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 uint64_t calc_plane_error ( unsigned char * orig , int orig_stride , unsigned char * recon , int recon_stride , unsigned int cols , unsigned int rows ) {
unsigned int row , col ;
uint64_t total_sse = 0 ;
int diff ;
for ( row = 0 ;
row + 16 <= rows ;
row += 16 ) {
for ( col = 0 ;
col + 16 <= cols ;
col += 16 ) {
unsigned int sse ;
vp8_mse16x16 ( orig + col , orig_stride , recon + col , recon_stride , & sse ) ;
total_sse += sse ;
}
if ( col < cols ) {
unsigned int border_row , border_col ;
unsigned char * border_orig = orig ;
unsigned char * border_recon = recon ;
for ( border_row = 0 ;
border_row < 16 ;
border_row ++ ) {
for ( border_col = col ;
border_col < cols ;
border_col ++ ) {
diff = border_orig [ border_col ] - border_recon [ border_col ] ;
total_sse += diff * diff ;
}
border_orig += orig_stride ;
border_recon += recon_stride ;
}
}
orig += orig_stride * 16 ;
recon += recon_stride * 16 ;
}
for ( ;
row < rows ;
row ++ ) {
for ( col = 0 ;
col < cols ;
col ++ ) {
diff = orig [ col ] - recon [ col ] ;
total_sse += diff * diff ;
}
orig += orig_stride ;
recon += recon_stride ;
}
vp8_clear_system_state ( ) ;
return total_sse ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int web_server_set_root_dir ( const char * root_dir ) {
size_t index ;
int ret ;
ret = membuffer_assign_str ( & gDocumentRootDir , root_dir ) ;
if ( ret != 0 ) return ret ;
if ( gDocumentRootDir . length > 0 ) {
index = gDocumentRootDir . length - 1 ;
if ( gDocumentRootDir . buf [ index ] == '/' ) membuffer_delete ( & gDocumentRootDir , index , 1 ) ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int decode_channel ( TAKDecContext * s , int chan ) {
AVCodecContext * avctx = s -> avctx ;
GetBitContext * gb = & s -> gb ;
int32_t * decoded = s -> decoded [ chan ] ;
int left = s -> nb_samples - 1 ;
int i , prev , ret , nb_subframes ;
int subframe_len [ MAX_SUBFRAMES ] ;
s -> sample_shift [ chan ] = get_bits_esc4 ( gb ) ;
if ( s -> sample_shift [ chan ] >= avctx -> bits_per_coded_sample ) return AVERROR_INVALIDDATA ;
* decoded ++ = get_sbits ( gb , avctx -> bits_per_coded_sample - s -> sample_shift [ chan ] ) ;
s -> lpc_mode [ chan ] = get_bits ( gb , 2 ) ;
nb_subframes = get_bits ( gb , 3 ) + 1 ;
i = 0 ;
if ( nb_subframes > 1 ) {
if ( get_bits_left ( gb ) < ( nb_subframes - 1 ) * 6 ) return AVERROR_INVALIDDATA ;
prev = 0 ;
for ( ;
i < nb_subframes - 1 ;
i ++ ) {
int subframe_end = get_bits ( gb , 6 ) * s -> subframe_scale ;
if ( subframe_end <= prev ) return AVERROR_INVALIDDATA ;
subframe_len [ i ] = subframe_end - prev ;
left -= subframe_len [ i ] ;
prev = subframe_end ;
}
if ( left <= 0 ) return AVERROR_INVALIDDATA ;
}
subframe_len [ i ] = left ;
prev = 0 ;
for ( i = 0 ;
i < nb_subframes ;
i ++ ) {
if ( ( ret = decode_subframe ( s , decoded , subframe_len [ i ] , prev ) ) < 0 ) return ret ;
decoded += subframe_len [ i ] ;
prev = subframe_len [ i ] ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
SPL_METHOD ( SplFileInfo , setInfoClass ) {
spl_filesystem_object * intern = ( spl_filesystem_object * ) zend_object_store_get_object ( getThis ( ) TSRMLS_CC ) ;
zend_class_entry * ce = spl_ce_SplFileInfo ;
zend_error_handling error_handling ;
zend_replace_error_handling ( EH_THROW , spl_ce_UnexpectedValueException , & error_handling TSRMLS_CC ) ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , "|C" , & ce ) == SUCCESS ) {
intern -> info_class = ce ;
}
zend_restore_error_handling ( & error_handling TSRMLS_CC ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
char * get_constraint_name ( Oid conoid ) {
HeapTuple tp ;
tp = SearchSysCache1 ( CONSTROID , ObjectIdGetDatum ( conoid ) ) ;
if ( HeapTupleIsValid ( tp ) ) {
Form_pg_constraint contup = ( Form_pg_constraint ) GETSTRUCT ( tp ) ;
char * result ;
result = pstrdup ( NameStr ( contup -> conname ) ) ;
ReleaseSysCache ( tp ) ;
return result ;
}
else return NULL ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void map_linear_vram_bank ( CirrusVGAState * s , unsigned bank ) {
MemoryRegion * mr = & s -> cirrus_bank [ bank ] ;
bool enabled = ! ( s -> cirrus_srcptr != s -> cirrus_srcptr_end ) && ! ( ( s -> vga . sr [ 0x07 ] & 0x01 ) == 0 ) && ! ( ( s -> vga . gr [ 0x0B ] & 0x14 ) == 0x14 ) && ! ( s -> vga . gr [ 0x0B ] & 0x02 ) ;
memory_region_set_enabled ( mr , enabled ) ;
memory_region_set_alias_offset ( mr , s -> cirrus_bank_base [ bank ] ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void event_text ( const char * data , SERVER_REC * server , WI_ITEM_REC * item ) {
char * line , * str , * target ;
g_return_if_fail ( data != NULL ) ;
if ( item == NULL ) return ;
if ( * data == '\0' ) {
signal_stop ( ) ;
return ;
}
line = settings_get_bool ( "expand_escapes" ) ? expand_escapes ( data , server , item ) : g_strdup ( data ) ;
if ( completion_auto && IS_CHANNEL ( item ) ) {
str = auto_complete ( CHANNEL ( item ) , line ) ;
if ( str != NULL ) {
g_free ( line ) ;
line = str ;
}
}
target = escape_string ( window_item_get_target ( item ) ) ;
str = g_strdup_printf ( IS_CHANNEL ( item ) ? "-channel \"%s\" %s" : IS_QUERY ( item ) ? "-nick \"%s\" %s" : "%s %s" , target , line ) ;
g_free ( target ) ;
signal_emit ( "command msg" , 3 , str , server , item ) ;
g_free ( str ) ;
g_free ( line ) ;
signal_stop ( ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( FullscreenControllerInteractiveTest , DISABLED_TestTabExitsFullscreenOnGoBack ) {
ASSERT_TRUE ( test_server ( ) -> Start ( ) ) ;
ui_test_utils : : NavigateToURL ( browser ( ) , GURL ( "about:blank" ) ) ;
ui_test_utils : : NavigateToURL ( browser ( ) , GURL ( "chrome:/ewtab" ) ) ;
ASSERT_NO_FATAL_FAILURE ( ToggleTabFullscreen ( true ) ) ;
GoBack ( ) ;
ASSERT_FALSE ( browser ( ) -> window ( ) -> IsFullscreen ( ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vp9_append_sub8x8_mvs_for_idx ( VP9_COMMON * cm , MACROBLOCKD * xd , const TileInfo * const tile , int block , int ref , int mi_row , int mi_col , int_mv * nearest , int_mv * near ) {
int_mv mv_list [ MAX_MV_REF_CANDIDATES ] ;
MODE_INFO * const mi = xd -> mi [ 0 ] ;
b_mode_info * bmi = mi -> bmi ;
int n ;
assert ( MAX_MV_REF_CANDIDATES == 2 ) ;
find_mv_refs_idx ( cm , xd , tile , mi , mi -> mbmi . ref_frame [ ref ] , mv_list , block , mi_row , mi_col ) ;
near -> as_int = 0 ;
switch ( block ) {
case 0 : nearest -> as_int = mv_list [ 0 ] . as_int ;
near -> as_int = mv_list [ 1 ] . as_int ;
break ;
case 1 : case 2 : nearest -> as_int = bmi [ 0 ] . as_mv [ ref ] . as_int ;
for ( n = 0 ;
n < MAX_MV_REF_CANDIDATES ;
++ n ) if ( nearest -> as_int != mv_list [ n ] . as_int ) {
near -> as_int = mv_list [ n ] . as_int ;
break ;
}
break ;
case 3 : {
int_mv candidates [ 2 + MAX_MV_REF_CANDIDATES ] ;
candidates [ 0 ] = bmi [ 1 ] . as_mv [ ref ] ;
candidates [ 1 ] = bmi [ 0 ] . as_mv [ ref ] ;
candidates [ 2 ] = mv_list [ 0 ] ;
candidates [ 3 ] = mv_list [ 1 ] ;
nearest -> as_int = bmi [ 2 ] . as_mv [ ref ] . as_int ;
for ( n = 0 ;
n < 2 + MAX_MV_REF_CANDIDATES ;
++ n ) if ( nearest -> as_int != candidates [ n ] . as_int ) {
near -> as_int = candidates [ n ] . as_int ;
break ;
}
break ;
}
default : assert ( "Invalid block index." ) ;
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void * gx_ttfMemory__alloc_struct ( ttfMemory * self , const ttfMemoryDescriptor * d , const char * cname ) {
gs_memory_t * mem = ( ( gx_ttfMemory * ) self ) -> memory ;
return mem -> procs . alloc_struct ( mem , ( const gs_memory_struct_type_t * ) d , cname ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static VP9_DENOISER_DECISION perform_motion_compensation ( VP9_DENOISER * denoiser , MACROBLOCK * mb , BLOCK_SIZE bs , int increase_denoising , int mi_row , int mi_col , PICK_MODE_CONTEXT * ctx , int * motion_magnitude ) {
int mv_col , mv_row ;
int sse_diff = ctx -> zeromv_sse - ctx -> newmv_sse ;
MV_REFERENCE_FRAME frame ;
MACROBLOCKD * filter_mbd = & mb -> e_mbd ;
MB_MODE_INFO * mbmi = & filter_mbd -> mi [ 0 ] . src_mi -> mbmi ;
MB_MODE_INFO saved_mbmi ;
int i , j ;
struct buf_2d saved_dst [ MAX_MB_PLANE ] ;
struct buf_2d saved_pre [ MAX_MB_PLANE ] [ 2 ] ;
saved_mbmi = * mbmi ;
for ( i = 0 ;
i < MAX_MB_PLANE ;
++ i ) {
for ( j = 0 ;
j < 2 ;
++ j ) {
saved_pre [ i ] [ j ] = filter_mbd -> plane [ i ] . pre [ j ] ;
}
saved_dst [ i ] = filter_mbd -> plane [ i ] . dst ;
}
mv_col = ctx -> best_sse_mv . as_mv . col ;
mv_row = ctx -> best_sse_mv . as_mv . row ;
* motion_magnitude = mv_row * mv_row + mv_col * mv_col ;
frame = ctx -> best_reference_frame ;
if ( frame != INTRA_FRAME && sse_diff > sse_diff_thresh ( bs , increase_denoising , mv_row , mv_col ) ) {
mbmi -> ref_frame [ 0 ] = ctx -> best_reference_frame ;
mbmi -> mode = ctx -> best_sse_inter_mode ;
mbmi -> mv [ 0 ] = ctx -> best_sse_mv ;
}
else {
frame = ctx -> best_zeromv_reference_frame ;
mbmi -> ref_frame [ 0 ] = ctx -> best_zeromv_reference_frame ;
mbmi -> mode = ZEROMV ;
mbmi -> mv [ 0 ] . as_int = 0 ;
ctx -> best_sse_inter_mode = ZEROMV ;
ctx -> best_sse_mv . as_int = 0 ;
ctx -> newmv_sse = ctx -> zeromv_sse ;
}
for ( j = 0 ;
j < 2 ;
++ j ) {
filter_mbd -> plane [ 0 ] . pre [ j ] . buf = block_start ( denoiser -> running_avg_y [ frame ] . y_buffer , denoiser -> running_avg_y [ frame ] . y_stride , mi_row , mi_col ) ;
filter_mbd -> plane [ 0 ] . pre [ j ] . stride = denoiser -> running_avg_y [ frame ] . y_stride ;
filter_mbd -> plane [ 1 ] . pre [ j ] . buf = block_start ( denoiser -> running_avg_y [ frame ] . u_buffer , denoiser -> running_avg_y [ frame ] . uv_stride , mi_row , mi_col ) ;
filter_mbd -> plane [ 1 ] . pre [ j ] . stride = denoiser -> running_avg_y [ frame ] . uv_stride ;
filter_mbd -> plane [ 2 ] . pre [ j ] . buf = block_start ( denoiser -> running_avg_y [ frame ] . v_buffer , denoiser -> running_avg_y [ frame ] . uv_stride , mi_row , mi_col ) ;
filter_mbd -> plane [ 2 ] . pre [ j ] . stride = denoiser -> running_avg_y [ frame ] . uv_stride ;
}
filter_mbd -> plane [ 0 ] . dst . buf = block_start ( denoiser -> mc_running_avg_y . y_buffer , denoiser -> mc_running_avg_y . y_stride , mi_row , mi_col ) ;
filter_mbd -> plane [ 0 ] . dst . stride = denoiser -> mc_running_avg_y . y_stride ;
filter_mbd -> plane [ 1 ] . dst . buf = block_start ( denoiser -> mc_running_avg_y . u_buffer , denoiser -> mc_running_avg_y . uv_stride , mi_row , mi_col ) ;
filter_mbd -> plane [ 1 ] . dst . stride = denoiser -> mc_running_avg_y . uv_stride ;
filter_mbd -> plane [ 2 ] . dst . buf = block_start ( denoiser -> mc_running_avg_y . v_buffer , denoiser -> mc_running_avg_y . uv_stride , mi_row , mi_col ) ;
filter_mbd -> plane [ 2 ] . dst . stride = denoiser -> mc_running_avg_y . uv_stride ;
vp9_build_inter_predictors_sby ( filter_mbd , mv_row , mv_col , bs ) ;
* mbmi = saved_mbmi ;
for ( i = 0 ;
i < MAX_MB_PLANE ;
++ i ) {
for ( j = 0 ;
j < 2 ;
++ j ) {
filter_mbd -> plane [ i ] . pre [ j ] = saved_pre [ i ] [ j ] ;
}
filter_mbd -> plane [ i ] . dst = saved_dst [ i ] ;
}
mv_row = ctx -> best_sse_mv . as_mv . row ;
mv_col = ctx -> best_sse_mv . as_mv . col ;
if ( ctx -> newmv_sse > sse_thresh ( bs , increase_denoising ) ) {
return COPY_BLOCK ;
}
if ( mv_row * mv_row + mv_col * mv_col > * noise_motion_thresh ( bs , increase_denoising ) ) {
return COPY_BLOCK ;
}
return FILTER_BLOCK ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vp9_sad ## m ## x ## n ## x ## k ## _c ( const uint8_t * src , int src_stride , const uint8_t * ref , int ref_stride , unsigned int * sads ) {
int i ;
for ( i = 0 ;
i < k ;
++ i ) sads [ i ] = vp9_sad ## m ## x ## n ## _c ( src , src_stride , & ref [ i ] , ref_stride ) ;
\ }
# define sadMxNx4D ( m , n ) void vp9_sad ## m ## x ## n ## x4d_c ( const uint8_t * src , int src_stride , const uint8_t * const refs [ ] , int ref_stride , unsigned int * sads ) {
int i ;
for ( i = 0 ;
i < 4 ;
++ i ) sads [ i ] = vp9_sad ## m ## x ## n ## _c ( src , src_stride , refs [ i ] , ref_stride ) ;
\ }
sadMxN ( 64 , 64 ) sadMxNxK ( 64 , 64 , 3 ) sadMxNxK ( 64 , 64 , 8 ) sadMxNx4D ( 64 , 64 ) sadMxN ( 64 , 32 ) sadMxNx4D ( 64 , 32 ) sadMxN ( 32 , 64 ) sadMxNx4D ( 32 , 64 ) sadMxN ( 32 , 32 ) sadMxNxK ( 32 , 32 , 3 ) sadMxNxK ( 32 , 32 , 8 )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int ASN1_TYPE_set1 ( ASN1_TYPE * a , int type , const void * value ) {
if ( ! value || ( type == V_ASN1_BOOLEAN ) ) {
void * p = ( void * ) value ;
ASN1_TYPE_set ( a , type , p ) ;
}
else if ( type == V_ASN1_OBJECT ) {
ASN1_OBJECT * odup ;
odup = OBJ_dup ( value ) ;
if ( ! odup ) return 0 ;
ASN1_TYPE_set ( a , type , odup ) ;
}
else {
ASN1_STRING * sdup ;
sdup = ASN1_STRING_dup ( value ) ;
if ( ! sdup ) return 0 ;
ASN1_TYPE_set ( a , type , sdup ) ;
}
return 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void * mspack_fmap_alloc ( struct mspack_system * self , size_t num ) {
return malloc ( num ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int check_principals_line ( struct ssh * ssh , char * cp , const struct sshkey_cert * cert , const char * loc , struct sshauthopt * * authoptsp ) {
u_int i , found = 0 ;
char * ep , * line_opts ;
const char * reason = NULL ;
struct sshauthopt * opts = NULL ;
if ( authoptsp != NULL ) * authoptsp = NULL ;
ep = cp + strlen ( cp ) - 1 ;
while ( ep > cp && ( * ep == '\n' || * ep == ' ' || * ep == '\t' ) ) * ep -- = '\0' ;
line_opts = NULL ;
if ( ( ep = strrchr ( cp , ' ' ) ) != NULL || ( ep = strrchr ( cp , '\t' ) ) != NULL ) {
for ( ;
* ep == ' ' || * ep == '\t' ;
ep ++ ) ;
line_opts = cp ;
cp = ep ;
}
if ( ( opts = sshauthopt_parse ( line_opts , & reason ) ) == NULL ) {
debug ( "%s: bad principals options: %s" , loc , reason ) ;
auth_debug_add ( "%s: bad principals options: %s" , loc , reason ) ;
return - 1 ;
}
for ( i = 0 ;
i < cert -> nprincipals ;
i ++ ) {
if ( strcmp ( cp , cert -> principals [ i ] ) != 0 ) continue ;
debug3 ( "%s: matched principal \"%.100s\"" , loc , cert -> principals [ i ] ) ;
found = 1 ;
}
if ( found && authoptsp != NULL ) {
* authoptsp = opts ;
opts = NULL ;
}
sshauthopt_free ( opts ) ;
return found ? 0 : - 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline int c6_to_8 ( int v ) {
int b ;
v &= 0x3f ;
b = v & 1 ;
return ( v << 2 ) | ( b << 1 ) | b ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static ossl_inline t2 * sk_ ## t1 ## _delete ( STACK_OF ( t1 ) * sk , int i ) {
return ( t2 * ) OPENSSL_sk_delete ( ( OPENSSL_STACK * ) sk , i ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _delete_ptr ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return ( t2 * ) OPENSSL_sk_delete_ptr ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _push ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_push ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _unshift ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_unshift ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _pop ( STACK_OF ( t1 ) * sk ) {
return ( t2 * ) OPENSSL_sk_pop ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _shift ( STACK_OF ( t1 ) * sk ) {
return ( t2 * ) OPENSSL_sk_shift ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline void sk_ ## t1 ## _pop_free ( STACK_OF ( t1 ) * sk , sk_ ## t1 ## _freefunc freefunc ) {
OPENSSL_sk_pop_free ( ( OPENSSL_STACK * ) sk , ( OPENSSL_sk_freefunc ) freefunc ) ;
}
static ossl_inline int sk_ ## t1 ## _insert ( STACK_OF ( t1 ) * sk , t2 * ptr , int idx ) {
return OPENSSL_sk_insert ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr , idx ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _set ( STACK_OF ( t1 ) * sk , int idx , t2 * ptr ) {
return ( t2 * ) OPENSSL_sk_set ( ( OPENSSL_STACK * ) sk , idx , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _find ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_find ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _find_ex ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_find_ex ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline void sk_ ## t1 ## _sort ( STACK_OF ( t1 ) * sk ) {
OPENSSL_sk_sort ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline int sk_ ## t1 ## _is_sorted ( const STACK_OF ( t1 ) * sk ) {
return OPENSSL_sk_is_sorted ( ( const OPENSSL_STACK * ) sk ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _dup ( const STACK_OF ( t1 ) * sk ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_dup ( ( const OPENSSL_STACK * ) sk ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _deep_copy ( const STACK_OF ( t1 ) * sk , sk_ ## t1 ## _copyfunc copyfunc , sk_ ## t1 ## _freefunc freefunc ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_deep_copy ( ( const OPENSSL_STACK * ) sk , ( OPENSSL_sk_copyfunc ) copyfunc , ( OPENSSL_sk_freefunc ) freefunc ) ;
}
static ossl_inline sk_ ## t1 ## _compfunc sk_ ## t1 ## _set_cmp_func ( STACK_OF ( t1 ) * sk , sk_ ## t1 ## _compfunc compare ) {
return ( sk_ ## t1 ## _compfunc ) OPENSSL_sk_set_cmp_func ( ( OPENSSL_STACK * ) sk , ( OPENSSL_sk_compfunc ) compare ) ;
}
# define DEFINE_SPECIAL_STACK_OF ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , t2 , t2 ) # define DEFINE_STACK_OF ( t ) SKM_DEFINE_STACK_OF ( t , t , t ) # define DEFINE_SPECIAL_STACK_OF_CONST ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , const t2 , t2 ) # define DEFINE_STACK_OF_CONST ( t ) SKM_DEFINE_STACK_OF ( t , const t , t ) typedef char * OPENSSL_STRING ;
typedef const char * OPENSSL_CSTRING ;
DEFINE_SPECIAL_STACK_OF ( OPENSSL_STRING , char )
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
void proto_register_rsvp ( void ) {
gint i ;
static hf_register_info rsvpf_info [ ] = {
{
& hf_rsvp_filter [ RSVPF_MSG ] , {
"Message Type" , "rsvp.msg" , FT_UINT8 , BASE_DEC | BASE_EXT_STRING , & message_type_vals_ext , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_PATH ] , {
"Path Message" , "rsvp.path" , FT_BOOLEAN , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_RESV ] , {
"Resv Message" , "rsvp.resv" , FT_BOOLEAN , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_PATHERR ] , {
"Path Error Message" , "rsvp.perr" , FT_BOOLEAN , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_RESVERR ] , {
"Resv Error Message" , "rsvp.rerr" , FT_BOOLEAN , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_PATHTEAR ] , {
"Path Tear Message" , "rsvp.ptear" , FT_BOOLEAN , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_RESVTEAR ] , {
"Resv Tear Message" , "rsvp.rtear" , FT_BOOLEAN , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_RCONFIRM ] , {
"Resv Confirm Message" , "rsvp.resvconf" , FT_BOOLEAN , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_RTEARCONFIRM ] , {
"Resv Tear Confirm Message" , "rsvp.rtearconf" , FT_BOOLEAN , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_BUNDLE ] , {
"Bundle Message" , "rsvp.bundle" , FT_BOOLEAN , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_ACK ] , {
"Ack Message" , "rsvp.ack" , FT_BOOLEAN , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_SREFRESH ] , {
"Srefresh Message" , "rsvp.srefresh" , FT_BOOLEAN , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_HELLO ] , {
"HELLO Message" , "rsvp.hello" , FT_BOOLEAN , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_OBJECT ] , {
"Object class" , "rsvp.object" , FT_UINT8 , BASE_DEC | BASE_EXT_STRING , & rsvp_class_vals_ext , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ctype , {
"C-type" , "rsvp.ctype" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_parameter , {
"Parameter" , "rsvp.parameter" , FT_UINT8 , BASE_DEC | BASE_EXT_STRING , & svc_vals_ext , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_parameter_flags , {
"Parameter flags" , "rsvp.parameter_flags" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_parameter_length , {
"Parameter length" , "rsvp.parameter_length" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_error_value , {
"Error value" , "rsvp.error_value" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_class , {
"Class" , "rsvp.class" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_class_length , {
"Length" , "rsvp.class_length" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_switching_granularity , {
"Switching granularity" , "rsvp.switching_granularity" , FT_UINT16 , BASE_DEC , VALS ( rsvp_switching_granularity_vals ) , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_NOTIFY ] , {
"Notify Message" , "rsvp.notify" , FT_BOOLEAN , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_SESSION ] , {
"SESSION" , "rsvp.session" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_HOP ] , {
"HOP" , "rsvp.hop" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_HELLO_OBJ ] , {
"HELLO Request/Ack" , "rsvp.hello_obj" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_INTEGRITY ] , {
"INTEGRITY" , "rsvp.integrity" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_TIME_VALUES ] , {
"TIME VALUES" , "rsvp.time" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_ERROR ] , {
"ERROR" , "rsvp.error" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_SCOPE ] , {
"SCOPE" , "rsvp.scope" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_STYLE ] , {
"STYLE" , "rsvp.style" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_FLOWSPEC ] , {
"FLOWSPEC" , "rsvp.flowspec" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_FILTER_SPEC ] , {
"FILTERSPEC" , "rsvp.filter" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_SENDER ] , {
"SENDER TEMPLATE" , "rsvp.sender" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_TSPEC ] , {
"SENDER TSPEC" , "rsvp.tspec" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_ADSPEC ] , {
"ADSPEC" , "rsvp.adspec" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_POLICY ] , {
"POLICY" , "rsvp.policy" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_CONFIRM ] , {
"CONFIRM" , "rsvp.confirm" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_LABEL ] , {
"LABEL" , "rsvp.label" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_RECOVERY_LABEL ] , {
"RECOVERY LABEL" , "rsvp.recovery_label" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_UPSTREAM_LABEL ] , {
"UPSTREAM LABEL" , "rsvp.upstream_label" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_SUGGESTED_LABEL ] , {
"SUGGESTED LABEL" , "rsvp.suggested_label" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_LABEL_SET ] , {
"LABEL SET" , "rsvp.label_set" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_ACCEPTABLE_LABEL_SET ] , {
"ACCEPTABLE LABEL SET" , "rsvp.acceptable_label_set" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_PROTECTION ] , {
"PROTECTION" , "rsvp.protection" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_DIFFSERV ] , {
"DIFFSERV" , "rsvp.diffserv" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_DSTE ] , {
"CLASSTYPE" , "rsvp.dste" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_RESTART_CAP ] , {
"RESTART CAPABILITY" , "rsvp.restart" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_LINK_CAP ] , {
"LINK CAPABILITY" , "rsvp.link" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_LABEL_REQUEST ] , {
"LABEL REQUEST" , "rsvp.label_request" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_SESSION_ATTRIBUTE ] , {
"SESSION ATTRIBUTE" , "rsvp.session_attribute" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_EXPLICIT_ROUTE ] , {
"EXPLICIT ROUTE" , "rsvp.explicit_route" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_RECORD_ROUTE ] , {
"RECORD ROUTE" , "rsvp.record_route" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_MESSAGE_ID ] , {
"MESSAGE-ID" , "rsvp.msgid" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_MESSAGE_ID_ACK ] , {
"MESSAGE-ID ACK" , "rsvp.msgid_ack" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_MESSAGE_ID_LIST ] , {
"MESSAGE-ID LIST" , "rsvp.msgid_list" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_DCLASS ] , {
"DCLASS" , "rsvp.dclass" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_LSP_TUNNEL_IF_ID ] , {
"LSP INTERFACE-ID" , "rsvp.lsp_tunnel_if_id" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_ADMIN_STATUS ] , {
"ADMIN STATUS" , "rsvp.admin_status" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_ADMIN_STATUS_REFLECT ] , {
"Reflect" , "rsvp.admin_status.reflect" , FT_BOOLEAN , 32 , NULL , 0x80000000 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_ADMIN_STATUS_HANDOVER ] , {
"Handover" , "rsvp.admin_status.handover" , FT_BOOLEAN , 32 , NULL , 0x40 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_ADMIN_STATUS_LOCKOUT ] , {
"Lockout" , "rsvp.admin_status.lockout" , FT_BOOLEAN , 32 , NULL , 0x20 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_ADMIN_STATUS_INHIBIT ] , {
"Inhibit Alarm Communication" , "rsvp.admin_status.inhibit" , FT_BOOLEAN , 32 , NULL , 0x10 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_ADMIN_STATUS_CALL_MGMT ] , {
"Call Management" , "rsvp.admin_status.callmgmt" , FT_BOOLEAN , 32 , NULL , 0x08 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_ADMIN_STATUS_TESTING ] , {
"Testing" , "rsvp.admin_status.testing" , FT_BOOLEAN , 32 , NULL , 0x04 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_ADMIN_STATUS_DOWN ] , {
"Administratively down" , "rsvp.admin_status.down" , FT_BOOLEAN , 32 , NULL , 0x02 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_ADMIN_STATUS_DELETE ] , {
"Delete in progress" , "rsvp.admin_status.delete" , FT_BOOLEAN , 32 , NULL , 0x01 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_LSP_ATTRIBUTES ] , {
"LSP ATTRIBUTES" , "rsvp.lsp_attributes" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_ASSOCIATION ] , {
"ASSOCIATION" , "rsvp.association" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_CALL_ATTRIBUTES ] , {
"CALL ATTRIBUTES" , "rsvp.call_attributes" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_NOTIFY_REQUEST ] , {
"NOTIFY REQUEST" , "rsvp.notify_request" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_GENERALIZED_UNI ] , {
"GENERALIZED UNI" , "rsvp.generalized_uni" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_CALL_ID ] , {
"CALL ID" , "rsvp.call_id" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_3GPP2_OBJECT ] , {
"3GPP2 OBJECT" , "rsvp.3gpp2_object" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_PRIVATE_OBJ ] , {
"Private object" , "rsvp.obj_private" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_UNKNOWN_OBJ ] , {
"Unknown object" , "rsvp.obj_unknown" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_SESSION_IP ] , {
"Destination address" , "rsvp.session.ip" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_SESSION_SHORT_CALL_ID ] , {
"Short Call ID" , "rsvp.session.short_call_id" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_SESSION_PORT ] , {
"Port number" , "rsvp.session.port" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_SESSION_PROTO ] , {
"Protocol" , "rsvp.session.proto" , FT_UINT8 , BASE_DEC , VALS ( proto_vals ) , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_SESSION_TUNNEL_ID ] , {
"Tunnel ID" , "rsvp.session.tunnel_id" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_SESSION_EXT_TUNNEL_ID ] , {
"Extended tunnel ID" , "rsvp.session.ext_tunnel_id" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_SESSION_EXT_TUNNEL_ID_IPV6 ] , {
"Extended tunnel ID" , "rsvp.session.ext_tunnel_id_ipv6" , FT_IPv6 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_JUNIPER ] , {
"Juniper" , "rsvp.juniper" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_SENDER_IP ] , {
"Sender IPv4 address" , "rsvp.sender.ip" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_SENDER_PORT ] , {
"Sender port number" , "rsvp.sender.port" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_SENDER_LSP_ID ] , {
"Sender LSP ID" , "rsvp.sender.lsp_id" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_SENDER_SHORT_CALL_ID ] , {
"Short Call ID" , "rsvp.sender.short_call_id" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_DIFFSERV_MAPNB ] , {
"MAPnb" , "rsvp.diffserv.mapnb" , FT_UINT8 , BASE_DEC , NULL , 0x0 , MAPNB_DESCRIPTION , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_DIFFSERV_MAP ] , {
"MAP" , "rsvp.diffserv.map" , FT_NONE , BASE_NONE , NULL , 0x0 , MAP_DESCRIPTION , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_DIFFSERV_MAP_EXP ] , {
"EXP" , "rsvp.diffserv.map.exp" , FT_UINT8 , BASE_DEC , NULL , 0x0 , EXP_DESCRIPTION , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_DIFFSERV_PHBID ] , {
PHBID_DESCRIPTION , "rsvp.diffserv.phbid" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_DIFFSERV_PHBID_DSCP ] , {
PHBID_DSCP_DESCRIPTION , "rsvp.diffserv.phbid.dscp" , FT_UINT16 , BASE_DEC , NULL , PHBID_DSCP_MASK , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_DIFFSERV_PHBID_CODE ] , {
PHBID_CODE_DESCRIPTION , "rsvp.diffserv.phbid.code" , FT_UINT16 , BASE_DEC , NULL , PHBID_CODE_MASK , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_DIFFSERV_PHBID_BIT14 ] , {
PHBID_BIT14_DESCRIPTION , "rsvp.diffserv.phbid.bit14" , FT_UINT16 , BASE_DEC , VALS ( phbid_bit14_vals ) , PHBID_BIT14_MASK , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_DIFFSERV_PHBID_BIT15 ] , {
PHBID_BIT15_DESCRIPTION , "rsvp.diffserv.phbid.bit15" , FT_UINT16 , BASE_DEC , VALS ( phbid_bit15_vals ) , PHBID_BIT15_MASK , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_DSTE_CLASSTYPE ] , {
"CT" , "rsvp.dste.classtype" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_GUNI_SRC_IPV4 ] , {
"Source TNA" , "rsvp.guni.srctna.ipv4" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_GUNI_DST_IPV4 ] , {
"Destination TNA" , "rsvp.guni.dsttna.ipv4" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_GUNI_SRC_IPV6 ] , {
"Source TNA" , "rsvp.guni.srctna.ipv6" , FT_IPv6 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_GUNI_DST_IPV6 ] , {
"Destination TNA" , "rsvp.guni.dsttna.ipv6" , FT_IPv6 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_CALL_ID_SRC_ADDR_IPV4 ] , {
"Source Transport Network Address" , "rsvp.callid.srcaddr.ipv4" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_CALL_ID_SRC_ADDR_IPV6 ] , {
"Source Transport Network Address" , "rsvp.callid.srcaddr.ipv6" , FT_IPv6 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_callid_srcaddr_ether , {
"Source Transport Network Address" , "rsvp.callid.srcaddr.ether" , FT_ETHER , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_callid_srcaddr_bytes , {
"Source Transport Network Address" , "rsvp.callid.srcaddr.bytes" , FT_ETHER , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_filter [ RSVPF_ENT_CODE ] , {
"Enterprise Code" , "rsvp.obj_private.enterprise" , FT_UINT32 , BASE_DEC | BASE_EXT_STRING , & sminmpec_values_ext , 0x0 , "IANA Network Management Private Enterprise Code" , HFILL }
}
, {
& hf_rsvp_error_flags , {
"Flags" , "rsvp.error_flags" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_error_flags_path_state_removed , {
"Path State Removed" , "rsvp.error_flags.path_state_removed" , FT_BOOLEAN , 8 , TFS ( & tfs_set_notset ) , 0x04 , NULL , HFILL }
}
, {
& hf_rsvp_error_flags_not_guilty , {
"NotGuilty" , "rsvp.error_flags.not_guilty" , FT_BOOLEAN , 8 , TFS ( & tfs_set_notset ) , 0x02 , NULL , HFILL }
}
, {
& hf_rsvp_error_flags_in_place , {
"InPlace" , "rsvp.error_flags.in_place" , FT_BOOLEAN , 8 , TFS ( & tfs_set_notset ) , 0x01 , NULL , HFILL }
}
, {
& hf_rsvp_eth_tspec_tlv_color_mode , {
"Color Mode (CM)" , "rsvp.eth_tspec_tlv.color_mode" , FT_BOOLEAN , 8 , TFS ( & tfs_set_notset ) , 0x02 , NULL , HFILL }
}
, {
& hf_rsvp_eth_tspec_tlv_coupling_flag , {
"Coupling Flag (CF)" , "rsvp.eth_tspec_tlv.coupling_flag" , FT_BOOLEAN , 8 , TFS ( & tfs_set_notset ) , 0x01 , NULL , HFILL }
}
, {
& hf_rsvp_sender_tspec_standard_contiguous_concatenation , {
"Standard contiguous concatenation" , "rsvp.sender_tspec.standard_contiguous_concatenation" , FT_BOOLEAN , 8 , TFS ( & tfs_yes_no ) , 0x01 , NULL , HFILL }
}
, {
& hf_rsvp_sender_tspec_arbitrary_contiguous_concatenation , {
"Arbitrary contiguous concatenation" , "rsvp.sender_tspec.arbitrary_contiguous_concatenation" , FT_BOOLEAN , 8 , TFS ( & tfs_yes_no ) , 0x02 , NULL , HFILL }
}
, {
& hf_rsvp_sender_tspec_regenerator_section , {
"Section/Regenerator Section layer transparency" , "rsvp.sender_tspec.regenerator_section" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0001 , NULL , HFILL }
}
, {
& hf_rsvp_sender_tspec_multiplex_section , {
"Line/Multiplex Section layer transparency" , "rsvp.sender_tspec.multiplex_section" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0002 , NULL , HFILL }
}
, {
& hf_rsvp_sender_tspec_J0_transparency , {
"J0 transparency" , "rsvp.sender_tspec.J0_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0004 , NULL , HFILL }
}
, {
& hf_rsvp_sender_tspec_SOH_RSOH_DCC_transparency , {
"SOH/RSOH DCC transparency" , "rsvp.sender_tspec.SOH_RSOH_DCC_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0008 , NULL , HFILL }
}
, {
& hf_rsvp_sender_tspec_LOH_MSOH_DCC_transparency , {
"LOH/MSOH DCC transparency" , "rsvp.sender_tspec.LOH_MSOH_DCC_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0010 , NULL , HFILL }
}
, {
& hf_rsvp_sender_tspec_LOH_MSOH_extended_DCC_transparency , {
"LOH/MSOH Extended DCC transparency" , "rsvp.sender_tspec.LOH_MSOH_extended_DCC_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0020 , NULL , HFILL }
}
, {
& hf_rsvp_sender_tspec_K1_K2_transparency , {
"K1/K2 transparency" , "rsvp.sender_tspec.K1_K2_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0040 , NULL , HFILL }
}
, {
& hf_rsvp_sender_tspec_E1_transparency , {
"E1 transparency" , "rsvp.sender_tspec.E1_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0080 , NULL , HFILL }
}
, {
& hf_rsvp_sender_tspec_F1_transparency , {
"F1 transparency" , "rsvp.sender_tspec.F1_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0100 , NULL , HFILL }
}
, {
& hf_rsvp_sender_tspec_E2_transparency , {
"E2 transparency" , "rsvp.sender_tspec.E2_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0200 , NULL , HFILL }
}
, {
& hf_rsvp_sender_tspec_B1_transparency , {
"B1 transparency" , "rsvp.sender_tspec.B1_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0400 , NULL , HFILL }
}
, {
& hf_rsvp_sender_tspec_B2_transparency , {
"B2 transparency" , "rsvp.sender_tspec.B2_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0800 , NULL , HFILL }
}
, {
& hf_rsvp_sender_tspec_M0_transparency , {
"M0 transparency" , "rsvp.sender_tspec.M0_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x1000 , NULL , HFILL }
}
, {
& hf_rsvp_sender_tspec_M1_transparency , {
"M1 transparency" , "rsvp.sender_tspec.M1_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x2000 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_standard_contiguous_concatenation , {
"Standard contiguous concatenation" , "rsvp.flowspec.standard_contiguous_concatenation" , FT_BOOLEAN , 8 , TFS ( & tfs_yes_no ) , 0x01 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_arbitrary_contiguous_concatenation , {
"Arbitrary contiguous concatenation" , "rsvp.flowspec.arbitrary_contiguous_concatenation" , FT_BOOLEAN , 8 , TFS ( & tfs_yes_no ) , 0x02 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_regenerator_section , {
"Section/Regenerator Section layer transparency" , "rsvp.flowspec.regenerator_section" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0001 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_multiplex_section , {
"Line/Multiplex Section layer transparency" , "rsvp.flowspec.multiplex_section" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0002 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_J0_transparency , {
"J0 transparency" , "rsvp.flowspec.J0_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0004 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_SOH_RSOH_DCC_transparency , {
"SOH/RSOH DCC transparency" , "rsvp.flowspec.SOH_RSOH_DCC_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0008 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_LOH_MSOH_DCC_transparency , {
"LOH/MSOH DCC transparency" , "rsvp.flowspec.LOH_MSOH_DCC_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0010 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_LOH_MSOH_extended_DCC_transparency , {
"LOH/MSOH Extended DCC transparency" , "rsvp.flowspec.LOH_MSOH_extended_DCC_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0020 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_K1_K2_transparency , {
"K1/K2 transparency" , "rsvp.flowspec.K1_K2_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0040 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_E1_transparency , {
"E1 transparency" , "rsvp.flowspec.E1_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0080 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_F1_transparency , {
"F1 transparency" , "rsvp.flowspec.F1_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0100 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_E2_transparency , {
"E2 transparency" , "rsvp.flowspec.E2_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0200 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_B1_transparency , {
"B1 transparency" , "rsvp.flowspec.B1_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0400 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_B2_transparency , {
"B2 transparency" , "rsvp.flowspec.B2_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x0800 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_M0_transparency , {
"M0 transparency" , "rsvp.flowspec.M0_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x1000 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_M1_transparency , {
"M1 transparency" , "rsvp.flowspec.M1_transparency" , FT_BOOLEAN , 32 , TFS ( & tfs_yes_no ) , 0x2000 , NULL , HFILL }
}
, {
& hf_rsvp_integrity_flags_handshake , {
"Handshake" , "rsvp.integrity.flags.handshake" , FT_BOOLEAN , 8 , TFS ( & tfs_capable_not_capable ) , 0x01 , NULL , HFILL }
}
, {
& hf_rsvp_sa_flags_local , {
"Local protection" , "rsvp.sa.flags.local" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x01 , NULL , HFILL }
}
, {
& hf_rsvp_sa_flags_label , {
"Label recording" , "rsvp.sa.flags.label" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x02 , NULL , HFILL }
}
, {
& hf_rsvp_sa_flags_se_style , {
"SE style" , "rsvp.sa.flags.se_style" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x04 , NULL , HFILL }
}
, {
& hf_rsvp_sa_flags_bandwidth , {
"Bandwidth protection" , "rsvp.sa.flags.bandwidth" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x08 , NULL , HFILL }
}
, {
& hf_rsvp_sa_flags_node , {
"Node protection" , "rsvp.sa.flags.node" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x10 , NULL , HFILL }
}
, {
& hf_rsvp_rro_flags_local_avail , {
"Local Protection" , "rsvp.rro.flags.local_avail" , FT_BOOLEAN , 8 , TFS ( & tfs_available_not_available ) , 0x01 , NULL , HFILL }
}
, {
& hf_rsvp_rro_flags_local_in_use , {
"Local Protection" , "rsvp.rro.flags.local_in_use" , FT_BOOLEAN , 8 , TFS ( & tfs_used_notused ) , 0x02 , NULL , HFILL }
}
, {
& hf_rsvp_rro_flags_bandwidth , {
"Bandwidth Protection" , "rsvp.rro.flags.bandwidth" , FT_BOOLEAN , 8 , TFS ( & tfs_available_not_available ) , 0x04 , NULL , HFILL }
}
, {
& hf_rsvp_rro_flags_node , {
"Node Protection" , "rsvp.rro.flags.node" , FT_BOOLEAN , 8 , TFS ( & tfs_available_not_available ) , 0x08 , NULL , HFILL }
}
, {
& hf_rsvp_rro_flags_node_address , {
"Address Specifies a Node-id Address" , "rsvp.rro.flags.node_address" , FT_BOOLEAN , 8 , TFS ( & tfs_yes_no ) , 0x20 , NULL , HFILL }
}
, {
& hf_rsvp_rro_flags_backup_tunnel_bandwidth , {
"Backup Tunnel Has Bandwidth" , "rsvp.rro.flags.backup_tunnel_bandwidth" , FT_BOOLEAN , 8 , TFS ( & tfs_yes_no ) , 0x04 , NULL , HFILL }
}
, {
& hf_rsvp_rro_flags_backup_tunnel_hop , {
"Backup Tunnel Goes To" , "rsvp.rro.flags.backup_tunnel_hop" , FT_BOOLEAN , 8 , TFS ( & tfs_next_next_hop_next_hop ) , 0x08 , NULL , HFILL }
}
, {
& hf_rsvp_rro_flags_global_label , {
"Global label" , "rsvp.rro.flags.global_label" , FT_BOOLEAN , 8 , NULL , 0x01 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_attr_e2e , {
"End-to-end re-routing" , "rsvp.lsp_attr.e2e" , FT_BOOLEAN , 32 , TFS ( & tfs_desired_not_desired ) , 0x00000001 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_attr_boundary , {
"Boundary re-routing" , "rsvp.lsp_attr.boundary" , FT_BOOLEAN , 32 , TFS ( & tfs_desired_not_desired ) , 0x00000002 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_attr_segment , {
"Segment-based re-routing" , "rsvp.lsp_attr.segment" , FT_BOOLEAN , 32 , TFS ( & tfs_desired_not_desired ) , 0x00000004 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_attr_integrity , {
"LSP Integrity Required" , "rsvp.lsp_attr.integrity" , FT_BOOLEAN , 32 , TFS ( & tfs_desired_not_desired ) , 0x00000008 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_attr_contiguous , {
"Contiguous LSP" , "rsvp.lsp_attr.contiguous" , FT_BOOLEAN , 32 , TFS ( & tfs_desired_not_desired ) , 0x00000010 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_attr_stitching , {
"LSP stitching desired" , "rsvp.lsp_attr.stitching" , FT_BOOLEAN , 32 , TFS ( & tfs_desired_not_desired ) , 0x00000020 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_attr_preplanned , {
"Pre-Planned LSP Flag" , "rsvp.lsp_attr.preplanned" , FT_BOOLEAN , 32 , TFS ( & tfs_desired_not_desired ) , 0x00000040 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_attr_nophp , {
"Non-PHP behavior flag" , "rsvp.lsp_attr.nophp" , FT_BOOLEAN , 32 , TFS ( & tfs_desired_not_desired ) , 0x00000080 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_attr_oobmap , {
"OOB mapping flag" , "rsvp.lsp_attr.oobmap" , FT_BOOLEAN , 32 , TFS ( & tfs_desired_not_desired ) , 0x00000100 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_attr_entropy , {
"Entropy Label Capability" , "rsvp.lsp_attr.entropy" , FT_BOOLEAN , 32 , TFS ( & tfs_desired_not_desired ) , 0x00000200 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_attr_srlgcollect , {
"SRLG Collection Flag" , "rsvp.lsp_attr.srlgcollect" , FT_BOOLEAN , 32 , TFS ( & tfs_desired_not_desired ) , 0x00000400 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_attr_costcollect , {
"Cost Collection Flag" , "rsvp.lsp_attr.costcollect" , FT_BOOLEAN , 32 , TFS ( & tfs_desired_not_desired ) , 0x00000800 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_attr_latcollect , {
"Latency Collection Flag" , "rsvp.lsp_attr.latcollect" , FT_BOOLEAN , 32 , TFS ( & tfs_desired_not_desired ) , 0x00001000 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_attr_latvarcollect , {
"Latency Variation Flag" , "rsvp.lsp_attr.latvarcollect" , FT_BOOLEAN , 32 , TFS ( & tfs_desired_not_desired ) , 0x00002000 , NULL , HFILL }
}
, {
& hf_rsvp_gen_uni_direction , {
"Direction" , "rsvp.gen_uni.direction" , FT_BOOLEAN , 8 , TFS ( & tfs_gen_uni_direction ) , 0x80 , NULL , HFILL }
}
, {
& hf_rsvp_protection_info_flags_secondary_lsp , {
"Secondary LSP" , "rsvp.pi.flags.secondary_lsp" , FT_BOOLEAN , 8 , TFS ( & tfs_yes_no ) , 0x80 , NULL , HFILL }
}
, {
& hf_rsvp_pi_link_flags_extra_traffic , {
"Extra Traffic" , "rsvp.pi_link.flags.extra_traffic" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x01 , NULL , HFILL }
}
, {
& hf_rsvp_pi_link_flags_unprotected , {
"Unprotected" , "rsvp.pi_link.flags.unprotected" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x02 , NULL , HFILL }
}
, {
& hf_rsvp_pi_link_flags_shared , {
"Shared" , "rsvp.pi_link.flags.shared" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x04 , NULL , HFILL }
}
, {
& hf_rsvp_pi_link_flags_dedicated1_1 , {
"Dedicated 1:1" , "rsvp.pi_link.flags.dedicated1_1" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x08 , NULL , HFILL }
}
, {
& hf_rsvp_pi_link_flags_dedicated1plus1 , {
"Dedicated 1+1" , "rsvp.pi_link.flags.dedicated1plus1" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x10 , NULL , HFILL }
}
, {
& hf_rsvp_pi_link_flags_enhanced , {
"Enhanced" , "rsvp.pi_link.flags.enhanced" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x20 , NULL , HFILL }
}
, {
& hf_rsvp_pi_link_flags_extra , {
"Extra Traffic" , "rsvp.pi_link.flags.extra" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x01 , NULL , HFILL }
}
, {
& hf_rsvp_pi_link_flags_dedicated_1_1 , {
"Dedicated 1:1" , "rsvp.pi_link.flags.dedicated_1_1" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x08 , NULL , HFILL }
}
, {
& hf_rsvp_pi_link_flags_dedicated_1plus1 , {
"Dedicated 1+1" , "rsvp.pi_link.flags.dedicated_1plus1" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x10 , NULL , HFILL }
}
, {
& hf_rsvp_rfc4872_secondary , {
"Secondary LSP" , "rsvp.rfc4872.secondary" , FT_BOOLEAN , 8 , TFS ( & tfs_yes_no ) , 0x80 , NULL , HFILL }
}
, {
& hf_rsvp_rfc4872_protecting , {
"Protecting LSP" , "rsvp.rfc4872.protecting" , FT_BOOLEAN , 8 , TFS ( & tfs_yes_no ) , 0x40 , NULL , HFILL }
}
, {
& hf_rsvp_rfc4872_notification_msg , {
"Protecting LSP" , "rsvp.rfc4872.notification_msg" , FT_BOOLEAN , 8 , TFS ( & tfs_yes_no ) , 0x20 , NULL , HFILL }
}
, {
& hf_rsvp_rfc4872_operational , {
"Protecting LSP" , "rsvp.rfc4872.operational" , FT_BOOLEAN , 8 , TFS ( & tfs_yes_no ) , 0x10 , NULL , HFILL }
}
, {
& hf_rsvp_pi_lsp_flags_full_rerouting , {
"(Full) rerouting" , "rsvp.pi_lsp.flags.full_rerouting" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x01 , NULL , HFILL }
}
, {
& hf_rsvp_pi_lsp_flags_rerouting_extra , {
"Rerouting without extra-traffic" , "rsvp.pi_lsp.flags.rerouting_extra" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x02 , NULL , HFILL }
}
, {
& hf_rsvp_pi_lsp_flags_1_n_protection , {
"1:N protection with extra-traffic" , "rsvp.pi_lsp.flags.1_n_protection" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x04 , NULL , HFILL }
}
, {
& hf_rsvp_pi_lsp_flags_1plus1_unidirectional , {
"1+1 unidirectional protection" , "rsvp.pi_lsp.flags.1plus1_unidirectional" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x08 , NULL , HFILL }
}
, {
& hf_rsvp_pi_lsp_flags_1plus1_bidirectional , {
"1+1 bidirectional protection" , "rsvp.pi_lsp.flags.1plus1_bidirectional" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x10 , NULL , HFILL }
}
, {
& hf_rsvp_protection_info_in_place , {
"In-Place" , "rsvp.protection_info.in_place" , FT_BOOLEAN , 8 , TFS ( & tfs_yes_no ) , 0x80 , NULL , HFILL }
}
, {
& hf_rsvp_protection_info_required , {
"Required" , "rsvp.protection_info.required" , FT_BOOLEAN , 8 , TFS ( & tfs_yes_no ) , 0x40 , NULL , HFILL }
}
, {
& hf_rsvp_pi_seg_flags_full_rerouting , {
"(Full) rerouting" , "rsvp.pi_seg.flags.full_rerouting" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x01 , NULL , HFILL }
}
, {
& hf_rsvp_pi_seg_flags_rerouting_extra , {
"Rerouting without extra-traffic" , "rsvp.pi_seg.flags.rerouting_extra" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x02 , NULL , HFILL }
}
, {
& hf_rsvp_pi_seg_flags_1_n_protection , {
"1:N protection with extra-traffic" , "rsvp.pi_seg.flags.1_n_protection" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x04 , NULL , HFILL }
}
, {
& hf_rsvp_pi_seg_flags_1plus1_unidirectional , {
"1+1 unidirectional protection" , "rsvp.pi_seg.flags.1plus1_unidirectional" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x08 , NULL , HFILL }
}
, {
& hf_rsvp_pi_seg_flags_1plus1_bidirectional , {
"1+1 bidirectional protection" , "rsvp.pi_seg.flags.1plus1_bidirectional" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x10 , NULL , HFILL }
}
, {
& hf_rsvp_frr_flags_one2one_backup , {
"One-to-One Backup" , "rsvp.frr.flags.one2one_backup" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x01 , NULL , HFILL }
}
, {
& hf_rsvp_frr_flags_facility_backup , {
"Facility Backup" , "rsvp.frr.flags.facility_backup" , FT_BOOLEAN , 8 , TFS ( & tfs_desired_not_desired ) , 0x02 , NULL , HFILL }
}
, {
& hf_rsvp_type , {
"Type" , "rsvp.type" , FT_UINT16 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_tid , {
"Transaction ID" , "rsvp.3gpp_obj.tid" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_ie_len , {
"Length" , "rsvp.3gpp_obj.length" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_ie_type , {
"IE Type" , "rsvp.3gpp_obj.ie_type" , FT_UINT32 , BASE_DEC , VALS ( rsvp_3gpp_object_ie_type_vals ) , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_ue_ipv4_addr , {
"UE IPv4 address" , "rsvp.3gpp_obj.ue_ipv4_addr" , FT_IPv4 , BASE_NONE , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_ue_ipv6_addr , {
"UE IPv6 address" , "rsvp.3gpp_obj.ue_ipv6_addr" , FT_IPv6 , BASE_NONE , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_tft_d , {
"Direction(D)" , "rsvp.3gpp_obj.tft_d" , FT_UINT32 , BASE_DEC , VALS ( rsvp_3gpp_object_tft_d_vals ) , 0xc0000000 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_tft_ns , {
"Non-Specific bit(NS)" , "rsvp.3gpp_obj.tft_ns" , FT_UINT32 , BASE_DEC , NULL , 0x08000000 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_tft_sr_id , {
"SR_ID" , "rsvp.3gpp_obj.tft_sr_id" , FT_UINT32 , BASE_DEC , NULL , 0x07000000 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_tft_p , {
"Persistency(P)" , "rsvp.3gpp_obj.tft_p" , FT_UINT32 , BASE_DEC , NULL , 0x00010000 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_tft_opcode , {
"TFT Operation Code" , "rsvp.3gpp_obj.tft_opcode" , FT_UINT32 , BASE_DEC , VALS ( rsvp_3gpp_obj_tft_opcode_vals ) , 0x000ff00 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_tft_n_pkt_flt , {
"Number of Packet filters" , "rsvp.3gpp_obj.tft_n_pkt_flt" , FT_UINT32 , BASE_DEC , NULL , 0x00000ff , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_flow_id , {
"Flow Identifier" , "rsvp.3gpp_obj.flow_id" , FT_UINT8 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_pf_ev_prec , {
"Packet filter evaluation precedence" , "rsvp.3gpp_obj.pf_ev_prec" , FT_UINT8 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_pf_len , {
"Packet filter length" , "rsvp.3gpp_obj.pf_len" , FT_UINT16 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_pf_type , {
"PF Type" , "rsvp.3gpp_obj.pf_type" , FT_UINT8 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_pf_cont_len , {
"Length" , "rsvp.3gpp_obj.pf_cont_len" , FT_UINT8 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_pf_comp_type_id , {
"PF component identifier" , "rsvp.3gpp_obj.pf_comp_type_id" , FT_UINT8 , BASE_DEC , VALS ( rsvp_3gpp_obj_pf_comp_type_id_vals ) , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_pf_src_ipv4 , {
"IPv4 Source Address" , "rsvp.3gpp_obj.pf_src_ipv4" , FT_IPv4 , BASE_NONE , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_pf_dst_ipv4 , {
"IPv4 Destination Address" , "rsvp.3gpp_obj.pf_dst_ipv4" , FT_IPv4 , BASE_NONE , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_pf_ipv4_mask , {
"IPv4 Mask" , "rsvp.3gpp_obj.pf_ipv4_mask" , FT_UINT32 , BASE_HEX , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_pf_src_ipv6 , {
"IPv6 Source Address" , "rsvp.3gpp_obj.pf_src_ipv6" , FT_IPv6 , BASE_NONE , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_pf_dst_ipv6 , {
"IPv6 Destination Address" , "rsvp.3gpp_obj.pf_dst_ipv6" , FT_IPv6 , BASE_NONE , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_pf_ipv6_prefix_length , {
"IPv6 Prefix length" , "rsvp.3gpp_obj.pf_ipv6_prefix_length" , FT_UINT8 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_pf_prot_next , {
"Protocol field(IPv4) or Next Header(IPv6)" , "rsvp.3gpp_obj.pf_prot_next" , FT_UINT8 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_pf_dst_port , {
"Single Destination Port" , "rsvp.3gpp_obj.pf_dst_port" , FT_UINT16 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_pf_src_port , {
"Single Source Port" , "rsvp.3gpp_obj.pf_src_port" , FT_UINT16 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_pf_ipsec_spi , {
"IPsec SPI" , "rsvp.3gpp_obj.pf_ipsec_spi" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_pf_tos_tc , {
"Type of Service (IPv4)/Traffic Class (IPv6)" , "rsvp.3gpp_obj.pf_tos_tc" , FT_UINT8 , BASE_HEX , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_pf_flow_lbl , {
"Flow label" , "rsvp.3gpp_obj.pf_flow_lbl" , FT_UINT24 , BASE_DEC , NULL , 0x0fffff , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_pf_ipv6 , {
"IPv6 Address" , "rsvp.3gpp_obj.pf_ipv6" , FT_IPv6 , BASE_NONE , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_pf_treatment , {
"PF Treatment" , "rsvp.3gpp_obj.pf_treatment" , FT_UINT8 , BASE_DEC , VALS ( rsvp_3gpp_obj_pf_treatment_vals ) , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_pf_hint , {
"PF Hint" , "rsvp.3gpp_obj.pf_hint" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_tft_qos_list_len , {
"QoS List Length" , "rsvp.3gpp_obj.qos_list_len" , FT_UINT16 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_r_qos_blob_len , {
"R_QOS_SUB_BLOB_LEN" , "rsvp.3gpp_obj.r_qos_blob_len" , FT_UINT8 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_r_qos_blob_flow_pri , {
"FLOW_PRIORITY" , "rsvp.3gpp_obj.r_qos_blob.flow_pri" , FT_UINT8 , BASE_DEC , NULL , 0xf0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_r_qos_blob_num_qos_att_set , {
"NUM_QoS_ATTRIBUTE_SETS" , "rsvp.3gpp_obj.r_qos_blob.num_qos_att_set" , FT_UINT8 , BASE_DEC , NULL , 0x0e , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_qos_att_set_len , {
"QoS_ATTRIBUTE_SET_LEN" , "rsvp.3gpp_obj.r_qos_blob.qos_att_set_len" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_qos_attribute_set_id , {
"QoS_ATTRIBUTE_SET_ID" , "rsvp.3gpp_obj.r_qos_blob.qos_attribute_set_id" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_qos_attribute_verbose , {
"VERBOSE" , "rsvp.3gpp_obj.r_qos_blob.verbose" , FT_BOOLEAN , 8 , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_qos_attribute_prof_id , {
"ProfileID" , "rsvp.3gpp_obj.r_qos_blob.prof_id" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_qos_attribute_traff_cls , {
"Traffic_Class" , "rsvp.3gpp_obj.r_qos_blob.traff_cls" , FT_UINT8 , BASE_DEC , VALS ( rsvp_3gpp_obj_traffic_class_vals ) , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_qos_attribute_peak_rate , {
"Peak_Rate" , "rsvp.3gpp_obj.r_qos_blob.peak_rate" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_qos_attribute_bucket_size , {
"Bucket_Size" , "rsvp.3gpp_obj.r_qos_blob.bucket_size" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_qos_attribute_token_rate , {
"Token_Rate" , "rsvp.3gpp_obj.r_qos_blob.token_rate" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_qos_attribute_max_latency , {
"Max_Latency" , "rsvp.3gpp_obj.r_qos_blob.max_latency" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_qos_attribute_max_loss_rte , {
"Max_Loss_Rate" , "rsvp.3gpp_obj.r_qos_blob.max_loss_rte" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_qos_attribute_delay_var_sensitive , {
"Delay_Var_Sensitive" , "rsvp.3gpp_obj.r_qos_blob.delay_var_sensitive" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_qos_attribute_reserved , {
"Reserved" , "rsvp.3gpp_obj.r_qos_blob.reserved" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_r_qos_blob , {
"R_QOS_SUB_BLOB" , "rsvp.3gpp_obj.r_qos_blob" , FT_BYTES , BASE_NONE , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_qos_result , {
"Result Code" , "rsvp.3gpp_obj.qos_result_code" , FT_UINT8 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_xro_sobj_lbit , {
"L(oose) bit" , "rsvp.xro.sobj.lbit" , FT_UINT8 , BASE_DEC , VALS ( rsvp_xro_sobj_lbit_vals ) , 0x80 , NULL , HFILL }
}
, {
& hf_rsvp_xro_sobj_type , {
"Type" , "rsvp.xro.sobj.type" , FT_UINT8 , BASE_DEC , VALS ( rsvp_xro_sobj_type_vals ) , 0 , NULL , HFILL }
}
, {
& hf_rsvp_xro_sobj_len , {
"Length" , "rsvp.xro.sobj.len" , FT_UINT8 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_xro_sobj_ipv4_addr , {
"IPv4 prefix" , "rsvp.xro.sobj.ipv4.addr" , FT_IPv4 , BASE_NONE , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_xro_sobj_ipv4_prefix , {
"Prefix Length" , "rsvp.xro.sobj.ipv4.prefix" , FT_UINT8 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_xro_sobj_ipv4_attr , {
"Attribute" , "rsvp.xro.sobj.ipv4.attr" , FT_UINT8 , BASE_DEC , VALS ( rsvp_xro_sobj_ip_attr_vals ) , 0 , NULL , HFILL }
}
, {
& hf_rsvp_xro_sobj_ipv6_addr , {
"IPv6 prefix" , "rsvp.xro.sobj.ipv6.addr" , FT_IPv6 , BASE_NONE , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_xro_sobj_ipv6_prefix , {
"Prefix Length" , "rsvp.xro.sobj.ipv6.prefix" , FT_UINT8 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_xro_sobj_ipv6_attr , {
"Attribute" , "rsvp.xro.sobj.ipv6.attr" , FT_UINT8 , BASE_DEC , VALS ( rsvp_xro_sobj_ip_attr_vals ) , 0 , NULL , HFILL }
}
, {
& hf_rsvp_xro_sobj_srlg_id , {
"SRLG Id" , "rsvp.xro.sobj.srlg.id" , FT_UINT32 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_xro_sobj_srlg_res , {
"Reserved" , "rsvp.xro.sobj.srlg.res" , FT_UINT16 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_private_data , {
"Data" , "rsvp.private.data" , FT_BYTES , BASE_NONE , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_juniper_numtlvs , {
"Num TLVs" , "rsvp.juniper.tlvs" , FT_UINT16 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_juniper_padlength , {
"Padlength" , "rsvp.juniper.padlength" , FT_UINT16 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_juniper_type , {
"Juniper type" , "rsvp.juniper.type" , FT_UINT8 , BASE_HEX , VALS ( rsvp_juniper_attr_vals ) , 0 , NULL , HFILL }
}
, {
& hf_rsvp_juniper_length , {
"Juniper length" , "rsvp.juniper.length" , FT_UINT8 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_juniper_attrib_cos , {
"Cos" , "rsvp.juniper.attrib.cos" , FT_UINT16 , BASE_HEX , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_juniper_attrib_metric1 , {
"Metric 1" , "rsvp.juniper.attrib.metric1" , FT_UINT16 , BASE_HEX , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_juniper_attrib_metric2 , {
"Metric 2" , "rsvp.juniper.attrib.metric2" , FT_UINT16 , BASE_HEX , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_juniper_attrib_ccc_status , {
"CCC Status" , "rsvp.juniper.attrib.ccc_status" , FT_UINT16 , BASE_HEX , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_juniper_attrib_path , {
"Path type" , "rsvp.juniper.attrib.path" , FT_UINT16 , BASE_HEX , VALS ( rsvp_juniper_path_attr_vals ) , 0 , NULL , HFILL }
}
, {
& hf_rsvp_juniper_attrib_unknown , {
"Unknown" , "rsvp.juniper.attrib.unknown" , FT_BYTES , BASE_NONE , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_juniper_pad , {
"Pad" , "rsvp.juniper.pad" , FT_BYTES , BASE_NONE , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_juniper_unknown , {
"Unknown" , "rsvp.juniper.unknown" , FT_BYTES , BASE_NONE , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_unknown_data , {
"Data" , "rsvp.unknown.data" , FT_BYTES , BASE_NONE , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_loose_hop , {
"Hop" , "rsvp.loose_hop" , FT_BOOLEAN , 8 , TFS ( & tfs_loose_strict_hop ) , 0x80 , NULL , HFILL }
}
, {
& hf_rsvp_data_length , {
"Data length" , "rsvp.data_length" , FT_UINT16 , BASE_DEC , NULL , 0 , NULL , HFILL }
}
, {
& hf_rsvp_session_flags , {
"Flags" , "rsvp.session.flags" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_session_destination_address , {
"Destination address" , "rsvp.session.destination_address" , FT_IPv6 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_session_protocol , {
"Protocol" , "rsvp.session.protocol" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_session_destination_port , {
"Destination port" , "rsvp.session.destination_port" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_session_dscp , {
"DSCP" , "rsvp.session.dscp" , FT_UINT8 , BASE_DEC | BASE_EXT_STRING , & dscp_vals_ext , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_session_extended_ipv4_address , {
"Extended IPv4 Address" , "rsvp.session.extended_ipv4_address" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_session_data , {
"Data" , "rsvp.session.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ifid_tlv_length , {
"Length" , "rsvp.ifid_tlv.length" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ifid_tlv_ipv4_address , {
"IPv4 address" , "rsvp.ifid_tlv.ipv4_address" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ifid_tlv_ipv6_address , {
"IPv6 address" , "rsvp.ifid_tlv.ipv6_address" , FT_IPv6 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ifid_tlvinterface_id , {
"Interface-ID" , "rsvp.ifid_tlv.interface_id" , FT_UINT32 , BASE_DEC_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ifid_tlv_label , {
"Label" , "rsvp.ifid_tlv.label" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ifid_tlv_node_id , {
"Node ID" , "rsvp.ifid_tlv.node_id" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ifid_tlv_area , {
"Area" , "rsvp.ifid_tlv.area" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ifid_tlv_autonomous_system , {
"Autonomous System" , "rsvp.ifid_tlv.autonomous_system" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ifid_tlv_error_string , {
"Error String" , "rsvp.ifid_tlv.error_string" , FT_STRING , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ifid_tlv_data , {
"Data" , "rsvp.ifid_tlv.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ifid_tlv_padding , {
"Padding" , "rsvp.ifid_tlv.padding" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_hop_neighbor_address_ipv4 , {
"Neighbor address" , "rsvp.hop.neighbor_address_ipv4" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_hop_logical_interface , {
"Logical interface" , "rsvp.hop.logical_interface" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_hop_neighbor_address_ipv6 , {
"Neighbor address" , "rsvp.neighbor_address_ipv6" , FT_IPv6 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_hop_data , {
"Data" , "rsvp.hop.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_time_values_data , {
"Data" , "rsvp.time_values.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_error_error_node_ipv4 , {
"Error node" , "rsvp.error.error_node_ipv4" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_error_error_node_ipv6 , {
"Error node" , "rsvp.error.error_node_ipv6" , FT_IPv6 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_error_data , {
"Data" , "rsvp.error.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_error_error_code , {
"Error code" , "rsvp.error.error_code" , FT_UINT8 , BASE_DEC | BASE_EXT_STRING , & rsvp_error_codes_ext , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_scope_ipv4_address , {
"IPv4 Address" , "rsvp.scope.ipv4_address" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_scope_ipv6_address , {
"IPv6 Address" , "rsvp.scope.ipv6_address" , FT_IPv6 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_scope_data , {
"Data" , "rsvp.scope.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_style_flags , {
"Flags" , "rsvp.style.flags" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_style_style , {
"Style" , "rsvp.style.style" , FT_UINT24 , BASE_HEX , VALS ( style_vals ) , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_style_data , {
"Data" , "rsvp.style.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_confirm_receiver_address_ipv4 , {
"Receiver address" , "rsvp.confirm.receiver_address_ipv4" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_confirm_receiver_address_ipv6 , {
"Receiver address" , "rsvp.confirm.receiver_address_ipv6" , FT_IPv6 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_confirm_data , {
"Data" , "rsvp.confirm.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_template_filter_source_address_ipv6 , {
"Source address" , "rsvp.template_filter.source_address_ipv6" , FT_IPv6 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_template_filter_source_port , {
"Source port" , "rsvp.template_filter.source_port" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_template_filter_data , {
"Data" , "rsvp.template_filter.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_eth_tspec_length , {
"Length" , "rsvp.eth_tspec.length" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_eth_tspec_profile , {
"Profile" , "rsvp.eth_tspec.profile" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_eth_tspec_index , {
"Index" , "rsvp.eth_tspec.index" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_eth_tspec_reserved , {
"Reserved" , "rsvp.eth_tspec.reserved" , FT_UINT16 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_eth_tspec_el2cp , {
"EL2CP" , "rsvp.eth_tspec.el2cp" , FT_UINT8 , BASE_DEC , VALS ( el2cp_val_str ) , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_eth_tspec_il2cp , {
"IL2CP" , "rsvp.eth_tspec.il2cp" , FT_UINT8 , BASE_DEC , VALS ( il2cp_val_str ) , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_eth_tspec_cir , {
"CIR" , "rsvp.eth_tspec.cir" , FT_FLOAT , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_eth_tspec_cbs , {
"CBS" , "rsvp.eth_tspec.cbs" , FT_FLOAT , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_eth_tspec_eir , {
"EIR" , "rsvp.eth_tspec.eir" , FT_FLOAT , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_eth_tspec_ebs , {
"EBS" , "rsvp.eth_tspec.ebs" , FT_FLOAT , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_tspec_message_format_version , {
"Message format version" , "rsvp.tspec.message_format_version" , FT_UINT8 , BASE_DEC , NULL , 0xF0 , NULL , HFILL }
}
, {
& hf_rsvp_tspec_service_header , {
"Service header" , "rsvp.tspec.service_header" , FT_UINT8 , BASE_DEC , VALS ( qos_vals ) , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_tspec_token_bucket_rate , {
"Token bucket rate" , "rsvp.tspec.token_bucket_rate" , FT_FLOAT , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_tspec_token_bucket_size , {
"Token bucket size" , "rsvp.tspec.token_bucket_size" , FT_FLOAT , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_tspec_peak_data_rate , {
"Peak data rate" , "rsvp.tspec.peak_data_rate" , FT_FLOAT , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_tspec_hint , {
"Hint" , "rsvp.tspec.hint" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_compression_factor , {
"Compression Factor" , "rsvp.tspec.compression_factor" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_tspec_signal_type_sonet , {
"Signal Type" , "rsvp.tspec.signal_type" , FT_UINT8 , BASE_DEC | BASE_EXT_STRING , & gmpls_sonet_signal_type_str_ext , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_tspec_requested_concatenation , {
"Requested Concatenation (RCC)" , "rsvp.tspec.requested_concatenation" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_tspec_number_of_contiguous_components , {
"Number of Contiguous Components (NCC)" , "rsvp.tspec.number_of_contiguous_components" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_tspec_number_of_virtual_components , {
"Number of Virtual Components (NVC)" , "rsvp.tspec.number_of_virtual_components" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_tspec_multiplier , {
"Multiplier (MT)" , "rsvp.tspec.multiplier" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_tspec_transparency , {
"Transparency (T)" , "rsvp.tspec.transparency" , FT_UINT32 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_tspec_profile , {
"Profile (P)" , "rsvp.tspec.profile" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_tspec_signal_type_g709 , {
"Signal Type" , "rsvp.tspec.signal_type" , FT_UINT8 , BASE_DEC | BASE_RANGE_STRING , RVALS ( gmpls_g709_signal_type_rvals ) , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_tspec_number_of_multiplexed_components , {
"Number of Multiplexed Components (NMC)" , "rsvp.number_of_multiplexed_components" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_tspec_mtu , {
"MTU" , "rsvp.tspec.mtu" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_tspec_data , {
"Data" , "rsvp.tspec.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_message_format_version , {
"Message format version" , "rsvp.flowspec.message_format_version" , FT_UINT8 , BASE_DEC , NULL , 0xF0 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_service_header , {
"Service header" , "rsvp.flowspec.service_header" , FT_UINT8 , BASE_DEC | BASE_EXT_STRING , & intsrv_services_str_ext , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_token_bucket_rate , {
"Token bucket rate" , "rsvp.flowspec.token_bucket_rate" , FT_FLOAT , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_token_bucket_size , {
"Token bucket size" , "rsvp.flowspec.token_bucket_size" , FT_FLOAT , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_peak_data_rate , {
"Peak data rate" , "rsvp.flowspec.peak_data_rate" , FT_FLOAT , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_rate , {
"Rate" , "rsvp.flowspec.rate" , FT_FLOAT , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_slack_term , {
"Slack term" , "rsvp.flowspec.slack_term" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_signal_type_sonet , {
"Signal Type" , "rsvp.flowspec.signal_type" , FT_UINT8 , BASE_DEC | BASE_EXT_STRING , & gmpls_sonet_signal_type_str_ext , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_requested_concatenation , {
"Requested Concatenation (RCC)" , "rsvp.flowspec.requested_concatenation" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_number_of_contiguous_components , {
"Number of Contiguous Components (NCC)" , "rsvp.flowspec.number_of_contiguous_components" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_number_of_virtual_components , {
"Number of Virtual Components (NVC)" , "rsvp.flowspec.number_of_virtual_components" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_multiplier , {
"Multiplier (MT)" , "rsvp.flowspec.multiplier" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_transparency , {
"Transparency (T)" , "rsvp.flowspec.transparency" , FT_UINT32 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_profile , {
"Profile (P)" , "rsvp.flowspec.profile" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_signal_type_g709 , {
"Signal Type" , "rsvp.flowspec.signal_type" , FT_UINT8 , BASE_DEC | BASE_RANGE_STRING , RVALS ( gmpls_g709_signal_type_rvals ) , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_number_of_multiplexed_components , {
"Number of Multiplexed Components (NMC)" , "rsvp.flowspec.number_of_multiplexed_components" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_flowspec_mtu , {
"MTU" , "rsvp.flowspec.mtu" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_adspec_message_format_version , {
"Message format version" , "rsvp.adspec.message_format_version" , FT_UINT8 , BASE_DEC , NULL , 0xF0 , NULL , HFILL }
}
, {
& hf_rsvp_adspec_service_header , {
"Service header" , "rsvp.adspec.service_header" , FT_UINT8 , BASE_DEC | BASE_EXT_STRING , & intsrv_services_str_ext , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_integrity_flags , {
"Flags" , "rsvp.integrity.flags" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_integrity_key_identifier , {
"Key Identifier" , "rsvp.integrity.key_identifier" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_integrity_sequence_number , {
"Sequence Number" , "rsvp.integrity.sequence_number" , FT_UINT64 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_integrity_hash , {
"Hash" , "rsvp.integrity.hash" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_policy_data , {
"Data" , "rsvp.policy.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_label_request_l3pid , {
"L3PID" , "rsvp.label_request.l3pid" , FT_UINT16 , BASE_HEX , VALS ( etype_vals ) , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_label_request_min_vpi , {
"Min VPI" , "rsvp.label_request.min_vpi" , FT_UINT16 , BASE_DEC , NULL , 0x7f , NULL , HFILL }
}
, {
& hf_rsvp_label_request_min_vci , {
"Min VCI" , "rsvp.label_request.min_vci" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_label_request_max_vpi , {
"Max VPI" , "rsvp.label_request.max_vpi" , FT_UINT16 , BASE_DEC , NULL , 0x7f , NULL , HFILL }
}
, {
& hf_rsvp_label_request_max_vci , {
"Max VCI" , "rsvp.label_request.max_vci" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_label_request_lsp_encoding_type , {
"LSP Encoding Type" , "rsvp.label_request.lsp_encoding_type" , FT_UINT8 , BASE_DEC | BASE_RANGE_STRING , RVALS ( gmpls_lsp_enc_rvals ) , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_label_request_switching_type , {
"Switching Type" , "rsvp.label_request.switching_type" , FT_UINT8 , BASE_DEC | BASE_RANGE_STRING , RVALS ( gmpls_switching_type_rvals ) , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_g_pid , {
"G-PID" , "rsvp.label_request.g_pid" , FT_UINT16 , BASE_HEX | BASE_RANGE_STRING , RVALS ( gmpls_gpid_rvals ) , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_label_request_data , {
"Data" , "rsvp.label_request.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_label_label , {
"Label" , "rsvp.label.label" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_label_generalized_label , {
"Generalized Label" , "rsvp.label.generalized_label" , FT_UINT32 , BASE_DEC_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_label_generalized_label_evpl_vlad_id , {
"VLAN ID" , "rsvp.label.generalized_label_evpl_vlad_id" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_label_data , {
"Data" , "rsvp.label.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_label_set_action , {
"Action" , "rsvp.label_set.action" , FT_UINT8 , BASE_DEC , VALS ( action_type_vals ) , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_session_attribute_exclude_any , {
"Exclude-Any" , "rsvp.session_attribute.exclude_any" , FT_UINT32 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_session_attribute_include_any , {
"Include-Any" , "rsvp.session_attribute.include_any" , FT_UINT32 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_session_attribute_include_all , {
"Include-All" , "rsvp.session_attribute.include_all" , FT_UINT32 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_session_attribute_setup_priority , {
"Setup priority" , "rsvp.session_attribute.setup_priority" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_session_attribute_hold_priority , {
"Hold priority" , "rsvp.session_attribute.hold_priority" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_session_attribute_flags , {
"Flags" , "rsvp.session_attribute.flags" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_session_attribute_name_length , {
"Name length" , "rsvp.session_attribute.name_length" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_session_attribute_name , {
"Name" , "rsvp.session_attribute.name" , FT_STRING , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_session_attribute_data , {
"Data" , "rsvp.session_attribute.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ero_rro_subobjects_length , {
"Length" , "rsvp.ero_rro_subobjects.length" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ero_rro_subobjects_ipv4_hop , {
"IPv4 hop" , "rsvp.ero_rro_subobjects.ipv4_hop" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ero_rro_subobjects_prefix_length , {
"Prefix length" , "rsvp.ero_rro_subobjects.prefix_length" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ero_rro_subobjects_flags , {
"Flags" , "rsvp.ero_rro_subobjects.flags" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ero_rro_subobjects_ipv6_hop , {
"IPv6 hop" , "rsvp.ero_rro_subobjects.ipv6_hop" , FT_IPv6 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ero_rro_subobjects_label , {
"Label" , "rsvp.ero_rro_subobjects.label" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ero_rro_subobjects_router_id , {
"Router-ID" , "rsvp.ero_rro_subobjects.router_id" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ero_rro_subobjects_interface_id , {
"Interface-ID" , "rsvp.ero_rro_subobjects.interface_id" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ero_rro_subobjects_path_key , {
"Path Key" , "rsvp.ero_rro_subobjects.path_key" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ero_rro_subobjects_pce_id_ipv4 , {
"PCE-ID" , "rsvp.ero_rro_subobjects.pce_id_ipv4" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ero_rro_subobjects_pce_id_ipv6 , {
"PCE-ID" , "rsvp.ero_rro_subobjects.pce_id_ipv6" , FT_IPv6 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ero_rro_subobjects_private_length , {
"Length" , "rsvp.ero_rro_subobjects.private_length" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ero_rro_subobjects_private_data , {
"Data" , "rsvp.ero_rro_subobjects.private_data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_explicit_route_data , {
"Data" , "rsvp.explicit_route.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_record_route_data , {
"Data" , "rsvp.record_route.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_exclude_route_data , {
"Data" , "rsvp.exclude_route.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_message_id_flags , {
"Flags" , "rsvp.message_id.flags" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_message_id_epoch , {
"Epoch" , "rsvp.message_id.epoch" , FT_UINT24 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_message_id_message_id , {
"Message-ID" , "rsvp.message_id.message_id" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_message_id_data , {
"Data" , "rsvp.message_id.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_message_id_ack_flags , {
"Flags" , "rsvp.message_id_ack.flags" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_message_id_ack_epoch , {
"Epoch" , "rsvp.message_id_ack.epoch" , FT_UINT24 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_message_id_ack_message_id , {
"Message-ID" , "rsvp.message_id_ack.message_id" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_message_id_ack_data , {
"Data" , "rsvp.message_id_ack.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_message_id_list_flags , {
"Flags" , "rsvp.message_id_list.flags" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_message_id_list_epoch , {
"Epoch" , "rsvp.message_id_list.epoch" , FT_UINT24 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_message_id_list_message_id , {
"Message-ID" , "rsvp.message_id_list.message_id" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_message_id_list_data , {
"Data" , "rsvp.message_id_list.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_hello_source_instance , {
"Source Instance" , "rsvp.hello.source_instance" , FT_UINT32 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_hello_destination_instance , {
"Destination Instance" , "rsvp.hello.destination_instance" , FT_UINT32 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_dclass_dscp , {
"DSCP" , "rsvp.dclass.dscp" , FT_UINT8 , BASE_DEC | BASE_EXT_STRING , & dscp_vals_ext , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_dclass_data , {
"Data" , "rsvp.dclass.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_admin_status_bits , {
"Admin Status" , "rsvp.admin_status.bits" , FT_UINT32 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_admin_status_data , {
"Data" , "rsvp.admin_status.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_attributes_tlv , {
"LSP attributes TLV" , "rsvp.lsp_attributes_tlv" , FT_UINT32 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_attributes_tlv_data , {
"Data" , "rsvp.lsp_attributes_tlv.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_association_type , {
"Association type" , "rsvp.association.type" , FT_UINT16 , BASE_DEC , VALS ( association_type_vals ) , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_association_id , {
"Association ID" , "rsvp.association.id" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_association_source_ipv4 , {
"Association source" , "rsvp.association.source_ipv4" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_association_source_ipv6 , {
"Association source" , "rsvp.association.source_ipv6" , FT_IPv6 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_association_routing_area_id , {
"Routing Area ID" , "rsvp.association.routing_area_id" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_association_node_id , {
"Node ID" , "rsvp.association.node_id" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_association_padding , {
"Padding" , "rsvp.association.padding" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_association_data , {
"Data" , "rsvp.association.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_tunnel_if_id_length , {
"Length" , "rsvp.lsp_tunnel_if_id.length" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_tunnel_if_id_component_link_identifier , {
"Component link identifier" , "rsvp.lsp_tunnel_if_id.component_link_identifier" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_tunnel_if_id_component_link_identifier_ipv4 , {
"Component link identifier" , "rsvp.lsp_tunnel_if_id.component_link_identifier_ipv4" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_tunnel_if_id_lsp_encoding_type , {
"LSP Encoding Type" , "rsvp.lsp_tunnel_if_id.lsp_encoding_type" , FT_UINT8 , BASE_DEC | BASE_RANGE_STRING , RVALS ( gmpls_lsp_enc_rvals ) , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_tunnel_if_id_switching_type , {
"Switching Type" , "rsvp.lsp_tunnel_if_id.switching_type" , FT_UINT8 , BASE_DEC | BASE_RANGE_STRING , RVALS ( gmpls_switching_type_rvals ) , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_tunnel_if_id_signal_type , {
"Signal Type" , "rsvp.lsp_tunnel_if_id.signal_type" , FT_UINT8 , BASE_DEC | BASE_EXT_STRING , & gmpls_sonet_signal_type_str_ext , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_tunnel_if_id_connection_id , {
"Sub Interface/Connection ID" , "rsvp.lsp_tunnel_if_id.connection_id" , FT_UINT64 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_tunnel_if_id_sc_pc_id , {
"SC PC ID" , "rsvp.lsp_tunnel_if_id.sc_pc_id" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_tunnel_if_id_sc_pc_scn_address , {
"SC PC SCN Address" , "rsvp.lsp_tunnel_if_id.sc_pc_scn_address" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_tunnel_if_id_router_id , {
"Router ID" , "rsvp.lsp_tunnel_if_id.router_id" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_tunnel_if_id_interface_id , {
"Interface ID" , "rsvp.lsp_tunnel_if_id.interface_id" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_tunnel_if_id_ipv4_interface_address , {
"IPv4 interface address" , "rsvp.lsp_tunnel_if_id.ipv4_interface_address" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_tunnel_if_id_target_igp_instance , {
"Target IGP instance" , "rsvp.lsp_tunnel_if_id.target_igp_instance" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_tunnel_if_id_action , {
"Action" , "rsvp.lsp_tunnel_if_id.action" , FT_UINT8 , BASE_DEC , VALS ( lsp_tunnel_if_id_action_str ) , 0xF0 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_tunnel_if_id_ipv6_interface_address , {
"IPv6 interface address" , "rsvp.lsp_tunnel_if_id.ipv6_interface_address" , FT_IPv6 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_lsp_tunnel_if_id_data , {
"Data" , "rsvp.lsp_tunnel_if_id.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_notify_request_notify_node_address_ipv4 , {
"Notify node address" , "rsvp.notify_request.notify_node_address_ipv4" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_notify_request_notify_node_address_ipv6 , {
"Notify node address" , "rsvp.notify_request.notify_node_address_ipv6" , FT_IPv6 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_notify_request_data , {
"Data" , "rsvp.notify_request.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_call_id_data , {
"Data" , "rsvp.call_id.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_call_id_address_type , {
"Address type" , "rsvp.call_id.address_type" , FT_UINT8 , BASE_DEC , VALS ( address_type_vals ) , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_call_id_reserved , {
"Reserved" , "rsvp.call_id.reserved" , FT_UINT24 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_call_id_international_segment , {
"International Segment" , "rsvp.call_id.international_segment" , FT_STRING , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_call_id_national_segment , {
"National Segment" , "rsvp.call_id.national_segment" , FT_STRING , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_call_id_local_identifier , {
"Local Identifier" , "rsvp.call_id.local_identifier" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_restart_cap_data , {
"Data" , "rsvp.restart_cap.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_protection_info_link_flags , {
"Link Flags" , "rsvp.protection_info.link_flags" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_protection_info_data , {
"Data" , "rsvp.protection_info.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_fast_reroute_setup_priority , {
"Setup Priority" , "rsvp.fast_reroute.setup_priority" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_fast_reroute_hold_priority , {
"Hold Priority" , "rsvp.fast_reroute.hold_priority" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_fast_reroute_hop_limit , {
"Hop Limit" , "rsvp.fast_reroute.hop_limit" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_fast_reroute_flags , {
"Flags" , "rsvp.fast_reroute.flags" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_fast_reroute_bandwidth , {
"Bandwidth" , "rsvp.fast_reroute.bandwidth" , FT_FLOAT , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_fast_reroute_include_any , {
"Include-Any" , "rsvp.fast_reroute.include_any" , FT_UINT32 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_fast_reroute_exclude_any , {
"Exclude-Any" , "rsvp.fast_reroute.exclude_any" , FT_UINT32 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_fast_reroute_include_all , {
"Include-All" , "rsvp.fast_reroute.include_all" , FT_UINT32 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_fast_reroute_data , {
"Data" , "rsvp.fast_reroute.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_detour_data , {
"Data" , "rsvp.detour.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_diffserv_data , {
"Data" , "rsvp.diffserv.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_diffserv_aware_te_data , {
"Data" , "rsvp.diffserv_aware_te.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_version , {
"RSVP Version" , "rsvp.version" , FT_UINT8 , BASE_DEC , NULL , 0xF0 , NULL , HFILL }
}
, {
& hf_rsvp_flags , {
"Flags" , "rsvp.flags" , FT_UINT8 , BASE_HEX , NULL , 0x0F , NULL , HFILL }
}
, {
& hf_rsvp_sending_ttl , {
"Sending TTL" , "rsvp.sending_ttl" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_message_length , {
"Message length" , "rsvp.message_length" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_length , {
"Length" , "rsvp.length" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_extended_tunnel_id , {
"Extended Tunnel ID" , "rsvp.extended_tunnel_id" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_extended_tunnel_ipv6 , {
"Extended Tunnel ID" , "rsvp.extended_tunnel_id_ipv6" , FT_IPv6 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_extended_tunnel , {
"Extended Tunnel" , "rsvp.extended_tunnel" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_refresh_interval , {
"Refresh interval" , "rsvp.refresh_interval" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_minimum_policed_unit , {
"Minimum policed unit [m]" , "rsvp.minimum_policed_unit" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_maximum_packet_size , {
"Maximum packet size [M]" , "rsvp.maximum_packet_size" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_hf_rsvp_adspec_break_bit , {
"Break bit" , "rsvp.adspec.break_bit" , FT_BOOLEAN , 8 , TFS ( & tfs_set_notset ) , 0x80 , NULL , HFILL }
}
, {
& hf_rsvp_label_request_m , {
"M (Merge in Data Plane)" , "rsvp.label_request.m" , FT_BOOLEAN , 8 , TFS ( & tfs_can_cannot ) , 0x80 , NULL , HFILL }
}
, {
& hf_rsvp_dlci_length , {
"DLCI Length" , "rsvp.label_request.dlci_length" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_min_dlci , {
"Min DLCI" , "rsvp.label_request.min_dlci" , FT_UINT24 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_max_dlci , {
"Max DLCI" , "rsvp.label_request.max_dlci" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ero_rro_autonomous_system , {
"Autonomous System" , "rsvp.ero_rro_subobjects.autonomous_system" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_nsap_length , {
"NSAP Length" , "rsvp.nsap_length" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_gen_uni_data , {
"Data" , "rsvp.gen_uni.data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_gen_uni_logical_port_id , {
"Logical Port ID" , "rsvp.gen_uni.logical_port_id" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_gen_uni_service_level , {
"Service Level" , "rsvp.gen_uni.service_level" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_restart_cap_restart_time , {
"Restart Time" , "rsvp.restart_cap.restart_time" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_restart_cap_recovery_time , {
"Recovery Time" , "rsvp.restart_cap.recovery_time" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_detour_plr_id , {
"PLR ID" , "rsvp.detour.plr_id" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_detour_avoid_node_id , {
"Avoid Node ID" , "rsvp.detour.avoid_node_id" , FT_IPv4 , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_message_checksum , {
"Message Checksum" , "rsvp.message_checksum" , FT_UINT16 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_call_attributes_endpont_id , {
"Endpoint ID" , "rsvp.call_attributes.endpoint_id" , FT_STRING , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_isis_area_id , {
"IS-IS Area Identifier" , "rsvp.isis_area_id" , FT_STRING , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_adspec_type , {
"Adspec Type" , "rsvp.adspec.type" , FT_UINT8 , BASE_DEC | BASE_EXT_STRING , & adspec_params_ext , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_adspec_len , {
"Length" , "rsvp.adspec.len" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_adspec_uint , {
"Adspec uint" , "rsvp.adspec.uint" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_adspec_float , {
"Adspec float" , "rsvp.adspec.float" , FT_FLOAT , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_adspec_bytes , {
"Adspec bytes" , "rsvp.adspec.bytes" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_wavelength_freq , {
"Freq" , "rsvp.wavelength.freq" , FT_FLOAT , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_wavelength_grid , {
"Grid" , "rsvp.wavelength.grid" , FT_UINT8 , BASE_DEC , VALS ( lambda_grid_vals ) , 0xE0 , NULL , HFILL }
}
, {
& hf_rsvp_wavelength_channel_spacing , {
"Channel Spacing" , "rsvp.wavelength.channel_spacing" , FT_UINT8 , BASE_DEC , NULL , 0x1E , NULL , HFILL }
}
, {
& hf_rsvp_wavelength_n , {
"n" , "rsvp.wavelength.n" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_wavelength_wavelength , {
"Wavelength" , "rsvp.wavelength.wavelength" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_sonet_s , {
"S" , "rsvp.sonet.s" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_sonet_u , {
"U" , "rsvp.sonet.u" , FT_UINT8 , BASE_DEC , NULL , 0xF0 , NULL , HFILL }
}
, {
& hf_rsvp_sonet_k , {
"K" , "rsvp.sonet.k" , FT_UINT8 , BASE_DEC , NULL , 0x0F , NULL , HFILL }
}
, {
& hf_rsvp_sonet_l , {
"L" , "rsvp.sonet.l" , FT_UINT8 , BASE_DEC , NULL , 0xF0 , NULL , HFILL }
}
, {
& hf_rsvp_sonet_m , {
"M" , "rsvp.sonet.m" , FT_UINT8 , BASE_DEC , NULL , 0x0F , NULL , HFILL }
}
, {
& hf_rsvp_g709_t3 , {
"t3" , "rsvp.g709.t3" , FT_UINT16 , BASE_DEC , NULL , 0x03F0 , NULL , HFILL }
}
, {
& hf_rsvp_g709_t2 , {
"t2" , "rsvp.g709.t2" , FT_UINT8 , BASE_DEC , NULL , 0x0E , NULL , HFILL }
}
, {
& hf_rsvp_g709_t1 , {
"t1" , "rsvp.g709.t1" , FT_UINT8 , BASE_DEC , NULL , 0x01 , NULL , HFILL }
}
, {
& hf_rsvp_label_set_type , {
"Label type" , "rsvp.label_set.type" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_label_set_subchannel , {
"Subchannel" , "rsvp.label_set.subchannel" , FT_UINT32 , BASE_DEC_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_nsap_address , {
"NSAP address" , "rsvp.nsap_address" , FT_STRING , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_class_diversity , {
"Diversity" , "rsvp.class_diversity" , FT_UINT8 , BASE_DEC , VALS ( ouni_guni_diversity_str ) , 0xF0 , NULL , HFILL }
}
, {
& hf_rsvp_egress_label_type , {
"Label type" , "rsvp.egress.label_type" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_egress_label , {
"Label" , "rsvp.egress.label" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_source_transport_network_addr , {
"Source Transport Network addr" , "rsvp.source_transport_network_addr" , FT_STRING , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_ie_data , {
"IE Data" , "rsvp.ie_data" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_pf_dst_port_range , {
"Destination Port range" , "rsvp.3gpp_obj.pf_dst_port_range" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_rsvp_3gpp_obj_pf_src_port_range , {
"Source Port range" , "rsvp.3gpp_obj.pf_src_port_range" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, }
;
static ei_register_info ei [ ] = {
{
& ei_rsvp_invalid_length , {
"rsvp.invalid_length" , PI_MALFORMED , PI_ERROR , "Invalid length" , EXPFILL }
}
, {
& ei_rsvp_packet_filter_component , {
"rsvp.packet_filter_component" , PI_UNDECODED , PI_WARN , "Not dissected Packet filter component" , EXPFILL }
}
, {
& ei_rsvp_bundle_component_msg , {
"rsvp.bundle_component_msg" , PI_UNDECODED , PI_WARN , "Bundle Component Messages Not Dissected" , EXPFILL }
}
, {
& ei_rsvp_parameter , {
"rsvp.parameter.unknown" , PI_PROTOCOL , PI_WARN , "Unknown parameter" , EXPFILL }
}
, {
& ei_rsvp_adspec_type , {
"rsvp.adspec.type.unknown" , PI_PROTOCOL , PI_WARN , "Unknown type" , EXPFILL }
}
, {
& ei_rsvp_call_id_address_type , {
"rsvp.call_id.address_type.unknown" , PI_PROTOCOL , PI_WARN , "Unknown Transport Network type" , EXPFILL }
}
, {
& ei_rsvp_session_type , {
"rsvp.session_type.unknown" , PI_PROTOCOL , PI_WARN , "Unknown session type" , EXPFILL }
}
, }
;
expert_module_t * expert_rsvp ;
gint * ett_tree [ TT_MAX ] ;
for ( i = 0 ;
i < TT_MAX ;
i ++ ) {
ett_treelist [ i ] = - 1 ;
ett_tree [ i ] = & ( ett_treelist [ i ] ) ;
}
proto_rsvp = proto_register_protocol ( "Resource ReserVation Protocol (RSVP)" , "RSVP" , "rsvp" ) ;
proto_rsvp_e2e1 = proto_register_protocol ( "Resource ReserVation Protocol (RSVP-E2EI)" , "RSVP-E2EI" , "rsvp-e2ei" ) ;
proto_register_field_array ( proto_rsvp , rsvpf_info , array_length ( rsvpf_info ) ) ;
proto_register_subtree_array ( ett_tree , array_length ( ett_tree ) ) ;
expert_rsvp = expert_register_protocol ( proto_rsvp ) ;
expert_register_field_array ( expert_rsvp , ei , array_length ( ei ) ) ;
register_rsvp_prefs ( ) ;
register_init_routine ( & rsvp_init_protocol ) ;
register_cleanup_routine ( & rsvp_cleanup_protocol ) ;
register_conversation_table ( proto_rsvp , TRUE , rsvp_conversation_packet , rsvp_hostlist_packet ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
char * jas_image_fmttostr ( int fmt ) {
jas_image_fmtinfo_t * fmtinfo ;
if ( ! ( fmtinfo = jas_image_lookupfmtbyid ( fmt ) ) ) {
return 0 ;
}
return fmtinfo -> name ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline void set_indic_properties ( hb_glyph_info_t & info ) {
hb_codepoint_t u = info . codepoint ;
unsigned int type = hb_indic_get_categories ( u ) ;
indic_category_t cat = ( indic_category_t ) ( type & 0x7Fu ) ;
indic_position_t pos = ( indic_position_t ) ( type >> 8 ) ;
if ( unlikely ( hb_in_ranges ( u , 0x0951u , 0x0952u , 0x1CD0u , 0x1CD2u , 0x1CD4u , 0x1CE1u ) || u == 0x1CF4u ) ) cat = OT_A ;
else if ( unlikely ( hb_in_range ( u , 0x0953u , 0x0954u ) ) ) cat = OT_SM ;
else if ( unlikely ( hb_in_ranges ( u , 0x0A72u , 0x0A73u , 0x1CF5u , 0x1CF6u ) ) ) cat = OT_C ;
else if ( unlikely ( hb_in_range ( u , 0x1CE2u , 0x1CE8u ) ) ) cat = OT_A ;
else if ( unlikely ( u == 0x1CEDu ) ) cat = OT_A ;
else if ( unlikely ( hb_in_ranges ( u , 0xA8F2u , 0xA8F7u , 0x1CE9u , 0x1CECu , 0x1CEEu , 0x1CF1u ) ) ) {
cat = OT_Symbol ;
ASSERT_STATIC ( ( int ) INDIC_SYLLABIC_CATEGORY_AVAGRAHA == OT_Symbol ) ;
}
else if ( unlikely ( hb_in_range ( u , 0x17CDu , 0x17D1u ) || u == 0x17CBu || u == 0x17D3u || u == 0x17DDu ) ) {
cat = OT_M ;
pos = POS_ABOVE_C ;
}
else if ( unlikely ( u == 0x17C6u ) ) cat = OT_N ;
else if ( unlikely ( u == 0x17D2u ) ) cat = OT_Coeng ;
else if ( unlikely ( hb_in_range ( u , 0x2010u , 0x2011u ) ) ) cat = OT_PLACEHOLDER ;
else if ( unlikely ( u == 0x25CCu ) ) cat = OT_DOTTEDCIRCLE ;
else if ( unlikely ( u == 0xA982u ) ) cat = OT_SM ;
else if ( unlikely ( u == 0xA9BEu ) ) cat = OT_CM2 ;
else if ( unlikely ( u == 0xA9BDu ) ) {
cat = OT_M ;
pos = POS_POST_C ;
}
if ( ( FLAG_SAFE ( cat ) & CONSONANT_FLAGS ) ) {
pos = POS_BASE_C ;
if ( is_ra ( u ) ) cat = OT_Ra ;
}
else if ( cat == OT_M ) {
pos = matra_position ( u , pos ) ;
}
else if ( ( FLAG_SAFE ( cat ) & ( FLAG ( OT_SM ) | FLAG ( OT_VD ) | FLAG ( OT_A ) | FLAG ( OT_Symbol ) ) ) ) {
pos = POS_SMVD ;
}
if ( unlikely ( u == 0x0B01u ) ) pos = POS_BEFORE_SUB ;
info . indic_category ( ) = cat ;
info . indic_position ( ) = pos ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
rfbBool rfbSendFileTransferChunk ( rfbClientPtr cl ) {
unsigned char readBuf [ sz_rfbBlockSize ] ;
int bytesRead = 0 ;
int retval = 0 ;
fd_set wfds ;
struct timeval tv ;
int n ;
# ifdef LIBVNCSERVER_HAVE_LIBZ unsigned char compBuf [ sz_rfbBlockSize + 1024 ] ;
unsigned long nMaxCompSize = sizeof ( compBuf ) ;
int nRetC = 0 ;
# endif if ( cl -> screen -> permitFileTransfer != TRUE || ( cl -> screen -> getFileTransferPermission != NULL && cl -> screen -> getFileTransferPermission ( cl ) != TRUE ) ) {
return TRUE ;
}
if ( ( cl -> fileTransfer . fd != - 1 ) && ( cl -> fileTransfer . sending == 1 ) ) {
FD_ZERO ( & wfds ) ;
FD_SET ( cl -> sock , & wfds ) ;
tv . tv_sec = 0 ;
tv . tv_usec = 0 ;
n = select ( cl -> sock + 1 , NULL , & wfds , NULL , & tv ) ;
if ( n < 0 ) {
# ifdef WIN32 errno = WSAGetLastError ( ) ;
# endif rfbLog ( "rfbSendFileTransferChunk() select failed: %s\n" , strerror ( errno ) ) ;
}
if ( n > 0 ) {
bytesRead = read ( cl -> fileTransfer . fd , readBuf , sz_rfbBlockSize ) ;
switch ( bytesRead ) {
case 0 : retval = rfbSendFileTransferMessage ( cl , rfbEndOfFile , 0 , 0 , 0 , NULL ) ;
close ( cl -> fileTransfer . fd ) ;
cl -> fileTransfer . fd = - 1 ;
cl -> fileTransfer . sending = 0 ;
cl -> fileTransfer . receiving = 0 ;
return retval ;
case - 1 : # ifdef WIN32 errno = WSAGetLastError ( ) ;
# endif rfbLog ( "rfbSendFileTransferChunk(): %s\n" , strerror ( errno ) ) ;
retval = rfbSendFileTransferMessage ( cl , rfbAbortFileTransfer , 0 , 0 , 0 , NULL ) ;
close ( cl -> fileTransfer . fd ) ;
cl -> fileTransfer . fd = - 1 ;
cl -> fileTransfer . sending = 0 ;
cl -> fileTransfer . receiving = 0 ;
return retval ;
default : if ( ! cl -> fileTransfer . compressionEnabled ) return rfbSendFileTransferMessage ( cl , rfbFilePacket , 0 , 0 , bytesRead , ( char * ) readBuf ) ;
else {
# ifdef LIBVNCSERVER_HAVE_LIBZ nRetC = compress ( compBuf , & nMaxCompSize , readBuf , bytesRead ) ;
if ( ( nRetC == 0 ) && ( nMaxCompSize < bytesRead ) ) return rfbSendFileTransferMessage ( cl , rfbFilePacket , 0 , 1 , nMaxCompSize , ( char * ) compBuf ) ;
else return rfbSendFileTransferMessage ( cl , rfbFilePacket , 0 , 0 , bytesRead , ( char * ) readBuf ) ;
# else return rfbSendFileTransferMessage ( cl , rfbFilePacket , 0 , 0 , bytesRead , ( char * ) readBuf ) ;
# endif }
}
}
}
return TRUE ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
guint16 de_serv_cat ( tvbuff_t * tvb , proto_tree * tree , packet_info * pinfo _U_ , guint32 offset , guint len _U_ , gchar * add_string _U_ , int string_len _U_ ) {
guint32 curr_offset ;
curr_offset = offset ;
proto_tree_add_bits_item ( tree , hf_gsm_a_spare_bits , tvb , curr_offset << 3 , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( tree , hf_gsm_a_dtap_serv_cat_b7 , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( tree , hf_gsm_a_dtap_serv_cat_b6 , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( tree , hf_gsm_a_dtap_serv_cat_b5 , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( tree , hf_gsm_a_dtap_serv_cat_b4 , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( tree , hf_gsm_a_dtap_serv_cat_b3 , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( tree , hf_gsm_a_dtap_serv_cat_b2 , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( tree , hf_gsm_a_dtap_serv_cat_b1 , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
curr_offset ++ ;
return len ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int qemuMonitorTextStartCPUs ( qemuMonitorPtr mon , virConnectPtr conn ) {
char * reply ;
if ( qemuMonitorTextCommandWithHandler ( mon , "cont" , qemuMonitorSendDiskPassphrase , conn , - 1 , & reply ) < 0 ) return - 1 ;
VIR_FREE ( reply ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline void mss4_update_dc_cache ( MSS4Context * c , int mb_x ) {
int i ;
c -> dc_cache [ 0 ] [ TOP ] = c -> prev_dc [ 0 ] [ mb_x * 2 + 1 ] ;
c -> dc_cache [ 0 ] [ LEFT ] = 0 ;
c -> dc_cache [ 1 ] [ TOP ] = 0 ;
c -> dc_cache [ 1 ] [ LEFT ] = 0 ;
for ( i = 0 ;
i < 2 ;
i ++ ) c -> prev_dc [ 0 ] [ mb_x * 2 + i ] = 0 ;
for ( i = 1 ;
i < 3 ;
i ++ ) {
c -> dc_cache [ i + 1 ] [ TOP ] = c -> prev_dc [ i ] [ mb_x ] ;
c -> dc_cache [ i + 1 ] [ LEFT ] = 0 ;
c -> prev_dc [ i ] [ mb_x ] = 0 ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int kvm_has_pit_state2 ( void ) {
return has_pit_state2 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static bool equivalent_locale ( int category , const char * loca , const char * locb ) {
const char * chara ;
const char * charb ;
char * canona ;
char * canonb ;
int lena ;
int lenb ;
if ( pg_strcasecmp ( loca , locb ) == 0 ) return true ;
canona = get_canonical_locale_name ( category , loca ) ;
chara = strrchr ( canona , '.' ) ;
lena = chara ? ( chara - canona ) : strlen ( canona ) ;
canonb = get_canonical_locale_name ( category , locb ) ;
charb = strrchr ( canonb , '.' ) ;
lenb = charb ? ( charb - canonb ) : strlen ( canonb ) ;
if ( lena == lenb && pg_strncasecmp ( canona , canonb , lena ) == 0 ) {
pg_free ( canona ) ;
pg_free ( canonb ) ;
return true ;
}
pg_free ( canona ) ;
pg_free ( canonb ) ;
return false ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static Pattern_Prefix_Status like_fixed_prefix ( Const * patt_const , bool case_insensitive , Oid collation , Const * * prefix_const , Selectivity * rest_selec ) {
char * match ;
char * patt ;
int pattlen ;
Oid typeid = patt_const -> consttype ;
int pos , match_pos ;
bool is_multibyte = ( pg_database_encoding_max_length ( ) > 1 ) ;
pg_locale_t locale = 0 ;
bool locale_is_c = false ;
Assert ( typeid == BYTEAOID || typeid == TEXTOID ) ;
if ( case_insensitive ) {
if ( typeid == BYTEAOID ) ereport ( ERROR , ( errcode ( ERRCODE_FEATURE_NOT_SUPPORTED ) , errmsg ( "case insensitive matching not supported on type bytea" ) ) ) ;
if ( lc_ctype_is_c ( collation ) ) locale_is_c = true ;
else if ( collation != DEFAULT_COLLATION_OID ) {
if ( ! OidIsValid ( collation ) ) {
ereport ( ERROR , ( errcode ( ERRCODE_INDETERMINATE_COLLATION ) , errmsg ( "could not determine which collation to use for ILIKE" ) , errhint ( "Use the COLLATE clause to set the collation explicitly." ) ) ) ;
}
locale = pg_newlocale_from_collation ( collation ) ;
}
}
if ( typeid != BYTEAOID ) {
patt = TextDatumGetCString ( patt_const -> constvalue ) ;
pattlen = strlen ( patt ) ;
}
else {
bytea * bstr = DatumGetByteaP ( patt_const -> constvalue ) ;
pattlen = VARSIZE ( bstr ) - VARHDRSZ ;
patt = ( char * ) palloc ( pattlen ) ;
memcpy ( patt , VARDATA ( bstr ) , pattlen ) ;
if ( ( Pointer ) bstr != DatumGetPointer ( patt_const -> constvalue ) ) pfree ( bstr ) ;
}
match = palloc ( pattlen + 1 ) ;
match_pos = 0 ;
for ( pos = 0 ;
pos < pattlen ;
pos ++ ) {
if ( patt [ pos ] == '%' || patt [ pos ] == '_' ) break ;
if ( patt [ pos ] == '\\' ) {
pos ++ ;
if ( pos >= pattlen ) break ;
}
if ( case_insensitive && pattern_char_isalpha ( patt [ pos ] , is_multibyte , locale , locale_is_c ) ) break ;
match [ match_pos ++ ] = patt [ pos ] ;
}
match [ match_pos ] = '\0' ;
if ( typeid != BYTEAOID ) * prefix_const = string_to_const ( match , typeid ) ;
else * prefix_const = string_to_bytea_const ( match , match_pos ) ;
if ( rest_selec != NULL ) * rest_selec = like_selectivity ( & patt [ pos ] , pattlen - pos , case_insensitive ) ;
pfree ( patt ) ;
pfree ( match ) ;
if ( pos == pattlen ) return Pattern_Prefix_Exact ;
if ( match_pos > 0 ) return Pattern_Prefix_Partial ;
return Pattern_Prefix_None ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static bool check_for_exec ( const_os_ptr op ) {
if ( ! r_has_attr ( op , a_execute ) && ref_type_uses_access ( r_type ( op ) ) && ( r_has_attr ( op , a_executable ) || ! r_has_type ( op , t_dictionary ) ) ) {
return_error ( gs_error_invalidaccess ) ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static GstFlowReturn gst_asf_demux_process_simple_index ( GstASFDemux * demux , guint8 * data , guint64 size ) {
GstClockTime interval ;
guint32 count , i ;
if ( size < ( 16 + 8 + 4 + 4 ) ) goto not_enough_data ;
gst_asf_demux_skip_bytes ( 16 , & data , & size ) ;
interval = gst_asf_demux_get_uint64 ( & data , & size ) * ( GstClockTime ) 100 ;
gst_asf_demux_skip_bytes ( 4 , & data , & size ) ;
count = gst_asf_demux_get_uint32 ( & data , & size ) ;
if ( count > 0 ) {
demux -> sidx_interval = interval ;
demux -> sidx_num_entries = count ;
g_free ( demux -> sidx_entries ) ;
demux -> sidx_entries = g_new0 ( AsfSimpleIndexEntry , count ) ;
for ( i = 0 ;
i < count ;
++ i ) {
if ( G_UNLIKELY ( size < 6 ) ) {
demux -> sidx_num_entries -= ( count - i ) ;
break ;
}
demux -> sidx_entries [ i ] . packet = gst_asf_demux_get_uint32 ( & data , & size ) ;
demux -> sidx_entries [ i ] . count = gst_asf_demux_get_uint16 ( & data , & size ) ;
GST_LOG_OBJECT ( demux , "%" GST_TIME_FORMAT " = packet %4u count : %2d" , GST_TIME_ARGS ( i * interval ) , demux -> sidx_entries [ i ] . packet , demux -> sidx_entries [ i ] . count ) ;
}
}
else {
GST_DEBUG_OBJECT ( demux , "simple index object with 0 entries" ) ;
}
return GST_FLOW_OK ;
not_enough_data : {
GST_WARNING_OBJECT ( demux , "short read parsing simple index object!" ) ;
return GST_FLOW_OK ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static uint64_t dchip_read ( void * opaque , hwaddr addr , unsigned size ) {
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
wtap_open_return_val ngsniffer_open ( wtap * wth , int * err , gchar * * err_info ) {
char magic [ sizeof ngsniffer_magic ] ;
char record_type [ 2 ] ;
char record_length [ 4 ] ;
guint16 type ;
struct vers_rec version ;
guint16 maj_vers ;
guint16 start_date ;
# if 0 guint16 start_time ;
# endif static const int sniffer_encap [ ] = {
WTAP_ENCAP_TOKEN_RING , WTAP_ENCAP_ETHERNET , WTAP_ENCAP_ARCNET , WTAP_ENCAP_UNKNOWN , WTAP_ENCAP_UNKNOWN , WTAP_ENCAP_UNKNOWN , WTAP_ENCAP_UNKNOWN , WTAP_ENCAP_PER_PACKET , WTAP_ENCAP_PER_PACKET , WTAP_ENCAP_FDDI_BITSWAPPED , WTAP_ENCAP_ATM_PDUS }
;
# define NUM_NGSNIFF_ENCAPS ( sizeof sniffer_encap / sizeof sniffer_encap [ 0 ] ) struct tm tm ;
gint64 current_offset ;
ngsniffer_t * ngsniffer ;
if ( ! wtap_read_bytes ( wth -> fh , magic , sizeof magic , err , err_info ) ) {
if ( * err != WTAP_ERR_SHORT_READ ) return WTAP_OPEN_ERROR ;
return WTAP_OPEN_NOT_MINE ;
}
if ( memcmp ( magic , ngsniffer_magic , sizeof ngsniffer_magic ) ) {
return WTAP_OPEN_NOT_MINE ;
}
if ( ! wtap_read_bytes ( wth -> fh , record_type , 2 , err , err_info ) ) return WTAP_OPEN_ERROR ;
if ( ! wtap_read_bytes ( wth -> fh , record_length , 4 , err , err_info ) ) return WTAP_OPEN_ERROR ;
type = pletoh16 ( record_type ) ;
if ( type != REC_VERS ) {
* err = WTAP_ERR_BAD_FILE ;
* err_info = g_strdup_printf ( "ngsniffer: Sniffer file doesn't start with a version record" ) ;
return WTAP_OPEN_ERROR ;
}
if ( ! wtap_read_bytes ( wth -> fh , & version , sizeof version , err , err_info ) ) return WTAP_OPEN_ERROR ;
if ( version . network >= NUM_NGSNIFF_ENCAPS || sniffer_encap [ version . network ] == WTAP_ENCAP_UNKNOWN ) {
* err = WTAP_ERR_UNSUPPORTED ;
* err_info = g_strdup_printf ( "ngsniffer: network type %u unknown or unsupported" , version . network ) ;
return WTAP_OPEN_ERROR ;
}
if ( version . timeunit >= NUM_NGSNIFF_TIMEUNITS ) {
* err = WTAP_ERR_UNSUPPORTED ;
* err_info = g_strdup_printf ( "ngsniffer: Unknown timeunit %u" , version . timeunit ) ;
return WTAP_OPEN_ERROR ;
}
if ( version . format != 1 ) {
wth -> file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_NGSNIFFER_COMPRESSED ;
}
else {
wth -> file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_NGSNIFFER_UNCOMPRESSED ;
}
wth -> file_encap = sniffer_encap [ version . network ] ;
maj_vers = pletoh16 ( & version . maj_vers ) ;
if ( process_header_records ( wth , err , err_info , maj_vers , version . network ) < 0 ) return WTAP_OPEN_ERROR ;
if ( ( version . network == NETWORK_SYNCHRO || version . network == NETWORK_ASYNC ) && wth -> file_encap == WTAP_ENCAP_PER_PACKET ) {
switch ( maj_vers ) {
case 1 : switch ( pletoh16 ( & version . rsvd [ 0 ] ) ) {
case 1 : case 2 : wth -> file_encap = WTAP_ENCAP_ISDN ;
break ;
}
break ;
case 3 : wth -> file_encap = WTAP_ENCAP_FRELAY_WITH_PHDR ;
break ;
}
}
current_offset = file_tell ( wth -> fh ) ;
if ( wth -> random_fh != NULL ) {
if ( file_seek ( wth -> random_fh , current_offset , SEEK_SET , err ) == - 1 ) return WTAP_OPEN_ERROR ;
}
ngsniffer = ( ngsniffer_t * ) g_malloc ( sizeof ( ngsniffer_t ) ) ;
wth -> priv = ( void * ) ngsniffer ;
ngsniffer -> maj_vers = maj_vers ;
ngsniffer -> min_vers = pletoh16 ( & version . min_vers ) ;
ngsniffer -> seq . buf = NULL ;
ngsniffer -> seq . nbytes = 0 ;
ngsniffer -> seq . nextout = 0 ;
ngsniffer -> rand . buf = NULL ;
ngsniffer -> rand . nbytes = 0 ;
ngsniffer -> rand . nextout = 0 ;
ngsniffer -> seq . uncomp_offset = current_offset ;
ngsniffer -> seq . comp_offset = current_offset ;
ngsniffer -> rand . uncomp_offset = current_offset ;
ngsniffer -> rand . comp_offset = current_offset ;
ngsniffer -> first_blob = NULL ;
ngsniffer -> last_blob = NULL ;
ngsniffer -> current_blob = NULL ;
wth -> subtype_read = ngsniffer_read ;
wth -> subtype_seek_read = ngsniffer_seek_read ;
wth -> subtype_sequential_close = ngsniffer_sequential_close ;
wth -> subtype_close = ngsniffer_close ;
wth -> snapshot_length = 0 ;
ngsniffer -> timeunit = Psec [ version . timeunit ] ;
ngsniffer -> network = version . network ;
start_date = pletoh16 ( & version . date ) ;
tm . tm_year = ( ( start_date & DOS_YEAR_MASK ) >> DOS_YEAR_SHIFT ) + DOS_YEAR_OFFSET ;
tm . tm_mon = ( ( start_date & DOS_MONTH_MASK ) >> DOS_MONTH_SHIFT ) + DOS_MONTH_OFFSET ;
tm . tm_mday = ( ( start_date & DOS_DAY_MASK ) >> DOS_DAY_SHIFT ) ;
# if 0 start_time = pletoh16 ( & version . time ) ;
tm . tm_hour = ( start_time & 0xf800 ) >> 11 ;
tm . tm_min = ( start_time & 0x7e0 ) >> 5 ;
tm . tm_sec = ( start_time & 0x1f ) << 1 ;
# endif tm . tm_hour = 0 ;
tm . tm_min = 0 ;
tm . tm_sec = 0 ;
tm . tm_isdst = - 1 ;
ngsniffer -> start = mktime ( & tm ) ;
wth -> file_tsprec = WTAP_TSPREC_NSEC ;
return WTAP_OPEN_MINE ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void do_info_qtree ( Monitor * mon ) {
if ( main_system_bus ) qbus_print ( mon , main_system_bus , 0 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_T_extendedPAR ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_constrained_set_of ( tvb , offset , actx , tree , hf_index , ett_h245_T_extendedPAR , T_extendedPAR_set_of , 1 , 256 , FALSE ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int decrypt_nss_2_3 ( struct crypto_instance * instance , unsigned char * buf , int * buf_len ) {
* buf_len -= sizeof ( struct crypto_config_header ) ;
if ( decrypt_nss ( instance , buf + sizeof ( struct crypto_config_header ) , buf_len ) < 0 ) {
return - 1 ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void read_variables ( struct recvbuf * rbufp , int restrict_mask ) {
if ( res_associd ) read_peervars ( ) ;
else read_sysvars ( ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void aes_crypt_ecb ( aes_context * ctx , int mode , const unsigned char input [ 16 ] , unsigned char output [ 16 ] ) {
int i ;
unsigned long * RK , X0 , X1 , X2 , X3 , Y0 , Y1 , Y2 , Y3 ;
# if defined ( XYSSL_PADLOCK_C ) && defined ( XYSSL_HAVE_X86 ) if ( padlock_supports ( PADLOCK_ACE ) ) {
if ( padlock_xcryptecb ( ctx , mode , input , output ) == 0 ) return ;
}
# endif RK = ctx -> rk ;
GET_ULONG_LE ( X0 , input , 0 ) ;
X0 ^= * RK ++ ;
GET_ULONG_LE ( X1 , input , 4 ) ;
X1 ^= * RK ++ ;
GET_ULONG_LE ( X2 , input , 8 ) ;
X2 ^= * RK ++ ;
GET_ULONG_LE ( X3 , input , 12 ) ;
X3 ^= * RK ++ ;
if ( mode == AES_DECRYPT ) {
for ( i = ( ctx -> nr >> 1 ) - 1 ;
i > 0 ;
i -- ) {
AES_RROUND ( Y0 , Y1 , Y2 , Y3 , X0 , X1 , X2 , X3 ) ;
AES_RROUND ( X0 , X1 , X2 , X3 , Y0 , Y1 , Y2 , Y3 ) ;
}
AES_RROUND ( Y0 , Y1 , Y2 , Y3 , X0 , X1 , X2 , X3 ) ;
X0 = * RK ++ ^ ( RSb [ ( Y0 ) & 0xFF ] ) ^ ( RSb [ ( Y3 >> 8 ) & 0xFF ] << 8 ) ^ ( RSb [ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^ ( ( ( unsigned int ) RSb [ ( Y1 >> 24 ) & 0xFF ] ) << 24 ) ;
X1 = * RK ++ ^ ( RSb [ ( Y1 ) & 0xFF ] ) ^ ( RSb [ ( Y0 >> 8 ) & 0xFF ] << 8 ) ^ ( RSb [ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^ ( ( ( unsigned int ) RSb [ ( Y2 >> 24 ) & 0xFF ] ) << 24 ) ;
X2 = * RK ++ ^ ( RSb [ ( Y2 ) & 0xFF ] ) ^ ( RSb [ ( Y1 >> 8 ) & 0xFF ] << 8 ) ^ ( RSb [ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^ ( ( ( unsigned int ) RSb [ ( Y3 >> 24 ) & 0xFF ] ) << 24 ) ;
X3 = * RK ++ ^ ( RSb [ ( Y3 ) & 0xFF ] ) ^ ( RSb [ ( Y2 >> 8 ) & 0xFF ] << 8 ) ^ ( RSb [ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^ ( ( ( unsigned int ) RSb [ ( Y0 >> 24 ) & 0xFF ] ) << 24 ) ;
}
else {
for ( i = ( ctx -> nr >> 1 ) - 1 ;
i > 0 ;
i -- ) {
AES_FROUND ( Y0 , Y1 , Y2 , Y3 , X0 , X1 , X2 , X3 ) ;
AES_FROUND ( X0 , X1 , X2 , X3 , Y0 , Y1 , Y2 , Y3 ) ;
}
AES_FROUND ( Y0 , Y1 , Y2 , Y3 , X0 , X1 , X2 , X3 ) ;
X0 = * RK ++ ^ ( FSb [ ( Y0 ) & 0xFF ] ) ^ ( FSb [ ( Y1 >> 8 ) & 0xFF ] << 8 ) ^ ( FSb [ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^ ( ( ( unsigned int ) FSb [ ( Y3 >> 24 ) & 0xFF ] ) << 24 ) ;
X1 = * RK ++ ^ ( FSb [ ( Y1 ) & 0xFF ] ) ^ ( FSb [ ( Y2 >> 8 ) & 0xFF ] << 8 ) ^ ( FSb [ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^ ( ( ( unsigned int ) FSb [ ( Y0 >> 24 ) & 0xFF ] ) << 24 ) ;
X2 = * RK ++ ^ ( FSb [ ( Y2 ) & 0xFF ] ) ^ ( FSb [ ( Y3 >> 8 ) & 0xFF ] << 8 ) ^ ( FSb [ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^ ( ( ( unsigned int ) FSb [ ( Y1 >> 24 ) & 0xFF ] ) << 24 ) ;
X3 = * RK ++ ^ ( FSb [ ( Y3 ) & 0xFF ] ) ^ ( FSb [ ( Y0 >> 8 ) & 0xFF ] << 8 ) ^ ( FSb [ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^ ( ( ( unsigned int ) FSb [ ( Y2 >> 24 ) & 0xFF ] ) << 24 ) ;
}
PUT_ULONG_LE ( X0 , output , 0 ) ;
PUT_ULONG_LE ( X1 , output , 4 ) ;
PUT_ULONG_LE ( X2 , output , 8 ) ;
PUT_ULONG_LE ( X3 , output , 12 ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void add_range ( fz_context * ctx , pdf_cmap * cmap , unsigned int low , unsigned int high , unsigned int out , int check_for_overlap , int many ) {
int current ;
cmap_splay * tree ;
if ( low > high ) {
fz_warn ( ctx , "range limits out of range in cmap %s" , cmap -> cmap_name ) ;
return ;
}
tree = cmap -> tree ;
if ( cmap -> tlen ) {
unsigned int move = cmap -> ttop ;
unsigned int gt = EMPTY ;
unsigned int lt = EMPTY ;
if ( check_for_overlap ) {
do {
current = move ;
if ( low <= tree [ current ] . low && tree [ current ] . low <= high ) {
tree [ current ] . out += high + 1 - tree [ current ] . low ;
tree [ current ] . low = high + 1 ;
if ( tree [ current ] . low > tree [ current ] . high ) {
move = delete_node ( cmap , current ) ;
current = EMPTY ;
continue ;
}
}
else if ( low <= tree [ current ] . high && tree [ current ] . high <= high ) {
tree [ current ] . high = low - 1 ;
assert ( tree [ current ] . low <= tree [ current ] . high ) ;
}
else if ( tree [ current ] . low < low && high < tree [ current ] . high ) {
int new_high = tree [ current ] . high ;
tree [ current ] . high = low - 1 ;
add_range ( ctx , cmap , high + 1 , new_high , tree [ current ] . out + high + 1 - tree [ current ] . low , 0 , tree [ current ] . many ) ;
}
if ( tree [ current ] . low > high ) {
move = tree [ current ] . left ;
gt = current ;
}
else {
move = tree [ current ] . right ;
lt = current ;
}
}
while ( move != EMPTY ) ;
}
else {
do {
current = move ;
if ( tree [ current ] . low > high ) {
move = tree [ current ] . left ;
gt = current ;
}
else {
move = tree [ current ] . right ;
lt = current ;
}
}
while ( move != EMPTY ) ;
}
if ( ! many ) {
if ( lt != EMPTY && ! tree [ lt ] . many && tree [ lt ] . high == low - 1 && tree [ lt ] . out - tree [ lt ] . low == out - low ) {
tree [ lt ] . high = high ;
if ( gt != EMPTY && ! tree [ gt ] . many && tree [ gt ] . low == high + 1 && tree [ gt ] . out - tree [ gt ] . low == out - low ) {
tree [ lt ] . high = tree [ gt ] . high ;
delete_node ( cmap , gt ) ;
}
goto exit ;
}
if ( gt != EMPTY && ! tree [ gt ] . many && tree [ gt ] . low == high + 1 && tree [ gt ] . out - tree [ gt ] . low == out - low ) {
tree [ gt ] . low = low ;
tree [ gt ] . out = out ;
goto exit ;
}
}
}
else current = EMPTY ;
if ( cmap -> tlen == cmap -> tcap ) {
int new_cap = cmap -> tcap ? cmap -> tcap * 2 : 256 ;
tree = cmap -> tree = fz_resize_array ( ctx , cmap -> tree , new_cap , sizeof * cmap -> tree ) ;
cmap -> tcap = new_cap ;
}
tree [ cmap -> tlen ] . low = low ;
tree [ cmap -> tlen ] . high = high ;
tree [ cmap -> tlen ] . out = out ;
tree [ cmap -> tlen ] . parent = current ;
tree [ cmap -> tlen ] . left = EMPTY ;
tree [ cmap -> tlen ] . right = EMPTY ;
tree [ cmap -> tlen ] . many = many ;
cmap -> tlen ++ ;
if ( current == EMPTY ) cmap -> ttop = 0 ;
else if ( tree [ current ] . low > high ) tree [ current ] . left = cmap -> tlen - 1 ;
else {
assert ( tree [ current ] . high < low ) ;
tree [ current ] . right = cmap -> tlen - 1 ;
}
move_to_root ( tree , cmap -> tlen - 1 ) ;
cmap -> ttop = cmap -> tlen - 1 ;
exit : {
}
# ifdef CHECK_SPLAY check_splay ( cmap -> tree , cmap -> ttop , 0 ) ;
# endif # ifdef DUMP_SPLAY dump_splay ( cmap -> tree , cmap -> ttop , 0 , "" ) ;
# endif }
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int RTP_packet ( void * ptr _U_ , packet_info * pinfo , epan_dissect_t * edt _U_ , void const * RTPinfo ) {
voip_rtp_tapinfo_t * tapinfo = & the_tapinfo_rtp_struct ;
voip_rtp_stream_info_t * tmp_listinfo ;
voip_rtp_stream_info_t * strinfo = NULL ;
GList * list ;
struct _rtp_conversation_info * p_conv_data = NULL ;
const struct _rtp_info * pi = ( const struct _rtp_info * ) RTPinfo ;
if ( pi -> info_setup_frame_num == 0 ) {
return 0 ;
}
# ifdef HAVE_LIBPORTAUDIO add_rtp_packet ( pi , pinfo ) ;
# endif list = g_list_first ( tapinfo -> list ) ;
while ( list ) {
tmp_listinfo = ( voip_rtp_stream_info_t * ) list -> data ;
if ( ( tmp_listinfo -> setup_frame_number == pi -> info_setup_frame_num ) && ( tmp_listinfo -> ssrc == pi -> info_sync_src ) && ( tmp_listinfo -> end_stream == FALSE ) ) {
if ( tmp_listinfo -> pt != pi -> info_payload_type ) {
tmp_listinfo -> end_stream = TRUE ;
}
else {
strinfo = ( voip_rtp_stream_info_t * ) ( list -> data ) ;
break ;
}
}
list = g_list_next ( list ) ;
}
if ( ( rtp_evt_frame_num == pinfo -> fd -> num ) && ! strinfo && ( rtp_evt_end == TRUE ) ) {
return 0 ;
}
if ( strinfo == NULL ) {
strinfo = ( voip_rtp_stream_info_t * ) g_malloc ( sizeof ( voip_rtp_stream_info_t ) ) ;
COPY_ADDRESS ( & ( strinfo -> src_addr ) , & ( pinfo -> src ) ) ;
strinfo -> src_port = pinfo -> srcport ;
COPY_ADDRESS ( & ( strinfo -> dest_addr ) , & ( pinfo -> dst ) ) ;
strinfo -> dest_port = pinfo -> destport ;
strinfo -> ssrc = pi -> info_sync_src ;
strinfo -> end_stream = FALSE ;
strinfo -> pt = pi -> info_payload_type ;
strinfo -> pt_str = NULL ;
strinfo -> is_srtp = pi -> info_is_srtp ;
if ( ( strinfo -> pt >= PT_UNDF_96 ) && ( strinfo -> pt <= PT_UNDF_127 ) ) {
p_conv_data = ( struct _rtp_conversation_info * ) p_get_proto_data ( wmem_file_scope ( ) , pinfo , proto_get_id_by_filter_name ( "rtp" ) , 0 ) ;
if ( p_conv_data && p_conv_data -> rtp_dyn_payload ) {
encoding_name_and_rate_t * encoding_name_and_rate_pt = NULL ;
encoding_name_and_rate_pt = ( encoding_name_and_rate_t * ) g_hash_table_lookup ( p_conv_data -> rtp_dyn_payload , & strinfo -> pt ) ;
if ( encoding_name_and_rate_pt ) {
strinfo -> pt_str = g_strdup ( encoding_name_and_rate_pt -> encoding_name ) ;
}
}
}
if ( ! strinfo -> pt_str ) strinfo -> pt_str = g_strdup ( val_to_str_ext ( strinfo -> pt , & rtp_payload_type_short_vals_ext , "%u" ) ) ;
strinfo -> npackets = 0 ;
strinfo -> start_fd = pinfo -> fd ;
strinfo -> start_rel_ts = pinfo -> rel_ts ;
strinfo -> setup_frame_number = pi -> info_setup_frame_num ;
strinfo -> rtp_event = - 1 ;
tapinfo -> list = g_list_prepend ( tapinfo -> list , strinfo ) ;
}
strinfo -> npackets ++ ;
strinfo -> stop_fd = pinfo -> fd ;
strinfo -> stop_rel_ts = pinfo -> rel_ts ;
if ( rtp_evt_frame_num == pinfo -> fd -> num ) {
strinfo -> rtp_event = rtp_evt ;
if ( rtp_evt_end == TRUE ) {
strinfo -> end_stream = TRUE ;
}
}
the_tapinfo_struct . redraw = TRUE ;
return 1 ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
int ber_ptrlen ( BerElement * ber ) {
return ( ber -> ber_ptr - ber -> ber_buf ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void data_destroy_indic ( void * data ) {
free ( data ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( PageLoadMetricsBrowserTest , NoAbortMetricsOnClientRedirect ) {
ASSERT_TRUE ( embedded_test_server ( ) -> Start ( ) ) ;
GURL first_url ( embedded_test_server ( ) -> GetURL ( "/title1.html" ) ) ;
ui_test_utils : : NavigateToURL ( browser ( ) , first_url ) ;
GURL second_url ( embedded_test_server ( ) -> GetURL ( "/title2.html" ) ) ;
NavigateParams params ( browser ( ) , second_url , ui : : PAGE_TRANSITION_LINK ) ;
content : : TestNavigationManager manager ( browser ( ) -> tab_strip_model ( ) -> GetActiveWebContents ( ) , second_url ) ;
Navigate ( & params ) ;
EXPECT_TRUE ( manager . WaitForRequestStart ( ) ) ;
{
auto waiter = CreatePageLoadMetricsWaiter ( ) ;
waiter -> AddPageExpectation ( TimingField : : LOAD_EVENT ) ;
EXPECT_TRUE ( content : : ExecuteScript ( browser ( ) -> tab_strip_model ( ) -> GetActiveWebContents ( ) , "window.location.reload();
" ) ) ;
waiter -> Wait ( ) ;
}
manager . WaitForNavigationFinished ( ) ;
EXPECT_TRUE ( histogram_tester_ . GetTotalCountsForPrefix ( "PageLoad.Experimental.AbortTiming." ) . empty ( ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
afs_int32 SPR_ListEntries ( struct rx_call * call , afs_int32 flag , afs_int32 startindex , prentries * bulkentries , afs_int32 * nextstartindex ) {
afs_int32 code ;
afs_int32 cid = ANONYMOUSID ;
code = listEntries ( call , flag , startindex , bulkentries , nextstartindex , & cid ) ;
osi_auditU ( call , PTS_LstEntsEvent , code , AUD_LONG , flag , AUD_END ) ;
ViceLog ( 125 , ( "PTS_ListEntries: code %d cid %d flag %d\n" , code , cid , flag ) ) ;
return code ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void weighted_vector_sumd ( double * out , const double * in_a , const double * in_b , double weight_coeff_a , double weight_coeff_b , int length ) {
int i ;
for ( i = 0 ;
i < length ;
i ++ ) out [ i ] = weight_coeff_a * in_a [ i ] + weight_coeff_b * in_b [ i ] ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void scalar_dequant_float ( COOKContext * q , int index , int quant_index , int * subband_coef_index , int * subband_coef_sign , float * mlt_p ) {
int i ;
float f1 ;
for ( i = 0 ;
i < SUBBAND_SIZE ;
i ++ ) {
if ( subband_coef_index [ i ] ) {
f1 = quant_centroid_tab [ index ] [ subband_coef_index [ i ] ] ;
if ( subband_coef_sign [ i ] ) f1 = - f1 ;
}
else {
f1 = dither_tab [ index ] ;
if ( av_lfg_get ( & q -> random_state ) < 0x80000000 ) f1 = - f1 ;
}
mlt_p [ i ] = f1 * rootpow2tab [ quant_index + 63 ] ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vp9_iwht4x4_add ( const int16_t * input , uint8_t * dest , int stride , int eob ) {
if ( eob > 1 ) vp9_iwht4x4_16_add ( input , dest , stride ) ;
else vp9_iwht4x4_1_add ( input , dest , stride ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
int key_reject_and_link ( struct key * key , unsigned timeout , unsigned error , struct key * keyring , struct key * authkey ) {
struct assoc_array_edit * edit ;
struct timespec now ;
int ret , awaken , link_ret = 0 ;
key_check ( key ) ;
key_check ( keyring ) ;
awaken = 0 ;
ret = - EBUSY ;
if ( keyring ) {
if ( keyring -> restrict_link ) return - EPERM ;
link_ret = __key_link_begin ( keyring , & key -> index_key , & edit ) ;
}
mutex_lock ( & key_construction_mutex ) ;
if ( ! test_bit ( KEY_FLAG_INSTANTIATED , & key -> flags ) ) {
atomic_inc ( & key -> user -> nikeys ) ;
key -> reject_error = - error ;
smp_wmb ( ) ;
set_bit ( KEY_FLAG_NEGATIVE , & key -> flags ) ;
set_bit ( KEY_FLAG_INSTANTIATED , & key -> flags ) ;
now = current_kernel_time ( ) ;
key -> expiry = now . tv_sec + timeout ;
key_schedule_gc ( key -> expiry + key_gc_delay ) ;
if ( test_and_clear_bit ( KEY_FLAG_USER_CONSTRUCT , & key -> flags ) ) awaken = 1 ;
ret = 0 ;
if ( keyring && link_ret == 0 ) __key_link ( key , & edit ) ;
if ( authkey ) key_revoke ( authkey ) ;
}
mutex_unlock ( & key_construction_mutex ) ;
if ( keyring ) __key_link_end ( keyring , & key -> index_key , edit ) ;
if ( awaken ) wake_up_bit ( & key -> flags , KEY_FLAG_USER_CONSTRUCT ) ;
return ret == 0 ? link_ret : ret ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
void var_set_int ( const char * name , int value ) {
char buf [ 21 ] ;
my_snprintf ( buf , sizeof ( buf ) , "%d" , value ) ;
var_set_string ( name , buf ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
inline static void _slurm_rpc_trigger_get ( slurm_msg_t * msg ) {
uid_t uid = g_slurm_auth_get_uid ( msg -> auth_cred , slurmctld_config . auth_info ) ;
trigger_info_msg_t * resp_data ;
trigger_info_msg_t * trigger_ptr = ( trigger_info_msg_t * ) msg -> data ;
slurm_msg_t response_msg ;
DEF_TIMERS ;
START_TIMER ;
debug ( "Processing RPC: REQUEST_TRIGGER_GET from uid=%d" , uid ) ;
resp_data = trigger_get ( uid , trigger_ptr ) ;
END_TIMER2 ( "_slurm_rpc_trigger_get" ) ;
slurm_msg_t_init ( & response_msg ) ;
response_msg . flags = msg -> flags ;
response_msg . protocol_version = msg -> protocol_version ;
response_msg . address = msg -> address ;
response_msg . conn = msg -> conn ;
response_msg . msg_type = RESPONSE_TRIGGER_GET ;
response_msg . data = resp_data ;
slurm_send_node_msg ( msg -> conn_fd , & response_msg ) ;
slurm_free_trigger_msg ( resp_data ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int unupack ( int upack , char * dest , uint32_t dsize , char * buff , uint32_t vma , uint32_t ep , uint32_t base , uint32_t va , int file ) {
int j , searchval ;
char * loc_esi , * loc_edi = NULL , * loc_ebx , * end_edi , * save_edi , * alvalue ;
char * paddr , * pushed_esi , * save2 ;
uint32_t save1 , save3 , loc_ecx , count , shlsize , original_ep , ret , loc_ebx_u ;
struct cli_exe_section section ;
int upack_version = UPACK_399 ;
if ( upack ) {
uint32_t aljump , shroff , lngjmpoff ;
if ( buff [ 5 ] == '\xff' && buff [ 6 ] == '\x36' ) upack_version = UPACK_0297729 ;
loc_esi = dest + ( cli_readint32 ( buff + 1 ) - vma ) ;
if ( ! CLI_ISCONTAINED ( dest , dsize , loc_esi , 12 ) ) return - 1 ;
original_ep = cli_readint32 ( loc_esi ) ;
loc_esi += 4 ;
loc_esi += 4 ;
original_ep -= vma ;
cli_dbgmsg ( "Upack: EP: %08x original: %08X || %08x\n" , ep , original_ep , cli_readint32 ( loc_esi - 8 ) ) ;
if ( upack_version == UPACK_399 ) {
loc_edi = dest + ( cli_readint32 ( loc_esi ) - vma ) ;
if ( ! CLI_ISCONTAINED ( dest , dsize , dest + ep + 0xa , 2 ) || dest [ ep + 0xa ] != '\xeb' ) return - 1 ;
loc_esi = dest + * ( dest + ep + 0xb ) + ep + 0xc ;
alvalue = loc_esi + 0x1a ;
if ( ! CLI_ISCONTAINED ( dest , dsize , alvalue , 2 ) || * alvalue != '\xeb' ) return - 1 ;
alvalue ++ ;
alvalue += ( * alvalue & 0xff ) + 1 + 0xa ;
lngjmpoff = 8 ;
}
else {
if ( ! CLI_ISCONTAINED ( dest , dsize , dest + ep + 7 , 5 ) || dest [ ep + 7 ] != '\xe9' ) return - 1 ;
loc_esi = dest + cli_readint32 ( dest + ep + 8 ) + ep + 0xc ;
alvalue = loc_esi + 0x25 ;
lngjmpoff = 10 ;
}
if ( ! CLI_ISCONTAINED ( dest , dsize , alvalue , 2 ) || * alvalue != '\xb5' ) return - 1 ;
alvalue ++ ;
count = * alvalue & 0xff ;
if ( ! CLI_ISCONTAINED ( dest , dsize , alvalue , lngjmpoff + 5 ) || * ( alvalue + lngjmpoff ) != '\xe9' ) return - 1 ;
shlsize = cli_readint32 ( alvalue + lngjmpoff + 1 ) ;
if ( upack_version == UPACK_399 ) shlsize = shlsize + ( loc_esi - dest ) + * ( loc_esi + 0x1b ) + 0x1c + 0x018 ;
else shlsize = shlsize + ( loc_esi - dest ) + 0x035 ;
alvalue = dest + shlsize + 43 ;
aljump = 8 ;
shroff = 24 ;
if ( ! CLI_ISCONTAINED ( dest , dsize , alvalue - 1 , 2 ) || * ( alvalue - 1 ) != '\xe3' ) {
alvalue = dest + shlsize + 46 ;
if ( ! CLI_ISCONTAINED ( dest , dsize , alvalue - 1 , 2 ) || * ( alvalue - 1 ) != '\xe3' ) return - 1 ;
else {
if ( upack_version != UPACK_0297729 ) upack_version = UPACK_0151477 ;
aljump = 7 ;
shroff = 26 ;
}
}
alvalue += ( * alvalue & 0xff ) + 1 ;
if ( ! CLI_ISCONTAINED ( dest , dsize , alvalue , aljump + 5 ) || * ( alvalue + aljump ) != '\xe9' ) return - 1 ;
ret = cli_readint32 ( alvalue + aljump + 1 ) ;
alvalue += ret + aljump + 1 + 4 + 27 ;
if ( upack_version == UPACK_0297729 ) alvalue += 2 ;
if ( ! CLI_ISCONTAINED ( dest , dsize , dest + shlsize + shroff , 3 ) || * ( dest + shlsize + shroff ) != '\xc1' || * ( dest + shlsize + shroff + 1 ) != '\xed' ) return - 1 ;
shlsize = ( * ( dest + shlsize + shroff + 2 ) ) & 0xff ;
count *= 0x100 ;
if ( shlsize < 2 || shlsize > 8 ) {
cli_dbgmsg ( "Upack: context bits out of bounds\n" ) ;
return - 1 ;
}
cli_dbgmsg ( "Upack: Context Bits parameter used with lzma: %02x, %02x\n" , shlsize , count ) ;
if ( upack_version == UPACK_0297729 ) {
if ( ! CLI_ISCONTAINED ( dest , dsize , loc_esi + 6 , 10 ) || * ( loc_esi + 6 ) != '\xbe' || * ( loc_esi + 11 ) != '\xbf' ) return - 1 ;
if ( ( uint32_t ) cli_readint32 ( loc_esi + 7 ) < base || ( uint32_t ) cli_readint32 ( loc_esi + 7 ) > vma ) return - 1 ;
loc_edi = dest + ( cli_readint32 ( loc_esi + 12 ) - vma ) ;
loc_esi = dest + ( cli_readint32 ( loc_esi + 7 ) - base ) ;
}
else {
if ( ! CLI_ISCONTAINED ( dest , dsize , loc_esi + 7 , 5 ) || * ( loc_esi + 7 ) != '\xbe' ) return - 1 ;
loc_esi = dest + ( cli_readint32 ( loc_esi + 8 ) - vma ) ;
}
if ( upack_version == UPACK_0297729 ) {
if ( ! CLI_ISCONTAINED ( dest , dsize , loc_edi , ( 0x58 + 24 + 4 * count ) ) || ! CLI_ISCONTAINED ( dest , dsize , loc_esi , ( 0x58 + 0x64 + 4 ) ) ) return - 1 ;
for ( j = 0 ;
j < 0x16 ;
j ++ , loc_esi += 4 , loc_edi += 4 ) cli_writeint32 ( loc_edi , cli_readint32 ( loc_esi ) ) ;
}
else {
if ( ! CLI_ISCONTAINED ( dest , dsize , loc_edi , ( 0x9c + 24 + 4 * count ) ) || ! CLI_ISCONTAINED ( dest , dsize , loc_esi , ( 0x9c + 0x34 + 4 ) ) ) return - 1 ;
for ( j = 0 ;
j < 0x27 ;
j ++ , loc_esi += 4 , loc_edi += 4 ) cli_writeint32 ( loc_edi , cli_readint32 ( loc_esi ) ) ;
}
save3 = cli_readint32 ( loc_esi + 4 ) ;
paddr = dest + ( ( uint32_t ) cli_readint32 ( loc_edi - 4 ) ) - vma ;
loc_ebx = loc_edi ;
cli_writeint32 ( loc_edi , 0xffffffff ) ;
loc_edi += 4 ;
cli_writeint32 ( loc_edi , 0 ) ;
loc_edi += 4 ;
for ( j = 0 ;
j < 4 ;
j ++ , loc_edi += 4 ) cli_writeint32 ( loc_edi , ( 1 ) ) ;
for ( j = 0 ;
( unsigned int ) j < count ;
j ++ , loc_edi += 4 ) cli_writeint32 ( loc_edi , 0x400 ) ;
loc_edi = dest + cli_readint32 ( loc_esi + 0xc ) - vma ;
if ( upack_version == UPACK_0297729 ) loc_edi = dest + vma - base ;
pushed_esi = loc_edi ;
if ( upack_version == UPACK_0297729 ) {
end_edi = dest + cli_readint32 ( loc_esi + 0x64 ) - vma ;
save3 = cli_readint32 ( loc_esi + 0x40 ) ;
}
else {
end_edi = dest + cli_readint32 ( loc_esi + 0x34 ) - vma ;
}
if ( loc_edi > end_edi ) {
cli_debug ( "Upack: loc_edi > end_edi breaks cli_rebuildpe() bb#11216\n" ) ;
return - 1 ;
}
cli_dbgmsg ( "Upack: data initialized, before upack lzma call!\n" ) ;
if ( ( ret = ( uint32_t ) unupack399 ( dest , dsize , 0 , loc_ebx , 0 , loc_edi , end_edi , shlsize , paddr ) ) == 0xffffffff ) return - 1 ;
}
else {
int ep_jmp_offs , rep_stosd_count_offs , context_bits_offs ;
loc_esi = dest + vma + ep ;
if ( buff [ 0 ] == '\xbe' && buff [ 5 ] == '\xad' && buff [ 6 ] == '\x8b' && buff [ 7 ] == '\xf8' ) upack_version = UPACK_11_12 ;
if ( upack_version == UPACK_11_12 ) {
ep_jmp_offs = 0x1a4 ;
rep_stosd_count_offs = 0x1b ;
context_bits_offs = 0x41 ;
alvalue = loc_esi + 0x184 ;
}
else {
ep_jmp_offs = 0x217 ;
rep_stosd_count_offs = 0x3a ;
context_bits_offs = 0x5f ;
alvalue = loc_esi + 0x1c1 ;
}
if ( ! CLI_ISCONTAINED ( dest , dsize , loc_esi , ep_jmp_offs + 4 ) ) return - 1 ;
save1 = cli_readint32 ( loc_esi + ep_jmp_offs ) ;
original_ep = ( loc_esi - dest ) + ep_jmp_offs + 4 ;
original_ep += ( int32_t ) save1 ;
cli_dbgmsg ( "Upack: EP: %08x original %08x\n" , ep , original_ep ) ;
count = ( * ( loc_esi + rep_stosd_count_offs ) ) & 0xff ;
shlsize = ( * ( loc_esi + context_bits_offs ) ) & 0xff ;
shlsize = 8 - shlsize ;
if ( shlsize < 2 || shlsize > 8 ) {
cli_dbgmsg ( "Upack: context bits out of bounds\n" ) ;
return - 1 ;
}
count *= 0x100 ;
cli_dbgmsg ( "Upack: Context Bits parameter used with lzma: %02x, %02x\n" , shlsize , count ) ;
if ( upack_version == UPACK_399 ) {
loc_esi += 4 ;
loc_ecx = cli_readint32 ( loc_esi + 2 ) ;
cli_writeint32 ( loc_esi + 2 , 0 ) ;
if ( ! loc_ecx ) {
cli_dbgmsg ( "Upack: something's wrong, report back\n" ) ;
return - 1 ;
}
loc_esi -= ( loc_ecx - 2 ) ;
if ( ! CLI_ISCONTAINED ( dest , dsize , loc_esi , 12 ) ) return - 1 ;
cli_dbgmsg ( "Upack: %p %p %08x %08x\n" , loc_esi , dest , cli_readint32 ( loc_esi ) , base ) ;
loc_ebx_u = loc_esi - ( dest + cli_readint32 ( loc_esi ) - base ) ;
cli_dbgmsg ( "Upack: EBX: %08x\n" , loc_ebx_u ) ;
loc_esi += 4 ;
save2 = loc_edi = dest + cli_readint32 ( loc_esi ) - base ;
cli_dbgmsg ( "Upack: DEST: %08x, %08x\n" , cli_readint32 ( loc_esi ) , cli_readint32 ( loc_esi ) - base ) ;
loc_esi += 4 ;
j = cli_readint32 ( loc_esi ) ;
if ( j < 0 ) {
cli_dbgmsg ( "Upack: probably hand-crafted data, report back\n" ) ;
return - 1 ;
}
loc_esi += 4 ;
cli_dbgmsg ( "Upack: ecx counter: %08x\n" , j ) ;
if ( ! CLI_ISCONTAINED ( dest , dsize , loc_esi , ( j * 4 ) ) || ! CLI_ISCONTAINED ( dest , dsize , loc_edi , ( ( j + count ) * 4 ) ) ) return - 1 ;
for ( ;
j -- ;
loc_edi += 4 , loc_esi += 4 ) cli_writeint32 ( loc_edi , cli_readint32 ( loc_esi ) ) ;
if ( ! CLI_ISCONTAINED ( dest , dsize , save2 , 8 ) ) return - 1 ;
loc_ecx = cli_readint32 ( save2 ) ;
save2 += 4 ;
loc_esi = save2 ;
do {
loc_esi += loc_ebx_u ;
loc_esi += 4 ;
}
while ( -- loc_ecx ) ;
if ( ! CLI_ISCONTAINED ( dest , dsize , loc_esi , 4 ) ) return - 1 ;
save1 = cli_readint32 ( loc_esi ) ;
loc_esi += 4 ;
for ( j = 0 ;
( uint32_t ) j < count ;
j ++ , loc_edi += 4 ) cli_writeint32 ( loc_edi , ( save1 ) ) ;
if ( ! CLI_ISCONTAINED ( dest , dsize , ( loc_esi + 0x10 ) , 4 ) ) return - 1 ;
cli_writeint32 ( loc_esi + 0x10 , ( uint32_t ) cli_readint32 ( loc_esi + 0x10 ) + loc_ebx_u ) ;
loc_ebx = loc_esi + 0x14 ;
loc_esi = save2 ;
save_edi = loc_edi = dest + ( ( uint32_t ) cli_readint32 ( loc_esi ) - base ) ;
loc_esi += 4 ;
cli_dbgmsg ( "Upack: before_fixing\n" ) ;
if ( ! CLI_ISCONTAINED ( dest , dsize , loc_ebx - 4 , ( 12 + 4 * 4 ) ) || ! CLI_ISCONTAINED ( dest , dsize , loc_esi + 0x24 , 4 ) || ! CLI_ISCONTAINED ( dest , dsize , loc_esi + 0x40 , 4 ) ) return - 1 ;
for ( j = 2 ;
j < 6 ;
j ++ ) cli_writeint32 ( loc_ebx + ( j << 2 ) , cli_readint32 ( loc_ebx + ( j << 2 ) ) ) ;
paddr = dest + cli_readint32 ( loc_ebx - 4 ) - base ;
save1 = loc_ecx ;
pushed_esi = loc_edi ;
end_edi = dest + cli_readint32 ( loc_esi + 0x24 ) - base ;
vma = cli_readint32 ( loc_ebx ) ;
cli_writeint32 ( loc_ebx , cli_readint32 ( loc_ebx + 4 ) ) ;
cli_writeint32 ( ( loc_ebx + 4 ) , vma ) ;
}
else if ( upack_version == UPACK_11_12 ) {
cli_dbgmsg ( "Upack v 1.1/1.2\n" ) ;
loc_esi = dest + 0x148 ;
loc_edi = dest + cli_readint32 ( loc_esi ) - base ;
loc_esi += 4 ;
save_edi = loc_edi ;
paddr = dest + ( ( uint32_t ) cli_readint32 ( loc_esi ) ) - base ;
loc_esi += 4 ;
loc_edi += 4 ;
loc_ebx = loc_edi ;
if ( ! CLI_ISCONTAINED ( dest , dsize , loc_edi , ( ( 6 + count ) * 4 ) ) ) return - 1 ;
cli_writeint32 ( loc_edi , 0xffffffff ) ;
loc_edi += 4 ;
cli_writeint32 ( loc_edi , 0 ) ;
loc_edi += 4 ;
for ( j = 0 ;
j < 4 ;
j ++ , loc_edi += 4 ) cli_writeint32 ( loc_edi , ( 1 ) ) ;
for ( j = 0 ;
( uint32_t ) j < count ;
j ++ , loc_edi += 4 ) cli_writeint32 ( loc_edi , 0x400 ) ;
loc_edi = dest + cli_readint32 ( loc_esi ) - base ;
pushed_esi = loc_edi ;
loc_esi += 4 ;
loc_ecx = 0 ;
loc_esi += 4 ;
end_edi = dest + cli_readint32 ( loc_esi - 0x28 ) - base ;
loc_esi = save_edi ;
}
if ( loc_edi > end_edi ) {
cli_debug ( "Upack(alt begin): loc_edi > end_edi breaks cli_rebuildpe() bb#11216\n" ) ;
return - 1 ;
}
cli_dbgmsg ( "Upack: data initialized, before upack lzma call!\n" ) ;
if ( ( ret = ( uint32_t ) unupack399 ( dest , dsize , loc_ecx , loc_ebx , loc_ecx , loc_edi , end_edi , shlsize , paddr ) ) == 0xffffffff ) return - 1 ;
if ( upack_version == UPACK_399 ) save3 = cli_readint32 ( loc_esi + 0x40 ) ;
else if ( upack_version == UPACK_11_12 ) save3 = cli_readint32 ( dest + vma + ep + 0x174 ) ;
}
loc_ecx = 0 ;
if ( ! CLI_ISCONTAINED ( dest , dsize , alvalue , 1 ) ) {
cli_dbgmsg ( "Upack: alvalue out of bounds\n" ) ;
return - 1 ;
}
searchval = * alvalue & 0xff ;
cli_dbgmsg ( "Upack: loops: %08x search value: %02x\n" , save3 , searchval ) ;
while ( save3 ) {
if ( ! CLI_ISCONTAINED ( dest , dsize , pushed_esi + loc_ecx , 1 ) ) {
cli_dbgmsg ( "Upack: callfixerr %p %08x = %p, %p\n" , dest , dsize , dest + dsize , pushed_esi + loc_ecx ) ;
return - 1 ;
}
if ( pushed_esi [ loc_ecx ] == '\xe8' || pushed_esi [ loc_ecx ] == '\xe9' ) {
char * adr = ( pushed_esi + loc_ecx + 1 ) ;
loc_ecx ++ ;
if ( ! CLI_ISCONTAINED ( dest , dsize , adr , 4 ) ) {
cli_dbgmsg ( "Upack: callfixerr\n" ) ;
return - 1 ;
}
if ( ( cli_readint32 ( adr ) & 0xff ) != searchval ) continue ;
cli_writeint32 ( adr , EC32 ( CE32 ( ( uint32_t ) ( cli_readint32 ( adr ) & 0xffffff00 ) ) ) - loc_ecx - 4 ) ;
loc_ecx += 4 ;
save3 -- ;
}
else loc_ecx ++ ;
}
section . raw = 0 ;
section . rva = va ;
section . rsz = end_edi - loc_edi ;
section . vsz = end_edi - loc_edi ;
if ( ! cli_rebuildpe ( dest + ( upack ? 0 : va ) , & section , 1 , base , original_ep , 0 , 0 , file ) ) {
cli_dbgmsg ( "Upack: Rebuilding failed\n" ) ;
return 0 ;
}
return 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static GFile * get_target_file_for_link ( GFile * src , GFile * dest_dir , const char * dest_fs_type , int count ) {
const char * editname ;
char * basename , * new_name ;
GFileInfo * info ;
GFile * dest ;
int max_length ;
max_length = get_max_name_length ( dest_dir ) ;
dest = NULL ;
info = g_file_query_info ( src , G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME , 0 , NULL , NULL ) ;
if ( info != NULL ) {
editname = g_file_info_get_attribute_string ( info , G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME ) ;
if ( editname != NULL ) {
new_name = get_link_name ( editname , count , max_length ) ;
make_file_name_valid_for_dest_fs ( new_name , dest_fs_type ) ;
dest = g_file_get_child_for_display_name ( dest_dir , new_name , NULL ) ;
g_free ( new_name ) ;
}
g_object_unref ( info ) ;
}
if ( dest == NULL ) {
basename = g_file_get_basename ( src ) ;
make_file_name_valid_for_dest_fs ( basename , dest_fs_type ) ;
if ( g_utf8_validate ( basename , - 1 , NULL ) ) {
new_name = get_link_name ( basename , count , max_length ) ;
make_file_name_valid_for_dest_fs ( new_name , dest_fs_type ) ;
dest = g_file_get_child_for_display_name ( dest_dir , new_name , NULL ) ;
g_free ( new_name ) ;
}
if ( dest == NULL ) {
if ( count == 1 ) {
new_name = g_strdup_printf ( "%s.lnk" , basename ) ;
}
else {
new_name = g_strdup_printf ( "%s.lnk%d" , basename , count ) ;
}
make_file_name_valid_for_dest_fs ( new_name , dest_fs_type ) ;
dest = g_file_get_child ( dest_dir , new_name ) ;
g_free ( new_name ) ;
}
g_free ( basename ) ;
}
return dest ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int archive_read_format_cpio_bid ( struct archive_read * a , int best_bid ) {
const unsigned char * p ;
struct cpio * cpio ;
int bid ;
( void ) best_bid ;
cpio = ( struct cpio * ) ( a -> format -> data ) ;
if ( ( p = __archive_read_ahead ( a , 6 , NULL ) ) == NULL ) return ( - 1 ) ;
bid = 0 ;
if ( memcmp ( p , "070707" , 6 ) == 0 ) {
cpio -> read_header = header_odc ;
bid += 48 ;
}
else if ( memcmp ( p , "070727" , 6 ) == 0 ) {
cpio -> read_header = header_odc ;
bid += 48 ;
}
else if ( memcmp ( p , "070701" , 6 ) == 0 ) {
cpio -> read_header = header_newc ;
bid += 48 ;
}
else if ( memcmp ( p , "070702" , 6 ) == 0 ) {
cpio -> read_header = header_newc ;
bid += 48 ;
}
else if ( p [ 0 ] * 256 + p [ 1 ] == 070707 ) {
cpio -> read_header = header_bin_be ;
bid += 16 ;
}
else if ( p [ 0 ] + p [ 1 ] * 256 == 070707 ) {
cpio -> read_header = header_bin_le ;
bid += 16 ;
}
else return ( ARCHIVE_WARN ) ;
return ( bid ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int selinux_inode_getxattr ( struct dentry * dentry , const char * name ) {
const struct cred * cred = current_cred ( ) ;
return dentry_has_perm ( cred , dentry , FILE__GETATTR ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h225_LocationRequest ( 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_LocationRequest , LocationRequest_sequence ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void compute_precache_lut ( uint8_t * output , uint16_t * table , int length ) {
uint32_t v = 0 ;
for ( v = 0 ;
v < PRECACHE_OUTPUT_SIZE ;
v ++ ) {
output [ v ] = lut_interp_linear_precache_output ( v , table , length ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
Expr * get_notclausearg ( Expr * notclause ) {
return linitial ( ( ( BoolExpr * ) notclause ) -> args ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int32_t u_scanf_simple_percent_handler ( UFILE * input , u_scanf_spec_info * info , ufmt_args * args , const UChar * fmt , int32_t * fmtConsumed , int32_t * argConverted ) {
* argConverted = 0 ;
if ( u_fgetc ( input ) != 0x0025 ) {
* argConverted = - 1 ;
}
return 1 ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void vapic_register ( void ) {
type_register_static ( & vapic_type ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
SPL_METHOD ( FilesystemIterator , current ) {
spl_filesystem_object * intern = ( spl_filesystem_object * ) zend_object_store_get_object ( getThis ( ) TSRMLS_CC ) ;
if ( zend_parse_parameters_none ( ) == FAILURE ) {
return ;
}
if ( SPL_FILE_DIR_CURRENT ( intern , SPL_FILE_DIR_CURRENT_AS_PATHNAME ) ) {
spl_filesystem_object_get_file_name ( intern TSRMLS_CC ) ;
RETURN_STRINGL ( intern -> file_name , intern -> file_name_len , 1 ) ;
}
else if ( SPL_FILE_DIR_CURRENT ( intern , SPL_FILE_DIR_CURRENT_AS_FILEINFO ) ) {
spl_filesystem_object_get_file_name ( intern TSRMLS_CC ) ;
spl_filesystem_object_create_type ( 0 , intern , SPL_FS_INFO , NULL , return_value TSRMLS_CC ) ;
}
else {
RETURN_ZVAL ( getThis ( ) , 1 , 0 ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void mime_hdr_field_attach ( MIMEHdrImpl * mh , MIMEField * field , int check_for_dups , MIMEField * prev_dup ) {
MIME_HDR_SANITY_CHECK ( mh ) ;
if ( ! field -> is_detached ( ) ) {
return ;
}
ink_assert ( field -> m_ptr_name != nullptr ) ;
if ( check_for_dups || ( prev_dup && ( ! prev_dup -> is_dup_head ( ) ) ) ) {
int length ;
const char * name = mime_field_name_get ( field , & length ) ;
prev_dup = mime_hdr_field_find ( mh , name , length ) ;
ink_assert ( ( prev_dup == nullptr ) || ( prev_dup -> is_dup_head ( ) ) ) ;
}
field -> m_readiness = MIME_FIELD_SLOT_READINESS_LIVE ;
if ( prev_dup ) {
MIMEField * next_dup ;
int field_slotnum , prev_slotnum , next_slotnum ;
field_slotnum = mime_hdr_field_slotnum ( mh , field ) ;
prev_slotnum = mime_hdr_field_slotnum ( mh , prev_dup ) ;
next_dup = prev_dup -> m_next_dup ;
next_slotnum = ( next_dup ? mime_hdr_field_slotnum ( mh , next_dup ) : - 1 ) ;
ink_assert ( field_slotnum != prev_slotnum ) ;
while ( prev_slotnum < field_slotnum ) {
if ( next_dup == nullptr ) {
break ;
}
if ( next_slotnum > field_slotnum ) {
break ;
}
prev_dup = next_dup ;
prev_slotnum = next_slotnum ;
next_dup = prev_dup -> m_next_dup ;
}
if ( prev_slotnum > field_slotnum ) {
field -> m_flags = ( field -> m_flags | MIME_FIELD_SLOT_FLAGS_DUP_HEAD ) ;
field -> m_next_dup = prev_dup ;
prev_dup -> m_flags = ( prev_dup -> m_flags & ~ MIME_FIELD_SLOT_FLAGS_DUP_HEAD ) ;
mime_hdr_set_accelerators_and_presence_bits ( mh , field ) ;
}
else {
ink_assert ( prev_slotnum < field_slotnum ) ;
ink_assert ( ( next_dup == nullptr ) || ( next_slotnum > field_slotnum ) ) ;
field -> m_flags = ( field -> m_flags & ~ MIME_FIELD_SLOT_FLAGS_DUP_HEAD ) ;
ink_assert ( ( next_dup == nullptr ) || next_dup -> is_live ( ) ) ;
prev_dup -> m_next_dup = field ;
field -> m_next_dup = next_dup ;
}
}
else {
field -> m_flags = ( field -> m_flags | MIME_FIELD_SLOT_FLAGS_DUP_HEAD ) ;
mime_hdr_set_accelerators_and_presence_bits ( mh , field ) ;
}
ink_assert ( field -> is_live ( ) ) ;
if ( field -> m_ptr_value && field -> is_cooked ( ) ) {
mh -> recompute_cooked_stuff ( field ) ;
}
MIME_HDR_SANITY_CHECK ( mh ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void usage_exit ( ) {
fprintf ( stderr , "Usage: %s <codec> <width> <height> <infile> <outfile> " "<keyframe-interval> [<error-resilient>]\nSee comments in " "simple_encoder.c for more information.\n" , exec_name ) ;
exit ( EXIT_FAILURE ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static MAIN_WINDOW_REC * mainwindows_find_left_upper ( MAIN_WINDOW_REC * window ) {
MAIN_WINDOW_REC * best ;
best = mainwindows_find_left ( window , FALSE ) ;
if ( best == NULL ) best = mainwindows_find_left ( mainwindows_find_upper ( window ) , TRUE ) ;
return best ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_T_tableEntryCapacityExceeded ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_choice ( tvb , offset , actx , tree , hf_index , ett_h245_T_tableEntryCapacityExceeded , T_tableEntryCapacityExceeded_choice , NULL ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void jbig2_global_ctx_free ( Jbig2GlobalCtx * global_ctx ) {
jbig2_ctx_free ( ( Jbig2Ctx * ) global_ctx ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static size_t unquote_string ( const char * string , size_t length , unsigned char * buf ) {
int esc = 0 ;
const unsigned char * s = ( const unsigned char * ) string ;
unsigned char * d = buf ;
size_t n = length ;
for ( ;
n ;
n -- , s ++ ) {
if ( esc ) {
switch ( * s ) {
case 'b' : * d ++ = '\b' ;
break ;
case 't' : * d ++ = '\t' ;
break ;
case 'v' : * d ++ = '\v' ;
break ;
case 'n' : * d ++ = '\n' ;
break ;
case 'f' : * d ++ = '\f' ;
break ;
case 'r' : * d ++ = '\r' ;
break ;
case '"' : * d ++ = '\"' ;
break ;
case '\'' : * d ++ = '\'' ;
break ;
case '\\' : * d ++ = '\\' ;
break ;
case '\r' : if ( n > 1 && s [ 1 ] == '\n' ) {
s ++ ;
n -- ;
}
break ;
case '\n' : if ( n > 1 && s [ 1 ] == '\r' ) {
s ++ ;
n -- ;
}
break ;
case 'x' : if ( n > 2 && hexdigitp ( s + 1 ) && hexdigitp ( s + 2 ) ) {
s ++ ;
n -- ;
* d ++ = xtoi_2 ( s ) ;
s ++ ;
n -- ;
}
break ;
default : if ( n > 2 && octdigitp ( s ) && octdigitp ( s + 1 ) && octdigitp ( s + 2 ) ) {
* d ++ = ( atoi_1 ( s ) * 64 ) + ( atoi_1 ( s + 1 ) * 8 ) + atoi_1 ( s + 2 ) ;
s += 2 ;
n -= 2 ;
}
break ;
}
esc = 0 ;
}
else if ( * s == '\\' ) esc = 1 ;
else * d ++ = * s ;
}
return d - buf ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( ImmersiveModeControllerAshTest , EnabledCommands ) {
ASSERT_FALSE ( controller ( ) -> IsEnabled ( ) ) ;
EXPECT_TRUE ( chrome : : IsCommandEnabled ( browser ( ) , IDC_OPEN_CURRENT_URL ) ) ;
EXPECT_TRUE ( chrome : : IsCommandEnabled ( browser ( ) , IDC_ABOUT ) ) ;
EXPECT_TRUE ( chrome : : IsCommandEnabled ( browser ( ) , IDC_FOCUS_LOCATION ) ) ;
ToggleFullscreen ( ) ;
EXPECT_TRUE ( controller ( ) -> IsEnabled ( ) ) ;
EXPECT_TRUE ( chrome : : IsCommandEnabled ( browser ( ) , IDC_OPEN_CURRENT_URL ) ) ;
EXPECT_TRUE ( chrome : : IsCommandEnabled ( browser ( ) , IDC_ABOUT ) ) ;
EXPECT_TRUE ( chrome : : IsCommandEnabled ( browser ( ) , IDC_FOCUS_LOCATION ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int evutil_vsnprintf ( char * buf , size_t buflen , const char * format , va_list ap ) {
# ifdef _MSC_VER int r = _vsnprintf ( buf , buflen , format , ap ) ;
buf [ buflen - 1 ] = '\0' ;
if ( r >= 0 ) return r ;
else return _vscprintf ( format , ap ) ;
# else int r = vsnprintf ( buf , buflen , format , ap ) ;
buf [ buflen - 1 ] = '\0' ;
return r ;
# endif }
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int row_prop_exists ( zval * object , zval * member , int check_empty , const zend_literal * key TSRMLS_DC ) {
pdo_stmt_t * stmt = ( pdo_stmt_t * ) zend_object_store_get_object ( object TSRMLS_CC ) ;
int colno = - 1 ;
if ( stmt ) {
if ( Z_TYPE_P ( member ) == IS_LONG ) {
return Z_LVAL_P ( member ) >= 0 && Z_LVAL_P ( member ) < stmt -> column_count ;
}
else {
convert_to_string ( member ) ;
for ( colno = 0 ;
colno < stmt -> column_count ;
colno ++ ) {
if ( strcmp ( stmt -> columns [ colno ] . name , Z_STRVAL_P ( member ) ) == 0 ) {
int res ;
zval * val ;
MAKE_STD_ZVAL ( val ) ;
fetch_value ( stmt , val , colno , NULL TSRMLS_CC ) ;
res = check_empty ? i_zend_is_true ( val ) : Z_TYPE_P ( val ) != IS_NULL ;
zval_ptr_dtor ( & val ) ;
return res ;
}
}
}
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int vp9_get_compressed_data ( VP9_COMP * cpi , unsigned int * frame_flags , size_t * size , uint8_t * dest , int64_t * time_stamp , int64_t * time_end , int flush ) {
const VP9EncoderConfig * const oxcf = & cpi -> oxcf ;
VP9_COMMON * const cm = & cpi -> common ;
MACROBLOCKD * const xd = & cpi -> mb . e_mbd ;
RATE_CONTROL * const rc = & cpi -> rc ;
struct vpx_usec_timer cmptimer ;
YV12_BUFFER_CONFIG * force_src_buffer = NULL ;
struct lookahead_entry * last_source = NULL ;
struct lookahead_entry * source = NULL ;
MV_REFERENCE_FRAME ref_frame ;
int arf_src_index ;
if ( is_two_pass_svc ( cpi ) ) {
# if CONFIG_SPATIAL_SVC vp9_svc_start_frame ( cpi ) ;
# endif if ( oxcf -> pass == 2 ) vp9_restore_layer_context ( cpi ) ;
}
vpx_usec_timer_start ( & cmptimer ) ;
vp9_set_high_precision_mv ( cpi , ALTREF_HIGH_PRECISION_MV ) ;
cm -> reset_frame_context = 0 ;
cm -> refresh_frame_context = 1 ;
cpi -> refresh_last_frame = 1 ;
cpi -> refresh_golden_frame = 0 ;
cpi -> refresh_alt_ref_frame = 0 ;
arf_src_index = get_arf_src_index ( cpi ) ;
if ( arf_src_index ) {
assert ( arf_src_index <= rc -> frames_to_key ) ;
if ( ( source = vp9_lookahead_peek ( cpi -> lookahead , arf_src_index ) ) != NULL ) {
cpi -> alt_ref_source = source ;
# if CONFIG_SPATIAL_SVC if ( is_two_pass_svc ( cpi ) && cpi -> svc . spatial_layer_id > 0 ) {
int i ;
for ( i = cpi -> svc . spatial_layer_id - 1 ;
i >= 0 ;
-- i ) {
if ( oxcf -> ss_play_alternate [ i ] ) {
cpi -> gld_fb_idx = cpi -> svc . layer_context [ i ] . alt_ref_idx ;
break ;
}
}
}
cpi -> svc . layer_context [ cpi -> svc . spatial_layer_id ] . has_alt_frame = 1 ;
# endif if ( oxcf -> arnr_max_frames > 0 ) {
vp9_temporal_filter ( cpi , arf_src_index ) ;
vp9_extend_frame_borders ( & cpi -> alt_ref_buffer ) ;
force_src_buffer = & cpi -> alt_ref_buffer ;
}
cm -> show_frame = 0 ;
cpi -> refresh_alt_ref_frame = 1 ;
cpi -> refresh_golden_frame = 0 ;
cpi -> refresh_last_frame = 0 ;
rc -> is_src_frame_alt_ref = 0 ;
rc -> source_alt_ref_pending = 0 ;
}
else {
rc -> source_alt_ref_pending = 0 ;
}
}
if ( ! source ) {
if ( cm -> current_video_frame > 0 ) {
if ( ( last_source = vp9_lookahead_peek ( cpi -> lookahead , - 1 ) ) == NULL ) return - 1 ;
}
# if CONFIG_SPATIAL_SVC if ( is_two_pass_svc ( cpi ) ) source = vp9_svc_lookahead_pop ( cpi , cpi -> lookahead , flush ) ;
else # endif source = vp9_lookahead_pop ( cpi -> lookahead , flush ) ;
if ( source != NULL ) {
cm -> show_frame = 1 ;
cm -> intra_only = 0 ;
check_src_altref ( cpi , source ) ;
}
}
if ( source ) {
cpi -> un_scaled_source = cpi -> Source = force_src_buffer ? force_src_buffer : & source -> img ;
cpi -> unscaled_last_source = last_source != NULL ? & last_source -> img : NULL ;
* time_stamp = source -> ts_start ;
* time_end = source -> ts_end ;
* frame_flags = ( source -> flags & VPX_EFLAG_FORCE_KF ) ? FRAMEFLAGS_KEY : 0 ;
}
else {
* size = 0 ;
if ( flush && oxcf -> pass == 1 && ! cpi -> twopass . first_pass_done ) {
vp9_end_first_pass ( cpi ) ;
cpi -> twopass . first_pass_done = 1 ;
}
return - 1 ;
}
if ( source -> ts_start < cpi -> first_time_stamp_ever ) {
cpi -> first_time_stamp_ever = source -> ts_start ;
cpi -> last_end_time_stamp_seen = source -> ts_start ;
}
vp9_clear_system_state ( ) ;
if ( cm -> show_frame ) {
adjust_frame_rate ( cpi , source ) ;
}
if ( cpi -> svc . number_temporal_layers > 1 && oxcf -> rc_mode == VPX_CBR ) {
vp9_update_temporal_layer_framerate ( cpi ) ;
vp9_restore_layer_context ( cpi ) ;
}
* size = 0 ;
cm -> frame_bufs [ cm -> new_fb_idx ] . ref_count -- ;
cm -> new_fb_idx = get_free_fb ( cm ) ;
if ( ( oxcf -> pass == 2 ) && ( ! cpi -> use_svc || is_two_pass_svc ( cpi ) ) ) {
vp9_rc_get_second_pass_params ( cpi ) ;
}
if ( ! cpi -> use_svc && cpi -> multi_arf_allowed ) {
if ( cm -> frame_type == KEY_FRAME ) {
init_buffer_indices ( cpi ) ;
}
else if ( oxcf -> pass == 2 ) {
const GF_GROUP * const gf_group = & cpi -> twopass . gf_group ;
cpi -> alt_fb_idx = gf_group -> arf_ref_idx [ gf_group -> index ] ;
}
}
cpi -> frame_flags = * frame_flags ;
if ( oxcf -> pass == 2 && cm -> current_video_frame == 0 && oxcf -> allow_spatial_resampling && oxcf -> rc_mode == VPX_VBR ) {
vp9_set_size_literal ( cpi , oxcf -> scaled_frame_width , oxcf -> scaled_frame_height ) ;
}
vp9_realloc_frame_buffer ( get_frame_new_buffer ( cm ) , cm -> width , cm -> height , cm -> subsampling_x , cm -> subsampling_y , # if CONFIG_VP9_HIGHBITDEPTH cm -> use_highbitdepth , # endif VP9_ENC_BORDER_IN_PIXELS , NULL , NULL , NULL ) ;
alloc_util_frame_buffers ( cpi ) ;
init_motion_estimation ( cpi ) ;
for ( ref_frame = LAST_FRAME ;
ref_frame <= ALTREF_FRAME ;
++ ref_frame ) {
const int idx = cm -> ref_frame_map [ get_ref_frame_idx ( cpi , ref_frame ) ] ;
YV12_BUFFER_CONFIG * const buf = & cm -> frame_bufs [ idx ] . buf ;
RefBuffer * const ref_buf = & cm -> frame_refs [ ref_frame - 1 ] ;
ref_buf -> buf = buf ;
ref_buf -> idx = idx ;
# if CONFIG_VP9_HIGHBITDEPTH vp9_setup_scale_factors_for_frame ( & ref_buf -> sf , buf -> y_crop_width , buf -> y_crop_height , cm -> width , cm -> height , ( buf -> flags & YV12_FLAG_HIGHBITDEPTH ) ? : 0 ) ;
# else vp9_setup_scale_factors_for_frame ( & ref_buf -> sf , buf -> y_crop_width , buf -> y_crop_height , cm -> width , cm -> height ) ;
# endif if ( vp9_is_scaled ( & ref_buf -> sf ) ) vp9_extend_frame_borders ( buf ) ;
}
set_ref_ptrs ( cm , xd , LAST_FRAME , LAST_FRAME ) ;
if ( oxcf -> aq_mode == VARIANCE_AQ ) {
vp9_vaq_init ( ) ;
}
if ( oxcf -> pass == 1 && ( ! cpi -> use_svc || is_two_pass_svc ( cpi ) ) ) {
const int lossless = is_lossless_requested ( oxcf ) ;
# if CONFIG_VP9_HIGHBITDEPTH if ( cpi -> oxcf . use_highbitdepth ) cpi -> mb . fwd_txm4x4 = lossless ? vp9_high_fwht4x4 : vp9_high_fdct4x4 ;
else cpi -> mb . fwd_txm4x4 = lossless ? vp9_fwht4x4 : vp9_fdct4x4 ;
cpi -> mb . high_itxm_add = lossless ? vp9_high_iwht4x4_add : vp9_high_idct4x4_add ;
# else cpi -> mb . fwd_txm4x4 = lossless ? vp9_fwht4x4 : vp9_fdct4x4 ;
# endif cpi -> mb . itxm_add = lossless ? vp9_iwht4x4_add : vp9_idct4x4_add ;
vp9_first_pass ( cpi , source ) ;
}
else if ( oxcf -> pass == 2 && ( ! cpi -> use_svc || is_two_pass_svc ( cpi ) ) ) {
Pass2Encode ( cpi , size , dest , frame_flags ) ;
}
else if ( cpi -> use_svc ) {
SvcEncode ( cpi , size , dest , frame_flags ) ;
}
else {
Pass0Encode ( cpi , size , dest , frame_flags ) ;
}
if ( cm -> refresh_frame_context ) cm -> frame_contexts [ cm -> frame_context_idx ] = cm -> fc ;
if ( * size == 0 ) {
release_scaled_references ( cpi ) ;
}
if ( * size > 0 ) {
cpi -> droppable = ! frame_is_reference ( cpi ) ;
}
if ( ( cpi -> svc . number_temporal_layers > 1 && oxcf -> rc_mode == VPX_CBR ) || ( ( cpi -> svc . number_temporal_layers > 1 || cpi -> svc . number_spatial_layers > 1 ) && oxcf -> pass == 2 ) ) {
vp9_save_layer_context ( cpi ) ;
}
vpx_usec_timer_mark ( & cmptimer ) ;
cpi -> time_compress_data += vpx_usec_timer_elapsed ( & cmptimer ) ;
if ( cpi -> b_calculate_psnr && oxcf -> pass != 1 && cm -> show_frame ) generate_psnr_packet ( cpi ) ;
# if CONFIG_INTERNAL_STATS if ( oxcf -> pass != 1 ) {
cpi -> bytes += ( int ) ( * size ) ;
if ( cm -> show_frame ) {
cpi -> count ++ ;
if ( cpi -> b_calculate_psnr ) {
YV12_BUFFER_CONFIG * orig = cpi -> Source ;
YV12_BUFFER_CONFIG * recon = cpi -> common . frame_to_show ;
YV12_BUFFER_CONFIG * pp = & cm -> post_proc_buffer ;
PSNR_STATS psnr ;
calc_psnr ( orig , recon , & psnr ) ;
cpi -> total += psnr . psnr [ 0 ] ;
cpi -> total_y += psnr . psnr [ 1 ] ;
cpi -> total_u += psnr . psnr [ 2 ] ;
cpi -> total_v += psnr . psnr [ 3 ] ;
cpi -> total_sq_error += psnr . sse [ 0 ] ;
cpi -> total_samples += psnr . samples [ 0 ] ;
{
PSNR_STATS psnr2 ;
double frame_ssim2 = 0 , weight = 0 ;
# if CONFIG_VP9_POSTPROC vp9_deblock ( cm -> frame_to_show , & cm -> post_proc_buffer , cm -> lf . filter_level * 10 / 6 ) ;
# endif vp9_clear_system_state ( ) ;
calc_psnr ( orig , pp , & psnr2 ) ;
cpi -> totalp += psnr2 . psnr [ 0 ] ;
cpi -> totalp_y += psnr2 . psnr [ 1 ] ;
cpi -> totalp_u += psnr2 . psnr [ 2 ] ;
cpi -> totalp_v += psnr2 . psnr [ 3 ] ;
cpi -> totalp_sq_error += psnr2 . sse [ 0 ] ;
cpi -> totalp_samples += psnr2 . samples [ 0 ] ;
frame_ssim2 = vp9_calc_ssim ( orig , recon , & weight ) ;
cpi -> summed_quality += frame_ssim2 * weight ;
cpi -> summed_weights += weight ;
frame_ssim2 = vp9_calc_ssim ( orig , & cm -> post_proc_buffer , & weight ) ;
cpi -> summedp_quality += frame_ssim2 * weight ;
cpi -> summedp_weights += weight ;
# if 0 {
FILE * f = fopen ( "q_used.stt" , "a" ) ;
fprintf ( f , "%5d : Y%f7.3:U%f7.3:V%f7.3:F%f7.3:S%7.3f\n" , cpi -> common . current_video_frame , y2 , u2 , v2 , frame_psnr2 , frame_ssim2 ) ;
fclose ( f ) ;
}
# endif }
}
if ( cpi -> b_calculate_ssimg ) {
double y , u , v , frame_all ;
frame_all = vp9_calc_ssimg ( cpi -> Source , cm -> frame_to_show , & y , & u , & v ) ;
cpi -> total_ssimg_y += y ;
cpi -> total_ssimg_u += u ;
cpi -> total_ssimg_v += v ;
cpi -> total_ssimg_all += frame_all ;
}
}
}
# endif if ( is_two_pass_svc ( cpi ) && cm -> show_frame ) {
++ cpi -> svc . spatial_layer_to_encode ;
if ( cpi -> svc . spatial_layer_to_encode >= cpi -> svc . number_spatial_layers ) cpi -> svc . spatial_layer_to_encode = 0 ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void dumpustr ( FILE * file , char * utf8_str ) {
unichar_t * ustr = utf82u_copy ( utf8_str ) , * pt = ustr ;
do {
putc ( * pt >> 8 , file ) ;
putc ( * pt & 0xff , file ) ;
}
while ( * pt ++ != '\0' ) ;
free ( ustr ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static Selectivity calc_arraycontsel ( VariableStatData * vardata , Datum constval , Oid elemtype , Oid operator ) {
Selectivity selec ;
TypeCacheEntry * typentry ;
FmgrInfo * cmpfunc ;
ArrayType * array ;
typentry = lookup_type_cache ( elemtype , TYPECACHE_CMP_PROC_FINFO ) ;
if ( ! OidIsValid ( typentry -> cmp_proc_finfo . fn_oid ) ) return DEFAULT_SEL ( operator ) ;
cmpfunc = & typentry -> cmp_proc_finfo ;
array = DatumGetArrayTypeP ( constval ) ;
if ( HeapTupleIsValid ( vardata -> statsTuple ) ) {
Form_pg_statistic stats ;
Datum * values ;
int nvalues ;
float4 * numbers ;
int nnumbers ;
float4 * hist ;
int nhist ;
stats = ( Form_pg_statistic ) GETSTRUCT ( vardata -> statsTuple ) ;
if ( get_attstatsslot ( vardata -> statsTuple , elemtype , vardata -> atttypmod , STATISTIC_KIND_MCELEM , InvalidOid , NULL , & values , & nvalues , & numbers , & nnumbers ) ) {
if ( operator != OID_ARRAY_CONTAINED_OP || ! get_attstatsslot ( vardata -> statsTuple , elemtype , vardata -> atttypmod , STATISTIC_KIND_DECHIST , InvalidOid , NULL , NULL , NULL , & hist , & nhist ) ) {
hist = NULL ;
nhist = 0 ;
}
selec = mcelem_array_selec ( array , typentry , values , nvalues , numbers , nnumbers , hist , nhist , operator , cmpfunc ) ;
if ( hist ) free_attstatsslot ( elemtype , NULL , 0 , hist , nhist ) ;
free_attstatsslot ( elemtype , values , nvalues , numbers , nnumbers ) ;
}
else {
selec = mcelem_array_selec ( array , typentry , NULL , 0 , NULL , 0 , NULL , 0 , operator , cmpfunc ) ;
}
selec *= ( 1.0 - stats -> stanullfrac ) ;
}
else {
selec = mcelem_array_selec ( array , typentry , NULL , 0 , NULL , 0 , NULL , 0 , operator , cmpfunc ) ;
}
if ( PointerGetDatum ( array ) != constval ) pfree ( array ) ;
return selec ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int set_palette ( BethsoftvidContext * ctx ) {
uint32_t * palette = ( uint32_t * ) ctx -> frame . data [ 1 ] ;
int a ;
if ( bytestream2_get_bytes_left ( & ctx -> g ) < 256 * 3 ) return AVERROR_INVALIDDATA ;
for ( a = 0 ;
a < 256 ;
a ++ ) {
palette [ a ] = bytestream2_get_be24u ( & ctx -> g ) * 4 ;
}
ctx -> frame . palette_has_changed = 1 ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int getnetnum ( const char * num , sockaddr_u * addr , int complain , enum gnn_type a_type ) {
NTP_REQUIRE ( AF_UNSPEC == AF ( addr ) || AF_INET == AF ( addr ) || AF_INET6 == AF ( addr ) ) ;
if ( ! is_ip_address ( num , AF ( addr ) , addr ) ) return 0 ;
if ( IS_IPV6 ( addr ) && ! ipv6_works ) return - 1 ;
# ifdef ISC_PLATFORM_HAVESALEN addr -> sa . sa_len = SIZEOF_SOCKADDR ( AF ( addr ) ) ;
# endif SET_PORT ( addr , NTP_PORT ) ;
DPRINTF ( 2 , ( "getnetnum given %s, got %s\n" , num , stoa ( addr ) ) ) ;
return 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int matroska_read_seek ( AVFormatContext * s , int stream_index , int64_t timestamp , int flags ) {
MatroskaDemuxContext * matroska = s -> priv_data ;
MatroskaTrack * tracks = NULL ;
AVStream * st = s -> streams [ stream_index ] ;
int i , index , index_sub , index_min ;
if ( matroska -> cues_parsing_deferred ) {
matroska_parse_cues ( matroska ) ;
matroska -> cues_parsing_deferred = 0 ;
}
if ( ! st -> nb_index_entries ) return 0 ;
timestamp = FFMAX ( timestamp , st -> index_entries [ 0 ] . timestamp ) ;
if ( ( index = av_index_search_timestamp ( st , timestamp , flags ) ) < 0 ) {
avio_seek ( s -> pb , st -> index_entries [ st -> nb_index_entries - 1 ] . pos , SEEK_SET ) ;
matroska -> current_id = 0 ;
while ( ( index = av_index_search_timestamp ( st , timestamp , flags ) ) < 0 ) {
matroska_clear_queue ( matroska ) ;
if ( matroska_parse_cluster ( matroska ) < 0 ) break ;
}
}
matroska_clear_queue ( matroska ) ;
if ( index < 0 ) return 0 ;
index_min = index ;
tracks = matroska -> tracks . elem ;
for ( i = 0 ;
i < matroska -> tracks . nb_elem ;
i ++ ) {
tracks [ i ] . audio . pkt_cnt = 0 ;
tracks [ i ] . audio . sub_packet_cnt = 0 ;
tracks [ i ] . audio . buf_timecode = AV_NOPTS_VALUE ;
tracks [ i ] . end_timecode = 0 ;
if ( tracks [ i ] . type == MATROSKA_TRACK_TYPE_SUBTITLE && tracks [ i ] . stream -> discard != AVDISCARD_ALL ) {
index_sub = av_index_search_timestamp ( tracks [ i ] . stream , st -> index_entries [ index ] . timestamp , AVSEEK_FLAG_BACKWARD ) ;
if ( index_sub >= 0 && st -> index_entries [ index_sub ] . pos < st -> index_entries [ index_min ] . pos && st -> index_entries [ index ] . timestamp - st -> index_entries [ index_sub ] . timestamp < 30000000000 / matroska -> time_scale ) index_min = index_sub ;
}
}
avio_seek ( s -> pb , st -> index_entries [ index_min ] . pos , SEEK_SET ) ;
matroska -> current_id = 0 ;
matroska -> skip_to_keyframe = ! ( flags & AVSEEK_FLAG_ANY ) ;
matroska -> skip_to_timecode = st -> index_entries [ index ] . timestamp ;
matroska -> done = 0 ;
ff_update_cur_dts ( s , st , st -> index_entries [ index ] . timestamp ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int aes_cfb_cipher ( EVP_CIPHER_CTX * ctx , unsigned char * out , const unsigned char * in , size_t len ) {
EVP_AES_KEY * dat = EVP_C_DATA ( EVP_AES_KEY , ctx ) ;
int num = EVP_CIPHER_CTX_num ( ctx ) ;
CRYPTO_cfb128_encrypt ( in , out , len , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , & num , EVP_CIPHER_CTX_encrypting ( ctx ) , dat -> block ) ;
EVP_CIPHER_CTX_set_num ( ctx , num ) ;
return 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int optimize_b ( MACROBLOCK * mb , int plane , int block , TX_SIZE tx_size , int ctx ) {
MACROBLOCKD * const xd = & mb -> e_mbd ;
struct macroblock_plane * const p = & mb -> plane [ plane ] ;
struct macroblockd_plane * const pd = & xd -> plane [ plane ] ;
const int ref = is_inter_block ( & xd -> mi [ 0 ] . src_mi -> mbmi ) ;
vp9_token_state tokens [ 1025 ] [ 2 ] ;
unsigned best_index [ 1025 ] [ 2 ] ;
uint8_t token_cache [ 1024 ] ;
const tran_low_t * const coeff = BLOCK_OFFSET ( mb -> plane [ plane ] . coeff , block ) ;
tran_low_t * const qcoeff = BLOCK_OFFSET ( p -> qcoeff , block ) ;
tran_low_t * const dqcoeff = BLOCK_OFFSET ( pd -> dqcoeff , block ) ;
const int eob = p -> eobs [ block ] ;
const PLANE_TYPE type = pd -> plane_type ;
const int default_eob = 16 << ( tx_size << 1 ) ;
const int mul = 1 + ( tx_size == TX_32X32 ) ;
const int16_t * dequant_ptr = pd -> dequant ;
const uint8_t * const band_translate = get_band_translate ( tx_size ) ;
const scan_order * const so = get_scan ( xd , tx_size , type , block ) ;
const int16_t * const scan = so -> scan ;
const int16_t * const nb = so -> neighbors ;
int next = eob , sz = 0 ;
int64_t rdmult = mb -> rdmult * plane_rd_mult [ type ] , rddiv = mb -> rddiv ;
int64_t rd_cost0 , rd_cost1 ;
int rate0 , rate1 , error0 , error1 , t0 , t1 ;
int best , band , pt , i , final_eob ;
assert ( ( ! type && ! plane ) || ( type && plane ) ) ;
assert ( eob <= default_eob ) ;
if ( ! ref ) rdmult = ( rdmult * 9 ) >> 4 ;
tokens [ eob ] [ 0 ] . rate = 0 ;
tokens [ eob ] [ 0 ] . error = 0 ;
tokens [ eob ] [ 0 ] . next = default_eob ;
tokens [ eob ] [ 0 ] . token = EOB_TOKEN ;
tokens [ eob ] [ 0 ] . qc = 0 ;
tokens [ eob ] [ 1 ] = tokens [ eob ] [ 0 ] ;
for ( i = 0 ;
i < eob ;
i ++ ) token_cache [ scan [ i ] ] = vp9_pt_energy_class [ vp9_dct_value_tokens_ptr [ qcoeff [ scan [ i ] ] ] . token ] ;
for ( i = eob ;
i -- > 0 ;
) {
int base_bits , d2 , dx ;
const int rc = scan [ i ] ;
int x = qcoeff [ rc ] ;
if ( x ) {
int shortcut = 0 ;
error0 = tokens [ next ] [ 0 ] . error ;
error1 = tokens [ next ] [ 1 ] . error ;
rate0 = tokens [ next ] [ 0 ] . rate ;
rate1 = tokens [ next ] [ 1 ] . rate ;
t0 = ( vp9_dct_value_tokens_ptr + x ) -> token ;
if ( next < default_eob ) {
band = band_translate [ i + 1 ] ;
pt = trellis_get_coeff_context ( scan , nb , i , t0 , token_cache ) ;
rate0 += mb -> token_costs [ tx_size ] [ type ] [ ref ] [ band ] [ 0 ] [ pt ] [ tokens [ next ] [ 0 ] . token ] ;
rate1 += mb -> token_costs [ tx_size ] [ type ] [ ref ] [ band ] [ 0 ] [ pt ] [ tokens [ next ] [ 1 ] . token ] ;
}
UPDATE_RD_COST ( ) ;
best = rd_cost1 < rd_cost0 ;
base_bits = vp9_dct_value_cost_ptr [ x ] ;
dx = mul * ( dqcoeff [ rc ] - coeff [ rc ] ) ;
d2 = dx * dx ;
tokens [ i ] [ 0 ] . rate = base_bits + ( best ? rate1 : rate0 ) ;
tokens [ i ] [ 0 ] . error = d2 + ( best ? error1 : error0 ) ;
tokens [ i ] [ 0 ] . next = next ;
tokens [ i ] [ 0 ] . token = t0 ;
tokens [ i ] [ 0 ] . qc = x ;
best_index [ i ] [ 0 ] = best ;
rate0 = tokens [ next ] [ 0 ] . rate ;
rate1 = tokens [ next ] [ 1 ] . rate ;
if ( ( abs ( x ) * dequant_ptr [ rc != 0 ] > abs ( coeff [ rc ] ) * mul ) && ( abs ( x ) * dequant_ptr [ rc != 0 ] < abs ( coeff [ rc ] ) * mul + dequant_ptr [ rc != 0 ] ) ) shortcut = 1 ;
else shortcut = 0 ;
if ( shortcut ) {
sz = - ( x < 0 ) ;
x -= 2 * sz + 1 ;
}
if ( ! x ) {
t0 = tokens [ next ] [ 0 ] . token == EOB_TOKEN ? EOB_TOKEN : ZERO_TOKEN ;
t1 = tokens [ next ] [ 1 ] . token == EOB_TOKEN ? EOB_TOKEN : ZERO_TOKEN ;
}
else {
t0 = t1 = ( vp9_dct_value_tokens_ptr + x ) -> token ;
}
if ( next < default_eob ) {
band = band_translate [ i + 1 ] ;
if ( t0 != EOB_TOKEN ) {
pt = trellis_get_coeff_context ( scan , nb , i , t0 , token_cache ) ;
rate0 += mb -> token_costs [ tx_size ] [ type ] [ ref ] [ band ] [ ! x ] [ pt ] [ tokens [ next ] [ 0 ] . token ] ;
}
if ( t1 != EOB_TOKEN ) {
pt = trellis_get_coeff_context ( scan , nb , i , t1 , token_cache ) ;
rate1 += mb -> token_costs [ tx_size ] [ type ] [ ref ] [ band ] [ ! x ] [ pt ] [ tokens [ next ] [ 1 ] . token ] ;
}
}
UPDATE_RD_COST ( ) ;
best = rd_cost1 < rd_cost0 ;
base_bits = vp9_dct_value_cost_ptr [ x ] ;
if ( shortcut ) {
dx -= ( dequant_ptr [ rc != 0 ] + sz ) ^ sz ;
d2 = dx * dx ;
}
tokens [ i ] [ 1 ] . rate = base_bits + ( best ? rate1 : rate0 ) ;
tokens [ i ] [ 1 ] . error = d2 + ( best ? error1 : error0 ) ;
tokens [ i ] [ 1 ] . next = next ;
tokens [ i ] [ 1 ] . token = best ? t1 : t0 ;
tokens [ i ] [ 1 ] . qc = x ;
best_index [ i ] [ 1 ] = best ;
next = i ;
}
else {
band = band_translate [ i + 1 ] ;
t0 = tokens [ next ] [ 0 ] . token ;
t1 = tokens [ next ] [ 1 ] . token ;
if ( t0 != EOB_TOKEN ) {
tokens [ next ] [ 0 ] . rate += mb -> token_costs [ tx_size ] [ type ] [ ref ] [ band ] [ 1 ] [ 0 ] [ t0 ] ;
tokens [ next ] [ 0 ] . token = ZERO_TOKEN ;
}
if ( t1 != EOB_TOKEN ) {
tokens [ next ] [ 1 ] . rate += mb -> token_costs [ tx_size ] [ type ] [ ref ] [ band ] [ 1 ] [ 0 ] [ t1 ] ;
tokens [ next ] [ 1 ] . token = ZERO_TOKEN ;
}
best_index [ i ] [ 0 ] = best_index [ i ] [ 1 ] = 0 ;
}
}
band = band_translate [ i + 1 ] ;
rate0 = tokens [ next ] [ 0 ] . rate ;
rate1 = tokens [ next ] [ 1 ] . rate ;
error0 = tokens [ next ] [ 0 ] . error ;
error1 = tokens [ next ] [ 1 ] . error ;
t0 = tokens [ next ] [ 0 ] . token ;
t1 = tokens [ next ] [ 1 ] . token ;
rate0 += mb -> token_costs [ tx_size ] [ type ] [ ref ] [ band ] [ 0 ] [ ctx ] [ t0 ] ;
rate1 += mb -> token_costs [ tx_size ] [ type ] [ ref ] [ band ] [ 0 ] [ ctx ] [ t1 ] ;
UPDATE_RD_COST ( ) ;
best = rd_cost1 < rd_cost0 ;
final_eob = - 1 ;
vpx_memset ( qcoeff , 0 , sizeof ( * qcoeff ) * ( 16 << ( tx_size * 2 ) ) ) ;
vpx_memset ( dqcoeff , 0 , sizeof ( * dqcoeff ) * ( 16 << ( tx_size * 2 ) ) ) ;
for ( i = next ;
i < eob ;
i = next ) {
const int x = tokens [ i ] [ best ] . qc ;
const int rc = scan [ i ] ;
if ( x ) {
final_eob = i ;
}
qcoeff [ rc ] = x ;
dqcoeff [ rc ] = ( x * dequant_ptr [ rc != 0 ] ) / mul ;
next = tokens [ i ] [ best ] . next ;
best = best_index [ i ] [ best ] ;
}
final_eob ++ ;
mb -> plane [ plane ] . eobs [ block ] = final_eob ;
return final_eob ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline void modify_pred ( const int8_t * mod_table , int * mode ) {
* mode = mod_table [ * mode ] ;
if ( * mode < 0 ) {
av_log ( NULL , AV_LOG_ERROR , "Illegal intra prediction mode\n" ) ;
* mode = 0 ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void test_bug28075 ( ) {
int rc ;
DBUG_ENTER ( "test_bug28075" ) ;
myheader ( "test_bug28075" ) ;
rc = mysql_dump_debug_info ( mysql ) ;
DIE_UNLESS ( rc == 0 ) ;
rc = mysql_ping ( mysql ) ;
DIE_UNLESS ( rc == 0 ) ;
DBUG_VOID_RETURN ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static gint protobuf_iter_next ( protobuf_desc_t * pb , protobuf_tag_t * tag ) {
gint len ;
if ( pb -> bytes_left <= 0 ) {
return 0 ;
}
tag -> value = get_varint64 ( pb -> tvb , pb -> offset , pb -> bytes_left , & len ) ;
tag -> field_number = tag -> value >> 3 ;
tag -> wire_type = tag -> value & 0x7 ;
protobuf_seek_forward ( pb , len ) ;
return pb -> bytes_left ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void build_inter_predictors ( MACROBLOCKD * xd , int plane , int block , int bw , int bh , int x , int y , int w , int h , int mi_x , int mi_y ) {
struct macroblockd_plane * const pd = & xd -> plane [ plane ] ;
const MODE_INFO * mi = xd -> mi [ 0 ] ;
const int is_compound = has_second_ref ( & mi -> mbmi ) ;
const InterpKernel * kernel = vp9_get_interp_kernel ( mi -> mbmi . interp_filter ) ;
int ref ;
for ( ref = 0 ;
ref < 1 + is_compound ;
++ ref ) {
const struct scale_factors * const sf = & xd -> block_refs [ ref ] -> sf ;
struct buf_2d * const pre_buf = & pd -> pre [ ref ] ;
struct buf_2d * const dst_buf = & pd -> dst ;
uint8_t * const dst = dst_buf -> buf + dst_buf -> stride * y + x ;
const MV mv = mi -> mbmi . sb_type < BLOCK_8X8 ? average_split_mvs ( pd , mi , ref , block ) : mi -> mbmi . mv [ ref ] . as_mv ;
const MV mv_q4 = clamp_mv_to_umv_border_sb ( xd , & mv , bw , bh , pd -> subsampling_x , pd -> subsampling_y ) ;
uint8_t * pre ;
MV32 scaled_mv ;
int xs , ys , subpel_x , subpel_y ;
if ( vp9_is_scaled ( sf ) ) {
pre = pre_buf -> buf + scaled_buffer_offset ( x , y , pre_buf -> stride , sf ) ;
scaled_mv = vp9_scale_mv ( & mv_q4 , mi_x + x , mi_y + y , sf ) ;
xs = sf -> x_step_q4 ;
ys = sf -> y_step_q4 ;
}
else {
pre = pre_buf -> buf + ( y * pre_buf -> stride + x ) ;
scaled_mv . row = mv_q4 . row ;
scaled_mv . col = mv_q4 . col ;
xs = ys = 16 ;
}
subpel_x = scaled_mv . col & SUBPEL_MASK ;
subpel_y = scaled_mv . row & SUBPEL_MASK ;
pre += ( scaled_mv . row >> SUBPEL_BITS ) * pre_buf -> stride + ( scaled_mv . col >> SUBPEL_BITS ) ;
inter_predictor ( pre , pre_buf -> stride , dst , dst_buf -> stride , subpel_x , subpel_y , sf , w , h , ref , kernel , xs , ys ) ;
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline void cirrus_bitblt_bgcol ( CirrusVGAState * s ) {
unsigned int color ;
switch ( s -> cirrus_blt_pixelwidth ) {
case 1 : s -> cirrus_blt_bgcol = s -> cirrus_shadow_gr0 ;
break ;
case 2 : color = s -> cirrus_shadow_gr0 | ( s -> vga . gr [ 0x10 ] << 8 ) ;
s -> cirrus_blt_bgcol = le16_to_cpu ( color ) ;
break ;
case 3 : s -> cirrus_blt_bgcol = s -> cirrus_shadow_gr0 | ( s -> vga . gr [ 0x10 ] << 8 ) | ( s -> vga . gr [ 0x12 ] << 16 ) ;
break ;
default : case 4 : color = s -> cirrus_shadow_gr0 | ( s -> vga . gr [ 0x10 ] << 8 ) | ( s -> vga . gr [ 0x12 ] << 16 ) | ( s -> vga . gr [ 0x14 ] << 24 ) ;
s -> cirrus_blt_bgcol = le32_to_cpu ( color ) ;
break ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void dumpglyph ( SplineChar * sc , struct glyphinfo * gi ) {
struct glyphhead gh ;
DBounds bb ;
SplineSet * ss , * ttfss ;
int contourcnt , ptcnt , origptcnt ;
BasePoint * bp ;
char * fs ;
SplineChar * isc = sc -> ttf_instrs == NULL && sc -> parent -> mm != NULL && sc -> parent -> mm -> apple ? sc -> parent -> mm -> normal -> glyphs [ sc -> orig_pos ] : sc ;
if ( sc -> layers [ gi -> layer ] . splines == NULL && sc -> layers [ gi -> layer ] . refs == NULL ) {
dumpspace ( sc , gi ) ;
return ;
}
if ( gi -> next_glyph != sc -> ttf_glyph ) IError ( "Glyph count wrong in ttf output" ) ;
if ( gi -> next_glyph >= gi -> maxp -> numGlyphs ) IError ( "max glyph count wrong in ttf output" ) ;
gi -> loca [ gi -> next_glyph ] = ftell ( gi -> glyphs ) ;
ttfss = SCttfApprox ( sc , gi -> layer ) ;
ptcnt = SSTtfNumberPoints ( ttfss ) ;
for ( ss = ttfss , contourcnt = 0 ;
ss != NULL ;
ss = ss -> next ) {
++ contourcnt ;
}
origptcnt = ptcnt ;
SplineSetQuickBounds ( ttfss , & bb ) ;
gh . numContours = contourcnt ;
gh . xmin = floor ( bb . minx ) ;
gh . ymin = floor ( bb . miny ) ;
gh . xmax = ceil ( bb . maxx ) ;
gh . ymax = ceil ( bb . maxy ) ;
dumpghstruct ( gi , & gh ) ;
if ( contourcnt > gi -> maxp -> maxContours ) gi -> maxp -> maxContours = contourcnt ;
if ( ptcnt > gi -> maxp -> maxPoints ) gi -> maxp -> maxPoints = ptcnt ;
bp = malloc ( ptcnt * sizeof ( BasePoint ) ) ;
fs = malloc ( ptcnt ) ;
ptcnt = contourcnt = 0 ;
for ( ss = ttfss ;
ss != NULL ;
ss = ss -> next ) {
ptcnt = SSAddPoints ( ss , ptcnt , bp , fs ) ;
putshort ( gi -> glyphs , ptcnt - 1 ) ;
}
if ( ptcnt != origptcnt ) IError ( "Point count wrong calculated=%d, actual=%d in %.20s" , origptcnt , ptcnt , sc -> name ) ;
gi -> pointcounts [ gi -> next_glyph ++ ] = ptcnt ;
dumpinstrs ( gi , isc -> ttf_instrs , isc -> ttf_instrs_len ) ;
dumppointarrays ( gi , bp , fs , ptcnt ) ;
SplinePointListsFree ( ttfss ) ;
free ( bp ) ;
free ( fs ) ;
ttfdumpmetrics ( sc , gi , & bb ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_mswsp_smb ( tvbuff_t * tvb , packet_info * pinfo , proto_tree * tree , void * data ) {
smb_info_t * si = ( smb_info_t * ) data ;
gboolean in = si -> request ;
smb_fid_info_t * fid_info = NULL ;
fid_info = find_fid_info ( si ) ;
if ( ! fid_info || ! fid_info -> fsi || ! fid_info -> fsi -> filename ) {
return 0 ;
}
if ( g_ascii_strcasecmp ( fid_info -> fsi -> filename , "\\MsFteWds" ) != 0 ) {
return 0 ;
}
p_add_proto_data ( wmem_file_scope ( ) , pinfo , proto_mswsp , 0 , ( void * ) & SMB1 ) ;
return dissect_mswsp ( tvb , pinfo , tree , in , data ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vp8_de_noise ( VP8_COMMON * cm , YV12_BUFFER_CONFIG * source , YV12_BUFFER_CONFIG * post , int q , int low_var_thresh , int flag , int uvfilter ) {
int mbr ;
double level = 6.0e-05 * q * q * q - .0067 * q * q + .306 * q + .0065 ;
int ppl = ( int ) ( level + .5 ) ;
int mb_rows = cm -> mb_rows ;
int mb_cols = cm -> mb_cols ;
unsigned char * limits = cm -> pp_limits_buffer ;
;
( void ) post ;
( void ) low_var_thresh ;
( void ) flag ;
vpx_memset ( limits , ( unsigned char ) ppl , 16 * mb_cols ) ;
for ( mbr = 0 ;
mbr < mb_rows ;
mbr ++ ) {
vp8_post_proc_down_and_across_mb_row ( source -> y_buffer + 16 * mbr * source -> y_stride , source -> y_buffer + 16 * mbr * source -> y_stride , source -> y_stride , source -> y_stride , source -> y_width , limits , 16 ) ;
if ( uvfilter == 1 ) {
vp8_post_proc_down_and_across_mb_row ( source -> u_buffer + 8 * mbr * source -> uv_stride , source -> u_buffer + 8 * mbr * source -> uv_stride , source -> uv_stride , source -> uv_stride , source -> uv_width , limits , 8 ) ;
vp8_post_proc_down_and_across_mb_row ( source -> v_buffer + 8 * mbr * source -> uv_stride , source -> v_buffer + 8 * mbr * source -> uv_stride , source -> uv_stride , source -> uv_stride , source -> uv_width , limits , 8 ) ;
}
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static uint get_table_structure ( char * table , char * db , char * table_type , char * ignore_flag ) {
my_bool init = 0 , delayed , write_data , complete_insert ;
my_ulonglong num_fields ;
char * result_table , * opt_quoted_table ;
const char * insert_option ;
char name_buff [ NAME_LEN + 3 ] , table_buff [ NAME_LEN * 2 + 3 ] ;
char table_buff2 [ NAME_LEN * 2 + 3 ] , query_buff [ QUERY_LENGTH ] ;
const char * show_fields_stmt = "SELECT `COLUMN_NAME` AS `Field`, " "`COLUMN_TYPE` AS `Type`, " "`IS_NULLABLE` AS `Null`, " "`COLUMN_KEY` AS `Key`, " "`COLUMN_DEFAULT` AS `Default`, " "`EXTRA` AS `Extra`, " "`COLUMN_COMMENT` AS `Comment` " "FROM `INFORMATION_SCHEMA`.`COLUMNS` WHERE " "TABLE_SCHEMA = '%s' AND TABLE_NAME = '%s'" ;
FILE * sql_file = md_result_file ;
int len ;
my_bool is_log_table ;
MYSQL_RES * result ;
MYSQL_ROW row ;
DBUG_ENTER ( "get_table_structure" ) ;
DBUG_PRINT ( "enter" , ( "db: %s table: %s" , db , table ) ) ;
* ignore_flag = check_if_ignore_table ( table , table_type ) ;
delayed = opt_delayed ;
if ( delayed && ( * ignore_flag & IGNORE_INSERT_DELAYED ) ) {
delayed = 0 ;
verbose_msg ( "-- Warning: Unable to use delayed inserts for table '%s' " "because it's of type %s\n" , table , table_type ) ;
}
complete_insert = 0 ;
if ( ( write_data = ! ( * ignore_flag & IGNORE_DATA ) ) ) {
complete_insert = opt_complete_insert ;
if ( ! insert_pat_inited ) {
insert_pat_inited = 1 ;
init_dynamic_string_checked ( & insert_pat , "" , 1024 , 1024 ) ;
}
else dynstr_set_checked ( & insert_pat , "" ) ;
}
insert_option = ( ( delayed && opt_ignore ) ? " DELAYED IGNORE " : delayed ? " DELAYED " : opt_ignore ? " IGNORE " : "" ) ;
verbose_msg ( "-- Retrieving table structure for table %s...\n" , table ) ;
len = my_snprintf ( query_buff , sizeof ( query_buff ) , "SET SQL_QUOTE_SHOW_CREATE=%d" , ( opt_quoted || opt_keywords ) ) ;
if ( ! create_options ) strmov ( query_buff + len , "/*!40102 ,SQL_MODE=concat(@@sql_mode, _utf8 ',NO_KEY_OPTIONS,NO_TABLE_OPTIONS,NO_FIELD_OPTIONS') */" ) ;
result_table = quote_name ( table , table_buff , 1 ) ;
opt_quoted_table = quote_name ( table , table_buff2 , 0 ) ;
if ( opt_order_by_primary ) order_by = primary_key_fields ( result_table ) ;
if ( ! opt_xml && ! mysql_query_with_error_report ( mysql , 0 , query_buff ) ) {
if ( ! opt_no_create_info ) {
char buff [ 20 + FN_REFLEN ] ;
MYSQL_FIELD * field ;
my_snprintf ( buff , sizeof ( buff ) , "show create table %s" , result_table ) ;
if ( switch_character_set_results ( mysql , "binary" ) || mysql_query_with_error_report ( mysql , & result , buff ) || switch_character_set_results ( mysql , default_charset ) ) DBUG_RETURN ( 0 ) ;
if ( path ) {
if ( ! ( sql_file = open_sql_file_for_table ( table , O_WRONLY ) ) ) DBUG_RETURN ( 0 ) ;
write_header ( sql_file , db ) ;
}
if ( strcmp ( table_type , "VIEW" ) == 0 ) print_comment ( sql_file , 0 , "\n--\n-- Temporary table structure for view %s\n--\n\n" , fix_for_comment ( result_table ) ) ;
else print_comment ( sql_file , 0 , "\n--\n-- Table structure for table %s\n--\n\n" , fix_for_comment ( result_table ) ) ;
if ( opt_drop ) {
if ( ! general_log_or_slow_log_tables ( db , table ) ) fprintf ( sql_file , "DROP TABLE IF EXISTS %s;
\n" , opt_quoted_table ) ;
check_io ( sql_file ) ;
}
field = mysql_fetch_field_direct ( result , 0 ) ;
if ( strcmp ( field -> name , "View" ) == 0 ) {
char * scv_buff = NULL ;
my_ulonglong n_cols ;
verbose_msg ( "-- It's a view, create dummy table for view\n" ) ;
if ( ( row = mysql_fetch_row ( result ) ) && ( scv_buff = row [ 1 ] ) ) scv_buff = my_strdup ( scv_buff , MYF ( 0 ) ) ;
mysql_free_result ( result ) ;
my_snprintf ( query_buff , sizeof ( query_buff ) , "SHOW FIELDS FROM %s" , result_table ) ;
if ( switch_character_set_results ( mysql , "binary" ) || mysql_query_with_error_report ( mysql , & result , query_buff ) || switch_character_set_results ( mysql , default_charset ) ) {
if ( mysql_errno ( mysql ) == ER_VIEW_INVALID ) fprintf ( sql_file , "\n-- failed on view %s: %s\n\n" , result_table , scv_buff ? scv_buff : "" ) ;
my_free ( scv_buff ) ;
DBUG_RETURN ( 0 ) ;
}
else my_free ( scv_buff ) ;
n_cols = mysql_num_rows ( result ) ;
if ( 0 != n_cols ) {
if ( n_cols >= 1000 ) fprintf ( stderr , "-- Warning: Creating a stand-in table for view %s may" " fail when replaying the dump file produced because " "of the number of columns exceeding 1000. Exercise " "caution when replaying the produced dump file.\n" , table ) ;
if ( opt_drop ) {
fprintf ( sql_file , "/*!50001 DROP VIEW IF EXISTS %s*/;
\n" , opt_quoted_table ) ;
check_io ( sql_file ) ;
}
fprintf ( sql_file , "SET @saved_cs_client = @@character_set_client;
\n" "SET character_set_client = utf8;
\n" "/*!50001 CREATE TABLE %s (\n" , result_table ) ;
row = mysql_fetch_row ( result ) ;
fprintf ( sql_file , " %s tinyint NOT NULL" , quote_name ( row [ 0 ] , name_buff , 0 ) ) ;
while ( ( row = mysql_fetch_row ( result ) ) ) {
fprintf ( sql_file , ",\n %s tinyint NOT NULL" , quote_name ( row [ 0 ] , name_buff , 0 ) ) ;
}
fprintf ( sql_file , "\n) ENGINE=MyISAM */;
\n" "SET character_set_client = @saved_cs_client;
\n" ) ;
check_io ( sql_file ) ;
}
mysql_free_result ( result ) ;
if ( path ) my_fclose ( sql_file , MYF ( MY_WME ) ) ;
seen_views = 1 ;
DBUG_RETURN ( 0 ) ;
}
row = mysql_fetch_row ( result ) ;
is_log_table = general_log_or_slow_log_tables ( db , table ) ;
if ( is_log_table ) row [ 1 ] += 13 ;
if ( opt_compatible_mode & 3 ) {
fprintf ( sql_file , is_log_table ? "CREATE TABLE IF NOT EXISTS %s;
\n" : "%s;
\n" , row [ 1 ] ) ;
}
else {
fprintf ( sql_file , "/*!40101 SET @saved_cs_client = @@character_set_client */;
\n" "/*!40101 SET character_set_client = utf8 */;
\n" "%s%s;
\n" "/*!40101 SET character_set_client = @saved_cs_client */;
\n" , is_log_table ? "CREATE TABLE IF NOT EXISTS " : "" , row [ 1 ] ) ;
}
check_io ( sql_file ) ;
mysql_free_result ( result ) ;
}
my_snprintf ( query_buff , sizeof ( query_buff ) , "show fields from %s" , result_table ) ;
if ( mysql_query_with_error_report ( mysql , & result , query_buff ) ) {
if ( path ) my_fclose ( sql_file , MYF ( MY_WME ) ) ;
DBUG_RETURN ( 0 ) ;
}
if ( write_data ) {
if ( opt_replace_into ) dynstr_append_checked ( & insert_pat , "REPLACE " ) ;
else dynstr_append_checked ( & insert_pat , "INSERT " ) ;
dynstr_append_checked ( & insert_pat , insert_option ) ;
dynstr_append_checked ( & insert_pat , "INTO " ) ;
dynstr_append_checked ( & insert_pat , opt_quoted_table ) ;
if ( complete_insert ) {
dynstr_append_checked ( & insert_pat , " (" ) ;
}
else {
dynstr_append_checked ( & insert_pat , " VALUES " ) ;
if ( ! extended_insert ) dynstr_append_checked ( & insert_pat , "(" ) ;
}
}
while ( ( row = mysql_fetch_row ( result ) ) ) {
if ( complete_insert ) {
if ( init ) {
dynstr_append_checked ( & insert_pat , ", " ) ;
}
init = 1 ;
dynstr_append_checked ( & insert_pat , quote_name ( row [ SHOW_FIELDNAME ] , name_buff , 0 ) ) ;
}
}
num_fields = mysql_num_rows ( result ) ;
mysql_free_result ( result ) ;
}
else {
verbose_msg ( "%s: Warning: Can't set SQL_QUOTE_SHOW_CREATE option (%s)\n" , my_progname_short , mysql_error ( mysql ) ) ;
my_snprintf ( query_buff , sizeof ( query_buff ) , show_fields_stmt , db , table ) ;
if ( mysql_query_with_error_report ( mysql , & result , query_buff ) ) DBUG_RETURN ( 0 ) ;
if ( ! opt_no_create_info ) {
if ( path ) {
if ( ! ( sql_file = open_sql_file_for_table ( table , O_WRONLY ) ) ) DBUG_RETURN ( 0 ) ;
write_header ( sql_file , db ) ;
}
print_comment ( sql_file , 0 , "\n--\n-- Table structure for table %s\n--\n\n" , fix_for_comment ( result_table ) ) ;
if ( opt_drop ) fprintf ( sql_file , "DROP TABLE IF EXISTS %s;
\n" , result_table ) ;
if ( ! opt_xml ) fprintf ( sql_file , "CREATE TABLE %s (\n" , result_table ) ;
else print_xml_tag ( sql_file , "\t" , "\n" , "table_structure" , "name=" , table , NullS ) ;
check_io ( sql_file ) ;
}
if ( write_data ) {
if ( opt_replace_into ) dynstr_append_checked ( & insert_pat , "REPLACE " ) ;
else dynstr_append_checked ( & insert_pat , "INSERT " ) ;
dynstr_append_checked ( & insert_pat , insert_option ) ;
dynstr_append_checked ( & insert_pat , "INTO " ) ;
dynstr_append_checked ( & insert_pat , result_table ) ;
if ( complete_insert ) dynstr_append_checked ( & insert_pat , " (" ) ;
else {
dynstr_append_checked ( & insert_pat , " VALUES " ) ;
if ( ! extended_insert ) dynstr_append_checked ( & insert_pat , "(" ) ;
}
}
while ( ( row = mysql_fetch_row ( result ) ) ) {
ulong * lengths = mysql_fetch_lengths ( result ) ;
if ( init ) {
if ( ! opt_xml && ! opt_no_create_info ) {
fputs ( ",\n" , sql_file ) ;
check_io ( sql_file ) ;
}
if ( complete_insert ) dynstr_append_checked ( & insert_pat , ", " ) ;
}
init = 1 ;
if ( complete_insert ) dynstr_append_checked ( & insert_pat , quote_name ( row [ SHOW_FIELDNAME ] , name_buff , 0 ) ) ;
if ( ! opt_no_create_info ) {
if ( opt_xml ) {
print_xml_row ( sql_file , "field" , result , & row , NullS ) ;
continue ;
}
if ( opt_keywords ) fprintf ( sql_file , " %s.%s %s" , result_table , quote_name ( row [ SHOW_FIELDNAME ] , name_buff , 0 ) , row [ SHOW_TYPE ] ) ;
else fprintf ( sql_file , " %s %s" , quote_name ( row [ SHOW_FIELDNAME ] , name_buff , 0 ) , row [ SHOW_TYPE ] ) ;
if ( row [ SHOW_DEFAULT ] ) {
fputs ( " DEFAULT " , sql_file ) ;
unescape ( sql_file , row [ SHOW_DEFAULT ] , lengths [ SHOW_DEFAULT ] ) ;
}
if ( ! row [ SHOW_NULL ] [ 0 ] ) fputs ( " NOT NULL" , sql_file ) ;
if ( row [ SHOW_EXTRA ] [ 0 ] ) fprintf ( sql_file , " %s" , row [ SHOW_EXTRA ] ) ;
check_io ( sql_file ) ;
}
}
num_fields = mysql_num_rows ( result ) ;
mysql_free_result ( result ) ;
if ( ! opt_no_create_info ) {
char buff [ 20 + FN_REFLEN ] ;
uint keynr , primary_key ;
my_snprintf ( buff , sizeof ( buff ) , "show keys from %s" , result_table ) ;
if ( mysql_query_with_error_report ( mysql , & result , buff ) ) {
if ( mysql_errno ( mysql ) == ER_WRONG_OBJECT ) {
fputs ( "\t\t<options Comment=\"view\" />\n" , sql_file ) ;
goto continue_xml ;
}
fprintf ( stderr , "%s: Can't get keys for table %s (%s)\n" , my_progname_short , result_table , mysql_error ( mysql ) ) ;
if ( path ) my_fclose ( sql_file , MYF ( MY_WME ) ) ;
DBUG_RETURN ( 0 ) ;
}
keynr = 0 ;
primary_key = INT_MAX ;
while ( ( row = mysql_fetch_row ( result ) ) ) {
if ( atoi ( row [ 3 ] ) == 1 ) {
keynr ++ ;
# ifdef FORCE_PRIMARY_KEY if ( atoi ( row [ 1 ] ) == 0 && primary_key == INT_MAX ) primary_key = keynr ;
# endif if ( ! strcmp ( row [ 2 ] , "PRIMARY" ) ) {
primary_key = keynr ;
break ;
}
}
}
mysql_data_seek ( result , 0 ) ;
keynr = 0 ;
while ( ( row = mysql_fetch_row ( result ) ) ) {
if ( opt_xml ) {
print_xml_row ( sql_file , "key" , result , & row , NullS ) ;
continue ;
}
if ( atoi ( row [ 3 ] ) == 1 ) {
if ( keynr ++ ) putc ( ')' , sql_file ) ;
if ( atoi ( row [ 1 ] ) ) fprintf ( sql_file , ",\n KEY %s (" , quote_name ( row [ 2 ] , name_buff , 0 ) ) ;
else if ( keynr == primary_key ) fputs ( ",\n PRIMARY KEY (" , sql_file ) ;
else fprintf ( sql_file , ",\n UNIQUE %s (" , quote_name ( row [ 2 ] , name_buff , 0 ) ) ;
}
else putc ( ',' , sql_file ) ;
fputs ( quote_name ( row [ 4 ] , name_buff , 0 ) , sql_file ) ;
if ( row [ 7 ] ) fprintf ( sql_file , " (%s)" , row [ 7 ] ) ;
check_io ( sql_file ) ;
}
mysql_free_result ( result ) ;
if ( ! opt_xml ) {
if ( keynr ) putc ( ')' , sql_file ) ;
fputs ( "\n)" , sql_file ) ;
check_io ( sql_file ) ;
}
if ( create_options ) {
char show_name_buff [ NAME_LEN * 2 + 2 + 24 ] ;
my_snprintf ( buff , sizeof ( buff ) , "show table status like %s" , quote_for_like ( table , show_name_buff ) ) ;
if ( mysql_query_with_error_report ( mysql , & result , buff ) ) {
if ( mysql_errno ( mysql ) != ER_PARSE_ERROR ) {
verbose_msg ( "-- Warning: Couldn't get status information for " "table %s (%s)\n" , result_table , mysql_error ( mysql ) ) ;
}
}
else if ( ! ( row = mysql_fetch_row ( result ) ) ) {
fprintf ( stderr , "Error: Couldn't read status information for table %s (%s)\n" , result_table , mysql_error ( mysql ) ) ;
}
else {
if ( opt_xml ) print_xml_row ( sql_file , "options" , result , & row , NullS ) ;
else {
fputs ( "/*!" , sql_file ) ;
print_value ( sql_file , result , row , "engine=" , "Engine" , 0 ) ;
print_value ( sql_file , result , row , "" , "Create_options" , 0 ) ;
print_value ( sql_file , result , row , "comment=" , "Comment" , 1 ) ;
fputs ( " */" , sql_file ) ;
check_io ( sql_file ) ;
}
}
mysql_free_result ( result ) ;
}
continue_xml : if ( ! opt_xml ) fputs ( ";
\n" , sql_file ) ;
else fputs ( "\t</table_structure>\n" , sql_file ) ;
check_io ( sql_file ) ;
}
}
if ( complete_insert ) {
dynstr_append_checked ( & insert_pat , ") VALUES " ) ;
if ( ! extended_insert ) dynstr_append_checked ( & insert_pat , "(" ) ;
}
if ( sql_file != md_result_file ) {
fputs ( "\n" , sql_file ) ;
write_footer ( sql_file ) ;
my_fclose ( sql_file , MYF ( MY_WME ) ) ;
}
DBUG_RETURN ( ( uint ) num_fields ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
const mbfl_encoding * mbfl_identify_encoding ( mbfl_string * string , enum mbfl_no_encoding * elist , int elistsz , int strict ) {
int i , n , num , bad ;
unsigned char * p ;
mbfl_identify_filter * flist , * filter ;
const mbfl_encoding * encoding ;
flist = ( mbfl_identify_filter * ) mbfl_calloc ( elistsz , sizeof ( mbfl_identify_filter ) ) ;
if ( flist == NULL ) {
return NULL ;
}
num = 0 ;
if ( elist != NULL ) {
for ( i = 0 ;
i < elistsz ;
i ++ ) {
if ( ! mbfl_identify_filter_init ( & flist [ num ] , elist [ i ] ) ) {
num ++ ;
}
}
}
n = string -> len ;
p = string -> val ;
if ( p != NULL ) {
bad = 0 ;
while ( n > 0 ) {
for ( i = 0 ;
i < num ;
i ++ ) {
filter = & flist [ i ] ;
if ( ! filter -> flag ) {
( * filter -> filter_function ) ( * p , filter ) ;
if ( filter -> flag ) {
bad ++ ;
}
}
}
if ( ( num - 1 ) <= bad && ! strict ) {
break ;
}
p ++ ;
n -- ;
}
}
encoding = NULL ;
for ( i = 0 ;
i < num ;
i ++ ) {
filter = & flist [ i ] ;
if ( ! filter -> flag ) {
if ( strict && filter -> status ) {
continue ;
}
encoding = filter -> encoding ;
break ;
}
}
if ( ! encoding ) {
for ( i = 0 ;
i < num ;
i ++ ) {
filter = & flist [ i ] ;
if ( ! filter -> flag && ( ! strict || ! filter -> status ) ) {
encoding = filter -> encoding ;
break ;
}
}
}
i = num ;
while ( -- i >= 0 ) {
mbfl_identify_filter_cleanup ( & flist [ i ] ) ;
}
mbfl_free ( ( void * ) flist ) ;
return encoding ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void link_info_cancel ( NautilusDirectory * directory ) {
if ( directory -> details -> link_info_read_state != NULL ) {
g_cancellable_cancel ( directory -> details -> link_info_read_state -> cancellable ) ;
directory -> details -> link_info_read_state -> directory = NULL ;
directory -> details -> link_info_read_state = NULL ;
async_job_end ( directory , "link info" ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
uint8_t * * jbig2_decode_gray_scale_image ( Jbig2Ctx * ctx , Jbig2Segment * segment , const byte * data , const size_t size , bool GSMMR , uint32_t GSW , uint32_t GSH , uint32_t GSBPP , bool GSUSESKIP , Jbig2Image * GSKIP , int GSTEMPLATE , Jbig2ArithCx * GB_stats ) {
uint8_t * * GSVALS = NULL ;
size_t consumed_bytes = 0 ;
uint32_t i , j , stride , x , y ;
int code ;
Jbig2Image * * GSPLANES ;
Jbig2GenericRegionParams rparams ;
Jbig2WordStream * ws = NULL ;
Jbig2ArithState * as = NULL ;
GSPLANES = jbig2_new ( ctx , Jbig2Image * , GSBPP ) ;
if ( GSPLANES == NULL ) {
jbig2_error ( ctx , JBIG2_SEVERITY_FATAL , segment -> number , "failed to allocate %d bytes for GSPLANES" , GSBPP ) ;
return NULL ;
}
for ( i = 0 ;
i < GSBPP ;
++ i ) {
GSPLANES [ i ] = jbig2_image_new ( ctx , GSW , GSH ) ;
if ( GSPLANES [ i ] == NULL ) {
jbig2_error ( ctx , JBIG2_SEVERITY_FATAL , segment -> number , "failed to allocate %dx%d image for GSPLANES" , GSW , GSH ) ;
for ( j = i ;
j > 0 ;
) jbig2_image_release ( ctx , GSPLANES [ -- j ] ) ;
jbig2_free ( ctx -> allocator , GSPLANES ) ;
return NULL ;
}
}
rparams . MMR = GSMMR ;
rparams . GBTEMPLATE = GSTEMPLATE ;
rparams . TPGDON = 0 ;
rparams . USESKIP = GSUSESKIP ;
rparams . gbat [ 0 ] = ( GSTEMPLATE <= 1 ? 3 : 2 ) ;
rparams . gbat [ 1 ] = - 1 ;
rparams . gbat [ 2 ] = - 3 ;
rparams . gbat [ 3 ] = - 1 ;
rparams . gbat [ 4 ] = 2 ;
rparams . gbat [ 5 ] = - 2 ;
rparams . gbat [ 6 ] = - 2 ;
rparams . gbat [ 7 ] = - 2 ;
if ( GSMMR ) {
code = jbig2_decode_halftone_mmr ( ctx , & rparams , data , size , GSPLANES [ GSBPP - 1 ] , & consumed_bytes ) ;
}
else {
ws = jbig2_word_stream_buf_new ( ctx , data , size ) ;
if ( ws == NULL ) {
jbig2_error ( ctx , JBIG2_SEVERITY_FATAL , segment -> number , "failed to allocate ws in jbig2_decode_gray_scale_image" ) ;
goto cleanup ;
}
as = jbig2_arith_new ( ctx , ws ) ;
if ( as == NULL ) {
jbig2_error ( ctx , JBIG2_SEVERITY_FATAL , segment -> number , "failed to allocate as in jbig2_decode_gray_scale_image" ) ;
goto cleanup ;
}
code = jbig2_decode_generic_region ( ctx , segment , & rparams , as , GSPLANES [ GSBPP - 1 ] , GB_stats ) ;
}
if ( code != 0 ) {
jbig2_error ( ctx , JBIG2_SEVERITY_FATAL , segment -> number , "error decoding GSPLANES for halftone image" ) ;
goto cleanup ;
}
j = GSBPP - 1 ;
while ( j > 0 ) {
j -- ;
if ( GSMMR ) {
code = jbig2_decode_halftone_mmr ( ctx , & rparams , data + consumed_bytes , size - consumed_bytes , GSPLANES [ j ] , & consumed_bytes ) ;
}
else {
code = jbig2_decode_generic_region ( ctx , segment , & rparams , as , GSPLANES [ j ] , GB_stats ) ;
}
if ( code != 0 ) {
jbig2_error ( ctx , JBIG2_SEVERITY_FATAL , segment -> number , "error decoding GSPLANES for halftone image" ) ;
goto cleanup ;
}
stride = GSPLANES [ 0 ] -> stride ;
for ( i = 0 ;
i < stride * GSH ;
++ i ) GSPLANES [ j ] -> data [ i ] ^= GSPLANES [ j + 1 ] -> data [ i ] ;
}
GSVALS = jbig2_new ( ctx , uint8_t * , GSW ) ;
if ( GSVALS == NULL ) {
jbig2_error ( ctx , JBIG2_SEVERITY_FATAL , segment -> number , "failed to allocate GSVALS: %d bytes" , GSW ) ;
goto cleanup ;
}
for ( i = 0 ;
i < GSW ;
++ i ) {
GSVALS [ i ] = jbig2_new ( ctx , uint8_t , GSH ) ;
if ( GSVALS [ i ] == NULL ) {
jbig2_error ( ctx , JBIG2_SEVERITY_FATAL , segment -> number , "failed to allocate GSVALS: %d bytes" , GSH * GSW ) ;
for ( j = i ;
j > 0 ;
) jbig2_free ( ctx -> allocator , GSVALS [ -- j ] ) ;
jbig2_free ( ctx -> allocator , GSVALS ) ;
GSVALS = NULL ;
goto cleanup ;
}
}
for ( x = 0 ;
x < GSW ;
++ x ) {
for ( y = 0 ;
y < GSH ;
++ y ) {
GSVALS [ x ] [ y ] = 0 ;
for ( j = 0 ;
j < GSBPP ;
++ j ) GSVALS [ x ] [ y ] += jbig2_image_get_pixel ( GSPLANES [ j ] , x , y ) << j ;
}
}
cleanup : if ( ! GSMMR ) {
jbig2_free ( ctx -> allocator , as ) ;
jbig2_word_stream_buf_free ( ctx , ws ) ;
}
for ( i = 0 ;
i < GSBPP ;
++ i ) jbig2_image_release ( ctx , GSPLANES [ i ] ) ;
jbig2_free ( ctx -> allocator , GSPLANES ) ;
return GSVALS ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
PGconn * GetConnection ( Archive * AHX ) {
ArchiveHandle * AH = ( ArchiveHandle * ) AHX ;
return AH -> connection ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int zsave ( i_ctx_t * i_ctx_p ) {
os_ptr op = osp ;
uint space = icurrent_space ;
vm_save_t * vmsave ;
ulong sid ;
int code ;
gs_gstate * prev ;
if ( I_VALIDATE_BEFORE_SAVE ) ivalidate_clean_spaces ( i_ctx_p ) ;
ialloc_set_space ( idmemory , avm_local ) ;
vmsave = ialloc_struct ( vm_save_t , & st_vm_save , "zsave" ) ;
ialloc_set_space ( idmemory , space ) ;
if ( vmsave == 0 ) return_error ( gs_error_VMerror ) ;
vmsave -> gsave = NULL ;
code = alloc_save_state ( idmemory , vmsave , & sid ) ;
if ( code < 0 ) return code ;
if ( sid == 0 ) {
ifree_object ( vmsave , "zsave" ) ;
return_error ( gs_error_VMerror ) ;
}
if_debug2m ( 'u' , imemory , "[u]vmsave 0x%lx, id = %lu\n" , ( ulong ) vmsave , ( ulong ) sid ) ;
code = gs_gsave_for_save ( igs , & prev ) ;
if ( code < 0 ) return code ;
code = gs_gsave ( igs ) ;
if ( code < 0 ) return code ;
vmsave -> gsave = prev ;
push ( 1 ) ;
make_tav ( op , t_save , 0 , saveid , sid ) ;
if ( I_VALIDATE_AFTER_SAVE ) ivalidate_clean_spaces ( i_ctx_p ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void proto_register_sigcomp ( void ) {
static hf_register_info hf [ ] = {
{
& hf_sigcomp_t_bit , {
"T bit" , "sigcomp.t.bit" , FT_UINT8 , BASE_DEC , NULL , 0x04 , "Sigcomp T bit" , HFILL }
}
, {
& hf_sigcomp_len , {
"Partial state id length" , "sigcomp.length" , FT_UINT8 , BASE_HEX , VALS ( length_encoding_vals ) , 0x03 , "Sigcomp length" , HFILL }
}
, {
& hf_sigcomp_returned_feedback_item , {
"Returned_feedback item" , "sigcomp.returned.feedback.item" , FT_BYTES , BASE_NONE , NULL , 0x0 , "Returned feedback item" , HFILL }
}
, {
& hf_sigcomp_partial_state , {
"Partial state identifier" , "sigcomp.partial.state.identifier" , FT_STRING , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_remaining_message_bytes , {
"Remaining SigComp message bytes" , "sigcomp.remaining-bytes" , FT_UINT32 , BASE_DEC , NULL , 0x0 , "Number of bytes remaining in message" , HFILL }
}
, {
& hf_sigcomp_compression_ratio , {
"Compression ratio (%)" , "sigcomp.compression-ratio" , FT_UINT32 , BASE_DEC , NULL , 0x0 , "Compression ratio (decompressed / compressed) %" , HFILL }
}
, {
& hf_sigcomp_returned_feedback_item_len , {
"Returned feedback item length" , "sigcomp.returned.feedback.item.len" , FT_UINT8 , BASE_DEC , NULL , 0x7f , NULL , HFILL }
}
, {
& hf_sigcomp_code_len , {
"Code length" , "sigcomp.code.len" , FT_UINT16 , BASE_HEX , NULL , 0xfff0 , NULL , HFILL }
}
, {
& hf_sigcomp_destination , {
"Destination" , "sigcomp.destination" , FT_UINT8 , BASE_HEX | BASE_EXT_STRING , & destination_address_encoding_vals_ext , 0xf , NULL , HFILL }
}
, {
& hf_sigcomp_udvm_bytecode , {
"Uploaded UDVM bytecode" , "sigcomp.udvm.byte-code" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_udvm_instr , {
"UDVM instruction code" , "sigcomp.udvm.instr" , FT_UINT8 , BASE_DEC | BASE_EXT_STRING , & udvm_instruction_code_vals_ext , 0x0 , NULL , HFILL }
}
, {
& hf_udvm_execution_trace , {
"UDVM execution trace" , "sigcomp.udvm.execution-trace" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_udvm_multitype_bytecode , {
"UDVM bytecode" , "sigcomp.udvm.multyt.bytecode" , FT_UINT8 , BASE_HEX , VALS ( display_bytecode_vals ) , 0x0 , NULL , HFILL }
}
, {
& hf_udvm_reference_bytecode , {
"UDVM bytecode" , "sigcomp.udvm.ref.bytecode" , FT_UINT8 , BASE_HEX , VALS ( display_ref_bytecode_vals ) , 0x0 , NULL , HFILL }
}
, {
& hf_udvm_literal_bytecode , {
"UDVM bytecode" , "sigcomp.udvm.lit.bytecode" , FT_UINT8 , BASE_HEX , VALS ( display_lit_bytecode_vals ) , 0x0 , NULL , HFILL }
}
, # if 0 {
& hf_udvm_operand , {
"UDVM operand" , "sigcomp.udvm.operand" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, # endif {
& hf_udvm_length , {
"%Length" , "sigcomp.udvm.length" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Length" , HFILL }
}
, {
& hf_udvm_addr_length , {
"%Length[memory address]" , "sigcomp.udvm.addr.length" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Length" , HFILL }
}
, {
& hf_udvm_destination , {
"%Destination" , "sigcomp.udvm.destination" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Destination" , HFILL }
}
, {
& hf_udvm_addr_destination , {
"%Destination[memory address]" , "sigcomp.udvm.addr.destination" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Destination" , HFILL }
}
, {
& hf_udvm_at_address , {
"@Address(mem_add_of_inst + D) mod 2^16)" , "sigcomp.udvm.at.address" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Address" , HFILL }
}
, {
& hf_udvm_address , {
"%Address" , "sigcomp.udvm.length" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Address" , HFILL }
}
, {
& hf_udvm_literal_num , {
"#n" , "sigcomp.udvm.literal-num" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Literal number" , HFILL }
}
, {
& hf_udvm_value , {
"%Value" , "sigcomp.udvm.value" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Value" , HFILL }
}
, {
& hf_udvm_addr_value , {
"%Value[memory address]" , "sigcomp.udvm.value" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Value" , HFILL }
}
, {
& hf_partial_identifier_start , {
"%Partial identifier start" , "sigcomp.udvm.partial.identifier.start" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Partial identifier start" , HFILL }
}
, {
& hf_partial_identifier_length , {
"%Partial identifier length" , "sigcomp.udvm.partial.identifier.length" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Partial identifier length" , HFILL }
}
, {
& hf_state_begin , {
"%State begin" , "sigcomp.udvm.state.begin" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "State begin" , HFILL }
}
, {
& hf_udvm_state_length , {
"%State length" , "sigcomp.udvm.state.length" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "State length" , HFILL }
}
, {
& hf_udvm_state_length_addr , {
"%State length[memory address]" , "sigcomp.udvm.state.length.addr" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "State length" , HFILL }
}
, {
& hf_udvm_state_address , {
"%State address" , "sigcomp.udvm.start.address" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "State address" , HFILL }
}
, {
& hf_udvm_state_address_addr , {
"%State address[memory address]" , "sigcomp.udvm.start.address.addr" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "State address" , HFILL }
}
, {
& hf_udvm_state_instr , {
"%State instruction" , "sigcomp.udvm.start.instr" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "State instruction" , HFILL }
}
, {
& hf_udvm_operand_1 , {
"$Operand 1[memory address]" , "sigcomp.udvm.operand.1" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Reference $ Operand 1" , HFILL }
}
, {
& hf_udvm_operand_2 , {
"%Operand 2" , "sigcomp.udvm.operand.2" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Operand 2" , HFILL }
}
, {
& hf_udvm_operand_2_addr , {
"%Operand 2[memory address]" , "sigcomp.udvm.operand.2.addr" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Operand 2" , HFILL }
}
, {
& hf_udvm_j , {
"%j" , "sigcomp.udvm.j" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "j" , HFILL }
}
, {
& hf_udvm_addr_j , {
"%j[memory address]" , "sigcomp.udvm.addr.j" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "j" , HFILL }
}
, {
& hf_udvm_output_start , {
"%Output_start" , "sigcomp.output.start" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Output start" , HFILL }
}
, {
& hf_udvm_addr_output_start , {
"%Output_start[memory address]" , "sigcomp.addr.output.start" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Output start" , HFILL }
}
, {
& hf_udvm_output_length , {
"%Output_length" , "sigcomp.output.length" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Output length" , HFILL }
}
, {
& hf_udvm_output_length_addr , {
"%Output_length[memory address]" , "sigcomp.output.length.addr" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Output length" , HFILL }
}
, {
& hf_udvm_req_feedback_loc , {
"%Requested feedback location" , "sigcomp.req.feedback.loc" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Requested feedback location" , HFILL }
}
, {
& hf_udvm_min_acc_len , {
"%Minimum access length" , "sigcomp.min.acc.len" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Minimum access length" , HFILL }
}
, {
& hf_udvm_state_ret_pri , {
"%State retention priority" , "sigcomp.udvm.state.ret.pri" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "State retention priority" , HFILL }
}
, {
& hf_udvm_ret_param_loc , {
"%Returned parameters location" , "sigcomp.ret.param.loc" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Returned parameters location" , HFILL }
}
, {
& hf_udvm_position , {
"%Position" , "sigcomp.udvm.position" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Position" , HFILL }
}
, {
& hf_udvm_ref_dest , {
"$Destination[memory address]" , "sigcomp.udvm.ref.destination" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "(reference)Destination" , HFILL }
}
, {
& hf_udvm_bits , {
"%Bits" , "sigcomp.udvm.bits" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Bits" , HFILL }
}
, {
& hf_udvm_lower_bound , {
"%Lower bound" , "sigcomp.udvm.lower.bound" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Lower_bound" , HFILL }
}
, {
& hf_udvm_upper_bound , {
"%Upper bound" , "sigcomp.udvm.upper.bound" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Upper bound" , HFILL }
}
, {
& hf_udvm_uncompressed , {
"%Uncompressed" , "sigcomp.udvm.uncompressed" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Uncompressed" , HFILL }
}
, {
& hf_udvm_start_value , {
"%Start value" , "sigcomp.udvm.start.value" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Start value" , HFILL }
}
, {
& hf_udvm_offset , {
"%Offset" , "sigcomp.udvm.offset" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Offset" , HFILL }
}
, {
& hf_udvm_addr_offset , {
"%Offset[memory address]" , "sigcomp.udvm.addr.offset" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "Offset" , HFILL }
}
, {
& hf_sigcomp_nack_ver , {
"NACK Version" , "sigcomp.nack.ver" , FT_UINT8 , BASE_DEC , NULL , 0x0f , NULL , HFILL }
}
, {
& hf_sigcomp_nack_reason_code , {
"Reason Code" , "sigcomp.nack.reason" , FT_UINT8 , BASE_DEC | BASE_EXT_STRING , & sigcomp_nack_reason_code_vals_ext , 0x0 , "NACK Reason Code" , HFILL }
}
, {
& hf_sigcomp_nack_failed_op_code , {
"OPCODE of failed instruction" , "sigcomp.nack.failed_op_code" , FT_UINT8 , BASE_DEC | BASE_EXT_STRING , & udvm_instruction_code_vals_ext , 0x0 , "NACK OPCODE of failed instruction" , HFILL }
}
, {
& hf_sigcomp_nack_pc , {
"PC of failed instruction" , "sigcomp.nack.pc" , FT_UINT16 , BASE_DEC , NULL , 0x0 , "NACK PC of failed instruction" , HFILL }
}
, {
& hf_sigcomp_nack_sha1 , {
"SHA-1 Hash of failed message" , "sigcomp.nack.sha1" , FT_BYTES , BASE_NONE , NULL , 0x0 , "NACK SHA-1 Hash of failed message" , HFILL }
}
, {
& hf_sigcomp_nack_state_id , {
"State ID (6 - 20 bytes)" , "sigcomp.nack.state_id" , FT_BYTES , BASE_NONE , NULL , 0x0 , "NACK State ID (6 - 20 bytes)" , HFILL }
}
, {
& hf_sigcomp_nack_cycles_per_bit , {
"Cycles Per Bit" , "sigcomp.nack.cycles_per_bit" , FT_UINT8 , BASE_DEC , NULL , 0x0 , "NACK Cycles Per Bit" , HFILL }
}
, {
& hf_sigcomp_nack_memory_size , {
"Memory size" , "sigcomp.memory_size" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_decompress_instruction , {
"Instruction" , "sigcomp.decompress_instruction" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_loading_result , {
"Loading result" , "sigcomp.loading_result" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_byte_copy , {
"byte copy" , "sigcomp.byte_copy" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_accessing_state , {
"### Accessing state ###" , "sigcomp.accessing_state" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_getting_value , {
"Getting value" , "sigcomp.getting_value" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_load_bytecode_into_udvm_start , {
"Load bytecode into UDVM starting at" , "sigcomp.load_bytecode_into_udvm_start" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_instruction_code , {
"Instruction code" , "sigcomp.instruction_code" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_current_instruction , {
"Addr" , "sigcomp.current_instruction" , FT_UINT8 , BASE_DEC | BASE_EXT_STRING , & udvm_instruction_code_vals_ext , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_decompression_failure , {
"DECOMPRESSION-FAILURE" , "sigcomp.decompression_failure" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_wireshark_udvm_diagnostic , {
"Wireshark UDVM diagnostic" , "sigcomp.wireshark_udvm_diagnostic" , FT_UINT32 , BASE_DEC , VALS ( result_code_vals ) , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_calculated_sha_1 , {
"Calculated SHA-1" , "sigcomp.calculated_sha_1" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_copying_value , {
"Copying value" , "sigcomp.copying_value" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_storing_value , {
"Storing value" , "sigcomp.storing_value" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_loading_value , {
"Loading value" , "sigcomp.loading_value" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_set_hu , {
"Set Hu" , "sigcomp.set_hu" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_loading_h , {
"Loading H" , "sigcomp.loading_h" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_state_value , {
"Addr" , "sigcomp.state_value" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_output_value , {
"Output value" , "sigcomp.output_value" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_num_state_create , {
"no_of_state_create" , "sigcomp.num_state_create" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_sha1_digest , {
"SHA1 digest" , "sigcomp.sha1_digest" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_creating_state , {
"### Creating state ###" , "sigcomp.creating_state" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_sigcomp_message_decompressed , {
"SigComp message Decompressed" , "sigcomp.message_decompressed" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_starting_to_remove_escape_digits , {
"Starting to remove escape digits" , "sigcomp.starting_to_remove_escape_digits" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_escape_digit_found , {
"Escape digit found" , "sigcomp.escape_digit_found" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_illegal_escape_code , {
"Illegal escape code" , "sigcomp.illegal_escape_code" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_end_of_sigcomp_message_indication_found , {
"End of SigComp message indication found" , "sigcomp.end_of_sigcomp_message_indication_found" , FT_NONE , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_addr_value , {
"Addr" , "sigcomp.addr" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_copying_bytes_literally , {
"Copying bytes literally" , "sigcomp.copying_bytes_literally" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_data_for_sigcomp_dissector , {
"Data handed to the Sigcomp dissector" , "sigcomp.data_for_sigcomp_dissector" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_remaining_sigcomp_message , {
"Remaining SigComp message" , "sigcomp.remaining_sigcomp_message" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_sha1buff , {
"sha1buff" , "sigcomp.sha1buff" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_udvm_instruction , {
"UDVM instruction" , "sigcomp.udvm_instruction" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_remaining_bytes , {
"Remaining bytes" , "sigcomp.remaining_bytes" , FT_BYTES , BASE_NONE , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_max_udvm_cycles , {
"maximum_UDVM_cycles" , "sigcomp.max_udvm_cycles" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_used_udvm_cycles , {
"used_udvm_cycles" , "sigcomp.used_udvm_cycles" , FT_UINT32 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_udvm_execution_stated , {
"UDVM EXECUTION STARTED" , "sigcomp.udvm_execution_stated" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_message_length , {
"Message Length" , "sigcomp.message_length" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_sigcomp_byte_code_length , {
"Byte code length" , "sigcomp.byte_code_length" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL }
}
, }
;
static gint * ett [ ] = {
& ett_sigcomp , & ett_sigcomp_udvm , & ett_sigcomp_udvm_exe , }
;
static gint * ett_raw [ ] = {
& ett_raw_text , }
;
static ei_register_info ei [ ] = {
{
& ei_sigcomp_nack_failed_op_code , {
"sigcomp.nack.failed_op_code.expert" , PI_SEQUENCE , PI_WARN , "SigComp NACK" , EXPFILL }
}
, {
& ei_sigcomp_invalid_instruction , {
"sigcomp.invalid_instruction" , PI_PROTOCOL , PI_WARN , "Invalid instruction" , EXPFILL }
}
, {
& ei_sigcomp_invalid_shift_value , {
"sigcomp.invalid_shift_value" , PI_PROTOCOL , PI_WARN , "Invalid shift value" , EXPFILL }
}
, {
& ei_sigcomp_sigcomp_message_decompression_failure , {
"sigcomp.message_decompression_failure" , PI_PROTOCOL , PI_WARN , "SigComp message Decompression failure" , EXPFILL }
}
, {
& ei_sigcomp_execution_of_this_instruction_is_not_implemented , {
"sigcomp.execution_of_this_instruction_is_not_implemented" , PI_UNDECODED , PI_WARN , "Execution of this instruction is NOT implemented" , EXPFILL }
}
, {
& ei_sigcomp_decompression_failure , {
"sigcomp.decompression_failure_expert" , PI_PROTOCOL , PI_WARN , "DECOMPRESSION FAILURE" , EXPFILL }
}
, {
& ei_sigcomp_tcp_fragment , {
"sigcomp.tcp_fragment" , PI_MALFORMED , PI_ERROR , "TCP Fragment" , EXPFILL }
}
, {
& ei_sigcomp_failed_to_access_state_wireshark_udvm_diagnostic , {
"sigcomp.failed_to_access_state_wireshark_udvm_diagnostic" , PI_PROTOCOL , PI_WARN , "Failed to Access state Wireshark UDVM diagnostic" , EXPFILL }
}
, {
& ei_sigcomp_all_remaining_parameters_zero , {
"sigcomp.all_remaining_parameters" , PI_PROTOCOL , PI_NOTE , "All remaining parameters = 0(Not in the uploaded code as UDVM buffer initialized to Zero" , EXPFILL }
}
, }
;
module_t * sigcomp_module ;
expert_module_t * expert_sigcomp ;
static const enum_val_t udvm_detail_vals [ ] = {
{
"no-printout" , "No-Printout" , 0 }
, {
"low-detail" , "Low-detail" , 1 }
, {
"medium-detail" , "Medium-detail" , 2 }
, {
"high-detail" , "High-detail" , 3 }
, {
NULL , NULL , - 1 }
}
;
proto_sigcomp = proto_register_protocol ( "Signaling Compression" , "SIGCOMP" , "sigcomp" ) ;
proto_raw_sigcomp = proto_register_protocol ( "Decompressed SigComp message as raw text" , "Raw_SigComp" , "raw_sigcomp" ) ;
register_dissector ( "sigcomp" , dissect_sigcomp , proto_sigcomp ) ;
proto_register_field_array ( proto_sigcomp , hf , array_length ( hf ) ) ;
proto_register_subtree_array ( ett , array_length ( ett ) ) ;
proto_register_subtree_array ( ett_raw , array_length ( ett_raw ) ) ;
expert_sigcomp = expert_register_protocol ( proto_sigcomp ) ;
expert_register_field_array ( expert_sigcomp , ei , array_length ( ei ) ) ;
sigcomp_module = prefs_register_protocol ( proto_sigcomp , proto_reg_handoff_sigcomp ) ;
prefs_register_uint_preference ( sigcomp_module , "udp.port" , "Sigcomp UDP Port 1" , "Set UDP port 1 for SigComp messages" , 10 , & SigCompUDPPort1 ) ;
prefs_register_uint_preference ( sigcomp_module , "udp.port2" , "Sigcomp UDP Port 2" , "Set UDP port 2 for SigComp messages" , 10 , & SigCompUDPPort2 ) ;
prefs_register_uint_preference ( sigcomp_module , "tcp.port" , "Sigcomp TCP Port 1" , "Set TCP port 1 for SigComp messages" , 10 , & SigCompTCPPort1 ) ;
prefs_register_uint_preference ( sigcomp_module , "tcp.port2" , "Sigcomp TCP Port 2" , "Set TCP port 2 for SigComp messages" , 10 , & SigCompTCPPort2 ) ;
prefs_register_bool_preference ( sigcomp_module , "display.udvm.code" , "Dissect the UDVM code" , "Preference whether to Dissect the UDVM code or not" , & dissect_udvm_code ) ;
prefs_register_bool_preference ( sigcomp_module , "display.bytecode" , "Display the bytecode of operands" , "preference whether to display the bytecode in " "UDVM operands or not" , & display_udvm_bytecode ) ;
prefs_register_bool_preference ( sigcomp_module , "decomp.msg" , "Decompress message" , "preference whether to decompress message or not" , & decompress ) ;
prefs_register_bool_preference ( sigcomp_module , "display.decomp.msg.as.txt" , "Displays the decompressed message as text" , "preference whether to display the decompressed message " "as raw text or not" , & display_raw_txt ) ;
prefs_register_enum_preference ( sigcomp_module , "show.udvm.execution" , "Level of detail of UDVM execution:" , "'No-Printout' = UDVM executes silently, then increasing detail " "about execution of UDVM instructions;
" "Warning! CPU intense at high detail" , & udvm_print_detail_level , udvm_detail_vals , FALSE ) ;
register_init_routine ( & sigcomp_init_udvm ) ;
register_cleanup_routine ( & sigcomp_cleanup_udvm ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void join_print_po ( struct packet_object * po ) {
int ret ;
if ( ! data_window ) return ;
if ( GBL_OPTIONS -> regex && regexec ( GBL_OPTIONS -> regex , po -> DATA . disp_data , 0 , NULL , 0 ) != 0 ) {
return ;
}
SAFE_REALLOC ( dispbuf , hex_len ( po -> DATA . disp_len ) * sizeof ( u_char ) + 1 ) ;
ret = GBL_FORMAT ( po -> DATA . disp_data , po -> DATA . disp_len , dispbuf ) ;
dispbuf [ ret ] = 0 ;
if ( ! ip_addr_cmp ( & po -> L3 . src , & curr_conn -> L3_addr1 ) ) gtkui_data_print ( 3 , dispbuf , 1 ) ;
else gtkui_data_print ( 3 , dispbuf , 2 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void ff_MPV_common_end ( MpegEncContext * s ) {
int i ;
if ( s -> slice_context_count > 1 ) {
for ( i = 0 ;
i < s -> slice_context_count ;
i ++ ) {
free_duplicate_context ( s -> thread_context [ i ] ) ;
}
for ( i = 1 ;
i < s -> slice_context_count ;
i ++ ) {
av_freep ( & s -> thread_context [ i ] ) ;
}
s -> slice_context_count = 1 ;
}
else free_duplicate_context ( s ) ;
av_freep ( & s -> parse_context . buffer ) ;
s -> parse_context . buffer_size = 0 ;
av_freep ( & s -> bitstream_buffer ) ;
s -> allocated_bitstream_buffer_size = 0 ;
av_freep ( & s -> avctx -> stats_out ) ;
av_freep ( & s -> ac_stats ) ;
av_freep ( & s -> q_intra_matrix ) ;
av_freep ( & s -> q_inter_matrix ) ;
av_freep ( & s -> q_intra_matrix16 ) ;
av_freep ( & s -> q_inter_matrix16 ) ;
av_freep ( & s -> input_picture ) ;
av_freep ( & s -> reordered_input_picture ) ;
av_freep ( & s -> dct_offset ) ;
if ( s -> picture && ! s -> avctx -> internal -> is_copy ) {
for ( i = 0 ;
i < s -> picture_count ;
i ++ ) {
free_picture ( s , & s -> picture [ i ] ) ;
}
}
av_freep ( & s -> picture ) ;
free_context_frame ( s ) ;
if ( ! ( s -> avctx -> active_thread_type & FF_THREAD_FRAME ) ) avcodec_default_free_buffers ( s -> avctx ) ;
s -> context_initialized = 0 ;
s -> last_picture_ptr = s -> next_picture_ptr = s -> current_picture_ptr = NULL ;
s -> linesize = s -> uvlinesize = 0 ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_MultiplePayloadStreamElement ( 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_MultiplePayloadStreamElement , MultiplePayloadStreamElement_sequence ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int get_qzbin_factor ( int q , vpx_bit_depth_t bit_depth ) {
const int quant = vp9_dc_quant ( q , 0 , bit_depth ) ;
# if CONFIG_VP9_HIGHBITDEPTH switch ( bit_depth ) {
case VPX_BITS_8 : return q == 0 ? 64 : ( quant < 148 ? 84 : 80 ) ;
case VPX_BITS_10 : return q == 0 ? 64 : ( quant < 592 ? 84 : 80 ) ;
case VPX_BITS_12 : return q == 0 ? 64 : ( quant < 2368 ? 84 : 80 ) ;
default : assert ( 0 && "bit_depth should be VPX_BITS_8, VPX_BITS_10 or VPX_BITS_12" ) ;
return - 1 ;
}
# else ( void ) bit_depth ;
return q == 0 ? 64 : ( quant < 148 ? 84 : 80 ) ;
# endif }
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline hwaddr pcnet_rdra_addr ( PCNetState * s , int idx ) {
while ( idx < 1 ) {
idx += CSR_RCVRL ( s ) ;
}
return s -> rdra + ( ( CSR_RCVRL ( s ) - idx ) * ( BCR_SWSTYLE ( s ) ? 16 : 8 ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( HttpsEngagementPageLoadMetricsBrowserTest , Simple_Https ) {
StartHttpsServer ( false ) ;
base : : TimeDelta upper_bound = NavigateInForegroundAndCloseWithTiming ( https_test_server_ -> GetURL ( "/simple.html" ) ) ;
histogram_tester_ . ExpectTotalCount ( internal : : kHttpEngagementHistogram , 0 ) ;
histogram_tester_ . ExpectTotalCount ( internal : : kHttpsEngagementHistogram , 1 ) ;
int32_t bucket_min = histogram_tester_ . GetAllSamples ( internal : : kHttpsEngagementHistogram ) [ 0 ] . min ;
EXPECT_GE ( upper_bound . InMilliseconds ( ) , bucket_min ) ;
EXPECT_LT ( 0 , bucket_min ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
WORK_STATE ossl_statem_server_post_work ( SSL * s , WORK_STATE wst ) {
OSSL_STATEM * st = & s -> statem ;
s -> init_num = 0 ;
switch ( st -> hand_state ) {
case TLS_ST_SW_HELLO_REQ : if ( statem_flush ( s ) != 1 ) return WORK_MORE_A ;
if ( ! ssl3_init_finished_mac ( s ) ) {
ossl_statem_set_error ( s ) ;
return WORK_ERROR ;
}
break ;
case DTLS_ST_SW_HELLO_VERIFY_REQUEST : if ( statem_flush ( s ) != 1 ) return WORK_MORE_A ;
if ( s -> version != DTLS1_BAD_VER && ! ssl3_init_finished_mac ( s ) ) {
ossl_statem_set_error ( s ) ;
return WORK_ERROR ;
}
s -> first_packet = 1 ;
break ;
case TLS_ST_SW_SRVR_HELLO : # ifndef OPENSSL_NO_SCTP if ( SSL_IS_DTLS ( s ) && s -> hit ) {
unsigned char sctpauthkey [ 64 ] ;
char labelbuffer [ sizeof ( DTLS1_SCTP_AUTH_LABEL ) ] ;
memcpy ( labelbuffer , DTLS1_SCTP_AUTH_LABEL , sizeof ( DTLS1_SCTP_AUTH_LABEL ) ) ;
if ( SSL_export_keying_material ( s , sctpauthkey , sizeof ( sctpauthkey ) , labelbuffer , sizeof ( labelbuffer ) , NULL , 0 , 0 ) <= 0 ) {
ossl_statem_set_error ( s ) ;
return WORK_ERROR ;
}
BIO_ctrl ( SSL_get_wbio ( s ) , BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY , sizeof ( sctpauthkey ) , sctpauthkey ) ;
}
# endif break ;
case TLS_ST_SW_CHANGE : # ifndef OPENSSL_NO_SCTP if ( SSL_IS_DTLS ( s ) && ! s -> hit ) {
BIO_ctrl ( SSL_get_wbio ( s ) , BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY , 0 , NULL ) ;
}
# endif if ( ! s -> method -> ssl3_enc -> change_cipher_state ( s , SSL3_CHANGE_CIPHER_SERVER_WRITE ) ) {
ossl_statem_set_error ( s ) ;
return WORK_ERROR ;
}
if ( SSL_IS_DTLS ( s ) ) dtls1_reset_seq_numbers ( s , SSL3_CC_WRITE ) ;
break ;
case TLS_ST_SW_SRVR_DONE : if ( statem_flush ( s ) != 1 ) return WORK_MORE_A ;
break ;
case TLS_ST_SW_FINISHED : if ( statem_flush ( s ) != 1 ) return WORK_MORE_A ;
# ifndef OPENSSL_NO_SCTP if ( SSL_IS_DTLS ( s ) && s -> hit ) {
BIO_ctrl ( SSL_get_wbio ( s ) , BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY , 0 , NULL ) ;
}
# endif break ;
default : break ;
}
return WORK_FINISHED_CONTINUE ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TSReturnCode TSMimeHdrDestroy ( TSMBuffer bufp , TSMLoc obj ) {
sdk_assert ( sdk_sanity_check_mbuffer ( bufp ) == TS_SUCCESS ) ;
sdk_assert ( ( sdk_sanity_check_mime_hdr_handle ( obj ) == TS_SUCCESS ) || ( sdk_sanity_check_http_hdr_handle ( obj ) == TS_SUCCESS ) ) ;
if ( ! isWriteable ( bufp ) ) {
return TS_ERROR ;
}
MIMEHdrImpl * mh = _hdr_mloc_to_mime_hdr_impl ( obj ) ;
mime_hdr_destroy ( ( ( HdrHeapSDKHandle * ) bufp ) -> m_heap , mh ) ;
return TS_SUCCESS ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int rawv6_recvmsg ( struct kiocb * iocb , struct sock * sk , struct msghdr * msg , size_t len , int noblock , int flags , int * addr_len ) {
struct ipv6_pinfo * np = inet6_sk ( sk ) ;
struct sockaddr_in6 * sin6 = ( struct sockaddr_in6 * ) msg -> msg_name ;
struct sk_buff * skb ;
size_t copied ;
int err ;
if ( flags & MSG_OOB ) return - EOPNOTSUPP ;
if ( addr_len ) * addr_len = sizeof ( * sin6 ) ;
if ( flags & MSG_ERRQUEUE ) return ipv6_recv_error ( sk , msg , len ) ;
if ( np -> rxpmtu && np -> rxopt . bits . rxpmtu ) return ipv6_recv_rxpmtu ( sk , msg , len ) ;
skb = skb_recv_datagram ( sk , flags , noblock , & err ) ;
if ( ! skb ) goto out ;
copied = skb -> len ;
if ( copied > len ) {
copied = len ;
msg -> msg_flags |= MSG_TRUNC ;
}
if ( skb_csum_unnecessary ( skb ) ) {
err = skb_copy_datagram_iovec ( skb , 0 , msg -> msg_iov , copied ) ;
}
else if ( msg -> msg_flags & MSG_TRUNC ) {
if ( __skb_checksum_complete ( skb ) ) goto csum_copy_err ;
err = skb_copy_datagram_iovec ( skb , 0 , msg -> msg_iov , copied ) ;
}
else {
err = skb_copy_and_csum_datagram_iovec ( skb , 0 , msg -> msg_iov ) ;
if ( err == - EINVAL ) goto csum_copy_err ;
}
if ( err ) goto out_free ;
if ( sin6 ) {
sin6 -> sin6_family = AF_INET6 ;
sin6 -> sin6_port = 0 ;
ipv6_addr_copy ( & sin6 -> sin6_addr , & ipv6_hdr ( skb ) -> saddr ) ;
sin6 -> sin6_flowinfo = 0 ;
sin6 -> sin6_scope_id = 0 ;
if ( ipv6_addr_type ( & sin6 -> sin6_addr ) & IPV6_ADDR_LINKLOCAL ) sin6 -> sin6_scope_id = IP6CB ( skb ) -> iif ;
}
sock_recv_ts_and_drops ( msg , sk , skb ) ;
if ( np -> rxopt . all ) datagram_recv_ctl ( sk , msg , skb ) ;
err = copied ;
if ( flags & MSG_TRUNC ) err = skb -> len ;
out_free : skb_free_datagram ( sk , skb ) ;
out : return err ;
csum_copy_err : skb_kill_datagram ( sk , skb , flags ) ;
err = ( flags & MSG_DONTWAIT ) ? - EAGAIN : - EHOSTUNREACH ;
goto out ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( PageLoadMetricsBrowserTest , UseCounterFeaturesInIframe ) {
ASSERT_TRUE ( embedded_test_server ( ) -> Start ( ) ) ;
auto waiter = CreatePageLoadMetricsWaiter ( ) ;
waiter -> AddPageExpectation ( TimingField : : LOAD_EVENT ) ;
ui_test_utils : : NavigateToURL ( browser ( ) , embedded_test_server ( ) -> GetURL ( "/page_load_metrics/use_counter_features_in_iframe.html" ) ) ;
waiter -> Wait ( ) ;
NavigateToUntrackedUrl ( ) ;
histogram_tester_ . ExpectBucketCount ( internal : : kFeaturesHistogramName , static_cast < int32_t > ( WebFeature : : kTextWholeText ) , 1 ) ;
histogram_tester_ . ExpectBucketCount ( internal : : kFeaturesHistogramName , static_cast < int32_t > ( WebFeature : : kV8Element_Animate_Method ) , 1 ) ;
histogram_tester_ . ExpectBucketCount ( internal : : kFeaturesHistogramName , static_cast < int32_t > ( WebFeature : : kNavigatorVibrate ) , 1 ) ;
histogram_tester_ . ExpectBucketCount ( internal : : kFeaturesHistogramName , static_cast < int32_t > ( WebFeature : : kPageVisits ) , 1 ) ;
}
| 0False
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.