Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
5,700 | CWE-000 double mint_timer_set ( mint_timer_t * timer , double time ) { clock_t current = clock ( ) ; double result = timer_get ( timer , current ) ; <S2SV_StartBug> * timer = ( clock_t ) ( current + time * CLOCKS_PER_SEC ) ; <S2SV_EndBug> return result ; } | <S2SV_ModStart> ) ( current - <S2SV_ModEnd> time * CLOCKS_PER_SEC |
5,701 | CWE-000 Env * rvmCreateEnv ( VM * vm ) { Env * env = gcAllocateUncollectable ( vm -> options -> enableHooks ? sizeof ( DebugEnv ) : sizeof ( Env ) ) ; if ( ! env ) return NULL ; env -> vm = vm ; if ( vm -> options -> enableHooks ) { DebugEnv * debugEnv = ( DebugEnv * ) env ; debugEnv -> reqId = 0 ; debugEnv -> suspended = FALSE ; <S2SV_StartBug> } <S2SV_EndBug> rvmInitJNIEnv ( env ) ; return env ; } | <S2SV_ModStart> = FALSE ; debugEnv -> ignoreExceptions = TRUE ; |
5,702 | CWE-000 void ue_selected_preamble ( ext_ra_inst_t * inst , int ue_id ) { ue_t * iterator2 ; int preamble_index ; int rar_index ; inst -> trial += 1 ; preamble_index = ( int ) ( inst -> number_of_preamble * lcgrand ( 2 ) ) ; rar_index = ( int ) ( inst -> rar_type * lcgrand ( 3 ) ) ; inst -> ue_list [ ue_id ] . is_active = 0x1 ; inst -> ue_list [ ue_id ] . preamble_index = preamble_index ; <S2SV_StartBug> inst -> preamble_table [ preamble_index ] . num_selected_rar [ rar_index ] += 1 ; <S2SV_EndBug> <S2SV_StartBug> if ( ( ue_t * ) 0 == inst -> preamble_table [ preamble_index ] . rar_ue_list [ rar_index ] ) { <S2SV_EndBug> inst -> preamble_table [ preamble_index ] . rar_ue_list [ rar_index ] = & inst -> ue_list [ ue_id ] ; inst -> ue_list [ ue_id ] . next = ( ue_t * ) 0 ; } else { <S2SV_StartBug> iterator2 = inst -> preamble_table [ preamble_index ] . rar_ue_list [ rar_index ] ; <S2SV_EndBug> while ( ( ue_t * ) 0 != iterator2 -> next ) { iterator2 = iterator2 -> next ; } iterator2 -> next = & inst -> ue_list [ ue_id ] ; inst -> ue_list [ ue_id ] . next = ( ue_t * ) 0 ; } } | <S2SV_ModStart> preamble_index ] . num_selected <S2SV_ModEnd> += 1 ; <S2SV_ModStart> preamble_index ] . rar_ue ) { inst -> preamble_table [ preamble_index ] . rar_ue <S2SV_ModEnd> = & inst <S2SV_ModStart> preamble_index ] . rar_ue <S2SV_ModEnd> ; while ( |
5,703 | CWE-000 static inline void move ( t_dlist * antloc [ ] , t_room * end , size_t j ) { char chg ; chg = 0 ; while ( antloc [ j ] ) { if ( LIST ( antloc [ j ] ) && ROOM ( LIST ( antloc [ j ] ) ) != end && ROOM ( LIST ( antloc [ j ] ) -> next ) -> in == 0 ) { ROOM ( LIST ( antloc [ j ] ) ) -> in = 0 ; antloc [ j ] -> content = LIST ( antloc [ j ] ) -> next ; <S2SV_StartBug> ft_printf ( "L%u-%s<S2SV_blank>" , j + 1 , ROOM ( LIST ( antloc [ j ] ) ) -> name ) ; <S2SV_EndBug> if ( ROOM ( LIST ( antloc [ j ] ) ) != end ) ROOM ( LIST ( antloc [ j ] ) ) -> in = 1 ; chg ++ ; } j ++ ; } if ( chg ) ft_printf ( "\\n" ) ; } | <S2SV_ModStart> ; ft_printf ( "L%u-%s%c" <S2SV_ModEnd> , j + <S2SV_ModStart> ) -> name , ( chg ) ? '<S2SV_blank>' : '\\0' |
5,704 | CWE-000 int main ( int argc , char * * argv ) { <S2SV_StartBug> if ( argc != 3 ) { <S2SV_EndBug> fprintf ( stderr , "ERROR" ) ; exit ( 1 ) ; } int mpid ; sscanf ( argv [ 2 ] , "%d" , & mpid ) ; int clientfd = open_clientfd ( "127.0.0.1" , "9001" ) ; <S2SV_StartBug> char input [ MAX_LINE ] , output [ MAX_LINE ] ; <S2SV_EndBug> recongnition ( argv [ 1 ] , input ) ; write ( clientfd , input , strlen ( input ) ) ; <S2SV_StartBug> server_exec ( input , output ) ; <S2SV_EndBug> write ( clientfd , output , strlen ( output ) ) ; pronounce ( output ) ; close ( clientfd ) ; return 0 ; } | <S2SV_ModStart> { if ( service_init ( ) == - 1 ) { puts ( "Oops!" ) ; puts ( "The<S2SV_blank>manager<S2SV_blank>couldn\'t<S2SV_blank>find<S2SV_blank>the<S2SV_blank>service<S2SV_blank>file<S2SV_blank>or<S2SV_blank>the<S2SV_blank>file<S2SV_blank>is<S2SV_blank>not<S2SV_blank>consistent." ) ; return - 1 ; } if ( <S2SV_ModStart> ) ; char * input = argv [ 1 ] ; for ( int i = 0 ; i < strlen ( input ) ; ++ i ) printf ( "%d<S2SV_blank>" , input [ i ] ) ; puts ( "" ) ; char output <S2SV_ModEnd> [ MAX_LINE ] <S2SV_ModStart> [ MAX_LINE ] <S2SV_ModEnd> ; write ( <S2SV_ModStart> ) ) ; service_exec <S2SV_ModEnd> ( input , |
5,705 | CWE-000 void vm_lldi ( t_process * process , t_vm * env ) { static char * * perm = NULL ; t_param param ; char peb ; <S2SV_StartBug> peb = env -> memory [ process -> pc + 1 ] ; <S2SV_EndBug> if ( ! perm ) perm = get_lldi_perm ( ) ; param . mod = IND_TARG | IMOD ; param . len = param_len ( peb , 0 , 3 ) + 2 ; if ( ! check_peb ( peb , perm , 3 ) ) { get_param ( & param , process , env ) ; if ( ! check_reg ( peb , 3 , & param ) ) { if ( PARAM_ONE ( peb ) == REG_CODE ) param . one = process -> reg [ param . one - 1 ] ; if ( PARAM_TWO ( peb ) == REG_CODE ) param . two = process -> reg [ param . two - 1 ] ; process -> carry = ! ( process -> reg [ param . thr - 1 ] = read_memory ( process -> pc + ( param . one + param . two ) , env ) ) ? 1 : 0 ; } } if ( ( env -> option -> verbose & SHOW_MOVE ) ) show_pc_mov ( process -> pc , process -> pc + param . len , param . len , env ) ; process -> pc += param . len ; } | <S2SV_ModStart> -> memory [ ( process -> pc + 1 ) % MEM_SIZE <S2SV_ModEnd> ] ; if |
5,706 | CWE-000 void walkTree ( pBstree * head , pBstree * tail , pBstree root ) { if ( root -> left == NULL ) { * head = root ; } else { walkTree ( head , tail , root -> left ) ; root -> left = * tail ; ( * tail ) -> right = root ; } if ( root -> right == NULL ) { * tail = root ; } else { walkTree ( & ( root -> right ) , tail , root -> right ) ; <S2SV_StartBug> } <S2SV_EndBug> } | <S2SV_ModStart> right ) ; root -> right -> left = root ; |
5,707 | CWE-000 static void csr_scan_remove_dup_bss_description_from_interim_list ( tpAniSirGlobal mac_ctx , tSirBssDescription * bss_dscp , uint32_t flags ) { tListElem * pEntry ; struct tag_csrscan_result * scan_bss_dscp ; <S2SV_StartBug> int8_t scan_entry_rssi = 0 ; <S2SV_EndBug> sme_debug ( "for<S2SV_blank>BSS<S2SV_blank>" MAC_ADDRESS_STR "<S2SV_blank>" , MAC_ADDR_ARRAY ( bss_dscp -> bssId ) ) ; csr_ll_lock ( & mac_ctx -> scan . tempScanResults ) ; pEntry = csr_ll_peek_head ( & mac_ctx -> scan . tempScanResults , LL_ACCESS_NOLOCK ) ; while ( pEntry ) { scan_bss_dscp = GET_BASE_ADDR ( pEntry , struct tag_csrscan_result , Link ) ; scan_entry_rssi = scan_bss_dscp -> Result . BssDescriptor . rssi ; <S2SV_StartBug> if ( csr_is_duplicate_bss_description ( mac_ctx , <S2SV_EndBug> & scan_bss_dscp -> Result . BssDescriptor , bss_dscp ) ) { if ( flags & WLAN_SKIP_RSSI_UPDATE ) { bss_dscp -> rssi = scan_bss_dscp -> Result . BssDescriptor . rssi ; bss_dscp -> rssi_raw = scan_bss_dscp -> Result . BssDescriptor . rssi_raw ; } else { bss_dscp -> rssi = ( int8_t ) ( ( ( ( int32_t ) bss_dscp -> rssi * CSR_SCAN_RESULT_RSSI_WEIGHT ) + ( ( int32_t ) scan_entry_rssi * ( 100 - CSR_SCAN_RESULT_RSSI_WEIGHT ) ) ) / 100 ) ; <S2SV_StartBug> } <S2SV_EndBug> if ( csr_ll_remove_entry ( & mac_ctx -> scan . tempScanResults , pEntry , LL_ACCESS_NOLOCK ) ) { csr_check_n_save_wsc_ie ( mac_ctx , bss_dscp , & scan_bss_dscp -> Result . BssDescriptor ) ; csr_free_scan_result_entry ( mac_ctx , scan_bss_dscp ) ; } break ; } pEntry = csr_ll_next ( & mac_ctx -> scan . tempScanResults , pEntry , LL_ACCESS_NOLOCK ) ; } csr_ll_unlock ( & mac_ctx -> scan . tempScanResults ) ; } | <S2SV_ModStart> ; int8_t scan_entry_rssi = 0 ; int8_t scan_entry_rssi_raw <S2SV_ModStart> . rssi ; scan_entry_rssi_raw = scan_bss_dscp -> Result . BssDescriptor . rssi_raw ; <S2SV_ModStart> 100 ) ; bss_dscp -> rssi_raw = ( int8_t ) ( ( ( ( int32_t ) bss_dscp -> rssi_raw * CSR_SCAN_RESULT_RSSI_WEIGHT ) + ( ( int32_t ) scan_entry_rssi_raw * ( 100 - CSR_SCAN_RESULT_RSSI_WEIGHT ) ) ) / 100 ) ; |
5,708 | CWE-000 extern int cpu_freq_verify_govlist ( const char * arg , uint32_t * govs ) { <S2SV_StartBug> char * list , * gov , * savestr ; <S2SV_EndBug> uint32_t agov ; * govs = 0 ; if ( arg == NULL ) { error ( "cpu_freq_verify_govlist:<S2SV_blank>governor<S2SV_blank>list<S2SV_blank>is<S2SV_blank>empty" ) ; return - 1 ; } list = xstrdup ( arg ) ; if ( ( gov = strtok_r ( list , "," , & savestr ) ) == NULL ) { error ( "cpu_freq_verify_govlist:<S2SV_blank>governor<S2SV_blank>list<S2SV_blank>\'%s\'<S2SV_blank>invalid" , arg ) ; return - 1 ; } do { debug3 ( "cpu_freq_verify_govlist:<S2SV_blank>gov<S2SV_blank>=<S2SV_blank>%s" , gov ) ; agov = _cpu_freq_check_gov ( gov , 0 ) ; if ( agov == 0 ) { error ( "cpu_freq_verify_govlist:<S2SV_blank>governor<S2SV_blank>\'%s\'<S2SV_blank>invalid" , gov ) ; return - 1 ; } * govs |= agov ; } while ( ( gov = strtok_r ( NULL , "," , & savestr ) ) != NULL ) ; xfree ( list ) ; return 0 ; } | <S2SV_ModStart> , * savestr = NULL |
5,709 | CWE-000 static int rtr_update_pfx_table ( struct rtr_socket * rtr_socket , const void * pdu ) { const enum pdu_type type = rtr_get_pdu_type ( pdu ) ; assert ( type == IPV4_PREFIX || type == IPV6_PREFIX ) ; struct pfx_record pfxr ; size_t pdu_size = ( type == IPV4_PREFIX ? sizeof ( struct pdu_ipv4 ) : sizeof ( struct pdu_ipv6 ) ) ; rtr_prefix_pdu_2_pfx_record ( rtr_socket , pdu , & pfxr , type ) ; int rtval ; if ( ( ( struct pdu_ipv4 * ) pdu ) -> flags == 1 ) rtval = pfx_table_add ( rtr_socket -> pfx_table , & pfxr ) ; else if ( ( ( struct pdu_ipv4 * ) pdu ) -> flags == 0 ) rtval = pfx_table_remove ( rtr_socket -> pfx_table , & pfxr ) ; else { const char txt [ ] = "Prefix<S2SV_blank>PDU<S2SV_blank>with<S2SV_blank>invalid<S2SV_blank>flags<S2SV_blank>value<S2SV_blank>received" ; RTR_DBG ( "%s" , txt ) ; rtr_send_error_pdu ( rtr_socket , pdu , pdu_size , CORRUPT_DATA , txt , sizeof ( txt ) ) ; return RTR_ERROR ; } if ( rtval == PFX_DUPLICATE_RECORD ) { char ip [ INET6_ADDRSTRLEN ] ; lrtr_ip_addr_to_str ( & ( pfxr . prefix ) , ip , INET6_ADDRSTRLEN ) ; RTR_DBG ( "Duplicate<S2SV_blank>Announcement<S2SV_blank>for<S2SV_blank>record:<S2SV_blank>%s/%u-%u,<S2SV_blank>ASN:<S2SV_blank>%u,<S2SV_blank>received" , ip , pfxr . min_len , pfxr . max_len , pfxr . asn ) ; rtr_send_error_pdu ( rtr_socket , pdu , pdu_size , DUPLICATE_ANNOUNCEMENT , NULL , 0 ) ; rtr_change_socket_state ( rtr_socket , RTR_ERROR_FATAL ) ; return RTR_ERROR ; } else if ( rtval == PFX_RECORD_NOT_FOUND ) { RTR_DBG1 ( "Withdrawal<S2SV_blank>of<S2SV_blank>unknown<S2SV_blank>record" ) ; rtr_send_error_pdu ( rtr_socket , pdu , pdu_size , WITHDRAWAL_OF_UNKNOWN_RECORD , NULL , 0 ) ; rtr_change_socket_state ( rtr_socket , RTR_ERROR_FATAL ) ; return RTR_ERROR ; } else if ( rtval == PFX_ERROR ) { const char txt [ ] = "PFX_TABLE<S2SV_blank>Error" ; RTR_DBG ( "%s" , txt ) ; <S2SV_StartBug> rtr_send_error_pdu ( rtr_socket , pdu , pdu_size , INTERNAL_ERROR , txt , sizeof ( txt ) ) ; <S2SV_EndBug> rtr_change_socket_state ( rtr_socket , RTR_ERROR_FATAL ) ; return RTR_ERROR ; } return RTR_SUCCESS ; } | <S2SV_ModStart> ( rtr_socket , NULL , 0 <S2SV_ModEnd> , INTERNAL_ERROR , |
5,710 | CWE-000 char * MVM_string_utf8_encode_C_string ( MVMThreadContext * tc , MVMString * str ) { MVMuint64 output_size ; <S2SV_StartBug> char * result ; <S2SV_EndBug> char * utf8_string = MVM_string_utf8_encode ( tc , str , & output_size , 0 ) ; result = MVM_malloc ( output_size + 1 ) ; memcpy ( result , utf8_string , output_size ) ; MVM_free ( utf8_string ) ; result [ output_size ] = ( char ) 0 ; return result ; } | <S2SV_ModStart> char * result = NULL |
5,711 | CWE-000 void usage ( const char * program ) { <S2SV_StartBug> fprintf ( stderr , "%s<S2SV_blank>(format|mount)<S2SV_blank><disk><S2SV_blank>[OPTIONS]\\n" , program ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( stderr , "%s<S2SV_blank>(format|mount)<S2SV_blank><disk><S2SV_blank>[OPTIONS...]\\n" <S2SV_ModEnd> , program ) |
5,712 | CWE-000 void sys_time_set ( const struct tm * tmbuf ) { sys_time_init_startup_micros = bcm2835_st_read ( ) ; <S2SV_StartBug> rtc_startup_seconds = ( uint32_t ) mktime ( ( struct tm * ) tmbuf ) ; <S2SV_EndBug> } | <S2SV_ModStart> ; rtc_startup_seconds = <S2SV_ModEnd> mktime ( ( |
5,713 | CWE-000 <S2SV_StartBug> static gboolean set_thread_mle_key ( ieee802154_packet * packet , unsigned char * key , unsigned char * alt_key , ieee802154_key_t * uat_key ) <S2SV_EndBug> { GByteArray * seq_ctr_bytes = NULL ; if ( packet -> key_id_mode == KEY_ID_MODE_KEY_INDEX ) { seq_ctr_bytes = set_thread_seq_ctr_from_key_index ( packet -> key_index ) ; } else if ( packet -> key_id_mode == KEY_ID_MODE_KEY_EXPLICIT_4 ) { seq_ctr_bytes = g_byte_array_new ( ) ; seq_ctr_bytes = g_byte_array_set_size ( seq_ctr_bytes , 4 ) ; seq_ctr_bytes -> data [ 0 ] = ( packet -> key_source . addr32 >> 24 ) & 0xFF ; seq_ctr_bytes -> data [ 1 ] = ( packet -> key_source . addr32 >> 16 ) & 0xFF ; seq_ctr_bytes -> data [ 2 ] = ( packet -> key_source . addr32 >> 8 ) & 0xFF ; seq_ctr_bytes -> data [ 3 ] = packet -> key_source . addr32 & 0xFF ; if ( thread_auto_acq_seq_ctr && ! thread_seq_ctr_acqd ) { memcpy ( thread_seq_ctr_bytes , seq_ctr_bytes -> data , 4 ) ; thread_seq_ctr_acqd = TRUE ; } } if ( seq_ctr_bytes != NULL ) { create_thread_temp_keys ( seq_ctr_bytes , packet -> src_pan , uat_key , NULL , key ) ; seq_ctr_bytes -> data [ 3 ] ^= 0x80 ; create_thread_temp_keys ( seq_ctr_bytes , packet -> src_pan , uat_key , NULL , alt_key ) ; g_byte_array_free ( seq_ctr_bytes , TRUE ) ; <S2SV_StartBug> return TRUE ; <S2SV_EndBug> } <S2SV_StartBug> return FALSE ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> static guint <S2SV_ModEnd> set_thread_mle_key ( ieee802154_packet <S2SV_ModStart> ) ; return 2 <S2SV_ModEnd> ; } return <S2SV_ModStart> ; } return 0 <S2SV_ModEnd> ; } <S2SV_null> |
5,714 | CWE-000 void core_pm_suspend ( u32 thread_id ) { u32 currnt_thread = core_pm_get_currnt_thread_id ( ) ; core_pm_spnlck_rw_r_lock ( & thread_table_lock ) ; if ( currnt_thread == thread_id ) { core_pm_disable_sched ( ) ; } pthread_obj_t p_thread_obj = core_rtl_array_get ( & thread_table , thread_id ) ; if ( p_thread_obj == NULL ) { if ( currnt_thread == thread_id ) { core_pm_enable_sched ( ) ; } core_pm_spnlck_rw_r_unlock ( & thread_table_lock ) ; peinval_except_t p_except = einval_except ( ) ; RAISE ( p_except , "Thread<S2SV_blank>does<S2SV_blank>not<S2SV_blank>exists." ) ; return ; } else if ( p_thread_obj -> status == TASK_ZOMBIE ) { if ( currnt_thread == thread_id ) { core_pm_enable_sched ( ) ; } core_pm_spnlck_rw_r_unlock ( & thread_table_lock ) ; peinval_except_t p_except = einval_except ( ) ; RAISE ( p_except , "Cannot<S2SV_blank>suspend<S2SV_blank>a<S2SV_blank>zombie<S2SV_blank>thread." ) ; return ; } else { p_thread_obj -> status = TASK_SUSPEND ; } if ( currnt_thread == thread_id ) { core_pm_enable_sched ( ) ; } core_pm_spnlck_rw_r_unlock ( & thread_table_lock ) ; <S2SV_StartBug> hal_cpu_send_IPI ( - 1 , IPI_TYPE_PREEMPT , NULL ) ; <S2SV_EndBug> <S2SV_StartBug> return ; <S2SV_EndBug> } | <S2SV_ModStart> thread_table_lock ) ; if ( thread_id != currnt_thread ) { <S2SV_ModStart> NULL ) ; } |
5,715 | CWE-000 static int testParseStorage ( testDriverPtr privconn , const char * file , xmlXPathContextPtr ctxt ) { int num , ret = - 1 ; size_t i ; xmlNodePtr * nodes = NULL ; virStoragePoolObjPtr obj ; num = virXPathNodeSet ( "/node/pool" , ctxt , & nodes ) ; if ( num < 0 ) goto error ; for ( i = 0 ; i < num ; i ++ ) { virStoragePoolDefPtr def ; xmlNodePtr node = testParseXMLDocFromFile ( nodes [ i ] , file , "pool" ) ; if ( ! node ) goto error ; def = virStoragePoolDefParseNode ( ctxt -> doc , node ) ; if ( ! def ) goto error ; <S2SV_StartBug> if ( ! ( obj = virStoragePoolObjAssignDef ( privconn -> pools , def ) ) ) { <S2SV_EndBug> virStoragePoolDefFree ( def ) ; goto error ; } if ( testStoragePoolObjSetDefaults ( obj ) == - 1 ) { virStoragePoolObjEndAPI ( & obj ) ; goto error ; } virStoragePoolObjSetActive ( obj , true ) ; if ( testOpenVolumesForPool ( file , ctxt , obj , i + 1 ) < 0 ) { virStoragePoolObjEndAPI ( & obj ) ; goto error ; } virStoragePoolObjEndAPI ( & obj ) ; } ret = 0 ; error : VIR_FREE ( nodes ) ; return ret ; } | <S2SV_ModStart> pools , def , false |
5,716 | CWE-000 static int cryptd_hash_import ( struct ahash_request * req , const void * in ) { <S2SV_StartBug> struct cryptd_hash_request_ctx * rctx = ahash_request_ctx ( req ) ; <S2SV_EndBug> <S2SV_StartBug> return crypto_shash_import ( & rctx -> desc , in ) ; <S2SV_EndBug> } | <S2SV_ModStart> ) { struct crypto_ahash * tfm = crypto_ahash_reqtfm <S2SV_ModEnd> ( req ) <S2SV_ModStart> req ) ; struct cryptd_hash_ctx * ctx = crypto_ahash_ctx ( tfm ) ; struct shash_desc * desc = cryptd_shash_desc ( req ) ; desc -> tfm = ctx -> child ; desc -> flags = req -> base . flags ; <S2SV_ModStart> return crypto_shash_import ( <S2SV_ModEnd> desc , in |
5,717 | CWE-000 static int ostprintf ( output_stream stream , const char * fmt , ... ) { int res ; va_list args ; va_start ( args , fmt ) ; res = ( * stream_operation . write_to_stream ) ( stream , fmt , args ) ; va_end ( args ) ; <S2SV_StartBug> return res ; <S2SV_EndBug> } | <S2SV_ModStart> args ) ; if ( res ) quickdie ( "could<S2SV_blank>not<S2SV_blank>write<S2SV_blank>to<S2SV_blank>stream" ) ; |
5,718 | CWE-000 void HCI_Event_CB ( void * pckt ) { hci_uart_pckt * hci_pckt = pckt ; hci_event_pckt * event_pckt = ( hci_event_pckt * ) hci_pckt -> data ; if ( hci_pckt -> type != HCI_EVENT_PKT ) { return ; } switch ( event_pckt -> evt ) { case EVT_DISCONN_COMPLETE : { GAP_DisconnectionComplete_CB ( ) ; break ; } case EVT_LE_META_EVENT : { evt_le_meta_event * evt = ( void * ) event_pckt -> data ; switch ( evt -> subevent ) { case EVT_LE_CONN_COMPLETE : { evt_le_connection_complete * cc = ( void * ) evt -> data ; GAP_ConnectionComplete_CB ( cc -> peer_bdaddr , cc -> handle ) ; } break ; } break ; } case EVT_VENDOR : { evt_blue_aci * blue_evt = ( void * ) event_pckt -> data ; switch ( blue_evt -> ecode ) { case EVT_BLUE_GATT_READ_PERMIT_REQ : { evt_gatt_read_permit_req * pr = ( void * ) blue_evt -> data ; Read_Request_CB ( pr -> attr_handle ) ; break ; } case EVT_BLUE_GATT_ATTRIBUTE_MODIFIED : { if ( TargetBoardFeatures . bnrg_expansion_board == IDB05A1 ) { evt_gatt_attr_modified_IDB05A1 * evt = ( evt_gatt_attr_modified_IDB05A1 * ) blue_evt -> data ; # ifdef MOTENV_DEBUG_CONNECTION { PRINTF ( "[%d]<S2SV_blank>:<S2SV_blank>" , evt -> data_length ) ; <S2SV_StartBug> for ( int i = 0 ; i < evt -> data_length ) <S2SV_EndBug> { <S2SV_StartBug> PRINTF ( "<S2SV_blank>[0x%02x]" , evt -> data [ i ] ) ; <S2SV_EndBug> } PRINTF ( "\\r\\n" ) ; } # endif Attribute_Modified_CB ( evt -> attr_handle , evt -> att_data , evt -> data_length ) ; } else { evt_gatt_attr_modified_IDB04A1 * evt = ( evt_gatt_attr_modified_IDB04A1 * ) blue_evt -> data ; Attribute_Modified_CB ( evt -> attr_handle , evt -> att_data , evt -> data_length ) ; } break ; } } } break ; } } | <S2SV_ModStart> evt -> data_length ; i ++ <S2SV_ModStart> , evt -> att_data <S2SV_ModEnd> [ i ] |
5,719 | CWE-000 <S2SV_StartBug> int ft_intminquit ( void ) <S2SV_EndBug> { ft_putstr ( "-2147483648" ) ; <S2SV_StartBug> return ( 0 ) ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> void <S2SV_ModEnd> ft_intminquit ( void <S2SV_ModStart> "-2147483648" ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
5,720 | CWE-000 static void cputime_adjust ( struct task_cputime * curr , struct cputime * prev , cputime_t * ut , cputime_t * st ) { cputime_t rtime , stime , utime ; if ( vtime_accounting_enabled ( ) ) { * ut = curr -> utime ; * st = curr -> stime ; return ; } rtime = nsecs_to_cputime ( curr -> sum_exec_runtime ) ; if ( prev -> stime + prev -> utime >= rtime ) goto out ; stime = curr -> stime ; utime = curr -> utime ; if ( utime == 0 ) { stime = rtime ; } else if ( stime == 0 ) { utime = rtime ; } else { cputime_t total = stime + utime ; stime = scale_stime ( ( __force u64 ) stime , ( __force u64 ) rtime , ( __force u64 ) total ) ; utime = rtime - stime ; } <S2SV_StartBug> while ( stime > ( rtime = READ_ONCE ( prev -> stime ) ) ) <S2SV_EndBug> <S2SV_StartBug> cmpxchg ( & prev -> stime , rtime , stime ) ; <S2SV_EndBug> while ( utime > ( rtime = READ_ONCE ( prev -> utime ) ) ) <S2SV_StartBug> cmpxchg ( & prev -> utime , rtime , utime ) ; <S2SV_EndBug> out : * ut = prev -> utime ; * st = prev -> stime ; } | <S2SV_ModStart> stime ; } cputime_advance <S2SV_ModEnd> ( & prev <S2SV_ModStart> -> stime , stime ) ; cputime_advance <S2SV_ModEnd> ( & prev <S2SV_ModStart> prev -> utime <S2SV_ModEnd> , utime ) |
5,721 | CWE-000 static void request_replace_pointer ( uv_work_t * work ) { json_request_replace_pointer_t * req = work -> data ; genaro_download_state_t * state = req -> state ; int status_code = 0 ; int excluded_farmer_ids_len = ( req -> excluded_farmer_ids ) ? strlen ( req -> excluded_farmer_ids ) : 0 ; char query_args [ BUFSIZ ] ; memset ( query_args , '\\0' , BUFSIZ ) ; snprintf ( query_args , BUFSIZ , "limit=1&skip=%i&exclude=%s" , req -> pointer_index , req -> excluded_farmer_ids ) ; int path_len = 9 + strlen ( req -> bucket_id ) + 7 + strlen ( req -> file_id ) + strlen ( query_args ) ; char * path = calloc ( path_len + 1 , sizeof ( char ) ) ; if ( ! path ) { req -> error_status = GENARO_MEMORY_ERROR ; return ; } strcat ( path , "/buckets/" ) ; strcat ( path , req -> bucket_id ) ; strcat ( path , "/files/" ) ; strcat ( path , req -> file_id ) ; int request_status = fetch_json ( req -> http_options , req -> encrypt_options , req -> options , "GET" , path , query_args , NULL , true , & req -> response , & status_code ) ; if ( request_status ) { state -> log -> warn ( state -> env -> log_options , state -> handle , "Request<S2SV_blank>replace<S2SV_blank>pointer<S2SV_blank>error:<S2SV_blank>%i" , request_status ) ; } req -> status_code = status_code ; if ( ! req -> response ) { req -> status_code = - 1 ; } free ( path ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> path ) ; path = NULL ; |
5,722 | CWE-000 static void cleanup ( ) { printf ( "Ending<S2SV_blank>Emulation!\\n" ) ; exit_SDL ( ) ; # ifdef DEBUG close_cpu_debug_logfile ( ) ; <S2SV_StartBug> # endif <S2SV_EndBug> } | <S2SV_ModStart> ( ) ; close_ppu_debug_logfile ( ) ; |
5,723 | CWE-000 void scu_dsp_test ( ) { interrupt_set_level_mask ( 0xF ) ; init_iapetus ( RES_320x224 ) ; vdp_rbg0_init ( & test_disp_settings ) ; vdp_set_default_palette ( ) ; vdp_disp_on ( ) ; unregister_all_tests ( ) ; register_test ( & test_dsp , "DSP<S2SV_blank>Execution" ) ; register_test ( & test_mvi_imm_d , "MVI<S2SV_blank>Imm,<S2SV_blank>[d]" ) ; register_test ( & test_dsp_timing , "DSP<S2SV_blank>Timing" ) ; do_tests ( "SCU<S2SV_blank>DSP<S2SV_blank>tests" , 0 , 0 ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> 0 ) ; gui_clear_scr ( & test_disp_font ) ; |
5,724 | CWE-000 static int subvol_snapshot_children ( int old_fd , int new_fd , const char * subvolume , uint64_t old_subvol_id , BtrfsSnapshotFlags flags ) { struct btrfs_ioctl_search_args args = { . key . tree_id = BTRFS_ROOT_TREE_OBJECTID , . key . min_objectid = BTRFS_FIRST_FREE_OBJECTID , . key . max_objectid = BTRFS_LAST_FREE_OBJECTID , . key . min_type = BTRFS_ROOT_BACKREF_KEY , . key . max_type = BTRFS_ROOT_BACKREF_KEY , . key . min_transid = 0 , . key . max_transid = ( uint64_t ) - 1 , } ; struct btrfs_ioctl_vol_args_v2 vol_args = { . flags = flags & BTRFS_SNAPSHOT_READ_ONLY ? BTRFS_SUBVOL_RDONLY : 0 , . fd = old_fd , } ; _cleanup_close_ int subvolume_fd = - 1 ; uint64_t new_subvol_id ; int r ; assert ( old_fd >= 0 ) ; assert ( new_fd >= 0 ) ; assert ( subvolume ) ; strncpy ( vol_args . name , subvolume , sizeof ( vol_args . name ) - 1 ) ; if ( ioctl ( new_fd , BTRFS_IOC_SNAP_CREATE_V2 , & vol_args ) < 0 ) return - errno ; if ( ! ( flags & BTRFS_SNAPSHOT_RECURSIVE ) && ! ( flags & BTRFS_SNAPSHOT_QUOTA ) ) return 0 ; if ( old_subvol_id == 0 ) { r = btrfs_subvol_get_id_fd ( old_fd , & old_subvol_id ) ; if ( r < 0 ) return r ; } r = btrfs_subvol_get_id ( new_fd , vol_args . name , & new_subvol_id ) ; if ( r < 0 ) return r ; if ( flags & BTRFS_SNAPSHOT_QUOTA ) ( void ) copy_quota_hierarchy ( new_fd , old_subvol_id , new_subvol_id ) ; if ( ! ( flags & BTRFS_SNAPSHOT_RECURSIVE ) ) { if ( flags & BTRFS_SNAPSHOT_QUOTA ) ( void ) copy_subtree_quota_limits ( new_fd , old_subvol_id , new_subvol_id ) ; return 0 ; } args . key . min_offset = args . key . max_offset = old_subvol_id ; while ( btrfs_ioctl_search_args_compare ( & args ) <= 0 ) { const struct btrfs_ioctl_search_header * sh ; unsigned i ; args . key . nr_items = 256 ; if ( ioctl ( old_fd , BTRFS_IOC_TREE_SEARCH , & args ) < 0 ) return - errno ; if ( args . key . nr_items <= 0 ) break ; FOREACH_BTRFS_IOCTL_SEARCH_HEADER ( i , sh , args ) { _cleanup_free_ char * p = NULL , * c = NULL , * np = NULL ; struct btrfs_ioctl_ino_lookup_args ino_args ; const struct btrfs_root_ref * ref ; _cleanup_close_ int old_child_fd = - 1 , new_child_fd = - 1 ; btrfs_ioctl_search_args_set ( & args , sh ) ; if ( sh -> type != BTRFS_ROOT_BACKREF_KEY ) continue ; if ( sh -> offset != old_subvol_id ) continue ; if ( sh -> objectid == new_subvol_id ) continue ; ref = BTRFS_IOCTL_SEARCH_HEADER_BODY ( sh ) ; p = strndup ( ( char * ) ref + sizeof ( struct btrfs_root_ref ) , le64toh ( ref -> name_len ) ) ; if ( ! p ) return - ENOMEM ; zero ( ino_args ) ; ino_args . treeid = old_subvol_id ; ino_args . objectid = htole64 ( ref -> dirid ) ; if ( ioctl ( old_fd , BTRFS_IOC_INO_LOOKUP , & ino_args ) < 0 ) return - errno ; c = strappend ( ino_args . name , p ) ; if ( ! c ) return - ENOMEM ; old_child_fd = openat ( old_fd , c , O_RDONLY | O_NOCTTY | O_CLOEXEC | O_DIRECTORY ) ; if ( old_child_fd < 0 ) return - errno ; <S2SV_StartBug> np = strjoin ( subvolume , "/" , ino_args . name , NULL ) ; <S2SV_EndBug> if ( ! np ) return - ENOMEM ; new_child_fd = openat ( new_fd , np , O_RDONLY | O_NOCTTY | O_CLOEXEC | O_DIRECTORY ) ; if ( new_child_fd < 0 ) return - errno ; if ( flags & BTRFS_SNAPSHOT_READ_ONLY ) { if ( subvolume_fd < 0 ) { subvolume_fd = openat ( new_fd , subvolume , O_RDONLY | O_NOCTTY | O_CLOEXEC | O_DIRECTORY ) ; if ( subvolume_fd < 0 ) return - errno ; } r = btrfs_subvol_set_read_only_fd ( subvolume_fd , false ) ; if ( r < 0 ) return r ; } if ( unlinkat ( new_child_fd , p , AT_REMOVEDIR ) < 0 ) { int k = - errno ; if ( flags & BTRFS_SNAPSHOT_READ_ONLY ) ( void ) btrfs_subvol_set_read_only_fd ( subvolume_fd , true ) ; return k ; } r = subvol_snapshot_children ( old_child_fd , new_child_fd , p , sh -> objectid , flags & ~ BTRFS_SNAPSHOT_FALLBACK_COPY ) ; if ( flags & BTRFS_SNAPSHOT_READ_ONLY ) { int k ; k = btrfs_subvol_set_read_only_fd ( subvolume_fd , true ) ; if ( r >= 0 && k < 0 ) return k ; } if ( r < 0 ) return r ; } if ( ! btrfs_ioctl_search_args_inc ( & args ) ) break ; } if ( flags & BTRFS_SNAPSHOT_QUOTA ) ( void ) copy_subtree_quota_limits ( new_fd , old_subvol_id , new_subvol_id ) ; return 0 ; } | <S2SV_ModStart> ino_args . name <S2SV_ModEnd> ) ; if |
5,725 | CWE-000 static int qpnp_lcdb_parse_dt ( struct qpnp_lcdb * lcdb ) { int rc = 0 ; const char * label ; struct device_node * revid_dev_node , * temp , * node = lcdb -> dev -> of_node ; revid_dev_node = of_parse_phandle ( node , "qcom,pmic-revid" , 0 ) ; if ( ! revid_dev_node ) { pr_err ( "Missing<S2SV_blank>qcom,pmic-revid<S2SV_blank>property<S2SV_blank>-<S2SV_blank>fail<S2SV_blank>driver\\n" ) ; return - EINVAL ; } lcdb -> pmic_rev_id = get_revid_data ( revid_dev_node ) ; if ( IS_ERR ( lcdb -> pmic_rev_id ) ) { pr_debug ( "Unable<S2SV_blank>to<S2SV_blank>get<S2SV_blank>revid<S2SV_blank>data\\n" ) ; of_node_put ( revid_dev_node ) ; return - EPROBE_DEFER ; } of_node_put ( revid_dev_node ) ; for_each_available_child_of_node ( node , temp ) { rc = of_property_read_string ( temp , "label" , & label ) ; if ( rc < 0 ) { pr_err ( "Failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>label<S2SV_blank>rc=%d\\n" , rc ) ; return rc ; } if ( ! strcmp ( label , "ldo" ) ) { lcdb -> ldo . node = temp ; rc = qpnp_lcdb_ldo_dt_init ( lcdb ) ; } else if ( ! strcmp ( label , "ncp" ) ) { lcdb -> ncp . node = temp ; rc = qpnp_lcdb_ncp_dt_init ( lcdb ) ; } else if ( ! strcmp ( label , "bst" ) ) { lcdb -> bst . node = temp ; rc = qpnp_lcdb_bst_dt_init ( lcdb ) ; } else { pr_err ( "Failed<S2SV_blank>to<S2SV_blank>identify<S2SV_blank>label<S2SV_blank>%s\\n" , label ) ; return - EINVAL ; } if ( rc < 0 ) { pr_err ( "Failed<S2SV_blank>to<S2SV_blank>register<S2SV_blank>%s<S2SV_blank>module\\n" , label ) ; return rc ; } } <S2SV_StartBug> if ( of_property_read_bool ( node , "qcom,ttw-enable" ) ) { <S2SV_EndBug> rc = qpnp_lcdb_parse_ttw ( lcdb ) ; if ( rc < 0 ) { pr_err ( "Failed<S2SV_blank>to<S2SV_blank>parse<S2SV_blank>ttw-params<S2SV_blank>rc=%d\\n" , rc ) ; return rc ; } lcdb -> ttw_enable = true ; } lcdb -> sc_irq = platform_get_irq_byname ( lcdb -> pdev , "sc-irq" ) ; if ( lcdb -> sc_irq < 0 ) pr_debug ( "sc<S2SV_blank>irq<S2SV_blank>is<S2SV_blank>not<S2SV_blank>defined\\n" ) ; return rc ; } | <S2SV_ModStart> ; } } lcdb -> force_module_reenable = of_property_read_bool ( node , "qcom,force-module-reenable" ) ; |
5,726 | CWE-000 libbe_handle_t * libbe_init ( void ) { struct stat sb ; dev_t root_dev , boot_dev ; libbe_handle_t * lbh ; zfs_handle_t * rootds ; char * poolname , * pos ; int pnamelen ; lbh = NULL ; poolname = pos = NULL ; pnamelen = 0 ; rootds = NULL ; if ( stat ( "/" , & sb ) != 0 ) goto err ; root_dev = sb . st_dev ; if ( stat ( "/boot" , & sb ) != 0 ) goto err ; boot_dev = sb . st_dev ; if ( root_dev != boot_dev ) { fprintf ( stderr , "/<S2SV_blank>and<S2SV_blank>/boot<S2SV_blank>not<S2SV_blank>on<S2SV_blank>same<S2SV_blank>device,<S2SV_blank>quitting\\n" ) ; goto err ; } if ( ( lbh = calloc ( 1 , sizeof ( libbe_handle_t ) ) ) == NULL ) goto err ; if ( ( lbh -> lzh = libzfs_init ( ) ) == NULL ) goto err ; if ( ( kenv ( KENV_GET , "zfs_be_root" , lbh -> root , BE_MAXPATHLEN ) ) == - 1 ) goto err ; if ( strcmp ( lbh -> root , "zfs:" ) == 0 ) <S2SV_StartBug> strncpy ( lbh -> root , strchr ( lbh -> root , ':' ) + sizeof ( char ) , <S2SV_EndBug> <S2SV_StartBug> BE_MAXPATHLEN ) ; <S2SV_EndBug> if ( ( pos = strchr ( lbh -> root , '/' ) ) == NULL ) goto err ; pnamelen = pos - lbh -> root ; poolname = malloc ( pnamelen + 1 ) ; if ( poolname == NULL ) goto err ; strncpy ( poolname , lbh -> root , pnamelen ) ; poolname [ pnamelen ] = '\\0' ; if ( ( lbh -> active_phandle = zpool_open ( lbh -> lzh , poolname ) ) == NULL ) goto err ; if ( zpool_get_prop ( lbh -> active_phandle , ZPOOL_PROP_BOOTFS , lbh -> bootfs , BE_MAXPATHLEN , NULL , true ) != 0 ) goto err ; if ( ( rootds = zfs_open ( lbh -> lzh , lbh -> root , ZFS_TYPE_DATASET ) ) == NULL ) goto err ; zfs_iter_filesystems ( rootds , be_locate_rootfs , lbh ) ; zfs_close ( rootds ) ; rootds = NULL ; if ( * lbh -> rootfs == '\\0' ) goto err ; return ( lbh ) ; err : if ( lbh != NULL ) { if ( lbh -> active_phandle != NULL ) zpool_close ( lbh -> active_phandle ) ; if ( lbh -> lzh != NULL ) libzfs_fini ( lbh -> lzh ) ; free ( lbh ) ; } <S2SV_StartBug> if ( rootds != NULL ) <S2SV_EndBug> zfs_close ( rootds ) ; free ( poolname ) ; return ( NULL ) ; } | <S2SV_ModStart> == 0 ) strlcpy <S2SV_ModEnd> ( lbh -> <S2SV_ModStart> ) , BE_MAXPATHLEN + 1 <S2SV_ModStart> ) ; } <S2SV_ModEnd> free ( poolname |
5,727 | CWE-000 static REPROC_ERROR wait_timeout ( pid_t pid , unsigned int timeout , unsigned int * exit_status ) { assert ( timeout > 0 ) ; REPROC_ERROR error = REPROC_SUCCESS ; <S2SV_StartBug> error = wait_no_hang ( pid , exit_status ) ; <S2SV_EndBug> if ( error != REPROC_WAIT_TIMEOUT ) { return error ; } pid_t timeout_pid = 0 ; error = fork_timeout ( timeout , pid , & timeout_pid ) ; if ( error ) { return error ; } int status = 0 ; errno = 0 ; pid_t exit_pid = waitpid ( - pid , & status , 0 ) ; if ( exit_pid == timeout_pid ) { return REPROC_WAIT_TIMEOUT ; } errno = 0 ; if ( kill ( timeout_pid , SIGTERM ) == - 1 ) { return REPROC_UNKNOWN_ERROR ; } errno = 0 ; if ( waitpid ( timeout_pid , NULL , 0 ) == - 1 ) { switch ( errno ) { case EINTR : return REPROC_INTERRUPTED ; default : return REPROC_UNKNOWN_ERROR ; } } if ( exit_pid == - 1 ) { switch ( errno ) { case EINTR : return REPROC_INTERRUPTED ; default : return REPROC_UNKNOWN_ERROR ; } } if ( exit_status ) { * exit_status = parse_exit_status ( status ) ; } return REPROC_SUCCESS ; } | <S2SV_ModStart> = REPROC_SUCCESS ; <S2SV_ModEnd> pid_t timeout_pid = |
5,728 | CWE-000 static rsRetVal thrdTerminateNonCancel ( thrdInfo_t * pThis ) { struct timespec tTimeout ; int ret ; int was_active ; DEFiRet ; assert ( pThis != NULL ) ; DBGPRINTF ( "request<S2SV_blank>term<S2SV_blank>via<S2SV_blank>SIGTTIN<S2SV_blank>for<S2SV_blank>input<S2SV_blank>thread<S2SV_blank>\'%s\'<S2SV_blank>%p\\n" , pThis -> name , ( void * ) pThis -> thrdID ) ; pThis -> bShallStop = RSTRUE ; <S2SV_StartBug> timeoutComp ( & tTimeout , glblInputTimeoutShutdown ) ; <S2SV_EndBug> d_pthread_mutex_lock ( & pThis -> mutThrd ) ; was_active = pThis -> bIsActive ; while ( was_active ) { if ( dbgTimeoutToStderr ) { fprintf ( stderr , "rsyslogd<S2SV_blank>debug:<S2SV_blank>info:<S2SV_blank>trying<S2SV_blank>to<S2SV_blank>kill<S2SV_blank>input<S2SV_blank>%s,<S2SV_blank>timeout<S2SV_blank>%d<S2SV_blank>ms\\n" , pThis -> name , glblInputTimeoutShutdown ) ; } DBGPRINTF ( "thread<S2SV_blank>%s:<S2SV_blank>initiating<S2SV_blank>termination,<S2SV_blank>timeout<S2SV_blank>%d<S2SV_blank>ms\\n" , pThis -> name , glblInputTimeoutShutdown ) ; pthread_kill ( pThis -> thrdID , SIGTTIN ) ; ret = d_pthread_cond_timedwait ( & pThis -> condThrdTerm , & pThis -> mutThrd , & tTimeout ) ; if ( ret == ETIMEDOUT ) { DBGPRINTF ( "input<S2SV_blank>thread<S2SV_blank>term:<S2SV_blank>timeout<S2SV_blank>expired<S2SV_blank>waiting<S2SV_blank>on<S2SV_blank>thread<S2SV_blank>%s<S2SV_blank>" "termination<S2SV_blank>-<S2SV_blank>canceling\\n" , pThis -> name ) ; if ( dbgTimeoutToStderr ) { fprintf ( stderr , "rsyslogd<S2SV_blank>debug:<S2SV_blank>input<S2SV_blank>thread<S2SV_blank>term:<S2SV_blank>" "timeout<S2SV_blank>expired<S2SV_blank>waiting<S2SV_blank>on<S2SV_blank>thread<S2SV_blank>%s<S2SV_blank>" "termination<S2SV_blank>-<S2SV_blank>canceling\\n" , pThis -> name ) ; } pthread_cancel ( pThis -> thrdID ) ; break ; } else if ( ret != 0 ) { char errStr [ 1024 ] ; int err = errno ; rs_strerror_r ( err , errStr , sizeof ( errStr ) ) ; DBGPRINTF ( "input<S2SV_blank>thread<S2SV_blank>term:<S2SV_blank>cond_wait<S2SV_blank>returned<S2SV_blank>with<S2SV_blank>error<S2SV_blank>%d:<S2SV_blank>%s\\n" , err , errStr ) ; } was_active = pThis -> bIsActive ; } d_pthread_mutex_unlock ( & pThis -> mutThrd ) ; if ( was_active ) { DBGPRINTF ( "non-cancel<S2SV_blank>input<S2SV_blank>thread<S2SV_blank>termination<S2SV_blank>FAILED<S2SV_blank>for<S2SV_blank>thread<S2SV_blank>%s<S2SV_blank>%p\\n" , pThis -> name , ( void * ) pThis -> thrdID ) ; } else { DBGPRINTF ( "non-cancel<S2SV_blank>input<S2SV_blank>thread<S2SV_blank>termination<S2SV_blank>succeeded<S2SV_blank>for<S2SV_blank>thread<S2SV_blank>%s<S2SV_blank>%p\\n" , pThis -> name , ( void * ) pThis -> thrdID ) ; } RETiRet ; } | <S2SV_ModStart> = RSTRUE ; d_pthread_mutex_lock ( & pThis -> mutThrd ) ; <S2SV_ModStart> tTimeout , glblInputTimeoutShutdown <S2SV_ModEnd> ) ; was_active |
5,729 | CWE-000 static void internal_co_reduce ( MPI_Op op , gfc_descriptor_t * source , int result_image , int * stat , <S2SV_StartBug> char * errmsg , int src_len , int errmsg_len ) <S2SV_EndBug> { size_t i , size ; int j , ierr ; int rank = GFC_DESCRIPTOR_RANK ( source ) ; MPI_Datatype datatype = get_MPI_datatype ( source , src_len ) ; size = 1 ; for ( j = 0 ; j < rank ; j ++ ) { ptrdiff_t dimextent = source -> dim [ j ] . _ubound - source -> dim [ j ] . lower_bound + 1 ; if ( dimextent < 0 ) dimextent = 0 ; size *= dimextent ; } if ( rank == 0 || PREFIX ( is_contiguous ) ( source ) ) { if ( result_image == 0 ) ierr = MPI_Allreduce ( MPI_IN_PLACE , source -> base_addr , size , datatype , op , CAF_COMM_WORLD ) ; else if ( result_image == caf_this_image ) ierr = MPI_Reduce ( MPI_IN_PLACE , source -> base_addr , size , datatype , op , result_image - 1 , CAF_COMM_WORLD ) ; else ierr = MPI_Reduce ( source -> base_addr , NULL , size , datatype , op , result_image - 1 , CAF_COMM_WORLD ) ; if ( ierr ) goto error ; goto co_reduce_cleanup ; } for ( i = 0 ; i < size ; i ++ ) { ptrdiff_t array_offset_sr = 0 ; ptrdiff_t stride = 1 ; ptrdiff_t extent = 1 ; for ( j = 0 ; j < GFC_DESCRIPTOR_RANK ( source ) - 1 ; j ++ ) { array_offset_sr += ( ( i / ( extent * stride ) ) % ( source -> dim [ j ] . _ubound - source -> dim [ j ] . lower_bound + 1 ) ) * source -> dim [ j ] . _stride ; extent = ( source -> dim [ j ] . _ubound - source -> dim [ j ] . lower_bound + 1 ) ; stride = source -> dim [ j ] . _stride ; } array_offset_sr += ( i / extent ) * source -> dim [ rank - 1 ] . _stride ; void * sr = ( void * ) ( ( char * ) source -> base_addr + array_offset_sr * GFC_DESCRIPTOR_SIZE ( source ) ) ; if ( result_image == 0 ) ierr = MPI_Allreduce ( MPI_IN_PLACE , sr , 1 , datatype , op , CAF_COMM_WORLD ) ; else if ( result_image == caf_this_image ) ierr = MPI_Reduce ( MPI_IN_PLACE , sr , 1 , datatype , op , result_image - 1 , CAF_COMM_WORLD ) ; else ierr = MPI_Reduce ( sr , NULL , 1 , datatype , op , result_image - 1 , CAF_COMM_WORLD ) ; if ( ierr ) goto error ; } co_reduce_cleanup : if ( GFC_DESCRIPTOR_TYPE ( source ) == BT_CHARACTER ) MPI_Type_free ( & datatype ) ; if ( stat ) * stat = 0 ; return ; error : if ( stat ) { * stat = ierr ; if ( ! errmsg ) return ; } int len = sizeof ( err_buffer ) ; MPI_Error_string ( ierr , err_buffer , & len ) ; if ( ! stat ) { err_buffer [ len == sizeof ( err_buffer ) ? len - 1 : len ] = '\\0' ; caf_runtime_error ( "CO_SUM<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>%s\\n" , err_buffer ) ; } memcpy ( errmsg , err_buffer , errmsg_len > len ? len : errmsg_len ) ; if ( errmsg_len > len ) memset ( & errmsg [ len ] , '\\0' , errmsg_len - len ) ; } | <S2SV_ModStart> int src_len , size_t <S2SV_ModEnd> errmsg_len ) { |
5,730 | CWE-000 static GPtrArray * fuzzy_generate_commands ( struct rspamd_task * task , struct fuzzy_rule * rule , gint c , gint flag , guint32 value ) { struct rspamd_mime_text_part * part ; struct rspamd_mime_part * mime_part ; struct rspamd_image * image ; struct fuzzy_cmd_io * io ; guint i ; GPtrArray * res ; res = g_ptr_array_sized_new ( task -> parts -> len + 1 ) ; if ( c == FUZZY_STAT ) { io = fuzzy_cmd_stat ( rule , c , flag , value , task -> task_pool ) ; if ( io ) { g_ptr_array_add ( res , io ) ; } goto end ; } for ( i = 0 ; i < task -> text_parts -> len ; i ++ ) { part = g_ptr_array_index ( task -> text_parts , i ) ; if ( IS_PART_EMPTY ( part ) ) { continue ; } if ( fuzzy_module_ctx -> min_bytes > part -> content -> len ) { msg_info_task ( "<%s>,<S2SV_blank>part<S2SV_blank>is<S2SV_blank>shorter<S2SV_blank>than<S2SV_blank>%d<S2SV_blank>bytes<S2SV_blank>(%d<S2SV_blank>bytes),<S2SV_blank>" "skip<S2SV_blank>fuzzy<S2SV_blank>check" , task -> message_id , fuzzy_module_ctx -> min_bytes , part -> content -> len ) ; continue ; } if ( part -> normalized_words == NULL || part -> normalized_words -> len == 0 ) { msg_info_task ( "<%s>,<S2SV_blank>part<S2SV_blank>hash<S2SV_blank>empty,<S2SV_blank>skip<S2SV_blank>fuzzy<S2SV_blank>check" , task -> message_id ) ; continue ; } if ( fuzzy_module_ctx -> min_hash_len != 0 && part -> normalized_words -> len < fuzzy_module_ctx -> min_hash_len ) { msg_info_task ( "<%s>,<S2SV_blank>part<S2SV_blank>hash<S2SV_blank>is<S2SV_blank>shorter<S2SV_blank>than<S2SV_blank>%d<S2SV_blank>symbols,<S2SV_blank>skip<S2SV_blank>fuzzy<S2SV_blank>check" , task -> message_id , fuzzy_module_ctx -> min_hash_len ) ; continue ; } io = fuzzy_cmd_from_text_part ( rule , c , flag , value , task -> task_pool , part ) ; if ( io ) { g_ptr_array_add ( res , io ) ; } } for ( i = 0 ; i < task -> parts -> len ; i ++ ) { mime_part = g_ptr_array_index ( task -> parts , i ) ; if ( mime_part -> flags & RSPAMD_MIME_PART_IMAGE ) { image = mime_part -> specific . img ; if ( image -> data -> len > 0 ) { if ( fuzzy_module_ctx -> min_height <= 0 || image -> height >= fuzzy_module_ctx -> min_height ) { if ( fuzzy_module_ctx -> min_width <= 0 || image -> width >= fuzzy_module_ctx -> min_width ) { io = fuzzy_cmd_from_data_part ( rule , c , flag , value , task -> task_pool , image -> parent -> digest ) ; if ( io ) { g_ptr_array_add ( res , io ) ; } <S2SV_StartBug> if ( image -> is_normalized ) { <S2SV_EndBug> io = fuzzy_cmd_from_image_part ( rule , c , flag , value , task -> task_pool , image ) ; if ( io ) { g_ptr_array_add ( res , io ) ; } } } } } } if ( mime_part -> parsed_data . len > 0 && fuzzy_check_content_type ( rule , mime_part -> ct ) ) { if ( fuzzy_module_ctx -> min_bytes <= 0 || mime_part -> parsed_data . len >= fuzzy_module_ctx -> min_bytes ) { io = fuzzy_cmd_from_data_part ( rule , c , flag , value , task -> task_pool , mime_part -> digest ) ; if ( io ) { g_ptr_array_add ( res , io ) ; } } } } # if 0 io = fuzzy_cmd_from_task_meta ( rule , c , flag , value , task -> task_pool , task ) ; if ( io ) { g_ptr_array_add ( res , io ) ; } # endif end : if ( res -> len == 0 ) { g_ptr_array_free ( res , FALSE ) ; return NULL ; } return res ; } | <S2SV_ModStart> } if ( rule -> fuzzy_images ) { if ( ! image -> is_normalized ) { rspamd_image_normalize ( task , image ) ; } } if ( |
5,731 | CWE-000 static void mini_regression_step ( MonoImage * image , int verbose , int * total_run , int * total , guint32 opt_flags , GTimer * timer , MonoDomain * domain ) { int result , expected , failed , cfailed , run , code_size ; TestMethod func ; double elapsed , comp_time , start_time ; char * n ; int i ; mono_set_defaults ( verbose , opt_flags ) ; n = mono_opt_descr ( opt_flags ) ; g_print ( "Test<S2SV_blank>run:<S2SV_blank>image=%s,<S2SV_blank>opts=%s\\n" , mono_image_get_filename ( image ) , n ) ; g_free ( n ) ; cfailed = failed = run = code_size = 0 ; comp_time = elapsed = 0.0 ; if ( domain_jit_info ( domain ) ) { g_hash_table_destroy ( domain_jit_info ( domain ) -> jit_trampoline_hash ) ; domain_jit_info ( domain ) -> jit_trampoline_hash = g_hash_table_new ( mono_aligned_addr_hash , NULL ) ; mono_internal_hash_table_destroy ( & ( domain -> jit_code_hash ) ) ; mono_jit_code_hash_init ( & ( domain -> jit_code_hash ) ) ; } g_timer_start ( timer ) ; if ( mini_stats_fd ) fprintf ( mini_stats_fd , "[" ) ; for ( i = 0 ; i < mono_image_get_table_rows ( image , MONO_TABLE_METHOD ) ; ++ i ) { ERROR_DECL ( error ) ; MonoMethod * method = mono_get_method_checked ( image , MONO_TOKEN_METHOD_DEF | ( i + 1 ) , NULL , NULL , error ) ; if ( ! method ) { mono_error_cleanup ( error ) ; continue ; } if ( strncmp ( method -> name , "test_" , 5 ) == 0 ) { MonoCompile * cfg ; expected = atoi ( method -> name + 5 ) ; run ++ ; start_time = g_timer_elapsed ( timer , NULL ) ; comp_time -= start_time ; cfg = mini_method_compile ( method , mono_get_optimizations_for_method ( method , opt_flags ) , mono_get_root_domain ( ) , JIT_FLAG_RUN_CCTORS , 0 , - 1 ) ; comp_time += g_timer_elapsed ( timer , NULL ) ; if ( cfg -> exception_type == MONO_EXCEPTION_NONE ) { if ( verbose >= 2 ) g_print ( "Running<S2SV_blank>\'%s\'<S2SV_blank>...\\n" , method -> name ) ; # ifdef MONO_USE_AOT_COMPILER ERROR_DECL ( error ) ; func = ( TestMethod ) mono_aot_get_method ( mono_get_root_domain ( ) , method , error ) ; mono_error_cleanup ( error ) ; if ( ! func ) func = ( TestMethod ) ( gpointer ) cfg -> native_code ; # else func = ( TestMethod ) ( gpointer ) cfg -> native_code ; # endif <S2SV_StartBug> func = ( TestMethod ) mono_create_ftnptr ( mono_get_root_domain ( ) , func ) ; <S2SV_EndBug> result = func ( ) ; if ( result != expected ) { failed ++ ; g_print ( "Test<S2SV_blank>\'%s\'<S2SV_blank>failed<S2SV_blank>result<S2SV_blank>(got<S2SV_blank>%d,<S2SV_blank>expected<S2SV_blank>%d).\\n" , method -> name , result , expected ) ; } code_size += cfg -> code_len ; mono_destroy_compile ( cfg ) ; } else { cfailed ++ ; g_print ( "Test<S2SV_blank>\'%s\'<S2SV_blank>failed<S2SV_blank>compilation.\\n" , method -> name ) ; } if ( mini_stats_fd ) fprintf ( mini_stats_fd , "%f,<S2SV_blank>" , g_timer_elapsed ( timer , NULL ) - start_time ) ; } } if ( mini_stats_fd ) fprintf ( mini_stats_fd , "],\\n" ) ; g_timer_stop ( timer ) ; elapsed = g_timer_elapsed ( timer , NULL ) ; if ( failed > 0 || cfailed > 0 ) { g_print ( "Results:<S2SV_blank>total<S2SV_blank>tests:<S2SV_blank>%d,<S2SV_blank>failed:<S2SV_blank>%d,<S2SV_blank>cfailed:<S2SV_blank>%d<S2SV_blank>(pass:<S2SV_blank>%.2f%%)\\n" , run , failed , cfailed , 100.0 * ( run - failed - cfailed ) / run ) ; } else { g_print ( "Results:<S2SV_blank>total<S2SV_blank>tests:<S2SV_blank>%d,<S2SV_blank>all<S2SV_blank>pass<S2SV_blank>\\n" , run ) ; } g_print ( "Elapsed<S2SV_blank>time:<S2SV_blank>%f<S2SV_blank>secs<S2SV_blank>(%f,<S2SV_blank>%f),<S2SV_blank>Code<S2SV_blank>size:<S2SV_blank>%d\\n\\n" , elapsed , elapsed - comp_time , comp_time , code_size ) ; * total += failed + cfailed ; * total_run += run ; } | <S2SV_ModStart> ( ) , ( gpointer ) |
5,732 | CWE-000 void usb_disconnect ( struct usb_device * * pdev ) { struct usb_device * udev = * pdev ; struct usb_hub * hub = usb_hub_to_struct_hub ( udev ) ; int i ; usb_set_device_state ( udev , USB_STATE_NOTATTACHED ) ; dev_info ( & udev -> dev , "USB<S2SV_blank>disconnect,<S2SV_blank>device<S2SV_blank>number<S2SV_blank>%d\\n" , udev -> devnum ) ; # ifdef CONFIG_USB_OTG if ( udev -> bus -> hnp_support && udev -> portnum == udev -> bus -> otg_port ) { cancel_delayed_work_sync ( & udev -> bus -> hnp_polling ) ; udev -> bus -> hnp_support = 0 ; } <S2SV_StartBug> # endif <S2SV_EndBug> usb_lock_device ( udev ) ; for ( i = 0 ; i < udev -> maxchild ; i ++ ) { if ( hub && hub -> ports [ i ] -> child ) usb_disconnect ( & hub -> ports [ i ] -> child ) ; } dev_dbg ( & udev -> dev , "unregistering<S2SV_blank>device\\n" ) ; usb_disable_device ( udev , 0 ) ; usb_hcd_synchronize_unlinks ( udev ) ; if ( udev -> parent ) { struct usb_hub * hub = usb_hub_to_struct_hub ( udev -> parent ) ; struct usb_port * port_dev = NULL ; if ( hub ) port_dev = hub -> ports [ udev -> portnum - 1 ] ; sysfs_remove_link ( & udev -> dev . kobj , "port" ) ; if ( port_dev ) { sysfs_remove_link ( & port_dev -> dev . kobj , "device" ) ; if ( ! port_dev -> did_runtime_put ) pm_runtime_put ( & port_dev -> dev ) ; else port_dev -> did_runtime_put = false ; } } usb_remove_ep_devs ( & udev -> ep0 ) ; usb_unlock_device ( udev ) ; device_del ( & udev -> dev ) ; release_devnum ( udev ) ; spin_lock_irq ( & device_state_lock ) ; * pdev = NULL ; spin_unlock_irq ( & device_state_lock ) ; hub_free_dev ( udev ) ; put_device ( & udev -> dev ) ; } | <S2SV_ModStart> } # endif pm_runtime_barrier ( & udev -> dev ) ; |
5,733 | CWE-000 static int query_info ( const unsigned int xid , struct cifs_tcon * tcon , u64 persistent_fid , u64 volatile_fid , u8 info_class , u8 info_type , u32 additional_info , size_t output_len , size_t min_len , void * * data , u32 * dlen ) { struct smb_rqst rqst ; struct smb2_query_info_rsp * rsp = NULL ; struct kvec iov [ 1 ] ; struct kvec rsp_iov ; int rc = 0 ; <S2SV_StartBug> int resp_buftype ; <S2SV_EndBug> struct cifs_ses * ses = tcon -> ses ; int flags = 0 ; cifs_dbg ( FYI , "Query<S2SV_blank>Info\\n" ) ; if ( ! ses || ! ( ses -> server ) ) return - EIO ; if ( smb3_encryption_required ( tcon ) ) flags |= CIFS_TRANSFORM_REQ ; memset ( & rqst , 0 , sizeof ( struct smb_rqst ) ) ; memset ( & iov , 0 , sizeof ( iov ) ) ; rqst . rq_iov = iov ; rqst . rq_nvec = 1 ; rc = SMB2_query_info_init ( tcon , & rqst , persistent_fid , volatile_fid , info_class , info_type , additional_info , output_len ) ; if ( rc ) goto qinf_exit ; rc = cifs_send_recv ( xid , ses , & rqst , & resp_buftype , flags , & rsp_iov ) ; rsp = ( struct smb2_query_info_rsp * ) rsp_iov . iov_base ; if ( rc ) { cifs_stats_fail_inc ( tcon , SMB2_QUERY_INFO_HE ) ; trace_smb3_query_info_err ( xid , persistent_fid , tcon -> tid , ses -> Suid , info_class , ( __u32 ) info_type , rc ) ; goto qinf_exit ; } if ( dlen ) { * dlen = le32_to_cpu ( rsp -> OutputBufferLength ) ; if ( ! * data ) { * data = kmalloc ( * dlen , GFP_KERNEL ) ; if ( ! * data ) { cifs_dbg ( VFS , "Error<S2SV_blank>%d<S2SV_blank>allocating<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>acl\\n" , rc ) ; * dlen = 0 ; goto qinf_exit ; } } } rc = smb2_validate_and_copy_iov ( le16_to_cpu ( rsp -> OutputBufferOffset ) , le32_to_cpu ( rsp -> OutputBufferLength ) , & rsp_iov , min_len , * data ) ; qinf_exit : SMB2_query_info_free ( & rqst ) ; free_rsp_buf ( resp_buftype , rsp ) ; return rc ; } | <S2SV_ModStart> ; int resp_buftype = CIFS_NO_BUFFER |
5,734 | CWE-000 static int xdma_probe ( struct platform_device * pdev ) { struct xdma_device * xdev ; struct resource * res ; int err , i , j ; struct xdma_chan * chan ; struct xdma_device_config * dma_config ; int dma_chan_dir ; int dma_chan_reg_offset ; pr_info ( "%s:<S2SV_blank>probe<S2SV_blank>dma<S2SV_blank>%p,<S2SV_blank>nres<S2SV_blank>%d,<S2SV_blank>id<S2SV_blank>%d\\n" , __func__ , & pdev -> dev , pdev -> num_resources , pdev -> id ) ; xdev = devm_kzalloc ( & pdev -> dev , sizeof ( struct xdma_device ) , GFP_KERNEL ) ; if ( ! xdev ) return - ENOMEM ; xdev -> dev = & pdev -> dev ; arch_setup_dma_ops ( & pdev -> dev , 0 , 0 , NULL , false ) ; dma_set_mask ( & pdev -> dev , 0xFFFFFFFFFFFFFFFFull ) ; dma_config = ( struct xdma_device_config * ) xdev -> dev -> platform_data ; if ( dma_config -> channel_count < 1 || dma_config -> channel_count > 2 ) return - EFAULT ; res = platform_get_resource ( pdev , IORESOURCE_MEM , 0 ) ; xdev -> regs = devm_ioremap_resource ( & pdev -> dev , res ) ; if ( ! xdev -> regs ) { dev_err ( & pdev -> dev , "unable<S2SV_blank>to<S2SV_blank>iomap<S2SV_blank>registers\\n" ) ; return - EFAULT ; } dev_info ( & pdev -> dev , "AXIDMA<S2SV_blank>device<S2SV_blank>%d<S2SV_blank>physical<S2SV_blank>base<S2SV_blank>address=%pa\\n" , pdev -> id , & res -> start ) ; dev_info ( & pdev -> dev , "AXIDMA<S2SV_blank>device<S2SV_blank>%d<S2SV_blank>remapped<S2SV_blank>to<S2SV_blank>%pa\\n" , pdev -> id , & xdev -> regs ) ; dev_info ( & pdev -> dev , "has<S2SV_blank>%d<S2SV_blank>channel(s)\\n" , dma_config -> channel_count ) ; for ( i = 0 ; i < dma_config -> channel_count ; i ++ ) { chan = devm_kzalloc ( & pdev -> dev , sizeof ( * chan ) , GFP_KERNEL ) ; if ( ! chan ) return - ENOMEM ; dma_chan_dir = strcmp ( dma_config -> channel_config [ i ] . type , "axi-dma-mm2s-channel" ) ? DMA_FROM_DEVICE : DMA_TO_DEVICE ; dma_chan_reg_offset = ( dma_chan_dir == DMA_TO_DEVICE ) ? 0 : 0x30 ; chan -> id = i ; chan -> regs = xdev -> regs + dma_chan_reg_offset ; chan -> dev = xdev -> dev ; chan -> max_len = XDMA_MAX_TRANS_LEN ; chan -> direction = dma_chan_dir ; sprintf ( chan -> name , "%s:%d" , dma_config -> name , chan -> id ) ; pr_info ( "<S2SV_blank><S2SV_blank>chan<S2SV_blank>%d<S2SV_blank>name:<S2SV_blank>%s\\n" , chan -> id , chan -> name ) ; pr_info ( "<S2SV_blank><S2SV_blank>chan<S2SV_blank>%d<S2SV_blank>direction:<S2SV_blank>%s\\n" , chan -> id , dma_chan_dir == DMA_FROM_DEVICE ? "FROM_DEVICE" : "TO_DEVICE" ) ; spin_lock_init ( & chan -> lock ) ; tasklet_init ( & chan -> tasklet , xdma_tasklet , ( unsigned long ) chan ) ; tasklet_init ( & chan -> dma_err_tasklet , xdma_err_tasklet , ( unsigned long ) chan ) ; xdev -> chan [ chan -> id ] = chan ; chan -> irq = xlate_irq ( dma_config -> channel_config [ i ] . irq ) ; if ( chan -> irq <= 0 ) { pr_err ( "get_resource<S2SV_blank>for<S2SV_blank>IRQ<S2SV_blank>for<S2SV_blank>dev<S2SV_blank>%d<S2SV_blank>failed\\n" , pdev -> id ) ; return - ENODEV ; } err = devm_request_irq ( & pdev -> dev , chan -> irq , dma_chan_dir == DMA_TO_DEVICE ? xdma_tx_intr_handler : xdma_rx_intr_handler , IRQF_SHARED , pdev -> name , chan ) ; if ( err ) { dev_err ( & pdev -> dev , "unable<S2SV_blank>to<S2SV_blank>request<S2SV_blank>IRQ\\n" ) ; return err ; } pr_info ( "<S2SV_blank><S2SV_blank>chan%d<S2SV_blank>irq:<S2SV_blank>%d\\n" , chan -> id , chan -> irq ) ; chan -> poll_mode = dma_config -> channel_config [ i ] . poll_mode ; pr_info ( "<S2SV_blank><S2SV_blank>chan%d<S2SV_blank>poll<S2SV_blank>mode:<S2SV_blank>%s\\n" , chan -> id , chan -> poll_mode ? "on" : "off" ) ; err = xdma_alloc_chan_descriptors ( xdev -> chan [ chan -> id ] ) ; if ( err ) { dev_err ( & pdev -> dev , "unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>BD\'s\\n" ) ; return - ENOMEM ; } <S2SV_StartBug> pr_info ( "<S2SV_blank><S2SV_blank>chan%d<S2SV_blank>bd<S2SV_blank>ring<S2SV_blank>@<S2SV_blank>0x%08x<S2SV_blank>(size:<S2SV_blank>0x%08x<S2SV_blank>bytes)\\n" , <S2SV_EndBug> chan -> id , chan -> bd_phys_addr , chan -> bd_chain_size ) ; err = dma_init ( xdev -> chan [ chan -> id ] ) ; if ( err ) { dev_err ( & pdev -> dev , "DMA<S2SV_blank>init<S2SV_blank>failed\\n" ) ; for ( j = 0 ; j <= i ; j ++ ) xdma_free_chan_resources ( xdev -> chan [ j ] ) ; return - EIO ; } } xdev -> channel_count = dma_config -> channel_count ; pdev -> dev . release = xdma_release ; mutex_lock ( & dma_list_mutex ) ; list_add_tail ( & xdev -> node , & dma_device_list ) ; mutex_unlock ( & dma_list_mutex ) ; platform_set_drvdata ( pdev , xdev ) ; return 0 ; } | <S2SV_ModStart> } pr_info ( "<S2SV_blank><S2SV_blank>chan%d<S2SV_blank>bd<S2SV_blank>ring<S2SV_blank>@<S2SV_blank>0x%p<S2SV_blank>(size:<S2SV_blank>0x%x<S2SV_blank>bytes)\\n" , chan -> id , ( void * ) <S2SV_ModEnd> chan -> bd_phys_addr |
5,735 | CWE-000 static int netsec_netdev_stop ( struct net_device * ndev ) { struct netsec_priv * priv = netdev_priv ( ndev ) ; <S2SV_StartBug> netif_stop_queue ( priv -> ndev ) ; <S2SV_EndBug> napi_disable ( & priv -> napi ) ; netsec_write ( priv , NETSEC_REG_INTEN_CLR , ~ 0 ) ; netsec_stop_gmac ( priv ) ; free_irq ( priv -> ndev -> irq , priv ) ; netsec_uninit_pkt_dring ( priv , NETSEC_RING_TX ) ; netsec_uninit_pkt_dring ( priv , NETSEC_RING_RX ) ; phy_stop ( ndev -> phydev ) ; phy_disconnect ( ndev -> phydev ) ; pm_runtime_put_sync ( priv -> dev ) ; return 0 ; } | <S2SV_ModStart> priv -> ndev ) ; dma_wmb ( |
5,736 | CWE-000 void <S2SV_StartBug> dbuf_rele_and_unlock ( dmu_buf_impl_t * db , void * tag ) <S2SV_EndBug> { int64_t holds ; ASSERT ( MUTEX_HELD ( & db -> db_mtx ) ) ; DBUF_VERIFY ( db ) ; holds = refcount_remove ( & db -> db_holds , tag ) ; ASSERT ( holds >= 0 ) ; if ( db -> db_buf != NULL && holds == ( db -> db_level == 0 ? db -> db_dirtycnt : 0 ) ) { arc_buf_freeze ( db -> db_buf ) ; } if ( holds == db -> db_dirtycnt && db -> db_level == 0 && db -> db_user_immediate_evict ) dbuf_evict_user ( db ) ; if ( holds == 0 ) { if ( db -> db_blkid == DMU_BONUS_BLKID ) { dnode_t * dn ; boolean_t evict_dbuf = db -> db_pending_evict ; DB_DNODE_ENTER ( db ) ; dn = DB_DNODE ( db ) ; atomic_dec_32 ( & dn -> dn_dbufs_count ) ; DB_DNODE_EXIT ( db ) ; mutex_exit ( & db -> db_mtx ) ; if ( evict_dbuf ) dnode_evict_bonus ( dn ) ; dnode_rele ( dn , db ) ; } else if ( db -> db_buf == NULL ) { ASSERT ( db -> db_state == DB_UNCACHED || db -> db_state == DB_NOFILL ) ; dbuf_destroy ( db ) ; } else if ( arc_released ( db -> db_buf ) ) { dbuf_destroy ( db ) ; } else { boolean_t do_arc_evict = B_FALSE ; blkptr_t bp ; spa_t * spa = dmu_objset_spa ( db -> db_objset ) ; if ( ! DBUF_IS_CACHEABLE ( db ) && db -> db_blkptr != NULL && ! BP_IS_HOLE ( db -> db_blkptr ) && ! BP_IS_EMBEDDED ( db -> db_blkptr ) ) { do_arc_evict = B_TRUE ; bp = * db -> db_blkptr ; } if ( ! DBUF_IS_CACHEABLE ( db ) || db -> db_pending_evict ) { dbuf_destroy ( db ) ; } else if ( ! multilist_link_active ( & db -> db_cache_link ) ) { ASSERT3U ( db -> db_caching_status , == , DB_NO_CACHE ) ; dbuf_cached_state_t dcs = dbuf_include_in_metadata_cache ( db ) ? DB_DBUF_METADATA_CACHE : DB_DBUF_CACHE ; db -> db_caching_status = dcs ; multilist_insert ( dbuf_caches [ dcs ] . cache , db ) ; ( void ) refcount_add_many ( & dbuf_caches [ dcs ] . size , db -> db . db_size , db ) ; if ( dcs == DB_DBUF_METADATA_CACHE ) { DBUF_STAT_BUMP ( metadata_cache_count ) ; DBUF_STAT_MAX ( metadata_cache_size_bytes_max , refcount_count ( & dbuf_caches [ dcs ] . size ) ) ; } else { DBUF_STAT_BUMP ( cache_levels [ db -> db_level ] ) ; DBUF_STAT_BUMP ( cache_count ) ; DBUF_STAT_INCR ( cache_levels_bytes [ db -> db_level ] , db -> db . db_size ) ; DBUF_STAT_MAX ( cache_size_bytes_max , refcount_count ( & dbuf_caches [ dcs ] . size ) ) ; } mutex_exit ( & db -> db_mtx ) ; <S2SV_StartBug> if ( db -> db_caching_status == DB_DBUF_CACHE ) { <S2SV_EndBug> dbuf_evict_notify ( ) ; } } if ( do_arc_evict ) arc_freed ( spa , & bp ) ; } } else { mutex_exit ( & db -> db_mtx ) ; } } | <S2SV_ModStart> void * tag , boolean_t evicting <S2SV_ModStart> db_caching_status == DB_DBUF_CACHE && ! evicting |
5,737 | CWE-000 void PrintWc ( char * * Answers ) { unsigned int total_lines = 0 ; unsigned int total_words = 0 ; unsigned int total_bytes = 0 ; for ( int i = 0 ; i < numWorkers ; i ++ ) { if ( Answers [ i ] != NULL ) { int lines = ( int ) strtol ( Answers [ i ] , NULL , 10 ) ; int words = ( int ) strtol ( Answers [ i ] + NumDigits ( lines ) + 1 , NULL , 10 ) ; int bytes = ( int ) strtol ( Answers [ i ] + NumDigits ( lines ) + 1 + NumDigits ( words ) + 1 , NULL , 10 ) ; total_lines += lines ; total_words += words ; total_bytes += bytes ; } else { <S2SV_StartBug> printf ( "Worker%d<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>respond.<S2SV_blank>Cant<S2SV_blank>calculate<S2SV_blank>wc.\\n" , i ) ; <S2SV_EndBug> return ; } free ( Answers [ i ] ) ; } printf ( "total<S2SV_blank>number<S2SV_blank>of<S2SV_blank>lines:%d\\n" , total_lines ) ; printf ( "total<S2SV_blank>number<S2SV_blank>of<S2SV_blank>words:%d\\n" , total_words ) ; printf ( "total<S2SV_blank>number<S2SV_blank>of<S2SV_blank>bytes:%d\\n" , total_bytes ) ; } | <S2SV_ModStart> { printf ( "Worker%d<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>respond." , i ) ; printf ( "Only<S2SV_blank>a<S2SV_blank>partial<S2SV_blank>answer<S2SV_blank>will<S2SV_blank>be<S2SV_blank>printed.\\n" ) <S2SV_ModEnd> ; } free |
5,738 | CWE-000 static int nfs4Sync ( sqlite3_file * pFile , int flags ) { <S2SV_StartBug> return SQLITE_OK ; <S2SV_EndBug> } | <S2SV_ModStart> flags ) { # ifdef TRACE printf ( "sync\\n" ) ; # endif |
5,739 | CWE-000 static inline int hash ( journal_t * journal , unsigned long long block ) { struct jbd2_revoke_table_s * table = journal -> j_revoke ; <S2SV_StartBug> int hash_shift = table -> hash_shift ; <S2SV_EndBug> int hash = ( int ) block ^ ( int ) ( ( block >> 31 ) >> 1 ) ; return ( ( hash << ( hash_shift - 6 ) ) ^ ( hash >> 13 ) ^ ( hash << ( hash_shift - 12 ) ) ) & ( table -> hash_size - 1 ) ; } | <S2SV_ModStart> -> j_revoke ; return ( hash_64 ( block , <S2SV_ModEnd> table -> hash_shift <S2SV_ModStart> table -> hash_shift ) <S2SV_ModEnd> ) ; } |
5,740 | CWE-000 static void ipoib_reap_neigh ( struct work_struct * work ) { struct ipoib_dev_priv * priv = container_of ( work , struct ipoib_dev_priv , neigh_reap_task . work ) ; __ipoib_reap_neigh ( priv ) ; <S2SV_StartBug> if ( ! test_bit ( IPOIB_STOP_NEIGH_GC , & priv -> flags ) ) <S2SV_EndBug> queue_delayed_work ( priv -> wq , & priv -> neigh_reap_task , arp_tbl . gc_interval ) ; } | <S2SV_ModStart> priv ) ; <S2SV_ModEnd> queue_delayed_work ( priv |
5,741 | CWE-000 static Page cache_set ( Cache cache , const char * key , int klen , Page value ) { int len = klen ; int64_t h = calc_hash ( key , & len ) ; Slot * bucket = get_bucketp ( cache , h ) ; Slot s ; Page old = NULL ; if ( MAX_KEY_LEN < len ) { return value ; } for ( s = * bucket ; NULL != s ; s = s -> next ) { if ( h == ( int64_t ) s -> hash && len == s -> klen && <S2SV_StartBug> ( ( 0 <= len && len <= MAX_KEY_UNIQ ) || 0 == strcmp ( s -> key , key ) ) ) { <S2SV_EndBug> if ( h == ( int64_t ) s -> hash && len == s -> klen && <S2SV_StartBug> ( ( 0 <= len && len <= MAX_KEY_UNIQ ) || 0 == strcmp ( s -> key , key ) ) ) { <S2SV_EndBug> old = s -> value ; s -> value = value ; return old ; } } } if ( NULL == ( s = ( Slot ) malloc ( sizeof ( struct _Slot ) ) ) ) { return value ; } DEBUG_ALLOC ( mem_page_slot , s ) s -> hash = h ; s -> klen = len ; if ( NULL == key ) { * s -> key = '\\0' ; } else { <S2SV_StartBug> strcpy ( s -> key , key ) ; <S2SV_EndBug> } s -> value = value ; s -> next = * bucket ; * bucket = s ; return old ; } | <S2SV_ModStart> || 0 == strncmp ( s -> key , key , len <S2SV_ModEnd> ) ) ) <S2SV_ModStart> || 0 == strncmp ( s -> key , key , len <S2SV_ModEnd> ) ) ) <S2SV_ModStart> } else { strncpy ( s -> key , key , len ) ; s -> key [ len ] = '\\0' <S2SV_ModEnd> ; } s |
5,742 | CWE-000 static int _size ( int argc , char * * argv ) { ( void ) argc ; ( void ) argv ; uint64_t bytes = sdcard_spi_get_capacity ( card ) ; uint32_t gib_int = bytes / ( SDCARD_SPI_IEC_KIBI * SDCARD_SPI_IEC_KIBI * SDCARD_SPI_IEC_KIBI ) ; uint32_t gib_frac = ( ( ( ( bytes / ( SDCARD_SPI_IEC_KIBI * SDCARD_SPI_IEC_KIBI ) ) - gib_int * SDCARD_SPI_IEC_KIBI ) * SDCARD_SPI_SI_KILO ) / SDCARD_SPI_IEC_KIBI ) ; uint32_t gb_int = bytes / ( SDCARD_SPI_SI_KILO * SDCARD_SPI_SI_KILO * SDCARD_SPI_SI_KILO ) ; uint32_t gb_frac = ( bytes / ( SDCARD_SPI_SI_KILO * SDCARD_SPI_SI_KILO ) ) - ( gb_int * SDCARD_SPI_SI_KILO ) ; puts ( "\\nCard<S2SV_blank>size:<S2SV_blank>" ) ; print_u64_dec ( bytes ) ; <S2SV_StartBug> printf ( "<S2SV_blank>bytes<S2SV_blank>(%lu,%03lu<S2SV_blank>GiB<S2SV_blank>|<S2SV_blank>%lu,%03lu<S2SV_blank>GB)\\n" , gib_int , gib_frac , gb_int , gb_frac ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> ; printf ( "<S2SV_blank>bytes<S2SV_blank>(%" PRIu32 ",%03" PRIu32 "<S2SV_blank>GiB<S2SV_blank>|<S2SV_blank>%" PRIu32 ",%03" PRIu32 "<S2SV_blank>GB)\\n" <S2SV_ModEnd> , gib_int , |
5,743 | CWE-000 <S2SV_StartBug> UTILLIB_TEST_TEAR_DOWN ( ) { } <S2SV_EndBug> | <S2SV_ModStart> ( ) { utillib_slist_destroy ( UT_FIXTURE ) ; |
5,744 | CWE-000 static int open_wlantest ( void ) { int s ; struct sockaddr_un addr ; s = socket ( AF_UNIX , SOCK_SEQPACKET , 0 ) ; if ( s < 0 ) { perror ( "socket" ) ; return - 1 ; } memset ( & addr , 0 , sizeof ( addr ) ) ; addr . sun_family = AF_UNIX ; <S2SV_StartBug> strncpy ( addr . sun_path + 1 , WLANTEST_SOCK_NAME , <S2SV_EndBug> sizeof ( addr . sun_path ) - 1 ) ; if ( connect ( s , ( struct sockaddr * ) & addr , sizeof ( addr ) ) < 0 ) { perror ( "connect" ) ; close ( s ) ; return - 1 ; } return s ; } | <S2SV_ModStart> = AF_UNIX ; strlcpy <S2SV_ModEnd> ( addr . |
5,745 | CWE-000 static void do_resize_cb ( struct urcu_work * work ) { struct resize_work * resize_work = caa_container_of ( work , struct resize_work , work ) ; struct cds_lfht * ht = resize_work -> ht ; ht -> flavor -> register_thread ( ) ; <S2SV_StartBug> pthread_mutex_lock ( & ht -> resize_mutex ) ; <S2SV_EndBug> _do_cds_lfht_resize ( ht ) ; <S2SV_StartBug> pthread_mutex_unlock ( & ht -> resize_mutex ) ; <S2SV_EndBug> ht -> flavor -> unregister_thread ( ) ; poison_free ( work ) ; } | <S2SV_ModStart> ( ) ; mutex_lock <S2SV_ModEnd> ( & ht <S2SV_ModStart> ht ) ; mutex_unlock <S2SV_ModEnd> ( & ht |
5,746 | CWE-000 static int jsonGrow ( JsonString * p , u32 N ) { u64 nTotal = N < p -> nAlloc ? p -> nAlloc * 2 : p -> nAlloc + N + 10 ; char * zNew ; if ( p -> bStatic ) { if ( p -> bErr ) return 1 ; zNew = sqlite3_malloc64 ( nTotal ) ; if ( zNew == 0 ) { jsonOom ( p ) ; return SQLITE_NOMEM ; } <S2SV_StartBug> memcpy ( zNew , p -> zBuf , p -> nUsed ) ; <S2SV_EndBug> p -> zBuf = zNew ; p -> bStatic = 0 ; } else { zNew = sqlite3_realloc64 ( p -> zBuf , nTotal ) ; if ( zNew == 0 ) { jsonOom ( p ) ; return SQLITE_NOMEM ; } p -> zBuf = zNew ; } p -> nAlloc = nTotal ; return SQLITE_OK ; } | <S2SV_ModStart> -> zBuf , ( size_t ) |
5,747 | CWE-000 static int dlfb_ops_release ( struct fb_info * info , int user ) { struct dlfb_data * dlfb = info -> par ; <S2SV_StartBug> dlfb -> fb_count -- ; <S2SV_EndBug> if ( dlfb -> virtualized && ( dlfb -> fb_count == 0 ) ) schedule_delayed_work ( & dlfb -> free_framebuffer_work , HZ ) ; if ( ( dlfb -> fb_count == 0 ) && ( info -> fbdefio ) ) { fb_deferred_io_cleanup ( info ) ; kfree ( info -> fbdefio ) ; info -> fbdefio = NULL ; info -> fbops -> fb_mmap = dlfb_ops_mmap ; } dev_dbg ( info -> dev , "release,<S2SV_blank>user=%d<S2SV_blank>count=%d\\n" , user , dlfb -> fb_count ) ; <S2SV_StartBug> kref_put ( & dlfb -> kref , dlfb_free ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> -> fb_count -- <S2SV_ModEnd> ; if ( <S2SV_ModStart> fb_count ) ; <S2SV_ModEnd> return 0 ; |
5,748 | CWE-000 static void virtDBusGDBusHandlePropertyGet ( GVariant * parameters , GDBusMethodInvocation * invocation , const gchar * objectPath , virtDBusGDBusMethodData * data ) { virtDBusGDBusPropertyGetFunc getFunc = NULL ; const gchar * interface ; const gchar * name ; GVariant * value = NULL ; <S2SV_StartBug> GError * error = NULL ; <S2SV_EndBug> g_variant_get ( parameters , "(&s&s)" , & interface , & name ) ; for ( gint i = 0 ; data -> properties [ i ] . name ; i ++ ) { if ( g_str_equal ( name , data -> properties [ i ] . name ) ) { getFunc = data -> properties [ i ] . getFunc ; break ; } } if ( ! getFunc ) { g_dbus_method_invocation_return_error ( invocation , G_DBUS_ERROR , G_DBUS_ERROR_UNKNOWN_PROPERTY , "unknown<S2SV_blank>property<S2SV_blank>\'%s\'" , name ) ; return ; } getFunc ( objectPath , data -> userData , & value , & error ) ; if ( error ) { g_dbus_method_invocation_return_gerror ( invocation , error ) ; return ; } g_return_if_fail ( value ) ; g_dbus_method_invocation_return_value ( invocation , g_variant_new ( "(v)" , value ) ) ; } | <S2SV_ModStart> = NULL ; g_autoptr ( GError ) <S2SV_ModEnd> error = NULL |
5,749 | CWE-000 <S2SV_StartBug> static int __dwc3_cleanup_done_trbs ( struct dwc3 * dwc , struct dwc3_ep * dep , <S2SV_EndBug> struct dwc3_request * req , struct dwc3_trb * trb , unsigned length , const struct dwc3_event_depevt * event , int status ) <S2SV_StartBug> { <S2SV_EndBug> unsigned int count ; unsigned int s_pkt = 0 ; unsigned int trb_status ; <S2SV_StartBug> trace_dwc3_complete_trb ( dep , trb ) ; <S2SV_EndBug> if ( ( trb -> ctrl & DWC3_TRB_CTRL_HWO ) && status != - ESHUTDOWN ) dev_err ( dwc -> dev , "%s\'s<S2SV_blank>TRB<S2SV_blank>(%p)<S2SV_blank>still<S2SV_blank>owned<S2SV_blank>by<S2SV_blank>HW\\n" , dep -> name , trb ) ; count = trb -> size & DWC3_TRB_SIZE_MASK ; if ( dep -> direction ) { if ( count ) { trb_status = DWC3_TRB_SIZE_TRBSTS ( trb -> size ) ; if ( trb_status == DWC3_TRBSTS_MISSED_ISOC ) { dev_dbg ( dwc -> dev , "incomplete<S2SV_blank>IN<S2SV_blank>transfer<S2SV_blank>%s\\n" , dep -> name ) ; dep -> flags |= DWC3_EP_MISSED_ISOC ; dbg_event ( dep -> number , "MISSED<S2SV_blank>ISOC" , status ) ; } else { dev_err ( dwc -> dev , "incomplete<S2SV_blank>IN<S2SV_blank>transfer<S2SV_blank>%s\\n" , dep -> name ) ; status = - ECONNRESET ; } } else { dep -> flags &= ~ DWC3_EP_MISSED_ISOC ; } } else { if ( count && ( event -> status & DEPEVT_STATUS_SHORT ) ) s_pkt = 1 ; } << << << < HEAD req -> request . actual += length - count ; == == == = >> >> >> > 9bf46c6... usb : dwc3 : gadget : increment request -> actual once if ( s_pkt ) return 1 ; if ( ( event -> status & DEPEVT_STATUS_LST ) && ( trb -> ctrl & ( DWC3_TRB_CTRL_LST | DWC3_TRB_CTRL_HWO ) ) ) return 1 ; if ( ( event -> status & DEPEVT_STATUS_IOC ) && ( trb -> ctrl & DWC3_TRB_CTRL_IOC ) ) return 1 ; return 0 ; } | <S2SV_ModStart> * dep , << << << < HEAD <S2SV_ModStart> int status ) == == == = struct dwc3_request * req , struct dwc3_trb * trb , const struct dwc3_event_depevt * event , int status , int chain ) >> >> >> > de72ed1 ... usb : dwc3 : gadget : fix for short pkts during chained xfers <S2SV_ModStart> , trb ) ; if ( chain && ( trb -> ctrl & DWC3_TRB_CTRL_HWO ) ) trb -> ctrl &= ~ DWC3_TRB_CTRL_HWO |
5,750 | CWE-000 <S2SV_StartBug> static inline int msm_jpeg_q_in_buf ( struct msm_jpeg_q * q_p , <S2SV_EndBug> struct msm_jpeg_core_buf * buf ) { struct msm_jpeg_core_buf * buf_p ; JPEG_DBG ( "%s:%d]\\n" , __func__ , __LINE__ ) ; buf_p = kmalloc ( sizeof ( struct msm_jpeg_core_buf ) , GFP_ATOMIC ) ; if ( ! buf_p ) { JPEG_PR_ERR ( "%s:<S2SV_blank>no<S2SV_blank>mem\\n" , __func__ ) ; return - EFAULT ; } memcpy ( buf_p , buf , sizeof ( struct msm_jpeg_core_buf ) ) ; msm_jpeg_q_in ( q_p , buf_p ) ; return 0 ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> <S2SV_ModEnd> inline int msm_jpeg_q_in_buf |
5,751 | CWE-000 int pass ( t_env * env , t_pqueue instructions , t_pqueue * gaps , int pass ) { int LC ; int i ; t_pqueue_elem * elem ; i = 0 ; LC = 0 ; elem = instructions . first ; while ( i < instructions . len ) { if ( ( ( t_instruction * ) elem -> p ) -> is_lab == false ) { <S2SV_StartBug> if ( pass == 1 ) <S2SV_EndBug> <S2SV_StartBug> assemble_op_fake ( & LC , gaps , elem -> p ) ; <S2SV_EndBug> if ( pass == 2 ) <S2SV_StartBug> assemble_op ( env -> champion , & LC , gaps , elem -> p ) ; <S2SV_EndBug> printf ( "the<S2SV_blank>LC<S2SV_blank>is<S2SV_blank>%d\\n" , LC ) ; } else if ( pass == 1 ) store_label ( LC , ( t_label * ) elem -> p ) ; elem = elem -> next ; i ++ ; } return ( LC ) ; } | <S2SV_ModStart> pass == 1 && assemble_op_fake ( env , <S2SV_ModEnd> & LC , <S2SV_ModStart> elem -> p ) ) return ( 0 <S2SV_ModStart> assemble_op ( env <S2SV_ModEnd> , & LC |
5,752 | CWE-000 static int st_num_comp ( lua_State * L ) { st_func_t * f = lua_to_st_func ( L , 1 ) ; <S2SV_StartBug> lua_pushnumber ( L , ( double ) st_func_num_comp ( f ) ) ; <S2SV_EndBug> return 1 ; } | <S2SV_ModStart> ( double ) ( <S2SV_ModStart> st_func_num_comp ( f ) |
5,753 | CWE-000 static uint32_t BME280_compensate_P ( const int32_t adcPres , const int32_t tFine ) { int64_t var1 , var2 , p = 0LL ; var1 = ( int64_t ) tFine - 128000 ; var2 = var1 * var1 * ( int64_t ) bme280Cal . p6 ; var2 = var2 + ( ( var1 * ( int64_t ) bme280Cal . p5 ) << 17 ) ; var2 = var2 + ( ( int64_t ) bme280Cal . p4 << 35 ) ; var1 = ( ( var1 * var1 * ( int64_t ) bme280Cal . p3 ) >> 8 ) + ( ( var1 * ( int64_t ) bme280Cal . p2 ) << 12 ) ; var1 = ( ( 1LL << 47 ) + var1 ) * ( ( int64_t ) bme280Cal . p1 ) >> 33 ; if ( var1 != 0LL ) { <S2SV_StartBug> int32_t p13 ; <S2SV_EndBug> p = 1048576 - adcPres ; <S2SV_StartBug> p = ( ( ( p << 31 ) - var2 ) * 3125 ) / var1 ; <S2SV_EndBug> p13 = p >> 13 ; var1 = ( ( int64_t ) bme280Cal . p9 * p13 * p13 ) >> 25 ; var2 = ( ( int64_t ) bme280Cal . p8 * p ) >> 19 ; p = ( ( p + var1 + var2 ) >> 8 ) + ( ( int64_t ) bme280Cal . p7 << 4 ) ; } return ( uint32_t ) p ; } | <S2SV_ModStart> 0LL ) { int64_t p13 ; p = 1048576LL - ( int64_t ) <S2SV_ModEnd> adcPres ; p <S2SV_ModStart> var2 ) * 3125LL <S2SV_ModEnd> ) / var1 |
5,754 | CWE-000 <S2SV_StartBug> static void remove_orphaned_files ( struct manifest * official_manifest ) <S2SV_EndBug> { int ret ; struct list * iter ; official_manifest -> files = list_sort ( official_manifest -> files , file_sort_filename_reverse ) ; iter = list_head ( official_manifest -> files ) ; while ( iter ) { struct file * file ; char * fullname ; char * base ; struct stat sb ; int fd ; file = iter -> data ; iter = iter -> next ; if ( ! file -> is_deleted || file -> is_config || file -> is_ghosted ) { continue ; } if ( ignore ( file ) ) { continue ; } fullname = mk_full_filename ( path_prefix , file -> filename ) ; if ( lstat ( fullname , & sb ) != 0 ) { <S2SV_StartBug> free_string ( & fullname ) ; <S2SV_EndBug> continue ; } <S2SV_StartBug> counts . extraneous ++ ; <S2SV_EndBug> fd = get_dirfd_path ( fullname ) ; if ( fd < 0 ) { fprintf ( stderr , "Not<S2SV_blank>safe<S2SV_blank>to<S2SV_blank>delete:<S2SV_blank>%s\\n" , fullname ) ; free_string ( & fullname ) ; counts . not_deleted ++ ; continue ; } base = basename ( fullname ) ; if ( ! S_ISDIR ( sb . st_mode ) ) { ret = unlinkat ( fd , base , 0 ) ; if ( ret && errno != ENOENT ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>remove<S2SV_blank>%s<S2SV_blank>(%i:<S2SV_blank>%s)\\n" , fullname , errno , strerror ( errno ) ) ; counts . not_deleted ++ ; } else { <S2SV_StartBug> fprintf ( stderr , "Deleted<S2SV_blank>%s\\n" , fullname ) ; <S2SV_EndBug> counts . deleted ++ ; } } else { ret = unlinkat ( fd , base , AT_REMOVEDIR ) ; if ( ret ) { counts . not_deleted ++ ; if ( errno != ENOTEMPTY ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>remove<S2SV_blank>empty<S2SV_blank>folder<S2SV_blank>%s<S2SV_blank>(%i:<S2SV_blank>%s)\\n" , fullname , errno , strerror ( errno ) ) ; } else { fprintf ( stderr , "Couldn\'t<S2SV_blank>remove<S2SV_blank>directory<S2SV_blank>containing<S2SV_blank>untracked<S2SV_blank>files:<S2SV_blank>%s\\n" , fullname ) ; } } else { <S2SV_StartBug> fprintf ( stderr , "Deleted<S2SV_blank>%s\\n" , fullname ) ; <S2SV_EndBug> counts . deleted ++ ; } } <S2SV_StartBug> free_string ( & fullname ) ; <S2SV_EndBug> <S2SV_StartBug> close ( fd ) ; <S2SV_EndBug> } } | <S2SV_ModStart> manifest * official_manifest , bool repair <S2SV_ModStart> 0 ) { goto out <S2SV_ModEnd> ; } counts <S2SV_ModStart> extraneous ++ ; printf ( "File<S2SV_blank>that<S2SV_blank>should<S2SV_blank>be<S2SV_blank>deleted:<S2SV_blank>%s\\n" , fullname ) ; if ( ! repair ) { goto out ; } <S2SV_ModStart> ( stderr , "\\tdeleted\\n" <S2SV_ModEnd> ) ; counts <S2SV_ModStart> ( stderr , "\\tdeleted\\n" <S2SV_ModEnd> ) ; counts <S2SV_ModStart> ; } } close ( fd ) ; out : <S2SV_ModStart> fullname ) ; <S2SV_ModEnd> } } <S2SV_null> |
5,755 | CWE-000 void data ( ) { Scene = glusSceneNew ( "scene.sdl" ) ; snow = ( PPeano ) glusSceneGetShapeByName ( Scene , "snow" ) -> Extern ; level = snow -> Level ; pic [ 0 ] = pixCheckboard ( ) ; pixChromaKey ( pic [ 0 ] , 0 , 0 , 0 ) ; <S2SV_StartBug> pic [ 1 ] = glusMandelbrotSet ( 160 , 120 , 0.5 ) ; <S2SV_EndBug> RGBA c = { 0 , 248 , 248 , 255 } , b = { 0 , . R = 255 , . A = 128 } ; pix2Rect ( pic [ 0 ] , & region , & c ) ; pi . nCol = 128 , pi . nRow = 128 ; glusAllocex ( pi . Pixels , RGBA , 128 * 128 , return ) ; rect2pix ( & pi , & region , & c , & b ) ; } | <S2SV_ModStart> ; pic [ 2 ] = pixCheckboard ( ) ; pixChromaKey ( pic [ 2 ] , 0 , 248 , 248 <S2SV_ModEnd> ) ; RGBA |
5,756 | CWE-000 void admin_resultset_merge ( network_mysqld_con * con , network_queue * send_queue , GPtrArray * recv_queues , result_merge_t * merged_result ) { shard_plugin_con_t * st = con -> plugin_con_state ; sql_context_t * context = st -> sql_context ; cetus_result_t res_merge = { 0 } ; <S2SV_StartBug> g_debug ( "%s:<S2SV_blank>context->stmt_type:%d" , G_STRLOC , context -> stmt_type ) ; <S2SV_EndBug> switch ( context -> stmt_type ) { case STMT_SELECT : if ( ! merge_for_admin ( context , send_queue , recv_queues , con , & res_merge , merged_result ) ) { cetus_result_destroy ( & res_merge ) ; return ; } <S2SV_StartBug> break ; <S2SV_EndBug> case STMT_INSERT : case STMT_UPDATE : case STMT_DELETE : case STMT_SET : default : g_debug ( "%s:<S2SV_blank>call<S2SV_blank>merge_for_modify:%d" , G_STRLOC , context -> stmt_type ) ; if ( ! merge_for_modify ( context , send_queue , recv_queues , con , & res_merge , merged_result ) ) { cetus_result_destroy ( & res_merge ) ; return ; } <S2SV_StartBug> break ; <S2SV_EndBug> } cetus_result_destroy ( & res_merge ) ; merged_result -> status = RM_SUCCESS ; } | <S2SV_ModStart> ; g_debug ( "%s:<S2SV_blank>sql:%s" <S2SV_ModEnd> , G_STRLOC , <S2SV_ModStart> , G_STRLOC , con -> orig_sql -> str ) ; if ( strcasestr ( con -> orig_sql -> str , "select" ) != NULL ) { <S2SV_ModEnd> if ( ! <S2SV_ModStart> return ; } } else { <S2SV_ModEnd> g_debug ( "%s:<S2SV_blank>call<S2SV_blank>merge_for_modify:%d" <S2SV_ModStart> return ; } <S2SV_ModEnd> } cetus_result_destroy ( |
5,757 | CWE-000 <S2SV_StartBug> static const char const * getLine ( ) <S2SV_EndBug> { char const * pch = NULL ; if ( iBtxBufferPos > iBtxBufferLen ) return NULL ; pch = pchBtxBuffer + iBtxBufferPos ; iBtxBufferPos += strlen ( pch ) + 1 ; return pch ; } | <S2SV_ModStart> static const char * const <S2SV_ModEnd> getLine ( ) |
5,758 | CWE-000 Bool radeon_do_pageflip ( ScrnInfoPtr scrn , ClientPtr client , PixmapPtr new_front , uint64_t id , void * data , xf86CrtcPtr ref_crtc , radeon_drm_handler_proc handler , radeon_drm_abort_proc abort , enum drmmode_flip_sync flip_sync , uint32_t target_msc ) { RADEONEntPtr pRADEONEnt = RADEONEntPriv ( scrn ) ; xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR ( scrn ) ; xf86CrtcPtr crtc = NULL ; drmmode_crtc_private_ptr drmmode_crtc = config -> crtc [ 0 ] -> driver_private ; uint32_t flip_flags = flip_sync == FLIP_ASYNC ? DRM_MODE_PAGE_FLIP_ASYNC : 0 ; drmmode_flipdata_ptr flipdata ; uintptr_t drm_queue_seq = 0 ; struct drmmode_fb * fb ; int i = 0 ; flipdata = calloc ( 1 , sizeof ( * flipdata ) + config -> num_crtc * sizeof ( flipdata -> fb [ 0 ] ) ) ; if ( ! flipdata ) { xf86DrvMsg ( scrn -> scrnIndex , X_WARNING , "flip<S2SV_blank>queue:<S2SV_blank>data<S2SV_blank>alloc<S2SV_blank>failed.\\n" ) ; goto error ; } fb = radeon_pixmap_get_fb ( new_front ) ; if ( ! fb ) { ErrorF ( "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>FB<S2SV_blank>for<S2SV_blank>flip\\n" ) ; goto error ; } flipdata -> event_data = data ; flipdata -> handler = handler ; flipdata -> abort = abort ; flipdata -> fe_crtc = ref_crtc ; for ( i = 0 ; i < config -> num_crtc ; i ++ ) { crtc = config -> crtc [ i ] ; drmmode_crtc = crtc -> driver_private ; if ( ! drmmode_crtc_can_flip ( crtc ) || ( drmmode_crtc -> tear_free && crtc != ref_crtc ) ) continue ; flipdata -> flip_count ++ ; drm_queue_seq = radeon_drm_queue_alloc ( crtc , client , id , flipdata , drmmode_flip_handler , drmmode_flip_abort ) ; if ( drm_queue_seq == RADEON_DRM_QUEUE_ERROR ) { xf86DrvMsg ( scrn -> scrnIndex , X_WARNING , "Allocating<S2SV_blank>DRM<S2SV_blank>queue<S2SV_blank>event<S2SV_blank>entry<S2SV_blank>failed.\\n" ) ; goto error ; } if ( drmmode_crtc -> tear_free ) { BoxRec extents = { . x1 = 0 , . y1 = 0 , . x2 = new_front -> drawable . width , . y2 = new_front -> drawable . height } ; int scanout_id = drmmode_crtc -> scanout_id ^ 1 ; if ( flip_sync == FLIP_ASYNC ) { if ( ! drmmode_wait_vblank ( crtc , DRM_VBLANK_RELATIVE | DRM_VBLANK_EVENT , 0 , drm_queue_seq , NULL , NULL ) ) goto flip_error ; goto next ; } drmmode_fb_reference ( pRADEONEnt -> fd , & flipdata -> fb [ i ] , radeon_pixmap_get_fb ( drmmode_crtc -> scanout [ scanout_id ] . pixmap ) ) ; if ( ! flipdata -> fb [ i ] ) { ErrorF ( "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>FB<S2SV_blank>for<S2SV_blank>TearFree<S2SV_blank>flip\\n" ) ; goto error ; } radeon_scanout_do_update ( crtc , scanout_id , new_front , extents ) ; radeon_cs_flush_indirect ( crtc -> scrn ) ; if ( drmmode_crtc -> scanout_update_pending ) { drmmode_crtc_wait_pending_event ( drmmode_crtc , pRADEONEnt -> fd , drmmode_crtc -> flip_pending ) ; radeon_drm_abort_entry ( drmmode_crtc -> scanout_update_pending ) ; drmmode_crtc -> scanout_update_pending = 0 ; } } else { drmmode_fb_reference ( pRADEONEnt -> fd , & flipdata -> fb [ i ] , fb ) ; } if ( crtc == ref_crtc ) { if ( drmmode_page_flip_target_absolute ( pRADEONEnt , drmmode_crtc , <S2SV_StartBug> fb -> handle , <S2SV_EndBug> flip_flags , drm_queue_seq , target_msc ) != 0 ) goto flip_error ; } else { if ( drmmode_page_flip_target_relative ( pRADEONEnt , drmmode_crtc , <S2SV_StartBug> fb -> handle , <S2SV_EndBug> flip_flags , drm_queue_seq , 0 ) != 0 ) goto flip_error ; } if ( drmmode_crtc -> tear_free ) { drmmode_crtc -> scanout_id ^= 1 ; drmmode_crtc -> ignore_damage = TRUE ; } next : drmmode_fb_reference ( pRADEONEnt -> fd , & drmmode_crtc -> flip_pending , flipdata -> fb [ i ] ) ; drm_queue_seq = 0 ; } if ( flipdata -> flip_count > 0 ) return TRUE ; flip_error : xf86DrvMsg ( scrn -> scrnIndex , X_WARNING , "flip<S2SV_blank>queue<S2SV_blank>failed:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; error : if ( drm_queue_seq ) radeon_drm_abort_entry ( drm_queue_seq ) ; else if ( crtc ) drmmode_flip_abort ( crtc , flipdata ) ; else { abort ( NULL , data ) ; free ( flipdata ) ; } xf86DrvMsg ( scrn -> scrnIndex , X_WARNING , "Page<S2SV_blank>flip<S2SV_blank>failed:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; return FALSE ; } | <S2SV_ModStart> , drmmode_crtc , flipdata -> fb [ i ] <S2SV_ModEnd> -> handle , <S2SV_ModStart> , drmmode_crtc , flipdata -> fb [ i ] <S2SV_ModEnd> -> handle , |
5,759 | CWE-000 static void cuda_update ( CUDAState * s ) { <S2SV_StartBug> MOS6522CUDAState * mcs = s -> mos6522_cuda ; <S2SV_EndBug> MOS6522State * ms = MOS6522 ( mcs ) ; int packet_received , len ; packet_received = 0 ; if ( ! ( ms -> b & TIP ) ) { if ( ms -> acr & SR_OUT ) { if ( ( ms -> b & ( TACK | TIP ) ) != ( s -> last_b & ( TACK | TIP ) ) ) { if ( s -> data_out_index < sizeof ( s -> data_out ) ) { trace_cuda_data_send ( ms -> sr ) ; s -> data_out [ s -> data_out_index ++ ] = ms -> sr ; cuda_delay_set_sr_int ( s ) ; } } } else { if ( s -> data_in_index < s -> data_in_size ) { if ( ( ms -> b & ( TACK | TIP ) ) != ( s -> last_b & ( TACK | TIP ) ) ) { ms -> sr = s -> data_in [ s -> data_in_index ++ ] ; trace_cuda_data_recv ( ms -> sr ) ; if ( s -> data_in_index >= s -> data_in_size ) { ms -> b = ( ms -> b | TREQ ) ; } cuda_delay_set_sr_int ( s ) ; } } } } else { if ( ( s -> last_b & TIP ) && ( ms -> b & TACK ) != ( s -> last_b & TACK ) ) { if ( ms -> b & TACK ) { ms -> b = ( ms -> b | TREQ ) ; } else { ms -> b = ( ms -> b & ~ TREQ ) ; } cuda_delay_set_sr_int ( s ) ; } else { if ( ! ( s -> last_b & TIP ) ) { packet_received = ( s -> data_out_index > 0 ) ; cuda_delay_set_sr_int ( s ) ; } if ( s -> data_in_index < s -> data_in_size ) { ms -> b = ( ms -> b & ~ TREQ ) ; } } } s -> last_acr = ms -> acr ; s -> last_b = ms -> b ; if ( packet_received ) { len = s -> data_out_index ; s -> data_out_index = 0 ; cuda_receive_packet_from_host ( s , s -> data_out , len ) ; } } | <S2SV_ModStart> * mcs = & |
5,760 | CWE-000 int ssl3_final_finish_mac ( SSL * s , const char * sender , int len , unsigned char * p ) { int ret ; EVP_MD_CTX * ctx = NULL ; if ( ! ssl3_digest_cached_records ( s , 0 ) ) return 0 ; if ( EVP_MD_CTX_type ( s -> s3 -> handshake_dgst ) != NID_md5_sha1 ) { SSLerr ( SSL_F_SSL3_FINAL_FINISH_MAC , SSL_R_NO_REQUIRED_DIGEST ) ; return 0 ; } ctx = EVP_MD_CTX_new ( ) ; if ( ctx == NULL ) { SSLerr ( SSL_F_SSL3_FINAL_FINISH_MAC , ERR_R_MALLOC_FAILURE ) ; return 0 ; } if ( ! EVP_MD_CTX_copy_ex ( ctx , s -> s3 -> handshake_dgst ) ) { SSLerr ( SSL_F_SSL3_FINAL_FINISH_MAC , ERR_R_INTERNAL_ERROR ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } ret = EVP_MD_CTX_size ( ctx ) ; if ( ret < 0 ) { <S2SV_StartBug> EVP_MD_CTX_reset ( ctx ) ; <S2SV_EndBug> return 0 ; } if ( ( sender != NULL && EVP_DigestUpdate ( ctx , sender , len ) <= 0 ) || EVP_MD_CTX_ctrl ( ctx , EVP_CTRL_SSL3_MASTER_SECRET , s -> session -> master_key_length , s -> session -> master_key ) <= 0 || EVP_DigestFinal_ex ( ctx , p , NULL ) <= 0 ) { SSLerr ( SSL_F_SSL3_FINAL_FINISH_MAC , ERR_R_INTERNAL_ERROR ) ; ret = 0 ; } <S2SV_StartBug> EVP_MD_CTX_free ( ctx ) ; <S2SV_EndBug> return ret ; } | <S2SV_ModStart> ERR_R_INTERNAL_ERROR ) ; ret = 0 ; goto err <S2SV_ModEnd> ; } ret <S2SV_ModStart> 0 ) { ret = 0 ; goto err <S2SV_ModEnd> ; } if <S2SV_ModStart> 0 ; } err : |
5,761 | CWE-000 int CRYPTO_secure_malloc_done ( ) { # ifdef IMPLEMENTED if ( secure_mem_used == 0 ) { sh_done ( ) ; secure_mem_initialized = 0 ; CRYPTO_THREAD_lock_free ( sec_malloc_lock ) ; <S2SV_StartBug> return 1 ; <S2SV_EndBug> } # endif return 0 ; } | <S2SV_ModStart> sec_malloc_lock ) ; sec_malloc_lock = NULL ; |
5,762 | CWE-000 static void init ( void ) { e_launch_time = time ( NULL ) ; enamel_init ( ) ; events_app_message_request_outbox_size ( APP_MESSAGE_OUTBOX_SIZE_MINIMUM ) ; <S2SV_StartBug> s_normal_msg_handler = events_app_message_register_inbox_received ( prv_init_callback , NULL ) ; <S2SV_EndBug> <S2SV_StartBug> s_enamel_msg_handler = enamel_settings_received_subscribe ( prv_update_config , NULL ) ; <S2SV_EndBug> events_app_message_open ( ) ; wakeup_service_subscribe ( wakeup_handler ) ; <S2SV_StartBug> prv_launch_handler ( enamel_get_activate ( ) ) ; <S2SV_EndBug> } | <S2SV_ModStart> = events_app_message_register_inbox_received ( init_callback <S2SV_ModEnd> , NULL ) <S2SV_ModStart> = enamel_settings_received_subscribe ( update_config <S2SV_ModEnd> , NULL ) <S2SV_ModStart> wakeup_handler ) ; launch_handler <S2SV_ModEnd> ( enamel_get_activate ( |
5,763 | CWE-000 int ft_find_path_aux ( t_env * e , int * path , int end ) { int i ; int * * m ; if ( end == 0 ) return ( 1 ) ; i = 0 ; while ( i < e -> nb_r ) { <S2SV_StartBug> if ( e -> cpy [ i ] [ end ] ) <S2SV_EndBug> { m = ft_backup_mat ( e -> cpy , e -> nb_r ) ; e -> cpy [ i ] [ end ] = 0 ; e -> cpy [ end ] [ i ] = 0 ; if ( ft_find_path_aux ( e , path , i ) ) { path [ end ] = i ; ft_free_mat ( e -> cpy , e -> nb_r ) ; e -> cpy = ft_backup_mat ( m , e -> nb_r ) ; ft_free_mat ( m , e -> nb_r ) ; return ( 1 ) ; } ft_free_mat ( e -> cpy , e -> nb_r ) ; e -> cpy = ft_backup_mat ( m , e -> nb_r ) ; ft_free_mat ( m , e -> nb_r ) ; } i ++ ; } return ( 0 ) ; } | <S2SV_ModStart> [ end ] && ! e -> visited [ i ] ) { e -> visited [ i ] = 1 ; <S2SV_ModEnd> m = ft_backup_mat |
5,764 | CWE-000 int gertboardAnalogRead ( const int chan ) { uint8_t spiData [ 2 ] ; uint8_t chanBits ; if ( chan == 0 ) chanBits = 0b11010000 ; else chanBits = 0b11110000 ; spiData [ 0 ] = chanBits ; spiData [ 1 ] = 0 ; wiringPiSPIDataRW ( SPI_A2D , spiData , 2 ) ; <S2SV_StartBug> return ( ( spiData [ 0 ] << 7 ) | ( spiData [ 1 ] >> 1 ) ) & 0x3FF ; <S2SV_EndBug> } | <S2SV_ModStart> 0 ] << 8 <S2SV_ModEnd> ) | ( |
5,765 | CWE-000 void job_unref ( Job * job ) { if ( -- job -> refcnt == 0 ) { assert ( job -> status == JOB_STATUS_NULL ) ; assert ( ! timer_pending ( & job -> sleep_timer ) ) ; assert ( ! job -> txn ) ; if ( job -> driver -> free ) { job -> driver -> free ( job ) ; } QLIST_REMOVE ( job , job_list ) ; <S2SV_StartBug> g_free ( job -> id ) ; <S2SV_EndBug> g_free ( job ) ; } } | <S2SV_ModStart> ( job -> error ) ; g_free ( job -> |
5,766 | CWE-000 void research_end ( t_edit * this ) { int tmp_pos_cursor ; if ( ! this -> research_mode ) return ; this -> research_mode = false ; <S2SV_StartBug> research_clear ( this ) ; <S2SV_EndBug> edit_prompt_print_last_line ( this ) ; tmp_pos_cursor = this -> pos_cursor ; this -> puts ( this -> current -> line ) ; this -> pos_cursor = this -> current -> size ; edit_move_goto_pos_cursor ( this , tmp_pos_cursor ) ; } | <S2SV_ModStart> ( this ) ; research_del ( this -> research ) ; this -> research = NULL |
5,767 | CWE-000 static void bridge_reconfigure ( const struct ovsrec_open_vswitch * ovs_cfg ) { struct sockaddr_in * managers ; struct bridge * br , * next ; int sflow_bridge_number ; size_t n_managers ; COVERAGE_INC ( bridge_reconfigure ) ; ofproto_set_flow_limit ( smap_get_int ( & ovs_cfg -> other_config , "flow-limit" , OFPROTO_FLOW_LIMIT_DEFAULT ) ) ; ofproto_set_max_idle ( smap_get_int ( & ovs_cfg -> other_config , "max-idle" , OFPROTO_MAX_IDLE_DEFAULT ) ) ; ofproto_set_vlan_limit ( smap_get_int ( & ovs_cfg -> other_config , "vlan-limit" , LEGACY_MAX_VLAN_HEADERS ) ) ; ofproto_set_threads ( smap_get_int ( & ovs_cfg -> other_config , "n-handler-threads" , 0 ) , smap_get_int ( & ovs_cfg -> other_config , "n-revalidator-threads" , 0 ) ) ; add_del_bridges ( ovs_cfg ) ; HMAP_FOR_EACH ( br , node , & all_bridges ) { bridge_collect_wanted_ports ( br , & br -> wanted_ports ) ; bridge_del_ports ( br , & br -> wanted_ports ) ; } bridge_delete_ofprotos ( ) ; HMAP_FOR_EACH ( br , node , & all_bridges ) { if ( br -> ofproto ) { bridge_delete_or_reconfigure_ports ( br ) ; } } HMAP_FOR_EACH_SAFE ( br , next , node , & all_bridges ) { if ( ! br -> ofproto ) { int error ; <S2SV_StartBug> error = ofproto_create ( br -> name , br -> type , & br -> ofproto ) ; <S2SV_EndBug> if ( error ) { VLOG_ERR ( "failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>bridge<S2SV_blank>%s:<S2SV_blank>%s" , br -> name , ovs_strerror ( error ) ) ; shash_destroy ( & br -> wanted_ports ) ; bridge_destroy ( br , true ) ; } else { seq_change ( connectivity_seq_get ( ) ) ; } } } config_ofproto_types ( & ovs_cfg -> other_config ) ; HMAP_FOR_EACH ( br , node , & all_bridges ) { bridge_add_ports ( br , & br -> wanted_ports ) ; shash_destroy ( & br -> wanted_ports ) ; } reconfigure_system_stats ( ovs_cfg ) ; sflow_bridge_number = 0 ; collect_in_band_managers ( ovs_cfg , & managers , & n_managers ) ; HMAP_FOR_EACH ( br , node , & all_bridges ) { struct port * port ; bridge_configure_datapath_id ( br ) ; HMAP_FOR_EACH ( port , hmap_node , & br -> ports ) { struct iface * iface ; port_configure ( port ) ; LIST_FOR_EACH ( iface , port_elem , & port -> ifaces ) { iface_set_ofport ( iface -> cfg , iface -> ofp_port ) ; ovsrec_interface_set_error ( iface -> cfg , NULL ) ; iface_configure_cfm ( iface ) ; iface_configure_qos ( iface , port -> cfg -> qos ) ; iface_set_mac ( br , port , iface ) ; ofproto_port_set_bfd ( br -> ofproto , iface -> ofp_port , & iface -> cfg -> bfd ) ; ofproto_port_set_lldp ( br -> ofproto , iface -> ofp_port , & iface -> cfg -> lldp ) ; ofproto_port_set_config ( br -> ofproto , iface -> ofp_port , & iface -> cfg -> other_config ) ; } } bridge_configure_mirrors ( br ) ; bridge_configure_forward_bpdu ( br ) ; bridge_configure_mac_table ( br ) ; bridge_configure_mcast_snooping ( br ) ; bridge_configure_remotes ( br , managers , n_managers ) ; bridge_configure_netflow ( br ) ; bridge_configure_sflow ( br , & sflow_bridge_number ) ; bridge_configure_ipfix ( br ) ; bridge_configure_spanning_tree ( br ) ; bridge_configure_tables ( br ) ; bridge_configure_dp_desc ( br ) ; bridge_configure_aa ( br ) ; } free ( managers ) ; bridge_run__ ( ) ; } | <S2SV_ModStart> -> type , br -> cfg -> mfr_desc , |
5,768 | CWE-000 static int flush_notification ( void ) { if ( tmp_notif_data == NULL ) <S2SV_StartBug> return - 1 ; <S2SV_EndBug> send_generic ( & tmp_notif_pkt , ( void * ) tmp_notif_data ) ; free ( tmp_notif_data -> host_name ) ; free ( tmp_notif_data -> service_description ) ; free ( tmp_notif_data -> output ) ; free ( tmp_notif_data -> ack_author ) ; free ( tmp_notif_data -> ack_data ) ; free ( tmp_notif_data ) ; tmp_notif_data = NULL ; return 0 ; } | <S2SV_ModStart> - 1 ; if ( tmp_notif_data -> notification_type == HOST_NOTIFICATION ) { ldebug ( "flushing<S2SV_blank>host<S2SV_blank>notification<S2SV_blank>for<S2SV_blank>%s" , tmp_notif_data -> host_name ) ; } else { ldebug ( "flushing<S2SV_blank>service<S2SV_blank>notification<S2SV_blank>for<S2SV_blank>%s;%s" , tmp_notif_data -> service_description , tmp_notif_data -> host_name ) ; } |
5,769 | CWE-000 void set_server_identity_key ( crypto_pk_t * k ) { crypto_pk_free ( server_identitykey ) ; server_identitykey = k ; <S2SV_StartBug> crypto_pk_get_digest ( server_identitykey , server_identitykey_digest ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> = k ; if ( <S2SV_ModStart> server_identitykey , server_identitykey_digest ) < 0 ) { log_err ( LD_BUG , "Couldn\'t<S2SV_blank>compute<S2SV_blank>our<S2SV_blank>own<S2SV_blank>identity<S2SV_blank>key<S2SV_blank>digest." ) ; tor_assert ( 0 <S2SV_ModStart> ) ; } } |
5,770 | CWE-000 <S2SV_StartBug> int8_t <S2SV_EndBug> ina219_write16 ( const struct ina219_dev * dev , const uint8_t reg , const uint16_t * data ) { int8_t r = 0 ; uint8_t buffer [ 2 ] ; buffer [ 0 ] = ( uint8_t ) ( * data >> 8 ) ; buffer [ 1 ] = ( uint8_t ) ( * data & 0xff ) ; r = dev -> write ( dev -> address , reg , buffer , 2 ) ; return r ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> int32_t <S2SV_ModEnd> ina219_write16 ( const |
5,771 | CWE-000 <S2SV_StartBug> Expr * expr_unary ( TokenType op , Expr * uexpr ) { <S2SV_EndBug> assert ( op == TOKEN_INC || op == TOKEN_DEC || op == '+' || op == '-' || op == '*' || op == '!' || op == '~' ) ; <S2SV_StartBug> Expr * expr = expr_alloc ( EXPR_UNARY ) ; <S2SV_EndBug> expr -> unary_expr = ( UnaryExpr ) { . expr = uexpr , . op = op } ; return expr ; } | <S2SV_ModStart> * expr_unary ( ExprType unary_type , <S2SV_ModStart> uexpr ) { assert ( unary_type == EXPR_PRE_UNARY || unary_type == EXPR_POST_UNARY ) ; <S2SV_ModStart> = expr_alloc ( unary_type <S2SV_ModEnd> ) ; expr |
5,772 | CWE-000 unsigned char * * GrayscaleToBinarized ( unsigned char * * grayscaleImageMatrix , int imageWidth , int imageHeight ) { unsigned char * * matrix = CreateImageMatrix ( imageWidth , imageHeight ) ; int totalIntensity = 0 ; for ( int y = 0 ; y < imageHeight ; y ++ ) { for ( int x = 0 ; x < imageWidth ; x ++ ) { <S2SV_StartBug> if ( imageWidth <= imageHeight ) <S2SV_EndBug> { totalIntensity += grayscaleImageMatrix [ x ] [ y ] ; } else { totalIntensity += grayscaleImageMatrix [ y ] [ x ] ; <S2SV_StartBug> } <S2SV_EndBug> } } int averageIntensity = totalIntensity / ( imageWidth * imageHeight ) ; for ( int y = 0 ; y < imageHeight ; y ++ ) { for ( int x = 0 ; x < imageWidth ; x ++ ) { <S2SV_StartBug> if ( imageWidth <= imageHeight ) <S2SV_EndBug> { if ( grayscaleImageMatrix [ x ] [ y ] > averageIntensity ) { matrix [ x ] [ y ] = 255 ; } else { matrix [ x ] [ y ] = 0 ; } } else { if ( grayscaleImageMatrix [ y ] [ x ] > averageIntensity ) { matrix [ y ] [ x ] = 255 ; } else { matrix [ y ] [ x ] = 0 ; } } } <S2SV_StartBug> } <S2SV_EndBug> return matrix ; } | <S2SV_ModStart> ++ ) { <S2SV_ModEnd> totalIntensity += grayscaleImageMatrix <S2SV_ModStart> x ] ; <S2SV_ModEnd> } } int <S2SV_ModStart> { if ( <S2SV_ModEnd> grayscaleImageMatrix [ y <S2SV_ModStart> } } } <S2SV_ModEnd> return matrix ; |
5,773 | CWE-000 static int siba_request_ext_rsrc ( device_t dev , device_t child , u_int rsrc ) { struct siba_softc * sc ; struct siba_devinfo * dinfo ; if ( device_get_parent ( child ) != dev ) return ( EINVAL ) ; sc = device_get_softc ( dev ) ; dinfo = device_get_ivars ( child ) ; SIBA_LOCK ( sc ) ; switch ( dinfo -> pmu_state ) { case SIBA_PMU_NONE : panic ( "no<S2SV_blank>active<S2SV_blank>PMU<S2SV_blank>request<S2SV_blank>state" ) ; SIBA_UNLOCK ( sc ) ; return ( ENXIO ) ; case SIBA_PMU_BHND : SIBA_UNLOCK ( sc ) ; return ( bhnd_generic_request_ext_rsrc ( dev , child , rsrc ) ) ; case SIBA_PMU_PWRCTL : <S2SV_StartBug> SIBA_UNLOCK ( sc ) ; <S2SV_EndBug> return ( ENODEV ) ; } panic ( "invalid<S2SV_blank>PMU<S2SV_blank>state:<S2SV_blank>%d" , dinfo -> pmu_state ) ; } | <S2SV_ModStart> case SIBA_PMU_PWRCTL : case SIBA_PMU_FIXED : |
5,774 | CWE-000 gboolean sqlite_db_commit ( DBConnection * vconn , GError * * error ) { SQLiteDBConnection * conn = ( SQLiteDBConnection * ) vconn ; int rc ; <S2SV_StartBug> EXEC_SQLITE ( rc , sqlite3_exec ( conn -> db , "COMMIT<S2SV_blank>TRANSACTION;" , NULL , NULL , NULL ) ) ; <S2SV_EndBug> if ( rc != SQLITE_OK ) { g_set_error ( error , SEAF_DB_ERROR_DOMAIN , SEAF_DB_ERROR_CODE , "commit<S2SV_blank>transaction<S2SV_blank>failed:<S2SV_blank>%s" , sqlite3_errmsg ( conn -> db ) ) ; return FALSE ; } return TRUE ; } | <S2SV_ModStart> int rc ; rc = sqlite3_blocking_exec <S2SV_ModEnd> ( conn -> <S2SV_ModStart> NULL , NULL <S2SV_ModEnd> ) ; if |
5,775 | CWE-000 static int build_path_from_dentry ( struct v9fs_session_info * v9ses , <S2SV_StartBug> struct dentry * dentry , char * * * names ) <S2SV_EndBug> { int n = 0 , i ; <S2SV_StartBug> char * * wnames ; <S2SV_EndBug> struct dentry * ds ; for ( ds = dentry ; ! IS_ROOT ( ds ) ; ds = ds -> d_parent ) n ++ ; wnames = kmalloc ( sizeof ( char * ) * n , GFP_KERNEL ) ; if ( ! wnames ) goto err_out ; for ( ds = dentry , i = ( n - 1 ) ; i >= 0 ; i -- , ds = ds -> d_parent ) <S2SV_StartBug> wnames [ i ] = ( char * ) ds -> d_name . name ; <S2SV_EndBug> * names = wnames ; return n ; err_out : return - ENOMEM ; } | <S2SV_ModStart> * dentry , const unsigned <S2SV_ModStart> , i ; const unsigned <S2SV_ModStart> i ] = <S2SV_ModEnd> ds -> d_name |
5,776 | CWE-000 void gimp_display_shell_render ( GimpDisplayShell * shell , cairo_t * cr , gint x , gint y , gint w , gint h ) { GimpProjection * projection ; GimpImage * image ; TileManager * tiles ; RenderInfo info ; GimpImageType type ; gint level ; gboolean premult ; gint image_w , image_h ; gint render_start_x , render_start_y ; g_return_if_fail ( GIMP_IS_DISPLAY_SHELL ( shell ) ) ; g_return_if_fail ( cr != NULL ) ; if ( w <= 0 || h <= 0 ) return ; image = gimp_display_get_image ( shell -> display ) ; projection = gimp_image_get_projection ( image ) ; level = gimp_projection_get_level ( projection , shell -> scale_x , shell -> scale_y ) ; tiles = gimp_projection_get_tiles_at_level ( projection , level , & premult ) ; gimp_display_shell_scroll_get_render_start_offset ( shell , & render_start_x , & render_start_y ) ; image_w = SCALEX ( shell , gimp_image_get_width ( image ) ) - render_start_x ; image_h = SCALEY ( shell , gimp_image_get_height ( image ) ) - render_start_y ; if ( x > image_w || y > image_h ) return ; <S2SV_StartBug> w = CLAMP ( w , 0 , image_w - x + 1 ) ; <S2SV_EndBug> <S2SV_StartBug> h = CLAMP ( h , 0 , image_h - y + 1 ) ; <S2SV_EndBug> if ( w == 0 || h == 0 ) return ; gimp_display_shell_render_info_init ( & info , shell , x , y , w , h , shell -> render_surface , tiles , level , premult ) ; type = gimp_pickable_get_image_type ( GIMP_PICKABLE ( projection ) ) ; switch ( type ) { case GIMP_RGBA_IMAGE : render_image_rgb_a ( & info ) ; break ; case GIMP_GRAYA_IMAGE : render_image_gray_a ( & info ) ; break ; default : g_warning ( "%s:<S2SV_blank>unsupported<S2SV_blank>projection<S2SV_blank>type<S2SV_blank>(%d)" , G_STRFUNC , type ) ; g_assert_not_reached ( ) ; } if ( shell -> filter_stack ) { cairo_surface_t * sub = shell -> render_surface ; if ( w != GIMP_DISPLAY_RENDER_BUF_WIDTH || h != GIMP_DISPLAY_RENDER_BUF_HEIGHT ) sub = cairo_image_surface_create_for_data ( cairo_image_surface_get_data ( sub ) , CAIRO_FORMAT_ARGB32 , w , h , GIMP_DISPLAY_RENDER_BUF_WIDTH * 4 ) ; gimp_color_display_stack_convert_surface ( shell -> filter_stack , sub ) ; if ( sub != shell -> render_surface ) cairo_surface_destroy ( sub ) ; } cairo_surface_mark_dirty_rectangle ( shell -> render_surface , 0 , 0 , w , h ) ; if ( shell -> mask ) { if ( ! shell -> mask_surface ) { shell -> mask_surface = cairo_image_surface_create ( CAIRO_FORMAT_A8 , GIMP_DISPLAY_RENDER_BUF_WIDTH , GIMP_DISPLAY_RENDER_BUF_HEIGHT ) ; } tiles = gimp_drawable_get_tiles ( shell -> mask ) ; gimp_display_shell_render_info_init ( & info , shell , x , y , w , h , shell -> mask_surface , tiles , 0 , FALSE ) ; render_image_alpha ( & info ) ; cairo_surface_mark_dirty ( shell -> mask_surface ) ; } { gint disp_xoffset , disp_yoffset ; gimp_display_shell_scroll_get_disp_offset ( shell , & disp_xoffset , & disp_yoffset ) ; cairo_save ( cr ) ; gimp_display_shell_set_cairo_rotate ( shell , cr ) ; cairo_rectangle ( cr , x + disp_xoffset , y + disp_yoffset , w , h ) ; cairo_clip ( cr ) ; cairo_set_source_surface ( cr , shell -> render_surface , x + disp_xoffset , y + disp_yoffset ) ; cairo_paint ( cr ) ; if ( shell -> mask ) { gimp_cairo_set_source_rgba ( cr , & shell -> mask_color ) ; cairo_mask_surface ( cr , shell -> mask_surface , x + disp_xoffset , y + disp_yoffset ) ; } cairo_restore ( cr ) ; } } | <S2SV_ModStart> image_w - x <S2SV_ModEnd> ) ; h <S2SV_ModStart> image_h - y <S2SV_ModEnd> ) ; if |
5,777 | CWE-000 void setNumCapabilities ( uint32_t new_n_capabilities USED_IF_THREADS ) { # if ! defined ( THREADED_RTS ) if ( new_n_capabilities != 1 ) { errorBelch ( "setNumCapabilities:<S2SV_blank>not<S2SV_blank>supported<S2SV_blank>in<S2SV_blank>the<S2SV_blank>non-threaded<S2SV_blank>RTS" ) ; } return ; # elif defined ( NOSMP ) if ( new_n_capabilities != 1 ) { errorBelch ( "setNumCapabilities:<S2SV_blank>not<S2SV_blank>supported<S2SV_blank>on<S2SV_blank>this<S2SV_blank>platform" ) ; } return ; # else Task * task ; Capability * cap ; uint32_t n ; Capability * old_capabilities = NULL ; uint32_t old_n_capabilities = n_capabilities ; if ( new_n_capabilities == enabled_capabilities ) return ; debugTrace ( DEBUG_sched , "changing<S2SV_blank>the<S2SV_blank>number<S2SV_blank>of<S2SV_blank>Capabilities<S2SV_blank>from<S2SV_blank>%d<S2SV_blank>to<S2SV_blank>%d" , enabled_capabilities , new_n_capabilities ) ; cap = rts_lock ( ) ; task = cap -> running_task ; stopAllCapabilities ( & cap , task ) ; if ( new_n_capabilities < enabled_capabilities ) { for ( n = new_n_capabilities ; n < enabled_capabilities ; n ++ ) { capabilities [ n ] -> disabled = rtsTrue ; traceCapDisable ( capabilities [ n ] ) ; } enabled_capabilities = new_n_capabilities ; } else { for ( n = enabled_capabilities ; n < new_n_capabilities && n < n_capabilities ; n ++ ) { capabilities [ n ] -> disabled = rtsFalse ; traceCapEnable ( capabilities [ n ] ) ; } enabled_capabilities = n ; if ( new_n_capabilities > n_capabilities ) { # if defined ( TRACING ) tracingAddCapapilities ( n_capabilities , new_n_capabilities ) ; # endif moreCapabilities ( n_capabilities , new_n_capabilities ) ; storageAddCapabilities ( n_capabilities , new_n_capabilities ) ; } } if ( new_n_capabilities > n_capabilities ) { n_capabilities = enabled_capabilities = new_n_capabilities ; } <S2SV_StartBug> startWorkerTasks ( old_n_capabilities , new_n_capabilities ) ; <S2SV_EndBug> releaseAllCapabilities ( old_n_capabilities , cap , task ) ; if ( old_capabilities ) { stgFree ( old_capabilities ) ; } rts_evalIO ( & cap , ioManagerCapabilitiesChanged_closure , NULL ) ; rts_unlock ( cap ) ; # endif } | <S2SV_ModStart> new_n_capabilities ; } releaseAllCapabilities <S2SV_ModEnd> ( old_n_capabilities , <S2SV_ModStart> ( old_n_capabilities , <S2SV_ModEnd> cap , task |
5,778 | CWE-000 <S2SV_StartBug> int parse_file ( FILE * in , int * mem , int * reg , char * filename ) { <S2SV_EndBug> char * alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" ; char * symbols = "<S2SV_blank>0123456789#,-" ; int number = 0 ; while ( ! feof ( in ) ) { <S2SV_StartBug> char * buf = calloc ( 32 , sizeof ( char ) ) ; <S2SV_EndBug> int read_symb = 0 ; unsigned int counter = 0 ; do { read_symb = fgetc ( in ) ; char * abc = strchr ( alphabet , ( char ) read_symb ) ; char * num = strchr ( symbols , ( char ) read_symb ) ; if ( read_symb == 10 || read_symb == EOF ) break ; else if ( ( abc == NULL && num == NULL ) || read_symb > 122 ) { printf ( "Error<S2SV_blank>102:<S2SV_blank>unknown<S2SV_blank>symbol<S2SV_blank>at<S2SV_blank>line<S2SV_blank>%d\\n" , number ) ; printf ( "%c" , read_symb ) ; exit ( 102 ) ; } if ( counter > sizeof ( buf ) ) { <S2SV_StartBug> buf = ( char * ) realloc ( buf , sizeof ( buf ) + sizeof ( char ) * 32 ) ; <S2SV_EndBug> } else if ( counter >= 100 ) { printf ( "Error<S2SV_blank>103:<S2SV_blank>command<S2SV_blank>line<S2SV_blank>%d<S2SV_blank>is<S2SV_blank>too<S2SV_blank>long\\n" , number ) ; exit ( 103 ) ; } buf [ counter ++ ] = ( char ) read_symb ; } while ( 1 ) ; number ++ ; if ( buf [ 0 ] == '#' ) continue ; else string_procession ( buf , in , mem , reg , number , filename ) ; free ( buf ) ; } <S2SV_StartBug> return 42 ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> void <S2SV_ModEnd> parse_file ( FILE <S2SV_ModStart> ) ) ; if ( buf == NULL ) { printf ( "Error:<S2SV_blank>can\'t<S2SV_blank>get<S2SV_blank>memory\\n" ) ; exit ( 1 ) ; } <S2SV_ModStart> 32 ) ; if ( buf == NULL ) { printf ( "Error:<S2SV_blank>can\'t<S2SV_blank>get<S2SV_blank>memory\\n" ) ; exit ( 1 ) ; } <S2SV_ModStart> ) ; } <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
5,779 | CWE-000 void initEvents ( ) { int i ; struct Event event ; for ( i = 0 ; i < MAX_NUMBER_EVENTS ; i ++ ) { <S2SV_StartBug> event . id = - 1 ; <S2SV_EndBug> events [ i ] = event ; } } | <S2SV_ModStart> { event . array_postion <S2SV_ModEnd> = - 1 |
5,780 | CWE-000 static bool asduReceivedHandler ( void * parameter , int address , CS101_ASDU asdu ) { <S2SV_StartBug> printf ( "RECVD<S2SV_blank>ASDU<S2SV_blank>type:<S2SV_blank>%s(%i)<S2SV_blank>elements:<S2SV_blank>%i\\n" , <S2SV_EndBug> TypeID_toString ( CS101_ASDU_getTypeID ( asdu ) ) , CS101_ASDU_getTypeID ( asdu ) , CS101_ASDU_getNumberOfElements ( asdu ) ) ; if ( CS101_ASDU_getTypeID ( asdu ) == M_ME_TE_1 ) { printf ( "<S2SV_blank><S2SV_blank>measured<S2SV_blank>scaled<S2SV_blank>values<S2SV_blank>with<S2SV_blank>CP56Time2a<S2SV_blank>timestamp:\\n" ) ; int i ; for ( i = 0 ; i < CS101_ASDU_getNumberOfElements ( asdu ) ; i ++ ) { MeasuredValueScaledWithCP56Time2a io = ( MeasuredValueScaledWithCP56Time2a ) CS101_ASDU_getElement ( asdu , i ) ; printf ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>IOA:<S2SV_blank>%i<S2SV_blank>value:<S2SV_blank>%i\\n" , InformationObject_getObjectAddress ( ( InformationObject ) io ) , MeasuredValueScaled_getValue ( ( MeasuredValueScaled ) io ) ) ; MeasuredValueScaledWithCP56Time2a_destroy ( io ) ; } } else if ( CS101_ASDU_getTypeID ( asdu ) == M_SP_NA_1 ) { printf ( "<S2SV_blank><S2SV_blank>single<S2SV_blank>point<S2SV_blank>information:\\n" ) ; int i ; for ( i = 0 ; i < CS101_ASDU_getNumberOfElements ( asdu ) ; i ++ ) { SinglePointInformation io = ( SinglePointInformation ) CS101_ASDU_getElement ( asdu , i ) ; printf ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>IOA:<S2SV_blank>%i<S2SV_blank>value:<S2SV_blank>%i\\n" , InformationObject_getObjectAddress ( ( InformationObject ) io ) , SinglePointInformation_getValue ( ( SinglePointInformation ) io ) ) ; SinglePointInformation_destroy ( io ) ; } } return true ; } | <S2SV_ModStart> { printf ( "SLAVE<S2SV_blank>%i:<S2SV_blank>RECVD<S2SV_blank>ASDU<S2SV_blank>type:<S2SV_blank>%s(%i)<S2SV_blank>elements:<S2SV_blank>%i\\n" , address <S2SV_ModEnd> , TypeID_toString ( |
5,781 | CWE-000 static bool status_yaml_readdb_refine_sub ( yamlwrapper * wrapper , int refine_info_index , char * file_name ) { if ( refine_info_index < 0 || refine_info_index >= REFINE_TYPE_MAX ) return false ; int bonus_per_level = yaml_get_int ( wrapper , "StatsPerLevel" ) ; int random_bonus_start_level = yaml_get_int ( wrapper , "RandomBonusStartLevel" ) ; int random_bonus = yaml_get_int ( wrapper , "RandomBonusValue" ) ; yamlwrapper * costs = yaml_get_subnode ( wrapper , "Costs" ) ; yamliterator * it = yaml_get_iterator ( costs ) ; if ( yaml_iterator_is_valid ( it ) ) { for ( yamlwrapper * type = yaml_iterator_first ( it ) ; yaml_iterator_has_next ( it ) ; type = yaml_iterator_next ( it ) ) { int idx = 0 , price ; unsigned short material ; static char * keys [ ] = { "Type" , "Price" , "Material" } ; char * result ; if ( ( result = yaml_verify_nodes ( type , ARRAYLENGTH ( keys ) , keys ) ) != NULL ) { ShowWarning ( "status_yaml_readdb_refine_sub:<S2SV_blank>Invalid<S2SV_blank>refine<S2SV_blank>cost<S2SV_blank>with<S2SV_blank>undefined<S2SV_blank>" CL_WHITE "%s" CL_RESET "in<S2SV_blank>file" CL_WHITE "%s" CL_RESET ".\\n" , result , file_name ) ; yaml_destroy_wrapper ( type ) ; continue ; } char * refine_cost_const = yaml_get_c_string ( type , "Type" ) ; if ( ISDIGIT ( refine_cost_const [ 0 ] ) ) idx = atoi ( refine_cost_const ) ; else script_get_constant ( refine_cost_const , & idx ) ; price = yaml_get_int ( type , "Price" ) ; material = yaml_get_uint16 ( type , "Material" ) ; refine_info [ refine_info_index ] . cost [ idx ] . nameid = material ; refine_info [ refine_info_index ] . cost [ idx ] . zeny = price ; aFree ( refine_cost_const ) ; yaml_destroy_wrapper ( type ) ; } } yaml_destroy_wrapper ( costs ) ; yaml_iterator_destroy ( it ) ; yamlwrapper * rates = yaml_get_subnode ( wrapper , "Rates" ) ; it = yaml_get_iterator ( rates ) ; if ( yaml_iterator_is_valid ( it ) ) { for ( yamlwrapper * level = yaml_iterator_first ( it ) ; yaml_iterator_has_next ( it ) ; level = yaml_iterator_next ( it ) ) { int refine_level = yaml_get_int ( level , "Level" ) - 1 ; if ( refine_level >= MAX_REFINE ) { yaml_destroy_wrapper ( level ) ; continue ; } if ( yaml_node_is_defined ( level , "NormalChance" ) ) refine_info [ refine_info_index ] . chance [ REFINE_CHANCE_NORMAL ] [ refine_level ] = yaml_get_int ( level , "NormalChance" ) ; if ( yaml_node_is_defined ( level , "EnrichedChance" ) ) refine_info [ refine_info_index ] . chance [ REFINE_CHANCE_ENRICHED ] [ refine_level ] = yaml_get_int ( level , "EnrichedChance" ) ; if ( yaml_node_is_defined ( level , "EventNormalChance" ) ) refine_info [ refine_info_index ] . chance [ REFINE_CHANCE_EVENT_NORMAL ] [ refine_level ] = yaml_get_int ( level , "EventNormalChance" ) ; if ( yaml_node_is_defined ( level , "EventEnrichedChance" ) ) refine_info [ refine_info_index ] . chance [ REFINE_CHANCE_EVENT_ENRICHED ] [ refine_level ] = yaml_get_int ( level , "EventEnrichedChance" ) ; if ( yaml_node_is_defined ( level , "Bonus" ) ) refine_info [ refine_info_index ] . bonus [ refine_level ] = yaml_get_int ( level , "Bonus" ) ; if ( refine_level >= random_bonus_start_level - 1 ) refine_info [ refine_info_index ] . randombonus_max [ refine_level ] = random_bonus * ( refine_level - random_bonus_start_level + 2 ) ; <S2SV_StartBug> refine_info [ refine_info_index ] . bonus [ refine_level ] = bonus_per_level + ( refine_level > 0 ? refine_info [ refine_info_index ] . bonus [ refine_level - 1 ] : 0 ) ; <S2SV_EndBug> <S2SV_StartBug> yaml_destroy_wrapper ( level ) ; <S2SV_EndBug> } } yaml_destroy_wrapper ( rates ) ; yaml_iterator_destroy ( it ) ; return true ; } | <S2SV_ModStart> 2 ) ; yaml_destroy_wrapper ( level ) ; } for ( int refine_level = 0 ; refine_level < MAX_REFINE ; ++ refine_level ) { <S2SV_ModStart> [ refine_level ] += <S2SV_ModEnd> bonus_per_level + ( <S2SV_ModStart> 0 ) ; <S2SV_ModEnd> } } yaml_destroy_wrapper |
5,782 | CWE-000 <S2SV_StartBug> __attribute__ ( ( noreturn ) ) void pfatal ( const char * msg , ... ) { <S2SV_EndBug> va_list args ; <S2SV_StartBug> va_start ( args , msg ) ; <S2SV_EndBug> rb_raise ( cNativeError , msg , args ) ; va_end ( args ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> const char * fmt <S2SV_ModEnd> , ... ) <S2SV_ModStart> ... ) { const char * err = strerror ( errno ) ; VALUE msg ; <S2SV_ModStart> ( args , fmt ) ; msg = rb_vsprintf ( fmt <S2SV_ModEnd> , args ) <S2SV_ModStart> args ) ; rb_str_catf ( msg , ":<S2SV_blank>%s" , err ) ; rb_raise ( cNativeError , StringValueCStr ( msg ) ) ; |
5,783 | CWE-000 void or_word1024 ( __m256i * a , const __m256i * b ) { <S2SV_StartBug> for ( int i = 0 ; i < N ; i ++ ) <S2SV_EndBug> <S2SV_StartBug> a [ 0 ] = _mm256_or_si256 ( a [ i ] , b [ i ] ) ; <S2SV_EndBug> } | <S2SV_ModStart> ; i < BITS / 256 <S2SV_ModEnd> ; i ++ <S2SV_ModStart> ) a [ i <S2SV_ModEnd> ] = _mm256_or_si256 |
5,784 | CWE-000 static void file_tracepoint_callback ( VALUE tracepoint , void * data ) { VALUE self = ( VALUE ) data ; rb_trace_arg_t * tracepoint_arg = rb_tracearg_from_tracepoint ( tracepoint ) ; VALUE tracepoint_path = rb_tracearg_path ( tracepoint_arg ) ; <S2SV_StartBug> VALUE match_found ; <S2SV_EndBug> if ( ! RB_TYPE_P ( tracepoint_path , T_STRING ) ) return ; <S2SV_StartBug> tracepoint_path = rb_file_expand_path ( tracepoint_path , Qnil ) ; <S2SV_EndBug> match_found = match_breakpoints_files ( self , tracepoint_path ) ; if ( match_found ) { enable_line_trace_for_thread ( self ) ; enable_return_trace_for_thread ( self ) ; } else { disable_line_trace_for_thread ( Qnil ) ; } return ; } | <S2SV_ModStart> tracepoint_arg ) ; int <S2SV_ModEnd> match_found ; if <S2SV_ModStart> Qnil ) ; if ( ! RTEST ( tracepoint_path ) ) { return ; } |
5,785 | CWE-000 int main ( void ) { signal ( SIGINT , stopHandler ) ; UA_ClientConfig config = UA_ClientConfig_default ; config . stateCallback = stateCallback ; UA_Client * client = UA_Client_new ( config ) ; <S2SV_StartBug> UA_Boolean connected = false ; <S2SV_EndBug> <S2SV_StartBug> UA_StatusCode retval ; <S2SV_EndBug> retval = UA_Client_connect_async ( client , "opc.tcp://localhost:4840" , onConnect , & connected ) ; <S2SV_StartBug> while ( running ) { <S2SV_EndBug> if ( retval != UA_STATUSCODE_GOOD ) { UA_LOG_ERROR ( logger , UA_LOGCATEGORY_USERLAND , "Not<S2SV_blank>connected.<S2SV_blank>Retrying<S2SV_blank>to<S2SV_blank>connect<S2SV_blank>in<S2SV_blank>1<S2SV_blank>second" ) ; UA_sleep_ms ( 1000 ) ; continue ; } UA_Client_Subscriptions_manuallySendPublishRequest ( client ) ; <S2SV_StartBug> UA_Client_run_iterate ( client , & retval ) ; <S2SV_EndBug> <S2SV_StartBug> UA_sleep_ms ( 1000 ) ; <S2SV_EndBug> } ; UA_Client_delete ( client ) ; return UA_STATUSCODE_GOOD ; } | <S2SV_ModStart> config ) ; UA_StatusCode retval ; <S2SV_ModStart> = false ; # ifdef ASYNC <S2SV_ModEnd> retval = UA_Client_connect_async <S2SV_ModStart> connected ) ; # endif <S2SV_ModStart> running ) { # ifndef ASYNC retval = UA_Client_connect ( client , "opc.tcp://localhost:4840" ) ; # endif <S2SV_ModStart> client ) ; # ifdef ASYNC <S2SV_ModStart> retval ) ; # endif UA_sleep_ms ( 500 <S2SV_ModEnd> ) ; } |
5,786 | CWE-000 EAPI void ecore_main_loop_quit ( void ) { Eina_Value v = EINA_VALUE_EMPTY ; <S2SV_StartBug> int val = 0 ; <S2SV_EndBug> eina_value_setup ( & v , EINA_VALUE_TYPE_INT ) ; <S2SV_StartBug> eina_value_set ( & v , & val ) ; <S2SV_EndBug> EINA_MAIN_LOOP_CHECK_RETURN ; efl_loop_quit ( ML_OBJ , v ) ; } | <S2SV_ModStart> = EINA_VALUE_EMPTY ; <S2SV_ModEnd> eina_value_setup ( & <S2SV_ModStart> & v , 0 <S2SV_ModEnd> ) ; EINA_MAIN_LOOP_CHECK_RETURN |
5,787 | CWE-000 void getPrescriptionInfo ( int ssnhash ) { FILE * fp = fopen ( "./prescriptions.bin" , "r" ) ; if ( fp == NULL ) { printf ( "Could<S2SV_blank>not<S2SV_blank>find<S2SV_blank>or<S2SV_blank>open<S2SV_blank>\\"prescriptions.bin\\"<S2SV_blank>in<S2SV_blank>the<S2SV_blank>directory!\\n" ) ; pressEnterKey ( ) ; fclose ( fp ) ; return ; } else { const int count = getUserCount ( fp ) ; int i ; <S2SV_StartBug> int found = 0 ; <S2SV_EndBug> for ( i = 0 ; i < count ; ++ i ) { char * temp = malloc ( sizeof ( char * ) * MAX_CHAR * 11 ) ; if ( NULL == temp ) { free ( temp ) ; temp = NULL ; } char buffer [ MAX_CHAR * 11 ] ; strncpy ( buffer , decrypt ( getLine ( fp , i ) ) , MAX_CHAR * 11 ) ; temp = strtok ( buffer , "|" ) ; if ( ssnhash == ( int ) strtol ( temp , NULL , 10 ) ) { printf ( "Patient<S2SV_blank>Prescriptions\\n" ) ; printf ( "---------------------\\n" ) ; int comma = 0 ; int j = 0 ; char c = '<S2SV_blank>' ; while ( c != '\\n' ) { c = buffer [ j ] ; if ( c == ',' ) { comma ++ ; } j ++ ; } for ( i = 0 ; i < comma + 1 ; i ++ ) { temp = strtok ( NULL , "," ) ; printf ( "%d.)<S2SV_blank>%s\\n" , i + 1 , temp ) ; } fclose ( fp ) ; return ; } if ( temp != NULL ) { temp = NULL ; } } if ( found == 0 ) { printf ( "\\nCould<S2SV_blank>not<S2SV_blank>find<S2SV_blank>prescription<S2SV_blank>information<S2SV_blank>for<S2SV_blank>the<S2SV_blank>specified<S2SV_blank>patient.\\n" ) ; pressEnterKey ( ) ; } fclose ( fp ) ; } } | <S2SV_ModStart> int i ; const |
5,788 | CWE-000 static void fill_connection ( EAPMethod * parent , NMConnection * connection ) { EAPMethodTTLS * method = ( EAPMethodTTLS * ) parent ; NMSetting8021x * s_8021x ; NMSetting8021xCKFormat format = NM_SETTING_802_1X_CK_FORMAT_UNKNOWN ; # if LIBNM_BUILD NMSettingSecretFlags secret_flags ; # endif GtkWidget * widget ; const char * text ; char * value = NULL ; EAPMethod * eap = NULL ; GtkTreeModel * model ; GtkTreeIter iter ; GError * error = NULL ; NMSetting8021xCKScheme scheme ; gboolean ca_cert_error = FALSE ; s_8021x = nm_connection_get_setting_802_1x ( connection ) ; g_assert ( s_8021x ) ; nm_setting_802_1x_add_eap_method ( s_8021x , "ttls" ) ; widget = GTK_WIDGET ( gtk_builder_get_object ( parent -> builder , "eap_ttls_anon_identity_entry" ) ) ; g_assert ( widget ) ; text = gtk_entry_get_text ( GTK_ENTRY ( widget ) ) ; if ( text && strlen ( text ) ) <S2SV_StartBug> g_object_set ( s_8021x , NM_SETTING_802_1X_ANONYMOUS_IDENTITY , text , NULL ) ; <S2SV_EndBug> # if LIBNM_BUILD secret_flags = nma_cert_chooser_get_cert_password_flags ( NMA_CERT_CHOOSER ( method -> ca_cert_chooser ) ) ; nm_setting_set_secret_flags ( NM_SETTING ( s_8021x ) , NM_SETTING_802_1X_CA_CERT_PASSWORD , secret_flags , NULL ) ; if ( method -> is_editor ) { nma_cert_chooser_update_cert_password_storage ( NMA_CERT_CHOOSER ( method -> ca_cert_chooser ) , secret_flags , NM_SETTING ( s_8021x ) , NM_SETTING_802_1X_CA_CERT_PASSWORD ) ; } # endif if ( gtk_widget_get_sensitive ( method -> ca_cert_chooser ) ) value = nma_cert_chooser_get_cert ( NMA_CERT_CHOOSER ( method -> ca_cert_chooser ) , & scheme ) ; format = NM_SETTING_802_1X_CK_FORMAT_UNKNOWN ; if ( ! nm_setting_802_1x_set_ca_cert ( s_8021x , value , scheme , & format , & error ) ) { g_warning ( "Couldn\'t<S2SV_blank>read<S2SV_blank>CA<S2SV_blank>certificate<S2SV_blank>\'%s\':<S2SV_blank>%s" , value , error ? error -> message : "(unknown)" ) ; g_clear_error ( & error ) ; ca_cert_error = TRUE ; } eap_method_ca_cert_ignore_set ( parent , connection , value , ca_cert_error ) ; g_free ( value ) ; widget = GTK_WIDGET ( gtk_builder_get_object ( parent -> builder , "eap_ttls_inner_auth_combo" ) ) ; model = gtk_combo_box_get_model ( GTK_COMBO_BOX ( widget ) ) ; gtk_combo_box_get_active_iter ( GTK_COMBO_BOX ( widget ) , & iter ) ; gtk_tree_model_get ( model , & iter , I_METHOD_COLUMN , & eap , - 1 ) ; g_assert ( eap ) ; eap_method_fill_connection ( eap , connection ) ; eap_method_unref ( eap ) ; } | <S2SV_ModStart> NULL ) ; # if LIBNM_BUILD widget = GTK_WIDGET ( gtk_builder_get_object ( parent -> builder , "eap_ttls_domain_entry" ) ) ; g_assert ( widget ) ; text = gtk_entry_get_text ( GTK_ENTRY ( widget ) ) ; if ( text && strlen ( text ) ) g_object_set ( s_8021x , NM_SETTING_802_1X_DOMAIN_SUFFIX_MATCH , text , NULL ) ; # endif |
5,789 | CWE-000 bool xfs_repair_fs ( struct scrub_ctx * ctx ) { struct workqueue wq ; xfs_agnumber_t agno ; bool moveon = true ; int ret ; ret = workqueue_create ( & wq , ( struct xfs_mount * ) ctx , scrub_nproc ( ctx ) ) ; if ( ret ) { str_error ( ctx , ctx -> mntpoint , _ ( "Could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>workqueue." ) ) ; return false ; } for ( agno = 0 ; agno < ctx -> geo . agcount ; agno ++ ) { if ( xfs_repair_list_length ( & ctx -> repair_lists [ agno ] ) > 0 ) { ret = workqueue_add ( & wq , xfs_repair_ag , agno , & moveon ) ; if ( ret ) { moveon = false ; str_error ( ctx , ctx -> mntpoint , _ ( "Could<S2SV_blank>not<S2SV_blank>queue<S2SV_blank>repair<S2SV_blank>work." ) ) ; break ; } } if ( ! moveon ) break ; } workqueue_destroy ( & wq ) ; <S2SV_StartBug> return moveon ; <S2SV_EndBug> } | <S2SV_ModStart> wq ) ; pthread_mutex_lock ( & ctx -> lock ) ; if ( moveon && ctx -> errors_found == 0 ) fstrim ( ctx ) ; pthread_mutex_unlock ( & ctx -> lock ) ; |
5,790 | CWE-000 static void replace_variables ( struct MHD_Connection * connection , t_client * client , char * dst , size_t dst_len , const char * src , size_t src_len ) { s_config * config = config_get_config ( ) ; char nclients [ 12 ] ; char maxclients [ 12 ] ; char clientupload [ 20 ] ; char clientdownload [ 20 ] ; const char * redirect_url = NULL ; char * uptime = NULL ; char * denyaction = NULL ; char * authaction = NULL ; char * authtarget = NULL ; char * imagesdir = NULL ; char * pagesdir = NULL ; sprintf ( clientupload , "%llu" , client -> counters . outgoing ) ; sprintf ( clientdownload , "%llu" , client -> counters . incoming ) ; uptime = get_uptime_string ( ) ; redirect_url = get_redirect_url ( connection ) ; sprintf ( nclients , "%d" , get_client_list_length ( ) ) ; sprintf ( maxclients , "%d" , config -> maxclients ) ; <S2SV_StartBug> safe_asprintf ( & denyaction , "http://%s:%d/%s/" , config -> gw_address , config -> gw_port , config -> denydir ) ; <S2SV_EndBug> <S2SV_StartBug> safe_asprintf ( & authaction , "http://%s:%d/%s/" , config -> gw_address , config -> gw_port , config -> authdir ) ; <S2SV_EndBug> <S2SV_StartBug> safe_asprintf ( & authtarget , "http://%s:%d/%s/?tok=%s&redir=%s" , <S2SV_EndBug> <S2SV_StartBug> config -> gw_address , config -> gw_port , config -> authdir , client -> token , redirect_url ) ; <S2SV_EndBug> safe_asprintf ( & pagesdir , "/%s" , config -> pagesdir ) ; safe_asprintf ( & imagesdir , "/%s" , config -> imagesdir ) ; struct template vars [ ] = { { "authaction" , authaction } , { "denyaction" , denyaction } , { "authtarget" , authtarget } , { "clientip" , client -> ip } , { "clientmac" , client -> mac } , { "clientupload" , clientupload } , { "clientdownload" , clientdownload } , { "gatewaymac" , config -> gw_mac } , { "gatewayname" , config -> gw_name } , { "imagesdir" , imagesdir } , { "pagesdir" , pagesdir } , { "maxclients" , maxclients } , { "nclients" , nclients } , { "redir" , redirect_url } , { "tok" , client -> token } , { "token" , client -> token } , { "uptime" , uptime } , { "version" , VERSION } , { NULL , NULL } } ; tmpl_parse ( vars , dst , dst_len , src , src_len ) ; free ( uptime ) ; free ( denyaction ) ; free ( authaction ) ; free ( authtarget ) ; free ( pagesdir ) ; free ( imagesdir ) ; } | <S2SV_ModStart> & denyaction , "http://%s/%s/" <S2SV_ModEnd> , config -> <S2SV_ModStart> config -> gw_address <S2SV_ModEnd> , config -> <S2SV_ModStart> & authaction , "http://%s/%s/" <S2SV_ModEnd> , config -> <S2SV_ModStart> config -> gw_address <S2SV_ModEnd> , config -> <S2SV_ModStart> & authtarget , "http://%s/%s/?tok=%s&redir=%s" <S2SV_ModEnd> , config -> <S2SV_ModStart> config -> gw_address <S2SV_ModEnd> , config -> |
5,791 | CWE-000 void print_usage ( ) { <S2SV_StartBug> char * usage = "Usage:<S2SV_blank>gzinject<S2SV_blank>-a,--action=(genkey<S2SV_blank>|<S2SV_blank>extract<S2SV_blank>|<S2SV_blank>pack)<S2SV_blank>[options]\\r\\n<S2SV_blank><S2SV_blank>options:\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-a,<S2SV_blank>--action(genkey<S2SV_blank>|<S2SV_blank>extract<S2SV_blank>|<S2SV_blank>pack)\\tDefines<S2SV_blank>the<S2SV_blank>action<S2SV_blank>to<S2SV_blank>run\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>genkey<S2SV_blank>:<S2SV_blank>generates<S2SV_blank>a<S2SV_blank>common<S2SV_blank>key\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>extract<S2SV_blank>:<S2SV_blank>extracts<S2SV_blank>contents<S2SV_blank>of<S2SV_blank>wadfile<S2SV_blank>specified<S2SV_blank>by<S2SV_blank>--wad<S2SV_blank>to<S2SV_blank>--directory\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>pack<S2SV_blank>:<S2SV_blank>packs<S2SV_blank>contents<S2SV_blank>--directory<S2SV_blank><S2SV_blank>into<S2SV_blank>wad<S2SV_blank>specified<S2SV_blank>by<S2SV_blank>--wad\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-w,<S2SV_blank>--wad<S2SV_blank>wadfile\\t\\t\\t\\tDefines<S2SV_blank>the<S2SV_blank>wadfile<S2SV_blank>to<S2SV_blank>use<S2SV_blank>Input<S2SV_blank>wad<S2SV_blank>for<S2SV_blank>extracting,<S2SV_blank>output<S2SV_blank>wad<S2SV_blank>for<S2SV_blank>packing\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-d,<S2SV_blank>--directory<S2SV_blank>directory\\t\\t\\tDefines<S2SV_blank>the<S2SV_blank>output<S2SV_blank>directory<S2SV_blank>for<S2SV_blank>extract<S2SV_blank>operations,<S2SV_blank>or<S2SV_blank>the<S2SV_blank>input<S2SV_blank>directory<S2SV_blank>for<S2SV_blank>pack<S2SV_blank>operations\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-i,<S2SV_blank>--channelid<S2SV_blank>channelid\\t\\t\\tChanges<S2SV_blank>the<S2SV_blank>channel<S2SV_blank>id<S2SV_blank>during<S2SV_blank>packing(4<S2SV_blank>characters)\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-t,<S2SV_blank>--channeltitle<S2SV_blank>channeltitle\\t\\tChanges<S2SV_blank>the<S2SV_blank>channel<S2SV_blank>title<S2SV_blank>during<S2SV_blank>packing(max<S2SV_blank>20<S2SV_blank>characters)\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-r,<S2SV_blank>--region[0<S2SV_blank>-<S2SV_blank>3]\\t\\t\\t\\tChanges<S2SV_blank>the<S2SV_blank>WAD<S2SV_blank>region<S2SV_blank>during<S2SV_blank>packing<S2SV_blank>0<S2SV_blank>=<S2SV_blank>JP,<S2SV_blank>1<S2SV_blank>=<S2SV_blank>US,<S2SV_blank>2<S2SV_blank>=<S2SV_blank>Europe,<S2SV_blank>3<S2SV_blank>=<S2SV_blank>FREE\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-k,<S2SV_blank>--key<S2SV_blank>keyfile\\t\\t\\t\\tUses<S2SV_blank>the<S2SV_blank>specified<S2SV_blank>common<S2SV_blank>key<S2SV_blank>file\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--cleanup\\t\\t\\t\\t\\tCleans<S2SV_blank>up<S2SV_blank>the<S2SV_blank>wad<S2SV_blank>directory<S2SV_blank>before<S2SV_blank>extracting<S2SV_blank>or<S2SV_blank>after<S2SV_blank>packing\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-v,<S2SV_blank>--verbose\\t\\t\\t\\tPrints<S2SV_blank>verbose<S2SV_blank>information\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-?<S2SV_blank>,<S2SV_blank>--help\\t\\t\\t\\t\\tPrints<S2SV_blank>this<S2SV_blank>help<S2SV_blank>message" ; <S2SV_EndBug> printf ( "%s\\r\\n" , usage ) ; } | <S2SV_ModStart> * usage = "Usage:<S2SV_blank>gzinject<S2SV_blank>-a,--action=(genkey<S2SV_blank>|<S2SV_blank>extract<S2SV_blank>|<S2SV_blank>pack)<S2SV_blank>[options]\\r\\n<S2SV_blank><S2SV_blank>options:\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-a,<S2SV_blank>--action(genkey<S2SV_blank>|<S2SV_blank>extract<S2SV_blank>|<S2SV_blank>pack)\\tDefines<S2SV_blank>the<S2SV_blank>action<S2SV_blank>to<S2SV_blank>run\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>genkey<S2SV_blank>:<S2SV_blank>generates<S2SV_blank>a<S2SV_blank>common<S2SV_blank>key\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>extract<S2SV_blank>:<S2SV_blank>extracts<S2SV_blank>contents<S2SV_blank>of<S2SV_blank>wadfile<S2SV_blank>specified<S2SV_blank>by<S2SV_blank>--wad<S2SV_blank>to<S2SV_blank>--directory\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>pack<S2SV_blank>:<S2SV_blank>packs<S2SV_blank>contents<S2SV_blank>--directory<S2SV_blank><S2SV_blank>into<S2SV_blank>wad<S2SV_blank>specified<S2SV_blank>by<S2SV_blank>--wad\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-w,<S2SV_blank>--wad<S2SV_blank>wadfile\\t\\t\\t\\tDefines<S2SV_blank>the<S2SV_blank>wadfile<S2SV_blank>to<S2SV_blank>use<S2SV_blank>Input<S2SV_blank>wad<S2SV_blank>for<S2SV_blank>extracting,<S2SV_blank>output<S2SV_blank>wad<S2SV_blank>for<S2SV_blank>packing\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-d,<S2SV_blank>--directory<S2SV_blank>directory\\t\\t\\tDefines<S2SV_blank>the<S2SV_blank>output<S2SV_blank>directory<S2SV_blank>for<S2SV_blank>extract<S2SV_blank>operations,<S2SV_blank>or<S2SV_blank>the<S2SV_blank>input<S2SV_blank>directory<S2SV_blank>for<S2SV_blank>pack<S2SV_blank>operations\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-i,<S2SV_blank>--channelid<S2SV_blank>channelid\\t\\t\\tChanges<S2SV_blank>the<S2SV_blank>channel<S2SV_blank>id<S2SV_blank>during<S2SV_blank>packing(4<S2SV_blank>characters)\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-t,<S2SV_blank>--channeltitle<S2SV_blank>channeltitle\\t\\tChanges<S2SV_blank>the<S2SV_blank>channel<S2SV_blank>title<S2SV_blank>during<S2SV_blank>packing(max<S2SV_blank>20<S2SV_blank>characters)\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-r,<S2SV_blank>--region[0<S2SV_blank>-<S2SV_blank>3]\\t\\t\\t\\tChanges<S2SV_blank>the<S2SV_blank>WAD<S2SV_blank>region<S2SV_blank>during<S2SV_blank>packing<S2SV_blank>0<S2SV_blank>=<S2SV_blank>JP,<S2SV_blank>1<S2SV_blank>=<S2SV_blank>US,<S2SV_blank>2<S2SV_blank>=<S2SV_blank>Europe,<S2SV_blank>3<S2SV_blank>=<S2SV_blank>FREE\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-k,<S2SV_blank>--key<S2SV_blank>keyfile\\t\\t\\t\\tUses<S2SV_blank>the<S2SV_blank>specified<S2SV_blank>common<S2SV_blank>key<S2SV_blank>file\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--cleanup\\t\\t\\t\\t\\tCleans<S2SV_blank>up<S2SV_blank>the<S2SV_blank>wad<S2SV_blank>directory<S2SV_blank>before<S2SV_blank>extracting<S2SV_blank>or<S2SV_blank>after<S2SV_blank>packing\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-v,<S2SV_blank>--verbose\\t\\t\\t\\tPrints<S2SV_blank>verbose<S2SV_blank>information\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-v<S2SV_blank>,<S2SV_blank>--version\\t\\t\\t\\t\\tPrints<S2SV_blank>Version<S2SV_blank>information\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-?<S2SV_blank>,<S2SV_blank>--help\\t\\t\\t\\t\\tPrints<S2SV_blank>this<S2SV_blank>help<S2SV_blank>message" <S2SV_ModEnd> ; printf ( |
5,792 | CWE-000 static void compute_convolution_depthwise_output ( <S2SV_StartBug> const struct convolution_output_context context [ restrict static 1 ] , <S2SV_EndBug> size_t sample , size_t output_channel ) { const size_t input_channels = context -> input_channels ; const size_t output_channels = context -> output_channels ; const size_t depthwise_multiplier = context -> depthwise_multiplier ; const struct nnp_size input_size = context -> input_size ; const struct nnp_padding input_padding = context -> input_padding ; const struct nnp_size kernel_size = context -> kernel_size ; const struct nnp_size output_size = context -> output_size ; const struct nnp_size output_subsampling = context -> output_subsampling ; const float ( * input ) [ input_channels ] [ input_size . height ] [ input_size . width ] = ( const float ( * ) [ input_channels ] [ input_size . height ] [ input_size . width ] ) context -> input_pointer ; const float ( * kernel ) [ input_channels ] [ kernel_size . height ] [ kernel_size . width ] = ( const float ( * ) [ input_channels ] [ kernel_size . height ] [ kernel_size . width ] ) context -> kernel_pointer ; float ( * output ) [ output_channels ] [ output_size . height ] [ output_size . width ] = ( float ( * ) [ output_channels ] [ output_size . height ] [ output_size . width ] ) context -> output_pointer ; size_t depthwise_channel = output_channel % depthwise_multiplier ; size_t input_channel = output_channel / depthwise_multiplier ; for ( size_t y = 0 ; y < output_size . height ; y ++ ) { for ( size_t x = 0 ; x < output_size . width ; x ++ ) { double v = 0.0 ; for ( size_t i = 0 ; i < kernel_size . height ; i ++ ) { const size_t s = y * output_subsampling . height + i - input_padding . top ; if ( s < input_size . height ) { for ( size_t j = 0 ; j < kernel_size . width ; j ++ ) { const size_t t = x * output_subsampling . width + j - input_padding . left ; if ( t < input_size . width ) { v += input [ sample ] [ input_channel ] [ s ] [ t ] * kernel [ depthwise_channel ] [ input_channel ] [ i ] [ j ] ; } } } } output [ sample ] [ output_channel ] [ y ] [ x ] = v + context -> bias [ output_channel ] ; } } } | <S2SV_ModStart> ( const struct convolution_depthwise_output_context <S2SV_ModEnd> context [ restrict |
5,793 | CWE-000 Plan * add_second_stage_agg ( PlannerInfo * root , bool is_agg , List * lower_tlist , List * upper_tlist , List * upper_qual , AggStrategy aggstrategy , int numGroupCols , AttrNumber * prelimGroupColIdx , Oid * prelimGroupOperators , int num_nullcols , uint64 input_grouping , uint64 grouping , int rollup_gs_times , double numGroups , int numAggs , int transSpace , const char * alias , List * * p_current_pathkeys , Plan * result_plan , bool use_root , bool adjust_scatter ) { Query * parse = root -> parse ; Query * subquery ; List * newrtable ; RangeTblEntry * newrte ; RangeTblRef * newrtref ; Plan * agg_node ; subquery = copyObject ( parse ) ; subquery -> targetList = copyObject ( lower_tlist ) ; subquery -> havingQual = NULL ; { ListCell * cell ; foreach ( cell , subquery -> targetList ) { TargetEntry * tle = ( TargetEntry * ) lfirst ( cell ) ; tle -> resjunk = false ; if ( tle -> resname == NULL ) { if ( use_root && IsA ( tle -> expr , Var ) ) { Var * var = ( Var * ) tle -> expr ; RangeTblEntry * rte = rt_fetch ( var -> varno , root -> parse -> rtable ) ; tle -> resname = pstrdup ( get_rte_attribute_name ( rte , var -> varattno ) ) ; } else { const char * fmt = "unnamed_attr_%d" ; char buf [ 32 ] ; sprintf ( buf , fmt , tle -> resno ) ; tle -> resname = pstrdup ( buf ) ; } } } } SS_finalize_plan ( root , result_plan , false ) ; newrte = addRangeTableEntryForSubquery ( NULL , subquery , makeAlias ( alias , NULL ) , TRUE ) ; newrtable = list_make1 ( newrte ) ; parse -> querySource = QSRC_PLANNER ; parse -> rtable = newrtable ; parse -> jointree = makeNode ( FromExpr ) ; newrtref = makeNode ( RangeTblRef ) ; newrtref -> rtindex = 1 ; parse -> jointree -> fromlist = list_make1 ( newrtref ) ; parse -> jointree -> quals = NULL ; parse -> rowMarks = NIL ; if ( use_root ) { if ( adjust_scatter ) { UpdateScatterClause ( parse , upper_tlist ) ; } parse -> targetList = copyObject ( upper_tlist ) ; } result_plan = add_subqueryscan ( root , p_current_pathkeys , 1 , subquery , result_plan ) ; long lNumGroups = ( long ) Min ( numGroups , ( double ) LONG_MAX ) ; agg_node = ( Plan * ) make_agg ( root , upper_tlist , upper_qual , aggstrategy , false , numGroupCols , prelimGroupColIdx , prelimGroupOperators , lNumGroups , num_nullcols , input_grouping , grouping , rollup_gs_times , numAggs , transSpace , result_plan ) ; agg_node -> flow = pull_up_Flow ( agg_node , agg_node -> lefttree ) ; <S2SV_StartBug> root -> parse -> groupClause = copyObject ( root -> parse -> groupClause ) ; <S2SV_EndBug> if ( root -> simple_rel_array ) pfree ( root -> simple_rel_array ) ; if ( root -> simple_rte_array ) pfree ( root -> simple_rte_array ) ; rebuild_simple_rel_and_rte ( root ) ; return agg_node ; } | <S2SV_ModStart> lefttree ) ; if ( aggstrategy != AGG_SORTED ) * p_current_pathkeys = NIL ; |
5,794 | CWE-000 static ssize_t environ_read ( struct file * file , char __user * buf , size_t count , loff_t * ppos ) { char * page ; unsigned long src = * ppos ; int ret = 0 ; struct mm_struct * mm = file -> private_data ; unsigned long env_start , env_end ; if ( ! mm || ! mm -> env_end ) return 0 ; page = ( char * ) __get_free_page ( GFP_TEMPORARY ) ; if ( ! page ) return - ENOMEM ; ret = 0 ; if ( ! atomic_inc_not_zero ( & mm -> mm_users ) ) goto free ; <S2SV_StartBug> down_read ( & mm -> mmap_sem ) ; <S2SV_EndBug> env_start = mm -> env_start ; env_end = mm -> env_end ; <S2SV_StartBug> up_read ( & mm -> mmap_sem ) ; <S2SV_EndBug> while ( count > 0 ) { size_t this_len , max_len ; int retval ; if ( src >= ( env_end - env_start ) ) break ; this_len = env_end - ( env_start + src ) ; max_len = min_t ( size_t , PAGE_SIZE , count ) ; this_len = min ( max_len , this_len ) ; retval = access_remote_vm ( mm , ( env_start + src ) , page , this_len , FOLL_ANON ) ; if ( retval <= 0 ) { ret = retval ; break ; } if ( copy_to_user ( buf , page , retval ) ) { ret = - EFAULT ; break ; } ret += retval ; src += retval ; buf += retval ; count -= retval ; } * ppos = src ; mmput ( mm ) ; free : free_page ( ( unsigned long ) page ) ; return ret ; } | <S2SV_ModStart> goto free ; spin_lock <S2SV_ModEnd> ( & mm <S2SV_ModStart> & mm -> arg_lock ) ; env_start = mm -> env_start ; env_end = mm -> env_end ; spin_unlock <S2SV_ModEnd> ( & mm <S2SV_ModStart> & mm -> arg_lock <S2SV_ModEnd> ) ; while |
5,795 | CWE-000 static void compose_savemsg_select_cb ( GtkWidget * widget , Compose * compose ) { FolderItem * dest ; gchar * path ; <S2SV_StartBug> dest = foldersel_folder_sel ( NULL , FOLDER_SEL_COPY , NULL , FALSE ) ; <S2SV_EndBug> if ( ! dest ) return ; path = folder_item_get_identifier ( dest ) ; compose_set_save_to ( compose , path ) ; g_free ( path ) ; } | <S2SV_ModStart> NULL , FALSE , _ ( "Select<S2SV_blank>folder<S2SV_blank>to<S2SV_blank>save<S2SV_blank>message<S2SV_blank>to" ) |
5,796 | CWE-000 void MX_GPIO_Init ( void ) { GPIO_InitTypeDef GPIO_InitStruct ; __HAL_RCC_GPIOF_CLK_ENABLE ( ) ; __HAL_RCC_GPIOC_CLK_ENABLE ( ) ; __HAL_RCC_GPIOA_CLK_ENABLE ( ) ; __HAL_RCC_GPIOB_CLK_ENABLE ( ) ; __HAL_RCC_GPIOD_CLK_ENABLE ( ) ; HAL_GPIO_WritePin ( GPIOB , MOTOR_A_POS_Pin | MOTOR_A_NEG_Pin , GPIO_PIN_RESET ) ; HAL_GPIO_WritePin ( GPIOC , GPIO_PIN_6 | MOTOR_B_POS_Pin | MOTOR_B_NEG_Pin , GPIO_PIN_RESET ) ; HAL_GPIO_WritePin ( GPIOA , MOTOR_C_POS_Pin | MOTOR_C_NEG_Pin , GPIO_PIN_RESET ) ; <S2SV_StartBug> GPIO_InitStruct . Pin = DIN_0_Pin | DIN_1_Pin | DIN_6_Pin | MOTOR_B_ENC_A_Pin ; <S2SV_EndBug> GPIO_InitStruct . Mode = GPIO_MODE_INPUT ; GPIO_InitStruct . Pull = GPIO_NOPULL ; HAL_GPIO_Init ( GPIOC , & GPIO_InitStruct ) ; GPIO_InitStruct . Pin = DIN_2_Pin | DIN_3_Pin | DIN_4_Pin | DIN_5_Pin | MOTOR_C_ENC_A_Pin | MOTOR_C_ENC_B_Pin | MOTOR_A_ENC_A_Pin | MOTOR_A_ENC_B_Pin | LIMIT_SWITCH_1_Pin | LIMIT_SWITCH_2_Pin ; GPIO_InitStruct . Mode = GPIO_MODE_INPUT ; GPIO_InitStruct . Pull = GPIO_NOPULL ; HAL_GPIO_Init ( GPIOB , & GPIO_InitStruct ) ; GPIO_InitStruct . Pin = MOTOR_A_POS_Pin | MOTOR_A_NEG_Pin ; GPIO_InitStruct . Mode = GPIO_MODE_OUTPUT_PP ; GPIO_InitStruct . Pull = GPIO_NOPULL ; GPIO_InitStruct . Speed = GPIO_SPEED_FREQ_LOW ; HAL_GPIO_Init ( GPIOB , & GPIO_InitStruct ) ; GPIO_InitStruct . Pin = GPIO_PIN_6 | MOTOR_B_POS_Pin | MOTOR_B_NEG_Pin ; GPIO_InitStruct . Mode = GPIO_MODE_OUTPUT_PP ; GPIO_InitStruct . Pull = GPIO_NOPULL ; GPIO_InitStruct . Speed = GPIO_SPEED_FREQ_LOW ; HAL_GPIO_Init ( GPIOC , & GPIO_InitStruct ) ; GPIO_InitStruct . Pin = DIN_7_Pin | DIN_8_Pin | DIN_9_Pin ; GPIO_InitStruct . Mode = GPIO_MODE_INPUT ; GPIO_InitStruct . Pull = GPIO_NOPULL ; HAL_GPIO_Init ( GPIOA , & GPIO_InitStruct ) ; GPIO_InitStruct . Pin = MOTOR_C_POS_Pin | MOTOR_C_NEG_Pin ; GPIO_InitStruct . Mode = GPIO_MODE_OUTPUT_PP ; GPIO_InitStruct . Pull = GPIO_NOPULL ; GPIO_InitStruct . Speed = GPIO_SPEED_FREQ_LOW ; HAL_GPIO_Init ( GPIOA , & GPIO_InitStruct ) ; GPIO_InitStruct . Pin = MOTOR_B_ENC_B_Pin ; GPIO_InitStruct . Mode = GPIO_MODE_INPUT ; GPIO_InitStruct . Pull = GPIO_NOPULL ; HAL_GPIO_Init ( MOTOR_B_ENC_B_GPIO_Port , & GPIO_InitStruct ) ; } | <S2SV_ModStart> . Pin = GPIO_PIN_0 | |
5,797 | CWE-000 static void show_worktree_porcelain ( struct worktree * wt ) { printf ( "worktree<S2SV_blank>%s\\n" , wt -> path ) ; if ( wt -> is_bare ) printf ( "bare\\n" ) ; else { printf ( "HEAD<S2SV_blank>%s\\n" , sha1_to_hex ( wt -> head_sha1 ) ) ; if ( wt -> is_detached ) printf ( "detached\\n" ) ; <S2SV_StartBug> else <S2SV_EndBug> printf ( "branch<S2SV_blank>%s\\n" , wt -> head_ref ) ; } printf ( "\\n" ) ; } | <S2SV_ModStart> ) ; else if ( wt -> head_ref ) |
5,798 | CWE-000 gfc_expr * gfc_build_init_expr ( gfc_typespec * ts , locus * where , bool force ) { <S2SV_StartBug> int char_len ; <S2SV_EndBug> <S2SV_StartBug> gfc_expr * init_expr ; <S2SV_EndBug> int i ; init_expr = gfc_get_constant_expr ( ts -> type , ts -> kind , where ) ; gfc_init_local_real init_real = flag_init_real ; int init_logical = gfc_option . flag_init_logical ; if ( force ) { if ( init_real == GFC_INIT_REAL_OFF ) init_real = GFC_INIT_REAL_ZERO ; if ( init_logical == GFC_INIT_LOGICAL_OFF ) init_logical = GFC_INIT_LOGICAL_FALSE ; } switch ( ts -> type ) { case BT_INTEGER : if ( force || gfc_option . flag_init_integer != GFC_INIT_INTEGER_OFF ) mpz_set_si ( init_expr -> value . integer , gfc_option . flag_init_integer_value ) ; else { gfc_free_expr ( init_expr ) ; init_expr = NULL ; } break ; case BT_REAL : switch ( init_real ) { case GFC_INIT_REAL_SNAN : init_expr -> is_snan = 1 ; case GFC_INIT_REAL_NAN : mpfr_set_nan ( init_expr -> value . real ) ; break ; case GFC_INIT_REAL_INF : mpfr_set_inf ( init_expr -> value . real , 1 ) ; break ; case GFC_INIT_REAL_NEG_INF : mpfr_set_inf ( init_expr -> value . real , - 1 ) ; break ; case GFC_INIT_REAL_ZERO : mpfr_set_ui ( init_expr -> value . real , 0.0 , GFC_RND_MODE ) ; break ; default : gfc_free_expr ( init_expr ) ; init_expr = NULL ; break ; } break ; case BT_COMPLEX : switch ( init_real ) { case GFC_INIT_REAL_SNAN : init_expr -> is_snan = 1 ; case GFC_INIT_REAL_NAN : mpfr_set_nan ( mpc_realref ( init_expr -> value . complex ) ) ; mpfr_set_nan ( mpc_imagref ( init_expr -> value . complex ) ) ; break ; case GFC_INIT_REAL_INF : mpfr_set_inf ( mpc_realref ( init_expr -> value . complex ) , 1 ) ; mpfr_set_inf ( mpc_imagref ( init_expr -> value . complex ) , 1 ) ; break ; case GFC_INIT_REAL_NEG_INF : mpfr_set_inf ( mpc_realref ( init_expr -> value . complex ) , - 1 ) ; mpfr_set_inf ( mpc_imagref ( init_expr -> value . complex ) , - 1 ) ; break ; case GFC_INIT_REAL_ZERO : mpc_set_ui ( init_expr -> value . complex , 0 , GFC_MPC_RND_MODE ) ; break ; default : gfc_free_expr ( init_expr ) ; init_expr = NULL ; break ; } break ; case BT_LOGICAL : if ( init_logical == GFC_INIT_LOGICAL_FALSE ) init_expr -> value . logical = 0 ; else if ( init_logical == GFC_INIT_LOGICAL_TRUE ) init_expr -> value . logical = 1 ; else { gfc_free_expr ( init_expr ) ; init_expr = NULL ; } break ; case BT_CHARACTER : if ( ( force || gfc_option . flag_init_character == GFC_INIT_CHARACTER_ON ) && ts -> u . cl -> length && ts -> u . cl -> length -> expr_type == EXPR_CONSTANT ) { <S2SV_StartBug> char_len = mpz_get_si ( ts -> u . cl -> length -> value . integer ) ; <S2SV_EndBug> init_expr -> value . character . length = char_len ; init_expr -> value . character . string = gfc_get_wide_string ( char_len + 1 ) ; <S2SV_StartBug> for ( i = 0 ; i < char_len ; i ++ ) <S2SV_EndBug> init_expr -> value . character . string [ i ] = ( unsigned char ) gfc_option . flag_init_character_value ; } else { gfc_free_expr ( init_expr ) ; init_expr = NULL ; } if ( ! init_expr && ( force || gfc_option . flag_init_character == GFC_INIT_CHARACTER_ON ) && ts -> u . cl -> length && flag_max_stack_var_size != 0 ) { gfc_actual_arglist * arg ; init_expr = gfc_get_expr ( ) ; init_expr -> where = * where ; init_expr -> ts = * ts ; init_expr -> expr_type = EXPR_FUNCTION ; init_expr -> value . function . isym = gfc_intrinsic_function_by_id ( GFC_ISYM_REPEAT ) ; init_expr -> value . function . name = "repeat" ; arg = gfc_get_actual_arglist ( ) ; arg -> expr = gfc_get_character_expr ( ts -> kind , where , NULL , 1 ) ; arg -> expr -> value . character . string [ 0 ] = gfc_option . flag_init_character_value ; arg -> next = gfc_get_actual_arglist ( ) ; arg -> next -> expr = gfc_copy_expr ( ts -> u . cl -> length ) ; init_expr -> value . function . actual = arg ; } break ; default : gfc_free_expr ( init_expr ) ; init_expr = NULL ; } return init_expr ; } | <S2SV_ModStart> force ) { <S2SV_ModEnd> gfc_expr * init_expr <S2SV_ModStart> gfc_expr * init_expr <S2SV_ModEnd> ; init_expr = <S2SV_ModStart> EXPR_CONSTANT ) { HOST_WIDE_INT char_len = gfc_mpz_get_hwi <S2SV_ModEnd> ( ts -> <S2SV_ModStart> ; for ( size_t <S2SV_ModStart> ; i < ( size_t ) |
5,799 | CWE-000 void test_mm512_prefetch_i64scatter_pd ( void * addr , __m512i index ) { <S2SV_StartBug> return _mm512_prefetch_i64scatter_pd ( addr , index , 1 , 2 ) ; <S2SV_EndBug> } | <S2SV_ModStart> , 1 , _MM_HINT_T1 <S2SV_ModEnd> ) ; } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.