Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
5,300 | CWE-000 static int loopback_open ( struct snd_pcm_substream * substream ) { struct snd_pcm_runtime * runtime = substream -> runtime ; struct loopback * loopback = substream -> private_data ; struct loopback_pcm * dpcm ; <S2SV_StartBug> struct loopback_cable * cable ; <S2SV_EndBug> int err = 0 ; int dev = get_cable_index ( substream ) ; mutex_lock ( & loopback -> cable_lock ) ; dpcm = kzalloc ( sizeof ( * dpcm ) , GFP_KERNEL ) ; if ( ! dpcm ) { err = - ENOMEM ; goto unlock ; } dpcm -> loopback = loopback ; dpcm -> substream = substream ; timer_setup ( & dpcm -> timer , loopback_timer_function , 0 ) ; cable = loopback -> cables [ substream -> number ] [ dev ] ; if ( ! cable ) { cable = kzalloc ( sizeof ( * cable ) , GFP_KERNEL ) ; if ( ! cable ) { <S2SV_StartBug> kfree ( dpcm ) ; <S2SV_EndBug> err = - ENOMEM ; goto unlock ; } spin_lock_init ( & cable -> lock ) ; cable -> hw = loopback_pcm_hardware ; loopback -> cables [ substream -> number ] [ dev ] = cable ; } dpcm -> cable = cable ; cable -> streams [ substream -> stream ] = dpcm ; snd_pcm_hw_constraint_integer ( runtime , SNDRV_PCM_HW_PARAM_PERIODS ) ; err = snd_pcm_hw_rule_add ( runtime , 0 , SNDRV_PCM_HW_PARAM_FORMAT , <S2SV_StartBug> rule_format , & runtime -> hw , <S2SV_EndBug> SNDRV_PCM_HW_PARAM_FORMAT , - 1 ) ; if ( err < 0 ) goto unlock ; err = snd_pcm_hw_rule_add ( runtime , 0 , SNDRV_PCM_HW_PARAM_RATE , <S2SV_StartBug> rule_rate , & runtime -> hw , <S2SV_EndBug> SNDRV_PCM_HW_PARAM_RATE , - 1 ) ; if ( err < 0 ) goto unlock ; err = snd_pcm_hw_rule_add ( runtime , 0 , SNDRV_PCM_HW_PARAM_CHANNELS , <S2SV_StartBug> rule_channels , & runtime -> hw , <S2SV_EndBug> SNDRV_PCM_HW_PARAM_CHANNELS , - 1 ) ; if ( err < 0 ) goto unlock ; runtime -> private_data = dpcm ; runtime -> private_free = loopback_runtime_free ; if ( get_notify ( dpcm ) ) runtime -> hw = loopback_pcm_hardware ; else runtime -> hw = cable -> hw ; unlock : <S2SV_StartBug> mutex_unlock ( & loopback -> cable_lock ) ; <S2SV_EndBug> return err ; } | <S2SV_ModStart> loopback_cable * cable = NULL <S2SV_ModStart> cable ) { <S2SV_ModEnd> err = - <S2SV_ModStart> , rule_format , dpcm <S2SV_ModEnd> , SNDRV_PCM_HW_PARAM_FORMAT , <S2SV_ModStart> , rule_rate , dpcm <S2SV_ModEnd> , SNDRV_PCM_HW_PARAM_RATE , <S2SV_ModStart> , rule_channels , dpcm <S2SV_ModEnd> , SNDRV_PCM_HW_PARAM_CHANNELS , <S2SV_ModStart> ; unlock : if ( err < 0 ) { free_cable ( substream ) ; kfree ( dpcm ) ; } |
5,301 | CWE-000 static void rText ( float x , float y , float scaleX , float scaleY , bool baseline , const char * text ) { setTextColor ( 0xffffffff ) ; char out [ 100 ] ; char sub [ 100 ] ; memset ( out , '\\0' , sizeof ( out ) ) ; strncpy ( out , text , sizeof ( out ) ) ; float height ; float width ; int i = 0 ; while ( strstr ( out , "!." ) != NULL && i < 40 ) { i ++ ; char * result = strstr ( out , "!." ) ; int position = result - out + 3 ; int substringLength = strlen ( out ) - position ; out [ position - 3 ] = '\\0' ; renderText ( x , y , .5f , .5f , true , out ) ; screen_get_string_size_wrap ( & width , & height , out , 0.5f , 0.5f , 320 ) ; x += width ; if ( out [ position - 1 ] == 'r' ) setTextColor ( 0xff0000ff ) ; else if ( out [ position - 1 ] == 'g' ) setTextColor ( colors [ 0 ] | 0xff000000 ) ; else if ( out [ position - 1 ] == 'y' ) setTextColor ( 0xff00ffe4 ) ; else if ( out [ position - 1 ] == 'b' ) setTextColor ( 0xffff4e00 ) ; else if ( out [ position - 1 ] == 'm' ) setTextColor ( 0xffff00fc ) ; else if ( out [ position - 1 ] == 'c' ) setTextColor ( 0xfff0ff00 ) ; else if ( out [ position - 1 ] == 'd' ) setTextColor ( 0xff2c7225 ) ; else if ( out [ position - 1 ] == 'o' ) setTextColor ( 0xff0096ff ) ; else if ( out [ position - 1 ] == 'p' ) setTextColor ( 0xff827fff ) ; else if ( out [ position - 1 ] == 'w' ) setTextColor ( 0xffffffff ) ; else if ( out [ position - 1 ] == 'z' ) setTextColor ( 0xff000000 ) ; <S2SV_StartBug> memset ( sub , '\\0' , sizeof ( sub ) ) ; <S2SV_EndBug> snprintf ( sub , sizeof ( sub ) , "%.*s" , substringLength , out + position ) ; result = strstr ( sub , "!." ) ; if ( result != NULL ) position = result - sub ; else position = sizeof ( sub ) ; memset ( out , '\\0' , sizeof ( out ) ) ; snprintf ( out , sizeof ( out ) , "%.*s" , sizeof ( sub ) - position , sub + position ) ; sub [ position ] = '\\0' ; renderText ( x , y , .5f , .5f , true , sub ) ; screen_get_string_size_wrap ( & width , & height , sub , 0.5f , 0.5f , 320 ) ; x += width ; } renderText ( x , y , .5f , .5f , true , out ) ; } | <S2SV_ModStart> 0xff000000 ) ; else if ( out [ position - 1 ] == 'j' ) setTextColor ( 0xff008275 ) ; |
5,302 | CWE-000 void z_clock_set_timeout ( s32_t ticks , bool idle ) { if ( IS_ENABLED ( CONFIG_TICKLESS_IDLE ) && idle && ticks == K_FOREVER ) { SysTick -> CTRL &= ~ SysTick_CTRL_ENABLE_Msk ; last_load = TIMER_STOPPED ; return ; } <S2SV_StartBug> # ifdef CONFIG_TICKLESS_KERNEL <S2SV_EndBug> u32_t delay ; ticks = min ( MAX_TICKS , max ( ticks - 1 , 0 ) ) ; delay = ( ticks == 0 ) ? MIN_DELAY : ticks * CYC_PER_TICK ; k_spinlock_key_t key = k_spin_lock ( & lock ) ; cycle_count += elapsed ( ) ; delay = delay + ( cycle_count - announced_cycles ) ; delay = ( ( delay + CYC_PER_TICK - 1 ) / CYC_PER_TICK ) * CYC_PER_TICK ; last_load = delay - ( cycle_count - announced_cycles ) ; SysTick -> LOAD = last_load ; SysTick -> VAL = 0 ; k_spin_unlock ( & lock , key ) ; # endif } | <S2SV_ModStart> ; } # if defined ( CONFIG_TICKLESS_KERNEL ) && ! defined ( CONFIG_QEMU_TICKLESS_WORKAROUND ) <S2SV_ModEnd> u32_t delay ; |
5,303 | CWE-000 static int l2tp_ip6_recvmsg ( struct kiocb * iocb , struct sock * sk , struct msghdr * msg , size_t len , int noblock , int flags , int * addr_len ) { struct ipv6_pinfo * np = inet6_sk ( sk ) ; struct sockaddr_l2tpip6 * lsa = ( struct sockaddr_l2tpip6 * ) msg -> msg_name ; size_t copied = 0 ; int err = - EOPNOTSUPP ; struct sk_buff * skb ; if ( flags & MSG_OOB ) goto out ; if ( addr_len ) * addr_len = sizeof ( * lsa ) ; if ( flags & MSG_ERRQUEUE ) <S2SV_StartBug> return ipv6_recv_error ( sk , msg , len ) ; <S2SV_EndBug> skb = skb_recv_datagram ( sk , flags , noblock , & err ) ; if ( ! skb ) goto out ; copied = skb -> len ; if ( len < copied ) { msg -> msg_flags |= MSG_TRUNC ; copied = len ; } err = skb_copy_datagram_iovec ( skb , 0 , msg -> msg_iov , copied ) ; if ( err ) goto done ; sock_recv_timestamp ( msg , sk , skb ) ; if ( lsa ) { lsa -> l2tp_family = AF_INET6 ; lsa -> l2tp_unused = 0 ; lsa -> l2tp_addr = ipv6_hdr ( skb ) -> saddr ; lsa -> l2tp_flowinfo = 0 ; lsa -> l2tp_scope_id = 0 ; lsa -> l2tp_conn_id = 0 ; if ( ipv6_addr_type ( & lsa -> l2tp_addr ) & IPV6_ADDR_LINKLOCAL ) lsa -> l2tp_scope_id = IP6CB ( skb ) -> iif ; } if ( np -> rxopt . all ) ip6_datagram_recv_ctl ( sk , msg , skb ) ; if ( flags & MSG_TRUNC ) copied = skb -> len ; done : skb_free_datagram ( sk , skb ) ; out : return err ? err : copied ; } | <S2SV_ModStart> msg , len , |
5,304 | CWE-000 void zend_shared_alloc_shutdown ( void ) { zend_shared_segment * * tmp_shared_segments ; <S2SV_StartBug> size_t shared_segments_array_size ; <S2SV_EndBug> zend_smm_shared_globals tmp_shared_globals ; int i ; tmp_shared_globals = * smm_shared_globals ; smm_shared_globals = & tmp_shared_globals ; shared_segments_array_size = ZSMMG ( shared_segments_count ) * ( S_H ( segment_type_size ) ( ) + sizeof ( void * ) ) ; <S2SV_StartBug> tmp_shared_segments = emalloc ( shared_segments_array_size ) ; <S2SV_EndBug> copy_shared_segments ( tmp_shared_segments , ZSMMG ( shared_segments ) [ 0 ] , ZSMMG ( shared_segments_count ) , S_H ( segment_type_size ) ( ) ) ; ZSMMG ( shared_segments ) = tmp_shared_segments ; for ( i = 0 ; i < ZSMMG ( shared_segments_count ) ; i ++ ) { S_H ( detach_segment ) ( ZSMMG ( shared_segments ) [ i ] ) ; } <S2SV_StartBug> efree ( ZSMMG ( shared_segments ) ) ; <S2SV_EndBug> ZSMMG ( shared_segments ) = NULL ; g_shared_alloc_handler = NULL ; # ifndef ZEND_WIN32 close ( lock_file ) ; # endif } | <S2SV_ModStart> * tmp_shared_segments ; zend_shared_segment * shared_segments_buf [ 16 ] ; <S2SV_ModStart> ) ) ; if ( shared_segments_array_size > 16 ) { tmp_shared_segments = malloc ( shared_segments_array_size ) ; } else { tmp_shared_segments = shared_segments_buf ; } <S2SV_ModEnd> copy_shared_segments ( tmp_shared_segments <S2SV_ModStart> ) ; } if ( shared_segments_array_size > 16 ) { free ( ZSMMG ( shared_segments ) ) ; } <S2SV_ModEnd> ZSMMG ( shared_segments |
5,305 | CWE-000 int ibv_cmd_alloc_pd ( struct ibv_context * context , struct ibv_pd * pd , struct ibv_alloc_pd * cmd , size_t cmd_size , <S2SV_StartBug> struct ibv_alloc_pd_resp * resp , size_t resp_size ) <S2SV_EndBug> { IBV_INIT_CMD_RESP ( cmd , cmd_size , ALLOC_PD , resp , resp_size ) ; if ( write ( context -> cmd_fd , cmd , cmd_size ) != cmd_size ) return errno ; ( void ) VALGRIND_MAKE_MEM_DEFINED ( resp , resp_size ) ; pd -> handle = resp -> pd_handle ; pd -> context = context ; return 0 ; } | <S2SV_ModStart> cmd_size , struct ib_uverbs_alloc_pd_resp <S2SV_ModEnd> * resp , |
5,306 | CWE-000 static int sdcardfs_rename ( struct inode * old_dir , struct dentry * old_dentry , struct inode * new_dir , struct dentry * new_dentry ) { int err = 0 ; struct dentry * lower_old_dentry = NULL ; struct dentry * lower_new_dentry = NULL ; struct dentry * lower_old_dir_dentry = NULL ; struct dentry * lower_new_dir_dentry = NULL ; struct vfsmount * lower_mnt = NULL ; struct dentry * trap = NULL ; <S2SV_StartBug> struct dentry * new_parent = NULL ; <S2SV_EndBug> struct path lower_old_path , lower_new_path ; const struct cred * saved_cred = NULL ; if ( ! check_caller_access_to_name ( old_dir , old_dentry -> d_name . name ) || ! check_caller_access_to_name ( new_dir , new_dentry -> d_name . name ) ) { printk ( KERN_INFO "%s:<S2SV_blank>need<S2SV_blank>to<S2SV_blank>check<S2SV_blank>the<S2SV_blank>caller\'s<S2SV_blank>gid<S2SV_blank>in<S2SV_blank>packages.list\\n" "<S2SV_blank><S2SV_blank>new_dentry:<S2SV_blank>%s,<S2SV_blank>task:%s\\n" , __func__ , new_dentry -> d_name . name , current -> comm ) ; err = - EACCES ; goto out_eacces ; } <S2SV_StartBug> OVERRIDE_CRED ( SDCARDFS_SB ( old_dir -> i_sb ) , saved_cred ) ; <S2SV_EndBug> sdcardfs_get_real_lower ( old_dentry , & lower_old_path ) ; sdcardfs_get_lower_path ( new_dentry , & lower_new_path ) ; lower_old_dentry = lower_old_path . dentry ; lower_new_dentry = lower_new_path . dentry ; lower_mnt = lower_old_path . mnt ; lower_old_dir_dentry = dget_parent ( lower_old_dentry ) ; lower_new_dir_dentry = dget_parent ( lower_new_dentry ) ; trap = lock_rename ( lower_old_dir_dentry , lower_new_dir_dentry ) ; if ( trap == lower_old_dentry ) { err = - EINVAL ; goto out ; } if ( trap == lower_new_dentry ) { err = - ENOTEMPTY ; goto out ; } err = vfs_rename2 ( lower_mnt , lower_old_dir_dentry -> d_inode , lower_old_dentry , lower_new_dir_dentry -> d_inode , lower_new_dentry ) ; if ( err ) goto out ; sdcardfs_copy_and_fix_attrs ( new_dir , lower_new_dir_dentry -> d_inode ) ; fsstack_copy_inode_size ( new_dir , lower_new_dir_dentry -> d_inode ) ; if ( new_dir != old_dir ) { sdcardfs_copy_and_fix_attrs ( old_dir , lower_old_dir_dentry -> d_inode ) ; fsstack_copy_inode_size ( old_dir , lower_old_dir_dentry -> d_inode ) ; } <S2SV_StartBug> get_derived_permission_new ( new_dentry -> d_parent , old_dentry , new_dentry ) ; <S2SV_EndBug> fixup_tmp_permissions ( old_dentry -> d_inode ) ; <S2SV_StartBug> fixup_top_recursive ( old_dentry ) ; <S2SV_EndBug> out : unlock_rename ( lower_old_dir_dentry , lower_new_dir_dentry ) ; dput ( lower_old_dir_dentry ) ; dput ( lower_new_dir_dentry ) ; sdcardfs_put_real_lower ( old_dentry , & lower_old_path ) ; sdcardfs_put_lower_path ( new_dentry , & lower_new_path ) ; REVERT_CRED ( saved_cred ) ; out_eacces : return err ; } | <S2SV_ModStart> NULL ; struct <S2SV_ModEnd> path lower_old_path , <S2SV_ModStart> ) , saved_cred , SDCARDFS_I ( new_dir ) <S2SV_ModStart> old_dentry , new_dentry -> d_name . name <S2SV_ModStart> d_inode ) ; fixup_lower_ownership ( old_dentry , new_dentry -> d_name . name ) ; drop_recursive <S2SV_ModEnd> ( old_dentry ) |
5,307 | CWE-000 void printRoom ( Room * room ) { printf ( "CURRENT<S2SV_blank>LOCATION:<S2SV_blank>%s\\n" , room -> name ) ; printf ( "POSSIBLE<S2SV_blank>CONNECTIONS:<S2SV_blank>" ) ; <S2SV_StartBug> for ( int i = 0 ; i < room -> connection_count ; i ++ ) { <S2SV_EndBug> printf ( "%s" , ( room -> connections [ i ] ) -> name ) ; if ( i < room -> connection_count - 1 ) { printf ( ",<S2SV_blank>" ) ; } } printf ( "." ) ; printf ( "\\nWHERE<S2SV_blank>TO?:<S2SV_blank>>" ) ; } | <S2SV_ModStart> "POSSIBLE<S2SV_blank>CONNECTIONS:<S2SV_blank>" ) ; int i = 0 ; for ( <S2SV_ModEnd> i = 0 |
5,308 | CWE-000 static int config_delete_multivar ( git_config_backend * cfg , const char * name , const char * regexp ) { diskfile_backend * b = ( diskfile_backend * ) cfg ; refcounted_strmap * map ; git_strmap * values ; char * key ; regex_t preg ; int result ; khiter_t pos ; if ( ( result = git_config__normalize_name ( name , & key ) ) < 0 ) return result ; if ( ( map = refcounted_strmap_take ( & b -> header ) ) == NULL ) return - 1 ; values = b -> header . values -> values ; pos = git_strmap_lookup_index ( values , key ) ; if ( ! git_strmap_valid_index ( values , pos ) ) { refcounted_strmap_free ( map ) ; git__free ( key ) ; giterr_set ( GITERR_CONFIG , "Could<S2SV_blank>not<S2SV_blank>find<S2SV_blank>key<S2SV_blank>\'%s\'<S2SV_blank>to<S2SV_blank>delete" , name ) ; return GIT_ENOTFOUND ; } refcounted_strmap_free ( map ) ; <S2SV_StartBug> result = regcomp ( & preg , regexp , REG_EXTENDED ) ; <S2SV_EndBug> if ( result != 0 ) { giterr_set_regex ( & preg , result ) ; result = - 1 ; goto out ; } if ( ( result = config_write ( b , key , & preg , NULL ) ) < 0 ) goto out ; result = config_refresh ( cfg ) ; out : git__free ( key ) ; regfree ( & preg ) ; return result ; } | <S2SV_ModStart> ; result = p_regcomp <S2SV_ModEnd> ( & preg |
5,309 | CWE-000 int authorizeConnection ( SOCKET sock ) { char recvbuf [ FTP_DEFAULT_BUFLEN ] ; int iResult = recv ( sock , recvbuf , sizeof ( recvbuf ) , 0 ) ; if ( iResult < 0 ) { hlogf ( "Error<S2SV_blank>receiving<S2SV_blank>welcome<S2SV_blank>message.\\n" ) ; return - 2 ; } recvbuf [ iResult ] = 0 ; printf ( "\\n%s\\n" , recvbuf ) ; int attempts = 3 ; char success = 0 ; for ( int i = 0 ; i <= 2 * attempts ; i ++ ) { strcpy ( recvbuf , ( i < attempts ? "USER<S2SV_blank>" : "PASS<S2SV_blank>" ) ) ; gmisc_GetLine ( ( i < attempts ? "Name:<S2SV_blank>" : "Password:<S2SV_blank>" ) , recvbuf + 5 , sizeof ( recvbuf ) - 7 , stdin ) ; strcpy ( recvbuf + strlen ( recvbuf ) , "\\r\\n" ) ; <S2SV_StartBug> if ( sendMessageGetResponse ( sock , recvbuf , recvbuf , sizeof ( recvbuf ) ) < 0 ) { <S2SV_EndBug> hlogf ( "Error<S2SV_blank>on<S2SV_blank>sendMessageGetResponse()\\n" ) ; return - 3 ; } <S2SV_StartBug> printf ( "\\n%s\\n" , recvbuf ) ; <S2SV_EndBug> if ( ( recvbuf [ 0 ] == '5' || recvbuf [ 0 ] == '4' ) && ! ( ( i + 1 ) % attempts ) ) { hlogf ( "Can\'t<S2SV_blank>authenticate.<S2SV_blank>Max<S2SV_blank>attempts<S2SV_blank>reached.<S2SV_blank>Aborting...\\n" ) ; return - 1 ; } if ( recvbuf [ 0 ] == '2' || recvbuf [ 0 ] == '3' ) { if ( i < attempts ) i = attempts ; else break ; } } return 0 ; } | <S2SV_ModStart> ( recvbuf ) , 1 <S2SV_ModStart> 3 ; } <S2SV_ModEnd> if ( ( |
5,310 | CWE-000 int rdma_resolve_ip ( struct sockaddr * src_addr , const struct sockaddr * dst_addr , struct rdma_dev_addr * addr , int timeout_ms , void ( * callback ) ( int status , struct sockaddr * src_addr , <S2SV_StartBug> struct rdma_dev_addr * addr , void * context ) , <S2SV_EndBug> void * context ) { struct sockaddr * src_in , * dst_in ; struct addr_req * req ; int ret = 0 ; req = kzalloc ( sizeof * req , GFP_KERNEL ) ; if ( ! req ) return - ENOMEM ; src_in = ( struct sockaddr * ) & req -> src_addr ; dst_in = ( struct sockaddr * ) & req -> dst_addr ; if ( src_addr ) { if ( src_addr -> sa_family != dst_addr -> sa_family ) { ret = - EINVAL ; goto err ; } memcpy ( src_in , src_addr , rdma_addr_size ( src_addr ) ) ; } else { src_in -> sa_family = dst_addr -> sa_family ; } memcpy ( dst_in , dst_addr , rdma_addr_size ( dst_addr ) ) ; req -> addr = addr ; req -> callback = callback ; req -> context = context ; <S2SV_StartBug> INIT_DELAYED_WORK ( & req -> work , process_one_req ) ; <S2SV_EndBug> req -> seq = ( u32 ) atomic_inc_return ( & ib_nl_addr_request_seq ) ; <S2SV_StartBug> req -> status = addr_resolve ( src_in , dst_in , addr , true , req -> seq ) ; <S2SV_EndBug> switch ( req -> status ) { case 0 : req -> timeout = jiffies ; queue_req ( req ) ; break ; case - ENODATA : req -> timeout = msecs_to_jiffies ( timeout_ms ) + jiffies ; queue_req ( req ) ; break ; default : ret = req -> status ; goto err ; } return ret ; err : kfree ( req ) ; return ret ; } | <S2SV_ModStart> * context ) , bool resolve_by_gid_attr <S2SV_ModStart> = context ; req -> resolve_by_gid_attr = resolve_by_gid_attr ; <S2SV_ModStart> addr , true , req -> resolve_by_gid_attr |
5,311 | CWE-000 GreyPacket * GreyList_next ( GreyPacket * packet ) { void * next = packet -> next ; if ( next == GREYLIST_LAST ) { return NULL ; <S2SV_StartBug> } else { <S2SV_EndBug> return ( GreyPacket * ) next ; } } | <S2SV_ModStart> ; } else if ( next == NULL ) { return packet + 1 ; } else |
5,312 | CWE-000 static void emit_rs_state ( struct anv_pipeline * pipeline , const VkPipelineRasterizationStateCreateInfo * rs_info , const VkPipelineMultisampleStateCreateInfo * ms_info , const struct anv_render_pass * pass , const struct anv_subpass * subpass ) { struct GENX ( 3DSTATE_SF ) sf = { GENX ( 3DSTATE_SF_header ) , } ; sf . ViewportTransformEnable = true ; sf . StatisticsEnable = true ; sf . TriangleStripListProvokingVertexSelect = 0 ; sf . LineStripListProvokingVertexSelect = 0 ; sf . TriangleFanProvokingVertexSelect = 1 ; <S2SV_StartBug> sf . PointWidthSource = Vertex ; <S2SV_EndBug> <S2SV_StartBug> sf . PointWidth = 1.0 ; <S2SV_EndBug> # if GEN_GEN >= 8 struct GENX ( 3DSTATE_RASTER ) raster = { GENX ( 3DSTATE_RASTER_header ) , } ; # else # define raster sf # endif # if GEN_GEN >= 8 raster . DXMultisampleRasterizationEnable = true ; raster . ForcedSampleCount = FSC_NUMRASTSAMPLES_0 ; raster . ForceMultisampling = false ; # else raster . MultisampleRasterizationMode = ( ms_info && ms_info -> rasterizationSamples > 1 ) ? MSRASTMODE_ON_PATTERN : MSRASTMODE_OFF_PIXEL ; # endif raster . FrontWinding = vk_to_gen_front_face [ rs_info -> frontFace ] ; raster . CullMode = vk_to_gen_cullmode [ rs_info -> cullMode ] ; raster . FrontFaceFillMode = vk_to_gen_fillmode [ rs_info -> polygonMode ] ; raster . BackFaceFillMode = vk_to_gen_fillmode [ rs_info -> polygonMode ] ; raster . ScissorRectangleEnable = true ; # if GEN_GEN >= 9 raster . ViewportZFarClipTestEnable = ! pipeline -> depth_clamp_enable ; raster . ViewportZNearClipTestEnable = ! pipeline -> depth_clamp_enable ; # elif GEN_GEN >= 8 raster . ViewportZClipTestEnable = ! pipeline -> depth_clamp_enable ; # endif raster . GlobalDepthOffsetEnableSolid = rs_info -> depthBiasEnable ; raster . GlobalDepthOffsetEnableWireframe = rs_info -> depthBiasEnable ; raster . GlobalDepthOffsetEnablePoint = rs_info -> depthBiasEnable ; # if GEN_GEN == 7 if ( subpass -> depth_stencil_attachment < pass -> attachment_count ) { VkFormat vk_format = pass -> attachments [ subpass -> depth_stencil_attachment ] . format ; assert ( vk_format_is_depth_or_stencil ( vk_format ) ) ; if ( vk_format_aspects ( vk_format ) & VK_IMAGE_ASPECT_DEPTH_BIT ) { enum isl_format isl_format = anv_get_isl_format ( & pipeline -> device -> info , vk_format , VK_IMAGE_ASPECT_DEPTH_BIT , VK_IMAGE_TILING_OPTIMAL ) ; sf . DepthBufferSurfaceFormat = isl_format_get_depth_format ( isl_format , false ) ; } } # endif # if GEN_GEN >= 8 GENX ( 3DSTATE_SF_pack ) ( NULL , pipeline -> gen8 . sf , & sf ) ; GENX ( 3DSTATE_RASTER_pack ) ( NULL , pipeline -> gen8 . raster , & raster ) ; # else # undef raster GENX ( 3DSTATE_SF_pack ) ( NULL , & pipeline -> gen7 . sf , & sf ) ; # endif } | <S2SV_ModStart> = 1 ; const struct brw_vue_prog_data * last_vue_prog_data = anv_pipeline_get_last_vue_prog_data ( pipeline ) ; if ( last_vue_prog_data -> vue_map . slots_valid & VARYING_BIT_PSIZ ) { <S2SV_ModStart> = Vertex ; } else { sf . PointWidthSource = State ; <S2SV_ModStart> = 1.0 ; } |
5,313 | CWE-000 void initializeSensors ( ) { <S2SV_StartBug> uint8_t autoIncrementRegister [ 1 ] = { 0x12 } ; <S2SV_EndBug> uint8_t autoIncrement = 0x04 ; int incrementSuccess = i2cWrite ( accelAddress , autoIncrementRegister , 1 , autoIncrement , AUTO_INCREMENT_ENABLED ) ; if ( incrementSuccess != 0 ) { printf ( "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>auto<S2SV_blank>increment<S2SV_blank>for<S2SV_blank>accelerometer\\n" ) ; } uint8_t accelConfigRegisters [ 1 ] = { 0x10 } ; uint8_t accelConfig = 0x84 ; int accelSuccess = i2cWrite ( accelAddress , accelConfigRegisters , 1 , accelConfig , AUTO_INCREMENT_ENABLED ) ; if ( accelSuccess != 0 ) { printf ( "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>i2c<S2SV_blank>configuration<S2SV_blank>for<S2SV_blank>accelerometer\\n" ) ; } uint8_t gyroConfigRegister [ 1 ] = { 0x11 } ; uint8_t gyroConfig = 0x8c ; int gyroSuccess = i2cWrite ( gyroAddress , gyroConfigRegister , 1 , gyroConfig , AUTO_INCREMENT_ENABLED ) ; gyroConfigRegister [ 0 ] = 0x16 ; gyroConfig = 0x64 ; gyroSuccess |= i2cWrite ( gyroAddress , gyroConfigRegister , 1 , gyroConfig , AUTO_INCREMENT_ENABLED ) ; if ( gyroSuccess != 0 ) { printf ( "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>i2c<S2SV_blank>configuration<S2SV_blank>for<S2SV_blank>gyroscope\\n" ) ; } uint8_t magConfigRegister1 = 0x10 ; uint8_t magSleepValue = 0x00 ; int magSuccess = i2cWrite ( magAddress , & magConfigRegister1 , 1 , magSleepValue , AUTO_INCREMENT_ENABLED ) ; uint8_t magConfigRegisters [ 2 ] = { 0x10 , 0x11 } ; uint16_t magConfig = 0x0920 ; magSuccess |= i2cWrite ( magAddress , magConfigRegisters , 2 , magConfig , AUTO_INCREMENT_ENABLED ) ; uint8_t magWakeValue = 0x09 ; magSuccess |= i2cWrite ( magAddress , & magConfigRegister1 , 1 , magWakeValue , AUTO_INCREMENT_ENABLED ) ; if ( magSuccess != 0 ) { printf ( "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>i2c<S2SV_blank>configuration<S2SV_blank>for<S2SV_blank>magnetometer\\n" ) ; } <S2SV_StartBug> usleep ( 50 ) ; <S2SV_EndBug> _sensorsAvailable = 1 ; } | <S2SV_ModStart> ( ) { if ( _sensorsAvailable == 1 ) { return ; } <S2SV_ModStart> ) ; } getBarometerParameters ( ) ; |
5,314 | CWE-000 void ds_init ( DynamicString * input ) { input -> capacity = DEFAULT_LENGTH ; <S2SV_StartBug> input -> data = malloc ( DEFAULT_LENGTH ) ; <S2SV_EndBug> input -> size = 0 ; } | <S2SV_ModStart> -> data = NULL ; input -> data = |
5,315 | CWE-000 int main ( int argc , char * argv [ ] ) { int sock ; struct sockaddr_in echoServAddr ; struct sockaddr_in fromAddr ; unsigned short echoServPort ; unsigned int fromSize ; char * servIP ; char * echoString ; char echoBuffer [ ECHOMAX + 1 ] ; int echoStringLen ; int respStringLen ; if ( ( argc < 3 ) || ( argc > 4 ) ) { fprintf ( stderr , "Usage:<S2SV_blank>%s<S2SV_blank><Server<S2SV_blank>IP><S2SV_blank><Echo<S2SV_blank>Word><S2SV_blank>[<Echo<S2SV_blank>Port>]\\n" , argv [ 0 ] ) ; exit ( 1 ) ; } servIP = argv [ 1 ] ; echoString = argv [ 2 ] ; echoStringLen = strlen ( echoString ) ; check ( echoStringLen < ECHOMAX , "Echo<S2SV_blank>word<S2SV_blank>too<S2SV_blank>long<S2SV_blank>%i" , echoStringLen ) ; if ( argc == 4 ) echoServPort = atoi ( argv [ 3 ] ) ; else echoServPort = 7 ; sock = socket ( PF_INET , SOCK_DGRAM , IPPROTO_UDP ) ; check ( sock > 0 , "socket()<S2SV_blank>failed" ) ; memset ( & echoServAddr , 0 , sizeof ( echoServAddr ) ) ; echoServAddr . sin_family = AF_INET ; echoServAddr . sin_addr . s_addr = inet_addr ( servIP ) ; echoServAddr . sin_port = htons ( echoServPort ) ; check ( ( sendto ( sock , echoString , echoStringLen , 0 , ( struct sockaddr * ) & echoServAddr , sizeof ( echoServAddr ) ) == echoStringLen ) , "sendto()<S2SV_blank>sent<S2SV_blank>a<S2SV_blank>different<S2SV_blank>number<S2SV_blank>of<S2SV_blank>bytes<S2SV_blank>than<S2SV_blank>expected" ) ; fromSize = sizeof ( fromAddr ) ; respStringLen = recvfrom ( sock , echoBuffer , ECHOMAX , 0 , ( struct sockaddr * ) & fromAddr , & fromSize ) ; check ( ( echoServAddr . sin_addr . s_addr == fromAddr . sin_addr . s_addr ) , "Error:<S2SV_blank>received<S2SV_blank>a<S2SV_blank>packet<S2SV_blank>from<S2SV_blank>unknown<S2SV_blank>source.\\n" ) ; printf ( "Received:\\n%s\\n" , echoBuffer ) ; for ( ; ; ) { scanf ( "%s" , echoString ) ; <S2SV_StartBug> check ( ( sendto ( sock , echoString , echoStringLen , 0 , ( struct sockaddr * ) <S2SV_EndBug> & echoServAddr , sizeof ( echoServAddr ) ) == echoStringLen ) , "sendto()<S2SV_blank>sent<S2SV_blank>a<S2SV_blank>different<S2SV_blank>number<S2SV_blank>of<S2SV_blank>bytes<S2SV_blank>than<S2SV_blank>expected" ) ; fromSize = sizeof ( fromAddr ) ; respStringLen = recvfrom ( sock , echoBuffer , ECHOMAX , 0 , ( struct sockaddr * ) & fromAddr , & fromSize ) ; check ( ( echoServAddr . sin_addr . s_addr == fromAddr . sin_addr . s_addr ) , "Error:<S2SV_blank>received<S2SV_blank>a<S2SV_blank>packet<S2SV_blank>from<S2SV_blank>unknown<S2SV_blank>source.\\n" ) ; echoBuffer [ respStringLen ] = '\\0' ; printf ( "Received:\\n%s\\n" , echoBuffer ) ; } error : close ( sock ) ; exit ( 0 ) ; } | <S2SV_ModStart> echoString ) ; echoStringLen = strlen ( echoString ) ; |
5,316 | CWE-000 int main ( ) { int type ; double op2 ; char s [ MAXOP ] ; char active_var ; int i = 0 ; for ( i ; i < MEM_LEN ; i ++ ) mem [ i ] = 0.0 ; <S2SV_StartBug> while ( getline ( s ) > 0 ) <S2SV_EndBug> { switch ( type ) { case NUMBER : push ( atof ( s ) ) ; break ; case MATH_FUNC : push ( runfunction ( s ) ) ; break ; case VAR_NAME : active_var = s [ 0 ] - 'a' ; push ( mem [ active_var ] ) ; break ; case '+' : push ( pop ( ) + pop ( ) ) ; break ; case '*' : push ( pop ( ) * pop ( ) ) ; break ; case '-' : op2 = pop ( ) ; push ( pop ( ) - op2 ) ; break ; case '/' : op2 = pop ( ) ; if ( op2 != 0.0 ) { push ( pop ( ) / op2 ) ; } else { printf ( "error:<S2SV_blank>zero<S2SV_blank>divisor\\n" ) ; } break ; case '%' : op2 = pop ( ) ; if ( op2 != 0.0 ) { push ( fmod ( pop ( ) , op2 ) ) ; } else { printf ( "error:<S2SV_blank>zero<S2SV_blank>divisor\\n" ) ; } break ; case '>' : getop ( s ) ; if ( strlen ( s ) > 1 ) { printf ( "error:<S2SV_blank>variable<S2SV_blank>names<S2SV_blank>must<S2SV_blank>be<S2SV_blank>one<S2SV_blank>character.\\n" ) ; } if ( s [ 0 ] - 'a' < 0 || s [ 0 ] - 'a' > 25 ) { printf ( "error:<S2SV_blank>invalid<S2SV_blank>var<S2SV_blank>name:<S2SV_blank>%c\\n" , s [ 0 ] ) ; } else { op2 = pop ( ) ; printf ( "setting<S2SV_blank>%c<S2SV_blank>to<S2SV_blank>%f\\n" , s [ 0 ] - 'a' , op2 ) ; mem [ s [ 0 ] - 'a' ] = op2 ; } break ; case '\\n' : printf ( "\\t%.8g\\n" , pop ( ) ) ; break ; case 'S' : if ( swap ( ) != 0 ) printf ( "error:<S2SV_blank>not<S2SV_blank>enough<S2SV_blank>stack<S2SV_blank>data<S2SV_blank>to<S2SV_blank>swap\\n" ) ; break ; case 'P' : if ( printtop ( ) != 0 ) printf ( "error:<S2SV_blank>nothing<S2SV_blank>to<S2SV_blank>print\\n" ) ; break ; case 'D' : if ( dupe ( ) != 0 ) printf ( "error:<S2SV_blank>nothing<S2SV_blank>to<S2SV_blank>duplicate<S2SV_blank>on<S2SV_blank>stack\\n" ) ; break ; case 'C' : clear ( ) ; break ; default : printf ( "error:<S2SV_blank>unknown<S2SV_blank>command<S2SV_blank>%s\\n" , s ) ; break ; } } return 0 ; } | <S2SV_ModStart> ( getline ( <S2SV_ModEnd> ) > 0 |
5,317 | CWE-000 void remove_color ( Colors * colors , color_t c ) { color_t i ; if ( c < 0 || c >= COLOR_COUNT || c == colors -> def || colors -> n == 0 ) { return ; } colors -> turn [ c ] = colors -> turn [ colors -> def ] = TURN_NONE ; if ( colors -> n -- == 1 ) { colors -> first = colors -> last = COLOR_NONE ; colors -> next [ c ] = colors -> next [ colors -> def ] = colors -> def ; return ; } if ( colors -> first == c ) { colors -> first = colors -> next [ colors -> last ] = colors -> next [ c ] ; } <S2SV_StartBug> for ( i = 0 ; i < COLOR_COUNT ; ++ i ) { <S2SV_EndBug> if ( colors -> next [ i ] == c ) { colors -> next [ i ] = colors -> next [ c ] ; if ( colors -> turn [ i ] != TURN_NONE && colors -> last == c ) { colors -> last = i ; } } } update_def ( colors ) ; } | <S2SV_ModStart> < COLOR_COUNT ; i ++ <S2SV_ModEnd> ) { if |
5,318 | CWE-000 static void draw_cursor ( uint x , uint y , uint c ) { uint i ; for ( i = x ; i < x + FNT_W - 2 ; i ++ ) { <S2SV_StartBug> set_cursor_pixel ( i , j , c ) ; <S2SV_EndBug> } return ; } | <S2SV_ModStart> ( i , y <S2SV_ModEnd> , c ) |
5,319 | CWE-000 void read_lifepo_current_batch ( lifepo_current_batch batch ) { <S2SV_StartBug> configure_adc ( & adc_instance , P_AI_LFB1SNS ) ; <S2SV_EndBug> <S2SV_StartBug> batch [ 0 ] = read_adc ( adc_instance ) ; <S2SV_EndBug> <S2SV_StartBug> configure_adc ( & adc_instance , P_AI_LFB1OSNS ) ; <S2SV_EndBug> <S2SV_StartBug> batch [ 1 ] = read_adc ( adc_instance ) ; <S2SV_EndBug> <S2SV_StartBug> configure_adc ( & adc_instance , P_AI_LFB2SNS ) ; <S2SV_EndBug> <S2SV_StartBug> batch [ 2 ] = read_adc ( adc_instance ) ; <S2SV_EndBug> <S2SV_StartBug> configure_adc ( & adc_instance , P_AI_LFB2OSNS ) ; <S2SV_EndBug> <S2SV_StartBug> batch [ 3 ] = read_adc ( adc_instance ) ; <S2SV_EndBug> } | <S2SV_ModStart> batch ) { struct adc_module adc_instance1 ; struct adc_module adc_instance2 ; struct adc_module adc_instance3 ; struct adc_module adc_instance4 ; <S2SV_ModStart> configure_adc ( & adc_instance1 <S2SV_ModEnd> , P_AI_LFB1SNS ) <S2SV_ModStart> = read_adc ( adc_instance1 <S2SV_ModEnd> ) ; configure_adc <S2SV_ModStart> configure_adc ( & adc_instance2 <S2SV_ModEnd> , P_AI_LFB1OSNS ) <S2SV_ModStart> = read_adc ( adc_instance2 <S2SV_ModEnd> ) ; configure_adc <S2SV_ModStart> configure_adc ( & adc_instance3 <S2SV_ModEnd> , P_AI_LFB2SNS ) <S2SV_ModStart> = read_adc ( adc_instance3 <S2SV_ModEnd> ) ; configure_adc <S2SV_ModStart> configure_adc ( & adc_instance4 <S2SV_ModEnd> , P_AI_LFB2OSNS ) <S2SV_ModStart> = read_adc ( adc_instance4 <S2SV_ModEnd> ) ; } |
5,320 | CWE-000 void cdate_str ( t_cdate * cdate ) { char str0 [ 64 ] ; <S2SV_StartBug> char str1 [ 64 ] ; <S2SV_EndBug> printf ( normal ) ; memset ( str0 , '\\0' , sizeof ( str0 ) ) ; memset ( str1 , '\\0' , sizeof ( str1 ) ) ; strftime ( str0 , sizeof ( str0 ) , cdate_fmt0 , cdate -> tm ) ; strftime ( str1 , sizeof ( str1 ) , cdate_fmt1 , cdate -> tm ) ; putchar ( '\\n' ) ; <S2SV_StartBug> printf ( active ) ; <S2SV_EndBug> printf ( "%*s\\n" , ( int ) strlen ( str0 ) + 3 , str0 ) ; printf ( "%*s\\n" , ( int ) strlen ( str1 ) + 3 , str1 ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> [ 64 ] <S2SV_ModEnd> ; memset ( <S2SV_ModStart> ; printf ( normal <S2SV_ModEnd> ) ; printf <S2SV_ModStart> str1 ) ; printf ( RESET ) ; |
5,321 | CWE-000 int comdb2_shard_table_constraints ( Parse * pParser , const char * zName , const char * zDatabase , Expr * * pWhere ) { GET_CLNT ; struct dbtable * db ; int idx = clnt -> conns_idx ; Expr * pExprLeft , * pExprRight , * pExpr ; struct Table * pTab ; if ( ! clnt -> conns ) { return SHARD_NOERR ; } db = get_dbtable_by_name ( zName ) ; if ( ! db ) return SHARD_NOERR ; if ( ! db -> sharding ) return SHARD_NOERR ; pTab = sqlite3FindTableCheckOnly ( pParser -> db , db -> tablename , "main" ) ; # if 0 if ( idx > 0 ) { pExprLeft = sqlite3PExpr ( pParse , TK_GE , sqlite3ExprAlloc ( pParse -> db , TK_COLUMN , & tok , 0 ) , <S2SV_StartBug> sqlite3ExprDup ( pParse -> db , db -> shards [ 0 ] -> limits -> a [ idx - 1 ] . pExpr , 0 ) , <S2SV_EndBug> 0 ) ; <S2SV_StartBug> pExprLeft -> pLeft -> pTab = pTab ; <S2SV_EndBug> } else { pExprLeft = NULL ; } if ( idx < db -> shards [ 0 ] -> limits -> nExpr ) { pExprRight = sqlite3PExpr ( pParse , TK_LT , sqlite3ExprAlloc ( pParse -> db , TK_COLUMN , & tok , 0 ) , <S2SV_StartBug> sqlite3ExprDup ( pParse -> db , db -> shards [ 0 ] -> limits -> a [ idx ] . pExpr , 0 ) , <S2SV_EndBug> 0 ) ; <S2SV_StartBug> pExprRight -> pLeft -> pTab = pTab ; <S2SV_EndBug> } else { pExprRight = NULL ; } # endif if ( db -> sharding -> low [ idx - 1 ] ) { pExprLeft = sqlite3ExprDup ( pParser -> db , db -> sharding -> low [ idx - 1 ] , 0 ) ; <S2SV_StartBug> pExprLeft -> pLeft -> pTab = pTab ; <S2SV_EndBug> } else { pExprLeft = NULL ; } if ( db -> sharding -> high [ idx - 1 ] ) { pExprRight = sqlite3ExprDup ( pParser -> db , db -> sharding -> high [ idx - 1 ] , 0 ) ; <S2SV_StartBug> pExprRight -> pLeft -> pTab = pTab ; <S2SV_EndBug> } else { pExprRight = NULL ; } if ( pExprLeft ) { if ( pExprRight ) { <S2SV_StartBug> pExprRight -> pLeft -> pTab = pTab ; <S2SV_EndBug> <S2SV_StartBug> pExpr = sqlite3PExpr ( pParser , TK_AND , pExprLeft , pExprRight , 0 ) ; <S2SV_EndBug> } else { pExpr = pExprLeft ; } } else { assert ( pExprRight ) ; pExpr = pExprRight ; } <S2SV_StartBug> * pWhere = sqlite3PExpr ( pParser , TK_AND , * pWhere , pExpr , 0 ) ; <S2SV_EndBug> return SHARD_NOERR_DONE ; } | <S2SV_ModStart> , 0 ) <S2SV_ModEnd> ) ; pExprLeft <S2SV_ModStart> -> pLeft -> y . <S2SV_ModStart> , 0 ) <S2SV_ModEnd> ) ; pExprRight <S2SV_ModStart> -> pLeft -> y . <S2SV_ModStart> -> pLeft -> y . <S2SV_ModStart> -> pLeft -> y . <S2SV_ModStart> -> pLeft -> y . <S2SV_ModStart> pExprLeft , pExprRight <S2SV_ModEnd> ) ; } <S2SV_ModStart> pWhere , pExpr <S2SV_ModEnd> ) ; return |
5,322 | CWE-000 int main ( int argc , char * * argv ) { int i , N ; _cleanup_globfree_ glob_t g = { } ; char * * fnames ; log_parse_environment ( ) ; if ( argc >= 2 ) { N = argc - 1 ; fnames = argv + 1 ; } else { <S2SV_StartBug> assert_se ( glob ( TEST_DIR "/test-resolve/*.pkts" , GLOB_NOSORT , NULL , & g ) == 0 ) ; <S2SV_EndBug> N = g . gl_pathc ; fnames = g . gl_pathv ; } for ( i = 0 ; i < N ; i ++ ) { test_packet_from_file ( fnames [ i ] , false ) ; puts ( "" ) ; test_packet_from_file ( fnames [ i ] , true ) ; if ( i + 1 < N ) puts ( "" ) ; } return EXIT_SUCCESS ; } | <S2SV_ModStart> ( glob ( TEST_DATA_DIR ( "/test-resolve/*.pkts" ) <S2SV_ModEnd> , GLOB_NOSORT , |
5,323 | CWE-000 static void config_tab_behavior ( GtkWidget * notebook ) { GtkWidget * hbox ; GtkWidget * vbox ; GtkWidget * group ; GtkWidget * button ; GtkWidget * tabcomp ; GtkWidget * ct_button ; GtkWidget * spin ; <S2SV_StartBug> vbox = scrolled_notebook_page ( notebook , _ ( "Behavior" ) ) ; <S2SV_EndBug> group = pref_group_new ( vbox , FALSE , _ ( "Delete" ) , GTK_ORIENTATION_VERTICAL ) ; pref_checkbox_new_int ( group , _ ( "Confirm<S2SV_blank>file<S2SV_blank>delete" ) , options -> file_ops . confirm_delete , & c_options -> file_ops . confirm_delete ) ; pref_checkbox_new_int ( group , _ ( "Enable<S2SV_blank>Delete<S2SV_blank>key" ) , options -> file_ops . enable_delete_key , & c_options -> file_ops . enable_delete_key ) ; ct_button = pref_checkbox_new_int ( group , _ ( "Safe<S2SV_blank>delete" ) , options -> file_ops . safe_delete_enable , & c_options -> file_ops . safe_delete_enable ) ; hbox = pref_box_new ( group , FALSE , GTK_ORIENTATION_HORIZONTAL , PREF_PAD_SPACE ) ; pref_checkbox_link_sensitivity ( ct_button , hbox ) ; pref_spacer ( hbox , PREF_PAD_INDENT - PREF_PAD_SPACE ) ; pref_label_new ( hbox , _ ( "Folder:" ) ) ; tabcomp = tab_completion_new ( & safe_delete_path_entry , options -> file_ops . safe_delete_path , NULL , NULL ) ; tab_completion_add_select_button ( safe_delete_path_entry , NULL , TRUE ) ; gtk_box_pack_start ( GTK_BOX ( hbox ) , tabcomp , TRUE , TRUE , 0 ) ; gtk_widget_show ( tabcomp ) ; hbox = pref_box_new ( group , FALSE , GTK_ORIENTATION_HORIZONTAL , PREF_PAD_BUTTON_GAP ) ; pref_checkbox_link_sensitivity ( ct_button , hbox ) ; pref_spacer ( hbox , PREF_PAD_INDENT - PREF_PAD_GAP ) ; spin = pref_spin_new_int ( hbox , _ ( "Maximum<S2SV_blank>size:" ) , _ ( "MB" ) , 0 , 2048 , 1 , options -> file_ops . safe_delete_folder_maxsize , & c_options -> file_ops . safe_delete_folder_maxsize ) ; gtk_widget_set_tooltip_markup ( spin , _ ( "Set<S2SV_blank>to<S2SV_blank>0<S2SV_blank>for<S2SV_blank>unlimited<S2SV_blank>size" ) ) ; button = pref_button_new ( NULL , NULL , _ ( "View" ) , FALSE , G_CALLBACK ( safe_delete_view_cb ) , NULL ) ; gtk_box_pack_end ( GTK_BOX ( hbox ) , button , FALSE , FALSE , 0 ) ; gtk_widget_show ( button ) ; button = pref_button_new ( NULL , GTK_STOCK_CLEAR , NULL , FALSE , G_CALLBACK ( safe_delete_clear_cb ) , NULL ) ; gtk_box_pack_end ( GTK_BOX ( hbox ) , button , FALSE , FALSE , 0 ) ; gtk_widget_show ( button ) ; group = pref_group_new ( vbox , FALSE , _ ( "Behavior" ) , GTK_ORIENTATION_VERTICAL ) ; pref_checkbox_new_int ( group , _ ( "Descend<S2SV_blank>folders<S2SV_blank>in<S2SV_blank>tree<S2SV_blank>view" ) , options -> tree_descend_subdirs , & c_options -> tree_descend_subdirs ) ; pref_checkbox_new_int ( group , _ ( "In<S2SV_blank>place<S2SV_blank>renaming" ) , options -> file_ops . enable_in_place_rename , & c_options -> file_ops . enable_in_place_rename ) ; pref_checkbox_new_int ( group , _ ( "List<S2SV_blank>directory<S2SV_blank>view<S2SV_blank>uses<S2SV_blank>single<S2SV_blank>click<S2SV_blank>to<S2SV_blank>enter" ) , options -> view_dir_list_single_click_enter , & c_options -> view_dir_list_single_click_enter ) ; pref_spin_new_int ( group , _ ( "Recent<S2SV_blank>folder<S2SV_blank>list<S2SV_blank>maximum<S2SV_blank>size" ) , NULL , 1 , 50 , 1 , options -> open_recent_list_maxsize , & c_options -> open_recent_list_maxsize ) ; pref_spin_new_int ( group , _ ( "Drag\'n<S2SV_blank>drop<S2SV_blank>icon<S2SV_blank>size" ) , NULL , 16 , 256 , 16 , options -> dnd_icon_size , & c_options -> dnd_icon_size ) ; group = pref_group_new ( vbox , FALSE , _ ( "Navigation" ) , GTK_ORIENTATION_VERTICAL ) ; pref_checkbox_new_int ( group , _ ( "Progressive<S2SV_blank>keyboard<S2SV_blank>scrolling" ) , options -> progressive_key_scrolling , & c_options -> progressive_key_scrolling ) ; pref_spin_new_int ( group , _ ( "Keyboard<S2SV_blank>scrolling<S2SV_blank>step<S2SV_blank>multiplier:" ) , NULL , 1 , 32 , 1 , options -> keyboard_scroll_step , ( int * ) & c_options -> keyboard_scroll_step ) ; pref_checkbox_new_int ( group , _ ( "Mouse<S2SV_blank>wheel<S2SV_blank>scrolls<S2SV_blank>image" ) , options -> mousewheel_scrolls , & c_options -> mousewheel_scrolls ) ; pref_checkbox_new_int ( group , _ ( "Navigation<S2SV_blank>by<S2SV_blank>left<S2SV_blank>or<S2SV_blank>middle<S2SV_blank>click<S2SV_blank>on<S2SV_blank>image" ) , options -> image_lm_click_nav , & c_options -> image_lm_click_nav ) ; <S2SV_StartBug> # ifdef DEBUG <S2SV_EndBug> group = pref_group_new ( vbox , FALSE , _ ( "Debugging" ) , GTK_ORIENTATION_VERTICAL ) ; pref_spin_new_int ( group , _ ( "Debug<S2SV_blank>level:" ) , NULL , DEBUG_LEVEL_MIN , DEBUG_LEVEL_MAX , 1 , get_debug_level ( ) , & debug_c ) ; pref_checkbox_new_int ( group , _ ( "Timer<S2SV_blank>data" ) , options -> log_window . timer_data , & c_options -> log_window . timer_data ) ; pref_spin_new_int ( group , _ ( "Log<S2SV_blank>Window<S2SV_blank>max.<S2SV_blank>lines:" ) , NULL , 1 , 99999 , 1 , options -> log_window_lines , & options -> log_window_lines ) ; # endif } | <S2SV_ModStart> * spin ; GtkWidget * table ; <S2SV_ModStart> image_lm_click_nav ) ; pref_checkbox_new_int ( group , _ ( "Play<S2SV_blank>video<S2SV_blank>by<S2SV_blank>left<S2SV_blank>click<S2SV_blank>on<S2SV_blank>image" ) , options -> image_l_click_video , & c_options -> image_l_click_video ) ; table = pref_table_new ( group , 2 , 1 , FALSE , FALSE ) ; add_video_menu ( table , 0 , 0 , _ ( "Play<S2SV_blank>with:" ) , options -> image_l_click_video_editor , & c_options -> image_l_click_video_editor ) ; |
5,324 | CWE-000 ngx_int_t ngx_http_vhost_traffic_status_node_time_queue_push ( ngx_http_vhost_traffic_status_node_time_queue_t * q , ngx_msec_int_t x ) { if ( ( q -> rear + 1 ) % q -> len == q -> front ) { return NGX_ERROR ; } <S2SV_StartBug> q -> times [ q -> rear ] . time = ngx_current_msec ; <S2SV_EndBug> q -> times [ q -> rear ] . msec = x ; q -> rear = ( q -> rear + 1 ) % q -> len ; return NGX_OK ; } | <S2SV_ModStart> . time = ngx_http_vhost_traffic_status_current_msec ( ) <S2SV_ModEnd> ; q -> |
5,325 | CWE-000 static uint8_t _event_loop_scrsvr_on_timeout ( struct Txcb * pxcb , struct Teventstate * peventstate ) { <S2SV_StartBug> if ( ! operation_handler ( OPERATION_GETBRIGHTNESS , pxcb , 0 , & peventstate -> brn_old_perc , & peventstate -> brn_cur_perc ) ) { <S2SV_EndBug> ERROR ( "Error:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>brightness<S2SV_blank>on<S2SV_blank>screensaver<S2SV_blank>timeout.<S2SV_blank>Exiting.\\n" ) ; return EXIT_FAILURE ; } if ( peventstate -> brn_cur_perc == 0 ) { DEBUG ( "[eventloop]<S2SV_blank>brightness<S2SV_blank>is<S2SV_blank>0%%<S2SV_blank>on<S2SV_blank>timeout,<S2SV_blank>setting<S2SV_blank>100%%<S2SV_blank>brightness\\n" ) ; if ( ! operation_handler ( OPERATION_SETBRIGHTNESS , pxcb , 100 , & peventstate -> brn_old_perc , & peventstate -> brn_cur_perc ) ) { ERROR ( "Error:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>initial<S2SV_blank>brightness<S2SV_blank>to<S2SV_blank>100%%<S2SV_blank>on<S2SV_blank>screensaver<S2SV_blank>timeout.<S2SV_blank>Exiting.\\n" ) ; return EXIT_FAILURE ; } DEBUG ( "[eventloop]<S2SV_blank>backlight<S2SV_blank>reports<S2SV_blank>brightness<S2SV_blank>%d%%<S2SV_blank>set\\n" , peventstate -> brn_cur_perc ) ; if ( peventstate -> brn_cur_perc == 0 ) { DEBUG ( "[eventloop]<S2SV_blank>brightness<S2SV_blank>is<S2SV_blank>still<S2SV_blank>0%%,<S2SV_blank>setting<S2SV_blank>100%%<S2SV_blank>brightness\\n" ) ; if ( ! operation_handler ( OPERATION_SETBRIGHTNESS , pxcb , 100 , & peventstate -> brn_old_perc , & peventstate -> brn_cur_perc ) ) { ERROR ( "Error:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>brightness<S2SV_blank>to<S2SV_blank>100%%<S2SV_blank>on<S2SV_blank>screensaver<S2SV_blank>timeout<S2SV_blank>again.<S2SV_blank>Exiting.\\n" ) ; return EXIT_FAILURE ; } DEBUG ( "[eventloop]<S2SV_blank>backlight<S2SV_blank>reports<S2SV_blank>brightness<S2SV_blank>%d%%<S2SV_blank>set\\n" , peventstate -> brn_cur_perc ) ; } } if ( peventstate -> brn_cur_perc < DIM_PERCENT_TIMEOUT ) { DEBUG ( "[eventloop]<S2SV_blank>current<S2SV_blank>brightness<S2SV_blank>%d%%<S2SV_blank>is<S2SV_blank>below<S2SV_blank>target<S2SV_blank>brightness<S2SV_blank>of<S2SV_blank>%d%%,<S2SV_blank>doing<S2SV_blank>nothing.\\n" , peventstate -> brn_cur_perc , DIM_PERCENT_TIMEOUT ) ; return RET_OK ; } <S2SV_StartBug> if ( ! operation_handler ( OPERATION_SETBRIGHTNESS , pxcb , DIM_PERCENT_TIMEOUT , & peventstate -> brn_priorscrsvr_perc , & peventstate -> brn_cur_perc ) ) { <S2SV_EndBug> ERROR ( "Error:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>decrease<S2SV_blank>brightness<S2SV_blank>on<S2SV_blank>screensaver<S2SV_blank>timeout.<S2SV_blank>Exiting.\\n" ) ; return EXIT_FAILURE ; } DEBUG ( "[eventloop]<S2SV_blank>brightness<S2SV_blank>%d%%<S2SV_blank>-><S2SV_blank>%d%%\\n" , peventstate -> brn_priorscrsvr_perc , peventstate -> brn_cur_perc ) ; return RET_OK ; } | <S2SV_ModStart> & peventstate -> brn_priorscrsvr_perc <S2SV_ModEnd> , & peventstate <S2SV_ModStart> & peventstate -> brn_old_perc , & peventstate -> brn_cur_perc ) ) { ERROR ( "Error:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>decrease<S2SV_blank>brightness<S2SV_blank>on<S2SV_blank>screensaver<S2SV_blank>timeout.<S2SV_blank>Exiting.\\n" ) ; return EXIT_FAILURE ; } DEBUG ( "[eventloop]<S2SV_blank>brightness<S2SV_blank>%d%%<S2SV_blank>-><S2SV_blank>%d%%\\n" , peventstate -> brn_priorscrsvr_perc , <S2SV_ModEnd> peventstate -> brn_cur_perc |
5,326 | CWE-000 int RedisModule_OnLoad ( RedisModuleCtx * ctx , RedisModuleString * * argv , int argc ) { if ( RedisModule_Init ( ctx , "ft" , REDISEARCH_MODULE_VERSION , REDISMODULE_APIVER_1 ) == REDISMODULE_ERR ) return REDISMODULE_ERR ; Extensions_Init ( ) ; ConcurrentSearch_ThreadPoolStart ( ) ; if ( argc > 0 && RMUtil_ArgIndex ( "EXTLOAD" , argv , argc ) >= 0 ) { const char * ext = NULL ; RMUtil_ParseArgsAfter ( "EXTLOAD" , argv , argc , "c" , & ext ) ; if ( ext ) { char * errMsg = NULL ; if ( Extension_LoadDynamic ( ext , & errMsg ) == REDISMODULE_ERR ) { RedisModule_Log ( ctx , "warning" , "Could<S2SV_blank>not<S2SV_blank>load<S2SV_blank>extension<S2SV_blank>%s:<S2SV_blank>%s" , ext , errMsg ) ; free ( errMsg ) ; return REDISMODULE_ERR ; } RedisModule_Log ( ctx , "notice" , "Loaded<S2SV_blank>RediSearch<S2SV_blank>extension<S2SV_blank>\'%s\'" , ext ) ; } } if ( Extension_Load ( "DEFAULT" , DefaultExtensionInit ) == REDISEARCH_ERR ) { RedisModule_Log ( ctx , "error" , "Could<S2SV_blank>not<S2SV_blank>register<S2SV_blank>default<S2SV_blank>extension" ) ; return REDISMODULE_ERR ; } if ( TrieType_Register ( ctx ) == REDISMODULE_ERR ) return REDISMODULE_ERR ; if ( IndexSpec_RegisterType ( ctx ) == REDISMODULE_ERR ) return REDISMODULE_ERR ; if ( InvertedIndex_RegisterType ( ctx ) == REDISMODULE_ERR ) return REDISMODULE_ERR ; if ( NumericIndexType_Register ( ctx ) == REDISMODULE_ERR ) return REDISMODULE_ERR ; if ( RedisModule_CreateCommand ( ctx , "ft.add" , AddDocumentCommand , "write<S2SV_blank>deny-oom" , 1 , 1 , 1 ) == REDISMODULE_ERR ) return REDISMODULE_ERR ; if ( RedisModule_CreateCommand ( ctx , "FT.SETPAYLOAD" , SetPayloadCommand , "write<S2SV_blank>deny-oom" , 1 , 1 , 1 ) == REDISMODULE_ERR ) return REDISMODULE_ERR ; if ( RedisModule_CreateCommand ( ctx , "ft.addhash" , AddHashCommand , "write<S2SV_blank>deny-oom" , 1 , 1 , 1 ) == REDISMODULE_ERR ) return REDISMODULE_ERR ; if ( RedisModule_CreateCommand ( ctx , "ft.dtadd" , DTAddCommand , "write<S2SV_blank>deny-oom" , 1 , 1 , 1 ) == REDISMODULE_ERR ) return REDISMODULE_ERR ; if ( RedisModule_CreateCommand ( ctx , "ft.del" , DeleteCommand , "write" , 1 , 1 , 1 ) == REDISMODULE_ERR ) return REDISMODULE_ERR ; if ( RedisModule_CreateCommand ( ctx , "ft.repair" , RepairCommand , "write" , 0 , 0 , - 1 ) == REDISMODULE_ERR ) return REDISMODULE_ERR ; if ( RedisModule_CreateCommand ( ctx , "ft.search" , SearchCommand , "readonly<S2SV_blank>deny-oom" , 1 , 1 , 1 ) == REDISMODULE_ERR ) return REDISMODULE_ERR ; if ( RedisModule_CreateCommand ( ctx , "ft.create" , CreateIndexCommand , "write" , 1 , 1 , 1 ) == REDISMODULE_ERR ) return REDISMODULE_ERR ; if ( RedisModule_CreateCommand ( ctx , "ft.optimize" , OptimizeIndexCommand , "write" , 1 , 1 , 1 ) == REDISMODULE_ERR ) return REDISMODULE_ERR ; if ( RedisModule_CreateCommand ( ctx , "ft.drop" , DropIndexCommand , "write" , 1 , 1 , 1 ) == REDISMODULE_ERR ) return REDISMODULE_ERR ; if ( RedisModule_CreateCommand ( ctx , "ft.info" , IndexInfoCommand , "readonly" , 1 , 1 , 1 ) == REDISMODULE_ERR ) return REDISMODULE_ERR ; if ( RedisModule_CreateCommand ( ctx , "ft.explain" , QueryExplainCommand , "readonly" , 1 , 1 , 1 ) == REDISMODULE_ERR ) return REDISMODULE_ERR ; if ( RedisModule_CreateCommand ( ctx , TRIE_ADD_CMD , SuggestAddCommand , "write<S2SV_blank>deny-oom" , 1 , 1 , 1 ) == REDISMODULE_ERR ) return REDISMODULE_ERR ; <S2SV_StartBug> if ( RedisModule_CreateCommand ( ctx , TRIE_ADD_AOF_CMD , TNAddCommand , "write<S2SV_blank>deny-oom" , 1 , 1 , 1 ) == <S2SV_EndBug> REDISMODULE_ERR ) return REDISMODULE_ERR ; if ( RedisModule_CreateCommand ( ctx , TRIE_DEL_CMD , SuggestDelCommand , "write" , 1 , 1 , 1 ) == REDISMODULE_ERR ) return REDISMODULE_ERR ; if ( RedisModule_CreateCommand ( ctx , TRIE_LEN_CMD , SuggestLenCommand , "readonly" , 1 , 1 , 1 ) == REDISMODULE_ERR ) return REDISMODULE_ERR ; if ( RedisModule_CreateCommand ( ctx , TRIE_SEARCH_CMD , SuggestGetCommand , "readonly" , 1 , 1 , 1 ) == REDISMODULE_ERR ) return REDISMODULE_ERR ; return REDISMODULE_OK ; } | <S2SV_ModStart> ( ctx , <S2SV_ModEnd> TRIE_DEL_CMD , SuggestDelCommand |
5,327 | CWE-000 int scanner ( ) { char tokn [ 9 ] = "" ; int tokenIndex = 0 ; int state = 0 ; char tmp [ 2 ] ; int column ; while ( state >= 0 && state < 1000 ) { state = FATable [ state ] [ column = filter ( ) ] ; <S2SV_StartBug> ch = getc ( fin ) ; <S2SV_EndBug> if ( state >= 0 && state < 1000 ) { if ( ! checkIfWhitespace ( ch ) && ! checkIfNewLine ( ch ) ) { tmp [ 0 ] = ch ; tokn [ tokenIndex ] = tmp [ 0 ] ; tokenIndex += 1 ; } } } if ( state >= 1000 ) { if ( state == 1000 ) { state = checkIfIdentifierIsKeyword ( tokn ) ; } Token * tok = NULL ; tok = tokenConstruct ( state , tokn , lineNum ) ; tokenPrint ( tok ) ; } if ( state == - 2 ) { fprintf ( stderr , "Error:<S2SV_blank>%d\\nCan\'t<S2SV_blank>begin<S2SV_blank>ID<S2SV_blank>with:<S2SV_blank>%c\\n" , state , ch ) ; exit ( 1 ) ; } if ( checkIfNewLine ( ch ) ) { <S2SV_StartBug> lineNum += 1 ; <S2SV_EndBug> } if ( checkIfEOF ( ch ) ) { Token * tok = NULL ; tok = tokenConstruct ( 1004 , tokn , - 1 ) ; tokenPrint ( tok ) ; } return 0 ; } | <S2SV_ModStart> getc ( fin ) ; printf ( "Character(c)<S2SV_blank>processed<S2SV_blank>by<S2SV_blank>filter:<S2SV_blank>%c\\n" , ch ) ; printf ( "Character(d)<S2SV_blank>processed<S2SV_blank>by<S2SV_blank>filter:<S2SV_blank>%d\\n" , ch <S2SV_ModStart> ) ) { printf ( "This<S2SV_blank>should<S2SV_blank>be<S2SV_blank>a<S2SV_blank>new<S2SV_blank>line:<S2SV_blank>%c\\n" , ch ) ; printf ( "This<S2SV_blank>should<S2SV_blank>be<S2SV_blank>a<S2SV_blank>new<S2SV_blank>line:<S2SV_blank>%d\\n" , ch ) ; |
5,328 | CWE-000 Runtime * getRuntimeOfThread ( Instance * jthread ) { Runtime * r = NULL ; <S2SV_StartBug> thread_lock ( & threadlist_lock ) ; <S2SV_EndBug> s32 i ; for ( i = 0 ; i < thread_list -> length ; i ++ ) { Runtime * rt = arraylist_get_value ( thread_list , i ) ; if ( rt -> threadInfo -> jthread == jthread ) r = rt ; } <S2SV_StartBug> thread_unlock ( & threadlist_lock ) ; <S2SV_EndBug> return r ; } | <S2SV_ModStart> = NULL ; garbage_thread_lock ( <S2SV_ModEnd> ) ; s32 <S2SV_ModStart> rt ; } garbage_thread_unlock ( <S2SV_ModEnd> ) ; return |
5,329 | CWE-000 static int aac_get_container_name ( struct scsi_cmnd * scsicmd ) { int status ; struct aac_get_name * dinfo ; struct fib * cmd_fibcontext ; struct aac_dev * dev ; dev = ( struct aac_dev * ) scsicmd -> device -> host -> hostdata ; cmd_fibcontext = aac_fib_alloc_tag ( dev , scsicmd ) ; aac_fib_init ( cmd_fibcontext ) ; dinfo = ( struct aac_get_name * ) fib_data ( cmd_fibcontext ) ; <S2SV_StartBug> dinfo -> command = cpu_to_le32 ( VM_ContainerConfig ) ; <S2SV_EndBug> dinfo -> type = cpu_to_le32 ( CT_READ_NAME ) ; dinfo -> cid = cpu_to_le32 ( scmd_id ( scsicmd ) ) ; dinfo -> count = cpu_to_le32 ( sizeof ( ( ( struct aac_get_name_resp * ) NULL ) -> data ) ) ; status = aac_fib_send ( ContainerCommand , cmd_fibcontext , sizeof ( struct aac_get_name_resp ) , FsaNormal , 0 , 1 , ( fib_callback ) get_container_name_callback , ( void * ) scsicmd ) ; <S2SV_StartBug> if ( status == - EINPROGRESS ) { <S2SV_EndBug> scsicmd -> SCp . phase = AAC_OWNER_FIRMWARE ; return 0 ; <S2SV_StartBug> } <S2SV_EndBug> printk ( KERN_WARNING "aac_get_container_name:<S2SV_blank>aac_fib_send<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>status:<S2SV_blank>%d.\\n" , status ) ; aac_fib_complete ( cmd_fibcontext ) ; return - 1 ; } | <S2SV_ModStart> cmd_fibcontext ) ; scsicmd -> SCp . phase = AAC_OWNER_FIRMWARE ; <S2SV_ModStart> - EINPROGRESS ) <S2SV_ModEnd> return 0 ; <S2SV_ModStart> return 0 ; <S2SV_ModEnd> printk ( KERN_WARNING |
5,330 | CWE-000 __attribute__ ( ( nonnull ( 1 , 2 ) , nothrow ) ) void ez_pstat_ngram ( <S2SV_StartBug> pstat_ngram_t * restrict s , <S2SV_EndBug> unigram_t const vals [ ] , size_t nval , size_t n ) { <S2SV_StartBug> size_t vi , vj ; <S2SV_EndBug> init_pstat_ngram ( s ) ; for ( vi = 0 ; vi != nval - n ; vi += n ) { update_pstat_ngram ( s , vals + vi ) ; } finish_pstat_ngram ( s ) ; } | <S2SV_ModStart> void ez_pstat_ngram ( pstat_t * restrict stat <S2SV_ModEnd> , unigram_t const <S2SV_ModStart> vi , vj ; pstat_ngram_t s ; s . stat = stat |
5,331 | CWE-000 int pf_ll_octal ( long long num , char * flags , int mod ) { char space_type ; int p ; int num_length ; num_length = get_num_length ( num , OCTAL ) ; p = ( ft_strrchr ( flags , '#' ) ) ? 1 : 0 ; p = ( num == 0 ) ? 0 : p ; space_type = get_space_type ( flags ) ; if ( num < 0 ) <S2SV_StartBug> num_length = ( sizeof ( long long ) * 8 ) / 3 ; <S2SV_EndBug> if ( space_type == '<S2SV_blank>' || ! ( space_type ) ) num_length += nondec_print_spaces ( mod - num_length , OCTAL , p , 0 ) ; if ( space_type == '0' ) num_length += nondec_print_zeroes ( mod - num_length , OCTAL , p , 0 ) ; if ( p && space_type == '-' ) num_length += print_precision ( OCTAL , 0 ) ; ft_putbase ( num , OCTAL , sizeof ( long long ) * 8 , 0 ) ; if ( space_type == '-' ) print_spaces ( mod - num_length ) ; return ( mod > num_length ) ? mod : num_length ; } | <S2SV_ModStart> ) / 3 + 1 |
5,332 | CWE-000 SEXP R_custom_data_access ( SEXP R_adios_data , SEXP R_adios_selection , SEXP R_adios_var_info ) { void * adios_data ; adios_data = R_ExternalPtrAddr ( R_adios_data ) ; ADIOS_SELECTION * adios_selection ; adios_selection = R_ExternalPtrAddr ( R_adios_selection ) ; ADIOS_VARINFO * adios_var_info ; adios_var_info = R_ExternalPtrAddr ( R_adios_var_info ) ; uint64_t num_element = 1 ; enum ADIOS_DATATYPES data_type ; data_type = adios_var_info -> type ; SEXP R_custom_data_access_val ; for ( int pos = 0 ; pos < adios_var_info -> ndim ; pos ++ ) { num_element = num_element * adios_selection -> u . bb . count [ pos ] ; } switch ( data_type ) { case adios_integer : R_custom_data_access_val = PROTECT ( allocVector ( INTSXP , num_element ) ) ; int * data = ( int * ) adios_data ; for ( int i = 0 ; i < num_element ; i ++ ) { INTEGER ( R_custom_data_access_val ) [ i ] = * ( data + i ) ; } UNPROTECT ( 1 ) ; break ; case adios_real : R_custom_data_access_val = PROTECT ( allocVector ( REALSXP , num_element ) ) ; float * data = ( float * ) adios_data ; for ( int i = 0 ; i < num_element ; i ++ ) { REAL ( R_custom_data_access_val ) [ i ] = * ( data + i ) ; } UNPROTECT ( 1 ) ; break ; case adios_double : R_custom_data_access_val = PROTECT ( allocVector ( REALSXP , num_element ) ) ; <S2SV_StartBug> float * data = ( double * ) adios_data ; <S2SV_EndBug> for ( int i = 0 ; i < num_element ; i ++ ) { REAL ( R_custom_data_access_val ) [ i ] = * ( data + i ) ; } UNPROTECT ( 1 ) ; break ; case adios_string : break ; default : error ( "Error<S2SV_blank>found<S2SV_blank>in<S2SV_blank>R_custom_data_access\\n" ) ; } return R_custom_data_access_val ; } | <S2SV_ModStart> ) ) ; double <S2SV_ModEnd> * data = |
5,333 | CWE-000 bool ring_buffer_peek ( ring_buffer_t * rb , void * data , ring_buffer_size_t index ) { if ( ! ring_buffer_is_empty ( rb ) && ring_buffer_num_items ( rb ) > index ) { <S2SV_StartBug> const ring_buffer_size_t offset = ( rb -> tail + index & ( rb -> num_elem - 1 ) ) * rb -> size_elem ; <S2SV_EndBug> memcpy ( data , & ( ( ( uint8_t * ) rb -> buffer ) [ offset ] ) , rb -> size_elem ) ; return true ; } else { return false ; } } | <S2SV_ModStart> ) { const uint16_t <S2SV_ModEnd> offset = ( |
5,334 | CWE-000 static int gps_bind ( struct usb_configuration * c , struct usb_function * f ) { struct f_gps * dev = func_to_gps ( f ) ; struct usb_ep * ep ; struct usb_composite_dev * cdev = c -> cdev ; int ret = - ENODEV ; dev -> ifc_id = usb_interface_id ( c , f ) ; if ( dev -> ifc_id < 0 ) { pr_err ( "%s:<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>ifc<S2SV_blank>id,<S2SV_blank>err:%d" , __func__ , dev -> ifc_id ) ; return dev -> ifc_id ; } gps_interface_desc . bInterfaceNumber = dev -> ifc_id ; dev -> port . in = NULL ; dev -> port . out = NULL ; ep = usb_ep_autoconfig ( cdev -> gadget , & gps_fs_notify_desc ) ; if ( ! ep ) { pr_err ( "%s:<S2SV_blank>usb<S2SV_blank>epnotify<S2SV_blank>autoconfig<S2SV_blank>failed\\n" , __func__ ) ; ret = - ENODEV ; goto ep_auto_notify_fail ; } dev -> notify = ep ; ep -> driver_data = cdev ; dev -> notify_req = gps_alloc_req ( ep , sizeof ( struct usb_cdc_notification ) , GFP_KERNEL ) ; if ( IS_ERR ( dev -> notify_req ) ) { pr_err ( "%s:<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>notify<S2SV_blank>req\\n" , __func__ ) ; ret = - ENOMEM ; goto ep_notify_alloc_fail ; } dev -> notify_req -> complete = gps_notify_complete ; dev -> notify_req -> context = dev ; ret = - ENOMEM ; f -> fs_descriptors = usb_copy_descriptors ( gps_fs_function ) ; if ( ! f -> fs_descriptors ) goto fail ; if ( gadget_is_dualspeed ( cdev -> gadget ) ) { gps_hs_notify_desc . bEndpointAddress = gps_fs_notify_desc . bEndpointAddress ; f -> hs_descriptors = usb_copy_descriptors ( gps_hs_function ) ; if ( ! f -> hs_descriptors ) goto fail ; } if ( gadget_is_superspeed ( cdev -> gadget ) ) { gps_ss_notify_desc . bEndpointAddress = gps_fs_notify_desc . bEndpointAddress ; f -> ss_descriptors = usb_copy_descriptors ( gps_ss_function ) ; if ( ! f -> ss_descriptors ) goto fail ; } pr_info ( "%s:<S2SV_blank>GPS(%d)<S2SV_blank>%s<S2SV_blank>Speed\\n" , __func__ , dev -> port_num , gadget_is_dualspeed ( cdev -> gadget ) ? "dual" : "full" ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> fail : if ( f -> ss_descriptors ) usb_free_descriptors ( f -> ss_descriptors ) ; if ( f -> hs_descriptors ) usb_free_descriptors ( f -> hs_descriptors ) ; if ( f -> fs_descriptors ) usb_free_descriptors ( f -> fs_descriptors ) ; if ( dev -> notify_req ) gps_free_req ( dev -> notify , dev -> notify_req ) ; ep_notify_alloc_fail : dev -> notify -> driver_data = NULL ; dev -> notify = NULL ; ep_auto_notify_fail : return ret ; } | <S2SV_ModStart> "full" ) ; INIT_DELAYED_WORK ( & dev -> wakeup_work , gps_remote_wakeup_work ) ; |
5,335 | CWE-000 void function_call_expression ( linked_list * * tokens , expression * * output ) { unsigned int num_args ; unsigned int i ; unsigned int parentheses_count ; unsigned int braces_count ; linked_list * temp_tokens ; expression * * args ; token current_token ; temp_tokens = * tokens ; current_token = * ( ( token * ) temp_tokens -> value ) ; parentheses_count = 0 ; braces_count = 0 ; if ( current_token . type == CLOSE_PARENTHESES ) { num_args = 0 ; } else { num_args = 1 ; <S2SV_StartBug> while ( current_token . type != CLOSE_PARENTHESES || parentheses_count ) { <S2SV_EndBug> if ( current_token . type == OPEN_PARENTHESES ) { parentheses_count ++ ; } else if ( current_token . type == CLOSE_PARENTHESES ) { parentheses_count -- ; } else if ( current_token . type == OPEN_BRACES ) { braces_count ++ ; } else if ( current_token . type == CLOSE_BRACES ) { braces_count -- ; } else if ( current_token . type == COMMA && ! parentheses_count && ! braces_count ) { num_args ++ ; } temp_tokens = temp_tokens -> next ; current_token = * ( ( token * ) temp_tokens -> value ) ; } } args = malloc ( sizeof ( expression * ) * num_args ) ; for ( i = 0 ; i < num_args ; i ++ ) { args [ i ] = build_expression ( tokens ) ; } <S2SV_StartBug> ( * output ) -> args = args ; <S2SV_EndBug> ( * output ) -> num_args = num_args ; add_expression ( output ) ; } | <S2SV_ModStart> CLOSE_PARENTHESES || parentheses_count || braces_count <S2SV_ModStart> ) ; } if ( num_args == 0 ) { * tokens = ( * tokens ) -> next ; } |
5,336 | CWE-000 int lua_git_blame_buffer ( lua_State * L ) { luagit2_blame * lua_blame ; const luagit2_blame * reference = ( luagit2_blame * ) lua_touserdata ( L , 1 ) ; const char * buffer = luaL_checkstring ( L , 2 ) ; size_t buffer_len = luaL_checkinteger ( L , 3 ) ; lua_blame = ( luagit2_blame * ) lua_newuserdata ( L , sizeof ( * lua_blame ) ) ; lua_blame -> blame = NULL ; luaL_newmetatable ( L , "luagit2_blame" ) ; lua_setmetatable ( L , - 2 ) ; git_blame * local_blame ; check_error_long ( git_blame_buffer ( & local_blame , reference -> blame , buffer , buffer_len ) , "Error<S2SV_blank>in<S2SV_blank>generating<S2SV_blank>blame<S2SV_blank>buffer" , NULL ) ; lua_blame -> blame = local_blame ; <S2SV_StartBug> git_blame_free ( local_blame ) ; <S2SV_EndBug> return 1 ; } | <S2SV_ModStart> = local_blame ; <S2SV_ModEnd> return 1 ; |
5,337 | CWE-000 static void usb_bam_work ( struct work_struct * w ) { int i ; struct usb_bam_event_info * event_info = container_of ( w , struct usb_bam_event_info , event_w ) ; struct usb_bam_pipe_connect * pipe_connect = container_of ( event_info , struct usb_bam_pipe_connect , event ) ; struct usb_bam_pipe_connect * pipe_iter ; int ( * callback ) ( void * priv ) ; void * param = NULL ; switch ( event_info -> type ) { case USB_BAM_EVENT_WAKEUP : case USB_BAM_EVENT_WAKEUP_PIPE : pr_debug ( "%s<S2SV_blank>recieved<S2SV_blank>USB_BAM_EVENT_WAKEUP\\n" , __func__ ) ; if ( pipe_connect -> peer_bam == IPA_P_BAM && pipe_connect -> bam_mode == USB_BAM_HOST && info [ pipe_connect -> bam_type ] . cur_prod_state != IPA_RM_RESOURCE_GRANTED ) { wait_for_prod_granted ( pipe_connect -> bam_type ) ; } spin_lock ( & usb_bam_lock ) ; if ( pipe_connect -> bam_mode == USB_BAM_HOST ) usb_bam_resume_host ( pipe_connect -> bam_type ) ; spin_unlock ( & usb_bam_lock ) ; if ( event_info -> callback ) event_info -> callback ( event_info -> param ) ; spin_lock ( & usb_bam_lock ) ; if ( ctx . inactivity_timer_ms [ pipe_connect -> bam_type ] ) usb_bam_set_inactivity_timer ( pipe_connect -> bam_type ) ; spin_unlock ( & usb_bam_lock ) ; if ( pipe_connect -> bam_mode == USB_BAM_DEVICE ) { wait_for_prod_granted ( pipe_connect -> bam_type ) ; if ( pipe_connect -> start ) { pr_debug ( "%s:<S2SV_blank>Enqueue<S2SV_blank>PROD<S2SV_blank>transfer" , __func__ ) ; pipe_connect -> start ( pipe_connect -> start_stop_param , USB_TO_PEER_PERIPHERAL ) ; } } break ; case USB_BAM_EVENT_INACTIVITY : pr_debug ( "%s<S2SV_blank>recieved<S2SV_blank>USB_BAM_EVENT_INACTIVITY\\n" , __func__ ) ; callback = event_info -> callback ; param = event_info -> param ; spin_lock ( & usb_bam_lock ) ; for ( i = 0 ; i < ctx . max_connections ; i ++ ) { pipe_iter = & usb_bam_connections [ i ] ; if ( pipe_iter -> bam_type == pipe_connect -> bam_type && pipe_iter -> dir == PEER_PERIPHERAL_TO_USB && pipe_iter -> enabled ) { <S2SV_StartBug> pr_debug ( "%s:<S2SV_blank>Register<S2SV_blank>wakeup<S2SV_blank>on<S2SV_blank>pipe<S2SV_blank>%p\\n" , <S2SV_EndBug> __func__ , pipe_iter ) ; __usb_bam_register_wake_cb ( i , pipe_iter -> activity_notify , pipe_iter -> priv , false ) ; } } spin_unlock ( & usb_bam_lock ) ; if ( callback ) callback ( param ) ; wait_for_prod_release ( pipe_connect -> bam_type ) ; pr_debug ( "%s:<S2SV_blank>complete<S2SV_blank>wait<S2SV_blank>on<S2SV_blank>hsic<S2SV_blank>producer<S2SV_blank>s=%d\\n" , __func__ , info [ pipe_connect -> bam_type ] . cur_prod_state ) ; if ( host_info [ pipe_connect -> bam_type ] . dev && info [ pipe_connect -> bam_type ] . cur_cons_state == IPA_RM_RESOURCE_RELEASED && ! info [ pipe_connect -> bam_type ] . in_lpm ) { usb_bam_suspend_core ( pipe_connect -> bam_type , pipe_connect -> bam_mode , 1 ) ; } break ; default : pr_err ( "%s:<S2SV_blank>unknown<S2SV_blank>usb<S2SV_blank>bam<S2SV_blank>event<S2SV_blank>type<S2SV_blank>%d\\n" , __func__ , event_info -> type ) ; } } | <S2SV_ModStart> { pr_debug ( "%s:<S2SV_blank>Register<S2SV_blank>wakeup<S2SV_blank>on<S2SV_blank>pipe<S2SV_blank>%pK\\n" <S2SV_ModEnd> , __func__ , |
5,338 | CWE-000 static void lift_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 ; } const float gain [ 3 ] = { p -> gain [ CHANNEL_RED ] , p -> gain [ CHANNEL_GREEN ] , p -> gain [ CHANNEL_BLUE ] } ; 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_lift [ c ] = RGB [ c ] ; <S2SV_EndBug> <S2SV_StartBug> d -> color_patches_flags [ LIFT ] = 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 ] = grey - RGB [ c ] * gain [ c ] ; dt_prophotorgb_to_XYZ ( RGB , XYZ ) ; for ( int c = 0 ; c < 3 ; ++ c ) RGB [ c ] = ( RGB [ c ] - XYZ [ 1 ] ) + 1.0f ; p -> lift [ CHANNEL_RED ] = RGB [ 0 ] ; p -> lift [ CHANNEL_GREEN ] = RGB [ 1 ] ; p -> lift [ CHANNEL_BLUE ] = RGB [ 2 ] ; darktable . gui -> reset = 1 ; dt_bauhaus_slider_set_soft ( g -> lift_r , p -> lift [ CHANNEL_RED ] - 1.0f ) ; dt_bauhaus_slider_set_soft ( g -> lift_g , p -> lift [ CHANNEL_GREEN ] - 1.0f ) ; dt_bauhaus_slider_set_soft ( g -> lift_b , p -> lift [ CHANNEL_BLUE ] - 1.0f ) ; set_HSL_sliders ( g -> hue_lift , g -> sat_lift , p -> lift ) ; 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_lift [ <S2SV_ModStart> c ] ; g <S2SV_ModEnd> -> color_patches_flags [ |
5,339 | CWE-000 int _DkSendHandle ( PAL_HANDLE hdl , PAL_HANDLE cargo ) { struct hdl_header hdl_hdr ; void * hdl_data ; int ret = handle_serialize ( cargo , & hdl_data ) ; if ( ret < 0 ) <S2SV_StartBug> return ret ; <S2SV_EndBug> hdl_hdr . data_size = ret ; int fds [ MAX_FDS ] ; int nfds = 0 ; for ( int i = 0 ; i < MAX_FDS ; i ++ ) if ( HANDLE_HDR ( cargo ) -> flags & ( RFD ( i ) | WFD ( 1 ) ) ) { hdl_hdr . fds |= 1U << i ; fds [ nfds ++ ] = cargo -> generic . fds [ i ] ; } int ch = hdl -> process . cargo ; struct msghdr hdr ; struct cmsghdr * chdr ; struct iovec iov [ 1 ] ; iov [ 0 ] . iov_base = & hdl_hdr ; iov [ 0 ] . iov_len = sizeof ( struct hdl_header ) ; hdr . msg_name = NULL ; hdr . msg_namelen = 0 ; hdr . msg_iov = iov ; hdr . msg_iovlen = 1 ; hdr . msg_control = NULL ; hdr . msg_controllen = 0 ; hdr . msg_flags = 0 ; ret = INLINE_SYSCALL ( sendmsg , 3 , ch , & hdr , MSG_NOSIGNAL ) ; if ( IS_ERR ( ret ) ) { free ( hdl_data ) ; return - PAL_ERROR_DENIED ; } char cbuf [ sizeof ( struct cmsghdr ) + nfds * sizeof ( int ) ] ; iov [ 0 ] . iov_base = hdl_data ; iov [ 0 ] . iov_len = hdl_hdr . data_size ; hdr . msg_iov = iov ; hdr . msg_iovlen = 1 ; hdr . msg_control = cbuf ; hdr . msg_controllen = sizeof ( struct cmsghdr ) + sizeof ( int ) * nfds ; chdr = CMSG_FIRSTHDR ( & hdr ) ; chdr -> cmsg_level = SOL_SOCKET ; chdr -> cmsg_type = SCM_RIGHTS ; chdr -> cmsg_len = CMSG_LEN ( sizeof ( int ) * nfds ) ; memcpy ( CMSG_DATA ( chdr ) , fds , sizeof ( int ) * nfds ) ; hdr . msg_controllen = chdr -> cmsg_len ; ret = INLINE_SYSCALL ( sendmsg , 3 , ch , & hdr , 0 ) ; free ( hdl_data ) ; return IS_ERR ( ret ) ? - PAL_ERROR_DENIED : 0 ; } | <S2SV_ModStart> ) return ret ; hdl_hdr . fds = 0 |
5,340 | CWE-000 static int fwu_read_f34_v7_queries ( void ) { int retval ; unsigned char ii ; unsigned char base ; unsigned char index ; unsigned char offset ; unsigned char * ptable ; struct f34_v7_query_0 query_0 ; struct f34_v7_query_1_7 query_1_7 ; struct synaptics_rmi4_data * rmi4_data = fwu -> rmi4_data ; base = fwu -> f34_fd . query_base_addr ; retval = synaptics_rmi4_reg_read ( rmi4_data , base , query_0 . data , sizeof ( query_0 . data ) ) ; if ( retval < 0 ) { dev_err ( rmi4_data -> pdev -> dev . parent , "%s:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>query<S2SV_blank>0\\n" , __func__ ) ; return retval ; } offset = query_0 . subpacket_1_size + 1 ; retval = synaptics_rmi4_reg_read ( rmi4_data , base + offset , query_1_7 . data , sizeof ( query_1_7 . data ) ) ; if ( retval < 0 ) { dev_err ( rmi4_data -> pdev -> dev . parent , "%s:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>queries<S2SV_blank>1<S2SV_blank>to<S2SV_blank>7\\n" , __func__ ) ; return retval ; } fwu -> bootloader_id [ 0 ] = query_1_7 . bl_minor_revision ; fwu -> bootloader_id [ 1 ] = query_1_7 . bl_major_revision ; if ( fwu -> bootloader_id [ 1 ] == BL_V8 ) fwu -> bl_version = BL_V8 ; fwu -> block_size = query_1_7 . block_size_15_8 << 8 | query_1_7 . block_size_7_0 ; fwu -> flash_config_length = query_1_7 . flash_config_length_15_8 << 8 | query_1_7 . flash_config_length_7_0 ; fwu -> payload_length = query_1_7 . payload_length_15_8 << 8 | query_1_7 . payload_length_7_0 ; fwu -> off . flash_status = V7_FLASH_STATUS_OFFSET ; fwu -> off . partition_id = V7_PARTITION_ID_OFFSET ; fwu -> off . block_number = V7_BLOCK_NUMBER_OFFSET ; fwu -> off . transfer_length = V7_TRANSFER_LENGTH_OFFSET ; fwu -> off . flash_cmd = V7_COMMAND_OFFSET ; fwu -> off . payload = V7_PAYLOAD_OFFSET ; index = sizeof ( query_1_7 . data ) - V7_PARTITION_SUPPORT_BYTES ; fwu -> partitions = 0 ; for ( offset = 0 ; offset < V7_PARTITION_SUPPORT_BYTES ; offset ++ ) { for ( ii = 0 ; ii < 8 ; ii ++ ) { if ( query_1_7 . data [ index + offset ] & ( 1 << ii ) ) fwu -> partitions ++ ; } dev_dbg ( rmi4_data -> pdev -> dev . parent , "%s:<S2SV_blank>Supported<S2SV_blank>partitions:<S2SV_blank>0x%02x\\n" , __func__ , query_1_7 . data [ index + offset ] ) ; } fwu -> partition_table_bytes = fwu -> partitions * 8 + 2 ; ptable = kzalloc ( fwu -> partition_table_bytes , GFP_KERNEL ) ; if ( ! ptable ) { dev_err ( rmi4_data -> pdev -> dev . parent , "%s:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>alloc<S2SV_blank>mem<S2SV_blank>for<S2SV_blank>partition<S2SV_blank>table\\n" , __func__ ) ; return - ENOMEM ; } retval = fwu_read_f34_v7_partition_table ( ptable ) ; if ( retval < 0 ) { dev_err ( rmi4_data -> pdev -> dev . parent , "%s:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>partition<S2SV_blank>table\\n" , __func__ ) ; kfree ( ptable ) ; return retval ; } <S2SV_StartBug> fwu_parse_partition_table ( ptable , & fwu -> blkcount , & fwu -> phyaddr ) ; <S2SV_EndBug> if ( fwu -> blkcount . dp_config ) fwu -> flash_properties . has_disp_config = 1 ; else fwu -> flash_properties . has_disp_config = 0 ; if ( fwu -> blkcount . pm_config ) fwu -> flash_properties . has_pm_config = 1 ; else fwu -> flash_properties . has_pm_config = 0 ; if ( fwu -> blkcount . bl_config ) fwu -> flash_properties . has_bl_config = 1 ; else fwu -> flash_properties . has_bl_config = 0 ; if ( fwu -> blkcount . guest_code ) fwu -> has_guest_code = 1 ; else fwu -> has_guest_code = 0 ; kfree ( ptable ) ; return 0 ; } | <S2SV_ModStart> retval ; } if ( <S2SV_ModStart> ( ptable , fwu -> partition_table_bytes , <S2SV_ModStart> -> phyaddr ) ) { kfree ( ptable ) ; return - EINVAL ; } <S2SV_ModEnd> if ( fwu |
5,341 | CWE-000 static gboolean panel_add_device ( CcNetworkPanel * panel , NMDevice * device ) { GtkListStore * liststore_devices ; GtkTreeIter iter ; NMDeviceType type ; NetDevice * net_device ; CcNetworkPanelPrivate * priv = panel -> priv ; GtkNotebook * notebook ; GtkSizeGroup * size_group ; GType device_g_type ; const char * udi ; if ( ! nm_device_get_managed ( device ) ) goto out ; udi = nm_device_get_udi ( device ) ; if ( find_in_model_by_id ( panel , udi , NULL ) != NULL ) goto out ; if ( g_strrstr ( udi , "/virbr0" ) != NULL ) goto out ; if ( g_strrstr ( udi , "/tun0" ) != NULL ) goto out ; type = nm_device_get_device_type ( device ) ; g_debug ( "device<S2SV_blank>%s<S2SV_blank>type<S2SV_blank>%i<S2SV_blank>path<S2SV_blank>%s" , udi , type , nm_object_get_path ( NM_OBJECT ( device ) ) ) ; switch ( type ) { case NM_DEVICE_TYPE_ETHERNET : device_g_type = NET_TYPE_DEVICE_ETHERNET ; break ; case NM_DEVICE_TYPE_MODEM : device_g_type = NET_TYPE_DEVICE_MOBILE ; break ; case NM_DEVICE_TYPE_WIFI : device_g_type = NET_TYPE_DEVICE_WIFI ; break ; default : device_g_type = NET_TYPE_DEVICE_SIMPLE ; break ; } net_device = g_object_new ( device_g_type , "panel" , panel , "removable" , FALSE , "cancellable" , panel -> priv -> cancellable , "client" , panel -> priv -> client , "nm-device" , device , "id" , nm_device_get_udi ( device ) , NULL ) ; if ( type == NM_DEVICE_TYPE_MODEM && g_str_has_prefix ( nm_device_get_udi ( device ) , "/org/freedesktop/ModemManager1/Modem/" ) ) { GDBusObject * modem_object ; if ( priv -> modem_manager == NULL ) { g_warning ( "Cannot<S2SV_blank>grab<S2SV_blank>information<S2SV_blank>for<S2SV_blank>modem<S2SV_blank>at<S2SV_blank>%s:<S2SV_blank>No<S2SV_blank>ModemManager<S2SV_blank>support" , nm_device_get_udi ( device ) ) ; goto out ; } modem_object = g_dbus_object_manager_get_object ( G_DBUS_OBJECT_MANAGER ( priv -> modem_manager ) , nm_device_get_udi ( device ) ) ; if ( modem_object == NULL ) { g_warning ( "Cannot<S2SV_blank>grab<S2SV_blank>information<S2SV_blank>for<S2SV_blank>modem<S2SV_blank>at<S2SV_blank>%s:<S2SV_blank>Not<S2SV_blank>found" , nm_device_get_udi ( device ) ) ; goto out ; } g_object_set ( net_device , "mm-object" , modem_object , NULL ) ; g_object_unref ( modem_object ) ; } if ( device_g_type != NET_TYPE_DEVICE ) { notebook = GTK_NOTEBOOK ( gtk_builder_get_object ( panel -> priv -> builder , "notebook_types" ) ) ; size_group = GTK_SIZE_GROUP ( gtk_builder_get_object ( panel -> priv -> builder , "sizegroup1" ) ) ; net_object_add_to_notebook ( NET_OBJECT ( net_device ) , notebook , size_group ) ; } liststore_devices = GTK_LIST_STORE ( gtk_builder_get_object ( priv -> builder , "liststore_devices" ) ) ; g_signal_connect_object ( net_device , "removed" , G_CALLBACK ( object_removed_cb ) , panel , 0 ) ; gtk_list_store_append ( liststore_devices , & iter ) ; gtk_list_store_set ( liststore_devices , & iter , PANEL_DEVICES_COLUMN_ICON , panel_device_to_icon_name ( device , TRUE ) , <S2SV_StartBug> PANEL_DEVICES_COLUMN_SORT , panel_device_to_sortable_string ( device ) , <S2SV_EndBug> PANEL_DEVICES_COLUMN_OBJECT , net_device , - 1 ) ; g_signal_connect ( net_device , "notify::title" , G_CALLBACK ( panel_net_object_notify_title_cb ) , panel ) ; g_object_unref ( net_device ) ; g_signal_connect ( device , "state-changed" , G_CALLBACK ( state_changed_cb ) , panel ) ; out : return FALSE ; } | <S2SV_ModStart> TRUE ) , <S2SV_ModEnd> PANEL_DEVICES_COLUMN_OBJECT , net_device |
5,342 | CWE-000 gboolean cfg_process_flag ( CfgFlagHandler * handlers , gpointer base , const gchar * flag_ ) { gint h ; gchar flag [ 32 ] ; for ( h = 0 ; flag_ [ h ] && h < sizeof ( flag ) ; h ++ ) { if ( flag_ [ h ] == '_' ) flag [ h ] = '-' ; else flag [ h ] = flag_ [ h ] ; } flag [ h ] = 0 ; for ( h = 0 ; handlers [ h ] . name ; h ++ ) { CfgFlagHandler * handler = & handlers [ h ] ; if ( strcmp ( handlers [ h ] . name , flag ) == 0 ) { guint32 * field = ( ( guint32 * ) ( ( ( gchar * ) base ) + handler -> ofs ) ) ; switch ( handler -> op ) { case CFH_SET : if ( handler -> mask ) * field = ( ( * field ) & ~ handler -> mask ) | handler -> param ; else * field = ( * field ) | handler -> param ; return TRUE ; case CFH_CLEAR : if ( handler -> mask ) * field = ( * field ) & ~ handler -> mask ; else * field = ( * field ) & ~ handler -> param ; return TRUE ; <S2SV_StartBug> } <S2SV_EndBug> } } return FALSE ; } | <S2SV_ModStart> return TRUE ; default : g_assert_not_reached ( ) ; break ; |
5,343 | CWE-000 static bool spapr_drc_needed ( void * opaque ) { sPAPRDRConnector * drc = ( sPAPRDRConnector * ) opaque ; sPAPRDRConnectorClass * drck = SPAPR_DR_CONNECTOR_GET_CLASS ( drc ) ; bool rc = false ; sPAPRDREntitySense value ; drck -> entity_sense ( drc , & value ) ; if ( value != SPAPR_DR_ENTITY_SENSE_PRESENT ) { return false ; } switch ( drc -> type ) { case SPAPR_DR_CONNECTOR_TYPE_PCI : <S2SV_StartBug> rc = ! ( ( drc -> isolation_state == SPAPR_DR_ISOLATION_STATE_UNISOLATED ) && <S2SV_EndBug> ( drc -> allocation_state == SPAPR_DR_ALLOCATION_STATE_USABLE ) && drc -> configured && drc -> signalled && ! drc -> awaiting_release ) ; break ; <S2SV_StartBug> case SPAPR_DR_CONNECTOR_TYPE_CPU : <S2SV_EndBug> case SPAPR_DR_CONNECTOR_TYPE_LMB : rc = ! ( ( drc -> isolation_state == SPAPR_DR_ISOLATION_STATE_ISOLATED ) && ( drc -> allocation_state == SPAPR_DR_ALLOCATION_STATE_UNUSABLE ) && drc -> configured && drc -> signalled && ! drc -> awaiting_release ) ; break ; case SPAPR_DR_CONNECTOR_TYPE_PHB : case SPAPR_DR_CONNECTOR_TYPE_VIO : default : <S2SV_StartBug> g_assert ( false ) ; <S2SV_EndBug> } return rc ; } | <S2SV_ModStart> case SPAPR_DR_CONNECTOR_TYPE_PCI : case SPAPR_DR_CONNECTOR_TYPE_CPU : case SPAPR_DR_CONNECTOR_TYPE_LMB : <S2SV_ModStart> break ; case <S2SV_ModEnd> SPAPR_DR_CONNECTOR_TYPE_PHB : case <S2SV_ModStart> : default : g_assert_not_reached ( <S2SV_ModEnd> ) ; } |
5,344 | CWE-000 void sim_model ( double * envar , double * par , int * finalT , int * control , double * result , int * success ) { param = par ; double * controlpar = 0 ; if ( ( * control ) ) { controlpar = param + NumPar ; } double * mean_air_temp = envar + 0 * ( * finalT ) ; ; double * daily_humidity = envar + 1 * ( * finalT ) ; ; double * colT = result + 0 * ( * finalT ) ; ; double * colnvE = result + 1 * ( * finalT ) ; ; double * colnvL = result + 2 * ( * finalT ) ; ; double * colnvP = result + 3 * ( * finalT ) ; ; double * colnvA = result + 4 * ( * finalT ) ; ; double * colnvAcap = result + 5 * ( * finalT ) ; ; int TIME = 0 ; ( * success ) = 2 ; int nvE = round ( param [ init_E ] ) ; int nvL = round ( param [ init_L ] ) ; int nvP = round ( param [ init_P ] ) ; int nvA = round ( param [ init_A ] ) ; int nvAcap = fun_capture ( & nvA , param ) ; spop pop_vecE = spop_init ( ) ; spop pop_vecL = spop_init ( ) ; spop pop_vecP = spop_init ( ) ; spop pop_vecA = spop_init ( ) ; if ( nvE > 0 ) spop_add ( pop_vecE , 0 , nvE ) ; if ( nvL > 0 ) spop_add ( pop_vecL , 0 , nvL ) ; if ( nvP > 0 ) spop_add ( pop_vecP , 0 , nvP ) ; if ( nvA > 0 ) spop_add ( pop_vecA , 0 , nvA ) ; colT [ TIME ] = ( double ) TIME ; colnvE [ TIME ] = ( double ) nvE ; colnvL [ TIME ] = ( double ) nvL ; colnvP [ TIME ] = ( double ) nvP ; colnvA [ TIME ] = ( double ) nvA ; colnvAcap [ TIME ] = ( double ) nvAcap ; for ( TIME = 1 ; TIME < ( * finalT ) ; TIME ++ ) { calculateSand ( mean_air_temp [ TIME - 1 ] , daily_humidity [ TIME - 1 ] , & pop_vecE , & pop_vecL , & pop_vecP , & pop_vecA , & nvE , & nvL , & nvP , & nvA , & nvAcap ) ; colT [ TIME ] = ( double ) TIME ; colnvE [ TIME ] = ( double ) nvE ; colnvL [ TIME ] = ( double ) nvL ; colnvP [ TIME ] = ( double ) nvP ; colnvA [ TIME ] = ( double ) nvA ; colnvAcap [ TIME ] = ( double ) nvAcap ; <S2SV_StartBug> if ( isnan ( colnvE [ TIME ] ) || isnan ( colnvL [ TIME ] ) || isnan ( colnvP [ TIME ] ) || isnan ( colnvA [ TIME ] ) || isnan ( colnvAcap [ TIME ] ) ) { <S2SV_EndBug> ( * success ) = 0 ; goto endall ; } } endall : ( * success ) = ( ( * success ) == 0 ) ? 0 : 1 ; spop_destroy ( & pop_vecE ) ; spop_destroy ( & pop_vecL ) ; spop_destroy ( & pop_vecP ) ; spop_destroy ( & pop_vecA ) ; gamma_dist_check ( ) ; } | <S2SV_ModStart> ; if ( CHECK ( nvE ) || CHECK ( nvL ) || CHECK ( nvP ) || CHECK ( nvA ) || CHECK ( nvAcap <S2SV_ModEnd> ) ) { |
5,345 | CWE-000 EXT_ID find_ext_id_head ( SYMBOL s , EXT_ID head ) { EXT_ID ep ; FOREACH_EXT_ID ( ep , head ) { <S2SV_StartBug> if ( strcmp ( SYM_NAME ( EXT_SYM ( ep ) ) , SYM_NAME ( s ) ) == 0 ) <S2SV_EndBug> return ep ; } return NULL ; } | <S2SV_ModStart> { if ( EXT_SYM ( ep ) && |
5,346 | CWE-000 int GetNPartFrames ( partdata * parti ) { FILE * stream ; char buffer [ 256 ] ; float time_local ; char * reg_file , * size_file ; int i ; int doit = 0 ; int stat_sizefile , stat_regfile ; STRUCTSTAT stat_sizefile_buffer , stat_regfile_buffer ; int nframes_all ; reg_file = parti -> reg_file ; size_file = parti -> size_file ; stat_sizefile = STAT ( size_file , & stat_sizefile_buffer ) ; stat_regfile = STAT ( reg_file , & stat_regfile_buffer ) ; if ( stat_regfile != 0 ) return - 1 ; if ( stat_regfile_buffer . st_size > parti -> reg_file_size ) { parti -> reg_file_size = stat_regfile_buffer . st_size ; doit = 1 ; } <S2SV_StartBug> if ( doit = 1 || stat_sizefile != 0 || stat_regfile_buffer . st_mtime > stat_sizefile_buffer . st_mtime ) { <S2SV_EndBug> int lenreg , lensize , error ; int angle_flag = 0 ; TrimBack ( reg_file ) ; TrimBack ( size_file ) ; lenreg = strlen ( reg_file ) ; lensize = strlen ( size_file ) ; if ( parti -> evac == 1 ) { angle_flag = 1 ; PRINTF ( "Sizing<S2SV_blank>evac<S2SV_blank>data:<S2SV_blank>%s\\n" , reg_file ) ; FORTfcreate_part5sizefile ( reg_file , size_file , & angle_flag , & redirect , & error , lenreg , lensize ) ; } else { angle_flag = 0 ; PRINTF ( "Sizing<S2SV_blank>particle<S2SV_blank>data:<S2SV_blank>%s\\n" , reg_file ) ; FORTfcreate_part5sizefile ( reg_file , size_file , & angle_flag , & redirect , & error , lenreg , lensize ) ; } } stream = fopen ( size_file , "r" ) ; if ( stream == NULL ) return - 1 ; nframes_all = 0 ; for ( ; ; ) { int exitloop ; if ( fgets ( buffer , 255 , stream ) == NULL ) break ; sscanf ( buffer , "%f" , & time_local ) ; exitloop = 0 ; for ( i = 0 ; i < parti -> nclasses ; i ++ ) { if ( fgets ( buffer , 255 , stream ) == NULL ) { exitloop = 1 ; break ; } } if ( exitloop == 1 ) break ; nframes_all ++ ; } fclose ( stream ) ; return nframes_all ; } | <S2SV_ModStart> if ( doit == <S2SV_ModEnd> 1 || stat_sizefile |
5,347 | CWE-000 <S2SV_StartBug> static void continue1 ( WIDNOW * win ) <S2SV_EndBug> { mvwaddstr ( win , 10 , 1 , "<S2SV_blank>Press<S2SV_blank>any<S2SV_blank>key<S2SV_blank>to<S2SV_blank>continue" ) ; wrefresh ( win ) ; raw ( ) ; wgetch ( win ) ; } | <S2SV_ModStart> void continue1 ( WINDOW <S2SV_ModEnd> * win ) |
5,348 | CWE-000 G_DEFINE_TYPE ( GepubArchive , gepub_archive , G_TYPE_OBJECT ) static gboolean gepub_archive_open ( GepubArchive * archive ) { <S2SV_StartBug> archive -> archive = archive_read_new ( ) ; <S2SV_EndBug> <S2SV_StartBug> archive_read_support_format_zip ( archive -> archive ) ; <S2SV_EndBug> int r ; r = archive_read_open_filename ( archive -> archive , archive -> path , 10240 ) ; if ( r != ARCHIVE_OK ) { archive_read_free ( archive -> archive ) ; return FALSE ; } return TRUE ; } | <S2SV_ModStart> archive ) { int r ; <S2SV_ModStart> -> archive ) <S2SV_ModEnd> ; r = |
5,349 | CWE-000 <S2SV_StartBug> int Run ( PCB * pcb , ConfigFile * config , PCBQueueNode * runningHead , <S2SV_EndBug> char * timeStr , char * logBuffer ) { MetaDataNode * current = pcb -> current ; Boolean toBeSetReady = False ; char * outputString = NodeToString ( current ) ; char toPrint [ MAX_LINE_LENGTH ] ; int cyclesToRun ; pthread_t ioThreads [ MAX_NUM_THREADS ] ; ioThreadData threadData ; AccessTimer ( GET_TIME_DIFF , timeStr ) ; snprintf ( toPrint , MAX_LINE_LENGTH , "Time:<S2SV_blank>%9s,<S2SV_blank>Process<S2SV_blank>%d,<S2SV_blank>%s<S2SV_blank>start\\n" , timeStr , pcb -> processID , outputString ) ; PrintWrapper ( toPrint , logBuffer , config -> logTo ) ; if ( current -> command == 'M' ) { } else if ( current -> command == 'I' || current -> command == 'O' ) { threadData . delay = current -> cycleTime * config -> ioCycleTime ; threadData . pcb = pcb ; pthread_create ( & ioThreads [ pcb -> processID ] , NULL , ( void * ) IOThreadFunction , ( void * ) & threadData ) ; if ( strcmp ( config -> schedulingCode , "FCFS-N" ) == 0 || strcmp ( config -> schedulingCode , "SJF-N" ) == 0 ) { pthread_join ( ioThreads [ pcb -> processID ] , NULL ) ; } else { return PROCESS_SET_BLOCKED ; } } else { if ( strcmp ( config -> schedulingCode , "RR-P" ) == 0 && current -> cycleTime > config -> quantumTime ) { cyclesToRun = config -> quantumTime ; toBeSetReady = True ; } else { cyclesToRun = current -> cycleTime ; } while ( cyclesToRun > 0 ) { Delay ( config -> pCycleTime ) ; current -> cycleTime -= 1 ; cyclesToRun -= 1 ; pcb -> remainingTime -= config -> pCycleTime ; } } AccessTimer ( GET_TIME_DIFF , timeStr ) ; snprintf ( toPrint , MAX_LINE_LENGTH , "Time:<S2SV_blank>%9s,<S2SV_blank>Process<S2SV_blank>%d,<S2SV_blank>%s<S2SV_blank>end\\n" , timeStr , pcb -> processID , outputString ) ; PrintWrapper ( toPrint , logBuffer , config -> logTo ) ; if ( toBeSetReady == True ) { return PROCESS_SET_READY ; } if ( current -> next -> cycleTime == - 1 ) { return PROCESS_FULLY_EXECUTED ; } pcb -> current = current -> next ; return 0 ; } | <S2SV_ModStart> ConfigFile * config <S2SV_ModEnd> , char * |
5,350 | CWE-000 TEST ( check_by_absolute_path_is_performed_beforehand ) { char name_a [ ] = "a" ; <S2SV_StartBug> char name_b [ PATH_MAX ] ; <S2SV_EndBug> char * names [ ] = { name_a , name_b } ; snprintf ( name_b , sizeof ( name_b ) , "%s/b" , lwin . curr_dir ) ; create_empty_dir ( name_b ) ; ( void ) fops_mkdirs ( & lwin , - 1 , names , 2 , 0 ) ; assert_failure ( rmdir ( SANDBOX_PATH "/a" ) ) ; assert_success ( rmdir ( SANDBOX_PATH "/b" ) ) ; } | <S2SV_ModStart> name_b [ PATH_MAX + 8 |
5,351 | CWE-000 static void put_matBSDF ( const char * XMLfile ) { const char * curdir = "./" ; if ( ! XMLfile ) { printf ( "\\n#<S2SV_blank>Simplified<S2SV_blank>material<S2SV_blank>because<S2SV_blank>we<S2SV_blank>have<S2SV_blank>no<S2SV_blank>XML<S2SV_blank>input\\n" ) ; printf ( "\\nvoid<S2SV_blank>brightfunc<S2SV_blank>latlong\\n2<S2SV_blank>latlong<S2SV_blank>bsdf2rad.cal\\n0\\n0\\n" ) ; if ( ( front_comp | back_comp ) & SDsampT ) printf ( "\\nlatlong<S2SV_blank>trans<S2SV_blank>%s\\n0\\n0\\n7<S2SV_blank>.75<S2SV_blank>.75<S2SV_blank>.75<S2SV_blank>0<S2SV_blank>.04<S2SV_blank>.5<S2SV_blank>.8\\n" , sph_mat ) ; else printf ( "\\nlatlong<S2SV_blank>plastic<S2SV_blank>%s\\n0\\n0\\n5<S2SV_blank>.5<S2SV_blank>.5<S2SV_blank>.5<S2SV_blank>0<S2SV_blank>0\\n" , sph_mat ) ; return ; } switch ( XMLfile [ 0 ] ) { case '.' : CASEDIRSEP : curdir = "" ; break ; case '\\0' : fprintf ( stderr , "%s:<S2SV_blank>empty<S2SV_blank>file<S2SV_blank>name<S2SV_blank>in<S2SV_blank>put_matBSDF\\n" , progname ) ; exit ( 1 ) ; break ; } printf ( "\\n#<S2SV_blank>Actual<S2SV_blank>BSDF<S2SV_blank>material<S2SV_blank>for<S2SV_blank>rendering<S2SV_blank>the<S2SV_blank>hemispheres\\n" ) ; <S2SV_StartBug> printf ( "\\nvoid<S2SV_blank>BSDF<S2SV_blank>BSDFmat\\n6<S2SV_blank>0<S2SV_blank>\\"%s%s\\"<S2SV_blank>0<S2SV_blank>1<S2SV_blank>0<S2SV_blank>.\\n0\\n0\\n" , <S2SV_EndBug> curdir , XMLfile ) ; printf ( "\\nvoid<S2SV_blank>plastic<S2SV_blank>black\\n0\\n0\\n5<S2SV_blank>0<S2SV_blank>0<S2SV_blank>0<S2SV_blank>0<S2SV_blank>0\\n" ) ; printf ( "\\nvoid<S2SV_blank>mixfunc<S2SV_blank>%s\\n4<S2SV_blank>BSDFmat<S2SV_blank>black<S2SV_blank>latlong<S2SV_blank>bsdf2rad.cal\\n0\\n0\\n" , sph_mat ) ; } | <S2SV_ModStart> ; printf ( "\\nvoid<S2SV_blank>BSDF<S2SV_blank>BSDFmat\\n6<S2SV_blank>0<S2SV_blank>\\"%s%s\\"<S2SV_blank>upx<S2SV_blank>upy<S2SV_blank>upz<S2SV_blank>bsdf2rad.cal\\n0\\n0\\n" <S2SV_ModEnd> , curdir , |
5,352 | CWE-000 void imap_capability_list_unref ( struct imap_capability_list * * capability_list ) { i_assert ( ( * capability_list ) -> refcount > 0 ) ; <S2SV_StartBug> * capability_list = NULL ; <S2SV_EndBug> <S2SV_StartBug> if ( -- ( * capability_list ) -> refcount > 0 ) <S2SV_EndBug> return ; pool_unref ( & ( * capability_list ) -> pool ) ; i_free ( * capability_list ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> 0 ) ; <S2SV_ModEnd> if ( -- <S2SV_ModStart> > 0 ) { * capability_list = NULL ; return ; } <S2SV_ModEnd> pool_unref ( & <S2SV_ModStart> capability_list ) ; * capability_list = NULL ; |
5,353 | CWE-000 void ft_raycast ( t_e * e ) { int i ; t_ray ray ; t_p map ; i = - 1 ; while ( ++ i < e -> width ) { ray_init ( e , & ray , & map , i ) ; cast_a_ray ( e , & ray , & map ) ; if ( ray . side == 0 || ray . side == 2 ) ray . wall_d = ( map . x - ray . pos . x + ( 1 - ray . step . x ) / 2 ) / ray . dir . x ; else ray . wall_d = ( map . y - ray . pos . y + ( 1 - ray . step . y ) / 2 ) / ray . dir . y ; <S2SV_StartBug> ray . l_height = ( int ) ( e -> height * 2 / ray . wall_d ) ; <S2SV_EndBug> ray . d_start = - ray . l_height / 2 + e -> height / 2 ; ray . d_end = ray . l_height / 2 + e -> height / 2 ; tex_put ( e , ray , map , i ) ; } } | <S2SV_ModStart> e -> height <S2SV_ModEnd> / ray . |
5,354 | CWE-000 int detach_device ( struct RD_PROFILE * rd_prof , RC_PROFILE * rc_prof , unsigned char * string ) { int err = - 1 ; FILE * fp ; unsigned char * buf ; while ( rd_prof != NULL ) { if ( strcmp ( string , rd_prof -> device ) == SUCCESS ) err = 0 ; rd_prof = rd_prof -> next ; } if ( err != 0 ) { printf ( "Error.<S2SV_blank>Device<S2SV_blank>%s<S2SV_blank>does<S2SV_blank>not<S2SV_blank>exist.\\n" , string ) ; return - 1 ; } while ( rc_prof != NULL ) { if ( strcmp ( string , rc_prof -> cache ) == SUCCESS ) { printf ( "Error.<S2SV_blank>Unable<S2SV_blank>to<S2SV_blank>remove<S2SV_blank>%s.\\nThis<S2SV_blank>RapidDisk<S2SV_blank>device<S2SV_blank>is<S2SV_blank>currently" "<S2SV_blank>mapped<S2SV_blank>as<S2SV_blank>a<S2SV_blank>cache<S2SV_blank>drive<S2SV_blank>to<S2SV_blank>%s.\\n\\n" , string , rc_prof -> device ) ; return - 1 ; } rc_prof = rc_prof -> next ; } <S2SV_StartBug> if ( ( buf = ( char * ) malloc ( BUFSZ ) ) == '\\0' ) { <S2SV_EndBug> printf ( "%s:<S2SV_blank>malloc:<S2SV_blank>Unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory.\\n" , __func__ ) ; return - 1 ; } if ( ( fp = fopen ( etc_mtab , "r" ) ) == NULL ) { printf ( "%s:<S2SV_blank>fopen:<S2SV_blank>%s:<S2SV_blank>%s\\n" , __func__ , etc_mtab , strerror ( errno ) ) ; return - ENOENT ; } fread ( buf , BUFSZ , 1 , fp ) ; fclose ( fp ) ; if ( ( strstr ( buf , string ) != NULL ) ) { printf ( "%s<S2SV_blank>is<S2SV_blank>currently<S2SV_blank>mounted.<S2SV_blank>Please<S2SV_blank>\\"umount\\"<S2SV_blank>and<S2SV_blank>retry.\\n" , string ) ; return - 1 ; } if ( ( fp = fopen ( SYS_RDSK , "w" ) ) == NULL ) { printf ( "%s:<S2SV_blank>fopen:<S2SV_blank>%s:<S2SV_blank>%s\\n" , __func__ , SYS_RDSK , strerror ( errno ) ) ; return - ENOENT ; } if ( ( err = fprintf ( fp , "rapiddisk<S2SV_blank>detach<S2SV_blank>%s\\n" , string + 2 ) ) < 0 ) { printf ( "%s:<S2SV_blank>fprintf:<S2SV_blank>%s\\n" , __func__ , strerror ( errno ) ) ; return - EIO ; } printf ( "Detached<S2SV_blank>device<S2SV_blank>%s\\n" , string ) ; fclose ( fp ) ; return 0 ; } | <S2SV_ModStart> ) ) == NULL <S2SV_ModEnd> ) { printf |
5,355 | CWE-000 static int file_lookup ( char * filename , struct stat * stbuf ) { struct entry * tmp ; char cpy [ 16 ] ; int i ; tmp = HEAD ; strcpy ( cpy , filename ) ; memmove ( cpy , cpy + 1 , strlen ( cpy ) ) ; printf ( "[+]<S2SV_blank>not<S2SV_blank>root<S2SV_blank>dir<S2SV_blank>filename:\\t%s\\n" , cpy ) ; for ( i = 0 ; i < ENTRIES ; i ++ ) { if ( strcmp ( cpy , tmp -> filename ) == 0 ) { printf ( "[!]<S2SV_blank>Match<S2SV_blank>found!\\n" ) ; if ( stbuf != NULL ) { stbuf -> st_nlink = 1 ; stbuf -> st_mode = S_IFREG | 0444 ; <S2SV_StartBug> stbuf -> st_size = 2048 ; <S2SV_EndBug> } return 1 ; } tmp = tmp -> next ; } return 0 ; } | <S2SV_ModStart> -> st_size = tmp -> info . st_size <S2SV_ModEnd> ; } return |
5,356 | CWE-000 int app ( struct CONSOLE * console , int * fat , char * cmdline ) { struct MEMMAN * memman = ( struct MEMMAN * ) MEMMAN_ADDR ; struct FILEINFO * finfo ; struct SEGMENT_DESCRIPTOR * gdt = ( struct SEGMENT_DESCRIPTOR * ) ADR_GDT ; struct TASK * task = task_now ( ) ; struct SHTCTL * shtctl ; struct SHEET * sheet ; char name [ 18 ] , * p , * q ; int i , segsize , datasize , esp , datarub ; for ( i = 0 ; i < 13 ; ++ i ) { if ( cmdline [ i ] <= '<S2SV_blank>' ) { break ; } name [ i ] = cmdline [ i ] ; } name [ i ] = 0 ; finfo = file_search ( name , ( struct FILEINFO * ) ( ADR_DISKIMG + 0x002600 ) , 224 ) ; if ( finfo == 0 && name [ i - 1 ] != '.' ) { name [ i ] = '.' ; name [ i + 1 ] = 'R' ; name [ i + 2 ] = 'U' ; name [ i + 3 ] = 'B' ; name [ i + 4 ] = 0 ; finfo = file_search ( name , ( struct FILEINFO * ) ( ADR_DISKIMG + 0x002600 ) , 224 ) ; } if ( finfo != 0 ) { p = ( char * ) memman_alloc_4k ( memman , finfo -> size ) ; file_loadfile ( finfo -> cluster_no , finfo -> size , p , fat , ( char * ) ( ADR_DISKIMG + 0x003e00 ) ) ; if ( finfo -> size >= 36 && strncmp ( p + 4 , "main" , 4 ) == 0 && * p == 0x00 ) { segsize = * ( ( int * ) ( p + 0x0000 ) ) ; esp = * ( ( int * ) ( p + 0x000c ) ) ; datasize = * ( ( int * ) ( p + 0x0010 ) ) ; datarub = * ( ( int * ) ( p + 0x0014 ) ) ; q = ( char * ) memman_alloc_4k ( memman , segsize ) ; ( * ( ( int * ) 0xfe8 ) ) = ( int ) q ; set_segmdesc ( gdt + 1003 , finfo -> size - 1 , ( int ) p , AR_CODE32_ER + 0x60 ) ; set_segmdesc ( gdt + 1004 , segsize - 1 , ( int ) q , AR_DATA32_RW + 0x60 ) ; for ( i = 0 ; i < datasize ; ++ i ) { q [ esp + i ] = p [ datarub + i ] ; } start_app ( 0x1b , 1003 * 8 , esp , 1004 * 8 , & ( task -> tss . esp0 ) ) ; shtctl = ( struct SHTCTL * ) * ( ( int * ) 0x0fe4 ) ; for ( i = 0 ; i < MAX_SHEETS ; ++ i ) { sheet = & ( shtctl -> sheets0 [ i ] ) ; if ( ( sheet -> flags & 0x11 ) == 0x11 && sheet -> task == task ) { sheet_free ( sheet ) ; } } <S2SV_StartBug> memman_free_4k ( memman , ( int ) q , segsize ) ; <S2SV_EndBug> } else { console_putstr ( console , ".rub<S2SV_blank>file<S2SV_blank>format<S2SV_blank>error.\\n" ) ; } memman_free_4k ( memman , ( int ) p , finfo -> size ) ; console_newline ( console ) ; return 1 ; } return 0 ; } | <S2SV_ModStart> ; } } timer_cancelall ( & task -> fifo ) ; |
5,357 | CWE-000 static int rkss_verify_ptable ( struct rk_secure_storage * rkss ) { void * vp = ( void * ) rkss -> data ; char * cp = ( char * ) vp ; struct rkss_file_verification * verify ; int ret ; if ( rkss -> index > RKSS_PARTITION_TABLE_COUNT ) { printf ( "cannot<S2SV_blank>support<S2SV_blank>verifing<S2SV_blank>other<S2SV_blank>section." ) ; return TEEC_ERROR_GENERIC ; } cp = ( char * ) ( cp + RKSS_DATA_LEN - sizeof ( struct rkss_file_verification ) ) ; verify = ( struct rkss_file_verification * ) ( void * ) cp ; if ( verify -> version != RKSS_VERSION || verify -> checkstr != RKSS_CHECK_STR ) { printf ( "verify<S2SV_blank>[%lu]<S2SV_blank>fail,<S2SV_blank>cleanning<S2SV_blank>...." , rkss -> index ) ; <S2SV_StartBug> memset ( rkss -> data , 0 , sizeof ( RKSS_DATA_LEN ) ) ; <S2SV_EndBug> verify -> checkstr = RKSS_CHECK_STR ; verify -> version = RKSS_VERSION ; ret = rkss_write_section ( rkss ) ; if ( ret < 0 ) { printf ( "cleanning<S2SV_blank>ptable<S2SV_blank>fail<S2SV_blank>!<S2SV_blank>ret:<S2SV_blank>%d." , ret ) ; return TEEC_ERROR_GENERIC ; } return TEEC_SUCCESS ; } debug ( "verify<S2SV_blank>success.<S2SV_blank>%lu" , rkss -> index ) ; return TEEC_SUCCESS ; } | <S2SV_ModStart> , 0 , RKSS_DATA_LEN <S2SV_ModEnd> ) ; verify |
5,358 | CWE-000 void xprt_release ( struct rpc_task * task ) { struct rpc_xprt * xprt ; struct rpc_rqst * req = task -> tk_rqstp ; if ( req == NULL ) { if ( task -> tk_client ) { xprt = task -> tk_xprt ; if ( xprt -> snd_task == task ) xprt_release_write ( xprt , task ) ; } return ; } xprt = req -> rq_xprt ; if ( task -> tk_ops -> rpc_count_stats != NULL ) task -> tk_ops -> rpc_count_stats ( task , task -> tk_calldata ) ; else if ( task -> tk_client ) rpc_count_iostats ( task , task -> tk_client -> cl_metrics ) ; spin_lock ( & xprt -> recv_lock ) ; if ( ! list_empty ( & req -> rq_list ) ) { list_del_init ( & req -> rq_list ) ; xprt_wait_on_pinned_rqst ( req ) ; } spin_unlock ( & xprt -> recv_lock ) ; spin_lock_bh ( & xprt -> transport_lock ) ; xprt -> ops -> release_xprt ( xprt , task ) ; if ( xprt -> ops -> release_request ) xprt -> ops -> release_request ( task ) ; xprt -> last_used = jiffies ; xprt_schedule_autodisconnect ( xprt ) ; spin_unlock_bh ( & xprt -> transport_lock ) ; if ( req -> rq_buffer ) xprt -> ops -> buf_free ( task ) ; xprt_inject_disconnect ( xprt ) ; if ( req -> rq_cred != NULL ) put_rpccred ( req -> rq_cred ) ; task -> tk_rqstp = NULL ; if ( req -> rq_release_snd_buf ) req -> rq_release_snd_buf ( req ) ; dprintk ( "RPC:<S2SV_blank>%5u<S2SV_blank>release<S2SV_blank>request<S2SV_blank>%p\\n" , task -> tk_pid , req ) ; if ( likely ( ! bc_prealloc ( req ) ) ) <S2SV_StartBug> xprt_free_slot ( xprt , req ) ; <S2SV_EndBug> else xprt_free_bc_request ( req ) ; } | <S2SV_ModStart> ) ) ) xprt -> ops -> free_slot <S2SV_ModEnd> ( xprt , |
5,359 | CWE-000 void COMvers ( int argc , const char * argv [ ] ) { ( void ) argc ; ( void ) argv ; <S2SV_StartBug> printf ( "%s<S2SV_blank>%.32s\\n" , PACKAGE_NAME , PACKAGE_VERSION ) ; <S2SV_EndBug> exit ( 0 ) ; } | <S2SV_ModStart> ; printf ( "%s<S2SV_blank>%s\\n" <S2SV_ModEnd> , PACKAGE_NAME , |
5,360 | CWE-000 struct pq_align_res math_l2_postlist_coarse_score_v2 ( struct math_l2_postlist * po , uint32_t n_doc_lr_paths ) { struct pq_align_res widest = { 0 } ; int dw = ( int ) n_doc_lr_paths ; struct math_pruner * pruner = & po -> pruner ; float threshold = pruner -> init_threshold ; int pivot = MIN ( pruner -> postlist_pivot , po -> iter -> size - 1 ) ; if ( priority_Q_full ( po -> rk_res ) ) threshold = MAX ( priority_Q_min_score ( po -> rk_res ) , threshold ) ; uint64_t candidate = UINT64_MAX ; for ( int i = 0 ; i <= pivot ; i ++ ) { uint64_t cur = postmerger_iter_call ( & po -> pm , po -> iter , cur , i ) ; if ( cur < candidate ) candidate = cur ; } # ifdef DEBUG_MATH_SCORE_INSPECT P_CAST ( p , struct math_postlist_item , & candidate ) ; int inspect = score_inspect_filter ( p -> doc_id , po -> indices ) ; if ( inspect ) { # endif # if defined ( DEBUG_MATH_PRUNING ) || defined ( DEBUG_MATH_SCORE_INSPECT ) printf ( "pivot<S2SV_blank>=<S2SV_blank>%d/%u,<S2SV_blank>threshold<S2SV_blank>=<S2SV_blank>%.3f.\\n" , pruner -> postlist_pivot , po -> iter -> size , threshold ) ; for ( int i = 0 ; i < po -> iter -> size ; i ++ ) { uint32_t pid = po -> iter -> map [ i ] ; uint64_t cur = postmerger_iter_call ( & po -> pm , po -> iter , cur , i ) ; if ( i > pruner -> postlist_pivot || cur == candidate ) { printf ( "%s:<S2SV_blank>" , ( cur == candidate ) ? "hit<S2SV_blank>" : "skip" ) ; printf ( "[%u]<S2SV_blank>" , i ) ; math_pruner_print_postlist ( pruner , pid ) ; uint32_t docID = ( uint32_t ) ( cur >> 32 ) ; uint32_t expID = ( uint32_t ) ( cur >> 0 ) ; printf ( "<S2SV_blank>[doc#%u,<S2SV_blank>exp#%u]\\n" , docID , expID ) ; } } printf ( "\\n" ) ; # endif # ifdef DEBUG_MATH_SCORE_INSPECT } # endif int n_save = 0 ; int save_idx [ MAX_NODE_IDS ] ; u16_ht_reset ( & pruner -> q_hit_nodes_ht , 0 ) ; for ( int i = 0 ; i < po -> iter -> size ; i ++ ) { <S2SV_StartBug> if ( i > pivot ) <S2SV_EndBug> <S2SV_StartBug> postmerger_iter_call ( & po -> pm , po -> iter , jump , i , candidate ) ; <S2SV_EndBug> uint64_t cur = postmerger_iter_call ( & po -> pm , po -> iter , cur , i ) ; if ( cur == candidate ) { uint32_t pid = po -> iter -> map [ i ] ; struct node_set ns = pruner -> postlist_nodes [ pid ] ; for ( int j = 0 ; j < ns . sz ; j ++ ) { int qid = ns . rid [ j ] ; if ( - 1 == u16_ht_lookup ( & pruner -> q_hit_nodes_ht , qid ) ) { int qid_idx = pruner -> nodeID2idx [ qid ] ; save_idx [ n_save ++ ] = qid_idx ; u16_ht_incr ( & pruner -> q_hit_nodes_ht , qid , 1 ) ; } } } } for ( int i = 0 ; i < n_save ; i ++ ) { int q_node_idx = save_idx [ i ] ; struct pruner_node * q_node = pruner -> nodes + q_node_idx ; float q_node_upperbound = pruner -> upp [ q_node -> width ] [ dw ] ; if ( q_node_upperbound <= threshold ) { # if defined ( DEBUG_MATH_PRUNING ) || defined ( DEBUG_MATH_SCORE_INSPECT ) # ifdef DEBUG_MATH_SCORE_INSPECT if ( inspect ) # endif printf ( "drop<S2SV_blank>node#%d\\n" , q_node -> secttr [ 0 ] . rnode ) ; # endif math_pruner_dele_node_safe ( pruner , q_node_idx , save_idx , n_save ) ; math_pruner_update ( pruner ) ; continue ; } else if ( q_node -> width < widest . width ) { # if defined ( DEBUG_MATH_PRUNING ) || defined ( DEBUG_MATH_SCORE_INSPECT ) # ifdef DEBUG_MATH_SCORE_INSPECT if ( inspect ) # endif printf ( "skip<S2SV_blank>node#%d<S2SV_blank>(upperbound<S2SV_blank><<S2SV_blank>widest<S2SV_blank>=<S2SV_blank>%d)\\n" , q_node -> secttr [ 0 ] . rnode , widest . width ) ; # endif continue ; } # ifdef DEBUG_MATH_SCORE_INSPECT struct q_node_match qm = calc_q_node_match ( po , q_node , inspect ) ; # else struct q_node_match qm = calc_q_node_match ( po , q_node ) ; # endif if ( qm . max > widest . width ) { # if defined ( DEBUG_MATH_PRUNING ) || defined ( DEBUG_MATH_SCORE_INSPECT ) # ifdef DEBUG_MATH_SCORE_INSPECT if ( inspect ) # endif printf ( "update<S2SV_blank>node#%d<S2SV_blank>widest:<S2SV_blank>%d\\n" , q_node -> secttr [ 0 ] . rnode , qm . max ) ; # endif widest . width = qm . max ; widest . qr = q_node -> secttr [ 0 ] . rnode ; widest . dr = qm . dr ; } } if ( widest . width && pruner -> upp [ widest . width ] [ dw ] <= threshold ) { # if defined ( DEBUG_MATH_PRUNING ) || defined ( DEBUG_MATH_SCORE_INSPECT ) # ifdef DEBUG_MATH_SCORE_INSPECT if ( inspect ) # endif printf ( "item<S2SV_blank>widest<S2SV_blank>upperbound<S2SV_blank>less<S2SV_blank>than<S2SV_blank>threshold,<S2SV_blank>drop.\\n" ) ; # endif widest . width = 0 ; } if ( threshold != pruner -> prev_threshold ) { int i , sum = 0 ; for ( i = po -> iter -> size - 1 ; i >= 0 ; i -- ) { uint32_t pid = po -> iter -> map [ i ] ; int qmw = pruner -> postlist_max [ pid ] ; sum += qmw ; if ( pruner -> upp [ sum ] [ dw ] > threshold ) break ; } if ( i < 0 ) po -> iter -> size = 0 ; pruner -> postlist_pivot = i ; pruner -> prev_threshold = threshold ; } return widest ; } | <S2SV_ModStart> ++ ) { uint64_t cur = postmerger_iter_call ( & po -> pm , po -> iter , cur , i ) ; <S2SV_ModStart> i > pivot && cur < candidate <S2SV_ModStart> i , candidate <S2SV_ModEnd> ) ; if |
5,361 | CWE-000 void init_func1 ( t_func1 * func ) { <S2SV_StartBug> func [ UP ] = & move_up ; <S2SV_EndBug> func [ DOWN ] = & move_down ; func [ LEFT ] = & move_left ; func [ RIGHT ] = & move_right ; <S2SV_StartBug> func [ DEL ] = & del_at ; <S2SV_EndBug> func [ HOME ] = & home ; func [ END ] = & end ; func [ FWORD ] = & fword ; func [ BWORD ] = & bword ; func [ CP ] = & select_c ; func [ SUP ] = & del ; func [ PAST ] = & past ; } | <S2SV_ModStart> { func [ <S2SV_ModEnd> RIGHT ] = <S2SV_ModStart> & move_right ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
5,362 | CWE-000 <S2SV_StartBug> static void grow_match_cases ( lily_emit_state * emit , int new_size ) <S2SV_EndBug> { while ( emit -> match_case_size < new_size ) emit -> match_case_size *= 2 ; emit -> match_cases = lily_realloc ( emit -> match_cases , sizeof ( * emit -> match_cases ) * emit -> match_case_size ) ; } | <S2SV_ModStart> lily_emit_state * emit ) { <S2SV_ModEnd> emit -> match_case_size |
5,363 | CWE-000 int iwl_mvm_send_rm_bcast_sta ( struct iwl_mvm * mvm , struct ieee80211_vif * vif ) { struct iwl_mvm_vif * mvmvif = iwl_mvm_vif_from_mac80211 ( vif ) ; int ret ; lockdep_assert_held ( & mvm -> mutex ) ; <S2SV_StartBug> ret = iwl_mvm_rm_sta_common ( mvm , mvmvif -> bcast_sta . sta_id ) ; <S2SV_EndBug> if ( ret ) IWL_WARN ( mvm , "Failed<S2SV_blank>sending<S2SV_blank>remove<S2SV_blank>station\\n" ) ; return ret ; } | <S2SV_ModStart> mutex ) ; if ( iwl_mvm_is_dqa_supported ( mvm ) ) iwl_mvm_free_bcast_sta_queues ( mvm , vif ) ; |
5,364 | CWE-000 static BOOL setLayerValue ( BOOL bMachine , const char * valueName , const char * value ) { HKEY key = NULL ; LSTATUS lstatus = RegCreateKeyExA ( bMachine ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER , "Software\\\\Microsoft\\\\Windows<S2SV_blank>NT\\\\CurrentVersion\\\\AppCompatFlags\\\\Layers" , 0 , NULL , 0 , QueryFlag ( ) | KEY_SET_VALUE , NULL , & key , NULL ) ; if ( lstatus == ERROR_SUCCESS ) { if ( value ) <S2SV_StartBug> lstatus = RegSetValueExA ( key , valueName , 0 , REG_SZ , ( const BYTE * ) value , strlen ( value ) + 1 ) ; <S2SV_EndBug> else { lstatus = RegDeleteValueA ( key , valueName ) ; lstatus = ( lstatus == ERROR_FILE_NOT_FOUND ? ERROR_SUCCESS : lstatus ) ; } RegCloseKey ( key ) ; } return lstatus == ERROR_SUCCESS ; } | <S2SV_ModStart> ) value , ( DWORD ) |
5,365 | CWE-000 <S2SV_StartBug> static _Bool dns_d_isanchored ( const void * _src , size_t len ) { <S2SV_EndBug> const unsigned char * src = _src ; return len > 0 && src [ len - 1 ] == '.' ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> static dns_bool <S2SV_ModEnd> dns_d_isanchored ( const |
5,366 | CWE-000 static int event_sequence_insert ( struct event_sequence * * event_sequences , int * n , PyObject * event ) { long template_id = get_template_id ( event ) ; struct event_sequence * event_sequence ; PyObject * * new_events ; int need_sort = 0 ; <S2SV_StartBug> if ( template_id < 0 ) <S2SV_EndBug> <S2SV_StartBug> return - 1 ; <S2SV_EndBug> event_sequence = event_sequence_get ( * event_sequences , * n , template_id ) ; if ( ! event_sequence ) { struct event_sequence * new = realloc ( * event_sequences , ( * n + 1 ) * sizeof ( * * event_sequences ) ) ; if ( ! new ) { Py_DECREF ( event ) ; PyErr_SetString ( PyExc_MemoryError , "realloc()<S2SV_blank>failed" ) ; return - 1 ; } * event_sequences = new ; event_sequence = & new [ * n ] ; ( * n ) ++ ; event_sequence -> template_id = template_id ; event_sequence -> events = NULL ; event_sequence -> length = 0 ; need_sort = 1 ; } new_events = realloc ( event_sequence -> events , ( event_sequence -> length + 1 ) * sizeof ( * event_sequence -> events ) ) ; if ( ! new_events ) { Py_DECREF ( event ) ; PyErr_SetString ( PyExc_MemoryError , "realloc()<S2SV_blank>failed" ) ; return - 1 ; } event_sequence -> events = new_events ; event_sequence -> events [ event_sequence -> length ] = event ; event_sequence -> length ++ ; if ( need_sort ) qsort ( * event_sequences , * n , sizeof ( * * event_sequences ) , event_sequence_sort_cmp ) ; return 0 ; } | <S2SV_ModStart> < 0 ) { Py_DECREF ( event ) ; <S2SV_ModStart> - 1 ; } |
5,367 | CWE-000 void init_smb2_1_server ( struct cifsd_tcp_conn * conn ) { conn -> vals = & smb21_server_values ; conn -> ops = & smb2_0_server_ops ; conn -> cmds = smb2_0_server_cmds ; conn -> max_cmds = ARRAY_SIZE ( smb2_0_server_cmds ) ; conn -> max_credits = SMB2_MAX_CREDITS ; <S2SV_StartBug> if ( lease_enable ) <S2SV_EndBug> <S2SV_StartBug> conn -> srv_cap = SMB2_GLOBAL_CAP_LEASING ; <S2SV_EndBug> conn -> srv_cap |= SMB2_GLOBAL_CAP_LARGE_MTU ; } | <S2SV_ModStart> = SMB2_MAX_CREDITS ; conn -> srv_cap = SMB2_GLOBAL_CAP_LARGE_MTU ; <S2SV_ModStart> conn -> srv_cap |= SMB2_GLOBAL_CAP_LEASING <S2SV_ModEnd> ; } <S2SV_null> |
5,368 | CWE-000 int x264_encoder_invalidate_reference ( x264_t * h , int64_t pts ) { x264_api_t * api = ( x264_api_t * ) h ; <S2SV_StartBug> return api -> encoder_invalidate_reference ( api -> x264 , pts ) ; <S2SV_EndBug> } | <S2SV_ModStart> h ; return x264_stack_align ( <S2SV_ModStart> api -> encoder_invalidate_reference , <S2SV_ModEnd> api -> x264 |
5,369 | CWE-000 static int IsLetterGroup ( Translator * tr , char * word , int group , int pre ) { char * p ; char * w ; int len = 0 ; p = tr -> letterGroups [ group ] ; if ( p == NULL ) <S2SV_StartBug> return 0 ; <S2SV_EndBug> while ( * p != RULE_GROUP_END ) { if ( pre ) { len = strlen ( p ) ; w = word - len + 1 ; } else w = word ; if ( * p == '~' ) return 0 ; while ( ( * p == * w ) && ( * w != 0 ) ) { w ++ ; p ++ ; } if ( * p == 0 ) { if ( pre ) return len ; return w - word ; } while ( * p ++ != 0 ) ; } return - 1 ; } | <S2SV_ModStart> NULL ) return - 1 <S2SV_ModEnd> ; while ( |
5,370 | CWE-000 value_t fcnStrConcat ( value_t * args , value_t thisVal , environment_t * env ) { string_t * str = js_addr ( thisVal ) ; value_t val [ 1 ] ; <S2SV_StartBug> int idx ; <S2SV_EndBug> * val = newString ( str -> val , str -> len ) ; for ( idx = 0 ; idx < vec_cnt ( args ) ; idx ++ ) { value_t v = conv2Str ( args [ idx ] , false , false ) ; valueCat ( val , v , false ) ; abandonValueIfDiff ( v , args [ idx ] ) ; } return * val ; } | <S2SV_ModStart> 1 ] ; uint32_t <S2SV_ModEnd> idx ; * |
5,371 | CWE-000 int nandmtd_EraseBlockInNAND ( struct yaffs_dev * dev , int blockNumber ) { struct mtd_info * mtd = ( struct mtd_info * ) ( dev -> driver_context ) ; __u32 addr = <S2SV_StartBug> ( ( loff_t ) blockNumber ) * dev -> data_bytes_per_chunk <S2SV_EndBug> * dev -> param . chunks_per_block ; struct erase_info ei ; int retval = 0 ; ei . mtd = mtd ; ei . addr = addr ; <S2SV_StartBug> ei . len = dev -> data_bytes_per_chunk * dev -> param . chunks_per_block ; <S2SV_EndBug> ei . time = 1000 ; ei . retries = 2 ; ei . callback = NULL ; ei . priv = ( u_long ) dev ; retval = mtd_erase ( mtd , & ei ) ; if ( retval == 0 ) return YAFFS_OK ; else return YAFFS_FAIL ; } | <S2SV_ModStart> * dev -> param . total_bytes_per_chunk <S2SV_ModEnd> * dev -> <S2SV_ModStart> = dev -> param . total_bytes_per_chunk <S2SV_ModEnd> * dev -> |
5,372 | CWE-000 <S2SV_StartBug> static int ip_identify_match_srv_lookup ( struct ip_identify_match * identify , const char * prefix , const char * host ) <S2SV_EndBug> { char service [ NI_MAXHOST ] ; struct srv_context * context = NULL ; int srv_ret ; const char * srvhost ; <S2SV_StartBug> unsigned short srvport ; <S2SV_EndBug> int results = 0 ; snprintf ( service , sizeof ( service ) , "%s.%s" , prefix , host ) ; while ( ! ( srv_ret = ast_srv_lookup ( & context , service , & srvhost , & srvport ) ) ) { int hosts ; hosts = ip_identify_match_host_lookup ( identify , srvhost ) ; if ( hosts == - 1 ) { results = - 1 ; break ; } else { results += hosts ; } } ast_srv_cleanup ( & context ) ; return results ; } | <S2SV_ModStart> char * host , int results <S2SV_ModStart> unsigned short srvport <S2SV_ModEnd> ; snprintf ( |
5,373 | CWE-000 mrb_callinfo * mrbjit_cipush ( mrb_state * mrb ) { struct mrb_context * c = mrb -> c ; mrb_callinfo * ci = c -> ci ; int ridx = ci -> ridx ; if ( ci + 1 == c -> ciend ) { ptrdiff_t size = ci - c -> cibase ; mrb_callinfo * sci ; mrb_callinfo * dci ; c -> cibase_org = ( mrb_callinfo * ) mrb_malloc ( mrb , sizeof ( mrb_callinfo ) * size * 2 + 64 ) ; sci = c -> cibase ; c -> cibase = ( mrb_callinfo * ) ( ( ( uintptr_t ) ( c -> cibase_org ) + 63 ) & ( ~ ( 64 - 1 ) ) ) ; for ( dci = c -> cibase ; sci <= c -> ci ; sci ++ , dci ++ ) { * dci = * sci ; } c -> ci = c -> cibase + size ; c -> ciend = c -> cibase + size * 2 ; } <S2SV_StartBug> ci = ++ c -> ci ; <S2SV_EndBug> ci -> epos = mrb -> c -> eidx ; ci -> ridx = ridx ; ci -> env = 0 ; ci -> pc = 0 ; ci -> err = 0 ; ci -> proc = 0 ; ci -> acc = 0 ; ci -> method_arg_ver = 0 ; ci -> prev_pc = NULL ; ci -> acc = 0 ; return ci ; } | <S2SV_ModStart> 2 ; } c -> ci -> jit_entry = NULL ; |
5,374 | CWE-000 static ssize_t kdsstat_show ( struct device * dev , struct device_attribute * attr , char * buf ) { <S2SV_StartBug> int i ; <S2SV_EndBug> struct xocl_dev * xdev = dev_get_drvdata ( dev ) ; int size = sprintf ( buf , "xclbin:\\t\\t\\t%pUl\\noutstanding<S2SV_blank>execs:\\t%d\\ntotal<S2SV_blank>execs:\\t\\t%ld\\ncontexts:\\t\\t%d\\n" , & xdev -> xclbin_id , atomic_read ( & xdev -> outstanding_execs ) , atomic64_read ( & xdev -> total_execs ) , get_live_client_size ( xdev ) ) ; buf += size ; if ( xdev -> layout == NULL ) return size ; # if 0 for ( i = 0 ; i < xdev -> layout -> m_count ; i ++ ) { if ( xdev -> layout -> m_ip_data [ i ] . m_type != IP_KERNEL ) continue ; size += sprintf ( buf , "\\t%s:\\t%d\\n" , xdev -> layout -> m_ip_data [ i ] . m_name , xdev -> ip_reference [ i ] ) ; buf += size ; } # endif return size ; } | <S2SV_ModStart> buf ) { <S2SV_ModEnd> struct xocl_dev * |
5,375 | CWE-000 ptr_int_t ksynch_wait ( mac_synch_t * synch , int mustbe , int timeout_ms ) { kern_return_t res ; if ( timeout_ms > 0 ) { mach_timespec_t timeout ; timeout . tv_sec = ( timeout_ms / 1000 ) ; timeout . tv_nsec = ( ( int64 ) timeout_ms % 1000 ) * 1000000 ; res = semaphore_timedwait ( synch -> sem , timeout ) ; } else res = semaphore_wait ( synch -> sem ) ; <S2SV_StartBug> return ( res == KERN_SUCCESS ? 0 : - 1 ) ; <S2SV_EndBug> } | <S2SV_ModStart> sem ) ; switch ( res ) { case KERN_SUCCESS : return 0 ; case KERN_OPERATION_TIMED_OUT : return - ETIMEDOUT ; default : return - 1 ; } } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
5,376 | CWE-000 rt_function_error_t free_exp_local_context ( rt_function_t * f ) { <S2SV_StartBug> rt_free_func ( f -> local_context ) ; <S2SV_EndBug> return RT_FUNCTION_ERROR_NOERROR ; } | <S2SV_ModStart> f ) { <S2SV_ModEnd> return RT_FUNCTION_ERROR_NOERROR ; |
5,377 | CWE-000 conn_t * conn_init ( int fd , int epfd ) { <S2SV_StartBug> pool_t * pool = pool_init ( ) ; <S2SV_EndBug> <S2SV_StartBug> conn_t * conn = malloc ( sizeof ( conn_t ) ) ; <S2SV_EndBug> conn -> pool = pool ; conn -> fd = fd ; conn -> epfd = epfd ; fd_set_non_blocking ( fd ) ; fd_set_no_delay ( fd ) ; <S2SV_StartBug> conn -> request = request_init ( pool ) ; <S2SV_EndBug> return conn ; } | <S2SV_ModStart> epfd ) { <S2SV_ModEnd> conn_t * conn <S2SV_ModStart> conn_t ) ) <S2SV_ModEnd> ; conn -> <S2SV_ModStart> = request_init ( <S2SV_ModEnd> ) ; return |
5,378 | CWE-000 static int anatop_regulator_probe ( struct platform_device * pdev ) { struct device * dev = & pdev -> dev ; struct device_node * np = dev -> of_node ; struct device_node * anatop_np ; struct regulator_desc * rdesc ; struct regulator_dev * rdev ; struct anatop_regulator * sreg ; struct regulator_init_data * initdata ; struct regulator_config config = { } ; int ret = 0 ; u32 val ; sreg = devm_kzalloc ( dev , sizeof ( * sreg ) , GFP_KERNEL ) ; if ( ! sreg ) return - ENOMEM ; sreg -> name = of_get_property ( np , "regulator-name" , NULL ) ; if ( ! sreg -> name ) { dev_err ( dev , "no<S2SV_blank>regulator-name<S2SV_blank>set\\n" ) ; return - EINVAL ; } rdesc = & sreg -> rdesc ; rdesc -> name = sreg -> name ; rdesc -> type = REGULATOR_VOLTAGE ; rdesc -> owner = THIS_MODULE ; initdata = of_get_regulator_init_data ( dev , np , rdesc ) ; sreg -> initdata = initdata ; if ( strcmp ( sreg -> name , "vddpu" ) == 0 ) vddpu = sreg ; else if ( strcmp ( sreg -> name , "vddsoc" ) == 0 ) vddsoc = sreg ; anatop_np = of_get_parent ( np ) ; if ( ! anatop_np ) return - ENODEV ; sreg -> anatop = syscon_node_to_regmap ( anatop_np ) ; of_node_put ( anatop_np ) ; if ( IS_ERR ( sreg -> anatop ) ) return PTR_ERR ( sreg -> anatop ) ; ret = of_property_read_u32 ( np , "anatop-reg-offset" , & sreg -> control_reg ) ; if ( ret ) { dev_err ( dev , "no<S2SV_blank>anatop-reg-offset<S2SV_blank>property<S2SV_blank>set\\n" ) ; return ret ; } ret = of_property_read_u32 ( np , "anatop-vol-bit-width" , & sreg -> vol_bit_width ) ; if ( ret ) { dev_err ( dev , "no<S2SV_blank>anatop-vol-bit-width<S2SV_blank>property<S2SV_blank>set\\n" ) ; return ret ; } ret = of_property_read_u32 ( np , "anatop-vol-bit-shift" , & sreg -> vol_bit_shift ) ; if ( ret ) { dev_err ( dev , "no<S2SV_blank>anatop-vol-bit-shift<S2SV_blank>property<S2SV_blank>set\\n" ) ; return ret ; } ret = of_property_read_u32 ( np , "anatop-min-bit-val" , & sreg -> min_bit_val ) ; if ( ret ) { dev_err ( dev , "no<S2SV_blank>anatop-min-bit-val<S2SV_blank>property<S2SV_blank>set\\n" ) ; return ret ; } ret = of_property_read_u32 ( np , "anatop-min-voltage" , & sreg -> min_voltage ) ; if ( ret ) { dev_err ( dev , "no<S2SV_blank>anatop-min-voltage<S2SV_blank>property<S2SV_blank>set\\n" ) ; return ret ; } ret = of_property_read_u32 ( np , "anatop-max-voltage" , & sreg -> max_voltage ) ; if ( ret ) { dev_err ( dev , "no<S2SV_blank>anatop-max-voltage<S2SV_blank>property<S2SV_blank>set\\n" ) ; return ret ; } of_property_read_u32 ( np , "anatop-delay-reg-offset" , & sreg -> delay_reg ) ; of_property_read_u32 ( np , "anatop-delay-bit-width" , & sreg -> delay_bit_width ) ; of_property_read_u32 ( np , "anatop-delay-bit-shift" , & sreg -> delay_bit_shift ) ; of_property_read_u32 ( np , "anatop-enable-bit" , & sreg -> enable_bit ) ; rdesc -> n_voltages = ( sreg -> max_voltage - sreg -> min_voltage ) / 25000 + 1 + sreg -> min_bit_val ; rdesc -> min_uV = sreg -> min_voltage ; rdesc -> uV_step = 25000 ; rdesc -> linear_min_sel = sreg -> min_bit_val ; rdesc -> vsel_reg = sreg -> control_reg ; rdesc -> vsel_mask = ( ( 1 << sreg -> vol_bit_width ) - 1 ) << sreg -> vol_bit_shift ; config . dev = & pdev -> dev ; config . init_data = initdata ; config . driver_data = sreg ; config . of_node = pdev -> dev . of_node ; config . regmap = sreg -> anatop ; if ( sreg -> control_reg && sreg -> delay_bit_width ) { rdesc -> ops = & anatop_core_rops ; ret = regmap_read ( config . regmap , rdesc -> vsel_reg , & val ) ; if ( ret ) { dev_err ( dev , "failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>initial<S2SV_blank>state\\n" ) ; return ret ; } sreg -> sel = ( val & rdesc -> vsel_mask ) >> sreg -> vol_bit_shift ; if ( sreg -> sel == LDO_FET_FULL_ON ) { sreg -> sel = 0 ; sreg -> bypass = true ; } if ( ! sreg -> sel && ! strcmp ( sreg -> name , "vddpu" ) ) sreg -> sel = 22 ; if ( ! sreg -> sel && ! strcmp ( sreg -> name , "vddpcie-phy" ) ) sreg -> sel = 0x10 ; <S2SV_StartBug> if ( ! sreg -> sel ) { <S2SV_EndBug> dev_err ( & pdev -> dev , "Failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>a<S2SV_blank>valid<S2SV_blank>default<S2SV_blank>voltage<S2SV_blank>selector.\\n" ) ; return - EINVAL ; } } else { rdesc -> ops = & anatop_rops ; } rdev = devm_regulator_register ( dev , rdesc , & config ) ; if ( IS_ERR ( rdev ) ) { dev_err ( dev , "failed<S2SV_blank>to<S2SV_blank>register<S2SV_blank>%s\\n" , rdesc -> name ) ; return PTR_ERR ( rdev ) ; } platform_set_drvdata ( pdev , rdev ) ; return 0 ; } | <S2SV_ModStart> ! sreg -> bypass && ! sreg -> |
5,379 | CWE-000 static void normalize_ts ( tsfix_t * tf , tfstream_t * tfs , th_pkt_t * pkt , int backlog ) { int64_t ref , dts , odts , opts , d ; if ( tf -> tf_tsref == PTS_UNSET ) { if ( backlog ) { if ( pkt -> pkt_dts != PTS_UNSET ) tfs -> tfs_seen = 1 ; pktref_enqueue ( & tf -> tf_backlog , pkt ) ; } else pkt_ref_dec ( pkt ) ; return ; } ref = tfs -> tfs_local_ref != PTS_UNSET ? tfs -> tfs_local_ref : tf -> tf_tsref ; odts = pkt -> pkt_dts ; opts = pkt -> pkt_pts ; if ( pkt -> pkt_dts == PTS_UNSET ) { if ( pkt -> pkt_pts != PTS_UNSET ) pkt -> pkt_dts = pkt -> pkt_pts ; else goto deliver ; } pkt -> pkt_dts &= PTS_MASK ; <S2SV_StartBug> dts = pkt -> pkt_dts - ref ; <S2SV_EndBug> if ( tfs -> tfs_last_dts_norm == PTS_UNSET ) { if ( dts < 0 || pkt -> pkt_err ) { tsfix_packet_drop ( tfs , pkt , "negative/error" ) ; return ; } } else { const int64_t nlimit = - 1 ; int64_t low = 90000 ; int64_t upper = 2 * 90000 ; d = dts + tfs -> tfs_dts_epoch - tfs -> tfs_last_dts_norm ; if ( tfs -> tfs_subtitle ) { low = PTS_MASK / 2 ; upper = low - 1 ; } if ( d < nlimit || d > low ) { if ( d < - PTS_MASK || d > - PTS_MASK + upper ) { if ( pkt -> pkt_err ) { tsfix_packet_drop ( tfs , pkt , "possible<S2SV_blank>wrong<S2SV_blank>discontinuity" ) ; return ; } tfs -> tfs_bad_dts ++ ; if ( tfs -> tfs_bad_dts < 5 ) { tvherror ( LS_TSFIX , "transport<S2SV_blank>stream<S2SV_blank>%s,<S2SV_blank>DTS<S2SV_blank>discontinuity.<S2SV_blank>" "DTS<S2SV_blank>=<S2SV_blank>%" PRId64 ",<S2SV_blank>last<S2SV_blank>=<S2SV_blank>%" PRId64 , streaming_component_type2txt ( tfs -> tfs_type ) , dts , tfs -> tfs_last_dts_norm ) ; } } else { tfs -> tfs_dts_epoch += PTS_MASK + 1 ; tfs -> tfs_bad_dts = 0 ; } } else { tfs -> tfs_bad_dts = 0 ; } } dts += tfs -> tfs_dts_epoch ; tfs -> tfs_last_dts_norm = dts ; if ( pkt -> pkt_pts != PTS_UNSET ) { d = ( ( pkt -> pkt_pts & PTS_MASK ) - pkt -> pkt_dts ) & PTS_MASK ; pkt -> pkt_pts = dts + d ; } if ( pkt -> pkt_pcr != PTS_UNSET ) { d = ( ( pkt -> pkt_pcr & PTS_MASK ) - pkt -> pkt_dts ) & PTS_MASK ; if ( d > PTS_MASK / 2 ) d = - ( PTS_MASK - d ) ; pkt -> pkt_pcr = dts + d ; } pkt -> pkt_dts = dts ; if ( pkt -> pkt_pts < 0 || pkt -> pkt_dts < 0 || pkt -> pkt_pcr < 0 ) { tsfix_packet_drop ( tfs , pkt , "negative2/error" ) ; return ; } deliver : if ( tvhtrace_enabled ( ) ) { char _odts [ 22 ] , _opts [ 22 ] ; pkt_trace ( LS_TSFIX , pkt , "deliver<S2SV_blank>odts<S2SV_blank>%s<S2SV_blank>opts<S2SV_blank>%s<S2SV_blank>ref<S2SV_blank>%" PRId64 "<S2SV_blank>epoch<S2SV_blank>%" PRId64 , pts_to_string ( odts , _odts ) , pts_to_string ( opts , _opts ) , ref , tfs -> tfs_dts_epoch ) ; } streaming_message_t * sm = streaming_msg_create_pkt ( pkt ) ; streaming_target_deliver2 ( tf -> tf_output , sm ) ; pkt_ref_dec ( pkt ) ; } | <S2SV_ModStart> ; dts = pts_diff ( ref , pkt -> pkt_dts ) <S2SV_ModEnd> ; if ( |
5,380 | CWE-000 <S2SV_StartBug> static inline ntPubMsg_p __pubMsg_New ( constr subj , int64_t timestamp , convoid data , int data_len ) <S2SV_EndBug> { int time_len = timestamp > - 1 ? 15 : 0 ; int subj_len = strlen ( subj ) + 1 ; int base_len = subj_len + time_len + data_len + 1 ; ntPubMsg_p _out = calloc ( 1 , sizeof ( * _out ) + base_len ) ; if ( ! _out ) return NULL ; _out -> subj = ( char * ) _out + sizeof ( * _out ) ; _out -> data = _out -> subj + subj_len ; _out -> data_len = time_len + data_len ; memcpy ( _out -> subj , subj , subj_len ) ; if ( time_len ) { struct tm time ; time_t sec = timestamp / 1000 ; localtime_r ( & sec , & time ) ; sprintf ( _out -> data , "%4d%02d%02d%02d%02d%02d<S2SV_blank>" , time . tm_year + 1900 , time . tm_mon + 1 , time . tm_mday , time . tm_hour , time . tm_min , time . tm_sec ) ; } memcpy ( _out -> data + time_len , data , data_len ) ; return _out ; } | <S2SV_ModStart> int64_t timestamp , conptr <S2SV_ModEnd> data , int |
5,381 | CWE-000 int sxpi_filtering_init ( void * log_ctx , struct filtering_ctx * ctx , AVThreadMessageQueue * in_queue , <S2SV_StartBug> AVThreadMessageQueue * out_queue , <S2SV_EndBug> const AVCodecContext * avctx , double media_rotation , const struct sxplayer_opts * o ) { int ret ; ctx -> log_ctx = log_ctx ; ctx -> in_queue = in_queue ; ctx -> out_queue = out_queue ; ctx -> sw_pix_fmt = o -> sw_pix_fmt ; ctx -> max_pixels = o -> max_pixels ; ctx -> audio_texture = o -> audio_texture ; <S2SV_StartBug> ctx -> max_pts = o -> trim_duration64 > 0 ? o -> skip64 + o -> trim_duration64 <S2SV_EndBug> : AV_NOPTS_VALUE ; ret = avcodec_parameters_from_context ( ctx -> codecpar , avctx ) ; if ( ret < 0 ) return ret ; if ( ctx -> codecpar -> codec_type == AVMEDIA_TYPE_AUDIO && ctx -> audio_texture ) { int i ; ctx -> window_func_lut = av_malloc_array ( AUDIO_NBSAMPLES , sizeof ( * ctx -> window_func_lut ) ) ; if ( ! ctx -> window_func_lut ) return AVERROR ( ENOMEM ) ; for ( i = 0 ; i < AUDIO_NBSAMPLES ; i ++ ) ctx -> window_func_lut [ i ] = .5f * ( 1 - cos ( 2 * M_PI * i / ( AUDIO_NBSAMPLES - 1 ) ) ) ; ctx -> rdft = av_rdft_init ( AUDIO_NBITS , DFT_R2C ) ; if ( ! ctx -> rdft ) { LOG ( ctx , ERROR , "Unable<S2SV_blank>to<S2SV_blank>init<S2SV_blank>RDFT<S2SV_blank>context<S2SV_blank>with<S2SV_blank>N=%d" , AUDIO_NBITS ) ; return AVERROR ( ENOMEM ) ; } ctx -> rdft_data [ 0 ] = av_mallocz_array ( AUDIO_NBSAMPLES , sizeof ( * ctx -> rdft_data [ 0 ] ) ) ; ctx -> rdft_data [ 1 ] = av_mallocz_array ( AUDIO_NBSAMPLES , sizeof ( * ctx -> rdft_data [ 1 ] ) ) ; if ( ! ctx -> rdft_data [ 0 ] || ! ctx -> rdft_data [ 1 ] ) return AVERROR ( ENOMEM ) ; } if ( o -> filters ) { ctx -> filters = av_strdup ( o -> filters ) ; if ( ! ctx -> filters ) return AVERROR ( ENOMEM ) ; } if ( ctx -> codecpar -> codec_type == AVMEDIA_TYPE_VIDEO && o -> autorotate ) { if ( fabs ( media_rotation - 90 ) < 1.0 ) ctx -> filters = update_filters_str ( ctx -> filters , "transpose=clock" ) ; else if ( fabs ( media_rotation - 180 ) < 1.0 ) ctx -> filters = update_filters_str ( ctx -> filters , "vflip,hflip" ) ; else if ( fabs ( media_rotation - 270 ) < 1.0 ) ctx -> filters = update_filters_str ( ctx -> filters , "transpose=cclock" ) ; TRACE ( ctx , "update<S2SV_blank>filtergraph<S2SV_blank>to:<S2SV_blank>%s" , ctx -> filters ) ; } return 0 ; } | <S2SV_ModStart> AVThreadMessageQueue * out_queue , const AVStream * stream <S2SV_ModStart> ; ctx -> st_timebase = stream -> time_base ; ctx -> <S2SV_ModStart> > 0 ? av_rescale_q ( <S2SV_ModStart> o -> trim_duration64 , AV_TIME_BASE_Q , ctx -> st_timebase ) |
5,382 | CWE-000 void vytvor_soubor_z_pc ( int cilova_slozka , char * filename , char * pc_soubor ) { <S2SV_StartBug> int i , j , k , l , size , ret , potreba_clusteru , adresa , volne_uid , spoj_len , starter ; <S2SV_EndBug> FILE * fr , * fw ; <S2SV_StartBug> char * result , * obsah_z_pc ; <S2SV_EndBug> <S2SV_StartBug> char pom [ 20 ] <S2SV_EndBug> struct mft_fragment mftf ; struct mft_item mfti ; struct mft_item * mpom ; size = 0 ; fr = fopen ( pc_soubor , "r" ) ; if ( fr != NULL ) { fseek ( fr , 0 , SEEK_END ) ; size = ftell ( fr ) ; obsah_z_pc = ( char * ) malloc ( size ) ; printf ( "--<S2SV_blank>size<S2SV_blank>souboru<S2SV_blank>%s<S2SV_blank>je=%d\\n" , pc_soubor , size ) ; fseek ( fr , 0 , SEEK_SET ) ; fread ( obsah_z_pc , 1 , size , fr ) ; printf ( "--<S2SV_blank>nacteno<S2SV_blank>z<S2SV_blank>pocitace:<S2SV_blank>%s\\n" , obsah_z_pc ) ; fclose ( fr ) ; } volne_uid = get_volne_uid ( ) ; potreba_clusteru = size / CLUSTER_SIZE + 1 ; int volne_clustery [ potreba_clusteru ] ; printf ( "--<S2SV_blank>Je<S2SV_blank>potreba<S2SV_blank>%d<S2SV_blank>volnych<S2SV_blank>clusteru\\n" , potreba_clusteru ) ; j = 0 ; for ( i = 0 ; i < CLUSTER_COUNT ; i ++ ) { if ( ntfs_bitmap [ i ] == 0 ) { volne_clustery [ j ] = i ; printf ( "--<S2SV_blank>Volny<S2SV_blank>cluster:<S2SV_blank>%d\\n" , i ) ; j ++ ; } if ( j == potreba_clusteru ) { break ; } } if ( j != potreba_clusteru ) { printf ( "ERROR<S2SV_blank>-<S2SV_blank>NOT<S2SV_blank>ENOUGH<S2SV_blank>CLUSTERS<S2SV_blank>(%d)\\n" , j ) ; return ; } fw = fopen ( output_file , "r+b" ) ; if ( fw != NULL ) { mfti . uid = volne_uid ; mfti . isDirectory = 0 ; mfti . item_order = 1 ; mfti . item_order_total = 1 ; strcpy ( mfti . item_name , filename ) ; mfti . item_size = strlen ( obsah_z_pc ) ; spoj_len = 1 ; starter = 0 ; l = 0 ; for ( j = 0 ; j < potreba_clusteru ; j ++ ) { if ( volne_clustery [ j + 1 ] == volne_clustery [ j ] + 1 ) { spoj_len = spoj_len + 1 ; if ( spoj_len == 2 ) { starter = volne_clustery [ j ] ; } } else { if ( spoj_len != 1 ) { printf ( "f(%d,<S2SV_blank>%d)\\n" , starter , spoj_len ) ; mftf . fragment_start_address = bootr -> data_start_address + starter * CLUSTER_SIZE ; mftf . fragment_count = spoj_len ; mfti . fragments [ l ] = mftf ; l ++ ; } else { printf ( "f(%d,<S2SV_blank>%d)\\n" , volne_clustery [ j ] , spoj_len ) ; mftf . fragment_start_address = bootr -> data_start_address + volne_clustery [ j ] * CLUSTER_SIZE ; mftf . fragment_count = spoj_len ; mfti . fragments [ l ] = mftf ; l ++ ; } spoj_len = 1 ; starter = 0 ; } } if ( spoj_len != 1 ) { printf ( "f(%d,<S2SV_blank>%d)\\n" , starter , spoj_len ) ; mftf . fragment_start_address = bootr -> data_start_address + starter * CLUSTER_SIZE ; mftf . fragment_count = spoj_len ; mfti . fragments [ l ] = mftf ; } for ( j = 0 ; j < potreba_clusteru ; j ++ ) { ntfs_bitmap [ volne_clustery [ j ] ] = 1 ; } fseek ( fw , bootr -> bitmap_start_address , SEEK_SET ) ; fwrite ( ntfs_bitmap , 4 , CLUSTER_COUNT , fw ) ; pridej_prvek_mft ( volne_uid , mfti ) ; mpom = malloc ( sizeof ( struct mft_item ) ) ; mpom = & mfti ; printf ( "--<S2SV_blank>MFTI<S2SV_blank>chci<S2SV_blank>zapsat<S2SV_blank>na<S2SV_blank>adresu<S2SV_blank>%lu\\n" , sizeof ( struct boot_record ) + volne_uid * sizeof ( struct mft_item ) ) ; fseek ( fw , sizeof ( struct boot_record ) + volne_uid * sizeof ( struct mft_item ) , SEEK_SET ) ; fwrite ( mpom , sizeof ( struct mft_item ) , 1 , fw ) ; printf ( "--<S2SV_blank>Zapisuji<S2SV_blank>odkaz<S2SV_blank>na<S2SV_blank>soubor<S2SV_blank>%d<S2SV_blank>do<S2SV_blank>adresare<S2SV_blank>%d\\n" , volne_uid , pwd ) ; sprintf ( pom , "%d" , volne_uid ) ; append_obsah_souboru ( pwd , pom ) ; fclose ( fw ) ; } | <S2SV_ModStart> , j , <S2SV_ModEnd> l , size <S2SV_ModStart> , size , potreba_clusteru , <S2SV_ModEnd> volne_uid , spoj_len <S2SV_ModStart> fw ; char <S2SV_ModEnd> * obsah_z_pc ; <S2SV_ModStart> [ 20 ] ; |
5,383 | CWE-000 static int _remove_accounts ( slurmdbd_conn_t * slurmdbd_conn , persist_msg_t * msg , Buf * out_buffer , uint32_t * uid ) { int rc = SLURM_SUCCESS ; dbd_cond_msg_t * get_msg = msg -> data ; <S2SV_StartBug> dbd_list_msg_t list_msg ; <S2SV_EndBug> char * comment = NULL ; debug2 ( "DBD_REMOVE_ACCOUNTS:<S2SV_blank>called" ) ; if ( ! ( list_msg . my_list = acct_storage_g_remove_accounts ( slurmdbd_conn -> db_conn , * uid , get_msg -> cond ) ) ) { if ( errno == ESLURM_ACCESS_DENIED ) { comment = "Your<S2SV_blank>user<S2SV_blank>doesn\'t<S2SV_blank>have<S2SV_blank>privilege<S2SV_blank>to<S2SV_blank>perform<S2SV_blank>this<S2SV_blank>action" ; rc = ESLURM_ACCESS_DENIED ; } else if ( errno == SLURM_ERROR ) { comment = "Something<S2SV_blank>was<S2SV_blank>wrong<S2SV_blank>with<S2SV_blank>your<S2SV_blank>query" ; rc = SLURM_ERROR ; } else if ( errno == SLURM_NO_CHANGE_IN_DATA ) { comment = "Request<S2SV_blank>didn\'t<S2SV_blank>affect<S2SV_blank>anything" ; rc = SLURM_SUCCESS ; } else if ( errno == ESLURM_DB_CONNECTION ) { comment = slurm_strerror ( errno ) ; rc = errno ; } else { rc = errno ; if ( ! ( comment = slurm_strerror ( errno ) ) ) comment = "Unknown<S2SV_blank>issue" ; } error ( "CONN:%u<S2SV_blank>%s" , slurmdbd_conn -> conn -> fd , comment ) ; * out_buffer = slurm_persist_make_rc_msg ( slurmdbd_conn -> conn , rc , comment , DBD_REMOVE_ACCOUNTS ) ; return rc ; } list_msg . return_code = errno ; * out_buffer = init_buf ( 1024 ) ; pack16 ( ( uint16_t ) DBD_GOT_LIST , * out_buffer ) ; slurmdbd_pack_list_msg ( & list_msg , slurmdbd_conn -> conn -> version , DBD_GOT_LIST , * out_buffer ) ; FREE_NULL_LIST ( list_msg . my_list ) ; return rc ; } | <S2SV_ModStart> ; dbd_list_msg_t list_msg = { NULL } |
5,384 | CWE-000 static struct fq_flow * fq_classify ( struct sk_buff * skb , struct fq_sched_data * q ) { struct rb_node * * p , * parent ; struct sock * sk = skb -> sk ; struct rb_root * root ; struct fq_flow * f ; if ( unlikely ( ( skb -> priority & TC_PRIO_MAX ) == TC_PRIO_CONTROL ) ) return & q -> internal ; if ( ! sk || sk_listener ( sk ) ) { unsigned long hash = skb_get_hash ( skb ) & q -> orphan_mask ; sk = ( struct sock * ) ( ( hash << 1 ) | 1UL ) ; skb_orphan ( skb ) ; } root = & q -> fq_root [ hash_32 ( ( u32 ) ( long ) sk , q -> fq_trees_log ) ] ; if ( q -> flows >= ( 2U << q -> fq_trees_log ) && q -> inactive_flows > q -> flows / 2 ) fq_gc ( q , root , sk ) ; p = & root -> rb_node ; parent = NULL ; while ( * p ) { parent = * p ; f = container_of ( parent , struct fq_flow , fq_node ) ; if ( f -> sk == sk ) { if ( unlikely ( skb -> sk && f -> socket_hash != sk -> sk_hash ) ) { f -> credit = q -> initial_quantum ; f -> socket_hash = sk -> sk_hash ; <S2SV_StartBug> f -> time_next_packet = 0ULL ; <S2SV_EndBug> } return f ; } if ( f -> sk > sk ) p = & parent -> rb_right ; else p = & parent -> rb_left ; } f = kmem_cache_zalloc ( fq_flow_cachep , GFP_ATOMIC | __GFP_NOWARN ) ; if ( unlikely ( ! f ) ) { q -> stat_allocation_errors ++ ; return & q -> internal ; } fq_flow_set_detached ( f ) ; f -> sk = sk ; if ( skb -> sk ) f -> socket_hash = sk -> sk_hash ; f -> credit = q -> initial_quantum ; rb_link_node ( & f -> fq_node , parent , p ) ; rb_insert_color ( & f -> fq_node , root ) ; q -> flows ++ ; q -> inactive_flows ++ ; return f ; } | <S2SV_ModStart> -> sk_hash ; if ( fq_flow_is_throttled ( f ) ) fq_flow_unset_throttled ( q , f ) ; |
5,385 | CWE-000 static void _parameter_string ( string * str , zend_function * fptr , struct _zend_arg_info * arg_info , uint32_t offset , uint32_t required , char * indent ) { string_printf ( str , "Parameter<S2SV_blank>#%d<S2SV_blank>[<S2SV_blank>" , offset ) ; if ( offset >= required ) { string_printf ( str , "<optional><S2SV_blank>" ) ; } else { string_printf ( str , "<required><S2SV_blank>" ) ; } if ( arg_info -> class_name ) { string_printf ( str , "%s<S2SV_blank>" , ( fptr -> type == ZEND_INTERNAL_FUNCTION && ! ( fptr -> common . fn_flags & ZEND_ACC_USER_ARG_INFO ) ) ? ( ( zend_internal_arg_info * ) arg_info ) -> class_name : ZSTR_VAL ( arg_info -> class_name ) ) ; if ( arg_info -> allow_null ) { string_printf ( str , "or<S2SV_blank>NULL<S2SV_blank>" ) ; } } else if ( arg_info -> type_hint ) { string_printf ( str , "%s<S2SV_blank>" , zend_get_type_by_const ( arg_info -> type_hint ) ) ; if ( arg_info -> allow_null ) { string_printf ( str , "or<S2SV_blank>NULL<S2SV_blank>" ) ; } } if ( arg_info -> pass_by_reference ) { string_write ( str , "&" , sizeof ( "&" ) - 1 ) ; } if ( arg_info -> is_variadic ) { string_write ( str , "..." , sizeof ( "..." ) - 1 ) ; } if ( arg_info -> name ) { string_printf ( str , "$%s" , ( fptr -> type == ZEND_INTERNAL_FUNCTION && ! ( fptr -> common . fn_flags & ZEND_ACC_USER_ARG_INFO ) ) ? ( ( zend_internal_arg_info * ) arg_info ) -> name : ZSTR_VAL ( arg_info -> name ) ) ; } else { string_printf ( str , "$param%d" , offset ) ; } if ( fptr -> type == ZEND_USER_FUNCTION && offset >= required ) { zend_op * precv = _get_recv_op ( ( zend_op_array * ) fptr , offset ) ; if ( precv && precv -> opcode == ZEND_RECV_INIT && precv -> op2_type != IS_UNUSED ) { zval zv ; string_write ( str , "<S2SV_blank>=<S2SV_blank>" , sizeof ( "<S2SV_blank>=<S2SV_blank>" ) - 1 ) ; ZVAL_DUP ( & zv , RT_CONSTANT ( & fptr -> op_array , precv -> op2 ) ) ; <S2SV_StartBug> zval_update_constant_ex ( & zv , fptr -> common . scope ) ; <S2SV_EndBug> if ( Z_TYPE ( zv ) == IS_TRUE ) { string_write ( str , "true" , sizeof ( "true" ) - 1 ) ; } else if ( Z_TYPE ( zv ) == IS_FALSE ) { string_write ( str , "false" , sizeof ( "false" ) - 1 ) ; } else if ( Z_TYPE ( zv ) == IS_NULL ) { string_write ( str , "NULL" , sizeof ( "NULL" ) - 1 ) ; } else if ( Z_TYPE ( zv ) == IS_STRING ) { string_write ( str , "\'" , sizeof ( "\'" ) - 1 ) ; string_write ( str , Z_STRVAL ( zv ) , MIN ( Z_STRLEN ( zv ) , 15 ) ) ; if ( Z_STRLEN ( zv ) > 15 ) { string_write ( str , "..." , sizeof ( "..." ) - 1 ) ; } string_write ( str , "\'" , sizeof ( "\'" ) - 1 ) ; } else if ( Z_TYPE ( zv ) == IS_ARRAY ) { string_write ( str , "Array" , sizeof ( "Array" ) - 1 ) ; } else { zend_string * zv_str = zval_get_string ( & zv ) ; string_write ( str , ZSTR_VAL ( zv_str ) , ZSTR_LEN ( zv_str ) ) ; zend_string_release ( zv_str ) ; } zval_ptr_dtor ( & zv ) ; } } string_write ( str , "<S2SV_blank>]" , sizeof ( "<S2SV_blank>]" ) - 1 ) ; } | <S2SV_ModStart> ) ) ; if ( UNEXPECTED ( <S2SV_ModStart> . scope ) == FAILURE ) ) { zval_ptr_dtor ( & zv ) ; return ; } <S2SV_ModEnd> if ( Z_TYPE |
5,386 | CWE-000 static int nc_uri ( ASN1_IA5STRING * uri , ASN1_IA5STRING * base ) { const char * baseptr = ( char * ) base -> data ; const char * hostptr = ( char * ) uri -> data ; const char * p = strchr ( hostptr , ':' ) ; int hostlen ; if ( ! p || ( p [ 1 ] != '/' ) || ( p [ 2 ] != '/' ) ) return X509_V_ERR_UNSUPPORTED_NAME_SYNTAX ; hostptr = p + 3 ; p = strchr ( hostptr , ':' ) ; if ( ! p ) p = strchr ( hostptr , '/' ) ; if ( ! p ) hostlen = strlen ( hostptr ) ; else hostlen = p - hostptr ; if ( hostlen == 0 ) return X509_V_ERR_UNSUPPORTED_NAME_SYNTAX ; if ( * baseptr == '.' ) { if ( hostlen > base -> length ) { p = hostptr + hostlen - base -> length ; <S2SV_StartBug> if ( ! strncasecmp ( p , baseptr , base -> length ) ) <S2SV_EndBug> return X509_V_OK ; } return X509_V_ERR_PERMITTED_VIOLATION ; } if ( ( base -> length != ( int ) hostlen ) <S2SV_StartBug> || strncasecmp ( hostptr , baseptr , hostlen ) ) <S2SV_EndBug> return X509_V_ERR_PERMITTED_VIOLATION ; return X509_V_OK ; } | <S2SV_ModStart> ; if ( ia5ncasecmp ( p , baseptr , base -> length ) == 0 <S2SV_ModEnd> ) return X509_V_OK <S2SV_ModStart> hostlen ) || ia5ncasecmp <S2SV_ModEnd> ( hostptr , |
5,387 | CWE-000 static gboolean spice_usb_device_manager_initable_init ( GInitable * initable , GCancellable * cancellable , GError * * err ) { SpiceUsbDeviceManager * self = SPICE_USB_DEVICE_MANAGER ( initable ) ; SpiceUsbDeviceManagerPrivate * priv = self -> priv ; <S2SV_StartBug> g_print ( "spice_usb_device_manager_initable_init<S2SV_blank>%p<S2SV_blank>max_luns:%d\\n" , self , priv -> max_luns ) ; <S2SV_EndBug> return TRUE ; } | <S2SV_ModStart> ; g_print ( "spice_usb_device_manager_initable_init<S2SV_blank>%p<S2SV_blank>max_luns:%u\\n" <S2SV_ModEnd> , self , |
5,388 | CWE-000 static void ui_init ( UIState * s ) { memset ( s , 0 , sizeof ( UIState ) ) ; pthread_mutex_init ( & s -> lock , NULL ) ; pthread_cond_init ( & s -> bg_cond , NULL ) ; s -> status = STATUS_DISENGAGED ; strcpy ( s -> car_model , "Tesla" ) ; strcpy ( s -> car_folder , "tesla" ) ; s -> label_last_modified = 0 ; s -> status_last_modified = 0 ; s -> thermal_sock = zsock_new_sub ( ">tcp://127.0.0.1:8005" , "" ) ; assert ( s -> thermal_sock ) ; s -> thermal_sock_raw = zsock_resolve ( s -> thermal_sock ) ; s -> gps_sock = zsock_new_sub ( ">tcp://127.0.0.1:8032" , "" ) ; assert ( s -> gps_sock ) ; s -> gps_sock_raw = zsock_resolve ( s -> gps_sock ) ; s -> model_sock = zsock_new_sub ( ">tcp://127.0.0.1:8009" , "" ) ; assert ( s -> model_sock ) ; s -> model_sock_raw = zsock_resolve ( s -> model_sock ) ; s -> live100_sock = zsock_new_sub ( ">tcp://127.0.0.1:8007" , "" ) ; assert ( s -> live100_sock ) ; s -> live100_sock_raw = zsock_resolve ( s -> live100_sock ) ; s -> uilayout_sock = zsock_new_sub ( ">tcp://127.0.0.1:8060" , "" ) ; assert ( s -> uilayout_sock ) ; s -> uilayout_sock_raw = zsock_resolve ( s -> uilayout_sock ) ; s -> livecalibration_sock = zsock_new_sub ( ">tcp://127.0.0.1:8019" , "" ) ; assert ( s -> livecalibration_sock ) ; s -> livecalibration_sock_raw = zsock_resolve ( s -> livecalibration_sock ) ; s -> live20_sock = zsock_new_sub ( ">tcp://127.0.0.1:8012" , "" ) ; assert ( s -> live20_sock ) ; s -> live20_sock_raw = zsock_resolve ( s -> live20_sock ) ; s -> livempc_sock = zsock_new_sub ( ">tcp://127.0.0.1:8035" , "" ) ; assert ( s -> livempc_sock ) ; s -> livempc_sock_raw = zsock_resolve ( s -> livempc_sock ) ; s -> plus_sock = zsock_new_sub ( ">tcp://127.0.0.1:8037" , "" ) ; assert ( s -> plus_sock ) ; s -> plus_sock_raw = zsock_resolve ( s -> plus_sock ) ; s -> uiButtonInfo_sock = zsock_new_sub ( ">tcp://127.0.0.1:8201" , "" ) ; assert ( s -> uiButtonInfo_sock ) ; s -> uiButtonInfo_sock_raw = zsock_resolve ( s -> uiButtonInfo_sock ) ; s -> uiCustomAlert_sock = zsock_new_sub ( ">tcp://127.0.0.1:8202" , "" ) ; assert ( s -> uiCustomAlert_sock ) ; s -> uiCustomAlert_sock_raw = zsock_resolve ( s -> uiCustomAlert_sock ) ; s -> uiSetCar_sock = zsock_new_sub ( ">tcp://127.0.0.1:8203" , "" ) ; assert ( s -> uiSetCar_sock ) ; s -> uiSetCar_sock_raw = zsock_resolve ( s -> uiSetCar_sock ) ; s -> uiPlaySound_sock = zsock_new_sub ( ">tcp://127.0.0.1:8205" , "" ) ; assert ( s -> uiPlaySound_sock ) ; s -> uiPlaySound_sock_raw = zsock_resolve ( s -> uiPlaySound_sock ) ; s -> uiButtonStatus_sock = zsock_new_pub ( ">tcp://127.0.0.1:8204" ) ; assert ( s -> uiButtonStatus_sock ) ; s -> uiButtonStatus_sock_raw = zsock_resolve ( s -> uiButtonStatus_sock ) ; s -> ipc_fd = - 1 ; s -> fb = framebuffer_init ( "ui" , 0x00010000 , true , & s -> display , & s -> surface , & s -> fb_w , & s -> fb_h ) ; assert ( s -> fb ) ; set_awake ( s , true ) ; s -> vg = nvgCreateGLES3 ( NVG_ANTIALIAS | NVG_STENCIL_STROKES | NVG_DEBUG ) ; assert ( s -> vg ) ; s -> font_courbd = nvgCreateFont ( s -> vg , "courbd" , "../assets/courbd.ttf" ) ; assert ( s -> font_courbd >= 0 ) ; s -> font_sans_regular = nvgCreateFont ( s -> vg , "sans-regular" , "../assets/OpenSans-Regular.ttf" ) ; assert ( s -> font_sans_regular >= 0 ) ; s -> font_sans_semibold = nvgCreateFont ( s -> vg , "sans-semibold" , "../assets/OpenSans-SemiBold.ttf" ) ; assert ( s -> font_sans_semibold >= 0 ) ; s -> font_sans_bold = nvgCreateFont ( s -> vg , "sans-bold" , "../assets/OpenSans-Bold.ttf" ) ; assert ( s -> font_sans_bold >= 0 ) ; assert ( s -> img_wheel >= 0 ) ; s -> img_wheel = nvgCreateImage ( s -> vg , "../assets/img_chffr_wheel.png" , 1 ) ; <S2SV_StartBug> s -> frame_program = load_program ( frame_vertex_shader , frame_fragment_shader ) ; <S2SV_EndBug> assert ( s -> frame_program ) ; s -> frame_pos_loc = glGetAttribLocation ( s -> frame_program , "aPosition" ) ; s -> frame_texcoord_loc = glGetAttribLocation ( s -> frame_program , "aTexCoord" ) ; s -> frame_texture_loc = glGetUniformLocation ( s -> frame_program , "uTexture" ) ; s -> frame_transform_loc = glGetUniformLocation ( s -> frame_program , "uTransform" ) ; s -> line_program = load_program ( line_vertex_shader , line_fragment_shader ) ; assert ( s -> line_program ) ; s -> line_pos_loc = glGetAttribLocation ( s -> line_program , "aPosition" ) ; s -> line_color_loc = glGetAttribLocation ( s -> line_program , "aColor" ) ; s -> line_transform_loc = glGetUniformLocation ( s -> line_program , "uTransform" ) ; glViewport ( 0 , 0 , s -> fb_w , s -> fb_h ) ; glDisable ( GL_DEPTH_TEST ) ; assert ( glGetError ( ) == GL_NO_ERROR ) ; s -> acc_enabled = false ; { char * value ; const int result = read_db_value ( NULL , "Passive" , & value , NULL ) ; if ( result == 0 ) { s -> passive = value [ 0 ] == '1' ; free ( value ) ; } } } | <S2SV_ModStart> ; s -> img_logo = nvgCreateImage ( s -> vg , "../assets/img_spinner_comma.png" , 1 ) ; s -> |
5,389 | CWE-000 void kmsan_vmap ( struct vm_struct * area , struct page * * pages , unsigned int count , unsigned long flags , pgprot_t prot , void * caller ) { struct vm_struct * shadow , * origin ; struct page * * s_pages , * * o_pages ; unsigned long irq_flags , size ; int i ; if ( ! kmsan_ready || IN_RUNTIME ( ) ) return ; size = ( unsigned long ) count << PAGE_SHIFT ; shadow = get_vm_area_caller ( size , flags , caller ) ; origin = get_vm_area_caller ( size , flags , caller ) ; s_pages = kmalloc ( count * sizeof ( struct page * ) , GFP_KERNEL ) ; if ( ! s_pages ) goto err_free ; o_pages = kmalloc ( count * sizeof ( struct page * ) , GFP_KERNEL ) ; for ( i = 0 ; i < count ; i ++ ) { <S2SV_StartBug> if ( pages [ i ] -> is_kmsan_untracked_page ) <S2SV_EndBug> goto err_free ; s_pages [ i ] = pages [ i ] -> shadow ; o_pages [ i ] = pages [ i ] -> origin ; } ENTER_RUNTIME ( irq_flags ) ; if ( map_vm_area ( shadow , prot , s_pages ) || map_vm_area ( origin , prot , o_pages ) ) goto err_free ; LEAVE_RUNTIME ( irq_flags ) ; shadow -> pages = s_pages ; shadow -> nr_pages = count ; shadow -> is_kmsan_tracked = false ; origin -> pages = o_pages ; origin -> nr_pages = count ; origin -> is_kmsan_tracked = false ; area -> shadow = shadow ; area -> origin = origin ; area -> is_kmsan_tracked = true ; return ; err_free : if ( s_pages ) kfree ( s_pages ) ; if ( o_pages ) kfree ( o_pages ) ; if ( shadow ) vunmap ( shadow -> addr ) ; if ( origin ) vunmap ( origin -> addr ) ; } | <S2SV_ModStart> { if ( ! pages [ i ] -> is_kmsan_tracked_page <S2SV_ModEnd> ) goto err_free |
5,390 | CWE-000 <S2SV_StartBug> QS_FUNC ( qsf_run ) <S2SV_EndBug> { qs_value_t * func_v = QS_ARGV ( 0 ) ; qs_list_t * l = malloc ( sizeof ( qs_list_t ) ) ; <S2SV_StartBug> l -> value_count = args - 1 ; <S2SV_EndBug> l -> values = arg + 1 ; qs_action_t * a = malloc ( sizeof ( qs_action_t ) ) ; memset ( a , 0 , sizeof ( qs_action_t ) ) ; a -> action_id = QS_ACTION_CALL ; a -> data_p = l ; a -> parent_value = action -> parent_value ; a -> node = action -> node ; qs_value_t * rval = qs_action_call ( exe , func_v , a ) ; free ( a ) ; free ( l ) ; return rval ; } | <S2SV_ModStart> <S2SV_null> QS_FUNC ( qsf_vars ) { qs_execute_t * e = qs_execute_get_block ( exe ) ; int i ; for ( i = 0 ; i < args ; i ++ ) qs_variable_new_execute ( e , QS_ARGS ( i <S2SV_ModEnd> ) ) ; <S2SV_ModStart> ) ) ; return QS_RETI ( args ) <S2SV_ModEnd> ; } <S2SV_null> |
5,391 | CWE-000 int main ( ) { igraph_t g , g2 ; igraph_bool_t iso ; igraph_lcf ( & g , 12 , 5 , - 5 , 6 , 0 ) ; igraph_famous ( & g2 , "franklin" ) ; igraph_isomorphic_vf2 ( & g , & g2 , 0 , 0 , 0 , 0 , & iso , 0 , 0 , 0 , 0 , 0 ) ; if ( ! iso ) { printf ( "Failure:<S2SV_blank>Franklin\\n" ) ; return 1 ; } igraph_destroy ( & g ) ; igraph_destroy ( & g2 ) ; igraph_lcf ( & g , 8 , 3 , - 2 , 4 , 0 ) ; if ( igraph_ecount ( & g ) != 16 ) { printf ( "Failure:<S2SV_blank>[3,<S2SV_blank>-2]^4,<S2SV_blank>n=8\\n" ) ; return 1 ; } igraph_destroy ( & g ) ; igraph_lcf ( & g , 2 , 2 , - 2 , 2 , 0 ) ; if ( igraph_ecount ( & g ) != 1 ) { printf ( "Failure:<S2SV_blank>[2,<S2SV_blank>-2]^2,<S2SV_blank>n=2\\n" ) ; return 1 ; } igraph_destroy ( & g ) ; igraph_lcf ( & g , 2 , 2 , 2 , 0 ) ; if ( igraph_ecount ( & g ) != 1 ) { printf ( "Failure:<S2SV_blank>[2]^2,<S2SV_blank>n=2\\n" ) ; return 1 ; } igraph_destroy ( & g ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> g ) ; igraph_lcf ( & g , 0 ) ; if ( igraph_vcount ( & g ) != 0 || igraph_ecount ( & g ) != 0 ) { printf ( "Failure:<S2SV_blank>regression<S2SV_blank>test<S2SV_blank>for<S2SV_blank>#996\\n" ) ; return 1 ; } igraph_destroy ( & g ) ; |
5,392 | CWE-000 void ANIM_animdata_update ( bAnimContext * ac , ListBase * anim_data ) { bAnimListElem * ale ; if ( ELEM ( ac -> datatype , ANIMCONT_MASK ) ) { # ifdef DEBUG for ( ale = anim_data -> first ; ale ; ale = ale -> next ) { ale -> update = 0 ; } # endif return ; } for ( ale = anim_data -> first ; ale ; ale = ale -> next ) { if ( ale -> type == ANIMTYPE_GPLAYER ) { bGPDlayer * gpl = ale -> data ; if ( ale -> update & ANIM_UPDATE_ORDER ) { ale -> update &= ~ ANIM_UPDATE_ORDER ; if ( gpl ) { } } if ( ale -> update & ANIM_UPDATE_DEPS ) { ale -> update &= ~ ANIM_UPDATE_DEPS ; ANIM_list_elem_update ( ac -> bmain , ac -> scene , ale ) ; } <S2SV_StartBug> } <S2SV_EndBug> else if ( ale -> datatype == ALE_FCURVE ) { FCurve * fcu = ale -> key_data ; if ( ale -> update & ANIM_UPDATE_ORDER ) { ale -> update &= ~ ANIM_UPDATE_ORDER ; if ( fcu ) sort_time_fcurve ( fcu ) ; } if ( ale -> update & ANIM_UPDATE_HANDLES ) { ale -> update &= ~ ANIM_UPDATE_HANDLES ; if ( fcu ) calchandles_fcurve ( fcu ) ; } if ( ale -> update & ANIM_UPDATE_DEPS ) { ale -> update &= ~ ANIM_UPDATE_DEPS ; ANIM_list_elem_update ( ac -> bmain , ac -> scene , ale ) ; } } else if ( ale -> datatype == ALE_NLASTRIP ) { if ( ale -> update & ANIM_UPDATE_DEPS ) { ale -> update &= ~ ANIM_UPDATE_DEPS ; ANIM_list_elem_update ( ac -> bmain , ac -> scene , ale ) ; } } else if ( ale -> update ) { # if 0 if ( G . debug & G_DEBUG ) { printf ( "%s:<S2SV_blank>Unhandled<S2SV_blank>animchannel<S2SV_blank>updates<S2SV_blank>(%d)<S2SV_blank>for<S2SV_blank>type=%d<S2SV_blank>(%p)\\n" , __func__ , ale -> update , ale -> type , ale -> data ) ; } # endif ale -> update = 0 ; } BLI_assert ( ale -> update == 0 ) ; } } | <S2SV_ModStart> ) ; } if ( ale -> update & ANIM_UPDATE_HANDLES ) { ale -> update &= ~ ANIM_UPDATE_HANDLES ; } |
5,393 | CWE-000 <S2SV_StartBug> __attribute__ ( ( leaf , warn_unused_result ) ) <S2SV_EndBug> size_t darr_resize_exact ( size_t inc , void * restrict unused ) { return inc ; } | <S2SV_ModStart> __attribute__ ( ( const , |
5,394 | CWE-000 static void fileio_release_on_update_headers_con_cb ( gpointer client , gpointer ctx ) { HttpConnection * con = ( HttpConnection * ) client ; FileIO * fop = ( FileIO * ) ctx ; gchar * path ; gchar * cpy_path ; gboolean res ; unsigned char digest [ 16 ] ; gchar * md5str ; size_t i ; <S2SV_StartBug> LOG_debug ( FIO_LOG , INO_CON_H "Updating<S2SV_blank>object\'s<S2SV_blank>headers.." , INO_T ( fop -> ino ) , con ) ; <S2SV_EndBug> http_connection_acquire ( con ) ; if ( fop -> content_type ) http_connection_add_output_header ( con , "Content-Type" , fop -> content_type ) ; http_connection_add_output_header ( con , "x-amz-metadata-directive" , "REPLACE" ) ; http_connection_add_output_header ( con , "x-amz-storage-class" , conf_get_string ( application_get_conf ( con -> app ) , "s3.storage_type" ) ) ; MD5_Final ( digest , & fop -> md5 ) ; md5str = g_malloc ( 33 ) ; for ( i = 0 ; i < 16 ; ++ i ) sprintf ( & md5str [ i * 2 ] , "%02x" , ( unsigned int ) digest [ i ] ) ; http_connection_add_output_header ( con , "x-amz-meta-md5" , md5str ) ; g_free ( md5str ) ; cpy_path = g_strdup_printf ( "%s%s" , conf_get_string ( application_get_conf ( fop -> app ) , "s3.bucket_name" ) , fop -> fname ) ; http_connection_add_output_header ( con , "x-amz-copy-source" , cpy_path ) ; g_free ( cpy_path ) ; path = g_strdup_printf ( "%s" , fop -> fname ) ; res = http_connection_make_request ( con , path , "PUT" , NULL , TRUE , NULL , fileio_release_on_update_header_cb , fop ) ; g_free ( path ) ; if ( ! res ) { <S2SV_StartBug> LOG_err ( FIO_LOG , INO_CON_H "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>HTTP<S2SV_blank>request<S2SV_blank>!" , INO_T ( fop -> ino ) , con ) ; <S2SV_EndBug> http_connection_release ( con ) ; fileio_destroy ( fop ) ; return ; } } | <S2SV_ModStart> ino ) , ( void * ) <S2SV_ModStart> ino ) , ( void * ) |
5,395 | CWE-000 void buzz ( void ) { int max = 0 ; if ( lewa == 0 && srodek == 0 && prawa == 0 ) { TIM_Cmd ( TIM4 , DISABLE ) ; <S2SV_StartBug> GPIO_ResetBits ( GPIOA , GPIO_Pin_7 ) ; <S2SV_EndBug> } else TIM_Cmd ( TIM4 , ENABLE ) ; if ( lewa >= srodek && lewa >= prawa ) max = lewa ; if ( srodek >= lewa && srodek >= prawa ) max = srodek ; if ( prawa >= lewa && prawa >= srodek ) max = prawa ; if ( max == 1 ) { TIM4 -> PSC = 10000 - 1 ; } if ( max == 2 ) { TIM4 -> PSC = 5000 - 1 ; } if ( max == 3 ) TIM4 -> PSC = 1000 - 1 ; } | <S2SV_ModStart> ; GPIO_ResetBits ( GPIOC , GPIO_Pin_1 <S2SV_ModEnd> ) ; } |
5,396 | CWE-000 static int nilfs_ioctl_change_cpmode ( struct inode * inode , struct file * filp , unsigned int cmd , void __user * argp ) { struct the_nilfs * nilfs = inode -> i_sb -> s_fs_info ; struct nilfs_transaction_info ti ; struct nilfs_cpmode cpmode ; int ret ; if ( ! capable ( CAP_SYS_ADMIN ) ) return - EPERM ; ret = mnt_want_write ( filp -> f_path . mnt ) ; if ( ret ) return ret ; ret = - EFAULT ; if ( copy_from_user ( & cpmode , argp , sizeof ( cpmode ) ) ) goto out ; <S2SV_StartBug> down_read ( & inode -> i_sb -> s_umount ) ; <S2SV_EndBug> nilfs_transaction_begin ( inode -> i_sb , & ti , 0 ) ; ret = nilfs_cpfile_change_cpmode ( nilfs -> ns_cpfile , cpmode . cm_cno , cpmode . cm_mode ) ; if ( unlikely ( ret < 0 ) ) nilfs_transaction_abort ( inode -> i_sb ) ; else nilfs_transaction_commit ( inode -> i_sb ) ; <S2SV_StartBug> up_read ( & inode -> i_sb -> s_umount ) ; <S2SV_EndBug> out : mnt_drop_write ( filp -> f_path . mnt ) ; return ret ; } | <S2SV_ModStart> goto out ; mutex_lock ( & nilfs -> ns_snapshot_mount_mutex <S2SV_ModEnd> ) ; nilfs_transaction_begin <S2SV_ModStart> i_sb ) ; mutex_unlock ( & nilfs -> ns_snapshot_mount_mutex <S2SV_ModEnd> ) ; out |
5,397 | CWE-000 static int ade7758_ring_preenable ( struct iio_dev * indio_dev ) { <S2SV_StartBug> struct ade7758_state * st = iio_priv ( indio_dev ) ; <S2SV_EndBug> unsigned channel ; int ret ; if ( ! bitmap_empty ( indio_dev -> active_scan_mask , indio_dev -> masklength ) ) return - EINVAL ; ret = iio_sw_buffer_preenable ( indio_dev ) ; if ( ret < 0 ) return ret ; channel = find_first_bit ( indio_dev -> active_scan_mask , indio_dev -> masklength ) ; ade7758_write_waveform_type ( & indio_dev -> dev , <S2SV_StartBug> st -> ade7758_ring_channels [ channel ] . address ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> indio_dev ) { <S2SV_ModEnd> unsigned channel ; <S2SV_ModStart> -> dev , indio_dev -> channels <S2SV_ModEnd> [ channel ] |
5,398 | CWE-000 bool ok_to_excute ( ) { int ret ; if ( if_state == WANT_THEN ) { ret = syn_error ( "then<S2SV_blank>expected!" ) ; } else if ( if_state == THEN_BLOCK && if_result == SUCCESS ) ret = 1 ; else if ( if_state == THEN_BLOCK && if_result == FAIL ) ret = 0 ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> = 0 ; else if ( if_state == NEUTRAL ) ret = 1 ; return ret == 1 ? true : false ; |
5,399 | CWE-000 esp_gatt_status_t esp_ble_gattc_unregister_for_notify ( esp_gatt_if_t gatt_if , esp_bd_addr_t server_bda , esp_gatt_srvc_id_t * srvc_id , esp_gatt_id_t * char_id ) { btc_msg_t msg ; btc_ble_gattc_args_t arg ; msg . sig = BTC_SIG_API_CALL ; msg . pid = BTC_PID_GATTC ; msg . act = BTC_GATTC_ACT_UNREG_FOR_NOTIFY ; arg . unreg_for_notify . gatt_if = gatt_if ; <S2SV_StartBug> memcpy ( & arg . unreg_for_notify . remote_bda , & server_bda , sizeof ( esp_bd_addr_t ) ) ; <S2SV_EndBug> memcpy ( & arg . unreg_for_notify . service_id , srvc_id , sizeof ( esp_gatt_srvc_id_t ) ) ; memcpy ( & arg . unreg_for_notify . char_id , char_id , sizeof ( esp_gatt_id_t ) ) ; return ( btc_transfer_context ( & msg , & arg , sizeof ( btc_ble_gattc_args_t ) , NULL ) == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL ) ; } | <S2SV_ModStart> ; memcpy ( <S2SV_ModEnd> arg . unreg_for_notify <S2SV_ModStart> . remote_bda , <S2SV_ModEnd> server_bda , sizeof |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.