Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
4,200 | CWE-000 <S2SV_StartBug> static inline int hashKey ( Hashmap * map , void * key ) { <S2SV_EndBug> <S2SV_StartBug> int h = map -> hash ( key ) ; <S2SV_EndBug> h += ~ ( h << 9 ) ; h ^= ( ( ( unsigned int ) h ) >> 14 ) ; h += ( h << 4 ) ; h ^= ( ( ( unsigned int ) h ) >> 10 ) ; return h ; } | <S2SV_ModStart> <S2SV_null> static inline unsigned <S2SV_ModStart> key ) { unsigned |
4,201 | CWE-000 int msm_isp_axi_create_stream ( struct msm_vfe_axi_shared_data * axi_data , struct msm_vfe_axi_stream_request_cmd * stream_cfg_cmd ) { <S2SV_StartBug> int i , rc = - 1 ; <S2SV_EndBug> for ( i = 0 ; i < MAX_NUM_STREAM ; i ++ ) { if ( axi_data -> stream_info [ i ] . state == AVALIABLE ) break ; } if ( i == MAX_NUM_STREAM ) { pr_err ( "%s:<S2SV_blank>No<S2SV_blank>free<S2SV_blank>stream\\n" , __func__ ) ; return rc ; } axi_data -> created_streams_num ++ ; if ( ( axi_data -> stream_handle_cnt << 8 ) == 0 ) axi_data -> stream_handle_cnt ++ ; stream_cfg_cmd -> axi_stream_handle = ( ++ axi_data -> stream_handle_cnt ) << 8 | i ; memset ( & axi_data -> stream_info [ i ] , 0 , sizeof ( struct msm_vfe_axi_stream ) ) ; axi_data -> stream_info [ i ] . session_id = stream_cfg_cmd -> session_id ; axi_data -> stream_info [ i ] . stream_id = stream_cfg_cmd -> stream_id ; axi_data -> stream_info [ i ] . buf_divert = stream_cfg_cmd -> buf_divert ; axi_data -> stream_info [ i ] . state = INACTIVE ; axi_data -> stream_info [ i ] . stream_handle = stream_cfg_cmd -> axi_stream_handle ; return 0 ; } | <S2SV_ModStart> ) { int <S2SV_ModEnd> rc = - <S2SV_ModStart> = - 1 ; uint32_t i |
4,202 | CWE-000 void enqueue ( struct Node * * start , int data ) { if ( ( * start ) == NULL ) { <S2SV_StartBug> struct Node * newnode = ( struct Node * ) malloc ( sizeof ( struct Node ) ) ; <S2SV_EndBug> newnode -> data = data ; newnode -> next = NULL ; * start = newnode ; } else { struct Node * copy = * start ; struct Node * newnode ; while ( copy -> next != NULL ) copy = copy -> next ; <S2SV_StartBug> newnode = ( struct Node * ) malloc ( sizeof ( struct Node ) ) ; <S2SV_EndBug> newnode -> data = data ; newnode -> next = NULL ; copy -> next = newnode ; } } | <S2SV_ModStart> * newnode = <S2SV_ModEnd> malloc ( sizeof <S2SV_ModStart> ; newnode = <S2SV_ModEnd> malloc ( sizeof |
4,203 | CWE-000 int main ( void ) { state state = MenuStart ; while ( true ) { switch ( state ) { case MenuStart : { configure_MenuStart ( ) ; is_solved = play_MenuStart ( ) ; if ( is_solved == 1 ) state = Room1 ; break ; } case Room1 : { <S2SV_StartBug> configure_Room1 ( ) ; <S2SV_EndBug> is_solved = play_Room1 ( ) ; if ( is_solved == 1 ) state = Room2 ; break ; } case Room2 : { configure_Room2 ( ) ; is_solved = play_Room2 ( ) ; if ( is_solved == 1 ) state = MenuEnd ; break ; } case MenuEnd : { configure_MenuEnd ( ) ; is_solved = play_MenuEnd ( ) ; if ( is_solved == 1 ) state = MenuStart ; break ; } } is_solved = 0 ; } return 0 ; } | <S2SV_ModStart> Room1 : { configure_room1_gfx <S2SV_ModEnd> ( ) ; |
4,204 | CWE-000 <S2SV_StartBug> static void <S2SV_EndBug> test2_list ( void ) { struct list list ; list_init ( & list ) ; struct person daniel = { . name = "Daniel" , . n = NODE_INIT } ; struct person daniela = { . name = "Daniela" , . n = NODE_INIT } ; struct person adam = { . name = "Adam" , . n = NODE_INIT } ; struct person eve = { . name = "Eve" , . n = NODE_INIT } ; struct person robot = { . name = "Robot" , . n = NODE_INIT } ; struct person daniel1 = { . name = "Daniel" , . n = NODE_INIT } ; list_add ( & list , LIST_ITEM ( daniel , n ) ) ; list_add ( & list , LIST_ITEM ( daniela , n ) ) ; list_add ( & list , LIST_ITEM ( adam , n ) ) ; list_add ( & list , LIST_ITEM ( eve , n ) ) ; list_add ( & list , LIST_ITEM ( robot , n ) ) ; list_add ( & list , LIST_ITEM ( daniel1 , n ) ) ; list_sort ( & list , person_node_cmp ) ; list_for_each ( list , n ) printf ( "dfn:%s\\n" , __container_of ( n , struct person , n ) -> name ) ; list_sort_asc ( & list , person_node_cmp ) ; list_for_each ( list , n ) printf ( "asc:%s\\n" , __container_of ( n , struct person , n ) -> name ) ; list_sort_dsc ( & list , person_node_cmp ) ; list_for_each ( list , n ) printf ( "dsc:%s\\n" , __container_of ( n , struct person , n ) -> name ) ; list_sort ( & list , person_cmp , struct person , n ) ; list_for_each ( list , n ) printf ( "dfn:%s\\n" , __container_of ( n , struct person , n ) -> name ) ; list_sort_asc ( & list , person_cmp , struct person , n ) ; list_for_each ( list , n ) printf ( "asc:%s\\n" , __container_of ( n , struct person , n ) -> name ) ; list_sort_dsc ( & list , person_cmp , struct person , n ) ; list_for_each ( list , n ) printf ( "dsc:%s\\n" , __container_of ( n , struct person , n ) -> name ) ; list_sort ( & list , person_node_cmp ) ; list_ddup ( & list , person_node_cmp ) ; list_for_each ( list , n ) printf ( "dup:%s\\n" , __container_of ( n , struct person , n ) -> name ) ; list_sort ( & list , person_cmp , struct person , n ) ; list_ddup ( & list , person_cmp , struct person , n ) ; list_for_each ( list , n ) printf ( "dup:%s\\n" , __container_of ( n , struct person , n ) -> name ) ; list_for_each_delsafe ( list , n ) list_del ( n ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> _unused |
4,205 | CWE-000 int main ( ) { HEAP * prQueue1 , * prQueue2 ; char exit , bufferCleaner ; CUST * cust ; bool result ; int numCusts = 0 ; prQueue1 = heapCreate ( maxQueue , compareCust ) ; prQueue2 = heapCreate ( maxQueue , compareCust ) ; printf ( "\\n<S2SV_blank>------<S2SV_blank>Queue<S2SV_blank>1<S2SV_blank>------" ) ; printf ( "\\n<S2SV_blank>Type<S2SV_blank>q<S2SV_blank>to<S2SV_blank>exit\\n" ) ; printf ( "<S2SV_blank>Type<S2SV_blank>y<S2SV_blank>to<S2SV_blank>continue<S2SV_blank>adding\\n\\n" ) ; do { cust = getCust ( ) ; <S2SV_StartBug> cust -> serial = cust -> priority * 1000 + ( 1000 - numCusts ) ; <S2SV_EndBug> result = heapInsert ( prQueue1 , cust ) ; printf ( "Keep<S2SV_blank>adding?\\n" ) ; scanf ( "%c%c" , & bufferCleaner , & exit ) ; } while ( exit != 'q' ) ; printf ( "\\n<S2SV_blank>------<S2SV_blank>Queue<S2SV_blank>2<S2SV_blank>------" ) ; printf ( "\\n<S2SV_blank>Type<S2SV_blank>q<S2SV_blank>to<S2SV_blank>exit\\n" ) ; printf ( "<S2SV_blank>Type<S2SV_blank>y<S2SV_blank>to<S2SV_blank>continue<S2SV_blank>adding\\n\\n" ) ; do { cust = getCust ( ) ; <S2SV_StartBug> cust -> serial = cust -> priority * 1000 + ( 1000 - numCusts ) ; <S2SV_EndBug> result = heapInsert ( prQueue2 , cust ) ; printf ( "Keep<S2SV_blank>adding?\\n" ) ; scanf ( "%c%c" , & bufferCleaner , & exit ) ; } while ( exit != 'q' ) ; return 0 ; } | <S2SV_ModStart> ( ) ; numCusts ++ ; <S2SV_ModStart> ( ) ; numCusts ++ ; |
4,206 | CWE-000 int grub_linuxefi_secure_validate ( void * data , grub_uint32_t size ) { grub_efi_guid_t guid = SHIM_LOCK_GUID ; grub_efi_shim_lock_t * shim_lock ; grub_efi_status_t status ; shim_lock = grub_efi_locate_protocol ( & guid , NULL ) ; grub_dprintf ( "secureboot" , "shim_lock:<S2SV_blank>%p\\n" , shim_lock ) ; if ( ! shim_lock ) { grub_dprintf ( "secureboot" , "shim<S2SV_blank>not<S2SV_blank>available\\n" ) ; return 0 ; } grub_dprintf ( "secureboot" , "Asking<S2SV_blank>shim<S2SV_blank>to<S2SV_blank>verify<S2SV_blank>kernel<S2SV_blank>signature\\n" ) ; status = shim_lock -> verify ( data , size ) ; <S2SV_StartBug> grub_dprintf ( "secureboot" , "shim_lock->verify():<S2SV_blank>%ld\\n" , status ) ; <S2SV_EndBug> if ( status == GRUB_EFI_SUCCESS ) { grub_dprintf ( "secureboot" , "Kernel<S2SV_blank>signature<S2SV_blank>verification<S2SV_blank>passed\\n" ) ; return 1 ; } grub_dprintf ( "secureboot" , "Kernel<S2SV_blank>signature<S2SV_blank>verification<S2SV_blank>failed<S2SV_blank>(0x%lx)\\n" , ( unsigned long ) status ) ; return - 1 ; } | <S2SV_ModStart> , "shim_lock->verify():<S2SV_blank>%ld\\n" , ( unsigned long ) |
4,207 | CWE-000 <S2SV_StartBug> unsigned long dma_alloc_from_contiguous ( struct device * dev , int count , <S2SV_EndBug> unsigned int align ) { unsigned long mask , pfn = 0 , pageno , start = 0 ; struct cma * cma = dev_get_cma_area ( dev ) ; int ret = 0 ; int tries = 0 ; if ( ! cma || ! cma -> count ) return 0 ; if ( align > CONFIG_CMA_ALIGNMENT ) align = CONFIG_CMA_ALIGNMENT ; <S2SV_StartBug> pr_debug ( "%s(cma<S2SV_blank>%p,<S2SV_blank>count<S2SV_blank>%d,<S2SV_blank>align<S2SV_blank>%d)\\n" , __func__ , ( void * ) cma , <S2SV_EndBug> count , align ) ; if ( ! count ) return 0 ; mask = ( 1 << align ) - 1 ; for ( ; ; ) { mutex_lock ( & cma -> lock ) ; pageno = bitmap_find_next_zero_area ( cma -> bitmap , cma -> count , start , count , mask ) ; if ( pageno >= cma -> count ) { pfn = 0 ; mutex_unlock ( & cma -> lock ) ; break ; } bitmap_set ( cma -> bitmap , pageno , count ) ; mutex_unlock ( & cma -> lock ) ; pfn = cma -> base_pfn + pageno ; if ( cma -> in_system ) { mutex_lock ( & cma_mutex ) ; ret = alloc_contig_range ( pfn , pfn + count , MIGRATE_CMA ) ; mutex_unlock ( & cma_mutex ) ; } if ( ret == 0 ) { break ; } else if ( ret != - EBUSY ) { pfn = 0 ; clear_cma_bitmap ( cma , pfn , count ) ; break ; } clear_cma_bitmap ( cma , pfn , count ) ; tries ++ ; trace_dma_alloc_contiguous_retry ( tries ) ; pr_debug ( "%s():<S2SV_blank>memory<S2SV_blank>range<S2SV_blank>at<S2SV_blank>%p<S2SV_blank>is<S2SV_blank>busy,<S2SV_blank>retrying\\n" , __func__ , pfn_to_page ( pfn ) ) ; start = pageno + mask + 1 ; } pr_debug ( "%s():<S2SV_blank>returned<S2SV_blank>%lx\\n" , __func__ , pfn ) ; return pfn ; } | <S2SV_ModStart> * dev , size_t <S2SV_ModEnd> count , unsigned <S2SV_ModStart> ; pr_debug ( "%s(cma<S2SV_blank>%p,<S2SV_blank>count<S2SV_blank>%zu,<S2SV_blank>align<S2SV_blank>%d)\\n" <S2SV_ModEnd> , __func__ , |
4,208 | CWE-000 unsigned char phNxpNciHal_initParser ( ) { char * error ; void * lib_handle ; sParserContext_t * psContext = & sParserContext ; memset ( & psContext -> sEntryFuncs , 0 , sizeof ( psContext -> sEntryFuncs ) ) ; psContext -> pvHandle = NULL ; psContext -> sEntryFuncs . createParser = NULL ; psContext -> sEntryFuncs . initParser = NULL ; psContext -> sEntryFuncs . deinitParser = NULL ; psContext -> sEntryFuncs . destroyParser = NULL ; psContext -> sEntryFuncs . parsePacket = NULL ; NXPLOG_NCIHAL_D ( "%s:<S2SV_blank>enter" , __FUNCTION__ ) ; <S2SV_StartBug> lib_handle = dlopen ( NXP_NCI_PARSER_PATH , RTLD_LAZY ) ; <S2SV_EndBug> if ( ! lib_handle ) { NXPLOG_NCIHAL_E ( "%s:<S2SV_blank>dlopen<S2SV_blank>failed<S2SV_blank>!!!" , __FUNCTION__ ) ; return FALSE ; } psContext -> sEntryFuncs . createParser = dlsym ( lib_handle , "native_createParser" ) ; if ( psContext -> sEntryFuncs . createParser == NULL ) { NXPLOG_NCIHAL_E ( "%s:<S2SV_blank>dlsym<S2SV_blank>native_createParser<S2SV_blank>failed<S2SV_blank>!!!" , __FUNCTION__ ) ; return FALSE ; } psContext -> sEntryFuncs . destroyParser = dlsym ( lib_handle , "native_destroyParser" ) ; if ( psContext -> sEntryFuncs . destroyParser == NULL ) { NXPLOG_NCIHAL_E ( "%s:<S2SV_blank>dlsym<S2SV_blank>native_destroyParser<S2SV_blank>failed<S2SV_blank>!!!" , __FUNCTION__ ) ; return FALSE ; } psContext -> sEntryFuncs . initParser = dlsym ( lib_handle , "native_initParser" ) ; if ( psContext -> sEntryFuncs . initParser == NULL ) { NXPLOG_NCIHAL_E ( "%s:<S2SV_blank>dlsym<S2SV_blank>native_initParser<S2SV_blank>failed<S2SV_blank>!!!" , __FUNCTION__ ) ; return FALSE ; } psContext -> sEntryFuncs . deinitParser = dlsym ( lib_handle , "native_deinitParser" ) ; if ( psContext -> sEntryFuncs . deinitParser == NULL ) { NXPLOG_NCIHAL_E ( "%s:<S2SV_blank>dlsym<S2SV_blank>native_deinitParser<S2SV_blank>failed<S2SV_blank>!!!" , __FUNCTION__ ) ; return FALSE ; } psContext -> sEntryFuncs . parsePacket = dlsym ( lib_handle , "native_parseNciMsg" ) ; if ( psContext -> sEntryFuncs . parsePacket == NULL ) { NXPLOG_NCIHAL_E ( "%s:<S2SV_blank>dlsym<S2SV_blank>native_parseNciMsg<S2SV_blank>failed<S2SV_blank>!!!" , __FUNCTION__ ) ; return FALSE ; } psContext -> pvHandle = ( * ( psContext -> sEntryFuncs . createParser ) ) ( ) ; if ( psContext -> pvHandle != NULL ) { ( * ( psContext -> sEntryFuncs . initParser ) ) ( psContext -> pvHandle ) ; } else { NXPLOG_NCIHAL_E ( "Parser<S2SV_blank>Creation<S2SV_blank>Failed<S2SV_blank>!!!" ) ; return FALSE ; } NXPLOG_NCIHAL_D ( "%s:<S2SV_blank>exit" , __FUNCTION__ ) ; return TRUE ; } | <S2SV_ModStart> ( NXP_NCI_PARSER_PATH , RTLD_NOW <S2SV_ModEnd> ) ; if |
4,209 | CWE-000 <S2SV_StartBug> long __attribute__ ( ( noinline ) ) <S2SV_EndBug> my_gettid ( void ) { long ret ; # ifdef __x86_64 asm volatile ( "syscall" : "=a" ( ret ) : "0" ( __NR_gettid ) : "cc" , "rcx" , "r11" , "memory" ) ; # elif __i386 asm volatile ( "int<S2SV_blank>$0x80" : "=a" ( ret ) : "0" ( __NR_gettid ) : "cc" , "edi" , "esi" , "memory" ) ; # else # error "Userspace<S2SV_blank>callstack<S2SV_blank>test<S2SV_blank>not<S2SV_blank>supported<S2SV_blank>for<S2SV_blank>this<S2SV_blank>architecture." # endif return ret ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> long nooptimization <S2SV_ModEnd> my_gettid ( void |
4,210 | CWE-000 static void scale_i ( matrix_type_t at , byte_t * ap , size_t as , matrix_type_t ct , byte_t * cp , size_t cs , size_t n , size_t m , int64_t factor ) { if ( at == ct ) { # ifdef USE_GCC_VECTOR if ( is_aligned ( ap ) && is_aligned ( cp ) ) <S2SV_StartBug> mtv_scale_i_ ( at , ap , as , cp , cs , n , m , factor ) ; <S2SV_EndBug> else # endif <S2SV_StartBug> mt_scale_i_ ( at , ap , as , cp , cs , n , m , factor ) ; <S2SV_EndBug> } else if ( element_is_float ( at ) ) { size_t elem_size_a = element_size ( at ) ; size_t elem_size_c = element_size ( ct ) ; while ( n -- ) { byte_t * ap1 = ap ; byte_t * cp1 = cp ; size_t m1 = m ; while ( m1 -- ) { float64_t a = read_float ( at , ap1 ) ; ap1 += elem_size_a ; write_float ( ct , cp1 , a * factor ) ; cp1 += elem_size_c ; } ap += as * elem_size_a ; cp += cs * elem_size_c ; } } else { size_t elem_size_a = element_size ( at ) ; size_t elem_size_c = element_size ( ct ) ; while ( n -- ) { byte_t * ap1 = ap ; byte_t * cp1 = cp ; size_t m1 = m ; while ( m1 -- ) { int64_t a = read_int ( at , ap1 ) ; ap1 += elem_size_a ; write_int ( ct , cp1 , a * factor ) ; cp1 += elem_size_c ; } ap += as * elem_size_a ; cp += cs * elem_size_c ; } } } | <S2SV_ModStart> cp ) ) mtv_scale_i <S2SV_ModEnd> ( at , <S2SV_ModStart> else # endif mt_scale_i <S2SV_ModEnd> ( at , |
4,211 | CWE-000 static int avb_capture_hw_params ( struct snd_pcm_substream * substream , struct snd_pcm_hw_params * hw_params ) { struct avbcard * avbcard = snd_pcm_substream_chip ( substream ) ; avbcard -> rx . substream = substream ; avbcard -> rx . hwIdx = 0 ; <S2SV_StartBug> avbcard -> rx . hwnwIdx = 0 ; <S2SV_EndBug> avbcard -> rx . fillsize = 0 ; <S2SV_StartBug> avbcard -> rx . prevHwIdx = 0 ; <S2SV_EndBug> avbcard -> rx . numBytesConsumed = 0 ; avbcard -> rx . periodsize = params_period_size ( hw_params ) ; avbcard -> rx . buffersize = params_buffer_bytes ( hw_params ) ; avbcard -> rx . framecount = params_buffer_size ( hw_params ) ; avbcard -> rx . framesize = params_buffer_bytes ( hw_params ) / params_buffer_size ( hw_params ) ; avb_log ( AVB_KERN_NOT , KERN_NOTICE "avb_capture_hw_params<S2SV_blank>buffersize:%lu<S2SV_blank>framesize:%lu" , avbcard -> rx . buffersize , avbcard -> rx . framesize ) ; avbdevice . avtpwd = ( struct workdata * ) kmalloc ( sizeof ( struct workdata ) , GFP_KERNEL ) ; if ( avbdevice . avtpwd == NULL ) { avb_log ( AVB_KERN_ERR , KERN_ERR "avb_capture_hw_params<S2SV_blank>avtp<S2SV_blank>workdata<S2SV_blank>allocation<S2SV_blank>failed" ) ; return - 1 ; } memset ( & avbdevice . rxts [ 0 ] , 0 , ( sizeof ( int ) * AVB_MAX_TS_SLOTS ) ) ; avbdevice . rxIdx = 0 ; avbdevice . avtpwd -> dw . card = avbcard ; avbdevice . avtpwd -> delayedWorkId = AVB_DELAY_WORK_AVTP ; INIT_DELAYED_WORK ( ( struct delayed_work * ) avbdevice . avtpwd , avbWqFn ) ; queue_delayed_work ( avbdevice . wq , ( struct delayed_work * ) avbdevice . avtpwd , 1 ) ; avbcard -> rx . tmpbuf = kmalloc ( avbcard -> rx . buffersize , GFP_KERNEL ) ; return 0 ; } | <S2SV_ModStart> -> rx . seqNo = 0 ; avbcard -> rx . <S2SV_ModStart> rx . prevHwIdx = 0 ; avbcard -> rx . socketCount |
4,212 | CWE-000 void intel_update_r8stencil ( struct brw_context * brw , struct intel_mipmap_tree * mt ) { const struct gen_device_info * devinfo = & brw -> screen -> devinfo ; assert ( devinfo -> gen >= 7 ) ; struct intel_mipmap_tree * src = mt -> format == MESA_FORMAT_S_UINT8 ? mt : mt -> stencil_mt ; if ( ! src || devinfo -> gen >= 8 ) return ; assert ( src -> surf . size > 0 ) ; <S2SV_StartBug> if ( ! mt -> r8stencil_mt ) { <S2SV_EndBug> assert ( devinfo -> gen > 6 ) ; <S2SV_StartBug> mt -> r8stencil_mt = make_surface ( <S2SV_EndBug> brw , src -> target , MESA_FORMAT_R_UINT8 , src -> first_level , src -> last_level , src -> surf . logical_level0_px . width , src -> surf . logical_level0_px . height , src -> surf . dim == ISL_SURF_DIM_3D ? src -> surf . logical_level0_px . depth : src -> surf . logical_level0_px . array_len , src -> surf . samples , ISL_TILING_Y0_BIT , ISL_SURF_USAGE_TEXTURE_BIT , BO_ALLOC_BUSY , 0 , NULL ) ; <S2SV_StartBug> assert ( mt -> r8stencil_mt ) ; <S2SV_EndBug> } <S2SV_StartBug> if ( src -> r8stencil_needs_update == false ) <S2SV_EndBug> return ; <S2SV_StartBug> struct intel_mipmap_tree * dst = mt -> r8stencil_mt ; <S2SV_EndBug> for ( int level = src -> first_level ; level <= src -> last_level ; level ++ ) { const unsigned depth = src -> surf . dim == ISL_SURF_DIM_3D ? minify ( src -> surf . phys_level0_sa . depth , level ) : src -> surf . phys_level0_sa . array_len ; for ( unsigned layer = 0 ; layer < depth ; layer ++ ) { brw_blorp_copy_miptrees ( brw , src , level , layer , dst , level , layer , 0 , 0 , 0 , 0 , minify ( src -> surf . logical_level0_px . width , level ) , minify ( src -> surf . logical_level0_px . height , level ) ) ; } } brw_cache_flush_for_read ( brw , dst -> bo ) ; <S2SV_StartBug> src -> r8stencil_needs_update = false ; <S2SV_EndBug> } | <S2SV_ModStart> ! mt -> shadow_mt <S2SV_ModEnd> ) { assert <S2SV_ModStart> ; mt -> shadow_mt <S2SV_ModEnd> = make_surface ( <S2SV_ModStart> ( mt -> shadow_mt <S2SV_ModEnd> ) ; } <S2SV_ModStart> ( src -> shadow_needs_update <S2SV_ModEnd> == false ) <S2SV_ModStart> = mt -> shadow_mt <S2SV_ModEnd> ; for ( <S2SV_ModStart> ; src -> shadow_needs_update <S2SV_ModEnd> = false ; |
4,213 | CWE-000 int OMPI_Affinity_str ( ompi_affinity_fmt_t fmt_type , char ompi_bound [ OMPI_AFFINITY_STRING_MAX ] , char current_binding [ OMPI_AFFINITY_STRING_MAX ] , char exists [ OMPI_AFFINITY_STRING_MAX ] ) { int ret ; memset ( ompi_bound , 0 , OMPI_AFFINITY_STRING_MAX ) ; <S2SV_StartBug> memset ( current_binding , 0 , OMPI_AFFINITY_STRING_MAX ) ; <S2SV_EndBug> if ( NULL == opal_hwloc_topology ) { return MPI_SUCCESS ; } switch ( fmt_type ) { case OMPI_AFFINITY_RSRC_STRING_FMT : if ( OMPI_SUCCESS != ( ret = get_rsrc_ompi_bound ( ompi_bound ) ) || OMPI_SUCCESS != ( ret = get_rsrc_current_binding ( current_binding ) ) || OMPI_SUCCESS != ( ret = get_rsrc_exists ( exists ) ) ) { return OMPI_ERRHANDLER_INVOKE ( MPI_COMM_WORLD , ret , FUNC_NAME ) ; } break ; case OMPI_AFFINITY_LAYOUT_FMT : if ( OMPI_SUCCESS != ( ret = get_layout_ompi_bound ( ompi_bound ) ) || OMPI_SUCCESS != ( ret = get_layout_current_binding ( current_binding ) ) || OMPI_SUCCESS != ( ret = get_layout_exists ( exists ) ) ) { return OMPI_ERRHANDLER_INVOKE ( MPI_COMM_WORLD , ret , FUNC_NAME ) ; } break ; default : return OMPI_ERRHANDLER_INVOKE ( MPI_COMM_WORLD , MPI_ERR_ARG , FUNC_NAME ) ; } return MPI_SUCCESS ; } | <S2SV_ModStart> memset ( current_binding , 0 , OMPI_AFFINITY_STRING_MAX ) ; memset ( exists |
4,214 | CWE-000 int main ( ) { init_lcd ( ) ; init_clock ( ) ; init_encoder ( ) ; writecommand ( 1 ) ; init_timer1 ( 15625 ) ; init_timer0 ( 250 ) ; init_temperature ( ) ; init_serial ( ) ; hoursTens = eeprom_read_byte ( ( void * ) 0 ) ; hoursOnes = eeprom_read_byte ( ( void * ) 1 ) ; minsTens = eeprom_read_byte ( ( void * ) 2 ) ; minsOnes = eeprom_read_byte ( ( void * ) 3 ) ; secsTens = eeprom_read_byte ( ( void * ) 4 ) ; secsOnes = eeprom_read_byte ( ( void * ) 5 ) ; daysIndex = eeprom_read_byte ( ( void * ) 6 ) ; if ( secsOnes >= 10 || secsOnes < 0 || secsTens >= 6 || secsTens < 0 || minsOnes >= 10 || minsOnes < 0 || minsTens >= 6 || minsTens < 0 || hoursOnes >= 10 || hoursOnes < 0 || hoursTens >= 10 || hoursOnes < 0 || ( hoursTens == 2 && hoursOnes > 4 ) || daysIndex >= 7 || daysIndex < 0 ) { hoursTens = 0 ; hoursOnes = 0 ; minsTens = 0 ; minsOnes = 0 ; secsTens = 0 ; secsOnes = 0 ; daysIndex = 0 ; } PCICR |= ( 1 << PCIE1 ) | ( 1 << PCIE2 ) ; PCMSK1 |= ( 1 << PCINT11 ) | ( 1 << PCINT12 ) | ( 1 << PCINT13 ) ; sei ( ) ; PORTC |= ( 1 << PC3 ) ; PORTC |= ( 1 << PC2 ) ; PORTC |= ( 1 << PC5 ) | ( 1 << PC4 ) ; DDRB |= ( 1 << PB5 ) ; DDRC |= ( 1 << PC1 ) ; PORTC &= ~ ( 1 << PC1 ) ; DDRB |= ( 1 << PB4 ) | ( 1 << PB3 ) ; ds1631_temp ( localTemp ) ; displayTemperature ( ) ; while ( 1 ) { unsigned int prev = computeFahrenheit ( localTemp ) ; ds1631_temp ( localTemp ) ; unsigned int curr = computeFahrenheit ( localTemp ) ; <S2SV_StartBug> if ( curr != prev ) { <S2SV_EndBug> unsigned int data = computeFahrenheit ( localTemp ) ; displayTemperature ( ) ; transmitData ( data ) ; } <S2SV_StartBug> if ( validFlag ) { <S2SV_EndBug> moveto ( 1 , 13 ) ; writedata ( buffer [ 1 ] + '0' ) ; writedata ( buffer [ 2 ] + '0' ) ; validFlag = 0 ; } if ( computeFahrenheit ( localTemp ) < bufferToFahrenheit ( buffer ) ) { PORTB |= ( 1 << PB3 ) ; PORTB &= ~ ( 1 << PB4 ) ; } else if ( computeFahrenheit ( localTemp ) >= bufferToFahrenheit ( buffer ) ) { PORTB |= ( 1 << PB4 ) ; PORTB &= ~ ( 1 << PB3 ) ; } if ( state == 0 && alarmHoursTens == hoursTens && alarmHoursOnes == hoursOnes && alarmMinsTens == minsTens && alarmMinsOnes == minsOnes && secsOnes == 1 && secsTens == 0 ) { TCCR0B |= ( 1 << CS11 ) | ( 1 << CS10 ) ; alarmOn = 1 ; } if ( alarmOn && ! ( PINC & ( 1 << PC2 ) ) ) { snooze = 1 ; TCCR0B &= ~ ( ( 1 << CS11 ) | ( 1 << CS10 ) ) ; alarmOn = 0 ; PORTB &= ~ ( 1 << PB5 ) ; <S2SV_StartBug> } <S2SV_EndBug> } } | <S2SV_ModStart> ; if ( state == 0 ) { moveto ( 1 , 15 ) ; } if ( state == 0 && <S2SV_ModStart> } if ( state == 0 && <S2SV_ModStart> PB5 ) ; buzzCounter = 0 ; |
4,215 | CWE-000 static int nfs4_opendata_access ( struct rpc_cred * cred , struct nfs4_opendata * opendata , struct nfs4_state * state , fmode_t fmode , int openflags ) { struct nfs_access_entry cache ; u32 mask ; if ( opendata -> o_res . access_supported == 0 ) return 0 ; mask = 0 ; if ( openflags & __FMODE_EXEC ) { mask = MAY_EXEC ; } else if ( ( fmode & FMODE_READ ) && ! opendata -> file_created ) mask = MAY_READ ; cache . cred = cred ; cache . jiffies = jiffies ; nfs_access_set_mask ( & cache , opendata -> o_res . access_result ) ; nfs_access_add_cache ( state -> inode , & cache ) ; if ( ( mask & ~ cache . mask & ( MAY_READ | MAY_EXEC ) ) == 0 ) return 0 ; <S2SV_StartBug> nfs4_close_state ( state , fmode ) ; <S2SV_EndBug> return - EACCES ; } | <S2SV_ModStart> return 0 ; <S2SV_ModEnd> return - EACCES |
4,216 | CWE-000 void saveFileLinked ( struct student_details_linked * * root ) { char file_name [ 50 ] ; struct student_details_linked * current ; current = * root ; printf ( "\\nPlease<S2SV_blank>input<S2SV_blank>your<S2SV_blank>file<S2SV_blank>name\\n" ) ; scanf ( "%s" , & file_name ) ; <S2SV_StartBug> FILE * file = fopen ( file_name , "wb+" ) ; <S2SV_EndBug> while ( current != NULL ) { fwrite ( current , sizeof ( struct student_details_linked ) , 1 , file ) ; current = current -> next ; } fclose ( file ) ; } | <S2SV_ModStart> ( file_name , "wb" <S2SV_ModEnd> ) ; while |
4,217 | CWE-000 void ff_put_pixels4_8_mmi ( uint8_t * block , const uint8_t * pixels , ptrdiff_t line_size , int h ) { double ftmp [ 4 ] ; DECLARE_VAR_LOW32 ; __asm__ volatile ( "1:<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n\\t" MMI_ULWC1 ( % [ ftmp0 ] , % [ pixels ] , 0x00 ) PTR_ADDU "%[pixels],<S2SV_blank><S2SV_blank><S2SV_blank>%[pixels],<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%[line_size]<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n\\t" MMI_ULWC1 ( % [ ftmp1 ] , % [ pixels ] , 0x00 ) PTR_ADDU "%[pixels],<S2SV_blank><S2SV_blank><S2SV_blank>%[pixels],<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%[line_size]<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n\\t" <S2SV_StartBug> MMI_ULWC1 ( % [ ftmp2 ] , % [ pixels ] , 0x00 ) <S2SV_EndBug> PTR_ADDU "%[pixels],<S2SV_blank><S2SV_blank><S2SV_blank>%[pixels],<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%[line_size]<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n\\t" MMI_ULWC1 ( % [ ftmp3 ] , % [ pixels ] , 0x00 ) PTR_ADDU "%[pixels],<S2SV_blank><S2SV_blank><S2SV_blank>%[pixels],<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%[line_size]<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n\\t" PTR_ADDI "%[h],<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%[h],<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-0x04<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n\\t" MMI_SWC1 ( % [ ftmp0 ] , % [ block ] , 0x00 ) PTR_ADDU "%[block],<S2SV_blank><S2SV_blank><S2SV_blank>%[block],<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%[line_size]<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n\\t" <S2SV_StartBug> MMI_SWC1 ( % [ ftmp1 ] , % [ block ] , 0x00 ) <S2SV_EndBug> PTR_ADDU "%[block],<S2SV_blank><S2SV_blank><S2SV_blank>%[block],<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%[line_size]<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n\\t" MMI_SWC1 ( % [ ftmp2 ] , % [ block ] , 0x00 ) PTR_ADDU "%[block],<S2SV_blank><S2SV_blank><S2SV_blank>%[block],<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%[line_size]<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n\\t" MMI_SWC1 ( % [ ftmp3 ] , % [ block ] , 0x00 ) PTR_ADDU "%[block],<S2SV_blank><S2SV_blank><S2SV_blank>%[block],<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%[line_size]<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n\\t" "bnez<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%[h],<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>1b<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n\\t" : [ ftmp0 ] "=&f" ( ftmp [ 0 ] ) , [ ftmp1 ] "=&f" ( ftmp [ 1 ] ) , [ ftmp2 ] "=&f" ( ftmp [ 2 ] ) , [ ftmp3 ] "=&f" ( ftmp [ 3 ] ) , RESTRICT_ASM_LOW32 [ block ] "+&r" ( block ) , [ pixels ] "+&r" ( pixels ) , [ h ] "+&r" ( h ) : [ line_size ] "r" ( ( mips_reg ) line_size ) : "memory" ) ; } | <S2SV_ModStart> ) PTR_ADDU "%[pixels],<S2SV_blank><S2SV_blank><S2SV_blank>%[pixels],<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%[line_size]<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n\\t" PTR_ADDI "%[h],<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%[h],<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-0x02<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n\\t" <S2SV_ModEnd> MMI_SWC1 ( % <S2SV_ModStart> % [ ftmp1 <S2SV_ModEnd> ] , % |
4,218 | CWE-000 static PHP_METHOD ( Phalcon_Config , __set_state ) { zend_long ZEPHIR_LAST_CALL_STATUS ; zval * data_param = NULL ; <S2SV_StartBug> zval data ; <S2SV_EndBug> zval * this_ptr = getThis ( ) ; ZVAL_UNDEF ( & data ) ; ZEPHIR_MM_GROW ( ) ; zephir_fetch_params ( 1 , 1 , 0 , & data_param ) ; <S2SV_StartBug> ZEPHIR_OBS_COPY_OR_DUP ( & data , data_param ) ; <S2SV_EndBug> object_init_ex ( return_value , phalcon_config_ce ) ; <S2SV_StartBug> ZEPHIR_CALL_METHOD ( NULL , return_value , "__construct" , NULL , 15 , & data ) ; <S2SV_EndBug> zephir_check_call_status ( ) ; RETURN_MM ( ) ; } | <S2SV_ModStart> NULL ; zval * data = NULL <S2SV_ModEnd> ; ZEPHIR_MM_GROW ( <S2SV_ModStart> data_param ) ; data = data_param <S2SV_ModEnd> ; object_init_ex ( <S2SV_ModStart> , NULL , 20 , <S2SV_ModEnd> data ) ; |
4,219 | CWE-000 static int qpnp_flash_led_calc_max_current ( struct qpnp_flash_led * led ) { <S2SV_StartBug> int ocv_uv , rbatt_uohm , ibat_now , voltage_hdrm_mv , rc ; <S2SV_EndBug> int64_t ibat_flash_ua , avail_flash_ua , avail_flash_power_fw ; int64_t ibat_safe_ua , vin_flash_uv , vph_flash_uv , vph_flash_vdip ; rc = get_property_from_fg ( led , POWER_SUPPLY_PROP_RESISTANCE , & rbatt_uohm ) ; if ( rc < 0 ) { pr_err ( "bms<S2SV_blank>psy<S2SV_blank>does<S2SV_blank>not<S2SV_blank>support<S2SV_blank>resistance,<S2SV_blank>rc=%d\\n" , rc ) ; return rc ; } if ( ! rbatt_uohm ) return FLASH_LED_MAX_TOTAL_CURRENT_MA ; rc = get_property_from_fg ( led , POWER_SUPPLY_PROP_VOLTAGE_OCV , & ocv_uv ) ; if ( rc < 0 ) { pr_err ( "bms<S2SV_blank>psy<S2SV_blank>does<S2SV_blank>not<S2SV_blank>support<S2SV_blank>OCV,<S2SV_blank>rc=%d\\n" , rc ) ; return rc ; } rc = get_property_from_fg ( led , POWER_SUPPLY_PROP_CURRENT_NOW , & ibat_now ) ; if ( rc < 0 ) { pr_err ( "bms<S2SV_blank>psy<S2SV_blank>does<S2SV_blank>not<S2SV_blank>support<S2SV_blank>current,<S2SV_blank>rc=%d\\n" , rc ) ; return rc ; } rbatt_uohm += led -> pdata -> rpara_uohm ; voltage_hdrm_mv = qpnp_flash_led_get_voltage_headroom ( led ) ; vph_flash_vdip = VPH_DROOP_THRESH_VAL_TO_UV ( led -> pdata -> vph_droop_threshold ) + FLASH_VDIP_MARGIN ; if ( ! led -> trigger_lmh && ( ocv_uv < led -> pdata -> lmh_ocv_threshold_uv || rbatt_uohm > led -> pdata -> lmh_rbatt_threshold_uohm ) ) { led -> trigger_lmh = true ; rc = qpnp_flash_led_masked_write ( led , FLASH_LED_REG_MITIGATION_SW ( led -> base ) , FLASH_LED_LMH_MITIGATION_EN_MASK , FLASH_LED_LMH_MITIGATION_ENABLE ) ; if ( rc < 0 ) { pr_err ( "trigger<S2SV_blank>lmh<S2SV_blank>mitigation<S2SV_blank>failed,<S2SV_blank>rc=%d\\n" , rc ) ; return rc ; } udelay ( 100 ) ; return qpnp_flash_led_calc_max_current ( led ) ; } ibat_safe_ua = div_s64 ( ( ocv_uv - vph_flash_vdip ) * UCONV , rbatt_uohm ) ; if ( ibat_safe_ua <= led -> pdata -> ibatt_ocp_threshold_ua ) { ibat_flash_ua = ibat_safe_ua - ibat_now ; vph_flash_uv = vph_flash_vdip ; } else { ibat_flash_ua = led -> pdata -> ibatt_ocp_threshold_ua - ibat_now ; vph_flash_uv = ocv_uv - div64_s64 ( ( int64_t ) rbatt_uohm * led -> pdata -> ibatt_ocp_threshold_ua , UCONV ) ; } vin_flash_uv = max ( ( led -> pdata -> vled_max_uv + ( voltage_hdrm_mv * MCONV ) ) , VIN_FLASH_MIN_UV ) ; avail_flash_power_fw = BOB_EFFICIENCY * vph_flash_uv * ibat_flash_ua ; avail_flash_ua = div64_s64 ( avail_flash_power_fw , vin_flash_uv * MCONV ) ; pr_debug ( "avail_iflash=%lld,<S2SV_blank>ocv=%d,<S2SV_blank>ibat=%d,<S2SV_blank>rbatt=%d,<S2SV_blank>trigger_lmh=%d\\n" , avail_flash_ua , ocv_uv , ibat_now , rbatt_uohm , led -> trigger_lmh ) ; return min ( FLASH_LED_MAX_TOTAL_CURRENT_MA , ( int ) ( div64_s64 ( avail_flash_ua , MCONV ) ) ) ; } | <S2SV_ModStart> { int ocv_uv = 0 , rbatt_uohm = 0 , ibat_now = 0 , voltage_hdrm_mv = 0 ; int rc = 0 <S2SV_ModEnd> ; int64_t ibat_flash_ua |
4,220 | CWE-000 int NR_L_R ( int base , int exp ) { int i ; int f = 1 ; for ( i = 0 ; i < exp ; i ++ ) { f = base * f ; <S2SV_StartBug> return f ; <S2SV_EndBug> } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> * f ; } <S2SV_ModStart> f ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
4,221 | CWE-000 static int final_sections_reloc ( TCCState * s1 ) { int i ; Section * s ; relocate_syms ( s1 , s1 -> symtab , 0 ) ; if ( s1 -> nb_errors != 0 ) return - 1 ; for ( i = 1 ; i < s1 -> nb_sections ; i ++ ) { s = s1 -> sections [ i ] ; <S2SV_StartBug> # if defined ( TCC_TARGET_I386 ) || defined ( TCC_MUSL ) <S2SV_EndBug> if ( s -> reloc && s != s1 -> got && ( s -> sh_flags & SHF_ALLOC ) ) # else if ( s -> reloc && s != s1 -> got ) # endif relocate_section ( s1 , s ) ; } for ( i = 1 ; i < s1 -> nb_sections ; i ++ ) { s = s1 -> sections [ i ] ; if ( ( s -> sh_flags & SHF_ALLOC ) && s -> sh_type == SHT_RELX ) { relocate_rel ( s1 , s ) ; } } return 0 ; } | <S2SV_ModStart> defined ( TCC_TARGET_I386 <S2SV_ModEnd> ) if ( |
4,222 | CWE-000 void drawParticles ( ) { CALint i , j , k ; <S2SV_StartBug> CALint color ; <S2SV_EndBug> float particle_size = 1.0 / MAX_NUMBER_OF_PARTICLES_PER_CELL ; float px , py , pz , x , y , z ; <S2SV_StartBug> glTranslatef ( 0 , 0 , model_view . z_trans ) ; <S2SV_EndBug> glRotatef ( model_view . x_rot , 1 , 0 , 0 ) ; glRotatef ( model_view . y_rot , 0 , 1 , 0 ) ; glRotatef ( - 90 , 1 , 0 , 0 ) ; glPushMatrix ( ) ; float scale_x = COLS - 2 ; float scale_y = ROWS - 2 ; float scale_z = SLICES - 2 ; glScalef ( scale_x , scale_y , scale_z ) ; glPushAttrib ( GL_LIGHTING_BIT ) ; <S2SV_StartBug> glDisable ( GL_LIGHTING ) ; <S2SV_EndBug> glColor3f ( 1 , 1 , 1 ) ; glutWireCube ( 1.0 ) ; glPopAttrib ( ) ; glPopMatrix ( ) ; glColor3f ( 1 , 0 , 0 ) ; for ( k = 0 ; k < u_modellu -> slices ; k ++ ) for ( i = 0 ; i < u_modellu -> rows ; i ++ ) for ( j = 0 ; j < u_modellu -> columns ; j ++ ) if ( calGet3Di ( u_modellu , Q . imove [ 0 ] , i , j , k ) != PARTICLE_BORDER ) { for ( int slot = 0 ; slot < MAX_NUMBER_OF_PARTICLES_PER_CELL ; slot ++ ) if ( calGet3Di ( u_modellu , Q . imove [ slot ] , i , j , k ) != PARTICLE_ABSENT ) { px = calGet3Dr ( u_modellu , Q . px [ slot ] , i , j , k ) / CELL_SIDE ; py = calGet3Dr ( u_modellu , Q . py [ slot ] , i , j , k ) / CELL_SIDE ; pz = calGet3Dr ( u_modellu , Q . pz [ slot ] , i , j , k ) / CELL_SIDE ; x = px ; y = ROWS - 1 - py ; z = SLICES - 1 - pz ; glPushMatrix ( ) ; glTranslated ( - ( COLS ) / 2 , - ( ROWS ) / 2 + 1 , - ( SLICES ) / 2 + 1 ) ; glTranslated ( x , y , z ) ; glutSolidSphere ( particle_size , 5 , 5 ) ; glPopMatrix ( ) ; } } } | <S2SV_ModStart> , k ; <S2SV_ModEnd> float particle_size = <S2SV_ModStart> , z ; glColor3f ( 1 , 1 , 1 <S2SV_ModEnd> ) ; glPushMatrix <S2SV_ModStart> glDisable ( GL_LIGHTING <S2SV_ModEnd> ) ; glutWireCube |
4,223 | CWE-000 void clear_entries ( ) { node_t * current = entries ; entries = NULL ; while ( current != NULL ) { node_t * last = current ; current = current -> next ; if ( clear_memory ) { memset ( last -> title , 0 , 256 ) ; memset ( last -> icon , 0 , 256 ) ; memset ( last -> cmd , 0 , 256 ) ; memset ( last , 0 , sizeof ( node_t ) ) ; } free ( last ) ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ) ; } if ( fuzzy_search ) { fuzzy_entries = realloc ( fuzzy_entries , 0 ) ; entries_count = 0 ; } |
4,224 | CWE-000 int checkEntry ( int option , char entry [ ] ) { if ( option == - 1 ) { if ( strcmp ( entry , "1\\n" ) != 0 && strcmp ( entry , "0\\n" ) != 0 ) return 0 ; else return 1 ; } else if ( option == 0 ) { <S2SV_StartBug> if ( strcmp ( entry , "left\\n" ) != 0 && strcmp ( entry , "right\\n" ) != 0 && strcmp ( entry , "stop\\n" ) != 0 ) <S2SV_EndBug> return 0 ; else return 1 ; } else if ( option == 1 ) { if ( strcmp ( entry , "alone\\n" ) != 0 && strcmp ( entry , "search\\n" ) != 0 && strcmp ( entry , "recruit\\n" ) != 0 && strcmp ( entry , "give<S2SV_blank>up\\n" ) != 0 ) return 0 ; else return 1 ; } else if ( option == 2 ) { if ( strcmp ( entry , "hold<S2SV_blank>princess<S2SV_blank>hostage\\n" ) != 0 && strcmp ( entry , "flee\\n" ) != 0 ) return 0 ; else return 1 ; } else if ( option == 3 ) { if ( strcmp ( entry , "accept\\n" ) != 0 && strcmp ( entry , "leave\\n" ) != 0 && strcmp ( entry , "punch<S2SV_blank>him\\n" ) != 0 ) return 0 ; else return 1 ; } else if ( option == 4 ) { if ( strcmp ( entry , "give<S2SV_blank>up\\n" ) != 0 && strcmp ( entry , "search\\n" ) != 0 && strcmp ( entry , "recruit\\n" ) != 0 && strcmp ( entry , "hide\\n" ) != 0 ) return 0 ; else return 1 ; } else if ( option == 8 ) { if ( strcmp ( entry , "hide\\n" ) != 0 && strcmp ( entry , "search\\n" ) != 0 && strcmp ( entry , "recruit\\n" ) != 0 ) return 0 ; else return 1 ; } else { printf ( "Adventurer,<S2SV_blank>it\'s<S2SV_blank>dangerous,<S2SV_blank>you<S2SV_blank>shouldn\'t<S2SV_blank>be<S2SV_blank>here!<S2SV_blank>Err:<S2SV_blank>badOption\\n" ) ; return 0 ; } } | <S2SV_ModStart> ) != 0 && strcmp ( entry , "death25\\n" ) != 0 && strcmp ( entry , "day25\\n" ) != 0 |
4,225 | CWE-000 int readargs ( int argc , char * argv [ ] ) { int next_option ; const char * const short_option = "hf:u:p:H:U:t:A:" ; const struct option long_option [ ] = { { "help" , 0 , NULL , 'h' } , { "user" , 1 , NULL , 'u' } , { "pass" , 1 , NULL , 'p' } , { "host" , 1 , NULL , 'H' } , { "url" , 1 , NULL , 'U' } , { "time" , 1 , NULL , 't' } , <S2SV_StartBug> { NULL , 0 , NULL , 0 } <S2SV_EndBug> } ; g_option . time = 900 ; snprintf ( g_option . agent , 128 , "ddnsv%s" , VERSION ) ; do { next_option = getopt_long ( argc , argv , short_option , long_option , NULL ) ; switch ( next_option ) { case 'h' : print_usage ( ) ; exit ( 0 ) ; case 'f' : { int ret = parse_configfile ( optarg ) ; if ( ret ) { fprintf ( stderr , "cannot<S2SV_blank>open<S2SV_blank>%s\\n" , optarg ) ; return ret ; } } break ; case 'u' : strcpy ( g_option . user , optarg ) ; break ; case 'p' : strcpy ( g_option . pass , optarg ) ; break ; case 'H' : strcpy ( g_option . host , optarg ) ; break ; case 'U' : strcpy ( g_option . url , optarg ) ; break ; case 'A' : strcpy ( g_option . agent , optarg ) ; break ; case 't' : g_option . time = atol ( optarg ) ; break ; case '?' : print_usage ( ) ; return ( 22 ) ; case - 1 : break ; default : abort ( ) ; } } while ( next_option != - 1 ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> } , { "agent" , 1 , NULL , 'A' } , { <S2SV_ModStart> 1 ) ; if ( ! g_option . host [ 0 ] ) { print_usage ( ) ; return 22 ; } if ( ! g_option . url [ 0 ] ) { g_option . url [ 0 ] = '/' ; g_option . url [ 1 ] = 0 ; } return <S2SV_ModEnd> 0 ; } |
4,226 | CWE-000 int pss_comp_free_error ( pss_comp_error_t * error ) { if ( NULL == error ) ERROR_RETURN_LOG ( int , "Invalid<S2SV_blank>arguments" ) ; pss_comp_error_t * this ; <S2SV_StartBug> for ( ; NULL != error -> next ; ) <S2SV_EndBug> { this = error ; error = error -> next ; free ( this ) ; } return 0 ; } | <S2SV_ModStart> NULL != error <S2SV_ModEnd> ; ) { |
4,227 | CWE-000 void Draw_FreePic ( const char * picname ) { int crc ; int hashkey ; cachepic_t * pic ; crc = CRC_Block ( ( unsigned char * ) picname , strlen ( picname ) ) ; hashkey = ( ( crc >> 8 ) ^ crc ) % CACHEPICHASHSIZE ; for ( pic = cachepichash [ hashkey ] ; pic ; pic = pic -> chain ) { if ( ! strcmp ( picname , pic -> name ) && pic -> skinframe ) { <S2SV_StartBug> R_SkinFrame_PurgeSkinFrame ( pic -> skinframe ) ; <S2SV_EndBug> pic -> width = 0 ; pic -> height = 0 ; return ; } } } | <S2SV_ModStart> skinframe ) { Con_DPrintf ( "Draw_FreePic(\\"%s\\"):<S2SV_blank>frame<S2SV_blank>%i:<S2SV_blank>freeing<S2SV_blank>pic\\n" , picname , draw_frame ) ; <S2SV_ModStart> -> skinframe ) <S2SV_ModEnd> ; return ; |
4,228 | CWE-000 CRYPT_RESULT _cpri__GetEphemeralEcc ( TPMS_ECC_POINT * q , TPM2B_ECC_PARAMETER * d , TPM_ECC_CURVE curve_id ) <S2SV_StartBug> { <S2SV_EndBug> uint8_t key_bytes [ P256_NBYTES ] __aligned ( 4 ) ; if ( curve_id != TPM_ECC_NIST_P256 ) return CRYPT_PARAMETER ; rand_bytes ( key_bytes , sizeof ( key_bytes ) ) ; <S2SV_StartBug> if ( DCRYPTO_p256_key_from_bytes ( ( p256_int * ) q -> x . b . buffer , <S2SV_EndBug> ( p256_int * ) q -> y . b . buffer , ( p256_int * ) d -> b . buffer , key_bytes ) ) { q -> x . b . size = sizeof ( p256_int ) ; q -> y . b . size = sizeof ( p256_int ) ; reverse_tpm2b ( & q -> x . b ) ; reverse_tpm2b ( & q -> y . b ) ; d -> b . size = sizeof ( p256_int ) ; reverse_tpm2b ( & d -> b ) ; return CRYPT_SUCCESS ; } else { return CRYPT_FAIL ; } } | <S2SV_ModStart> curve_id ) { int result ; <S2SV_ModStart> ) ) ; result = DCRYPTO_p256_key_from_bytes ( ( p256_int * ) q -> x . b . buffer , ( p256_int * ) q -> y . b . buffer , ( p256_int * ) d -> b . buffer , key_bytes ) ; always_memset ( key_bytes , 0 , sizeof ( key_bytes ) ) ; if ( result <S2SV_ModEnd> ) { q |
4,229 | CWE-000 __attribute__ ( ( nonnull ( 1 ) , nothrow , warn_unused_result ) ) static void * io_thread_cb ( void * _arg ) { io_t * restrict arg = ( io_t * restrict ) _arg ; pipe_t * restrict in ; pipe_t * restrict out ; in = arg -> in ; out = arg -> out ; while ( true ) { <S2SV_StartBug> error_check ( read_pipe ( in ) != 0 ) return NULL ; <S2SV_EndBug> error_check ( write_pipe ( out ) != 0 ) return NULL ; <S2SV_StartBug> } <S2SV_EndBug> return NULL ; } | <S2SV_ModStart> true ) { puts ( "A" ) ; fflush ( stdout ) ; <S2SV_ModStart> ) return NULL ; puts ( "B" ) ; fflush ( stdout ) <S2SV_ModStart> return NULL ; puts ( "C" ) ; fflush ( stdout ) ; |
4,230 | CWE-000 void bc_module_lcd_init ( bc_module_lcd_framebuffer_t * framebuffer ) { bc_module_lcd_t * self = & _bc_module_lcd ; bc_tca9534a_init ( & _bc_module_lcd . tca9534a , BC_I2C_I2C0 , 0x3c ) ; bc_tca9534a_set_port_direction ( & _bc_module_lcd . tca9534a , 0x0a ) ; _bc_module_lcd . gpio = _BC_MODULE_LCD_DISP_CS | _BC_MODULE_LCD_DISP_ON | _BC_MODULE_LCD_LED_GREEN | _BC_MODULE_LCD_LED_RED | _BC_MODULE_LCD_LED_BLUE ; bc_tca9534a_write_port ( & _bc_module_lcd . tca9534a , _bc_module_lcd . gpio ) ; <S2SV_StartBug> bc_spi_init ( BC_SPI_SPEED_2_MHZ , BC_SPI_MODE_0 ) ; <S2SV_EndBug> self -> framebuffer = framebuffer -> framebuffer ; uint8_t line ; uint32_t offs ; for ( line = 0x01 , offs = 1 ; line <= 128 ; line ++ , offs += 18 ) { self -> framebuffer [ offs ] = reverse2 ( line ) ; } bc_module_lcd_clear ( ) ; _bc_module_lcd . task_id = bc_scheduler_register ( _bc_module_lcd_task , NULL , _BC_MODULE_LCD_VCOM_PERIOD ) ; } | <S2SV_ModStart> ; bc_spi_init ( BC_SPI_SPEED_1_MHZ <S2SV_ModEnd> , BC_SPI_MODE_0 ) |
4,231 | CWE-000 static void raid1_end_write_request ( struct bio * bio , int error ) { int uptodate = test_bit ( BIO_UPTODATE , & bio -> bi_flags ) ; struct r1bio * r1_bio = bio -> bi_private ; int mirror , behind = test_bit ( R1BIO_BehindIO , & r1_bio -> state ) ; struct r1conf * conf = r1_bio -> mddev -> private ; struct bio * to_put = NULL ; mirror = find_bio_disk ( r1_bio , bio ) ; if ( ! uptodate ) { set_bit ( WriteErrorSeen , & conf -> mirrors [ mirror ] . rdev -> flags ) ; if ( ! test_and_set_bit ( WantReplacement , & conf -> mirrors [ mirror ] . rdev -> flags ) ) set_bit ( MD_RECOVERY_NEEDED , & conf -> mddev -> recovery ) ; set_bit ( R1BIO_WriteError , & r1_bio -> state ) ; } else { sector_t first_bad ; int bad_sectors ; r1_bio -> bios [ mirror ] = NULL ; to_put = bio ; <S2SV_StartBug> set_bit ( R1BIO_Uptodate , & r1_bio -> state ) ; <S2SV_EndBug> if ( is_badblock ( conf -> mirrors [ mirror ] . rdev , r1_bio -> sector , r1_bio -> sectors , & first_bad , & bad_sectors ) ) { r1_bio -> bios [ mirror ] = IO_MADE_GOOD ; set_bit ( R1BIO_MadeGood , & r1_bio -> state ) ; } } if ( behind ) { if ( test_bit ( WriteMostly , & conf -> mirrors [ mirror ] . rdev -> flags ) ) atomic_dec ( & r1_bio -> behind_remaining ) ; if ( atomic_read ( & r1_bio -> behind_remaining ) >= ( atomic_read ( & r1_bio -> remaining ) - 1 ) && test_bit ( R1BIO_Uptodate , & r1_bio -> state ) ) { if ( ! test_and_set_bit ( R1BIO_Returned , & r1_bio -> state ) ) { struct bio * mbio = r1_bio -> master_bio ; pr_debug ( "raid1:<S2SV_blank>behind<S2SV_blank>end<S2SV_blank>write<S2SV_blank>sectors" "<S2SV_blank>%llu-%llu\\n" , ( unsigned long long ) mbio -> bi_sector , ( unsigned long long ) mbio -> bi_sector + ( mbio -> bi_size >> 9 ) - 1 ) ; call_bio_endio ( r1_bio ) ; } } } if ( r1_bio -> bios [ mirror ] == NULL ) rdev_dec_pending ( conf -> mirrors [ mirror ] . rdev , conf -> mddev ) ; r1_bio_write_done ( r1_bio ) ; if ( to_put ) bio_put ( to_put ) ; } | <S2SV_ModStart> = bio ; if ( test_bit ( In_sync , & conf -> mirrors [ mirror ] . rdev -> flags ) && ! test_bit ( Faulty , & conf -> mirrors [ mirror ] . rdev -> flags ) ) |
4,232 | CWE-000 extern int <S2SV_StartBug> is_5321_email ( const char * email , size_t length ) <S2SV_EndBug> { char * ch = NULL ; char * brs = NULL ; char * bre = NULL ; <S2SV_StartBug> int r = 0 ; <S2SV_EndBug> const char * end = email + length ; if ( length == 0 ) return inverse ( EEAV_EMAIL_EMPTY ) ; ch = strrchr ( email , '@' ) ; if ( ch == NULL ) return inverse ( EEAV_DOMAIN_EMPTY ) ; # ifdef _DEBUG printf ( ">>><S2SV_blank>local-part:<S2SV_blank>%.*s<S2SV_blank>(%zu)\\n" , ch - email , email , ch - email ) ; printf ( ">>><S2SV_blank>domain:<S2SV_blank>%s\\n" , ch + 1 ) ; # endif if ( ch - email > VALID_LPART_LEN ) return inverse ( EEAV_LPART_TOO_LONG ) ; <S2SV_StartBug> r = is_5321_local ( email , ch ) ; <S2SV_EndBug> <S2SV_StartBug> if ( r != EEAV_NO_ERROR ) <S2SV_EndBug> <S2SV_StartBug> return r ; <S2SV_EndBug> <S2SV_StartBug> brs = strchr ( ch + 1 , '[' ) ; <S2SV_EndBug> if ( brs == NULL ) <S2SV_StartBug> return ( is_ascii_domain ( ch + 1 , end ) ) ; <S2SV_EndBug> check_ip ( ) ; } | <S2SV_ModStart> , size_t length , bool tld_check <S2SV_ModStart> NULL ; int rc <S2SV_ModEnd> ; const char <S2SV_ModStart> EEAV_LPART_TOO_LONG ) ; rc <S2SV_ModEnd> = is_5321_local ( <S2SV_ModStart> ; if ( rc <S2SV_ModEnd> != EEAV_NO_ERROR ) <S2SV_ModStart> EEAV_NO_ERROR ) return rc <S2SV_ModEnd> ; brs = <S2SV_ModStart> ; brs = <S2SV_ModEnd> ch + 1 <S2SV_ModStart> ch + 1 ; if ( * brs != '[' ) { rc = <S2SV_ModEnd> is_ascii_domain ( ch <S2SV_ModStart> , end ) ; if ( rc != EEAV_NO_ERROR ) return rc ; check_tld ( ) ; } <S2SV_ModEnd> check_ip ( ) |
4,233 | CWE-000 <S2SV_StartBug> json_t * add_webradio_from_playlist ( struct config_elements * config , json_t * j_playlist , const char * username , const char * format , unsigned short channels , unsigned int sample_rate , unsigned int bit_rate , short int random , struct _t_webradio * * new_webradio ) { <S2SV_EndBug> json_t * j_result = NULL , * j_element ; size_t index ; char * full_path ; int webradio_index ; if ( ! pthread_mutex_lock ( & config -> playlist_lock ) ) { config -> webradio_set = o_realloc ( config -> webradio_set , ( config -> nb_webradio + 1 ) * sizeof ( struct _t_webradio * ) ) ; if ( config -> webradio_set != NULL ) { webradio_index = config -> nb_webradio ; config -> nb_webradio ++ ; config -> webradio_set [ webradio_index ] = o_malloc ( sizeof ( struct _t_webradio ) ) ; if ( config -> webradio_set [ webradio_index ] != NULL ) { if ( webradio_init ( config -> webradio_set [ webradio_index ] , format , channels , sample_rate , bit_rate ) == T_OK ) { config -> webradio_set [ webradio_index ] -> config = config ; config -> webradio_set [ webradio_index ] -> username = o_strdup ( username ) ; config -> webradio_set [ webradio_index ] -> random = random ; <S2SV_StartBug> config -> webradio_set [ webradio_index ] -> display_name = o_strdup ( json_string_value ( json_object_get ( j_playlist , "description" ) ) ) ; <S2SV_EndBug> config -> webradio_set [ webradio_index ] -> playlist_name = o_strdup ( json_string_value ( json_object_get ( j_playlist , "name" ) ) ) ; config -> webradio_set [ webradio_index ] -> tpl_id = json_integer_value ( json_object_get ( j_playlist , "tpl_id" ) ) ; json_array_foreach ( json_object_get ( j_playlist , "media" ) , index , j_element ) { full_path = msprintf ( "%s/%s" , json_string_value ( json_object_get ( j_element , "tds_path" ) ) , json_string_value ( json_object_get ( j_element , "path" ) ) ) ; if ( file_list_enqueue_new_file ( config -> webradio_set [ webradio_index ] -> file_list , full_path , json_integer_value ( json_object_get ( j_element , "tm_id" ) ) ) != T_OK ) { y_log_message ( Y_LOG_LEVEL_ERROR , "add_webradio_from_playlist<S2SV_blank>-<S2SV_blank>Error<S2SV_blank>adding<S2SV_blank>file<S2SV_blank>%s" , json_string_value ( json_object_get ( j_element , "full_path" ) ) ) ; } o_free ( full_path ) ; } if ( new_webradio != NULL ) { * new_webradio = config -> webradio_set [ webradio_index ] ; } if ( webradio_add_db_stream ( config , config -> webradio_set [ webradio_index ] ) == T_OK ) { j_result = json_pack ( "{sis{sssssssssisisosis[]}}" , "result" , T_OK , "stream" , "name" , config -> webradio_set [ webradio_index ] -> name , "display_name" , config -> webradio_set [ webradio_index ] -> display_name , "format" , format , "channels" , channels == 1 ? "mono" : "stereo" , "sample_rate" , sample_rate , "bitrate" , bit_rate , "webradio" , json_true ( ) , "elements" , config -> webradio_set [ webradio_index ] -> file_list -> nb_files , "clients" ) ; } else { y_log_message ( Y_LOG_LEVEL_ERROR , "add_webradio_from_playlist<S2SV_blank>-<S2SV_blank>Error<S2SV_blank>webradio_add_db_stream" ) ; j_result = json_pack ( "{si}" , "result" , T_ERROR ) ; } } else { y_log_message ( Y_LOG_LEVEL_ERROR , "add_webradio_from_playlist<S2SV_blank>-<S2SV_blank>Error<S2SV_blank>webradio_init" ) ; j_result = json_pack ( "{si}" , "result" , T_ERROR ) ; } } else { y_log_message ( Y_LOG_LEVEL_ERROR , "add_webradio_from_playlist<S2SV_blank>-<S2SV_blank>Error<S2SV_blank>malloc<S2SV_blank>new<S2SV_blank>playlist" ) ; j_result = json_pack ( "{si}" , "result" , T_ERROR_MEMORY ) ; } } else { y_log_message ( Y_LOG_LEVEL_ERROR , "add_webradio_from_playlist<S2SV_blank>-<S2SV_blank>Error<S2SV_blank>realloc<S2SV_blank>webradio_set" ) ; j_result = json_pack ( "{si}" , "result" , T_ERROR_MEMORY ) ; } pthread_mutex_unlock ( & config -> playlist_lock ) ; } else { j_result = json_pack ( "{si}" , "result" , T_ERROR ) ; } return j_result ; } | <S2SV_ModStart> int random , const char * name , <S2SV_ModStart> = random ; if ( name == NULL ) { <S2SV_ModStart> ) ) ; } else { config -> webradio_set [ webradio_index ] -> display_name = name ; } |
4,234 | CWE-000 static bool get_connection_status_cb ( LSHandle * sh , LSMessage * message , void * ctx ) { <S2SV_StartBug> OIC_LOG ( DEBUG , TAG , "Callback<S2SV_blank>for<S2SV_blank>com.webos.service.connectionmanager/getstatus<S2SV_blank>is<S2SV_blank>invoked..." ) ; <S2SV_EndBug> jvalue_ref parsedObj = { 0 } ; jschema_ref input_schema = jschema_parse ( j_cstr_to_buffer ( "{}" ) , DOMOPT_NOOPT , NULL ) ; if ( ! input_schema ) return false ; JSchemaInfo schemaInfo ; jschema_info_init ( & schemaInfo , input_schema , NULL , NULL ) ; parsedObj = jdom_parse ( j_cstr_to_buffer ( LSMessageGetPayload ( message ) ) , DOMOPT_NOOPT , & schemaInfo ) ; jschema_release ( & input_schema ) ; if ( jis_null ( parsedObj ) ) return true ; const char * payload = jvalue_tostring ( parsedObj , input_schema ) ; OIC_LOG_V ( DEBUG , TAG , "Paylod:<S2SV_blank>%s" , payload ) ; jvalue_ref wiredObj = { 0 } , wifiObj = { 0 } , wiredStateObj = { 0 } , wifiStateObj = { 0 } ; if ( jobject_get_exists ( parsedObj , J_CSTR_TO_BUF ( "wired" ) , & wiredObj ) ) { if ( jobject_get_exists ( wiredObj , J_CSTR_TO_BUF ( "state" ) , & wiredStateObj ) ) { if ( jstring_equal2 ( wiredStateObj , J_CSTR_TO_BUF ( "connected" ) ) && ! gConnectionStates . isConnectWired ) { gConnectionStates . isConnectWired = true ; CAIPPassNetworkChangesToAdapter ( CA_INTERFACE_UP ) ; OIC_LOG ( INFO , TAG , "Wired<S2SV_blank>LAN<S2SV_blank>is<S2SV_blank>connected..." ) ; } else if ( jstring_equal2 ( wiredStateObj , J_CSTR_TO_BUF ( "disconnected" ) ) && gConnectionStates . isConnectWired ) { gConnectionStates . isConnectWired = false ; CAIPPassNetworkChangesToAdapter ( CA_INTERFACE_DOWN ) ; OIC_LOG ( INFO , TAG , "Wired<S2SV_blank>LAN<S2SV_blank>is<S2SV_blank>disconnected..." ) ; } } } if ( jobject_get_exists ( parsedObj , J_CSTR_TO_BUF ( "wifi" ) , & wifiObj ) ) { if ( jobject_get_exists ( wifiObj , J_CSTR_TO_BUF ( "state" ) , & wifiStateObj ) ) { if ( jstring_equal2 ( wifiStateObj , J_CSTR_TO_BUF ( "connected" ) ) && ! gConnectionStates . isConnectWiFi ) { gConnectionStates . isConnectWiFi = true ; CAIPPassNetworkChangesToAdapter ( CA_INTERFACE_UP ) ; OIC_LOG ( INFO , TAG , "Wi-Fi<S2SV_blank>is<S2SV_blank>connected..." ) ; } else if ( jstring_equal2 ( wifiStateObj , J_CSTR_TO_BUF ( "disconnected" ) ) && gConnectionStates . isConnectWiFi ) { gConnectionStates . isConnectWiFi = false ; CAIPPassNetworkChangesToAdapter ( CA_INTERFACE_DOWN ) ; OIC_LOG ( DEBUG , TAG , "Wi-Fi<S2SV_blank>is<S2SV_blank>disconnected..." ) ; } } } return true ; } | <S2SV_ModStart> TAG , "Callback<S2SV_blank>for<S2SV_blank>com.webos.service.connectionmanager/getstatus<S2SV_blank>is<S2SV_blank>invoked..." ) ; OC_UNUSED ( sh ) ; OC_UNUSED ( ctx |
4,235 | CWE-000 BOOL DbgrOsGetCharacter ( PUCHAR Key , PUCHAR ControlKey ) { ssize_t BytesRead ; int Character ; UCHAR ControlKeyValue ; struct pollfd Events [ 2 ] ; int Result ; ControlKeyValue = 0 ; <S2SV_StartBug> if ( __freadahead ( stdin ) != 0 ) { <S2SV_EndBug> Character = fgetc ( stdin ) ; assert ( Character != - 1 ) ; } else { while ( TRUE ) { fflush ( NULL ) ; <S2SV_StartBug> Events [ 0 ] . fd = fileno ( stdin ) ; <S2SV_EndBug> Events [ 0 ] . events = POLLIN ; Events [ 0 ] . revents = 0 ; Events [ 1 ] . fd = DbgRemoteInputPipe [ 1 ] ; Events [ 1 ] . events = POLLIN ; Events [ 1 ] . revents = 0 ; Result = poll ( Events , 2 , - 1 ) ; if ( Result == - 1 ) { if ( errno == EINTR ) { continue ; } else { DbgOut ( "Failed<S2SV_blank>to<S2SV_blank>poll:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; return FALSE ; } } if ( ( Events [ 0 ] . revents & POLLIN ) != 0 ) { <S2SV_StartBug> Character = fgetc ( stdin ) ; <S2SV_EndBug> if ( Character == - 1 ) { <S2SV_StartBug> if ( errno == EINTR ) { <S2SV_EndBug> continue ; } DbgOut ( "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>character.<S2SV_blank>Errno<S2SV_blank>%d\\n" , errno ) ; return FALSE ; } break ; } else if ( ( Events [ 1 ] . revents & POLLIN ) != 0 ) { do { BytesRead = read ( DbgRemoteInputPipe [ 1 ] , & Character , 1 ) ; } while ( ( BytesRead < 0 ) && ( errno == EINTR ) ) ; Character = 0 ; ControlKeyValue = KEY_REMOTE ; break ; } else { DbgOut ( "Poll<S2SV_blank>succeeded,<S2SV_blank>but<S2SV_blank>nothing<S2SV_blank>available.\\n" ) ; } } <S2SV_StartBug> } <S2SV_EndBug> if ( Character == '\\n' ) { Character = 0 ; ControlKeyValue = KEY_RETURN ; } if ( Key != NULL ) { * Key = Character ; } if ( ControlKey != NULL ) { * ControlKey = ControlKeyValue ; } return TRUE ; } | <S2SV_ModStart> = 0 ; <S2SV_ModEnd> while ( TRUE <S2SV_ModStart> . fd = STDIN_FILENO <S2SV_ModEnd> ; Events [ <S2SV_ModStart> 0 ) { do { BytesRead = read ( STDIN_FILENO , & Character , 1 ) ; } while ( ( BytesRead < 0 ) && <S2SV_ModEnd> ( errno == <S2SV_ModStart> == EINTR ) ) ; if ( BytesRead <= 0 ) { <S2SV_ModEnd> return FALSE ; <S2SV_ModStart> ; } } <S2SV_ModEnd> if ( Character |
4,236 | CWE-000 void emptyPacket ( ) <S2SV_StartBug> { <S2SV_EndBug> packet . syn_syn [ 0 ] = buffer [ 0 ] ; packet . syn_syn [ 1 ] = buffer [ 1 ] ; packet . dle_stx [ 0 ] = buffer [ 2 ] ; packet . dle_stx [ 1 ] = buffer [ 3 ] ; packet . destination = buffer [ 4 ] ; packet . source = buffer [ 5 ] ; for ( i = 0 ; i < 80 ; i ++ ) { packet . text [ 0 ] = buffer [ i + 6 ] ; } packet . dle_etx [ 0 ] = buffer [ 86 ] ; packet . dle_etx [ 1 ] = buffer [ 87 ] ; } | <S2SV_ModStart> ( ) { int i ; |
4,237 | CWE-000 static sqInt NoDbgRegParms closedPICRefersToUnmarkedObject ( CogMethod * cPIC ) { sqInt i ; <S2SV_StartBug> sqInt object ; <S2SV_EndBug> sqInt pc ; if ( ! ( ( isImmediate ( ( cPIC -> selector ) ) ) || ( isMarked ( ( cPIC -> selector ) ) ) ) ) { return 1 ; } pc = addressOfEndOfCaseinCPIC ( 1 , cPIC ) ; if ( couldBeObject ( ( object = literalBeforeFollowingAddress ( backEnd , pc - 5 ) ) ) ) { if ( ! ( isMarked ( object ) ) ) { return 1 ; } } if ( markAndTraceOrFreePICTargetin ( jumpLongTargetBeforeFollowingAddress ( backEnd , pc ) , cPIC ) ) { return 1 ; } for ( i = 2 ; i <= ( ( cPIC -> cPICNumCases ) ) ; i += 1 ) { pc = addressOfEndOfCaseinCPIC ( i , cPIC ) ; if ( couldBeObject ( ( object = literalBeforeFollowingAddress ( backEnd , ( pc - 6 ) - 5 ) ) ) ) { if ( ! ( isMarked ( object ) ) ) { return 1 ; } } if ( markAndTraceOrFreePICTargetin ( jumpLongTargetBeforeFollowingAddress ( backEnd , pc ) , cPIC ) ) { return 1 ; } } return 0 ; } | <S2SV_ModStart> sqInt i ; usqInt <S2SV_ModEnd> object ; sqInt |
4,238 | CWE-000 void R_Interrupt_Create ( void ) { <S2SV_StartBug> IEN ( ICU , GROUPAL1 ) = 0U ; <S2SV_EndBug> IPR ( ICU , GROUPAL1 ) = _02_ICU_PRIORITY_LEVEL2 ; IEN ( ICU , GROUPAL1 ) = 1U ; } | <S2SV_ModStart> void ) { <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
4,239 | CWE-000 static void skip_delete_command ( char * arg , int from_tty ) { struct skiplist_entry * e , * temp , * b_prev ; int found = 0 ; b_prev = 0 ; ALL_SKIPLIST_ENTRIES_SAFE ( e , temp ) if ( arg == NULL || number_is_in_list ( arg , e -> number ) ) { if ( b_prev != NULL ) b_prev -> next = e -> next ; else skiplist_entry_chain = e -> next ; <S2SV_StartBug> free_skiplist_entry ( e ) ; <S2SV_EndBug> found = 1 ; } else { b_prev = e ; } if ( ! found ) error ( _ ( "No<S2SV_blank>skiplist<S2SV_blank>entries<S2SV_blank>found<S2SV_blank>with<S2SV_blank>number<S2SV_blank>%s." ) , arg ) ; } | <S2SV_ModStart> -> next ; delete e <S2SV_ModEnd> ; found = |
4,240 | CWE-000 static void riscv_patch_generated_code ( ) { basic_block bb ; FOR_EACH_BB_FN ( bb , cfun ) { basic_block TargetBB ; rtx_insn * end , * head = BB_HEAD ( bb ) ; rtx_insn * insn , * prev_insn ; rtx jump_insn , call_insn ; rtx RegW , RegR ; edge e ; edge_iterator ei ; for ( insn = BB_END ( bb ) ; ; insn = PREV_INSN ( insn ) ) { if ( NONDEBUG_INSN_P ( insn ) || ( insn == head ) ) break ; } if ( ! JUMP_P ( insn ) ) continue ; jump_insn = PATTERN ( insn ) ; if ( ! ( GET_CODE ( jump_insn ) == SET && GET_CODE ( SET_SRC ( jump_insn ) ) == IF_THEN_ELSE ) ) continue ; prev_insn = prev_nonnote_nondebug_insn ( insn ) ; if ( prev_insn == NULL_RTX || ! INSN_P ( prev_insn ) ) continue ; RegW = SET_DEST ( PATTERN ( prev_insn ) ) ; if ( ! REG_P ( RegW ) || ! MEM_P ( SET_SRC ( PATTERN ( prev_insn ) ) ) ) continue ; TargetBB = 0 ; FOR_EACH_EDGE ( e , ei , bb -> succs ) { if ( e -> flags & EDGE_FALLTHRU ) { TargetBB = e -> dest ; break ; } } if ( ! TargetBB ) continue ; end = BB_END ( TargetBB ) ; for ( insn = BB_HEAD ( TargetBB ) ; ; insn = NEXT_INSN ( insn ) ) { if ( ( ! DEBUG_INSN_P ( insn ) && ! NOTE_P ( insn ) ) || ( insn == end ) ) break ; } if ( insn == NULL_RTX || ! CALL_P ( insn ) ) continue ; <S2SV_StartBug> if ( GET_CODE ( PATTERN ( insn ) ) == PARALLEL ) call_insn = XVECEXP ( insn , 0 , 0 ) ; else call_insn = PATTERN ( insn ) ; <S2SV_EndBug> if ( GET_CODE ( call_insn ) != CALL ) continue ; RegR = XEXP ( call_insn , 0 ) ; if ( GET_CODE ( RegR ) != MEM ) continue ; RegR = XEXP ( RegR , 0 ) ; if ( ! REG_P ( RegR ) ) continue ; if ( REGNO ( RegW ) != REGNO ( RegR ) ) continue ; prev_insn = emit_insn_after ( gen_forced_nop ( ) , prev_insn ) ; } } | <S2SV_ModStart> = XVECEXP ( PATTERN ( insn ) <S2SV_ModEnd> , 0 , |
4,241 | CWE-000 static MYSQL * db_connect ( char * host , char * database , char * user , char * passwd ) { MYSQL * mysql ; if ( verbose ) fprintf ( stdout , "Connecting<S2SV_blank>to<S2SV_blank>%s\\n" , host ? host : "localhost" ) ; if ( opt_use_threads && ! lock_tables ) { pthread_mutex_lock ( & init_mutex ) ; if ( ! ( mysql = mysql_init ( NULL ) ) ) { pthread_mutex_unlock ( & init_mutex ) ; return 0 ; } pthread_mutex_unlock ( & init_mutex ) ; } else if ( ! ( mysql = mysql_init ( NULL ) ) ) return 0 ; if ( opt_compress ) mysql_options ( mysql , MYSQL_OPT_COMPRESS , NullS ) ; if ( opt_local_file ) mysql_options ( mysql , MYSQL_OPT_LOCAL_INFILE , ( char * ) & opt_local_file ) ; # ifdef HAVE_OPENSSL if ( opt_use_ssl ) { mysql_ssl_set ( mysql , opt_ssl_key , opt_ssl_cert , opt_ssl_ca , opt_ssl_capath , opt_ssl_cipher ) ; mysql_options ( mysql , MYSQL_OPT_SSL_CRL , opt_ssl_crl ) ; mysql_options ( mysql , MYSQL_OPT_SSL_CRLPATH , opt_ssl_crlpath ) ; } mysql_options ( mysql , MYSQL_OPT_SSL_VERIFY_SERVER_CERT , ( char * ) & opt_ssl_verify_server_cert ) ; # endif if ( opt_protocol ) mysql_options ( mysql , MYSQL_OPT_PROTOCOL , ( char * ) & opt_protocol ) ; if ( opt_bind_addr ) mysql_options ( mysql , MYSQL_OPT_BIND , opt_bind_addr ) ; if ( ! opt_secure_auth ) mysql_options ( mysql , MYSQL_SECURE_AUTH , ( char * ) & opt_secure_auth ) ; # ifdef HAVE_SMEM if ( shared_memory_base_name ) mysql_options ( mysql , MYSQL_SHARED_MEMORY_BASE_NAME , shared_memory_base_name ) ; # endif if ( opt_plugin_dir && * opt_plugin_dir ) mysql_options ( mysql , MYSQL_PLUGIN_DIR , opt_plugin_dir ) ; if ( opt_default_auth && * opt_default_auth ) mysql_options ( mysql , MYSQL_DEFAULT_AUTH , opt_default_auth ) ; if ( using_opt_enable_cleartext_plugin ) mysql_options ( mysql , MYSQL_ENABLE_CLEARTEXT_PLUGIN , ( char * ) & opt_enable_cleartext_plugin ) ; mysql_options ( mysql , MYSQL_SET_CHARSET_NAME , default_charset ) ; mysql_options ( mysql , MYSQL_OPT_CONNECT_ATTR_RESET , 0 ) ; mysql_options4 ( mysql , MYSQL_OPT_CONNECT_ATTR_ADD , "program_name" , "mysqlimport" ) ; if ( ! ( mysql_connect_ssl_check ( mysql , host , user , passwd , database , opt_mysql_port , opt_mysql_unix_port , <S2SV_StartBug> 0 , opt_ssl_required ) ) ) <S2SV_EndBug> { ignore_errors = 0 ; db_error ( mysql ) ; } mysql -> reconnect = 0 ; if ( verbose ) fprintf ( stdout , "Selecting<S2SV_blank>database<S2SV_blank>%s\\n" , database ) ; if ( mysql_select_db ( mysql , database ) ) { ignore_errors = 0 ; db_error ( mysql ) ; } return mysql ; } | <S2SV_ModStart> , 0 , opt_ssl_mode == SSL_MODE_REQUIRED <S2SV_ModEnd> ) ) ) |
4,242 | CWE-000 static PyObject * attr_iter_advance ( attr_iter_object * self , PyObject * ret ) { kdump_ctx_t * ctx = self -> kdumpfile -> ctx ; kdump_status status ; status = kdump_attr_iter_next ( ctx , & self -> iter ) ; if ( status != KDUMP_OK ) { <S2SV_StartBug> PyErr_Format ( exception_map ( status ) , kdump_get_err ( ctx ) ) ; <S2SV_EndBug> Py_XDECREF ( ret ) ; ret = NULL ; } return ret ; } | <S2SV_ModStart> KDUMP_OK ) { PyErr_SetString <S2SV_ModEnd> ( exception_map ( |
4,243 | CWE-000 SQLITE_PRIVATE int sqlite3ViewGetColumnNames ( Parse * pParse , Table * pTable ) { Table * pSelTab ; Select * pSel ; int nErr = 0 ; int n ; sqlite3 * db = pParse -> db ; # ifndef SQLITE_OMIT_VIRTUALTABLE int rc ; # endif # ifndef SQLITE_OMIT_AUTHORIZATION sqlite3_xauth xAuth ; # endif assert ( pTable ) ; # ifndef SQLITE_OMIT_VIRTUALTABLE db -> nSchemaLock ++ ; rc = sqlite3VtabCallConnect ( pParse , pTable ) ; db -> nSchemaLock -- ; if ( rc ) { return 1 ; } if ( IsVirtual ( pTable ) ) return 0 ; # endif # ifndef SQLITE_OMIT_VIEW if ( pTable -> nCol > 0 ) return 0 ; if ( pTable -> nCol < 0 ) { sqlite3ErrorMsg ( pParse , "view<S2SV_blank>%s<S2SV_blank>is<S2SV_blank>circularly<S2SV_blank>defined" , pTable -> zName ) ; return 1 ; } assert ( pTable -> nCol >= 0 ) ; assert ( pTable -> pSelect ) ; pSel = sqlite3SelectDup ( db , pTable -> pSelect , 0 ) ; if ( pSel ) { n = pParse -> nTab ; sqlite3SrcListAssignCursors ( pParse , pSel -> pSrc ) ; pTable -> nCol = - 1 ; db -> lookaside . bDisable ++ ; # ifndef SQLITE_OMIT_AUTHORIZATION xAuth = db -> xAuth ; db -> xAuth = 0 ; pSelTab = sqlite3ResultSetOfSelect ( pParse , pSel ) ; db -> xAuth = xAuth ; # else pSelTab = sqlite3ResultSetOfSelect ( pParse , pSel ) ; # endif pParse -> nTab = n ; if ( pTable -> pCheck ) { sqlite3ColumnsFromExprList ( pParse , pTable -> pCheck , & pTable -> nCol , & pTable -> aCol ) ; if ( db -> mallocFailed == 0 && pParse -> nErr == 0 && pTable -> nCol == pSel -> pEList -> nExpr ) { sqlite3SelectAddColumnTypeAndCollation ( pParse , pTable , pSel ) ; } } else if ( pSelTab ) { assert ( pTable -> aCol == 0 ) ; pTable -> nCol = pSelTab -> nCol ; pTable -> aCol = pSelTab -> aCol ; pSelTab -> nCol = 0 ; pSelTab -> aCol = 0 ; assert ( sqlite3SchemaMutexHeld ( db , 0 , pTable -> pSchema ) ) ; } else { pTable -> nCol = 0 ; nErr ++ ; } sqlite3DeleteTable ( db , pSelTab ) ; sqlite3SelectDelete ( db , pSel ) ; db -> lookaside . bDisable -- ; } else { nErr ++ ; } pTable -> pSchema -> schemaFlags |= DB_UnresetViews ; <S2SV_StartBug> # endif <S2SV_EndBug> return nErr ; } | <S2SV_ModStart> |= DB_UnresetViews ; if ( db -> mallocFailed ) { sqlite3DeleteColumnNames ( db , pTable ) ; pTable -> aCol = 0 ; pTable -> nCol = 0 ; } |
4,244 | CWE-000 int main ( int argc , char * * argv ) { FILE * in = NULL ; FILE * out = NULL ; char * inname = NULL ; char * outname = NULL ; char * varname = NULL ; int c ; int cnt = 0 ; int first = 1 ; int total = 0 ; int start = 0 ; int pos = 0 ; if ( argc < 4 ) { printf ( "Usage:<S2SV_blank>./%s<S2SV_blank>input.bin<S2SV_blank>output.c<S2SV_blank>varname\\n" , argv [ 0 ] ) ; exit ( 1 ) ; } inname = argv [ 1 ] ; outname = argv [ 2 ] ; varname = argv [ 3 ] ; if ( argc >= 5 ) start = strtol ( argv [ 4 ] , NULL , 16 ) ; if ( argc >= 6 ) total = strtol ( argv [ 5 ] , NULL , 16 ) ; printf ( "<S2SV_blank>Start<S2SV_blank>at<S2SV_blank>0x%x<S2SV_blank>and<S2SV_blank>make<S2SV_blank>array<S2SV_blank>size<S2SV_blank>0x%x\\n" , start , total ) ; in = fopen ( inname , "rb" ) ; if ( in ) out = fopen ( outname , "wb" ) ; if ( in && out ) { fprintf ( out , "unsigned<S2SV_blank>char<S2SV_blank>%s<S2SV_blank>[]<S2SV_blank>=<S2SV_blank>\\n{" , varname ) ; for ( ; ; ) { if ( pos < start ) { c = 0x00 ; } else { c = fgetc ( in ) ; if ( feof ( in ) ) { if ( total ) c = 0x00 ; else break ; } } <S2SV_StartBug> if ( ( total ) && ( pos > total ) ) { <S2SV_EndBug> if ( ! feof ( in ) ) printf ( "<S2SV_blank>Warning:<S2SV_blank>input<S2SV_blank>file<S2SV_blank>longer<S2SV_blank>than<S2SV_blank>requested<S2SV_blank>memory<S2SV_blank>image\\n" ) ; break ; } pos ++ ; if ( ! first ) fprintf ( out , "," ) ; first = 0 ; if ( ( cnt & 15 ) == 0 ) fprintf ( out , "\\n\\t" ) ; fprintf ( out , "0x%02x" , c ) ; cnt ++ ; } fprintf ( out , "\\n};\\n" ) ; } if ( in ) fclose ( in ) ; if ( out ) fclose ( out ) ; return 0 ; } | <S2SV_ModStart> && ( pos >= <S2SV_ModEnd> total ) ) |
4,245 | CWE-000 static void scan_file ( const char * filename ) { int fd ; char * lang , * pathname , * exclude_pattern ; int len ; struct sq_list * comment_list ; struct line_counter * counter ; list_reset ( & exclude_list ) ; while ( ( exclude_pattern = ( char * ) list_current ( & exclude_list ) ) ) { if ( ! fnmatch ( exclude_pattern , filename , 0 ) ) { return ; } list_next ( & exclude_list ) ; } if ( ! ( comment_list = find_comment_list ( filename , & lang ) ) ) { <S2SV_StartBug> fprintf ( stderr , "No<S2SV_blank>matched<S2SV_blank>language<S2SV_blank>found,<S2SV_blank>skip<S2SV_blank>count<S2SV_blank>file:<S2SV_blank>%s\\n" , filename ) ; <S2SV_EndBug> return ; } if ( ! ( counter = malloc ( sizeof ( struct line_counter ) ) ) ) { error ( EXIT_FAILURE , "Cannot<S2SV_blank>alloc<S2SV_blank>line_counter" ) ; } len = strlen ( filename ) ; if ( ! ( pathname = malloc ( len + 1 ) ) ) { error ( EXIT_FAILURE , "Cannot<S2SV_blank>alloc<S2SV_blank>pathname" ) ; } if ( verbose ) { field_width . filename = len ; } strncpy ( pathname , filename , len ) ; pathname [ len ] = '\\0' ; counter -> filename = pathname ; counter -> lang = lang ; counter -> blank_lines = 0 ; counter -> code_lines = 0 ; counter -> comment_lines = 0 ; list_append ( & line_counter_list , ( void * ) counter ) ; fd = open ( filename , O_RDONLY ) ; if ( fd == - 1 ) { error ( EXIT_FAILURE , "Cannot<S2SV_blank>open<S2SV_blank>file:<S2SV_blank>%s" , filename ) ; } posix_fadvise ( fd , 0 , 0 , POSIX_FADV_SEQUENTIAL ) ; count_line ( fd , comment_list , counter ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ) ) { if ( verbose ) <S2SV_ModStart> counter ) ; close ( fd ) ; |
4,246 | CWE-000 SQLITE_PRIVATE KeyInfo * sqlite3KeyInfoAlloc ( sqlite3 * db , int N , int X ) { <S2SV_StartBug> KeyInfo * p = sqlite3DbMallocZero ( 0 , <S2SV_EndBug> <S2SV_StartBug> sizeof ( KeyInfo ) + ( N + X ) * ( sizeof ( CollSeq * ) + 1 ) ) ; <S2SV_EndBug> if ( p ) { p -> aSortOrder = ( u8 * ) & p -> aColl [ N + X ] ; p -> nField = ( u16 ) N ; p -> nXField = ( u16 ) X ; p -> enc = ENC ( db ) ; p -> db = db ; p -> nRef = 1 ; <S2SV_StartBug> } else { <S2SV_EndBug> <S2SV_StartBug> db -> mallocFailed = 1 ; <S2SV_EndBug> } return p ; } | <S2SV_ModStart> X ) { int nExtra = <S2SV_ModEnd> ( N + <S2SV_ModStart> + 1 ) ; KeyInfo * p = sqlite3DbMallocRawNN ( db , sizeof ( KeyInfo ) + nExtra <S2SV_ModStart> = 1 ; memset ( & p [ 1 ] , 0 , nExtra ) ; <S2SV_ModStart> } else { sqlite3OomFault ( db ) <S2SV_ModEnd> ; } return |
4,247 | CWE-000 int main ( void ) { <S2SV_StartBug> char * str = "/*%cFT_PRINTMYNAME%c*/%cchar<S2SV_blank>*ft_printmyname(void)<S2SV_blank>{return(%cAlex%c);}%cint<S2SV_blank>main(void)<S2SV_blank>{%c/*%cstr<S2SV_blank>to<S2SV_blank>write<S2SV_blank>in<S2SV_blank>printf%c*/%c%cchar<S2SV_blank>*str<S2SV_blank>=<S2SV_blank>%c%s%c;%c%cprintf(str,<S2SV_blank>10,<S2SV_blank>10,<S2SV_blank>10,<S2SV_blank>10,<S2SV_blank>34,<S2SV_blank>34,<S2SV_blank>10,<S2SV_blank>10,<S2SV_blank>10,<S2SV_blank>10,<S2SV_blank>10,<S2SV_blank>9,<S2SV_blank>34,<S2SV_blank>str,<S2SV_blank>34,<S2SV_blank>10,<S2SV_blank>9,<S2SV_blank>10,<S2SV_blank>9,<S2SV_blank>10,<S2SV_blank>10);%c%cft_printmyname();%c}%c" ; <S2SV_EndBug> <S2SV_StartBug> printf ( str , 10 , 10 , 10 , 34 , 34 , 10 , 10 , 10 , 10 , 10 , 9 , 34 , str , 34 , 10 , 9 , 10 , 9 , 10 , 10 ) ; <S2SV_EndBug> ft_printmyname ( ) ; } | <S2SV_ModStart> * str = "/*%c%cFT_PRINTMYNAME%c*/%c#include<S2SV_blank><stdio.h>%cchar<S2SV_blank>*ft_printmyname(void)<S2SV_blank>{return(%cAlex%c);}%cint<S2SV_blank>main(void)<S2SV_blank>{%c/*%c%cstr<S2SV_blank>to<S2SV_blank>write<S2SV_blank>in<S2SV_blank>printf%c*/%c%cchar<S2SV_blank>*str<S2SV_blank>=<S2SV_blank>%c%s%c;%c%cprintf(str,<S2SV_blank>10,<S2SV_blank>9,<S2SV_blank>10,<S2SV_blank>10,<S2SV_blank>10,<S2SV_blank>34,<S2SV_blank>34,<S2SV_blank>10,<S2SV_blank>10,<S2SV_blank>10,<S2SV_blank>9,<S2SV_blank>10,<S2SV_blank>10,<S2SV_blank>9,<S2SV_blank>34,<S2SV_blank>str,<S2SV_blank>34,<S2SV_blank>10,<S2SV_blank>9,<S2SV_blank>10,<S2SV_blank>9,<S2SV_blank>10,<S2SV_blank>10);%c%cft_printmyname();%c}%c" <S2SV_ModEnd> ; printf ( <S2SV_ModStart> printf ( str , 10 , 9 <S2SV_ModStart> 10 , 10 , 9 |
4,248 | CWE-000 int SimpleFS_removeFile ( DirectoryHandle * d , int file ) { int i , res , stop = 0 ; int FFB_max_entries = ( BLOCK_SIZE - sizeof ( FileControlBlock ) - sizeof ( BlockHeader ) - sizeof ( int ) - sizeof ( int ) ) / sizeof ( int ) ; int IB_max_entries = ( BLOCK_SIZE - sizeof ( int ) - sizeof ( int ) - sizeof ( int ) ) ; int next_IndexBlock ; FirstFileBlock * ffb = ( FirstFileBlock * ) malloc ( sizeof ( FirstFileBlock ) ) ; <S2SV_StartBug> res = DiskDriver_readBlock ( d -> sfs -> disk , ffb , sizeof ( FirstFileBlock ) ) ; <S2SV_EndBug> if ( res == FAILED ) { free ( ffb ) ; CHECK_ERR ( res == FAILED , "can\'t<S2SV_blank>read<S2SV_blank>the<S2SV_blank>FFB<S2SV_blank>to<S2SV_blank>remove" ) ; } for ( i = 0 ; i < FFB_max_entries && ! stop ; i ++ ) { if ( ffb -> blocks [ i ] != MISSING ) { res = DiskDriver_freeBlock ( d -> sfs -> disk , ffb -> blocks [ i ] ) ; CHECK_ERR ( res == FAILED , "can\'t<S2SV_blank>deallocate<S2SV_blank>a<S2SV_blank>data<S2SV_blank>block<S2SV_blank>indexed<S2SV_blank>in<S2SV_blank>the<S2SV_blank>ffb" ) ; } else { stop = 1 ; } } res = DiskDriver_freeBlock ( d -> sfs -> disk , file ) ; if ( ffb -> next_IndexBlock == MISSING ) { free ( ffb ) ; return SUCCESS ; } Index * index = ( Index * ) malloc ( sizeof ( Index ) ) ; next_IndexBlock = ffb -> next_IndexBlock ; free ( ffb ) ; while ( next_IndexBlock != MISSING ) { memset ( index , 0 , sizeof ( Index ) ) ; res = DiskDriver_readBlock ( d -> sfs -> disk , index , next_IndexBlock ) ; CHECK_ERR ( res == FAILED , "can\'t<S2SV_blank>load<S2SV_blank>the<S2SV_blank>next<S2SV_blank>index<S2SV_blank>block" ) ; for ( i = 0 ; i < IB_max_entries && ! stop ; i ++ ) { if ( index -> indexes [ i ] != MISSING ) { res = DiskDriver_freeBlock ( d -> sfs -> disk , index -> indexes [ i ] ) ; CHECK_ERR ( res == FAILED , "can\'t<S2SV_blank>deallocate<S2SV_blank>a<S2SV_blank>block<S2SV_blank>in<S2SV_blank>the<S2SV_blank>index<S2SV_blank>chain" ) ; } else { stop = 1 ; } res = DiskDriver_freeBlock ( d -> sfs -> disk , index -> block_in_disk ) ; CHECK_ERR ( res == FAILED , "can\'t<S2SV_blank>deallocate<S2SV_blank>the<S2SV_blank>current<S2SV_blank>index<S2SV_blank>block" ) ; } next_IndexBlock = index -> nextIndex ; } free ( index ) ; return SUCCESS ; } | <S2SV_ModStart> , ffb , file <S2SV_ModEnd> ) ; if |
4,249 | CWE-000 void run_field_inv_all_var ( void ) { secp256k1_fe x [ 16 ] , xi [ 16 ] , xii [ 16 ] ; int i ; <S2SV_StartBug> secp256k1_fe_inv_all_var ( xi , x , 0 ) ; <S2SV_EndBug> for ( i = 0 ; i < count ; i ++ ) { size_t j ; size_t len = secp256k1_rand_int ( 15 ) + 1 ; for ( j = 0 ; j < len ; j ++ ) { random_fe_non_zero ( & x [ j ] ) ; } <S2SV_StartBug> secp256k1_fe_inv_all_var ( xi , x , len ) ; <S2SV_EndBug> for ( j = 0 ; j < len ; j ++ ) { CHECK ( check_fe_inverse ( & x [ j ] , & xi [ j ] ) ) ; } <S2SV_StartBug> secp256k1_fe_inv_all_var ( xii , xi , len ) ; <S2SV_EndBug> for ( j = 0 ; j < len ; j ++ ) { CHECK ( check_fe_equal ( & x [ j ] , & xii [ j ] ) ) ; } } } | <S2SV_ModStart> ; secp256k1_fe_inv_all_var ( 0 , <S2SV_ModStart> xi , x <S2SV_ModEnd> ) ; for <S2SV_ModStart> } secp256k1_fe_inv_all_var ( len , <S2SV_ModStart> xi , x <S2SV_ModEnd> ) ; for <S2SV_ModStart> } secp256k1_fe_inv_all_var ( len , <S2SV_ModStart> xii , xi <S2SV_ModEnd> ) ; for |
4,250 | CWE-000 void replicationCron ( void ) { if ( server . masterhost && ( server . repl_state == REPL_STATE_CONNECTING || server . repl_state == REPL_STATE_RECEIVE_PONG ) && ( time ( NULL ) - server . repl_transfer_lastio ) > server . repl_timeout ) { serverLog ( LL_WARNING , "Timeout<S2SV_blank>connecting<S2SV_blank>to<S2SV_blank>the<S2SV_blank>MASTER..." ) ; undoConnectWithMaster ( ) ; } if ( server . masterhost && server . repl_state == REPL_STATE_TRANSFER && ( time ( NULL ) - server . repl_transfer_lastio ) > server . repl_timeout ) { serverLog ( LL_WARNING , "Timeout<S2SV_blank>receiving<S2SV_blank>bulk<S2SV_blank>data<S2SV_blank>from<S2SV_blank>MASTER...<S2SV_blank>If<S2SV_blank>the<S2SV_blank>problem<S2SV_blank>persists<S2SV_blank>try<S2SV_blank>to<S2SV_blank>set<S2SV_blank>the<S2SV_blank>\'repl-timeout\'<S2SV_blank>parameter<S2SV_blank>in<S2SV_blank>redis.conf<S2SV_blank>to<S2SV_blank>a<S2SV_blank>larger<S2SV_blank>value." ) ; replicationAbortSyncTransfer ( ) ; } if ( server . masterhost && server . repl_state == REPL_STATE_CONNECTED && ( time ( NULL ) - server . master -> lastinteraction ) > server . repl_timeout ) { serverLog ( LL_WARNING , "MASTER<S2SV_blank>timeout:<S2SV_blank>no<S2SV_blank>data<S2SV_blank>nor<S2SV_blank>PING<S2SV_blank>received..." ) ; freeClient ( server . master ) ; } if ( server . repl_state == REPL_STATE_CONNECT ) { serverLog ( LL_NOTICE , "Connecting<S2SV_blank>to<S2SV_blank>MASTER<S2SV_blank>%s:%d" , server . masterhost , server . masterport ) ; if ( connectWithMaster ( ) == C_OK ) { serverLog ( LL_NOTICE , "MASTER<S2SV_blank><-><S2SV_blank>SLAVE<S2SV_blank>sync<S2SV_blank>started" ) ; } } if ( server . masterhost && server . master && ! ( server . master -> flags & CLIENT_PRE_PSYNC ) ) replicationSendAck ( ) ; if ( ! ( server . cronloops % ( server . repl_ping_slave_period * server . hz ) ) ) { listIter li ; listNode * ln ; robj * ping_argv [ 1 ] ; ping_argv [ 0 ] = createStringObject ( "PING" , 4 ) ; replicationFeedSlaves ( server . slaves , server . slaveseldb , ping_argv , 1 ) ; decrRefCount ( ping_argv [ 0 ] ) ; listRewind ( server . slaves , & li ) ; while ( ( ln = listNext ( & li ) ) ) { client * slave = ln -> value ; if ( slave -> replstate == SLAVE_STATE_WAIT_BGSAVE_START || ( slave -> replstate == SLAVE_STATE_WAIT_BGSAVE_END && server . rdb_child_type != RDB_CHILD_TYPE_SOCKET ) ) { if ( write ( slave -> fd , "\\n" , 1 ) == - 1 ) { } } } } if ( listLength ( server . slaves ) ) { listIter li ; listNode * ln ; listRewind ( server . slaves , & li ) ; while ( ( ln = listNext ( & li ) ) ) { client * slave = ln -> value ; if ( slave -> replstate != SLAVE_STATE_ONLINE ) continue ; if ( slave -> flags & CLIENT_PRE_PSYNC ) continue ; if ( ( server . unixtime - slave -> repl_ack_time ) > server . repl_timeout ) { serverLog ( LL_WARNING , "Disconnecting<S2SV_blank>timedout<S2SV_blank>slave:<S2SV_blank>%s" , replicationGetSlaveName ( slave ) ) ; freeClient ( slave ) ; } } } if ( listLength ( server . slaves ) == 0 && server . repl_backlog_time_limit && server . repl_backlog ) { time_t idle = server . unixtime - server . repl_no_slaves_since ; if ( idle > server . repl_backlog_time_limit ) { freeReplicationBacklog ( ) ; serverLog ( LL_NOTICE , "Replication<S2SV_blank>backlog<S2SV_blank>freed<S2SV_blank>after<S2SV_blank>%d<S2SV_blank>seconds<S2SV_blank>" "without<S2SV_blank>connected<S2SV_blank>slaves." , ( int ) server . repl_backlog_time_limit ) ; } } if ( listLength ( server . slaves ) == 0 && server . aof_state == AOF_OFF && listLength ( server . repl_scriptcache_fifo ) != 0 ) { replicationScriptCacheFlush ( ) ; } if ( server . rdb_child_pid == - 1 && server . aof_child_pid == - 1 ) { time_t idle , max_idle = 0 ; int slaves_waiting = 0 ; listNode * ln ; listIter li ; listRewind ( server . slaves , & li ) ; while ( ( ln = listNext ( & li ) ) ) { client * slave = ln -> value ; if ( slave -> replstate == SLAVE_STATE_WAIT_BGSAVE_START ) { idle = server . unixtime - slave -> lastinteraction ; if ( idle > max_idle ) max_idle = idle ; slaves_waiting ++ ; } } if ( slaves_waiting && max_idle > server . repl_diskless_sync_delay ) { if ( startBgsaveForReplication ( ) == C_OK ) { listRewind ( server . slaves , & li ) ; while ( ( ln = listNext ( & li ) ) ) { client * slave = ln -> value ; <S2SV_StartBug> if ( slave -> replstate == SLAVE_STATE_WAIT_BGSAVE_START ) <S2SV_EndBug> slave -> replstate = SLAVE_STATE_WAIT_BGSAVE_END ; <S2SV_StartBug> } <S2SV_EndBug> } } } refreshGoodSlavesCount ( ) ; } | <S2SV_ModStart> == SLAVE_STATE_WAIT_BGSAVE_START ) { <S2SV_ModStart> = SLAVE_STATE_WAIT_BGSAVE_END ; replicationSendFullresyncReply ( slave , getPsyncInitialOffset ( ) ) ; } |
4,251 | CWE-000 DEFUN ( show_ip_bgp_ipv4 , show_ip_bgp_ipv4_cmd , <S2SV_StartBug> "show<S2SV_blank>ip<S2SV_blank>bgp<S2SV_blank>ipv4<S2SV_blank>" BGP_SAFI_CMD_STR "<S2SV_blank>{json}" , <S2SV_EndBug> SHOW_STR IP_STR BGP_STR "Address<S2SV_blank>family\\n" <S2SV_StartBug> BGP_SAFI_HELP_STR <S2SV_EndBug> "JavaScript<S2SV_blank>Object<S2SV_blank>Notation\\n" ) { u_char uj = use_json ( argc , argv ) ; return bgp_show ( vty , NULL , AFI_IP , bgp_vty_safi_from_arg ( argv [ 0 ] ) , bgp_show_type_normal , NULL , uj ) ; } | <S2SV_ModStart> , show_ip_bgp_ipv4_cmd , "show<S2SV_blank>ip<S2SV_blank>bgp<S2SV_blank>ipv4<S2SV_blank>(unicast|multicast)<S2SV_blank>{json}" <S2SV_ModEnd> , SHOW_STR IP_STR <S2SV_ModStart> IP_STR BGP_STR "Address<S2SV_blank>family\\n" "Address<S2SV_blank>Family<S2SV_blank>modifier\\n" "Address<S2SV_blank>Family<S2SV_blank>modifier\\n" <S2SV_ModEnd> "JavaScript<S2SV_blank>Object<S2SV_blank>Notation\\n" ) { |
4,252 | CWE-000 static Result loader_LoadProcess ( Handle * process , u64 prog_handle ) { Result res ; int count ; u32 flags ; u32 desc ; u32 dummy ; prog_addrs_t shared_addr ; prog_addrs_t vaddr ; Handle codeset ; CodeSetInfo codesetinfo ; u32 data_mem_size ; u64 progid ; <S2SV_StartBug> if ( g_cached_prog_handle != prog_handle ) <S2SV_EndBug> { res = loader_GetProgramInfo ( & g_exheader , prog_handle ) ; g_cached_prog_handle = prog_handle ; if ( res < 0 ) { g_cached_prog_handle = 0 ; return res ; } } flags = 0 ; for ( count = 0 ; count < 28 ; count ++ ) { desc = g_exheader . arm11kernelcaps . descriptors [ count ] ; if ( 0x1FE == desc >> 23 ) { flags = desc & 0xF00 ; } } if ( flags == 0 ) { return MAKERESULT ( RL_PERMANENT , RS_INVALIDARG , 1 , 2 ) ; } progid = g_exheader . arm11systemlocalcaps . programid ; if ( progid == HBLDR_3DSX_TID ) { Handle hbldr = 0 ; res = HBLDR_Init ( & hbldr ) ; if ( R_FAILED ( res ) ) { return res ; } u32 * cmdbuf = getThreadCommandBuffer ( ) ; cmdbuf [ 0 ] = IPC_MakeHeader ( 1 , 6 , 0 ) ; cmdbuf [ 1 ] = g_exheader . codesetinfo . text . address ; cmdbuf [ 2 ] = flags & 0xF00 ; cmdbuf [ 3 ] = progid ; cmdbuf [ 4 ] = progid >> 32 ; memcpy ( & cmdbuf [ 5 ] , g_exheader . codesetinfo . name , 8 ) ; res = svcSendSyncRequest ( hbldr ) ; svcCloseHandle ( hbldr ) ; if ( R_SUCCEEDED ( res ) ) { res = cmdbuf [ 1 ] ; } if ( R_FAILED ( res ) ) { return res ; } codeset = ( Handle ) cmdbuf [ 3 ] ; res = svcCreateProcess ( process , codeset , g_exheader . arm11kernelcaps . descriptors , count ) ; svcCloseHandle ( codeset ) ; return res ; } vaddr . text_addr = g_exheader . codesetinfo . text . address ; vaddr . text_size = ( g_exheader . codesetinfo . text . codesize + 4095 ) >> 12 ; vaddr . ro_addr = g_exheader . codesetinfo . ro . address ; vaddr . ro_size = ( g_exheader . codesetinfo . ro . codesize + 4095 ) >> 12 ; vaddr . data_addr = g_exheader . codesetinfo . data . address ; vaddr . data_size = ( g_exheader . codesetinfo . data . codesize + 4095 ) >> 12 ; data_mem_size = ( g_exheader . codesetinfo . data . codesize + g_exheader . codesetinfo . bsssize + 4095 ) >> 12 ; vaddr . total_size = vaddr . text_size + vaddr . ro_size + vaddr . data_size ; if ( ( res = allocate_shared_mem ( & shared_addr , & vaddr , flags ) ) < 0 ) { return res ; } if ( ( res = load_code ( progid , & shared_addr , prog_handle , g_exheader . codesetinfo . flags . flag & 1 ) ) >= 0 ) { memcpy ( & codesetinfo . name , g_exheader . codesetinfo . name , 8 ) ; codesetinfo . program_id = progid ; codesetinfo . text_addr = vaddr . text_addr ; codesetinfo . text_size = vaddr . text_size ; codesetinfo . text_size_total = vaddr . text_size ; codesetinfo . ro_addr = vaddr . ro_addr ; codesetinfo . ro_size = vaddr . ro_size ; codesetinfo . ro_size_total = vaddr . ro_size ; codesetinfo . rw_addr = vaddr . data_addr ; codesetinfo . rw_size = vaddr . data_size ; codesetinfo . rw_size_total = data_mem_size ; res = svcCreateCodeSet ( & codeset , & codesetinfo , ( void * ) shared_addr . text_addr , ( void * ) shared_addr . ro_addr , ( void * ) shared_addr . data_addr ) ; if ( res >= 0 ) { res = svcCreateProcess ( process , codeset , g_exheader . arm11kernelcaps . descriptors , count ) ; svcCloseHandle ( codeset ) ; if ( res >= 0 ) { return 0 ; } } } svcControlMemory ( & dummy , shared_addr . text_addr , 0 , shared_addr . total_size << 12 , MEMOP_FREE , 0 ) ; return res ; } | <S2SV_ModStart> g_cached_prog_handle != prog_handle || g_exheader . arm11systemlocalcaps . programid == HBLDR_3DSX_TID |
4,253 | CWE-000 void pre_suspend ( void ) { <S2SV_StartBug> local_irq_disable ( ) ; <S2SV_EndBug> fini_time ( ) ; suspend_console ( ) ; suspend_events ( ) ; } | <S2SV_ModStart> ) { local_irq_disable ( ) ; suspend_gnttab |
4,254 | CWE-000 void rldisp_mouse ( rldisp * this , int * x , int * y ) { sfVector2i m ; if ( ! this || ! this -> window . handle || ! x || ! y ) return ; m = sfMouse_getPositionRenderWindow ( this -> window . handle ) ; if ( m . x < 0 || m . x > this -> window . width ) <S2SV_StartBug> * x = m . x ; <S2SV_EndBug> else * x = ( int ) ( ( float ) m . x / this -> frame . scale . x ) ; if ( m . y < 0 || m . y > this -> window . height ) <S2SV_StartBug> * y = m . y ; <S2SV_EndBug> else * y = ( int ) ( ( float ) m . y / this -> frame . scale . y ) ; } | <S2SV_ModStart> * x = - 1 <S2SV_ModEnd> ; else * <S2SV_ModStart> * y = - 1 <S2SV_ModEnd> ; else * |
4,255 | CWE-000 static int atmel_nand_controller_init ( struct atmel_nand_controller * nc , struct platform_device * pdev , const struct atmel_nand_controller_caps * caps ) { struct device * dev = & pdev -> dev ; struct device_node * np = dev -> of_node ; int ret ; nand_hw_control_init ( & nc -> base ) ; INIT_LIST_HEAD ( & nc -> chips ) ; nc -> dev = dev ; nc -> caps = caps ; platform_set_drvdata ( pdev , nc ) ; nc -> pmecc = devm_atmel_pmecc_get ( dev ) ; if ( IS_ERR ( nc -> pmecc ) ) { ret = PTR_ERR ( nc -> pmecc ) ; if ( ret != - EPROBE_DEFER ) dev_err ( dev , "Could<S2SV_blank>not<S2SV_blank>get<S2SV_blank>PMECC<S2SV_blank>object<S2SV_blank>(err<S2SV_blank>=<S2SV_blank>%d)\\n" , ret ) ; return ret ; } if ( nc -> caps -> has_dma ) { dma_cap_mask_t mask ; dma_cap_zero ( mask ) ; dma_cap_set ( DMA_MEMCPY , mask ) ; nc -> dmac = dma_request_channel ( mask , NULL , NULL ) ; if ( ! nc -> dmac ) dev_err ( nc -> dev , "Failed<S2SV_blank>to<S2SV_blank>request<S2SV_blank>DMA<S2SV_blank>channel\\n" ) ; } if ( nc -> caps -> legacy_of_bindings ) return 0 ; np = of_parse_phandle ( dev -> parent -> of_node , "atmel,smc" , 0 ) ; if ( ! np ) { dev_err ( dev , "Missing<S2SV_blank>or<S2SV_blank>invalid<S2SV_blank>atmel,smc<S2SV_blank>property\\n" ) ; return - EINVAL ; } nc -> smc = syscon_node_to_regmap ( np ) ; of_node_put ( np ) ; if ( IS_ERR ( nc -> smc ) ) { <S2SV_StartBug> ret = IS_ERR ( nc -> smc ) ; <S2SV_EndBug> dev_err ( dev , "Could<S2SV_blank>not<S2SV_blank>get<S2SV_blank>SMC<S2SV_blank>regmap<S2SV_blank>(err<S2SV_blank>=<S2SV_blank>%d)\\n" , ret ) ; return ret ; } return 0 ; } | <S2SV_ModStart> { ret = PTR_ERR <S2SV_ModEnd> ( nc -> |
4,256 | CWE-000 static void test_circular_file_broken_metadata_file ( Fixture * fixture , const gchar * metadata_file_contents , gssize metadata_file_length , GKeyFileError expected_error_code ) { const gsize max_size = 1024 ; g_autofree gchar * data_file_contents = g_malloc ( max_size ) ; g_autofree gchar * metadata_file_path = g_strconcat ( fixture -> data_file_path , METADATA_EXTENSION , NULL ) ; g_autoptr ( GError ) error = NULL ; gboolean ret ; memset ( data_file_contents , '*' , max_size ) ; ret = g_file_set_contents ( fixture -> data_file_path , data_file_contents , max_size , & error ) ; g_assert_no_error ( error ) ; g_assert_true ( ret ) ; ret = g_file_set_contents ( metadata_file_path , metadata_file_contents , metadata_file_length , & error ) ; g_assert_no_error ( error ) ; g_assert_true ( ret ) ; g_autoptr ( EmerCircularFile ) circular_file = NULL ; circular_file = emer_circular_file_new ( fixture -> data_file_path , max_size , FALSE , & error ) ; g_assert_null ( circular_file ) ; <S2SV_StartBug> g_assert_error ( error , G_KEY_FILE_ERROR , expected_error_code ) ; <S2SV_EndBug> g_clear_error ( & error ) ; circular_file = emer_circular_file_new ( fixture -> data_file_path , max_size , TRUE , & error ) ; g_assert_no_error ( error ) ; g_assert_nonnull ( circular_file ) ; assert_circular_file_works_after_recovery ( fixture , circular_file , max_size ) ; } | <S2SV_ModStart> , G_KEY_FILE_ERROR , ( gint ) |
4,257 | CWE-000 static double <S2SV_StartBug> local_time ( double t ) <S2SV_EndBug> { <S2SV_StartBug> return t - utc_offset ( ) - dst_offset ( t ) ; <S2SV_EndBug> } | <S2SV_ModStart> local_time ( double utc_ms <S2SV_ModEnd> ) { return <S2SV_ModStart> ) { return utc_ms + utc_offset ( utc_ms <S2SV_ModEnd> ) ; } |
4,258 | CWE-000 GlimpseTypeHandler_t * glimpse_typesystem_query ( GlimpseTypeDesc_t * type ) { int i ; for ( i = 0 ; i < _glimpse_typesystem_known_handler -> size ; i ++ ) { GlimpseTypeHandler_t * known_handler = ( GlimpseTypeHandler_t * ) glimpse_vector_get ( _glimpse_typesystem_known_handler , i ) ; if ( NULL == known_handler ) continue ; if ( _glimpse_typesystem_typedesc_equal ( known_handler -> type , type ) ) { if ( ! type -> registered ) glimpse_typesystem_typedesc_free ( type ) ; char buffer [ 1024 ] ; if ( glimpse_typesystem_typehandler_tostring ( known_handler , buffer , sizeof ( buffer ) ) ) GLIMPSE_LOG_DEBUG ( "queried<S2SV_blank>an<S2SV_blank>known<S2SV_blank>handler:<S2SV_blank>%s" , buffer ) ; return known_handler ; } } if ( NULL == type ) return NULL ; GlimpseTypeHandler_t handler = { . type = type } ; switch ( type -> builtin_type ) { case GLIMPSE_TYPE_BUILTIN_VECTOR : handler . vector_parser_param [ 0 ] = ( GlimpseTypeVectorParserParam_t * ) malloc ( sizeof ( GlimpseTypeVectorParserParam_t ) ) ; if ( NULL == handler . vector_parser_param [ 0 ] ) goto ERR_VEC ; handler . vector_parser_param [ 0 ] -> basetype_handler = glimpse_typesystem_query ( type -> param . vector . basetype ) ; if ( NULL == handler . vector_parser_param [ 0 ] -> basetype_handler ) goto ERR_VEC ; type -> param . vector . basetype = handler . vector_parser_param [ 0 ] -> basetype_handler -> type ; handler . vector_parser_param [ 0 ] -> sep = type -> param . vector . sep ; # ifdef STRING_SEPERATOR_SUPPORT if ( NULL == handler . vector_parser_param [ 0 ] -> sep ) goto ERR_VEC ; # endif handler . init_data = NULL ; handler . free_data = type -> param . vector . basetype ; handler . alloc_data = NULL ; handler . finalize_data = type -> param . vector . basetype ; handler . parse = glimpse_builtintype_vector_parse ; handler . init = glimpse_builtintype_vector_init ; handler . free = glimpse_builtintype_vector_free ; handler . alloc = glimpse_builtintype_vector_alloc ; handler . finalize = glimpse_builtintype_vector_finalize ; handler . tostring = glimpse_builtintype_vector_tostring ; <S2SV_StartBug> break ; <S2SV_EndBug> ERR_VEC : if ( handler . vector_parser_param [ 0 ] ) free ( handler . vector_parser_param [ 0 ] ) ; return NULL ; case GLIMPSE_TYPE_BUILTIN_SUBLOG : if ( NULL == type -> param . sublog . tree ) return NULL ; if ( NULL == type -> param . sublog . tree -> model ) return NULL ; handler . sublog_parser_param [ 0 ] = type -> param . sublog . tree ; handler . sublog_alloc_param [ 0 ] = type -> param . sublog . tree -> model ; handler . init_data = NULL ; handler . free_data = NULL ; handler . finalize_data = NULL ; handler . parse = glimpse_builtintype_sublog_parse ; handler . alloc = glimpse_builtintype_sublog_alloc ; handler . free = glimpse_builtintype_sublog_free ; handler . init = glimpse_builtintype_sublog_init ; handler . finalize = glimpse_builtintype_sublog_finalize ; handler . tostring = glimpse_builtintype_sublog_tostring ; <S2SV_StartBug> break ; <S2SV_EndBug> case GLIMPSE_TYPE_BUILTIN_MAP : break ; case GLIMPSE_TYPE_BUILTIN_NONE : for ( i = 0 ; i < _glimpse_typesystem_typegroup_count ; i ++ ) if ( strcmp ( _glimpse_typesystem_typegroup_list [ i ] -> name , type -> param . normal . group ) == 0 ) { int ret = _glimpse_typesystem_typegroup_list [ i ] -> resolve ( type , & handler ) ; if ( GLIMPSE_ESUCCESS == ret ) break ; } if ( i == _glimpse_typesystem_typegroup_count ) { glimpse_typesystem_typedesc_free ( type ) ; return NULL ; } break ; default : GLIMPSE_LOG_ERROR ( "invalid<S2SV_blank>builtin<S2SV_blank>type<S2SV_blank>%d\\n" , type -> builtin_type ) ; } int rc = glimpse_vector_push ( _glimpse_typesystem_known_handler , & handler ) ; if ( GLIMPSE_ESUCCESS != rc ) return NULL ; type -> registered = 1 ; char buffer [ 1024 ] ; if ( glimpse_typesystem_typehandler_tostring ( & handler , buffer , sizeof ( buffer ) ) ) GLIMPSE_LOG_DEBUG ( "registed<S2SV_blank>new<S2SV_blank>type<S2SV_blank>handler:<S2SV_blank>%s" , buffer ) ; # ifdef THREAD_SAFE GlimpseTypeHandler_t * ret = ( GlimpseTypeHandler_t * ) glimpse_vector_get ( _glimpse_typesystem_known_handler , _glimpse_typesystem_known_handler -> size - 1 ) ; if ( NULL == ret ) return NULL ; pthread_mutex_init ( & ret -> pool . mutex , NULL ) ; return ret ; # else return ( GlimpseTypeHandler_t * ) glimpse_vector_get ( _glimpse_typesystem_known_handler , _glimpse_typesystem_known_handler -> size - 1 ) ; # endif } | <S2SV_ModStart> = glimpse_builtintype_vector_tostring ; # ifdef LAZY_INSTANCE handler . cleanup_data = type -> param . vector . basetype ; handler . cleanup = glimpse_builtintype_vector_cleanup ; # endif <S2SV_ModStart> = glimpse_builtintype_sublog_tostring ; # ifdef LAZY_INSTANCE handler . cleanup_data = NULL ; handler . cleanup = glimpse_builtintype_sublog_cleanup ; # endif |
4,259 | CWE-000 static void gamma_neutralize_callback ( GtkWidget * button , gpointer user_data ) { dt_iop_module_t * self = ( dt_iop_module_t * ) user_data ; if ( self -> dt -> gui -> reset ) return ; if ( self -> off ) gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( self -> off ) , 1 ) ; if ( self -> request_color_pick == DT_REQUEST_COLORPICK_OFF ) { dt_iop_request_focus ( self ) ; self -> request_color_pick = DT_REQUEST_COLORPICK_MODULE ; dt_control_queue_redraw ( ) ; } else { dt_dev_reprocess_all ( self -> dev ) ; dt_iop_colorbalance_params_t * p = ( dt_iop_colorbalance_params_t * ) self -> params ; dt_iop_colorbalance_gui_data_t * g = ( dt_iop_colorbalance_gui_data_t * ) self -> gui_data ; if ( self -> request_color_pick != DT_REQUEST_COLORPICK_MODULE || self -> picked_color_max [ 0 ] < 0.0f ) { dt_control_log ( _ ( "wait<S2SV_blank>for<S2SV_blank>the<S2SV_blank>preview<S2SV_blank>to<S2SV_blank>be<S2SV_blank>updated." ) ) ; return ; } float XYZ [ 3 ] = { 0.0f } ; dt_Lab_to_XYZ ( ( const float * ) self -> picked_color , XYZ ) ; float RGB [ 3 ] = { 0.0f } ; dt_XYZ_to_prophotorgb ( ( const float * ) XYZ , RGB ) ; # ifdef OPTIM <S2SV_StartBug> dt_iop_colorbalance_data_t * d = ( dt_iop_colorbalance_data_t * ) self -> data ; <S2SV_EndBug> <S2SV_StartBug> for ( int c = 0 ; c < 3 ; ++ c ) d -> color_patches_gamma [ c ] = RGB [ c ] ; <S2SV_EndBug> <S2SV_StartBug> d -> color_patches_flags [ GAMMA ] = 1 ; <S2SV_EndBug> # endif for ( int c = 0 ; c < 3 ; ++ c ) RGB [ c ] = CDL ( RGB [ c ] , p -> gain [ CHANNEL_FACTOR ] , p -> lift [ CHANNEL_FACTOR ] - 1.0f , 1.0f / p -> gamma [ CHANNEL_FACTOR ] ) ; float grey = 0.0 ; for ( int c = 0 ; c < 3 ; ++ c ) grey += RGB [ c ] / 3.0f ; for ( int c = 0 ; c < 3 ; ++ c ) RGB [ c ] = logf ( RGB [ c ] ) / logf ( grey ) ; dt_prophotorgb_to_XYZ ( RGB , XYZ ) ; for ( int c = 0 ; c < 3 ; ++ c ) RGB [ c ] = ( RGB [ c ] - XYZ [ 1 ] ) + 1.0f ; p -> gamma [ CHANNEL_RED ] = RGB [ 0 ] ; p -> gamma [ CHANNEL_GREEN ] = RGB [ 1 ] ; p -> gamma [ CHANNEL_BLUE ] = RGB [ 2 ] ; darktable . gui -> reset = 1 ; dt_bauhaus_slider_set_soft ( g -> gamma_r , p -> gamma [ CHANNEL_RED ] - 1.0f ) ; dt_bauhaus_slider_set_soft ( g -> gamma_g , p -> gamma [ CHANNEL_GREEN ] - 1.0f ) ; dt_bauhaus_slider_set_soft ( g -> gamma_b , p -> gamma [ CHANNEL_BLUE ] - 1.0f ) ; set_HSL_sliders ( g -> hue_gamma , g -> sat_gamma , p -> gamma ) ; darktable . gui -> reset = 0 ; self -> request_color_pick = DT_REQUEST_COLORPICK_OFF ; dt_dev_add_history_item ( darktable . develop , self , TRUE ) ; } } | <S2SV_ModStart> # ifdef OPTIM <S2SV_ModEnd> for ( int <S2SV_ModStart> ++ c ) g <S2SV_ModEnd> -> color_patches_gamma [ <S2SV_ModStart> c ] ; g <S2SV_ModEnd> -> color_patches_flags [ |
4,260 | CWE-000 void sc_do_mount ( const char * source , const char * target , const char * fs_type , unsigned long mountflags , const void * data ) { char buf [ 10000 ] = { 0 } ; const char * mount_cmd = NULL ; if ( sc_is_debug_enabled ( ) ) { # ifdef SNAP_CONFINE_DEBUG_BUILD mount_cmd = sc_mount_cmd ( buf , sizeof ( buf ) , source , target , fs_type , mountflags , data ) ; <S2SV_StartBug> # else <S2SV_EndBug> mount_cmd = "(disabled)<S2SV_blank>use<S2SV_blank>debug<S2SV_blank>build<S2SV_blank>to<S2SV_blank>see<S2SV_blank>details" ; # endif <S2SV_StartBug> debug ( "performing<S2SV_blank>operation:<S2SV_blank>%s" , mount_cmd ) ; <S2SV_EndBug> } if ( sc_faulty ( "mount" , NULL ) || mount ( source , target , fs_type , mountflags , data ) < 0 ) { int saved_errno = errno ; sc_privs_drop ( ) ; if ( mount_cmd == NULL ) { mount_cmd = sc_mount_cmd ( buf , sizeof ( buf ) , source , target , fs_type , mountflags , data ) ; } errno = saved_errno ; die ( "cannot<S2SV_blank>perform<S2SV_blank>operation:<S2SV_blank>%s" , mount_cmd ) ; } } | <S2SV_ModStart> ) ; # <S2SV_ModEnd> endif debug ( <S2SV_ModStart> "performing<S2SV_blank>operation:<S2SV_blank>%s" , mount_cmd ? mount_cmd : use_debug_build |
4,261 | CWE-000 static int mppa256_portal_allow ( int portalid , int local , int remote ) { int sync_fd ; char pathname [ 128 ] ; sprintf ( pathname , "/mppa/sync/%d:%d" , remote , <S2SV_StartBug> ( noc_is_cnode ( remote ) || noc_is_cnode ( local ) ) ? <S2SV_EndBug> noctag_portal ( portals [ portalid ] . local ) : 127 ) ; if ( ( sync_fd = mppa_open ( pathname , O_WRONLY ) ) == - 1 ) return ( - EAGAIN ) ; portals [ portalid ] . remote = remote ; portals [ portalid ] . sync_fd = sync_fd ; return ( 0 ) ; } | <S2SV_ModStart> , remote , noctag_portal <S2SV_ModEnd> ( local ) <S2SV_ModStart> ( local ) <S2SV_ModEnd> ) ; if |
4,262 | CWE-000 <S2SV_StartBug> int char_char_child ( int parent_id , int child_id ) <S2SV_EndBug> { if ( SQL_ERROR == SQL -> Query ( inter -> sql_handle , "SELECT<S2SV_blank>`child`<S2SV_blank>FROM<S2SV_blank>`%s`<S2SV_blank>WHERE<S2SV_blank>`char_id`<S2SV_blank>=<S2SV_blank>\'%d\'" , char_db , parent_id ) ) Sql_ShowDebug ( inter -> sql_handle ) ; else if ( SQL_SUCCESS == SQL -> NextRow ( inter -> sql_handle ) ) { char * data ; SQL -> GetData ( inter -> sql_handle , 0 , & data , NULL ) ; if ( child_id == atoi ( data ) ) { SQL -> FreeResult ( inter -> sql_handle ) ; return 1 ; } } SQL -> FreeResult ( inter -> sql_handle ) ; return 0 ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static |
4,263 | CWE-000 static uint16_t prv_dcdc_undervoltage_convert ( uint16_t value ) { <S2SV_StartBug> return TEST_POWER_PATH_DCDC_UV_VAL ; <S2SV_EndBug> } | <S2SV_ModStart> value ) { LOG_DEBUG ( "DCDC<S2SV_blank>Voltage<S2SV_blank>Converted\\n" ) ; |
4,264 | CWE-000 int media_setup_link ( struct media_device * media , struct media_pad * source , struct media_pad * sink , __u32 flags ) { <S2SV_StartBug> struct media_link * link ; <S2SV_EndBug> struct media_link_desc ulink ; unsigned int i ; int ret ; ret = media_device_open ( media ) ; if ( ret < 0 ) goto done ; for ( i = 0 ; i < source -> entity -> num_links ; i ++ ) { link = & source -> entity -> links [ i ] ; if ( link -> source -> entity == source -> entity && link -> source -> index == source -> index && link -> sink -> entity == sink -> entity && link -> sink -> index == sink -> index ) break ; } if ( i == source -> entity -> num_links ) { media_dbg ( media , "%s:<S2SV_blank>Link<S2SV_blank>not<S2SV_blank>found\\n" , __func__ ) ; ret = - ENOENT ; goto done ; } ulink . source . entity = source -> entity -> info . id ; ulink . source . index = source -> index ; ulink . source . flags = MEDIA_PAD_FL_SOURCE ; ulink . sink . entity = sink -> entity -> info . id ; ulink . sink . index = sink -> index ; ulink . sink . flags = MEDIA_PAD_FL_SINK ; ulink . flags = flags | ( link -> flags & MEDIA_LNK_FL_IMMUTABLE ) ; ret = ioctl ( media -> fd , MEDIA_IOC_SETUP_LINK , & ulink ) ; if ( ret == - 1 ) { ret = - errno ; media_dbg ( media , "%s:<S2SV_blank>Unable<S2SV_blank>to<S2SV_blank>setup<S2SV_blank>link<S2SV_blank>(%s)\\n" , __func__ , strerror ( errno ) ) ; goto done ; } <S2SV_StartBug> link -> flags = ulink . flags ; <S2SV_EndBug> link -> twin -> flags = ulink . flags ; <S2SV_StartBug> ret = 0 ; <S2SV_EndBug> done : media_device_close ( media ) ; return ret ; } | <S2SV_ModStart> media_link * link = 0 <S2SV_ModStart> done ; } if ( 0 != link ) { <S2SV_ModStart> = 0 ; } |
4,265 | CWE-000 void sendOfflineMsg ( int indexOfSelf , int * client , struct clientProfile * clientProfiles , char * sendbuf ) { for ( int i = 0 ; i < FD_SETSIZE ; i ++ ) { if ( client [ i ] != - 1 ) { snprintf ( sendbuf , BUFMAX , "[Server]<S2SV_blank>%s<S2SV_blank>is<S2SV_blank>offline\\n" , clientProfiles [ indexOfSelf ] . name ) ; <S2SV_StartBug> Writen ( client [ i ] , sendbuf , strlen ( sendbuf ) ) ; <S2SV_EndBug> } } } | <S2SV_ModStart> name ) ; write <S2SV_ModEnd> ( client [ |
4,266 | CWE-000 int ft_strncmp ( const char * s1 , const char * s2 , size_t n ) { <S2SV_StartBug> if ( n == 0 ) <S2SV_EndBug> <S2SV_StartBug> return ( 0 ) ; <S2SV_EndBug> while ( * s1 == * s2 && -- n > 0 ) { if ( * s1 == '\\0' && * s2 == '\\0' ) return ( 0 ) ; s1 ++ ; s2 ++ ; } return ( * ( unsigned char * ) s1 - * ( unsigned char * ) s2 ) ; } | <S2SV_ModStart> n == 0 || ( ! s1 && ! s2 ) <S2SV_ModStart> return ( 0 ) ; if ( ( ! s1 && s2 ) || ( s1 && ! s2 ) ) return ( 1 |
4,267 | CWE-000 static enum QUALITY_PRESET parseQuality ( const char * s ) { if ( ! strcmp ( "low" , s ) ) return LOW ; else if ( ! strcmp ( "medium" , s ) ) return MEDIUM ; else if ( ! strcmp ( "high" , s ) ) return preset = HIGH ; else if ( ! strcmp ( "veryhigh" , s ) ) return preset = VERYHIGH ; <S2SV_StartBug> fprintf ( stderr , "Unknown<S2SV_blank>quality<S2SV_blank>preset<S2SV_blank>\'%s\'!\\n" , s ) ; <S2SV_EndBug> return MEDIUM ; } | <S2SV_ModStart> = VERYHIGH ; error ( "unknown<S2SV_blank>quality<S2SV_blank>preset:<S2SV_blank>%s" <S2SV_ModEnd> , s ) |
4,268 | CWE-000 static int __hif_pci_resume ( struct pci_dev * pdev , bool runtime_pm ) { struct hif_pci_softc * sc = pci_get_drvdata ( pdev ) ; void * vos_context = vos_get_global_context ( VOS_MODULE_ID_HIF , NULL ) ; struct HIF_CE_state * hif_state = ( struct HIF_CE_state * ) sc -> hif_device ; A_target_id_t targid = hif_state -> targid ; u32 val ; int err = 0 ; v_VOID_t * temp_module ; u32 tmp ; int retry = 0 ; if ( vos_is_logp_in_progress ( VOS_MODULE_ID_HIF , NULL ) ) return err ; err = __hif_check_link_status ( pdev ) ; if ( err ) return err ; adf_os_atomic_set ( & sc -> pci_link_suspended , 0 ) ; adf_os_atomic_set ( & sc -> wow_done , 0 ) ; if ( HIFTargetSleepStateAdjust ( targid , FALSE , TRUE ) < 0 ) goto out ; for ( ; ; ) { A_PCI_WRITE32 ( sc -> mem + ( SOC_CORE_BASE_ADDRESS | PCIE_INTR_ENABLE_ADDRESS ) , PCIE_INTR_FIRMWARE_MASK | PCIE_INTR_CE_MASK_ALL ) ; tmp = A_PCI_READ32 ( sc -> mem + ( SOC_CORE_BASE_ADDRESS | PCIE_INTR_ENABLE_ADDRESS ) ) ; if ( tmp != 0xffffffff ) break ; if ( retry > MAX_REG_READ_RETRIES ) { pr_err ( "%s:<S2SV_blank>PCIe<S2SV_blank>link<S2SV_blank>is<S2SV_blank>possible<S2SV_blank>down!\\n" , __func__ ) ; <S2SV_StartBug> print_config_soc_reg ( sc ) ; <S2SV_EndBug> VOS_ASSERT ( 0 ) ; break ; } A_MDELAY ( 1 ) ; retry ++ ; } hif_irq_record ( HIF_RESUME , sc ) ; if ( HIFTargetSleepStateAdjust ( targid , TRUE , FALSE ) < 0 ) goto out ; if ( runtime_pm ) goto skip ; err = pci_enable_device ( pdev ) ; if ( err ) { printk ( "\\n%s<S2SV_blank>%d<S2SV_blank>:<S2SV_blank>pci_enable_device<S2SV_blank>returned<S2SV_blank>failure<S2SV_blank>%d\\n" , __func__ , __LINE__ , err ) ; goto out ; } pci_read_config_dword ( pdev , OL_ATH_PCI_PM_CONTROL , & val ) ; if ( ( val & 0x000000ff ) != 0 ) { pci_restore_state ( pdev ) ; pci_write_config_dword ( pdev , OL_ATH_PCI_PM_CONTROL , val & 0xffffff00 ) ; pci_read_config_dword ( pdev , 0x40 , & val ) ; if ( ( val & 0x0000ff00 ) != 0 ) pci_write_config_dword ( pdev , 0x40 , val & 0xffff00ff ) ; } pci_set_master ( pdev ) ; skip : # ifdef HIF_PCI vos_pcie_shadow_control ( pdev , TRUE ) ; # endif # ifdef DISABLE_L1SS_STATES pci_read_config_dword ( pdev , 0x188 , & val ) ; pci_write_config_dword ( pdev , 0x188 , ( val & ~ 0x0000000f ) ) ; # endif temp_module = vos_get_context ( VOS_MODULE_ID_WDA , vos_context ) ; if ( ! temp_module ) { printk ( "%s:<S2SV_blank>WDA<S2SV_blank>module<S2SV_blank>is<S2SV_blank>NULL\\n" , __func__ ) ; goto out ; } hif_enable_tasklet_noclient ( sc , temp_module ) ; if ( ! wma_is_wow_mode_selected ( temp_module ) ) err = wma_resume_target ( temp_module , runtime_pm ) ; else err = wma_disable_wow_in_fw ( temp_module , runtime_pm ) ; # ifdef FEATURE_WLAN_D0WOW if ( wma_get_client_count ( temp_module ) ) { if ( disable_irq_wake ( pdev -> irq ) ) { pr_err ( "%s:<S2SV_blank>Fail<S2SV_blank>to<S2SV_blank>disable<S2SV_blank>wake<S2SV_blank>IRQ!\\n" , __func__ ) ; err = - 1 ; goto out ; } } # endif pr_debug ( "%s:<S2SV_blank>Resume<S2SV_blank>completes%s<S2SV_blank>in%s<S2SV_blank>mode\\n" , __func__ , runtime_pm ? "<S2SV_blank>for<S2SV_blank>runtime<S2SV_blank>pm" : "" , wma_is_wow_mode_selected ( temp_module ) ? "<S2SV_blank>wow" : "<S2SV_blank>pdev" ) ; out : if ( err ) { pr_err ( "%s:<S2SV_blank>resume<S2SV_blank>failed<S2SV_blank>err:%d\\n" , __func__ , err ) ; return ( - 1 ) ; } return ( 0 ) ; } | <S2SV_ModStart> __func__ ) ; if ( vos_is_logp_in_progress ( VOS_MODULE_ID_HIF , NULL ) ) return 0 ; sc -> recovery = true ; vos_set_logp_in_progress ( VOS_MODULE_ID_VOSS , TRUE ) ; vos_wlan_pci_link_down ( ) ; goto out <S2SV_ModEnd> ; } A_MDELAY |
4,269 | CWE-000 void _db_doprnt_ ( const char * format , ... ) { va_list args ; CODE_STATE * cs ; <S2SV_StartBug> int save_errno ; <S2SV_EndBug> get_code_state_or_return ; va_start ( args , format ) ; <S2SV_StartBug> if ( ! cs -> locked ) <S2SV_EndBug> <S2SV_StartBug> pthread_mutex_lock ( & THR_LOCK_dbug ) ; <S2SV_EndBug> save_errno = errno ; DoPrefix ( cs , cs -> u_line ) ; if ( TRACING ) Indent ( cs , cs -> level + 1 ) ; else ( void ) fprintf ( cs -> stack -> out_file -> file , "%s:<S2SV_blank>" , cs -> func ) ; ( void ) fprintf ( cs -> stack -> out_file -> file , "%s:<S2SV_blank>" , cs -> u_keyword ) ; DbugVfprintf ( cs -> stack -> out_file -> file , format , args ) ; DbugFlush ( cs ) ; <S2SV_StartBug> errno = save_errno ; <S2SV_EndBug> va_end ( args ) ; } | <S2SV_ModStart> ; int save_errno , org_cs_locked <S2SV_ModStart> if ( ! ( org_cs_locked = <S2SV_ModStart> -> locked ) ) { <S2SV_ModStart> THR_LOCK_dbug ) ; cs -> locked = 1 ; } <S2SV_ModStart> cs ) ; if ( ! org_cs_locked ) { cs -> locked = 0 ; pthread_mutex_unlock ( & THR_LOCK_dbug ) ; } |
4,270 | CWE-000 static void DisplayPage_KeyHandler ( eKeyData_t key ) { static u8 itemY = DISPLAY_ITEM_Y_RESOLUTION ; u8 inc_dec = DECREASE ; eResolution_t resolution ; BOOL osdOn ; BOOL borderLineOn ; switch ( key ) { case KEY_UP : inc_dec = INCREASE ; case KEY_DOWN : if ( requestEnterKeyProc ) { switch ( itemY ) { case DISPLAY_ITEM_Y_RESOLUTION : Read_NvItem_Resolution ( & resolution ) ; IncreaseDecreaseCount ( RESOLUTION_MAX - 1 , 0 , inc_dec , & resolution ) ; Write_NvItem_Resolution ( resolution ) ; break ; case DISPLAY_ITEM_Y_OSD_DISPLAY : Read_NvItem_OsdOn ( & osdOn ) ; Toggle ( & osdOn ) ; Write_NvItem_OsdOn ( osdOn ) ; break ; case DISPLAY_ITEM_Y_BORDER_LINE_DISPLAY : Read_NvItem_BorderLineDisplay ( & borderLineOn ) ; Toggle ( & borderLineOn ) ; Write_NvItem_BorderLineDisplay ( borderLineOn ) ; break ; } DisplayPage_UpdatePageOption ( itemY ) ; } else { IncreaseDecreaseCount ( 3 , 1 , inc_dec , & itemY ) ; DrawSelectMark ( itemY ) ; } break ; case KEY_ENTER : <S2SV_StartBug> toggle ( requestEnterKeyProc ) ; <S2SV_EndBug> DisplayPage_UpdatePageOption ( itemY ) ; break ; case KEY_EXIT : if ( requestEnterKeyProc ) { <S2SV_StartBug> toggle ( requestEnterKeyProc ) ; <S2SV_EndBug> DisplayPage_UpdatePageOption ( itemY ) ; } else { itemY = DISPLAY_ITEM_Y_RESOLUTION ; MainMenu_Entry ( currentPage ) ; } break ; } } | <S2SV_ModStart> case KEY_ENTER : Toggle <S2SV_ModEnd> ( requestEnterKeyProc ) <S2SV_ModStart> requestEnterKeyProc ) { Toggle <S2SV_ModEnd> ( requestEnterKeyProc ) |
4,271 | CWE-000 <S2SV_StartBug> void null_cache_flush ( void ) <S2SV_EndBug> { mb ( ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static |
4,272 | CWE-000 boolean superTrackDropDownWithExtra ( struct cart * cart , struct trackDb * tdb , int visibleChild , struct slPair * events ) { if ( ! tdbIsSuperTrack ( tdb ) ) return FALSE ; boolean show = FALSE ; char * setting = cartUsualString ( cart , tdb -> track , tdb -> isShow ? "show" : "hide" ) ; if ( sameString ( "show" , setting ) ) show = TRUE ; if ( show && ( visibleChild == - 1 ) ) { visibleChild = 0 ; struct slRef * childRef ; for ( childRef = tdb -> children ; childRef != NULL ; childRef = childRef -> next ) { struct trackDb * cTdb = childRef -> val ; cTdb -> visibility = hTvFromString ( cartUsualString ( cart , cTdb -> track , hStringFromTv ( cTdb -> visibility ) ) ) ; if ( cTdb -> visibility != tvHide ) visibleChild = 1 ; } } <S2SV_StartBug> hideShowDropDownWithClassAndExtra ( tdb -> track , show , ( show && visibleChild ) ? <S2SV_EndBug> "normalText<S2SV_blank>visDD" : "hiddenText<S2SV_blank>visDD" , events ) ; return TRUE ; } | <S2SV_ModStart> -> track , NULL , |
4,273 | CWE-000 int usage ( void ) { printf ( "locktest<S2SV_blank>-n<S2SV_blank><number<S2SV_blank>of<S2SV_blank>process><S2SV_blank>-f<S2SV_blank><test<S2SV_blank>file><S2SV_blank>[-T]\\n" ) ; printf ( "Number<S2SV_blank>of<S2SV_blank>child<S2SV_blank>process<S2SV_blank>must<S2SV_blank>be<S2SV_blank>higher<S2SV_blank>than<S2SV_blank>1\\n" ) ; <S2SV_StartBug> printf ( "\\n" ) ; <S2SV_EndBug> printf ( "Send<S2SV_blank>bugs<S2SV_blank>to<S2SV_blank>vincent.roqueta@ext.bull.net\\n" ) ; exit ( 0 ) ; return 0 ; } | <S2SV_ModStart> "Number<S2SV_blank>of<S2SV_blank>child<S2SV_blank>process<S2SV_blank>must<S2SV_blank>be<S2SV_blank>higher<S2SV_blank>than<S2SV_blank>1\\n" ) ; <S2SV_ModEnd> exit ( 0 |
4,274 | CWE-000 int openFile ( FILE * * file , char * option ) { char opt [ 4 ] = "0" ; if ( ! isTextFile ( ) ) sprintf ( opt , "%sb" , option ) ; <S2SV_StartBug> * file = fopen ( filename , opt ) ; <S2SV_EndBug> if ( ! * file ) return - 1 ; return 0 ; } | <S2SV_ModStart> ( filename , option <S2SV_ModEnd> ) ; if |
4,275 | CWE-000 void log_backend_enable ( struct log_backend const * const backend , void * ctx , u32_t level ) <S2SV_StartBug> { <S2SV_EndBug> backend_filter_set ( backend , level ) ; log_backend_activate ( backend , ctx ) ; backend_attached = true ; } | <S2SV_ModStart> level ) { u32_t id = LOG_FILTER_FIRST_BACKEND_SLOT_IDX ; id += backend - log_backend_get ( 0 ) ; log_backend_id_set ( backend , id ) ; |
4,276 | CWE-000 int btrfs_grow_device ( struct btrfs_trans_handle * trans , struct btrfs_device * device , u64 new_size ) { struct btrfs_fs_info * fs_info = device -> fs_info ; struct btrfs_super_block * super_copy = fs_info -> super_copy ; struct btrfs_fs_devices * fs_devices ; u64 old_total ; u64 diff ; if ( ! device -> writeable ) return - EACCES ; new_size = round_down ( new_size , fs_info -> sectorsize ) ; mutex_lock ( & fs_info -> chunk_mutex ) ; old_total = btrfs_super_total_bytes ( super_copy ) ; <S2SV_StartBug> diff = new_size - device -> total_bytes ; <S2SV_EndBug> if ( new_size <= device -> total_bytes || device -> is_tgtdev_for_dev_replace ) { mutex_unlock ( & fs_info -> chunk_mutex ) ; return - EINVAL ; } fs_devices = fs_info -> fs_devices ; btrfs_set_super_total_bytes ( super_copy , round_down ( old_total + diff , fs_info -> sectorsize ) ) ; device -> fs_devices -> total_rw_bytes += diff ; btrfs_device_set_total_bytes ( device , new_size ) ; btrfs_device_set_disk_total_bytes ( device , new_size ) ; btrfs_clear_space_info_full ( device -> fs_info ) ; if ( list_empty ( & device -> resized_list ) ) list_add_tail ( & device -> resized_list , & fs_devices -> resized_devices ) ; mutex_unlock ( & fs_info -> chunk_mutex ) ; return btrfs_update_device ( trans , device ) ; } | <S2SV_ModStart> ; diff = round_down ( <S2SV_ModStart> device -> total_bytes , fs_info -> sectorsize ) |
4,277 | CWE-000 int processMultibulkBuffer ( client * c ) { char * newline = NULL ; int pos = 0 , ok ; long long ll ; if ( c -> multibulklen == 0 ) { serverAssertWithInfo ( c , NULL , c -> argc == 0 ) ; newline = strchr ( c -> querybuf , '\\r' ) ; if ( newline == NULL ) { if ( sdslen ( c -> querybuf ) > PROTO_INLINE_MAX_SIZE ) { addReplyError ( c , "Protocol<S2SV_blank>error:<S2SV_blank>too<S2SV_blank>big<S2SV_blank>mbulk<S2SV_blank>count<S2SV_blank>string" ) ; setProtocolError ( "too<S2SV_blank>big<S2SV_blank>mbulk<S2SV_blank>count<S2SV_blank>string" , c , 0 ) ; } return C_ERR ; } if ( newline - ( c -> querybuf ) > ( ( signed ) sdslen ( c -> querybuf ) - 2 ) ) return C_ERR ; serverAssertWithInfo ( c , NULL , c -> querybuf [ 0 ] == '*' ) ; ok = string2ll ( c -> querybuf + 1 , newline - ( c -> querybuf + 1 ) , & ll ) ; if ( ! ok || ll > 1024 * 1024 ) { addReplyError ( c , "Protocol<S2SV_blank>error:<S2SV_blank>invalid<S2SV_blank>multibulk<S2SV_blank>length" ) ; setProtocolError ( "invalid<S2SV_blank>mbulk<S2SV_blank>count" , c , pos ) ; return C_ERR ; } pos = ( newline - c -> querybuf ) + 2 ; if ( ll <= 0 ) { sdsrange ( c -> querybuf , pos , - 1 ) ; return C_OK ; } c -> multibulklen = ll ; if ( c -> argv ) zfree ( c -> argv ) ; c -> argv = zmalloc ( sizeof ( robj * ) * c -> multibulklen ) ; } serverAssertWithInfo ( c , NULL , c -> multibulklen > 0 ) ; while ( c -> multibulklen ) { if ( c -> bulklen == - 1 ) { newline = strchr ( c -> querybuf + pos , '\\r' ) ; if ( newline == NULL ) { if ( sdslen ( c -> querybuf ) > PROTO_INLINE_MAX_SIZE ) { addReplyError ( c , "Protocol<S2SV_blank>error:<S2SV_blank>too<S2SV_blank>big<S2SV_blank>bulk<S2SV_blank>count<S2SV_blank>string" ) ; setProtocolError ( "too<S2SV_blank>big<S2SV_blank>bulk<S2SV_blank>count<S2SV_blank>string" , c , 0 ) ; return C_ERR ; } break ; } if ( newline - ( c -> querybuf ) > ( ( signed ) sdslen ( c -> querybuf ) - 2 ) ) break ; if ( c -> querybuf [ pos ] != '$' ) { addReplyErrorFormat ( c , "Protocol<S2SV_blank>error:<S2SV_blank>expected<S2SV_blank>\'$\',<S2SV_blank>got<S2SV_blank>\'%c\'" , c -> querybuf [ pos ] ) ; setProtocolError ( "expected<S2SV_blank>$<S2SV_blank>but<S2SV_blank>got<S2SV_blank>something<S2SV_blank>else" , c , pos ) ; return C_ERR ; } ok = string2ll ( c -> querybuf + pos + 1 , newline - ( c -> querybuf + pos + 1 ) , & ll ) ; if ( ! ok || ll < 0 || ll > 512 * 1024 * 1024 ) { addReplyError ( c , "Protocol<S2SV_blank>error:<S2SV_blank>invalid<S2SV_blank>bulk<S2SV_blank>length" ) ; setProtocolError ( "invalid<S2SV_blank>bulk<S2SV_blank>length" , c , pos ) ; return C_ERR ; } pos += newline - ( c -> querybuf + pos ) + 2 ; if ( ll >= PROTO_MBULK_BIG_ARG ) { size_t qblen ; sdsrange ( c -> querybuf , pos , - 1 ) ; pos = 0 ; qblen = sdslen ( c -> querybuf ) ; if ( qblen < ( size_t ) ll + 2 ) c -> querybuf = sdsMakeRoomFor ( c -> querybuf , ll + 2 - qblen ) ; } c -> bulklen = ll ; } if ( sdslen ( c -> querybuf ) - pos < ( unsigned ) ( c -> bulklen + 2 ) ) { break ; } else { if ( pos == 0 && c -> bulklen >= PROTO_MBULK_BIG_ARG && ( signed ) sdslen ( c -> querybuf ) == c -> bulklen + 2 ) { c -> argv [ c -> argc ++ ] = createObject ( OBJ_STRING , c -> querybuf ) ; sdsIncrLen ( c -> querybuf , - 2 ) ; <S2SV_StartBug> c -> querybuf = sdsnewlen ( NULL , c -> bulklen + 2 ) ; <S2SV_EndBug> sdsclear ( c -> querybuf ) ; pos = 0 ; } else { c -> argv [ c -> argc ++ ] = createStringObject ( c -> querybuf + pos , c -> bulklen ) ; pos += c -> bulklen + 2 ; } c -> bulklen = - 1 ; c -> multibulklen -- ; } } if ( pos ) sdsrange ( c -> querybuf , pos , - 1 ) ; if ( c -> multibulklen == 0 ) return C_OK ; return C_ERR ; } | <S2SV_ModStart> = sdsnewlen ( SDS_NOINIT <S2SV_ModEnd> , c -> |
4,278 | CWE-000 int ide_host_register ( struct ide_host * host , const struct ide_port_info * d , struct ide_hw * * hws ) { ide_hwif_t * hwif , * mate = NULL ; int i , j = 0 ; ide_host_for_each_port ( i , hwif , host ) { if ( hwif == NULL ) { mate = NULL ; continue ; } ide_init_port_hw ( hwif , hws [ i ] ) ; ide_port_apply_params ( hwif ) ; if ( ( i & 1 ) && mate ) { hwif -> mate = mate ; mate -> mate = hwif ; } mate = ( i & 1 ) ? NULL : hwif ; ide_init_port ( hwif , i & 1 , d ) ; ide_port_cable_detect ( hwif ) ; hwif -> port_flags |= IDE_PFLAG_PROBING ; ide_port_init_devices ( hwif ) ; } ide_host_for_each_port ( i , hwif , host ) { if ( hwif == NULL ) continue ; if ( ide_probe_port ( hwif ) == 0 ) hwif -> present = 1 ; hwif -> port_flags &= ~ IDE_PFLAG_PROBING ; if ( ( hwif -> host_flags & IDE_HFLAG_4DRIVES ) == 0 || hwif -> mate == NULL || hwif -> mate -> present == 0 ) { if ( ide_register_port ( hwif ) ) { ide_disable_port ( hwif ) ; continue ; } } if ( hwif -> present ) ide_port_tune_devices ( hwif ) ; } ide_host_enable_irqs ( host ) ; ide_host_for_each_port ( i , hwif , host ) { if ( hwif == NULL ) continue ; if ( hwif_init ( hwif ) == 0 ) { printk ( KERN_INFO "%s:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>IDE<S2SV_blank>" "interface\\n" , hwif -> name ) ; <S2SV_StartBug> device_unregister ( & hwif -> gendev ) ; <S2SV_EndBug> ide_disable_port ( hwif ) ; continue ; } if ( hwif -> present ) if ( ide_port_setup_devices ( hwif ) == 0 ) { hwif -> present = 0 ; continue ; } j ++ ; ide_acpi_init_port ( hwif ) ; if ( hwif -> present ) ide_acpi_port_init_devices ( hwif ) ; } ide_host_for_each_port ( i , hwif , host ) { if ( hwif == NULL ) continue ; ide_sysfs_register_port ( hwif ) ; ide_proc_register_port ( hwif ) ; if ( hwif -> present ) { ide_proc_port_register_devices ( hwif ) ; hwif_register_devices ( hwif ) ; } } return j ? 0 : - 1 ; } | <S2SV_ModStart> ; device_unregister ( hwif -> portdev ) ; device_unregister ( |
4,279 | CWE-000 static void draw_neat_network ( cairo_t * cr , GtkStyleContext * context , size_t network , guint x , guint y , guint width , guint height ) { ( void ) context ; int radius = MIN ( width , height ) / 20 ; int xoffset = width / 10 , yoffset = height / 20 ; if ( worst == network ) { cairo_save ( cr ) ; cairo_rectangle ( cr , x , y , width , height ) ; cairo_set_source_rgb ( cr , 1.0 , 0.5 , 0.5 ) ; cairo_fill ( cr ) ; cairo_restore ( cr ) ; } size_t species = neat_get_species_id ( neat , network ) ; cairo_set_font_size ( cr , 13 ) ; cairo_move_to ( cr , x , y + 13 ) ; char text [ 256 ] ; snprintf ( text , 256 , <S2SV_StartBug> "Species:<S2SV_blank>%d,<S2SV_blank>err:<S2SV_blank>%g" , <S2SV_EndBug> ( int ) species , <S2SV_StartBug> errors [ network ] ) ; <S2SV_EndBug> cairo_show_text ( cr , text ) ; cairo_stroke ( cr ) ; const struct nn_ffnet * n = neat_get_network ( neat , network ) ; float * neuron = n -> output ; float * weight = n -> weight ; char * activation = n -> activation ; x += radius + xoffset ; y += radius + yoffset + 13 ; guint xinc = radius * 2 + xoffset ; guint yinc = radius * 2 + yoffset ; guint starty = y ; size_t layer_count = n -> nhiddens ; if ( n -> nhidden_layers == 0 ) { layer_count = n -> noutputs ; } for ( size_t i = 0 ; i < layer_count ; i ++ ) { for ( size_t j = 0 ; j < n -> ninputs + 1 ; j ++ ) { draw_weight ( cr , x , y + yinc * j , x + xinc , y + yinc * ( i + 1 ) , * weight ++ ) ; } } for ( size_t i = 0 ; i < n -> nhidden_layers ; i ++ ) { layer_count = n -> nhiddens ; if ( i == n -> nhidden_layers - 1 ) { layer_count = n -> noutputs ; } for ( size_t j = 0 ; j < layer_count ; j ++ ) { for ( size_t k = 0 ; k < n -> nhiddens + 1 ; k ++ ) { draw_weight ( cr , x + xinc * ( i + 1 ) , y + yinc * k , x + xinc * ( i + 2 ) , y + yinc * ( j + 1 ) , * weight ++ ) ; } } } draw_neuron ( cr , x , y , radius , n -> bias , true , 0 ) ; y += yinc ; for ( size_t i = 0 ; i < n -> ninputs ; i ++ ) { draw_neuron ( cr , x , y , radius , * neuron ++ , false , 0 ) ; y += yinc ; } x += xinc ; y = starty ; for ( size_t i = 0 ; i < n -> nhidden_layers ; i ++ ) { draw_neuron ( cr , x , y , radius , n -> bias , true , 0 ) ; y += yinc ; for ( size_t j = 0 ; j < n -> nhiddens ; j ++ ) { draw_neuron ( cr , x , y , radius , * neuron ++ , false , * activation ++ ) ; y += yinc ; } x += xinc ; y = starty ; } for ( size_t i = 0 ; i < n -> noutputs ; i ++ ) { y += yinc ; draw_neuron ( cr , x , y , radius , * neuron ++ , false , * activation ++ ) ; } } | <S2SV_ModStart> , 256 , "Species:<S2SV_blank>%d,<S2SV_blank>fitness:<S2SV_blank>%g" <S2SV_ModEnd> , ( int <S2SV_ModStart> ) species , fitnesses <S2SV_ModEnd> [ network ] |
4,280 | CWE-000 void loop_terminal ( ) { shell_instance_cnt += 1 ; if ( skip_prints == false ) { if ( shell_instance_cnt != 1 ) printk ( "Shell<S2SV_blank>#%d\\n" , shell_instance_cnt ) ; printk ( "%s<S2SV_blank>release<S2SV_blank>%s<S2SV_blank>started<S2SV_blank>at<S2SV_blank>" , VAR_OSNAME , VAR_RELEASE ) ; start_time = rtc_get_time ( ) ; rtc_print_struct ( start_time ) ; } else { } <S2SV_StartBug> while ( 1 ) <S2SV_EndBug> { start_shell : ; if ( exit_set__shell == true ) { exit_set__shell = false ; goto end_shell ; } int FG__ = video_drivers [ VGA_VIDEO_DRIVER_INDEX ] -> fg ; int BG__ = video_drivers [ VGA_VIDEO_DRIVER_INDEX ] -> bg ; if ( video_drivers [ VGA_VIDEO_DRIVER_INDEX ] -> fg == 0x7 && video_drivers [ VGA_VIDEO_DRIVER_INDEX ] -> bg == 0x0 ) { printck ( 2 , 0 , "%s@boneos:" , VAR_USER ) ; printck ( 1 , 0 , "%s" , VAR_PWD ) ; printck ( 0x0 , 0x7 , "" ) ; printck ( 0x7 , 0x0 , "<S2SV_blank>$<S2SV_blank>" ) ; } else { printk ( "%s@boneos:" , VAR_USER ) ; printk ( "%s" , VAR_PWD ) ; printk ( "<S2SV_blank>$<S2SV_blank>" ) ; } video_drivers [ VGA_VIDEO_DRIVER_INDEX ] -> fg = FG__ ; video_drivers [ VGA_VIDEO_DRIVER_INDEX ] -> bg = BG__ ; virtual_cursor_pos = 0 ; virtual_index_scank = 0 ; scank ( true , true , "%s" , cmd_active . value ) ; if ( tab_multiple_opts == true ) { tab_multiple_opts = false ; goto start_shell ; } else if ( tab_one_opt == true ) { tab_one_opt = false ; strcpy ( cmd_active . value , tab__ ) ; executed_internally = true ; removeSpaces ( cmd_active . value ) ; } else if ( tab_zero_opt == true ) { key_handler_util_backspace ( ) ; tab_zero_opt = false ; scank ( true , true , "%s" , cmd_active . value + ( strlen ( cmd_active . value ) ) ) ; } if ( strcmp ( cmd_active . value , "exit" ) == 0 || exit_set__shell == true ) { shell_instance_cnt -- ; exit_set__shell = false ; strcpy ( cmd_active . value , "<S2SV_blank>" ) ; printk ( "Exited<S2SV_blank>shell<S2SV_blank>instance<S2SV_blank>#%d\\n" , shell_instance_cnt + 1 ) ; goto end_shell ; } if ( new_set__shell == true ) { new_set__shell = false ; loop_terminal ( ) ; goto start_shell ; } for ( int i = 0 ; cmds [ i ] ; i ++ ) { if ( termcmp ( cmds [ i ] -> name , cmd_active . value ) == 0 ) { if ( executed_internally == true ) { executed_internally = false ; } cmds [ i ] -> handler ( cmd_active . value ) ; __found = 1 ; } } if ( __found == 0 && cmd_active . value [ 0 ] != '\\0' ) { printk ( "Invalid<S2SV_blank>Command<S2SV_blank>\'%s\'<S2SV_blank>\\n" , cmd_active . value ) ; printk ( "Try<S2SV_blank>\'help\'<S2SV_blank>for<S2SV_blank>more<S2SV_blank>information.\\n" ) ; } __found = 0 ; cmd_active_index ++ ; } end_shell : ; } | <S2SV_ModStart> else { } for ( total_cmd = 0 ; cmds [ total_cmd ] ; total_cmd ++ ) ; |
4,281 | CWE-000 CC_NOINLINE static void LScreen_Reset ( struct LScreen * s ) { int i ; s -> Init = NULL ; s -> Free = LScreen_NullFunc ; s -> DrawAll = LScreen_DrawAll ; s -> Tick = LScreen_NullFunc ; <S2SV_StartBug> s -> OnDisplay = LScreen_NullFunc ; <S2SV_EndBug> s -> HoverWidget = LScreen_HoverWidget ; s -> UnhoverWidget = LScreen_UnhoverWidget ; for ( i = 0 ; i < s -> NumWidgets ; i ++ ) { s -> Widgets [ i ] -> Hovered = false ; s -> Widgets [ i ] -> Selected = false ; } s -> OnEnterWidget = NULL ; s -> HoveredWidget = NULL ; } | <S2SV_ModStart> OnDisplay = LScreen_NullFunc ; s -> KeyDown = LScreen_KeyDown ; s -> MouseDown = LScreen_MouseDown ; s -> MouseMove = LScreen_MouseMove |
4,282 | CWE-000 static struct cache_tree_sub * find_subtree ( struct cache_tree * it , const char * path , int pathlen , int create ) { struct cache_tree_sub * down ; int pos = subtree_pos ( it , path , pathlen ) ; if ( 0 <= pos ) return it -> down [ pos ] ; if ( ! create ) return NULL ; pos = - pos - 1 ; ALLOC_GROW ( it -> down , it -> subtree_nr + 1 , it -> subtree_alloc ) ; it -> subtree_nr ++ ; FLEX_ALLOC_MEM ( down , name , path , pathlen ) ; down -> cache_tree = NULL ; down -> namelen = pathlen ; if ( pos < it -> subtree_nr ) <S2SV_StartBug> memmove ( it -> down + pos + 1 , <S2SV_EndBug> it -> down + pos , <S2SV_StartBug> sizeof ( down ) * ( it -> subtree_nr - pos - 1 ) ) ; <S2SV_EndBug> it -> down [ pos ] = down ; return down ; } | <S2SV_ModStart> -> subtree_nr ) MOVE_ARRAY <S2SV_ModEnd> ( it -> <S2SV_ModStart> + pos , <S2SV_ModEnd> it -> subtree_nr <S2SV_ModStart> pos - 1 <S2SV_ModEnd> ) ; it |
4,283 | CWE-000 void press_launch ( struct nk_context * ctx , t_world * world , int img_active [ 5 ] ) { <S2SV_StartBug> if ( nk_button_label ( ctx , "Launch" ) ) <S2SV_EndBug> { if ( img_active [ 2 ] == 1 ) launch_scene_select ( world , 1 ) ; else if ( img_active [ 2 ] == 2 ) launch_scene_select ( world , 2 ) ; else if ( img_active [ 2 ] == 3 ) launch_scene_select ( world , 3 ) ; else if ( img_active [ 2 ] == 4 ) launch_scene_select ( world , 4 ) ; else if ( img_active [ 2 ] == 5 ) launch_scene_select ( world , 5 ) ; else if ( img_active [ 2 ] == 6 ) launch_scene_select ( world , 6 ) ; else if ( img_active [ 2 ] == 7 ) launch_scene_select ( world , 7 ) ; else if ( img_active [ 2 ] == 8 ) launch_scene_select ( world , 8 ) ; img_active [ 0 ] = 0 ; img_active [ 1 ] = 0 ; nk_popup_close ( ctx ) ; } } | <S2SV_ModStart> , "Launch" ) && world -> render_factor == 1 |
4,284 | CWE-000 int main ( void ) { int i ; <S2SV_StartBug> for ( i = 0 ; i <= 100 ; i ++ ) <S2SV_EndBug> { if ( ( i % 3 ) == 0 && ( i % 5 ) == 0 ) printf ( "FizzBuzz" ) ; else if ( ( i % 3 ) == 0 ) printf ( "Fizz" ) ; else if ( ( i % 5 ) == 0 ) printf ( "Buzz" ) ; else <S2SV_StartBug> printf ( "%i" , i ) ; <S2SV_EndBug> if ( i != 100 ) printf ( "<S2SV_blank>" ) ; } printf ( "\\n" ) ; return ( 0 ) ; } | <S2SV_ModStart> ( i = 1 <S2SV_ModEnd> ; i <= <S2SV_ModStart> else printf ( "%d" <S2SV_ModEnd> , i ) |
4,285 | CWE-000 abd_t * abd_alloc_sametype ( abd_t * sabd , size_t size ) <S2SV_StartBug> { <S2SV_EndBug> boolean_t is_metadata = ( sabd -> abd_flags & ABD_FLAG_META ) != 0 ; if ( abd_is_linear ( sabd ) ) { return ( abd_alloc_linear ( size , is_metadata ) ) ; } else { return ( abd_alloc ( size , is_metadata ) ) ; } } | <S2SV_ModStart> size ) { VERIFY_ABD_MAGIC ( sabd ) ; |
4,286 | CWE-000 static inline void peer_cache_cleaner ( void ) { unsigned short i ; struct natcap_session * ns ; <S2SV_StartBug> if ( peer_cache [ peer_cache_index_first ] . user == NULL || ! time_after ( jiffies , peer_cache [ peer_cache_index_first ] . jiffies + 8 * HZ ) ) <S2SV_EndBug> return ; spin_lock_bh ( & peer_cache_lock ) ; <S2SV_StartBug> i = peer_cache_index_first ; <S2SV_EndBug> <S2SV_StartBug> while ( peer_cache [ i ] . user != NULL ) { <S2SV_EndBug> <S2SV_StartBug> if ( ! time_after ( jiffies , peer_cache [ i ] . jiffies + 8 * HZ ) ) <S2SV_EndBug> break ; ns = natcap_session_get ( peer_cache [ i ] . user ) ; ns -> p . cache_index = 0 ; nf_ct_put ( peer_cache [ i ] . user ) ; peer_cache [ i ] . user = NULL ; if ( peer_cache [ i ] . skb != NULL ) { consume_skb ( peer_cache [ i ] . skb ) ; peer_cache [ i ] . skb = NULL ; } i = ( i + 1 ) % MAX_PEER_CACHE ; <S2SV_StartBug> if ( i == peer_cache_index_first ) <S2SV_EndBug> break ; } peer_cache_index_first = i ; spin_unlock_bh ( & peer_cache_lock ) ; } | <S2SV_ModStart> ( peer_cache [ peer_cache_next_to_clean ] . user != NULL && <S2SV_ModEnd> ! time_after ( <S2SV_ModStart> , peer_cache [ peer_cache_next_to_clean ] . jiffies + PEER_CACHE_TIMEOUT <S2SV_ModEnd> * HZ ) <S2SV_ModStart> ; i = peer_cache_next_to_clean <S2SV_ModEnd> ; while ( <S2SV_ModStart> ; while ( i != peer_cache_next_to_use ) { if ( peer_cache [ i ] . user == NULL ) { i = ( i + 1 ) % MAX_PEER_CACHE ; continue ; } <S2SV_ModEnd> if ( ! <S2SV_ModStart> . jiffies + PEER_CACHE_TIMEOUT <S2SV_ModEnd> * HZ ) <S2SV_ModStart> % MAX_PEER_CACHE ; } peer_cache_next_to_clean <S2SV_ModEnd> = i ; |
4,287 | CWE-000 static int ioctl_wdev_set_oldest_lsid ( struct walb_dev * wdev , struct walb_ctl * ctl ) { u64 lsid , oldest_lsid , prev_written_lsid ; bool is_valid ; LOGd ( "WALB_IOCTL_SET_OLDEST_LSID_SET\\n" ) ; lsid = ctl -> val_u64 ; spin_lock ( & wdev -> lsid_lock ) ; prev_written_lsid = wdev -> lsids . prev_written ; oldest_lsid = wdev -> lsids . oldest ; spin_unlock ( & wdev -> lsid_lock ) ; is_valid = lsid == prev_written_lsid ; if ( ! is_valid ) is_valid = oldest_lsid <= lsid && lsid < prev_written_lsid && walb_check_lsid_valid ( wdev , lsid ) ; if ( ! is_valid ) { LOGe ( "lsid<S2SV_blank>%" PRIu64 "<S2SV_blank>is<S2SV_blank>not<S2SV_blank>valid.\\n" , lsid ) ; LOGe ( "You<S2SV_blank>shoud<S2SV_blank>specify<S2SV_blank>valid<S2SV_blank>logpack<S2SV_blank>header<S2SV_blank>lsid" "<S2SV_blank>(oldest_lsid<S2SV_blank>(%" PRIu64 ")<S2SV_blank><=<S2SV_blank>lsid<S2SV_blank><=<S2SV_blank>prev_written_lsid<S2SV_blank>(%" PRIu64 ").\\n" , oldest_lsid , prev_written_lsid ) ; return - EFAULT ; } spin_lock ( & wdev -> lsid_lock ) ; wdev -> lsids . oldest = lsid ; spin_unlock ( & wdev -> lsid_lock ) ; <S2SV_StartBug> if ( ! walb_sync_super_block ( wdev ) ) { <S2SV_EndBug> LOGe ( "sync<S2SV_blank>super<S2SV_blank>block<S2SV_blank>failed.\\n" ) ; return - EFAULT ; <S2SV_StartBug> } <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> wdev ) ) <S2SV_ModEnd> return - EFAULT <S2SV_ModStart> - EFAULT ; <S2SV_ModEnd> return 0 ; |
4,288 | CWE-000 <S2SV_StartBug> int readFromDevice ( struct file * , char * , size_t , loff_t * ) <S2SV_EndBug> { } | <S2SV_ModStart> struct file * filp <S2SV_ModStart> , char * buffer , size_t length <S2SV_ModEnd> , loff_t * <S2SV_ModStart> , loff_t * offset ) { return 0 ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
4,289 | CWE-000 int main ( int argc , char * argv [ ] ) { printf ( "***<S2SV_blank>Network<S2SV_blank>Emulator<S2SV_blank>Set<S2SV_blank>***\\n" ) ; if ( argc < 4 ) { printf ( "./set<S2SV_blank>[NODE]<S2SV_blank>[Option[Value]]\\n" ) ; return - 1 ; } printf ( "Node<S2SV_blank>Name:<S2SV_blank>%s\\n" , argv [ 1 ] ) ; char * host = getenv ( "NETEMUL_ADDR" ) ; char * _port = getenv ( "NETEMUL_PORT" ) ; if ( ! host || ! _port ) { printf ( "Error:<S2SV_blank>$<S2SV_blank>source<S2SV_blank>netemul.conf\\n" ) ; exit ( - 1 ) ; } char * next ; uint16_t port = strtol ( _port , & next , 10 ) ; RPC_NetEmulator * rpc = rpc_netemul_open ( host , port , 3 ) ; if ( ! rpc ) { printf ( "Error:<S2SV_blank>NetEmulator<S2SV_blank>Connection<S2SV_blank>fail<S2SV_blank>%s:%s\\n" , host , _port ) ; exit ( - 1 ) ; } bool callback ( bool result , void * context ) { <S2SV_StartBug> printf ( "On<S2SV_blank>%s\\n" , result ? "Success" : "Fail" ) ; <S2SV_EndBug> rpc_netemul_close ( rpc ) ; exit ( 0 ) ; return true ; } rpc_set ( rpc , argv [ 1 ] , argc - 2 , & argv [ 2 ] , callback , NULL ) ; while ( 1 ) rpc_netemul_loop ( rpc ) ; return 0 ; } | <S2SV_ModStart> { printf ( "Set<S2SV_blank>%s\\n" <S2SV_ModEnd> , result ? |
4,290 | CWE-000 void handle_cmd_response ( enum command_response cmd , void * data ) { dprintk ( VIDC_DBG , "Command<S2SV_blank>response<S2SV_blank>=<S2SV_blank>%d\\n" , cmd ) ; switch ( cmd ) { case SYS_INIT_DONE : handle_sys_init_done ( cmd , data ) ; break ; case RELEASE_RESOURCE_DONE : handle_sys_release_res_done ( cmd , data ) ; break ; case SESSION_INIT_DONE : handle_session_init_done ( cmd , data ) ; break ; case SESSION_PROPERTY_INFO : handle_session_prop_info ( cmd , data ) ; break ; case SESSION_LOAD_RESOURCE_DONE : handle_load_resource_done ( cmd , data ) ; break ; case SESSION_START_DONE : handle_start_done ( cmd , data ) ; break ; case SESSION_ETB_DONE : handle_ebd ( cmd , data ) ; break ; case SESSION_FTB_DONE : handle_fbd ( cmd , data ) ; break ; case SESSION_STOP_DONE : handle_stop_done ( cmd , data ) ; break ; case SESSION_RELEASE_RESOURCE_DONE : handle_release_res_done ( cmd , data ) ; break ; case SESSION_END_DONE : case SESSION_ABORT_DONE : handle_session_close ( cmd , data ) ; break ; case VIDC_EVENT_CHANGE : handle_event_change ( cmd , data ) ; break ; case SESSION_FLUSH_DONE : handle_session_flush ( cmd , data ) ; break ; case SESSION_GET_SEQ_HDR_DONE : handle_seq_hdr_done ( cmd , data ) ; break ; case SYS_WATCHDOG_TIMEOUT : <S2SV_StartBug> handle_sys_watchdog_timeout ( cmd , data ) ; <S2SV_EndBug> break ; case SYS_ERROR : handle_sys_error ( cmd , data ) ; break ; case SESSION_ERROR : handle_session_error ( cmd , data ) ; break ; case SESSION_RELEASE_BUFFER_DONE : handle_session_release_buf_done ( cmd , data ) ; break ; default : dprintk ( VIDC_ERR , "response<S2SV_blank>unhandled\\n" ) ; break ; } } | <S2SV_ModStart> case SYS_WATCHDOG_TIMEOUT : handle_sys_error <S2SV_ModEnd> ( cmd , |
4,291 | CWE-000 double findinterplane ( t_ray ray , t_plane plane ) { double a ; double b ; a = dot_prod ( ray . dir , plane . norm ) ; if ( a == 0 ) return ( - 1 ) ; else { b = dot_prod ( plane . norm , add_vert ( ray . origin , invert ( mult_vert ( plane . norm , plane . dist ) ) ) ) ; <S2SV_StartBug> return ( - 1 * b / a ) ; <S2SV_EndBug> } } | <S2SV_ModStart> return ( - <S2SV_ModEnd> b / a |
4,292 | CWE-000 static int run_worker ( uv_loop_t * loop , struct engine * engine , fd_array_t * ipc_set , bool leader , int control_fd ) { auto_free char * sock_file = NULL ; uv_pipe_t pipe ; uv_pipe_init ( loop , & pipe , 0 ) ; pipe . data = engine ; if ( g_interactive ) { if ( ! g_quiet ) printf ( "[system]<S2SV_blank>interactive<S2SV_blank>mode\\n><S2SV_blank>" ) ; fflush ( stdout ) ; uv_pipe_open ( & pipe , 0 ) ; uv_read_start ( ( uv_stream_t * ) & pipe , tty_alloc , tty_read ) ; } else { int pipe_ret = - 1 ; if ( control_fd != - 1 ) { pipe_ret = uv_pipe_open ( & pipe , control_fd ) ; } else { ( void ) mkdir ( "tty" , S_IRWXU | S_IRWXG ) ; sock_file = afmt ( "tty/%ld" , getpid ( ) ) ; if ( sock_file ) { pipe_ret = uv_pipe_bind ( & pipe , sock_file ) ; } } if ( ! pipe_ret ) uv_listen ( ( uv_stream_t * ) & pipe , 16 , tty_accept ) ; } if ( ! leader ) { for ( size_t i = 0 ; i < ipc_set -> len ; ++ i ) { if ( ! ipc_watch ( loop , engine , ipc_set -> at [ i ] ) ) { kr_log_error ( "[system]<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>poller:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; close ( ipc_set -> at [ i ] ) ; } } } memcpy ( & engine -> ipc_set , ipc_set , sizeof ( * ipc_set ) ) ; <S2SV_StartBug> tls_setup_logging ( kr_debug_status ( ) ) ; <S2SV_EndBug> # ifdef HAS_SYSTEMD sd_notify ( 0 , "READY=1" ) ; # endif uv_run ( loop , UV_RUN_DEFAULT ) ; if ( sock_file ) { unlink ( sock_file ) ; } return kr_ok ( ) ; } | <S2SV_ModStart> ; tls_setup_logging ( kr_verbose_status <S2SV_ModEnd> ) ; # |
4,293 | CWE-000 static void <S2SV_StartBug> ssse3_test_pabsw ( int * i1 , int * r ) <S2SV_EndBug> { <S2SV_StartBug> __m64 t1 = * ( __m64 * ) i1 ; <S2SV_EndBug> <S2SV_StartBug> * ( __m64 * ) r = _mm_abs_pi16 ( t1 ) ; <S2SV_EndBug> _mm_empty ( ) ; } | <S2SV_ModStart> void ssse3_test_pabsw ( __m64 <S2SV_ModEnd> * i1 , <S2SV_ModStart> * i1 , __m64 <S2SV_ModEnd> * r ) <S2SV_ModStart> r ) { * <S2SV_ModEnd> r = _mm_abs_pi16 <S2SV_ModStart> = _mm_abs_pi16 ( * i1 <S2SV_ModEnd> ) ; _mm_empty |
4,294 | CWE-000 rage_ElementTypes * rage_element_loader_list ( rage_ElementLoader * el ) { rage_ElementTypes * elems = malloc ( sizeof ( rage_ElementTypes ) ) ; <S2SV_StartBug> elems -> len = 0 ; <S2SV_EndBug> char const * rage_elements_path = getenv ( "RAGE_ELEMENTS_PATH" ) ; if ( rage_elements_path == NULL ) { return elems ; } struct dirent * * entries ; int n_items = scandir ( rage_elements_path , & entries , is_plugin , NULL ) ; if ( n_items >= 0 ) { elems -> len = n_items ; elems -> items = calloc ( n_items , sizeof ( char * ) ) ; for ( uint32_t i = 0 ; i < n_items ; i ++ ) { elems -> items [ i ] = strdup ( entries [ i ] -> d_name ) ; free ( entries [ i ] ) ; } free ( entries ) ; } else { <S2SV_StartBug> elems -> items = NULL ; <S2SV_EndBug> } return elems ; } | <S2SV_ModStart> len = 0 ; elems -> items = NULL <S2SV_ModStart> } else { <S2SV_ModEnd> } return elems |
4,295 | CWE-000 strong_alias ( __ieee754_j0f , __j0f_finite ) static const float u00 = - 7.3804296553e-02 , u01 = 1.7666645348e-01 , u02 = - 1.3818567619e-02 , u03 = 3.4745343146e-04 , u04 = - 3.8140706238e-06 , u05 = 1.9559013964e-08 , u06 = - 3.9820518410e-11 , v01 = 1.2730483897e-02 , v02 = 7.6006865129e-05 , v03 = 2.5915085189e-07 , v04 = 4.4111031494e-10 ; float __ieee754_y0f ( float x ) { float z , s , c , ss , cc , u , v ; int32_t hx , ix ; GET_FLOAT_WORD ( hx , x ) ; ix = 0x7fffffff & hx ; if ( ix >= 0x7f800000 ) return one / ( x + x * x ) ; <S2SV_StartBug> if ( ix == 0 ) return - HUGE_VALF + x ; <S2SV_EndBug> if ( hx < 0 ) return zero / ( zero * x ) ; if ( ix >= 0x40000000 ) { __sincosf ( x , & s , & c ) ; ss = s - c ; cc = s + c ; if ( ix < 0x7f000000 ) { z = - __cosf ( x + x ) ; if ( ( s * c ) < zero ) cc = z / ss ; else ss = z / cc ; } if ( ix > 0x48000000 ) z = ( invsqrtpi * ss ) / __ieee754_sqrtf ( x ) ; else { u = pzerof ( x ) ; v = qzerof ( x ) ; z = invsqrtpi * ( u * ss + v * cc ) / __ieee754_sqrtf ( x ) ; } return z ; } if ( ix <= 0x39800000 ) { return ( u00 + tpi * __ieee754_logf ( x ) ) ; } z = x * x ; u = u00 + z * ( u01 + z * ( u02 + z * ( u03 + z * ( u04 + z * ( u05 + z * u06 ) ) ) ) ) ; v = one + z * ( v01 + z * ( v02 + z * ( v03 + z * v04 ) ) ) ; return ( u / v + tpi * ( __ieee754_j0f ( x ) * __ieee754_logf ( x ) ) ) ; } | <S2SV_ModStart> ) return - 1 / zero <S2SV_ModEnd> ; if ( |
4,296 | CWE-000 int main ( int argc , char * argv [ ] ) { MPI_Init ( & argc , & argv ) ; int mpi_size ; int mpi_rank ; MPI_Comm_rank ( MPI_COMM_WORLD , & mpi_rank ) ; MPI_Comm_size ( MPI_COMM_WORLD , & mpi_size ) ; if ( argc != 2 ) { printf ( "Syntax:<S2SV_blank>%s<S2SV_blank>SIZE" , argv [ 0 ] ) ; printf ( "\\t<S2SV_blank>SIZE<S2SV_blank>specifies<S2SV_blank>one<S2SV_blank>dimension<S2SV_blank>of<S2SV_blank>a<S2SV_blank>2D<S2SV_blank>field\\n" ) ; exit ( 1 ) ; } <S2SV_StartBug> const long size = atol ( argv [ 1 ] ) ; <S2SV_EndBug> if ( mpi_rank == 0 ) printf ( "Running<S2SV_blank>with<S2SV_blank>a<S2SV_blank>2D<S2SV_blank>slice<S2SV_blank>of<S2SV_blank>%ld*%ld\\n" , size , size ) ; int64_t dim [ ] = { size / mpi_size + ( mpi_rank < ( size % mpi_size ) ? 1 : 0 ) , size } ; int64_t offset [ ] = { size / mpi_size * mpi_rank + ( mpi_rank < ( size % mpi_size ) ? mpi_rank : size % mpi_size ) , 0 } ; const long volume = dim [ 0 ] * dim [ 1 ] * sizeof ( uint64_t ) ; const long volume_all = size * size * sizeof ( uint64_t ) ; uint64_t * buf_w = ( uint64_t * ) malloc ( volume ) ; <S2SV_StartBug> uint64_t * buf_r = ( uint64_t * ) malloc ( volume ) ; <S2SV_EndBug> for ( int y = offset [ 0 ] ; y < dim [ 0 ] ; y ++ ) { for ( int x = offset [ 1 ] ; x < dim [ 1 ] ; x ++ ) { buf_w [ ( y - offset [ 0 ] ) * size + x ] = y * size + x + 1 ; } } esdm_status_t ret ; esdm_container_t * container = NULL ; esdm_dataset_t * dataset = NULL ; esdm_init ( ) ; int64_t bounds [ ] = { size , size } ; esdm_dataspace_t * dataspace = esdm_dataspace_create ( 2 , bounds , esdm_uint64_t ) ; container = esdm_container_create ( "mycontainer" ) ; dataset = esdm_dataset_create ( container , "mydataset" , dataspace ) ; esdm_container_commit ( container ) ; esdm_dataset_commit ( dataset ) ; esdm_dataspace_t * subspace = esdm_dataspace_subspace ( dataspace , 2 , dim , offset ) ; timer t ; MPI_Barrier ( MPI_COMM_WORLD ) ; start_timer ( & t ) ; ret = esdm_write ( dataset , buf_w , subspace ) ; assert ( ret == ESDM_SUCCESS ) ; MPI_Barrier ( MPI_COMM_WORLD ) ; const double write_time = stop_timer ( t ) ; start_timer ( & t ) ; ret = esdm_read ( dataset , buf_r , subspace ) ; assert ( ret == ESDM_SUCCESS ) ; MPI_Barrier ( MPI_COMM_WORLD ) ; const double read_time = stop_timer ( t ) ; int mismatches = 0 ; int idx ; for ( int y = offset [ 0 ] ; y < dim [ 0 ] ; y ++ ) { for ( int x = offset [ 1 ] ; x < dim [ 1 ] ; x ++ ) { idx = ( y - offset [ 0 ] ) * size + x ; if ( buf_r [ idx ] != buf_w [ idx ] ) { mismatches ++ ; } } } double total_time_w ; double total_time_r ; MPI_Reduce ( & write_time , & total_time_w , 1 , MPI_DOUBLE , MPI_MAX , 0 , MPI_COMM_WORLD ) ; MPI_Reduce ( & read_time , & total_time_r , 1 , MPI_DOUBLE , MPI_MAX , 0 , MPI_COMM_WORLD ) ; int mismatches_sum ; MPI_Reduce ( & mismatches , & mismatches_sum , 1 , MPI_INT , MPI_SUM , 0 , MPI_COMM_WORLD ) ; if ( mpi_rank == 0 ) { if ( mismatches_sum > 0 ) { printf ( "FAILED\\n" ) ; printf ( "Mismatches:<S2SV_blank>%d\\n" , mismatches_sum ) ; } else { printf ( "OK\\n" ) ; } assert ( mismatches_sum == 0 ) ; printf ( "Runtime<S2SV_blank>read,write:<S2SV_blank>%.3f,%.3f\\n" , total_time_r , total_time_w ) ; printf ( "Performance<S2SV_blank>read,write:<S2SV_blank>%.3f<S2SV_blank>MiB/s,%.3f<S2SV_blank>MiB/s\\n" , volume_all / total_time_r / 1024 / 1024 , volume_all / total_time_w / 1024.0 / 1024 ) ; } free ( buf_w ) ; free ( buf_r ) ; MPI_Finalize ( ) ; return 0 ; } | <S2SV_ModStart> ; } const int64_t size = atoll <S2SV_ModEnd> ( argv [ <S2SV_ModStart> malloc ( volume ) ; assert ( buf_w != NULL ) ; assert ( buf_r != NULL |
4,297 | CWE-000 static void vmbus_process_offer ( struct vmbus_channel * newchannel ) { struct vmbus_channel * channel ; bool fnew = true ; unsigned long flags ; u16 dev_type ; int ret ; mutex_lock ( & vmbus_connection . channel_mutex ) ; list_for_each_entry ( channel , & vmbus_connection . chn_list , listentry ) { if ( ! uuid_le_cmp ( channel -> offermsg . offer . if_type , newchannel -> offermsg . offer . if_type ) && ! uuid_le_cmp ( channel -> offermsg . offer . if_instance , newchannel -> offermsg . offer . if_instance ) ) { fnew = false ; break ; } } if ( fnew ) list_add_tail ( & newchannel -> listentry , & vmbus_connection . chn_list ) ; mutex_unlock ( & vmbus_connection . channel_mutex ) ; if ( ! fnew ) { if ( newchannel -> offermsg . offer . sub_channel_index != 0 ) { newchannel -> primary_channel = channel ; spin_lock_irqsave ( & channel -> lock , flags ) ; list_add_tail ( & newchannel -> sc_list , & channel -> sc_list ) ; channel -> num_sc ++ ; spin_unlock_irqrestore ( & channel -> lock , flags ) ; <S2SV_StartBug> } else <S2SV_EndBug> <S2SV_StartBug> goto err_free_chan ; <S2SV_EndBug> } dev_type = hv_get_dev_type ( newchannel ) ; init_vp_index ( newchannel , dev_type ) ; newchannel -> state = CHANNEL_OPEN_STATE ; if ( ! fnew ) { if ( channel -> sc_creation_callback != NULL ) channel -> sc_creation_callback ( newchannel ) ; <S2SV_StartBug> return ; <S2SV_EndBug> } newchannel -> device_obj = vmbus_device_create ( & newchannel -> offermsg . offer . if_type , & newchannel -> offermsg . offer . if_instance , newchannel ) ; if ( ! newchannel -> device_obj ) goto err_deq_chan ; newchannel -> device_obj -> device_id = dev_type ; <S2SV_StartBug> mutex_lock ( & vmbus_connection . channel_mutex ) ; <S2SV_EndBug> <S2SV_StartBug> ret = vmbus_device_register ( newchannel -> device_obj ) ; <S2SV_EndBug> mutex_unlock ( & vmbus_connection . channel_mutex ) ; if ( ret != 0 ) { pr_err ( "unable<S2SV_blank>to<S2SV_blank>add<S2SV_blank>child<S2SV_blank>device<S2SV_blank>object<S2SV_blank>(relid<S2SV_blank>%d)\\n" , newchannel -> offermsg . child_relid ) ; kfree ( newchannel -> device_obj ) ; goto err_deq_chan ; } <S2SV_StartBug> return ; <S2SV_EndBug> err_deq_chan : mutex_lock ( & vmbus_connection . channel_mutex ) ; list_del ( & newchannel -> listentry ) ; mutex_unlock ( & vmbus_connection . channel_mutex ) ; vmbus_release_relid ( newchannel -> offermsg . child_relid ) ; err_free_chan : free_channel ( newchannel ) ; } | <S2SV_ModStart> ; } else { atomic_dec ( & vmbus_connection . offer_in_progress ) ; <S2SV_ModStart> goto err_free_chan ; } <S2SV_ModStart> newchannel ) ; atomic_dec ( & vmbus_connection . offer_in_progress ) ; <S2SV_ModStart> = dev_type ; <S2SV_ModEnd> ret = vmbus_device_register <S2SV_ModStart> newchannel -> device_obj <S2SV_ModEnd> ) ; if <S2SV_ModStart> err_deq_chan ; } atomic_dec ( & vmbus_connection . offer_in_progress ) ; |
4,298 | CWE-000 static int snd_es18xx_playback1_trigger ( struct snd_es18xx * chip , struct snd_pcm_substream * substream , int cmd ) { switch ( cmd ) { case SNDRV_PCM_TRIGGER_START : case SNDRV_PCM_TRIGGER_RESUME : if ( chip -> active & DAC2 ) return 0 ; chip -> active |= DAC2 ; if ( chip -> dma2 >= 4 ) snd_es18xx_mixer_write ( chip , 0x78 , 0xb3 ) ; else snd_es18xx_mixer_write ( chip , 0x78 , 0x93 ) ; # ifdef AVOID_POPS <S2SV_StartBug> udelay ( 100000 ) ; <S2SV_EndBug> if ( chip -> caps & ES18XX_PCM2 ) snd_es18xx_mixer_write ( chip , 0x7C , chip -> audio2_vol ) ; else snd_es18xx_dsp_command ( chip , 0xD1 ) ; # endif break ; case SNDRV_PCM_TRIGGER_STOP : case SNDRV_PCM_TRIGGER_SUSPEND : if ( ! ( chip -> active & DAC2 ) ) return 0 ; chip -> active &= ~ DAC2 ; snd_es18xx_mixer_write ( chip , 0x78 , 0x00 ) ; # ifdef AVOID_POPS <S2SV_StartBug> udelay ( 25000 ) ; <S2SV_EndBug> if ( chip -> caps & ES18XX_PCM2 ) snd_es18xx_mixer_write ( chip , 0x7C , 0 ) ; else snd_es18xx_dsp_command ( chip , 0xD3 ) ; # endif break ; default : return - EINVAL ; } return 0 ; } | <S2SV_ModStart> # ifdef AVOID_POPS mdelay ( 100 <S2SV_ModEnd> ) ; if <S2SV_ModStart> # ifdef AVOID_POPS mdelay ( 25 <S2SV_ModEnd> ) ; if |
4,299 | CWE-000 static void add_slab_mem ( unsigned long base , size_t size ) { int i ; struct slab_pool * pool ; struct slab_header * header ; pr_info ( "add<S2SV_blank>boot_mem-0x%x<S2SV_blank>:<S2SV_blank>0x%x<S2SV_blank>to<S2SV_blank>slab\\n" , base , size ) ; if ( ! ( base & ( MEM_BLOCK_SIZE - 1 ) ) ) pr_warn ( "memory<S2SV_blank>may<S2SV_blank>be<S2SV_blank>a<S2SV_blank>block\\n" ) ; if ( size <= SLAB_SIZE ( 512 ) ) { if ( size < SLAB_SIZE ( SLAB_MIN_DATA_SIZE ) ) { pr_warn ( "drop<S2SV_blank>small<S2SV_blank>slab<S2SV_blank>memory<S2SV_blank>0x%p<S2SV_blank>0x%x\\n" , base , size ) ; return ; } i = size - SLAB_HEADER_SIZE ; <S2SV_StartBug> i &= ( SLAB_MIN_DATA_SIZE - 1 ) ; <S2SV_EndBug> if ( i < SLAB_MIN_DATA_SIZE ) return ; size = i ; i = slab_pool_id ( size ) ; pool = & pslab -> pool [ i ] ; header = ( struct slab_header * ) base ; header -> size = size ; header -> next = NULL ; add_slab_to_slab_pool ( header , pool ) ; return ; } pool = & pslab -> pool [ pslab -> pool_nr - 1 ] ; header = ( struct slab_header * ) base ; header -> size = size - SLAB_HEADER_SIZE ; header -> next = NULL ; add_slab_to_slab_pool ( header , pool ) ; } | <S2SV_ModStart> ; i &= ~ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.