Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
7,900 |
CWE-000 void stop_animation ( ) { <S2SV_StartBug> dprintf ( "stop_animation\\n" ) ; <S2SV_EndBug> if ( animation . animationStop ) animation . animationStop ( ) ; <S2SV_StartBug> animation . is_running = false ; <S2SV_EndBug> animation . animationStart = 0 ; animation . animationStop = 0 ; animation . animationLoop = 0 ; animation . animation_typematrix_row = 0 ; }
|
<S2SV_ModStart> ( "stop_animation\\n" ) ; if ( ! animation . is_running && ! animation . is_suspended ) return <S2SV_ModStart> animation . is_running = false ; animation . is_suspended
|
7,901 |
CWE-000 void dhms_clock_tick ( ) { time_t ct = time ( 0 ) ; time_t passed = ct - dhms_clock . t ; dhms_clock . t = ct ; if ( passed > 0 ) { dhms_clock . d += passed / ( 24 * 60 * 60 ) ; dhms_clock . h += ( passed % ( 24 * 60 * 60 ) ) / ( 60 * 60 ) ; dhms_clock . m += ( passed % ( 60 * 60 ) ) / ( 60 ) ; dhms_clock . s += passed % 60 ; <S2SV_StartBug> if ( dhms_clock . s > 60 ) { <S2SV_EndBug> dhms_clock . m += dhms_clock . s / 60 ; dhms_clock . s %= 60 ; } <S2SV_StartBug> if ( dhms_clock . m > 60 ) { <S2SV_EndBug> dhms_clock . h += dhms_clock . m / 60 ; dhms_clock . m %= 60 ; } <S2SV_StartBug> if ( dhms_clock . h > 24 ) { <S2SV_EndBug> dhms_clock . d += dhms_clock . h / 24 ; dhms_clock . h %= 24 ; } } }
|
<S2SV_ModStart> dhms_clock . s >= <S2SV_ModEnd> 60 ) { <S2SV_ModStart> dhms_clock . m >= <S2SV_ModEnd> 60 ) { <S2SV_ModStart> dhms_clock . h >= <S2SV_ModEnd> 24 ) {
|
7,902 |
CWE-000 <S2SV_StartBug> static size_t dstrsize ( size_t len ) <S2SV_EndBug> { return 1 << ( ( 8 * sizeof ( len ) ) - __builtin_clz ( len ) ) ; }
|
<S2SV_ModStart> dstrsize ( size_t _len ) { unsigned len = ( unsigned ) _len ; <S2SV_ModEnd> return 1 <<
|
7,903 |
CWE-000 void isor_reader_get_sample_from_item ( ISOMChannel * ch ) { if ( ch -> current_slh . AU_sequenceNumber ) { ch -> last_state = GF_EOS ; return ; } ch -> sample_time = 0 ; ch -> last_state = GF_OK ; ch -> sample = gf_isom_sample_new ( ) ; ch -> sample -> IsRAP = RAP ; ch -> current_slh . accessUnitEndFlag = ch -> current_slh . accessUnitStartFlag = 1 ; ch -> current_slh . au_duration = 1000 ; ch -> current_slh . randomAccessPointFlag = ch -> sample -> IsRAP ; ch -> current_slh . compositionTimeStampFlag = 1 ; ch -> current_slh . decodingTimeStampFlag = 1 ; <S2SV_StartBug> gf_isom_extract_meta_item_mem ( ch -> owner -> mov , GF_TRUE , 0 , ch -> item_id , & ch -> sample -> data , & ch -> sample -> dataLength , NULL ) ; <S2SV_EndBug> ch -> current_slh . accessUnitLength = ch -> sample -> dataLength ; }
|
<S2SV_ModStart> dataLength , NULL , GF_FALSE
|
7,904 |
CWE-000 VOS_STATUS WDA_HALDumpCmdReq ( tpAniSirGlobal pMac , tANI_U32 cmd , tANI_U32 arg1 , tANI_U32 arg2 , tANI_U32 arg3 , tANI_U32 arg4 , tANI_U8 * pBuffer , wpt_boolean async ) { WDI_Status status = WDI_STATUS_SUCCESS ; WDI_HALDumpCmdReqParamsType * wdiHALDumpCmdReqParam = NULL ; WDI_HALDumpCmdReqInfoType * wdiHalDumpCmdInfo = NULL ; tWDA_HalDumpReqParams * pWdaParams ; pVosContextType pVosContext = NULL ; VOS_STATUS vStatus ; pVosContext = ( pVosContextType ) vos_get_global_context ( VOS_MODULE_ID_PE , ( void * ) pMac ) ; if ( pVosContext ) { if ( pVosContext -> isLogpInProgress ) { VOS_TRACE ( VOS_MODULE_ID_WDA , VOS_TRACE_LEVEL_FATAL , "%s:LOGP<S2SV_blank>in<S2SV_blank>Progress.<S2SV_blank>Ignore!!!" , __func__ ) ; return VOS_STATUS_E_BUSY ; } } else { VOS_TRACE ( VOS_MODULE_ID_WDA , VOS_TRACE_LEVEL_ERROR , "%s:<S2SV_blank>VOS<S2SV_blank>Context<S2SV_blank>Null" , __func__ ) ; return VOS_STATUS_E_RESOURCES ; } if ( NULL == pVosContext -> pWDAContext ) { VOS_TRACE ( VOS_MODULE_ID_WDA , VOS_TRACE_LEVEL_ERROR , "%s:<S2SV_blank>WDA<S2SV_blank>Context<S2SV_blank>Null" , __func__ ) ; return VOS_STATUS_E_RESOURCES ; } pWdaParams = ( tWDA_HalDumpReqParams * ) vos_mem_malloc ( sizeof ( tWDA_HalDumpReqParams ) ) ; if ( NULL == pWdaParams ) { VOS_TRACE ( VOS_MODULE_ID_WDA , VOS_TRACE_LEVEL_ERROR , "%s:<S2SV_blank>VOS<S2SV_blank>MEM<S2SV_blank>Alloc<S2SV_blank>Failure" , __func__ ) ; return VOS_STATUS_E_NOMEM ; } wdiHALDumpCmdReqParam = ( WDI_HALDumpCmdReqParamsType * ) vos_mem_malloc ( sizeof ( WDI_HALDumpCmdReqParamsType ) ) ; if ( NULL == wdiHALDumpCmdReqParam ) { VOS_TRACE ( VOS_MODULE_ID_WDA , VOS_TRACE_LEVEL_ERROR , "WDA<S2SV_blank>HAL<S2SV_blank>DUMP<S2SV_blank>Command<S2SV_blank>buffer<S2SV_blank>alloc<S2SV_blank>fail" ) ; vos_mem_free ( pWdaParams ) ; return WDI_STATUS_E_FAILURE ; } wdiHalDumpCmdInfo = & wdiHALDumpCmdReqParam -> wdiHALDumpCmdInfoType ; wdiHalDumpCmdInfo -> command = cmd ; wdiHalDumpCmdInfo -> argument1 = arg1 ; wdiHalDumpCmdInfo -> argument2 = arg2 ; wdiHalDumpCmdInfo -> argument3 = arg3 ; wdiHalDumpCmdInfo -> argument4 = arg4 ; wdiHALDumpCmdReqParam -> wdiReqStatusCB = NULL ; pWdaParams -> pWdaContext = pVosContext -> pWDAContext ; pWdaParams -> wdaHALDumpAsync = async ; pWdaParams -> wdaMsgParam = ( void * ) pBuffer ; pWdaParams -> wdaWdiApiMsgParam = ( void * ) wdiHALDumpCmdReqParam ; VOS_TRACE ( VOS_MODULE_ID_WDA , VOS_TRACE_LEVEL_INFO , "%s:<S2SV_blank>WDA<S2SV_blank>HAL<S2SV_blank>DUMP<S2SV_blank>Command<S2SV_blank>sent" , __func__ ) ; status = WDI_HALDumpCmdReq ( wdiHALDumpCmdReqParam , WDA_HALDumpCmdCallback , pWdaParams ) ; if ( ! async ) { vStatus = vos_wait_single_event ( & ( pVosContext -> wdaCompleteEvent ) , WDA_DUMPCMD_WAIT_TIMEOUT ) ; if ( vStatus != VOS_STATUS_SUCCESS ) { if ( vStatus == VOS_STATUS_E_TIMEOUT ) { VOS_TRACE ( VOS_MODULE_ID_VOSS , VOS_TRACE_LEVEL_ERROR , "%s:<S2SV_blank>Timeout<S2SV_blank>occurred<S2SV_blank>before<S2SV_blank>WDA_HALDUMP<S2SV_blank>complete" , __func__ ) ; } else { VOS_TRACE ( VOS_MODULE_ID_VOSS , VOS_TRACE_LEVEL_ERROR , "%s:<S2SV_blank>WDA_HALDUMP<S2SV_blank>reporting<S2SV_blank><S2SV_blank>other<S2SV_blank>error" , __func__ ) ; } <S2SV_StartBug> VOS_BUG ( 0 ) ; <S2SV_EndBug> } } return status ; }
|
<S2SV_ModStart> ) ; } if ( ! ( vos_isLoadUnloadInProgress ( ) || vos_is_logp_in_progress ( VOS_MODULE_ID_VOSS , NULL ) ) )
|
7,905 |
CWE-000 Abc_Cex_t * Saig_ManGenerateCex ( Gia_ManBmc_t * p , int f , int i ) { Aig_Obj_t * pObjPi ; Abc_Cex_t * pCex = Abc_CexMakeTriv ( Aig_ManRegNum ( p -> pAig ) , Saig_ManPiNum ( p -> pAig ) , Saig_ManPoNum ( p -> pAig ) , f * Saig_ManPoNum ( p -> pAig ) + i ) ; int j , k , iBit = Saig_ManRegNum ( p -> pAig ) ; for ( j = 0 ; j <= f ; j ++ , iBit += Saig_ManPiNum ( p -> pAig ) ) Saig_ManForEachPi ( p -> pAig , pObjPi , k ) { int iLit = Saig_ManBmcLiteral ( p , pObjPi , j ) ; if ( p -> pSat2 ) { <S2SV_StartBug> if ( iLit != ~ 0 && var_polarity ( p -> pSat2 , lit_var ( iLit ) ) == LIT_TRUE ) <S2SV_EndBug> Abc_InfoSetBit ( pCex -> pData , iBit + k ) ; } else { if ( iLit != ~ 0 && sat_solver_var_value ( p -> pSat , lit_var ( iLit ) ) ) Abc_InfoSetBit ( pCex -> pData , iBit + k ) ; } } return pCex ; }
|
<S2SV_ModStart> ~ 0 && solver_read_cex_varvalue <S2SV_ModEnd> ( p -> <S2SV_ModStart> iLit ) ) <S2SV_ModEnd> ) Abc_InfoSetBit (
|
7,906 |
CWE-000 static int mcast4opt_set_out_interface ( struct netsocket_config * cfg ) { struct in_addr addr ; if ( ! cfg -> out_interface ) return 0 ; if ( str_to_addr4 ( cfg -> out_interface , & addr ) ) return 1 ; if ( setsockopt ( sk , IPPROTO_IP , IP_MULTICAST_IF , & addr , sizeof ( addr ) ) ) { log_perror ( "-><S2SV_blank>setsockopt(IP_MULTICAST_IF)<S2SV_blank>failed" , errno ) ; return 1 ; } <S2SV_StartBug> log_info ( "-><S2SV_blank>The<S2SV_blank>outgoing<S2SV_blank>interface<S2SV_blank>was<S2SV_blank>overriden." ) ; <S2SV_EndBug> return 0 ; }
|
<S2SV_ModStart> } log_info ( "-><S2SV_blank>The<S2SV_blank>outgoing<S2SV_blank>interface<S2SV_blank>was<S2SV_blank>overridden." <S2SV_ModEnd> ) ; return
|
7,907 |
CWE-000 G_DEFINE_TYPE ( GfMonitorNormal , gf_monitor_normal , GF_TYPE_MONITOR ) static void generate_modes ( GfMonitorNormal * normal ) { GfMonitor * monitor ; GfOutput * output ; <S2SV_StartBug> guint i ; <S2SV_EndBug> monitor = GF_MONITOR ( normal ) ; output = gf_monitor_get_main_output ( monitor ) ; <S2SV_StartBug> for ( i = 0 ; i < output -> n_modes ; i ++ ) <S2SV_EndBug> { GfCrtcMode * crtc_mode ; <S2SV_StartBug> GfMonitorMode * mode ; <S2SV_EndBug> crtc_mode = output -> modes [ i ] ; mode = g_new0 ( GfMonitorMode , 1 ) ; mode -> spec . width = crtc_mode -> width ; mode -> spec . height = crtc_mode -> height ; mode -> spec . refresh_rate = crtc_mode -> refresh_rate ; mode -> spec . flags = crtc_mode -> flags & HANDLED_CRTC_MODE_FLAGS ; mode -> id = gf_monitor_mode_spec_generate_id ( & mode -> spec ) ; mode -> crtc_modes = g_new ( GfMonitorCrtcMode , 1 ) ; mode -> crtc_modes [ 0 ] . output = output ; mode -> crtc_modes [ 0 ] . crtc_mode = crtc_mode ; <S2SV_StartBug> if ( gf_monitor_add_mode ( monitor , mode ) ) <S2SV_EndBug> <S2SV_StartBug> { <S2SV_EndBug> if ( crtc_mode == output -> preferred_mode ) gf_monitor_set_preferred_mode ( monitor , mode ) ; if ( output -> crtc && crtc_mode == output -> crtc -> current_mode ) gf_monitor_set_current_mode ( monitor , mode ) ; } <S2SV_StartBug> else <S2SV_EndBug> { gf_monitor_mode_free ( mode ) ; } } }
|
<S2SV_ModStart> * output ; GfCrtcModeFlag preferred_mode_flags ; <S2SV_ModStart> monitor ) ; preferred_mode_flags = output -> preferred_mode -> flags ; <S2SV_ModStart> GfMonitorMode * mode ; gboolean replace <S2SV_ModStart> = crtc_mode ; replace = crtc_mode -> flags == preferred_mode_flags ; if ( ! <S2SV_ModEnd> gf_monitor_add_mode ( monitor <S2SV_ModStart> monitor , mode , replace <S2SV_ModStart> ) ) { g_assert ( crtc_mode != output -> preferred_mode ) ; gf_monitor_mode_free ( mode ) ; continue ; } <S2SV_ModStart> ) ; } <S2SV_ModEnd> } <S2SV_null> <S2SV_null>
|
7,908 |
CWE-000 main ( int argc , char * argv [ ] ) { char * buffer = NULL ; <S2SV_StartBug> struct calendarEvent_t c ; <S2SV_EndBug> <S2SV_StartBug> while ( readInput ( & buffer ) > 0 ) { <S2SV_EndBug> <S2SV_StartBug> if ( parseInput ( buffer , c ) > 0 ) { <S2SV_EndBug> } } while ( charsRead = getline ( & buffer , & len , stdin ) > 0 ) { <S2SV_StartBug> if ( parseEmail ( buffer , & c ) != - 1 ) printCalendarEvent ( c ) ; <S2SV_EndBug> switch ( c . type ) { <S2SV_StartBug> case 'C' : break ; <S2SV_EndBug> <S2SV_StartBug> case 'D' : break ; <S2SV_EndBug> <S2SV_StartBug> case 'X' : break ; <S2SV_EndBug> <S2SV_StartBug> default : perror ( "unsupported<S2SV_blank>calendarEvent<S2SV_blank>command" ) ; <S2SV_EndBug> } } free ( buffer ) ; return ( 0 ) ; }
|
<S2SV_ModStart> = NULL ; long unsigned int len ; <S2SV_ModStart> & buffer ) != - 1 <S2SV_ModEnd> ) { if <S2SV_ModStart> ( buffer , <S2SV_ModEnd> & c ) <S2SV_ModStart> & c ) ) { <S2SV_ModEnd> switch ( c <S2SV_ModStart> case 'C' : printf ( "Email<S2SV_blank>create<S2SV_blank>type\\n" ) ; <S2SV_ModStart> case 'D' : printf ( "Email<S2SV_blank>delete<S2SV_blank>type\\n" ) ; <S2SV_ModStart> case 'X' : printf ( "Email<S2SV_blank>modify<S2SV_blank>type\\n" ) ; <S2SV_ModStart> ; default : printf ( "incompatible<S2SV_blank>calendarEvent<S2SV_blank>type\\n" ) ; } <S2SV_ModEnd> } } free
|
7,909 |
CWE-000 int main ( int argc , char const * argv [ ] ) { int status ; no_of_devices = 0 ; status = pthread_create ( & listener_thread , NULL , listener , NULL ) ; <S2SV_StartBug> cmd_lookup_table = malloc ( 20 * sizeof ( Ltable ) ) ; <S2SV_EndBug> <S2SV_StartBug> devices = malloc ( 20 * sizeof ( VTS ) ) ; <S2SV_EndBug> if ( status != 0 ) { puts ( "cannot<S2SV_blank>start<S2SV_blank>listener<S2SV_blank>thread\\n" ) ; } while ( 1 ) { <S2SV_StartBug> sleep ( 1000 ) ; <S2SV_EndBug> } }
|
<S2SV_ModStart> = malloc ( <S2SV_ModEnd> sizeof ( Ltable <S2SV_ModStart> = malloc ( <S2SV_ModEnd> sizeof ( VTS <S2SV_ModStart> { sleep ( 100 <S2SV_ModEnd> ) ; }
|
7,910 |
CWE-000 static void nrt_init ( volatile void * ctx_ptr , volatile hal_pin_inst_t * pin_ptr ) { struct adc_ctx_t * ctx = ( struct adc_ctx_t * ) ctx_ptr ; struct adc_pin_ctx_t * pins = ( struct adc_pin_ctx_t * ) pin_ptr ; PINA ( gain , 0 ) = 200 ; PINA ( gain , 1 ) = 200 ; <S2SV_StartBug> PIN ( sin_gain ) = 1.0 ; <S2SV_EndBug> PIN ( cos_gain ) = 1.0 ; ctx -> txpos = 0 ; ctx -> send_counter = 0 ; <S2SV_StartBug> ctx -> send = 1 ; <S2SV_EndBug> }
|
<S2SV_ModStart> = 200 ; PINA ( gain , 2 ) = 200 ; PINA ( gain , 3 ) = 200 ; <S2SV_ModStart> -> send = 0 <S2SV_ModEnd> ; } <S2SV_null>
|
7,911 |
CWE-000 output_file_t * init_output_file ( char * basename , char * suffix , mw_version_t * mwv ) { <S2SV_StartBug> output_file_t * outf , * current , * head = NULL ; <S2SV_EndBug> mw_version_t * next = NULL ; int do_once = 1 ; char * version = NULL ; while ( mwv || do_once ) { do_once = 0 ; if ( mwv ) next = mwv -> next ; outf = ( output_file_t * ) malloc ( sizeof ( output_file_t ) ) ; if ( ! outf ) { fprintf ( stderr , "failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>output<S2SV_blank>file<S2SV_blank>information\\n" ) ; return ( NULL ) ; } if ( ! head ) head = outf ; else current -> next = outf ; outf -> fd = NULL ; outf -> gzfd = NULL ; outf -> bz2fd = NULL ; outf -> filename = NULL ; outf -> mwv = mwv ; outf -> next = NULL ; mwv = next ; if ( basename == NULL ) { outf -> filetype = PLAINTEXT ; outf -> fd = stdout ; continue ; } if ( outf -> mwv ) version = outf -> mwv -> version ; else version = NULL ; <S2SV_StartBug> outf -> filename = ( char * ) malloc ( strlen ( basename ) + ( suffix ? strlen ( suffix ) : 0 ) + strlen ( version ) + 2 ) ; <S2SV_EndBug> if ( ! outf -> filename ) { fprintf ( stderr , "failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>output<S2SV_blank>file<S2SV_blank>information\\n" ) ; free_output_file ( head ) ; return ( NULL ) ; } sprintf ( outf -> filename , "%s%s%s%s" , basename , version ? "-" : "" , version ? version : "" , suffix ? suffix : "" ) ; if ( ! suffix ) { outf -> filetype = PLAINTEXT ; outf -> fd = fopen ( outf -> filename , "w" ) ; if ( ! outf -> fd ) { fprintf ( stderr , "failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>file<S2SV_blank>for<S2SV_blank>write" ) ; free_output_file ( head ) ; return ( NULL ) ; } } else if ( ! strcmp ( suffix , BZSUFFIX ) ) { outf -> filetype = BZCOMPRESSED ; outf -> bz2fd = BZ2_bzopen ( outf -> filename , "w" ) ; if ( ! outf -> bz2fd ) { fprintf ( stderr , "failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>bz2<S2SV_blank>file<S2SV_blank>for<S2SV_blank>write" ) ; free_output_file ( head ) ; return ( NULL ) ; } } else if ( ! strcmp ( suffix , GZSUFFIX ) ) { outf -> filetype = GZCOMPRESSED ; outf -> gzfd = gzopen ( outf -> filename , "w" ) ; if ( ! outf -> gzfd ) { fprintf ( stderr , "failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>gz<S2SV_blank>file<S2SV_blank>for<S2SV_blank>write" ) ; free_output_file ( head ) ; return ( NULL ) ; } } else { outf -> filetype = PLAINTEXT ; outf -> fd = fopen ( outf -> filename , "w" ) ; if ( ! outf -> fd ) { fprintf ( stderr , "failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>file<S2SV_blank>for<S2SV_blank>write" ) ; free_output_file ( head ) ; return ( NULL ) ; } } mwv = next ; current = outf ; } return ( head ) ; }
|
<S2SV_ModStart> , * current = NULL <S2SV_ModStart> 0 ) + ( version ? <S2SV_ModStart> strlen ( version ) : 0
|
7,912 |
CWE-000 static void ata_channel_thaw_locked ( struct ata_channel * chp ) { KASSERT ( mutex_owned ( & chp -> ch_lock ) ) ; <S2SV_StartBug> chp -> ch_queue -> queue_freeze -- ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> ) ) ; KASSERT ( chp -> ch_queue -> queue_freeze > 0 ) ; <S2SV_ModStart> queue_freeze -- ; ATADEBUG_PRINT ( ( "%s(chp=%p)<S2SV_blank>-><S2SV_blank>%d\\n" , __func__ , chp , chp -> ch_queue -> queue_freeze ) , DEBUG_FUNCS | DEBUG_XFERS ) ;
|
7,913 |
CWE-000 int unit_load ( Unit * u ) { int r ; assert ( u ) ; if ( u -> in_load_queue ) { LIST_REMOVE ( load_queue , u -> manager -> load_queue , u ) ; u -> in_load_queue = false ; } if ( u -> type == _UNIT_TYPE_INVALID ) return - EINVAL ; if ( u -> load_state != UNIT_STUB ) return 0 ; if ( UNIT_VTABLE ( u ) -> load ) { r = UNIT_VTABLE ( u ) -> load ( u ) ; if ( r < 0 ) goto fail ; } if ( u -> load_state == UNIT_STUB ) { r = - ENOENT ; goto fail ; } if ( u -> load_state == UNIT_LOADED ) { <S2SV_StartBug> r = unit_add_target_dependencies ( u ) ; <S2SV_EndBug> if ( r < 0 ) goto fail ; r = unit_add_slice_dependencies ( u ) ; if ( r < 0 ) goto fail ; r = unit_add_mount_dependencies ( u ) ; if ( r < 0 ) goto fail ; r = unit_add_startup_units ( u ) ; if ( r < 0 ) goto fail ; if ( u -> on_failure_job_mode == JOB_ISOLATE && set_size ( u -> dependencies [ UNIT_ON_FAILURE ] ) > 1 ) { log_unit_error ( u -> id , "More<S2SV_blank>than<S2SV_blank>one<S2SV_blank>OnFailure=<S2SV_blank>dependencies<S2SV_blank>specified<S2SV_blank>for<S2SV_blank>%s<S2SV_blank>but<S2SV_blank>OnFailureJobMode=isolate<S2SV_blank>set.<S2SV_blank>Refusing." , u -> id ) ; r = - EINVAL ; goto fail ; } unit_update_cgroup_members_masks ( u ) ; } assert ( ( u -> load_state != UNIT_MERGED ) == ! u -> merged_into ) ; unit_add_to_dbus_queue ( unit_follow_merge ( u ) ) ; unit_add_to_gc_queue ( u ) ; return 0 ; fail : u -> load_state = u -> load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR ; u -> load_error = r ; unit_add_to_dbus_queue ( u ) ; unit_add_to_gc_queue ( u ) ; log_unit_debug ( u -> id , "Failed<S2SV_blank>to<S2SV_blank>load<S2SV_blank>configuration<S2SV_blank>for<S2SV_blank>%s:<S2SV_blank>%s" , u -> id , strerror ( - r ) ) ; return r ; }
|
<S2SV_ModStart> UNIT_LOADED ) { unit_add_to_target_deps_queue ( u ) <S2SV_ModEnd> ; r =
|
7,914 |
CWE-000 static void epdc_powerup ( struct mxc_epdc_fb_data * fb_data ) { int ret = 0 ; mutex_lock ( & fb_data -> power_mutex ) ; if ( fb_data -> powering_down ) fb_data -> powering_down = false ; if ( fb_data -> power_state == POWER_STATE_ON ) { mutex_unlock ( & fb_data -> power_mutex ) ; return ; } dev_dbg ( fb_data -> dev , "EPDC<S2SV_blank>Powerup\\n" ) ; fb_data -> updates_active = true ; ret = regulator_enable ( fb_data -> v3p3_regulator ) ; if ( IS_ERR ( ( void * ) ret ) ) { dev_err ( fb_data -> dev , "Unable<S2SV_blank>to<S2SV_blank>enable<S2SV_blank>V3P3<S2SV_blank>regulator." "err<S2SV_blank>=<S2SV_blank>0x%x\\n" , ret ) ; mutex_unlock ( & fb_data -> power_mutex ) ; return ; } msleep ( 1 ) ; pm_runtime_get_sync ( fb_data -> dev ) ; clk_prepare_enable ( fb_data -> epdc_clk_axi ) ; clk_prepare_enable ( fb_data -> epdc_clk_pix ) ; __raw_writel ( EPDC_CTRL_CLKGATE , EPDC_CTRL_CLEAR ) ; ret = regulator_enable ( fb_data -> display_regulator ) ; if ( IS_ERR ( ( void * ) ret ) ) { dev_err ( fb_data -> dev , "Unable<S2SV_blank>to<S2SV_blank>enable<S2SV_blank>DISPLAY<S2SV_blank>regulator." <S2SV_StartBug> "err<S2SV_blank>=<S2SV_blank>0x%x\\n" , ret ) ; <S2SV_EndBug> mutex_unlock ( & fb_data -> power_mutex ) ; return ; } <S2SV_StartBug> ret = regulator_enable ( fb_data -> vcom_regulator ) ; <S2SV_EndBug> if ( IS_ERR ( ( void * ) ret ) ) { dev_err ( fb_data -> dev , "Unable<S2SV_blank>to<S2SV_blank>enable<S2SV_blank>VCOM<S2SV_blank>regulator." "err<S2SV_blank>=<S2SV_blank>0x%x\\n" , ret ) ; mutex_unlock ( & fb_data -> power_mutex ) ; return ; } fb_data -> power_state = POWER_STATE_ON ; mutex_unlock ( & fb_data -> power_mutex ) ; }
|
<S2SV_ModStart> dev , "Unable<S2SV_blank>to<S2SV_blank>enable<S2SV_blank>DISPLAY<S2SV_blank>regulator." "err<S2SV_blank>=<S2SV_blank>%d\\n" , PTR_ERR ( ret ) ) ; mutex_unlock ( & fb_data -> power_mutex ) ; return ; } ret = regulator_enable ( fb_data -> vcom_regulator ) ; if ( IS_ERR ( ( void * ) ret ) ) { dev_err ( fb_data -> dev , "Unable<S2SV_blank>to<S2SV_blank>enable<S2SV_blank>VCOM<S2SV_blank>regulator." <S2SV_ModStart> return ; } <S2SV_ModEnd> fb_data -> power_state
|
7,915 |
CWE-000 int doprocessing ( int rqst ) { int n ; char buf [ BUFSIZE ] ; bzero ( buf , BUFSIZE ) ; n = read ( rqst , buf , BUFSIZE ) ; if ( n < 0 ) <S2SV_StartBug> error ( "ERROR<S2SV_blank>reading<S2SV_blank>from<S2SV_blank>socket" ) ; <S2SV_EndBug> printf ( "server<S2SV_blank>received<S2SV_blank>%d<S2SV_blank>bytes:<S2SV_blank>%s" , n , buf ) ; n = write ( rqst , buf , strlen ( buf ) ) ; if ( n < 0 ) <S2SV_StartBug> error ( "ERROR<S2SV_blank>writing<S2SV_blank>to<S2SV_blank>socket" ) ; <S2SV_EndBug> return 1 ; }
|
<S2SV_ModStart> < 0 ) perror <S2SV_ModEnd> ( "ERROR<S2SV_blank>reading<S2SV_blank>from<S2SV_blank>socket" ) <S2SV_ModStart> < 0 ) perror <S2SV_ModEnd> ( "ERROR<S2SV_blank>writing<S2SV_blank>to<S2SV_blank>socket" )
|
7,916 |
CWE-000 extern void * realloc ( void * ptr , size_t size ) { void * newptr ; size_t oldsize ; <S2SV_StartBug> if ( ptr >= ( void * ) init_heap && <S2SV_EndBug> <S2SV_StartBug> ptr <= ( void * ) init_heap + init_heap_use ) <S2SV_EndBug> { if ( log_operations_init_heap ) { fprintf ( stderr , "malloc_count<S2SV_blank>###<S2SV_blank>realloc(%p)<S2SV_blank>=<S2SV_blank>on<S2SV_blank>init<S2SV_blank>heap\\n" , ptr ) ; } <S2SV_StartBug> ptr -= 2 * sizeof ( size_t ) ; <S2SV_EndBug> if ( ( ( size_t * ) ptr ) [ 1 ] != sentinel ) { fprintf ( stderr , "malloc_count<S2SV_blank>###<S2SV_blank>realloc(%p)<S2SV_blank>has<S2SV_blank>no<S2SV_blank>sentinel<S2SV_blank>!!!<S2SV_blank>memory<S2SV_blank>corruption?\\n" , ptr ) ; } oldsize = ( ( size_t * ) ptr ) [ 0 ] ; if ( oldsize >= size ) { ( ( size_t * ) ptr ) [ 0 ] = size ; <S2SV_StartBug> return ptr + 2 * sizeof ( size_t ) ; <S2SV_EndBug> } else { <S2SV_StartBug> ptr += 2 * sizeof ( size_t ) ; <S2SV_EndBug> newptr = malloc ( size ) ; memcpy ( newptr , ptr , oldsize ) ; free ( ptr ) ; return newptr ; } } if ( size == 0 ) { free ( ptr ) ; return NULL ; } if ( ptr == NULL ) { return malloc ( size ) ; } <S2SV_StartBug> ptr -= 2 * sizeof ( size_t ) ; <S2SV_EndBug> if ( ( ( size_t * ) ptr ) [ 1 ] != sentinel ) { fprintf ( stderr , "malloc_count<S2SV_blank>###<S2SV_blank>free(%p)<S2SV_blank>has<S2SV_blank>no<S2SV_blank>sentinel<S2SV_blank>!!!<S2SV_blank>memory<S2SV_blank>corruption?\\n" , ptr ) ; } oldsize = ( ( size_t * ) ptr ) [ 0 ] ; dec_count ( oldsize ) ; inc_count ( size ) ; newptr = ( * real_realloc ) ( ptr , 2 * sizeof ( size_t ) + size ) ; if ( log_operations && size >= log_operations_threshold ) { if ( newptr == ptr ) fprintf ( stderr , "malloc_count<S2SV_blank>###<S2SV_blank>realloc(%\'lld<S2SV_blank>-><S2SV_blank>%\'lld)<S2SV_blank>=<S2SV_blank>%p<S2SV_blank><S2SV_blank><S2SV_blank>(current<S2SV_blank>%\'lld)\\n" , ( long long ) oldsize , ( long long ) size , newptr , curr ) ; else fprintf ( stderr , "malloc_count<S2SV_blank>###<S2SV_blank>realloc(%\'lld<S2SV_blank>-><S2SV_blank>%\'lld)<S2SV_blank>=<S2SV_blank>%p<S2SV_blank>-><S2SV_blank>%p<S2SV_blank><S2SV_blank><S2SV_blank>(current<S2SV_blank>%\'lld)\\n" , ( long long ) oldsize , ( long long ) size , ptr , newptr , curr ) ; } ( ( size_t * ) newptr ) [ 0 ] = size ; <S2SV_StartBug> return newptr + 2 * sizeof ( size_t ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> ; if ( ( char * ) <S2SV_ModStart> ptr >= ( char <S2SV_ModEnd> * ) init_heap <S2SV_ModStart> ) init_heap && ( char * ) <S2SV_ModStart> ptr <= ( char <S2SV_ModEnd> * ) init_heap <S2SV_ModStart> ; } ptr = ( char * ) ptr - <S2SV_ModEnd> 2 * sizeof <S2SV_ModStart> size ; return ( char * ) <S2SV_ModStart> else { ptr = ( char * ) ptr + <S2SV_ModEnd> 2 * sizeof <S2SV_ModStart> ; } ptr = ( char * ) ptr - <S2SV_ModEnd> 2 * sizeof <S2SV_ModStart> size ; return ( char * )
|
7,917 |
CWE-000 <S2SV_StartBug> static int Decode_JPEG ( unsigned char * inBuffer , unsigned char * outBuffer , unsigned int width , unsigned int height , int bufsize ) <S2SV_EndBug> { <S2SV_StartBug> int rowstride ; <S2SV_EndBug> unsigned int y ; struct jpeg_decompress_struct dinfo ; struct jpeg_error_mgr jerr ; ( void ) width ; numbytes = 0 ; dinfo . err = jpeg_std_error ( & jerr ) ; jpeg_create_decompress ( & dinfo ) ; jpegmemsrcmgr_build ( & dinfo , inBuffer , bufsize ) ; jpeg_read_header ( & dinfo , true ) ; if ( dinfo . dc_huff_tbl_ptrs [ 0 ] == NULL ) { std_huff_tables ( & dinfo ) ; } dinfo . out_color_space = JCS_RGB ; dinfo . dct_method = JDCT_IFAST ; jpeg_start_decompress ( & dinfo ) ; <S2SV_StartBug> rowstride = dinfo . output_width * dinfo . output_components ; <S2SV_EndBug> <S2SV_StartBug> for ( y = 0 ; y < dinfo . output_height ; y ++ ) { <S2SV_EndBug> jpeg_read_scanlines ( & dinfo , ( JSAMPARRAY ) & outBuffer , 1 ) ; outBuffer += rowstride ; } jpeg_finish_decompress ( & dinfo ) ; if ( dinfo . output_height >= height ) return 0 ; inBuffer += numbytes ; jpegmemsrcmgr_build ( & dinfo , inBuffer , bufsize - numbytes ) ; numbytes = 0 ; jpeg_read_header ( & dinfo , true ) ; if ( dinfo . dc_huff_tbl_ptrs [ 0 ] == NULL ) { std_huff_tables ( & dinfo ) ; } jpeg_start_decompress ( & dinfo ) ; rowstride = dinfo . output_width * dinfo . output_components ; <S2SV_StartBug> for ( y = 0 ; y < dinfo . output_height ; y ++ ) { <S2SV_EndBug> jpeg_read_scanlines ( & dinfo , ( JSAMPARRAY ) & outBuffer , 1 ) ; outBuffer += rowstride ; } jpeg_finish_decompress ( & dinfo ) ; jpeg_destroy_decompress ( & dinfo ) ; return 1 ; }
|
<S2SV_ModStart> int height , size_t <S2SV_ModEnd> bufsize ) { <S2SV_ModStart> bufsize ) { <S2SV_ModEnd> struct jpeg_decompress_struct dinfo <S2SV_ModStart> dinfo ) ; size_t <S2SV_ModStart> ; for ( size_t <S2SV_ModStart> ; for ( size_t
|
7,918 |
CWE-000 cJSON * stringToJson ( const char * json ) { if ( NULL == json ) { oidc_setArgNullFuncError ( __func__ ) ; return NULL ; } <S2SV_StartBug> syslog ( LOG_AUTHPRIV | LOG_DEBUG , "Parsing<S2SV_blank>json<S2SV_blank>\'%s\'" , json ) ; <S2SV_EndBug> <S2SV_StartBug> cJSON * cj = cJSON_Parse ( json ) ; <S2SV_EndBug> if ( cj == NULL ) { oidc_errno = OIDC_EJSONPARS ; <S2SV_StartBug> } <S2SV_EndBug> return cj ; }
|
<S2SV_ModStart> NULL ; } initCJSON ( ) ; <S2SV_ModStart> json ) ; char * minJson = oidc_strcopy ( json ) ; cJSON_Minify ( minJson ) ; syslog ( LOG_AUTHPRIV | LOG_DEBUG , "Parsing<S2SV_blank>json<S2SV_blank>\'%s\'" , minJson ) ; <S2SV_ModStart> = cJSON_Parse ( minJson ) ; secFree ( minJson <S2SV_ModEnd> ) ; if <S2SV_ModStart> = OIDC_EJSONPARS ; syslog ( LOG_AUTHPRIV | LOG_ERR , "Parsing<S2SV_blank>failed<S2SV_blank>somewhere<S2SV_blank>around<S2SV_blank>%s" , cJSON_GetErrorPtr ( ) ) ;
|
7,919 |
CWE-000 static bool success ( json_object * r , bool fallback ) { if ( ! json_object_is_type ( r , json_type_array ) ) { return fallback ; } size_t results_len = json_object_array_length ( r ) ; if ( ! results_len ) { return fallback ; } for ( size_t i = 0 ; i < results_len ; ++ i ) { json_object * result = json_object_array_get_idx ( r , i ) ; <S2SV_StartBug> json_object * success ; <S2SV_EndBug> <S2SV_StartBug> if ( ! json_object_object_get_ex ( result , "success" , & success ) ) { <S2SV_EndBug> return false ; } if ( ! json_object_get_boolean ( success ) ) { return false ; } } return true ; }
|
<S2SV_ModStart> i ) ; <S2SV_ModEnd> if ( ! <S2SV_ModStart> if ( ! success_object ( result <S2SV_ModEnd> ) ) {
|
7,920 |
CWE-000 static void getaddrinfo_race_gotresolve_test ( void * arg ) { struct race_param rp ; struct evdns_server_port * dns_port = NULL ; ev_uint16_t portnum = 0 ; char buf [ 64 ] ; int i ; int n_reqs = 16384 ; # ifdef _SC_NPROCESSORS_ONLN int n_threads = sysconf ( _SC_NPROCESSORS_ONLN ) + 1 ; # else int n_threads = 17 ; # endif THREAD_T thread [ n_threads ] ; struct timeval tv ; ( void ) arg ; evthread_use_pthreads ( ) ; rp . base = event_base_new ( ) ; tt_assert ( rp . base ) ; if ( evthread_make_base_notifiable ( rp . base ) < 0 ) tt_abort_msg ( "Couldn\'t<S2SV_blank>make<S2SV_blank>base<S2SV_blank>notifiable!" ) ; dns_port = regress_get_dnsserver ( rp . base , & portnum , NULL , regress_dns_server_cb , reissue_table ) ; tt_assert ( dns_port ) ; evutil_snprintf ( buf , sizeof ( buf ) , "127.0.0.1:%d" , ( int ) portnum ) ; rp . dns = evdns_base_new ( rp . base , 0 ) ; tt_assert ( ! evdns_base_nameserver_ip_add ( rp . dns , buf ) ) ; n_replies_left = n_reqs ; EVTHREAD_ALLOC_LOCK ( rp . lock , 0 ) ; EVTHREAD_ALLOC_COND ( rp . reqs_cmpl_cond ) ; EVTHREAD_ALLOC_COND ( rp . bw_threads_exited_cond ) ; tt_assert ( rp . lock ) ; tt_assert ( rp . reqs_cmpl_cond ) ; tt_assert ( rp . bw_threads_exited_cond ) ; rp . bw_threads = 0 ; rp . stopping = 0 ; THREAD_START ( thread [ 0 ] , race_base_run , & rp ) ; for ( i = 1 ; i < n_threads ; i ++ ) { rp . bw_threads ++ ; THREAD_START ( thread [ i ] , race_busywait_run , & rp ) ; } EVLOCK_LOCK ( rp . lock , 0 ) ; <S2SV_StartBug> for ( i = 0 ; i < n_reqs ; ++ i ) { <S2SV_EndBug> tt_assert ( evdns_getaddrinfo ( rp . dns , "foof.example.com" , "ssh" , NULL , race_gai_cb , & rp ) ) ; if ( i % 100 == 0 ) { tv . tv_sec = 0 ; tv . tv_usec = 10000 ; evutil_usleep_ ( & tv ) ; } } exit_base = rp . base ; tv . tv_sec = 5 ; tv . tv_usec = 0 ; EVTHREAD_COND_WAIT_TIMED ( rp . reqs_cmpl_cond , rp . lock , & tv ) ; tv . tv_sec = 1 ; tv . tv_usec = 0 ; rp . stopping = 1 ; tt_assert ( EVTHREAD_COND_WAIT_TIMED ( rp . bw_threads_exited_cond , rp . lock , & tv ) == 0 ) ; EVLOCK_UNLOCK ( rp . lock , 0 ) ; <S2SV_StartBug> evdns_base_free ( rp . dns , 1 ) ; <S2SV_EndBug> tt_int_op ( n_replies_left , == , 0 ) ; end : <S2SV_StartBug> EVTHREAD_FREE_LOCK ( rp . lock , 0 ) ; <S2SV_EndBug> EVTHREAD_FREE_COND ( rp . reqs_cmpl_cond ) ; EVTHREAD_FREE_COND ( rp . bw_threads_exited_cond ) ; evdns_close_server_port ( dns_port ) ; event_base_loopbreak ( rp . base ) ; event_base_free ( rp . base ) ; }
|
<S2SV_ModStart> 0 ) ; rp . locked = 1 ; <S2SV_ModStart> 0 ) ; rp . locked = 0 ; <S2SV_ModStart> ; end : if ( rp . locked ) EVLOCK_UNLOCK ( rp . lock , 0 ) ;
|
7,921 |
CWE-000 int ping_recvmsg ( struct kiocb * iocb , struct sock * sk , struct msghdr * msg , size_t len , int noblock , int flags , int * addr_len ) { struct inet_sock * isk = inet_sk ( sk ) ; int family = sk -> sk_family ; struct sockaddr_in * sin ; struct sockaddr_in6 * sin6 ; struct sk_buff * skb ; int copied , err ; pr_debug ( "ping_recvmsg(sk=%p,sk->num=%u)\\n" , isk , isk -> inet_num ) ; err = - EOPNOTSUPP ; if ( flags & MSG_OOB ) goto out ; if ( addr_len ) { if ( family == AF_INET ) * addr_len = sizeof ( * sin ) ; else if ( family == AF_INET6 && addr_len ) * addr_len = sizeof ( * sin6 ) ; } if ( flags & MSG_ERRQUEUE ) { if ( family == AF_INET ) { return ip_recv_error ( sk , msg , len , addr_len ) ; # if IS_ENABLED ( CONFIG_IPV6 ) } else if ( family == AF_INET6 ) { <S2SV_StartBug> return pingv6_ops . ipv6_recv_error ( sk , msg , len , addr_len ) ; <S2SV_EndBug> # endif } } skb = skb_recv_datagram ( sk , flags , noblock , & err ) ; if ( ! skb ) goto out ; copied = skb -> len ; if ( copied > len ) { msg -> msg_flags |= MSG_TRUNC ; copied = len ; } err = skb_copy_datagram_iovec ( skb , 0 , msg -> msg_iov , copied ) ; if ( err ) goto done ; sock_recv_timestamp ( msg , sk , skb ) ; <S2SV_StartBug> << << << < HEAD <S2SV_EndBug> if ( family == AF_INET ) { sin = ( struct sockaddr_in * ) msg -> msg_name ; <S2SV_StartBug> if ( sin ) { <S2SV_EndBug> sin -> sin_family = AF_INET ; sin -> sin_port = 0 ; sin -> sin_addr . s_addr = ip_hdr ( skb ) -> saddr ; memset ( sin -> sin_zero , 0 , sizeof ( sin -> sin_zero ) ) ; <S2SV_StartBug> } <S2SV_EndBug> if ( isk -> cmsg_flags ) ip_cmsg_recv ( msg , skb ) ; # if IS_ENABLED ( CONFIG_IPV6 ) } else if ( family == AF_INET6 ) { struct ipv6_pinfo * np = inet6_sk ( sk ) ; struct ipv6hdr * ip6 = ipv6_hdr ( skb ) ; sin6 = ( struct sockaddr_in6 * ) msg -> msg_name ; if ( sin6 ) { sin6 -> sin6_family = AF_INET6 ; sin6 -> sin6_port = 0 ; sin6 -> sin6_addr = ip6 -> saddr ; sin6 -> sin6_flowinfo = 0 ; if ( np -> sndflow ) sin6 -> sin6_flowinfo = * ( __be32 * ) ip6 & IPV6_FLOWINFO_MASK ; sin6 -> sin6_scope_id = ipv6_iface_scope_id ( & sin6 -> sin6_addr , IP6CB ( skb ) -> iif ) ; } if ( inet6_sk ( sk ) -> rxopt . all ) pingv6_ops . datagram_recv_ctl ( sk , msg , skb ) ; # endif } else { BUG ( ) ; <S2SV_StartBug> == == == = <S2SV_EndBug> if ( msg -> msg_name ) { struct sockaddr_in * sin = ( struct sockaddr_in * ) msg -> msg_name ; sin -> sin_family = AF_INET ; sin -> sin_port = 0 ; sin -> sin_addr . s_addr = ip_hdr ( skb ) -> saddr ; memset ( sin -> sin_zero , 0 , sizeof ( sin -> sin_zero ) ) ; * addr_len = sizeof ( * sin ) ; >> >> >> > 5533699708b66a5dfe85d8298d971bb41a799c8a } err = copied ; done : skb_free_datagram ( sk , skb ) ; out : pr_debug ( "ping_recvmsg<S2SV_blank>-><S2SV_blank>%d\\n" , err ) ; return err ; }
|
<S2SV_ModStart> msg , len <S2SV_ModEnd> ) ; # <S2SV_ModStart> skb ) ; <S2SV_ModEnd> if ( family <S2SV_ModStart> ; if ( msg -> msg_name <S2SV_ModEnd> ) { sin <S2SV_ModStart> ) ) ; * addr_len = sizeof ( * sin ) ; <S2SV_ModStart> ( ) ; <S2SV_ModEnd> } err =
|
7,922 |
CWE-000 static dbus_bool_t bus_driver_handle_get_connection_selinux_security_context ( DBusConnection * connection , BusTransaction * transaction , DBusMessage * message , DBusError * error ) { DBusConnection * conn ; DBusMessage * reply ; BusSELinuxID * context ; const char * service ; BusDriverFound found ; _DBUS_ASSERT_ERROR_IS_CLEAR ( error ) ; reply = NULL ; found = bus_driver_get_conn_helper ( connection , message , "security<S2SV_blank>context" , & service , & conn , error ) ; if ( found == BUS_DRIVER_FOUND_ERROR ) goto failed ; reply = dbus_message_new_method_return ( message ) ; if ( reply == NULL ) goto oom ; <S2SV_StartBug> if ( found == BUS_DRIVER_FOUND_PEER ) <S2SV_EndBug> context = bus_connection_get_selinux_id ( conn ) ; else context = NULL ; if ( ! context ) { dbus_set_error ( error , DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN , "Could<S2SV_blank>not<S2SV_blank>determine<S2SV_blank>security<S2SV_blank>context<S2SV_blank>for<S2SV_blank>\'%s\'" , service ) ; goto failed ; } if ( ! bus_selinux_append_context ( reply , context , error ) ) goto failed ; if ( ! bus_transaction_send_from_driver ( transaction , connection , reply ) ) goto oom ; dbus_message_unref ( reply ) ; return TRUE ; oom : BUS_SET_OOM ( error ) ; failed : _DBUS_ASSERT_ERROR_IS_SET ( error ) ; if ( reply ) dbus_message_unref ( reply ) ; return FALSE ; }
|
<S2SV_ModStart> ( found == BUS_DRIVER_FOUND_SELF ) context = bus_selinux_get_self ( ) ; else if ( found ==
|
7,923 |
CWE-000 static void gen_vertex_arrays ( size_t count , const GLuint * real , const GLuint * fake , bool create ) { trc_gl_vao_rev_t rev ; rev . has_object = create ; rev . element_buffer . obj = NULL ; int attrib_count = gls_get_state_int ( GL_MAX_VERTEX_ATTRIBS , 0 ) ; rev . attribs = trc_create_data ( ctx -> trace , attrib_count * sizeof ( trc_gl_vao_attrib_t ) , NULL , TRC_DATA_NO_ZERO ) ; trc_gl_vao_attrib_t * attribs = trc_map_data ( rev . attribs , TRC_MAP_REPLACE ) ; memset ( attribs , 0 , attrib_count * sizeof ( trc_gl_vao_attrib_t ) ) ; for ( size_t i = 0 ; i < attrib_count ; i ++ ) { attribs [ i ] . enabled = false ; attribs [ i ] . normalized = false ; attribs [ i ] . integer = false ; attribs [ i ] . size = 4 ; attribs [ i ] . offset = 0 ; attribs [ i ] . type = GL_FLOAT ; attribs [ i ] . buffer_index = 0 ; } trc_unmap_data ( attribs ) ; int binding_count = gls_get_state_int ( GL_MAX_VERTEX_ATTRIB_BINDINGS , 0 ) ; <S2SV_StartBug> rev . buffers = trc_create_data ( ctx -> trace , binding_count * sizeof ( trc_gl_vao_buffer_t ) , NULL , TRC_DATA_NO_ZERO ) ; <S2SV_EndBug> trc_gl_vao_buffer_t * buffers = trc_map_data ( rev . buffers , TRC_MAP_REPLACE ) ; memset ( buffers , 0 , binding_count * sizeof ( trc_gl_vao_buffer_t ) ) ; for ( size_t i = 0 ; i < binding_count ; i ++ ) { buffers [ i ] . offset = 0 ; buffers [ i ] . stride = 0 ; buffers [ i ] . divisor = 0 ; buffers [ i ] . buffer = ( trc_obj_ref_t ) { NULL } ; } trc_unmap_data ( buffers ) ; for ( size_t i = 0 ; i < count ; ++ i ) { rev . real = real [ i ] ; trc_create_named_obj ( ctx -> priv_ns , TrcVAO , fake [ i ] , & rev ) ; } }
|
<S2SV_ModStart> 0 ) ; if ( gls_get_ver ( ) < 430 ) binding_count = attrib_count ;
|
7,924 |
CWE-000 char * str_dup_n ( const char * source , size_t len ) { <S2SV_StartBug> char * cpy = malloc ( len + 1 ) ; <S2SV_EndBug> strncpy ( cpy , source , len ) ; cpy [ len ] = '\\0' ; return cpy ; }
|
<S2SV_ModStart> * cpy = calloc ( 1 , <S2SV_ModEnd> len + 1
|
7,925 |
CWE-000 static int idletimer_tg_create ( struct idletimer_tg_info * info ) { int ret ; info -> timer = kmalloc ( sizeof ( * info -> timer ) , GFP_KERNEL ) ; if ( ! info -> timer ) { pr_debug ( "couldn\'t<S2SV_blank>alloc<S2SV_blank>timer\\n" ) ; ret = - ENOMEM ; goto out ; } info -> timer -> attr . attr . name = kstrdup ( info -> label , GFP_KERNEL ) ; if ( ! info -> timer -> attr . attr . name ) { pr_debug ( "couldn\'t<S2SV_blank>alloc<S2SV_blank>attribute<S2SV_blank>name\\n" ) ; ret = - ENOMEM ; goto out_free_timer ; } info -> timer -> attr . attr . mode = S_IRUGO ; info -> timer -> attr . show = idletimer_tg_show ; ret = sysfs_create_file ( idletimer_tg_kobj , & info -> timer -> attr . attr ) ; if ( ret < 0 ) { pr_debug ( "couldn\'t<S2SV_blank>add<S2SV_blank>file<S2SV_blank>to<S2SV_blank>sysfs" ) ; goto out_free_attr ; } list_add ( & info -> timer -> entry , & idletimer_tg_list ) ; setup_timer ( & info -> timer -> timer , idletimer_tg_expired , ( unsigned long ) info -> timer ) ; info -> timer -> refcnt = 1 ; info -> timer -> send_nl_msg = ( info -> send_nl_msg == 0 ) ? false : true ; info -> timer -> active = true ; info -> timer -> timeout = info -> timeout ; info -> timer -> delayed_timer_trigger . tv_sec = 0 ; info -> timer -> delayed_timer_trigger . tv_nsec = 0 ; info -> timer -> work_pending = false ; <S2SV_StartBug> get_monotonic_boottime ( & info -> timer -> last_modified_timer ) ; <S2SV_EndBug> info -> timer -> pm_nb . notifier_call = idletimer_resume ; ret = register_pm_notifier ( & info -> timer -> pm_nb ) ; if ( ret ) printk ( KERN_WARNING "[%s]<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>register<S2SV_blank>pm<S2SV_blank>notifier<S2SV_blank>%d\\n" , __func__ , ret ) ; mod_timer ( & info -> timer -> timer , msecs_to_jiffies ( info -> timeout * 1000 ) + jiffies ) ; INIT_WORK ( & info -> timer -> work , idletimer_tg_work ) ; return 0 ; out_free_attr : kfree ( info -> timer -> attr . attr . name ) ; out_free_timer : kfree ( info -> timer ) ; out : return ret ; }
|
<S2SV_ModStart> = false ; info -> timer -> uid = 0 ;
|
7,926 |
CWE-000 static int f2fs_write_data_page ( struct page * page , struct writeback_control * wbc ) { struct inode * inode = page -> mapping -> host ; struct f2fs_sb_info * sbi = F2FS_SB ( inode -> i_sb ) ; loff_t i_size = i_size_read ( inode ) ; const pgoff_t end_index = ( ( unsigned long long ) i_size ) >> PAGE_CACHE_SHIFT ; unsigned offset = 0 ; bool need_balance_fs = false ; int err = 0 ; struct f2fs_io_info fio = { . type = DATA , . rw = ( wbc -> sync_mode == WB_SYNC_ALL ) ? WRITE_SYNC : WRITE , } ; if ( page -> index < end_index ) goto write ; offset = i_size & ( PAGE_CACHE_SIZE - 1 ) ; if ( ( page -> index >= end_index + 1 ) || ! offset ) { if ( S_ISDIR ( inode -> i_mode ) ) { dec_page_count ( sbi , F2FS_DIRTY_DENTS ) ; inode_dec_dirty_dents ( inode ) ; } goto out ; } zero_user_segment ( page , offset , PAGE_CACHE_SIZE ) ; write : if ( unlikely ( sbi -> por_doing ) ) { err = AOP_WRITEPAGE_ACTIVATE ; goto redirty_out ; } if ( S_ISDIR ( inode -> i_mode ) ) { dec_page_count ( sbi , F2FS_DIRTY_DENTS ) ; inode_dec_dirty_dents ( inode ) ; err = do_write_data_page ( page , & fio ) ; } else { f2fs_lock_op ( sbi ) ; if ( f2fs_has_inline_data ( inode ) || f2fs_may_inline ( inode ) ) { err = f2fs_write_inline_data ( inode , page , offset ) ; f2fs_unlock_op ( sbi ) ; goto out ; } else { err = do_write_data_page ( page , & fio ) ; } f2fs_unlock_op ( sbi ) ; need_balance_fs = true ; } if ( err == - ENOENT ) goto out ; else if ( err ) goto redirty_out ; <S2SV_StartBug> if ( wbc -> for_reclaim ) <S2SV_EndBug> <S2SV_StartBug> f2fs_submit_merged_bio ( sbi , DATA , WRITE ) ; <S2SV_EndBug> clear_cold_data ( page ) ; out : unlock_page ( page ) ; if ( need_balance_fs ) f2fs_balance_fs ( sbi ) ; return 0 ; redirty_out : wbc -> pages_skipped ++ ; set_page_dirty ( page ) ; return err ; }
|
<S2SV_ModStart> -> for_reclaim ) { <S2SV_ModStart> WRITE ) ; need_balance_fs = false ; }
|
7,927 |
CWE-000 int DLLEXPORT swmm_start_project ( SWMM_Project * sp , int saveResults ) { if ( ErrorCode ) return error_getCode ( ErrorCode ) ; if ( ! IsOpenFlag || IsStartedFlag ) { report_writeErrorMsg ( sp , ERR_NOT_OPEN , "" ) ; return error_getCode ( ErrorCode ) ; } SaveResultsFlag = saveResults ; ExceptionCount = 0 ; # ifdef EXH __try # endif { ElapsedTime = 0.0 ; NewRunoffTime = 0.0 ; NewRoutingTime = 0.0 ; ReportTime = ( double ) ( 1000 * ReportStep ) ; StepCount = 0 ; NonConvergeCount = 0 ; IsStartedFlag = TRUE ; RunoffError = 0.0 ; GwaterError = 0.0 ; FlowError = 0.0 ; QualError = 0.0 ; if ( ! IgnoreRainfall ) rain_open ( sp ) ; if ( ErrorCode ) return error_getCode ( ErrorCode ) ; project_init ( ) ; if ( Nobjects [ SUBCATCH ] > 0 ) DoRunoff = TRUE ; else DoRunoff = FALSE ; if ( Nobjects [ NODE ] > 0 && ! IgnoreRouting ) DoRouting = TRUE ; else DoRouting = FALSE ; output_open ( sp ) ; if ( DoRunoff ) runoff_open ( sp ) ; if ( ! hotstart_open ( sp ) ) return ErrorCode ; if ( DoRouting ) routing_open ( sp ) ; massbal_open ( sp ) ; stats_open ( sp ) ; report_writeOptions ( sp ) ; if ( RptFlags . controls ) report_writeControlActionsHeading ( sp ) ; } # ifdef EXH <S2SV_StartBug> __except ( xfilter ( GetExceptionCode ( ) , "swmm_start" , 0.0 , 0 ) ) <S2SV_EndBug> { ErrorCode = ERR_SYSTEM ; } # endif return error_getCode ( ErrorCode ) ; }
|
<S2SV_ModStart> ( xfilter ( sp ,
|
7,928 |
CWE-000 static uint32_t getkey ( XEvent * e ) { <S2SV_StartBug> size_t i = 0 , len = 0 ; <S2SV_EndBug> char buf [ 8 ] ; KeySym key ; Status status ; if ( X . xic ) <S2SV_StartBug> len = Xutf8LookupString ( X . xic , & ( e -> xkey ) , buf , sizeof ( buf ) , & key , & status ) ; <S2SV_EndBug> else <S2SV_StartBug> len = XLookupString ( & ( e -> xkey ) , buf , sizeof ( buf ) , & key , 0 ) ; <S2SV_EndBug> if ( key >= 0x20 && key <= 0x7F ) return ( uint32_t ) key ; return special_keys ( key ) ; }
|
<S2SV_ModStart> e ) { <S2SV_ModEnd> char buf [ <S2SV_ModStart> . xic ) <S2SV_ModEnd> Xutf8LookupString ( X <S2SV_ModStart> ) ; else <S2SV_ModEnd> XLookupString ( &
|
7,929 |
CWE-000 static qboolean CG_DrawScoreboard ( void ) { # ifdef MISSIONPACK static qboolean firstTime = qtrue ; float * fadeColor ; if ( menuScoreboard ) { menuScoreboard -> window . flags &= ~ WINDOW_FORCED ; } if ( cg_paused . integer ) { cg . deferredPlayerLoading = 0 ; firstTime = qtrue ; return qfalse ; } if ( cgs . gametype == GT_SINGLE_PLAYER && cg . predictedPlayerState . pm_type == PM_INTERMISSION ) { cg . deferredPlayerLoading = 0 ; firstTime = qtrue ; return qfalse ; } if ( cg . warmup && ! cg . showScores ) { return qfalse ; } if ( cg . showScores || cg . predictedPlayerState . pm_type == PM_DEAD || cg . predictedPlayerState . pm_type == PM_INTERMISSION ) { fadeColor = colorWhite ; } else { fadeColor = CG_FadeColor ( cg . scoreFadeTime , FADE_TIME ) ; if ( ! fadeColor ) { cg . deferredPlayerLoading = 0 ; cg . killerName [ 0 ] = 0 ; firstTime = qtrue ; return qfalse ; } } if ( menuScoreboard == NULL ) { if ( CG_IsATeamGametype ( cgs . gametype ) && CG_UsesKeyObjectives ( cgs . gametype ) ) { menuScoreboard = Menus_FindByName ( "teamscore_menu" ) ; } else { menuScoreboard = Menus_FindByName ( "score_menu" ) ; } } if ( menuScoreboard ) { if ( firstTime ) { CG_SetScoreSelection ( menuScoreboard ) ; firstTime = qfalse ; } Menu_Paint ( menuScoreboard , qtrue ) ; } if ( ++ cg . deferredPlayerLoading > 10 ) { CG_LoadDeferredPlayers ( ) ; } return qtrue ; # else char * s ; int w ; <S2SV_StartBug> if ( cg . respawnTime && cg . snap -> ps . persistant [ PERS_TEAM ] != TEAM_SPECTATOR && ( ! CG_IsARoundBasedGametype ( cgs . gametype ) ) { <S2SV_EndBug> if ( cg . respawnTime > cg . time ) { s = va ( "Respawn<S2SV_blank>in:<S2SV_blank>%2.2f" , ( ( double ) cg . respawnTime - ( double ) cg . time ) / 1000.0 ) ; w = CG_DrawStrlen ( s ) * SMALLCHAR_WIDTH ; CG_DrawSmallStringColor ( 320 - w / 2 , 400 , s , colorYellow ) ; } else { s = va ( "Click<S2SV_blank>FIRE<S2SV_blank>to<S2SV_blank>respawn" ) ; w = CG_DrawStrlen ( s ) * SMALLCHAR_WIDTH ; CG_DrawSmallStringColor ( 320 - w / 2 , 400 , "Click<S2SV_blank>FIRE<S2SV_blank>to<S2SV_blank>respawn" , colorGreen ) ; } } return CG_DrawOldScoreboard ( ) ; # endif }
|
<S2SV_ModStart> gametype ) ) )
|
7,930 |
CWE-000 static irqreturn_t mlx5_eq_int ( int irq , void * eq_ptr ) { struct mlx5_eq * eq = eq_ptr ; struct mlx5_core_dev * dev = eq -> dev ; struct mlx5_eqe * eqe ; int set_ci = 0 ; u32 cqn = - 1 ; u32 rsn ; u8 port ; while ( ( eqe = next_eqe_sw ( eq ) ) ) { dma_rmb ( ) ; mlx5_core_dbg ( eq -> dev , "eqn<S2SV_blank>%d,<S2SV_blank>eqe<S2SV_blank>type<S2SV_blank>%s\\n" , eq -> eqn , eqe_type_str ( eqe -> type ) ) ; switch ( eqe -> type ) { case MLX5_EVENT_TYPE_COMP : cqn = be32_to_cpu ( eqe -> data . comp . cqn ) & 0xffffff ; mlx5_cq_completion ( dev , cqn ) ; break ; case MLX5_EVENT_TYPE_PATH_MIG : case MLX5_EVENT_TYPE_COMM_EST : case MLX5_EVENT_TYPE_SQ_DRAINED : case MLX5_EVENT_TYPE_SRQ_LAST_WQE : case MLX5_EVENT_TYPE_WQ_CATAS_ERROR : case MLX5_EVENT_TYPE_PATH_MIG_FAILED : case MLX5_EVENT_TYPE_WQ_INVAL_REQ_ERROR : case MLX5_EVENT_TYPE_WQ_ACCESS_ERROR : rsn = be32_to_cpu ( eqe -> data . qp_srq . qp_srq_n ) & 0xffffff ; rsn |= ( eqe -> data . qp_srq . type << MLX5_USER_INDEX_LEN ) ; mlx5_core_dbg ( dev , "event<S2SV_blank>%s(%d)<S2SV_blank>arrived<S2SV_blank>on<S2SV_blank>resource<S2SV_blank>0x%x\\n" , eqe_type_str ( eqe -> type ) , eqe -> type , rsn ) ; mlx5_rsc_event ( dev , rsn , eqe -> type ) ; break ; case MLX5_EVENT_TYPE_SRQ_RQ_LIMIT : case MLX5_EVENT_TYPE_SRQ_CATAS_ERROR : rsn = be32_to_cpu ( eqe -> data . qp_srq . qp_srq_n ) & 0xffffff ; mlx5_core_dbg ( dev , "SRQ<S2SV_blank>event<S2SV_blank>%s(%d):<S2SV_blank>srqn<S2SV_blank>0x%x\\n" , eqe_type_str ( eqe -> type ) , eqe -> type , rsn ) ; mlx5_srq_event ( dev , rsn , eqe -> type ) ; break ; case MLX5_EVENT_TYPE_CMD : mlx5_cmd_comp_handler ( dev , be32_to_cpu ( eqe -> data . cmd . vector ) , false ) ; break ; case MLX5_EVENT_TYPE_PORT_CHANGE : port = ( eqe -> data . port . port >> 4 ) & 0xf ; switch ( eqe -> sub_type ) { case MLX5_PORT_CHANGE_SUBTYPE_DOWN : case MLX5_PORT_CHANGE_SUBTYPE_ACTIVE : case MLX5_PORT_CHANGE_SUBTYPE_LID : case MLX5_PORT_CHANGE_SUBTYPE_PKEY : case MLX5_PORT_CHANGE_SUBTYPE_GUID : case MLX5_PORT_CHANGE_SUBTYPE_CLIENT_REREG : case MLX5_PORT_CHANGE_SUBTYPE_INITIALIZED : if ( dev -> event ) dev -> event ( dev , port_subtype_event ( eqe -> sub_type ) , ( unsigned long ) port ) ; break ; default : mlx5_core_warn ( dev , "Port<S2SV_blank>event<S2SV_blank>with<S2SV_blank>unrecognized<S2SV_blank>subtype:<S2SV_blank>port<S2SV_blank>%d,<S2SV_blank>sub_type<S2SV_blank>%d\\n" , port , eqe -> sub_type ) ; } break ; case MLX5_EVENT_TYPE_CQ_ERROR : cqn = be32_to_cpu ( eqe -> data . cq_err . cqn ) & 0xffffff ; <S2SV_StartBug> mlx5_core_warn ( dev , "CQ<S2SV_blank>error<S2SV_blank>on<S2SV_blank>CQN<S2SV_blank>0x%x,<S2SV_blank>syndrom<S2SV_blank>0x%x\\n" , <S2SV_EndBug> cqn , eqe -> data . cq_err . syndrome ) ; mlx5_cq_event ( dev , cqn , eqe -> type ) ; break ; case MLX5_EVENT_TYPE_PAGE_REQUEST : { u16 func_id = be16_to_cpu ( eqe -> data . req_pages . func_id ) ; s32 npages = be32_to_cpu ( eqe -> data . req_pages . num_pages ) ; mlx5_core_dbg ( dev , "page<S2SV_blank>request<S2SV_blank>for<S2SV_blank>func<S2SV_blank>0x%x,<S2SV_blank>npages<S2SV_blank>%d\\n" , func_id , npages ) ; mlx5_core_req_pages_handler ( dev , func_id , npages ) ; } break ; case MLX5_EVENT_TYPE_NIC_VPORT_CHANGE : mlx5_eswitch_vport_event ( dev -> priv . eswitch , eqe ) ; break ; case MLX5_EVENT_TYPE_PORT_MODULE_EVENT : mlx5_port_module_event ( dev , eqe ) ; break ; case MLX5_EVENT_TYPE_PPS_EVENT : mlx5_pps_event ( dev , eqe ) ; break ; case MLX5_EVENT_TYPE_FPGA_ERROR : mlx5_fpga_event ( dev , eqe -> type , & eqe -> data . raw ) ; break ; case MLX5_EVENT_TYPE_GENERAL_EVENT : general_event_handler ( dev , eqe ) ; break ; default : mlx5_core_warn ( dev , "Unhandled<S2SV_blank>event<S2SV_blank>0x%x<S2SV_blank>on<S2SV_blank>EQ<S2SV_blank>0x%x\\n" , eqe -> type , eq -> eqn ) ; break ; } ++ eq -> cons_index ; ++ set_ci ; if ( unlikely ( set_ci >= MLX5_NUM_SPARE_EQE ) ) { eq_update_ci ( eq , 0 ) ; set_ci = 0 ; } } eq_update_ci ( eq , 1 ) ; if ( cqn != - 1 ) tasklet_schedule ( & eq -> tasklet_ctx . task ) ; return IRQ_HANDLED ; }
|
<S2SV_ModStart> ( dev , "CQ<S2SV_blank>error<S2SV_blank>on<S2SV_blank>CQN<S2SV_blank>0x%x,<S2SV_blank>syndrome<S2SV_blank>0x%x\\n" <S2SV_ModEnd> , cqn ,
|
7,931 |
CWE-000 static yy_state_type yy_try_NUL_trans ( yy_state_type yy_current_state ) { register int yy_is_jam ; register char * yy_cp = ( yy_c_buf_p ) ; register YY_CHAR yy_c = 1 ; if ( yy_accept [ yy_current_state ] ) { ( yy_last_accepting_state ) = yy_current_state ; ( yy_last_accepting_cpos ) = yy_cp ; } while ( yy_chk [ yy_base [ yy_current_state ] + yy_c ] != yy_current_state ) { yy_current_state = ( int ) yy_def [ yy_current_state ] ; <S2SV_StartBug> if ( yy_current_state >= 32 ) <S2SV_EndBug> yy_c = yy_meta [ ( unsigned int ) yy_c ] ; } yy_current_state = yy_nxt [ yy_base [ yy_current_state ] + ( unsigned int ) yy_c ] ; <S2SV_StartBug> yy_is_jam = ( yy_current_state == 31 ) ; <S2SV_EndBug> return yy_is_jam ? 0 : yy_current_state ; }
|
<S2SV_ModStart> ( yy_current_state >= 24 <S2SV_ModEnd> ) yy_c = <S2SV_ModStart> ( yy_current_state == 23 <S2SV_ModEnd> ) ; return
|
7,932 |
CWE-000 void empire_scroll_map ( int direction ) { if ( direction == DIR_8_NONE ) { return ; } switch ( direction ) { case DIR_0_TOP : data . scroll_y -= 20 ; break ; case DIR_1_TOP_RIGHT : data . scroll_x += 20 ; data . scroll_y -= 20 ; break ; case DIR_2_RIGHT : data . scroll_x += 20 ; break ; case DIR_3_BOTTOM_RIGHT : data . scroll_x += 20 ; data . scroll_y += 20 ; break ; case DIR_4_BOTTOM : data . scroll_y += 20 ; break ; case DIR_5_BOTTOM_LEFT : data . scroll_x -= 20 ; data . scroll_y += 20 ; break ; case DIR_6_LEFT : data . scroll_x -= 20 ; break ; case DIR_7_TOP_LEFT : data . scroll_x -= 20 ; data . scroll_y -= 20 ; break ; <S2SV_StartBug> } ; <S2SV_EndBug> check_scroll_boundaries ( ) ; }
|
<S2SV_ModStart> break ; } <S2SV_ModEnd> check_scroll_boundaries ( )
|
7,933 |
CWE-000 static char * get_vf_name ( const char * filename ) { char * _post = "_odeModel" ; char * lib_name = basename ( filename ) ; size_t len = strlen ( lib_name ) ; <S2SV_StartBug> size_t i ; <S2SV_EndBug> for ( i = 0 ; i < len ; i ++ ) if ( ( ( lib_name [ i ] == '_' ) && ( lib_name [ i + 1 ] == 'c' ) ) || ( lib_name [ i ] == '.' ) ) break ; <S2SV_StartBug> size_t new_size = i + strlen ( _post ) + 1 ; <S2SV_EndBug> <S2SV_StartBug> char * ret = ( char * ) malloc ( new_size * sizeof ( char ) ) ; <S2SV_EndBug> <S2SV_StartBug> strncat ( ret , lib_name , i ) ; <S2SV_EndBug> strcat ( ret , _post ) ; <S2SV_StartBug> return ret ; <S2SV_EndBug> }
|
<S2SV_ModStart> lib_name ) ; int n ; char * dot ; printf ( "[get_vf_name]<S2SV_blank>lib_name:<S2SV_blank>%s\\n" , lib_name ) ; dot = strchr ( lib_name , '.' ) ; n = strlen ( lib_name ) ; n -= strlen ( dot ) <S2SV_ModEnd> ; size_t new_size <S2SV_ModStart> size_t new_size = n <S2SV_ModEnd> + strlen ( <S2SV_ModStart> _post ) + 2 <S2SV_ModEnd> ; char * <S2SV_ModStart> char * ) calloc ( new_size , <S2SV_ModEnd> sizeof ( char <S2SV_ModStart> , lib_name , n <S2SV_ModEnd> ) ; strcat <S2SV_ModStart> _post ) ; printf ( "[get_vf_name]<S2SV_blank>vf_name:<S2SV_blank>%s\\n" , ret ) ;
|
7,934 |
CWE-000 void k_sched_lock ( void ) { # ifdef CONFIG_PREEMPT_ENABLED __ASSERT ( _current -> base . sched_locked != 1 , "" ) ; __ASSERT ( ! _is_in_isr ( ) , "" ) ; -- _current -> base . sched_locked ; <S2SV_StartBug> K_DEBUG ( "scheduler<S2SV_blank>locked<S2SV_blank>(%p:%d)\\n" , <S2SV_EndBug> _current , _current -> base . sched_locked ) ; # endif }
|
<S2SV_ModStart> . sched_locked ; compiler_barrier ( ) ;
|
7,935 |
CWE-000 bool radeon_card_posted ( struct radeon_device * rdev ) { uint32_t reg ; <S2SV_StartBug> if ( efi_enabled && rdev -> pdev -> subsystem_vendor == PCI_VENDOR_ID_APPLE ) <S2SV_EndBug> return false ; if ( ASIC_IS_DCE41 ( rdev ) ) { reg = RREG32 ( EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC0_REGISTER_OFFSET ) | RREG32 ( EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC1_REGISTER_OFFSET ) ; if ( reg & EVERGREEN_CRTC_MASTER_EN ) return true ; } else if ( ASIC_IS_DCE4 ( rdev ) ) { reg = RREG32 ( EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC0_REGISTER_OFFSET ) | RREG32 ( EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC1_REGISTER_OFFSET ) | RREG32 ( EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC2_REGISTER_OFFSET ) | RREG32 ( EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC3_REGISTER_OFFSET ) | RREG32 ( EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC4_REGISTER_OFFSET ) | RREG32 ( EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC5_REGISTER_OFFSET ) ; if ( reg & EVERGREEN_CRTC_MASTER_EN ) return true ; } else if ( ASIC_IS_AVIVO ( rdev ) ) { reg = RREG32 ( AVIVO_D1CRTC_CONTROL ) | RREG32 ( AVIVO_D2CRTC_CONTROL ) ; if ( reg & AVIVO_CRTC_EN ) { return true ; } } else { reg = RREG32 ( RADEON_CRTC_GEN_CNTL ) | RREG32 ( RADEON_CRTC2_GEN_CNTL ) ; if ( reg & RADEON_CRTC_EN ) { return true ; } } if ( rdev -> family >= CHIP_R600 ) reg = RREG32 ( R600_CONFIG_MEMSIZE ) ; else reg = RREG32 ( RADEON_CONFIG_MEMSIZE ) ; if ( reg ) return true ; return false ; }
|
<S2SV_ModStart> if ( efi_enabled ( EFI_BOOT )
|
7,936 |
CWE-000 int itc_equeue_put ( itc_equeue_token_t token , itc_equeue_event_t event ) { if ( token == _SCHED_TOKEN ) ERROR_RETURN_LOG ( int , "Cannot<S2SV_blank>call<S2SV_blank>put<S2SV_blank>method<S2SV_blank>from<S2SV_blank>the<S2SV_blank>scheduler<S2SV_blank>thread" ) ; if ( event . type == ITC_EQUEUE_EVENT_TYPE_IO && ( event . io . in == NULL || event . io . out == NULL ) ) ERROR_RETURN_LOG ( int , "Invalid<S2SV_blank>IO<S2SV_blank>event" ) ; else if ( event . type == ITC_EQUEUE_EVENT_TYPE_TASK && ( event . task . loop == NULL || event . task . task == NULL ) ) ERROR_RETURN_LOG ( int , "Invalid<S2SV_blank>Task<S2SV_blank>event" ) ; else if ( event . type != ITC_EQUEUE_EVENT_TYPE_IO && event . type != ITC_EQUEUE_EVENT_TYPE_TASK ) ERROR_RETURN_LOG ( int , "Invalid<S2SV_blank>event<S2SV_blank>type" ) ; _queue_t * queue = * VECTOR_GET ( _queue_t * , _queues , token ) ; if ( NULL == queue ) ERROR_RETURN_LOG ( int , "Cannot<S2SV_blank>get<S2SV_blank>the<S2SV_blank>queue<S2SV_blank>for<S2SV_blank>token<S2SV_blank>%u" , token ) ; if ( queue -> type != event . type ) ERROR_RETURN_LOG ( int , "Invalid<S2SV_blank>event<S2SV_blank>type,<S2SV_blank>the<S2SV_blank>queue<S2SV_blank>do<S2SV_blank>not<S2SV_blank>accept<S2SV_blank>specified<S2SV_blank>event<S2SV_blank>type" ) ; LOG_DEBUG ( "token<S2SV_blank>%u:<S2SV_blank>wait<S2SV_blank>for<S2SV_blank>the<S2SV_blank>queue<S2SV_blank>have<S2SV_blank>space<S2SV_blank>for<S2SV_blank>the<S2SV_blank>new<S2SV_blank>event" , token ) ; struct timespec abstime ; struct timeval now ; gettimeofday ( & now , NULL ) ; abstime . tv_sec = now . tv_sec + 1 ; abstime . tv_nsec = 0 ; if ( pthread_mutex_lock ( & queue -> mutex ) < 0 ) ERROR_RETURN_LOG_ERRNO ( int , "Cannot<S2SV_blank>acquire<S2SV_blank>the<S2SV_blank>queue<S2SV_blank>mutex" ) ; while ( queue -> rear == queue -> front + queue -> size ) { if ( pthread_cond_timedwait ( & queue -> put_cond , & queue -> mutex , & abstime ) < 0 && errno != ETIMEDOUT && errno != EINTR ) LOG_WARNING_ERRNO ( "failed<S2SV_blank>to<S2SV_blank>wait<S2SV_blank>for<S2SV_blank>the<S2SV_blank>cond<S2SV_blank>variable<S2SV_blank>get<S2SV_blank>ready" ) ; if ( itc_eloop_thread_killed == 1 ) { LOG_INFO ( "event<S2SV_blank>thread<S2SV_blank>gets<S2SV_blank>killed" ) ; return 0 ; } abstime . tv_sec ++ ; } if ( pthread_mutex_unlock ( & queue -> mutex ) < 0 ) LOG_WARNING_ERRNO ( "cannot<S2SV_blank>release<S2SV_blank>the<S2SV_blank>queue<S2SV_blank>mutex" ) ; LOG_DEBUG ( "token<S2SV_blank>%u:<S2SV_blank>now<S2SV_blank>the<S2SV_blank>queue<S2SV_blank>have<S2SV_blank>sufficent<S2SV_blank>space<S2SV_blank>for<S2SV_blank>the<S2SV_blank>new<S2SV_blank>event" , token ) ; uint64_t next_position = ( queue -> rear ) & ( queue -> size - 1 ) ; queue -> events [ next_position ] = event ; BARRIER ( ) ; arch_atomic_sw_increment_u32 ( & queue -> rear ) ; LOG_DEBUG ( "token<S2SV_blank>%u:<S2SV_blank>notifiying<S2SV_blank>the<S2SV_blank>schduler<S2SV_blank>thread<S2SV_blank>to<S2SV_blank>read<S2SV_blank>this<S2SV_blank>element" , token ) ; if ( pthread_mutex_lock ( & _take_mutex ) < 0 ) LOG_WARNING_ERRNO ( "cannot<S2SV_blank>acquire<S2SV_blank>the<S2SV_blank>reader<S2SV_blank>mutex" ) ; <S2SV_StartBug> _nevents [ event . type ] ++ ; <S2SV_EndBug> _nevents [ ITC_EQUEUE_EVENT_TYPE_COUNT ] ++ ; if ( pthread_cond_signal ( & _take_cond ) < 0 ) LOG_WARNING_ERRNO ( "cannot<S2SV_blank>send<S2SV_blank>signal<S2SV_blank>to<S2SV_blank>the<S2SV_blank>scheduler<S2SV_blank>thread" ) ; if ( pthread_mutex_unlock ( & _take_mutex ) < 0 ) LOG_WARNING_ERRNO ( "cannot<S2SV_blank>release<S2SV_blank>the<S2SV_blank>reader<S2SV_blank>mutex" ) ; LOG_DEBUG ( "token<S2SV_blank>%u:<S2SV_blank>event<S2SV_blank>message<S2SV_blank>notified" , token ) ; return 0 ; }
|
<S2SV_ModStart> "cannot<S2SV_blank>acquire<S2SV_blank>the<S2SV_blank>reader<S2SV_blank>mutex" ) ; <S2SV_ModEnd> if ( pthread_cond_signal
|
7,937 |
CWE-000 char * TagsToXML ( Tag * tags , int size ) { if ( NULL == tags ) return NULL ; <S2SV_StartBug> char * s = malloc ( 512 ) ; <S2SV_EndBug> <S2SV_StartBug> memset ( s , 0 , 512 ) ; <S2SV_EndBug> int j = 0 ; for ( int i = 0 ; i < size ; i ++ ) { <S2SV_StartBug> j += sprintf ( s , "<Tag<S2SV_blank>id=\\"%s\\">" , hex ( littleEndianBin ( ( tags + i ) -> id ) , 0 , 2 ) ) ; <S2SV_EndBug> } return s ; }
|
<S2SV_ModStart> = malloc ( 10240 <S2SV_ModEnd> ) ; memset <S2SV_ModStart> , 0 , 10240 <S2SV_ModEnd> ) ; int <S2SV_ModStart> sprintf ( s + j
|
7,938 |
CWE-000 void dae_solver_free ( dae_solver_t * integ ) <S2SV_StartBug> { <S2SV_EndBug> if ( integ -> precond != NULL ) newton_pc_free ( integ -> precond ) ; N_VDestroy ( integ -> U_dot ) ; polymec_free ( integ -> U_with_ghosts ) ; N_VDestroy ( integ -> U ) ; polymec_free ( integ -> U_dot_with_ghosts ) ; IDAFree ( & integ -> ida ) ; if ( integ -> status_message != NULL ) polymec_free ( integ -> status_message ) ; if ( ( integ -> context != NULL ) && ( integ -> dtor != NULL ) ) integ -> dtor ( integ -> context ) ; if ( integ -> error_weights != NULL ) polymec_free ( integ -> error_weights ) ; polymec_free ( integ ) ; }
|
<S2SV_ModStart> integ ) { string_free ( integ -> name ) ;
|
7,939 |
CWE-000 bool mapif_elemental_save ( struct s_elemental * ele ) { bool flag = true ; if ( ele -> elemental_id == 0 ) { if ( SQL_ERROR == Sql_Query ( sql_handle , "INSERT<S2SV_blank>INTO<S2SV_blank>`%s`<S2SV_blank>(`char_id`,`class`,`mode`,`hp`,`sp`,`max_hp`,`max_sp`,`atk1`,`atk2`,`matk`,`aspd`,`def`,`mdef`,`flee`,`hit`,`life_time`)" <S2SV_StartBug> "VALUES<S2SV_blank>(\'%d\',\'%d\',\'%d\',\'%d\',\'%d\',\'%d\',\'%d\',\'%d\',\'%d\',\'%d\',\'%d\',\'%d\',\'%d\',\'%d\',\'%d\',\'%u\')" , <S2SV_EndBug> schema_config . elemental_db , ele -> char_id , ele -> class_ , ele -> mode , ele -> hp , ele -> sp , ele -> max_hp , ele -> max_sp , ele -> atk , ele -> atk2 , ele -> matk , ele -> amotion , ele -> def , ele -> mdef , ele -> flee , ele -> hit , ele -> life_time ) ) { Sql_ShowDebug ( sql_handle ) ; flag = false ; } else ele -> elemental_id = ( int ) Sql_LastInsertId ( sql_handle ) ; } else if ( SQL_ERROR == Sql_Query ( sql_handle , <S2SV_StartBug> "UPDATE<S2SV_blank>`%s`<S2SV_blank>SET<S2SV_blank>`char_id`<S2SV_blank>=<S2SV_blank>\'%d\',<S2SV_blank>`class`<S2SV_blank>=<S2SV_blank>\'%d\',<S2SV_blank>`mode`<S2SV_blank>=<S2SV_blank>\'%d\',<S2SV_blank>`hp`<S2SV_blank>=<S2SV_blank>\'%d\',<S2SV_blank>`sp`<S2SV_blank>=<S2SV_blank>\'%d\'," <S2SV_EndBug> "`max_hp`<S2SV_blank>=<S2SV_blank>\'%d\',<S2SV_blank>`max_sp`<S2SV_blank>=<S2SV_blank>\'%d\',<S2SV_blank>`atk1`<S2SV_blank>=<S2SV_blank>\'%d\',<S2SV_blank>`atk2`<S2SV_blank>=<S2SV_blank>\'%d\',<S2SV_blank>`matk`<S2SV_blank>=<S2SV_blank>\'%d\',<S2SV_blank>`aspd`<S2SV_blank>=<S2SV_blank>\'%d\',<S2SV_blank>`def`<S2SV_blank>=<S2SV_blank>\'%d\'," "`mdef`<S2SV_blank>=<S2SV_blank>\'%d\',<S2SV_blank>`flee`<S2SV_blank>=<S2SV_blank>\'%d\',<S2SV_blank>`hit`<S2SV_blank>=<S2SV_blank>\'%d\',<S2SV_blank>`life_time`<S2SV_blank>=<S2SV_blank>\'%u\'<S2SV_blank>WHERE<S2SV_blank>`ele_id`<S2SV_blank>=<S2SV_blank>\'%d\'" , schema_config . elemental_db , ele -> char_id , ele -> class_ , ele -> mode , ele -> hp , ele -> sp , ele -> max_hp , ele -> max_sp , ele -> atk , ele -> atk2 , ele -> matk , ele -> amotion , ele -> def , ele -> mdef , ele -> flee , ele -> hit , ele -> life_time , ele -> elemental_id ) ) { Sql_ShowDebug ( sql_handle ) ; flag = false ; } return flag ; }
|
<S2SV_ModStart> sql_handle , "INSERT<S2SV_blank>INTO<S2SV_blank>`%s`<S2SV_blank>(`char_id`,`class`,`mode`,`hp`,`sp`,`max_hp`,`max_sp`,`atk1`,`atk2`,`matk`,`aspd`,`def`,`mdef`,`flee`,`hit`,`life_time`)" "VALUES<S2SV_blank>(\'%d\',\'%d\',\'%d\',\'%u\',\'%u\',\'%u\',\'%u\',\'%d\',\'%d\',\'%d\',\'%d\',\'%d\',\'%d\',\'%d\',\'%d\',\'%u\')" <S2SV_ModEnd> , schema_config . <S2SV_ModStart> ( sql_handle , "UPDATE<S2SV_blank>`%s`<S2SV_blank>SET<S2SV_blank>`char_id`<S2SV_blank>=<S2SV_blank>\'%d\',<S2SV_blank>`class`<S2SV_blank>=<S2SV_blank>\'%d\',<S2SV_blank>`mode`<S2SV_blank>=<S2SV_blank>\'%d\',<S2SV_blank>`hp`<S2SV_blank>=<S2SV_blank>\'%u\',<S2SV_blank>`sp`<S2SV_blank>=<S2SV_blank>\'%u\'," "`max_hp`<S2SV_blank>=<S2SV_blank>\'%u\',<S2SV_blank>`max_sp`<S2SV_blank>=<S2SV_blank>\'%u\',<S2SV_blank>`atk1`<S2SV_blank>=<S2SV_blank>\'%d\',<S2SV_blank>`atk2`<S2SV_blank>=<S2SV_blank>\'%d\',<S2SV_blank>`matk`<S2SV_blank>=<S2SV_blank>\'%d\',<S2SV_blank>`aspd`<S2SV_blank>=<S2SV_blank>\'%d\',<S2SV_blank>`def`<S2SV_blank>=<S2SV_blank>\'%d\'," <S2SV_ModEnd> "`mdef`<S2SV_blank>=<S2SV_blank>\'%d\',<S2SV_blank>`flee`<S2SV_blank>=<S2SV_blank>\'%d\',<S2SV_blank>`hit`<S2SV_blank>=<S2SV_blank>\'%d\',<S2SV_blank>`life_time`<S2SV_blank>=<S2SV_blank>\'%u\'<S2SV_blank>WHERE<S2SV_blank>`ele_id`<S2SV_blank>=<S2SV_blank>\'%d\'" , schema_config
|
7,940 |
CWE-000 static void cpufreq_interactive_timer ( unsigned long data ) { u64 now ; unsigned int delta_time ; u64 cputime_speedadj ; int cpu_load ; struct cpufreq_interactive_cpuinfo * pcpu = & per_cpu ( cpuinfo , data ) ; struct cpufreq_interactive_tunables * tunables = pcpu -> policy -> governor_data ; unsigned int new_freq ; unsigned int loadadjfreq ; unsigned int index ; unsigned long flags ; # ifdef CONFIG_MODE_AUTO_CHANGE unsigned int new_mode ; # endif if ( ! down_read_trylock ( & pcpu -> enable_sem ) ) return ; if ( ! pcpu -> governor_enabled ) goto exit ; spin_lock_irqsave ( & pcpu -> load_lock , flags ) ; now = update_load ( data ) ; delta_time = ( unsigned int ) ( now - pcpu -> cputime_speedadj_timestamp ) ; cputime_speedadj = pcpu -> cputime_speedadj ; spin_unlock_irqrestore ( & pcpu -> load_lock , flags ) ; if ( WARN_ON_ONCE ( ! delta_time ) ) goto rearm ; # ifdef CONFIG_MODE_AUTO_CHANGE spin_lock_irqsave ( & tunables -> mode_lock , flags ) ; if ( tunables -> enforced_mode ) new_mode = tunables -> enforced_mode ; else new_mode = check_mode ( data , tunables -> mode , now ) ; if ( new_mode != tunables -> mode ) { tunables -> mode = new_mode ; if ( new_mode & MULTI_MODE || new_mode & SINGLE_MODE ) enter_mode ( tunables ) ; else exit_mode ( tunables ) ; } spin_unlock_irqrestore ( & tunables -> mode_lock , flags ) ; # endif spin_lock_irqsave ( & pcpu -> target_freq_lock , flags ) ; do_div ( cputime_speedadj , delta_time ) ; loadadjfreq = ( unsigned int ) cputime_speedadj * 100 ; cpu_load = loadadjfreq / pcpu -> policy -> cur ; if ( cpu_load >= tunables -> go_hispeed_load ) { if ( pcpu -> target_freq < tunables -> hispeed_freq ) { new_freq = tunables -> hispeed_freq ; } else { new_freq = choose_freq ( pcpu , loadadjfreq ) ; if ( new_freq < tunables -> hispeed_freq ) new_freq = tunables -> hispeed_freq ; } } else { new_freq = choose_freq ( pcpu , loadadjfreq ) ; if ( new_freq > tunables -> hispeed_freq && pcpu -> target_freq < tunables -> hispeed_freq ) new_freq = tunables -> hispeed_freq ; } if ( pcpu -> policy -> cur >= tunables -> hispeed_freq && new_freq > pcpu -> policy -> cur && now - pcpu -> hispeed_validate_time < freq_to_above_hispeed_delay ( tunables , pcpu -> policy -> cur ) ) { trace_cpufreq_interactive_notyet ( data , cpu_load , pcpu -> target_freq , pcpu -> policy -> cur , new_freq ) ; spin_unlock_irqrestore ( & pcpu -> target_freq_lock , flags ) ; goto rearm ; } if ( cpufreq_frequency_table_target ( pcpu -> policy , pcpu -> freq_table , new_freq , CPUFREQ_RELATION_L , & index ) ) { spin_unlock_irqrestore ( & pcpu -> target_freq_lock , flags ) ; goto rearm ; } new_freq = pcpu -> freq_table [ index ] . frequency ; if ( new_freq < pcpu -> floor_freq ) { if ( now - pcpu -> floor_validate_time < tunables -> min_sample_time ) { trace_cpufreq_interactive_notyet ( data , cpu_load , pcpu -> target_freq , pcpu -> policy -> cur , new_freq ) ; spin_unlock_irqrestore ( & pcpu -> target_freq_lock , flags ) ; goto rearm ; } } if ( new_freq > tunables -> hispeed_freq ) { pcpu -> floor_freq = new_freq ; pcpu -> floor_validate_time = now ; } if ( pcpu -> target_freq == new_freq && pcpu -> target_freq <= pcpu -> policy -> cur ) { trace_cpufreq_interactive_already ( data , cpu_load , pcpu -> target_freq , pcpu -> policy -> cur , new_freq ) ; spin_unlock_irqrestore ( & pcpu -> target_freq_lock , flags ) ; <S2SV_StartBug> goto rearm_if_notmax ; <S2SV_EndBug> } trace_cpufreq_interactive_target ( data , cpu_load , pcpu -> target_freq , pcpu -> policy -> cur , new_freq ) ; pcpu -> target_freq = new_freq ; spin_unlock_irqrestore ( & pcpu -> target_freq_lock , flags ) ; spin_lock_irqsave ( & speedchange_cpumask_lock , flags ) ; cpumask_set_cpu ( data , & speedchange_cpumask ) ; spin_unlock_irqrestore ( & speedchange_cpumask_lock , flags ) ; wake_up_process ( tunables -> speedchange_task ) ; <S2SV_StartBug> rearm_if_notmax : <S2SV_EndBug> if ( pcpu -> target_freq == pcpu -> policy -> max ) # ifdef CONFIG_MODE_AUTO_CHANGE goto rearm ; # else goto exit ; # endif rearm : if ( ! timer_pending ( & pcpu -> cpu_timer ) ) cpufreq_interactive_timer_resched ( pcpu ) ; exit : up_read ( & pcpu -> enable_sem ) ; return ; }
|
<S2SV_ModStart> ) ; goto rearm <S2SV_ModEnd> ; } trace_cpufreq_interactive_target <S2SV_ModStart> speedchange_task ) ; <S2SV_ModEnd> rearm : if
|
7,941 |
CWE-000 static void quote_max ( struct Client * source_p , int newval ) { if ( newval > 0 ) { recalc_fdlimit ( NULL ) ; if ( newval > MAXCLIENTS_MAX ) { sendto_one ( source_p , ":%s<S2SV_blank>NOTICE<S2SV_blank>%s<S2SV_blank>:You<S2SV_blank>cannot<S2SV_blank>set<S2SV_blank>MAXCLIENTS<S2SV_blank>to<S2SV_blank>><S2SV_blank>%d,<S2SV_blank>restoring<S2SV_blank>to<S2SV_blank>%d" , <S2SV_StartBug> me . name , source_p -> name , MAXCLIENTS_MAX ) ; <S2SV_EndBug> return ; } if ( newval < MAXCLIENTS_MIN ) { sendto_one ( source_p , ":%s<S2SV_blank>NOTICE<S2SV_blank>%s<S2SV_blank>:You<S2SV_blank>cannot<S2SV_blank>set<S2SV_blank>MAXCLIENTS<S2SV_blank>to<S2SV_blank><<S2SV_blank>%d,<S2SV_blank>restoring<S2SV_blank>to<S2SV_blank>%d" , me . name , source_p -> name , MAXCLIENTS_MIN , ServerInfo . max_clients ) ; return ; } ServerInfo . max_clients = newval ; sendto_gnotice_flags ( UMODE_ALL , L_ALL , me . name , & me , NULL , "%s!%s@%s<S2SV_blank>set<S2SV_blank>new<S2SV_blank>MAXCLIENTS<S2SV_blank>to<S2SV_blank>%d<S2SV_blank>(%d<S2SV_blank>current)" , source_p -> name , source_p -> username , source_p -> host , ServerInfo . max_clients , Count . local ) ; } else sendto_one ( source_p , ":%s<S2SV_blank>NOTICE<S2SV_blank>%s<S2SV_blank>:Current<S2SV_blank>MAXCLIENTS<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>(%d)" , me . name , source_p -> name , ServerInfo . max_clients , Count . local ) ; }
|
<S2SV_ModStart> name , MAXCLIENTS_MAX , ServerInfo . max_clients
|
7,942 |
CWE-000 gboolean builder_git_shallow_mirror_ref ( const char * repo_location , const char * destination_path , gboolean mirror_submodules , const char * ref , BuilderContext * context , GError * * error ) { g_autoptr ( GFile ) cache_mirror_dir = NULL ; g_autoptr ( GFile ) mirror_dir = NULL ; g_autofree char * current_commit = NULL ; g_autofree char * file_name = NULL ; g_autofree char * destination_file_path = NULL ; g_autofree char * full_ref = NULL ; <S2SV_StartBug> cache_mirror_dir = git_get_mirror_dir ( repo_location , context ) ; <S2SV_EndBug> file_name = g_file_get_basename ( cache_mirror_dir ) ; destination_file_path = g_build_filename ( destination_path , file_name , NULL ) ; mirror_dir = g_file_new_for_path ( destination_file_path ) ; if ( ! g_file_query_exists ( mirror_dir , NULL ) ) { if ( ! git ( NULL , NULL , error , "init" , "--bare" , destination_file_path , NULL ) ) return FALSE ; if ( ! git ( mirror_dir , NULL , error , "remote" , "add" , "--mirror=fetch" , "origin" , ( char * ) flatpak_file_get_path_cached ( cache_mirror_dir ) , NULL ) ) return FALSE ; } if ( ! git ( cache_mirror_dir , & full_ref , NULL , "rev-parse" , "--symbolic-full-name" , ref , NULL ) ) return FALSE ; g_strchomp ( full_ref ) ; if ( * full_ref == 0 ) { g_free ( full_ref ) ; full_ref = g_strdup_printf ( "flatpak-builder/ref-%s" , ref ) ; if ( ! git ( cache_mirror_dir , NULL , NULL , "branch" , "-f" , full_ref , ref , NULL ) ) return FALSE ; } <S2SV_StartBug> if ( ! git ( mirror_dir , NULL , error , <S2SV_EndBug> <S2SV_StartBug> "fetch" , "--depth" , "1" , "origin" , full_ref , NULL ) ) <S2SV_EndBug> return FALSE ; if ( mirror_submodules ) { current_commit = git_get_current_commit ( mirror_dir , ref , FALSE , context , error ) ; if ( current_commit == NULL ) return FALSE ; if ( ! git_mirror_submodules ( repo_location , destination_path , TRUE , FALSE , mirror_dir , TRUE , current_commit , context , error ) ) return FALSE ; } return TRUE ; }
|
<S2SV_ModStart> = NULL ; g_autofree char * full_ref_colon_full_ref = NULL ; <S2SV_ModStart> FALSE ; } full_ref_colon_full_ref = g_strdup_printf ( "%s:%s" , full_ref , full_ref ) ; <S2SV_ModStart> , "origin" , full_ref_colon_full_ref <S2SV_ModEnd> , NULL )
|
7,943 |
CWE-000 static void DumpAstExprFromBin ( const SAstExprFromBin * ast ) { <S2SV_StartBug> PrintTab ( ) ; fwprintf ( FilePtr , L"<ExprFromBin" ) ; <S2SV_EndBug> fwprintf ( FilePtr , L"<S2SV_blank>Offset=\\"0x%08X\\"" , ast -> Offset ) ; fwprintf ( FilePtr , L">\\n" ) ; Tab ++ ; { DumpAstExpr ( ( const SAstExpr * ) ast ) ; PrintAst ( L"ExprFromBin_Child" , ( const SAst * ) ast -> Child ) ; PrintAst ( L"ExprFromBin_ChildType" , ( const SAst * ) ast -> ChildType ) ; <S2SV_StartBug> } <S2SV_EndBug> Tab -- ; PrintTab ( ) ; fwprintf ( FilePtr , L"</ExprFromBin>\\n" ) ; }
|
<S2SV_ModStart> ( FilePtr , L"<ExprFromBin>\\n" <S2SV_ModEnd> ) ; Tab <S2SV_ModStart> ChildType ) ; PrintAst ( L"ExprFromBin_Offset" , ( const SAst * ) ast -> Offset ) ;
|
7,944 |
CWE-000 long get_data_from_url_with_session ( void * * ptr_session , char * url , char * * out , size_t * size , int type , char * * new_url ) { assert ( ptr_session && * ptr_session ) ; struct http_session * session = * ptr_session ; struct curl_slist * headers = session -> headers ; assert ( session -> handle ) ; assert ( url ) ; assert ( size ) ; CURL * c = ( CURL * ) ( session -> handle ) ; CURLcode res ; long http_code = 0 ; char * e_url = NULL ; url [ strcspn ( url , "\\r" ) ] = '\\0' ; struct MemoryStruct chunk ; chunk . memory = malloc ( 1 ) ; chunk . memory [ 0 ] = '\\0' ; chunk . size = 0 ; chunk . reserved = 0 ; chunk . c = c ; curl_easy_setopt ( c , CURLOPT_URL , url ) ; curl_easy_setopt ( c , CURLOPT_WRITEFUNCTION , WriteMemoryCallback ) ; curl_easy_setopt ( c , CURLOPT_WRITEDATA , ( void * ) & chunk ) ; <S2SV_StartBug> curl_easy_setopt ( c , CURLOPT_LOW_SPEED_LIMIT , 2L ) ; <S2SV_EndBug> <S2SV_StartBug> curl_easy_setopt ( c , CURLOPT_LOW_SPEED_TIME , 3L ) ; <S2SV_EndBug> curl_easy_setopt ( c , CURLOPT_SSL_VERIFYPEER , 0L ) ; curl_easy_setopt ( c , CURLOPT_ACCEPT_ENCODING , "" ) ; if ( session -> user_agent ) { curl_easy_setopt ( c , CURLOPT_USERAGENT , session -> user_agent ) ; } else { curl_easy_setopt ( c , CURLOPT_USERAGENT , USER_AGENT ) ; } if ( headers ) { curl_easy_setopt ( c , CURLOPT_HTTPHEADER , headers ) ; } if ( session -> proxy_uri ) { curl_easy_setopt ( c , CURLOPT_PROXY , session -> proxy_uri ) ; } curl_easy_setopt ( c , CURLOPT_FOLLOWLOCATION , 1L ) ; res = curl_easy_perform ( c ) ; curl_easy_getinfo ( c , CURLINFO_RESPONSE_CODE , & http_code ) ; if ( new_url && CURLE_OK == curl_easy_getinfo ( c , CURLINFO_EFFECTIVE_URL , & e_url ) ) { free ( * new_url ) ; * new_url = strdup ( e_url ) ; } if ( res != CURLE_OK ) { MSG_ERROR ( "curl_easy_perform()<S2SV_blank>failed:<S2SV_blank>%s\\n" , curl_easy_strerror ( res ) ) ; if ( http_code == 200 ) { http_code = - res ; } } else { if ( type == STRING ) { * out = strdup ( chunk . memory ) ; } else if ( type == BINKEY ) { * out = malloc ( KEYLEN ) ; * out = memcpy ( * out , chunk . memory , KEYLEN ) ; } else if ( type == BINARY ) { * out = malloc ( chunk . size ) ; * out = memcpy ( * out , chunk . memory , chunk . size ) ; } } * size = chunk . size ; if ( chunk . memory ) { free ( chunk . memory ) ; } return http_code ; }
|
<S2SV_ModStart> chunk ) ; if ( session -> speed_limit ) { <S2SV_ModStart> , CURLOPT_LOW_SPEED_LIMIT , session -> speed_limit ) ; } if ( session -> speed_time ) { <S2SV_ModEnd> curl_easy_setopt ( c <S2SV_ModStart> , CURLOPT_LOW_SPEED_TIME , session -> speed_time ) ; } <S2SV_ModEnd> curl_easy_setopt ( c
|
7,945 |
CWE-000 int proc_pid_readdir ( struct file * file , struct dir_context * ctx ) { struct tgid_iter iter ; struct pid_namespace * ns = file_inode ( file ) -> i_sb -> s_fs_info ; loff_t pos = ctx -> pos ; if ( pos >= PID_MAX_LIMIT + TGID_OFFSET ) return 0 ; if ( pos == TGID_OFFSET - 2 ) { struct inode * inode = d_inode ( ns -> proc_self ) ; if ( ! dir_emit ( ctx , "self" , 4 , inode -> i_ino , DT_LNK ) ) return 0 ; ctx -> pos = pos = pos + 1 ; } if ( pos == TGID_OFFSET - 1 ) { struct inode * inode = d_inode ( ns -> proc_thread_self ) ; if ( ! dir_emit ( ctx , "thread-self" , 11 , inode -> i_ino , DT_LNK ) ) return 0 ; ctx -> pos = pos = pos + 1 ; } iter . tgid = pos - TGID_OFFSET ; iter . task = NULL ; for ( iter = next_tgid ( ns , iter ) ; iter . task ; iter . tgid += 1 , iter = next_tgid ( ns , iter ) ) { char name [ PROC_NUMBUF ] ; int len ; <S2SV_StartBug> if ( ! has_pid_permissions ( ns , iter . task , 2 ) ) <S2SV_EndBug> continue ; len = snprintf ( name , sizeof ( name ) , "%d" , iter . tgid ) ; ctx -> pos = iter . tgid + TGID_OFFSET ; if ( ! proc_fill_cache ( file , ctx , name , len , proc_pid_instantiate , iter . task , NULL ) ) { put_task_struct ( iter . task ) ; return 0 ; } } ctx -> pos = PID_MAX_LIMIT + TGID_OFFSET ; return 0 ; }
|
<S2SV_ModStart> int len ; cond_resched ( ) ;
|
7,946 |
CWE-000 int main ( int argc , char * argv [ ] ) { struct event_base * base = event_base_new ( ) ; struct redis_conf * conf = malloc ( sizeof ( struct redis_conf ) ) ; <S2SV_StartBug> conf -> redis_host = "/tmp/redis_6380.sock" ; <S2SV_EndBug> <S2SV_StartBug> conf -> redis_port = 6380 ; <S2SV_EndBug> conf -> redis_auth = NULL ; conf -> database = - 1 ; conf -> max_conn_retry_times = 10 ; struct redis_pool * pool = redis_pool_new ( base , conf , 5 ) ; redis_pool_init ( pool ) ; struct event ev ; struct timeval tv ; tv . tv_sec = 2 ; tv . tv_usec = 0 ; evtimer_set ( & ev , redis_pool_test , ( void * ) pool ) ; event_base_set ( base , & ev ) ; evtimer_add ( & ev , & tv ) ; event_base_dispatch ( base ) ; <S2SV_StartBug> free_redis_pool ( pool ) ; <S2SV_EndBug> free ( conf ) ; <S2SV_StartBug> event_base_free ( base ) ; <S2SV_EndBug> return 0 ; }
|
<S2SV_ModStart> -> redis_host = "127.0.0.1" <S2SV_ModEnd> ; conf -> <S2SV_ModStart> -> redis_port = 6379 <S2SV_ModEnd> ; conf -> <S2SV_ModStart> base ) ; event_base_free ( base <S2SV_ModEnd> ) ; free <S2SV_ModStart> conf ) ; <S2SV_ModEnd> return 0 ;
|
7,947 |
CWE-000 static void process_adv_report ( struct hci_dev * hdev , u8 type , bdaddr_t * bdaddr , u8 bdaddr_type , bdaddr_t * direct_addr , u8 direct_addr_type , s8 rssi , u8 * data , u8 len ) { struct discovery_state * d = & hdev -> discovery ; struct smp_irk * irk ; struct hci_conn * conn ; bool match ; u32 flags ; u8 * ptr , real_len ; switch ( type ) { case LE_ADV_IND : case LE_ADV_DIRECT_IND : case LE_ADV_SCAN_IND : case LE_ADV_NONCONN_IND : case LE_ADV_SCAN_RSP : break ; default : <S2SV_StartBug> BT_ERR_RATELIMITED ( "Unknown<S2SV_blank>advetising<S2SV_blank>packet<S2SV_blank>type:<S2SV_blank>0x%02x" , <S2SV_EndBug> type ) ; return ; } for ( ptr = data ; ptr < data + len && * ptr ; ptr += * ptr + 1 ) { if ( ptr + 1 + * ptr > data + len ) break ; } real_len = ptr - data ; if ( len != real_len ) { BT_ERR_RATELIMITED ( "%s<S2SV_blank>advertising<S2SV_blank>data<S2SV_blank>length<S2SV_blank>corrected" , hdev -> name ) ; len = real_len ; } if ( direct_addr ) { if ( ! hci_bdaddr_is_rpa ( direct_addr , direct_addr_type ) ) return ; if ( ! hci_dev_test_flag ( hdev , HCI_PRIVACY ) ) return ; if ( ! smp_irk_matches ( hdev , hdev -> irk , direct_addr ) ) return ; } irk = hci_get_irk ( hdev , bdaddr , bdaddr_type ) ; if ( irk ) { bdaddr = & irk -> bdaddr ; bdaddr_type = irk -> addr_type ; } conn = check_pending_le_conn ( hdev , bdaddr , bdaddr_type , type ) ; if ( conn && type == LE_ADV_IND ) { memcpy ( conn -> le_adv_data , data , len ) ; conn -> le_adv_data_len = len ; } if ( hdev -> le_scan_type == LE_SCAN_PASSIVE ) { if ( type == LE_ADV_DIRECT_IND ) return ; if ( ! hci_pend_le_action_lookup ( & hdev -> pend_le_reports , bdaddr , bdaddr_type ) ) return ; if ( type == LE_ADV_NONCONN_IND || type == LE_ADV_SCAN_IND ) flags = MGMT_DEV_FOUND_NOT_CONNECTABLE ; else flags = 0 ; mgmt_device_found ( hdev , bdaddr , LE_LINK , bdaddr_type , NULL , rssi , flags , data , len , NULL , 0 ) ; return ; } if ( type == LE_ADV_NONCONN_IND || type == LE_ADV_SCAN_IND || type == LE_ADV_SCAN_RSP ) flags = MGMT_DEV_FOUND_NOT_CONNECTABLE ; else flags = 0 ; if ( ! has_pending_adv_report ( hdev ) ) { if ( type == LE_ADV_IND || type == LE_ADV_SCAN_IND ) { store_pending_adv_report ( hdev , bdaddr , bdaddr_type , rssi , flags , data , len ) ; return ; } mgmt_device_found ( hdev , bdaddr , LE_LINK , bdaddr_type , NULL , rssi , flags , data , len , NULL , 0 ) ; return ; } match = ( ! bacmp ( bdaddr , & d -> last_adv_addr ) && bdaddr_type == d -> last_adv_addr_type ) ; if ( type != LE_ADV_SCAN_RSP || ! match ) { if ( ! match ) mgmt_device_found ( hdev , & d -> last_adv_addr , LE_LINK , d -> last_adv_addr_type , NULL , d -> last_adv_rssi , d -> last_adv_flags , d -> last_adv_data , d -> last_adv_data_len , NULL , 0 ) ; if ( type == LE_ADV_IND || type == LE_ADV_SCAN_IND ) { store_pending_adv_report ( hdev , bdaddr , bdaddr_type , rssi , flags , data , len ) ; return ; } clear_pending_adv_report ( hdev ) ; mgmt_device_found ( hdev , bdaddr , LE_LINK , bdaddr_type , NULL , rssi , flags , data , len , NULL , 0 ) ; return ; } mgmt_device_found ( hdev , & d -> last_adv_addr , LE_LINK , d -> last_adv_addr_type , NULL , rssi , d -> last_adv_flags , d -> last_adv_data , d -> last_adv_data_len , data , len ) ; clear_pending_adv_report ( hdev ) ; }
|
<S2SV_ModStart> : BT_ERR_RATELIMITED ( "Unknown<S2SV_blank>advertising<S2SV_blank>packet<S2SV_blank>type:<S2SV_blank>0x%02x" <S2SV_ModEnd> , type )
|
7,948 |
CWE-000 static int lxcDomainAttachDeviceHostdevSubsysUSBLive ( virLXCDriverPtr driver , virDomainObjPtr vm , virDomainDeviceDefPtr dev ) { virLXCDomainObjPrivatePtr priv = vm -> privateData ; virDomainHostdevDefPtr def = dev -> data . hostdev ; int ret = - 1 ; char * src = NULL ; struct stat sb ; virUSBDevicePtr usb = NULL ; virDomainHostdevSubsysUSBPtr usbsrc ; if ( virDomainHostdevFind ( vm -> def , def , NULL ) >= 0 ) { virReportError ( VIR_ERR_OPERATION_FAILED , "%s" , _ ( "host<S2SV_blank>USB<S2SV_blank>device<S2SV_blank>already<S2SV_blank>exists" ) ) ; return - 1 ; } usbsrc = & def -> source . subsys . u . usb ; if ( virAsprintf ( & src , "/dev/bus/usb/%03d/%03d" , usbsrc -> bus , usbsrc -> device ) < 0 ) goto cleanup ; if ( ! ( usb = virUSBDeviceNew ( usbsrc -> bus , usbsrc -> device , NULL ) ) ) goto cleanup ; if ( stat ( src , & sb ) < 0 ) { virReportSystemError ( errno , _ ( "Unable<S2SV_blank>to<S2SV_blank>access<S2SV_blank>%s" ) , src ) ; goto cleanup ; } if ( ! S_ISCHR ( sb . st_mode ) ) { virReportError ( VIR_ERR_CONFIG_UNSUPPORTED , _ ( "USB<S2SV_blank>source<S2SV_blank>%s<S2SV_blank>was<S2SV_blank>not<S2SV_blank>a<S2SV_blank>character<S2SV_blank>device" ) , src ) ; goto cleanup ; } if ( VIR_REALLOC_N ( vm -> def -> hostdevs , vm -> def -> nhostdevs + 1 ) < 0 ) goto cleanup ; if ( virUSBDeviceFileIterate ( usb , virLXCSetupHostUSBDeviceCgroup , priv -> cgroup ) < 0 ) goto cleanup ; if ( lxcDomainAttachDeviceMknod ( driver , 0700 | S_IFCHR , sb . st_rdev , vm , dev , src ) < 0 ) { if ( virUSBDeviceFileIterate ( usb , virLXCTeardownHostUSBDeviceCgroup , priv -> cgroup ) < 0 ) <S2SV_StartBug> VIR_WARN ( "cannot<S2SV_blank>deny<S2SV_blank>device<S2SV_blank>%s<S2SV_blank>for<S2SV_blank>domain<S2SV_blank>%s" , <S2SV_EndBug> <S2SV_StartBug> src , vm -> def -> name ) ; <S2SV_EndBug> goto cleanup ; } vm -> def -> hostdevs [ vm -> def -> nhostdevs ++ ] = def ; ret = 0 ; cleanup : virDomainAuditHostdev ( vm , def , "attach" , ret == 0 ) ; virUSBDeviceFree ( usb ) ; VIR_FREE ( src ) ; return ret ; }
|
<S2SV_ModStart> ) VIR_WARN ( "cannot<S2SV_blank>deny<S2SV_blank>device<S2SV_blank>%s<S2SV_blank>for<S2SV_blank>domain<S2SV_blank>%s:<S2SV_blank>%s" <S2SV_ModEnd> , src , <S2SV_ModStart> def -> name , virGetLastErrorMessage ( )
|
7,949 |
CWE-000 static int ceu_set_fmt ( struct ceu_device * ceudev , struct v4l2_format * v4l2_fmt ) { struct ceu_subdev * ceu_sd = ceudev -> sd ; struct v4l2_subdev * v4l2_sd = ceu_sd -> v4l2_sd ; int ret ; struct v4l2_subdev_format format = { <S2SV_StartBug> . which = V4L2_SUBDEV_FORMAT_ACTIVE , <S2SV_EndBug> } ; ret = ceu_try_fmt ( ceudev , v4l2_fmt ) ; if ( ret ) return ret ; v4l2_fill_mbus_format_mplane ( & format . format , & v4l2_fmt -> fmt . pix_mp ) ; ret = v4l2_subdev_call ( v4l2_sd , pad , set_fmt , NULL , & format ) ; if ( ret ) return ret ; ceudev -> v4l2_pix = v4l2_fmt -> fmt . pix_mp ; ceudev -> field = V4L2_FIELD_NONE ; return 0 ; }
|
<S2SV_ModStart> which = V4L2_SUBDEV_FORMAT_ACTIVE , . format = { . code = ceu_sd -> mbus_fmt . mbus_code , }
|
7,950 |
CWE-000 static void intel_crtc_init ( struct drm_device * dev , int pipe ) { drm_i915_private_t * dev_priv = dev -> dev_private ; struct intel_crtc * intel_crtc ; int i ; intel_crtc = kzalloc ( sizeof ( struct intel_crtc ) + ( INTELFB_CONN_LIMIT * sizeof ( struct drm_connector * ) ) , GFP_KERNEL ) ; if ( intel_crtc == NULL ) return ; drm_crtc_init ( dev , & intel_crtc -> base , & intel_crtc_funcs ) ; drm_mode_crtc_set_gamma_size ( & intel_crtc -> base , 256 ) ; for ( i = 0 ; i < 256 ; i ++ ) { intel_crtc -> lut_r [ i ] = i ; intel_crtc -> lut_g [ i ] = i ; intel_crtc -> lut_b [ i ] = i ; } intel_crtc -> pipe = pipe ; intel_crtc -> plane = pipe ; if ( IS_MOBILE ( dev ) && IS_GEN3 ( dev ) ) { DRM_DEBUG_KMS ( "swapping<S2SV_blank>pipes<S2SV_blank>&<S2SV_blank>planes<S2SV_blank>for<S2SV_blank>FBC\\n" ) ; intel_crtc -> plane = ! pipe ; } BUG_ON ( pipe >= ARRAY_SIZE ( dev_priv -> plane_to_crtc_mapping ) || dev_priv -> plane_to_crtc_mapping [ intel_crtc -> plane ] != NULL ) ; dev_priv -> plane_to_crtc_mapping [ intel_crtc -> plane ] = & intel_crtc -> base ; dev_priv -> pipe_to_crtc_mapping [ intel_crtc -> pipe ] = & intel_crtc -> base ; <S2SV_StartBug> intel_crtc -> cursor_addr = 0 ; <S2SV_EndBug> intel_crtc -> dpms_mode = - 1 ; intel_crtc -> active = true ; if ( HAS_PCH_SPLIT ( dev ) ) { intel_helper_funcs . prepare = ironlake_crtc_prepare ; intel_helper_funcs . commit = ironlake_crtc_commit ; } else { intel_helper_funcs . prepare = i9xx_crtc_prepare ; intel_helper_funcs . commit = i9xx_crtc_commit ; } drm_crtc_helper_add ( & intel_crtc -> base , & intel_helper_funcs ) ; intel_crtc -> busy = false ; setup_timer ( & intel_crtc -> idle_timer , intel_crtc_idle_timer , ( unsigned long ) intel_crtc ) ; intel_sanitize_modesetting ( dev , intel_crtc -> pipe , intel_crtc -> plane ) ; }
|
<S2SV_ModStart> -> base ; intel_crtc_reset ( & intel_crtc -> base ) <S2SV_ModEnd> ; if (
|
7,951 |
CWE-000 static bool isHeadLeftChar ( char * str ) { const char * u1 = "\\342\\224\\200" ; const char * u2 = "\\342\\225\\220" ; const char * u3 = "\\342\\225\\236" ; const char * u4 = "\\342\\224\\234" ; const char * u5 = "\\342\\225\\240" ; const char * u6 = "\\342\\225\\237" ; <S2SV_StartBug> if ( str [ 0 ] == '+' || str [ 0 ] == '-' ) <S2SV_EndBug> return true ; if ( str [ 0 ] == '|' && str [ 1 ] == '-' ) return true ; if ( strncmp ( str , u1 , 3 ) == 0 ) return true ; if ( strncmp ( str , u2 , 3 ) == 0 ) return true ; if ( strncmp ( str , u3 , 3 ) == 0 ) return true ; if ( strncmp ( str , u4 , 3 ) == 0 ) return true ; if ( strncmp ( str , u5 , 3 ) == 0 ) return true ; if ( strncmp ( str , u6 , 3 ) == 0 ) return true ; return false ; }
|
<S2SV_ModStart> ; if ( ( <S2SV_ModStart> == '-' ) && str [ 1 ] == '-' )
|
7,952 |
CWE-000 static void passcap_without_msi ( struct bnx * bnx , struct pci_device * pci ) { u32 val ; u8 cap , cur ; <S2SV_StartBug> pci_config_address_t addr ; <S2SV_EndBug> addr = pci -> address ; addr . reg_no = 0x34 >> 2 ; cap = pci_read_config_data8 ( addr , 0 ) ; cur = 0x34 ; bnx -> config_override [ cur ] = cap ; while ( cap >= 0x40 ) { <S2SV_StartBug> addr . reg_no = cap >> 2 ; <S2SV_EndBug> val = pci_read_config_data32 ( addr , 0 ) ; switch ( val & 0xFF ) { case 0x05 : printi ( "[%02x:%02x.%01x]<S2SV_blank>Capabilities<S2SV_blank>[%02x]<S2SV_blank>MSI\\n" , pci -> address . bus_no , pci -> address . device_no , pci -> address . func_no , cap ) ; break ; case 0x11 : printi ( "[%02x:%02x.%01x]<S2SV_blank>Capabilities<S2SV_blank>[%02x]<S2SV_blank>MSI-X\\n" , pci -> address . bus_no , pci -> address . device_no , pci -> address . func_no , cap ) ; break ; default : cur = cap + 1 ; if ( bnx -> config_override [ cur ] ) { printf ( "[%02x:%02x.%01x]<S2SV_blank>Capability<S2SV_blank>loop?\\n" , pci -> address . bus_no , pci -> address . device_no , pci -> address . func_no ) ; return ; } } cap = val >> 8 ; bnx -> config_override [ cur ] = cap ; } }
|
<S2SV_ModStart> , cur ; pci_config_read ( pci , & cap , sizeof cap , 0x34 <S2SV_ModEnd> ) ; cur <S2SV_ModStart> 0x40 ) { pci_config_read ( pci , & val , sizeof val , cap & ~ 3 <S2SV_ModEnd> ) ; switch
|
7,953 |
CWE-000 struct iommu_resv_region * iommu_alloc_resv_region ( phys_addr_t start , size_t length , <S2SV_StartBug> int prot , int type ) <S2SV_EndBug> { struct iommu_resv_region * region ; region = kzalloc ( sizeof ( * region ) , GFP_KERNEL ) ; if ( ! region ) return NULL ; INIT_LIST_HEAD ( & region -> list ) ; region -> start = start ; region -> length = length ; region -> prot = prot ; region -> type = type ; return region ; }
|
<S2SV_ModStart> int prot , enum iommu_resv_type <S2SV_ModEnd> type ) {
|
7,954 |
CWE-000 int ClientConf ( const char * cfgfile ) { int modules = 0 ; int min_eps ; <S2SV_StartBug> agt -> port = NULL ; <S2SV_EndBug> agt -> rip = NULL ; agt -> lip = NULL ; agt -> rip_id = 0 ; agt -> execdq = 0 ; <S2SV_StartBug> agt -> profile = NULL ; <S2SV_EndBug> agt -> protocol = NULL ; agt -> buffer = 1 ; agt -> buflength = 5000 ; agt -> events_persec = 500 ; agt -> flags . auto_restart = 1 ; os_calloc ( 1 , sizeof ( wlabel_t ) , agt -> labels ) ; modules |= CCLIENT ; if ( ReadConfig ( modules , cfgfile , agt , NULL ) < 0 || ReadConfig ( CLABELS | CBUFFER , cfgfile , & agt -> labels , agt ) < 0 ) { return ( OS_INVALID ) ; } # ifdef CLIENT ReadConfig ( CLABELS | CBUFFER | CAGENT_CONFIG , AGENTCONFIG , & agt -> labels , agt ) ; # endif if ( min_eps = getDefine_Int ( "agent" , "min_eps" , 1 , 1000 ) , agt -> events_persec < min_eps ) { mwarn ( "Client<S2SV_blank>buffer<S2SV_blank>throughput<S2SV_blank>too<S2SV_blank>low:<S2SV_blank>set<S2SV_blank>to<S2SV_blank>%d<S2SV_blank>eps" , min_eps ) ; agt -> events_persec = min_eps ; } return ( 1 ) ; }
|
<S2SV_ModStart> ; agt -> server <S2SV_ModEnd> = NULL ; <S2SV_ModStart> agt -> profile <S2SV_ModEnd> = NULL ;
|
7,955 |
CWE-000 void print_arg_string ( Argument * arg ) { <S2SV_StartBug> printf ( "\\t-%-5s/<S2SV_blank>--%-10s\\t:<S2SV_blank>" , arg -> short_opt , arg -> long_opt ) ; <S2SV_EndBug> print_arg_value ( arg ) ; printf ( "\\n" ) ; }
|
<S2SV_ModStart> ( "\\t-%-5s/<S2SV_blank>--%-10s\\t:<S2SV_blank>" , get_short_name ( arg ) , get_long_name ( arg ) <S2SV_ModEnd> ) ; print_arg_value
|
7,956 |
CWE-000 struct page * alloc_huge_page_node ( struct hstate * h , int nid ) { gfp_t gfp_mask = htlb_alloc_mask ( h ) ; struct page * page = NULL ; if ( nid != NUMA_NO_NODE ) gfp_mask |= __GFP_THISNODE ; spin_lock ( & hugetlb_lock ) ; if ( h -> free_huge_pages - h -> resv_huge_pages > 0 ) page = dequeue_huge_page_nodemask ( h , gfp_mask , nid , NULL ) ; spin_unlock ( & hugetlb_lock ) ; if ( ! page ) <S2SV_StartBug> page = __alloc_buddy_huge_page ( h , gfp_mask , nid , NULL ) ; <S2SV_EndBug> return page ; }
|
<S2SV_ModStart> ) page = __alloc_migrate_huge_page <S2SV_ModEnd> ( h ,
|
7,957 |
CWE-000 int PEER ( char * buf ) { char name [ 200 ] ; char port [ 6 ] ; char ip [ 17 ] ; bzero ( name , 200 ) ; bzero ( port , 6 ) ; bzero ( ip , 17 ) ; int index = 0 ; while ( buf [ index ] != ':' ) { index ++ ; } int offset = 0 ; index ++ ; while ( buf [ index ] != ':' ) { name [ offset ++ ] = buf [ index ++ ] ; } offset = 0 ; <S2SV_StartBug> index ++ ; <S2SV_EndBug> while ( buf [ index ] != ':' ) { port [ offset ++ ] = buf [ index ++ ] ; } offset = 0 ; <S2SV_StartBug> index ++ ; <S2SV_EndBug> while ( buf [ index ] != '%' ) { ip [ offset ++ ] = buf [ index ++ ] ; } <S2SV_StartBug> int lineToUpdate = isKnown ( name ) ; <S2SV_EndBug> if ( lineToUpdate ) { if ( updateFile ( name , lineToUpdate ) == - 1 ) { return - 1 ; } } else { FILE * fpeers ; fpeers = fopen ( "fpeerstest.txt" , "a" ) ; fprintf ( fpeers , "BEGIN\\n" ) ; fprintf ( fpeers , "1:%s\\n" , name ) ; fprintf ( fpeers , "2:%s\\n" , port ) ; fprintf ( fpeers , "3:%s\\n" , ip ) ; fprintf ( fpeers , "END\\n" ) ; if ( fclose ( fpeers ) ) { error ( "File<S2SV_blank>not<S2SV_blank>closed<S2SV_blank>properly" ) ; return - 1 ; } } return 0 ; }
|
<S2SV_ModStart> 0 ; index += 6 <S2SV_ModEnd> ; while ( <S2SV_ModStart> 0 ; index += 4 <S2SV_ModEnd> ; while ( <S2SV_ModStart> isKnown ( name , "fpeerstest.txt"
|
7,958 |
CWE-000 static int s6e3ha2_probe ( struct mipi_dsi_device * dsi ) { struct device * dev = & dsi -> dev ; struct s6e3ha2 * ctx ; int ret ; ctx = devm_kzalloc ( dev , sizeof ( * ctx ) , GFP_KERNEL ) ; if ( ! ctx ) return - ENOMEM ; mipi_dsi_set_drvdata ( dsi , ctx ) ; <S2SV_StartBug> ctx -> dev = dev ; <S2SV_EndBug> dsi -> lanes = 4 ; dsi -> format = MIPI_DSI_FMT_RGB888 ; dsi -> mode_flags = MIPI_DSI_CLOCK_NON_CONTINUOUS ; ctx -> supplies [ 0 ] . supply = "vdd3" ; ctx -> supplies [ 1 ] . supply = "vci" ; ret = devm_regulator_bulk_get ( dev , ARRAY_SIZE ( ctx -> supplies ) , ctx -> supplies ) ; if ( ret < 0 ) { dev_err ( dev , "failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>regulators:<S2SV_blank>%d\\n" , ret ) ; return ret ; } ctx -> reset_gpio = devm_gpiod_get ( dev , "reset" , GPIOD_OUT_LOW ) ; if ( IS_ERR ( ctx -> reset_gpio ) ) { dev_err ( dev , "cannot<S2SV_blank>get<S2SV_blank>reset-gpios<S2SV_blank>%ld\\n" , PTR_ERR ( ctx -> reset_gpio ) ) ; return PTR_ERR ( ctx -> reset_gpio ) ; } ctx -> enable_gpio = devm_gpiod_get ( dev , "enable" , GPIOD_OUT_HIGH ) ; if ( IS_ERR ( ctx -> enable_gpio ) ) { dev_err ( dev , "cannot<S2SV_blank>get<S2SV_blank>enable-gpios<S2SV_blank>%ld\\n" , PTR_ERR ( ctx -> enable_gpio ) ) ; return PTR_ERR ( ctx -> enable_gpio ) ; } ctx -> bl_dev = backlight_device_register ( "s6e3ha2" , dev , ctx , & s6e3ha2_bl_ops , NULL ) ; if ( IS_ERR ( ctx -> bl_dev ) ) { dev_err ( dev , "failed<S2SV_blank>to<S2SV_blank>register<S2SV_blank>backlight<S2SV_blank>device\\n" ) ; return PTR_ERR ( ctx -> bl_dev ) ; } ctx -> bl_dev -> props . max_brightness = S6E3HA2_MAX_BRIGHTNESS ; ctx -> bl_dev -> props . brightness = S6E3HA2_DEFAULT_BRIGHTNESS ; ctx -> bl_dev -> props . power = FB_BLANK_POWERDOWN ; drm_panel_init ( & ctx -> panel ) ; ctx -> panel . dev = dev ; ctx -> panel . funcs = & s6e3ha2_drm_funcs ; ret = drm_panel_add ( & ctx -> panel ) ; if ( ret < 0 ) goto unregister_backlight ; ret = mipi_dsi_attach ( dsi ) ; if ( ret < 0 ) goto remove_panel ; return ret ; remove_panel : drm_panel_remove ( & ctx -> panel ) ; unregister_backlight : backlight_device_unregister ( ctx -> bl_dev ) ; return ret ; }
|
<S2SV_ModStart> dev = dev ; ctx -> desc = of_device_get_match_data ( dev )
|
7,959 |
CWE-000 int min ( int x , int y ) { <S2SV_StartBug> return ( x < y ) ? x : y <S2SV_EndBug> }
|
<S2SV_ModStart> x : y ;
|
7,960 |
CWE-000 void genX ( CmdDraw ) ( VkCommandBuffer commandBuffer , uint32_t vertexCount , uint32_t instanceCount , uint32_t firstVertex , uint32_t firstInstance ) { ANV_FROM_HANDLE ( anv_cmd_buffer , cmd_buffer , commandBuffer ) ; struct anv_pipeline * pipeline = cmd_buffer -> state . gfx . base . pipeline ; const struct brw_vs_prog_data * vs_prog_data = get_vs_prog_data ( pipeline ) ; if ( anv_batch_has_error ( & cmd_buffer -> batch ) ) return ; genX ( cmd_buffer_flush_state ) ( cmd_buffer ) ; if ( vs_prog_data -> uses_firstvertex || vs_prog_data -> uses_baseinstance ) emit_base_vertex_instance ( cmd_buffer , firstVertex , firstInstance ) ; if ( vs_prog_data -> uses_drawid ) emit_draw_index ( cmd_buffer , 0 ) ; instanceCount *= anv_subpass_view_count ( cmd_buffer -> state . subpass ) ; anv_batch_emit ( & cmd_buffer -> batch , GENX ( 3DPRIMITIVE ) , prim ) { prim . VertexAccessType = SEQUENTIAL ; prim . PrimitiveTopologyType = pipeline -> topology ; prim . VertexCountPerInstance = vertexCount ; prim . StartVertexLocation = firstVertex ; prim . InstanceCount = instanceCount ; prim . StartInstanceLocation = firstInstance ; prim . BaseVertexLocation = 0 ; } <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> 0 ; } cmd_buffer -> state . pending_pipe_bits |= ANV_PIPE_RENDER_TARGET_WRITES ;
|
7,961 |
CWE-000 int check_plan ( t_obj * cam , t_calc * v , t_obj * cord ) { double dir ; int xl ; int yl ; int zl ; <S2SV_StartBug> xl = cam -> x - cord -> x ; <S2SV_EndBug> <S2SV_StartBug> yl = cam -> y - cord -> y ; <S2SV_EndBug> <S2SV_StartBug> zl = cam -> z - cord -> z ; <S2SV_EndBug> <S2SV_StartBug> dir = - ( ( cord -> dir [ 0 ] * xl + cord -> dir [ 1 ] * yl + cord -> dir [ 2 ] * zl ) <S2SV_EndBug> <S2SV_StartBug> / ( cord -> dir [ 0 ] * cam -> dir [ 0 ] + cord -> dir [ 1 ] * cam -> dir [ 1 ] <S2SV_EndBug> + cord -> dir [ 2 ] * cam -> dir [ 2 ] ) ) ; if ( dir > 0.00000001 && dir < 20000 ) { if ( v -> t <= dir && v -> t != 0 ) return ( 1 ) ; v -> t = dir ; } return ( 0 ) ; }
|
<S2SV_ModStart> = cam -> pos -> <S2SV_ModStart> x - cord -> pos <S2SV_ModStart> = cam -> pos -> <S2SV_ModStart> y - cord -> pos <S2SV_ModStart> = cam -> pos -> <S2SV_ModStart> z - cord -> pos <S2SV_ModStart> cord -> dir -> x <S2SV_ModEnd> * xl + <S2SV_ModStart> cord -> dir -> y <S2SV_ModEnd> * yl + <S2SV_ModStart> cord -> dir -> z <S2SV_ModEnd> * zl ) <S2SV_ModStart> zl ) / dot_product <S2SV_ModStart> cord -> dir , <S2SV_ModEnd> cam -> dir <S2SV_ModStart> cam -> dir <S2SV_ModEnd> ) ) ;
|
7,962 |
CWE-000 int main ( ) { float val = 0 ; char str [ 5 ] ; strcpy ( str , "3.14" ) ; <S2SV_StartBug> val = atoi ( str ) ; <S2SV_EndBug> printf ( "String<S2SV_blank>value:<S2SV_blank>%s<S2SV_blank>,<S2SV_blank>float<S2SV_blank>value:<S2SV_blank>%.2f" , str , val ) ; return ( 0 ) ; }
|
<S2SV_ModStart> ; val = atof <S2SV_ModEnd> ( str )
|
7,963 |
CWE-000 oc_clock_time_t oc_clock_time ( void ) { <S2SV_StartBug> oc_clock_time_t time = 0 ; <S2SV_EndBug> struct timespec t ; if ( clock_gettime ( CLOCK_REALTIME , & t ) != - 1 ) { time = ( oc_clock_time_t ) t . tv_sec * OC_CLOCK_SECOND + ( oc_clock_time_t ) ceil ( t . tv_nsec / ( 1.e09 / OC_CLOCK_SECOND ) ) ; } <S2SV_StartBug> return time ; <S2SV_EndBug> }
|
<S2SV_ModStart> void ) { return mach_absolute_time ( ) / oc_clock_mac_get_clocks_per_microsec ( <S2SV_ModEnd> ) ; } <S2SV_ModStart> ) ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null>
|
7,964 |
CWE-000 int suspend_devices_and_enter ( suspend_state_t state ) { int error ; bool wakeup = false ; if ( need_suspend_ops ( state ) && ! suspend_ops ) return - ENOSYS ; trace_machine_suspend ( state ) ; if ( need_suspend_ops ( state ) && suspend_ops -> begin ) { error = suspend_ops -> begin ( state ) ; if ( error ) goto Close ; } suspend_console ( ) ; ftrace_stop ( ) ; suspend_test_start ( ) ; error = dpm_suspend_start ( PMSG_SUSPEND ) ; if ( error ) { pr_err ( "PM:<S2SV_blank>Some<S2SV_blank>devices<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>suspend,<S2SV_blank>or<S2SV_blank>early<S2SV_blank>wake<S2SV_blank>event<S2SV_blank>detected\\n" ) ; log_suspend_abort_reason ( "Some<S2SV_blank>devices<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>suspend" ) ; goto Recover_platform ; } suspend_test_finish ( "suspend<S2SV_blank>devices" ) ; if ( suspend_test ( TEST_DEVICES ) ) goto Recover_platform ; do { error = suspend_enter ( state , & wakeup ) ; } while ( ! error && ! wakeup && need_suspend_ops ( state ) <S2SV_StartBug> && suspend_ops -> suspend_again && suspend_ops -> suspend_again ( ) ) ; <S2SV_EndBug> Resume_devices : suspend_test_start ( ) ; dpm_resume_end ( PMSG_RESUME ) ; suspend_test_finish ( "resume<S2SV_blank>devices" ) ; ftrace_start ( ) ; resume_console ( ) ; Close : if ( need_suspend_ops ( state ) && suspend_ops -> end ) suspend_ops -> end ( ) ; trace_machine_suspend ( PWR_EVENT_EXIT ) ; return error ; Recover_platform : if ( need_suspend_ops ( state ) && suspend_ops -> recover ) suspend_ops -> recover ( ) ; goto Resume_devices ; }
|
<S2SV_ModStart> state ) && platform_suspend_again <S2SV_ModEnd> ( ) )
|
7,965 |
CWE-000 <S2SV_StartBug> static int crypt_mod_pgp_send_menu ( HEADER * msg , int * redraw ) <S2SV_EndBug> { <S2SV_StartBug> return pgp_send_menu ( msg , redraw ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> HEADER * msg <S2SV_ModEnd> ) { return <S2SV_ModStart> pgp_send_menu ( msg <S2SV_ModEnd> ) ; }
|
7,966 |
CWE-000 char * * createNullTerminatedStrings ( char * text , size_t bytes , int * numLines ) { if ( numLines && text ) { * numLines = 0 ; char * zeroedText = malloc ( bytes ) ; memcpy ( zeroedText , text , bytes ) ; for ( int i = 0 ; i < bytes ; i ++ ) { if ( zeroedText [ i ] == '\\n' ) { zeroedText [ i ] = 0 ; ++ * numLines ; } } <S2SV_StartBug> char * * lines = malloc ( * numLines * sizeof ( char * ) ) ; <S2SV_EndBug> for ( int i = 0 ; i < * numLines ; i ++ ) { size_t linelen = bytelen ( zeroedText ) + 1 ; lines [ i ] = malloc ( linelen ) ; memcpy ( lines [ i ] , zeroedText , linelen ) ; zeroedText += linelen ; } <S2SV_StartBug> return lines ; <S2SV_EndBug> } else { <S2SV_StartBug> return 0 ; <S2SV_EndBug> } <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> ; } } if ( * numLines > 0 ) { <S2SV_ModStart> * ) ) ; char * zeroedstart = zeroedText <S2SV_ModStart> linelen ; } if ( zeroedstart ) { free ( zeroedstart ) ; } <S2SV_ModStart> } else { if ( zeroedText ) { free ( zeroedText ) ; } <S2SV_ModStart> ; } } else { return 0 ; } }
|
7,967 |
CWE-000 void populate_pressure_information ( struct dive * dive , struct divecomputer * dc , struct plot_info * pi , int sensor ) { ( void ) dc ; int first , last , cyl ; cylinder_t * cylinder = dive -> cylinder + sensor ; pr_track_t * track = NULL ; pr_track_t * current = NULL ; struct plot_data * entry ; struct event * ev ; int missing_pr = 0 , dense = 1 ; if ( ! cylinder -> start . mbar && ! cylinder -> end . mbar && ! cylinder -> sample_start . mbar && ! cylinder -> sample_end . mbar ) return ; first = last = - 1 ; for ( int i = 0 ; i < pi -> nr ; i ++ ) { struct plot_data * entry = pi -> entry + i ; unsigned pressure = SENSOR_PRESSURE ( entry , sensor ) ; if ( ! pressure ) continue ; if ( first < 0 ) first = i ; last = i ; } if ( first == last ) return ; cyl = sensor ; ev = NULL ; if ( has_gaschange_event ( dive , dc , sensor ) ) ev = get_next_event ( dc -> events , "gaschange" ) ; for ( int i = first ; i <= last ; i ++ ) { struct plot_data * entry = pi -> entry + i ; unsigned pressure = SENSOR_PRESSURE ( entry , sensor ) ; int time = entry -> sec ; while ( ev && ev -> time . seconds <= time ) { cyl = get_cylinder_index ( dive , ev ) ; if ( cyl < 0 ) cyl = sensor ; ev = get_next_event ( ev -> next , "gaschange" ) ; } if ( current ) { entry -> pressure_time = calc_pressure_time ( dive , entry - 1 , entry ) ; current -> pressure_time += entry -> pressure_time ; current -> t_end = entry -> sec ; if ( pressure ) current -> end = pressure ; } <S2SV_StartBug> if ( ! pressure ) { <S2SV_EndBug> missing_pr = 1 ; dense = 0 ; continue ; } if ( cyl != sensor ) { current = NULL ; <S2SV_StartBug> SENSOR_PRESSURE ( entry , sensor ) = 0 ; <S2SV_EndBug> continue ; } if ( current && dense ) continue ; current = pr_track_alloc ( pressure , entry -> sec ) ; track = list_add ( track , current ) ; dense = 1 ; } if ( missing_pr ) { fill_missing_tank_pressures ( dive , pi , track , sensor ) ; } # ifdef PRINT_PRESSURES_DEBUG debug_print_pressures ( pi ) ; # endif list_free ( track ) ; }
|
<S2SV_ModStart> } if ( <S2SV_ModEnd> cyl != sensor <S2SV_ModStart> , sensor ) = 0 ; continue ; } if ( current && ! pressure ) { missing_pr = 1 ; dense
|
7,968 |
CWE-000 static void ngx_worker_process_exit ( ngx_cycle_t * cycle ) { ngx_uint_t i ; ngx_connection_t * c ; for ( i = 0 ; cycle -> modules [ i ] ; i ++ ) { if ( cycle -> modules [ i ] -> exit_process ) { cycle -> modules [ i ] -> exit_process ( cycle ) ; } } if ( ngx_exiting ) { c = cycle -> connections ; for ( i = 0 ; i < cycle -> connection_n ; i ++ ) { if ( c [ i ] . fd != - 1 && c [ i ] . read && ! c [ i ] . read -> accept && ! c [ i ] . read -> channel && ! c [ i ] . read -> resolver ) { ngx_log_error ( NGX_LOG_ALERT , cycle -> log , 0 , "*%uA<S2SV_blank>open<S2SV_blank>socket<S2SV_blank>#%d<S2SV_blank>left<S2SV_blank>in<S2SV_blank>connection<S2SV_blank>%ui" , c [ i ] . number , c [ i ] . fd , i ) ; ngx_debug_quit = 1 ; } } if ( ngx_debug_quit ) { ngx_log_error ( NGX_LOG_ALERT , cycle -> log , 0 , "aborting" ) ; ngx_debug_point ( ) ; } } ngx_exit_log = * ngx_log_get_file_log ( ngx_cycle -> log ) ; ngx_exit_log_file . fd = ngx_exit_log . file -> fd ; ngx_exit_log . file = & ngx_exit_log_file ; ngx_exit_log . next = NULL ; ngx_exit_log . writer = NULL ; ngx_exit_cycle . log = & ngx_exit_log ; ngx_exit_cycle . files = ngx_cycle -> files ; ngx_exit_cycle . files_n = ngx_cycle -> files_n ; ngx_cycle = & ngx_exit_cycle ; ngx_destroy_pool ( cycle -> pool ) ; ngx_log_error ( NGX_LOG_NOTICE , ngx_cycle -> log , 0 , "exit" ) ; # if ( NGX_HAVE_FSTACK ) <S2SV_StartBug> if ( ngx_ff_primary ) { <S2SV_EndBug> ngx_msleep ( 500 ) ; } # endif exit ( 0 ) ; }
|
<S2SV_ModStart> ) if ( ngx_ff_process == NGX_FF_PROCESS_PRIMARY <S2SV_ModEnd> ) { ngx_msleep
|
7,969 |
CWE-000 void gt_diagband_statistics_add ( void * v_diagband_statistics , const GtEncseq * aencseq , const GtEncseq * bencseq , GT_UNUSED GtUword aseqnum , GT_UNUSED GtUword bseqnum , const GtDiagbandStruct * diagband_struct , const GtDiagbandseedMaximalmatch * memstore , unsigned int seedlength , const GtSeedpairPositions * seedstore , GtUword segment_length ) { GtUword idx ; GtDiagbandStatistics * diagband_statistics = ( GtDiagbandStatistics * ) v_diagband_statistics ; if ( diagband_statistics -> track == NULL ) { GT_INITBITTAB ( diagband_statistics -> track , diagband_struct -> num_diagbands ) ; } else { GT_CLEARBITTAB ( diagband_statistics -> track , diagband_struct -> num_diagbands ) ; } if ( seedstore != NULL ) { amaxlen = diagband_struct -> amaxlen ; logdiagbandwidth = diagband_struct -> logdiagbandwidth ; GtUword curr_diagband_idx , prev_diagband_idx , count = 0 , size = 0 ; GtSeedpairPositions * seedstore2 = gt_malloc ( sizeof ( * seedstore2 ) * segment_length ) ; seedstore2 = memcpy ( seedstore2 , seedstore , segment_length * sizeof ( * seedstore ) ) ; qsort ( seedstore2 , segment_length , sizeof ( GtSeedpairPositions ) , compare_seeds_by_diags ) ; SeedArea * seed_area = gt_malloc ( diagband_struct -> used_diagbands * sizeof ( * seed_area ) ) ; size = diagband_struct -> used_diagbands ; prev_diagband_idx = GT_DIAGBANDSEED_DIAGONALBAND ( diagband_struct -> amaxlen , diagband_struct -> logdiagbandwidth , seedstore2 [ 0 ] . apos , seedstore2 [ 0 ] . bpos ) ; seed_area [ 0 ] . abegin = seedstore2 [ 0 ] . apos - seedlength ; seed_area [ 0 ] . bbegin = seedstore2 [ 0 ] . bpos - seedlength ; seed_area [ 0 ] . aend = seedstore2 [ 0 ] . apos ; seed_area [ 0 ] . bend = seedstore2 [ 0 ] . bpos ; seed_area [ 0 ] . diagidx = prev_diagband_idx ; count ++ ; for ( idx = 1 ; idx < segment_length ; idx ++ ) { curr_diagband_idx = GT_DIAGBANDSEED_DIAGONALBAND ( diagband_struct -> amaxlen , diagband_struct -> logdiagbandwidth , seedstore2 [ idx ] . apos , seedstore2 [ idx ] . bpos ) ; if ( curr_diagband_idx == prev_diagband_idx ) { <S2SV_StartBug> GtUword bbegin = seedstore2 [ idx ] . bpos - seedlength ; <S2SV_EndBug> <S2SV_StartBug> if ( seed_area [ idx - 1 ] . bend + 1 <= bbegin ) <S2SV_EndBug> { <S2SV_StartBug> if ( seed_area [ idx - 1 ] . bend < seedstore2 [ idx ] . bpos ) <S2SV_EndBug> { <S2SV_StartBug> seed_area [ count ] . aend = seedstore2 [ idx ] . apos ; <S2SV_EndBug> <S2SV_StartBug> seed_area [ count ] . bend = seedstore2 [ idx ] . bpos ; <S2SV_EndBug> } } else { if ( count == size ) { size += SIZE ; seed_area = gt_realloc ( seed_area , sizeof ( * seed_area ) * size ) ; } seed_area [ count ] . abegin = seedstore2 [ idx ] . apos - seedlength + 1 ; seed_area [ count ] . bbegin = seedstore2 [ idx ] . bpos - seedlength + 1 ; seed_area [ count ] . aend = seedstore2 [ idx ] . apos ; seed_area [ count ] . bend = seedstore2 [ idx ] . bpos ; seed_area [ count ] . diagidx = curr_diagband_idx ; count ++ ; } } else { if ( count == size ) { size += SIZE ; seed_area = gt_realloc ( seed_area , sizeof ( * seed_area ) * size ) ; } seed_area [ count ] . abegin = seedstore2 [ idx ] . apos - seedlength + 1 ; seed_area [ count ] . bbegin = seedstore2 [ idx ] . bpos - seedlength + 1 ; seed_area [ count ] . aend = seedstore2 [ idx ] . apos ; seed_area [ count ] . bend = seedstore2 [ idx ] . bpos ; seed_area [ count ] . diagidx = curr_diagband_idx ; count ++ ; } <S2SV_StartBug> } <S2SV_EndBug> gt_free ( seedstore2 ) ; qsort ( seed_area , count , sizeof ( SeedArea ) , compare_seeds_by_bstart ) ; SeedArea * pre_area = & seed_area [ 0 ] ; GtUword nextstart_min = pre_area -> bend + 1 , mismatches = 0 , len = 0 , jdx ; bool anchor = false ; for ( idx = 1 ; idx < count ; idx ++ ) { if ( seed_area [ idx ] . bbegin < nextstart_min ) continue ; if ( seed_area [ idx ] . diagidx != pre_area -> diagidx ) { if ( anchor ) len += pre_area -> bend - pre_area -> bbegin + 1 ; pre_area = & seed_area [ idx ] ; nextstart_min = pre_area -> bend + 1 ; anchor = false ; } else { GtUword range = seed_area [ idx ] . bbegin - pre_area -> bend + 1 ; for ( jdx = 0 ; jdx < range ; jdx ++ ) { len ++ ; if ( gt_encseq_get_encoded_char ( aencseq , pre_area -> aend + 1 + jdx , GT_READMODE_FORWARD ) != gt_encseq_get_encoded_char ( bencseq , pre_area -> bend + 1 + jdx , GT_READMODE_FORWARD ) ) { mismatches ++ ; } } pre_area = & seed_area [ idx ] ; nextstart_min = pre_area -> bend + 1 ; anchor = true ; } } printf ( "substitutions<S2SV_blank>per<S2SV_blank>site:<S2SV_blank>%f\\n" , mismatches / ( float ) len ) ; gt_free ( seed_area ) ; } else { for ( idx = 0 ; idx < segment_length ; idx ++ ) { const GtUword diagband_idx = GT_DIAGBANDSEED_DIAGONALBAND ( diagband_struct -> amaxlen , diagband_struct -> logdiagbandwidth , memstore [ idx ] . apos , memstore [ idx ] . bpos ) ; gt_diagband_statistics_score_add ( diagband_statistics , diagband_struct , diagband_idx ) ; } } }
|
<S2SV_ModStart> prev_diagband_idx ) { gt_assert ( count > 0 ) ; <S2SV_ModStart> ( seed_area [ count - 1 ] . bend + 1 >= <S2SV_ModEnd> bbegin ) { <S2SV_ModStart> ( seed_area [ count <S2SV_ModEnd> - 1 ] <S2SV_ModStart> seed_area [ count - 1 <S2SV_ModStart> seed_area [ count - 1 <S2SV_ModStart> ++ ; } prev_diagband_idx = curr_diagband_idx ;
|
7,970 |
CWE-000 int inter_make_op ( int inter_op_type , int num , ... ) { va_list valist ; va_start ( valist , num ) ; int k [ 10 ] ; int i ; for ( i = 0 ; i < num ; i ++ ) k [ i ] = va_arg ( valist , int ) ; char * op_name , * relop ; char op_str [ MAX_VAR_LEN ] ; int result_op = - 1 , op_num ; char vars1 [ MAX_VAR_LEN ] , vars2 [ MAX_VAR_LEN ] , labels [ MAX_VAR_LEN ] , vars3 [ MAX_VAR_LEN ] , funcs [ MAX_VAR_LEN ] ; int var_id1 , var_id2 , var_id3 , label , func_id ; int pass_flag = false ; switch ( inter_op_type ) { case IOP_IF_LEQ : if ( ! pass_flag ) relop = "<=" ; pass_flag = true ; case IOP_IF_L : if ( ! pass_flag ) relop = "<" ; pass_flag = true ; case IOP_IF_G : if ( ! pass_flag ) relop = ">" ; pass_flag = true ; case IOP_IF_GEQ : if ( ! pass_flag ) relop = ">=" ; pass_flag = true ; case IOP_IF_EQ : if ( ! pass_flag ) relop = "==" ; pass_flag = true ; case IOP_IF_NE : if ( ! pass_flag ) relop = "!=" ; pass_flag = true ; var_id1 = k [ 0 ] ; var_id2 = k [ 1 ] ; label = k [ 2 ] ; inter_var_name ( var_id1 , vars1 ) ; inter_var_name ( var_id2 , vars2 ) ; inter_label_name ( label , labels ) ; sprintf ( op_str , "IF<S2SV_blank>%s<S2SV_blank>%s<S2SV_blank>%s<S2SV_blank>GOTO<S2SV_blank>%s" , vars1 , relop , vars2 , labels ) ; op_num = inter_add_op ( op_str ) ; result_op = op_num ; break ; case IOP_LABEL : label = k [ 0 ] ; inter_label_name ( label , labels ) ; sprintf ( op_str , "LABEL<S2SV_blank>%s<S2SV_blank>:" , labels ) ; op_num = inter_add_op ( op_str ) ; result_op = op_num ; break ; case IOP_GOTO : label = k [ 0 ] ; inter_label_name ( label , labels ) ; sprintf ( op_str , "GOTO<S2SV_blank>%s<S2SV_blank>:" , labels ) ; op_num = inter_add_op ( op_str ) ; result_op = op_num ; break ; case IOP_ARG : if ( ! pass_flag ) op_name = "ARG" ; pass_flag = true ; case IOP_PARAM : if ( ! pass_flag ) op_name = "PARAM" ; pass_flag = true ; case IOP_RETURN : if ( ! pass_flag ) op_name = "RETURN" ; pass_flag = true ; case IOP_READ : if ( ! pass_flag ) op_name = "READ" ; pass_flag = true ; case IOP_WRITE : if ( ! pass_flag ) op_name = "WRITE" ; pass_flag = true ; var_id1 = k [ 0 ] ; inter_var_name ( var_id1 , vars1 ) ; sprintf ( op_str , "%s<S2SV_blank>%s" , op_name , vars1 ) ; op_num = inter_add_op ( op_str ) ; result_op = op_num ; break ; case IOP_FUNC : func_id = k [ 0 ] ; inter_func_name ( func_id , funcs ) ; sprintf ( op_str , "FUNCTION<S2SV_blank>%s<S2SV_blank>:" , funcs ) ; int op_num = inter_add_op ( op_str ) ; result_op = op_num ; break ; case IOP_ADD : if ( ! pass_flag ) op_name = "+" ; pass_flag = true ; case IOP_DIV : if ( ! pass_flag ) op_name = "/" ; pass_flag = true ; case IOP_MUL : if ( ! pass_flag ) op_name = "*" ; pass_flag = true ; case IOP_MINUS : if ( ! pass_flag ) op_name = "-" ; pass_flag = true ; var_id1 = k [ 0 ] ; var_id2 = k [ 1 ] ; var_id3 = k [ 2 ] ; inter_var_name ( var_id1 , vars1 ) ; inter_var_name ( var_id2 , vars2 ) ; inter_var_name ( var_id3 , vars3 ) ; sprintf ( op_str , "%s<S2SV_blank>:=<S2SV_blank>%s<S2SV_blank>%s<S2SV_blank>%s" , vars1 , vars2 , op_name , vars3 ) ; op_num = inter_add_op ( op_str ) ; result_op = op_num ; break ; case IOP_CALL : var_id1 = k [ 0 ] ; func_id = k [ 1 ] ; inter_var_name ( var_id1 , vars1 ) ; inter_func_name ( func_id , funcs ) ; sprintf ( op_str , "%s<S2SV_blank>:=<S2SV_blank>CALL<S2SV_blank>%s" , vars1 , funcs ) ; op_num = inter_add_op ( op_str ) ; result_op = op_num ; break ; case IOP_ASSIGN : var_id1 = k [ 0 ] ; var_id2 = k [ 1 ] ; inter_var_name ( var_id1 , vars1 ) ; inter_var_name ( var_id2 , vars2 ) ; sprintf ( op_str , "%s<S2SV_blank>:=<S2SV_blank>%s" , vars1 , vars2 ) ; op_num = inter_add_op ( op_str ) ; result_op = op_num ; break ; case IOP_AT : var_id1 = k [ 0 ] ; var_id2 = k [ 1 ] ; vars1 [ MAX_VAR_LEN ] , vars2 [ MAX_VAR_LEN ] ; inter_var_name ( var_id1 , vars1 ) ; inter_var_name ( var_id2 , vars2 ) ; sprintf ( op_str , "%s<S2SV_blank>:=<S2SV_blank>&<S2SV_blank>%s" , vars1 , vars2 ) ; op_num = inter_add_op ( op_str ) ; result_op = op_num ; break ; case IOP_LSTAR : var_id1 = k [ 0 ] ; var_id2 = k [ 1 ] ; vars1 [ MAX_VAR_LEN ] , vars2 [ MAX_VAR_LEN ] ; inter_var_name ( var_id1 , vars1 ) ; inter_var_name ( var_id2 , vars2 ) ; sprintf ( op_str , "*%s<S2SV_blank>:=<S2SV_blank>%s" , vars1 , vars2 ) ; op_num = inter_add_op ( op_str ) ; result_op = op_num ; break ; case IOP_RSTAR : var_id1 = k [ 0 ] ; var_id2 = k [ 1 ] ; vars1 [ MAX_VAR_LEN ] ; vars2 [ MAX_VAR_LEN ] ; inter_var_name ( var_id1 , vars1 ) ; inter_var_name ( var_id2 , vars2 ) ; sprintf ( op_str , "%s<S2SV_blank>:=<S2SV_blank>*%s" , vars1 , vars2 ) ; op_num = inter_add_op ( op_str ) ; result_op = op_num ; break ; } <S2SV_StartBug> int result_block = inter_new_op_block ( result_op , result_op ) ; <S2SV_EndBug> return result_block ; }
|
<S2SV_ModStart> break ; } return result_op <S2SV_ModEnd> ; } <S2SV_null>
|
7,971 |
CWE-000 void load_program ( char * array ) { char * space_ptr = strchr ( array , '<S2SV_blank>' ) ; uint8_t part_fun = 0 ; <S2SV_StartBug> uint8_t nested = 0 ; <S2SV_EndBug> size_t space ; size_t bracket = 0 ; size_t d_bracket ; if ( space_ptr == NULL ) error ( "No<S2SV_blank>spaces<S2SV_blank>in<S2SV_blank>the<S2SV_blank>program\\n" ) ; while ( space_ptr != NULL ) { space = ( size_t ) ( space_ptr - ( array + bracket + 1 ) ) / sizeof ( unsigned char ) ; space_ptr = ( char * ) calloc ( space , sizeof ( unsigned char ) ) ; strncpy ( space_ptr , array + bracket + 1 , space ) ; if ( ! part_fun ) standard_coms ( space_ptr ) ; <S2SV_StartBug> else <S2SV_EndBug> <S2SV_StartBug> user_coms ( space_ptr , & nested ) ; <S2SV_EndBug> free ( space_ptr ) ; if ( token . type == 1 && token . repr == '+' ) { if ( part_fun ) error ( "Defun<S2SV_blank>called<S2SV_blank>in<S2SV_blank>a<S2SV_blank>defun\\n" ) ; space_ptr = strchr ( array + bracket + 1 , ')' ) ; d_bracket = ( size_t ) ( space_ptr - ( array + bracket + 1 + space ) ) / sizeof ( unsigned char ) ; space_ptr = ( char * ) calloc ( d_bracket , sizeof ( unsigned char ) ) ; strncpy ( space_ptr , array + bracket + 2 + space , d_bracket ) ; add_fun ( space_ptr ) ; free ( space_ptr ) ; bracket = d_bracket ; part_fun = 1 ; } space_ptr = strchr ( array + bracket + 1 , '(' ) ; if ( space_ptr == NULL ) break ; bracket = ( size_t ) ( space_ptr - array ) / sizeof ( unsigned char ) ; space_ptr = strchr ( array + bracket , '<S2SV_blank>' ) ; } }
|
<S2SV_ModStart> = 0 ; int8_t nested = 1 <S2SV_ModEnd> ; size_t space <S2SV_ModStart> ) ; else { check_function_layer ( array + bracket + 1 , & nested ) ; <S2SV_ModStart> nested ) ; if ( nested == - 1 ) { part_fun = 0 ; nested = 1 ; } }
|
7,972 |
CWE-000 void loadBinary_ARM7 ( aFile file ) { u32 ndsHeader [ 0x170 >> 2 ] ; nocashMessage ( "loadBinary_ARM7" ) ; fileRead ( ( char * ) ndsHeader , file , 0 , 0x170 ) ; u32 ARM9_SRC = ndsHeader [ 0x020 >> 2 ] ; char * ARM9_DST = ( char * ) ndsHeader [ 0x028 >> 2 ] ; ARM9_LEN = ndsHeader [ 0x02C >> 2 ] ; u32 ARM7_SRC = ndsHeader [ 0x030 >> 2 ] ; char * ARM7_DST = ( char * ) ndsHeader [ 0x038 >> 2 ] ; u32 ARM7_LEN = ndsHeader [ 0x03C >> 2 ] ; ROM_TID = ndsHeader [ 0x00C >> 2 ] ; <S2SV_StartBug> romSize = ndsHeader [ 0x080 >> 2 ] ; <S2SV_EndBug> ROM_HEADERCRC = ndsHeader [ 0x15C >> 2 ] ; fileRead ( ( char * ) 0x027FF000 , file , 0 , 0x170 ) ; if ( ( * ( u32 * ) ( 0x27FF00C ) & 0x00FFFFFF ) == 0x414441 || ( * ( u32 * ) ( 0x27FF00C ) & 0x00FFFFFF ) == 0x415041 || ( * ( u32 * ) ( 0x27FF00C ) & 0x00FFFFFF ) == 0x555043 || ( * ( u32 * ) ( 0x27FF00C ) & 0x00FFFFFF ) == 0x4B5049 || ( * ( u32 * ) ( 0x27FF00C ) & 0x00FFFFFF ) == 0x475049 ) { * ( u32 * ) ( 0x27FF00C ) = 0x4A414441 ; } fileRead ( ARM9_DST , file , ARM9_SRC , ARM9_LEN ) ; fileRead ( ARM7_DST , file , ARM7_SRC , ARM7_LEN ) ; if ( ROM_TID == 0x454C5741 || ROM_TID == 0x504C5741 ) { * ( u32 * ) ( 0x203E7B0 ) = 0 ; } if ( ROM_TID == 0x4A4C5741 ) { * ( u32 * ) ( 0x203F114 ) = 0 ; } if ( ROM_TID == 0x45575641 ) { * ( u32 * ) ( 0x0204cccc ) = 0xe1a00000 ; } if ( ROM_TID == 0x50575641 ) { * ( u32 * ) ( 0x0204cdbc ) = 0xe1a00000 ; } TEMP_ARM9_START_ADDRESS = ndsHeader [ 0x024 >> 2 ] ; ndsHeader [ 0x024 >> 2 ] = 0 ; dmaCopyWords ( 3 , ( void * ) ndsHeader , ( void * ) NDS_HEAD , 0x170 ) ; nocashMessage ( "Switch<S2SV_blank>to<S2SV_blank>NTR<S2SV_blank>mode<S2SV_blank>BIOS" ) ; REG_SCFG_ROM = 0x703 ; }
|
<S2SV_ModStart> 2 ] ; fatSize = ndsHeader [ 0x04C >> 2 ] ;
|
7,973 |
CWE-000 void undo_action ( tree_t * tree , action_t * action ) { if ( action -> type == EDIT ) { action -> edited -> description = strdup ( action -> original . description ) ; action -> edited -> price = action -> original . price ; while ( list_remove ( action -> edited -> shelves , 0 , NULL ) ) ; action -> edited -> shelves = list_new ( ) ; int shelves_length = list_length ( action -> original . shelves ) ; <S2SV_StartBug> L * tmp ; <S2SV_EndBug> for ( int i = 0 ; i < shelves_length ; i ++ ) { <S2SV_StartBug> list_remove ( action -> original . shelves , i , tmp ) ; <S2SV_EndBug> list_append ( action -> edited -> shelves , tmp ) ; } } return ; }
|
<S2SV_ModStart> shelves ) ; <S2SV_ModEnd> for ( int <S2SV_ModStart> ++ ) { shelf_t * tmp = list_get ( action -> original . shelves , i ) ; <S2SV_ModStart> , i , NULL <S2SV_ModEnd> ) ; list_append
|
7,974 |
CWE-000 static void dt_bauhaus_draw_quad ( dt_bauhaus_widget_t * w , cairo_t * cr ) { GtkWidget * widget = GTK_WIDGET ( w ) ; <S2SV_StartBug> gboolean sensitive = gtk_widget_is_sensitive ( GTK_WIDGET ( w ) ) ; <S2SV_EndBug> GtkAllocation allocation ; gtk_widget_get_allocation ( widget , & allocation ) ; <S2SV_StartBug> int width = allocation . width ; <S2SV_EndBug> <S2SV_StartBug> int height = allocation . height ; <S2SV_EndBug> if ( w -> quad_paint ) { <S2SV_StartBug> float font_size = get_label_font_size ( ) ; <S2SV_EndBug> cairo_save ( cr ) ; <S2SV_StartBug> if ( sensitive ) <S2SV_EndBug> set_color ( cr , darktable . bauhaus -> color_border ) ; else set_color ( cr , darktable . bauhaus -> color_bg ) ; <S2SV_StartBug> w -> quad_paint ( cr , width - height - 1 , - 1 , height + 2 , font_size + 2 , w -> quad_paint_flags , w -> quad_paint_data ) ; <S2SV_EndBug> if ( sensitive ) set_color ( cr , darktable . bauhaus -> color_fg ) ; else set_color ( cr , darktable . bauhaus -> color_fg_insensitive ) ; w -> quad_paint ( cr , width - height , 0 , height , font_size , w -> quad_paint_flags , w -> quad_paint_data ) ; cairo_restore ( cr ) ; } else { cairo_save ( cr ) ; if ( sensitive ) set_color ( cr , darktable . bauhaus -> color_fg ) ; else set_color ( cr , darktable . bauhaus -> color_fg_insensitive ) ; switch ( w -> type ) { case DT_BAUHAUS_COMBOBOX : cairo_translate ( cr , width - height * .5f , get_label_font_size ( ) * .5f ) ; draw_equilateral_triangle ( cr , height * get_marker_size ( ) ) ; cairo_fill_preserve ( cr ) ; cairo_set_line_width ( cr , 1. ) ; set_color ( cr , darktable . bauhaus -> color_border ) ; cairo_stroke ( cr ) ; break ; case DT_BAUHAUS_SLIDER : break ; default : cairo_set_source_rgb ( cr , 1.0 , 0.0 , 0.0 ) ; cairo_rectangle ( cr , width - height , 0 , height , height ) ; cairo_fill ( cr ) ; break ; } cairo_restore ( cr ) ; } }
|
<S2SV_ModStart> w ) ; const <S2SV_ModStart> allocation ) ; const <S2SV_ModStart> . width ; const <S2SV_ModStart> quad_paint ) { const <S2SV_ModStart> if ( sensitive && ( <S2SV_ModEnd> w -> quad_paint_flags <S2SV_ModStart> w -> quad_paint_flags & CPF_ACTIVE ) <S2SV_ModEnd> ) set_color (
|
7,975 |
CWE-000 void gdb_stub ( ) { # ifdef DEBUG_MODE <S2SV_StartBug> Print ( L"Waiting<S2SV_blank>for<S2SV_blank>GDB\\n" ) ; <S2SV_EndBug> int wait = 1 ; while ( wait ) { __asm__ __volatile__ ( "pause" ) ; } Print ( L"Linked<S2SV_blank>with<S2SV_blank>GDB\\n" ) ; # endif }
|
<S2SV_ModStart> DEBUG_MODE Print ( L"\\nWaiting<S2SV_blank>for<S2SV_blank>GDB\\n" <S2SV_ModEnd> ) ; int
|
7,976 |
CWE-000 void gen_view_list_face ( Face * face ) { int i ; Edge * e ; Point * last_point ; Point * p , * v ; BOOL arc_cw ; if ( face -> view_valid ) return ; free_view_list_face ( face ) ; p = point_newp ( face -> initial_point ) ; p -> hdr . ID = 0 ; objid -- ; link_tail ( ( Object * ) p , ( Object * * ) & face -> view_list ) ; # if DEBUG_VIEW_LIST_RECT_FACE sprintf_s ( buf , 256 , "Face<S2SV_blank>%d<S2SV_blank>IP<S2SV_blank>%d\\r\\n" , face -> hdr . ID , face -> initial_point -> hdr . ID ) ; Log ( buf ) ; sprintf_s ( buf , 256 , "%d<S2SV_blank>%d\\r\\n" , ( ( StraightEdge * ) face -> edges [ 0 ] ) -> endpoints [ 0 ] -> hdr . ID , ( ( StraightEdge * ) face -> edges [ 0 ] ) -> endpoints [ 1 ] -> hdr . ID ) ; Log ( buf ) ; sprintf_s ( buf , 256 , "%d<S2SV_blank>%d\\r\\n" , ( ( StraightEdge * ) face -> edges [ 1 ] ) -> endpoints [ 0 ] -> hdr . ID , ( ( StraightEdge * ) face -> edges [ 1 ] ) -> endpoints [ 1 ] -> hdr . ID ) ; Log ( buf ) ; sprintf_s ( buf , 256 , "%d<S2SV_blank>%d\\r\\n" , ( ( StraightEdge * ) face -> edges [ 2 ] ) -> endpoints [ 0 ] -> hdr . ID , ( ( StraightEdge * ) face -> edges [ 2 ] ) -> endpoints [ 1 ] -> hdr . ID ) ; Log ( buf ) ; sprintf_s ( buf , 256 , "%d<S2SV_blank>%d\\r\\n" , ( ( StraightEdge * ) face -> edges [ 3 ] ) -> endpoints [ 0 ] -> hdr . ID , ( ( StraightEdge * ) face -> edges [ 3 ] ) -> endpoints [ 1 ] -> hdr . ID ) ; Log ( buf ) ; # endif last_point = face -> initial_point ; for ( i = 0 ; i < face -> n_edges ; i ++ ) { e = face -> edges [ i ] ; <S2SV_StartBug> switch ( e -> type & ! EDGE_CONSTRUCTION ) <S2SV_EndBug> { case EDGE_STRAIGHT : if ( last_point == e -> endpoints [ 0 ] ) { last_point = e -> endpoints [ 1 ] ; } else { ASSERT ( last_point == e -> endpoints [ 1 ] , "Point<S2SV_blank>order<S2SV_blank>messed<S2SV_blank>up" ) ; last_point = e -> endpoints [ 0 ] ; } p = point_newp ( last_point ) ; p -> hdr . ID = 0 ; objid -- ; link_tail ( ( Object * ) p , ( Object * * ) & face -> view_list ) ; break ; case EDGE_ARC : gen_view_list_arc ( ( ArcEdge * ) e ) ; if ( e -> endpoints [ 0 ] == e -> endpoints [ 1 ] ) arc_cw = ( ( ArcEdge * ) e ) -> clockwise ; else arc_cw = FALSE ; goto copy_view_list ; case EDGE_BEZIER : gen_view_list_bez ( ( BezierEdge * ) e ) ; copy_view_list : if ( last_point == e -> endpoints [ 0 ] && ! arc_cw ) { last_point = e -> endpoints [ 1 ] ; for ( v = ( Point * ) e -> view_list -> hdr . next ; v != NULL ; v = ( Point * ) v -> hdr . next ) { p = point_newp ( v ) ; p -> hdr . ID = 0 ; objid -- ; link_tail ( ( Object * ) p , ( Object * * ) & face -> view_list ) ; } } else { ASSERT ( last_point == e -> endpoints [ 1 ] , "Point<S2SV_blank>order<S2SV_blank>messed<S2SV_blank>up" ) ; last_point = e -> endpoints [ 0 ] ; for ( v = ( Point * ) e -> view_list ; v -> hdr . next -> next != NULL ; v = ( Point * ) v -> hdr . next ) ; for ( ; v != NULL ; v = ( Point * ) v -> hdr . prev ) { p = point_newp ( v ) ; p -> hdr . ID = 0 ; objid -- ; link_tail ( ( Object * ) p , ( Object * * ) & face -> view_list ) ; } } p = point_newp ( last_point ) ; p -> hdr . ID = 0 ; objid -- ; link_tail ( ( Object * ) p , ( Object * * ) & face -> view_list ) ; break ; } } face -> view_valid = TRUE ; polygon_normal ( face -> view_list , & face -> normal ) ; face -> normal . refpt = * face -> edges [ 0 ] -> endpoints [ 0 ] ; }
|
<S2SV_ModStart> -> type & ~ <S2SV_ModEnd> EDGE_CONSTRUCTION ) {
|
7,977 |
CWE-000 static int ssl3_get_channel_id ( SSL * ssl ) { int ret = - 1 ; uint8_t channel_id_hash [ EVP_MAX_MD_SIZE ] ; size_t channel_id_hash_len ; const uint8_t * p ; uint16_t extension_type ; EC_GROUP * p256 = NULL ; EC_KEY * key = NULL ; EC_POINT * point = NULL ; ECDSA_SIG sig ; BIGNUM x , y ; CBS encrypted_extensions , extension ; int msg_ret = ssl -> method -> ssl_get_message ( ssl , SSL3_MT_CHANNEL_ID , ssl_dont_hash_message ) ; if ( msg_ret <= 0 ) { return msg_ret ; } if ( ! tls1_channel_id_hash ( ssl , channel_id_hash , & channel_id_hash_len ) ) { return - 1 ; } assert ( channel_id_hash_len == SHA256_DIGEST_LENGTH ) ; if ( ! ssl -> method -> hash_current_message ( ssl ) ) { return - 1 ; } CBS_init ( & encrypted_extensions , ssl -> init_msg , ssl -> init_num ) ; if ( ! CBS_get_u16 ( & encrypted_extensions , & extension_type ) || ! CBS_get_u16_length_prefixed ( & encrypted_extensions , & extension ) || CBS_len ( & encrypted_extensions ) != 0 || extension_type != TLSEXT_TYPE_channel_id || CBS_len ( & extension ) != TLSEXT_CHANNEL_ID_SIZE ) { <S2SV_StartBug> OPENSSL_PUT_ERROR ( SSL , SSL_R_INVALID_MESSAGE ) ; <S2SV_EndBug> return - 1 ; } p256 = EC_GROUP_new_by_curve_name ( NID_X9_62_prime256v1 ) ; if ( ! p256 ) { OPENSSL_PUT_ERROR ( SSL , SSL_R_NO_P256_SUPPORT ) ; return - 1 ; } BN_init ( & x ) ; BN_init ( & y ) ; sig . r = BN_new ( ) ; sig . s = BN_new ( ) ; if ( sig . r == NULL || sig . s == NULL ) { goto err ; } p = CBS_data ( & extension ) ; if ( BN_bin2bn ( p + 0 , 32 , & x ) == NULL || BN_bin2bn ( p + 32 , 32 , & y ) == NULL || BN_bin2bn ( p + 64 , 32 , sig . r ) == NULL || BN_bin2bn ( p + 96 , 32 , sig . s ) == NULL ) { goto err ; } point = EC_POINT_new ( p256 ) ; if ( ! point || ! EC_POINT_set_affine_coordinates_GFp ( p256 , point , & x , & y , NULL ) ) { goto err ; } key = EC_KEY_new ( ) ; if ( ! key || ! EC_KEY_set_group ( key , p256 ) || ! EC_KEY_set_public_key ( key , point ) ) { goto err ; } if ( ! ECDSA_do_verify ( channel_id_hash , channel_id_hash_len , & sig , key ) ) { OPENSSL_PUT_ERROR ( SSL , SSL_R_CHANNEL_ID_SIGNATURE_INVALID ) ; ssl -> s3 -> tlsext_channel_id_valid = 0 ; goto err ; } memcpy ( ssl -> s3 -> tlsext_channel_id , p , 64 ) ; ret = 1 ; err : BN_free ( & x ) ; BN_free ( & y ) ; BN_free ( sig . r ) ; BN_free ( sig . s ) ; EC_KEY_free ( key ) ; EC_POINT_free ( point ) ; EC_GROUP_free ( p256 ) ; return ret ; }
|
<S2SV_ModStart> ( SSL , SSL_R_DECODE_ERROR ) ; ssl3_send_alert ( ssl , SSL3_AL_FATAL , SSL_AD_DECODE_ERROR <S2SV_ModEnd> ) ; return
|
7,978 |
CWE-000 int ion_heap_buffer_zero ( struct ion_buffer * buffer ) { struct sg_table * table = buffer -> sg_table ; pgprot_t pgprot ; struct scatterlist * sg ; struct vm_struct * vm_struct ; int i , j , ret = 0 ; if ( buffer -> flags & ION_FLAG_CACHED ) pgprot = PAGE_KERNEL ; else pgprot = pgprot_writecombine ( PAGE_KERNEL ) ; vm_struct = get_vm_area ( PAGE_SIZE , VM_ALLOC ) ; if ( ! vm_struct ) return - ENOMEM ; for_each_sg ( table -> sgl , sg , table -> nents , i ) { struct page * page = sg_page ( sg ) ; unsigned long len = sg_dma_len ( sg ) ; for ( j = 0 ; j < len / PAGE_SIZE ; j ++ ) { struct page * sub_page = page + j ; struct page * * pages = & sub_page ; <S2SV_StartBug> ret = map_vm_area ( vm_struct , pgprot , pages ) ; <S2SV_EndBug> if ( ret ) goto end ; memset ( vm_struct -> addr , 0 , PAGE_SIZE ) ; unmap_kernel_range ( ( unsigned long ) vm_struct -> addr , PAGE_SIZE ) ; } } end : free_vm_area ( vm_struct ) ; return ret ; }
|
<S2SV_ModStart> , pgprot , &
|
7,979 |
CWE-000 static void read_cloud_conf_data ( oc_rep_t * payload , void * * user_data ) { sc_cloud_server_conf_properties * cloud_prop = oc_mem_calloc ( 1 , sizeof ( sc_cloud_server_conf_properties ) ) ; MEM_ALLOC_CHECK ( cloud_prop ) ; if ( read_sc_string_prop_from_payload ( payload , SC_RSRVD_ES_VENDOR_CLIENTID , & cloud_prop -> client_id ) ) { es_new_string ( & g_scprop -> client_id , oc_string ( cloud_prop -> client_id ) ) ; } if ( read_sc_string_prop_from_payload ( payload , SC_RSRVD_ES_VENDOR_AAC , & cloud_prop -> aac ) ) { es_new_string ( & g_scprop -> aac , oc_string ( cloud_prop -> aac ) ) ; } <S2SV_StartBug> if ( read_sc_string_prop_from_payload ( payload , SC_RSRVD_ES_VENDOR_TNC_RESULT , <S2SV_EndBug> & cloud_prop -> tnc_result ) ) { es_new_string ( & g_scprop -> tnc_result , oc_string ( cloud_prop -> tnc_result ) ) ; <S2SV_StartBug> } <S2SV_EndBug> if ( read_sc_string_prop_from_payload ( payload , SC_RSRVD_ES_VENDOR_UID , & cloud_prop -> uid ) ) { es_new_string ( & g_scprop -> uid , oc_string ( cloud_prop -> uid ) ) ; } if ( read_sc_string_prop_from_payload ( payload , SC_RSRVD_ES_VENDOR_REFRESH_TOKEN , & cloud_prop -> refresh_token ) ) { es_new_string ( & g_scprop -> refresh_token , oc_string ( cloud_prop -> refresh_token ) ) ; } * user_data = cloud_prop ; return ; exit : delete_cloud_prop ( cloud_prop ) ; }
|
<S2SV_ModStart> ) ; } # ifndef SC_ES_OPT <S2SV_ModStart> ) ; } # endif
|
7,980 |
CWE-000 static int out_get_presentation_position ( const struct audio_stream_out * stream , uint64_t * frames , struct timespec * timestamp ) { struct stream_out * out = ( struct stream_out * ) stream ; <S2SV_StartBug> int ret = - 1 ; <S2SV_EndBug> unsigned long dsp_frames ; if ( is_offload_usecase ( out -> usecase ) && ! out -> non_blocking && ! ( out -> flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD ) ) { * frames = get_actual_pcm_frames_rendered ( out ) ; clock_gettime ( CLOCK_MONOTONIC , timestamp ) ; ALOGVV ( "frames<S2SV_blank>%lld<S2SV_blank>playedat<S2SV_blank>%lld" , ( long long int ) * frames , timestamp -> tv_sec * 1000000LL + timestamp -> tv_nsec / 1000 ) ; return 0 ; } lock_output_stream ( out ) ; if ( is_offload_usecase ( out -> usecase ) && out -> compr != NULL && out -> non_blocking ) { ret = compress_get_tstamp ( out -> compr , & dsp_frames , & out -> sample_rate ) ; ALOGVV ( "%s<S2SV_blank>rendered<S2SV_blank>frames<S2SV_blank>%ld<S2SV_blank>sample_rate<S2SV_blank>%d" , __func__ , dsp_frames , out -> sample_rate ) ; * frames = dsp_frames ; if ( ret < 0 ) ret = - errno ; if ( - ENETRESET == ret ) { ALOGE ( "<S2SV_blank>ERROR:<S2SV_blank>sound<S2SV_blank>card<S2SV_blank>not<S2SV_blank>active<S2SV_blank>Unable<S2SV_blank>to<S2SV_blank>get<S2SV_blank>time<S2SV_blank>stamp<S2SV_blank>from<S2SV_blank>compress<S2SV_blank>driver" ) ; out -> card_status = CARD_STATUS_OFFLINE ; ret = - EINVAL ; } else ret = 0 ; clock_gettime ( CLOCK_MONOTONIC , timestamp ) ; } else { if ( out -> pcm ) { unsigned int avail ; if ( pcm_get_htimestamp ( out -> pcm , & avail , timestamp ) == 0 ) { size_t kernel_buffer_size = out -> config . period_size * out -> config . period_count ; int64_t signed_frames = out -> written - kernel_buffer_size + avail ; signed_frames -= ( platform_render_latency ( out -> usecase ) * out -> sample_rate / 1000000LL ) ; if ( signed_frames >= 0 ) { * frames = signed_frames ; ret = 0 ; } } } } pthread_mutex_unlock ( & out -> lock ) ; return ret ; }
|
<S2SV_ModStart> ret = - ENODATA <S2SV_ModEnd> ; unsigned long
|
7,981 |
CWE-000 DEFUN ( "eql" , Feql , Seql , 2 , 2 , 0 , doc : ) ( Lisp_Object obj1 , Lisp_Object obj2 ) { if ( FLOATP ( obj1 ) ) <S2SV_StartBug> return internal_equal ( obj1 , obj2 , 0 , 0 , Qnil ) ? Qt : Qnil ; <S2SV_EndBug> else return EQ ( obj1 , obj2 ) ? Qt : Qnil ; }
|
<S2SV_ModStart> ) ) return equal_no_quit <S2SV_ModEnd> ( obj1 , <S2SV_ModStart> obj1 , obj2 <S2SV_ModEnd> ) ? Qt
|
7,982 |
CWE-000 int new_mkdir ( struct inode * dir , struct dentry * dentry , umode_t mode ) { struct new_entry new_entry ; struct dir_bucket dir_bucket ; struct dir_bucket_head dir_bucket_head ; int res ; int flag = GET_BUCKET_NORMAL ; <S2SV_StartBug> unsigned int parent_bucket_num = dentry -> bucket_info . parent_bucket_num ; <S2SV_EndBug> struct file * dir_file = dentry -> d_sb -> dir_file ; res = get_dir_bucket ( parent_bucket_num , & dir_bucket , dir_file ) ; if ( res == NO_BUCKET ) flag = CREATE_BUCKET ; res = add_entry_to_bucket ( & dir_bucket , dentry , & new_entry , dir_file , flag ) ; if ( res == BUCKET_FULL ) { } else { res = writeback_entry ( & dir_bucket , & new_entry , dir_file ) ; } return res ; }
|
<S2SV_ModStart> = dentry -> <S2SV_ModEnd> parent_bucket_num ; struct
|
7,983 |
CWE-000 static void savegame_serialize ( savegame_state * state ) { scenario_settings_save_state ( state -> scenario_campaign_mission , state -> scenario_settings , state -> scenario_is_custom , state -> player_name ) ; write_all_to_buffer ( state -> savegameFileVersion , & savegameFileVersion ) ; write_all_to_buffer ( state -> Data_Grid_graphicIds , & Data_Grid_graphicIds ) ; write_all_to_buffer ( state -> Data_Grid_edge , & Data_Grid_edge ) ; write_all_to_buffer ( state -> Data_Grid_buildingIds , & Data_Grid_buildingIds ) ; write_all_to_buffer ( state -> Data_Grid_terrain , & Data_Grid_terrain ) ; write_all_to_buffer ( state -> Data_Grid_aqueducts , & Data_Grid_aqueducts ) ; write_all_to_buffer ( state -> Data_Grid_figureIds , & Data_Grid_figureIds ) ; write_all_to_buffer ( state -> Data_Grid_bitfields , & Data_Grid_bitfields ) ; write_all_to_buffer ( state -> Data_Grid_spriteOffsets , & Data_Grid_spriteOffsets ) ; <S2SV_StartBug> write_all_to_buffer ( state -> Data_Grid_random , & Data_Grid_random ) ; <S2SV_EndBug> map_desirability_save_state ( state -> map_desirability ) ; write_all_to_buffer ( state -> Data_Grid_elevation , & Data_Grid_elevation ) ; write_all_to_buffer ( state -> Data_Grid_buildingDamage , & Data_Grid_buildingDamage ) ; write_all_to_buffer ( state -> Data_Grid_Undo_aqueducts , & Data_Grid_Undo_aqueducts ) ; write_all_to_buffer ( state -> Data_Grid_Undo_spriteOffsets , & Data_Grid_Undo_spriteOffsets ) ; write_all_to_buffer ( state -> Data_Figures , & Data_Figures ) ; figure_route_save_state ( state -> route_figures , state -> route_paths ) ; formations_save_state ( state -> formations , state -> formation_totals ) ; write_all_to_buffer ( state -> Data_CityInfo , & Data_CityInfo ) ; write_all_to_buffer ( state -> Data_CityInfo_Extra_unknownBytes , & Data_CityInfo_Extra . unknownBytes ) ; write_all_to_buffer ( state -> Data_CityInfo_Extra_ciid , & Data_CityInfo_Extra . ciid ) ; write_all_to_buffer ( state -> Data_Buildings , & Data_Buildings ) ; write_all_to_buffer ( state -> Data_Settings_Map_orientation , & Data_State . map . orientation ) ; game_time_save_state ( state -> game_time ) ; write_all_to_buffer ( state -> Data_Buildings_Extra_highestBuildingIdEver , & Data_Buildings_Extra . highestBuildingIdEver ) ; write_all_to_buffer ( state -> Data_Debug_maxConnectsEver , & Data_Buildings_Extra . maxConnectsEver ) ; random_save_state ( state -> random_iv ) ; write_all_to_buffer ( state -> Data_Settings_Map_camera_x , & Data_State . map . camera . x ) ; write_all_to_buffer ( state -> Data_Settings_Map_camera_y , & Data_State . map . camera . y ) ; building_count_save_state ( state -> building_count_industry , state -> building_count_culture1 , state -> building_count_culture2 , state -> building_count_culture3 , state -> building_count_military , state -> building_count_support ) ; write_all_to_buffer ( state -> Data_CityInfo_Extra_populationGraphOrder , & Data_CityInfo_Extra . populationGraphOrder ) ; write_all_to_buffer ( state -> Data_CityInfo_Extra_unknownOrder , & Data_CityInfo_Extra . unknownOrder ) ; scenario_emperor_change_save_state ( state -> emperor_change_time , state -> emperor_change_state ) ; empire_save_state ( state -> empire ) ; empire_city_save_state ( state -> empire_cities ) ; trade_prices_save_state ( state -> trade_prices ) ; figure_name_save_state ( state -> figure_names ) ; city_culture_save_state ( state -> culture_coverage ) ; scenario_save_state ( state -> scenario ) ; scenario_criteria_save_state ( state -> max_game_year ) ; scenario_earthquake_save_state ( state -> earthquake ) ; city_message_save_state ( state -> messages , state -> message_extra , state -> message_counts , state -> message_delays , state -> population_messages ) ; write_all_to_buffer ( state -> Data_Figure_Extra_createdSequence , & Data_Figure_Extra . createdSequence ) ; sound_city_save_state ( state -> city_sounds ) ; write_all_to_buffer ( state -> Data_Buildings_Extra_highestBuildingIdInUse , & Data_Buildings_Extra . highestBuildingIdInUse ) ; traders_save_state ( state -> figure_traders ) ; building_list_save_state ( state -> building_list_small , state -> building_list_large , state -> building_list_burning , state -> building_list_burning_totals ) ; tutorial_save_state ( state -> tutorial_part1 , state -> tutorial_part2 , state -> tutorial_part3 ) ; building_storage_save_state ( state -> building_storages ) ; scenario_gladiator_revolt_save_state ( state -> gladiator_revolt ) ; trade_routes_save_state ( state -> trade_route_limit , state -> trade_route_traded ) ; write_all_to_buffer ( state -> Data_Buildings_Extra_barracksTowerSentryRequested , & Data_Buildings_Extra . barracksTowerSentryRequested ) ; write_all_to_buffer ( state -> Data_Buildings_Extra_createdSequence , & Data_Buildings_Extra . createdSequence ) ; map_routing_save_state ( state -> routing_counters ) ; enemy_armies_save_state ( state -> enemy_armies , state -> enemy_army_totals ) ; write_all_to_buffer ( state -> Data_CityInfo_Extra_entryPointFlag_x , & Data_CityInfo_Extra . entryPointFlag . x ) ; write_all_to_buffer ( state -> Data_CityInfo_Extra_entryPointFlag_y , & Data_CityInfo_Extra . entryPointFlag . y ) ; write_all_to_buffer ( state -> Data_CityInfo_Extra_exitPointFlag_x , & Data_CityInfo_Extra . exitPointFlag . x ) ; write_all_to_buffer ( state -> Data_CityInfo_Extra_exitPointFlag_y , & Data_CityInfo_Extra . exitPointFlag . y ) ; scenario_invasion_save_state ( state -> last_invasion_id , state -> invasion_warnings ) ; write_all_to_buffer ( state -> Data_Debug_incorrectHousePositions , & Data_Buildings_Extra . incorrectHousePositions ) ; write_all_to_buffer ( state -> Data_Debug_unfixableHousePositions , & Data_Buildings_Extra . unfixableHousePositions ) ; write_all_to_buffer ( state -> Data_FileList_selectedScenario , & Data_FileList . selectedScenario ) ; map_bookmark_save_state ( state -> bookmarks ) ; write_all_to_buffer ( state -> Data_CityInfo_Extra_entryPointFlag_gridOffset , & Data_CityInfo_Extra . entryPointFlag . gridOffset ) ; write_all_to_buffer ( state -> Data_CityInfo_Extra_exitPointFlag_gridOffset , & Data_CityInfo_Extra . exitPointFlag . gridOffset ) ; buffer_skip ( state -> endMarker , 284 ) ; for ( int i = 0 ; i < savegame_data . num_pieces ; i ++ ) { buffer * buf = & savegame_data . pieces [ i ] . buf ; if ( buf -> index != buf -> size ) { printf ( "ERR:<S2SV_blank>buffer<S2SV_blank>%d<S2SV_blank>not<S2SV_blank>empty:<S2SV_blank>%d<S2SV_blank>of<S2SV_blank>%d<S2SV_blank>bytes<S2SV_blank>used\\n" , i , buf -> index , buf -> size ) ; } else if ( buf -> overflow ) { printf ( "ERR:<S2SV_blank>buffer<S2SV_blank>%d<S2SV_blank>overflowed\\n" , i ) ; } } }
|
<S2SV_ModStart> Data_Grid_spriteOffsets ) ; map_random_save_state ( state -> random <S2SV_ModEnd> ) ; map_desirability_save_state
|
7,984 |
CWE-000 int main ( int argc , char * argv [ ] ) { char * end ; int * my_array = NULL ; <S2SV_StartBug> int sleep_period = 2 , num_iter = 10 , i , j ; <S2SV_EndBug> int array_size_base = 1048576 * 18 ; int array_size = 0 , array_size_old = 0 ; int low_intensity = 1 , high_intensity = 2 ; <S2SV_StartBug> int duration = 0 ; <S2SV_EndBug> if ( argc <= 1 ) { return 0 ; } else { duration = ( int ) strtoll ( argv [ 1 ] , & end , 10 ) ; if ( argc == 3 && strcmp ( argv [ 2 ] , "l" ) == 0 ) array_size_base = array_size_base * low_intensity ; else array_size_base = array_size_base * high_intensity ; array_size = array_size_base ; } parent_pid = getpid ( ) ; <S2SV_StartBug> signal ( SIGALRM , signal_handler ) ; <S2SV_EndBug> signal ( SIGINT , signal_handler ) ; signal ( SIGTERM , signal_handler ) ; alarm ( duration ) ; while ( 1 ) { child_pid = fork ( ) ; if ( child_pid == 0 ) { srand ( time ( NULL ) ) ; my_array = ( int * ) malloc ( array_size * sizeof ( int ) ) ; for ( i = 0 ; i < array_size ; i ++ ) my_array [ i ] = ( int ) rand ( ) ; for ( j = 0 ; j < num_iter ; j ++ ) { array_size_old = array_size ; array_size += array_size_base ; my_array = ( int * ) realloc ( my_array , array_size * sizeof ( int ) ) ; <S2SV_StartBug> if ( my_array == NULL || getppid ( ) == parent_pid ) <S2SV_EndBug> { return - 1 ; } else for ( i = 0 ; i < array_size - array_size_old ; i ++ ) my_array [ array_size_old + i ] = my_array [ i ] ; <S2SV_StartBug> sleep ( sleep_period ) ; <S2SV_EndBug> } return 0 ; } else wait ( & child_status ) ; child_pid = 0 ; } return 0 ; }
|
<S2SV_ModStart> i , j , k <S2SV_ModStart> 2 ; int r , tot = 0 , <S2SV_ModStart> ( ) ; srand ( time ( NULL ) ) ; <S2SV_ModStart> getppid ( ) != <S2SV_ModEnd> parent_pid ) { <S2SV_ModStart> i ] ; for ( k = 0 ; k < 10 ; k ++ ) { r = rand ( ) ; if ( r < array_size ) tot += my_array [ r ] ; }
|
7,985 |
CWE-000 sqInt dir_EntryLookup ( char * pathString , sqInt pathStringLength , char * nameString , sqInt nameStringLength , char * name , sqInt * nameLength , sqInt * creationDate , sqInt * modificationDate , sqInt * isDirectory , squeakFileOffsetType * sizeIfFile ) # endif { char unixPath [ MAXPATHLEN + 1 ] ; struct stat statBuf ; * name = 0 ; * nameLength = 0 ; * creationDate = 0 ; * modificationDate = 0 ; * isDirectory = false ; * sizeIfFile = 0 ; # if PharoVM * posixPermissions = 0 ; * isSymlink = false ; # endif if ( ( pathStringLength == 0 ) ) strcpy ( unixPath , "." ) ; else if ( ! sq2uxPath ( pathString , pathStringLength , unixPath , MAXPATHLEN , 1 ) ) return BAD_PATH ; char terminatedName [ MAXPATHLEN + 1 ] ; <S2SV_StartBug> strncpy ( terminatedName , nameString , nameStringLength ) ; <S2SV_EndBug> <S2SV_StartBug> terminatedName [ nameStringLength ] = '\\0' ; <S2SV_EndBug> strcat ( unixPath , "/" ) ; strcat ( unixPath , terminatedName ) ; if ( stat ( unixPath , & statBuf ) && lstat ( unixPath , & statBuf ) ) { return NO_MORE_ENTRIES ; } * nameLength = ux2sqPath ( nameString , nameStringLength , name , 256 , 0 ) ; * creationDate = convertToSqueakTime ( statBuf . st_ctime ) ; * modificationDate = convertToSqueakTime ( statBuf . st_mtime ) ; if ( S_ISDIR ( statBuf . st_mode ) ) * isDirectory = true ; else * sizeIfFile = statBuf . st_size ; # if PharoVM * isSymlink = S_ISLNK ( statBuf . st_mode ) ; * posixPermissions = statBuf . st_mode & 0777 ; # endif return ENTRY_FOUND ; }
|
<S2SV_ModStart> 1 ] ; if ( nameStringLength > MAXPATHLEN ) return BAD_PATH <S2SV_ModStart> ] = '\\0' ; if ( strlen ( unixPath ) + 1 + nameStringLength > MAXPATHLEN ) return BAD_PATH
|
7,986 |
CWE-000 static int get_padded_blocksize ( int w , int hd , int blocksize ) { int word_size = w / 8 ; <S2SV_StartBug> return ( int ) ceill ( ( double ) blocksize / ( word_size - hd ) ) * word_size ; <S2SV_EndBug> }
|
<S2SV_ModStart> ; return ( ( blocksize + ( ( word_size - hd ) - 1 ) ) <S2SV_ModEnd> / ( word_size
|
7,987 |
CWE-000 ANSC_STATUS CosaDmlDcRebootWifi ( ANSC_HANDLE hContext ) { CCSP_MESSAGE_BUS_INFO * bus_info = ( CCSP_MESSAGE_BUS_INFO * ) bus_handle ; fprintf ( stderr , "WiFi<S2SV_blank>is<S2SV_blank>going<S2SV_blank>to<S2SV_blank>reboot\\n" ) ; pthread_detach ( pthread_self ( ) ) ; CcspTraceWarning ( ( "RebootDevice:WiFi<S2SV_blank>is<S2SV_blank>going<S2SV_blank>to<S2SV_blank>reboot<S2SV_blank>now\\n" ) ) ; int ret ; int size = 0 ; componentStruct_t * * ppComponents = NULL ; char * faultParam = NULL ; sprintf ( dst_pathname_cr , "%s%s" , g_Subsystem , CCSP_DBUS_INTERFACE_CR ) ; ret = CcspBaseIf_discComponentSupportingNamespace ( bus_handle , dst_pathname_cr , "Device.WiFi." , g_Subsystem , & ppComponents , & size ) ; if ( ret == CCSP_SUCCESS && size == 1 ) { parameterValStruct_t val [ 1 ] = { { "Device.WiFi.X_CISCO_COM_ResetRadios" , "true" , ccsp_boolean } } ; ret = CcspBaseIf_setParameterValues ( bus_handle , ppComponents [ 0 ] -> componentName , ppComponents [ 0 ] -> dbusPath , 0 , 0x0 , & val , 1 , TRUE , & faultParam ) ; if ( ret != CCSP_SUCCESS && faultParam ) { CcspTraceError ( ( "RebootDevice:%s<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>SetValue<S2SV_blank>for<S2SV_blank>param<S2SV_blank>\'%s\'\\n" , __FUNCTION__ , faultParam ) ) ; bus_info -> freefunc ( faultParam ) ; } else { char buf [ 7 ] = { 0 } ; int wifiresetcount = 0 ; syscfg_get ( NULL , "wifi_reset_count" , buf , sizeof ( buf ) ) ; wifiresetcount = atoi ( buf ) ; wifiresetcount ++ ; memset ( buf , 0 , sizeof ( buf ) ) ; snprintf ( buf , sizeof ( buf ) , "%d" , wifiresetcount ) ; syscfg_set ( NULL , "wifi_reset_count" , buf ) ; FILE * fp = NULL ; memset ( buf , 0 , sizeof ( buf ) ) ; sprintf ( buf , "date" ) ; char buffer [ 50 ] = { 0 } ; memset ( buffer , 0 , sizeof ( buffer ) ) ; <S2SV_StartBug> fp = v_secure_popen ( buf ) ; <S2SV_EndBug> if ( fp != NULL ) { while ( fgets ( buffer , sizeof ( buffer ) , fp ) != NULL ) { buffer [ strlen ( buffer ) - 1 ] = '\\0' ; syscfg_set ( NULL , "latest_wifi_reset_time" , buffer ) ; } <S2SV_StartBug> v_secure_pclose ( fp ) ; <S2SV_EndBug> } if ( syscfg_commit ( ) != 0 ) { CcspTraceWarning ( ( "syscfg_commit<S2SV_blank>failed\\n" ) ) ; } CcspTraceWarning ( ( "WIFI_RESET_COUNT<S2SV_blank>:<S2SV_blank>%d<S2SV_blank>Time<S2SV_blank>:<S2SV_blank>%s<S2SV_blank><S2SV_blank>\\n" , wifiresetcount , buffer ) ) ; } free_componentStruct_t ( bus_handle , size , ppComponents ) ; } return ANSC_STATUS_SUCCESS ; }
|
<S2SV_ModStart> ; fp = popen ( buf , "r" <S2SV_ModEnd> ) ; if <S2SV_ModStart> ) ; } pclose <S2SV_ModEnd> ( fp )
|
7,988 |
CWE-000 int BFileFlush ( BFILE * bf ) { <S2SV_StartBug> int i ; <S2SV_EndBug> for ( i = 0 ; i < bf -> nr ; i ++ ) { if ( bf -> w [ i ] > 0 ) { fwrite ( bf -> buf + i * bf -> nbuf , 1 , bf -> w [ i ] , bf -> f ) ; bf -> w [ i ] = 0 ; } } <S2SV_StartBug> return fflush ( bf -> f ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> int i ; if ( bf -> buf != NULL ) { <S2SV_ModStart> ; } } }
|
7,989 |
CWE-000 void print_fragment_submessage ( const char * pre , uint16_t size , uint8_t flags ) { printf ( "%s[FRAGMENT<S2SV_blank>|<S2SV_blank>size:<S2SV_blank>%hu<S2SV_blank>|<S2SV_blank>%s]%s" , pre , size , <S2SV_StartBug> ( FLAG_LAST_FRAGMENT & flags ) ? "last" : "-" , <S2SV_EndBug> RESTORE_COLOR ) ; }
|
<S2SV_ModStart> ? "last" : "intermediate" <S2SV_ModEnd> , RESTORE_COLOR )
|
7,990 |
CWE-000 <S2SV_StartBug> static PHP_METHOD ( Phalcon_Mvc_Model_MetaData_Memory , write ) { <S2SV_EndBug> <S2SV_StartBug> zval * key_param = NULL , * data , data_sub ; <S2SV_EndBug> zval key ; zval * this_ptr = getThis ( ) ; ZVAL_UNDEF ( & key ) ; ZVAL_UNDEF ( & data_sub ) ; ZEPHIR_MM_GROW ( ) ; <S2SV_StartBug> zephir_fetch_params ( 1 , 2 , 0 , & key_param , & data ) ; <S2SV_EndBug> if ( UNEXPECTED ( Z_TYPE_P ( key_param ) != IS_STRING && Z_TYPE_P ( key_param ) != IS_NULL ) ) { zephir_throw_exception_string ( spl_ce_InvalidArgumentException , SL ( "Parameter<S2SV_blank>\'key\'<S2SV_blank>must<S2SV_blank>be<S2SV_blank>a<S2SV_blank>string" ) TSRMLS_CC ) ; RETURN_MM_NULL ( ) ; <S2SV_StartBug> } <S2SV_EndBug> if ( EXPECTED ( Z_TYPE_P ( key_param ) == IS_STRING ) ) { zephir_get_strval ( & key , key_param ) ; } else { ZEPHIR_INIT_VAR ( & key ) ; ZVAL_EMPTY_STRING ( & key ) ; } RETURN_MM_NULL ( ) ; }
|
<S2SV_ModStart> static PHP_METHOD ( Phalcon_Http_Request , isConnect <S2SV_ModEnd> ) { zval <S2SV_ModStart> { zval * _0 = NULL ; zend_long ZEPHIR_LAST_CALL_STATUS <S2SV_ModEnd> ; ZEPHIR_MM_GROW ( <S2SV_ModStart> ( ) ; ZEPHIR_CALL_METHOD ( & _0 , this_ptr , "getmethod" , NULL , 234 ) ; zephir_check_call_status <S2SV_ModEnd> ( ) ; <S2SV_ModStart> ( ) ; RETURN_MM_BOOL ( ZEPHIR_IS_STRING_IDENTICAL ( _0 , "CONNECT" ) <S2SV_ModEnd> ) ; }
|
7,991 |
CWE-000 <S2SV_StartBug> int main ( void ) <S2SV_EndBug> { int fd ; char * line ; int ret ; <S2SV_StartBug> fd = open ( "test2" , O_RDONLY ) ; <S2SV_EndBug> while ( ( ret = get_next_line ( fd , & line ) ) ) { printf ( "Ret:<S2SV_blank>%d<S2SV_blank>Line:<S2SV_blank>%s\\n" , ret , line ) ; } printf ( "Ret:<S2SV_blank>%d<S2SV_blank>Line:<S2SV_blank>%s\\n" , ret , line ) ; return ( 0 ) ; }
|
<S2SV_ModStart> int main ( int argc , char * * argv <S2SV_ModEnd> ) { int <S2SV_ModStart> int ret ; ( void ) argc ; <S2SV_ModStart> = open ( argv [ 1 ] <S2SV_ModEnd> , O_RDONLY )
|
7,992 |
CWE-000 <S2SV_StartBug> int allocateCacheSlot ( ) { <S2SV_EndBug> int slot = 0 ; u32 lowerCounter = accessCounter ; for ( int i = 0 ; i < REG_MBK_CACHE_SIZE ; i ++ ) { <S2SV_StartBug> if ( ( currentSlot / 8 ) == ( i / 8 ) || ! isSlotAccessibleFromArm9 ( i ) ) { <S2SV_EndBug> i = ( i / 8 ) * 8 + 8 - 1 ; if ( i >= REG_MBK_CACHE_SIZE ) break ; } else { if ( cacheCounter [ i ] <= lowerCounter ) { lowerCounter = cacheCounter [ i ] ; slot = i ; if ( ! lowerCounter ) break ; } } } return slot ; }
|
<S2SV_ModStart> ( ) { # ifdef DEBUG nocashMessage ( "\\narm9<S2SV_blank>allocateCacheSlot\\n" ) ; # endif <S2SV_ModStart> 8 ) || ( cacheCounter [ i ] && <S2SV_ModStart> isSlotAccessibleFromArm9 ( i )
|
7,993 |
CWE-000 int init_front ( ) { init_front_global_variables ( ) ; init_ast ( ) ; <S2SV_StartBug> init_spec ( ) ; <S2SV_EndBug> init_lexical ( ) ; init_macro ( ) ; init_seman ( ) ; yyrestart ( fp ) ; yycurline = yytext ; front_has_been_inited = true ; if ( is_only_preprocessor ) { preprocessor ( ) ; } else { is_syntax_error = false ; reset_yylines ( ) ; yyparse ( ) ; if ( is_print_ast ) print_ast ( astroot ) ; } fclose ( fp ) ; return 0 ; }
|
<S2SV_ModStart> ) ; init_spec ( ) ; init_scope
|
7,994 |
CWE-000 static int __smsg_eager_msg_w_data ( void * data , void * msg ) { int ret = FI_SUCCESS ; gni_return_t status ; struct gnix_vc * vc = ( struct gnix_vc * ) data ; struct gnix_smsg_eager_hdr * hdr = ( struct gnix_smsg_eager_hdr * ) msg ; struct gnix_fid_ep * ep ; struct gnix_fab_req * req = NULL ; void * data_ptr ; struct gnix_tag_storage * unexp_queue ; struct gnix_tag_storage * posted_queue ; fastlock_t * queue_lock ; int tagged ; GNIX_TRACE ( FI_LOG_EP_DATA , "\\n" ) ; ep = vc -> ep ; assert ( ep ) ; data_ptr = ( void * ) ( ( char * ) msg + sizeof ( * hdr ) ) ; tagged = ! ! ( hdr -> flags & FI_TAGGED ) ; __gnix_msg_queues ( ep , tagged , & queue_lock , & posted_queue , & unexp_queue ) ; COND_ACQUIRE ( ep -> requires_lock , queue_lock ) ; req = _gnix_match_tag ( posted_queue , hdr -> msg_tag , 0 , FI_PEEK , NULL , & vc -> peer_addr ) ; if ( req ) { req -> addr = vc -> peer_addr ; req -> gnix_ep = ep ; req -> vc = vc ; req -> msg . cum_send_len = hdr -> len ; req -> msg . send_flags = hdr -> flags ; req -> msg . send_iov_cnt = 1 ; req -> msg . tag = hdr -> msg_tag ; req -> msg . imm = hdr -> imm ; GNIX_DEBUG ( FI_LOG_EP_DATA , "Matched<S2SV_blank>req:<S2SV_blank>%p<S2SV_blank>(%p,<S2SV_blank>%u)\\n" , req , req -> msg . recv_info [ 0 ] . recv_addr , req -> msg . cum_send_len ) ; __gnix_msg_copy_data_to_recv_addr ( req , data_ptr ) ; <S2SV_StartBug> __gnix_msg_recv_completion ( ep , req ) ; <S2SV_EndBug> if ( ( req -> msg . recv_flags & FI_MULTI_RECV ) && <S2SV_StartBug> ( ( req -> msg . cum_recv_len - req -> msg . cum_send_len ) >= <S2SV_EndBug> ep -> min_multi_recv ) ) { GNIX_DEBUG ( FI_LOG_EP_DATA , "Re-using<S2SV_blank>req:<S2SV_blank>%p\\n" , req ) ; <S2SV_StartBug> req -> msg . recv_info [ 0 ] . recv_addr += req -> msg . send_info [ 0 ] . send_len ; <S2SV_EndBug> req -> msg . recv_info [ 0 ] . recv_len -= req -> msg . cum_send_len ; req -> msg . cum_recv_len = req -> msg . recv_info [ 0 ] . recv_len ; } else { GNIX_DEBUG ( FI_LOG_EP_DATA , "Freeing<S2SV_blank>req:<S2SV_blank>%p\\n" , req ) ; _gnix_remove_tag ( posted_queue , req ) ; _gnix_fr_free ( ep , req ) ; } } else { req = _gnix_fr_alloc ( ep ) ; if ( req == NULL ) { COND_RELEASE ( ep -> requires_lock , queue_lock ) ; return - FI_ENOMEM ; } req -> msg . send_info [ 0 ] . send_addr = ( uint64_t ) malloc ( hdr -> len ) ; if ( unlikely ( req -> msg . send_info [ 0 ] . send_addr == 0ULL ) ) { COND_RELEASE ( ep -> requires_lock , queue_lock ) ; _gnix_fr_free ( ep , req ) ; return - FI_ENOMEM ; } req -> type = GNIX_FAB_RQ_RECV ; req -> addr = vc -> peer_addr ; req -> gnix_ep = ep ; req -> vc = vc ; req -> msg . cum_send_len = hdr -> len ; req -> msg . send_info [ 0 ] . send_len = hdr -> len ; req -> msg . send_iov_cnt = 1 ; req -> msg . send_flags = hdr -> flags ; req -> msg . tag = hdr -> msg_tag ; req -> msg . imm = hdr -> imm ; memcpy ( ( void * ) req -> msg . send_info [ 0 ] . send_addr , data_ptr , hdr -> len ) ; req -> addr = vc -> peer_addr ; _gnix_insert_tag ( unexp_queue , req -> msg . tag , req , ~ 0 ) ; GNIX_DEBUG ( FI_LOG_EP_DATA , "New<S2SV_blank>req:<S2SV_blank>%p<S2SV_blank>(%u)\\n" , req , req -> msg . cum_send_len ) ; } COND_RELEASE ( ep -> requires_lock , queue_lock ) ; status = GNI_SmsgRelease ( vc -> gni_ep ) ; if ( unlikely ( status != GNI_RC_SUCCESS ) ) { GNIX_WARN ( FI_LOG_EP_DATA , "GNI_SmsgRelease<S2SV_blank>returned<S2SV_blank>%s\\n" , gni_err_str [ status ] ) ; ret = gnixu_to_fi_errno ( status ) ; } return ret ; }
|
<S2SV_ModStart> data_ptr ) ; <S2SV_ModEnd> if ( ( <S2SV_ModStart> . cum_send_len ) < ep -> min_multi_recv ) ) req -> msg . recv_flags &= ~ GNIX_MSG_MULTI_RECV_SUP ; __gnix_msg_recv_completion ( ep , req ) ; if ( ( req -> msg . recv_flags & FI_MULTI_RECV ) && ( ( req -> msg . cum_recv_len - req -> msg . cum_send_len ) <S2SV_ModStart> -> msg . cum_send_len <S2SV_ModEnd> ; req ->
|
7,995 |
CWE-000 static int qed_hw_init_pf_doorbell_bar ( struct qed_hwfn * p_hwfn , struct qed_ptt * p_ptt ) { u32 pwm_regsize , norm_regsize ; u32 non_pwm_conn , min_addr_reg1 ; u32 db_bar_size , n_cpus ; u32 roce_edpm_mode ; u32 pf_dems_shift ; int rc = 0 ; u8 cond ; db_bar_size = qed_hw_bar_size ( p_hwfn , BAR_ID_1 ) ; if ( p_hwfn -> cdev -> num_hwfns > 1 ) db_bar_size /= 2 ; non_pwm_conn = qed_cxt_get_proto_cid_start ( p_hwfn , PROTOCOLID_CORE ) + qed_cxt_get_proto_cid_count ( p_hwfn , PROTOCOLID_CORE , NULL ) + qed_cxt_get_proto_cid_count ( p_hwfn , PROTOCOLID_ETH , NULL ) ; norm_regsize = roundup ( QED_PF_DEMS_SIZE * non_pwm_conn , 4096 ) ; min_addr_reg1 = norm_regsize / 4096 ; pwm_regsize = db_bar_size - norm_regsize ; if ( db_bar_size < norm_regsize ) { DP_ERR ( p_hwfn -> cdev , "Doorbell<S2SV_blank>BAR<S2SV_blank>size<S2SV_blank>0x%x<S2SV_blank>is<S2SV_blank>too<S2SV_blank>small<S2SV_blank>(normal<S2SV_blank>region<S2SV_blank>is<S2SV_blank>0x%0x<S2SV_blank>)\\n" , db_bar_size , norm_regsize ) ; return - EINVAL ; } if ( pwm_regsize < QED_MIN_PWM_REGION ) { DP_ERR ( p_hwfn -> cdev , "PWM<S2SV_blank>region<S2SV_blank>size<S2SV_blank>0x%0x<S2SV_blank>is<S2SV_blank>too<S2SV_blank>small.<S2SV_blank>Should<S2SV_blank>be<S2SV_blank>at<S2SV_blank>least<S2SV_blank>0x%0x<S2SV_blank>(Doorbell<S2SV_blank>BAR<S2SV_blank>size<S2SV_blank>is<S2SV_blank>0x%x<S2SV_blank>and<S2SV_blank>normal<S2SV_blank>region<S2SV_blank>size<S2SV_blank>is<S2SV_blank>0x%0x)\\n" , pwm_regsize , QED_MIN_PWM_REGION , db_bar_size , norm_regsize ) ; return - EINVAL ; } roce_edpm_mode = p_hwfn -> pf_params . rdma_pf_params . roce_edpm_mode ; if ( ( roce_edpm_mode == QED_ROCE_EDPM_MODE_ENABLE ) || ( ( roce_edpm_mode == QED_ROCE_EDPM_MODE_FORCE_ON ) ) ) { <S2SV_StartBug> n_cpus = num_active_cpus ( ) ; <S2SV_EndBug> rc = qed_hw_init_dpi_size ( p_hwfn , p_ptt , pwm_regsize , n_cpus ) ; } cond = ( rc && ( roce_edpm_mode == QED_ROCE_EDPM_MODE_ENABLE ) ) || ( roce_edpm_mode == QED_ROCE_EDPM_MODE_DISABLE ) ; if ( cond || p_hwfn -> dcbx_no_edpm ) { n_cpus = 1 ; rc = qed_hw_init_dpi_size ( p_hwfn , p_ptt , pwm_regsize , n_cpus ) ; if ( cond ) qed_rdma_dpm_bar ( p_hwfn , p_ptt ) ; } DP_INFO ( p_hwfn , "doorbell<S2SV_blank>bar:<S2SV_blank>normal_region_size=%d,<S2SV_blank>pwm_region_size=%d,<S2SV_blank>dpi_size=%d,<S2SV_blank>dpi_count=%d,<S2SV_blank>roce_edpm=%s\\n" , norm_regsize , pwm_regsize , p_hwfn -> dpi_size , p_hwfn -> dpi_count , ( ( p_hwfn -> dcbx_no_edpm ) || ( p_hwfn -> db_bar_no_edpm ) ) ? "disabled" : "enabled" ) ; if ( rc ) { DP_ERR ( p_hwfn , "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>enough<S2SV_blank>DPIs.<S2SV_blank>Allocated<S2SV_blank>%d<S2SV_blank>but<S2SV_blank>the<S2SV_blank>current<S2SV_blank>minimum<S2SV_blank>is<S2SV_blank>%d.\\n" , p_hwfn -> dpi_count , p_hwfn -> pf_params . rdma_pf_params . min_dpis ) ; return - EINVAL ; } p_hwfn -> dpi_start_offset = norm_regsize ; pf_dems_shift = ilog2 ( QED_PF_DEMS_SIZE / 4 ) ; qed_wr ( p_hwfn , p_ptt , DORQ_REG_PF_ICID_BIT_SHIFT_NORM , pf_dems_shift ) ; qed_wr ( p_hwfn , p_ptt , DORQ_REG_PF_MIN_ADDR_REG1 , min_addr_reg1 ) ; return 0 ; }
|
<S2SV_ModStart> { n_cpus = num_present_cpus <S2SV_ModEnd> ( ) ;
|
7,996 |
CWE-000 void print_buckets ( ) { for ( int i = 0 ; i < __c -> size ; ++ i ) { Data * head = __c -> buckets [ i ] -> head ; <S2SV_StartBug> if ( head ) { <S2SV_EndBug> puts ( "\\n" ) ; puts ( "Bucket:" ) ; } while ( head != NULL ) { printf ( "(%s,<S2SV_blank>%s)->" , head -> key , head -> value ) ; head = head -> next ; } } }
|
<S2SV_ModStart> if ( head != NULL
|
7,997 |
CWE-000 static int out_set_parameters ( struct audio_stream * stream , const char * kvpairs ) { struct stream_out * out = ( struct stream_out * ) stream ; struct audio_device * adev = out -> dev ; struct audio_usecase * usecase ; struct listnode * node ; struct str_parms * parms ; char value [ 32 ] ; int ret , val = 0 ; bool select_new_device = false ; int status = 0 ; ALOGD ( "%s:<S2SV_blank>enter:<S2SV_blank>usecase(%d:<S2SV_blank>%s)<S2SV_blank>kvpairs:<S2SV_blank>%s" , __func__ , out -> usecase , use_case_table [ out -> usecase ] , kvpairs ) ; parms = str_parms_create_str ( kvpairs ) ; ret = str_parms_get_str ( parms , AUDIO_PARAMETER_STREAM_ROUTING , value , sizeof ( value ) ) ; if ( ret >= 0 ) { val = atoi ( value ) ; pthread_mutex_lock ( & out -> lock ) ; pthread_mutex_lock ( & adev -> lock ) ; if ( out -> devices == AUDIO_DEVICE_OUT_AUX_DIGITAL && val == AUDIO_DEVICE_NONE ) { val = AUDIO_DEVICE_OUT_SPEAKER ; } if ( val != 0 ) { out -> devices = val ; if ( ! out -> standby ) select_devices ( adev , out -> usecase ) ; if ( ( adev -> mode == AUDIO_MODE_IN_CALL ) && output_drives_call ( adev , out ) ) { if ( adev -> current_call_output != out ) { voice_stop_call ( adev ) ; } if ( ! voice_is_in_call ( adev ) ) { <S2SV_StartBug> ret = voice_start_call ( adev , out ) ; <S2SV_EndBug> adev -> current_call_output = out ; } else voice_update_devices_for_all_voice_usecases ( adev ) ; } } if ( ( adev -> mode == AUDIO_MODE_NORMAL ) && voice_is_in_call ( adev ) && output_drives_call ( adev , out ) ) { ret = voice_stop_call ( adev ) ; adev -> current_call_output = NULL ; } pthread_mutex_unlock ( & adev -> lock ) ; pthread_mutex_unlock ( & out -> lock ) ; } if ( out -> usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD ) { parse_compress_metadata ( out , parms ) ; } str_parms_destroy ( parms ) ; ALOGV ( "%s:<S2SV_blank>exit:<S2SV_blank>code(%d)" , __func__ , status ) ; return status ; }
|
<S2SV_ModStart> ) ) { adev -> current_call_output = out ; <S2SV_ModStart> voice_start_call ( adev ) <S2SV_ModEnd> ; } else
|
7,998 |
CWE-000 static void scu_stp_raw_request_construct_task_context ( struct isci_request * ireq ) { struct scu_task_context * task_context = ireq -> tc ; <S2SV_StartBug> scu_sata_reqeust_construct_task_context ( ireq , task_context ) ; <S2SV_EndBug> task_context -> control_frame = 0 ; task_context -> priority = SCU_TASK_PRIORITY_NORMAL ; task_context -> task_type = SCU_TASK_TYPE_SATA_RAW_FRAME ; task_context -> type . stp . fis_type = FIS_REGH2D ; task_context -> transfer_length_bytes = sizeof ( struct host_to_dev_fis ) - sizeof ( u32 ) ; }
|
<S2SV_ModStart> -> tc ; scu_sata_request_construct_task_context <S2SV_ModEnd> ( ireq ,
|
7,999 |
CWE-000 static int bpf_skb_proto_6_to_4 ( struct sk_buff * skb ) { const u32 len_diff = sizeof ( struct ipv6hdr ) - sizeof ( struct iphdr ) ; u32 off = skb_mac_header_len ( skb ) ; int ret ; <S2SV_StartBug> ret = skb_unclone ( skb , GFP_ATOMIC ) ; <S2SV_EndBug> if ( unlikely ( ret < 0 ) ) return ret ; ret = bpf_skb_net_hdr_pop ( skb , off , len_diff ) ; if ( unlikely ( ret < 0 ) ) return ret ; if ( skb_is_gso ( skb ) ) { <S2SV_StartBug> if ( skb_shinfo ( skb ) -> gso_type & SKB_GSO_TCPV6 ) { <S2SV_EndBug> <S2SV_StartBug> skb_shinfo ( skb ) -> gso_type &= ~ SKB_GSO_TCPV6 ; <S2SV_EndBug> <S2SV_StartBug> skb_shinfo ( skb ) -> gso_type |= SKB_GSO_TCPV4 ; <S2SV_EndBug> } <S2SV_StartBug> skb_shinfo ( skb ) -> gso_size += len_diff ; <S2SV_EndBug> skb_shinfo ( skb ) -> gso_type |= SKB_GSO_DODGY ; <S2SV_StartBug> skb_shinfo ( skb ) -> gso_segs = 0 ; <S2SV_EndBug> } skb -> protocol = htons ( ETH_P_IP ) ; skb_clear_hash ( skb ) ; return 0 ; }
|
<S2SV_ModStart> int ret ; if ( skb_is_gso ( skb ) && unlikely ( skb_is_gso_sctp ( skb ) ) ) return - ENOTSUPP ; <S2SV_ModStart> ) ) { struct skb_shared_info * shinfo = <S2SV_ModEnd> skb_shinfo ( skb <S2SV_ModStart> ( skb ) ; if ( shinfo <S2SV_ModStart> SKB_GSO_TCPV6 ) { shinfo <S2SV_ModEnd> -> gso_type &= <S2SV_ModStart> ~ SKB_GSO_TCPV6 ; shinfo <S2SV_ModEnd> -> gso_type |= <S2SV_ModStart> SKB_GSO_TCPV4 ; } skb_increase_gso_size ( shinfo , len_diff ) ; shinfo <S2SV_ModEnd> -> gso_type |= <S2SV_ModStart> |= SKB_GSO_DODGY ; shinfo <S2SV_ModEnd> -> gso_segs =
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.