instruction
stringclasses 1
value | input
stringlengths 31
235k
| output
class label 2
classes |
|---|---|---|
Categorize the following code snippet as vulnerable or not. True or False
|
static int before ( celt x , celt y ) {
if ( x < y ) return 1 ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline __u8 ip_reply_arg_flowi_flags ( const struct ip_reply_arg * arg ) {
return ( arg -> flags & IP_REPLY_ARG_NOSRCCHECK ) ? FLOWI_FLAG_ANYSRC : 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( ExtensionServiceSyncTest , GetSyncDataDisableReasons ) {
InitializeEmptyExtensionService ( ) ;
const Extension * extension = InstallCRX ( data_dir ( ) . AppendASCII ( "good.crx" ) , INSTALL_NEW ) ;
ASSERT_TRUE ( extension ) ;
extension_sync_service ( ) -> MergeDataAndStartSyncing ( syncer : : EXTENSIONS , syncer : : SyncDataList ( ) , base : : MakeUnique < syncer : : FakeSyncChangeProcessor > ( ) , base : : MakeUnique < syncer : : SyncErrorFactoryMock > ( ) ) ;
{
syncer : : SyncDataList list = extension_sync_service ( ) -> GetAllSyncData ( syncer : : EXTENSIONS ) ;
ASSERT_EQ ( list . size ( ) , 1U ) ;
std : : unique_ptr < ExtensionSyncData > data = ExtensionSyncData : : CreateFromSyncData ( list [ 0 ] ) ;
ASSERT_TRUE ( data . get ( ) ) ;
EXPECT_TRUE ( data -> enabled ( ) ) ;
EXPECT_TRUE ( data -> supports_disable_reasons ( ) ) ;
EXPECT_EQ ( extensions : : disable_reason : : DISABLE_NONE , data -> disable_reasons ( ) ) ;
}
service ( ) -> DisableExtension ( good_crx , extensions : : disable_reason : : DISABLE_USER_ACTION ) ;
{
syncer : : SyncDataList list = extension_sync_service ( ) -> GetAllSyncData ( syncer : : EXTENSIONS ) ;
ASSERT_EQ ( list . size ( ) , 1U ) ;
std : : unique_ptr < ExtensionSyncData > data = ExtensionSyncData : : CreateFromSyncData ( list [ 0 ] ) ;
ASSERT_TRUE ( data . get ( ) ) ;
EXPECT_FALSE ( data -> enabled ( ) ) ;
EXPECT_TRUE ( data -> supports_disable_reasons ( ) ) ;
EXPECT_EQ ( extensions : : disable_reason : : DISABLE_USER_ACTION , data -> disable_reasons ( ) ) ;
}
service ( ) -> EnableExtension ( good_crx ) ;
service ( ) -> DisableExtension ( good_crx , extensions : : disable_reason : : DISABLE_RELOAD ) ;
{
syncer : : SyncDataList list = extension_sync_service ( ) -> GetAllSyncData ( syncer : : EXTENSIONS ) ;
ASSERT_EQ ( list . size ( ) , 1U ) ;
std : : unique_ptr < ExtensionSyncData > data = ExtensionSyncData : : CreateFromSyncData ( list [ 0 ] ) ;
ASSERT_TRUE ( data . get ( ) ) ;
EXPECT_TRUE ( data -> enabled ( ) ) ;
EXPECT_TRUE ( data -> supports_disable_reasons ( ) ) ;
EXPECT_EQ ( extensions : : disable_reason : : DISABLE_NONE , data -> disable_reasons ( ) ) ;
}
service ( ) -> EnableExtension ( good_crx ) ;
service ( ) -> DisableExtension ( good_crx , extensions : : disable_reason : : DISABLE_USER_ACTION | extensions : : disable_reason : : DISABLE_RELOAD ) ;
{
syncer : : SyncDataList list = extension_sync_service ( ) -> GetAllSyncData ( syncer : : EXTENSIONS ) ;
ASSERT_EQ ( list . size ( ) , 1U ) ;
std : : unique_ptr < ExtensionSyncData > data = ExtensionSyncData : : CreateFromSyncData ( list [ 0 ] ) ;
ASSERT_TRUE ( data . get ( ) ) ;
EXPECT_FALSE ( data -> enabled ( ) ) ;
EXPECT_TRUE ( data -> supports_disable_reasons ( ) ) ;
EXPECT_EQ ( extensions : : disable_reason : : DISABLE_USER_ACTION , data -> disable_reasons ( ) ) ;
}
service ( ) -> EnableExtension ( good_crx ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_T_crcDesired ( 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_T_crcDesired , T_crcDesired_sequence ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
CharList * pkg_appendToList ( CharList * l , CharList * * end , const char * str ) {
CharList * endptr = NULL , * tmp ;
if ( end == NULL ) {
end = & endptr ;
}
if ( ( * end == NULL ) && ( l != NULL ) ) {
tmp = l ;
while ( tmp -> next ) {
tmp = tmp -> next ;
}
* end = tmp ;
}
if ( l == NULL ) {
l = pkg_prependToList ( NULL , str ) ;
}
else {
( * end ) -> next = pkg_prependToList ( NULL , str ) ;
}
if ( * end ) {
( * end ) = ( * end ) -> next ;
}
else {
* end = l ;
}
return l ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST ( ExtensionCSPValidator , IsSecure ) {
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( std : : string ( ) , OPTIONS_ALLOW_UNSAFE_EVAL ) , "script-src 'self';
object-src 'self';
" , MissingSecureSrcWarning ( "script-src" ) , MissingSecureSrcWarning ( "object-src" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "img-src https://google.com" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "img-src https://google.com;
script-src 'self';
object-src 'self';
" , MissingSecureSrcWarning ( "script-src" ) , MissingSecureSrcWarning ( "object-src" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "script-src a b" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "script-src;
object-src 'self';
" , InsecureValueWarning ( "script-src" , "a" ) , InsecureValueWarning ( "script-src" , "b" ) , MissingSecureSrcWarning ( "object-src" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src *" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src;
" , InsecureValueWarning ( "default-src" , "*" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self';
" , OPTIONS_ALLOW_UNSAFE_EVAL ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'none';
" , OPTIONS_ALLOW_UNSAFE_EVAL ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' ftp://google.com" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "ftp://google.com" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' https://google.com;
" , OPTIONS_ALLOW_UNSAFE_EVAL ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src *;
default-src 'self'" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src;
default-src 'self';
" , InsecureValueWarning ( "default-src" , "*" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self';
default-src *;
" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
default-src;
" ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self';
default-src *;
script-src *;
script-src 'self'" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
default-src;
script-src;
script-src 'self';
" , InsecureValueWarning ( "script-src" , "*" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self';
default-src *;
script-src 'self';
script-src *;
" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
default-src;
script-src 'self';
script-src;
" ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src *;
script-src 'self'" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src;
script-src 'self';
" , InsecureValueWarning ( "default-src" , "*" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src *;
script-src 'self';
img-src 'self'" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src;
script-src 'self';
img-src 'self';
" , InsecureValueWarning ( "default-src" , "*" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src *;
script-src 'self';
object-src 'self';
" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src;
script-src 'self';
object-src 'self';
" ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "script-src 'self';
object-src 'self';
" , OPTIONS_ALLOW_UNSAFE_EVAL ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'unsafe-eval';
" , OPTIONS_ALLOW_UNSAFE_EVAL ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'unsafe-eval'" , OPTIONS_NONE ) , "default-src;
" , InsecureValueWarning ( "default-src" , "'unsafe-eval'" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'unsafe-inline'" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src;
" , InsecureValueWarning ( "default-src" , "'unsafe-inline'" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'unsafe-inline' 'none'" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'none';
" , InsecureValueWarning ( "default-src" , "'unsafe-inline'" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' http://google.com" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "http://google.com" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' https://google.com;
" , OPTIONS_ALLOW_UNSAFE_EVAL ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' chrome://resources;
" , OPTIONS_ALLOW_UNSAFE_EVAL ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' chrome-extension://aabbcc;
" , OPTIONS_ALLOW_UNSAFE_EVAL ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' chrome-extension-resource://aabbcc;
" , OPTIONS_ALLOW_UNSAFE_EVAL ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' https:" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "https:" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' http:" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "http:" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' google.com" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "google.com" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' *" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "*" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' *:*" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "*:*" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' *:*/" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "*:*/" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' *:*/path" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "*:*/path" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' https://" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "https://" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' https://*:*" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "https://*:*" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' https://*:*/" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "https://*:*/" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' https://*:*/path" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "https://*:*/path" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' https://*.com" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "https://*.com" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' https://*.*.google.com/" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "https://*.*.google.com/" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' https://*.*.google.com:*/" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "https://*.*.google.com:*/" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' https://www.*.google.com/" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "https://www.*.google.com/" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' https://www.*.google.com:*/" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "https://www.*.google.com:*/" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' chrome://*" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "chrome://*" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' chrome-extension://*" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "chrome-extension://*" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' chrome-extension://" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "chrome-extension://" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' https://*.google.com;
" , OPTIONS_ALLOW_UNSAFE_EVAL ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' https://*.google.com:1;
" , OPTIONS_ALLOW_UNSAFE_EVAL ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' https://*.google.com:*;
" , OPTIONS_ALLOW_UNSAFE_EVAL ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' https://*.google.com:1/;
" , OPTIONS_ALLOW_UNSAFE_EVAL ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' https://*.google.com:*/;
" , OPTIONS_ALLOW_UNSAFE_EVAL ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' http://127.0.0.1;
" , OPTIONS_ALLOW_UNSAFE_EVAL ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' http://localhost;
" , OPTIONS_ALLOW_UNSAFE_EVAL ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' http://lOcAlHoSt;
" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self' http://lOcAlHoSt;
" ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' http://127.0.0.1:9999;
" , OPTIONS_ALLOW_UNSAFE_EVAL ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' http://localhost:8888;
" , OPTIONS_ALLOW_UNSAFE_EVAL ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' http://127.0.0.1.example.com" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "http://127.0.0.1.example.com" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' http://localhost.example.com" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "http://localhost.example.com" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' blob:;
" , OPTIONS_ALLOW_UNSAFE_EVAL ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' blob:http://example.com/XXX" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "blob:http://example.com/XXX" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' filesystem:;
" , OPTIONS_ALLOW_UNSAFE_EVAL ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' filesystem:http://example.com/XX" , OPTIONS_ALLOW_UNSAFE_EVAL ) , "default-src 'self';
" , InsecureValueWarning ( "default-src" , "filesystem:http://example.com/XX" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' https://*.googleapis.com;
" , OPTIONS_ALLOW_UNSAFE_EVAL ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src 'self' https://x.googleapis.com;
" , OPTIONS_ALLOW_UNSAFE_EVAL ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "script-src 'self';
object-src *" , OPTIONS_NONE ) , "script-src 'self';
object-src;
" , InsecureValueWarning ( "object-src" , "*" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "script-src 'self';
object-src *" , OPTIONS_ALLOW_INSECURE_OBJECT_SRC ) , "script-src 'self';
object-src;
" , InsecureValueWarning ( "object-src" , "*" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "script-src 'self';
object-src *;
plugin-types application/pdf;
" , OPTIONS_ALLOW_INSECURE_OBJECT_SRC ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "script-src 'self';
object-src *;
" "plugin-types application/x-shockwave-flash" , OPTIONS_ALLOW_INSECURE_OBJECT_SRC ) , "script-src 'self';
object-src;
" "plugin-types application/x-shockwave-flash;
" , InsecureValueWarning ( "object-src" , "*" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "script-src 'self';
object-src *;
" "plugin-types application/x-shockwave-flash application/pdf;
" , OPTIONS_ALLOW_INSECURE_OBJECT_SRC ) , "script-src 'self';
object-src;
" "plugin-types application/x-shockwave-flash application/pdf;
" , InsecureValueWarning ( "object-src" , "*" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "script-src 'self';
object-src http://www.example.com;
" "plugin-types application/pdf;
" , OPTIONS_ALLOW_INSECURE_OBJECT_SRC ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "object-src http://www.example.com blob:;
script-src 'self';
" "plugin-types application/pdf;
" , OPTIONS_ALLOW_INSECURE_OBJECT_SRC ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "script-src 'self';
object-src http://*.example.com;
" "plugin-types application/pdf;
" , OPTIONS_ALLOW_INSECURE_OBJECT_SRC ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "script-src *;
object-src *;
plugin-types application/pdf;
" , OPTIONS_ALLOW_INSECURE_OBJECT_SRC ) , "script-src;
object-src *;
plugin-types application/pdf;
" , InsecureValueWarning ( "script-src" , "*" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src;
script-src" " 'sha256-hndjYvzUzy2Ykuad81Cwsl1FOXX/qYs/aDVyUyNZwBw='" " 'sha384-bSVm1i3sjPBRM4TwZtYTDjk9JxZMExYHWbFmP1SxDhJH4ue0Wu9OPOkY5hcqRcS" "t'" " 'sha512-440MmBLtj9Kp5Bqloogn9BqGDylY8vFsv5/zXL1zH2fJVssCoskRig4gyM+9Kqw" "vCSapSz5CVoUGHQcxv43UQg==';
" , OPTIONS_NONE ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src;
script-src 'sha1-eYyYGmKWdhpUewohaXk9o8IaLSw=';
" , OPTIONS_NONE ) , "default-src;
script-src;
" , InsecureValueWarning ( "script-src" , "'sha1-eYyYGmKWdhpUewohaXk9o8IaLSw='" ) ) ) ;
EXPECT_TRUE ( CheckCSP ( SanitizeCSP ( "default-src;
script-src 'sha256-hndjYvzUzy2Ykuad81Cwsl1FOXX/qYs/aDVyUyNZ" "wBw= sha256-qznLcsROx4GACP2dm0UCKCzCG+HiZ1guq6ZZDob/Tng=';
" , OPTIONS_NONE ) , "default-src;
script-src;
" , InsecureValueWarning ( "script-src" , "'sha256-hndjYvzUzy2Ykuad81Cwsl1FOXX/qYs/aDVyUyNZwBw=" ) , InsecureValueWarning ( "script-src" , "sha256-qznLcsROx4GACP2dm0UCKCzCG+HiZ1guq6ZZDob/Tng='" ) ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void ff_h263_encode_mba ( MpegEncContext * s ) {
int i , mb_pos ;
for ( i = 0 ;
i < 6 ;
i ++ ) {
if ( s -> mb_num - 1 <= ff_mba_max [ i ] ) break ;
}
mb_pos = s -> mb_x + s -> mb_width * s -> mb_y ;
put_bits ( & s -> pb , ff_mba_length [ i ] , mb_pos ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void init_uncompress ( compress_filter_context_t * zfx , z_stream * zs ) {
int rc ;
if ( ( rc = zfx -> algo == 1 ? inflateInit2 ( zs , - 15 ) : inflateInit ( zs ) ) != Z_OK ) {
log_fatal ( "zlib problem: %s\n" , zs -> msg ? zs -> msg : rc == Z_MEM_ERROR ? "out of core" : rc == Z_VERSION_ERROR ? "invalid lib version" : "unknown error" ) ;
}
zfx -> inbufsize = 2048 ;
zfx -> inbuf = xmalloc ( zfx -> inbufsize ) ;
zs -> avail_in = 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void e1000e_msix_notify ( E1000ECore * core , uint32_t causes ) {
if ( causes & E1000_ICR_RXQ0 ) {
e1000e_msix_notify_one ( core , E1000_ICR_RXQ0 , E1000_IVAR_RXQ0 ( core -> mac [ IVAR ] ) ) ;
}
if ( causes & E1000_ICR_RXQ1 ) {
e1000e_msix_notify_one ( core , E1000_ICR_RXQ1 , E1000_IVAR_RXQ1 ( core -> mac [ IVAR ] ) ) ;
}
if ( causes & E1000_ICR_TXQ0 ) {
e1000e_msix_notify_one ( core , E1000_ICR_TXQ0 , E1000_IVAR_TXQ0 ( core -> mac [ IVAR ] ) ) ;
}
if ( causes & E1000_ICR_TXQ1 ) {
e1000e_msix_notify_one ( core , E1000_ICR_TXQ1 , E1000_IVAR_TXQ1 ( core -> mac [ IVAR ] ) ) ;
}
if ( causes & E1000_ICR_OTHER ) {
e1000e_msix_notify_one ( core , E1000_ICR_OTHER , E1000_IVAR_OTHER ( core -> mac [ IVAR ] ) ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_INTEGER_27_78 ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_constrained_integer ( tvb , offset , actx , tree , hf_index , 27U , 78U , NULL , FALSE ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( WebUsbDetectorTest , ThreeUsbDevicesWereThereBeforeAndThenRemovedAfterWebUsbDetectorWasCreated ) {
base : : string16 product_name_1 = base : : UTF8ToUTF16 ( kProductName_1 ) ;
GURL landing_page_1 ( kLandingPage_1 ) ;
scoped_refptr < device : : MockUsbDevice > device_1 ( new device : : MockUsbDevice ( 0 , 1 , "Google" , kProductName_1 , "002" , landing_page_1 ) ) ;
std : : string guid_1 = device_1 -> guid ( ) ;
base : : string16 product_name_2 = base : : UTF8ToUTF16 ( kProductName_2 ) ;
GURL landing_page_2 ( kLandingPage_2 ) ;
scoped_refptr < device : : MockUsbDevice > device_2 ( new device : : MockUsbDevice ( 3 , 4 , "Google" , kProductName_2 , "005" , landing_page_2 ) ) ;
std : : string guid_2 = device_2 -> guid ( ) ;
base : : string16 product_name_3 = base : : UTF8ToUTF16 ( kProductName_3 ) ;
GURL landing_page_3 ( kLandingPage_3 ) ;
scoped_refptr < device : : MockUsbDevice > device_3 ( new device : : MockUsbDevice ( 6 , 7 , "Google" , kProductName_3 , "008" , landing_page_3 ) ) ;
std : : string guid_3 = device_3 -> guid ( ) ;
device_client_ . usb_service ( ) -> AddDevice ( device_1 ) ;
EXPECT_TRUE ( message_center_ -> FindVisibleNotificationById ( guid_1 ) == nullptr ) ;
device_client_ . usb_service ( ) -> AddDevice ( device_2 ) ;
EXPECT_TRUE ( message_center_ -> FindVisibleNotificationById ( guid_2 ) == nullptr ) ;
device_client_ . usb_service ( ) -> AddDevice ( device_3 ) ;
EXPECT_TRUE ( message_center_ -> FindVisibleNotificationById ( guid_3 ) == nullptr ) ;
Initialize ( ) ;
device_client_ . usb_service ( ) -> RemoveDevice ( device_1 ) ;
EXPECT_TRUE ( message_center_ -> FindVisibleNotificationById ( guid_1 ) == nullptr ) ;
device_client_ . usb_service ( ) -> RemoveDevice ( device_2 ) ;
EXPECT_TRUE ( message_center_ -> FindVisibleNotificationById ( guid_2 ) == nullptr ) ;
device_client_ . usb_service ( ) -> RemoveDevice ( device_3 ) ;
EXPECT_TRUE ( message_center_ -> FindVisibleNotificationById ( guid_3 ) == nullptr ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static const char * cmd_audit_engine ( cmd_parms * cmd , void * _dcfg , const char * p1 ) {
directory_config * dcfg = _dcfg ;
if ( strcasecmp ( p1 , "On" ) == 0 ) dcfg -> auditlog_flag = AUDITLOG_ON ;
else if ( strcasecmp ( p1 , "Off" ) == 0 ) dcfg -> auditlog_flag = AUDITLOG_OFF ;
else if ( strcasecmp ( p1 , "RelevantOnly" ) == 0 ) dcfg -> auditlog_flag = AUDITLOG_RELEVANT ;
else return ( const char * ) apr_psprintf ( cmd -> pool , "ModSecurity: Unrecognised parameter value for SecAuditEngine: %s" , p1 ) ;
return NULL ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int pxa2xx_clkcfg_read ( CPUARMState * env , const ARMCPRegInfo * ri , uint64_t * value ) {
PXA2xxState * s = ( PXA2xxState * ) ri -> opaque ;
* value = s -> clkcfg ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int my_kill ( int pid , int sig ) {
# ifdef __WIN__ HANDLE proc ;
if ( ( proc = OpenProcess ( SYNCHRONIZE | PROCESS_TERMINATE , FALSE , pid ) ) == NULL ) return - 1 ;
if ( sig == 0 ) {
DWORD wait_result = WaitForSingleObject ( proc , 0 ) ;
CloseHandle ( proc ) ;
return wait_result == WAIT_OBJECT_0 ? - 1 : 0 ;
}
( void ) TerminateProcess ( proc , 201 ) ;
CloseHandle ( proc ) ;
return 1 ;
# else return kill ( pid , sig ) ;
# endif }
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int vp9_get_frame_buffer ( void * cb_priv , size_t min_size , vpx_codec_frame_buffer_t * fb ) {
int i ;
InternalFrameBufferList * const int_fb_list = ( InternalFrameBufferList * ) cb_priv ;
if ( int_fb_list == NULL ) return - 1 ;
for ( i = 0 ;
i < int_fb_list -> num_internal_frame_buffers ;
++ i ) {
if ( ! int_fb_list -> int_fb [ i ] . in_use ) break ;
}
if ( i == int_fb_list -> num_internal_frame_buffers ) return - 1 ;
if ( int_fb_list -> int_fb [ i ] . size < min_size ) {
int_fb_list -> int_fb [ i ] . data = ( uint8_t * ) vpx_realloc ( int_fb_list -> int_fb [ i ] . data , min_size ) ;
if ( ! int_fb_list -> int_fb [ i ] . data ) return - 1 ;
vpx_memset ( int_fb_list -> int_fb [ i ] . data , 0 , min_size ) ;
int_fb_list -> int_fb [ i ] . size = min_size ;
}
fb -> data = int_fb_list -> int_fb [ i ] . data ;
fb -> size = int_fb_list -> int_fb [ i ] . size ;
int_fb_list -> int_fb [ i ] . in_use = 1 ;
fb -> priv = & int_fb_list -> int_fb [ i ] ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void pdf_tos_restore ( fz_context * ctx , pdf_text_object_state * tos , fz_matrix save [ 2 ] ) {
tos -> tm = save [ 0 ] ;
tos -> tlm = save [ 1 ] ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int get_zbin_mode_boost ( const MB_MODE_INFO * mbmi , int enabled ) {
if ( enabled ) {
if ( is_inter_block ( mbmi ) ) {
if ( mbmi -> mode == ZEROMV ) {
return mbmi -> ref_frame [ 0 ] != LAST_FRAME ? GF_ZEROMV_ZBIN_BOOST : LF_ZEROMV_ZBIN_BOOST ;
}
else {
return mbmi -> sb_type < BLOCK_8X8 ? SPLIT_MV_ZBIN_BOOST : MV_ZBIN_BOOST ;
}
}
else {
return INTRA_ZBIN_BOOST ;
}
}
else {
return 0 ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
VALUE ossl_cipher_new ( const EVP_CIPHER * cipher ) {
VALUE ret ;
EVP_CIPHER_CTX * ctx ;
ret = ossl_cipher_alloc ( cCipher ) ;
AllocCipher ( ret , ctx ) ;
if ( EVP_CipherInit_ex ( ctx , cipher , NULL , NULL , NULL , - 1 ) != 1 ) ossl_raise ( eCipherError , NULL ) ;
return ret ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static PyObject * string_partition ( PyStringObject * self , PyObject * sep_obj ) {
const char * sep ;
Py_ssize_t sep_len ;
if ( PyString_Check ( sep_obj ) ) {
sep = PyString_AS_STRING ( sep_obj ) ;
sep_len = PyString_GET_SIZE ( sep_obj ) ;
}
# ifdef Py_USING_UNICODE else if ( PyUnicode_Check ( sep_obj ) ) return PyUnicode_Partition ( ( PyObject * ) self , sep_obj ) ;
# endif else if ( PyObject_AsCharBuffer ( sep_obj , & sep , & sep_len ) ) return NULL ;
return stringlib_partition ( ( PyObject * ) self , PyString_AS_STRING ( self ) , PyString_GET_SIZE ( self ) , sep_obj , sep , sep_len ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void istr_set_insert ( GHashTable * table , const char * istr ) {
char * key ;
key = g_strdup ( istr ) ;
g_hash_table_replace ( table , key , key ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int SpoolssGetJob_r ( tvbuff_t * tvb , int offset , packet_info * pinfo , proto_tree * tree , dcerpc_info * di , guint8 * drep ) {
dcerpc_call_value * dcv = ( dcerpc_call_value * ) di -> call_data ;
gint32 level = GPOINTER_TO_UINT ( dcv -> se_data ) ;
BUFFER buffer ;
offset = dissect_spoolss_buffer ( tvb , offset , pinfo , tree , di , drep , & buffer ) ;
if ( buffer . tvb ) {
int buffer_offset = 0 ;
switch ( level ) {
case 1 : dissect_spoolss_JOB_INFO_1 ( buffer . tvb , buffer_offset , pinfo , buffer . tree , di , drep ) ;
break ;
case 2 : default : proto_tree_add_expert_format ( buffer . tree , pinfo , & ei_job_info_level , buffer . tvb , buffer_offset , - 1 , "Unknown job info level %d" , level ) ;
break ;
}
}
offset = dissect_ndr_uint32 ( tvb , offset , pinfo , tree , di , drep , hf_needed , NULL ) ;
offset = dissect_doserror ( tvb , offset , pinfo , tree , di , drep , hf_rc , NULL ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static UBool action_mirror ( UBiDiTransform * pTransform , UErrorCode * pErrorCode ) {
UChar32 c ;
uint32_t i = 0 , j = 0 ;
if ( 0 == ( pTransform -> reorderingOptions & UBIDI_DO_MIRRORING ) ) {
return FALSE ;
}
if ( pTransform -> destSize < pTransform -> srcLength ) {
* pErrorCode = U_BUFFER_OVERFLOW_ERROR ;
return FALSE ;
}
do {
UBool isOdd = ubidi_getLevelAt ( pTransform -> pBidi , i ) & 1 ;
U16_NEXT ( pTransform -> src , i , pTransform -> srcLength , c ) ;
U16_APPEND_UNSAFE ( pTransform -> dest , j , isOdd ? u_charMirror ( c ) : c ) ;
}
while ( i < pTransform -> srcLength ) ;
* pTransform -> pDestLength = pTransform -> srcLength ;
pTransform -> reorderingOptions = UBIDI_REORDER_DEFAULT ;
return TRUE ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static gint dissect_ac_if_hdr_body ( tvbuff_t * tvb , gint offset , packet_info * pinfo _U_ , proto_tree * tree , usb_conv_info_t * usb_conv_info ) {
gint offset_start ;
guint16 bcdADC ;
guint8 ver_major ;
double ver ;
guint8 if_in_collection , i ;
audio_conv_info_t * audio_conv_info ;
offset_start = offset ;
bcdADC = tvb_get_letohs ( tvb , offset ) ;
ver_major = USB_AUDIO_BCD44_TO_DEC ( bcdADC >> 8 ) ;
ver = ver_major + USB_AUDIO_BCD44_TO_DEC ( bcdADC & 0xFF ) / 100.0 ;
proto_tree_add_double_format_value ( tree , hf_ac_if_hdr_ver , tvb , offset , 2 , ver , "%2.2f" , ver ) ;
audio_conv_info = ( audio_conv_info_t * ) usb_conv_info -> class_data ;
if ( ! audio_conv_info ) {
audio_conv_info = wmem_new ( wmem_file_scope ( ) , audio_conv_info_t ) ;
usb_conv_info -> class_data = audio_conv_info ;
usb_conv_info -> class_data_type = USB_CONV_AUDIO ;
}
else if ( usb_conv_info -> class_data_type != USB_CONV_AUDIO ) {
return 0 ;
}
audio_conv_info -> ver_major = ver_major ;
offset += 2 ;
if ( ver_major == 1 ) {
proto_tree_add_item ( tree , hf_ac_if_hdr_total_len , tvb , offset , 2 , ENC_LITTLE_ENDIAN ) ;
offset += 2 ;
if_in_collection = tvb_get_guint8 ( tvb , offset ) ;
proto_tree_add_item ( tree , hf_ac_if_hdr_bInCollection , tvb , offset , 1 , ENC_LITTLE_ENDIAN ) ;
offset ++ ;
for ( i = 0 ;
i < if_in_collection ;
i ++ ) {
proto_tree_add_item ( tree , hf_ac_if_hdr_if_num , tvb , offset , 1 , ENC_LITTLE_ENDIAN ) ;
offset ++ ;
}
}
return offset - offset_start ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_P ( GLES2DecoderTestWithBlendEquationAdvanced , BlendBarrierKHRValidArgs ) {
EXPECT_CALL ( * gl_ , BlendBarrierKHR ( ) ) ;
SpecializedSetup < cmds : : BlendBarrierKHR , 0 > ( true ) ;
cmds : : BlendBarrierKHR cmd ;
cmd . Init ( ) ;
EXPECT_EQ ( error : : kNoError , ExecuteCmd ( cmd ) ) ;
EXPECT_EQ ( GL_NO_ERROR , GetGLError ( ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void InitializeSchemeWhitelist ( SchemeSet * whitelist , const SchemeSet & client_schemes_to_whitelist ) {
DCHECK ( whitelist ) ;
if ( ! whitelist -> empty ( ) ) return ;
whitelist -> insert ( client_schemes_to_whitelist . begin ( ) , client_schemes_to_whitelist . end ( ) ) ;
whitelist -> insert ( std : : string ( url : : kAboutScheme ) ) ;
whitelist -> insert ( std : : string ( url : : kFileScheme ) ) ;
whitelist -> insert ( std : : string ( url : : kFtpScheme ) ) ;
whitelist -> insert ( std : : string ( url : : kHttpScheme ) ) ;
whitelist -> insert ( std : : string ( url : : kHttpsScheme ) ) ;
whitelist -> insert ( std : : string ( url : : kMailToScheme ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void auth_server_connection_disconnect ( struct auth_server_connection * conn , const char * reason ) {
if ( ! conn -> connected ) return ;
conn -> connected = FALSE ;
conn -> handshake_received = FALSE ;
conn -> version_received = FALSE ;
conn -> has_plain_mech = FALSE ;
conn -> server_pid = 0 ;
conn -> connect_uid = 0 ;
conn -> cookie = NULL ;
array_clear ( & conn -> available_auth_mechs ) ;
timeout_remove ( & conn -> to ) ;
io_remove ( & conn -> io ) ;
if ( conn -> fd != - 1 ) {
i_stream_destroy ( & conn -> input ) ;
o_stream_destroy ( & conn -> output ) ;
if ( close ( conn -> fd ) < 0 ) i_error ( "close(auth server connection) failed: %m" ) ;
conn -> fd = - 1 ;
}
auth_server_connection_remove_requests ( conn , reason ) ;
if ( conn -> client -> connect_notify_callback != NULL ) {
conn -> client -> connect_notify_callback ( conn -> client , FALSE , conn -> client -> connect_notify_context ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
MSG_PROCESS_RETURN tls_process_client_key_exchange ( SSL * s , PACKET * pkt ) {
int al = - 1 ;
unsigned long alg_k ;
alg_k = s -> s3 -> tmp . new_cipher -> algorithm_mkey ;
if ( ( alg_k & SSL_PSK ) && ! tls_process_cke_psk_preamble ( s , pkt , & al ) ) goto err ;
if ( alg_k & SSL_kPSK ) {
if ( PACKET_remaining ( pkt ) != 0 ) {
al = SSL_AD_HANDSHAKE_FAILURE ;
SSLerr ( SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE , SSL_R_LENGTH_MISMATCH ) ;
goto err ;
}
if ( ! ssl_generate_master_secret ( s , NULL , 0 , 0 ) ) {
al = SSL_AD_INTERNAL_ERROR ;
SSLerr ( SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE , ERR_R_INTERNAL_ERROR ) ;
goto err ;
}
}
else if ( alg_k & ( SSL_kRSA | SSL_kRSAPSK ) ) {
if ( ! tls_process_cke_rsa ( s , pkt , & al ) ) goto err ;
}
else if ( alg_k & ( SSL_kDHE | SSL_kDHEPSK ) ) {
if ( ! tls_process_cke_dhe ( s , pkt , & al ) ) goto err ;
}
else if ( alg_k & ( SSL_kECDHE | SSL_kECDHEPSK ) ) {
if ( ! tls_process_cke_ecdhe ( s , pkt , & al ) ) goto err ;
}
else if ( alg_k & SSL_kSRP ) {
if ( ! tls_process_cke_srp ( s , pkt , & al ) ) goto err ;
}
else if ( alg_k & SSL_kGOST ) {
if ( ! tls_process_cke_gost ( s , pkt , & al ) ) goto err ;
}
else {
al = SSL_AD_HANDSHAKE_FAILURE ;
SSLerr ( SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE , SSL_R_UNKNOWN_CIPHER_TYPE ) ;
goto err ;
}
return MSG_PROCESS_CONTINUE_PROCESSING ;
err : if ( al != - 1 ) ssl3_send_alert ( s , SSL3_AL_FATAL , al ) ;
# ifndef OPENSSL_NO_PSK OPENSSL_clear_free ( s -> s3 -> tmp . psk , s -> s3 -> tmp . psklen ) ;
s -> s3 -> tmp . psk = NULL ;
# endif ossl_statem_set_error ( s ) ;
return MSG_PROCESS_ERROR ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int su_main ( int argc , char * * argv , int mode ) {
int optc ;
const char * new_user = DEFAULT_USER , * runuser_user = NULL ;
char * command = NULL ;
int request_same_session = 0 ;
char * shell = NULL ;
struct passwd * pw ;
struct passwd pw_copy ;
gid_t * groups = NULL ;
size_t ngroups = 0 ;
bool use_supp = false ;
bool use_gid = false ;
gid_t gid = 0 ;
static const struct option longopts [ ] = {
{
"command" , required_argument , NULL , 'c' }
, {
"session-command" , required_argument , NULL , 'C' }
, {
"fast" , no_argument , NULL , 'f' }
, {
"login" , no_argument , NULL , 'l' }
, {
"preserve-environment" , no_argument , NULL , 'p' }
, {
"shell" , required_argument , NULL , 's' }
, {
"group" , required_argument , NULL , 'g' }
, {
"supp-group" , required_argument , NULL , 'G' }
, {
"user" , required_argument , NULL , 'u' }
, {
"help" , no_argument , 0 , 'h' }
, {
"version" , no_argument , 0 , 'V' }
, {
NULL , 0 , NULL , 0 }
}
;
setlocale ( LC_ALL , "" ) ;
bindtextdomain ( PACKAGE , LOCALEDIR ) ;
textdomain ( PACKAGE ) ;
atexit ( close_stdout ) ;
su_mode = mode ;
fast_startup = false ;
simulate_login = false ;
change_environment = true ;
while ( ( optc = getopt_long ( argc , argv , "c:fg:G:lmps:u:hV" , longopts , NULL ) ) != - 1 ) {
switch ( optc ) {
case 'c' : command = optarg ;
break ;
case 'C' : command = optarg ;
request_same_session = 1 ;
break ;
case 'f' : fast_startup = true ;
break ;
case 'g' : use_gid = true ;
gid = add_supp_group ( optarg , & groups , & ngroups ) ;
break ;
case 'G' : use_supp = true ;
add_supp_group ( optarg , & groups , & ngroups ) ;
break ;
case 'l' : simulate_login = true ;
break ;
case 'm' : case 'p' : change_environment = false ;
break ;
case 's' : shell = optarg ;
break ;
case 'u' : if ( su_mode != RUNUSER_MODE ) usage ( EXIT_FAILURE ) ;
runuser_user = optarg ;
break ;
case 'h' : usage ( 0 ) ;
case 'V' : printf ( UTIL_LINUX_VERSION ) ;
exit ( EXIT_SUCCESS ) ;
default : errtryhelp ( EXIT_FAILURE ) ;
}
}
restricted = evaluate_uid ( ) ;
if ( optind < argc && ! strcmp ( argv [ optind ] , "-" ) ) {
simulate_login = true ;
++ optind ;
}
if ( simulate_login && ! change_environment ) {
warnx ( _ ( "ignoring --preserve-environment, it's mutually exclusive with --login" ) ) ;
change_environment = true ;
}
switch ( su_mode ) {
case RUNUSER_MODE : if ( runuser_user ) {
new_user = runuser_user ;
if ( shell || fast_startup || command || simulate_login ) {
errx ( EXIT_FAILURE , _ ( "options --{
shell,fast,command,session-command,login}
and " "--user are mutually exclusive" ) ) ;
}
if ( optind == argc ) errx ( EXIT_FAILURE , _ ( "no command was specified" ) ) ;
break ;
}
case SU_MODE : if ( optind < argc ) new_user = argv [ optind ++ ] ;
break ;
}
if ( ( use_supp || use_gid ) && restricted ) errx ( EXIT_FAILURE , _ ( "only root can specify alternative groups" ) ) ;
logindefs_load_defaults = load_config ;
pw = getpwnam ( new_user ) ;
if ( ! ( pw && pw -> pw_name && pw -> pw_name [ 0 ] && pw -> pw_dir && pw -> pw_dir [ 0 ] && pw -> pw_passwd ) ) errx ( EXIT_FAILURE , _ ( "user %s does not exist" ) , new_user ) ;
pw_copy = * pw ;
pw = & pw_copy ;
pw -> pw_name = xstrdup ( pw -> pw_name ) ;
pw -> pw_passwd = xstrdup ( pw -> pw_passwd ) ;
pw -> pw_dir = xstrdup ( pw -> pw_dir ) ;
pw -> pw_shell = xstrdup ( pw -> pw_shell && pw -> pw_shell [ 0 ] ? pw -> pw_shell : DEFAULT_SHELL ) ;
endpwent ( ) ;
if ( use_supp && ! use_gid ) pw -> pw_gid = groups [ 0 ] ;
else if ( use_gid ) pw -> pw_gid = gid ;
authenticate ( pw ) ;
if ( request_same_session || ! command || ! pw -> pw_uid ) same_session = 1 ;
if ( runuser_user ) {
shell = NULL ;
}
else {
if ( ! shell && ! change_environment ) shell = getenv ( "SHELL" ) ;
if ( shell && getuid ( ) != 0 && restricted_shell ( pw -> pw_shell ) ) {
warnx ( _ ( "using restricted shell %s" ) , pw -> pw_shell ) ;
shell = NULL ;
}
shell = xstrdup ( shell ? shell : pw -> pw_shell ) ;
}
init_groups ( pw , groups , ngroups ) ;
if ( ! simulate_login || command ) suppress_pam_info = 1 ;
create_watching_parent ( ) ;
change_identity ( pw ) ;
if ( ! same_session ) setsid ( ) ;
modify_environment ( pw , shell ) ;
if ( simulate_login && chdir ( pw -> pw_dir ) != 0 ) warn ( _ ( "warning: cannot change directory to %s" ) , pw -> pw_dir ) ;
if ( shell ) run_shell ( shell , command , argv + optind , max ( 0 , argc - optind ) ) ;
else {
execvp ( argv [ optind ] , & argv [ optind ] ) ;
err ( EXIT_FAILURE , _ ( "failed to execute %s" ) , argv [ optind ] ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static gcry_err_code_t pkcs1_encode_for_signature ( gcry_mpi_t * r_result , unsigned int nbits , const unsigned char * value , size_t valuelen , int algo ) {
gcry_err_code_t rc = 0 ;
gcry_error_t err ;
byte asn [ 100 ] ;
byte * frame = NULL ;
size_t nframe = ( nbits + 7 ) / 8 ;
int i ;
size_t n ;
size_t asnlen , dlen ;
asnlen = DIM ( asn ) ;
dlen = gcry_md_get_algo_dlen ( algo ) ;
if ( gcry_md_algo_info ( algo , GCRYCTL_GET_ASNOID , asn , & asnlen ) ) {
return GPG_ERR_NOT_IMPLEMENTED ;
}
if ( valuelen != dlen ) {
return GPG_ERR_CONFLICT ;
}
if ( ! dlen || dlen + asnlen + 4 > nframe ) {
return GPG_ERR_TOO_SHORT ;
}
if ( ! ( frame = gcry_malloc ( nframe ) ) ) return gpg_err_code_from_syserror ( ) ;
n = 0 ;
frame [ n ++ ] = 0 ;
frame [ n ++ ] = 1 ;
i = nframe - valuelen - asnlen - 3 ;
gcry_assert ( i > 1 ) ;
memset ( frame + n , 0xff , i ) ;
n += i ;
frame [ n ++ ] = 0 ;
memcpy ( frame + n , asn , asnlen ) ;
n += asnlen ;
memcpy ( frame + n , value , valuelen ) ;
n += valuelen ;
gcry_assert ( n == nframe ) ;
err = gcry_mpi_scan ( r_result , GCRYMPI_FMT_USG , frame , n , & nframe ) ;
if ( err ) rc = gcry_err_code ( err ) ;
else if ( DBG_CIPHER ) log_mpidump ( "PKCS#1 block type 1 encoded data" , * r_result ) ;
gcry_free ( frame ) ;
return rc ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int parse_CCategorizationSpec ( tvbuff_t * tvb , int offset , proto_tree * parent_tree , proto_tree * pad_tree , const char * fmt , ... ) {
proto_item * item ;
proto_tree * tree ;
const char * txt ;
va_list ap ;
va_start ( ap , fmt ) ;
txt = wmem_strdup_vprintf ( wmem_packet_scope ( ) , fmt , ap ) ;
va_end ( ap ) ;
tree = proto_tree_add_subtree ( parent_tree , tvb , offset , 0 , ett_CCategorizationSpec , & item , txt ) ;
offset = parse_CColumnSet ( tvb , offset , tree , "csColumns" ) ;
offset = parse_CCategSpec ( tvb , offset , tree , pad_tree , "Spec" ) ;
offset = parse_CAggregSet ( tvb , offset , tree , pad_tree , "AggregSet" ) ;
offset = parse_CSortAggregSet ( tvb , offset , tree , pad_tree , "SortAggregSet" ) ;
offset = parse_CInGroupSortAggregSets ( tvb , offset , tree , pad_tree , "InGroupSortAggregSets" ) ;
proto_tree_add_item ( tree , hf_mswsp_categorizationspec_cmaxres , tvb , offset , 4 , ENC_LITTLE_ENDIAN ) ;
offset += 4 ;
proto_item_set_end ( item , tvb , offset ) ;
return offset ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int selinux_shm_alloc_security ( struct shmid_kernel * shp ) {
struct ipc_security_struct * isec ;
struct common_audit_data ad ;
u32 sid = current_sid ( ) ;
int rc ;
rc = ipc_alloc_security ( current , & shp -> shm_perm , SECCLASS_SHM ) ;
if ( rc ) return rc ;
isec = shp -> shm_perm . security ;
ad . type = LSM_AUDIT_DATA_IPC ;
ad . u . ipc_id = shp -> shm_perm . key ;
rc = avc_has_perm ( sid , isec -> sid , SECCLASS_SHM , SHM__CREATE , & ad ) ;
if ( rc ) {
ipc_free_security ( & shp -> shm_perm ) ;
return rc ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_T_responseCode ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_choice ( tvb , offset , actx , tree , hf_index , ett_h245_T_responseCode , T_responseCode_choice , NULL ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static __inline__ unsigned int tipc_zone ( __u32 addr ) {
return addr >> TIPC_ZONE_OFFSET ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void CommuteRowCompareExpr ( RowCompareExpr * clause ) {
List * newops ;
List * temp ;
ListCell * l ;
if ( ! IsA ( clause , RowCompareExpr ) ) elog ( ERROR , "expected a RowCompareExpr" ) ;
newops = NIL ;
foreach ( l , clause -> opnos ) {
Oid opoid = lfirst_oid ( l ) ;
opoid = get_commutator ( opoid ) ;
if ( ! OidIsValid ( opoid ) ) elog ( ERROR , "could not find commutator for operator %u" , lfirst_oid ( l ) ) ;
newops = lappend_oid ( newops , opoid ) ;
}
switch ( clause -> rctype ) {
case ROWCOMPARE_LT : clause -> rctype = ROWCOMPARE_GT ;
break ;
case ROWCOMPARE_LE : clause -> rctype = ROWCOMPARE_GE ;
break ;
case ROWCOMPARE_GE : clause -> rctype = ROWCOMPARE_LE ;
break ;
case ROWCOMPARE_GT : clause -> rctype = ROWCOMPARE_LT ;
break ;
default : elog ( ERROR , "unexpected RowCompare type: %d" , ( int ) clause -> rctype ) ;
break ;
}
clause -> opnos = newops ;
temp = clause -> largs ;
clause -> largs = clause -> rargs ;
clause -> rargs = temp ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static bool contain_mutable_functions_walker ( Node * node , void * context ) {
if ( node == NULL ) return false ;
if ( check_functions_in_node ( node , contain_mutable_functions_checker , context ) ) return true ;
if ( IsA ( node , Query ) ) {
return query_tree_walker ( ( Query * ) node , contain_mutable_functions_walker , context , 0 ) ;
}
return expression_tree_walker ( node , contain_mutable_functions_walker , context ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
apr_port_t mgs_hook_default_port ( const request_rec * r ) {
mgs_srvconf_rec * sc ;
if ( r == NULL ) return 0 ;
sc = ( mgs_srvconf_rec * ) ap_get_module_config ( r -> server -> module_config , & gnutls_module ) ;
_gnutls_log ( debug_log_fp , "%s: %d\n" , __func__ , __LINE__ ) ;
if ( sc -> enabled == GNUTLS_ENABLED_FALSE ) {
return 0 ;
}
return 443 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void test_view ( ) {
MYSQL_STMT * stmt ;
int rc , i ;
MYSQL_BIND my_bind [ 1 ] ;
char str_data [ 50 ] ;
ulong length = 0L ;
long is_null = 0L ;
const char * query = "SELECT COUNT(*) FROM v1 WHERE SERVERNAME=?" ;
myheader ( "test_view" ) ;
rc = mysql_query ( mysql , "DROP TABLE IF EXISTS t1,t2,t3,v1" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "DROP VIEW IF EXISTS v1,t1,t2,t3" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "CREATE TABLE t1 (" " SERVERGRP varchar(20) NOT NULL default '', " " DBINSTANCE varchar(20) NOT NULL default '', " " PRIMARY KEY (SERVERGRP)) " " CHARSET=latin1 collate=latin1_bin" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "CREATE TABLE t2 (" " SERVERNAME varchar(20) NOT NULL, " " SERVERGRP varchar(20) NOT NULL, " " PRIMARY KEY (SERVERNAME)) " " CHARSET=latin1 COLLATE latin1_bin" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "CREATE TABLE t3 (" " SERVERGRP varchar(20) BINARY NOT NULL, " " TABNAME varchar(30) NOT NULL, MAPSTATE char(1) NOT NULL, " " ACTSTATE char(1) NOT NULL , " " LOCAL_NAME varchar(30) NOT NULL, " " CHG_DATE varchar(8) NOT NULL default '00000000', " " CHG_TIME varchar(6) NOT NULL default '000000', " " MXUSER varchar(12) NOT NULL default '', " " PRIMARY KEY (SERVERGRP, TABNAME, MAPSTATE, ACTSTATE, " " LOCAL_NAME)) CHARSET=latin1 COLLATE latin1_bin" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "CREATE VIEW v1 AS select sql_no_cache" " T0001.SERVERNAME AS SERVERNAME, T0003.TABNAME AS" " TABNAME,T0003.LOCAL_NAME AS LOCAL_NAME,T0002.DBINSTANCE AS" " DBINSTANCE from t2 T0001 join t1 T0002 join t3 T0003 where" " ((T0002.SERVERGRP = T0001.SERVERGRP) and" " (T0002.SERVERGRP = T0003.SERVERGRP)" " and (T0003.MAPSTATE = _latin1'A') and" " (T0003.ACTSTATE = _latin1' '))" ) ;
myquery ( rc ) ;
stmt = mysql_stmt_init ( mysql ) ;
rc = mysql_stmt_prepare ( stmt , query , strlen ( query ) ) ;
check_execute ( stmt , rc ) ;
strmov ( str_data , "TEST" ) ;
memset ( my_bind , 0 , sizeof ( my_bind ) ) ;
my_bind [ 0 ] . buffer_type = MYSQL_TYPE_STRING ;
my_bind [ 0 ] . buffer = ( char * ) & str_data ;
my_bind [ 0 ] . buffer_length = 50 ;
my_bind [ 0 ] . length = & length ;
length = 4 ;
my_bind [ 0 ] . is_null = ( char * ) & is_null ;
rc = mysql_stmt_bind_param ( stmt , my_bind ) ;
check_execute ( stmt , rc ) ;
for ( i = 0 ;
i < 3 ;
i ++ ) {
rc = mysql_stmt_execute ( stmt ) ;
check_execute ( stmt , rc ) ;
rc = my_process_stmt_result ( stmt ) ;
DIE_UNLESS ( 1 == rc ) ;
}
mysql_stmt_close ( stmt ) ;
rc = mysql_query ( mysql , "DROP TABLE t1,t2,t3" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "DROP VIEW v1" ) ;
myquery ( rc ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
SPL_METHOD ( SplFileInfo , getPathInfo ) {
spl_filesystem_object * intern = ( spl_filesystem_object * ) zend_object_store_get_object ( getThis ( ) TSRMLS_CC ) ;
zend_class_entry * ce = intern -> info_class ;
zend_error_handling error_handling ;
zend_replace_error_handling ( EH_THROW , spl_ce_UnexpectedValueException , & error_handling TSRMLS_CC ) ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , "|C" , & ce ) == SUCCESS ) {
int path_len ;
char * path = spl_filesystem_object_get_pathname ( intern , & path_len TSRMLS_CC ) ;
if ( path ) {
char * dpath = estrndup ( path , path_len ) ;
path_len = php_dirname ( dpath , path_len ) ;
spl_filesystem_object_create_info ( intern , dpath , path_len , 1 , ce , return_value TSRMLS_CC ) ;
efree ( dpath ) ;
}
}
zend_restore_error_handling ( & error_handling TSRMLS_CC ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( NewAvatarMenuButtonTest , MAYBE_SignOut ) {
if ( ! profiles : : IsMultipleProfilesEnabled ( ) ) return ;
CreateTestingProfile ( ) ;
ASSERT_NO_FATAL_FAILURE ( StartAvatarMenu ( ) ) ;
BrowserList * browser_list = BrowserList : : GetInstance ( chrome : : GetActiveDesktop ( ) ) ;
EXPECT_EQ ( 1U , browser_list -> size ( ) ) ;
content : : WindowedNotificationObserver window_close_observer ( chrome : : NOTIFICATION_BROWSER_CLOSED , content : : Source < Browser > ( browser ( ) ) ) ;
AvatarMenu * menu = ProfileChooserView : : profile_bubble_ -> avatar_menu_ . get ( ) ;
const AvatarMenu : : Item & menu_item_before = menu -> GetItemAt ( menu -> GetActiveProfileIndex ( ) ) ;
EXPECT_FALSE ( menu_item_before . signin_required ) ;
ui : : MouseEvent mouse_ev ( ui : : ET_MOUSE_RELEASED , gfx : : Point ( ) , gfx : : Point ( ) , 0 , 0 ) ;
ProfileChooserView : : profile_bubble_ -> ButtonPressed ( ProfileChooserView : : profile_bubble_ -> lock_button_ , mouse_ev ) ;
EXPECT_TRUE ( menu -> GetItemAt ( menu -> GetActiveProfileIndex ( ) ) . signin_required ) ;
window_close_observer . Wait ( ) ;
EXPECT_TRUE ( browser_list -> empty ( ) ) ;
if ( ! UserManagerView : : IsShowing ( ) ) base : : MessageLoop : : current ( ) -> RunUntilIdle ( ) ;
chrome : : HideUserManager ( ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void cirrus_bitblt_start ( CirrusVGAState * s ) {
uint8_t blt_rop ;
if ( ! s -> enable_blitter ) {
goto bitblt_ignore ;
}
s -> vga . gr [ 0x31 ] |= CIRRUS_BLT_BUSY ;
s -> cirrus_blt_width = ( s -> vga . gr [ 0x20 ] | ( s -> vga . gr [ 0x21 ] << 8 ) ) + 1 ;
s -> cirrus_blt_height = ( s -> vga . gr [ 0x22 ] | ( s -> vga . gr [ 0x23 ] << 8 ) ) + 1 ;
s -> cirrus_blt_dstpitch = ( s -> vga . gr [ 0x24 ] | ( s -> vga . gr [ 0x25 ] << 8 ) ) ;
s -> cirrus_blt_srcpitch = ( s -> vga . gr [ 0x26 ] | ( s -> vga . gr [ 0x27 ] << 8 ) ) ;
s -> cirrus_blt_dstaddr = ( s -> vga . gr [ 0x28 ] | ( s -> vga . gr [ 0x29 ] << 8 ) | ( s -> vga . gr [ 0x2a ] << 16 ) ) ;
s -> cirrus_blt_srcaddr = ( s -> vga . gr [ 0x2c ] | ( s -> vga . gr [ 0x2d ] << 8 ) | ( s -> vga . gr [ 0x2e ] << 16 ) ) ;
s -> cirrus_blt_mode = s -> vga . gr [ 0x30 ] ;
s -> cirrus_blt_modeext = s -> vga . gr [ 0x33 ] ;
blt_rop = s -> vga . gr [ 0x32 ] ;
s -> cirrus_blt_dstaddr &= s -> cirrus_addr_mask ;
s -> cirrus_blt_srcaddr &= s -> cirrus_addr_mask ;
# ifdef DEBUG_BITBLT printf ( "rop=0x%02x mode=0x%02x modeext=0x%02x w=%d h=%d dpitch=%d spitch=%d daddr=0x%08x saddr=0x%08x writemask=0x%02x\n" , blt_rop , s -> cirrus_blt_mode , s -> cirrus_blt_modeext , s -> cirrus_blt_width , s -> cirrus_blt_height , s -> cirrus_blt_dstpitch , s -> cirrus_blt_srcpitch , s -> cirrus_blt_dstaddr , s -> cirrus_blt_srcaddr , s -> vga . gr [ 0x2f ] ) ;
# endif switch ( s -> cirrus_blt_mode & CIRRUS_BLTMODE_PIXELWIDTHMASK ) {
case CIRRUS_BLTMODE_PIXELWIDTH8 : s -> cirrus_blt_pixelwidth = 1 ;
break ;
case CIRRUS_BLTMODE_PIXELWIDTH16 : s -> cirrus_blt_pixelwidth = 2 ;
break ;
case CIRRUS_BLTMODE_PIXELWIDTH24 : s -> cirrus_blt_pixelwidth = 3 ;
break ;
case CIRRUS_BLTMODE_PIXELWIDTH32 : s -> cirrus_blt_pixelwidth = 4 ;
break ;
default : # ifdef DEBUG_BITBLT printf ( "cirrus: bitblt - pixel width is unknown\n" ) ;
# endif goto bitblt_ignore ;
}
s -> cirrus_blt_mode &= ~ CIRRUS_BLTMODE_PIXELWIDTHMASK ;
if ( ( s -> cirrus_blt_mode & ( CIRRUS_BLTMODE_MEMSYSSRC | CIRRUS_BLTMODE_MEMSYSDEST ) ) == ( CIRRUS_BLTMODE_MEMSYSSRC | CIRRUS_BLTMODE_MEMSYSDEST ) ) {
# ifdef DEBUG_BITBLT printf ( "cirrus: bitblt - memory-to-memory copy is requested\n" ) ;
# endif goto bitblt_ignore ;
}
if ( ( s -> cirrus_blt_modeext & CIRRUS_BLTMODEEXT_SOLIDFILL ) && ( s -> cirrus_blt_mode & ( CIRRUS_BLTMODE_MEMSYSDEST | CIRRUS_BLTMODE_TRANSPARENTCOMP | CIRRUS_BLTMODE_PATTERNCOPY | CIRRUS_BLTMODE_COLOREXPAND ) ) == ( CIRRUS_BLTMODE_PATTERNCOPY | CIRRUS_BLTMODE_COLOREXPAND ) ) {
cirrus_bitblt_fgcol ( s ) ;
cirrus_bitblt_solidfill ( s , blt_rop ) ;
}
else {
if ( ( s -> cirrus_blt_mode & ( CIRRUS_BLTMODE_COLOREXPAND | CIRRUS_BLTMODE_PATTERNCOPY ) ) == CIRRUS_BLTMODE_COLOREXPAND ) {
if ( s -> cirrus_blt_mode & CIRRUS_BLTMODE_TRANSPARENTCOMP ) {
if ( s -> cirrus_blt_modeext & CIRRUS_BLTMODEEXT_COLOREXPINV ) cirrus_bitblt_bgcol ( s ) ;
else cirrus_bitblt_fgcol ( s ) ;
s -> cirrus_rop = cirrus_colorexpand_transp [ rop_to_index [ blt_rop ] ] [ s -> cirrus_blt_pixelwidth - 1 ] ;
}
else {
cirrus_bitblt_fgcol ( s ) ;
cirrus_bitblt_bgcol ( s ) ;
s -> cirrus_rop = cirrus_colorexpand [ rop_to_index [ blt_rop ] ] [ s -> cirrus_blt_pixelwidth - 1 ] ;
}
}
else if ( s -> cirrus_blt_mode & CIRRUS_BLTMODE_PATTERNCOPY ) {
if ( s -> cirrus_blt_mode & CIRRUS_BLTMODE_COLOREXPAND ) {
if ( s -> cirrus_blt_mode & CIRRUS_BLTMODE_TRANSPARENTCOMP ) {
if ( s -> cirrus_blt_modeext & CIRRUS_BLTMODEEXT_COLOREXPINV ) cirrus_bitblt_bgcol ( s ) ;
else cirrus_bitblt_fgcol ( s ) ;
s -> cirrus_rop = cirrus_colorexpand_pattern_transp [ rop_to_index [ blt_rop ] ] [ s -> cirrus_blt_pixelwidth - 1 ] ;
}
else {
cirrus_bitblt_fgcol ( s ) ;
cirrus_bitblt_bgcol ( s ) ;
s -> cirrus_rop = cirrus_colorexpand_pattern [ rop_to_index [ blt_rop ] ] [ s -> cirrus_blt_pixelwidth - 1 ] ;
}
}
else {
s -> cirrus_rop = cirrus_patternfill [ rop_to_index [ blt_rop ] ] [ s -> cirrus_blt_pixelwidth - 1 ] ;
}
}
else {
if ( s -> cirrus_blt_mode & CIRRUS_BLTMODE_TRANSPARENTCOMP ) {
if ( s -> cirrus_blt_pixelwidth > 2 ) {
printf ( "src transparent without colorexpand must be 8bpp or 16bpp\n" ) ;
goto bitblt_ignore ;
}
if ( s -> cirrus_blt_mode & CIRRUS_BLTMODE_BACKWARDS ) {
s -> cirrus_blt_dstpitch = - s -> cirrus_blt_dstpitch ;
s -> cirrus_blt_srcpitch = - s -> cirrus_blt_srcpitch ;
s -> cirrus_rop = cirrus_bkwd_transp_rop [ rop_to_index [ blt_rop ] ] [ s -> cirrus_blt_pixelwidth - 1 ] ;
}
else {
s -> cirrus_rop = cirrus_fwd_transp_rop [ rop_to_index [ blt_rop ] ] [ s -> cirrus_blt_pixelwidth - 1 ] ;
}
}
else {
if ( s -> cirrus_blt_mode & CIRRUS_BLTMODE_BACKWARDS ) {
s -> cirrus_blt_dstpitch = - s -> cirrus_blt_dstpitch ;
s -> cirrus_blt_srcpitch = - s -> cirrus_blt_srcpitch ;
s -> cirrus_rop = cirrus_bkwd_rop [ rop_to_index [ blt_rop ] ] ;
}
else {
s -> cirrus_rop = cirrus_fwd_rop [ rop_to_index [ blt_rop ] ] ;
}
}
}
if ( s -> cirrus_blt_mode & CIRRUS_BLTMODE_MEMSYSSRC ) {
if ( ! cirrus_bitblt_cputovideo ( s ) ) goto bitblt_ignore ;
}
else if ( s -> cirrus_blt_mode & CIRRUS_BLTMODE_MEMSYSDEST ) {
if ( ! cirrus_bitblt_videotocpu ( s ) ) goto bitblt_ignore ;
}
else {
if ( ! cirrus_bitblt_videotovideo ( s ) ) goto bitblt_ignore ;
}
}
return ;
bitblt_ignore : ;
cirrus_bitblt_reset ( s ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
uint32_t mime_field_value_get_uint ( const MIMEField * field ) {
int length ;
const char * str = mime_field_value_get ( field , & length ) ;
return mime_parse_uint ( str , str + length ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int selinux_socket_accept ( struct socket * sock , struct socket * newsock ) {
int err ;
struct inode_security_struct * isec ;
struct inode_security_struct * newisec ;
u16 sclass ;
u32 sid ;
err = sock_has_perm ( current , sock -> sk , SOCKET__ACCEPT ) ;
if ( err ) return err ;
isec = inode_security_novalidate ( SOCK_INODE ( sock ) ) ;
spin_lock ( & isec -> lock ) ;
sclass = isec -> sclass ;
sid = isec -> sid ;
spin_unlock ( & isec -> lock ) ;
newisec = inode_security_novalidate ( SOCK_INODE ( newsock ) ) ;
newisec -> sclass = sclass ;
newisec -> sid = sid ;
newisec -> initialized = LABEL_INITIALIZED ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_t38_UDPTLPacket ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
# line 232 "../../asn1/t38/t38.cnf" Data_Field_field_type_value = 1 ;
offset = dissect_per_sequence ( tvb , offset , actx , tree , hf_index , ett_t38_UDPTLPacket , UDPTLPacket_sequence ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int selinux_tun_dev_create ( void ) {
u32 sid = current_sid ( ) ;
return avc_has_perm ( sid , sid , SECCLASS_TUN_SOCKET , TUN_SOCKET__CREATE , NULL ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int tcomp ( const void * _t1 , const void * _t2 ) {
struct taboff * t1 = * ( ( struct taboff * * ) _t1 ) , * t2 = * ( ( struct taboff * * ) _t2 ) ;
return ( t1 -> orderingval - t2 -> orderingval ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h225_Endpoint ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_sequence ( tvb , offset , actx , tree , hf_index , ett_h225_Endpoint , Endpoint_sequence ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void TSSkipRemappingSet ( TSHttpTxn txnp , int flag ) {
sdk_assert ( sdk_sanity_check_txn ( txnp ) == TS_SUCCESS ) ;
HttpSM * sm = ( HttpSM * ) txnp ;
sm -> t_state . api_skip_all_remapping = ( flag != 0 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static char * alloc_query_str ( ulong size ) {
char * query ;
if ( ! ( query = ( char * ) my_malloc ( size , MYF ( MY_WME ) ) ) ) die ( EX_MYSQLERR , "Couldn't allocate a query string." ) ;
return query ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
enum block_op find_operand ( const char * start ) {
char first = * start ;
char next = * ( start + 1 ) ;
if ( first == '=' && next == '=' ) return EQ_OP ;
if ( first == '!' && next == '=' ) return NE_OP ;
if ( first == '>' && next == '=' ) return GE_OP ;
if ( first == '>' ) return GT_OP ;
if ( first == '<' && next == '=' ) return LE_OP ;
if ( first == '<' ) return LT_OP ;
return ILLEG_OP ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void convolve_avg_horiz ( const uint8_t * src , ptrdiff_t src_stride , uint8_t * dst , ptrdiff_t dst_stride , const InterpKernel * x_filters , int x0_q4 , int x_step_q4 , int w , int h ) {
int x , y ;
src -= SUBPEL_TAPS / 2 - 1 ;
for ( y = 0 ;
y < h ;
++ y ) {
int x_q4 = x0_q4 ;
for ( x = 0 ;
x < w ;
++ x ) {
const uint8_t * const src_x = & src [ x_q4 >> SUBPEL_BITS ] ;
const int16_t * const x_filter = x_filters [ x_q4 & SUBPEL_MASK ] ;
int k , sum = 0 ;
for ( k = 0 ;
k < SUBPEL_TAPS ;
++ k ) sum += src_x [ k ] * x_filter [ k ] ;
dst [ x ] = ROUND_POWER_OF_TWO ( dst [ x ] + clip_pixel ( ROUND_POWER_OF_TWO ( sum , FILTER_BITS ) ) , 1 ) ;
x_q4 += x_step_q4 ;
}
src += src_stride ;
dst += dst_stride ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h225_SEQUENCE_OF_DisplayName ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_sequence_of ( tvb , offset , actx , tree , hf_index , ett_h225_SEQUENCE_OF_DisplayName , SEQUENCE_OF_DisplayName_sequence_of ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_SET_SIZE_1_14_OF_BEnhancementParameters ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_constrained_set_of ( tvb , offset , actx , tree , hf_index , ett_h245_SET_SIZE_1_14_OF_BEnhancementParameters , SET_SIZE_1_14_OF_BEnhancementParameters_set_of , 1 , 14 , FALSE ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int proc_releaseinterface ( struct usb_dev_state * ps , void __user * arg ) {
unsigned int ifnum ;
int ret ;
if ( get_user ( ifnum , ( unsigned int __user * ) arg ) ) return - EFAULT ;
ret = releaseintf ( ps , ifnum ) ;
if ( ret < 0 ) return ret ;
destroy_async_on_interface ( ps , ifnum ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static afs_int32 isAMemberOf ( struct rx_call * call , afs_int32 uid , afs_int32 gid , afs_int32 * flag , afs_int32 * cid ) {
afs_int32 code ;
struct ubik_trans * tt ;
code = Initdb ( ) ;
if ( code != PRSUCCESS ) return code ;
code = ubik_BeginTransReadAny ( dbase , UBIK_READTRANS , & tt ) ;
if ( code ) return code ;
code = ubik_SetLock ( tt , 1 , 1 , LOCKREAD ) ;
if ( code ) ABORT_WITH ( tt , code ) ;
code = read_DbHeader ( tt ) ;
if ( code ) ABORT_WITH ( tt , code ) ;
{
afs_int32 uloc = FindByID ( tt , uid ) ;
afs_int32 gloc = FindByID ( tt , gid ) ;
struct prentry uentry , gentry ;
if ( ! uloc || ! gloc ) ABORT_WITH ( tt , PRNOENT ) ;
code = WhoIsThis ( call , tt , cid ) ;
if ( code ) ABORT_WITH ( tt , PRPERM ) ;
code = pr_ReadEntry ( tt , 0 , uloc , & uentry ) ;
if ( code ) ABORT_WITH ( tt , code ) ;
code = pr_ReadEntry ( tt , 0 , gloc , & gentry ) ;
if ( code ) ABORT_WITH ( tt , code ) ;
# if ! defined ( SUPERGROUPS ) if ( ( uentry . flags & PRGRP ) || ! ( gentry . flags & PRGRP ) ) ABORT_WITH ( tt , PRBADARG ) ;
# else if ( ! ( gentry . flags & PRGRP ) ) ABORT_WITH ( tt , PRBADARG ) ;
# endif if ( ! AccessOK ( tt , * cid , & uentry , 0 , PRP_MEMBER_ANY ) && ! AccessOK ( tt , * cid , & gentry , PRP_MEMBER_MEM , PRP_MEMBER_ANY ) ) ABORT_WITH ( tt , PRPERM ) ;
}
* flag = IsAMemberOf ( tt , uid , gid ) ;
code = ubik_EndTrans ( tt ) ;
return code ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int rfc2231_parse ( struct rfc822_parser_context * ctx , const char * const * * result_r ) {
ARRAY_TYPE ( const_string ) result ;
ARRAY ( struct rfc2231_parameter ) rfc2231_params_arr ;
struct rfc2231_parameter rfc2231_param ;
const struct rfc2231_parameter * rfc2231_params ;
const char * key , * value , * p , * p2 ;
string_t * str ;
unsigned int i , j , count , next , next_idx ;
bool ok , have_extended , broken = FALSE ;
int ret ;
i_zero ( & rfc2231_param ) ;
t_array_init ( & result , 8 ) ;
t_array_init ( & rfc2231_params_arr , 8 ) ;
while ( ( ret = rfc822_parse_content_param ( ctx , & key , & value ) ) != 0 ) {
if ( ret < 0 ) {
broken = TRUE ;
if ( ctx -> data >= ctx -> end ) break ;
ctx -> data ++ ;
continue ;
}
p = strchr ( key , '*' ) ;
if ( p != NULL ) {
p2 = p ;
if ( p [ 1 ] != '\0' ) {
p ++ ;
rfc2231_param . idx = 0 ;
for ( ;
* p >= '0' && * p <= '9' ;
p ++ ) {
rfc2231_param . idx = rfc2231_param . idx * 10 + * p - '0' ;
}
}
if ( * p != '*' ) rfc2231_param . extended = FALSE ;
else {
rfc2231_param . extended = TRUE ;
p ++ ;
}
if ( * p != '\0' ) p = NULL ;
else {
rfc2231_param . key = t_strdup_until ( key , p2 ) ;
rfc2231_param . value = value ;
array_append ( & rfc2231_params_arr , & rfc2231_param , 1 ) ;
}
}
if ( p == NULL ) {
array_append ( & result , & key , 1 ) ;
array_append ( & result , & value , 1 ) ;
}
}
if ( array_count ( & rfc2231_params_arr ) == 0 ) {
array_append_zero ( & result ) ;
* result_r = array_idx ( & result , 0 ) ;
return broken ? - 1 : 0 ;
}
array_sort ( & rfc2231_params_arr , rfc2231_parameter_cmp ) ;
rfc2231_params = array_get ( & rfc2231_params_arr , & count ) ;
str = t_str_new ( 64 ) ;
for ( i = 0 ;
i < count ;
i = next ) {
ok = TRUE ;
have_extended = FALSE ;
next_idx = 0 ;
for ( j = i ;
j < count ;
j ++ ) {
if ( strcasecmp ( rfc2231_params [ i ] . key , rfc2231_params [ j ] . key ) != 0 ) break ;
if ( rfc2231_params [ j ] . idx != next_idx ) {
ok = FALSE ;
}
if ( rfc2231_params [ j ] . extended ) have_extended = TRUE ;
next_idx ++ ;
}
next = j ;
if ( ! ok ) {
for ( j = i ;
j < next ;
j ++ ) {
key = t_strdup_printf ( rfc2231_params [ j ] . extended ? "%s*%u*" : "%s*%u" , rfc2231_params [ j ] . key , rfc2231_params [ j ] . idx ) ;
array_append ( & result , & key , 1 ) ;
array_append ( & result , & rfc2231_params [ j ] . value , 1 ) ;
}
}
else {
str_truncate ( str , 0 ) ;
if ( ! rfc2231_params [ i ] . extended && have_extended ) str_append ( str , "''" ) ;
for ( j = i ;
j < next ;
j ++ ) {
if ( ! rfc2231_params [ j ] . extended && have_extended ) {
rfc2231_escape ( str , rfc2231_params [ j ] . value ) ;
}
else {
str_append ( str , rfc2231_params [ j ] . value ) ;
}
}
key = rfc2231_params [ i ] . key ;
if ( have_extended ) key = t_strconcat ( key , "*" , NULL ) ;
value = t_strdup ( str_c ( str ) ) ;
array_append ( & result , & key , 1 ) ;
array_append ( & result , & value , 1 ) ;
}
}
array_append_zero ( & result ) ;
* result_r = array_idx ( & result , 0 ) ;
return broken ? - 1 : 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h225_ResourcesAvailableIndicate ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_sequence ( tvb , offset , actx , tree , hf_index , ett_h225_ResourcesAvailableIndicate , ResourcesAvailableIndicate_sequence ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static cmsBool Type_ColorantOrderType_Write ( struct _cms_typehandler_struct * self , cmsIOHANDLER * io , void * Ptr , cmsUInt32Number nItems ) {
cmsUInt8Number * ColorantOrder = ( cmsUInt8Number * ) Ptr ;
cmsUInt32Number i , sz , Count ;
for ( Count = i = 0 ;
i < cmsMAXCHANNELS ;
i ++ ) {
if ( ColorantOrder [ i ] != 0xFF ) Count ++ ;
}
if ( ! _cmsWriteUInt32Number ( io , Count ) ) return FALSE ;
sz = Count * sizeof ( cmsUInt8Number ) ;
if ( ! io -> Write ( io , sz , ColorantOrder ) ) return FALSE ;
return TRUE ;
cmsUNUSED_PARAMETER ( nItems ) ;
cmsUNUSED_PARAMETER ( self ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int dissect_ber_constrained_integer64 ( gboolean implicit_tag , asn1_ctx_t * actx , proto_tree * tree , tvbuff_t * tvb , int offset , gint64 min_len , gint64 max_len , gint hf_id , gint64 * value ) {
gint64 val ;
offset = dissect_ber_integer64 ( implicit_tag , actx , tree , tvb , offset , hf_id , & val ) ;
if ( value ) {
* value = val ;
}
ber_check_value64 ( val , min_len , max_len , actx , actx -> created_item ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int avi_read_header ( AVFormatContext * s ) {
AVIContext * avi = s -> priv_data ;
AVIOContext * pb = s -> pb ;
unsigned int tag , tag1 , handler ;
int codec_type , stream_index , frame_period ;
unsigned int size ;
int i ;
AVStream * st ;
AVIStream * ast = NULL ;
int avih_width = 0 , avih_height = 0 ;
int amv_file_format = 0 ;
uint64_t list_end = 0 ;
int64_t pos ;
int ret ;
AVDictionaryEntry * dict_entry ;
avi -> stream_index = - 1 ;
ret = get_riff ( s , pb ) ;
if ( ret < 0 ) return ret ;
av_log ( avi , AV_LOG_DEBUG , "use odml:%d\n" , avi -> use_odml ) ;
avi -> io_fsize = avi -> fsize = avio_size ( pb ) ;
if ( avi -> fsize <= 0 || avi -> fsize < avi -> riff_end ) avi -> fsize = avi -> riff_end == 8 ? INT64_MAX : avi -> riff_end ;
stream_index = - 1 ;
codec_type = - 1 ;
frame_period = 0 ;
for ( ;
;
) {
if ( avio_feof ( pb ) ) goto fail ;
tag = avio_rl32 ( pb ) ;
size = avio_rl32 ( pb ) ;
print_tag ( "tag" , tag , size ) ;
switch ( tag ) {
case MKTAG ( 'L' , 'I' , 'S' , 'T' ) : list_end = avio_tell ( pb ) + size ;
tag1 = avio_rl32 ( pb ) ;
print_tag ( "list" , tag1 , 0 ) ;
if ( tag1 == MKTAG ( 'm' , 'o' , 'v' , 'i' ) ) {
avi -> movi_list = avio_tell ( pb ) - 4 ;
if ( size ) avi -> movi_end = avi -> movi_list + size + ( size & 1 ) ;
else avi -> movi_end = avi -> fsize ;
av_log ( NULL , AV_LOG_TRACE , "movi end=%" PRIx64 "\n" , avi -> movi_end ) ;
goto end_of_header ;
}
else if ( tag1 == MKTAG ( 'I' , 'N' , 'F' , 'O' ) ) ff_read_riff_info ( s , size - 4 ) ;
else if ( tag1 == MKTAG ( 'n' , 'c' , 'd' , 't' ) ) avi_read_nikon ( s , list_end ) ;
break ;
case MKTAG ( 'I' , 'D' , 'I' , 'T' ) : {
unsigned char date [ 64 ] = {
0 }
;
size += ( size & 1 ) ;
size -= avio_read ( pb , date , FFMIN ( size , sizeof ( date ) - 1 ) ) ;
avio_skip ( pb , size ) ;
avi_metadata_creation_time ( & s -> metadata , date ) ;
break ;
}
case MKTAG ( 'd' , 'm' , 'l' , 'h' ) : avi -> is_odml = 1 ;
avio_skip ( pb , size + ( size & 1 ) ) ;
break ;
case MKTAG ( 'a' , 'm' , 'v' , 'h' ) : amv_file_format = 1 ;
case MKTAG ( 'a' , 'v' , 'i' , 'h' ) : frame_period = avio_rl32 ( pb ) ;
avio_rl32 ( pb ) ;
avio_rl32 ( pb ) ;
avi -> non_interleaved |= avio_rl32 ( pb ) & AVIF_MUSTUSEINDEX ;
avio_skip ( pb , 2 * 4 ) ;
avio_rl32 ( pb ) ;
avio_rl32 ( pb ) ;
avih_width = avio_rl32 ( pb ) ;
avih_height = avio_rl32 ( pb ) ;
avio_skip ( pb , size - 10 * 4 ) ;
break ;
case MKTAG ( 's' , 't' , 'r' , 'h' ) : tag1 = avio_rl32 ( pb ) ;
handler = avio_rl32 ( pb ) ;
if ( tag1 == MKTAG ( 'p' , 'a' , 'd' , 's' ) ) {
avio_skip ( pb , size - 8 ) ;
break ;
}
else {
stream_index ++ ;
st = avformat_new_stream ( s , NULL ) ;
if ( ! st ) goto fail ;
st -> id = stream_index ;
ast = av_mallocz ( sizeof ( AVIStream ) ) ;
if ( ! ast ) goto fail ;
st -> priv_data = ast ;
}
if ( amv_file_format ) tag1 = stream_index ? MKTAG ( 'a' , 'u' , 'd' , 's' ) : MKTAG ( 'v' , 'i' , 'd' , 's' ) ;
print_tag ( "strh" , tag1 , - 1 ) ;
if ( tag1 == MKTAG ( 'i' , 'a' , 'v' , 's' ) || tag1 == MKTAG ( 'i' , 'v' , 'a' , 's' ) ) {
int64_t dv_dur ;
if ( s -> nb_streams != 1 ) goto fail ;
if ( handler != MKTAG ( 'd' , 'v' , 's' , 'd' ) && handler != MKTAG ( 'd' , 'v' , 'h' , 'd' ) && handler != MKTAG ( 'd' , 'v' , 's' , 'l' ) ) goto fail ;
ast = s -> streams [ 0 ] -> priv_data ;
av_freep ( & s -> streams [ 0 ] -> codecpar -> extradata ) ;
av_freep ( & s -> streams [ 0 ] -> codecpar ) ;
# if FF_API_LAVF_AVCTX FF_DISABLE_DEPRECATION_WARNINGS av_freep ( & s -> streams [ 0 ] -> codec ) ;
FF_ENABLE_DEPRECATION_WARNINGS # endif if ( s -> streams [ 0 ] -> info ) av_freep ( & s -> streams [ 0 ] -> info -> duration_error ) ;
av_freep ( & s -> streams [ 0 ] -> info ) ;
if ( s -> streams [ 0 ] -> internal ) av_freep ( & s -> streams [ 0 ] -> internal -> avctx ) ;
av_freep ( & s -> streams [ 0 ] -> internal ) ;
av_freep ( & s -> streams [ 0 ] ) ;
s -> nb_streams = 0 ;
if ( CONFIG_DV_DEMUXER ) {
avi -> dv_demux = avpriv_dv_init_demux ( s ) ;
if ( ! avi -> dv_demux ) goto fail ;
}
else goto fail ;
s -> streams [ 0 ] -> priv_data = ast ;
avio_skip ( pb , 3 * 4 ) ;
ast -> scale = avio_rl32 ( pb ) ;
ast -> rate = avio_rl32 ( pb ) ;
avio_skip ( pb , 4 ) ;
dv_dur = avio_rl32 ( pb ) ;
if ( ast -> scale > 0 && ast -> rate > 0 && dv_dur > 0 ) {
dv_dur *= AV_TIME_BASE ;
s -> duration = av_rescale ( dv_dur , ast -> scale , ast -> rate ) ;
}
stream_index = s -> nb_streams - 1 ;
avio_skip ( pb , size - 9 * 4 ) ;
break ;
}
av_assert0 ( stream_index < s -> nb_streams ) ;
ast -> handler = handler ;
avio_rl32 ( pb ) ;
avio_rl16 ( pb ) ;
avio_rl16 ( pb ) ;
avio_rl32 ( pb ) ;
ast -> scale = avio_rl32 ( pb ) ;
ast -> rate = avio_rl32 ( pb ) ;
if ( ! ( ast -> scale && ast -> rate ) ) {
av_log ( s , AV_LOG_WARNING , "scale/rate is %" PRIu32 "/%" PRIu32 " which is invalid. " "(This file has been generated by broken software.)\n" , ast -> scale , ast -> rate ) ;
if ( frame_period ) {
ast -> rate = 1000000 ;
ast -> scale = frame_period ;
}
else {
ast -> rate = 25 ;
ast -> scale = 1 ;
}
}
avpriv_set_pts_info ( st , 64 , ast -> scale , ast -> rate ) ;
ast -> cum_len = avio_rl32 ( pb ) ;
st -> nb_frames = avio_rl32 ( pb ) ;
st -> start_time = 0 ;
avio_rl32 ( pb ) ;
avio_rl32 ( pb ) ;
if ( ast -> cum_len * ast -> scale / ast -> rate > 3600 ) {
av_log ( s , AV_LOG_ERROR , "crazy start time, iam scared, giving up\n" ) ;
ast -> cum_len = 0 ;
}
ast -> sample_size = avio_rl32 ( pb ) ;
ast -> cum_len *= FFMAX ( 1 , ast -> sample_size ) ;
av_log ( s , AV_LOG_TRACE , "%" PRIu32 " %" PRIu32 " %d\n" , ast -> rate , ast -> scale , ast -> sample_size ) ;
switch ( tag1 ) {
case MKTAG ( 'v' , 'i' , 'd' , 's' ) : codec_type = AVMEDIA_TYPE_VIDEO ;
ast -> sample_size = 0 ;
st -> avg_frame_rate = av_inv_q ( st -> time_base ) ;
break ;
case MKTAG ( 'a' , 'u' , 'd' , 's' ) : codec_type = AVMEDIA_TYPE_AUDIO ;
break ;
case MKTAG ( 't' , 'x' , 't' , 's' ) : codec_type = AVMEDIA_TYPE_SUBTITLE ;
break ;
case MKTAG ( 'd' , 'a' , 't' , 's' ) : codec_type = AVMEDIA_TYPE_DATA ;
break ;
default : av_log ( s , AV_LOG_INFO , "unknown stream type %X\n" , tag1 ) ;
}
if ( ast -> sample_size < 0 ) {
if ( s -> error_recognition & AV_EF_EXPLODE ) {
av_log ( s , AV_LOG_ERROR , "Invalid sample_size %d at stream %d\n" , ast -> sample_size , stream_index ) ;
goto fail ;
}
av_log ( s , AV_LOG_WARNING , "Invalid sample_size %d at stream %d " "setting it to 0\n" , ast -> sample_size , stream_index ) ;
ast -> sample_size = 0 ;
}
if ( ast -> sample_size == 0 ) {
st -> duration = st -> nb_frames ;
if ( st -> duration > 0 && avi -> io_fsize > 0 && avi -> riff_end > avi -> io_fsize ) {
av_log ( s , AV_LOG_DEBUG , "File is truncated adjusting duration\n" ) ;
st -> duration = av_rescale ( st -> duration , avi -> io_fsize , avi -> riff_end ) ;
}
}
ast -> frame_offset = ast -> cum_len ;
avio_skip ( pb , size - 12 * 4 ) ;
break ;
case MKTAG ( 's' , 't' , 'r' , 'f' ) : if ( ! size && ( codec_type == AVMEDIA_TYPE_AUDIO || codec_type == AVMEDIA_TYPE_VIDEO ) ) break ;
if ( stream_index >= ( unsigned ) s -> nb_streams || avi -> dv_demux ) {
avio_skip ( pb , size ) ;
}
else {
uint64_t cur_pos = avio_tell ( pb ) ;
unsigned esize ;
if ( cur_pos < list_end ) size = FFMIN ( size , list_end - cur_pos ) ;
st = s -> streams [ stream_index ] ;
if ( st -> codecpar -> codec_type != AVMEDIA_TYPE_UNKNOWN ) {
avio_skip ( pb , size ) ;
break ;
}
switch ( codec_type ) {
case AVMEDIA_TYPE_VIDEO : if ( amv_file_format ) {
st -> codecpar -> width = avih_width ;
st -> codecpar -> height = avih_height ;
st -> codecpar -> codec_type = AVMEDIA_TYPE_VIDEO ;
st -> codecpar -> codec_id = AV_CODEC_ID_AMV ;
avio_skip ( pb , size ) ;
break ;
}
tag1 = ff_get_bmp_header ( pb , st , & esize ) ;
if ( tag1 == MKTAG ( 'D' , 'X' , 'S' , 'B' ) || tag1 == MKTAG ( 'D' , 'X' , 'S' , 'A' ) ) {
st -> codecpar -> codec_type = AVMEDIA_TYPE_SUBTITLE ;
st -> codecpar -> codec_tag = tag1 ;
st -> codecpar -> codec_id = AV_CODEC_ID_XSUB ;
break ;
}
if ( size > 10 * 4 && size < ( 1 << 30 ) && size < avi -> fsize ) {
if ( esize == size - 1 && ( esize & 1 ) ) {
st -> codecpar -> extradata_size = esize - 10 * 4 ;
}
else st -> codecpar -> extradata_size = size - 10 * 4 ;
if ( st -> codecpar -> extradata ) {
av_log ( s , AV_LOG_WARNING , "New extradata in strf chunk, freeing previous one.\n" ) ;
av_freep ( & st -> codecpar -> extradata ) ;
}
if ( ff_get_extradata ( s , st -> codecpar , pb , st -> codecpar -> extradata_size ) < 0 ) return AVERROR ( ENOMEM ) ;
}
if ( st -> codecpar -> extradata_size & 1 ) avio_r8 ( pb ) ;
if ( st -> codecpar -> extradata_size && ( st -> codecpar -> bits_per_coded_sample <= 8 ) ) {
int pal_size = ( 1 << st -> codecpar -> bits_per_coded_sample ) << 2 ;
const uint8_t * pal_src ;
pal_size = FFMIN ( pal_size , st -> codecpar -> extradata_size ) ;
pal_src = st -> codecpar -> extradata + st -> codecpar -> extradata_size - pal_size ;
if ( pal_src - st -> codecpar -> extradata >= 9 && ! memcmp ( st -> codecpar -> extradata + st -> codecpar -> extradata_size - 9 , "BottomUp" , 9 ) ) pal_src -= 9 ;
for ( i = 0 ;
i < pal_size / 4 ;
i ++ ) ast -> pal [ i ] = 0xFFU << 24 | AV_RL32 ( pal_src + 4 * i ) ;
ast -> has_pal = 1 ;
}
print_tag ( "video" , tag1 , 0 ) ;
st -> codecpar -> codec_type = AVMEDIA_TYPE_VIDEO ;
st -> codecpar -> codec_tag = tag1 ;
st -> codecpar -> codec_id = ff_codec_get_id ( ff_codec_bmp_tags , tag1 ) ;
if ( ! st -> codecpar -> codec_id ) {
st -> codecpar -> codec_id = ff_codec_get_id ( ff_codec_movvideo_tags , tag1 ) ;
if ( st -> codecpar -> codec_id ) av_log ( s , AV_LOG_WARNING , "mov tag found in avi (fourcc %s)\n" , av_fourcc2str ( tag1 ) ) ;
}
st -> need_parsing = AVSTREAM_PARSE_HEADERS ;
if ( st -> codecpar -> codec_id == AV_CODEC_ID_MPEG4 && ast -> handler == MKTAG ( 'X' , 'V' , 'I' , 'D' ) ) st -> codecpar -> codec_tag = MKTAG ( 'X' , 'V' , 'I' , 'D' ) ;
if ( st -> codecpar -> codec_tag == MKTAG ( 'V' , 'S' , 'S' , 'H' ) ) st -> need_parsing = AVSTREAM_PARSE_FULL ;
if ( st -> codecpar -> codec_id == AV_CODEC_ID_RV40 ) st -> need_parsing = AVSTREAM_PARSE_NONE ;
if ( st -> codecpar -> codec_tag == 0 && st -> codecpar -> height > 0 && st -> codecpar -> extradata_size < 1U << 30 ) {
st -> codecpar -> extradata_size += 9 ;
if ( ( ret = av_reallocp ( & st -> codecpar -> extradata , st -> codecpar -> extradata_size + AV_INPUT_BUFFER_PADDING_SIZE ) ) < 0 ) {
st -> codecpar -> extradata_size = 0 ;
return ret ;
}
else memcpy ( st -> codecpar -> extradata + st -> codecpar -> extradata_size - 9 , "BottomUp" , 9 ) ;
}
st -> codecpar -> height = FFABS ( st -> codecpar -> height ) ;
break ;
case AVMEDIA_TYPE_AUDIO : ret = ff_get_wav_header ( s , pb , st -> codecpar , size , 0 ) ;
if ( ret < 0 ) return ret ;
ast -> dshow_block_align = st -> codecpar -> block_align ;
if ( ast -> sample_size && st -> codecpar -> block_align && ast -> sample_size != st -> codecpar -> block_align ) {
av_log ( s , AV_LOG_WARNING , "sample size (%d) != block align (%d)\n" , ast -> sample_size , st -> codecpar -> block_align ) ;
ast -> sample_size = st -> codecpar -> block_align ;
}
if ( size & 1 ) avio_skip ( pb , 1 ) ;
st -> need_parsing = AVSTREAM_PARSE_TIMESTAMPS ;
if ( st -> codecpar -> codec_id == AV_CODEC_ID_AAC && st -> codecpar -> extradata_size ) st -> need_parsing = AVSTREAM_PARSE_NONE ;
if ( st -> codecpar -> codec_id == AV_CODEC_ID_FLAC ) st -> need_parsing = AVSTREAM_PARSE_NONE ;
if ( ast -> handler == AV_RL32 ( "Axan" ) ) {
st -> codecpar -> codec_id = AV_CODEC_ID_XAN_DPCM ;
st -> codecpar -> codec_tag = 0 ;
ast -> dshow_block_align = 0 ;
}
if ( amv_file_format ) {
st -> codecpar -> codec_id = AV_CODEC_ID_ADPCM_IMA_AMV ;
ast -> dshow_block_align = 0 ;
}
if ( ( st -> codecpar -> codec_id == AV_CODEC_ID_AAC || st -> codecpar -> codec_id == AV_CODEC_ID_FLAC || st -> codecpar -> codec_id == AV_CODEC_ID_MP2 ) && ast -> dshow_block_align <= 4 && ast -> dshow_block_align ) {
av_log ( s , AV_LOG_DEBUG , "overriding invalid dshow_block_align of %d\n" , ast -> dshow_block_align ) ;
ast -> dshow_block_align = 0 ;
}
if ( st -> codecpar -> codec_id == AV_CODEC_ID_AAC && ast -> dshow_block_align == 1024 && ast -> sample_size == 1024 || st -> codecpar -> codec_id == AV_CODEC_ID_AAC && ast -> dshow_block_align == 4096 && ast -> sample_size == 4096 || st -> codecpar -> codec_id == AV_CODEC_ID_MP3 && ast -> dshow_block_align == 1152 && ast -> sample_size == 1152 ) {
av_log ( s , AV_LOG_DEBUG , "overriding sample_size\n" ) ;
ast -> sample_size = 0 ;
}
break ;
case AVMEDIA_TYPE_SUBTITLE : st -> codecpar -> codec_type = AVMEDIA_TYPE_SUBTITLE ;
st -> request_probe = 1 ;
avio_skip ( pb , size ) ;
break ;
default : st -> codecpar -> codec_type = AVMEDIA_TYPE_DATA ;
st -> codecpar -> codec_id = AV_CODEC_ID_NONE ;
st -> codecpar -> codec_tag = 0 ;
avio_skip ( pb , size ) ;
break ;
}
}
break ;
case MKTAG ( 's' , 't' , 'r' , 'd' ) : if ( stream_index >= ( unsigned ) s -> nb_streams || s -> streams [ stream_index ] -> codecpar -> extradata_size || s -> streams [ stream_index ] -> codecpar -> codec_tag == MKTAG ( 'H' , '2' , '6' , '4' ) ) {
avio_skip ( pb , size ) ;
}
else {
uint64_t cur_pos = avio_tell ( pb ) ;
if ( cur_pos < list_end ) size = FFMIN ( size , list_end - cur_pos ) ;
st = s -> streams [ stream_index ] ;
if ( size < ( 1 << 30 ) ) {
if ( st -> codecpar -> extradata ) {
av_log ( s , AV_LOG_WARNING , "New extradata in strd chunk, freeing previous one.\n" ) ;
av_freep ( & st -> codecpar -> extradata ) ;
}
if ( ff_get_extradata ( s , st -> codecpar , pb , size ) < 0 ) return AVERROR ( ENOMEM ) ;
}
if ( st -> codecpar -> extradata_size & 1 ) avio_r8 ( pb ) ;
ret = avi_extract_stream_metadata ( s , st ) ;
if ( ret < 0 ) {
av_log ( s , AV_LOG_WARNING , "could not decoding EXIF data in stream header.\n" ) ;
}
}
break ;
case MKTAG ( 'i' , 'n' , 'd' , 'x' ) : pos = avio_tell ( pb ) ;
if ( ( pb -> seekable & AVIO_SEEKABLE_NORMAL ) && ! ( s -> flags & AVFMT_FLAG_IGNIDX ) && avi -> use_odml && read_odml_index ( s , 0 ) < 0 && ( s -> error_recognition & AV_EF_EXPLODE ) ) goto fail ;
avio_seek ( pb , pos + size , SEEK_SET ) ;
break ;
case MKTAG ( 'v' , 'p' , 'r' , 'p' ) : if ( stream_index < ( unsigned ) s -> nb_streams && size > 9 * 4 ) {
AVRational active , active_aspect ;
st = s -> streams [ stream_index ] ;
avio_rl32 ( pb ) ;
avio_rl32 ( pb ) ;
avio_rl32 ( pb ) ;
avio_rl32 ( pb ) ;
avio_rl32 ( pb ) ;
active_aspect . den = avio_rl16 ( pb ) ;
active_aspect . num = avio_rl16 ( pb ) ;
active . num = avio_rl32 ( pb ) ;
active . den = avio_rl32 ( pb ) ;
avio_rl32 ( pb ) ;
if ( active_aspect . num && active_aspect . den && active . num && active . den ) {
st -> sample_aspect_ratio = av_div_q ( active_aspect , active ) ;
av_log ( s , AV_LOG_TRACE , "vprp %d/%d %d/%d\n" , active_aspect . num , active_aspect . den , active . num , active . den ) ;
}
size -= 9 * 4 ;
}
avio_skip ( pb , size ) ;
break ;
case MKTAG ( 's' , 't' , 'r' , 'n' ) : if ( s -> nb_streams ) {
ret = avi_read_tag ( s , s -> streams [ s -> nb_streams - 1 ] , tag , size ) ;
if ( ret < 0 ) return ret ;
break ;
}
default : if ( size > 1000000 ) {
av_log ( s , AV_LOG_ERROR , "Something went wrong during header parsing, " "tag %s has size %u, " "I will ignore it and try to continue anyway.\n" , av_fourcc2str ( tag ) , size ) ;
if ( s -> error_recognition & AV_EF_EXPLODE ) goto fail ;
avi -> movi_list = avio_tell ( pb ) - 4 ;
avi -> movi_end = avi -> fsize ;
goto end_of_header ;
}
case MKTAG ( 'i' , 'd' , 'x' , '1' ) : size += ( size & 1 ) ;
avio_skip ( pb , size ) ;
break ;
}
}
end_of_header : if ( stream_index != s -> nb_streams - 1 ) {
fail : return AVERROR_INVALIDDATA ;
}
if ( ! avi -> index_loaded && ( pb -> seekable & AVIO_SEEKABLE_NORMAL ) ) avi_load_index ( s ) ;
calculate_bitrate ( s ) ;
avi -> index_loaded |= 1 ;
if ( ( ret = guess_ni_flag ( s ) ) < 0 ) return ret ;
avi -> non_interleaved |= ret | ( s -> flags & AVFMT_FLAG_SORT_DTS ) ;
dict_entry = av_dict_get ( s -> metadata , "ISFT" , NULL , 0 ) ;
if ( dict_entry && ! strcmp ( dict_entry -> value , "PotEncoder" ) ) for ( i = 0 ;
i < s -> nb_streams ;
i ++ ) {
AVStream * st = s -> streams [ i ] ;
if ( st -> codecpar -> codec_id == AV_CODEC_ID_MPEG1VIDEO || st -> codecpar -> codec_id == AV_CODEC_ID_MPEG2VIDEO ) st -> need_parsing = AVSTREAM_PARSE_FULL ;
}
for ( i = 0 ;
i < s -> nb_streams ;
i ++ ) {
AVStream * st = s -> streams [ i ] ;
if ( st -> nb_index_entries ) break ;
}
if ( avi -> dv_demux ) avi -> non_interleaved = 0 ;
if ( i == s -> nb_streams && avi -> non_interleaved ) {
av_log ( s , AV_LOG_WARNING , "Non-interleaved AVI without index, switching to interleaved\n" ) ;
avi -> non_interleaved = 0 ;
}
if ( avi -> non_interleaved ) {
av_log ( s , AV_LOG_INFO , "non-interleaved AVI\n" ) ;
clean_index ( s ) ;
}
ff_metadata_conv_ctx ( s , NULL , avi_metadata_conv ) ;
ff_metadata_conv_ctx ( s , NULL , ff_riff_info_conv ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int proc_claiminterface ( struct usb_dev_state * ps , void __user * arg ) {
unsigned int ifnum ;
if ( get_user ( ifnum , ( unsigned int __user * ) arg ) ) return - EFAULT ;
return claimintf ( ps , ifnum ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_usb_video_control_interface_descriptor ( proto_tree * parent_tree , tvbuff_t * tvb , guint8 descriptor_len , packet_info * pinfo , usb_conv_info_t * usb_conv_info ) {
video_conv_info_t * video_conv_info = NULL ;
video_entity_t * entity = NULL ;
proto_item * item = NULL ;
proto_item * subtype_item = NULL ;
proto_tree * tree = NULL ;
guint8 entity_id = 0 ;
guint16 terminal_type = 0 ;
int offset = 0 ;
guint8 subtype ;
subtype = tvb_get_guint8 ( tvb , offset + 2 ) ;
if ( parent_tree ) {
const gchar * subtype_str ;
subtype_str = val_to_str_ext ( subtype , & vc_if_descriptor_subtypes_ext , "Unknown (0x%x)" ) ;
tree = proto_tree_add_subtree_format ( parent_tree , tvb , offset , descriptor_len , ett_descriptor_video_control , & item , "VIDEO CONTROL INTERFACE DESCRIPTOR [%s]" , subtype_str ) ;
}
dissect_usb_descriptor_header ( tree , tvb , offset , & vid_descriptor_type_vals_ext ) ;
subtype_item = proto_tree_add_item ( tree , hf_usb_vid_control_ifdesc_subtype , tvb , offset + 2 , 1 , ENC_LITTLE_ENDIAN ) ;
offset += 3 ;
if ( subtype == VC_HEADER ) {
guint8 num_vs_interfaces ;
proto_tree_add_item ( tree , hf_usb_vid_control_ifdesc_bcdUVC , tvb , offset , 2 , ENC_LITTLE_ENDIAN ) ;
proto_tree_add_item ( tree , hf_usb_vid_ifdesc_wTotalLength , tvb , offset + 2 , 2 , ENC_LITTLE_ENDIAN ) ;
proto_tree_add_item ( tree , hf_usb_vid_control_ifdesc_dwClockFrequency , tvb , offset + 4 , 4 , ENC_LITTLE_ENDIAN ) ;
num_vs_interfaces = tvb_get_guint8 ( tvb , offset + 8 ) ;
proto_tree_add_item ( tree , hf_usb_vid_control_ifdesc_bInCollection , tvb , offset + 8 , 1 , ENC_LITTLE_ENDIAN ) ;
if ( num_vs_interfaces > 0 ) {
proto_tree_add_item ( tree , hf_usb_vid_control_ifdesc_baInterfaceNr , tvb , offset + 9 , num_vs_interfaces , ENC_NA ) ;
}
offset += 9 + num_vs_interfaces ;
}
else if ( ( subtype == VC_INPUT_TERMINAL ) || ( subtype == VC_OUTPUT_TERMINAL ) ) {
entity_id = tvb_get_guint8 ( tvb , offset ) ;
terminal_type = tvb_get_letohs ( tvb , offset + 1 ) ;
proto_tree_add_item ( tree , hf_usb_vid_control_ifdesc_terminal_id , tvb , offset , 1 , ENC_LITTLE_ENDIAN ) ;
proto_tree_add_item ( tree , hf_usb_vid_control_ifdesc_terminal_type , tvb , offset + 1 , 2 , ENC_LITTLE_ENDIAN ) ;
proto_tree_add_item ( tree , hf_usb_vid_control_ifdesc_assoc_terminal , tvb , offset + 3 , 1 , ENC_LITTLE_ENDIAN ) ;
offset += 4 ;
if ( subtype == VC_OUTPUT_TERMINAL ) {
proto_tree_add_item ( tree , hf_usb_vid_control_ifdesc_src_id , tvb , offset , 1 , ENC_LITTLE_ENDIAN ) ;
++ offset ;
}
proto_tree_add_item ( tree , hf_usb_vid_control_ifdesc_iTerminal , tvb , offset , 1 , ENC_LITTLE_ENDIAN ) ;
++ offset ;
if ( subtype == VC_INPUT_TERMINAL ) {
if ( terminal_type == ITT_CAMERA ) {
offset = dissect_usb_video_camera_terminal ( tree , tvb , offset ) ;
}
else if ( terminal_type == ITT_MEDIA_TRANSPORT_INPUT ) {
}
}
if ( subtype == VC_OUTPUT_TERMINAL ) {
if ( terminal_type == OTT_MEDIA_TRANSPORT_OUTPUT ) {
}
}
}
else {
entity_id = tvb_get_guint8 ( tvb , offset ) ;
proto_tree_add_item ( tree , hf_usb_vid_control_ifdesc_unit_id , tvb , offset , 1 , ENC_LITTLE_ENDIAN ) ;
++ offset ;
if ( subtype == VC_PROCESSING_UNIT ) {
offset = dissect_usb_video_processing_unit ( tree , tvb , offset ) ;
}
else if ( subtype == VC_SELECTOR_UNIT ) {
offset = dissect_usb_video_selector_unit ( tree , tvb , offset ) ;
}
else if ( subtype == VC_EXTENSION_UNIT ) {
offset = dissect_usb_video_extension_unit ( tree , tvb , offset ) ;
}
else if ( subtype == VC_ENCODING_UNIT ) {
}
else {
expert_add_info_format ( pinfo , subtype_item , & ei_usb_vid_subtype_unknown , "Unknown VC subtype %u" , subtype ) ;
}
}
if ( offset < descriptor_len ) {
proto_tree_add_item ( tree , hf_usb_vid_descriptor_data , tvb , offset , descriptor_len - offset , ENC_NA ) ;
}
if ( entity_id != 0 ) proto_item_append_text ( item , " (Entity %d)" , entity_id ) ;
if ( subtype != VC_HEADER && usb_conv_info ) {
usb_conv_info = get_usb_iface_conv_info ( pinfo , usb_conv_info -> interfaceNum ) ;
video_conv_info = ( video_conv_info_t * ) usb_conv_info -> class_data ;
if ( ! video_conv_info ) {
video_conv_info = wmem_new ( wmem_file_scope ( ) , video_conv_info_t ) ;
video_conv_info -> entities = wmem_tree_new ( wmem_file_scope ( ) ) ;
usb_conv_info -> class_data = video_conv_info ;
}
entity = ( video_entity_t * ) wmem_tree_lookup32 ( video_conv_info -> entities , entity_id ) ;
if ( ! entity ) {
entity = wmem_new ( wmem_file_scope ( ) , video_entity_t ) ;
entity -> entityID = entity_id ;
entity -> subtype = subtype ;
entity -> terminalType = terminal_type ;
wmem_tree_insert32 ( video_conv_info -> entities , entity_id , entity ) ;
}
}
return descriptor_len ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
TSReturnCode TSHttpAltInfoCachedReqGet ( TSHttpAltInfo infop , TSMBuffer * bufp , TSMLoc * obj ) {
sdk_assert ( sdk_sanity_check_alt_info ( infop ) == TS_SUCCESS ) ;
HttpAltInfo * info = ( HttpAltInfo * ) infop ;
* ( reinterpret_cast < HTTPHdr * * > ( bufp ) ) = & info -> m_cached_req ;
* obj = reinterpret_cast < TSMLoc > ( info -> m_cached_req . m_http ) ;
return sdk_sanity_check_mbuffer ( * bufp ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int decode_cabac_mb_ref ( H264Context * h , int list , int n ) {
int refa = h -> ref_cache [ list ] [ scan8 [ n ] - 1 ] ;
int refb = h -> ref_cache [ list ] [ scan8 [ n ] - 8 ] ;
int ref = 0 ;
int ctx = 0 ;
if ( h -> slice_type_nos == AV_PICTURE_TYPE_B ) {
if ( refa > 0 && ! ( h -> direct_cache [ scan8 [ n ] - 1 ] & ( MB_TYPE_DIRECT2 >> 1 ) ) ) ctx ++ ;
if ( refb > 0 && ! ( h -> direct_cache [ scan8 [ n ] - 8 ] & ( MB_TYPE_DIRECT2 >> 1 ) ) ) ctx += 2 ;
}
else {
if ( refa > 0 ) ctx ++ ;
if ( refb > 0 ) ctx += 2 ;
}
while ( get_cabac ( & h -> cabac , & h -> cabac_state [ 54 + ctx ] ) ) {
ref ++ ;
ctx = ( ctx >> 2 ) + 4 ;
if ( ref >= 32 ) {
return - 1 ;
}
}
return ref ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TSNextProtocolSet TSGetcloneProtoSet ( TSAcceptor tna ) {
NetAccept * na = reinterpret_cast < NetAccept * > ( tna ) ;
return ( na && na -> snpa ) ? reinterpret_cast < TSNextProtocolSet > ( na -> snpa -> cloneProtoSet ( ) ) : nullptr ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
krb5_error_code krb5_read_tkt_policy ( krb5_context context , krb5_ldap_context * ldap_context , krb5_db_entry * entries , char * policy ) {
krb5_error_code st = 0 ;
int mask = 0 , omask = 0 ;
int tkt_mask = ( KDB_MAX_LIFE_ATTR | KDB_MAX_RLIFE_ATTR | KDB_TKT_FLAGS_ATTR ) ;
krb5_ldap_policy_params * tktpoldnparam = NULL ;
if ( ( st = krb5_get_attributes_mask ( context , entries , & mask ) ) != 0 ) goto cleanup ;
if ( ( mask & tkt_mask ) == tkt_mask ) goto cleanup ;
if ( policy != NULL ) {
st = krb5_ldap_read_policy ( context , policy , & tktpoldnparam , & omask ) ;
if ( st && st != KRB5_KDB_NOENTRY ) {
prepend_err_str ( context , _ ( "Error reading ticket policy. " ) , st , st ) ;
goto cleanup ;
}
st = 0 ;
}
if ( ( mask & KDB_MAX_LIFE_ATTR ) == 0 ) {
if ( ( omask & KDB_MAX_LIFE_ATTR ) == KDB_MAX_LIFE_ATTR ) entries -> max_life = tktpoldnparam -> maxtktlife ;
else if ( ldap_context -> lrparams -> max_life ) entries -> max_life = ldap_context -> lrparams -> max_life ;
}
if ( ( mask & KDB_MAX_RLIFE_ATTR ) == 0 ) {
if ( ( omask & KDB_MAX_RLIFE_ATTR ) == KDB_MAX_RLIFE_ATTR ) entries -> max_renewable_life = tktpoldnparam -> maxrenewlife ;
else if ( ldap_context -> lrparams -> max_renewable_life ) entries -> max_renewable_life = ldap_context -> lrparams -> max_renewable_life ;
}
if ( ( mask & KDB_TKT_FLAGS_ATTR ) == 0 ) {
if ( ( omask & KDB_TKT_FLAGS_ATTR ) == KDB_TKT_FLAGS_ATTR ) entries -> attributes = tktpoldnparam -> tktflags ;
else if ( ldap_context -> lrparams -> tktflags ) entries -> attributes |= ldap_context -> lrparams -> tktflags ;
}
krb5_ldap_free_policy ( context , tktpoldnparam ) ;
cleanup : return st ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void final_reordering_syllable ( const hb_ot_shape_plan_t * plan , hb_buffer_t * buffer , unsigned int start , unsigned int end ) {
const indic_shape_plan_t * indic_plan = ( const indic_shape_plan_t * ) plan -> data ;
hb_glyph_info_t * info = buffer -> info ;
if ( indic_plan -> virama_glyph ) {
unsigned int virama_glyph = indic_plan -> virama_glyph ;
for ( unsigned int i = start ;
i < end ;
i ++ ) if ( info [ i ] . codepoint == virama_glyph && _hb_glyph_info_ligated ( & info [ i ] ) && _hb_glyph_info_multiplied ( & info [ i ] ) ) {
info [ i ] . indic_category ( ) = OT_H ;
_hb_glyph_info_clear_ligated_and_multiplied ( & info [ i ] ) ;
}
}
bool try_pref = ! ! indic_plan -> mask_array [ PREF ] ;
unsigned int base ;
for ( base = start ;
base < end ;
base ++ ) if ( info [ base ] . indic_position ( ) >= POS_BASE_C ) {
if ( try_pref && base + 1 < end && indic_plan -> config -> pref_len == 2 ) {
for ( unsigned int i = base + 1 ;
i < end ;
i ++ ) if ( ( info [ i ] . mask & indic_plan -> mask_array [ PREF ] ) != 0 ) {
if ( ! ( _hb_glyph_info_substituted ( & info [ i ] ) && _hb_glyph_info_ligated_and_didnt_multiply ( & info [ i ] ) ) ) {
base = i ;
while ( base < end && is_halant_or_coeng ( info [ base ] ) ) base ++ ;
info [ base ] . indic_position ( ) = POS_BASE_C ;
try_pref = false ;
}
break ;
}
}
if ( start < base && info [ base ] . indic_position ( ) > POS_BASE_C ) base -- ;
break ;
}
if ( base == end && start < base && is_one_of ( info [ base - 1 ] , FLAG ( OT_ZWJ ) ) ) base -- ;
if ( base < end ) while ( start < base && is_one_of ( info [ base ] , ( FLAG ( OT_N ) | HALANT_OR_COENG_FLAGS ) ) ) base -- ;
if ( start + 1 < end && start < base ) {
unsigned int new_pos = base == end ? base - 2 : base - 1 ;
if ( buffer -> props . script != HB_SCRIPT_MALAYALAM && buffer -> props . script != HB_SCRIPT_TAMIL ) {
while ( new_pos > start && ! ( is_one_of ( info [ new_pos ] , ( FLAG ( OT_M ) | HALANT_OR_COENG_FLAGS ) ) ) ) new_pos -- ;
if ( is_halant_or_coeng ( info [ new_pos ] ) && info [ new_pos ] . indic_position ( ) != POS_PRE_M ) {
if ( new_pos + 1 < end && is_joiner ( info [ new_pos + 1 ] ) ) new_pos ++ ;
}
else new_pos = start ;
}
if ( start < new_pos && info [ new_pos ] . indic_position ( ) != POS_PRE_M ) {
for ( unsigned int i = new_pos ;
i > start ;
i -- ) if ( info [ i - 1 ] . indic_position ( ) == POS_PRE_M ) {
unsigned int old_pos = i - 1 ;
hb_glyph_info_t tmp = info [ old_pos ] ;
memmove ( & info [ old_pos ] , & info [ old_pos + 1 ] , ( new_pos - old_pos ) * sizeof ( info [ 0 ] ) ) ;
info [ new_pos ] = tmp ;
if ( old_pos < base && base <= new_pos ) base -- ;
buffer -> merge_clusters ( new_pos , MIN ( end , base + 1 ) ) ;
new_pos -- ;
}
}
else {
for ( unsigned int i = start ;
i < base ;
i ++ ) if ( info [ i ] . indic_position ( ) == POS_PRE_M ) {
buffer -> merge_clusters ( i , MIN ( end , base + 1 ) ) ;
break ;
}
}
}
if ( start + 1 < end && info [ start ] . indic_position ( ) == POS_RA_TO_BECOME_REPH && ( ( info [ start ] . indic_category ( ) == OT_Repha ) ^ _hb_glyph_info_ligated_and_didnt_multiply ( & info [ start ] ) ) ) {
unsigned int new_reph_pos ;
reph_position_t reph_pos = indic_plan -> config -> reph_pos ;
assert ( reph_pos != REPH_POS_DONT_CARE ) ;
if ( reph_pos == REPH_POS_AFTER_POST ) {
goto reph_step_5 ;
}
{
new_reph_pos = start + 1 ;
while ( new_reph_pos < base && ! is_halant_or_coeng ( info [ new_reph_pos ] ) ) new_reph_pos ++ ;
if ( new_reph_pos < base && is_halant_or_coeng ( info [ new_reph_pos ] ) ) {
if ( new_reph_pos + 1 < base && is_joiner ( info [ new_reph_pos + 1 ] ) ) new_reph_pos ++ ;
goto reph_move ;
}
}
if ( reph_pos == REPH_POS_AFTER_MAIN ) {
new_reph_pos = base ;
while ( new_reph_pos + 1 < end && info [ new_reph_pos + 1 ] . indic_position ( ) <= POS_AFTER_MAIN ) new_reph_pos ++ ;
if ( new_reph_pos < end ) goto reph_move ;
}
if ( reph_pos == REPH_POS_AFTER_SUB ) {
new_reph_pos = base ;
while ( new_reph_pos < end && ! ( FLAG ( info [ new_reph_pos + 1 ] . indic_position ( ) ) & ( FLAG ( POS_POST_C ) | FLAG ( POS_AFTER_POST ) | FLAG ( POS_SMVD ) ) ) ) new_reph_pos ++ ;
if ( new_reph_pos < end ) goto reph_move ;
}
reph_step_5 : {
new_reph_pos = start + 1 ;
while ( new_reph_pos < base && ! is_halant_or_coeng ( info [ new_reph_pos ] ) ) new_reph_pos ++ ;
if ( new_reph_pos < base && is_halant_or_coeng ( info [ new_reph_pos ] ) ) {
if ( new_reph_pos + 1 < base && is_joiner ( info [ new_reph_pos + 1 ] ) ) new_reph_pos ++ ;
goto reph_move ;
}
}
{
new_reph_pos = end - 1 ;
while ( new_reph_pos > start && info [ new_reph_pos ] . indic_position ( ) == POS_SMVD ) new_reph_pos -- ;
if ( ! hb_options ( ) . uniscribe_bug_compatible && unlikely ( is_halant_or_coeng ( info [ new_reph_pos ] ) ) ) {
for ( unsigned int i = base + 1 ;
i < new_reph_pos ;
i ++ ) if ( info [ i ] . indic_category ( ) == OT_M ) {
new_reph_pos -- ;
}
}
goto reph_move ;
}
reph_move : {
buffer -> merge_clusters ( start , new_reph_pos + 1 ) ;
hb_glyph_info_t reph = info [ start ] ;
memmove ( & info [ start ] , & info [ start + 1 ] , ( new_reph_pos - start ) * sizeof ( info [ 0 ] ) ) ;
info [ new_reph_pos ] = reph ;
if ( start < base && base <= new_reph_pos ) base -- ;
}
}
if ( try_pref && base + 1 < end ) {
unsigned int pref_len = indic_plan -> config -> pref_len ;
for ( unsigned int i = base + 1 ;
i < end ;
i ++ ) if ( ( info [ i ] . mask & indic_plan -> mask_array [ PREF ] ) != 0 ) {
if ( _hb_glyph_info_substituted ( & info [ i ] ) && ( ( pref_len == 1 ) ^ _hb_glyph_info_ligated_and_didnt_multiply ( & info [ i ] ) ) ) {
unsigned int new_pos = base ;
if ( buffer -> props . script != HB_SCRIPT_MALAYALAM && buffer -> props . script != HB_SCRIPT_TAMIL ) {
while ( new_pos > start && ! ( is_one_of ( info [ new_pos - 1 ] , FLAG ( OT_M ) | HALANT_OR_COENG_FLAGS ) ) ) new_pos -- ;
if ( new_pos > start && info [ new_pos - 1 ] . indic_category ( ) == OT_M ) {
unsigned int old_pos = i ;
for ( unsigned int i = base + 1 ;
i < old_pos ;
i ++ ) if ( info [ i ] . indic_category ( ) == OT_M ) {
new_pos -- ;
break ;
}
}
}
if ( new_pos > start && is_halant_or_coeng ( info [ new_pos - 1 ] ) ) {
if ( new_pos < end && is_joiner ( info [ new_pos ] ) ) new_pos ++ ;
}
{
unsigned int old_pos = i ;
buffer -> merge_clusters ( new_pos , old_pos + 1 ) ;
hb_glyph_info_t tmp = info [ old_pos ] ;
memmove ( & info [ new_pos + 1 ] , & info [ new_pos ] , ( old_pos - new_pos ) * sizeof ( info [ 0 ] ) ) ;
info [ new_pos ] = tmp ;
if ( new_pos <= base && base < old_pos ) base ++ ;
}
}
break ;
}
}
if ( info [ start ] . indic_position ( ) == POS_PRE_M && ( ! start || ! ( FLAG ( _hb_glyph_info_get_general_category ( & info [ start - 1 ] ) ) & FLAG_RANGE ( HB_UNICODE_GENERAL_CATEGORY_FORMAT , HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK ) ) ) ) info [ start ] . mask |= indic_plan -> mask_array [ INIT ] ;
if ( hb_options ( ) . uniscribe_bug_compatible ) {
switch ( ( hb_tag_t ) plan -> props . script ) {
case HB_SCRIPT_TAMIL : case HB_SCRIPT_SINHALA : break ;
default : buffer -> merge_clusters ( start , end ) ;
break ;
}
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
void proto_reg_handoff_btavdtp ( void ) {
dissector_add_string ( "bluetooth.uuid" , "19" , btavdtp_handle ) ;
dissector_add_uint ( "btl2cap.psm" , BTL2CAP_PSM_AVDTP , btavdtp_handle ) ;
dissector_add_for_decode_as ( "btl2cap.cid" , btavdtp_handle ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
GPtrArray * proto_get_finfo_ptr_array ( const proto_tree * tree , const int id ) {
if ( ! tree ) return NULL ;
if ( PTREE_DATA ( tree ) -> interesting_hfids != NULL ) return ( GPtrArray * ) g_hash_table_lookup ( PTREE_DATA ( tree ) -> interesting_hfids , GINT_TO_POINTER ( id ) ) ;
else return NULL ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline int op ( uint8_t * * dst , const uint8_t * dst_end , GetByteContext * gb , int pixel , int count , int * x , int width , int linesize ) {
int remaining = width - * x ;
while ( count > 0 ) {
int striplen = FFMIN ( count , remaining ) ;
if ( gb ) {
if ( bytestream2_get_bytes_left ( gb ) < striplen ) goto exhausted ;
bytestream2_get_bufferu ( gb , * dst , striplen ) ;
}
else if ( pixel >= 0 ) memset ( * dst , pixel , striplen ) ;
* dst += striplen ;
remaining -= striplen ;
count -= striplen ;
if ( remaining <= 0 ) {
* dst += linesize - width ;
remaining = width ;
}
if ( linesize > 0 ) {
if ( * dst >= dst_end ) goto exhausted ;
}
else {
if ( * dst <= dst_end ) goto exhausted ;
}
}
* x = width - remaining ;
return 0 ;
exhausted : * x = width - remaining ;
return 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void pdf_run_TJ ( fz_context * ctx , pdf_processor * proc , pdf_obj * obj ) {
pdf_run_processor * pr = ( pdf_run_processor * ) proc ;
pdf_show_text ( ctx , pr , obj ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void intra_pred_dc_128 ( uint8_t * d , uint8_t * top , uint8_t * left , int stride ) {
int y ;
uint64_t a = 0x8080808080808080ULL ;
for ( y = 0 ;
y < 8 ;
y ++ ) * ( ( uint64_t * ) ( d + y * stride ) ) = a ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int * __xmlDoValidityCheckingDefaultValue ( void ) {
if ( IS_MAIN_THREAD ) return ( & xmlDoValidityCheckingDefaultValue ) ;
else return ( & xmlGetGlobalState ( ) -> xmlDoValidityCheckingDefaultValue ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void real_proto_register_diameter ( void ) {
module_t * diameter_module ;
expert_module_t * expert_diameter ;
guint i , ett_length ;
hf_register_info hf_base [ ] = {
{
& hf_diameter_version , {
"Version" , "diameter.version" , FT_UINT8 , BASE_HEX , NULL , 0x00 , NULL , HFILL }
}
, {
& hf_diameter_length , {
"Length" , "diameter.length" , FT_UINT24 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_diameter_flags , {
"Flags" , "diameter.flags" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_diameter_flags_request , {
"Request" , "diameter.flags.request" , FT_BOOLEAN , 8 , TFS ( & tfs_set_notset ) , DIAM_FLAGS_R , NULL , HFILL }
}
, {
& hf_diameter_flags_proxyable , {
"Proxyable" , "diameter.flags.proxyable" , FT_BOOLEAN , 8 , TFS ( & tfs_set_notset ) , DIAM_FLAGS_P , NULL , HFILL }
}
, {
& hf_diameter_flags_error , {
"Error" , "diameter.flags.error" , FT_BOOLEAN , 8 , TFS ( & tfs_set_notset ) , DIAM_FLAGS_E , NULL , HFILL }
}
, {
& hf_diameter_flags_T , {
"T(Potentially re-transmitted message)" , "diameter.flags.T" , FT_BOOLEAN , 8 , TFS ( & tfs_set_notset ) , DIAM_FLAGS_T , NULL , HFILL }
}
, {
& hf_diameter_flags_reserved4 , {
"Reserved" , "diameter.flags.reserved4" , FT_BOOLEAN , 8 , TFS ( & tfs_set_notset ) , DIAM_FLAGS_RESERVED4 , NULL , HFILL }
}
, {
& hf_diameter_flags_reserved5 , {
"Reserved" , "diameter.flags.reserved5" , FT_BOOLEAN , 8 , TFS ( & tfs_set_notset ) , DIAM_FLAGS_RESERVED5 , NULL , HFILL }
}
, {
& hf_diameter_flags_reserved6 , {
"Reserved" , "diameter.flags.reserved6" , FT_BOOLEAN , 8 , TFS ( & tfs_set_notset ) , DIAM_FLAGS_RESERVED6 , NULL , HFILL }
}
, {
& hf_diameter_flags_reserved7 , {
"Reserved" , "diameter.flags.reserved7" , FT_BOOLEAN , 8 , TFS ( & tfs_set_notset ) , DIAM_FLAGS_RESERVED7 , NULL , HFILL }
}
, {
& hf_diameter_vendor_id , {
"VendorId" , "diameter.vendorId" , FT_UINT32 , BASE_DEC | BASE_EXT_STRING , & sminmpec_values_ext , 0x0 , NULL , HFILL }
}
, {
& hf_diameter_application_id , {
"ApplicationId" , "diameter.applicationId" , FT_UINT32 , BASE_DEC | BASE_EXT_STRING , VALS_EXT_PTR ( dictionary . applications ) , 0x0 , NULL , HFILL }
}
, {
& hf_diameter_hopbyhopid , {
"Hop-by-Hop Identifier" , "diameter.hopbyhopid" , FT_UINT32 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_diameter_endtoendid , {
"End-to-End Identifier" , "diameter.endtoendid" , FT_UINT32 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_diameter_avp , {
"AVP" , "diameter.avp" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_diameter_avp_len , {
"AVP Length" , "diameter.avp.len" , FT_UINT24 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_diameter_avp_code , {
"AVP Code" , "diameter.avp.code" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_diameter_avp_flags , {
"AVP Flags" , "diameter.avp.flags" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_diameter_avp_flags_vendor_specific , {
"Vendor-Specific" , "diameter.flags.vendorspecific" , FT_BOOLEAN , 8 , TFS ( & tfs_set_notset ) , AVP_FLAGS_V , NULL , HFILL }
}
, {
& hf_diameter_avp_flags_mandatory , {
"Mandatory" , "diameter.flags.mandatory" , FT_BOOLEAN , 8 , TFS ( & tfs_set_notset ) , AVP_FLAGS_M , NULL , HFILL }
}
, {
& hf_diameter_avp_flags_protected , {
"Protected" , "diameter.avp.flags.protected" , FT_BOOLEAN , 8 , TFS ( & tfs_set_notset ) , AVP_FLAGS_P , NULL , HFILL }
}
, {
& hf_diameter_avp_flags_reserved3 , {
"Reserved" , "diameter.avp.flags.reserved3" , FT_BOOLEAN , 8 , TFS ( & tfs_set_notset ) , AVP_FLAGS_RESERVED3 , NULL , HFILL }
}
, {
& hf_diameter_avp_flags_reserved4 , {
"Reserved" , "diameter.avp.flags.reserved4" , FT_BOOLEAN , 8 , TFS ( & tfs_set_notset ) , AVP_FLAGS_RESERVED4 , NULL , HFILL }
}
, {
& hf_diameter_avp_flags_reserved5 , {
"Reserved" , "diameter.avp.flags.reserved5" , FT_BOOLEAN , 8 , TFS ( & tfs_set_notset ) , AVP_FLAGS_RESERVED5 , NULL , HFILL }
}
, {
& hf_diameter_avp_flags_reserved6 , {
"Reserved" , "diameter.avp.flags.reserved6" , FT_BOOLEAN , 8 , TFS ( & tfs_set_notset ) , AVP_FLAGS_RESERVED6 , NULL , HFILL }
}
, {
& hf_diameter_avp_flags_reserved7 , {
"Reserved" , "diameter.avp.flags.reserved7" , FT_BOOLEAN , 8 , TFS ( & tfs_set_notset ) , AVP_FLAGS_RESERVED7 , NULL , HFILL }
}
, {
& hf_diameter_avp_vendor_id , {
"AVP Vendor Id" , "diameter.avp.vendorId" , FT_UINT32 , BASE_DEC | BASE_EXT_STRING , & sminmpec_values_ext , 0x0 , NULL , HFILL }
}
, {
& ( unknown_avp . hf_value ) , {
"Value" , "diameter.avp.unknown" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_diameter_avp_data_wrong_length , {
"Data" , "diameter.avp.invalid-data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_diameter_avp_pad , {
"Padding" , "diameter.avp.pad" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_diameter_code , {
"Command Code" , "diameter.cmd.code" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_diameter_answer_in , {
"Answer In" , "diameter.answer_in" , FT_FRAMENUM , BASE_NONE , FRAMENUM_TYPE ( FT_FRAMENUM_RESPONSE ) , 0x0 , "The answer to this diameter request is in this frame" , HFILL }
}
, {
& hf_diameter_answer_to , {
"Request In" , "diameter.answer_to" , FT_FRAMENUM , BASE_NONE , FRAMENUM_TYPE ( FT_FRAMENUM_REQUEST ) , 0x0 , "This is an answer to the diameter request in this frame" , HFILL }
}
, {
& hf_diameter_answer_time , {
"Response Time" , "diameter.resp_time" , FT_RELATIVE_TIME , BASE_NONE , NULL , 0x0 , "The time between the request and the answer" , HFILL }
}
, {
& hf_framed_ipv6_prefix_reserved , {
"Framed IPv6 Prefix Reserved byte" , "diameter.framed_ipv6_prefix_reserved" , FT_UINT8 , BASE_HEX , NULL , 0 , NULL , HFILL }
}
, {
& hf_framed_ipv6_prefix_length , {
"Framed IPv6 Prefix length (in bits)" , "diameter.framed_ipv6_prefix_length" , FT_UINT8 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_framed_ipv6_prefix_bytes , {
"Framed IPv6 Prefix as a bytestring" , "diameter.framed_ipv6_prefix_bytes" , FT_BYTES , BASE_NONE , NULL , 0 , NULL , HFILL }
}
, {
& hf_framed_ipv6_prefix_ipv6 , {
"Framed IPv6 Prefix as an IPv6 address" , "diameter.framed_ipv6_prefix_ipv6" , FT_IPv6 , BASE_NONE , NULL , 0 , "This field is present only if the prefix length is 128" , HFILL }
}
, {
& hf_diameter_3gpp2_exp_res , {
"Experimental-Result-Code" , "diameter.3gpp2.exp_res" , FT_UINT32 , BASE_DEC , VALS ( diameter_3gpp2_exp_res_vals ) , 0x0 , NULL , HFILL }
}
, {
& hf_diameter_other_vendor_exp_res , {
"Experimental-Result-Code" , "diameter.other_vendor.Experimental-Result-Code" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
}
;
gint * ett_base [ ] = {
& ett_diameter , & ett_diameter_flags , & ett_diameter_avp_flags , & ett_diameter_avpinfo , & ett_unknown , & ett_err , & ( unknown_avp . ett ) }
;
static ei_register_info ei [ ] = {
{
& ei_diameter_reserved_bit_set , {
"diameter.reserved_bit_set" , PI_MALFORMED , PI_WARN , "Reserved bit set" , EXPFILL }
}
, {
& ei_diameter_avp_code , {
"diameter.avp.code.unknown" , PI_UNDECODED , PI_WARN , "Unknown AVP, if you know what this is you can add it to dictionary.xml" , EXPFILL }
}
, {
& ei_diameter_avp_vendor_id , {
"diameter.unknown_vendor" , PI_UNDECODED , PI_WARN , "Unknown Vendor, if you know whose this is you can add it to dictionary.xml" , EXPFILL }
}
, {
& ei_diameter_avp_no_data , {
"diameter.avp.no_data" , PI_UNDECODED , PI_WARN , "Data is empty" , EXPFILL }
}
, {
& ei_diameter_avp_pad , {
"diameter.avp.pad.non_zero" , PI_MALFORMED , PI_NOTE , "Padding is non-zero" , EXPFILL }
}
, {
& ei_diameter_avp_len , {
"diameter.avp.invalid-len" , PI_MALFORMED , PI_WARN , "Wrong length" , EXPFILL }
}
, {
& ei_diameter_application_id , {
"diameter.applicationId.unknown" , PI_UNDECODED , PI_WARN , "Unknown Application Id, if you know what this is you can add it to dictionary.xml" , EXPFILL }
}
, {
& ei_diameter_version , {
"diameter.version.unknown" , PI_UNDECODED , PI_WARN , "Unknown Diameter Version (decoding as RFC 3588)" , EXPFILL }
}
, {
& ei_diameter_code , {
"diameter.cmd.code.unknown" , PI_UNDECODED , PI_WARN , "Unknown command, if you know what this is you can add it to dictionary.xml" , EXPFILL }
}
, }
;
wmem_array_append ( build_dict . hf , hf_base , array_length ( hf_base ) ) ;
ett_length = array_length ( ett_base ) ;
for ( i = 0 ;
i < ett_length ;
i ++ ) {
g_ptr_array_add ( build_dict . ett , ett_base [ i ] ) ;
}
proto_diameter = proto_register_protocol ( "Diameter Protocol" , "DIAMETER" , "diameter" ) ;
proto_register_field_array ( proto_diameter , ( hf_register_info * ) wmem_array_get_raw ( build_dict . hf ) , wmem_array_get_count ( build_dict . hf ) ) ;
proto_register_subtree_array ( ( gint * * ) build_dict . ett -> pdata , build_dict . ett -> len ) ;
expert_diameter = expert_register_protocol ( proto_diameter ) ;
expert_register_field_array ( expert_diameter , ei , array_length ( ei ) ) ;
g_ptr_array_free ( build_dict . ett , TRUE ) ;
new_register_dissector ( "diameter" , dissect_diameter , proto_diameter ) ;
diameter_dissector_table = register_dissector_table ( "diameter.base" , "DIAMETER_BASE_AVPS" , FT_UINT32 , BASE_DEC , DISSECTOR_TABLE_ALLOW_DUPLICATE ) ;
diameter_3gpp_avp_dissector_table = register_dissector_table ( "diameter.3gpp" , "DIAMETER_3GPP_AVPS" , FT_UINT32 , BASE_DEC , DISSECTOR_TABLE_ALLOW_DUPLICATE ) ;
diameter_ericsson_avp_dissector_table = register_dissector_table ( "diameter.ericsson" , "DIAMETER_ERICSSON_AVPS" , FT_UINT32 , BASE_DEC , DISSECTOR_TABLE_ALLOW_DUPLICATE ) ;
diameter_expr_result_vnd_table = register_dissector_table ( "diameter.vnd_exp_res" , "DIAMETER Experimental-Result-Code" , FT_UINT32 , BASE_DEC , DISSECTOR_TABLE_ALLOW_DUPLICATE ) ;
range_convert_str ( & global_diameter_tcp_port_range , DEFAULT_DIAMETER_PORT_RANGE , MAX_UDP_PORT ) ;
range_convert_str ( & global_diameter_sctp_port_range , DEFAULT_DIAMETER_PORT_RANGE , MAX_SCTP_PORT ) ;
range_convert_str ( & global_diameter_udp_port_range , "" , MAX_UDP_PORT ) ;
diameter_module = prefs_register_protocol ( proto_diameter , proto_reg_handoff_diameter ) ;
prefs_register_range_preference ( diameter_module , "tcp.ports" , "Diameter TCP ports" , "TCP ports to be decoded as Diameter (default: " DEFAULT_DIAMETER_PORT_RANGE ")" , & global_diameter_tcp_port_range , MAX_UDP_PORT ) ;
prefs_register_range_preference ( diameter_module , "sctp.ports" , "Diameter SCTP Ports" , "SCTP ports to be decoded as Diameter (default: " DEFAULT_DIAMETER_PORT_RANGE ")" , & global_diameter_sctp_port_range , MAX_SCTP_PORT ) ;
prefs_register_bool_preference ( diameter_module , "desegment" , "Reassemble Diameter messages\nspanning multiple TCP segments" , "Whether the Diameter dissector should reassemble messages spanning multiple TCP segments." " To use this option, you must also enable \"Allow subdissectors to reassemble TCP streams\" in the TCP protocol settings." , & gbl_diameter_desegment ) ;
prefs_register_range_preference ( diameter_module , "udp.ports" , "Diameter UDP ports" , "UDP ports to be decoded as Diameter (default: 0 as Diameter over UDP is nonstandard)" , & global_diameter_udp_port_range , MAX_UDP_PORT ) ;
prefs_register_obsolete_preference ( diameter_module , "version" ) ;
prefs_register_obsolete_preference ( diameter_module , "tcp.port" ) ;
prefs_register_obsolete_preference ( diameter_module , "sctp.port" ) ;
prefs_register_obsolete_preference ( diameter_module , "command_in_header" ) ;
prefs_register_obsolete_preference ( diameter_module , "dictionary.name" ) ;
prefs_register_obsolete_preference ( diameter_module , "dictionary.use" ) ;
prefs_register_obsolete_preference ( diameter_module , "allow_zero_as_app_id" ) ;
prefs_register_obsolete_preference ( diameter_module , "suppress_console_output" ) ;
diameter_tap = register_tap ( "diameter" ) ;
register_srt_table ( proto_diameter , NULL , 1 , diameterstat_packet , diameterstat_init , NULL ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static UBool _isPrivateuseVariantSubtag ( const char * s , int32_t len ) {
if ( len < 0 ) {
len = ( int32_t ) uprv_strlen ( s ) ;
}
if ( len >= 1 && len <= 8 && _isAlphaNumericString ( s , len ) ) {
return TRUE ;
}
return FALSE ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int selinux_mount ( const char * dev_name , const struct path * path , const char * type , unsigned long flags , void * data ) {
const struct cred * cred = current_cred ( ) ;
if ( flags & MS_REMOUNT ) return superblock_has_perm ( cred , path -> dentry -> d_sb , FILESYSTEM__REMOUNT , NULL ) ;
else return path_has_perm ( cred , path , FILE__MOUNTON ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
GPtrArray * proto_all_finfos ( proto_tree * tree ) {
ffdata_t ffdata ;
ffdata . array = g_ptr_array_new ( ) ;
ffdata . id = 0 ;
proto_tree_traverse_pre_order ( tree , every_finfo , & ffdata ) ;
return ffdata . array ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void get_dav_remote_heads ( void ) {
remote_ls ( "refs/" , ( PROCESS_FILES | PROCESS_DIRS | RECURSIVE ) , process_ls_ref , NULL ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static PGconn * get_db_conn ( ClusterInfo * cluster , const char * db_name ) {
PQExpBufferData conn_opts ;
PGconn * conn ;
initPQExpBuffer ( & conn_opts ) ;
appendPQExpBufferStr ( & conn_opts , "dbname=" ) ;
appendConnStrVal ( & conn_opts , db_name ) ;
appendPQExpBufferStr ( & conn_opts , " user=" ) ;
appendConnStrVal ( & conn_opts , os_info . user ) ;
appendPQExpBuffer ( & conn_opts , " port=%d" , cluster -> port ) ;
if ( cluster -> sockdir ) {
appendPQExpBufferStr ( & conn_opts , " host=" ) ;
appendConnStrVal ( & conn_opts , cluster -> sockdir ) ;
}
conn = PQconnectdb ( conn_opts . data ) ;
termPQExpBuffer ( & conn_opts ) ;
return conn ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
u_int sl_if_print ( netdissect_options * ndo , const struct pcap_pkthdr * h , const u_char * p ) {
register u_int caplen = h -> caplen ;
register u_int length = h -> len ;
register const struct ip * ip ;
if ( caplen < SLIP_HDRLEN || length < SLIP_HDRLEN ) {
ND_PRINT ( ( ndo , "%s" , tstr ) ) ;
return ( caplen ) ;
}
caplen -= SLIP_HDRLEN ;
length -= SLIP_HDRLEN ;
ip = ( const struct ip * ) ( p + SLIP_HDRLEN ) ;
if ( ndo -> ndo_eflag ) sliplink_print ( ndo , p , ip , length ) ;
if ( caplen < 1 || length < 1 ) {
ND_PRINT ( ( ndo , "%s" , tstr ) ) ;
return ( caplen + SLIP_HDRLEN ) ;
}
switch ( IP_V ( ip ) ) {
case 4 : ip_print ( ndo , ( const u_char * ) ip , length ) ;
break ;
case 6 : ip6_print ( ndo , ( const u_char * ) ip , length ) ;
break ;
default : ND_PRINT ( ( ndo , "ip v%d" , IP_V ( ip ) ) ) ;
}
return ( SLIP_HDRLEN ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void dissect_rsvp_message_id_ack ( proto_tree * ti , proto_tree * rsvp_object_tree , tvbuff_t * tvb , int offset , int obj_length , int rsvp_class _U_ , int type ) {
int offset2 = offset + 4 ;
switch ( type ) {
case 1 : proto_tree_add_uint ( rsvp_object_tree , hf_rsvp_ctype , tvb , offset + 3 , 1 , type ) ;
proto_tree_add_item ( rsvp_object_tree , hf_rsvp_message_id_ack_flags , tvb , offset + 4 , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_object_tree , hf_rsvp_message_id_ack_epoch , tvb , offset + 5 , 3 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_object_tree , hf_rsvp_message_id_ack_message_id , tvb , offset + 8 , 4 , ENC_BIG_ENDIAN ) ;
proto_item_set_text ( ti , "MESSAGE-ID ACK: %d" , tvb_get_ntohl ( tvb , offset + 8 ) ) ;
break ;
case 2 : proto_tree_add_uint ( rsvp_object_tree , hf_rsvp_ctype , tvb , offset + 3 , 1 , type ) ;
proto_tree_add_item ( rsvp_object_tree , hf_rsvp_message_id_ack_flags , tvb , offset + 4 , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_object_tree , hf_rsvp_message_id_ack_epoch , tvb , offset + 5 , 3 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_object_tree , hf_rsvp_message_id_ack_message_id , tvb , offset + 8 , 4 , ENC_BIG_ENDIAN ) ;
proto_item_set_text ( ti , "MESSAGE-ID NACK: %d" , tvb_get_ntohl ( tvb , offset + 8 ) ) ;
break ;
default : proto_tree_add_uint_format_value ( rsvp_object_tree , hf_rsvp_ctype , tvb , offset + 3 , 1 , type , "Unknown (%u)" , type ) ;
proto_tree_add_item ( rsvp_object_tree , hf_rsvp_message_id_ack_data , tvb , offset2 , obj_length - 4 , ENC_NA ) ;
break ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( FramebustBlockBrowserTest , FramebustAllowedBySiteSetting ) {
GURL top_level_url = embedded_test_server ( ) -> GetURL ( "/iframe.html" ) ;
HostContentSettingsMap * settings_map = HostContentSettingsMapFactory : : GetForProfile ( browser ( ) -> profile ( ) ) ;
settings_map -> SetContentSettingDefaultScope ( top_level_url , GURL ( ) , CONTENT_SETTINGS_TYPE_POPUPS , std : : string ( ) , CONTENT_SETTING_ALLOW ) ;
CreateAndSetBrowser ( ) ;
ui_test_utils : : NavigateToURL ( browser ( ) , top_level_url ) ;
NavigateIframeToUrlWithoutGesture ( GetWebContents ( ) , "test" , embedded_test_server ( ) -> GetURL ( "a.com" , "/title1.html" ) ) ;
content : : RenderFrameHost * child = content : : ChildFrameAt ( GetWebContents ( ) -> GetMainFrame ( ) , 0 ) ;
ASSERT_TRUE ( child ) ;
GURL redirect_url = embedded_test_server ( ) -> GetURL ( "b.com" , "/title1.html" ) ;
content : : TestNavigationObserver observer ( GetWebContents ( ) ) ;
child -> ExecuteJavaScriptForTests ( base : : ASCIIToUTF16 ( base : : StringPrintf ( "window.top.location = '%s';
" , redirect_url . spec ( ) . c_str ( ) ) ) ) ;
observer . Wait ( ) ;
EXPECT_TRUE ( GetFramebustTabHelper ( ) -> blocked_urls ( ) . empty ( ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int jas_stream_getc_func ( jas_stream_t * stream ) {
assert ( stream -> ptr_ - stream -> bufbase_ <= stream -> bufsize_ + JAS_STREAM_MAXPUTBACK ) ;
return jas_stream_getc_macro ( stream ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void stroke_initiate ( private_stroke_socket_t * this , stroke_msg_t * msg , FILE * out ) {
pop_string ( msg , & msg -> initiate . name ) ;
DBG1 ( DBG_CFG , "received stroke: initiate '%s'" , msg -> initiate . name ) ;
this -> control -> initiate ( this -> control , msg , out ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static const char * csv_escape_str ( AVBPrint * dst , const char * src , const char sep , void * log_ctx ) {
char meta_chars [ ] = {
sep , '"' , '\n' , '\r' , '\0' }
;
int needs_quoting = ! ! src [ strcspn ( src , meta_chars ) ] ;
if ( needs_quoting ) av_bprint_chars ( dst , '"' , 1 ) ;
for ( ;
* src ;
src ++ ) {
if ( * src == '"' ) av_bprint_chars ( dst , '"' , 1 ) ;
av_bprint_chars ( dst , * src , 1 ) ;
}
if ( needs_quoting ) av_bprint_chars ( dst , '"' , 1 ) ;
return dst -> str ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void virLogStackTraceToFd ( int fd ) {
void * array [ 100 ] ;
int size ;
static bool doneWarning ;
const char * msg = "Stack trace not available on this platform\n" ;
# define STRIP_DEPTH 3 size = backtrace ( array , ARRAY_CARDINALITY ( array ) ) ;
if ( size ) {
backtrace_symbols_fd ( array + STRIP_DEPTH , size - STRIP_DEPTH , fd ) ;
ignore_value ( safewrite ( fd , "\n" , 1 ) ) ;
}
else if ( ! doneWarning ) {
ignore_value ( safewrite ( fd , msg , strlen ( msg ) ) ) ;
doneWarning = true ;
}
# undef STRIP_DEPTH }
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void sun4m_irq_info ( Monitor * mon , const QDict * qdict ) {
if ( slavio_intctl ) slavio_irq_info ( mon , slavio_intctl ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void test_bug5126 ( ) {
MYSQL_STMT * stmt ;
MYSQL_BIND my_bind [ 2 ] ;
int32 c1 , c2 ;
const char * stmt_text ;
int rc ;
myheader ( "test_bug5126" ) ;
stmt_text = "DROP TABLE IF EXISTS t1" ;
rc = mysql_real_query ( mysql , stmt_text , strlen ( stmt_text ) ) ;
myquery ( rc ) ;
stmt_text = "CREATE TABLE t1 (a mediumint, b int)" ;
rc = mysql_real_query ( mysql , stmt_text , strlen ( stmt_text ) ) ;
myquery ( rc ) ;
stmt_text = "INSERT INTO t1 VALUES (8386608, 1)" ;
rc = mysql_real_query ( mysql , stmt_text , strlen ( stmt_text ) ) ;
myquery ( rc ) ;
stmt = mysql_stmt_init ( mysql ) ;
stmt_text = "SELECT a, b FROM t1" ;
rc = mysql_stmt_prepare ( stmt , stmt_text , strlen ( stmt_text ) ) ;
check_execute ( stmt , rc ) ;
rc = mysql_stmt_execute ( stmt ) ;
check_execute ( stmt , rc ) ;
memset ( my_bind , 0 , sizeof ( my_bind ) ) ;
my_bind [ 0 ] . buffer_type = MYSQL_TYPE_LONG ;
my_bind [ 0 ] . buffer = & c1 ;
my_bind [ 1 ] . buffer_type = MYSQL_TYPE_LONG ;
my_bind [ 1 ] . buffer = & c2 ;
mysql_stmt_bind_result ( stmt , my_bind ) ;
rc = mysql_stmt_fetch ( stmt ) ;
DIE_UNLESS ( rc == 0 ) ;
DIE_UNLESS ( c1 == 8386608 && c2 == 1 ) ;
if ( ! opt_silent ) printf ( "%ld, %ld\n" , ( long ) c1 , ( long ) c2 ) ;
mysql_stmt_close ( stmt ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int print_ip6cp_config_options ( netdissect_options * ndo , const u_char * p , int length ) {
int len , opt ;
if ( length < 2 ) return 0 ;
ND_TCHECK2 ( * p , 2 ) ;
len = p [ 1 ] ;
opt = p [ 0 ] ;
if ( length < len ) return 0 ;
if ( len < 2 ) {
ND_PRINT ( ( ndo , "\n\t %s Option (0x%02x), length %u (length bogus, should be >= 2)" , tok2str ( ip6cpopt_values , "unknown" , opt ) , opt , len ) ) ;
return 0 ;
}
ND_PRINT ( ( ndo , "\n\t %s Option (0x%02x), length %u" , tok2str ( ip6cpopt_values , "unknown" , opt ) , opt , len ) ) ;
switch ( opt ) {
case IP6CP_IFID : if ( len != 10 ) {
ND_PRINT ( ( ndo , " (length bogus, should be = 10)" ) ) ;
return len ;
}
ND_TCHECK2 ( * ( p + 2 ) , 8 ) ;
ND_PRINT ( ( ndo , ": %04x:%04x:%04x:%04x" , EXTRACT_16BITS ( p + 2 ) , EXTRACT_16BITS ( p + 4 ) , EXTRACT_16BITS ( p + 6 ) , EXTRACT_16BITS ( p + 8 ) ) ) ;
break ;
default : if ( ndo -> ndo_vflag < 2 ) print_unknown_data ( ndo , & p [ 2 ] , "\n\t " , len - 2 ) ;
break ;
}
if ( ndo -> ndo_vflag > 1 ) print_unknown_data ( ndo , & p [ 2 ] , "\n\t " , len - 2 ) ;
return len ;
trunc : ND_PRINT ( ( ndo , "[|ip6cp]" ) ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void vga_draw_glyph8 ( uint8_t * d , int linesize , const uint8_t * font_ptr , int h , uint32_t fgcol , uint32_t bgcol ) {
uint32_t font_data , xorcol ;
xorcol = bgcol ^ fgcol ;
do {
font_data = font_ptr [ 0 ] ;
vga_draw_glyph_line ( d , font_data , xorcol , bgcol ) ;
font_ptr += 4 ;
d += linesize ;
}
while ( -- h ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
bool id_h ( connection_t * c ) {
char name [ MAX_STRING_SIZE ] ;
if ( sscanf ( c -> buffer , "%*d " MAX_STRING " %d" , name , & c -> protocol_version ) != 2 ) {
logger ( LOG_ERR , "Got bad %s from %s (%s)" , "ID" , c -> name , c -> hostname ) ;
return false ;
}
if ( ! check_id ( name ) || ! strcmp ( name , myself -> name ) ) {
logger ( LOG_ERR , "Got bad %s from %s (%s): %s" , "ID" , c -> name , c -> hostname , "invalid name" ) ;
return false ;
}
if ( c -> outgoing ) {
if ( strcmp ( c -> name , name ) ) {
logger ( LOG_ERR , "Peer %s is %s instead of %s" , c -> hostname , name , c -> name ) ;
return false ;
}
}
else {
if ( c -> name ) {
free ( c -> name ) ;
}
c -> name = xstrdup ( name ) ;
}
if ( c -> protocol_version != myself -> connection -> protocol_version ) {
logger ( LOG_ERR , "Peer %s (%s) uses incompatible version %d" , c -> name , c -> hostname , c -> protocol_version ) ;
return false ;
}
if ( bypass_security ) {
if ( ! c -> config_tree ) {
init_configuration ( & c -> config_tree ) ;
}
c -> allow_request = ACK ;
if ( ! c -> outgoing ) {
send_id ( c ) ;
}
return send_ack ( c ) ;
}
if ( ! c -> config_tree ) {
init_configuration ( & c -> config_tree ) ;
if ( ! read_connection_config ( c ) ) {
logger ( LOG_ERR , "Peer %s had unknown identity (%s)" , c -> hostname , c -> name ) ;
return false ;
}
}
if ( ! read_rsa_public_key ( c ) ) {
return false ;
}
c -> allow_request = METAKEY ;
if ( ! c -> outgoing ) {
send_id ( c ) ;
}
return send_metakey ( c ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void terminate_chunked_cb ( struct evhttp_request * req , void * arg ) {
struct terminate_state * state = arg ;
struct timeval tv ;
state -> req = req ;
evhttp_send_reply_start ( req , HTTP_OK , "OK" ) ;
tv . tv_sec = 0 ;
tv . tv_usec = 3000 ;
event_once ( - 1 , EV_TIMEOUT , terminate_chunked_trickle_cb , arg , & tv ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( ExtensionServiceSyncTest , GetSyncDataFilter ) {
InitializeEmptyExtensionService ( ) ;
InstallCRX ( data_dir ( ) . AppendASCII ( "good.crx" ) , INSTALL_NEW ) ;
const Extension * extension = service ( ) -> GetInstalledExtension ( good_crx ) ;
ASSERT_TRUE ( extension ) ;
extension_sync_service ( ) -> MergeDataAndStartSyncing ( syncer : : APPS , syncer : : SyncDataList ( ) , base : : MakeUnique < syncer : : FakeSyncChangeProcessor > ( ) , base : : MakeUnique < syncer : : SyncErrorFactoryMock > ( ) ) ;
syncer : : SyncDataList list = extension_sync_service ( ) -> GetAllSyncData ( syncer : : EXTENSIONS ) ;
ASSERT_EQ ( list . size ( ) , 0U ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TSReturnCode TSBase64Decode ( const char * str , size_t str_len , unsigned char * dst , size_t dst_size , size_t * length ) {
sdk_assert ( sdk_sanity_check_null_ptr ( ( void * ) str ) == TS_SUCCESS ) ;
sdk_assert ( sdk_sanity_check_null_ptr ( ( void * ) dst ) == TS_SUCCESS ) ;
return ats_base64_decode ( str , str_len , dst , dst_size , length ) ? TS_SUCCESS : TS_ERROR ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void moresubs ( struct vars * v , int wanted ) {
struct subre * * p ;
size_t n ;
assert ( wanted > 0 && ( size_t ) wanted >= v -> nsubs ) ;
n = ( size_t ) wanted * 3 / 2 + 1 ;
if ( v -> subs == v -> sub10 ) {
p = ( struct subre * * ) MALLOC ( n * sizeof ( struct subre * ) ) ;
if ( p != NULL ) memcpy ( VS ( p ) , VS ( v -> subs ) , v -> nsubs * sizeof ( struct subre * ) ) ;
}
else p = ( struct subre * * ) REALLOC ( v -> subs , n * sizeof ( struct subre * ) ) ;
if ( p == NULL ) {
ERR ( REG_ESPACE ) ;
return ;
}
v -> subs = p ;
for ( p = & v -> subs [ v -> nsubs ] ;
v -> nsubs < n ;
p ++ , v -> nsubs ++ ) * p = NULL ;
assert ( v -> nsubs == n ) ;
assert ( ( size_t ) wanted < v -> nsubs ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static ossl_inline int sk_ ## t1 ## _is_sorted ( const STACK_OF ( t1 ) * sk ) {
return OPENSSL_sk_is_sorted ( ( const OPENSSL_STACK * ) sk ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _dup ( const STACK_OF ( t1 ) * sk ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_dup ( ( const OPENSSL_STACK * ) sk ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _deep_copy ( const STACK_OF ( t1 ) * sk , sk_ ## t1 ## _copyfunc copyfunc , sk_ ## t1 ## _freefunc freefunc ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_deep_copy ( ( const OPENSSL_STACK * ) sk , ( OPENSSL_sk_copyfunc ) copyfunc , ( OPENSSL_sk_freefunc ) freefunc ) ;
}
static ossl_inline sk_ ## t1 ## _compfunc sk_ ## t1 ## _set_cmp_func ( STACK_OF ( t1 ) * sk , sk_ ## t1 ## _compfunc compare ) {
return ( sk_ ## t1 ## _compfunc ) OPENSSL_sk_set_cmp_func ( ( OPENSSL_STACK * ) sk , ( OPENSSL_sk_compfunc ) compare ) ;
}
# define DEFINE_SPECIAL_STACK_OF ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , t2 , t2 ) # define DEFINE_STACK_OF ( t ) SKM_DEFINE_STACK_OF ( t , t , t ) # define DEFINE_SPECIAL_STACK_OF_CONST ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , const t2 , t2 ) # define DEFINE_STACK_OF_CONST ( t ) SKM_DEFINE_STACK_OF ( t , const t , t ) typedef char * OPENSSL_STRING ;
typedef const char * OPENSSL_CSTRING ;
DEFINE_SPECIAL_STACK_OF ( OPENSSL_STRING , char ) DEFINE_SPECIAL_STACK_OF_CONST ( OPENSSL_CSTRING , char )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST ( AutocompleteMatchTest , MergeClassifications ) {
EXPECT_EQ ( std : : string ( ) , AutocompleteMatch : : ClassificationsToString ( AutocompleteMatch : : MergeClassifications ( AutocompleteMatch : : ACMatchClassifications ( ) , AutocompleteMatch : : ACMatchClassifications ( ) ) ) ) ;
EXPECT_EQ ( "0,0" , AutocompleteMatch : : ClassificationsToString ( AutocompleteMatch : : MergeClassifications ( AutocompleteMatch : : ClassificationsFromString ( "0,0" ) , AutocompleteMatch : : ACMatchClassifications ( ) ) ) ) ;
EXPECT_EQ ( "0,0" , AutocompleteMatch : : ClassificationsToString ( AutocompleteMatch : : MergeClassifications ( AutocompleteMatch : : ACMatchClassifications ( ) , AutocompleteMatch : : ClassificationsFromString ( "0,0" ) ) ) ) ;
EXPECT_EQ ( "0,1" , AutocompleteMatch : : ClassificationsToString ( AutocompleteMatch : : MergeClassifications ( AutocompleteMatch : : ClassificationsFromString ( "0,1" ) , AutocompleteMatch : : ACMatchClassifications ( ) ) ) ) ;
EXPECT_EQ ( "0,1" , AutocompleteMatch : : ClassificationsToString ( AutocompleteMatch : : MergeClassifications ( AutocompleteMatch : : ACMatchClassifications ( ) , AutocompleteMatch : : ClassificationsFromString ( "0,1" ) ) ) ) ;
EXPECT_EQ ( "0,1" , AutocompleteMatch : : ClassificationsToString ( AutocompleteMatch : : MergeClassifications ( AutocompleteMatch : : ClassificationsFromString ( "0,0" ) , AutocompleteMatch : : ClassificationsFromString ( "0,1" ) ) ) ) ;
EXPECT_EQ ( "0,3," "1,2" , AutocompleteMatch : : ClassificationsToString ( AutocompleteMatch : : MergeClassifications ( AutocompleteMatch : : ClassificationsFromString ( "0,1," "1,0" ) , AutocompleteMatch : : ClassificationsFromString ( "0,2" ) ) ) ) ;
EXPECT_EQ ( "0,3," "1,2" , AutocompleteMatch : : ClassificationsToString ( AutocompleteMatch : : MergeClassifications ( AutocompleteMatch : : ClassificationsFromString ( "0,2" ) , AutocompleteMatch : : ClassificationsFromString ( "0,1," "1,0" ) ) ) ) ;
EXPECT_EQ ( "0,3" , AutocompleteMatch : : ClassificationsToString ( AutocompleteMatch : : MergeClassifications ( AutocompleteMatch : : ClassificationsFromString ( "0,1," "1,2" ) , AutocompleteMatch : : ClassificationsFromString ( "0,2," "1,1" ) ) ) ) ;
EXPECT_EQ ( "0,2," "1,0," "2,1," "4,3," "5,7," "6,3," "7,7," "15,1," "17,0" , AutocompleteMatch : : ClassificationsToString ( AutocompleteMatch : : MergeClassifications ( AutocompleteMatch : : ClassificationsFromString ( "0,0," "2,1," "4,3," "7,7," "10,6," "15,0" ) , AutocompleteMatch : : ClassificationsFromString ( "0,2," "1,0," "5,7," "6,1," "17,0" ) ) ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( ExternalProtocolHandlerTest , TestLaunchSchemeBlockedChromeDefault ) {
DoTest ( ExternalProtocolHandler : : BLOCK , shell_integration : : IS_DEFAULT , Action : : BLOCK ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int get_intra_count ( MpegEncContext * s , uint8_t * src , uint8_t * ref , int stride ) {
int x , y , w , h ;
int acc = 0 ;
w = s -> width & ~ 15 ;
h = s -> height & ~ 15 ;
for ( y = 0 ;
y < h ;
y += 16 ) {
for ( x = 0 ;
x < w ;
x += 16 ) {
int offset = x + y * stride ;
int sad = s -> dsp . sad [ 0 ] ( NULL , src + offset , ref + offset , stride , 16 ) ;
int mean = ( s -> dsp . pix_sum ( src + offset , stride ) + 128 ) >> 8 ;
int sae = get_sae ( src + offset , mean , stride ) ;
acc += sae + 500 < sad ;
}
}
return acc ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void exsltMathConstantFunction ( xmlXPathParserContextPtr ctxt , int nargs ) {
double ret ;
xmlChar * name ;
if ( nargs != 2 ) {
xmlXPathSetArityError ( ctxt ) ;
return ;
}
ret = xmlXPathPopNumber ( ctxt ) ;
if ( xmlXPathCheckError ( ctxt ) ) return ;
name = xmlXPathPopString ( ctxt ) ;
if ( xmlXPathCheckError ( ctxt ) ) return ;
ret = exsltMathConstant ( name , ret ) ;
if ( name != NULL ) xmlFree ( name ) ;
xmlXPathReturnNumber ( ctxt , ret ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void pdf_run_K ( fz_context * ctx , pdf_processor * proc , float c , float m , float y , float k ) {
pdf_run_processor * pr = ( pdf_run_processor * ) proc ;
float color [ 4 ] = {
c , m , y , k }
;
pr -> dev -> flags &= ~ FZ_DEVFLAG_STROKECOLOR_UNDEFINED ;
pdf_set_colorspace ( ctx , pr , PDF_STROKE , fz_device_cmyk ( ctx ) ) ;
pdf_set_color ( ctx , pr , PDF_STROKE , color ) ;
}
| 0False
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.