Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
6,500 | CWE-000 void wlan_hdd_three_connections_scenario ( hdd_context_t * hdd_ctx , uint8_t first_chnl , uint8_t second_chnl , enum cds_chain_mode chain_mask , uint8_t use_same_mac ) { uint8_t vdevid_1 = 0 , tx_stream_1 = 2 , rx_stream_1 = 2 ; uint8_t vdevid_2 = 1 , tx_stream_2 = 2 , rx_stream_2 = 2 ; uint8_t channel_id_1 = first_chnl , channel_id_2 = second_chnl ; uint8_t mac_id_1 , mac_id_2 ; uint8_t type_1 = WMI_VDEV_TYPE_STA , type_2 = WMI_VDEV_TYPE_STA ; uint8_t pcl [ MAX_NUM_CHAN ] = { 0 } , weight_list [ MAX_NUM_CHAN ] = { 0 } ; uint32_t pcl_len = 0 ; enum cds_chain_mode chain_mask_1 ; enum cds_chain_mode chain_mask_2 ; enum cds_con_mode sub_type_1 , sub_type_2 , next_sub_type ; enum cds_con_mode dummy_type_1 , dummy_type_2 ; <S2SV_StartBug> enum cds_conc_priority_mode system_pref = <S2SV_EndBug> hdd_ctx -> config -> conc_system_pref ; enum cds_pcl_type pcl_type ; enum cds_two_connection_mode third_index ; char reason [ 20 ] = { 0 } ; bool status = false ; QDF_STATUS ret ; struct cds_sme_cbacks sme_cbacks ; <S2SV_StartBug> if ( chain_mask == CDS_TWO_TWO ) { <S2SV_EndBug> mac_id_1 = 1 ; mac_id_2 = 1 ; chain_mask_1 = CDS_TWO_TWO ; chain_mask_2 = CDS_TWO_TWO ; } else if ( use_same_mac == 1 ) { mac_id_1 = 1 ; mac_id_2 = 1 ; chain_mask_1 = CDS_ONE_ONE ; chain_mask_2 = CDS_ONE_ONE ; } else { mac_id_1 = 1 ; mac_id_2 = 2 ; chain_mask_1 = CDS_ONE_ONE ; chain_mask_2 = CDS_ONE_ONE ; } for ( sub_type_1 = CDS_STA_MODE ; sub_type_1 < CDS_MAX_NUM_OF_MODE ; sub_type_1 ++ ) { type_1 = wlan_hdd_valid_type_of_persona ( sub_type_1 ) ; sme_cbacks . sme_get_valid_channels = sme_get_cfg_valid_channels ; sme_cbacks . sme_get_nss_for_vdev = sme_get_vdev_type_nss ; ret = cds_init_policy_mgr ( & sme_cbacks ) ; if ( ! QDF_IS_STATUS_SUCCESS ( ret ) ) { hdd_err ( "Policy<S2SV_blank>manager<S2SV_blank>initialization<S2SV_blank>failed" ) ; return ; } wlan_hdd_map_subtypes_hdd_wma ( & dummy_type_1 , & sub_type_1 ) ; cds_incr_connection_count_utfw ( vdevid_1 , tx_stream_1 , rx_stream_1 , chain_mask_1 , type_1 , dummy_type_1 , channel_id_1 , mac_id_1 ) ; if ( cds_get_connection_count ( ) != 1 ) { hdd_err ( "Test<S2SV_blank>fail<S2SV_blank>-<S2SV_blank>No.<S2SV_blank>of<S2SV_blank>connection<S2SV_blank>not<S2SV_blank>1" ) ; return ; } for ( sub_type_2 = CDS_STA_MODE ; sub_type_2 < CDS_MAX_NUM_OF_MODE ; sub_type_2 ++ ) { type_2 = wlan_hdd_valid_type_of_persona ( sub_type_2 ) ; wlan_hdd_map_subtypes_hdd_wma ( & dummy_type_2 , & sub_type_2 ) ; cds_incr_connection_count_utfw ( vdevid_2 , tx_stream_2 , rx_stream_2 , chain_mask_2 , type_2 , dummy_type_2 , channel_id_2 , mac_id_2 ) ; if ( cds_get_connection_count ( ) != 2 ) { hdd_err ( "Test<S2SV_blank>fail<S2SV_blank>-<S2SV_blank>No.<S2SV_blank>connection<S2SV_blank>not<S2SV_blank>2" ) ; return ; } next_sub_type = CDS_STA_MODE ; while ( next_sub_type < CDS_MAX_NUM_OF_MODE ) { third_index = cds_get_third_connection_pcl_table_index ( ) ; if ( CDS_MAX_TWO_CONNECTION_MODE == third_index ) { next_sub_type ++ ; continue ; } qdf_mem_zero ( pcl , sizeof ( pcl ) ) ; pcl_len = 0 ; pcl_type = get_pcl_from_third_conn_table ( third_index , next_sub_type , system_pref , wma_is_hw_dbs_capable ( ) ) ; cds_get_pcl ( next_sub_type , pcl , & pcl_len , weight_list , QDF_ARRAY_SIZE ( weight_list ) ) ; status = wlan_hdd_validate_pcl ( hdd_ctx , pcl_type , pcl , pcl_len , channel_id_1 , channel_id_2 , reason , sizeof ( reason ) ) ; if ( ( pcl_type == CDS_MAX_PCL_TYPE ) && ( pcl [ 0 ] == 0 ) ) { next_sub_type ++ ; continue ; } fill_report ( hdd_ctx , "3<S2SV_blank>connections" , sub_type_1 , sub_type_2 , next_sub_type , first_chnl , second_chnl , 0 , status , pcl_type , reason , pcl ) ; next_sub_type ++ ; } cds_decr_connection_count ( vdevid_2 ) ; } next_sub_type = CDS_STA_MODE ; } } | <S2SV_ModStart> enum cds_conc_priority_mode system_pref <S2SV_ModEnd> ; enum cds_pcl_type <S2SV_ModStart> cds_sme_cbacks sme_cbacks ; system_pref = cds_get_cur_conc_system_pref ( ) ; |
6,501 | CWE-000 int tls_session_verify_callback ( int ok , X509_STORE_CTX * ctx ) { SSL * ssl = ( SSL * ) X509_STORE_CTX_get_ex_data ( ctx , SSL_get_ex_data_X509_STORE_CTX_idx ( ) ) ; TLSSession * self = SSL_get_app_data ( ssl ) ; if ( X509_STORE_CTX_get_current_cert ( ctx ) == NULL ) { int ctx_error = X509_STORE_CTX_get_error ( ctx ) ; switch ( ctx_error ) { case X509_V_ERR_NO_EXPLICIT_POLICY : ok = 1 ; break ; default : msg_notice ( "Error<S2SV_blank>occured<S2SV_blank>during<S2SV_blank>certificate<S2SV_blank>validation" , <S2SV_StartBug> evt_tag_int ( "error" , X509_STORE_CTX_get_error ( ctx ) ) ) ; <S2SV_EndBug> break ; } } else { ok = tls_session_verify ( self , ok , ctx ) ; tls_log_certificate_validation_progress ( ok , ctx ) ; if ( self -> verify_func ) return self -> verify_func ( ok , ctx , self -> verify_data ) ; } return ok ; } | <S2SV_ModStart> ctx ) ) , tls_context_format_location_tag ( self -> ctx ) |
6,502 | CWE-000 static ret_code_t led_status_send_to_all ( uint8_t button_action ) { ret_code_t err_code ; for ( uint32_t i = 0 ; i < NRF_SDH_BLE_CENTRAL_LINK_COUNT ; i ++ ) { err_code = ble_lbs_led_status_send ( & m_lbs_c [ i ] , button_action ) ; if ( err_code != NRF_SUCCESS ) { <S2SV_StartBug> err_code = ble_thingy_uis_led_set_constant ( & m_thingy_uis_c [ i ] , button_action ? 255 : 0 , button_action ? 255 : 0 , button_action ? 255 : 0 ) ; <S2SV_EndBug> if ( err_code != NRF_SUCCESS && err_code != BLE_ERROR_INVALID_CONN_HANDLE && err_code != NRF_ERROR_INVALID_STATE ) { return err_code ; } } } return NRF_SUCCESS ; } | <S2SV_ModStart> { err_code = ble_thingy_uis_led_set_on_off <S2SV_ModEnd> ( & m_thingy_uis_c <S2SV_ModStart> ] , button_action <S2SV_ModEnd> ) ; if |
6,503 | CWE-000 void FTM_ChannelInit ( FTM_Type * pFTM , uint8_t u8FTM_Channel , FTM_ChParamsType pTFTMCH_Params ) { if ( pFTM0 == pFTM ) { SIM -> SCGC |= SIM_SCGC_FTM0_MASK ; } else if ( pFTM1 == pFTM ) { SIM -> SCGC |= SIM_SCGC_FTM1_MASK ; } else { SIM -> SCGC |= SIM_SCGC_FTM2_MASK ; } if ( pTFTMCH_Params . ctrl . bits . bMode == FTM_INPUT_CAPTURE ) { <S2SV_StartBug> pFTM -> CONTROLS [ u8FTM_Channel ] . CnSC |= 0b00 << 4 ; <S2SV_EndBug> pFTM -> CONTROLS [ u8FTM_Channel ] . CnSC |= pTFTMCH_Params . ctrl . bits . bEdge << 2 ; } else if ( pTFTMCH_Params . ctrl . bits . bMode == FTM_OUTPUT_COMPARE ) { pFTM -> CONTROLS [ u8FTM_Channel ] . CnSC |= FTM_CnSC_MSA_MASK ; pFTM -> CONTROLS [ u8FTM_Channel ] . CnSC |= pTFTMCH_Params . ctrl . bits . bOutCmp << 2 ; } else if ( pTFTMCH_Params . ctrl . bits . bMode == FTM_PWMMODE_EDGEALLIGNED ) { pFTM -> CONTROLS [ u8FTM_Channel ] . CnSC |= FTM_CnSC_MSB_MASK ; pFTM -> CONTROLS [ u8FTM_Channel ] . CnSC |= pTFTMCH_Params . ctrl . bits . bPWMPol << 2 ; } else if ( pTFTMCH_Params . ctrl . bits . bMode == FTM_PWMMODE_CENTERALLIGNED ) { pFTM -> SC |= FTM_SC_CPWMS_MASK ; pFTM -> CONTROLS [ u8FTM_Channel ] . CnSC |= pTFTMCH_Params . ctrl . bits . bPWMPol << 2 ; } else if ( pTFTMCH_Params . ctrl . bits . bMode == FTM_PWMMODE_COMBINE ) { pFTM -> CONTROLS [ u8FTM_Channel ] . CnSC |= FTM_CnSC_MSA_MASK | FTM_CnSC_MSB_MASK | pTFTMCH_Params . ctrl . bits . bPWMPol << 2 ; } else if ( pTFTMCH_Params . ctrl . bits . bMode == FTM_INPUTCAPTURE_DUALEDGE ) { pFTM -> CONTROLS [ u8FTM_Channel ] . CnSC |= pTFTMCH_Params . ctrl . bits . bEdge << 2 ; if ( pTFTMCH_Params . ctrl . bits . bDualCapMode == FTM_INPUTCAPTURE_DUALEDGE_ONESHOT ) { pFTM -> CONTROLS [ u8FTM_Channel ] . CnSC &= ~ FTM_CnSC_MSA_MASK ; } else if ( pTFTMCH_Params . ctrl . bits . bDualCapMode == FTM_INPUTCAPTURE_DUALEDGE_CONTINUOUS ) { pFTM -> CONTROLS [ u8FTM_Channel ] . CnSC |= FTM_CnSC_MSA_MASK ; } } if ( 1 == pTFTMCH_Params . ctrl . bits . bCHIE ) { pFTM -> CONTROLS [ u8FTM_Channel ] . CnSC |= FTM_CnSC_CHIE_MASK ; if ( pFTM0 == pFTM ) { NVIC_ClearPendingIRQ ( FTM0_IRQn ) ; NVIC_EnableIRQ ( FTM0_IRQn ) ; } else if ( pFTM1 == pFTM ) { NVIC_ClearPendingIRQ ( FTM1_IRQn ) ; NVIC_EnableIRQ ( FTM1_IRQn ) ; } else { NVIC_ClearPendingIRQ ( FTM2_IRQn ) ; NVIC_EnableIRQ ( FTM2_IRQn ) ; } } pFTM -> CONTROLS [ u8FTM_Channel ] . CnV = pTFTMCH_Params . u16CnV ; return ; } | <S2SV_ModStart> . CnSC |= 0 <S2SV_ModEnd> << 4 ; |
6,504 | CWE-000 int local_listen ( char * host , char * port , struct addrinfo hints ) { struct addrinfo * res , * res0 ; int s , ret , x = 1 ; int error ; hints . ai_flags |= AI_PASSIVE ; if ( host == NULL && hints . ai_family == AF_UNSPEC ) hints . ai_family = AF_INET ; if ( ( error = getaddrinfo ( host , port , & hints , & res ) ) ) errx ( 1 , "getaddrinfo:<S2SV_blank>%s" , gai_strerror ( error ) ) ; res0 = res ; do { if ( ( s = socket ( res0 -> ai_family , res0 -> ai_socktype , res0 -> ai_protocol ) ) < 0 ) continue ; if ( rtableid >= 0 && ( setsockopt ( s , SOL_SOCKET , SO_SETFIB , & rtableid , sizeof ( rtableid ) ) == - 1 ) ) err ( 1 , "setsockopt<S2SV_blank>SO_SETFIB" ) ; ret = setsockopt ( s , SOL_SOCKET , SO_REUSEPORT , & x , sizeof ( x ) ) ; if ( ret == - 1 ) err ( 1 , NULL ) ; <S2SV_StartBug> # ifdef IPSEC <S2SV_EndBug> if ( ipsec_policy [ 0 ] != NULL ) add_ipsec_policy ( s , ipsec_policy [ 0 ] ) ; if ( ipsec_policy [ 1 ] != NULL ) add_ipsec_policy ( s , ipsec_policy [ 1 ] ) ; # endif if ( FreeBSD_Oflag ) { if ( setsockopt ( s , IPPROTO_TCP , TCP_NOOPT , & FreeBSD_Oflag , sizeof ( FreeBSD_Oflag ) ) == - 1 ) err ( 1 , "disable<S2SV_blank>TCP<S2SV_blank>options" ) ; } set_common_sockopts ( s , res0 -> ai_family ) ; if ( bind ( s , ( struct sockaddr * ) res0 -> ai_addr , res0 -> ai_addrlen ) == 0 ) break ; close ( s ) ; s = - 1 ; } while ( ( res0 = res0 -> ai_next ) != NULL ) ; if ( ! uflag && s != - 1 ) { if ( listen ( s , 1 ) < 0 ) err ( 1 , "listen" ) ; } freeaddrinfo ( res ) ; return ( s ) ; } | <S2SV_ModStart> NULL ) ; <S2SV_ModEnd> if ( FreeBSD_Oflag |
6,505 | CWE-000 int gather ( double tgt_lon , int tgt_hour , int preceding_days , int total_days ) { size_t time , day , lvl , lat , lon , src_idx , dst_idx ; size_t tgt_lon_idx , tgt_lon_bin , cur_lon_bin ; size_t starts [ vars [ VAR_ID_SPECIAL ] . num_dims ] ; size_t counts [ vars [ VAR_ID_SPECIAL ] . num_dims ] ; int time_start , time_end , time_N , pre_diff , post_diff , time_offset ; float * lon_data , * var_data , * output_data , * prev_data , * next_data , tgt_data ; Variable output , * next_vars ; Dimension * next_dims ; char prev_file [ 256 ] ; char next_file [ 256 ] ; DAY_STRIDE = LEAP_YEAR ? dims [ DIM_ID_TIME ] . length / 366 : dims [ DIM_ID_TIME ] . length / 365 ; if ( DAY_STRIDE != 24 ) { <S2SV_StartBug> fprintf ( stderr , "NCAR/NCEP<S2SV_blank>Reanalysis<S2SV_blank>file<S2SV_blank>\'%s\'<S2SV_blank>variable<S2SV_blank>\'%s\'<S2SV_blank>must<S2SV_blank>have<S2SV_blank>24<S2SV_blank>time<S2SV_blank>indices<S2SV_blank>per<S2SV_blank>day.\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Broader<S2SV_blank>and<S2SV_blank>finer<S2SV_blank>granularities<S2SV_blank>currently<S2SV_blank>unsupported.\\n" , input_file_name , vars [ VAR_ID_SPECIAL ] . name ) ; <S2SV_EndBug> return 1 ; } time_start = DAY_STRIDE * preceding_days + tgt_hour ; time_end = DAY_STRIDE * ( preceding_days + total_days ) + tgt_hour ; time_N = time_end - time_start ; if ( find_longitude ( & tgt_lon_idx , & tgt_lon_bin , tgt_lon ) ) { <S2SV_StartBug> fprintf ( stderr , "Longitude<S2SV_blank>(%f)<S2SV_blank>invalid<S2SV_blank>or<S2SV_blank>not<S2SV_blank>found<S2SV_blank>in<S2SV_blank>reanalysis<S2SV_blank>variable.\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Cannot<S2SV_blank>proceed;<S2SV_blank>terminating.\\n" , tgt_lon ) ; <S2SV_EndBug> return 1 ; } for ( int i = 0 ; i < TIME_ZONE_N ; i ++ ) { TIME_ZONE_OFFSET [ i ] = TIME_ZONE [ i ] - TIME_ZONE [ tgt_lon_bin ] ; printf ( "tz[%d]<S2SV_blank>=<S2SV_blank>%d\\n" , i , TIME_ZONE_OFFSET [ i ] ) ; } pre_diff = time_start - 12 ; post_diff = time_end + 12 ; printf ( "Time<S2SV_blank>pre:<S2SV_blank>%d\\n" , pre_diff ) ; if ( pre_diff < 0 ) { <S2SV_StartBug> printf ( "Time<S2SV_blank>dimension<S2SV_blank>initial<S2SV_blank>indices<S2SV_blank>less<S2SV_blank>than<S2SV_blank>zero<S2SV_blank>in<S2SV_blank>Eastward<S2SV_blank>direction<S2SV_blank>(likely<S2SV_blank>due<S2SV_blank>to<S2SV_blank>January<S2SV_blank>selection).\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Searching<S2SV_blank>for<S2SV_blank>previous<S2SV_blank>year<S2SV_blank>.nc<S2SV_blank>file<S2SV_blank>in<S2SV_blank>directory\\n" ) ; <S2SV_EndBug> find_target_file ( prev_file_path , prev_file_name , input_dir , INPUT_YEAR - 1 ) ; ___nc_open ( prev_file_path , & PREV_FILE_ID ) ; populate_buffer_file ( PREV_FILE_ID , & prev_vars , & prev_dims ) ; prev_data = prev_vars [ VAR_ID_SPECIAL ] . data ; } printf ( "Time<S2SV_blank>post:<S2SV_blank>%d\\n" , post_diff ) ; if ( post_diff > dims [ DIM_ID_TIME ] . length ) { <S2SV_StartBug> printf ( "Time<S2SV_blank>dimension<S2SV_blank>final<S2SV_blank>indices<S2SV_blank>greater<S2SV_blank>than<S2SV_blank>length<S2SV_blank>of<S2SV_blank>.nc<S2SV_blank>file<S2SV_blank>in<S2SV_blank>Westward<S2SV_blank>direction<S2SV_blank>(likely<S2SV_blank>due<S2SV_blank>to<S2SV_blank>December<S2SV_blank>selection).\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Searching<S2SV_blank>for<S2SV_blank>next<S2SV_blank>year<S2SV_blank>.nc<S2SV_blank>file<S2SV_blank>in<S2SV_blank>directory\\n" ) ; <S2SV_EndBug> find_target_file ( next_file_path , next_file_name , input_dir , INPUT_YEAR + 1 ) ; ___nc_open ( next_file_path , & NEXT_FILE_ID ) ; populate_buffer_file ( NEXT_FILE_ID , & next_vars , & next_dims ) ; next_data = next_vars [ VAR_ID_SPECIAL ] . data ; } memcpy ( & output , & vars [ VAR_ID_SPECIAL ] , sizeof ( Variable ) ) ; if ( NULL == ( output . data = malloc ( TIME_STRIDE * sizeof ( float ) ) ) ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>output<S2SV_blank>data<S2SV_blank>variable\\n" ) ; return 1 ; } for ( int i = 0 ; i < vars [ VAR_ID_SPECIAL ] . num_dims ; i ++ ) { starts [ i ] = 0 ; counts [ i ] = dims [ vars [ VAR_ID_SPECIAL ] . dim_ids [ i ] ] . length ; } counts [ 0 ] = 1 ; lon_data = vars [ VAR_ID_LON ] . data ; var_data = vars [ VAR_ID_SPECIAL ] . data ; output_data = output . data ; for ( time = time_start , day = 0 ; time < time_end && time < dims [ DIM_ID_TIME ] . length ; time += 24 , day ++ ) { printf ( "TIME:<S2SV_blank>%lu\\n" , time ) ; for ( lvl = 0 ; lvl < dims [ DIM_ID_LVL ] . length ; lvl ++ ) { for ( lat = 0 ; lat < dims [ DIM_ID_LAT ] . length ; lat ++ ) { for ( lon = 0 , cur_lon_bin = 0 ; lon < dims [ DIM_ID_LON ] . length ; lon ++ ) { if ( fmod ( lon_data [ lon ] , 15.0 ) == 7.5 || lon_data [ lon ] == 180.0 ) { cur_lon_bin += 1 ; } <S2SV_StartBug> time_offset = time + TIME_ZONE_OFFSET [ cur_lon_bin ] ; <S2SV_EndBug> if ( time_offset < 0 ) { time_offset = prev_dims [ DIM_ID_TIME ] . length + time_offset ; src_idx = ___access_nc_array ( time_offset , lvl , lat , lon ) ; tgt_data = prev_data [ src_idx ] ; } else if ( time_offset >= dims [ DIM_ID_TIME ] . length ) { time_offset = time_offset - dims [ DIM_ID_TIME ] . length ; src_idx = ___access_nc_array ( time_offset , lvl , lat , lon ) ; tgt_data = next_data [ src_idx ] ; } else { src_idx = ___access_nc_array ( time_offset , lvl , lat , lon ) ; tgt_data = var_data [ src_idx ] ; } dst_idx = ___access_nc_array ( 0 , lvl , lat , lon ) ; if ( time == time_start ) { output_data [ dst_idx ] = 0.0 ; } if ( MONTHLY_AVERAGE ) { output_data [ dst_idx ] += tgt_data / total_days ; } else { output_data [ dst_idx ] = tgt_data ; } } } } if ( ! MONTHLY_AVERAGE ) { starts [ 0 ] = day ; if ( ( retval = nc_put_vara_float ( OUTPUT_FILE_ID , output . id , starts , counts , output_data ) ) ) NC_ERR ( retval ) ; } } if ( MONTHLY_AVERAGE ) { starts [ 0 ] = 0 ; if ( ( retval = nc_put_vara_float ( OUTPUT_FILE_ID , output . id , starts , counts , output_data ) ) ) NC_ERR ( retval ) ; } nc_close ( INPUT_FILE_ID ) ; nc_close ( OUTPUT_FILE_ID ) ; return 0 ; } | <S2SV_ModStart> ( stderr , "NCAR/NCEP<S2SV_blank>Reanalysis<S2SV_blank>file<S2SV_blank>\'%s\'<S2SV_blank>variable<S2SV_blank>\'%s\'<S2SV_blank>must<S2SV_blank>have<S2SV_blank>24<S2SV_blank>time<S2SV_blank>indices<S2SV_blank>per<S2SV_blank>day.\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Broader<S2SV_blank>and<S2SV_blank>finer<S2SV_blank>granularities<S2SV_blank>currently<S2SV_blank>unsupported.\\n" <S2SV_ModEnd> , input_file_name , <S2SV_ModStart> ( stderr , "Longitude<S2SV_blank>(%f)<S2SV_blank>invalid<S2SV_blank>or<S2SV_blank>not<S2SV_blank>found<S2SV_blank>in<S2SV_blank>reanalysis<S2SV_blank>variable.\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Cannot<S2SV_blank>proceed;<S2SV_blank>terminating.\\n" <S2SV_ModEnd> , tgt_lon ) <S2SV_ModStart> { printf ( "Time<S2SV_blank>dimension<S2SV_blank>initial<S2SV_blank>indices<S2SV_blank>less<S2SV_blank>than<S2SV_blank>zero<S2SV_blank>in<S2SV_blank>Eastward<S2SV_blank>direction<S2SV_blank>(likely<S2SV_blank>due<S2SV_blank>to<S2SV_blank>January<S2SV_blank>selection).\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Searching<S2SV_blank>for<S2SV_blank>previous<S2SV_blank>year<S2SV_blank>.nc<S2SV_blank>file<S2SV_blank>in<S2SV_blank>directory\\n" <S2SV_ModEnd> ) ; find_target_file <S2SV_ModStart> { printf ( "Time<S2SV_blank>dimension<S2SV_blank>final<S2SV_blank>indices<S2SV_blank>greater<S2SV_blank>than<S2SV_blank>length<S2SV_blank>of<S2SV_blank>.nc<S2SV_blank>file<S2SV_blank>in<S2SV_blank>Westward<S2SV_blank>direction<S2SV_blank>(likely<S2SV_blank>due<S2SV_blank>to<S2SV_blank>December<S2SV_blank>selection).\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Searching<S2SV_blank>for<S2SV_blank>next<S2SV_blank>year<S2SV_blank>.nc<S2SV_blank>file<S2SV_blank>in<S2SV_blank>directory\\n" <S2SV_ModEnd> ) ; find_target_file <S2SV_ModStart> time_offset = time - <S2SV_ModEnd> TIME_ZONE_OFFSET [ cur_lon_bin |
6,506 | CWE-000 int msm_jpeg_platform_init ( struct platform_device * pdev , struct resource * * mem , void * * base , int * irq , irqreturn_t ( * handler ) ( int , void * ) , void * context ) { int rc = - 1 ; int jpeg_irq ; struct resource * jpeg_mem , * jpeg_io , * jpeg_irq_res ; void * jpeg_base ; struct msm_jpeg_device * pgmn_dev = ( struct msm_jpeg_device * ) context ; pgmn_dev -> state = MSM_JPEG_IDLE ; jpeg_mem = platform_get_resource ( pdev , IORESOURCE_MEM , 0 ) ; if ( ! jpeg_mem ) { JPEG_PR_ERR ( "%s:<S2SV_blank>no<S2SV_blank>mem<S2SV_blank>resource?\\n" , __func__ ) ; return - ENODEV ; } jpeg_irq_res = platform_get_resource ( pdev , IORESOURCE_IRQ , 0 ) ; if ( ! jpeg_irq_res ) { JPEG_PR_ERR ( "no<S2SV_blank>irq<S2SV_blank>resource?\\n" ) ; return - ENODEV ; } jpeg_irq = jpeg_irq_res -> start ; JPEG_DBG ( "%s<S2SV_blank>base<S2SV_blank>address:<S2SV_blank>0x%x,<S2SV_blank>jpeg<S2SV_blank>irq<S2SV_blank>number:<S2SV_blank>%d\\n" , __func__ , jpeg_mem -> start , jpeg_irq ) ; pgmn_dev -> jpeg_bus_client = msm_bus_scale_register_client ( & msm_jpeg_bus_client_pdata ) ; if ( ! pgmn_dev -> jpeg_bus_client ) { JPEG_PR_ERR ( "%s:<S2SV_blank>Registration<S2SV_blank>Failed!\\n" , __func__ ) ; pgmn_dev -> jpeg_bus_client = 0 ; return - EINVAL ; } msm_bus_scale_client_update_request ( pgmn_dev -> jpeg_bus_client , 1 ) ; jpeg_io = request_mem_region ( jpeg_mem -> start , resource_size ( jpeg_mem ) , pdev -> name ) ; if ( ! jpeg_io ) { JPEG_PR_ERR ( "%s:<S2SV_blank>region<S2SV_blank>already<S2SV_blank>claimed\\n" , __func__ ) ; return - EBUSY ; } jpeg_base = ioremap ( jpeg_mem -> start , resource_size ( jpeg_mem ) ) ; if ( ! jpeg_base ) { rc = - ENOMEM ; JPEG_PR_ERR ( "%s:<S2SV_blank>ioremap<S2SV_blank>failed\\n" , __func__ ) ; goto fail_remap ; } pgmn_dev -> jpeg_fs = regulator_get ( & pgmn_dev -> pdev -> dev , "vdd" ) ; rc = regulator_enable ( pgmn_dev -> jpeg_fs ) ; if ( rc ) { JPEG_PR_ERR ( "%s:%d]jpeg<S2SV_blank>regulator<S2SV_blank>get<S2SV_blank>failed\\n" , __func__ , __LINE__ ) ; goto fail_fs ; } rc = msm_cam_clk_enable ( & pgmn_dev -> pdev -> dev , jpeg_8x_clk_info , pgmn_dev -> jpeg_clk , ARRAY_SIZE ( jpeg_8x_clk_info ) , 1 ) ; if ( rc < 0 ) { JPEG_PR_ERR ( "%s:<S2SV_blank>clk<S2SV_blank>failed<S2SV_blank>rc<S2SV_blank>=<S2SV_blank>%d\\n" , __func__ , rc ) ; goto fail_clk ; } pgmn_dev -> hw_version = readl_relaxed ( jpeg_base + JPEG_HW_VERSION ) ; JPEG_DBG_HIGH ( "%s:%d]<S2SV_blank>jpeg<S2SV_blank>HW<S2SV_blank>version<S2SV_blank>0x%x" , __func__ , __LINE__ , pgmn_dev -> hw_version ) ; pgmn_dev -> jpeg_vbif = ioremap ( VBIF_BASE_ADDRESS , VBIF_REGION_SIZE ) ; if ( ! pgmn_dev -> jpeg_vbif ) { rc = - ENOMEM ; JPEG_PR_ERR ( "%s:%d]<S2SV_blank>ioremap<S2SV_blank>failed\\n" , __func__ , __LINE__ ) ; goto fail_vbif ; } JPEG_DBG ( "%s:%d]<S2SV_blank>jpeg_vbif<S2SV_blank>0x%x" , __func__ , __LINE__ , ( uint32_t ) pgmn_dev -> jpeg_vbif ) ; rc = msm_jpeg_attach_iommu ( pgmn_dev ) ; if ( rc < 0 ) goto fail_iommu ; set_vbif_params ( pgmn_dev , pgmn_dev -> jpeg_vbif ) ; rc = request_irq ( jpeg_irq , handler , IRQF_TRIGGER_RISING , "jpeg" , context ) ; if ( rc ) { JPEG_PR_ERR ( "%s:<S2SV_blank>request_irq<S2SV_blank>failed,<S2SV_blank>%d\\n" , __func__ , jpeg_irq ) ; goto fail_request_irq ; } * mem = jpeg_mem ; * base = jpeg_base ; * irq = jpeg_irq ; <S2SV_StartBug> pgmn_dev -> jpeg_client = msm_ion_client_create ( - 1 , "camera/jpeg" ) ; <S2SV_EndBug> JPEG_DBG ( "%s:%d]<S2SV_blank>success\\n" , __func__ , __LINE__ ) ; pgmn_dev -> state = MSM_JPEG_INIT ; return rc ; fail_request_irq : msm_jpeg_detach_iommu ( pgmn_dev ) ; fail_iommu : iounmap ( pgmn_dev -> jpeg_vbif ) ; fail_vbif : msm_cam_clk_enable ( & pgmn_dev -> pdev -> dev , jpeg_8x_clk_info , pgmn_dev -> jpeg_clk , ARRAY_SIZE ( jpeg_8x_clk_info ) , 0 ) ; fail_clk : regulator_disable ( pgmn_dev -> jpeg_fs ) ; regulator_put ( pgmn_dev -> jpeg_fs ) ; fail_fs : iounmap ( jpeg_base ) ; fail_remap : release_mem_region ( jpeg_mem -> start , resource_size ( jpeg_mem ) ) ; JPEG_DBG ( "%s:%d]<S2SV_blank>fail\\n" , __func__ , __LINE__ ) ; return rc ; } | <S2SV_ModStart> - 1 , "camera-jpeg" <S2SV_ModEnd> ) ; JPEG_DBG |
6,507 | CWE-000 void gen_is_tuple_fun ( compile_t * c , reach_type_t * t ) { pony_assert ( t -> underlying == TK_TUPLETYPE ) ; reach_method_t * m = reach_method ( t , TK_BOX , stringtab ( "__is" ) , NULL ) ; if ( m == NULL ) return ; compile_method_t * c_m = ( compile_method_t * ) m -> c_method ; LLVMTypeRef params [ 3 ] ; params [ 0 ] = c -> object_ptr ; params [ 1 ] = c -> object_ptr ; params [ 2 ] = c -> i32 ; c_m -> func_type = LLVMFunctionType ( c -> i1 , params , 3 , false ) ; <S2SV_StartBug> c_m -> func = codegen_addfun ( c , m -> full_name , c_m -> func_type ) ; <S2SV_EndBug> codegen_startfun ( c , c_m -> func , NULL , NULL , false ) ; LLVMValueRef l_value = LLVMGetParam ( codegen_fun ( c ) , 0 ) ; LLVMValueRef r_value = LLVMGetParam ( codegen_fun ( c ) , 1 ) ; LLVMValueRef r_id = LLVMGetParam ( codegen_fun ( c ) , 2 ) ; l_value = gen_unbox ( c , t -> ast_cap , l_value ) ; LLVMBasicBlockRef notreltype_block = codegen_block ( c , "not_reltype" ) ; LLVMValueRef type_switch = LLVMBuildSwitch ( c -> builder , r_id , notreltype_block , 0 ) ; pony_assert ( m -> tuple_is_types != NULL ) ; reach_type_t * right ; size_t i = HASHMAP_BEGIN ; while ( ( right = reach_type_cache_next ( m -> tuple_is_types , & i ) ) != NULL ) { LLVMBasicBlockRef reltype_block = codegen_block ( c , "reltype" ) ; LLVMAddCase ( type_switch , LLVMConstInt ( c -> i32 , right -> type_id , false ) , reltype_block ) ; LLVMPositionBuilderAtEnd ( c -> builder , reltype_block ) ; LLVMValueRef r_unbox = gen_unbox ( c , right -> ast_cap , r_value ) ; LLVMBuildRet ( c -> builder , tuple_is ( c , t -> ast_cap , right -> ast_cap , l_value , r_unbox ) ) ; } LLVMMoveBasicBlockAfter ( notreltype_block , LLVMGetInsertBlock ( c -> builder ) ) ; LLVMPositionBuilderAtEnd ( c -> builder , notreltype_block ) ; LLVMBuildRet ( c -> builder , LLVMConstInt ( c -> i1 , 0 , false ) ) ; codegen_finishfun ( c ) ; } | <S2SV_ModStart> c_m -> func_type , true |
6,508 | CWE-000 int cpuidle_idle_call ( void ) { struct cpuidle_device * dev = __this_cpu_read ( cpuidle_devices ) ; struct cpuidle_driver * drv ; int next_state , entered_state ; if ( off ) return - ENODEV ; if ( ! initialized ) return - ENODEV ; if ( ! dev || ! dev -> enabled ) return - EBUSY ; drv = cpuidle_get_cpu_driver ( dev ) ; next_state = cpuidle_curr_governor -> select ( drv , dev ) ; <S2SV_StartBug> if ( need_resched ( ) ) { <S2SV_EndBug> dev -> last_residency = 0 ; if ( cpuidle_curr_governor -> reflect ) cpuidle_curr_governor -> reflect ( dev , next_state ) ; local_irq_enable ( ) ; return 0 ; } trace_cpu_idle_rcuidle ( next_state , dev -> cpu ) ; if ( drv -> states [ next_state ] . flags & CPUIDLE_FLAG_TIMER_STOP ) clockevents_notify ( CLOCK_EVT_NOTIFY_BROADCAST_ENTER , & dev -> cpu ) ; if ( cpuidle_state_is_coupled ( dev , drv , next_state ) ) entered_state = cpuidle_enter_state_coupled ( dev , drv , next_state ) ; else entered_state = cpuidle_enter_state ( dev , drv , next_state ) ; if ( drv -> states [ next_state ] . flags & CPUIDLE_FLAG_TIMER_STOP ) clockevents_notify ( CLOCK_EVT_NOTIFY_BROADCAST_EXIT , & dev -> cpu ) ; trace_cpu_idle_rcuidle ( PWR_EVENT_EXIT , dev -> cpu ) ; if ( cpuidle_curr_governor -> reflect ) cpuidle_curr_governor -> reflect ( dev , entered_state ) ; return 0 ; } | <S2SV_ModStart> ; if ( next_state < 0 ) return - EBUSY ; if ( |
6,509 | CWE-000 int main ( int ac , char * * av ) { int bytes_read ; int is_separated = FALSE ; int i ; size_t buf_size = 1 ; char * buf = NULL ; char * buf_ptr ; char * buf_tmp ; char * * args = NULL ; ac = ac ; shell_name = _strdup ( * av ) ; environ = array_cpy ( environ , list_len ( environ , NULL ) ) ; buf = malloc ( 1 ) ; if ( buf == NULL ) exit ( EXIT_FAILURE ) ; while ( 1 ) { if ( is_separated == FALSE ) { if ( isatty ( STDIN_FILENO ) == 1 ) write ( STDOUT_FILENO , "my_shell$<S2SV_blank>" , 10 ) ; bytes_read = getline ( & buf , & buf_size , stdin ) ; if ( bytes_read == - 1 ) <S2SV_StartBug> exit ( EXIT_FAILURE ) ; <S2SV_EndBug> <S2SV_StartBug> buf = input_san ( buf , buf_size ) ; <S2SV_EndBug> <S2SV_StartBug> buf_ptr = buf ; <S2SV_EndBug> } else buf_ptr = buf_tmp ; buf_tmp = NULL ; args = make_array ( buf_ptr , '<S2SV_blank>' , & buf_tmp ) ; if ( buf_tmp != NULL ) is_separated = TRUE ; else is_separated = FALSE ; <S2SV_StartBug> i = command_manager ( args ) ; <S2SV_EndBug> if ( i == FALSE && is_separated == FALSE ) err_num ++ ; <S2SV_StartBug> free ( args ) ; <S2SV_EndBug> if ( i == EXIT_SHELL || i == EXIT_SHELL_CODE ) break ; } free ( buf ) ; alias_func ( NULL , TRUE ) ; free_array ( environ ) ; free ( shell_name ) ; <S2SV_StartBug> if ( i == EXIT_SHELL_CODE ) <S2SV_EndBug> <S2SV_StartBug> return ( status % 255 ) ; <S2SV_EndBug> return ( 0 ) ; } | <S2SV_ModStart> - 1 ) break ; buf [ bytes_read - 1 ] = '\\0' <S2SV_ModEnd> ; buf = <S2SV_ModStart> ( buf , & <S2SV_ModStart> buf_size ) ; if ( buf_size == 0 ) continue ; <S2SV_ModStart> i = command_manager ( args ) ; free <S2SV_ModStart> err_num ++ ; if ( i == EXIT_SHELL ) break ; } free ( buf ) ; alias_func ( NULL , TRUE ) ; free_array ( environ ) ; free ( <S2SV_ModEnd> shell_name ) ; <S2SV_ModStart> shell_name ) ; <S2SV_ModEnd> return ( status <S2SV_ModStart> ( status % 256 <S2SV_ModEnd> ) ; } |
6,510 | CWE-000 static int chv_gpio_probe ( struct chv_pinctrl * pctrl , int irq ) { const struct chv_gpio_pinrange * range ; struct gpio_chip * chip = & pctrl -> chip ; int ret , i , offset ; * chip = chv_gpio_chip ; chip -> ngpio = pctrl -> community -> ngpios ; chip -> label = dev_name ( pctrl -> dev ) ; chip -> dev = pctrl -> dev ; chip -> base = - 1 ; ret = gpiochip_add ( chip ) ; if ( ret ) { dev_err ( pctrl -> dev , "Failed<S2SV_blank>to<S2SV_blank>register<S2SV_blank>gpiochip\\n" ) ; return ret ; } for ( i = 0 , offset = 0 ; i < pctrl -> community -> ngpio_ranges ; i ++ ) { range = & pctrl -> community -> gpio_ranges [ i ] ; ret = gpiochip_add_pin_range ( chip , dev_name ( pctrl -> dev ) , offset , range -> base , range -> npins ) ; if ( ret ) { dev_err ( pctrl -> dev , "failed<S2SV_blank>to<S2SV_blank>add<S2SV_blank>GPIO<S2SV_blank>pin<S2SV_blank>range\\n" ) ; goto fail ; } offset += range -> npins ; } <S2SV_StartBug> chv_writel ( 0 , pctrl -> regs + CHV_INTMASK ) ; <S2SV_EndBug> chv_writel ( 0xffff , pctrl -> regs + CHV_INTSTAT ) ; ret = gpiochip_irqchip_add ( chip , & chv_gpio_irqchip , 0 , <S2SV_StartBug> handle_simple_irq , IRQ_TYPE_NONE ) ; <S2SV_EndBug> if ( ret ) { dev_err ( pctrl -> dev , "failed<S2SV_blank>to<S2SV_blank>add<S2SV_blank>IRQ<S2SV_blank>chip\\n" ) ; goto fail ; } gpiochip_set_chained_irqchip ( chip , & chv_gpio_irqchip , irq , chv_gpio_irq_handler ) ; return 0 ; fail : gpiochip_remove ( chip ) ; return ret ; } | <S2SV_ModStart> } chv_writel ( <S2SV_ModEnd> 0xffff , pctrl <S2SV_ModStart> , 0 , handle_bad_irq <S2SV_ModEnd> , IRQ_TYPE_NONE ) |
6,511 | CWE-000 void bbztable_add_data ( uint16_t strid , bbzheap_idx_t data ) { <S2SV_StartBug> bbzheap_idx_t t = bbzvm_stack_at ( 0 ) ; <S2SV_EndBug> bbzvm_pushs ( strid ) ; bbzvm_push ( data ) ; bbzvm_tput ( ) ; <S2SV_StartBug> bbzvm_push ( t ) ; <S2SV_EndBug> } | <S2SV_ModStart> data ) { bbzvm_dup ( <S2SV_ModEnd> ) ; bbzvm_pushs <S2SV_ModStart> ( ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
6,512 | CWE-000 int main ( int argc , char * argv [ ] ) { <S2SV_StartBug> const char * program_name = argv [ 0 ] ; <S2SV_EndBug> const char space [ ] = "<S2SV_blank>\\n\\0" ; const int port_number = 12345 ; int socket_fd , rc ; struct sockaddr_in serv_addr ; struct hostent * server ; char buffer [ MAX_SIZE ] ; handle_options ( argc , argv , program_name ) ; if ( argc < 2 ) { fprintf ( stderr , "Incorrect<S2SV_blank>arguments<S2SV_blank>input\\n" ) ; exit ( 0 ) ; } server = gethostbyname ( argv [ 1 ] ) ; socket_fd = socket ( AF_INET , SOCK_STREAM , 0 ) ; if ( socket_fd < 0 ) { perror ( "Error<S2SV_blank>opening<S2SV_blank>socket\\n" ) ; exit ( 1 ) ; } bzero ( ( char * ) & serv_addr , sizeof ( serv_addr ) ) ; serv_addr . sin_family = AF_INET ; serv_addr . sin_port = htons ( port_number ) ; bcopy ( ( char * ) server -> h_addr , ( char * ) & serv_addr . sin_addr . s_addr , sizeof ( server -> h_length ) ) ; if ( connect ( socket_fd , ( struct sockaddr * ) & serv_addr , sizeof ( serv_addr ) ) < 0 ) { perror ( "Error<S2SV_blank>connecting\\n" ) ; exit ( 1 ) ; } enum { INIT_STATE , READY_STATE } serv_state = INIT_STATE ; # define check_serv_state ( str , st ) ( strncmp ( str , # st , sizeof ( # st ) - 1 ) == 0 ) for ( ; ; ) { memset ( buffer , 0 , sizeof ( buffer ) ) ; rc = recv ( socket_fd , buffer , sizeof ( buffer ) , 0 ) ; if ( rc < 0 ) { perror ( "Error<S2SV_blank>reading<S2SV_blank>back<S2SV_blank>from<S2SV_blank>server.\\n" ) ; exit ( 1 ) ; } else if ( rc == 0 ) { printf ( "The<S2SV_blank>server<S2SV_blank>has<S2SV_blank>been<S2SV_blank>disconnected.<S2SV_blank>Quitting.\\n" ) ; exit ( 0 ) ; } if ( serv_state == INIT_STATE ) { char * msg = strtok ( buffer , "\\n" ) ; do { if ( check_serv_state ( msg , READY ) ) { printf ( "Server<S2SV_blank>is<S2SV_blank>ready\\n" ) ; serv_state = READY_STATE ; } else printf ( "Server:<S2SV_blank>[[[%s]]]\\n" , msg ) ; } while ( ( msg = strtok ( NULL , "\\n" ) ) ) ; if ( serv_state != READY_STATE ) continue ; } else printf ( "#server:<S2SV_blank>%s" , buffer ) ; memset ( buffer , 0 , sizeof ( buffer ) ) ; printf ( "\\n#client:<S2SV_blank>" ) ; fgets ( buffer , sizeof ( buffer ) / sizeof ( buffer [ 0 ] ) - 1 , stdin ) ; <S2SV_StartBug> char * temp = ( char * ) malloc ( strlen ( buffer ) + 1 ) ; <S2SV_EndBug> <S2SV_StartBug> strcpy ( temp , buffer ) ; <S2SV_EndBug> char * fix = strtok ( temp , space ) ; char * part1 ; char * part2 ; char * part3 ; char * part4 ; int flag = 0 ; while ( fix != NULL ) { if ( flag == 0 ) { part1 = fix ; fix = strtok ( NULL , space ) ; } if ( flag == 1 ) { part2 = fix ; fix = strtok ( NULL , space ) ; } if ( flag == 2 ) { part3 = fix ; fix = strtok ( NULL , space ) ; } if ( flag == 3 ) { part4 = fix ; fix = strtok ( NULL , space ) ; } flag ++ ; } flag = 0 ; <S2SV_StartBug> if ( strcmp ( part1 , "scp" ) == 0 ) { <S2SV_EndBug> FILE * fp ; size_t nbytes ; char file_buf [ MAX_SIZE ] ; char scp_buffer [ MAX_SIZE ] ; <S2SV_StartBug> fp = fopen ( part2 , "r" ) ; <S2SV_EndBug> if ( fp != NULL ) { nbytes = fread ( file_buf , 1 , MAX_SIZE , fp ) ; } else perror ( "Error<S2SV_blank>reading<S2SV_blank>file" ) ; if ( nbytes > 0 ) { <S2SV_StartBug> strcpy ( scp_buffer , part1 ) ; <S2SV_EndBug> strcat ( scp_buffer , "<S2SV_blank>" ) ; <S2SV_StartBug> strcat ( scp_buffer , part3 ) ; <S2SV_EndBug> strcat ( scp_buffer , "<S2SV_blank>" ) ; strcat ( scp_buffer , file_buf ) ; send_message ( socket_fd , scp_buffer ) ; } fclose ( fp ) ; } <S2SV_StartBug> else if ( strcmp ( part1 , "wget" ) == 0 ) { <S2SV_EndBug> send_message ( socket_fd , buffer ) ; <S2SV_StartBug> FILE * fd = fopen ( part3 , "w" ) ; <S2SV_EndBug> memset ( buffer , 0 , sizeof ( buffer ) ) ; rc = recv ( socket_fd , buffer , sizeof ( buffer ) , 0 ) ; if ( rc < 0 ) { perror ( "Error<S2SV_blank>reading<S2SV_blank>back<S2SV_blank>from<S2SV_blank>server" ) ; exit ( 1 ) ; } else if ( rc == 0 ) { printf ( "The<S2SV_blank>server<S2SV_blank>has<S2SV_blank>been<S2SV_blank>disconnected.<S2SV_blank>Quitting.\\n" ) ; exit ( 0 ) ; } fwrite ( buffer , sizeof ( char ) , strlen ( buffer ) , fd ) ; fclose ( fd ) ; printf ( "Done<S2SV_blank>downloading\\n" ) ; } else { int len = strlen ( buffer ) ; if ( buffer [ len - 1 ] == '\\n' ) { buffer [ len - 1 ] = '\\0' ; } send_message ( socket_fd , buffer ) ; } } close ( socket_fd ) ; return 0 ; } | <S2SV_ModStart> [ 0 ] <S2SV_ModEnd> ; const int <S2SV_ModStart> ; char * message <S2SV_ModEnd> = ( char <S2SV_ModStart> ; strcpy ( message , buffer ) ; MsgParts userCommand ; prepare_tokens ( message , userCommand ) ; free ( message ) <S2SV_ModEnd> ; if ( <S2SV_ModStart> ( strcmp ( userCommand . <S2SV_ModStart> = fopen ( userCommand . <S2SV_ModStart> ( scp_buffer , userCommand . <S2SV_ModStart> ( scp_buffer , userCommand . <S2SV_ModStart> ( strcmp ( userCommand . <S2SV_ModStart> = fopen ( userCommand . |
6,513 | CWE-000 static void updateMissionStatus ( void ) { Tuple * t ; for ( t = game . missionStatusHead . next ; t != NULL ; t = t -> next ) { if ( strcmp ( t -> key , world . id ) == 0 ) { <S2SV_StartBug> t -> value . i = status = getMissionStatus ( ) ; <S2SV_EndBug> return ; } } t = malloc ( sizeof ( Tuple ) ) ; memset ( t , 0 , sizeof ( Tuple ) ) ; game . missionStatusTail -> next = t ; game . missionStatusTail = t ; STRNCPY ( t -> key , world . id , MAX_NAME_LENGTH ) ; <S2SV_StartBug> t -> value . i = status = getMissionStatus ( ) ; <S2SV_EndBug> } | <S2SV_ModStart> = status = getPostMissionStatus <S2SV_ModEnd> ( ) ; <S2SV_ModStart> = status = getPostMissionStatus <S2SV_ModEnd> ( ) ; |
6,514 | CWE-000 static int f2fs_move_rehashed_dirents ( struct inode * dir , struct page * ipage , void * inline_dentry ) { void * backup_dentry ; int err ; backup_dentry = f2fs_kmalloc ( F2FS_I_SB ( dir ) , MAX_INLINE_DATA ( dir ) , GFP_F2FS_ZERO ) ; if ( ! backup_dentry ) { f2fs_put_page ( ipage , 1 ) ; return - ENOMEM ; } memcpy ( backup_dentry , inline_dentry , MAX_INLINE_DATA ( dir ) ) ; truncate_inline_inode ( dir , ipage , 0 ) ; unlock_page ( ipage ) ; err = f2fs_add_inline_entries ( dir , backup_dentry ) ; if ( err ) goto recover ; lock_page ( ipage ) ; stat_dec_inline_dir ( dir ) ; clear_inode_flag ( dir , FI_INLINE_DENTRY ) ; kfree ( backup_dentry ) ; return 0 ; recover : lock_page ( ipage ) ; <S2SV_StartBug> memcpy ( inline_dentry , backup_dentry , MAX_INLINE_DATA ( dir ) ) ; <S2SV_EndBug> f2fs_i_depth_write ( dir , 0 ) ; f2fs_i_size_write ( dir , MAX_INLINE_DATA ( dir ) ) ; set_page_dirty ( ipage ) ; f2fs_put_page ( ipage , 1 ) ; kfree ( backup_dentry ) ; return err ; } | <S2SV_ModStart> ipage ) ; f2fs_wait_on_page_writeback ( ipage , NODE , true ) ; |
6,515 | CWE-000 static void __update_writeback_rate ( struct cached_dev * dc ) { int64_t target = __calc_target_rate ( dc ) ; int64_t dirty = bcache_dev_sectors_dirty ( & dc -> disk ) ; int64_t error = dirty - target ; int64_t proportional_scaled = div_s64 ( error , dc -> writeback_rate_p_term_inverse ) ; int64_t integral_scaled ; uint32_t new_rate ; if ( ( error < 0 && dc -> writeback_rate_integral > 0 ) || ( error > 0 && time_before64 ( local_clock ( ) , dc -> writeback_rate . next + NSEC_PER_MSEC ) ) ) { dc -> writeback_rate_integral += error * dc -> writeback_rate_update_seconds ; } integral_scaled = div_s64 ( dc -> writeback_rate_integral , dc -> writeback_rate_i_term_inverse ) ; new_rate = clamp_t ( int32_t , ( proportional_scaled + integral_scaled ) , dc -> writeback_rate_minimum , NSEC_PER_SEC ) ; dc -> writeback_rate_proportional = proportional_scaled ; dc -> writeback_rate_integral_scaled = integral_scaled ; <S2SV_StartBug> dc -> writeback_rate_change = new_rate - dc -> writeback_rate . rate ; <S2SV_EndBug> <S2SV_StartBug> dc -> writeback_rate . rate = new_rate ; <S2SV_EndBug> dc -> writeback_rate_target = target ; } | <S2SV_ModStart> = new_rate - atomic64_read ( & <S2SV_ModStart> writeback_rate . rate ) ; atomic64_set ( & <S2SV_ModEnd> dc -> writeback_rate <S2SV_ModStart> writeback_rate . rate , new_rate ) <S2SV_ModEnd> ; dc -> |
6,516 | CWE-000 <S2SV_StartBug> void kick_clients ( uint8_t bssid [ ] ) { <S2SV_EndBug> int i ; for ( i = 0 ; i <= client_entry_last ; i ++ ) { if ( mac_is_equal ( client_array [ i ] . bssid_addr , bssid ) ) { break ; } } int j ; for ( j = i ; j <= client_entry_last ; j ++ ) { if ( ! mac_is_equal ( client_array [ j ] . bssid_addr , bssid ) ) { break ; } if ( kick_client ( client_array [ j ] ) ) { printf ( "KICKING<S2SV_blank>CLIENT!!!!!!!!!!!!!\\n" ) ; del_client ( client_array [ j ] . client_addr , 5 , 1 , 60000 ) ; } else { printf ( "STAAAY<S2SV_blank>CLIENT!!!!!!!!!!!!!\\n" ) ; } } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ] ) { pthread_mutex_lock ( & probe_array_mutex ) ; pthread_mutex_lock ( & client_array_mutex ) ; <S2SV_ModStart> ; } } pthread_mutex_unlock ( & probe_array_mutex ) ; pthread_mutex_unlock ( & client_array_mutex ) ; |
6,517 | CWE-000 int already_there ( char * interfacename ) { for ( int i = 0 ; i < 5 ; i ++ ) { if ( interfaces [ i ] . interface_name == NULL ) { return 0 ; } else if ( strcmp ( interfaces [ i ] . interface_name , interfacename ) == 0 ) { return 1 ; } } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ; } } return 0 ; |
6,518 | CWE-000 void app_main ( void ) { <S2SV_StartBug> if ( hf_cpuid ( ) == 2 ) { <S2SV_EndBug> <S2SV_StartBug> hf_spawn ( sender , 0 , 0 , 0 , "sender" , 4096 ) ; <S2SV_EndBug> } else { <S2SV_StartBug> hf_spawn ( receiver , 0 , 0 , 0 , "receiver" , 4096 ) ; <S2SV_EndBug> } } | <S2SV_ModStart> ( ) == 0 <S2SV_ModEnd> ) { hf_spawn <S2SV_ModStart> , 0 , "xsender" <S2SV_ModEnd> , 4096 ) <S2SV_ModStart> , 0 , "xreceiver" <S2SV_ModEnd> , 4096 ) |
6,519 | CWE-000 int udiv32 ( uint32_t dividend , uint32_t divisor , struct udiv_result * res ) { res -> q . dwords . low = 0U ; res -> r . dwords . low = 0U ; if ( divisor == 0U ) { res -> q . dwords . low = 0xffffffffU ; <S2SV_StartBug> return ! 0 ; <S2SV_EndBug> } if ( divisor == dividend ) { <S2SV_StartBug> res -> q . dwords . low = 1 ; <S2SV_EndBug> return 0 ; } if ( divisor > dividend ) { res -> r . dwords . low = dividend ; return 0 ; } return do_udiv32 ( dividend , divisor , res ) ; } | <S2SV_ModStart> 0xffffffffU ; return 1 <S2SV_ModEnd> ; } if <S2SV_ModStart> . low = 1U <S2SV_ModEnd> ; return 0 |
6,520 | CWE-000 static void mpssas_action_resetdev ( struct mpssas_softc * sassc , union ccb * ccb ) { MPI2_SCSI_TASK_MANAGE_REQUEST * req ; struct mps_softc * sc ; struct mps_command * tm ; struct mpssas_target * targ ; MPS_FUNCTRACE ( sassc -> sc ) ; mtx_assert ( & sassc -> sc -> mps_mtx , MA_OWNED ) ; KASSERT ( ccb -> ccb_h . target_id < sassc -> maxtargets , ( "Target<S2SV_blank>%d<S2SV_blank>out<S2SV_blank>of<S2SV_blank>bounds<S2SV_blank>in<S2SV_blank>XPT_RESET_DEV\\n" , ccb -> ccb_h . target_id ) ) ; sc = sassc -> sc ; tm = mps_alloc_command ( sc ) ; if ( tm == NULL ) { mps_dprint ( sc , MPS_ERROR , "command<S2SV_blank>alloc<S2SV_blank>failure<S2SV_blank>in<S2SV_blank>mpssas_action_resetdev\\n" ) ; mpssas_set_ccbstatus ( ccb , CAM_RESRC_UNAVAIL ) ; xpt_done ( ccb ) ; return ; } targ = & sassc -> targets [ ccb -> ccb_h . target_id ] ; req = ( MPI2_SCSI_TASK_MANAGE_REQUEST * ) tm -> cm_req ; req -> DevHandle = htole16 ( targ -> handle ) ; req -> Function = MPI2_FUNCTION_SCSI_TASK_MGMT ; req -> TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET ; req -> MsgFlags = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET ; tm -> cm_data = NULL ; <S2SV_StartBug> tm -> cm_desc . HighPriority . RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY ; <S2SV_EndBug> tm -> cm_complete = mpssas_resetdev_complete ; tm -> cm_complete_data = ccb ; tm -> cm_targ = targ ; targ -> flags |= MPSSAS_TARGET_INRESET ; mps_map_command ( sc , tm ) ; } | <S2SV_ModStart> ; tm -> <S2SV_ModEnd> cm_complete = mpssas_resetdev_complete |
6,521 | CWE-000 Error_Code ext2_inode_read_data ( Ext2_Filesystem * ext2fs , Ext2_Inode * inode , uint64_t offset , uint64_t size , uint8_t * buffer ) { uint32_t start_block_number = offset / ext2fs -> block_size ; uint32_t blocks_to_read_count = size / ext2fs -> block_size ; if ( size % ext2fs -> block_size ) blocks_to_read_count ++ ; <S2SV_StartBug> if ( blocks_to_read_count == 0 ) return Error_Code_NONE ; <S2SV_EndBug> uint8_t temp_buffer [ 4096 ] ; uint32_t block_number_to_read = 0 ; uint32_t offset_into_start_block = offset % ext2fs -> block_size ; uint32_t start_block_data_size = ext2fs -> block_size - offset_into_start_block ; if ( ext2_inode_get_data_block_number ( ext2fs , inode , start_block_number , & block_number_to_read ) ) <S2SV_StartBug> return Error_Code_FAILED_READ ; <S2SV_EndBug> if ( ext2_block_read ( ext2fs , block_number_to_read , temp_buffer ) ) <S2SV_StartBug> return Error_Code_FAILED_READ ; <S2SV_EndBug> memory_copy ( buffer , temp_buffer + offset_into_start_block , start_block_data_size ) ; uint8_t * write_ptr = buffer + start_block_data_size ; for ( uint64_t i = 1 ; i < blocks_to_read_count - 1 ; i ++ ) { if ( ext2_inode_get_data_block_number ( ext2fs , inode , start_block_number + i , & block_number_to_read ) ) return Error_Code_FAILED_READ ; if ( ext2_block_read ( ext2fs , block_number_to_read , write_ptr ) ) return Error_Code_FAILED_READ ; write_ptr += ext2fs -> block_size ; } if ( blocks_to_read_count > 1 ) { if ( ext2_inode_get_data_block_number ( ext2fs , inode , start_block_number + ( blocks_to_read_count - 1 ) , & block_number_to_read ) ) return Error_Code_FAILED_READ ; if ( ext2_block_read ( ext2fs , block_number_to_read , temp_buffer ) ) return Error_Code_FAILED_READ ; uint32_t size_of_last_block = ( offset + size ) % ext2fs -> block_size ; memory_copy ( write_ptr , temp_buffer , size_of_last_block ) ; } return Error_Code_NONE ; } | <S2SV_ModStart> == 0 ) { <S2SV_ModStart> return Error_Code_NONE ; } <S2SV_ModStart> block_number_to_read ) ) { log_error ( VFS , "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>data<S2SV_blank>block<S2SV_blank>number<S2SV_blank>at<S2SV_blank>index<S2SV_blank>%u" , start_block_number ) ; return Error_Code_FAILED_READ ; } <S2SV_ModEnd> if ( ext2_block_read <S2SV_ModStart> temp_buffer ) ) { log_error ( VFS , "Failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>block<S2SV_blank>%u" , block_number_to_read ) ; return Error_Code_FAILED_READ ; } <S2SV_ModEnd> memory_copy ( buffer |
6,522 | CWE-000 int acqiris_dma_read ( struct acqiris_device * aq_dev , u32 local_addr , void __user * dest , size_t size ) { long retval = 0 ; char buffer [ 20 ] ; long timeToExpire ; <S2SV_StartBug> DECLARE_WAITQUEUE ( wait , get_current ( ) ) ; <S2SV_EndBug> dma_addr_t desc_addr = virt_to_phys ( aq_dev -> dma_desc ) ; u32 desc_addr_lo = desc_addr ; u32 desc_addr_hi = desc_addr >> 16 >> 16 ; ulong value ; int nbr_pages ; int nbr_pages_needed ; nbr_pages_needed = ( ( ( unsigned long ) dest + size - 1 ) / PAGE_SIZE ) - ( ( unsigned long ) dest / PAGE_SIZE ) + 1 ; down_read ( & current -> mm -> mmap_sem ) ; # if LINUX_VERSION_CODE >= KERNEL_VERSION ( 4 , 9 , 0 ) nbr_pages = get_user_pages ( ( unsigned long ) dest , nbr_pages_needed , 0 , aq_dev -> pages , NULL ) ; # elif LINUX_VERSION_CODE >= KERNEL_VERSION ( 4 , 6 , 0 ) nbr_pages = get_user_pages ( ( unsigned long ) dest , nbr_pages_needed , 1 , 0 , aq_dev -> pages , NULL ) ; # else nbr_pages = get_user_pages ( current , current -> mm , ( unsigned long ) dest , nbr_pages_needed , 1 , 0 , aq_dev -> pages , NULL ) ; # endif up_read ( & current -> mm -> mmap_sem ) ; if ( nbr_pages < 0 ) { printk ( ACQRS_ERR "get_user_pages<S2SV_blank>failed.<S2SV_blank>0x%x<S2SV_blank>\\n" , nbr_pages ) ; return - ENOMEM ; } else if ( nbr_pages < nbr_pages_needed ) { printk ( ACQRS_ERR "get_user_pages<S2SV_blank>failed.<S2SV_blank>Only<S2SV_blank>%d<S2SV_blank>pages<S2SV_blank>out<S2SV_blank>of<S2SV_blank>%d.\\n" , nbr_pages , nbr_pages_needed ) ; release_user_pages ( nbr_pages , aq_dev -> pages , 0 ) ; return - ENOMEM ; } if ( dbgl & DDMA ) printk ( ACQRS_INFO "DMA<S2SV_blank>Read<S2SV_blank>addr<S2SV_blank>%#06x<S2SV_blank>dest<S2SV_blank>%p<S2SV_blank>size<S2SV_blank>%#010zx<S2SV_blank>(desc<S2SV_blank>%08x:%08x)\\n" , local_addr , dest , size , desc_addr_hi , desc_addr_lo ) ; retval = make_dma_desc ( aq_dev , aq_dev -> dma_desc , local_addr , dest , size , aq_dev -> pages , nbr_pages ) ; if ( retval < 0 ) { release_user_pages ( nbr_pages , aq_dev -> pages , 0 ) ; return retval ; } WRITE_REG32 ( aq_dev -> res . controlBase , DMA0DESC_OFFSET , desc_addr_lo + 0x9 ) ; if ( aq_dev -> vendor_id == PCI_DEVICE_ID_ACQIRIS_2 ) WRITE_REG32 ( aq_dev -> res . controlBase , DMA0DESC_OFFSET + 4 , desc_addr_hi ) ; value = READ_REG32 ( aq_dev -> res . controlBase , DMA0MODE_OFFSET ) ; value |= DMA0MODE ; WRITE_REG32 ( aq_dev -> res . controlBase , DMA0MODE_OFFSET , value ) ; add_wait_queue ( & aq_dev -> wait_dma , & wait ) ; set_current_state ( TASK_INTERRUPTIBLE ) ; value = ( DMA0CSR_CLRINTRPT | DMA0CSR_ENABLE ) ; WRITE_REG32 ( aq_dev -> res . controlBase , DMA0CSR_OFFSET , value ) ; value = READ_REG32 ( aq_dev -> res . controlBase , INTSRC_OFFSET ) ; value |= INTSRC_DMA_INT_EN ; WRITE_REG32 ( aq_dev -> res . controlBase , INTSRC_OFFSET , value ) ; value = ( DMA0CSR_ENABLE | DMA0CSR_START ) ; WRITE_REG32 ( aq_dev -> res . controlBase , DMA0CSR_OFFSET , value ) ; value = ( 100 + ( size >> 22 ) ) * HZ / 100 ; timeToExpire = schedule_timeout ( value ) ; remove_wait_queue ( & aq_dev -> wait_dma , & wait ) ; if ( ! timeToExpire ) { u32 value0 = READ_REG32 ( aq_dev -> res . controlBase , DMA0CSR_OFFSET ) ; WRITE_REG32 ( aq_dev -> res . controlBase , DMA0CSR_OFFSET , 0 ) ; value0 = READ_REG32 ( aq_dev -> res . controlBase , DMA0CSR_OFFSET ) ; if ( ( value0 & DMA0CSR_CHAN_DONE ) == 0 ) { value = DMA0CSR_CLRINTRPT | DMA0CSR_ABORT ; WRITE_REG32 ( aq_dev -> res . controlBase , DMA0CSR_OFFSET , value ) ; } else { value = DMA0CSR_CLRINTRPT ; WRITE_REG32 ( aq_dev -> res . controlBase , DMA0CSR_OFFSET , value ) ; } printk ( ACQRS_WARNING "DMA<S2SV_blank>read<S2SV_blank>on<S2SV_blank>device(%s)<S2SV_blank>(%#010x):<S2SV_blank>Timeout<S2SV_blank>occurred.\\n" , format_dev_t ( buffer , aq_dev -> dev ) , value0 ) ; retval = - ETIME ; } free_dma_desc ( aq_dev , aq_dev -> dma_desc , nbr_pages ) ; release_user_pages ( nbr_pages , aq_dev -> pages , ( retval == 0 ) ) ; return retval ; } | <S2SV_ModStart> ( wait , current <S2SV_ModEnd> ) ; dma_addr_t |
6,523 | CWE-000 static inline void __free_one_page ( struct page * page , struct zone * zone , unsigned int order , int migratetype ) { unsigned long page_idx ; unsigned long combined_idx ; unsigned long uninitialized_var ( buddy_idx ) ; struct page * buddy = NULL ; <S2SV_StartBug> VM_BUG_ON ( ! zone_is_initialized ( zone ) ) ; <S2SV_EndBug> if ( unlikely ( PageCompound ( page ) ) ) if ( unlikely ( destroy_compound_page ( page , order ) ) ) return ; VM_BUG_ON ( migratetype == - 1 ) ; <S2SV_StartBug> if ( ! is_migrate_isolate ( migratetype ) ) <S2SV_EndBug> __mod_zone_freepage_state ( zone , 1 << order , migratetype ) ; <S2SV_StartBug> page_idx = page_to_pfn ( page ) & ( ( 1 << MAX_ORDER ) - 1 ) ; <S2SV_EndBug> VM_BUG_ON ( page_idx & ( ( 1 << order ) - 1 ) ) ; VM_BUG_ON ( bad_range ( zone , page ) ) ; <S2SV_StartBug> while ( order < MAX_ORDER - 1 ) { <S2SV_EndBug> buddy_idx = __find_buddy_index ( page_idx , order ) ; buddy = page + ( buddy_idx - page_idx ) ; if ( ! page_is_buddy ( page , buddy , order ) ) break ; if ( page_is_guard ( buddy ) ) { clear_page_guard_flag ( buddy ) ; set_page_private ( page , 0 ) ; __mod_zone_freepage_state ( zone , 1 << order , migratetype ) ; } else { list_del ( & buddy -> lru ) ; zone -> free_area [ order ] . nr_free -- ; rmv_page_order ( buddy ) ; } combined_idx = buddy_idx & page_idx ; page = page + ( combined_idx - page_idx ) ; page_idx = combined_idx ; order ++ ; } set_page_order ( page , order ) ; if ( ( order < MAX_ORDER - 2 ) && pfn_valid_within ( page_to_pfn ( buddy ) ) ) { struct page * higher_page , * higher_buddy ; combined_idx = buddy_idx & page_idx ; higher_page = page + ( combined_idx - page_idx ) ; buddy_idx = __find_buddy_index ( combined_idx , order + 1 ) ; higher_buddy = higher_page + ( buddy_idx - combined_idx ) ; if ( page_is_buddy ( higher_page , higher_buddy , order + 1 ) ) { list_add_tail ( & page -> lru , & zone -> free_area [ order ] . free_list [ migratetype ] ) ; goto out ; } } list_add ( & page -> lru , & zone -> free_area [ order ] . free_list [ migratetype ] ) ; out : zone -> free_area [ order ] . nr_free ++ ; } | <S2SV_ModStart> = NULL ; int max_order = MAX_ORDER ; <S2SV_ModStart> ; if ( <S2SV_ModEnd> is_migrate_isolate ( migratetype <S2SV_ModStart> migratetype ) ) { max_order = min ( MAX_ORDER , pageblock_order + 1 ) ; } else { <S2SV_ModStart> migratetype ) ; } <S2SV_ModStart> ( 1 << max_order <S2SV_ModEnd> ) - 1 <S2SV_ModStart> ( order < max_order <S2SV_ModEnd> - 1 ) |
6,524 | CWE-000 static Datum plcontainer_function_handler ( FunctionCallInfo fcinfo , plcProcInfo * proc ) { Datum datumreturn ; <S2SV_StartBug> plcProcResult * presult = NULL ; <S2SV_EndBug> <S2SV_StartBug> MemoryContext oldcontext = CurrentMemoryContext ; <S2SV_EndBug> FuncCallContext * volatile funcctx = NULL ; <S2SV_StartBug> bool bFirstTimeCall = false ; <S2SV_EndBug> PG_TRY ( ) ; { plc_elog ( DEBUG1 , "fcinfo->flinfo->fn_retset:<S2SV_blank>%d" , fcinfo -> flinfo -> fn_retset ) ; if ( fcinfo -> flinfo -> fn_retset ) { if ( SRF_IS_FIRSTCALL ( ) ) { funcctx = SRF_FIRSTCALL_INIT ( ) ; bFirstTimeCall = true ; plc_elog ( DEBUG1 , "The<S2SV_blank>funcctx<S2SV_blank>pointer<S2SV_blank>returned<S2SV_blank>by<S2SV_blank>SRF_FIRSTCALL_INIT()<S2SV_blank>is:<S2SV_blank>%p" , funcctx ) ; } funcctx = SRF_PERCALL_SETUP ( ) ; plc_elog ( DEBUG1 , "The<S2SV_blank>funcctx<S2SV_blank>pointer<S2SV_blank>returned<S2SV_blank>by<S2SV_blank>SRF_PERCALL_SETUP()<S2SV_blank>is:<S2SV_blank>%p" , funcctx ) ; Assert ( funcctx != NULL ) ; oldcontext = MemoryContextSwitchTo ( funcctx -> multi_call_memory_ctx ) ; } else { oldcontext = MemoryContextSwitchTo ( pl_container_caller_context ) ; } if ( ! fcinfo -> flinfo -> fn_retset || bFirstTimeCall ) { presult = plcontainer_get_result ( fcinfo , proc ) ; if ( ! fcinfo -> flinfo -> fn_retset ) { } } if ( fcinfo -> flinfo -> fn_retset ) { ReturnSetInfo * rsi = ( ReturnSetInfo * ) fcinfo -> resultinfo ; if ( funcctx -> user_fctx == NULL ) { plc_elog ( DEBUG1 , "first<S2SV_blank>time<S2SV_blank>call,<S2SV_blank>preparing<S2SV_blank>the<S2SV_blank>result<S2SV_blank>set..." ) ; if ( ! rsi || ! IsA ( rsi , ReturnSetInfo ) || ( rsi -> allowedModes & SFRM_ValuePerCall ) == 0 ) { ereport ( ERROR , ( errcode ( ERRCODE_FEATURE_NOT_SUPPORTED ) , errmsg ( "unsupported<S2SV_blank>set<S2SV_blank>function<S2SV_blank>return<S2SV_blank>mode" ) , errdetail ( "PL/Python<S2SV_blank>set-returning<S2SV_blank>functions<S2SV_blank>only<S2SV_blank>support<S2SV_blank>returning<S2SV_blank>only<S2SV_blank>value<S2SV_blank>per<S2SV_blank>call." ) ) ) ; } rsi -> returnMode = SFRM_ValuePerCall ; funcctx -> user_fctx = ( void * ) presult ; if ( funcctx -> user_fctx == NULL ) ereport ( ERROR , ( errcode ( ERRCODE_DATATYPE_MISMATCH ) , errmsg ( "returned<S2SV_blank>object<S2SV_blank>cannot<S2SV_blank>be<S2SV_blank>iterated" ) , errdetail ( "PL/Python<S2SV_blank>set-returning<S2SV_blank>functions<S2SV_blank>must<S2SV_blank>return<S2SV_blank>an<S2SV_blank>iterable<S2SV_blank>object." ) ) ) ; } presult = ( plcProcResult * ) funcctx -> user_fctx ; if ( presult -> resrow < presult -> resmsg -> rows ) rsi -> isDone = ExprMultipleResult ; else { rsi -> isDone = ExprEndResult ; } if ( rsi -> isDone == ExprEndResult ) { free_result ( presult -> resmsg , false ) ; pfree ( presult ) ; MemoryContextSwitchTo ( oldcontext ) ; funcctx -> user_fctx = NULL ; SRF_RETURN_DONE ( funcctx ) ; } } datumreturn = plcontainer_process_result ( fcinfo , proc , presult ) ; presult -> resrow += 1 ; MemoryContextSwitchTo ( oldcontext ) ; } PG_CATCH ( ) ; { if ( fcinfo -> flinfo -> fn_retset && funcctx -> user_fctx != NULL ) { funcctx -> user_fctx = NULL ; } if ( presult && presult -> resmsg ) { free_result ( presult -> resmsg , false ) ; pfree ( presult ) ; } MemoryContextSwitchTo ( oldcontext ) ; PG_RE_THROW ( ) ; } PG_END_TRY ( ) ; if ( fcinfo -> flinfo -> fn_retset ) { SRF_RETURN_NEXT ( funcctx , datumreturn ) ; } else { free_result ( presult -> resmsg , false ) ; pfree ( presult ) ; } # ifndef PLC_PG SIMPLE_FAULT_NAME_INJECTOR ( "plcontainer_before_udf_finish" ) ; # endif return datumreturn ; } | <S2SV_ModStart> ; plcProcResult * volatile <S2SV_ModStart> NULL ; MemoryContext volatile <S2SV_ModStart> NULL ; bool volatile |
6,525 | CWE-000 void printStats ( uint8_t time , char * text ) { g_point_t pt ; pt . x = TILE_X * GRID_X + HORI_PADDING ; pt . y = TILE_Y * ( MENU_HEIGHT * 4 ) + VERT_PADDING ; <S2SV_StartBug> Graphics_DrawText ( & gCntx , pt , "Time<S2SV_blank>Remaining:<S2SV_blank>%d" , time ) ; <S2SV_EndBug> } | <S2SV_ModStart> , pt , "Time<S2SV_blank>Remaining:<S2SV_blank>%d<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" <S2SV_ModEnd> , time ) |
6,526 | CWE-000 <S2SV_StartBug> VALUE shoes_native_menubar_make_block ( char * code ) { <S2SV_EndBug> int argc = 1 ; VALUE argv [ 2 ] ; argv [ 0 ] = rb_str_new2 ( code ) ; argv [ 1 ] = Qnil ; <S2SV_StartBug> VALUE block = Qnil ; <S2SV_EndBug> rb_scan_args ( argc , argv , "0&" , & block ) ; <S2SV_StartBug> return block ; <S2SV_EndBug> } | <S2SV_ModStart> code ) { VALUE block ; block = rb_eval_string ( code ) ; # if 0 <S2SV_ModStart> = Qnil ; <S2SV_ModEnd> rb_scan_args ( argc <S2SV_ModStart> block ) ; # endif |
6,527 | CWE-000 void relocate ( TCCState * s1 , ElfW_Rel * rel , int type , unsigned char * ptr , addr_t addr , addr_t val ) { int sym_index = ELFW ( R_SYM ) ( rel -> r_info ) ; # ifdef DEBUG_RELOC ElfW ( Sym ) * sym = & ( ( ElfW ( Sym ) * ) symtab_section -> data ) [ sym_index ] ; # endif switch ( type ) { case R_AARCH64_ABS64 : write64le ( ptr , val ) ; return ; case R_AARCH64_ABS32 : write32le ( ptr , val ) ; return ; case R_AARCH64_PREL32 : write32le ( ptr , val - addr ) ; return ; case R_AARCH64_MOVW_UABS_G0_NC : write32le ( ptr , ( ( read32le ( ptr ) & 0xffe0001f ) | ( val & 0xffff ) << 5 ) ) ; return ; case R_AARCH64_MOVW_UABS_G1_NC : write32le ( ptr , ( ( read32le ( ptr ) & 0xffe0001f ) | ( val >> 16 & 0xffff ) << 5 ) ) ; return ; case R_AARCH64_MOVW_UABS_G2_NC : write32le ( ptr , ( ( read32le ( ptr ) & 0xffe0001f ) | ( val >> 32 & 0xffff ) << 5 ) ) ; return ; case R_AARCH64_MOVW_UABS_G3 : write32le ( ptr , ( ( read32le ( ptr ) & 0xffe0001f ) | ( val >> 48 & 0xffff ) << 5 ) ) ; return ; case R_AARCH64_ADR_PREL_PG_HI21 : { uint64_t off = ( val >> 12 ) - ( addr >> 12 ) ; if ( ( off + ( ( uint64_t ) 1 << 20 ) ) >> 21 ) tcc_error ( "R_AARCH64_ADR_PREL_PG_HI21<S2SV_blank>relocation<S2SV_blank>failed" ) ; write32le ( ptr , ( ( read32le ( ptr ) & 0x9f00001f ) | ( off & 0x1ffffc ) << 3 | ( off & 3 ) << 29 ) ) ; return ; } case R_AARCH64_ADD_ABS_LO12_NC : write32le ( ptr , ( ( read32le ( ptr ) & 0xffc003ff ) | ( val & 0xfff ) << 10 ) ) ; return ; case R_AARCH64_JUMP26 : case R_AARCH64_CALL26 : # ifdef DEBUG_RELOC printf ( "reloc<S2SV_blank>%d<S2SV_blank>@<S2SV_blank>0x%lx:<S2SV_blank>val=0x%lx<S2SV_blank>name=%s\\n" , type , addr , val , ( char * ) symtab_section -> link -> data + sym -> st_name ) ; # endif if ( ( ( val - addr ) + ( ( uint64_t ) 1 << 27 ) ) & ~ ( uint64_t ) 0xffffffc ) tcc_error ( "R_AARCH64_(JUMP|CALL)26<S2SV_blank>relocation<S2SV_blank>failed" "<S2SV_blank>(val=%lx,<S2SV_blank>addr=%lx)" , val , addr ) ; write32le ( ptr , ( 0x14000000 | ( uint32_t ) ( type == R_AARCH64_CALL26 ) << 31 | ( ( val - addr ) >> 2 & 0x3ffffff ) ) ) ; return ; case R_AARCH64_ADR_GOT_PAGE : { uint64_t off = ( ( ( s1 -> got -> sh_addr + s1 -> sym_attrs [ sym_index ] . got_offset ) >> 12 ) - ( addr >> 12 ) ) ; if ( ( off + ( ( uint64_t ) 1 << 20 ) ) >> 21 ) tcc_error ( "R_AARCH64_ADR_GOT_PAGE<S2SV_blank>relocation<S2SV_blank>failed" ) ; write32le ( ptr , ( ( read32le ( ptr ) & 0x9f00001f ) | ( off & 0x1ffffc ) << 3 | ( off & 3 ) << 29 ) ) ; return ; } case R_AARCH64_LD64_GOT_LO12_NC : write32le ( ptr , ( ( read32le ( ptr ) & 0xfff803ff ) | ( ( s1 -> got -> sh_addr + s1 -> sym_attrs [ sym_index ] . got_offset ) & 0xff8 ) << 7 ) ) ; return ; case R_AARCH64_COPY : return ; case R_AARCH64_GLOB_DAT : case R_AARCH64_JUMP_SLOT : # ifdef DEBUG_RELOC printf ( "reloc<S2SV_blank>%d<S2SV_blank>@<S2SV_blank>0x%lx:<S2SV_blank>val=0x%lx<S2SV_blank>name=%s\\n" , type , addr , val - rel -> r_addend , ( char * ) symtab_section -> link -> data + sym -> st_name ) ; # endif write64le ( ptr , val - rel -> r_addend ) ; return ; <S2SV_StartBug> default : <S2SV_EndBug> fprintf ( stderr , "FIXME:<S2SV_blank>handle<S2SV_blank>reloc<S2SV_blank>type<S2SV_blank>%x<S2SV_blank>at<S2SV_blank>%x<S2SV_blank>[%p]<S2SV_blank>to<S2SV_blank>%x\\n" , type , ( unsigned ) addr , ptr , ( unsigned ) val ) ; return ; } } | <S2SV_ModStart> ; return ; case R_AARCH64_RELATIVE : # ifdef TCC_TARGET_PE add32le ( ptr , val - s1 -> pe_imagebase ) ; # endif return ; |
6,528 | CWE-000 static int app1_gll ( PyGllObject * self , PyObject * s ) { <S2SV_StartBug> Py_ssize_t n = PyList_GET_SIZE ( self ) ; <S2SV_EndBug> assert ( s != NULL ) ; if ( n == PY_SSIZE_T_MAX ) { PyErr_SetString ( PyExc_OverflowError , "cannot<S2SV_blank>add<S2SV_blank>more<S2SV_blank>objects<S2SV_blank>to<S2SV_blank>list" ) ; return - 1 ; } if ( list_resize ( self , n + 1 ) < 0 ) return - 1 ; Py_INCREF ( s ) ; <S2SV_StartBug> py_set_item ( self , s ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> Py_ssize_t n = PyGll_GET_SIZE <S2SV_ModEnd> ( self ) <S2SV_ModStart> s ) ; PyGll_SET_ITEM ( self , n <S2SV_ModEnd> , s ) |
6,529 | CWE-000 static bool handle_view_created ( wlc_handle handle ) { wlc_handle parent = wlc_view_get_parent ( handle ) ; swayc_t * focused = NULL ; swayc_t * newview = NULL ; swayc_t * current_ws = swayc_active_workspace ( ) ; bool return_to_workspace = false ; struct wl_client * client = wlc_view_get_wl_client ( handle ) ; pid_t pid ; struct panel_config * panel_config = NULL ; struct background_config * background_config = NULL ; panel_config = if_panel_find_config ( client ) ; if ( panel_config ) { panel_config -> handle = handle ; update_panel_geometry ( panel_config ) ; wlc_view_set_mask ( handle , VISIBLE ) ; wlc_view_set_output ( handle , panel_config -> output ) ; wlc_view_bring_to_front ( handle ) ; arrange_windows ( & root_container , - 1 , - 1 ) ; return true ; } background_config = if_background_find_config ( client ) ; if ( background_config ) { background_config -> handle = handle ; update_background_geometry ( background_config ) ; wlc_view_set_mask ( handle , VISIBLE ) ; wlc_view_set_output ( handle , background_config -> output ) ; wlc_view_send_to_back ( handle ) ; return true ; } if ( parent ) { focused = swayc_by_handle ( parent ) ; } if ( client ) { pid = wlc_view_get_pid ( handle ) ; if ( pid ) { newview = workspace_for_pid ( pid ) ; if ( newview ) { focused = get_focused_container ( newview ) ; return_to_workspace = true ; } newview = NULL ; } } if ( ! focused || focused -> type == C_OUTPUT ) { focused = get_focused_container ( & root_container ) ; if ( focused -> is_floating ) { if ( focused -> parent -> children -> length == 0 ) { focused = focused -> parent ; } else { focused = get_focused_container ( focused -> parent -> children -> items [ 0 ] ) ; } } } sway_log ( L_DEBUG , "handle:%" PRIuPTR "<S2SV_blank>type:%x<S2SV_blank>state:%x<S2SV_blank>parent:%" PRIuPTR "<S2SV_blank>" "mask:%d<S2SV_blank>(x:%d<S2SV_blank>y:%d<S2SV_blank>w:%d<S2SV_blank>h:%d)<S2SV_blank>title:%s<S2SV_blank>" "class:%s<S2SV_blank>appid:%s" , handle , wlc_view_get_type ( handle ) , wlc_view_get_state ( handle ) , parent , wlc_view_get_mask ( handle ) , wlc_view_get_geometry ( handle ) -> origin . x , wlc_view_get_geometry ( handle ) -> origin . y , wlc_view_get_geometry ( handle ) -> size . w , wlc_view_get_geometry ( handle ) -> size . h , wlc_view_get_title ( handle ) , wlc_view_get_class ( handle ) , wlc_view_get_app_id ( handle ) ) ; switch ( wlc_view_get_type ( handle ) ) { case 0 : if ( parent ) { newview = new_floating_view ( handle ) ; } else { newview = new_view ( focused , handle ) ; wlc_view_set_state ( handle , WLC_BIT_MAXIMIZED , true ) ; } break ; case WLC_BIT_OVERRIDE_REDIRECT : wlc_view_focus ( handle ) ; wlc_view_set_state ( handle , WLC_BIT_ACTIVATED , true ) ; wlc_view_bring_to_front ( handle ) ; break ; case WLC_BIT_OVERRIDE_REDIRECT | WLC_BIT_UNMANAGED : wlc_view_bring_to_front ( handle ) ; locked_container_focus = true ; break ; case WLC_BIT_MODAL : wlc_view_focus ( handle ) ; wlc_view_bring_to_front ( handle ) ; newview = new_floating_view ( handle ) ; case WLC_BIT_POPUP : wlc_view_bring_to_front ( handle ) ; break ; } suspend_workspace_cleanup = true ; if ( newview ) { ipc_event_window ( newview , "new" ) ; set_focused_container ( newview ) ; swayc_t * output = swayc_parent_by_type ( newview , C_OUTPUT ) ; arrange_windows ( output , - 1 , - 1 ) ; list_t * criteria = criteria_for ( newview ) ; for ( int i = 0 ; i < criteria -> length ; i ++ ) { struct criteria * crit = criteria -> items [ i ] ; sway_log ( L_DEBUG , "for_window<S2SV_blank>\'%s\'<S2SV_blank>matches<S2SV_blank>new<S2SV_blank>view<S2SV_blank>%p,<S2SV_blank>cmd:<S2SV_blank>\'%s\'" , crit -> crit_raw , newview , crit -> cmdlist ) ; struct cmd_results * res = handle_command ( crit -> cmdlist ) ; if ( res -> status != CMD_SUCCESS ) { sway_log ( L_ERROR , "Command<S2SV_blank>\'%s\'<S2SV_blank>failed:<S2SV_blank>%s" , res -> input , res -> error ) ; } free_cmd_results ( res ) ; set_focused_container ( newview ) ; } swayc_t * workspace = swayc_parent_by_type ( focused , C_WORKSPACE ) ; if ( workspace && workspace -> fullscreen ) { set_focused_container ( workspace -> fullscreen ) ; } swayc_t * parent_container = newview -> parent ; if ( parent_container -> type == C_WORKSPACE && parent_container -> children -> length == 1 && ( parent_container -> layout == L_TABBED || parent_container -> layout == L_STACKED ) ) { swayc_t * container = new_container ( newview , parent_container -> layout ) ; set_focused_container ( newview ) ; arrange_windows ( container , - 1 , - 1 ) ; } } else { swayc_t * output = swayc_parent_by_type ( focused , C_OUTPUT ) ; wlc_handle * h = malloc ( sizeof ( wlc_handle ) ) ; * h = handle ; sway_log ( L_DEBUG , "Adding<S2SV_blank>unmanaged<S2SV_blank>window<S2SV_blank>%p<S2SV_blank>to<S2SV_blank>%p" , h , output -> unmanaged ) ; list_add ( output -> unmanaged , h ) ; } wlc_view_set_mask ( handle , VISIBLE ) ; if ( return_to_workspace && current_ws ) { workspace_switch ( current_ws ) ; <S2SV_StartBug> set_focused_container ( current_ws -> focused ) ; <S2SV_EndBug> } suspend_workspace_cleanup = false ; ws_cleanup ( ) ; return true ; } | <S2SV_ModStart> ; set_focused_container ( get_focused_container ( current_ws ) <S2SV_ModEnd> ) ; } |
6,530 | CWE-000 static void bnxt_timer ( unsigned long data ) { struct bnxt * bp = ( struct bnxt * ) data ; struct net_device * dev = bp -> dev ; if ( ! netif_running ( dev ) ) return ; if ( atomic_read ( & bp -> intr_sem ) != 0 ) goto bnxt_restart_timer ; if ( bp -> link_info . link_up && ( bp -> flags & BNXT_FLAG_PORT_STATS ) && bp -> stats_coal_ticks ) { set_bit ( BNXT_PERIODIC_STATS_SP_EVENT , & bp -> sp_event ) ; <S2SV_StartBug> schedule_work ( & bp -> sp_task ) ; <S2SV_EndBug> } bnxt_restart_timer : mod_timer ( & bp -> timer , jiffies + bp -> current_interval ) ; } | <S2SV_ModStart> sp_event ) ; bnxt_queue_sp_work ( bp <S2SV_ModEnd> ) ; } |
6,531 | CWE-000 static int __rdtgroup_move_task ( struct task_struct * tsk , struct rdtgroup * rdtgrp ) { struct task_move_callback * callback ; int ret ; callback = kzalloc ( sizeof ( * callback ) , GFP_KERNEL ) ; if ( ! callback ) return - ENOMEM ; callback -> work . func = move_myself ; callback -> rdtgrp = rdtgrp ; atomic_inc ( & rdtgrp -> waitcount ) ; mutex_lock ( & rdtgrp -> lock ) ; ret = task_work_add ( tsk , & callback -> work , true ) ; if ( ret ) { atomic_dec ( & rdtgrp -> waitcount ) ; kfree ( callback ) ; rdt_last_cmd_puts ( "task<S2SV_blank>exited\\n" ) ; } else { if ( rdtgrp -> type == RDTCTRL_GROUP ) { tsk -> closid = rdtgrp -> closid ; tsk -> rmid = rdtgrp -> mon . rmid ; tsk -> grp = rdtgrp ; list_add_tail ( & tsk -> rdtgrp_list , & rdtgrp -> tasks_list ) ; } else if ( rdtgrp -> type == RDTMON_GROUP ) { if ( rdtgrp -> mon . parent -> closid == tsk -> closid ) { tsk -> rmid = rdtgrp -> mon . rmid ; } else { rdt_last_cmd_puts ( "Can\'t<S2SV_blank>move<S2SV_blank>task<S2SV_blank>to<S2SV_blank>different<S2SV_blank>control<S2SV_blank>group\\n" ) ; ret = - EINVAL ; } } } <S2SV_StartBug> mutex_lock ( & rdtgrp -> lock ) ; <S2SV_EndBug> return ret ; } | <S2SV_ModStart> } } } mutex_unlock <S2SV_ModEnd> ( & rdtgrp |
6,532 | CWE-000 void * ofi_ns_resolve_name ( struct util_ns * ns , const char * server_hostname , void * service ) { void * dest_addr = NULL , * io_buf ; size_t io_len = 0 ; SOCKET sockfd ; ssize_t ret = 0 ; struct util_ns_cmd cmd = { . op = OFI_UTIL_NS_QUERY , . status = 0 , } ; if ( ! ns -> is_initialized ) return NULL ; sockfd = util_ns_connect_server ( ns , server_hostname ) ; if ( sockfd == INVALID_SOCKET ) goto err1 ; io_buf = calloc ( cmd_len + ns -> service_len , 1 ) ; if ( ! io_buf ) goto err2 ; memcpy ( io_buf , & cmd , cmd_len ) ; io_len += cmd_len ; memcpy ( ( void * ) ( ( char * ) io_buf + io_len ) , service , ns -> service_len ) ; io_len += ns -> service_len ; ret = util_ns_write_socket_op ( sockfd , io_buf , io_len ) ; if ( ret < 0 ) goto err3 ; free ( io_buf ) ; io_len = ns -> service_len + ns -> name_len ; io_buf = calloc ( io_len , 1 ) ; if ( ! io_buf ) goto err2 ; ret = util_ns_read_socket_op ( sockfd , & cmd , cmd_len ) ; if ( ret < 0 || cmd . status ) goto err3 ; ret = util_ns_read_socket_op ( sockfd , io_buf , io_len ) ; <S2SV_StartBug> if ( ret == io_len ) { <S2SV_EndBug> dest_addr = calloc ( ns -> name_len , 1 ) ; if ( ! dest_addr ) goto err3 ; io_len = 0 ; memcpy ( service , ( void * ) ( ( char * ) io_buf + io_len ) , ns -> service_len ) ; io_len += ns -> service_len ; memcpy ( dest_addr , ( void * ) ( ( char * ) io_buf + io_len ) , ns -> name_len ) ; } err3 : free ( io_buf ) ; err2 : ofi_close_socket ( sockfd ) ; err1 : return dest_addr ; } | <S2SV_ModStart> ; if ( ! ret <S2SV_ModEnd> ) { dest_addr |
6,533 | CWE-000 static gint rotctld_socket_open ( const gchar * host , gint port ) { struct sockaddr_in ServAddr ; struct hostent * h ; gint sock ; gint status ; sock = socket ( PF_INET , SOCK_STREAM , IPPROTO_TCP ) ; if ( sock == - 1 ) { sat_log_log ( SAT_LOG_LEVEL_ERROR , _ ( "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>rotctl<S2SV_blank>socket:<S2SV_blank>%s" ) , strerror ( errno ) ) ; return - 1 ; } sat_log_log ( SAT_LOG_LEVEL_DEBUG , _ ( "%s:<S2SV_blank>Network<S2SV_blank>socket<S2SV_blank>created<S2SV_blank>successfully" ) , __func__ ) ; memset ( & ServAddr , 0 , sizeof ( ServAddr ) ) ; ServAddr . sin_family = AF_INET ; <S2SV_StartBug> h = gethostbyname ( host ) ; <S2SV_EndBug> memcpy ( ( char * ) & ServAddr . sin_addr . s_addr , h -> h_addr_list [ 0 ] , h -> h_length ) ; ServAddr . sin_port = htons ( port ) ; status = connect ( sock , ( struct sockaddr * ) & ServAddr , sizeof ( ServAddr ) ) ; if ( status == - 1 ) { sat_log_log ( SAT_LOG_LEVEL_ERROR , _ ( "Connection<S2SV_blank>to<S2SV_blank>rotctld<S2SV_blank>server<S2SV_blank>at<S2SV_blank>%s:%d<S2SV_blank>failed:<S2SV_blank>%s" ) , host , port ) ; return - 1 ; } sat_log_log ( SAT_LOG_LEVEL_DEBUG , _ ( "%s:<S2SV_blank>Connection<S2SV_blank>opened<S2SV_blank>to<S2SV_blank>%s:%d" ) , __func__ , host , port ) ; return sock ; } | <S2SV_ModStart> host ) ; if ( h == NULL ) { sat_log_log ( SAT_LOG_LEVEL_ERROR , _ ( "Name<S2SV_blank>resolution<S2SV_blank>of<S2SV_blank>rotctld<S2SV_blank>server<S2SV_blank>%s<S2SV_blank>failed." ) , host ) ; return - 1 ; } |
6,534 | CWE-000 int pop_node ( stack_t * * head , size_t line_number ) { <S2SV_StartBug> int n ; <S2SV_EndBug> stack_t * temp ; if ( head == NULL || * head == NULL ) { <S2SV_StartBug> printf ( "L%d:<S2SV_blank>can\'t<S2SV_blank>pop<S2SV_blank>an<S2SV_blank>empty<S2SV_blank>stack\\n" , line_number ) ; <S2SV_EndBug> return ( - 1 ) ; } temp = * head ; * head = temp -> next ; free ( temp ) ; return ( 0 ) ; } | <S2SV_ModStart> line_number ) { <S2SV_ModEnd> stack_t * temp <S2SV_ModStart> { printf ( "L%lu:<S2SV_blank>can\'t<S2SV_blank>pop<S2SV_blank>an<S2SV_blank>empty<S2SV_blank>stack\\n" <S2SV_ModEnd> , line_number ) |
6,535 | CWE-000 static void dump_imp_open_cb ( void * cb_arg , struct spdk_blob * blob , int bserrno ) { struct cli_context_t * cli_context = cb_arg ; if ( bserrno ) { unload_bs ( cli_context , "Error<S2SV_blank>in<S2SV_blank>blob<S2SV_blank>open<S2SV_blank>callback" , bserrno ) ; return ; } cli_context -> blob = blob ; cli_context -> buff = spdk_dma_malloc ( cli_context -> page_size , ALIGN_4K , NULL ) ; if ( cli_context -> buff == NULL ) { printf ( "Error<S2SV_blank>in<S2SV_blank>allocating<S2SV_blank>memory\\n" ) ; spdk_blob_close ( cli_context -> blob , close_cb , cli_context ) ; return ; } printf ( "Working" ) ; cli_context -> blob_pages = spdk_blob_get_num_pages ( cli_context -> blob ) ; cli_context -> page_count = 0 ; if ( cli_context -> action == CLI_DUMP_BLOB ) { cli_context -> fp = fopen ( cli_context -> file , "w" ) ; if ( cli_context -> fp == NULL ) { printf ( "Error<S2SV_blank>in<S2SV_blank>opening<S2SV_blank>file\\n" ) ; spdk_blob_close ( cli_context -> blob , close_cb , cli_context ) ; return ; } spdk_bs_io_read_blob ( cli_context -> blob , cli_context -> channel , cli_context -> buff , cli_context -> page_count , NUM_PAGES , read_dump_cb , cli_context ) ; } else { cli_context -> fp = fopen ( cli_context -> file , "r" ) ; if ( cli_context -> fp == NULL ) { <S2SV_StartBug> printf ( "Error<S2SV_blank>in<S2SV_blank>opening<S2SV_blank>file\\n" ) ; <S2SV_EndBug> spdk_blob_close ( cli_context -> blob , close_cb , cli_context ) ; return ; } fseek ( cli_context -> fp , 0L , SEEK_END ) ; cli_context -> filesize = ftell ( cli_context -> fp ) ; rewind ( cli_context -> fp ) ; cli_context -> bytes_so_far = fread ( cli_context -> buff , NUM_PAGES , cli_context -> page_size , cli_context -> fp ) ; if ( cli_context -> filesize < cli_context -> page_size ) { uint8_t * offset = cli_context -> buff + cli_context -> filesize ; memset ( offset , 0 , cli_context -> page_size - cli_context -> filesize ) ; } spdk_bs_io_write_blob ( cli_context -> blob , cli_context -> channel , cli_context -> buff , cli_context -> page_count , NUM_PAGES , write_imp_cb , cli_context ) ; } } | <S2SV_ModStart> { printf ( "Error<S2SV_blank>in<S2SV_blank>opening<S2SV_blank>file:<S2SV_blank>errno<S2SV_blank>%d\\n" , errno <S2SV_ModEnd> ) ; spdk_blob_close |
6,536 | CWE-000 void main ( void ) { initialization ( ) ; float adcVoltage = getHandleAngle ( ) ; TRISBbits . TRISB3 = 0 ; TRISBbits . TRISB4 = 0 ; int handleMovement = 0 ; float angleCurrent = 0 ; float anglePrevious = 0 ; <S2SV_StartBug> float angleDelta = 0 ; <S2SV_EndBug> while ( 1 ) { anglePrevious = getHandleAngle ( ) ; handleMovement = 0 ; while ( handleMovement == 0 ) { ClearWatchDogTimer ( ) ; TimeSinceLastHourCheck ++ ; if ( TimeSinceLastHourCheck > 5000 ) { TimeSinceLastHourCheck = 0 ; } int sandy = 1 ; delayMs ( upstrokeInterval ) ; float newAngle = getHandleAngle ( ) ; float deltaAngle = newAngle - anglePrevious ; if ( deltaAngle < 0 ) { deltaAngle *= - 1 ; } if ( deltaAngle > handleMovementThreshold ) { <S2SV_StartBug> PORTBbits . RB3 = 1 ; <S2SV_EndBug> <S2SV_StartBug> } else { <S2SV_EndBug> <S2SV_StartBug> PORTBbits . RB3 = 1 ; <S2SV_EndBug> } PORTBbits . RB4 = 0 ; handleMovement ++ ; } PORTBbits . RB4 = 1 ; if ( readWaterSensor ( ) ) { PORTBbits . RB4 = 1 ; } else { <S2SV_StartBug> PORTBbits . RB4 = 1 ; <S2SV_EndBug> } } return ; } | <S2SV_ModStart> ; float angleDelta = 0 ; PORTBbits . RB3 = 0 ; PORTBbits . RB4 <S2SV_ModStart> handleMovementThreshold ) { handleMovement = 1 ; <S2SV_ModStart> = 1 ; PORTBbits . RB4 = 0 ; <S2SV_ModStart> . RB3 = 0 ; PORTBbits . RB4 = 0 ; handleMovement = 1 ; } } <S2SV_ModEnd> if ( readWaterSensor <S2SV_ModStart> . RB4 = 0 <S2SV_ModEnd> ; } } |
6,537 | CWE-000 struct CO_core * CO_init ( uint32_t node_id , void * can_driver , void ( * nmt_state_changed_callback ) ( CO_NMT_internalState_t previous_state , CO_NMT_internalState_t requested_state ) ) { int32_t err ; <S2SV_StartBug> void * OD = NULL ; <S2SV_EndBug> void * CANdev = ( void * ) 0x1234 ; struct con_od_list_node_var * device_type ; device_type = MALLOC ( sizeof ( struct con_od_list_node_var ) ) ; INIT_OD_ENTRY_VAR ( device_type , 0x1000 , OD_TYPE_UINT32 , CO_ODA_READABLE , & device_type_data , NULL , NULL ) ; OD = & device_type ; err = make_nmt_od_entries ( OD ) ; if ( err ) { return NULL ; } err = CO_NMT_init ( & CO_core . NMT , node_id , OD , nmt_state_changed_callback , CO_CAN_ID_NMT_SERVICE , can_driver ) ; if ( err ) { return NULL ; } <S2SV_StartBug> err = ( int32_t ) co_driver_register_callback ( CO_CAN_ID_NMT_SERVICE + node_id , <S2SV_EndBug> CO_NMT_receive , & CO_core . NMT ) ; if ( err ) { return NULL ; } return & CO_core ; } | <S2SV_ModStart> OD = NULL <S2SV_ModEnd> ; struct con_od_list_node_var <S2SV_ModStart> co_driver_register_callback ( CO_CAN_ID_NMT_SERVICE <S2SV_ModEnd> , CO_NMT_receive , |
6,538 | CWE-000 static void pmac_show_cpuinfo ( struct seq_file * m ) { struct device_node * np ; const char * pp ; int plen ; int mbmodel ; unsigned int mbflags ; char * mbname ; mbmodel = pmac_call_feature ( PMAC_FTR_GET_MB_INFO , NULL , PMAC_MB_INFO_MODEL , 0 ) ; mbflags = pmac_call_feature ( PMAC_FTR_GET_MB_INFO , NULL , PMAC_MB_INFO_FLAGS , 0 ) ; if ( pmac_call_feature ( PMAC_FTR_GET_MB_INFO , NULL , PMAC_MB_INFO_NAME , ( long ) & mbname ) != 0 ) mbname = "Unknown" ; seq_printf ( m , "machine\\t\\t:<S2SV_blank>" ) ; np = of_find_node_by_path ( "/" ) ; if ( np != NULL ) { pp = of_get_property ( np , "model" , NULL ) ; if ( pp != NULL ) seq_printf ( m , "%s\\n" , pp ) ; else seq_printf ( m , "PowerMac\\n" ) ; pp = of_get_property ( np , "compatible" , & plen ) ; if ( pp != NULL ) { seq_printf ( m , "motherboard\\t:" ) ; while ( plen > 0 ) { int l = strlen ( pp ) + 1 ; seq_printf ( m , "<S2SV_blank>%s" , pp ) ; plen -= l ; pp += l ; } seq_printf ( m , "\\n" ) ; } of_node_put ( np ) ; } else seq_printf ( m , "PowerMac\\n" ) ; seq_printf ( m , "detected<S2SV_blank>as\\t:<S2SV_blank>%d<S2SV_blank>(%s)\\n" , mbmodel , mbname ) ; seq_printf ( m , "pmac<S2SV_blank>flags\\t:<S2SV_blank>%08x\\n" , mbflags ) ; np = of_find_node_by_name ( NULL , "l2-cache" ) ; if ( np == NULL ) np = of_find_node_by_type ( NULL , "cache" ) ; if ( np != NULL ) { const unsigned int * ic = of_get_property ( np , "i-cache-size" , NULL ) ; const unsigned int * dc = of_get_property ( np , "d-cache-size" , NULL ) ; seq_printf ( m , "L2<S2SV_blank>cache\\t:" ) ; has_l2cache = 1 ; <S2SV_StartBug> if ( of_get_property ( np , "cache-unified" , NULL ) != 0 && dc ) { <S2SV_EndBug> seq_printf ( m , "<S2SV_blank>%dK<S2SV_blank>unified" , * dc / 1024 ) ; } else { if ( ic ) seq_printf ( m , "<S2SV_blank>%dK<S2SV_blank>instruction" , * ic / 1024 ) ; if ( dc ) seq_printf ( m , "%s<S2SV_blank>%dK<S2SV_blank>data" , ( ic ? "<S2SV_blank>+" : "" ) , * dc / 1024 ) ; } pp = of_get_property ( np , "ram-type" , NULL ) ; if ( pp ) seq_printf ( m , "<S2SV_blank>%s" , pp ) ; seq_printf ( m , "\\n" ) ; of_node_put ( np ) ; } seq_printf ( m , "pmac-generation\\t:<S2SV_blank>%s\\n" , pmac_newworld ? "NewWorld" : "OldWorld" ) ; } | <S2SV_ModStart> , NULL ) <S2SV_ModEnd> && dc ) |
6,539 | CWE-000 char * disemvowel ( char * str ) { size_t leng = strlen ( str ) ; int i ; int consonants = 0 ; for ( i = 0 ; i < leng ; i = i + 1 ) { if ( check_not_vowel ( str [ i ] ) ) { consonants = consonants + 1 ; } } int j = 0 ; <S2SV_StartBug> char * toReturn = ( char * ) malloc ( consonants ) ; <S2SV_EndBug> for ( i = 0 ; i < leng ; i = i + 1 ) { if ( check_not_vowel ( str [ i ] ) ) { toReturn [ j ] = str [ i ] ; j = j + 1 ; } } toReturn [ j ] = '\\0' ; <S2SV_StartBug> free ( toReturn ) ; <S2SV_EndBug> return ( char * ) toReturn ; } | <S2SV_ModStart> malloc ( consonants + 1 <S2SV_ModStart> = '\\0' ; <S2SV_ModEnd> return ( char |
6,540 | CWE-000 void clk_disable ( struct clk * clk ) { <S2SV_StartBug> const char * name = clk ? clk -> dbg_name : NULL ; <S2SV_EndBug> unsigned long flags ; if ( IS_ERR_OR_NULL ( clk ) ) <S2SV_StartBug> return ; <S2SV_EndBug> spin_lock_irqsave ( & clk -> lock , flags ) ; WARN ( ! clk -> prepare_count , "%s:<S2SV_blank>Never<S2SV_blank>called<S2SV_blank>prepare<S2SV_blank>or<S2SV_blank>calling<S2SV_blank>disable<S2SV_blank>after<S2SV_blank>unprepare\\n" , name ) ; if ( WARN ( clk -> count == 0 , "%s<S2SV_blank>is<S2SV_blank>unbalanced" , name ) ) goto out ; if ( clk -> count == 1 ) { struct clk * parent = clk -> parent ; trace_clock_disable ( name , 0 , smp_processor_id ( ) ) ; if ( clk -> ops -> disable ) clk -> ops -> disable ( clk ) ; clk_disable ( clk -> depends ) ; clk_disable ( parent ) ; } clk -> count -- ; out : spin_unlock_irqrestore ( & clk -> lock , flags ) ; } | <S2SV_ModStart> char * name <S2SV_ModEnd> ; unsigned long <S2SV_ModStart> ) ) return ; name = clk -> dbg_name |
6,541 | CWE-000 static inline int handle_ipv6 ( struct __sk_buff * skb ) { void * data = ( void * ) ( long ) skb -> data ; void * data_end = ( void * ) ( long ) skb -> data_end ; struct lb6_key key = { } ; struct lb6_service * svc ; struct ipv6hdr * ip6 = data + ETH_HLEN ; union v6addr * dst = ( union v6addr * ) & ip6 -> daddr ; struct csum_offset csum_off = { } ; int l3_off , l4_off , ret ; union v6addr new_dst ; __u8 nexthdr ; __u16 slave ; if ( data + ETH_HLEN + sizeof ( * ip6 ) > data_end ) return DROP_INVALID ; cilium_trace_capture ( skb , DBG_CAPTURE_FROM_LB , skb -> ingress_ifindex ) ; nexthdr = ip6 -> nexthdr ; ipv6_addr_copy ( & key . address , dst ) ; l3_off = ETH_HLEN ; l4_off = ETH_HLEN + ipv6_hdrlen ( skb , ETH_HLEN , & nexthdr ) ; csum_l4_offset_and_flags ( nexthdr , & csum_off ) ; # ifdef LB_L4 ret = extract_l4_port ( skb , nexthdr , l4_off , & key . dport ) ; if ( IS_ERR ( ret ) ) { if ( ret == DROP_UNKNOWN_L4 ) { return TC_ACT_OK ; } else return ret ; } # endif svc = lb6_lookup_service ( skb , & key ) ; if ( svc == NULL ) { return TC_ACT_OK ; } <S2SV_StartBug> slave = lb_select_slave ( skb , svc -> count ) ; <S2SV_EndBug> if ( ! ( svc = lb6_lookup_slave ( skb , & key , slave ) ) ) return DROP_NO_SERVICE ; ipv6_addr_copy ( & new_dst , & svc -> target ) ; if ( svc -> rev_nat_index ) new_dst . p4 |= svc -> rev_nat_index ; ret = lb6_xlate ( skb , & new_dst , nexthdr , l3_off , l4_off , & csum_off , & key , svc ) ; if ( IS_ERR ( ret ) ) return ret ; return TC_ACT_REDIRECT ; } | <S2SV_ModStart> } slave = lb6_select_slave ( skb , & key <S2SV_ModEnd> , svc -> <S2SV_ModStart> svc -> count , svc -> weight |
6,542 | CWE-000 <S2SV_StartBug> static long init_record ( void * precord , int pass ) <S2SV_EndBug> { <S2SV_StartBug> aiRecord * prec = ( aiRecord * ) precord ; <S2SV_EndBug> aidset * pdset ; double eoff = prec -> eoff , eslo = prec -> eslo ; if ( pass == 0 ) return ( 0 ) ; if ( prec -> siml . type == CONSTANT ) { recGblInitConstantLink ( & prec -> siml , DBF_USHORT , & prec -> simm ) ; } if ( prec -> siol . type == CONSTANT ) { recGblInitConstantLink ( & prec -> siol , DBF_DOUBLE , & prec -> sval ) ; } if ( ! ( pdset = ( aidset * ) ( prec -> dset ) ) ) { recGblRecordError ( S_dev_noDSET , ( void * ) prec , "ai:<S2SV_blank>init_record" ) ; return ( S_dev_noDSET ) ; } if ( ( pdset -> number < 6 ) || ( pdset -> read_ai == NULL ) ) { recGblRecordError ( S_dev_missingSup , ( void * ) prec , "ai:<S2SV_blank>init_record" ) ; return ( S_dev_missingSup ) ; } prec -> init = TRUE ; if ( ( prec -> eslo == 1.0 ) && ( prec -> eoff == 0.0 ) ) { prec -> eoff = prec -> egul ; } if ( pdset -> init_record ) { long status = ( * pdset -> init_record ) ( prec ) ; if ( prec -> linr == menuConvertSLOPE ) { prec -> eoff = eoff ; prec -> eslo = eslo ; } return ( status ) ; } prec -> mlst = prec -> val ; prec -> alst = prec -> val ; prec -> lalm = prec -> val ; prec -> oraw = prec -> rval ; return ( 0 ) ; } | <S2SV_ModStart> long init_record ( aiRecord * prec <S2SV_ModEnd> , int pass <S2SV_ModStart> pass ) { <S2SV_ModEnd> aidset * pdset |
6,543 | CWE-000 static void * oshfs_init ( struct fuse_conn_info * conn ) { int i ; <S2SV_StartBug> fs_addr * ip ; <S2SV_EndBug> mem [ 0 ] = create_new_block ( ) ; <S2SV_StartBug> init_prologue_block ( 1 , FORMAL_DATA_NUMBER ) ; <S2SV_EndBug> markbit ( 0 ) ; for ( i = 1 ; i <= FORMAL_DATA_NUMBER ; i ++ ) <S2SV_StartBug> mark ( i ) ; <S2SV_EndBug> ip = ( fs_addr * ) mem [ 0 ] ; ip [ 1 ] = FORMAL_DATA_NUMBER + 1 ; ip [ 0 ] = BLOCKNR ; <S2SV_StartBug> ip [ 2 ] = root ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> int i ; <S2SV_ModEnd> mem [ 0 <S2SV_ModStart> ( ) ; markbit ( 0 ) ; <S2SV_ModStart> 1 , FORMAL_DATA_NUMBER <S2SV_ModEnd> ) ; for <S2SV_ModStart> i ++ ) markbit <S2SV_ModEnd> ( i ) <S2SV_ModStart> 2 ] = 0 <S2SV_ModEnd> ; return 0 |
6,544 | CWE-000 static void ack ( LiveAPIReceiveFixedState * state , size_t offset ) <S2SV_StartBug> { <S2SV_EndBug> state -> offset = offset ; state -> send_events = SEND_ACK ; } | <S2SV_ModStart> offset ) { if ( ! state -> valid && offset != 0xFFFF ) { return ; } |
6,545 | CWE-000 WimaStatus wima_area_moveSplit ( DynaTree areas , DynaNode node , WimaMouseSplitEvent e , WimaPos cursor ) { <S2SV_StartBug> yassert_wima_init ; <S2SV_EndBug> WimaAr * area = dtree_node ( areas , node ) ; assert ( area ) ; WimaPos pos = wima_area_translatePos ( area , cursor ) ; int diff = ( e . vertical ? pos . x : pos . y ) - area -> parent . spliti ; bool isLeft = diff < 0 ; DynaNode child = isLeft ? dtree_left ( node ) : dtree_right ( node ) ; int limit = wima_area_node_moveSplit_limit ( areas , child , diff < 0 , e . vertical ) ; limit = isLeft && limit != 0 ? - limit : limit ; if ( limit == 0 ) { return WIMA_STATUS_SUCCESS ; } diff = abs ( diff ) > abs ( limit ) ? limit : diff ; area -> parent . spliti += diff ; float dim = ( float ) ( ( e . vertical ? area -> rect . w : area -> rect . h ) - 1 ) ; area -> parent . split = ( float ) area -> parent . spliti / dim ; WimaStatus status ; DynaNode leftNode = dtree_left ( node ) ; DynaNode rightNode = dtree_right ( node ) ; status = wima_area_node_moveSplit ( areas , leftNode , diff , true , e . vertical ) ; if ( status ) { return status ; } status = wima_area_node_moveSplit ( areas , rightNode , - diff , false , e . vertical ) ; if ( status ) { return status ; } status = wima_area_node_resize ( areas , node , area -> rect , false ) ; return status ; } | <S2SV_ModStart> cursor ) { assert_wima_init <S2SV_ModEnd> ; WimaAr * |
6,546 | CWE-000 static void * hash_acl_set_heap ( acl_main_t * am ) { if ( 0 == am -> hash_lookup_mheap ) { am -> hash_lookup_mheap = mheap_alloc ( 0 , 2 << 25 ) ; <S2SV_StartBug> } <S2SV_EndBug> void * oldheap = clib_mem_set_heap ( am -> hash_lookup_mheap ) ; return oldheap ; } | <S2SV_ModStart> 25 ) ; mheap_t * h = mheap_header ( am -> hash_lookup_mheap ) ; h -> flags |= MHEAP_FLAG_THREAD_SAFE ; |
6,547 | CWE-000 enum pwm_status pwm_set_duty ( enum pwm_pin pwm , duty_pct duty ) { pwm_assert ( pwm_valid ( pwm ) ) ; pwm_assert ( duty >= 0.0 && duty <= 100.0 ) ; uint32_t period_counts = PWMGenPeriodGet ( pwm_module , pwm_gen [ pwm ] ) ; <S2SV_StartBug> uint32_t duty_period = ( uint32_t ) ( period_counts * duty / 100.0 ) ; <S2SV_EndBug> if ( duty_period >= period_counts ) { PWMPulseWidthSet ( pwm_module , pwm_out [ pwm ] . out , 0 ) ; PWMOutputInvert ( pwm_module , pwm_out [ pwm ] . bit , true ) ; } else { PWMOutputInvert ( pwm_module , pwm_out [ pwm ] . bit , false ) ; PWMPulseWidthSet ( pwm_module , pwm_out [ pwm ] . out , duty_period ) ; } return PWM_SUCCESS ; } | <S2SV_ModStart> duty / 100.0 ) ; tst_debugging ( "%s<S2SV_blank>%d<S2SV_blank>%s\\n" , "" , duty_period , "" |
6,548 | CWE-000 static void fallback_lid_toggle_keyboard_listener ( struct fallback_dispatch * dispatch , <S2SV_StartBug> bool is_closed ) <S2SV_EndBug> { <S2SV_StartBug> if ( ! dispatch -> lid . keyboard ) <S2SV_EndBug> return ; if ( is_closed ) { libinput_device_add_event_listener ( <S2SV_StartBug> & dispatch -> lid . keyboard -> base , <S2SV_EndBug> <S2SV_StartBug> & dispatch -> lid . listener , <S2SV_EndBug> fallback_lid_keyboard_event , dispatch ) ; } else { libinput_device_remove_event_listener ( <S2SV_StartBug> & dispatch -> lid . listener ) ; <S2SV_EndBug> libinput_device_init_event_listener ( <S2SV_StartBug> & dispatch -> lid . listener ) ; <S2SV_EndBug> } } | <S2SV_ModStart> * dispatch , struct paired_keyboard * kbd , <S2SV_ModStart> is_closed ) { assert ( kbd -> device ) <S2SV_ModEnd> ; if ( <S2SV_ModStart> libinput_device_add_event_listener ( & kbd -> device <S2SV_ModEnd> -> base , <S2SV_ModStart> base , & kbd -> <S2SV_ModEnd> listener , fallback_lid_keyboard_event <S2SV_ModStart> libinput_device_remove_event_listener ( & kbd -> <S2SV_ModEnd> listener ) ; <S2SV_ModStart> libinput_device_init_event_listener ( & kbd -> <S2SV_ModEnd> listener ) ; |
6,549 | CWE-000 static Oid DefineVirtualRelation ( RangeVar * relation , List * tlist , bool replace , List * options ) { Oid viewOid ; LOCKMODE lockmode ; CreateStmt * createStmt = makeNode ( CreateStmt ) ; List * attrList ; ListCell * t ; createStmt -> ownerid = GetUserId ( ) ; attrList = NIL ; foreach ( t , tlist ) { TargetEntry * tle = lfirst ( t ) ; if ( ! tle -> resjunk ) { ColumnDef * def = makeNode ( ColumnDef ) ; def -> colname = pstrdup ( tle -> resname ) ; def -> typeName = makeTypeNameFromOid ( exprType ( ( Node * ) tle -> expr ) , exprTypmod ( ( Node * ) tle -> expr ) ) ; def -> inhcount = 0 ; def -> is_local = true ; def -> is_not_null = false ; def -> is_from_type = false ; def -> storage = 0 ; def -> raw_default = NULL ; def -> cooked_default = NULL ; def -> collClause = NULL ; def -> collOid = exprCollation ( ( Node * ) tle -> expr ) ; if ( type_is_collatable ( exprType ( ( Node * ) tle -> expr ) ) ) { if ( ! OidIsValid ( def -> collOid ) ) ereport ( ERROR , ( errcode ( ERRCODE_INDETERMINATE_COLLATION ) , errmsg ( "could<S2SV_blank>not<S2SV_blank>determine<S2SV_blank>which<S2SV_blank>collation<S2SV_blank>to<S2SV_blank>use<S2SV_blank>for<S2SV_blank>view<S2SV_blank>column<S2SV_blank>\\"%s\\"" , def -> colname ) , errhint ( "Use<S2SV_blank>the<S2SV_blank>COLLATE<S2SV_blank>clause<S2SV_blank>to<S2SV_blank>set<S2SV_blank>the<S2SV_blank>collation<S2SV_blank>explicitly." ) ) ) ; } else Assert ( ! OidIsValid ( def -> collOid ) ) ; def -> constraints = NIL ; attrList = lappend ( attrList , def ) ; } } if ( attrList == NIL ) ereport ( ERROR , ( errcode ( ERRCODE_INVALID_TABLE_DEFINITION ) , errmsg ( "view<S2SV_blank>must<S2SV_blank>have<S2SV_blank>at<S2SV_blank>least<S2SV_blank>one<S2SV_blank>column" ) ) ) ; lockmode = replace ? AccessExclusiveLock : NoLock ; ( void ) RangeVarGetAndCheckCreationNamespace ( relation , lockmode , & viewOid ) ; if ( OidIsValid ( viewOid ) && replace ) { Relation rel ; TupleDesc descriptor ; List * atcmds = NIL ; AlterTableCmd * atcmd ; rel = relation_open ( viewOid , NoLock ) ; if ( rel -> rd_rel -> relkind != RELKIND_VIEW ) ereport ( ERROR , ( errcode ( ERRCODE_WRONG_OBJECT_TYPE ) , errmsg ( "\\"%s\\"<S2SV_blank>is<S2SV_blank>not<S2SV_blank>a<S2SV_blank>view" , RelationGetRelationName ( rel ) ) ) ) ; CheckTableNotInUse ( rel , "CREATE<S2SV_blank>OR<S2SV_blank>REPLACE<S2SV_blank>VIEW" ) ; Assert ( relation -> relpersistence == rel -> rd_rel -> relpersistence ) ; descriptor = BuildDescForRelation ( attrList ) ; checkViewTupleDesc ( descriptor , rel -> rd_att ) ; atcmd = makeNode ( AlterTableCmd ) ; atcmd -> subtype = AT_ReplaceRelOptions ; atcmd -> def = ( Node * ) options ; atcmds = lappend ( atcmds , atcmd ) ; if ( list_length ( attrList ) > rel -> rd_att -> natts ) { ListCell * c ; int skip = rel -> rd_att -> natts ; foreach ( c , attrList ) { if ( skip > 0 ) { skip -- ; continue ; } atcmd = makeNode ( AlterTableCmd ) ; atcmd -> subtype = AT_AddColumnToView ; atcmd -> def = ( Node * ) lfirst ( c ) ; atcmds = lappend ( atcmds , atcmd ) ; } } AlterTableInternal ( viewOid , atcmds , true ) ; relation_close ( rel , NoLock ) ; return viewOid ; } else { Oid relid ; createStmt -> relation = relation ; createStmt -> tableElts = attrList ; createStmt -> inhRelations = NIL ; createStmt -> inhOids = NIL ; createStmt -> parentOidCount = 0 ; createStmt -> constraints = NIL ; createStmt -> options = options ; createStmt -> options = lappend ( options , defWithOids ( false ) ) ; createStmt -> oncommit = ONCOMMIT_NOOP ; createStmt -> tablespacename = NULL ; createStmt -> relKind = RELKIND_VIEW ; createStmt -> if_not_exists = false ; <S2SV_StartBug> relid = DefineRelation ( createStmt , RELKIND_VIEW , InvalidOid , RELSTORAGE_VIRTUAL , false , true ) ; <S2SV_EndBug> Assert ( relid != InvalidOid ) ; return relid ; } } | <S2SV_ModStart> false , true , NULL |
6,550 | CWE-000 void SwapMasterPoint ( Bag bag1 , Bag bag2 ) { <S2SV_StartBug> Bag * ptr1 ; <S2SV_EndBug> Bag * ptr2 ; Bag swapbag ; if ( bag1 == bag2 ) return ; <S2SV_StartBug> ptr1 = PTR_BAG ( bag1 ) ; <S2SV_EndBug> ptr2 = PTR_BAG ( bag2 ) ; if ( LINK_BAG ( bag1 ) == bag1 && LINK_BAG ( bag2 ) == bag2 ) { LINK_BAG ( bag1 ) = bag2 ; LINK_BAG ( bag2 ) = bag1 ; } else { if ( LINK_BAG ( bag1 ) == bag1 ) { LINK_BAG ( bag1 ) = ChangedBags ; ChangedBags = bag1 ; } if ( LINK_BAG ( bag2 ) == bag2 ) { LINK_BAG ( bag2 ) = ChangedBags ; ChangedBags = bag2 ; } <S2SV_StartBug> swapbag = LINK_BAG ( bag1 ) ; <S2SV_EndBug> LINK_BAG ( bag1 ) = LINK_BAG ( bag2 ) ; LINK_BAG ( bag2 ) = swapbag ; } <S2SV_StartBug> SET_PTR_BAG ( bag1 , ptr2 ) ; <S2SV_EndBug> SET_PTR_BAG ( bag2 , ptr1 ) ; } | <S2SV_ModStart> { Bag * swapptr <S2SV_ModEnd> ; Bag swapbag <S2SV_ModStart> ) return ; <S2SV_ModEnd> if ( LINK_BAG <S2SV_ModStart> bag2 ; } swapptr = PTR_BAG ( bag1 ) ; SET_PTR_BAG ( bag1 , PTR_BAG ( bag2 ) ) ; SET_PTR_BAG ( bag2 , swapptr ) ; <S2SV_ModStart> swapbag ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
6,551 | CWE-000 static void read_from_client ( void * arg ) { struct connection * c = arg ; int rbytes = 0 ; for ( ; ; ) { rbytes = read ( c -> fd , c -> t -> shared_rbuf , 1024 * 32 ) ; if ( rbytes == - 1 ) { if ( errno == EAGAIN || errno == EWOULDBLOCK ) { break ; } else { perror ( "Read<S2SV_blank>error<S2SV_blank>from<S2SV_blank>client" ) ; } } <S2SV_StartBug> if ( rbytes < 4095 ) <S2SV_EndBug> break ; } } | <S2SV_ModStart> ( rbytes < 2096 <S2SV_ModEnd> ) break ; |
6,552 | CWE-000 const uschar * expand_cstring ( const uschar * string ) { <S2SV_StartBug> search_find_defer = FALSE ; <S2SV_EndBug> malformed_header = FALSE ; <S2SV_StartBug> return ( Ustrpbrk ( string , "$\\\\" ) == NULL ) ? string : <S2SV_EndBug> expand_string_internal ( string , FALSE , NULL , FALSE , TRUE , NULL ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> string ) { if ( Ustrpbrk ( string , "$\\\\" ) != NULL ) { int old_pool = store_pool ; uschar * s ; <S2SV_ModStart> = FALSE ; store_pool = POOL_MAIN ; s = <S2SV_ModEnd> expand_string_internal ( string <S2SV_ModStart> NULL ) ; store_pool = old_pool ; return s ; } return string ; |
6,553 | CWE-000 list_node_t * list_remove_first ( list_t * list ) { list_node_t * head = ( list_node_t * ) NULL ; list_node_t * next = ( list_node_t * ) NULL ; list_node_t * ret = ( list_node_t * ) NULL ; if ( list == ( list_t * ) NULL ) { goto cleanup ; } head = & ( list -> head ) ; ret = head -> next ; if ( ret == head ) { <S2SV_StartBug> goto cleanup ; <S2SV_EndBug> } next = ret -> next ; head -> next = next ; next -> prev = head ; ret -> next = ret ; ret -> prev = ret ; list -> node_count -- ; cleanup : return ret ; } | <S2SV_ModStart> head ) { ret = ( list_node_t * ) NULL ; |
6,554 | CWE-000 int main ( ) { int choice = 0 ; <S2SV_StartBug> Matrix * m1 ; <S2SV_EndBug> <S2SV_StartBug> Matrix * m2 ; <S2SV_EndBug> <S2SV_StartBug> Matrix * r ; <S2SV_EndBug> printf ( "Welcome<S2SV_blank>to<S2SV_blank>MatrixCalc.\\n" ) ; while ( choice > 5 || choice < 1 ) { printf ( "Please<S2SV_blank>select<S2SV_blank>an<S2SV_blank>option\\n" ) ; printf ( "1)Addition\\n" "2)Subtraction\\n" "3)Muliplication\\n" <S2SV_StartBug> "4)inverse\\n" <S2SV_EndBug> "5)Transpose\\n\\n" ) ; scanf ( "%i" , & choice ) ; } printf ( "\\n\\n" ) ; m1 = promptMatrix ( ) ; printf ( "You<S2SV_blank>have<S2SV_blank>entered<S2SV_blank>the<S2SV_blank>following<S2SV_blank>matrix\\n" ) ; printMatrix ( m1 ) ; switch ( choice ) { case 1 : m2 = promptMatrixRC ( m1 -> rowC , m1 -> colC ) ; printf ( "You<S2SV_blank>have<S2SV_blank>entered<S2SV_blank>the<S2SV_blank>following<S2SV_blank>matrix\\n" ) ; r = addMatrix ( m1 , m2 ) ; printf ( "The<S2SV_blank>addition<S2SV_blank>of<S2SV_blank>your<S2SV_blank>matrices<S2SV_blank>is\\n" ) ; printMatrix ( r ) ; break ; case 2 : m2 = promptMatrixRC ( m1 -> rowC , m1 -> colC ) ; printf ( "You<S2SV_blank>have<S2SV_blank>entered<S2SV_blank>the<S2SV_blank>following<S2SV_blank>matrix\\n\\n" ) ; r = subMatrix ( m1 , m2 ) ; printf ( "The<S2SV_blank>subtraction<S2SV_blank>of<S2SV_blank>your<S2SV_blank>matrices<S2SV_blank>is\\n\\n" ) ; printMatrix ( r ) ; break ; case 3 : m2 = promptMatrixRC ( m1 -> colC , 0 ) ; printf ( "You<S2SV_blank>have<S2SV_blank>entered<S2SV_blank>the<S2SV_blank>following<S2SV_blank>matrix\\n" ) ; r = multMatrix ( m1 , m2 ) ; printf ( "The<S2SV_blank>product<S2SV_blank>of<S2SV_blank>your<S2SV_blank>matrices<S2SV_blank>is\\n\\n" ) ; printMatrix ( r ) ; break ; case 4 : printf ( "Functionality<S2SV_blank>not<S2SV_blank>yet<S2SV_blank>implemented\\n\\n" ) ; break ; case 5 : r = transposeM ( m1 ) ; printf ( "The<S2SV_blank>transpose<S2SV_blank>of<S2SV_blank>your<S2SV_blank>matrix<S2SV_blank>is\\n\\n" ) ; printMatrix ( r ) ; break ; } if ( m1 ) destroyMatrix ( m1 ) ; <S2SV_StartBug> if ( m2 != NULL ) <S2SV_EndBug> <S2SV_StartBug> destroyMatrix ( m2 ) ; <S2SV_EndBug> if ( r ) destroyMatrix ( r ) ; return 0 ; } | <S2SV_ModStart> Matrix * m1 = NULL <S2SV_ModStart> Matrix * m2 = NULL <S2SV_ModStart> Matrix * r = NULL <S2SV_ModStart> "1)Addition\\n" "2)Subtraction\\n" "3)Muliplication\\n" "4)Inverse\\n" <S2SV_ModEnd> "5)Transpose\\n\\n" ) ; <S2SV_ModStart> if ( m2 ) { <S2SV_ModEnd> destroyMatrix ( m2 <S2SV_ModStart> m2 ) ; } |
6,555 | CWE-000 static void updatePlayer ( void * tData ) { ( void ) tData ; if ( ! gData . mCanShoot || isWrapperPaused ( ) ) return ; if ( hasShotGunFlank ( ) ) { shoot ( ) ; } <S2SV_StartBug> if ( handleDurationAndCheckIfOver ( & gNowDebugShot , 5 ) ) { <S2SV_EndBug> Position p = getLowestMirklingPosition ( ) ; if ( p . y > 200 ) { addShot ( p , 200 ) ; gNowDebugShot = 0 ; } } } | <S2SV_ModStart> ) ; } <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
6,556 | CWE-000 void output_yearly_canopy_stratum ( int basinID , int hillID , int zoneID , <S2SV_StartBug> int patchID , <S2SV_EndBug> struct canopy_strata_object * stratum , struct date current_date , FILE * outfile ) { if ( stratum [ 0 ] . acc_year . length == 0 ) stratum [ 0 ] . acc_year . length = 1 ; fprintf ( outfile , "%4d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%lf<S2SV_blank>%lf<S2SV_blank>%lf<S2SV_blank>\\n" , current_date . year , basinID , hillID , zoneID , patchID , stratum [ 0 ] . ID , ( stratum [ 0 ] . acc_year . psn ) / stratum [ 0 ] . acc_year . length , ( stratum [ 0 ] . acc_year . lwp ) / stratum [ 0 ] . acc_year . length , stratum [ 0 ] . rootzone . depth * 1000.0 ) ; <S2SV_StartBug> stratum [ 0 ] . acc_year . psn = 0.0 ; <S2SV_EndBug> stratum [ 0 ] . acc_year . lwp = 0.0 ; <S2SV_StartBug> stratum [ 0 ] . acc_year . length = 0 ; <S2SV_EndBug> return ; } | <S2SV_ModStart> , int patchID , int reset_flag <S2SV_ModStart> 1000.0 ) ; if ( reset_flag == 1 ) { <S2SV_ModStart> = 0 ; } |
6,557 | CWE-000 static int wm8523_startup ( struct snd_pcm_substream * substream , struct snd_soc_dai * dai ) { struct snd_soc_codec * codec = dai -> codec ; struct wm8523_priv * wm8523 = snd_soc_codec_get_drvdata ( codec ) ; if ( ! wm8523 -> sysclk ) { dev_err ( codec -> dev , "No<S2SV_blank>MCLK<S2SV_blank>configured,<S2SV_blank>call<S2SV_blank>set_sysclk()<S2SV_blank>on<S2SV_blank>init\\n" ) ; return - EINVAL ; } <S2SV_StartBug> return 0 ; <S2SV_EndBug> snd_pcm_hw_constraint_list ( substream -> runtime , 0 , SNDRV_PCM_HW_PARAM_RATE , & wm8523 -> rate_constraint ) ; return 0 ; } | <S2SV_ModStart> EINVAL ; } <S2SV_ModEnd> snd_pcm_hw_constraint_list ( substream |
6,558 | CWE-000 void draw_winner ( t_game * g ) { char text [ 50 ] ; SDL_Event * event = NULL ; sprintf ( text , "AND<S2SV_blank>THE<S2SV_blank>WINNER<S2SV_blank>IS<S2SV_blank>..." ) ; <S2SV_StartBug> drawString ( g , text , 50 , 100 , g -> font , 1 , 0 ) ; <S2SV_EndBug> for ( int i = 0 ; i < MAX_PLAYER ; ++ i ) { if ( g -> player [ i ] -> connected == 1 && g -> player [ i ] -> life > 0 ) { sprintf ( text , "PLAYER<S2SV_blank>%d<S2SV_blank>!!!" , i + 1 ) ; <S2SV_StartBug> drawString ( g , text , 50 , 150 , g -> font , 1 , 0 ) ; <S2SV_EndBug> } } sprintf ( text , "PRESS<S2SV_blank>ANY<S2SV_blank>KEY<S2SV_blank>TO<S2SV_blank>CONTINUE" ) ; <S2SV_StartBug> drawString ( g , text , 50 , 300 , g -> font , 1 , 0 ) ; <S2SV_EndBug> SDL_RenderPresent ( g -> renderer ) ; SDL_WaitEvent ( event ) ; } | <S2SV_ModStart> "AND<S2SV_blank>THE<S2SV_blank>WINNER<S2SV_blank>IS<S2SV_blank>..." ) ; draw_string <S2SV_ModEnd> ( g , <S2SV_ModStart> 1 ) ; draw_string <S2SV_ModEnd> ( g , <S2SV_ModStart> "PRESS<S2SV_blank>ANY<S2SV_blank>KEY<S2SV_blank>TO<S2SV_blank>CONTINUE" ) ; draw_string <S2SV_ModEnd> ( g , |
6,559 | CWE-000 static bool fiddle_bare_shunt ( const ip_address * src , const ip_address * dst , policy_prio_t policy_prio , ipsec_spi_t cur_shunt_spi , ipsec_spi_t new_shunt_spi , bool repl , int transport_proto , const char * why ) { ip_subnet this_client , that_client ; const ip_address * null_host = aftoinfo ( addrtypeof ( src ) ) -> any ; DBG ( DBG_CONTROL , DBG_log ( "fiddle_bare_shunt<S2SV_blank>called" ) ) ; passert ( addrtypeof ( src ) == addrtypeof ( dst ) ) ; happy ( addrtosubnet ( src , & this_client ) ) ; happy ( addrtosubnet ( dst , & that_client ) ) ; DBG ( DBG_CONTROL , if ( transport_proto != 0 ) DBG_log ( "fiddle_bare_shunt<S2SV_blank>with<S2SV_blank>transport_proto<S2SV_blank>%d" , transport_proto ) ) ; enum pluto_sadb_operations op = repl ? ERO_REPLACE : ERO_DELETE ; DBG ( DBG_KERNEL , DBG_log ( "%s<S2SV_blank>specific<S2SV_blank>host-to-host<S2SV_blank>bare<S2SV_blank>shunt" , repl ? "replacing" : "removing" ) ) ; if ( raw_eroute ( null_host , & this_client , null_host , & that_client , htonl ( cur_shunt_spi ) , htonl ( new_shunt_spi ) , SA_INT , transport_proto , ET_INT , null_proto_info , deltatime ( SHUNT_PATIENCE ) , <S2SV_StartBug> DEFAULT_IPSEC_SA_PRIORITY , <S2SV_EndBug> NULL , op , why # ifdef HAVE_LABELED_IPSEC , NULL # endif ) ) { struct bare_shunt * * bs_pp = bare_shunt_ptr ( & this_client , & that_client , transport_proto ) ; DBG ( DBG_CONTROL , DBG_log ( "raw_eroute<S2SV_blank>with<S2SV_blank>op=\'%s\'<S2SV_blank>for<S2SV_blank>transport_proto=\'%d\'<S2SV_blank>kernel<S2SV_blank>shunt<S2SV_blank>succeeded,<S2SV_blank>bare<S2SV_blank>shunt<S2SV_blank>lookup<S2SV_blank>%s" , repl ? "replace" : "delete" , transport_proto , ( bs_pp == NULL ) ? "failed" : "succeeded" ) ) ; if ( bs_pp == NULL ) { ipstr_buf srcb , dstb ; libreswan_log ( "can\'t<S2SV_blank>find<S2SV_blank>expected<S2SV_blank>bare<S2SV_blank>shunt<S2SV_blank>to<S2SV_blank>%s:<S2SV_blank>%s->%s<S2SV_blank>transport_proto=\'%d\'" , repl ? "replace" : "delete" , ipstr ( src , & srcb ) , ipstr ( dst , & dstb ) , transport_proto ) ; return TRUE ; } if ( repl ) { struct bare_shunt * bs = * bs_pp ; bs -> why = why ; bs -> policy_prio = policy_prio ; bs -> said . spi = htonl ( new_shunt_spi ) ; bs -> said . proto = SA_INT ; bs -> said . dst = * null_host ; bs -> count = 0 ; bs -> last_activity = mononow ( ) ; DBG_bare_shunt ( "change" , bs ) ; } else { free_bare_shunt ( bs_pp ) ; } return TRUE ; } else { struct bare_shunt * * bs_pp = bare_shunt_ptr ( & this_client , & that_client , transport_proto ) ; free_bare_shunt ( bs_pp ) ; libreswan_log ( "raw_eroute()<S2SV_blank>to<S2SV_blank>op=\'%s\'<S2SV_blank>with<S2SV_blank>transport_proto=\'%d\'<S2SV_blank>kernel<S2SV_blank>shunt<S2SV_blank>failed<S2SV_blank>-<S2SV_blank>deleting<S2SV_blank>from<S2SV_blank>pluto<S2SV_blank>shunt<S2SV_blank>table" , repl ? "replace" : "delete" , transport_proto ) ; return FALSE ; } } | <S2SV_ModStart> SHUNT_PATIENCE ) , 0 <S2SV_ModEnd> , NULL , |
6,560 | CWE-000 method ( MCSkybox , MCSkybox * , initWithCubeTexture , BECubeTextureData * cubetex , double widthHeightRatio ) { <S2SV_StartBug> MCGLContext_initWithShaderName ( 0 , var ( ctx ) , "MCSkyboxShader" , "MCSkyboxShader" , <S2SV_EndBug> ( const char * [ ] ) { "position" } , 1 , ( MCGLUniformType [ ] ) { MCGLUniformMat4 , MCGLUniformMat4 , MCGLUniformScalar } , ( const char * [ ] ) { "boxViewMatrix" , "boxProjectionMatrix" , "cubeSampler" } , 3 ) ; MCSkyboxCamera_initWithWidthHeightRatio ( 0 , var ( camera ) , ( MCFloat ) widthHeightRatio ) ; MCUInt buffers [ 3 ] ; glGenVertexArrays ( 1 , & var ( vaoid ) ) ; glGenBuffers ( 3 , buffers ) ; var ( vboid ) = buffers [ 0 ] ; var ( eboid ) = buffers [ 1 ] ; var ( texid ) = buffers [ 2 ] ; glBindVertexArray ( var ( vaoid ) ) ; glBindBuffer ( GL_ARRAY_BUFFER , var ( vboid ) ) ; glBufferData ( GL_ARRAY_BUFFER , sizeof ( skyboxVertices ) , skyboxVertices , GL_STATIC_DRAW ) ; glBindBuffer ( GL_ELEMENT_ARRAY_BUFFER , var ( eboid ) ) ; glBufferData ( GL_ELEMENT_ARRAY_BUFFER , sizeof ( indexs ) , indexs , GL_STATIC_DRAW ) ; MCVertexAttribute attr = ( MCVertexAttribute ) { MCVertexAttribPosition , 3 , GL_FLOAT , GL_FALSE , sizeof ( GLfloat ) * 3 , MCBUFFER_OFFSET ( 0 ) } ; MCVertexAttributeLoad ( & attr ) ; MCGLEngine_activeTextureUnit ( 0 ) ; MCGLEngine_bindCubeTexture ( var ( texid ) ) ; for ( int i = 0 ; i < 6 ; i ++ ) { BE2DTextureData * face = cubetex -> faces [ i ] ; glTexImage2D ( GL_TEXTURE_CUBE_MAP_POSITIVE_X + i , 0 , GL_RGB , face -> width , face -> height , 0 , GL_RGB , GL_UNSIGNED_BYTE , face -> raw ) ; } glTexParameteri ( GL_TEXTURE_CUBE_MAP , GL_TEXTURE_MIN_FILTER , GL_NEAREST ) ; glTexParameteri ( GL_TEXTURE_CUBE_MAP , GL_TEXTURE_MAG_FILTER , GL_NEAREST ) ; glTexParameteri ( GL_TEXTURE_CUBE_MAP , GL_TEXTURE_WRAP_S , GL_CLAMP_TO_EDGE ) ; glTexParameteri ( GL_TEXTURE_CUBE_MAP , GL_TEXTURE_WRAP_T , GL_CLAMP_TO_EDGE ) ; glBindVertexArray ( 0 ) ; return obj ; } | <S2SV_ModStart> ctx ) , "MCSkyboxShader.vsh" , "MCSkyboxShader.fsh" <S2SV_ModEnd> , ( const |
6,561 | CWE-000 void * ntp ( void * ntp_thread_arg ) { thread_args_s * local_args = ( thread_args_s * ) ntp_thread_arg ; int s ; struct sockaddr_in server_addr ; s = local_args -> s ; server_addr = local_args -> server_addr ; int maxlen = 1024 ; unsigned long buf [ maxlen ] ; unsigned char msg [ 48 ] = { 010 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 } ; uint32_t i , tmit ; while ( 1 ) { <S2SV_StartBug> printf ( "sending<S2SV_blank>data..\\n" ) ; <S2SV_EndBug> <S2SV_StartBug> i = sendto ( s , msg , sizeof ( msg ) , 0 , ( struct sockaddr * ) & server_addr , sizeof ( server_addr ) ) ; <S2SV_EndBug> perror ( "sendto" ) ; struct sockaddr saddr ; socklen_t saddr_l = sizeof ( saddr ) ; <S2SV_StartBug> i = recvfrom ( s , buf , 48 , 0 , & saddr , & saddr_l ) ; <S2SV_EndBug> perror ( "recvfr:" ) ; tmit = ntohl ( ( time_t ) buf [ 10 ] ) ; tmit -= 2208988800U ; <S2SV_StartBug> printf ( "Time:<S2SV_blank>%s" , ctime ( & tmit ) ) ; <S2SV_EndBug> <S2SV_StartBug> i = time ( 0 ) ; <S2SV_EndBug> printf ( "System<S2SV_blank>time<S2SV_blank>is<S2SV_blank>%d<S2SV_blank>seconds<S2SV_blank>off\\n" , i - tmit ) ; pthread_mutex_lock ( & mutex ) ; ntp_time = tmit ; pthread_mutex_unlock ( & mutex ) ; <S2SV_StartBug> usleep ( 100000 ) ; <S2SV_EndBug> } } | <S2SV_ModStart> 1 ) { <S2SV_ModEnd> i = sendto <S2SV_ModStart> ( server_addr ) <S2SV_ModEnd> ) ; struct <S2SV_ModStart> , & saddr_l <S2SV_ModEnd> ) ; tmit <S2SV_ModStart> ; printf ( "SECOND<S2SV_blank>Time:<S2SV_blank>%s<S2SV_blank>" <S2SV_ModEnd> , ctime ( <S2SV_ModStart> ) ) ; <S2SV_ModEnd> pthread_mutex_lock ( & <S2SV_ModStart> ; usleep ( 300000 <S2SV_ModEnd> ) ; } |
6,562 | CWE-000 void zen_teardown ( zenroom_t * Z ) { notice ( Z -> lua , "Zenroom<S2SV_blank>teardown." ) ; if ( Z -> mem -> heap ) { if ( umm_integrity_check ( ) ) act ( Z -> lua , "HEAP<S2SV_blank>integrity<S2SV_blank>checks<S2SV_blank>passed." ) ; umm_info ( Z -> mem -> heap ) ; } <S2SV_StartBug> if ( Z -> lua ) { <S2SV_EndBug> lua_gc ( ( lua_State * ) Z -> lua , LUA_GCCOLLECT , 0 ) ; lua_gc ( ( lua_State * ) Z -> lua , LUA_GCCOLLECT , 0 ) ; lua_close ( ( lua_State * ) Z -> lua ) ; } <S2SV_StartBug> if ( Z -> mem -> heap ) <S2SV_EndBug> <S2SV_StartBug> system_free ( Z -> mem -> heap ) ; <S2SV_EndBug> <S2SV_StartBug> if ( Z -> mem ) system_free ( Z -> mem ) ; <S2SV_EndBug> <S2SV_StartBug> if ( Z ) system_free ( Z ) ; <S2SV_EndBug> } | <S2SV_ModStart> ) ; } void * mem = Z -> mem ; void * heap = Z -> mem -> heap ; <S2SV_ModStart> lua ) { act ( Z -> lua , "lua<S2SV_blank>gc<S2SV_blank>and<S2SV_blank>close..." ) ; <S2SV_ModStart> ) ; } act ( NULL , "zen<S2SV_blank>free" ) ; if ( <S2SV_ModEnd> heap ) system_free <S2SV_ModStart> ) system_free ( <S2SV_ModEnd> heap ) ; <S2SV_ModStart> ; if ( <S2SV_ModEnd> mem ) system_free <S2SV_ModStart> ) system_free ( <S2SV_ModEnd> mem ) ; <S2SV_ModStart> mem ) ; act ( NULL , "teardown<S2SV_blank>completed" <S2SV_ModEnd> ) ; } |
6,563 | CWE-000 static int pn544_suspend ( struct device * dev ) { struct i2c_client * client = to_i2c_client ( dev ) ; struct pn544_dev * pn544_dev = i2c_get_clientdata ( client ) ; printk ( "%s<S2SV_blank>pn544_dev->clk_gpio<S2SV_blank>=<S2SV_blank>%d\\n" , __func__ , gpio_get_value ( pn544_dev -> clk_gpio ) ) ; <S2SV_StartBug> if ( gpio_get_value ( pn544_dev -> clk_gpio ) ) { <S2SV_EndBug> __pm_wakeup_event ( & pn544_dev -> pn544_ws , msecs_to_jiffies ( CLOCK_HOLD_TIME ) ) ; pn544_enable_clk ( pn544_dev ) ; } return 0 ; } | <S2SV_ModStart> ; if ( pn544_dev -> nfc_ven_enabled && |
6,564 | CWE-000 static struct zip_archive * zip_get_archive_file ( FILE * fp ) { struct zip_archive * zp = zip_new_archive ( ) ; zp -> is_memory = 0 ; zp -> fp = fp ; zp -> hasspace = NULL ; zp -> vgetc = ( int ( * ) ( void * ) ) fgetc ; zp -> vgetw = ( int ( * ) ( void * ) ) fgetw ; zp -> vgetd = ( int ( * ) ( void * ) ) fgetd ; zp -> vputc = ( int ( * ) ( int , void * ) ) fputc ; zp -> vputw = ( void ( * ) ( int , void * ) ) fputw ; zp -> vputd = ( void ( * ) ( int , void * ) ) fputd ; zp -> vread = ( int ( * ) ( void * , size_t , size_t , void * ) ) fread ; zp -> vwrite = ( int ( * ) ( const void * , size_t , size_t , void * ) ) fwrite ; <S2SV_StartBug> zp -> vseek = ( int ( * ) ( void * , long int , long int ) ) fseek ; <S2SV_EndBug> zp -> vtell = ( int ( * ) ( void * ) ) ftell ; zp -> verror = ( int ( * ) ( void * ) ) ferror ; zp -> vclose = ( int ( * ) ( void * ) ) fclose ; return zp ; } | <S2SV_ModStart> long int , <S2SV_ModEnd> int ) ) |
6,565 | CWE-000 int __pmLogPutLabel ( __pmLogCtl * lcp , unsigned int type , unsigned int ident , int nsets , pmLabelSet * labelsets , const __pmTimeval * tp ) { int sts = 0 ; int i ; int j ; int len ; char * ptr ; int inst ; int nlabels ; int jsonlen ; int convert ; pmLabel label ; typedef struct { __pmLogHdr hdr ; __pmTimeval stamp ; int type ; int ident ; int nsets ; char data [ 0 ] ; } ext_t ; ext_t * out ; len = ( int ) sizeof ( ext_t ) ; for ( i = 0 ; i < nsets ; i ++ ) { <S2SV_StartBug> len += sizeof ( unsigned int ) + sizeof ( int ) + labelsets [ i ] . jsonlen <S2SV_EndBug> <S2SV_StartBug> + sizeof ( int ) + labelsets [ i ] . nlabels * sizeof ( pmLabel ) ; <S2SV_EndBug> } len += LENSIZE ; PM_FAULT_POINT ( "libpcp/" __FILE__ ":12" , PM_FAULT_ALLOC ) ; if ( ( out = ( ext_t * ) malloc ( len ) ) == NULL ) return - oserror ( ) ; out -> hdr . len = htonl ( len ) ; out -> hdr . type = htonl ( TYPE_LABEL ) ; out -> stamp . tv_sec = htonl ( tp -> tv_sec ) ; out -> stamp . tv_usec = htonl ( tp -> tv_usec ) ; out -> nsets = htonl ( nsets ) ; out -> type = htonl ( type ) ; out -> ident = htonl ( ident ) ; ptr = ( char * ) & out -> data ; for ( i = 0 ; i < nsets ; i ++ ) { inst = htonl ( labelsets [ i ] . inst ) ; memmove ( ( void * ) ptr , ( void * ) & inst , sizeof ( inst ) ) ; ptr += sizeof ( inst ) ; jsonlen = labelsets [ i ] . jsonlen ; convert = htonl ( jsonlen ) ; memmove ( ( void * ) ptr , ( void * ) & convert , sizeof ( jsonlen ) ) ; ptr += sizeof ( jsonlen ) ; memmove ( ( void * ) ptr , ( void * ) labelsets [ i ] . json , jsonlen ) ; ptr += jsonlen ; nlabels = labelsets [ i ] . nlabels ; convert = htonl ( nlabels ) ; memmove ( ( void * ) ptr , ( void * ) & convert , sizeof ( nlabels ) ) ; ptr += sizeof ( nlabels ) ; for ( j = 0 ; j < nlabels ; j ++ ) { label = labelsets [ i ] . labels [ j ] ; __htonpmLabel ( & label ) ; memmove ( ( void * ) ptr , ( void * ) & label , sizeof ( label ) ) ; ptr += sizeof ( label ) ; } } memmove ( ( void * ) ptr , & out -> hdr . len , sizeof ( out -> hdr . len ) ) ; if ( ( sts = __pmFwrite ( out , 1 , len , lcp -> l_mdfp ) ) != len ) { char errmsg [ PM_MAXERRMSGLEN ] ; pmprintf ( "__pmLogPutLabel(...,type=%d,indent=%d):<S2SV_blank>write<S2SV_blank>failed:<S2SV_blank>returned<S2SV_blank>%d<S2SV_blank>expecting<S2SV_blank>%d:<S2SV_blank>%s\\n" , type , ident , sts , len , osstrerror_r ( errmsg , sizeof ( errmsg ) ) ) ; pmflush ( ) ; free ( out ) ; return - oserror ( ) ; } free ( out ) ; return addlabel ( lcp , type , ident , nsets , labelsets , tp ) ; } | <S2SV_ModStart> unsigned int ) ; len += sizeof ( int ) + labelsets [ i ] . jsonlen ; len += sizeof ( int ) ; if ( labelsets [ i ] . nlabels > 0 ) len += ( <S2SV_ModEnd> labelsets [ i <S2SV_ModStart> sizeof ( pmLabel ) |
6,566 | CWE-000 END_LUA <S2SV_StartBug> BEGIN_LUA ( __tostring ) <S2SV_EndBug> { <S2SV_StartBug> lua_pushfstring ( L , "MININIM<S2SV_blank>LEVEL<S2SV_blank>%d<S2SV_blank>INTERFACE" , global_level . n ) ; <S2SV_EndBug> <S2SV_StartBug> return 1 ; <S2SV_EndBug> } | <S2SV_ModStart> END_LUA BEGIN_LUA ( __newindex ) { const char * key ; int type = lua_type <S2SV_ModEnd> ( L , <S2SV_ModStart> ( L , 2 ) ; switch ( type ) { case LUA_TSTRING : key = lua_tostring ( L , 2 ) ; if ( ! strcasecmp ( key , "number" ) ) { int n = lua_tonumber ( L , 3 ) ; ui_jump_to_level ( <S2SV_ModEnd> n ) ; <S2SV_ModStart> ) ; return 0 ; } else break ; default : break ; } return 0 <S2SV_ModEnd> ; } <S2SV_null> |
6,567 | CWE-000 long install_xhdi_driver ( void ) { # ifndef TOSONLY <S2SV_StartBug> return xhnewcookie ( xhdi_handler ) ; <S2SV_EndBug> # else long r = 0 ; cookie_fun XHDI = get_fun_ptr ( ) ; if ( XHDI ) { long tmp ; tmp = sys_XHDOSLimits ( XH_DL_SECSIZ , 0 ) ; ( void ) XHDI ( XHDOSLIMITS , XH_DL_SECSIZ , tmp ) ; tmp = sys_XHDOSLimits ( XH_DL_MINFAT , 0 ) ; ( void ) XHDI ( XHDOSLIMITS , XH_DL_MINFAT , tmp ) ; tmp = sys_XHDOSLimits ( XH_DL_MAXFAT , 0 ) ; ( void ) XHDI ( XHDOSLIMITS , XH_DL_MAXFAT , tmp ) ; tmp = sys_XHDOSLimits ( XH_DL_MINSPC , 0 ) ; ( void ) XHDI ( XHDOSLIMITS , XH_DL_MINSPC , tmp ) ; tmp = sys_XHDOSLimits ( XH_DL_MAXSPC , 0 ) ; ( void ) XHDI ( XHDOSLIMITS , XH_DL_MAXSPC , tmp ) ; tmp = sys_XHDOSLimits ( XH_DL_CLUSTS , 0 ) ; ( void ) XHDI ( XHDOSLIMITS , XH_DL_CLUSTS , tmp ) ; tmp = sys_XHDOSLimits ( XH_DL_MAXSEC , 0 ) ; ( void ) XHDI ( XHDOSLIMITS , XH_DL_MAXSEC , tmp ) ; tmp = sys_XHDOSLimits ( XH_DL_DRIVES , 0 ) ; ( void ) XHDI ( XHDOSLIMITS , XH_DL_DRIVES , tmp ) ; tmp = sys_XHDOSLimits ( XH_DL_CLSIZB , 0 ) ; ( void ) XHDI ( XHDOSLIMITS , XH_DL_CLSIZB , tmp ) ; tmp = sys_XHDOSLimits ( XH_DL_RDLEN , 0 ) ; ( void ) XHDI ( XHDOSLIMITS , XH_DL_RDLEN , tmp ) ; tmp = sys_XHDOSLimits ( XH_DL_CLUSTS12 , 0 ) ; ( void ) XHDI ( XHDOSLIMITS , XH_DL_CLUSTS12 , tmp ) ; tmp = sys_XHDOSLimits ( XH_DL_CLUSTS32 , 0 ) ; ( void ) XHDI ( XHDOSLIMITS , XH_DL_CLUSTS32 , tmp ) ; tmp = sys_XHDOSLimits ( XH_DL_BFLAGS , 0 ) ; ( void ) XHDI ( XHDOSLIMITS , XH_DL_BFLAGS , tmp ) ; next_handler = XHDI ; } set_cookie ( ) ; return r ; # endif } | <S2SV_ModStart> return xhnewcookie ( usbxhdi <S2SV_ModEnd> ) ; # |
6,568 | CWE-000 int input_gpio ( int gpio ) <S2SV_StartBug> { <S2SV_EndBug> if ( odroid_found ) { return ( * ( gpio_map_odroid [ ( gpio >= 100 ) ] + gpioToGPLEVReg ( gpio ) ) & ( 1 << gpioToShiftReg ( gpio ) ) ) ; } else { int offset , value , mask ; offset = PINLEVEL_OFFSET + ( gpio / 32 ) ; mask = ( 1 << gpio % 32 ) ; value = * ( gpio_map + offset ) & mask ; return value ; } } | <S2SV_ModStart> gpio ) { { char buf [ 256 ] ; sprintf ( buf , "input_gpio:<S2SV_blank>gpio=%i,<S2SV_blank>val=%i" , gpio ) ; PyErr_WarnEx ( NULL , buf , 1 ) ; } |
6,569 | CWE-000 static struct task_struct * pick_next_task_fair ( struct rq * rq , struct task_struct * prev ) { struct cfs_rq * cfs_rq = & rq -> cfs ; struct sched_entity * se ; struct task_struct * p ; int new_tasks ; again : # ifdef CONFIG_FAIR_GROUP_SCHED if ( ! cfs_rq -> nr_running ) goto idle ; if ( prev -> sched_class != & fair_sched_class ) goto simple ; do { struct sched_entity * curr = cfs_rq -> curr ; if ( curr ) { if ( curr -> on_rq ) update_curr ( cfs_rq ) ; else curr = NULL ; if ( unlikely ( check_cfs_rq_runtime ( cfs_rq ) ) ) goto simple ; } se = pick_next_entity ( cfs_rq , curr ) ; cfs_rq = group_cfs_rq ( se ) ; } while ( cfs_rq ) ; p = task_of ( se ) ; if ( prev != p ) { struct sched_entity * pse = & prev -> se ; while ( ! ( cfs_rq = is_same_group ( se , pse ) ) ) { int se_depth = se -> depth ; int pse_depth = pse -> depth ; if ( se_depth <= pse_depth ) { put_prev_entity ( cfs_rq_of ( pse ) , pse ) ; pse = parent_entity ( pse ) ; } if ( se_depth >= pse_depth ) { set_next_entity ( cfs_rq_of ( se ) , se ) ; se = parent_entity ( se ) ; } } put_prev_entity ( cfs_rq , pse ) ; set_next_entity ( cfs_rq , se ) ; } <S2SV_StartBug> if ( hrtick_enabled ( rq ) ) <S2SV_EndBug> hrtick_start_fair ( rq , p ) ; rq -> misfit_task = ! task_fits_max ( p , rq -> cpu ) ; return p ; simple : cfs_rq = & rq -> cfs ; # endif if ( ! cfs_rq -> nr_running ) goto idle ; put_prev_task ( rq , prev ) ; do { se = pick_next_entity ( cfs_rq , NULL ) ; set_next_entity ( cfs_rq , se ) ; cfs_rq = group_cfs_rq ( se ) ; } while ( cfs_rq ) ; <S2SV_StartBug> p = task_of ( se ) ; <S2SV_EndBug> if ( hrtick_enabled ( rq ) ) hrtick_start_fair ( rq , p ) ; rq -> misfit_task = ! task_fits_max ( p , rq -> cpu ) ; return p ; idle : rq -> misfit_task = 0 ; lockdep_unpin_lock ( & rq -> lock ) ; new_tasks = idle_balance ( rq ) ; lockdep_pin_lock ( & rq -> lock ) ; if ( new_tasks < 0 ) return RETRY_TASK ; if ( new_tasks > 0 ) goto again ; return NULL ; } | <S2SV_ModStart> ) ; } goto done <S2SV_ModEnd> ; simple : <S2SV_ModStart> se ) ; done : __maybe_unused # ifdef CONFIG_SMP list_move ( & p -> se . group_node , & rq -> cfs_tasks ) ; # endif |
6,570 | CWE-000 int main ( int argc , char * argv [ ] ) { struct aub_file * file ; int c , i ; bool help = false , pager = true ; const struct option aubinator_opts [ ] = { { "help" , no_argument , ( int * ) & help , true } , { "no-pager" , no_argument , ( int * ) & pager , false } , { "no-offsets" , no_argument , ( int * ) & option_print_offsets , false } , { "gen" , required_argument , NULL , 'g' } , { "headers" , no_argument , ( int * ) & option_full_decode , false } , { "color" , required_argument , NULL , 'c' } , { "xml" , required_argument , NULL , 'x' } , { "max-vbo-lines" , required_argument , NULL , 'v' } , { NULL , 0 , NULL , 0 } } ; outfile = stdout ; i = 0 ; while ( ( c = getopt_long ( argc , argv , "" , aubinator_opts , & i ) ) != - 1 ) { switch ( c ) { case 'g' : { const int id = gen_device_name_to_pci_device_id ( optarg ) ; if ( id < 0 ) { fprintf ( stderr , "can\'t<S2SV_blank>parse<S2SV_blank>gen:<S2SV_blank>\'%s\',<S2SV_blank>expected<S2SV_blank>ivb,<S2SV_blank>byt,<S2SV_blank>hsw,<S2SV_blank>" "bdw,<S2SV_blank>chv,<S2SV_blank>skl,<S2SV_blank>kbl<S2SV_blank>or<S2SV_blank>bxt\\n" , optarg ) ; exit ( EXIT_FAILURE ) ; } else { pci_id = id ; } break ; } case 'c' : if ( optarg == NULL || strcmp ( optarg , "always" ) == 0 ) option_color = COLOR_ALWAYS ; else if ( strcmp ( optarg , "never" ) == 0 ) option_color = COLOR_NEVER ; else if ( strcmp ( optarg , "auto" ) == 0 ) option_color = COLOR_AUTO ; else { fprintf ( stderr , "invalid<S2SV_blank>value<S2SV_blank>for<S2SV_blank>--color:<S2SV_blank>%s" , optarg ) ; exit ( EXIT_FAILURE ) ; } break ; case 'x' : xml_path = strdup ( optarg ) ; break ; case 'v' : max_vbo_lines = atoi ( optarg ) ; break ; default : break ; } } if ( optind < argc ) input_file = argv [ optind ] ; if ( help || ! input_file ) { print_help ( argv [ 0 ] , stderr ) ; exit ( 0 ) ; } if ( option_color == COLOR_AUTO ) option_color = isatty ( 1 ) ? COLOR_ALWAYS : COLOR_NEVER ; if ( isatty ( 1 ) && pager ) setup_pager ( ) ; <S2SV_StartBug> mem_fd = memfd_create ( "phys<S2SV_blank>memory" , 0 ) ; <S2SV_EndBug> list_inithead ( & maps ) ; file = aub_file_open ( input_file ) ; while ( aub_file_more_stuff ( file ) && aub_file_decode_batch ( file ) == AUB_ITEM_DECODE_OK ) ; fflush ( stdout ) ; close ( 1 ) ; free ( xml_path ) ; wait ( NULL ) ; return EXIT_SUCCESS ; } | <S2SV_ModStart> ; mem_fd = local_memfd_create <S2SV_ModEnd> ( "phys<S2SV_blank>memory" , |
6,571 | CWE-000 int ext2x_get ( const opal_process_name_t * proc , const char * key , opal_list_t * info , opal_value_t * * val ) { pmix_status_t rc ; pmix_proc_t p ; char * nsptr ; pmix_info_t * pinfo = NULL ; size_t sz = 0 , n ; opal_value_t * ival ; pmix_value_t * pval = NULL ; int ret ; opal_output_verbose ( 1 , opal_pmix_base_framework . framework_output , "%s<S2SV_blank>ext2x:client<S2SV_blank>get<S2SV_blank>on<S2SV_blank>proc<S2SV_blank>%s<S2SV_blank>key<S2SV_blank>%s" , OPAL_NAME_PRINT ( OPAL_PROC_MY_NAME ) , ( NULL == proc ) ? "NULL" : OPAL_NAME_PRINT ( * proc ) , key ) ; OPAL_PMIX_ACQUIRE_THREAD ( & opal_pmix_base . lock ) ; if ( 0 >= opal_pmix_base . initialized ) { OPAL_PMIX_RELEASE_THREAD ( & opal_pmix_base . lock ) ; return OPAL_ERR_NOT_INITIALIZED ; } <S2SV_StartBug> if ( NULL == proc ) { <S2SV_EndBug> if ( 0 == strcmp ( key , OPAL_PMIX_JOBID ) ) { ( * val ) = OBJ_NEW ( opal_value_t ) ; ( * val ) -> key = strdup ( key ) ; ( * val ) -> type = OPAL_UINT32 ; ( * val ) -> data . uint32 = OPAL_PROC_MY_NAME . jobid ; OPAL_PMIX_RELEASE_THREAD ( & opal_pmix_base . lock ) ; return OPAL_SUCCESS ; } if ( 0 == strcmp ( key , OPAL_PMIX_RANK ) ) { ( * val ) = OBJ_NEW ( opal_value_t ) ; ( * val ) -> key = strdup ( key ) ; ( * val ) -> type = OPAL_INT ; ( * val ) -> data . integer = ext2x_convert_rank ( my_proc . rank ) ; OPAL_PMIX_RELEASE_THREAD ( & opal_pmix_base . lock ) ; return OPAL_SUCCESS ; } } * val = NULL ; if ( NULL == proc ) { ( void ) strncpy ( p . nspace , my_proc . nspace , PMIX_MAX_NSLEN ) ; p . rank = ext2x_convert_rank ( PMIX_RANK_WILDCARD ) ; } else { if ( NULL == ( nsptr = ext2x_convert_jobid ( proc -> jobid ) ) ) { OPAL_PMIX_RELEASE_THREAD ( & opal_pmix_base . lock ) ; return OPAL_ERR_NOT_FOUND ; } ( void ) strncpy ( p . nspace , nsptr , PMIX_MAX_NSLEN ) ; p . rank = ext2x_convert_opalrank ( proc -> vpid ) ; } OPAL_PMIX_RELEASE_THREAD ( & opal_pmix_base . lock ) ; if ( NULL != info && 0 < ( sz = opal_list_get_size ( info ) ) ) { PMIX_INFO_CREATE ( pinfo , sz ) ; n = 0 ; OPAL_LIST_FOREACH ( ival , info , opal_value_t ) { ( void ) strncpy ( pinfo [ n ] . key , ival -> key , PMIX_MAX_KEYLEN ) ; ext2x_value_load ( & pinfo [ n ] . value , ival ) ; ++ n ; } } rc = PMIx_Get ( & p , key , pinfo , sz , & pval ) ; if ( PMIX_SUCCESS == rc ) { ival = OBJ_NEW ( opal_value_t ) ; <S2SV_StartBug> ival -> key = strdup ( key ) ; <S2SV_EndBug> if ( OPAL_SUCCESS != ( ret = ext2x_value_unload ( ival , pval ) ) ) { rc = ext2x_convert_opalrc ( ret ) ; } else { * val = ival ; } PMIX_VALUE_FREE ( pval , 1 ) ; } PMIX_INFO_FREE ( pinfo , sz ) ; return ext2x_convert_rc ( rc ) ; } | <S2SV_ModStart> NULL == proc && NULL != key <S2SV_ModStart> opal_value_t ) ; if ( NULL != key ) { <S2SV_ModStart> key ) ; } |
6,572 | CWE-000 void loop_keylist ( SeqNodeDataPtr ndp , FILE * fp , int human_readable ) { char * start = SeqLoops_getLoopAttribute ( ndp -> data , "START" ) , * end = SeqLoops_getLoopAttribute ( ndp -> data , "END" ) , * step = SeqLoops_getLoopAttribute ( ndp -> data , "STEP" ) , * set = SeqLoops_getLoopAttribute ( ndp -> data , "SET" ) , * expression = SeqLoops_getLoopAttribute ( ndp -> data , "EXPRESSION" ) ; <S2SV_StartBug> if ( human_readable ) { <S2SV_EndBug> fprintf ( fp , "%s.loop\\n" , indent ) ; if ( expression == NULL ) { fprintf ( fp , "%s.start<S2SV_blank>=<S2SV_blank>%s\\n" , doubleIndent , start ) ; fprintf ( fp , "%s.end<S2SV_blank><S2SV_blank><S2SV_blank>=<S2SV_blank>%s\\n" , doubleIndent , end ) ; fprintf ( fp , "%s.step<S2SV_blank><S2SV_blank>=<S2SV_blank>%s\\n" , doubleIndent , step ) ; fprintf ( fp , "%s.set<S2SV_blank><S2SV_blank><S2SV_blank>=<S2SV_blank>%s\\n" , doubleIndent , set ) ; } else { fprintf ( fp , "%s.expression<S2SV_blank>=<S2SV_blank>%s\\n" , doubleIndent , expression ) ; } } else { fprintf ( fp , "{loop<S2SV_blank>{" ) ; if ( expression == NULL ) { fprintf ( fp , "{start<S2SV_blank>%s}<S2SV_blank>" , start ) ; fprintf ( fp , "{end<S2SV_blank>%s}<S2SV_blank>" , end ) ; fprintf ( fp , "{step<S2SV_blank>%s}<S2SV_blank>" , step ) ; fprintf ( fp , "{set<S2SV_blank>%s}" , set ) ; } else { fprintf ( fp , "{expression<S2SV_blank>%s}" , expression ) ; } fprintf ( fp , "}}" ) ; } free ( start ) ; free ( end ) ; free ( step ) ; free ( set ) ; free ( expression ) ; } | <S2SV_ModStart> ; if ( expression == NULL ) { if ( start == NULL ) start = DEFAULT_LOOP_START_STR ; if ( end == NULL ) end = DEFAULT_LOOP_END_STR ; if ( step == NULL ) step = DEFAULT_LOOP_STEP_STR ; if ( set == NULL ) set = DEFAULT_LOOP_SET_STR ; } if ( |
6,573 | CWE-000 void cpu_step ( struct cpu * cpu , struct kprog * prog ) { union opcode op = * ( union opcode * ) & prog -> program [ cpu -> pc ] ; switch ( op . I ) { case 0x00 : cpu -> pc = prog -> prog_size ; break ; case 0x12 : cpu -> regs [ op . r . A ] = cpu -> regs [ op . r . B ] ^ cpu -> regs [ op . r . C ] ; break ; case 0x21 : cpu -> regs [ op . i . A ] = cpu -> regs [ op . i . B ] + op . i . Cx ; break ; case 0x22 : cpu -> regs [ op . i . A ] = op . i . Cx ; break ; case 0x29 : printf ( "%d\\n" , cpu -> regs [ op . i . A ] ) ; break ; case 0x2A : printf ( "%d\\n" , op . i . Cx ) ; break ; case 0x2B : if ( cpu -> regs [ op . i . A ] == cpu -> regs [ op . i . B ] ) { cpu -> pc = op . i . Cx ; } break ; case 0x2C : if ( cpu -> regs [ op . i . A ] != cpu -> regs [ op . i . B ] ) { <S2SV_StartBug> cpu -> pc = op . i . Cx ; <S2SV_EndBug> } break ; case 0x2D : cpu -> pc = op . b . Ax ; break ; default : err ( "unimplemented<S2SV_blank>opcode<S2SV_blank>0x%X" , op . I ) ; break ; } ; cpu -> pc += 4 ; } | <S2SV_ModStart> i . Cx - sizeof ( union opcode ) |
6,574 | CWE-000 int main ( int argc , char const * argv [ ] ) { <S2SV_StartBug> printf ( "Hello<S2SV_blank>wsx\\n" ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> ] ) { Stack S ; if ( ! ( S = CreateStack ( ) ) ) printf ( "Create<S2SV_blank>stack<S2SV_blank>failed.\\n" ) ; else printf ( "Create<S2SV_blank>stack<S2SV_blank>success\\n" ) ; |
6,575 | CWE-000 M_bool M_table_merge ( M_table_t * * dest , M_table_t * src ) { const char * colname ; const char * val ; size_t numcols ; size_t numcols_dest ; size_t numrows ; size_t rowidx ; size_t i ; size_t j ; <S2SV_StartBug> if ( dest == NULL ) { <S2SV_EndBug> * dest = src ; return M_TRUE ; } if ( src == NULL ) return M_TRUE ; numcols_dest = M_table_column_count ( * dest ) ; numrows = M_table_row_count ( src ) ; numcols = M_table_column_count ( src ) ; for ( i = 0 ; i < numcols_dest ; i ++ ) { if ( M_str_isempty ( M_table_column_name ( * dest , i ) ) ) { return M_FALSE ; } } for ( i = 0 ; i < numcols ; i ++ ) { if ( M_str_isempty ( M_table_column_name ( src , i ) ) ) { return M_FALSE ; } } for ( i = 0 ; i < numrows ; i ++ ) { rowidx = M_table_row_insert ( * dest ) ; for ( j = 0 ; j < numcols ; j ++ ) { colname = M_table_column_name ( src , j ) ; val = M_table_cell_at ( src , i , j ) ; M_table_cell_set ( * dest , rowidx , colname , val , M_TABLE_INSERT_COLADD ) ; } } M_table_destroy ( src ) ; return M_TRUE ; } | <S2SV_ModStart> ; if ( * |
6,576 | CWE-000 int main ( int argc , char * argv [ ] ) { int workers [ ] = { 1 , 2 , 4 , 8 , 16 , 24 } ; <S2SV_StartBug> int size [ ] = { 1000 , 10000 , 100000 } <S2SV_EndBug> int i , j ; for ( i = 0 ; i < sizeof ( workers ) / sizeof ( workers [ 0 ] ) ; i ++ ) { for ( j = 0 ; j < sizeof ( size ) / sizeof ( size [ 0 ] ) ; j ++ ) { printf ( "Median<S2SV_blank>time<S2SV_blank>for<S2SV_blank>matrix<S2SV_blank>of<S2SV_blank>size:<S2SV_blank>%d,<S2SV_blank>and<S2SV_blank>with<S2SV_blank>%d<S2SV_blank>workers<S2SV_blank>is:<S2SV_blank>" , size [ j ] , workers [ i ] , medianTime ( workers [ i ] , size [ j ] ) ) ; } } } | <S2SV_ModStart> , 100000 } ; |
6,577 | CWE-000 static int diag_cmd_update_event_mask ( unsigned char * src_buf , int src_len , unsigned char * dest_buf , int dest_len , struct diag_md_session_t * info ) { int i ; int write_len = 0 ; int mask_len = 0 ; int header_len = sizeof ( struct diag_event_mask_config_t ) ; struct diag_event_mask_config_t rsp ; struct diag_event_mask_config_t * req ; struct diag_mask_info * mask_info = NULL ; mask_info = ( ! info ) ? & event_mask : info -> event_mask ; if ( ! src_buf || ! dest_buf || src_len <= 0 || dest_len <= 0 || ! mask_info ) { pr_err ( "diag:<S2SV_blank>Invalid<S2SV_blank>input<S2SV_blank>in<S2SV_blank>%s,<S2SV_blank>src_buf:<S2SV_blank>%pK,<S2SV_blank>src_len:<S2SV_blank>%d,<S2SV_blank>dest_buf:<S2SV_blank>%pK,<S2SV_blank>dest_len:<S2SV_blank>%d,<S2SV_blank>mask_info:<S2SV_blank>%pK\\n" , __func__ , src_buf , src_len , dest_buf , dest_len , mask_info ) ; return - EINVAL ; } req = ( struct diag_event_mask_config_t * ) src_buf ; mask_len = EVENT_COUNT_TO_BYTES ( req -> num_bits ) ; if ( mask_len <= 0 || mask_len > event_mask . mask_len ) { pr_err ( "diag:<S2SV_blank>In<S2SV_blank>%s,<S2SV_blank>invalid<S2SV_blank>event<S2SV_blank>mask<S2SV_blank>len:<S2SV_blank>%d\\n" , __func__ , mask_len ) ; return - EIO ; } mutex_lock ( & mask_info -> lock ) ; memcpy ( mask_info -> ptr , src_buf + header_len , mask_len ) ; mask_info -> status = DIAG_CTRL_MASK_VALID ; mutex_unlock ( & mask_info -> lock ) ; if ( diag_check_update ( APPS_DATA ) ) diag_update_userspace_clients ( EVENT_MASKS_TYPE ) ; rsp . cmd_code = DIAG_CMD_SET_EVENT_MASK ; rsp . status = EVENT_STATUS_SUCCESS ; rsp . padding = 0 ; rsp . num_bits = driver -> last_event_id + 1 ; memcpy ( dest_buf , & rsp , header_len ) ; write_len += header_len ; memcpy ( dest_buf + write_len , mask_info -> ptr , mask_len ) ; write_len += mask_len ; for ( i = 0 ; i < NUM_PERIPHERALS ; i ++ ) { if ( ! diag_check_update ( i ) ) continue ; <S2SV_StartBug> diag_send_event_mask_update ( i ) ; <S2SV_EndBug> } return write_len ; } | <S2SV_ModStart> ) continue ; mutex_lock ( & driver -> md_session_lock ) ; <S2SV_ModStart> diag_send_event_mask_update ( i ) ; mutex_unlock ( & driver -> md_session_lock |
6,578 | CWE-000 static void rtl_hw_start_8106 ( struct rtl8169_private * tp ) <S2SV_StartBug> { <S2SV_EndBug> RTL_W32 ( tp , FuncEvent , RTL_R32 ( tp , FuncEvent ) | 0x002800 ) ; RTL_W32 ( tp , MISC , ( RTL_R32 ( tp , MISC ) | DISABLE_LAN_EN ) & ~ EARLY_TALLY_EN ) ; RTL_W8 ( tp , MCU , RTL_R8 ( tp , MCU ) | EN_NDP | EN_OOB_RESET ) ; RTL_W8 ( tp , DLLPR , RTL_R8 ( tp , DLLPR ) & ~ PFM_EN ) ; rtl_pcie_state_l2l3_enable ( tp , false ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> tp ) { rtl_hw_aspm_clkreq_enable ( tp , false ) ; <S2SV_ModStart> false ) ; rtl_hw_aspm_clkreq_enable ( tp , true ) ; |
6,579 | CWE-000 <S2SV_StartBug> void smartconfig_othenState_enablekey ( void ) { <S2SV_EndBug> wm8960_state = 0 ; } | <S2SV_ModStart> void ) { if ( wm8960_state == 1 ) { smartconfig_enable_i2s_miss_enable_othenkey ( ) ; } |
6,580 | CWE-000 i40e_status i40e_read_nvm_word ( struct i40e_hw * hw , u16 offset , u16 * data ) { <S2SV_StartBug> enum i40e_status_code ret_code = 0 ; <S2SV_EndBug> ret_code = i40e_acquire_nvm ( hw , I40E_RESOURCE_READ ) ; <S2SV_StartBug> if ( ! ret_code ) { <S2SV_EndBug> if ( hw -> flags & I40E_HW_FLAG_AQ_SRCTL_ACCESS_ENABLE ) { ret_code = i40e_read_nvm_word_aq ( hw , offset , data ) ; <S2SV_StartBug> } else { <S2SV_EndBug> ret_code = i40e_read_nvm_word_srctl ( hw , offset , data ) ; } i40e_release_nvm ( hw ) ; <S2SV_StartBug> } <S2SV_EndBug> return ret_code ; } | <S2SV_ModStart> data ) { i40e_status <S2SV_ModEnd> ret_code = 0 <S2SV_ModStart> ; if ( ret_code ) return ret_code ; ret_code = __i40e_read_nvm_word <S2SV_ModEnd> ( hw , <S2SV_ModStart> data ) ; <S2SV_ModEnd> i40e_release_nvm ( hw <S2SV_ModStart> hw ) ; <S2SV_ModEnd> return ret_code ; |
6,581 | CWE-000 static char * * split_line ( const SERVER_REC * server , const char * line , const char * target , int len ) { const char * start = settings_get_str ( "split_line_start" ) ; const char * end = settings_get_str ( "split_line_end" ) ; gboolean onspace = settings_get_bool ( "split_line_on_space" ) ; char * recoded_start = recode_out ( server , start , target ) ; char * recoded_end = recode_out ( server , end , target ) ; char * * lines ; int i ; len -= strlen ( recoded_start ) + strlen ( recoded_end ) ; <S2SV_StartBug> if ( len <= 0 ) { <S2SV_EndBug> g_free ( recoded_start ) ; g_free ( recoded_end ) ; <S2SV_StartBug> return NULL ; <S2SV_EndBug> } lines = recode_split ( server , line , target , len , onspace ) ; for ( i = 0 ; lines [ i ] != NULL ; i ++ ) { if ( i != 0 && * start != '\\0' ) { char * tmp = lines [ i ] ; lines [ i ] = g_strconcat ( start , tmp , NULL ) ; g_free ( tmp ) ; } if ( lines [ i + 1 ] != NULL && * end != '\\0' ) { char * tmp = lines [ i ] ; if ( lines [ i + 2 ] == NULL ) { char * recoded_l = recode_out ( server , lines [ i + 1 ] , target ) ; if ( strlen ( recoded_l ) <= strlen ( recoded_end ) ) { lines [ i ] = g_strconcat ( tmp , lines [ i + 1 ] , NULL ) ; g_free_and_null ( lines [ i + 1 ] ) ; lines = g_renew ( char * , lines , i + 2 ) ; g_free ( recoded_l ) ; g_free ( tmp ) ; break ; } g_free ( recoded_l ) ; } lines [ i ] = g_strconcat ( tmp , end , NULL ) ; g_free ( tmp ) ; } } g_free ( recoded_start ) ; g_free ( recoded_end ) ; return lines ; } | <S2SV_ModStart> recoded_end ) ; g_warn_if_fail ( len > 0 ) ; <S2SV_ModStart> recoded_end ) ; lines = g_new ( char * , 1 ) ; lines [ 0 ] = NULL ; return lines <S2SV_ModEnd> ; } lines |
6,582 | CWE-000 void crt_plugin_pmix_fini ( void ) { <S2SV_StartBug> if ( ! crt_is_service ( ) ) <S2SV_EndBug> return ; PMIx_Deregister_event_handler ( crt_plugin_gdata . cpg_pmix_errhdlr_ref , crt_plugin_pmix_errhdlr_dereg_cb , NULL ) ; } | <S2SV_ModStart> ( ! crt_is_service ( ) || crt_is_singleton |
6,583 | CWE-000 static void * naive_thread ( void * arg ) { Args_t * Args = ( Args_t * ) arg ; int block_i = Args -> block_i , block_j = Args -> block_j ; matrix_t * C = Args -> C ; sub_matrix_t subMat ; DECLARE_MULTIPLY ( * Args ) ; allocate_sub ( & subMat ) ; subMat . row = subA [ block_i ] [ block_j ] . row ; subMat . col = subA [ block_i ] [ block_j ] . col ; subMat . start_pos_i = subA [ block_i ] [ block_j ] . start_pos_i ; subMat . start_pos_j = subA [ block_i ] [ block_j ] . start_pos_j ; clear_sub ( & subMat ) ; for ( int i = 0 ; i < 2 ; i ++ ) { <S2SV_StartBug> multiply_opt ( & subMat , & subA [ block_i ] [ i ] , & subB [ i ] [ block_j ] ) ; <S2SV_EndBug> } for ( int i = 0 ; i < subMat . row ; i ++ ) { for ( int j = 0 ; j < subMat . col ; j ++ ) C -> data [ subMat . start_pos_i + i ] [ subMat . start_pos_j + j ] = subMat . data [ i ] [ j ] ; } free_memory_sub ( & subMat ) ; } | <S2SV_ModStart> ++ ) { multiply <S2SV_ModEnd> ( & subMat |
6,584 | CWE-000 static int proceed ( tpl_query * q ) { do { TRACE ( "proceed" ) ; if ( ! q -> curr_choice ) break ; <S2SV_StartBug> choice * c = & q -> choices [ q -> curr_choice ] ; <S2SV_EndBug> q -> curr_choice = c -> previous ; q -> curr_context = c -> curr_frame ; q -> curr_match = c -> curr_match ; q -> idx_iter = c -> idx_iter ; q -> curr_db = c -> curr_db ; q -> curr_term = term_next ( c -> curr_term ) ; q -> curr_frame = c -> curr_frame ; q -> frame_size = c -> frame_size ; if ( c -> nofollow ) q -> curr_term = NULL ; } while ( q -> curr_term == NULL ) ; if ( q -> trace && q -> curr_term ) trace ( q , 0 , 0 ) ; return q -> curr_term != NULL ; } | <S2SV_ModStart> -> curr_choice ] ; q -> mask = c -> mask |
6,585 | CWE-000 void masterdump ( ) { int i ; printf ( "==MASTER<S2SV_blank>DUMP==\\n" ) ; printf ( "Received<S2SV_blank>data:<S2SV_blank>slave:<S2SV_blank>%d,<S2SV_blank>addr:<S2SV_blank>%d,<S2SV_blank>count:<S2SV_blank>%d,<S2SV_blank>type:<S2SV_blank>%d\\n" , mstatus . data . address , mstatus . data . index , mstatus . data . count , mstatus . data . type ) ; <S2SV_StartBug> printf ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>values:" ) ; <S2SV_EndBug> switch ( mstatus . data . type ) { case MODBUS_HOLDING_REGISTER : case MODBUS_INPUT_REGISTER : for ( i = 0 ; i < mstatus . data . count ; i ++ ) printf ( "<S2SV_blank>%d" , mstatus . data . regs [ i ] ) ; break ; case MODBUS_COIL : case MODBUS_DISCRETE_INPUT : for ( i = 0 ; i < mstatus . data . count ; i ++ ) <S2SV_StartBug> printf ( "<S2SV_blank>%d" , mstatus . data . coils [ i ] ) ; <S2SV_EndBug> break ; } printf ( "\\n" ) ; printf ( "Request:" ) ; for ( i = 0 ; i < mstatus . request . length ; i ++ ) printf ( "<S2SV_blank>%d" , mstatus . request . frame [ i ] ) ; printf ( "\\n" ) ; printf ( "Response:" ) ; for ( i = 0 ; i < mstatus . response . length ; i ++ ) printf ( "<S2SV_blank>%d" , mstatus . response . frame [ i ] ) ; printf ( "\\n" ) ; printf ( "Exit<S2SV_blank>code:<S2SV_blank>%d\\n\\n" , mec ) ; } | <S2SV_ModStart> ; printf ( "\\t\\tvalues:" <S2SV_ModEnd> ) ; switch <S2SV_ModStart> ( "<S2SV_blank>%d" , modbusMaskRead ( <S2SV_ModStart> data . coils , mstatus . data . length , i ) <S2SV_ModEnd> ) ; break |
6,586 | CWE-000 static void hfi_process_session_ftb_done ( msm_vidc_callback callback , u32 device_id , void * msg_hdr ) { struct msm_vidc_cb_data_done data_done ; struct hfi_msg_session_fill_buffer_done_compressed_packet * pack = ( struct hfi_msg_session_fill_buffer_done_compressed_packet * ) msg_hdr ; u32 is_decoder = ( ( struct hal_session * ) pack -> session_id ) -> is_decoder ; struct hal_session * session ; if ( ! msg_hdr ) { dprintk ( VIDC_ERR , "Invalid<S2SV_blank>Params" ) ; return ; } session = ( struct hal_session * ) ( ( struct hal_session * ) pack -> session_id ) -> session_id ; dprintk ( VIDC_DBG , "RECEIVED:<S2SV_blank>SESSION_FTB_DONE[%u]\\n" , pack -> session_id ) ; memset ( & data_done , 0 , sizeof ( struct msm_vidc_cb_data_done ) ) ; if ( is_decoder == 0 ) { struct hfi_msg_session_fill_buffer_done_compressed_packet * pkt = ( struct hfi_msg_session_fill_buffer_done_compressed_packet * ) msg_hdr ; if ( sizeof ( struct hfi_msg_session_fill_buffer_done_compressed_packet ) > pkt -> size ) { dprintk ( VIDC_ERR , "hal_process_session_ftb_done:<S2SV_blank>bad_pkt_size" ) ; return ; } else if ( pkt -> error_type != HFI_ERR_NONE ) { dprintk ( VIDC_ERR , "got<S2SV_blank>buffer<S2SV_blank>back<S2SV_blank>with<S2SV_blank>error<S2SV_blank>%x" , pkt -> error_type ) ; } data_done . device_id = device_id ; data_done . session_id = ( u32 ) session ; data_done . status = hfi_map_err_status ( ( u32 ) pkt -> error_type ) ; data_done . size = sizeof ( struct msm_vidc_cb_data_done ) ; data_done . clnt_data = ( void * ) pkt -> input_tag ; data_done . output_done . timestamp_hi = pkt -> time_stamp_hi ; data_done . output_done . timestamp_lo = pkt -> time_stamp_lo ; data_done . output_done . flags1 = pkt -> flags ; data_done . output_done . mark_target = pkt -> mark_target ; data_done . output_done . mark_data = pkt -> mark_data ; data_done . output_done . stats = pkt -> stats ; data_done . output_done . offset1 = pkt -> offset ; data_done . output_done . alloc_len1 = pkt -> alloc_len ; data_done . output_done . filled_len1 = pkt -> filled_len ; data_done . output_done . picture_type = pkt -> picture_type ; data_done . output_done . packet_buffer1 = pkt -> packet_buffer ; data_done . output_done . extra_data_buffer = pkt -> extra_data_buffer ; data_done . output_done . buffer_type = HAL_BUFFER_OUTPUT ; <S2SV_StartBug> dprintk ( VIDC_DBG , "FBD:<S2SV_blank>Received<S2SV_blank>buf:<S2SV_blank>%p,<S2SV_blank>of<S2SV_blank>len:<S2SV_blank>%d\\n" , <S2SV_EndBug> pkt -> packet_buffer , pkt -> filled_len ) ; } else if ( is_decoder == 1 ) { struct hfi_msg_session_fbd_uncompressed_plane0_packet * pkt = ( struct hfi_msg_session_fbd_uncompressed_plane0_packet * ) msg_hdr ; if ( sizeof ( struct hfi_msg_session_fbd_uncompressed_plane0_packet ) > pkt -> size ) { dprintk ( VIDC_ERR , "hal_process_session_ftb_done:" "bad_pkt_size" ) ; return ; } data_done . device_id = device_id ; data_done . session_id = ( u32 ) session ; data_done . status = hfi_map_err_status ( ( u32 ) pkt -> error_type ) ; data_done . size = sizeof ( struct msm_vidc_cb_data_done ) ; data_done . clnt_data = ( void * ) pkt -> input_tag ; data_done . output_done . stream_id = pkt -> stream_id ; data_done . output_done . view_id = pkt -> view_id ; data_done . output_done . timestamp_hi = pkt -> time_stamp_hi ; data_done . output_done . timestamp_lo = pkt -> time_stamp_lo ; data_done . output_done . flags1 = pkt -> flags ; data_done . output_done . mark_target = pkt -> mark_target ; data_done . output_done . mark_data = pkt -> mark_data ; data_done . output_done . stats = pkt -> stats ; data_done . output_done . alloc_len1 = pkt -> alloc_len ; data_done . output_done . filled_len1 = pkt -> filled_len ; data_done . output_done . offset1 = pkt -> offset ; data_done . output_done . frame_width = pkt -> frame_width ; data_done . output_done . frame_height = pkt -> frame_height ; data_done . output_done . start_x_coord = pkt -> start_x_coord ; data_done . output_done . start_y_coord = pkt -> start_y_coord ; data_done . output_done . input_tag1 = pkt -> input_tag ; data_done . output_done . picture_type = pkt -> picture_type ; data_done . output_done . packet_buffer1 = pkt -> packet_buffer ; data_done . output_done . extra_data_buffer = pkt -> extra_data_buffer ; if ( pkt -> stream_id == 0 ) data_done . output_done . buffer_type = HAL_BUFFER_OUTPUT ; else if ( pkt -> stream_id == 1 ) data_done . output_done . buffer_type = HAL_BUFFER_OUTPUT2 ; } callback ( SESSION_FTB_DONE , & data_done ) ; } | <S2SV_ModStart> ( VIDC_DBG , "FBD:<S2SV_blank>Received<S2SV_blank>buf:<S2SV_blank>%pK,<S2SV_blank>of<S2SV_blank>len:<S2SV_blank>%d\\n" <S2SV_ModEnd> , pkt -> |
6,587 | CWE-000 int do_huge_pmd_wp_page ( struct fault_env * fe , pmd_t orig_pmd ) { struct vm_area_struct * vma = fe -> vma ; struct page * page = NULL , * new_page ; struct mem_cgroup * memcg ; unsigned long haddr = fe -> address & HPAGE_PMD_MASK ; unsigned long mmun_start ; unsigned long mmun_end ; gfp_t huge_gfp ; int ret = 0 ; fe -> ptl = pmd_lockptr ( vma -> vm_mm , fe -> pmd ) ; VM_BUG_ON_VMA ( ! vma -> anon_vma , vma ) ; if ( is_huge_zero_pmd ( orig_pmd ) ) goto alloc ; spin_lock ( fe -> ptl ) ; if ( unlikely ( ! pmd_same ( * fe -> pmd , orig_pmd ) ) ) goto out_unlock ; page = pmd_page ( orig_pmd ) ; VM_BUG_ON_PAGE ( ! PageCompound ( page ) || ! PageHead ( page ) , page ) ; if ( page_trans_huge_mapcount ( page , NULL ) == 1 ) { pmd_t entry ; entry = pmd_mkyoung ( orig_pmd ) ; entry = maybe_pmd_mkwrite ( pmd_mkdirty ( entry ) , vma ) ; if ( pmdp_set_access_flags ( vma , haddr , fe -> pmd , entry , 1 ) ) update_mmu_cache_pmd ( vma , fe -> address , fe -> pmd ) ; ret |= VM_FAULT_WRITE ; goto out_unlock ; } get_page ( page ) ; spin_unlock ( fe -> ptl ) ; alloc : if ( transparent_hugepage_enabled ( vma ) && ! transparent_hugepage_debug_cow ( ) ) { huge_gfp = alloc_hugepage_direct_gfpmask ( vma ) ; new_page = alloc_hugepage_vma ( huge_gfp , vma , haddr , HPAGE_PMD_ORDER ) ; } else new_page = NULL ; if ( likely ( new_page ) ) { prep_transhuge_page ( new_page ) ; } else { if ( ! page ) { split_huge_pmd ( vma , fe -> pmd , fe -> address ) ; ret |= VM_FAULT_FALLBACK ; } else { ret = do_huge_pmd_wp_page_fallback ( fe , orig_pmd , page ) ; if ( ret & VM_FAULT_OOM ) { split_huge_pmd ( vma , fe -> pmd , fe -> address ) ; ret |= VM_FAULT_FALLBACK ; } put_page ( page ) ; } count_vm_event ( THP_FAULT_FALLBACK ) ; goto out ; } if ( unlikely ( mem_cgroup_try_charge ( new_page , vma -> vm_mm , <S2SV_StartBug> huge_gfp , & memcg , true ) ) ) { <S2SV_EndBug> put_page ( new_page ) ; split_huge_pmd ( vma , fe -> pmd , fe -> address ) ; if ( page ) put_page ( page ) ; ret |= VM_FAULT_FALLBACK ; count_vm_event ( THP_FAULT_FALLBACK ) ; goto out ; } count_vm_event ( THP_FAULT_ALLOC ) ; if ( ! page ) clear_huge_page ( new_page , haddr , HPAGE_PMD_NR ) ; else copy_user_huge_page ( new_page , page , haddr , vma , HPAGE_PMD_NR ) ; __SetPageUptodate ( new_page ) ; mmun_start = haddr ; mmun_end = haddr + HPAGE_PMD_SIZE ; mmu_notifier_invalidate_range_start ( vma -> vm_mm , mmun_start , mmun_end ) ; spin_lock ( fe -> ptl ) ; if ( page ) put_page ( page ) ; if ( unlikely ( ! pmd_same ( * fe -> pmd , orig_pmd ) ) ) { spin_unlock ( fe -> ptl ) ; mem_cgroup_cancel_charge ( new_page , memcg , true ) ; put_page ( new_page ) ; goto out_mn ; } else { pmd_t entry ; entry = mk_huge_pmd ( new_page , vma -> vm_page_prot ) ; entry = maybe_pmd_mkwrite ( pmd_mkdirty ( entry ) , vma ) ; pmdp_huge_clear_flush_notify ( vma , haddr , fe -> pmd ) ; page_add_new_anon_rmap ( new_page , vma , haddr , true ) ; mem_cgroup_commit_charge ( new_page , memcg , false , true ) ; lru_cache_add_active_or_unevictable ( new_page , vma ) ; set_pmd_at ( vma -> vm_mm , haddr , fe -> pmd , entry ) ; update_mmu_cache_pmd ( vma , fe -> address , fe -> pmd ) ; if ( ! page ) { add_mm_counter ( vma -> vm_mm , MM_ANONPAGES , HPAGE_PMD_NR ) ; } else { VM_BUG_ON_PAGE ( ! PageHead ( page ) , page ) ; page_remove_rmap ( page , true ) ; put_page ( page ) ; } ret |= VM_FAULT_WRITE ; } spin_unlock ( fe -> ptl ) ; out_mn : mmu_notifier_invalidate_range_end ( vma -> vm_mm , mmun_start , mmun_end ) ; out : return ret ; out_unlock : spin_unlock ( fe -> ptl ) ; return ret ; } | <S2SV_ModStart> vm_mm , huge_gfp | __GFP_NORETRY |
6,588 | CWE-000 int psb_fbdev_init ( struct drm_device * dev ) { struct psb_fbdev * fbdev ; struct drm_psb_private * dev_priv = dev -> dev_private ; <S2SV_StartBug> fbdev = kzalloc ( sizeof ( struct psb_fbdev ) , GFP_KERNEL ) ; <S2SV_EndBug> if ( ! fbdev ) { dev_err ( dev -> dev , "no<S2SV_blank>memory\\n" ) ; return - ENOMEM ; } dev_priv -> fbdev = fbdev ; drm_fb_helper_prepare ( dev , & fbdev -> psb_fb_helper , & psb_fb_helper_funcs ) ; <S2SV_StartBug> drm_fb_helper_init ( dev , & fbdev -> psb_fb_helper , dev_priv -> ops -> crtcs , <S2SV_EndBug> INTELFB_CONN_LIMIT ) ; <S2SV_StartBug> drm_fb_helper_single_add_all_connectors ( & fbdev -> psb_fb_helper ) ; <S2SV_EndBug> <S2SV_StartBug> drm_helper_disable_unused_functions ( dev ) ; <S2SV_EndBug> <S2SV_StartBug> drm_fb_helper_initial_config ( & fbdev -> psb_fb_helper , 32 ) ; <S2SV_EndBug> return 0 ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> -> dev_private ; int ret ; <S2SV_ModStart> psb_fb_helper_funcs ) ; ret = <S2SV_ModStart> INTELFB_CONN_LIMIT ) ; if ( ret ) goto free ; ret = <S2SV_ModStart> psb_fb_helper ) ; if ( ret ) goto fini ; <S2SV_ModStart> dev ) ; ret = <S2SV_ModStart> , 32 ) ; if ( ret ) goto fini <S2SV_ModStart> return 0 ; fini : drm_fb_helper_fini ( & fbdev -> psb_fb_helper ) ; free : kfree ( fbdev ) ; return ret ; |
6,589 | CWE-000 void of_print_phandle_args ( const char * msg , const struct of_phandle_args * args ) { int i ; printk ( "%s<S2SV_blank>%s" , msg , of_node_full_name ( args -> np ) ) ; <S2SV_StartBug> for ( i = 0 ; i < args -> args_count ; i ++ ) <S2SV_EndBug> printk ( i ? ",%08x" : ":%08x" , args -> args [ i ] ) ; <S2SV_StartBug> printk ( "\\n" ) ; <S2SV_EndBug> } | <S2SV_ModStart> i ++ ) { const char delim = i ? ',' : ':' ; pr_cont ( "%c%08x" , delim <S2SV_ModEnd> , args -> <S2SV_ModStart> ] ) ; } pr_cont <S2SV_ModEnd> ( "\\n" ) |
6,590 | CWE-000 static void dbs_check_cpu ( struct cpu_dbs_info_s * this_dbs_info ) { unsigned int load = 0 ; unsigned int max_load = 0 ; unsigned int freq_target ; struct cpufreq_policy * policy ; unsigned int j ; policy = this_dbs_info -> cur_policy ; for_each_cpu ( j , policy -> cpus ) { struct cpu_dbs_info_s * j_dbs_info ; <S2SV_StartBug> cputime64_t cur_wall_time , cur_idle_time ; <S2SV_EndBug> unsigned int idle_time , wall_time ; j_dbs_info = & per_cpu ( cs_cpu_dbs_info , j ) ; cur_idle_time = get_cpu_idle_time ( j , & cur_wall_time , 0 ) ; wall_time = ( unsigned int ) ( cur_wall_time - j_dbs_info -> prev_cpu_wall ) ; j_dbs_info -> prev_cpu_wall = cur_wall_time ; idle_time = ( unsigned int ) ( cur_idle_time - j_dbs_info -> prev_cpu_idle ) ; j_dbs_info -> prev_cpu_idle = cur_idle_time ; if ( dbs_tuners_ins . ignore_nice ) { u64 cur_nice ; unsigned long cur_nice_jiffies ; cur_nice = kcpustat_cpu ( j ) . cpustat [ CPUTIME_NICE ] - j_dbs_info -> prev_cpu_nice ; cur_nice_jiffies = ( unsigned long ) cputime64_to_jiffies64 ( cur_nice ) ; j_dbs_info -> prev_cpu_nice = kcpustat_cpu ( j ) . cpustat [ CPUTIME_NICE ] ; idle_time += jiffies_to_usecs ( cur_nice_jiffies ) ; } if ( unlikely ( ! wall_time || wall_time < idle_time ) ) continue ; load = 100 * ( wall_time - idle_time ) / wall_time ; if ( load > max_load ) max_load = load ; } if ( dbs_tuners_ins . freq_step == 0 ) return ; if ( max_load > dbs_tuners_ins . up_threshold ) { this_dbs_info -> down_skip = 0 ; if ( this_dbs_info -> requested_freq == policy -> max ) return ; freq_target = ( dbs_tuners_ins . freq_step * policy -> max ) / 100 ; if ( unlikely ( freq_target == 0 ) ) freq_target = 5 ; this_dbs_info -> requested_freq += freq_target ; if ( this_dbs_info -> requested_freq > policy -> max ) this_dbs_info -> requested_freq = policy -> max ; __cpufreq_driver_target ( policy , this_dbs_info -> requested_freq , CPUFREQ_RELATION_H ) ; return ; } <S2SV_StartBug> if ( max_load < ( dbs_tuners_ins . down_threshold - 10 ) ) { <S2SV_EndBug> freq_target = ( dbs_tuners_ins . freq_step * policy -> max ) / 100 ; this_dbs_info -> requested_freq -= freq_target ; if ( this_dbs_info -> requested_freq < policy -> min ) this_dbs_info -> requested_freq = policy -> min ; <S2SV_StartBug> if ( policy -> cur == policy -> min ) <S2SV_EndBug> return ; __cpufreq_driver_target ( policy , this_dbs_info -> requested_freq , <S2SV_StartBug> CPUFREQ_RELATION_H ) ; <S2SV_EndBug> return ; } } | <S2SV_ModStart> * j_dbs_info ; u64 <S2SV_ModEnd> cur_wall_time , cur_idle_time <S2SV_ModStart> dbs_tuners_ins . down_threshold <S2SV_ModEnd> ) ) { <S2SV_ModStart> ) ) { if ( policy -> cur == policy -> min ) return ; <S2SV_ModStart> -> min ; <S2SV_ModEnd> __cpufreq_driver_target ( policy <S2SV_ModStart> -> requested_freq , CPUFREQ_RELATION_L <S2SV_ModEnd> ) ; return |
6,591 | CWE-000 static bool gpioc_intr_reconfig_allowed ( struct gpioc_cdevpriv * priv , struct gpioc_pin_intr * intr_conf ) { <S2SV_StartBug> struct gpioc_privs * priv_link ; <S2SV_EndBug> if ( SLIST_EMPTY ( & intr_conf -> privs ) ) return ( true ) ; SLIST_FOREACH ( priv_link , & intr_conf -> privs , next ) { if ( priv_link -> priv != priv ) return ( false ) ; } return ( true ) ; } | <S2SV_ModStart> gpioc_privs * priv_link ; mtx_assert ( & intr_conf -> mtx , MA_OWNED ) |
6,592 | CWE-000 static int aio_onceonly ( void ) { <S2SV_StartBug> if ( aio_listio_max < AIO_LISTIO_MAX ) <S2SV_EndBug> aio_listio_max = AIO_LISTIO_MAX ; if ( aio_listio_max > MIN ( MAX_AIO_QUEUE_PER_PROC , max_queue_count ) ) aio_listio_max = MIN ( MAX_AIO_QUEUE_PER_PROC , max_queue_count ) ; exit_tag = EVENTHANDLER_REGISTER ( process_exit , aio_proc_rundown , NULL , EVENTHANDLER_PRI_ANY ) ; exec_tag = EVENTHANDLER_REGISTER ( process_exec , aio_proc_rundown_exec , NULL , EVENTHANDLER_PRI_ANY ) ; kqueue_add_filteropts ( EVFILT_AIO , & aio_filtops ) ; kqueue_add_filteropts ( EVFILT_LIO , & lio_filtops ) ; TAILQ_INIT ( & aio_freeproc ) ; sema_init ( & aio_newproc_sem , 0 , "aio_new_proc" ) ; mtx_init ( & aio_job_mtx , "aio_job" , NULL , MTX_DEF ) ; TAILQ_INIT ( & aio_jobs ) ; aiod_unr = new_unrhdr ( 1 , INT_MAX , NULL ) ; kaio_zone = uma_zcreate ( "AIO" , sizeof ( struct kaioinfo ) , NULL , NULL , NULL , NULL , UMA_ALIGN_PTR , UMA_ZONE_NOFREE ) ; aiop_zone = uma_zcreate ( "AIOP" , sizeof ( struct aioproc ) , NULL , NULL , NULL , NULL , UMA_ALIGN_PTR , UMA_ZONE_NOFREE ) ; aiocb_zone = uma_zcreate ( "AIOCB" , sizeof ( struct kaiocb ) , NULL , NULL , <S2SV_StartBug> NULL , NULL , UMA_ALIGN_PTR , UMA_ZONE_NOFREE ) ; <S2SV_EndBug> aiol_zone = uma_zcreate ( "AIOL" , aio_listio_max * sizeof ( intptr_t ) , NULL , NULL , NULL , NULL , UMA_ALIGN_PTR , UMA_ZONE_NOFREE ) ; aiolio_zone = uma_zcreate ( "AIOLIO" , sizeof ( struct aioliojob ) , NULL , NULL , NULL , NULL , UMA_ALIGN_PTR , UMA_ZONE_NOFREE ) ; aiod_lifetime = AIOD_LIFETIME_DEFAULT ; jobrefid = 1 ; p31b_setcfg ( CTL_P1003_1B_ASYNCHRONOUS_IO , _POSIX_ASYNCHRONOUS_IO ) ; p31b_setcfg ( CTL_P1003_1B_AIO_MAX , MAX_AIO_QUEUE ) ; p31b_setcfg ( CTL_P1003_1B_AIO_PRIO_DELTA_MAX , 0 ) ; return ( 0 ) ; } | <S2SV_ModStart> void ) { <S2SV_ModEnd> exit_tag = EVENTHANDLER_REGISTER <S2SV_ModStart> , NULL , <S2SV_ModEnd> NULL , NULL |
6,593 | CWE-000 static void dh_web_view_class_init ( DhWebViewClass * klass ) { GObjectClass * object_class = G_OBJECT_CLASS ( klass ) ; GtkWidgetClass * widget_class = GTK_WIDGET_CLASS ( klass ) ; object_class -> constructed = dh_web_view_constructed ; object_class -> finalize = dh_web_view_finalize ; widget_class -> scroll_event = dh_web_view_scroll_event ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> = dh_web_view_scroll_event ; widget_class -> button_press_event = dh_web_view_button_press_event ; |
6,594 | CWE-000 static void _assign_stat ( Statement * s ) { StatementAssign * st = s -> statement ; PreparedVariable var = prepareVariable ( st -> name ) ; expression_value_t * eval = getValueExpression ( st -> expression ) ; if ( eval -> type == dtINTEGER ) memorySet ( var . parent_handler , newRecordInteger ( var . name , eval -> value . i ) ) ; if ( eval -> type == dtFLOAT ) memorySet ( var . parent_handler , newRecordFloat ( var . name , eval -> value . f ) ) ; if ( eval -> type == dtSTRING ) memorySet ( var . parent_handler , newRecordString ( var . name , eval -> value . s ) ) ; if ( eval -> type == dtBOOLEAN ) memorySet ( var . parent_handler , newRecordBoolean ( var . name , eval -> value . b ) ) ; if ( eval -> type == dtNIL ) memorySet ( var . parent_handler , newRecordNil ( var . name ) ) ; if ( eval -> type == dtTABLE ) memorySet ( var . parent_handler , newRecordTable ( var . name , eval -> value . table ) ) ; if ( eval -> type == dtLIST ) memorySet ( var . parent_handler , newRecordList ( var . name , eval -> value . list ) ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ) ) ; if ( eval -> type == dtFUNCTION ) memorySet ( var . parent_handler , newRecordFunction ( var . name , eval -> value . fn ) ) ; |
6,595 | CWE-000 <S2SV_StartBug> void writeit ( int f , void * buf , size_t len ) { <S2SV_EndBug> ssize_t res ; while ( len > 0 ) { DEBUG ( "+" ) ; <S2SV_StartBug> if ( ( res = write ( f , buf , len ) ) <= 0 ) <S2SV_EndBug> <S2SV_StartBug> err ( "Send<S2SV_blank>failed:<S2SV_blank>%m" ) ; <S2SV_EndBug> len -= res ; buf += res ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> int <S2SV_ModEnd> writeit ( int <S2SV_ModStart> <= 0 ) { switch ( errno ) { case EAGAIN : break ; default : err_nonfatal <S2SV_ModEnd> ( "Send<S2SV_blank>failed:<S2SV_blank>%m" ) <S2SV_ModStart> "Send<S2SV_blank>failed:<S2SV_blank>%m" ) ; return - 1 ; } } <S2SV_ModStart> res ; } return 0 ; |
6,596 | CWE-000 static xlat_action_t cipher_rsa_verify_xlat ( UNUSED TALLOC_CTX * ctx , UNUSED fr_cursor_t * out , REQUEST * request , void const * xlat_inst , void * xlat_thread_inst , fr_value_box_t * * in ) { <S2SV_StartBug> rlm_cipher_t const * inst = talloc_get_type_abort ( * ( ( void const * const * ) xlat_inst ) , rlm_cipher_t ) ; <S2SV_EndBug> <S2SV_StartBug> rlm_cipher_rsa_thread_inst_t * xt = talloc_get_type_abort ( * ( ( void const * const * ) xlat_thread_inst ) , <S2SV_EndBug> rlm_cipher_rsa_thread_inst_t ) ; uint8_t const * sig ; size_t sig_len ; char const * msg ; size_t msg_len ; size_t digest_len ; fr_value_box_t * vb ; if ( ! * in ) { REDEBUG ( "verification<S2SV_blank>requires<S2SV_blank>two<S2SV_blank>or<S2SV_blank>more<S2SV_blank>arguments<S2SV_blank>(<signature>,<S2SV_blank><message>...)" ) ; return XLAT_ACTION_FAIL ; } if ( ! ( * in ) -> next ) { REDEBUG ( "Missing<S2SV_blank>message<S2SV_blank>data<S2SV_blank>arg<S2SV_blank>or<S2SV_blank>message<S2SV_blank>data<S2SV_blank>was<S2SV_blank>(null)" ) ; return XLAT_ACTION_FAIL ; } if ( ( * in ) -> type != FR_TYPE_OCTETS ) { REDEBUG ( "Signature<S2SV_blank>argument<S2SV_blank>wrong<S2SV_blank>type,<S2SV_blank>expected<S2SV_blank>%s,<S2SV_blank>got<S2SV_blank>%s.<S2SV_blank><S2SV_blank>" "Use<S2SV_blank>%%{base64_decode:<text>}<S2SV_blank>or<S2SV_blank>%%{hex_decode:<text>}<S2SV_blank>if<S2SV_blank>signature<S2SV_blank>is<S2SV_blank>armoured" , fr_int2str ( dict_attr_types , FR_TYPE_OCTETS , "?Unknown?" ) , fr_int2str ( dict_attr_types , ( * in ) -> type , "?Unknown?" ) ) ; return XLAT_ACTION_FAIL ; } sig = ( * in ) -> vb_octets ; sig_len = ( * in ) -> vb_length ; if ( fr_value_box_list_concat ( ctx , ( * in ) -> next , & ( ( * in ) -> next ) , FR_TYPE_STRING , true ) < 0 ) { REDEBUG ( "Failed<S2SV_blank>concatenating<S2SV_blank>arguments<S2SV_blank>to<S2SV_blank>form<S2SV_blank>plaintext" ) ; return XLAT_ACTION_FAIL ; } msg = ( * in ) -> next -> vb_strvalue ; msg_len = ( * in ) -> next -> vb_length ; if ( * msg != '<S2SV_blank>' ) { REDEBUG ( "Expected<S2SV_blank>whitespace<S2SV_blank>argument<S2SV_blank>separator" ) ; return XLAT_ACTION_FAIL ; } msg ++ ; msg_len -- ; if ( msg_len == 0 ) { REDEBUG ( "Zero<S2SV_blank>length<S2SV_blank>message<S2SV_blank>data" ) ; return XLAT_ACTION_FAIL ; } if ( unlikely ( EVP_PKEY_verify_init ( xt -> evp_pkey_ctx ) <= 0 ) ) { tls_log_error ( request , "Failed<S2SV_blank>initialising<S2SV_blank>EVP_PKEY_CTX" ) ; return XLAT_ACTION_FAIL ; } if ( unlikely ( cipher_rsa_padding_params_set ( request , xt -> evp_pkey_ctx , inst -> rsa ) < 0 ) ) return XLAT_ACTION_FAIL ; if ( unlikely ( EVP_PKEY_CTX_set_signature_md ( xt -> evp_pkey_ctx , inst -> rsa -> sig_digest ) ) <= 0 ) { tls_log_error ( request , "Failed<S2SV_blank>setting<S2SV_blank>signature<S2SV_blank>digest<S2SV_blank>type" ) ; return XLAT_ACTION_FAIL ; } if ( unlikely ( EVP_DigestInit ( xt -> evp_md_ctx , inst -> rsa -> sig_digest ) <= 0 ) ) { tls_log_error ( request , "Failed<S2SV_blank>initialising<S2SV_blank>message<S2SV_blank>digest" ) ; return XLAT_ACTION_FAIL ; } if ( EVP_DigestUpdate ( xt -> evp_md_ctx , msg , msg_len ) <= 0 ) { tls_log_error ( request , "Failed<S2SV_blank>ingesting<S2SV_blank>message" ) ; return XLAT_ACTION_FAIL ; } if ( EVP_DigestFinal ( xt -> evp_md_ctx , xt -> digest_buff , ( unsigned int * ) & digest_len ) <= 0 ) { tls_log_error ( request , "Failed<S2SV_blank>finalising<S2SV_blank>message<S2SV_blank>digest" ) ; return XLAT_ACTION_FAIL ; } switch ( EVP_PKEY_verify ( ctx , sig , sig_len , xt -> digest_buff , digest_len ) ) { case 1 : MEM ( vb = fr_value_box_alloc ( ctx , FR_TYPE_BOOL , NULL , false ) ) ; vb -> vb_bool = true ; fr_cursor_append ( out , vb ) ; break ; case 0 : MEM ( vb = fr_value_box_alloc ( ctx , FR_TYPE_BOOL , NULL , false ) ) ; vb -> vb_bool = false ; fr_cursor_append ( out , vb ) ; break ; default : tls_log_error ( request , "Failed<S2SV_blank>validating<S2SV_blank>signature" ) ; return XLAT_ACTION_FAIL ; } return XLAT_ACTION_DONE ; } | <S2SV_ModStart> * inst = talloc_get_type_abort_const <S2SV_ModEnd> ( * ( <S2SV_ModStart> ( ( void * <S2SV_ModEnd> * ) xlat_thread_inst |
6,597 | CWE-000 static int s3_wmi_check_platform_device ( struct device * dev , void * data ) { <S2SV_StartBug> struct acpi_device * adev , * ts_adev ; <S2SV_EndBug> acpi_handle handle ; acpi_status status ; handle = ACPI_HANDLE ( dev ) ; if ( ! handle || acpi_bus_get_device ( handle , & adev ) ) return 0 ; if ( ! strcmp ( ACPI_BUTTON_HID_LID , acpi_device_hid ( adev ) ) ) { s3_wmi . pnp0c0d_adev = adev ; return 0 ; } if ( strncmp ( acpi_device_bid ( adev ) , SPI_CTL_OBJ_NAME , strlen ( SPI_CTL_OBJ_NAME ) ) ) return 0 ; status = acpi_walk_namespace ( ACPI_TYPE_DEVICE , handle , 1 , s3_wmi_attach_spi_device , NULL , & ts_adev , NULL ) ; if ( ACPI_FAILURE ( status ) ) dev_warn ( dev , "failed<S2SV_blank>to<S2SV_blank>enumerate<S2SV_blank>SPI<S2SV_blank>slaves\\n" ) ; if ( ! ts_adev ) return 0 ; s3_wmi . touchscreen_adev = ts_adev ; return 0 ; } | <S2SV_ModStart> , * ts_adev = NULL |
6,598 | CWE-000 static void xfce_panel_plugin_init ( XfcePanelPlugin * plugin ) { <S2SV_StartBug> plugin -> priv = G_TYPE_INSTANCE_GET_PRIVATE ( plugin , XFCE_TYPE_PANEL_PLUGIN , XfcePanelPluginPrivate ) ; <S2SV_EndBug> plugin -> priv -> name = NULL ; plugin -> priv -> display_name = NULL ; plugin -> priv -> comment = NULL ; plugin -> priv -> unique_id = - 1 ; plugin -> priv -> property_base = NULL ; plugin -> priv -> arguments = NULL ; plugin -> priv -> size = 0 ; plugin -> priv -> icon_size = 0 ; plugin -> priv -> small = FALSE ; plugin -> priv -> expand = FALSE ; plugin -> priv -> shrink = FALSE ; plugin -> priv -> mode = XFCE_PANEL_PLUGIN_MODE_HORIZONTAL ; plugin -> priv -> screen_position = XFCE_SCREEN_POSITION_NONE ; plugin -> priv -> menu = NULL ; plugin -> priv -> menu_blocked = 0 ; plugin -> priv -> panel_lock = 0 ; plugin -> priv -> flags = 0 ; plugin -> priv -> locked = TRUE ; plugin -> priv -> menu_items = NULL ; plugin -> priv -> nrows = 1 ; bindtextdomain ( GETTEXT_PACKAGE , PACKAGE_LOCALE_DIR ) ; # ifdef HAVE_BIND_TEXTDOMAIN_CODESET bind_textdomain_codeset ( GETTEXT_PACKAGE , "UTF-8" ) ; # endif gtk_event_box_set_visible_window ( GTK_EVENT_BOX ( plugin ) , FALSE ) ; } | <S2SV_ModStart> -> priv = xfce_panel_plugin_get_instance_private ( plugin <S2SV_ModEnd> ) ; plugin |
6,599 | CWE-000 void arcan_tui_erase_sb ( struct tui_context * c ) { <S2SV_StartBug> if ( c ) { <S2SV_EndBug> tsm_screen_inc_age ( c -> screen ) ; tsm_screen_clear_sb ( c -> screen ) ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> { if ( ! c ) <S2SV_ModEnd> tsm_screen_clear_sb ( c <S2SV_ModStart> ) ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.