instruction
stringclasses 1
value | input
stringlengths 31
235k
| output
class label 2
classes |
|---|---|---|
Categorize the following code snippet as vulnerable or not. True or False
|
static void read_graphic_control_extension ( Gif_Context * gfc , Gif_Image * gfi , Gif_Reader * grr ) {
uint8_t len ;
uint8_t crap [ GIF_MAX_BLOCK ] ;
len = gifgetbyte ( grr ) ;
if ( len == 4 ) {
uint8_t packed = gifgetbyte ( grr ) ;
gfi -> disposal = ( packed >> 2 ) & 0x07 ;
gfi -> delay = gifgetunsigned ( grr ) ;
gfi -> transparent = gifgetbyte ( grr ) ;
if ( ! ( packed & 0x01 ) ) gfi -> transparent = - 1 ;
len -= 4 ;
}
if ( len > 0 ) {
gif_read_error ( gfc , 1 , "bad graphic extension" ) ;
gifgetblock ( crap , len , grr ) ;
}
len = gifgetbyte ( grr ) ;
while ( len > 0 ) {
gif_read_error ( gfc , 1 , "bad graphic extension" ) ;
gifgetblock ( crap , len , grr ) ;
len = gifgetbyte ( grr ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_CapabilityDescriptorNumber ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_constrained_integer ( tvb , offset , actx , tree , hf_index , 0U , 255U , NULL , FALSE ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h225_T_h245Ip6 ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
# line 350 "./asn1/h225/h225.cnf" tvbuff_t * value_tvb ;
ipv6_address = ipv6_address_zeros ;
offset = dissect_per_octet_string ( tvb , offset , actx , tree , hf_index , 16 , 16 , FALSE , & value_tvb ) ;
if ( value_tvb ) tvb_get_ipv6 ( value_tvb , 0 , & ipv6_address ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int X509_pubkey_digest ( const X509 * data , const EVP_MD * type , unsigned char * md , unsigned int * len ) {
ASN1_BIT_STRING * key ;
key = X509_get0_pubkey_bitstr ( data ) ;
if ( ! key ) return 0 ;
return EVP_Digest ( key -> data , key -> length , md , len , type , NULL ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static PyObject * string_item ( PyStringObject * a , register Py_ssize_t i ) {
char pchar ;
PyObject * v ;
if ( i < 0 || i >= Py_SIZE ( a ) ) {
PyErr_SetString ( PyExc_IndexError , "string index out of range" ) ;
return NULL ;
}
pchar = a -> ob_sval [ i ] ;
v = ( PyObject * ) characters [ pchar & UCHAR_MAX ] ;
if ( v == NULL ) v = PyString_FromStringAndSize ( & pchar , 1 ) ;
else {
# ifdef COUNT_ALLOCS one_strings ++ ;
# endif Py_INCREF ( v ) ;
}
return v ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
bool matchesOrigin ( const url : : Origin & origin , const GURL & url ) {
return origin . IsSameOriginWith ( url : : Origin ( url ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
afs_int32 SPR_GetHostCPS ( struct rx_call * call , afs_int32 ahost , prlist * alist , afs_int32 * over ) {
afs_int32 code ;
code = getHostCPS ( call , ahost , alist , over ) ;
osi_auditU ( call , PTS_GetHCPSEvent , code , AUD_HOST , htonl ( ahost ) , AUD_END ) ;
ViceLog ( 125 , ( "PTS_GetHostCPS: code %d ahost %d\n" , code , ahost ) ) ;
return code ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void proto_tree_set_protocol_tvb ( field_info * fi , tvbuff_t * tvb , const char * field_data ) {
fvalue_set_protocol ( & fi -> value , tvb , field_data ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( SessionRestorePageLoadMetricsBrowserTest , RestoreForeignSession ) {
Profile * profile = browser ( ) -> profile ( ) ;
sessions : : SerializedNavigationEntry nav1 = sessions : : SerializedNavigationEntryTestHelper : : CreateNavigation ( GetTestURL ( ) . spec ( ) , "one" ) ;
sessions : : SerializedNavigationEntry nav2 = sessions : : SerializedNavigationEntryTestHelper : : CreateNavigation ( GetTestURL2 ( ) . spec ( ) , "two" ) ;
std : : vector < const sessions : : SessionWindow * > session ;
sessions : : SessionWindow window ;
auto tab1 = std : : make_unique < sessions : : SessionTab > ( ) ;
{
sync_pb : : SessionTab sync_data ;
sync_data . set_tab_visual_index ( 0 ) ;
sync_data . set_current_navigation_index ( 0 ) ;
sync_data . set_pinned ( true ) ;
sync_data . add_navigation ( ) -> CopyFrom ( nav1 . ToSyncData ( ) ) ;
tab1 -> SetFromSyncData ( sync_data , base : : Time : : Now ( ) ) ;
}
window . tabs . push_back ( std : : move ( tab1 ) ) ;
auto tab2 = std : : make_unique < sessions : : SessionTab > ( ) ;
{
sync_pb : : SessionTab sync_data ;
sync_data . set_tab_visual_index ( 1 ) ;
sync_data . set_current_navigation_index ( 0 ) ;
sync_data . set_pinned ( false ) ;
sync_data . add_navigation ( ) -> CopyFrom ( nav2 . ToSyncData ( ) ) ;
tab2 -> SetFromSyncData ( sync_data , base : : Time : : Now ( ) ) ;
}
window . tabs . push_back ( std : : move ( tab2 ) ) ;
session . push_back ( static_cast < const sessions : : SessionWindow * > ( & window ) ) ;
ui_test_utils : : BrowserAddedObserver window_observer ;
SessionRestorePaintWaiter session_restore_paint_waiter ;
SessionRestore : : RestoreForeignSessionWindows ( profile , session . begin ( ) , session . end ( ) ) ;
Browser * new_browser = window_observer . WaitForSingleNewBrowser ( ) ;
ASSERT_TRUE ( new_browser ) ;
ASSERT_EQ ( 2 , new_browser -> tab_strip_model ( ) -> count ( ) ) ;
session_restore_paint_waiter . WaitForForegroundTabs ( 1 ) ;
ASSERT_NO_FATAL_FAILURE ( WaitForTabsToLoad ( new_browser ) ) ;
ExpectFirstPaintMetricsTotalCount ( 1 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void server_port_read ( struct evdns_server_port * s ) {
u8 packet [ 1500 ] ;
struct sockaddr_storage addr ;
socklen_t addrlen ;
int r ;
for ( ;
;
) {
addrlen = sizeof ( struct sockaddr_storage ) ;
r = recvfrom ( s -> socket , packet , sizeof ( packet ) , 0 , ( struct sockaddr * ) & addr , & addrlen ) ;
if ( r < 0 ) {
int err = last_error ( s -> socket ) ;
if ( error_is_eagain ( err ) ) return ;
log ( EVDNS_LOG_WARN , "Error %s (%d) while reading request." , strerror ( err ) , err ) ;
return ;
}
request_parse ( packet , r , s , ( struct sockaddr * ) & addr , addrlen ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int nsv_read_seek ( AVFormatContext * s , int stream_index , int64_t timestamp , int flags ) {
NSVContext * nsv = s -> priv_data ;
AVStream * st = s -> streams [ stream_index ] ;
NSVStream * nst = st -> priv_data ;
int index ;
index = av_index_search_timestamp ( st , timestamp , flags ) ;
if ( index < 0 ) return - 1 ;
if ( avio_seek ( s -> pb , st -> index_entries [ index ] . pos , SEEK_SET ) < 0 ) return - 1 ;
nst -> frame_offset = st -> index_entries [ index ] . timestamp ;
nsv -> state = NSV_UNSYNC ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
SPL_METHOD ( SplFileObject , fgetss ) {
spl_filesystem_object * intern = ( spl_filesystem_object * ) zend_object_store_get_object ( getThis ( ) TSRMLS_CC ) ;
zval * arg2 = NULL ;
MAKE_STD_ZVAL ( arg2 ) ;
if ( intern -> u . file . max_line_len > 0 ) {
ZVAL_LONG ( arg2 , intern -> u . file . max_line_len ) ;
}
else {
ZVAL_LONG ( arg2 , 1024 ) ;
}
spl_filesystem_file_free_line ( intern TSRMLS_CC ) ;
intern -> u . file . current_line_num ++ ;
FileFunctionCall ( fgetss , ZEND_NUM_ARGS ( ) , arg2 ) ;
zval_ptr_dtor ( & arg2 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void xps_parse_glyphs ( xps_document * doc , const fz_matrix * ctm , char * base_uri , xps_resource * dict , fz_xml * root ) {
fz_xml * node ;
char * fill_uri ;
char * opacity_mask_uri ;
char * bidi_level_att ;
char * fill_att ;
char * font_size_att ;
char * font_uri_att ;
char * origin_x_att ;
char * origin_y_att ;
char * is_sideways_att ;
char * indices_att ;
char * unicode_att ;
char * style_att ;
char * transform_att ;
char * clip_att ;
char * opacity_att ;
char * opacity_mask_att ;
char * navigate_uri_att ;
fz_xml * transform_tag = NULL ;
fz_xml * clip_tag = NULL ;
fz_xml * fill_tag = NULL ;
fz_xml * opacity_mask_tag = NULL ;
char * fill_opacity_att = NULL ;
xps_part * part ;
fz_font * font ;
char partname [ 1024 ] ;
char fakename [ 1024 ] ;
char * subfont ;
float font_size = 10 ;
int subfontid = 0 ;
int is_sideways = 0 ;
int bidi_level = 0 ;
fz_text * text ;
fz_rect area ;
fz_matrix local_ctm = * ctm ;
bidi_level_att = fz_xml_att ( root , "BidiLevel" ) ;
fill_att = fz_xml_att ( root , "Fill" ) ;
font_size_att = fz_xml_att ( root , "FontRenderingEmSize" ) ;
font_uri_att = fz_xml_att ( root , "FontUri" ) ;
origin_x_att = fz_xml_att ( root , "OriginX" ) ;
origin_y_att = fz_xml_att ( root , "OriginY" ) ;
is_sideways_att = fz_xml_att ( root , "IsSideways" ) ;
indices_att = fz_xml_att ( root , "Indices" ) ;
unicode_att = fz_xml_att ( root , "UnicodeString" ) ;
style_att = fz_xml_att ( root , "StyleSimulations" ) ;
transform_att = fz_xml_att ( root , "RenderTransform" ) ;
clip_att = fz_xml_att ( root , "Clip" ) ;
opacity_att = fz_xml_att ( root , "Opacity" ) ;
opacity_mask_att = fz_xml_att ( root , "OpacityMask" ) ;
navigate_uri_att = fz_xml_att ( root , "FixedPage.NavigateUri" ) ;
for ( node = fz_xml_down ( root ) ;
node ;
node = fz_xml_next ( node ) ) {
if ( ! strcmp ( fz_xml_tag ( node ) , "Glyphs.RenderTransform" ) ) transform_tag = fz_xml_down ( node ) ;
if ( ! strcmp ( fz_xml_tag ( node ) , "Glyphs.OpacityMask" ) ) opacity_mask_tag = fz_xml_down ( node ) ;
if ( ! strcmp ( fz_xml_tag ( node ) , "Glyphs.Clip" ) ) clip_tag = fz_xml_down ( node ) ;
if ( ! strcmp ( fz_xml_tag ( node ) , "Glyphs.Fill" ) ) fill_tag = fz_xml_down ( node ) ;
}
fill_uri = base_uri ;
opacity_mask_uri = base_uri ;
xps_resolve_resource_reference ( doc , dict , & transform_att , & transform_tag , NULL ) ;
xps_resolve_resource_reference ( doc , dict , & clip_att , & clip_tag , NULL ) ;
xps_resolve_resource_reference ( doc , dict , & fill_att , & fill_tag , & fill_uri ) ;
xps_resolve_resource_reference ( doc , dict , & opacity_mask_att , & opacity_mask_tag , & opacity_mask_uri ) ;
if ( ! font_size_att || ! font_uri_att || ! origin_x_att || ! origin_y_att ) {
fz_warn ( doc -> ctx , "missing attributes in glyphs element" ) ;
return ;
}
if ( ! indices_att && ! unicode_att ) return ;
if ( is_sideways_att ) is_sideways = ! strcmp ( is_sideways_att , "true" ) ;
if ( bidi_level_att ) bidi_level = atoi ( bidi_level_att ) ;
xps_resolve_url ( partname , base_uri , font_uri_att , sizeof partname ) ;
subfont = strrchr ( partname , '#' ) ;
if ( subfont ) {
subfontid = atoi ( subfont + 1 ) ;
* subfont = 0 ;
}
fz_strlcpy ( fakename , partname , sizeof fakename ) ;
if ( style_att ) {
if ( ! strcmp ( style_att , "BoldSimulation" ) ) fz_strlcat ( fakename , "#Bold" , sizeof fakename ) ;
else if ( ! strcmp ( style_att , "ItalicSimulation" ) ) fz_strlcat ( fakename , "#Italic" , sizeof fakename ) ;
else if ( ! strcmp ( style_att , "BoldItalicSimulation" ) ) fz_strlcat ( fakename , "#BoldItalic" , sizeof fakename ) ;
}
font = xps_lookup_font ( doc , fakename ) ;
if ( ! font ) {
fz_try ( doc -> ctx ) {
part = xps_read_part ( doc , partname ) ;
}
fz_catch ( doc -> ctx ) {
fz_rethrow_if ( doc -> ctx , FZ_ERROR_TRYLATER ) ;
fz_warn ( doc -> ctx , "cannot find font resource part '%s'" , partname ) ;
return ;
}
if ( strstr ( part -> name , ".odttf" ) ) xps_deobfuscate_font_resource ( doc , part ) ;
if ( strstr ( part -> name , ".ODTTF" ) ) xps_deobfuscate_font_resource ( doc , part ) ;
fz_try ( doc -> ctx ) {
fz_buffer * buf = fz_new_buffer_from_data ( doc -> ctx , part -> data , part -> size ) ;
font = fz_new_font_from_buffer ( doc -> ctx , NULL , buf , subfontid , 1 ) ;
fz_drop_buffer ( doc -> ctx , buf ) ;
}
fz_catch ( doc -> ctx ) {
fz_rethrow_if ( doc -> ctx , FZ_ERROR_TRYLATER ) ;
fz_warn ( doc -> ctx , "cannot load font resource '%s'" , partname ) ;
xps_free_part ( doc , part ) ;
return ;
}
if ( style_att ) {
font -> ft_bold = ! ! strstr ( style_att , "Bold" ) ;
font -> ft_italic = ! ! strstr ( style_att , "Italic" ) ;
}
xps_select_best_font_encoding ( doc , font ) ;
xps_insert_font ( doc , fakename , font ) ;
fz_free ( doc -> ctx , part -> name ) ;
fz_free ( doc -> ctx , part ) ;
}
if ( transform_att || transform_tag ) {
fz_matrix transform ;
if ( transform_att ) xps_parse_render_transform ( doc , transform_att , & transform ) ;
if ( transform_tag ) xps_parse_matrix_transform ( doc , transform_tag , & transform ) ;
fz_concat ( & local_ctm , & transform , & local_ctm ) ;
}
if ( clip_att || clip_tag ) xps_clip ( doc , & local_ctm , dict , clip_att , clip_tag ) ;
font_size = fz_atof ( font_size_att ) ;
text = xps_parse_glyphs_imp ( doc , & local_ctm , font , font_size , fz_atof ( origin_x_att ) , fz_atof ( origin_y_att ) , is_sideways , bidi_level , indices_att , unicode_att ) ;
fz_bound_text ( doc -> ctx , text , NULL , & local_ctm , & area ) ;
if ( navigate_uri_att ) xps_add_link ( doc , & area , base_uri , navigate_uri_att ) ;
xps_begin_opacity ( doc , & local_ctm , & area , opacity_mask_uri , dict , opacity_att , opacity_mask_tag ) ;
if ( fill_tag && ! strcmp ( fz_xml_tag ( fill_tag ) , "SolidColorBrush" ) ) {
fill_opacity_att = fz_xml_att ( fill_tag , "Opacity" ) ;
fill_att = fz_xml_att ( fill_tag , "Color" ) ;
fill_tag = NULL ;
}
if ( fill_att ) {
float samples [ FZ_MAX_COLORS ] ;
fz_colorspace * colorspace ;
xps_parse_color ( doc , base_uri , fill_att , & colorspace , samples ) ;
if ( fill_opacity_att ) samples [ 0 ] *= fz_atof ( fill_opacity_att ) ;
xps_set_color ( doc , colorspace , samples ) ;
fz_fill_text ( doc -> dev , text , & local_ctm , doc -> colorspace , doc -> color , doc -> alpha ) ;
}
if ( fill_tag ) {
fz_clip_text ( doc -> dev , text , & local_ctm , 0 ) ;
xps_parse_brush ( doc , & local_ctm , & area , fill_uri , dict , fill_tag ) ;
fz_pop_clip ( doc -> dev ) ;
}
xps_end_opacity ( doc , opacity_mask_uri , dict , opacity_att , opacity_mask_tag ) ;
fz_free_text ( doc -> ctx , text ) ;
if ( clip_att || clip_tag ) fz_pop_clip ( doc -> dev ) ;
fz_drop_font ( doc -> ctx , font ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( ExternalProtocolHandlerTest , TestGetBlockStateLocalBlockStateCopiedAndResetOnProfilePref ) {
base : : DictionaryValue prefs_local ;
prefs_local . SetBoolean ( "tel" , true ) ;
local_state_ -> Set ( prefs : : kExcludedSchemes , prefs_local ) ;
ExternalProtocolHandler : : BlockState block_state = ExternalProtocolHandler : : GetBlockState ( "tel" , profile_ . get ( ) ) ;
EXPECT_EQ ( ExternalProtocolHandler : : UNKNOWN , block_state ) ;
EXPECT_TRUE ( local_state_ -> GetDictionary ( prefs : : kExcludedSchemes ) -> empty ( ) ) ;
EXPECT_FALSE ( profile_ -> GetPrefs ( ) -> GetDictionary ( prefs : : kExcludedSchemes ) -> empty ( ) ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vp9_idct8x8_64_add_sse2 ( const int16_t * input , uint8_t * dest , int stride ) {
const __m128i zero = _mm_setzero_si128 ( ) ;
const __m128i rounding = _mm_set1_epi32 ( DCT_CONST_ROUNDING ) ;
const __m128i final_rounding = _mm_set1_epi16 ( 1 << 4 ) ;
const __m128i stg1_0 = pair_set_epi16 ( cospi_28_64 , - cospi_4_64 ) ;
const __m128i stg1_1 = pair_set_epi16 ( cospi_4_64 , cospi_28_64 ) ;
const __m128i stg1_2 = pair_set_epi16 ( - cospi_20_64 , cospi_12_64 ) ;
const __m128i stg1_3 = pair_set_epi16 ( cospi_12_64 , cospi_20_64 ) ;
const __m128i stg2_0 = pair_set_epi16 ( cospi_16_64 , cospi_16_64 ) ;
const __m128i stg2_1 = pair_set_epi16 ( cospi_16_64 , - cospi_16_64 ) ;
const __m128i stg2_2 = pair_set_epi16 ( cospi_24_64 , - cospi_8_64 ) ;
const __m128i stg2_3 = pair_set_epi16 ( cospi_8_64 , cospi_24_64 ) ;
__m128i in0 , in1 , in2 , in3 , in4 , in5 , in6 , in7 ;
__m128i stp1_0 , stp1_1 , stp1_2 , stp1_3 , stp1_4 , stp1_5 , stp1_6 , stp1_7 ;
__m128i stp2_0 , stp2_1 , stp2_2 , stp2_3 , stp2_4 , stp2_5 , stp2_6 , stp2_7 ;
__m128i tmp0 , tmp1 , tmp2 , tmp3 , tmp4 , tmp5 , tmp6 , tmp7 ;
int i ;
in0 = _mm_load_si128 ( ( const __m128i * ) input ) ;
in1 = _mm_load_si128 ( ( const __m128i * ) ( input + 8 * 1 ) ) ;
in2 = _mm_load_si128 ( ( const __m128i * ) ( input + 8 * 2 ) ) ;
in3 = _mm_load_si128 ( ( const __m128i * ) ( input + 8 * 3 ) ) ;
in4 = _mm_load_si128 ( ( const __m128i * ) ( input + 8 * 4 ) ) ;
in5 = _mm_load_si128 ( ( const __m128i * ) ( input + 8 * 5 ) ) ;
in6 = _mm_load_si128 ( ( const __m128i * ) ( input + 8 * 6 ) ) ;
in7 = _mm_load_si128 ( ( const __m128i * ) ( input + 8 * 7 ) ) ;
for ( i = 0 ;
i < 2 ;
i ++ ) {
TRANSPOSE_8X8 ( in0 , in1 , in2 , in3 , in4 , in5 , in6 , in7 , in0 , in1 , in2 , in3 , in4 , in5 , in6 , in7 ) ;
IDCT8 ( in0 , in1 , in2 , in3 , in4 , in5 , in6 , in7 , in0 , in1 , in2 , in3 , in4 , in5 , in6 , in7 ) ;
}
in0 = _mm_adds_epi16 ( in0 , final_rounding ) ;
in1 = _mm_adds_epi16 ( in1 , final_rounding ) ;
in2 = _mm_adds_epi16 ( in2 , final_rounding ) ;
in3 = _mm_adds_epi16 ( in3 , final_rounding ) ;
in4 = _mm_adds_epi16 ( in4 , final_rounding ) ;
in5 = _mm_adds_epi16 ( in5 , final_rounding ) ;
in6 = _mm_adds_epi16 ( in6 , final_rounding ) ;
in7 = _mm_adds_epi16 ( in7 , final_rounding ) ;
in0 = _mm_srai_epi16 ( in0 , 5 ) ;
in1 = _mm_srai_epi16 ( in1 , 5 ) ;
in2 = _mm_srai_epi16 ( in2 , 5 ) ;
in3 = _mm_srai_epi16 ( in3 , 5 ) ;
in4 = _mm_srai_epi16 ( in4 , 5 ) ;
in5 = _mm_srai_epi16 ( in5 , 5 ) ;
in6 = _mm_srai_epi16 ( in6 , 5 ) ;
in7 = _mm_srai_epi16 ( in7 , 5 ) ;
RECON_AND_STORE ( dest , in0 ) ;
RECON_AND_STORE ( dest , in1 ) ;
RECON_AND_STORE ( dest , in2 ) ;
RECON_AND_STORE ( dest , in3 ) ;
RECON_AND_STORE ( dest , in4 ) ;
RECON_AND_STORE ( dest , in5 ) ;
RECON_AND_STORE ( dest , in6 ) ;
RECON_AND_STORE ( dest , in7 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int t_fromb64 ( unsigned char * a , const char * src ) {
char * loc ;
int i , j ;
int size ;
while ( * src && ( * src == ' ' || * src == '\t' || * src == '\n' ) ) ++ src ;
size = strlen ( src ) ;
i = 0 ;
while ( i < size ) {
loc = strchr ( b64table , src [ i ] ) ;
if ( loc == ( char * ) 0 ) break ;
else a [ i ] = loc - b64table ;
++ i ;
}
if ( i == 0 ) return 0 ;
size = i ;
i = size - 1 ;
j = size ;
while ( 1 ) {
a [ j ] = a [ i ] ;
if ( -- i < 0 ) break ;
a [ j ] |= ( a [ i ] & 3 ) << 6 ;
-- j ;
a [ j ] = ( unsigned char ) ( ( a [ i ] & 0x3c ) >> 2 ) ;
if ( -- i < 0 ) break ;
a [ j ] |= ( a [ i ] & 0xf ) << 4 ;
-- j ;
a [ j ] = ( unsigned char ) ( ( a [ i ] & 0x30 ) >> 4 ) ;
if ( -- i < 0 ) break ;
a [ j ] |= ( a [ i ] << 2 ) ;
a [ -- j ] = 0 ;
if ( -- i < 0 ) break ;
}
while ( a [ j ] == 0 && j <= size ) ++ j ;
i = 0 ;
while ( j <= size ) a [ i ++ ] = a [ j ++ ] ;
return i ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void libopenjpeg_copy_to_packed8 ( AVFrame * picture , opj_image_t * image ) {
uint8_t * img_ptr ;
int index , x , y , c ;
for ( y = 0 ;
y < picture -> height ;
y ++ ) {
index = y * picture -> width ;
img_ptr = picture -> data [ 0 ] + y * picture -> linesize [ 0 ] ;
for ( x = 0 ;
x < picture -> width ;
x ++ , index ++ ) {
for ( c = 0 ;
c < image -> numcomps ;
c ++ ) {
* img_ptr ++ = image -> comps [ c ] . data [ index ] ;
}
}
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vp9_rc_set_gf_max_interval ( const VP9_COMP * const cpi , RATE_CONTROL * const rc ) {
const VP9EncoderConfig * const oxcf = & cpi -> oxcf ;
rc -> max_gf_interval = 16 ;
rc -> static_scene_max_gf_interval = oxcf -> key_freq >> 1 ;
if ( rc -> static_scene_max_gf_interval > ( MAX_LAG_BUFFERS * 2 ) ) rc -> static_scene_max_gf_interval = MAX_LAG_BUFFERS * 2 ;
if ( is_altref_enabled ( cpi ) ) {
if ( rc -> static_scene_max_gf_interval > oxcf -> lag_in_frames - 1 ) rc -> static_scene_max_gf_interval = oxcf -> lag_in_frames - 1 ;
}
if ( rc -> max_gf_interval > rc -> static_scene_max_gf_interval ) rc -> max_gf_interval = rc -> static_scene_max_gf_interval ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void await_reference_mb_row ( H264Context * const h , Picture * ref , int mb_y ) {
int ref_field = ref -> reference - 1 ;
int ref_field_picture = ref -> field_picture ;
int ref_height = 16 * h -> mb_height >> ref_field_picture ;
if ( ! HAVE_THREADS || ! ( h -> avctx -> active_thread_type & FF_THREAD_FRAME ) ) return ;
ff_thread_await_progress ( & ref -> tf , FFMIN ( 16 * mb_y >> ref_field_picture , ref_height - 1 ) , ref_field_picture && ref_field ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int main ( int argc , char * * argv ) {
gpg_error_t err ;
if ( argc ) {
argc -- ;
argv ++ ;
}
if ( argc ) {
unsigned char * buffer ;
size_t n , buflen ;
for ( ;
argc ;
argc -- , argv ++ ) {
err = ksba_oid_from_str ( * argv , & buffer , & buflen ) ;
if ( err ) {
fprintf ( stderr , "can't convert `%s': %s\n" , * argv , gpg_strerror ( err ) ) ;
return 1 ;
}
printf ( "%s ->" , * argv ) ;
for ( n = 0 ;
n < buflen ;
n ++ ) printf ( " %02X" , buffer [ n ] ) ;
putchar ( '\n' ) ;
free ( buffer ) ;
}
}
else {
char * buffer ;
size_t buflen ;
char * result ;
buffer = read_into_buffer ( stdin , & buflen ) ;
result = ksba_oid_to_str ( buffer , buflen ) ;
free ( buffer ) ;
printf ( "%s\n" , result ? result : "[malloc failed]" ) ;
free ( result ) ;
}
return 0 ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int h261_decode_gob ( H261Context * h ) {
MpegEncContext * const s = & h -> s ;
ff_set_qscale ( s , s -> qscale ) ;
while ( h -> current_mba <= MBA_STUFFING ) {
int ret ;
ret = h261_decode_mb ( h ) ;
if ( ret < 0 ) {
if ( ret == SLICE_END ) {
h261_decode_mb_skipped ( h , h -> current_mba , 33 ) ;
return 0 ;
}
av_log ( s -> avctx , AV_LOG_ERROR , "Error at MB: %d\n" , s -> mb_x + s -> mb_y * s -> mb_stride ) ;
return - 1 ;
}
h261_decode_mb_skipped ( h , h -> current_mba - h -> mba_diff , h -> current_mba - 1 ) ;
}
return - 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void rv34_pred_mv_rv3 ( RV34DecContext * r , int block_type , int dir ) {
MpegEncContext * s = & r -> s ;
int mv_pos = s -> mb_x * 2 + s -> mb_y * 2 * s -> b8_stride ;
int A [ 2 ] = {
0 }
, B [ 2 ] , C [ 2 ] ;
int i , j , k ;
int mx , my ;
int * avail = r -> avail_cache + avail_indexes [ 0 ] ;
if ( avail [ - 1 ] ) {
A [ 0 ] = s -> current_picture_ptr -> motion_val [ 0 ] [ mv_pos - 1 ] [ 0 ] ;
A [ 1 ] = s -> current_picture_ptr -> motion_val [ 0 ] [ mv_pos - 1 ] [ 1 ] ;
}
if ( avail [ - 4 ] ) {
B [ 0 ] = s -> current_picture_ptr -> motion_val [ 0 ] [ mv_pos - s -> b8_stride ] [ 0 ] ;
B [ 1 ] = s -> current_picture_ptr -> motion_val [ 0 ] [ mv_pos - s -> b8_stride ] [ 1 ] ;
}
else {
B [ 0 ] = A [ 0 ] ;
B [ 1 ] = A [ 1 ] ;
}
if ( ! avail [ - 4 + 2 ] ) {
if ( avail [ - 4 ] && ( avail [ - 1 ] ) ) {
C [ 0 ] = s -> current_picture_ptr -> motion_val [ 0 ] [ mv_pos - s -> b8_stride - 1 ] [ 0 ] ;
C [ 1 ] = s -> current_picture_ptr -> motion_val [ 0 ] [ mv_pos - s -> b8_stride - 1 ] [ 1 ] ;
}
else {
C [ 0 ] = A [ 0 ] ;
C [ 1 ] = A [ 1 ] ;
}
}
else {
C [ 0 ] = s -> current_picture_ptr -> motion_val [ 0 ] [ mv_pos - s -> b8_stride + 2 ] [ 0 ] ;
C [ 1 ] = s -> current_picture_ptr -> motion_val [ 0 ] [ mv_pos - s -> b8_stride + 2 ] [ 1 ] ;
}
mx = mid_pred ( A [ 0 ] , B [ 0 ] , C [ 0 ] ) ;
my = mid_pred ( A [ 1 ] , B [ 1 ] , C [ 1 ] ) ;
mx += r -> dmv [ 0 ] [ 0 ] ;
my += r -> dmv [ 0 ] [ 1 ] ;
for ( j = 0 ;
j < 2 ;
j ++ ) {
for ( i = 0 ;
i < 2 ;
i ++ ) {
for ( k = 0 ;
k < 2 ;
k ++ ) {
s -> current_picture_ptr -> motion_val [ k ] [ mv_pos + i + j * s -> b8_stride ] [ 0 ] = mx ;
s -> current_picture_ptr -> motion_val [ k ] [ mv_pos + i + j * s -> b8_stride ] [ 1 ] = my ;
}
}
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void encode_wavelet_transform ( VC2EncContext * s ) {
encode_transform_params ( s ) ;
avpriv_align_put_bits ( & s -> pb ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
Jbig2PatternDict * jbig2_decode_ht_region_get_hpats ( Jbig2Ctx * ctx , Jbig2Segment * segment ) {
int index = 0 ;
Jbig2PatternDict * pattern_dict = NULL ;
Jbig2Segment * rsegment = NULL ;
while ( ! pattern_dict && segment -> referred_to_segment_count > index ) {
rsegment = jbig2_find_segment ( ctx , segment -> referred_to_segments [ index ] ) ;
if ( rsegment ) {
if ( ( rsegment -> flags & 0x3f ) == 16 && rsegment -> result ) {
pattern_dict = ( Jbig2PatternDict * ) rsegment -> result ;
return pattern_dict ;
}
}
index ++ ;
}
return pattern_dict ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void dissect_rsvp_unknown ( proto_tree * ti _U_ , proto_tree * rsvp_object_tree , tvbuff_t * tvb , int offset , int obj_length , int rsvp_class _U_ , int type ) {
proto_tree_add_uint ( rsvp_object_tree , hf_rsvp_ctype , tvb , offset + 3 , 1 , type ) ;
if ( obj_length > 4 ) {
proto_tree_add_item ( rsvp_object_tree , hf_rsvp_unknown_data , tvb , offset + 4 , obj_length - 4 , ENC_NA ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int opt_show_ ## section ( const char * opt , const char * arg ) {
mark_section_show_entries ( SECTION_ID_ ## target_section_id , 1 , NULL ) ;
return 0 ;
}
DEFINE_OPT_SHOW_SECTION ( chapters , CHAPTERS ) DEFINE_OPT_SHOW_SECTION ( error , ERROR ) DEFINE_OPT_SHOW_SECTION ( format , FORMAT )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void reorderLine ( UBiDi * pBiDi , UBiDiLevel minLevel , UBiDiLevel maxLevel ) {
Run * runs , tempRun ;
UBiDiLevel * levels ;
int32_t firstRun , endRun , limitRun , runCount ;
if ( maxLevel <= ( minLevel | 1 ) ) {
return ;
}
++ minLevel ;
runs = pBiDi -> runs ;
levels = pBiDi -> levels ;
runCount = pBiDi -> runCount ;
if ( pBiDi -> trailingWSStart < pBiDi -> length ) {
-- runCount ;
}
while ( -- maxLevel >= minLevel ) {
firstRun = 0 ;
for ( ;
;
) {
while ( firstRun < runCount && levels [ runs [ firstRun ] . logicalStart ] < maxLevel ) {
++ firstRun ;
}
if ( firstRun >= runCount ) {
break ;
}
for ( limitRun = firstRun ;
++ limitRun < runCount && levels [ runs [ limitRun ] . logicalStart ] >= maxLevel ;
) {
}
endRun = limitRun - 1 ;
while ( firstRun < endRun ) {
tempRun = runs [ firstRun ] ;
runs [ firstRun ] = runs [ endRun ] ;
runs [ endRun ] = tempRun ;
++ firstRun ;
-- endRun ;
}
if ( limitRun == runCount ) {
break ;
}
else {
firstRun = limitRun + 1 ;
}
}
}
if ( ! ( minLevel & 1 ) ) {
firstRun = 0 ;
if ( pBiDi -> trailingWSStart == pBiDi -> length ) {
-- runCount ;
}
while ( firstRun < runCount ) {
tempRun = runs [ firstRun ] ;
runs [ firstRun ] = runs [ runCount ] ;
runs [ runCount ] = tempRun ;
++ firstRun ;
-- runCount ;
}
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int mdb_search ( Operation * op , SlapReply * rs ) {
struct mdb_info * mdb = ( struct mdb_info * ) op -> o_bd -> be_private ;
ID id , cursor , nsubs , ncand , cscope ;
ID lastid = NOID ;
ID candidates [ MDB_IDL_UM_SIZE ] ;
ID iscopes [ MDB_IDL_DB_SIZE ] ;
ID2 * scopes ;
void * stack ;
Entry * e = NULL , * base = NULL ;
Entry * matched = NULL ;
AttributeName * attrs ;
slap_mask_t mask ;
time_t stoptime ;
int manageDSAit ;
int tentries = 0 ;
IdScopes isc ;
MDB_cursor * mci , * mcd ;
ww_ctx wwctx ;
slap_callback cb = {
0 }
;
mdb_op_info opinfo = {
{
{
0 }
}
}
, * moi = & opinfo ;
MDB_txn * ltid = NULL ;
Debug ( LDAP_DEBUG_TRACE , "=> " LDAP_XSTRING ( mdb_search ) "\n" , 0 , 0 , 0 ) ;
attrs = op -> oq_search . rs_attrs ;
manageDSAit = get_manageDSAit ( op ) ;
rs -> sr_err = mdb_opinfo_get ( op , mdb , 1 , & moi ) ;
switch ( rs -> sr_err ) {
case 0 : break ;
default : send_ldap_error ( op , rs , LDAP_OTHER , "internal error" ) ;
return rs -> sr_err ;
}
ltid = moi -> moi_txn ;
rs -> sr_err = mdb_cursor_open ( ltid , mdb -> mi_id2entry , & mci ) ;
if ( rs -> sr_err ) {
send_ldap_error ( op , rs , LDAP_OTHER , "internal error" ) ;
return rs -> sr_err ;
}
rs -> sr_err = mdb_cursor_open ( ltid , mdb -> mi_dn2id , & mcd ) ;
if ( rs -> sr_err ) {
mdb_cursor_close ( mci ) ;
send_ldap_error ( op , rs , LDAP_OTHER , "internal error" ) ;
return rs -> sr_err ;
}
scopes = scope_chunk_get ( op ) ;
stack = search_stack ( op ) ;
isc . mt = ltid ;
isc . mc = mcd ;
isc . scopes = scopes ;
isc . oscope = op -> ors_scope ;
isc . sctmp = stack ;
if ( op -> ors_deref & LDAP_DEREF_FINDING ) {
MDB_IDL_ZERO ( candidates ) ;
}
dn2entry_retry : rs -> sr_err = mdb_dn2entry ( op , ltid , mcd , & op -> o_req_ndn , & e , & nsubs , 1 ) ;
switch ( rs -> sr_err ) {
case MDB_NOTFOUND : matched = e ;
e = NULL ;
break ;
case 0 : break ;
case LDAP_BUSY : send_ldap_error ( op , rs , LDAP_BUSY , "ldap server busy" ) ;
goto done ;
default : send_ldap_error ( op , rs , LDAP_OTHER , "internal error" ) ;
goto done ;
}
if ( op -> ors_deref & LDAP_DEREF_FINDING ) {
if ( matched && is_entry_alias ( matched ) ) {
struct berval stub ;
stub . bv_val = op -> o_req_ndn . bv_val ;
stub . bv_len = op -> o_req_ndn . bv_len - matched -> e_nname . bv_len - 1 ;
e = deref_base ( op , rs , matched , & matched , ltid , candidates , NULL ) ;
if ( e ) {
build_new_dn ( & op -> o_req_ndn , & e -> e_nname , & stub , op -> o_tmpmemctx ) ;
mdb_entry_return ( op , e ) ;
matched = NULL ;
goto dn2entry_retry ;
}
}
else if ( e && is_entry_alias ( e ) ) {
e = deref_base ( op , rs , e , & matched , ltid , candidates , NULL ) ;
}
}
if ( e == NULL ) {
struct berval matched_dn = BER_BVNULL ;
if ( matched != NULL ) {
BerVarray erefs = NULL ;
if ( ! access_allowed ( op , matched , slap_schema . si_ad_entry , NULL , ACL_DISCLOSE , NULL ) ) {
rs -> sr_err = LDAP_NO_SUCH_OBJECT ;
}
else {
ber_dupbv ( & matched_dn , & matched -> e_name ) ;
erefs = is_entry_referral ( matched ) ? get_entry_referrals ( op , matched ) : NULL ;
if ( rs -> sr_err == MDB_NOTFOUND ) rs -> sr_err = LDAP_REFERRAL ;
rs -> sr_matched = matched_dn . bv_val ;
}
mdb_entry_return ( op , matched ) ;
matched = NULL ;
if ( erefs ) {
rs -> sr_ref = referral_rewrite ( erefs , & matched_dn , & op -> o_req_dn , op -> oq_search . rs_scope ) ;
ber_bvarray_free ( erefs ) ;
}
}
else {
rs -> sr_ref = referral_rewrite ( default_referral , NULL , & op -> o_req_dn , op -> oq_search . rs_scope ) ;
rs -> sr_err = rs -> sr_ref != NULL ? LDAP_REFERRAL : LDAP_NO_SUCH_OBJECT ;
}
send_ldap_result ( op , rs ) ;
if ( rs -> sr_ref ) {
ber_bvarray_free ( rs -> sr_ref ) ;
rs -> sr_ref = NULL ;
}
if ( ! BER_BVISNULL ( & matched_dn ) ) {
ber_memfree ( matched_dn . bv_val ) ;
rs -> sr_matched = NULL ;
}
goto done ;
}
if ( ! access_allowed_mask ( op , e , slap_schema . si_ad_entry , NULL , ACL_SEARCH , NULL , & mask ) ) {
if ( ! ACL_GRANT ( mask , ACL_DISCLOSE ) ) {
rs -> sr_err = LDAP_NO_SUCH_OBJECT ;
}
else {
rs -> sr_err = LDAP_INSUFFICIENT_ACCESS ;
}
mdb_entry_return ( op , e ) ;
send_ldap_result ( op , rs ) ;
goto done ;
}
if ( ! manageDSAit && is_entry_referral ( e ) ) {
struct berval matched_dn = BER_BVNULL ;
BerVarray erefs = NULL ;
ber_dupbv ( & matched_dn , & e -> e_name ) ;
erefs = get_entry_referrals ( op , e ) ;
rs -> sr_err = LDAP_REFERRAL ;
mdb_entry_return ( op , e ) ;
e = NULL ;
if ( erefs ) {
rs -> sr_ref = referral_rewrite ( erefs , & matched_dn , & op -> o_req_dn , op -> oq_search . rs_scope ) ;
ber_bvarray_free ( erefs ) ;
if ( ! rs -> sr_ref ) {
rs -> sr_text = "bad_referral object" ;
}
}
Debug ( LDAP_DEBUG_TRACE , LDAP_XSTRING ( mdb_search ) ": entry is referral\n" , 0 , 0 , 0 ) ;
rs -> sr_matched = matched_dn . bv_val ;
send_ldap_result ( op , rs ) ;
ber_bvarray_free ( rs -> sr_ref ) ;
rs -> sr_ref = NULL ;
ber_memfree ( matched_dn . bv_val ) ;
rs -> sr_matched = NULL ;
goto done ;
}
if ( get_assert ( op ) && ( test_filter ( op , e , get_assertion ( op ) ) != LDAP_COMPARE_TRUE ) ) {
rs -> sr_err = LDAP_ASSERTION_FAILED ;
mdb_entry_return ( op , e ) ;
send_ldap_result ( op , rs ) ;
goto done ;
}
stoptime = op -> o_time + op -> ors_tlimit ;
base = e ;
e = NULL ;
if ( op -> oq_search . rs_scope == LDAP_SCOPE_BASE ) {
rs -> sr_err = base_candidate ( op -> o_bd , base , candidates ) ;
scopes [ 0 ] . mid = 0 ;
ncand = 1 ;
}
else {
if ( op -> ors_scope == LDAP_SCOPE_ONELEVEL ) {
size_t nkids ;
MDB_val key , data ;
key . mv_data = & base -> e_id ;
key . mv_size = sizeof ( ID ) ;
mdb_cursor_get ( mcd , & key , & data , MDB_SET ) ;
mdb_cursor_count ( mcd , & nkids ) ;
nsubs = nkids - 1 ;
}
else if ( ! base -> e_id ) {
MDB_stat ms ;
mdb_stat ( ltid , mdb -> mi_id2entry , & ms ) ;
nsubs = ms . ms_entries ;
}
MDB_IDL_ZERO ( candidates ) ;
scopes [ 0 ] . mid = 1 ;
scopes [ 1 ] . mid = base -> e_id ;
scopes [ 1 ] . mval . mv_data = NULL ;
rs -> sr_err = search_candidates ( op , rs , base , & isc , mci , candidates , stack ) ;
ncand = MDB_IDL_N ( candidates ) ;
if ( ! base -> e_id || ncand == NOID ) {
MDB_stat ms ;
mdb_stat ( ltid , mdb -> mi_id2entry , & ms ) ;
if ( ! base -> e_id ) nsubs = ms . ms_entries ;
if ( ncand == NOID ) ncand = ms . ms_entries ;
}
}
cursor = 0 ;
if ( candidates [ 0 ] == 0 ) {
Debug ( LDAP_DEBUG_TRACE , LDAP_XSTRING ( mdb_search ) ": no candidates\n" , 0 , 0 , 0 ) ;
goto nochange ;
}
if ( op -> ors_limit && op -> ors_limit -> lms_s_unchecked != - 1 && ncand > ( unsigned ) op -> ors_limit -> lms_s_unchecked ) {
rs -> sr_err = LDAP_ADMINLIMIT_EXCEEDED ;
send_ldap_result ( op , rs ) ;
rs -> sr_err = LDAP_SUCCESS ;
goto done ;
}
if ( op -> ors_limit == NULL || ! op -> ors_limit -> lms_s_pr_hide ) {
tentries = ncand ;
}
wwctx . flag = 0 ;
if ( moi == & opinfo ) {
cb . sc_writewait = mdb_writewait ;
cb . sc_private = & wwctx ;
wwctx . txn = ltid ;
wwctx . mcd = NULL ;
cb . sc_next = op -> o_callback ;
op -> o_callback = & cb ;
}
if ( get_pagedresults ( op ) > SLAP_CONTROL_IGNORED ) {
PagedResultsState * ps = op -> o_pagedresults_state ;
rs -> sr_err = parse_paged_cookie ( op , rs ) ;
if ( rs -> sr_err != LDAP_SUCCESS ) {
send_ldap_result ( op , rs ) ;
goto done ;
}
cursor = ( ID ) ps -> ps_cookie ;
if ( cursor && ps -> ps_size == 0 ) {
rs -> sr_err = LDAP_SUCCESS ;
rs -> sr_text = "search abandoned by pagedResult size=0" ;
send_ldap_result ( op , rs ) ;
goto done ;
}
id = mdb_idl_first ( candidates , & cursor ) ;
if ( id == NOID ) {
Debug ( LDAP_DEBUG_TRACE , LDAP_XSTRING ( mdb_search ) ": no paged results candidates\n" , 0 , 0 , 0 ) ;
send_paged_response ( op , rs , & lastid , 0 ) ;
rs -> sr_err = LDAP_OTHER ;
goto done ;
}
if ( id == ( ID ) ps -> ps_cookie ) id = mdb_idl_next ( candidates , & cursor ) ;
nsubs = ncand ;
goto loop_begin ;
}
if ( nsubs < ncand ) {
int rc ;
if ( scopes [ 0 ] . mid > 1 ) {
cursor = 1 ;
for ( cscope = 1 ;
cscope <= scopes [ 0 ] . mid ;
cscope ++ ) {
if ( scopes [ cscope ] . mid == base -> e_id ) continue ;
iscopes [ cursor ++ ] = scopes [ cscope ] . mid ;
}
iscopes [ 0 ] = scopes [ 0 ] . mid - 1 ;
}
else {
iscopes [ 0 ] = 0 ;
}
wwctx . mcd = mcd ;
isc . id = base -> e_id ;
isc . numrdns = 0 ;
rc = mdb_dn2id_walk ( op , & isc ) ;
if ( rc ) id = NOID ;
else id = isc . id ;
cscope = 0 ;
}
else {
id = mdb_idl_first ( candidates , & cursor ) ;
}
while ( id != NOID ) {
int scopeok ;
MDB_val edata ;
loop_begin : if ( op -> o_abandon ) {
rs -> sr_err = SLAPD_ABANDON ;
send_ldap_result ( op , rs ) ;
goto done ;
}
if ( slapd_shutdown ) {
rs -> sr_err = LDAP_UNAVAILABLE ;
send_ldap_disconnect ( op , rs ) ;
goto done ;
}
if ( op -> ors_tlimit != SLAP_NO_LIMIT && slap_get_time ( ) > stoptime ) {
rs -> sr_err = LDAP_TIMELIMIT_EXCEEDED ;
rs -> sr_ref = rs -> sr_v2ref ;
send_ldap_result ( op , rs ) ;
rs -> sr_err = LDAP_SUCCESS ;
goto done ;
}
if ( nsubs < ncand ) {
unsigned i ;
scopeok = 0 ;
if ( MDB_IDL_IS_RANGE ( candidates ) ) {
if ( id >= MDB_IDL_RANGE_FIRST ( candidates ) && id <= MDB_IDL_RANGE_LAST ( candidates ) ) scopeok = 1 ;
}
else {
i = mdb_idl_search ( candidates , id ) ;
if ( i <= candidates [ 0 ] && candidates [ i ] == id ) scopeok = 1 ;
}
if ( scopeok ) goto scopeok ;
goto loop_continue ;
}
scopeok = 0 ;
isc . numrdns = 0 ;
switch ( op -> ors_scope ) {
case LDAP_SCOPE_BASE : if ( id == base -> e_id ) scopeok = 1 ;
break ;
# ifdef LDAP_SCOPE_CHILDREN case LDAP_SCOPE_CHILDREN : if ( id == base -> e_id ) break ;
# endif case LDAP_SCOPE_SUBTREE : if ( id == base -> e_id ) {
scopeok = 1 ;
break ;
}
case LDAP_SCOPE_ONELEVEL : if ( id == base -> e_id ) break ;
isc . id = id ;
isc . nscope = 0 ;
rs -> sr_err = mdb_idscopes ( op , & isc ) ;
if ( rs -> sr_err == MDB_SUCCESS ) {
if ( isc . nscope ) scopeok = 1 ;
}
else {
if ( rs -> sr_err == MDB_NOTFOUND ) goto notfound ;
}
break ;
}
if ( ! scopeok ) {
Debug ( LDAP_DEBUG_TRACE , LDAP_XSTRING ( mdb_search ) ": %ld scope not okay\n" , ( long ) id , 0 , 0 ) ;
goto loop_continue ;
}
scopeok : if ( id == base -> e_id ) {
e = base ;
}
else {
rs -> sr_err = mdb_id2edata ( op , mci , id , & edata ) ;
if ( rs -> sr_err == MDB_NOTFOUND ) {
notfound : if ( nsubs < ncand ) goto loop_continue ;
if ( ! MDB_IDL_IS_RANGE ( candidates ) ) {
Debug ( LDAP_DEBUG_TRACE , LDAP_XSTRING ( mdb_search ) ": candidate %ld not found\n" , ( long ) id , 0 , 0 ) ;
}
else {
rs -> sr_err = mdb_get_nextid ( mci , & cursor ) ;
if ( rs -> sr_err == MDB_NOTFOUND ) {
break ;
}
if ( rs -> sr_err ) {
rs -> sr_err = LDAP_OTHER ;
rs -> sr_text = "internal error in get_nextid" ;
send_ldap_result ( op , rs ) ;
goto done ;
}
cursor -- ;
}
goto loop_continue ;
}
else if ( rs -> sr_err ) {
rs -> sr_err = LDAP_OTHER ;
rs -> sr_text = "internal error in mdb_id2edata" ;
send_ldap_result ( op , rs ) ;
goto done ;
}
rs -> sr_err = mdb_entry_decode ( op , ltid , & edata , id , & e ) ;
if ( rs -> sr_err ) {
rs -> sr_err = LDAP_OTHER ;
rs -> sr_text = "internal error in mdb_entry_decode" ;
send_ldap_result ( op , rs ) ;
goto done ;
}
e -> e_id = id ;
e -> e_name . bv_val = NULL ;
e -> e_nname . bv_val = NULL ;
}
if ( is_entry_subentry ( e ) ) {
if ( op -> oq_search . rs_scope != LDAP_SCOPE_BASE ) {
if ( ! get_subentries_visibility ( op ) ) {
goto loop_continue ;
}
}
else if ( get_subentries ( op ) && ! get_subentries_visibility ( op ) ) {
goto loop_continue ;
}
}
else if ( get_subentries_visibility ( op ) ) {
goto loop_continue ;
}
if ( op -> ors_deref & LDAP_DEREF_SEARCHING ) {
if ( is_entry_alias ( e ) && ( ( op -> ors_deref & LDAP_DEREF_FINDING ) || e != base ) ) {
goto loop_continue ;
}
}
if ( ! manageDSAit && is_entry_glue ( e ) ) {
goto loop_continue ;
}
if ( e != base ) {
struct berval pdn , pndn ;
char * d , * n ;
int i ;
if ( nsubs < ncand || isc . scopes [ isc . nscope ] . mid == base -> e_id ) {
pdn = base -> e_name ;
pndn = base -> e_nname ;
}
else {
mdb_id2name ( op , ltid , & isc . mc , scopes [ isc . nscope ] . mid , & pdn , & pndn ) ;
}
e -> e_name . bv_len = pdn . bv_len ;
e -> e_nname . bv_len = pndn . bv_len ;
for ( i = 0 ;
i < isc . numrdns ;
i ++ ) {
e -> e_name . bv_len += isc . rdns [ i ] . bv_len + 1 ;
e -> e_nname . bv_len += isc . nrdns [ i ] . bv_len + 1 ;
}
e -> e_name . bv_val = op -> o_tmpalloc ( e -> e_name . bv_len + 1 , op -> o_tmpmemctx ) ;
e -> e_nname . bv_val = op -> o_tmpalloc ( e -> e_nname . bv_len + 1 , op -> o_tmpmemctx ) ;
d = e -> e_name . bv_val ;
n = e -> e_nname . bv_val ;
if ( nsubs < ncand ) {
for ( i = isc . numrdns - 1 ;
i >= 0 ;
i -- ) {
memcpy ( d , isc . rdns [ i ] . bv_val , isc . rdns [ i ] . bv_len ) ;
d += isc . rdns [ i ] . bv_len ;
* d ++ = ',' ;
memcpy ( n , isc . nrdns [ i ] . bv_val , isc . nrdns [ i ] . bv_len ) ;
n += isc . nrdns [ i ] . bv_len ;
* n ++ = ',' ;
}
}
else {
for ( i = 0 ;
i < isc . numrdns ;
i ++ ) {
memcpy ( d , isc . rdns [ i ] . bv_val , isc . rdns [ i ] . bv_len ) ;
d += isc . rdns [ i ] . bv_len ;
* d ++ = ',' ;
memcpy ( n , isc . nrdns [ i ] . bv_val , isc . nrdns [ i ] . bv_len ) ;
n += isc . nrdns [ i ] . bv_len ;
* n ++ = ',' ;
}
}
if ( pdn . bv_len ) {
memcpy ( d , pdn . bv_val , pdn . bv_len + 1 ) ;
memcpy ( n , pndn . bv_val , pndn . bv_len + 1 ) ;
}
else {
* -- d = '\0' ;
* -- n = '\0' ;
e -> e_name . bv_len -- ;
e -> e_nname . bv_len -- ;
}
if ( pndn . bv_val != base -> e_nname . bv_val ) {
op -> o_tmpfree ( pndn . bv_val , op -> o_tmpmemctx ) ;
op -> o_tmpfree ( pdn . bv_val , op -> o_tmpmemctx ) ;
}
}
if ( ! manageDSAit && op -> oq_search . rs_scope != LDAP_SCOPE_BASE && is_entry_referral ( e ) ) {
BerVarray erefs = get_entry_referrals ( op , e ) ;
rs -> sr_ref = referral_rewrite ( erefs , & e -> e_name , NULL , op -> oq_search . rs_scope == LDAP_SCOPE_ONELEVEL ? LDAP_SCOPE_BASE : LDAP_SCOPE_SUBTREE ) ;
rs -> sr_entry = e ;
rs -> sr_flags = 0 ;
send_search_reference ( op , rs ) ;
if ( e != base ) mdb_entry_return ( op , e ) ;
rs -> sr_entry = NULL ;
e = NULL ;
ber_bvarray_free ( rs -> sr_ref ) ;
ber_bvarray_free ( erefs ) ;
rs -> sr_ref = NULL ;
goto loop_continue ;
}
rs -> sr_err = test_filter ( op , e , op -> oq_search . rs_filter ) ;
if ( rs -> sr_err == LDAP_COMPARE_TRUE ) {
if ( get_pagedresults ( op ) > SLAP_CONTROL_IGNORED ) {
if ( rs -> sr_nentries >= ( ( PagedResultsState * ) op -> o_pagedresults_state ) -> ps_size ) {
if ( e != base ) mdb_entry_return ( op , e ) ;
e = NULL ;
send_paged_response ( op , rs , & lastid , tentries ) ;
goto done ;
}
lastid = id ;
}
if ( e ) {
rs -> sr_attrs = op -> oq_search . rs_attrs ;
rs -> sr_operational_attrs = NULL ;
rs -> sr_ctrls = NULL ;
rs -> sr_entry = e ;
RS_ASSERT ( e -> e_private != NULL ) ;
rs -> sr_flags = 0 ;
rs -> sr_err = LDAP_SUCCESS ;
rs -> sr_err = send_search_entry ( op , rs ) ;
rs -> sr_attrs = NULL ;
rs -> sr_entry = NULL ;
if ( e != base ) mdb_entry_return ( op , e ) ;
e = NULL ;
switch ( rs -> sr_err ) {
case LDAP_SUCCESS : break ;
default : break ;
case LDAP_BUSY : send_ldap_result ( op , rs ) ;
goto done ;
case LDAP_UNAVAILABLE : case LDAP_SIZELIMIT_EXCEEDED : if ( rs -> sr_err == LDAP_SIZELIMIT_EXCEEDED ) {
rs -> sr_ref = rs -> sr_v2ref ;
send_ldap_result ( op , rs ) ;
rs -> sr_err = LDAP_SUCCESS ;
}
else {
rs -> sr_err = LDAP_OTHER ;
}
goto done ;
}
}
}
else {
Debug ( LDAP_DEBUG_TRACE , LDAP_XSTRING ( mdb_search ) ": %ld does not match filter\n" , ( long ) id , 0 , 0 ) ;
}
loop_continue : if ( moi == & opinfo && ! wwctx . flag && mdb -> mi_rtxn_size ) {
wwctx . nentries ++ ;
if ( wwctx . nentries >= mdb -> mi_rtxn_size ) {
wwctx . nentries = 0 ;
mdb_rtxn_snap ( op , & wwctx ) ;
}
}
if ( wwctx . flag ) {
rs -> sr_err = mdb_waitfixup ( op , & wwctx , mci , mcd , & isc ) ;
if ( rs -> sr_err ) {
send_ldap_result ( op , rs ) ;
goto done ;
}
}
if ( e != NULL ) {
if ( e != base ) mdb_entry_return ( op , e ) ;
RS_ASSERT ( rs -> sr_entry == NULL ) ;
e = NULL ;
rs -> sr_entry = NULL ;
}
if ( nsubs < ncand ) {
int rc = mdb_dn2id_walk ( op , & isc ) ;
if ( rc ) {
id = NOID ;
while ( iscopes [ 0 ] && cscope < iscopes [ 0 ] ) {
cscope ++ ;
isc . id = iscopes [ cscope ] ;
if ( base ) mdb_entry_return ( op , base ) ;
rs -> sr_err = mdb_id2entry ( op , mci , isc . id , & base ) ;
if ( ! rs -> sr_err ) {
mdb_id2name ( op , ltid , & isc . mc , isc . id , & base -> e_name , & base -> e_nname ) ;
isc . numrdns = 0 ;
if ( isc . oscope == LDAP_SCOPE_ONELEVEL ) isc . oscope = LDAP_SCOPE_BASE ;
rc = mdb_dn2id_walk ( op , & isc ) ;
if ( ! rc ) {
id = isc . id ;
break ;
}
}
}
}
else id = isc . id ;
}
else {
id = mdb_idl_next ( candidates , & cursor ) ;
}
}
nochange : rs -> sr_ctrls = NULL ;
rs -> sr_ref = rs -> sr_v2ref ;
rs -> sr_err = ( rs -> sr_v2ref == NULL ) ? LDAP_SUCCESS : LDAP_REFERRAL ;
rs -> sr_rspoid = NULL ;
if ( get_pagedresults ( op ) > SLAP_CONTROL_IGNORED ) {
send_paged_response ( op , rs , NULL , 0 ) ;
}
else {
send_ldap_result ( op , rs ) ;
}
rs -> sr_err = LDAP_SUCCESS ;
done : if ( cb . sc_private ) {
slap_callback * * scp = & op -> o_callback ;
while ( * scp ) {
if ( * scp == & cb ) {
* scp = cb . sc_next ;
cb . sc_private = NULL ;
break ;
}
}
}
mdb_cursor_close ( mcd ) ;
mdb_cursor_close ( mci ) ;
if ( moi == & opinfo ) {
mdb_txn_reset ( moi -> moi_txn ) ;
LDAP_SLIST_REMOVE ( & op -> o_extra , & moi -> moi_oe , OpExtra , oe_next ) ;
}
else {
moi -> moi_ref -- ;
}
if ( rs -> sr_v2ref ) {
ber_bvarray_free ( rs -> sr_v2ref ) ;
rs -> sr_v2ref = NULL ;
}
if ( base ) mdb_entry_return ( op , base ) ;
scope_chunk_ret ( op , scopes ) ;
return rs -> sr_err ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int fill_schema_user_privileges ( THD * thd , TABLE_LIST * tables , COND * cond ) {
# ifndef NO_EMBEDDED_ACCESS_CHECKS int error = 0 ;
uint counter ;
ACL_USER * acl_user ;
ulong want_access ;
char buff [ 100 ] ;
TABLE * table = tables -> table ;
bool no_global_access = check_access ( thd , SELECT_ACL , "mysql" , 0 , 1 , 1 , 0 ) ;
char * curr_host = thd -> security_ctx -> priv_host_name ( ) ;
DBUG_ENTER ( "fill_schema_user_privileges" ) ;
if ( ! initialized ) DBUG_RETURN ( 0 ) ;
pthread_mutex_lock ( & acl_cache -> lock ) ;
for ( counter = 0 ;
counter < acl_users . elements ;
counter ++ ) {
const char * user , * host , * is_grantable = "YES" ;
acl_user = dynamic_element ( & acl_users , counter , ACL_USER * ) ;
if ( ! ( user = acl_user -> user ) ) user = "" ;
if ( ! ( host = acl_user -> host . hostname ) ) host = "" ;
if ( no_global_access && ( strcmp ( thd -> security_ctx -> priv_user , user ) || my_strcasecmp ( system_charset_info , curr_host , host ) ) ) continue ;
want_access = acl_user -> access ;
if ( ! ( want_access & GRANT_ACL ) ) is_grantable = "NO" ;
strxmov ( buff , "'" , user , "'@'" , host , "'" , NullS ) ;
if ( ! ( want_access & ~ GRANT_ACL ) ) {
if ( update_schema_privilege ( thd , table , buff , 0 , 0 , 0 , 0 , STRING_WITH_LEN ( "USAGE" ) , is_grantable ) ) {
error = 1 ;
goto err ;
}
}
else {
uint priv_id ;
ulong j , test_access = want_access & ~ GRANT_ACL ;
for ( priv_id = 0 , j = SELECT_ACL ;
j <= GLOBAL_ACLS ;
priv_id ++ , j <<= 1 ) {
if ( test_access & j ) {
if ( update_schema_privilege ( thd , table , buff , 0 , 0 , 0 , 0 , command_array [ priv_id ] , command_lengths [ priv_id ] , is_grantable ) ) {
error = 1 ;
goto err ;
}
}
}
}
}
err : pthread_mutex_unlock ( & acl_cache -> lock ) ;
DBUG_RETURN ( error ) ;
# else return ( 0 ) ;
# endif }
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void rd_use_partition ( VP9_COMP * cpi , const TileInfo * const tile , MODE_INFO * * mi_8x8 , TOKENEXTRA * * tp , int mi_row , int mi_col , BLOCK_SIZE bsize , int * rate , int64_t * dist , int do_recon , PC_TREE * pc_tree ) {
VP9_COMMON * const cm = & cpi -> common ;
MACROBLOCK * const x = & cpi -> mb ;
MACROBLOCKD * const xd = & x -> e_mbd ;
const int mis = cm -> mi_stride ;
const int bsl = b_width_log2 ( bsize ) ;
const int mi_step = num_4x4_blocks_wide_lookup [ bsize ] / 2 ;
const int bss = ( 1 << bsl ) / 4 ;
int i , pl ;
PARTITION_TYPE partition = PARTITION_NONE ;
BLOCK_SIZE subsize ;
ENTROPY_CONTEXT l [ 16 * MAX_MB_PLANE ] , a [ 16 * MAX_MB_PLANE ] ;
PARTITION_CONTEXT sl [ 8 ] , sa [ 8 ] ;
int last_part_rate = INT_MAX ;
int64_t last_part_dist = INT64_MAX ;
int64_t last_part_rd = INT64_MAX ;
int none_rate = INT_MAX ;
int64_t none_dist = INT64_MAX ;
int64_t none_rd = INT64_MAX ;
int chosen_rate = INT_MAX ;
int64_t chosen_dist = INT64_MAX ;
int64_t chosen_rd = INT64_MAX ;
BLOCK_SIZE sub_subsize = BLOCK_4X4 ;
int splits_below = 0 ;
BLOCK_SIZE bs_type = mi_8x8 [ 0 ] -> mbmi . sb_type ;
int do_partition_search = 1 ;
PICK_MODE_CONTEXT * ctx = & pc_tree -> none ;
if ( mi_row >= cm -> mi_rows || mi_col >= cm -> mi_cols ) return ;
assert ( num_4x4_blocks_wide_lookup [ bsize ] == num_4x4_blocks_high_lookup [ bsize ] ) ;
partition = partition_lookup [ bsl ] [ bs_type ] ;
subsize = get_subsize ( bsize , partition ) ;
pc_tree -> partitioning = partition ;
save_context ( cpi , mi_row , mi_col , a , l , sa , sl , bsize ) ;
if ( bsize == BLOCK_16X16 && cpi -> oxcf . aq_mode ) {
set_offsets ( cpi , tile , mi_row , mi_col , bsize ) ;
x -> mb_energy = vp9_block_energy ( cpi , x , bsize ) ;
}
if ( do_partition_search && cpi -> sf . partition_search_type == SEARCH_PARTITION && cpi -> sf . adjust_partitioning_from_last_frame ) {
if ( partition == PARTITION_SPLIT && subsize > BLOCK_8X8 ) {
sub_subsize = get_subsize ( subsize , PARTITION_SPLIT ) ;
splits_below = 1 ;
for ( i = 0 ;
i < 4 ;
i ++ ) {
int jj = i >> 1 , ii = i & 0x01 ;
MODE_INFO * this_mi = mi_8x8 [ jj * bss * mis + ii * bss ] ;
if ( this_mi && this_mi -> mbmi . sb_type >= sub_subsize ) {
splits_below = 0 ;
}
}
}
if ( partition != PARTITION_NONE && ! splits_below && mi_row + ( mi_step >> 1 ) < cm -> mi_rows && mi_col + ( mi_step >> 1 ) < cm -> mi_cols ) {
pc_tree -> partitioning = PARTITION_NONE ;
rd_pick_sb_modes ( cpi , tile , mi_row , mi_col , & none_rate , & none_dist , bsize , ctx , INT64_MAX , 0 ) ;
pl = partition_plane_context ( xd , mi_row , mi_col , bsize ) ;
if ( none_rate < INT_MAX ) {
none_rate += cpi -> partition_cost [ pl ] [ PARTITION_NONE ] ;
none_rd = RDCOST ( x -> rdmult , x -> rddiv , none_rate , none_dist ) ;
}
restore_context ( cpi , mi_row , mi_col , a , l , sa , sl , bsize ) ;
mi_8x8 [ 0 ] -> mbmi . sb_type = bs_type ;
pc_tree -> partitioning = partition ;
}
}
switch ( partition ) {
case PARTITION_NONE : rd_pick_sb_modes ( cpi , tile , mi_row , mi_col , & last_part_rate , & last_part_dist , bsize , ctx , INT64_MAX , 0 ) ;
break ;
case PARTITION_HORZ : rd_pick_sb_modes ( cpi , tile , mi_row , mi_col , & last_part_rate , & last_part_dist , subsize , & pc_tree -> horizontal [ 0 ] , INT64_MAX , 0 ) ;
if ( last_part_rate != INT_MAX && bsize >= BLOCK_8X8 && mi_row + ( mi_step >> 1 ) < cm -> mi_rows ) {
int rt = 0 ;
int64_t dt = 0 ;
PICK_MODE_CONTEXT * ctx = & pc_tree -> horizontal [ 0 ] ;
update_state ( cpi , ctx , mi_row , mi_col , subsize , 0 ) ;
encode_superblock ( cpi , tp , 0 , mi_row , mi_col , subsize , ctx ) ;
rd_pick_sb_modes ( cpi , tile , mi_row + ( mi_step >> 1 ) , mi_col , & rt , & dt , subsize , & pc_tree -> horizontal [ 1 ] , INT64_MAX , 1 ) ;
if ( rt == INT_MAX || dt == INT64_MAX ) {
last_part_rate = INT_MAX ;
last_part_dist = INT64_MAX ;
break ;
}
last_part_rate += rt ;
last_part_dist += dt ;
}
break ;
case PARTITION_VERT : rd_pick_sb_modes ( cpi , tile , mi_row , mi_col , & last_part_rate , & last_part_dist , subsize , & pc_tree -> vertical [ 0 ] , INT64_MAX , 0 ) ;
if ( last_part_rate != INT_MAX && bsize >= BLOCK_8X8 && mi_col + ( mi_step >> 1 ) < cm -> mi_cols ) {
int rt = 0 ;
int64_t dt = 0 ;
PICK_MODE_CONTEXT * ctx = & pc_tree -> vertical [ 0 ] ;
update_state ( cpi , ctx , mi_row , mi_col , subsize , 0 ) ;
encode_superblock ( cpi , tp , 0 , mi_row , mi_col , subsize , ctx ) ;
rd_pick_sb_modes ( cpi , tile , mi_row , mi_col + ( mi_step >> 1 ) , & rt , & dt , subsize , & pc_tree -> vertical [ bsize > BLOCK_8X8 ] , INT64_MAX , 1 ) ;
if ( rt == INT_MAX || dt == INT64_MAX ) {
last_part_rate = INT_MAX ;
last_part_dist = INT64_MAX ;
break ;
}
last_part_rate += rt ;
last_part_dist += dt ;
}
break ;
case PARTITION_SPLIT : if ( bsize == BLOCK_8X8 ) {
rd_pick_sb_modes ( cpi , tile , mi_row , mi_col , & last_part_rate , & last_part_dist , subsize , pc_tree -> leaf_split [ 0 ] , INT64_MAX , 0 ) ;
break ;
}
last_part_rate = 0 ;
last_part_dist = 0 ;
for ( i = 0 ;
i < 4 ;
i ++ ) {
int x_idx = ( i & 1 ) * ( mi_step >> 1 ) ;
int y_idx = ( i >> 1 ) * ( mi_step >> 1 ) ;
int jj = i >> 1 , ii = i & 0x01 ;
int rt ;
int64_t dt ;
if ( ( mi_row + y_idx >= cm -> mi_rows ) || ( mi_col + x_idx >= cm -> mi_cols ) ) continue ;
rd_use_partition ( cpi , tile , mi_8x8 + jj * bss * mis + ii * bss , tp , mi_row + y_idx , mi_col + x_idx , subsize , & rt , & dt , i != 3 , pc_tree -> split [ i ] ) ;
if ( rt == INT_MAX || dt == INT64_MAX ) {
last_part_rate = INT_MAX ;
last_part_dist = INT64_MAX ;
break ;
}
last_part_rate += rt ;
last_part_dist += dt ;
}
break ;
default : assert ( 0 ) ;
break ;
}
pl = partition_plane_context ( xd , mi_row , mi_col , bsize ) ;
if ( last_part_rate < INT_MAX ) {
last_part_rate += cpi -> partition_cost [ pl ] [ partition ] ;
last_part_rd = RDCOST ( x -> rdmult , x -> rddiv , last_part_rate , last_part_dist ) ;
}
if ( do_partition_search && cpi -> sf . adjust_partitioning_from_last_frame && cpi -> sf . partition_search_type == SEARCH_PARTITION && partition != PARTITION_SPLIT && bsize > BLOCK_8X8 && ( mi_row + mi_step < cm -> mi_rows || mi_row + ( mi_step >> 1 ) == cm -> mi_rows ) && ( mi_col + mi_step < cm -> mi_cols || mi_col + ( mi_step >> 1 ) == cm -> mi_cols ) ) {
BLOCK_SIZE split_subsize = get_subsize ( bsize , PARTITION_SPLIT ) ;
chosen_rate = 0 ;
chosen_dist = 0 ;
restore_context ( cpi , mi_row , mi_col , a , l , sa , sl , bsize ) ;
pc_tree -> partitioning = PARTITION_SPLIT ;
for ( i = 0 ;
i < 4 ;
i ++ ) {
int x_idx = ( i & 1 ) * ( mi_step >> 1 ) ;
int y_idx = ( i >> 1 ) * ( mi_step >> 1 ) ;
int rt = 0 ;
int64_t dt = 0 ;
ENTROPY_CONTEXT l [ 16 * MAX_MB_PLANE ] , a [ 16 * MAX_MB_PLANE ] ;
PARTITION_CONTEXT sl [ 8 ] , sa [ 8 ] ;
if ( ( mi_row + y_idx >= cm -> mi_rows ) || ( mi_col + x_idx >= cm -> mi_cols ) ) continue ;
save_context ( cpi , mi_row , mi_col , a , l , sa , sl , bsize ) ;
pc_tree -> split [ i ] -> partitioning = PARTITION_NONE ;
rd_pick_sb_modes ( cpi , tile , mi_row + y_idx , mi_col + x_idx , & rt , & dt , split_subsize , & pc_tree -> split [ i ] -> none , INT64_MAX , i ) ;
restore_context ( cpi , mi_row , mi_col , a , l , sa , sl , bsize ) ;
if ( rt == INT_MAX || dt == INT64_MAX ) {
chosen_rate = INT_MAX ;
chosen_dist = INT64_MAX ;
break ;
}
chosen_rate += rt ;
chosen_dist += dt ;
if ( i != 3 ) encode_sb ( cpi , tile , tp , mi_row + y_idx , mi_col + x_idx , 0 , split_subsize , pc_tree -> split [ i ] ) ;
pl = partition_plane_context ( xd , mi_row + y_idx , mi_col + x_idx , split_subsize ) ;
chosen_rate += cpi -> partition_cost [ pl ] [ PARTITION_NONE ] ;
}
pl = partition_plane_context ( xd , mi_row , mi_col , bsize ) ;
if ( chosen_rate < INT_MAX ) {
chosen_rate += cpi -> partition_cost [ pl ] [ PARTITION_SPLIT ] ;
chosen_rd = RDCOST ( x -> rdmult , x -> rddiv , chosen_rate , chosen_dist ) ;
}
}
if ( last_part_rd < chosen_rd ) {
mi_8x8 [ 0 ] -> mbmi . sb_type = bsize ;
if ( bsize >= BLOCK_8X8 ) pc_tree -> partitioning = partition ;
chosen_rate = last_part_rate ;
chosen_dist = last_part_dist ;
chosen_rd = last_part_rd ;
}
if ( none_rd < chosen_rd ) {
if ( bsize >= BLOCK_8X8 ) pc_tree -> partitioning = PARTITION_NONE ;
chosen_rate = none_rate ;
chosen_dist = none_dist ;
}
restore_context ( cpi , mi_row , mi_col , a , l , sa , sl , bsize ) ;
if ( bsize == BLOCK_64X64 ) assert ( chosen_rate < INT_MAX && chosen_dist < INT64_MAX ) ;
if ( do_recon ) {
int output_enabled = ( bsize == BLOCK_64X64 ) ;
if ( ( cpi -> oxcf . aq_mode == COMPLEXITY_AQ ) && cm -> seg . update_map ) {
vp9_select_in_frame_q_segment ( cpi , mi_row , mi_col , output_enabled , chosen_rate ) ;
}
if ( cpi -> oxcf . aq_mode == CYCLIC_REFRESH_AQ ) vp9_cyclic_refresh_set_rate_and_dist_sb ( cpi -> cyclic_refresh , chosen_rate , chosen_dist ) ;
encode_sb ( cpi , tile , tp , mi_row , mi_col , output_enabled , bsize , pc_tree ) ;
}
* rate = chosen_rate ;
* dist = chosen_dist ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static RelOptInfo * find_join_input_rel ( PlannerInfo * root , Relids relids ) {
RelOptInfo * rel = NULL ;
switch ( bms_membership ( relids ) ) {
case BMS_EMPTY_SET : break ;
case BMS_SINGLETON : rel = find_base_rel ( root , bms_singleton_member ( relids ) ) ;
break ;
case BMS_MULTIPLE : rel = find_join_rel ( root , relids ) ;
break ;
}
if ( rel == NULL ) elog ( ERROR , "could not find RelOptInfo for given relids" ) ;
return rel ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void vga_draw_line16_be ( VGACommonState * vga , uint8_t * d , uint32_t addr , int width ) {
int w ;
uint32_t v , r , g , b ;
w = width ;
do {
v = vga_read_word_be ( vga , addr ) ;
r = ( v >> 8 ) & 0xf8 ;
g = ( v >> 3 ) & 0xfc ;
b = ( v << 3 ) & 0xf8 ;
( ( uint32_t * ) d ) [ 0 ] = rgb_to_pixel32 ( r , g , b ) ;
addr += 2 ;
d += 4 ;
}
while ( -- w != 0 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
BerElement * ber_dup ( BerElement * ber ) {
BerElement * new ;
assert ( ber != NULL ) ;
assert ( LBER_VALID ( ber ) ) ;
if ( ( new = ber_alloc_t ( ber -> ber_options ) ) == NULL ) {
return NULL ;
}
* new = * ber ;
assert ( LBER_VALID ( new ) ) ;
return ( new ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static bool _try_writable_inplace ( hb_blob_t * blob ) {
DEBUG_MSG_FUNC ( BLOB , blob , "making writable inplace\n" ) ;
if ( _try_make_writable_inplace_unix ( blob ) ) return true ;
DEBUG_MSG_FUNC ( BLOB , blob , "making writable -> FAILED\n" ) ;
blob -> mode = HB_MEMORY_MODE_READONLY ;
return false ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int write_superframe_index ( vpx_codec_alg_priv_t * ctx ) {
uint8_t marker = 0xc0 ;
unsigned int mask ;
int mag , index_sz ;
assert ( ctx -> pending_frame_count ) ;
assert ( ctx -> pending_frame_count <= 8 ) ;
marker |= ctx -> pending_frame_count - 1 ;
for ( mag = 0 , mask = 0xff ;
mag < 4 ;
mag ++ ) {
if ( ctx -> pending_frame_magnitude < mask ) break ;
mask <<= 8 ;
mask |= 0xff ;
}
marker |= mag << 3 ;
index_sz = 2 + ( mag + 1 ) * ctx -> pending_frame_count ;
if ( ctx -> pending_cx_data_sz + index_sz < ctx -> cx_data_sz ) {
uint8_t * x = ctx -> pending_cx_data + ctx -> pending_cx_data_sz ;
int i , j ;
# ifdef TEST_SUPPLEMENTAL_SUPERFRAME_DATA uint8_t marker_test = 0xc0 ;
int mag_test = 2 ;
int frames_test = 4 ;
int index_sz_test = 2 + mag_test * frames_test ;
marker_test |= frames_test - 1 ;
marker_test |= ( mag_test - 1 ) << 3 ;
* x ++ = marker_test ;
for ( i = 0 ;
i < mag_test * frames_test ;
++ i ) * x ++ = 0 ;
* x ++ = marker_test ;
ctx -> pending_cx_data_sz += index_sz_test ;
printf ( "Added supplemental superframe data\n" ) ;
# endif * x ++ = marker ;
for ( i = 0 ;
i < ctx -> pending_frame_count ;
i ++ ) {
unsigned int this_sz = ( unsigned int ) ctx -> pending_frame_sizes [ i ] ;
for ( j = 0 ;
j <= mag ;
j ++ ) {
* x ++ = this_sz & 0xff ;
this_sz >>= 8 ;
}
}
* x ++ = marker ;
ctx -> pending_cx_data_sz += index_sz ;
# ifdef TEST_SUPPLEMENTAL_SUPERFRAME_DATA index_sz += index_sz_test ;
# endif }
return index_sz ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int wild_case_compare ( CHARSET_INFO * cs , const char * str , const char * wildstr ) {
reg3 int flag ;
DBUG_ENTER ( "wild_case_compare" ) ;
DBUG_PRINT ( "enter" , ( "str: '%s' wildstr: '%s'" , str , wildstr ) ) ;
while ( * wildstr ) {
while ( * wildstr && * wildstr != wild_many && * wildstr != wild_one ) {
if ( * wildstr == wild_prefix && wildstr [ 1 ] ) wildstr ++ ;
if ( my_toupper ( cs , * wildstr ++ ) != my_toupper ( cs , * str ++ ) ) DBUG_RETURN ( 1 ) ;
}
if ( ! * wildstr ) DBUG_RETURN ( * str != 0 ) ;
if ( * wildstr ++ == wild_one ) {
if ( ! * str ++ ) DBUG_RETURN ( 1 ) ;
}
else {
if ( ! * wildstr ) DBUG_RETURN ( 0 ) ;
flag = ( * wildstr != wild_many && * wildstr != wild_one ) ;
do {
if ( flag ) {
char cmp ;
if ( ( cmp = * wildstr ) == wild_prefix && wildstr [ 1 ] ) cmp = wildstr [ 1 ] ;
cmp = my_toupper ( cs , cmp ) ;
while ( * str && my_toupper ( cs , * str ) != cmp ) str ++ ;
if ( ! * str ) DBUG_RETURN ( 1 ) ;
}
if ( wild_case_compare ( cs , str , wildstr ) == 0 ) DBUG_RETURN ( 0 ) ;
}
while ( * str ++ ) ;
DBUG_RETURN ( 1 ) ;
}
}
DBUG_RETURN ( * str != '\0' ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void option_date_format ( const char * fmt ) {
if ( ! strcmp ( fmt , "raw" ) ) whenspec = WHENSPEC_RAW ;
else if ( ! strcmp ( fmt , "rfc2822" ) ) whenspec = WHENSPEC_RFC2822 ;
else if ( ! strcmp ( fmt , "now" ) ) whenspec = WHENSPEC_NOW ;
else die ( "unknown --date-format argument %s" , fmt ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
bool hostname_requires_resolving ( const char * hostname ) {
char cur ;
if ( ! hostname ) return FALSE ;
size_t namelen = strlen ( hostname ) ;
size_t lhlen = strlen ( my_localhost ) ;
if ( ( namelen == lhlen ) && ! my_strnncoll ( system_charset_info , ( const uchar * ) hostname , namelen , ( const uchar * ) my_localhost , strlen ( my_localhost ) ) ) return FALSE ;
for ( ;
( cur = * hostname ) ;
hostname ++ ) {
if ( ( cur != '%' ) && ( cur != '_' ) && ( cur != '.' ) && ( cur != '/' ) && ( ( cur < '0' ) || ( cur > '9' ) ) ) return TRUE ;
}
return FALSE ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void extrapolate_isf ( float isf [ LP_ORDER_16k ] ) {
float diff_isf [ LP_ORDER - 2 ] , diff_mean ;
float corr_lag [ 3 ] ;
float est , scale ;
int i , j , i_max_corr ;
isf [ LP_ORDER_16k - 1 ] = isf [ LP_ORDER - 1 ] ;
for ( i = 0 ;
i < LP_ORDER - 2 ;
i ++ ) diff_isf [ i ] = isf [ i + 1 ] - isf [ i ] ;
diff_mean = 0.0 ;
for ( i = 2 ;
i < LP_ORDER - 2 ;
i ++ ) diff_mean += diff_isf [ i ] * ( 1.0f / ( LP_ORDER - 4 ) ) ;
i_max_corr = 0 ;
for ( i = 0 ;
i < 3 ;
i ++ ) {
corr_lag [ i ] = auto_correlation ( diff_isf , diff_mean , i + 2 ) ;
if ( corr_lag [ i ] > corr_lag [ i_max_corr ] ) i_max_corr = i ;
}
i_max_corr ++ ;
for ( i = LP_ORDER - 1 ;
i < LP_ORDER_16k - 1 ;
i ++ ) isf [ i ] = isf [ i - 1 ] + isf [ i - 1 - i_max_corr ] - isf [ i - 2 - i_max_corr ] ;
est = 7965 + ( isf [ 2 ] - isf [ 3 ] - isf [ 4 ] ) / 6.0 ;
scale = 0.5 * ( FFMIN ( est , 7600 ) - isf [ LP_ORDER - 2 ] ) / ( isf [ LP_ORDER_16k - 2 ] - isf [ LP_ORDER - 2 ] ) ;
for ( i = LP_ORDER - 1 , j = 0 ;
i < LP_ORDER_16k - 1 ;
i ++ , j ++ ) diff_isf [ j ] = scale * ( isf [ i ] - isf [ i - 1 ] ) ;
for ( i = 1 ;
i < LP_ORDER_16k - LP_ORDER ;
i ++ ) if ( diff_isf [ i ] + diff_isf [ i - 1 ] < 5.0 ) {
if ( diff_isf [ i ] > diff_isf [ i - 1 ] ) {
diff_isf [ i - 1 ] = 5.0 - diff_isf [ i ] ;
}
else diff_isf [ i ] = 5.0 - diff_isf [ i - 1 ] ;
}
for ( i = LP_ORDER - 1 , j = 0 ;
i < LP_ORDER_16k - 1 ;
i ++ , j ++ ) isf [ i ] = isf [ i - 1 ] + diff_isf [ j ] * ( 1.0f / ( 1 << 15 ) ) ;
for ( i = 0 ;
i < LP_ORDER_16k - 1 ;
i ++ ) isf [ i ] *= 0.8 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_P ( BrowserCloseManagerBrowserTest , TestHangInBeforeUnloadMultipleWindows ) {
browsers_ . push_back ( CreateBrowser ( browser ( ) -> profile ( ) ) ) ;
browsers_ . push_back ( CreateBrowser ( browser ( ) -> profile ( ) ) ) ;
ASSERT_NO_FATAL_FAILURE ( ui_test_utils : : NavigateToURL ( browsers_ [ 0 ] , embedded_test_server ( ) -> GetURL ( "/beforeunload_hang.html" ) ) ) ;
ASSERT_NO_FATAL_FAILURE ( ui_test_utils : : NavigateToURL ( browsers_ [ 1 ] , embedded_test_server ( ) -> GetURL ( "/beforeunload.html" ) ) ) ;
ASSERT_NO_FATAL_FAILURE ( ui_test_utils : : NavigateToURL ( browsers_ [ 2 ] , embedded_test_server ( ) -> GetURL ( "/beforeunload_hang.html" ) ) ) ;
PrepareForDialog ( browsers_ [ 1 ] ) ;
RepeatedNotificationObserver cancel_observer ( chrome : : NOTIFICATION_BROWSER_CLOSE_CANCELLED , 2 ) ;
chrome : : CloseAllBrowsersAndQuit ( ) ;
ASSERT_NO_FATAL_FAILURE ( CancelClose ( ) ) ;
cancel_observer . Wait ( ) ;
EXPECT_FALSE ( browser_shutdown : : IsTryingToQuit ( ) ) ;
EXPECT_EQ ( 1 , browsers_ [ 0 ] -> tab_strip_model ( ) -> count ( ) ) ;
EXPECT_EQ ( 1 , browsers_ [ 1 ] -> tab_strip_model ( ) -> count ( ) ) ;
EXPECT_EQ ( 1 , browsers_ [ 2 ] -> tab_strip_model ( ) -> count ( ) ) ;
RepeatedNotificationObserver close_observer ( chrome : : NOTIFICATION_BROWSER_CLOSED , 3 ) ;
chrome : : CloseAllBrowsersAndQuit ( ) ;
ASSERT_NO_FATAL_FAILURE ( AcceptClose ( ) ) ;
close_observer . Wait ( ) ;
EXPECT_TRUE ( browser_shutdown : : IsTryingToQuit ( ) ) ;
EXPECT_TRUE ( BrowserList : : GetInstance ( ) -> empty ( ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
proto_item * proto_tree_get_parent ( proto_tree * tree ) {
if ( ! tree ) return NULL ;
return ( proto_item * ) tree ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_P ( SlimmingPaintWebFrameTest , DidScrollCallbackAfterScrollableAreaChanges ) {
DCHECK ( RuntimeEnabledFeatures : : SlimmingPaintV2Enabled ( ) ) ;
InitializeWithHTML ( * WebView ( ) -> MainFrameImpl ( ) -> GetFrame ( ) , "<style>" " #scrollable {
" " height: 100px;
" " width: 100px;
" " overflow: scroll;
" " will-change: transform;
" " }
" " #forceScroll {
height: 120px;
width: 50px;
}
" "</style>" "<div id='scrollable'>" " <div id='forceScroll'></div>" "</div>" ) ;
WebView ( ) -> UpdateAllLifecyclePhases ( ) ;
Document * document = WebView ( ) -> MainFrameImpl ( ) -> GetFrame ( ) -> GetDocument ( ) ;
Element * scrollable = document -> getElementById ( "scrollable" ) ;
auto * scrollable_area = ToLayoutBox ( scrollable -> GetLayoutObject ( ) ) -> GetScrollableArea ( ) ;
EXPECT_NE ( nullptr , scrollable_area ) ;
EXPECT_EQ ( ContentLayerCount ( ) , 2u ) ;
EXPECT_EQ ( ScrollHitTestLayerCount ( ) , 1u ) ;
EXPECT_EQ ( ScrollOffset ( ) , scrollable_area -> GetScrollOffset ( ) ) ;
ScrollHitTestLayerAt ( 0 ) -> SetScrollOffsetFromImplSide ( gfx : : ScrollOffset ( 0 , 1 ) ) ;
WebView ( ) -> UpdateAllLifecyclePhases ( ) ;
EXPECT_EQ ( ScrollOffset ( 0 , 1 ) , scrollable_area -> GetScrollOffset ( ) ) ;
scrollable -> setAttribute ( HTMLNames : : styleAttr , "overflow: visible" ) ;
LocalMainFrame ( ) -> ExecuteScript ( WebScriptSource ( "var forceLayoutFromScript = scrollable.offsetTop;
" ) ) ;
EXPECT_EQ ( document -> Lifecycle ( ) . GetState ( ) , DocumentLifecycle : : kLayoutClean ) ;
EXPECT_EQ ( nullptr , ToLayoutBox ( scrollable -> GetLayoutObject ( ) ) -> GetScrollableArea ( ) ) ;
EXPECT_EQ ( ScrollHitTestLayerCount ( ) , 1u ) ;
ScrollHitTestLayerAt ( 0 ) -> SetScrollOffsetFromImplSide ( gfx : : ScrollOffset ( 0 , 3 ) ) ;
WebView ( ) -> UpdateAllLifecyclePhases ( ) ;
EXPECT_EQ ( ContentLayerCount ( ) , 1u ) ;
EXPECT_EQ ( ScrollHitTestLayerCount ( ) , 0u ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void model256_reset ( Model256 * m ) {
int i ;
for ( i = 0 ;
i < 255 ;
i ++ ) m -> weights [ i ] = 1 ;
m -> weights [ 255 ] = 0 ;
m -> tot_weight = 0 ;
m -> upd_val = 256 ;
m -> till_rescale = 1 ;
model256_update ( m , 255 ) ;
m -> till_rescale = m -> upd_val = ( 256 + 6 ) >> 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int zerocodec_decode_frame ( AVCodecContext * avctx , void * data , int * got_frame , AVPacket * avpkt ) {
ZeroCodecContext * zc = avctx -> priv_data ;
AVFrame * pic = avctx -> coded_frame ;
AVFrame * prev_pic = & zc -> previous_frame ;
z_stream * zstream = & zc -> zstream ;
uint8_t * prev = prev_pic -> data [ 0 ] ;
uint8_t * dst ;
int i , j , zret ;
pic -> reference = 3 ;
if ( avpkt -> flags & AV_PKT_FLAG_KEY ) {
pic -> key_frame = 1 ;
pic -> pict_type = AV_PICTURE_TYPE_I ;
}
else {
if ( ! prev ) {
av_log ( avctx , AV_LOG_ERROR , "Missing reference frame.\n" ) ;
return AVERROR_INVALIDDATA ;
}
prev += ( avctx -> height - 1 ) * prev_pic -> linesize [ 0 ] ;
pic -> key_frame = 0 ;
pic -> pict_type = AV_PICTURE_TYPE_P ;
}
zret = inflateReset ( zstream ) ;
if ( zret != Z_OK ) {
av_log ( avctx , AV_LOG_ERROR , "Could not reset inflate: %d.\n" , zret ) ;
return AVERROR_INVALIDDATA ;
}
if ( ff_get_buffer ( avctx , pic ) < 0 ) {
av_log ( avctx , AV_LOG_ERROR , "Could not allocate buffer.\n" ) ;
return AVERROR ( ENOMEM ) ;
}
zstream -> next_in = avpkt -> data ;
zstream -> avail_in = avpkt -> size ;
dst = pic -> data [ 0 ] + ( avctx -> height - 1 ) * pic -> linesize [ 0 ] ;
for ( i = 0 ;
i < avctx -> height ;
i ++ ) {
zstream -> next_out = dst ;
zstream -> avail_out = avctx -> width << 1 ;
zret = inflate ( zstream , Z_SYNC_FLUSH ) ;
if ( zret != Z_OK && zret != Z_STREAM_END ) {
avctx -> release_buffer ( avctx , pic ) ;
av_log ( avctx , AV_LOG_ERROR , "Inflate failed with return code: %d.\n" , zret ) ;
return AVERROR_INVALIDDATA ;
}
if ( ! ( avpkt -> flags & AV_PKT_FLAG_KEY ) ) for ( j = 0 ;
j < avctx -> width << 1 ;
j ++ ) dst [ j ] += prev [ j ] & - ! dst [ j ] ;
prev -= prev_pic -> linesize [ 0 ] ;
dst -= pic -> linesize [ 0 ] ;
}
if ( prev_pic -> data [ 0 ] ) avctx -> release_buffer ( avctx , prev_pic ) ;
* got_frame = 1 ;
* ( AVFrame * ) data = * pic ;
FFSWAP ( AVFrame , * pic , * prev_pic ) ;
return avpkt -> size ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void update_state ( AMRContext * p ) {
memcpy ( p -> prev_lsp_sub4 , p -> lsp [ 3 ] , LP_FILTER_ORDER * sizeof ( p -> lsp [ 3 ] [ 0 ] ) ) ;
memmove ( & p -> excitation_buf [ 0 ] , & p -> excitation_buf [ AMR_SUBFRAME_SIZE ] , ( PITCH_DELAY_MAX + LP_FILTER_ORDER + 1 ) * sizeof ( float ) ) ;
memmove ( & p -> pitch_gain [ 0 ] , & p -> pitch_gain [ 1 ] , 4 * sizeof ( float ) ) ;
memmove ( & p -> fixed_gain [ 0 ] , & p -> fixed_gain [ 1 ] , 4 * sizeof ( float ) ) ;
memmove ( & p -> samples_in [ 0 ] , & p -> samples_in [ AMR_SUBFRAME_SIZE ] , LP_FILTER_ORDER * sizeof ( float ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int ff_h263_decode_motion ( MpegEncContext * s , int pred , int f_code ) {
int code , val , sign , shift ;
code = get_vlc2 ( & s -> gb , mv_vlc . table , MV_VLC_BITS , 2 ) ;
if ( code == 0 ) return pred ;
if ( code < 0 ) return 0xffff ;
sign = get_bits1 ( & s -> gb ) ;
shift = f_code - 1 ;
val = code ;
if ( shift ) {
val = ( val - 1 ) << shift ;
val |= get_bits ( & s -> gb , shift ) ;
val ++ ;
}
if ( sign ) val = - val ;
val += pred ;
if ( ! s -> h263_long_vectors ) {
val = sign_extend ( val , 5 + f_code ) ;
}
else {
if ( pred < - 31 && val < - 63 ) val += 64 ;
if ( pred > 32 && val > 63 ) val -= 64 ;
}
return val ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
const char * SSL_alert_desc_string ( int value ) {
const char * str ;
switch ( value & 0xff ) {
case SSL3_AD_CLOSE_NOTIFY : str = "CN" ;
break ;
case SSL3_AD_UNEXPECTED_MESSAGE : str = "UM" ;
break ;
case SSL3_AD_BAD_RECORD_MAC : str = "BM" ;
break ;
case SSL3_AD_DECOMPRESSION_FAILURE : str = "DF" ;
break ;
case SSL3_AD_HANDSHAKE_FAILURE : str = "HF" ;
break ;
case SSL3_AD_NO_CERTIFICATE : str = "NC" ;
break ;
case SSL3_AD_BAD_CERTIFICATE : str = "BC" ;
break ;
case SSL3_AD_UNSUPPORTED_CERTIFICATE : str = "UC" ;
break ;
case SSL3_AD_CERTIFICATE_REVOKED : str = "CR" ;
break ;
case SSL3_AD_CERTIFICATE_EXPIRED : str = "CE" ;
break ;
case SSL3_AD_CERTIFICATE_UNKNOWN : str = "CU" ;
break ;
case SSL3_AD_ILLEGAL_PARAMETER : str = "IP" ;
break ;
case TLS1_AD_DECRYPTION_FAILED : str = "DC" ;
break ;
case TLS1_AD_RECORD_OVERFLOW : str = "RO" ;
break ;
case TLS1_AD_UNKNOWN_CA : str = "CA" ;
break ;
case TLS1_AD_ACCESS_DENIED : str = "AD" ;
break ;
case TLS1_AD_DECODE_ERROR : str = "DE" ;
break ;
case TLS1_AD_DECRYPT_ERROR : str = "CY" ;
break ;
case TLS1_AD_EXPORT_RESTRICTION : str = "ER" ;
break ;
case TLS1_AD_PROTOCOL_VERSION : str = "PV" ;
break ;
case TLS1_AD_INSUFFICIENT_SECURITY : str = "IS" ;
break ;
case TLS1_AD_INTERNAL_ERROR : str = "IE" ;
break ;
case TLS1_AD_USER_CANCELLED : str = "US" ;
break ;
case TLS1_AD_NO_RENEGOTIATION : str = "NR" ;
break ;
case TLS1_AD_UNSUPPORTED_EXTENSION : str = "UE" ;
break ;
case TLS1_AD_CERTIFICATE_UNOBTAINABLE : str = "CO" ;
break ;
case TLS1_AD_UNRECOGNIZED_NAME : str = "UN" ;
break ;
case TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE : str = "BR" ;
break ;
case TLS1_AD_BAD_CERTIFICATE_HASH_VALUE : str = "BH" ;
break ;
case TLS1_AD_UNKNOWN_PSK_IDENTITY : str = "UP" ;
break ;
default : str = "UK" ;
break ;
}
return ( str ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int selinux_inode_unlink ( struct inode * dir , struct dentry * dentry ) {
return may_link ( dir , dentry , MAY_UNLINK ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void reindex_all_databases ( const char * maintenance_db , const char * host , const char * port , const char * username , enum trivalue prompt_password , const char * progname , bool echo , bool quiet , bool verbose ) {
PGconn * conn ;
PGresult * result ;
int i ;
conn = connectMaintenanceDatabase ( maintenance_db , host , port , username , prompt_password , progname ) ;
result = executeQuery ( conn , "SELECT datname FROM pg_database WHERE datallowconn ORDER BY 1;
" , progname , echo ) ;
PQfinish ( conn ) ;
for ( i = 0 ;
i < PQntuples ( result ) ;
i ++ ) {
char * dbname = PQgetvalue ( result , i , 0 ) ;
if ( ! quiet ) {
printf ( _ ( "%s: reindexing database \"%s\"\n" ) , progname , dbname ) ;
fflush ( stdout ) ;
}
reindex_one_database ( dbname , dbname , "DATABASE" , host , port , username , prompt_password , progname , echo , verbose ) ;
}
PQclear ( result ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static uint64_t translate_kernel_address ( void * opaque , uint64_t addr ) {
return addr - 0xf0000000ULL ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int _WriteType42SFNTS ( FILE * type42 , SplineFont * sf , enum fontformat format , int flags , EncMap * map , int layer ) {
struct alltabs at ;
int i ;
locale_t tmplocale ;
locale_t oldlocale ;
switch_to_c_locale ( & tmplocale , & oldlocale ) ;
if ( sf -> subfontcnt != 0 ) sf = sf -> subfonts [ 0 ] ;
for ( i = 0 ;
i < sf -> glyphcnt ;
++ i ) if ( sf -> glyphs [ i ] != NULL ) sf -> glyphs [ i ] -> ttf_glyph = - 1 ;
memset ( & at , '\0' , sizeof ( struct alltabs ) ) ;
ATinit ( & at , sf , map , flags , layer , format , bf_none , NULL ) ;
at . applemode = false ;
at . opentypemode = false ;
if ( initTables ( & at , sf , format , NULL , bf_none ) ) dumptype42 ( type42 , & at , format ) ;
free ( at . gi . loca ) ;
switch_to_old_locale ( & tmplocale , & oldlocale ) ;
if ( at . error || ferror ( type42 ) ) return ( 0 ) ;
return ( 1 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void config_remotely ( sockaddr_u * remote_addr ) {
struct FILE_INFO remote_cuckoo ;
char origin [ 128 ] ;
snprintf ( origin , sizeof ( origin ) , "remote config from %s" , stoa ( remote_addr ) ) ;
memset ( & remote_cuckoo , 0 , sizeof ( remote_cuckoo ) ) ;
remote_cuckoo . fname = origin ;
remote_cuckoo . line_no = 1 ;
remote_cuckoo . col_no = 1 ;
ip_file = & remote_cuckoo ;
input_from_file = 0 ;
init_syntax_tree ( & cfgt ) ;
yyparse ( ) ;
cfgt . source . attr = CONF_SOURCE_NTPQ ;
cfgt . timestamp = time ( NULL ) ;
cfgt . source . value . s = estrdup ( stoa ( remote_addr ) ) ;
DPRINTF ( 1 , ( "Finished Parsing!!\n" ) ) ;
save_and_apply_config_tree ( ) ;
input_from_file = 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int SpoolssDeleteForm_r ( tvbuff_t * tvb , int offset , packet_info * pinfo , proto_tree * tree , dcerpc_info * di , guint8 * drep _U_ ) {
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_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 vp9_sad ## m ## x ## n ## x ## k ## _c ( const uint8_t * src , int src_stride , const uint8_t * ref , int ref_stride , unsigned int * sads ) {
int i ;
for ( i = 0 ;
i < k ;
++ i ) sads [ i ] = vp9_sad ## m ## x ## n ## _c ( src , src_stride , & ref [ i ] , ref_stride ) ;
\ }
# define sadMxNx4D ( m , n ) void vp9_sad ## m ## x ## n ## x4d_c ( const uint8_t * src , int src_stride , const uint8_t * const refs [ ] , int ref_stride , unsigned int * sads ) {
int i ;
for ( i = 0 ;
i < 4 ;
++ i ) sads [ i ] = vp9_sad ## m ## x ## n ## _c ( src , src_stride , refs [ i ] , ref_stride ) ;
\ }
sadMxN ( 64 , 64 ) sadMxNxK ( 64 , 64 , 3 )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static guint get_pvfs_pdu_len ( packet_info * pinfo _U_ , tvbuff_t * tvb , int offset , void * data _U_ ) {
guint32 plen ;
plen = tvb_get_letohl ( tvb , offset + 16 ) ;
return plen + 24 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void encode_nonrd_sb_row ( VP9_COMP * cpi , const TileInfo * const tile , int mi_row , TOKENEXTRA * * tp ) {
SPEED_FEATURES * const sf = & cpi -> sf ;
VP9_COMMON * const cm = & cpi -> common ;
MACROBLOCK * const x = & cpi -> mb ;
MACROBLOCKD * const xd = & x -> e_mbd ;
int mi_col ;
vpx_memset ( & xd -> left_context , 0 , sizeof ( xd -> left_context ) ) ;
vpx_memset ( xd -> left_seg_context , 0 , sizeof ( xd -> left_seg_context ) ) ;
for ( mi_col = tile -> mi_col_start ;
mi_col < tile -> mi_col_end ;
mi_col += MI_BLOCK_SIZE ) {
int dummy_rate = 0 ;
int64_t dummy_dist = 0 ;
const int idx_str = cm -> mi_stride * mi_row + mi_col ;
MODE_INFO * mi = cm -> mi + idx_str ;
MODE_INFO * prev_mi = ( cm -> prev_mip + cm -> mi_stride + 1 + idx_str ) -> src_mi ;
BLOCK_SIZE bsize ;
x -> in_static_area = 0 ;
x -> source_variance = UINT_MAX ;
vp9_zero ( x -> pred_mv ) ;
switch ( sf -> partition_search_type ) {
case VAR_BASED_PARTITION : choose_partitioning ( cpi , tile , mi_row , mi_col ) ;
nonrd_use_partition ( cpi , tile , mi , tp , mi_row , mi_col , BLOCK_64X64 , 1 , & dummy_rate , & dummy_dist , cpi -> pc_root ) ;
break ;
case SOURCE_VAR_BASED_PARTITION : set_source_var_based_partition ( cpi , tile , mi , mi_row , mi_col ) ;
nonrd_use_partition ( cpi , tile , mi , tp , mi_row , mi_col , BLOCK_64X64 , 1 , & dummy_rate , & dummy_dist , cpi -> pc_root ) ;
break ;
case VAR_BASED_FIXED_PARTITION : case FIXED_PARTITION : bsize = sf -> partition_search_type == FIXED_PARTITION ? sf -> always_this_block_size : get_nonrd_var_based_fixed_partition ( cpi , mi_row , mi_col ) ;
set_fixed_partitioning ( cpi , tile , mi , mi_row , mi_col , bsize ) ;
nonrd_use_partition ( cpi , tile , mi , tp , mi_row , mi_col , BLOCK_64X64 , 1 , & dummy_rate , & dummy_dist , cpi -> pc_root ) ;
break ;
case REFERENCE_PARTITION : if ( sf -> partition_check || ! ( x -> in_static_area = is_background ( cpi , tile , mi_row , mi_col ) ) ) {
set_modeinfo_offsets ( cm , xd , mi_row , mi_col ) ;
auto_partition_range ( cpi , tile , mi_row , mi_col , & sf -> min_partition_size , & sf -> max_partition_size ) ;
nonrd_pick_partition ( cpi , tile , tp , mi_row , mi_col , BLOCK_64X64 , & dummy_rate , & dummy_dist , 1 , INT64_MAX , cpi -> pc_root ) ;
}
else {
copy_partitioning ( cm , mi , prev_mi ) ;
nonrd_use_partition ( cpi , tile , mi , tp , mi_row , mi_col , BLOCK_64X64 , 1 , & dummy_rate , & dummy_dist , cpi -> pc_root ) ;
}
break ;
default : assert ( 0 ) ;
break ;
}
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void test_bug27592 ( ) {
const int NUM_ITERATIONS = 40 ;
int i ;
int rc ;
MYSQL_STMT * stmt = NULL ;
MYSQL_BIND bind [ 1 ] ;
MYSQL_TIME time_val ;
DBUG_ENTER ( "test_bug27592" ) ;
myheader ( "test_bug27592" ) ;
mysql_query ( mysql , "DROP TABLE IF EXISTS t1" ) ;
mysql_query ( mysql , "CREATE TABLE t1(c2 DATETIME)" ) ;
stmt = mysql_simple_prepare ( mysql , "INSERT INTO t1 VALUES (?)" ) ;
DIE_UNLESS ( stmt ) ;
memset ( bind , 0 , sizeof ( bind ) ) ;
bind [ 0 ] . buffer_type = MYSQL_TYPE_DATETIME ;
bind [ 0 ] . buffer = ( char * ) & time_val ;
bind [ 0 ] . length = NULL ;
for ( i = 0 ;
i < NUM_ITERATIONS ;
i ++ ) {
time_val . year = 2007 ;
time_val . month = 6 ;
time_val . day = 7 ;
time_val . hour = 18 ;
time_val . minute = 41 ;
time_val . second = 3 ;
time_val . second_part = 0 ;
time_val . neg = 0 ;
rc = mysql_stmt_bind_param ( stmt , bind ) ;
check_execute ( stmt , rc ) ;
rc = mysql_stmt_execute ( stmt ) ;
check_execute ( stmt , rc ) ;
}
mysql_stmt_close ( stmt ) ;
DBUG_VOID_RETURN ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static double eqjoinsel_inner ( Oid operator , VariableStatData * vardata1 , VariableStatData * vardata2 ) {
double selec ;
double nd1 ;
double nd2 ;
bool isdefault1 ;
bool isdefault2 ;
Form_pg_statistic stats1 = NULL ;
Form_pg_statistic stats2 = NULL ;
bool have_mcvs1 = false ;
Datum * values1 = NULL ;
int nvalues1 = 0 ;
float4 * numbers1 = NULL ;
int nnumbers1 = 0 ;
bool have_mcvs2 = false ;
Datum * values2 = NULL ;
int nvalues2 = 0 ;
float4 * numbers2 = NULL ;
int nnumbers2 = 0 ;
nd1 = get_variable_numdistinct ( vardata1 , & isdefault1 ) ;
nd2 = get_variable_numdistinct ( vardata2 , & isdefault2 ) ;
if ( HeapTupleIsValid ( vardata1 -> statsTuple ) ) {
stats1 = ( Form_pg_statistic ) GETSTRUCT ( vardata1 -> statsTuple ) ;
have_mcvs1 = get_attstatsslot ( vardata1 -> statsTuple , vardata1 -> atttype , vardata1 -> atttypmod , STATISTIC_KIND_MCV , InvalidOid , NULL , & values1 , & nvalues1 , & numbers1 , & nnumbers1 ) ;
}
if ( HeapTupleIsValid ( vardata2 -> statsTuple ) ) {
stats2 = ( Form_pg_statistic ) GETSTRUCT ( vardata2 -> statsTuple ) ;
have_mcvs2 = get_attstatsslot ( vardata2 -> statsTuple , vardata2 -> atttype , vardata2 -> atttypmod , STATISTIC_KIND_MCV , InvalidOid , NULL , & values2 , & nvalues2 , & numbers2 , & nnumbers2 ) ;
}
if ( have_mcvs1 && have_mcvs2 ) {
FmgrInfo eqproc ;
bool * hasmatch1 ;
bool * hasmatch2 ;
double nullfrac1 = stats1 -> stanullfrac ;
double nullfrac2 = stats2 -> stanullfrac ;
double matchprodfreq , matchfreq1 , matchfreq2 , unmatchfreq1 , unmatchfreq2 , otherfreq1 , otherfreq2 , totalsel1 , totalsel2 ;
int i , nmatches ;
fmgr_info ( get_opcode ( operator ) , & eqproc ) ;
hasmatch1 = ( bool * ) palloc0 ( nvalues1 * sizeof ( bool ) ) ;
hasmatch2 = ( bool * ) palloc0 ( nvalues2 * sizeof ( bool ) ) ;
matchprodfreq = 0.0 ;
nmatches = 0 ;
for ( i = 0 ;
i < nvalues1 ;
i ++ ) {
int j ;
for ( j = 0 ;
j < nvalues2 ;
j ++ ) {
if ( hasmatch2 [ j ] ) continue ;
if ( DatumGetBool ( FunctionCall2Coll ( & eqproc , DEFAULT_COLLATION_OID , values1 [ i ] , values2 [ j ] ) ) ) {
hasmatch1 [ i ] = hasmatch2 [ j ] = true ;
matchprodfreq += numbers1 [ i ] * numbers2 [ j ] ;
nmatches ++ ;
break ;
}
}
}
CLAMP_PROBABILITY ( matchprodfreq ) ;
matchfreq1 = unmatchfreq1 = 0.0 ;
for ( i = 0 ;
i < nvalues1 ;
i ++ ) {
if ( hasmatch1 [ i ] ) matchfreq1 += numbers1 [ i ] ;
else unmatchfreq1 += numbers1 [ i ] ;
}
CLAMP_PROBABILITY ( matchfreq1 ) ;
CLAMP_PROBABILITY ( unmatchfreq1 ) ;
matchfreq2 = unmatchfreq2 = 0.0 ;
for ( i = 0 ;
i < nvalues2 ;
i ++ ) {
if ( hasmatch2 [ i ] ) matchfreq2 += numbers2 [ i ] ;
else unmatchfreq2 += numbers2 [ i ] ;
}
CLAMP_PROBABILITY ( matchfreq2 ) ;
CLAMP_PROBABILITY ( unmatchfreq2 ) ;
pfree ( hasmatch1 ) ;
pfree ( hasmatch2 ) ;
otherfreq1 = 1.0 - nullfrac1 - matchfreq1 - unmatchfreq1 ;
otherfreq2 = 1.0 - nullfrac2 - matchfreq2 - unmatchfreq2 ;
CLAMP_PROBABILITY ( otherfreq1 ) ;
CLAMP_PROBABILITY ( otherfreq2 ) ;
totalsel1 = matchprodfreq ;
if ( nd2 > nvalues2 ) totalsel1 += unmatchfreq1 * otherfreq2 / ( nd2 - nvalues2 ) ;
if ( nd2 > nmatches ) totalsel1 += otherfreq1 * ( otherfreq2 + unmatchfreq2 ) / ( nd2 - nmatches ) ;
totalsel2 = matchprodfreq ;
if ( nd1 > nvalues1 ) totalsel2 += unmatchfreq2 * otherfreq1 / ( nd1 - nvalues1 ) ;
if ( nd1 > nmatches ) totalsel2 += otherfreq2 * ( otherfreq1 + unmatchfreq1 ) / ( nd1 - nmatches ) ;
selec = ( totalsel1 < totalsel2 ) ? totalsel1 : totalsel2 ;
}
else {
double nullfrac1 = stats1 ? stats1 -> stanullfrac : 0.0 ;
double nullfrac2 = stats2 ? stats2 -> stanullfrac : 0.0 ;
selec = ( 1.0 - nullfrac1 ) * ( 1.0 - nullfrac2 ) ;
if ( nd1 > nd2 ) selec /= nd1 ;
else selec /= nd2 ;
}
if ( have_mcvs1 ) free_attstatsslot ( vardata1 -> atttype , values1 , nvalues1 , numbers1 , nnumbers1 ) ;
if ( have_mcvs2 ) free_attstatsslot ( vardata2 -> atttype , values2 , nvalues2 , numbers2 , nnumbers2 ) ;
return selec ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
int tm_init ( void * info , struct tm_roots * roots ) {
tm_event_t nevent , revent ;
char * env , * hold ;
int err ;
int nerr = 0 ;
struct tcp_chan * chan = NULL ;
if ( init_done ) {
return ( TM_BADINIT ) ;
}
if ( ( tm_jobid = getenv ( "PBS_JOBID" ) ) == NULL ) {
return ( TM_EBADENVIRONMENT ) ;
}
tm_jobid_len = strlen ( tm_jobid ) ;
if ( ( tm_jobcookie = getenv ( "PBS_JOBCOOKIE" ) ) == NULL ) return TM_EBADENVIRONMENT ;
tm_jobcookie_len = strlen ( tm_jobcookie ) ;
if ( ( env = getenv ( "PBS_NODENUM" ) ) == NULL ) return TM_EBADENVIRONMENT ;
tm_jobndid = ( tm_node_id ) strtol ( env , & hold , 10 ) ;
if ( env == hold ) return TM_EBADENVIRONMENT ;
if ( ( env = getenv ( "PBS_TASKNUM" ) ) == NULL ) return TM_EBADENVIRONMENT ;
if ( ( tm_jobtid = atoi ( env ) ) == 0 ) return TM_EBADENVIRONMENT ;
if ( ( env = getenv ( "PBS_MOMPORT" ) ) == NULL ) return TM_EBADENVIRONMENT ;
if ( ( tm_momport = atoi ( env ) ) == 0 ) return TM_EBADENVIRONMENT ;
init_done = 1 ;
nevent = new_event ( ) ;
if ( startcom ( TM_INIT , nevent , & chan ) != DIS_SUCCESS ) return TM_ESYSTEM ;
DIS_tcp_wflush ( chan ) ;
DIS_tcp_cleanup ( chan ) ;
add_event ( nevent , TM_ERROR_NODE , TM_INIT , ( void * ) roots ) ;
while ( TRUE ) {
if ( ( err = tm_poll ( TM_NULL_EVENT , & revent , 1 , & nerr ) ) != TM_SUCCESS ) return err ;
if ( event_count == 0 ) break ;
}
return nerr ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void pk_transaction_get_updates ( PkTransaction * transaction , GVariant * params , GDBusMethodInvocation * context ) {
PkBitfield filter ;
g_autoptr ( GError ) error = NULL ;
g_return_if_fail ( PK_IS_TRANSACTION ( transaction ) ) ;
g_return_if_fail ( transaction -> priv -> tid != NULL ) ;
g_variant_get ( params , "(t)" , & filter ) ;
g_debug ( "GetUpdates method called" ) ;
if ( ! pk_backend_is_implemented ( transaction -> priv -> backend , PK_ROLE_ENUM_GET_UPDATES ) ) {
g_set_error ( & error , PK_TRANSACTION_ERROR , PK_TRANSACTION_ERROR_NOT_SUPPORTED , "GetUpdates not supported by backend" ) ;
pk_transaction_set_state ( transaction , PK_TRANSACTION_STATE_ERROR ) ;
goto out ;
}
transaction -> priv -> cached_filters = filter ;
pk_transaction_set_role ( transaction , PK_ROLE_ENUM_GET_UPDATES ) ;
pk_transaction_set_state ( transaction , PK_TRANSACTION_STATE_READY ) ;
out : pk_transaction_dbus_return ( context , error ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int seqvideo_decode ( SeqVideoContext * seq , const unsigned char * data , int data_size ) {
const unsigned char * data_end = data + data_size ;
GetBitContext gb ;
int flags , i , j , x , y , op ;
unsigned char c [ 3 ] ;
unsigned char * dst ;
uint32_t * palette ;
flags = * data ++ ;
if ( flags & 1 ) {
palette = ( uint32_t * ) seq -> frame . data [ 1 ] ;
if ( data_end - data < 256 * 3 ) return AVERROR_INVALIDDATA ;
for ( i = 0 ;
i < 256 ;
i ++ ) {
for ( j = 0 ;
j < 3 ;
j ++ , data ++ ) c [ j ] = ( * data << 2 ) | ( * data >> 4 ) ;
palette [ i ] = AV_RB24 ( c ) ;
}
seq -> frame . palette_has_changed = 1 ;
}
if ( flags & 2 ) {
if ( data_end - data < 128 ) return AVERROR_INVALIDDATA ;
init_get_bits ( & gb , data , 128 * 8 ) ;
data += 128 ;
for ( y = 0 ;
y < 128 ;
y += 8 ) for ( x = 0 ;
x < 256 ;
x += 8 ) {
dst = & seq -> frame . data [ 0 ] [ y * seq -> frame . linesize [ 0 ] + x ] ;
op = get_bits ( & gb , 2 ) ;
switch ( op ) {
case 1 : data = seq_decode_op1 ( seq , data , data_end , dst ) ;
break ;
case 2 : data = seq_decode_op2 ( seq , data , data_end , dst ) ;
break ;
case 3 : data = seq_decode_op3 ( seq , data , data_end , dst ) ;
break ;
}
if ( ! data ) return AVERROR_INVALIDDATA ;
}
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static char * lxc_cgroup_find_abs_path ( const char * subsystem , const char * group , bool should_be_writable , const char * suffix ) {
struct cgroup_meta_data * meta_data ;
struct cgroup_hierarchy * h ;
struct cgroup_mount_point * mp ;
char * result ;
int saved_errno ;
meta_data = lxc_cgroup_load_meta ( ) ;
if ( ! meta_data ) return NULL ;
h = lxc_cgroup_find_hierarchy ( meta_data , subsystem ) ;
if ( ! h ) goto out_error ;
mp = lxc_cgroup_find_mount_point ( h , group , should_be_writable ) ;
if ( ! mp ) goto out_error ;
result = cgroup_to_absolute_path ( mp , group , suffix ) ;
if ( ! result ) goto out_error ;
lxc_cgroup_put_meta ( meta_data ) ;
return result ;
out_error : saved_errno = errno ;
lxc_cgroup_put_meta ( meta_data ) ;
errno = saved_errno ;
return NULL ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_H2250LogicalChannelParameters ( 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_H2250LogicalChannelParameters , H2250LogicalChannelParameters_sequence ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static uint32_t gic_dist_readl ( void * opaque , hwaddr offset ) {
uint32_t val ;
val = gic_dist_readw ( opaque , offset ) ;
val |= gic_dist_readw ( opaque , offset + 2 ) << 16 ;
return val ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int unpack_modes ( Vp3DecodeContext * s , GetBitContext * gb ) {
int i , j , k , sb_x , sb_y ;
int scheme ;
int current_macroblock ;
int current_fragment ;
int coding_mode ;
int custom_mode_alphabet [ CODING_MODE_COUNT ] ;
const int * alphabet ;
Vp3Fragment * frag ;
if ( s -> keyframe ) {
for ( i = 0 ;
i < s -> fragment_count ;
i ++ ) s -> all_fragments [ i ] . coding_method = MODE_INTRA ;
}
else {
scheme = get_bits ( gb , 3 ) ;
if ( scheme == 0 ) {
for ( i = 0 ;
i < 8 ;
i ++ ) custom_mode_alphabet [ i ] = MODE_INTER_NO_MV ;
for ( i = 0 ;
i < 8 ;
i ++ ) custom_mode_alphabet [ get_bits ( gb , 3 ) ] = i ;
alphabet = custom_mode_alphabet ;
}
else alphabet = ModeAlphabet [ scheme - 1 ] ;
for ( sb_y = 0 ;
sb_y < s -> y_superblock_height ;
sb_y ++ ) {
for ( sb_x = 0 ;
sb_x < s -> y_superblock_width ;
sb_x ++ ) {
if ( get_bits_left ( gb ) <= 0 ) return - 1 ;
for ( j = 0 ;
j < 4 ;
j ++ ) {
int mb_x = 2 * sb_x + ( j >> 1 ) ;
int mb_y = 2 * sb_y + ( ( ( j >> 1 ) + j ) & 1 ) ;
current_macroblock = mb_y * s -> macroblock_width + mb_x ;
if ( mb_x >= s -> macroblock_width || mb_y >= s -> macroblock_height ) continue ;
# define BLOCK_X ( 2 * mb_x + ( k & 1 ) ) # define BLOCK_Y ( 2 * mb_y + ( k >> 1 ) ) for ( k = 0 ;
k < 4 ;
k ++ ) {
current_fragment = BLOCK_Y * s -> fragment_width [ 0 ] + BLOCK_X ;
if ( s -> all_fragments [ current_fragment ] . coding_method != MODE_COPY ) break ;
}
if ( k == 4 ) {
s -> macroblock_coding [ current_macroblock ] = MODE_INTER_NO_MV ;
continue ;
}
if ( scheme == 7 ) coding_mode = get_bits ( gb , 3 ) ;
else coding_mode = alphabet [ get_vlc2 ( gb , s -> mode_code_vlc . table , 3 , 3 ) ] ;
s -> macroblock_coding [ current_macroblock ] = coding_mode ;
for ( k = 0 ;
k < 4 ;
k ++ ) {
frag = s -> all_fragments + BLOCK_Y * s -> fragment_width [ 0 ] + BLOCK_X ;
if ( frag -> coding_method != MODE_COPY ) frag -> coding_method = coding_mode ;
}
# define SET_CHROMA_MODES if ( frag [ s -> fragment_start [ 1 ] ] . coding_method != MODE_COPY ) frag [ s -> fragment_start [ 1 ] ] . coding_method = coding_mode ;
if ( frag [ s -> fragment_start [ 2 ] ] . coding_method != MODE_COPY ) frag [ s -> fragment_start [ 2 ] ] . coding_method = coding_mode ;
if ( s -> chroma_y_shift ) {
frag = s -> all_fragments + mb_y * s -> fragment_width [ 1 ] + mb_x ;
SET_CHROMA_MODES }
else if ( s -> chroma_x_shift ) {
frag = s -> all_fragments + 2 * mb_y * s -> fragment_width [ 1 ] + mb_x ;
for ( k = 0 ;
k < 2 ;
k ++ ) {
SET_CHROMA_MODES frag += s -> fragment_width [ 1 ] ;
}
}
else {
for ( k = 0 ;
k < 4 ;
k ++ ) {
frag = s -> all_fragments + BLOCK_Y * s -> fragment_width [ 1 ] + BLOCK_X ;
SET_CHROMA_MODES }
}
}
}
}
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static ossl_inline void lh_ ## type ## _set_down_load ( LHASH_OF ( type ) * lh , unsigned long dl ) {
OPENSSL_LH_set_down_load ( ( OPENSSL_LHASH * ) lh , dl ) ;
}
static ossl_inline void lh_ ## type ## _doall ( LHASH_OF ( type ) * lh , void ( * doall ) ( type * ) ) {
OPENSSL_LH_doall ( ( OPENSSL_LHASH * ) lh , ( OPENSSL_LH_DOALL_FUNC ) doall ) ;
}
LHASH_OF ( type ) # define IMPLEMENT_LHASH_DOALL_ARG_CONST ( type , argtype ) int_implement_lhash_doall ( type , argtype , const type ) # define IMPLEMENT_LHASH_DOALL_ARG ( type , argtype ) int_implement_lhash_doall ( type , argtype , type ) # define int_implement_lhash_doall ( type , argtype , cbargtype ) static ossl_inline void lh_ ## type ## _doall_ ## argtype ( LHASH_OF ( type ) * lh , void ( * fn ) ( cbargtype * , argtype * ) , argtype * arg ) {
OPENSSL_LH_doall_arg ( ( OPENSSL_LHASH * ) lh , ( OPENSSL_LH_DOALL_FUNCARG ) fn , ( void * ) arg ) ;
}
LHASH_OF ( type ) DEFINE_LHASH_OF ( OPENSSL_STRING )
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int update_mv ( vp9_writer * w , const unsigned int ct [ 2 ] , vp9_prob * cur_p , vp9_prob upd_p ) {
const vp9_prob new_p = get_binary_prob ( ct [ 0 ] , ct [ 1 ] ) | 1 ;
const int update = cost_branch256 ( ct , * cur_p ) + vp9_cost_zero ( upd_p ) > cost_branch256 ( ct , new_p ) + vp9_cost_one ( upd_p ) + 7 * 256 ;
vp9_write ( w , update , upd_p ) ;
if ( update ) {
* cur_p = new_p ;
vp9_write_literal ( w , new_p >> 1 , 7 ) ;
}
return update ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void pdf_process_SC ( fz_context * ctx , pdf_processor * proc , pdf_csi * csi , int stroke ) {
if ( csi -> name [ 0 ] ) {
pdf_obj * patres , * patobj , * type ;
patres = pdf_dict_get ( ctx , csi -> rdb , PDF_NAME_Pattern ) ;
if ( ! patres ) fz_throw ( ctx , FZ_ERROR_SYNTAX , "cannot find Pattern dictionary" ) ;
patobj = pdf_dict_gets ( ctx , patres , csi -> name ) ;
if ( ! patobj ) fz_throw ( ctx , FZ_ERROR_SYNTAX , "cannot find Pattern resource '%s'" , csi -> name ) ;
type = pdf_dict_get ( ctx , patobj , PDF_NAME_PatternType ) ;
if ( pdf_to_int ( ctx , type ) == 1 ) {
if ( proc -> op_SC_pattern && proc -> op_sc_pattern ) {
pdf_pattern * pat = pdf_load_pattern ( ctx , csi -> doc , patobj ) ;
fz_try ( ctx ) {
if ( stroke ) proc -> op_SC_pattern ( ctx , proc , csi -> name , pat , csi -> top , csi -> stack ) ;
else proc -> op_sc_pattern ( ctx , proc , csi -> name , pat , csi -> top , csi -> stack ) ;
}
fz_always ( ctx ) pdf_drop_pattern ( ctx , pat ) ;
fz_catch ( ctx ) fz_rethrow ( ctx ) ;
}
}
else if ( pdf_to_int ( ctx , type ) == 2 ) {
if ( proc -> op_SC_shade && proc -> op_sc_shade ) {
fz_shade * shade = pdf_load_shading ( ctx , csi -> doc , patobj ) ;
fz_try ( ctx ) {
if ( stroke ) proc -> op_SC_shade ( ctx , proc , csi -> name , shade ) ;
else proc -> op_sc_shade ( ctx , proc , csi -> name , shade ) ;
}
fz_always ( ctx ) fz_drop_shade ( ctx , shade ) ;
fz_catch ( ctx ) fz_rethrow ( ctx ) ;
}
}
else {
fz_throw ( ctx , FZ_ERROR_SYNTAX , "unknown pattern type: %d" , pdf_to_int ( ctx , type ) ) ;
}
}
else {
if ( proc -> op_SC_color && proc -> op_sc_color ) {
if ( stroke ) proc -> op_SC_color ( ctx , proc , csi -> top , csi -> stack ) ;
else proc -> op_sc_color ( ctx , proc , csi -> top , csi -> stack ) ;
}
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void dsp_x8_put_solidcolor ( uint8_t const pix , uint8_t * dst , int const linesize ) {
int k ;
for ( k = 0 ;
k < 8 ;
k ++ ) {
memset ( dst , pix , 8 ) ;
dst += linesize ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void initial_reordering ( const hb_ot_shape_plan_t * plan , hb_font_t * font , hb_buffer_t * buffer ) {
update_consonant_positions ( plan , font , buffer ) ;
insert_dotted_circles ( plan , font , buffer ) ;
hb_glyph_info_t * info = buffer -> info ;
unsigned int count = buffer -> len ;
if ( unlikely ( ! count ) ) return ;
unsigned int last = 0 ;
unsigned int last_syllable = info [ 0 ] . syllable ( ) ;
for ( unsigned int i = 1 ;
i < count ;
i ++ ) if ( last_syllable != info [ i ] . syllable ( ) ) {
initial_reordering_syllable ( plan , font -> face , buffer , last , i ) ;
last = i ;
last_syllable = info [ last ] . syllable ( ) ;
}
initial_reordering_syllable ( plan , font -> face , buffer , last , count ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void U_CALLCONV _UTF16LEOpen ( UConverter * cnv , UConverterLoadArgs * pArgs , UErrorCode * pErrorCode ) {
( void ) pArgs ;
if ( UCNV_GET_VERSION ( cnv ) <= 1 ) {
_UTF16LEReset ( cnv , UCNV_RESET_BOTH ) ;
}
else {
* pErrorCode = U_ILLEGAL_ARGUMENT_ERROR ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void handle_mlppp ( netdissect_options * ndo , const u_char * p , int length ) {
if ( ! ndo -> ndo_eflag ) ND_PRINT ( ( ndo , "MLPPP, " ) ) ;
ND_PRINT ( ( ndo , "seq 0x%03x, Flags [%s], length %u" , ( EXTRACT_16BITS ( p ) ) & 0x0fff , bittok2str ( ppp_ml_flag_values , "none" , * p & 0xc0 ) , length ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int X509_REQ_add1_attr ( X509_REQ * req , X509_ATTRIBUTE * attr ) {
if ( X509at_add1_attr ( & req -> req_info -> attributes , attr ) ) return 1 ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static gboolean gst_asf_demux_check_activate_streams ( GstASFDemux * demux , gboolean force ) {
guint i , actual_streams = 0 ;
if ( demux -> activated_streams ) return TRUE ;
if ( G_UNLIKELY ( ! gst_asf_demux_check_first_ts ( demux , force ) ) ) return FALSE ;
if ( ! all_streams_prerolled ( demux ) && ! force ) {
GST_DEBUG_OBJECT ( demux , "not all streams with data beyond preroll yet" ) ;
return FALSE ;
}
for ( i = 0 ;
i < demux -> num_streams ;
++ i ) {
AsfStream * stream = & demux -> stream [ i ] ;
if ( stream -> payloads -> len > 0 ) {
if ( stream -> inspect_payload && ! stream -> active && ! gst_asf_demux_update_caps_from_payload ( demux , stream ) && stream -> payloads -> len < 20 ) {
return FALSE ;
}
GST_LOG_OBJECT ( stream -> pad , "is prerolled - activate!" ) ;
gst_asf_demux_activate_stream ( demux , stream ) ;
actual_streams += 1 ;
}
else {
GST_LOG_OBJECT ( stream -> pad , "no data, ignoring stream" ) ;
}
}
if ( actual_streams == 0 ) {
GST_ERROR_OBJECT ( demux , "No streams activated!" ) ;
return FALSE ;
}
gst_asf_demux_release_old_pads ( demux ) ;
demux -> activated_streams = TRUE ;
GST_LOG_OBJECT ( demux , "signalling no more pads" ) ;
gst_element_no_more_pads ( GST_ELEMENT ( demux ) ) ;
return TRUE ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void do_rmdir ( struct st_command * command ) {
int error ;
static DYNAMIC_STRING ds_dirname ;
const struct command_arg rmdir_args [ ] = {
{
"dirname" , ARG_STRING , TRUE , & ds_dirname , "Directory to remove" }
}
;
DBUG_ENTER ( "do_rmdir" ) ;
check_command_args ( command , command -> first_argument , rmdir_args , sizeof ( rmdir_args ) / sizeof ( struct command_arg ) , ' ' ) ;
DBUG_PRINT ( "info" , ( "removing directory: %s" , ds_dirname . str ) ) ;
error = rmdir ( ds_dirname . str ) != 0 ;
handle_command_error ( command , error , errno ) ;
dynstr_free ( & ds_dirname ) ;
DBUG_VOID_RETURN ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
jpc_pchg_t * jpc_pchglist_get ( jpc_pchglist_t * pchglist , int pchgno ) {
return pchglist -> pchgs [ pchgno ] ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int do_fail ( xd3_stream * stream , const char * buf ) {
int ret ;
ret = system ( buf ) ;
if ( ! WIFEXITED ( ret ) || WEXITSTATUS ( ret ) != 1 ) {
stream -> msg = "command should have not succeeded" ;
XPR ( NT "command was %s\n" , buf ) ;
return XD3_INTERNAL ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void e1000e_set_rxdctl ( E1000ECore * core , int index , uint32_t val ) {
core -> mac [ RXDCTL ] = core -> mac [ RXDCTL1 ] = val ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void generate_2_noise_channels ( MLPDecodeContext * m , unsigned int substr ) {
SubStream * s = & m -> substream [ substr ] ;
unsigned int i ;
uint32_t seed = s -> noisegen_seed ;
unsigned int maxchan = s -> max_matrix_channel ;
for ( i = 0 ;
i < s -> blockpos ;
i ++ ) {
uint16_t seed_shr7 = seed >> 7 ;
m -> sample_buffer [ i ] [ maxchan + 1 ] = ( ( int8_t ) ( seed >> 15 ) ) << s -> noise_shift ;
m -> sample_buffer [ i ] [ maxchan + 2 ] = ( ( int8_t ) seed_shr7 ) << s -> noise_shift ;
seed = ( seed << 16 ) ^ seed_shr7 ^ ( seed_shr7 << 5 ) ;
}
s -> noisegen_seed = seed ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int parse_CCategSpec ( tvbuff_t * tvb , int offset , proto_tree * parent_tree , proto_tree * pad_tree , const char * fmt , ... ) {
proto_item * item ;
proto_tree * tree ;
va_list ap ;
guint32 type ;
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_CCategSpec , & item , txt ) ;
type = tvb_get_letohl ( tvb , offset ) ;
proto_tree_add_uint ( tree , hf_mswsp_ccategspec_type , tvb , offset , 4 , type ) ;
proto_item_append_text ( item , " Type %u" , type ) ;
offset += 4 ;
offset = parse_CSort ( tvb , offset , tree , pad_tree , "CSort" ) ;
offset = parse_CRangeCategSpec ( tvb , offset , tree , pad_tree , "CRangeCategSpec" ) ;
proto_item_set_end ( item , tvb , offset ) ;
return offset ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void ps2_common_post_load ( PS2State * s ) {
PS2Queue * q = & s -> queue ;
int size ;
int i ;
int tmp_data [ PS2_QUEUE_SIZE ] ;
size = q -> count > PS2_QUEUE_SIZE ? 0 : q -> count ;
if ( size > 0 ) {
for ( i = 0 ;
i < size ;
i ++ ) {
tmp_data [ i ] = q -> data [ q -> rptr ] ;
if ( ++ q -> rptr == 256 ) {
q -> rptr = 0 ;
}
}
memcpy ( q -> data , tmp_data , size ) ;
}
q -> rptr = 0 ;
q -> wptr = size ;
q -> count = size ;
s -> update_irq ( s -> update_arg , q -> count != 0 ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline void e1000e_write_rx_descr ( E1000ECore * core , uint8_t * desc , struct NetRxPkt * pkt , const E1000E_RSSInfo * rss_info , size_t ps_hdr_len , uint16_t ( * written ) [ MAX_PS_BUFFERS ] ) {
if ( e1000e_rx_use_legacy_descriptor ( core ) ) {
assert ( ps_hdr_len == 0 ) ;
e1000e_write_lgcy_rx_descr ( core , desc , pkt , rss_info , ( * written ) [ 0 ] ) ;
}
else {
if ( core -> mac [ RCTL ] & E1000_RCTL_DTYP_PS ) {
e1000e_write_ps_rx_descr ( core , desc , pkt , rss_info , ps_hdr_len , written ) ;
}
else {
assert ( ps_hdr_len == 0 ) ;
e1000e_write_ext_rx_descr ( core , desc , pkt , rss_info , ( * written ) [ 0 ] ) ;
}
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int main_file_write ( main_file * ofile , uint8_t * buf , usize_t size , const char * msg ) {
int ret = 0 ;
# if XD3_STDIO usize_t result ;
result = fwrite ( buf , 1 , size , ofile -> file ) ;
if ( result != size ) {
ret = get_errno ( ) ;
}
# elif XD3_POSIX ret = xd3_posix_io ( ofile -> file , buf , size , ( xd3_posix_func * ) & write , NULL ) ;
# elif XD3_WIN32 ret = xd3_win32_io ( ofile -> file , buf , size , 0 , NULL ) ;
# endif if ( ret ) {
XPR ( NT "%s: %s: %s\n" , msg , ofile -> filename , xd3_mainerror ( ret ) ) ;
}
else {
if ( option_verbose > 5 ) {
XPR ( NT "write %s: %u bytes\n" , ofile -> filename , size ) ;
}
ofile -> nwrite += size ;
}
return ret ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void xmlHashScan3 ( xmlHashTablePtr table , const xmlChar * name , const xmlChar * name2 , const xmlChar * name3 , xmlHashScanner f , void * data ) {
xmlHashScanFull3 ( table , name , name2 , name3 , ( xmlHashScannerFull ) f , data ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
hb_unicode_funcs_t * hb_icu_get_unicode_funcs ( void ) {
static const hb_unicode_funcs_t _hb_icu_unicode_funcs = {
HB_OBJECT_HEADER_STATIC , NULL , true , {
# define HB_UNICODE_FUNC_IMPLEMENT ( name ) hb_icu_unicode_ ## name , HB_UNICODE_FUNCS_IMPLEMENT_CALLBACKS # undef HB_UNICODE_FUNC_IMPLEMENT }
}
;
# if U_ICU_VERSION_MAJOR_NUM >= 49 if ( ! hb_atomic_ptr_get ( & normalizer ) ) {
UErrorCode icu_err = U_ZERO_ERROR ;
( void ) hb_atomic_ptr_cmpexch ( & normalizer , NULL , unorm2_getNFCInstance ( & icu_err ) ) ;
}
# endif return const_cast < hb_unicode_funcs_t * > ( & _hb_icu_unicode_funcs ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline void e1000e_autoneg_timer ( void * opaque ) {
E1000ECore * core = opaque ;
if ( ! qemu_get_queue ( core -> owner_nic ) -> link_down ) {
e1000x_update_regs_on_autoneg_done ( core -> mac , core -> phy [ 0 ] ) ;
e1000e_start_recv ( core ) ;
e1000e_update_flowctl_status ( core ) ;
e1000e_set_interrupt_cause ( core , E1000_ICR_LSC ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static guint16 de_day_saving_time ( tvbuff_t * tvb , proto_tree * tree , packet_info * pinfo _U_ , guint32 offset , guint len , gchar * add_string _U_ , int string_len _U_ ) {
guint32 curr_offset ;
curr_offset = offset ;
proto_tree_add_bits_item ( tree , hf_gsm_a_spare_bits , tvb , curr_offset << 3 , 6 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( tree , hf_gsm_a_dtap_dst_adjustment , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
curr_offset ++ ;
EXTRANEOUS_DATA_CHECK ( len , curr_offset - offset , pinfo , & ei_gsm_a_dtap_extraneous_data ) ;
return ( curr_offset - offset ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int psf_set_stdio ( SF_PRIVATE * psf ) {
int error = 0 ;
switch ( psf -> file . mode ) {
case SFM_RDWR : error = SFE_OPEN_PIPE_RDWR ;
break ;
case SFM_READ : psf -> file . filedes = 0 ;
break ;
case SFM_WRITE : psf -> file . filedes = 1 ;
break ;
default : error = SFE_BAD_OPEN_MODE ;
break ;
}
;
psf -> filelength = 0 ;
return error ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void mark_object ( struct object * obj , const struct name_path * path , const char * name , void * data ) {
update_progress ( data ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
SRP_VBASE * SRP_VBASE_new ( char * seed_key ) {
SRP_VBASE * vb = ( SRP_VBASE * ) OPENSSL_malloc ( sizeof ( SRP_VBASE ) ) ;
if ( vb == NULL ) return NULL ;
if ( ! ( vb -> users_pwd = sk_SRP_user_pwd_new_null ( ) ) || ! ( vb -> gN_cache = sk_SRP_gN_cache_new_null ( ) ) ) {
OPENSSL_free ( vb ) ;
return NULL ;
}
vb -> default_g = NULL ;
vb -> default_N = NULL ;
vb -> seed_key = NULL ;
if ( ( seed_key != NULL ) && ( vb -> seed_key = BUF_strdup ( seed_key ) ) == NULL ) {
sk_SRP_user_pwd_free ( vb -> users_pwd ) ;
sk_SRP_gN_cache_free ( vb -> gN_cache ) ;
OPENSSL_free ( vb ) ;
return NULL ;
}
return vb ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
gr_face * hb_graphite2_face_get_gr_face ( hb_face_t * face ) {
if ( unlikely ( ! hb_graphite2_shaper_face_data_ensure ( face ) ) ) return NULL ;
return HB_SHAPER_DATA_GET ( face ) -> grface ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void mp_flush ( MPADecodeContext * ctx ) {
memset ( ctx -> synth_buf , 0 , sizeof ( ctx -> synth_buf ) ) ;
ctx -> last_buf_size = 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void unsigned_relts_print ( netdissect_options * ndo , uint32_t secs ) {
static const char * lengths [ ] = {
"y" , "w" , "d" , "h" , "m" , "s" }
;
static const u_int seconds [ ] = {
31536000 , 604800 , 86400 , 3600 , 60 , 1 }
;
const char * * l = lengths ;
const u_int * s = seconds ;
if ( secs == 0 ) {
ND_PRINT ( ( ndo , "0s" ) ) ;
return ;
}
while ( secs > 0 ) {
if ( secs >= * s ) {
ND_PRINT ( ( ndo , "%d%s" , secs / * s , * l ) ) ;
secs -= ( secs / * s ) * * s ;
}
s ++ ;
l ++ ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( SSLErrorAssistantTest , DynamicInterstitialListOrganizationMismatch ) {
ASSERT_TRUE ( embedded_test_server ( ) -> Start ( ) ) ;
EXPECT_EQ ( 1u , ssl_info ( ) . public_key_hashes . size ( ) ) ;
auto config_proto = std : : make_unique < chrome_browser_ssl : : SSLErrorAssistantConfig > ( ) ;
config_proto -> set_version_id ( kLargeVersionId ) ;
chrome_browser_ssl : : DynamicInterstitial * filter = config_proto -> add_dynamic_interstitial ( ) ;
filter -> set_interstitial_type ( chrome_browser_ssl : : DynamicInterstitial : : INTERSTITIAL_PAGE_SSL ) ;
filter -> set_cert_error ( chrome_browser_ssl : : DynamicInterstitial : : UNKNOWN_CERT_ERROR ) ;
filter -> add_sha256_hash ( "sha256uthatch" ) ;
filter -> add_sha256_hash ( ssl_info ( ) . public_key_hashes [ 0 ] . ToString ( ) ) ;
filter -> add_sha256_hash ( "sha256/treecreeper" ) ;
filter -> set_issuer_common_name_regex ( issuer_common_name ( ) ) ;
filter -> set_issuer_organization_regex ( "beeeater" ) ;
filter -> set_mitm_software_name ( "UwS" ) ;
error_assistant ( ) -> SetErrorAssistantProto ( std : : move ( config_proto ) ) ;
EXPECT_FALSE ( error_assistant ( ) -> MatchDynamicInterstitial ( ssl_info ( ) ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void rfc2231_escape ( string_t * dest , const char * src ) {
for ( ;
* src != '\0' ;
src ++ ) {
if ( * src == '%' ) str_append ( dest , "%25" ) ;
else str_append_c ( dest , * src ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TSAcceptor TSAcceptorGetbyID ( int ID ) {
Debug ( "ssl" , "getNetAccept in INK API.cc %p" , naVec . at ( ID ) ) ;
return reinterpret_cast < TSAcceptor > ( naVec . at ( ID ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void remove_monitor ( NautilusDirectory * directory , NautilusFile * file , gconstpointer client ) {
remove_monitor_link ( directory , find_monitor ( directory , file , client ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int MBS_ApplyPatch ( const MBSPatchHeader * header , int patchfd , unsigned char * fbuffer , int filefd ) {
unsigned char * fbufstart = fbuffer ;
unsigned char * fbufend = fbuffer + header -> slen ;
unsigned char * buf = ( unsigned char * ) malloc ( header -> cblen + header -> difflen + header -> extralen ) ;
if ( ! buf ) return MEM_ERROR ;
int rv = OK ;
int r = header -> cblen + header -> difflen + header -> extralen ;
unsigned char * wb = buf ;
while ( r ) {
int c = read ( patchfd , wb , ( r > SSIZE_MAX ) ? SSIZE_MAX : r ) ;
if ( c < 0 ) {
rv = READ_ERROR ;
goto end ;
}
r -= c ;
wb += c ;
if ( c == 0 && r ) {
rv = UNEXPECTED_ERROR ;
goto end ;
}
}
{
MBSPatchTriple * ctrlsrc = ( MBSPatchTriple * ) buf ;
if ( header -> cblen % sizeof ( MBSPatchTriple ) != 0 ) {
rv = UNEXPECTED_ERROR ;
goto end ;
}
unsigned char * diffsrc = buf + header -> cblen ;
unsigned char * extrasrc = diffsrc + header -> difflen ;
MBSPatchTriple * ctrlend = ( MBSPatchTriple * ) diffsrc ;
unsigned char * diffend = extrasrc ;
unsigned char * extraend = extrasrc + header -> extralen ;
while ( ctrlsrc < ctrlend ) {
ctrlsrc -> x = ntohl ( ctrlsrc -> x ) ;
ctrlsrc -> y = ntohl ( ctrlsrc -> y ) ;
ctrlsrc -> z = ntohl ( ctrlsrc -> z ) ;
# ifdef DEBUG_bsmedberg printf ( "Applying block:\n" " x: %u\n" " y: %u\n" " z: %i\n" , ctrlsrc -> x , ctrlsrc -> y , ctrlsrc -> z ) ;
# endif if ( ctrlsrc -> x > static_cast < size_t > ( fbufend - fbuffer ) || ctrlsrc -> x > static_cast < size_t > ( diffend - diffsrc ) ) {
rv = UNEXPECTED_ERROR ;
goto end ;
}
for ( unsigned int i = 0 ;
i < ctrlsrc -> x ;
++ i ) {
diffsrc [ i ] += fbuffer [ i ] ;
}
if ( ( int ) write ( filefd , diffsrc , ctrlsrc -> x ) != ctrlsrc -> x ) {
rv = WRITE_ERROR ;
goto end ;
}
fbuffer += ctrlsrc -> x ;
diffsrc += ctrlsrc -> x ;
if ( ctrlsrc -> y > static_cast < size_t > ( extraend - extrasrc ) ) {
rv = UNEXPECTED_ERROR ;
goto end ;
}
if ( ( int ) write ( filefd , extrasrc , ctrlsrc -> y ) != ctrlsrc -> y ) {
rv = WRITE_ERROR ;
goto end ;
}
extrasrc += ctrlsrc -> y ;
if ( ctrlsrc -> z < fbufstart - fbuffer || ctrlsrc -> z > fbufend - fbuffer ) {
rv = UNEXPECTED_ERROR ;
goto end ;
}
fbuffer += ctrlsrc -> z ;
++ ctrlsrc ;
}
}
end : free ( buf ) ;
return rv ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void _slurm_rpc_reconfigure_controller ( slurm_msg_t * msg ) {
int error_code = SLURM_SUCCESS ;
static bool in_progress = false ;
DEF_TIMERS ;
slurmctld_lock_t config_write_lock = {
WRITE_LOCK , WRITE_LOCK , WRITE_LOCK , WRITE_LOCK , NO_LOCK }
;
uid_t uid = g_slurm_auth_get_uid ( msg -> auth_cred , slurmctld_config . auth_info ) ;
START_TIMER ;
info ( "Processing RPC: REQUEST_RECONFIGURE from uid=%d" , uid ) ;
if ( ! validate_super_user ( uid ) ) {
error ( "Security violation, RECONFIGURE RPC from uid=%d" , uid ) ;
error_code = ESLURM_USER_ID_MISSING ;
}
if ( in_progress || slurmctld_config . shutdown_time ) error_code = EINPROGRESS ;
if ( error_code == SLURM_SUCCESS ) {
debug ( "sched: begin reconfiguration" ) ;
lock_slurmctld ( config_write_lock ) ;
in_progress = true ;
error_code = read_slurm_conf ( 1 , true ) ;
if ( error_code == SLURM_SUCCESS ) {
_update_cred_key ( ) ;
set_slurmctld_state_loc ( ) ;
msg_to_slurmd ( REQUEST_RECONFIGURE ) ;
}
in_progress = false ;
gs_reconfig ( ) ;
unlock_slurmctld ( config_write_lock ) ;
assoc_mgr_set_missing_uids ( ) ;
start_power_mgr ( & slurmctld_config . thread_id_power ) ;
trigger_reconfig ( ) ;
}
END_TIMER2 ( "_slurm_rpc_reconfigure_controller" ) ;
if ( error_code ) {
error ( "_slurm_rpc_reconfigure_controller: %s" , slurm_strerror ( error_code ) ) ;
slurm_send_rc_msg ( msg , error_code ) ;
}
else {
info ( "_slurm_rpc_reconfigure_controller: completed %s" , TIME_STR ) ;
slurm_send_rc_msg ( msg , SLURM_SUCCESS ) ;
acct_storage_g_reconfig ( acct_db_conn , 0 ) ;
priority_g_reconfig ( false ) ;
save_all_state ( ) ;
queue_job_scheduler ( ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void var_set_string ( const char * name , const char * value ) {
var_set ( name , name + strlen ( name ) , value , value + strlen ( value ) ) ;
}
| 0False
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.