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 gboolean gsm_a_bssmap_stat_packet ( void * tapdata , packet_info * pinfo _U_ , epan_dissect_t * edt _U_ , const void * gatr_ptr ) {
return gsm_a_stat_packet ( tapdata , gatr_ptr , BSSAP_PDU_TYPE_BSSMAP , 0 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
GAppInfo * nautilus_mime_get_default_application_for_files ( GList * files ) {
GList * l , * sorted_files ;
NautilusFile * file ;
GAppInfo * app , * one_app ;
g_assert ( files != NULL ) ;
sorted_files = g_list_sort ( g_list_copy ( files ) , ( GCompareFunc ) file_compare_by_mime_type ) ;
app = NULL ;
for ( l = sorted_files ;
l != NULL ;
l = l -> next ) {
file = l -> data ;
if ( l -> prev && file_compare_by_mime_type ( file , l -> prev -> data ) == 0 && file_compare_by_parent_uri ( file , l -> prev -> data ) == 0 ) {
continue ;
}
one_app = nautilus_mime_get_default_application_for_file ( file ) ;
if ( one_app == NULL || ( app != NULL && ! g_app_info_equal ( app , one_app ) ) ) {
if ( app ) {
g_object_unref ( app ) ;
}
if ( one_app ) {
g_object_unref ( one_app ) ;
}
app = NULL ;
break ;
}
if ( app == NULL ) {
app = one_app ;
}
else {
g_object_unref ( one_app ) ;
}
}
g_list_free ( sorted_files ) ;
return app ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static gboolean ascend_seek_read ( wtap * wth , gint64 seek_off , struct wtap_pkthdr * phdr , Buffer * buf , int * err , gchar * * err_info ) {
ascend_t * ascend = ( ascend_t * ) wth -> priv ;
if ( file_seek ( wth -> random_fh , seek_off , SEEK_SET , err ) == - 1 ) return FALSE ;
if ( parse_ascend ( ascend , wth -> random_fh , phdr , buf , wth -> snapshot_length ) != PARSED_RECORD ) {
* err = WTAP_ERR_BAD_FILE ;
* err_info = g_strdup ( ( ascend_parse_error != NULL ) ? ascend_parse_error : "parse error" ) ;
return FALSE ;
}
return TRUE ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_notify_field ( tvbuff_t * tvb , int offset , packet_info * pinfo , proto_tree * tree , dcerpc_info * di , guint8 * drep , guint16 type , guint16 * data ) {
guint16 field ;
const char * str ;
offset = dissect_ndr_uint16 ( tvb , offset , pinfo , NULL , di , drep , hf_notify_field , & field ) ;
switch ( type ) {
case PRINTER_NOTIFY_TYPE : str = val_to_str_ext_const ( field , & printer_notify_option_data_vals_ext , "Unknown" ) ;
break ;
case JOB_NOTIFY_TYPE : str = val_to_str_ext_const ( field , & job_notify_option_data_vals_ext , "Unknown" ) ;
break ;
default : str = "Unknown notify type" ;
break ;
}
proto_tree_add_uint_format_value ( tree , hf_notify_field , tvb , offset - 2 , 2 , field , "%s (%d)" , str , field ) ;
if ( data ) * data = field ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h225_InfoRequestResponseStatus ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_choice ( tvb , offset , actx , tree , hf_index , ett_h225_InfoRequestResponseStatus , InfoRequestResponseStatus_choice , NULL ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static proto_tree * ptvcursor_add_subtree_item ( ptvcursor_t * ptvc , proto_item * it , gint ett_subtree , gint length ) {
ptvcursor_push_subtree ( ptvc , it , ett_subtree ) ;
if ( length == SUBTREE_UNDEFINED_LENGTH ) ptvcursor_subtree_set_item ( ptvc , it ) ;
return ptvcursor_tree ( ptvc ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h225_Q954Details ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_sequence ( tvb , offset , actx , tree , hf_index , ett_h225_Q954Details , Q954Details_sequence ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static VALUE ossl_asn1_decode ( VALUE self , VALUE obj ) {
VALUE ret ;
unsigned char * p ;
VALUE tmp ;
long len , read = 0 , offset = 0 ;
obj = ossl_to_der_if_possible ( obj ) ;
tmp = rb_str_new4 ( StringValue ( obj ) ) ;
p = ( unsigned char * ) RSTRING_PTR ( tmp ) ;
len = RSTRING_LEN ( tmp ) ;
ret = ossl_asn1_decode0 ( & p , len , & offset , 0 , 0 , & read ) ;
RB_GC_GUARD ( tmp ) ;
int_ossl_decode_sanity_check ( len , read , offset ) ;
return ret ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void pmac_ide_transfer_cb ( void * opaque , int ret ) {
DBDMA_io * io = opaque ;
MACIOIDEState * m = io -> opaque ;
IDEState * s = idebus_active_if ( & m -> bus ) ;
int n = 0 ;
int64_t sector_num ;
int unaligned ;
if ( ret < 0 ) {
MACIO_DPRINTF ( "DMA error\n" ) ;
m -> aiocb = NULL ;
qemu_sglist_destroy ( & s -> sg ) ;
ide_dma_error ( s ) ;
io -> remainder_len = 0 ;
goto done ;
}
if ( -- io -> requests ) {
return ;
}
if ( ! m -> dma_active ) {
MACIO_DPRINTF ( "waiting for data (%#x - %#x - %x)\n" , s -> nsector , io -> len , s -> status ) ;
io -> processing = false ;
return ;
}
sector_num = ide_get_sector ( s ) ;
MACIO_DPRINTF ( "io_buffer_size = %#x\n" , s -> io_buffer_size ) ;
if ( s -> io_buffer_size > 0 ) {
m -> aiocb = NULL ;
qemu_sglist_destroy ( & s -> sg ) ;
n = ( s -> io_buffer_size + 0x1ff ) >> 9 ;
sector_num += n ;
ide_set_sector ( s , sector_num ) ;
s -> nsector -= n ;
}
if ( io -> finish_remain_read ) {
io -> finish_remain_read = false ;
cpu_physical_memory_write ( io -> finish_addr , io -> remainder , io -> finish_len ) ;
}
MACIO_DPRINTF ( "remainder: %d io->len: %d nsector: %d " "sector_num: %" PRId64 "\n" , io -> remainder_len , io -> len , s -> nsector , sector_num ) ;
if ( io -> remainder_len && io -> len ) {
int remainder_len = MIN ( io -> remainder_len , io -> len ) ;
uint8_t * p = & io -> remainder [ 0x200 - remainder_len ] ;
MACIO_DPRINTF ( "copying remainder %d bytes at %#" HWADDR_PRIx "\n" , remainder_len , io -> addr ) ;
switch ( s -> dma_cmd ) {
case IDE_DMA_READ : cpu_physical_memory_write ( io -> addr , p , remainder_len ) ;
break ;
case IDE_DMA_WRITE : cpu_physical_memory_read ( io -> addr , p , remainder_len ) ;
break ;
case IDE_DMA_TRIM : break ;
}
io -> addr += remainder_len ;
io -> len -= remainder_len ;
io -> remainder_len -= remainder_len ;
if ( s -> dma_cmd == IDE_DMA_WRITE && ! io -> remainder_len ) {
io -> requests ++ ;
qemu_iovec_reset ( & io -> iov ) ;
qemu_iovec_add ( & io -> iov , io -> remainder , 0x200 ) ;
m -> aiocb = blk_aio_writev ( s -> blk , sector_num - 1 , & io -> iov , 1 , pmac_ide_transfer_cb , io ) ;
}
}
if ( s -> nsector == 0 && ! io -> remainder_len ) {
MACIO_DPRINTF ( "end of transfer\n" ) ;
s -> status = READY_STAT | SEEK_STAT ;
ide_set_irq ( s -> bus ) ;
m -> dma_active = false ;
}
if ( io -> len == 0 ) {
MACIO_DPRINTF ( "end of DMA\n" ) ;
goto done ;
}
s -> io_buffer_index = 0 ;
s -> io_buffer_size = MIN ( io -> len , s -> nsector * 512 ) ;
unaligned = io -> len & 0x1ff ;
if ( unaligned ) {
int nsector = io -> len >> 9 ;
MACIO_DPRINTF ( "precopying unaligned %d bytes to %#" HWADDR_PRIx "\n" , unaligned , io -> addr + io -> len - unaligned ) ;
switch ( s -> dma_cmd ) {
case IDE_DMA_READ : io -> requests ++ ;
io -> finish_addr = io -> addr + io -> len - unaligned ;
io -> finish_len = unaligned ;
io -> finish_remain_read = true ;
qemu_iovec_reset ( & io -> iov ) ;
qemu_iovec_add ( & io -> iov , io -> remainder , 0x200 ) ;
m -> aiocb = blk_aio_readv ( s -> blk , sector_num + nsector , & io -> iov , 1 , pmac_ide_transfer_cb , io ) ;
break ;
case IDE_DMA_WRITE : cpu_physical_memory_read ( io -> addr + io -> len - unaligned , io -> remainder + io -> remainder_len , unaligned ) ;
break ;
case IDE_DMA_TRIM : break ;
}
}
MACIO_DPRINTF ( "io->len = %#x\n" , io -> len ) ;
qemu_sglist_init ( & s -> sg , DEVICE ( m ) , io -> len / MACIO_PAGE_SIZE + 1 , & address_space_memory ) ;
qemu_sglist_add ( & s -> sg , io -> addr , io -> len ) ;
io -> addr += io -> len + unaligned ;
io -> remainder_len = ( 0x200 - unaligned ) & 0x1ff ;
MACIO_DPRINTF ( "set remainder to: %d\n" , io -> remainder_len ) ;
if ( ! io -> len ) {
if ( ! io -> requests ) {
io -> requests ++ ;
pmac_ide_transfer_cb ( opaque , ret ) ;
}
return ;
}
io -> len = 0 ;
MACIO_DPRINTF ( "sector_num=%" PRId64 " n=%d, nsector=%d, cmd_cmd=%d\n" , sector_num , n , s -> nsector , s -> dma_cmd ) ;
switch ( s -> dma_cmd ) {
case IDE_DMA_READ : m -> aiocb = dma_blk_read ( s -> blk , & s -> sg , sector_num , pmac_ide_transfer_cb , io ) ;
break ;
case IDE_DMA_WRITE : m -> aiocb = dma_blk_write ( s -> blk , & s -> sg , sector_num , pmac_ide_transfer_cb , io ) ;
break ;
case IDE_DMA_TRIM : m -> aiocb = dma_blk_io ( s -> blk , & s -> sg , sector_num , ide_issue_trim , pmac_ide_transfer_cb , io , DMA_DIRECTION_TO_DEVICE ) ;
break ;
}
io -> requests ++ ;
return ;
done : if ( s -> dma_cmd == IDE_DMA_READ || s -> dma_cmd == IDE_DMA_WRITE ) {
block_acct_done ( blk_get_stats ( s -> blk ) , & s -> acct ) ;
}
io -> dma_end ( io ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
gboolean rtp_dyn_payload_remove ( rtp_dyn_payload_t * rtp_dyn_payload , const guint8 pt ) {
return ( rtp_dyn_payload && rtp_dyn_payload -> table && g_hash_table_remove ( rtp_dyn_payload -> table , GUINT_TO_POINTER ( pt ) ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int mainwindow_rgrow ( MAIN_WINDOW_REC * window , int count ) {
if ( ! try_rshrink_right ( window , count ) ) {
if ( ! try_rshrink_left ( window , count ) ) return FALSE ;
}
return TRUE ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void idct4 ( const int16_t * input , int16_t * output ) {
int16_t step [ 4 ] ;
int temp1 , temp2 ;
temp1 = ( input [ 0 ] + input [ 2 ] ) * cospi_16_64 ;
temp2 = ( input [ 0 ] - input [ 2 ] ) * cospi_16_64 ;
step [ 0 ] = dct_const_round_shift ( temp1 ) ;
step [ 1 ] = dct_const_round_shift ( temp2 ) ;
temp1 = input [ 1 ] * cospi_24_64 - input [ 3 ] * cospi_8_64 ;
temp2 = input [ 1 ] * cospi_8_64 + input [ 3 ] * cospi_24_64 ;
step [ 2 ] = dct_const_round_shift ( temp1 ) ;
step [ 3 ] = dct_const_round_shift ( temp2 ) ;
output [ 0 ] = step [ 0 ] + step [ 3 ] ;
output [ 1 ] = step [ 1 ] + step [ 2 ] ;
output [ 2 ] = step [ 1 ] - step [ 2 ] ;
output [ 3 ] = step [ 0 ] - step [ 3 ] ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void pdo_stmt_iter_move_forwards ( zend_object_iterator * iter TSRMLS_DC ) {
struct php_pdo_iterator * I = ( struct php_pdo_iterator * ) iter -> data ;
if ( I -> fetch_ahead ) {
zval_ptr_dtor ( & I -> fetch_ahead ) ;
I -> fetch_ahead = NULL ;
}
MAKE_STD_ZVAL ( I -> fetch_ahead ) ;
if ( ! do_fetch ( I -> stmt , TRUE , I -> fetch_ahead , PDO_FETCH_USE_DEFAULT , PDO_FETCH_ORI_NEXT , 0 , 0 TSRMLS_CC ) ) {
pdo_stmt_t * stmt = I -> stmt ;
PDO_HANDLE_STMT_ERR ( ) ;
I -> key = ( ulong ) - 1 ;
FREE_ZVAL ( I -> fetch_ahead ) ;
I -> fetch_ahead = NULL ;
return ;
}
I -> key ++ ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static UChar32 U_CALLCONV _UTF16LEGetNextUChar ( UConverterToUnicodeArgs * pArgs , UErrorCode * err ) {
const uint8_t * s , * sourceLimit ;
UChar32 c ;
if ( pArgs -> converter -> mode < 8 ) {
return UCNV_GET_NEXT_UCHAR_USE_TO_U ;
}
s = ( const uint8_t * ) pArgs -> source ;
sourceLimit = ( const uint8_t * ) pArgs -> sourceLimit ;
if ( s >= sourceLimit ) {
* err = U_INDEX_OUTOFBOUNDS_ERROR ;
return 0xffff ;
}
if ( s + 2 > sourceLimit ) {
pArgs -> converter -> toUBytes [ 0 ] = * s ++ ;
pArgs -> converter -> toULength = 1 ;
pArgs -> source = ( const char * ) s ;
* err = U_TRUNCATED_CHAR_FOUND ;
return 0xffff ;
}
c = ( ( UChar32 ) s [ 1 ] << 8 ) | * s ;
s += 2 ;
if ( U_IS_SURROGATE ( c ) ) {
if ( U16_IS_SURROGATE_LEAD ( c ) ) {
if ( s + 2 <= sourceLimit ) {
UChar trail ;
trail = ( ( UChar ) s [ 1 ] << 8 ) | * s ;
if ( U16_IS_TRAIL ( trail ) ) {
c = U16_GET_SUPPLEMENTARY ( c , trail ) ;
s += 2 ;
}
else {
c = - 2 ;
}
}
else {
uint8_t * bytes = pArgs -> converter -> toUBytes ;
s -= 2 ;
pArgs -> converter -> toULength = ( int8_t ) ( sourceLimit - s ) ;
do {
* bytes ++ = * s ++ ;
}
while ( s < sourceLimit ) ;
c = 0xffff ;
* err = U_TRUNCATED_CHAR_FOUND ;
}
}
else {
c = - 2 ;
}
if ( c < 0 ) {
uint8_t * bytes = pArgs -> converter -> toUBytes ;
pArgs -> converter -> toULength = 2 ;
* bytes = * ( s - 2 ) ;
bytes [ 1 ] = * ( s - 1 ) ;
c = 0xffff ;
* err = U_ILLEGAL_CHAR_FOUND ;
}
}
pArgs -> source = ( const char * ) s ;
return c ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vpx_svc_release ( SvcContext * svc_ctx ) {
SvcInternal * si ;
if ( svc_ctx == NULL ) return ;
si = ( SvcInternal * ) svc_ctx -> internal ;
if ( si != NULL ) {
free ( si ) ;
svc_ctx -> internal = NULL ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void parseExtensionObject ( proto_tree * tree , tvbuff_t * tvb , packet_info * pinfo , gint * pOffset , const char * szFieldName ) {
static const int * extobj_mask [ ] = {
& hf_opcua_extobj_mask_binbodyflag , & hf_opcua_extobj_mask_xmlbodyflag , NULL }
;
gint iOffset = * pOffset ;
guint8 EncodingMask ;
guint32 TypeId ;
proto_tree * extobj_tree ;
proto_item * ti ;
guint opcua_nested_count ;
extobj_tree = proto_tree_add_subtree_format ( tree , tvb , * pOffset , - 1 , ett_opcua_extensionobject , & ti , "%s: ExtensionObject" , szFieldName ) ;
opcua_nested_count = GPOINTER_TO_UINT ( p_get_proto_data ( pinfo -> pool , pinfo , proto_opcua , 0 ) ) ;
if ( ++ opcua_nested_count > MAX_NESTING_DEPTH ) {
expert_add_info ( pinfo , ti , & ei_nesting_depth ) ;
return ;
}
p_add_proto_data ( pinfo -> pool , pinfo , proto_opcua , 0 , GUINT_TO_POINTER ( opcua_nested_count ) ) ;
TypeId = getExtensionObjectType ( tvb , & iOffset ) ;
parseExpandedNodeId ( extobj_tree , tvb , pinfo , & iOffset , "TypeId" ) ;
EncodingMask = tvb_get_guint8 ( tvb , iOffset ) ;
proto_tree_add_bitmask ( extobj_tree , tvb , iOffset , hf_opcua_extobj_mask , ett_opcua_extensionobject_encodingmask , extobj_mask , ENC_LITTLE_ENDIAN ) ;
iOffset ++ ;
if ( EncodingMask & EXTOBJ_ENCODINGMASK_BINBODY_FLAG ) {
dispatchExtensionObjectType ( extobj_tree , tvb , pinfo , & iOffset , TypeId ) ;
}
proto_item_set_end ( ti , tvb , iOffset ) ;
* pOffset = iOffset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( SessionRestorePageLoadMetricsBrowserTest , SingleTabSessionRestore ) {
ui_test_utils : : NavigateToURL ( browser ( ) , GetTestURL ( ) ) ;
SessionRestorePaintWaiter session_restore_paint_waiter ;
QuitBrowserAndRestore ( browser ( ) ) ;
session_restore_paint_waiter . WaitForForegroundTabs ( 1 ) ;
ExpectFirstPaintMetricsTotalCount ( 1 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dsa_pub_print ( BIO * bp , const EVP_PKEY * pkey , int indent , ASN1_PCTX * ctx ) {
return do_dsa_print ( bp , pkey -> pkey . dsa , indent , 1 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int qemuAssignDeviceNetAlias ( virDomainDefPtr def , virDomainNetDefPtr net , int idx ) {
if ( networkGetActualType ( net ) == VIR_DOMAIN_NET_TYPE_HOSTDEV ) return qemuAssignDeviceHostdevAlias ( def , & net -> info . alias , - 1 ) ;
if ( idx == - 1 ) {
size_t i ;
idx = 0 ;
for ( i = 0 ;
i < def -> nnets ;
i ++ ) {
int thisidx ;
if ( ( thisidx = qemuDomainDeviceAliasIndex ( & def -> nets [ i ] -> info , "net" ) ) < 0 ) continue ;
if ( thisidx >= idx ) idx = thisidx + 1 ;
}
}
if ( virAsprintf ( & net -> info . alias , "net%d" , idx ) < 0 ) return - 1 ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
struct message_search_context * message_search_init ( const char * normalized_key_utf8 , normalizer_func_t * normalizer , enum message_search_flags flags ) {
struct message_search_context * ctx ;
i_assert ( * normalized_key_utf8 != '\0' ) ;
ctx = i_new ( struct message_search_context , 1 ) ;
ctx -> flags = flags ;
ctx -> decoder = message_decoder_init ( normalizer , 0 ) ;
ctx -> str_find_ctx = str_find_init ( default_pool , normalized_key_utf8 ) ;
return ctx ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void ff_init_qscale_tab ( MpegEncContext * s ) {
int8_t * const qscale_table = s -> current_picture . f . qscale_table ;
int i ;
for ( i = 0 ;
i < s -> mb_num ;
i ++ ) {
unsigned int lam = s -> lambda_table [ s -> mb_index2xy [ i ] ] ;
int qp = ( lam * 139 + FF_LAMBDA_SCALE * 64 ) >> ( FF_LAMBDA_SHIFT + 7 ) ;
qscale_table [ s -> mb_index2xy [ i ] ] = av_clip ( qp , s -> avctx -> qmin , s -> avctx -> qmax ) ;
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
extern rtype gnu_dev_ ## name proto __THROW __attribute_const__ ;
# define __SYSMACROS_IMPL_TEMPL ( rtype , name , proto ) __extension__ __extern_inline __attribute_const__ rtype __NTH ( gnu_dev_ ## name proto ) __BEGIN_DECLS __SYSMACROS_DECLARE_MAJOR ( __SYSMACROS_DECL_TEMPL ) __SYSMACROS_DECLARE_MINOR ( __SYSMACROS_DECL_TEMPL )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int dissect_ber_GeneralizedTime ( gboolean implicit_tag , asn1_ctx_t * actx , proto_tree * tree , tvbuff_t * tvb , int offset , gint hf_id ) {
char str [ 35 ] ;
int tmp_int ;
const guint8 * tmpstr ;
char * strptr ;
char first_delim [ 2 ] ;
int first_digits ;
char second_delim [ 2 ] ;
int second_digits ;
int ret ;
gint8 ber_class ;
gboolean pc ;
gint32 tag ;
guint32 len ;
int end_offset ;
int hoffset ;
proto_item * cause ;
if ( ! implicit_tag ) {
hoffset = offset ;
offset = dissect_ber_identifier ( actx -> pinfo , tree , tvb , offset , & ber_class , & pc , & tag ) ;
offset = dissect_ber_length ( actx -> pinfo , tree , tvb , offset , & len , NULL ) ;
end_offset = offset + len ;
if ( ( ber_class != BER_CLASS_UNI ) || ( tag != BER_UNI_TAG_GeneralizedTime ) ) {
tvb_ensure_bytes_exist ( tvb , hoffset , 2 ) ;
cause = proto_tree_add_string_format_value ( tree , hf_ber_error , tvb , offset , len , "generalized_time_expected" , "GeneralizedTime expected but class:%s(%d) %s tag:%d was unexpected" , val_to_str_const ( ber_class , ber_class_codes , "Unknown" ) , ber_class , pc ? ber_pc_codes_short . true_string : ber_pc_codes_short . false_string , tag ) ;
expert_add_info ( actx -> pinfo , cause , & ei_ber_expected_generalized_time ) ;
if ( decode_unexpected ) {
proto_tree * unknown_tree = proto_item_add_subtree ( cause , ett_ber_unknown ) ;
dissect_unknown_ber ( actx -> pinfo , tvb , hoffset , unknown_tree ) ;
}
return end_offset ;
}
}
else {
len = tvb_reported_length_remaining ( tvb , offset ) ;
end_offset = offset + len ;
}
if ( ( len < 14 ) || ( len > 23 ) ) {
cause = proto_tree_add_string_format_value ( tree , hf_ber_error , tvb , offset , len , "illegal_length" , "GeneralizedTime invalid length: %u" , len ) ;
expert_add_info_format ( actx -> pinfo , cause , & ei_ber_error_length , "BER Error: GeneralizedTime invalid length" ) ;
if ( decode_unexpected ) {
proto_tree * unknown_tree = proto_item_add_subtree ( cause , ett_ber_unknown ) ;
dissect_unknown_ber ( actx -> pinfo , tvb , offset , unknown_tree ) ;
}
return end_offset ;
}
tmpstr = tvb_get_string_enc ( wmem_packet_scope ( ) , tvb , offset , len , ENC_ASCII ) ;
strptr = str ;
strptr += g_snprintf ( str , 20 , "%.4s-%.2s-%.2s %.2s:%.2s:%.2s" , tmpstr , tmpstr + 4 , tmpstr + 6 , tmpstr + 8 , tmpstr + 10 , tmpstr + 12 ) ;
first_delim [ 0 ] = 0 ;
second_delim [ 0 ] = 0 ;
ret = sscanf ( tmpstr , "%14d%1[.,+-Z]%4d%1[+-Z]%4d" , & tmp_int , first_delim , & first_digits , second_delim , & second_digits ) ;
if ( ret < 1 ) {
cause = proto_tree_add_string_format_value ( tree , hf_ber_error , tvb , offset , len , "invalid_generalized_time" , "GeneralizedTime invalid format: %s" , tmpstr ) ;
expert_add_info ( actx -> pinfo , cause , & ei_ber_invalid_format_generalized_time ) ;
if ( decode_unexpected ) {
proto_tree * unknown_tree = proto_item_add_subtree ( cause , ett_ber_unknown ) ;
dissect_unknown_ber ( actx -> pinfo , tvb , offset , unknown_tree ) ;
}
return end_offset ;
}
switch ( first_delim [ 0 ] ) {
case '.' : case ',' : strptr += g_snprintf ( strptr , 5 , "%c%.3d" , first_delim [ 0 ] , first_digits ) ;
switch ( second_delim [ 0 ] ) {
case '+' : case '-' : g_snprintf ( strptr , 12 , " (UTC%c%.4d)" , second_delim [ 0 ] , second_digits ) ;
break ;
case 'Z' : g_snprintf ( strptr , 7 , " (UTC)" ) ;
break ;
case 0 : break ;
default : break ;
}
break ;
case '+' : case '-' : g_snprintf ( strptr , 12 , " (UTC%c%.4d)" , first_delim [ 0 ] , first_digits ) ;
break ;
case 'Z' : g_snprintf ( strptr , 7 , " (UTC)" ) ;
break ;
case 0 : break ;
default : break ;
}
if ( hf_id >= 0 ) {
proto_tree_add_string ( tree , hf_id , tvb , offset , len , str ) ;
}
offset += len ;
return offset ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
const char * proto_get_protocol_long_name ( const protocol_t * protocol ) {
if ( protocol == NULL ) return "(none)" ;
return protocol -> name ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static DeviceState * qdev_find_recursive ( BusState * bus , const char * id ) {
DeviceState * dev , * ret ;
BusState * child ;
QLIST_FOREACH ( dev , & bus -> children , sibling ) {
if ( dev -> id && strcmp ( dev -> id , id ) == 0 ) return dev ;
QLIST_FOREACH ( child , & dev -> child_bus , sibling ) {
ret = qdev_find_recursive ( child , id ) ;
if ( ret ) {
return ret ;
}
}
}
return NULL ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( ContentFaviconDriverTest , AssociateIconWithInitialPageIconDespitePushState ) {
ASSERT_TRUE ( embedded_test_server ( ) -> Start ( ) ) ;
GURL url = embedded_test_server ( ) -> GetURL ( "/favicon/pushstate_with_favicon.html" ) ;
GURL pushstate_url = embedded_test_server ( ) -> GetURL ( "/favicon/pushstate_with_favicon_pushed.html" ) ;
PendingTaskWaiter waiter ( web_contents ( ) ) ;
waiter . AlsoRequireUrl ( pushstate_url ) ;
ui_test_utils : : NavigateToURLWithDisposition ( browser ( ) , url , WindowOpenDisposition : : CURRENT_TAB , ui_test_utils : : BROWSER_TEST_NONE ) ;
waiter . Wait ( ) ;
EXPECT_NE ( nullptr , GetFaviconForPageURL ( url , favicon_base : : IconType : : kFavicon ) . bitmap_data ) ;
EXPECT_NE ( nullptr , GetFaviconForPageURL ( pushstate_url , favicon_base : : IconType : : kFavicon ) . bitmap_data ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline void U_EXPORT2 utimer_getTime ( UTimer * timer ) {
uprv_initFrequency ( timer ) ;
uprv_start ( timer ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( SupervisedUserNavigationThrottleNotSupervisedTest , DontBlock ) {
BlockHost ( kExampleHost ) ;
WebContents * tab = browser ( ) -> tab_strip_model ( ) -> GetActiveWebContents ( ) ;
GURL blocked_url = embedded_test_server ( ) -> GetURL ( kExampleHost , "/supervised_user/simple.html" ) ;
ui_test_utils : : NavigateToURL ( browser ( ) , blocked_url ) ;
EXPECT_FALSE ( tab -> ShowingInterstitialPage ( ) ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static uint32_t e1000e_rss_calc_hash ( E1000ECore * core , struct NetRxPkt * pkt , E1000E_RSSInfo * info ) {
NetRxPktRssType type ;
assert ( e1000e_rss_enabled ( core ) ) ;
switch ( info -> type ) {
case E1000_MRQ_RSS_TYPE_IPV4 : type = NetPktRssIpV4 ;
break ;
case E1000_MRQ_RSS_TYPE_IPV4TCP : type = NetPktRssIpV4Tcp ;
break ;
case E1000_MRQ_RSS_TYPE_IPV6TCP : type = NetPktRssIpV6Tcp ;
break ;
case E1000_MRQ_RSS_TYPE_IPV6 : type = NetPktRssIpV6 ;
break ;
case E1000_MRQ_RSS_TYPE_IPV6EX : type = NetPktRssIpV6Ex ;
break ;
default : assert ( false ) ;
return 0 ;
}
return net_rx_pkt_calc_rss_hash ( pkt , type , ( uint8_t * ) & core -> mac [ RSSRK ] ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void evdns_set_log_fn ( evdns_debug_log_fn_type fn ) {
evdns_log_fn = fn ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void openpic_save ( QEMUFile * f , void * opaque ) {
OpenPICState * opp = ( OpenPICState * ) opaque ;
unsigned int i ;
qemu_put_be32s ( f , & opp -> gcr ) ;
qemu_put_be32s ( f , & opp -> vir ) ;
qemu_put_be32s ( f , & opp -> pir ) ;
qemu_put_be32s ( f , & opp -> spve ) ;
qemu_put_be32s ( f , & opp -> tfrr ) ;
qemu_put_be32s ( f , & opp -> nb_cpus ) ;
for ( i = 0 ;
i < opp -> nb_cpus ;
i ++ ) {
qemu_put_sbe32s ( f , & opp -> dst [ i ] . ctpr ) ;
openpic_save_IRQ_queue ( f , & opp -> dst [ i ] . raised ) ;
openpic_save_IRQ_queue ( f , & opp -> dst [ i ] . servicing ) ;
qemu_put_buffer ( f , ( uint8_t * ) & opp -> dst [ i ] . outputs_active , sizeof ( opp -> dst [ i ] . outputs_active ) ) ;
}
for ( i = 0 ;
i < OPENPIC_MAX_TMR ;
i ++ ) {
qemu_put_be32s ( f , & opp -> timers [ i ] . tccr ) ;
qemu_put_be32s ( f , & opp -> timers [ i ] . tbcr ) ;
}
for ( i = 0 ;
i < opp -> max_irq ;
i ++ ) {
qemu_put_be32s ( f , & opp -> src [ i ] . ivpr ) ;
qemu_put_be32s ( f , & opp -> src [ i ] . idr ) ;
qemu_get_be32s ( f , & opp -> src [ i ] . destmask ) ;
qemu_put_sbe32s ( f , & opp -> src [ i ] . last_cpu ) ;
qemu_put_sbe32s ( f , & opp -> src [ i ] . pending ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int unistim_calls_packet ( void * ptr _U_ , packet_info * pinfo , epan_dissect_t * edt _U_ , const void * unistim_info ) {
voip_calls_tapinfo_t * tapinfo = & the_tapinfo_struct ;
voip_calls_info_t * tmp_listinfo ;
voip_calls_info_t * callsinfo = NULL ;
unistim_info_t * tmp_unistim_info = NULL ;
GList * list = NULL ;
GString * g_tmp = NULL ;
const gchar * frame_label = NULL ;
gchar * comment = NULL ;
const unistim_info_t * pi = ( const unistim_info_t * ) unistim_info ;
g_tmp = g_string_new ( NULL ) ;
list = g_list_first ( tapinfo -> callsinfo_list ) ;
while ( list ) {
tmp_listinfo = ( voip_calls_info_t * ) list -> data ;
if ( tmp_listinfo -> protocol == VOIP_UNISTIM ) {
tmp_unistim_info = ( unistim_info_t * ) tmp_listinfo -> prot_info ;
if ( pi -> termid != 0 ) {
if ( tmp_unistim_info -> termid == pi -> termid ) {
if ( tmp_listinfo -> call_state == VOIP_COMPLETED || tmp_listinfo -> call_state == VOIP_UNKNOWN ) {
}
else {
callsinfo = ( voip_calls_info_t * ) ( list -> data ) ;
break ;
}
}
}
else {
if ( ADDRESSES_EQUAL ( & tmp_unistim_info -> it_ip , & pinfo -> dst ) && ADDRESSES_EQUAL ( & tmp_unistim_info -> ni_ip , & pinfo -> src ) && ( tmp_unistim_info -> it_port == pinfo -> destport ) ) {
if ( tmp_listinfo -> call_state == VOIP_COMPLETED || tmp_listinfo -> call_state == VOIP_UNKNOWN ) {
}
else {
callsinfo = ( voip_calls_info_t * ) ( list -> data ) ;
break ;
}
}
else if ( ADDRESSES_EQUAL ( & tmp_unistim_info -> it_ip , & pinfo -> src ) && ADDRESSES_EQUAL ( & tmp_unistim_info -> ni_ip , & pinfo -> dst ) && ( tmp_unistim_info -> it_port == pinfo -> srcport ) ) {
if ( tmp_listinfo -> call_state == VOIP_COMPLETED || tmp_listinfo -> call_state == VOIP_UNKNOWN ) {
}
else {
callsinfo = ( voip_calls_info_t * ) ( list -> data ) ;
break ;
}
}
}
}
list = g_list_next ( list ) ;
}
if ( pi -> payload_type == 2 || pi -> payload_type == 1 ) {
if ( pi -> key_state == 1 || pi -> hook_state == 1 ) {
if ( callsinfo == NULL ) {
callsinfo = ( voip_calls_info_t * ) g_malloc0 ( sizeof ( voip_calls_info_t ) ) ;
callsinfo -> call_active_state = VOIP_ACTIVE ;
callsinfo -> call_state = VOIP_CALL_SETUP ;
callsinfo -> from_identity = g_strdup_printf ( "%x" , pi -> termid ) ;
callsinfo -> to_identity = g_strdup ( "UNKNOWN" ) ;
COPY_ADDRESS ( & ( callsinfo -> initial_speaker ) , & ( pinfo -> src ) ) ;
callsinfo -> selected = FALSE ;
callsinfo -> start_fd = pinfo -> fd ;
callsinfo -> start_rel_ts = pinfo -> rel_ts ;
callsinfo -> protocol = VOIP_UNISTIM ;
callsinfo -> prot_info = g_malloc ( sizeof ( unistim_info_t ) ) ;
tmp_unistim_info = ( unistim_info_t * ) callsinfo -> prot_info ;
tmp_unistim_info -> rudp_type = 0 ;
tmp_unistim_info -> payload_type = 0 ;
tmp_unistim_info -> sequence = pi -> sequence ;
tmp_unistim_info -> termid = pi -> termid ;
tmp_unistim_info -> key_val = - 1 ;
tmp_unistim_info -> key_state = - 1 ;
tmp_unistim_info -> hook_state = - 1 ;
tmp_unistim_info -> stream_connect = - 1 ;
tmp_unistim_info -> trans_connect = - 1 ;
tmp_unistim_info -> set_termid = - 1 ;
tmp_unistim_info -> string_data = NULL ;
tmp_unistim_info -> key_buffer = NULL ;
COPY_ADDRESS ( & ( tmp_unistim_info -> it_ip ) , & ( pi -> it_ip ) ) ;
COPY_ADDRESS ( & ( tmp_unistim_info -> ni_ip ) , & ( pi -> ni_ip ) ) ;
tmp_unistim_info -> it_port = pi -> it_port ;
callsinfo -> free_prot_info = g_free ;
callsinfo -> npackets = 0 ;
callsinfo -> call_num = tapinfo -> ncalls ++ ;
tapinfo -> callsinfo_list = g_list_prepend ( tapinfo -> callsinfo_list , callsinfo ) ;
}
else {
tmp_unistim_info = ( unistim_info_t * ) callsinfo -> prot_info ;
tmp_unistim_info -> sequence = pi -> sequence ;
}
callsinfo -> stop_fd = pinfo -> fd ;
callsinfo -> stop_rel_ts = pinfo -> rel_ts ;
++ ( callsinfo -> npackets ) ;
++ ( tapinfo -> npackets ) ;
if ( pi -> key_val >= 0 && pi -> key_val <= 11 ) {
if ( tmp_unistim_info -> key_buffer != NULL ) {
g_string_assign ( g_tmp , tmp_unistim_info -> key_buffer ) ;
if ( pi -> key_val == 10 ) {
tmp_unistim_info -> key_buffer = g_strdup_printf ( "%s*" , g_tmp -> str ) ;
}
else if ( pi -> key_val == 11 ) {
tmp_unistim_info -> key_buffer = g_strdup_printf ( "%s#" , g_tmp -> str ) ;
}
else {
tmp_unistim_info -> key_buffer = g_strdup_printf ( "%s%d" , g_tmp -> str , pi -> key_val ) ;
}
}
else {
if ( pi -> key_val == 10 ) {
tmp_unistim_info -> key_buffer = g_strdup ( "*" ) ;
}
else if ( pi -> key_val == 11 ) {
tmp_unistim_info -> key_buffer = g_strdup ( "#" ) ;
}
else {
tmp_unistim_info -> key_buffer = g_strdup_printf ( "%d" , pi -> key_val ) ;
}
}
if ( pi -> key_val == 10 ) {
comment = g_strdup_printf ( "Key Input Sent: * (%d)" , pi -> sequence ) ;
}
else if ( pi -> key_val == 11 ) {
comment = g_strdup_printf ( "Key Input Sent: # (%d)" , pi -> sequence ) ;
}
else {
comment = g_strdup_printf ( "Key Input Sent: %d (%d)" , pi -> key_val , pi -> sequence ) ;
}
}
else if ( pi -> key_val == 12 ) {
comment = g_strdup_printf ( "Key Input Sent: UP (%d)" , pi -> sequence ) ;
}
else if ( pi -> key_val == 13 ) {
comment = g_strdup_printf ( "Key Input Sent: DOWN (%d)" , pi -> sequence ) ;
}
else if ( pi -> key_val == 14 ) {
comment = g_strdup_printf ( "Key Input Sent: RIGHT (%d)" , pi -> sequence ) ;
}
else if ( pi -> key_val == 15 ) {
if ( pi -> key_buffer != NULL ) {
g_string_assign ( g_tmp , pi -> key_buffer ) ;
g_string_truncate ( g_tmp , g_tmp -> len - 1 ) ;
tmp_unistim_info -> key_buffer = g_strdup ( g_tmp -> str ) ;
}
comment = g_strdup_printf ( "Key Input Sent: LEFT (%d)" , pi -> sequence ) ;
}
else if ( pi -> key_val == 20 ) {
comment = g_strdup_printf ( "Key Input Sent: S0 (%d)" , pi -> sequence ) ;
}
else if ( pi -> key_val == 21 ) {
comment = g_strdup_printf ( "Key Input Sent: S1 (%d)" , pi -> sequence ) ;
}
else if ( pi -> key_val == 22 ) {
if ( pi -> key_buffer != NULL ) {
g_string_assign ( g_tmp , pi -> key_buffer ) ;
g_string_truncate ( g_tmp , g_tmp -> len - 1 ) ;
tmp_unistim_info -> key_buffer = g_strdup ( g_tmp -> str ) ;
}
comment = g_strdup_printf ( "Key Input Sent: S2 (%d)" , pi -> sequence ) ;
}
else if ( pi -> key_val == 28 ) {
comment = g_strdup_printf ( "Key Input Sent: Release (%d)" , pi -> sequence ) ;
}
else if ( pi -> key_val == 23 ) {
tmp_unistim_info -> key_buffer = g_strdup ( "\n" ) ;
comment = g_strdup_printf ( "Key Input Sent: S3 (%d)" , pi -> sequence ) ;
}
else if ( pi -> key_val == 27 ) {
comment = g_strdup_printf ( "Key Input Sent: Hold (%d)" , pi -> sequence ) ;
}
else if ( pi -> key_val == 29 ) {
comment = g_strdup_printf ( "Key Input Sent: Mute (%d)" , pi -> sequence ) ;
}
else if ( pi -> key_val == 30 ) {
comment = g_strdup_printf ( "Key Input Sent: Headset (%d)" , pi -> sequence ) ;
}
else if ( pi -> key_val == 31 ) {
comment = g_strdup_printf ( "Key Input Sent: Handsfree (%d)" , pi -> sequence ) ;
}
else if ( pi -> key_val >= 32 && pi -> key_val <= 56 ) {
comment = g_strdup_printf ( "Key Input Sent: Prog%d (%d)" , ( pi -> key_val & 31 ) , pi -> sequence ) ;
}
if ( pi -> key_val != - 1 ) {
frame_label = "KEY INPUT" ;
if ( comment == NULL ) comment = g_strdup_printf ( "Key Input Sent: UNKNOWN - %d (%d)" , pi -> key_val , pi -> sequence ) ;
add_to_graph ( tapinfo , pinfo , frame_label , comment , callsinfo -> call_num , & ( pinfo -> src ) , & ( pinfo -> dst ) , 1 ) ;
g_free ( comment ) ;
}
if ( pi -> hook_state == 1 ) {
frame_label = "OFF HOOK" ;
comment = g_strdup_printf ( "Off Hook (%d)" , pi -> sequence ) ;
add_to_graph ( tapinfo , pinfo , frame_label , comment , callsinfo -> call_num , & ( pinfo -> src ) , & ( pinfo -> dst ) , 1 ) ;
g_free ( comment ) ;
}
else if ( pi -> hook_state == 0 ) {
frame_label = "ON HOOK" ;
comment = g_strdup_printf ( "On Hook (%d)" , pi -> sequence ) ;
add_to_graph ( tapinfo , pinfo , frame_label , comment , callsinfo -> call_num , & ( pinfo -> src ) , & ( pinfo -> dst ) , 1 ) ;
g_free ( comment ) ;
}
}
if ( pi -> stream_connect == 1 && callsinfo != NULL ) {
callsinfo -> start_fd = pinfo -> fd ;
callsinfo -> start_rel_ts = pinfo -> rel_ts ;
callsinfo -> stop_fd = pinfo -> fd ;
callsinfo -> stop_rel_ts = pinfo -> rel_ts ;
++ ( callsinfo -> npackets ) ;
++ ( tapinfo -> npackets ) ;
if ( tmp_unistim_info -> key_buffer != NULL ) {
callsinfo -> to_identity = g_strdup_printf ( "?? %s" , tmp_unistim_info -> key_buffer ) ;
}
tmp_unistim_info -> sequence = pi -> sequence ;
callsinfo -> call_active_state = VOIP_ACTIVE ;
callsinfo -> call_state = VOIP_IN_CALL ;
frame_label = "STREAM OPENED" ;
comment = g_strdup_printf ( "Stream Opened (%d)" , pi -> sequence ) ;
add_to_graph ( tapinfo , pinfo , frame_label , comment , callsinfo -> call_num , & ( pinfo -> src ) , & ( pinfo -> dst ) , 1 ) ;
}
else if ( pi -> stream_connect == 1 && callsinfo == NULL ) {
callsinfo = ( voip_calls_info_t * ) g_malloc0 ( sizeof ( voip_calls_info_t ) ) ;
callsinfo -> call_active_state = VOIP_ACTIVE ;
callsinfo -> call_state = VOIP_CALL_SETUP ;
callsinfo -> from_identity = g_strdup ( "UNKNOWN" ) ;
callsinfo -> to_identity = g_strdup ( "UNKNOWN" ) ;
COPY_ADDRESS ( & ( callsinfo -> initial_speaker ) , & ( pinfo -> src ) ) ;
callsinfo -> selected = FALSE ;
callsinfo -> start_fd = pinfo -> fd ;
callsinfo -> start_rel_ts = pinfo -> rel_ts ;
callsinfo -> protocol = VOIP_UNISTIM ;
callsinfo -> prot_info = g_malloc ( sizeof ( unistim_info_t ) ) ;
tmp_unistim_info = ( unistim_info_t * ) callsinfo -> prot_info ;
tmp_unistim_info -> rudp_type = 0 ;
tmp_unistim_info -> payload_type = 0 ;
tmp_unistim_info -> sequence = pi -> sequence ;
tmp_unistim_info -> termid = 0 ;
tmp_unistim_info -> key_val = - 1 ;
tmp_unistim_info -> key_state = - 1 ;
tmp_unistim_info -> hook_state = - 1 ;
tmp_unistim_info -> stream_connect = - 1 ;
tmp_unistim_info -> trans_connect = - 1 ;
tmp_unistim_info -> set_termid = - 1 ;
tmp_unistim_info -> string_data = NULL ;
tmp_unistim_info -> key_buffer = NULL ;
COPY_ADDRESS ( & ( tmp_unistim_info -> it_ip ) , & ( pi -> it_ip ) ) ;
COPY_ADDRESS ( & ( tmp_unistim_info -> ni_ip ) , & ( pi -> ni_ip ) ) ;
tmp_unistim_info -> it_port = pi -> it_port ;
callsinfo -> free_prot_info = g_free ;
callsinfo -> npackets = 0 ;
callsinfo -> call_num = tapinfo -> ncalls ++ ;
tapinfo -> callsinfo_list = g_list_prepend ( tapinfo -> callsinfo_list , callsinfo ) ;
callsinfo -> stop_fd = pinfo -> fd ;
callsinfo -> stop_rel_ts = pinfo -> rel_ts ;
++ ( callsinfo -> npackets ) ;
++ ( tapinfo -> npackets ) ;
if ( tmp_unistim_info -> key_buffer != NULL ) {
callsinfo -> to_identity = g_strdup_printf ( "?? %s" , tmp_unistim_info -> key_buffer ) ;
}
tmp_unistim_info -> sequence = pi -> sequence ;
callsinfo -> call_active_state = VOIP_ACTIVE ;
callsinfo -> call_state = VOIP_IN_CALL ;
frame_label = "STREAM OPENED" ;
comment = g_strdup_printf ( "Stream Opened (%d)" , pi -> sequence ) ;
add_to_graph ( tapinfo , pinfo , frame_label , comment , callsinfo -> call_num , & ( pinfo -> src ) , & ( pinfo -> dst ) , 1 ) ;
}
else if ( pi -> stream_connect == 0 && callsinfo != NULL ) {
callsinfo -> stop_fd = pinfo -> fd ;
callsinfo -> stop_rel_ts = pinfo -> rel_ts ;
tmp_unistim_info -> sequence = pi -> sequence ;
if ( callsinfo -> call_state == VOIP_IN_CALL ) {
callsinfo -> call_active_state = VOIP_INACTIVE ;
callsinfo -> call_state = VOIP_COMPLETED ;
}
else {
callsinfo -> call_state = VOIP_UNKNOWN ;
callsinfo -> call_active_state = VOIP_INACTIVE ;
}
frame_label = "STREAM CLOSED" ;
comment = g_strdup_printf ( "Stream Closed (%d)" , pi -> sequence ) ;
add_to_graph ( tapinfo , pinfo , frame_label , comment , callsinfo -> call_num , & ( pinfo -> src ) , & ( pinfo -> dst ) , 1 ) ;
}
else comment = NULL ;
}
else if ( pi -> rudp_type == 1 && callsinfo != NULL ) {
if ( tmp_unistim_info -> sequence == pi -> sequence ) {
frame_label = "ACK" ;
comment = g_strdup_printf ( "ACK for sequence %d" , pi -> sequence ) ;
add_to_graph ( tapinfo , pinfo , frame_label , comment , callsinfo -> call_num , & ( pinfo -> src ) , & ( pinfo -> dst ) , 1 ) ;
}
}
else if ( pi -> rudp_type == 0 && callsinfo != NULL ) {
frame_label = "NAK" ;
comment = g_strdup_printf ( "NAK for sequence %d" , pi -> sequence ) ;
add_to_graph ( tapinfo , pinfo , frame_label , comment , callsinfo -> call_num , & ( pinfo -> src ) , & ( pinfo -> dst ) , 1 ) ;
}
g_free ( comment ) ;
tapinfo -> redraw = TRUE ;
return 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void send_restrict_entry ( restrict_u * pres , int ipv6 , u_int idx ) {
const char addr_fmtu [ ] = "addr.%u" ;
const char mask_fmtu [ ] = "mask.%u" ;
const char hits_fmt [ ] = "hits.%u" ;
const char flags_fmt [ ] = "flags.%u" ;
char tag [ 32 ] ;
u_char sent [ RESLIST_FIELDS ] ;
int noisebits ;
u_int32 noise ;
u_int which ;
u_int remaining ;
sockaddr_u addr ;
sockaddr_u mask ;
const char * pch ;
char * buf ;
const char * match_str ;
const char * access_str ;
sockaddrs_from_restrict_u ( & addr , & mask , pres , ipv6 ) ;
remaining = COUNTOF ( sent ) ;
ZERO ( sent ) ;
noise = 0 ;
noisebits = 0 ;
while ( remaining > 0 ) {
if ( noisebits < 2 ) {
noise = rand ( ) ^ ( rand ( ) << 16 ) ;
noisebits = 31 ;
}
which = ( noise & 0x3 ) % COUNTOF ( sent ) ;
noise >>= 2 ;
noisebits -= 2 ;
while ( sent [ which ] ) which = ( which + 1 ) % COUNTOF ( sent ) ;
switch ( which ) {
case 0 : snprintf ( tag , sizeof ( tag ) , addr_fmtu , idx ) ;
pch = stoa ( & addr ) ;
ctl_putunqstr ( tag , pch , strlen ( pch ) ) ;
break ;
case 1 : snprintf ( tag , sizeof ( tag ) , mask_fmtu , idx ) ;
pch = stoa ( & mask ) ;
ctl_putunqstr ( tag , pch , strlen ( pch ) ) ;
break ;
case 2 : snprintf ( tag , sizeof ( tag ) , hits_fmt , idx ) ;
ctl_putuint ( tag , pres -> count ) ;
break ;
case 3 : snprintf ( tag , sizeof ( tag ) , flags_fmt , idx ) ;
match_str = res_match_flags ( pres -> mflags ) ;
access_str = res_access_flags ( pres -> flags ) ;
if ( '\0' == match_str [ 0 ] ) {
pch = access_str ;
}
else {
LIB_GETBUF ( buf ) ;
snprintf ( buf , LIB_BUFLENGTH , "%s %s" , match_str , access_str ) ;
pch = buf ;
}
ctl_putunqstr ( tag , pch , strlen ( pch ) ) ;
break ;
}
sent [ which ] = TRUE ;
remaining -- ;
}
send_random_tag_value ( ( int ) idx ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline uint64_t replicate64 ( uint64_t a ) {
# if HAVE_BIGENDIAN a &= 0xFF00FF00FF00FF00ULL ;
a |= a >> 8 ;
# else a &= 0x00FF00FF00FF00FFULL ;
a |= a << 8 ;
# endif return a ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void * init_tls ( void ) {
GL ( dl_tls_static_nelem ) = GL ( dl_tls_max_dtv_idx ) ;
if ( GL ( dl_initial_dtv ) != NULL ) return NULL ;
size_t nelem = GL ( dl_tls_max_dtv_idx ) + 1 + TLS_SLOTINFO_SURPLUS ;
GL ( dl_tls_dtv_slotinfo_list ) = ( struct dtv_slotinfo_list * ) calloc ( sizeof ( struct dtv_slotinfo_list ) + nelem * sizeof ( struct dtv_slotinfo ) , 1 ) ;
struct dtv_slotinfo * slotinfo = GL ( dl_tls_dtv_slotinfo_list ) -> slotinfo ;
GL ( dl_tls_dtv_slotinfo_list ) -> len = nelem ;
GL ( dl_tls_dtv_slotinfo_list ) -> next = NULL ;
assert ( GL ( dl_ns ) [ LM_ID_BASE + 1 ] . _ns_loaded == NULL ) ;
int i = 0 ;
for ( struct link_map * l = GL ( dl_ns ) [ LM_ID_BASE ] . _ns_loaded ;
l != NULL ;
l = l -> l_next ) if ( l -> l_tls_blocksize != 0 ) {
slotinfo [ i ] . map = l ;
++ i ;
}
assert ( i == GL ( dl_tls_max_dtv_idx ) ) ;
_dl_determine_tlsoffset ( ) ;
void * tcbp = _dl_allocate_tls_storage ( ) ;
if ( tcbp == NULL ) _dl_fatal_printf ( "\ cannot allocate TLS data structures for initial thread" ) ;
GL ( dl_initial_dtv ) = GET_DTV ( tcbp ) ;
const char * lossage = TLS_INIT_TP ( tcbp ) ;
if ( __glibc_unlikely ( lossage != NULL ) ) _dl_fatal_printf ( "cannot set up thread-local storage: %s\n" , lossage ) ;
tls_init_tp_called = true ;
return tcbp ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static PREDICTION_MODE read_intra_mode ( vp9_reader * r , const vp9_prob * p ) {
return ( PREDICTION_MODE ) vp9_read_tree ( r , vp9_intra_mode_tree , p ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int decode_blockcodes ( int code1 , int code2 , int levels , int * values ) {
return decode_blockcode ( code1 , levels , values ) | decode_blockcode ( code2 , levels , values + 4 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int xml_complete ( modsec_rec * msr , char * * error_msg ) {
if ( error_msg == NULL ) return - 1 ;
* error_msg = NULL ;
if ( msr -> xml -> parsing_ctx != NULL ) {
xmlParseChunk ( msr -> xml -> parsing_ctx , NULL , 0 , 1 ) ;
msr -> xml -> well_formed = msr -> xml -> parsing_ctx -> wellFormed ;
msr -> xml -> doc = msr -> xml -> parsing_ctx -> myDoc ;
xmlFreeParserCtxt ( msr -> xml -> parsing_ctx ) ;
msr -> xml -> parsing_ctx = NULL ;
msr_log ( msr , 4 , "XML: Parsing complete (well_formed %u)." , msr -> xml -> well_formed ) ;
if ( msr -> xml -> well_formed != 1 ) {
* error_msg = apr_psprintf ( msr -> mp , "XML: Failed parsing document." ) ;
return - 1 ;
}
}
return 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int synthesis ( AMRContext * p , float * lpc , float fixed_gain , const float * fixed_vector , float * samples , uint8_t overflow ) {
int i ;
float excitation [ AMR_SUBFRAME_SIZE ] ;
if ( overflow ) for ( i = 0 ;
i < AMR_SUBFRAME_SIZE ;
i ++ ) p -> pitch_vector [ i ] *= 0.25 ;
ff_weighted_vector_sumf ( excitation , p -> pitch_vector , fixed_vector , p -> pitch_gain [ 4 ] , fixed_gain , AMR_SUBFRAME_SIZE ) ;
if ( p -> pitch_gain [ 4 ] > 0.5 && ! overflow ) {
float energy = avpriv_scalarproduct_float_c ( excitation , excitation , AMR_SUBFRAME_SIZE ) ;
float pitch_factor = p -> pitch_gain [ 4 ] * ( p -> cur_frame_mode == MODE_12k2 ? 0.25 * FFMIN ( p -> pitch_gain [ 4 ] , 1.0 ) : 0.5 * FFMIN ( p -> pitch_gain [ 4 ] , SHARP_MAX ) ) ;
for ( i = 0 ;
i < AMR_SUBFRAME_SIZE ;
i ++ ) excitation [ i ] += pitch_factor * p -> pitch_vector [ i ] ;
ff_scale_vector_to_given_sum_of_squares ( excitation , excitation , energy , AMR_SUBFRAME_SIZE ) ;
}
ff_celp_lp_synthesis_filterf ( samples , lpc , excitation , AMR_SUBFRAME_SIZE , LP_FILTER_ORDER ) ;
for ( i = 0 ;
i < AMR_SUBFRAME_SIZE ;
i ++ ) if ( fabsf ( samples [ i ] ) > AMR_SAMPLE_BOUND ) {
return 1 ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_INTEGER_0_524287 ( 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 , 524287U , NULL , FALSE ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int decode_rle ( GetBitContext * gb , uint8_t * pal_dst , int pal_stride , uint8_t * rgb_dst , int rgb_stride , uint32_t * pal , int keyframe , int kf_slipt , int slice , int w , int h ) {
uint8_t bits [ 270 ] = {
0 }
;
uint32_t codes [ 270 ] ;
VLC vlc ;
int current_length = 0 , read_codes = 0 , next_code = 0 , current_codes = 0 ;
int remaining_codes , surplus_codes , i ;
const int alphabet_size = 270 - keyframe ;
int last_symbol = 0 , repeat = 0 , prev_avail = 0 ;
if ( ! keyframe ) {
int x , y , clipw , cliph ;
x = get_bits ( gb , 12 ) ;
y = get_bits ( gb , 12 ) ;
clipw = get_bits ( gb , 12 ) + 1 ;
cliph = get_bits ( gb , 12 ) + 1 ;
if ( x + clipw > w || y + cliph > h ) return AVERROR_INVALIDDATA ;
pal_dst += pal_stride * y + x ;
rgb_dst += rgb_stride * y + x * 3 ;
w = clipw ;
h = cliph ;
if ( y ) prev_avail = 1 ;
}
else {
if ( slice > 0 ) {
pal_dst += pal_stride * kf_slipt ;
rgb_dst += rgb_stride * kf_slipt ;
prev_avail = 1 ;
h -= kf_slipt ;
}
else h = kf_slipt ;
}
do {
while ( current_codes -- ) {
int symbol = get_bits ( gb , 8 ) ;
if ( symbol >= 204 - keyframe ) symbol += 14 - keyframe ;
else if ( symbol > 189 ) symbol = get_bits1 ( gb ) + ( symbol << 1 ) - 190 ;
if ( bits [ symbol ] ) return AVERROR_INVALIDDATA ;
bits [ symbol ] = current_length ;
codes [ symbol ] = next_code ++ ;
read_codes ++ ;
}
current_length ++ ;
next_code <<= 1 ;
remaining_codes = ( 1 << current_length ) - next_code ;
current_codes = get_bits ( gb , av_ceil_log2 ( remaining_codes + 1 ) ) ;
if ( current_length > 22 || current_codes > remaining_codes ) return AVERROR_INVALIDDATA ;
}
while ( current_codes != remaining_codes ) ;
remaining_codes = alphabet_size - read_codes ;
while ( ( surplus_codes = ( 2 << current_length ) - ( next_code << 1 ) - remaining_codes ) < 0 ) {
current_length ++ ;
next_code <<= 1 ;
}
for ( i = 0 ;
i < alphabet_size ;
i ++ ) if ( ! bits [ i ] ) {
if ( surplus_codes -- == 0 ) {
current_length ++ ;
next_code <<= 1 ;
}
bits [ i ] = current_length ;
codes [ i ] = next_code ++ ;
}
if ( next_code != 1 << current_length ) return AVERROR_INVALIDDATA ;
if ( i = init_vlc ( & vlc , 9 , alphabet_size , bits , 1 , 1 , codes , 4 , 4 , 0 ) ) return i ;
do {
uint8_t * pp = pal_dst ;
uint8_t * rp = rgb_dst ;
do {
if ( repeat -- < 1 ) {
int b = get_vlc2 ( gb , vlc . table , 9 , 3 ) ;
if ( b < 256 ) last_symbol = b ;
else if ( b < 268 ) {
b -= 256 ;
if ( b == 11 ) b = get_bits ( gb , 4 ) + 10 ;
if ( ! b ) repeat = 0 ;
else repeat = get_bits ( gb , b ) ;
repeat += ( 1 << b ) - 1 ;
if ( last_symbol == - 2 ) {
int skip = FFMIN ( repeat , pal_dst + w - pp ) ;
repeat -= skip ;
pp += skip ;
rp += skip * 3 ;
}
}
else last_symbol = 267 - b ;
}
if ( last_symbol >= 0 ) {
* pp = last_symbol ;
AV_WB24 ( rp , pal [ last_symbol ] ) ;
}
else if ( last_symbol == - 1 && prev_avail ) {
* pp = * ( pp - pal_stride ) ;
memcpy ( rp , rp - rgb_stride , 3 ) ;
}
rp += 3 ;
}
while ( ++ pp < pal_dst + w ) ;
pal_dst += pal_stride ;
rgb_dst += rgb_stride ;
prev_avail = 1 ;
}
while ( -- h ) ;
ff_free_vlc ( & vlc ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int DecoderGetInputAttachments ( decoder_t * p_dec , input_attachment_t * * * ppp_attachment , int * pi_attachment ) {
input_thread_t * p_input = p_dec -> p_owner -> p_input ;
if ( unlikely ( p_input == NULL ) ) return VLC_ENOOBJ ;
return input_Control ( p_input , INPUT_GET_ATTACHMENTS , ppp_attachment , pi_attachment ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int x_catch_alloc ( Display * dpy , XErrorEvent * err ) {
if ( err -> error_code == BadAlloc ) x_error_handler . alloc_error = True ;
if ( x_error_handler . alloc_error ) return 0 ;
return x_error_handler . oldhandler ( dpy , err ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static guint16 compute_key_id ( tvbuff_t * tvb , int offset , int size , guint8 algo ) {
guint32 ac ;
guint8 c1 , c2 ;
DISSECTOR_ASSERT ( size >= 4 ) ;
switch ( algo ) {
case DNS_ALGO_RSAMD5 : return ( guint16 ) ( tvb_get_guint8 ( tvb , offset + size - 3 ) << 8 ) + tvb_get_guint8 ( tvb , offset + size - 2 ) ;
default : for ( ac = 0 ;
size > 1 ;
size -= 2 , offset += 2 ) {
c1 = tvb_get_guint8 ( tvb , offset ) ;
c2 = tvb_get_guint8 ( tvb , offset + 1 ) ;
ac += ( c1 << 8 ) + c2 ;
}
if ( size > 0 ) {
c1 = tvb_get_guint8 ( tvb , offset ) ;
ac += c1 << 8 ;
}
ac += ( ac >> 16 ) & 0xffff ;
return ( guint16 ) ( ac & 0xffff ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int spl_filesystem_file_read_line ( zval * this_ptr , spl_filesystem_object * intern , int silent TSRMLS_DC ) {
int ret = spl_filesystem_file_read_line_ex ( this_ptr , intern , silent TSRMLS_CC ) ;
while ( SPL_HAS_FLAG ( intern -> flags , SPL_FILE_OBJECT_SKIP_EMPTY ) && ret == SUCCESS && spl_filesystem_file_is_empty_line ( intern TSRMLS_CC ) ) {
spl_filesystem_file_free_line ( intern TSRMLS_CC ) ;
ret = spl_filesystem_file_read_line_ex ( this_ptr , intern , silent TSRMLS_CC ) ;
}
return ret ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
SPL_METHOD ( SplFileObject , fgetcsv ) {
spl_filesystem_object * intern = ( spl_filesystem_object * ) zend_object_store_get_object ( getThis ( ) TSRMLS_CC ) ;
char delimiter = intern -> u . file . delimiter , enclosure = intern -> u . file . enclosure , escape = intern -> u . file . escape ;
char * delim = NULL , * enclo = NULL , * esc = NULL ;
int d_len = 0 , e_len = 0 , esc_len = 0 ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , "|sss" , & delim , & d_len , & enclo , & e_len , & esc , & esc_len ) == SUCCESS ) {
switch ( ZEND_NUM_ARGS ( ) ) {
case 3 : if ( esc_len != 1 ) {
php_error_docref ( NULL TSRMLS_CC , E_WARNING , "escape must be a character" ) ;
RETURN_FALSE ;
}
escape = esc [ 0 ] ;
case 2 : if ( e_len != 1 ) {
php_error_docref ( NULL TSRMLS_CC , E_WARNING , "enclosure must be a character" ) ;
RETURN_FALSE ;
}
enclosure = enclo [ 0 ] ;
case 1 : if ( d_len != 1 ) {
php_error_docref ( NULL TSRMLS_CC , E_WARNING , "delimiter must be a character" ) ;
RETURN_FALSE ;
}
delimiter = delim [ 0 ] ;
case 0 : break ;
}
spl_filesystem_file_read_csv ( intern , delimiter , enclosure , escape , return_value TSRMLS_CC ) ;
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
void mime_init ( ) {
static int init = 1 ;
if ( init ) {
init = 0 ;
hdrtoken_init ( ) ;
day_names_dfa = new DFA ;
day_names_dfa -> compile ( day_names , SIZEOF ( day_names ) , RE_CASE_INSENSITIVE ) ;
month_names_dfa = new DFA ;
month_names_dfa -> compile ( month_names , SIZEOF ( month_names ) , RE_CASE_INSENSITIVE ) ;
MIME_FIELD_ACCEPT = hdrtoken_string_to_wks ( "Accept" ) ;
MIME_FIELD_ACCEPT_CHARSET = hdrtoken_string_to_wks ( "Accept-Charset" ) ;
MIME_FIELD_ACCEPT_ENCODING = hdrtoken_string_to_wks ( "Accept-Encoding" ) ;
MIME_FIELD_ACCEPT_LANGUAGE = hdrtoken_string_to_wks ( "Accept-Language" ) ;
MIME_FIELD_ACCEPT_RANGES = hdrtoken_string_to_wks ( "Accept-Ranges" ) ;
MIME_FIELD_AGE = hdrtoken_string_to_wks ( "Age" ) ;
MIME_FIELD_ALLOW = hdrtoken_string_to_wks ( "Allow" ) ;
MIME_FIELD_APPROVED = hdrtoken_string_to_wks ( "Approved" ) ;
MIME_FIELD_AUTHORIZATION = hdrtoken_string_to_wks ( "Authorization" ) ;
MIME_FIELD_BYTES = hdrtoken_string_to_wks ( "Bytes" ) ;
MIME_FIELD_CACHE_CONTROL = hdrtoken_string_to_wks ( "Cache-Control" ) ;
MIME_FIELD_CLIENT_IP = hdrtoken_string_to_wks ( "Client-ip" ) ;
MIME_FIELD_CONNECTION = hdrtoken_string_to_wks ( "Connection" ) ;
MIME_FIELD_CONTENT_BASE = hdrtoken_string_to_wks ( "Content-Base" ) ;
MIME_FIELD_CONTENT_ENCODING = hdrtoken_string_to_wks ( "Content-Encoding" ) ;
MIME_FIELD_CONTENT_LANGUAGE = hdrtoken_string_to_wks ( "Content-Language" ) ;
MIME_FIELD_CONTENT_LENGTH = hdrtoken_string_to_wks ( "Content-Length" ) ;
MIME_FIELD_CONTENT_LOCATION = hdrtoken_string_to_wks ( "Content-Location" ) ;
MIME_FIELD_CONTENT_MD5 = hdrtoken_string_to_wks ( "Content-MD5" ) ;
MIME_FIELD_CONTENT_RANGE = hdrtoken_string_to_wks ( "Content-Range" ) ;
MIME_FIELD_CONTENT_TYPE = hdrtoken_string_to_wks ( "Content-Type" ) ;
MIME_FIELD_CONTROL = hdrtoken_string_to_wks ( "Control" ) ;
MIME_FIELD_COOKIE = hdrtoken_string_to_wks ( "Cookie" ) ;
MIME_FIELD_DATE = hdrtoken_string_to_wks ( "Date" ) ;
MIME_FIELD_DISTRIBUTION = hdrtoken_string_to_wks ( "Distribution" ) ;
MIME_FIELD_ETAG = hdrtoken_string_to_wks ( "Etag" ) ;
MIME_FIELD_EXPECT = hdrtoken_string_to_wks ( "Expect" ) ;
MIME_FIELD_EXPIRES = hdrtoken_string_to_wks ( "Expires" ) ;
MIME_FIELD_FOLLOWUP_TO = hdrtoken_string_to_wks ( "Followup-To" ) ;
MIME_FIELD_FROM = hdrtoken_string_to_wks ( "From" ) ;
MIME_FIELD_HOST = hdrtoken_string_to_wks ( "Host" ) ;
MIME_FIELD_IF_MATCH = hdrtoken_string_to_wks ( "If-Match" ) ;
MIME_FIELD_IF_MODIFIED_SINCE = hdrtoken_string_to_wks ( "If-Modified-Since" ) ;
MIME_FIELD_IF_NONE_MATCH = hdrtoken_string_to_wks ( "If-None-Match" ) ;
MIME_FIELD_IF_RANGE = hdrtoken_string_to_wks ( "If-Range" ) ;
MIME_FIELD_IF_UNMODIFIED_SINCE = hdrtoken_string_to_wks ( "If-Unmodified-Since" ) ;
MIME_FIELD_KEEP_ALIVE = hdrtoken_string_to_wks ( "Keep-Alive" ) ;
MIME_FIELD_KEYWORDS = hdrtoken_string_to_wks ( "Keywords" ) ;
MIME_FIELD_LAST_MODIFIED = hdrtoken_string_to_wks ( "Last-Modified" ) ;
MIME_FIELD_LINES = hdrtoken_string_to_wks ( "Lines" ) ;
MIME_FIELD_LOCATION = hdrtoken_string_to_wks ( "Location" ) ;
MIME_FIELD_MAX_FORWARDS = hdrtoken_string_to_wks ( "Max-Forwards" ) ;
MIME_FIELD_MESSAGE_ID = hdrtoken_string_to_wks ( "Message-ID" ) ;
MIME_FIELD_NEWSGROUPS = hdrtoken_string_to_wks ( "Newsgroups" ) ;
MIME_FIELD_ORGANIZATION = hdrtoken_string_to_wks ( "Organization" ) ;
MIME_FIELD_PATH = hdrtoken_string_to_wks ( "Path" ) ;
MIME_FIELD_PRAGMA = hdrtoken_string_to_wks ( "Pragma" ) ;
MIME_FIELD_PROXY_AUTHENTICATE = hdrtoken_string_to_wks ( "Proxy-Authenticate" ) ;
MIME_FIELD_PROXY_AUTHORIZATION = hdrtoken_string_to_wks ( "Proxy-Authorization" ) ;
MIME_FIELD_PROXY_CONNECTION = hdrtoken_string_to_wks ( "Proxy-Connection" ) ;
MIME_FIELD_PUBLIC = hdrtoken_string_to_wks ( "Public" ) ;
MIME_FIELD_RANGE = hdrtoken_string_to_wks ( "Range" ) ;
MIME_FIELD_REFERENCES = hdrtoken_string_to_wks ( "References" ) ;
MIME_FIELD_REFERER = hdrtoken_string_to_wks ( "Referer" ) ;
MIME_FIELD_REPLY_TO = hdrtoken_string_to_wks ( "Reply-To" ) ;
MIME_FIELD_RETRY_AFTER = hdrtoken_string_to_wks ( "Retry-After" ) ;
MIME_FIELD_SENDER = hdrtoken_string_to_wks ( "Sender" ) ;
MIME_FIELD_SERVER = hdrtoken_string_to_wks ( "Server" ) ;
MIME_FIELD_SET_COOKIE = hdrtoken_string_to_wks ( "Set-Cookie" ) ;
MIME_FIELD_STRICT_TRANSPORT_SECURITY = hdrtoken_string_to_wks ( "Strict-Transport-Security" ) ;
MIME_FIELD_SUBJECT = hdrtoken_string_to_wks ( "Subject" ) ;
MIME_FIELD_SUMMARY = hdrtoken_string_to_wks ( "Summary" ) ;
MIME_FIELD_TE = hdrtoken_string_to_wks ( "TE" ) ;
MIME_FIELD_TRANSFER_ENCODING = hdrtoken_string_to_wks ( "Transfer-Encoding" ) ;
MIME_FIELD_UPGRADE = hdrtoken_string_to_wks ( "Upgrade" ) ;
MIME_FIELD_USER_AGENT = hdrtoken_string_to_wks ( "User-Agent" ) ;
MIME_FIELD_VARY = hdrtoken_string_to_wks ( "Vary" ) ;
MIME_FIELD_VIA = hdrtoken_string_to_wks ( "Via" ) ;
MIME_FIELD_WARNING = hdrtoken_string_to_wks ( "Warning" ) ;
MIME_FIELD_WWW_AUTHENTICATE = hdrtoken_string_to_wks ( "Www-Authenticate" ) ;
MIME_FIELD_XREF = hdrtoken_string_to_wks ( "Xref" ) ;
MIME_FIELD_ATS_INTERNAL = hdrtoken_string_to_wks ( "@Ats-Internal" ) ;
MIME_FIELD_X_ID = hdrtoken_string_to_wks ( "X-ID" ) ;
MIME_FIELD_X_FORWARDED_FOR = hdrtoken_string_to_wks ( "X-Forwarded-For" ) ;
MIME_FIELD_SEC_WEBSOCKET_KEY = hdrtoken_string_to_wks ( "Sec-WebSocket-Key" ) ;
MIME_FIELD_SEC_WEBSOCKET_VERSION = hdrtoken_string_to_wks ( "Sec-WebSocket-Version" ) ;
MIME_FIELD_HTTP2_SETTINGS = hdrtoken_string_to_wks ( "HTTP2-Settings" ) ;
MIME_LEN_ACCEPT = hdrtoken_wks_to_length ( MIME_FIELD_ACCEPT ) ;
MIME_LEN_ACCEPT_CHARSET = hdrtoken_wks_to_length ( MIME_FIELD_ACCEPT_CHARSET ) ;
MIME_LEN_ACCEPT_ENCODING = hdrtoken_wks_to_length ( MIME_FIELD_ACCEPT_ENCODING ) ;
MIME_LEN_ACCEPT_LANGUAGE = hdrtoken_wks_to_length ( MIME_FIELD_ACCEPT_LANGUAGE ) ;
MIME_LEN_ACCEPT_RANGES = hdrtoken_wks_to_length ( MIME_FIELD_ACCEPT_RANGES ) ;
MIME_LEN_AGE = hdrtoken_wks_to_length ( MIME_FIELD_AGE ) ;
MIME_LEN_ALLOW = hdrtoken_wks_to_length ( MIME_FIELD_ALLOW ) ;
MIME_LEN_APPROVED = hdrtoken_wks_to_length ( MIME_FIELD_APPROVED ) ;
MIME_LEN_AUTHORIZATION = hdrtoken_wks_to_length ( MIME_FIELD_AUTHORIZATION ) ;
MIME_LEN_BYTES = hdrtoken_wks_to_length ( MIME_FIELD_BYTES ) ;
MIME_LEN_CACHE_CONTROL = hdrtoken_wks_to_length ( MIME_FIELD_CACHE_CONTROL ) ;
MIME_LEN_CLIENT_IP = hdrtoken_wks_to_length ( MIME_FIELD_CLIENT_IP ) ;
MIME_LEN_CONNECTION = hdrtoken_wks_to_length ( MIME_FIELD_CONNECTION ) ;
MIME_LEN_CONTENT_BASE = hdrtoken_wks_to_length ( MIME_FIELD_CONTENT_BASE ) ;
MIME_LEN_CONTENT_ENCODING = hdrtoken_wks_to_length ( MIME_FIELD_CONTENT_ENCODING ) ;
MIME_LEN_CONTENT_LANGUAGE = hdrtoken_wks_to_length ( MIME_FIELD_CONTENT_LANGUAGE ) ;
MIME_LEN_CONTENT_LENGTH = hdrtoken_wks_to_length ( MIME_FIELD_CONTENT_LENGTH ) ;
MIME_LEN_CONTENT_LOCATION = hdrtoken_wks_to_length ( MIME_FIELD_CONTENT_LOCATION ) ;
MIME_LEN_CONTENT_MD5 = hdrtoken_wks_to_length ( MIME_FIELD_CONTENT_MD5 ) ;
MIME_LEN_CONTENT_RANGE = hdrtoken_wks_to_length ( MIME_FIELD_CONTENT_RANGE ) ;
MIME_LEN_CONTENT_TYPE = hdrtoken_wks_to_length ( MIME_FIELD_CONTENT_TYPE ) ;
MIME_LEN_CONTROL = hdrtoken_wks_to_length ( MIME_FIELD_CONTROL ) ;
MIME_LEN_COOKIE = hdrtoken_wks_to_length ( MIME_FIELD_COOKIE ) ;
MIME_LEN_DATE = hdrtoken_wks_to_length ( MIME_FIELD_DATE ) ;
MIME_LEN_DISTRIBUTION = hdrtoken_wks_to_length ( MIME_FIELD_DISTRIBUTION ) ;
MIME_LEN_ETAG = hdrtoken_wks_to_length ( MIME_FIELD_ETAG ) ;
MIME_LEN_EXPECT = hdrtoken_wks_to_length ( MIME_FIELD_EXPECT ) ;
MIME_LEN_EXPIRES = hdrtoken_wks_to_length ( MIME_FIELD_EXPIRES ) ;
MIME_LEN_FOLLOWUP_TO = hdrtoken_wks_to_length ( MIME_FIELD_FOLLOWUP_TO ) ;
MIME_LEN_FROM = hdrtoken_wks_to_length ( MIME_FIELD_FROM ) ;
MIME_LEN_HOST = hdrtoken_wks_to_length ( MIME_FIELD_HOST ) ;
MIME_LEN_IF_MATCH = hdrtoken_wks_to_length ( MIME_FIELD_IF_MATCH ) ;
MIME_LEN_IF_MODIFIED_SINCE = hdrtoken_wks_to_length ( MIME_FIELD_IF_MODIFIED_SINCE ) ;
MIME_LEN_IF_NONE_MATCH = hdrtoken_wks_to_length ( MIME_FIELD_IF_NONE_MATCH ) ;
MIME_LEN_IF_RANGE = hdrtoken_wks_to_length ( MIME_FIELD_IF_RANGE ) ;
MIME_LEN_IF_UNMODIFIED_SINCE = hdrtoken_wks_to_length ( MIME_FIELD_IF_UNMODIFIED_SINCE ) ;
MIME_LEN_KEEP_ALIVE = hdrtoken_wks_to_length ( MIME_FIELD_KEEP_ALIVE ) ;
MIME_LEN_KEYWORDS = hdrtoken_wks_to_length ( MIME_FIELD_KEYWORDS ) ;
MIME_LEN_LAST_MODIFIED = hdrtoken_wks_to_length ( MIME_FIELD_LAST_MODIFIED ) ;
MIME_LEN_LINES = hdrtoken_wks_to_length ( MIME_FIELD_LINES ) ;
MIME_LEN_LOCATION = hdrtoken_wks_to_length ( MIME_FIELD_LOCATION ) ;
MIME_LEN_MAX_FORWARDS = hdrtoken_wks_to_length ( MIME_FIELD_MAX_FORWARDS ) ;
MIME_LEN_MESSAGE_ID = hdrtoken_wks_to_length ( MIME_FIELD_MESSAGE_ID ) ;
MIME_LEN_NEWSGROUPS = hdrtoken_wks_to_length ( MIME_FIELD_NEWSGROUPS ) ;
MIME_LEN_ORGANIZATION = hdrtoken_wks_to_length ( MIME_FIELD_ORGANIZATION ) ;
MIME_LEN_PATH = hdrtoken_wks_to_length ( MIME_FIELD_PATH ) ;
MIME_LEN_PRAGMA = hdrtoken_wks_to_length ( MIME_FIELD_PRAGMA ) ;
MIME_LEN_PROXY_AUTHENTICATE = hdrtoken_wks_to_length ( MIME_FIELD_PROXY_AUTHENTICATE ) ;
MIME_LEN_PROXY_AUTHORIZATION = hdrtoken_wks_to_length ( MIME_FIELD_PROXY_AUTHORIZATION ) ;
MIME_LEN_PROXY_CONNECTION = hdrtoken_wks_to_length ( MIME_FIELD_PROXY_CONNECTION ) ;
MIME_LEN_PUBLIC = hdrtoken_wks_to_length ( MIME_FIELD_PUBLIC ) ;
MIME_LEN_RANGE = hdrtoken_wks_to_length ( MIME_FIELD_RANGE ) ;
MIME_LEN_REFERENCES = hdrtoken_wks_to_length ( MIME_FIELD_REFERENCES ) ;
MIME_LEN_REFERER = hdrtoken_wks_to_length ( MIME_FIELD_REFERER ) ;
MIME_LEN_REPLY_TO = hdrtoken_wks_to_length ( MIME_FIELD_REPLY_TO ) ;
MIME_LEN_RETRY_AFTER = hdrtoken_wks_to_length ( MIME_FIELD_RETRY_AFTER ) ;
MIME_LEN_SENDER = hdrtoken_wks_to_length ( MIME_FIELD_SENDER ) ;
MIME_LEN_SERVER = hdrtoken_wks_to_length ( MIME_FIELD_SERVER ) ;
MIME_LEN_SET_COOKIE = hdrtoken_wks_to_length ( MIME_FIELD_SET_COOKIE ) ;
MIME_LEN_STRICT_TRANSPORT_SECURITY = hdrtoken_wks_to_length ( MIME_FIELD_STRICT_TRANSPORT_SECURITY ) ;
MIME_LEN_SUBJECT = hdrtoken_wks_to_length ( MIME_FIELD_SUBJECT ) ;
MIME_LEN_SUMMARY = hdrtoken_wks_to_length ( MIME_FIELD_SUMMARY ) ;
MIME_LEN_TE = hdrtoken_wks_to_length ( MIME_FIELD_TE ) ;
MIME_LEN_TRANSFER_ENCODING = hdrtoken_wks_to_length ( MIME_FIELD_TRANSFER_ENCODING ) ;
MIME_LEN_UPGRADE = hdrtoken_wks_to_length ( MIME_FIELD_UPGRADE ) ;
MIME_LEN_USER_AGENT = hdrtoken_wks_to_length ( MIME_FIELD_USER_AGENT ) ;
MIME_LEN_VARY = hdrtoken_wks_to_length ( MIME_FIELD_VARY ) ;
MIME_LEN_VIA = hdrtoken_wks_to_length ( MIME_FIELD_VIA ) ;
MIME_LEN_WARNING = hdrtoken_wks_to_length ( MIME_FIELD_WARNING ) ;
MIME_LEN_WWW_AUTHENTICATE = hdrtoken_wks_to_length ( MIME_FIELD_WWW_AUTHENTICATE ) ;
MIME_LEN_XREF = hdrtoken_wks_to_length ( MIME_FIELD_XREF ) ;
MIME_LEN_ATS_INTERNAL = hdrtoken_wks_to_length ( MIME_FIELD_ATS_INTERNAL ) ;
MIME_LEN_X_ID = hdrtoken_wks_to_length ( MIME_FIELD_X_ID ) ;
MIME_LEN_X_FORWARDED_FOR = hdrtoken_wks_to_length ( MIME_FIELD_X_FORWARDED_FOR ) ;
MIME_LEN_SEC_WEBSOCKET_KEY = hdrtoken_wks_to_length ( MIME_FIELD_SEC_WEBSOCKET_KEY ) ;
MIME_LEN_SEC_WEBSOCKET_VERSION = hdrtoken_wks_to_length ( MIME_FIELD_SEC_WEBSOCKET_VERSION ) ;
MIME_LEN_HTTP2_SETTINGS = hdrtoken_wks_to_length ( MIME_FIELD_HTTP2_SETTINGS ) ;
MIME_WKSIDX_ACCEPT = hdrtoken_wks_to_index ( MIME_FIELD_ACCEPT ) ;
MIME_WKSIDX_ACCEPT_CHARSET = hdrtoken_wks_to_index ( MIME_FIELD_ACCEPT_CHARSET ) ;
MIME_WKSIDX_ACCEPT_ENCODING = hdrtoken_wks_to_index ( MIME_FIELD_ACCEPT_ENCODING ) ;
MIME_WKSIDX_ACCEPT_LANGUAGE = hdrtoken_wks_to_index ( MIME_FIELD_ACCEPT_LANGUAGE ) ;
MIME_WKSIDX_ACCEPT_RANGES = hdrtoken_wks_to_index ( MIME_FIELD_ACCEPT_RANGES ) ;
MIME_WKSIDX_AGE = hdrtoken_wks_to_index ( MIME_FIELD_AGE ) ;
MIME_WKSIDX_ALLOW = hdrtoken_wks_to_index ( MIME_FIELD_ALLOW ) ;
MIME_WKSIDX_APPROVED = hdrtoken_wks_to_index ( MIME_FIELD_APPROVED ) ;
MIME_WKSIDX_AUTHORIZATION = hdrtoken_wks_to_index ( MIME_FIELD_AUTHORIZATION ) ;
MIME_WKSIDX_BYTES = hdrtoken_wks_to_index ( MIME_FIELD_BYTES ) ;
MIME_WKSIDX_CACHE_CONTROL = hdrtoken_wks_to_index ( MIME_FIELD_CACHE_CONTROL ) ;
MIME_WKSIDX_CLIENT_IP = hdrtoken_wks_to_index ( MIME_FIELD_CLIENT_IP ) ;
MIME_WKSIDX_CONNECTION = hdrtoken_wks_to_index ( MIME_FIELD_CONNECTION ) ;
MIME_WKSIDX_CONTENT_BASE = hdrtoken_wks_to_index ( MIME_FIELD_CONTENT_BASE ) ;
MIME_WKSIDX_CONTENT_ENCODING = hdrtoken_wks_to_index ( MIME_FIELD_CONTENT_ENCODING ) ;
MIME_WKSIDX_CONTENT_LANGUAGE = hdrtoken_wks_to_index ( MIME_FIELD_CONTENT_LANGUAGE ) ;
MIME_WKSIDX_CONTENT_LENGTH = hdrtoken_wks_to_index ( MIME_FIELD_CONTENT_LENGTH ) ;
MIME_WKSIDX_CONTENT_LOCATION = hdrtoken_wks_to_index ( MIME_FIELD_CONTENT_LOCATION ) ;
MIME_WKSIDX_CONTENT_MD5 = hdrtoken_wks_to_index ( MIME_FIELD_CONTENT_MD5 ) ;
MIME_WKSIDX_CONTENT_RANGE = hdrtoken_wks_to_index ( MIME_FIELD_CONTENT_RANGE ) ;
MIME_WKSIDX_CONTENT_TYPE = hdrtoken_wks_to_index ( MIME_FIELD_CONTENT_TYPE ) ;
MIME_WKSIDX_CONTROL = hdrtoken_wks_to_index ( MIME_FIELD_CONTROL ) ;
MIME_WKSIDX_COOKIE = hdrtoken_wks_to_index ( MIME_FIELD_COOKIE ) ;
MIME_WKSIDX_DATE = hdrtoken_wks_to_index ( MIME_FIELD_DATE ) ;
MIME_WKSIDX_DISTRIBUTION = hdrtoken_wks_to_index ( MIME_FIELD_DISTRIBUTION ) ;
MIME_WKSIDX_ETAG = hdrtoken_wks_to_index ( MIME_FIELD_ETAG ) ;
MIME_WKSIDX_EXPECT = hdrtoken_wks_to_index ( MIME_FIELD_EXPECT ) ;
MIME_WKSIDX_EXPIRES = hdrtoken_wks_to_index ( MIME_FIELD_EXPIRES ) ;
MIME_WKSIDX_FOLLOWUP_TO = hdrtoken_wks_to_index ( MIME_FIELD_FOLLOWUP_TO ) ;
MIME_WKSIDX_FROM = hdrtoken_wks_to_index ( MIME_FIELD_FROM ) ;
MIME_WKSIDX_HOST = hdrtoken_wks_to_index ( MIME_FIELD_HOST ) ;
MIME_WKSIDX_IF_MATCH = hdrtoken_wks_to_index ( MIME_FIELD_IF_MATCH ) ;
MIME_WKSIDX_IF_MODIFIED_SINCE = hdrtoken_wks_to_index ( MIME_FIELD_IF_MODIFIED_SINCE ) ;
MIME_WKSIDX_IF_NONE_MATCH = hdrtoken_wks_to_index ( MIME_FIELD_IF_NONE_MATCH ) ;
MIME_WKSIDX_IF_RANGE = hdrtoken_wks_to_index ( MIME_FIELD_IF_RANGE ) ;
MIME_WKSIDX_IF_UNMODIFIED_SINCE = hdrtoken_wks_to_index ( MIME_FIELD_IF_UNMODIFIED_SINCE ) ;
MIME_WKSIDX_KEEP_ALIVE = hdrtoken_wks_to_index ( MIME_FIELD_KEEP_ALIVE ) ;
MIME_WKSIDX_KEYWORDS = hdrtoken_wks_to_index ( MIME_FIELD_KEYWORDS ) ;
MIME_WKSIDX_LAST_MODIFIED = hdrtoken_wks_to_index ( MIME_FIELD_LAST_MODIFIED ) ;
MIME_WKSIDX_LINES = hdrtoken_wks_to_index ( MIME_FIELD_LINES ) ;
MIME_WKSIDX_LOCATION = hdrtoken_wks_to_index ( MIME_FIELD_LOCATION ) ;
MIME_WKSIDX_MAX_FORWARDS = hdrtoken_wks_to_index ( MIME_FIELD_MAX_FORWARDS ) ;
MIME_WKSIDX_MESSAGE_ID = hdrtoken_wks_to_index ( MIME_FIELD_MESSAGE_ID ) ;
MIME_WKSIDX_NEWSGROUPS = hdrtoken_wks_to_index ( MIME_FIELD_NEWSGROUPS ) ;
MIME_WKSIDX_ORGANIZATION = hdrtoken_wks_to_index ( MIME_FIELD_ORGANIZATION ) ;
MIME_WKSIDX_PATH = hdrtoken_wks_to_index ( MIME_FIELD_PATH ) ;
MIME_WKSIDX_PRAGMA = hdrtoken_wks_to_index ( MIME_FIELD_PRAGMA ) ;
MIME_WKSIDX_PROXY_AUTHENTICATE = hdrtoken_wks_to_index ( MIME_FIELD_PROXY_AUTHENTICATE ) ;
MIME_WKSIDX_PROXY_AUTHORIZATION = hdrtoken_wks_to_index ( MIME_FIELD_PROXY_AUTHORIZATION ) ;
MIME_WKSIDX_PROXY_CONNECTION = hdrtoken_wks_to_index ( MIME_FIELD_PROXY_CONNECTION ) ;
MIME_WKSIDX_PUBLIC = hdrtoken_wks_to_index ( MIME_FIELD_PUBLIC ) ;
MIME_WKSIDX_RANGE = hdrtoken_wks_to_index ( MIME_FIELD_RANGE ) ;
MIME_WKSIDX_REFERENCES = hdrtoken_wks_to_index ( MIME_FIELD_REFERENCES ) ;
MIME_WKSIDX_REFERER = hdrtoken_wks_to_index ( MIME_FIELD_REFERER ) ;
MIME_WKSIDX_REPLY_TO = hdrtoken_wks_to_index ( MIME_FIELD_REPLY_TO ) ;
MIME_WKSIDX_RETRY_AFTER = hdrtoken_wks_to_index ( MIME_FIELD_RETRY_AFTER ) ;
MIME_WKSIDX_SENDER = hdrtoken_wks_to_index ( MIME_FIELD_SENDER ) ;
MIME_WKSIDX_SERVER = hdrtoken_wks_to_index ( MIME_FIELD_SERVER ) ;
MIME_WKSIDX_SET_COOKIE = hdrtoken_wks_to_index ( MIME_FIELD_SET_COOKIE ) ;
MIME_WKSIDX_STRICT_TRANSPORT_SECURITY = hdrtoken_wks_to_index ( MIME_FIELD_STRICT_TRANSPORT_SECURITY ) ;
MIME_WKSIDX_SUBJECT = hdrtoken_wks_to_index ( MIME_FIELD_SUBJECT ) ;
MIME_WKSIDX_SUMMARY = hdrtoken_wks_to_index ( MIME_FIELD_SUMMARY ) ;
MIME_WKSIDX_TE = hdrtoken_wks_to_index ( MIME_FIELD_TE ) ;
MIME_WKSIDX_TRANSFER_ENCODING = hdrtoken_wks_to_index ( MIME_FIELD_TRANSFER_ENCODING ) ;
MIME_WKSIDX_UPGRADE = hdrtoken_wks_to_index ( MIME_FIELD_UPGRADE ) ;
MIME_WKSIDX_USER_AGENT = hdrtoken_wks_to_index ( MIME_FIELD_USER_AGENT ) ;
MIME_WKSIDX_VARY = hdrtoken_wks_to_index ( MIME_FIELD_VARY ) ;
MIME_WKSIDX_VIA = hdrtoken_wks_to_index ( MIME_FIELD_VIA ) ;
MIME_WKSIDX_WARNING = hdrtoken_wks_to_index ( MIME_FIELD_WARNING ) ;
MIME_WKSIDX_WWW_AUTHENTICATE = hdrtoken_wks_to_index ( MIME_FIELD_WWW_AUTHENTICATE ) ;
MIME_WKSIDX_XREF = hdrtoken_wks_to_index ( MIME_FIELD_XREF ) ;
MIME_WKSIDX_X_ID = hdrtoken_wks_to_index ( MIME_FIELD_X_ID ) ;
MIME_WKSIDX_X_FORWARDED_FOR = hdrtoken_wks_to_index ( MIME_FIELD_X_FORWARDED_FOR ) ;
MIME_WKSIDX_SEC_WEBSOCKET_KEY = hdrtoken_wks_to_index ( MIME_FIELD_SEC_WEBSOCKET_KEY ) ;
MIME_WKSIDX_SEC_WEBSOCKET_VERSION = hdrtoken_wks_to_index ( MIME_FIELD_SEC_WEBSOCKET_VERSION ) ;
MIME_WKSIDX_HTTP2_SETTINGS = hdrtoken_wks_to_index ( MIME_FIELD_HTTP2_SETTINGS ) ;
MIME_VALUE_BYTES = hdrtoken_string_to_wks ( "bytes" ) ;
MIME_VALUE_CHUNKED = hdrtoken_string_to_wks ( "chunked" ) ;
MIME_VALUE_CLOSE = hdrtoken_string_to_wks ( "close" ) ;
MIME_VALUE_COMPRESS = hdrtoken_string_to_wks ( "compress" ) ;
MIME_VALUE_DEFLATE = hdrtoken_string_to_wks ( "deflate" ) ;
MIME_VALUE_GZIP = hdrtoken_string_to_wks ( "gzip" ) ;
MIME_VALUE_IDENTITY = hdrtoken_string_to_wks ( "identity" ) ;
MIME_VALUE_KEEP_ALIVE = hdrtoken_string_to_wks ( "keep-alive" ) ;
MIME_VALUE_MAX_AGE = hdrtoken_string_to_wks ( "max-age" ) ;
MIME_VALUE_MAX_STALE = hdrtoken_string_to_wks ( "max-stale" ) ;
MIME_VALUE_MIN_FRESH = hdrtoken_string_to_wks ( "min-fresh" ) ;
MIME_VALUE_MUST_REVALIDATE = hdrtoken_string_to_wks ( "must-revalidate" ) ;
MIME_VALUE_NONE = hdrtoken_string_to_wks ( "none" ) ;
MIME_VALUE_NO_CACHE = hdrtoken_string_to_wks ( "no-cache" ) ;
MIME_VALUE_NO_STORE = hdrtoken_string_to_wks ( "no-store" ) ;
MIME_VALUE_NO_TRANSFORM = hdrtoken_string_to_wks ( "no-transform" ) ;
MIME_VALUE_ONLY_IF_CACHED = hdrtoken_string_to_wks ( "only-if-cached" ) ;
MIME_VALUE_PRIVATE = hdrtoken_string_to_wks ( "private" ) ;
MIME_VALUE_PROXY_REVALIDATE = hdrtoken_string_to_wks ( "proxy-revalidate" ) ;
MIME_VALUE_PUBLIC = hdrtoken_string_to_wks ( "public" ) ;
MIME_VALUE_S_MAXAGE = hdrtoken_string_to_wks ( "s-maxage" ) ;
MIME_VALUE_NEED_REVALIDATE_ONCE = hdrtoken_string_to_wks ( "need-revalidate-once" ) ;
MIME_VALUE_WEBSOCKET = hdrtoken_string_to_wks ( "websocket" ) ;
MIME_VALUE_H2C = hdrtoken_string_to_wks ( MIME_UPGRADE_H2C_TOKEN ) ;
mime_init_date_format_table ( ) ;
mime_init_cache_control_cooking_masks ( ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int dissect_ber_real ( gboolean implicit_tag , asn1_ctx_t * actx , proto_tree * tree , tvbuff_t * tvb , int offset , gint hf_id _U_ , double * value ) {
gint8 ber_class ;
gboolean pc ;
gint32 tag ;
guint32 val_length = 0 , len_remain , end_offset ;
double val = 0 ;
proto_item * cause ;
if ( ! implicit_tag ) {
offset = dissect_ber_identifier ( actx -> pinfo , tree , tvb , offset , & ber_class , & pc , & tag ) ;
offset = dissect_ber_length ( actx -> pinfo , tree , tvb , offset , & val_length , NULL ) ;
end_offset = offset + val_length ;
}
else {
get_last_ber_identifier ( & ber_class , & pc , & tag ) ;
get_last_ber_length ( & val_length , NULL ) ;
end_offset = offset + val_length ;
len_remain = ( guint32 ) tvb_reported_length_remaining ( tvb , offset ) ;
if ( len_remain < val_length ) {
cause = proto_tree_add_string_format_value ( tree , hf_ber_error , tvb , offset , val_length , "illegal_length" , "length:%u longer than tvb_reported_length_remaining:%d" , val_length , len_remain ) ;
expert_add_info ( actx -> pinfo , cause , & ei_ber_error_length ) ;
return end_offset ;
}
}
if ( pc ) {
cause = proto_tree_add_string_format_value ( tree , hf_ber_error , tvb , offset - 2 , 1 , "wrong_tag" , "REAL class must be encoded as primitive" ) ;
expert_add_info ( actx -> pinfo , cause , & ei_ber_error_length ) ;
}
val = asn1_get_real ( tvb_get_ptr ( tvb , offset , val_length ) , val_length ) ;
actx -> created_item = proto_tree_add_double ( tree , hf_id , tvb , end_offset - val_length , val_length , val ) ;
if ( value ) * value = val ;
return end_offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int imc_decode_frame ( AVCodecContext * avctx , void * data , int * got_frame_ptr , AVPacket * avpkt ) {
AVFrame * frame = data ;
const uint8_t * buf = avpkt -> data ;
int buf_size = avpkt -> size ;
int ret , i ;
IMCContext * q = avctx -> priv_data ;
LOCAL_ALIGNED_16 ( uint16_t , buf16 , [ IMC_BLOCK_SIZE / 2 ] ) ;
if ( buf_size < IMC_BLOCK_SIZE * avctx -> channels ) {
av_log ( avctx , AV_LOG_ERROR , "frame too small!\n" ) ;
return AVERROR_INVALIDDATA ;
}
frame -> nb_samples = COEFFS ;
if ( ( ret = ff_get_buffer ( avctx , frame ) ) < 0 ) {
av_log ( avctx , AV_LOG_ERROR , "get_buffer() failed\n" ) ;
return ret ;
}
for ( i = 0 ;
i < avctx -> channels ;
i ++ ) {
q -> out_samples = ( float * ) frame -> extended_data [ i ] ;
q -> dsp . bswap16_buf ( buf16 , ( const uint16_t * ) buf , IMC_BLOCK_SIZE / 2 ) ;
init_get_bits ( & q -> gb , ( const uint8_t * ) buf16 , IMC_BLOCK_SIZE * 8 ) ;
buf += IMC_BLOCK_SIZE ;
if ( ( ret = imc_decode_block ( avctx , q , i ) ) < 0 ) return ret ;
}
if ( avctx -> channels == 2 ) {
q -> fdsp . butterflies_float ( ( float * ) frame -> extended_data [ 0 ] , ( float * ) frame -> extended_data [ 1 ] , COEFFS ) ;
}
* got_frame_ptr = 1 ;
return IMC_BLOCK_SIZE * avctx -> channels ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
void ttfFont__destroy ( ttfFont * self , gs_font_dir * dir ) {
gs_memory_t * mem = dir -> memory -> stable_memory ;
ttfFont__finit ( self ) ;
gs_free_object ( mem , self , "ttfFont__destroy" ) ;
ttfInterpreter__release ( & dir -> tti ) ;
gx_san__release ( & dir -> san ) ;
if ( dir -> tti == NULL && dir -> ttm != NULL ) {
gs_free_object ( mem , dir -> ttm , "ttfFont__destroy(gx_ttfMemory)" ) ;
dir -> ttm = NULL ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void pxa2xx_i2s_write ( void * opaque , hwaddr addr , uint64_t value , unsigned size ) {
PXA2xxI2SState * s = ( PXA2xxI2SState * ) opaque ;
uint32_t * sample ;
switch ( addr ) {
case SACR0 : if ( value & ( 1 << 3 ) ) pxa2xx_i2s_reset ( s ) ;
s -> control [ 0 ] = value & 0xff3d ;
if ( ! s -> enable && ( value & 1 ) && s -> tx_len ) {
for ( sample = s -> fifo ;
s -> fifo_len > 0 ;
s -> fifo_len -- , sample ++ ) s -> codec_out ( s -> opaque , * sample ) ;
s -> status &= ~ ( 1 << 7 ) ;
}
if ( value & ( 1 << 4 ) ) printf ( "%s: Attempt to use special function\n" , __FUNCTION__ ) ;
s -> enable = ( value & 9 ) == 1 ;
pxa2xx_i2s_update ( s ) ;
break ;
case SACR1 : s -> control [ 1 ] = value & 0x0039 ;
if ( value & ( 1 << 5 ) ) printf ( "%s: Attempt to use loopback function\n" , __FUNCTION__ ) ;
if ( value & ( 1 << 4 ) ) s -> fifo_len = 0 ;
pxa2xx_i2s_update ( s ) ;
break ;
case SAIMR : s -> mask = value & 0x0078 ;
pxa2xx_i2s_update ( s ) ;
break ;
case SAICR : s -> status &= ~ ( value & ( 3 << 5 ) ) ;
pxa2xx_i2s_update ( s ) ;
break ;
case SADIV : s -> clk = value & 0x007f ;
break ;
case SADR : if ( s -> tx_len && s -> enable ) {
s -> tx_len -- ;
pxa2xx_i2s_update ( s ) ;
s -> codec_out ( s -> opaque , value ) ;
}
else if ( s -> fifo_len < 16 ) {
s -> fifo [ s -> fifo_len ++ ] = value ;
pxa2xx_i2s_update ( s ) ;
}
break ;
default : printf ( "%s: Bad register " REG_FMT "\n" , __FUNCTION__ , addr ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void free_sip_info ( gpointer p ) {
sip_calls_info_t * si = ( sip_calls_info_t * ) p ;
g_free ( si -> call_identifier ) ;
g_free ( si ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h225_H323Caps ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_sequence ( tvb , offset , actx , tree , hf_index , ett_h225_H323Caps , H323Caps_sequence ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline uint32_t e1000e_tx_wb_interrupt_cause ( E1000ECore * core , int queue_idx ) {
if ( ! msix_enabled ( core -> owner ) ) {
return E1000_ICR_TXDW ;
}
return ( queue_idx == 0 ) ? E1000_ICR_TXQ0 : E1000_ICR_TXQ1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static decNumber * decDecap ( decNumber * dn , Int drop ) {
Unit * msu ;
Int cut ;
if ( drop >= dn -> digits ) {
# if DECCHECK if ( drop > dn -> digits ) printf ( "decDecap called with drop>digits [%ld>%ld]\n" , ( LI ) drop , ( LI ) dn -> digits ) ;
# endif dn -> lsu [ 0 ] = 0 ;
dn -> digits = 1 ;
return dn ;
}
msu = dn -> lsu + D2U ( dn -> digits - drop ) - 1 ;
cut = MSUDIGITS ( dn -> digits - drop ) ;
if ( cut != DECDPUN ) * msu %= powers [ cut ] ;
dn -> digits = decGetDigits ( dn -> lsu , msu - dn -> lsu + 1 ) ;
return dn ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline gboolean is_sysex_code ( guint8 code ) {
return ( code == 0x04 || code == 0x05 || code == 0x06 || code == 0x07 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
ATF_TC_HEAD ( option_refcnt , tc ) {
atf_tc_set_md_var ( tc , "descr" , "Verify option reference count does not overflow." ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void rtp_dyn_payloads_init ( void ) {
if ( rtp_dyn_payloads == NULL ) {
rtp_dyn_payloads = g_hash_table_new ( NULL , NULL ) ;
wmem_register_callback ( wmem_file_scope ( ) , wmem_rtp_dyn_payload_destroy_cb , NULL ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void dissect_rsvp_lsp_attributes ( proto_tree * ti , packet_info * pinfo , proto_tree * rsvp_object_tree , tvbuff_t * tvb , int offset , int obj_length , int rsvp_class _U_ , int type ) {
int tlv_off ;
guint32 attributes ;
guint16 tlv_type , tlv_len ;
proto_tree * ti2 , * rsvp_lsp_attr_subtree ;
if ( rsvp_class == RSVP_CLASS_LSP_REQUIRED_ATTRIBUTES ) proto_item_set_text ( ti , "LSP REQUIRED ATTRIBUTES: " ) ;
else proto_item_set_text ( ti , "LSP ATTRIBUTES: " ) ;
switch ( type ) {
case 1 : proto_tree_add_uint ( rsvp_object_tree , hf_rsvp_ctype , tvb , offset + 3 , 1 , type ) ;
for ( tlv_off = 4 ;
tlv_off < obj_length - 4 ;
) {
tlv_type = tvb_get_ntohs ( tvb , offset + tlv_off ) ;
tlv_len = tvb_get_ntohs ( tvb , offset + tlv_off + 2 ) ;
if ( ( tlv_len == 0 ) || ( tlv_off + tlv_len > obj_length ) ) {
proto_tree_add_expert ( rsvp_object_tree , pinfo , & ei_rsvp_invalid_length , tvb , offset + tlv_off + 2 , 2 ) ;
return ;
}
switch ( tlv_type ) {
case 1 : attributes = tvb_get_ntohl ( tvb , offset + tlv_off + 4 ) ;
ti2 = proto_tree_add_item ( rsvp_object_tree , hf_rsvp_lsp_attributes_tlv , tvb , offset + tlv_off , 4 , ENC_BIG_ENDIAN ) ;
rsvp_lsp_attr_subtree = proto_item_add_subtree ( ti2 , TREE ( TT_LSP_ATTRIBUTES_FLAGS ) ) ;
proto_tree_add_item ( rsvp_lsp_attr_subtree , hf_rsvp_lsp_attr_e2e , tvb , offset + tlv_off + 4 , 4 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_lsp_attr_subtree , hf_rsvp_lsp_attr_boundary , tvb , offset + tlv_off + 4 , 4 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_lsp_attr_subtree , hf_rsvp_lsp_attr_segment , tvb , offset + tlv_off + 4 , 4 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_lsp_attr_subtree , hf_rsvp_lsp_attr_integrity , tvb , offset + tlv_off + 4 , 4 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_lsp_attr_subtree , hf_rsvp_lsp_attr_contiguous , tvb , offset + tlv_off + 4 , 4 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_lsp_attr_subtree , hf_rsvp_lsp_attr_stitching , tvb , offset + tlv_off + 4 , 4 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_lsp_attr_subtree , hf_rsvp_lsp_attr_preplanned , tvb , offset + tlv_off + 4 , 4 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_lsp_attr_subtree , hf_rsvp_lsp_attr_nophp , tvb , offset + tlv_off + 4 , 4 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_lsp_attr_subtree , hf_rsvp_lsp_attr_oobmap , tvb , offset + tlv_off + 4 , 4 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_lsp_attr_subtree , hf_rsvp_lsp_attr_entropy , tvb , offset + tlv_off + 4 , 4 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_lsp_attr_subtree , hf_rsvp_lsp_attr_srlgcollect , tvb , offset + tlv_off + 4 , 4 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_lsp_attr_subtree , hf_rsvp_lsp_attr_costcollect , tvb , offset + tlv_off + 4 , 4 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_lsp_attr_subtree , hf_rsvp_lsp_attr_latcollect , tvb , offset + tlv_off + 4 , 4 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_lsp_attr_subtree , hf_rsvp_lsp_attr_latvarcollect , tvb , offset + tlv_off + 4 , 4 , ENC_BIG_ENDIAN ) ;
proto_item_append_text ( ti , "LSP Attribute:%s%s%s%s%s%s%s%s%s%s%s%s%s%s" , ( attributes & 0x00000001 ) ? " End-to-end re-routing" : "" , ( attributes & 0x00000002 ) ? " Boundary re-routing" : "" , ( attributes & 0x00000004 ) ? " Segment-based re-routing" : "" , ( attributes & 0x00000008 ) ? " LSP Integrity Required" : "" , ( attributes & 0x00000010 ) ? " Contiguous LSP" : "" , ( attributes & 0x00000020 ) ? " LSP stitching desired" : "" , ( attributes & 0x00000040 ) ? " Pre-Planned LSP Flag" : "" , ( attributes & 0x00000080 ) ? " Non-PHP behavior flag" : "" , ( attributes & 0x00000100 ) ? " OOB mapping flag" : "" , ( attributes & 0x00000200 ) ? " Entropy Label Capability" : "" , ( attributes & 0x00000400 ) ? " SRLG Collection Flag" : "" , ( attributes & 0x00000800 ) ? " Cost Collection Flag" : "" , ( attributes & 0x00001000 ) ? " Latency Collection Flag" : "" , ( attributes & 0x00002000 ) ? " Latency Variation Flag" : "" ) ;
break ;
default : proto_tree_add_uint_format ( rsvp_object_tree , hf_rsvp_type , tvb , offset + tlv_off , tlv_len , tlv_type , "Unknown TLV: %d" , tlv_type ) ;
break ;
}
tlv_off += tlv_len ;
}
break ;
default : proto_tree_add_uint_format_value ( rsvp_object_tree , hf_rsvp_ctype , tvb , offset + 3 , 1 , type , "Unknown (%u)" , type ) ;
proto_tree_add_item ( rsvp_object_tree , hf_rsvp_lsp_attributes_tlv_data , tvb , offset + 4 , obj_length - 4 , ENC_NA ) ;
break ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline int PopLZWStack ( LZWStack * stack_info ) {
if ( stack_info -> index <= stack_info -> codes ) return ( - 1 ) ;
stack_info -> index -- ;
return ( ( int ) * stack_info -> index ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int decode_frame ( AVCodecContext * avctx , void * data , int * got_frame , AVPacket * avpkt ) {
ASV1Context * const a = avctx -> priv_data ;
const uint8_t * buf = avpkt -> data ;
int buf_size = avpkt -> size ;
AVFrame * picture = data ;
AVFrame * const p = & a -> picture ;
int mb_x , mb_y , ret ;
if ( p -> data [ 0 ] ) avctx -> release_buffer ( avctx , p ) ;
p -> reference = 0 ;
if ( ( ret = ff_get_buffer ( avctx , p ) ) < 0 ) {
av_log ( avctx , AV_LOG_ERROR , "get_buffer() failed\n" ) ;
return ret ;
}
p -> pict_type = AV_PICTURE_TYPE_I ;
p -> key_frame = 1 ;
av_fast_padded_malloc ( & a -> bitstream_buffer , & a -> bitstream_buffer_size , buf_size ) ;
if ( ! a -> bitstream_buffer ) return AVERROR ( ENOMEM ) ;
if ( avctx -> codec_id == AV_CODEC_ID_ASV1 ) a -> dsp . bswap_buf ( ( uint32_t * ) a -> bitstream_buffer , ( const uint32_t * ) buf , buf_size / 4 ) ;
else {
int i ;
for ( i = 0 ;
i < buf_size ;
i ++ ) a -> bitstream_buffer [ i ] = ff_reverse [ buf [ i ] ] ;
}
init_get_bits ( & a -> gb , a -> bitstream_buffer , buf_size * 8 ) ;
for ( mb_y = 0 ;
mb_y < a -> mb_height2 ;
mb_y ++ ) {
for ( mb_x = 0 ;
mb_x < a -> mb_width2 ;
mb_x ++ ) {
if ( ( ret = decode_mb ( a , a -> block ) ) < 0 ) return ret ;
idct_put ( a , mb_x , mb_y ) ;
}
}
if ( a -> mb_width2 != a -> mb_width ) {
mb_x = a -> mb_width2 ;
for ( mb_y = 0 ;
mb_y < a -> mb_height2 ;
mb_y ++ ) {
if ( ( ret = decode_mb ( a , a -> block ) ) < 0 ) return ret ;
idct_put ( a , mb_x , mb_y ) ;
}
}
if ( a -> mb_height2 != a -> mb_height ) {
mb_y = a -> mb_height2 ;
for ( mb_x = 0 ;
mb_x < a -> mb_width ;
mb_x ++ ) {
if ( ( ret = decode_mb ( a , a -> block ) ) < 0 ) return ret ;
idct_put ( a , mb_x , mb_y ) ;
}
}
* picture = a -> picture ;
* got_frame = 1 ;
emms_c ( ) ;
return ( get_bits_count ( & a -> gb ) + 31 ) / 32 * 4 ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int process_rec_header2_v2 ( wtap * wth , unsigned char * buffer , guint16 length , int * err , gchar * * err_info ) {
static const char x_25_str [ ] = "HDLC\nX.25\n" ;
if ( length < sizeof x_25_str - 1 ) {
* err = WTAP_ERR_UNSUPPORTED ;
* err_info = g_strdup_printf ( "ngsniffer: WAN capture has too-short protocol list" ) ;
return - 1 ;
}
if ( strncmp ( ( char * ) buffer , x_25_str , sizeof x_25_str - 1 ) == 0 ) {
wth -> file_encap = WTAP_ENCAP_LAPB ;
}
else {
* err = WTAP_ERR_UNSUPPORTED ;
* err_info = g_strdup_printf ( "ngsniffer: WAN capture protocol string %.*s unknown" , length , buffer ) ;
return - 1 ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TSReturnCode TSHttpAltInfoClientReqGet ( TSHttpAltInfo infop , TSMBuffer * bufp , TSMLoc * obj ) {
sdk_assert ( sdk_sanity_check_alt_info ( infop ) == TS_SUCCESS ) ;
HttpAltInfo * info = ( HttpAltInfo * ) infop ;
* ( reinterpret_cast < HTTPHdr * * > ( bufp ) ) = & info -> m_client_req ;
* obj = reinterpret_cast < TSMLoc > ( info -> m_client_req . m_http ) ;
return sdk_sanity_check_mbuffer ( * bufp ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
zend_object_iterator * spl_filesystem_dir_get_iterator ( zend_class_entry * ce , zval * object , int by_ref TSRMLS_DC ) {
spl_filesystem_iterator * iterator ;
spl_filesystem_object * dir_object ;
if ( by_ref ) {
zend_error ( E_ERROR , "An iterator cannot be used with foreach by reference" ) ;
}
dir_object = ( spl_filesystem_object * ) zend_object_store_get_object ( object TSRMLS_CC ) ;
iterator = spl_filesystem_object_to_iterator ( dir_object ) ;
if ( iterator -> intern . data == NULL ) {
iterator -> intern . data = object ;
iterator -> intern . funcs = & spl_filesystem_dir_it_funcs ;
iterator -> current = object ;
}
zval_add_ref ( & object ) ;
return ( zend_object_iterator * ) iterator ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( BluetoothChooserBrowserTest , InvokeDialog_UnavailableBubble ) {
RunDialog ( ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void MCFUNC ( hl_motion ) ( H264Context * h , uint8_t * dest_y , uint8_t * dest_cb , uint8_t * dest_cr , qpel_mc_func ( * qpix_put ) [ 16 ] , h264_chroma_mc_func ( * chroma_put ) , qpel_mc_func ( * qpix_avg ) [ 16 ] , h264_chroma_mc_func ( * chroma_avg ) , h264_weight_func * weight_op , h264_biweight_func * weight_avg ) {
const int mb_xy = h -> mb_xy ;
const int mb_type = h -> cur_pic . f . mb_type [ mb_xy ] ;
assert ( IS_INTER ( mb_type ) ) ;
if ( HAVE_THREADS && ( h -> avctx -> active_thread_type & FF_THREAD_FRAME ) ) await_references ( h ) ;
prefetch_motion ( h , 0 , PIXEL_SHIFT , CHROMA_IDC ) ;
if ( IS_16X16 ( mb_type ) ) {
mc_part ( h , 0 , 1 , 16 , 0 , dest_y , dest_cb , dest_cr , 0 , 0 , qpix_put [ 0 ] , chroma_put [ 0 ] , qpix_avg [ 0 ] , chroma_avg [ 0 ] , weight_op , weight_avg , IS_DIR ( mb_type , 0 , 0 ) , IS_DIR ( mb_type , 0 , 1 ) ) ;
}
else if ( IS_16X8 ( mb_type ) ) {
mc_part ( h , 0 , 0 , 8 , 8 << PIXEL_SHIFT , dest_y , dest_cb , dest_cr , 0 , 0 , qpix_put [ 1 ] , chroma_put [ 0 ] , qpix_avg [ 1 ] , chroma_avg [ 0 ] , weight_op , weight_avg , IS_DIR ( mb_type , 0 , 0 ) , IS_DIR ( mb_type , 0 , 1 ) ) ;
mc_part ( h , 8 , 0 , 8 , 8 << PIXEL_SHIFT , dest_y , dest_cb , dest_cr , 0 , 4 , qpix_put [ 1 ] , chroma_put [ 0 ] , qpix_avg [ 1 ] , chroma_avg [ 0 ] , weight_op , weight_avg , IS_DIR ( mb_type , 1 , 0 ) , IS_DIR ( mb_type , 1 , 1 ) ) ;
}
else if ( IS_8X16 ( mb_type ) ) {
mc_part ( h , 0 , 0 , 16 , 8 * h -> mb_linesize , dest_y , dest_cb , dest_cr , 0 , 0 , qpix_put [ 1 ] , chroma_put [ 1 ] , qpix_avg [ 1 ] , chroma_avg [ 1 ] , & weight_op [ 1 ] , & weight_avg [ 1 ] , IS_DIR ( mb_type , 0 , 0 ) , IS_DIR ( mb_type , 0 , 1 ) ) ;
mc_part ( h , 4 , 0 , 16 , 8 * h -> mb_linesize , dest_y , dest_cb , dest_cr , 4 , 0 , qpix_put [ 1 ] , chroma_put [ 1 ] , qpix_avg [ 1 ] , chroma_avg [ 1 ] , & weight_op [ 1 ] , & weight_avg [ 1 ] , IS_DIR ( mb_type , 1 , 0 ) , IS_DIR ( mb_type , 1 , 1 ) ) ;
}
else {
int i ;
assert ( IS_8X8 ( mb_type ) ) ;
for ( i = 0 ;
i < 4 ;
i ++ ) {
const int sub_mb_type = h -> sub_mb_type [ i ] ;
const int n = 4 * i ;
int x_offset = ( i & 1 ) << 2 ;
int y_offset = ( i & 2 ) << 1 ;
if ( IS_SUB_8X8 ( sub_mb_type ) ) {
mc_part ( h , n , 1 , 8 , 0 , dest_y , dest_cb , dest_cr , x_offset , y_offset , qpix_put [ 1 ] , chroma_put [ 1 ] , qpix_avg [ 1 ] , chroma_avg [ 1 ] , & weight_op [ 1 ] , & weight_avg [ 1 ] , IS_DIR ( sub_mb_type , 0 , 0 ) , IS_DIR ( sub_mb_type , 0 , 1 ) ) ;
}
else if ( IS_SUB_8X4 ( sub_mb_type ) ) {
mc_part ( h , n , 0 , 4 , 4 << PIXEL_SHIFT , dest_y , dest_cb , dest_cr , x_offset , y_offset , qpix_put [ 2 ] , chroma_put [ 1 ] , qpix_avg [ 2 ] , chroma_avg [ 1 ] , & weight_op [ 1 ] , & weight_avg [ 1 ] , IS_DIR ( sub_mb_type , 0 , 0 ) , IS_DIR ( sub_mb_type , 0 , 1 ) ) ;
mc_part ( h , n + 2 , 0 , 4 , 4 << PIXEL_SHIFT , dest_y , dest_cb , dest_cr , x_offset , y_offset + 2 , qpix_put [ 2 ] , chroma_put [ 1 ] , qpix_avg [ 2 ] , chroma_avg [ 1 ] , & weight_op [ 1 ] , & weight_avg [ 1 ] , IS_DIR ( sub_mb_type , 0 , 0 ) , IS_DIR ( sub_mb_type , 0 , 1 ) ) ;
}
else if ( IS_SUB_4X8 ( sub_mb_type ) ) {
mc_part ( h , n , 0 , 8 , 4 * h -> mb_linesize , dest_y , dest_cb , dest_cr , x_offset , y_offset , qpix_put [ 2 ] , chroma_put [ 2 ] , qpix_avg [ 2 ] , chroma_avg [ 2 ] , & weight_op [ 2 ] , & weight_avg [ 2 ] , IS_DIR ( sub_mb_type , 0 , 0 ) , IS_DIR ( sub_mb_type , 0 , 1 ) ) ;
mc_part ( h , n + 1 , 0 , 8 , 4 * h -> mb_linesize , dest_y , dest_cb , dest_cr , x_offset + 2 , y_offset , qpix_put [ 2 ] , chroma_put [ 2 ] , qpix_avg [ 2 ] , chroma_avg [ 2 ] , & weight_op [ 2 ] , & weight_avg [ 2 ] , IS_DIR ( sub_mb_type , 0 , 0 ) , IS_DIR ( sub_mb_type , 0 , 1 ) ) ;
}
else {
int j ;
assert ( IS_SUB_4X4 ( sub_mb_type ) ) ;
for ( j = 0 ;
j < 4 ;
j ++ ) {
int sub_x_offset = x_offset + 2 * ( j & 1 ) ;
int sub_y_offset = y_offset + ( j & 2 ) ;
mc_part ( h , n + j , 1 , 4 , 0 , dest_y , dest_cb , dest_cr , sub_x_offset , sub_y_offset , qpix_put [ 2 ] , chroma_put [ 2 ] , qpix_avg [ 2 ] , chroma_avg [ 2 ] , & weight_op [ 2 ] , & weight_avg [ 2 ] , IS_DIR ( sub_mb_type , 0 , 0 ) , IS_DIR ( sub_mb_type , 0 , 1 ) ) ;
}
}
}
}
prefetch_motion ( h , 1 , PIXEL_SHIFT , CHROMA_IDC ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int decode_udvm_literal_operand ( guint8 * buff , guint operand_address , guint16 * value ) {
guint bytecode ;
guint16 operand ;
guint test_bits ;
guint offset = operand_address ;
guint8 temp_data ;
bytecode = buff [ operand_address ] ;
test_bits = bytecode >> 7 ;
if ( test_bits == 1 ) {
test_bits = bytecode >> 6 ;
if ( test_bits == 2 ) {
temp_data = buff [ operand_address ] & 0x1f ;
operand = temp_data << 8 ;
temp_data = buff [ ( operand_address + 1 ) & 0xffff ] ;
operand = operand | temp_data ;
* value = operand ;
offset = offset + 2 ;
}
else {
offset ++ ;
temp_data = buff [ operand_address ] & 0x1f ;
operand = temp_data << 8 ;
temp_data = buff [ ( operand_address + 1 ) & 0xffff ] ;
operand = operand | temp_data ;
* value = operand ;
offset = offset + 2 ;
}
}
else {
operand = ( bytecode & 0x7f ) ;
* value = operand ;
offset ++ ;
}
return offset ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( WebFrameTest , ContextMenuDataNonLocatedMenu ) {
ContextMenuWebFrameClient frame ;
FrameTestHelpers : : WebViewHelper web_view_helper ;
WebViewImpl * web_view = web_view_helper . Initialize ( & frame ) ;
const std : : string & html = "<div style='font-size: 1000%;
line-height: 0.7em'>Select me<br/>" "Next line</div>" ;
FrameTestHelpers : : LoadHTMLString ( web_view -> MainFrameImpl ( ) , html , ToKURL ( "about:blank" ) ) ;
web_view -> Resize ( WebSize ( 500 , 300 ) ) ;
web_view -> UpdateAllLifecyclePhases ( ) ;
RunPendingTasks ( ) ;
web_view -> SetInitialFocus ( false ) ;
RunPendingTasks ( ) ;
WebMouseEvent mouse_event ( WebInputEvent : : kMouseDown , WebInputEvent : : kNoModifiers , WebInputEvent : : GetStaticTimeStampForTests ( ) ) ;
mouse_event . button = WebMouseEvent : : Button : : kLeft ;
mouse_event . SetPositionInWidget ( 0 , 0 ) ;
mouse_event . click_count = 2 ;
web_view -> HandleInputEvent ( WebCoalescedInputEvent ( mouse_event ) ) ;
web_view -> ShowContextMenu ( kMenuSourceTouch ) ;
RunPendingTasks ( ) ;
web_view_helper . Reset ( ) ;
EXPECT_EQ ( frame . GetMenuData ( ) . source_type , kMenuSourceTouch ) ;
EXPECT_FALSE ( frame . GetMenuData ( ) . selected_text . IsEmpty ( ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int rfc2047_encode ( const char * d , size_t dlen , int col , const char * fromcode , const char * charsets , char * * e , size_t * elen , const char * specials ) {
int rc = 0 ;
char * buf = NULL ;
size_t bufpos , buflen ;
char * t0 = NULL , * t1 = NULL , * t = NULL ;
char * s0 = NULL , * s1 = NULL ;
size_t ulen , r , wlen = 0 ;
encoder_t encoder = NULL ;
char * tocode1 = NULL ;
const char * tocode = NULL ;
char * icode = "utf-8" ;
char * u = mutt_str_substr_dup ( d , d + dlen ) ;
if ( mutt_ch_convert_string ( & u , fromcode , icode , 0 ) != 0 ) {
rc = 1 ;
icode = 0 ;
}
ulen = mutt_str_strlen ( u ) ;
s0 = s1 = t0 = t1 = 0 ;
for ( t = u ;
t < ( u + ulen ) ;
t ++ ) {
if ( ( * t & 0x80 ) || ( ( * t == '=' ) && ( t [ 1 ] == '?' ) && ( ( t == u ) || HSPACE ( * ( t - 1 ) ) ) ) ) {
if ( ! t0 ) t0 = t ;
t1 = t ;
}
else if ( specials && * t && strchr ( specials , * t ) ) {
if ( ! s0 ) s0 = t ;
s1 = t ;
}
}
if ( t0 && s0 && ( s0 < t0 ) ) t0 = s0 ;
if ( t1 && s1 && ( s1 > t1 ) ) t1 = s1 ;
if ( ! t0 ) {
* e = u ;
* elen = ulen ;
return rc ;
}
tocode = fromcode ;
if ( icode ) {
tocode1 = mutt_ch_choose ( icode , charsets , u , ulen , 0 , 0 ) ;
if ( tocode1 ) tocode = tocode1 ;
else {
rc = 2 ;
icode = 0 ;
}
}
if ( ! icode && mutt_ch_is_us_ascii ( tocode ) ) tocode = "unknown-8bit" ;
t = u + ( ENCWORD_LEN_MAX + 1 ) - col - ENCWORD_LEN_MIN ;
if ( t < u ) t = u ;
if ( t < t0 ) t0 = t ;
for ( ;
t0 > u ;
t0 -- ) {
if ( ! HSPACE ( * ( t0 - 1 ) ) ) continue ;
t = t0 + 1 ;
if ( icode ) while ( ( t < ( u + ulen ) ) && CONTINUATION_BYTE ( * t ) ) t ++ ;
if ( ( try_block ( t0 , t - t0 , icode , tocode , & encoder , & wlen ) == 0 ) && ( ( col + ( t0 - u ) + wlen ) <= ( ENCWORD_LEN_MAX + 1 ) ) ) {
break ;
}
}
for ( ;
t1 < ( u + ulen ) ;
t1 ++ ) {
if ( ! HSPACE ( * t1 ) ) continue ;
t = t1 - 1 ;
if ( icode ) while ( CONTINUATION_BYTE ( * t ) ) t -- ;
if ( ( try_block ( t , t1 - t , icode , tocode , & encoder , & wlen ) == 0 ) && ( ( 1 + wlen + ( u + ulen - t1 ) ) <= ( ENCWORD_LEN_MAX + 1 ) ) ) {
break ;
}
}
buflen = 2 * ulen ;
buf = mutt_mem_malloc ( buflen ) ;
bufpos = t0 - u ;
memcpy ( buf , u , t0 - u ) ;
col += t0 - u ;
t = t0 ;
while ( true ) {
size_t n = choose_block ( t , t1 - t , col , icode , tocode , & encoder , & wlen ) ;
if ( n == ( t1 - t ) ) {
if ( ( col + wlen + ( u + ulen - t1 ) ) <= ( ENCWORD_LEN_MAX + 1 ) ) break ;
n = t1 - t - 1 ;
if ( icode ) while ( CONTINUATION_BYTE ( t [ n ] ) ) n -- ;
if ( ! n ) {
assert ( t1 < ( u + ulen ) ) ;
for ( t1 ++ ;
( t1 < ( u + ulen ) ) && ! HSPACE ( * t1 ) ;
t1 ++ ) ;
continue ;
}
n = choose_block ( t , n , col , icode , tocode , & encoder , & wlen ) ;
}
const char * line_break = "\n\t" ;
const int lb_len = 2 ;
if ( ( bufpos + wlen + lb_len ) > buflen ) {
buflen = bufpos + wlen + lb_len ;
mutt_mem_realloc ( & buf , buflen ) ;
}
r = encode_block ( buf + bufpos , t , n , icode , tocode , encoder ) ;
assert ( r == wlen ) ;
bufpos += wlen ;
memcpy ( buf + bufpos , line_break , lb_len ) ;
bufpos += lb_len ;
col = 1 ;
t += n ;
}
buflen = bufpos + wlen + ( u + ulen - t1 ) ;
mutt_mem_realloc ( & buf , buflen + 1 ) ;
r = encode_block ( buf + bufpos , t , t1 - t , icode , tocode , encoder ) ;
assert ( r == wlen ) ;
bufpos += wlen ;
memcpy ( buf + bufpos , t1 , u + ulen - t1 ) ;
FREE ( & tocode1 ) ;
FREE ( & u ) ;
buf [ buflen ] = '\0' ;
* e = buf ;
* elen = buflen + 1 ;
return rc ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline int file_path_has_perm ( const struct cred * cred , struct file * file , u32 av ) {
struct common_audit_data ad ;
ad . type = LSM_AUDIT_DATA_FILE ;
ad . u . file = file ;
return inode_has_perm ( cred , file_inode ( file ) , av , & ad ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void print_value ( FILE * file , MYSQL_RES * result , MYSQL_ROW row , const char * prefix , const char * name , int string_value ) {
MYSQL_FIELD * field ;
mysql_field_seek ( result , 0 ) ;
for ( ;
( field = mysql_fetch_field ( result ) ) ;
row ++ ) {
if ( ! strcmp ( field -> name , name ) ) {
if ( row [ 0 ] && row [ 0 ] [ 0 ] && strcmp ( row [ 0 ] , "0" ) ) {
fputc ( ' ' , file ) ;
fputs ( prefix , file ) ;
if ( string_value ) unescape ( file , row [ 0 ] , strlen ( row [ 0 ] ) ) ;
else fputs ( row [ 0 ] , file ) ;
check_io ( file ) ;
return ;
}
}
}
return ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void dissect_rsvp_xro_subobjects ( proto_tree * ti , packet_info * pinfo , proto_tree * rsvp_object_tree , tvbuff_t * tvb , int offset , int obj_length , int rsvp_class ) {
int i , lbit , type , l ;
proto_tree * rsvp_xro_subtree ;
int tree_type ;
switch ( rsvp_class ) {
case RSVP_CLASS_EXCLUDE_ROUTE : tree_type = TREE ( TT_EXCLUDE_ROUTE_SUBOBJ ) ;
break ;
default : return ;
}
for ( i = 1 , l = 0 ;
l < obj_length - 4 ;
i ++ ) {
lbit = tvb_get_guint8 ( tvb , offset + l ) & 0x80 ;
type = tvb_get_guint8 ( tvb , offset + l ) & 0x7f ;
switch ( type ) {
case 1 : rsvp_xro_subtree = proto_tree_add_subtree_format ( rsvp_object_tree , tvb , offset + l , 8 , tree_type , NULL , "IPv4 Subobject - %s" , tvb_ip_to_str ( tvb , offset + l + 2 ) ) ;
proto_tree_add_item ( rsvp_xro_subtree , hf_rsvp_xro_sobj_lbit , tvb , offset + l , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_xro_subtree , hf_rsvp_xro_sobj_type , tvb , offset + l , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_xro_subtree , hf_rsvp_xro_sobj_len , tvb , offset + l + 1 , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_xro_subtree , hf_rsvp_xro_sobj_ipv4_addr , tvb , offset + l + 2 , 4 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_xro_subtree , hf_rsvp_xro_sobj_ipv4_prefix , tvb , offset + l + 6 , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_xro_subtree , hf_rsvp_xro_sobj_ipv4_attr , tvb , offset + l + 7 , 1 , ENC_BIG_ENDIAN ) ;
if ( i < 4 ) {
proto_item_append_text ( ti , "IPv4 %s%s" , tvb_ip_to_str ( tvb , offset + l + 2 ) , lbit ? " [L]" : "" ) ;
}
break ;
case 2 : rsvp_xro_subtree = proto_tree_add_subtree_format ( rsvp_object_tree , tvb , offset + l , 20 , tree_type , NULL , "IPv6 Subobject - %s" , tvb_ip6_to_str ( tvb , offset + l + 2 ) ) ;
proto_tree_add_item ( rsvp_xro_subtree , hf_rsvp_xro_sobj_lbit , tvb , offset + l , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_xro_subtree , hf_rsvp_xro_sobj_type , tvb , offset + l , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_xro_subtree , hf_rsvp_xro_sobj_len , tvb , offset + l + 1 , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_xro_subtree , hf_rsvp_xro_sobj_ipv6_addr , tvb , offset + l + 2 , 16 , ENC_NA ) ;
proto_tree_add_item ( rsvp_xro_subtree , hf_rsvp_xro_sobj_ipv6_prefix , tvb , offset + l + 18 , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_xro_subtree , hf_rsvp_xro_sobj_ipv6_attr , tvb , offset + l + 19 , 1 , ENC_BIG_ENDIAN ) ;
if ( i < 4 ) {
proto_item_append_text ( ti , "IPv6 [...]%s" , lbit ? " [L]" : "" ) ;
}
break ;
case 34 : rsvp_xro_subtree = proto_tree_add_subtree_format ( rsvp_object_tree , tvb , offset + l , 8 , tree_type , NULL , "SRLG Subobject - %u" , tvb_get_ntohl ( tvb , offset + l + 2 ) ) ;
proto_tree_add_item ( rsvp_xro_subtree , hf_rsvp_xro_sobj_lbit , tvb , offset + l , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_xro_subtree , hf_rsvp_xro_sobj_type , tvb , offset + l , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_xro_subtree , hf_rsvp_xro_sobj_len , tvb , offset + l + 1 , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_xro_subtree , hf_rsvp_xro_sobj_srlg_id , tvb , offset + l + 2 , 4 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_xro_subtree , hf_rsvp_xro_sobj_srlg_res , tvb , offset + l + 6 , 2 , ENC_BIG_ENDIAN ) ;
if ( i < 4 ) {
proto_item_append_text ( ti , "SRLG %u%s" , tvb_get_ntohl ( tvb , offset + l + 2 ) , lbit ? " [L]" : "" ) ;
}
break ;
default : rsvp_xro_subtree = proto_tree_add_subtree_format ( rsvp_object_tree , tvb , offset + l , tvb_get_guint8 ( tvb , offset + l + 1 ) , tree_type , NULL , "Unknown subobject: %d" , type ) ;
proto_tree_add_item ( rsvp_xro_subtree , hf_rsvp_xro_sobj_lbit , tvb , offset + l , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_xro_subtree , hf_rsvp_xro_sobj_type , tvb , offset + l , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( rsvp_xro_subtree , hf_rsvp_xro_sobj_len , tvb , offset + l + 1 , 1 , ENC_BIG_ENDIAN ) ;
break ;
}
if ( tvb_get_guint8 ( tvb , offset + l + 1 ) < 1 ) {
proto_tree_add_expert_format ( rsvp_xro_subtree , pinfo , & ei_rsvp_invalid_length , tvb , offset + l + 1 , 1 , "Invalid Length: %u" , tvb_get_guint8 ( tvb , offset + l + 1 ) ) ;
return ;
}
l += tvb_get_guint8 ( tvb , offset + l + 1 ) ;
if ( l < obj_length - 4 ) {
if ( i < 4 ) proto_item_append_text ( ti , ", " ) ;
else if ( i == 4 ) proto_item_append_text ( ti , "..." ) ;
}
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
err_status_t srtp_kdf_clear ( srtp_kdf_t * kdf ) {
err_status_t status ;
status = cipher_dealloc ( kdf -> cipher ) ;
if ( status ) return status ;
kdf -> cipher = NULL ;
return err_status_ok ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void test_bind_nagative ( ) {
MYSQL_STMT * stmt_insert ;
char * query ;
int rc ;
MYSQL_BIND my_bind [ 1 ] ;
int32 my_val = 0 ;
ulong my_length = 0L ;
my_bool my_null = FALSE ;
myheader ( "test_insert_select" ) ;
rc = mysql_query ( mysql , "DROP TABLE IF EXISTS t1" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "create temporary table t1 (c1 int unsigned)" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "INSERT INTO t1 VALUES (1), (-1)" ) ;
myquery ( rc ) ;
query = ( char * ) "INSERT INTO t1 VALUES (?)" ;
stmt_insert = mysql_simple_prepare ( mysql , query ) ;
check_stmt ( stmt_insert ) ;
memset ( my_bind , 0 , sizeof ( my_bind ) ) ;
my_bind [ 0 ] . buffer_type = MYSQL_TYPE_LONG ;
my_bind [ 0 ] . buffer = ( void * ) & my_val ;
my_bind [ 0 ] . length = & my_length ;
my_bind [ 0 ] . is_null = ( char * ) & my_null ;
rc = mysql_stmt_bind_param ( stmt_insert , my_bind ) ;
check_execute ( stmt_insert , rc ) ;
my_val = - 1 ;
rc = mysql_stmt_execute ( stmt_insert ) ;
check_execute ( stmt_insert , rc ) ;
mysql_stmt_close ( stmt_insert ) ;
rc = mysql_query ( mysql , "drop table t1" ) ;
myquery ( rc ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TSAction TSNetConnect ( TSCont contp , sockaddr const * addr ) {
sdk_assert ( sdk_sanity_check_continuation ( contp ) == TS_SUCCESS ) ;
sdk_assert ( ats_is_ip ( addr ) ) ;
HttpConfigParams * http_config_param = HttpConfig : : acquire ( ) ;
NetVCOptions opt ;
if ( http_config_param ) {
opt . set_sock_param ( http_config_param -> oride . sock_recv_buffer_size_out , http_config_param -> oride . sock_send_buffer_size_out , http_config_param -> oride . sock_option_flag_out , http_config_param -> oride . sock_packet_mark_out , http_config_param -> oride . sock_packet_tos_out ) ;
HttpConfig : : release ( http_config_param ) ;
}
FORCE_PLUGIN_SCOPED_MUTEX ( contp ) ;
return reinterpret_cast < TSAction > ( netProcessor . connect_re ( reinterpret_cast < INKContInternal * > ( contp ) , addr , & opt ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static ossl_inline type * lh_ ## type ## _insert ( LHASH_OF ( type ) * lh , type * d ) {
return ( type * ) OPENSSL_LH_insert ( ( OPENSSL_LHASH * ) lh , d ) ;
}
static ossl_inline type * lh_ ## type ## _delete ( LHASH_OF ( type ) * lh , const type * d ) {
return ( type * ) OPENSSL_LH_delete ( ( OPENSSL_LHASH * ) lh , d ) ;
}
static ossl_inline type * lh_ ## type ## _retrieve ( LHASH_OF ( type ) * lh , const type * d ) {
return ( type * ) OPENSSL_LH_retrieve ( ( OPENSSL_LHASH * ) lh , d ) ;
}
static ossl_inline int lh_ ## type ## _error ( LHASH_OF ( type ) * lh ) {
return OPENSSL_LH_error ( ( OPENSSL_LHASH * ) lh ) ;
}
static ossl_inline unsigned long lh_ ## type ## _num_items ( LHASH_OF ( type ) * lh ) {
return OPENSSL_LH_num_items ( ( OPENSSL_LHASH * ) lh ) ;
}
static ossl_inline void lh_ ## type ## _node_stats_bio ( const LHASH_OF ( type ) * lh , BIO * out ) {
OPENSSL_LH_node_stats_bio ( ( const OPENSSL_LHASH * ) lh , out ) ;
}
static ossl_inline void lh_ ## type ## _node_usage_stats_bio ( const LHASH_OF ( type ) * lh , BIO * out ) {
OPENSSL_LH_node_usage_stats_bio ( ( const OPENSSL_LHASH * ) lh , out ) ;
}
static ossl_inline void lh_ ## type ## _stats_bio ( const LHASH_OF ( type ) * lh , BIO * out ) {
OPENSSL_LH_stats_bio ( ( const OPENSSL_LHASH * ) lh , out ) ;
}
static ossl_inline unsigned long lh_ ## type ## _get_down_load ( LHASH_OF ( type ) * lh ) {
return OPENSSL_LH_get_down_load ( ( OPENSSL_LHASH * ) lh ) ;
}
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 ) ;
# ifdef _MSC_VER # pragma warning ( push ) # pragma warning ( disable : 4090 ) # endif DEFINE_LHASH_OF ( OPENSSL_CSTRING )
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int decode_residual_block ( AVSContext * h , GetBitContext * gb , const struct dec_2dvlc * r , int esc_golomb_order , int qp , uint8_t * dst , int stride ) {
int i , level_code , esc_code , level , run , mask ;
int16_t level_buf [ 65 ] ;
uint8_t run_buf [ 65 ] ;
int16_t * block = h -> block ;
for ( i = 0 ;
i < 65 ;
i ++ ) {
level_code = get_ue_code ( gb , r -> golomb_order ) ;
if ( level_code >= ESCAPE_CODE ) {
run = ( ( level_code - ESCAPE_CODE ) >> 1 ) + 1 ;
esc_code = get_ue_code ( gb , esc_golomb_order ) ;
level = esc_code + ( run > r -> max_run ? 1 : r -> level_add [ run ] ) ;
while ( level > r -> inc_limit ) r ++ ;
mask = - ( level_code & 1 ) ;
level = ( level ^ mask ) - mask ;
}
else if ( level_code >= 0 ) {
level = r -> rltab [ level_code ] [ 0 ] ;
if ( ! level ) break ;
run = r -> rltab [ level_code ] [ 1 ] ;
r += r -> rltab [ level_code ] [ 2 ] ;
}
else {
break ;
}
level_buf [ i ] = level ;
run_buf [ i ] = run ;
}
if ( dequant ( h , level_buf , run_buf , block , dequant_mul [ qp ] , dequant_shift [ qp ] , i ) ) return - 1 ;
h -> cdsp . cavs_idct8_add ( dst , block , stride ) ;
h -> dsp . clear_block ( block ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static struct hash_list * parse_merge ( unsigned int * count ) {
struct hash_list * list = NULL , * * tail = & list , * n ;
const char * from ;
struct branch * s ;
* count = 0 ;
while ( skip_prefix ( command_buf . buf , "merge " , & from ) ) {
n = xmalloc ( sizeof ( * n ) ) ;
s = lookup_branch ( from ) ;
if ( s ) hashcpy ( n -> sha1 , s -> sha1 ) ;
else if ( * from == ':' ) {
uintmax_t idnum = parse_mark_ref_eol ( from ) ;
struct object_entry * oe = find_mark ( idnum ) ;
if ( oe -> type != OBJ_COMMIT ) die ( "Mark :%" PRIuMAX " not a commit" , idnum ) ;
hashcpy ( n -> sha1 , oe -> idx . sha1 ) ;
}
else if ( ! get_sha1 ( from , n -> sha1 ) ) {
unsigned long size ;
char * buf = read_object_with_reference ( n -> sha1 , commit_type , & size , n -> sha1 ) ;
if ( ! buf || size < 46 ) die ( "Not a valid commit: %s" , from ) ;
free ( buf ) ;
}
else die ( "Invalid ref name or SHA1 expression: %s" , from ) ;
n -> next = NULL ;
* tail = n ;
tail = & n -> next ;
( * count ) ++ ;
read_next_command ( ) ;
}
return list ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void print_table_data_vertically ( MYSQL_RES * result ) {
MYSQL_ROW cur ;
uint max_length = 0 ;
MYSQL_FIELD * field ;
while ( ( field = mysql_fetch_field ( result ) ) ) {
uint length = field -> name_length ;
if ( length > max_length ) max_length = length ;
field -> max_length = length ;
}
mysql_field_seek ( result , 0 ) ;
for ( uint row_count = 1 ;
( cur = mysql_fetch_row ( result ) ) ;
row_count ++ ) {
if ( interrupted_query ) break ;
mysql_field_seek ( result , 0 ) ;
tee_fprintf ( PAGER , "*************************** %d. row ***************************\n" , row_count ) ;
ulong * lengths = mysql_fetch_lengths ( result ) ;
for ( uint off = 0 ;
off < mysql_num_fields ( result ) ;
off ++ ) {
field = mysql_fetch_field ( result ) ;
if ( column_names ) tee_fprintf ( PAGER , "%*s: " , ( int ) max_length , field -> name ) ;
if ( cur [ off ] ) {
unsigned int i ;
const char * p ;
for ( i = 0 , p = cur [ off ] ;
i < lengths [ off ] ;
i += 1 , p += 1 ) {
if ( * p == '\0' ) tee_putc ( ( int ) ' ' , PAGER ) ;
else tee_putc ( ( int ) * p , PAGER ) ;
}
tee_putc ( '\n' , PAGER ) ;
}
else tee_fprintf ( PAGER , "NULL\n" ) ;
}
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static UBool hasCESU8Data ( const UConverter * cnv ) {
# if UCONFIG_ONLY_HTML_CONVERSION return FALSE ;
# else return ( UBool ) ( cnv -> sharedData == & _CESU8Data ) ;
# endif }
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vp8_strict_quantize_b_c ( BLOCK * b , BLOCKD * d ) {
int i ;
int rc ;
int eob ;
int x ;
int y ;
int z ;
int sz ;
short * coeff_ptr ;
short * quant_ptr ;
short * quant_shift_ptr ;
short * qcoeff_ptr ;
short * dqcoeff_ptr ;
short * dequant_ptr ;
coeff_ptr = b -> coeff ;
quant_ptr = b -> quant ;
quant_shift_ptr = b -> quant_shift ;
qcoeff_ptr = d -> qcoeff ;
dqcoeff_ptr = d -> dqcoeff ;
dequant_ptr = d -> dequant ;
eob = - 1 ;
vpx_memset ( qcoeff_ptr , 0 , 32 ) ;
vpx_memset ( dqcoeff_ptr , 0 , 32 ) ;
for ( i = 0 ;
i < 16 ;
i ++ ) {
int dq ;
int rounding ;
rc = vp8_default_zig_zag1d [ i ] ;
z = coeff_ptr [ rc ] ;
dq = dequant_ptr [ rc ] ;
rounding = dq >> 1 ;
sz = - ( z < 0 ) ;
x = ( z + sz ) ^ sz ;
x += rounding ;
if ( x >= dq ) {
y = ( ( ( ( x * quant_ptr [ rc ] ) >> 16 ) + x ) * quant_shift_ptr [ rc ] ) >> 16 ;
x = ( y + sz ) ^ sz ;
qcoeff_ptr [ rc ] = x ;
dqcoeff_ptr [ rc ] = x * dq ;
if ( y ) eob = i ;
}
}
* d -> eob = ( char ) ( eob + 1 ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int run_cancel_or_skip_warning ( CommonJob * job , char * primary_text , char * secondary_text , const char * details_text , int total_operations , int operations_remaining ) {
int response ;
if ( total_operations == 1 ) {
response = run_warning ( job , primary_text , secondary_text , details_text , FALSE , CANCEL , NULL ) ;
}
else {
response = run_warning ( job , primary_text , secondary_text , details_text , operations_remaining > 1 , CANCEL , SKIP_ALL , SKIP , NULL ) ;
}
return response ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int setup_interp_filter_search_mask ( VP9_COMP * cpi ) {
INTERP_FILTER ifilter ;
int ref_total [ MAX_REF_FRAMES ] = {
0 }
;
MV_REFERENCE_FRAME ref ;
int mask = 0 ;
if ( cpi -> common . last_frame_type == KEY_FRAME || cpi -> refresh_alt_ref_frame ) return mask ;
for ( ref = LAST_FRAME ;
ref <= ALTREF_FRAME ;
++ ref ) for ( ifilter = EIGHTTAP ;
ifilter <= EIGHTTAP_SHARP ;
++ ifilter ) ref_total [ ref ] += cpi -> interp_filter_selected [ ref ] [ ifilter ] ;
for ( ifilter = EIGHTTAP ;
ifilter <= EIGHTTAP_SHARP ;
++ ifilter ) {
if ( ( ref_total [ LAST_FRAME ] && cpi -> interp_filter_selected [ LAST_FRAME ] [ ifilter ] == 0 ) && ( ref_total [ GOLDEN_FRAME ] == 0 || cpi -> interp_filter_selected [ GOLDEN_FRAME ] [ ifilter ] * 50 < ref_total [ GOLDEN_FRAME ] ) && ( ref_total [ ALTREF_FRAME ] == 0 || cpi -> interp_filter_selected [ ALTREF_FRAME ] [ ifilter ] * 50 < ref_total [ ALTREF_FRAME ] ) ) mask |= 1 << ifilter ;
}
return mask ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline void store_mvs ( AVSContext * h ) {
h -> col_mv [ h -> mbidx * 4 + 0 ] = h -> mv [ MV_FWD_X0 ] ;
h -> col_mv [ h -> mbidx * 4 + 1 ] = h -> mv [ MV_FWD_X1 ] ;
h -> col_mv [ h -> mbidx * 4 + 2 ] = h -> mv [ MV_FWD_X2 ] ;
h -> col_mv [ h -> mbidx * 4 + 3 ] = h -> mv [ MV_FWD_X3 ] ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
unsigned int auth_server_connection_add_request ( struct auth_server_connection * conn , struct auth_client_request * request ) {
unsigned int id ;
i_assert ( conn -> handshake_received ) ;
id = ++ conn -> client -> request_id_counter ;
if ( id == 0 ) {
id = ++ conn -> client -> request_id_counter ;
}
i_assert ( hash_table_lookup ( conn -> requests , POINTER_CAST ( id ) ) == NULL ) ;
hash_table_insert ( conn -> requests , POINTER_CAST ( id ) , request ) ;
return id ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
SPL_METHOD ( SplFileObject , setFlags ) {
spl_filesystem_object * intern = ( spl_filesystem_object * ) zend_object_store_get_object ( getThis ( ) TSRMLS_CC ) ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , "l" , & intern -> flags ) == FAILURE ) {
return ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void kvm_synchronize_all_tsc ( void ) {
CPUState * cpu ;
if ( kvm_enabled ( ) ) {
CPU_FOREACH ( cpu ) {
run_on_cpu ( cpu , do_kvm_synchronize_tsc , RUN_ON_CPU_NULL ) ;
}
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void activate_files ( ActivateParameters * parameters ) {
NautilusFile * file ;
NautilusWindow * window ;
NautilusWindowOpenFlags flags ;
g_autoptr ( GList ) open_in_app_parameters = NULL ;
g_autoptr ( GList ) unhandled_open_in_app_uris = NULL ;
ApplicationLaunchParameters * one_parameters ;
int count ;
g_autofree char * old_working_dir = NULL ;
GdkScreen * screen ;
gint num_apps ;
gint num_unhandled ;
gint num_files ;
gboolean open_files ;
gboolean closed_window ;
g_autoptr ( GQueue ) launch_desktop_files = NULL ;
g_autoptr ( GQueue ) launch_files = NULL ;
g_autoptr ( GQueue ) launch_in_terminal_files = NULL ;
g_autoptr ( GQueue ) open_in_app_uris = NULL ;
g_autoptr ( GQueue ) open_in_view_files = NULL ;
GList * l ;
ActivationAction action ;
LaunchLocation * location ;
launch_desktop_files = g_queue_new ( ) ;
launch_files = g_queue_new ( ) ;
launch_in_terminal_files = g_queue_new ( ) ;
open_in_view_files = g_queue_new ( ) ;
open_in_app_uris = g_queue_new ( ) ;
for ( l = parameters -> locations ;
l != NULL ;
l = l -> next ) {
location = l -> data ;
file = location -> file ;
if ( file_was_cancelled ( file ) ) {
continue ;
}
action = get_activation_action ( file ) ;
if ( action == ACTIVATION_ACTION_ASK ) {
pause_activation_timed_cancel ( parameters ) ;
action = get_executable_text_file_action ( parameters -> parent_window , file ) ;
unpause_activation_timed_cancel ( parameters ) ;
}
switch ( action ) {
case ACTIVATION_ACTION_LAUNCH_DESKTOP_FILE : {
g_queue_push_tail ( launch_desktop_files , file ) ;
}
break ;
case ACTIVATION_ACTION_LAUNCH : {
g_queue_push_tail ( launch_files , file ) ;
}
break ;
case ACTIVATION_ACTION_LAUNCH_IN_TERMINAL : {
g_queue_push_tail ( launch_in_terminal_files , file ) ;
}
break ;
case ACTIVATION_ACTION_OPEN_IN_VIEW : {
g_queue_push_tail ( open_in_view_files , file ) ;
}
break ;
case ACTIVATION_ACTION_OPEN_IN_APPLICATION : {
g_queue_push_tail ( open_in_app_uris , location -> uri ) ;
}
break ;
case ACTIVATION_ACTION_DO_NOTHING : {
}
break ;
case ACTIVATION_ACTION_EXTRACT : {
g_assert_not_reached ( ) ;
}
break ;
case ACTIVATION_ACTION_ASK : {
g_assert_not_reached ( ) ;
}
break ;
}
}
for ( l = g_queue_peek_head_link ( launch_desktop_files ) ;
l != NULL ;
l = l -> next ) {
file = NAUTILUS_FILE ( l -> data ) ;
activate_desktop_file ( parameters , file ) ;
}
if ( parameters -> activation_directory && ( ! g_queue_is_empty ( launch_files ) || ! g_queue_is_empty ( launch_in_terminal_files ) ) ) {
old_working_dir = g_get_current_dir ( ) ;
g_chdir ( parameters -> activation_directory ) ;
}
screen = gtk_widget_get_screen ( GTK_WIDGET ( parameters -> parent_window ) ) ;
for ( l = g_queue_peek_head_link ( launch_files ) ;
l != NULL ;
l = l -> next ) {
g_autofree char * uri = NULL ;
g_autofree char * executable_path = NULL ;
g_autofree char * quoted_path = NULL ;
file = NAUTILUS_FILE ( l -> data ) ;
uri = nautilus_file_get_activation_uri ( file ) ;
executable_path = g_filename_from_uri ( uri , NULL , NULL ) ;
quoted_path = g_shell_quote ( executable_path ) ;
DEBUG ( "Launching file path %s" , quoted_path ) ;
nautilus_launch_application_from_command ( screen , quoted_path , FALSE , NULL ) ;
}
for ( l = g_queue_peek_head_link ( launch_in_terminal_files ) ;
l != NULL ;
l = l -> next ) {
g_autofree char * uri = NULL ;
g_autofree char * executable_path = NULL ;
g_autofree char * quoted_path = NULL ;
file = NAUTILUS_FILE ( l -> data ) ;
uri = nautilus_file_get_activation_uri ( file ) ;
executable_path = g_filename_from_uri ( uri , NULL , NULL ) ;
quoted_path = g_shell_quote ( executable_path ) ;
DEBUG ( "Launching in terminal file quoted path %s" , quoted_path ) ;
nautilus_launch_application_from_command ( screen , quoted_path , TRUE , NULL ) ;
}
if ( old_working_dir != NULL ) {
g_chdir ( old_working_dir ) ;
}
count = g_queue_get_length ( open_in_view_files ) ;
flags = parameters -> flags ;
if ( count > 1 ) {
if ( ( parameters -> flags & NAUTILUS_WINDOW_OPEN_FLAG_NEW_WINDOW ) == 0 ) {
if ( ( parameters -> flags & NAUTILUS_WINDOW_OPEN_FLAG_CLOSE_BEHIND ) != 0 ) {
flags |= NAUTILUS_WINDOW_OPEN_FLAG_NEW_WINDOW ;
}
else {
flags |= NAUTILUS_WINDOW_OPEN_FLAG_NEW_TAB ;
}
}
else {
flags |= NAUTILUS_WINDOW_OPEN_FLAG_NEW_WINDOW ;
}
}
else {
if ( ( parameters -> flags & NAUTILUS_WINDOW_OPEN_FLAG_CLOSE_BEHIND ) != 0 ) {
flags |= NAUTILUS_WINDOW_OPEN_FLAG_NEW_WINDOW ;
}
}
if ( parameters -> slot != NULL && ( ! parameters -> user_confirmation || confirm_multiple_windows ( parameters -> parent_window , count , ( flags & NAUTILUS_WINDOW_OPEN_FLAG_NEW_TAB ) != 0 ) ) ) {
if ( ( flags & NAUTILUS_WINDOW_OPEN_FLAG_NEW_TAB ) != 0 && g_settings_get_enum ( nautilus_preferences , NAUTILUS_PREFERENCES_NEW_TAB_POSITION ) == NAUTILUS_NEW_TAB_POSITION_AFTER_CURRENT_TAB ) {
g_queue_reverse ( open_in_view_files ) ;
}
closed_window = FALSE ;
for ( l = g_queue_peek_head_link ( open_in_view_files ) ;
l != NULL ;
l = l -> next ) {
g_autofree char * uri = NULL ;
g_autoptr ( GFile ) location = NULL ;
g_autoptr ( GFile ) location_with_permissions = NULL ;
file = NAUTILUS_FILE ( l -> data ) ;
uri = nautilus_file_get_activation_uri ( file ) ;
location = g_file_new_for_uri ( uri ) ;
if ( g_file_is_native ( location ) && ( nautilus_file_is_in_admin ( file ) || ! nautilus_file_can_read ( file ) || ! nautilus_file_can_execute ( file ) ) ) {
g_autofree gchar * file_path = NULL ;
g_free ( uri ) ;
file_path = g_file_get_path ( location ) ;
uri = g_strconcat ( "admin://" , file_path , NULL ) ;
}
location_with_permissions = g_file_new_for_uri ( uri ) ;
nautilus_application_open_location_full ( NAUTILUS_APPLICATION ( g_application_get_default ( ) ) , location_with_permissions , flags , NULL , NULL , parameters -> slot ) ;
if ( ! closed_window && ( flags & NAUTILUS_WINDOW_OPEN_FLAG_CLOSE_BEHIND ) != 0 ) {
flags &= ( ~ NAUTILUS_WINDOW_OPEN_FLAG_CLOSE_BEHIND ) ;
if ( ( parameters -> flags & NAUTILUS_WINDOW_OPEN_FLAG_NEW_WINDOW ) == 0 ) {
flags &= ( ~ NAUTILUS_WINDOW_OPEN_FLAG_NEW_WINDOW ) ;
flags |= NAUTILUS_WINDOW_OPEN_FLAG_NEW_TAB ;
}
closed_window = TRUE ;
}
}
}
if ( open_in_app_uris != NULL ) {
open_in_app_parameters = make_activation_parameters ( g_queue_peek_head_link ( open_in_app_uris ) , & unhandled_open_in_app_uris ) ;
}
num_apps = g_list_length ( open_in_app_parameters ) ;
num_unhandled = g_list_length ( unhandled_open_in_app_uris ) ;
num_files = g_queue_get_length ( open_in_app_uris ) ;
open_files = TRUE ;
if ( g_queue_is_empty ( open_in_app_uris ) && ( ! parameters -> user_confirmation || num_files + num_unhandled > SILENT_OPEN_LIMIT ) && num_apps > 1 ) {
GtkDialog * dialog ;
char * prompt ;
g_autofree char * detail = NULL ;
int response ;
pause_activation_timed_cancel ( parameters ) ;
prompt = _ ( "Are you sure you want to open all files?" ) ;
detail = g_strdup_printf ( ngettext ( "This will open %d separate application." , "This will open %d separate applications." , num_apps ) , num_apps ) ;
dialog = eel_show_yes_no_dialog ( prompt , detail , _ ( "_OK" ) , _ ( "_Cancel" ) , parameters -> parent_window ) ;
response = gtk_dialog_run ( dialog ) ;
gtk_widget_destroy ( GTK_WIDGET ( dialog ) ) ;
unpause_activation_timed_cancel ( parameters ) ;
if ( response != GTK_RESPONSE_YES ) {
open_files = FALSE ;
}
}
if ( open_files ) {
for ( l = open_in_app_parameters ;
l != NULL ;
l = l -> next ) {
one_parameters = l -> data ;
nautilus_launch_application_by_uri ( one_parameters -> application , one_parameters -> uris , parameters -> parent_window ) ;
application_launch_parameters_free ( one_parameters ) ;
}
for ( l = unhandled_open_in_app_uris ;
l != NULL ;
l = l -> next ) {
char * uri = l -> data ;
application_unhandled_uri ( parameters , uri ) ;
}
}
window = NULL ;
if ( parameters -> slot != NULL ) {
window = nautilus_window_slot_get_window ( parameters -> slot ) ;
}
if ( open_in_app_parameters != NULL || unhandled_open_in_app_uris != NULL ) {
if ( ( parameters -> flags & NAUTILUS_WINDOW_OPEN_FLAG_CLOSE_BEHIND ) != 0 && window != NULL ) {
nautilus_window_close ( window ) ;
}
}
activation_parameters_free ( parameters ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h225_T_billingMode ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_choice ( tvb , offset , actx , tree , hf_index , ett_h225_T_billingMode , T_billingMode_choice , NULL ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int main ( int argc , char * * argv ) {
using std : : string ;
if ( argc != 2 ) {
fprintf ( stderr , "One argument, the input filename, must be provided.\n" ) ;
return 1 ;
}
string filename ( argv [ 1 ] ) ;
string outfilename = filename . substr ( 0 , filename . find_last_of ( "." ) ) + ".ttf" ;
string input = woff2 : : GetFileContent ( filename ) ;
const uint8_t * raw_input = reinterpret_cast < const uint8_t * > ( input . data ( ) ) ;
string output ( std : : min ( woff2 : : ComputeWOFF2FinalSize ( raw_input , input . size ( ) ) , woff2 : : kDefaultMaxSize ) , 0 ) ;
woff2 : : WOFF2StringOut out ( & output ) ;
const bool ok = woff2 : : ConvertWOFF2ToTTF ( raw_input , input . size ( ) , & out ) ;
if ( ok ) {
woff2 : : SetFileContents ( outfilename , output . begin ( ) , output . begin ( ) + out . Size ( ) ) ;
}
return ok ? 0 : 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int dissect_ber_constrained_sequence_of ( gboolean implicit_tag , asn1_ctx_t * actx , proto_tree * parent_tree , tvbuff_t * tvb , int offset , gint32 min_len , gint32 max_len , const ber_sequence_t * seq , gint hf_id , gint ett_id ) {
return dissect_ber_sq_of ( implicit_tag , BER_UNI_TAG_SEQUENCE , actx , parent_tree , tvb , offset , min_len , max_len , seq , hf_id , ett_id ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static cmsStage * ReadMatrix ( struct _cms_typehandler_struct * self , cmsIOHANDLER * io , cmsUInt32Number Offset ) {
cmsFloat64Number dMat [ 3 * 3 ] ;
cmsFloat64Number dOff [ 3 ] ;
cmsStage * Mat ;
if ( ! io -> Seek ( io , Offset ) ) return NULL ;
if ( ! _cmsRead15Fixed16Number ( io , & dMat [ 0 ] ) ) return NULL ;
if ( ! _cmsRead15Fixed16Number ( io , & dMat [ 1 ] ) ) return NULL ;
if ( ! _cmsRead15Fixed16Number ( io , & dMat [ 2 ] ) ) return NULL ;
if ( ! _cmsRead15Fixed16Number ( io , & dMat [ 3 ] ) ) return NULL ;
if ( ! _cmsRead15Fixed16Number ( io , & dMat [ 4 ] ) ) return NULL ;
if ( ! _cmsRead15Fixed16Number ( io , & dMat [ 5 ] ) ) return NULL ;
if ( ! _cmsRead15Fixed16Number ( io , & dMat [ 6 ] ) ) return NULL ;
if ( ! _cmsRead15Fixed16Number ( io , & dMat [ 7 ] ) ) return NULL ;
if ( ! _cmsRead15Fixed16Number ( io , & dMat [ 8 ] ) ) return NULL ;
if ( ! _cmsRead15Fixed16Number ( io , & dOff [ 0 ] ) ) return NULL ;
if ( ! _cmsRead15Fixed16Number ( io , & dOff [ 1 ] ) ) return NULL ;
if ( ! _cmsRead15Fixed16Number ( io , & dOff [ 2 ] ) ) return NULL ;
Mat = cmsStageAllocMatrix ( self -> ContextID , 3 , 3 , dMat , dOff ) ;
return Mat ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int main ( int argc , char * * argv ) {
BlockBackend * blk ;
BlockDriverState * bs ;
off_t dev_offset = 0 ;
uint16_t nbdflags = 0 ;
bool disconnect = false ;
const char * bindto = NULL ;
const char * port = NULL ;
char * sockpath = NULL ;
char * device = NULL ;
off_t fd_size ;
QemuOpts * sn_opts = NULL ;
const char * sn_id_or_name = NULL ;
const char * sopt = "hVb:o:p:rsnP:c:dvk:e:f:tl:x:T:D:" ;
struct option lopt [ ] = {
{
"help" , no_argument , NULL , 'h' }
, {
"version" , no_argument , NULL , 'V' }
, {
"bind" , required_argument , NULL , 'b' }
, {
"port" , required_argument , NULL , 'p' }
, {
"socket" , required_argument , NULL , 'k' }
, {
"offset" , required_argument , NULL , 'o' }
, {
"read-only" , no_argument , NULL , 'r' }
, {
"partition" , required_argument , NULL , 'P' }
, {
"connect" , required_argument , NULL , 'c' }
, {
"disconnect" , no_argument , NULL , 'd' }
, {
"snapshot" , no_argument , NULL , 's' }
, {
"load-snapshot" , required_argument , NULL , 'l' }
, {
"nocache" , no_argument , NULL , 'n' }
, {
"cache" , required_argument , NULL , QEMU_NBD_OPT_CACHE }
, {
"aio" , required_argument , NULL , QEMU_NBD_OPT_AIO }
, {
"discard" , required_argument , NULL , QEMU_NBD_OPT_DISCARD }
, {
"detect-zeroes" , required_argument , NULL , QEMU_NBD_OPT_DETECT_ZEROES }
, {
"shared" , required_argument , NULL , 'e' }
, {
"format" , required_argument , NULL , 'f' }
, {
"persistent" , no_argument , NULL , 't' }
, {
"verbose" , no_argument , NULL , 'v' }
, {
"object" , required_argument , NULL , QEMU_NBD_OPT_OBJECT }
, {
"export-name" , required_argument , NULL , 'x' }
, {
"description" , required_argument , NULL , 'D' }
, {
"tls-creds" , required_argument , NULL , QEMU_NBD_OPT_TLSCREDS }
, {
"image-opts" , no_argument , NULL , QEMU_NBD_OPT_IMAGE_OPTS }
, {
"trace" , required_argument , NULL , 'T' }
, {
"fork" , no_argument , NULL , QEMU_NBD_OPT_FORK }
, {
NULL , 0 , NULL , 0 }
}
;
int ch ;
int opt_ind = 0 ;
char * end ;
int flags = BDRV_O_RDWR ;
int partition = - 1 ;
int ret = 0 ;
bool seen_cache = false ;
bool seen_discard = false ;
bool seen_aio = false ;
pthread_t client_thread ;
const char * fmt = NULL ;
Error * local_err = NULL ;
BlockdevDetectZeroesOptions detect_zeroes = BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF ;
QDict * options = NULL ;
const char * export_name = NULL ;
const char * export_description = NULL ;
const char * tlscredsid = NULL ;
bool imageOpts = false ;
bool writethrough = true ;
char * trace_file = NULL ;
bool fork_process = false ;
int old_stderr = - 1 ;
unsigned socket_activation ;
struct sigaction sa_sigterm ;
memset ( & sa_sigterm , 0 , sizeof ( sa_sigterm ) ) ;
sa_sigterm . sa_handler = termsig_handler ;
sigaction ( SIGTERM , & sa_sigterm , NULL ) ;
module_call_init ( MODULE_INIT_TRACE ) ;
qcrypto_init ( & error_fatal ) ;
module_call_init ( MODULE_INIT_QOM ) ;
qemu_add_opts ( & qemu_object_opts ) ;
qemu_add_opts ( & qemu_trace_opts ) ;
qemu_init_exec_dir ( argv [ 0 ] ) ;
while ( ( ch = getopt_long ( argc , argv , sopt , lopt , & opt_ind ) ) != - 1 ) {
switch ( ch ) {
case 's' : flags |= BDRV_O_SNAPSHOT ;
break ;
case 'n' : optarg = ( char * ) "none" ;
case QEMU_NBD_OPT_CACHE : if ( seen_cache ) {
error_report ( "-n and --cache can only be specified once" ) ;
exit ( EXIT_FAILURE ) ;
}
seen_cache = true ;
if ( bdrv_parse_cache_mode ( optarg , & flags , & writethrough ) == - 1 ) {
error_report ( "Invalid cache mode `%s'" , optarg ) ;
exit ( EXIT_FAILURE ) ;
}
break ;
case QEMU_NBD_OPT_AIO : if ( seen_aio ) {
error_report ( "--aio can only be specified once" ) ;
exit ( EXIT_FAILURE ) ;
}
seen_aio = true ;
if ( ! strcmp ( optarg , "native" ) ) {
flags |= BDRV_O_NATIVE_AIO ;
}
else if ( ! strcmp ( optarg , "threads" ) ) {
}
else {
error_report ( "invalid aio mode `%s'" , optarg ) ;
exit ( EXIT_FAILURE ) ;
}
break ;
case QEMU_NBD_OPT_DISCARD : if ( seen_discard ) {
error_report ( "--discard can only be specified once" ) ;
exit ( EXIT_FAILURE ) ;
}
seen_discard = true ;
if ( bdrv_parse_discard_flags ( optarg , & flags ) == - 1 ) {
error_report ( "Invalid discard mode `%s'" , optarg ) ;
exit ( EXIT_FAILURE ) ;
}
break ;
case QEMU_NBD_OPT_DETECT_ZEROES : detect_zeroes = qapi_enum_parse ( BlockdevDetectZeroesOptions_lookup , optarg , BLOCKDEV_DETECT_ZEROES_OPTIONS__MAX , BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF , & local_err ) ;
if ( local_err ) {
error_reportf_err ( local_err , "Failed to parse detect_zeroes mode: " ) ;
exit ( EXIT_FAILURE ) ;
}
if ( detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP && ! ( flags & BDRV_O_UNMAP ) ) {
error_report ( "setting detect-zeroes to unmap is not allowed " "without setting discard operation to unmap" ) ;
exit ( EXIT_FAILURE ) ;
}
break ;
case 'b' : bindto = optarg ;
break ;
case 'p' : port = optarg ;
break ;
case 'o' : dev_offset = strtoll ( optarg , & end , 0 ) ;
if ( * end ) {
error_report ( "Invalid offset `%s'" , optarg ) ;
exit ( EXIT_FAILURE ) ;
}
if ( dev_offset < 0 ) {
error_report ( "Offset must be positive `%s'" , optarg ) ;
exit ( EXIT_FAILURE ) ;
}
break ;
case 'l' : if ( strstart ( optarg , SNAPSHOT_OPT_BASE , NULL ) ) {
sn_opts = qemu_opts_parse_noisily ( & internal_snapshot_opts , optarg , false ) ;
if ( ! sn_opts ) {
error_report ( "Failed in parsing snapshot param `%s'" , optarg ) ;
exit ( EXIT_FAILURE ) ;
}
}
else {
sn_id_or_name = optarg ;
}
case 'r' : nbdflags |= NBD_FLAG_READ_ONLY ;
flags &= ~ BDRV_O_RDWR ;
break ;
case 'P' : partition = strtol ( optarg , & end , 0 ) ;
if ( * end ) {
error_report ( "Invalid partition `%s'" , optarg ) ;
exit ( EXIT_FAILURE ) ;
}
if ( partition < 1 || partition > 8 ) {
error_report ( "Invalid partition %d" , partition ) ;
exit ( EXIT_FAILURE ) ;
}
break ;
case 'k' : sockpath = optarg ;
if ( sockpath [ 0 ] != '/' ) {
error_report ( "socket path must be absolute" ) ;
exit ( EXIT_FAILURE ) ;
}
break ;
case 'd' : disconnect = true ;
break ;
case 'c' : device = optarg ;
break ;
case 'e' : shared = strtol ( optarg , & end , 0 ) ;
if ( * end ) {
error_report ( "Invalid shared device number '%s'" , optarg ) ;
exit ( EXIT_FAILURE ) ;
}
if ( shared < 1 ) {
error_report ( "Shared device number must be greater than 0" ) ;
exit ( EXIT_FAILURE ) ;
}
break ;
case 'f' : fmt = optarg ;
break ;
case 't' : persistent = 1 ;
break ;
case 'x' : export_name = optarg ;
break ;
case 'D' : export_description = optarg ;
break ;
case 'v' : verbose = 1 ;
break ;
case 'V' : version ( argv [ 0 ] ) ;
exit ( 0 ) ;
break ;
case 'h' : usage ( argv [ 0 ] ) ;
exit ( 0 ) ;
break ;
case '?' : error_report ( "Try `%s --help' for more information." , argv [ 0 ] ) ;
exit ( EXIT_FAILURE ) ;
case QEMU_NBD_OPT_OBJECT : {
QemuOpts * opts ;
opts = qemu_opts_parse_noisily ( & qemu_object_opts , optarg , true ) ;
if ( ! opts ) {
exit ( EXIT_FAILURE ) ;
}
}
break ;
case QEMU_NBD_OPT_TLSCREDS : tlscredsid = optarg ;
break ;
case QEMU_NBD_OPT_IMAGE_OPTS : imageOpts = true ;
break ;
case 'T' : g_free ( trace_file ) ;
trace_file = trace_opt_parse ( optarg ) ;
break ;
case QEMU_NBD_OPT_FORK : fork_process = true ;
break ;
}
}
if ( ( argc - optind ) != 1 ) {
error_report ( "Invalid number of arguments" ) ;
error_printf ( "Try `%s --help' for more information.\n" , argv [ 0 ] ) ;
exit ( EXIT_FAILURE ) ;
}
if ( qemu_opts_foreach ( & qemu_object_opts , user_creatable_add_opts_foreach , NULL , NULL ) ) {
exit ( EXIT_FAILURE ) ;
}
if ( ! trace_init_backends ( ) ) {
exit ( 1 ) ;
}
trace_init_file ( trace_file ) ;
qemu_set_log ( LOG_TRACE ) ;
socket_activation = check_socket_activation ( ) ;
if ( socket_activation == 0 ) {
setup_address_and_port ( & bindto , & port ) ;
}
else {
const char * err_msg = socket_activation_validate_opts ( device , sockpath , bindto , port ) ;
if ( err_msg != NULL ) {
error_report ( "%s" , err_msg ) ;
exit ( EXIT_FAILURE ) ;
}
if ( socket_activation > 1 ) {
error_report ( "qemu-nbd does not support socket activation with %s > 1" , "LISTEN_FDS" ) ;
exit ( EXIT_FAILURE ) ;
}
}
if ( tlscredsid ) {
if ( sockpath ) {
error_report ( "TLS is only supported with IPv4/IPv6" ) ;
exit ( EXIT_FAILURE ) ;
}
if ( device ) {
error_report ( "TLS is not supported with a host device" ) ;
exit ( EXIT_FAILURE ) ;
}
if ( ! export_name ) {
export_name = "" ;
}
tlscreds = nbd_get_tls_creds ( tlscredsid , & local_err ) ;
if ( local_err ) {
error_report ( "Failed to get TLS creds %s" , error_get_pretty ( local_err ) ) ;
exit ( EXIT_FAILURE ) ;
}
}
if ( disconnect ) {
int nbdfd = open ( argv [ optind ] , O_RDWR ) ;
if ( nbdfd < 0 ) {
error_report ( "Cannot open %s: %s" , argv [ optind ] , strerror ( errno ) ) ;
exit ( EXIT_FAILURE ) ;
}
nbd_disconnect ( nbdfd ) ;
close ( nbdfd ) ;
printf ( "%s disconnected\n" , argv [ optind ] ) ;
return 0 ;
}
if ( ( device && ! verbose ) || fork_process ) {
int stderr_fd [ 2 ] ;
pid_t pid ;
int ret ;
if ( qemu_pipe ( stderr_fd ) < 0 ) {
error_report ( "Error setting up communication pipe: %s" , strerror ( errno ) ) ;
exit ( EXIT_FAILURE ) ;
}
pid = fork ( ) ;
if ( pid < 0 ) {
error_report ( "Failed to fork: %s" , strerror ( errno ) ) ;
exit ( EXIT_FAILURE ) ;
}
else if ( pid == 0 ) {
close ( stderr_fd [ 0 ] ) ;
ret = qemu_daemon ( 1 , 0 ) ;
old_stderr = dup ( STDERR_FILENO ) ;
dup2 ( stderr_fd [ 1 ] , STDERR_FILENO ) ;
if ( ret < 0 ) {
error_report ( "Failed to daemonize: %s" , strerror ( errno ) ) ;
exit ( EXIT_FAILURE ) ;
}
close ( stderr_fd [ 1 ] ) ;
}
else {
bool errors = false ;
char * buf ;
close ( stderr_fd [ 1 ] ) ;
buf = g_malloc ( 1024 ) ;
while ( ( ret = read ( stderr_fd [ 0 ] , buf , 1024 ) ) > 0 ) {
errors = true ;
ret = qemu_write_full ( STDERR_FILENO , buf , ret ) ;
if ( ret < 0 ) {
exit ( EXIT_FAILURE ) ;
}
}
if ( ret < 0 ) {
error_report ( "Cannot read from daemon: %s" , strerror ( errno ) ) ;
exit ( EXIT_FAILURE ) ;
}
exit ( errors ) ;
}
}
if ( device != NULL && sockpath == NULL ) {
sockpath = g_malloc ( 128 ) ;
snprintf ( sockpath , 128 , SOCKET_PATH , basename ( device ) ) ;
}
if ( socket_activation == 0 ) {
server_ioc = qio_channel_socket_new ( ) ;
saddr = nbd_build_socket_address ( sockpath , bindto , port ) ;
if ( qio_channel_socket_listen_sync ( server_ioc , saddr , & local_err ) < 0 ) {
object_unref ( OBJECT ( server_ioc ) ) ;
error_report_err ( local_err ) ;
return 1 ;
}
}
else {
assert ( socket_activation == 1 ) ;
server_ioc = qio_channel_socket_new_fd ( FIRST_SOCKET_ACTIVATION_FD , & local_err ) ;
if ( server_ioc == NULL ) {
error_report ( "Failed to use socket activation: %s" , error_get_pretty ( local_err ) ) ;
exit ( EXIT_FAILURE ) ;
}
}
if ( qemu_init_main_loop ( & local_err ) ) {
error_report_err ( local_err ) ;
exit ( EXIT_FAILURE ) ;
}
bdrv_init ( ) ;
atexit ( bdrv_close_all ) ;
srcpath = argv [ optind ] ;
if ( imageOpts ) {
QemuOpts * opts ;
if ( fmt ) {
error_report ( "--image-opts and -f are mutually exclusive" ) ;
exit ( EXIT_FAILURE ) ;
}
opts = qemu_opts_parse_noisily ( & file_opts , srcpath , true ) ;
if ( ! opts ) {
qemu_opts_reset ( & file_opts ) ;
exit ( EXIT_FAILURE ) ;
}
options = qemu_opts_to_qdict ( opts , NULL ) ;
qemu_opts_reset ( & file_opts ) ;
blk = blk_new_open ( NULL , NULL , options , flags , & local_err ) ;
}
else {
if ( fmt ) {
options = qdict_new ( ) ;
qdict_put_str ( options , "driver" , fmt ) ;
}
blk = blk_new_open ( srcpath , NULL , options , flags , & local_err ) ;
}
if ( ! blk ) {
error_reportf_err ( local_err , "Failed to blk_new_open '%s': " , argv [ optind ] ) ;
exit ( EXIT_FAILURE ) ;
}
bs = blk_bs ( blk ) ;
blk_set_enable_write_cache ( blk , ! writethrough ) ;
if ( sn_opts ) {
ret = bdrv_snapshot_load_tmp ( bs , qemu_opt_get ( sn_opts , SNAPSHOT_OPT_ID ) , qemu_opt_get ( sn_opts , SNAPSHOT_OPT_NAME ) , & local_err ) ;
}
else if ( sn_id_or_name ) {
ret = bdrv_snapshot_load_tmp_by_id_or_name ( bs , sn_id_or_name , & local_err ) ;
}
if ( ret < 0 ) {
error_reportf_err ( local_err , "Failed to load snapshot: " ) ;
exit ( EXIT_FAILURE ) ;
}
bs -> detect_zeroes = detect_zeroes ;
fd_size = blk_getlength ( blk ) ;
if ( fd_size < 0 ) {
error_report ( "Failed to determine the image length: %s" , strerror ( - fd_size ) ) ;
exit ( EXIT_FAILURE ) ;
}
if ( dev_offset >= fd_size ) {
error_report ( "Offset (%lld) has to be smaller than the image size " "(%lld)" , ( long long int ) dev_offset , ( long long int ) fd_size ) ;
exit ( EXIT_FAILURE ) ;
}
fd_size -= dev_offset ;
if ( partition != - 1 ) {
ret = find_partition ( blk , partition , & dev_offset , & fd_size ) ;
if ( ret < 0 ) {
error_report ( "Could not find partition %d: %s" , partition , strerror ( - ret ) ) ;
exit ( EXIT_FAILURE ) ;
}
}
exp = nbd_export_new ( bs , dev_offset , fd_size , nbdflags , nbd_export_closed , writethrough , NULL , & local_err ) ;
if ( ! exp ) {
error_report_err ( local_err ) ;
exit ( EXIT_FAILURE ) ;
}
if ( export_name ) {
nbd_export_set_name ( exp , export_name ) ;
nbd_export_set_description ( exp , export_description ) ;
newproto = true ;
}
else if ( export_description ) {
error_report ( "Export description requires an export name" ) ;
exit ( EXIT_FAILURE ) ;
}
if ( device ) {
int ret ;
ret = pthread_create ( & client_thread , NULL , nbd_client_thread , device ) ;
if ( ret != 0 ) {
error_report ( "Failed to create client thread: %s" , strerror ( ret ) ) ;
exit ( EXIT_FAILURE ) ;
}
}
else {
memset ( & client_thread , 0 , sizeof ( client_thread ) ) ;
}
nbd_update_server_watch ( ) ;
if ( chdir ( "/" ) < 0 ) {
error_report ( "Could not chdir to root directory: %s" , strerror ( errno ) ) ;
exit ( EXIT_FAILURE ) ;
}
if ( fork_process ) {
dup2 ( old_stderr , STDERR_FILENO ) ;
close ( old_stderr ) ;
}
state = RUNNING ;
do {
main_loop_wait ( false ) ;
if ( state == TERMINATE ) {
state = TERMINATING ;
nbd_export_close ( exp ) ;
nbd_export_put ( exp ) ;
exp = NULL ;
}
}
while ( state != TERMINATED ) ;
blk_unref ( blk ) ;
if ( sockpath ) {
unlink ( sockpath ) ;
}
qemu_opts_del ( sn_opts ) ;
if ( device ) {
void * ret ;
pthread_join ( client_thread , & ret ) ;
exit ( ret != NULL ) ;
}
else {
exit ( EXIT_SUCCESS ) ;
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline void vc1_pred_mv ( VC1Context * v , int n , int dmv_x , int dmv_y , int mv1 , int r_x , int r_y , uint8_t * is_intra , int pred_flag , int dir ) {
MpegEncContext * s = & v -> s ;
int xy , wrap , off = 0 ;
int16_t * A , * B , * C ;
int px , py ;
int sum ;
int mixedmv_pic , num_samefield = 0 , num_oppfield = 0 ;
int opposite , a_f , b_f , c_f ;
int16_t field_predA [ 2 ] ;
int16_t field_predB [ 2 ] ;
int16_t field_predC [ 2 ] ;
int a_valid , b_valid , c_valid ;
int hybridmv_thresh , y_bias = 0 ;
if ( v -> mv_mode == MV_PMODE_MIXED_MV || ( ( v -> mv_mode == MV_PMODE_INTENSITY_COMP ) && ( v -> mv_mode2 == MV_PMODE_MIXED_MV ) ) ) mixedmv_pic = 1 ;
else mixedmv_pic = 0 ;
dmv_x <<= 1 - s -> quarter_sample ;
dmv_y <<= 1 - s -> quarter_sample ;
wrap = s -> b8_stride ;
xy = s -> block_index [ n ] ;
if ( s -> mb_intra ) {
s -> mv [ 0 ] [ n ] [ 0 ] = s -> current_picture . f . motion_val [ 0 ] [ xy + v -> blocks_off ] [ 0 ] = 0 ;
s -> mv [ 0 ] [ n ] [ 1 ] = s -> current_picture . f . motion_val [ 0 ] [ xy + v -> blocks_off ] [ 1 ] = 0 ;
s -> current_picture . f . motion_val [ 1 ] [ xy + v -> blocks_off ] [ 0 ] = 0 ;
s -> current_picture . f . motion_val [ 1 ] [ xy + v -> blocks_off ] [ 1 ] = 0 ;
if ( mv1 ) {
s -> current_picture . f . motion_val [ 0 ] [ xy + 1 + v -> blocks_off ] [ 0 ] = 0 ;
s -> current_picture . f . motion_val [ 0 ] [ xy + 1 + v -> blocks_off ] [ 1 ] = 0 ;
s -> current_picture . f . motion_val [ 0 ] [ xy + wrap + v -> blocks_off ] [ 0 ] = 0 ;
s -> current_picture . f . motion_val [ 0 ] [ xy + wrap + v -> blocks_off ] [ 1 ] = 0 ;
s -> current_picture . f . motion_val [ 0 ] [ xy + wrap + 1 + v -> blocks_off ] [ 0 ] = 0 ;
s -> current_picture . f . motion_val [ 0 ] [ xy + wrap + 1 + v -> blocks_off ] [ 1 ] = 0 ;
v -> luma_mv [ s -> mb_x ] [ 0 ] = v -> luma_mv [ s -> mb_x ] [ 1 ] = 0 ;
s -> current_picture . f . motion_val [ 1 ] [ xy + 1 + v -> blocks_off ] [ 0 ] = 0 ;
s -> current_picture . f . motion_val [ 1 ] [ xy + 1 + v -> blocks_off ] [ 1 ] = 0 ;
s -> current_picture . f . motion_val [ 1 ] [ xy + wrap ] [ 0 ] = 0 ;
s -> current_picture . f . motion_val [ 1 ] [ xy + wrap + v -> blocks_off ] [ 1 ] = 0 ;
s -> current_picture . f . motion_val [ 1 ] [ xy + wrap + 1 + v -> blocks_off ] [ 0 ] = 0 ;
s -> current_picture . f . motion_val [ 1 ] [ xy + wrap + 1 + v -> blocks_off ] [ 1 ] = 0 ;
}
return ;
}
C = s -> current_picture . f . motion_val [ dir ] [ xy - 1 + v -> blocks_off ] ;
A = s -> current_picture . f . motion_val [ dir ] [ xy - wrap + v -> blocks_off ] ;
if ( mv1 ) {
if ( v -> field_mode && mixedmv_pic ) off = ( s -> mb_x == ( s -> mb_width - 1 ) ) ? - 2 : 2 ;
else off = ( s -> mb_x == ( s -> mb_width - 1 ) ) ? - 1 : 2 ;
}
else {
switch ( n ) {
case 0 : off = ( s -> mb_x > 0 ) ? - 1 : 1 ;
break ;
case 1 : off = ( s -> mb_x == ( s -> mb_width - 1 ) ) ? - 1 : 1 ;
break ;
case 2 : off = 1 ;
break ;
case 3 : off = - 1 ;
}
}
B = s -> current_picture . f . motion_val [ dir ] [ xy - wrap + off + v -> blocks_off ] ;
a_valid = ! s -> first_slice_line || ( n == 2 || n == 3 ) ;
b_valid = a_valid && ( s -> mb_width > 1 ) ;
c_valid = s -> mb_x || ( n == 1 || n == 3 ) ;
if ( v -> field_mode ) {
a_valid = a_valid && ! is_intra [ xy - wrap ] ;
b_valid = b_valid && ! is_intra [ xy - wrap + off ] ;
c_valid = c_valid && ! is_intra [ xy - 1 ] ;
}
if ( a_valid ) {
a_f = v -> mv_f [ dir ] [ xy - wrap + v -> blocks_off ] ;
num_oppfield += a_f ;
num_samefield += 1 - a_f ;
field_predA [ 0 ] = A [ 0 ] ;
field_predA [ 1 ] = A [ 1 ] ;
}
else {
field_predA [ 0 ] = field_predA [ 1 ] = 0 ;
a_f = 0 ;
}
if ( b_valid ) {
b_f = v -> mv_f [ dir ] [ xy - wrap + off + v -> blocks_off ] ;
num_oppfield += b_f ;
num_samefield += 1 - b_f ;
field_predB [ 0 ] = B [ 0 ] ;
field_predB [ 1 ] = B [ 1 ] ;
}
else {
field_predB [ 0 ] = field_predB [ 1 ] = 0 ;
b_f = 0 ;
}
if ( c_valid ) {
c_f = v -> mv_f [ dir ] [ xy - 1 + v -> blocks_off ] ;
num_oppfield += c_f ;
num_samefield += 1 - c_f ;
field_predC [ 0 ] = C [ 0 ] ;
field_predC [ 1 ] = C [ 1 ] ;
}
else {
field_predC [ 0 ] = field_predC [ 1 ] = 0 ;
c_f = 0 ;
}
if ( v -> field_mode ) {
if ( ! v -> numref ) opposite = 1 - v -> reffield ;
else {
if ( num_samefield <= num_oppfield ) opposite = 1 - pred_flag ;
else opposite = pred_flag ;
}
}
else opposite = 0 ;
if ( opposite ) {
if ( a_valid && ! a_f ) {
field_predA [ 0 ] = scaleforopp ( v , field_predA [ 0 ] , 0 , dir ) ;
field_predA [ 1 ] = scaleforopp ( v , field_predA [ 1 ] , 1 , dir ) ;
}
if ( b_valid && ! b_f ) {
field_predB [ 0 ] = scaleforopp ( v , field_predB [ 0 ] , 0 , dir ) ;
field_predB [ 1 ] = scaleforopp ( v , field_predB [ 1 ] , 1 , dir ) ;
}
if ( c_valid && ! c_f ) {
field_predC [ 0 ] = scaleforopp ( v , field_predC [ 0 ] , 0 , dir ) ;
field_predC [ 1 ] = scaleforopp ( v , field_predC [ 1 ] , 1 , dir ) ;
}
v -> mv_f [ dir ] [ xy + v -> blocks_off ] = 1 ;
v -> ref_field_type [ dir ] = ! v -> cur_field_type ;
}
else {
if ( a_valid && a_f ) {
field_predA [ 0 ] = scaleforsame ( v , n , field_predA [ 0 ] , 0 , dir ) ;
field_predA [ 1 ] = scaleforsame ( v , n , field_predA [ 1 ] , 1 , dir ) ;
}
if ( b_valid && b_f ) {
field_predB [ 0 ] = scaleforsame ( v , n , field_predB [ 0 ] , 0 , dir ) ;
field_predB [ 1 ] = scaleforsame ( v , n , field_predB [ 1 ] , 1 , dir ) ;
}
if ( c_valid && c_f ) {
field_predC [ 0 ] = scaleforsame ( v , n , field_predC [ 0 ] , 0 , dir ) ;
field_predC [ 1 ] = scaleforsame ( v , n , field_predC [ 1 ] , 1 , dir ) ;
}
v -> mv_f [ dir ] [ xy + v -> blocks_off ] = 0 ;
v -> ref_field_type [ dir ] = v -> cur_field_type ;
}
if ( a_valid ) {
px = field_predA [ 0 ] ;
py = field_predA [ 1 ] ;
}
else if ( c_valid ) {
px = field_predC [ 0 ] ;
py = field_predC [ 1 ] ;
}
else if ( b_valid ) {
px = field_predB [ 0 ] ;
py = field_predB [ 1 ] ;
}
else {
px = 0 ;
py = 0 ;
}
if ( num_samefield + num_oppfield > 1 ) {
px = mid_pred ( field_predA [ 0 ] , field_predB [ 0 ] , field_predC [ 0 ] ) ;
py = mid_pred ( field_predA [ 1 ] , field_predB [ 1 ] , field_predC [ 1 ] ) ;
}
if ( ! v -> field_mode ) {
int qx , qy , X , Y ;
qx = ( s -> mb_x << 6 ) + ( ( n == 1 || n == 3 ) ? 32 : 0 ) ;
qy = ( s -> mb_y << 6 ) + ( ( n == 2 || n == 3 ) ? 32 : 0 ) ;
X = ( s -> mb_width << 6 ) - 4 ;
Y = ( s -> mb_height << 6 ) - 4 ;
if ( mv1 ) {
if ( qx + px < - 60 ) px = - 60 - qx ;
if ( qy + py < - 60 ) py = - 60 - qy ;
}
else {
if ( qx + px < - 28 ) px = - 28 - qx ;
if ( qy + py < - 28 ) py = - 28 - qy ;
}
if ( qx + px > X ) px = X - qx ;
if ( qy + py > Y ) py = Y - qy ;
}
if ( ! v -> field_mode || s -> pict_type != AV_PICTURE_TYPE_B ) {
hybridmv_thresh = 32 ;
if ( a_valid && c_valid ) {
if ( is_intra [ xy - wrap ] ) sum = FFABS ( px ) + FFABS ( py ) ;
else sum = FFABS ( px - field_predA [ 0 ] ) + FFABS ( py - field_predA [ 1 ] ) ;
if ( sum > hybridmv_thresh ) {
if ( get_bits1 ( & s -> gb ) ) {
px = field_predA [ 0 ] ;
py = field_predA [ 1 ] ;
}
else {
px = field_predC [ 0 ] ;
py = field_predC [ 1 ] ;
}
}
else {
if ( is_intra [ xy - 1 ] ) sum = FFABS ( px ) + FFABS ( py ) ;
else sum = FFABS ( px - field_predC [ 0 ] ) + FFABS ( py - field_predC [ 1 ] ) ;
if ( sum > hybridmv_thresh ) {
if ( get_bits1 ( & s -> gb ) ) {
px = field_predA [ 0 ] ;
py = field_predA [ 1 ] ;
}
else {
px = field_predC [ 0 ] ;
py = field_predC [ 1 ] ;
}
}
}
}
}
if ( v -> field_mode && v -> numref ) r_y >>= 1 ;
if ( v -> field_mode && v -> cur_field_type && v -> ref_field_type [ dir ] == 0 ) y_bias = 1 ;
s -> mv [ dir ] [ n ] [ 0 ] = s -> current_picture . f . motion_val [ dir ] [ xy + v -> blocks_off ] [ 0 ] = ( ( px + dmv_x + r_x ) & ( ( r_x << 1 ) - 1 ) ) - r_x ;
s -> mv [ dir ] [ n ] [ 1 ] = s -> current_picture . f . motion_val [ dir ] [ xy + v -> blocks_off ] [ 1 ] = ( ( py + dmv_y + r_y - y_bias ) & ( ( r_y << 1 ) - 1 ) ) - r_y + y_bias ;
if ( mv1 ) {
s -> current_picture . f . motion_val [ dir ] [ xy + 1 + v -> blocks_off ] [ 0 ] = s -> current_picture . f . motion_val [ dir ] [ xy + v -> blocks_off ] [ 0 ] ;
s -> current_picture . f . motion_val [ dir ] [ xy + 1 + v -> blocks_off ] [ 1 ] = s -> current_picture . f . motion_val [ dir ] [ xy + v -> blocks_off ] [ 1 ] ;
s -> current_picture . f . motion_val [ dir ] [ xy + wrap + v -> blocks_off ] [ 0 ] = s -> current_picture . f . motion_val [ dir ] [ xy + v -> blocks_off ] [ 0 ] ;
s -> current_picture . f . motion_val [ dir ] [ xy + wrap + v -> blocks_off ] [ 1 ] = s -> current_picture . f . motion_val [ dir ] [ xy + v -> blocks_off ] [ 1 ] ;
s -> current_picture . f . motion_val [ dir ] [ xy + wrap + 1 + v -> blocks_off ] [ 0 ] = s -> current_picture . f . motion_val [ dir ] [ xy + v -> blocks_off ] [ 0 ] ;
s -> current_picture . f . motion_val [ dir ] [ xy + wrap + 1 + v -> blocks_off ] [ 1 ] = s -> current_picture . f . motion_val [ dir ] [ xy + v -> blocks_off ] [ 1 ] ;
v -> mv_f [ dir ] [ xy + 1 + v -> blocks_off ] = v -> mv_f [ dir ] [ xy + v -> blocks_off ] ;
v -> mv_f [ dir ] [ xy + wrap + v -> blocks_off ] = v -> mv_f [ dir ] [ xy + wrap + 1 + v -> blocks_off ] = v -> mv_f [ dir ] [ xy + v -> blocks_off ] ;
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
void tcg_exec_init ( unsigned long tb_size ) {
cpu_gen_init ( ) ;
code_gen_alloc ( tb_size ) ;
tcg_ctx . code_gen_ptr = tcg_ctx . code_gen_buffer ;
tcg_register_jit ( tcg_ctx . code_gen_buffer , tcg_ctx . code_gen_buffer_size ) ;
page_init ( ) ;
# if ! defined ( CONFIG_USER_ONLY ) || ! defined ( CONFIG_USE_GUEST_BASE ) tcg_prologue_init ( & tcg_ctx ) ;
# endif }
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int read_dct_coeffs ( GetBitContext * gb , int32_t block [ 64 ] , const uint8_t * scan , const int32_t quant_matrices [ 16 ] [ 64 ] , int q ) {
int coef_list [ 128 ] ;
int mode_list [ 128 ] ;
int i , t , bits , ccoef , mode , sign ;
int list_start = 64 , list_end = 64 , list_pos ;
int coef_count = 0 ;
int coef_idx [ 64 ] ;
int quant_idx ;
const int32_t * quant ;
coef_list [ list_end ] = 4 ;
mode_list [ list_end ++ ] = 0 ;
coef_list [ list_end ] = 24 ;
mode_list [ list_end ++ ] = 0 ;
coef_list [ list_end ] = 44 ;
mode_list [ list_end ++ ] = 0 ;
coef_list [ list_end ] = 1 ;
mode_list [ list_end ++ ] = 3 ;
coef_list [ list_end ] = 2 ;
mode_list [ list_end ++ ] = 3 ;
coef_list [ list_end ] = 3 ;
mode_list [ list_end ++ ] = 3 ;
for ( bits = get_bits ( gb , 4 ) - 1 ;
bits >= 0 ;
bits -- ) {
list_pos = list_start ;
while ( list_pos < list_end ) {
if ( ! ( mode_list [ list_pos ] | coef_list [ list_pos ] ) || ! get_bits1 ( gb ) ) {
list_pos ++ ;
continue ;
}
ccoef = coef_list [ list_pos ] ;
mode = mode_list [ list_pos ] ;
switch ( mode ) {
case 0 : coef_list [ list_pos ] = ccoef + 4 ;
mode_list [ list_pos ] = 1 ;
case 2 : if ( mode == 2 ) {
coef_list [ list_pos ] = 0 ;
mode_list [ list_pos ++ ] = 0 ;
}
for ( i = 0 ;
i < 4 ;
i ++ , ccoef ++ ) {
if ( get_bits1 ( gb ) ) {
coef_list [ -- list_start ] = ccoef ;
mode_list [ list_start ] = 3 ;
}
else {
if ( ! bits ) {
t = 1 - ( get_bits1 ( gb ) << 1 ) ;
}
else {
t = get_bits ( gb , bits ) | 1 << bits ;
sign = - get_bits1 ( gb ) ;
t = ( t ^ sign ) - sign ;
}
block [ scan [ ccoef ] ] = t ;
coef_idx [ coef_count ++ ] = ccoef ;
}
}
break ;
case 1 : mode_list [ list_pos ] = 2 ;
for ( i = 0 ;
i < 3 ;
i ++ ) {
ccoef += 4 ;
coef_list [ list_end ] = ccoef ;
mode_list [ list_end ++ ] = 2 ;
}
break ;
case 3 : if ( ! bits ) {
t = 1 - ( get_bits1 ( gb ) << 1 ) ;
}
else {
t = get_bits ( gb , bits ) | 1 << bits ;
sign = - get_bits1 ( gb ) ;
t = ( t ^ sign ) - sign ;
}
block [ scan [ ccoef ] ] = t ;
coef_idx [ coef_count ++ ] = ccoef ;
coef_list [ list_pos ] = 0 ;
mode_list [ list_pos ++ ] = 0 ;
break ;
}
}
}
if ( q == - 1 ) {
quant_idx = get_bits ( gb , 4 ) ;
}
else {
quant_idx = q ;
}
quant = quant_matrices [ quant_idx ] ;
block [ 0 ] = ( block [ 0 ] * quant [ 0 ] ) >> 11 ;
for ( i = 0 ;
i < coef_count ;
i ++ ) {
int idx = coef_idx [ i ] ;
block [ scan [ idx ] ] = ( block [ scan [ idx ] ] * quant [ idx ] ) >> 11 ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_T_videoFastUpdateMB ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_sequence ( tvb , offset , actx , tree , hf_index , ett_h245_T_videoFastUpdateMB , T_videoFastUpdateMB_sequence ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
SPL_METHOD ( FilesystemIterator , getFlags ) {
spl_filesystem_object * intern = ( spl_filesystem_object * ) zend_object_store_get_object ( getThis ( ) TSRMLS_CC ) ;
if ( zend_parse_parameters_none ( ) == FAILURE ) {
return ;
}
RETURN_LONG ( intern -> flags & ( SPL_FILE_DIR_KEY_MODE_MASK | SPL_FILE_DIR_CURRENT_MODE_MASK | SPL_FILE_DIR_OTHERS_MASK ) ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
int gdev_mem_open_scan_lines ( gx_device_memory * mdev , int setup_height ) {
bool line_pointers_adjacent = true ;
ulong size ;
if ( setup_height < 0 || setup_height > mdev -> height ) return_error ( gs_error_rangecheck ) ;
if ( mdev -> bitmap_memory != 0 ) {
int align ;
if ( gdev_mem_bitmap_size ( mdev , & size ) < 0 ) return_error ( gs_error_VMerror ) ;
if ( ( uint ) size != size ) return_error ( gs_error_limitcheck ) ;
mdev -> base = gs_alloc_bytes ( mdev -> bitmap_memory , ( uint ) size , "mem_open" ) ;
if ( mdev -> base == 0 ) return_error ( gs_error_VMerror ) ;
# ifdef PACIFY_VALGRIND memset ( mdev -> base , 0x00 , size ) ;
# endif align = 1 << mdev -> log2_align_mod ;
mdev -> base += ( - ( int ) ( intptr_t ) mdev -> base ) & ( align - 1 ) ;
mdev -> foreign_bits = false ;
}
else if ( mdev -> line_pointer_memory != 0 ) {
mdev -> line_ptrs = ( byte * * ) gs_alloc_byte_array ( mdev -> line_pointer_memory , mdev -> height , sizeof ( byte * ) * ( mdev -> is_planar ? mdev -> color_info . num_components : 1 ) , "gdev_mem_open_scan_lines" ) ;
if ( mdev -> line_ptrs == 0 ) return_error ( gs_error_VMerror ) ;
mdev -> foreign_line_pointers = false ;
line_pointers_adjacent = false ;
}
if ( line_pointers_adjacent ) {
int code ;
if ( mdev -> base == 0 ) return_error ( gs_error_rangecheck ) ;
code = gdev_mem_bits_size ( mdev , mdev -> width , mdev -> height , & size ) ;
if ( code < 0 ) return code ;
mdev -> line_ptrs = ( byte * * ) ( mdev -> base + size ) ;
}
mdev -> raster = gx_device_raster ( ( gx_device * ) mdev , 1 ) ;
return gdev_mem_set_line_ptrs ( mdev , NULL , 0 , NULL , setup_height ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( SessionRestorePageLoadMetricsBrowserTest , MultipleTabsSessionRestore ) {
ui_test_utils : : NavigateToURL ( browser ( ) , GetTestURL ( ) ) ;
ui_test_utils : : NavigateToURLWithDisposition ( browser ( ) , GetTestURL ( ) , WindowOpenDisposition : : NEW_BACKGROUND_TAB , ui_test_utils : : BROWSER_TEST_WAIT_FOR_NAVIGATION ) ;
SessionRestorePaintWaiter session_restore_paint_waiter ;
Browser * new_browser = QuitBrowserAndRestore ( browser ( ) ) ;
TabStripModel * tab_strip = new_browser -> tab_strip_model ( ) ;
ASSERT_TRUE ( tab_strip ) ;
ASSERT_EQ ( 2 , tab_strip -> count ( ) ) ;
session_restore_paint_waiter . WaitForForegroundTabs ( 1 ) ;
ASSERT_NO_FATAL_FAILURE ( WaitForTabsToLoad ( new_browser ) ) ;
ExpectFirstPaintMetricsTotalCount ( 1 ) ;
}
| 0False
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.