Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
5,900 | CWE-000 static int gen_expr ( Node * node ) { if ( node -> ty == ND_NUM ) { int r = regno ++ ; <S2SV_StartBug> add ( IR_IMM , r , node -> val ) ; <S2SV_EndBug> return r ; } if ( node -> ty == IR_CALL ) { int args [ 6 ] ; for ( int i = 0 ; i < node -> args -> len ; i ++ ) { args [ i ] = gen_expr ( node -> args -> data [ i ] ) ; } int r = regno ++ ; IR * ir = add ( IR_CALL , r , - 1 ) ; ir -> name = node -> name ; ir -> nargs = node -> args -> len ; memcpy ( ir -> args , args , sizeof ( args ) ) ; for ( int i = 0 ; i < ir -> nargs ; i ++ ) { add ( IR_KILL , ir -> args [ i ] , - 1 ) ; } return r ; } if ( node -> ty == '=' ) { int rhs = gen_expr ( node -> rhs ) ; int lhs = gen_lval ( node -> lhs ) ; add ( IR_STORE , lhs , rhs ) ; add ( IR_KILL , rhs , - 1 ) ; return lhs ; } assert ( strchr ( "+-*/" , node -> ty ) ) ; int lhs = gen_expr ( node -> lhs ) ; int rhs = gen_expr ( node -> rhs ) ; add ( node -> ty , lhs , rhs ) ; add ( IR_KILL , rhs , - 1 ) ; return lhs ; } | <S2SV_ModStart> node -> val ) ; return r ; } if ( node -> ty == ND_IDENT ) { int r = gen_lval ( node ) ; add ( IR_LOAD , r , r |
5,901 | CWE-000 static int aesbs_xts_decrypt ( struct blkcipher_desc * desc , struct scatterlist * dst , struct scatterlist * src , unsigned int nbytes ) { struct aesbs_xts_ctx * ctx = crypto_blkcipher_ctx ( desc -> tfm ) ; struct blkcipher_walk walk ; int err ; blkcipher_walk_init ( & walk , dst , src , nbytes ) ; err = blkcipher_walk_virt_block ( desc , & walk , 8 * AES_BLOCK_SIZE ) ; AES_encrypt ( walk . iv , walk . iv , & ctx -> twkey ) ; while ( walk . nbytes ) { kernel_neon_begin ( ) ; bsaes_xts_decrypt ( walk . src . virt . addr , walk . dst . virt . addr , walk . nbytes , & ctx -> dec , walk . iv ) ; kernel_neon_end ( ) ; <S2SV_StartBug> err = blkcipher_walk_done ( desc , & walk , 0 ) ; <S2SV_EndBug> } return err ; } | <S2SV_ModStart> & walk , walk . nbytes % AES_BLOCK_SIZE <S2SV_ModEnd> ) ; } |
5,902 | CWE-000 gpointer gcr_secure_memory_try_realloc ( gpointer memory , gsize size ) { gpointer new_memory ; if ( ! memory ) { return gcr_secure_memory_try_alloc ( size ) ; } else if ( ! size ) { gcr_secure_memory_free ( memory ) ; return NULL ; } else if ( ! egg_secure_check ( memory ) ) { return g_try_realloc ( memory , size ) ; } new_memory = egg_secure_realloc_full ( "gcr-secure-memory" , memory , size , 0 ) ; <S2SV_StartBug> g_assert ( new_memory != NULL ) ; <S2SV_EndBug> return new_memory ; } | <S2SV_ModStart> 0 ) ; <S2SV_ModEnd> return new_memory ; |
5,903 | CWE-000 <S2SV_StartBug> void column_init ( int i ) <S2SV_EndBug> { m [ i ] [ 0 ] . cost = i ; if ( i > 0 ) m [ i ] [ 0 ] . parent = DELETE ; else m [ 0 ] [ i ] . parent = - 1 ; } | <S2SV_ModStart> ( int i , cell m [ MAXLEN + 1 ] [ MAXLEN + 1 ] |
5,904 | CWE-000 celix_status_t pubsub_topicPublicationRemoveSerializer ( topic_publication_pt pub , pubsub_serializer_service_t * svc ) { celix_status_t status = CELIX_SUCCESS ; celixThreadMutex_lock ( & ( pub -> tp_lock ) ) ; if ( pub -> serializerSvc == svc ) { hash_map_iterator_t iter = hashMapIterator_construct ( pub -> boundServices ) ; while ( hashMapIterator_hasNext ( & iter ) ) { publish_bundle_bound_service_t * bound = hashMapIterator_nextValue ( & iter ) ; celixThreadMutex_lock ( & bound -> mp_lock ) ; pub -> serializerSvc -> destroySerializerMap ( pub -> serializerSvc -> handle , bound -> map ) ; celixThreadMutex_unlock ( & bound -> mp_lock ) ; bound -> map = NULL ; } <S2SV_StartBug> } <S2SV_EndBug> <S2SV_StartBug> pub -> serializerSvc = NULL ; <S2SV_EndBug> celixThreadMutex_unlock ( & ( pub -> tp_lock ) ) ; return status ; } | <S2SV_ModStart> NULL ; } <S2SV_ModEnd> pub -> serializerSvc <S2SV_ModStart> = NULL ; } |
5,905 | CWE-000 static void read_string ( lexState * ls , int flag ) { next ( ls ) ; while ( ls -> current != flag ) { switch ( ls -> current ) { case '\\\\' : { int c ; next ( ls ) ; switch ( ls -> current ) { case 'a' : c = '\\a' ; goto save_flag ; case 'b' : c = '\\b' ; goto save_flag ; case 'f' : c = '\\f' ; goto save_flag ; case 'n' : c = '\\n' ; goto save_flag ; case 'r' : c = '\\r' ; goto save_flag ; case 't' : c = '\\t' ; goto save_flag ; case 'v' : c = '\\v' ; goto save_flag ; case 'u' : { next ( ls ) ; unsigned ucode = handle_surrogate ( ls ) ; if ( ucode == 0 ) goto no_save_flag ; encodeutf8 ( ls , ucode ) ; goto no_save_flag ; } <S2SV_StartBug> case '\\n' : case '\\r' : case '\\\\' : case \'\\"\' : case '\\'' : <S2SV_EndBug> c = ls -> current ; goto save_flag ; default : c = ls -> current ; goto save_flag ; } break ; save_flag : save ( ls , c ) ; next ( ls ) ; break ; no_save_flag : break ; } default : <S2SV_StartBug> if ( ls -> current == EOF ) error_msg ( "Unexpected<S2SV_blank>end!" ) ; <S2SV_EndBug> save_and_next ( ls , ls -> current ) ; break ; } } next ( ls ) ; settoken ( ls , LEX_STRING ) ; } | <S2SV_ModStart> no_save_flag ; } <S2SV_ModEnd> default : c <S2SV_ModStart> ) error_msg ( "Unexpected<S2SV_blank>\'EOF\'" <S2SV_ModEnd> ) ; save_and_next |
5,906 | CWE-000 int available_freepages ( size_t num ) { <S2SV_StartBug> return nfreepages >= num ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> num ) { lock_nfreepages ( ) ; int res = <S2SV_ModEnd> nfreepages >= num <S2SV_ModStart> >= num ; unlock_nfreepages ( ) ; return res ; |
5,907 | CWE-000 static int wlan_suspend ( hdd_context_t * pHddCtx ) { long rc = 0 ; pVosSchedContext vosSchedContext = NULL ; vosSchedContext = get_vos_sched_ctxt ( ) ; if ( ! vosSchedContext ) { VOS_TRACE ( VOS_MODULE_ID_HDD , VOS_TRACE_LEVEL_FATAL , "%s:<S2SV_blank>Global<S2SV_blank>VOS_SCHED<S2SV_blank>context<S2SV_blank>is<S2SV_blank>Null" , __func__ ) ; return 0 ; } if ( ! pHddCtx -> last_suspend_success ) pHddCtx -> last_suspend_success = vos_timer_get_system_time ( ) ; if ( ! vos_is_apps_power_collapse_allowed ( pHddCtx ) ) { pHddCtx -> continuous_suspend_fail_cnt ++ ; VOS_TRACE ( VOS_MODULE_ID_HDD , VOS_TRACE_LEVEL_ERROR , FL ( "Fail<S2SV_blank>wlan<S2SV_blank>suspend:<S2SV_blank>not<S2SV_blank>in<S2SV_blank>IMPS/BMPS,<S2SV_blank>continuous<S2SV_blank>Failcnt<S2SV_blank>%d" ) , pHddCtx -> continuous_suspend_fail_cnt ) ; if ( ( vos_timer_get_system_time ( ) - pHddCtx -> last_suspend_success ) >= WLAN_POWER_COLLAPSE_FAIL_THRESHOLD ) { pHddCtx -> last_suspend_success = 0 ; vos_fatal_event_logs_req ( WLAN_LOG_TYPE_FATAL , WLAN_LOG_INDICATOR_HOST_DRIVER , WLAN_LOG_REASON_POWER_COLLAPSE_FAIL , FALSE , TRUE ) ; } return - EPERM ; } pHddCtx -> continuous_suspend_fail_cnt = 0 ; VOS_TRACE ( VOS_MODULE_ID_HDD , VOS_TRACE_LEVEL_INFO , "%s:<S2SV_blank>Suspending<S2SV_blank>Mc,<S2SV_blank>Rx<S2SV_blank>and<S2SV_blank>Tx<S2SV_blank>Threads" , __func__ ) ; INIT_COMPLETION ( pHddCtx -> tx_sus_event_var ) ; <S2SV_StartBug> set_bit ( TX_SUSPEND_EVENT_MASK , & vosSchedContext -> txEventFlag ) ; <S2SV_EndBug> wake_up_interruptible ( & vosSchedContext -> txWaitQueue ) ; rc = wait_for_completion_interruptible_timeout ( & pHddCtx -> tx_sus_event_var , msecs_to_jiffies ( 200 ) ) ; if ( rc <= 0 ) { VOS_TRACE ( VOS_MODULE_ID_HDD , VOS_TRACE_LEVEL_FATAL , "%s:<S2SV_blank>TX<S2SV_blank>Thread:<S2SV_blank>timeout<S2SV_blank>while<S2SV_blank>suspending<S2SV_blank>%ld" , __func__ , rc ) ; <S2SV_StartBug> if ( ! test_and_clear_bit ( TX_SUSPEND_EVENT_MASK , <S2SV_EndBug> & vosSchedContext -> txEventFlag ) ) { VOS_TRACE ( VOS_MODULE_ID_HDD , VOS_TRACE_LEVEL_ERROR , "%s:<S2SV_blank>TX<S2SV_blank>Thread:<S2SV_blank>will<S2SV_blank>still<S2SV_blank>suspend" , __func__ ) ; goto tx_suspend ; } if ( ( vos_timer_get_system_time ( ) - pHddCtx -> last_suspend_success ) >= WLAN_POWER_COLLAPSE_FAIL_THRESHOLD ) { pHddCtx -> last_suspend_success = 0 ; vos_fatal_event_logs_req ( WLAN_LOG_TYPE_FATAL , WLAN_LOG_INDICATOR_HOST_DRIVER , WLAN_LOG_REASON_POWER_COLLAPSE_FAIL , FALSE , TRUE ) ; } return - ETIME ; } tx_suspend : pHddCtx -> isTxThreadSuspended = TRUE ; INIT_COMPLETION ( pHddCtx -> rx_sus_event_var ) ; <S2SV_StartBug> set_bit ( RX_SUSPEND_EVENT_MASK , & vosSchedContext -> rxEventFlag ) ; <S2SV_EndBug> wake_up_interruptible ( & vosSchedContext -> rxWaitQueue ) ; rc = wait_for_completion_interruptible_timeout ( & pHddCtx -> rx_sus_event_var , msecs_to_jiffies ( 200 ) ) ; if ( rc <= 0 ) { VOS_TRACE ( VOS_MODULE_ID_HDD , VOS_TRACE_LEVEL_FATAL , "%s:<S2SV_blank>RX<S2SV_blank>Thread:<S2SV_blank>timeout<S2SV_blank>while<S2SV_blank>suspending<S2SV_blank>%ld" , __func__ , rc ) ; <S2SV_StartBug> if ( ! test_and_clear_bit ( RX_SUSPEND_EVENT_MASK , <S2SV_EndBug> & vosSchedContext -> rxEventFlag ) ) { VOS_TRACE ( VOS_MODULE_ID_HDD , VOS_TRACE_LEVEL_ERROR , "%s:<S2SV_blank>RX<S2SV_blank>Thread:<S2SV_blank>will<S2SV_blank>still<S2SV_blank>suspend" , __func__ ) ; goto rx_suspend ; } complete ( & vosSchedContext -> ResumeTxEvent ) ; pHddCtx -> isTxThreadSuspended = FALSE ; if ( ( vos_timer_get_system_time ( ) - pHddCtx -> last_suspend_success ) >= WLAN_POWER_COLLAPSE_FAIL_THRESHOLD ) { pHddCtx -> last_suspend_success = 0 ; vos_fatal_event_logs_req ( WLAN_LOG_TYPE_FATAL , WLAN_LOG_INDICATOR_HOST_DRIVER , WLAN_LOG_REASON_POWER_COLLAPSE_FAIL , FALSE , TRUE ) ; } return - ETIME ; } rx_suspend : pHddCtx -> isRxThreadSuspended = TRUE ; INIT_COMPLETION ( pHddCtx -> mc_sus_event_var ) ; <S2SV_StartBug> set_bit ( MC_SUSPEND_EVENT_MASK , & vosSchedContext -> mcEventFlag ) ; <S2SV_EndBug> wake_up_interruptible ( & vosSchedContext -> mcWaitQueue ) ; rc = wait_for_completion_interruptible_timeout ( & pHddCtx -> mc_sus_event_var , msecs_to_jiffies ( 200 ) ) ; if ( rc <= 0 ) { VOS_TRACE ( VOS_MODULE_ID_HDD , VOS_TRACE_LEVEL_FATAL , "%s:<S2SV_blank>MC<S2SV_blank>Thread:<S2SV_blank>timeout<S2SV_blank>while<S2SV_blank>suspending<S2SV_blank>%ld" , __func__ , rc ) ; <S2SV_StartBug> if ( ! test_and_clear_bit ( MC_SUSPEND_EVENT_MASK , <S2SV_EndBug> & vosSchedContext -> mcEventFlag ) ) { VOS_TRACE ( VOS_MODULE_ID_HDD , VOS_TRACE_LEVEL_ERROR , "%s:<S2SV_blank>MC<S2SV_blank>Thread:<S2SV_blank>will<S2SV_blank>still<S2SV_blank>suspend" , __func__ ) ; goto mc_suspend ; } complete ( & vosSchedContext -> ResumeRxEvent ) ; pHddCtx -> isRxThreadSuspended = FALSE ; complete ( & vosSchedContext -> ResumeTxEvent ) ; pHddCtx -> isTxThreadSuspended = FALSE ; if ( ( vos_timer_get_system_time ( ) - pHddCtx -> last_suspend_success ) >= WLAN_POWER_COLLAPSE_FAIL_THRESHOLD ) { pHddCtx -> last_suspend_success = 0 ; vos_fatal_event_logs_req ( WLAN_LOG_TYPE_FATAL , WLAN_LOG_INDICATOR_HOST_DRIVER , WLAN_LOG_REASON_POWER_COLLAPSE_FAIL , FALSE , TRUE ) ; } return - ETIME ; } mc_suspend : pHddCtx -> isMcThreadSuspended = TRUE ; pHddCtx -> isWlanSuspended = TRUE ; pHddCtx -> last_suspend_success = 0 ; hdd_wlan_suspend_resume_event ( HDD_WLAN_SUSPEND ) ; return 0 ; } | <S2SV_ModStart> ; set_bit ( TX_SUSPEND_EVENT <S2SV_ModEnd> , & vosSchedContext <S2SV_ModStart> ! test_and_clear_bit ( TX_SUSPEND_EVENT <S2SV_ModEnd> , & vosSchedContext <S2SV_ModStart> ; set_bit ( RX_SUSPEND_EVENT <S2SV_ModEnd> , & vosSchedContext <S2SV_ModStart> ! test_and_clear_bit ( RX_SUSPEND_EVENT <S2SV_ModEnd> , & vosSchedContext <S2SV_ModStart> ; set_bit ( MC_SUSPEND_EVENT <S2SV_ModEnd> , & vosSchedContext <S2SV_ModStart> ! test_and_clear_bit ( MC_SUSPEND_EVENT <S2SV_ModEnd> , & vosSchedContext |
5,908 | CWE-000 <S2SV_StartBug> void freeBoard ( Board * * boardPtrPtr ) { <S2SV_EndBug> unsigned int i , j ; unsigned int N ; <S2SV_StartBug> Board * boardPtr = * boardPtrPtr ; <S2SV_EndBug> <S2SV_StartBug> Cell * temp_cell ; <S2SV_EndBug> printf ( "freeBoard<S2SV_blank>-<S2SV_blank>Good<S2SV_blank>luck\\n" ) ; if ( boardPtr == NULL ) { return ; } <S2SV_StartBug> printf ( "freeBoard<S2SV_blank>-<S2SV_blank>1\\n" ) ; <S2SV_EndBug> N = boardPtr -> m * boardPtr -> n ; for ( i = 0 ; i < N ; i ++ ) { for ( j = 0 ; j < N ; j ++ ) { if ( boardPtr -> board [ i ] [ j ] . possible_vals != NULL ) { <S2SV_StartBug> printf ( "\t\t\tfree<S2SV_blank>%d,%d\\n" , i , j ) ; <S2SV_EndBug> printf ( "possible_vals[0]<S2SV_blank>==<S2SV_blank>%d\\n" , boardPtr -> board [ i ] [ j ] . possible_vals [ 0 ] ) ; temp_cell = getCell ( boardPtr , i , j ) ; free ( temp_cell -> possible_vals ) ; } } if ( boardPtr -> board [ i ] != NULL ) { free ( boardPtr -> board [ i ] ) ; <S2SV_StartBug> printf ( "\tfree<S2SV_blank>row<S2SV_blank>%d\\n" , i ) ; <S2SV_EndBug> } } printf ( "freeBoard<S2SV_blank>-<S2SV_blank>2\\n" ) ; if ( boardPtr -> board != NULL ) { free ( boardPtr -> board ) ; } boardPtr = NULL ; } | <S2SV_ModStart> ( Board * boardPtr <S2SV_ModEnd> ) { unsigned <S2SV_ModStart> int N ; <S2SV_ModEnd> Cell * temp_cell <S2SV_ModStart> Cell * temp_cell <S2SV_ModEnd> ; if ( <S2SV_ModStart> return ; } <S2SV_ModEnd> N = boardPtr <S2SV_ModStart> NULL ) { <S2SV_ModEnd> temp_cell = getCell <S2SV_ModStart> ] ) ; } } <S2SV_ModEnd> if ( boardPtr |
5,909 | CWE-000 static int cache_ref_iterator_abort ( struct ref_iterator * ref_iterator ) { struct cache_ref_iterator * iter = ( struct cache_ref_iterator * ) ref_iterator ; <S2SV_StartBug> free ( iter -> levels ) ; <S2SV_EndBug> base_ref_iterator_free ( ref_iterator ) ; return ITER_DONE ; } | <S2SV_ModStart> ; free ( ( char * ) iter -> prefix ) ; free ( |
5,910 | CWE-000 static bool data_flow_join ( void * data , struct cling_data_flow_callback const * algorithm , <S2SV_StartBug> struct cling_basic_block const * cur_blk , <S2SV_EndBug> struct utillib_vector const * blocks ) { bool changed = false ; struct cling_basic_block const * block ; UTILLIB_VECTOR_FOREACH ( block , blocks ) <S2SV_StartBug> if ( algorithm -> join ( data , cur_blk -> block_id , block -> block_id ) ) <S2SV_EndBug> changed = true ; return changed ; } | <S2SV_ModStart> * algorithm , int block_id <S2SV_ModEnd> , struct utillib_vector <S2SV_ModStart> ( data , <S2SV_ModEnd> block_id , block |
5,911 | CWE-000 char * edit_exit ( t_line * line ) { move_cursor_lastline ( line ) ; move_cursor_bufflen_from_lastline ( line ) ; <S2SV_StartBug> ft_putchar_fd ( '\\n' , 2 ) ; <S2SV_EndBug> edit_insert_str ( line , line -> buff + ft_strlen ( line -> buff ) , "\\n" ) ; <S2SV_StartBug> return ( line -> buff ) ; <S2SV_EndBug> } | <S2SV_ModStart> line ) ; <S2SV_ModEnd> edit_insert_str ( line <S2SV_ModStart> "\\n" ) ; ft_putchar_fd ( '\\n' , 2 ) ; |
5,912 | CWE-000 static gchar * * simple_notes_event_create_split ( SimpleNotesEvent * object , gchar * strippedBuffer , GError * * error ) { gchar * search = NULL ; gchar * previousSearch = strippedBuffer ; <S2SV_StartBug> size_t len = strlen ( previousSearch ) ; <S2SV_EndBug> gchar * spaceBeforeQuote = previousSearch ; gchar * openQuoteSearch = NULL , * closeQuoteSearch = NULL ; SIMPLE_NOTES_TRY_WITHOUT_ERROR ( simple_notes_event_find_quotes ( object , previousSearch , len , & openQuoteSearch , & closeQuoteSearch , error ) ) ; GPtrArray * splitBuff = g_ptr_array_new_with_free_func ( g_free ) ; while ( ( search = g_strstr_len ( previousSearch , len , "<S2SV_blank>" ) ) ) { if ( ! ( openQuoteSearch != NULL && search > openQuoteSearch && search < closeQuoteSearch ) ) { gchar * previous = spaceBeforeQuote ; if ( * previous == '<S2SV_blank>' ) { previous ++ ; } size_t copyLen = search - previous ; <S2SV_StartBug> gchar * copy = g_malloc ( sizeof ( gchar * ) * ( copyLen + 1 ) ) ; <S2SV_EndBug> strncpy ( copy , previous , copyLen ) ; copy [ copyLen ] = '\\0' ; simple_notes_event_copy_split_part ( object , copy , splitBuff ) ; <S2SV_StartBug> spaceBeforeQuote = search ; <S2SV_EndBug> } search += 1 ; len -= search - previousSearch ; previousSearch = search ; } if ( * spaceBeforeQuote == '<S2SV_blank>' ) { spaceBeforeQuote ++ ; } gchar * copy = g_malloc ( sizeof ( gchar * ) * ( strlen ( spaceBeforeQuote ) + 1 ) ) ; strcpy ( copy , spaceBeforeQuote ) ; simple_notes_event_copy_split_part ( object , copy , splitBuff ) ; g_ptr_array_add ( splitBuff , NULL ) ; gchar * * split = ( gchar * * ) g_ptr_array_free ( splitBuff , FALSE ) ; return split ; } | <S2SV_ModStart> previousSearch ) ; if ( ! len ) { if ( error ) { * error = g_error_new ( kSimpleNotesDomain , 22 , "Empty<S2SV_blank>command" ) ; } return NULL ; } <S2SV_ModStart> - previous ; if ( copyLen ) { <S2SV_ModStart> splitBuff ) ; } |
5,913 | CWE-000 static int set_config_int32_option ( const char * name , int32 value , GucContext context ) { char buf [ 16 ] ; if ( snprintf ( buf , 16 , "%d" , value ) < 0 ) { ereport ( pg_hint_plan_message_level , <S2SV_StartBug> ( errmsg ( "Cannot<S2SV_blank>set<S2SV_blank>integer<S2SV_blank>value:<S2SV_blank>%d:<S2SV_blank>%s" , <S2SV_EndBug> max_hint_nworkers , strerror ( errno ) ) ) ) ; return false ; } return set_config_option_noerror ( name , buf , context , PGC_S_SESSION , GUC_ACTION_SAVE , true , pg_hint_plan_message_level ) ; } | <S2SV_ModStart> ( errmsg ( "Failed<S2SV_blank>to<S2SV_blank>convert<S2SV_blank>integer<S2SV_blank>to<S2SV_blank>string:<S2SV_blank>%d" , value <S2SV_ModEnd> ) ) ) |
5,914 | CWE-000 int initADXL ( ) { int ans ; __delay_us ( 2000 ) ; <S2SV_StartBug> ans = readAddr ( ADXL345_DEVID ) ; <S2SV_EndBug> if ( ans == ADXL345_DEVID_VALUE ) { <S2SV_StartBug> writeAddr ( ADXL345_POWER_CTL , 0x08 ) ; <S2SV_EndBug> <S2SV_StartBug> writeAddr ( ADXL345_BW_RATE , 0x0A ) ; <S2SV_EndBug> <S2SV_StartBug> writeAddr ( ADXL345_DATA_FORMAT , 0x0B ) ; <S2SV_EndBug> <S2SV_StartBug> writeAddr ( ADXL345_FIFO_CTL , 0x00 ) ; <S2SV_EndBug> __delay_us ( 2000 ) ; } else ans = - 1 ; return ans ; } | <S2SV_ModStart> ; ans = readADXLAddr <S2SV_ModEnd> ( ADXL345_DEVID ) <S2SV_ModStart> ADXL345_DEVID_VALUE ) { writeADXLAddr <S2SV_ModEnd> ( ADXL345_POWER_CTL , <S2SV_ModStart> 0x08 ) ; writeADXLAddr <S2SV_ModEnd> ( ADXL345_BW_RATE , <S2SV_ModStart> 0x0A ) ; writeADXLAddr <S2SV_ModEnd> ( ADXL345_DATA_FORMAT , <S2SV_ModStart> 0x0B ) ; writeADXLAddr <S2SV_ModEnd> ( ADXL345_FIFO_CTL , |
5,915 | CWE-000 static void set_counter ( CUDAState * s , CUDATimer * ti , unsigned int val ) { CUDA_DPRINTF ( "T%d.counter=%d\\n" , 1 + ti -> index , val ) ; <S2SV_StartBug> ti -> load_time = get_tb ( qemu_clock_get_ns ( QEMU_CLOCK_VIRTUAL ) , <S2SV_EndBug> s -> frequency ) ; ti -> counter_value = val ; cuda_timer_update ( s , ti , ti -> load_time ) ; } | <S2SV_ModStart> -> load_time = get_counter_load_time ( s , ti <S2SV_ModEnd> ) ; ti |
5,916 | CWE-000 void gpio_interrupt_callback ( void * data , uint8_t port_pin ) { wiced_result_t result ; wiced_hal_gpio_clear_pin_interrupt_status ( WICED_GPIO_PIN_BUTTON_1 ) ; manuf_data ++ ; <S2SV_StartBug> e01_ble_adv_set_advertisement_data ( ) ; <S2SV_EndBug> result = wiced_bt_start_advertisements ( BTM_BLE_ADVERT_NONCONN_HIGH , 0 , NULL ) ; WICED_BT_TRACE ( "wiced_bt_start_advertisements:<S2SV_blank>%d\\n\\r" , result ) ; } | <S2SV_ModStart> manuf_data ++ ; ex01_ble_adv_set_advertisement_data <S2SV_ModEnd> ( ) ; |
5,917 | CWE-000 static int zpa2326_wait_oneshot_completion ( const struct iio_dev * indio_dev , struct zpa2326_private * private ) { <S2SV_StartBug> int ret ; <S2SV_EndBug> unsigned int val ; long timeout ; zpa2326_dbg ( indio_dev , "waiting<S2SV_blank>for<S2SV_blank>one<S2SV_blank>shot<S2SV_blank>completion<S2SV_blank>interrupt" ) ; timeout = wait_for_completion_interruptible_timeout ( & private -> data_ready , ZPA2326_CONVERSION_JIFFIES ) ; if ( timeout > 0 ) return private -> result ; regmap_read ( private -> regmap , ZPA2326_INT_SOURCE_REG , & val ) ; if ( ! timeout ) { zpa2326_warn ( indio_dev , "no<S2SV_blank>one<S2SV_blank>shot<S2SV_blank>interrupt<S2SV_blank>occurred<S2SV_blank>(%ld)" , timeout ) ; <S2SV_StartBug> ret = - ETIME ; <S2SV_EndBug> <S2SV_StartBug> } else if ( timeout < 0 ) { <S2SV_EndBug> zpa2326_warn ( indio_dev , "wait<S2SV_blank>for<S2SV_blank>one<S2SV_blank>shot<S2SV_blank>interrupt<S2SV_blank>cancelled" ) ; <S2SV_StartBug> ret = - ERESTARTSYS ; <S2SV_EndBug> } <S2SV_StartBug> return ret ; <S2SV_EndBug> } | <S2SV_ModStart> private ) { <S2SV_ModEnd> unsigned int val <S2SV_ModStart> timeout ) ; return <S2SV_ModEnd> - ETIME ; <S2SV_ModStart> ETIME ; } <S2SV_ModEnd> zpa2326_warn ( indio_dev <S2SV_ModStart> "wait<S2SV_blank>for<S2SV_blank>one<S2SV_blank>shot<S2SV_blank>interrupt<S2SV_blank>cancelled" ) ; return <S2SV_ModEnd> - ERESTARTSYS ; <S2SV_ModStart> ERESTARTSYS ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
5,918 | CWE-000 bool vfs_create ( const path_t * start , const char * pathname , uint32_t mode , bool excl ) { path_t wd ; char * last ; if ( ! get_path_wd ( start , pathname , & wd , & last ) ) { return false ; } path_t f ; if ( vfs_lookup ( & wd , last , & f ) ) { if ( excl ) { kfree ( last ) ; return false ; } } else { char * copy = strdup ( last ) ; dentry_t * new = dentry_alloc ( copy ) ; wd . dentry -> inode -> ops -> create ( wd . dentry -> inode , new , mode ) ; <S2SV_StartBug> if ( ! new -> inode ) { <S2SV_EndBug> kfree ( copy ) ; return false ; } dentry_activate ( new , wd . dentry ) ; } return true ; } | <S2SV_ModStart> new -> inode || ! validate_inode ( new ) |
5,919 | CWE-000 int amqpvalue_get_sasl_mechanisms ( AMQP_VALUE value , SASL_MECHANISMS_HANDLE * sasl_mechanisms_handle ) { int result ; SASL_MECHANISMS_INSTANCE * sasl_mechanisms_instance = ( SASL_MECHANISMS_INSTANCE * ) sasl_mechanisms_create_internal ( ) ; * sasl_mechanisms_handle = sasl_mechanisms_instance ; if ( * sasl_mechanisms_handle == NULL ) { result = __FAILURE__ ; } else { AMQP_VALUE list_value = amqpvalue_get_inplace_described_value ( value ) ; if ( list_value == NULL ) { sasl_mechanisms_destroy ( * sasl_mechanisms_handle ) ; result = __FAILURE__ ; } else { uint32_t list_item_count ; if ( amqpvalue_get_list_item_count ( list_value , & list_item_count ) != 0 ) { result = __FAILURE__ ; } else { do { AMQP_VALUE item_value ; if ( list_item_count > 0 ) { item_value = amqpvalue_get_list_item ( list_value , 0 ) ; if ( item_value == NULL ) { { sasl_mechanisms_destroy ( * sasl_mechanisms_handle ) ; result = __FAILURE__ ; break ; } } else { if ( amqpvalue_get_type ( item_value ) == AMQP_TYPE_NULL ) { amqpvalue_destroy ( item_value ) ; sasl_mechanisms_destroy ( * sasl_mechanisms_handle ) ; result = __FAILURE__ ; break ; } else { const char * sasl_server_mechanisms = NULL ; AMQP_VALUE sasl_server_mechanisms_array ; <S2SV_StartBug> if ( ( amqpvalue_get_array ( item_value , & sasl_server_mechanisms_array ) != 0 ) && <S2SV_EndBug> ( amqpvalue_get_symbol ( item_value , & sasl_server_mechanisms ) != 0 ) ) { amqpvalue_destroy ( item_value ) ; sasl_mechanisms_destroy ( * sasl_mechanisms_handle ) ; result = __FAILURE__ ; break ; } } amqpvalue_destroy ( item_value ) ; } } else { result = __FAILURE__ ; } sasl_mechanisms_instance -> composite_value = amqpvalue_clone ( value ) ; result = 0 ; } while ( ( void ) 0 , 0 ) ; } } } return result ; } | <S2SV_ModStart> if ( ( ( amqpvalue_get_type ( item_value ) != AMQP_TYPE_ARRAY ) || ( <S2SV_ModStart> ) != 0 ) |
5,920 | CWE-000 static void eevee_render_result_normal ( <S2SV_StartBug> RenderResult * rr , RenderLayer * rl , const char * viewname , <S2SV_EndBug> EEVEE_Data * vedata , EEVEE_ViewLayerData * UNUSED ( sldata ) ) { const DRWContextState * draw_ctx = DRW_context_state_get ( ) ; ViewLayer * view_layer = draw_ctx -> view_layer ; EEVEE_StorageList * stl = vedata -> stl ; EEVEE_PrivateData * g_data = stl -> g_data ; if ( stl -> effects -> taa_current_sample > 1 ) return ; if ( ( view_layer -> passflag & SCE_PASS_NORMAL ) != 0 ) { RenderPass * rp = RE_pass_find_by_name ( rl , RE_PASSNAME_NORMAL , viewname ) ; <S2SV_StartBug> DRW_framebuffer_read_data ( rr -> xof , rr -> yof , rr -> rectx , rr -> recty , 3 , 1 , rp -> rect ) ; <S2SV_EndBug> for ( int i = 0 ; i < rr -> rectx * rr -> recty * 3 ; i += 3 ) { if ( rp -> rect [ i ] == 0.0f && rp -> rect [ i + 1 ] == 0.0f ) { continue ; } float fenc [ 2 ] ; fenc [ 0 ] = rp -> rect [ i + 0 ] * 4.0f - 2.0f ; fenc [ 1 ] = rp -> rect [ i + 1 ] * 4.0f - 2.0f ; float f = dot_v2v2 ( fenc , fenc ) ; float g = sqrtf ( 1.0f - f / 4.0f ) ; rp -> rect [ i + 0 ] = fenc [ 0 ] * g ; rp -> rect [ i + 1 ] = fenc [ 1 ] * g ; rp -> rect [ i + 2 ] = 1.0f - f / 2.0f ; mul_mat3_m4_v3 ( g_data -> viewinv , & rp -> rect [ i ] ) ; } } } | <S2SV_ModStart> void eevee_render_result_normal ( <S2SV_ModEnd> RenderLayer * rl <S2SV_ModStart> char * viewname , const rcti * rect <S2SV_ModStart> ; DRW_framebuffer_read_data ( rect -> xmin , rect -> ymin , BLI_rcti_size_x ( rect ) , BLI_rcti_size_y ( rect ) , 3 , 1 , rp -> rect ) ; for ( int i = 0 ; i < rp -> rectx * rp <S2SV_ModEnd> -> recty * |
5,921 | CWE-000 void send_result_to_client ( int fd , void * data ) { int nsend ; if ( data == NULL ) return ; nsend = write ( fd , data , strlen ( data ) ) ; if ( nsend == - 1 ) { if ( errno == EAGAIN || errno == EWOULDBLOCK ) return ; printf ( "send<S2SV_blank>error:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; <S2SV_StartBug> return ; <S2SV_EndBug> } } | <S2SV_ModStart> ) ) ; set_event ( fd , NULL , SMD_DEL_EVENT , NULL , NULL ) ; close ( fd ) ; |
5,922 | CWE-000 unsigned neighbour_rxcost ( struct neighbour * neigh ) { unsigned delay , udelay ; unsigned short reach = neigh -> hello . reach ; unsigned short ureach = neigh -> uhello . reach ; delay = timeval_minus_msec ( & now , & neigh -> hello . time ) ; udelay = timeval_minus_msec ( & now , & neigh -> uhello . time ) ; if ( ( ( reach & 0xFFF0 ) == 0 || delay >= 180000 ) && ( ( ureach & 0xFFF0 ) == 0 || udelay >= 180000 ) ) { <S2SV_StartBug> return INFINITY ; <S2SV_EndBug> } else if ( ( neigh -> ifp -> flags & IF_LQ ) ) { int sreach = ( ( reach & 0x8000 ) >> 2 ) + ( ( reach & 0x4000 ) >> 1 ) + ( reach & 0x3FFF ) ; int cost = ( 0x8000 * neigh -> ifp -> cost ) / ( sreach + 1 ) ; if ( delay >= 40000 ) cost = ( cost * ( delay - 20000 ) + 10000 ) / 20000 ; <S2SV_StartBug> return MIN ( cost , INFINITY ) ; <S2SV_EndBug> } else { if ( two_three ( reach ) || two_three ( ureach ) ) return neigh -> ifp -> cost ; else <S2SV_StartBug> return INFINITY ; <S2SV_EndBug> } } | <S2SV_ModStart> ) { return BABEL_INFINITY <S2SV_ModEnd> ; } else <S2SV_ModStart> ( cost , BABEL_INFINITY <S2SV_ModEnd> ) ; } <S2SV_ModStart> ; else return BABEL_INFINITY <S2SV_ModEnd> ; } } |
5,923 | CWE-000 bool parser_block_build ( vector * tokens , ast_node * root , vector * symbol_table ) { for ( int i = 0 ; i < tokens -> count ; i ++ ) { ast_node * line_number = parser_linenumber_build ( tokens , & i ) ; if ( line_number == NULL ) { lexical_token * current_token = tokens -> data [ i ] ; printf ( "ERROR:<S2SV_blank>Line<S2SV_blank>number<S2SV_blank>not<S2SV_blank>found:<S2SV_blank>%s\\n" , current_token -> value . data ) ; exit ( - 1 ) ; } ast_node * keyword = parser_keyword_build ( tokens , & i ) ; if ( keyword == NULL ) { lexical_token * current_token = tokens -> data [ i ] ; printf ( "ERROR:<S2SV_blank>Keyword<S2SV_blank>not<S2SV_blank>found:<S2SV_blank>%s\\n" , current_token -> value . data ) ; exit ( - 1 ) ; } if ( ! ast_parsearguments ( tokens , keyword , & i , symbol_table ) ) { lexical_token * current_token = tokens -> data [ i ] ; printf ( "ERROR:<S2SV_blank>Invalid<S2SV_blank>argument:<S2SV_blank>%s\\n" , current_token -> value . data ) ; exit ( - 1 ) ; } vector_add ( & root -> children , line_number ) ; vector_add ( & line_number -> children , keyword ) ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ) ; } return true ; |
5,924 | CWE-000 int app_debug ( struct Application * app , const char * cypher ) { struct timespec t [ 7 ] ; BoltUtil_get_time ( & t [ 1 ] ) ; <S2SV_StartBug> app_connect ( app ) ; <S2SV_EndBug> BoltUtil_get_time ( & t [ 2 ] ) ; BoltConnection_load_begin_request ( app -> connection ) ; BoltConnection_cypher ( app -> connection , cypher , strlen ( cypher ) , 0 ) ; BoltConnection_load_run_request ( app -> connection ) ; bolt_request_t run = BoltConnection_last_request ( app -> connection ) ; BoltConnection_load_pull_request ( app -> connection , - 1 ) ; bolt_request_t pull = BoltConnection_last_request ( app -> connection ) ; BoltConnection_load_commit_request ( app -> connection ) ; bolt_request_t commit = BoltConnection_last_request ( app -> connection ) ; BoltConnection_send ( app -> connection ) ; BoltUtil_get_time ( & t [ 3 ] ) ; long record_count = 0 ; BoltConnection_fetch_summary ( app -> connection , run ) ; BoltUtil_get_time ( & t [ 4 ] ) ; while ( BoltConnection_fetch ( app -> connection , pull ) ) { record_count += 1 ; } BoltConnection_fetch_summary ( app -> connection , commit ) ; BoltUtil_get_time ( & t [ 5 ] ) ; BoltConnector_release ( app -> connector , app -> connection ) ; BoltUtil_get_time ( & t [ 6 ] ) ; fprintf ( stderr , "query<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>%s\\n" , cypher ) ; fprintf ( stderr , "record<S2SV_blank>count<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>%ld\\n" , record_count ) ; fprintf ( stderr , "=====================================\\n" ) ; timespec_diff ( & t [ 0 ] , & t [ 2 ] , & t [ 1 ] ) ; fprintf ( stderr , "initialisation<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>%lds<S2SV_blank>%09ldns\\n" , ( long ) t [ 0 ] . tv_sec , t [ 0 ] . tv_nsec ) ; timespec_diff ( & t [ 0 ] , & t [ 3 ] , & t [ 2 ] ) ; fprintf ( stderr , "query<S2SV_blank>transmission<S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>%lds<S2SV_blank>%09ldns\\n" , ( long ) t [ 0 ] . tv_sec , t [ 0 ] . tv_nsec ) ; timespec_diff ( & t [ 0 ] , & t [ 4 ] , & t [ 3 ] ) ; fprintf ( stderr , "query<S2SV_blank>processing<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>%lds<S2SV_blank>%09ldns\\n" , ( long ) t [ 0 ] . tv_sec , t [ 0 ] . tv_nsec ) ; timespec_diff ( & t [ 0 ] , & t [ 5 ] , & t [ 4 ] ) ; fprintf ( stderr , "result<S2SV_blank>processing<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>%lds<S2SV_blank>%09ldns\\n" , ( long ) t [ 0 ] . tv_sec , t [ 0 ] . tv_nsec ) ; timespec_diff ( & t [ 0 ] , & t [ 6 ] , & t [ 5 ] ) ; fprintf ( stderr , "shutdown<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>%lds<S2SV_blank>%09ldns\\n" , ( long ) t [ 0 ] . tv_sec , t [ 0 ] . tv_nsec ) ; timespec_diff ( & t [ 0 ] , & t [ 6 ] , & t [ 1 ] ) ; fprintf ( stderr , "=====================================\\n" ) ; fprintf ( stderr , "TOTAL<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>%lds<S2SV_blank>%09ldns\\n" , ( long ) t [ 0 ] . tv_sec , t [ 0 ] . tv_nsec ) ; BoltConnector_release ( app -> connector , app -> connection ) ; return 0 ; } | <S2SV_ModStart> ] ) ; app -> connector -> config -> log -> debug_enabled = 1 ; app -> connector -> config -> log -> info_enabled = 1 ; app -> connector -> config -> log -> warning_enabled = 1 ; app -> connector -> config -> log -> error_enabled = 1 ; |
5,925 | CWE-000 bool initialize_enemy ( int frame_index ) { <S2SV_StartBug> switch ( frame_index ) <S2SV_EndBug> { case 120 : enemy_exists = 1 ; octorok1 . x = 240 ; octorok1 . y = 220 ; octorok1 . dir = DIR_DOWN ; chhar_spawn ( & octorok1 , 0 ) ; enemy_move ( & octorok1 ) ; octorok2 . x = 320 ; octorok2 . y = 240 ; octorok2 . dir = DIR_UP ; enemy_move ( & octorok1 ) ; chhar_spawn ( & octorok2 , 3 ) ; enemy_move ( & octorok2 ) ; octorok3 . x = 320 ; octorok3 . y = 290 ; octorok3 . dir = DIR_DOWN ; enemy_move ( & octorok1 ) ; chhar_spawn ( & octorok3 , 0 ) ; enemy_move ( & octorok3 ) ; octorok4 . x = 355 ; octorok4 . y = 250 ; octorok4 . dir = DIR_LEFT ; enemy_move ( & octorok1 ) ; chhar_spawn ( & octorok4 , 0 ) ; enemy_move ( & octorok4 ) ; return 1 ; case 125 : return 0 ; default : enemy_exists = 0 ; return 0 ; } } | <S2SV_ModStart> frame_index ) { random_enemy_position ( ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
5,926 | CWE-000 void loadConfig ( const char * file ) { if ( file == NULL ) { return ; } char buf [ 201 ] ; FILE * fp = fopen ( file , "r" ) ; if ( ! fp ) { Log ( LOG_WARNING , "the<S2SV_blank>log<S2SV_blank>file<S2SV_blank>can\'t<S2SV_blank>open<S2SV_blank>%s" , "error" , file ) ; return ; } char * p ; while ( fgets ( buf , 201 , fp ) != NULL ) { p = strstr ( buf , "logfile=" ) ; if ( p != NULL ) { p += 8 ; while ( * p == '<S2SV_blank>' ) p ++ ; server . logfile = p ; int i = 0 ; while ( * ( p + i ) != '\\r' && * ( p + i ) != '\\n' && * ( p + i ) != '\\0' ) i ++ ; server . logfile [ i ] = 0 ; char * c = malloc ( strlen ( server . logfile ) + 1 ) ; memcpy ( c , server . logfile , strlen ( server . logfile ) ) ; server . logfile = c ; } p = strstr ( buf , "loglevel=" ) ; if ( p != NULL ) { p += 9 ; while ( * p == '<S2SV_blank>' ) p ++ ; if ( strncmp ( p , "DEBUG" , 5 ) == 0 ) { server . loglevel = LOG_DEBUG ; } ; if ( strncmp ( p , "NOTICE" , 6 ) == 0 ) { server . loglevel = LOG_NOTICE ; } ; if ( strncmp ( p , "WARNING" , 7 ) == 0 ) { server . loglevel = LOG_WARNING ; } ; if ( strncmp ( p , "ERROR" , 5 ) == 0 ) { server . loglevel = LOG_ERROR ; } ; } p = strstr ( buf , "filter=" ) ; if ( p != NULL ) { p += 7 ; while ( * p == '<S2SV_blank>' ) p ++ ; server . filter = p ; int i = 0 ; while ( * ( p + i ) != '\\r' && * ( p + i ) != '\\n' && * ( p + i ) != '\\0' ) i ++ ; server . filter [ i ] = 0 ; char * c = malloc ( strlen ( server . filter ) + 1 ) ; memcpy ( c , server . filter , strlen ( server . filter ) ) ; server . filter = c ; } p = strstr ( buf , "prefix=" ) ; if ( p != NULL ) { p += 7 ; while ( * p == '<S2SV_blank>' ) p ++ ; server . prefix = p ; int i = 0 ; while ( * ( p + i ) != '\\r' && * ( p + i ) != '\\n' && * ( p + i ) != '\\0' ) i ++ ; server . prefix [ i ] = 0 ; char * c = malloc ( strlen ( server . prefix ) + 1 ) ; memcpy ( c , server . prefix , strlen ( server . prefix ) ) ; server . prefix = c ; } p = strstr ( buf , "removePrefix=" ) ; if ( p != NULL ) { <S2SV_StartBug> p += 7 ; <S2SV_EndBug> while ( * p == '<S2SV_blank>' ) p ++ ; server . removePre = p ; int i = 0 ; while ( * ( p + i ) != '\\r' && * ( p + i ) != '\\n' && * ( p + i ) != '\\0' ) i ++ ; server . removePre [ i ] = 0 ; char * c = malloc ( strlen ( server . removePre ) + 1 ) ; memcpy ( c , server . removePre , strlen ( server . removePre ) ) ; server . removePre = c ; } } } | <S2SV_ModStart> { p += 13 <S2SV_ModEnd> ; while ( |
5,927 | CWE-000 static int mount_udev ( const char * root , const char * target , const char * option ) { devf ( "%s\\n" , __func__ ) ; if ( is_same_inode ( "/dev" , target ) ) { debugf ( "Unmounting<S2SV_blank>old<S2SV_blank>devfs...\\n" ) ; if ( umount2 ( target , MNT_DETACH | UMOUNT_NOFOLLOW ) ) { return - 1 ; } } char optstr [ 4096 ] , ptspath [ PATH_MAX ] ; if ( strlen ( option ) > 0 ) { snprintf ( optstr , sizeof ( optstr ) , "mode=755,%s" , option ) ; } else { snprintf ( optstr , sizeof ( optstr ) , "mode=755" ) ; } if ( mount ( "dev" , target , "tmpfs" , MS_NOEXEC | MS_NOSUID , optstr ) ) { return - 1 ; } int rfd ; if ( ( rfd = open ( target , O_DIRECTORY | O_CLOEXEC ) ) < 0 ) { return - 1 ; } int ret = 0 ; <S2SV_StartBug> ret |= combine_path ( ptspath , root , "/dev/pts" ) ; <S2SV_EndBug> ret |= mkdirat ( rfd , "pts" , 0755 ) ; ret |= mount ( "devpts" , ptspath , "devpts" , MS_NOEXEC | MS_NOSUID , "mode=620,ptmxmode=000" ) ; ret |= mknodat ( rfd , "console" , S_IFCHR | 0600 , makedev ( 5 , 1 ) ) ; ret |= mknodat ( rfd , "ptmx" , S_IFCHR | 0666 , makedev ( 5 , 2 ) ) ; ret |= mknodat ( rfd , "full" , S_IFCHR | 0666 , makedev ( 1 , 7 ) ) ; ret |= mknodat ( rfd , "tty" , S_IFCHR | 0666 , makedev ( 5 , 0 ) ) ; ret |= mknodat ( rfd , "random" , S_IFCHR | 0666 , makedev ( 1 , 8 ) ) ; ret |= mknodat ( rfd , "urandom" , S_IFCHR | 0666 , makedev ( 1 , 9 ) ) ; ret |= mknodat ( rfd , "zero" , S_IFCHR | 0666 , makedev ( 1 , 5 ) ) ; ret |= symlinkat ( "/proc/self/fd" , rfd , "fd" ) ; ret |= symlinkat ( "/proc/self/fd/0" , rfd , "stdin" ) ; ret |= symlinkat ( "/proc/self/fd/1" , rfd , "stdout" ) ; ret |= symlinkat ( "/proc/self/fd/2" , rfd , "stderr" ) ; ret |= close ( rfd ) ; <S2SV_StartBug> return ret ; <S2SV_EndBug> } | <S2SV_ModStart> = 0 ; mode_t orig_umask = umask ( 0000 ) ; <S2SV_ModStart> rfd ) ; umask ( orig_umask ) ; |
5,928 | CWE-000 static ssize_t iwl_dbgfs_fw_nmi_write ( struct iwl_mvm * mvm , char * buf , size_t count , loff_t * ppos ) { <S2SV_StartBug> int ret = iwl_mvm_ref_sync ( mvm , IWL_MVM_REF_NMI ) ; <S2SV_EndBug> if ( ret ) return ret ; iwl_force_nmi ( mvm -> trans ) ; iwl_mvm_unref ( mvm , IWL_MVM_REF_NMI ) ; return count ; } | <S2SV_ModStart> ) { int ret ; if ( ! iwl_mvm_firmware_running ( mvm ) ) return - EIO ; |
5,929 | CWE-000 static void xio_nexus_release_cb ( void * data ) { struct xio_nexus * nexus = ( struct xio_nexus * ) data ; TRACE_LOG ( "physical<S2SV_blank>nexus<S2SV_blank>close.<S2SV_blank>nexus:%p<S2SV_blank>%s_hndl:%p\\n" , nexus , xio_proto_str ( nexus -> transport_hndl -> proto ) , nexus -> transport_hndl ) ; if ( ! nexus -> is_listener ) xio_nexus_cache_remove ( nexus -> cid ) ; if ( nexus -> state != XIO_NEXUS_STATE_DISCONNECTED ) { nexus -> state = XIO_NEXUS_STATE_CLOSED ; TRACE_LOG ( "nexus<S2SV_blank>state<S2SV_blank>changed<S2SV_blank>to<S2SV_blank>closed\\n" ) ; } xio_ctx_del_delayed_work ( nexus -> transport_hndl -> ctx , & nexus -> close_time_hndl ) ; if ( nexus -> transport && nexus -> transport -> close ) { nexus -> transport -> close ( nexus -> transport_hndl ) ; <S2SV_StartBug> nexus -> transport_hndl = NULL ; <S2SV_EndBug> } } | <S2SV_ModStart> transport_hndl ) ; <S2SV_ModEnd> } } <S2SV_null> |
5,930 | CWE-000 static GstFlowReturn gst_wayland_sink_show_frame ( GstVideoSink * vsink , GstBuffer * buffer ) { GstWaylandSink * sink = GST_WAYLAND_SINK ( vsink ) ; GstBuffer * to_render ; GstWlBuffer * wlbuffer ; GstVideoMeta * vmeta ; GstVideoFormat format ; GstMemory * mem ; struct wl_buffer * wbuf = NULL ; GstFlowReturn ret = GST_FLOW_OK ; g_mutex_lock ( & sink -> render_lock ) ; GST_LOG_OBJECT ( sink , "render<S2SV_blank>buffer<S2SV_blank>%p" , buffer ) ; if ( G_UNLIKELY ( ! sink -> window ) ) { g_mutex_unlock ( & sink -> render_lock ) ; gst_video_overlay_prepare_window_handle ( GST_VIDEO_OVERLAY ( sink ) ) ; g_mutex_lock ( & sink -> render_lock ) ; if ( ! sink -> window ) { sink -> window = gst_wl_window_new_toplevel ( sink -> display , & sink -> video_info , & sink -> render_lock ) ; } } <S2SV_StartBug> if ( sink -> redraw_pending ) { <S2SV_EndBug> GST_LOG_OBJECT ( sink , "buffer<S2SV_blank>%p<S2SV_blank>dropped<S2SV_blank>(redraw<S2SV_blank>pending)" , buffer ) ; goto done ; } if ( G_UNLIKELY ( sink -> window -> render_rectangle . w == 0 ) ) goto no_window_size ; wlbuffer = gst_buffer_get_wl_buffer ( buffer ) ; if ( G_LIKELY ( wlbuffer && wlbuffer -> display == sink -> display ) ) { GST_LOG_OBJECT ( sink , "buffer<S2SV_blank>%p<S2SV_blank>has<S2SV_blank>a<S2SV_blank>wl_buffer<S2SV_blank>from<S2SV_blank>our<S2SV_blank>display,<S2SV_blank>" "writing<S2SV_blank>directly" , buffer ) ; to_render = buffer ; goto render ; } mem = gst_buffer_peek_memory ( buffer , 0 ) ; vmeta = gst_buffer_get_video_meta ( buffer ) ; if ( vmeta ) { gint i ; for ( i = 0 ; i < vmeta -> n_planes ; i ++ ) { sink -> video_info . offset [ i ] = vmeta -> offset [ i ] ; sink -> video_info . stride [ i ] = vmeta -> stride [ i ] ; } sink -> video_info . size = mem -> size ; } GST_LOG_OBJECT ( sink , "buffer<S2SV_blank>%p<S2SV_blank>does<S2SV_blank>not<S2SV_blank>have<S2SV_blank>a<S2SV_blank>wl_buffer<S2SV_blank>from<S2SV_blank>our<S2SV_blank>" "display,<S2SV_blank>creating<S2SV_blank>it" , buffer ) ; format = GST_VIDEO_INFO_FORMAT ( & sink -> video_info ) ; if ( gst_wl_display_check_format_for_dmabuf ( sink -> display , format ) ) { guint i , nb_dmabuf = 0 ; for ( i = 0 ; i < gst_buffer_n_memory ( buffer ) ; i ++ ) if ( gst_is_dmabuf_memory ( gst_buffer_peek_memory ( buffer , i ) ) ) nb_dmabuf ++ ; if ( nb_dmabuf && ( nb_dmabuf == gst_buffer_n_memory ( buffer ) ) ) wbuf = gst_wl_linux_dmabuf_construct_wl_buffer ( buffer , sink -> display , & sink -> video_info ) ; } if ( ! wbuf && gst_wl_display_check_format_for_shm ( sink -> display , format ) ) { if ( gst_is_fd_memory ( mem ) ) { wbuf = gst_wl_shm_memory_construct_wl_buffer ( mem , sink -> display , & sink -> video_info ) ; } else { GstVideoFrame src , dst ; GstVideoInfo src_info = sink -> video_info ; GST_LOG_OBJECT ( sink , "buffer<S2SV_blank>%p<S2SV_blank>cannot<S2SV_blank>have<S2SV_blank>a<S2SV_blank>wl_buffer,<S2SV_blank>" "copying<S2SV_blank>to<S2SV_blank>wl_shm<S2SV_blank>memory" , buffer ) ; if ( ! gst_buffer_pool_is_active ( sink -> pool ) ) { GstStructure * config ; GstCaps * caps ; config = gst_buffer_pool_get_config ( sink -> pool ) ; gst_buffer_pool_config_get_params ( config , & caps , NULL , NULL , NULL ) ; gst_buffer_pool_config_set_params ( config , caps , sink -> video_info . size , 2 , 0 ) ; if ( ! gst_buffer_pool_set_config ( sink -> pool , config ) || ! gst_buffer_pool_set_active ( sink -> pool , TRUE ) ) goto activate_failed ; } ret = gst_buffer_pool_acquire_buffer ( sink -> pool , & to_render , NULL ) ; if ( ret != GST_FLOW_OK ) goto no_buffer ; wlbuffer = gst_buffer_get_wl_buffer ( to_render ) ; if ( G_UNLIKELY ( ! wlbuffer ) ) { mem = gst_buffer_peek_memory ( to_render , 0 ) ; wbuf = gst_wl_shm_memory_construct_wl_buffer ( mem , sink -> display , & sink -> video_info ) ; if ( G_UNLIKELY ( ! wbuf ) ) goto no_wl_buffer_shm ; gst_buffer_add_wl_buffer ( to_render , wbuf , sink -> display ) ; } if ( ! gst_video_frame_map ( & dst , & sink -> video_info , to_render , GST_MAP_WRITE ) ) goto dst_map_failed ; if ( ! gst_video_frame_map ( & src , & src_info , buffer , GST_MAP_READ ) ) { gst_video_frame_unmap ( & dst ) ; goto src_map_failed ; } gst_video_frame_copy ( & dst , & src ) ; gst_video_frame_unmap ( & src ) ; gst_video_frame_unmap ( & dst ) ; goto render ; } } if ( ! wbuf ) goto no_wl_buffer ; gst_buffer_add_wl_buffer ( buffer , wbuf , sink -> display ) ; to_render = buffer ; render : if ( G_UNLIKELY ( to_render == sink -> last_buffer ) ) { GST_LOG_OBJECT ( sink , "Buffer<S2SV_blank>already<S2SV_blank>being<S2SV_blank>rendered" ) ; goto done ; } gst_buffer_replace ( & sink -> last_buffer , to_render ) ; render_last_buffer ( sink ) ; if ( buffer != to_render ) gst_buffer_unref ( to_render ) ; goto done ; no_window_size : { GST_ELEMENT_ERROR ( sink , RESOURCE , WRITE , ( "Window<S2SV_blank>has<S2SV_blank>no<S2SV_blank>size<S2SV_blank>set" ) , ( "Make<S2SV_blank>sure<S2SV_blank>you<S2SV_blank>set<S2SV_blank>the<S2SV_blank>size<S2SV_blank>after<S2SV_blank>calling<S2SV_blank>set_window_handle" ) ) ; ret = GST_FLOW_ERROR ; goto done ; } no_buffer : { GST_WARNING_OBJECT ( sink , "could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>buffer" ) ; goto done ; } no_wl_buffer_shm : { GST_ERROR_OBJECT ( sink , "could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>wl_buffer<S2SV_blank>out<S2SV_blank>of<S2SV_blank>wl_shm<S2SV_blank>memory" ) ; ret = GST_FLOW_ERROR ; goto done ; } no_wl_buffer : { GST_ERROR_OBJECT ( sink , "buffer<S2SV_blank>%p<S2SV_blank>cannot<S2SV_blank>have<S2SV_blank>a<S2SV_blank>wl_buffer" , buffer ) ; ret = GST_FLOW_ERROR ; goto done ; } activate_failed : { GST_ERROR_OBJECT ( sink , "failed<S2SV_blank>to<S2SV_blank>activate<S2SV_blank>bufferpool." ) ; ret = GST_FLOW_ERROR ; goto done ; } src_map_failed : { GST_ELEMENT_ERROR ( sink , RESOURCE , READ , ( "Video<S2SV_blank>memory<S2SV_blank>can<S2SV_blank>not<S2SV_blank>be<S2SV_blank>read<S2SV_blank>from<S2SV_blank>userspace." ) , ( NULL ) ) ; ret = GST_FLOW_ERROR ; goto done ; } dst_map_failed : { GST_ELEMENT_ERROR ( sink , RESOURCE , WRITE , ( "Video<S2SV_blank>memory<S2SV_blank>can<S2SV_blank>not<S2SV_blank>be<S2SV_blank>written<S2SV_blank>from<S2SV_blank>userspace." ) , ( NULL ) ) ; ret = GST_FLOW_ERROR ; goto done ; } done : { g_mutex_unlock ( & sink -> render_lock ) ; return ret ; } } | <S2SV_ModStart> ; } } g_mutex_unlock ( & sink -> render_lock ) ; wl_display_dispatch_queue_pending ( sink -> display -> display , sink -> frame_queue ) ; g_mutex_lock ( & sink -> render_lock ) ; while <S2SV_ModEnd> ( sink -> <S2SV_ModStart> sink -> redraw_pending == TRUE ) { g_mutex_unlock ( & sink -> render_lock ) ; wl_display_dispatch_queue ( sink -> display -> display , sink -> frame_queue ) ; g_mutex_lock ( & sink -> render_lock ) <S2SV_ModEnd> ; } if |
5,931 | CWE-000 static void fmtobject ( js_State * J , js_Buffer * * sb , js_Object * obj , const char * gap , int level ) { const char * key ; int save ; int i , n ; n = js_gettop ( J ) - 1 ; for ( i = 4 ; i < n ; ++ i ) if ( js_isobject ( J , i ) ) if ( js_toobject ( J , i ) == js_toobject ( J , - 1 ) ) js_typeerror ( J , "cyclic<S2SV_blank>object<S2SV_blank>value" ) ; n = 0 ; js_putc ( J , sb , '{' ) ; js_pushiterator ( J , - 1 , 1 ) ; while ( ( key = js_nextiterator ( J , - 1 ) ) ) { save = ( * sb ) -> n ; if ( n ) js_putc ( J , sb , ',' ) ; if ( gap ) fmtindent ( J , sb , gap , level + 1 ) ; fmtstr ( J , sb , key ) ; js_putc ( J , sb , ':' ) ; if ( gap ) js_putc ( J , sb , '<S2SV_blank>' ) ; js_rot2 ( J ) ; if ( ! fmtvalue ( J , sb , key , gap , level + 1 ) ) ( * sb ) -> n = save ; else ++ n ; js_rot2 ( J ) ; } <S2SV_StartBug> if ( gap && n ) fmtindent ( J , sb , gap , level ) ; <S2SV_EndBug> js_putc ( J , sb , '}' ) ; } | <S2SV_ModStart> ) ; } js_pop ( J , 1 ) ; |
5,932 | CWE-000 int main ( int argc , char * * argv ) { int clientfd ; <S2SV_StartBug> char * host , buf [ MAXLINE ] ; <S2SV_EndBug> rio_t rio ; int fd ; char * nomFichier ; struct cmdline * l ; if ( argc != 2 ) { fprintf ( stderr , "usage:<S2SV_blank>%s<S2SV_blank><host>\\n" , argv [ 0 ] ) ; exit ( 0 ) ; } host = argv [ 1 ] ; clientfd = Open_clientfd ( host , DEFAULT_PORT ) ; printf ( "client<S2SV_blank>connected<S2SV_blank>to<S2SV_blank>server<S2SV_blank>OS\\n" ) ; Rio_readinitb ( & rio , clientfd ) ; printf ( "ftp><S2SV_blank>" ) ; while ( Fgets ( buf , MAXLINE , stdin ) != NULL ) { l = readcmd ( buf ) ; if ( l -> err ) { continue ; } Rio_writen ( clientfd , buf , strlen ( buf ) ) ; <S2SV_StartBug> if ( Rio_readlineb ( & rio , buf , MAXLINE ) > 0 ) { <S2SV_EndBug> <S2SV_StartBug> nomFichier = "client/test.txt" ; <S2SV_EndBug> <S2SV_StartBug> fd = open ( nomFichier , O_WRONLY ) ; <S2SV_EndBug> <S2SV_StartBug> write ( fd , buf , 1024 ) ; <S2SV_EndBug> } else { break ; } printf ( "ftp><S2SV_blank>" ) ; } Close ( clientfd ) ; exit ( 0 ) ; } | <S2SV_ModStart> , buf [ TAILLE_MAX_FICHIER <S2SV_ModEnd> ] ; rio_t <S2SV_ModStart> ) ) ; int test ; if ( ( test = Rio_readnb <S2SV_ModEnd> ( & rio <S2SV_ModStart> , buf , TAILLE_MAX_FICHIER ) <S2SV_ModEnd> ) > 0 <S2SV_ModStart> 0 ) { printf ( "%d" , test ) ; <S2SV_ModStart> nomFichier , O_WRONLY | O_CREAT <S2SV_ModStart> , buf , TAILLE_MAX_FICHIER <S2SV_ModEnd> ) ; } |
5,933 | CWE-000 void selinux_complete_init ( void ) { <S2SV_StartBug> printk ( KERN_DEBUG "SELinux:<S2SV_blank><S2SV_blank>Completing<S2SV_blank>initialization.\\n" ) ; <S2SV_EndBug> <S2SV_StartBug> printk ( KERN_DEBUG "SELinux:<S2SV_blank><S2SV_blank>Setting<S2SV_blank>up<S2SV_blank>existing<S2SV_blank>superblocks.\\n" ) ; <S2SV_EndBug> iterate_supers ( delayed_superblock_init , NULL ) ; } | <S2SV_ModStart> void ) { pr_debug ( <S2SV_ModEnd> "SELinux:<S2SV_blank><S2SV_blank>Completing<S2SV_blank>initialization.\\n" ) ; <S2SV_ModStart> "SELinux:<S2SV_blank><S2SV_blank>Completing<S2SV_blank>initialization.\\n" ) ; pr_debug ( <S2SV_ModEnd> "SELinux:<S2SV_blank><S2SV_blank>Setting<S2SV_blank>up<S2SV_blank>existing<S2SV_blank>superblocks.\\n" ) ; |
5,934 | CWE-000 void raise_current_window ( void ) { raisewindow ( focuswin -> id ) ; <S2SV_StartBug> raisedwin = focuswin ; <S2SV_EndBug> } | <S2SV_ModStart> id ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
5,935 | CWE-000 void fc3d_nonsmooth_Newton_AlartCurnier ( FrictionContactProblem * problem , double * reaction , double * velocity , int * info , SolverOptions * options ) { assert ( problem ) ; assert ( reaction ) ; assert ( velocity ) ; assert ( info ) ; assert ( options ) ; assert ( problem -> dimension == 3 ) ; assert ( options -> iparam ) ; assert ( options -> dparam ) ; assert ( problem -> q ) ; assert ( problem -> mu ) ; assert ( problem -> M ) ; assert ( ! options -> iparam [ 4 ] ) ; AlartCurnierParams acparams ; <S2SV_StartBug> switch ( options -> iparam [ 10 ] ) <S2SV_EndBug> { case 0 : { acparams . computeACFun3x3 = & computeAlartCurnierSTD ; break ; } case 1 : { acparams . computeACFun3x3 = & computeAlartCurnierJeanMoreau ; break ; } ; case 2 : { acparams . computeACFun3x3 = & fc3d_AlartCurnierFunctionGenerated ; break ; } case 3 : { acparams . computeACFun3x3 = & fc3d_AlartCurnierJeanMoreauFunctionGenerated ; break ; } } fc3d_nonsmooth_Newton_solvers equation ; equation . problem = problem ; equation . data = ( void * ) & acparams ; equation . function = & nonsmoothEqnAlartCurnierFun ; if ( options -> iparam [ SICONOS_FRICTION_3D_NSN_HYBRID_STRATEGY ] == SICONOS_FRICTION_3D_NSN_HYBRID_STRATEGY_VI_EG_NSN ) { SolverOptions * options_vi_eg = ( SolverOptions * ) malloc ( sizeof ( SolverOptions ) ) ; fc3d_VI_ExtraGradient_setDefaultSolverOptions ( options_vi_eg ) ; <S2SV_StartBug> options_vi_eg -> iparam [ 0 ] = 50 ; <S2SV_EndBug> <S2SV_StartBug> options_vi_eg -> dparam [ 0 ] = sqrt ( options -> dparam [ 0 ] ) ; <S2SV_EndBug> options_vi_eg -> iparam [ SICONOS_VI_IPARAM_ERROR_EVALUATION ] = SICONOS_VI_ERROR_EVALUATION_LIGHT ; fc3d_VI_ExtraGradient ( problem , reaction , velocity , info , options_vi_eg ) ; fc3d_nonsmooth_Newton_solvers_solve ( & equation , reaction , velocity , info , options ) ; solver_options_delete ( options_vi_eg ) ; free ( options_vi_eg ) ; } else if ( options -> iparam [ SICONOS_FRICTION_3D_NSN_HYBRID_STRATEGY ] == SICONOS_FRICTION_3D_NSN_HYBRID_STRATEGY_NO ) { fc3d_nonsmooth_Newton_solvers_solve ( & equation , reaction , velocity , info , options ) ; } else { numerics_error ( "fc3d_nonsmooth_Newton_AlartCurnier" , "Unknown<S2SV_blank>nsn<S2SV_blank>hybrid<S2SV_blank>solver" ) ; } } | <S2SV_ModStart> -> iparam [ SICONOS_FRICTION_3D_NSN_FORMULATION <S2SV_ModEnd> ] ) { <S2SV_ModStart> -> iparam [ SICONOS_IPARAM_MAX_ITER <S2SV_ModEnd> ] = 50 <S2SV_ModStart> -> dparam [ SICONOS_DPARAM_TOL <S2SV_ModEnd> ] = sqrt |
5,936 | CWE-000 void lpfc_nlp_init ( struct lpfc_vport * vport , struct lpfc_nodelist * ndlp , uint32_t did ) { memset ( ndlp , 0 , sizeof ( struct lpfc_nodelist ) ) ; lpfc_initialize_node ( vport , ndlp , did ) ; INIT_LIST_HEAD ( & ndlp -> nlp_listp ) ; if ( vport -> phba -> sli_rev == LPFC_SLI_REV4 ) { ndlp -> nlp_rpi = lpfc_sli4_alloc_rpi ( vport -> phba ) ; <S2SV_StartBug> ndlp -> active_rrqs_xri_bitmap = <S2SV_EndBug> mempool_alloc ( vport -> phba -> active_rrq_pool , GFP_KERNEL ) ; if ( ndlp -> active_rrqs_xri_bitmap ) memset ( ndlp -> active_rrqs_xri_bitmap , 0 , ndlp -> phba -> cfg_rrq_xri_bitmap_sz ) ; } lpfc_debugfs_disc_trc ( vport , LPFC_DISC_TRC_NODE , "node<S2SV_blank>init:<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>did:x%x" , ndlp -> nlp_DID , 0 , 0 ) ; return ; } | <S2SV_ModStart> phba ) ; lpfc_printf_vlog ( vport , KERN_INFO , LOG_NODE , "0007<S2SV_blank>rpi:%x<S2SV_blank>DID:%x<S2SV_blank>flg:%x<S2SV_blank>refcnt:%d<S2SV_blank>" "map:%x<S2SV_blank>%p\\n" , ndlp -> nlp_rpi , ndlp -> nlp_DID , ndlp -> nlp_flag , atomic_read ( & ndlp -> kref . refcount ) , ndlp -> nlp_usg_map , ndlp ) ; |
5,937 | CWE-000 char * width ( char * s , t_arg arg ) { char * new_s ; char * width_s ; if ( arg . width > ( int ) ft_strlen ( s ) ) { width_s = create_width ( arg . att . width_modi , arg . width - ( int ) ft_strlen ( s ) ) ; new_s = arg . att . width_modi != '-' ? ft_strjoin ( width_s , s ) : ft_strjoin ( s , width_s ) ; ft_strdel ( & s ) ; ft_strdel ( & width_s ) ; <S2SV_StartBug> s = new_s ; <S2SV_EndBug> } return ( s ) ; } | <S2SV_ModStart> width_s ) ; return ( new_s ) <S2SV_ModEnd> ; } return |
5,938 | CWE-000 static void binder_transaction_buffer_release ( struct binder_proc * proc , struct binder_buffer * buffer , size_t * failed_at ) { size_t * offp , * off_end ; int debug_id = buffer -> debug_id ; binder_debug ( BINDER_DEBUG_TRANSACTION , "binder:<S2SV_blank>%d<S2SV_blank>buffer<S2SV_blank>release<S2SV_blank>%d,<S2SV_blank>size<S2SV_blank>%zd-%zd,<S2SV_blank>failed<S2SV_blank>at<S2SV_blank>%p\\n" , proc -> pid , buffer -> debug_id , buffer -> data_size , buffer -> offsets_size , failed_at ) ; if ( buffer -> target_node ) binder_dec_node ( buffer -> target_node , 1 , 0 ) ; offp = ( size_t * ) ( buffer -> data + ALIGN ( buffer -> data_size , sizeof ( void * ) ) ) ; if ( failed_at ) off_end = failed_at ; else off_end = ( void * ) offp + buffer -> offsets_size ; for ( ; offp < off_end ; offp ++ ) { struct flat_binder_object * fp ; if ( * offp > buffer -> data_size - sizeof ( * fp ) || buffer -> data_size < sizeof ( * fp ) || ! IS_ALIGNED ( * offp , sizeof ( void * ) ) ) { <S2SV_StartBug> binder_debug ( BINDER_DEBUG_TOP_ERRORS , <S2SV_EndBug> "binder:<S2SV_blank>transaction<S2SV_blank>release<S2SV_blank>%d<S2SV_blank>bad" "offset<S2SV_blank>%zd,<S2SV_blank>size<S2SV_blank>%zd\\n" , debug_id , * offp , buffer -> data_size ) ; continue ; } fp = ( struct flat_binder_object * ) ( buffer -> data + * offp ) ; switch ( fp -> type ) { case BINDER_TYPE_BINDER : case BINDER_TYPE_WEAK_BINDER : { struct binder_node * node = binder_get_node ( proc , fp -> binder ) ; if ( node == NULL ) { <S2SV_StartBug> binder_debug ( BINDER_DEBUG_TOP_ERRORS , <S2SV_EndBug> "binder:<S2SV_blank>transaction<S2SV_blank>release<S2SV_blank>%d" "<S2SV_blank>bad<S2SV_blank>node<S2SV_blank>%p\\n" , debug_id , fp -> binder ) ; break ; } binder_debug ( BINDER_DEBUG_TRANSACTION , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>node<S2SV_blank>%d<S2SV_blank>u%p\\n" , node -> debug_id , node -> ptr ) ; binder_dec_node ( node , fp -> type == BINDER_TYPE_BINDER , 0 ) ; } break ; case BINDER_TYPE_HANDLE : case BINDER_TYPE_WEAK_HANDLE : { struct binder_ref * ref = binder_get_ref ( proc , fp -> handle , fp -> type == BINDER_TYPE_HANDLE ) ; if ( ref == NULL ) { <S2SV_StartBug> binder_debug ( BINDER_DEBUG_TOP_ERRORS , <S2SV_EndBug> "binder:<S2SV_blank>transaction<S2SV_blank>release<S2SV_blank>%d" "<S2SV_blank>bad<S2SV_blank>handle<S2SV_blank>%ld\\n" , debug_id , fp -> handle ) ; break ; } binder_debug ( BINDER_DEBUG_TRANSACTION , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>ref<S2SV_blank>%d<S2SV_blank>desc<S2SV_blank>%d<S2SV_blank>(node<S2SV_blank>%d)\\n" , ref -> debug_id , ref -> desc , ref -> node -> debug_id ) ; binder_dec_ref ( ref , fp -> type == BINDER_TYPE_HANDLE ) ; } break ; case BINDER_TYPE_FD : binder_debug ( BINDER_DEBUG_TRANSACTION , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>fd<S2SV_blank>%ld\\n" , fp -> handle ) ; if ( failed_at ) task_close_fd ( proc , fp -> handle ) ; break ; default : <S2SV_StartBug> binder_debug ( BINDER_DEBUG_TOP_ERRORS , <S2SV_EndBug> "binder:<S2SV_blank>transaction<S2SV_blank>release<S2SV_blank>%d<S2SV_blank>bad<S2SV_blank>" "object<S2SV_blank>type<S2SV_blank>%lx\\n" , debug_id , fp -> type ) ; break ; } } } | <S2SV_ModStart> ) ) { pr_err ( <S2SV_ModEnd> "binder:<S2SV_blank>transaction<S2SV_blank>release<S2SV_blank>%d<S2SV_blank>bad" "offset<S2SV_blank>%zd,<S2SV_blank>size<S2SV_blank>%zd\\n" , <S2SV_ModStart> NULL ) { pr_err ( <S2SV_ModEnd> "binder:<S2SV_blank>transaction<S2SV_blank>release<S2SV_blank>%d" "<S2SV_blank>bad<S2SV_blank>node<S2SV_blank>%p\\n" , <S2SV_ModStart> NULL ) { pr_err ( <S2SV_ModEnd> "binder:<S2SV_blank>transaction<S2SV_blank>release<S2SV_blank>%d" "<S2SV_blank>bad<S2SV_blank>handle<S2SV_blank>%ld\\n" , <S2SV_ModStart> ; default : pr_err ( <S2SV_ModEnd> "binder:<S2SV_blank>transaction<S2SV_blank>release<S2SV_blank>%d<S2SV_blank>bad<S2SV_blank>" "object<S2SV_blank>type<S2SV_blank>%lx\\n" , |
5,939 | CWE-000 int rsa_key_save ( void * key , size_t size , const char * filename ) { FILE * file ; if ( ( file = fopen ( filename , "w" ) ) == NULL ) { <S2SV_StartBug> perror ( strerror ( errno ) ) ; <S2SV_EndBug> return - 1 ; } fwrite ( key , size , 1 , file ) ; return fclose ( file ) ; } | <S2SV_ModStart> { perror ( "fopen" <S2SV_ModEnd> ) ; return |
5,940 | CWE-000 int main ( int argc , const char * argv [ ] ) { ruid = getuid ( ) ; euid = geteuid ( ) ; char recvbuf [ 1024 ] ; <S2SV_StartBug> char * content ; <S2SV_EndBug> char * * parameters ; <S2SV_StartBug> memset ( recvbuf , 0 , sizeof ( recvbuf ) ) ; <S2SV_EndBug> printf ( "Start<S2SV_blank>File<S2SV_blank>Read<S2SV_blank>Service.\\n" ) ; while ( 1 ) { int status = listen_main_prog_request ( recvbuf , 1024 ) ; if ( status == 10 ) { parameters = SF_get_filename ( recvbuf ) ; int num = 1 ; sleep ( 2 ) ; while ( parameters [ num ] != NULL ) { printf ( "FileReadService:<S2SV_blank>parameters[%d]<S2SV_blank>is<S2SV_blank>%s\\n" , num , parameters [ num ] ) ; <S2SV_StartBug> content = SF_read_content ( parameters [ num ] ) ; <S2SV_EndBug> printf ( "FileReadService:<S2SV_blank>get<S2SV_blank>content<S2SV_blank>%s\\n" , content ) ; <S2SV_StartBug> SF_send_content ( content , parameters [ num ] ) ; <S2SV_EndBug> sleep ( 2 ) ; num ++ ; } } sleep ( 2 ) ; SF_send_content ( NULL , NULL ) ; sleep ( 3 ) ; } return 0 ; } | <S2SV_ModStart> ] ; char readbuf [ 1024 ] ; char * content = readbuf <S2SV_ModEnd> ; char * <S2SV_ModStart> sizeof ( recvbuf ) ) ; memset ( readbuf , 0 , sizeof ( readbuf <S2SV_ModStart> ] ) ; SF_read_content ( content , parameters [ num ] ) ; SF_send_content ( content , parameters [ num ] ) ; memset ( readbuf , 0 , sizeof ( readbuf ) ) ; sleep ( 2 ) ; num ++ ; } } sleep ( 2 <S2SV_ModEnd> ) ; SF_send_content <S2SV_ModStart> ; SF_send_content ( <S2SV_ModEnd> NULL , NULL |
5,941 | CWE-000 static sqInt NoDbgRegParms genConvertBitsToSmallFloatInscratch ( sqInt reg , sqInt scratch ) { AbstractInstruction * anInstruction ; AbstractInstruction * anInstruction1 ; AbstractInstruction * anInstruction2 ; AbstractInstruction * jumpZero ; sqInt quickConstant ; sqInt quickConstant1 ; genoperandoperand ( RotateLeftCqR , 1 , reg ) ; <S2SV_StartBug> anInstruction1 = genoperandoperand ( CmpCqR , 1 , reg ) ; <S2SV_EndBug> jumpZero = genConditionalBranchoperand ( JumpBelowOrEqual , ( ( sqInt ) 0 ) ) ; quickConstant = ( ( sqInt ) ( ( usqInt ) ( ( smallFloatExponentOffset ( ) ) ) << ( ( smallFloatMantissaBits ( ) ) + 1 ) ) ) ; <S2SV_StartBug> anInstruction = genoperandoperand ( SubCqR , quickConstant , reg ) ; <S2SV_EndBug> jmpTarget ( jumpZero , gLogicalShiftLeftCqR ( numTagBits ( ) , reg ) ) ; quickConstant1 = smallFloatTag ( ) ; anInstruction2 = genoperandoperand ( AddCqR , quickConstant1 , reg ) ; return 0 ; } | <S2SV_ModStart> reg ) ; anInstruction <S2SV_ModEnd> = genoperandoperand ( <S2SV_ModStart> ) ) ; anInstruction1 <S2SV_ModEnd> = genoperandoperand ( |
5,942 | CWE-000 static inline void doAMO ( c_nodeid_t node , void * object , const void * operand1 , const void * operand2 , void * result , int ofiOp , enum fi_datatype ofiType , size_t size ) { if ( chpl_numNodes <= 1 ) { doCpuAMO ( object , operand1 , operand2 , result , ofiOp , ofiType , size ) ; return ; } uint64_t mrKey ; if ( mrGetKey ( & mrKey , node , object , size ) == 0 ) { struct perTxCtxInfo_t * tcip = NULL ; <S2SV_StartBug> CHK_TRUE ( ( tcip = getTxCtxInfo ( true ) ) != NULL ) ; <S2SV_EndBug> size_t count ; if ( fi_atomicvalid ( tcip -> txCtx , ofiType , ofiOp , & count ) == 0 && count > 0 ) { ofi_amo ( tcip , node , object , mrKey , operand1 , operand2 , result , ofiOp , ofiType , size ) ; <S2SV_StartBug> releaseTxCtxInfo ( tcip ) ; <S2SV_EndBug> return ; } <S2SV_StartBug> releaseTxCtxInfo ( tcip ) ; <S2SV_EndBug> } amRequestAMO ( node , object , operand1 , operand2 , result , ofiOp , ofiType , size ) ; } | <S2SV_ModStart> ( tcip = tciAlloc ( false <S2SV_ModEnd> ) ) != <S2SV_ModStart> size ) ; tciFree <S2SV_ModEnd> ( tcip ) <S2SV_ModStart> return ; } tciFree <S2SV_ModEnd> ( tcip ) |
5,943 | CWE-000 int main ( int argc , char * argv [ ] ) { bool_t write_analyze_output , equilibria_only , run_ray , exit_on_EOF ; int nact , Nspect , Nread , Nrequired , checkPoint , * wave_index = NULL ; double muz ; Atom * atom ; FILE * fp_ray ; char inputLine [ MAX_LINE_SIZE ] ; initParallel ( & argc , & argv , run_ray = FALSE ) ; setOptions ( argc , argv ) ; getCPU ( 0 , TIME_START , NULL ) ; SetFPEtraps ( ) ; mpi . main_logfile = commandline . logfile ; commandline . logfile = mpi . logfile ; strcpy ( mpi . rev_id , REV_ID ) ; readInput ( ) ; spectrum . updateJ = FALSE ; getCPU ( 1 , TIME_START , NULL ) ; init_hdf5_atmos ( & atmos , & geometry , & infile ) ; distribute_jobs ( ) ; if ( ( fp_ray = fopen ( RAY_INPUT_FILE , "r" ) ) == NULL ) { sprintf ( messageStr , "Unable<S2SV_blank>to<S2SV_blank>open<S2SV_blank>inputfile<S2SV_blank>%s" , RAY_INPUT_FILE ) ; Error ( ERROR_LEVEL_2 , argv [ 0 ] , messageStr ) ; } getLine ( fp_ray , COMMENT_CHAR , inputLine , exit_on_EOF = TRUE ) ; Nread = sscanf ( inputLine , "%lf" , & muz ) ; checkNread ( Nread , Nrequired = 1 , argv [ 0 ] , checkPoint = 1 ) ; if ( muz <= 0.0 || muz > 1.0 ) { sprintf ( messageStr , "Value<S2SV_blank>of<S2SV_blank>muz<S2SV_blank>=<S2SV_blank>%f<S2SV_blank>does<S2SV_blank>not<S2SV_blank>lie<S2SV_blank>in<S2SV_blank>interval<S2SV_blank><0.0,<S2SV_blank>1.0]\\n" , muz ) ; Error ( ERROR_LEVEL_2 , argv [ 0 ] , messageStr ) ; } if ( input . StokesMode == FIELD_FREE || input . StokesMode == POLARIZATION_FREE ) { input . StokesMode = FULL_STOKES ; } Nread = fscanf ( fp_ray , "%d" , & Nspect ) ; checkNread ( Nread , 1 , argv [ 0 ] , checkPoint = 2 ) ; io . ray_nwave_sel = Nspect ; if ( Nspect > 0 ) { io . ray_wave_idx = ( int * ) malloc ( Nspect * sizeof ( int ) ) ; Nread = 0 ; while ( fscanf ( fp_ray , "%d" , & io . ray_wave_idx [ Nread ] ) != EOF ) Nread ++ ; checkNread ( Nread , Nspect , argv [ 0 ] , checkPoint = 3 ) ; fclose ( fp_ray ) ; wave_index = io . ray_wave_idx ; } atmos . Nrays = geometry . Nrays = 1 ; geometry . muz [ 0 ] = muz ; geometry . mux [ 0 ] = sqrt ( 1.0 - SQ ( geometry . muz [ 0 ] ) ) ; geometry . muy [ 0 ] = 0.0 ; geometry . wmu [ 0 ] = 1.0 ; atmos . moving = TRUE ; readAtmos_hdf5 ( 0 , 0 , & atmos , & geometry , & infile ) ; readAtomicModels ( ) ; readMolecularModels ( ) ; SortLambda ( ) ; for ( nact = 0 ; nact < atmos . Nactiveatom ; nact ++ ) { atom = atmos . activeatoms [ nact ] ; atom -> initial_solution = LTE_POPULATIONS ; } init_Background ( ) ; mpi . StokesMode_save = input . StokesMode ; io . atom_file_pos = ( long * ) malloc ( atmos . Nactiveatom * sizeof ( long ) ) ; mpi . zcut_hist = ( int * ) calloc ( mpi . Ntasks , sizeof ( int ) ) ; for ( nact = 0 ; nact < atmos . Nactiveatom ; nact ++ ) { atom = atmos . activeatoms [ nact ] ; io . atom_file_pos [ nact ] = ftell ( atom -> fp_input ) ; } mpi . single_log = FALSE ; init_hdf5_ray ( ) ; for ( mpi . task = 0 ; mpi . task < mpi . Ntasks ; mpi . task ++ ) { mpi . ix = mpi . taskmap [ mpi . task + mpi . my_start ] [ 0 ] ; mpi . iy = mpi . taskmap [ mpi . task + mpi . my_start ] [ 1 ] ; sprintf ( messageStr , <S2SV_StartBug> "Process<S2SV_blank>%3d:<S2SV_blank>---<S2SV_blank>START<S2SV_blank>task<S2SV_blank>%3ld<S2SV_blank>[of<S2SV_blank>%ld],<S2SV_blank>(xi,yi)<S2SV_blank>=<S2SV_blank>(%3d,%3d)\\n" , <S2SV_EndBug> mpi . rank , mpi . task + 1 , mpi . Ntasks , mpi . xnum [ mpi . ix ] , mpi . ynum [ mpi . iy ] ) ; fprintf ( mpi . main_logfile , messageStr ) ; Error ( MESSAGE , "main" , messageStr ) ; readAtmos_hdf5 ( mpi . xnum [ mpi . ix ] , mpi . ynum [ mpi . iy ] , & atmos , & geometry , & infile ) ; UpdateAtmosDep ( ) ; Background_p ( write_analyze_output = FALSE , equilibria_only = FALSE ) ; getProfiles ( ) ; initSolution_p ( ) ; initScatter ( ) ; getCPU ( 1 , TIME_POLL , "Total<S2SV_blank>Initialize" ) ; solveSpectrum ( FALSE , FALSE ) ; writeRay ( ) ; sprintf ( messageStr , <S2SV_StartBug> "Process<S2SV_blank>%3d:<S2SV_blank>***<S2SV_blank>END<S2SV_blank><S2SV_blank><S2SV_blank>task<S2SV_blank>%3ld\\n" , <S2SV_EndBug> mpi . rank , mpi . task + 1 ) ; fprintf ( mpi . main_logfile , messageStr ) ; Error ( MESSAGE , "main" , messageStr ) ; mpi . nconv ++ ; } if ( mpi . Ntasks == 0 ) { <S2SV_StartBug> sprintf ( messageStr , "Process<S2SV_blank>%3d:<S2SV_blank>***<S2SV_blank>NO<S2SV_blank>WORK<S2SV_blank>(more<S2SV_blank>processes<S2SV_blank>than<S2SV_blank>tasks!)\\n" , mpi . rank ) ; <S2SV_EndBug> fprintf ( mpi . main_logfile , messageStr ) ; Error ( MESSAGE , "main" , messageStr ) ; } close_hdf5_atmos ( & atmos , & geometry , & infile ) ; free ( io . atom_file_pos ) ; close_hdf5_ray ( ) ; finish_jobs ( ) ; sprintf ( messageStr , "***<S2SV_blank>Job<S2SV_blank>ending.<S2SV_blank>Total<S2SV_blank>%ld<S2SV_blank>1-D<S2SV_blank>columns:<S2SV_blank>%ld<S2SV_blank>computed,<S2SV_blank>%ld<S2SV_blank>skipped.\\n%s" , mpi . Ntasks , mpi . nconv , mpi . ncrash , "***<S2SV_blank>RH<S2SV_blank>lte<S2SV_blank>ray<S2SV_blank>finished<S2SV_blank>gracefully.\\n" ) ; if ( mpi . rank == 0 ) fprintf ( mpi . main_logfile , messageStr ) ; Error ( MESSAGE , "main" , messageStr ) ; printTotalCPU ( ) ; MPI_Finalize ( ) ; return 0 ; } | <S2SV_ModStart> ( messageStr , "Process<S2SV_blank>%4d:<S2SV_blank>---<S2SV_blank>START<S2SV_blank>task<S2SV_blank>%3ld<S2SV_blank>[of<S2SV_blank>%ld],<S2SV_blank>(xi,yi)<S2SV_blank>=<S2SV_blank>(%3d,%3d)\\n" <S2SV_ModEnd> , mpi . <S2SV_ModStart> ( messageStr , "Process<S2SV_blank>%4d:<S2SV_blank>***<S2SV_blank>END<S2SV_blank><S2SV_blank><S2SV_blank>task<S2SV_blank>%3ld\\n" <S2SV_ModEnd> , mpi . <S2SV_ModStart> ( messageStr , "Process<S2SV_blank>%4d:<S2SV_blank>***<S2SV_blank>NO<S2SV_blank>WORK<S2SV_blank>(more<S2SV_blank>processes<S2SV_blank>than<S2SV_blank>tasks!)\\n" <S2SV_ModEnd> , mpi . |
5,944 | CWE-000 <S2SV_StartBug> static int php_cli_server_ctor ( php_cli_server * server , const char * addr , const char * document_root , const char * router ) <S2SV_EndBug> { int retval = SUCCESS ; char * host = NULL ; zend_string * errstr = NULL ; char * _document_root = NULL ; char * _router = NULL ; int err = 0 ; int port = 3000 ; php_socket_t server_sock = SOCK_ERR ; char * p = NULL ; if ( addr [ 0 ] == '[' ) { host = pestrdup ( addr + 1 , 1 ) ; if ( ! host ) { return FAILURE ; } p = strchr ( host , ']' ) ; if ( p ) { * p ++ = '\\0' ; if ( * p == ':' ) { port = strtol ( p + 1 , & p , 10 ) ; if ( port <= 0 || port > 65535 ) { p = NULL ; } } else if ( * p != '\\0' ) { p = NULL ; } } } else { host = pestrdup ( addr , 1 ) ; if ( ! host ) { return FAILURE ; } p = strchr ( host , ':' ) ; if ( p ) { * p ++ = '\\0' ; port = strtol ( p , & p , 10 ) ; if ( port <= 0 || port > 65535 ) { p = NULL ; } } } if ( ! p ) { fprintf ( stderr , "Invalid<S2SV_blank>address:<S2SV_blank>%s\\n" , addr ) ; retval = FAILURE ; goto out ; } server_sock = php_network_listen_socket ( host , & port , SOCK_STREAM , & server -> address_family , & server -> socklen , & errstr ) ; if ( server_sock == SOCK_ERR ) { php_cli_server_logf ( "Failed<S2SV_blank>to<S2SV_blank>listen<S2SV_blank>on<S2SV_blank>%s:%d<S2SV_blank>(reason:<S2SV_blank>%s)" , host , port , errstr ? ZSTR_VAL ( errstr ) : "?" ) ; if ( errstr ) { zend_string_release ( errstr ) ; } retval = FAILURE ; goto out ; } server -> server_sock = server_sock ; err = php_cli_server_poller_ctor ( & server -> poller ) ; if ( SUCCESS != err ) { goto out ; } php_cli_server_poller_add ( & server -> poller , POLLIN , server_sock ) ; server -> host = host ; server -> port = port ; zend_hash_init ( & server -> clients , 0 , NULL , php_cli_server_client_dtor_wrapper , 1 ) ; { size_t document_root_len = strlen ( document_root ) ; _document_root = pestrndup ( document_root , document_root_len , 1 ) ; if ( ! _document_root ) { retval = FAILURE ; goto out ; } server -> document_root = _document_root ; server -> document_root_len = document_root_len ; } if ( router ) { size_t router_len = strlen ( router ) ; _router = pestrndup ( router , router_len , 1 ) ; if ( ! _router ) { retval = FAILURE ; goto out ; } server -> router = _router ; server -> router_len = router_len ; } else { server -> router = NULL ; server -> router_len = 0 ; } if ( php_cli_server_mime_type_ctor ( server , mime_type_map ) == FAILURE ) { retval = FAILURE ; goto out ; } <S2SV_StartBug> server -> is_running = 1 ; <S2SV_EndBug> out : if ( retval != SUCCESS ) { if ( host ) { pefree ( host , 1 ) ; } if ( _document_root ) { pefree ( _document_root , 1 ) ; } if ( _router ) { pefree ( _router , 1 ) ; } if ( server_sock > - 1 ) { closesocket ( server_sock ) ; } } return retval ; } | <S2SV_ModStart> char * router , int redirect <S2SV_ModStart> } server -> redirect = redirect ; server -> |
5,945 | CWE-000 void collect_shareinput_producers ( PlannerInfo * root , Plan * plan ) { PlannerGlobal * glob = root -> glob ; <S2SV_StartBug> glob -> share . curr_rtable = root -> parse -> rtable ; <S2SV_EndBug> shareinput_walker ( collect_shareinput_producers_walker , ( Node * ) plan , root ) ; } | <S2SV_ModStart> . curr_rtable = glob -> finalrtable <S2SV_ModEnd> ; shareinput_walker ( |
5,946 | CWE-000 zjs_callback_id add_callback_priv ( jerry_value_t js_func , jerry_value_t this , void * handle , zjs_post_callback_func post , u8_t once # ifdef DEBUG_BUILD , const char * file , const char * func ) # else ) # endif { <S2SV_StartBug> LOCK ( ) ; <S2SV_EndBug> zjs_callback_t * new_cb = zjs_malloc ( sizeof ( zjs_callback_t ) ) ; if ( ! new_cb ) { DBG_PRINT ( "error<S2SV_blank>allocating<S2SV_blank>space<S2SV_blank>for<S2SV_blank>new<S2SV_blank>callback\\n" ) ; return - 1 ; } memset ( new_cb , 0 , sizeof ( zjs_callback_t ) ) ; SET_ONCE ( new_cb -> flags , ( once ) ? 1 : 0 ) ; SET_TYPE ( new_cb -> flags , CALLBACK_TYPE_JS ) ; SET_JS_TYPE ( new_cb -> flags , JS_TYPE_SINGLE ) ; new_cb -> id = new_id ( ) ; new_cb -> js_func = jerry_acquire_value ( js_func ) ; new_cb -> this = jerry_acquire_value ( this ) ; new_cb -> post = post ; new_cb -> handle = handle ; new_cb -> max_funcs = 1 ; new_cb -> num_funcs = 1 ; cb_map [ new_cb -> id ] = new_cb ; if ( new_cb -> id >= cb_size - 1 ) { cb_size ++ ; } DBG_PRINT ( "adding<S2SV_blank>new<S2SV_blank>callback<S2SV_blank>id<S2SV_blank>%d,<S2SV_blank>js_func=%u,<S2SV_blank>once=%u\\n" , new_cb -> id , new_cb -> js_func , once ) ; # ifdef DEBUG_BUILD set_info_string ( cb_map [ new_cb -> id ] -> creator , file , func ) ; # endif <S2SV_StartBug> UNLOCK ( ) ; <S2SV_EndBug> return new_cb -> id ; } | <S2SV_ModStart> # endif { <S2SV_ModEnd> zjs_callback_t * new_cb <S2SV_ModStart> ; # endif <S2SV_ModEnd> return new_cb -> |
5,947 | CWE-000 DynaStatus dntree_init ( dntree * t , size_t children , size_t cap , DynaCopyFunc copy , DynaDestructFunc dtor , size_t esize ) { dassert ( esize != 0 , DYNA_ASSERT_ESIZE_ZERO ) ; dassert ( children >= 3 , DYNA_ASSERT_NTREE_CHILDREN_RANGE ) ; DynaStatus status = dvec_init ( & t -> tree , cap , copy , dtor , esize ) ; <S2SV_StartBug> if ( yunlikely ( status ) ) { <S2SV_EndBug> return status ; } t -> selfFlags = ycalloc ( t -> tree . cap , sizeof ( bool ) ) ; <S2SV_StartBug> if ( yunlikely ( ! t -> selfFlags ) ) { <S2SV_EndBug> yfree ( t -> tree . array ) ; return DYNA_STATUS_MALLOC_FAIL ; } t -> nodes = 0 ; t -> children = children ; return DYNA_STATUS_SUCCESS ; } | <S2SV_ModStart> ; if ( yerror <S2SV_ModEnd> ( status ) <S2SV_ModStart> ; if ( yerror <S2SV_ModEnd> ( ! t |
5,948 | CWE-000 int iscsi_target_start_negotiation ( struct iscsi_login * login , struct iscsi_conn * conn ) { int ret ; if ( conn -> sock ) { struct sock * sk = conn -> sock -> sk ; write_lock_bh ( & sk -> sk_callback_lock ) ; set_bit ( LOGIN_FLAGS_READY , & conn -> login_flags ) ; <S2SV_StartBug> write_unlock_bh ( & sk -> sk_callback_lock ) ; <S2SV_EndBug> } <S2SV_StartBug> ret = iscsi_target_do_login ( conn , login ) ; <S2SV_EndBug> if ( ret < 0 ) { cancel_delayed_work_sync ( & conn -> login_work ) ; cancel_delayed_work_sync ( & conn -> login_cleanup_work ) ; iscsi_target_restore_sock_callbacks ( conn ) ; iscsi_remove_failed_auth_entry ( conn ) ; } if ( ret != 0 ) iscsi_target_nego_release ( conn ) ; return ret ; } | <S2SV_ModStart> login_flags ) ; set_bit ( LOGIN_FLAGS_INITIAL_PDU , & conn -> login_flags ) ; <S2SV_ModStart> , login ) ; if ( ! ret && iscsi_target_sk_check_and_clear ( conn , LOGIN_FLAGS_INITIAL_PDU ) ) ret = - 1 |
5,949 | CWE-000 DEFUN struct dt_d_s dt_dadd_d ( struct dt_d_s d , int n ) { <S2SV_StartBug> switch ( d . typ ) { <S2SV_EndBug> case DT_JDN : d . daisy = __jdn_to_daisy ( d . jdn ) ; goto daisy_add_d ; case DT_LDN : d . daisy = __ldn_to_daisy ( d . ldn ) ; goto daisy_add_d ; case DT_MDN : d . daisy = __mdn_to_daisy ( d . mdn ) ; goto daisy_add_d ; case DT_DAISY : daisy_add_d : d . daisy = __daisy_add_d ( d . daisy , n ) ; switch ( d . typ ) { case DT_DAISY : default : break ; case DT_LDN : d . ldn = __daisy_to_ldn ( d . daisy ) ; break ; case DT_JDN : d . jdn = __daisy_to_jdn ( d . daisy ) ; break ; case DT_MDN : d . mdn = __daisy_to_mdn ( d . daisy ) ; break ; } break ; case DT_YMD : d . ymd = __ymd_add_d ( d . ymd , n ) ; break ; case DT_YMCW : d . ymcw = __ymcw_add_d ( d . ymcw , n ) ; break ; case DT_BIZDA : d . bizda = __bizda_add_d ( d . bizda , n ) ; break ; case DT_YWD : d . ywd = __ywd_add_d ( d . ywd , n ) ; break ; case DT_YD : d . yd = __yd_add_d ( d . yd , n ) ; break ; case DT_DUNK : default : d . typ = DT_DUNK ; d . u = 0 ; break ; } <S2SV_StartBug> return d ; <S2SV_EndBug> } | <S2SV_ModStart> n ) { if ( UNLIKELY ( ! n ) ) { goto out ; } <S2SV_ModStart> break ; } out : |
5,950 | CWE-000 static void sp_timer_isr ( void * arg ) { ARG_UNUSED ( arg ) ; _sys_idle_elapsed_ticks = silent_ticks + 1 ; silent_ticks = 0 ; <S2SV_StartBug> _sys_clock_tick_announce ( ) ; <S2SV_EndBug> } | <S2SV_ModStart> = 0 ; z_clock_announce ( _sys_idle_elapsed_ticks <S2SV_ModEnd> ) ; } |
5,951 | CWE-000 int load_profile ( ) { FILE * profile = fopen ( "./data/profile/.profile.txt" , "rb" ) ; if ( profile == NULL ) { return - 1 ; } if ( getc ( profile ) == EOF ) { fclose ( profile ) ; return - 1 ; } char * str = ( char * ) calloc ( 1000 , sizeof ( char ) ) ; char * pruf = ":<S2SV_blank>\\n<S2SV_blank>\\0" ; fgets ( str , 1000 , profile ) ; char * token = strtok ( str , pruf ) ; if ( strcmp ( token , "ame" ) ) { fclose ( profile ) ; return - 1 ; } token = strtok ( NULL , pruf ) ; name = convert_to_wchar ( token ) ; fgets ( str , 1000 , profile ) ; token = strtok ( str , pruf ) ; token = strtok ( NULL , pruf ) ; level = atoi ( token ) ; <S2SV_StartBug> fgets ( str , 1000 , profile ) ; <S2SV_EndBug> token = strtok ( str , pruf ) ; token = strtok ( NULL , pruf ) ; words = atoi ( token ) ; fgets ( str , 1000 , profile ) ; token = strtok ( str , pruf ) ; token = strtok ( NULL , pruf ) ; fail = atoi ( token ) ; fgets ( str , 1000 , profile ) ; max_learn = 0 ; index_arr = ( int * ) malloc ( sizeof ( int ) * 10000 ) ; if ( index_arr == NULL ) { return - 1 ; } while ( fscanf ( profile , "%s" , str ) != EOF ) { <S2SV_StartBug> if ( atoi ( str ) > 0 || atoi ( str ) < max_learn ) { <S2SV_EndBug> index_arr [ max_learn ] = atoi ( str ) ; <S2SV_StartBug> max_learn ++ ; <S2SV_EndBug> } } <S2SV_StartBug> free ( str ) ; <S2SV_EndBug> fclose ( profile ) ; return 0 ; } | <S2SV_ModStart> token ) ; load_max_index ( ) ; <S2SV_ModStart> ) > 0 && <S2SV_ModEnd> atoi ( str <S2SV_ModStart> str ) < max_index <S2SV_ModEnd> ) { index_arr <S2SV_ModStart> str ) ; wprintf ( L"{-%d-}" , index_arr [ max_learn ] ) ; <S2SV_ModStart> ; } } wprintf ( L"\\n" ) ; |
5,952 | CWE-000 static int bch_cached_dev_io_limit_thread ( void * arg ) { struct cached_dev * dc = arg ; struct cache_set * c = dc -> disk . c ; uint64_t last_seq = 0 ; uint64_t last_size = 0 ; uint64_t last_time = 0 ; uint64_t dirty = 0 ; uint32_t io_limit_enable_interval = 0 ; while ( ! kthread_should_stop ( ) && ! test_bit ( CACHE_SET_IO_DISABLE , & dc -> disk . c -> flags ) ) { <S2SV_StartBug> dirty = cached_dev_sectors_dirty ( & dc -> disk ) ; <S2SV_EndBug> if ( dirty == 0 ) { io_limit_enable_interval = 0 ; goto schedule_sleep ; } if ( dc -> writeback_rate_target <= dirty ) { dc -> writeback_enable_io_limit = 1 ; } else { io_limit_enable_interval ++ ; if ( io_limit_enable_interval >= 5 ) { dc -> writeback_enable_io_limit = 0 ; io_limit_enable_interval = 0 ; } } if ( c -> gc_stats . in_use > CUTOFF_CACHE_READA ) { dc -> writeback_enable_io_limit = 1 ; } else { io_limit_enable_interval ++ ; if ( io_limit_enable_interval >= 5 ) { dc -> writeback_enable_io_limit = 0 ; io_limit_enable_interval = 0 ; } } if ( last_seq == 0 || last_size == 0 ) { dc -> io_limit . iops = 20000 ; dc -> io_limit . mbps = 200 * 1024 * 1024 ; } else { dc -> io_limit . iops = dc -> io_stats . wb_seq - last_seq ; <S2SV_StartBug> dc -> io_limit . mbps = dc -> io_stats . wb_size - last_size ; <S2SV_EndBug> } schedule_sleep : last_seq = dc -> io_stats . wb_seq ; last_size = dc -> io_stats . wb_size ; last_time = local_clock ( ) ; dc -> io_limit . next = last_time + NSEC_PER_SEC ; schedule_timeout_interruptible ( msecs_to_jiffies ( MSEC_PER_SEC ) ) ; } <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> ) ) { set_current_state ( TASK_RUNNING ) ; <S2SV_ModStart> . mbps = ( <S2SV_ModStart> wb_size - last_size ) << 9 <S2SV_ModStart> ) ; } dc -> io_limit_thread = NULL ; cached_dev_put ( dc ) ; wait_for_kthread_stop ( ) ; |
5,953 | CWE-000 int insertLine ( Graph * g , block * u , block * v ) { if ( u == NULL || v == NULL ) { return - 1 ; } <S2SV_StartBug> block * aux = g -> list [ u -> vertex ] -> next ; <S2SV_EndBug> <S2SV_StartBug> g -> list [ u -> vertex ] -> next = v ; <S2SV_EndBug> v -> next = aux ; <S2SV_StartBug> aux = g -> list [ v -> vertex ] -> next ; <S2SV_EndBug> <S2SV_StartBug> g -> list [ v -> vertex ] -> next = u ; <S2SV_EndBug> u -> next = aux ; return 1 ; } | <S2SV_ModStart> -> vertex ] ; g -> list [ u -> vertex ] = v ; printGraph ( g ) <S2SV_ModEnd> ; g -> <S2SV_ModStart> -> next = aux ; printGraph ( g ) <S2SV_ModEnd> ; aux = <S2SV_ModStart> -> vertex ] ; g -> list [ v -> vertex ] = u ; printGraph ( g ) <S2SV_ModEnd> ; g -> <S2SV_ModStart> -> next = aux ; printGraph ( g ) <S2SV_ModEnd> ; return 1 |
5,954 | CWE-000 <S2SV_StartBug> inline void pin_set_output_low ( const pin * p ) { <S2SV_EndBug> * ( p -> io -> clr ) |= p -> mask ; } | <S2SV_ModStart> pin_set_output_low ( const volatile |
5,955 | CWE-000 static int mlx5i_close ( struct net_device * netdev ) { struct mlx5e_priv * epriv = mlx5i_epriv ( netdev ) ; struct mlx5i_priv * ipriv = epriv -> ppriv ; struct mlx5_core_dev * mdev = epriv -> mdev ; mutex_lock ( & epriv -> state_lock ) ; if ( ! test_bit ( MLX5E_STATE_OPENED , & epriv -> state ) ) goto unlock ; clear_bit ( MLX5E_STATE_OPENED , & epriv -> state ) ; netif_carrier_off ( epriv -> netdev ) ; mlx5_fs_remove_rx_underlay_qpn ( mdev , ipriv -> qp . qpn ) ; <S2SV_StartBug> mlx5i_uninit_underlay_qp ( epriv ) ; <S2SV_EndBug> mlx5e_deactivate_priv_channels ( epriv ) ; <S2SV_StartBug> mlx5e_close_channels ( & epriv -> channels ) ; <S2SV_EndBug> unlock : mutex_unlock ( & epriv -> state_lock ) ; return 0 ; } | <S2SV_ModStart> qpn ) ; <S2SV_ModEnd> mlx5e_deactivate_priv_channels ( epriv <S2SV_ModStart> epriv -> channels ) ; mlx5i_uninit_underlay_qp ( epriv |
5,956 | CWE-000 int osp_precreate_get_fid ( const struct lu_env * env , struct osp_device * d , struct lu_fid * fid ) { <S2SV_StartBug> spin_lock ( & d -> opd_pre_lock ) ; <S2SV_EndBug> LASSERTF ( osp_fid_diff ( & d -> opd_pre_used_fid , & d -> opd_pre_last_created_fid ) < 0 , "next<S2SV_blank>fid<S2SV_blank>" DFID "<S2SV_blank>last<S2SV_blank>created<S2SV_blank>fid<S2SV_blank>" DFID "\\n" , PFID ( & d -> opd_pre_used_fid ) , <S2SV_StartBug> PFID ( & d -> opd_pre_last_created_fid ) ) ; <S2SV_EndBug> d -> opd_pre_used_fid . f_oid ++ ; memcpy ( fid , & d -> opd_pre_used_fid , sizeof ( * fid ) ) ; d -> opd_pre_reserved -- ; osp_update_last_fid ( d , fid ) ; spin_unlock ( & d -> opd_pre_lock ) ; if ( unlikely ( d -> opd_pre_reserved == 0 && d -> opd_pre_status ) ) wake_up ( & d -> opd_pre_waitq ) ; return 0 ; } | <S2SV_ModStart> fid ) { struct lu_fid * pre_used_fid = & d -> opd_pre_used_fid ; <S2SV_ModStart> opd_pre_last_created_fid ) ) ; LASSERTF ( osp_fid_end_seq ( env , pre_used_fid ) == 0 , "next<S2SV_blank>fid<S2SV_blank>" DFID "<S2SV_blank>last<S2SV_blank>created<S2SV_blank>fid<S2SV_blank>" DFID "\\n" , PFID ( & d -> opd_pre_used_fid ) , PFID ( & d -> opd_pre_last_created_fid ) ) ; if ( fid_is_idif ( pre_used_fid ) && unlikely ( fid_oid ( pre_used_fid ) == LUSTRE_DATA_SEQ_MAX_WIDTH ) ) pre_used_fid -> f_seq ++ |
5,957 | CWE-000 static void dump_memory_around_ip ( void * ctx ) { # ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX MonoContext mctx ; mono_sigctx_to_monoctx ( ctx , & mctx ) ; gpointer native_ip = MONO_CONTEXT_GET_IP ( & mctx ) ; <S2SV_StartBug> g_printerr ( "Memory<S2SV_blank>around<S2SV_blank>native<S2SV_blank>instruction<S2SV_blank>pointer<S2SV_blank>(%p):\\n" , native_ip ) ; <S2SV_EndBug> xxd_mem ( ( ( guint8 * ) native_ip ) - 0x10 , 0x40 ) ; <S2SV_StartBug> # endif <S2SV_EndBug> } | <S2SV_ModStart> mctx ) ; if ( native_ip ) { mono_runtime_printf_err ( "Memory<S2SV_blank>around<S2SV_blank>native<S2SV_blank>instruction<S2SV_blank>pointer<S2SV_blank>(%p):" <S2SV_ModEnd> , native_ip ) <S2SV_ModStart> 0x40 ) ; } else { mono_runtime_printf_err ( "instruction<S2SV_blank>pointer<S2SV_blank>is<S2SV_blank>NULL,<S2SV_blank>skip<S2SV_blank>dumping" ) ; } |
5,958 | CWE-000 void lcd_refresh ( ) { TCNT2 = _TM2 ; get_screen ( Linebuffer , ui_current_screen ) ; rx_count = 0 ; tx_count = 0 ; <S2SV_StartBug> lcd_quickrefresh ( ) ; <S2SV_EndBug> } | <S2SV_ModStart> = 0 ; snprintf ( Linebuffer [ 2 ] , sizeof Linebuffer [ 2 ] , "0x%lx;" , debugval ) ; |
5,959 | CWE-000 unsigned char * cstring_to_hexarr ( char * arg , int length , char * hashname ) { char * a , * argend ; char v1 , v2 ; unsigned char * output ; unsigned char * p ; int filled ; output = palloc0 ( length ) ; argend = arg + strlen ( arg ) ; a = arg ; p = output ; filled = 0 ; while ( a < argend ) { if ( * a == '<S2SV_blank>' || * a == '\\n' || * a == '\\t' || * a == '\\r' ) { a ++ ; continue ; } v1 = get_hex ( * a ++ ) << 4 ; if ( a >= argend ) ereport ( ERROR , ( errcode ( ERRCODE_INVALID_PARAMETER_VALUE ) , errmsg ( "invalid<S2SV_blank>%s<S2SV_blank>data:<S2SV_blank>odd<S2SV_blank>number<S2SV_blank>of<S2SV_blank>digits" , hashname ) ) ) ; v2 = get_hex ( * a ++ ) ; filled ++ ; if ( filled > length ) ereport ( ERROR , ( errmsg ( "invalid<S2SV_blank>%s<S2SV_blank>data:<S2SV_blank>too<S2SV_blank>many<S2SV_blank>digits<S2SV_blank>(expected<S2SV_blank>%d)" , hashname , length * 2 ) ) ) ; * p ++ = v1 | v2 ; } if ( filled != length ) ereport ( ERROR , <S2SV_StartBug> ( errmsg ( "invalid<S2SV_blank>MD5<S2SV_blank>data:<S2SV_blank>not<S2SV_blank>enough<S2SV_blank>digits<S2SV_blank>(got<S2SV_blank>%d,<S2SV_blank>expected<S2SV_blank>%d)" , <S2SV_EndBug> filled * 2 , length * 2 ) ) ) ; return output ; } | <S2SV_ModStart> ( errmsg ( "invalid<S2SV_blank>%s<S2SV_blank>data:<S2SV_blank>not<S2SV_blank>enough<S2SV_blank>digits<S2SV_blank>(got<S2SV_blank>%d,<S2SV_blank>expected<S2SV_blank>%d)" , hashname <S2SV_ModEnd> , filled * |
5,960 | CWE-000 void render ( renderer * r , float * sampleBuff , float * fftBuff , int buffSize ) { glUseProgram ( r -> progID ) ; glActiveTexture ( GL_TEXTURE0 ) ; glBindTexture ( GL_TEXTURE_1D , r -> audioSamples ) ; <S2SV_StartBug> glTexImage1D ( GL_TEXTURE_1D , 0 , GL_R16 , buffSize , 0 , GL_RED , GL_FLOAT , sampleBuff ) ; <S2SV_EndBug> glActiveTexture ( GL_TEXTURE1 ) ; glBindTexture ( GL_TEXTURE_1D , r -> audioFFT ) ; glTexImage1D ( GL_TEXTURE_1D , 0 , GL_R16 , buffSize / 2 , 0 , GL_RED , GL_FLOAT , fftBuff ) ; GLint timeLoc = glGetUniformLocation ( r -> progID , "time" ) ; if ( timeLoc != - 1 ) glUniform1f ( timeLoc , getUnixTime ( ) ) ; GLint resolutionLoc = glGetUniformLocation ( r -> progID , "resolution" ) ; if ( resolutionLoc != - 1 ) glUniform2f ( resolutionLoc , ( float ) r -> win -> width , ( float ) r -> win -> height ) ; <S2SV_StartBug> glDrawArrays ( GL_TRIANGLE_STRIP , 0 , 4 ) ; <S2SV_EndBug> checkErrors ( "Draw<S2SV_blank>screen" ) ; swapBuffers ( r -> win ) ; usleep ( 1000000 / cfg . fps ) ; } | <S2SV_ModStart> GL_R16 , buffSize / 2 <S2SV_ModStart> GL_FLOAT , sampleBuff + buffSize / 2 <S2SV_ModStart> height ) ; GLint transparencyLoc = glGetUniformLocation ( r -> progID , "transparency" ) ; if ( transparencyLoc != - 1 ) glUniform1f ( transparencyLoc , cfg . transparency ) ; |
5,961 | CWE-000 <S2SV_StartBug> void find_ways ( t_lem * s , int to ) <S2SV_EndBug> { t_ch * chain ; int i ; int ch_loc ; ch_loc = 0 ; chain = ( t_ch * ) malloc ( sizeof ( t_ch ) * s -> ch_cnt ) ; s -> ch_a [ ch_loc ] = chain ; i = - 1 ; while ( ++ i < s -> dim ) { <S2SV_StartBug> if ( s -> c [ to ] [ i ] == 1 && ! on_ch ( s , i ) ) <S2SV_EndBug> { <S2SV_StartBug> add_room ( s , i ) ; <S2SV_EndBug> <S2SV_StartBug> find_ways ( s , i ) ; <S2SV_EndBug> if ( smth_left ( s , to , i ) ) { s -> ch_cnt ++ ; <S2SV_StartBug> fork ( s ) ; <S2SV_EndBug> } } } } | <S2SV_ModStart> , int to , int ch_loc ) { int i <S2SV_ModEnd> ; i = <S2SV_ModStart> s , i , ch_loc <S2SV_ModStart> s , i , ch_loc <S2SV_ModStart> s , i , ch_loc <S2SV_ModStart> ch_cnt ++ ; fork_chain <S2SV_ModEnd> ( s ) <S2SV_ModStart> ( s ) ; ch_loc ++ |
5,962 | CWE-000 json_t * bn_encode_json ( const BIGNUM * bn , size_t len ) { uint8_t * buf = NULL ; json_t * out = NULL ; if ( ! bn ) return NULL ; if ( len == 0 ) len = BN_num_bytes ( bn ) ; if ( ( int ) len < BN_num_bytes ( bn ) ) return NULL ; buf = calloc ( 1 , len ) ; if ( ! buf ) return NULL ; <S2SV_StartBug> if ( ! bn_encode ( bn , buf , len ) ) <S2SV_EndBug> <S2SV_StartBug> return NULL ; <S2SV_EndBug> out = jose_b64_enc ( buf , len ) ; OPENSSL_cleanse ( buf , len ) ; <S2SV_StartBug> free ( buf ) ; <S2SV_EndBug> return out ; } | <S2SV_ModStart> ; if ( <S2SV_ModEnd> bn_encode ( bn <S2SV_ModStart> len ) ) { <S2SV_ModEnd> out = jose_b64_enc <S2SV_ModStart> len ) ; } |
5,963 | CWE-000 int ffop_cancel ( ffop_h _op ) { <S2SV_StartBug> ffop_t * op = ( ffop_t * ) _op ; <S2SV_EndBug> return ff . impl . ops [ op -> type ] . cancel ( op ) ; } | <S2SV_ModStart> * ) _op ; FFLOG ( "Cancelling<S2SV_blank>op<S2SV_blank>%lu<S2SV_blank>(version:<S2SV_blank>%u)\\n" , op -> id , op -> version ) |
5,964 | CWE-000 static ssize_t fill_periodic_buffer ( struct debug_buffer * buf ) { struct usb_hcd * hcd ; struct ehci_hcd * ehci ; unsigned long flags ; union ehci_shadow p , * seen ; unsigned temp , size , seen_count ; char * next ; unsigned i ; __hc32 tag ; if ( ! ( seen = kmalloc ( DBG_SCHED_LIMIT * sizeof * seen , GFP_ATOMIC ) ) ) return 0 ; seen_count = 0 ; hcd = bus_to_hcd ( buf -> bus ) ; ehci = hcd_to_ehci ( hcd ) ; next = buf -> output_buf ; size = buf -> alloc_size ; temp = scnprintf ( next , size , "size<S2SV_blank>=<S2SV_blank>%d\\n" , ehci -> periodic_size ) ; size -= temp ; next += temp ; spin_lock_irqsave ( & ehci -> lock , flags ) ; for ( i = 0 ; i < ehci -> periodic_size ; i ++ ) { p = ehci -> pshadow [ i ] ; if ( likely ( ! p . ptr ) ) continue ; tag = Q_NEXT_TYPE ( ehci , ehci -> periodic [ i ] ) ; temp = scnprintf ( next , size , "%4d:<S2SV_blank>" , i ) ; size -= temp ; next += temp ; do { struct ehci_qh_hw * hw ; switch ( hc32_to_cpu ( ehci , tag ) ) { case Q_TYPE_QH : hw = p . qh -> hw ; <S2SV_StartBug> temp = scnprintf ( next , size , "<S2SV_blank>qh%d-%04x/%p" , <S2SV_EndBug> p . qh -> period , hc32_to_cpup ( ehci , & hw -> hw_info2 ) & ( QH_CMASK | QH_SMASK ) , p . qh ) ; size -= temp ; next += temp ; for ( temp = 0 ; temp < seen_count ; temp ++ ) { if ( seen [ temp ] . ptr != p . ptr ) continue ; if ( p . qh -> qh_next . ptr ) { temp = scnprintf ( next , size , "<S2SV_blank>..." ) ; size -= temp ; next += temp ; } break ; } if ( temp == seen_count ) { u32 scratch = hc32_to_cpup ( ehci , & hw -> hw_info1 ) ; struct ehci_qtd * qtd ; char * type = "" ; temp = 0 ; list_for_each_entry ( qtd , & p . qh -> qtd_list , qtd_list ) { temp ++ ; switch ( 0x03 & ( hc32_to_cpu ( ehci , qtd -> hw_token ) >> 8 ) ) { case 0 : type = "out" ; continue ; case 1 : type = "in" ; continue ; } } temp = scnprintf ( next , size , "<S2SV_blank>(%c%d<S2SV_blank>ep%d%s<S2SV_blank>" "[%d/%d]<S2SV_blank>q%d<S2SV_blank>p%d)" , speed_char ( scratch ) , scratch & 0x007f , ( scratch >> 8 ) & 0x000f , type , p . qh -> usecs , p . qh -> c_usecs , temp , 0x7ff & ( scratch >> 16 ) ) ; if ( seen_count < DBG_SCHED_LIMIT ) seen [ seen_count ++ ] . qh = p . qh ; } else temp = 0 ; tag = Q_NEXT_TYPE ( ehci , hw -> hw_next ) ; p = p . qh -> qh_next ; break ; case Q_TYPE_FSTN : temp = scnprintf ( next , size , <S2SV_StartBug> "<S2SV_blank>fstn-%8x/%p" , p . fstn -> hw_prev , <S2SV_EndBug> p . fstn ) ; tag = Q_NEXT_TYPE ( ehci , p . fstn -> hw_next ) ; p = p . fstn -> fstn_next ; break ; case Q_TYPE_ITD : temp = scnprintf ( next , size , <S2SV_StartBug> "<S2SV_blank>itd/%p" , p . itd ) ; <S2SV_EndBug> tag = Q_NEXT_TYPE ( ehci , p . itd -> hw_next ) ; p = p . itd -> itd_next ; break ; case Q_TYPE_SITD : temp = scnprintf ( next , size , <S2SV_StartBug> "<S2SV_blank>sitd%d-%04x/%p" , <S2SV_EndBug> p . sitd -> stream -> interval , hc32_to_cpup ( ehci , & p . sitd -> hw_uframe ) & 0x0000ffff , p . sitd ) ; tag = Q_NEXT_TYPE ( ehci , p . sitd -> hw_next ) ; p = p . sitd -> sitd_next ; break ; } size -= temp ; next += temp ; } while ( p . ptr ) ; temp = scnprintf ( next , size , "\\n" ) ; size -= temp ; next += temp ; } spin_unlock_irqrestore ( & ehci -> lock , flags ) ; kfree ( seen ) ; return buf -> alloc_size - size ; } | <S2SV_ModStart> , size , "<S2SV_blank>qh%d-%04x/%pK" <S2SV_ModEnd> , p . <S2SV_ModStart> , size , "<S2SV_blank>fstn-%8x/%pK" <S2SV_ModEnd> , p . <S2SV_ModStart> , size , "<S2SV_blank>itd/%pK" <S2SV_ModEnd> , p . <S2SV_ModStart> , size , "<S2SV_blank>sitd%d-%04x/%pK" <S2SV_ModEnd> , p . |
5,965 | CWE-000 void ChunkUpdater_PerformAllocations ( void ) { MapRenderer_Chunks = Platform_MemAlloc ( MapRenderer_ChunksCount * sizeof ( ChunkInfo ) ) ; if ( MapRenderer_Chunks == NULL ) ErrorHandler_Fail ( "ChunkUpdater<S2SV_blank>-<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>chunk<S2SV_blank>info" ) ; MapRenderer_SortedChunks = Platform_MemAlloc ( MapRenderer_ChunksCount * sizeof ( ChunkInfo * ) ) ; if ( MapRenderer_Chunks == NULL ) ErrorHandler_Fail ( "ChunkUpdater<S2SV_blank>-<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>sorted<S2SV_blank>chunk<S2SV_blank>info" ) ; MapRenderer_RenderChunks = Platform_MemAlloc ( MapRenderer_ChunksCount * sizeof ( ChunkInfo * ) ) ; if ( MapRenderer_RenderChunks == NULL ) ErrorHandler_Fail ( "ChunkUpdater<S2SV_blank>-<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>render<S2SV_blank>chunk<S2SV_blank>info" ) ; ChunkUpdater_Distances = Platform_MemAlloc ( MapRenderer_ChunksCount * sizeof ( Int32 ) ) ; if ( ChunkUpdater_Distances == NULL ) ErrorHandler_Fail ( "ChunkUpdater<S2SV_blank>-<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>chunk<S2SV_blank>distances" ) ; <S2SV_StartBug> UInt32 partsSize = MapRenderer_ChunksCount * ( sizeof ( ChunkPartInfo ) * cu_atlas1DCount ) ; <S2SV_EndBug> MapRenderer_PartsBuffer = Platform_MemAlloc ( partsSize ) ; if ( MapRenderer_PartsBuffer == NULL ) ErrorHandler_Fail ( "ChunkUpdater<S2SV_blank>-<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>chunk<S2SV_blank>parts<S2SV_blank>buffer" ) ; Platform_MemSet ( MapRenderer_PartsBuffer , 0 , partsSize ) ; } | <S2SV_ModStart> ChunkPartInfo ) * MapRenderer_1DUsedCount <S2SV_ModEnd> ) ; MapRenderer_PartsBuffer |
5,966 | CWE-000 static void do_python_eval ( char * expr_file ) { verbose ( "eval:<S2SV_blank>%s" , expr_file ) ; if ( strcmp ( expr_file , "-" ) == 0 ) crash ( "expr<S2SV_blank>file<S2SV_blank>cannot<S2SV_blank>be<S2SV_blank>-" ) ; char * expr = slurp ( expr_file ) ; if ( expr == NULL ) crash ( "failed<S2SV_blank>to<S2SV_blank>read:<S2SV_blank>%s" , expr_file ) ; chomp ( expr ) ; char * result ; bool rc = python_eval ( expr , & result ) ; <S2SV_StartBug> free ( expr ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ! rc ) crash ( "python<S2SV_blank>expr<S2SV_blank>failed." ) ; <S2SV_EndBug> printf ( "%s\\n" , result ) ; } | <S2SV_ModStart> result ) ; <S2SV_ModEnd> if ( ! <S2SV_ModStart> crash ( "python<S2SV_blank>expr<S2SV_blank>failed." ) ; free ( expr |
5,967 | CWE-000 static void ft_cmd_ls_rjt ( struct fc_frame * rx_fp , enum fc_els_rjt_reason reason , enum fc_els_rjt_explan explan ) { # if LINUX_VERSION_CODE < KERNEL_VERSION ( 2 , 6 , 36 ) struct fc_seq * sp = fr_seq ( rx_fp ) ; struct fc_frame * fp ; struct fc_els_ls_rjt * rjt ; struct fc_lport * lport ; struct fc_exch * ep ; ep = fc_seq_exch ( sp ) ; lport = ep -> lp ; fp = fc_frame_alloc ( lport , sizeof ( * rjt ) ) ; if ( ! fp ) return ; rjt = fc_frame_payload_get ( fp , sizeof ( * rjt ) ) ; memset ( rjt , 0 , sizeof ( * rjt ) ) ; rjt -> er_cmd = ELS_LS_RJT ; rjt -> er_reason = reason ; rjt -> er_explan = explan ; sp = lport -> tt . seq_start_next ( sp ) ; fc_fill_fc_hdr ( fp , FC_RCTL_ELS_REP , ep -> did , ep -> sid , FC_TYPE_FCP , FC_FC_EX_CTX | FC_FC_END_SEQ | FC_FC_LAST_SEQ , 0 ) ; lport -> tt . seq_send ( lport , sp , fp ) ; # else struct fc_seq_els_data rjt_data ; struct fc_lport * lport ; lport = fr_dev ( rx_fp ) ; rjt_data . reason = reason ; rjt_data . explan = explan ; <S2SV_StartBug> lport -> tt . seq_els_rsp_send ( rx_fp , ELS_LS_RJT , & rjt_data ) ; <S2SV_EndBug> # endif } | <S2SV_ModStart> = explan ; # if LINUX_VERSION_CODE >= KERNEL_VERSION ( 4 , 10 , 0 ) fc_seq_els_rsp_send ( rx_fp , ELS_LS_RJT , & rjt_data ) ; # else <S2SV_ModStart> rjt_data ) ; # endif |
5,968 | CWE-000 static boolean_t _sendMail ( Mail_T mail ) { ASSERT ( mail ) ; boolean_t failed = false ; volatile SMTP_T smtp = NULL ; volatile MailServer_T mta = NULL ; TRY { mta = _connectMTA ( ) ; smtp = SMTP_new ( mta -> socket ) ; SMTP_greeting ( smtp ) ; SMTP_helo ( smtp , Run . mail_hostname ? Run . mail_hostname : Run . system -> name ) ; if ( mta -> ssl . flags == SSL_StartTLS ) SMTP_starttls ( smtp , mta -> ssl ) ; if ( mta -> username && mta -> password ) SMTP_auth ( smtp , mta -> username , mta -> password ) ; char now [ STRLEN ] ; Time_gmtstring ( Time_now ( ) , now ) ; for ( Mail_T m = mail ; m ; m = m -> next ) { SMTP_from ( smtp , m -> from ) ; SMTP_to ( smtp , m -> to ) ; SMTP_dataBegin ( smtp ) ; <S2SV_StartBug> if ( ( m -> replyto && Socket_print ( mta -> socket , "Reply-To:<S2SV_blank>%s\\r\\n" , m -> replyto ) <= 0 ) || Socket_print ( mta -> socket , <S2SV_EndBug> <S2SV_StartBug> "From:<S2SV_blank>%s\\r\\n" <S2SV_EndBug> "To:<S2SV_blank>%s\\r\\n" "Subject:<S2SV_blank>%s\\r\\n" "Date:<S2SV_blank>%s\\r\\n" "X-Mailer:<S2SV_blank>Monit<S2SV_blank>%s\\r\\n" "MIME-Version:<S2SV_blank>1.0\\r\\n" "Content-Type:<S2SV_blank>text/plain;<S2SV_blank>charset=\\"iso-8859-1\\"\\r\\n" "Content-Transfer-Encoding:<S2SV_blank>8bit\\r\\n" "Message-Id:<S2SV_blank><%lld.%lu@%s>\\r\\n" "\\r\\n" <S2SV_StartBug> "%s" , <S2SV_EndBug> m -> from , m -> to , m -> subject , now , VERSION , ( long long ) Time_now ( ) , random ( ) , Run . mail_hostname ? Run . mail_hostname : Run . system -> name , m -> message ) <= 0 ) { THROW ( IOException , "Error<S2SV_blank>sending<S2SV_blank>data<S2SV_blank>to<S2SV_blank>mail<S2SV_blank>server<S2SV_blank>%s<S2SV_blank>--<S2SV_blank>%s" , mta -> host , STRERROR ) ; } SMTP_dataCommit ( smtp ) ; } SMTP_quit ( smtp ) ; } ELSE { failed = true ; LogError ( "Mail:<S2SV_blank>%s\\n" , Exception_frame . message ) ; } FINALLY { if ( smtp ) SMTP_free ( ( SMTP_T * ) & smtp ) ; if ( mta && mta -> socket ) Socket_free ( & ( mta -> socket ) ) ; } END_TRY ; return failed ; } | <S2SV_ModStart> <= 0 ) || ( ( m -> sender && Socket_print ( mta -> socket , "From:<S2SV_blank>\\"%s\\"<S2SV_blank><%s>\\r\\n" , m -> sender , m -> from ) <= 0 ) <S2SV_ModStart> socket , "From:<S2SV_blank>%s\\r\\n" , m -> from ) <= 0 ) || Socket_print ( mta -> socket , <S2SV_ModStart> "Message-Id:<S2SV_blank><%lld.%lu@%s>\\r\\n" "\\r\\n" "%s" <S2SV_ModEnd> , m -> |
5,969 | CWE-000 int removemem ( void ) { if ( shmctl ( shmid , IPC_RMID , ( struct shmid_ds * ) 0 ) < 0 ) { <S2SV_StartBug> return 0 ; <S2SV_EndBug> } perror ( "removemem" ) ; <S2SV_StartBug> return 1 ; <S2SV_EndBug> } | <S2SV_ModStart> 0 ) { <S2SV_ModEnd> perror ( "removemem" <S2SV_ModStart> ) ; return 0 ; } return |
5,970 | CWE-000 void startConsoleMode ( ) { Command userCmd ; <S2SV_StartBug> GameSettings * settings ; <S2SV_EndBug> GameState * game = NULL ; bool is_reset = true ; do { if ( is_reset ) { printf ( STR_SELECT_SETTINGS ) ; is_reset = false ; } if ( settings == NULL ) { settings = GameSettingsCreate ( ) ; } userCmd = getUserCommand ( ) ; if ( userCmd . cmd == GAME_MODE ) { arg = strtoumax ( userCmd . arg , NULL , 10 ) ; setGameMode ( settings , arg ) ; } else if ( userCmd . cmd == DIFFICULTY ) { arg = strtoumax ( userCmd . arg , NULL , 10 ) ; setDifficulty ( settings , arg ) ; } else if ( userCmd . cmd == USER_COLOR ) { arg = strtoumax ( userCmd . arg , NULL , 10 ) ; setUserColor ( settings , arg ) ; } else if ( userCmd . cmd == LOAD ) { game = xmlGameLoadGame ( userCmd . arg ) ; if ( game != NULL ) { GameSettingsDestroy ( settings ) ; settings = NULL ; is_reset = startGame ( game ) ; game = NULL ; if ( ! is_reset ) { break ; } } else { printf ( STR_ERR_FILE ) ; } } else if ( userCmd . cmd == DEFAULT ) { setDefaultSettings ( settings ) ; } else if ( userCmd . cmd == PRINT_SETTING ) { printSettings ( settings ) ; } else if ( userCmd . cmd == QUIT ) { printf ( STR_EXITING ) ; GameSettingsDestroy ( settings ) ; return ; } else if ( userCmd . cmd == START ) { if ( game == NULL ) { game = GameStateCreate ( settings -> difficulty , settings -> userColor == 1 , settings -> gameMode ) ; } GameSettingsDestroy ( settings ) ; settings = NULL ; is_reset = startGame ( game ) ; game = NULL ; if ( ! is_reset ) { break ; } } } while ( userCmd . cmd != QUIT ) ; GameSettingsDestroy ( settings ) ; <S2SV_StartBug> return ; <S2SV_EndBug> } | <S2SV_ModStart> GameSettings * settings = NULL <S2SV_ModStart> settings ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
5,971 | CWE-000 void av1_update_tx_type_count ( const AV1_COMMON * cm , MACROBLOCKD * xd , # if CONFIG_TXK_SEL int blk_row , int blk_col , int plane , # endif BLOCK_SIZE bsize , TX_SIZE tx_size , FRAME_COUNTS * counts , uint8_t allow_update_cdf ) { MB_MODE_INFO * mbmi = & xd -> mi [ 0 ] -> mbmi ; int is_inter = is_inter_block ( mbmi ) ; FRAME_CONTEXT * fc = xd -> tile_ctx ; # if ! CONFIG_ENTROPY_STATS ( void ) counts ; # endif # if ! CONFIG_TXK_SEL TX_TYPE tx_type = mbmi -> tx_type ; # else <S2SV_StartBug> ( void ) blk_row ; <S2SV_EndBug> ( void ) blk_col ; if ( plane > 0 ) return ; TX_TYPE tx_type = av1_get_tx_type ( PLANE_TYPE_Y , xd , blk_row , blk_col , tx_size ) ; # endif if ( get_ext_tx_types ( tx_size , bsize , is_inter , cm -> reduced_tx_set_used ) > 1 && cm -> base_qindex > 0 && ! mbmi -> skip && ! segfeature_active ( & cm -> seg , mbmi -> segment_id , SEG_LVL_SKIP ) ) { const int eset = get_ext_tx_set ( tx_size , bsize , is_inter , cm -> reduced_tx_set_used ) ; if ( eset > 0 ) { const TxSetType tx_set_type = get_ext_tx_set_type ( tx_size , bsize , is_inter , cm -> reduced_tx_set_used ) ; if ( is_inter ) { if ( allow_update_cdf ) update_cdf ( fc -> inter_ext_tx_cdf [ eset ] [ txsize_sqr_map [ tx_size ] ] , av1_ext_tx_ind [ tx_set_type ] [ tx_type ] , av1_num_ext_tx_set [ tx_set_type ] ) ; # if CONFIG_ENTROPY_STATS ++ counts -> inter_ext_tx [ eset ] [ txsize_sqr_map [ tx_size ] ] [ tx_type ] ; # endif } else { # if CONFIG_FILTER_INTRA PREDICTION_MODE intra_dir ; if ( mbmi -> filter_intra_mode_info . use_filter_intra ) intra_dir = fimode_to_intradir [ mbmi -> filter_intra_mode_info . filter_intra_mode ] ; else intra_dir = mbmi -> mode ; # if CONFIG_ENTROPY_STATS ++ counts -> intra_ext_tx [ eset ] [ txsize_sqr_map [ tx_size ] ] [ intra_dir ] [ tx_type ] ; # endif if ( allow_update_cdf ) update_cdf ( fc -> intra_ext_tx_cdf [ eset ] [ txsize_sqr_map [ tx_size ] ] [ intra_dir ] , av1_ext_tx_ind [ tx_set_type ] [ tx_type ] , av1_num_ext_tx_set [ tx_set_type ] ) ; # else # if CONFIG_ENTROPY_STATS ++ counts -> intra_ext_tx [ eset ] [ txsize_sqr_map [ tx_size ] ] [ mbmi -> mode ] [ tx_type ] ; # endif if ( allow_update_cdf ) update_cdf ( fc -> intra_ext_tx_cdf [ eset ] [ txsize_sqr_map [ tx_size ] ] [ mbmi -> mode ] , av1_ext_tx_ind [ tx_set_type ] [ tx_type ] , av1_num_ext_tx_set [ tx_set_type ] ) ; # endif } } } } | <S2SV_ModStart> ; # else <S2SV_ModEnd> if ( plane |
5,972 | CWE-000 int main ( ) { int i ; <S2SV_StartBug> for ( i = 0 ; i < 100 ; i ++ ) <S2SV_EndBug> pong ( ) ; return 0 ; } | <S2SV_ModStart> int i ; while ( 1 <S2SV_ModEnd> ) pong ( |
5,973 | CWE-000 static int fastrpc_file_free ( struct fastrpc_file * fl ) { struct hlist_node * n ; struct fastrpc_mmap * map = NULL ; int cid ; if ( ! fl ) return 0 ; cid = fl -> cid ; spin_lock ( & fl -> apps -> hlock ) ; hlist_del_init ( & fl -> hn ) ; spin_unlock ( & fl -> apps -> hlock ) ; if ( ! fl -> sctx ) { <S2SV_StartBug> goto bail ; <S2SV_EndBug> } ( void ) fastrpc_release_current_dsp_process ( fl ) ; fastrpc_context_list_dtor ( fl ) ; fastrpc_buf_list_free ( fl ) ; hlist_for_each_entry_safe ( map , n , & fl -> maps , hn ) { fastrpc_mmap_free ( map ) ; } if ( fl -> ssrcount == fl -> apps -> channel [ cid ] . ssrcount ) kref_put_mutex ( & fl -> apps -> channel [ cid ] . kref , fastrpc_channel_close , & fl -> apps -> smd_mutex ) ; <S2SV_StartBug> bail : <S2SV_EndBug> mutex_destroy ( & fl -> map_mutex ) ; kfree ( fl ) ; return 0 ; } | <S2SV_ModStart> sctx ) { kfree ( fl ) ; return 0 <S2SV_ModEnd> ; } ( <S2SV_ModStart> smd_mutex ) ; <S2SV_ModEnd> mutex_destroy ( & |
5,974 | CWE-000 static int _qce_sps_add_sg_data ( struct qce_device * pce_dev , struct scatterlist * sg_src , uint32_t nbytes , struct sps_transfer * sps_bam_pipe ) { uint32_t addr , data_cnt , len ; struct sps_iovec * iovec = sps_bam_pipe -> iovec + sps_bam_pipe -> iovec_count ; while ( nbytes > 0 ) { len = min ( nbytes , sg_dma_len ( sg_src ) ) ; nbytes -= len ; addr = sg_dma_address ( sg_src ) ; if ( pce_dev -> ce_sps . minor_version == 0 ) len = ALIGN ( len , pce_dev -> ce_sps . ce_burst_size ) ; while ( len > 0 ) { if ( len > SPS_MAX_PKT_SIZE ) { <S2SV_StartBug> data_cnt = SPS_MAX_PKT_SIZE ; <S2SV_EndBug> iovec -> size = data_cnt ; iovec -> addr = addr ; iovec -> flags = 0 ; } else { data_cnt = len ; iovec -> size = data_cnt ; iovec -> addr = addr ; iovec -> flags = 0 ; } iovec ++ ; sps_bam_pipe -> iovec_count ++ ; addr += data_cnt ; len -= data_cnt ; } sg_src ++ ; } return 0 ; } | <S2SV_ModStart> SPS_MAX_PKT_SIZE ) { if ( ( len % SPS_MAX_PKT_SIZE ) > 0 ) data_cnt = ( len % SPS_MAX_PKT_SIZE ) ; else |
5,975 | CWE-000 int pnl_test_mat_int_eq ( const PnlMatInt * X , const PnlMatInt * Y , const char * str , const char * fmt , ... ) { int i , status ; va_list ap ; <S2SV_StartBug> va_start ( ap , fmt ) ; <S2SV_EndBug> va_end ( ap ) ; status = 0 ; if ( X -> m != Y -> m || X -> n != Y -> n ) { printf ( "%s<S2SV_blank>:<S2SV_blank>" , str ) ; printf ( "FAIL<S2SV_blank>(size<S2SV_blank>mismatch" ) ; printf ( fmt , ap ) ; printf ( ")\\n" ) ; <S2SV_StartBug> update_count_tests ( 1 ) ; <S2SV_EndBug> return FALSE ; } for ( i = 0 ; i < X -> mn ; i ++ ) { const int x = X -> array [ i ] ; const int y = Y -> array [ i ] ; status = ( x != y ) ; if ( status ) break ; } if ( status || verbose == TRUE ) { printf ( "\\t%s<S2SV_blank>:<S2SV_blank>" , str ) ; printf ( status ? "FAIL" : "OK" ) ; if ( status ) { printf ( "<S2SV_blank>(" ) ; vprintf ( fmt , ap ) ; <S2SV_StartBug> va_end ( ap ) ; <S2SV_EndBug> printf ( "<S2SV_blank>expected<S2SV_blank>%d<S2SV_blank>observed<S2SV_blank>%d)" , Y -> array [ i ] , X -> array [ i ] ) ; } printf ( "\\n" ) ; } update_count_tests ( status ) ; return ( status ? FALSE : TRUE ) ; } | <S2SV_ModStart> ap , fmt <S2SV_ModEnd> ) ; status <S2SV_ModStart> update_count_tests ( 1 ) ; va_end ( ap <S2SV_ModStart> ap ) ; printf ( "<S2SV_blank>expected<S2SV_blank>%d<S2SV_blank>observed<S2SV_blank>%d)" , Y -> array [ i ] , X -> array [ i ] ) ; } printf ( "\\n" ) ; } update_count_tests ( status ) ; <S2SV_ModStart> va_end ( ap <S2SV_ModEnd> ) ; return |
5,976 | CWE-000 PROCESS_THREAD ( mqtt_process , ev , data ) { static struct mqtt_connection * conn ; PROCESS_BEGIN ( ) ; while ( 1 ) { PROCESS_WAIT_EVENT ( ) ; if ( ev == mqtt_abort_now_event ) { DBG ( "MQTT<S2SV_blank>-<S2SV_blank>Abort\\n" ) ; conn = data ; conn -> state = MQTT_CONN_STATE_ABORT_IMMEDIATE ; abort_connection ( conn ) ; } if ( ev == mqtt_do_connect_tcp_event ) { conn = data ; DBG ( "MQTT<S2SV_blank>-<S2SV_blank>Got<S2SV_blank>mqtt_do_connect_tcp_event!\\n" ) ; connect_tcp ( conn ) ; } if ( ev == mqtt_do_connect_mqtt_event ) { conn = data ; conn -> socket . output_data_max_seg = conn -> max_segment_size ; DBG ( "MQTT<S2SV_blank>-<S2SV_blank>Got<S2SV_blank>mqtt_do_connect_mqtt_event!\\n" ) ; if ( conn -> out_buffer_sent == 1 ) { PT_INIT ( & conn -> out_proto_thread ) ; while ( connect_pt ( & conn -> out_proto_thread , conn ) < PT_EXITED && conn -> state != MQTT_CONN_STATE_ABORT_IMMEDIATE ) { PT_MQTT_WAIT_SEND ( ) ; } } } if ( ev == mqtt_do_disconnect_mqtt_event ) { conn = data ; DBG ( "MQTT<S2SV_blank>-<S2SV_blank>Got<S2SV_blank>mqtt_do_disconnect_mqtt_event!\\n" ) ; if ( conn -> state == MQTT_CONN_STATE_SENDING_MQTT_DISCONNECT ) { if ( conn -> out_buffer_sent == 1 ) { PT_INIT ( & conn -> out_proto_thread ) ; while ( conn -> state != MQTT_CONN_STATE_ABORT_IMMEDIATE && disconnect_pt ( & conn -> out_proto_thread , conn ) < PT_EXITED ) { PT_MQTT_WAIT_SEND ( ) ; } abort_connection ( conn ) ; call_event ( conn , MQTT_EVENT_DISCONNECTED , & ev ) ; } else { process_post ( & mqtt_process , mqtt_do_disconnect_mqtt_event , conn ) ; } } } if ( ev == mqtt_do_pingreq_event ) { conn = data ; DBG ( "MQTT<S2SV_blank>-<S2SV_blank>Got<S2SV_blank>mqtt_do_pingreq_event!\\n" ) ; if ( conn -> out_buffer_sent == 1 && conn -> state == MQTT_CONN_STATE_CONNECTED_TO_BROKER ) { PT_INIT ( & conn -> out_proto_thread ) ; while ( conn -> state == MQTT_CONN_STATE_CONNECTED_TO_BROKER && pingreq_pt ( & conn -> out_proto_thread , conn ) < PT_EXITED ) { PT_MQTT_WAIT_SEND ( ) ; } <S2SV_StartBug> } <S2SV_EndBug> } if ( ev == mqtt_do_subscribe_event ) { conn = data ; DBG ( "MQTT<S2SV_blank>-<S2SV_blank>Got<S2SV_blank>mqtt_do_subscribe_mqtt_event!\\n" ) ; if ( conn -> out_buffer_sent == 1 && conn -> state == MQTT_CONN_STATE_CONNECTED_TO_BROKER ) { PT_INIT ( & conn -> out_proto_thread ) ; while ( conn -> state == MQTT_CONN_STATE_CONNECTED_TO_BROKER && subscribe_pt ( & conn -> out_proto_thread , conn ) < PT_EXITED ) { PT_MQTT_WAIT_SEND ( ) ; } } } if ( ev == mqtt_do_unsubscribe_event ) { conn = data ; DBG ( "MQTT<S2SV_blank>-<S2SV_blank>Got<S2SV_blank>mqtt_do_unsubscribe_mqtt_event!\\n" ) ; if ( conn -> out_buffer_sent == 1 && conn -> state == MQTT_CONN_STATE_CONNECTED_TO_BROKER ) { PT_INIT ( & conn -> out_proto_thread ) ; while ( conn -> state == MQTT_CONN_STATE_CONNECTED_TO_BROKER && unsubscribe_pt ( & conn -> out_proto_thread , conn ) < PT_EXITED ) { PT_MQTT_WAIT_SEND ( ) ; } } } if ( ev == mqtt_do_publish_event ) { conn = data ; DBG ( "MQTT<S2SV_blank>-<S2SV_blank>Got<S2SV_blank>mqtt_do_publish_mqtt_event!\\n" ) ; if ( conn -> out_buffer_sent == 1 && conn -> state == MQTT_CONN_STATE_CONNECTED_TO_BROKER ) { PT_INIT ( & conn -> out_proto_thread ) ; while ( conn -> state == MQTT_CONN_STATE_CONNECTED_TO_BROKER && publish_pt ( & conn -> out_proto_thread , conn ) < PT_EXITED ) { PT_MQTT_WAIT_SEND ( ) ; } } } } PROCESS_END ( ) ; } | <S2SV_ModStart> ) ; } printf ( "Done<S2SV_blank>pt_pingreq<S2SV_blank>pt<S2SV_blank>p<S2SV_blank>t<S2SV_blank>p<S2SV_blank><S2SV_blank>t\\n" ) ; |
5,977 | CWE-000 int msr_restore ( const char * restore_path , const char * whitelist_path , const char * msr_path_format , int num_cpu ) { int err = 0 ; int tmp_err = 0 ; int i , j ; <S2SV_StartBug> int msr_fd ; <S2SV_EndBug> int do_print_header = 1 ; size_t num_msr = 0 ; uint64_t read_val = 0 ; uint64_t masked_val = 0 ; uint64_t write_val = 0 ; uint64_t * msr_offset = NULL ; uint64_t * msr_mask = NULL ; uint64_t * restore_buffer = NULL ; FILE * restore_fid = NULL ; struct stat restore_stat ; struct stat whitelist_stat ; char err_msg [ NAME_MAX ] ; err = msr_parse_whitelist ( whitelist_path , & num_msr , & msr_offset , & msr_mask ) ; if ( err ) <S2SV_StartBug> { <S2SV_EndBug> goto exit ; } tmp_err = stat ( restore_path , & restore_stat ) ; if ( tmp_err != 0 ) { err = errno ? errno : - 1 ; snprintf ( err_msg , NAME_MAX , "stat()<S2SV_blank>of<S2SV_blank>%s<S2SV_blank>failed!<S2SV_blank>" , restore_path ) ; perror ( err_msg ) ; goto exit ; } tmp_err = stat ( whitelist_path , & whitelist_stat ) ; if ( tmp_err != 0 ) { err = errno ? errno : - 1 ; snprintf ( err_msg , NAME_MAX , "stat()<S2SV_blank>of<S2SV_blank>%s<S2SV_blank>failed!<S2SV_blank>" , whitelist_path ) ; perror ( err_msg ) ; goto exit ; } if ( restore_stat . st_mtime < whitelist_stat . st_mtime ) { err = - 1 ; fprintf ( stderr , "Error:<S2SV_blank>whitelist<S2SV_blank>was<S2SV_blank>modified<S2SV_blank>after<S2SV_blank>restore<S2SV_blank>file<S2SV_blank>was<S2SV_blank>written!" ) ; goto exit ; } restore_buffer = ( uint64_t * ) malloc ( num_msr * num_cpu * sizeof ( uint64_t ) ) ; if ( ! restore_buffer ) { err = errno ? errno : - 1 ; snprintf ( err_msg , NAME_MAX , "Unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>msr<S2SV_blank>restore<S2SV_blank>state<S2SV_blank>buffer<S2SV_blank>of<S2SV_blank>size:<S2SV_blank>%zu!" , num_msr * num_cpu * sizeof ( uint64_t ) ) ; perror ( err_msg ) ; goto exit ; } restore_fid = fopen ( restore_path , "r" ) ; if ( ! restore_fid ) { err = errno ? errno : - 1 ; snprintf ( err_msg , NAME_MAX , "Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>restore<S2SV_blank>file<S2SV_blank>\\"%s\\"!" , restore_path ) ; perror ( err_msg ) ; goto exit ; } size_t num_read = fread ( restore_buffer , sizeof ( uint64_t ) , num_msr * num_cpu , restore_fid ) ; if ( num_read != num_msr * num_cpu || fgetc ( restore_fid ) != EOF ) { err = errno ? errno : - 1 ; snprintf ( err_msg , NAME_MAX , "Could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>all<S2SV_blank>values<S2SV_blank>from<S2SV_blank>input<S2SV_blank>file<S2SV_blank>\\"%s\\"!" , restore_path ) ; perror ( err_msg ) ; goto exit ; } tmp_err = fclose ( restore_fid ) ; restore_fid = NULL ; if ( tmp_err ) { err = errno ? errno : - 1 ; snprintf ( err_msg , NAME_MAX , "Could<S2SV_blank>not<S2SV_blank>close<S2SV_blank>MSR<S2SV_blank>file<S2SV_blank>\\"%s\\"!" , restore_path ) ; perror ( err_msg ) ; goto exit ; } for ( i = 0 ; i < num_cpu ; ++ i ) { char msr_file_name [ NAME_MAX ] ; snprintf ( msr_file_name , NAME_MAX , msr_path_format , i ) ; msr_fd = open ( msr_file_name , O_RDWR ) ; if ( msr_fd == - 1 ) { err = errno ? errno : - 1 ; snprintf ( err_msg , NAME_MAX , "Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>MSR<S2SV_blank>file<S2SV_blank>\\"%s\\"!" , msr_file_name ) ; perror ( err_msg ) ; goto exit ; } for ( j = 0 ; j < num_msr ; ++ j ) { ssize_t count = pread ( msr_fd , & read_val , sizeof ( uint64_t ) , msr_offset [ j ] ) ; if ( count != sizeof ( uint64_t ) ) { err = errno ? errno : - 1 ; snprintf ( err_msg , NAME_MAX , "Failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>msr<S2SV_blank>value<S2SV_blank>from<S2SV_blank>MSR<S2SV_blank>file<S2SV_blank>\\"%s\\"!" , msr_file_name ) ; perror ( err_msg ) ; goto exit ; } masked_val = ( read_val & msr_mask [ j ] ) ; if ( masked_val != restore_buffer [ i * num_msr + j ] ) { write_val = ( ( read_val & ~ ( msr_mask [ j ] ) ) | restore_buffer [ i * num_msr + j ] ) ; count = pwrite ( msr_fd , & write_val , sizeof ( uint64_t ) , msr_offset [ j ] ) ; if ( count != sizeof ( uint64_t ) ) { err = errno ? errno : - 1 ; <S2SV_StartBug> snprintf ( err_msg , NAME_MAX , "Failed<S2SV_blank>to<S2SV_blank>write<S2SV_blank>msr<S2SV_blank>value<S2SV_blank>at<S2SV_blank>offset<S2SV_blank>0x%016xz<S2SV_blank>to<S2SV_blank>MSR<S2SV_blank>file<S2SV_blank>\\"%s\\"!" , msr_offset [ j ] , msr_file_name ) ; <S2SV_EndBug> perror ( err_msg ) ; goto exit ; } if ( do_print_header ) { printf ( "offset,<S2SV_blank>read,<S2SV_blank>restored\\n" ) ; do_print_header = 0 ; } printf ( "0x%016zx,<S2SV_blank>0x%016zx,<S2SV_blank>0x%016zx\\n" , msr_offset [ j ] , read_val , write_val ) ; } } tmp_err = close ( msr_fd ) ; msr_fd = - 1 ; if ( tmp_err ) { err = errno ? errno : - 1 ; snprintf ( err_msg , NAME_MAX , "Could<S2SV_blank>not<S2SV_blank>close<S2SV_blank>MSR<S2SV_blank>file<S2SV_blank>\\"%s\\"!" , msr_file_name ) ; perror ( err_msg ) ; goto exit ; } } exit : if ( restore_buffer ) { free ( restore_buffer ) ; } if ( restore_fid ) { fclose ( restore_fid ) ; } if ( msr_offset ) { free ( msr_offset ) ; } if ( msr_mask ) { free ( msr_mask ) ; } if ( msr_fd != - 1 ) { close ( msr_fd ) ; } return err ; } | <S2SV_ModStart> ; int msr_fd = - 1 <S2SV_ModStart> err ) { goto exit ; } if ( ! msr_offset || ! msr_mask ) { err = - 1 ; <S2SV_ModStart> , NAME_MAX , "Failed<S2SV_blank>to<S2SV_blank>write<S2SV_blank>msr<S2SV_blank>value<S2SV_blank>at<S2SV_blank>offset<S2SV_blank>0x%016zx<S2SV_blank>to<S2SV_blank>MSR<S2SV_blank>file<S2SV_blank>\\"%s\\"!" <S2SV_ModEnd> , msr_offset [ |
5,978 | CWE-000 WimaStatus wima_area_setup ( WimaAr * area , bool allocate ) { wassert ( WIMA_AREA_IS_LEAF ( area ) , WIMA_ASSERT_AREA_LEAF ) ; WimaStatus status = WIMA_STATUS_SUCCESS ; if ( ! allocate ) { area -> area . ctx . itemCount = 0 ; area -> area . ctx . items = NULL ; area -> area . ctx . widgetData = NULL ; return WIMA_STATUS_SUCCESS ; } WimaEditor edtr = area -> area . type ; wassert ( edtr < dvec_len ( wg . editors ) , WIMA_ASSERT_EDITOR ) ; WimaEdtr * editor = dvec_get ( wg . editors , edtr ) ; size_t size = ynalloc ( sizeof ( WimaItem ) * editor -> itemCap ) ; area -> area . ctx . items = ymalloc ( size ) ; <S2SV_StartBug> if ( yunlikely ( ! area -> area . ctx . items ) ) { <S2SV_EndBug> return WIMA_STATUS_MALLOC_ERR ; } area -> area . ctx . itemCap = size / sizeof ( WimaItem ) ; area -> area . ctx . itemCount = 0 ; area -> area . ctx . widgetData = dpool_create ( 0.9f , NULL , NULL , NULL , sizeof ( uint64_t ) ) ; <S2SV_StartBug> if ( yunlikely ( area -> area . ctx . widgetData == NULL ) ) { <S2SV_EndBug> ysfree ( area -> area . ctx . items , size ) ; return WIMA_STATUS_MALLOC_ERR ; } if ( editor -> allocSize > 0 ) { uint64_t key = wima_widget_hash ( WIMA_PROP_INVALID , ( uint8_t ) - 1 ) ; WimaAreaInitDataFunc init = editor -> funcs . init ; if ( init ) { void * ptr = dpool_malloc ( area -> area . ctx . widgetData , & key , editor -> allocSize ) ; <S2SV_StartBug> if ( yunlikely ( ptr == NULL ) ) { <S2SV_EndBug> return WIMA_STATUS_MALLOC_ERR ; } WimaArea wah ; wah . area = area -> node ; wah . window = area -> window ; status = init ( wah , ptr ) ; } else { void * ptr = dpool_calloc ( area -> area . ctx . widgetData , & key , editor -> allocSize ) ; <S2SV_StartBug> if ( yunlikely ( ptr == NULL ) ) { <S2SV_EndBug> status = WIMA_STATUS_MALLOC_ERR ; } } } return status ; } | <S2SV_ModStart> ; if ( yerror <S2SV_ModEnd> ( ! area <S2SV_ModStart> ; if ( yerror <S2SV_ModEnd> ( area -> <S2SV_ModStart> ; if ( yerror <S2SV_ModEnd> ( ptr == <S2SV_ModStart> ; if ( yerror <S2SV_ModEnd> ( ptr == |
5,979 | CWE-000 static int ceph_x_decrypt ( struct ceph_crypto_key * secret , <S2SV_StartBug> void * * p , void * end , void * obuf , size_t olen ) <S2SV_EndBug> { struct ceph_x_encrypt_header head ; size_t head_len = sizeof ( head ) ; int len , ret ; len = ceph_decode_32 ( p ) ; if ( * p + len > end ) return - EINVAL ; dout ( "ceph_x_decrypt<S2SV_blank>len<S2SV_blank>%d\\n" , len ) ; <S2SV_StartBug> ret = ceph_decrypt2 ( secret , & head , & head_len , obuf , & olen , <S2SV_EndBug> * p , len ) ; if ( ret ) return ret ; if ( head . struct_v != 1 || le64_to_cpu ( head . magic ) != CEPHX_ENC_MAGIC ) return - EPERM ; * p += len ; return olen ; } | <S2SV_ModStart> end , void * <S2SV_ModStart> len ) ; if ( * obuf == NULL ) { * obuf = kmalloc ( len , GFP_NOFS ) ; if ( ! * obuf ) return - ENOMEM ; olen = len ; } <S2SV_ModStart> & head_len , * |
5,980 | CWE-000 bigint * bi_divide ( BI_CTX * ctx , bigint * u , bigint * v , int is_mod ) { int n = v -> size , m = u -> size - n ; int j = 0 , orig_u_size = u -> size ; uint8_t mod_offset = ctx -> mod_offset ; comp d ; bigint * quotient , * tmp_u ; comp q_dash ; check ( u ) ; check ( v ) ; if ( is_mod && bi_compare ( v , u ) > 0 ) { bi_free ( ctx , v ) ; return u ; } quotient = alloc ( ctx , m + 1 ) ; tmp_u = alloc ( ctx , n + 1 ) ; v = trim ( v ) ; <S2SV_StartBug> d = ( comp ) ( ( long_comp ) COMP_RADIX / ( V1 + 1 ) ) ; <S2SV_EndBug> memset ( quotient -> comps , 0 , ( ( quotient -> size ) * COMP_BYTE_SIZE ) ) ; if ( d > 1 ) { u = bi_int_multiply ( ctx , u , d ) ; if ( is_mod ) { v = ctx -> bi_normalised_mod [ mod_offset ] ; } else { v = bi_int_multiply ( ctx , v , d ) ; } } if ( orig_u_size == u -> size ) { more_comps ( u , orig_u_size + 1 ) ; } do { memcpy ( tmp_u -> comps , & u -> comps [ u -> size - n - 1 - j ] , ( n + 1 ) * COMP_BYTE_SIZE ) ; if ( U ( 0 ) == V1 ) { q_dash = COMP_RADIX - 1 ; } else { q_dash = ( comp ) ( ( ( long_comp ) U ( 0 ) * COMP_RADIX + U ( 1 ) ) / V1 ) ; if ( v -> size > 1 && V2 ) { comp inner = ( comp ) ( ( long_comp ) COMP_RADIX * U ( 0 ) + U ( 1 ) - ( long_comp ) q_dash * V1 ) ; if ( ( long_comp ) V2 * q_dash > ( long_comp ) inner * COMP_RADIX + U ( 2 ) ) { q_dash -- ; } } } if ( q_dash ) { int is_negative ; tmp_u = bi_subtract ( ctx , tmp_u , bi_int_multiply ( ctx , bi_copy ( v ) , q_dash ) , & is_negative ) ; more_comps ( tmp_u , n + 1 ) ; Q ( j ) = q_dash ; if ( is_negative ) { Q ( j ) -- ; tmp_u = bi_add ( ctx , tmp_u , bi_copy ( v ) ) ; tmp_u -> size -- ; v -> size -- ; } } else { Q ( j ) = 0 ; } memcpy ( & u -> comps [ u -> size - n - 1 - j ] , tmp_u -> comps , ( n + 1 ) * COMP_BYTE_SIZE ) ; } while ( ++ j <= m ) ; bi_free ( ctx , tmp_u ) ; bi_free ( ctx , v ) ; if ( is_mod ) { bi_free ( ctx , quotient ) ; return bi_int_divide ( ctx , trim ( u ) , d ) ; } else { bi_free ( ctx , u ) ; return trim ( quotient ) ; } } | <S2SV_ModStart> COMP_RADIX / ( ( ( long_comp ) V1 ) <S2SV_ModEnd> + 1 ) |
5,981 | CWE-000 static unsigned int procmsg_INITRESP ( unsigned char * buf , unsigned int nb , void * p ) { <S2SV_StartBug> struct PICA_c2n * ci = ( struct PICA_c2n * ) p ; <S2SV_EndBug> switch ( buf [ 0 ] ) { case PICA_PROTO_INITRESPOK : ci -> init_resp_ok = 1 ; break ; case PICA_PROTO_VERDIFFER : ci -> init_resp_ok = - 1 ; ci -> node_ver_major = buf [ 2 ] ; ci -> node_ver_minor = buf [ 3 ] ; break ; default : return 0 ; } return 1 ; } | <S2SV_ModStart> * ) p ; if ( ci -> state != PICA_C2N_STATE_WAITINGREP ) return 0 |
5,982 | CWE-000 static bool on_option ( char key , char * value ) { bool res ; switch ( key ) { case 'H' : if ( ! tpm2_util_string_to_uint32 ( value , & ctx . parent_handle ) ) { LOG_ERR ( "Invalid<S2SV_blank>parent<S2SV_blank>handle,<S2SV_blank>got\\"%s\\"" , value ) ; return false ; } ctx . flags . H = 1 ; break ; case 'P' : res = tpm2_password_util_from_optarg ( value , & ctx . session_data . hmac ) ; if ( ! res ) { LOG_ERR ( "Invalid<S2SV_blank>parent<S2SV_blank>key<S2SV_blank>password,<S2SV_blank>got\\"%s\\"" , value ) ; return false ; } ctx . flags . P = 1 ; break ; case 'K' : res = tpm2_password_util_from_optarg ( value , & ctx . in_sensitive . sensitive . userAuth ) ; if ( ! res ) { LOG_ERR ( "Invalid<S2SV_blank>key<S2SV_blank>password,<S2SV_blank>got\\"%s\\"" , value ) ; return false ; } ctx . flags . K = 1 ; <S2SV_StartBug> break ; <S2SV_EndBug> case 'g' : ctx . nameAlg = tpm2_alg_util_from_optarg ( value ) ; if ( ctx . nameAlg == TPM2_ALG_ERROR ) { LOG_ERR ( "Invalid<S2SV_blank>hash<S2SV_blank>algorithm,<S2SV_blank>got\\"%s\\"" , value ) ; return false ; } ctx . flags . g = 1 ; break ; case 'G' : ctx . in_public . publicArea . type = tpm2_alg_util_from_optarg ( value ) ; if ( ctx . in_public . publicArea . type == TPM2_ALG_ERROR ) { LOG_ERR ( "Invalid<S2SV_blank>key<S2SV_blank>algorithm,<S2SV_blank>got\\"%s\\"" , value ) ; return false ; } ctx . flags . G = 1 ; break ; case 'A' : { bool res = tpm2_attr_util_obj_from_optarg ( value , & ctx . in_public . publicArea . objectAttributes ) ; if ( ! res ) { LOG_ERR ( "Invalid<S2SV_blank>object<S2SV_blank>attribute,<S2SV_blank>got\\"%s\\"" , value ) ; return false ; } ctx . flags . A = 1 ; } break ; case 'I' : ctx . input = strcmp ( "-" , value ) ? value : NULL ; ctx . flags . I = 1 ; break ; case 'L' : ctx . in_public . publicArea . authPolicy . size = sizeof ( ctx . in_public . publicArea . authPolicy ) - 2 ; if ( ! files_load_bytes_from_path ( value , ctx . in_public . publicArea . authPolicy . buffer , & ctx . in_public . publicArea . authPolicy . size ) ) { return false ; } <S2SV_StartBug> ctx . flags . L = 1 ; <S2SV_EndBug> break ; case 'S' : if ( ! tpm2_util_string_to_uint32 ( value , & ctx . session_data . sessionHandle ) ) { LOG_ERR ( "Could<S2SV_blank>not<S2SV_blank>convert<S2SV_blank>session<S2SV_blank>handle<S2SV_blank>to<S2SV_blank>number,<S2SV_blank>got:<S2SV_blank>\\"%s\\"" , value ) ; return false ; } break ; case 'u' : ctx . opu_path = value ; if ( files_does_file_exist ( ctx . opu_path ) != 0 ) { return false ; } ctx . flags . o = 1 ; break ; case 'r' : ctx . opr_path = value ; if ( files_does_file_exist ( ctx . opr_path ) != 0 ) { return false ; } ctx . flags . O = 1 ; break ; case 'c' : ctx . context_parent_path = value ; if ( ctx . context_parent_path == NULL || ctx . context_parent_path [ 0 ] == '\\0' ) { return false ; } ctx . flags . c = 1 ; break ; } ; return true ; } | <S2SV_ModStart> = 1 ; ctx . in_public . publicArea . objectAttributes |= TPMA_OBJECT_USERWITHAUTH ; <S2SV_ModStart> L = 1 ; if ( ! ctx . flags . K ) ctx . in_public . publicArea . objectAttributes &= ~ TPMA_OBJECT_USERWITHAUTH ; ctx . in_public . publicArea . objectAttributes |= TPMA_OBJECT_ADMINWITHPOLICY |
5,983 | CWE-000 void closeClient ( ftpDataType * ftpData , int processingSocket ) { <S2SV_StartBug> printf ( "\\nQUIT<S2SV_blank>FLAG<S2SV_blank>SET!\\n" ) ; <S2SV_EndBug> void * pReturn ; pthread_cancel ( ftpData -> clients [ processingSocket ] . workerData . workerThread ) ; <S2SV_StartBug> pthread_join ( ftpData -> clients [ processingSocket ] . workerData . workerThread , & pReturn ) ; <S2SV_EndBug> <S2SV_StartBug> printf ( "\\nQuit<S2SV_blank>command<S2SV_blank>received<S2SV_blank>the<S2SV_blank>Pasv<S2SV_blank>Thread<S2SV_blank>has<S2SV_blank>been<S2SV_blank>cancelled." ) ; <S2SV_EndBug> FD_CLR ( ftpData -> clients [ processingSocket ] . socketDescriptor , & ftpData -> connectionData . rsetAll ) ; FD_CLR ( ftpData -> clients [ processingSocket ] . socketDescriptor , & ftpData -> connectionData . wsetAll ) ; FD_CLR ( ftpData -> clients [ processingSocket ] . socketDescriptor , & ftpData -> connectionData . esetAll ) ; closeSocket ( ftpData , processingSocket ) ; ftpData -> connectionData . maxSocketFD = ftpData -> connectionData . theMainSocket + 1 ; ftpData -> connectionData . maxSocketFD = getMaximumSocketFd ( ftpData -> connectionData . theMainSocket , ftpData ) + 1 ; return ; } | <S2SV_ModStart> "\\nQUIT<S2SV_blank>FLAG<S2SV_blank>SET!\\n" ) ; if ( ftpData -> clients [ processingSocket ] . workerData . threadIsAlive == 1 ) { <S2SV_ModStart> workerThread ) ; <S2SV_ModEnd> printf ( "\\nQuit<S2SV_blank>command<S2SV_blank>received<S2SV_blank>the<S2SV_blank>Pasv<S2SV_blank>Thread<S2SV_blank>has<S2SV_blank>been<S2SV_blank>cancelled." <S2SV_ModStart> "\\nQuit<S2SV_blank>command<S2SV_blank>received<S2SV_blank>the<S2SV_blank>Pasv<S2SV_blank>Thread<S2SV_blank>has<S2SV_blank>been<S2SV_blank>cancelled." ) ; } |
5,984 | CWE-000 static bool DoesLinkExist ( app_Ref_t appRef , struct stat srcStat , const char * destPath ) { struct stat destStat ; if ( stat ( destPath , & destStat ) == - 1 ) { if ( errno != ENOENT ) { LE_WARN ( "Could<S2SV_blank>not<S2SV_blank>stat<S2SV_blank>file<S2SV_blank>at<S2SV_blank>\'%s\'.<S2SV_blank>%m" , destPath ) ; } } else { <S2SV_StartBug> if ( srcStat . st_ino == destStat . st_ino ) <S2SV_EndBug> { <S2SV_StartBug> return true ; <S2SV_EndBug> } if ( ! appRef -> sandboxed ) { if ( unlink ( destPath ) == - 1 ) { LE_WARN ( "Could<S2SV_blank>not<S2SV_blank>delete<S2SV_blank>%s.<S2SV_blank><S2SV_blank>%m," , destPath ) ; } } } return false ; } | <S2SV_ModStart> { if ( S_ISCHR ( srcStat . st_mode ) || S_ISBLK ( srcStat . st_mode ) ) { if ( ( srcStat . st_rdev == destStat . st_rdev ) && ( srcStat . st_ino != destStat . st_ino ) ) { return true ; } } else { if ( <S2SV_ModStart> return true ; } |
5,985 | CWE-000 mfs_error_t mfsEraseRecord ( MFSDriver * mfsp , uint32_t id ) { flash_offset_t free , required ; mfs_bank_state_t sts ; bool warning = false ; osalDbgCheck ( ( mfsp != NULL ) && ( id >= 1 ) && ( id <= MFS_CFG_MAX_RECORDS ) ) ; osalDbgAssert ( mfsp -> state == MFS_MOUNTED , "invalid<S2SV_blank>state" ) ; <S2SV_StartBug> if ( mfsp -> descriptors [ id ] . offset == 0U ) { <S2SV_EndBug> return MFS_ERR_NOT_FOUND ; } required = ( flash_offset_t ) sizeof ( mfs_data_header_t ) ; if ( required > mfsp -> config -> bank_size - mfsp -> used_space ) { return MFS_ERR_INTERNAL ; } free = mfsp -> config -> bank_size - mfsp -> next_offset ; if ( required > free ) { warning = true ; RET_ON_ERROR ( mfs_garbage_collect ( mfsp , & sts ) ) ; } mfsp -> buffer . dhdr . fields . magic = ( uint32_t ) MFS_HEADER_MAGIC ; mfsp -> buffer . dhdr . fields . id = ( uint16_t ) id ; mfsp -> buffer . dhdr . fields . size = ( uint32_t ) 0 ; mfsp -> buffer . dhdr . fields . crc = ( uint16_t ) 0 ; RET_ON_ERROR ( mfs_flash_write ( mfsp , mfsp -> next_offset , sizeof ( mfs_data_header_t ) , <S2SV_StartBug> mfsp -> buffer . data ) ) ; <S2SV_EndBug> mfsp -> used_space -= sizeof ( mfs_data_header_t ) + <S2SV_StartBug> mfsp -> descriptors [ id ] . size ; <S2SV_EndBug> mfsp -> next_offset += sizeof ( mfs_data_header_t ) ; <S2SV_StartBug> mfsp -> descriptors [ id ] . offset = 0U ; <S2SV_EndBug> <S2SV_StartBug> mfsp -> descriptors [ id ] . size = 0U ; <S2SV_EndBug> return warning ? MFS_WARN_GC : MFS_NO_ERROR ; } | <S2SV_ModStart> descriptors [ id - 1U <S2SV_ModStart> -> buffer . data8 <S2SV_ModEnd> ) ) ; <S2SV_ModStart> descriptors [ id - 1U <S2SV_ModStart> descriptors [ id - 1U <S2SV_ModStart> descriptors [ id - 1U |
5,986 | CWE-000 <S2SV_StartBug> xpc_connection_t XpcConnect ( char * service , void * ctx ) { <S2SV_EndBug> dispatch_queue_t queue = dispatch_queue_create ( service , 0 ) ; xpc_connection_t conn = xpc_connection_create_mach_service ( service , queue , XPC_CONNECTION_MACH_SERVICE_PRIVILEGED ) ; <S2SV_StartBug> GoInterface ictx = * ( ( GoInterface * ) ctx ) ; <S2SV_EndBug> xpc_connection_set_event_handler ( conn , Block_copy ( ^ ( xpc_object_t event ) { <S2SV_StartBug> handleXpcEvent ( event , ( void * ) & ictx ) ; <S2SV_EndBug> } ) ) ; xpc_connection_resume ( conn ) ; return conn ; } | <S2SV_ModStart> * service , uintptr_t <S2SV_ModEnd> ctx ) { <S2SV_ModStart> XPC_CONNECTION_MACH_SERVICE_PRIVILEGED ) ; <S2SV_ModEnd> xpc_connection_set_event_handler ( conn <S2SV_ModStart> ( event , ctx <S2SV_ModEnd> ) ; } |
5,987 | CWE-000 struct page * follow_page ( struct vm_area_struct * vma , unsigned long address , unsigned int flags ) { pgd_t * pgd ; pud_t * pud ; pmd_t * pmd ; pte_t * ptep , pte ; spinlock_t * ptl ; struct page * page ; struct mm_struct * mm = vma -> vm_mm ; page = follow_huge_addr ( mm , address , flags & FOLL_WRITE ) ; if ( ! IS_ERR ( page ) ) { BUG_ON ( flags & FOLL_GET ) ; goto out ; } page = NULL ; pgd = pgd_offset ( mm , address ) ; if ( pgd_none ( * pgd ) || unlikely ( pgd_bad ( * pgd ) ) ) goto no_page_table ; pud = pud_offset ( pgd , address ) ; if ( pud_none ( * pud ) ) goto no_page_table ; if ( pud_huge ( * pud ) && vma -> vm_flags & VM_HUGETLB ) { BUG_ON ( flags & FOLL_GET ) ; page = follow_huge_pud ( mm , address , pud , flags & FOLL_WRITE ) ; goto out ; } if ( unlikely ( pud_bad ( * pud ) ) ) goto no_page_table ; pmd = pmd_offset ( pud , address ) ; if ( pmd_none ( * pmd ) ) goto no_page_table ; if ( pmd_huge ( * pmd ) && vma -> vm_flags & VM_HUGETLB ) { BUG_ON ( flags & FOLL_GET ) ; page = follow_huge_pmd ( mm , address , pmd , flags & FOLL_WRITE ) ; goto out ; } if ( pmd_trans_huge ( * pmd ) ) { if ( flags & FOLL_SPLIT ) { split_huge_page_pmd ( mm , pmd ) ; goto split_fallthrough ; } spin_lock ( & mm -> page_table_lock ) ; if ( likely ( pmd_trans_huge ( * pmd ) ) ) { if ( unlikely ( pmd_trans_splitting ( * pmd ) ) ) { spin_unlock ( & mm -> page_table_lock ) ; wait_split_huge_page ( vma -> anon_vma , pmd ) ; } else { page = follow_trans_huge_pmd ( mm , address , pmd , flags ) ; spin_unlock ( & mm -> page_table_lock ) ; goto out ; } } else spin_unlock ( & mm -> page_table_lock ) ; } split_fallthrough : if ( unlikely ( pmd_bad ( * pmd ) ) ) goto no_page_table ; ptep = pte_offset_map_lock ( mm , pmd , address , & ptl ) ; pte = * ptep ; if ( ! pte_present ( pte ) ) goto no_page ; <S2SV_StartBug> if ( ( flags & FOLL_WRITE ) && ! pte_write ( pte ) ) <S2SV_EndBug> goto unlock ; page = vm_normal_page ( vma , address , pte ) ; if ( unlikely ( ! page ) ) { if ( ( flags & FOLL_DUMP ) || ! is_zero_pfn ( pte_pfn ( pte ) ) ) goto bad_page ; page = pte_page ( pte ) ; } if ( flags & FOLL_GET ) get_page_foll ( page ) ; if ( flags & FOLL_TOUCH ) { if ( ( flags & FOLL_WRITE ) && ! pte_dirty ( pte ) && ! PageDirty ( page ) ) set_page_dirty ( page ) ; mark_page_accessed ( page ) ; } if ( ( flags & FOLL_MLOCK ) && ( vma -> vm_flags & VM_LOCKED ) ) { if ( page -> mapping && trylock_page ( page ) ) { lru_add_drain ( ) ; if ( page -> mapping ) mlock_vma_page ( page ) ; unlock_page ( page ) ; } } <S2SV_StartBug> unlock : <S2SV_EndBug> pte_unmap_unlock ( ptep , ptl ) ; out : return page ; bad_page : pte_unmap_unlock ( ptep , ptl ) ; return ERR_PTR ( - EFAULT ) ; no_page : pte_unmap_unlock ( ptep , ptl ) ; if ( ! pte_none ( pte ) ) return page ; no_page_table : if ( ( flags & FOLL_DUMP ) && ( ! vma -> vm_ops || ! vma -> vm_ops -> fault ) ) return ERR_PTR ( - EFAULT ) ; return page ; } | <S2SV_ModStart> goto no_page ; page = vm_normal_page ( vma , address , pte ) ; <S2SV_ModStart> ) && ! can_follow_write_pte ( pte , page , flags ) ) { pte_unmap_unlock ( ptep , ptl ) ; return NULL ; } <S2SV_ModEnd> if ( unlikely <S2SV_ModStart> ; } } <S2SV_ModEnd> pte_unmap_unlock ( ptep |
5,988 | CWE-000 int fcgi_accept_request ( fcgi_request * req ) { # ifdef _WIN32 HANDLE pipe ; OVERLAPPED ov ; # endif while ( 1 ) { if ( req -> fd < 0 ) { while ( 1 ) { if ( in_shutdown ) { return - 1 ; } # ifdef _WIN32 if ( ! req -> tcp ) { pipe = ( HANDLE ) _get_osfhandle ( req -> listen_socket ) ; FCGI_LOCK ( req -> listen_socket ) ; ov . hEvent = CreateEvent ( NULL , TRUE , FALSE , NULL ) ; if ( ! ConnectNamedPipe ( pipe , & ov ) ) { errno = GetLastError ( ) ; if ( errno == ERROR_IO_PENDING ) { while ( WaitForSingleObject ( ov . hEvent , 1000 ) == WAIT_TIMEOUT ) { if ( in_shutdown ) { CloseHandle ( ov . hEvent ) ; FCGI_UNLOCK ( req -> listen_socket ) ; return - 1 ; } } } else if ( errno != ERROR_PIPE_CONNECTED ) { } } CloseHandle ( ov . hEvent ) ; req -> fd = req -> listen_socket ; FCGI_UNLOCK ( req -> listen_socket ) ; } else { SOCKET listen_socket = ( SOCKET ) _get_osfhandle ( req -> listen_socket ) ; # else { int listen_socket = req -> listen_socket ; # endif sa_t sa ; socklen_t len = sizeof ( sa ) ; req -> hook . on_accept ( ) ; FCGI_LOCK ( req -> listen_socket ) ; req -> fd = accept ( listen_socket , ( struct sockaddr * ) & sa , & len ) ; FCGI_UNLOCK ( req -> listen_socket ) ; client_sa = sa ; if ( req -> fd >= 0 && ! fcgi_is_allowed ( ) ) { fcgi_log ( FCGI_ERROR , "Connection<S2SV_blank>disallowed:<S2SV_blank>IP<S2SV_blank>address<S2SV_blank>\'%s\'<S2SV_blank>has<S2SV_blank>been<S2SV_blank>dropped." , fcgi_get_last_client_ip ( ) ) ; closesocket ( req -> fd ) ; req -> fd = - 1 ; continue ; } } # ifdef _WIN32 if ( req -> fd < 0 && ( in_shutdown || errno != EINTR ) ) { # else if ( req -> fd < 0 && ( in_shutdown || ( errno != EINTR && errno != ECONNABORTED ) ) ) { # endif return - 1 ; } # ifdef _WIN32 break ; # else if ( req -> fd >= 0 ) { <S2SV_StartBug> # if defined ( HAVE_SYS_POLL_H ) && defined ( HAVE_POLL ) <S2SV_EndBug> struct pollfd fds ; int ret ; fds . fd = req -> fd ; fds . events = POLLIN ; fds . revents = 0 ; do { errno = 0 ; ret = poll ( & fds , 1 , 5000 ) ; } while ( ret < 0 && errno == EINTR ) ; if ( ret > 0 && ( fds . revents & POLLIN ) ) { break ; } fcgi_close ( req , 1 , 0 ) ; # else if ( req -> fd < FD_SETSIZE ) { struct timeval tv = { 5 , 0 } ; fd_set set ; int ret ; FD_ZERO ( & set ) ; FD_SET ( req -> fd , & set ) ; do { errno = 0 ; ret = select ( req -> fd + 1 , & set , NULL , NULL , & tv ) >= 0 ; } while ( ret < 0 && errno == EINTR ) ; if ( ret > 0 && FD_ISSET ( req -> fd , & set ) ) { break ; } fcgi_close ( req , 1 , 0 ) ; } else { fcgi_log ( FCGI_ERROR , "Too<S2SV_blank>many<S2SV_blank>open<S2SV_blank>file<S2SV_blank>descriptors.<S2SV_blank>FD_SETSIZE<S2SV_blank>limit<S2SV_blank>exceeded." ) ; fcgi_close ( req , 1 , 0 ) ; } # endif } # endif } } else if ( in_shutdown ) { return - 1 ; } req -> hook . on_read ( ) ; if ( fcgi_read_request ( req ) ) { # ifdef _WIN32 if ( is_impersonate && ! req -> tcp ) { pipe = ( HANDLE ) _get_osfhandle ( req -> fd ) ; if ( ! ImpersonateNamedPipeClient ( pipe ) ) { fcgi_close ( req , 1 , 1 ) ; continue ; } } # endif return req -> fd ; } else { fcgi_close ( req , 1 , 1 ) ; } } } | <S2SV_ModStart> if defined ( HAVE_POLL_H <S2SV_ModEnd> ) && defined |
5,989 | CWE-000 void cpu_thread_clean ( struct thread * td ) { struct pcb * pcb ; pcb = td -> td_pcb ; if ( pcb -> pcb_tssp != NULL ) { pmap_pti_remove_kva ( ( vm_offset_t ) pcb -> pcb_tssp , ( vm_offset_t ) pcb -> pcb_tssp + ctob ( IOPAGES + 1 ) ) ; <S2SV_StartBug> kmem_free ( kernel_arena , ( vm_offset_t ) pcb -> pcb_tssp , <S2SV_EndBug> ctob ( IOPAGES + 1 ) ) ; pcb -> pcb_tssp = NULL ; } } | <S2SV_ModStart> ; kmem_free ( <S2SV_ModEnd> ( vm_offset_t ) |
5,990 | CWE-000 int main ( int argc , const char * const * const argv ) { if ( argc < 2 ) { fprintf ( stderr , "usage:<S2SV_blank>%s<S2SV_blank>filename\\n" , argv [ 0 ] ) ; exit ( EXIT_FAILURE ) ; } size_t loc_next [ LOCS ] ; size_t loc_size [ LOCS ] ; double * loc_value [ LOCS ] ; for ( uint_fast8_t i = 0 ; i < LOCS ; i ++ ) { loc_next [ i ] = 0 ; loc_size [ i ] = EXT_SIZE ; loc_value [ i ] = malloc ( loc_size [ i ] * sizeof ( loc_value [ i ] [ 0 ] ) ) ; if ( NULL == loc_value [ i ] ) error_exit ( "malloc:<S2SV_blank>" ) ; } FILE * fp = fopen ( argv [ 1 ] , "r" ) ; if ( NULL == fp ) error_exit ( "fopen:<S2SV_blank>" ) ; uint_fast32_t lineno = 0 ; char line [ MAX_LINE_LEN ] ; while ( NULL != fgets ( line , sizeof ( line ) , fp ) ) { lineno ++ ; char * s = strpbrk ( line , "#\\n" ) ; if ( NULL != s ) * s = '\\0' ; for ( s = & line [ 0 ] ; isspace ( * s ) ; s ++ ) ; if ( '\\0' == * s ) continue ; uint8_t loc = 0 ; double value = NAN ; # if 0 <S2SV_StartBug> if ( 2 != sscanf ( s , "%*d;<S2SV_blank>%" SCNu8 ";<S2SV_blank>%lf" , & loc , & value ) ) <S2SV_EndBug> print_error_and_continue ( lineno , line ) ; if ( loc < 1 || loc > LOCS ) print_error_and_continue ( lineno , line ) ; # else while ( isdigit ( * s ) ) s ++ ; while ( isspace ( * s ) ) s ++ ; if ( ';' != * s ) print_error_and_continue ( lineno , line ) ; s ++ ; while ( isspace ( * s ) ) s ++ ; if ( * s < '1' || * s > ( LOCS + '0' ) ) print_error_and_continue ( lineno , line ) ; loc = * s - '0' ; s ++ ; if ( isspace ( * s ) ) s ++ ; if ( ';' != * s ) print_error_and_continue ( lineno , line ) ; s ++ ; char * ep = NULL ; value = strtod ( s , & ep ) ; if ( s == ep ) print_error_and_continue ( lineno , line ) ; while ( isspace ( * ep ) ) ep ++ ; if ( '\\0' != * ep ) print_error_and_continue ( lineno , line ) ; # endif if ( ! isnormal ( value ) || value <= 0.0 ) <S2SV_StartBug> { <S2SV_EndBug> fprintf ( stderr , "Line<S2SV_blank>%" PRIuFAST32 ":<S2SV_blank>Invalid<S2SV_blank>value\\n" , lineno ) ; continue ; } loc -- ; assert ( loc < LOCS ) ; if ( loc_next [ loc ] == loc_size [ loc ] ) { loc_size [ loc ] += EXT_SIZE ; loc_value [ loc ] = realloc ( loc_value [ loc ] , loc_size [ loc ] * sizeof ( loc_value [ loc ] [ 0 ] ) ) ; if ( NULL == loc_value [ loc ] ) error_exit ( "realloc:<S2SV_blank>" ) ; } assert ( loc_next [ loc ] < loc_size [ loc ] ) ; loc_value [ loc ] [ loc_next [ loc ] ] = value ; loc_next [ loc ] ++ ; } if ( fclose ( fp ) ) error_exit ( "fclose:<S2SV_blank>" ) ; printf ( "File:<S2SV_blank>%s<S2SV_blank>with<S2SV_blank>%" PRIuFAST64 "<S2SV_blank>lines\\n" , argv [ 1 ] , lineno ) ; for ( uint_fast8_t i = 0 ; i < LOCS ; i ++ ) { printf ( "Valid<S2SV_blank>values<S2SV_blank>Loc%" PRIuFAST8 ":<S2SV_blank>%zu<S2SV_blank>with<S2SV_blank>GeoMean:<S2SV_blank>%.6f\\n" , i , loc_next [ i ] , geom_mean_log ( loc_value [ i ] , loc_next [ i ] ) ) ; free ( loc_value [ i ] ) ; } return EXIT_SUCCESS ; } | <S2SV_ModStart> # if 0 char extra [ 2 ] ; int ret = sscanf ( s , "%*d<S2SV_blank>;<S2SV_blank>%" SCNu8 "<S2SV_blank>;<S2SV_blank>%lf<S2SV_blank>%1s" , & loc , & value , extra ) ; <S2SV_ModStart> ( 2 != ret <S2SV_ModEnd> ) print_error_and_continue ( <S2SV_ModStart> <= 0.0 ) print_error_and_continue ( lineno , line ) ; <S2SV_ModEnd> loc -- ; |
5,991 | CWE-000 void var_return_to_heap ( seni_vm * vm , seni_var * var ) { if ( var -> allocated == false ) { return ; } DEBUG_INFO_RETURN_TO_HEAP ( vm ) ; # ifdef SENI_DEBUG_MODE if ( var -> debug_allocatable == false ) { SENI_ERROR ( "trying<S2SV_blank>to<S2SV_blank>return<S2SV_blank>a<S2SV_blank>seni_var<S2SV_blank>to<S2SV_blank>the<S2SV_blank>pool<S2SV_blank>that<S2SV_blank>wasnt<S2SV_blank>originally<S2SV_blank>from<S2SV_blank>the<S2SV_blank>pool" ) ; } # endif if ( var -> type == VAR_VEC_HEAD ) { <S2SV_StartBug> vector_ref_count_decrement ( vm , var ) ; <S2SV_EndBug> } if ( var -> type == VAR_COLOUR ) { colour_return_to_vm ( vm , var -> value . c ) ; } if ( var -> next != NULL ) { var_return_to_heap ( vm , var -> next ) ; } var -> allocated = false ; DL_APPEND ( vm -> heap_avail , var ) ; } | <S2SV_ModStart> VAR_VEC_HEAD ) { bool res = <S2SV_ModStart> var ) ; if ( res == false ) { SENI_ERROR ( "var_return_to_heap" ) ; } |
5,992 | CWE-000 static int camera_v4l2_queryctrl ( struct file * filep , void * fh , struct v4l2_queryctrl * ctrl ) { int rc = 0 ; <S2SV_StartBug> struct v4l2_event event ; <S2SV_EndBug> if ( ctrl -> type == V4L2_CTRL_TYPE_MENU ) { camera_pack_event ( filep , MSM_CAMERA_GET_PARM , ctrl -> id , - 1 , & event ) ; rc = msm_post_event ( & event , MSM_POST_EVT_TIMEOUT ) ; if ( rc < 0 ) return rc ; rc = camera_check_event_status ( & event ) ; } return rc ; } | <S2SV_ModStart> struct v4l2_event event ; if ( msm_is_daemon_present ( ) == false ) return 0 |
5,993 | CWE-000 static void ngx_mrb_timer_handler ( ngx_event_t * ev ) { ngx_mrb_reentrant_t * re ; ngx_http_mruby_ctx_t * ctx ; ngx_int_t rc = NGX_OK ; re = ev -> data ; ctx = ngx_mrb_http_get_module_ctx ( NULL , re -> r ) ; if ( ctx != NULL ) { if ( re -> fiber != NULL ) { ngx_mrb_push_request ( re -> r ) ; if ( mrb_test ( ngx_mrb_run_fiber ( re -> mrb , re -> fiber , ctx -> async_handler_result ) ) ) { return ; } else { mrb_gc_unregister ( re -> mrb , * re -> fiber ) ; re -> fiber = NULL ; } ngx_http_run_posted_requests ( re -> r -> connection ) ; if ( re -> mrb -> exc ) { ngx_mrb_raise_error ( re -> mrb , mrb_obj_value ( re -> mrb -> exc ) , re -> r ) ; rc = NGX_HTTP_INTERNAL_SERVER_ERROR ; } if ( ctx -> set_var_target . len > 1 ) { if ( ctx -> set_var_target . data [ 0 ] != '$' ) { ngx_log_error ( NGX_LOG_NOTICE , re -> r -> connection -> log , 0 , <S2SV_StartBug> "%s<S2SV_blank>NOTICE<S2SV_blank>%s:%d:<S2SV_blank>invalid<S2SV_blank>variable<S2SV_blank>name<S2SV_blank>error,<S2SV_blank>name:<S2SV_blank>%s" MODULE_NAME , __func__ , __LINE__ , <S2SV_EndBug> ctx -> set_var_target . data ) ; rc = NGX_HTTP_INTERNAL_SERVER_ERROR ; } else { ngx_mrb_var_set_vector ( re -> mrb , mrb_top_self ( re -> mrb ) , ( char * ) ctx -> set_var_target . data + 1 , ctx -> set_var_target . len - 1 , * ctx -> async_handler_result , re -> r ) ; } } } else { ngx_log_error ( NGX_LOG_NOTICE , re -> r -> connection -> log , 0 , <S2SV_StartBug> "%s<S2SV_blank>NOTICE<S2SV_blank>%s:%d:<S2SV_blank>unexpected<S2SV_blank>error,<S2SV_blank>fiber<S2SV_blank>missing" MODULE_NAME , __func__ , __LINE__ ) ; <S2SV_EndBug> rc = NGX_HTTP_INTERNAL_SERVER_ERROR ; } if ( rc != NGX_OK ) { re -> r -> headers_out . status = NGX_HTTP_INTERNAL_SERVER_ERROR ; } rc = ngx_mrb_finalize_rputs ( re -> r , ctx ) ; } else { rc = NGX_ERROR ; } if ( rc == NGX_DECLINED ) { re -> r -> phase_handler ++ ; ngx_http_core_run_phases ( re -> r ) ; return ; } ngx_http_finalize_request ( re -> r , rc ) ; } | <S2SV_ModStart> , 0 , "%s<S2SV_blank>NOTICE<S2SV_blank>%s:%d:<S2SV_blank>invalid<S2SV_blank>variable<S2SV_blank>name<S2SV_blank>error<S2SV_blank>name:<S2SV_blank>%s" , <S2SV_ModEnd> MODULE_NAME , __func__ <S2SV_ModStart> 0 , "%s<S2SV_blank>NOTICE<S2SV_blank>%s:%d:<S2SV_blank>unexpected<S2SV_blank>error,<S2SV_blank>fiber<S2SV_blank>missing" , |
5,994 | CWE-000 int pblk_rail_read_bio ( struct pblk * pblk , struct nvm_rq * rqd , unsigned int bio_init_idx , unsigned long * read_bitmap , struct nvm_rq * new_rqd , unsigned char * pvalid ) { struct bio * new_bio , * bio = rqd -> bio ; struct bio_vec src_bv , dst_bv ; void * src_p , * dst_p ; int nr_orig_secs = bitmap_weight ( read_bitmap , rqd -> nr_ppas ) ; int nr_holes = nr_orig_secs * ( pblk -> rail . stride_width - 1 ) ; int nr_secs = rqd -> nr_ppas ; int i , ret , hole , n_idx = 0 ; DECLARE_COMPLETION_ONSTACK ( wait ) ; new_bio = bio_alloc ( GFP_KERNEL , nr_holes ) ; if ( ! new_bio ) { pr_err ( "pblk:<S2SV_blank>could<S2SV_blank>not<S2SV_blank>alloc<S2SV_blank>read<S2SV_blank>bio\\n" ) ; return NVM_IO_ERR ; } if ( pblk_bio_add_pages ( pblk , new_bio , GFP_KERNEL , nr_holes ) ) goto err ; if ( nr_holes != new_bio -> bi_vcnt ) { pr_err ( "pblk:<S2SV_blank>malformed<S2SV_blank>bio\\n" ) ; goto err_pages ; } new_bio -> bi_iter . bi_sector = 0 ; bio_set_op_attrs ( new_bio , REQ_OP_READ , 0 ) ; new_bio -> bi_private = & wait ; new_bio -> bi_end_io = pblk_end_bio_sync ; new_rqd -> opcode = NVM_OP_PREAD ; new_rqd -> private = pblk ; new_rqd -> bio = new_bio ; new_rqd -> nr_ppas = nr_holes ; new_rqd -> flags = pblk_set_read_mode ( pblk , PBLK_READ_RANDOM ) ; new_rqd -> end_io = NULL ; ret = pblk_submit_read_io ( pblk , new_rqd ) ; if ( ret ) { bio_put ( new_rqd -> bio ) ; pr_err ( "pblk:<S2SV_blank>read<S2SV_blank>IO<S2SV_blank>submission<S2SV_blank>failed\\n" ) ; goto err_pages ; } if ( ! wait_for_completion_io_timeout ( & wait , msecs_to_jiffies ( PBLK_COMMAND_TIMEOUT_MS ) ) ) { pr_err ( "pblk:<S2SV_blank>partial<S2SV_blank>read<S2SV_blank>I/O<S2SV_blank>timed<S2SV_blank>out\\n" ) ; } if ( new_rqd -> error ) { atomic_long_inc ( & pblk -> read_failed ) ; # ifdef CONFIG_NVM_DEBUG # endif } i = 0 ; hole = find_first_bit ( read_bitmap , nr_secs ) ; do { <S2SV_StartBug> unsigned int swidth = pblk -> rail . stride_width - 1 ; <S2SV_EndBug> int r ; dst_bv = bio -> bi_io_vec [ bio_init_idx + hole ] ; dst_p = kmap_atomic ( dst_bv . bv_page ) ; memset ( dst_p + dst_bv . bv_offset , 0 , PBLK_EXPOSED_PAGE_SIZE ) ; for ( r = 0 ; r < pvalid [ i ] ; r ++ ) { src_bv = new_bio -> bi_io_vec [ n_idx ++ ] ; src_p = kmap_atomic ( src_bv . bv_page ) ; pblk_rail_compute_parity ( dst_p + dst_bv . bv_offset , src_p + src_bv . bv_offset ) ; kunmap_atomic ( src_p ) ; mempool_free ( src_bv . bv_page , pblk -> page_pool ) ; } kunmap_atomic ( dst_p ) ; i ++ ; hole = find_next_zero_bit ( read_bitmap , nr_secs , hole + 1 ) ; } while ( hole < nr_orig_secs ) ; bio_put ( new_bio ) ; return NVM_IO_OK ; err_pages : pblk_bio_free_pages ( pblk , bio , 0 , new_bio -> bi_vcnt ) ; err : bio_put ( new_bio ) ; return NVM_IO_ERR ; } | <S2SV_ModStart> ; do { <S2SV_ModEnd> int r ; |
5,995 | CWE-000 void errors ( char * message ) { <S2SV_StartBug> fprintf ( stderr , message ) ; <S2SV_EndBug> exit ( 0 ) ; } | <S2SV_ModStart> ( stderr , "%s" , |
5,996 | CWE-000 static int FlushChannel ( Tcl_Interp * interp , Channel * chanPtr , int calledFromAsyncFlush ) { ChannelState * statePtr = chanPtr -> state ; ChannelBuffer * bufPtr ; int written ; int errorCode = 0 ; int wroteSome = 0 ; if ( CheckForDeadChannel ( interp , statePtr ) ) { return - 1 ; } bufPtr = statePtr -> curOutPtr ; if ( bufPtr && BytesLeft ( bufPtr ) && ( statePtr -> outQueueHead == NULL || IsBufferFull ( bufPtr ) ) ) { if ( statePtr -> outQueueHead == NULL ) { statePtr -> outQueueHead = bufPtr ; } else { statePtr -> outQueueTail -> nextPtr = bufPtr ; } statePtr -> outQueueTail = bufPtr ; statePtr -> curOutPtr = NULL ; } assert ( ! IsBufferFull ( statePtr -> curOutPtr ) ) ; if ( ! calledFromAsyncFlush && GotFlag ( statePtr , BG_FLUSH_SCHEDULED ) ) { return 0 ; } TclChannelPreserve ( ( Tcl_Channel ) chanPtr ) ; while ( statePtr -> outQueueHead ) { bufPtr = statePtr -> outQueueHead ; PreserveChannelBuffer ( bufPtr ) ; written = ChanWrite ( chanPtr , RemovePoint ( bufPtr ) , BytesLeft ( bufPtr ) , & errorCode ) ; if ( written < 0 ) { if ( errorCode == EINTR ) { errorCode = 0 ; ReleaseChannelBuffer ( bufPtr ) ; continue ; } if ( ( errorCode == EWOULDBLOCK ) || ( errorCode == EAGAIN ) ) { if ( ! GotFlag ( statePtr , BG_FLUSH_SCHEDULED ) && ! TclInExit ( ) ) { SetFlag ( statePtr , BG_FLUSH_SCHEDULED ) ; UpdateInterest ( chanPtr ) ; } errorCode = 0 ; ReleaseChannelBuffer ( bufPtr ) ; break ; } if ( calledFromAsyncFlush ) { Tcl_Obj * msg = statePtr -> chanMsg ; if ( statePtr -> unreportedError == 0 ) { statePtr -> unreportedError = errorCode ; statePtr -> unreportedMsg = msg ; if ( msg != NULL ) { Tcl_IncrRefCount ( msg ) ; } } else { statePtr -> chanMsg = NULL ; if ( msg != NULL ) { TclDecrRefCount ( msg ) ; } } } else { Tcl_SetErrno ( errorCode ) ; if ( interp != NULL && ! TclChanCaughtErrorBypass ( interp , ( Tcl_Channel ) chanPtr ) ) { Tcl_SetObjResult ( interp , Tcl_NewStringObj ( Tcl_PosixError ( interp ) , - 1 ) ) ; } } DiscardOutputQueued ( statePtr ) ; ReleaseChannelBuffer ( bufPtr ) ; break ; } else { wroteSome = 1 ; } bufPtr -> nextRemoved += written ; if ( IsBufferEmpty ( bufPtr ) ) { statePtr -> outQueueHead = bufPtr -> nextPtr ; if ( statePtr -> outQueueHead == NULL ) { statePtr -> outQueueTail = NULL ; } RecycleBuffer ( statePtr , bufPtr , 0 ) ; } ReleaseChannelBuffer ( bufPtr ) ; } if ( GotFlag ( statePtr , BG_FLUSH_SCHEDULED ) ) { if ( wroteSome ) { goto done ; } else if ( statePtr -> outQueueHead == NULL ) { ResetFlag ( statePtr , BG_FLUSH_SCHEDULED ) ; ChanWatch ( chanPtr , statePtr -> interestMask ) ; } else { <S2SV_StartBug> assert ( ! calledFromAsyncFlush ) ; <S2SV_EndBug> } } if ( GotFlag ( statePtr , CHANNEL_CLOSED ) && ( statePtr -> refCount <= 0 ) && ( statePtr -> outQueueHead == NULL ) && ( ( statePtr -> curOutPtr == NULL ) || IsBufferEmpty ( statePtr -> curOutPtr ) ) ) { errorCode = CloseChannel ( interp , chanPtr , errorCode ) ; goto done ; } if ( GotFlag ( statePtr , CHANNEL_CLOSEDWRITE ) && ( statePtr -> outQueueHead == NULL ) && ( ( statePtr -> curOutPtr == NULL ) || IsBufferEmpty ( statePtr -> curOutPtr ) ) ) { errorCode = CloseChannelPart ( interp , chanPtr , errorCode , TCL_CLOSE_WRITE ) ; goto done ; } done : TclChannelRelease ( ( Tcl_Channel ) chanPtr ) ; return errorCode ; } | <S2SV_ModStart> } else { <S2SV_ModEnd> } } if |
5,997 | CWE-000 static void * extract_worker_thread_func ( void * arg ) { xb_rstream_chunk_t chunk ; file_entry_t * entry ; xb_rstream_result_t res ; <S2SV_StartBug> extract_ctxt_t * ctxt = ( extract_ctxt_t * ) arg ; <S2SV_EndBug> while ( 1 ) { pthread_mutex_lock ( ctxt -> mutex ) ; res = xb_stream_read_chunk ( ctxt -> stream , & chunk ) ; if ( res != XB_STREAM_READ_CHUNK ) { pthread_mutex_unlock ( ctxt -> mutex ) ; break ; } if ( chunk . type == XB_CHUNK_TYPE_UNKNOWN && ! ( chunk . flags & XB_STREAM_FLAG_IGNORABLE ) ) { pthread_mutex_unlock ( ctxt -> mutex ) ; continue ; } entry = ( file_entry_t * ) my_hash_search ( ctxt -> filehash , ( uchar * ) chunk . path , chunk . pathlen ) ; if ( entry == NULL ) { entry = file_entry_new ( ctxt -> ds_ctxt , chunk . path , chunk . pathlen ) ; if ( entry == NULL ) { pthread_mutex_unlock ( ctxt -> mutex ) ; break ; } if ( my_hash_insert ( ctxt -> filehash , ( uchar * ) entry ) ) { msg ( "%s:<S2SV_blank>my_hash_insert()<S2SV_blank>failed.\\n" , my_progname ) ; pthread_mutex_unlock ( ctxt -> mutex ) ; break ; } } pthread_mutex_lock ( & entry -> mutex ) ; pthread_mutex_unlock ( ctxt -> mutex ) ; <S2SV_StartBug> if ( chunk . type == XB_CHUNK_TYPE_EOF ) { <S2SV_EndBug> my_hash_delete ( ctxt -> filehash , ( uchar * ) entry ) ; pthread_mutex_unlock ( & entry -> mutex ) ; continue ; } if ( entry -> offset != chunk . offset ) { msg ( "%s:<S2SV_blank>out-of-order<S2SV_blank>chunk:<S2SV_blank>real<S2SV_blank>offset<S2SV_blank>=<S2SV_blank>0x%llx,<S2SV_blank>" "expected<S2SV_blank>offset<S2SV_blank>=<S2SV_blank>0x%llx\\n" , my_progname , chunk . offset , entry -> offset ) ; pthread_mutex_unlock ( & entry -> mutex ) ; break ; } if ( ds_write ( entry -> file , chunk . data , chunk . length ) ) { msg ( "%s:<S2SV_blank>my_write()<S2SV_blank>failed.\\n" , my_progname ) ; pthread_mutex_unlock ( & entry -> mutex ) ; break ; } entry -> offset += chunk . length ; pthread_mutex_unlock ( & entry -> mutex ) ; } <S2SV_StartBug> return ( void * ) ( res ) ; <S2SV_EndBug> } | <S2SV_ModStart> * ) arg ; memset ( & chunk , 0 , sizeof ( chunk ) ) <S2SV_ModStart> mutex ) ; res = xb_stream_validate_checksum ( & chunk ) ; if ( res != XB_STREAM_READ_CHUNK ) { pthread_mutex_unlock ( & entry -> mutex ) ; break ; } <S2SV_ModStart> ) ; } my_free ( chunk . data ) ; |
5,998 | CWE-000 int src_hops_process ( src_hops_obj * obj ) { <S2SV_StartBug> int rtnValue ; <S2SV_EndBug> switch ( obj -> interface -> type ) { case interface_file : rtnValue = src_hops_process_interface_file ( obj ) ; break ; case interface_soundcard : rtnValue = src_hops_process_interface_soundcard ( obj ) ; break ; default : printf ( "Source<S2SV_blank>hops:<S2SV_blank>Invalid<S2SV_blank>interface<S2SV_blank>type.\\n" ) ; exit ( EXIT_FAILURE ) ; break ; } obj -> timeStamp ++ ; obj -> out -> timeStamp = obj -> timeStamp ; return rtnValue ; } | <S2SV_ModStart> int rtnValue ; switch ( obj -> format -> type ) { case format_binary_int08 : src_hops_process_format_binary_int08 ( obj ) ; break ; case format_binary_int16 : src_hops_process_format_binary_int16 ( obj ) ; break ; case format_binary_int24 : src_hops_process_format_binary_int24 ( obj ) ; break ; case format_binary_int32 : src_hops_process_format_binary_int32 ( obj ) ; break ; default : printf ( "Source<S2SV_blank>hops:<S2SV_blank>Invalid<S2SV_blank>format<S2SV_blank>type.\\n" ) ; exit ( EXIT_FAILURE ) ; break ; } |
5,999 | CWE-000 <S2SV_StartBug> UndoRecPtr <S2SV_EndBug> FetchLatestUndoPtrForXid ( UndoRecPtr urecptr , UnpackedUndoRecord * uur_start , UndoLogControl * log ) { UndoRecPtr next_urecptr , from_urecptr ; uint16 prevlen ; UndoLogOffset next_insert ; UnpackedUndoRecord * uur ; bool refetch = false ; uur = uur_start ; while ( true ) { if ( refetch ) { uur = UndoFetchRecord ( urecptr , InvalidBlockNumber , InvalidOffsetNumber , InvalidTransactionId , NULL , NULL ) ; refetch = false ; } next_urecptr = uur -> uur_next ; prevlen = UndoLogGetPrevLen ( log -> logno ) ; if ( uur -> uur_next == InvalidUndoRecPtr ) { next_insert = UndoLogGetNextInsertPtr ( log -> logno , uur -> uur_xid ) ; if ( ! UndoRecPtrIsValid ( next_insert ) ) { if ( uur != uur_start ) UndoRecordRelease ( uur ) ; refetch = true ; continue ; } from_urecptr = UndoGetPrevUndoRecptr ( next_insert , prevlen ) ; break ; } else if ( ( UndoRecPtrGetLogNo ( next_urecptr ) != log -> logno ) && UndoLogIsDiscarded ( next_urecptr ) ) { next_insert = UndoLogGetNextInsertPtr ( log -> logno , uur -> uur_xid ) ; Assert ( UndoRecPtrIsValid ( next_insert ) ) ; from_urecptr = UndoGetPrevUndoRecptr ( next_insert , prevlen ) ; break ; } else { UnpackedUndoRecord * next_uur ; next_uur = UndoFetchRecord ( next_urecptr , InvalidBlockNumber , InvalidOffsetNumber , InvalidTransactionId , NULL , NULL ) ; if ( UndoRecPtrGetLogNo ( next_urecptr ) == log -> logno ) { from_urecptr = UndoGetPrevUndoRecptr ( next_urecptr , next_uur -> uur_prevlen ) ; UndoRecordRelease ( next_uur ) ; break ; } else { <S2SV_StartBug> log = UndoLogGet ( UndoRecPtrGetLogNo ( next_urecptr ) ) ; <S2SV_EndBug> if ( uur != uur_start ) UndoRecordRelease ( uur ) ; uur = next_uur ; continue ; } UndoRecordRelease ( next_uur ) ; } } if ( uur != uur_start ) UndoRecordRelease ( uur ) ; return from_urecptr ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static <S2SV_ModStart> ( next_urecptr ) , false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.