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 handle_cgroup_settings ( struct cgroup_mount_point * mp , char * cgroup_path ) {
int r , saved_errno = 0 ;
char buf [ 2 ] ;
mp -> need_cpuset_init = false ;
if ( lxc_string_in_array ( "memory" , ( const char * * ) mp -> hierarchy -> subsystems ) ) {
char * cc_path = cgroup_to_absolute_path ( mp , cgroup_path , "/memory.use_hierarchy" ) ;
if ( cc_path ) {
r = lxc_read_from_file ( cc_path , buf , 1 ) ;
if ( r < 1 || buf [ 0 ] != '1' ) {
r = lxc_write_to_file ( cc_path , "1" , 1 , false ) ;
if ( r < 0 ) SYSERROR ( "failed to set memory.use_hierarchy to 1;
continuing" ) ;
}
free ( cc_path ) ;
}
}
if ( lxc_string_in_array ( "cpuset" , ( const char * * ) mp -> hierarchy -> subsystems ) ) {
char * cc_path = cgroup_to_absolute_path ( mp , cgroup_path , "/cgroup.clone_children" ) ;
struct stat sb ;
if ( ! cc_path ) return - 1 ;
if ( stat ( cc_path , & sb ) != 0 && errno == ENOENT ) {
mp -> need_cpuset_init = true ;
free ( cc_path ) ;
return 0 ;
}
r = lxc_read_from_file ( cc_path , buf , 1 ) ;
if ( r == 1 && buf [ 0 ] == '1' ) {
free ( cc_path ) ;
return 0 ;
}
r = lxc_write_to_file ( cc_path , "1" , 1 , false ) ;
saved_errno = errno ;
free ( cc_path ) ;
errno = saved_errno ;
return r < 0 ? - 1 : 0 ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int ztokenexec ( i_ctx_t * i_ctx_p ) {
os_ptr op = osp ;
stream * s ;
scanner_state state ;
check_read_file ( i_ctx_p , s , op ) ;
check_estack ( 1 ) ;
gs_scanner_init ( & state , op ) ;
return tokenexec_continue ( i_ctx_p , & state , true ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int dissect_h225_AliasAddress ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_choice ( tvb , offset , actx , tree , hf_index , ett_h225_AliasAddress , AliasAddress_choice , NULL ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
float lut_interp_linear_float ( float value , float * table , size_t length ) {
int upper , lower ;
value = value * ( length - 1 ) ;
upper = ceil ( value ) ;
lower = floor ( value ) ;
value = table [ upper ] * ( 1. - ( upper - value ) ) + table [ lower ] * ( upper - value ) ;
return value ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static __inline__ void __swab16s ( __u16 * p ) {
# ifdef __arch_swab16s __arch_swab16s ( p ) ;
# else * p = __swab16p ( p ) ;
# endif }
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static const gchar * gen_olc_key ( guint16 lc_num , address * dst_addr , address * src_addr ) {
return wmem_strdup_printf ( wmem_packet_scope ( ) , "%s/%s/%u" , address_to_str ( wmem_packet_scope ( ) , dst_addr ) , address_to_str ( wmem_packet_scope ( ) , src_addr ) , lc_num ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int extra_setup_location ( struct isoent * isoent , int location ) {
struct extr_rec * rec ;
int cnt ;
cnt = 0 ;
rec = isoent -> extr_rec_list . first ;
isoent -> extr_rec_list . current = rec ;
while ( rec ) {
cnt ++ ;
rec -> location = location ++ ;
rec -> offset = 0 ;
rec = rec -> next ;
}
return ( cnt ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int64_t TSMimeHdrFieldValueInt64Get ( TSMBuffer bufp , TSMLoc hdr , TSMLoc field , int idx ) {
sdk_assert ( sdk_sanity_check_mbuffer ( bufp ) == TS_SUCCESS ) ;
sdk_assert ( ( sdk_sanity_check_mime_hdr_handle ( hdr ) == TS_SUCCESS ) || ( sdk_sanity_check_http_hdr_handle ( hdr ) == TS_SUCCESS ) ) ;
sdk_assert ( sdk_sanity_check_field_handle ( field , hdr ) == TS_SUCCESS ) ;
int value_len ;
const char * value_str = TSMimeFieldValueGet ( bufp , field , idx , & value_len ) ;
if ( value_str == nullptr ) {
return 0 ;
}
return mime_parse_int64 ( value_str , value_str + value_len ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void identify_locking_dependencies ( ArchiveHandle * AH , TocEntry * te ) {
DumpId * lockids ;
int nlockids ;
int i ;
if ( te -> nDeps == 0 ) return ;
if ( ! ( strcmp ( te -> desc , "CONSTRAINT" ) == 0 || strcmp ( te -> desc , "CHECK CONSTRAINT" ) == 0 || strcmp ( te -> desc , "FK CONSTRAINT" ) == 0 || strcmp ( te -> desc , "RULE" ) == 0 || strcmp ( te -> desc , "TRIGGER" ) == 0 ) ) return ;
lockids = ( DumpId * ) pg_malloc ( te -> nDeps * sizeof ( DumpId ) ) ;
nlockids = 0 ;
for ( i = 0 ;
i < te -> nDeps ;
i ++ ) {
DumpId depid = te -> dependencies [ i ] ;
if ( depid <= AH -> maxDumpId && AH -> tocsByDumpId [ depid ] != NULL && ( ( strcmp ( AH -> tocsByDumpId [ depid ] -> desc , "TABLE DATA" ) == 0 ) || strcmp ( AH -> tocsByDumpId [ depid ] -> desc , "TABLE" ) == 0 ) ) lockids [ nlockids ++ ] = depid ;
}
if ( nlockids == 0 ) {
free ( lockids ) ;
return ;
}
te -> lockDeps = pg_realloc ( lockids , nlockids * sizeof ( DumpId ) ) ;
te -> nLockDeps = nlockids ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( ProtocolHandlerRegistryTest , DisallowRegisteringExternallyHandledProtocols ) {
delegate ( ) -> RegisterExternalHandler ( "test" ) ;
ASSERT_FALSE ( registry ( ) -> CanSchemeBeOverridden ( "test" ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( FullscreenControllerStateUnitTest , TransitionsForEachState ) {
AddTab ( browser ( ) , GURL ( url : : kAboutBlankURL ) ) ;
TestTransitionsForEachState ( ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void save_mtu ( packet_info * pinfo , bluetooth_data_t * bluetooth_data , guint mtu ) {
wmem_tree_key_t key [ 4 ] ;
guint32 frame_number ;
mtu_data_t * mtu_data ;
frame_number = pinfo -> num ;
key [ 0 ] . length = 1 ;
key [ 0 ] . key = & bluetooth_data -> interface_id ;
key [ 1 ] . length = 1 ;
key [ 1 ] . key = & bluetooth_data -> adapter_id ;
key [ 2 ] . length = 1 ;
key [ 2 ] . key = & frame_number ;
key [ 3 ] . length = 0 ;
key [ 3 ] . key = NULL ;
mtu_data = wmem_new ( wmem_file_scope ( ) , mtu_data_t ) ;
mtu_data -> mtu = mtu ;
wmem_tree_insert32_array ( mtus , key , mtu_data ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void show_frame ( WriterContext * w , AVFrame * frame , AVStream * stream , AVFormatContext * fmt_ctx ) {
AVBPrint pbuf ;
char val_str [ 128 ] ;
const char * s ;
int i ;
av_bprint_init ( & pbuf , 1 , AV_BPRINT_SIZE_UNLIMITED ) ;
writer_print_section_header ( w , SECTION_ID_FRAME ) ;
s = av_get_media_type_string ( stream -> codecpar -> codec_type ) ;
if ( s ) print_str ( "media_type" , s ) ;
else print_str_opt ( "media_type" , "unknown" ) ;
print_int ( "stream_index" , stream -> index ) ;
print_int ( "key_frame" , frame -> key_frame ) ;
print_ts ( "pkt_pts" , frame -> pts ) ;
print_time ( "pkt_pts_time" , frame -> pts , & stream -> time_base ) ;
print_ts ( "pkt_dts" , frame -> pkt_dts ) ;
print_time ( "pkt_dts_time" , frame -> pkt_dts , & stream -> time_base ) ;
print_ts ( "best_effort_timestamp" , frame -> best_effort_timestamp ) ;
print_time ( "best_effort_timestamp_time" , frame -> best_effort_timestamp , & stream -> time_base ) ;
print_duration_ts ( "pkt_duration" , frame -> pkt_duration ) ;
print_duration_time ( "pkt_duration_time" , frame -> pkt_duration , & stream -> time_base ) ;
if ( frame -> pkt_pos != - 1 ) print_fmt ( "pkt_pos" , "%" PRId64 , frame -> pkt_pos ) ;
else print_str_opt ( "pkt_pos" , "N/A" ) ;
if ( frame -> pkt_size != - 1 ) print_val ( "pkt_size" , frame -> pkt_size , unit_byte_str ) ;
else print_str_opt ( "pkt_size" , "N/A" ) ;
switch ( stream -> codecpar -> codec_type ) {
AVRational sar ;
case AVMEDIA_TYPE_VIDEO : print_int ( "width" , frame -> width ) ;
print_int ( "height" , frame -> height ) ;
s = av_get_pix_fmt_name ( frame -> format ) ;
if ( s ) print_str ( "pix_fmt" , s ) ;
else print_str_opt ( "pix_fmt" , "unknown" ) ;
sar = av_guess_sample_aspect_ratio ( fmt_ctx , stream , frame ) ;
if ( sar . num ) {
print_q ( "sample_aspect_ratio" , sar , ':' ) ;
}
else {
print_str_opt ( "sample_aspect_ratio" , "N/A" ) ;
}
print_fmt ( "pict_type" , "%c" , av_get_picture_type_char ( frame -> pict_type ) ) ;
print_int ( "coded_picture_number" , frame -> coded_picture_number ) ;
print_int ( "display_picture_number" , frame -> display_picture_number ) ;
print_int ( "interlaced_frame" , frame -> interlaced_frame ) ;
print_int ( "top_field_first" , frame -> top_field_first ) ;
print_int ( "repeat_pict" , frame -> repeat_pict ) ;
if ( frame -> color_range != AVCOL_RANGE_UNSPECIFIED ) print_str ( "color_range" , av_color_range_name ( frame -> color_range ) ) ;
else print_str_opt ( "color_range" , av_color_range_name ( frame -> color_range ) ) ;
if ( frame -> colorspace != AVCOL_SPC_UNSPECIFIED ) print_str ( "color_space" , av_color_space_name ( frame -> colorspace ) ) ;
else print_str_opt ( "color_space" , av_color_space_name ( frame -> colorspace ) ) ;
if ( frame -> color_primaries != AVCOL_PRI_UNSPECIFIED ) print_str ( "color_primaries" , av_color_primaries_name ( frame -> color_primaries ) ) ;
else print_str_opt ( "color_primaries" , av_color_primaries_name ( frame -> color_primaries ) ) ;
if ( frame -> color_trc != AVCOL_TRC_UNSPECIFIED ) print_str ( "color_transfer" , av_color_transfer_name ( frame -> color_trc ) ) ;
else print_str_opt ( "color_transfer" , av_color_transfer_name ( frame -> color_trc ) ) ;
if ( frame -> chroma_location != AVCHROMA_LOC_UNSPECIFIED ) print_str ( "chroma_location" , av_chroma_location_name ( frame -> chroma_location ) ) ;
else print_str_opt ( "chroma_location" , av_chroma_location_name ( frame -> chroma_location ) ) ;
break ;
case AVMEDIA_TYPE_AUDIO : s = av_get_sample_fmt_name ( frame -> format ) ;
if ( s ) print_str ( "sample_fmt" , s ) ;
else print_str_opt ( "sample_fmt" , "unknown" ) ;
print_int ( "nb_samples" , frame -> nb_samples ) ;
print_int ( "channels" , frame -> channels ) ;
if ( frame -> channel_layout ) {
av_bprint_clear ( & pbuf ) ;
av_bprint_channel_layout ( & pbuf , frame -> channels , frame -> channel_layout ) ;
print_str ( "channel_layout" , pbuf . str ) ;
}
else print_str_opt ( "channel_layout" , "unknown" ) ;
break ;
}
if ( do_show_frame_tags ) show_tags ( w , frame -> metadata , SECTION_ID_FRAME_TAGS ) ;
if ( do_show_log ) show_log ( w , SECTION_ID_FRAME_LOGS , SECTION_ID_FRAME_LOG , do_show_log ) ;
if ( frame -> nb_side_data ) {
writer_print_section_header ( w , SECTION_ID_FRAME_SIDE_DATA_LIST ) ;
for ( i = 0 ;
i < frame -> nb_side_data ;
i ++ ) {
AVFrameSideData * sd = frame -> side_data [ i ] ;
const char * name ;
writer_print_section_header ( w , SECTION_ID_FRAME_SIDE_DATA ) ;
name = av_frame_side_data_name ( sd -> type ) ;
print_str ( "side_data_type" , name ? name : "unknown" ) ;
if ( sd -> type == AV_FRAME_DATA_DISPLAYMATRIX && sd -> size >= 9 * 4 ) {
writer_print_integers ( w , "displaymatrix" , sd -> data , 9 , " %11d" , 3 , 4 , 1 ) ;
print_int ( "rotation" , av_display_rotation_get ( ( int32_t * ) sd -> data ) ) ;
}
else if ( sd -> type == AV_FRAME_DATA_GOP_TIMECODE && sd -> size >= 8 ) {
char tcbuf [ AV_TIMECODE_STR_SIZE ] ;
av_timecode_make_mpeg_tc_string ( tcbuf , * ( int64_t * ) ( sd -> data ) ) ;
print_str ( "timecode" , tcbuf ) ;
}
else if ( sd -> type == AV_FRAME_DATA_MASTERING_DISPLAY_METADATA ) {
AVMasteringDisplayMetadata * metadata = ( AVMasteringDisplayMetadata * ) sd -> data ;
if ( metadata -> has_primaries ) {
print_q ( "red_x" , metadata -> display_primaries [ 0 ] [ 0 ] , '/' ) ;
print_q ( "red_y" , metadata -> display_primaries [ 0 ] [ 1 ] , '/' ) ;
print_q ( "green_x" , metadata -> display_primaries [ 1 ] [ 0 ] , '/' ) ;
print_q ( "green_y" , metadata -> display_primaries [ 1 ] [ 1 ] , '/' ) ;
print_q ( "blue_x" , metadata -> display_primaries [ 2 ] [ 0 ] , '/' ) ;
print_q ( "blue_y" , metadata -> display_primaries [ 2 ] [ 1 ] , '/' ) ;
print_q ( "white_point_x" , metadata -> white_point [ 0 ] , '/' ) ;
print_q ( "white_point_y" , metadata -> white_point [ 1 ] , '/' ) ;
}
if ( metadata -> has_luminance ) {
print_q ( "min_luminance" , metadata -> min_luminance , '/' ) ;
print_q ( "max_luminance" , metadata -> max_luminance , '/' ) ;
}
}
else if ( sd -> type == AV_FRAME_DATA_CONTENT_LIGHT_LEVEL ) {
AVContentLightMetadata * metadata = ( AVContentLightMetadata * ) sd -> data ;
print_int ( "max_content" , metadata -> MaxCLL ) ;
print_int ( "max_average" , metadata -> MaxFALL ) ;
}
else if ( sd -> type == AV_FRAME_DATA_ICC_PROFILE ) {
AVDictionaryEntry * tag = av_dict_get ( sd -> metadata , "name" , NULL , AV_DICT_MATCH_CASE ) ;
if ( tag ) print_str ( tag -> key , tag -> value ) ;
print_int ( "size" , sd -> size ) ;
}
writer_print_section_footer ( w ) ;
}
writer_print_section_footer ( w ) ;
}
writer_print_section_footer ( w ) ;
av_bprint_finalize ( & pbuf , NULL ) ;
fflush ( stdout ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void U_CALLCONV _Latin1FromUnicodeWithOffsets ( UConverterFromUnicodeArgs * pArgs , UErrorCode * pErrorCode ) {
UConverter * cnv ;
const UChar * source , * sourceLimit ;
uint8_t * target , * oldTarget ;
int32_t targetCapacity , length ;
int32_t * offsets ;
UChar32 cp ;
UChar c , max ;
int32_t sourceIndex ;
cnv = pArgs -> converter ;
source = pArgs -> source ;
sourceLimit = pArgs -> sourceLimit ;
target = oldTarget = ( uint8_t * ) pArgs -> target ;
targetCapacity = ( int32_t ) ( pArgs -> targetLimit - pArgs -> target ) ;
offsets = pArgs -> offsets ;
if ( cnv -> sharedData == & _Latin1Data ) {
max = 0xff ;
}
else {
max = 0x7f ;
}
cp = cnv -> fromUChar32 ;
sourceIndex = cp == 0 ? 0 : - 1 ;
length = ( int32_t ) ( sourceLimit - source ) ;
if ( length < targetCapacity ) {
targetCapacity = length ;
}
if ( cp != 0 && targetCapacity > 0 ) {
goto getTrail ;
}
# if LATIN1_UNROLL_FROM_UNICODE if ( targetCapacity >= 16 ) {
int32_t count , loops ;
UChar u , oredChars ;
loops = count = targetCapacity >> 4 ;
do {
oredChars = u = * source ++ ;
* target ++ = ( uint8_t ) u ;
oredChars |= u = * source ++ ;
* target ++ = ( uint8_t ) u ;
oredChars |= u = * source ++ ;
* target ++ = ( uint8_t ) u ;
oredChars |= u = * source ++ ;
* target ++ = ( uint8_t ) u ;
oredChars |= u = * source ++ ;
* target ++ = ( uint8_t ) u ;
oredChars |= u = * source ++ ;
* target ++ = ( uint8_t ) u ;
oredChars |= u = * source ++ ;
* target ++ = ( uint8_t ) u ;
oredChars |= u = * source ++ ;
* target ++ = ( uint8_t ) u ;
oredChars |= u = * source ++ ;
* target ++ = ( uint8_t ) u ;
oredChars |= u = * source ++ ;
* target ++ = ( uint8_t ) u ;
oredChars |= u = * source ++ ;
* target ++ = ( uint8_t ) u ;
oredChars |= u = * source ++ ;
* target ++ = ( uint8_t ) u ;
oredChars |= u = * source ++ ;
* target ++ = ( uint8_t ) u ;
oredChars |= u = * source ++ ;
* target ++ = ( uint8_t ) u ;
oredChars |= u = * source ++ ;
* target ++ = ( uint8_t ) u ;
oredChars |= u = * source ++ ;
* target ++ = ( uint8_t ) u ;
if ( oredChars > max ) {
source -= 16 ;
target -= 16 ;
break ;
}
}
while ( -- count > 0 ) ;
count = loops - count ;
targetCapacity -= 16 * count ;
if ( offsets != NULL ) {
oldTarget += 16 * count ;
while ( count > 0 ) {
* offsets ++ = sourceIndex ++ ;
* offsets ++ = sourceIndex ++ ;
* offsets ++ = sourceIndex ++ ;
* offsets ++ = sourceIndex ++ ;
* offsets ++ = sourceIndex ++ ;
* offsets ++ = sourceIndex ++ ;
* offsets ++ = sourceIndex ++ ;
* offsets ++ = sourceIndex ++ ;
* offsets ++ = sourceIndex ++ ;
* offsets ++ = sourceIndex ++ ;
* offsets ++ = sourceIndex ++ ;
* offsets ++ = sourceIndex ++ ;
* offsets ++ = sourceIndex ++ ;
* offsets ++ = sourceIndex ++ ;
* offsets ++ = sourceIndex ++ ;
* offsets ++ = sourceIndex ++ ;
-- count ;
}
}
}
# endif c = 0 ;
while ( targetCapacity > 0 && ( c = * source ++ ) <= max ) {
* target ++ = ( uint8_t ) c ;
-- targetCapacity ;
}
if ( c > max ) {
cp = c ;
if ( ! U_IS_SURROGATE ( cp ) ) {
}
else if ( U_IS_SURROGATE_LEAD ( cp ) ) {
getTrail : if ( source < sourceLimit ) {
UChar trail = * source ;
if ( U16_IS_TRAIL ( trail ) ) {
++ source ;
cp = U16_GET_SUPPLEMENTARY ( cp , trail ) ;
}
else {
}
}
else {
cnv -> fromUChar32 = cp ;
goto noMoreInput ;
}
}
else {
}
* pErrorCode = U_IS_SURROGATE ( cp ) ? U_ILLEGAL_CHAR_FOUND : U_INVALID_CHAR_FOUND ;
cnv -> fromUChar32 = cp ;
}
noMoreInput : if ( offsets != NULL ) {
size_t count = target - oldTarget ;
while ( count > 0 ) {
* offsets ++ = sourceIndex ++ ;
-- count ;
}
}
if ( U_SUCCESS ( * pErrorCode ) && source < sourceLimit && target >= ( uint8_t * ) pArgs -> targetLimit ) {
* pErrorCode = U_BUFFER_OVERFLOW_ERROR ;
}
pArgs -> source = source ;
pArgs -> target = ( char * ) target ;
pArgs -> offsets = offsets ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void test_bug2248 ( ) {
MYSQL_STMT * stmt ;
int rc ;
const char * query1 = "SELECT DATABASE()" ;
const char * query2 = "INSERT INTO test_bug2248 VALUES (10)" ;
myheader ( "test_bug2248" ) ;
rc = mysql_query ( mysql , "DROP TABLE IF EXISTS test_bug2248" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "CREATE TABLE test_bug2248 (id int)" ) ;
myquery ( rc ) ;
stmt = mysql_simple_prepare ( mysql , query1 ) ;
check_stmt ( stmt ) ;
rc = mysql_stmt_fetch ( stmt ) ;
check_execute_r ( stmt , rc ) ;
rc = mysql_stmt_store_result ( stmt ) ;
check_execute_r ( stmt , rc ) ;
mysql_stmt_close ( stmt ) ;
stmt = mysql_simple_prepare ( mysql , query2 ) ;
check_stmt ( stmt ) ;
rc = mysql_stmt_execute ( stmt ) ;
check_execute ( stmt , rc ) ;
rc = mysql_stmt_fetch ( stmt ) ;
DIE_UNLESS ( rc == 1 ) ;
rc = mysql_stmt_store_result ( stmt ) ;
check_execute ( stmt , rc ) ;
rc = mysql_stmt_fetch ( stmt ) ;
check_execute_r ( stmt , rc ) ;
DIE_UNLESS ( rc == 1 ) ;
mysql_stmt_close ( stmt ) ;
rc = mysql_query ( mysql , "DROP TABLE test_bug2248" ) ;
myquery ( rc ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int capture_android_bluetooth_external_parser ( char * interface , char * fifo , const char * adb_server_ip , unsigned short * adb_server_tcp_port , unsigned short * bt_server_tcp_port , unsigned int bt_forward_socket , const char * bt_local_ip , unsigned short * bt_local_tcp_port ) {
struct extcap_dumper extcap_dumper ;
static char buffer [ PACKET_LENGTH ] ;
uint64_t * timestamp ;
char * packet = buffer + BLUEDROID_TIMESTAMP_SIZE - sizeof ( own_pcap_bluetooth_h4_header ) ;
own_pcap_bluetooth_h4_header * h4_header ;
guint8 * payload = packet + sizeof ( own_pcap_bluetooth_h4_header ) ;
const char * adb_transport = "0012" "host:transport-any" ;
const char * adb_transport_serial_templace = "%04x" "host:transport:%s" ;
const char * adb_tcp_bluedroid_external_parser_template = "%04x" "tcp:%05u" ;
gssize length ;
gssize used_buffer_length = 0 ;
uint64_t ts ;
socket_handle_t sock ;
struct sockaddr_in server ;
int captured_length ;
char * serial_number = NULL ;
size_t serial_number_length = 0 ;
SET_DATA ( timestamp , value_u64 , buffer ) ;
SET_DATA ( h4_header , value_own_pcap_bluetooth_h4_header , packet ) ;
extcap_dumper = extcap_dumper_open ( fifo , EXTCAP_ENCAP_BLUETOOTH_H4_WITH_PHDR ) ;
if ( is_specified_interface ( interface , INTERFACE_ANDROID_BLUETOOTH_EXTERNAL_PARSER ) && strlen ( interface ) > strlen ( INTERFACE_ANDROID_BLUETOOTH_EXTERNAL_PARSER ) + 1 ) {
serial_number = interface + strlen ( INTERFACE_ANDROID_BLUETOOTH_EXTERNAL_PARSER ) + 1 ;
serial_number_length = strlen ( serial_number ) ;
}
if ( bt_forward_socket ) {
if ( ( sock = socket ( AF_INET , SOCK_STREAM , IPPROTO_TCP ) ) == INVALID_SOCKET ) {
errmsg_print ( "ERROR: Cannot open system TCP socket: %s" , strerror ( errno ) ) ;
return EXIT_CODE_GENERIC ;
}
verbose_print ( "Using config: Server TCP Port=%u, Local IP=%s, Local TCP Port=%u\n" , * bt_server_tcp_port , bt_local_ip , * bt_local_tcp_port ) ;
if ( * bt_local_tcp_port != 0 ) {
int result ;
result = adb_forward ( serial_number , adb_server_ip , adb_server_tcp_port , * bt_local_tcp_port , * bt_server_tcp_port ) ;
verbose_print ( "DO: adb forward tcp:%u (local) tcp:%u (remote) result=%i\n" , * bt_local_tcp_port , * bt_server_tcp_port , result ) ;
}
memset ( & server , 0 , sizeof ( server ) ) ;
server . sin_family = AF_INET ;
server . sin_port = GINT16_TO_BE ( * bt_local_tcp_port ) ;
server . sin_addr . s_addr = inet_addr ( bt_local_ip ) ;
useSndTimeout ( sock ) ;
if ( connect ( sock , ( struct sockaddr * ) & server , sizeof ( server ) ) == SOCKET_ERROR ) {
errmsg_print ( "ERROR: <%s> Please check that adb daemon is running." , strerror ( errno ) ) ;
closesocket ( sock ) ;
return EXIT_CODE_GENERIC ;
}
if ( verbose ) {
struct sockaddr_in client ;
length = sizeof ( client ) ;
if ( getsockname ( sock , ( struct sockaddr * ) & client , ( socklen_t * ) & length ) ) {
errmsg_print ( "ERROR getsockname: %s" , strerror ( errno ) ) ;
closesocket ( sock ) ;
return EXIT_CODE_GENERIC ;
}
if ( length != sizeof ( client ) ) {
errmsg_print ( "ERROR: incorrect length" ) ;
closesocket ( sock ) ;
return EXIT_CODE_GENERIC ;
}
verbose_print ( "VERBOSE: Client port %u\n" , GUINT16_FROM_BE ( client . sin_port ) ) ;
}
}
else {
int result ;
sock = adb_connect ( adb_server_ip , adb_server_tcp_port ) ;
if ( sock == INVALID_SOCKET ) return EXIT_CODE_INVALID_SOCKET_6 ;
if ( ! serial_number ) {
result = adb_send ( sock , adb_transport ) ;
if ( result ) {
errmsg_print ( "ERROR: Error while setting adb transport" ) ;
closesocket ( sock ) ;
return EXIT_CODE_GENERIC ;
}
}
else {
result = g_snprintf ( ( char * ) buffer , PACKET_LENGTH , adb_transport_serial_templace , 15 + serial_number_length , serial_number ) ;
if ( result <= 0 || result > PACKET_LENGTH ) {
errmsg_print ( "ERROR: Error while completing adb packet" ) ;
closesocket ( sock ) ;
return EXIT_CODE_BAD_SIZE_OF_ASSEMBLED_ADB_PACKET_13 ;
}
result = adb_send ( sock , buffer ) ;
if ( result ) {
errmsg_print ( "ERROR: Error while setting adb transport" ) ;
closesocket ( sock ) ;
return EXIT_CODE_GENERIC ;
}
}
result = g_snprintf ( ( char * ) buffer , PACKET_LENGTH , adb_tcp_bluedroid_external_parser_template , 4 + 5 , * bt_server_tcp_port ) ;
if ( result <= 0 || result > PACKET_LENGTH ) {
errmsg_print ( "ERROR: Error while completing adb packet" ) ;
closesocket ( sock ) ;
return EXIT_CODE_BAD_SIZE_OF_ASSEMBLED_ADB_PACKET_14 ;
}
result = adb_send ( sock , buffer ) ;
if ( result ) {
errmsg_print ( "ERROR: Error while forwarding adb port" ) ;
closesocket ( sock ) ;
return EXIT_CODE_GENERIC ;
}
}
while ( endless_loop ) {
errno = 0 ;
length = recv ( sock , buffer + used_buffer_length , ( int ) ( PACKET_LENGTH - used_buffer_length ) , 0 ) ;
if ( errno == EAGAIN # if EWOULDBLOCK != EAGAIN || errno == EWOULDBLOCK # endif ) {
continue ;
}
else if ( errno != 0 ) {
errmsg_print ( "ERROR capture: %s" , strerror ( errno ) ) ;
closesocket ( sock ) ;
return EXIT_CODE_GENERIC ;
}
if ( length <= 0 ) {
if ( bt_forward_socket ) {
verbose_print ( "WARNING: Broken socket connection. Try reconnect.\n" ) ;
closesocket ( sock ) ;
if ( ( sock = socket ( AF_INET , SOCK_STREAM , IPPROTO_TCP ) ) == INVALID_SOCKET ) {
errmsg_print ( "ERROR: %s" , strerror ( errno ) ) ;
return EXIT_CODE_GENERIC ;
}
server . sin_family = AF_INET ;
server . sin_port = GINT16_TO_BE ( * bt_local_tcp_port ) ;
server . sin_addr . s_addr = inet_addr ( bt_local_ip ) ;
useSndTimeout ( sock ) ;
if ( connect ( sock , ( struct sockaddr * ) & server , sizeof ( server ) ) == SOCKET_ERROR ) {
errmsg_print ( "ERROR reconnect: <%s> Please check that adb daemon is running." , strerror ( errno ) ) ;
closesocket ( sock ) ;
return EXIT_CODE_GENERIC ;
}
}
else {
errmsg_print ( "ERROR: Broken socket connection." ) ;
closesocket ( sock ) ;
return EXIT_CODE_GENERIC ;
}
continue ;
}
used_buffer_length += length ;
verbose_print ( "Received: length=%" G_GSSIZE_FORMAT "\n" , length ) ;
while ( ( ( payload [ BLUEDROID_H4_PACKET_TYPE ] == BLUEDROID_H4_PACKET_TYPE_HCI_CMD || payload [ BLUEDROID_H4_PACKET_TYPE ] == BLUEDROID_H4_PACKET_TYPE_SCO ) && used_buffer_length >= BLUEDROID_TIMESTAMP_SIZE + BLUEDROID_H4_SIZE + 2 + 1 && BLUEDROID_TIMESTAMP_SIZE + BLUEDROID_H4_SIZE + 2 + payload [ BLUEDROID_H4_SIZE + 2 ] + 1 <= used_buffer_length ) || ( payload [ BLUEDROID_H4_PACKET_TYPE ] == BLUEDROID_H4_PACKET_TYPE_ACL && used_buffer_length >= BLUEDROID_TIMESTAMP_SIZE + BLUEDROID_H4_SIZE + 2 + 2 && BLUEDROID_TIMESTAMP_SIZE + BLUEDROID_H4_SIZE + 2 + payload [ BLUEDROID_H4_SIZE + 2 ] + ( payload [ BLUEDROID_H4_SIZE + 2 + 1 ] << 8 ) + 2 <= used_buffer_length ) || ( payload [ BLUEDROID_H4_PACKET_TYPE ] == BLUEDROID_H4_PACKET_TYPE_SCO && used_buffer_length >= BLUEDROID_TIMESTAMP_SIZE + BLUEDROID_H4_SIZE + 2 + 1 && BLUEDROID_TIMESTAMP_SIZE + BLUEDROID_H4_SIZE + 2 + payload [ BLUEDROID_H4_SIZE + 2 ] + 1 <= used_buffer_length ) || ( payload [ BLUEDROID_H4_PACKET_TYPE ] == BLUEDROID_H4_PACKET_TYPE_HCI_EVT && used_buffer_length >= BLUEDROID_TIMESTAMP_SIZE + BLUEDROID_H4_SIZE + 1 + 1 && BLUEDROID_TIMESTAMP_SIZE + BLUEDROID_H4_SIZE + 1 + payload [ BLUEDROID_H4_SIZE + 1 ] + 1 <= used_buffer_length ) ) {
ts = GINT64_FROM_BE ( * timestamp ) ;
switch ( payload [ BLUEDROID_H4_PACKET_TYPE ] ) {
case BLUEDROID_H4_PACKET_TYPE_HCI_CMD : h4_header -> direction = GINT32_TO_BE ( BLUEDROID_DIRECTION_SENT ) ;
captured_length = ( unsigned int ) sizeof ( own_pcap_bluetooth_h4_header ) + payload [ 3 ] + 4 ;
length = sizeof ( own_pcap_bluetooth_h4_header ) + BLUEDROID_H4_SIZE + 2 + 1 + payload [ 3 ] ;
break ;
case BLUEDROID_H4_PACKET_TYPE_ACL : h4_header -> direction = ( payload [ 2 ] & 0x80 ) ? GINT32_TO_BE ( BLUEDROID_DIRECTION_RECV ) : GINT32_TO_BE ( BLUEDROID_DIRECTION_SENT ) ;
captured_length = ( unsigned int ) sizeof ( own_pcap_bluetooth_h4_header ) + payload [ 3 ] + ( payload [ 3 + 1 ] << 8 ) + 5 ;
length = sizeof ( own_pcap_bluetooth_h4_header ) + BLUEDROID_H4_SIZE + 2 + 2 + payload [ 3 ] + ( gssize ) ( payload [ 3 + 1 ] << 8 ) ;
break ;
case BLUEDROID_H4_PACKET_TYPE_SCO : h4_header -> direction = ( payload [ 2 ] & 0x80 ) ? GINT32_TO_BE ( BLUEDROID_DIRECTION_RECV ) : GINT32_TO_BE ( BLUEDROID_DIRECTION_SENT ) ;
captured_length = ( unsigned int ) sizeof ( own_pcap_bluetooth_h4_header ) + payload [ 3 ] + 4 ;
length = sizeof ( own_pcap_bluetooth_h4_header ) + BLUEDROID_H4_SIZE + 2 + 1 + payload [ 3 ] ;
break ;
case BLUEDROID_H4_PACKET_TYPE_HCI_EVT : h4_header -> direction = GINT32_TO_BE ( BLUEDROID_DIRECTION_RECV ) ;
captured_length = ( unsigned int ) sizeof ( own_pcap_bluetooth_h4_header ) + payload [ 2 ] + 3 ;
length = sizeof ( own_pcap_bluetooth_h4_header ) + BLUEDROID_H4_SIZE + 1 + 1 + payload [ 2 ] ;
break ;
default : errmsg_print ( "ERROR: Invalid stream" ) ;
closesocket ( sock ) ;
return EXIT_CODE_GENERIC ;
}
if ( verbose ) {
static unsigned int id = 1 ;
verbose_print ( "\t Packet %u: used_buffer_length=%" G_GSSIZE_FORMAT " length=%" G_GSSIZE_FORMAT " captured_length=%i type=0x%02x\n" , id , used_buffer_length , length , captured_length , payload [ BLUEDROID_H4_PACKET_TYPE ] ) ;
if ( payload [ BLUEDROID_H4_PACKET_TYPE ] == BLUEDROID_H4_PACKET_TYPE_HCI_EVT ) verbose_print ( "\t Packet: %02x %02x %02x\n" , ( unsigned int ) payload [ 0 ] , ( unsigned int ) payload [ 1 ] , ( unsigned int ) payload [ 2 ] ) ;
id += 1 ;
}
ts -= BLUEDROID_TIMESTAMP_BASE ;
endless_loop = extcap_dumper_dump ( extcap_dumper , packet , captured_length , captured_length , ( uint32_t ) ( ts / 1000000 ) , ( ( uint32_t ) ( ts % 1000000 ) ) * 1000 ) ;
used_buffer_length -= length - sizeof ( own_pcap_bluetooth_h4_header ) + BLUEDROID_TIMESTAMP_SIZE ;
if ( used_buffer_length < 0 ) {
errmsg_print ( "ERROR: Internal error: Negative used buffer length." ) ;
closesocket ( sock ) ;
return EXIT_CODE_GENERIC ;
}
memmove ( buffer , packet + length , used_buffer_length ) ;
}
}
closesocket ( sock ) ;
return EXIT_CODE_SUCCESS ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static PyObject * string_mod ( PyObject * v , PyObject * w ) {
if ( ! PyString_Check ( v ) ) {
Py_INCREF ( Py_NotImplemented ) ;
return Py_NotImplemented ;
}
return PyString_Format ( v , w ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void vapic_reset ( DeviceState * dev ) {
VAPICROMState * s = DO_UPCAST ( VAPICROMState , busdev . qdev , dev ) ;
if ( s -> state == VAPIC_ACTIVE ) {
s -> state = VAPIC_STANDBY ;
}
vapic_enable_tpr_reporting ( false ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( BrowsingDataRemoverImplTest , CompletionInhibition ) {
BrowsingDataRemoverCompletionInhibitor completion_inhibitor ;
BrowsingDataRemoverImpl * remover = static_cast < BrowsingDataRemoverImpl * > ( BrowsingDataRemoverFactory : : GetForBrowserContext ( GetBrowserContext ( ) ) ) ;
InspectableCompletionObserver completion_observer ( remover ) ;
remover -> RemoveAndReply ( base : : Time ( ) , base : : Time : : Max ( ) , BrowsingDataRemover : : REMOVE_HISTORY , BrowsingDataHelper : : UNPROTECTED_WEB , & completion_observer ) ;
completion_inhibitor . BlockUntilNearCompletion ( ) ;
base : : RunLoop ( ) . RunUntilIdle ( ) ;
EXPECT_TRUE ( remover -> is_removing ( ) ) ;
EXPECT_FALSE ( completion_observer . called ( ) ) ;
completion_inhibitor . ContinueToCompletion ( ) ;
completion_observer . BlockUntilCompletion ( ) ;
EXPECT_FALSE ( remover -> is_removing ( ) ) ;
EXPECT_TRUE ( completion_observer . called ( ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void dissect_zcl_ota_upgradeendrsp ( tvbuff_t * tvb , proto_tree * tree , guint * offset ) {
proto_tree_add_item ( tree , hf_zbee_zcl_ota_manufacturer_code , tvb , * offset , 2 , ENC_LITTLE_ENDIAN ) ;
* offset += 2 ;
proto_tree_add_item ( tree , hf_zbee_zcl_ota_image_type , tvb , * offset , 2 , ENC_LITTLE_ENDIAN ) ;
* offset += 2 ;
dissect_zcl_ota_file_version_field ( tvb , tree , offset ) ;
proto_tree_add_item ( tree , hf_zbee_zcl_ota_current_time , tvb , * offset , 4 , ENC_LITTLE_ENDIAN ) ;
* offset += 4 ;
proto_tree_add_item ( tree , hf_zbee_zcl_ota_upgrade_time , tvb , * offset , 4 , ENC_LITTLE_ENDIAN ) ;
* offset += 4 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void nameserver_read ( struct nameserver * ns ) {
u8 packet [ 1500 ] ;
struct sockaddr_storage ss ;
socklen_t addrlen = sizeof ( ss ) ;
for ( ;
;
) {
const int r = recvfrom ( ns -> socket , packet , sizeof ( packet ) , 0 , ( struct sockaddr * ) & ss , & addrlen ) ;
if ( r < 0 ) {
int err = last_error ( ns -> socket ) ;
if ( error_is_eagain ( err ) ) return ;
nameserver_failed ( ns , strerror ( err ) ) ;
return ;
}
if ( ! address_is_correct ( ns , ( struct sockaddr * ) & ss , addrlen ) ) {
log ( EVDNS_LOG_WARN , "Address mismatch on received " "DNS packet." ) ;
return ;
}
ns -> timedout = 0 ;
reply_parse ( packet , r ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int vp9_pattern_search_sad ( const MACROBLOCK * x , MV * ref_mv , int search_param , int sad_per_bit , int do_init_search , int * sad_list , const vp9_variance_fn_ptr_t * vfp , int use_mvcost , const MV * center_mv , MV * best_mv , const int num_candidates [ MAX_PATTERN_SCALES ] , const MV candidates [ MAX_PATTERN_SCALES ] [ MAX_PATTERN_CANDIDATES ] ) {
const MACROBLOCKD * const xd = & x -> e_mbd ;
static const int search_param_to_steps [ MAX_MVSEARCH_STEPS ] = {
10 , 9 , 8 , 7 , 6 , 5 , 4 , 3 , 2 , 1 , 0 , }
;
int i , s , t ;
const struct buf_2d * const what = & x -> plane [ 0 ] . src ;
const struct buf_2d * const in_what = & xd -> plane [ 0 ] . pre [ 0 ] ;
int br , bc ;
int bestsad = INT_MAX ;
int thissad ;
int k = - 1 ;
const MV fcenter_mv = {
center_mv -> row >> 3 , center_mv -> col >> 3 }
;
int best_init_s = search_param_to_steps [ search_param ] ;
clamp_mv ( ref_mv , x -> mv_col_min , x -> mv_col_max , x -> mv_row_min , x -> mv_row_max ) ;
br = ref_mv -> row ;
bc = ref_mv -> col ;
if ( sad_list != NULL ) {
sad_list [ 0 ] = sad_list [ 1 ] = sad_list [ 2 ] = sad_list [ 3 ] = sad_list [ 4 ] = INT_MAX ;
}
bestsad = vfp -> sdf ( what -> buf , what -> stride , get_buf_from_mv ( in_what , ref_mv ) , in_what -> stride ) + mvsad_err_cost ( x , ref_mv , & fcenter_mv , sad_per_bit ) ;
if ( do_init_search ) {
s = best_init_s ;
best_init_s = - 1 ;
for ( t = 0 ;
t <= s ;
++ t ) {
int best_site = - 1 ;
if ( check_bounds ( x , br , bc , 1 << t ) ) {
for ( i = 0 ;
i < num_candidates [ t ] ;
i ++ ) {
const MV this_mv = {
br + candidates [ t ] [ i ] . row , bc + candidates [ t ] [ i ] . col }
;
thissad = vfp -> sdf ( what -> buf , what -> stride , get_buf_from_mv ( in_what , & this_mv ) , in_what -> stride ) ;
CHECK_BETTER }
}
else {
for ( i = 0 ;
i < num_candidates [ t ] ;
i ++ ) {
const MV this_mv = {
br + candidates [ t ] [ i ] . row , bc + candidates [ t ] [ i ] . col }
;
if ( ! is_mv_in ( x , & this_mv ) ) continue ;
thissad = vfp -> sdf ( what -> buf , what -> stride , get_buf_from_mv ( in_what , & this_mv ) , in_what -> stride ) ;
CHECK_BETTER }
}
if ( best_site == - 1 ) {
continue ;
}
else {
best_init_s = t ;
k = best_site ;
}
}
if ( best_init_s != - 1 ) {
br += candidates [ best_init_s ] [ k ] . row ;
bc += candidates [ best_init_s ] [ k ] . col ;
}
}
if ( best_init_s != - 1 ) {
int do_sad = ( num_candidates [ 0 ] == 4 && sad_list != NULL ) ;
int best_site = - 1 ;
s = best_init_s ;
for ( ;
s >= do_sad ;
s -- ) {
if ( ! do_init_search || s != best_init_s ) {
if ( check_bounds ( x , br , bc , 1 << s ) ) {
for ( i = 0 ;
i < num_candidates [ s ] ;
i ++ ) {
const MV this_mv = {
br + candidates [ s ] [ i ] . row , bc + candidates [ s ] [ i ] . col }
;
thissad = vfp -> sdf ( what -> buf , what -> stride , get_buf_from_mv ( in_what , & this_mv ) , in_what -> stride ) ;
CHECK_BETTER }
}
else {
for ( i = 0 ;
i < num_candidates [ s ] ;
i ++ ) {
const MV this_mv = {
br + candidates [ s ] [ i ] . row , bc + candidates [ s ] [ i ] . col }
;
if ( ! is_mv_in ( x , & this_mv ) ) continue ;
thissad = vfp -> sdf ( what -> buf , what -> stride , get_buf_from_mv ( in_what , & this_mv ) , in_what -> stride ) ;
CHECK_BETTER }
}
if ( best_site == - 1 ) {
continue ;
}
else {
br += candidates [ s ] [ best_site ] . row ;
bc += candidates [ s ] [ best_site ] . col ;
k = best_site ;
}
}
do {
int next_chkpts_indices [ PATTERN_CANDIDATES_REF ] ;
best_site = - 1 ;
next_chkpts_indices [ 0 ] = ( k == 0 ) ? num_candidates [ s ] - 1 : k - 1 ;
next_chkpts_indices [ 1 ] = k ;
next_chkpts_indices [ 2 ] = ( k == num_candidates [ s ] - 1 ) ? 0 : k + 1 ;
if ( check_bounds ( x , br , bc , 1 << s ) ) {
for ( i = 0 ;
i < PATTERN_CANDIDATES_REF ;
i ++ ) {
const MV this_mv = {
br + candidates [ s ] [ next_chkpts_indices [ i ] ] . row , bc + candidates [ s ] [ next_chkpts_indices [ i ] ] . col }
;
thissad = vfp -> sdf ( what -> buf , what -> stride , get_buf_from_mv ( in_what , & this_mv ) , in_what -> stride ) ;
CHECK_BETTER }
}
else {
for ( i = 0 ;
i < PATTERN_CANDIDATES_REF ;
i ++ ) {
const MV this_mv = {
br + candidates [ s ] [ next_chkpts_indices [ i ] ] . row , bc + candidates [ s ] [ next_chkpts_indices [ i ] ] . col }
;
if ( ! is_mv_in ( x , & this_mv ) ) continue ;
thissad = vfp -> sdf ( what -> buf , what -> stride , get_buf_from_mv ( in_what , & this_mv ) , in_what -> stride ) ;
CHECK_BETTER }
}
if ( best_site != - 1 ) {
k = next_chkpts_indices [ best_site ] ;
br += candidates [ s ] [ k ] . row ;
bc += candidates [ s ] [ k ] . col ;
}
}
while ( best_site != - 1 ) ;
}
if ( s == 0 ) {
sad_list [ 0 ] = bestsad ;
if ( ! do_init_search || s != best_init_s ) {
if ( check_bounds ( x , br , bc , 1 << s ) ) {
for ( i = 0 ;
i < num_candidates [ s ] ;
i ++ ) {
const MV this_mv = {
br + candidates [ s ] [ i ] . row , bc + candidates [ s ] [ i ] . col }
;
sad_list [ i + 1 ] = thissad = vfp -> sdf ( what -> buf , what -> stride , get_buf_from_mv ( in_what , & this_mv ) , in_what -> stride ) ;
CHECK_BETTER }
}
else {
for ( i = 0 ;
i < num_candidates [ s ] ;
i ++ ) {
const MV this_mv = {
br + candidates [ s ] [ i ] . row , bc + candidates [ s ] [ i ] . col }
;
if ( ! is_mv_in ( x , & this_mv ) ) continue ;
sad_list [ i + 1 ] = thissad = vfp -> sdf ( what -> buf , what -> stride , get_buf_from_mv ( in_what , & this_mv ) , in_what -> stride ) ;
CHECK_BETTER }
}
if ( best_site != - 1 ) {
br += candidates [ s ] [ best_site ] . row ;
bc += candidates [ s ] [ best_site ] . col ;
k = best_site ;
}
}
while ( best_site != - 1 ) {
int next_chkpts_indices [ PATTERN_CANDIDATES_REF ] ;
best_site = - 1 ;
next_chkpts_indices [ 0 ] = ( k == 0 ) ? num_candidates [ s ] - 1 : k - 1 ;
next_chkpts_indices [ 1 ] = k ;
next_chkpts_indices [ 2 ] = ( k == num_candidates [ s ] - 1 ) ? 0 : k + 1 ;
sad_list [ 1 ] = sad_list [ 2 ] = sad_list [ 3 ] = sad_list [ 4 ] = INT_MAX ;
sad_list [ ( ( k + 2 ) % 4 ) + 1 ] = sad_list [ 0 ] ;
sad_list [ 0 ] = bestsad ;
if ( check_bounds ( x , br , bc , 1 << s ) ) {
for ( i = 0 ;
i < PATTERN_CANDIDATES_REF ;
i ++ ) {
const MV this_mv = {
br + candidates [ s ] [ next_chkpts_indices [ i ] ] . row , bc + candidates [ s ] [ next_chkpts_indices [ i ] ] . col }
;
sad_list [ next_chkpts_indices [ i ] + 1 ] = thissad = vfp -> sdf ( what -> buf , what -> stride , get_buf_from_mv ( in_what , & this_mv ) , in_what -> stride ) ;
CHECK_BETTER }
}
else {
for ( i = 0 ;
i < PATTERN_CANDIDATES_REF ;
i ++ ) {
const MV this_mv = {
br + candidates [ s ] [ next_chkpts_indices [ i ] ] . row , bc + candidates [ s ] [ next_chkpts_indices [ i ] ] . col }
;
if ( ! is_mv_in ( x , & this_mv ) ) {
sad_list [ next_chkpts_indices [ i ] + 1 ] = INT_MAX ;
continue ;
}
sad_list [ next_chkpts_indices [ i ] + 1 ] = thissad = vfp -> sdf ( what -> buf , what -> stride , get_buf_from_mv ( in_what , & this_mv ) , in_what -> stride ) ;
CHECK_BETTER }
}
if ( best_site != - 1 ) {
k = next_chkpts_indices [ best_site ] ;
br += candidates [ s ] [ k ] . row ;
bc += candidates [ s ] [ k ] . col ;
}
}
}
}
if ( sad_list ) {
static const MV neighbors [ 4 ] = {
{
0 , - 1 }
, {
1 , 0 }
, {
0 , 1 }
, {
- 1 , 0 }
}
;
if ( sad_list [ 0 ] == INT_MAX ) {
sad_list [ 0 ] = bestsad ;
if ( check_bounds ( x , br , bc , 1 ) ) {
for ( i = 0 ;
i < 4 ;
i ++ ) {
const MV this_mv = {
br + neighbors [ i ] . row , bc + neighbors [ i ] . col }
;
sad_list [ i + 1 ] = vfp -> sdf ( what -> buf , what -> stride , get_buf_from_mv ( in_what , & this_mv ) , in_what -> stride ) ;
}
}
else {
for ( i = 0 ;
i < 4 ;
i ++ ) {
const MV this_mv = {
br + neighbors [ i ] . row , bc + neighbors [ i ] . col }
;
if ( ! is_mv_in ( x , & this_mv ) ) sad_list [ i + 1 ] = INT_MAX ;
else sad_list [ i + 1 ] = vfp -> sdf ( what -> buf , what -> stride , get_buf_from_mv ( in_what , & this_mv ) , in_what -> stride ) ;
}
}
}
else {
if ( use_mvcost ) {
for ( i = 0 ;
i < 4 ;
i ++ ) {
const MV this_mv = {
br + neighbors [ i ] . row , bc + neighbors [ i ] . col }
;
if ( sad_list [ i + 1 ] != INT_MAX ) {
sad_list [ i + 1 ] += mvsad_err_cost ( x , & this_mv , & fcenter_mv , sad_per_bit ) ;
}
}
}
}
}
best_mv -> row = br ;
best_mv -> col = bc ;
return bestsad ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void PNGAPI png_set_hIST ( png_structp png_ptr , png_infop info_ptr , png_uint_16p hist ) {
int i ;
png_debug1 ( 1 , "in %s storage function" , "hIST" ) ;
if ( png_ptr == NULL || info_ptr == NULL ) return ;
if ( info_ptr -> num_palette == 0 || info_ptr -> num_palette > PNG_MAX_PALETTE_LENGTH ) {
png_warning ( png_ptr , "Invalid palette size, hIST allocation skipped." ) ;
return ;
}
# ifdef PNG_FREE_ME_SUPPORTED png_free_data ( png_ptr , info_ptr , PNG_FREE_HIST , 0 ) ;
# endif png_ptr -> hist = ( png_uint_16p ) png_malloc_warn ( png_ptr , ( png_uint_32 ) ( PNG_MAX_PALETTE_LENGTH * png_sizeof ( png_uint_16 ) ) ) ;
if ( png_ptr -> hist == NULL ) {
png_warning ( png_ptr , "Insufficient memory for hIST chunk data." ) ;
return ;
}
for ( i = 0 ;
i < info_ptr -> num_palette ;
i ++ ) png_ptr -> hist [ i ] = hist [ i ] ;
info_ptr -> hist = png_ptr -> hist ;
info_ptr -> valid |= PNG_INFO_hIST ;
# ifdef PNG_FREE_ME_SUPPORTED info_ptr -> free_me |= PNG_FREE_HIST ;
# else png_ptr -> flags |= PNG_FLAG_FREE_HIST ;
# endif }
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void proto_register_amf ( void ) {
static hf_register_info hf [ ] = {
{
& hf_amf_version , {
"AMF version" , "amf.version" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_amf_header_count , {
"Header count" , "amf.header_count" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_amf_header_name , {
"Name" , "amf.header.name" , FT_UINT_STRING , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_amf_header_must_understand , {
"Must understand" , "amf.header.must_understand" , FT_BOOLEAN , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_amf_header_length , {
"Length" , "amf.header.length" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, # if 0 {
& hf_amf_header_value_type , {
"Value type" , "amf.header.value_type" , FT_UINT32 , BASE_HEX , VALS ( rtmpt_type_vals ) , 0x0 , NULL , HFILL }
}
, # endif {
& hf_amf_message_count , {
"Message count" , "amf.message_count" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_amf_message_target_uri , {
"Target URI" , "amf.message.target_uri" , FT_UINT_STRING , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_amf_message_response_uri , {
"Response URI" , "amf.message.response_uri" , FT_UINT_STRING , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_amf_message_length , {
"Length" , "amf.message.length" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_amf_amf0_type , {
"AMF0 type" , "amf.amf0_type" , FT_UINT8 , BASE_HEX , VALS ( amf0_type_vals ) , 0x0 , NULL , HFILL }
}
, {
& hf_amf_amf3_type , {
"AMF3 type" , "amf.amf3_type" , FT_UINT8 , BASE_HEX , VALS ( amf3_type_vals ) , 0x0 , NULL , HFILL }
}
, {
& hf_amf_number , {
"Number" , "amf.number" , FT_DOUBLE , BASE_NONE , NULL , 0x0 , "AMF number" , HFILL }
}
, {
& hf_amf_integer , {
"Integer" , "amf.integer" , FT_UINT32 , BASE_DEC , NULL , 0x0 , "RTMPT AMF3 integer" , HFILL }
}
, {
& hf_amf_boolean , {
"Boolean" , "amf.boolean" , FT_BOOLEAN , BASE_NONE , NULL , 0x0 , "AMF boolean" , HFILL }
}
, {
& hf_amf_stringlength , {
"String length" , "amf.stringlength" , FT_UINT32 , BASE_DEC , NULL , 0x0 , "AMF string length" , HFILL }
}
, {
& hf_amf_string , {
"String" , "amf.string" , FT_STRING , BASE_NONE , NULL , 0x0 , "AMF string" , HFILL }
}
, {
& hf_amf_string_reference , {
"String reference" , "amf.string_reference" , FT_UINT32 , BASE_DEC , NULL , 0x0 , "RTMPT AMF3 string reference" , HFILL }
}
, {
& hf_amf_object_reference , {
"Object reference" , "amf.object_reference" , FT_UINT32 , BASE_DEC , NULL , 0x0 , "AMF object reference" , HFILL }
}
, {
& hf_amf_date , {
"Date" , "amf.date" , FT_ABSOLUTE_TIME , ABSOLUTE_TIME_LOCAL , NULL , 0x0 , "AMF date" , HFILL }
}
, # if 0 {
& hf_amf_longstringlength , {
"String length" , "amf.longstringlength" , FT_UINT32 , BASE_DEC , NULL , 0x0 , "AMF long string length" , HFILL }
}
, # endif {
& hf_amf_longstring , {
"Long string" , "amf.longstring" , FT_STRING , BASE_NONE , NULL , 0x0 , "AMF long string" , HFILL }
}
, {
& hf_amf_xml_doc , {
"XML document" , "amf.xml_doc" , FT_STRING , BASE_NONE , NULL , 0x0 , "AMF XML document" , HFILL }
}
, {
& hf_amf_xmllength , {
"XML text length" , "amf.xmllength" , FT_UINT32 , BASE_DEC , NULL , 0x0 , "AMF E4X XML length" , HFILL }
}
, {
& hf_amf_xml , {
"XML" , "amf.xml" , FT_STRING , BASE_NONE , NULL , 0x0 , "AMF E4X XML" , HFILL }
}
, {
& hf_amf_int64 , {
"Int64" , "amf.int64" , FT_INT64 , BASE_DEC , NULL , 0x0 , "AMF int64" , HFILL }
}
, {
& hf_amf_bytearraylength , {
"ByteArray length" , "amf.bytearraylength" , FT_UINT32 , BASE_DEC , NULL , 0x0 , "RTMPT AMF3 ByteArray length" , HFILL }
}
, {
& hf_amf_bytearray , {
"ByteArray" , "amf.bytearray" , FT_BYTES , BASE_NONE , NULL , 0x0 , "RTMPT AMF3 ByteArray" , HFILL }
}
, {
& hf_amf_object , {
"Object" , "amf.object" , FT_NONE , BASE_NONE , NULL , 0x0 , "AMF object" , HFILL }
}
, {
& hf_amf_traitcount , {
"Trait count" , "amf.traitcount" , FT_UINT32 , BASE_DEC , NULL , 0x0 , "AMF count of traits for an object" , HFILL }
}
, {
& hf_amf_classnamelength , {
"Class name length" , "amf.classnamelength" , FT_UINT32 , BASE_DEC , NULL , 0x0 , "AMF class name length" , HFILL }
}
, {
& hf_amf_classname , {
"Class name" , "amf.classname" , FT_STRING , BASE_NONE , NULL , 0x0 , "AMF class name" , HFILL }
}
, {
& hf_amf_membernamelength , {
"Member name length" , "amf.membernamelength" , FT_UINT32 , BASE_DEC , NULL , 0x0 , "AMF member name length" , HFILL }
}
, {
& hf_amf_membername , {
"Member name" , "amf.membername" , FT_STRING , BASE_NONE , NULL , 0x0 , "AMF member name" , HFILL }
}
, {
& hf_amf_trait_reference , {
"Trait reference" , "amf.trait_reference" , FT_UINT32 , BASE_DEC , NULL , 0x0 , "AMF trait reference" , HFILL }
}
, {
& hf_amf_ecmaarray , {
"ECMA array" , "amf.ecmaarray" , FT_NONE , BASE_NONE , NULL , 0x0 , "AMF ECMA array" , HFILL }
}
, {
& hf_amf_strictarray , {
"Strict array" , "amf.strictarray" , FT_NONE , BASE_NONE , NULL , 0x0 , "AMF strict array" , HFILL }
}
, {
& hf_amf_array , {
"Array" , "amf.array" , FT_NONE , BASE_NONE , NULL , 0x0 , "RTMPT AMF3 array" , HFILL }
}
, {
& hf_amf_arraylength , {
"Array length" , "amf.arraylength" , FT_UINT32 , BASE_DEC , NULL , 0x0 , "AMF array length" , HFILL }
}
, {
& hf_amf_arraydenselength , {
"Length of dense portion" , "amf.arraydenselength" , FT_UINT32 , BASE_DEC , NULL , 0x0 , "AMF length of dense portion of array" , HFILL }
}
, {
& hf_amf_end_of_object_marker , {
"End Of Object Marker" , "amf.end_of_object_marker" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_amf_end_of_associative_part , {
"End of associative part" , "amf.end_of_associative_part" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_amf_end_of_dynamic_members , {
"End Of dynamic members" , "amf.end_of_dynamic_members" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, }
;
static gint * ett [ ] = {
& ett_amf , & ett_amf_headers , & ett_amf_messages , & ett_amf_value , & ett_amf_property , & ett_amf_string , & ett_amf_array_element , & ett_amf_traits , & ett_amf_trait_member , }
;
proto_amf = proto_register_protocol ( "Action Message Format" , "AMF" , "amf" ) ;
proto_register_field_array ( proto_amf , hf , array_length ( hf ) ) ;
proto_register_subtree_array ( ett , array_length ( ett ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int parse_CNatLanguageRestriction ( tvbuff_t * tvb , int offset , proto_tree * parent_tree , proto_tree * pad_tree , struct CNatLanguageRestriction * v , const char * fmt , ... ) {
proto_tree * tree ;
proto_item * item ;
va_list ap ;
guint32 cc ;
const char * txt ;
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_CNatLanguageRestriction , & item , txt ) ;
offset = parse_CFullPropSpec ( tvb , offset , tree , pad_tree , & v -> property , "Property" ) ;
offset = parse_padding ( tvb , offset , 4 , pad_tree , "padding_cc" ) ;
cc = tvb_get_letohl ( tvb , offset ) ;
proto_tree_add_uint ( tree , hf_mswsp_natlangrestrict_cc , tvb , offset , 4 , cc ) ;
offset += 4 ;
proto_tree_add_item_ret_string ( tree , hf_mswsp_natlangrestrict_phrase , tvb , offset , 2 * cc , ENC_LITTLE_ENDIAN | ENC_UCS_2 , wmem_packet_scope ( ) , & v -> phrase ) ;
offset += 2 * cc ;
offset = parse_padding ( tvb , offset , 4 , pad_tree , "padding_lcid" ) ;
v -> lcid = tvb_get_letohl ( tvb , offset ) ;
offset = parse_lcid ( tvb , offset , tree , "lcid" ) ;
proto_item_set_end ( item , tvb , offset ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int find_partition ( BlockBackend * blk , int partition , off_t * offset , off_t * size ) {
struct partition_record mbr [ 4 ] ;
uint8_t data [ MBR_SIZE ] ;
int i ;
int ext_partnum = 4 ;
int ret ;
ret = blk_pread ( blk , 0 , data , sizeof ( data ) ) ;
if ( ret < 0 ) {
error_report ( "error while reading: %s" , strerror ( - ret ) ) ;
exit ( EXIT_FAILURE ) ;
}
if ( data [ 510 ] != 0x55 || data [ 511 ] != 0xaa ) {
return - EINVAL ;
}
for ( i = 0 ;
i < 4 ;
i ++ ) {
read_partition ( & data [ 446 + 16 * i ] , & mbr [ i ] ) ;
if ( ! mbr [ i ] . system || ! mbr [ i ] . nb_sectors_abs ) {
continue ;
}
if ( mbr [ i ] . system == 0xF || mbr [ i ] . system == 0x5 ) {
struct partition_record ext [ 4 ] ;
uint8_t data1 [ MBR_SIZE ] ;
int j ;
ret = blk_pread ( blk , mbr [ i ] . start_sector_abs * MBR_SIZE , data1 , sizeof ( data1 ) ) ;
if ( ret < 0 ) {
error_report ( "error while reading: %s" , strerror ( - ret ) ) ;
exit ( EXIT_FAILURE ) ;
}
for ( j = 0 ;
j < 4 ;
j ++ ) {
read_partition ( & data1 [ 446 + 16 * j ] , & ext [ j ] ) ;
if ( ! ext [ j ] . system || ! ext [ j ] . nb_sectors_abs ) {
continue ;
}
if ( ( ext_partnum + j + 1 ) == partition ) {
* offset = ( uint64_t ) ext [ j ] . start_sector_abs << 9 ;
* size = ( uint64_t ) ext [ j ] . nb_sectors_abs << 9 ;
return 0 ;
}
}
ext_partnum += 4 ;
}
else if ( ( i + 1 ) == partition ) {
* offset = ( uint64_t ) mbr [ i ] . start_sector_abs << 9 ;
* size = ( uint64_t ) mbr [ i ] . nb_sectors_abs << 9 ;
return 0 ;
}
}
return - ENOENT ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static const char * cmd_upload_dir ( cmd_parms * cmd , void * _dcfg , const char * p1 ) {
directory_config * dcfg = ( directory_config * ) _dcfg ;
if ( dcfg == NULL ) return NULL ;
if ( strcasecmp ( p1 , "none" ) == 0 ) dcfg -> upload_dir = NULL ;
else dcfg -> upload_dir = ap_server_root_relative ( cmd -> pool , p1 ) ;
return NULL ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( ExtensionServiceSyncTest , ProcessSyncDataNewExtension ) {
InitializeEmptyExtensionService ( ) ;
extension_sync_service ( ) -> MergeDataAndStartSyncing ( syncer : : EXTENSIONS , syncer : : SyncDataList ( ) , base : : MakeUnique < syncer : : FakeSyncChangeProcessor > ( ) , base : : MakeUnique < syncer : : SyncErrorFactoryMock > ( ) ) ;
const base : : FilePath path = data_dir ( ) . AppendASCII ( "good.crx" ) ;
const ExtensionPrefs * prefs = ExtensionPrefs : : Get ( profile ( ) ) ;
struct TestCase {
const char * name ;
bool sync_enabled ;
int sync_disable_reasons ;
int expect_disable_reasons ;
bool expect_permissions_granted ;
}
test_cases [ ] = {
{
"Standard" , true , 0 , 0 , true }
, {
"Disabled" , false , extensions : : disable_reason : : DISABLE_USER_ACTION , extensions : : disable_reason : : DISABLE_USER_ACTION , true }
, {
"Legacy" , false , - 1 , extensions : : disable_reason : : DISABLE_USER_ACTION , true }
, {
"PermissionsIncrease" , false , extensions : : disable_reason : : DISABLE_PERMISSIONS_INCREASE , extensions : : disable_reason : : DISABLE_PERMISSIONS_INCREASE , false }
, }
;
for ( const TestCase & test_case : test_cases ) {
SCOPED_TRACE ( test_case . name ) ;
sync_pb : : EntitySpecifics specifics ;
sync_pb : : ExtensionSpecifics * ext_specifics = specifics . mutable_extension ( ) ;
ext_specifics -> set_id ( good_crx ) ;
ext_specifics -> set_version ( base : : Version ( "1" ) . GetString ( ) ) ;
ext_specifics -> set_enabled ( test_case . sync_enabled ) ;
if ( test_case . sync_disable_reasons != - 1 ) ext_specifics -> set_disable_reasons ( test_case . sync_disable_reasons ) ;
SyncChangeList list = MakeSyncChangeList ( good_crx , specifics , SyncChange : : ACTION_UPDATE ) ;
extension_sync_service ( ) -> ProcessSyncChanges ( FROM_HERE , list ) ;
ASSERT_TRUE ( service ( ) -> pending_extension_manager ( ) -> IsIdPending ( good_crx ) ) ;
UpdateExtension ( good_crx , path , test_case . sync_enabled ? ENABLED : DISABLED ) ;
EXPECT_EQ ( test_case . expect_disable_reasons , prefs -> GetDisableReasons ( good_crx ) ) ;
std : : unique_ptr < const PermissionSet > permissions = prefs -> GetGrantedPermissions ( good_crx ) ;
EXPECT_EQ ( test_case . expect_permissions_granted , ! permissions -> IsEmpty ( ) ) ;
ASSERT_FALSE ( service ( ) -> pending_extension_manager ( ) -> IsIdPending ( good_crx ) ) ;
UninstallExtension ( good_crx , false , test_case . sync_enabled ? Extension : : ENABLED : Extension : : DISABLED ) ;
}
}
TEST_F ( ExtensionServiceSyncTest , ProcessSyncDataTerminatedExtension ) {
InitializeExtensionServiceWithUpdater ( ) ;
extension_sync_service ( ) -> MergeDataAndStartSyncing ( syncer : : EXTENSIONS , syncer : : SyncDataList ( ) , base : : MakeUnique < syncer : : FakeSyncChangeProcessor > ( ) , base : : MakeUnique < syncer : : SyncErrorFactoryMock > ( ) ) ;
InstallCRX ( data_dir ( ) . AppendASCII ( "good.crx" ) , INSTALL_NEW ) ;
TerminateExtension ( good_crx ) ;
EXPECT_TRUE ( service ( ) -> IsExtensionEnabled ( good_crx ) ) ;
EXPECT_FALSE ( extensions : : util : : IsIncognitoEnabled ( good_crx , profile ( ) ) ) ;
sync_pb : : EntitySpecifics specifics ;
sync_pb : : ExtensionSpecifics * ext_specifics = specifics . mutable_extension ( ) ;
ext_specifics -> set_id ( good_crx ) ;
ext_specifics -> set_version ( service ( ) -> GetInstalledExtension ( good_crx ) -> version ( ) -> GetString ( ) ) ;
ext_specifics -> set_enabled ( false ) ;
ext_specifics -> set_incognito_enabled ( true ) ;
SyncChangeList list = MakeSyncChangeList ( good_crx , specifics , SyncChange : : ACTION_UPDATE ) ;
extension_sync_service ( ) -> ProcessSyncChanges ( FROM_HERE , list ) ;
EXPECT_FALSE ( service ( ) -> IsExtensionEnabled ( good_crx ) ) ;
EXPECT_TRUE ( extensions : : util : : IsIncognitoEnabled ( good_crx , profile ( ) ) ) ;
EXPECT_FALSE ( service ( ) -> pending_extension_manager ( ) -> IsIdPending ( good_crx ) ) ;
}
TEST_F ( ExtensionServiceSyncTest , ProcessSyncDataVersionCheck ) {
InitializeExtensionServiceWithUpdater ( ) ;
extension_sync_service ( ) -> MergeDataAndStartSyncing ( syncer : : EXTENSIONS , syncer : : SyncDataList ( ) , base : : MakeUnique < syncer : : FakeSyncChangeProcessor > ( ) , base : : MakeUnique < syncer : : SyncErrorFactoryMock > ( ) ) ;
InstallCRX ( data_dir ( ) . AppendASCII ( "good.crx" ) , INSTALL_NEW ) ;
EXPECT_TRUE ( service ( ) -> IsExtensionEnabled ( good_crx ) ) ;
EXPECT_FALSE ( extensions : : util : : IsIncognitoEnabled ( good_crx , profile ( ) ) ) ;
sync_pb : : EntitySpecifics specifics ;
sync_pb : : ExtensionSpecifics * ext_specifics = specifics . mutable_extension ( ) ;
ext_specifics -> set_id ( good_crx ) ;
ext_specifics -> set_enabled ( true ) ;
const base : : Version installed_version = * service ( ) -> GetInstalledExtension ( good_crx ) -> version ( ) ;
{
ext_specifics -> set_version ( installed_version . GetString ( ) ) ;
SyncChangeList list = MakeSyncChangeList ( good_crx , specifics , SyncChange : : ACTION_UPDATE ) ;
extension_sync_service ( ) -> ProcessSyncChanges ( FROM_HERE , list ) ;
EXPECT_FALSE ( service ( ) -> updater ( ) -> WillCheckSoon ( ) ) ;
syncer : : SyncDataList data = extension_sync_service ( ) -> GetAllSyncData ( syncer : : EXTENSIONS ) ;
ASSERT_EQ ( 1u , data . size ( ) ) ;
std : : unique_ptr < ExtensionSyncData > extension_data = ExtensionSyncData : : CreateFromSyncData ( data [ 0 ] ) ;
ASSERT_TRUE ( extension_data ) ;
EXPECT_EQ ( installed_version , extension_data -> version ( ) ) ;
}
{
ext_specifics -> set_version ( "0.0.0.0" ) ;
SyncChangeList list = MakeSyncChangeList ( good_crx , specifics , SyncChange : : ACTION_UPDATE ) ;
extension_sync_service ( ) -> ProcessSyncChanges ( FROM_HERE , list ) ;
EXPECT_FALSE ( service ( ) -> updater ( ) -> WillCheckSoon ( ) ) ;
syncer : : SyncDataList data = extension_sync_service ( ) -> GetAllSyncData ( syncer : : EXTENSIONS ) ;
ASSERT_EQ ( 1u , data . size ( ) ) ;
std : : unique_ptr < ExtensionSyncData > extension_data = ExtensionSyncData : : CreateFromSyncData ( data [ 0 ] ) ;
ASSERT_TRUE ( extension_data ) ;
EXPECT_EQ ( installed_version , extension_data -> version ( ) ) ;
}
{
const base : : Version new_version ( "9.9.9.9" ) ;
ext_specifics -> set_version ( new_version . GetString ( ) ) ;
SyncChangeList list = MakeSyncChangeList ( good_crx , specifics , SyncChange : : ACTION_UPDATE ) ;
extension_sync_service ( ) -> ProcessSyncChanges ( FROM_HERE , list ) ;
EXPECT_TRUE ( service ( ) -> updater ( ) -> WillCheckSoon ( ) ) ;
syncer : : SyncDataList data = extension_sync_service ( ) -> GetAllSyncData ( syncer : : EXTENSIONS ) ;
ASSERT_EQ ( 1u , data . size ( ) ) ;
std : : unique_ptr < ExtensionSyncData > extension_data = ExtensionSyncData : : CreateFromSyncData ( data [ 0 ] ) ;
ASSERT_TRUE ( extension_data ) ;
EXPECT_EQ ( new_version , extension_data -> version ( ) ) ;
}
EXPECT_FALSE ( service ( ) -> pending_extension_manager ( ) -> IsIdPending ( good_crx ) ) ;
}
TEST_F ( ExtensionServiceSyncTest , ProcessSyncDataNotInstalled ) {
InitializeExtensionServiceWithUpdater ( ) ;
extension_sync_service ( ) -> MergeDataAndStartSyncing ( syncer : : EXTENSIONS , syncer : : SyncDataList ( ) , base : : MakeUnique < syncer : : FakeSyncChangeProcessor > ( ) , base : : MakeUnique < syncer : : SyncErrorFactoryMock > ( ) ) ;
sync_pb : : EntitySpecifics specifics ;
sync_pb : : ExtensionSpecifics * ext_specifics = specifics . mutable_extension ( ) ;
ext_specifics -> set_id ( good_crx ) ;
ext_specifics -> set_enabled ( false ) ;
ext_specifics -> set_incognito_enabled ( true ) ;
ext_specifics -> set_update_url ( "http://www.google.com/" ) ;
ext_specifics -> set_version ( "1.2.3.4" ) ;
SyncChangeList list = MakeSyncChangeList ( good_crx , specifics , SyncChange : : ACTION_UPDATE ) ;
EXPECT_TRUE ( service ( ) -> IsExtensionEnabled ( good_crx ) ) ;
EXPECT_FALSE ( extensions : : util : : IsIncognitoEnabled ( good_crx , profile ( ) ) ) ;
extension_sync_service ( ) -> ProcessSyncChanges ( FROM_HERE , list ) ;
EXPECT_TRUE ( service ( ) -> updater ( ) -> WillCheckSoon ( ) ) ;
EXPECT_FALSE ( service ( ) -> IsExtensionEnabled ( good_crx ) ) ;
EXPECT_TRUE ( extensions : : util : : IsIncognitoEnabled ( good_crx , profile ( ) ) ) ;
const extensions : : PendingExtensionInfo * info ;
EXPECT_TRUE ( ( info = service ( ) -> pending_extension_manager ( ) -> GetById ( good_crx ) ) ) ;
EXPECT_EQ ( ext_specifics -> update_url ( ) , info -> update_url ( ) . spec ( ) ) ;
EXPECT_TRUE ( info -> is_from_sync ( ) ) ;
EXPECT_EQ ( Manifest : : INTERNAL , info -> install_source ( ) ) ;
}
TEST_F ( ExtensionServiceSyncTest , ProcessSyncDataEnableDisable ) {
InitializeEmptyExtensionService ( ) ;
extension_sync_service ( ) -> MergeDataAndStartSyncing ( syncer : : EXTENSIONS , syncer : : SyncDataList ( ) , base : : MakeUnique < syncer : : FakeSyncChangeProcessor > ( ) , base : : MakeUnique < syncer : : SyncErrorFactoryMock > ( ) ) ;
const ExtensionPrefs * prefs = ExtensionPrefs : : Get ( profile ( ) ) ;
struct TestCase {
const char * name ;
int previous_disable_reasons ;
bool sync_enable ;
int sync_disable_reasons ;
int expect_disable_reasons ;
}
test_cases [ ] = {
{
"NopEnable" , 0 , true , 0 , 0 }
, {
"NopDisable" , extensions : : disable_reason : : DISABLE_USER_ACTION , false , extensions : : disable_reason : : DISABLE_USER_ACTION , extensions : : disable_reason : : DISABLE_USER_ACTION }
, {
"Enable" , extensions : : disable_reason : : DISABLE_USER_ACTION , true , 0 , 0 }
, {
"Disable" , 0 , false , extensions : : disable_reason : : DISABLE_USER_ACTION , extensions : : disable_reason : : DISABLE_USER_ACTION }
, {
"AddDisableReason" , extensions : : disable_reason : : DISABLE_REMOTE_INSTALL , false , extensions : : disable_reason : : DISABLE_REMOTE_INSTALL | extensions : : disable_reason : : DISABLE_USER_ACTION , extensions : : disable_reason : : DISABLE_REMOTE_INSTALL | extensions : : disable_reason : : DISABLE_USER_ACTION }
, {
"RemoveDisableReason" , extensions : : disable_reason : : DISABLE_REMOTE_INSTALL | extensions : : disable_reason : : DISABLE_USER_ACTION , false , extensions : : disable_reason : : DISABLE_USER_ACTION , extensions : : disable_reason : : DISABLE_USER_ACTION }
, {
"PreserveLocalDisableReason" , extensions : : disable_reason : : DISABLE_RELOAD , true , 0 , extensions : : disable_reason : : DISABLE_RELOAD }
, {
"PreserveOnlyLocalDisableReason" , extensions : : disable_reason : : DISABLE_USER_ACTION | extensions : : disable_reason : : DISABLE_RELOAD , true , 0 , extensions : : disable_reason : : DISABLE_RELOAD }
, {
"M44Enable" , extensions : : disable_reason : : DISABLE_USER_ACTION , true , - 1 , 0 }
, {
"M44ReEnable" , extensions : : disable_reason : : DISABLE_USER_ACTION , true , extensions : : disable_reason : : DISABLE_USER_ACTION , 0 }
, {
"M44Disable" , 0 , false , - 1 , extensions : : disable_reason : : DISABLE_USER_ACTION }
, {
"M44ReDisable" , 0 , false , 0 , extensions : : disable_reason : : DISABLE_USER_ACTION }
, {
"M44AlreadyDisabledByUser" , extensions : : disable_reason : : DISABLE_USER_ACTION , false , - 1 , extensions : : disable_reason : : DISABLE_USER_ACTION }
, {
"M44AlreadyDisabledWithOtherReason" , extensions : : disable_reason : : DISABLE_REMOTE_INSTALL , false , - 1 , extensions : : disable_reason : : DISABLE_REMOTE_INSTALL | extensions : : disable_reason : : DISABLE_USER_ACTION }
, }
;
for ( const TestCase & test_case : test_cases ) {
SCOPED_TRACE ( test_case . name ) ;
std : : string id ;
std : : string version ;
{
const Extension * extension = InstallCRX ( data_dir ( ) . AppendASCII ( "good.crx" ) , INSTALL_NEW ) ;
ASSERT_TRUE ( extension ) ;
id = extension -> id ( ) ;
version = extension -> VersionString ( ) ;
}
ASSERT_TRUE ( registry ( ) -> enabled_extensions ( ) . Contains ( id ) ) ;
if ( test_case . previous_disable_reasons ) {
service ( ) -> DisableExtension ( id , test_case . previous_disable_reasons ) ;
ASSERT_TRUE ( registry ( ) -> disabled_extensions ( ) . Contains ( id ) ) ;
}
sync_pb : : EntitySpecifics specifics ;
sync_pb : : ExtensionSpecifics * ext_specifics = specifics . mutable_extension ( ) ;
ext_specifics -> set_id ( id ) ;
ext_specifics -> set_enabled ( test_case . sync_enable ) ;
ext_specifics -> set_version ( version ) ;
if ( test_case . sync_disable_reasons != - 1 ) ext_specifics -> set_disable_reasons ( test_case . sync_disable_reasons ) ;
SyncChangeList list = MakeSyncChangeList ( good_crx , specifics , SyncChange : : ACTION_UPDATE ) ;
extension_sync_service ( ) -> ProcessSyncChanges ( FROM_HERE , list ) ;
const bool expect_enabled = ! test_case . expect_disable_reasons ;
EXPECT_EQ ( expect_enabled , service ( ) -> IsExtensionEnabled ( id ) ) ;
EXPECT_EQ ( test_case . expect_disable_reasons , prefs -> GetDisableReasons ( id ) ) ;
UninstallExtension ( id , false , expect_enabled ? Extension : : ENABLED : Extension : : DISABLED ) ;
}
}
TEST_F ( ExtensionServiceSyncTest , ProcessSyncDataDeferredEnable ) {
base : : CommandLine : : ForCurrentProcess ( ) -> AppendSwitchASCII ( switches : : kAppsGalleryUpdateURL , "http://localhost/autoupdate/updates.xml" ) ;
InitializeEmptyExtensionService ( ) ;
extension_sync_service ( ) -> MergeDataAndStartSyncing ( syncer : : EXTENSIONS , syncer : : SyncDataList ( ) , base : : MakeUnique < syncer : : FakeSyncChangeProcessor > ( ) , base : : MakeUnique < syncer : : SyncErrorFactoryMock > ( ) ) ;
base : : FilePath base_path = data_dir ( ) . AppendASCII ( "permissions_increase" ) ;
base : : FilePath pem_path = base_path . AppendASCII ( "permissions.pem" ) ;
base : : FilePath path = base_path . AppendASCII ( "v1" ) ;
const Extension * extension = PackAndInstallCRX ( path , pem_path , INSTALL_NEW ) ;
ASSERT_TRUE ( extension ) ;
ASSERT_TRUE ( registry ( ) -> enabled_extensions ( ) . Contains ( extension -> id ( ) ) ) ;
std : : string id = extension -> id ( ) ;
path = base_path . AppendASCII ( "v2" ) ;
PackCRXAndUpdateExtension ( id , path , pem_path , DISABLED ) ;
sync_pb : : EntitySpecifics specifics ;
sync_pb : : ExtensionSpecifics * ext_specifics = specifics . mutable_extension ( ) ;
ext_specifics -> set_id ( id ) ;
ext_specifics -> set_version ( "3" ) ;
ext_specifics -> set_enabled ( true ) ;
ext_specifics -> set_disable_reasons ( extensions : : disable_reason : : DISABLE_NONE ) ;
SyncChangeList list = MakeSyncChangeList ( good_crx , specifics , SyncChange : : ACTION_UPDATE ) ;
extension_sync_service ( ) -> ProcessSyncChanges ( FROM_HERE , list ) ;
EXPECT_TRUE ( registry ( ) -> disabled_extensions ( ) . Contains ( id ) ) ;
path = base_path . AppendASCII ( "v3" ) ;
PackCRXAndUpdateExtension ( id , path , pem_path , ENABLED ) ;
}
class ExtensionServiceSyncCustomGalleryTest : public ExtensionServiceSyncTest {
public : void SetUp ( ) override {
ExtensionServiceSyncTest : : SetUp ( ) ;
base : : CommandLine : : ForCurrentProcess ( ) -> AppendSwitchASCII ( switches : : kAppsGalleryUpdateURL , "http://localhost/autoupdate/updates.xml" ) ;
}
}
;
TEST_F ( ExtensionServiceSyncCustomGalleryTest , ProcessSyncDataPermissionApproval ) {
InitializeEmptyExtensionService ( ) ;
extension_sync_service ( ) -> MergeDataAndStartSyncing ( syncer : : EXTENSIONS , syncer : : SyncDataList ( ) , base : : MakeUnique < syncer : : FakeSyncChangeProcessor > ( ) , base : : MakeUnique < syncer : : SyncErrorFactoryMock > ( ) ) ;
const base : : FilePath base_path = data_dir ( ) . AppendASCII ( "permissions_increase" ) ;
const base : : FilePath pem_path = base_path . AppendASCII ( "permissions.pem" ) ;
const base : : FilePath path_v1 = base_path . AppendASCII ( "v1" ) ;
const base : : FilePath path_v2 = base_path . AppendASCII ( "v2" ) ;
base : : ScopedTempDir crx_dir ;
ASSERT_TRUE ( crx_dir . CreateUniqueTempDir ( ) ) ;
const base : : FilePath crx_path_v1 = crx_dir . GetPath ( ) . AppendASCII ( "temp1.crx" ) ;
PackCRX ( path_v1 , pem_path , crx_path_v1 ) ;
const base : : FilePath crx_path_v2 = crx_dir . GetPath ( ) . AppendASCII ( "temp2.crx" ) ;
PackCRX ( path_v2 , pem_path , crx_path_v2 ) ;
const std : : string v1 ( "1" ) ;
const std : : string v2 ( "2" ) ;
const ExtensionPrefs * prefs = ExtensionPrefs : : Get ( profile ( ) ) ;
struct TestCase {
const char * name ;
const std : : string & sync_version ;
int sync_disable_reasons ;
int expect_disable_reasons ;
bool expect_permissions_granted ;
}
test_cases [ ] = {
{
"OldVersion" , v1 , 0 , extensions : : disable_reason : : DISABLE_PERMISSIONS_INCREASE , false }
, {
"Legacy" , v2 , - 1 , extensions : : disable_reason : : DISABLE_PERMISSIONS_INCREASE , false }
, {
"GrantPermissions" , v2 , 0 , extensions : : disable_reason : : DISABLE_NONE , true }
, }
;
for ( const TestCase & test_case : test_cases ) {
SCOPED_TRACE ( test_case . name ) ;
std : : string id ;
{
const Extension * extension = InstallCRX ( crx_path_v1 , INSTALL_NEW ) ;
ASSERT_TRUE ( extension ) ;
ASSERT_EQ ( v1 , extension -> VersionString ( ) ) ;
id = extension -> id ( ) ;
}
ASSERT_TRUE ( registry ( ) -> enabled_extensions ( ) . Contains ( id ) ) ;
std : : unique_ptr < const PermissionSet > granted_permissions_v1 = prefs -> GetGrantedPermissions ( id ) ;
UpdateExtension ( id , crx_path_v2 , DISABLED ) ;
{
const Extension * extension = registry ( ) -> disabled_extensions ( ) . GetByID ( id ) ;
ASSERT_TRUE ( extension ) ;
ASSERT_EQ ( v2 , extension -> VersionString ( ) ) ;
}
ASSERT_TRUE ( prefs -> HasDisableReason ( id , extensions : : disable_reason : : DISABLE_PERMISSIONS_INCREASE ) ) ;
std : : unique_ptr < const PermissionSet > granted_permissions_v2 = prefs -> GetGrantedPermissions ( id ) ;
ASSERT_EQ ( * granted_permissions_v1 , * granted_permissions_v2 ) ;
sync_pb : : EntitySpecifics specifics ;
sync_pb : : ExtensionSpecifics * ext_specifics = specifics . mutable_extension ( ) ;
ext_specifics -> set_id ( id ) ;
ext_specifics -> set_enabled ( true ) ;
ext_specifics -> set_version ( test_case . sync_version ) ;
if ( test_case . sync_disable_reasons != - 1 ) ext_specifics -> set_disable_reasons ( test_case . sync_disable_reasons ) ;
SyncChangeList list = MakeSyncChangeList ( good_crx , specifics , SyncChange : : ACTION_UPDATE ) ;
extension_sync_service ( ) -> ProcessSyncChanges ( FROM_HERE , list ) ;
const bool expect_enabled = ! test_case . expect_disable_reasons ;
EXPECT_EQ ( expect_enabled , service ( ) -> IsExtensionEnabled ( id ) ) ;
EXPECT_EQ ( test_case . expect_disable_reasons , prefs -> GetDisableReasons ( id ) ) ;
std : : unique_ptr < const PermissionSet > granted_permissions = prefs -> GetGrantedPermissions ( id ) ;
if ( test_case . expect_permissions_granted ) {
std : : unique_ptr < const PermissionSet > active_permissions = prefs -> GetActivePermissions ( id ) ;
EXPECT_EQ ( * granted_permissions , * active_permissions ) ;
}
else {
EXPECT_EQ ( * granted_permissions , * granted_permissions_v1 ) ;
}
UninstallExtension ( id , false , expect_enabled ? Extension : : ENABLED : Extension : : DISABLED ) ;
}
}
TEST_F ( ExtensionServiceSyncTest , DontSyncThemes ) {
InitializeEmptyExtensionService ( ) ;
ProfileSyncServiceFactory : : GetForProfile ( profile ( ) ) -> SetFirstSetupComplete ( ) ;
extension_sync_service ( ) ;
service ( ) -> Init ( ) ;
ASSERT_TRUE ( service ( ) -> is_ready ( ) ) ;
syncer : : FakeSyncChangeProcessor * processor = new syncer : : FakeSyncChangeProcessor ;
extension_sync_service ( ) -> MergeDataAndStartSyncing ( syncer : : EXTENSIONS , syncer : : SyncDataList ( ) , base : : WrapUnique ( processor ) , base : : WrapUnique ( new syncer : : SyncErrorFactoryMock ) ) ;
processor -> changes ( ) . clear ( ) ;
InstallCRX ( data_dir ( ) . AppendASCII ( "good.crx" ) , INSTALL_NEW ) ;
EXPECT_EQ ( 1u , processor -> changes ( ) . size ( ) ) ;
processor -> changes ( ) . clear ( ) ;
InstallCRX ( data_dir ( ) . AppendASCII ( "theme.crx" ) , INSTALL_NEW ) ;
content : : WindowedNotificationObserver theme_change_observer ( chrome : : NOTIFICATION_BROWSER_THEME_CHANGED , content : : Source < ThemeService > ( ThemeServiceFactory : : GetForProfile ( profile ( ) ) ) ) ;
theme_change_observer . Wait ( ) ;
EXPECT_TRUE ( processor -> changes ( ) . empty ( ) ) ;
}
# if BUILDFLAG ( ENABLE_SUPERVISED_USERS ) class ExtensionServiceTestSupervised : public ExtensionServiceSyncCustomGalleryTest , public SupervisedUserService : : Delegate {
public : ExtensionServiceTestSupervised ( ) : field_trial_list_ ( base : : MakeUnique < base : : MockEntropyProvider > ( ) ) {
}
void TearDown ( ) override {
supervised_user_service ( ) -> SetDelegate ( nullptr ) ;
ExtensionServiceSyncCustomGalleryTest : : TearDown ( ) ;
}
protected : void InitSupervisedUserInitiatedExtensionInstallFeature ( bool enabled ) {
if ( enabled ) {
scoped_feature_list_ . InitAndEnableFeature ( supervised_users : : kSupervisedUserInitiatedExtensionInstall ) ;
}
}
bool IsPendingCustodianApproval ( const std : : string & extension_id ) {
auto function = make_scoped_refptr ( new WebstorePrivateIsPendingCustodianApprovalFunction ( ) ) ;
std : : unique_ptr < base : : Value > result ( RunFunctionAndReturnSingleResult ( function . get ( ) , "[\"" + extension_id + "\"]" , browser_context ( ) ) ) ;
bool copy_bool_result = false ;
EXPECT_TRUE ( result -> GetAsBoolean ( & copy_bool_result ) ) ;
return copy_bool_result ;
}
void InitServices ( bool profile_is_supervised ) {
ExtensionServiceInitParams params = CreateDefaultInitParams ( ) ;
params . profile_is_supervised = profile_is_supervised ;
if ( profile_is_supervised ) {
params . pref_file = base : : FilePath ( ) ;
}
InitializeExtensionService ( params ) ;
StartSyncing ( syncer : : EXTENSIONS ) ;
supervised_user_service ( ) -> SetDelegate ( this ) ;
supervised_user_service ( ) -> Init ( ) ;
}
std : : string InstallPermissionsTestExtension ( bool by_custodian ) {
return InstallTestExtension ( permissions_increase , dir_path ( "1" ) , pem_path ( ) , by_custodian ) ;
}
void UpdatePermissionsTestExtension ( const std : : string & id , const std : : string & version , UpdateState expected_state ) {
UpdateTestExtension ( dir_path ( version ) , pem_path ( ) , id , version , expected_state ) ;
}
std : : string InstallNoPermissionsTestExtension ( bool by_custodian ) {
base : : FilePath base_path = data_dir ( ) . AppendASCII ( "autoupdate" ) ;
base : : FilePath pem_path = base_path . AppendASCII ( "key.pem" ) ;
base : : FilePath dir_path = base_path . AppendASCII ( "v1" ) ;
return InstallTestExtension ( autoupdate , dir_path , pem_path , by_custodian ) ;
}
void UpdateNoPermissionsTestExtension ( const std : : string & id , const std : : string & version , UpdateState expected_state ) {
base : : FilePath base_path = data_dir ( ) . AppendASCII ( "autoupdate" ) ;
base : : FilePath pem_path = base_path . AppendASCII ( "key.pem" ) ;
base : : FilePath dir_path = base_path . AppendASCII ( "v" + version ) ;
UpdateTestExtension ( dir_path , pem_path , id , version , expected_state ) ;
}
std : : string InstallTestExtension ( const std : : string & id , const base : : FilePath & dir_path , const base : : FilePath & pem_path , bool by_custodian ) {
InstallState expected_state = INSTALL_WITHOUT_LOAD ;
if ( by_custodian ) {
extensions : : util : : SetWasInstalledByCustodian ( id , profile ( ) , true ) ;
expected_state = INSTALL_NEW ;
}
const Extension * extension = PackAndInstallCRX ( dir_path , pem_path , expected_state ) ;
EXPECT_TRUE ( extension ) ;
EXPECT_EQ ( extension -> id ( ) , id ) ;
if ( by_custodian ) {
EXPECT_TRUE ( registry ( ) -> enabled_extensions ( ) . Contains ( id ) ) ;
}
else {
CheckDisabledForCustodianApproval ( id ) ;
}
EXPECT_EQ ( * extension -> version ( ) , base : : Version ( "1" ) ) ;
return id ;
}
void UpdateTestExtension ( const base : : FilePath & dir_path , const base : : FilePath & pem_path , const std : : string & id , const std : : string & version , const UpdateState & expected_state ) {
PackCRXAndUpdateExtension ( id , dir_path , pem_path , expected_state ) ;
const Extension * extension = registry ( ) -> GetInstalledExtension ( id ) ;
ASSERT_TRUE ( extension ) ;
EXPECT_EQ ( * extension -> version ( ) , base : : Version ( version ) ) ;
}
void SimulateCustodianApprovalChangeViaSync ( const std : : string & extension_id , const std : : string & version , SyncChange : : SyncChangeType type ) {
std : : string key = SupervisedUserSettingsService : : MakeSplitSettingKey ( supervised_users : : kApprovedExtensions , extension_id ) ;
syncer : : SyncData sync_data = SupervisedUserSettingsService : : CreateSyncDataForSetting ( key , base : : Value ( version ) ) ;
SyncChangeList list ( 1 , SyncChange ( FROM_HERE , type , sync_data ) ) ;
SupervisedUserSettingsService * supervised_user_settings_service = SupervisedUserSettingsServiceFactory : : GetForProfile ( profile ( ) ) ;
supervised_user_settings_service -> ProcessSyncChanges ( FROM_HERE , list ) ;
}
void CheckDisabledForCustodianApproval ( const std : : string & extension_id ) {
EXPECT_TRUE ( registry ( ) -> disabled_extensions ( ) . Contains ( extension_id ) ) ;
ExtensionPrefs * extension_prefs = ExtensionPrefs : : Get ( profile ( ) ) ;
EXPECT_TRUE ( extension_prefs -> HasDisableReason ( extension_id , extensions : : disable_reason : : DISABLE_CUSTODIAN_APPROVAL_REQUIRED ) ) ;
}
SupervisedUserService * supervised_user_service ( ) {
return SupervisedUserServiceFactory : : GetForProfile ( profile ( ) ) ;
}
static std : : string RequestId ( const std : : string & extension_id , const std : : string & version ) {
return SupervisedUserService : : GetExtensionRequestId ( extension_id , base : : Version ( version ) ) ;
}
private : bool SetActive ( bool active ) override {
return true ;
}
base : : FilePath base_path ( ) const {
return data_dir ( ) . AppendASCII ( "permissions_increase" ) ;
}
base : : FilePath dir_path ( const std : : string & version ) const {
return base_path ( ) . AppendASCII ( "v" + version ) ;
}
base : : FilePath pem_path ( ) const {
return base_path ( ) . AppendASCII ( "permissions.pem" ) ;
}
base : : FieldTrialList field_trial_list_ ;
base : : test : : ScopedFeatureList scoped_feature_list_ ;
}
;
class MockPermissionRequestCreator : public PermissionRequestCreator {
public : MockPermissionRequestCreator ( ) {
}
~ MockPermissionRequestCreator ( ) override {
}
bool IsEnabled ( ) const override {
return true ;
}
void CreateURLAccessRequest ( const GURL & url_requested , const SuccessCallback & callback ) override {
FAIL ( ) ;
}
MOCK_METHOD2 ( CreateExtensionInstallRequest , void ( const std : : string & id , const SupervisedUserService : : SuccessCallback & callback ) ) ;
MOCK_METHOD2 ( CreateExtensionUpdateRequest , void ( const std : : string & id , const SupervisedUserService : : SuccessCallback & callback ) ) ;
private : DISALLOW_COPY_AND_ASSIGN ( MockPermissionRequestCreator ) ;
}
;
TEST_F ( ExtensionServiceTestSupervised , InstallOnlyAllowedByCustodian ) {
InitServices ( true ) ;
InitSupervisedUserInitiatedExtensionInstallFeature ( false ) ;
extensions : : util : : SetWasInstalledByCustodian ( good2048 , profile ( ) , true ) ;
base : : FilePath path1 = data_dir ( ) . AppendASCII ( "good.crx" ) ;
base : : FilePath path2 = data_dir ( ) . AppendASCII ( "good2048.crx" ) ;
const Extension * extensions [ ] = {
InstallCRX ( path1 , INSTALL_FAILED ) , InstallCRX ( path2 , INSTALL_NEW ) }
;
EXPECT_FALSE ( extensions [ 0 ] ) ;
ASSERT_TRUE ( extensions [ 1 ] ) ;
EXPECT_TRUE ( registry ( ) -> enabled_extensions ( ) . Contains ( extensions [ 1 ] -> id ( ) ) ) ;
EXPECT_FALSE ( IsPendingCustodianApproval ( extensions [ 1 ] -> id ( ) ) ) ;
}
TEST_F ( ExtensionServiceTestSupervised , DelegatedAndPreinstalledExtensionIsSUFirst ) {
InitServices ( false ) ;
InitSupervisedUserInitiatedExtensionInstallFeature ( false ) ;
base : : FilePath path = data_dir ( ) . AppendASCII ( "good.crx" ) ;
const Extension * extension = InstallCRX ( path , INSTALL_NEW ) ;
std : : string id = extension -> id ( ) ;
const std : : string version ( "1.0.0.0" ) ;
EXPECT_TRUE ( registry ( ) -> enabled_extensions ( ) . Contains ( id ) ) ;
profile ( ) -> AsTestingProfile ( ) -> SetSupervisedUserId ( supervised_users : : kChildAccountSUID ) ;
EXPECT_FALSE ( registry ( ) -> enabled_extensions ( ) . Contains ( id ) ) ;
sync_pb : : EntitySpecifics specifics ;
sync_pb : : ExtensionSpecifics * ext_specifics = specifics . mutable_extension ( ) ;
ext_specifics -> set_id ( id ) ;
ext_specifics -> set_enabled ( true ) ;
ext_specifics -> set_disable_reasons ( extensions : : disable_reason : : DISABLE_NONE ) ;
ext_specifics -> set_installed_by_custodian ( true ) ;
ext_specifics -> set_version ( version ) ;
SyncChangeList list = MakeSyncChangeList ( id , specifics , SyncChange : : ACTION_UPDATE ) ;
extension_sync_service ( ) -> ProcessSyncChanges ( FROM_HERE , list ) ;
EXPECT_TRUE ( registry ( ) -> enabled_extensions ( ) . Contains ( id ) ) ;
EXPECT_TRUE ( extensions : : util : : WasInstalledByCustodian ( id , profile ( ) ) ) ;
}
TEST_F ( ExtensionServiceTestSupervised , DelegatedAndPreinstalledExtensionSyncFirst ) {
InitServices ( false ) ;
InitSupervisedUserInitiatedExtensionInstallFeature ( false ) ;
base : : FilePath path = data_dir ( ) . AppendASCII ( "good.crx" ) ;
const Extension * extension = InstallCRX ( path , INSTALL_NEW ) ;
std : : string id = extension -> id ( ) ;
const std : : string version ( "1.0.0.0" ) ;
EXPECT_TRUE ( registry ( ) -> enabled_extensions ( ) . Contains ( id ) ) ;
sync_pb : : EntitySpecifics specifics ;
sync_pb : : ExtensionSpecifics * ext_specifics = specifics . mutable_extension ( ) ;
ext_specifics -> set_id ( id ) ;
ext_specifics -> set_enabled ( true ) ;
ext_specifics -> set_disable_reasons ( extensions : : disable_reason : : DISABLE_NONE ) ;
ext_specifics -> set_installed_by_custodian ( true ) ;
ext_specifics -> set_version ( version ) ;
SyncChangeList list = MakeSyncChangeList ( id , specifics , SyncChange : : ACTION_UPDATE ) ;
extension_sync_service ( ) -> ProcessSyncChanges ( FROM_HERE , list ) ;
EXPECT_TRUE ( registry ( ) -> enabled_extensions ( ) . Contains ( id ) ) ;
EXPECT_TRUE ( extensions : : util : : WasInstalledByCustodian ( id , profile ( ) ) ) ;
}
TEST_F ( ExtensionServiceTestSupervised , InstallAllowedByCustodianAndSupervisedUser ) {
InitServices ( true ) ;
InitSupervisedUserInitiatedExtensionInstallFeature ( true ) ;
extensions : : util : : SetWasInstalledByCustodian ( good2048 , profile ( ) , true ) ;
base : : FilePath path1 = data_dir ( ) . AppendASCII ( "good.crx" ) ;
base : : FilePath path2 = data_dir ( ) . AppendASCII ( "good2048.crx" ) ;
const Extension * extensions [ ] = {
InstallCRX ( path1 , INSTALL_WITHOUT_LOAD ) , InstallCRX ( path2 , INSTALL_NEW ) }
;
ASSERT_TRUE ( extensions [ 0 ] ) ;
ASSERT_TRUE ( extensions [ 1 ] ) ;
EXPECT_TRUE ( registry ( ) -> disabled_extensions ( ) . Contains ( extensions [ 0 ] -> id ( ) ) ) ;
EXPECT_TRUE ( IsPendingCustodianApproval ( extensions [ 0 ] -> id ( ) ) ) ;
EXPECT_TRUE ( registry ( ) -> enabled_extensions ( ) . Contains ( extensions [ 1 ] -> id ( ) ) ) ;
EXPECT_FALSE ( IsPendingCustodianApproval ( extensions [ 1 ] -> id ( ) ) ) ;
}
TEST_F ( ExtensionServiceTestSupervised , PreinstalledExtensionWithSUInitiatedInstalls ) {
InitServices ( false ) ;
InitSupervisedUserInitiatedExtensionInstallFeature ( true ) ;
base : : FilePath path = data_dir ( ) . AppendASCII ( "good.crx" ) ;
const Extension * extension = InstallCRX ( path , INSTALL_NEW ) ;
std : : string id = extension -> id ( ) ;
EXPECT_TRUE ( registry ( ) -> enabled_extensions ( ) . Contains ( id ) ) ;
MockPermissionRequestCreator * creator = new MockPermissionRequestCreator ;
supervised_user_service ( ) -> AddPermissionRequestCreator ( base : : WrapUnique ( creator ) ) ;
const std : : string version ( "1.0.0.0" ) ;
EXPECT_CALL ( * creator , CreateExtensionInstallRequest ( RequestId ( good_crx , version ) , testing : : _ ) ) ;
profile ( ) -> AsTestingProfile ( ) -> SetSupervisedUserId ( supervised_users : : kChildAccountSUID ) ;
Mock : : VerifyAndClearExpectations ( creator ) ;
CheckDisabledForCustodianApproval ( id ) ;
EXPECT_TRUE ( IsPendingCustodianApproval ( id ) ) ;
}
TEST_F ( ExtensionServiceTestSupervised , PreinstalledExtensionWithoutSUInitiatedInstalls ) {
InitServices ( false ) ;
InitSupervisedUserInitiatedExtensionInstallFeature ( false ) ;
base : : FilePath path = data_dir ( ) . AppendASCII ( "good.crx" ) ;
const Extension * extension = InstallCRX ( path , INSTALL_NEW ) ;
std : : string id = extension -> id ( ) ;
EXPECT_TRUE ( registry ( ) -> enabled_extensions ( ) . Contains ( id ) ) ;
MockPermissionRequestCreator * creator = new MockPermissionRequestCreator ;
supervised_user_service ( ) -> AddPermissionRequestCreator ( base : : WrapUnique ( creator ) ) ;
const std : : string version ( "1.0.0.0" ) ;
EXPECT_CALL ( * creator , CreateExtensionInstallRequest ( testing : : _ , testing : : _ ) ) . Times ( 0 ) ;
profile ( ) -> AsTestingProfile ( ) -> SetSupervisedUserId ( supervised_users : : kChildAccountSUID ) ;
EXPECT_FALSE ( registry ( ) -> GetInstalledExtension ( id ) ) ;
}
TEST_F ( ExtensionServiceTestSupervised , ExtensionApprovalBeforeInstallation ) {
InitServices ( true ) ;
InitSupervisedUserInitiatedExtensionInstallFeature ( true ) ;
MockPermissionRequestCreator * creator = new MockPermissionRequestCreator ;
supervised_user_service ( ) -> AddPermissionRequestCreator ( base : : WrapUnique ( creator ) ) ;
std : : string id = good_crx ;
std : : string version ( "1.0.0.0" ) ;
SimulateCustodianApprovalChangeViaSync ( id , version , SyncChange : : ACTION_ADD ) ;
base : : FilePath path = data_dir ( ) . AppendASCII ( "good.crx" ) ;
InstallCRX ( path , INSTALL_NEW ) ;
EXPECT_CALL ( * creator , CreateExtensionInstallRequest ( testing : : _ , testing : : _ ) ) . Times ( 0 ) ;
EXPECT_TRUE ( registry ( ) -> enabled_extensions ( ) . Contains ( id ) ) ;
EXPECT_FALSE ( IsPendingCustodianApproval ( id ) ) ;
}
TEST_F ( ExtensionServiceTestSupervised , UpdateWithoutPermissionIncrease ) {
InitServices ( true ) ;
std : : string id = InstallNoPermissionsTestExtension ( true ) ;
std : : string version2 ( "2" ) ;
UpdateNoPermissionsTestExtension ( id , version2 , ENABLED ) ;
const Extension * extension = registry ( ) -> enabled_extensions ( ) . GetByID ( id ) ;
ASSERT_TRUE ( extension ) ;
EXPECT_EQ ( * extension -> version ( ) , base : : Version ( version2 ) ) ;
EXPECT_FALSE ( IsPendingCustodianApproval ( id ) ) ;
}
TEST_F ( ExtensionServiceTestSupervised , UpdateWithPermissionIncreaseApprovalOldVersion ) {
InitServices ( true ) ;
MockPermissionRequestCreator * creator = new MockPermissionRequestCreator ;
supervised_user_service ( ) -> AddPermissionRequestCreator ( base : : WrapUnique ( creator ) ) ;
const std : : string version1 ( "1" ) ;
const std : : string version2 ( "2" ) ;
std : : string id = InstallPermissionsTestExtension ( true ) ;
EXPECT_CALL ( * creator , CreateExtensionUpdateRequest ( RequestId ( id , version2 ) , testing : : _ ) ) ;
UpdatePermissionsTestExtension ( id , version2 , DISABLED ) ;
Mock : : VerifyAndClearExpectations ( creator ) ;
EXPECT_TRUE ( IsPendingCustodianApproval ( id ) ) ;
sync_pb : : EntitySpecifics specifics ;
sync_pb : : ExtensionSpecifics * ext_specifics = specifics . mutable_extension ( ) ;
ext_specifics -> set_id ( id ) ;
ext_specifics -> set_enabled ( true ) ;
ext_specifics -> set_disable_reasons ( extensions : : disable_reason : : DISABLE_NONE ) ;
ext_specifics -> set_installed_by_custodian ( true ) ;
ext_specifics -> set_version ( version1 ) ;
EXPECT_CALL ( * creator , CreateExtensionUpdateRequest ( RequestId ( id , version2 ) , testing : : _ ) ) ;
SyncChangeList list = MakeSyncChangeList ( id , specifics , SyncChange : : ACTION_UPDATE ) ;
extension_sync_service ( ) -> ProcessSyncChanges ( FROM_HERE , list ) ;
EXPECT_FALSE ( registry ( ) -> enabled_extensions ( ) . Contains ( id ) ) ;
EXPECT_FALSE ( extension_sync_service ( ) -> HasPendingReenable ( id , base : : Version ( version1 ) ) ) ;
EXPECT_FALSE ( extension_sync_service ( ) -> HasPendingReenable ( id , base : : Version ( version2 ) ) ) ;
Mock : : VerifyAndClearExpectations ( creator ) ;
EXPECT_TRUE ( IsPendingCustodianApproval ( id ) ) ;
}
TEST_F ( ExtensionServiceTestSupervised , UpdateWithPermissionIncreaseApprovalMatchingVersion ) {
InitServices ( true ) ;
MockPermissionRequestCreator * creator = new MockPermissionRequestCreator ;
supervised_user_service ( ) -> AddPermissionRequestCreator ( base : : WrapUnique ( creator ) ) ;
std : : string id = InstallPermissionsTestExtension ( true ) ;
const std : : string version2 ( "2" ) ;
EXPECT_CALL ( * creator , CreateExtensionUpdateRequest ( RequestId ( id , version2 ) , testing : : _ ) ) ;
UpdatePermissionsTestExtension ( id , version2 , DISABLED ) ;
Mock : : VerifyAndClearExpectations ( creator ) ;
EXPECT_TRUE ( IsPendingCustodianApproval ( id ) ) ;
sync_pb : : EntitySpecifics specifics ;
sync_pb : : ExtensionSpecifics * ext_specifics = specifics . mutable_extension ( ) ;
ext_specifics -> set_id ( id ) ;
ext_specifics -> set_enabled ( true ) ;
ext_specifics -> set_disable_reasons ( extensions : : disable_reason : : DISABLE_NONE ) ;
ext_specifics -> set_installed_by_custodian ( true ) ;
ext_specifics -> set_version ( version2 ) ;
SyncChangeList list = MakeSyncChangeList ( id , specifics , SyncChange : : ACTION_UPDATE ) ;
extension_sync_service ( ) -> ProcessSyncChanges ( FROM_HERE , list ) ;
EXPECT_TRUE ( registry ( ) -> enabled_extensions ( ) . Contains ( id ) ) ;
EXPECT_FALSE ( IsPendingCustodianApproval ( id ) ) ;
}
TEST_F ( ExtensionServiceTestSupervised , UpdateWithPermissionIncreaseApprovalNewVersion ) {
InitServices ( true ) ;
MockPermissionRequestCreator * creator = new MockPermissionRequestCreator ;
supervised_user_service ( ) -> AddPermissionRequestCreator ( base : : WrapUnique ( creator ) ) ;
std : : string id = InstallPermissionsTestExtension ( true ) ;
const std : : string version2 ( "2" ) ;
EXPECT_CALL ( * creator , CreateExtensionUpdateRequest ( RequestId ( id , version2 ) , testing : : _ ) ) ;
UpdatePermissionsTestExtension ( id , version2 , DISABLED ) ;
Mock : : VerifyAndClearExpectations ( creator ) ;
const std : : string version3 ( "3" ) ;
sync_pb : : EntitySpecifics specifics ;
sync_pb : : ExtensionSpecifics * ext_specifics = specifics . mutable_extension ( ) ;
ext_specifics -> set_id ( id ) ;
ext_specifics -> set_enabled ( true ) ;
ext_specifics -> set_disable_reasons ( extensions : : disable_reason : : DISABLE_NONE ) ;
ext_specifics -> set_installed_by_custodian ( true ) ;
ext_specifics -> set_version ( version3 ) ;
EXPECT_CALL ( * creator , CreateExtensionUpdateRequest ( RequestId ( id , version3 ) , testing : : _ ) ) . Times ( 0 ) ;
SyncChangeList list = MakeSyncChangeList ( id , specifics , SyncChange : : ACTION_UPDATE ) ;
extension_sync_service ( ) -> ProcessSyncChanges ( FROM_HERE , list ) ;
EXPECT_FALSE ( registry ( ) -> enabled_extensions ( ) . Contains ( id ) ) ;
EXPECT_TRUE ( extension_sync_service ( ) -> HasPendingReenable ( id , base : : Version ( version3 ) ) ) ;
UpdatePermissionsTestExtension ( id , version3 , ENABLED ) ;
}
TEST_F ( ExtensionServiceTestSupervised , SupervisedUserInitiatedInstalls ) {
InitSupervisedUserInitiatedExtensionInstallFeature ( true ) ;
InitServices ( true ) ;
MockPermissionRequestCreator * creator = new MockPermissionRequestCreator ;
supervised_user_service ( ) -> AddPermissionRequestCreator ( base : : WrapUnique ( creator ) ) ;
base : : FilePath path = data_dir ( ) . AppendASCII ( "good.crx" ) ;
std : : string version ( "1.0.0.0" ) ;
EXPECT_CALL ( * creator , CreateExtensionInstallRequest ( RequestId ( good_crx , version ) , testing : : _ ) ) ;
const Extension * extension = InstallCRX ( path , INSTALL_WITHOUT_LOAD ) ;
ASSERT_TRUE ( extension ) ;
ASSERT_EQ ( extension -> id ( ) , good_crx ) ;
EXPECT_TRUE ( registry ( ) -> disabled_extensions ( ) . Contains ( good_crx ) ) ;
Mock : : VerifyAndClearExpectations ( creator ) ;
EXPECT_TRUE ( IsPendingCustodianApproval ( extension -> id ( ) ) ) ;
SimulateCustodianApprovalChangeViaSync ( good_crx , version , SyncChange : : ACTION_ADD ) ;
EXPECT_TRUE ( registry ( ) -> enabled_extensions ( ) . Contains ( good_crx ) ) ;
EXPECT_FALSE ( IsPendingCustodianApproval ( extension -> id ( ) ) ) ;
SimulateCustodianApprovalChangeViaSync ( good_crx , version , SyncChange : : ACTION_DELETE ) ;
EXPECT_TRUE ( registry ( ) -> disabled_extensions ( ) . Contains ( good_crx ) ) ;
EXPECT_TRUE ( IsPendingCustodianApproval ( extension -> id ( ) ) ) ;
}
TEST_F ( ExtensionServiceTestSupervised , UpdateSUInitiatedInstallWithoutPermissionIncrease ) {
InitSupervisedUserInitiatedExtensionInstallFeature ( true ) ;
InitServices ( true ) ;
std : : string id = InstallNoPermissionsTestExtension ( false ) ;
std : : string version1 ( "1" ) ;
SimulateCustodianApprovalChangeViaSync ( id , version1 , SyncChange : : ACTION_ADD ) ;
EXPECT_TRUE ( registry ( ) -> enabled_extensions ( ) . Contains ( id ) ) ;
std : : string version2 ( "2" ) ;
UpdateNoPermissionsTestExtension ( id , version2 , ENABLED ) ;
const Extension * extension = registry ( ) -> enabled_extensions ( ) . GetByID ( id ) ;
ASSERT_TRUE ( extension ) ;
EXPECT_EQ ( 1 , extension -> version ( ) -> CompareTo ( base : : Version ( version1 ) ) ) ;
std : : string approved_version ;
PrefService * pref_service = profile ( ) -> GetPrefs ( ) ;
const base : : DictionaryValue * approved_extensions = pref_service -> GetDictionary ( prefs : : kSupervisedUserApprovedExtensions ) ;
approved_extensions -> GetStringWithoutPathExpansion ( id , & approved_version ) ;
EXPECT_EQ ( base : : Version ( approved_version ) , * extension -> version ( ) ) ;
EXPECT_FALSE ( IsPendingCustodianApproval ( id ) ) ;
}
TEST_F ( ExtensionServiceTestSupervised , UpdateSUInitiatedInstallWithPermissionIncrease ) {
InitSupervisedUserInitiatedExtensionInstallFeature ( true ) ;
InitServices ( true ) ;
std : : string id = InstallPermissionsTestExtension ( false ) ;
std : : string version1 ( "1" ) ;
SimulateCustodianApprovalChangeViaSync ( id , version1 , SyncChange : : ACTION_ADD ) ;
EXPECT_TRUE ( registry ( ) -> enabled_extensions ( ) . Contains ( id ) ) ;
std : : string version3 ( "3" ) ;
UpdatePermissionsTestExtension ( id , version3 , DISABLED ) ;
EXPECT_FALSE ( registry ( ) -> enabled_extensions ( ) . Contains ( id ) ) ;
EXPECT_TRUE ( ExtensionPrefs : : Get ( profile ( ) ) -> HasDisableReason ( id , extensions : : disable_reason : : DISABLE_PERMISSIONS_INCREASE ) ) ;
std : : string version2 ( "2" ) ;
SimulateCustodianApprovalChangeViaSync ( id , version2 , SyncChange : : ACTION_UPDATE ) ;
EXPECT_FALSE ( registry ( ) -> enabled_extensions ( ) . Contains ( id ) ) ;
EXPECT_TRUE ( ExtensionPrefs : : Get ( profile ( ) ) -> HasDisableReason ( id , extensions : : disable_reason : : DISABLE_PERMISSIONS_INCREASE ) ) ;
EXPECT_TRUE ( ExtensionPrefs : : Get ( profile ( ) ) -> HasDisableReason ( id , extensions : : disable_reason : : DISABLE_CUSTODIAN_APPROVAL_REQUIRED ) ) ;
EXPECT_TRUE ( IsPendingCustodianApproval ( id ) ) ;
SimulateCustodianApprovalChangeViaSync ( id , version3 , SyncChange : : ACTION_UPDATE ) ;
EXPECT_TRUE ( registry ( ) -> enabled_extensions ( ) . Contains ( id ) ) ;
EXPECT_FALSE ( IsPendingCustodianApproval ( id ) ) ;
}
TEST_F ( ExtensionServiceTestSupervised , UpdateSUInitiatedInstallWithPermissionIncreaseApprovalArrivesFirst ) {
InitSupervisedUserInitiatedExtensionInstallFeature ( true ) ;
InitServices ( true ) ;
std : : string id = InstallPermissionsTestExtension ( false ) ;
std : : string version1 ( "1" ) ;
SimulateCustodianApprovalChangeViaSync ( id , version1 , SyncChange : : ACTION_ADD ) ;
EXPECT_TRUE ( registry ( ) -> enabled_extensions ( ) . Contains ( id ) ) ;
std : : string version2 ( "2" ) ;
SimulateCustodianApprovalChangeViaSync ( id , version2 , SyncChange : : ACTION_UPDATE ) ;
CheckDisabledForCustodianApproval ( id ) ;
UpdatePermissionsTestExtension ( id , version2 , ENABLED ) ;
EXPECT_TRUE ( registry ( ) -> enabled_extensions ( ) . Contains ( id ) ) ;
EXPECT_FALSE ( IsPendingCustodianApproval ( id ) ) ;
}
TEST_F ( ExtensionServiceSyncTest , SyncUninstallByCustodianSkipsPolicy ) {
InitializeEmptyExtensionService ( ) ;
extension_sync_service ( ) -> MergeDataAndStartSyncing ( syncer : : EXTENSIONS , syncer : : SyncDataList ( ) , base : : MakeUnique < syncer : : FakeSyncChangeProcessor > ( ) , base : : MakeUnique < syncer : : SyncErrorFactoryMock > ( ) ) ;
extensions : : util : : SetWasInstalledByCustodian ( good2048 , profile ( ) , true ) ;
base : : FilePath path1 = data_dir ( ) . AppendASCII ( "good.crx" ) ;
base : : FilePath path2 = data_dir ( ) . AppendASCII ( "good2048.crx" ) ;
const Extension * extensions [ ] = {
InstallCRX ( path1 , INSTALL_NEW ) , InstallCRX ( path2 , INSTALL_NEW ) }
;
extensions : : TestManagementPolicyProvider provider ( extensions : : TestManagementPolicyProvider : : PROHIBIT_MODIFY_STATUS ) ;
ExtensionSystem : : Get ( browser_context ( ) ) -> management_policy ( ) -> RegisterProvider ( & provider ) ;
SyncChangeList list ;
for ( size_t i = 0 ;
i < arraysize ( extensions ) ;
i ++ ) {
const std : : string & id = extensions [ i ] -> id ( ) ;
sync_pb : : EntitySpecifics specifics ;
sync_pb : : ExtensionSpecifics * ext_specifics = specifics . mutable_extension ( ) ;
ext_specifics -> set_id ( id ) ;
ext_specifics -> set_version ( "1.0" ) ;
ext_specifics -> set_installed_by_custodian ( extensions : : util : : WasInstalledByCustodian ( id , profile ( ) ) ) ;
syncer : : SyncData sync_data = syncer : : SyncData : : CreateLocalData ( id , "Name" , specifics ) ;
list . push_back ( SyncChange ( FROM_HERE , SyncChange : : ACTION_DELETE , sync_data ) ) ;
}
std : : string extension_ids [ ] = {
extensions [ 0 ] -> id ( ) , extensions [ 1 ] -> id ( ) }
;
extension_sync_service ( ) -> ProcessSyncChanges ( FROM_HERE , list ) ;
EXPECT_TRUE ( registry ( ) -> enabled_extensions ( ) . Contains ( extension_ids [ 0 ] ) ) ;
EXPECT_FALSE ( registry ( ) -> GenerateInstalledExtensionsSet ( ) -> Contains ( extension_ids [ 1 ] ) ) ;
}
TEST_F ( ExtensionServiceSyncTest , SyncExtensionHasAllhostsWithheld ) {
InitializeEmptyExtensionService ( ) ;
StartSyncing ( syncer : : EXTENSIONS ) ;
const std : : string kName ( "extension" ) ;
scoped_refptr < const Extension > extension = extensions : : ExtensionBuilder ( kName ) . SetLocation ( Manifest : : INTERNAL ) . AddPermission ( "*://*/*" ) . Build ( ) ;
service ( ) -> AddExtension ( extension . get ( ) ) ;
service ( ) -> GrantPermissionsAndEnableExtension ( extension . get ( ) ) ;
const std : : string id = extension -> id ( ) ;
EXPECT_TRUE ( registry ( ) -> enabled_extensions ( ) . GetByID ( id ) ) ;
sync_pb : : EntitySpecifics specifics ;
sync_pb : : ExtensionSpecifics * ext_specifics = specifics . mutable_extension ( ) ;
ext_specifics -> set_id ( id ) ;
ext_specifics -> set_name ( kName ) ;
ext_specifics -> set_version ( "1.0" ) ;
ext_specifics -> set_all_urls_enabled ( false ) ;
ext_specifics -> set_enabled ( true ) ;
SyncChangeList list = MakeSyncChangeList ( id , specifics , SyncChange : : ACTION_UPDATE ) ;
extension_sync_service ( ) -> ProcessSyncChanges ( FROM_HERE , list ) ;
const Extension * enabled_extension = registry ( ) -> enabled_extensions ( ) . GetByID ( id ) ;
ASSERT_TRUE ( enabled_extension ) ;
ScriptingPermissionsModifier modifier ( profile ( ) , enabled_extension ) ;
EXPECT_FALSE ( modifier . IsAllowedOnAllUrls ( ) ) ;
EXPECT_TRUE ( modifier . HasSetAllowedOnAllUrls ( ) ) ;
}
# endif TEST_F ( ExtensionServiceSyncTest , AppToExtension ) {
InitializeEmptyExtensionService ( ) ;
service ( ) -> Init ( ) ;
ASSERT_TRUE ( service ( ) -> is_ready ( ) ) ;
const Extension * v1 = InstallCRX ( data_dir ( ) . AppendASCII ( "sync_datatypes" ) . AppendASCII ( "v1.crx" ) , INSTALL_NEW ) ;
EXPECT_TRUE ( v1 -> is_app ( ) ) ;
EXPECT_FALSE ( v1 -> is_extension ( ) ) ;
std : : string id = v1 -> id ( ) ;
StatefulChangeProcessor extensions_processor ( syncer : : ModelType : : EXTENSIONS ) ;
StatefulChangeProcessor apps_processor ( syncer : : ModelType : : APPS ) ;
extension_sync_service ( ) -> MergeDataAndStartSyncing ( syncer : : EXTENSIONS , syncer : : SyncDataList ( ) , extensions_processor . GetWrapped ( ) , base : : WrapUnique ( new syncer : : SyncErrorFactoryMock ( ) ) ) ;
extension_sync_service ( ) -> MergeDataAndStartSyncing ( syncer : : APPS , syncer : : SyncDataList ( ) , apps_processor . GetWrapped ( ) , base : : WrapUnique ( new syncer : : SyncErrorFactoryMock ( ) ) ) ;
EXPECT_TRUE ( extensions_processor . changes ( ) . empty ( ) ) ;
EXPECT_TRUE ( extensions_processor . data ( ) . empty ( ) ) ;
EXPECT_EQ ( 1u , apps_processor . data ( ) . size ( ) ) ;
ASSERT_EQ ( 1u , apps_processor . changes ( ) . size ( ) ) ;
const SyncChange & app_change = apps_processor . changes ( ) [ 0 ] ;
EXPECT_EQ ( SyncChange : : ACTION_ADD , app_change . change_type ( ) ) ;
std : : unique_ptr < ExtensionSyncData > app_data = ExtensionSyncData : : CreateFromSyncData ( app_change . sync_data ( ) ) ;
EXPECT_TRUE ( app_data -> is_app ( ) ) ;
EXPECT_EQ ( id , app_data -> id ( ) ) ;
EXPECT_EQ ( * v1 -> version ( ) , app_data -> version ( ) ) ;
const Extension * v2 = InstallCRX ( data_dir ( ) . AppendASCII ( "sync_datatypes" ) . AppendASCII ( "v2.crx" ) , INSTALL_UPDATED ) ;
EXPECT_FALSE ( v2 -> is_app ( ) ) ;
EXPECT_TRUE ( v2 -> is_extension ( ) ) ;
EXPECT_EQ ( id , v2 -> id ( ) ) ;
ASSERT_EQ ( 1u , extensions_processor . changes ( ) . size ( ) ) ;
const SyncChange & extension_change = extensions_processor . changes ( ) [ 0 ] ;
EXPECT_EQ ( SyncChange : : ACTION_ADD , extension_change . change_type ( ) ) ;
std : : unique_ptr < ExtensionSyncData > extension_data = ExtensionSyncData : : CreateFromSyncData ( extension_change . sync_data ( ) ) ;
EXPECT_FALSE ( extension_data -> is_app ( ) ) ;
EXPECT_EQ ( id , extension_data -> id ( ) ) ;
EXPECT_EQ ( * v2 -> version ( ) , extension_data -> version ( ) ) ;
syncer : : SyncDataList extensions_data = extensions_processor . GetAllSyncData ( syncer : : EXTENSIONS ) ;
syncer : : SyncDataList apps_data = apps_processor . GetAllSyncData ( syncer : : APPS ) ;
extension_sync_service ( ) -> StopSyncing ( syncer : : EXTENSIONS ) ;
extension_sync_service ( ) -> StopSyncing ( syncer : : APPS ) ;
extension_sync_service ( ) -> MergeDataAndStartSyncing ( syncer : : EXTENSIONS , extensions_data , extensions_processor . GetWrapped ( ) , base : : WrapUnique ( new syncer : : SyncErrorFactoryMock ( ) ) ) ;
extension_sync_service ( ) -> MergeDataAndStartSyncing ( syncer : : APPS , apps_data , apps_processor . GetWrapped ( ) , base : : WrapUnique ( new syncer : : SyncErrorFactoryMock ( ) ) ) ;
bool found_delete = false ;
for ( const auto & change : apps_processor . changes ( ) ) {
if ( change . change_type ( ) == SyncChange : : ACTION_DELETE ) {
std : : unique_ptr < ExtensionSyncData > data = ExtensionSyncData : : CreateFromSyncChange ( change ) ;
if ( data -> id ( ) == id ) {
found_delete = true ;
break ;
}
}
}
EXPECT_TRUE ( found_delete ) ;
EXPECT_EQ ( 1u , extensions_processor . data ( ) . size ( ) ) ;
EXPECT_TRUE ( apps_processor . data ( ) . empty ( ) ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
const char * SSL_state_string ( const SSL * s ) {
const char * str ;
switch ( s -> state ) {
case SSL_ST_BEFORE : str = "PINIT " ;
break ;
case SSL_ST_ACCEPT : str = "AINIT " ;
break ;
case SSL_ST_CONNECT : str = "CINIT " ;
break ;
case SSL_ST_OK : str = "SSLOK " ;
break ;
# ifndef OPENSSL_NO_SSL2 case SSL2_ST_CLIENT_START_ENCRYPTION : str = "2CSENC" ;
break ;
case SSL2_ST_SERVER_START_ENCRYPTION : str = "2SSENC" ;
break ;
case SSL2_ST_SEND_CLIENT_HELLO_A : str = "2SCH_A" ;
break ;
case SSL2_ST_SEND_CLIENT_HELLO_B : str = "2SCH_B" ;
break ;
case SSL2_ST_GET_SERVER_HELLO_A : str = "2GSH_A" ;
break ;
case SSL2_ST_GET_SERVER_HELLO_B : str = "2GSH_B" ;
break ;
case SSL2_ST_SEND_CLIENT_MASTER_KEY_A : str = "2SCMKA" ;
break ;
case SSL2_ST_SEND_CLIENT_MASTER_KEY_B : str = "2SCMKB" ;
break ;
case SSL2_ST_SEND_CLIENT_FINISHED_A : str = "2SCF_A" ;
break ;
case SSL2_ST_SEND_CLIENT_FINISHED_B : str = "2SCF_B" ;
break ;
case SSL2_ST_SEND_CLIENT_CERTIFICATE_A : str = "2SCC_A" ;
break ;
case SSL2_ST_SEND_CLIENT_CERTIFICATE_B : str = "2SCC_B" ;
break ;
case SSL2_ST_SEND_CLIENT_CERTIFICATE_C : str = "2SCC_C" ;
break ;
case SSL2_ST_SEND_CLIENT_CERTIFICATE_D : str = "2SCC_D" ;
break ;
case SSL2_ST_GET_SERVER_VERIFY_A : str = "2GSV_A" ;
break ;
case SSL2_ST_GET_SERVER_VERIFY_B : str = "2GSV_B" ;
break ;
case SSL2_ST_GET_SERVER_FINISHED_A : str = "2GSF_A" ;
break ;
case SSL2_ST_GET_SERVER_FINISHED_B : str = "2GSF_B" ;
break ;
case SSL2_ST_GET_CLIENT_HELLO_A : str = "2GCH_A" ;
break ;
case SSL2_ST_GET_CLIENT_HELLO_B : str = "2GCH_B" ;
break ;
case SSL2_ST_GET_CLIENT_HELLO_C : str = "2GCH_C" ;
break ;
case SSL2_ST_SEND_SERVER_HELLO_A : str = "2SSH_A" ;
break ;
case SSL2_ST_SEND_SERVER_HELLO_B : str = "2SSH_B" ;
break ;
case SSL2_ST_GET_CLIENT_MASTER_KEY_A : str = "2GCMKA" ;
break ;
case SSL2_ST_GET_CLIENT_MASTER_KEY_B : str = "2GCMKA" ;
break ;
case SSL2_ST_SEND_SERVER_VERIFY_A : str = "2SSV_A" ;
break ;
case SSL2_ST_SEND_SERVER_VERIFY_B : str = "2SSV_B" ;
break ;
case SSL2_ST_SEND_SERVER_VERIFY_C : str = "2SSV_C" ;
break ;
case SSL2_ST_GET_CLIENT_FINISHED_A : str = "2GCF_A" ;
break ;
case SSL2_ST_GET_CLIENT_FINISHED_B : str = "2GCF_B" ;
break ;
case SSL2_ST_SEND_SERVER_FINISHED_A : str = "2SSF_A" ;
break ;
case SSL2_ST_SEND_SERVER_FINISHED_B : str = "2SSF_B" ;
break ;
case SSL2_ST_SEND_REQUEST_CERTIFICATE_A : str = "2SRC_A" ;
break ;
case SSL2_ST_SEND_REQUEST_CERTIFICATE_B : str = "2SRC_B" ;
break ;
case SSL2_ST_SEND_REQUEST_CERTIFICATE_C : str = "2SRC_C" ;
break ;
case SSL2_ST_SEND_REQUEST_CERTIFICATE_D : str = "2SRC_D" ;
break ;
case SSL2_ST_X509_GET_SERVER_CERTIFICATE : str = "2X9GSC" ;
break ;
case SSL2_ST_X509_GET_CLIENT_CERTIFICATE : str = "2X9GCC" ;
break ;
# endif # ifndef OPENSSL_NO_SSL3 case SSL3_ST_SW_FLUSH : case SSL3_ST_CW_FLUSH : str = "3FLUSH" ;
break ;
case SSL3_ST_CW_CLNT_HELLO_A : str = "3WCH_A" ;
break ;
case SSL3_ST_CW_CLNT_HELLO_B : str = "3WCH_B" ;
break ;
case SSL3_ST_CR_SRVR_HELLO_A : str = "3RSH_A" ;
break ;
case SSL3_ST_CR_SRVR_HELLO_B : str = "3RSH_B" ;
break ;
case SSL3_ST_CR_CERT_A : str = "3RSC_A" ;
break ;
case SSL3_ST_CR_CERT_B : str = "3RSC_B" ;
break ;
case SSL3_ST_CR_KEY_EXCH_A : str = "3RSKEA" ;
break ;
case SSL3_ST_CR_KEY_EXCH_B : str = "3RSKEB" ;
break ;
case SSL3_ST_CR_CERT_REQ_A : str = "3RCR_A" ;
break ;
case SSL3_ST_CR_CERT_REQ_B : str = "3RCR_B" ;
break ;
case SSL3_ST_CR_SRVR_DONE_A : str = "3RSD_A" ;
break ;
case SSL3_ST_CR_SRVR_DONE_B : str = "3RSD_B" ;
break ;
case SSL3_ST_CW_CERT_A : str = "3WCC_A" ;
break ;
case SSL3_ST_CW_CERT_B : str = "3WCC_B" ;
break ;
case SSL3_ST_CW_CERT_C : str = "3WCC_C" ;
break ;
case SSL3_ST_CW_CERT_D : str = "3WCC_D" ;
break ;
case SSL3_ST_CW_KEY_EXCH_A : str = "3WCKEA" ;
break ;
case SSL3_ST_CW_KEY_EXCH_B : str = "3WCKEB" ;
break ;
case SSL3_ST_CW_CERT_VRFY_A : str = "3WCV_A" ;
break ;
case SSL3_ST_CW_CERT_VRFY_B : str = "3WCV_B" ;
break ;
case SSL3_ST_SW_CHANGE_A : case SSL3_ST_CW_CHANGE_A : str = "3WCCSA" ;
break ;
case SSL3_ST_SW_CHANGE_B : case SSL3_ST_CW_CHANGE_B : str = "3WCCSB" ;
break ;
case SSL3_ST_SW_FINISHED_A : case SSL3_ST_CW_FINISHED_A : str = "3WFINA" ;
break ;
case SSL3_ST_SW_FINISHED_B : case SSL3_ST_CW_FINISHED_B : str = "3WFINB" ;
break ;
case SSL3_ST_SR_CHANGE_A : case SSL3_ST_CR_CHANGE_A : str = "3RCCSA" ;
break ;
case SSL3_ST_SR_CHANGE_B : case SSL3_ST_CR_CHANGE_B : str = "3RCCSB" ;
break ;
case SSL3_ST_SR_FINISHED_A : case SSL3_ST_CR_FINISHED_A : str = "3RFINA" ;
break ;
case SSL3_ST_SR_FINISHED_B : case SSL3_ST_CR_FINISHED_B : str = "3RFINB" ;
break ;
case SSL3_ST_SW_HELLO_REQ_A : str = "3WHR_A" ;
break ;
case SSL3_ST_SW_HELLO_REQ_B : str = "3WHR_B" ;
break ;
case SSL3_ST_SW_HELLO_REQ_C : str = "3WHR_C" ;
break ;
case SSL3_ST_SR_CLNT_HELLO_A : str = "3RCH_A" ;
break ;
case SSL3_ST_SR_CLNT_HELLO_B : str = "3RCH_B" ;
break ;
case SSL3_ST_SR_CLNT_HELLO_C : str = "3RCH_C" ;
break ;
case SSL3_ST_SW_SRVR_HELLO_A : str = "3WSH_A" ;
break ;
case SSL3_ST_SW_SRVR_HELLO_B : str = "3WSH_B" ;
break ;
case SSL3_ST_SW_CERT_A : str = "3WSC_A" ;
break ;
case SSL3_ST_SW_CERT_B : str = "3WSC_B" ;
break ;
case SSL3_ST_SW_KEY_EXCH_A : str = "3WSKEA" ;
break ;
case SSL3_ST_SW_KEY_EXCH_B : str = "3WSKEB" ;
break ;
case SSL3_ST_SW_CERT_REQ_A : str = "3WCR_A" ;
break ;
case SSL3_ST_SW_CERT_REQ_B : str = "3WCR_B" ;
break ;
case SSL3_ST_SW_SRVR_DONE_A : str = "3WSD_A" ;
break ;
case SSL3_ST_SW_SRVR_DONE_B : str = "3WSD_B" ;
break ;
case SSL3_ST_SR_CERT_A : str = "3RCC_A" ;
break ;
case SSL3_ST_SR_CERT_B : str = "3RCC_B" ;
break ;
case SSL3_ST_SR_KEY_EXCH_A : str = "3RCKEA" ;
break ;
case SSL3_ST_SR_KEY_EXCH_B : str = "3RCKEB" ;
break ;
case SSL3_ST_SR_CERT_VRFY_A : str = "3RCV_A" ;
break ;
case SSL3_ST_SR_CERT_VRFY_B : str = "3RCV_B" ;
break ;
# endif case SSL23_ST_CW_CLNT_HELLO_A : str = "23WCHA" ;
break ;
case SSL23_ST_CW_CLNT_HELLO_B : str = "23WCHB" ;
break ;
case SSL23_ST_CR_SRVR_HELLO_A : str = "23RSHA" ;
break ;
case SSL23_ST_CR_SRVR_HELLO_B : str = "23RSHA" ;
break ;
case SSL23_ST_SR_CLNT_HELLO_A : str = "23RCHA" ;
break ;
case SSL23_ST_SR_CLNT_HELLO_B : str = "23RCHB" ;
break ;
case DTLS1_ST_CR_HELLO_VERIFY_REQUEST_A : str = "DRCHVA" ;
break ;
case DTLS1_ST_CR_HELLO_VERIFY_REQUEST_B : str = "DRCHVB" ;
break ;
case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_A : str = "DWCHVA" ;
break ;
case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_B : str = "DWCHVB" ;
break ;
default : str = "UNKWN " ;
break ;
}
return ( str ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void idct4_sse2 ( __m128i * in ) {
const __m128i k__cospi_p16_p16 = pair_set_epi16 ( cospi_16_64 , cospi_16_64 ) ;
const __m128i k__cospi_p16_m16 = pair_set_epi16 ( cospi_16_64 , - cospi_16_64 ) ;
const __m128i k__cospi_p24_m08 = pair_set_epi16 ( cospi_24_64 , - cospi_8_64 ) ;
const __m128i k__cospi_p08_p24 = pair_set_epi16 ( cospi_8_64 , cospi_24_64 ) ;
const __m128i k__DCT_CONST_ROUNDING = _mm_set1_epi32 ( DCT_CONST_ROUNDING ) ;
__m128i u [ 8 ] , v [ 8 ] ;
transpose_4x4 ( in ) ;
u [ 0 ] = _mm_unpacklo_epi16 ( in [ 0 ] , in [ 1 ] ) ;
u [ 1 ] = _mm_unpackhi_epi16 ( in [ 0 ] , in [ 1 ] ) ;
v [ 0 ] = _mm_madd_epi16 ( u [ 0 ] , k__cospi_p16_p16 ) ;
v [ 1 ] = _mm_madd_epi16 ( u [ 0 ] , k__cospi_p16_m16 ) ;
v [ 2 ] = _mm_madd_epi16 ( u [ 1 ] , k__cospi_p24_m08 ) ;
v [ 3 ] = _mm_madd_epi16 ( u [ 1 ] , k__cospi_p08_p24 ) ;
u [ 0 ] = _mm_add_epi32 ( v [ 0 ] , k__DCT_CONST_ROUNDING ) ;
u [ 1 ] = _mm_add_epi32 ( v [ 1 ] , k__DCT_CONST_ROUNDING ) ;
u [ 2 ] = _mm_add_epi32 ( v [ 2 ] , k__DCT_CONST_ROUNDING ) ;
u [ 3 ] = _mm_add_epi32 ( v [ 3 ] , k__DCT_CONST_ROUNDING ) ;
v [ 0 ] = _mm_srai_epi32 ( u [ 0 ] , DCT_CONST_BITS ) ;
v [ 1 ] = _mm_srai_epi32 ( u [ 1 ] , DCT_CONST_BITS ) ;
v [ 2 ] = _mm_srai_epi32 ( u [ 2 ] , DCT_CONST_BITS ) ;
v [ 3 ] = _mm_srai_epi32 ( u [ 3 ] , DCT_CONST_BITS ) ;
u [ 0 ] = _mm_packs_epi32 ( v [ 0 ] , v [ 1 ] ) ;
u [ 1 ] = _mm_packs_epi32 ( v [ 3 ] , v [ 2 ] ) ;
in [ 0 ] = _mm_add_epi16 ( u [ 0 ] , u [ 1 ] ) ;
in [ 1 ] = _mm_sub_epi16 ( u [ 0 ] , u [ 1 ] ) ;
in [ 1 ] = _mm_shuffle_epi32 ( in [ 1 ] , 0x4E ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int selinux_capset ( struct cred * new , const struct cred * old , const kernel_cap_t * effective , const kernel_cap_t * inheritable , const kernel_cap_t * permitted ) {
return cred_has_perm ( old , new , PROCESS__SETCAP ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int crypto_encrypt_and_sign ( struct crypto_instance * instance , const unsigned char * buf_in , const size_t buf_in_len , unsigned char * buf_out , size_t * buf_out_len ) {
struct crypto_config_header * cch = ( struct crypto_config_header * ) buf_out ;
int err ;
cch -> crypto_cipher_type = CRYPTO_CIPHER_TYPE_2_3 ;
cch -> crypto_hash_type = CRYPTO_HASH_TYPE_2_3 ;
cch -> __pad0 = 0 ;
cch -> __pad1 = 0 ;
err = encrypt_and_sign_nss_2_3 ( instance , buf_in , buf_in_len , buf_out , buf_out_len ) ;
return err ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int count_new_keys ( int n_key_data , krb5_key_data * key_data ) {
int n ;
for ( n = 1 ;
n < n_key_data ;
n ++ ) {
if ( key_data [ n - 1 ] . key_data_kvno != key_data [ n ] . key_data_kvno ) return n ;
}
return n_key_data ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void print_help ( ) {
MEM_ROOT mem_root ;
init_alloc_root ( & mem_root , 4096 , 4096 ) ;
pop_dynamic ( & all_options ) ;
sys_var_add_options ( & all_options , sys_var : : PARSE_EARLY ) ;
add_plugin_options ( & all_options , & mem_root ) ;
sort_dynamic ( & all_options , ( qsort_cmp ) option_cmp ) ;
add_terminator ( & all_options ) ;
my_print_help ( ( my_option * ) all_options . buffer ) ;
my_print_variables ( ( my_option * ) all_options . buffer ) ;
free_root ( & mem_root , MYF ( 0 ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dwarf_elf_object_access_internals_init ( void * obj_in , dwarf_elf_handle elf , int * error ) {
dwarf_elf_object_access_internals_t * obj = ( dwarf_elf_object_access_internals_t * ) obj_in ;
char * ehdr_ident = 0 ;
Dwarf_Half machine = 0 ;
obj -> elf = elf ;
if ( ( ehdr_ident = elf_getident ( elf , NULL ) ) == NULL ) {
* error = DW_DLE_ELF_GETIDENT_ERROR ;
return DW_DLV_ERROR ;
}
obj -> is_64bit = ( ehdr_ident [ EI_CLASS ] == ELFCLASS64 ) ;
if ( ehdr_ident [ EI_DATA ] == ELFDATA2LSB ) {
obj -> endianness = DW_OBJECT_LSB ;
}
else if ( ehdr_ident [ EI_DATA ] == ELFDATA2MSB ) {
obj -> endianness = DW_OBJECT_MSB ;
}
if ( obj -> is_64bit ) {
# ifdef HAVE_ELF64_GETEHDR obj -> ehdr64 = elf64_getehdr ( elf ) ;
if ( obj -> ehdr64 == NULL ) {
* error = DW_DLE_ELF_GETEHDR_ERROR ;
return DW_DLV_ERROR ;
}
obj -> section_count = obj -> ehdr64 -> e_shnum ;
machine = obj -> ehdr64 -> e_machine ;
obj -> machine = machine ;
# else * error = DW_DLE_NO_ELF64_SUPPORT ;
return DW_DLV_ERROR ;
# endif }
else {
obj -> ehdr32 = elf32_getehdr ( elf ) ;
if ( obj -> ehdr32 == NULL ) {
* error = DW_DLE_ELF_GETEHDR_ERROR ;
return DW_DLV_ERROR ;
}
obj -> section_count = obj -> ehdr32 -> e_shnum ;
machine = obj -> ehdr32 -> e_machine ;
obj -> machine = machine ;
}
obj -> length_size = obj -> is_64bit ? 8 : 4 ;
obj -> pointer_size = obj -> is_64bit ? 8 : 4 ;
# ifdef WIN32 if ( obj -> is_64bit && machine == EM_PPC64 ) {
obj -> pointer_size = 4 ;
}
# endif if ( obj -> is_64bit && machine != EM_MIPS ) {
obj -> length_size = 4 ;
}
return DW_DLV_OK ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline Quantum GetPixelAlpha ( const Image * restrict image , const Quantum * restrict pixel ) {
if ( image -> channel_map [ AlphaPixelChannel ] . traits == UndefinedPixelTrait ) return ( OpaqueAlpha ) ;
return ( pixel [ image -> channel_map [ AlphaPixelChannel ] . offset ] ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int avi_read_packet ( AVFormatContext * s , AVPacket * pkt ) {
AVIContext * avi = s -> priv_data ;
AVIOContext * pb = s -> pb ;
int err ;
if ( CONFIG_DV_DEMUXER && avi -> dv_demux ) {
int size = avpriv_dv_get_packet ( avi -> dv_demux , pkt ) ;
if ( size >= 0 ) return size ;
else goto resync ;
}
if ( avi -> non_interleaved ) {
err = ni_prepare_read ( s ) ;
if ( err < 0 ) return err ;
}
resync : if ( avi -> stream_index >= 0 ) {
AVStream * st = s -> streams [ avi -> stream_index ] ;
AVIStream * ast = st -> priv_data ;
int size , err ;
if ( get_subtitle_pkt ( s , st , pkt ) ) return 0 ;
if ( ast -> sample_size <= 1 ) size = INT_MAX ;
else if ( ast -> sample_size < 32 ) size = 1024 * ast -> sample_size ;
else size = ast -> sample_size ;
if ( size > ast -> remaining ) size = ast -> remaining ;
avi -> last_pkt_pos = avio_tell ( pb ) ;
err = av_get_packet ( pb , pkt , size ) ;
if ( err < 0 ) return err ;
size = err ;
if ( ast -> has_pal && pkt -> size < ( unsigned ) INT_MAX / 2 ) {
uint8_t * pal ;
pal = av_packet_new_side_data ( pkt , AV_PKT_DATA_PALETTE , AVPALETTE_SIZE ) ;
if ( ! pal ) {
av_log ( s , AV_LOG_ERROR , "Failed to allocate data for palette\n" ) ;
}
else {
memcpy ( pal , ast -> pal , AVPALETTE_SIZE ) ;
ast -> has_pal = 0 ;
}
}
if ( CONFIG_DV_DEMUXER && avi -> dv_demux ) {
AVBufferRef * avbuf = pkt -> buf ;
size = avpriv_dv_produce_packet ( avi -> dv_demux , pkt , pkt -> data , pkt -> size , pkt -> pos ) ;
pkt -> buf = avbuf ;
pkt -> flags |= AV_PKT_FLAG_KEY ;
if ( size < 0 ) av_packet_unref ( pkt ) ;
}
else if ( st -> codecpar -> codec_type == AVMEDIA_TYPE_SUBTITLE && ! st -> codecpar -> codec_tag && read_gab2_sub ( s , st , pkt ) ) {
ast -> frame_offset ++ ;
avi -> stream_index = - 1 ;
ast -> remaining = 0 ;
goto resync ;
}
else {
pkt -> dts = ast -> frame_offset ;
if ( ast -> sample_size ) pkt -> dts /= ast -> sample_size ;
pkt -> stream_index = avi -> stream_index ;
if ( st -> codecpar -> codec_type == AVMEDIA_TYPE_VIDEO && st -> index_entries ) {
AVIndexEntry * e ;
int index ;
index = av_index_search_timestamp ( st , ast -> frame_offset , AVSEEK_FLAG_ANY ) ;
e = & st -> index_entries [ index ] ;
if ( index >= 0 && e -> timestamp == ast -> frame_offset ) {
if ( index == st -> nb_index_entries - 1 ) {
int key = 1 ;
uint32_t state = - 1 ;
if ( st -> codecpar -> codec_id == AV_CODEC_ID_MPEG4 ) {
const uint8_t * ptr = pkt -> data , * end = ptr + FFMIN ( size , 256 ) ;
while ( ptr < end ) {
ptr = avpriv_find_start_code ( ptr , end , & state ) ;
if ( state == 0x1B6 && ptr < end ) {
key = ! ( * ptr & 0xC0 ) ;
break ;
}
}
}
if ( ! key ) e -> flags &= ~ AVINDEX_KEYFRAME ;
}
if ( e -> flags & AVINDEX_KEYFRAME ) pkt -> flags |= AV_PKT_FLAG_KEY ;
}
}
else {
pkt -> flags |= AV_PKT_FLAG_KEY ;
}
ast -> frame_offset += get_duration ( ast , pkt -> size ) ;
}
ast -> remaining -= err ;
if ( ! ast -> remaining ) {
avi -> stream_index = - 1 ;
ast -> packet_size = 0 ;
}
if ( ! avi -> non_interleaved && pkt -> pos >= 0 && ast -> seek_pos > pkt -> pos ) {
av_packet_unref ( pkt ) ;
goto resync ;
}
ast -> seek_pos = 0 ;
if ( ! avi -> non_interleaved && st -> nb_index_entries > 1 && avi -> index_loaded > 1 ) {
int64_t dts = av_rescale_q ( pkt -> dts , st -> time_base , AV_TIME_BASE_Q ) ;
if ( avi -> dts_max - dts > 2 * AV_TIME_BASE ) {
avi -> non_interleaved = 1 ;
av_log ( s , AV_LOG_INFO , "Switching to NI mode, due to poor interleaving\n" ) ;
}
else if ( avi -> dts_max < dts ) avi -> dts_max = dts ;
}
return 0 ;
}
if ( ( err = avi_sync ( s , 0 ) ) < 0 ) return err ;
goto resync ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( ExtensionWelcomeNotificationTest , DelayedPreferenceSyncPreviouslyDismissed ) {
EXPECT_FALSE ( GetBooleanPref ( prefs : : kWelcomeNotificationDismissed ) ) ;
EXPECT_FALSE ( GetBooleanPref ( prefs : : kWelcomeNotificationDismissedLocal ) ) ;
EXPECT_FALSE ( GetBooleanPref ( prefs : : kWelcomeNotificationPreviouslyPoppedUp ) ) ;
ShowChromeNowNotification ( ) ;
EXPECT_EQ ( message_center ( ) -> add_notification_calls ( ) , 0 ) ;
EXPECT_EQ ( message_center ( ) -> remove_notification_calls ( ) , 0 ) ;
EXPECT_EQ ( message_center ( ) -> notifications_with_shown_as_popup ( ) , 0 ) ;
EXPECT_FALSE ( GetBooleanPref ( prefs : : kWelcomeNotificationDismissed ) ) ;
EXPECT_FALSE ( GetBooleanPref ( prefs : : kWelcomeNotificationDismissedLocal ) ) ;
EXPECT_FALSE ( GetBooleanPref ( prefs : : kWelcomeNotificationPreviouslyPoppedUp ) ) ;
SetBooleanPref ( prefs : : kWelcomeNotificationDismissed , true ) ;
EXPECT_TRUE ( GetBooleanPref ( prefs : : kWelcomeNotificationDismissed ) ) ;
EXPECT_FALSE ( GetBooleanPref ( prefs : : kWelcomeNotificationDismissedLocal ) ) ;
EXPECT_FALSE ( GetBooleanPref ( prefs : : kWelcomeNotificationPreviouslyPoppedUp ) ) ;
StartPreferenceSyncing ( ) ;
EXPECT_EQ ( message_center ( ) -> add_notification_calls ( ) , 0 ) ;
EXPECT_EQ ( message_center ( ) -> remove_notification_calls ( ) , 0 ) ;
EXPECT_EQ ( message_center ( ) -> notifications_with_shown_as_popup ( ) , 0 ) ;
EXPECT_TRUE ( GetBooleanPref ( prefs : : kWelcomeNotificationDismissed ) ) ;
EXPECT_FALSE ( GetBooleanPref ( prefs : : kWelcomeNotificationDismissedLocal ) ) ;
EXPECT_FALSE ( GetBooleanPref ( prefs : : kWelcomeNotificationPreviouslyPoppedUp ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void _UTF16Reset ( UConverter * cnv , UConverterResetChoice choice ) {
if ( choice <= UCNV_RESET_TO_UNICODE ) {
cnv -> mode = 0 ;
}
if ( choice != UCNV_RESET_TO_UNICODE ) {
cnv -> fromUnicodeStatus = UCNV_NEED_TO_WRITE_BOM ;
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int xwd_decode_frame ( AVCodecContext * avctx , void * data , int * got_frame , AVPacket * avpkt ) {
AVFrame * p = avctx -> coded_frame ;
const uint8_t * buf = avpkt -> data ;
int i , ret , buf_size = avpkt -> size ;
uint32_t version , header_size , vclass , ncolors ;
uint32_t xoffset , be , bpp , lsize , rsize ;
uint32_t pixformat , pixdepth , bunit , bitorder , bpad ;
uint32_t rgb [ 3 ] ;
uint8_t * ptr ;
GetByteContext gb ;
if ( buf_size < XWD_HEADER_SIZE ) return AVERROR_INVALIDDATA ;
bytestream2_init ( & gb , buf , buf_size ) ;
header_size = bytestream2_get_be32u ( & gb ) ;
version = bytestream2_get_be32u ( & gb ) ;
if ( version != XWD_VERSION ) {
av_log ( avctx , AV_LOG_ERROR , "unsupported version\n" ) ;
return AVERROR_INVALIDDATA ;
}
if ( buf_size < header_size || header_size < XWD_HEADER_SIZE ) {
av_log ( avctx , AV_LOG_ERROR , "invalid header size\n" ) ;
return AVERROR_INVALIDDATA ;
}
pixformat = bytestream2_get_be32u ( & gb ) ;
pixdepth = bytestream2_get_be32u ( & gb ) ;
avctx -> width = bytestream2_get_be32u ( & gb ) ;
avctx -> height = bytestream2_get_be32u ( & gb ) ;
xoffset = bytestream2_get_be32u ( & gb ) ;
be = bytestream2_get_be32u ( & gb ) ;
bunit = bytestream2_get_be32u ( & gb ) ;
bitorder = bytestream2_get_be32u ( & gb ) ;
bpad = bytestream2_get_be32u ( & gb ) ;
bpp = bytestream2_get_be32u ( & gb ) ;
lsize = bytestream2_get_be32u ( & gb ) ;
vclass = bytestream2_get_be32u ( & gb ) ;
rgb [ 0 ] = bytestream2_get_be32u ( & gb ) ;
rgb [ 1 ] = bytestream2_get_be32u ( & gb ) ;
rgb [ 2 ] = bytestream2_get_be32u ( & gb ) ;
bytestream2_skipu ( & gb , 8 ) ;
ncolors = bytestream2_get_be32u ( & gb ) ;
bytestream2_skipu ( & gb , header_size - ( XWD_HEADER_SIZE - 20 ) ) ;
av_log ( avctx , AV_LOG_DEBUG , "pixformat %d, pixdepth %d, bunit %d, bitorder %d, bpad %d\n" , pixformat , pixdepth , bunit , bitorder , bpad ) ;
av_log ( avctx , AV_LOG_DEBUG , "vclass %d, ncolors %d, bpp %d, be %d, lsize %d, xoffset %d\n" , vclass , ncolors , bpp , be , lsize , xoffset ) ;
av_log ( avctx , AV_LOG_DEBUG , "red %0x, green %0x, blue %0x\n" , rgb [ 0 ] , rgb [ 1 ] , rgb [ 2 ] ) ;
if ( pixformat > XWD_Z_PIXMAP ) {
av_log ( avctx , AV_LOG_ERROR , "invalid pixmap format\n" ) ;
return AVERROR_INVALIDDATA ;
}
if ( pixdepth == 0 || pixdepth > 32 ) {
av_log ( avctx , AV_LOG_ERROR , "invalid pixmap depth\n" ) ;
return AVERROR_INVALIDDATA ;
}
if ( xoffset ) {
av_log_ask_for_sample ( avctx , "unsupported xoffset %d\n" , xoffset ) ;
return AVERROR_PATCHWELCOME ;
}
if ( be > 1 ) {
av_log ( avctx , AV_LOG_ERROR , "invalid byte order\n" ) ;
return AVERROR_INVALIDDATA ;
}
if ( bitorder > 1 ) {
av_log ( avctx , AV_LOG_ERROR , "invalid bitmap bit order\n" ) ;
return AVERROR_INVALIDDATA ;
}
if ( bunit != 8 && bunit != 16 && bunit != 32 ) {
av_log ( avctx , AV_LOG_ERROR , "invalid bitmap unit\n" ) ;
return AVERROR_INVALIDDATA ;
}
if ( bpad != 8 && bpad != 16 && bpad != 32 ) {
av_log ( avctx , AV_LOG_ERROR , "invalid bitmap scan-line pad\n" ) ;
return AVERROR_INVALIDDATA ;
}
if ( bpp == 0 || bpp > 32 ) {
av_log ( avctx , AV_LOG_ERROR , "invalid bits per pixel\n" ) ;
return AVERROR_INVALIDDATA ;
}
if ( ncolors > 256 ) {
av_log ( avctx , AV_LOG_ERROR , "invalid number of entries in colormap\n" ) ;
return AVERROR_INVALIDDATA ;
}
if ( ( ret = av_image_check_size ( avctx -> width , avctx -> height , 0 , NULL ) ) < 0 ) return ret ;
rsize = FFALIGN ( avctx -> width * bpp , bpad ) / 8 ;
if ( lsize < rsize ) {
av_log ( avctx , AV_LOG_ERROR , "invalid bytes per scan-line\n" ) ;
return AVERROR_INVALIDDATA ;
}
if ( bytestream2_get_bytes_left ( & gb ) < ncolors * XWD_CMAP_SIZE + avctx -> height * lsize ) {
av_log ( avctx , AV_LOG_ERROR , "input buffer too small\n" ) ;
return AVERROR_INVALIDDATA ;
}
if ( pixformat != XWD_Z_PIXMAP ) {
av_log ( avctx , AV_LOG_ERROR , "pixmap format %d unsupported\n" , pixformat ) ;
return AVERROR_PATCHWELCOME ;
}
avctx -> pix_fmt = AV_PIX_FMT_NONE ;
switch ( vclass ) {
case XWD_STATIC_GRAY : case XWD_GRAY_SCALE : if ( bpp != 1 ) return AVERROR_INVALIDDATA ;
if ( pixdepth == 1 ) avctx -> pix_fmt = AV_PIX_FMT_MONOWHITE ;
break ;
case XWD_STATIC_COLOR : case XWD_PSEUDO_COLOR : if ( bpp == 8 ) avctx -> pix_fmt = AV_PIX_FMT_PAL8 ;
break ;
case XWD_TRUE_COLOR : case XWD_DIRECT_COLOR : if ( bpp != 16 && bpp != 24 && bpp != 32 ) return AVERROR_INVALIDDATA ;
if ( bpp == 16 && pixdepth == 15 ) {
if ( rgb [ 0 ] == 0x7C00 && rgb [ 1 ] == 0x3E0 && rgb [ 2 ] == 0x1F ) avctx -> pix_fmt = be ? AV_PIX_FMT_RGB555BE : AV_PIX_FMT_RGB555LE ;
else if ( rgb [ 0 ] == 0x1F && rgb [ 1 ] == 0x3E0 && rgb [ 2 ] == 0x7C00 ) avctx -> pix_fmt = be ? AV_PIX_FMT_BGR555BE : AV_PIX_FMT_BGR555LE ;
}
else if ( bpp == 16 && pixdepth == 16 ) {
if ( rgb [ 0 ] == 0xF800 && rgb [ 1 ] == 0x7E0 && rgb [ 2 ] == 0x1F ) avctx -> pix_fmt = be ? AV_PIX_FMT_RGB565BE : AV_PIX_FMT_RGB565LE ;
else if ( rgb [ 0 ] == 0x1F && rgb [ 1 ] == 0x7E0 && rgb [ 2 ] == 0xF800 ) avctx -> pix_fmt = be ? AV_PIX_FMT_BGR565BE : AV_PIX_FMT_BGR565LE ;
}
else if ( bpp == 24 ) {
if ( rgb [ 0 ] == 0xFF0000 && rgb [ 1 ] == 0xFF00 && rgb [ 2 ] == 0xFF ) avctx -> pix_fmt = be ? AV_PIX_FMT_RGB24 : AV_PIX_FMT_BGR24 ;
else if ( rgb [ 0 ] == 0xFF && rgb [ 1 ] == 0xFF00 && rgb [ 2 ] == 0xFF0000 ) avctx -> pix_fmt = be ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_RGB24 ;
}
else if ( bpp == 32 ) {
if ( rgb [ 0 ] == 0xFF0000 && rgb [ 1 ] == 0xFF00 && rgb [ 2 ] == 0xFF ) avctx -> pix_fmt = be ? AV_PIX_FMT_ARGB : AV_PIX_FMT_BGRA ;
else if ( rgb [ 0 ] == 0xFF && rgb [ 1 ] == 0xFF00 && rgb [ 2 ] == 0xFF0000 ) avctx -> pix_fmt = be ? AV_PIX_FMT_ABGR : AV_PIX_FMT_RGBA ;
}
bytestream2_skipu ( & gb , ncolors * XWD_CMAP_SIZE ) ;
break ;
default : av_log ( avctx , AV_LOG_ERROR , "invalid visual class\n" ) ;
return AVERROR_INVALIDDATA ;
}
if ( avctx -> pix_fmt == AV_PIX_FMT_NONE ) {
av_log_ask_for_sample ( avctx , "unknown file: bpp %d, pixdepth %d, vclass %d\n" , bpp , pixdepth , vclass ) ;
return AVERROR_PATCHWELCOME ;
}
if ( p -> data [ 0 ] ) avctx -> release_buffer ( avctx , p ) ;
p -> reference = 0 ;
if ( ( ret = ff_get_buffer ( avctx , p ) ) < 0 ) {
av_log ( avctx , AV_LOG_ERROR , "get_buffer() failed\n" ) ;
return ret ;
}
p -> key_frame = 1 ;
p -> pict_type = AV_PICTURE_TYPE_I ;
if ( avctx -> pix_fmt == AV_PIX_FMT_PAL8 ) {
uint32_t * dst = ( uint32_t * ) p -> data [ 1 ] ;
uint8_t red , green , blue ;
for ( i = 0 ;
i < ncolors ;
i ++ ) {
bytestream2_skipu ( & gb , 4 ) ;
red = bytestream2_get_byteu ( & gb ) ;
bytestream2_skipu ( & gb , 1 ) ;
green = bytestream2_get_byteu ( & gb ) ;
bytestream2_skipu ( & gb , 1 ) ;
blue = bytestream2_get_byteu ( & gb ) ;
bytestream2_skipu ( & gb , 3 ) ;
dst [ i ] = red << 16 | green << 8 | blue ;
}
}
ptr = p -> data [ 0 ] ;
for ( i = 0 ;
i < avctx -> height ;
i ++ ) {
bytestream2_get_bufferu ( & gb , ptr , rsize ) ;
bytestream2_skipu ( & gb , lsize - rsize ) ;
ptr += p -> linesize [ 0 ] ;
}
* got_frame = 1 ;
* ( AVFrame * ) data = * p ;
return buf_size ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int token_continue ( i_ctx_t * i_ctx_p , scanner_state * pstate , bool save ) {
os_ptr op = osp ;
int code ;
ref token ;
pop ( 1 ) ;
again : code = gs_scan_token ( i_ctx_p , & token , pstate ) ;
op = osp ;
switch ( code ) {
default : if ( code > 0 ) code = gs_note_error ( gs_error_syntaxerror ) ;
gs_scanner_error_object ( i_ctx_p , pstate , & i_ctx_p -> error_object ) ;
break ;
case scan_BOS : code = 0 ;
case 0 : push ( 2 ) ;
ref_assign ( op - 1 , & token ) ;
make_true ( op ) ;
break ;
case scan_EOF : push ( 1 ) ;
make_false ( op ) ;
code = 0 ;
break ;
case scan_Refill : code = gs_scan_handle_refill ( i_ctx_p , pstate , save , ztoken_continue ) ;
switch ( code ) {
case 0 : goto again ;
case o_push_estack : return code ;
}
break ;
}
if ( code <= 0 && ! save ) {
ifree_object ( pstate , "token_continue" ) ;
}
return code ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int brenext ( struct vars * v , chr pc ) {
chr c = ( chr ) pc ;
switch ( c ) {
case CHR ( '*' ) : if ( LASTTYPE ( EMPTY ) || LASTTYPE ( '(' ) || LASTTYPE ( '^' ) ) RETV ( PLAIN , c ) ;
RET ( '*' ) ;
break ;
case CHR ( '[' ) : if ( HAVE ( 6 ) && * ( v -> now + 0 ) == CHR ( '[' ) && * ( v -> now + 1 ) == CHR ( ':' ) && ( * ( v -> now + 2 ) == CHR ( '<' ) || * ( v -> now + 2 ) == CHR ( '>' ) ) && * ( v -> now + 3 ) == CHR ( ':' ) && * ( v -> now + 4 ) == CHR ( ']' ) && * ( v -> now + 5 ) == CHR ( ']' ) ) {
c = * ( v -> now + 2 ) ;
v -> now += 6 ;
NOTE ( REG_UNONPOSIX ) ;
RET ( ( c == CHR ( '<' ) ) ? '<' : '>' ) ;
}
INTOCON ( L_BRACK ) ;
if ( NEXT1 ( '^' ) ) {
v -> now ++ ;
RETV ( '[' , 0 ) ;
}
RETV ( '[' , 1 ) ;
break ;
case CHR ( '.' ) : RET ( '.' ) ;
break ;
case CHR ( '^' ) : if ( LASTTYPE ( EMPTY ) ) RET ( '^' ) ;
if ( LASTTYPE ( '(' ) ) {
NOTE ( REG_UUNSPEC ) ;
RET ( '^' ) ;
}
RETV ( PLAIN , c ) ;
break ;
case CHR ( '$' ) : if ( v -> cflags & REG_EXPANDED ) skip ( v ) ;
if ( ATEOS ( ) ) RET ( '$' ) ;
if ( NEXT2 ( '\\' , ')' ) ) {
NOTE ( REG_UUNSPEC ) ;
RET ( '$' ) ;
}
RETV ( PLAIN , c ) ;
break ;
case CHR ( '\\' ) : break ;
default : RETV ( PLAIN , c ) ;
break ;
}
assert ( c == CHR ( '\\' ) ) ;
if ( ATEOS ( ) ) FAILW ( REG_EESCAPE ) ;
c = * v -> now ++ ;
switch ( c ) {
case CHR ( '{
' ) : INTOCON ( L_BBND ) ;
NOTE ( REG_UBOUNDS ) ;
RET ( '{
' ) ;
break ;
case CHR ( '(' ) : RETV ( '(' , 1 ) ;
break ;
case CHR ( ')' ) : RETV ( ')' , c ) ;
break ;
case CHR ( '<' ) : NOTE ( REG_UNONPOSIX ) ;
RET ( '<' ) ;
break ;
case CHR ( '>' ) : NOTE ( REG_UNONPOSIX ) ;
RET ( '>' ) ;
break ;
case CHR ( '1' ) : case CHR ( '2' ) : case CHR ( '3' ) : case CHR ( '4' ) : case CHR ( '5' ) : case CHR ( '6' ) : case CHR ( '7' ) : case CHR ( '8' ) : case CHR ( '9' ) : NOTE ( REG_UBACKREF ) ;
RETV ( BACKREF , ( chr ) DIGITVAL ( c ) ) ;
break ;
default : if ( iscalnum ( c ) ) {
NOTE ( REG_UBSALNUM ) ;
NOTE ( REG_UUNSPEC ) ;
}
RETV ( PLAIN , c ) ;
break ;
}
assert ( NOTREACHED ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void vble_restore_plane ( VBLEContext * ctx , int plane , int offset , int width , int height ) {
AVFrame * pic = ctx -> avctx -> coded_frame ;
uint8_t * dst = pic -> data [ plane ] ;
uint8_t * val = ctx -> val + offset ;
int stride = pic -> linesize [ plane ] ;
int i , j , left , left_top ;
for ( i = 0 ;
i < height ;
i ++ ) {
for ( j = 0 ;
j < width ;
j ++ ) val [ j ] = ( val [ j ] >> 1 ) ^ - ( val [ j ] & 1 ) ;
if ( i ) {
left = 0 ;
left_top = dst [ - stride ] ;
ctx -> dsp . add_hfyu_median_prediction ( dst , dst - stride , val , width , & left , & left_top ) ;
}
else {
dst [ 0 ] = val [ 0 ] ;
for ( j = 1 ;
j < width ;
j ++ ) dst [ j ] = val [ j ] + dst [ j - 1 ] ;
}
dst += stride ;
val += width ;
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static const char * flat_escape_key_str ( AVBPrint * dst , const char * src , const char sep ) {
const char * p ;
for ( p = src ;
* p ;
p ++ ) {
if ( ! ( ( * p >= '0' && * p <= '9' ) || ( * p >= 'a' && * p <= 'z' ) || ( * p >= 'A' && * p <= 'Z' ) ) ) av_bprint_chars ( dst , '_' , 1 ) ;
else av_bprint_chars ( dst , * p , 1 ) ;
}
return dst -> str ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static char * nexttok ( char * * str ) {
register char * cp ;
char * starttok ;
cp = * str ;
while ( * cp == ' ' || * cp == '\t' ) cp ++ ;
starttok = cp ;
while ( * cp != '\0' && * cp != '\n' && * cp != ' ' && * cp != '\t' && * cp != '#' ) cp ++ ;
if ( starttok == cp ) return NULL ;
if ( * cp == ' ' || * cp == '\t' ) * cp ++ = '\0' ;
else * cp = '\0' ;
* str = cp ;
return starttok ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void decFinalize ( decNumber * dn , decContext * set , Int * residue , uInt * status ) {
Int shift ;
Int tinyexp = set -> emin - dn -> digits + 1 ;
if ( dn -> exponent <= tinyexp ) {
Int comp ;
decNumber nmin ;
if ( dn -> exponent < tinyexp ) {
decSetSubnormal ( dn , set , residue , status ) ;
return ;
}
uprv_decNumberZero ( & nmin ) ;
nmin . lsu [ 0 ] = 1 ;
nmin . exponent = set -> emin ;
comp = decCompare ( dn , & nmin , 1 ) ;
if ( comp == BADINT ) {
* status |= DEC_Insufficient_storage ;
return ;
}
if ( * residue < 0 && comp == 0 ) {
decApplyRound ( dn , set , * residue , status ) ;
decSetSubnormal ( dn , set , residue , status ) ;
return ;
}
}
if ( * residue != 0 ) decApplyRound ( dn , set , * residue , status ) ;
if ( dn -> exponent <= set -> emax - set -> digits + 1 ) return ;
if ( dn -> exponent > set -> emax - dn -> digits + 1 ) {
decSetOverflow ( dn , set , status ) ;
return ;
}
if ( ! set -> clamp ) return ;
shift = dn -> exponent - ( set -> emax - set -> digits + 1 ) ;
if ( ! ISZERO ( dn ) ) {
dn -> digits = decShiftToMost ( dn -> lsu , dn -> digits , shift ) ;
}
dn -> exponent -= shift ;
* status |= DEC_Clamped ;
return ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int decodeint ( char * str , long * val ) {
if ( * str == '0' ) {
if ( * ( str + 1 ) == 'x' || * ( str + 1 ) == 'X' ) return hextoint ( str + 2 , ( u_long * ) val ) ;
return octtoint ( str , ( u_long * ) val ) ;
}
return atoint ( str , val ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void qmp_pmemsave ( int64_t addr , int64_t size , const char * filename , Error * * errp ) {
FILE * f ;
uint32_t l ;
uint8_t buf [ 1024 ] ;
f = fopen ( filename , "wb" ) ;
if ( ! f ) {
error_setg_file_open ( errp , errno , filename ) ;
return ;
}
while ( size != 0 ) {
l = sizeof ( buf ) ;
if ( l > size ) l = size ;
cpu_physical_memory_rw ( addr , buf , l , 0 ) ;
if ( fwrite ( buf , 1 , l , f ) != l ) {
error_set ( errp , QERR_IO_ERROR ) ;
goto exit ;
}
addr += l ;
size -= l ;
}
exit : fclose ( f ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
SPL_METHOD ( SplFileInfo , func_name ) \ {
\ spl_filesystem_object * intern = ( spl_filesystem_object * ) zend_object_store_get_object ( getThis ( ) TSRMLS_CC ) ;
\ zend_error_handling error_handling ;
\ if ( zend_parse_parameters_none ( ) == FAILURE ) {
\ return ;
\ }
\ \ zend_replace_error_handling ( EH_THROW , spl_ce_RuntimeException , & error_handling TSRMLS_CC ) ;
\ spl_filesystem_object_get_file_name ( intern TSRMLS_CC ) ;
\ php_stat ( intern -> file_name , intern -> file_name_len , func_num , return_value TSRMLS_CC ) ;
\ zend_restore_error_handling ( & error_handling TSRMLS_CC ) ;
\ }
FileInfoFunction ( getPerms , FS_PERMS ) FileInfoFunction ( getInode , FS_INODE ) FileInfoFunction ( getSize , FS_SIZE ) FileInfoFunction ( getOwner , FS_OWNER ) FileInfoFunction ( getGroup , FS_GROUP ) FileInfoFunction ( getATime , FS_ATIME ) FileInfoFunction ( getMTime , FS_MTIME ) FileInfoFunction ( getCTime , FS_CTIME ) FileInfoFunction ( getType , FS_TYPE )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int diffie_hellman_sha256 ( LIBSSH2_SESSION * session , _libssh2_bn * g , _libssh2_bn * p , int group_order , unsigned char packet_type_init , unsigned char packet_type_reply , unsigned char * midhash , unsigned long midhash_len , kmdhgGPshakex_state_t * exchange_state ) {
int ret = 0 ;
int rc ;
libssh2_sha256_ctx exchange_hash_ctx ;
if ( exchange_state -> state == libssh2_NB_state_idle ) {
exchange_state -> e_packet = NULL ;
exchange_state -> s_packet = NULL ;
exchange_state -> k_value = NULL ;
exchange_state -> ctx = _libssh2_bn_ctx_new ( ) ;
exchange_state -> x = _libssh2_bn_init ( ) ;
exchange_state -> e = _libssh2_bn_init ( ) ;
exchange_state -> f = _libssh2_bn_init_from_bin ( ) ;
exchange_state -> k = _libssh2_bn_init ( ) ;
memset ( & exchange_state -> req_state , 0 , sizeof ( packet_require_state_t ) ) ;
_libssh2_bn_rand ( exchange_state -> x , group_order * 8 - 1 , 0 , - 1 ) ;
_libssh2_bn_mod_exp ( exchange_state -> e , g , exchange_state -> x , p , exchange_state -> ctx ) ;
exchange_state -> e_packet_len = _libssh2_bn_bytes ( exchange_state -> e ) + 6 ;
if ( _libssh2_bn_bits ( exchange_state -> e ) % 8 ) {
exchange_state -> e_packet_len -- ;
}
exchange_state -> e_packet = LIBSSH2_ALLOC ( session , exchange_state -> e_packet_len ) ;
if ( ! exchange_state -> e_packet ) {
ret = _libssh2_error ( session , LIBSSH2_ERROR_ALLOC , "Out of memory error" ) ;
goto clean_exit ;
}
exchange_state -> e_packet [ 0 ] = packet_type_init ;
_libssh2_htonu32 ( exchange_state -> e_packet + 1 , exchange_state -> e_packet_len - 5 ) ;
if ( _libssh2_bn_bits ( exchange_state -> e ) % 8 ) {
_libssh2_bn_to_bin ( exchange_state -> e , exchange_state -> e_packet + 5 ) ;
}
else {
exchange_state -> e_packet [ 5 ] = 0 ;
_libssh2_bn_to_bin ( exchange_state -> e , exchange_state -> e_packet + 6 ) ;
}
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Sending KEX packet %d" , ( int ) packet_type_init ) ;
exchange_state -> state = libssh2_NB_state_created ;
}
if ( exchange_state -> state == libssh2_NB_state_created ) {
rc = _libssh2_transport_send ( session , exchange_state -> e_packet , exchange_state -> e_packet_len , NULL , 0 ) ;
if ( rc == LIBSSH2_ERROR_EAGAIN ) {
return rc ;
}
else if ( rc ) {
ret = _libssh2_error ( session , rc , "Unable to send KEX init message" ) ;
goto clean_exit ;
}
exchange_state -> state = libssh2_NB_state_sent ;
}
if ( exchange_state -> state == libssh2_NB_state_sent ) {
if ( session -> burn_optimistic_kexinit ) {
int burn_type ;
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Waiting for badly guessed KEX packet (to be ignored)" ) ;
burn_type = _libssh2_packet_burn ( session , & exchange_state -> burn_state ) ;
if ( burn_type == LIBSSH2_ERROR_EAGAIN ) {
return burn_type ;
}
else if ( burn_type <= 0 ) {
ret = burn_type ;
goto clean_exit ;
}
session -> burn_optimistic_kexinit = 0 ;
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Burnt packet of type: %02x" , ( unsigned int ) burn_type ) ;
}
exchange_state -> state = libssh2_NB_state_sent1 ;
}
if ( exchange_state -> state == libssh2_NB_state_sent1 ) {
rc = _libssh2_packet_require ( session , packet_type_reply , & exchange_state -> s_packet , & exchange_state -> s_packet_len , 0 , NULL , 0 , & exchange_state -> req_state ) ;
if ( rc == LIBSSH2_ERROR_EAGAIN ) {
return rc ;
}
if ( rc ) {
ret = _libssh2_error ( session , LIBSSH2_ERROR_TIMEOUT , "Timed out waiting for KEX reply" ) ;
goto clean_exit ;
}
exchange_state -> s = exchange_state -> s_packet + 1 ;
session -> server_hostkey_len = _libssh2_ntohu32 ( exchange_state -> s ) ;
exchange_state -> s += 4 ;
if ( session -> server_hostkey ) LIBSSH2_FREE ( session , session -> server_hostkey ) ;
session -> server_hostkey = LIBSSH2_ALLOC ( session , session -> server_hostkey_len ) ;
if ( ! session -> server_hostkey ) {
ret = _libssh2_error ( session , LIBSSH2_ERROR_ALLOC , "Unable to allocate memory for a copy " "of the host key" ) ;
goto clean_exit ;
}
memcpy ( session -> server_hostkey , exchange_state -> s , session -> server_hostkey_len ) ;
exchange_state -> s += session -> server_hostkey_len ;
# if LIBSSH2_MD5 {
libssh2_md5_ctx fingerprint_ctx ;
if ( libssh2_md5_init ( & fingerprint_ctx ) ) {
libssh2_md5_update ( fingerprint_ctx , session -> server_hostkey , session -> server_hostkey_len ) ;
libssh2_md5_final ( fingerprint_ctx , session -> server_hostkey_md5 ) ;
session -> server_hostkey_md5_valid = TRUE ;
}
else {
session -> server_hostkey_md5_valid = FALSE ;
}
}
# ifdef LIBSSH2DEBUG {
char fingerprint [ 50 ] , * fprint = fingerprint ;
int i ;
for ( i = 0 ;
i < 16 ;
i ++ , fprint += 3 ) {
snprintf ( fprint , 4 , "%02x:" , session -> server_hostkey_md5 [ i ] ) ;
}
* ( -- fprint ) = '\0' ;
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Server's MD5 Fingerprint: %s" , fingerprint ) ;
}
# endif # endif {
libssh2_sha1_ctx fingerprint_ctx ;
if ( libssh2_sha1_init ( & fingerprint_ctx ) ) {
libssh2_sha1_update ( fingerprint_ctx , session -> server_hostkey , session -> server_hostkey_len ) ;
libssh2_sha1_final ( fingerprint_ctx , session -> server_hostkey_sha1 ) ;
session -> server_hostkey_sha1_valid = TRUE ;
}
else {
session -> server_hostkey_sha1_valid = FALSE ;
}
}
# ifdef LIBSSH2DEBUG {
char fingerprint [ 64 ] , * fprint = fingerprint ;
int i ;
for ( i = 0 ;
i < 20 ;
i ++ , fprint += 3 ) {
snprintf ( fprint , 4 , "%02x:" , session -> server_hostkey_sha1 [ i ] ) ;
}
* ( -- fprint ) = '\0' ;
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Server's SHA1 Fingerprint: %s" , fingerprint ) ;
}
# endif if ( session -> hostkey -> init ( session , session -> server_hostkey , session -> server_hostkey_len , & session -> server_hostkey_abstract ) ) {
ret = _libssh2_error ( session , LIBSSH2_ERROR_HOSTKEY_INIT , "Unable to initialize hostkey importer" ) ;
goto clean_exit ;
}
exchange_state -> f_value_len = _libssh2_ntohu32 ( exchange_state -> s ) ;
exchange_state -> s += 4 ;
exchange_state -> f_value = exchange_state -> s ;
exchange_state -> s += exchange_state -> f_value_len ;
_libssh2_bn_from_bin ( exchange_state -> f , exchange_state -> f_value_len , exchange_state -> f_value ) ;
exchange_state -> h_sig_len = _libssh2_ntohu32 ( exchange_state -> s ) ;
exchange_state -> s += 4 ;
exchange_state -> h_sig = exchange_state -> s ;
_libssh2_bn_mod_exp ( exchange_state -> k , exchange_state -> f , exchange_state -> x , p , exchange_state -> ctx ) ;
exchange_state -> k_value_len = _libssh2_bn_bytes ( exchange_state -> k ) + 5 ;
if ( _libssh2_bn_bits ( exchange_state -> k ) % 8 ) {
exchange_state -> k_value_len -- ;
}
exchange_state -> k_value = LIBSSH2_ALLOC ( session , exchange_state -> k_value_len ) ;
if ( ! exchange_state -> k_value ) {
ret = _libssh2_error ( session , LIBSSH2_ERROR_ALLOC , "Unable to allocate buffer for K" ) ;
goto clean_exit ;
}
_libssh2_htonu32 ( exchange_state -> k_value , exchange_state -> k_value_len - 4 ) ;
if ( _libssh2_bn_bits ( exchange_state -> k ) % 8 ) {
_libssh2_bn_to_bin ( exchange_state -> k , exchange_state -> k_value + 4 ) ;
}
else {
exchange_state -> k_value [ 4 ] = 0 ;
_libssh2_bn_to_bin ( exchange_state -> k , exchange_state -> k_value + 5 ) ;
}
exchange_state -> exchange_hash = ( void * ) & exchange_hash_ctx ;
libssh2_sha256_init ( & exchange_hash_ctx ) ;
if ( session -> local . banner ) {
_libssh2_htonu32 ( exchange_state -> h_sig_comp , strlen ( ( char * ) session -> local . banner ) - 2 ) ;
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> h_sig_comp , 4 ) ;
libssh2_sha256_update ( exchange_hash_ctx , ( char * ) session -> local . banner , strlen ( ( char * ) session -> local . banner ) - 2 ) ;
}
else {
_libssh2_htonu32 ( exchange_state -> h_sig_comp , sizeof ( LIBSSH2_SSH_DEFAULT_BANNER ) - 1 ) ;
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> h_sig_comp , 4 ) ;
libssh2_sha256_update ( exchange_hash_ctx , LIBSSH2_SSH_DEFAULT_BANNER , sizeof ( LIBSSH2_SSH_DEFAULT_BANNER ) - 1 ) ;
}
_libssh2_htonu32 ( exchange_state -> h_sig_comp , strlen ( ( char * ) session -> remote . banner ) ) ;
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> h_sig_comp , 4 ) ;
libssh2_sha256_update ( exchange_hash_ctx , session -> remote . banner , strlen ( ( char * ) session -> remote . banner ) ) ;
_libssh2_htonu32 ( exchange_state -> h_sig_comp , session -> local . kexinit_len ) ;
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> h_sig_comp , 4 ) ;
libssh2_sha256_update ( exchange_hash_ctx , session -> local . kexinit , session -> local . kexinit_len ) ;
_libssh2_htonu32 ( exchange_state -> h_sig_comp , session -> remote . kexinit_len ) ;
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> h_sig_comp , 4 ) ;
libssh2_sha256_update ( exchange_hash_ctx , session -> remote . kexinit , session -> remote . kexinit_len ) ;
_libssh2_htonu32 ( exchange_state -> h_sig_comp , session -> server_hostkey_len ) ;
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> h_sig_comp , 4 ) ;
libssh2_sha256_update ( exchange_hash_ctx , session -> server_hostkey , session -> server_hostkey_len ) ;
if ( packet_type_init == SSH_MSG_KEX_DH_GEX_INIT ) {
# ifdef LIBSSH2_DH_GEX_NEW _libssh2_htonu32 ( exchange_state -> h_sig_comp , LIBSSH2_DH_GEX_MINGROUP ) ;
_libssh2_htonu32 ( exchange_state -> h_sig_comp + 4 , LIBSSH2_DH_GEX_OPTGROUP ) ;
_libssh2_htonu32 ( exchange_state -> h_sig_comp + 8 , LIBSSH2_DH_GEX_MAXGROUP ) ;
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> h_sig_comp , 12 ) ;
# else _libssh2_htonu32 ( exchange_state -> h_sig_comp , LIBSSH2_DH_GEX_OPTGROUP ) ;
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> h_sig_comp , 4 ) ;
# endif }
if ( midhash ) {
libssh2_sha256_update ( exchange_hash_ctx , midhash , midhash_len ) ;
}
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> e_packet + 1 , exchange_state -> e_packet_len - 1 ) ;
_libssh2_htonu32 ( exchange_state -> h_sig_comp , exchange_state -> f_value_len ) ;
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> h_sig_comp , 4 ) ;
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> f_value , exchange_state -> f_value_len ) ;
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> k_value , exchange_state -> k_value_len ) ;
libssh2_sha256_final ( exchange_hash_ctx , exchange_state -> h_sig_comp ) ;
if ( session -> hostkey -> sig_verify ( session , exchange_state -> h_sig , exchange_state -> h_sig_len , exchange_state -> h_sig_comp , SHA256_DIGEST_LENGTH , & session -> server_hostkey_abstract ) ) {
ret = _libssh2_error ( session , LIBSSH2_ERROR_HOSTKEY_SIGN , "Unable to verify hostkey signature" ) ;
goto clean_exit ;
}
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Sending NEWKEYS message" ) ;
exchange_state -> c = SSH_MSG_NEWKEYS ;
exchange_state -> state = libssh2_NB_state_sent2 ;
}
if ( exchange_state -> state == libssh2_NB_state_sent2 ) {
rc = _libssh2_transport_send ( session , & exchange_state -> c , 1 , NULL , 0 ) ;
if ( rc == LIBSSH2_ERROR_EAGAIN ) {
return rc ;
}
else if ( rc ) {
ret = _libssh2_error ( session , rc , "Unable to send NEWKEYS message" ) ;
goto clean_exit ;
}
exchange_state -> state = libssh2_NB_state_sent3 ;
}
if ( exchange_state -> state == libssh2_NB_state_sent3 ) {
rc = _libssh2_packet_require ( session , SSH_MSG_NEWKEYS , & exchange_state -> tmp , & exchange_state -> tmp_len , 0 , NULL , 0 , & exchange_state -> req_state ) ;
if ( rc == LIBSSH2_ERROR_EAGAIN ) {
return rc ;
}
else if ( rc ) {
ret = _libssh2_error ( session , rc , "Timed out waiting for NEWKEYS" ) ;
goto clean_exit ;
}
session -> state |= LIBSSH2_STATE_NEWKEYS ;
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Received NEWKEYS message" ) ;
LIBSSH2_FREE ( session , exchange_state -> tmp ) ;
if ( ! session -> session_id ) {
session -> session_id = LIBSSH2_ALLOC ( session , SHA256_DIGEST_LENGTH ) ;
if ( ! session -> session_id ) {
ret = _libssh2_error ( session , LIBSSH2_ERROR_ALLOC , "Unable to allocate buffer for SHA digest" ) ;
goto clean_exit ;
}
memcpy ( session -> session_id , exchange_state -> h_sig_comp , SHA256_DIGEST_LENGTH ) ;
session -> session_id_len = SHA256_DIGEST_LENGTH ;
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "session_id calculated" ) ;
}
if ( session -> local . crypt -> dtor ) {
session -> local . crypt -> dtor ( session , & session -> local . crypt_abstract ) ;
}
if ( session -> local . crypt -> init ) {
unsigned char * iv = NULL , * secret = NULL ;
int free_iv = 0 , free_secret = 0 ;
LIBSSH2_KEX_METHOD_DIFFIE_HELLMAN_SHA256_HASH ( iv , session -> local . crypt -> iv_len , "A" ) ;
if ( ! iv ) {
ret = - 1 ;
goto clean_exit ;
}
LIBSSH2_KEX_METHOD_DIFFIE_HELLMAN_SHA256_HASH ( secret , session -> local . crypt -> secret_len , "C" ) ;
if ( ! secret ) {
LIBSSH2_FREE ( session , iv ) ;
ret = LIBSSH2_ERROR_KEX_FAILURE ;
goto clean_exit ;
}
if ( session -> local . crypt -> init ( session , session -> local . crypt , iv , & free_iv , secret , & free_secret , 1 , & session -> local . crypt_abstract ) ) {
LIBSSH2_FREE ( session , iv ) ;
LIBSSH2_FREE ( session , secret ) ;
ret = LIBSSH2_ERROR_KEX_FAILURE ;
goto clean_exit ;
}
if ( free_iv ) {
memset ( iv , 0 , session -> local . crypt -> iv_len ) ;
LIBSSH2_FREE ( session , iv ) ;
}
if ( free_secret ) {
memset ( secret , 0 , session -> local . crypt -> secret_len ) ;
LIBSSH2_FREE ( session , secret ) ;
}
}
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Client to Server IV and Key calculated" ) ;
if ( session -> remote . crypt -> dtor ) {
session -> remote . crypt -> dtor ( session , & session -> remote . crypt_abstract ) ;
}
if ( session -> remote . crypt -> init ) {
unsigned char * iv = NULL , * secret = NULL ;
int free_iv = 0 , free_secret = 0 ;
LIBSSH2_KEX_METHOD_DIFFIE_HELLMAN_SHA256_HASH ( iv , session -> remote . crypt -> iv_len , "B" ) ;
if ( ! iv ) {
ret = LIBSSH2_ERROR_KEX_FAILURE ;
goto clean_exit ;
}
LIBSSH2_KEX_METHOD_DIFFIE_HELLMAN_SHA256_HASH ( secret , session -> remote . crypt -> secret_len , "D" ) ;
if ( ! secret ) {
LIBSSH2_FREE ( session , iv ) ;
ret = LIBSSH2_ERROR_KEX_FAILURE ;
goto clean_exit ;
}
if ( session -> remote . crypt -> init ( session , session -> remote . crypt , iv , & free_iv , secret , & free_secret , 0 , & session -> remote . crypt_abstract ) ) {
LIBSSH2_FREE ( session , iv ) ;
LIBSSH2_FREE ( session , secret ) ;
ret = LIBSSH2_ERROR_KEX_FAILURE ;
goto clean_exit ;
}
if ( free_iv ) {
memset ( iv , 0 , session -> remote . crypt -> iv_len ) ;
LIBSSH2_FREE ( session , iv ) ;
}
if ( free_secret ) {
memset ( secret , 0 , session -> remote . crypt -> secret_len ) ;
LIBSSH2_FREE ( session , secret ) ;
}
}
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Server to Client IV and Key calculated" ) ;
if ( session -> local . mac -> dtor ) {
session -> local . mac -> dtor ( session , & session -> local . mac_abstract ) ;
}
if ( session -> local . mac -> init ) {
unsigned char * key = NULL ;
int free_key = 0 ;
LIBSSH2_KEX_METHOD_DIFFIE_HELLMAN_SHA256_HASH ( key , session -> local . mac -> key_len , "E" ) ;
if ( ! key ) {
ret = LIBSSH2_ERROR_KEX_FAILURE ;
goto clean_exit ;
}
session -> local . mac -> init ( session , key , & free_key , & session -> local . mac_abstract ) ;
if ( free_key ) {
memset ( key , 0 , session -> local . mac -> key_len ) ;
LIBSSH2_FREE ( session , key ) ;
}
}
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Client to Server HMAC Key calculated" ) ;
if ( session -> remote . mac -> dtor ) {
session -> remote . mac -> dtor ( session , & session -> remote . mac_abstract ) ;
}
if ( session -> remote . mac -> init ) {
unsigned char * key = NULL ;
int free_key = 0 ;
LIBSSH2_KEX_METHOD_DIFFIE_HELLMAN_SHA256_HASH ( key , session -> remote . mac -> key_len , "F" ) ;
if ( ! key ) {
ret = LIBSSH2_ERROR_KEX_FAILURE ;
goto clean_exit ;
}
session -> remote . mac -> init ( session , key , & free_key , & session -> remote . mac_abstract ) ;
if ( free_key ) {
memset ( key , 0 , session -> remote . mac -> key_len ) ;
LIBSSH2_FREE ( session , key ) ;
}
}
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Server to Client HMAC Key calculated" ) ;
if ( session -> local . comp && session -> local . comp -> dtor ) {
session -> local . comp -> dtor ( session , 1 , & session -> local . comp_abstract ) ;
}
if ( session -> local . comp && session -> local . comp -> init ) {
if ( session -> local . comp -> init ( session , 1 , & session -> local . comp_abstract ) ) {
ret = LIBSSH2_ERROR_KEX_FAILURE ;
goto clean_exit ;
}
}
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Client to Server compression initialized" ) ;
if ( session -> remote . comp && session -> remote . comp -> dtor ) {
session -> remote . comp -> dtor ( session , 0 , & session -> remote . comp_abstract ) ;
}
if ( session -> remote . comp && session -> remote . comp -> init ) {
if ( session -> remote . comp -> init ( session , 0 , & session -> remote . comp_abstract ) ) {
ret = LIBSSH2_ERROR_KEX_FAILURE ;
goto clean_exit ;
}
}
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Server to Client compression initialized" ) ;
}
clean_exit : _libssh2_bn_free ( exchange_state -> x ) ;
exchange_state -> x = NULL ;
_libssh2_bn_free ( exchange_state -> e ) ;
exchange_state -> e = NULL ;
_libssh2_bn_free ( exchange_state -> f ) ;
exchange_state -> f = NULL ;
_libssh2_bn_free ( exchange_state -> k ) ;
exchange_state -> k = NULL ;
_libssh2_bn_ctx_free ( exchange_state -> ctx ) ;
exchange_state -> ctx = NULL ;
if ( exchange_state -> e_packet ) {
LIBSSH2_FREE ( session , exchange_state -> e_packet ) ;
exchange_state -> e_packet = NULL ;
}
if ( exchange_state -> s_packet ) {
LIBSSH2_FREE ( session , exchange_state -> s_packet ) ;
exchange_state -> s_packet = NULL ;
}
if ( exchange_state -> k_value ) {
LIBSSH2_FREE ( session , exchange_state -> k_value ) ;
exchange_state -> k_value = NULL ;
}
exchange_state -> state = libssh2_NB_state_idle ;
return ret ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int SpoolssGetForm_r ( tvbuff_t * tvb , int offset , packet_info * pinfo , proto_tree * tree , dcerpc_info * di , guint8 * drep _U_ ) {
dcerpc_call_value * dcv = ( dcerpc_call_value * ) di -> call_data ;
BUFFER buffer ;
guint32 level = GPOINTER_TO_UINT ( dcv -> se_data ) ;
proto_item * hidden_item ;
hidden_item = proto_tree_add_uint ( tree , hf_form , tvb , offset , 0 , 1 ) ;
PROTO_ITEM_SET_HIDDEN ( hidden_item ) ;
offset = dissect_spoolss_buffer ( tvb , offset , pinfo , tree , di , drep , & buffer ) ;
offset = dissect_ndr_uint32 ( tvb , offset , pinfo , tree , di , drep , hf_needed , NULL ) ;
col_append_fstr ( pinfo -> cinfo , COL_INFO , ", level %d" , level ) ;
if ( buffer . tvb ) {
int buffer_offset = 0 ;
switch ( level ) {
case 1 : {
int struct_start = buffer_offset ;
dissect_FORM_REL ( buffer . tvb , buffer_offset , pinfo , tree , di , drep , struct_start ) ;
break ;
}
default : proto_tree_add_expert_format ( buffer . tree , pinfo , & ei_form_level , buffer . tvb , buffer_offset , - 1 , "Unknown form info level %d" , level ) ;
break ;
}
}
offset = dissect_doserror ( tvb , offset , pinfo , tree , di , drep , hf_rc , NULL ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void proto_reg_handoff_zbee_zcl_ota ( void ) {
dissector_handle_t ota_handle ;
ota_handle = find_dissector ( ZBEE_PROTOABBREV_ZCL_OTA ) ;
dissector_add_uint ( "zbee.zcl.cluster" , ZBEE_ZCL_CID_OTA_UPGRADE , ota_handle ) ;
zbee_zcl_init_cluster ( proto_zbee_zcl_ota , ett_zbee_zcl_ota , ZBEE_ZCL_CID_OTA_UPGRADE , hf_zbee_zcl_ota_attr_id , hf_zbee_zcl_ota_srv_rx_cmd_id , hf_zbee_zcl_ota_srv_tx_cmd_id , ( zbee_zcl_fn_attr_data ) dissect_zcl_ota_attr_data ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_TransparencyParameters ( 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_TransparencyParameters , TransparencyParameters_sequence ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void message_search_reset ( struct message_search_context * ctx ) {
ctx -> content_type_text = TRUE ;
ctx -> prev_part = NULL ;
str_find_reset ( ctx -> str_find_ctx ) ;
message_decoder_decode_reset ( ctx -> decoder ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static long uptomult ( long x , long y ) {
assert ( x >= 0 ) ;
return ( ( x + y - 1 ) / y ) * y ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void nautilus_file_operations_new_file_from_template ( GtkWidget * parent_view , GdkPoint * target_point , const char * parent_dir , const char * target_filename , const char * template_uri , NautilusCreateCallback done_callback , gpointer done_callback_data ) {
GTask * task ;
CreateJob * job ;
GtkWindow * parent_window ;
parent_window = NULL ;
if ( parent_view ) {
parent_window = ( GtkWindow * ) gtk_widget_get_ancestor ( parent_view , GTK_TYPE_WINDOW ) ;
}
job = op_job_new ( CreateJob , parent_window ) ;
job -> done_callback = done_callback ;
job -> done_callback_data = done_callback_data ;
job -> dest_dir = g_file_new_for_uri ( parent_dir ) ;
if ( target_point != NULL ) {
job -> position = * target_point ;
job -> has_position = TRUE ;
}
job -> filename = g_strdup ( target_filename ) ;
if ( template_uri ) {
job -> src = g_file_new_for_uri ( template_uri ) ;
}
if ( ! nautilus_file_undo_manager_is_operating ( ) ) {
job -> common . undo_info = nautilus_file_undo_info_create_new ( NAUTILUS_FILE_UNDO_OP_CREATE_FILE_FROM_TEMPLATE ) ;
}
task = g_task_new ( NULL , job -> common . cancellable , create_task_done , job ) ;
g_task_set_task_data ( task , job , NULL ) ;
g_task_run_in_thread ( task , create_task_thread_func ) ;
g_object_unref ( task ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static VALUE ossl_x509name_to_s ( int argc , VALUE * argv , VALUE self ) {
X509_NAME * name ;
VALUE flag , str ;
BIO * out ;
unsigned long iflag ;
rb_scan_args ( argc , argv , "01" , & flag ) ;
if ( NIL_P ( flag ) ) return ossl_x509name_to_s_old ( self ) ;
else iflag = NUM2ULONG ( flag ) ;
if ( ! ( out = BIO_new ( BIO_s_mem ( ) ) ) ) ossl_raise ( eX509NameError , NULL ) ;
GetX509Name ( self , name ) ;
if ( ! X509_NAME_print_ex ( out , name , 0 , iflag ) ) {
BIO_free ( out ) ;
ossl_raise ( eX509NameError , NULL ) ;
}
str = ossl_membio2str ( out ) ;
return str ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int tunnel_tun ( int tun_fd , int dns_fd ) {
unsigned long outlen ;
struct ip * header ;
char out [ 64 * 1024 ] ;
char in [ 64 * 1024 ] ;
int userid ;
int read ;
if ( ( read = read_tun ( tun_fd , in , sizeof ( in ) ) ) <= 0 ) return 0 ;
header = ( struct ip * ) ( in + 4 ) ;
userid = find_user_by_ip ( header -> ip_dst . s_addr ) ;
if ( userid < 0 ) return 0 ;
outlen = sizeof ( out ) ;
compress2 ( ( uint8_t * ) out , & outlen , ( uint8_t * ) in , read , 9 ) ;
if ( users [ userid ] . conn == CONN_DNS_NULL ) {
# ifdef OUTPACKETQ_LEN if ( users [ userid ] . outpacket . len > 0 ) {
save_to_outpacketq ( userid , out , outlen ) ;
return 0 ;
}
# endif start_new_outpacket ( userid , out , outlen ) ;
if ( users [ userid ] . q_sendrealsoon . id != 0 ) send_chunk_or_dataless ( dns_fd , userid , & users [ userid ] . q_sendrealsoon ) ;
else if ( users [ userid ] . q . id != 0 ) send_chunk_or_dataless ( dns_fd , userid , & users [ userid ] . q ) ;
return outlen ;
}
else {
send_raw ( dns_fd , out , outlen , userid , RAW_HDR_CMD_DATA , & users [ userid ] . q ) ;
return outlen ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
extern int name ( int , locale_t ) __THROW __exctype_l ( isalnum_l ) ;
__exctype_l ( isalpha_l ) ;
__exctype_l ( iscntrl_l ) ;
__exctype_l ( isdigit_l ) ;
__exctype_l ( islower_l ) ;
__exctype_l ( isgraph_l ) ;
__exctype_l ( isprint_l ) ;
__exctype_l ( ispunct_l ) ;
__exctype_l ( isspace_l ) ;
__exctype_l ( isupper_l )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
const char * TSHttpHdrReasonLookup ( TSHttpStatus status ) {
return http_hdr_reason_lookup ( ( HTTPStatus ) status ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline void ac6_proc_exit ( struct net * net ) {
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int MDC2_Init ( MDC2_CTX * c ) {
c -> num = 0 ;
c -> pad_type = 1 ;
memset ( & ( c -> h [ 0 ] ) , 0x52 , MDC2_BLOCK ) ;
memset ( & ( c -> hh [ 0 ] ) , 0x25 , MDC2_BLOCK ) ;
return 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void web_server_destroy ( void ) {
if ( bWebServerState == WEB_SERVER_ENABLED ) {
membuffer_destroy ( & gDocumentRootDir ) ;
alias_release ( & gAliasDoc ) ;
ithread_mutex_lock ( & gWebMutex ) ;
memset ( & gAliasDoc , 0 , sizeof ( struct xml_alias_t ) ) ;
ithread_mutex_unlock ( & gWebMutex ) ;
ithread_mutex_destroy ( & gWebMutex ) ;
bWebServerState = WEB_SERVER_DISABLED ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void get_icu_disp_value_src_php ( char * tag_name , INTERNAL_FUNCTION_PARAMETERS ) {
const char * loc_name = NULL ;
int loc_name_len = 0 ;
const char * disp_loc_name = NULL ;
int disp_loc_name_len = 0 ;
int free_loc_name = 0 ;
UChar * disp_name = NULL ;
int32_t disp_name_len = 0 ;
char * mod_loc_name = NULL ;
int32_t buflen = 512 ;
UErrorCode status = U_ZERO_ERROR ;
char * utf8value = NULL ;
int utf8value_len = 0 ;
char * msg = NULL ;
int grOffset = 0 ;
intl_error_reset ( NULL TSRMLS_CC ) ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , "s|s" , & loc_name , & loc_name_len , & disp_loc_name , & disp_loc_name_len ) == FAILURE ) {
spprintf ( & msg , 0 , "locale_get_display_%s : unable to parse input params" , tag_name ) ;
intl_error_set ( NULL , U_ILLEGAL_ARGUMENT_ERROR , msg , 1 TSRMLS_CC ) ;
efree ( msg ) ;
RETURN_FALSE ;
}
if ( loc_name_len > ULOC_FULLNAME_CAPACITY ) {
spprintf ( & msg , 0 , "locale_get_display_%s : name too long" , tag_name ) ;
intl_error_set ( NULL , U_ILLEGAL_ARGUMENT_ERROR , msg , 1 TSRMLS_CC ) ;
efree ( msg ) ;
RETURN_FALSE ;
}
if ( loc_name_len == 0 ) {
loc_name = intl_locale_get_default ( TSRMLS_C ) ;
}
if ( strcmp ( tag_name , DISP_NAME ) != 0 ) {
grOffset = findOffset ( LOC_GRANDFATHERED , loc_name ) ;
if ( grOffset >= 0 ) {
if ( strcmp ( tag_name , LOC_LANG_TAG ) == 0 ) {
mod_loc_name = getPreferredTag ( loc_name ) ;
}
else {
RETURN_FALSE ;
}
}
}
if ( mod_loc_name == NULL ) {
mod_loc_name = estrdup ( loc_name ) ;
}
if ( ! disp_loc_name ) {
disp_loc_name = estrdup ( intl_locale_get_default ( TSRMLS_C ) ) ;
free_loc_name = 1 ;
}
do {
disp_name = erealloc ( disp_name , buflen * sizeof ( UChar ) ) ;
disp_name_len = buflen ;
if ( strcmp ( tag_name , LOC_LANG_TAG ) == 0 ) {
buflen = uloc_getDisplayLanguage ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , & status ) ;
}
else if ( strcmp ( tag_name , LOC_SCRIPT_TAG ) == 0 ) {
buflen = uloc_getDisplayScript ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , & status ) ;
}
else if ( strcmp ( tag_name , LOC_REGION_TAG ) == 0 ) {
buflen = uloc_getDisplayCountry ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , & status ) ;
}
else if ( strcmp ( tag_name , LOC_VARIANT_TAG ) == 0 ) {
buflen = uloc_getDisplayVariant ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , & status ) ;
}
else if ( strcmp ( tag_name , DISP_NAME ) == 0 ) {
buflen = uloc_getDisplayName ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , & status ) ;
}
if ( U_FAILURE ( status ) ) {
if ( status == U_BUFFER_OVERFLOW_ERROR ) {
status = U_ZERO_ERROR ;
continue ;
}
spprintf ( & msg , 0 , "locale_get_display_%s : unable to get locale %s" , tag_name , tag_name ) ;
intl_error_set ( NULL , status , msg , 1 TSRMLS_CC ) ;
efree ( msg ) ;
if ( disp_name ) {
efree ( disp_name ) ;
}
if ( mod_loc_name ) {
efree ( mod_loc_name ) ;
}
if ( free_loc_name ) {
efree ( ( void * ) disp_loc_name ) ;
disp_loc_name = NULL ;
}
RETURN_FALSE ;
}
}
while ( buflen > disp_name_len ) ;
if ( mod_loc_name ) {
efree ( mod_loc_name ) ;
}
if ( free_loc_name ) {
efree ( ( void * ) disp_loc_name ) ;
disp_loc_name = NULL ;
}
intl_convert_utf16_to_utf8 ( & utf8value , & utf8value_len , disp_name , buflen , & status ) ;
efree ( disp_name ) ;
if ( U_FAILURE ( status ) ) {
spprintf ( & msg , 0 , "locale_get_display_%s :error converting display name for %s to UTF-8" , tag_name , tag_name ) ;
intl_error_set ( NULL , status , msg , 1 TSRMLS_CC ) ;
efree ( msg ) ;
RETURN_FALSE ;
}
RETVAL_STRINGL ( utf8value , utf8value_len , FALSE ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void process_blob ( struct rev_info * revs , struct blob * blob , show_object_fn show , struct strbuf * path , const char * name , void * cb_data ) {
struct object * obj = & blob -> object ;
size_t pathlen ;
if ( ! revs -> blob_objects ) return ;
if ( ! obj ) die ( "bad blob object" ) ;
if ( obj -> flags & ( UNINTERESTING | SEEN ) ) return ;
obj -> flags |= SEEN ;
pathlen = path -> len ;
strbuf_addstr ( path , name ) ;
show ( obj , path -> buf , cb_data ) ;
strbuf_setlen ( path , pathlen ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void virtio_net_tx_bh ( void * opaque ) {
VirtIONet * n = opaque ;
int32_t ret ;
assert ( n -> vdev . vm_running ) ;
n -> tx_waiting = 0 ;
if ( unlikely ( ! ( n -> vdev . status & VIRTIO_CONFIG_S_DRIVER_OK ) ) ) return ;
ret = virtio_net_flush_tx ( n , n -> tx_vq ) ;
if ( ret == - EBUSY ) {
return ;
}
if ( ret >= n -> tx_burst ) {
qemu_bh_schedule ( n -> tx_bh ) ;
n -> tx_waiting = 1 ;
return ;
}
virtio_queue_set_notification ( n -> tx_vq , 1 ) ;
if ( virtio_net_flush_tx ( n , n -> tx_vq ) > 0 ) {
virtio_queue_set_notification ( n -> tx_vq , 0 ) ;
qemu_bh_schedule ( n -> tx_bh ) ;
n -> tx_waiting = 1 ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void cmyk2rgb ( fz_context * ctx , fz_color_converter * cc , float * dv , const float * sv ) {
# ifdef SLOWCMYK cmyk_to_rgb ( ctx , NULL , sv , dv ) ;
# else dv [ 0 ] = 1 - fz_min ( sv [ 0 ] + sv [ 3 ] , 1 ) ;
dv [ 1 ] = 1 - fz_min ( sv [ 1 ] + sv [ 3 ] , 1 ) ;
dv [ 2 ] = 1 - fz_min ( sv [ 2 ] + sv [ 3 ] , 1 ) ;
# endif }
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void do_rematrixing ( AC3DecodeContext * s ) {
int bnd , i ;
int end , bndend ;
end = FFMIN ( s -> end_freq [ 1 ] , s -> end_freq [ 2 ] ) ;
for ( bnd = 0 ;
bnd < s -> num_rematrixing_bands ;
bnd ++ ) {
if ( s -> rematrixing_flags [ bnd ] ) {
bndend = FFMIN ( end , ff_ac3_rematrix_band_tab [ bnd + 1 ] ) ;
for ( i = ff_ac3_rematrix_band_tab [ bnd ] ;
i < bndend ;
i ++ ) {
int tmp0 = s -> fixed_coeffs [ 1 ] [ i ] ;
s -> fixed_coeffs [ 1 ] [ i ] += s -> fixed_coeffs [ 2 ] [ i ] ;
s -> fixed_coeffs [ 2 ] [ i ] = tmp0 - s -> fixed_coeffs [ 2 ] [ i ] ;
}
}
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static afs_int32 iNewEntry ( struct rx_call * call , char aname [ ] , afs_int32 aid , afs_int32 oid , afs_int32 * cid ) {
struct ubik_trans * tt ;
afs_int32 code ;
afs_int32 gflag = 0 ;
int admin ;
stolower ( aname ) ;
code = Initdb ( ) ;
if ( code != PRSUCCESS ) return code ;
code = ubik_BeginTrans ( dbase , UBIK_WRITETRANS , & tt ) ;
if ( code ) return code ;
code = ubik_SetLock ( tt , 1 , 1 , LOCKWRITE ) ;
if ( code ) ABORT_WITH ( tt , code ) ;
code = read_DbHeader ( tt ) ;
if ( code ) ABORT_WITH ( tt , code ) ;
code = WhoIsThis ( call , tt , cid ) ;
if ( code ) ABORT_WITH ( tt , PRPERM ) ;
admin = IsAMemberOf ( tt , * cid , SYSADMINID ) ;
if ( aid == 0 ) ABORT_WITH ( tt , PRPERM ) ;
if ( aid < 0 ) {
gflag |= PRGRP ;
if ( ! admin && ! pr_noAuth && ( aid != ntohl ( cheader . maxGroup ) - 1 ) ) ABORT_WITH ( tt , PRPERM ) ;
}
if ( FindByID ( tt , aid ) ) ABORT_WITH ( tt , PRIDEXIST ) ;
if ( ! CreateOK ( tt , * cid , oid , gflag , admin ) ) ABORT_WITH ( tt , PRPERM ) ;
code = CreateEntry ( tt , aname , & aid , 1 , gflag , oid , * cid ) ;
if ( code != PRSUCCESS ) ABORT_WITH ( tt , code ) ;
code = ubik_EndTrans ( tt ) ;
if ( code ) return code ;
return PRSUCCESS ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void get_command_type ( struct st_command * command ) {
char save ;
uint type ;
DBUG_ENTER ( "get_command_type" ) ;
if ( * command -> query == '}
' ) {
command -> type = Q_END_BLOCK ;
DBUG_VOID_RETURN ;
}
save = command -> query [ command -> first_word_len ] ;
command -> query [ command -> first_word_len ] = 0 ;
type = find_type ( command -> query , & command_typelib , FIND_TYPE_NO_PREFIX ) ;
command -> query [ command -> first_word_len ] = save ;
if ( type > 0 ) {
command -> type = ( enum enum_commands ) type ;
if ( type == Q_QUERY ) {
command -> query = command -> first_argument ;
}
}
else {
if ( command -> type != Q_COMMENT_WITH_COMMAND ) {
command -> type = Q_QUERY ;
}
else {
report_or_die ( "Found line beginning with -- that didn't contain " "a valid mysqltest command, check your syntax or " "use # if you intended to write a comment" ) ;
command -> type = Q_COMMENT ;
}
}
memcpy ( & command -> expected_errors , & saved_expected_errors , sizeof ( saved_expected_errors ) ) ;
DBUG_PRINT ( "info" , ( "There are %d expected errors" , command -> expected_errors . count ) ) ;
DBUG_VOID_RETURN ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void steamdiscover_dissect_body_streamingrequest ( tvbuff_t * tvb , packet_info * pinfo , proto_tree * tree , gint offset , gint bytes_left ) {
gint len ;
gint64 value ;
protobuf_desc_t pb = {
tvb , offset , bytes_left }
;
protobuf_tag_t tag = {
0 , 0 , 0 }
;
while ( protobuf_iter_next ( & pb , & tag ) ) {
switch ( tag . field_number ) {
case STEAMDISCOVER_FN_STREAMINGREQUEST_REQUESTID : STEAMDISCOVER_ENSURE_WIRETYPE ( PROTOBUF_WIRETYPE_VARINT ) ;
value = get_varint64 ( pb . tvb , pb . offset , pb . bytes_left , & len ) ;
proto_tree_add_uint ( tree , hf_steam_ihs_discovery_body_streamingrequest_requestid , pb . tvb , pb . offset , len , ( guint32 ) value ) ;
col_add_fstr ( pinfo -> cinfo , COL_INFO , "%s ID=%08x" , hf_steam_ihs_discovery_header_msgtype_strings [ STEAMDISCOVER_MSGTYPE_DEVICESTREAMINGREQUEST ] . strptr , ( guint32 ) value ) ;
break ;
case STEAMDISCOVER_FN_STREAMINGREQUEST_MAXIMUMRESOLUTIONX : STEAMDISCOVER_ENSURE_WIRETYPE ( PROTOBUF_WIRETYPE_VARINT ) ;
value = get_varint64 ( pb . tvb , pb . offset , pb . bytes_left , & len ) ;
proto_tree_add_int ( tree , hf_steam_ihs_discovery_body_streamingrequest_maximumresolutionx , pb . tvb , pb . offset , len , ( gint32 ) value ) ;
break ;
case STEAMDISCOVER_FN_STREAMINGREQUEST_MAXIMUMRESOLUTIONY : STEAMDISCOVER_ENSURE_WIRETYPE ( PROTOBUF_WIRETYPE_VARINT ) ;
value = get_varint64 ( pb . tvb , pb . offset , pb . bytes_left , & len ) ;
proto_tree_add_int ( tree , hf_steam_ihs_discovery_body_streamingrequest_maximumresolutiony , pb . tvb , pb . offset , len , ( gint32 ) value ) ;
break ;
case STEAMDISCOVER_FN_STREAMINGREQUEST_AUDIOCHANNELCOUNT : STEAMDISCOVER_ENSURE_WIRETYPE ( PROTOBUF_WIRETYPE_VARINT ) ;
value = get_varint64 ( pb . tvb , pb . offset , pb . bytes_left , & len ) ;
proto_tree_add_int ( tree , hf_steam_ihs_discovery_body_streamingrequest_audiochannelcount , pb . tvb , pb . offset , len , ( gint32 ) value ) ;
break ;
case STEAMDISCOVER_FN_STREAMINGREQUEST_DEVICEVERSION : STEAMDISCOVER_ENSURE_WIRETYPE ( PROTOBUF_WIRETYPE_LENGTHDELIMITED ) ;
value = get_varint64 ( pb . tvb , pb . offset , pb . bytes_left , & len ) ;
proto_tree_add_item ( tree , hf_steam_ihs_discovery_body_streamingrequest_deviceversion , pb . tvb , pb . offset + len , ( gint ) value , ENC_UTF_8 | ENC_NA ) ;
len += ( gint ) value ;
break ;
case STEAMDISCOVER_FN_STREAMINGREQUEST_STREAMDESKTOP : STEAMDISCOVER_ENSURE_WIRETYPE ( PROTOBUF_WIRETYPE_VARINT ) ;
value = get_varint64 ( pb . tvb , pb . offset , pb . bytes_left , & len ) ;
proto_tree_add_boolean ( tree , hf_steam_ihs_discovery_body_streamingrequest_streamdesktop , pb . tvb , pb . offset , len , ( gint32 ) value ) ;
break ;
case STEAMDISCOVER_FN_STREAMINGREQUEST_DEVICETOKEN : STEAMDISCOVER_ENSURE_WIRETYPE ( PROTOBUF_WIRETYPE_LENGTHDELIMITED ) ;
value = get_varint64 ( pb . tvb , pb . offset , pb . bytes_left , & len ) ;
proto_tree_add_item ( tree , hf_steam_ihs_discovery_body_streamingrequest_devicetoken , pb . tvb , pb . offset + len , ( gint ) value , ENC_NA ) ;
len += ( gint ) value ;
break ;
case STEAMDISCOVER_FN_STREAMINGREQUEST_PIN : STEAMDISCOVER_ENSURE_WIRETYPE ( PROTOBUF_WIRETYPE_LENGTHDELIMITED ) ;
value = get_varint64 ( pb . tvb , pb . offset , pb . bytes_left , & len ) ;
proto_tree_add_item ( tree , hf_steam_ihs_discovery_body_streamingrequest_pin , pb . tvb , pb . offset + len , ( gint ) value , ENC_NA ) ;
len += ( gint ) value ;
break ;
case STEAMDISCOVER_FN_STREAMINGREQUEST_ENABLEVIDEOSTREAMING : STEAMDISCOVER_ENSURE_WIRETYPE ( PROTOBUF_WIRETYPE_VARINT ) ;
value = get_varint64 ( pb . tvb , pb . offset , pb . bytes_left , & len ) ;
proto_tree_add_boolean ( tree , hf_steam_ihs_discovery_body_streamingrequest_enablevideostreaming , pb . tvb , pb . offset , len , ( gint32 ) value ) ;
break ;
case STEAMDISCOVER_FN_STREAMINGREQUEST_ENABLEAUDIOSTREAMING : STEAMDISCOVER_ENSURE_WIRETYPE ( PROTOBUF_WIRETYPE_VARINT ) ;
value = get_varint64 ( pb . tvb , pb . offset , pb . bytes_left , & len ) ;
proto_tree_add_boolean ( tree , hf_steam_ihs_discovery_body_streamingrequest_enableaudiostreaming , pb . tvb , pb . offset , len , ( gint32 ) value ) ;
break ;
case STEAMDISCOVER_FN_STREAMINGREQUEST_ENABLEINPUTSTREAMING : STEAMDISCOVER_ENSURE_WIRETYPE ( PROTOBUF_WIRETYPE_VARINT ) ;
value = get_varint64 ( pb . tvb , pb . offset , pb . bytes_left , & len ) ;
proto_tree_add_boolean ( tree , hf_steam_ihs_discovery_body_streamingrequest_enableinputstreaming , pb . tvb , pb . offset , len , ( gint32 ) value ) ;
break ;
default : len = protobuf_dissect_unknown_field ( & pb , & tag , pinfo , tree , NULL ) ;
break ;
}
protobuf_seek_forward ( & pb , len ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int qemuAgentFSFreeze ( qemuAgentPtr mon , const char * * mountpoints , unsigned int nmountpoints ) {
int ret = - 1 ;
virJSONValuePtr cmd , arg = NULL ;
virJSONValuePtr reply = NULL ;
if ( mountpoints && nmountpoints ) {
arg = qemuAgentMakeStringsArray ( mountpoints , nmountpoints ) ;
if ( ! arg ) return - 1 ;
cmd = qemuAgentMakeCommand ( "guest-fsfreeze-freeze-list" , "a:mountpoints" , arg , NULL ) ;
}
else {
cmd = qemuAgentMakeCommand ( "guest-fsfreeze-freeze" , NULL ) ;
}
if ( ! cmd ) goto cleanup ;
arg = NULL ;
if ( qemuAgentCommand ( mon , cmd , & reply , true , VIR_DOMAIN_QEMU_AGENT_COMMAND_BLOCK ) < 0 ) goto cleanup ;
if ( virJSONValueObjectGetNumberInt ( reply , "return" , & ret ) < 0 ) {
virReportError ( VIR_ERR_INTERNAL_ERROR , "%s" , _ ( "malformed return value" ) ) ;
}
cleanup : virJSONValueFree ( arg ) ;
virJSONValueFree ( cmd ) ;
virJSONValueFree ( reply ) ;
return ret ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void HtmlPut ( char * * ppsz_html , const char * psz_text ) {
HtmlNPut ( ppsz_html , psz_text , INT_MAX ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int selinux_inode_rename ( struct inode * old_inode , struct dentry * old_dentry , struct inode * new_inode , struct dentry * new_dentry ) {
return may_rename ( old_inode , old_dentry , new_inode , new_dentry ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int checkcmap ( int n , uint16 * r , uint16 * g , uint16 * b ) {
while ( n -- > 0 ) if ( * r ++ >= 256 || * g ++ >= 256 || * b ++ >= 256 ) return ( 16 ) ;
fprintf ( stderr , "Warning, assuming 8-bit colormap.\n" ) ;
return ( 8 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int ssl_cert_type ( X509 * x , EVP_PKEY * pkey ) {
EVP_PKEY * pk ;
int ret = - 1 , i ;
if ( pkey == NULL ) pk = X509_get_pubkey ( x ) ;
else pk = pkey ;
if ( pk == NULL ) goto err ;
i = pk -> type ;
if ( i == EVP_PKEY_RSA ) {
ret = SSL_PKEY_RSA_ENC ;
}
else if ( i == EVP_PKEY_DSA ) {
ret = SSL_PKEY_DSA_SIGN ;
}
# ifndef OPENSSL_NO_EC else if ( i == EVP_PKEY_EC ) {
ret = SSL_PKEY_ECC ;
}
# endif else if ( i == NID_id_GostR3410_94 || i == NID_id_GostR3410_94_cc ) {
ret = SSL_PKEY_GOST94 ;
}
else if ( i == NID_id_GostR3410_2001 || i == NID_id_GostR3410_2001_cc ) {
ret = SSL_PKEY_GOST01 ;
}
err : if ( ! pkey ) EVP_PKEY_free ( pk ) ;
return ( ret ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline PixelTrait GetPixelYellowTraits ( const Image * restrict image ) {
return ( image -> channel_map [ YellowPixelChannel ] . traits ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int gdev_pdf_put_params_impl ( gx_device * dev , const gx_device_pdf * save_dev , gs_param_list * plist ) {
int ecode , code ;
gx_device_pdf * pdev = ( gx_device_pdf * ) dev ;
float cl = ( float ) pdev -> CompatibilityLevel ;
bool locked = pdev -> params . LockDistillerParams , ForOPDFRead ;
gs_param_name param_name ;
pdev -> pdf_memory = gs_memory_stable ( pdev -> memory ) ;
{
gs_param_string_array ppa ;
gs_param_string pps ;
code = param_read_string_array ( plist , ( param_name = "pdfmark" ) , & ppa ) ;
switch ( code ) {
case 0 : code = pdfwrite_pdf_open_document ( pdev ) ;
if ( code < 0 ) return code ;
code = pdfmark_process ( pdev , & ppa ) ;
if ( code >= 0 ) return code ;
default : param_signal_error ( plist , param_name , code ) ;
return code ;
case 1 : break ;
}
code = param_read_string_array ( plist , ( param_name = "DSC" ) , & ppa ) ;
switch ( code ) {
case 0 : code = pdfwrite_pdf_open_document ( pdev ) ;
if ( code < 0 ) return code ;
code = pdf_dsc_process ( pdev , & ppa ) ;
if ( code >= 0 ) return code ;
default : param_signal_error ( plist , param_name , code ) ;
return code ;
case 1 : break ;
}
code = param_read_string ( plist , ( param_name = "pdfpagelabels" ) , & pps ) ;
switch ( code ) {
case 0 : {
if ( ! pdev -> ForOPDFRead ) {
cos_dict_t * const pcd = pdev -> Catalog ;
code = pdfwrite_pdf_open_document ( pdev ) ;
if ( code < 0 ) return code ;
code = cos_dict_put_string ( pcd , ( const byte * ) "/PageLabels" , 11 , pps . data , pps . size ) ;
if ( code >= 0 ) return code ;
}
else return 0 ;
}
default : param_signal_error ( plist , param_name , code ) ;
return code ;
case 1 : break ;
}
}
ecode = param_read_bool ( plist , "LockDistillerParams" , & locked ) ;
if ( ecode < 0 ) param_signal_error ( plist , param_name , ecode ) ;
{
int efo = 1 ;
ecode = param_put_int ( plist , ( param_name = ".EmbedFontObjects" ) , & efo , ecode ) ;
if ( ecode < 0 ) param_signal_error ( plist , param_name , ecode ) ;
if ( efo != 1 ) param_signal_error ( plist , param_name , ecode = gs_error_rangecheck ) ;
}
{
int cdv = CoreDistVersion ;
ecode = param_put_int ( plist , ( param_name = "CoreDistVersion" ) , & cdv , ecode ) ;
if ( ecode < 0 ) return gs_note_error ( ecode ) ;
if ( cdv != CoreDistVersion ) param_signal_error ( plist , param_name , ecode = gs_error_rangecheck ) ;
}
switch ( code = param_read_float ( plist , ( param_name = "CompatibilityLevel" ) , & cl ) ) {
default : ecode = code ;
param_signal_error ( plist , param_name , ecode ) ;
break ;
case 0 : if ( ! ( locked && pdev -> params . LockDistillerParams ) ) {
if ( cl < ( float ) 1.15 ) cl = ( float ) 1.1 ;
else if ( cl < ( float ) 1.25 ) cl = ( float ) 1.2 ;
else if ( cl < ( float ) 1.35 ) cl = ( float ) 1.3 ;
else if ( cl < ( float ) 1.45 ) cl = ( float ) 1.4 ;
else if ( cl < ( float ) 1.55 ) cl = ( float ) 1.5 ;
else if ( cl < ( float ) 1.65 ) cl = ( float ) 1.6 ;
else if ( cl < ( float ) 1.75 ) cl = ( float ) 1.7 ;
else {
cl = ( float ) 2.0 ;
if ( pdev -> params . TransferFunctionInfo == tfi_Preserve ) pdev -> params . TransferFunctionInfo = tfi_Apply ;
}
}
case 1 : break ;
}
{
gs_memory_t * mem = plist -> memory ;
plist -> memory = pdev -> pdf_memory ;
code = gs_param_read_items ( plist , pdev , pdf_param_items ) ;
if ( code < 0 || ( code = param_read_bool ( plist , "ForOPDFRead" , & ForOPDFRead ) ) < 0 ) {
}
if ( code == 0 && ! pdev -> is_ps2write && ! ( locked && pdev -> params . LockDistillerParams ) ) pdev -> ForOPDFRead = ForOPDFRead ;
plist -> memory = mem ;
}
if ( code < 0 ) ecode = code ;
{
long fon = pdev -> FirstObjectNumber ;
if ( fon != save_dev -> FirstObjectNumber ) {
if ( fon <= 0 || fon > 0x7fff0000 || ( pdev -> next_id != 0 && pdev -> next_id != save_dev -> FirstObjectNumber + pdf_num_initial_ids ) ) {
ecode = gs_error_rangecheck ;
param_signal_error ( plist , "FirstObjectNumber" , ecode ) ;
}
}
}
{
static const char * const pcm_names [ ] = {
"DeviceGray" , "DeviceRGB" , "DeviceCMYK" , "DeviceN" , 0 }
;
int pcm = - 1 ;
ecode = param_put_enum ( plist , "ProcessColorModel" , & pcm , pcm_names , ecode ) ;
if ( pcm >= 0 ) {
pdf_set_process_color_model ( pdev , pcm ) ;
rc_decrement ( pdev -> icc_struct , "gdev_pdf_put_params_impl, ProcessColorModel changed" ) ;
pdev -> icc_struct = 0 ;
}
}
if ( ecode < 0 ) goto fail ;
if ( pdev -> is_ps2write && ( code = param_read_bool ( plist , "ProduceDSC" , & pdev -> ProduceDSC ) ) < 0 ) {
param_signal_error ( plist , param_name , code ) ;
}
if ( pdev -> PDFA < 0 || pdev -> PDFA > 3 ) {
ecode = gs_note_error ( gs_error_rangecheck ) ;
param_signal_error ( plist , "PDFA" , ecode ) ;
goto fail ;
}
if ( pdev -> PDFA != 0 && pdev -> AbortPDFAX ) pdev -> PDFA = 0 ;
if ( pdev -> PDFX && pdev -> AbortPDFAX ) pdev -> PDFX = 0 ;
if ( pdev -> PDFX && pdev -> PDFA != 0 ) {
ecode = gs_note_error ( gs_error_rangecheck ) ;
param_signal_error ( plist , "PDFA" , ecode ) ;
goto fail ;
}
if ( pdev -> PDFX && pdev -> ForOPDFRead ) {
ecode = gs_note_error ( gs_error_rangecheck ) ;
param_signal_error ( plist , "PDFX" , ecode ) ;
goto fail ;
}
if ( pdev -> PDFA != 0 && pdev -> ForOPDFRead ) {
ecode = gs_note_error ( gs_error_rangecheck ) ;
param_signal_error ( plist , "PDFA" , ecode ) ;
goto fail ;
}
if ( pdev -> PDFA == 1 || pdev -> PDFX || pdev -> CompatibilityLevel < 1.4 ) {
pdev -> HaveTransparency = false ;
pdev -> PreserveSMask = false ;
}
if ( pdev -> PDFX ) cl = ( float ) 1.3 ;
if ( pdev -> PDFA != 0 && cl < 1.4 ) cl = ( float ) 1.4 ;
pdev -> version = ( cl < 1.2 ? psdf_version_level2 : psdf_version_ll3 ) ;
if ( pdev -> ForOPDFRead ) {
pdev -> ResourcesBeforeUsage = true ;
pdev -> HaveCFF = false ;
pdev -> HavePDFWidths = false ;
pdev -> HaveStrokeColor = false ;
cl = ( float ) 1.2 ;
pdev -> MaxInlineImageSize = max_long ;
pdev -> version = psdf_version_level2 ;
}
else {
pdev -> ResourcesBeforeUsage = false ;
pdev -> HaveCFF = true ;
pdev -> HavePDFWidths = true ;
pdev -> HaveStrokeColor = true ;
}
pdev -> ParamCompatibilityLevel = cl ;
if ( cl < 1.2 ) {
pdev -> HaveCFF = false ;
}
ecode = gdev_psdf_put_params ( dev , plist ) ;
if ( ecode < 0 ) goto fail ;
if ( pdev -> CompatibilityLevel > 1.7 && pdev -> params . TransferFunctionInfo == tfi_Preserve ) {
pdev -> params . TransferFunctionInfo = tfi_Apply ;
emprintf ( pdev -> memory , "\nIt is not possible to preserve transfer functions in PDF 2.0\ntransfer functions will be applied instead\n" ) ;
}
if ( pdev -> params . ConvertCMYKImagesToRGB ) {
if ( pdev -> params . ColorConversionStrategy == ccs_CMYK ) {
emprintf ( pdev -> memory , "ConvertCMYKImagesToRGB is not compatible with ColorConversionStrategy of CMYK\n" ) ;
}
else {
if ( pdev -> params . ColorConversionStrategy == ccs_Gray ) {
emprintf ( pdev -> memory , "ConvertCMYKImagesToRGB is not compatible with ColorConversionStrategy of Gray\n" ) ;
}
else {
if ( pdev -> icc_struct ) rc_decrement ( pdev -> icc_struct , "reset default profile\n" ) ;
pdf_set_process_color_model ( pdev , 1 ) ;
ecode = gsicc_init_device_profile_struct ( ( gx_device * ) pdev , NULL , 0 ) ;
if ( ecode < 0 ) goto fail ;
}
}
}
switch ( pdev -> params . ColorConversionStrategy ) {
case ccs_ByObjectType : case ccs_LeaveColorUnchanged : break ;
case ccs_UseDeviceDependentColor : case ccs_UseDeviceIndependentColor : case ccs_UseDeviceIndependentColorForImages : pdev -> params . TransferFunctionInfo = tfi_Apply ;
break ;
case ccs_CMYK : pdev -> params . TransferFunctionInfo = tfi_Apply ;
if ( pdev -> icc_struct ) rc_decrement ( pdev -> icc_struct , "reset default profile\n" ) ;
pdf_set_process_color_model ( pdev , 2 ) ;
ecode = gsicc_init_device_profile_struct ( ( gx_device * ) pdev , NULL , 0 ) ;
if ( ecode < 0 ) goto fail ;
break ;
case ccs_Gray : pdev -> params . TransferFunctionInfo = tfi_Apply ;
if ( pdev -> icc_struct ) rc_decrement ( pdev -> icc_struct , "reset default profile\n" ) ;
pdf_set_process_color_model ( pdev , 0 ) ;
ecode = gsicc_init_device_profile_struct ( ( gx_device * ) pdev , NULL , 0 ) ;
if ( ecode < 0 ) goto fail ;
break ;
case ccs_sRGB : case ccs_RGB : pdev -> params . TransferFunctionInfo = tfi_Apply ;
if ( ! pdev -> params . ConvertCMYKImagesToRGB ) {
if ( pdev -> icc_struct ) rc_decrement ( pdev -> icc_struct , "reset default profile\n" ) ;
pdf_set_process_color_model ( pdev , 1 ) ;
ecode = gsicc_init_device_profile_struct ( ( gx_device * ) pdev , NULL , 0 ) ;
if ( ecode < 0 ) goto fail ;
}
break ;
default : break ;
}
if ( cl < 1.5f && pdev -> params . ColorImage . Filter != NULL && ! strcmp ( pdev -> params . ColorImage . Filter , "JPXEncode" ) ) {
emprintf ( pdev -> memory , "JPXEncode requires CompatibilityLevel >= 1.5 .\n" ) ;
ecode = gs_note_error ( gs_error_rangecheck ) ;
}
if ( cl < 1.5f && pdev -> params . GrayImage . Filter != NULL && ! strcmp ( pdev -> params . GrayImage . Filter , "JPXEncode" ) ) {
emprintf ( pdev -> memory , "JPXEncode requires CompatibilityLevel >= 1.5 .\n" ) ;
ecode = gs_note_error ( gs_error_rangecheck ) ;
}
if ( cl < 1.4f && pdev -> params . MonoImage . Filter != NULL && ! strcmp ( pdev -> params . MonoImage . Filter , "JBIG2Encode" ) ) {
emprintf ( pdev -> memory , "JBIG2Encode requires CompatibilityLevel >= 1.4 .\n" ) ;
ecode = gs_note_error ( gs_error_rangecheck ) ;
}
if ( pdev -> HaveTrueTypes && pdev -> version == psdf_version_level2 ) {
pdev -> version = psdf_version_level2_with_TT ;
}
if ( ecode < 0 ) goto fail ;
if ( pdev -> FirstObjectNumber != save_dev -> FirstObjectNumber ) {
if ( pdev -> xref . file != 0 ) {
if ( gp_fseek_64 ( pdev -> xref . file , 0L , SEEK_SET ) != 0 ) {
ecode = gs_error_ioerror ;
goto fail ;
}
pdf_initialize_ids ( pdev ) ;
}
}
pdev -> CompatibilityLevel = ( int ) ( cl * 10 + 0.5 ) / 10.0 ;
if ( pdev -> OwnerPassword . size != save_dev -> OwnerPassword . size || ( pdev -> OwnerPassword . size != 0 && memcmp ( pdev -> OwnerPassword . data , save_dev -> OwnerPassword . data , pdev -> OwnerPassword . size ) != 0 ) ) {
if ( pdev -> is_open ) {
if ( pdev -> PageCount == 0 ) {
gs_closedevice ( ( gx_device * ) save_dev ) ;
return 0 ;
}
else emprintf ( pdev -> memory , "Owner Password changed mid-job, ignoring.\n" ) ;
}
}
if ( pdev -> Linearise && pdev -> is_ps2write ) {
emprintf ( pdev -> memory , "Can't linearise PostScript output, ignoring\n" ) ;
pdev -> Linearise = false ;
}
if ( pdev -> Linearise && pdev -> OwnerPassword . size != 0 ) {
emprintf ( pdev -> memory , "Can't linearise encrypted PDF, ignoring\n" ) ;
pdev -> Linearise = false ;
}
if ( pdev -> FlattenFonts ) pdev -> PreserveTrMode = false ;
return 0 ;
fail : pdev -> version = save_dev -> version ;
pdf_set_process_color_model ( pdev , save_dev -> pcm_color_info_index ) ;
pdev -> saved_fill_color = save_dev -> saved_fill_color ;
pdev -> saved_stroke_color = save_dev -> saved_fill_color ;
{
const gs_param_item_t * ppi = pdf_param_items ;
for ( ;
ppi -> key ;
++ ppi ) memcpy ( ( char * ) pdev + ppi -> offset , ( char * ) save_dev + ppi -> offset , gs_param_type_sizes [ ppi -> type ] ) ;
pdev -> ForOPDFRead = save_dev -> ForOPDFRead ;
}
return ecode ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void test_simplesignal ( void ) {
struct event ev ;
struct itimerval itv ;
setup_test ( "Simple signal: " ) ;
signal_set ( & ev , SIGALRM , signal_cb , & ev ) ;
signal_add ( & ev , NULL ) ;
signal_del ( & ev ) ;
signal_add ( & ev , NULL ) ;
memset ( & itv , 0 , sizeof ( itv ) ) ;
itv . it_value . tv_sec = 1 ;
if ( setitimer ( ITIMER_REAL , & itv , NULL ) == - 1 ) goto skip_simplesignal ;
event_dispatch ( ) ;
skip_simplesignal : if ( signal_del ( & ev ) == - 1 ) test_ok = 0 ;
cleanup_test ( ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static PHP_NAMED_FUNCTION ( zif_zip_entry_close ) {
zval * zip_entry ;
zip_read_rsrc * zr_rsrc ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , "r" , & zip_entry ) == FAILURE ) {
return ;
}
ZEND_FETCH_RESOURCE ( zr_rsrc , zip_read_rsrc * , & zip_entry , - 1 , le_zip_entry_name , le_zip_entry ) ;
RETURN_BOOL ( SUCCESS == zend_list_delete ( Z_LVAL_P ( zip_entry ) ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static uint32_t e1000e_txdesc_writeback ( E1000ECore * core , dma_addr_t base , struct e1000_tx_desc * dp , bool * ide , int queue_idx ) {
uint32_t txd_upper , txd_lower = le32_to_cpu ( dp -> lower . data ) ;
if ( ! ( txd_lower & E1000_TXD_CMD_RS ) && ! ( core -> mac [ IVAR ] & E1000_IVAR_TX_INT_EVERY_WB ) ) {
return 0 ;
}
* ide = ( txd_lower & E1000_TXD_CMD_IDE ) ? true : false ;
txd_upper = le32_to_cpu ( dp -> upper . data ) | E1000_TXD_STAT_DD ;
dp -> upper . data = cpu_to_le32 ( txd_upper ) ;
pci_dma_write ( core -> owner , base + ( ( char * ) & dp -> upper - ( char * ) dp ) , & dp -> upper , sizeof ( dp -> upper ) ) ;
return e1000e_tx_wb_interrupt_cause ( core , queue_idx ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( ExternalProtocolHandlerTest , TestLaunchSchemeUnBlockedChromeNotDefault ) {
DoTest ( ExternalProtocolHandler : : DONT_BLOCK , shell_integration : : NOT_DEFAULT , Action : : LAUNCH ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void mspack_fmap_free ( void * mem ) {
if ( mem ) {
free ( mem ) ;
mem = NULL ;
}
return ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
zend_object_value pdo_dbstmt_new ( zend_class_entry * ce TSRMLS_DC ) {
zend_object_value retval ;
pdo_stmt_t * stmt ;
stmt = emalloc ( sizeof ( * stmt ) ) ;
memset ( stmt , 0 , sizeof ( * stmt ) ) ;
zend_object_std_init ( & stmt -> std , ce TSRMLS_CC ) ;
object_properties_init ( & stmt -> std , ce ) ;
stmt -> refcount = 1 ;
retval . handle = zend_objects_store_put ( stmt , ( zend_objects_store_dtor_t ) zend_objects_destroy_object , ( zend_objects_free_object_storage_t ) pdo_dbstmt_free_storage , ( zend_objects_store_clone_t ) dbstmt_clone_obj TSRMLS_CC ) ;
retval . handlers = & pdo_dbstmt_object_handlers ;
return retval ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_MIPAddress ( 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_MIPAddress , MIPAddress_sequence ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void DerFree ( Asn1Generic * a ) {
Asn1Generic * it , * n ;
if ( a == NULL ) return ;
it = a ;
while ( it ) {
n = it -> next ;
if ( it -> data ) {
DerFree ( it -> data ) ;
}
if ( it -> str ) SCFree ( it -> str ) ;
memset ( it , 0xff , sizeof ( Asn1Generic ) ) ;
SCFree ( it ) ;
it = n ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int AlreadyMSSymbolArea ( SplineFont * sf , EncMap * map ) {
int i ;
int acnt = 0 , pcnt = 0 ;
for ( i = 0 ;
i < map -> enccount && i < 0xffff ;
++ i ) {
if ( map -> map [ i ] != - 1 && sf -> glyphs [ map -> map [ i ] ] != NULL && sf -> glyphs [ map -> map [ i ] ] -> ttf_glyph != - 1 ) {
if ( i >= 0xf000 && i <= 0xf0ff ) ++ pcnt ;
else if ( i >= 0x20 && i <= 0xff ) ++ acnt ;
}
}
return ( pcnt > acnt ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int h263_decode_gob_header ( MpegEncContext * s ) {
unsigned int val , gob_number ;
int left ;
val = show_bits ( & s -> gb , 16 ) ;
if ( val ) return - 1 ;
skip_bits ( & s -> gb , 16 ) ;
left = get_bits_left ( & s -> gb ) ;
for ( ;
left > 13 ;
left -- ) {
if ( get_bits1 ( & s -> gb ) ) break ;
}
if ( left <= 13 ) return - 1 ;
if ( s -> h263_slice_structured ) {
if ( get_bits1 ( & s -> gb ) == 0 ) return - 1 ;
ff_h263_decode_mba ( s ) ;
if ( s -> mb_num > 1583 ) if ( get_bits1 ( & s -> gb ) == 0 ) return - 1 ;
s -> qscale = get_bits ( & s -> gb , 5 ) ;
if ( get_bits1 ( & s -> gb ) == 0 ) return - 1 ;
skip_bits ( & s -> gb , 2 ) ;
}
else {
gob_number = get_bits ( & s -> gb , 5 ) ;
s -> mb_x = 0 ;
s -> mb_y = s -> gob_index * gob_number ;
skip_bits ( & s -> gb , 2 ) ;
s -> qscale = get_bits ( & s -> gb , 5 ) ;
}
if ( s -> mb_y >= s -> mb_height ) return - 1 ;
if ( s -> qscale == 0 ) return - 1 ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static Datum ExecEvalScalarVar ( ExprState * exprstate , ExprContext * econtext , bool * isNull , ExprDoneCond * isDone ) {
Var * variable = ( Var * ) exprstate -> expr ;
TupleTableSlot * slot ;
AttrNumber attnum ;
if ( isDone ) * isDone = ExprSingleResult ;
switch ( variable -> varno ) {
case INNER_VAR : slot = econtext -> ecxt_innertuple ;
break ;
case OUTER_VAR : slot = econtext -> ecxt_outertuple ;
break ;
default : slot = econtext -> ecxt_scantuple ;
break ;
}
attnum = variable -> varattno ;
Assert ( attnum != InvalidAttrNumber ) ;
if ( attnum > 0 ) {
TupleDesc slot_tupdesc = slot -> tts_tupleDescriptor ;
Form_pg_attribute attr ;
if ( attnum > slot_tupdesc -> natts ) elog ( ERROR , "attribute number %d exceeds number of columns %d" , attnum , slot_tupdesc -> natts ) ;
attr = slot_tupdesc -> attrs [ attnum - 1 ] ;
if ( ! attr -> attisdropped ) {
if ( variable -> vartype != attr -> atttypid ) ereport ( ERROR , ( errcode ( ERRCODE_DATATYPE_MISMATCH ) , errmsg ( "attribute %d has wrong type" , attnum ) , errdetail ( "Table has type %s, but query expects %s." , format_type_be ( attr -> atttypid ) , format_type_be ( variable -> vartype ) ) ) ) ;
}
}
exprstate -> evalfunc = ExecEvalScalarVarFast ;
return slot_getattr ( slot , attnum , isNull ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vp9_sad ## m ## x ## n ## x4d_c ( const uint8_t * src , int src_stride , const uint8_t * const refs [ ] , int ref_stride , unsigned int * sads ) {
int i ;
for ( i = 0 ;
i < 4 ;
++ i ) sads [ i ] = vp9_sad ## m ## x ## n ## _c ( src , src_stride , refs [ i ] , ref_stride ) ;
\ }
sadMxN ( 64 , 64 ) sadMxNxK ( 64 , 64 , 3 ) sadMxNxK ( 64 , 64 , 8 ) sadMxNx4D ( 64 , 64 ) sadMxN ( 64 , 32 ) sadMxNx4D ( 64 , 32 ) sadMxN ( 32 , 64 ) sadMxNx4D ( 32 , 64 ) sadMxN ( 32 , 32 ) sadMxNxK ( 32 , 32 , 3 ) sadMxNxK ( 32 , 32 , 8 ) sadMxNx4D ( 32 , 32 ) sadMxN ( 32 , 16 ) sadMxNx4D ( 32 , 16 ) sadMxN ( 16 , 32 ) sadMxNx4D ( 16 , 32 ) sadMxN ( 16 , 16 ) sadMxNxK ( 16 , 16 , 3 ) sadMxNxK ( 16 , 16 , 8 ) sadMxNx4D ( 16 , 16 ) sadMxN ( 16 , 8 ) sadMxNxK ( 16 , 8 , 3 ) sadMxNxK ( 16 , 8 , 8 ) sadMxNx4D ( 16 , 8 ) sadMxN ( 8 , 16 ) sadMxNxK ( 8 , 16 , 3 ) sadMxNxK ( 8 , 16 , 8 ) sadMxNx4D ( 8 , 16 ) sadMxN ( 8 , 8 ) sadMxNxK ( 8 , 8 , 3 ) sadMxNxK ( 8 , 8 , 8 ) sadMxNx4D ( 8 , 8 ) sadMxN ( 8 , 4 ) sadMxNxK ( 8 , 4 , 8 ) sadMxNx4D ( 8 , 4 ) sadMxN ( 4 , 8 ) sadMxNxK ( 4 , 8 , 8 ) sadMxNx4D ( 4 , 8 ) sadMxN ( 4 , 4 ) sadMxNxK ( 4 , 4 , 3 ) sadMxNxK ( 4 , 4 , 8 ) sadMxNx4D ( 4 , 4 )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
inline static void _slurm_rpc_dump_licenses ( slurm_msg_t * msg ) {
DEF_TIMERS ;
char * dump ;
int dump_size ;
slurm_msg_t response_msg ;
license_info_request_msg_t * lic_req_msg ;
uid_t uid = g_slurm_auth_get_uid ( msg -> auth_cred , slurmctld_config . auth_info ) ;
START_TIMER ;
debug2 ( "%s: Processing RPC: REQUEST_LICENSE_INFO uid=%d" , __func__ , uid ) ;
lic_req_msg = ( license_info_request_msg_t * ) msg -> data ;
if ( ( lic_req_msg -> last_update - 1 ) >= last_license_update ) {
debug2 ( "%s: no change SLURM_NO_CHANGE_IN_DATA" , __func__ ) ;
slurm_send_rc_msg ( msg , SLURM_NO_CHANGE_IN_DATA ) ;
return ;
}
get_all_license_info ( & dump , & dump_size , uid , msg -> protocol_version ) ;
END_TIMER2 ( "_slurm_rpc_dump_licenses" ) ;
debug2 ( "%s: size=%d %s" , __func__ , dump_size , TIME_STR ) ;
slurm_msg_t_init ( & response_msg ) ;
response_msg . flags = msg -> flags ;
response_msg . protocol_version = msg -> protocol_version ;
response_msg . address = msg -> address ;
response_msg . conn = msg -> conn ;
response_msg . msg_type = RESPONSE_LICENSE_INFO ;
response_msg . data = dump ;
response_msg . data_size = dump_size ;
slurm_send_node_msg ( msg -> conn_fd , & response_msg ) ;
xfree ( dump ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static __inline__ void TLV_SET_TYPE ( struct tlv_desc * tlv , __u16 type ) {
tlv -> tlv_type = htons ( type ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int vp3_init_thread_copy ( AVCodecContext * avctx ) {
Vp3DecodeContext * s = avctx -> priv_data ;
s -> superblock_coding = NULL ;
s -> all_fragments = NULL ;
s -> coded_fragment_list [ 0 ] = NULL ;
s -> dct_tokens_base = NULL ;
s -> superblock_fragments = NULL ;
s -> macroblock_coding = NULL ;
s -> motion_val [ 0 ] = NULL ;
s -> motion_val [ 1 ] = NULL ;
s -> edge_emu_buffer = NULL ;
return init_frames ( s ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void mime_parser_clear ( MIMEParser * parser ) {
mime_scanner_clear ( & parser -> m_scanner ) ;
_mime_parser_init ( parser ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void U_CALLCONV _UTF7Open ( UConverter * cnv , UConverterLoadArgs * pArgs , UErrorCode * pErrorCode ) {
( void ) pArgs ;
if ( UCNV_GET_VERSION ( cnv ) <= 1 ) {
cnv -> fromUnicodeStatus = UCNV_GET_VERSION ( cnv ) << 28 ;
_UTF7Reset ( cnv , UCNV_RESET_BOTH ) ;
}
else {
* pErrorCode = U_ILLEGAL_ARGUMENT_ERROR ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static char * emnc10_opaque_binary_attr ( tvbuff_t * tvb , guint32 offset , guint8 token , guint8 codepage , guint32 * length ) {
guint32 data_len = tvb_get_guintvar ( tvb , offset , length ) ;
char * str = NULL ;
switch ( codepage ) {
case 0 : switch ( token ) {
case 0x05 : str = date_time_from_opaque ( tvb , offset + * length , data_len ) ;
break ;
default : break ;
}
break ;
default : break ;
}
if ( str == NULL ) {
str = wmem_strdup_printf ( wmem_packet_scope ( ) , "(%d bytes of unparsed opaque data)" , data_len ) ;
}
* length += data_len ;
return str ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static uint ms_to_precision ( uint ms ) {
uint cut , precision ;
for ( cut = 10 , precision = 6 ;
precision > 0 ;
cut *= 10 , precision -- ) {
if ( ms % cut ) return precision ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void dtap_gcc_setup ( tvbuff_t * tvb , proto_tree * tree , packet_info * pinfo _U_ , guint32 offset , guint len ) {
guint32 curr_offset ;
guint32 consumed ;
guint curr_len ;
curr_offset = offset ;
curr_len = len ;
ELEM_MAND_V ( GSM_A_PDU_TYPE_DTAP , DE_GCC_CALL_REF , NULL ) ;
ELEM_OPT_TLV ( 0x7e , GSM_A_PDU_TYPE_DTAP , DE_USER_USER , NULL ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void encode_without_recode_loop ( VP9_COMP * cpi , int q ) {
VP9_COMMON * const cm = & cpi -> common ;
vp9_clear_system_state ( ) ;
vp9_set_quantizer ( cm , q ) ;
setup_frame ( cpi ) ;
if ( cpi -> oxcf . aq_mode == VARIANCE_AQ ) {
vp9_vaq_frame_setup ( cpi ) ;
}
else if ( cpi -> oxcf . aq_mode == COMPLEXITY_AQ ) {
vp9_setup_in_frame_q_adj ( cpi ) ;
}
else if ( cpi -> oxcf . aq_mode == CYCLIC_REFRESH_AQ ) {
vp9_cyclic_refresh_setup ( cpi ) ;
}
vp9_encode_frame ( cpi ) ;
vp9_clear_system_state ( ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void proto_reg_handoff_mswsp ( void ) {
heur_dissector_add ( "smb_transact" , dissect_mswsp_smb , "WSP over SMB1" , "smb1_wsp" , proto_mswsp , HEURISTIC_ENABLE ) ;
heur_dissector_add ( "smb2_pipe_subdissectors" , dissect_mswsp_smb2 , "WSP over SMB2" , "smb2_wsp" , proto_mswsp , HEURISTIC_ENABLE ) ;
}
| 0False
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.