Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
300 | CWE-000 static snd_pcm_sframes_t snd_pcm_dsnoop_mmap_commit ( snd_pcm_t * pcm , snd_pcm_uframes_t offset ATTRIBUTE_UNUSED , snd_pcm_uframes_t size ) { snd_pcm_direct_t * dsnoop = pcm -> private_data ; int err ; switch ( snd_pcm_state ( dsnoop -> spcm ) ) { case SND_PCM_STATE_XRUN : <S2SV_StartBug> return - EPIPE ; <S2SV_EndBug> case SND_PCM_STATE_SUSPENDED : return - ESTRPIPE ; default : break ; <S2SV_StartBug> } <S2SV_EndBug> if ( dsnoop -> state == SND_PCM_STATE_RUNNING ) { err = snd_pcm_dsnoop_sync_ptr ( pcm ) ; if ( err < 0 ) return err ; } snd_pcm_mmap_appl_forward ( pcm , size ) ; if ( snd_pcm_mmap_capture_avail ( pcm ) < pcm -> avail_min ) snd_pcm_direct_clear_timer_queue ( dsnoop ) ; return size ; } | <S2SV_ModStart> case SND_PCM_STATE_XRUN : if ( ( err = snd_pcm_direct_slave_recover ( dsnoop ) ) < 0 ) return err ; break <S2SV_ModEnd> ; case SND_PCM_STATE_SUSPENDED <S2SV_ModStart> break ; } if ( snd_pcm_direct_client_chk_xrun ( dsnoop , pcm ) ) return - EPIPE ; |
301 | CWE-000 <S2SV_StartBug> dictEntry * * dictFindEntryRefByPtrAndHash ( dict * d , const void * oldptr , unsigned int hash ) { <S2SV_EndBug> dictEntry * he , * * heref ; unsigned long idx , table ; if ( d -> ht [ 0 ] . used + d -> ht [ 1 ] . used == 0 ) return NULL ; for ( table = 0 ; table <= 1 ; table ++ ) { idx = hash & d -> ht [ table ] . sizemask ; heref = & d -> ht [ table ] . table [ idx ] ; he = * heref ; while ( he ) { if ( oldptr == he -> key ) return heref ; heref = & he -> next ; he = * heref ; } if ( ! dictIsRehashing ( d ) ) return NULL ; } return NULL ; } | <S2SV_ModStart> * oldptr , uint64_t <S2SV_ModEnd> hash ) { |
302 | CWE-000 PyObject * bitprim_native_chain_fetch_spend_hash_index ( PyObject * self , PyObject * args ) { <S2SV_StartBug> PyObject * py_exec ; <S2SV_EndBug> char * py_hash ; size_t py_size ; uint32_t py_index ; PyObject * py_callback ; # if PY_MAJOR_VERSION >= 3 <S2SV_StartBug> if ( ! PyArg_ParseTuple ( args , "y*LOO" , & py_hash , & py_size , & py_index , & py_exec , & py_callback ) ) { <S2SV_EndBug> return NULL ; } # else <S2SV_StartBug> if ( ! PyArg_ParseTuple ( args , "s#LOO" , & py_hash , & py_size , & py_index , & py_exec , & py_callback ) ) { <S2SV_EndBug> return NULL ; } # endif hash_t hash ; memcpy ( hash . hash , py_hash , 32 ) ; if ( ! PyCallable_Check ( py_callback ) ) { PyErr_SetString ( PyExc_TypeError , "parameter<S2SV_blank>must<S2SV_blank>be<S2SV_blank>callable" ) ; return NULL ; } <S2SV_StartBug> executor_t exec = cast_executor ( py_exec ) ; <S2SV_EndBug> output_point_t p = output_point_construct_from_hash_index ( hash , py_index ) ; Py_XINCREF ( py_callback ) ; <S2SV_StartBug> chain_fetch_spend ( exec , py_callback , p , chain_fetch_spend_handler ) ; <S2SV_EndBug> Py_RETURN_NONE ; } | <S2SV_ModStart> { PyObject * py_chain <S2SV_ModEnd> ; char * <S2SV_ModStart> ( args , "y#IOO" <S2SV_ModEnd> , & py_hash <S2SV_ModStart> py_index , & py_chain <S2SV_ModEnd> , & py_callback <S2SV_ModStart> ( args , "s#IOO" <S2SV_ModEnd> , & py_hash <S2SV_ModStart> py_index , & py_chain <S2SV_ModEnd> , & py_callback <S2SV_ModStart> NULL ; } chain_t chain = ( chain_t ) get_ptr ( py_chain <S2SV_ModEnd> ) ; output_point_t <S2SV_ModStart> ; chain_fetch_spend ( chain <S2SV_ModEnd> , py_callback , |
303 | CWE-000 GC_INNER void GC_notify_or_invoke_finalizers ( void ) { GC_finalizer_notifier_proc notifier_fn = 0 ; # if defined ( KEEP_BACK_PTRS ) || defined ( MAKE_BACK_GRAPH ) static word last_back_trace_gc_no = 1 ; # endif DCL_LOCK_STATE ; # if defined ( THREADS ) && ! defined ( KEEP_BACK_PTRS ) && ! defined ( MAKE_BACK_GRAPH ) if ( GC_finalize_now == 0 ) return ; # endif LOCK ( ) ; # if defined ( KEEP_BACK_PTRS ) || defined ( MAKE_BACK_GRAPH ) if ( GC_gc_no > last_back_trace_gc_no ) { # ifdef KEEP_BACK_PTRS long i ; last_back_trace_gc_no = ( word ) ( - 1 ) ; for ( i = 0 ; i < GC_backtraces ; ++ i ) { UNLOCK ( ) ; GC_generate_random_backtrace_no_gc ( ) ; LOCK ( ) ; } last_back_trace_gc_no = GC_gc_no ; # endif # ifdef MAKE_BACK_GRAPH if ( GC_print_back_height ) { <S2SV_StartBug> UNLOCK ( ) ; <S2SV_EndBug> GC_print_back_graph_stats ( ) ; LOCK ( ) ; } # endif } # endif if ( GC_finalize_now == 0 ) { UNLOCK ( ) ; return ; } if ( ! GC_finalize_on_demand ) { unsigned char * pnested = GC_check_finalizer_nested ( ) ; UNLOCK ( ) ; if ( pnested != NULL ) { ( void ) GC_invoke_finalizers ( ) ; * pnested = 0 ; # ifndef THREADS GC_ASSERT ( GC_finalize_now == 0 ) ; # endif } return ; } if ( last_finalizer_notification != GC_gc_no ) { last_finalizer_notification = GC_gc_no ; notifier_fn = GC_finalizer_notifier ; } UNLOCK ( ) ; if ( notifier_fn != 0 ) ( * notifier_fn ) ( ) ; } | <S2SV_ModStart> GC_print_back_height ) { GC_print_back_graph_stats <S2SV_ModEnd> ( ) ; |
304 | CWE-000 <S2SV_StartBug> SQLITE_API int SQLITE_STDCALL sqlite3_reset ( sqlite3_stmt * pStmt ) { <S2SV_EndBug> int rc ; if ( pStmt == 0 ) { rc = SQLITE_OK ; } else { Vdbe * v = ( Vdbe * ) pStmt ; <S2SV_StartBug> sqlite3_mutex_enter ( v -> db -> mutex ) ; <S2SV_EndBug> rc = sqlite3VdbeReset ( v ) ; sqlite3VdbeRewind ( v ) ; <S2SV_StartBug> assert ( ( rc & ( v -> db -> errMask ) ) == rc ) ; <S2SV_EndBug> <S2SV_StartBug> rc = sqlite3ApiExit ( v -> db , rc ) ; <S2SV_EndBug> <S2SV_StartBug> sqlite3_mutex_leave ( v -> db -> mutex ) ; <S2SV_EndBug> } return rc ; } | <S2SV_ModStart> <S2SV_null> SQLITE_API int <S2SV_ModEnd> sqlite3_reset ( sqlite3_stmt <S2SV_ModStart> ) pStmt ; sqlite3 * db = <S2SV_ModEnd> v -> db <S2SV_ModStart> v -> db ; sqlite3_mutex_enter ( db -> mutex ) ; checkProfileCallback ( db , v <S2SV_ModEnd> ) ; rc <S2SV_ModStart> rc & ( <S2SV_ModEnd> db -> errMask <S2SV_ModStart> = sqlite3ApiExit ( <S2SV_ModEnd> db , rc <S2SV_ModStart> ; sqlite3_mutex_leave ( <S2SV_ModEnd> db -> mutex |
305 | CWE-000 static svn_error_t * get_dir_contents ( apr_uint32_t dirent_fields , const char * dir , svn_revnum_t rev , svn_ra_session_t * ra_session , apr_hash_t * locks , const char * fs_path , <S2SV_StartBug> apr_array_header_t * patterns , <S2SV_EndBug> svn_depth_t depth , svn_client_ctx_t * ctx , apr_hash_t * externals , const char * external_parent_url , const char * external_target , svn_client_list_func2_t list_func , void * baton , apr_pool_t * result_pool , apr_pool_t * scratch_pool ) { apr_hash_t * tmpdirents ; apr_pool_t * iterpool = svn_pool_create ( scratch_pool ) ; apr_array_header_t * array ; svn_error_t * err ; apr_hash_t * prop_hash = NULL ; const svn_string_t * prop_val = NULL ; int i ; if ( depth == svn_depth_empty ) return SVN_NO_ERROR ; err = svn_ra_get_dir2 ( ra_session , & tmpdirents , NULL , externals ? & prop_hash : NULL , dir , rev , dirent_fields , scratch_pool ) ; if ( err && ( ( err -> apr_err == SVN_ERR_RA_NOT_AUTHORIZED ) || ( err -> apr_err == SVN_ERR_RA_DAV_FORBIDDEN ) ) ) { svn_error_clear ( err ) ; return SVN_NO_ERROR ; } SVN_ERR ( err ) ; if ( locks && apr_hash_count ( locks ) == 0 ) locks = NULL ; if ( prop_hash ) prop_val = svn_hash_gets ( prop_hash , SVN_PROP_EXTERNALS ) ; if ( prop_val ) { const char * url ; SVN_ERR ( svn_ra_get_session_url ( ra_session , & url , scratch_pool ) ) ; svn_hash_sets ( externals , svn_path_url_add_component2 ( url , dir , result_pool ) , svn_string_dup ( prop_val , result_pool ) ) ; } if ( ctx -> cancel_func ) SVN_ERR ( ctx -> cancel_func ( ctx -> cancel_baton ) ) ; array = svn_sort__hash ( tmpdirents , svn_sort_compare_items_lexically , scratch_pool ) ; for ( i = 0 ; i < array -> nelts ; ++ i ) { svn_sort__item_t * item = & APR_ARRAY_IDX ( array , i , svn_sort__item_t ) ; const char * path ; svn_dirent_t * the_ent = item -> value ; svn_lock_t * lock ; svn_pool_clear ( iterpool ) ; path = svn_relpath_join ( dir , item -> key , iterpool ) ; if ( locks ) { const char * abs_path = svn_fspath__join ( fs_path , path , iterpool ) ; lock = svn_hash_gets ( locks , abs_path ) ; } else lock = NULL ; if ( the_ent -> kind == svn_node_file || depth == svn_depth_immediates || depth == svn_depth_infinity ) if ( match_patterns ( item -> key , patterns ) ) SVN_ERR ( list_func ( baton , path , the_ent , lock , fs_path , external_parent_url , external_target , iterpool ) ) ; if ( depth == svn_depth_infinity && the_ent -> kind == svn_node_dir ) SVN_ERR ( get_dir_contents ( dirent_fields , path , rev , ra_session , locks , fs_path , patterns , depth , ctx , externals , external_parent_url , external_target , list_func , baton , result_pool , iterpool ) ) ; } svn_pool_destroy ( iterpool ) ; return SVN_NO_ERROR ; } | <S2SV_ModStart> * fs_path , const |
306 | CWE-000 static bool hclge_is_rx_buf_ok ( struct hclge_dev * hdev , struct hclge_pkt_buf_alloc * buf_alloc , u32 rx_all ) { u32 shared_buf_min , shared_buf_tc , shared_std ; int tc_num , pfc_enable_num ; u32 shared_buf , aligned_mps ; u32 rx_priv ; int i ; tc_num = hclge_get_tc_num ( hdev ) ; pfc_enable_num = hclge_get_pfc_enalbe_num ( hdev ) ; aligned_mps = roundup ( hdev -> mps , HCLGE_BUF_SIZE_UNIT ) ; if ( hnae3_dev_dcb_supported ( hdev ) ) shared_buf_min = 2 * aligned_mps + hdev -> dv_buf_size ; else shared_buf_min = aligned_mps + HCLGE_NON_DCB_ADDITIONAL_BUF + hdev -> dv_buf_size ; shared_buf_tc = pfc_enable_num * aligned_mps + ( tc_num - pfc_enable_num ) * aligned_mps / 2 + aligned_mps ; <S2SV_StartBug> shared_std = max_t ( u32 , shared_buf_min , shared_buf_tc ) ; <S2SV_EndBug> rx_priv = hclge_get_rx_priv_buff_alloced ( buf_alloc ) ; <S2SV_StartBug> if ( rx_all <= rx_priv + shared_std ) <S2SV_EndBug> return false ; shared_buf = rounddown ( rx_all - rx_priv , HCLGE_BUF_SIZE_UNIT ) ; buf_alloc -> s_buf . buf_size = shared_buf ; if ( hnae3_dev_dcb_supported ( hdev ) ) { buf_alloc -> s_buf . self . high = shared_buf - hdev -> dv_buf_size ; buf_alloc -> s_buf . self . low = buf_alloc -> s_buf . self . high - roundup ( aligned_mps / 2 , HCLGE_BUF_SIZE_UNIT ) ; } else { buf_alloc -> s_buf . self . high = aligned_mps + HCLGE_NON_DCB_ADDITIONAL_BUF ; buf_alloc -> s_buf . self . low = roundup ( aligned_mps / 2 , HCLGE_BUF_SIZE_UNIT ) ; } for ( i = 0 ; i < HCLGE_MAX_TC_NUM ; i ++ ) { if ( ( hdev -> hw_tc_map & BIT ( i ) ) && ( hdev -> tm_info . hw_pfc_map & BIT ( i ) ) ) { buf_alloc -> s_buf . tc_thrd [ i ] . low = aligned_mps ; buf_alloc -> s_buf . tc_thrd [ i ] . high = 2 * aligned_mps ; } else { buf_alloc -> s_buf . tc_thrd [ i ] . low = 0 ; buf_alloc -> s_buf . tc_thrd [ i ] . high = aligned_mps ; } } return true ; } | <S2SV_ModStart> ; shared_std = roundup ( <S2SV_ModStart> , shared_buf_tc ) , HCLGE_BUF_SIZE_UNIT ) <S2SV_ModStart> if ( rx_all < <S2SV_ModEnd> rx_priv + shared_std |
307 | CWE-000 static struct request * initialize_request ( const struct url * u , struct http_stat * hs , int * dt , struct url * proxy , bool inhibit_keep_alive , bool * basic_auth_finished , wgint * body_data_size , char * * user , char * * passwd , uerr_t * ret ) { bool head_only = ! ! ( * dt & HEAD_ONLY ) ; struct request * req ; { char * meth_arg ; const char * meth = "GET" ; if ( head_only ) meth = "HEAD" ; else if ( opt . method ) meth = opt . method ; if ( proxy # ifdef HAVE_SSL && u -> scheme != SCHEME_HTTPS # endif ) meth_arg = xstrdup ( u -> url ) ; else meth_arg = url_full_path ( u ) ; req = request_new ( meth , meth_arg ) ; } request_set_header ( req , "Referer" , ( char * ) hs -> referer , rel_none ) ; if ( * dt & SEND_NOCACHE ) { request_set_header ( req , "Cache-Control" , "no-cache,<S2SV_blank>must-revalidate" , rel_none ) ; request_set_header ( req , "Pragma" , "no-cache" , rel_none ) ; } if ( * dt & IF_MODIFIED_SINCE ) { char strtime [ 32 ] ; uerr_t err = time_to_rfc1123 ( hs -> orig_file_tstamp , strtime , countof ( strtime ) ) ; if ( err != RETROK ) { logputs ( LOG_VERBOSE , _ ( "Cannot<S2SV_blank>convert<S2SV_blank>timestamp<S2SV_blank>to<S2SV_blank>http<S2SV_blank>format.<S2SV_blank>" "Falling<S2SV_blank>back<S2SV_blank>to<S2SV_blank>time<S2SV_blank>0<S2SV_blank>as<S2SV_blank>last<S2SV_blank>modification<S2SV_blank>" "time.\\n" ) ) ; strcpy ( strtime , "Thu,<S2SV_blank>01<S2SV_blank>Jan<S2SV_blank>1970<S2SV_blank>00:00:00<S2SV_blank>GMT" ) ; } request_set_header ( req , "If-Modified-Since" , xstrdup ( strtime ) , rel_value ) ; } if ( hs -> restval ) request_set_header ( req , "Range" , aprintf ( "bytes=%s-" , number_to_static_string ( hs -> restval ) ) , rel_value ) ; SET_USER_AGENT ( req ) ; request_set_header ( req , "Accept" , "*/*" , rel_none ) ; request_set_header ( req , "Accept-Encoding" , "identity" , rel_none ) ; if ( u -> user ) * user = u -> user ; else if ( opt . user && ( opt . use_askpass || opt . ask_passwd ) ) * user = opt . user ; else if ( opt . http_user ) * user = opt . http_user ; else if ( opt . user ) * user = opt . user ; else * user = NULL ; if ( u -> passwd ) * passwd = u -> passwd ; else if ( opt . passwd && ( opt . use_askpass || opt . ask_passwd ) ) * passwd = opt . passwd ; else if ( opt . http_passwd ) * passwd = opt . http_passwd ; else if ( opt . passwd ) * passwd = opt . passwd ; else * passwd = NULL ; <S2SV_StartBug> if ( opt . netrc && ( ! user || ( ! passwd || ! * passwd ) ) ) <S2SV_EndBug> search_netrc ( u -> host , ( const char * * ) user , ( const char * * ) passwd , 0 ) ; if ( * user && * passwd && ( ! u -> user || opt . auth_without_challenge ) ) { * basic_auth_finished = maybe_send_basic_creds ( u -> host , * user , * passwd , req ) ; } { static const char * hfmt [ ] [ 2 ] = { { "%s" , "[%s]" } , { "%s:%d" , "[%s]:%d" } } ; int add_port = u -> port != scheme_default_port ( u -> scheme ) ; int add_squares = strchr ( u -> host , ':' ) != NULL ; request_set_header ( req , "Host" , aprintf ( hfmt [ add_port ] [ add_squares ] , u -> host , u -> port ) , rel_value ) ; } if ( inhibit_keep_alive ) request_set_header ( req , "Connection" , "Close" , rel_none ) ; else { request_set_header ( req , "Connection" , "Keep-Alive" , rel_none ) ; if ( proxy ) request_set_header ( req , "Proxy-Connection" , "Keep-Alive" , rel_none ) ; } if ( opt . method ) { if ( opt . body_data || opt . body_file ) { request_set_header ( req , "Content-Type" , "application/x-www-form-urlencoded" , rel_none ) ; if ( opt . body_data ) * body_data_size = strlen ( opt . body_data ) ; else { * body_data_size = file_size ( opt . body_file ) ; if ( * body_data_size == - 1 ) { logprintf ( LOG_NOTQUIET , _ ( "BODY<S2SV_blank>data<S2SV_blank>file<S2SV_blank>%s<S2SV_blank>missing:<S2SV_blank>%s\\n" ) , quote ( opt . body_file ) , strerror ( errno ) ) ; request_free ( & req ) ; * ret = FILEBADFILE ; return NULL ; } } request_set_header ( req , "Content-Length" , xstrdup ( number_to_static_string ( * body_data_size ) ) , rel_value ) ; } else if ( c_strcasecmp ( opt . method , "post" ) == 0 || c_strcasecmp ( opt . method , "put" ) == 0 || c_strcasecmp ( opt . method , "patch" ) == 0 ) request_set_header ( req , "Content-Length" , "0" , rel_none ) ; } return req ; } | <S2SV_ModStart> && ( ! * user <S2SV_ModEnd> || ! * <S2SV_ModStart> ! * passwd <S2SV_ModEnd> ) ) search_netrc |
308 | CWE-000 static void checkfile ( char * f1 , char * f2 ) { char buf1 [ 10240 ] , buf2 [ 10240 ] ; int line = 0 ; FILE * i1 , * i2 ; i1 = fopen ( f1 , "r" ) ; if ( ! i1 ) fatal_exit ( "cannot<S2SV_blank>open<S2SV_blank>%s:<S2SV_blank>%s" , f1 , strerror ( errno ) ) ; i2 = fopen ( f2 , "r" ) ; if ( ! i2 ) fatal_exit ( "cannot<S2SV_blank>open<S2SV_blank>%s:<S2SV_blank>%s" , f2 , strerror ( errno ) ) ; while ( ! feof ( i1 ) && ! feof ( i2 ) ) { char * cp1 , * cp2 ; line ++ ; cp1 = fgets ( buf1 , ( int ) sizeof ( buf1 ) , i1 ) ; cp2 = fgets ( buf2 , ( int ) sizeof ( buf2 ) , i2 ) ; if ( ( ! cp1 && ! feof ( i1 ) ) || ( ! cp2 && ! feof ( i2 ) ) ) fatal_exit ( "fgets<S2SV_blank>failed:<S2SV_blank>%s" , strerror ( errno ) ) ; if ( strcmp ( buf1 , buf2 ) != 0 ) { log_info ( "in<S2SV_blank>files<S2SV_blank>%s<S2SV_blank>and<S2SV_blank>%s:%d" , f1 , f2 , line ) ; log_info ( "\'%s\'" , buf1 ) ; log_info ( "\'%s\'" , buf2 ) ; <S2SV_StartBug> fatal_exit ( "files<S2SV_blank>are<S2SV_blank>not<S2SV_blank>eqaul" ) ; <S2SV_EndBug> } } unit_assert ( feof ( i1 ) && feof ( i2 ) ) ; fclose ( i1 ) ; fclose ( i2 ) ; } | <S2SV_ModStart> ; fatal_exit ( "files<S2SV_blank>are<S2SV_blank>not<S2SV_blank>equal" <S2SV_ModEnd> ) ; } |
309 | CWE-000 bool file_open ( FIL * file_handle , const char * filename , const char mode ) { <S2SV_StartBug> FRESULT err ; <S2SV_EndBug> BYTE flags ; <S2SV_StartBug> if ( ! fs_ready && ( err = mount ( ) ) ) { <S2SV_EndBug> return FALSE ; } switch ( mode ) { case 'r' : flags = FA_READ | FA_OPEN_EXISTING ; break ; case 'w' : flags = FA_WRITE | FA_OPEN_ALWAYS ; break ; case 'a' : flags = FA_WRITE | FA_OPEN_EXISTING ; break ; } if ( f_open ( file_handle , ( TCHAR * ) filename , flags ) != FR_OK ) { return FALSE ; } return TRUE ; } | <S2SV_ModStart> mode ) { <S2SV_ModEnd> BYTE flags ; <S2SV_ModStart> fs_ready && ( <S2SV_ModEnd> mount ( ) <S2SV_ModStart> mount ( ) != 0 |
310 | CWE-000 uint32_t process_create ( int argc , char * * argv ) { process_t * proc = ( process_t * ) kmalloc ( sizeof ( process_t ) ) ; if ( proc ) { <S2SV_StartBug> printk ( "Process<S2SV_blank>PID<S2SV_blank>%d<S2SV_blank>at<S2SV_blank>%x\\n" , num_proc , proc ) ; <S2SV_EndBug> <S2SV_StartBug> proc -> pagedir = vmm2_create_directory ( ) ; <S2SV_EndBug> printk ( "Creating<S2SV_blank>pagedir<S2SV_blank>%x\\n" , proc -> pagedir ) ; proc -> pid = num_proc ; proc -> parent = process_get_current ( ) ; proc -> mailbox = mailbox_create ( ) ; proc -> heapend_addr = PROCESS_MEM_START ; if ( num_proc > 0 ) { process_t * prev = _processes [ num_proc - 1 ] ; proc -> next = _processes [ 0 ] ; prev -> next = proc ; } else { proc -> next = proc ; } _processes [ num_proc ++ ] = proc ; uint32_t ustackAddr = 0xBFFFC000 ; vmm2_map_todir ( ustackAddr , 1 , VMM2_PAGE_USER | VMM2_PAGE_WRITABLE , proc -> pagedir ) ; ustackAddr += ( VMM2_BLOCK_SIZE - sizeof ( unsigned int ) ) ; uint32_t kstackAddr = ( uint32_t ) kmalloc ( KERNEL_STACK_SIZE ) + ( KERNEL_STACK_SIZE - sizeof ( uint32_t ) ) ; proc -> thread . user_stack_ptr = ustackAddr ; proc -> thread . kernel_stack_ptr = kstackAddr ; proc -> thread . instr_ptr = ( uint32_t ) process_init ; proc -> thread . priority = 1 ; proc -> thread . state = PROCESS_RUNNING ; proc -> regs . eax = 0 ; proc -> regs . ebx = 0 ; proc -> regs . ecx = 0 ; proc -> regs . edx = 0 ; proc -> regs . esi = 0 ; proc -> regs . edi = 0 ; proc -> regs . eip = proc -> thread . instr_ptr ; proc -> regs . cr3 = ( unsigned int ) proc -> pagedir -> tables ; proc -> regs . esp = proc -> thread . kernel_stack_ptr ; proc -> regs . eflags = _current_process -> regs . eflags ; proc -> argc = argc ; proc -> argv = 0 ; if ( argc > 0 ) { proc -> argv = ( char * * ) kmalloc ( sizeof ( char * ) * argc ) ; for ( int i = 0 ; i < argc ; i ++ ) { proc -> argv [ i ] = ( char * ) kmalloc ( ( sizeof ( char ) * strlen ( argv [ i ] ) ) + 1 ) ; strcpy ( proc -> argv [ i ] , argv [ i ] ) ; } } return proc -> pid ; } else { return - 1 ; } } | <S2SV_ModStart> proc ) { <S2SV_ModEnd> proc -> pagedir <S2SV_ModStart> = vmm2_create_directory ( <S2SV_ModEnd> ) ; proc |
311 | CWE-000 <S2SV_StartBug> void rtc_set_hour_mode ( uint32_t mode ) <S2SV_EndBug> { <S2SV_StartBug> assert ( ( mode & 0xFFFFFFFE ) == 0 ) ; <S2SV_EndBug> <S2SV_StartBug> RTC -> RTC_MR = mode ; <S2SV_EndBug> } | <S2SV_ModStart> void rtc_set_hour_mode ( enum _rtc_hour_mode <S2SV_ModEnd> mode ) { <S2SV_ModStart> mode ) { RTC -> RTC_MR &= ~ RTC_MR_HRMOD ; switch ( mode ) { case RTC_HOUR_MODE_12 : <S2SV_ModEnd> RTC -> RTC_MR <S2SV_ModStart> RTC -> RTC_MR |= RTC_MR_HRMOD ; break ; case RTC_HOUR_MODE_24 : break ; } } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
312 | CWE-000 tid_t lwp_create ( lwpfun function , void * argument , size_t stackSize ) { void * stack = NULL ; thread newThread ; <S2SV_StartBug> GLOBAL_SCHEDULAR = set_init_schedular_RR ( ) ; <S2SV_EndBug> createQueue ( GLOBAL_THREAD_QUEUE ) ; if ( ( stack = malloc ( stackSize * __WORDSIZE ) ) == NULL ) { perror ( "lwp_create" ) ; exit ( EXIT_FAILURE ) ; } uintptr_t sp = stack ; sp += stackSize * __WORDSIZE ; uintptr_t bsp = sp ; stack [ sp ] = argument ; sp += sizeof ( void * ) ; stack [ sp ] = function ; if ( newThread = malloc ( sizeof ( struct threadinfo_st ) ) == NULL ) { perror ( "lwp_create" ) ; exit ( EXIT_FAILURE ) ; } newThread -> tid = nexttid ; nexttid ++ ; newThread -> stack = bsp ; newThread -> stacksize = stackSize ; admit ( newThread ) ; return newThread -> tid ; } | <S2SV_ModStart> thread newThread ; GLOBAL_SCHEDULER = set_init_scheduler_RR <S2SV_ModEnd> ( ) ; |
313 | CWE-000 static gboolean gs_plugin_loader_is_error_fatal ( GsPluginFailureFlags failure_flags , const GError * err ) { if ( failure_flags & GS_PLUGIN_FAILURE_FLAGS_FATAL_ANY ) return TRUE ; if ( failure_flags & GS_PLUGIN_FAILURE_FLAGS_FATAL_AUTH ) { if ( g_error_matches ( err , GS_PLUGIN_ERROR , GS_PLUGIN_ERROR_AUTH_REQUIRED ) ) return TRUE ; if ( g_error_matches ( err , GS_PLUGIN_ERROR , GS_PLUGIN_ERROR_AUTH_INVALID ) ) return TRUE ; } <S2SV_StartBug> return FALSE ; <S2SV_EndBug> } | <S2SV_ModStart> TRUE ; } if ( g_error_matches ( err , GS_PLUGIN_ERROR , GS_PLUGIN_ERROR_TIMED_OUT ) ) return TRUE ; |
314 | CWE-000 static ssize_t core_info_read ( struct file * file , char __user * buf , size_t count , loff_t * ppos ) { struct msm_vidc_core * core = file -> private_data ; struct hfi_device * hdev ; struct hal_fw_info fw_info ; int i = 0 , rc = 0 ; <S2SV_StartBug> if ( ! core || ! core -> device ) { <S2SV_EndBug> dprintk ( VIDC_ERR , "Invalid<S2SV_blank>params,<S2SV_blank>core:<S2SV_blank>%p\\n" , core ) ; return 0 ; <S2SV_StartBug> } <S2SV_EndBug> hdev = core -> device ; INIT_DBG_BUF ( dbg_buf ) ; write_str ( & dbg_buf , "===============================\\n" ) ; write_str ( & dbg_buf , "CORE<S2SV_blank>%d:<S2SV_blank>0x%p\\n" , core -> id , core ) ; write_str ( & dbg_buf , "===============================\\n" ) ; write_str ( & dbg_buf , "Core<S2SV_blank>state:<S2SV_blank>%d\\n" , core -> state ) ; rc = call_hfi_op ( hdev , get_fw_info , hdev -> hfi_device_data , & fw_info ) ; if ( rc ) { dprintk ( VIDC_WARN , "Failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>FW<S2SV_blank>info\\n" ) ; goto err_fw_info ; } write_str ( & dbg_buf , "FW<S2SV_blank>version<S2SV_blank>:<S2SV_blank>%s\\n" , & fw_info . version ) ; write_str ( & dbg_buf , "base<S2SV_blank>addr:<S2SV_blank>0x%x\\n" , fw_info . base_addr ) ; write_str ( & dbg_buf , "register_base:<S2SV_blank>0x%x\\n" , fw_info . register_base ) ; write_str ( & dbg_buf , "register_size:<S2SV_blank>%u\\n" , fw_info . register_size ) ; write_str ( & dbg_buf , "irq:<S2SV_blank>%u\\n" , fw_info . irq ) ; write_str ( & dbg_buf , "clock<S2SV_blank>count:<S2SV_blank>%d\\n" , call_hfi_op ( hdev , get_info , hdev -> hfi_device_data , DEV_CLOCK_COUNT ) ) ; write_str ( & dbg_buf , "clock<S2SV_blank>enabled:<S2SV_blank>%u\\n" , call_hfi_op ( hdev , get_info , hdev -> hfi_device_data , DEV_CLOCK_ENABLED ) ) ; write_str ( & dbg_buf , "power<S2SV_blank>count:<S2SV_blank>%d\\n" , call_hfi_op ( hdev , get_info , hdev -> hfi_device_data , DEV_PWR_COUNT ) ) ; write_str ( & dbg_buf , "power<S2SV_blank>enabled:<S2SV_blank>%u\\n" , call_hfi_op ( hdev , get_info , hdev -> hfi_device_data , DEV_PWR_ENABLED ) ) ; err_fw_info : for ( i = SYS_MSG_START ; i < SYS_MSG_END ; i ++ ) { write_str ( & dbg_buf , "completions[%d]:<S2SV_blank>%s\\n" , i , completion_done ( & core -> completions [ SYS_MSG_INDEX ( i ) ] ) ? "pending" : "done" ) ; } <S2SV_StartBug> return simple_read_from_buffer ( buf , count , ppos , <S2SV_EndBug> dbg_buf . ptr , dbg_buf . filled_size ) ; } | <S2SV_ModStart> = 0 ; ssize_t len = 0 ; <S2SV_ModStart> 0 ; } mutex_lock ( & dbg_buf . lock ) ; <S2SV_ModStart> ) ; } len = simple_read_from_buffer ( buf , count , ppos , dbg_buf . ptr , dbg_buf . filled_size ) ; mutex_unlock ( & dbg_buf . lock ) ; return len <S2SV_ModEnd> ; } <S2SV_null> |
315 | CWE-000 const struct mailbox_info * mailbox_list_iter_next ( struct mailbox_list_iterate_context * ctx ) { const struct mailbox_info * info ; if ( ctx == & mailbox_list_iter_failed ) return NULL ; do { T_BEGIN { <S2SV_StartBug> if ( ctx -> autocreate_ctx != NULL ) <S2SV_EndBug> info = autocreate_iter_next ( ctx ) ; else info = mailbox_list_iter_next_call ( ctx ) ; } T_END ; } while ( info != NULL && ! special_use_selection ( ctx , info ) ) ; return info ; } | <S2SV_ModStart> { T_BEGIN { <S2SV_ModEnd> info = mailbox_list_iter_next_call |
316 | CWE-000 struct request_queue * blk_init_queue_node ( request_fn_proc * rfn , spinlock_t * lock , int node_id ) { struct request_queue * uninit_q , * q ; uninit_q = blk_alloc_queue_node ( GFP_KERNEL , node_id ) ; if ( ! uninit_q ) return NULL ; <S2SV_StartBug> q = blk_init_allocated_queue_node ( uninit_q , rfn , lock , node_id ) ; <S2SV_EndBug> if ( ! q ) blk_cleanup_queue ( uninit_q ) ; return q ; } | <S2SV_ModStart> ; q = blk_init_allocated_queue <S2SV_ModEnd> ( uninit_q , <S2SV_ModStart> rfn , lock <S2SV_ModEnd> ) ; if |
317 | CWE-000 static int taskq_seq_show_impl ( struct seq_file * f , void * p , boolean_t allflag ) { taskq_t * tq = p ; taskq_thread_t * tqt ; wait_queue_t * wq ; struct task_struct * tsk ; taskq_ent_t * tqe ; char name [ 100 ] ; struct list_head * lheads [ LHEAD_SIZE ] , * lh ; static char * list_names [ LHEAD_SIZE ] = { "pend" , "prio" , "delay" , "wait" , "active" } ; int i , j , have_lheads = 0 ; unsigned long wflags , flags ; spin_lock_irqsave_nested ( & tq -> tq_lock , flags , tq -> tq_lock_class ) ; spin_lock_irqsave ( & tq -> tq_wait_waitq . lock , wflags ) ; lheads [ LHEAD_PEND ] = & tq -> tq_pend_list ; lheads [ LHEAD_PRIO ] = & tq -> tq_prio_list ; lheads [ LHEAD_DELAY ] = & tq -> tq_delay_list ; lheads [ LHEAD_WAIT ] = & tq -> tq_wait_waitq . task_list ; lheads [ LHEAD_ACTIVE ] = & tq -> tq_active_list ; for ( i = 0 ; i < LHEAD_SIZE ; ++ i ) { if ( list_empty ( lheads [ i ] ) ) lheads [ i ] = NULL ; else ++ have_lheads ; } if ( ! allflag && ! have_lheads ) { spin_unlock_irqrestore ( & tq -> tq_wait_waitq . lock , wflags ) ; spin_unlock_irqrestore ( & tq -> tq_lock , flags ) ; return ( 0 ) ; } if ( ! lheads [ LHEAD_WAIT ] ) spin_unlock_irqrestore ( & tq -> tq_wait_waitq . lock , wflags ) ; snprintf ( name , sizeof ( name ) , "%s/%d" , tq -> tq_name , tq -> tq_instance ) ; seq_printf ( f , "%-25s<S2SV_blank>" , name ) ; seq_printf ( f , "%5d<S2SV_blank>%5d<S2SV_blank>%5d<S2SV_blank>%5d<S2SV_blank>%5d<S2SV_blank>%5d<S2SV_blank>%12d<S2SV_blank>%5d<S2SV_blank>%10x\\n" , tq -> tq_nactive , tq -> tq_nthreads , tq -> tq_nspawn , tq -> tq_maxthreads , tq -> tq_pri , tq -> tq_minalloc , tq -> tq_maxalloc , tq -> tq_nalloc , tq -> tq_flags ) ; if ( lheads [ LHEAD_ACTIVE ] ) { j = 0 ; list_for_each_entry ( tqt , & tq -> tq_active_list , tqt_active_list ) { if ( j == 0 ) seq_printf ( f , "\\t%s:" , list_names [ LHEAD_ACTIVE ] ) ; else if ( j == 2 ) { seq_printf ( f , "\\n\\t<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" ) ; j = 0 ; } seq_printf ( f , "<S2SV_blank>[%d]%pf(%ps)" , tqt -> tqt_thread -> pid , tqt -> tqt_task -> tqent_func , tqt -> tqt_task -> tqent_arg ) ; ++ j ; } seq_printf ( f , "\\n" ) ; } for ( i = LHEAD_PEND ; i <= LHEAD_WAIT ; ++ i ) if ( lheads [ i ] ) { j = 0 ; list_for_each ( lh , lheads [ i ] ) { <S2SV_StartBug> if ( i == LHEAD_WAIT ) { <S2SV_EndBug> wq = list_entry ( lh , wait_queue_t , task_list ) ; if ( j == 0 ) seq_printf ( f , "\\t%s:" , list_names [ i ] ) ; <S2SV_StartBug> else if ( j == 12 ) { <S2SV_EndBug> seq_printf ( f , "\\n\\t<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" ) ; <S2SV_StartBug> j = 0 ; <S2SV_EndBug> } tsk = wq -> private ; seq_printf ( f , "<S2SV_blank>%d" , tsk -> pid ) ; } else { tqe = list_entry ( lh , taskq_ent_t , tqent_list ) ; if ( j == 0 ) seq_printf ( f , "\\t%s:" , list_names [ i ] ) ; <S2SV_StartBug> else if ( j == 2 ) { <S2SV_EndBug> seq_printf ( f , "\\n\\t<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" ) ; <S2SV_StartBug> j = 0 ; <S2SV_EndBug> } seq_printf ( f , "<S2SV_blank>%pf(%ps)" , tqe -> tqent_func , tqe -> tqent_arg ) ; } ++ j ; } seq_printf ( f , "\\n" ) ; } if ( lheads [ LHEAD_WAIT ] ) spin_unlock_irqrestore ( & tq -> tq_wait_waitq . lock , wflags ) ; spin_unlock_irqrestore ( & tq -> tq_lock , flags ) ; return ( 0 ) ; } | <S2SV_ModStart> { if ( spl_max_show_tasks != 0 && j >= spl_max_show_tasks ) { seq_printf ( f , "\\n\\t(truncated)" ) ; break ; } if ( <S2SV_ModStart> if ( j % 8 == 0 ) <S2SV_ModEnd> seq_printf ( f <S2SV_ModStart> "\\n\\t<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" ) ; <S2SV_ModEnd> tsk = wq <S2SV_ModStart> if ( j % 2 == 0 ) <S2SV_ModEnd> seq_printf ( f <S2SV_ModStart> "\\n\\t<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" ) ; <S2SV_ModEnd> seq_printf ( f |
318 | CWE-000 void * wifi_platform_get_country_code ( wifi_adapter_info_t * adapter , char * ccode ) { # if ( LINUX_VERSION_CODE >= KERNEL_VERSION ( 2 , 6 , 39 ) ) struct wifi_platform_data * plat_data ; if ( ! ccode || ! adapter || ! adapter -> wifi_plat_data ) return NULL ; plat_data = adapter -> wifi_plat_data ; DHD_TRACE ( ( "%s\\n" , __FUNCTION__ ) ) ; if ( plat_data -> get_country_code ) { # if ( LINUX_VERSION_CODE >= KERNEL_VERSION ( 3 , 10 , 58 ) ) <S2SV_StartBug> return plat_data -> get_country_code ( ccode , WLAN_PLAT_NODFS_FLAG ) ; <S2SV_EndBug> # else return plat_data -> get_country_code ( ccode ) ; # endif } # endif return NULL ; } | <S2SV_ModStart> get_country_code ( ccode <S2SV_ModEnd> ) ; # |
319 | CWE-000 int proj_transform_obs ( PJ * P , enum proj_direction direction , size_t n , PJ_OBS * obs ) { <S2SV_StartBug> for ( int i = 0 ; i < n ; i ++ ) { <S2SV_EndBug> obs [ i ] = proj_trans_obs ( P , direction , obs [ i ] ) ; if ( proj_errno ( P ) ) return proj_errno ( P ) ; } return 0 ; } | <S2SV_ModStart> obs ) { size_t i ; for ( <S2SV_ModEnd> i = 0 |
320 | CWE-000 oe_result_t oe_load_elf_enclave_image ( const char * path , oe_enclave_image_t * image ) { oe_result_t result = OE_UNEXPECTED ; memset ( image , 0 , sizeof ( oe_enclave_image_t ) ) ; OE_CHECK ( _oe_load_elf_image ( path , image ) ) ; if ( elf64_load_relocations ( & image -> u . elf . elf , & image -> u . elf . reloc_data , & image -> reloc_size ) != 0 ) OE_RAISE ( OE_FAILURE ) ; # if ( OE_TRACE_LEVEL >= OE_TRACE_LEVEL_INFO ) <S2SV_StartBug> _dump_relocations ( image -> reloc_data , image -> reloc_size ) ; <S2SV_EndBug> # endif image -> type = OE_IMAGE_TYPE_ELF ; image -> calculate_size = _calculate_size ; image -> add_pages = _add_pages ; image -> patch = _patch ; image -> build_ecall_array = _build_ecall_array ; image -> sgx_load_enclave_properties = _sgx_load_enclave_properties ; image -> sgx_update_enclave_properties = _sgx_update_enclave_properties ; image -> unload = _unload ; result = OE_OK ; done : if ( OE_OK != result ) _unload ( image ) ; return result ; } | <S2SV_ModStart> ( image -> u . elf . |
321 | CWE-000 static void mdf_auto_network_task ( void * arg ) { esp_err_t ret = 0 ; network_config_t network_config = { 0 } ; auto_network_data_t * request_data = mdf_calloc ( 1 , ESP_NOW_MAX_DATA_LEN ) ; auto_network_data_t * response_data = mdf_calloc ( 1 , ESP_NOW_MAX_DATA_LEN ) ; char * pubkey_pem = mdf_malloc ( MDF_RSA_PUBKEY_PEM_SIZE ) ; uint8_t source_addr [ 6 ] = { 0 } ; uint32_t auto_network_window_timeout = ( uint32_t ) arg ; uint32_t auto_network_start_time = xTaskGetTickCount ( ) ; ret = mdf_info_load ( MDF_NETWORK_CONFIG_KEY , & network_config , sizeof ( network_config_t ) ) ; MDF_ERROR_GOTO ( ret < 0 , EXIT , "mdf_info_load,<S2SV_blank>ret:<S2SV_blank>%d" , ret ) ; MDF_LOGD ( "start<S2SV_blank>auto<S2SV_blank>network<S2SV_blank>configured" ) ; MDF_LOGV ( "network_config,<S2SV_blank>ssid:<S2SV_blank>%s,<S2SV_blank>password:<S2SV_blank>%s" , network_config . ssid , network_config . password ) ; ESP_ERROR_CHECK ( mdf_espnow_enable ( MDF_ESPNOW_RESERVED ) ) ; ESP_ERROR_CHECK ( mdf_espnow_enable ( MDF_ESPNOW_NETCONFIG ) ) ; ESP_ERROR_CHECK ( mdf_espnow_add_peer_no_encrypt ( WIFI_MESH_BROADCAST_ADDR ) ) ; mdf_espnow_write ( MDF_ESPNOW_RESERVED , WIFI_MESH_BROADCAST_ADDR , MDF_AUTO_NETWORK_OUI , sizeof ( MDF_AUTO_NETWORK_OUI ) , 100 / portTICK_RATE_MS ) ; while ( g_mdf_network_enable_auto_flag && ( xTaskGetTickCount ( ) - auto_network_start_time ) * portTICK_RATE_MS / 1000 < auto_network_window_timeout ) { ret = mdf_espnow_read ( MDF_ESPNOW_NETCONFIG , source_addr , request_data , ESP_NOW_MAX_DATA_LEN , 100 / portTICK_RATE_MS ) ; if ( ret < 0 ) { ret = mdf_espnow_write ( MDF_ESPNOW_RESERVED , WIFI_MESH_BROADCAST_ADDR , MDF_AUTO_NETWORK_OUI , sizeof ( MDF_AUTO_NETWORK_OUI ) , portMAX_DELAY ) ; MDF_ERROR_CONTINUE ( ret < 0 , "mdf_espnow_write,<S2SV_blank>ret:<S2SV_blank>%d" , ret ) ; continue ; } <S2SV_StartBug> # ifdef CONFIG_MDF_USE_NETWORK_WHITELIST <S2SV_EndBug> if ( ! mdf_auto_network_find_whitelist ( source_addr ) ) { MDF_LOGW ( "this<S2SV_blank>device(" MACSTR ")<S2SV_blank>is<S2SV_blank>not<S2SV_blank>on<S2SV_blank>the<S2SV_blank>whitelist<S2SV_blank>of<S2SV_blank>the<S2SV_blank>device<S2SV_blank>configuration<S2SV_blank>network<S2SV_blank>device" , MAC2STR ( source_addr ) ) ; continue ; } # endif if ( ret != sizeof ( auto_network_data_t ) + MDF_RSA_PUBKEY_PEM_DATA_SIZE ) { MDF_LOGW ( "receive,<S2SV_blank>size:<S2SV_blank>%d,<S2SV_blank>data:\\n%s" , ret , request_data -> data ) ; continue ; } MDF_LOGD ( "add<S2SV_blank>device<S2SV_blank>addr:<S2SV_blank>" MACSTR , MAC2STR ( source_addr ) ) ; sprintf ( pubkey_pem , "-----BEGIN<S2SV_blank>PUBLIC<S2SV_blank>KEY-----\\n%s\\n-----END<S2SV_blank>PUBLIC<S2SV_blank>KEY-----\\n" , request_data -> data ) ; ret = mdf_rsa_encrypt ( & network_config , sizeof ( network_config_t ) , ( uint8_t * ) pubkey_pem , response_data -> data ) ; MDF_ERROR_CONTINUE ( ret < 0 , "mdf_rsa_encrypt,<S2SV_blank>ret:<S2SV_blank>%d" , ret ) ; ESP_ERROR_CHECK ( mdf_espnow_add_peer_default_encrypt ( source_addr ) ) ; ssize_t write_size = - 1 ; for ( int i = 0 ; i < NETWORK_ESPNOW_SEND_RETRY_NUM && write_size <= 0 ; i ++ ) { vTaskDelay ( i * NETWORK_ESPNOW_SEND_DELAY_TIME / portTICK_RATE_MS ) ; write_size = mdf_espnow_write ( MDF_ESPNOW_NETCONFIG , source_addr , response_data , MDF_RSA_CIPHERTEXT_SIZE + sizeof ( auto_network_data_t ) , portMAX_DELAY ) ; } if ( write_size <= 0 ) { ESP_ERROR_CHECK ( mdf_espnow_del_peer ( source_addr ) ) ; MDF_LOGW ( "mdf_espnow_write<S2SV_blank>public<S2SV_blank>key,<S2SV_blank>ret:<S2SV_blank>%d" , ret ) ; continue ; } <S2SV_StartBug> # ifdef CONFIG_MDF_USE_NETWORK_WHITELIST <S2SV_EndBug> write_size = 0 ; size_t network_whitelist_size = sizeof ( auto_network_addrs_t ) + g_auto_network_whitelist -> num * MDF_NETWORK_NETWORK_ADDR_SIZE ; for ( int i = 0 ; i < NETWORK_ESPNOW_SEND_RETRY_NUM && write_size != network_whitelist_size ; i ++ ) { vTaskDelay ( i * NETWORK_ESPNOW_SEND_DELAY_TIME / portTICK_RATE_MS ) ; ret = mdf_espnow_write ( MDF_ESPNOW_NETCONFIG , source_addr , ( uint8_t * ) g_auto_network_whitelist + write_size , network_whitelist_size - write_size , portMAX_DELAY ) ; write_size += ( ret > 0 ) ? ret : 0 ; } ESP_ERROR_CHECK ( mdf_espnow_del_peer ( source_addr ) ) ; if ( write_size != network_whitelist_size ) { MDF_LOGW ( "mdf_espnow_write<S2SV_blank>whitelist,<S2SV_blank>write_size:<S2SV_blank>%d" , write_size ) ; } # else ESP_ERROR_CHECK ( mdf_espnow_del_peer ( source_addr ) ) ; # endif } ESP_ERROR_CHECK ( mdf_espnow_del_peer ( WIFI_MESH_BROADCAST_ADDR ) ) ; MDF_LOGD ( "end<S2SV_blank>auto<S2SV_blank>network<S2SV_blank>configured" ) ; EXIT : mdf_espnow_disable ( MDF_ESPNOW_RESERVED ) ; mdf_espnow_disable ( MDF_ESPNOW_NETCONFIG ) ; mdf_network_delete_whitelist ( ) ; g_mdf_network_enable_auto_flag = false ; mdf_free ( pubkey_pem ) ; mdf_free ( response_data ) ; mdf_free ( request_data ) ; vTaskDelete ( NULL ) ; } | <S2SV_ModStart> } # ifdef MDF_USE_NETWORK_WHITELIST <S2SV_ModEnd> if ( ! <S2SV_ModStart> } # ifdef MDF_USE_NETWORK_WHITELIST <S2SV_ModEnd> write_size = 0 |
322 | CWE-000 static void show_entry_xml ( ExifEntry * e , void * data ) { unsigned char * ids = data ; char v [ TAG_VALUE_BUF ] , t [ TAG_VALUE_BUF ] ; if ( * ids ) { fprintf ( stdout , "<0x%04x>" , e -> tag ) ; <S2SV_StartBug> fprintf ( stdout , "%s" , exif_entry_get_value ( e , v , sizeof ( v ) ) ) ; <S2SV_EndBug> fprintf ( stdout , "</0x%04x>" , e -> tag ) ; } else { strncpy ( t , exif_tag_get_title_in_ifd ( e -> tag , exif_entry_get_ifd ( e ) ) , sizeof ( t ) ) ; remove_bad_chars ( t ) ; fprintf ( stdout , "\\t<%s>" , t ) ; <S2SV_StartBug> fprintf ( stdout , "%s" , exif_entry_get_value ( e , v , sizeof ( v ) ) ) ; <S2SV_EndBug> fprintf ( stdout , "</%s>\\n" , t ) ; } } | <S2SV_ModStart> , "%s" , escape_xml ( <S2SV_ModStart> sizeof ( v ) <S2SV_ModStart> , "%s" , escape_xml ( <S2SV_ModStart> sizeof ( v ) |
323 | CWE-000 DEVICE_LINKED_LIST * createEmptyDeviceList ( ) { DEVICE_LINKED_LIST * dList ; printk ( "Creating<S2SV_blank>new<S2SV_blank>empty<S2SV_blank>devices<S2SV_blank>list\\n" ) ; dList = ( DEVICE_LINKED_LIST * ) kmalloc ( sizeof ( DEVICE_LINKED_LIST ) , GFP_KERNEL ) ; if ( dList == NULL ) { return NULL ; } printk ( "Allocation<S2SV_blank>Successfully<S2SV_blank>for<S2SV_blank>Devices<S2SV_blank>List\\n" ) ; dList -> head = NULL ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> = NULL ; return dList ; |
324 | CWE-000 static struct kvm * kvm_create_vm ( unsigned long type ) { int r , i ; struct kvm * kvm = kvm_arch_alloc_vm ( ) ; if ( ! kvm ) return ERR_PTR ( - ENOMEM ) ; <S2SV_StartBug> r = kvm_arch_init_vm ( kvm , type ) ; <S2SV_EndBug> if ( r ) goto out_err_nodisable ; r = hardware_enable_all ( ) ; if ( r ) goto out_err_nodisable ; # ifdef CONFIG_HAVE_KVM_IRQCHIP INIT_HLIST_HEAD ( & kvm -> mask_notifier_list ) ; INIT_HLIST_HEAD ( & kvm -> irq_ack_notifier_list ) ; # endif BUILD_BUG_ON ( KVM_MEM_SLOTS_NUM > SHRT_MAX ) ; r = - ENOMEM ; kvm -> memslots = kzalloc ( sizeof ( struct kvm_memslots ) , GFP_KERNEL ) ; if ( ! kvm -> memslots ) goto out_err_nosrcu ; kvm_init_memslots_id ( kvm ) ; if ( init_srcu_struct ( & kvm -> srcu ) ) goto out_err_nosrcu ; for ( i = 0 ; i < KVM_NR_BUSES ; i ++ ) { kvm -> buses [ i ] = kzalloc ( sizeof ( struct kvm_io_bus ) , GFP_KERNEL ) ; if ( ! kvm -> buses [ i ] ) goto out_err ; } <S2SV_StartBug> spin_lock_init ( & kvm -> mmu_lock ) ; <S2SV_EndBug> kvm -> mm = current -> mm ; atomic_inc ( & kvm -> mm -> mm_count ) ; kvm_eventfd_init ( kvm ) ; mutex_init ( & kvm -> lock ) ; mutex_init ( & kvm -> irq_lock ) ; mutex_init ( & kvm -> slots_lock ) ; atomic_set ( & kvm -> users_count , 1 ) ; INIT_LIST_HEAD ( & kvm -> devices ) ; r = kvm_init_mmu_notifier ( kvm ) ; if ( r ) goto out_err ; raw_spin_lock ( & kvm_lock ) ; list_add ( & kvm -> vm_list , & vm_list ) ; raw_spin_unlock ( & kvm_lock ) ; return kvm ; out_err : cleanup_srcu_struct ( & kvm -> srcu ) ; out_err_nosrcu : hardware_disable_all ( ) ; out_err_nodisable : for ( i = 0 ; i < KVM_NR_BUSES ; i ++ ) kfree ( kvm -> buses [ i ] ) ; kfree ( kvm -> memslots ) ; kvm_arch_free_vm ( kvm ) ; <S2SV_StartBug> return ERR_PTR ( r ) ; <S2SV_EndBug> } | <S2SV_ModStart> ENOMEM ) ; spin_lock_init ( & kvm -> mmu_lock ) ; atomic_inc ( & current -> mm -> mm_count ) ; kvm -> mm = current -> mm ; kvm_eventfd_init ( kvm ) ; mutex_init ( & kvm -> lock ) ; mutex_init ( & kvm -> irq_lock ) ; mutex_init ( & kvm -> slots_lock ) ; atomic_set ( & kvm -> users_count , 1 ) ; INIT_LIST_HEAD ( & kvm -> devices ) ; <S2SV_ModStart> out_err ; } <S2SV_ModEnd> r = kvm_init_mmu_notifier <S2SV_ModStart> kvm ) ; mmdrop ( current -> mm ) ; |
325 | CWE-000 void convertTDPStoFlatBytes_double_args ( TightDataPointStorageD * tdps , unsigned char * bytes , size_t * size ) { size_t i , k = 0 ; unsigned char dsLengthBytes [ 8 ] ; if ( SZ_SIZE_TYPE == 4 ) intToBytes_bigEndian ( dsLengthBytes , tdps -> dataSeriesLength ) ; else longToBytes_bigEndian ( dsLengthBytes , tdps -> dataSeriesLength ) ; unsigned char sameByte = tdps -> allSameData == 1 ? ( unsigned char ) 1 : ( unsigned char ) 0 ; sameByte = sameByte | ( szMode << 1 ) ; if ( tdps -> isLossless ) sameByte = ( unsigned char ) ( sameByte | 0x10 ) ; <S2SV_StartBug> if ( errorBoundMode == PW_REL ) <S2SV_EndBug> sameByte = ( unsigned char ) ( sameByte | 0x20 ) ; if ( SZ_SIZE_TYPE == 8 ) sameByte = ( unsigned char ) ( sameByte | 0x40 ) ; if ( tdps -> allSameData == 1 ) { size_t totalByteLength = 3 + SZ_SIZE_TYPE + 1 + tdps -> exactMidBytes_size ; for ( i = 0 ; i < 3 ; i ++ ) bytes [ k ++ ] = versionNumber [ i ] ; bytes [ k ++ ] = sameByte ; for ( i = 0 ; i < SZ_SIZE_TYPE ; i ++ ) bytes [ k ++ ] = dsLengthBytes [ i ] ; for ( i = 0 ; i < tdps -> exactMidBytes_size ; i ++ ) bytes [ k ++ ] = tdps -> exactMidBytes [ i ] ; * size = totalByteLength ; } else if ( tdps -> rtypeArray == NULL ) { size_t residualMidBitsLength = tdps -> residualMidBits == NULL ? 0 : tdps -> residualMidBits_size ; size_t segmentL = 0 , radExpoL = 0 , pwrBoundArrayL = 0 ; <S2SV_StartBug> if ( errorBoundMode == PW_REL ) <S2SV_EndBug> { segmentL = SZ_SIZE_TYPE ; radExpoL = 1 ; pwrBoundArrayL = 4 ; } size_t totalByteLength = 3 + SZ_SIZE_TYPE + 1 + 4 + radExpoL + segmentL + pwrBoundArrayL + 4 + 8 + 1 + 8 + SZ_SIZE_TYPE + SZ_SIZE_TYPE + SZ_SIZE_TYPE + tdps -> typeArray_size + tdps -> leadNumArray_size + tdps -> exactMidBytes_size + residualMidBitsLength + tdps -> pwrErrBoundBytes_size ; convertTDPStoBytes_double ( tdps , bytes , dsLengthBytes , sameByte ) ; * size = totalByteLength ; } else { size_t residualMidBitsLength = tdps -> residualMidBits == NULL ? 0 : tdps -> residualMidBits_size ; size_t segmentL = 0 , radExpoL = 0 , pwrBoundArrayL = 0 ; <S2SV_StartBug> if ( errorBoundMode == PW_REL ) <S2SV_EndBug> { segmentL = SZ_SIZE_TYPE ; radExpoL = 1 ; pwrBoundArrayL = 4 ; } size_t totalByteLength = 3 + SZ_SIZE_TYPE + 1 + 4 + radExpoL + segmentL + pwrBoundArrayL + 4 + 8 + 1 + 8 + SZ_SIZE_TYPE + SZ_SIZE_TYPE + SZ_SIZE_TYPE + SZ_SIZE_TYPE + 8 + tdps -> rtypeArray_size + tdps -> typeArray_size + tdps -> leadNumArray_size + tdps -> exactMidBytes_size + residualMidBitsLength + tdps -> pwrErrBoundBytes_size ; sameByte = ( unsigned char ) ( sameByte | 0x08 ) ; <S2SV_StartBug> if ( errorBoundMode == PW_REL ) <S2SV_EndBug> sameByte = ( unsigned char ) ( sameByte | 0x10 ) ; convertTDPStoBytes_double_reserve ( tdps , bytes , dsLengthBytes , sameByte ) ; * size = totalByteLength ; } } | <S2SV_ModStart> if ( errorBoundMode >= <S2SV_ModEnd> PW_REL ) sameByte <S2SV_ModStart> if ( errorBoundMode >= <S2SV_ModEnd> PW_REL ) { <S2SV_ModStart> if ( errorBoundMode >= <S2SV_ModEnd> PW_REL ) { <S2SV_ModStart> if ( errorBoundMode >= <S2SV_ModEnd> PW_REL ) sameByte |
326 | CWE-000 static int plugin_trim ( struct backend * b , struct connection * conn , uint32_t count , uint64_t offset , uint32_t flags ) { int r ; struct backend_plugin * p = container_of ( b , struct backend_plugin , backend ) ; bool fua = flags & NBDKIT_FLAG_FUA ; assert ( connection_get_handle ( conn , 0 ) ) ; assert ( ! ( flags & ~ NBDKIT_FLAG_FUA ) ) ; debug ( "trim<S2SV_blank>count=%" PRIu32 "<S2SV_blank>offset=%" PRIu64 "<S2SV_blank>fua=%d" , count , offset , fua ) ; if ( p -> plugin . trim != NULL ) r = p -> plugin . trim ( connection_get_handle ( conn , 0 ) , count , offset ) ; else { errno = EINVAL ; return - 1 ; } <S2SV_StartBug> if ( r == 0 && fua ) { <S2SV_EndBug> assert ( p -> plugin . flush ) ; r = plugin_flush ( b , conn , 0 ) ; } return r ; } | <S2SV_ModStart> if ( r != - 1 <S2SV_ModEnd> && fua ) |
327 | CWE-000 static int pm8921_remove ( struct platform_device * pdev ) { struct pm8xxx_drvdata * drvdata ; struct pm8921 * pmic = NULL ; int i ; drvdata = platform_get_drvdata ( pdev ) ; if ( drvdata ) pmic = drvdata -> pm_chip_data ; if ( pmic ) { <S2SV_StartBug> if ( pmic -> dev ) <S2SV_EndBug> mfd_remove_devices ( pmic -> dev ) ; <S2SV_StartBug> if ( pmic -> irq_chip ) <S2SV_EndBug> pm8xxx_irq_exit ( pmic -> irq_chip ) ; <S2SV_StartBug> if ( pmic -> mfd_regulators ) { <S2SV_EndBug> for ( i = 0 ; i < ARRAY_SIZE ( regulator_data ) ; i ++ ) mutex_destroy ( & regulator_data [ i ] . pc_lock ) ; for ( i = 0 ; i < ARRAY_SIZE ( pm8917_regulator_data ) ; i ++ ) mutex_destroy ( & pm8917_regulator_data [ i ] . pc_lock ) ; } kfree ( pmic -> mfd_regulators ) ; kfree ( pmic -> regulator_cdata ) ; kfree ( pmic ) ; } platform_set_drvdata ( pdev , NULL ) ; return 0 ; } | <S2SV_ModStart> pmic ) { <S2SV_ModEnd> mfd_remove_devices ( pmic <S2SV_ModStart> -> irq_chip ) { <S2SV_ModStart> irq_chip ) ; pmic -> irq_chip = NULL ; } <S2SV_ModEnd> } platform_set_drvdata ( |
328 | CWE-000 static uint32_t parallel_ioport_read_sw ( void * opaque , uint32_t addr ) { ParallelState * s = opaque ; uint32_t ret = 0xff ; addr &= 7 ; switch ( addr ) { case PARA_REG_DATA : if ( s -> control & PARA_CTR_DIR ) ret = s -> datar ; else ret = s -> dataw ; break ; case PARA_REG_STS : ret = s -> status ; s -> irq_pending = 0 ; if ( ( s -> status & PARA_STS_BUSY ) == 0 && ( s -> control & PARA_CTR_STROBE ) == 0 ) { if ( s -> status & PARA_STS_ACK ) s -> status &= ~ PARA_STS_ACK ; else { s -> status |= PARA_STS_ACK ; s -> status |= PARA_STS_BUSY ; } } parallel_update_irq ( s ) ; break ; case PARA_REG_CTR : ret = s -> control ; break ; } <S2SV_StartBug> pdebug ( "read<S2SV_blank>addr=0x%02x<S2SV_blank>val=0x%02x\\n" , addr , ret ) ; <S2SV_EndBug> return ret ; } | <S2SV_ModStart> break ; } trace_parallel_ioport_read ( "SW" <S2SV_ModEnd> , addr , |
329 | CWE-000 static void gst_omx_h265_enc_class_init ( GstOMXH265EncClass * klass ) { GObjectClass * gobject_class = G_OBJECT_CLASS ( klass ) ; GstElementClass * element_class = GST_ELEMENT_CLASS ( klass ) ; GstOMXVideoEncClass * videoenc_class = GST_OMX_VIDEO_ENC_CLASS ( klass ) ; videoenc_class -> set_format = GST_DEBUG_FUNCPTR ( gst_omx_h265_enc_set_format ) ; videoenc_class -> get_caps = GST_DEBUG_FUNCPTR ( gst_omx_h265_enc_get_caps ) ; gobject_class -> set_property = gst_omx_h265_enc_set_property ; gobject_class -> get_property = gst_omx_h265_enc_get_property ; g_object_class_install_property ( gobject_class , PROP_INTERVALOFCODINGINTRAFRAMES , g_param_spec_uint ( "interval-intraframes" , "Interval<S2SV_blank>of<S2SV_blank>coding<S2SV_blank>Intra<S2SV_blank>frames" , "Interval<S2SV_blank>of<S2SV_blank>coding<S2SV_blank>Intra<S2SV_blank>frames<S2SV_blank>(0xffffffff=component<S2SV_blank>default)" , 0 , G_MAXUINT , GST_OMX_H265_VIDEO_ENC_INTERVAL_OF_CODING_INTRA_FRAMES_DEFAULT , G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | GST_PARAM_MUTABLE_READY ) ) ; # ifdef USE_OMX_TARGET_ZYNQ_USCALE_PLUS g_object_class_install_property ( gobject_class , PROP_PERIODICITYOFIDRFRAMES , <S2SV_StartBug> g_param_spec_uint ( "periodicty-idr" , "Target<S2SV_blank>Bitrate" , <S2SV_EndBug> "Periodicity<S2SV_blank>of<S2SV_blank>IDR<S2SV_blank>frames<S2SV_blank>(0xffffffff=component<S2SV_blank>default)" , 0 , G_MAXUINT , GST_OMX_H265_VIDEO_ENC_PERIODICITY_OF_IDR_FRAMES_DEFAULT , G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | GST_PARAM_MUTABLE_READY ) ) ; g_object_class_install_property ( gobject_class , PROP_B_FRAMES , g_param_spec_uint ( "b-frames" , "Number<S2SV_blank>of<S2SV_blank>B-frames" , "Number<S2SV_blank>of<S2SV_blank>B-frames<S2SV_blank>between<S2SV_blank>two<S2SV_blank>consecutive<S2SV_blank>I-frames<S2SV_blank>(0xffffffff=component<S2SV_blank>default)" , 0 , G_MAXUINT , GST_OMX_H265_VIDEO_ENC_B_FRAMES_DEFAULT , G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | GST_PARAM_MUTABLE_READY ) ) ; g_object_class_install_property ( gobject_class , PROP_CONSTRAINED_INTRA_PREDICTION , g_param_spec_boolean ( "constrained-intra-prediction" , "Constrained<S2SV_blank>Intra<S2SV_blank>Prediction" , "If<S2SV_blank>enabled,<S2SV_blank>prediction<S2SV_blank>only<S2SV_blank>uses<S2SV_blank>residual<S2SV_blank>data<S2SV_blank>and<S2SV_blank>decoded<S2SV_blank>samples<S2SV_blank>" "from<S2SV_blank>neighbouring<S2SV_blank>coding<S2SV_blank>blocks<S2SV_blank>coded<S2SV_blank>using<S2SV_blank>intra<S2SV_blank>prediction<S2SV_blank>modes" , GST_OMX_H265_VIDEO_ENC_CONSTRAINED_INTRA_PREDICTION_DEFAULT , G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | GST_PARAM_MUTABLE_READY ) ) ; g_object_class_install_property ( gobject_class , PROP_LOOP_FILTER_MODE , g_param_spec_enum ( "loop-filter-mode" , "Loop<S2SV_blank>Filter<S2SV_blank>mode" , "Enable<S2SV_blank>or<S2SV_blank>disable<S2SV_blank>the<S2SV_blank>deblocking<S2SV_blank>filter<S2SV_blank>(0xffffffff=component<S2SV_blank>default)" , GST_TYPE_OMX_H265_ENC_LOOP_FILTER_MODE , GST_OMX_H265_VIDEO_ENC_LOOP_FILTER_MODE_DEFAULT , G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | GST_PARAM_MUTABLE_READY ) ) ; # endif videoenc_class -> cdata . default_src_template_caps = "video/x-h265,<S2SV_blank>" "width=(int)<S2SV_blank>[<S2SV_blank>1,<S2SV_blank>MAX<S2SV_blank>],<S2SV_blank>" "height=(int)<S2SV_blank>[<S2SV_blank>1,<S2SV_blank>MAX<S2SV_blank>],<S2SV_blank>" "framerate<S2SV_blank>=<S2SV_blank>(fraction)<S2SV_blank>[0,<S2SV_blank>MAX],<S2SV_blank>" "stream-format=(string)<S2SV_blank>byte-stream,<S2SV_blank>alignment=(string)<S2SV_blank>au<S2SV_blank>" ; gst_element_class_set_static_metadata ( element_class , "OpenMAX<S2SV_blank>H.265<S2SV_blank>Video<S2SV_blank>Encoder" , "Codec/Encoder/Video" , "Encode<S2SV_blank>H.265<S2SV_blank>video<S2SV_blank>streams" , "Sebastian<S2SV_blank>Dröge<S2SV_blank><sebastian.droege@collabora.co.uk>" ) ; gst_omx_set_default_role ( & videoenc_class -> cdata , "video_encoder.hevc" ) ; } | <S2SV_ModStart> , g_param_spec_uint ( "periodicity-idr" , "IDR<S2SV_blank>periodicity" <S2SV_ModEnd> , "Periodicity<S2SV_blank>of<S2SV_blank>IDR<S2SV_blank>frames<S2SV_blank>(0xffffffff=component<S2SV_blank>default)" , |
330 | CWE-000 void lm_qrsolv ( const int64_t n , double * r , const int64_t ldr , const int64_t * Pivot , const double * diag , const double * qtb , double * x , double * Sdiag , double * W ) { int64_t i , kk , j , k , nsing ; double qtbpj , sum , temp ; double _sin , _cos , _tan , _cot ; for ( j = 0 ; j < n ; j ++ ) { for ( i = j ; i < n ; i ++ ) r [ j * ldr + i ] = r [ i * ldr + j ] ; x [ j ] = r [ j * ldr + j ] ; W [ j ] = qtb [ j ] ; } for ( j = 0 ; j < n ; j ++ ) { <S2SV_StartBug> if ( diag [ Pivot [ j ] ] != 0 ) { <S2SV_EndBug> for ( k = j ; k < n ; k ++ ) Sdiag [ k ] = 0 ; Sdiag [ j ] = diag [ Pivot [ j ] ] ; qtbpj = 0 ; for ( k = j ; k < n ; k ++ ) { <S2SV_StartBug> if ( Sdiag [ k ] == 0 ) <S2SV_EndBug> continue ; kk = k + ldr * k ; if ( fabs ( r [ kk ] ) < fabs ( Sdiag [ k ] ) ) { _cot = r [ kk ] / Sdiag [ k ] ; _sin = 1 / hypot ( 1 , _cot ) ; _cos = _sin * _cot ; } else { _tan = Sdiag [ k ] / r [ kk ] ; _cos = 1 / hypot ( 1 , _tan ) ; _sin = _cos * _tan ; } r [ kk ] = _cos * r [ kk ] + _sin * Sdiag [ k ] ; temp = _cos * W [ k ] + _sin * qtbpj ; qtbpj = - _sin * W [ k ] + _cos * qtbpj ; W [ k ] = temp ; for ( i = k + 1 ; i < n ; i ++ ) { temp = _cos * r [ k * ldr + i ] + _sin * Sdiag [ i ] ; Sdiag [ i ] = - _sin * r [ k * ldr + i ] + _cos * Sdiag [ i ] ; r [ k * ldr + i ] = temp ; } } } Sdiag [ j ] = r [ j * ldr + j ] ; r [ j * ldr + j ] = x [ j ] ; } nsing = n ; for ( j = 0 ; j < n ; j ++ ) { <S2SV_StartBug> if ( Sdiag [ j ] == 0 && nsing == n ) <S2SV_EndBug> nsing = j ; if ( nsing < n ) W [ j ] = 0 ; } for ( j = nsing - 1 ; j >= 0 ; j -- ) { sum = 0 ; for ( i = j + 1 ; i < nsing ; i ++ ) sum += r [ j * ldr + i ] * W [ i ] ; W [ j ] = ( W [ j ] - sum ) / Sdiag [ j ] ; } for ( j = 0 ; j < n ; j ++ ) x [ Pivot [ j ] ] = W [ j ] ; } | <S2SV_ModStart> { if ( d_abs ( <S2SV_ModStart> j ] ] ) > EPS <S2SV_ModEnd> ) { for <S2SV_ModStart> { if ( d_abs ( Sdiag [ k ] ) < EPS <S2SV_ModEnd> ) continue ; <S2SV_ModStart> { if ( d_abs ( Sdiag [ j ] ) < EPS <S2SV_ModEnd> && nsing == |
331 | CWE-000 int script_parse ( xmlDocPtr doc , struct script * script ) { int rc = 0 ; <S2SV_StartBug> xmlNode * root = xmlDocGetRootElement ( doc ) ; <S2SV_EndBug> if ( xmlStrcmp ( root -> name , ( xmlChar * ) "script" ) != 0 ) { rc = 1 ; goto cleanup ; } bool ctester = true ; xmlChar * ctesterProp = xmlGetProp ( root , ( xmlChar * ) "ctester" ) ; if ( ctesterProp != NULL ) { rc = bool_from_xml ( ctesterProp , & ctester ) ; xmlFree ( ctesterProp ) ; if ( rc != 0 ) { goto cleanup ; } } if ( ! ctester ) { rc = 1 ; goto cleanup ; } if ( ( rc = script_init ( script ) ) != 0 ) { goto cleanup ; } script -> name = xmlGetProp ( root , ( xmlChar * ) "name" ) ; xmlNode * cur_node = root -> children ; for ( ; cur_node ; cur_node = cur_node -> next ) { if ( xmlStrcmp ( cur_node -> name , ( xmlChar * ) "command" ) == 0 ) { if ( ( rc = command_parse ( cur_node , script ) ) != 0 ) { goto cleanup ; } } else { if ( ( cur_node -> type == XML_TEXT_NODE && xmlIsBlankNode ( cur_node ) ) || ( cur_node -> type == XML_COMMENT_NODE ) ) { } else { rc = 1 ; goto cleanup ; } } } cleanup : return rc ; } | <S2SV_ModStart> doc ) ; if ( root == NULL ) { rc = 1 ; goto cleanup ; } |
332 | CWE-000 static int mdp3_res_init ( void ) { int rc = 0 ; rc = mdp3_irq_setup ( ) ; if ( rc ) return rc ; rc = mdp3_clk_setup ( ) ; if ( rc ) return rc ; mdp3_res -> ion_client = msm_ion_client_create ( mdp3_res -> pdev -> name ) ; if ( IS_ERR_OR_NULL ( mdp3_res -> ion_client ) ) { <S2SV_StartBug> pr_err ( "msm_ion_client_create()<S2SV_blank>return<S2SV_blank>error<S2SV_blank>(%p)\\n" , <S2SV_EndBug> mdp3_res -> ion_client ) ; mdp3_res -> ion_client = NULL ; return - EINVAL ; } rc = mdp3_iommu_init ( ) ; if ( rc ) return rc ; mdp3_res -> bus_handle = mdp3_bus_handle ; rc = mdp3_bus_scale_register ( ) ; if ( rc ) { pr_err ( "unable<S2SV_blank>to<S2SV_blank>register<S2SV_blank>bus<S2SV_blank>scaling\\n" ) ; return rc ; } rc = mdp3_hw_init ( ) ; return rc ; } | <S2SV_ModStart> { pr_err ( "msm_ion_client_create()<S2SV_blank>return<S2SV_blank>error<S2SV_blank>(%pK)\\n" <S2SV_ModEnd> , mdp3_res -> |
333 | CWE-000 <S2SV_StartBug> nyoci_status_t <S2SV_EndBug> resend_get_request ( void * context ) { nyoci_status_t status = 0 ; status = nyoci_outbound_begin ( nyoci_get_current_instance ( ) , COAP_METHOD_GET , get_tt ) ; require_noerr ( status , bail ) ; status = nyoci_outbound_set_uri ( url_data , 0 ) ; require_noerr ( status , bail ) ; if ( request_accept_type != COAP_CONTENT_TYPE_UNKNOWN ) { status = nyoci_outbound_add_option_uint ( COAP_OPTION_ACCEPT , request_accept_type ) ; require_noerr ( status , bail ) ; } status = nyoci_outbound_send ( ) ; if ( status ) { check_noerr ( status ) ; fprintf ( stderr , "nyoci_outbound_send()<S2SV_blank>returned<S2SV_blank>error<S2SV_blank>%d(%s).\\n" , status , nyoci_status_to_cstr ( status ) ) ; goto bail ; } bail : return status ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static |
334 | CWE-000 int gpio_read ( u32 port , u32 pins ) { <S2SV_StartBug> return GPIO ( _gpio_in [ port ] ) & pins ? 1 : 0 ; <S2SV_EndBug> } | <S2SV_ModStart> ) { return ( <S2SV_ModStart> ) & pins ) |
335 | CWE-000 void keyboard_handler_main ( void ) { puts ( "I\'m<S2SV_blank>not<S2SV_blank>doing<S2SV_blank>this..." ) ; unsigned char status ; char keycode ; outb ( 0x20 , 0x20 ) ; status = inb ( 0x64 ) ; if ( status & 0x01 ) { keycode = inb ( 0x60 ) ; if ( keycode < 0 ) return ; <S2SV_StartBug> term_putc ( asChar ( keycode , false ) ) ; <S2SV_EndBug> } } | <S2SV_ModStart> ) return ; putchar <S2SV_ModEnd> ( asChar ( |
336 | CWE-000 static int pn532_uart_send ( nfc_device * pnd , const uint8_t * pbtData , const size_t szData , int timeout ) { int res = 0 ; uart_flush_input ( DRIVER_DATA ( pnd ) -> port , false ) ; switch ( CHIP_DATA ( pnd ) -> power_mode ) { case LOWVBAT : { if ( ( res = pn532_uart_wakeup ( pnd ) ) < 0 ) { return res ; } <S2SV_StartBug> if ( ( res = pn532_SAMConfiguration ( pnd , PSM_NORMAL , 1000 ) ) < 0 ) { <S2SV_EndBug> return res ; } } break ; case POWERDOWN : { if ( ( res = pn532_uart_wakeup ( pnd ) ) < 0 ) { return res ; } } break ; case NORMAL : break ; } ; uint8_t abtFrame [ PN532_BUFFER_LEN ] = { 0x00 , 0x00 , 0xff } ; size_t szFrame = 0 ; if ( ( res = pn53x_build_frame ( abtFrame , & szFrame , pbtData , szData ) ) < 0 ) { pnd -> last_error = res ; return pnd -> last_error ; } res = uart_send ( DRIVER_DATA ( pnd ) -> port , abtFrame , szFrame , timeout ) ; if ( res != 0 ) { log_put ( LOG_GROUP , LOG_CATEGORY , NFC_LOG_PRIORITY_ERROR , "%s" , "Unable<S2SV_blank>to<S2SV_blank>transmit<S2SV_blank>data.<S2SV_blank>(TX)" ) ; pnd -> last_error = res ; return pnd -> last_error ; } uint8_t abtRxBuf [ PN53x_ACK_FRAME__LEN ] ; res = uart_receive ( DRIVER_DATA ( pnd ) -> port , abtRxBuf , sizeof ( abtRxBuf ) , 0 , timeout ) ; if ( res != 0 ) { log_put ( LOG_GROUP , LOG_CATEGORY , NFC_LOG_PRIORITY_DEBUG , "%s" , "Unable<S2SV_blank>to<S2SV_blank>read<S2SV_blank>ACK" ) ; pnd -> last_error = res ; return pnd -> last_error ; } if ( pn53x_check_ack_frame ( pnd , abtRxBuf , sizeof ( abtRxBuf ) ) == 0 ) { } else { return pnd -> last_error ; } return NFC_SUCCESS ; } | <S2SV_ModStart> res ; } for ( int i = 0 ; i < 10 ; i ++ ) { <S2SV_ModEnd> res = pn532_SAMConfiguration <S2SV_ModStart> , PSM_NORMAL , 20 ) ; if ( res == NFC_ETIMEOUT ) { log_put ( LOG_GROUP , LOG_CATEGORY , NFC_LOG_PRIORITY_ERROR , "%s" , "Command<S2SV_blank>SAMConfiguration<S2SV_blank>timeout,<S2SV_blank>retry..." ) ; } else { break ; } } if ( res <S2SV_ModEnd> < 0 ) |
337 | CWE-000 int Get_my_info ( u_char * dev , HOST * my ) { FILE * fp ; int i ; int fd ; struct ifreq ifr ; char hwaddr [ 20 ] ; fd = socket ( AF_INET , SOCK_DGRAM , 0 ) ; ifr . ifr_addr . sa_family = AF_INET ; strncpy ( ifr . ifr_name , dev , IFNAMSIZ - 1 ) ; ioctl ( fd , SIOCGIFADDR , & ifr ) ; inet_ntop ( AF_INET , & ( ( ( struct sockaddr_in * ) & ifr . ifr_addr ) -> sin_addr ) , my -> ip , INET_ADDRSTRLEN ) ; ioctl ( fd , SIOCGIFHWADDR , & ifr ) ; <S2SV_StartBug> for ( i = 0 ; i < 6 ; i ++ ) <S2SV_EndBug> <S2SV_StartBug> my -> mac [ i ] = ( ( unsigned char * ) ifr . ifr_hwaddr . sa_data ) [ i ] ; <S2SV_EndBug> close ( fd ) ; return 1 ; } | <S2SV_ModStart> ifr ) ; memcpy ( <S2SV_ModEnd> my -> mac <S2SV_ModStart> my -> mac , <S2SV_ModEnd> ifr . ifr_hwaddr <S2SV_ModStart> ifr_hwaddr . sa_data , 6 ) <S2SV_ModEnd> ; close ( |
338 | CWE-000 int mv88e6xxx_port_bridge_join ( struct dsa_switch * ds , int port , struct net_device * bridge ) { struct mv88e6xxx_priv_state * ps = ds_to_priv ( ds ) ; <S2SV_StartBug> u16 fid ; <S2SV_EndBug> int i , err ; <S2SV_StartBug> mutex_lock ( & ps -> smi_mutex ) ; <S2SV_EndBug> for ( i = 0 ; i < ps -> num_ports ; ++ i ) if ( ps -> ports [ i ] . bridge_dev == bridge ) break ; if ( i < ps -> num_ports ) err = _mv88e6xxx_port_fid_get ( ds , i , & fid ) ; else err = _mv88e6xxx_fid_new ( ds , & fid ) ; if ( err ) goto unlock ; err = _mv88e6xxx_port_fid_set ( ds , port , fid ) ; if ( err ) goto unlock ; ps -> ports [ port ] . bridge_dev = bridge ; for ( i = 0 ; i < ps -> num_ports ; ++ i ) { if ( ps -> ports [ i ] . bridge_dev == bridge ) { err = _mv88e6xxx_port_based_vlan_map ( ds , i ) ; if ( err ) break ; } } <S2SV_StartBug> unlock : <S2SV_EndBug> mutex_unlock ( & ps -> smi_mutex ) ; return err ; } | <S2SV_ModStart> ds ) ; <S2SV_ModEnd> int i , <S2SV_ModStart> -> smi_mutex ) <S2SV_ModEnd> ; ps -> <S2SV_ModStart> ; } } <S2SV_ModEnd> mutex_unlock ( & |
339 | CWE-000 <S2SV_StartBug> SPL_METHOD ( Array , getFlags ) <S2SV_EndBug> { zval * object = getThis ( ) ; spl_array_object * intern = Z_SPLARRAY_P ( object ) ; if ( zend_parse_parameters_none ( ) == FAILURE ) { return ; } <S2SV_StartBug> RETURN_LONG ( intern -> ar_flags & ~ SPL_ARRAY_INT_MASK ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( Array , getIteratorClass <S2SV_ModEnd> ) { zval <S2SV_ModStart> return ; } zend_string_addref <S2SV_ModEnd> ( intern -> <S2SV_ModStart> ( intern -> ce_get_iterator -> name ) ; RETURN_STR ( intern -> ce_get_iterator -> name <S2SV_ModEnd> ) ; } |
340 | CWE-000 void testDrawTri ( ) { srand ( ( int ) time ( NULL ) ) ; SDL2Context c = new_SDL2Context ( SDL_INIT_VIDEO ) ; System s = random_sys ( 1e10 , 1000 ) ; s . tree = build_tree ( s . bodies , s . count ) ; init_shaders ( & c ) ; while ( 1 ) { update_system ( & s ) ; float r = 0 , g = 0 , b = 0 ; <S2SV_StartBug> printf ( "%d<S2SV_blank>%d<S2SV_blank>%d\\n" , ( int ) ( r * 255 ) , ( int ) ( g * 255 ) , ( int ) ( b * 255 ) ) ; <S2SV_EndBug> glClearColor ( r , g , b , 0 ) ; glClear ( GL_COLOR_BUFFER_BIT ) ; draw_bodies ( c , s . bodies , s . count ) ; SDL_GL_SwapWindow ( c . win ) ; <S2SV_StartBug> SDL_Delay ( 5 ) ; <S2SV_EndBug> printf ( "%llu\\n" , s . time ) ; SDL_Event e ; while ( SDL_PollEvent ( & e ) ) { switch ( e . type ) { case SDL_QUIT : SDL_GL_DeleteContext ( c . renderer ) ; SDL_DestroyWindow ( c . win ) ; exit ( 0 ) ; break ; case SDL_KEYDOWN : { SDL_KeyboardEvent key = e . key ; switch ( key . keysym . sym ) { case SDLK_d : { FILE * f = fopen ( "/Users/Thomas/treedump.txt" , "w" ) ; print_tree ( & s . tree , f ) ; fclose ( f ) ; puts ( "Writing<S2SV_blank>tree<S2SV_blank>dump" ) ; SDL_Delay ( 1000 ) ; break ; } <S2SV_StartBug> } <S2SV_EndBug> } default : break ; } } } } | <S2SV_ModStart> = 0 ; glClearColor ( r , g , b <S2SV_ModEnd> , 0 ) <S2SV_ModStart> SDL_Delay ( 5 <S2SV_ModEnd> ) ; SDL_Event <S2SV_ModStart> break ; } case SDLK_e : printf ( "Total<S2SV_blank>system<S2SV_blank>kinetic<S2SV_blank>energy:<S2SV_blank>%f\\n" , system_total_e ( & s ) ) ; break ; case SDLK_TAB : s = random_sys ( 1e10 , 1000 ) ; s . tree = build_tree ( s . bodies , 1000 ) ; break ; |
341 | CWE-000 static int mod_open ( void * instance , fr_schedule_t * sc , CONF_SECTION * conf ) { fr_listen_t * li ; proto_detail_t * inst = talloc_get_type_abort ( instance , proto_detail_t ) ; li = talloc_zero ( inst , fr_listen_t ) ; li -> app_io = inst -> app_io ; <S2SV_StartBug> li -> thread_instance = inst -> app_io_instance ; <S2SV_EndBug> li -> app_io_instance = li -> thread_instance ; li -> app = & proto_detail ; li -> app_instance = instance ; li -> server_cs = inst -> server_cs ; li -> default_message_size = inst -> max_packet_size ; li -> num_messages = inst -> num_messages ; if ( inst -> app_io -> open ( li ) < 0 ) { cf_log_err ( conf , "Failed<S2SV_blank>opening<S2SV_blank>%s<S2SV_blank>interface" , inst -> app_io -> name ) ; talloc_free ( li ) ; return - 1 ; } if ( strcmp ( inst -> io_submodule -> module -> name , "proto_detail_work" ) == 0 ) { if ( ! fr_schedule_listen_add ( sc , li ) ) { talloc_free ( li ) ; return - 1 ; } inst -> listen = li ; return 0 ; } if ( ! fr_schedule_directory_add ( sc , li ) ) { talloc_free ( li ) ; return - 1 ; } inst -> listen = li ; inst -> sc = sc ; return 0 ; } | <S2SV_ModStart> -> thread_instance = talloc_zero_array ( li , uint8_t , li -> app_io -> thread_inst_size ) ; talloc_set_name ( li -> thread_instance , "proto_%s_thread_t" , inst -> app_io -> name ) ; li -> app_io_instance = inst -> app_io_instance <S2SV_ModEnd> ; li -> |
342 | CWE-000 GHashTable * get_vendor_capability_hashtable ( JsonArray * jarray ) { GHashTable * ghashtable = g_hash_table_new ( NULL , NULL ) ; GList * vendor_capability_nodes = json_array_get_elements ( jarray ) ; while ( vendor_capability_nodes != NULL ) { JsonObject * jobject = json_node_get_object ( vendor_capability_nodes -> data ) ; g_assert ( jobject != NULL ) ; g_assert ( json_object_has_member ( jobject , "id" ) == TRUE ) ; g_assert ( json_object_has_member ( jobject , "select_cap" ) == TRUE ) ; const gchar * id = json_object_get_string_member ( jobject , "id" ) ; JsonNode * select_cap_node = json_object_get_member ( jobject , "select_cap" ) ; JsonObject * select_cap_obj = json_node_get_object ( select_cap_node ) ; JsonArray * options = get_array_from_json_object ( select_cap_obj , "option" ) ; GList * option_list = json_array_get_elements ( options ) ; GList * values = NULL ; while ( option_list != NULL ) { JsonObject * option_obj = json_node_get_object ( option_list -> data ) ; g_assert ( option_obj != NULL ) ; g_assert ( json_object_has_member ( option_obj , "value" ) == TRUE ) ; const gchar * value = json_object_get_string_member ( option_obj , "value" ) ; <S2SV_StartBug> values = g_list_append ( values , ( gpointer * ) value ) ; <S2SV_EndBug> option_list = option_list -> next ; } <S2SV_StartBug> g_hash_table_insert ( ghashtable , ( gpointer * ) id , ( gpointer * ) values ) ; <S2SV_EndBug> vendor_capability_nodes = vendor_capability_nodes -> next ; } return ghashtable ; } | <S2SV_ModStart> , ( gpointer <S2SV_ModEnd> ) value ) <S2SV_ModStart> , ( gpointer <S2SV_ModEnd> ) id , <S2SV_ModStart> , ( gpointer <S2SV_ModEnd> ) values ) |
343 | CWE-000 static int gmc_v9_0_sw_init ( void * handle ) { int r ; int dma_bits ; struct amdgpu_device * adev = ( struct amdgpu_device * ) handle ; spin_lock_init ( & adev -> mc . invalidate_lock ) ; if ( adev -> flags & AMD_IS_APU ) { adev -> mc . vram_type = AMDGPU_VRAM_TYPE_UNKNOWN ; <S2SV_StartBug> } else { <S2SV_EndBug> adev -> mc . vram_type = AMDGPU_VRAM_TYPE_HBM ; <S2SV_StartBug> } <S2SV_EndBug> r = amdgpu_irq_add_id ( adev , AMDGPU_IH_CLIENTID_VMC , 0 , & adev -> mc . vm_fault ) ; r = amdgpu_irq_add_id ( adev , AMDGPU_IH_CLIENTID_UTCL2 , 0 , & adev -> mc . vm_fault ) ; if ( r ) return r ; <S2SV_StartBug> if ( amdgpu_vm_size < 512 ) { <S2SV_EndBug> DRM_WARN ( "VM<S2SV_blank>size<S2SV_blank>is<S2SV_blank>at<S2SV_blank>least<S2SV_blank>512GB!\\n" ) ; amdgpu_vm_size = 512 ; } <S2SV_StartBug> adev -> vm_manager . max_pfn = ( uint64_t ) amdgpu_vm_size << 18 ; <S2SV_EndBug> adev -> mc . mc_mask = 0xffffffffffffULL ; adev -> need_dma32 = false ; dma_bits = adev -> need_dma32 ? 32 : 44 ; r = pci_set_dma_mask ( adev -> pdev , DMA_BIT_MASK ( dma_bits ) ) ; if ( r ) { adev -> need_dma32 = true ; dma_bits = 32 ; printk ( KERN_WARNING "amdgpu:<S2SV_blank>No<S2SV_blank>suitable<S2SV_blank>DMA<S2SV_blank>available.\\n" ) ; } r = pci_set_consistent_dma_mask ( adev -> pdev , DMA_BIT_MASK ( dma_bits ) ) ; if ( r ) { pci_set_consistent_dma_mask ( adev -> pdev , DMA_BIT_MASK ( 32 ) ) ; printk ( KERN_WARNING "amdgpu:<S2SV_blank>No<S2SV_blank>coherent<S2SV_blank>DMA<S2SV_blank>available.\\n" ) ; } r = gmc_v9_0_mc_init ( adev ) ; if ( r ) return r ; r = amdgpu_bo_init ( adev ) ; if ( r ) return r ; r = gmc_v9_0_gart_init ( adev ) ; if ( r ) return r ; if ( ! adev -> vm_manager . enabled ) { r = gmc_v9_0_vm_init ( adev ) ; if ( r ) { dev_err ( adev -> dev , "vm<S2SV_blank>manager<S2SV_blank>initialization<S2SV_blank>failed<S2SV_blank>(%d).\\n" , r ) ; return r ; } adev -> vm_manager . enabled = true ; } return r ; } | <S2SV_ModStart> = AMDGPU_VRAM_TYPE_UNKNOWN ; adev -> vm_manager . vm_size = amdgpu_vm_size ; adev -> vm_manager . block_size = amdgpu_vm_block_size ; <S2SV_ModStart> = AMDGPU_VRAM_TYPE_HBM ; adev -> vm_manager . vm_size = 1U << 18 ; adev -> vm_manager . block_size = 9 ; } DRM_INFO ( "vm<S2SV_blank>size<S2SV_blank>is<S2SV_blank>%llu<S2SV_blank>GB,<S2SV_blank>block<S2SV_blank>size<S2SV_blank>is<S2SV_blank>%d-bit\\n" , adev -> vm_manager . vm_size , adev -> vm_manager . block_size ) ; <S2SV_ModEnd> r = amdgpu_irq_add_id <S2SV_ModStart> return r ; <S2SV_ModEnd> adev -> vm_manager <S2SV_ModStart> . max_pfn = adev -> vm_manager . vm_size <S2SV_ModEnd> << 18 ; |
344 | CWE-000 enum nss_status _nss_mymachines_getgrgid_r ( gid_t gid , struct group * gr , char * buffer , size_t buflen , int * errnop ) { _cleanup_ ( sd_bus_error_free ) sd_bus_error error = SD_BUS_ERROR_NULL ; _cleanup_ ( sd_bus_message_unrefp ) sd_bus_message * reply = NULL ; _cleanup_ ( sd_bus_flush_close_unrefp ) sd_bus * bus = NULL ; const char * machine , * object ; uint32_t mapped ; int r ; BLOCK_SIGNALS ( NSS_SIGNALS_BLOCK ) ; if ( ! gid_is_valid ( gid ) ) goto not_found ; if ( gid < HOST_GID_LIMIT ) goto not_found ; if ( getenv_bool ( "SYSTEMD_NSS_BYPASS_BUS" ) > 0 ) goto not_found ; r = sd_bus_open_system ( & bus ) ; if ( r < 0 ) goto fail ; r = sd_bus_call_method ( bus , "org.freedesktop.machine1" , "/org/freedesktop/machine1" , "org.freedesktop.machine1.Manager" , "MapToMachineGroup" , & error , & reply , "u" , ( uint32_t ) gid ) ; if ( r < 0 ) { if ( sd_bus_error_has_name ( & error , BUS_ERROR_NO_SUCH_GROUP_MAPPING ) ) goto not_found ; goto fail ; } r = sd_bus_message_read ( reply , "sou" , & machine , & object , & mapped ) ; if ( r < 0 ) goto fail ; if ( mapped == gid ) goto not_found ; if ( buflen < sizeof ( char * ) + 1 ) { <S2SV_StartBug> * errnop = ENOMEM ; <S2SV_EndBug> return NSS_STATUS_TRYAGAIN ; } memzero ( buffer , sizeof ( char * ) ) ; if ( snprintf ( buffer + sizeof ( char * ) , buflen - sizeof ( char * ) , "vg-%s-" GID_FMT , machine , ( gid_t ) mapped ) >= ( int ) buflen ) { <S2SV_StartBug> * errnop = ENOMEM ; <S2SV_EndBug> return NSS_STATUS_TRYAGAIN ; } gr -> gr_name = buffer + sizeof ( char * ) ; gr -> gr_gid = gid ; gr -> gr_passwd = ( char * ) "*" ; gr -> gr_mem = ( char * * ) buffer ; * errnop = 0 ; return NSS_STATUS_SUCCESS ; not_found : * errnop = 0 ; return NSS_STATUS_NOTFOUND ; fail : * errnop = - r ; return NSS_STATUS_UNAVAIL ; } | <S2SV_ModStart> * errnop = ERANGE <S2SV_ModEnd> ; return NSS_STATUS_TRYAGAIN <S2SV_ModStart> * errnop = ERANGE <S2SV_ModEnd> ; return NSS_STATUS_TRYAGAIN |
345 | CWE-000 void TestPathJoin ( L_REGPARAMS * rp , const char * first , const char * second , const char * result ) { char * newfirst = NULL ; char * newsecond = NULL ; char * newpath = NULL ; <S2SV_StartBug> char * path = pathJoin ( first , second ) ; <S2SV_EndBug> regTestCompareStrings ( rp , ( l_uint8 * ) result , strlen ( result ) , ( l_uint8 * ) path , strlen ( path ) ) ; if ( first && first [ 0 ] == '\\0' ) newfirst = stringNew ( "\\"\\"" ) ; else if ( first ) newfirst = stringNew ( first ) ; if ( second && second [ 0 ] == '\\0' ) newsecond = stringNew ( "\\"\\"" ) ; else if ( second ) newsecond = stringNew ( second ) ; if ( path && path [ 0 ] == '\\0' ) newpath = stringNew ( "\\"\\"" ) ; else if ( path ) newpath = stringNew ( path ) ; if ( rp -> display ) fprintf ( stderr , "join:<S2SV_blank>%s<S2SV_blank>+<S2SV_blank>%s<S2SV_blank>--><S2SV_blank>%s\\n" , newfirst , newsecond , newpath ) ; lept_free ( path ) ; lept_free ( newfirst ) ; lept_free ( newsecond ) ; lept_free ( newpath ) ; return ; } | <S2SV_ModStart> * path = NULL ; if ( ( path = <S2SV_ModStart> , second ) ) == NULL ) return |
346 | CWE-000 static void create_bucket_callback ( uv_work_t * work_req , int status ) { assert ( status == 0 ) ; json_request_t * req = work_req -> data ; if ( req -> status_code != 201 ) { printf ( "Request<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>status<S2SV_blank>code:<S2SV_blank>%i\\n" , req -> status_code ) ; } if ( req -> response == NULL ) { free ( req ) ; free ( work_req ) ; printf ( "Failed<S2SV_blank>to<S2SV_blank>add<S2SV_blank>bucket.\\n" ) ; exit ( 1 ) ; } struct json_object * bucket ; struct json_object * id ; struct json_object * name ; struct json_object * storage ; struct json_object * transfer ; json_object_object_get_ex ( req -> response , "id" , & id ) ; json_object_object_get_ex ( req -> response , "name" , & name ) ; json_object_object_get_ex ( req -> response , "storage" , & storage ) ; json_object_object_get_ex ( req -> response , "transfer" , & transfer ) ; printf ( "ID:<S2SV_blank>\\"%s\\",<S2SV_blank>Name:<S2SV_blank>%s,<S2SV_blank>Storage:<S2SV_blank>%s,<S2SV_blank>Transfer:<S2SV_blank>%s\\n" , json_object_get_string ( id ) , json_object_get_string ( name ) , json_object_get_string ( storage ) , json_object_get_string ( transfer ) ) ; json_object_put ( req -> response ) ; <S2SV_StartBug> free ( req ) ; <S2SV_EndBug> free ( work_req ) ; } | <S2SV_ModStart> response ) ; json_object_put ( req -> body ) ; |
347 | CWE-000 static int nvavp_load_os ( struct nvavp_info * nvavp , char * fw_os_file ) { struct nvavp_os_info * os_info = & nvavp -> os_info ; const struct firmware * nvavp_os_fw ; void * ptr ; u32 size ; int ret = 0 ; <S2SV_StartBug> u32 max_index = 0 ; <S2SV_EndBug> if ( ! os_info -> os_bin ) { ret = request_firmware ( & nvavp_os_fw , fw_os_file , nvavp -> video_misc_dev . this_device ) ; if ( ret ) { dev_err ( & nvavp -> nvhost_dev -> dev , "cannot<S2SV_blank>read<S2SV_blank>os<S2SV_blank>firmware<S2SV_blank>\'%s\'\\n" , fw_os_file ) ; goto err_req_fw ; } dev_info ( & nvavp -> nvhost_dev -> dev , "read<S2SV_blank>firmware<S2SV_blank>from<S2SV_blank>\'%s\'<S2SV_blank>(%d<S2SV_blank>bytes)\\n" , fw_os_file , nvavp_os_fw -> size ) ; ptr = ( void * ) nvavp_os_fw -> data ; if ( strncmp ( ( const char * ) ptr , "NVAVP-OS" , 8 ) ) { dev_info ( & nvavp -> nvhost_dev -> dev , "os<S2SV_blank>hdr<S2SV_blank>string<S2SV_blank>mismatch\\n" ) ; ret = - EINVAL ; goto err_os_bin ; } ptr += 8 ; os_info -> entry_offset = * ( ( u32 * ) ptr ) ; ptr += sizeof ( u32 ) ; os_info -> control_offset = * ( ( u32 * ) ptr ) ; ptr += sizeof ( u32 ) ; os_info -> debug_offset = * ( ( u32 * ) ptr ) ; ptr += sizeof ( u32 ) ; size = * ( ( u32 * ) ptr ) ; ptr += sizeof ( u32 ) ; os_info -> size = size ; os_info -> os_bin = kzalloc ( os_info -> size , GFP_KERNEL ) ; if ( ! os_info -> os_bin ) { dev_err ( & nvavp -> nvhost_dev -> dev , "cannot<S2SV_blank>allocate<S2SV_blank>os<S2SV_blank>bin\\n" ) ; ret = - ENOMEM ; goto err_os_bin ; } memcpy ( os_info -> os_bin , ptr , os_info -> size ) ; memset ( os_info -> data + os_info -> size , 0 , SZ_1M - os_info -> size ) ; dev_info ( & nvavp -> nvhost_dev -> dev , "entry=%08x<S2SV_blank>control=%08x<S2SV_blank>debug=%08x<S2SV_blank>size=%d\\n" , os_info -> entry_offset , os_info -> control_offset , os_info -> debug_offset , os_info -> size ) ; release_firmware ( nvavp_os_fw ) ; } memcpy ( os_info -> data , os_info -> os_bin , os_info -> size ) ; os_info -> reset_addr = os_info -> phys + os_info -> entry_offset ; dev_info ( & nvavp -> nvhost_dev -> dev , "AVP<S2SV_blank>os<S2SV_blank>at<S2SV_blank>vaddr=%p<S2SV_blank>paddr=%lx<S2SV_blank>reset_addr=%p\\n" , os_info -> data , ( unsigned long ) ( os_info -> phys ) , ( void * ) os_info -> reset_addr ) ; return 0 ; err_os_bin : release_firmware ( nvavp_os_fw ) ; err_req_fw : return ret ; } | <S2SV_ModStart> = 0 ; <S2SV_ModEnd> if ( ! |
348 | CWE-000 int32_t rasterizer_winopen ( char * title ) { int dev_mem = open ( "/dev/mem" , O_RDWR ) ; if ( dev_mem == 0 ) { perror ( "open" ) ; exit ( EXIT_FAILURE ) ; } fpga_manager_base = ( uint8_t * ) mmap ( 0 , 64 , PROT_READ | PROT_WRITE , MAP_SHARED , dev_mem , FPGA_MANAGER_BASE ) ; if ( fpga_manager_base == 0 ) { perror ( "mmap<S2SV_blank>for<S2SV_blank>gpu<S2SV_blank>manager<S2SV_blank>base" ) ; exit ( EXIT_FAILURE ) ; } fpga_gpo = ( uint32_t * ) ( fpga_manager_base + FPGA_GPO_OFFSET ) ; fpga_gpi = ( uint32_t * ) ( fpga_manager_base + FPGA_GPI_OFFSET ) ; gpu_buffers_base = ( uint8_t * ) mmap ( 0 , RAM_SIZE - BASE , PROT_READ | PROT_WRITE , MAP_SHARED , dev_mem , BASE ) ; if ( gpu_buffers_base == 0 ) { perror ( "mmap<S2SV_blank>for<S2SV_blank>buffers" ) ; exit ( EXIT_FAILURE ) ; } gpu_protocol_next = gpu_protocol_buffer = <S2SV_StartBug> ( uint64_t * ) ( buffers_base + PROTOCOL_BUFFER_OFFSET ) ; <S2SV_EndBug> gpu_frame_start ( ) ; <S2SV_StartBug> counter = 0 ; <S2SV_EndBug> } | <S2SV_ModStart> * ) ( gpu_buffers_base <S2SV_ModEnd> + PROTOCOL_BUFFER_OFFSET ) <S2SV_ModStart> ( ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
349 | CWE-000 static eARDISCOVERY_ERROR ARDISCOVERY_Socket_Connect ( int sockfd , const struct sockaddr * addr , socklen_t addrlen ) { eARDISCOVERY_ERROR error = ARDISCOVERY_OK ; int connectError = ARSAL_Socket_Connect ( sockfd , addr , addrlen ) ; if ( connectError != 0 ) { <S2SV_StartBug> switch ( errno ) <S2SV_EndBug> { case EINPROGRESS : break ; case EACCES : error = ARDISCOVERY_ERROR_SOCKET_PERMISSION_DENIED ; break ; case ENETUNREACH : case EHOSTUNREACH : <S2SV_StartBug> ARSAL_PRINT ( ARSAL_PRINT_ERROR , ARDISCOVERY_CONNECTION_TAG , "connect()<S2SV_blank>failed:<S2SV_blank>%d<S2SV_blank>%s<S2SV_blank>=><S2SV_blank>Try<S2SV_blank>reconnecting<S2SV_blank>after<S2SV_blank>%d<S2SV_blank>seconds" , errno , strerror ( errno ) , ARDISCOVERY_RECONNECTION_TIME_SEC ) ; <S2SV_EndBug> error = ARDISCOVERY_ERROR_SOCKET_UNREACHABLE ; break ; default : error = ARDISCOVERY_ERROR ; break ; } if ( error != ARDISCOVERY_OK ) { <S2SV_StartBug> ARSAL_PRINT ( ARSAL_PRINT_ERROR , ARDISCOVERY_CONNECTION_TAG , "connect()<S2SV_blank>failed:<S2SV_blank>%d<S2SV_blank>%s" , errno , strerror ( errno ) ) ; <S2SV_EndBug> } } return error ; } | <S2SV_ModStart> 0 ) { connectError = errno ; switch ( connectError <S2SV_ModEnd> ) { case <S2SV_ModStart> , "connect()<S2SV_blank>failed:<S2SV_blank>%d<S2SV_blank>%s<S2SV_blank>=><S2SV_blank>Try<S2SV_blank>reconnecting<S2SV_blank>after<S2SV_blank>%d<S2SV_blank>seconds" , connectError <S2SV_ModEnd> , strerror ( <S2SV_ModStart> , strerror ( connectError <S2SV_ModEnd> ) , ARDISCOVERY_RECONNECTION_TIME_SEC <S2SV_ModStart> , "connect()<S2SV_blank>failed:<S2SV_blank>%d<S2SV_blank>%s" , connectError <S2SV_ModEnd> , strerror ( <S2SV_ModStart> , strerror ( connectError <S2SV_ModEnd> ) ) ; |
350 | CWE-000 int work_with_width ( char * s , int i , int num , int decimal ) { int is_real ; is_real = 0 ; i = - 1 ; while ( s [ ++ i ] ) { if ( modificator_is_real ( s [ i ] ) == 1 ) <S2SV_StartBug> return ( num ) ; <S2SV_EndBug> if ( ( s [ i ] >= '0' && s [ i ] <= '9' ) || s [ i ] == '.' ) { if ( s [ i ] == '.' ) return ( num ) ; if ( decimal >= 1 ) num *= 10 ; num += ( s [ i ] - 48 ) ; decimal ++ ; } if ( is_width_real ( s [ i ] ) == 1 && is_real == 0 ) { <S2SV_StartBug> break ; <S2SV_EndBug> is_real = 1 ; } } return ( ( is_real == 0 ) ? num : 0 ) ; } | <S2SV_ModStart> return ( num ) ; if ( s [ i ] == '%' ) return ( 0 <S2SV_ModStart> 0 ) { is_real = 1 ; break ; <S2SV_ModEnd> } } return |
351 | CWE-000 int thread_create ( task_t * new_task ) { <S2SV_StartBug> unsigned indicies_size = CHAN_IN1 ( unsigned , size , INDICIES_CH ) ; <S2SV_EndBug> thread_state_t new_thread ; if ( curr_free_index < indicies_size ) { new_thread . thread . context . task = new_task ; new_thread . thread . context . time = 0 ; new_thread . thread . context . next_ctx = NULL ; <S2SV_StartBug> CHAN_OUT1 ( thread_state_t , threads [ curr_free_index ] , <S2SV_EndBug> THREAD_ARRAY_CH ) ; curr_free_index ++ ; return 0 ; } return - 1 ; } | <S2SV_ModStart> unsigned indicies_size = * <S2SV_ModStart> curr_free_index ] , new_thread , |
352 | CWE-000 int sicm_is_near ( struct sicm_device * device ) { int dist ; switch ( device -> tag ) { case SICM_DRAM : dist = numa_distance ( sicm_numa_id ( device ) , numa_node_of_cpu ( sched_getcpu ( ) ) ) ; return dist == 10 ; case SICM_KNL_HBM : dist = numa_distance ( sicm_numa_id ( device ) , numa_node_of_cpu ( sched_getcpu ( ) ) ) ; return dist == 31 ; <S2SV_StartBug> default : <S2SV_EndBug> return 0 ; } } | <S2SV_ModStart> == 31 ; case SICM_POWERPC_HBM : dist = numa_distance ( sicm_numa_id ( device ) , numa_node_of_cpu ( sched_getcpu ( ) ) ) ; return dist == 80 ; |
353 | CWE-000 static int gpio_rda5981a_init ( struct device * dev ) { IRQ_CONNECT ( GPIO_IRQ , CONFIG_GPIO_RDA5981A_PORT_PRI , gpio_rda5981a_port_isr , DEVICE_GET ( gpio_rda5981a ) , 0 ) ; irq_enable ( GPIO_IRQ ) ; <S2SV_StartBug> # if SPLASH_LED <S2SV_EndBug> k_thread_spawn ( & splash_stack [ 0 ] , SPLASH_STACK_SIZE , ( k_thread_entry_t ) splash , dev , NULL , NULL , K_PRIO_COOP ( 10 ) , 0 , K_MSEC ( 500 ) ) ; # endif return 0 ; } | <S2SV_ModStart> GPIO_IRQ ) ; <S2SV_ModEnd> return 0 ; |
354 | CWE-000 void ft_uchar ( unsigned int c ) { <S2SV_StartBug> int active_bits ; <S2SV_EndBug> unsigned char byte [ 4 ] ; <S2SV_StartBug> unsigned char octet ; <S2SV_EndBug> active_bits = count_active_bits ( c ) ; <S2SV_StartBug> if ( active_bits <= 7 ) <S2SV_EndBug> write ( 1 , & c , 1 ) ; <S2SV_StartBug> else if ( active_bits <= 11 ) <S2SV_EndBug> { byte [ 1 ] = ( c << 26 ) >> 26 ; byte [ 0 ] = ( ( c >> 6 ) << 27 ) >> 27 ; octet = ( MASK1 >> 8 ) | byte [ 0 ] ; write ( 1 , & octet , 1 ) ; octet = ( ( MASK1 << 24 ) >> 24 ) | byte [ 1 ] ; write ( 1 , & octet , 1 ) ; } <S2SV_StartBug> else if ( active_bits <= 16 ) <S2SV_EndBug> three_bytes ( c , byte ) ; else four_bytes ( c , byte ) ; } | <S2SV_ModStart> ) { int active_bytes ; unsigned int <S2SV_ModEnd> byte [ 4 <S2SV_ModStart> ] ; unsigned int octet ; active_bytes = ft_count_active_bytes <S2SV_ModEnd> ( c ) <S2SV_ModStart> ; if ( active_bytes == 1 <S2SV_ModEnd> ) write ( <S2SV_ModStart> else if ( active_bytes == 2 <S2SV_ModEnd> ) { byte <S2SV_ModStart> else if ( active_bytes == 3 <S2SV_ModEnd> ) three_bytes ( |
355 | CWE-000 <S2SV_StartBug> static main_node_t * cnode_update ( main_node_t * main_node , int pos , int key , int value ) <S2SV_EndBug> { DEBUG ( "updating<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>to<S2SV_blank>cnode<S2SV_blank>%p" , key , value , main_node ) ; <S2SV_StartBug> return cnode_insert ( main_node , pos , 0 , key , value ) ; <S2SV_EndBug> } | <S2SV_ModStart> * cnode_update ( volatile <S2SV_ModStart> , int value , branch_t * * new_branch <S2SV_ModStart> key , value , new_branch |
356 | CWE-000 void GameStateMainMenuInit ( ) <S2SV_StartBug> { <S2SV_EndBug> printf ( "GAM100<S2SV_blank>Game\\n" ) ; printf ( "Select<S2SV_blank>an<S2SV_blank>option:\\n(P)lay\\n(Q)uit\\n" ) ; } | <S2SV_ModStart> ( ) { FILE * chp ; chp = fopen ( "chp.txt" , "w" ) ; char ch ; if ( chp == NULL ) { printf ( "Cannot<S2SV_blank>open<S2SV_blank>file<S2SV_blank>for<S2SV_blank>writing.\\n" ) ; exit ( 0 ) ; } fprintf ( chp , "%c" , '/' ) ; fclose ( chp ) ; |
357 | CWE-000 static int afiucv_hs_rcv ( struct sk_buff * skb , struct net_device * dev , struct packet_type * pt , struct net_device * orig_dev ) { struct sock * sk ; struct iucv_sock * iucv ; struct af_iucv_trans_hdr * trans_hdr ; <S2SV_StartBug> char nullstring [ 8 ] ; <S2SV_EndBug> <S2SV_StartBug> int err = 0 ; <S2SV_EndBug> if ( skb -> len < ( ETH_HLEN + sizeof ( struct af_iucv_trans_hdr ) ) ) { WARN_ONCE ( 1 , "AF_IUCV<S2SV_blank>too<S2SV_blank>short<S2SV_blank>skb,<S2SV_blank>len=%d,<S2SV_blank>min=%d" , ( int ) skb -> len , ( int ) ( ETH_HLEN + sizeof ( struct af_iucv_trans_hdr ) ) ) ; kfree_skb ( skb ) ; return NET_RX_SUCCESS ; } if ( skb_headlen ( skb ) < ( ETH_HLEN + sizeof ( struct af_iucv_trans_hdr ) ) ) if ( skb_linearize ( skb ) ) { WARN_ONCE ( 1 , "AF_IUCV<S2SV_blank>skb_linearize<S2SV_blank>failed,<S2SV_blank>len=%d" , ( int ) skb -> len ) ; kfree_skb ( skb ) ; return NET_RX_SUCCESS ; } skb_pull ( skb , ETH_HLEN ) ; trans_hdr = ( struct af_iucv_trans_hdr * ) skb -> data ; EBCASC ( trans_hdr -> destAppName , sizeof ( trans_hdr -> destAppName ) ) ; EBCASC ( trans_hdr -> destUserID , sizeof ( trans_hdr -> destUserID ) ) ; EBCASC ( trans_hdr -> srcAppName , sizeof ( trans_hdr -> srcAppName ) ) ; EBCASC ( trans_hdr -> srcUserID , sizeof ( trans_hdr -> srcUserID ) ) ; memset ( nullstring , 0 , sizeof ( nullstring ) ) ; iucv = NULL ; sk = NULL ; read_lock ( & iucv_sk_list . lock ) ; sk_for_each ( sk , & iucv_sk_list . head ) { if ( trans_hdr -> flags == AF_IUCV_FLAG_SYN ) { if ( ( ! memcmp ( & iucv_sk ( sk ) -> src_name , trans_hdr -> destAppName , 8 ) ) && ( ! memcmp ( & iucv_sk ( sk ) -> src_user_id , trans_hdr -> destUserID , 8 ) ) && ( ! memcmp ( & iucv_sk ( sk ) -> dst_name , nullstring , 8 ) ) && ( ! memcmp ( & iucv_sk ( sk ) -> dst_user_id , nullstring , 8 ) ) ) { iucv = iucv_sk ( sk ) ; break ; } } else { if ( ( ! memcmp ( & iucv_sk ( sk ) -> src_name , trans_hdr -> destAppName , 8 ) ) && ( ! memcmp ( & iucv_sk ( sk ) -> src_user_id , trans_hdr -> destUserID , 8 ) ) && ( ! memcmp ( & iucv_sk ( sk ) -> dst_name , trans_hdr -> srcAppName , 8 ) ) && ( ! memcmp ( & iucv_sk ( sk ) -> dst_user_id , trans_hdr -> srcUserID , 8 ) ) ) { iucv = iucv_sk ( sk ) ; break ; } } } read_unlock ( & iucv_sk_list . lock ) ; if ( ! iucv ) sk = NULL ; switch ( trans_hdr -> flags ) { case AF_IUCV_FLAG_SYN : err = afiucv_hs_callback_syn ( sk , skb ) ; break ; case ( AF_IUCV_FLAG_SYN | AF_IUCV_FLAG_ACK ) : err = afiucv_hs_callback_synack ( sk , skb ) ; break ; case ( AF_IUCV_FLAG_SYN | AF_IUCV_FLAG_FIN ) : err = afiucv_hs_callback_synfin ( sk , skb ) ; break ; case ( AF_IUCV_FLAG_FIN ) : err = afiucv_hs_callback_fin ( sk , skb ) ; break ; case ( AF_IUCV_FLAG_WIN ) : err = afiucv_hs_callback_win ( sk , skb ) ; if ( skb -> len == sizeof ( struct af_iucv_trans_hdr ) ) { kfree_skb ( skb ) ; break ; } case ( AF_IUCV_FLAG_SHT ) : case 0 : IUCV_SKB_CB ( skb ) -> class = trans_hdr -> iucv_hdr . class ; err = afiucv_hs_callback_rx ( sk , skb ) ; break ; default : <S2SV_StartBug> ; <S2SV_EndBug> } return err ; } | <S2SV_ModStart> * trans_hdr ; int err = NET_RX_SUCCESS ; <S2SV_ModStart> 8 ] ; <S2SV_ModEnd> if ( skb <S2SV_ModStart> ; default : kfree_skb ( skb ) |
358 | CWE-000 static void update_node ( TreeNode * node ) { if ( node -> level == 0 ) { double max_pt = max_point ( * node -> bodies , node -> nbodies ) ; if ( 2 * max_pt > node -> max . x ) { <S2SV_StartBug> node -> max = ( vec3 ) ( 10 * max_pt ) ; <S2SV_EndBug> node -> min = - node -> max ; node -> resized = true ; printf ( "Resizing<S2SV_blank>tree!<S2SV_blank>New<S2SV_blank>max<S2SV_blank>is<S2SV_blank>%f\\n" , max_pt ) ; } } if ( node -> nodes == NULL ) { node -> nodes = calloc ( 8 , sizeof ( TreeNode ) ) ; for ( uint i = 0 ; i < 8 ; i ++ ) { TreeNode * child_node = & node -> nodes [ i ] ; node -> resized = true ; child_node -> bodies = calloc ( sizeof ( Body * ) , node -> nbodies ) ; child_node -> nodes = NULL ; child_node -> capacity = node -> nbodies ; child_node -> nbodies = 0 ; child_node -> level = node -> level + 1 ; child_node -> initialized = true ; } } if ( node -> resized ) { for ( uint i = 0 ; i < 8 ; i ++ ) { TreeNode * child = & node -> nodes [ i ] ; child -> resized = true ; child -> min = node_min_point ( node -> min , node -> divs , i ) ; child -> max = child -> min + ( node -> max - node -> divs ) ; child -> divs = ( child -> max + child -> min ) * 0.5 ; } } for ( uint i = 0 ; i < 8 ; i ++ ) { if ( node -> nodes [ i ] . initialized ) { memset ( node -> nodes [ i ] . bodies , 0x0 , sizeof ( Body * ) * node -> nodes [ i ] . capacity ) ; node -> nodes [ i ] . nbodies = 0 ; node -> nodes [ i ] . mass = 0 ; } } for ( uint i = 0 ; i < node -> nbodies ; i ++ ) { vec3 tpos = node -> bodies [ i ] -> pos ; vec3 tdivs = node -> divs ; uint8_t index = coord_to_index ( tpos , tdivs ) ; TreeNode * child_node = & node -> nodes [ index ] ; if ( child_node -> nbodies == child_node -> capacity ) { child_node -> bodies = realloc ( child_node -> bodies , ( 2 * sizeof ( Body * ) * child_node -> capacity ) ) ; child_node -> capacity *= 2 ; } child_node -> bodies [ child_node -> nbodies ] = node -> bodies [ i ] ; child_node -> nbodies ++ ; # ifdef UNIT_MASS child_node -> mass ++ ; # else child_node -> mass += node -> bodies [ i ] -> mass ; # endif } for ( uint i = 0 ; i < 8 ; i ++ ) { node -> nodes [ i ] . ctr_mass = center_of_mass ( & node -> nodes [ i ] ) ; if ( node -> nodes [ i ] . nbodies > 1 ) { update_node ( & node -> nodes [ i ] ) ; } } } | <S2SV_ModStart> x ) { assert ( max_pt > 0 ) ; |
359 | CWE-000 static void Kernel_Send ( ) { CH * channel_ptr = & Channels [ channel_buffer . id ] ; if ( channel_ptr -> receivers . head == NULL ) { if ( channel_ptr -> sender != NULL ) { } channel_ptr -> sender = Cp ; Cp -> state = WAITING ; channel_ptr -> val = channel_buffer . val ; Kernel_Dispatch ( ) ; } else { <S2SV_StartBug> PD * recv_process = Dequeue ( channel_ptr -> receivers ) ; <S2SV_EndBug> while ( recv_process != NULL ) { recv_process -> state = READY ; recv_process -> retval = channel_ptr -> val ; EnqueueTaskToStateQueue ( recv_process ) ; <S2SV_StartBug> recv_process = Dequeue ( channel_ptr -> receivers ) ; <S2SV_EndBug> } } } | <S2SV_ModStart> = Dequeue ( & <S2SV_ModStart> = Dequeue ( & |
360 | CWE-000 void drawSolid ( entity * object ) { int i , j ; for ( i = 0 ; i <= ( object -> sizeX ) ; i ++ ) { for ( j = 0 ; j <= ( object -> sizeY ) ; j ++ ) { <S2SV_StartBug> gotoxy ( 1814_TO_INT ( object -> x1 + i ) , 1814_TO_INT ( object -> y1 ) + j ) ; <S2SV_EndBug> printf ( "%c" , SOLIDTEXTURE ) ; } } object -> changedSinceLast = 0 ; } | <S2SV_ModStart> { gotoxy ( EIGHTEEN_FOURTEEN_TO_INT <S2SV_ModEnd> ( object -> <S2SV_ModStart> i ) , EIGHTEEN_FOURTEEN_TO_INT <S2SV_ModEnd> ( object -> |
361 | CWE-000 ode_solver_t * functional_am_ode_solver_new ( int order , MPI_Comm comm , int num_local_values , int num_remote_values , <S2SV_StartBug> void * context , <S2SV_EndBug> int ( * rhs ) ( void * context , real_t t , real_t * U , real_t * U_dot ) , void ( * dtor ) ( void * context ) ) { ASSERT ( order >= 1 ) ; ASSERT ( order <= 12 ) ; ASSERT ( num_local_values > 0 ) ; ASSERT ( num_remote_values >= 0 ) ; ASSERT ( rhs != NULL ) ; am_ode_t * solver = polymec_malloc ( sizeof ( am_ode_t ) ) ; solver -> comm = comm ; solver -> num_local_values = num_local_values ; solver -> num_remote_values = num_remote_values ; solver -> context = context ; solver -> rhs = rhs ; solver -> dtor = dtor ; solver -> status_message = NULL ; solver -> max_krylov_dim = 0 ; solver -> Jy = NULL ; solver -> precond = NULL ; solver -> observers = ptr_array_new ( ) ; solver -> error_weights = NULL ; solver -> U = N_VNew ( solver -> comm , solver -> num_local_values ) ; solver -> U_with_ghosts = polymec_malloc ( sizeof ( real_t ) * ( solver -> num_local_values + solver -> num_remote_values ) ) ; solver -> cvode = CVodeCreate ( CV_ADAMS ) ; CVodeSetMaxOrd ( solver -> cvode , order ) ; CVodeSetUserData ( solver -> cvode , solver ) ; CVodeInit ( solver -> cvode , am_evaluate_rhs , 0.0 , solver -> U ) ; <S2SV_StartBug> int num_accels ; <S2SV_EndBug> <S2SV_StartBug> SUNNonlinearSolver nls = SUNNonlinSol_FixedPoint ( solver -> U , num_accels ) ; <S2SV_EndBug> <S2SV_StartBug> CVodeSetNonlinearSolver ( solver -> cvode , nls ) ; <S2SV_EndBug> ode_solver_vtable vtable = { . step = am_step , . advance = am_advance , . reset = am_reset , . dtor = am_dtor } ; char name [ 1024 ] ; snprintf ( name , 1024 , "Functional<S2SV_blank>Adams-Moulton<S2SV_blank>(order<S2SV_blank>%d)" , order ) ; ode_solver_t * I = ode_solver_new ( name , solver , vtable , order , num_local_values + num_remote_values ) ; am_ode_solver_set_tolerances ( I , 1e-4 , 1.0 ) ; return I ; } | <S2SV_ModStart> int num_remote_values , int num_accel_vectors , <S2SV_ModStart> U ) ; solver -> <S2SV_ModEnd> nls = SUNNonlinSol_FixedPoint <S2SV_ModStart> -> U , num_accel_vectors <S2SV_ModEnd> ) ; CVodeSetNonlinearSolver <S2SV_ModStart> -> cvode , solver -> |
362 | CWE-000 RList * PE_ ( r_bin_mdmp_pe_get_imports ) ( struct PE_ ( r_bin_mdmp_pe_bin ) * pe_bin ) { int i ; ut64 offset ; struct r_bin_pe_import_t * imports = NULL ; RBinImport * ptr = NULL ; RBinReloc * rel ; RList * ret , * relocs ; if ( ! ( imports = PE_ ( r_bin_pe_get_imports ) ( pe_bin -> bin ) ) ) { return NULL ; } if ( ! ( ret = r_list_new ( ) ) ) { return NULL ; } if ( ! ( relocs = r_list_newf ( free ) ) ) { free ( ret ) ; return NULL ; } pe_bin -> bin -> relocs = relocs ; for ( i = 0 ; ! imports [ i ] . last ; i ++ ) { if ( ! ( ptr = R_NEW0 ( RBinImport ) ) ) { break ; } filter_import ( imports [ i ] . name ) ; ptr -> name = strdup ( ( char * ) imports [ i ] . name ) ; ptr -> bind = r_str_const ( "NONE" ) ; <S2SV_StartBug> ptr -> type = r_str_const ( "FUNC" ) ; <S2SV_EndBug> ptr -> ordinal = imports [ i ] . ordinal ; r_list_append ( ret , ptr ) ; if ( ! ( rel = R_NEW0 ( RBinReloc ) ) ) { break ; } # ifdef R_BIN_PE64 rel -> type = R_BIN_RELOC_64 ; # else rel -> type = R_BIN_RELOC_32 ; # endif offset = imports [ i ] . vaddr ; if ( offset > pe_bin -> vaddr ) { offset -= pe_bin -> vaddr ; } rel -> additive = 0 ; rel -> import = ptr ; rel -> addend = 0 ; rel -> vaddr = offset + pe_bin -> vaddr ; rel -> paddr = imports [ i ] . paddr + pe_bin -> paddr ; r_list_append ( relocs , rel ) ; } free ( imports ) ; return ret ; } | <S2SV_ModStart> = r_str_const ( R_BIN_TYPE_FUNC_STR <S2SV_ModEnd> ) ; ptr |
363 | CWE-000 matrix_t * mean_normalization ( matrix_t * mat , matrix_t * min_max_mean ) { <S2SV_StartBug> return_null_or_exit_if_invalid ( mat ) ; <S2SV_EndBug> matrix_t * normalized_mat = copy_matrix ( mat ) ; return_null_or_exit_if_invalid ( normalized_mat ) ; mat_i_t min = 0 ; mat_i_t max = 1 ; mat_i_t mean = 2 ; print_matrix ( min_max_mean ) ; mat_col_iter ( normalized_mat , c ) { mat_data_t mean_value = idx ( min_max_mean , mean , c ) ; mat_data_t max_minus_min = idx ( min_max_mean , max , c ) - idx ( min_max_mean , min , c ) ; if ( is_close ( max_minus_min , 0 ) ) { max_minus_min = 1 ; } mat_row_iter ( normalized_mat , r ) { idx ( normalized_mat , r , c ) -= mean_value ; idx ( normalized_mat , r , c ) /= max_minus_min ; } } return normalized_mat ; } | <S2SV_ModStart> mat ) ; if ( ! is_valid_matrix ( min_max_mean ) || cols ( min_max_mean ) != cols ( mat ) || rows ( min_max_mean ) != 3 ) { debug_printf ( "%lu<S2SV_blank>x<S2SV_blank>%lu<S2SV_blank>min_max_mean<S2SV_blank>matrix<S2SV_blank>is<S2SV_blank>invalid<S2SV_blank>for<S2SV_blank>%lu<S2SV_blank>x<S2SV_blank>%lu<S2SV_blank>matrix.\\n" , rows ( min_max_mean ) , cols ( min_max_mean ) , rows ( mat ) , cols ( mat ) ) ; return_null_or_exit ; } |
364 | CWE-000 void VivSolid ( PixmapPtr pPixmap , int x1 , int y1 , int x2 , int y2 ) { TRACE_ENTER ( ) ; VivPtr pViv = VIVPTR_FROM_PIXMAP ( pPixmap ) ; Viv2DPixmapPtr pdst = exaGetPixmapDriverPrivate ( pPixmap ) ; pViv -> mGrCtx . mBlitInfo . mDstBox . x1 = x1 ; pViv -> mGrCtx . mBlitInfo . mDstBox . y1 = y1 ; pViv -> mGrCtx . mBlitInfo . mDstBox . x2 = x2 ; pViv -> mGrCtx . mBlitInfo . mDstBox . y2 = y2 ; pViv -> mGrCtx . mBlitInfo . mSwsolid = FALSE ; <S2SV_StartBug> if ( ( x2 - x1 ) * ( y2 - y1 ) < IMX_EXA_NONCACHESURF_SIZE ) <S2SV_EndBug> { pViv -> mGrCtx . mBlitInfo . mSwsolid = TRUE ; pdst -> mCpuBusy = TRUE ; gcmASSERT ( ( pViv -> mGrCtx . mBlitInfo . mDstSurfInfo . mStride % 4 ) == 0 ) ; pixman_fill ( ( uint32_t * ) MapViv2DPixmap ( pdst ) , pViv -> mGrCtx . mBlitInfo . mDstSurfInfo . mStride / 4 , pViv -> mGrCtx . mBlitInfo . mDstSurfInfo . mFormat . mBpp , x1 , y1 , x2 - x1 , y2 - y1 , pViv -> mGrCtx . mBlitInfo . mColorARGB32 ) ; TRACE_EXIT ( ) ; } if ( pdst -> mCpuBusy ) { VIV2DCacheOperation ( & pViv -> mGrCtx , pdst , FLUSH ) ; pdst -> mCpuBusy = FALSE ; } if ( ! SetDestinationSurface ( & pViv -> mGrCtx ) ) { TRACE_ERROR ( "Solid<S2SV_blank>Blit<S2SV_blank>Failed\\n" ) ; } if ( ! SetClipping ( & pViv -> mGrCtx ) ) { TRACE_ERROR ( "Solid<S2SV_blank>Blit<S2SV_blank>Failed\\n" ) ; } if ( ! SetSolidBrush ( & pViv -> mGrCtx ) ) { TRACE_ERROR ( "Solid<S2SV_blank>Blit<S2SV_blank>Failed\\n" ) ; } if ( ! DoSolidBlit ( & pViv -> mGrCtx ) ) { TRACE_ERROR ( "Solid<S2SV_blank>Blit<S2SV_blank>Failed\\n" ) ; } TRACE_EXIT ( ) ; } | <S2SV_ModStart> y1 ) < SUB_FILL_SIZE <S2SV_ModEnd> ) { pViv |
365 | CWE-000 static void check_local_shadow ( tree decl ) { if ( TREE_CODE ( decl ) == PARM_DECL && ! DECL_CONTEXT ( decl ) ) return ; if ( DECL_FROM_INLINE ( decl ) ) return ; if ( DECL_EXTERNAL ( decl ) ) return ; tree old = NULL_TREE ; cp_binding_level * old_scope = NULL ; if ( cxx_binding * binding = outer_binding ( DECL_NAME ( decl ) , NULL , true ) ) { old = binding -> value ; old_scope = binding -> scope ; } while ( old && VAR_P ( old ) && DECL_DEAD_FOR_LOCAL ( old ) ) old = DECL_SHADOWED_FOR_VAR ( old ) ; tree shadowed = NULL_TREE ; if ( old && ( TREE_CODE ( old ) == PARM_DECL || VAR_P ( old ) || ( TREE_CODE ( old ) == TYPE_DECL && ( ! DECL_ARTIFICIAL ( old ) || TREE_CODE ( decl ) == TYPE_DECL ) ) ) && ( ! DECL_ARTIFICIAL ( decl ) || DECL_IMPLICIT_TYPEDEF_P ( decl ) || ( VAR_P ( decl ) && DECL_ANON_UNION_VAR_P ( decl ) ) ) ) { if ( DECL_CONTEXT ( old ) == current_function_decl && TREE_CODE ( decl ) != PARM_DECL && TREE_CODE ( old ) == PARM_DECL ) { cp_binding_level * b = current_binding_level -> level_chain ; if ( FUNCTION_NEEDS_BODY_BLOCK ( current_function_decl ) ) b = b -> level_chain ; if ( b -> kind == sk_function_parms ) { error ( "declaration<S2SV_blank>of<S2SV_blank>%q#D<S2SV_blank>shadows<S2SV_blank>a<S2SV_blank>parameter" , decl ) ; return ; } } if ( DECL_CONTEXT ( old ) != current_function_decl ) { for ( cp_binding_level * scope = current_binding_level ; scope != old_scope ; scope = scope -> level_chain ) if ( scope -> kind == sk_class && ! LAMBDA_TYPE_P ( scope -> this_entity ) ) return ; } else if ( VAR_P ( old ) && old_scope == current_binding_level -> level_chain && ( old_scope -> kind == sk_cond || old_scope -> kind == sk_for ) ) { error ( "redeclaration<S2SV_blank>of<S2SV_blank>%q#D" , decl ) ; inform ( DECL_SOURCE_LOCATION ( old ) , "%q#D<S2SV_blank>previously<S2SV_blank>declared<S2SV_blank>here" , old ) ; return ; } else if ( ( TREE_CODE ( old ) == VAR_DECL && old_scope == current_binding_level -> level_chain && old_scope -> kind == sk_catch ) || ( TREE_CODE ( old ) == PARM_DECL && ( current_binding_level -> kind == sk_catch || current_binding_level -> level_chain -> kind == sk_catch ) && in_function_try_handler ) ) { if ( permerror ( input_location , "redeclaration<S2SV_blank>of<S2SV_blank>%q#D" , decl ) ) inform ( DECL_SOURCE_LOCATION ( old ) , "%q#D<S2SV_blank>previously<S2SV_blank>declared<S2SV_blank>here" , old ) ; return ; } enum opt_code warning_code ; if ( warn_shadow ) warning_code = OPT_Wshadow ; else if ( warn_shadow_local ) warning_code = OPT_Wshadow_local ; else if ( warn_shadow_compatible_local && can_convert ( TREE_TYPE ( old ) , TREE_TYPE ( decl ) , tf_none ) ) warning_code = OPT_Wshadow_compatible_local ; else return ; const char * msg ; if ( TREE_CODE ( old ) == PARM_DECL ) msg = "declaration<S2SV_blank>of<S2SV_blank>%q#D<S2SV_blank>shadows<S2SV_blank>a<S2SV_blank>parameter" ; else if ( is_capture_proxy ( old ) ) msg = "declaration<S2SV_blank>of<S2SV_blank>%qD<S2SV_blank>shadows<S2SV_blank>a<S2SV_blank>lambda<S2SV_blank>capture" ; else msg = "declaration<S2SV_blank>of<S2SV_blank>%qD<S2SV_blank>shadows<S2SV_blank>a<S2SV_blank>previous<S2SV_blank>local" ; if ( warning_at ( input_location , warning_code , msg , decl ) ) { shadowed = old ; goto inform_shadowed ; } return ; } if ( ! warn_shadow ) return ; if ( DECL_ARTIFICIAL ( decl ) && ! DECL_IMPLICIT_TYPEDEF_P ( decl ) ) return ; if ( nonlambda_method_basetype ( ) ) if ( tree member = lookup_member ( current_nonlambda_class_type ( ) , DECL_NAME ( decl ) , 0 , false , tf_warning_or_error ) ) { member = MAYBE_BASELINK_FUNCTIONS ( member ) ; <S2SV_StartBug> if ( ( TREE_CODE ( member ) != FUNCTION_DECL <S2SV_EndBug> && TREE_CODE ( member ) != OVERLOAD ) || TREE_CODE ( decl ) == FUNCTION_DECL || TYPE_PTRFN_P ( TREE_TYPE ( decl ) ) || TYPE_PTRMEMFUNC_P ( TREE_TYPE ( decl ) ) ) { if ( warning_at ( input_location , OPT_Wshadow , "declaration<S2SV_blank>of<S2SV_blank>%qD<S2SV_blank>shadows<S2SV_blank>a<S2SV_blank>member<S2SV_blank>of<S2SV_blank>%qT" , decl , current_nonlambda_class_type ( ) ) && DECL_P ( member ) ) { shadowed = member ; goto inform_shadowed ; } } return ; } old = find_namespace_value ( current_namespace , DECL_NAME ( decl ) ) ; if ( old && ( VAR_P ( old ) || ( TREE_CODE ( old ) == TYPE_DECL && ( ! DECL_ARTIFICIAL ( old ) || TREE_CODE ( decl ) == TYPE_DECL ) ) ) && ! instantiating_current_function_p ( ) ) { if ( warning_at ( input_location , OPT_Wshadow , "declaration<S2SV_blank>of<S2SV_blank>%qD<S2SV_blank>shadows<S2SV_blank>a<S2SV_blank>global<S2SV_blank>declaration" , decl ) ) { shadowed = old ; goto inform_shadowed ; } return ; } return ; inform_shadowed : inform ( DECL_SOURCE_LOCATION ( shadowed ) , "shadowed<S2SV_blank>declaration<S2SV_blank>is<S2SV_blank>here" ) ; } | <S2SV_ModStart> ; if ( ! OVL_P ( member <S2SV_ModEnd> ) || TREE_CODE |
366 | CWE-000 int main ( ) { char op = 's' ; char userOp , idade_calc [ 20 ] ; while ( ( op == 's' ) && ( controle < 10 ) ) { printf ( "\\nMENU:\\n<S2SV_blank>a)Insere<S2SV_blank>pessoa\\n<S2SV_blank>b)Calcula<S2SV_blank>idade\\n<S2SV_blank>c)\\n<S2SV_blank>d)\\n<S2SV_blank>e)\\n<S2SV_blank>s)Sair\\n" ) ; userOp = getch ( ) ; switch ( userOp ) { case 'a' : insere ( ) ; break ; case 'b' : printf ( "\\nDigite<S2SV_blank>o<S2SV_blank>nome<S2SV_blank>da<S2SV_blank>pessoa<S2SV_blank>da<S2SV_blank>qual<S2SV_blank>deseja<S2SV_blank>saber<S2SV_blank>a<S2SV_blank>idade:" ) ; gets ( idade_calc ) ; <S2SV_StartBug> printf ( "\\nA<S2SV_blank>idade<S2SV_blank>dele<S2SV_blank>eh:<S2SV_blank>%d" , calcIdade ( idade_calc ) ) ; <S2SV_EndBug> break ; } printf ( "\\ndeseja<S2SV_blank>continuar?(S/N)" ) ; op = getch ( ) ; } return 0 ; } | <S2SV_ModStart> ; printf ( idade_calc ) ; printf ( |
367 | CWE-000 static int get_comdb2db_hosts ( cdb2_hndl_tp * hndl , char comdb2db_hosts [ ] [ 64 ] , int * comdb2db_ports , int * master , char * comdb2db_name , int * num_hosts , int * comdb2db_num , char * dbname , char * dbtype , char db_hosts [ ] [ 64 ] , int * num_db_hosts , int * dbnum , int just_defaults ) { int rc ; int comdb2db_found = 0 ; int dbname_found = 0 ; if ( hndl && hndl -> debug_trace ) { fprintf ( stderr , "td<S2SV_blank>%u<S2SV_blank>%s:%d<S2SV_blank>\\n" , ( uint32_t ) pthread_self ( ) , __func__ , __LINE__ ) ; } rc = read_available_comdb2db_configs ( hndl , comdb2db_hosts , comdb2db_name , num_hosts , comdb2db_num , dbname , db_hosts , num_db_hosts , dbnum , & comdb2db_found , & dbname_found ) ; if ( rc == - 1 ) <S2SV_StartBug> return rc ; <S2SV_EndBug> if ( num_hosts ) * num_hosts = 0 ; if ( num_db_hosts ) * num_db_hosts = 0 ; if ( master ) * master = - 1 ; if ( just_defaults || comdb2db_found || dbname_found ) return 0 ; rc = cdb2_dbinfo_query ( hndl , cdb2_default_cluster , comdb2db_name , * comdb2db_num , NULL , comdb2db_hosts , comdb2db_ports , master , num_hosts , NULL ) ; if ( rc == 0 ) return 0 ; rc = get_host_by_name ( comdb2db_name , comdb2db_hosts , num_hosts ) ; return rc ; } | <S2SV_ModStart> ) return rc <S2SV_ModEnd> ; if ( |
368 | CWE-000 static int close_metadata ( uint64_t chan_key ) { int ret = 0 ; struct lttng_consumer_channel * channel ; DBG ( "UST<S2SV_blank>consumer<S2SV_blank>close<S2SV_blank>metadata<S2SV_blank>key<S2SV_blank>%" PRIu64 , chan_key ) ; channel = consumer_find_channel ( chan_key ) ; if ( ! channel ) { DBG ( "UST<S2SV_blank>consumer<S2SV_blank>close<S2SV_blank>metadata<S2SV_blank>%" PRIu64 "<S2SV_blank>not<S2SV_blank>found" , chan_key ) ; ret = LTTNG_ERR_UST_CHAN_NOT_FOUND ; goto error ; } pthread_mutex_lock ( & consumer_data . lock ) ; pthread_mutex_lock ( & channel -> lock ) ; if ( cds_lfht_is_node_deleted ( & channel -> node . node ) ) { goto error_unlock ; } lttng_ustconsumer_close_metadata ( channel ) ; <S2SV_StartBug> error_unlock : <S2SV_EndBug> pthread_mutex_unlock ( & channel -> lock ) ; pthread_mutex_unlock ( & consumer_data . lock ) ; error : return ret ; } | <S2SV_ModStart> channel ) ; pthread_mutex_unlock ( & channel -> lock ) ; pthread_mutex_unlock ( & consumer_data . lock ) ; if ( ! channel -> monitor ) { consumer_del_channel ( channel ) ; } return ret ; |
369 | CWE-000 int <S2SV_StartBug> intcmp ( void * x , void * y ) <S2SV_EndBug> { Int * s , * t ; <S2SV_StartBug> s = x ; <S2SV_EndBug> <S2SV_StartBug> t = y ; <S2SV_EndBug> if ( s -> i < t -> i ) return - 1 ; if ( s -> i > t -> i ) return 1 ; return 0 ; } | <S2SV_ModStart> int intcmp ( Fibnode <S2SV_ModEnd> * x , <S2SV_ModStart> * x , Fibnode <S2SV_ModEnd> * y ) <S2SV_ModStart> ; s = ( Int * ) <S2SV_ModStart> ; t = ( Int * ) |
370 | CWE-000 <S2SV_StartBug> void S_PaintChannelFromWavelet ( channel_t * ch , sfx_t * sc , int count , int sampleOffset , int bufferOffset ) { <S2SV_EndBug> int data ; int leftvol , rightvol ; int i ; portable_samplepair_t * samp ; sndBuffer * chunk ; short * samples ; leftvol = ch -> leftvol * snd_vol ; rightvol = ch -> rightvol * snd_vol ; i = 0 ; samp = & paintbuffer [ bufferOffset ] ; chunk = sc -> soundData ; while ( sampleOffset >= ( SND_CHUNK_SIZE_FLOAT * 4 ) ) { chunk = chunk -> next ; sampleOffset -= ( SND_CHUNK_SIZE_FLOAT * 4 ) ; i ++ ; } if ( i != sfxScratchIndex || sfxScratchPointer != sc ) { S_AdpcmGetSamples ( chunk , sfxScratchBuffer ) ; sfxScratchIndex = i ; sfxScratchPointer = sc ; } samples = sfxScratchBuffer ; for ( i = 0 ; i < count ; i ++ ) { data = samples [ sampleOffset ++ ] ; samp [ i ] . left += ( data * leftvol ) >> 8 ; samp [ i ] . right += ( data * rightvol ) >> 8 ; if ( sampleOffset == SND_CHUNK_SIZE * 2 ) { chunk = chunk -> next ; decodeWavelet ( chunk , sfxScratchBuffer ) ; sfxScratchIndex ++ ; sampleOffset = 0 ; } } } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static |
371 | CWE-000 void RS485IntHandler ( void ) { uint32_t lChar ; uint16_t sCarga ; uint8_t ucChar ; uint32_t ulStatus ; uint8_t time_out = 0 ; ulStatus = UARTIntStatus ( RS485_UART_BASE , true ) ; UARTIntClear ( RS485_UART_BASE , ulStatus ) ; if ( UARTRxErrorGet ( RS485_UART_BASE ) ) UARTRxErrorClear ( RS485_UART_BASE ) ; if ( UART_INT_RX == ulStatus || UART_INT_RT == ulStatus ) { while ( UARTCharsAvail ( RS485_UART_BASE ) && recv_buffer . index < SERIAL_BUF_SIZE ) { <S2SV_StartBug> lChar = UARTCharGet ( RS485_UART_BASE ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ! ( lChar & ~ 0xFF ) ) <S2SV_EndBug> { ucChar = ( unsigned char ) ( lChar & 0xFF ) ; recv_buffer . data [ recv_buffer . index ] = ucChar ; <S2SV_StartBug> recv_buffer . csum += recv_buffer . data [ recv_buffer . index ++ ] ; <S2SV_EndBug> } time_out = 0 ; } sCarga = ( recv_buffer . data [ 2 ] << 8 ) | recv_buffer . data [ 3 ] ; if ( recv_buffer . index > sCarga + 4 ) { RS485ProcessData ( ) ; MessageOverflow = 0 ; } else { recv_buffer . index = 0 ; recv_buffer . csum = 0 ; send_buffer . index = 0 ; send_buffer . csum = 0 ; } } else if ( UART_INT_TX == ulStatus ) { while ( UARTBusy ( RS485_RD_BASE ) ) ; GPIOPinWrite ( RS485_RD_BASE , RS485_RD_PIN , OFF ) ; } } | <S2SV_ModStart> SERIAL_BUF_SIZE ) { recv_buffer . data [ recv_buffer . index ] = ( uint8_t ) <S2SV_ModEnd> UARTCharGet ( RS485_UART_BASE <S2SV_ModStart> RS485_UART_BASE ) ; <S2SV_ModEnd> ; recv_buffer . <S2SV_ModStart> index ++ ] <S2SV_ModEnd> ; } sCarga |
372 | CWE-000 int ABT_sched_config_create ( ABT_sched_config * config , ... ) { int abt_errno = ABT_SUCCESS ; ABTI_sched_config * p_config ; char * buffer = NULL ; size_t alloc_size = 8 * sizeof ( size_t ) ; int num_params = 0 ; size_t offset = sizeof ( num_params ) ; size_t buffer_size = alloc_size ; buffer = ( char * ) ABTU_malloc ( buffer_size ) ; va_list varg_list ; va_start ( varg_list , config ) ; while ( 1 ) { ABT_sched_config_var var = va_arg ( varg_list , ABT_sched_config_var ) ; if ( var . idx == ABT_sched_config_var_end . idx ) break ; int param = var . idx ; ABT_sched_config_type type = var . type ; num_params ++ ; size_t size = ABTI_sched_config_type_size ( type ) ; if ( offset + sizeof ( param ) + sizeof ( type ) + size > buffer_size ) { <S2SV_StartBug> buffer_size += alloc_size ; <S2SV_EndBug> <S2SV_StartBug> buffer = ABTU_realloc ( buffer , buffer_size ) ; <S2SV_EndBug> } memcpy ( buffer + offset , ( void * ) & param , sizeof ( param ) ) ; offset += sizeof ( param ) ; memcpy ( buffer + offset , ( void * ) & size , sizeof ( size ) ) ; offset += sizeof ( size ) ; void * ptr ; int i ; double d ; void * p ; switch ( type ) { case ABT_SCHED_CONFIG_INT : i = va_arg ( varg_list , int ) ; ptr = ( void * ) & i ; break ; case ABT_SCHED_CONFIG_DOUBLE : d = va_arg ( varg_list , double ) ; ptr = ( void * ) & d ; break ; case ABT_SCHED_CONFIG_PTR : p = va_arg ( varg_list , void * ) ; ptr = ( void * ) & p ; break ; default : abt_errno = ABT_ERR_SCHED_CONFIG ; goto fn_fail ; } memcpy ( buffer + offset , ptr , size ) ; offset += size ; } va_end ( varg_list ) ; if ( num_params ) { memcpy ( buffer , ( int * ) & num_params , sizeof ( num_params ) ) ; } else { ABTU_free ( buffer ) ; buffer = NULL ; } p_config = ( ABTI_sched_config * ) buffer ; * config = ABTI_sched_config_get_handle ( p_config ) ; fn_exit : return abt_errno ; fn_fail : HANDLE_ERROR_FUNC_WITH_CODE ( abt_errno ) ; goto fn_exit ; } | <S2SV_ModStart> buffer_size ) { size_t cur_size = buffer_size ; <S2SV_ModStart> ( buffer , cur_size , |
373 | CWE-000 int main ( int argc , char * argv [ ] ) { const char * name , * type ; int i ; SDL_Joystick * joystick ; SDL_SetHint ( SDL_HINT_ACCELEROMETER_AS_JOYSTICK , "0" ) ; SDL_LogSetPriority ( SDL_LOG_CATEGORY_APPLICATION , SDL_LOG_PRIORITY_INFO ) ; if ( SDL_Init ( SDL_INIT_VIDEO | SDL_INIT_JOYSTICK ) < 0 ) { SDL_LogError ( SDL_LOG_CATEGORY_APPLICATION , "Couldn\'t<S2SV_blank>initialize<S2SV_blank>SDL:<S2SV_blank>%s\\n" , SDL_GetError ( ) ) ; exit ( 1 ) ; } ULONG_PTR ppid = GetParentProcessId ( ) ; AttachConsole ( ppid ) ; HANDLE handle_out = GetStdHandle ( STD_OUTPUT_HANDLE ) ; int hCrt = _open_osfhandle ( ( long ) handle_out , _O_TEXT ) ; FILE * hf_out = _fdopen ( hCrt , "w" ) ; setvbuf ( hf_out , NULL , _IONBF , 1 ) ; * stdout = * hf_out ; HANDLE handle_in = GetStdHandle ( STD_INPUT_HANDLE ) ; hCrt = _open_osfhandle ( ( long ) handle_in , _O_TEXT ) ; FILE * hf_in = _fdopen ( hCrt , "r" ) ; setvbuf ( hf_in , NULL , _IONBF , 128 ) ; * stdin = * hf_in ; SDL_Log ( "There<S2SV_blank>are<S2SV_blank>%d<S2SV_blank>joysticks<S2SV_blank>attached\\n" , SDL_NumJoysticks ( ) ) ; <S2SV_StartBug> for ( i = 0 ; i < SDL_NumJoysticks ( ) ; ++ i ) { <S2SV_EndBug> name = SDL_JoystickNameForIndex ( i ) ; SDL_Log ( "Joystick<S2SV_blank>%d:<S2SV_blank>%s\\n" , i , name ? name : "Unknown<S2SV_blank>Joystick" ) ; joystick = SDL_JoystickOpen ( i ) ; if ( joystick == NULL ) { SDL_LogError ( SDL_LOG_CATEGORY_APPLICATION , "SDL_JoystickOpen(%d)<S2SV_blank>failed:<S2SV_blank>%s\\n" , i , SDL_GetError ( ) ) ; } else { char guid [ 64 ] ; SDL_assert ( SDL_JoystickFromInstanceID ( SDL_JoystickInstanceID ( joystick ) ) == joystick ) ; SDL_JoystickGetGUIDString ( SDL_JoystickGetGUID ( joystick ) , guid , sizeof ( guid ) ) ; switch ( SDL_JoystickGetType ( joystick ) ) { case SDL_JOYSTICK_TYPE_GAMECONTROLLER : type = "Game<S2SV_blank>Controller" ; break ; case SDL_JOYSTICK_TYPE_WHEEL : type = "Wheel" ; break ; case SDL_JOYSTICK_TYPE_ARCADE_STICK : type = "Arcade<S2SV_blank>Stick" ; break ; case SDL_JOYSTICK_TYPE_FLIGHT_STICK : type = "Flight<S2SV_blank>Stick" ; break ; case SDL_JOYSTICK_TYPE_DANCE_PAD : type = "Dance<S2SV_blank>Pad" ; break ; case SDL_JOYSTICK_TYPE_GUITAR : type = "Guitar" ; break ; case SDL_JOYSTICK_TYPE_DRUM_KIT : type = "Drum<S2SV_blank>Kit" ; break ; case SDL_JOYSTICK_TYPE_ARCADE_PAD : type = "Arcade<S2SV_blank>Pad" ; break ; case SDL_JOYSTICK_TYPE_THROTTLE : type = "Throttle" ; break ; default : type = "Unknown" ; break ; } SDL_Log ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>type:<S2SV_blank>%s\\n" , type ) ; SDL_Log ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>axes:<S2SV_blank>%d\\n" , SDL_JoystickNumAxes ( joystick ) ) ; SDL_Log ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>balls:<S2SV_blank>%d\\n" , SDL_JoystickNumBalls ( joystick ) ) ; SDL_Log ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>hats:<S2SV_blank>%d\\n" , SDL_JoystickNumHats ( joystick ) ) ; SDL_Log ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>buttons:<S2SV_blank>%d\\n" , SDL_JoystickNumButtons ( joystick ) ) ; SDL_Log ( "instance<S2SV_blank>id:<S2SV_blank>%d\\n" , SDL_JoystickInstanceID ( joystick ) ) ; SDL_Log ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>guid:<S2SV_blank>%s\\n" , guid ) ; SDL_Log ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>VID/PID:<S2SV_blank>0x%.4x/0x%.4x\\n" , SDL_JoystickGetVendor ( joystick ) , SDL_JoystickGetProduct ( joystick ) ) ; SDL_Log ( "Watching<S2SV_blank>joystick<S2SV_blank>%d:<S2SV_blank>(%s)\\n" , SDL_JoystickInstanceID ( joystick ) , name ? name : "Unknown<S2SV_blank>Joystick" ) ; printf ( "Watching<S2SV_blank>Joystick<S2SV_blank>%s\\n" , name ? name : "Unknown<S2SV_blank>Joystick" ) ; SDL_Log ( "Joystick<S2SV_blank>has<S2SV_blank>%d<S2SV_blank>axes,<S2SV_blank>%d<S2SV_blank>hats,<S2SV_blank>%d<S2SV_blank>balls,<S2SV_blank>and<S2SV_blank>%d<S2SV_blank>buttons\\n" , SDL_JoystickNumAxes ( joystick ) , SDL_JoystickNumHats ( joystick ) , SDL_JoystickNumBalls ( joystick ) , SDL_JoystickNumButtons ( joystick ) ) ; # ifdef __EMSCRIPTEN__ emscripten_set_main_loop_arg ( loop , joystick , 0 , 1 ) ; # else while ( ! done ) { loop ( joystick ) ; } # endif SDL_JoystickClose ( joystick ) ; } } # if defined ( __ANDROID__ ) || defined ( __IPHONEOS__ ) if ( SDL_NumJoysticks ( ) > 0 ) { # else if ( argv [ 1 ] ) { # endif SDL_bool reportederror = SDL_FALSE ; SDL_bool keepGoing = SDL_TRUE ; SDL_Event event ; int device ; # if defined ( __ANDROID__ ) || defined ( __IPHONEOS__ ) device = 0 ; # else device = atoi ( argv [ 1 ] ) ; # endif joystick = SDL_JoystickOpen ( device ) ; if ( joystick != NULL ) { SDL_assert ( SDL_JoystickFromInstanceID ( SDL_JoystickInstanceID ( joystick ) ) == joystick ) ; } while ( keepGoing ) { if ( joystick == NULL ) { if ( ! reportederror ) { SDL_Log ( "Couldn\'t<S2SV_blank>open<S2SV_blank>joystick<S2SV_blank>%d:<S2SV_blank>%s\\n" , device , SDL_GetError ( ) ) ; keepGoing = SDL_FALSE ; reportederror = SDL_TRUE ; } } else { reportederror = SDL_FALSE ; keepGoing = WatchJoystick ( joystick ) ; SDL_JoystickClose ( joystick ) ; } joystick = NULL ; if ( keepGoing ) { SDL_Log ( "Waiting<S2SV_blank>for<S2SV_blank>attach\\n" ) ; } while ( keepGoing ) { SDL_WaitEvent ( & event ) ; if ( ( event . type == SDL_QUIT ) || ( event . type == SDL_FINGERDOWN ) || ( event . type == SDL_MOUSEBUTTONDOWN ) ) { keepGoing = SDL_FALSE ; } else if ( event . type == SDL_JOYDEVICEADDED ) { device = event . jdevice . which ; joystick = SDL_JoystickOpen ( device ) ; if ( joystick != NULL ) { SDL_assert ( SDL_JoystickFromInstanceID ( SDL_JoystickInstanceID ( joystick ) ) == joystick ) ; } break ; } } } } SDL_QuitSubSystem ( SDL_INIT_VIDEO | SDL_INIT_JOYSTICK ) ; return 0 ; } | <S2SV_ModStart> ) ) ; if ( SDL_NumJoysticks ( ) == 0 ) { printf ( "No<S2SV_blank>Joysticks<S2SV_blank>Attached\\n" ) ; exit ( 1 ) ; } else { printf ( "Joysticks<S2SV_blank>Attached\\n" ) ; } |
374 | CWE-000 void entry_group_cb ( AvahiEntryGroup * group , AvahiEntryGroupState state , AVAHI_GCC_UNUSED void * userdata ) { service_ctx_t * ctx = userdata ; <S2SV_StartBug> char * new_name ; <S2SV_EndBug> switch ( state ) { case AVAHI_ENTRY_GROUP_ESTABLISHED : log_printf ( LOG_INFO , "SSA<S2SV_blank>service<S2SV_blank>published\\n" ) ; <S2SV_StartBug> break ; <S2SV_EndBug> case AVAHI_ENTRY_GROUP_FAILURE : case AVAHI_ENTRY_GROUP_COLLISION : log_printf ( LOG_INFO , "Avahi<S2SV_blank>name<S2SV_blank>collision:<S2SV_blank>%s\\n" , avahi_strerror ( avahi_client_errno ( ctx -> client ) ) ) ; new_name = avahi_alternative_service_name ( ctx -> service_name ) ; avahi_free ( ctx -> service_name ) ; ctx -> service_name = new_name ; log_printf ( LOG_INFO , "Switching<S2SV_blank>NSD<S2SV_blank>name<S2SV_blank>to<S2SV_blank>%s\\n" , new_name ) ; publish_service ( ctx ) ; break ; <S2SV_StartBug> case AVAHI_ENTRY_GROUP_REGISTERING : <S2SV_EndBug> case AVAHI_ENTRY_GROUP_UNCOMMITED : default : break ; } return ; } | <S2SV_ModStart> char * new_name , * charp <S2SV_ModStart> "SSA<S2SV_blank>service<S2SV_blank>published\\n" ) ; log_printf ( LOG_INFO , "NSD<S2SV_blank>name:<S2SV_blank>%s\\n" , ctx -> service_name ) ; break ; <S2SV_ModEnd> case AVAHI_ENTRY_GROUP_COLLISION : <S2SV_ModStart> break ; case AVAHI_ENTRY_GROUP_FAILURE : log_printf ( LOG_DEBUG , "AVAHI_ENTRY_GROUP_FAILURE\\n" ) ; break ; case |
375 | CWE-000 static irqreturn_t bb_avr_las_trigger_handler ( int irq , void * p ) { struct iio_poll_func * pf = p ; struct iio_dev * indio_dev = pf -> indio_dev ; struct bb_avr_las * las = iio_priv ( indio_dev ) ; struct iio_buffer * buffer = indio_dev -> buffer ; int ret ; u8 position ; ret = iio_buffer_remove_sample ( buffer , & position ) ; if ( ret < 0 ) { <S2SV_StartBug> dev_err ( & indio_dev -> dev , <S2SV_EndBug> "iio_buffer_remove_sample<S2SV_blank>failed:<S2SV_blank>%d" , ret ) ; goto out ; } bb_avr_exec ( las -> avr , BB_AVR_CMD_SET_LIFT_ACTUATOR_POSITION , & position , 1 , NULL , 0 ) ; out : iio_trigger_notify_done ( indio_dev -> trig ) ; return IRQ_HANDLED ; } | <S2SV_ModStart> 0 ) { if ( ret != - ENODATA ) |
376 | CWE-000 int ToneTest ( ) { uint16_t counter = 0 ; while ( 1 ) { while ( counter <= 511 ) { uint16_t Vout = 0 ; Vout = 2048 + ( ( ( sintab2 [ counter ] ) - 2048 ) / 4 ) ; i2c_DAC_send_value ( Vout ) ; counter = ( counter + advance ) ; } counter &= 511 ; if ( ( ( KEY_IN_PORT_PIN >> KEY_STRAIGHT ) & 0x01 ) == 1 ) { while ( ( ( KEY_IN_PORT_PIN >> KEY_STRAIGHT ) & 0x01 ) == 1 ) ; int adcval = adc_read ( ADC_TONE ) ; uint8_t toneid = adc_pos ( adcval ) ; <S2SV_StartBug> SetTone ( toneid ) <S2SV_EndBug> adcval = adc_read ( ADC_VOLUME ) ; uint8_t volumeid = adc_pos ( adcval ) ; SetVolume ( volumeid ) ; counter = 0 ; char tmp [ 64 ] ; sprintf ( tmp , "NewTone<S2SV_blank>:%d<S2SV_blank>(%lu)\\r\\n" , toneid , tones [ toneid ] ) ; UartPutString ( tmp ) ; sprintf ( tmp , "NewVolume<S2SV_blank>:%d<S2SV_blank>(%lu)\\r\\n" , volumeid , volumes [ volumeid ] ) ; UartPutString ( tmp ) ; } } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ( toneid ) ; <S2SV_ModStart> ; } } return SUCCESS ; |
377 | CWE-000 void display_categories ( void ) { printf ( "On<S2SV_blank>the<S2SV_blank>menu<S2SV_blank>tonight:\\n" ) ; for ( int i = 0 ; i < 3 ; i ++ ) { <S2SV_StartBug> if ( quest [ 0 + i ] . answered || quest [ 1 + i ] . answered || quest [ 2 + i ] . answered || quest [ 3 + i ] . answered == false ) <S2SV_EndBug> { printf ( "%-5s<S2SV_blank>%-5s\\t" , categories [ i ] , "for" ) ; for ( int j = 0 ; j < 4 ; j ++ ) { if ( quest [ i * 4 + j ] . answered == false ) { printf ( "%-2d<S2SV_blank>\\t" , quest [ i * 4 + j ] . value ) ; } <S2SV_StartBug> else printf ( "%-2s\\t" , "<S2SV_blank>" ) ; <S2SV_EndBug> } } printf ( "\\n" ) ; } printf ( "Pick<S2SV_blank>your<S2SV_blank>poison:<S2SV_blank>" ) ; } | <S2SV_ModStart> { if ( ! <S2SV_ModStart> . answered || ! <S2SV_ModStart> . answered || ! <S2SV_ModStart> . answered || ! <S2SV_ModStart> ] . answered <S2SV_ModEnd> ) { printf <S2SV_ModStart> ( "%-2s\\t" , "ANS" <S2SV_ModEnd> ) ; } |
378 | CWE-000 static int bif_edin_display_1 ( tpl_query * q ) { node * args = get_args ( q ) ; node * term1 = get_term ( term1 ) ; size_t max_len = PRINTBUF_SIZE ; char * tmpbuf = ( char * ) malloc ( max_len + 1 ) ; char * dst = tmpbuf ; <S2SV_StartBug> q -> display_slots = q -> ignore_ops = 1 ; <S2SV_EndBug> size_t len = term_sprint2 ( & tmpbuf , & max_len , & dst , q -> pl , q , term1 , 0 ) ; <S2SV_StartBug> q -> display_slots = q -> ignore_ops = 0 ; <S2SV_EndBug> if ( q -> halt ) { free ( tmpbuf ) ; return 0 ; } fwrite ( tmpbuf , 1 , len , q -> curr_stdout ) ; free ( tmpbuf ) ; return 1 ; } | <S2SV_ModStart> ; q -> <S2SV_ModEnd> ignore_ops = 1 <S2SV_ModStart> 0 ) ; <S2SV_ModEnd> q -> ignore_ops |
379 | CWE-000 static void power_hint ( struct power_module * module , power_hint_t hint , void * data ) { switch ( hint ) { case POWER_HINT_LOW_POWER : if ( data ) { power_fwrite ( MT_FPS_UPPER_BOUND_PATH , "30" ) ; power_fwrite ( MT_RUSH_BOOST_PATH , "0" ) ; } else { power_fwrite ( MT_FPS_UPPER_BOUND_PATH , "60" ) ; power_fwrite ( MT_RUSH_BOOST_PATH , "1" ) ; } ALOGI ( "POWER_HINT_LOW_POWER" ) ; break ; case POWER_HINT_VSYNC : case POWER_HINT_INTERACTION : <S2SV_StartBug> case POWER_HINT_CPU_BOOST : <S2SV_EndBug> case POWER_HINT_LAUNCH : case POWER_HINT_SET_PROFILE : case POWER_HINT_VIDEO_ENCODE : case POWER_HINT_VIDEO_DECODE : case POWER_HINT_SUSTAINED_PERFORMANCE : case POWER_HINT_VR_MODE : break ; default : break ; } } | <S2SV_ModStart> POWER_HINT_INTERACTION : case POWER_HINT_LAUNCH <S2SV_ModEnd> : case POWER_HINT_VIDEO_ENCODE |
380 | CWE-000 gboolean device_or_mountpoint_exists ( GPtrArray * pdisks , t_disk * pdisk ) { gboolean returnValue = FALSE ; <S2SV_StartBug> int i ; <S2SV_EndBug> t_disk * disk ; int stringlength1 , stringlength2 , stringlength3 , stringlength4 ; stringlength1 = strlen ( pdisk -> device ) ; stringlength3 = strlen ( pdisk -> mount_point ) ; for ( i = 0 ; i < pdisks -> len ; i ++ ) { disk = ( t_disk * ) ( g_ptr_array_index ( pdisks , i ) ) ; stringlength2 = strlen ( disk -> device ) ; stringlength4 = strlen ( disk -> mount_point ) ; if ( stringlength1 == stringlength2 + 1 && pdisk -> device [ stringlength1 - 1 ] == '/' && strncmp ( pdisk -> device , disk -> device , stringlength2 ) == 0 ) { returnValue = TRUE ; break ; } else if ( stringlength2 == stringlength1 + 1 && disk -> device [ stringlength2 - 1 ] == '/' && strncmp ( pdisk -> device , disk -> device , stringlength1 ) == 0 ) { returnValue = TRUE ; break ; } else if ( stringlength3 == stringlength4 + 1 && pdisk -> mount_point [ stringlength3 - 1 ] == '/' && strncmp ( pdisk -> mount_point , disk -> mount_point , stringlength4 ) == 0 ) { returnValue = TRUE ; break ; } else if ( stringlength4 == stringlength3 + 1 && disk -> mount_point [ stringlength4 - 1 ] == '/' && strncmp ( pdisk -> mount_point , disk -> mount_point , stringlength3 ) == 0 ) { returnValue = TRUE ; break ; } } return returnValue ; } | <S2SV_ModStart> = FALSE ; guint <S2SV_ModEnd> i ; t_disk |
381 | CWE-000 <S2SV_StartBug> int load_modules ( unsigned int preload_only ) <S2SV_EndBug> { <S2SV_StartBug> struct ast_config * cfg ; <S2SV_EndBug> <S2SV_StartBug> struct load_order_entry * order ; <S2SV_EndBug> struct ast_variable * v ; unsigned int load_count ; struct load_order load_order ; int res = 0 ; <S2SV_StartBug> struct ast_flags config_flags = { 0 } ; <S2SV_EndBug> <S2SV_StartBug> int modulecount = 0 ; <S2SV_EndBug> struct dirent * dirent ; DIR * dir ; ast_verb ( 1 , "Asterisk<S2SV_blank>Dynamic<S2SV_blank>Loader<S2SV_blank>Starting:\\n" ) ; AST_LIST_HEAD_INIT_NOLOCK ( & load_order ) ; AST_DLLIST_LOCK ( & module_list ) ; <S2SV_StartBug> loader_ready = 1 ; <S2SV_EndBug> while ( ( resource_being_loaded = AST_DLLIST_REMOVE_HEAD ( & builtin_module_list , entry ) ) ) { ast_module_register ( resource_being_loaded -> info ) ; } if ( ! preload_only ) { struct ast_module * mod ; AST_DLLIST_TRAVERSE ( & module_list , mod , entry ) { if ( ! mod -> flags . builtin ) { continue ; } add_to_load_order ( mod -> resource , & load_order , 0 ) ; } } cfg = ast_config_load2 ( AST_MODULE_CONFIG , "" , config_flags ) ; <S2SV_StartBug> if ( cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEINVALID ) { <S2SV_EndBug> ast_log ( LOG_WARNING , "No<S2SV_blank>\'%s\'<S2SV_blank>found,<S2SV_blank>no<S2SV_blank>modules<S2SV_blank>will<S2SV_blank>be<S2SV_blank>loaded.\\n" , AST_MODULE_CONFIG ) ; goto done ; } <S2SV_StartBug> for ( v = ast_variable_browse ( cfg , "modules" ) ; v ; v = v -> next ) { <S2SV_EndBug> if ( ! strcasecmp ( v -> name , preload_only ? "preload" : "load" ) ) { add_to_load_order ( v -> value , & load_order , 0 ) ; } if ( ! strcasecmp ( v -> name , preload_only ? "preload-require" : "require" ) ) { add_to_load_order ( v -> value , & load_order , 1 ) ; ast_debug ( 2 , "Adding<S2SV_blank>module<S2SV_blank>to<S2SV_blank>required<S2SV_blank>list:<S2SV_blank>%s<S2SV_blank>(%s)\\n" , v -> value , v -> name ) ; } } if ( ! preload_only && ast_true ( ast_variable_retrieve ( cfg , "modules" , "autoload" ) ) ) { if ( ( dir = opendir ( ast_config_AST_MODULE_DIR ) ) ) { while ( ( dirent = readdir ( dir ) ) ) { int ld = strlen ( dirent -> d_name ) ; <S2SV_StartBug> if ( ld < 4 ) <S2SV_EndBug> continue ; if ( strcasecmp ( dirent -> d_name + ld - 3 , ".so" ) ) continue ; if ( find_resource ( dirent -> d_name , 0 ) ) continue ; add_to_load_order ( dirent -> d_name , & load_order , 0 ) ; } closedir ( dir ) ; } else { if ( ! ast_opt_quiet ) ast_log ( LOG_WARNING , "Unable<S2SV_blank>to<S2SV_blank>open<S2SV_blank>modules<S2SV_blank>directory<S2SV_blank>\'%s\'.\\n" , ast_config_AST_MODULE_DIR ) ; } } for ( v = ast_variable_browse ( cfg , "modules" ) ; v ; v = v -> next ) { size_t baselen ; if ( strcasecmp ( v -> name , "noload" ) ) { continue ; } baselen = resource_name_baselen ( v -> value ) ; AST_LIST_TRAVERSE_SAFE_BEGIN ( & load_order , order , entry ) { if ( ! resource_name_match ( v -> value , baselen , order -> resource ) ) { AST_LIST_REMOVE_CURRENT ( entry ) ; ast_free ( order -> resource ) ; ast_free ( order ) ; } } AST_LIST_TRAVERSE_SAFE_END ; } ast_config_destroy ( cfg ) ; load_count = 0 ; AST_LIST_TRAVERSE ( & load_order , order , entry ) load_count ++ ; if ( load_count ) ast_log ( LOG_NOTICE , "%u<S2SV_blank>modules<S2SV_blank>will<S2SV_blank>be<S2SV_blank>loaded.\\n" , load_count ) ; res = load_resource_list ( & load_order , & modulecount ) ; done : while ( ( order = AST_LIST_REMOVE_HEAD ( & load_order , entry ) ) ) { ast_free ( order -> resource ) ; ast_free ( order ) ; } AST_DLLIST_UNLOCK ( & module_list ) ; return res ; } | <S2SV_ModStart> int load_modules ( void <S2SV_ModEnd> ) { struct <S2SV_ModStart> ) { struct <S2SV_ModEnd> load_order_entry * order <S2SV_ModStart> load_order_entry * order <S2SV_ModEnd> ; unsigned int <S2SV_ModStart> = 0 ; <S2SV_ModEnd> int modulecount = <S2SV_ModStart> modulecount = 0 <S2SV_ModEnd> ; ast_verb ( <S2SV_ModStart> module_list ) ; res = loader_builtin_init ( & load_order <S2SV_ModEnd> ) ; if <S2SV_ModStart> ; if ( res ) { <S2SV_ModEnd> goto done ; <S2SV_ModStart> done ; } res = loader_config_init ( & load_order <S2SV_ModEnd> ) ; if <S2SV_ModStart> ; if ( res ) { goto done ; } <S2SV_ModEnd> load_count = 0 |
382 | CWE-000 static int dwc3_msm_suspend ( struct dwc3_msm * mdwc ) { int ret , i ; bool can_suspend_ssphy ; struct dwc3 * dwc = platform_get_drvdata ( mdwc -> dwc3 ) ; dbg_event ( 0xFF , "Ctl<S2SV_blank>Sus" , atomic_read ( & dwc -> in_lpm ) ) ; if ( atomic_read ( & dwc -> in_lpm ) ) { <S2SV_StartBug> dev_dbg ( mdwc -> dev , "%s:<S2SV_blank>Already<S2SV_blank>suspended\\n" , __func__ ) ; <S2SV_EndBug> return 0 ; } if ( ! mdwc -> in_host_mode ) { for ( i = 0 ; i < dwc -> num_event_buffers ; i ++ ) { struct dwc3_event_buffer * evt = dwc -> ev_buffs [ i ] ; if ( ( evt -> flags & DWC3_EVENT_PENDING ) ) { dev_dbg ( mdwc -> dev , "%s:<S2SV_blank>%d<S2SV_blank>device<S2SV_blank>events<S2SV_blank>pending,<S2SV_blank>abort<S2SV_blank>suspend\\n" , __func__ , evt -> count / 4 ) ; dbg_print_reg ( "PENDING<S2SV_blank>DEVICE<S2SV_blank>EVENT" , * ( u32 * ) ( evt -> buf + evt -> lpos ) ) ; return - EBUSY ; } } } if ( ! mdwc -> vbus_active && dwc -> is_drd && mdwc -> otg_state == OTG_STATE_B_PERIPHERAL ) { dev_dbg ( mdwc -> dev , "%s:<S2SV_blank>cable<S2SV_blank>disconnected<S2SV_blank>while<S2SV_blank>not<S2SV_blank>in<S2SV_blank>idle<S2SV_blank>otg<S2SV_blank>state\\n" , __func__ ) ; return - EBUSY ; } if ( ( dwc -> is_drd && mdwc -> otg_state == OTG_STATE_B_SUSPEND ) && ( dwc -> gadget . state != USB_STATE_CONFIGURED ) ) { pr_err ( "%s():<S2SV_blank>Trying<S2SV_blank>to<S2SV_blank>go<S2SV_blank>in<S2SV_blank>LPM<S2SV_blank>with<S2SV_blank>state:%d\\n" , __func__ , dwc -> gadget . state ) ; pr_err ( "%s():<S2SV_blank>LPM<S2SV_blank>is<S2SV_blank>not<S2SV_blank>performed.\\n" , __func__ ) ; return - EBUSY ; } ret = dwc3_msm_prepare_suspend ( mdwc ) ; if ( ret ) return ret ; can_suspend_ssphy = ! ( mdwc -> in_host_mode && dwc3_msm_is_host_superspeed ( mdwc ) ) ; tasklet_kill ( & dwc -> bh ) ; if ( dwc -> irq ) disable_irq ( dwc -> irq ) ; disable_irq ( mdwc -> pwr_event_irq ) ; usb_phy_set_suspend ( mdwc -> hs_phy , 1 ) ; if ( can_suspend_ssphy ) { if ( dwc3_msm_is_superspeed ( mdwc ) ) mdwc -> ss_phy -> flags |= DEVICE_IN_SS_MODE ; usb_phy_set_suspend ( mdwc -> ss_phy , 1 ) ; mdwc -> lpm_flags |= MDWC3_SS_PHY_SUSPEND ; } wmb ( ) ; if ( mdwc -> bus_aggr_clk ) clk_disable_unprepare ( mdwc -> bus_aggr_clk ) ; clk_disable_unprepare ( mdwc -> utmi_clk ) ; clk_set_rate ( mdwc -> core_clk , 19200000 ) ; clk_disable_unprepare ( mdwc -> core_clk ) ; clk_disable_unprepare ( mdwc -> iface_clk ) ; clk_disable_unprepare ( mdwc -> xo_clk ) ; if ( ! mdwc -> in_host_mode && ( ! mdwc -> vbus_active || mdwc -> otg_state == OTG_STATE_B_IDLE || mdwc -> in_restart ) ) { mdwc -> lpm_flags |= MDWC3_POWER_COLLAPSE ; dev_dbg ( mdwc -> dev , "%s:<S2SV_blank>power<S2SV_blank>collapse\\n" , __func__ ) ; dwc3_msm_config_gdsc ( mdwc , 0 ) ; clk_disable_unprepare ( mdwc -> sleep_clk ) ; } if ( mdwc -> bus_perf_client ) { mdwc -> bus_vote = 0 ; schedule_work ( & mdwc -> bus_vote_w ) ; } if ( mdwc -> lpm_to_suspend_delay ) { dev_dbg ( mdwc -> dev , "defer<S2SV_blank>suspend<S2SV_blank>with<S2SV_blank>%d(msecs)\\n" , mdwc -> lpm_to_suspend_delay ) ; pm_wakeup_event ( mdwc -> dev , mdwc -> lpm_to_suspend_delay ) ; } else { pm_relax ( mdwc -> dev ) ; } atomic_set ( & dwc -> in_lpm , 1 ) ; if ( ( mdwc -> vbus_active && mdwc -> otg_state == OTG_STATE_B_SUSPEND ) || mdwc -> in_host_mode ) { enable_irq_wake ( mdwc -> hs_phy_irq ) ; enable_irq ( mdwc -> hs_phy_irq ) ; if ( mdwc -> ss_phy_irq ) { enable_irq_wake ( mdwc -> ss_phy_irq ) ; enable_irq ( mdwc -> ss_phy_irq ) ; } mdwc -> lpm_flags |= MDWC3_ASYNC_IRQ_WAKE_CAPABILITY ; } dev_info ( mdwc -> dev , "DWC3<S2SV_blank>in<S2SV_blank>low<S2SV_blank>power<S2SV_blank>mode.<S2SV_blank>irq:%d\\n" , dwc -> irq ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> "%s:<S2SV_blank>Already<S2SV_blank>suspended\\n" , __func__ ) ; dbg_event ( 0xFF , "AlreadySUS" , 0 <S2SV_ModStart> irq ) ; dbg_event ( 0xFF , "SUSComplete" , mdwc -> lpm_to_suspend_delay ) ; |
383 | CWE-000 int binary_chunk ( char buffer [ ] , int source , int length ) { unsigned char byte ; unsigned char * b = ( unsigned char * ) & source ; size_t const size = sizeof ( source ) ; <S2SV_StartBug> int bit = bit = size * 8 ; <S2SV_EndBug> int i , j ; for ( i = size - 1 ; i >= 0 ; i -- ) { for ( j = 7 ; j >= 0 ; j -- , bit -- ) { if ( bit <= length ) { byte = ( b [ i ] >> j ) & 1 ; buffer += sprintf ( buffer , "%u" , byte ) ; } } } return 0 ; } | <S2SV_ModStart> ) ; int <S2SV_ModEnd> bit = size |
384 | CWE-000 void printboard ( char board [ 3 ] [ 3 ] [ 3 ] [ 3 ] ) { for ( int i = 0 ; i < 3 ; i ++ ) { int j = 0 ; for ( int k = 0 ; k < 3 ; k ++ ) { <S2SV_StartBug> for ( int l1 = 0 ; l < 3 ; l1 ++ ) { <S2SV_EndBug> printf ( "%c" , board [ i ] [ j ] [ k ] [ l1 ] ) ; } printf ( "<S2SV_blank>" ) ; for ( int l2 = 0 ; l2 < 3 ; l2 ++ ) { printf ( "%c" , board [ i ] [ j + 1 ] [ k ] [ l2 ] ) ; } printf ( "<S2SV_blank>" ) ; for ( int l3 = 0 ; l3 < 3 ; l3 ++ ) { printf ( "%c" , board [ i ] [ j + 2 ] [ k ] [ l3 ] ) ; } } printf ( "\\n" ) ; } } | <S2SV_ModStart> = 0 ; l1 <S2SV_ModEnd> < 3 ; |
385 | CWE-000 static ngx_rtmp_relay_ctx_t * ngx_rtmp_relay_create_remote_ctx ( ngx_rtmp_session_t * s , ngx_str_t * name , ngx_rtmp_relay_target_t * target ) { <S2SV_StartBug> ngx_rtmp_conf_ctx_t cctx ; <S2SV_EndBug> cctx . app_conf = s -> app_conf ; cctx . srv_conf = s -> srv_conf ; cctx . main_conf = s -> main_conf ; <S2SV_StartBug> return ngx_rtmp_relay_create_connection ( & cctx , name , target ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> { ngx_rtmp_conf_ctx_t cctx ; ngx_rtmp_relay_ctx_t * rctx <S2SV_ModStart> -> main_conf ; rctx = <S2SV_ModEnd> ngx_rtmp_relay_create_connection ( & <S2SV_ModStart> target ) ; if ( rctx ) { rctx -> server_name . data = s -> host_start ; rctx -> server_name . len = s -> host_end - s -> host_start ; } return rctx ; |
386 | CWE-000 ZyanStatus ZydisDecoderDecodeBuffer ( const ZydisDecoder * decoder , const void * buffer , ZyanUSize length , ZydisDecodedInstruction * instruction ) { if ( ! decoder || ! instruction ) { return ZYAN_STATUS_INVALID_ARGUMENT ; } if ( ! buffer || ! length ) { return ZYDIS_STATUS_NO_MORE_DATA ; } ZydisDecoderContext context ; ZYAN_MEMSET ( & context , 0 , sizeof ( context ) ) ; context . decoder = decoder ; context . buffer = ( ZyanU8 * ) buffer ; context . buffer_len = length ; ZYAN_MEMSET ( instruction , 0 , sizeof ( * instruction ) ) ; <S2SV_StartBug> instruction -> machine_mode = decoder -> machineMode ; <S2SV_EndBug> static const ZyanU8 lookup [ ZYDIS_ADDRESS_WIDTH_MAX_VALUE + 1 ] = { 16 , 32 , 64 } ; <S2SV_StartBug> instruction -> stack_width = lookup [ decoder -> addressWidth ] ; <S2SV_EndBug> ZYAN_CHECK ( ZydisCollectOptionalPrefixes ( & context , instruction ) ) ; ZYAN_CHECK ( ZydisDecodeInstruction ( & context , instruction ) ) ; return ZYAN_STATUS_SUCCESS ; } | <S2SV_ModStart> = decoder -> machine_mode <S2SV_ModEnd> ; static const <S2SV_ModStart> [ decoder -> address_width <S2SV_ModEnd> ] ; ZYAN_CHECK |
387 | CWE-000 void trace_graph_adv_filter_callback ( gboolean accept , const gchar * text , gint * event_ids , gpointer data ) { struct graph_info * ginfo = data ; struct event_filter * event_filter ; char error_str [ 200 ] ; int ret ; int i ; if ( ! accept ) return ; if ( ! has_text ( text ) && ! event_ids ) return ; event_filter = ginfo -> event_filter ; if ( event_ids ) { for ( i = 0 ; event_ids [ i ] >= 0 ; i ++ ) <S2SV_StartBug> pevent_filter_remove_event ( event_filter , event_ids [ i ] ) ; <S2SV_EndBug> } if ( has_text ( text ) ) { ginfo -> all_events = FALSE ; <S2SV_StartBug> pevent_filter_clear_trivial ( event_filter , <S2SV_EndBug> FILTER_TRIVIAL_BOTH ) ; <S2SV_StartBug> ret = pevent_filter_add_filter_str ( event_filter , text ) ; <S2SV_EndBug> if ( ret < 0 ) { pevent_strerror ( event_filter -> pevent , ret , error_str , sizeof ( error_str ) ) ; warning ( "filter<S2SV_blank>failed<S2SV_blank>due<S2SV_blank>to:<S2SV_blank>%s" , error_str ) ; return ; } } redraw_graph ( ginfo ) ; } | <S2SV_ModStart> i ++ ) tep_filter_remove_event <S2SV_ModEnd> ( event_filter , <S2SV_ModStart> = FALSE ; tep_filter_clear_trivial <S2SV_ModEnd> ( event_filter , <S2SV_ModStart> ; ret = tep_filter_add_filter_str <S2SV_ModEnd> ( event_filter , |
388 | CWE-000 <S2SV_StartBug> void sendMovementMessage ( uint32_t duration , JSON_Value * measurement_array ) <S2SV_EndBug> { JSON_Value * root_value = json_value_init_object ( ) ; JSON_Object * root_object = json_value_get_object ( root_value ) ; char * serialized_string = NULL ; JSON_Value * arr_val = json_value_init_array ( ) ; JSON_Array * arr_obj = json_value_get_array ( arr_val ) ; json_object_set_value ( root_object , "hasAttributes" , arr_val ) ; JSON_Value * arrval = json_value_init_object ( ) ; JSON_Object * arro = json_value_get_object ( arrval ) ; json_object_set_string ( arro , "hasAttributeClazzType" , "DA" ) ; json_object_set_string ( arro , "hasName" , "mov_meas" ) ; JSON_Value * arrsub_arr = json_value_init_array ( ) ; JSON_Array * arrsub_obj = json_value_get_array ( arrsub_arr ) ; json_object_set_value ( arro , "hasValueContainers" , arrsub_arr ) ; JSON_Value * arrsub_val_1 = json_value_init_object ( ) ; JSON_Object * arrsub_o_1 = json_value_get_object ( arrsub_val_1 ) ; json_object_dotset_value ( arrsub_o_1 , "hasValue.values" , measurement_array ) ; json_object_dotset_string ( arrsub_o_1 , "uuid.value" , "move" ) ; json_array_append_value ( arrsub_obj , arrsub_val_1 ) ; JSON_Value * arrsub_val_2 = json_value_init_object ( ) ; JSON_Object * arrsub_o_2 = json_value_get_object ( arrsub_val_2 ) ; json_object_dotset_number ( arrsub_o_2 , "hasValue.value" , duration ) ; json_object_dotset_string ( arrsub_o_2 , "uuid.value" , "duration" ) ; json_array_append_value ( arrsub_obj , arrsub_val_2 ) ; json_array_append_value ( arr_obj , arrval ) ; json_object_dotset_string ( root_object , "hasEventDescriptionUuid.value" , "5392" ) ; JSON_Value * loc2val = json_value_init_object ( ) ; JSON_Object * loc2 = json_value_get_object ( loc2val ) ; <S2SV_StartBug> json_object_set_string ( loc2 , "value" , "-7482202863293359861" ) ; <S2SV_EndBug> json_object_dotset_value ( root_object , "hasLocation.measLocId" , loc2val ) ; JSON_Value * times2val = json_value_init_object ( ) ; JSON_Object * times2 = json_value_get_object ( times2val ) ; json_object_set_string ( times2 , "format" , "DATETIME" ) ; <S2SV_StartBug> json_object_set_string ( times2 , "value" , "2017.04.19.9:45:12" ) ; <S2SV_EndBug> json_object_dotset_value ( root_object , "hasTimestamp.hasUTCDateTime" , times2val ) ; serialized_string = json_serialize_to_string_pretty ( root_value ) ; if ( available ( & MQTT ) ) { publish ( & MQTT , QoSVal . s_DUP , QoSVal . s_QoS , QoSVal . s_RETAIN , _generateMessageID ( & MQTT ) , "/movement" , serialized_string ) ; } json_free_serialized_string ( serialized_string ) ; json_value_free ( root_value ) ; return ; } | <S2SV_ModStart> uint32_t duration , char * meas_loc , char * timeStamp , <S2SV_ModStart> , "value" , meas_loc <S2SV_ModEnd> ) ; json_object_dotset_value <S2SV_ModStart> , "value" , timeStamp <S2SV_ModEnd> ) ; json_object_dotset_value |
389 | CWE-000 void dr_delete ( dr_t * dr ) <S2SV_StartBug> { <S2SV_EndBug> XPLMUnregisterDataAccessor ( dr -> dr ) ; memset ( dr , 0 , sizeof ( * dr ) ) ; } | <S2SV_ModStart> dr ) { VERIFY_MSG ( dr -> value != NULL , "%s" , dr -> name ) ; |
390 | CWE-000 static void _outWindowAggPath ( StringInfo str , const WindowAggPath * node ) { WRITE_NODE_TYPE ( "WINDOWAGGPATH" ) ; _outPathInfo ( str , ( const Path * ) node ) ; WRITE_NODE_FIELD ( subpath ) ; WRITE_NODE_FIELD ( winclause ) ; <S2SV_StartBug> WRITE_NODE_FIELD ( winpathkeys ) ; <S2SV_EndBug> } | <S2SV_ModStart> winclause ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
391 | CWE-000 void ovs_numa_info_init ( struct ovsdb_idl * idl ) { <S2SV_StartBug> static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER ; <S2SV_EndBug> if ( ovsthread_once_start ( & once ) ) { struct ovsdb_idl_txn * txn = ovsdb_idl_txn_create ( idl ) ; struct ovsrec_hardwareinfo * hardware_info ; enum ovsdb_idl_txn_status status ; bool status_txn_try_again = false ; int64_t numanodenum = hmap_count ( & all_numa_nodes ) ; unsigned int idl_seq = ovsdb_idl_get_seqno ( idl ) ; VLOG_INFO ( "IDL<S2SV_blank>seqno<S2SV_blank>is<S2SV_blank>%d" , idl_seq ) ; do { hardware_info = ovsrec_hardwareinfo_insert ( txn ) ; ovsrec_hardwareinfo_set_NumaNodeNum ( hardware_info , numanodenum ) ; status = ovsdb_idl_txn_commit ( txn ) ; VLOG_INFO ( "set<S2SV_blank>hardware_info<S2SV_blank>numa<S2SV_blank>node<S2SV_blank>number." ) ; ovsdb_idl_run ( idl ) ; VLOG_INFO ( "called<S2SV_blank>ovsdb_idl_run." ) ; if ( status != TXN_INCOMPLETE ) { ovsdb_idl_txn_destroy ( txn ) ; if ( status == TXN_SUCCESS || status == TXN_UNCHANGED ) { status_txn_try_again = false ; if ( status == TXN_SUCCESS ) { VLOG_INFO ( "txn<S2SV_blank>success!" ) ; } } else { status_txn_try_again = true ; VLOG_WARN ( "retry:<S2SV_blank>set<S2SV_blank>hardware_info<S2SV_blank>numa<S2SV_blank>node<S2SV_blank>number." ) ; } } } while ( status_txn_try_again ) ; <S2SV_StartBug> ovsthread_once_done ( & once ) ; <S2SV_EndBug> } } | <S2SV_ModStart> idl ) { if ( ! done <S2SV_ModEnd> ) { struct <S2SV_ModStart> status_txn_try_again ) ; done = true <S2SV_ModEnd> ; } } |
392 | CWE-000 void clear_order_in_queue ( int floor ) { <S2SV_StartBug> if ( floor < NUM_FLOORS || floor >= NUM_FLOORS ) { <S2SV_EndBug> fprintf ( stderr , "Invalid<S2SV_blank>floor\\n" ) ; return ; } orders_up [ floor ] = NO_ORDER ; orders_down [ floor ] = NO_ORDER ; orders_destination [ floor ] = NO_ORDER ; printf ( "Clear<S2SV_blank>order<S2SV_blank>at<S2SV_blank>floor<S2SV_blank>%i\\n" , floor ) ; } | <S2SV_ModStart> ( floor < 0 <S2SV_ModEnd> || floor >= |
393 | CWE-000 static int gpio_cc2650_config_pin ( int pin , int flags ) { const u32_t iocfg = REG_ADDR ( TI_CC2650_PINMUX_40081000_BASE_ADDRESS , CC2650_IOC_IOCFG0 + 0x4 * pin ) ; u32_t iocfg_config = sys_read32 ( iocfg ) ; u32_t gpio_doe31_0_config = sys_read32 ( doe31_0 ) ; iocfg_config &= ~ ( CC2650_IOC_IOCFGX_IOSTR_MASK | CC2650_IOC_IOCFGX_PULL_CTL_MASK | CC2650_IOC_IOCFGX_EDGE_DET_MASK | CC2650_IOC_IOCFGX_EDGE_IRQ_EN_MASK | CC2650_IOC_IOCFGX_IOMODE_MASK | CC2650_IOC_IOCFGX_IE_MASK | CC2650_IOC_IOCFGX_HYST_EN_MASK ) ; if ( flags & GPIO_PIN_DISABLE ) { disconnect ( pin , & gpio_doe31_0_config , & iocfg_config ) ; goto commit_config ; } if ( flags & GPIO_DIR_OUT ) { gpio_doe31_0_config |= BIT ( pin ) ; iocfg_config |= CC2650_IOC_INPUT_DISABLED ; } else { gpio_doe31_0_config &= ~ BIT ( pin ) ; iocfg_config |= CC2650_IOC_INPUT_ENABLED ; } if ( flags & GPIO_INT ) { if ( ! ( flags & GPIO_INT_EDGE ) && ! ( flags & GPIO_INT_DOUBLE_EDGE ) ) { return - ENOTSUP ; } iocfg_config |= BIT ( CC2650_IOC_IOCFGX_EDGE_IRQ_EN_POS ) ; if ( flags & GPIO_INT_EDGE ) { if ( flags & GPIO_INT_ACTIVE_HIGH ) { iocfg_config |= CC2650_IOC_POS_EDGE_DET ; } else { iocfg_config |= CC2650_IOC_NEG_EDGE_DET ; } } else if ( flags & GPIO_INT_DOUBLE_EDGE ) { iocfg_config |= CC2650_IOC_NEG_AND_POS_EDGE_DET ; } if ( flags & GPIO_INT_CLOCK_SYNC ) { return - ENOTSUP ; } if ( flags & GPIO_INT_DEBOUNCE ) { iocfg_config |= CC2650_IOC_HYSTERESIS_ENABLED ; } else { iocfg_config |= CC2650_IOC_HYSTERESIS_DISABLED ; } } if ( flags & GPIO_POL_INV ) { iocfg_config |= CC2650_IOC_INVERTED_IO ; } else { iocfg_config |= CC2650_IOC_NORMAL_IO ; } if ( flags & GPIO_PUD_NORMAL ) { iocfg_config |= CC2650_IOC_NO_PULL ; } else if ( flags & GPIO_PUD_PULL_UP ) { iocfg_config |= CC2650_IOC_PULL_UP ; } else if ( flags & GPIO_PUD_PULL_DOWN ) { iocfg_config |= CC2650_IOC_PULL_DOWN ; } if ( flags & GPIO_DS_DISCONNECT_LOW ) { disconnect ( pin , & gpio_doe31_0_config , & iocfg_config ) ; } <S2SV_StartBug> if ( flags & GPIO_DS_DFLT_LOW ) { <S2SV_EndBug> iocfg_config |= CC2650_IOC_MIN_DRIVE_STRENGTH ; } else { iocfg_config |= CC2650_IOC_MAX_DRIVE_STRENGTH ; } commit_config : sys_write32 ( iocfg_config , iocfg ) ; sys_write32 ( gpio_doe31_0_config , doe31_0 ) ; return 0 ; } | <S2SV_ModStart> } if ( ! ( flags & GPIO_DS_ALT_LOW ) <S2SV_ModEnd> ) { iocfg_config |
394 | CWE-000 int elf_mem_subst ( void * mem , int len , long pat , long val ) { int i ; long data ; unsigned char * ptr ; ptr = ( unsigned char * ) mem ; for ( i = 0 ; i < len ; i ++ ) { data = * ( ( long * ) ( ptr + i ) ) ; if ( ( data ^ pat ) == 0 ) { * ( ( long * ) ( ptr + i ) ) = val ; <S2SV_StartBug> log_debugf ( "pattern<S2SV_blank>%lx<S2SV_blank>at<S2SV_blank>offset<S2SV_blank>%d<S2SV_blank>-><S2SV_blank>%lx" , pat , i , val ) ; <S2SV_EndBug> return 0 ; } } return - 1 ; } | <S2SV_ModStart> ; log_debugf ( "pattern<S2SV_blank>found<S2SV_blank>at<S2SV_blank>offset<S2SV_blank>%d<S2SV_blank>-><S2SV_blank>0x%lx" <S2SV_ModEnd> , pat , |
395 | CWE-000 static void do_one_unbind ( union specbinding * this_binding , bool unwinding , enum Set_Internal_Bind bindflag ) { eassert ( unwinding || this_binding -> kind >= SPECPDL_LET ) ; switch ( this_binding -> kind ) { case SPECPDL_UNWIND : <S2SV_StartBug> this_binding -> unwind . func ( this_binding -> unwind . arg ) ; <S2SV_EndBug> break ; case SPECPDL_UNWIND_ARRAY : xfree ( this_binding -> unwind_array . array ) ; break ; case SPECPDL_UNWIND_PTR : this_binding -> unwind_ptr . func ( this_binding -> unwind_ptr . arg ) ; break ; case SPECPDL_UNWIND_INT : this_binding -> unwind_int . func ( this_binding -> unwind_int . arg ) ; break ; case SPECPDL_UNWIND_VOID : this_binding -> unwind_void . func ( ) ; break ; case SPECPDL_UNWIND_EXCURSION : save_excursion_restore ( this_binding -> unwind_excursion . marker , this_binding -> unwind_excursion . window ) ; break ; case SPECPDL_BACKTRACE : break ; case SPECPDL_LET : { Lisp_Object sym = specpdl_symbol ( this_binding ) ; if ( SYMBOLP ( sym ) && XSYMBOL ( sym ) -> u . s . redirect == SYMBOL_PLAINVAL ) { if ( XSYMBOL ( sym ) -> u . s . trapped_write == SYMBOL_UNTRAPPED_WRITE ) SET_SYMBOL_VAL ( XSYMBOL ( sym ) , specpdl_old_value ( this_binding ) ) ; else set_internal ( sym , specpdl_old_value ( this_binding ) , Qnil , bindflag ) ; break ; } } FALLTHROUGH ; case SPECPDL_LET_DEFAULT : set_default_internal ( specpdl_symbol ( this_binding ) , specpdl_old_value ( this_binding ) , bindflag ) ; break ; case SPECPDL_LET_LOCAL : { Lisp_Object symbol = specpdl_symbol ( this_binding ) ; Lisp_Object where = specpdl_where ( this_binding ) ; Lisp_Object old_value = specpdl_old_value ( this_binding ) ; eassert ( BUFFERP ( where ) ) ; if ( ! NILP ( Flocal_variable_p ( symbol , where ) ) ) set_internal ( symbol , old_value , where , bindflag ) ; } break ; } } | <S2SV_ModStart> case SPECPDL_UNWIND : lisp_eval_depth = this_binding -> unwind . eval_depth ; |
396 | CWE-000 static void smc_prefetch_set_insert_from_buf ( SMCSet * smc_set , const void * buf , int nb_eles ) { int new_cap = smc_set -> cap ; if ( new_cap < nb_eles ) { do { new_cap += SMC_SET_INIT_CAP ; } while ( new_cap - smc_set -> nb_eles < nb_eles ) ; <S2SV_StartBug> smc_prefetch_set_resize ( smc_set , new_cap ) ; <S2SV_EndBug> } memcpy ( smc_set -> eles , buf , nb_eles * smc_set -> ele_size + 2 ) ; smc_set -> nb_eles = nb_eles ; } | <S2SV_ModStart> nb_eles ) ; smc_set_resize <S2SV_ModEnd> ( smc_set , |
397 | CWE-000 bool messages_mleave ( PANEL * UNUSED ( m ) ) { <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> ) { return false <S2SV_ModEnd> ; } <S2SV_null> |
398 | CWE-000 RSA * parse_ssh_pubkey ( char * file , char * key , int keysize ) { <S2SV_StartBug> unsigned long i ; <S2SV_EndBug> char buf [ SSH_MAX_PUBKEY_BYTES ] ; int offset = 0 ; RSA * rsa = RSA_new ( ) ; if ( ! rsa ) log_err_exit ( "Could<S2SV_blank>not<S2SV_blank>allocate<S2SV_blank>RSA" ) ; rsa -> e = BN_new ( ) ; if ( ! rsa -> e ) log_err_exit ( "Could<S2SV_blank>not<S2SV_blank>allocate<S2SV_blank>BIGNUM" ) ; rsa -> n = BN_new ( ) ; if ( ! rsa -> n ) log_err_exit ( "Could<S2SV_blank>not<S2SV_blank>allocate<S2SV_blank>BIGNUM" ) ; read_bytes ( key , keysize , 4 , & offset , & i ) ; i = ntohl ( i ) ; read_bytes ( key , keysize , i , & offset , & buf ) ; buf [ i ] = '\\0' ; if ( strcmp ( buf , "ssh-rsa" ) ) log_err_exit ( "%s<S2SV_blank>does<S2SV_blank>not<S2SV_blank>appear<S2SV_blank>to<S2SV_blank>contain<S2SV_blank>an<S2SV_blank>SSH<S2SV_blank>RSA<S2SV_blank>public<S2SV_blank>key" , file ) ; read_bytes ( key , keysize , 4 , & offset , & i ) ; i = ntohl ( i ) ; read_bytes ( key , keysize , i , & offset , & buf ) ; if ( BN_bin2bn ( ( unsigned char * ) buf , i , rsa -> e ) == NULL ) log_err_exit ( "buffer_get_bignum2_ret:<S2SV_blank>BN_bin2bn<S2SV_blank>failed" ) ; read_bytes ( key , keysize , 4 , & offset , & i ) ; i = ntohl ( i ) ; read_bytes ( key , keysize , i , & offset , & buf ) ; if ( BN_bin2bn ( ( unsigned char * ) buf , i , rsa -> n ) == NULL ) log_err_exit ( "buffer_get_bignum2_ret:<S2SV_blank>BN_bin2bn<S2SV_blank>failed" ) ; return rsa ; } | <S2SV_ModStart> keysize ) { uint32_t <S2SV_ModEnd> i ; char |
399 | CWE-000 static int pre_munmap ( void * buf , size_t length ) { int ret ; ret = munmap ( buf , length ) ; # ifdef RAMMETRICS j__TotalBytesAllocated -= length ; if ( j__MFlag ) <S2SV_StartBug> PRINTMUMAP ( buf , length ) ; <S2SV_EndBug> # endif return ( ret ) ; } | <S2SV_ModStart> ( j__MFlag ) PRINTMUNMAP <S2SV_ModEnd> ( buf , |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.