Datasets:
xin1997
/
bugfix_pretraining

Dataset card Data Studio Files Community
Unnamed: 0
int64
0
535k
source
stringlengths
50
89.8k
target
stringlengths
23
37.7k
2,000
CWE-000 GST_START_TEST ( test_query_duration ) { GstElement * videorate ; gulong probe_sink ; gint64 duration ; GstQuery * query ; videorate = setup_videorate ( ) ; fail_unless ( gst_element_set_state ( videorate , GST_STATE_PLAYING ) == GST_STATE_CHANGE_SUCCESS , "could<S2SV_blank>not<S2SV_blank>set<S2SV_blank>to<S2SV_blank>playing" ) ; probe_sink = gst_pad_add_probe ( mysrcpad , <S2SV_StartBug> GST_PAD_PROBE_TYPE_QUERY_DOWNSTREAM | GST_PAD_PROBE_TYPE_PUSH , <S2SV_EndBug> ( GstPadProbeCallback ) listen_sink_query_duration , & duration , NULL ) ; query = gst_query_new_duration ( GST_FORMAT_TIME ) ; duration = GST_CLOCK_TIME_NONE ; <S2SV_StartBug> gst_pad_peer_query ( mysrcpad , query ) ; <S2SV_EndBug> gst_query_parse_duration ( query , NULL , & duration ) ; fail_unless_equals_uint64 ( duration , GST_CLOCK_TIME_NONE ) ; duration = GST_SECOND ; g_object_set ( videorate , "rate" , 2.0 , NULL ) ; <S2SV_StartBug> gst_pad_peer_query ( mysrcpad , query ) ; <S2SV_EndBug> gst_query_parse_duration ( query , NULL , & duration ) ; fail_unless_equals_uint64 ( duration , 0.5 * GST_SECOND ) ; gst_query_unref ( query ) ; gst_pad_remove_probe ( mysrcpad , probe_sink ) ; cleanup_videorate ( videorate ) ; }
<S2SV_ModStart> ( mysrcpad , GST_PAD_PROBE_TYPE_QUERY_UPSTREAM <S2SV_ModEnd> , ( GstPadProbeCallback <S2SV_ModStart> ; gst_pad_peer_query ( mysinkpad <S2SV_ModEnd> , query ) <S2SV_ModStart> ; gst_pad_peer_query ( mysinkpad <S2SV_ModEnd> , query )
2,001
CWE-000 static void print_usage ( int level ) { int i ; const char * name = "?" , * desc ; zz_mixer_info ( ZZ_MIXER_DEF , & name , & desc ) ; printf ( "Usage:<S2SV_blank>zingzong<S2SV_blank>[OPTIONS]<S2SV_blank><song.4v><S2SV_blank>[<inst.set>]" "\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>zingzong<S2SV_blank>[OPTIONS]<S2SV_blank><music.4q>" "\\n" "\\n" "<S2SV_blank><S2SV_blank>A<S2SV_blank>Microdeal<S2SV_blank>quartet<S2SV_blank>music<S2SV_blank>file<S2SV_blank>player\\n" "\\n" # ifndef NDEBUG "<S2SV_blank><S2SV_blank>-------><S2SV_blank>/!\\\\<S2SV_blank>DEBUG<S2SV_blank>BUILD<S2SV_blank>/!\\\\<S2SV_blank><-------\\n" "\\n" # endif "OPTIONS:\\n" "<S2SV_blank>-h<S2SV_blank>--help<S2SV_blank>--usage<S2SV_blank><S2SV_blank>Print<S2SV_blank>this<S2SV_blank>message<S2SV_blank>and<S2SV_blank>exit.\\n" "<S2SV_blank>-V<S2SV_blank>--version<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Print<S2SV_blank>version<S2SV_blank>and<S2SV_blank>copyright<S2SV_blank>and<S2SV_blank>exit.\\n" "<S2SV_blank>-t<S2SV_blank>--tick=HZ<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Set<S2SV_blank>player<S2SV_blank>tick<S2SV_blank>rate<S2SV_blank>(default<S2SV_blank>is<S2SV_blank>200hz).\\n" "<S2SV_blank>-r<S2SV_blank>--rate=[R,]HZ<S2SV_blank><S2SV_blank><S2SV_blank>Set<S2SV_blank>re-sampling<S2SV_blank>method<S2SV_blank>and<S2SV_blank>rate<S2SV_blank>(%s,%uK).\\n" , name , SPR_DEF / 1000u ) ; if ( ! level ) puts ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Try<S2SV_blank>`-hh\'<S2SV_blank>to<S2SV_blank>print<S2SV_blank>the<S2SV_blank>list<S2SV_blank>of<S2SV_blank>[R]esampler." ) ; else for ( i = 0 ; i == zz_mixer_info ( i , & name , & desc ) ; ++ i ) { printf ( "%6s<S2SV_blank>`%s\'<S2SV_blank>%s<S2SV_blank>%s.\\n" , i ? "" : "<S2SV_blank>R<S2SV_blank>:=" , name , "............." + strlen ( name ) , desc ) ; } puts ( "<S2SV_blank>-l<S2SV_blank>--length=TIME<S2SV_blank><S2SV_blank><S2SV_blank>Set<S2SV_blank>play<S2SV_blank>time.\\n" "<S2SV_blank>-m<S2SV_blank>--mute=CHANS<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Mute<S2SV_blank>selected<S2SV_blank>channels<S2SV_blank>(bit-field<S2SV_blank>or<S2SV_blank>string).\\n" "<S2SV_blank>-i<S2SV_blank>--ignore=CHANS<S2SV_blank><S2SV_blank>Ignore<S2SV_blank>selected<S2SV_blank>channels<S2SV_blank>(bit-field<S2SV_blank>or<S2SV_blank>string).\\n" "<S2SV_blank>-o<S2SV_blank>--output=URI<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Set<S2SV_blank>output<S2SV_blank>file<S2SV_blank>name<S2SV_blank>(-w<S2SV_blank>or<S2SV_blank>-c).\\n" "<S2SV_blank>-c<S2SV_blank>--stdout<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Output<S2SV_blank>raw<S2SV_blank>PCM<S2SV_blank>to<S2SV_blank>stdout<S2SV_blank>or<S2SV_blank>file<S2SV_blank>(native<S2SV_blank>16-bit).\\n" "<S2SV_blank>-n<S2SV_blank>--null<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Output<S2SV_blank>to<S2SV_blank>the<S2SV_blank>void.\\n" # ifndef NO_AO "<S2SV_blank>-w<S2SV_blank>--wav<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Generated<S2SV_blank>a<S2SV_blank>.wav<S2SV_blank>file.\\n" # endif ) ; puts ( ! level ? <S2SV_StartBug> "Try<S2SV_blank>`-hh\'<S2SV_blank>for<S2SV_blank>more<S2SV_blank>details<S2SV_blank>on<S2SV_blank>OUTPUT/TIME/CHANS." : <S2SV_EndBug> "OUTPUT:\\n" "<S2SV_blank>Options<S2SV_blank>`-n/--null`,\'-c/--stdout\'<S2SV_blank>and<S2SV_blank>`-w/--wav`<S2SV_blank>are<S2SV_blank>used<S2SV_blank>to<S2SV_blank>set<S2SV_blank>the\\n" "<S2SV_blank>output<S2SV_blank>type.<S2SV_blank>The<S2SV_blank>last<S2SV_blank>one<S2SV_blank>is<S2SV_blank>used.<S2SV_blank>Without<S2SV_blank>it<S2SV_blank>the<S2SV_blank>default<S2SV_blank>output<S2SV_blank>type\\n" "<S2SV_blank>is<S2SV_blank>used<S2SV_blank>which<S2SV_blank>should<S2SV_blank>be<S2SV_blank>playing<S2SV_blank>sound<S2SV_blank>via<S2SV_blank>the<S2SV_blank>default<S2SV_blank>or<S2SV_blank>configured\\n" "<S2SV_blank>libao<S2SV_blank>driver.\\n" "\\n" <S2SV_StartBug> "<S2SV_blank>The<S2SV_blank>`-o/--output`<S2SV_blank>option<S2SV_blank>specify<S2SV_blank>the<S2SV_blank>output<S2SV_blank>depending<S2SV_blank>on<S2SV_blank>the<S2SV_blank>output\\n" <S2SV_EndBug> "<S2SV_blank>type.\\n" "\\n" "<S2SV_blank>-n/--null`<S2SV_blank><S2SV_blank><S2SV_blank>output<S2SV_blank>is<S2SV_blank>ignored\\n" "<S2SV_blank>-c/--stdout<S2SV_blank><S2SV_blank>output<S2SV_blank>to<S2SV_blank>the<S2SV_blank>specified<S2SV_blank>file<S2SV_blank>instead<S2SV_blank>of<S2SV_blank>`stdout`.\\n" "<S2SV_blank>-w/--wav<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>unless<S2SV_blank>set<S2SV_blank>output<S2SV_blank>is<S2SV_blank>a<S2SV_blank>file<S2SV_blank>based<S2SV_blank>on<S2SV_blank>song<S2SV_blank>filename.\\n" # ifdef NO_AO "\\n" "IMPORTANT:\\n" "<S2SV_blank>This<S2SV_blank>version<S2SV_blank>of<S2SV_blank>zingzong<S2SV_blank>has<S2SV_blank>been<S2SV_blank>built<S2SV_blank>without<S2SV_blank>libao<S2SV_blank>support.\\n" "<S2SV_blank>Therefore<S2SV_blank>it<S2SV_blank>can<S2SV_blank>not<S2SV_blank>produce<S2SV_blank>audio<S2SV_blank>output<S2SV_blank>nor<S2SV_blank>RIFF<S2SV_blank>.wav<S2SV_blank>file.\\n" # endif "\\n" "TIME:\\n" "<S2SV_blank>.<S2SV_blank>0<S2SV_blank>or<S2SV_blank>`inf\'<S2SV_blank>represents<S2SV_blank>an<S2SV_blank>infinite<S2SV_blank>duration\\n" "<S2SV_blank>.<S2SV_blank>comma<S2SV_blank>`,\'<S2SV_blank>dot<S2SV_blank>`.\'<S2SV_blank>or<S2SV_blank>double-quote<S2SV_blank>`\\"\'<S2SV_blank>separates<S2SV_blank>milliseconds\\n" "<S2SV_blank>.<S2SV_blank>`m\'<S2SV_blank>or<S2SV_blank>quote<S2SV_blank>to<S2SV_blank>suffix<S2SV_blank>minutes\\n" "<S2SV_blank>.<S2SV_blank>`h\'<S2SV_blank>to<S2SV_blank>suffix<S2SV_blank>hour\\n" "\\n" "<S2SV_blank>If<S2SV_blank>time<S2SV_blank>is<S2SV_blank>not<S2SV_blank>set<S2SV_blank>the<S2SV_blank>player<S2SV_blank>tries<S2SV_blank>to<S2SV_blank>auto-detect<S2SV_blank>the<S2SV_blank>music<S2SV_blank>duration.\\n" "<S2SV_blank>However<S2SV_blank>a<S2SV_blank>number<S2SV_blank>of<S2SV_blank>musics<S2SV_blank>are<S2SV_blank>going<S2SV_blank>into<S2SV_blank>unnecessary<S2SV_blank>loops<S2SV_blank>which<S2SV_blank>make\\n" <S2SV_StartBug> "<S2SV_blank>it<S2SV_blank>harder<S2SV_blank>to<S2SV_blank>properly<S2SV_blank>detect.<S2SV_blank>Detection<S2SV_blank>threshold<S2SV_blank>is<S2SV_blank>set<S2SV_blank>to<S2SV_blank>30<S2SV_blank>minutes\'.\\n" <S2SV_EndBug> "\\n" "CHANS:\\n" "<S2SV_blank>Select<S2SV_blank>channels<S2SV_blank>to<S2SV_blank>be<S2SV_blank>either<S2SV_blank>muted<S2SV_blank>or<S2SV_blank>ignored.<S2SV_blank>It<S2SV_blank>can<S2SV_blank>be<S2SV_blank>either:\\n" "<S2SV_blank>.<S2SV_blank>an<S2SV_blank>integer<S2SV_blank>representing<S2SV_blank>a<S2SV_blank>mask<S2SV_blank>of<S2SV_blank>selected<S2SV_blank>channels<S2SV_blank>(C-style<S2SV_blank>prefix)\\n" "<S2SV_blank>.<S2SV_blank>a<S2SV_blank>string<S2SV_blank>containing<S2SV_blank>the<S2SV_blank>letter<S2SV_blank>A<S2SV_blank>to<S2SV_blank>D<S2SV_blank>(case<S2SV_blank>insensitive)<S2SV_blank>in<S2SV_blank>any<S2SV_blank>order\\n" ) ; puts ( copyright ) ; puts ( license ) ; puts ( bugreport ) ; }
<S2SV_ModStart> ! level ? "Try<S2SV_blank>`-hh\'<S2SV_blank>for<S2SV_blank>more<S2SV_blank>details<S2SV_blank>on<S2SV_blank>OUTPUT/TIME/CHANS.\\n" : "OUTPUT:\\n" "<S2SV_blank>Options<S2SV_blank>`-n/--null\',`-c/--stdout\'<S2SV_blank>and<S2SV_blank>`-w/--wav\'<S2SV_blank>are<S2SV_blank>used<S2SV_blank>to<S2SV_blank>set<S2SV_blank>the\\n" <S2SV_ModEnd> "<S2SV_blank>output<S2SV_blank>type.<S2SV_blank>The<S2SV_blank>last<S2SV_blank>one<S2SV_blank>is<S2SV_blank>used.<S2SV_blank>Without<S2SV_blank>it<S2SV_blank>the<S2SV_blank>default<S2SV_blank>output<S2SV_blank>type\\n" "<S2SV_blank>is<S2SV_blank>used<S2SV_blank>which<S2SV_blank>should<S2SV_blank>be<S2SV_blank>playing<S2SV_blank>sound<S2SV_blank>via<S2SV_blank>the<S2SV_blank>default<S2SV_blank>or<S2SV_blank>configured\\n" "<S2SV_blank>libao<S2SV_blank>driver.\\n" <S2SV_ModStart> "<S2SV_blank>is<S2SV_blank>used<S2SV_blank>which<S2SV_blank>should<S2SV_blank>be<S2SV_blank>playing<S2SV_blank>sound<S2SV_blank>via<S2SV_blank>the<S2SV_blank>default<S2SV_blank>or<S2SV_blank>configured\\n" "<S2SV_blank>libao<S2SV_blank>driver.\\n" "\\n" "<S2SV_blank>The<S2SV_blank>`-o/--output\'<S2SV_blank>option<S2SV_blank>specify<S2SV_blank>the<S2SV_blank>output<S2SV_blank>depending<S2SV_blank>on<S2SV_blank>the<S2SV_blank>output\\n" "<S2SV_blank>type.\\n" "\\n" "<S2SV_blank>`-n/--null\'<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>output<S2SV_blank>is<S2SV_blank>ignored\\n" "<S2SV_blank>`-c/--stdout\'<S2SV_blank><S2SV_blank>output<S2SV_blank>to<S2SV_blank>the<S2SV_blank>specified<S2SV_blank>file<S2SV_blank>instead<S2SV_blank>of<S2SV_blank>`stdout\'.\\n" "<S2SV_blank>`-w/--wav\'<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>unless<S2SV_blank>set<S2SV_blank>output<S2SV_blank>is<S2SV_blank>a<S2SV_blank>file<S2SV_blank>based<S2SV_blank>on<S2SV_blank>song<S2SV_blank>filename.\\n" <S2SV_ModEnd> # ifdef NO_AO <S2SV_ModStart> "\\n" "<S2SV_blank>If<S2SV_blank>time<S2SV_blank>is<S2SV_blank>not<S2SV_blank>set<S2SV_blank>the<S2SV_blank>player<S2SV_blank>tries<S2SV_blank>to<S2SV_blank>auto-detect<S2SV_blank>the<S2SV_blank>music<S2SV_blank>duration.\\n" "<S2SV_blank>However<S2SV_blank>a<S2SV_blank>number<S2SV_blank>of<S2SV_blank>musics<S2SV_blank>are<S2SV_blank>going<S2SV_blank>into<S2SV_blank>unnecessary<S2SV_blank>loops<S2SV_blank>which<S2SV_blank>make\\n" "<S2SV_blank>it<S2SV_blank>harder<S2SV_blank>to<S2SV_blank>properly<S2SV_blank>detect.\\n" <S2SV_ModEnd> "\\n" "CHANS:\\n" "<S2SV_blank>Select<S2SV_blank>channels<S2SV_blank>to<S2SV_blank>be<S2SV_blank>either<S2SV_blank>muted<S2SV_blank>or<S2SV_blank>ignored.<S2SV_blank>It<S2SV_blank>can<S2SV_blank>be<S2SV_blank>either:\\n"
2,002
CWE-000 int picoquic_prepare_ack_frame ( picoquic_cnx_t * cnx , uint64_t current_time , uint8_t * bytes , size_t bytes_max , size_t * consumed ) { int ret = 0 ; size_t byte_index = 0 ; uint64_t num_block = 0 ; size_t l_largest = 0 ; size_t l_delay = 0 ; size_t l_first_range = 0 ; picoquic_sack_item_t * next_sack = cnx -> first_sack_item . next_sack ; uint64_t ack_delay = 0 ; uint64_t ack_range = 0 ; uint64_t ack_gap = 0 ; uint64_t lowest_acknowledged = 0 ; <S2SV_StartBug> size_t num_block_index = 0 ; <S2SV_EndBug> if ( cnx -> first_sack_item . start_of_sack_range == 0 && cnx -> first_sack_item . end_of_sack_range == 0 ) { * consumed = 0 ; } else if ( bytes_max < 13 ) { * consumed = 0 ; ret = PICOQUIC_ERROR_FRAME_BUFFER_TOO_SMALL ; } else { bytes [ byte_index ++ ] = picoquic_frame_type_ack ; if ( byte_index < bytes_max ) { l_largest = picoquic_varint_encode ( bytes + byte_index , bytes_max - byte_index , cnx -> first_sack_item . end_of_sack_range ) ; byte_index += l_largest ; } if ( byte_index < bytes_max ) { if ( current_time > cnx -> time_stamp_largest_received ) { ack_delay = current_time - cnx -> time_stamp_largest_received ; ack_delay >>= cnx -> local_parameters . ack_delay_exponent ; } l_delay = picoquic_varint_encode ( bytes + byte_index , bytes_max - byte_index , ack_delay ) ; byte_index += l_delay ; } num_block_index = byte_index ; byte_index ++ ; if ( byte_index < bytes_max ) { ack_range = cnx -> first_sack_item . end_of_sack_range - cnx -> first_sack_item . start_of_sack_range ; l_first_range = picoquic_varint_encode ( bytes + byte_index , bytes_max - byte_index , ack_range ) ; byte_index += l_first_range ; } if ( l_delay == 0 || l_largest == 0 || l_first_range == 0 || byte_index > bytes_max ) { * consumed = 0 ; ret = PICOQUIC_ERROR_FRAME_BUFFER_TOO_SMALL ; } else { lowest_acknowledged = cnx -> first_sack_item . start_of_sack_range ; while ( num_block < 63 && next_sack != NULL ) { size_t l_gap = 0 ; size_t l_range = 0 ; if ( byte_index < bytes_max ) { ack_gap = lowest_acknowledged - next_sack -> end_of_sack_range - 1 ; l_gap = picoquic_varint_encode ( bytes + byte_index , bytes_max - byte_index , ack_gap ) ; } if ( byte_index + l_gap < bytes_max ) { ack_range = next_sack -> end_of_sack_range - next_sack -> start_of_sack_range + 1 ; l_range = picoquic_varint_encode ( bytes + byte_index + l_gap , bytes_max - byte_index - l_gap , ack_range ) ; } if ( l_gap == 0 || l_range == 0 ) { break ; } else { byte_index += l_gap + l_range ; lowest_acknowledged = next_sack -> start_of_sack_range ; next_sack = next_sack -> next_sack ; num_block ++ ; } } bytes [ num_block_index ] = ( uint8_t ) num_block ; cnx -> highest_ack_sent = cnx -> first_sack_item . end_of_sack_range ; cnx -> highest_ack_time = current_time ; * consumed = byte_index ; } } if ( ret == 0 ) { cnx -> ack_needed = 0 ; } return ret ; }
<S2SV_ModStart> = 0 ; if ( cnx -> first_sack_item . end_of_sack_range == 0x0F ) { * consumed = 0 ; }
2,003
CWE-000 REB_R Datatype_Checker_Dispatcher ( REBFRM * f ) { <S2SV_StartBug> RELVAL * datatype = FUNC_BODY ( f -> func ) ; <S2SV_EndBug> assert ( IS_DATATYPE ( datatype ) ) ; if ( VAL_TYPE ( FRM_ARG ( f , 1 ) ) == VAL_TYPE_KIND ( datatype ) ) return R_TRUE ; return R_FALSE ; }
<S2SV_ModStart> ( f -> phase <S2SV_ModEnd> ) ; assert
2,004
CWE-000 static int skl_compute_plane_wm_params ( const struct drm_i915_private * dev_priv , struct intel_crtc_state * cstate , const struct intel_plane_state * intel_pstate , struct skl_wm_params * wp ) { struct intel_plane * plane = to_intel_plane ( intel_pstate -> base . plane ) ; const struct drm_plane_state * pstate = & intel_pstate -> base ; const struct drm_framebuffer * fb = pstate -> fb ; uint32_t interm_pbpl ; struct intel_atomic_state * state = to_intel_atomic_state ( cstate -> base . state ) ; bool apply_memory_bw_wa = skl_needs_memory_bw_wa ( state ) ; if ( ! intel_wm_plane_visible ( cstate , intel_pstate ) ) return 0 ; wp -> y_tiled = fb -> modifier == I915_FORMAT_MOD_Y_TILED || fb -> modifier == I915_FORMAT_MOD_Yf_TILED || fb -> modifier == I915_FORMAT_MOD_Y_TILED_CCS || fb -> modifier == I915_FORMAT_MOD_Yf_TILED_CCS ; wp -> x_tiled = fb -> modifier == I915_FORMAT_MOD_X_TILED ; wp -> rc_surface = fb -> modifier == I915_FORMAT_MOD_Y_TILED_CCS || fb -> modifier == I915_FORMAT_MOD_Yf_TILED_CCS ; if ( plane -> id == PLANE_CURSOR ) { wp -> width = intel_pstate -> base . crtc_w ; } else { wp -> width = drm_rect_width ( & intel_pstate -> base . src ) >> 16 ; } wp -> cpp = ( fb -> format -> format == DRM_FORMAT_NV12 ) ? fb -> format -> cpp [ 1 ] : fb -> format -> cpp [ 0 ] ; wp -> plane_pixel_rate = skl_adjusted_plane_pixel_rate ( cstate , intel_pstate ) ; <S2SV_StartBug> if ( drm_rotation_90_or_270 ( pstate -> rotation ) ) { <S2SV_EndBug> switch ( wp -> cpp ) { case 1 : wp -> y_min_scanlines = 16 ; break ; case 2 : wp -> y_min_scanlines = 8 ; break ; case 4 : wp -> y_min_scanlines = 4 ; break ; default : MISSING_CASE ( wp -> cpp ) ; return - EINVAL ; } } else { wp -> y_min_scanlines = 4 ; } if ( apply_memory_bw_wa ) wp -> y_min_scanlines *= 2 ; wp -> plane_bytes_per_line = wp -> width * wp -> cpp ; if ( wp -> y_tiled ) { interm_pbpl = DIV_ROUND_UP ( wp -> plane_bytes_per_line * <S2SV_StartBug> wp -> y_min_scanlines , 512 ) ; <S2SV_EndBug> if ( INTEL_GEN ( dev_priv ) >= 10 ) interm_pbpl ++ ; wp -> plane_blocks_per_line = div_fixed16 ( interm_pbpl , wp -> y_min_scanlines ) ; } else if ( wp -> x_tiled && IS_GEN9 ( dev_priv ) ) { <S2SV_StartBug> interm_pbpl = DIV_ROUND_UP ( wp -> plane_bytes_per_line , 512 ) ; <S2SV_EndBug> wp -> plane_blocks_per_line = u32_to_fixed16 ( interm_pbpl ) ; } else { <S2SV_StartBug> interm_pbpl = DIV_ROUND_UP ( wp -> plane_bytes_per_line , 512 ) + 1 ; <S2SV_EndBug> wp -> plane_blocks_per_line = u32_to_fixed16 ( interm_pbpl ) ; } wp -> y_tile_minimum = mul_u32_fixed16 ( wp -> y_min_scanlines , wp -> plane_blocks_per_line ) ; wp -> linetime_us = fixed16_to_u32_round_up ( intel_get_linetime_us ( cstate ) ) ; return 0 ; }
<S2SV_ModStart> ; if ( INTEL_GEN ( dev_priv ) >= 11 && fb -> modifier == I915_FORMAT_MOD_Yf_TILED && wp -> cpp == 8 ) wp -> dbuf_block_size = 256 ; else wp -> dbuf_block_size = 512 ; if ( <S2SV_ModStart> -> y_min_scanlines , wp -> dbuf_block_size <S2SV_ModEnd> ) ; if <S2SV_ModStart> -> plane_bytes_per_line , wp -> dbuf_block_size <S2SV_ModEnd> ) ; wp <S2SV_ModStart> -> plane_bytes_per_line , wp -> dbuf_block_size <S2SV_ModEnd> ) + 1
2,005
CWE-000 IndexScanState * ExecInitIndexScan ( IndexScan * node , EState * estate , int eflags ) { IndexScanState * indexstate ; Relation currentRelation ; bool relistarget ; indexstate = makeNode ( IndexScanState ) ; indexstate -> ss . ps . plan = ( Plan * ) node ; indexstate -> ss . ps . state = estate ; ExecAssignExprContext ( estate , & indexstate -> ss . ps ) ; indexstate -> ss . ps . targetlist = ( List * ) ExecInitExpr ( ( Expr * ) node -> scan . plan . targetlist , ( PlanState * ) indexstate ) ; indexstate -> ss . ps . qual = ( List * ) ExecInitExpr ( ( Expr * ) node -> scan . plan . qual , ( PlanState * ) indexstate ) ; indexstate -> indexqualorig = ( List * ) ExecInitExpr ( ( Expr * ) node -> indexqualorig , ( PlanState * ) indexstate ) ; # define INDEXSCAN_NSLOTS 2 ExecInitResultTupleSlot ( estate , & indexstate -> ss . ps ) ; ExecInitScanTupleSlot ( estate , & indexstate -> ss ) ; currentRelation = ExecOpenScanRelation ( estate , node -> scan . scanrelid ) ; indexstate -> ss . ss_currentRelation = currentRelation ; ExecAssignScanType ( & indexstate -> ss , RelationGetDescr ( currentRelation ) ) ; ExecAssignResultTypeFromTL ( & indexstate -> ss . ps ) ; <S2SV_StartBug> ExecAssignScanProjectionInfo ( & indexstate -> ss ) ; <S2SV_EndBug> if ( eflags & EXEC_FLAG_EXPLAIN_ONLY ) return indexstate ; relistarget = ExecRelationIsTargetRelation ( estate , node -> scan . scanrelid ) ; indexstate -> iss_RelationDesc = index_open ( node -> indexid , relistarget ? NoLock : AccessShareLock ) ; ExecIndexBuildScanKeys ( ( PlanState * ) indexstate , indexstate -> iss_RelationDesc , node -> indexqual , node -> indexstrategy , node -> indexsubtype , & indexstate -> iss_ScanKeys , & indexstate -> iss_NumScanKeys , & indexstate -> iss_RuntimeKeys , & indexstate -> iss_NumRuntimeKeys , NULL , NULL ) ; InitRuntimeKeysContext ( indexstate ) ; Assert ( NULL != indexstate -> iss_RuntimeContext ) ; indexstate -> iss_RuntimeKeysReady = false ; <S2SV_StartBug> initGpmonPktForIndexScan ( ( Plan * ) node , & indexstate -> ss . ps . gpmon_pkt , estate ) ; <S2SV_EndBug> indexstate -> ss . ps . delayEagerFree = ( ( eflags & ( EXEC_FLAG_REWIND | EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK ) ) != 0 ) ; return indexstate ; }
<S2SV_ModStart> indexstate -> ss ) ; initGpmonPktForIndexScan ( ( Plan * ) node , & indexstate -> ss . ps . gpmon_pkt , estate <S2SV_ModStart> = false ; <S2SV_ModEnd> indexstate -> ss
2,006
CWE-000 static bool rpi_init ( struct ra_ctx * ctx ) { struct priv * p = ctx -> priv = talloc_zero ( ctx , struct priv ) ; bcm_host_init ( ) ; vc_tv_register_callback ( tv_callback , ctx ) ; p -> egl_display = eglGetDisplay ( EGL_DEFAULT_DISPLAY ) ; if ( ! eglInitialize ( p -> egl_display , NULL , NULL ) ) { MP_FATAL ( ctx , "EGL<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>initialize.\\n" ) ; goto fail ; } if ( ! mpegl_create_context ( ctx , p -> egl_display , & p -> egl_context , & p -> egl_config ) ) goto fail ; if ( recreate_dispmanx ( ctx ) < 0 ) goto fail ; mpegl_load_functions ( & p -> gl , ctx -> log ) ; struct ra_gl_ctx_params params = { . swap_buffers = rpi_swap_buffers , . native_display_type = "MPV_RPI_WINDOW" , . native_display = p -> win_params , } ; if ( ! ra_gl_ctx_init ( ctx , & p -> gl , params ) ) goto fail ; <S2SV_StartBug> return true ; <S2SV_EndBug> fail : rpi_uninit ( ctx ) ; return false ; }
<S2SV_ModStart> goto fail ; ra_gl_ctx_resize ( ctx -> swapchain , ctx -> vo -> dwidth , ctx -> vo -> dheight , 0 ) ;
2,007
CWE-000 static void svc_attr_memory_release ( void ) { LOG_DBG ( "Attr<S2SV_blank>memory<S2SV_blank>release" ) ; memset ( attrs , 0 , sizeof ( attrs ) ) ; cur_attr_id = 0 ; <S2SV_StartBug> for ( size_t i = 0 ; i < cur_chunk_id ; i ++ ) { <S2SV_EndBug> k_free ( user_data_chunks [ i ] ) ; user_data_chunks [ i ] = NULL ; } cur_chunk_id = 0 ; cur_chunk_data_len = 0 ; }
<S2SV_ModStart> 0 ; i <= <S2SV_ModEnd> cur_chunk_id ; i
2,008
CWE-000 uint8_t gpcb_increment_tail ( GenericPacketCircularBuffer * gpcbs ) { <S2SV_StartBug> uint32_t temp_tail ; <S2SV_EndBug> temp_tail = gpcbs -> gpcb_tail ; gpcbs -> gpcb_tail ++ ; if ( gpcbs -> gpcb_tail >= gpcbs -> gpcb_size ) { gpcbs -> gpcb_tail = 0 ; } <S2SV_StartBug> if ( gpcbs -> gpcb_tail > gpcbs -> gpcb_head ) <S2SV_EndBug> { gpcbs -> gpcb_tail = temp_tail ; return GP_CIRC_BUFFER_ERROR_TAIL_CAUGHT_HEAD ; } <S2SV_StartBug> return GP_CIRC_BUFFER_SUCCESS ; <S2SV_EndBug> }
<S2SV_ModStart> uint32_t temp_tail ; if ( gpcbs -> gpcb_tail != gpcbs -> gpcb_head ) { <S2SV_ModStart> 0 ; } return GP_CIRC_BUFFER_SUCCESS ; } else { <S2SV_ModEnd> return GP_CIRC_BUFFER_ERROR_TAIL_CAUGHT_HEAD ; <S2SV_ModStart> GP_CIRC_BUFFER_ERROR_TAIL_CAUGHT_HEAD ; } <S2SV_ModEnd> } <S2SV_null> <S2SV_null>
2,009
CWE-000 <S2SV_StartBug> void control_select_pressed ( void ) { <S2SV_EndBug> control_change_state ( control_state -> select_pressed ) ; }
<S2SV_ModStart> void ) { spi ( 251 ) ;
2,010
CWE-000 static void iio_proxy_claim_light ( GsdPowerManager * manager , gboolean active ) { GError * error = NULL ; if ( manager -> priv -> iio_proxy == NULL ) return ; if ( ! manager -> priv -> backlight_available ) return ; if ( ! g_dbus_proxy_call_sync ( manager -> priv -> iio_proxy , active ? "ClaimLight" : "ReleaseLight" , NULL , G_DBUS_CALL_FLAGS_NONE , - 1 , NULL , & error ) ) { <S2SV_StartBug> g_warning ( "Call<S2SV_blank>to<S2SV_blank>ii-proxy<S2SV_blank>failed:<S2SV_blank>%s" , error -> message ) ; <S2SV_EndBug> g_error_free ( error ) ; } if ( active ) iio_proxy_changed ( manager ) ; }
<S2SV_ModStart> { g_warning ( "Call<S2SV_blank>to<S2SV_blank>iio-proxy<S2SV_blank>failed:<S2SV_blank>%s" <S2SV_ModEnd> , error ->
2,011
CWE-000 mxml_node_t * mxmlNewOpaque ( mxml_node_t * parent , const char * opaque ) { mxml_node_t * node ; <S2SV_StartBug> # ifdef DEBUG <S2SV_EndBug> fprintf ( stderr , "mxmlNewOpaque(parent=%p,<S2SV_blank>opaque=\\"%s\\")\\n" , parent , opaque ? opaque : "(null)" ) ; # endif if ( ! opaque ) return ( NULL ) ; if ( ( node = mxml_new ( parent , MXML_OPAQUE ) ) != NULL ) node -> value . opaque = PhDuplicateBytesZSafe ( ( char * ) opaque ) ; return ( node ) ; }
<S2SV_ModStart> node ; # if DEBUG > 1 <S2SV_ModEnd> fprintf ( stderr
2,012
CWE-000 CeCommandStatus_t command_replace_all ( CeCommand_t * command , void * user_data ) { if ( command -> arg_count != 0 ) return CE_COMMAND_PRINT_HELP ; CeApp_t * app = user_data ; <S2SV_StartBug> CommandContext_t command_context ; <S2SV_EndBug> if ( ! get_command_context ( app , & command_context ) ) return CE_COMMAND_NO_ACTION ; if ( command -> arg_count == 0 ) { app -> input_mode = enable_input_mode ( & app -> input_view , command_context . view , & app -> vim , "REPLACE<S2SV_blank>ALL" ) ; } else if ( command -> arg_count == 1 && command -> args [ 0 ] . type == CE_COMMAND_ARG_STRING ) { int64_t index = ce_vim_register_index ( '/' ) ; CeVimYank_t * yank = app -> vim . yanks + index ; if ( yank -> text ) { replace_all ( command_context . view , & app -> vim , yank -> text , command -> args [ 0 ] . string ) ; } } else { return CE_COMMAND_PRINT_HELP ; } return CE_COMMAND_SUCCESS ; }
<S2SV_ModStart> ; CommandContext_t command_context = { }
2,013
CWE-000 PLL_EXPORT double pll_core_edge_loglikelihood_ti_20x20_avx2 ( unsigned int sites , unsigned int rate_cats , const double * parent_clv , const unsigned int * parent_scaler , const unsigned char * tipchars , const unsigned int * tipmap , unsigned int tipmap_size , const double * pmatrix , double * * frequencies , const double * rate_weights , const unsigned int * pattern_weights , const double * invar_proportion , const int * invar_indices , const unsigned int * freqs_indices , double * persite_lnl ) { unsigned int n , i , j , m = 0 ; double logl = 0 ; double prop_invar = 0 ; const double * clvp = parent_clv ; const double * pmat ; const double * freqs = NULL ; double terma , terma_r ; double site_lk , inv_site_lk ; unsigned int cstate ; unsigned int scale_factors ; unsigned int states = 20 ; unsigned int states_padded = states ; __m256d xmm0 , xmm1 , xmm2 ; size_t displacement = ( states_padded - states ) * ( states_padded ) ; unsigned int span = states_padded * rate_cats ; unsigned int maxstates = tipmap_size ; double * lookup = pll_aligned_alloc ( maxstates * span * sizeof ( double ) , PLL_ALIGNMENT_AVX ) ; if ( ! lookup ) { pll_errno = PLL_ERROR_MEM_ALLOC ; snprintf ( pll_errmsg , 200 , "Cannot<S2SV_blank>allocate<S2SV_blank>space<S2SV_blank>for<S2SV_blank>precomputation." ) ; return 0. ; } double * ptr = lookup ; for ( j = 0 ; j < maxstates ; ++ j ) { pmat = pmatrix ; unsigned int state = tipmap [ j ] ; int ss = __builtin_popcount ( state ) == 1 ? __builtin_ctz ( state ) : - 1 ; for ( n = 0 ; n < rate_cats ; ++ n ) { freqs = frequencies [ freqs_indices [ n ] ] ; for ( i = 0 ; i < states ; ++ i ) { double terml ; if ( ss != - 1 ) { terml = pmat [ ss ] ; } else { terml = 0 ; for ( m = 0 ; m < states ; ++ m ) { if ( ( state >> m ) & 1 ) { terml += pmat [ m ] ; } } } pmat += states ; ptr [ i ] = terml * freqs [ i ] ; } ptr += states ; } } for ( n = 0 ; n < sites ; ++ n ) { terma = 0 ; cstate = ( unsigned int ) tipchars [ n ] ; unsigned int loffset = cstate * span ; for ( i = 0 ; i < rate_cats ; ++ i ) { xmm1 = _mm256_setzero_pd ( ) ; for ( j = 0 ; j < states_padded ; j += 4 ) { xmm2 = _mm256_load_pd ( lookup + loffset ) ; xmm0 = _mm256_load_pd ( clvp ) ; xmm1 = _mm256_fmadd_pd ( xmm2 , xmm0 , xmm1 ) ; clvp += 4 ; loffset += 4 ; } xmm0 = _mm256_hadd_pd ( xmm1 , xmm1 ) ; terma_r = ( ( double * ) & xmm0 ) [ 0 ] + ( ( double * ) & xmm0 ) [ 2 ] ; prop_invar = invar_proportion ? invar_proportion [ freqs_indices [ i ] ] : 0 ; if ( prop_invar > 0 ) { freqs = frequencies [ freqs_indices [ i ] ] ; inv_site_lk = ( invar_indices [ n ] == - 1 ) ? 0 : freqs [ invar_indices [ n ] ] ; terma += rate_weights [ i ] * ( terma_r * ( 1 - prop_invar ) + inv_site_lk * prop_invar ) ; } else { terma += terma_r * rate_weights [ i ] ; } pmat -= displacement ; } scale_factors = ( parent_scaler ) ? parent_scaler [ n ] : 0 ; site_lk = log ( terma ) ; if ( scale_factors ) site_lk += scale_factors * log ( PLL_SCALE_THRESHOLD ) ; site_lk *= pattern_weights [ n ] ; if ( persite_lnl ) <S2SV_StartBug> persite_lnl [ m ++ ] = site_lk ; <S2SV_EndBug> logl += site_lk ; } pll_aligned_free ( lookup ) ; return logl ; }
<S2SV_ModStart> ) persite_lnl [ n <S2SV_ModEnd> ] = site_lk
2,014
CWE-000 int main ( int argc , char * argv [ ] ) { if ( argc != 5 ) { printf ( "Usage:<S2SV_blank>./indexer<S2SV_blank>[postingbuffersize]<S2SV_blank>[mergebuffersize]<S2SV_blank>[WETdir]<S2SV_blank>[OutputDir]\\n" ) ; } else { size_t postingbuffer = strtoull ( argv [ 1 ] , NULL , 0 ) ; size_t mergebuffer = strtoull ( argv [ 2 ] , NULL , 0 ) ; char * WET = argv [ 3 ] ; char * output = argv [ 4 ] ; struct timeval t1 , t2 ; double elapsedtime ; gettimeofday ( & t1 , NULL ) ; DirReader * reader = dirreader_new ( WET ) ; PostingGenerator * postinggen = postinggen_new ( output , postingbuffer ) ; PageTable * table = pagetable_new ( ) ; Document doc ; printf ( "Generating<S2SV_blank>intermediate<S2SV_blank>files...\\n" ) ; <S2SV_StartBug> int i = 0 ; <S2SV_EndBug> while ( i < 200 ) { doc = dirreader_getDocument ( reader ) ; if ( dirreader_getStatus ( reader ) ) break ; pagetable_add ( table , doc . url , doc . docsize ) ; postinggen_addDoc ( postinggen , doc ) ; <S2SV_StartBug> reader_freedoc ( & doc ) ; <S2SV_EndBug> i ++ ; } postinggen_flush ( postinggen ) ; postinggen_free ( postinggen ) ; dirreader_free ( reader ) ; gettimeofday ( & t2 , NULL ) ; elapsedtime = ( t2 . tv_sec - t1 . tv_sec ) ; printf ( "Merging<S2SV_blank>intermediate<S2SV_blank>files...<S2SV_blank>(%fs)\\n" , elapsedtime ) ; merge ( output , "merged" , mergebuffer ) ; gettimeofday ( & t2 , NULL ) ; elapsedtime = ( t2 . tv_sec - t1 . tv_sec ) ; printf ( "Building<S2SV_blank>final<S2SV_blank>index...<S2SV_blank>(%fs)\\n" , elapsedtime ) ; Lexicon * lex = block_buildIndex ( output , "merged" , "index" ) ; FILE * lfp = fopen ( "output/lexicon" , "wb" ) ; lexicon_dump ( & lex , lfp ) ; fclose ( lfp ) ; lexicon_free ( & lex ) ; FILE * tfp = fopen ( "output/pagetable" , "wb" ) ; pagetable_dump ( table , tfp ) ; fclose ( tfp ) ; pagetable_free ( table ) ; gettimeofday ( & t2 , NULL ) ; elapsedtime = ( t2 . tv_sec - t1 . tv_sec ) ; printf ( "Done<S2SV_blank>(%fs)\\n" , elapsedtime ) ; } return 0 ; }
<S2SV_ModStart> "Generating<S2SV_blank>intermediate<S2SV_blank>files...\\n" ) ; while ( 1 <S2SV_ModEnd> ) { doc <S2SV_ModStart> & doc ) <S2SV_ModEnd> ; } postinggen_flush
2,015
CWE-000 VOID VmDirCloseClientConnectionImpl ( PVM_DIR_CONNECTION pConnection ) { if ( pConnection -> fd > - 1 ) { <S2SV_StartBug> close ( pConnection -> fd ) ; <S2SV_EndBug> pConnection -> fd = - 1 ; } }
<S2SV_ModStart> 1 ) { tcp_socket_close <S2SV_ModEnd> ( pConnection ->
2,016
CWE-000 void sector_all_decrease_hsv_color ( HSVColorName color ) { for ( uint8_t sector = 0 ; sector < SECTOR_MAX ; ++ sector ) <S2SV_StartBug> sector_decrease_sector_hsv_by_name ( sector , color ) ; <S2SV_EndBug> is31fl3733_91tkl_update_led_pwm ( & issi ) ; }
<S2SV_ModStart> ++ sector ) if ( sector_is_enabled ( sector ) )
2,017
CWE-000 LIBXSMM_API void libxsmm_set_target_archid ( int id ) { int target_archid = LIBXSMM_TARGET_ARCH_UNKNOWN ; <S2SV_StartBug> switch ( id ) { <S2SV_EndBug> case LIBXSMM_X86_AVX512_CORE : case LIBXSMM_X86_AVX512_KNM : case LIBXSMM_X86_AVX512_MIC : case LIBXSMM_X86_AVX512 : case LIBXSMM_X86_AVX2 : case LIBXSMM_X86_AVX : case LIBXSMM_X86_SSE4 : case LIBXSMM_X86_SSE3 : case LIBXSMM_TARGET_ARCH_GENERIC : { target_archid = id ; } break ; default : if ( LIBXSMM_X86_GENERIC <= id ) { target_archid = LIBXSMM_X86_GENERIC ; } else { target_archid = libxsmm_cpuid ( ) ; } } LIBXSMM_ATOMIC_STORE ( & libxsmm_target_archid , target_archid , LIBXSMM_ATOMIC_RELAXED ) ; if ( 0 != libxsmm_verbosity ) { const int cpuid = libxsmm_cpuid ( ) ; if ( cpuid < target_archid ) { const char * const target_arch = internal_get_target_arch ( target_archid ) ; fprintf ( stderr , "LIBXSMM<S2SV_blank>WARNING:<S2SV_blank>\\"%s\\"<S2SV_blank>code<S2SV_blank>will<S2SV_blank>fail<S2SV_blank>to<S2SV_blank>run<S2SV_blank>on<S2SV_blank>\\"%s\\"!\\n" , target_arch , internal_get_target_arch ( cpuid ) ) ; } } }
<S2SV_ModStart> id ) { case LIBXSMM_X86_AVX512_ICL :
2,018
CWE-000 uint64_t efi_add_memory_map ( uint64_t start , uint64_t pages , int memory_type , bool overlap_only_ram ) { struct list_head * lhandle ; struct efi_mem_list * newlist ; bool carve_again ; uint64_t carved_pages = 0 ; debug ( "%s:<S2SV_blank>0x%" PRIx64 "<S2SV_blank>0x%" PRIx64 "<S2SV_blank>%d<S2SV_blank>%s\\n" , __func__ , start , pages , memory_type , overlap_only_ram ? "yes" : "no" ) ; if ( memory_type >= EFI_MAX_MEMORY_TYPE ) return EFI_INVALID_PARAMETER ; if ( ! pages ) return start ; ++ efi_memory_map_key ; newlist = calloc ( 1 , sizeof ( * newlist ) ) ; newlist -> desc . type = memory_type ; newlist -> desc . physical_start = start ; newlist -> desc . virtual_start = start ; newlist -> desc . num_pages = pages ; switch ( memory_type ) { case EFI_RUNTIME_SERVICES_CODE : case EFI_RUNTIME_SERVICES_DATA : <S2SV_StartBug> newlist -> desc . attribute = ( 1 << EFI_MEMORY_WB_SHIFT ) | <S2SV_EndBug> ( 1ULL << EFI_MEMORY_RUNTIME_SHIFT ) ; break ; case EFI_MMAP_IO : <S2SV_StartBug> newlist -> desc . attribute = 1ULL << EFI_MEMORY_RUNTIME_SHIFT ; <S2SV_EndBug> break ; default : <S2SV_StartBug> newlist -> desc . attribute = 1 << EFI_MEMORY_WB_SHIFT ; <S2SV_EndBug> break ; } do { carve_again = false ; list_for_each ( lhandle , & efi_mem ) { struct efi_mem_list * lmem ; s64 r ; lmem = list_entry ( lhandle , struct efi_mem_list , link ) ; r = efi_mem_carve_out ( lmem , & newlist -> desc , overlap_only_ram ) ; switch ( r ) { case EFI_CARVE_OVERLAPS_NONRAM : return 0 ; case EFI_CARVE_NO_OVERLAP : break ; case EFI_CARVE_LOOP_AGAIN : carve_again = true ; break ; default : carved_pages += r ; carve_again = true ; break ; } if ( carve_again ) { break ; } } } while ( carve_again ) ; if ( overlap_only_ram && ( carved_pages != pages ) ) { return 0 ; } list_add_tail ( & newlist -> link , & efi_mem ) ; efi_mem_sort ( ) ; return start ; }
<S2SV_ModStart> . attribute = EFI_MEMORY_WB | EFI_MEMORY_RUNTIME <S2SV_ModEnd> ; break ; <S2SV_ModStart> . attribute = EFI_MEMORY_RUNTIME <S2SV_ModEnd> ; break ; <S2SV_ModStart> . attribute = EFI_MEMORY_WB <S2SV_ModEnd> ; break ;
2,019
CWE-000 static int thread_start_func_2 ( rb_thread_t * th , VALUE * stack_start , VALUE * register_stack_start ) { enum ruby_tag_type state ; VALUE args = th -> first_args ; rb_thread_list_t * join_list ; rb_thread_t * main_th ; VALUE errinfo = Qnil ; # ifdef USE_SIGALTSTACK void rb_register_sigaltstack ( rb_thread_t * th ) ; rb_register_sigaltstack ( th ) ; # endif if ( th == th -> vm -> main_thread ) rb_bug ( "thread_start_func_2<S2SV_blank>must<S2SV_blank>not<S2SV_blank>be<S2SV_blank>used<S2SV_blank>for<S2SV_blank>main<S2SV_blank>thread" ) ; <S2SV_StartBug> ruby_thread_set_native ( th ) ; <S2SV_EndBug> th -> ec -> machine . stack_start = stack_start ; # ifdef __ia64 th -> ec -> machine . register_stack_start = register_stack_start ; # endif thread_debug ( "thread<S2SV_blank>start:<S2SV_blank>%p\\n" , ( void * ) th ) ; gvl_acquire ( th -> vm , th ) ; { thread_debug ( "thread<S2SV_blank>start<S2SV_blank>(get<S2SV_blank>lock):<S2SV_blank>%p\\n" , ( void * ) th ) ; rb_thread_set_current ( th ) ; EC_PUSH_TAG ( th -> ec ) ; if ( ( state = EC_EXEC_TAG ( ) ) == TAG_NONE ) { SAVE_ROOT_JMPBUF ( th , thread_do_start ( th , args ) ) ; } else { errinfo = th -> ec -> errinfo ; if ( state == TAG_FATAL ) { } else if ( rb_obj_is_kind_of ( errinfo , rb_eSystemExit ) ) { } else { if ( th -> report_on_exception ) { VALUE mesg = rb_thread_to_s ( th -> self ) ; rb_str_cat_cstr ( mesg , "<S2SV_blank>terminated<S2SV_blank>with<S2SV_blank>exception<S2SV_blank>(report_on_exception<S2SV_blank>is<S2SV_blank>true):\\n" ) ; rb_write_error_str ( mesg ) ; rb_ec_error_print ( th -> ec , errinfo ) ; } if ( th -> vm -> thread_abort_on_exception || th -> abort_on_exception || RTEST ( ruby_debug ) ) { } else { errinfo = Qnil ; } } th -> value = Qnil ; } th -> status = THREAD_KILLED ; thread_debug ( "thread<S2SV_blank>end:<S2SV_blank>%p\\n" , ( void * ) th ) ; main_th = th -> vm -> main_thread ; if ( main_th == th ) { ruby_stop ( 0 ) ; } if ( RB_TYPE_P ( errinfo , T_OBJECT ) ) { rb_threadptr_raise ( main_th , 1 , & errinfo ) ; } EC_POP_TAG ( ) ; rb_ec_clear_current_thread_trace_func ( th -> ec ) ; if ( th -> locking_mutex != Qfalse ) { rb_bug ( "thread_start_func_2:<S2SV_blank>locking_mutex<S2SV_blank>must<S2SV_blank>not<S2SV_blank>be<S2SV_blank>set<S2SV_blank>(%p:%" PRIxVALUE ")" , ( void * ) th , th -> locking_mutex ) ; } rb_vm_living_threads_remove ( th -> vm , th ) ; if ( main_th -> status == THREAD_KILLED && rb_thread_alone ( ) ) { rb_threadptr_interrupt ( main_th ) ; } join_list = th -> join_list ; while ( join_list ) { rb_threadptr_interrupt ( join_list -> th ) ; switch ( join_list -> th -> status ) { case THREAD_STOPPED : case THREAD_STOPPED_FOREVER : join_list -> th -> status = THREAD_RUNNABLE ; default : break ; } join_list = join_list -> next ; } rb_threadptr_unlock_all_locking_mutexes ( th ) ; rb_check_deadlock ( th -> vm ) ; rb_fiber_close ( th -> ec -> fiber_ptr ) ; } rb_native_mutex_lock ( & th -> vm -> thread_destruct_lock ) ; th -> vm -> running_thread = NULL ; rb_native_mutex_unlock ( & th -> vm -> thread_destruct_lock ) ; thread_cleanup_func ( th , FALSE ) ; gvl_release ( th -> vm ) ; return 0 ; }
<S2SV_ModStart> ) ; ruby_thread_set_native ( th ) ; rb_threadptr_root_fiber_setup_by_child
2,020
CWE-000 <S2SV_StartBug> void le_pm_Relax <S2SV_EndBug> ( le_pm_WakeupSourceRef_t w ) { <S2SV_StartBug> return ; <S2SV_EndBug> }
<S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> le_result_t <S2SV_ModEnd> le_pm_Relax ( le_pm_WakeupSourceRef_t <S2SV_ModStart> ) { return LE_OK
2,021
CWE-000 const sockaddr_t * get_recent_address ( address_cache_t * cache ) { if ( cache -> tried < cache -> data . used ) { return & cache -> data . address [ cache -> tried ++ ] ; } while ( cache -> tried == cache -> data . used ) { if ( ! cache -> ai ) { cache -> aip = cache -> ai = get_known_addresses ( cache -> node ) ; } if ( cache -> ai ) { if ( cache -> aip ) { sockaddr_t * sa = ( sockaddr_t * ) cache -> aip ; if ( find_cached ( cache , sa ) != NOT_CACHED ) { continue ; } cache -> aip = cache -> aip -> ai_next ; return sa ; } else { free_known_addresses ( cache -> ai ) ; cache -> ai = NULL ; } } cache -> tried ++ ; } if ( ! cache -> config_tree ) { init_configuration ( & cache -> config_tree ) ; read_host_config ( cache -> config_tree , cache -> node -> name , false ) ; cache -> cfg = lookup_config ( cache -> config_tree , "Address" ) ; } while ( cache -> cfg && ! cache -> ai ) { char * address , * port ; get_config_string ( cache -> cfg , & address ) ; char * space = strchr ( address , '<S2SV_blank>' ) ; if ( space ) { port = xstrdup ( space + 1 ) ; * space = 0 ; } else { if ( ! get_config_string ( lookup_config ( cache -> config_tree , "Port" ) , & port ) ) { port = xstrdup ( "655" ) ; } } cache -> aip = cache -> ai = str2addrinfo ( address , port , SOCK_STREAM ) ; free ( address ) ; free ( port ) ; cache -> cfg = lookup_config_next ( cache -> config_tree , cache -> cfg ) ; } if ( cache -> aip ) { sockaddr_t * sa = ( sockaddr_t * ) cache -> aip -> ai_addr ; cache -> aip = cache -> aip -> ai_next ; if ( ! cache -> aip ) { <S2SV_StartBug> freeaddrinfo ( cache -> aip ) ; <S2SV_EndBug> cache -> aip = NULL ; } return sa ; } exit_configuration ( & cache -> config_tree ) ; return false ; }
<S2SV_ModStart> ( cache -> ai ) ; cache -> ai = <S2SV_ModEnd> cache -> aip
2,022
CWE-000 static int compare_by_type ( NautilusFile * file_1 , NautilusFile * file_2 ) { gboolean is_directory_1 ; gboolean is_directory_2 ; char * type_string_1 ; char * type_string_2 ; int result ; is_directory_1 = nautilus_file_is_directory ( file_1 ) ; is_directory_2 = nautilus_file_is_directory ( file_2 ) ; if ( is_directory_1 && is_directory_2 ) { return 0 ; } if ( is_directory_1 ) { return - 1 ; } if ( is_directory_2 ) { return + 1 ; } if ( file_1 -> details -> mime_type != NULL && file_2 -> details -> mime_type != NULL && strcmp ( eel_ref_str_peek ( file_1 -> details -> mime_type ) , eel_ref_str_peek ( file_2 -> details -> mime_type ) ) == 0 ) { return 0 ; } <S2SV_StartBug> type_string_1 = nautilus_file_get_type_as_string ( file_1 ) ; <S2SV_EndBug> type_string_2 = nautilus_file_get_type_as_string ( file_2 ) ; if ( type_string_1 == NULL || type_string_2 == NULL ) { if ( type_string_1 != NULL ) { return - 1 ; } if ( type_string_2 != NULL ) { return 1 ; } return 0 ; } result = g_utf8_collate ( type_string_1 , type_string_2 ) ; g_free ( type_string_1 ) ; g_free ( type_string_2 ) ; return result ; }
<S2SV_ModStart> } type_string_1 = nautilus_file_get_type_as_string_no_extra_text ( file_1 ) ; type_string_2 = nautilus_file_get_type_as_string_no_extra_text <S2SV_ModEnd> ( file_2 )
2,023
CWE-000 static int msm_comm_get_inst_load ( struct msm_vidc_inst * inst , enum load_calc_quirks quirks ) { int load = 0 ; if ( ! ( inst -> state >= MSM_VIDC_OPEN_DONE && inst -> state < MSM_VIDC_STOP_DONE ) ) return 0 ; load = msm_comm_get_mbs_per_sec ( inst ) ; if ( is_thumbnail_session ( inst ) ) { if ( quirks & LOAD_CALC_IGNORE_THUMBNAIL_LOAD ) load = 0 ; } if ( is_turbo_session ( inst ) ) { if ( ! ( quirks & LOAD_CALC_IGNORE_TURBO_LOAD ) ) load = inst -> core -> resources . max_load ; } if ( is_non_realtime_session ( inst ) && ( quirks & LOAD_CALC_IGNORE_NON_REALTIME_LOAD ) ) { if ( ! inst -> prop . fps ) { <S2SV_StartBug> dprintk ( VIDC_INFO , "%s:<S2SV_blank>instance:%p<S2SV_blank>prop->fps<S2SV_blank>is<S2SV_blank>set<S2SV_blank>0\\n" , __func__ , inst ) ; <S2SV_EndBug> load = 0 ; } else load = msm_comm_get_mbs_per_sec ( inst ) / inst -> prop . fps ; } return load ; }
<S2SV_ModStart> ( VIDC_INFO , "%s:<S2SV_blank>instance:%pK<S2SV_blank>prop->fps<S2SV_blank>is<S2SV_blank>set<S2SV_blank>0\\n" <S2SV_ModEnd> , __func__ ,
2,024
CWE-000 void abAppend ( struct abuf * ab , const char * s , int len ) { char * new = realloc ( ab -> b , ab -> len + len ) ; <S2SV_StartBug> if ( new == NULL ) return ; <S2SV_EndBug> memcpy ( & new [ ab -> len ] , s , len ) ; ab -> b = new ; ab -> len += len ; }
<S2SV_ModStart> == NULL ) { return ; } <S2SV_ModEnd> memcpy ( &
2,025
CWE-000 static bool digest_matches ( int fd , const char * file , const struct sudo_digest * sd ) { unsigned char * file_digest = NULL ; unsigned char * sudoers_digest = NULL ; bool matched = false ; size_t digest_len ; debug_decl ( digest_matches , SUDOERS_DEBUG_MATCH ) file_digest = sudo_filedigest ( fd , file , sd -> digest_type , & digest_len ) ; <S2SV_StartBug> lseek ( fd , SEEK_SET , ( off_t ) 0 ) ; <S2SV_EndBug> if ( file_digest == NULL ) { goto done ; } if ( ( sudoers_digest = malloc ( digest_len ) ) == NULL ) { sudo_warnx ( U_ ( "%s:<S2SV_blank>%s" ) , __func__ , U_ ( "unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory" ) ) ; goto done ; } if ( strlen ( sd -> digest_str ) == digest_len * 2 ) { unsigned int i ; for ( i = 0 ; i < digest_len ; i ++ ) { const int h = hexchar ( & sd -> digest_str [ i + i ] ) ; if ( h == - 1 ) goto bad_format ; sudoers_digest [ i ] = ( unsigned char ) h ; } } else { size_t len = base64_decode ( sd -> digest_str , sudoers_digest , digest_len ) ; if ( len != digest_len ) { sudo_debug_printf ( SUDO_DEBUG_ERROR | SUDO_DEBUG_LINENO , "incorrect<S2SV_blank>length<S2SV_blank>for<S2SV_blank>digest,<S2SV_blank>expected<S2SV_blank>%zu,<S2SV_blank>got<S2SV_blank>%zu" , digest_len , len ) ; goto bad_format ; } } if ( memcmp ( file_digest , sudoers_digest , digest_len ) == 0 ) { matched = true ; } else { sudo_debug_printf ( SUDO_DEBUG_DIAG | SUDO_DEBUG_LINENO , "%s<S2SV_blank>digest<S2SV_blank>mismatch<S2SV_blank>for<S2SV_blank>%s,<S2SV_blank>expecting<S2SV_blank>%s" , digest_type_to_name ( sd -> digest_type ) , file , sd -> digest_str ) ; } goto done ; bad_format : sudo_warnx ( U_ ( "digest<S2SV_blank>for<S2SV_blank>%s<S2SV_blank>(%s)<S2SV_blank>is<S2SV_blank>not<S2SV_blank>in<S2SV_blank>%s<S2SV_blank>form" ) , file , sd -> digest_str , digest_type_to_name ( sd -> digest_type ) ) ; done : free ( sudoers_digest ) ; free ( file_digest ) ; debug_return_bool ( matched ) ; }
<S2SV_ModStart> digest_len ) ; ( void ) <S2SV_ModStart> ( fd , ( off_t ) 0 , SEEK_SET <S2SV_ModEnd> ) ; if
2,026
CWE-000 static void rt_mutex_init_task ( struct task_struct * p ) { raw_spin_lock_init ( & p -> pi_lock ) ; # ifdef CONFIG_RT_MUTEXES p -> pi_waiters = RB_ROOT ; p -> pi_waiters_leftmost = NULL ; p -> pi_blocked_on = NULL ; <S2SV_StartBug> # endif <S2SV_EndBug> }
<S2SV_ModStart> = NULL ; p -> pi_top_task = NULL ;
2,027
CWE-000 static void mod_sub_overwrite ( struct bt_mesh_model * model , struct bt_mesh_msg_ctx * ctx , struct net_buf_simple * buf ) { u16_t elem_addr , sub_addr ; struct bt_mesh_model * mod ; struct bt_mesh_elem * elem ; u8_t * mod_id ; u8_t status ; bool vnd ; elem_addr = net_buf_simple_pull_le16 ( buf ) ; sub_addr = net_buf_simple_pull_le16 ( buf ) ; BT_DBG ( "elem_addr<S2SV_blank>0x%04x<S2SV_blank>sub_addr<S2SV_blank>0x%04x" , elem_addr , sub_addr ) ; mod_id = buf -> data ; elem = bt_mesh_elem_find ( elem_addr ) ; if ( ! elem ) { mod = NULL ; vnd = ( buf -> len == 4 ) ; status = STATUS_INVALID_ADDRESS ; goto send_status ; } mod = get_model ( elem , buf , & vnd ) ; if ( ! mod ) { status = STATUS_INVALID_MODEL ; goto send_status ; } if ( ! BT_MESH_ADDR_IS_GROUP ( sub_addr ) ) { status = STATUS_INVALID_ADDRESS ; goto send_status ; } if ( IS_ENABLED ( CONFIG_BT_MESH_LOW_POWER ) ) { bt_mesh_lpn_group_del ( mod -> groups , ARRAY_SIZE ( mod -> groups ) ) ; } <S2SV_StartBug> memset ( mod -> groups , 0 , sizeof ( mod -> groups ) ) ; <S2SV_EndBug> if ( ARRAY_SIZE ( mod -> groups ) > 0 ) { mod -> groups [ 0 ] = sub_addr ; status = STATUS_SUCCESS ; if ( IS_ENABLED ( CONFIG_BT_MESH_LOW_POWER ) ) { bt_mesh_lpn_group_add ( sub_addr ) ; } } else { status = STATUS_INSUFF_RESOURCES ; } send_status : send_mod_sub_status ( model , ctx , status , elem_addr , sub_addr , mod_id , vnd ) ; }
<S2SV_ModStart> ) ; } mod_sub_list_clear ( mod <S2SV_ModEnd> ) ; if
2,028
CWE-000 <S2SV_StartBug> int check_exec ( char * exec_path ) <S2SV_EndBug> { struct stat exec_stat ; if ( ! access ( exec_path , X_OK ) && ! lstat ( exec_path , & exec_stat ) ) { if ( ( exec_stat . st_mode & S_IXUSR ) && ( exec_stat . st_mode & S_IXGRP ) && ( exec_stat . st_mode & S_IXOTH ) ) return ( 1 ) ; else { handle_error ( exec_path , NO_EXEC_PERM ) ; return ( 0 ) ; } } return ( 0 ) ; }
<S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static
2,029
CWE-000 static void __unlink_buffer ( struct dm_buffer * b ) { struct dm_bufio_client * c = b -> c ; BUG_ON ( ! c -> n_buffers [ b -> list_mode ] ) ; c -> n_buffers [ b -> list_mode ] -- ; <S2SV_StartBug> hlist_del ( & b -> hash_list ) ; <S2SV_EndBug> list_del ( & b -> lru_list ) ; }
<S2SV_ModStart> ] -- ; __remove ( b -> c , b <S2SV_ModEnd> ) ; list_del
2,030
CWE-000 static irq_return_t ti816x_interrupt_mactxint0 ( unsigned int irq_num , void * dev_id ) { struct ti816x_priv * dev_priv ; int eoq ; ipl_t sp ; struct emac_desc * desc ; struct emac_desc_head * hdesc ; assert ( DEFAULT_MASK == REG_LOAD ( EMAC_CTRL_BASE + EMAC_R_CMTXINTSTAT ) ) ; <S2SV_StartBug> log_debug ( "ti<S2SV_blank>tx<S2SV_blank>int" ) ; <S2SV_EndBug> dev_priv = netdev_priv ( dev_id , struct ti816x_priv ) ; assert ( dev_priv != NULL ) ; <S2SV_StartBug> desc = dev_priv -> tx_cur_head ; <S2SV_EndBug> do { hdesc = head_from_desc ( desc ) ; dcache_inval ( desc , sizeof * desc ) ; assert ( CHECK_TXOK ( desc -> flags ) ) ; assert ( ! CHECK_TXERR ( desc -> flags ) ) ; eoq = desc -> flags & EMAC_DESC_F_EOQ ; emac_desc_confirm ( desc , EMAC_R_TXCP ( DEFAULT_CHANNEL ) ) ; desc = ( void * ) desc -> next ; skb_free ( hdesc -> skb ) ; emac_hdesc_tx_free ( hdesc ) ; } while ( ! eoq && desc ) ; assert ( eoq && ! desc ) ; sp = ipl_save ( ) ; { dev_priv -> tx_cur_head = dev_priv -> tx_wait_head ; if ( dev_priv -> tx_cur_head ) { emac_queue_activate ( dev_priv -> tx_cur_head , EMAC_R_TXHDP ( DEFAULT_CHANNEL ) ) ; dev_priv -> tx_wait_head = dev_priv -> tx_wait_tail = NULL ; } } ipl_restore ( sp ) ; <S2SV_StartBug> REG_STORE ( EMAC_BASE + EMAC_R_MACEOIVECTOR , TXEOI ) ; <S2SV_EndBug> return IRQ_HANDLED ; }
<S2SV_ModStart> ) ) ; <S2SV_ModEnd> dev_priv = netdev_priv <S2SV_ModStart> -> tx_cur_head ; if ( desc == NULL ) { return IRQ_HANDLED ; } <S2SV_ModStart> sp ) ; emac_eoi ( <S2SV_ModEnd> TXEOI ) ;
2,031
CWE-000 static int setup ( struct ukvm_hv * hv ) { if ( netiface == NULL ) return - 1 ; netfd = tap_attach ( netiface ) ; if ( netfd < 0 ) { err ( 1 , "Could<S2SV_blank>not<S2SV_blank>attach<S2SV_blank>interface:<S2SV_blank>%s" , netiface ) ; exit ( 1 ) ; } if ( ! cmdline_mac ) { int rfd = open ( "/dev/urandom" , O_RDONLY ) ; if ( rfd == - 1 ) err ( 1 , "Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>/dev/urandom" ) ; uint8_t guest_mac [ 6 ] ; int ret ; ret = read ( rfd , guest_mac , sizeof ( guest_mac ) ) ; assert ( ret == sizeof ( guest_mac ) ) ; close ( rfd ) ; guest_mac [ 0 ] &= 0xfe ; guest_mac [ 0 ] |= 0x02 ; <S2SV_StartBug> uint64_t val = 0xf6e358284e50 ; <S2SV_EndBug> <S2SV_StartBug> memcpy ( netinfo . mac_address , & val , sizeof netinfo . mac_address ) ; <S2SV_EndBug> } if ( use_shm_stream ) { int flags = fcntl ( netfd , F_GETFL , 0 ) ; fcntl ( netfd , F_SETFL , flags | O_NONBLOCK ) ; if ( configure_shmstream ( hv ) ) { err ( 1 , "Failed<S2SV_blank>to<S2SV_blank>configure<S2SV_blank>shmstream" ) ; exit ( 1 ) ; } } assert ( ukvm_core_register_hypercall ( UKVM_HYPERCALL_NETINFO , hypercall_netinfo ) == 0 ) ; assert ( ukvm_core_register_hypercall ( UKVM_HYPERCALL_NETWRITE , hypercall_netwrite ) == 0 ) ; assert ( ukvm_core_register_hypercall ( UKVM_HYPERCALL_NETREAD , hypercall_netread ) == 0 ) ; assert ( ukvm_core_register_hypercall ( UKVM_HYPERCALL_NET_SHMINFO , hypercall_net_shm_info ) == 0 ) ; if ( use_event_thread ) { assert ( ukvm_core_register_hypercall ( UKVM_HYPERCALL_NETXON , hypercall_netxon ) == 0 ) ; assert ( ukvm_core_register_hypercall ( UKVM_HYPERCALL_NETNOTIFY , hypercall_netnotify ) == 0 ) ; } if ( use_shm_stream ) { assert ( ukvm_core_register_pollfd ( solo5_rx_fd , read_solo5_rx_fd ) == 0 ) ; if ( use_event_thread ) { assert ( ukvm_core_register_pollfd ( solo5_tx_xon_fd , read_solo5_tx_xon_fd ) == 0 ) ; } } else { assert ( ukvm_core_register_pollfd ( netfd , NULL ) == 0 ) ; } return 0 ; }
<S2SV_ModStart> |= 0x02 ; <S2SV_ModEnd> memcpy ( netinfo <S2SV_ModStart> mac_address , & guest_mac <S2SV_ModEnd> , sizeof netinfo
2,032
CWE-000 static void foo ( const char * p1 , int p2 ) { <S2SV_StartBug> if ( strcmp ( p1 , "hello" ) != 0 ) <S2SV_EndBug> ASSERT ( 0 ) ; }
<S2SV_ModStart> p2 ) { ( void ) p2 ; ASSERT <S2SV_ModEnd> ( strcmp ( <S2SV_ModStart> , "hello" ) == <S2SV_ModEnd> 0 ) ;
2,033
CWE-000 <S2SV_StartBug> static int handle_minln ( char * s , char * ml , int i , t_flags * fl ) <S2SV_EndBug> { <S2SV_StartBug> int j ; <S2SV_EndBug> if ( i < fl -> min_lenth ) { ml = ( char * ) ft_memalloc ( sizeof ( char ) * ( fl -> min_lenth + 2 ) ) ; j = fl -> minus ? i : 0 ; while ( j < fl -> min_lenth && ! fl -> minus ) ml [ j ++ ] = ( fl -> zero && ! fl -> precs_spec ) ? '0' : '<S2SV_blank>' ; while ( i > 0 ) ml [ -- j ] = s [ -- i ] ; j = fl -> minus ? ft_strlen ( s ) : 0 ; while ( j < fl -> min_lenth && fl -> minus ) ml [ j ++ ] = '<S2SV_blank>' ; free ( s ) ; j = ft_putstr ( ml ) ; free ( ml ) ; return ( j ) ; } j = ( int ) write ( 1 , s , i ) ; free ( s ) ; return ( j ) ; }
<S2SV_ModStart> * s , unsigned <S2SV_ModEnd> int i , <S2SV_ModStart> fl ) { unsigned int j ; char * ml <S2SV_ModEnd> ; if (
2,034
CWE-000 static void dtrace_load ( void * dummy ) { dtrace_provider_id_t id ; # ifdef EARLY_AP_STARTUP int i ; # endif # ifndef illumos if ( dtrace_allow_destructive ) dtrace_destructive_disallow = 0 ; else dtrace_destructive_disallow = 1 ; # endif dtrace_trap_func = dtrace_trap ; dtrace_vtime_switch_func = dtrace_vtime_switch ; dtrace_invop_init ( ) ; dtrace_taskq = taskq_create ( "dtrace_taskq" , 1 , maxclsyspri , 0 , 0 , 0 ) ; dtrace_arena = new_unrhdr ( 1 , INT_MAX , & dtrace_unr_mtx ) ; dtrace_kld_load_tag = EVENTHANDLER_REGISTER ( kld_load , dtrace_kld_load , NULL , EVENTHANDLER_PRI_ANY ) ; dtrace_kld_unload_try_tag = EVENTHANDLER_REGISTER ( kld_unload_try , dtrace_kld_unload_try , NULL , EVENTHANDLER_PRI_ANY ) ; mutex_init ( & dtrace_lock , "dtrace<S2SV_blank>probe<S2SV_blank>state" , MUTEX_DEFAULT , NULL ) ; mutex_init ( & dtrace_instance_lock , "dtrace<S2SV_blank>instance<S2SV_blank>state" , MUTEX_DEFAULT , NULL ) ; mutex_init ( & dtrace_provider_lock , "dtrace<S2SV_blank>provider<S2SV_blank>state" , MUTEX_DEFAULT , NULL ) ; mutex_init ( & dtrace_meta_lock , "dtrace<S2SV_blank>meta-provider<S2SV_blank>state" , MUTEX_DEFAULT , NULL ) ; # ifdef DEBUG mutex_init ( & dtrace_errlock , "dtrace<S2SV_blank>error<S2SV_blank>lock" , MUTEX_DEFAULT , NULL ) ; # endif dtrace_instance_seed = arc4random ( ) ; mutex_enter ( & dtrace_instance_lock ) ; mutex_enter ( & dtrace_provider_lock ) ; mutex_enter ( & dtrace_lock ) ; mutex_enter ( & cpu_lock ) ; ASSERT ( MUTEX_HELD ( & cpu_lock ) ) ; dtrace_state_cache = kmem_cache_create ( "dtrace_state_cache" , sizeof ( dtrace_dstate_percpu_t ) * NCPU , DTRACE_STATE_ALIGN , NULL , NULL , NULL , NULL , NULL , 0 ) ; ASSERT ( MUTEX_HELD ( & cpu_lock ) ) ; dtrace_istc_probes = kmem_zalloc ( DTRACE_MAX_INSTANCES * sizeof ( dtrace_probe_t * * ) , KM_SLEEP ) ; dtrace_istc_probecount = kmem_zalloc ( DTRACE_MAX_INSTANCES * sizeof ( uint32_t ) , KM_SLEEP ) ; dtrace_istc_names = kmem_zalloc ( DTRACE_MAX_INSTANCES * sizeof ( char * ) , KM_SLEEP ) ; dtrace_byinstance = dtrace_hash_create ( offsetof ( dtrace_probe_t , dtpr_instance ) , offsetof ( dtrace_probe_t , dtpr_nextinstance ) , offsetof ( dtrace_probe_t , dtpr_previnstance ) ) ; dtrace_bymod = dtrace_hash_create ( offsetof ( dtrace_probe_t , dtpr_mod ) , offsetof ( dtrace_probe_t , dtpr_nextmod ) , offsetof ( dtrace_probe_t , dtpr_prevmod ) ) ; dtrace_byfunc = dtrace_hash_create ( offsetof ( dtrace_probe_t , dtpr_func ) , offsetof ( dtrace_probe_t , dtpr_nextfunc ) , offsetof ( dtrace_probe_t , dtpr_prevfunc ) ) ; dtrace_byname = dtrace_hash_create ( offsetof ( dtrace_probe_t , dtpr_name ) , offsetof ( dtrace_probe_t , dtpr_nextname ) , offsetof ( dtrace_probe_t , dtpr_prevname ) ) ; if ( dtrace_retain_max < 1 ) { cmn_err ( CE_WARN , "illegal<S2SV_blank>value<S2SV_blank>(%lu)<S2SV_blank>for<S2SV_blank>dtrace_retain_max;<S2SV_blank>" "setting<S2SV_blank>to<S2SV_blank>1" , dtrace_retain_max ) ; dtrace_retain_max = 1 ; } dtrace_toxic_ranges ( dtrace_toxrange_add ) ; ( void ) dtrace_register ( "dtrace" , & dtrace_provider_attr , DTRACE_PRIV_NONE , 0 , & dtrace_provider_ops , NULL , & id ) ; ASSERT ( dtrace_provider != NULL ) ; ASSERT ( ( dtrace_provider_id_t ) dtrace_provider == id ) ; <S2SV_StartBug> dtrace_provider -> dtpv_next = NULL ; <S2SV_EndBug> dtrace_probeid_begin = dtrace_probe_create ( ( dtrace_provider_id_t ) dtrace_provider , NULL , NULL , "BEGIN" , 0 , NULL ) ; dtrace_probeid_end = dtrace_probe_create ( ( dtrace_provider_id_t ) dtrace_provider , NULL , NULL , "END" , 0 , NULL ) ; dtrace_probeid_error = dtrace_probe_create ( ( dtrace_provider_id_t ) dtrace_provider , NULL , NULL , "ERROR" , 1 , NULL ) ; mutex_exit ( & cpu_lock ) ; mutex_exit ( & dtrace_lock ) ; mutex_exit ( & dtrace_provider_lock ) ; mutex_exit ( & dtrace_instance_lock ) ; mutex_enter ( & cpu_lock ) ; # ifdef EARLY_AP_STARTUP CPU_FOREACH ( i ) { ( void ) dtrace_cpu_setup ( CPU_CONFIG , i ) ; } # else ( void ) dtrace_cpu_setup ( CPU_CONFIG , 0 ) ; # endif mutex_exit ( & cpu_lock ) ; dtrace_dev = make_dev ( & dtrace_cdevsw , 0 , UID_ROOT , GID_WHEEL , 0600 , "dtrace/dtrace" ) ; helper_dev = make_dev ( & helper_cdevsw , 0 , UID_ROOT , GID_WHEEL , 0660 , "dtrace/helper" ) ; return ; }
<S2SV_ModStart> id ) ; printf ( "dtrace_provider->dtpv_instance<S2SV_blank>=<S2SV_blank>%s\\n" , dtrace_provider -> dtpv_instance ) ;
2,035
CWE-000 static int au_cmoo ( struct dentry * dentry ) { <S2SV_StartBug> int err , cmoo ; <S2SV_EndBug> unsigned int udba ; struct path h_path ; struct au_pin pin ; struct au_cp_generic cpg = { . dentry = dentry , . bdst = - 1 , . bsrc = - 1 , . len = - 1 , . pin = & pin , . flags = AuCpup_DTIME | AuCpup_HOPEN } ; struct inode * delegated ; struct super_block * sb ; struct au_sbinfo * sbinfo ; struct au_fhsm * fhsm ; pid_t pid ; struct au_branch * br ; struct dentry * parent ; struct au_hinode * hdir ; DiMustWriteLock ( dentry ) ; IiMustWriteLock ( d_inode ( dentry ) ) ; err = 0 ; if ( IS_ROOT ( dentry ) ) goto out ; cpg . bsrc = au_dbtop ( dentry ) ; if ( ! cpg . bsrc ) goto out ; sb = dentry -> d_sb ; sbinfo = au_sbi ( sb ) ; fhsm = & sbinfo -> si_fhsm ; pid = au_fhsm_pid ( fhsm ) ; <S2SV_StartBug> if ( pid <S2SV_EndBug> && ( current -> pid == pid <S2SV_StartBug> || current -> real_parent -> pid == pid ) ) <S2SV_EndBug> goto out ; br = au_sbr ( sb , cpg . bsrc ) ; cmoo = au_br_cmoo ( br -> br_perm ) ; if ( ! cmoo ) goto out ; if ( ! d_is_reg ( dentry ) ) cmoo &= AuBrAttr_COO_ALL ; if ( ! cmoo ) goto out ; parent = dget_parent ( dentry ) ; di_write_lock_parent ( parent ) ; err = au_wbr_do_copyup_bu ( dentry , cpg . bsrc - 1 ) ; cpg . bdst = err ; if ( unlikely ( err < 0 ) ) { err = 0 ; goto out_dgrade ; } AuDbg ( "bsrc<S2SV_blank>%d,<S2SV_blank>bdst<S2SV_blank>%d\\n" , cpg . bsrc , cpg . bdst ) ; err = au_cpup_dirs ( dentry , cpg . bdst ) ; if ( unlikely ( err ) ) goto out_dgrade ; di_downgrade_lock ( parent , AuLock_IR ) ; udba = au_opt_udba ( sb ) ; err = au_pin ( & pin , dentry , cpg . bdst , udba , AuPin_DI_LOCKED | AuPin_MNT_WRITE ) ; if ( unlikely ( err ) ) goto out_parent ; err = au_sio_cpup_simple ( & cpg ) ; au_unpin ( & pin ) ; if ( unlikely ( err ) ) goto out_parent ; if ( ! ( cmoo & AuBrWAttr_MOO ) ) goto out_parent ; err = au_pin ( & pin , dentry , cpg . bsrc , udba , AuPin_DI_LOCKED | AuPin_MNT_WRITE ) ; if ( unlikely ( err ) ) goto out_parent ; h_path . mnt = au_br_mnt ( br ) ; h_path . dentry = au_h_dptr ( dentry , cpg . bsrc ) ; hdir = au_hi ( d_inode ( parent ) , cpg . bsrc ) ; delegated = NULL ; err = vfsub_unlink ( hdir -> hi_inode , & h_path , & delegated , 1 ) ; au_unpin ( & pin ) ; if ( unlikely ( err == - EWOULDBLOCK ) ) { pr_warn ( "cannot<S2SV_blank>retry<S2SV_blank>for<S2SV_blank>NFSv4<S2SV_blank>delegation" "<S2SV_blank>for<S2SV_blank>an<S2SV_blank>internal<S2SV_blank>unlink\\n" ) ; iput ( delegated ) ; } if ( unlikely ( err ) ) { pr_err ( "unlink<S2SV_blank>%pd<S2SV_blank>after<S2SV_blank>coo<S2SV_blank>failed<S2SV_blank>(%d),<S2SV_blank>ignored\\n" , dentry , err ) ; err = 0 ; } goto out_parent ; out_dgrade : di_downgrade_lock ( parent , AuLock_IR ) ; out_parent : di_read_unlock ( parent , AuLock_IR ) ; dput ( parent ) ; out : AuTraceErr ( err ) ; return err ; }
<S2SV_ModStart> err , cmoo , matched <S2SV_ModStart> fhsm ) ; rcu_read_lock ( ) ; matched = <S2SV_ModEnd> ( pid && <S2SV_ModStart> == pid || rcu_dereference ( <S2SV_ModStart> current -> real_parent ) <S2SV_ModStart> pid ) ) ; rcu_read_unlock ( ) ; if ( matched )
2,036
CWE-000 int lookup_is_exported_symbol ( struct lookup_table * table , char * name ) { <S2SV_StartBug> struct symbol * sym ; <S2SV_EndBug> int i ; <S2SV_StartBug> char export [ 255 ] = "__ksymtab_" ; <S2SV_EndBug> strncat ( export , name , 254 ) ; <S2SV_StartBug> for_each_symbol ( i , sym , table ) <S2SV_EndBug> <S2SV_StartBug> if ( ! sym -> skip && ! strcmp ( sym -> name , export ) ) <S2SV_EndBug> return 1 ; return 0 ; }
<S2SV_ModStart> ) { struct export_symbol * sym , * match = NULL <S2SV_ModEnd> ; int i <S2SV_ModStart> int i ; for_each_exp_symbol <S2SV_ModEnd> ( i , <S2SV_ModStart> , table ) { if ( <S2SV_ModEnd> ! strcmp ( <S2SV_ModStart> -> name , name ) ) { if ( match ) ERROR ( "duplicate<S2SV_blank>exported<S2SV_blank>symbol<S2SV_blank>found<S2SV_blank>for<S2SV_blank>%s" , name ) ; match = sym ; } } return ! ! match <S2SV_ModEnd> ; } <S2SV_null>
2,037
CWE-000 void PuttyInterface_Init ( PuttyInterfaceTypeDef * pitd ) { pitd -> huart2_Rx_len = 0 ; char * startmessage = "----------PuttyInterface_Init-----------\\n\\r" ; uprintf ( startmessage ) ; # ifdef PUTTY_USART <S2SV_StartBug> HAL_UART_Receive_IT ( & huart2 , pitd -> rec_buf , 1 ) ; <S2SV_EndBug> # endif }
<S2SV_ModStart> HAL_UART_Receive_IT ( & huartx <S2SV_ModEnd> , pitd ->
2,038
CWE-000 <S2SV_StartBug> static PHP_METHOD ( Phalcon_Assets_Inline , getType ) { <S2SV_EndBug> zval * this_ptr = getThis ( ) ; <S2SV_StartBug> RETURN_MEMBER ( getThis ( ) , "_type" ) ; <S2SV_EndBug> }
<S2SV_ModStart> static PHP_METHOD ( Phalcon_Session_Factory , load ) { zend_long ZEPHIR_LAST_CALL_STATUS ; zval * config , * _0 ; ZEPHIR_MM_GROW <S2SV_ModEnd> ( ) ; <S2SV_ModStart> ( ) ; zephir_fetch_params ( 1 , 1 , 0 , & config ) ; ZEPHIR_INIT_VAR ( _0 ) ; ZVAL_STRING ( _0 , "Phalcon\\\\Session\\\\Adapter" , ZEPHIR_TEMP_PARAM_COPY ) ; ZEPHIR_RETURN_CALL_SELF ( "loadclass" , NULL , 0 , _0 , config ) ; zephir_check_temp_parameter ( _0 ) ; zephir_check_call_status ( ) ; RETURN_MM ( <S2SV_ModEnd> ) ; }
2,039
CWE-000 <S2SV_StartBug> sexpr_t * eval_if ( scope_t * s , sexpr_t * expr ) { <S2SV_EndBug> <S2SV_StartBug> if ( istrue ( eval_sexpr ( s , car ( expr ) ) ) ) <S2SV_EndBug> <S2SV_StartBug> return eval_sexpr ( s , cadr ( expr ) ) ; <S2SV_EndBug> else <S2SV_StartBug> return eval_sexpr ( s , caddr ( expr ) ) ; <S2SV_EndBug> }
<S2SV_ModStart> ( scope_t * scope <S2SV_ModEnd> , sexpr_t * <S2SV_ModStart> expr ) { err_raise ( ERR_ARG_COUNT , sexpr_length ( expr ) != 3 ) ; if ( err_log ( ) ) return sexpr_err ( ) ; <S2SV_ModStart> ( eval_sexpr ( scope <S2SV_ModEnd> , car ( <S2SV_ModStart> return eval_sexpr ( scope <S2SV_ModEnd> , cadr ( <S2SV_ModStart> return eval_sexpr ( scope <S2SV_ModEnd> , caddr (
2,040
CWE-000 void * L5_pool ( void * data ) { int * dataBis = data ; int width = dataBis [ 0 ] ; int height = dataBis [ 1 ] ; pthread_t pthread ; int j ; int tab [ 2 ] ; tab [ 0 ] = width ; <S2SV_StartBug> while ( l5Treated < width ) <S2SV_EndBug> { pthread_mutex_lock ( & l5MutexTab ) ; for ( j = 0 ; j < height ; ++ j ) { <S2SV_StartBug> if ( tab [ j ] == 0 ) <S2SV_EndBug> { l5Tab [ j ] = 1 ; l5Treated ++ ; tab [ 1 ] = j ; break ; } } pthread_mutex_unlock ( & l5MutexTab ) ; pthread_create ( & pthread , NULL , L5_line , tab ) ; pthread_join ( pthread , NULL ) ; } return NULL ; }
<S2SV_ModStart> ( l5Treated < height <S2SV_ModEnd> ) { pthread_mutex_lock <S2SV_ModStart> { if ( l5Tab <S2SV_ModEnd> [ j ]
2,041
CWE-000 RECID HF_GetNextRec ( int fileDesc , RECID recId , char * record ) { int error ; HFftab_ele * hfftab_ele ; size_t bytes_in_bitmap , amount_of_slots ; char * pagebuf ; hfftab_ele = HFftab + fileDesc ; error = PF_GetThisPage ( hfftab_ele -> fd , recId . pagenum , & pagebuf ) ; if ( error != PFE_OK ) PF_ErrorHandler ( error ) ; bytes_in_bitmap = HF_GetBytesInBitmap ( hfftab_ele -> header . rec_page ) ; <S2SV_StartBug> memcpy ( ( size_t * ) & amount_of_slots , ( int * ) ( * pagebuf ) + bytes_in_bitmap , sizeof ( int ) ) ; <S2SV_EndBug> if ( recId . recnum > amount_of_slots ) HF_ErrorHandler ( HFE_INVALIDRECORD ) ; else if ( recId . recnum == amount_of_slots ) { recId . recnum = 0 ; recId . pagenum ++ ; <S2SV_StartBug> } <S2SV_EndBug> HF_GetThisRec ( fileDesc , recId , record ) ; return recId ; }
<S2SV_ModStart> * ) ( <S2SV_ModEnd> pagebuf ) + <S2SV_ModStart> ++ ; } else { recId . recnum ++ ; }
2,042
CWE-000 SEXP ps__define_signals ( ) { SEXP signalenv = PROTECT ( Rf_allocSExp ( ENVSXP ) ) ; <S2SV_StartBug> # define PS_ADD_SIGNAL ( sig ) defineVar ( install ( # sig ) , ScalarInteger ( sig ) , signalenv ) <S2SV_EndBug> # ifdef SIGHUP PS_ADD_SIGNAL ( SIGHUP ) ; # endif # ifdef SIGINT PS_ADD_SIGNAL ( SIGINT ) ; # endif # ifdef SIGQUIT PS_ADD_SIGNAL ( SIGQUIT ) ; # endif # ifdef SIGILL PS_ADD_SIGNAL ( SIGILL ) ; # endif # ifdef SIGTRAP PS_ADD_SIGNAL ( SIGTRAP ) ; # endif # ifdef SIGABRT PS_ADD_SIGNAL ( SIGABRT ) ; # endif # ifdef SIGEMT PS_ADD_SIGNAL ( SIGEMT ) ; # endif # ifdef SIGFPE PS_ADD_SIGNAL ( SIGFPE ) ; # endif # ifdef SIGKILL PS_ADD_SIGNAL ( SIGKILL ) ; # endif # ifdef SIGBUS PS_ADD_SIGNAL ( SIGBUS ) ; # endif # ifdef SIGSEGV PS_ADD_SIGNAL ( SIGSEGV ) ; # endif # ifdef SIGSYS PS_ADD_SIGNAL ( SIGSYS ) ; # endif # ifdef SIGPIPE PS_ADD_SIGNAL ( SIGPIPE ) ; # endif # ifdef SIGALRM PS_ADD_SIGNAL ( SIGALRM ) ; # endif # ifdef SIGTERM PS_ADD_SIGNAL ( SIGTERM ) ; # endif # ifdef SIGURG PS_ADD_SIGNAL ( SIGURG ) ; # endif # ifdef SIGSTOP PS_ADD_SIGNAL ( SIGSTOP ) ; # endif # ifdef SIGTSTP PS_ADD_SIGNAL ( SIGTSTP ) ; # endif # ifdef SIGCONT PS_ADD_SIGNAL ( SIGCONT ) ; # endif # ifdef SIGCHLD PS_ADD_SIGNAL ( SIGCHLD ) ; # endif # ifdef SIGTTIN PS_ADD_SIGNAL ( SIGTTIN ) ; # endif # ifdef SIGTTOU PS_ADD_SIGNAL ( SIGTTOU ) ; # endif # ifdef SIGIO PS_ADD_SIGNAL ( SIGIO ) ; # endif # ifdef SIGXCPU PS_ADD_SIGNAL ( SIGXCPU ) ; # endif # ifdef SIGXFSZ PS_ADD_SIGNAL ( SIGXFSZ ) ; # endif # ifdef SIGVTALRM PS_ADD_SIGNAL ( SIGVTALRM ) ; # endif # ifdef SIGPROF PS_ADD_SIGNAL ( SIGPROF ) ; # endif # ifdef SIGWINCH PS_ADD_SIGNAL ( SIGWINCH ) ; # endif # ifdef SIGINFO PS_ADD_SIGNAL ( SIGINFO ) ; # endif # ifdef SIGUSR1 PS_ADD_SIGNAL ( SIGUSR1 ) ; # endif # ifdef SIGUSR2 PS_ADD_SIGNAL ( SIGUSR2 ) ; # endif # ifdef SIGPOLL PS_ADD_SIGNAL ( SIGPOLL ) ; # endif # ifdef SIGIOT PS_ADD_SIGNAL ( SIGIOT ) ; # endif # ifdef SIGSTKFLT PS_ADD_SIGNAL ( SIGSTKFLT ) ; # endif # ifdef SIGCLD PS_ADD_SIGNAL ( SIGCLD ) ; # endif # ifdef SIGPWR PS_ADD_SIGNAL ( SIGPWR ) ; # endif # ifdef SIGLOST PS_ADD_SIGNAL ( SIGLOST ) ; # endif # ifdef SIGUNUSED PS_ADD_SIGNAL ( SIGUNUSED ) ; # endif # undef PS_ADD_SIGNAL UNPROTECT ( 1 ) ; return signalenv ; }
<S2SV_ModStart> sig ) , PROTECT ( <S2SV_ModStart> ScalarInteger ( sig ) <S2SV_ModStart> , signalenv ) ; UNPROTECT ( 1 )
2,043
CWE-000 void save_board ( char * path ) { <S2SV_StartBug> FILE * fp ; <S2SV_EndBug> int i ; int j ; if ( ( GAME_MODE != 1 ) && ( GAME_MODE != 2 ) ) { printf ( "ERROR:<S2SV_blank>invalid<S2SV_blank>command\\n" ) ; return ; } else if ( GAME_MODE == 1 ) { if ( check_if_board_erroneous ( ) ) { printf ( "ERROR:<S2SV_blank>board<S2SV_blank>contains<S2SV_blank>erroneous<S2SV_blank>values\\n" ) ; return ; } if ( validate_solution ( ) == 0 ) { printf ( "ERROR:<S2SV_blank>board<S2SV_blank>validation<S2SV_blank>failed\\n" ) ; return ; } } fp = fopen ( path , "w+" ) ; if ( fp == NULL ) { printf ( "Error:<S2SV_blank>File<S2SV_blank>cannot<S2SV_blank>be<S2SV_blank>created<S2SV_blank>or<S2SV_blank>modified\\n" ) ; return ; } else { save_board_to_file ( fp ) ; } fclose ( fp ) ; printf ( "Saved<S2SV_blank>to:<S2SV_blank>%s\\n" , path ) ; }
<S2SV_ModStart> FILE * fp <S2SV_ModEnd> ; if (
2,044
CWE-000 void FIFO_Flush ( FIFO_t * fifo ) <S2SV_StartBug> { <S2SV_EndBug> fifo -> r = 0 ; fifo -> w = 0 ; fifo -> n = 0 ; }
<S2SV_ModStart> fifo ) { memset ( fifo -> buf , 0 , fifo -> len * sizeof ( uint8_t ) ) ;
2,045
CWE-000 void common_timer_get ( struct k_itimer * timr , struct itimerspec64 * cur_setting ) { const struct k_clock * kc = timr -> kclock ; ktime_t now , remaining , iv ; struct timespec64 ts64 ; bool sig_none ; <S2SV_StartBug> sig_none = ( timr -> it_sigev_notify & ~ SIGEV_THREAD_ID ) == SIGEV_NONE ; <S2SV_EndBug> iv = timr -> it_interval ; if ( iv ) { cur_setting -> it_interval = ktime_to_timespec64 ( iv ) ; } else if ( ! timr -> it_active ) { if ( ! sig_none ) return ; } kc -> clock_get ( timr -> it_clock , & ts64 ) ; now = timespec64_to_ktime ( ts64 ) ; if ( iv && ( timr -> it_requeue_pending & REQUEUE_PENDING || sig_none ) ) timr -> it_overrun += kc -> timer_forward ( timr , now ) ; remaining = kc -> timer_remaining ( timr , now ) ; if ( remaining <= 0 ) { if ( ! sig_none ) cur_setting -> it_value . tv_nsec = 1 ; } else { cur_setting -> it_value = ktime_to_timespec64 ( remaining ) ; } }
<S2SV_ModStart> ; sig_none = <S2SV_ModEnd> timr -> it_sigev_notify <S2SV_ModStart> timr -> it_sigev_notify <S2SV_ModEnd> == SIGEV_NONE ;
2,046
CWE-000 <S2SV_StartBug> void WaveTransformation ( struct BeachGrid * grid , struct BeachNode * shoreline , double wave_angle , double wave_period , double wave_height ) <S2SV_EndBug> { double start_depth = 3 * wave_height ; double refract_step = 0.2 ; double k_break = 0.5 ; struct BeachNode * curr = shoreline ; do { curr -> transport_potential = 0 ; if ( ( * grid ) . CheckIfInShadow ( grid , curr , wave_angle ) ) { curr = curr -> next ; continue ; } double alpha_deep ; double shore_angle = ( * grid ) . GetAngleByDifferencingScheme ( grid , curr , wave_angle ) ; if ( shore_angle == EMPTY_DOUBLE ) { alpha_deep = PI / 4 ; } else { alpha_deep = wave_angle - shore_angle ; } if ( abs ( alpha_deep > ( 0.995 * PI / 2 ) ) ) { curr = curr -> next ; continue ; } double local_wave_height = wave_height ; double c_deep = ( GRAVITY * wave_period ) / ( 2 * PI ) ; double l_deep = c_deep * wave_period ; double local_depth = start_depth ; double local_alpha ; do { double wave_length = l_deep * raise ( tanh ( raise ( ( local_depth / GRAVITY ) * raise ( ( 2 * PI / wave_period ) , 2 ) , 3 / 4 ) ) , 2 / 3 ) ; double local_c = wave_length / wave_period ; double kh = 2 * PI * local_depth / wave_length ; double n = 0.5 * ( 1 + 2.0 * kh / sinh ( 2.0 * kh ) ) ; local_alpha = asin ( local_c / c_deep * sin ( alpha_deep ) ) ; local_wave_height = wave_height * sqrt ( ( c_deep * cos ( alpha_deep ) ) / ( local_c * 2 * n * cos ( local_alpha ) ) ) ; local_depth -= refract_step ; } while ( local_wave_height <= k_break * local_depth && local_depth >= refract_step ) ; curr -> transport_potential = ( wave_angle - ( * grid ) . GetRightAngle ( grid , curr ) ) > 0 ? RIGHT : LEFT ; curr -> transport_potential = GetTransportVolumePotential ( local_alpha , local_wave_height ) ; curr = curr -> next ; <S2SV_StartBug> } while ( curr != shoreline ) ; <S2SV_EndBug> return ; }
<S2SV_ModStart> * grid , double wave_angle , double wave_period , double wave_height ) { double start_depth = 3 * wave_height ; double refract_step = 0.2 ; double k_break = 0.5 ; <S2SV_ModStart> struct BeachNode * curr = grid -> <S2SV_ModEnd> shoreline ; do <S2SV_ModStart> ( curr != grid ->
2,047
CWE-000 void derivePhases ( int rxIdx , int sbIdx , int pntIdx ) { int a1 , a2 , nFitParams , refAnt ; float refAngle , fitParams [ 2 * N_ANTENNAS ] , scaleParams [ 2 * N_ANTENNAS ] ; float fTol = 1.0e-6 ; nFitParams = nAntennas * 2 ; for ( a1 = 0 ; a1 < nAntennas ; a1 ++ ) { fitParams [ a1 ] = fitParams [ a1 + nAntennas ] = 0.0 ; scaleParams [ a1 ] = scaleParams [ a1 + nAntennas ] = 0.0 ; } for ( a1 = 0 ; a1 < nAntennas - 1 ; a1 ++ ) { for ( a2 = a1 + 1 ; a2 < nAntennas ; a2 ++ ) { fitParams [ a1 ] += sqrt ( ( intData [ a1 ] [ a2 ] [ 0 ] * intData [ a1 ] [ a2 ] [ 0 ] ) + ( intData [ a1 ] [ a2 ] [ 1 ] * intData [ a1 ] [ a2 ] [ 1 ] ) ) ; fitParams [ a2 ] += sqrt ( ( intData [ 0 ] [ a1 ] [ a2 ] * intData [ 0 ] [ a1 ] [ a2 ] ) + ( intData [ a1 ] [ a2 ] [ 1 ] * intData [ a1 ] [ a2 ] [ 1 ] ) ) ; } } refAnt = 0 ; <S2SV_StartBug> for ( a1 = 1 ; a1 < nAntennas ; a1 ++ ) { <S2SV_EndBug> fitParams [ a1 ] = sqrt ( fitParams [ a1 ] / ( ( float ) ( nAntennas - 1.0 ) ) ) ; fitParams [ a1 + nAntennas ] = fitParams [ a1 ] ; if ( fitParams [ refAnt ] < fitParams [ a1 ] ) { refAnt = a1 ; } } for ( a1 = 0 ; a1 < nAntennas ; a1 ++ ) { scaleParams [ a1 ] = fitParams [ a1 ] / 4.0 ; scaleParams [ a1 + nAntennas ] = fitParams [ a1 + nAntennas ] / 4.0 ; if ( a1 == refAnt ) { refAngle = scaleParams [ a1 + nAntennas ] = 0.0 ; } else if ( a1 > refAnt ) { refAngle = - atan2 ( intData [ refAnt ] [ a1 ] [ 1 ] , intData [ refAnt ] [ a1 ] [ 0 ] ) ; } else { refAngle = atan2 ( intData [ a1 ] [ refAnt ] [ 1 ] , intData [ a1 ] [ refAnt ] [ 0 ] ) ; } fitParams [ a1 ] *= cos ( refAngle ) ; fitParams [ a1 + nAntennas ] *= sin ( refAngle ) ; } try_amoeba ( fitParams , scaleParams , 2 * nAntennas , meritPhaseFunction , fTol ) ; for ( a1 = 0 ; a1 < nAntennas ; a1 ++ ) { gainPhase [ rxIdx ] [ sbIdx ] [ a1 ] = atan2 ( fitParams [ a1 + nAntennas ] , fitParams [ a1 ] ) ; } }
<S2SV_ModStart> ( a1 = 0 <S2SV_ModEnd> ; a1 <
2,048
CWE-000 static int alsa_open ( struct sound_params * sound_params ) { int rc , result = 0 ; unsigned int period_time , buffer_time ; char fmt_name [ 128 ] ; const char * device ; snd_pcm_hw_params_t * hw_params ; assert ( ! handle ) ; params . format = format_to_mask ( sound_params -> fmt & SFMT_MASK_FORMAT ) ; if ( params . format == SND_PCM_FORMAT_UNKNOWN ) { error ( "Unknown<S2SV_blank>sample<S2SV_blank>format:<S2SV_blank>%s" , sfmt_str ( sound_params -> fmt , fmt_name , sizeof ( fmt_name ) ) ) ; return 0 ; } device = options_get_str ( "ALSADevice" ) ; logit ( "Opening<S2SV_blank>ALSA<S2SV_blank>device:<S2SV_blank>%s" , device ) ; hw_params = alsa_open_device ( device ) ; if ( ! hw_params ) return 0 ; rc = snd_pcm_hw_params_set_access ( handle , hw_params , SND_PCM_ACCESS_RW_INTERLEAVED ) ; if ( rc < 0 ) { error_errno ( "Can\'t<S2SV_blank>set<S2SV_blank>ALSA<S2SV_blank>access<S2SV_blank>type" , rc ) ; goto err ; } rc = snd_pcm_hw_params_set_format ( handle , hw_params , params . format ) ; if ( rc < 0 ) { error_errno ( "Can\'t<S2SV_blank>set<S2SV_blank>sample<S2SV_blank>format" , rc ) ; goto err ; } bytes_per_sample = sfmt_Bps ( sound_params -> fmt ) ; logit ( "Set<S2SV_blank>sample<S2SV_blank>width:<S2SV_blank>%d<S2SV_blank>bytes" , bytes_per_sample ) ; <S2SV_StartBug> params . rate = sound_params -> rate ; <S2SV_EndBug> rc = snd_pcm_hw_params_set_rate_near ( handle , hw_params , & params . rate , 0 ) ; if ( rc < 0 ) { error_errno ( "Can\'t<S2SV_blank>set<S2SV_blank>sample<S2SV_blank>rate" , rc ) ; goto err ; } logit ( "Set<S2SV_blank>rate:<S2SV_blank>%uHz" , params . rate ) ; rc = snd_pcm_hw_params_set_channels ( handle , hw_params , sound_params -> channels ) ; if ( rc < 0 ) { error_errno ( "Can\'t<S2SV_blank>set<S2SV_blank>number<S2SV_blank>of<S2SV_blank>channels" , rc ) ; goto err ; } logit ( "Set<S2SV_blank>channels:<S2SV_blank>%d" , sound_params -> channels ) ; rc = snd_pcm_hw_params_get_buffer_time_max ( hw_params , & buffer_time , 0 ) ; if ( rc < 0 ) { error_errno ( "Can\'t<S2SV_blank>get<S2SV_blank>maximum<S2SV_blank>buffer<S2SV_blank>time" , rc ) ; goto err ; } buffer_time = MIN ( buffer_time , BUFFER_MAX_USEC ) ; period_time = buffer_time / 4 ; rc = snd_pcm_hw_params_set_period_time_near ( handle , hw_params , & period_time , 0 ) ; if ( rc < 0 ) { error_errno ( "Can\'t<S2SV_blank>set<S2SV_blank>period<S2SV_blank>time" , rc ) ; goto err ; } rc = snd_pcm_hw_params_set_buffer_time_near ( handle , hw_params , & buffer_time , 0 ) ; if ( rc < 0 ) { error_errno ( "Can\'t<S2SV_blank>set<S2SV_blank>buffer<S2SV_blank>time" , rc ) ; goto err ; } rc = snd_pcm_hw_params ( handle , hw_params ) ; if ( rc < 0 ) { error_errno ( "Can\'t<S2SV_blank>set<S2SV_blank>audio<S2SV_blank>parameters" , rc ) ; goto err ; } snd_pcm_hw_params_get_period_size ( hw_params , & chunk_frames , 0 ) ; debug ( "Chunk<S2SV_blank>size:<S2SV_blank>%lu<S2SV_blank>frames" , chunk_frames ) ; snd_pcm_hw_params_get_buffer_size ( hw_params , & buffer_frames ) ; debug ( "Buffer<S2SV_blank>size:<S2SV_blank>%lu<S2SV_blank>frames" , buffer_frames ) ; debug ( "Buffer<S2SV_blank>time:<S2SV_blank>%" PRIu64 "us" , ( uint64_t ) buffer_frames * UINT64_C ( 1000000 ) / params . rate ) ; bytes_per_frame = sound_params -> channels * bytes_per_sample ; debug ( "Frame<S2SV_blank>size:<S2SV_blank>%d<S2SV_blank>bytes" , bytes_per_frame ) ; chunk_bytes = chunk_frames * bytes_per_frame ; if ( chunk_frames == buffer_frames ) { error ( "Can\'t<S2SV_blank>use<S2SV_blank>period<S2SV_blank>equal<S2SV_blank>to<S2SV_blank>buffer<S2SV_blank>size<S2SV_blank>(%lu<S2SV_blank>==<S2SV_blank>%lu)" , chunk_frames , buffer_frames ) ; goto err ; } rc = snd_pcm_prepare ( handle ) ; if ( rc < 0 ) { error_errno ( "Can\'t<S2SV_blank>prepare<S2SV_blank>audio<S2SV_blank>interface<S2SV_blank>for<S2SV_blank>use" , rc ) ; goto err ; } ALSA_CHECK ( samples_to_bytes , bytes_per_sample ) ; ALSA_CHECK ( frames_to_bytes , bytes_per_frame ) ; logit ( "ALSA<S2SV_blank>device<S2SV_blank>opened" ) ; params . channels = sound_params -> channels ; alsa_buf_fill = 0 ; result = 1 ; err : snd_pcm_hw_params_free ( hw_params ) ; return result ; }
<S2SV_ModStart> bytes_per_sample ) ; if ( options_get_bool ( "ALSAStutterDefeat" ) ) { rc = snd_pcm_hw_params_set_rate_resample ( handle , hw_params , 0 ) ; if ( rc == 0 ) logit ( "ALSA<S2SV_blank>resampling<S2SV_blank>disabled" ) ; else log_errno ( "Unable<S2SV_blank>to<S2SV_blank>disable<S2SV_blank>ALSA<S2SV_blank>resampling" , rc ) ; }
2,049
CWE-000 int main ( int argc , char * * argv ) { uint64_t threads ; uint64_t repeat ; if ( argc == 2 ) threads = atoi ( argv [ 1 ] ) ; else threads = THREADS ; <S2SV_StartBug> printf ( "Hardware<S2SV_blank>Transaction<S2SV_blank>Memory<S2SV_blank>Torture\\n" ) ; <S2SV_EndBug> printf ( "!<S2SV_blank>=<S2SV_blank>Transaction<S2SV_blank>Failed<S2SV_blank>but<S2SV_blank>the<S2SV_blank>VSX<S2SV_blank>+<S2SV_blank>VRSAVE<S2SV_blank>registers<S2SV_blank>were<S2SV_blank>preserved\\n" ) ; printf ( ".<S2SV_blank>=<S2SV_blank>Transaction<S2SV_blank>Succeeded<S2SV_blank>but<S2SV_blank>the<S2SV_blank>VSX<S2SV_blank>+<S2SV_blank>VRSAVE<S2SV_blank>registers<S2SV_blank>were<S2SV_blank>preserved\\n\\n" ) ; <S2SV_StartBug> printf ( "Starting<S2SV_blank>%" PRIu64 "<S2SV_blank>threads\\n" , threads ) ; <S2SV_EndBug> printf ( "---------------------------\\n" ) ; set_workloads ( ) ; <S2SV_StartBug> for ( int i = 0 ; i < REPEAT ; i ++ ) <S2SV_EndBug> start_threads ( threads ) ; return 0 ; }
<S2SV_ModStart> ; printf ( "Hardware<S2SV_blank>Transactional<S2SV_blank>Memory<S2SV_blank>Torture\\n\\n" <S2SV_ModEnd> ) ; printf <S2SV_ModStart> ".<S2SV_blank>=<S2SV_blank>Transaction<S2SV_blank>Succeeded<S2SV_blank>but<S2SV_blank>the<S2SV_blank>VSX<S2SV_blank>+<S2SV_blank>VRSAVE<S2SV_blank>registers<S2SV_blank>were<S2SV_blank>preserved\\n\\n" ) ; <S2SV_ModEnd> set_workloads ( ) <S2SV_ModStart> ( ) ; init_workers ( ) ; start_workers ( 0 , 1 ) ; start_workers ( 1 , 1 <S2SV_ModEnd> ) ; return
2,050
CWE-000 static void init_buf_vals ( ) { switch ( tested_op ) { case FI_OP_ATOMIC : case FI_OP_FETCH_ATOMIC : case FI_OP_COMPARE_ATOMIC : <S2SV_StartBug> memset ( compare_buf , ~ 0 , strlen ( compare_buf ) ) ; <S2SV_EndBug> sprintf ( tx_buf , "%s" , welcome_text ) ; memset ( & tx_buf [ strlen ( welcome_text ) ] , ~ 0 , strlen ( welcome_text ) ) ; if ( opts . dst_addr ) sprintf ( rx_buf , "%s" , welcome_text ) ; break ; default : sprintf ( tx_buf , "%s%s" , welcome_text , write_text ) ; } }
<S2SV_ModStart> , strlen ( welcome_text ) * 2 <S2SV_ModEnd> ) ; sprintf
2,051
CWE-000 int WriteAppletInfo ( char * action , char * launcher_location , char * data ) { int flen , num ; FILE * fp ; GKeyFile * keyfile ; GKeyFileFlags flags ; GError * error = NULL ; GSettings * settings1 ; char * home , * Name , * state , * path1 , * filename , * Language , * file_content = "" , * desktopFile , home_applet [ 100 ] , config_desktop_filename [ 100 ] , autostart_desktop_filename [ 100 ] , applications_desktop_filename [ 100 ] ; state = action ; filename = launcher_location ; home = getenv ( "HOME" ) ; keyfile = g_key_file_new ( ) ; Language = getenv ( "GDM_LANG" ) ; if ( filename [ 0 ] == '/' ) { desktopFile = launcher_location ; } else { sprintf ( autostart_desktop_filename , "/etc/xdg/autostart/%s" , filename ) ; sprintf ( applications_desktop_filename , "/usr/share/applications/%s" , filename ) ; sprintf ( applications_desktop_filename , "/usr/share/applications/%s" , filename ) ; sprintf ( applications_desktop_filename , "/usr/share/applications/%s" , filename ) ; sprintf ( config_desktop_filename , "%s/.config/ukui/panel2.d/default/launchers/%s" , home , filename ) ; } if ( Language == NULL ) { Language = "" ; } if ( ! access ( applications_desktop_filename , 0 ) ) { desktopFile = applications_desktop_filename ; } else if ( ! access ( config_desktop_filename , 0 ) ) { desktopFile = config_desktop_filename ; } else if ( ! access ( autostart_desktop_filename , 0 ) ) { desktopFile = autostart_desktop_filename ; } if ( ! g_key_file_load_from_file ( keyfile , desktopFile , flags , & error ) ) { printf ( "g_key_file_load_from_file<S2SV_blank>error!\\n" ) ; return - 1 ; } sprintf ( home_applet , "%s/.applet" , home ) ; Name = g_key_file_get_locale_string ( keyfile , "Desktop<S2SV_blank>Entry" , "Name" , NULL , NULL ) ; if ( ( fp = fopen ( home_applet , "r" ) ) != NULL ) { fseek ( fp , 0L , SEEK_END ) ; flen = ftell ( fp ) ; file_content = ( char * ) malloc ( flen + 1 ) ; if ( file_content == NULL ) { fclose ( fp ) ; return - 1 ; } fseek ( fp , 0L , SEEK_SET ) ; fread ( file_content , flen , 1 , fp ) ; file_content [ flen ] = 0 ; fclose ( fp ) ; } path1 = g_strdup_printf ( "%s/" , "/org/ukui/panel/toplevels/bottom" ) ; settings1 = g_settings_new_with_path ( "org.ukui.panel.toplevel" , path1 ) ; num = g_settings_get_int ( settings1 , "applet-nums" ) ; if ( ! strcmp ( state , "add" ) ) { if ( strstr ( file_content , Name ) == NULL ) { if ( ( fp = fopen ( home_applet , "a+" ) ) != NULL ) { <S2SV_StartBug> fprintf ( fp , "%s" , Name ) ; <S2SV_EndBug> fclose ( fp ) ; num = num + 1 ; g_settings_set_int ( settings1 , "applet-nums" , num ) ; } } else { if ( ! strcmp ( data , "after" ) ) { return 1 ; } } } if ( ! strcmp ( state , "delete" ) ) { if ( strstr ( file_content , Name ) != NULL ) { if ( ( fp = fopen ( home_applet , "w" ) ) != NULL ) { fprintf ( fp , "%s" , StrReplace ( file_content , Name , "" ) ) ; fclose ( fp ) ; num = num - 1 ; g_settings_set_int ( settings1 , "applet-nums" , num ) ; } } <S2SV_StartBug> } <S2SV_EndBug> return 0 ; }
<S2SV_ModStart> ( fp , "%s\\n" <S2SV_ModEnd> , Name ) <S2SV_ModStart> ; } } system ( "sed<S2SV_blank>-i<S2SV_blank>/^[[:space:]]*$/d<S2SV_blank>~/.applet" ) ;
2,052
CWE-000 static void generate_symbol_defs ( generate_config_t * conf ) { struct stat st ; if ( stat ( conf -> kernel_dir , & st ) != 0 ) fail ( "Failed<S2SV_blank>to<S2SV_blank>stat<S2SV_blank>%s:<S2SV_blank>%s\\n" , conf -> kernel_dir , strerror ( errno ) ) ; printf ( "Generating<S2SV_blank>symbol<S2SV_blank>defs<S2SV_blank>from<S2SV_blank>%s...\\n" , conf -> kernel_dir ) ; conf -> db = record_db_init ( ) ; if ( S_ISDIR ( st . st_mode ) ) { walk_dir ( conf -> kernel_dir , false , process_symbol_file , conf ) ; } else if ( S_ISREG ( st . st_mode ) ) { char * path = conf -> kernel_dir ; conf -> kernel_dir = "" ; process_symbol_file ( path , conf ) ; } else { fail ( "Not<S2SV_blank>a<S2SV_blank>file<S2SV_blank>or<S2SV_blank>directory:<S2SV_blank>%s\\n" , conf -> kernel_dir ) ; } ksymtab_for_each ( conf -> symbols , print_not_found , NULL ) ; <S2SV_StartBug> record_db_dump ( conf -> db , conf -> kabi_dir ) ; <S2SV_EndBug> record_db_free ( conf -> db ) ; }
<S2SV_ModStart> NULL ) ; record_db_merge ( conf -> db ) ;
2,053
CWE-000 static PyObject * _gfx_beziercolor ( PyObject * self , PyObject * args ) { PyObject * surface , * color , * points , * item ; Sint16 * vx , * vy , x , y ; Py_ssize_t count , i ; int ret , steps ; Uint32 c ; ASSERT_VIDEO_INIT ( NULL ) ; if ( ! PyArg_ParseTuple ( args , "OOiO:polygon" , & surface , & points , & steps , & color ) ) return NULL ; if ( ! PySurface_Check ( surface ) ) { PyErr_SetString ( PyExc_TypeError , "surface<S2SV_blank>must<S2SV_blank>be<S2SV_blank>a<S2SV_blank>Surface" ) ; return NULL ; } if ( ! PyColor_Check ( color ) ) { PyErr_SetString ( PyExc_TypeError , "color<S2SV_blank>must<S2SV_blank>be<S2SV_blank>a<S2SV_blank>Color" ) ; return NULL ; } if ( ! PySequence_Check ( points ) ) { PyErr_SetString ( PyExc_TypeError , "points<S2SV_blank>must<S2SV_blank>be<S2SV_blank>a<S2SV_blank>sequence" ) ; return NULL ; } count = PySequence_Size ( points ) ; if ( count < 3 ) { PyErr_SetString ( PyExc_ValueError , "points<S2SV_blank>must<S2SV_blank>contain<S2SV_blank>more<S2SV_blank>than<S2SV_blank>2<S2SV_blank>points" ) ; return NULL ; } c = ( Uint32 ) PyColor_AsNumber ( color ) ; ARGB2FORMAT ( c , ( ( PySurface * ) surface ) -> surface -> format ) ; vx = PyMem_New ( Sint16 , ( size_t ) count ) ; vy = PyMem_New ( Sint16 , ( size_t ) count ) ; if ( ! vx || ! vy ) { PyErr_SetString ( PyExc_MemoryError , "memory<S2SV_blank>allocation<S2SV_blank>failed" ) ; if ( vx ) PyMem_Free ( vx ) ; if ( vy ) PyMem_Free ( vy ) ; return NULL ; } for ( i = 0 ; i < count ; i ++ ) { item = PySequence_ITEM ( points , i ) ; if ( ! Sint16FromSeqIndex ( item , 0 , & x ) ) { PyMem_Free ( vx ) ; PyMem_Free ( vy ) ; Py_XDECREF ( item ) ; return NULL ; } if ( ! Sint16FromSeqIndex ( item , 1 , & y ) ) { PyMem_Free ( vx ) ; PyMem_Free ( vy ) ; Py_XDECREF ( item ) ; return NULL ; } Py_DECREF ( item ) ; vx [ i ] = x ; <S2SV_StartBug> vy [ i ] = x ; <S2SV_EndBug> } Py_BEGIN_ALLOW_THREADS ; ret = bezierColor ( ( ( PySurface * ) surface ) -> surface , vx , vy , ( int ) count , steps , c ) ; Py_END_ALLOW_THREADS ; PyMem_Free ( vx ) ; PyMem_Free ( vy ) ; if ( ret == - 1 ) { PyErr_SetString ( PyExc_PyGameError , SDL_GetError ( ) ) ; return NULL ; } Py_RETURN_NONE ; }
<S2SV_ModStart> i ] = y <S2SV_ModEnd> ; } Py_BEGIN_ALLOW_THREADS
2,054
CWE-000 char * scst_get_next_lexem ( char * * token_str ) { char * p , * q ; <S2SV_StartBug> static const char blank = '\\0' ; <S2SV_EndBug> if ( ( token_str == NULL ) || ( * token_str == NULL ) ) <S2SV_StartBug> return ( char * ) & blank ; <S2SV_EndBug> for ( p = * token_str ; ( * p != '\\0' ) && ( isspace ( * p ) || ( * p == '=' ) ) ; p ++ ) ; for ( q = p ; ( * q != '\\0' ) && ! isspace ( * q ) && ( * q != '=' ) ; q ++ ) ; if ( * q != '\\0' ) * q ++ = '\\0' ; * token_str = q ; return p ; }
<S2SV_ModStart> q ; static <S2SV_ModEnd> char blank = <S2SV_ModStart> ) ) return <S2SV_ModEnd> & blank ;
2,055
CWE-000 CLinkedlistNode * CLinkedlist_last_node ( CLinkedlist * this ) { if ( CLinkedlist_is_empty ( this ) ) <S2SV_StartBug> return NULL ; <S2SV_EndBug> CLinkedlistNode * buffer = this -> head -> next ; while ( 1 ) { if ( buffer -> next != NULL ) { buffer = buffer -> next ; continue ; } else return buffer ; } }
<S2SV_ModStart> ) ) return CLINKEDLIST_EMPTY <S2SV_ModEnd> ; CLinkedlistNode *
2,056
CWE-000 static void rlc_r ( GB_gameboy_t * gb , uint8_t opcode ) { bool carry ; uint8_t value ; value = get_src_value ( gb , opcode ) ; carry = ( value & 0x80 ) != 0 ; gb -> registers [ GB_REGISTER_AF ] &= 0xFF00 ; set_src_value ( gb , opcode , ( value << 1 ) | carry ) ; if ( carry ) { gb -> registers [ GB_REGISTER_AF ] |= GB_CARRY_FLAG ; } <S2SV_StartBug> if ( ! ( value << 1 ) ) { <S2SV_EndBug> gb -> registers [ GB_REGISTER_AF ] |= GB_ZERO_FLAG ; } }
<S2SV_ModStart> } if ( <S2SV_ModEnd> ( value << <S2SV_ModStart> << 1 ) != 0
2,057
CWE-000 sdigit_t mdi_sub ( digit_t * r , size_t rn , digit_t const * a , size_t an , digit_t const * b , size_t bn ) { assert ( r == a || ! ( r < a + an && a < r + rn ) ) ; assert ( r == b || ! ( r < b + bn && b < r + rn ) ) ; size_t n = rn ; if ( r == NULL && n == 0 ) n = an > bn ? an : bn ; bool a_lt_b ; while ( n -- ) { digit_t ad = n < an ? a [ n ] : 0 ; digit_t bd = n < bn ? b [ n ] : 0 ; if ( ad < bd ) { a_lt_b = true ; break ; } if ( ad > bd ) { a_lt_b = false ; break ; } } ++ n ; if ( r != NULL && rn > 0 ) { for ( size_t i = n ; i < rn ; ++ i ) r [ i ] = 0 ; if ( a_lt_b ) { digit_t const * t = a ; a = b ; b = t ; size_t tn = an ; an = bn ; bn = tn ; } digit_t borrow = 0 ; <S2SV_StartBug> if ( bn == 1 ) { <S2SV_EndBug> borrow = b [ 0 ] ; for ( size_t i = 0 ; i < n ; ++ i ) { digit_t ad = i < an ? a [ i ] : 0 ; borrow = sub_overflow ( ad , borrow , & r [ i ] ) ; } } else { for ( size_t i = 0 ; i < n ; ++ i ) { digit_t ad = i < an ? a [ i ] : 0 ; digit_t bd = i < bn ? b [ i ] : 0 ; digit_t rd ; borrow = sub_overflow ( ad , borrow , & rd ) ; borrow |= sub_overflow ( rd , bd , & rd ) ; r [ i ] = rd ; } } assert ( borrow == 0 ) ; } return a_lt_b ? - ( sdigit_t ) n : ( sdigit_t ) n ; }
<S2SV_ModStart> ; if ( n > 0 &&
2,058
CWE-000 int wma_roam_event_callback ( WMA_HANDLE handle , uint8_t * event_buf , uint32_t len ) { tp_wma_handle wma_handle = ( tp_wma_handle ) handle ; WMI_ROAM_EVENTID_param_tlvs * param_buf ; wmi_roam_event_fixed_param * wmi_event ; struct sSirSmeRoamOffloadSynchInd * roam_synch_data ; enum sir_roam_op_code op_code = { 0 } ; param_buf = ( WMI_ROAM_EVENTID_param_tlvs * ) event_buf ; if ( ! param_buf ) { WMA_LOGE ( "Invalid<S2SV_blank>roam<S2SV_blank>event<S2SV_blank>buffer" ) ; return - EINVAL ; } wmi_event = param_buf -> fixed_param ; WMA_LOGD ( "%s:<S2SV_blank>Reason<S2SV_blank>%x,<S2SV_blank>Notif<S2SV_blank>%x<S2SV_blank>for<S2SV_blank>vdevid<S2SV_blank>%x,<S2SV_blank>rssi<S2SV_blank>%d" , __func__ , wmi_event -> reason , wmi_event -> notif , wmi_event -> vdev_id , wmi_event -> rssi ) ; wma_peer_debug_log ( wmi_event -> vdev_id , DEBUG_ROAM_EVENT , DEBUG_INVALID_PEER_ID , NULL , NULL , wmi_event -> reason , ( wmi_event -> reason == WMI_ROAM_REASON_INVALID ) ? wmi_event -> notif : wmi_event -> rssi ) ; if ( wmi_event -> vdev_id >= wma_handle -> max_bssid ) { WMA_LOGE ( "Invalid<S2SV_blank>vdev<S2SV_blank>id<S2SV_blank>from<S2SV_blank>firmware" ) ; return - EINVAL ; } DPTRACE ( qdf_dp_trace_record_event ( QDF_DP_TRACE_EVENT_RECORD , wmi_event -> vdev_id , QDF_PROTO_TYPE_EVENT , QDF_ROAM_EVENTID ) ) ; switch ( wmi_event -> reason ) { case WMI_ROAM_REASON_BMISS : WMA_LOGD ( "Beacon<S2SV_blank>Miss<S2SV_blank>for<S2SV_blank>vdevid<S2SV_blank>%x" , wmi_event -> vdev_id ) ; wma_beacon_miss_handler ( wma_handle , wmi_event -> vdev_id , wmi_event -> rssi ) ; wma_sta_kickout_event ( HOST_STA_KICKOUT_REASON_BMISS , wmi_event -> vdev_id , NULL ) ; break ; case WMI_ROAM_REASON_BETTER_AP : WMA_LOGD ( "%s:Better<S2SV_blank>AP<S2SV_blank>found<S2SV_blank>for<S2SV_blank>vdevid<S2SV_blank>%x,<S2SV_blank>rssi<S2SV_blank>%d" , __func__ , wmi_event -> vdev_id , wmi_event -> rssi ) ; wma_handle -> suitable_ap_hb_failure = false ; wma_roam_better_ap_handler ( wma_handle , wmi_event -> vdev_id ) ; break ; case WMI_ROAM_REASON_SUITABLE_AP : wma_handle -> suitable_ap_hb_failure = true ; wma_handle -> suitable_ap_hb_failure_rssi = wmi_event -> rssi ; WMA_LOGD ( "%s:Bmiss<S2SV_blank>scan<S2SV_blank>AP<S2SV_blank>found<S2SV_blank>for<S2SV_blank>vdevid<S2SV_blank>%x,<S2SV_blank>rssi<S2SV_blank>%d" , __func__ , wmi_event -> vdev_id , wmi_event -> rssi ) ; wma_roam_better_ap_handler ( wma_handle , wmi_event -> vdev_id ) ; break ; # ifdef WLAN_FEATURE_ROAM_OFFLOAD case WMI_ROAM_REASON_HO_FAILED : WMA_LOGE ( "LFR3:Hand-Off<S2SV_blank>Failed<S2SV_blank>for<S2SV_blank>vdevid<S2SV_blank>%x" , wmi_event -> vdev_id ) ; wma_roam_ho_fail_handler ( wma_handle , wmi_event -> vdev_id ) ; <S2SV_StartBug> break ; <S2SV_EndBug> # endif case WMI_ROAM_REASON_INVALID : roam_synch_data = qdf_mem_malloc ( sizeof ( * roam_synch_data ) ) ; if ( NULL == roam_synch_data ) { WMA_LOGE ( "Memory<S2SV_blank>unavailable<S2SV_blank>for<S2SV_blank>roam<S2SV_blank>synch<S2SV_blank>data" ) ; return - ENOMEM ; } <S2SV_StartBug> if ( wmi_event -> notif == WMI_ROAM_NOTIF_ROAM_START ) <S2SV_EndBug> <S2SV_StartBug> op_code = SIR_ROAMING_START ; <S2SV_EndBug> <S2SV_StartBug> if ( wmi_event -> notif == WMI_ROAM_NOTIF_ROAM_ABORT ) <S2SV_EndBug> <S2SV_StartBug> op_code = SIR_ROAMING_ABORT ; <S2SV_EndBug> roam_synch_data -> roamedVdevId = wmi_event -> vdev_id ; wma_handle -> pe_roam_synch_cb ( ( tpAniSirGlobal ) wma_handle -> mac_context , roam_synch_data , NULL , op_code ) ; wma_handle -> csr_roam_synch_cb ( ( tpAniSirGlobal ) wma_handle -> mac_context , roam_synch_data , NULL , op_code ) ; qdf_mem_free ( roam_synch_data ) ; break ; case WMI_ROAM_REASON_RSO_STATUS : wma_rso_cmd_status_event_handler ( wmi_event ) ; break ; case WMI_ROAM_REASON_INVOKE_ROAM_FAIL : roam_synch_data = qdf_mem_malloc ( sizeof ( * roam_synch_data ) ) ; if ( ! roam_synch_data ) { WMA_LOGE ( "Memory<S2SV_blank>unavailable<S2SV_blank>for<S2SV_blank>roam<S2SV_blank>synch<S2SV_blank>data" ) ; return - ENOMEM ; } roam_synch_data -> roamedVdevId = wmi_event -> vdev_id ; wma_handle -> csr_roam_synch_cb ( ( tpAniSirGlobal ) wma_handle -> mac_context , roam_synch_data , NULL , SIR_ROAMING_INVOKE_FAIL ) ; qdf_mem_free ( roam_synch_data ) ; break ; default : WMA_LOGD ( "%s:Unhandled<S2SV_blank>Roam<S2SV_blank>Event<S2SV_blank>%x<S2SV_blank>for<S2SV_blank>vdevid<S2SV_blank>%x" , __func__ , wmi_event -> reason , wmi_event -> vdev_id ) ; break ; } if ( ( ( WMI_ROAM_REASON_INVALID == wmi_event -> reason ) && ( WMI_ROAM_NOTIF_ROAM_ABORT == wmi_event -> notif ) ) || ( WMI_ROAM_REASON_HO_FAILED == wmi_event -> reason ) || ( WMI_ROAM_REASON_INVOKE_ROAM_FAIL == wmi_event -> reason ) ) { WMA_LOGD ( FL ( "SELF-REASSOC:<S2SV_blank>Roam<S2SV_blank>reason-%x<S2SV_blank>notif-%x<S2SV_blank>vdevid-%x" ) , wmi_event -> reason , wmi_event -> notif , wmi_event -> vdev_id ) ; wma_roam_remove_self_reassoc ( wma_handle , wmi_event -> vdev_id ) ; cds_restart_opportunistic_timer ( false ) ; } return 0 ; }
<S2SV_ModStart> vdev_id ) ; wma_handle -> interfaces [ wmi_event -> vdev_id ] . roaming_in_progress = false ; <S2SV_ModStart> == WMI_ROAM_NOTIF_ROAM_START ) { <S2SV_ModStart> = SIR_ROAMING_START ; wma_handle -> interfaces [ wmi_event -> vdev_id ] . roaming_in_progress = true ; } <S2SV_ModStart> == WMI_ROAM_NOTIF_ROAM_ABORT ) { <S2SV_ModStart> = SIR_ROAMING_ABORT ; wma_handle -> interfaces [ wmi_event -> vdev_id ] . roaming_in_progress = false ; }
2,059
CWE-000 static int <S2SV_StartBug> ztest_replay_remove ( ztest_ds_t * zd , lr_remove_t * lr , boolean_t byteswap ) <S2SV_EndBug> <S2SV_StartBug> { <S2SV_EndBug> char * name = ( void * ) ( lr + 1 ) ; objset_t * os = zd -> zd_os ; dmu_object_info_t doi ; dmu_tx_t * tx ; uint64_t object , txg ; if ( byteswap ) byteswap_uint64_array ( lr , sizeof ( * lr ) ) ; ASSERT ( lr -> lr_doid == ZTEST_DIROBJ ) ; ASSERT ( name [ 0 ] != '\\0' ) ; VERIFY3U ( 0 , == , zap_lookup ( os , lr -> lr_doid , name , sizeof ( object ) , 1 , & object ) ) ; ASSERT ( object != 0 ) ; ztest_object_lock ( zd , object , RL_WRITER ) ; VERIFY3U ( 0 , == , dmu_object_info ( os , object , & doi ) ) ; tx = dmu_tx_create ( os ) ; dmu_tx_hold_zap ( tx , lr -> lr_doid , B_FALSE , name ) ; dmu_tx_hold_free ( tx , object , 0 , DMU_OBJECT_END ) ; txg = ztest_tx_assign ( tx , TXG_WAIT , FTAG ) ; if ( txg == 0 ) { ztest_object_unlock ( zd , object ) ; return ( ENOSPC ) ; } if ( doi . doi_type == DMU_OT_ZAP_OTHER ) { VERIFY3U ( 0 , == , zap_destroy ( os , object , tx ) ) ; } else { VERIFY3U ( 0 , == , dmu_object_free ( os , object , tx ) ) ; } VERIFY3U ( 0 , == , zap_remove ( os , lr -> lr_doid , name , tx ) ) ; ( void ) ztest_log_remove ( zd , tx , lr , object ) ; dmu_tx_commit ( tx ) ; ztest_object_unlock ( zd , object ) ; return ( 0 ) ; }
<S2SV_ModStart> int ztest_replay_remove ( void * arg1 , void * arg2 <S2SV_ModEnd> , boolean_t byteswap <S2SV_ModStart> byteswap ) { ztest_ds_t * zd = arg1 ; lr_remove_t * lr = arg2 ;
2,060
CWE-000 outputCode optAction ( char * arg , params_t * params ) { if ( arg == NULL ) { <S2SV_StartBug> fprintf ( stderr , "ERROR:<S2SV_blank>Invalid<S2SV_blank>argument.\\n" ) ; <S2SV_EndBug> return outERROR ; } if ( strcmp ( arg , ENCODE_STR_TOKEN ) == 0 ) { params -> action = ENCODE_STR_TOKEN ; } else if ( strcmp ( arg , DECODE_STR_TOKEN ) == 0 ) { params -> action = DECODE_STR_TOKEN ; } else { <S2SV_StartBug> fprintf ( stderr , "ERROR:<S2SV_blank>Invalid<S2SV_blank>argument.\\n" ) ; <S2SV_EndBug> return outERROR ; } return outOK ; }
<S2SV_ModStart> ( stderr , ERROR_ACTION_INVALID_ARGUMENT <S2SV_ModEnd> ) ; return <S2SV_ModStart> ( stderr , ERROR_ACTION_INVALID_ARGUMENT <S2SV_ModEnd> ) ; return
2,061
CWE-000 void phy_addrFilt ( uint16_t panid , uint8_t * ieee_addr , uint16_t uc_addr , uint16_t bc_addr ) { <S2SV_StartBug> uint8_t reg_data [ 8 ] ; <S2SV_EndBug> reg_data [ 0 ] = 0x80 ; reg_data [ 1 ] = 0x00 ; <S2SV_StartBug> reg_data [ 2 ] = 0x0F ; <S2SV_EndBug> reg_wr ( REG_ADR_C_CHECK_CTRL , reg_data , 3 ) ; reg_data [ 0 ] = panid >> 0 & 0xff ; reg_data [ 1 ] = panid >> 8 & 0xff ; reg_data [ 2 ] = uc_addr >> 0 & 0xff ; reg_data [ 3 ] = uc_addr >> 8 & 0xff ; reg_wr ( REG_ADR_A_FIELD_CODE1 , reg_data , 4 ) ; # ifndef LAZURITE_IDE if ( module_test & MODE_PHY_DEBUG ) { printk ( KERN_INFO "%s,%s\\n" , __FILE__ , __func__ ) ; reg_rd ( REG_ADR_A_CHECK_CTRL , reg_data , 1 ) ; printk ( KERN_INFO "ADDFIL_CNTRL:<S2SV_blank>%s,%s,%x\\n" , __FILE__ , __func__ , reg_data [ 0 ] ) ; reg_rd ( REG_ADR_A_FIELD_CODE1 , reg_data , 4 ) ; printk ( KERN_INFO "ADDFIL1:<S2SV_blank>%s,%s,%x\\n" , __FILE__ , __func__ , reg_data [ 0 ] ) ; printk ( KERN_INFO "ADDFIL2:<S2SV_blank>%s,%s,%x\\n" , __FILE__ , __func__ , reg_data [ 1 ] ) ; printk ( KERN_INFO "ADDFIL3:<S2SV_blank>%s,%s,%x\\n" , __FILE__ , __func__ , reg_data [ 2 ] ) ; printk ( KERN_INFO "ADDFIL4:<S2SV_blank>%s,%s,%x\\n" , __FILE__ , __func__ , reg_data [ 3 ] ) ; <S2SV_StartBug> } <S2SV_EndBug> # endif }
<S2SV_ModStart> uint8_t reg_data [ 4 ] ; if ( dsss_param . modulation == PHY_MODULATION_FSK ) { <S2SV_ModEnd> reg_data [ 0 <S2SV_ModStart> = 0x0F ; } else { reg_data [ 0 ] = 0x00 ; reg_data [ 1 ] = 0x00 ; reg_data [ 2 ] = 0x00 ; } <S2SV_ModStart> ] ) ; printk ( KERN_INFO "MODULATION:<S2SV_blank>%s,%s,%x\\n" , __FILE__ , __func__ , dsss_param . modulation ) ;
2,062
CWE-000 int syslogger ( const char * message ) { char msg [ MAX_BYTES ] = "" ; char pid_str [ 6 ] = "" ; parse_pid ( pid_str ) ; char * proc_name = get_prog_name ( pid_str ) ; if ( proc_name != NULL ) { <S2SV_StartBug> printf ( "%s\\n" , proc_name ) ; <S2SV_EndBug> if ( concat_message ( msg , pid_str , proc_name , message ) ) { <S2SV_StartBug> printf ( "%s\\n" , msg ) ; <S2SV_EndBug> <S2SV_StartBug> char * fifoname = syslogger_fifo ( pid_str ) ; <S2SV_EndBug> printf ( "%s\\n" , fifoname ) ; free ( proc_name ) ; int fd = open ( fifoname , O_WRONLY | O_NONBLOCK ) ; struct timeval time_elapsed ; gettimeofday ( & time_elapsed , NULL ) ; <S2SV_StartBug> time_t start_time = time_elapsed . tv_sec ; <S2SV_EndBug> while ( 1 ) { if ( fd > 0 ) break ; <S2SV_StartBug> else if ( fd < 0 && errno != ENXIO ) break ; <S2SV_EndBug> <S2SV_StartBug> else if ( time_elapsed . tv_sec > start_time ) break ; <S2SV_EndBug> fd = open ( fifoname , O_WRONLY | O_NONBLOCK ) ; gettimeofday ( & time_elapsed , NULL ) ; } free ( fifoname ) ; if ( fd > 0 ) { write ( fd , msg , strlen ( msg ) ) ; return 1 ; } } } return 0 ; }
<S2SV_ModStart> NULL ) { <S2SV_ModEnd> if ( concat_message <S2SV_ModStart> ) ) { <S2SV_ModEnd> char * fifoname <S2SV_ModStart> syslogger_fifo ( pid_str <S2SV_ModEnd> ) ; free <S2SV_ModStart> NULL ) ; struct timeval <S2SV_ModEnd> start_time = time_elapsed <S2SV_ModStart> start_time = time_elapsed <S2SV_ModEnd> ; while ( <S2SV_ModStart> != ENXIO ) { break ; } <S2SV_ModEnd> else if ( <S2SV_ModStart> else if ( ( <S2SV_ModStart> tv_sec > start_time . tv_sec + 1 ) && ( time_elapsed . tv_usec > start_time . tv_usec ) ) { break ; } <S2SV_ModEnd> fd = open
2,063
CWE-000 int do_insert_up_via_r ( struct cluster_head_t * pclst , struct insert_info_t * pinsert , char * new_data ) { struct spt_vec tmp_vec , * pvec_a , * pvec_b , * next_vec , * prev_vec ; u32 dataid , vecid_a , vecid_b , tmp_rd ; struct spt_dh * pdh , * plast_dh ; <S2SV_StartBug> struct spt_dh_ext * pdh_ext , * plast_dh_ext ; <S2SV_EndBug> int ret ; int pre_pos ; unsigned int window_hash , seg_hash ; char * pcur_data , * pnew_data ; int chg_pos , new_next_pos ; u64 next_vec_val ; chg_pos = 0 ; pvec_b = NULL ; tmp_vec . val = pinsert -> key_val ; tmp_rd = tmp_vec . rd ; if ( tmp_vec . scan_lock ) return SPT_DO_AGAIN ; dataid = db_alloc_from_grp ( pclst , 0 , & pdh ) ; if ( ! pdh ) { spt_print ( "\\r\\n%d\\t%s" , __LINE__ , __func__ ) ; return SPT_NOMEM ; } pdh -> ref = pinsert -> ref_cnt ; pdh -> pdata = new_data ; if ( tmp_vec . type != SPT_VEC_DATA ) next_vec = ( struct spt_vec * ) vec_id_2_ptr ( pclst , tmp_rd ) ; pre_pos = pinsert -> vec_real_pos ; pnew_data = pinsert -> pnew_data ; pcur_data = pinsert -> pcur_data ; calc_hash ( pnew_data , & window_hash , & seg_hash , pinsert -> cmp_pos ) ; vecid_a = vec_alloc ( pclst , & pvec_a , seg_hash ) ; if ( pvec_a == NULL ) { spt_print ( "\\r\\n%d\\t%s" , __LINE__ , __func__ ) ; spt_set_data_not_free ( pdh ) ; db_free ( pclst , dataid ) ; return SPT_NOMEM ; } pvec_a -> val = 0 ; pvec_a -> type = SPT_VEC_DATA ; pvec_a -> rd = dataid ; set_real_pos ( pvec_a , pinsert -> cmp_pos , pre_pos , window_hash ) ; tmp_vec . rd = vecid_a ; if ( tmp_vec . pos == pvec_a -> pos && tmp_vec . pos != 0 ) spt_assert ( 0 ) ; if ( tmp_vec . type == SPT_VEC_DATA || pinsert -> endbit > pinsert -> fs ) { unsigned int new_window_hash , new_seg_hash ; calc_hash_by_base ( pcur_data , window_hash , pinsert -> cmp_pos , & new_window_hash , & new_seg_hash , pinsert -> fs ) ; vecid_b = vec_alloc ( pclst , & pvec_b , new_seg_hash ) ; if ( pvec_b == NULL ) { spt_print ( "\\r\\n%d\\t%s" , __LINE__ , __func__ ) ; spt_set_data_not_free ( pdh ) ; db_free ( pclst , dataid ) ; vec_free ( pclst , vecid_a ) ; return SPT_NOMEM ; } pvec_b -> val = 0 ; pvec_b -> type = tmp_vec . type ; pvec_b -> rd = tmp_rd ; pvec_b -> down = SPT_NULL ; set_real_pos ( pvec_b , pinsert -> fs , pinsert -> cmp_pos , new_window_hash ) ; if ( tmp_vec . type != SPT_VEC_DATA ) { if ( chg_pos = is_need_chg_pos ( pvec_b , next_vec , SPT_OP_INSERT ) ) { pvec_b -> scan_lock = 1 ; new_next_pos = ( new_window_hash << SPT_POS_BIT ) + ( next_vec -> pos + 1 ) % 32 ; prev_vec = pvec_b ; tmp_vec . scan_lock == 1 ; } } tmp_vec . type = SPT_VEC_RIGHT ; pvec_a -> down = vecid_b ; } else { pvec_a -> down = tmp_rd ; if ( tmp_vec . type != SPT_VEC_DATA ) { if ( chg_pos = is_need_chg_pos ( pvec_a , next_vec , SPT_OP_INSERT ) ) { pvec_a -> scan_lock = 1 ; new_next_pos = ( window_hash << SPT_POS_BIT ) + ( next_vec -> pos + 1 ) % 32 ; prev_vec = pvec_a ; tmp_vec . scan_lock == 1 ; } } } if ( ! pclst -> is_bottom ) { pdh_ext = ( struct spt_dh_ext * ) pdh -> pdata ; plast_dh = ( struct spt_dh * ) db_id_2_ptr ( pclst , pinsert -> dataid ) ; plast_dh_ext = ( struct spt_dh_ext * ) plast_dh -> pdata ; pdh_ext -> hang_vec = plast_dh_ext -> hang_vec ; } smp_mb ( ) ; if ( pinsert -> key_val == atomic64_cmpxchg ( ( atomic64_t * ) pinsert -> pkey_vec , pinsert -> key_val , tmp_vec . val ) ) { if ( chg_pos ) { do { next_vec_val = tmp_vec . val = next_vec -> val ; tmp_vec . scan_status = SPT_VEC_PVALUE ; tmp_vec . pos = new_next_pos ; } while ( next_vec_val != atomic64_cmpxchg ( ( atomic64_t * ) next_vec , next_vec_val , tmp_vec . val ) ) ; do { next_vec_val = tmp_vec . val = pinsert -> pkey_vec -> val ; tmp_vec . scan_lock = 0 ; } while ( next_vec_val != atomic64_cmpxchg ( ( atomic64_t * ) pinsert -> pkey_vec , next_vec_val , tmp_vec . val ) ) ; do { next_vec_val = tmp_vec . val = prev_vec -> val ; tmp_vec . scan_lock = 0 ; } while ( next_vec_val != atomic64_cmpxchg ( ( atomic64_t * ) prev_vec , next_vec_val , tmp_vec . val ) ) ; smp_mb ( ) ; } if ( ! pclst -> is_bottom ) plast_dh_ext -> hang_vec = vecid_a ; return dataid ; } spt_set_data_not_free ( pdh ) ; db_free ( pclst , dataid ) ; vec_free ( pclst , vecid_a ) ; if ( pvec_b != NULL ) vec_free ( pclst , vecid_b ) ; return SPT_DO_AGAIN ; }
<S2SV_ModStart> , * plast_dh_ext <S2SV_ModEnd> ; int pre_pos
2,064
CWE-000 void l2cu_release_ccb ( tL2C_CCB * p_ccb ) { tL2C_LCB * p_lcb = p_ccb -> p_lcb ; tL2C_RCB * p_rcb = p_ccb -> p_rcb ; L2CAP_TRACE_DEBUG ( "l2cu_release_ccb:<S2SV_blank>cid<S2SV_blank>0x%04x<S2SV_blank><S2SV_blank>in_use:<S2SV_blank>%u" , p_ccb -> local_cid , p_ccb -> in_use ) ; if ( ! p_ccb -> in_use ) { return ; } # if ( SDP_INCLUDED == TRUE ) if ( p_rcb && ( p_rcb -> psm != p_rcb -> real_psm ) ) { btm_sec_clr_service_by_psm ( p_rcb -> psm ) ; } # endif if ( p_ccb -> should_free_rcb ) { osi_free ( p_rcb ) ; p_ccb -> p_rcb = NULL ; p_ccb -> should_free_rcb = false ; } <S2SV_StartBug> btm_sec_clr_temp_auth_service ( p_lcb -> remote_bd_addr ) ; <S2SV_EndBug> btu_stop_timer ( & p_ccb -> timer_entry ) ; while ( ! GKI_queue_is_empty ( & p_ccb -> xmit_hold_q ) ) { GKI_freebuf ( GKI_dequeue ( & p_ccb -> xmit_hold_q ) ) ; } # if ( CLASSIC_BT_INCLUDED == TRUE ) l2c_fcr_cleanup ( p_ccb ) ; # endif if ( ( p_lcb ) && ( ( p_ccb -> local_cid >= L2CAP_BASE_APPL_CID ) # if ( L2CAP_UCD_INCLUDED == TRUE ) || ( p_ccb -> local_cid == L2CAP_CONNECTIONLESS_CID ) # endif ) ) { l2cu_dequeue_ccb ( p_ccb ) ; p_ccb -> p_lcb = NULL ; } if ( ! l2cb . p_free_ccb_first ) { l2cb . p_free_ccb_first = p_ccb ; l2cb . p_free_ccb_last = p_ccb ; p_ccb -> p_next_ccb = NULL ; p_ccb -> p_prev_ccb = NULL ; } else { p_ccb -> p_next_ccb = NULL ; p_ccb -> p_prev_ccb = l2cb . p_free_ccb_last ; l2cb . p_free_ccb_last -> p_next_ccb = p_ccb ; l2cb . p_free_ccb_last = p_ccb ; } p_ccb -> in_use = FALSE ; if ( ( p_lcb ) && p_lcb -> in_use && ( p_lcb -> link_state == LST_CONNECTED ) ) { if ( ! p_lcb -> ccb_queue . p_first_ccb ) { l2cu_no_dynamic_ccbs ( p_lcb ) ; } else { l2c_link_adjust_chnl_allocation ( ) ; } } }
<S2SV_ModStart> false ; } if ( p_lcb ) { <S2SV_ModStart> remote_bd_addr ) ; }
2,065
CWE-000 static int tgsi_op3_dst ( struct r600_shader_ctx * ctx , int dst ) { struct tgsi_full_instruction * inst = & ctx -> parse . FullToken . FullInstruction ; struct r600_bytecode_alu alu ; <S2SV_StartBug> int i , j , r ; <S2SV_EndBug> <S2SV_StartBug> int lasti = tgsi_last_instruction ( inst -> Dst [ 0 ] . Register . WriteMask ) ; <S2SV_EndBug> int temp_regs [ 4 ] ; unsigned op = ctx -> inst_info -> op ; if ( op == ALU_OP3_MULADD_IEEE && ctx -> info . properties [ TGSI_PROPERTY_MUL_ZERO_WINS ] ) op = ALU_OP3_MULADD ; for ( j = 0 ; j < inst -> Instruction . NumSrcRegs ; j ++ ) { <S2SV_StartBug> temp_regs [ j ] = 0 ; <S2SV_EndBug> <S2SV_StartBug> if ( ctx -> src [ j ] . abs ) <S2SV_EndBug> temp_regs [ j ] = r600_get_temp ( ctx ) ; } for ( i = 0 ; i < lasti + 1 ; i ++ ) { if ( ! ( inst -> Dst [ 0 ] . Register . WriteMask & ( 1 << i ) ) ) continue ; memset ( & alu , 0 , sizeof ( struct r600_bytecode_alu ) ) ; alu . op = op ; for ( j = 0 ; j < inst -> Instruction . NumSrcRegs ; j ++ ) { <S2SV_StartBug> r = tgsi_make_src_for_op3 ( ctx , temp_regs [ j ] , i , & alu . src [ j ] , & ctx -> src [ j ] ) ; <S2SV_EndBug> if ( r ) return r ; } if ( dst == - 1 ) { tgsi_dst ( ctx , & inst -> Dst [ 0 ] , i , & alu . dst ) ; } else { alu . dst . sel = dst ; } alu . dst . chan = i ; alu . dst . write = 1 ; alu . is_op3 = 1 ; if ( i == lasti ) { alu . last = 1 ; } r = r600_bytecode_add_alu ( ctx -> bc , & alu ) ; if ( r ) return r ; } return 0 ; }
<S2SV_ModStart> r600_bytecode_alu alu ; struct r600_bytecode_alu_src srcs [ 4 ] [ 4 ] ; <S2SV_ModStart> . WriteMask ) <S2SV_ModEnd> ; unsigned op <S2SV_ModStart> ++ ) { r = tgsi_make_src_for_op3 ( ctx , inst -> Dst [ 0 ] . Register . WriteMask , srcs [ j ] , & <S2SV_ModEnd> ctx -> src <S2SV_ModStart> [ j ] ) ; if ( r ) return r <S2SV_ModEnd> ; } for <S2SV_ModStart> ++ ) { <S2SV_ModEnd> alu . src <S2SV_ModStart> [ j ] = srcs [ j ] [ i ] <S2SV_ModEnd> ; } if
2,066
CWE-000 static void _outCreateOpClassItem ( StringInfo str , const CreateOpClassItem * node ) { WRITE_NODE_TYPE ( "CREATEOPCLASSITEM" ) ; WRITE_INT_FIELD ( itemtype ) ; WRITE_NODE_FIELD ( name ) ; WRITE_NODE_FIELD ( args ) ; WRITE_INT_FIELD ( number ) ; <S2SV_StartBug> WRITE_NODE_FIELD ( class_args ) ; <S2SV_EndBug> WRITE_NODE_FIELD ( storedtype ) ; }
<S2SV_ModStart> ; WRITE_NODE_FIELD ( order_family ) ; WRITE_NODE_FIELD (
2,067
CWE-000 <S2SV_StartBug> int ls_refs ( struct repository * r , struct argv_array * keys , <S2SV_EndBug> struct packet_reader * request ) { struct ls_refs_data data ; memset ( & data , 0 , sizeof ( data ) ) ; while ( packet_reader_read ( request ) != PACKET_READ_FLUSH ) { const char * arg = request -> line ; const char * out ; if ( ! strcmp ( "peel" , arg ) ) data . peel = 1 ; else if ( ! strcmp ( "symrefs" , arg ) ) data . symrefs = 1 ; else if ( skip_prefix ( arg , "ref-prefix<S2SV_blank>" , & out ) ) argv_array_push ( & data . prefixes , out ) ; } head_ref_namespaced ( send_ref , & data ) ; for_each_namespaced_ref ( send_ref , & data ) ; packet_flush ( 1 ) ; argv_array_clear ( & data . prefixes ) ; return 0 ; }
<S2SV_ModStart> * r , const char * config_section ,
2,068
CWE-000 void read_excludes_file ( const char * name ) { FILE * fp ; char * line , * str ; struct exclude * e ; <S2SV_StartBug> size_t linecap = 0 ; <S2SV_EndBug> ssize_t len ; <S2SV_StartBug> fp = fopen ( name , "r" ) ; <S2SV_EndBug> if ( fp == NULL ) <S2SV_StartBug> err ( 1 , "%s" , name ) ; <S2SV_EndBug> while ( ( len = getline ( & line , & linecap , fp ) ) != - 1 ) { <S2SV_StartBug> if ( line [ len - 1 ] == '\\n' ) <S2SV_EndBug> len -- ; if ( len == 0 ) continue ; str = malloc ( len + 1 ) ; e = malloc ( sizeof * e ) ; if ( str == NULL || e == NULL ) errx ( 1 , "memory<S2SV_blank>allocation<S2SV_blank>error" ) ; e -> glob = str ; memcpy ( str , line , len ) ; str [ len ] = '\\0' ; if ( strchr ( str , '/' ) ) e -> pathname = 1 ; else e -> pathname = 0 ; LIST_INSERT_HEAD ( & excludes , e , link ) ; } <S2SV_StartBug> free ( line ) ; <S2SV_EndBug> fclose ( fp ) ; }
<S2SV_ModStart> * e ; # ifdef __linux__ <S2SV_ModStart> ssize_t len ; # else size_t len ; # endif <S2SV_ModStart> name ) ; # ifdef __linux__ <S2SV_ModStart> 1 ) { # else while ( ( line = fgetln ( fp , & len ) ) != NULL ) { # endif <S2SV_ModStart> ) ; } # ifdef __linux__ <S2SV_ModStart> line ) ; # endif
2,069
CWE-000 static void hid_irq_out ( struct urb * urb ) { struct hid_device * hid = urb -> context ; struct usbhid_device * usbhid = hid -> driver_data ; unsigned long flags ; int unplug = 0 ; switch ( urb -> status ) { case 0 : break ; case - ESHUTDOWN : unplug = 1 ; case - EILSEQ : case - EPROTO : case - ECONNRESET : case - ENOENT : break ; default : hid_warn ( urb -> dev , "output<S2SV_blank>irq<S2SV_blank>status<S2SV_blank>%d<S2SV_blank>received\\n" , urb -> status ) ; } spin_lock_irqsave ( & usbhid -> lock , flags ) ; <S2SV_StartBug> if ( unplug ) <S2SV_EndBug> usbhid -> outtail = usbhid -> outhead ; <S2SV_StartBug> else <S2SV_EndBug> usbhid -> outtail = ( usbhid -> outtail + 1 ) & ( HID_OUTPUT_FIFO_SIZE - 1 ) ; <S2SV_StartBug> if ( ! irq_out_pump_restart ( hid ) ) { <S2SV_EndBug> spin_unlock_irqrestore ( & usbhid -> lock , flags ) ; return ; } <S2SV_StartBug> clear_bit ( HID_OUT_RUNNING , & usbhid -> iofl ) ; <S2SV_EndBug> spin_unlock_irqrestore ( & usbhid -> lock , flags ) ; usb_autopm_put_interface_async ( usbhid -> intf ) ; wake_up ( & usbhid -> wait ) ; }
<S2SV_ModStart> ( unplug ) { <S2SV_ModStart> -> outhead ; } else { <S2SV_ModEnd> usbhid -> outtail <S2SV_ModStart> ; if ( usbhid -> outhead != usbhid -> outtail && hid_submit_out <S2SV_ModEnd> ( hid ) <S2SV_ModStart> ( hid ) == 0 <S2SV_ModStart> return ; } }
2,070
CWE-000 time_t <S2SV_StartBug> sr_state_get_start_time_of_current_protocol_run ( time_t now ) <S2SV_EndBug> { int total_rounds = SHARED_RANDOM_N_ROUNDS * SHARED_RANDOM_N_PHASES ; int voting_interval = get_voting_interval ( ) ; <S2SV_StartBug> time_t beginning_of_current_round = get_start_time_of_current_round ( ) ; <S2SV_EndBug> ( void ) now ; int current_round = ( beginning_of_current_round / voting_interval ) % total_rounds ; time_t time_elapsed_since_start_of_run = current_round * voting_interval ; return beginning_of_current_round - time_elapsed_since_start_of_run ; }
<S2SV_ModStart> time_t sr_state_get_start_time_of_current_protocol_run ( void <S2SV_ModEnd> ) { int <S2SV_ModStart> get_start_time_of_current_round ( ) <S2SV_ModEnd> ; int current_round
2,071
CWE-000 int ncncio_rename_att ( void * ncdp , int varid , const char * name , const char * newname ) { int err ; NC_nc4 * nc4p = ( NC_nc4 * ) ncdp ; <S2SV_StartBug> DEBUG_RETURN_ERROR ( NC_ENOT_SUPPORTED ) <S2SV_EndBug> err = nc_rename_att ( nc4p -> ncid , varid , name , newname ) ; if ( err != NC_NOERR ) DEBUG_RETURN_ERROR ( err ) ; return NC_NOERR ; }
<S2SV_ModStart> ; DEBUG_RETURN_ERROR ( NC_ENOTSUPPORT <S2SV_ModEnd> ) err =
2,072
CWE-000 void creer_tank_ennemis ( char * * fake_map , struct TANK * * head , int pos_x , int pos_y , char direction ) { struct TANK * newEnnemyTank = ( struct TANK * ) malloc ( sizeof ( struct TANK ) ) ; int blindage_origine = rand ( ) % ( 3 ) ; while ( repartitionTankEnnemis [ blindage_origine ] <= 0 ) blindage_origine = rand ( ) % ( 3 ) ; repartitionTankEnnemis [ blindage_origine ] -- ; newEnnemyTank -> pos_x = pos_x ; newEnnemyTank -> pos_y = pos_y ; newEnnemyTank -> direction = direction ; newEnnemyTank -> blindage = blindage_origine ; newEnnemyTank -> blindage_origine = blindage_origine ; newEnnemyTank -> nb_impacts = 0 ; newEnnemyTank -> camp = 'E' ; newEnnemyTank -> etat = 2 ; switch ( blindage_origine ) { case ( 0 ) : switch ( direction ) { case ( 'A' ) : newEnnemyTank -> carrosserie = carrosserieWTH ; break ; case ( 'B' ) : newEnnemyTank -> carrosserie = carrosserieWTB ; break ; case ( 'C' ) : newEnnemyTank -> carrosserie = carrosserieWTD ; break ; case ( 'D' ) : newEnnemyTank -> carrosserie = carrosserieWTG ; break ; default : break ; } break ; case ( 1 ) : switch ( direction ) { case ( 'A' ) : newEnnemyTank -> carrosserie = carrosserieMTH ; break ; case ( 'B' ) : newEnnemyTank -> carrosserie = carrosserieMTB ; break ; case ( 'C' ) : newEnnemyTank -> carrosserie = carrosserieMTD ; break ; case ( 'D' ) : newEnnemyTank -> carrosserie = carrosserieMTG ; break ; default : break ; } break ; case ( 2 ) : switch ( direction ) { case ( 'A' ) : newEnnemyTank -> carrosserie = carrosserieSTH ; break ; case ( 'B' ) : newEnnemyTank -> carrosserie = carrosserieSTB ; break ; case ( 'C' ) : newEnnemyTank -> carrosserie = carrosserieSTD ; break ; case ( 'D' ) : newEnnemyTank -> carrosserie = carrosserieSTG ; break ; default : break ; } break ; default : break ; } newEnnemyTank -> suivant = ( * head ) ; ( * head ) = newEnnemyTank ; remplir_map_tank ( fake_map , newEnnemyTank ) ; <S2SV_StartBug> NBTANKTOTAL -- ; <S2SV_EndBug> nb_tank_wave ++ ; }
<S2SV_ModStart> newEnnemyTank ) ; affichage_tank_terminal ( newEnnemyTank ) ;
2,073
CWE-000 int main ( int argc , char * * argv ) { # if DEBUG g_log_set_always_fatal ( G_LOG_LEVEL_CRITICAL ) ; # endif if ( argc == 2 && ( strcmp ( argv [ 1 ] , "-h" ) == 0 || strcmp ( argv [ 1 ] , "--help" ) == 0 ) ) { g_print ( usage ) ; exit ( 0 ) ; } if ( argc >= 4 ) suffix = argv [ 1 ] ; fullname = g_strconcat ( APPNAME , suffix , NULL ) ; gchar * exarg = "" ; if ( argc > 4 ) { exarg = argv [ 4 ] ; argc = 4 ; } gchar * action = argc > 2 ? argv [ argc - 2 ] : "new" ; gchar * uri = argc > 1 ? argv [ argc - 1 ] : NULL ; if ( * action == '\\0' ) action = "new" ; if ( uri && * uri == '\\0' ) uri = NULL ; if ( argc == 2 && uri && g_file_test ( uri , G_FILE_TEST_EXISTS ) ) uri = g_strconcat ( "file://" , uri , NULL ) ; <S2SV_StartBug> const gchar * winid = g_getenv ( "WINID" ) ? : "0" ; <S2SV_EndBug> if ( * winid == '\\0' ) winid = "0" ; gchar * cwd = g_get_current_dir ( ) ; gchar * sendstr = g_strdup_printf ( "m:%ld:%ld:%s%s%s:%s:%s" , <S2SV_StartBug> strlen ( cwd ) , strlen ( exarg ) , cwd , exarg , winid , action , uri ? : "" ) ; <S2SV_EndBug> g_free ( cwd ) ; if ( ipcsend ( "main" , sendstr ) ) exit ( 0 ) ; g_free ( sendstr ) ; gtk_init ( NULL , NULL ) ; checkconf ( false ) ; ipcwatch ( "main" ) ; GdkPixbuf * pix = gtk_icon_theme_load_icon ( gtk_icon_theme_get_default ( ) , APP , 128 , 0 , NULL ) ; if ( pix ) { gtk_window_set_default_icon ( pix ) ; g_object_unref ( pix ) ; } wins = g_ptr_array_new ( ) ; dlwins = g_ptr_array_new ( ) ; histimgs = g_queue_new ( ) ; if ( run ( NULL , action , uri ) ) gtk_main ( ) ; else exit ( 1 ) ; exit ( 0 ) ; }
<S2SV_ModStart> * winid = strcmp ( suffix , g_getenv ( "SUFFIX" ) <S2SV_ModEnd> ? : "" <S2SV_ModStart> : "" ) == 0 ? g_getenv ( "WINID" ) : NULL ; if ( ! winid || * winid == '\\0' ) winid = "0" ; gchar * cwd = g_get_current_dir ( ) ; gchar * sendstr = g_strdup_printf ( "m:%ld:%ld:%s%s%s:%s:%s" , strlen ( cwd ) , strlen ( exarg ) , cwd , exarg , winid , action , uri ? : "" )
2,074
CWE-000 struct libinput * tools_open_backend ( enum tools_backend which , const char * seat_or_device , bool verbose , <S2SV_StartBug> bool grab ) <S2SV_EndBug> { struct libinput * li ; switch ( which ) { case BACKEND_UDEV : li = tools_open_udev ( seat_or_device , verbose , grab ) ; break ; case BACKEND_DEVICE : li = tools_open_device ( seat_or_device , verbose , grab ) ; break ; default : abort ( ) ; } return li ; }
<S2SV_ModStart> verbose , bool *
2,075
CWE-000 void CMod_LoadAreas ( lump_t * l ) { int i ; carea_t * out ; darea_t * in ; int count ; in = ( void * ) ( cmod_base + l -> fileofs ) ; if ( l -> filelen % sizeof ( * in ) ) { <S2SV_StartBug> Com_Error ( ERR_DROP , "MOD_LoadBmodel:<S2SV_blank>funny<S2SV_blank>lump<S2SV_blank>size" ) ; <S2SV_EndBug> } count = l -> filelen / sizeof ( * in ) ; if ( count > MAX_MAP_AREAS ) { Com_Error ( ERR_DROP , "Map<S2SV_blank>has<S2SV_blank>too<S2SV_blank>many<S2SV_blank>areas" ) ; } out = map_areas ; numareas = count ; for ( i = 0 ; i < count ; i ++ , in ++ , out ++ ) { out -> numareaportals = LittleLong ( in -> numareaportals ) ; out -> firstareaportal = LittleLong ( in -> firstareaportal ) ; out -> floodvalid = 0 ; out -> floodnum = 0 ; } }
<S2SV_ModStart> ( ERR_DROP , "Mod_LoadAreas:<S2SV_blank>funny<S2SV_blank>lump<S2SV_blank>size" <S2SV_ModEnd> ) ; }
2,076
CWE-000 int main ( int argc , char * argv [ ] ) { if ( ! ( strcmp ( "--help" , argv [ 1 ] ) ) ) { printf ( "Help<S2SV_blank>Documentation\\n" ) ; return 0 ; } char * seedPoolChar = argv [ 1 ] ; <S2SV_StartBug> printf ( "You<S2SV_blank>keyed<S2SV_blank>in:<S2SV_blank>%s\\n" , seedPoolChar ) ; <S2SV_EndBug> <S2SV_StartBug> uint32_t seedPool = convertStrToInt ( seedPoolChar ) ; <S2SV_EndBug> printf ( "You<S2SV_blank>keyed<S2SV_blank>in:<S2SV_blank>%#4x\\n" , seedPool ) ; uint32_t partialKey = solvePartialKey ( seedPool ) ; <S2SV_StartBug> printf ( "The<S2SV_blank>partial<S2SV_blank>key<S2SV_blank>is<S2SV_blank>:<S2SV_blank>%#4x\\n" , partialKey ) ; <S2SV_EndBug> return 0 ; }
<S2SV_ModStart> 1 ] ; <S2SV_ModEnd> uint32_t seedPool = <S2SV_ModStart> convertStrToInt ( seedPoolChar <S2SV_ModEnd> ) ; uint32_t <S2SV_ModStart> ; printf ( "The<S2SV_blank>partial<S2SV_blank>key<S2SV_blank>is<S2SV_blank>:<S2SV_blank>0x%04X\\n" <S2SV_ModEnd> , partialKey )
2,077
CWE-000 static drmModeModeInfo * <S2SV_StartBug> test_setup ( data_t * data , enum pipe pipe , uint64_t modifier , int flags , <S2SV_EndBug> igt_output_t * output ) { drmModeModeInfo * mode ; int size ; int i = 1 , x , y ; igt_plane_t * plane ; igt_output_set_pipe ( output , pipe ) ; mode = igt_output_get_mode ( output ) ; data -> fb = calloc ( data -> display . pipes [ pipe ] . n_planes , sizeof ( struct igt_fb ) ) ; igt_assert_f ( data -> fb , "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>%d<S2SV_blank>FBs\\n" , data -> display . pipes [ pipe ] . n_planes ) ; igt_create_color_fb ( data -> drm_fd , mode -> hdisplay , mode -> vdisplay , DRM_FORMAT_XRGB8888 , modifier , 0.0 , 0.0 , 1.0 , & data -> fb [ 0 ] ) ; for_each_plane_on_pipe ( & data -> display , pipe , plane ) { if ( plane -> type == DRM_PLANE_TYPE_PRIMARY ) { igt_plane_set_fb ( plane , & data -> fb [ 0 ] ) ; continue ; } if ( plane -> type == DRM_PLANE_TYPE_CURSOR ) size = 64 ; else size = SIZE ; x = 0 ; y = mode -> vdisplay - size ; igt_create_color_fb ( data -> drm_fd , size , size , plane -> type == DRM_PLANE_TYPE_CURSOR ? DRM_FORMAT_ARGB8888 : DRM_FORMAT_XRGB8888 , plane -> type == DRM_PLANE_TYPE_CURSOR ? LOCAL_DRM_FORMAT_MOD_NONE : modifier , 1.0 , 1.0 , 0.0 , & data -> fb [ i ] ) ; igt_plane_set_position ( plane , x , y ) ; igt_plane_set_fb ( plane , & data -> fb [ i ++ ] ) ; } return mode ; }
<S2SV_ModStart> , uint64_t modifier <S2SV_ModEnd> , igt_output_t *
2,078
CWE-000 <S2SV_StartBug> void searchViewController ( DICT * dictionaryPtr , HOME * homeViewPtr ) <S2SV_EndBug> { printf ( "searchViewController\\n" ) ; char aString [ 32 ] ; scanf ( "%s" , aString ) ; for ( int i = 0 ; i < VOC ; ++ i ) { if ( strcmp ( aString , * ( dictionaryPtr + i ) -> vocabulary ) == 0 ) { switch ( CurrentLanguage ) { case uyghur : case english : printf ( "%s\\n" , * ( dictionaryPtr + i ) -> definition . latinDefinition ) ; break ; case chinese : printf ( "%s\\n" , * ( dictionaryPtr + i ) -> definition . cnDefinition ) ; break ; default : break ; } } } <S2SV_StartBug> backView ( homeViewPtr ) ; <S2SV_EndBug> }
<S2SV_ModStart> DICT * dictionaryPtr <S2SV_ModEnd> ) { printf <S2SV_ModStart> } backView ( <S2SV_ModEnd> ) ; }
2,079
CWE-000 void common_init ( PrivateData * p , unsigned char if_bit ) { <S2SV_StartBug> int init_brightness = ( p -> backlightstate ) ? p -> brightness : p -> offbrightness ; <S2SV_EndBug> unsigned char cmd_funcset = FUNCSET | if_bit | TWOLINE | SMALLCHAR ; if ( has_extended_mode ( p ) ) { p -> hd44780_functions -> senddata ( p , 0 , RS_INSTR , cmd_funcset | EXTREG ) ; p -> hd44780_functions -> uPause ( p , 40 ) ; p -> hd44780_functions -> senddata ( p , 0 , RS_INSTR , EXTMODESET | FOURLINE ) ; p -> hd44780_functions -> uPause ( p , 40 ) ; } if ( p -> model == HD44780_MODEL_PT6314_VFD ) { cmd_funcset &= ~ PT6314_BRIGHT_MASK ; p -> func_set_mode = cmd_funcset ; if ( init_brightness >= 3 * ( MAX_BRIGHTNESS / 4 ) ) cmd_funcset |= PT6314_BRIGHT_100 ; else if ( init_brightness >= MAX_BRIGHTNESS / 2 ) cmd_funcset |= PT6314_BRIGHT_75 ; else if ( init_brightness > MAX_BRIGHTNESS / 4 ) cmd_funcset |= PT6314_BRIGHT_50 ; else cmd_funcset |= PT6314_BRIGHT_25 ; } else { cmd_funcset |= p -> font_bank ; } p -> func_set_mode = cmd_funcset ; p -> hd44780_functions -> senddata ( p , 0 , RS_INSTR , cmd_funcset ) ; p -> hd44780_functions -> uPause ( p , 40 ) ; p -> hd44780_functions -> senddata ( p , 0 , RS_INSTR , ONOFFCTRL | DISPOFF | CURSOROFF | CURSORNOBLINK ) ; p -> hd44780_functions -> uPause ( p , 40 ) ; p -> hd44780_functions -> senddata ( p , 0 , RS_INSTR , CLEAR ) ; p -> hd44780_functions -> uPause ( p , ( p -> model == HD44780_MODEL_WINSTAR_OLED ) ? 6200 : 1600 ) ; if ( p -> model == HD44780_MODEL_WINSTAR_OLED ) { unsigned char pwr = WINST_PWROFF ; if ( init_brightness >= MAX_BRIGHTNESS / 2 ) { pwr = WINST_PWRON ; } p -> hd44780_functions -> senddata ( p , 0 , RS_INSTR , WINST_MODESET | WINST_TEXTMODE | pwr ) ; p -> hd44780_functions -> uPause ( p , 500 ) ; } p -> hd44780_functions -> senddata ( p , 0 , RS_INSTR , ENTRYMODE | E_MOVERIGHT | NOSCROLL ) ; p -> hd44780_functions -> uPause ( p , 40 ) ; p -> hd44780_functions -> senddata ( p , 0 , RS_INSTR , HOMECURSOR ) ; p -> hd44780_functions -> uPause ( p , 1600 ) ; p -> hd44780_functions -> senddata ( p , 0 , RS_INSTR , ONOFFCTRL | DISPON | CURSOROFF | CURSORNOBLINK ) ; p -> hd44780_functions -> uPause ( p , 40 ) ; if ( p -> hd44780_functions -> flush != NULL ) p -> hd44780_functions -> flush ( p ) ; }
<S2SV_ModStart> int init_brightness = <S2SV_ModEnd> p -> brightness <S2SV_ModStart> p -> brightness <S2SV_ModEnd> ; unsigned char
2,080
CWE-000 int main ( ) { <S2SV_StartBug> struct sat_loc_params sv_1 = { 0.0 , - 20200000.0 - 3894033.0 , 0.0 } ; <S2SV_EndBug> <S2SV_StartBug> struct sat_loc_params sv_2 = { 20200000.0 + 3894033.0 , 0.0 , 0.0 } ; <S2SV_EndBug> <S2SV_StartBug> struct sat_loc_params sv_3 = { - 20200000.0 - 3894033.0 , 0.0 , 0.0 } ; <S2SV_EndBug> <S2SV_StartBug> struct sat_loc_params sv_4 = { 0.0 , 0.0 , 20200000.0 + 3894033.0 } ; <S2SV_EndBug> struct ecef_pos final_result ; struct delta_t time_deltas = { 0.06796112069 , 0.09133565296 , 0.07389219269 , 0.069398661109 } ; find_position ( & sv_1 , & sv_2 , & sv_3 , & sv_4 , & time_deltas , & final_result ) ; return 0 ; }
<S2SV_ModStart> ) { struct double_sat_loc_params <S2SV_ModEnd> sv_1 = { <S2SV_ModStart> } ; struct double_sat_loc_params <S2SV_ModEnd> sv_2 = { <S2SV_ModStart> } ; struct double_sat_loc_params <S2SV_ModEnd> sv_3 = { <S2SV_ModStart> } ; struct double_sat_loc_params <S2SV_ModEnd> sv_4 = {
2,081
CWE-000 int mynewt_fseek ( FILE * stream , long offset , int whence ) { # ifndef NO_FILESYSTEM uint32_t fs_offset ; switch ( whence ) { <S2SV_StartBug> case SEEK_SET : <S2SV_EndBug> { fs_offset += offset ; } break ; <S2SV_StartBug> case SEEK_CUR : <S2SV_EndBug> { fs_offset = fs_getpos ( stream ) ; fs_offset += offset ; } break ; <S2SV_StartBug> case SEEK_END : <S2SV_EndBug> { fs_filelen ( stream , & fs_offset ) ; fs_offset += offset ; } break ; } <S2SV_StartBug> fs_seek ( stream , fs_oofset ) ; <S2SV_EndBug> return 0 ; # else return - 1 ; # endif }
<S2SV_ModStart> ) { case 0 <S2SV_ModEnd> : { fs_offset <S2SV_ModStart> break ; case 1 <S2SV_ModEnd> : { fs_offset <S2SV_ModStart> break ; case 2 <S2SV_ModEnd> : { fs_filelen <S2SV_ModStart> ( stream , fs_offset <S2SV_ModEnd> ) ; return
2,082
CWE-000 void batadv_interface_rx ( struct net_device * soft_iface , struct sk_buff * skb , struct batadv_hard_iface * recv_if , int hdr_size , struct batadv_orig_node * orig_node ) { struct batadv_bcast_packet * batadv_bcast_packet ; struct batadv_priv * bat_priv = netdev_priv ( soft_iface ) ; __be16 ethertype = htons ( ETH_P_BATMAN ) ; struct vlan_ethhdr * vhdr ; struct ethhdr * ethhdr ; unsigned short vid ; bool is_bcast ; batadv_bcast_packet = ( struct batadv_bcast_packet * ) skb -> data ; is_bcast = ( batadv_bcast_packet -> packet_type == BATADV_BCAST ) ; if ( ! pskb_may_pull ( skb , hdr_size ) ) goto dropped ; skb_pull_rcsum ( skb , hdr_size ) ; skb_reset_mac_header ( skb ) ; nf_reset ( skb ) ; if ( unlikely ( ! pskb_may_pull ( skb , ETH_HLEN ) ) ) goto dropped ; vid = batadv_get_vid ( skb , 0 ) ; ethhdr = eth_hdr ( skb ) ; switch ( ntohs ( ethhdr -> h_proto ) ) { case ETH_P_8021Q : if ( ! pskb_may_pull ( skb , VLAN_ETH_HLEN ) ) goto dropped ; vhdr = ( struct vlan_ethhdr * ) skb -> data ; if ( vhdr -> h_vlan_encapsulated_proto != ethertype ) break ; case ETH_P_BATMAN : goto dropped ; } skb -> protocol = eth_type_trans ( skb , soft_iface ) ; <S2SV_StartBug> batadv_inc_counter ( bat_priv , BATADV_CNT_RX ) ; <S2SV_EndBug> batadv_add_counter ( bat_priv , BATADV_CNT_RX_BYTES , skb -> len + ETH_HLEN ) ; soft_iface -> last_rx = jiffies ; if ( batadv_bla_rx ( bat_priv , skb , vid , is_bcast ) ) goto out ; if ( orig_node ) batadv_tt_add_temporary_global_entry ( bat_priv , orig_node , ethhdr -> h_source , vid ) ; if ( is_multicast_ether_addr ( ethhdr -> h_dest ) ) { if ( batadv_vlan_ap_isola_get ( bat_priv , vid ) && batadv_tt_global_is_isolated ( bat_priv , ethhdr -> h_source , vid ) ) { skb -> mark &= ~ bat_priv -> isolation_mark_mask ; skb -> mark |= bat_priv -> isolation_mark ; } } else if ( batadv_is_ap_isolated ( bat_priv , ethhdr -> h_source , ethhdr -> h_dest , vid ) ) { goto dropped ; } netif_rx ( skb ) ; goto out ; dropped : kfree_skb ( skb ) ; out : return ; }
<S2SV_ModStart> soft_iface ) ; skb_postpull_rcsum ( skb , eth_hdr ( skb ) , ETH_HLEN ) ;
2,083
CWE-000 double resistanceRange1M ( uint32_t ADCValue ) { double voltPerBit = 3.312f / 4096.0f ; double bitsIn3V = 3.0f / voltPerBit ; <S2SV_StartBug> double x = ( ( ( ( double ) ADCValue * voltPerBit ) - 1.613 ) / ( 0.1513 ) ) <S2SV_EndBug> double retVal = ( 572340000.0 ) * x * x - ( 265220000.0 * x ) + ( 31166000.0 ) ; return retVal ; }
<S2SV_ModStart> 0.1513 ) ) ;
2,084
CWE-000 struct sock * cookie_v4_check ( struct sock * sk , struct sk_buff * skb ) { struct ip_options * opt = & TCP_SKB_CB ( skb ) -> header . h4 . opt ; struct tcp_options_received tcp_opt ; struct inet_request_sock * ireq ; struct tcp_request_sock * treq ; struct tcp_sock * tp = tcp_sk ( sk ) ; const struct tcphdr * th = tcp_hdr ( skb ) ; __u32 cookie = ntohl ( th -> ack_seq ) - 1 ; struct sock * ret = sk ; struct request_sock * req ; int mss ; struct rtable * rt ; __u8 rcv_wscale ; struct flowi4 fl4 ; if ( ! sock_net ( sk ) -> ipv4 . sysctl_tcp_syncookies || ! th -> ack || th -> rst ) goto out ; if ( tcp_synq_no_recent_overflow ( sk ) ) goto out ; mss = __cookie_v4_check ( ip_hdr ( skb ) , th , cookie ) ; if ( mss == 0 ) { __NET_INC_STATS ( sock_net ( sk ) , LINUX_MIB_SYNCOOKIESFAILED ) ; goto out ; } __NET_INC_STATS ( sock_net ( sk ) , LINUX_MIB_SYNCOOKIESRECV ) ; memset ( & tcp_opt , 0 , sizeof ( tcp_opt ) ) ; tcp_parse_options ( skb , & tcp_opt , 0 , NULL ) ; if ( ! cookie_timestamp_decode ( & tcp_opt ) ) goto out ; ret = NULL ; req = inet_reqsk_alloc ( & tcp_request_sock_ops , sk , false ) ; if ( ! req ) goto out ; ireq = inet_rsk ( req ) ; treq = tcp_rsk ( req ) ; treq -> rcv_isn = ntohl ( th -> seq ) - 1 ; treq -> snt_isn = cookie ; treq -> txhash = net_tx_rndhash ( ) ; req -> mss = mss ; ireq -> ir_num = ntohs ( th -> dest ) ; ireq -> ir_rmt_port = th -> source ; sk_rcv_saddr_set ( req_to_sk ( req ) , ip_hdr ( skb ) -> daddr ) ; sk_daddr_set ( req_to_sk ( req ) , ip_hdr ( skb ) -> saddr ) ; ireq -> ir_mark = inet_request_mark ( sk , skb ) ; ireq -> snd_wscale = tcp_opt . snd_wscale ; ireq -> sack_ok = tcp_opt . sack_ok ; ireq -> wscale_ok = tcp_opt . wscale_ok ; ireq -> tstamp_ok = tcp_opt . saw_tstamp ; req -> ts_recent = tcp_opt . saw_tstamp ? tcp_opt . rcv_tsval : 0 ; treq -> snt_synack . v64 = 0 ; treq -> tfo_listener = false ; ireq -> ir_iif = inet_request_bound_dev_if ( sk , skb ) ; <S2SV_StartBug> ireq -> opt = tcp_v4_save_options ( skb ) ; <S2SV_EndBug> if ( security_inet_conn_request ( sk , skb , req ) ) { reqsk_free ( req ) ; goto out ; } req -> num_retrans = 0 ; flowi4_init_output ( & fl4 , ireq -> ir_iif , ireq -> ir_mark , RT_CONN_FLAGS ( sk ) , RT_SCOPE_UNIVERSE , IPPROTO_TCP , inet_sk_flowi_flags ( sk ) , opt -> srr ? opt -> faddr : ireq -> ir_rmt_addr , ireq -> ir_loc_addr , th -> source , th -> dest ) ; security_req_classify_flow ( req , flowi4_to_flowi ( & fl4 ) ) ; rt = ip_route_output_key ( sock_net ( sk ) , & fl4 ) ; if ( IS_ERR ( rt ) ) { reqsk_free ( req ) ; goto out ; } req -> rsk_window_clamp = tp -> window_clamp ? : dst_metric ( & rt -> dst , RTAX_WINDOW ) ; tcp_select_initial_window ( tcp_full_space ( sk ) , req -> mss , & req -> rsk_rcv_wnd , & req -> rsk_window_clamp , ireq -> wscale_ok , & rcv_wscale , dst_metric ( & rt -> dst , RTAX_INITRWND ) ) ; ireq -> rcv_wscale = rcv_wscale ; ireq -> ecn_ok = cookie_ecn_ok ( & tcp_opt , sock_net ( sk ) , & rt -> dst ) ; ret = tcp_get_cookie_sock ( sk , skb , req , & rt -> dst ) ; if ( ret ) inet_sk ( ret ) -> cork . fl . u . ip4 = fl4 ; out : return ret ; }
<S2SV_ModStart> skb ) ; RCU_INIT_POINTER ( ireq -> ireq_opt , <S2SV_ModEnd> tcp_v4_save_options ( skb <S2SV_ModStart> tcp_v4_save_options ( skb )
2,085
CWE-000 int Tk_ChooseDirectoryObjCmd ( ClientData clientData , Tcl_Interp * interp , int objc , Tcl_Obj * const objv [ ] ) { Tk_Window tkwin = clientData ; char * str ; int i , result = TCL_ERROR , haveParentOption = 0 ; int index , len , mustexist = 0 ; Tcl_Obj * cmdObj = NULL ; FilePanelCallbackInfo callbackInfoStruct ; FilePanelCallbackInfo * callbackInfo = & callbackInfoStruct ; NSString * directory = nil ; NSString * message , * title ; NSWindow * parent ; NSOpenPanel * panel = [ NSOpenPanel openPanel ] ; NSInteger modalReturnCode = modalError ; BOOL parentIsKey = NO ; for ( i = 1 ; i < objc ; i += 2 ) { if ( Tcl_GetIndexFromObjStruct ( interp , objv [ i ] , chooseOptionStrings , sizeof ( char * ) , "option" , TCL_EXACT , & index ) != TCL_OK ) { goto end ; } if ( i + 1 == objc ) { Tcl_SetObjResult ( interp , Tcl_ObjPrintf ( "value<S2SV_blank>for<S2SV_blank>\\"%s\\"<S2SV_blank>missing" , Tcl_GetString ( objv [ i ] ) ) ) ; Tcl_SetErrorCode ( interp , "TK" , "DIRDIALOG" , "VALUE" , NULL ) ; goto end ; } switch ( index ) { case CHOOSE_INITDIR : str = Tcl_GetStringFromObj ( objv [ i + 1 ] , & len ) ; if ( len ) { directory = [ [ [ NSString alloc ] initWithUTF8String : str ] autorelease ] ; } break ; case CHOOSE_MESSAGE : message = [ [ NSString alloc ] initWithUTF8String : Tcl_GetString ( objv [ i + 1 ] ) ] ; [ panel setMessage : message ] ; [ message release ] ; break ; case CHOOSE_MUSTEXIST : if ( Tcl_GetBooleanFromObj ( interp , objv [ i + 1 ] , & mustexist ) != TCL_OK ) { goto end ; } break ; case CHOOSE_PARENT : str = Tcl_GetStringFromObj ( objv [ i + 1 ] , & len ) ; tkwin = Tk_NameToWindow ( interp , str , tkwin ) ; if ( ! tkwin ) { goto end ; } haveParentOption = 1 ; break ; case CHOOSE_TITLE : title = [ [ NSString alloc ] initWithUTF8String : Tcl_GetString ( objv [ i + 1 ] ) ] ; [ panel setTitle : title ] ; [ title release ] ; break ; case CHOOSE_COMMAND : cmdObj = objv [ i + 1 ] ; break ; } } [ panel setPrompt : @ "Choose" ] ; [ panel setCanChooseFiles : NO ] ; [ panel setCanChooseDirectories : YES ] ; [ panel setCanCreateDirectories : ! mustexist ] ; if ( cmdObj ) { callbackInfo = ckalloc ( sizeof ( FilePanelCallbackInfo ) ) ; if ( Tcl_IsShared ( cmdObj ) ) { cmdObj = Tcl_DuplicateObj ( cmdObj ) ; } Tcl_IncrRefCount ( cmdObj ) ; } callbackInfo -> cmdObj = cmdObj ; callbackInfo -> interp = interp ; <S2SV_StartBug> callbackInfo -> multiple = 0 ; <S2SV_EndBug> parent = TkMacOSXDrawableWindow ( ( ( TkWindow * ) tkwin ) -> window ) ; if ( haveParentOption && parent && ! [ parent attachedSheet ] ) { parentIsKey = [ parent isKeyWindow ] ; # if MAC_OS_X_VERSION_MIN_REQUIRED < 1060 [ panel beginSheetForDirectory : directory file : nil modalForWindow : parent modalDelegate : NSApp didEndSelector : @ selector ( tkFilePanelDidEnd : returnCode : contextInfo : ) contextInfo : callbackInfo ] ; # else [ panel setDirectoryURL : [ NSURL fileURLWithPath : directory isDirectory : YES ] ] ; [ panel beginSheetModalForWindow : parent completionHandler : ^ ( NSInteger returnCode ) { [ NSApp tkFilePanelDidEnd : panel returnCode : returnCode contextInfo : callbackInfo ] ; } ] ; # endif modalReturnCode = cmdObj ? modalOther : [ NSApp runModalForWindow : panel ] ; } else { # if MAC_OS_X_VERSION_MIN_REQUIRED < 1060 modalReturnCode = [ panel runModalForDirectory : directory file : nil ] ; # else [ panel setDirectoryURL : [ NSURL fileURLWithPath : directory isDirectory : YES ] ] ; modalReturnCode = [ panel runModal ] ; # endif [ NSApp tkFilePanelDidEnd : panel returnCode : modalReturnCode contextInfo : callbackInfo ] ; } result = ( modalReturnCode != modalError ) ? TCL_OK : TCL_ERROR ; if ( parentIsKey ) { [ parent makeKeyWindow ] ; } end : return result ; }
<S2SV_ModStart> = 0 ; if ( ! directory ) { directory = @ "/" ; }
2,086
CWE-000 bool xnu_create_exception_thread ( RDebug * dbg ) { # if __POWERPC__ return false ; # else kern_return_t kr ; mach_port_t exception_port = MACH_PORT_NULL ; mach_port_t req_port ; mach_port_t task_self = mach_task_self ( ) ; task_t task = pid_to_task ( dbg -> pid ) ; if ( ! task ) { eprintf ( "error<S2SV_blank>to<S2SV_blank>get<S2SV_blank>task<S2SV_blank>for<S2SV_blank>the<S2SV_blank>debuggee<S2SV_blank>process" "<S2SV_blank>xnu_start_exception_thread\\n" ) ; return false ; } <S2SV_StartBug> if ( ! MACH_PORT_VALID ( task_self ) ) { <S2SV_EndBug> eprintf ( "error<S2SV_blank>to<S2SV_blank>get<S2SV_blank>the<S2SV_blank>task<S2SV_blank>for<S2SV_blank>the<S2SV_blank>current<S2SV_blank>process" "<S2SV_blank>xnu_start_exception_thread\\n" ) ; return false ; } kr = mach_port_allocate ( task_self , MACH_PORT_RIGHT_RECEIVE , & exception_port ) ; RETURN_ON_MACH_ERROR ( "error<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>mach_port<S2SV_blank>exception\\n" , false ) ; kr = mach_port_insert_right ( task_self , exception_port , exception_port , MACH_MSG_TYPE_MAKE_SEND ) ; RETURN_ON_MACH_ERROR ( "error<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>insert<S2SV_blank>right\\n" , false ) ; ex . count = ( sizeof ( ex . ports ) / sizeof ( * ex . ports ) ) ; kr = task_swap_exception_ports ( task , EXC_MASK_ALL , exception_port , EXCEPTION_DEFAULT | MACH_EXCEPTION_CODES , THREAD_STATE_NONE , ex . masks , & ex . count , ex . ports , ex . behaviors , ex . flavors ) ; RETURN_ON_MACH_ERROR ( "failed<S2SV_blank>to<S2SV_blank>swap<S2SV_blank>exception<S2SV_blank>ports\\n" , false ) ; kr = mach_port_request_notification ( task_self , task , MACH_NOTIFY_DEAD_NAME , 0 , exception_port , MACH_MSG_TYPE_MAKE_SEND_ONCE , & req_port ) ; if ( kr != KERN_SUCCESS ) { eprintf ( "Termination<S2SV_blank>notification<S2SV_blank>request<S2SV_blank>failed\\n" ) ; } ex . exception_port = exception_port ; return true ; # endif }
<S2SV_ModStart> false ; } ptrace ( PT_ATTACHEXC , dbg -> pid , 0 , 0 ) ;
2,087
CWE-000 static void tscm_free ( struct snd_tscm * tscm ) { snd_tscm_transaction_unregister ( tscm ) ; snd_tscm_stream_destroy_duplex ( tscm ) ; fw_unit_put ( tscm -> unit ) ; mutex_destroy ( & tscm -> mutex ) ; <S2SV_StartBug> } <S2SV_EndBug>
<S2SV_ModStart> mutex ) ; kfree ( tscm ) ;
2,088
CWE-000 void sig_handle_bgp_exit ( int signo ) { <S2SV_StartBug> if ( signo == SIGCHLD ) { printf ( "=====SIGCHLD====\\n" ) ; } <S2SV_EndBug> pid_t pid ; int status ; sigset_t mask ; sigemptyset ( & mask ) ; sigaddset ( & mask , SIGCHLD ) ; while ( ( pid = waitpid ( - 1 , & status , 0 ) ) > 0 ) { printf ( "[qshell:info:sig_handle_bg_exit]<S2SV_blank>bgp<S2SV_blank>pid=%d<S2SV_blank>stopped!\\n" , pid ) ; sigprocmask ( SIG_BLOCK , & mask , NULL ) ; <S2SV_StartBug> if ( handle_sigchild ( pid ) ) { <S2SV_EndBug> printf ( "[qshell:info:sig_handle_bg_exit]<S2SV_blank>removed<S2SV_blank>bgp<S2SV_blank>pid=%d<S2SV_blank>!\\n" , pid ) ; } sigprocmask ( SIG_UNBLOCK , & mask , NULL ) ; } return ; }
<S2SV_ModStart> signo ) { <S2SV_ModEnd> pid_t pid ; <S2SV_ModStart> ; if ( remove_process_by_id <S2SV_ModEnd> ( pid )
2,089
CWE-000 int_f h5ovisit_c ( hid_t_f * group_id , int_f * index_type , int_f * order , H5O_iterate_t op , void * op_data ) { int_f ret_value = - 1 ; herr_t func_ret_value ; <S2SV_StartBug> func_ret_value = H5Ovisit ( ( hid_t ) * group_id , ( H5_index_t ) * index_type , ( H5_iter_order_t ) * order , op , op_data ) ; <S2SV_EndBug> ret_value = ( int_f ) func_ret_value ; return ret_value ; }
<S2SV_ModStart> op , op_data , ( unsigned ) 15
2,090
CWE-000 static int test_item4 ( void ) { int rc = TC_PASS ; int64_t * source , * dest ; int64_t expect_value ; int i , count , dst , sst , pe ; int num_proc = 0 ; int my_proc = 0 ; num_proc = shmem_n_pes ( ) ; my_proc = shmem_my_pe ( ) ; count = 2 ; dst = 2 ; sst = 1 ; dest = ( int64_t * ) shmem_malloc ( count * dst * num_proc * sizeof ( * dest ) ) ; source = ( int64_t * ) shmem_malloc ( count * sst * num_proc * sizeof ( * source ) ) ; for ( pe = 0 ; pe < num_proc ; pe ++ ) { for ( i = 0 ; i < count ; i ++ ) { <S2SV_StartBug> source [ ( pe * count * sst ) + i ] = my_proc + i ; <S2SV_EndBug> <S2SV_StartBug> dest [ ( pe * count * dst ) + i ] = 9999 ; <S2SV_EndBug> } } <S2SV_StartBug> for ( i = 0 ; i < SHMEM_ALLTOALL_SYNC_SIZE ; i ++ ) <S2SV_EndBug> { pSync [ i ] = _SHMEM_SYNC_VALUE ; } shmem_barrier_all ( ) ; shmem_alltoalls64 ( dest , source , dst , sst , count , 0 , 0 , num_proc , pSync ) ; for ( pe = 0 ; pe < num_proc ; pe ++ ) { for ( i = 0 ; i < count ; i ++ ) { expect_value = i + index_to_pe ( pe , 0 , 0 , num_proc ) ; <S2SV_StartBug> if ( dest [ ( pe * count * dst ) + i ] != expect_value ) { <S2SV_EndBug> rc = TC_FAIL ; log_debug ( OSH_TC , "my#%d<S2SV_blank>ERROR:<S2SV_blank>dest[%d]=%ld,<S2SV_blank>should<S2SV_blank>be<S2SV_blank>%d\\n" , <S2SV_StartBug> my_proc , ( pe * count * dst ) + i , dest [ ( pe * count * dst ) + i ] , <S2SV_EndBug> expect_value ) ; } } } shmem_barrier_all ( ) ; shmem_free ( dest ) ; shmem_free ( source ) ; return rc ; }
<S2SV_ModStart> sst ) + ( i * sst ) <S2SV_ModEnd> ] = my_proc <S2SV_ModStart> dst ) + ( i * dst ) <S2SV_ModEnd> ] = 9999 <S2SV_ModStart> ; i < SHMEM_ALLTOALLS_SYNC_SIZE <S2SV_ModEnd> ; i ++ <S2SV_ModStart> dst ) + ( i * dst ) <S2SV_ModEnd> ] != expect_value <S2SV_ModStart> dst ) + ( i * dst ) <S2SV_ModEnd> , dest [ <S2SV_ModStart> dst ) + ( i * dst ) <S2SV_ModEnd> ] , expect_value
2,091
CWE-000 int __close_fd ( struct files_struct * files , unsigned fd ) { struct file * file ; struct fdtable * fdt ; struct fdt_user * user ; struct task_struct * task ; spin_lock ( & files -> file_lock ) ; fdt = files_fdtable ( files ) ; if ( fd >= fdt -> max_fds ) { pr_debug ( "[%s]<S2SV_blank>fd<S2SV_blank>%u<S2SV_blank>exceeds<S2SV_blank>max_fds<S2SV_blank>%u<S2SV_blank>(user:<S2SV_blank>%s<S2SV_blank>%d:%d)\\n" , __func__ , fd , fdt -> max_fds , current -> comm , current -> tgid , current -> pid ) ; goto out_unlock ; } file = fdt -> fd [ fd ] ; if ( ! file ) { user = & fdt -> user [ fd ] ; if ( unlikely ( user -> remover && user -> remover != current -> pid ) ) { task = find_task_by_vpid ( user -> remover ) ; pr_warn ( "[%s]<S2SV_blank>fd<S2SV_blank>%u<S2SV_blank>of<S2SV_blank>%s<S2SV_blank>%d:%d<S2SV_blank>is<S2SV_blank>already<S2SV_blank>closed<S2SV_blank>by<S2SV_blank>thread<S2SV_blank>%d<S2SV_blank>(%s<S2SV_blank>%d:%d)<S2SV_blank>at<S2SV_blank>%lu<S2SV_blank>ms,<S2SV_blank>opened<S2SV_blank>at<S2SV_blank>%lu<S2SV_blank>ms\\n" , __func__ , fd , current -> comm , current -> tgid , current -> pid , user -> remover , task ? task -> comm : "<unknown>" , task ? task -> tgid : - 1 , task ? task -> pid : - 1 , user -> remove_ts , user -> install_ts ) ; } goto out_unlock ; } rcu_assign_pointer ( fdt -> fd [ fd ] , NULL ) ; <S2SV_StartBug> fdt -> user [ fd ] . remover = current -> pid ; <S2SV_EndBug> <S2SV_StartBug> fdt -> user [ fd ] . remove_ts = htc_debug_get_sched_clock_ms ( ) ; <S2SV_EndBug> __clear_close_on_exec ( fd , fdt ) ; __put_unused_fd ( files , fd ) ; spin_unlock ( & files -> file_lock ) ; return filp_close ( file , files ) ; out_unlock : spin_unlock ( & files -> file_lock ) ; return - EBADF ; }
<S2SV_ModStart> NULL ) ; # ifdef CONFIG_HTC_DEBUG <S2SV_ModStart> ( ) ; # endif
2,092
CWE-000 struct syncenv * syncenv_new ( size_t stacksize , int procmin , int procmax ) { struct syncenv * newenv = NULL ; int ret = 0 ; int i = 0 ; if ( ! procmin || procmin < 0 ) procmin = SYNCENV_PROC_MIN ; if ( ! procmax || procmax > SYNCENV_PROC_MAX ) procmax = SYNCENV_PROC_MAX ; if ( procmin > procmax ) return NULL ; newenv = GF_CALLOC ( 1 , sizeof ( * newenv ) , gf_common_mt_syncenv ) ; if ( ! newenv ) return NULL ; pthread_mutex_init ( & newenv -> mutex , NULL ) ; pthread_cond_init ( & newenv -> cond , NULL ) ; INIT_LIST_HEAD ( & newenv -> runq ) ; INIT_LIST_HEAD ( & newenv -> waitq ) ; newenv -> stacksize = SYNCENV_DEFAULT_STACKSIZE ; if ( stacksize ) newenv -> stacksize = stacksize ; newenv -> procmin = procmin ; newenv -> procmax = procmax ; for ( i = 0 ; i < newenv -> procmin ; i ++ ) { newenv -> proc [ i ] . env = newenv ; ret = gf_thread_create ( & newenv -> proc [ i ] . processor , NULL , syncenv_processor , & newenv -> proc [ i ] ) ; if ( ret ) break ; newenv -> procs ++ ; } <S2SV_StartBug> if ( ret != 0 ) <S2SV_EndBug> <S2SV_StartBug> syncenv_destroy ( newenv ) ; <S2SV_EndBug> return newenv ; }
<S2SV_ModStart> != 0 ) { <S2SV_ModStart> newenv ) ; newenv = NULL ; }
2,093
CWE-000 int db_redis_parse_keys ( km_redis_con_t * con ) { char * p ; char * start ; char * end ; str table_name ; str type_name ; str column_name ; struct str_hash_entry * table_entry ; redis_table_t * table ; redis_type_t * type ; redis_type_t * type_target ; redis_key_t * key ; redis_key_t * * key_target ; redis_key_t * key_location ; enum { DBREDIS_KEYS_TABLE_ST , DBREDIS_KEYS_TYPE_ST , DBREDIS_KEYS_COLUMN_ST , DBREDIS_KEYS_END_ST } state ; if ( ! redis_keys . len ) { LM_ERR ( "Failed<S2SV_blank>to<S2SV_blank>parse<S2SV_blank>empty<S2SV_blank>\'keys\'<S2SV_blank>mod-param,<S2SV_blank>please<S2SV_blank>define<S2SV_blank>it!\\n" ) ; return - 1 ; } type_target = NULL ; key_location = NULL ; end = redis_keys . s + redis_keys . len ; p = start = redis_keys . s ; state = DBREDIS_KEYS_TABLE_ST ; do { <S2SV_StartBug> switch ( state ) { <S2SV_EndBug> case DBREDIS_KEYS_TABLE_ST : while ( p != end && * p != '=' ) ++ p ; if ( p == end ) { LM_ERR ( "Invalid<S2SV_blank>table<S2SV_blank>definition,<S2SV_blank>expecting<S2SV_blank><table>=<definition>\\n" ) ; goto err ; } table_name . s = start ; table_name . len = p - start ; state = DBREDIS_KEYS_TYPE_ST ; start = ++ p ; LM_DBG ( "found<S2SV_blank>table<S2SV_blank>name<S2SV_blank>\'%.*s\'\\n" , table_name . len , table_name . s ) ; table_entry = str_hash_get ( & con -> tables , table_name . s , table_name . len ) ; if ( ! table_entry ) { LM_ERR ( "No<S2SV_blank>table<S2SV_blank>schema<S2SV_blank>found<S2SV_blank>for<S2SV_blank>table<S2SV_blank>\'%.*s\',<S2SV_blank>fix<S2SV_blank>config<S2SV_blank>by<S2SV_blank>adding<S2SV_blank>one<S2SV_blank>to<S2SV_blank>the<S2SV_blank>\'schema\'<S2SV_blank>mod-param!\\n" , table_name . len , table_name . s ) ; goto err ; } table = table_entry -> u . p ; break ; case DBREDIS_KEYS_TYPE_ST : while ( p != end && * p != ':' ) ++ p ; if ( p == end ) { LM_ERR ( "Invalid<S2SV_blank>type<S2SV_blank>definition,<S2SV_blank>expecting<S2SV_blank><type>:<definition>\\n" ) ; goto err ; } type_name . s = start ; type_name . len = p - start ; state = DBREDIS_KEYS_COLUMN_ST ; start = ++ p ; LM_DBG ( "found<S2SV_blank>type<S2SV_blank>name<S2SV_blank>\'%.*s\'<S2SV_blank>for<S2SV_blank>table<S2SV_blank>\'%.*s\'\\n" , type_name . len , type_name . s , table_name . len , table_name . s ) ; if ( type_name . len == REDIS_DIRECT_PREFIX_LEN && ! strncmp ( type_name . s , REDIS_DIRECT_PREFIX , type_name . len ) ) { key_target = & table -> entry_keys ; } else { type = db_redis_create_type ( & type_name ) ; if ( ! type ) goto err ; if ( ! table -> types ) { table -> types = type_target = type ; } else { if ( ! type_target ) { LM_ERR ( "Internal<S2SV_blank>error<S2SV_blank>accessing<S2SV_blank>null<S2SV_blank>type_target\\n" ) ; goto err ; } type_target -> next = type ; type_target = type_target -> next ; } key_target = & type -> keys ; } break ; case DBREDIS_KEYS_COLUMN_ST : while ( p != end && * p != ',' && * p != '&' && * p != ';' ) ++ p ; if ( p == end ) { state = DBREDIS_KEYS_END_ST ; } else if ( * p == ',' ) { state = DBREDIS_KEYS_COLUMN_ST ; } else if ( * p == '&' ) { state = DBREDIS_KEYS_TYPE_ST ; } else if ( * p == ';' ) { state = DBREDIS_KEYS_TABLE_ST ; } column_name . s = start ; column_name . len = p - start ; start = ++ p ; key = db_redis_create_key ( & column_name ) ; if ( ! key ) goto err ; if ( * key_target == NULL ) { * key_target = key_location = key ; } else { if ( ! key_location ) { LM_ERR ( "Internal<S2SV_blank>error,<S2SV_blank>null<S2SV_blank>key_location<S2SV_blank>pointer\\n" ) ; goto err ; } key_location -> next = key ; key_location = key_location -> next ; } break ; case DBREDIS_KEYS_END_ST : LM_DBG ( "done<S2SV_blank>parsing<S2SV_blank>keys<S2SV_blank>definition\\n" ) ; return 0 ; } } while ( p != end ) ; return 0 ; err : <S2SV_StartBug> db_redis_free_tables ( con ) ; <S2SV_EndBug> return - 1 ; }
<S2SV_ModStart> ; do { type = NULL ; key = NULL ; <S2SV_ModStart> ; err : if ( type ) pkg_free ( type ) ; if ( key ) pkg_free ( key ) ;
2,094
CWE-000 static size_t redis_set_handler_sequential ( redis_client_t * client , index_entry_t * existing ) { resp_request_t * request = client -> request ; index_root_t * index = client -> ns -> index ; data_root_t * data = client -> ns -> data ; index_entry_t * idxentry = NULL ; uint32_t id = index_next_id ( index ) ; uint8_t idlength = sizeof ( uint32_t ) ; if ( request -> argv [ 1 ] -> length ) { if ( request -> argv [ 1 ] -> length != idlength ) { debug ( "[-]<S2SV_blank>redis:<S2SV_blank>set:<S2SV_blank>trying<S2SV_blank>to<S2SV_blank>insert<S2SV_blank>key<S2SV_blank>with<S2SV_blank>invalid<S2SV_blank>size\\n" ) ; redis_hardsend ( client , "-Invalid<S2SV_blank>key,<S2SV_blank>use<S2SV_blank>empty<S2SV_blank>key<S2SV_blank>for<S2SV_blank>auto-generated<S2SV_blank>key" ) ; return 0 ; } index_entry_t * found = NULL ; if ( ! ( found = redis_get_handlers [ SEQUENTIAL ] ( client ) ) ) { debug ( "[-]<S2SV_blank>redis:<S2SV_blank>set:<S2SV_blank>trying<S2SV_blank>to<S2SV_blank>insert<S2SV_blank>invalid<S2SV_blank>key\\n" ) ; redis_hardsend ( client , "-Invalid<S2SV_blank>key,<S2SV_blank>only<S2SV_blank>update<S2SV_blank>authorized" ) ; return 0 ; } memcpy ( & id , found -> id , idlength ) ; debug ( "[+]<S2SV_blank>redis:<S2SV_blank>set:<S2SV_blank>updating<S2SV_blank>existing<S2SV_blank>key:<S2SV_blank>%08x\\n" , id ) ; } unsigned char * value = request -> argv [ 2 ] -> buffer ; uint32_t valuelength = request -> argv [ 2 ] -> length ; debug ( "[+]<S2SV_blank>command:<S2SV_blank>set:<S2SV_blank>%u<S2SV_blank>bytes<S2SV_blank>key,<S2SV_blank>%u<S2SV_blank>bytes<S2SV_blank>data\\n" , idlength , valuelength ) ; data_request_t dreq = { . data = value , . datalength = valuelength , . vid = & id , . idlength = idlength , . flags = 0 , . crc = data_crc32 ( value , valuelength ) , } ; if ( existing && existing -> crc == dreq . crc ) { debug ( "[+]<S2SV_blank>command:<S2SV_blank>set:<S2SV_blank>existing<S2SV_blank>%08x<S2SV_blank><><S2SV_blank>%08x<S2SV_blank>crc<S2SV_blank>match,<S2SV_blank>ignoring\\n" , existing -> crc , dreq . crc ) ; redis_hardsend ( client , "$-1" ) ; return 0 ; } size_t offset = data_insert ( data , & dreq ) ; if ( offset == 0 ) { redis_hardsend ( client , "-Internal<S2SV_blank>Error<S2SV_blank>(data)" ) ; return 0 ; } debug ( "[+]<S2SV_blank>command:<S2SV_blank>set:<S2SV_blank>sequential-key:<S2SV_blank>" ) ; debughex ( & id , idlength ) ; debug ( "\\n" ) ; debug ( "[+]<S2SV_blank>command:<S2SV_blank>set:<S2SV_blank>offset:<S2SV_blank>%lu\\n" , offset ) ; index_entry_t idxreq = { . idlength = idlength , . offset = offset , . length = request -> argv [ 2 ] -> length , . crc = dreq . crc , . flags = 0 , } ; if ( ! ( idxentry = index_entry_insert_new ( index , & id , & idxreq ) ) ) { redis_hardsend ( client , "-Internal<S2SV_blank>Error<S2SV_blank>(index)" ) ; return 0 ; } free ( idxentry ) ; redis_bulk_t response = redis_bulk ( & id , idlength ) ; if ( ! response . buffer ) { redis_hardsend ( client , "-Internal<S2SV_blank>Error<S2SV_blank>(bulk)" ) ; return 0 ; } <S2SV_StartBug> redis_reply ( client , response . buffer , response . length , free ) ; <S2SV_EndBug> return offset ; }
<S2SV_ModStart> response . length ) ; free ( response . buffer <S2SV_ModEnd> ) ; return
2,095
CWE-000 Heap * new_heap ( int capacity ) { if ( capacity <= 0 ) { return NULL ; } int * data = malloc ( sizeof ( int ) * capacity ) ; <S2SV_StartBug> if ( data == NULL ) { <S2SV_EndBug> return NULL ; } Heap * heap = malloc ( sizeof * heap ) ; <S2SV_StartBug> if ( heap == NULL ) { <S2SV_EndBug> <S2SV_StartBug> free ( data ) ; <S2SV_EndBug> return NULL ; } heap -> data = data ; heap -> length = 0 ; heap -> capacity = capacity ; return heap ; }
<S2SV_ModStart> capacity ) ; <S2SV_ModEnd> Heap * heap <S2SV_ModStart> ; if ( data == NULL || <S2SV_ModStart> free ( data ) ; free ( heap
2,096
CWE-000 void scav_hash_table_entries ( struct hash_table * hash_table , int ( * alivep [ 5 ] ) ( lispobj , lispobj ) , void ( * scav_entry ) ( lispobj * ) ) { lispobj * kv_vector ; uword_t kv_length ; lispobj * index_vector ; uword_t length ; lispobj * next_vector ; uword_t next_vector_length ; lispobj * hash_vector ; uword_t hash_vector_length ; uword_t i ; kv_vector = get_array_data ( hash_table -> table , SIMPLE_VECTOR_WIDETAG , & kv_length ) ; if ( kv_vector == NULL ) lose ( "invalid<S2SV_blank>kv_vector<S2SV_blank>%x\\n" , hash_table -> table ) ; index_vector = get_array_data ( hash_table -> index_vector , SIMPLE_ARRAY_WORD_WIDETAG , & length ) ; if ( index_vector == NULL ) lose ( "invalid<S2SV_blank>index_vector<S2SV_blank>%x\\n" , hash_table -> index_vector ) ; next_vector = get_array_data ( hash_table -> next_vector , SIMPLE_ARRAY_WORD_WIDETAG , & next_vector_length ) ; if ( next_vector == NULL ) lose ( "invalid<S2SV_blank>next_vector<S2SV_blank>%x\\n" , hash_table -> next_vector ) ; hash_vector = get_array_data ( hash_table -> hash_vector , SIMPLE_ARRAY_WORD_WIDETAG , & hash_vector_length ) ; if ( hash_vector != NULL ) gc_assert ( hash_vector_length == next_vector_length ) ; gc_assert ( next_vector_length * 2 == kv_length ) ; <S2SV_StartBug> if ( kv_vector [ 1 ] != UNBOUND_MARKER_WIDETAG ) <S2SV_EndBug> <S2SV_StartBug> lose ( "unexpected<S2SV_blank>empty-hash-table-slot<S2SV_blank>marker:<S2SV_blank>%p\\n" , kv_vector [ 1 ] ) ; <S2SV_EndBug> int ( * alivep_test ) ( lispobj , lispobj ) = alivep [ fixnum_value ( hash_table -> _weakness ) ] ; <S2SV_StartBug> # define SCAV_ENTRIES ( aliveness_predicate ) for ( i = 1 ; i < next_vector_length ; i ++ ) { lispobj old_key = kv_vector [ 2 * i ] ; lispobj __attribute__ ( ( unused ) ) value = kv_vector [ 2 * i + 1 ] ; if ( aliveness_predicate ) { scav_entry ( & kv_vector [ 2 * i ] ) ; if ( kv_vector [ 2 * i ] != old_key && ( ! hash_vector || hash_vector [ i ] == MAGIC_HASH_VECTOR_VALUE ) ) hash_table -> needs_rehash_p = T ; } } <S2SV_EndBug> if ( alivep_test ) SCAV_ENTRIES ( alivep_test ( old_key , value ) ) else SCAV_ENTRIES ( 1 ) }
<S2SV_ModStart> [ 1 ] && kv_vector [ 1 ] != make_fixnum ( 1 ) <S2SV_ModEnd> ) lose ( <S2SV_ModStart> ) lose ( "unexpected<S2SV_blank>need-to-rehash:<S2SV_blank>%" OBJ_FMTX <S2SV_ModEnd> , kv_vector [ <S2SV_ModStart> MAGIC_HASH_VECTOR_VALUE ) ) kv_vector [ 1 ] = make_fixnum ( 1 ) <S2SV_ModEnd> ; } }
2,097
CWE-000 void ProcessList_processEntries ( ProcessList * this , char * dirname , int parent , float period ) { DIR * dir ; struct dirent * entry ; Process * prototype = this -> prototype ; dir = opendir ( dirname ) ; if ( ! dir ) return ; while ( ( entry = readdir ( dir ) ) != NULL ) { char * name = entry -> d_name ; int pid ; pid = atoi ( name ) ; bool isThread = false ; if ( ( ! this -> hideThreads ) && pid == 0 && name [ 0 ] == '.' ) { char * tname = name + 1 ; pid = atoi ( tname ) ; if ( pid > 0 ) isThread = true ; } if ( pid > 0 && pid != parent ) { if ( ! this -> hideUserlandThreads ) { char subdirname [ MAX_NAME + 1 ] ; snprintf ( subdirname , MAX_NAME , "%s/%s/task" , dirname , name ) ; if ( access ( subdirname , X_OK ) == 0 ) { ProcessList_processEntries ( this , subdirname , pid , period ) ; } } FILE * status ; char statusfilename [ MAX_NAME + 1 ] ; char command [ PROCESS_COMM_LEN + 1 ] ; Process * process = NULL ; <S2SV_StartBug> Process * existingProcess = ( Process * ) Hashtable_get ( this -> processTable , pid ) ; <S2SV_EndBug> if ( existingProcess ) { assert ( Vector_indexOf ( this -> processes , existingProcess , Process_pidCompare ) != - 1 ) ; process = existingProcess ; assert ( process -> pid == pid ) ; } else { process = prototype ; assert ( process -> comm == NULL ) ; process -> pid = pid ; if ( ! ProcessList_readStatusFile ( this , process , dirname , name ) ) goto errorReadingProcess ; } process -> updated = true ; snprintf ( statusfilename , MAX_NAME , "%s/%s/statm" , dirname , name ) ; status = ProcessList_fopen ( this , statusfilename , "r" ) ; if ( ! status ) { goto errorReadingProcess ; } int num = ProcessList_fread ( this , status , "%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d" , & process -> m_size , & process -> m_resident , & process -> m_share , & process -> m_trs , & process -> m_drs , & process -> m_lrs , & process -> m_dt ) ; fclose ( status ) ; if ( num != 7 ) goto errorReadingProcess ; if ( this -> hideKernelThreads && process -> m_size == 0 ) goto errorReadingProcess ; int lasttimes = ( process -> utime + process -> stime ) ; snprintf ( statusfilename , MAX_NAME , "%s/%s/stat" , dirname , name ) ; status = ProcessList_fopen ( this , statusfilename , "r" ) ; if ( status == NULL ) goto errorReadingProcess ; int success = ProcessList_readStatFile ( this , process , status , command ) ; fclose ( status ) ; if ( ! success ) goto errorReadingProcess ; if ( ! existingProcess ) { process -> user = UsersTable_getRef ( this -> usersTable , process -> st_uid ) ; snprintf ( statusfilename , MAX_NAME , "%s/%s/cmdline" , dirname , name ) ; status = ProcessList_fopen ( this , statusfilename , "r" ) ; if ( ! status ) { goto errorReadingProcess ; } int amtRead = fread ( command , 1 , PROCESS_COMM_LEN - 1 , status ) ; if ( amtRead > 0 ) { for ( int i = 0 ; i < amtRead ; i ++ ) if ( command [ i ] == '\\0' || command [ i ] == '\\n' ) command [ i ] = '<S2SV_blank>' ; command [ amtRead ] = '\\0' ; } command [ PROCESS_COMM_LEN ] = '\\0' ; process -> comm = String_copy ( command ) ; fclose ( status ) ; } process -> percent_cpu = ( process -> utime + process -> stime - lasttimes ) / period * 100.0 ; process -> percent_mem = process -> m_resident / ( float ) ( this -> usedMem - this -> cachedMem - this -> buffersMem ) * 100.0 ; this -> totalTasks ++ ; if ( process -> state == 'R' ) { this -> runningTasks ++ ; } if ( ! existingProcess ) { process = Process_clone ( process ) ; ProcessList_add ( this , process ) ; } continue ; errorReadingProcess : { if ( process -> comm ) { free ( process -> comm ) ; process -> comm = NULL ; } if ( existingProcess ) ProcessList_remove ( this , process ) ; <S2SV_StartBug> } <S2SV_EndBug> } } closedir ( dir ) ; }
<S2SV_ModStart> = NULL ; assert ( Hashtable_count ( this -> processTable ) == Vector_count ( this -> processes ) ) ; <S2SV_ModStart> process ) ; assert ( Hashtable_count ( this -> processTable ) == Vector_count ( this -> processes ) ) ;
2,098
CWE-000 void run_function_onearg_nat ( jsobjtype parent , const char * name , jsobjtype child ) { duk_push_heapptr ( jcx , parent ) ; <S2SV_StartBug> if ( ! duk_get_prop_string ( jcx , - 1 , name ) || ! duk_is_function ( jcx , - 1 ) ) <S2SV_EndBug> return ; <S2SV_StartBug> duk_insert ( jcx , 0 ) ; <S2SV_EndBug> duk_push_heapptr ( jcx , child ) ; duk_call_method ( jcx , 1 ) ; duk_pop ( jcx ) ; }
<S2SV_ModStart> 1 ) ) { duk_pop_2 ( jcx ) ; return ; } <S2SV_ModEnd> duk_insert ( jcx <S2SV_ModStart> ( jcx , - 2 <S2SV_ModEnd> ) ; duk_push_heapptr
2,099
CWE-000 struct lt_arg * lt_args_getarg ( struct lt_config_shared * cfg , const char * type , const char * name , int pointer , int create , char * enum_name ) { struct lt_arg * arg ; void * xfm_func = NULL ; char * bitmask = NULL , * fmt = NULL , * name_copy = NULL , * modifier = NULL ; int collapsed = 0 ; if ( name ) { bitmask = strchr ( name , '|' ) ; fmt = strchr ( name , '/' ) ; } if ( bitmask && fmt && ( bitmask < fmt ) ) modifier = bitmask - 1 ; else if ( fmt && bitmask && ( fmt < bitmask ) ) modifier = fmt - 1 ; else if ( bitmask ) modifier = bitmask - 1 ; else if ( fmt ) modifier = fmt - 1 ; else if ( name ) modifier = ( char * ) & name [ strlen ( name ) - 1 ] ; if ( modifier ) { if ( * modifier == '!' ) collapsed = COLLAPSED_BASIC ; else if ( * modifier == '~' ) collapsed = COLLAPSED_TERSE ; else if ( * modifier == '^' ) collapsed = COLLAPSED_BARE ; } if ( ! collapsed ) modifier = NULL ; if ( bitmask || fmt || modifier ) { XSTRDUP_ASSIGN ( name_copy , name ) ; if ( ! name_copy ) return NULL ; bitmask = strchr ( name_copy , '|' ) ; fmt = strchr ( name_copy , '/' ) ; if ( modifier ) { modifier = name_copy + ( modifier - name ) ; * modifier = 0 ; } if ( bitmask ) * bitmask ++ = 0 ; if ( fmt ) * fmt ++ = 0 ; name = name_copy ; } if ( create ) { ENTRY e , * ep ; e . key = ( char * ) type ; if ( hsearch_r ( e , FIND , & ep , & args_struct_xfm_tab ) ) xfm_func = ep -> data ; } do { ENTRY e , * ep ; <S2SV_StartBug> if ( ( arg = find_arg ( cfg , type , <S2SV_EndBug> args_def_pod , LT_ARGS_DEF_POD_NUM , create ) ) ) { <S2SV_StartBug> if ( name ) { <S2SV_EndBug> e . key = ( char * ) name ; if ( hsearch_r ( e , FIND , & ep , & args_func_xfm_tab ) ) arg -> latrace_custom_func_transformer = ( void * ) ep -> data ; if ( hsearch_r ( e , FIND , & ep , & args_func_intercept_tab ) ) arg -> latrace_custom_func_intercept = ( void * ) ep -> data ; } <S2SV_StartBug> break ; <S2SV_EndBug> } if ( ( arg = find_arg ( cfg , type , args_def_struct , args_def_struct_cnt , create ) ) ) break ; if ( ( arg = find_arg ( cfg , type , args_def_typedef , args_def_typedef_cnt , create ) ) ) break ; if ( ! create ) return NULL ; e . key = ( char * ) type ; if ( name && xfm_func ) { arg = find_arg ( cfg , "custom_user_struct_transformer" , args_def_pod , LT_ARGS_DEF_POD_NUM , create ) ; if ( arg ) { arg -> latrace_custom_struct_transformer = ( void * ) ep -> data ; break ; } } return NULL ; } while ( 0 ) ; if ( ! create ) return arg ; if ( xfm_func ) arg -> latrace_custom_struct_transformer = xfm_func ; if ( enum_name ) { if ( ( arg -> en = getenum ( cfg , enum_name ) ) == NULL ) { return NULL ; } if ( arg -> en -> bitmask ) bitmask = enum_name ; fmt = arg -> en -> fmt ; } XSTRDUP_ASSIGN ( arg -> name , name ) ; if ( ! arg -> name ) return NULL ; if ( ! arg -> pointer ) arg -> pointer = pointer ; if ( fmt && * fmt ) { XSTRDUP_ASSIGN ( arg -> fmt , fmt ) ; if ( ! arg -> fmt ) return NULL ; } if ( bitmask ) { XSTRDUP_ASSIGN ( arg -> bitmask_class , bitmask ) ; if ( ! arg -> bitmask_class ) return NULL ; } if ( collapsed ) arg -> collapsed = collapsed ; if ( name_copy ) XFREE ( name_copy ) ; return arg ; }
<S2SV_ModStart> * ep ; int found = 0 ; <S2SV_ModStart> ) ) { found = 1 ; } else if ( ( arg = find_arg ( cfg , type , args_def_struct , args_def_struct_cnt , create ) ) ) { found = 1 ; } else if ( ( arg = find_arg ( cfg , type , args_def_typedef , args_def_typedef_cnt , create ) ) ) { found = 1 ; } if ( found && <S2SV_ModEnd> name ) { <S2SV_ModStart> data ; } if ( found <S2SV_ModEnd> ) break ;