Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
1,700 | CWE-000 <S2SV_StartBug> void set_motor_left_direction_reverse ( ) { <S2SV_EndBug> set_pin_x_clear_pin_y ( MOTOR_LEFT_R_GPIO , MOTOR_LEFT_F_GPIO ) ; } | <S2SV_ModStart> ( ) { ESP_LOGD ( TAG , ">><S2SV_blank>setting<S2SV_blank>motor<S2SV_blank>left<S2SV_blank>reverse" ) ; |
1,701 | CWE-000 static void gen9_avc_pak_context_destroy ( void * context ) { struct encoder_vme_mfc_context * pak_context = ( struct encoder_vme_mfc_context * ) context ; <S2SV_StartBug> struct generic_encoder_context * generic_ctx = ( struct generic_encoder_context * ) pak_context -> generic_enc_ctx ; <S2SV_EndBug> <S2SV_StartBug> struct i965_avc_encoder_context * avc_ctx = ( struct i965_avc_encoder_context * ) pak_context -> private_enc_ctx ; <S2SV_EndBug> int i = 0 ; if ( ! pak_context ) return ; i965_free_gpe_resource ( & generic_ctx -> res_reconstructed_surface ) ; i965_free_gpe_resource ( & avc_ctx -> res_post_deblocking_output ) ; i965_free_gpe_resource ( & avc_ctx -> res_pre_deblocking_output ) ; i965_free_gpe_resource ( & generic_ctx -> res_uncompressed_input_surface ) ; i965_free_gpe_resource ( & generic_ctx -> compressed_bitstream . res ) ; i965_free_gpe_resource ( & avc_ctx -> res_intra_row_store_scratch_buffer ) ; i965_free_gpe_resource ( & avc_ctx -> res_deblocking_filter_row_store_scratch_buffer ) ; i965_free_gpe_resource ( & avc_ctx -> res_bsd_mpc_row_store_scratch_buffer ) ; i965_free_gpe_resource ( & avc_ctx -> res_pak_mb_status_buffer ) ; for ( i = 0 ; i < MAX_MFC_AVC_REFERENCE_SURFACES ; i ++ ) { i965_free_gpe_resource ( & avc_ctx -> list_reference_res [ i ] ) ; } for ( i = 0 ; i < NUM_MFC_AVC_DMV_BUFFERS ; i ++ ) { i965_free_gpe_resource ( & avc_ctx -> res_direct_mv_buffersr [ i ] ) ; } if ( avc_ctx -> pres_slice_batch_buffer_2nd_level ) { intel_batchbuffer_free ( avc_ctx -> pres_slice_batch_buffer_2nd_level ) ; avc_ctx -> pres_slice_batch_buffer_2nd_level = NULL ; } } | <S2SV_ModStart> generic_encoder_context * generic_ctx ; struct i965_avc_encoder_context * avc_ctx ; int i = 0 ; if ( ! pak_context ) return ; generic_ctx <S2SV_ModStart> -> generic_enc_ctx ; avc_ctx = ( <S2SV_ModStart> struct i965_avc_encoder_context * <S2SV_ModEnd> ) pak_context -> <S2SV_ModStart> pak_context -> private_enc_ctx <S2SV_ModEnd> ; i965_free_gpe_resource ( |
1,702 | CWE-000 int ocp_nlp_dims_calculate_size_self ( int N ) { int size = 0 ; size += sizeof ( ocp_nlp_dims ) ; size += 4 * ( N + 1 ) * sizeof ( int ) ; size += N * sizeof ( void * ) ; size += ( N + 1 ) * sizeof ( void * ) ; size += ( N + 1 ) * sizeof ( void * ) ; size += ocp_qp_dims_calculate_size ( N ) ; <S2SV_StartBug> size += 8 ; <S2SV_EndBug> return size ; } | <S2SV_ModStart> ; size += sizeof ( ocp_nlp_reg_dims ) ; size += |
1,703 | CWE-000 __uint32_t string_hash_func ( void * key ) { char * str = ( char * ) key ; __uint32_t hash_value = 0 ; <S2SV_StartBug> while ( str ) { <S2SV_EndBug> hash_value = ( hash_value << 5 ) + hash_value + * str ; ++ str ; } return hash_value ; } | <S2SV_ModStart> ; while ( * |
1,704 | CWE-000 static int stm32_dfsdm_adc_probe ( struct platform_device * pdev ) { struct device * dev = & pdev -> dev ; struct stm32_dfsdm_adc * adc ; struct device_node * np = dev -> of_node ; const struct stm32_dfsdm_dev_data * dev_data ; struct iio_dev * iio ; char * name ; int ret , irq , val ; dev_data = of_device_get_match_data ( dev ) ; iio = devm_iio_device_alloc ( dev , sizeof ( * adc ) ) ; if ( ! iio ) { dev_err ( dev , "%s:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>IIO\\n" , __func__ ) ; return - ENOMEM ; } adc = iio_priv ( iio ) ; adc -> dfsdm = dev_get_drvdata ( dev -> parent ) ; iio -> dev . parent = dev ; iio -> dev . of_node = np ; iio -> modes = INDIO_DIRECT_MODE | INDIO_BUFFER_SOFTWARE ; platform_set_drvdata ( pdev , adc ) ; ret = of_property_read_u32 ( dev -> of_node , "reg" , & adc -> fl_id ) ; if ( ret != 0 ) { dev_err ( dev , "Missing<S2SV_blank>reg<S2SV_blank>property\\n" ) ; return - EINVAL ; } name = devm_kzalloc ( dev , sizeof ( "dfsdm-adc0" ) , GFP_KERNEL ) ; if ( ! name ) return - ENOMEM ; if ( dev_data -> type == DFSDM_AUDIO ) { iio -> info = & stm32_dfsdm_info_audio ; snprintf ( name , sizeof ( "dfsdm-pdm0" ) , "dfsdm-pdm%d" , adc -> fl_id ) ; } else { iio -> info = & stm32_dfsdm_info_adc ; snprintf ( name , sizeof ( "dfsdm-adc0" ) , "dfsdm-adc%d" , adc -> fl_id ) ; } iio -> name = name ; irq = platform_get_irq ( pdev , 0 ) ; ret = devm_request_irq ( dev , irq , stm32_dfsdm_irq , 0 , pdev -> name , adc ) ; if ( ret < 0 ) { dev_err ( dev , "Failed<S2SV_blank>to<S2SV_blank>request<S2SV_blank>IRQ\\n" ) ; return ret ; } ret = of_property_read_u32 ( dev -> of_node , "st,filter-order" , & val ) ; if ( ret < 0 ) { dev_err ( dev , "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>filter<S2SV_blank>order\\n" ) ; return ret ; } adc -> dfsdm -> fl_list [ adc -> fl_id ] . ford = val ; ret = of_property_read_u32 ( dev -> of_node , "st,filter0-sync" , & val ) ; if ( ! ret ) adc -> dfsdm -> fl_list [ adc -> fl_id ] . sync_mode = val ; adc -> dev_data = dev_data ; ret = dev_data -> init ( iio ) ; if ( ret < 0 ) return ret ; ret = iio_device_register ( iio ) ; if ( ret < 0 ) goto err_cleanup ; <S2SV_StartBug> dev_err ( dev , "of_platform_populate\\n" ) ; <S2SV_EndBug> if ( dev_data -> type == DFSDM_AUDIO ) { ret = of_platform_populate ( np , NULL , NULL , dev ) ; if ( ret < 0 ) { dev_err ( dev , "Failed<S2SV_blank>to<S2SV_blank>find<S2SV_blank>an<S2SV_blank>audio<S2SV_blank>DAI\\n" ) ; goto err_unregister ; } } return 0 ; err_unregister : iio_device_unregister ( iio ) ; err_cleanup : stm32_dfsdm_dma_release ( iio ) ; return ret ; } | <S2SV_ModStart> goto err_cleanup ; <S2SV_ModEnd> if ( dev_data |
1,705 | CWE-000 static int do_read_inode ( struct inode * inode ) { struct f2fs_sb_info * sbi = F2FS_I_SB ( inode ) ; struct f2fs_inode_info * fi = F2FS_I ( inode ) ; struct page * node_page ; struct f2fs_inode * ri ; projid_t i_projid ; if ( check_nid_range ( sbi , inode -> i_ino ) ) { f2fs_msg ( inode -> i_sb , KERN_ERR , "bad<S2SV_blank>inode<S2SV_blank>number:<S2SV_blank>%lu" , ( unsigned long ) inode -> i_ino ) ; WARN_ON ( 1 ) ; return - EINVAL ; } node_page = get_node_page ( sbi , inode -> i_ino ) ; if ( IS_ERR ( node_page ) ) return PTR_ERR ( node_page ) ; ri = F2FS_INODE ( node_page ) ; inode -> i_mode = le16_to_cpu ( ri -> i_mode ) ; i_uid_write ( inode , le32_to_cpu ( ri -> i_uid ) ) ; i_gid_write ( inode , le32_to_cpu ( ri -> i_gid ) ) ; set_nlink ( inode , le32_to_cpu ( ri -> i_links ) ) ; inode -> i_size = le64_to_cpu ( ri -> i_size ) ; inode -> i_blocks = SECTOR_FROM_BLOCK ( le64_to_cpu ( ri -> i_blocks ) - 1 ) ; inode -> i_atime . tv_sec = le64_to_cpu ( ri -> i_atime ) ; inode -> i_ctime . tv_sec = le64_to_cpu ( ri -> i_ctime ) ; inode -> i_mtime . tv_sec = le64_to_cpu ( ri -> i_mtime ) ; inode -> i_atime . tv_nsec = le32_to_cpu ( ri -> i_atime_nsec ) ; inode -> i_ctime . tv_nsec = le32_to_cpu ( ri -> i_ctime_nsec ) ; inode -> i_mtime . tv_nsec = le32_to_cpu ( ri -> i_mtime_nsec ) ; inode -> i_generation = le32_to_cpu ( ri -> i_generation ) ; fi -> i_current_depth = le32_to_cpu ( ri -> i_current_depth ) ; fi -> i_xattr_nid = le32_to_cpu ( ri -> i_xattr_nid ) ; fi -> i_flags = le32_to_cpu ( ri -> i_flags ) ; fi -> flags = 0 ; fi -> i_advise = ri -> i_advise ; fi -> i_pino = le32_to_cpu ( ri -> i_pino ) ; fi -> i_dir_level = ri -> i_dir_level ; if ( f2fs_init_extent_tree ( inode , & ri -> i_ext ) ) set_page_dirty ( node_page ) ; get_inline_info ( inode , ri ) ; fi -> i_extra_isize = f2fs_has_extra_attr ( inode ) ? le16_to_cpu ( ri -> i_extra_isize ) : 0 ; if ( f2fs_sb_has_flexible_inline_xattr ( sbi -> sb ) ) { f2fs_bug_on ( sbi , ! f2fs_has_extra_attr ( inode ) ) ; fi -> i_inline_xattr_size = le16_to_cpu ( ri -> i_inline_xattr_size ) ; } else if ( f2fs_has_inline_xattr ( inode ) || f2fs_has_inline_dentry ( inode ) ) { fi -> i_inline_xattr_size = DEFAULT_INLINE_XATTR_ADDRS ; } else { fi -> i_inline_xattr_size = 0 ; } if ( f2fs_has_inline_data ( inode ) && ! f2fs_exist_data ( inode ) ) __recover_inline_status ( inode , node_page ) ; __get_inode_rdev ( inode , ri ) ; if ( __written_first_block ( ri ) ) set_inode_flag ( inode , FI_FIRST_BLOCK_WRITTEN ) ; if ( ! need_inode_block_update ( sbi , inode -> i_ino ) ) fi -> last_disk_size = inode -> i_size ; <S2SV_StartBug> if ( fi -> i_flags & FS_PROJINHERIT_FL ) <S2SV_EndBug> set_inode_flag ( inode , FI_PROJ_INHERIT ) ; if ( f2fs_has_extra_attr ( inode ) && f2fs_sb_has_project_quota ( sbi -> sb ) && F2FS_FITS_IN_INODE ( ri , fi -> i_extra_isize , i_projid ) ) i_projid = ( projid_t ) le32_to_cpu ( ri -> i_projid ) ; else i_projid = F2FS_DEF_PROJID ; fi -> i_projid = make_kprojid ( & init_user_ns , i_projid ) ; if ( f2fs_has_extra_attr ( inode ) && f2fs_sb_has_inode_crtime ( sbi -> sb ) && F2FS_FITS_IN_INODE ( ri , fi -> i_extra_isize , i_crtime ) ) { fi -> i_crtime . tv_sec = le64_to_cpu ( ri -> i_crtime ) ; fi -> i_crtime . tv_nsec = le32_to_cpu ( ri -> i_crtime_nsec ) ; } F2FS_I ( inode ) -> i_disk_time [ 0 ] = inode -> i_atime ; F2FS_I ( inode ) -> i_disk_time [ 1 ] = inode -> i_ctime ; F2FS_I ( inode ) -> i_disk_time [ 2 ] = inode -> i_mtime ; F2FS_I ( inode ) -> i_disk_time [ 3 ] = F2FS_I ( inode ) -> i_crtime ; f2fs_put_page ( node_page , 1 ) ; stat_inc_inline_xattr ( inode ) ; stat_inc_inline_inode ( inode ) ; stat_inc_inline_dir ( inode ) ; return 0 ; } | <S2SV_ModStart> -> i_flags & F2FS_PROJINHERIT_FL <S2SV_ModEnd> ) set_inode_flag ( |
1,706 | CWE-000 static int __die ( const char * str , int err , struct pt_regs * regs ) { struct task_struct * tsk = current ; static int die_counter ; int ret ; ecd_printf ( "%s\\n" , str ) ; pr_emerg ( "Internal<S2SV_blank>error:<S2SV_blank>%s:<S2SV_blank>%x<S2SV_blank>[#%d]" S_PREEMPT S_SMP "\\n" , str , err , ++ die_counter ) ; ret = notify_die ( DIE_OOPS , str , regs , err , 0 , SIGSEGV ) ; if ( ret == NOTIFY_STOP ) return ret ; print_modules ( ) ; __show_regs ( regs ) ; pr_emerg ( "Process<S2SV_blank>%.*s<S2SV_blank>(pid:<S2SV_blank>%d,<S2SV_blank>stack<S2SV_blank>limit<S2SV_blank>=<S2SV_blank>0x%p)\\n" , TASK_COMM_LEN , tsk -> comm , task_pid_nr ( tsk ) , end_of_stack ( tsk ) ) ; if ( ! user_mode ( regs ) ) { dump_mem ( KERN_EMERG , "Stack:<S2SV_blank>" , regs -> sp , THREAD_SIZE + ( unsigned long ) task_stack_page ( tsk ) ) ; # ifdef CONFIG_SEC_DEBUG_AUTO_SUMMARY dump_backtrace_auto_summary ( regs , tsk ) ; # else dump_backtrace ( regs , tsk ) ; # endif dump_instr ( KERN_EMERG , regs ) ; } <S2SV_StartBug> print_ppmpu_protection ( regs ) ; <S2SV_EndBug> return ret ; } | <S2SV_ModStart> ) ; } # ifdef CONFIG_SEC_DEBUG <S2SV_ModStart> regs ) ; # endif |
1,707 | CWE-000 DEFUN ( "xwidget-webkit-execute-script" , Fxwidget_webkit_execute_script , Sxwidget_webkit_execute_script , 2 , 3 , 0 , doc : ) ( Lisp_Object xwidget , Lisp_Object script , Lisp_Object fun ) { WEBKIT_FN_INIT ( ) ; CHECK_STRING ( script ) ; if ( ! NILP ( fun ) && ! FUNCTIONP ( fun ) ) wrong_type_argument ( Qinvalid_function , fun ) ; script = ENCODE_SYSTEM ( script ) ; <S2SV_StartBug> ptrdiff_t idx = save_script_callback ( xw , script , fun ) ; <S2SV_EndBug> webkit_web_view_run_javascript ( WEBKIT_WEB_VIEW ( xw -> widget_osr ) , XSAVE_POINTER ( XCAR ( AREF ( xw -> script_callbacks , idx ) ) , 0 ) , NULL , webkit_javascript_finished_cb , ( gpointer ) idx ) ; return Qnil ; } | <S2SV_ModStart> script ) ; intptr_t <S2SV_ModEnd> idx = save_script_callback |
1,708 | CWE-000 static void fastrpc_init ( struct fastrpc_apps * me ) { int i ; INIT_HLIST_HEAD ( & me -> drivers ) ; spin_lock_init ( & me -> hlock ) ; spin_lock_init ( & me -> ctxlock ) ; mutex_init ( & me -> smd_mutex ) ; me -> channel = & gcinfo [ 0 ] ; for ( i = 0 ; i < NUM_CHANNELS ; i ++ ) { init_completion ( & me -> channel [ i ] . work ) ; init_completion ( & me -> channel [ i ] . workport ) ; me -> channel [ i ] . sesscount = 0 ; <S2SV_StartBug> } <S2SV_EndBug> } | <S2SV_ModStart> = 0 ; me -> channel [ i ] . secure = SECURE_CHANNEL ; } me -> channel [ CDSP_DOMAIN_ID ] . secure = NON_SECURE_CHANNEL ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
1,709 | CWE-000 STATE parsedollar ( ) { int quote = '<S2SV_blank>' , anslen = strlen ( ans ) ; <S2SV_StartBug> parsedollarindex = 0 ; <S2SV_EndBug> mcmdindex = 0 ; for ( ; parsedollarindex < anslen ; parsedollarindex ++ ) { switch ( ans [ parsedollarindex ] ) { case '\\'' : if ( quote == '<S2SV_blank>' ) { quote = '\\'' ; break ; } else if ( quote == '\\'' ) { quote = '<S2SV_blank>' ; break ; } case \'\\"\' : if ( quote == '<S2SV_blank>' ) { quote = \'\\"\' ; break ; } else if ( quote == \'\\"\' ) { quote = '<S2SV_blank>' ; break ; } case '$' : if ( quote == \'\\"\' ) { int nameindex = 0 ; for ( parsedollarindex ++ ; ; parsedollarindex ++ ) { if ( ! ans [ parsedollarindex ] || strchr ( "<S2SV_blank>\\t\\r\\n\\v\\"$" , ans [ parsedollarindex ] ) ) { name [ nameindex ++ ] = 0 ; parsedollarindex -- ; break ; } name [ nameindex ++ ] = ans [ parsedollarindex ] ; if ( nameindex >= DEFALUT_VARIABLE_NAME ) { return STATE_ERROR ; } } if ( getvariable ( ) == STATE_ERROR ) { return STATE_ERROR ; } break ; } default : mcmd [ mcmdindex ++ ] = ans [ parsedollarindex ] ; if ( mcmdindex >= 2048 ) { return STATE_ERROR ; } } } mcmd [ mcmdindex ] = 0 ; return STATE_OK ; } | <S2SV_ModStart> ; parsedollarindex = strimAndTrip ( ans ) - ans <S2SV_ModEnd> ; mcmdindex = |
1,710 | CWE-000 int * render ( triangle * ts , size_t ntriangles , matarrayvec materials ) { render_context * rc = input_assembler ( ts , ntriangles , materials ) ; vertex_shader ( rc ) ; tessellation_shader ( rc ) ; geometry_shader ( rc ) ; <S2SV_StartBug> clip ( rc ) ; <S2SV_EndBug> raster_context * rac = rasterizer ( rc , 512 , 512 ) ; fragment_shader ( rac ) ; free_vec3arrayvec ( rc -> vlist ) ; free_vec3arrayvec ( rc -> nlist ) ; free_vec2arrayvec ( rc -> tlist ) ; free_matarrayvec ( rc -> materials ) ; free_intarrayvec ( rc -> mlist ) ; printf ( "rc<S2SV_blank>mlist<S2SV_blank>%d<S2SV_blank>%d" , rc -> mlist -> data [ 0 ] , rc -> mlist -> data [ 1 ] ) ; free ( rc ) ; <S2SV_StartBug> free ( rac -> z_buffer ) ; <S2SV_EndBug> free ( rac -> mat_buffer ) ; int * ret = rac -> color_buffer ; printf ( "%d<S2SV_blank>%d" , rac -> width , rac -> height ) ; free ( rac ) ; return ret ; } | <S2SV_ModStart> clip ( rc , 512 , 512 <S2SV_ModStart> rc ) ; printf ( "zbuf<S2SV_blank>corners<S2SV_blank>%f<S2SV_blank>%f<S2SV_blank>%f<S2SV_blank>%f" , rac -> z_buffer [ 0 ] , rac -> z_buffer [ 511 ] , rac -> z_buffer [ 511 * 512 ] , rac -> z_buffer [ 512 * 512 - 1 ] ) ; |
1,711 | CWE-000 static void layoutrecall_one_call ( void * arg ) { struct layoutrecall_cb_data * cb_data = arg ; state_t * state ; int code ; struct root_op_context root_op_context ; struct fsal_obj_handle * obj = NULL ; struct gsh_export * export = NULL ; state_owner_t * owner = NULL ; bool ok = false ; init_root_op_context ( & root_op_context , NULL , NULL , 0 , 0 , UNKNOWN_REQUEST ) ; if ( cb_data -> attempts == 0 ) now ( & cb_data -> first_recall ) ; state = nfs4_State_Get_Pointer ( cb_data -> stateid_other ) ; ok = get_state_obj_export_owner_refs ( state , & obj , & export , & owner ) ; if ( ok ) { PTHREAD_RWLOCK_wrlock ( & obj -> state_hdl -> state_lock ) ; root_op_context . req_ctx . clientid = & owner -> so_owner . so_nfs4_owner . so_clientid ; root_op_context . req_ctx . ctx_export = export ; root_op_context . req_ctx . fsal_export = export -> fsal_export ; code = nfs_rpc_v41_single ( cb_data -> client , & cb_data -> arg , & state -> state_refer , layoutrec_completion , cb_data , free_layoutrec ) ; if ( code != 0 ) { if ( cb_data -> attempts == 0 ) { delayed_submit ( return_one_async , cb_data , 0 ) ; } else { bool deleted = false ; nfs4_return_one_state ( obj , LAYOUTRETURN4_FILE , circumstance_revoke , state , cb_data -> segment , 0 , NULL , & deleted ) ; <S2SV_StartBug> gsh_free ( cb_data ) ; <S2SV_EndBug> } } else { ++ cb_data -> attempts ; } PTHREAD_RWLOCK_unlock ( & obj -> state_hdl -> state_lock ) ; } else { gsh_free ( cb_data ) ; } release_root_op_context ( ) ; if ( state != NULL ) { dec_state_t_ref ( state ) ; } if ( ok ) { put_gsh_export ( export ) ; obj -> obj_ops . put_ref ( obj ) ; dec_state_owner_ref ( owner ) ; } } | <S2SV_ModStart> deleted ) ; free_layoutrec ( & cb_data -> arg ) ; |
1,712 | CWE-000 <S2SV_StartBug> void zebra_redistribute_add ( int command , struct zserv * client , int length , <S2SV_EndBug> struct zebra_vrf * zvrf ) { afi_t afi = 0 ; <S2SV_StartBug> int type = 0 ; <S2SV_EndBug> u_short instance ; <S2SV_StartBug> STREAM_GETC ( client -> ibuf , afi ) ; <S2SV_EndBug> <S2SV_StartBug> STREAM_GETC ( client -> ibuf , type ) ; <S2SV_EndBug> <S2SV_StartBug> STREAM_GETW ( client -> ibuf , instance ) ; <S2SV_EndBug> if ( afi == 0 || afi > AFI_MAX ) { zlog_warn ( "%s:<S2SV_blank>Specified<S2SV_blank>afi<S2SV_blank>%d<S2SV_blank>does<S2SV_blank>not<S2SV_blank>exist" , __PRETTY_FUNCTION__ , afi ) ; return ; } if ( type == 0 || type >= ZEBRA_ROUTE_MAX ) { zlog_warn ( "%s:<S2SV_blank>Specified<S2SV_blank>Route<S2SV_blank>Type<S2SV_blank>%d<S2SV_blank>does<S2SV_blank>not<S2SV_blank>exist" , __PRETTY_FUNCTION__ , type ) ; return ; } if ( instance ) { if ( ! redist_check_instance ( & client -> mi_redist [ afi ] [ type ] , instance ) ) { redist_add_instance ( & client -> mi_redist [ afi ] [ type ] , instance ) ; zebra_redistribute ( client , type , instance , zvrf_id ( zvrf ) , afi ) ; } } else { if ( ! vrf_bitmap_check ( client -> redist [ afi ] [ type ] , zvrf_id ( zvrf ) ) ) { vrf_bitmap_set ( client -> redist [ afi ] [ type ] , zvrf_id ( zvrf ) ) ; zebra_redistribute ( client , type , 0 , zvrf_id ( zvrf ) , afi ) ; } } stream_failure : return ; } | <S2SV_ModStart> void zebra_redistribute_add ( ZAPI_HANDLER_ARGS ) { afi_t afi = 0 ; int type <S2SV_ModEnd> = 0 ; <S2SV_ModStart> = 0 ; <S2SV_ModEnd> u_short instance ; <S2SV_ModStart> ; STREAM_GETC ( msg <S2SV_ModEnd> , afi ) <S2SV_ModStart> ; STREAM_GETC ( msg <S2SV_ModEnd> , type ) <S2SV_ModStart> ; STREAM_GETW ( msg <S2SV_ModEnd> , instance ) |
1,713 | CWE-000 void pgResetFn_controlRateProfiles ( controlRateConfig_t * instance ) { for ( int i = 0 ; i < MAX_CONTROL_RATE_PROFILE_COUNT ; i ++ ) { # ifndef C2_VERSION RESET_CONFIG ( controlRateConfig_t , & instance [ i ] , . rcRate8 = 109 , . rcExpo8 = 65 , . thrMid8 = 52 , . thrExpo8 = 40 , . tpa_breakpoint = 1500 , ) ; # else # if ( C2_VERSION == 11 ) RESET_CONFIG ( controlRateConfig_t , & instance [ i ] , . rcRate8 = 60 , . rcExpo8 = 0 , . thrMid8 = 47 , . thrExpo8 = 38 , . tpa_breakpoint = 1500 , ) ; <S2SV_StartBug> # elif <S2SV_EndBug> # endif # endif } } | <S2SV_ModStart> ) ; # <S2SV_ModEnd> endif # endif |
1,714 | CWE-000 int mdss_pll_resource_enable ( struct mdss_pll_resources * pll_res , bool enable ) { int rc = 0 ; int changed = 0 ; if ( ! pll_res ) { pr_err ( "Invalid<S2SV_blank>input<S2SV_blank>parameters\\n" ) ; return - EINVAL ; } if ( pll_res -> handoff_resources && ( ! enable || ( enable & pll_res -> resource_enable ) ) ) { pr_debug ( "Do<S2SV_blank>not<S2SV_blank>turn<S2SV_blank>on/off<S2SV_blank>pll<S2SV_blank>resources<S2SV_blank>during<S2SV_blank>handoff<S2SV_blank>case\\n" ) ; return rc ; } <S2SV_StartBug> if ( enable ) { <S2SV_EndBug> if ( pll_res -> resource_ref_cnt == 0 ) changed ++ ; pll_res -> resource_ref_cnt ++ ; } else { if ( pll_res -> resource_ref_cnt ) { pll_res -> resource_ref_cnt -- ; if ( pll_res -> resource_ref_cnt == 0 ) changed ++ ; } else { pr_err ( "PLL<S2SV_blank>Resources<S2SV_blank>already<S2SV_blank>OFF\\n" ) ; } } if ( changed ) { rc = mdss_pll_util_resource_enable ( pll_res , enable ) ; if ( rc ) pr_err ( "Resource<S2SV_blank>update<S2SV_blank>failed<S2SV_blank>rc=%d\\n" , rc ) ; else pll_res -> resource_enable = enable ; } <S2SV_StartBug> return rc ; <S2SV_EndBug> } | <S2SV_ModStart> rc ; } mutex_lock ( & pll_res -> mutex ) ; <S2SV_ModStart> enable ; } mutex_unlock ( & pll_res -> mutex ) ; |
1,715 | CWE-000 gboolean sqlite_result_set_next ( ResultSet * vr , GError * * error ) { SQLiteResultSet * r = ( SQLiteResultSet * ) vr ; int rc ; <S2SV_StartBug> EXEC_SQLITE ( rc , sqlite3_step ( r -> stmt ) ) ; <S2SV_EndBug> if ( rc != SQLITE_ROW && rc != SQLITE_DONE ) { g_set_error ( error , SEAF_DB_ERROR_DOMAIN , SEAF_DB_ERROR_CODE , "sqlite3_step<S2SV_blank>failed:<S2SV_blank>%s" , sqlite3_errmsg ( r -> db ) ) ; return FALSE ; } return ( rc == SQLITE_ROW ) ; } | <S2SV_ModStart> int rc ; rc = sqlite3_blocking_step <S2SV_ModEnd> ( r -> <S2SV_ModStart> r -> stmt <S2SV_ModEnd> ) ; if |
1,716 | CWE-000 static void OSD_DisplayNoVideo ( void ) { sPosition_t position [ NUM_OF_CHANNEL ] ; eChannel_t channel ; eChannel_t startChannel ; eDisplayMode_t displayMode = Get_SystemDisplayMode ( ) ; BOOL videoLossDiplayOn ; u8 * pInfoStr [ NUM_OF_CHANNEL ] ; Read_NvItem_VideoLossDisplayOn ( & videoLossDiplayOn ) ; for ( channel = CHANNEL1 ; channel < NUM_OF_CHANNEL ; channel ++ ) { pInfoStr [ channel ] = OSD_GetInfoStr ( channel ) ; } if ( ( videoLossDiplayOn == ON ) & ( ( GetVideoLossEvent ( ) == SET ) || ( requestRefreshScreen == SET ) ) ) { if ( displayMode == DISPLAY_MODE_FULL ) { channel = Get_SystemDisplayChannel ( ) ; } SetVideoLossEvent ( CLEAR ) ; if ( displayMode == DISPLAY_MODE_FULL ) { position [ channel ] . pos_x = ( DISPLAY_WIDTH - ( strlen ( osdStr_NoVideo ) * CHAR_WIDTH_S ) ) / 2 ; position [ channel ] . pos_y = ( DISPLAY_HEIGHT - CHAR_HEIGHT ) / 2 ; if ( IsVideoLossChannel ( channel ) == TRUE ) { <S2SV_StartBug> OSD_PrintString ( position [ channel ] , osdStr_NoVideo , strlen ( pInfoStr ) ) ; <S2SV_EndBug> } else { OSD_PrintString ( position [ channel ] , osdStr_Space10 , strlen ( osdStr_Space10 ) ) ; } } else if ( displayMode == DISPLAY_MODE_QUAD_A ) { for ( channel = CHANNEL1 ; channel < NUM_OF_CHANNEL ; channel ++ ) { position [ channel ] . pos_x = <S2SV_StartBug> tbl_OSD_SPLIT4_POSITION [ channel ] . pos_x - ( strlen ( pInfoStr ) * CHAR_WIDTH_S ) / 2 ; <S2SV_EndBug> position [ channel ] . pos_y = tbl_OSD_SPLIT4_POSITION [ channel ] . pos_y + ( ( DISPLAY_HEIGHT / 2 ) - CHAR_HEIGHT ) / 2 ; if ( IsVideoLossChannel ( channel ) == TRUE ) { <S2SV_StartBug> OSD_PrintString ( position [ channel ] , osdStr_NoVideo , strlen ( pInfoStr ) ) ; <S2SV_EndBug> } else { OSD_PrintString ( position [ channel ] , osdStr_Space10 , strlen ( osdStr_Space10 ) ) ; } } } } } | <S2SV_ModStart> , strlen ( ( const u8 * ) <S2SV_ModStart> ( strlen ( ( const u8 * ) <S2SV_ModStart> , strlen ( ( const u8 * ) |
1,717 | CWE-000 static void page_fault ( struct intr_frame * f ) { bool not_present ; bool write ; bool user ; void * fault_addr ; asm ( "movl<S2SV_blank>%%cr2,<S2SV_blank>%0" : "=r" ( fault_addr ) ) ; intr_enable ( ) ; page_fault_cnt ++ ; not_present = ( f -> error_code & PF_P ) == 0 ; write = ( f -> error_code & PF_W ) != 0 ; user = ( f -> error_code & PF_U ) != 0 ; if ( user == false ) { f -> eip = ( void * ) f -> eax ; f -> eax = 0xffffffff ; <S2SV_StartBug> } <S2SV_EndBug> printf ( "Page<S2SV_blank>fault<S2SV_blank>at<S2SV_blank>%p:<S2SV_blank>%s<S2SV_blank>error<S2SV_blank>%s<S2SV_blank>page<S2SV_blank>in<S2SV_blank>%s<S2SV_blank>context.\\n" , fault_addr , not_present ? "not<S2SV_blank>present" : "rights<S2SV_blank>violation" , write ? "writing" : "reading" , user ? "user" : "kernel" ) ; kill ( f ) ; } | <S2SV_ModStart> = 0xffffffff ; return ; |
1,718 | CWE-000 int bgenv_get ( BGENV * env , char * key , uint64_t * type , void * data , uint32_t maxlen ) { EBGENVKEY e ; unsigned int src ; uint64_t t ; wchar_t * srcstr ; char buffer [ ENV_STRING_LENGTH ] ; if ( ! key || maxlen == 0 ) { return - EINVAL ; } e = bgenv_str2enum ( key ) ; if ( ! env ) { return - EPERM ; } if ( e == EBGENV_UNKNOWN ) { if ( ! data ) { uint8_t * u ; uint32_t size ; u = bgenv_find_uservar ( env -> data -> userdata , key ) ; bgenv_map_uservar ( u , NULL , NULL , NULL , NULL , & size ) ; return size ; } return bgenv_get_uservar ( env -> data -> userdata , key , type , data , maxlen ) ; } switch ( e ) { case EBGENV_KERNELFILE : return bgenv_get_string ( buffer , type , data , env -> data -> kernelfile ) ; case EBGENV_KERNELPARAMS : return bgenv_get_string ( buffer , type , data , env -> data -> kernelparams ) ; case EBGENV_WATCHDOG_TIMEOUT_SEC : return bgenv_get_uint ( buffer , type , data , env -> data -> watchdog_timeout_sec , USERVAR_TYPE_UINT16 ) ; case EBGENV_REVISION : return bgenv_get_uint ( buffer , type , data , env -> data -> revision , USERVAR_TYPE_UINT16 ) ; case EBGENV_USTATE : return bgenv_get_uint ( buffer , type , data , env -> data -> ustate , <S2SV_StartBug> USERVAR_TYPE_UINT16 ) ; <S2SV_EndBug> case EBGENV_IN_PROGRESS : return bgenv_get_uint ( buffer , type , data , env -> data -> in_progress , USERVAR_TYPE_UINT8 ) ; default : if ( ! data ) { return 0 ; } return - EINVAL ; } } | <S2SV_ModStart> -> ustate , USERVAR_TYPE_UINT8 <S2SV_ModEnd> ) ; case |
1,719 | CWE-000 void etc ( void ) { struct ptable_t tab ; ptable_init ( & tab , 600000 ) ; <S2SV_StartBug> perm_t pattern = perm_from_csv ( "0,1,2,3" ) ; <S2SV_EndBug> build_complement_prefixes ( & tab , pattern ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> = perm_from_csv ( "3,2,1,0" <S2SV_ModEnd> ) ; build_complement_prefixes <S2SV_ModStart> pattern ) ; perm_t perm = perm_from_csv ( "3,2,1,0" ) ; int perm_len = perm_length ( perm ) ; int pattern_len = perm_length ( pattern ) ; perm_t inverse = perm_inverse ( perm , perm_len ) ; int count ; checkpatterns ( perm , inverse , ( perm_t ) 0 , 0 , perm_len , pattern_len , ( uint64_t ) 0 , & tab , & count ) ; printf ( "%d\\n" , count ) ; |
1,720 | CWE-000 void enumerate_files_in_zelda_drive ( void ) { struct zelda_file * _file = NULL ; uint32_t iptr = zelda_drive_start ; for ( ; iptr < zelda_drive_end ; ) { _file = ( struct zelda_file * ) iptr ; <S2SV_StartBug> printk ( "Found<S2SV_blank>a<S2SV_blank>zelda<S2SV_blank>file:%s\\n" , _file -> path ) ; <S2SV_EndBug> iptr += sizeof ( struct zelda_file ) + _file -> length ; } } | <S2SV_ModStart> ) iptr ; _file -> list . next = NULL ; _file -> list . prev = NULL ; list_append ( & head , & _file -> list <S2SV_ModEnd> ) ; iptr |
1,721 | CWE-000 lval * lval_read ( mpc_ast_t * t ) { if ( strstr ( t -> tag , "number" ) ) { return lval_read_num ( t ) ; } if ( strstr ( t -> tag , "symbol" ) ) { return lval_sym ( t -> contents ) ; } lval * x = NULL ; if ( strcmp ( t -> tag , ">" ) == 0 ) { x = lval_sexpr ( ) ; } if ( strstr ( t -> tag , "sexpr" ) ) { x = lval_sexpr ( ) ; } <S2SV_StartBug> for ( int i = 0 ; i < t -> childen_num ; ++ i ) <S2SV_EndBug> { if ( strcmp ( t -> children [ i ] -> contents , "(" ) == 0 ) { continue ; } if ( strcmp ( t -> children [ i ] -> contents , ")" ) == 0 ) { continue ; } if ( strcmp ( t -> children [ i ] -> tag , "regex" ) == 0 ) { continue ; } x = lval_add ( x , lval_read ( t -> children [ i ] ) ) ; } return x ; } | <S2SV_ModStart> < t -> children_num <S2SV_ModEnd> ; ++ i |
1,722 | CWE-000 static int sugov_init ( struct cpufreq_policy * policy ) { struct sugov_policy * sg_policy ; struct sugov_tunables * tunables ; unsigned int lat ; int ret = 0 ; if ( policy -> governor_data ) return - EBUSY ; sg_policy = sugov_policy_alloc ( policy ) ; if ( ! sg_policy ) return - ENOMEM ; mutex_lock ( & global_tunables_lock ) ; if ( global_tunables ) { if ( WARN_ON ( have_governor_per_policy ( ) ) ) { ret = - EINVAL ; goto free_sg_policy ; } policy -> governor_data = sg_policy ; sg_policy -> tunables = global_tunables ; gov_attr_set_get ( & global_tunables -> attr_set , & sg_policy -> tunables_hook ) ; goto out ; } tunables = sugov_tunables_alloc ( sg_policy ) ; if ( ! tunables ) { ret = - ENOMEM ; goto free_sg_policy ; } tunables -> rate_limit_us = 20 * USEC_PER_MSEC ; lat = policy -> cpuinfo . transition_latency / NSEC_PER_USEC ; if ( lat ) tunables -> rate_limit_us *= lat ; policy -> governor_data = sg_policy ; sg_policy -> tunables = tunables ; ret = kobject_init_and_add ( & tunables -> attr_set . kobj , & sugov_tunables_ktype , get_governor_parent_kobj ( policy ) , "%s" , <S2SV_StartBug> schedutil_gov . name ) ; <S2SV_EndBug> if ( ret ) goto fail ; out : mutex_unlock ( & global_tunables_lock ) ; cpufreq_enable_fast_switch ( policy ) ; return 0 ; fail : policy -> governor_data = NULL ; sugov_tunables_free ( tunables ) ; free_sg_policy : mutex_unlock ( & global_tunables_lock ) ; sugov_policy_free ( sg_policy ) ; pr_err ( "initialization<S2SV_blank>failed<S2SV_blank>(error<S2SV_blank>%d)\\n" , ret ) ; return ret ; } | <S2SV_ModStart> , "%s" , cpufreq_gov_schedutil <S2SV_ModEnd> . name ) |
1,723 | CWE-000 void * lpopWorkerThread ( void * args ) { struct WorkerArgs * wArgs = ( struct WorkerArgs * ) args ; char * coordinatorLocator = wArgs -> coordinatorLocator ; uint64_t requests = wArgs -> requests ; uint64_t valueSize = wArgs -> valueSize ; uint64_t keySpaceLength = wArgs -> keySpaceLength ; Context * context = ramdis_connect ( coordinatorLocator ) ; struct WorkerStats * wStats = ( struct WorkerStats * ) malloc ( sizeof ( struct WorkerStats ) ) ; uint64_t * latencies = ( uint64_t * ) malloc ( requests * sizeof ( uint64_t ) ) ; int i ; Object key ; char keyBuf [ 16 ] ; key . len = sizeof ( keyBuf ) ; <S2SV_StartBug> uint64_t testStart = ustime ( ) ; <S2SV_EndBug> for ( i = 0 ; i < requests ; i ++ ) { snprintf ( keyBuf , 16 , "%015d" , rand ( ) % keySpaceLength ) ; key . data = keyBuf ; uint64_t reqStart = ustime ( ) ; lpop ( context , & key ) ; latencies [ i ] = ustime ( ) - reqStart ; <S2SV_StartBug> if ( i % ( requests / 100 ) == 0 ) { <S2SV_EndBug> printf ( "Progress:<S2SV_blank>%3d%%\\r" , i * 100 / requests ) ; fflush ( stdout ) ; } } uint64_t testEnd = ustime ( ) ; wStats -> latencies = latencies ; ramdis_disconnect ( context ) ; return wStats ; } | <S2SV_ModStart> ) ; uint64_t progressUnit = ( requests / 100 ) > 0 ? ( requests / 100 ) : 1 ; uint64_t <S2SV_ModStart> ( i % progressUnit <S2SV_ModEnd> == 0 ) |
1,724 | CWE-000 char * parseToMediaType ( char * string , mediaType * mt ) { stateMachineADT sm = createStateMachine ( ( stateFunc_t * * ) stateTable , <S2SV_StartBug> ( transitionFunc_t * * * ) transitionTable ) ; <S2SV_EndBug> parserData data = { . remaining = string , . sizeType = 0 , . sizeSubtype = 0 , . error = NO_ERROR } ; initStateMachine ( sm , STATE_TYPE , ( void * ) & data ) ; while ( ! isDone ( getState ( sm ) , & data ) ) feedStateMachine ( sm ) ; <S2SV_StartBug> char * ret = convertDataToMediaType ( & data , mt ) ; <S2SV_EndBug> return ret ; } | <S2SV_ModStart> * ) transitionTable , NUM_STATES <S2SV_ModStart> sm ) ; deleteStateMachine ( sm ) ; |
1,725 | CWE-000 void execute ( uint16_t op ) { if ( ! Opcodes [ op ] ) { fprintf ( stderr , "Unknown<S2SV_blank>Op<S2SV_blank>%x<S2SV_blank>at<S2SV_blank>address<S2SV_blank>%x" , op , r . PC . val - 1 ) ; exit ( 1 ) ; } Opcodes [ op ] ( ) ; <S2SV_StartBug> clock . total_m += clock . m ; <S2SV_EndBug> clock . total_t += clock . t ; clock . lineticks += clock . m ; switch ( clock . mode ) { case 0 : if ( clock . lineticks > 203 ) { if ( clock . total_m >= 70224 ) { clock . mode = 1 ; clock . total_m = 0 ; } else { clock . mode = 2 ; } clock . lineticks = 0 ; MMU . memory [ 0xFF44 ] ++ ; } break ; case 1 : if ( clock . lineticks >= 4560 ) { clock . mode = 2 ; clock . lineticks = 0 ; MMU . memory [ 0xFF44 ] = 0 ; } break ; case 2 : if ( clock . lineticks > 80 ) { clock . mode = 3 ; clock . lineticks = 0 ; } break ; case 3 : if ( clock . lineticks > 172 ) { clock . mode = 0 ; clock . lineticks = 0 ; } break ; } } | <S2SV_ModStart> ( ) ; clock_handling ( ) ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
1,726 | CWE-000 static int8_t apx_clientConnection_parseMessage ( apx_clientConnection_t * self , const uint8_t * dataBuf , uint32_t dataLen , uint32_t * parseLen ) { uint32_t msgLen ; const uint8_t * pBegin = dataBuf ; const uint8_t * pResult ; const uint8_t * pEnd = dataBuf + dataLen ; const uint8_t * pNext = pBegin ; <S2SV_StartBug> pResult = headerutil_numDecode32 ( pNext , pEnd , & msgLen ) ; <S2SV_EndBug> if ( pResult > pNext ) { uint32_t headerLen = ( uint32_t ) ( pResult - pNext ) ; pNext = pResult ; if ( pNext + msgLen <= pEnd ) { if ( parseLen != 0 ) { * parseLen = headerLen + msgLen ; } if ( self -> isAcknowledgeSeen == false ) { if ( msgLen == 8 ) { if ( ( pNext [ 0 ] == 0xbf ) && ( pNext [ 1 ] == 0xff ) && ( pNext [ 2 ] == 0xfc ) && ( pNext [ 3 ] == 0x00 ) && ( pNext [ 4 ] == 0x00 ) && ( pNext [ 5 ] == 0x00 ) && ( pNext [ 6 ] == 0x00 ) && ( pNext [ 7 ] == 0x00 ) ) { self -> isAcknowledgeSeen = true ; apx_fileManager_onHeaderAccepted ( & self -> fileManager ) ; } } } else { apx_fileManager_processMessage ( & self -> fileManager , pNext , msgLen ) ; } } else { } } else { } return 0 ; } | <S2SV_ModStart> ; pResult = numheader_decode32 <S2SV_ModEnd> ( pNext , |
1,727 | CWE-000 static void init_seq_coding_tools ( SequenceHeader * seq , AV1_COMMON * cm , const AV1EncoderConfig * oxcf ) { seq -> still_picture = ( oxcf -> limit == 1 ) ; seq -> reduced_still_picture_hdr = seq -> still_picture ; seq -> reduced_still_picture_hdr &= ! oxcf -> full_still_picture_hdr ; seq -> force_screen_content_tools = 2 ; seq -> force_integer_mv = 2 ; seq -> order_hint_info . enable_order_hint = oxcf -> enable_order_hint ; <S2SV_StartBug> seq -> frame_id_numbers_present_flag = oxcf -> large_scale_tile ; <S2SV_EndBug> <S2SV_StartBug> if ( seq -> still_picture && seq -> reduced_still_picture_hdr ) { <S2SV_EndBug> <S2SV_StartBug> seq -> order_hint_info . enable_order_hint = 0 ; <S2SV_EndBug> seq -> frame_id_numbers_present_flag = 0 ; seq -> force_screen_content_tools = 2 ; seq -> force_integer_mv = 2 ; } seq -> order_hint_info . order_hint_bits_minus_1 = seq -> order_hint_info . enable_order_hint ? DEFAULT_EXPLICIT_ORDER_HINT_BITS - 1 : - 1 ; seq -> enable_dual_filter = oxcf -> enable_dual_filter ; seq -> order_hint_info . enable_jnt_comp = oxcf -> enable_jnt_comp ; seq -> order_hint_info . enable_jnt_comp &= seq -> order_hint_info . enable_order_hint ; seq -> order_hint_info . enable_ref_frame_mvs = oxcf -> enable_ref_frame_mvs ; seq -> order_hint_info . enable_ref_frame_mvs &= seq -> order_hint_info . enable_order_hint ; seq -> enable_superres = oxcf -> enable_superres ; seq -> enable_cdef = oxcf -> enable_cdef ; seq -> enable_restoration = oxcf -> enable_restoration ; seq -> enable_warped_motion = oxcf -> enable_warped_motion ; seq -> enable_interintra_compound = 1 ; seq -> enable_masked_compound = 1 ; seq -> enable_intra_edge_filter = 1 ; seq -> enable_filter_intra = 1 ; set_bitstream_level_tier ( seq , cm , oxcf ) ; if ( seq -> operating_points_cnt_minus_1 == 0 ) { seq -> operating_point_idc [ 0 ] = 0 ; } else { for ( int i = 0 ; i < seq -> operating_points_cnt_minus_1 + 1 ; i ++ ) seq -> operating_point_idc [ i ] = ( ~ ( ~ 0u << ( seq -> operating_points_cnt_minus_1 + 1 - i ) ) << 8 ) | 1 ; } } | <S2SV_ModStart> -> frame_id_numbers_present_flag = ! <S2SV_ModEnd> ( seq -> <S2SV_ModStart> -> reduced_still_picture_hdr ) && ! oxcf -> large_scale_tile && oxcf -> error_resilient_mode ; if ( seq -> still_picture && seq -> reduced_still_picture_hdr ) <S2SV_ModStart> order_hint_info . enable_order_hint <S2SV_ModEnd> = 0 ; |
1,728 | CWE-000 void * Delete ( ) { while ( 1 ) { sem_wait ( & full ) ; <S2SV_StartBug> pthread_mutex_lock ( & mutexInsDele ) ; <S2SV_EndBug> <S2SV_StartBug> pthread_mutex_lock ( & mutexSerDele ) ; <S2SV_EndBug> printf ( "Deleter<S2SV_blank>--------><S2SV_blank><S2SV_blank>Start<S2SV_blank>\\n" ) ; int val = bufferPull ( ) ; printf ( "Deleter<S2SV_blank>---><S2SV_blank>%d<S2SV_blank>|<S2SV_blank>%d\\n" , bufNum , val ) ; sleep ( 1 ) ; printf ( "Deleter<S2SV_blank>--------><S2SV_blank><S2SV_blank>End<S2SV_blank>\\n" ) ; sem_post ( & empty ) ; pthread_mutex_unlock ( & mutexInsDele ) ; pthread_mutex_unlock ( & mutexSerDele ) ; sleep ( randNumber ( 2 , 9 ) ) ; } } | <S2SV_ModStart> pthread_mutex_lock ( & mutexSerDele <S2SV_ModEnd> ) ; pthread_mutex_lock <S2SV_ModStart> pthread_mutex_lock ( & mutexInsDele <S2SV_ModEnd> ) ; printf |
1,729 | CWE-000 static void FinishedWithFont ( UnixFtFont * fontPtr ) { Display * display = fontPtr -> display ; int i ; Tk_ErrorHandler handler = Tk_CreateErrorHandler ( display , - 1 , - 1 , - 1 , NULL , ( ClientData ) NULL ) ; for ( i = 0 ; i < fontPtr -> nfaces ; i ++ ) { if ( fontPtr -> faces [ i ] . ftFont ) { XftFontClose ( fontPtr -> display , fontPtr -> faces [ i ] . ftFont ) ; } <S2SV_StartBug> if ( fontPtr -> faces [ i ] . source ) { <S2SV_EndBug> FcPatternDestroy ( fontPtr -> faces [ i ] . source ) ; } if ( fontPtr -> faces [ i ] . charset ) { FcCharSetDestroy ( fontPtr -> faces [ i ] . charset ) ; } } if ( fontPtr -> faces ) { ckfree ( ( char * ) fontPtr -> faces ) ; } if ( fontPtr -> pattern ) { FcPatternDestroy ( fontPtr -> pattern ) ; } if ( fontPtr -> ftDraw ) { XftDrawDestroy ( fontPtr -> ftDraw ) ; } if ( fontPtr -> font . fid ) { XUnloadFont ( fontPtr -> display , fontPtr -> font . fid ) ; } if ( fontPtr -> fontset ) { FcFontSetDestroy ( fontPtr -> fontset ) ; } Tk_DeleteErrorHandler ( handler ) ; } | <S2SV_ModStart> i ] . <S2SV_ModEnd> charset ) { |
1,730 | CWE-000 <S2SV_StartBug> static yaml_node_t * find ( yaml_document_t * doc , const char * path , int * attr ) { <S2SV_EndBug> const char * name ; int index ; yaml_node_t * node = yaml_document_get_root_node ( doc ) ; while ( path != NULL ) { <S2SV_StartBug> path = next ( path , & name , & index , attr ) ; <S2SV_EndBug> if ( node -> type != YAML_MAPPING_NODE ) return NULL ; for ( yaml_node_pair_t * pair = node -> data . mapping . pairs . start ; pair < node -> data . mapping . pairs . top ; pair ++ ) { yaml_node_t * key = yaml_document_get_node ( doc , pair -> key ) ; yaml_node_t * value = yaml_document_get_node ( doc , pair -> value ) ; if ( strcmp ( ( const char * ) key -> data . scalar . value , name ) == 0 ) { node = value ; goto found ; } } return NULL ; found : if ( index >= 0 ) { if ( node -> type != YAML_SEQUENCE_NODE ) return NULL ; if ( node -> data . sequence . items . start + index < node -> data . sequence . items . top ) node = yaml_document_get_node ( doc , * ( node -> data . sequence . items . start + index ) ) ; else return NULL ; } <S2SV_StartBug> if ( * attr == 1 ) { <S2SV_EndBug> if ( node -> type != YAML_SEQUENCE_NODE ) return NULL ; } if ( path == NULL ) { if ( node -> type != YAML_SCALAR_NODE ) return NULL ; else return node ; } } return NULL ; } | <S2SV_ModStart> char * path <S2SV_ModEnd> ) { const <S2SV_ModStart> , & index <S2SV_ModEnd> ) ; if <S2SV_ModStart> } if ( path == NULL ) { <S2SV_ModEnd> return node ; |
1,731 | CWE-000 int main ( int argc , char * * argv ) { in = ( argc > 1 ) ? fopen ( argv [ 1 ] , "r" ) : stdin ; if ( ! in ) in = stdin ; if ( fileno ( in ) == fileno ( stdin ) ) fprintf ( stderr , "Warning:<S2SV_blank>Jumps<S2SV_blank>may<S2SV_blank>not<S2SV_blank>work<S2SV_blank>properly<S2SV_blank>when<S2SV_blank>reading<S2SV_blank>from<S2SV_blank>STDIN.\\n" ) ; int c ; while ( ( c = getc ( in ) ) != EOF ) { switch ( c ) { case '0' : set_default_stack_index ( ) ; break ; case '1' : push ( ) ; break ; case '2' : pop ( ) ; break ; case '3' : io ( ) ; break ; case '4' : math ( ) ; break ; case '5' : cond ( ) ; break ; case '6' : mem ( ) ; break ; <S2SV_StartBug> case '9' : <S2SV_EndBug> jump ( ) ; break ; case ';' : while ( ( c = getc ( in ) ) != '\\n' && c != EOF ) ; break ; case '<S2SV_blank>' : case 10 : case 13 : case 'D' : break ; default : putchar ( c ) ; } } return 0 ; } | <S2SV_ModStart> break ; case '8' : builtins ( ) ; break ; case |
1,732 | CWE-000 int belle_sip_tester_set_log_file ( const char * filename ) { BctoolboxLogHandler * filehandler ; char * dir ; char * base ; if ( log_file ) { fclose ( log_file ) ; } log_file = fopen ( filename , "w" ) ; if ( ! log_file ) { belle_sip_error ( "Cannot<S2SV_blank>open<S2SV_blank>file<S2SV_blank>[%s]<S2SV_blank>for<S2SV_blank>writing<S2SV_blank>logs<S2SV_blank>because<S2SV_blank>[%s]" , filename , strerror ( errno ) ) ; return - 1 ; } dir = bctbx_strdup ( filename ) ; base = bctbx_strdup ( filename ) ; belle_sip_message ( "Redirecting<S2SV_blank>traces<S2SV_blank>to<S2SV_blank>file<S2SV_blank>[%s]" , filename ) ; <S2SV_StartBug> filehandler = bctbx_create_file_log_handler ( 0 , dirname_r ( filename , dirbuffer ) , basename_r ( filename , basebuffer ) , log_file ) ; <S2SV_EndBug> bctbx_add_log_handler ( filehandler ) ; bctbx_add_log_handler ( filehandler ) ; bctbx_free ( dir ) ; bctbx_free ( base ) ; return 0 ; } | <S2SV_ModStart> ( 0 , dirname ( dir ) , basename ( base <S2SV_ModEnd> ) , log_file |
1,733 | CWE-000 void nrzi_addbit ( struct trkstate_t * t , byte bit , double t_bit ) { if ( bit ) TRACE ( data , high ) else TRACE ( data , low ) ; <S2SV_StartBug> dlog ( "addbit<S2SV_blank>at<S2SV_blank>midbit<S2SV_blank>%d<S2SV_blank>at<S2SV_blank>%.7lf,<S2SV_blank>add<S2SV_blank>%d<S2SV_blank>to<S2SV_blank>trk<S2SV_blank>%d<S2SV_blank>datacount<S2SV_blank>%d\\n" , nrzi . post_counter , timenow , bit , t -> trknum , t -> datacount ) ; <S2SV_EndBug> t -> t_lastbit = t_bit ; if ( t -> datacount == 0 ) { t -> t_firstbit = t_bit ; t -> v_avg_height = 2 * ( t -> v_bot + t -> v_top ) ; t -> max_agc_gain = t -> agc_gain ; } if ( ! nrzi . datablock ) { nrzi . t_lastclock = t_bit - nrzi . clkavg . t_bitspaceavg ; nrzi . datablock = true ; } <S2SV_StartBug> if ( trkstate [ 0 ] . datacount > 900 ) dlog ( "trk<S2SV_blank>%d<S2SV_blank>at<S2SV_blank>%.7lf,<S2SV_blank>lastpeak<S2SV_blank>%.7lf,<S2SV_blank>add<S2SV_blank>%d<S2SV_blank>to<S2SV_blank>%d<S2SV_blank>bytes<S2SV_blank>at<S2SV_blank>%.7lf,<S2SV_blank>bitspacing<S2SV_blank>%.2f\\n" , <S2SV_EndBug> t -> trknum , timenow , t -> t_lastpeak , bit , t -> datacount , t_bit , nrzi . clkavg . t_bitspaceavg * 1e6 ) ; uint16_t mask = 0x100 >> t -> trknum ; data [ t -> datacount ] = bit ? data [ t -> datacount ] | mask : data [ t -> datacount ] & ~ mask ; data_time [ t -> datacount ] = t_bit ; if ( t -> datacount < MAXBLOCK ) ++ t -> datacount ; if ( nrzi . post_counter > 0 && bit ) { nrzi . t_lastclock = t_bit - nrzi . clkavg . t_bitspaceavg ; } } | <S2SV_ModStart> low ) ; <S2SV_ModEnd> t -> t_lastbit <S2SV_ModStart> true ; } <S2SV_ModEnd> uint16_t mask = |
1,734 | CWE-000 void recorder_chan_delete ( recorder_chan_p chan ) { recorder_shmem_p shmem = chan -> recorder_shmem ; intptr_t chan_offset = chan -> offset ; char * map_addr = shmem -> map_addr ; recorder_shmem_shp shmemp = ( recorder_shmem_shp ) map_addr ; off_t * last = & shmemp -> head ; <S2SV_StartBug> for ( off_t offset = * last ; offset ; offset = * last ) <S2SV_EndBug> { recorder_chan_shp chanp = ( recorder_chan_shp ) ( map_addr + offset ) ; if ( * last == chan_offset ) { * last = chanp -> next ; chanp -> next = shmemp -> free_list ; shmemp -> free_list = chan -> offset ; break ; } last = & chanp -> next ; } free ( chan ) ; } | <S2SV_ModStart> -> head ; off_t offset ; for ( <S2SV_ModEnd> offset = * |
1,735 | CWE-000 <S2SV_StartBug> static void igmp_validatedata ( void ) <S2SV_EndBug> { if ( got_link ) { <S2SV_StartBug> if ( ( nemesis_check_link ( & etherhdr , device ) ) < 0 ) <S2SV_EndBug> { fprintf ( stderr , "ERROR:<S2SV_blank>Cannot<S2SV_blank>retrieve<S2SV_blank>hardware<S2SV_blank>address<S2SV_blank>of<S2SV_blank>%s.\\n" , device ) ; igmp_exit ( 1 ) ; } } if ( ! got_type ) igmphdr . igmp_type = IGMP_V1_MEMBERSHIP_REPORT ; if ( ! got_code ) igmphdr . igmp_code = 0 ; if ( ! got_group ) { nemesis_name_resolve ( "224.0.0.1" , ( u_int32_t * ) & igmphdr . igmp_group . s_addr ) ; nemesis_name_resolve ( "224.0.0.1" , ( u_int32_t * ) & iphdr . ip_dst . s_addr ) ; } return ; } | <S2SV_ModStart> void igmp_validatedata ( libnet_t * l <S2SV_ModEnd> ) { if <S2SV_ModStart> & etherhdr , l <S2SV_ModEnd> ) ) < |
1,736 | CWE-000 int qla24xx_async_gidpn ( scsi_qla_host_t * vha , fc_port_t * fcport ) { int rval = QLA_FUNCTION_FAILED ; struct ct_sns_req * ct_req ; srb_t * sp ; if ( ! vha -> flags . online || ( fcport -> flags & FCF_ASYNC_SENT ) ) return rval ; fcport -> disc_state = DSC_GID_PN ; fcport -> scan_state = QLA_FCPORT_SCAN ; sp = qla2x00_get_sp ( vha , fcport , GFP_ATOMIC ) ; if ( ! sp ) goto done ; fcport -> flags |= FCF_ASYNC_SENT ; sp -> type = SRB_CT_PTHRU_CMD ; sp -> name = "gidpn" ; sp -> gen1 = fcport -> rscn_gen ; sp -> gen2 = fcport -> login_gen ; qla2x00_init_timer ( sp , qla2x00_get_async_timeout ( vha ) + 2 ) ; ct_req = qla2x00_prep_ct_req ( fcport -> ct_desc . ct_sns , GID_PN_CMD , GID_PN_RSP_SIZE ) ; memcpy ( ct_req -> req . gid_pn . port_name , fcport -> port_name , WWN_SIZE ) ; sp -> u . iocb_cmd . u . ctarg . req = fcport -> ct_desc . ct_sns ; sp -> u . iocb_cmd . u . ctarg . req_dma = fcport -> ct_desc . ct_sns_dma ; sp -> u . iocb_cmd . u . ctarg . rsp = fcport -> ct_desc . ct_sns ; sp -> u . iocb_cmd . u . ctarg . rsp_dma = fcport -> ct_desc . ct_sns_dma ; sp -> u . iocb_cmd . u . ctarg . req_size = GID_PN_REQ_SIZE ; sp -> u . iocb_cmd . u . ctarg . rsp_size = GID_PN_RSP_SIZE ; sp -> u . iocb_cmd . u . ctarg . nport_handle = NPH_SNS ; sp -> u . iocb_cmd . timeout = qla2x00_async_iocb_timeout ; sp -> done = qla2x00_async_gidpn_sp_done ; rval = qla2x00_start_sp ( sp ) ; if ( rval != QLA_SUCCESS ) goto done_free_sp ; ql_dbg ( ql_dbg_disc , vha , 0x20a4 , "Async-%s<S2SV_blank>-<S2SV_blank>%8phC<S2SV_blank>hdl=%x<S2SV_blank>loopid=%x<S2SV_blank>portid<S2SV_blank>%02x%02x%02x.\\n" , sp -> name , fcport -> port_name , sp -> handle , fcport -> loop_id , fcport -> d_id . b . domain , fcport -> d_id . b . area , fcport -> d_id . b . al_pa ) ; return rval ; done_free_sp : sp -> free ( sp ) ; fcport -> flags &= ~ FCF_ASYNC_SENT ; done : <S2SV_StartBug> return rval ; <S2SV_EndBug> } | <S2SV_ModStart> ; done : fcport -> flags &= ~ FCF_ASYNC_ACTIVE ; |
1,737 | CWE-000 static int do_delete_objects ( struct sc_profile * profile , unsigned int myopt_delete_flags ) { <S2SV_StartBug> int r = 0 , count = 0 ; <S2SV_EndBug> if ( myopt_delete_flags & SC_PKCS15INIT_TYPE_DATA ) { struct sc_object_id app_oid ; sc_pkcs15_object_t * obj = NULL ; if ( opt_application_id != NULL ) { sc_format_oid ( & app_oid , opt_application_id ) ; r = sc_pkcs15_find_data_object_by_app_oid ( p15card , & app_oid , & obj ) ; } else if ( opt_application_name != NULL && opt_label != NULL ) { r = sc_pkcs15_find_data_object_by_name ( p15card , opt_application_name , opt_label , & obj ) ; } else { util_fatal ( "Specify<S2SV_blank>the<S2SV_blank>--application-id<S2SV_blank>or<S2SV_blank>--application-name<S2SV_blank>and<S2SV_blank>--label<S2SV_blank>for<S2SV_blank>the<S2SV_blank>data<S2SV_blank>object<S2SV_blank>to<S2SV_blank>be<S2SV_blank>deleted\\n" ) ; } if ( r >= 0 ) { r = sc_pkcs15init_delete_object ( p15card , profile , obj ) ; if ( r >= 0 ) count ++ ; } } if ( myopt_delete_flags & ( SC_PKCS15INIT_TYPE_PRKEY | SC_PKCS15INIT_TYPE_PUBKEY | SC_PKCS15INIT_TYPE_CHAIN ) ) { sc_pkcs15_id_t id ; if ( opt_objectid == NULL ) util_fatal ( "Specify<S2SV_blank>the<S2SV_blank>--id<S2SV_blank>for<S2SV_blank>key(s)<S2SV_blank>or<S2SV_blank>cert(s)<S2SV_blank>to<S2SV_blank>be<S2SV_blank>deleted\\n" ) ; sc_pkcs15_format_id ( opt_objectid , & id ) ; r = do_delete_crypto_objects ( p15card , profile , & id , myopt_delete_flags ) ; if ( r >= 0 ) count += r ; } <S2SV_StartBug> printf ( "Deleted<S2SV_blank>%d<S2SV_blank>objects\\n" , count ) ; <S2SV_EndBug> return r ; } | <S2SV_ModStart> count = 0 ; r = sc_lock ( p15card -> card ) ; if ( r < 0 ) return r <S2SV_ModStart> r ; } sc_unlock ( p15card -> card ) ; |
1,738 | CWE-000 void sort_5 ( t_stack * a , t_oplst * * lst , t_flag * f ) { t_stack * b ; t_oplst * * cur ; int pmax ; int maxx ; cur = lst ; b = create_stack ( NULL , a -> size ) ; set_max_maxx ( a , f , & maxx , & pmax ) ; while ( TAIL ( a , 0 ) != f -> max ) { if ( HEAD ( a , 0 ) != f -> max && HEAD ( a , 0 ) != maxx && HEAD ( a , 0 ) > HEAD ( a , 1 ) ) do_op ( a , b , & cur , "sa" ) ; <S2SV_StartBug> else if ( ( HEAD ( a , 1 ) == f -> max && HEAD ( a , 0 ) != maxx ) && <S2SV_EndBug> HEAD ( a , 0 ) < HEAD ( a , 1 ) ) do_op ( a , b , & cur , "pb" ) ; else do_op ( a , NULL , & cur , pmax <= 2 ? "ra" : "rra" ) ; } push_back_to_a ( a , b , & cur ) ; free_stack ( b ) ; } | <S2SV_ModStart> else if ( HEAD ( a , 0 ) < <S2SV_ModEnd> HEAD ( a <S2SV_ModStart> , 1 ) && ! ( HEAD ( a , 1 ) <S2SV_ModStart> , 0 ) == maxx <S2SV_ModEnd> ) ) do_op |
1,739 | CWE-000 static void visit_List ( const Compiler * const compiler , const Node * const node ) { bb_add_byte ( compiler -> buffer , END ) ; <S2SV_StartBug> for ( int64_t i = node -> children [ 0 ] -> children_len - 1 ; i >= 0 ; i -- ) { <S2SV_EndBug> <S2SV_StartBug> visit ( compiler , node -> children [ 0 ] -> children [ i ] ) ; <S2SV_EndBug> } bb_add_byte ( compiler -> buffer , NEWLIST ) ; } | <S2SV_ModStart> END ) ; visit_Body_reverse <S2SV_ModEnd> ( compiler , <S2SV_ModStart> [ 0 ] ) ; <S2SV_ModEnd> bb_add_byte ( compiler |
1,740 | CWE-000 bool SimonGetPosteriors ( int len , double * * retPosteriors , bool doApprox , int approxSize ) { int i , j ; assert ( allPosteriors == NULL ) ; allPosteriors = retPosteriors ; posterior = ( double * ) ( malloc ( ( len ) * sizeof ( double ) ) ) ; sample = ( int * ) ( malloc ( ( len ) * sizeof ( int ) ) ) ; Xpos = ( int * ) ( malloc ( ( len ) * sizeof ( int ) ) ) ; Ypos = ( int * ) ( malloc ( ( len ) * sizeof ( int ) ) ) ; states = ( int * ) ( malloc ( ( len ) * sizeof ( int ) ) ) ; checkSpaceX = ( double * ) malloc ( len * sizeof ( double ) ) ; checkSpaceY = ( double * ) malloc ( len * sizeof ( double ) ) ; if ( doApprox ) { <S2SV_StartBug> leftBounds = ( int * ) malloc ( ( len ) * sizeof ( int ) ) ; <S2SV_EndBug> <S2SV_StartBug> rightBounds = ( int * ) malloc ( ( len ) * sizeof ( int ) ) ; <S2SV_EndBug> } for ( i = 0 ; i < len ; i ++ ) { posterior [ i ] = 0.0 ; sample [ i ] = 0 ; } for ( i = 0 ; i < Nseq ; i ++ ) { for ( j = i + 1 ; j < Nseq ; j ++ ) { ProgressSpinner ( i + 1 , Nseq ) ; RunMakePosteriors ( i , j , doApprox , approxSize ) ; } } printf ( "\\r<S2SV_blank>...<S2SV_blank>Done<S2SV_blank>Get<S2SV_blank>Posteriors" ) ; allPosteriors = NULL ; return true ; } | <S2SV_ModStart> doApprox ) { printf ( "\\nDeclaring<S2SV_blank>left/right<S2SV_blank>%d" , len + 3 ) ; <S2SV_ModStart> ( ( len + 3 <S2SV_ModStart> ( ( len + 3 |
1,741 | CWE-000 <S2SV_StartBug> int parse_bw ( void * _buf , struct rdt_resource * r , struct rdt_domain * d ) <S2SV_EndBug> { <S2SV_StartBug> unsigned long data ; <S2SV_EndBug> char * buf = _buf ; if ( d -> have_new_ctrl ) { rdt_last_cmd_printf ( "duplicate<S2SV_blank>domain<S2SV_blank>%d\\n" , d -> id ) ; return - EINVAL ; } <S2SV_StartBug> if ( ! bw_validate ( buf , & data , r ) ) <S2SV_EndBug> return - EINVAL ; <S2SV_StartBug> d -> new_ctrl = data ; <S2SV_EndBug> d -> have_new_ctrl = true ; return 0 ; } | <S2SV_ModStart> int parse_bw ( struct rdt_parse_data * data <S2SV_ModEnd> , struct rdt_resource <S2SV_ModStart> { unsigned long bw_val <S2SV_ModEnd> ; if ( <S2SV_ModStart> ! bw_validate ( data -> <S2SV_ModStart> buf , & bw_val <S2SV_ModEnd> , r ) <S2SV_ModStart> -> new_ctrl = bw_val <S2SV_ModEnd> ; d -> |
1,742 | CWE-000 <S2SV_StartBug> static PHP_METHOD ( Phalcon_Mvc_Router_Route , getRoutePaths ) { <S2SV_EndBug> zend_long _0$$4 ; zval * paths = NULL , paths_sub , __$null , moduleName , controllerName , actionName , parts , routePaths , realClassName , namespaceName , _1$$9 ; <S2SV_StartBug> zval * this_ptr = getThis ( ) ; <S2SV_EndBug> ZVAL_UNDEF ( & paths_sub ) ; ZVAL_NULL ( & __$null ) ; ZVAL_UNDEF ( & moduleName ) ; ZVAL_UNDEF ( & controllerName ) ; ZVAL_UNDEF ( & actionName ) ; ZVAL_UNDEF ( & parts ) ; ZVAL_UNDEF ( & routePaths ) ; ZVAL_UNDEF ( & realClassName ) ; ZVAL_UNDEF ( & namespaceName ) ; ZVAL_UNDEF ( & _1$$9 ) ; ZEPHIR_MM_GROW ( ) ; zephir_fetch_params ( 1 , 0 , 1 , & paths ) ; if ( ! paths ) { paths = & paths_sub ; paths = & __$null ; } if ( Z_TYPE_P ( paths ) != IS_NULL ) { if ( Z_TYPE_P ( paths ) == IS_STRING ) { ZEPHIR_INIT_VAR ( & moduleName ) ; ZVAL_NULL ( & moduleName ) ; ZEPHIR_INIT_VAR ( & controllerName ) ; ZVAL_NULL ( & controllerName ) ; ZEPHIR_INIT_VAR ( & actionName ) ; ZVAL_NULL ( & actionName ) ; ZEPHIR_INIT_VAR ( & parts ) ; zephir_fast_explode_str ( & parts , SL ( "::" ) , paths , LONG_MAX TSRMLS_CC ) ; do { _0$$4 = zephir_fast_count_int ( & parts TSRMLS_CC ) ; if ( _0$$4 == 3 ) { ZEPHIR_OBS_NVAR ( & moduleName ) ; zephir_array_fetch_long ( & moduleName , & parts , 0 , PH_NOISY , "phalcon/mvc/router/route.zep" , 367 TSRMLS_CC ) ; ZEPHIR_OBS_NVAR ( & controllerName ) ; zephir_array_fetch_long ( & controllerName , & parts , 1 , PH_NOISY , "phalcon/mvc/router/route.zep" , 368 TSRMLS_CC ) ; ZEPHIR_OBS_NVAR ( & actionName ) ; zephir_array_fetch_long ( & actionName , & parts , 2 , PH_NOISY , "phalcon/mvc/router/route.zep" , 369 TSRMLS_CC ) ; break ; } if ( _0$$4 == 2 ) { ZEPHIR_OBS_NVAR ( & controllerName ) ; zephir_array_fetch_long ( & controllerName , & parts , 0 , PH_NOISY , "phalcon/mvc/router/route.zep" , 373 TSRMLS_CC ) ; ZEPHIR_OBS_NVAR ( & actionName ) ; zephir_array_fetch_long ( & actionName , & parts , 1 , PH_NOISY , "phalcon/mvc/router/route.zep" , 374 TSRMLS_CC ) ; break ; } if ( _0$$4 == 1 ) { ZEPHIR_OBS_NVAR ( & controllerName ) ; zephir_array_fetch_long ( & controllerName , & parts , 0 , PH_NOISY , "phalcon/mvc/router/route.zep" , 378 TSRMLS_CC ) ; break ; } } while ( 0 ) ; ZEPHIR_INIT_VAR ( & routePaths ) ; array_init ( & routePaths ) ; if ( Z_TYPE_P ( & moduleName ) != IS_NULL ) { zephir_array_update_string ( & routePaths , SL ( "module" ) , & moduleName , PH_COPY | PH_SEPARATE ) ; } if ( Z_TYPE_P ( & controllerName ) != IS_NULL ) { if ( zephir_memnstr_str ( & controllerName , SL ( "\\\\" ) , "phalcon/mvc/router/route.zep" , 393 ) ) { ZEPHIR_INIT_VAR ( & realClassName ) ; zephir_get_class_ns ( & realClassName , & controllerName , 0 TSRMLS_CC ) ; ZEPHIR_INIT_VAR ( & namespaceName ) ; zephir_get_ns_class ( & namespaceName , & controllerName , 0 TSRMLS_CC ) ; if ( zephir_is_true ( & namespaceName ) ) { zephir_array_update_string ( & routePaths , SL ( "namespace" ) , & namespaceName , PH_COPY | PH_SEPARATE ) ; } } else { ZEPHIR_CPY_WRT ( & realClassName , & controllerName ) ; } ZEPHIR_INIT_VAR ( & _1$$9 ) ; zephir_uncamelize ( & _1$$9 , & realClassName , NULL ) ; zephir_array_update_string ( & routePaths , SL ( "controller" ) , & _1$$9 , PH_COPY | PH_SEPARATE ) ; } if ( Z_TYPE_P ( & actionName ) != IS_NULL ) { zephir_array_update_string ( & routePaths , SL ( "action" ) , & actionName , PH_COPY | PH_SEPARATE ) ; } } else { ZEPHIR_CPY_WRT ( & routePaths , paths ) ; } } else { ZEPHIR_INIT_NVAR ( & routePaths ) ; array_init ( & routePaths ) ; } if ( Z_TYPE_P ( & routePaths ) != IS_ARRAY ) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR ( phalcon_mvc_router_exception_ce , "The<S2SV_blank>route<S2SV_blank>contains<S2SV_blank>invalid<S2SV_blank>paths" , "phalcon/mvc/router/route.zep" , 425 ) ; return ; } RETURN_CCTOR ( & routePaths ) ; } | <S2SV_ModStart> static PHP_METHOD ( Phalcon_Paginator_Adapter , getLimit ) { RETURN_MEMBER ( <S2SV_ModEnd> getThis ( ) <S2SV_ModStart> getThis ( ) , "_limitRows" <S2SV_ModEnd> ) ; } |
1,743 | CWE-000 void SynchronizeGpuContext ( GpuContext * gcontext ) { CUresult rc ; int i ; if ( ! gcontext -> worker_is_running ) return ; pg_atomic_write_u32 ( & gcontext -> terminate_workers , 1 ) ; pthreadCondBroadcast ( gcontext -> cond ) ; for ( i = 0 ; i < gcontext -> num_workers ; i ++ ) { if ( ( rc = cuEventRecord ( gcontext -> cuda_events0 [ i ] , CU_STREAM_PER_THREAD ) ) != CUDA_SUCCESS ) elog ( WARNING , "failed<S2SV_blank>on<S2SV_blank>cuEventRecord:<S2SV_blank>%s" , errorText ( rc ) ) ; if ( ( rc = cuEventRecord ( gcontext -> cuda_events1 [ i ] , CU_STREAM_PER_THREAD ) ) != CUDA_SUCCESS ) elog ( WARNING , "failed<S2SV_blank>on<S2SV_blank>cuEventRecord:<S2SV_blank>%s" , errorText ( rc ) ) ; } for ( i = 0 ; i < gcontext -> num_workers ; i ++ ) { pthread_t thread = gcontext -> worker_threads [ i ] ; if ( ( errno = pthread_join ( thread , NULL ) ) != 0 ) elog ( PANIC , "failed<S2SV_blank>on<S2SV_blank>pthread_join:<S2SV_blank>%m" ) ; } memset ( gcontext -> worker_threads , 0 , sizeof ( pthread_t ) * gcontext -> num_workers ) ; gcontext -> worker_is_running = false ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> = false ; pg_atomic_write_u32 ( & gcontext -> terminate_workers , 0 ) ; |
1,744 | CWE-000 int qedr_iw_connect ( struct iw_cm_id * cm_id , struct iw_cm_conn_param * conn_param ) { struct qedr_dev * dev = get_qedr_dev ( cm_id -> device ) ; struct qed_iwarp_connect_out out_params ; struct qed_iwarp_connect_in in_params ; struct qed_iwarp_cm_info * cm_info ; struct sockaddr_in6 * laddr6 ; struct sockaddr_in6 * raddr6 ; struct sockaddr_in * laddr ; struct sockaddr_in * raddr ; struct qedr_iw_ep * ep ; struct qedr_qp * qp ; int rc = 0 ; int i ; qp = idr_find ( & dev -> qpidr , conn_param -> qpn ) ; laddr = ( struct sockaddr_in * ) & cm_id -> local_addr ; raddr = ( struct sockaddr_in * ) & cm_id -> remote_addr ; laddr6 = ( struct sockaddr_in6 * ) & cm_id -> local_addr ; raddr6 = ( struct sockaddr_in6 * ) & cm_id -> remote_addr ; DP_DEBUG ( dev , QEDR_MSG_IWARP , "Connect<S2SV_blank>source<S2SV_blank>address:<S2SV_blank>%pISpc,<S2SV_blank>remote<S2SV_blank>address:<S2SV_blank>%pISpc\\n" , & cm_id -> local_addr , & cm_id -> remote_addr ) ; if ( ! laddr -> sin_port || ! raddr -> sin_port ) return - EINVAL ; ep = kzalloc ( sizeof ( * ep ) , GFP_KERNEL ) ; if ( ! ep ) return - ENOMEM ; ep -> dev = dev ; ep -> qp = qp ; qp -> ep = ep ; cm_id -> add_ref ( cm_id ) ; ep -> cm_id = cm_id ; in_params . event_cb = qedr_iw_event_handler ; in_params . cb_context = ep ; cm_info = & in_params . cm_info ; memset ( cm_info -> local_ip , 0 , sizeof ( cm_info -> local_ip ) ) ; memset ( cm_info -> remote_ip , 0 , sizeof ( cm_info -> remote_ip ) ) ; <S2SV_StartBug> if ( cm_id -> remote_addr . ss_family == AF_INET ) { <S2SV_EndBug> cm_info -> ip_version = QED_TCP_IPV4 ; cm_info -> remote_ip [ 0 ] = ntohl ( raddr -> sin_addr . s_addr ) ; cm_info -> local_ip [ 0 ] = ntohl ( laddr -> sin_addr . s_addr ) ; cm_info -> remote_port = ntohs ( raddr -> sin_port ) ; cm_info -> local_port = ntohs ( laddr -> sin_port ) ; cm_info -> vlan = qedr_iw_get_vlan_ipv4 ( dev , cm_info -> local_ip ) ; rc = qedr_addr4_resolve ( dev , laddr , raddr , ( u8 * ) in_params . remote_mac_addr ) ; in_params . mss = dev -> iwarp_max_mtu - ( sizeof ( struct iphdr ) + sizeof ( struct tcphdr ) ) ; } else { in_params . cm_info . ip_version = QED_TCP_IPV6 ; for ( i = 0 ; i < 4 ; i ++ ) { cm_info -> remote_ip [ i ] = ntohl ( raddr6 -> sin6_addr . in6_u . u6_addr32 [ i ] ) ; cm_info -> local_ip [ i ] = ntohl ( laddr6 -> sin6_addr . in6_u . u6_addr32 [ i ] ) ; } cm_info -> local_port = ntohs ( laddr6 -> sin6_port ) ; cm_info -> remote_port = ntohs ( raddr6 -> sin6_port ) ; in_params . mss = dev -> iwarp_max_mtu - ( sizeof ( struct ipv6hdr ) + sizeof ( struct tcphdr ) ) ; cm_info -> vlan = qedr_iw_get_vlan_ipv6 ( cm_info -> local_ip ) ; rc = qedr_addr6_resolve ( dev , laddr6 , raddr6 , ( u8 * ) in_params . remote_mac_addr ) ; } if ( rc ) goto err ; DP_DEBUG ( dev , QEDR_MSG_IWARP , "ord<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>ird=%d<S2SV_blank>private_data=%p<S2SV_blank>private_data_len=%d<S2SV_blank>rq_psn=%d\\n" , conn_param -> ord , conn_param -> ird , conn_param -> private_data , conn_param -> private_data_len , qp -> rq_psn ) ; cm_info -> ord = conn_param -> ord ; cm_info -> ird = conn_param -> ird ; cm_info -> private_data = conn_param -> private_data ; cm_info -> private_data_len = conn_param -> private_data_len ; in_params . qp = qp -> qed_qp ; memcpy ( in_params . local_mac_addr , dev -> ndev -> dev_addr , ETH_ALEN ) ; ep -> during_connect = 1 ; rc = dev -> ops -> iwarp_connect ( dev -> rdma_ctx , & in_params , & out_params ) ; if ( rc ) goto err ; return rc ; err : cm_id -> rem_ref ( cm_id ) ; kfree ( ep ) ; return rc ; } | <S2SV_ModStart> ; if ( ! IS_ENABLED ( CONFIG_IPV6 ) || |
1,745 | CWE-000 static void synthesize_lrmd_failure ( lrm_state_t * lrm_state , xmlNode * action , int rc ) { lrmd_event_data_t * op = NULL ; <S2SV_StartBug> lrmd_rsc_info_t * rsc_info = NULL ; <S2SV_EndBug> const char * operation = crm_element_value ( action , XML_LRM_ATTR_TASK ) ; const char * target_node = crm_element_value ( action , XML_LRM_ATTR_TARGET ) ; xmlNode * xml_rsc = find_xml_node ( action , XML_CIB_TAG_RESOURCE , TRUE ) ; if ( ( xml_rsc == NULL ) || ( ID ( xml_rsc ) == NULL ) ) { crm_info ( "Can\'t<S2SV_blank>fake<S2SV_blank>%s<S2SV_blank>failure<S2SV_blank>(%d)<S2SV_blank>on<S2SV_blank>%s<S2SV_blank>without<S2SV_blank>resource<S2SV_blank>configuration" , crm_element_value ( action , XML_LRM_ATTR_TASK_KEY ) , rc , target_node ) ; return ; } else if ( operation == NULL ) { crm_info ( "Can\'t<S2SV_blank>fake<S2SV_blank>%s<S2SV_blank>failure<S2SV_blank>(%d)<S2SV_blank>on<S2SV_blank>%s<S2SV_blank>without<S2SV_blank>operation" , ID ( xml_rsc ) , rc , target_node ) ; return ; } op = construct_op ( lrm_state , action , ID ( xml_rsc ) , operation ) ; if ( safe_str_eq ( operation , RSC_NOTIFY ) ) { fake_op_status ( lrm_state , op , PCMK_LRM_OP_DONE , PCMK_OCF_OK ) ; } else { fake_op_status ( lrm_state , op , PCMK_LRM_OP_ERROR , rc ) ; } crm_info ( "Faking<S2SV_blank>%s_%s_%d<S2SV_blank>result<S2SV_blank>(%d)<S2SV_blank>on<S2SV_blank>%s" , op -> rsc_id , op -> op_type , op -> interval , op -> rc , target_node ) ; <S2SV_StartBug> if ( lrm_state ) { <S2SV_EndBug> rsc_info = lrm_state_get_rsc_info ( lrm_state , op -> rsc_id , 0 ) ; } if ( rsc_info ) { lrmd_free_rsc_info ( rsc_info ) ; <S2SV_StartBug> process_lrm_event ( lrm_state , op , NULL ) ; <S2SV_EndBug> } else if ( controld_action_is_recordable ( op -> op_type ) ) { const char * standard = crm_element_value ( xml_rsc , XML_AGENT_ATTR_CLASS ) ; const char * provider = crm_element_value ( xml_rsc , XML_AGENT_ATTR_PROVIDER ) ; const char * type = crm_element_value ( xml_rsc , XML_ATTR_TYPE ) ; if ( standard && type ) { rsc_info = lrmd_new_rsc_info ( op -> rsc_id , standard , provider , type ) ; do_update_resource ( target_node , rsc_info , op ) ; lrmd_free_rsc_info ( rsc_info ) ; } else { crm_info ( "Can\'t<S2SV_blank>fake<S2SV_blank>%s<S2SV_blank>failure<S2SV_blank>(%d)<S2SV_blank>on<S2SV_blank>%s<S2SV_blank>without<S2SV_blank>resource<S2SV_blank>standard<S2SV_blank>and<S2SV_blank>type" , crm_element_value ( action , XML_LRM_ATTR_TASK_KEY ) , rc , target_node ) ; } } lrmd_free_event ( op ) ; } | <S2SV_ModStart> = NULL ; <S2SV_ModEnd> const char * <S2SV_ModStart> target_node ) ; <S2SV_ModEnd> process_lrm_event ( lrm_state <S2SV_ModStart> op , NULL , action ) ; <S2SV_ModEnd> lrmd_free_event ( op |
1,746 | CWE-000 void write_signed_int ( t_conversion * conversion , va_list ap , t_format * format ) { intmax_t nbr ; char * draft ; nbr = get_signed_int_arg ( conversion , ap ) ; <S2SV_StartBug> draft = ft_itoa ( nbr ) ; <S2SV_EndBug> if ( conversion -> precision_set ) apply_precision ( conversion , & draft ) ; if ( conversion -> width ) apply_width ( conversion , & draft ) ; if ( nbr >= 0 && ( conversion -> flags . pos_values_begin_w_space || conversion -> flags . show_sign ) ) apply_prefix ( conversion , & draft ) ; ft_putstr ( draft ) ; format -> chars_written += ft_strlen ( draft ) ; return ; } | <S2SV_ModStart> ; draft = ft_itoa_base_intmax ( nbr , 10 <S2SV_ModEnd> ) ; if |
1,747 | CWE-000 Frame build_image_frame ( ) { Frame frame ; <S2SV_StartBug> clear_array ( & frame . message , 8 ) ; <S2SV_EndBug> <S2SV_StartBug> clear_array ( & frame . command , 5 ) ; <S2SV_EndBug> frame . start = 0x0D ; <S2SV_StartBug> frame . adress = 'Z' ; <S2SV_EndBug> <S2SV_StartBug> frame . command = "D001" ; <S2SV_EndBug> <S2SV_StartBug> set_checksum ( & frame ) ; <S2SV_EndBug> frame . end = 0x0A ; } | <S2SV_ModStart> . message , INFO_FRAME_MESSAGE_LEN <S2SV_ModEnd> ) ; clear_array <S2SV_ModStart> . command , INFO_FRAME_COMMAND_LEN <S2SV_ModEnd> ) ; frame <S2SV_ModStart> ; frame . address <S2SV_ModEnd> = 'Z' ; <S2SV_ModStart> = 'Z' ; strncpy ( <S2SV_ModStart> frame . command , "D001" , IMG_FRAME_COMMAND_LEN ) <S2SV_ModEnd> ; set_checksum ( <S2SV_ModStart> ( & frame , calculate_checksum ( frame ) |
1,748 | CWE-000 __noreturn void master_early_init ( void ) { static uint32_t entry_count = 0 ; <S2SV_StartBug> void * boot_vmm_start = NULL ; <S2SV_EndBug> if ( entry_count != 0 ) goto next_line ; entry_count ++ ; early_mapping_clear ( ) ; mmu_handlers_clear ( ) ; if ( early_devices_init ( ) < 0 ) goto panic ; arch_early_init ( ) ; if ( early_console_init ( EARLY_CONSOLE_BUS , EARLY_CONSOLE_BASE , EARLY_CONSOLE_MAPPING ) < 0 ) panic ( "Early<S2SV_blank>console<S2SV_blank>init<S2SV_blank>failed.\\n" ) ; kputs ( "Hello,<S2SV_blank>world!\\n" ) ; arch_init_mmu ( ) ; arch_jump_high ( ) ; next_line : <S2SV_StartBug> { <S2SV_EndBug> uint32_t page_num = 1 ; uint32_t stack_poi , astack_poi ; __asm__ __volatile__ ( "movl<S2SV_blank>%%esp,%%eax;" : "=a" ( stack_poi ) : : "memory" ) ; astack_poi = stack_poi ; if ( stack_poi % PAGE_SIZE ) astack_poi = ( ( stack_poi ) / PAGE_SIZE ) * PAGE_SIZE + PAGE_SIZE ; uint32_t page_start = 0 ; page_start = astack_poi + page_num * PAGE_SIZE ; __asm__ __volatile__ ( "subl<S2SV_blank>%%eax,%%esp;" : : "a" ( page_start - stack_poi ) : "memory" ) ; boot_vmm_start = page_start ; } simple_allocator_bootstrap ( boot_vmm_start , PAGE_SIZE ) ; page_allocator_init ( ) ; simple_allocator_init ( ) ; add_memory_pages ( ) ; goto panic ; panic : while ( 1 ) ; } | <S2SV_ModStart> = 0 ; char boot_vmm_start [ PAGE_SIZE ] <S2SV_ModEnd> ; if ( <S2SV_ModStart> ; next_line : simple_allocator_bootstrap ( ( void * ) <S2SV_ModEnd> boot_vmm_start , PAGE_SIZE |
1,749 | CWE-000 static void process_msg ( topic_subscription_pt sub , pubsub_udp_msg_pt msg ) { hash_map_iterator_pt iter = hashMapIterator_create ( sub -> servicesMap ) ; while ( hashMapIterator_hasNext ( iter ) ) { hash_map_entry_pt entry = hashMapIterator_nextEntry ( iter ) ; pubsub_subscriber_pt subsvc = hashMapEntry_getKey ( entry ) ; hash_map_pt msgTypes = hashMapEntry_getValue ( entry ) ; pubsub_message_type * msgType = hashMap_get ( msgTypes , & ( msg -> header . type ) ) ; if ( msgType == NULL ) { printf ( "TS:<S2SV_blank>Primary<S2SV_blank>message<S2SV_blank>%d<S2SV_blank>not<S2SV_blank>supported.<S2SV_blank>NOT<S2SV_blank>receiving<S2SV_blank>any<S2SV_blank>part<S2SV_blank>of<S2SV_blank>the<S2SV_blank>whole<S2SV_blank>message.\\n" , msg -> header . type ) ; } else { void * msgInst = NULL ; char * name = pubsubSerializer_getName ( msgType ) ; version_pt msgVersion = pubsubSerializer_getVersion ( msgType ) ; bool validVersion = checkVersion ( msgVersion , & msg -> header ) ; if ( validVersion ) { <S2SV_StartBug> int rc = pubsubSerializer_deserialize ( msgType , ( const void * ) msg -> payload , & msgInst ) ; <S2SV_EndBug> <S2SV_StartBug> if ( rc != - 1 ) { <S2SV_EndBug> bool release = true ; pubsub_multipart_callbacks_t mp_callbacks ; mp_callbacks . handle = sub ; mp_callbacks . localMsgTypeIdForMsgType = pubsub_localMsgTypeIdForMsgType ; mp_callbacks . getMultipart = NULL ; subsvc -> receive ( subsvc -> handle , name , msg -> header . type , msgInst , & mp_callbacks , & release ) ; if ( release ) { pubsubSerializer_freeMsg ( msgType , msgInst ) ; } } else { printf ( "TS:<S2SV_blank>Cannot<S2SV_blank>deserialize<S2SV_blank>msgType<S2SV_blank>%s.\\n" , name ) ; } } else { int major = 0 , minor = 0 ; version_getMajor ( msgVersion , & major ) ; version_getMinor ( msgVersion , & minor ) ; printf ( "TS:<S2SV_blank>Version<S2SV_blank>mismatch<S2SV_blank>for<S2SV_blank>primary<S2SV_blank>message<S2SV_blank>\'%s\'<S2SV_blank>(have<S2SV_blank>%d.%d,<S2SV_blank>received<S2SV_blank>%u.%u).<S2SV_blank>NOT<S2SV_blank>sending<S2SV_blank>any<S2SV_blank>part<S2SV_blank>of<S2SV_blank>the<S2SV_blank>whole<S2SV_blank>message.\\n" , name , major , minor , msg -> header . major , msg -> header . minor ) ; } } } hashMapIterator_destroy ( iter ) ; } | <S2SV_ModStart> validVersion ) { celix_status_t status <S2SV_ModEnd> = pubsubSerializer_deserialize ( <S2SV_ModStart> ; if ( status == CELIX_SUCCESS <S2SV_ModEnd> ) { bool |
1,750 | CWE-000 static void convert_sourcefiles_in ( char * source , char * dest_dir , char * dest , char * suffix ) { char abs_srcdir [ MAXPGPATH ] ; char abs_builddir [ MAXPGPATH ] ; char testtablespace [ MAXPGPATH ] ; char indir [ MAXPGPATH ] ; struct stat st ; int ret ; char * * name ; char * * names ; int count = 0 ; # ifdef WIN32 char * c ; # endif if ( ! getcwd ( abs_builddir , sizeof ( abs_builddir ) ) ) { fprintf ( stderr , _ ( "%s:<S2SV_blank>could<S2SV_blank>not<S2SV_blank>get<S2SV_blank>current<S2SV_blank>directory:<S2SV_blank>%s\\n" ) , progname , strerror ( errno ) ) ; exit_nicely ( 2 ) ; } if ( srcdir ) strlcpy ( abs_srcdir , srcdir , MAXPGPATH ) ; else strlcpy ( abs_srcdir , abs_builddir , MAXPGPATH ) ; snprintf ( indir , MAXPGPATH , "%s/%s" , abs_srcdir , source ) ; ret = stat ( indir , & st ) ; if ( ret != 0 || ! S_ISDIR ( st . st_mode ) ) { return ; } names = pgfnames ( indir ) ; if ( ! names ) exit_nicely ( 2 ) ; { char outdir [ MAXPGPATH ] ; snprintf ( outdir , MAXPGPATH , "%s/%s" , dest_dir , dest ) ; if ( ! directory_exists ( outdir ) ) make_directory ( outdir ) ; } # ifdef WIN32 for ( c = abs_builddir ; * c ; c ++ ) if ( * c == '\\\\' ) * c = '/' ; for ( c = abs_srcdir ; * c ; c ++ ) if ( * c == '\\\\' ) * c = '/' ; # endif snprintf ( testtablespace , MAXPGPATH , "%s/testtablespace" , abs_builddir ) ; # ifdef WIN32 if ( directory_exists ( testtablespace ) ) rmtree ( testtablespace , true ) ; make_directory ( testtablespace ) ; # endif for ( name = names ; * name ; name ++ ) { char srcfile [ MAXPGPATH ] ; char destfile [ MAXPGPATH ] ; char prefix [ MAXPGPATH ] ; FILE * infile , * outfile ; char line [ 1024 ] ; bool has_tokens = false ; <S2SV_StartBug> if ( strlen ( * name ) < 8 ) <S2SV_EndBug> continue ; if ( strcmp ( * name + strlen ( * name ) - 7 , ".source" ) != 0 ) continue ; count ++ ; snprintf ( prefix , strlen ( * name ) - 6 , "%s" , * name ) ; snprintf ( srcfile , MAXPGPATH , "%s/%s" , indir , * name ) ; snprintf ( destfile , MAXPGPATH , "%s/%s/%s.%s" , dest_dir , dest , prefix , suffix ) ; infile = fopen ( srcfile , "r" ) ; if ( ! infile ) { fprintf ( stderr , _ ( "%s:<S2SV_blank>could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>file<S2SV_blank>\\"%s\\"<S2SV_blank>for<S2SV_blank>reading:<S2SV_blank>%s\\n" ) , progname , srcfile , strerror ( errno ) ) ; exit_nicely ( 2 ) ; } outfile = fopen ( destfile , "w" ) ; if ( ! outfile ) { fprintf ( stderr , _ ( "%s:<S2SV_blank>could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>file<S2SV_blank>\\"%s\\"<S2SV_blank>for<S2SV_blank>writing:<S2SV_blank>%s\\n" ) , progname , destfile , strerror ( errno ) ) ; exit_nicely ( 2 ) ; } while ( fgets ( line , sizeof ( line ) , infile ) ) { replace_string ( line , "@abs_srcdir@" , abs_srcdir ) ; replace_string ( line , "@abs_builddir@" , abs_builddir ) ; replace_string ( line , "@testtablespace@" , testtablespace ) ; replace_string ( line , "@DLSUFFIX@" , DLSUFFIX ) ; replace_string ( line , "@bindir@" , bindir ) ; fputs ( line , outfile ) ; if ( ! has_tokens && strchr ( line , '@' ) != NULL ) has_tokens = true ; } fclose ( infile ) ; fclose ( outfile ) ; if ( has_tokens ) { char cmd [ MAXPGPATH * 3 ] ; snprintf ( cmd , sizeof ( cmd ) , SYSTEMQUOTE "%s<S2SV_blank>%s" SYSTEMQUOTE , gpstringsubsprog , destfile ) ; if ( run_diff ( cmd , destfile ) != 0 ) { fprintf ( stderr , _ ( "%s:<S2SV_blank>could<S2SV_blank>not<S2SV_blank>convert<S2SV_blank>%s\\n" ) , progname , destfile ) ; } } } if ( count <= 0 ) { fprintf ( stderr , _ ( "%s:<S2SV_blank>no<S2SV_blank>*.source<S2SV_blank>files<S2SV_blank>found<S2SV_blank>in<S2SV_blank>\\"%s\\"\\n" ) , progname , indir ) ; exit_nicely ( 2 ) ; } pgfnames_cleanup ( names ) ; } | <S2SV_ModStart> ; if ( strncmp ( * name , "uao" , 3 ) == 0 && strcmp ( * name + strlen ( * name ) - 7 , ".source" ) != 0 ) { snprintf ( srcfile , MAXPGPATH , "%s/%s" , indir , * name ) ; snprintf ( destfile , MAXPGPATH , "%s/%s/%s" , dest_dir , dest , * name ) ; count += generate_uao_sourcefiles ( srcfile , destfile , suffix ) ; continue ; } if ( |
1,751 | CWE-000 static Block * get_block ( void * raw_block ) { uint32_t p = ( ( uint32_t ) raw_block ) ; <S2SV_StartBug> if ( p & 0x3 != 0 ) <S2SV_EndBug> fail ( ) ; size_t offset = offsetof ( Block , data ) ; Block * b = raw_block - offset ; return b ; } | <S2SV_ModStart> ; if ( ( <S2SV_ModStart> p & 0x3 ) |
1,752 | CWE-000 void ft_d_calc ( t_dda * l , t_param * par , t_player * p , int col ) { double perp_wall_dist ; double dist ; double x_diff ; double y_diff ; x_diff = l -> map -> x - l -> p -> x ; y_diff = l -> map -> y - l -> p -> y ; <S2SV_StartBug> printf ( "l->map->x<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>l->map-><S2SV_blank>=<S2SV_blank>%d<S2SV_blank>l->p->x<S2SV_blank>=<S2SV_blank>%f<S2SV_blank>l->p->y<S2SV_blank>=<S2SV_blank>%f<S2SV_blank>" , l -> map -> x , l -> map -> y , l -> p -> x , l -> p -> y ) ; <S2SV_EndBug> if ( l -> side == 0 ) perp_wall_dist = ( x_diff + ( 1 - l -> step -> x ) / 2 ) / l -> ray_dir -> x ; else perp_wall_dist = ( y_diff + ( 1 - l -> step -> y ) / 2 ) / l -> ray_dir -> y ; printf ( "perp_wall_dist<S2SV_blank>=<S2SV_blank>%f\\n" , perp_wall_dist ) ; ft_draw_ray ( p , l , perp_wall_dist , par ) ; if ( perp_wall_dist == 0 ) dist = 0 ; else dist = ( int ) ( HEIGHT / perp_wall_dist ) ; <S2SV_StartBug> if ( col < WIDTH ) <S2SV_EndBug> draw_col ( dist , col , par , l ) ; } | <S2SV_ModStart> ; printf ( "l->map->x<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>l->map-><S2SV_blank>=<S2SV_blank>%d<S2SV_blank>l->p->x<S2SV_blank>=<S2SV_blank>%f<S2SV_blank>l->p->y<S2SV_blank>=<S2SV_blank>%f\\n" <S2SV_ModEnd> , l -> <S2SV_ModStart> perp_wall_dist ) ; printf ( "dist<S2SV_blank>=<S2SV_blank>%f\\n" , dist ) ; |
1,753 | CWE-000 ISR ( INT2_vect ) { <S2SV_StartBug> if ( PIND == 0x0C ) { <S2SV_EndBug> resetGame ( ) ; return ; } if ( blockLocation . column > 0 ) { if ( display_array [ blockLocation . row ] [ blockLocation . column - 1 ] == 0 && display_array [ blockLocation . row - 1 ] [ blockLocation . column - 1 ] == 0 ) { blockLocation . column -- ; } } } | <S2SV_ModStart> if ( PIND >> 3 == 0x03 <S2SV_ModEnd> ) { resetGame |
1,754 | CWE-000 void tiler ( TrianglePShaderData * local_data_ptr , uint32_t vshader_idx , uint32_t tri_num , uint16_t * num_of_tris_in_tile_arr , gpu_cfg_t * cfg_ptr ) { hfixpt_t x [ 3 ] ; hfixpt_t y [ 3 ] ; for ( size_t i = 0 ; i < 3 ; i ++ ) { <S2SV_StartBug> x [ i ] = local_data_ptr -> screen_coords [ i ] . as_struct . x ; <S2SV_EndBug> <S2SV_StartBug> y [ i ] = local_data_ptr -> screen_coords [ i ] . as_struct . y ; <S2SV_EndBug> } volatile TrianglePShaderData * volatile ext_data_arr = cfg_ptr -> tri_for_pshader [ vshader_idx ] ; ext_data_arr [ tri_num ] = * local_data_ptr ; volatile TrianglePShaderData * volatile * ext_tri_ptr_arr = cfg_ptr -> tri_ptr_list [ vshader_idx ] ; BoundBox bb = clip_boundbox_to_screen ( get_tri_boundbox ( x , y ) , cfg_ptr ) ; bb . min . x &= ~ ( GPU_TILE_WIDTH - 1 ) ; bb . min . y &= ~ ( GPU_TILE_HEIGHT - 1 ) ; ScreenPt p ; for ( p . y = bb . min . y ; p . y <= bb . max . y ; p . y += GPU_TILE_HEIGHT ) { for ( p . x = bb . min . x ; p . x <= bb . max . x ; p . x += GPU_TILE_WIDTH ) { hfixpt_t x0 = hfixpt_from_screenxy ( p . x ) ; hfixpt_t x1 = hfixpt_from_screenxy ( p . x + GPU_TILE_WIDTH - 1 ) ; hfixpt_t y0 = hfixpt_from_screenxy ( p . y ) ; hfixpt_t y1 = hfixpt_from_screenxy ( p . y + GPU_TILE_HEIGHT - 1 ) ; FixPt3 b0 = get_bar_coords ( x , y , x0 , y0 ) ; FixPt3 b1 = get_bar_coords ( x , y , x0 , y1 ) ; FixPt3 b2 = get_bar_coords ( x , y , x1 , y0 ) ; FixPt3 b3 = get_bar_coords ( x , y , x1 , y1 ) ; bool tri_inside_tile = true ; for ( int i = 0 ; i < 3 ; i ++ ) { if ( ( b0 . as_array [ i ] & b1 . as_array [ i ] & b2 . as_array [ i ] & b3 . as_array [ i ] ) < 0 ) { tri_inside_tile = false ; break ; } } if ( tri_inside_tile ) { size_t tile_num = ( p . y >> GPU_TILE_HEIGHT_LOG2 ) * ( get_screen_width ( cfg_ptr ) >> GPU_TILE_WIDTH_LOG2 ) + ( p . x >> GPU_TILE_WIDTH_LOG2 ) ; size_t idx = ( tile_num << GPU_MAX_TRIANGLES_PER_TILE_LOG2 ) + num_of_tris_in_tile_arr [ tile_num ] ; ext_tri_ptr_arr [ idx ] = & ( ext_data_arr [ tri_num ] ) ; num_of_tris_in_tile_arr [ tile_num ] ++ ; } } } } | <S2SV_ModStart> = local_data_ptr -> screen_x [ i ] <S2SV_ModEnd> ; y [ <S2SV_ModStart> = local_data_ptr -> screen_y [ i ] <S2SV_ModEnd> ; } volatile |
1,755 | CWE-000 static int apply_r_riscv_rvc_jump_rela ( struct module * me , u32 * location , Elf_Addr v ) { <S2SV_StartBug> s64 offset = ( void * ) v - ( void * ) location ; <S2SV_EndBug> u16 imm11 = ( offset & 0x800 ) << ( 12 - 11 ) ; u16 imm10 = ( offset & 0x400 ) >> ( 10 - 8 ) ; u16 imm9_8 = ( offset & 0x300 ) << ( 12 - 11 ) ; u16 imm7 = ( offset & 0x80 ) >> ( 7 - 6 ) ; u16 imm6 = ( offset & 0x40 ) << ( 12 - 11 ) ; u16 imm5 = ( offset & 0x20 ) >> ( 5 - 2 ) ; u16 imm4 = ( offset & 0x10 ) << ( 12 - 5 ) ; u16 imm3_1 = ( offset & 0xe ) << ( 12 - 10 ) ; * ( u16 * ) location = ( * ( u16 * ) location & 0xe003 ) | imm11 | imm10 | imm9_8 | imm7 | imm6 | imm5 | imm4 | imm3_1 ; return 0 ; } | <S2SV_ModStart> v ) { ptrdiff_t <S2SV_ModEnd> offset = ( |
1,756 | CWE-000 int main ( int argc , char * argv [ ] ) { int provided ; MPI_Init_thread ( & argc , & argv , MPI_THREAD_FUNNELED , & provided ) ; MPI_Status status [ 2 ] ; MPI_Request request [ 2 ] ; MPI_Comm sm_comm ; MPI_Comm_split_type ( MPI_COMM_WORLD , MPI_COMM_TYPE_SHARED , 0 , MPI_INFO_NULL , & sm_comm ) ; int myWorldRank , worldSize , nthreads ; MPI_Comm_rank ( MPI_COMM_WORLD , & myWorldRank ) ; MPI_Comm_size ( MPI_COMM_WORLD , & worldSize ) ; int mySharedRank , sharedSize ; MPI_Comm_rank ( sm_comm , & mySharedRank ) ; MPI_Comm_size ( sm_comm , & sharedSize ) ; int nNodes = CEILING ( worldSize , sharedSize ) ; const int root = 0 ; const int sRow = ( BLOCK_LOW ( myWorldRank , worldSize , ROWS ) + 1 ) ; const int eRow = ( BLOCK_HIGH ( myWorldRank , worldSize , ROWS ) + 1 ) ; const int nRows = eRow - sRow + 3 ; int max_iterations ; int iteration = 0 ; double dt = 0.0 ; double elapsed_time ; if ( argc > 1 ) { max_iterations = atoi ( argv [ 1 ] ) ; } if ( ( argc <= 1 || max_iterations < 0 ) ) { if ( myWorldRank == 0 ) { printf ( "Maximum<S2SV_blank>iterations<S2SV_blank>[100-4000]?:<S2SV_blank>" ) ; fflush ( stdout ) ; while ( ! scanf ( "%d" , & max_iterations ) || max_iterations < 0 ) { printf ( "wrong<S2SV_blank>input<S2SV_blank>value.<S2SV_blank>Try<S2SV_blank>again...<S2SV_blank>" ) ; fflush ( stdout ) ; } } MPI_Bcast ( & max_iterations , 1 , MPI_INT , 0 , MPI_COMM_WORLD ) ; } if ( myWorldRank == root ) printf ( "Running<S2SV_blank>%d<S2SV_blank>iterations<S2SV_blank>\\n" , max_iterations ) ; fflush ( stdout ) ; double * Temperature ; double * Temperature_last ; double * temp ; const int size = nRows * COL2 ; Temperature = malloc ( size * sizeof ( double ) ) ; Temperature_last = malloc ( size * sizeof ( double ) ) ; MPI_Barrier ( MPI_COMM_WORLD ) ; elapsed_time = - MPI_Wtime ( ) ; # pragma omp parallel { nthreads = omp_get_num_threads ( ) ; initialize ( Temperature , Temperature_last , sRow , eRow , myWorldRank , worldSize - 1 ) ; } MPI_Barrier ( MPI_COMM_WORLD ) ; do { ++ iteration ; dt = 0.0 ; # pragma omp parallel reduction ( max : dt ) <S2SV_StartBug> dt = laplace ( Temperature , Temperature_last , nRows - 2 ) ; <S2SV_EndBug> if ( myWorldRank < worldSize - 1 ) { MPI_Irecv ( & Temperature [ ( nRows - 1 ) * COL2 ] , COL2 , MPI_DOUBLE , myWorldRank + 1 , 200 , MPI_COMM_WORLD , & request [ 0 ] ) ; MPI_Isend ( & Temperature [ ( nRows - 2 ) * COL2 ] , COL2 , MPI_DOUBLE , myWorldRank + 1 , 100 , MPI_COMM_WORLD , & request [ 1 ] ) ; MPI_Waitall ( 2 , request , status ) ; } if ( myWorldRank > 0 ) { MPI_Irecv ( & Temperature [ 0 ] , COL2 , MPI_DOUBLE , myWorldRank - 1 , 100 , MPI_COMM_WORLD , & request [ 0 ] ) ; MPI_Isend ( & Temperature [ COL2 ] , COL2 , MPI_DOUBLE , myWorldRank - 1 , 200 , MPI_COMM_WORLD , & request [ 1 ] ) ; MPI_Waitall ( 2 , request , status ) ; } temp = Temperature_last ; Temperature_last = Temperature ; Temperature = temp ; if ( ( iteration % 100 ) == 0 && myWorldRank == worldSize - 1 ) { track_progress ( iteration , Temperature_last , sRow , eRow ) ; printf ( "Max<S2SV_blank>error<S2SV_blank>at<S2SV_blank>iteration<S2SV_blank>%d<S2SV_blank>is<S2SV_blank>%f\\n" , iteration , dt ) ; } } while ( dt > MAX_TEMP_ERROR && iteration < max_iterations ) ; MPI_Barrier ( MPI_COMM_WORLD ) ; elapsed_time += MPI_Wtime ( ) ; if ( myWorldRank == root ) { printf ( "\\nMax<S2SV_blank>error<S2SV_blank>at<S2SV_blank>iteration<S2SV_blank>%d<S2SV_blank>was<S2SV_blank>%f\\n" , iteration , dt ) ; printf ( "Total<S2SV_blank>time<S2SV_blank>for<S2SV_blank>%d<S2SV_blank>nodes,<S2SV_blank>%d<S2SV_blank>MPI<S2SV_blank>processors<S2SV_blank>and<S2SV_blank>%d<S2SV_blank>openMP<S2SV_blank>threads<S2SV_blank>was<S2SV_blank>%f<S2SV_blank>seconds.\\n" , nNodes , worldSize , nthreads , elapsed_time ) ; } free ( Temperature ) ; free ( Temperature_last ) ; MPI_Finalize ( ) ; return 0 ; } | <S2SV_ModStart> nRows - 2 ) ; MPI_Allreduce ( MPI_IN_PLACE , & dt , 1 , MPI_DOUBLE , MPI_MAX , MPI_COMM_WORLD |
1,757 | CWE-000 GString * sql_construct_select ( sql_select_t * select , int explain ) { int i = 0 ; GString * s = g_string_new ( NULL ) ; if ( explain ) { g_string_append ( s , "EXPLAIN<S2SV_blank>" ) ; } g_string_append ( s , "SELECT<S2SV_blank>" ) ; if ( select -> columns ) { if ( select -> flags & SF_DISTINCT ) { g_string_append ( s , "DISTINCT<S2SV_blank>" ) ; } for ( i = 0 ; i < select -> columns -> len ; ++ i ) { sql_expr_t * expr = g_ptr_array_index ( select -> columns , i ) ; append_sql_expr ( s , expr ) ; if ( expr -> alias ) { g_string_append ( s , "<S2SV_blank>AS<S2SV_blank>" ) ; g_string_append ( s , expr -> alias ) ; } if ( i != select -> columns -> len - 1 ) g_string_append ( s , "," ) ; } } if ( select -> from_src ) { g_string_append ( s , "<S2SV_blank>FROM<S2SV_blank>" ) ; for ( i = 0 ; i < select -> from_src -> len ; ++ i ) { sql_src_item_t * src = g_ptr_array_index ( select -> from_src , i ) ; if ( src -> table_name ) { if ( src -> dbname ) { g_string_append ( s , src -> dbname ) ; g_string_append ( s , "." ) ; } g_string_append ( s , src -> table_name ) ; g_string_append ( s , "<S2SV_blank>" ) ; } else if ( src -> select ) { GString * sub = sql_construct_select ( src -> select , 0 ) ; g_string_append_c ( s , '(' ) ; g_string_append_len ( s , sub -> str , sub -> len ) ; g_string_append_c ( s , ')' ) ; g_string_free ( sub , TRUE ) ; } if ( src -> table_alias ) { g_string_append ( s , "<S2SV_blank>AS<S2SV_blank>" ) ; g_string_append ( s , src -> table_alias ) ; g_string_append ( s , "<S2SV_blank>" ) ; } if ( src -> index_hint ) { switch ( src -> index_hint -> type ) { case IH_USE_INDEX : { g_string_append ( s , "<S2SV_blank>USE<S2SV_blank>INDEX<S2SV_blank>(<S2SV_blank>" ) ; break ; } case IH_USE_KEY : { g_string_append ( s , "<S2SV_blank>USE<S2SV_blank>KEY<S2SV_blank>(<S2SV_blank>" ) ; break ; } case IH_IGNORE_INDEX : { g_string_append ( s , "<S2SV_blank>IGNORE<S2SV_blank>INDEX<S2SV_blank>(<S2SV_blank>" ) ; break ; } case IH_IGNORE_KEY : { g_string_append ( s , "<S2SV_blank>IGNORE<S2SV_blank>KEY<S2SV_blank>(<S2SV_blank>" ) ; break ; } case IH_FORCE_INDEX : { g_string_append ( s , "<S2SV_blank>FORCE<S2SV_blank>INDEX<S2SV_blank>(<S2SV_blank>" ) ; break ; } case IH_FORCE_KEY : { g_string_append ( s , "<S2SV_blank>FORCE<S2SV_blank>KEY<S2SV_blank>(<S2SV_blank>" ) ; break ; } } gint len = src -> index_hint -> names -> len ; gint i = 0 ; for ( i = 0 ; i < len ; i ++ ) { g_string_append ( s , g_ptr_array_index ( src -> index_hint -> names , i ) ) ; <S2SV_StartBug> if ( i != len - 1 ) { <S2SV_EndBug> g_string_append ( s , "<S2SV_blank>,<S2SV_blank>" ) ; } } g_string_append ( s , "<S2SV_blank>)<S2SV_blank>" ) ; } if ( src -> on_clause ) { g_string_append ( s , "<S2SV_blank>ON<S2SV_blank>" ) ; append_sql_expr ( s , src -> on_clause ) ; g_string_append_c ( s , '<S2SV_blank>' ) ; } if ( src -> jointype != 0 ) { sql_construct_join ( s , src -> jointype ) ; } } } if ( select -> where_clause ) { g_string_append ( s , "<S2SV_blank>WHERE<S2SV_blank>" ) ; append_sql_expr ( s , select -> where_clause ) ; } if ( select -> groupby_clause ) { sql_expr_list_t * groupby = select -> groupby_clause ; g_string_append ( s , "<S2SV_blank>GROUP<S2SV_blank>BY<S2SV_blank>" ) ; for ( i = 0 ; i < groupby -> len ; ++ i ) { sql_expr_t * expr = g_ptr_array_index ( groupby , i ) ; append_sql_expr ( s , expr ) ; if ( i < groupby -> len - 1 ) { g_string_append ( s , "," ) ; } } } if ( select -> having_clause ) { g_string_append ( s , "<S2SV_blank>HAVING<S2SV_blank>" ) ; append_sql_expr ( s , select -> having_clause ) ; } if ( select -> orderby_clause ) { sql_expr_list_t * orderby = select -> orderby_clause ; g_string_append ( s , "<S2SV_blank>ORDER<S2SV_blank>BY<S2SV_blank>" ) ; for ( i = 0 ; i < orderby -> len ; ++ i ) { sql_column_t * col = g_ptr_array_index ( orderby , i ) ; sql_expr_t * expr = col -> expr ; sql_expr_traverse ( s , expr ) ; if ( col -> sort_order && col -> sort_order == SQL_SO_DESC ) { g_string_append ( s , "<S2SV_blank>DESC<S2SV_blank>" ) ; } if ( i < orderby -> len - 1 ) { g_string_append ( s , "," ) ; } } } if ( select -> limit ) { g_string_append ( s , "<S2SV_blank>LIMIT<S2SV_blank>" ) ; sql_expr_traverse ( s , select -> limit ) ; } if ( select -> offset ) { g_string_append ( s , "<S2SV_blank>OFFSET<S2SV_blank>" ) ; sql_expr_traverse ( s , select -> offset ) ; } if ( select -> lock_read ) { g_string_append ( s , "<S2SV_blank>FOR<S2SV_blank>UPDATE" ) ; } return s ; } | <S2SV_ModStart> ( i != ( <S2SV_ModStart> len - 1 ) |
1,758 | CWE-000 void app_init ( ) { tcpecho_server_init ( ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ( ) ; http_server_init ( ) ; tftp_server_init ( ) ; |
1,759 | CWE-000 static void Init_System_Object ( REBARR * boot_sysobj_spec , REBARR * datatypes_catalog , REBARR * natives_catalog , REBARR * actions_catalog , REBCTX * errors_catalog ) { RELVAL * spec_head = ARR_HEAD ( boot_sysobj_spec ) ; REBCTX * system = Make_Selfish_Context_Detect ( REB_OBJECT , NULL , spec_head , NULL ) ; Bind_Values_Deep ( spec_head , Lib_Context ) ; Bind_Values_Shallow ( spec_head , system ) ; DECLARE_LOCAL ( result ) ; if ( Do_At_Throws ( result , boot_sysobj_spec , 0 , SPECIFIED ) ) panic ( result ) ; if ( ! IS_VOID ( result ) ) panic ( result ) ; Init_Object ( Append_Context ( Lib_Context , NULL , Canon ( SYM_SYSTEM ) ) , system ) ; Init_Object ( ROOT_SYSTEM , system ) ; assert ( 0 == CT_Context ( Get_System ( SYS_STANDARD , STD_FUNCTION_META ) , ROOT_FUNCTION_META , TRUE ) ) ; Init_Block ( Get_System ( SYS_CATALOG , CAT_DATATYPES ) , datatypes_catalog ) ; Init_Block ( Get_System ( SYS_CATALOG , CAT_NATIVES ) , natives_catalog ) ; Init_Block ( Get_System ( SYS_CATALOG , CAT_ACTIONS ) , actions_catalog ) ; Init_Object ( Get_System ( SYS_CATALOG , CAT_ERRORS ) , errors_catalog ) ; { <S2SV_StartBug> REBCTX * codecs = Alloc_Context ( 10 ) ; <S2SV_EndBug> SET_BLANK ( CTX_ROOTKEY ( codecs ) ) ; VAL_RESET_HEADER ( CTX_VALUE ( codecs ) , REB_OBJECT ) ; CTX_VALUE ( codecs ) -> extra . binding = NULL ; <S2SV_StartBug> Init_Object ( Get_System ( SYS_CODECS , 0 ) , codecs ) ; <S2SV_EndBug> } } | <S2SV_ModStart> = Alloc_Context ( REB_OBJECT , 10 <S2SV_ModEnd> ) ; VAL_RESET_HEADER <S2SV_ModStart> = NULL ; CTX_VALUE ( codecs ) -> payload . any_context . phase = NULL ; |
1,760 | CWE-000 void sha256_final8x ( sha256ctx * ctx , unsigned char * out0 , unsigned char * out1 , unsigned char * out2 , unsigned char * out3 , unsigned char * out4 , unsigned char * out5 , unsigned char * out6 , unsigned char * out7 ) { unsigned int i , curlen ; if ( ctx -> datalen < 56 ) { for ( i = 0 ; i < 8 ; ++ i ) { curlen = ctx -> datalen ; ctx -> msgblocks [ 64 * i + curlen ++ ] = 0x80 ; while ( curlen < 64 ) { ctx -> msgblocks [ 64 * i + curlen ++ ] = 0x00 ; } } } else { for ( i = 0 ; i < 8 ; ++ i ) { curlen = ctx -> datalen ; ctx -> msgblocks [ 64 * i + curlen ++ ] = 0x80 ; while ( curlen < 64 ) { ctx -> msgblocks [ 64 * i + curlen ++ ] = 0x00 ; } } sha256_transform8x ( ctx , ctx -> msgblocks ) ; <S2SV_StartBug> memset ( ctx -> msgblocks , 0 , 8 * 56 ) ; <S2SV_EndBug> } ctx -> msglen += ctx -> datalen * 8 ; for ( i = 0 ; i < 8 ; i ++ ) { ctx -> msgblocks [ 64 * i + 63 ] = ctx -> msglen ; ctx -> msgblocks [ 64 * i + 62 ] = ctx -> msglen >> 8 ; ctx -> msgblocks [ 64 * i + 61 ] = ctx -> msglen >> 16 ; ctx -> msgblocks [ 64 * i + 60 ] = ctx -> msglen >> 24 ; ctx -> msgblocks [ 64 * i + 59 ] = ctx -> msglen >> 32 ; ctx -> msgblocks [ 64 * i + 58 ] = ctx -> msglen >> 40 ; ctx -> msgblocks [ 64 * i + 57 ] = ctx -> msglen >> 48 ; ctx -> msgblocks [ 64 * i + 56 ] = ctx -> msglen >> 56 ; } sha256_transform8x ( ctx , ctx -> msgblocks ) ; transpose ( ctx -> s ) ; STORE ( out0 , BYTESWAP ( ctx -> s [ 0 ] ) ) ; STORE ( out1 , BYTESWAP ( ctx -> s [ 1 ] ) ) ; STORE ( out2 , BYTESWAP ( ctx -> s [ 2 ] ) ) ; STORE ( out3 , BYTESWAP ( ctx -> s [ 3 ] ) ) ; STORE ( out4 , BYTESWAP ( ctx -> s [ 4 ] ) ) ; STORE ( out5 , BYTESWAP ( ctx -> s [ 5 ] ) ) ; STORE ( out6 , BYTESWAP ( ctx -> s [ 6 ] ) ) ; STORE ( out7 , BYTESWAP ( ctx -> s [ 7 ] ) ) ; } | <S2SV_ModStart> , 8 * 64 <S2SV_ModEnd> ) ; } |
1,761 | CWE-000 <S2SV_StartBug> void row_init ( int i ) <S2SV_EndBug> { m [ 0 ] [ i ] . cost = i ; if ( i > 0 ) m [ 0 ] [ i ] . parent = INSERT ; else m [ 0 ] [ i ] . parent = - 1 ; } | <S2SV_ModStart> ( int i , cell m [ MAXLEN + 1 ] [ MAXLEN + 1 ] |
1,762 | CWE-000 void eeprom_log ( char * message ) { <S2SV_StartBug> eeprom_update_block ( message , & current_address , strlen ( message ) ) ; <S2SV_EndBug> current_address += strlen ( message ) ; eeprom_update_word ( 0 , current_address ) ; } | <S2SV_ModStart> ( message , ( void * ) ( uint16_t ) <S2SV_ModEnd> current_address , strlen |
1,763 | CWE-000 static void * conn_thread_proc ( void * args ) { int term = R_NO_ERR ; DevConn * pdc = ( DevConn * ) args ; if ( ! pdc ) { return NULL ; } LOG ( & pdc -> ctx , "New<S2SV_blank>connection" ) ; pdc -> state = CONS_WAIT_HS ; pdc -> est_ts = sys_ts ( ) ; pdc -> last_ka_ts = pdc -> est_ts ; while ( ! sys_term && term == R_NO_ERR && ! pdc -> term ) { pdc -> rx_len = tlwsvr_socket_read ( pdc , pdc -> sock_fd , pdc -> rx , sizeof ( pdc -> rx ) ) ; if ( pdc -> rx_len < 0 ) { <S2SV_StartBug> term = R_SOCK_READ_FAIL ; <S2SV_EndBug> } else if ( pdc -> rx_len > 0 ) { term = Rx_Parse ( & pdc -> rxtx , pdc -> rx , pdc -> rx_len , pdc ) ; } if ( term != R_NO_ERR ) { break ; } u32 ts = sys_ts ( ) ; switch ( pdc -> state ) { case CONS_INIT : break ; case CONS_WAIT_HS : if ( ts_diff ( pdc -> est_ts , ts ) > T2_DURATION_MS ) { <S2SV_StartBug> term = R_NO_HS_REQ ; <S2SV_EndBug> } break ; case CONS_IDLE : if ( ts_diff ( pdc -> last_msg_ts , ts ) > T5_KEEP_ALIVE_DURATION ) { <S2SV_StartBug> term = R_PEER_NOT_ALIVE ; <S2SV_EndBug> } else if ( ts_diff ( pdc -> last_ka_ts , ts ) > T5_DURATION_MS ) { term = send_keep_alive ( pdc ) ; } if ( term == R_NO_ERR ) { term = check_ack ( pdc ) ; } break ; case CONS_TERM : break ; default : break ; } } int status = pthread_mutex_lock ( & mutex ) ; if ( status != 0 ) err_abort ( status , "Lock<S2SV_blank>mutex" ) ; list_del ( & pdc -> node ) ; status = pthread_mutex_unlock ( & mutex ) ; if ( status != 0 ) err_abort ( status , "Unlock<S2SV_blank>mutex" ) ; tlwsvr_socket_close ( pdc -> sock_fd ) ; if ( pdc -> dev_id ) free ( pdc -> dev_id ) ; if ( pdc -> ver ) free ( pdc -> ver ) ; while ( ! list_empty ( & pdc -> txq ) ) { TxNode * p = list_first_entry ( & pdc -> txq , TxNode , node ) ; list_del ( & p -> node ) ; free ( p ) ; } free ( pdc ) ; return NULL ; } | <S2SV_ModStart> 0 ) { SET_ERR ( term , R_SOCK_READ_FAIL ) <S2SV_ModEnd> ; } else <S2SV_ModStart> T2_DURATION_MS ) { SET_ERR ( term , R_NO_HS_REQ ) <S2SV_ModEnd> ; } break <S2SV_ModStart> T5_KEEP_ALIVE_DURATION ) { SET_ERR ( term , R_PEER_NOT_ALIVE ) <S2SV_ModEnd> ; } else |
1,764 | CWE-000 static void send_frame ( frame_kind fk , seq_nr frame_nr , seq_nr frame_expected , packet buffer [ ] ) { printf ( "send_frame<S2SV_blank>called<S2SV_blank>\\n" ) ; frame s ; s . kind = fk ; if ( fk == DATA ) { s . info = buffer [ frame_nr % NR_BUFS ] ; } s . seq = frame_nr ; s . ack = ( frame_expected + MAX_SEQ ) % ( MAX_SEQ + 1 ) ; if ( fk == NAK ) { nak_possible = false ; } <S2SV_StartBug> to_physical_layer ( & s ) ; <S2SV_EndBug> if ( fk == DATA ) { start_timer ( frame_nr , 0 ) ; } stop_ack_timer ( 0 ) ; } | <S2SV_ModStart> ( & s , 0 |
1,765 | CWE-000 void deplacerUnite ( Unite * unite , Monde * monde , int destX , int destY ) { <S2SV_StartBug> if ( unite -> posX != posX || unite -> posY != posY ) <S2SV_EndBug> { if ( ( unite -> posX - destX ) <= - 1 && ( unite -> posX - destX ) >= 1 && ( unite -> posY - destY ) <= - 1 && ( unite -> posY - destY ) >= 1 ) { unite -> posX = destX ; unite -> posY = destY ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } } } | <S2SV_ModStart> -> posX != destX <S2SV_ModEnd> || unite -> <S2SV_ModStart> -> posY != destY <S2SV_ModEnd> ) { if <S2SV_ModStart> = destY ; <S2SV_ModEnd> } } } |
1,766 | CWE-000 static void _init_scene ( Gst3DScene * scene ) { GstGLContext * context = scene -> context ; <S2SV_StartBug> Gst3DShader * uv_shader = <S2SV_EndBug> <S2SV_StartBug> gst_3d_shader_new_vert_frag ( context , "mvp_uv.vert" , "debug_uv.frag" ) ; <S2SV_EndBug> Gst3DNode * axes_node = gst_3d_node_new_debug_axes ( context ) ; gst_3d_scene_append_node ( scene , axes_node ) ; Gst3DMesh * sphere_mesh = gst_3d_mesh_new_sphere ( context , 0.5 , 100 , 100 ) ; Gst3DNode * sphere_node = gst_3d_node_new_from_mesh_shader ( context , sphere_mesh , uv_shader ) ; gst_3d_scene_append_node ( scene , sphere_node ) ; } | <S2SV_ModStart> -> context ; Gst3DNode * axes_node ; GError * error = NULL ; <S2SV_ModStart> "mvp_uv.vert" , "debug_uv.frag" , & error ) ; if ( uv_shader == NULL ) { GST_WARNING ( "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>VR<S2SV_blank>shaders.<S2SV_blank>Error:<S2SV_blank>%s" , error -> message ) ; g_clear_error ( & error ) ; return ; } <S2SV_ModEnd> axes_node = gst_3d_node_new_debug_axes |
1,767 | CWE-000 static void test_wolfSSL_RAND ( void ) { # if defined ( OPENSSL_EXTRA ) byte seed [ 16 ] ; printf ( testingFmt , "wolfSSL_RAND()" ) ; RAND_seed ( seed , sizeof ( seed ) ) ; RAND_cleanup ( ) ; AssertIntEQ ( RAND_egd ( NULL ) , - 1 ) ; # ifndef NO_FILESYSTEM { char fname [ 100 ] ; <S2SV_StartBug> AssertNotNull ( RAND_file_name ( fname , sizeof ( fname ) ) ) ; <S2SV_EndBug> AssertIntEQ ( RAND_write_file ( NULL ) , 0 ) ; } # endif printf ( resultFmt , passed ) ; # endif } | <S2SV_ModStart> ( fname , ( <S2SV_ModStart> sizeof ( fname ) - 1 |
1,768 | CWE-000 int rxm_info_to_rxm ( uint32_t version , struct fi_info * core_info , struct fi_info * info ) { info -> caps = rxm_info . caps ; info -> mode = core_info -> mode | rxm_info . mode ; * info -> tx_attr = * rxm_info . tx_attr ; <S2SV_StartBug> info -> tx_attr -> size = core_info -> tx_attr -> size ; <S2SV_EndBug> info -> tx_attr -> iov_limit = MIN ( MIN ( info -> tx_attr -> iov_limit , core_info -> tx_attr -> iov_limit ) , core_info -> tx_attr -> rma_iov_limit ) ; * info -> rx_attr = * rxm_info . rx_attr ; info -> rx_attr -> iov_limit = MIN ( info -> rx_attr -> iov_limit , <S2SV_StartBug> core_info -> rx_attr -> iov_limit ) ; <S2SV_EndBug> * info -> ep_attr = * rxm_info . ep_attr ; info -> ep_attr -> max_msg_size = core_info -> ep_attr -> max_msg_size ; * info -> domain_attr = * rxm_info . domain_attr ; info -> domain_attr -> mr_mode = core_info -> domain_attr -> mr_mode ; info -> domain_attr -> cq_data_size = MIN ( core_info -> domain_attr -> cq_data_size , rxm_info . domain_attr -> cq_data_size ) ; return 0 ; } | <S2SV_ModStart> -> tx_attr -> msg_order = core_info -> tx_attr -> msg_order ; info -> tx_attr -> comp_order = core_info -> tx_attr -> comp_order ; info -> tx_attr -> <S2SV_ModStart> -> iov_limit ) ; info -> rx_attr -> msg_order |= FI_ORDER_SAS |
1,769 | CWE-000 int main ( void ) { char commandline [ COMMANDLINE_BUFSIZE ] ; char * args [ MAX_TOKENS ] ; int args_count ; while ( 1 ) { printf ( "%s" , PROMPT ) ; fflush ( stdout ) ; fgets ( commandline , sizeof commandline , stdin ) ; if ( feof ( stdin ) ) { break ; } parse_commandline ( commandline , args , & args_count ) ; if ( args_count == 0 ) { continue ; } if ( strcmp ( args [ 0 ] , "exit" ) == 0 ) { break ; } # if DEBUG for ( int i = 0 ; args [ i ] != NULL ; i ++ ) { printf ( "%d:<S2SV_blank>\'%s\'\\n" , i , args [ i ] ) ; } # endif <S2SV_StartBug> int rc = fork ( ) ; <S2SV_EndBug> if ( rc < 0 ) { fprintf ( stderr , "fork<S2SV_blank>failed\\n" ) ; } else if ( rc == 0 ) { <S2SV_StartBug> execvp ( args [ 0 ] , args [ 1 ] ) ; <S2SV_EndBug> } return 0 ; } } | <S2SV_ModStart> } # endif pid_t paid ; <S2SV_ModStart> 0 ) { printf ( "I<S2SV_blank>am<S2SV_blank>here" ) ; <S2SV_ModStart> ] , args ) ; continue ; } else { do { paid = wait ( & rc ) ; if ( paid != rc ) exit ( 1 ) ; } while ( paid != rc ) ; return rc ; } return <S2SV_ModEnd> 0 ; } |
1,770 | CWE-000 static int ia_log_params ( struct ThreadContext * t_ctx , const JSON_Object * action_params ) { const struct FuncParam * param ; const struct FuncParam * arr_cnt_param ; const struct DataType * ref_data_type ; int ret ; size_t i ; int param_idx ; int cnt_param_idx ; char * serialized_string ; JSON_Value * root_value ; JSON_Object * root_object ; JSON_Value * arr_val ; JSON_Array * omit_params ; size_t sz_size ; size_t arr_size ; size_t ref_data_size ; const void * ref_data ; char * sz ; char deref_sz [ MAXLEN_PARAM_NAME + 2 ] ; root_value = json_value_init_object ( ) ; root_object = json_value_get_object ( root_value ) ; omit_params = NULL ; if ( action_params != NULL ) omit_params = json_object_get_array ( action_params , "omit_params" ) ; for ( param_idx = 0 ; param_idx != t_ctx -> params_cnt ; param_idx ++ ) { param = & t_ctx -> params [ param_idx ] ; if ( omit_params != NULL ) { for ( i = 0 ; i < json_array_get_count ( omit_params ) ; i ++ ) { if ( ! retrace_real_impls . strcmp ( param -> param_meta . name , json_array_get_string ( omit_params , i ) ) ) { log_info ( "omitting<S2SV_blank>param<S2SV_blank>\'%s\'" , param -> param_meta . name ) ; goto next_param ; } } } sz_size = param -> data_type -> get_sz_size ( ( const void * ) & param -> val , param -> data_type ) ; sz = ( char * ) retrace_real_impls . malloc ( sz_size + 1 ) ; param -> data_type -> to_sz ( ( const void * ) & param -> val , param -> data_type , sz ) ; json_object_set_string ( root_object , param -> param_meta . name , sz ) ; retrace_real_impls . free ( sz ) ; if ( param -> param_meta . modifiers & CDM_POINTER ) { ref_data = ( void * ) param -> val ; ref_data_type = retrace_datatype_get ( param -> param_meta . ref_type_name ) ; if ( ref_data_type == NULL ) { log_err ( "get_param_type()<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>%s" , param -> param_meta . ref_type_name ) ; break ; } if ( param -> param_meta . modifiers & CDM_ARRAY ) { for ( cnt_param_idx = 0 ; cnt_param_idx != t_ctx -> params_cnt ; cnt_param_idx ++ ) { if ( ! retrace_real_impls . strcmp ( t_ctx -> params [ cnt_param_idx ] . param_meta . name , param -> param_meta . array_cnt_param ) ) break ; } if ( cnt_param_idx == t_ctx -> params_cnt ) { log_err ( "wrong<S2SV_blank>array_cnt_param<S2SV_blank>for<S2SV_blank>param<S2SV_blank>\'%s\'" , param -> param_meta . name ) ; break ; } arr_cnt_param = & t_ctx -> params [ cnt_param_idx ] ; ret = arr_cnt_param -> data_type -> to_size_t ( ( const void * ) & arr_cnt_param -> val , & arr_size ) ; if ( ret ) { log_err ( "to_size_t()<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>%s,<S2SV_blank>error<S2SV_blank>%d" , arr_cnt_param -> param_meta . name , ret ) ; break ; } } else arr_size = 1 ; if ( arr_size > ARR_MAX_COUNT ) arr_size = ARR_MAX_COUNT ; arr_val = json_value_init_array ( ) ; while ( arr_size ) { sz_size = ref_data_type -> get_sz_size ( ref_data , ref_data_type ) ; sz = ( char * ) retrace_real_impls . malloc ( sz_size + 1 ) ; ref_data_type -> to_sz ( ref_data , ref_data_type , sz ) ; json_array_append_string ( json_array ( arr_val ) , sz ) ; retrace_real_impls . free ( sz ) ; ret = ref_data_type -> get_size ( ref_data , ref_data_type , & ref_data_size ) ; if ( ret ) { log_err ( "get_size()<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>type<S2SV_blank>%s,<S2SV_blank>error<S2SV_blank>%d" , ref_data_type -> name , ret ) ; break ; } ref_data += ref_data_size ; arr_size -- ; } retrace_real_impls . snprintf ( deref_sz , sizeof ( deref_sz ) , "*%s" , param -> param_meta . name ) ; json_object_set_value ( root_object , deref_sz , arr_val ) ; } next_param : ; } <S2SV_StartBug> retrace_logger_log_json ( ACTIONS , INFO , root_value ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> ( ACTIONS , SEVERITY_INFO <S2SV_ModEnd> , root_value ) |
1,771 | CWE-000 void draw_rect ( GtkWidget * widget , GdkRectangle * p_area_rect , cairo_surface_t * surface ) { clear_surface ( widget , surface ) ; gtk_widget_queue_draw ( widget ) ; GdkRectangle * p_surface_rect = P ( "p_surface_rect" ) ; int mon_width = p_surface_rect -> width , mon_height = p_surface_rect -> height ; if ( p_area_rect -> x + p_area_rect -> width > mon_width ) { if ( p_area_rect -> width >= mon_width ) { p_area_rect -> x = 0 ; p_area_rect -> width = mon_width ; } else p_area_rect -> x = mon_width - p_area_rect -> width ; } if ( p_area_rect -> y + p_area_rect -> height > mon_height ) { if ( p_area_rect -> height >= mon_height ) { p_area_rect -> y = 0 ; p_area_rect -> height = mon_height ; } else p_area_rect -> y = mon_height - p_area_rect -> height ; } if ( p_area_rect -> x < 0 ) p_area_rect -> x = 0 ; if ( p_area_rect -> width >= mon_width ) p_area_rect -> width = mon_width ; if ( p_area_rect -> y < 0 ) p_area_rect -> y = 0 ; if ( p_area_rect -> height >= mon_height ) p_area_rect -> height = mon_height ; double rleft = ( double ) p_area_rect -> x ; double rupper = ( double ) p_area_rect -> y ; double rwidth = ( double ) p_area_rect -> width ; double rheight = ( double ) p_area_rect -> height ; cairo_t * cr ; char char_rleft [ 5 ] , char_rupper [ 5 ] , char_rwidth [ 5 ] , char_rheight [ 5 ] , text [ 512 ] ; cr = cairo_create ( surface ) ; cairo_set_operator ( cr , CAIRO_OPERATOR_SOURCE ) ; cairo_set_source_rgb ( cr , 0 , 1 , 0 ) ; cairo_rectangle ( cr , rleft - 2 , rupper - 2 , rwidth + 4 , rheight + 4 ) ; cairo_stroke ( cr ) ; snprintf ( char_rleft , 5 , "%d" , ( int ) rleft ) ; snprintf ( char_rupper , 5 , "%d" , ( int ) rupper ) ; snprintf ( char_rwidth , 5 , "%d" , ( int ) rwidth ) ; snprintf ( char_rheight , 5 , "%d" , ( int ) rheight ) ; strcpy ( text , char_rleft ) ; strcat ( text , "," ) ; strcat ( text , char_rupper ) ; strcat ( text , "<S2SV_blank>" ) ; <S2SV_StartBug> strcat ( text , char_rwidth ) ; strcat ( text , "x" ) ; strcat ( text , char_rheight ) ; strcat ( text , "\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>F1<S2SV_blank>About<S2SV_blank>Mouse<S2SV_blank>Controls|Configuration|Preferences\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>F2<S2SV_blank>Set<S2SV_blank>recording<S2SV_blank>area<S2SV_blank>with<S2SV_blank>number<S2SV_blank>keys<S2SV_blank>&<S2SV_blank>resize<S2SV_blank>active<S2SV_blank>window<S2SV_blank>checkbox\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>F3<S2SV_blank>View<S2SV_blank>the<S2SV_blank>ffmpeg<S2SV_blank>command<S2SV_blank>that<S2SV_blank>will<S2SV_blank>record<S2SV_blank>the<S2SV_blank>rectangle<S2SV_blank>area\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank>ESC<S2SV_blank>Quit,<S2SV_blank>q<S2SV_blank>Quit,<S2SV_blank>F11<S2SV_blank>Toggle<S2SV_blank>Fullscreen,<S2SV_blank>F4<S2SV_blank>Begin<S2SV_blank>Recording" ) ; <S2SV_EndBug> draw_text ( cr , rleft , rupper + rheight + 10 , widget , text ) ; cairo_destroy ( cr ) ; gtk_widget_queue_draw_area ( widget , rleft - 2 , rupper - 2 , rwidth + 4 , rheight + 4 ) ; cr = cairo_create ( surface ) ; cairo_set_operator ( cr , CAIRO_OPERATOR_CLEAR ) ; cairo_rectangle ( cr , rleft , rupper , rwidth , rheight ) ; cairo_fill ( cr ) ; cairo_destroy ( cr ) ; gtk_widget_queue_draw_area ( widget , rleft , rupper , rwidth , rheight ) ; if ( * ( ( gboolean * ) P ( "p_should_resize_active" ) ) ) { int ax = p_area_rect -> x + p_surface_rect -> x , ay = p_area_rect -> y + p_surface_rect -> y , aw = p_area_rect -> width , ah = p_area_rect -> height ; if ( * ( ( gboolean * ) P ( "p_include_extents" ) ) ) { int * p_dx = P ( "p_dx" ) , * p_dy = P ( "p_dy" ) , * p_dw = P ( "p_dw" ) , * p_dh = P ( "p_dh" ) ; int dx = * p_dx , dy = * p_dy , dw = * p_dw , dh = * p_dh ; ax = ax - dx ; ay = ay - dy ; aw = aw - dw ; ah = ah - dh ; } gdk_window_move_resize ( P ( "active_window" ) , ax , ay , aw , ah ) ; } } | <S2SV_ModStart> ( text , "\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank>F1<S2SV_blank>About<S2SV_blank>Mouse<S2SV_blank>Controls|Configuration|Preferences\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank>F2<S2SV_blank>Set<S2SV_blank>recording<S2SV_blank>area<S2SV_blank>with<S2SV_blank>number<S2SV_blank>keys<S2SV_blank>&<S2SV_blank>resize<S2SV_blank>active<S2SV_blank>window<S2SV_blank>checkbox\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank>F3<S2SV_blank>View<S2SV_blank>the<S2SV_blank>ffmpeg<S2SV_blank>command<S2SV_blank>that<S2SV_blank>will<S2SV_blank>record<S2SV_blank>the<S2SV_blank>rectangle<S2SV_blank>area\\n\\\n<S2SV_blank><S2SV_blank>ESC<S2SV_blank>Quit,<S2SV_blank>q<S2SV_blank>Quit,<S2SV_blank>F11<S2SV_blank>Toggle<S2SV_blank>Fullscreen,<S2SV_blank>RETURN<S2SV_blank>Begin<S2SV_blank>Recording" <S2SV_ModEnd> ) ; draw_text |
1,772 | CWE-000 int analogRead ( uint8_t pin ) { <S2SV_StartBug> # if defined ( NUM_DIGITAL_PINS ) && ! defined ( ANALOG_PINS_SEPARATE ) <S2SV_EndBug> if ( pin >= NUM_DIGITAL_PINS ) pin -= NUM_DIGITAL_PINS ; # endif # ifndef ADCSRA return digitalRead ( analogInputToDigitalPin ( pin ) ) ? 1023 : 0 ; # endif # if defined ( ADMUX ) ADMUX = ( ( analog_reference & ADMUX_REFS_MASK ) << REFS0 ) | ( ( pin & ADMUX_MUX_MASK ) << MUX0 ) ; # if defined ( REFS2 ) ADMUX |= ( ( ( analog_reference & 0x04 ) >> 2 ) << REFS2 ) ; # endif # endif # if defined ( HAVE_ADC ) && HAVE_ADC sbi ( ADCSRA , ADSC ) ; while ( ADCSRA & ( 1 << ADSC ) ) ; uint8_t low = ADCL ; uint8_t high = ADCH ; return ( high << 8 ) | low ; # else return LOW ; # endif } | <S2SV_ModStart> pin ) { pin &= 127 ; <S2SV_ModEnd> # ifndef ADCSRA |
1,773 | CWE-000 void L2state2_L1L2Event2Fun ( void * pFsm ) { FSM_Pop ( ( FSM_t * ) pFsm ) ; <S2SV_StartBug> printf ( "L1L2<S2SV_blank>event2<S2SV_blank>:<S2SV_blank>L2<S2SV_blank>state2<S2SV_blank>-<S2SV_blank>L2<S2SV_blank>state2\\n" ) ; <S2SV_EndBug> return ; } | <S2SV_ModStart> pFsm ) ; FSM_MoveState ( ( FSM_t * ) pFsm , L1_STATE3 ) ; printf ( "L1L2<S2SV_blank>event2<S2SV_blank>:<S2SV_blank>L2<S2SV_blank>state2<S2SV_blank>-<S2SV_blank>L1<S2SV_blank>state3\\n" <S2SV_ModEnd> ) ; return |
1,774 | CWE-000 static int uvc_video_alloc_requests ( struct uvc_video * video ) { unsigned int req_size ; unsigned int i ; int ret = - ENOMEM ; <S2SV_StartBug> BUG_ON ( video -> req_size ) ; <S2SV_EndBug> req_size = video -> ep -> maxpacket * max_t ( unsigned int , video -> ep -> maxburst , 1 ) * ( video -> ep -> mult + 1 ) ; for ( i = 0 ; i < UVC_NUM_REQUESTS ; ++ i ) { video -> req_buffer [ i ] = kmalloc ( req_size , GFP_KERNEL ) ; if ( video -> req_buffer [ i ] == NULL ) goto error ; video -> req [ i ] = usb_ep_alloc_request ( video -> ep , GFP_KERNEL ) ; if ( video -> req [ i ] == NULL ) goto error ; video -> req [ i ] -> buf = video -> req_buffer [ i ] ; video -> req [ i ] -> length = 0 ; video -> req [ i ] -> complete = uvc_video_complete ; video -> req [ i ] -> context = video ; list_add_tail ( & video -> req [ i ] -> list , & video -> req_free ) ; } video -> req_size = req_size ; return 0 ; error : uvc_video_free_requests ( video ) ; return ret ; } | <S2SV_ModStart> - ENOMEM ; if ( video -> req_size ) { pr_err ( "%s:<S2SV_blank>close<S2SV_blank>the<S2SV_blank>video<S2SV_blank>node<S2SV_blank>and<S2SV_blank>reopen<S2SV_blank>it\\n" , __func__ ) ; return - EBUSY ; } <S2SV_ModEnd> req_size = video |
1,775 | CWE-000 int __ipa3_del_hdr ( u32 hdr_hdl , bool by_user ) { struct ipa3_hdr_entry * entry ; struct ipa3_hdr_tbl * htbl = & ipa3_ctx -> hdr_tbl ; entry = ipa3_id_find ( hdr_hdl ) ; if ( entry == NULL ) { IPAERR ( "lookup<S2SV_blank>failed\\n" ) ; return - EINVAL ; } if ( entry -> cookie != IPA_COOKIE ) { IPAERR ( "bad<S2SV_blank>parm\\n" ) ; return - EINVAL ; } if ( entry -> is_hdr_proc_ctx ) IPADBG ( "del<S2SV_blank>hdr<S2SV_blank>of<S2SV_blank>sz=%d<S2SV_blank>hdr_cnt=%d<S2SV_blank>phys_base=%pa\\n" , entry -> hdr_len , htbl -> hdr_cnt , & entry -> phys_base ) ; else IPADBG ( "del<S2SV_blank>hdr<S2SV_blank>of<S2SV_blank>sz=%d<S2SV_blank>hdr_cnt=%d<S2SV_blank>ofst=%d\\n" , entry -> hdr_len , htbl -> hdr_cnt , entry -> offset_entry -> offset ) ; if ( by_user && entry -> user_deleted ) { IPAERR ( "proc_ctx<S2SV_blank>already<S2SV_blank>deleted<S2SV_blank>by<S2SV_blank>user\\n" ) ; return - EINVAL ; } <S2SV_StartBug> if ( by_user ) <S2SV_EndBug> entry -> user_deleted = true ; <S2SV_StartBug> if ( -- entry -> ref_cnt ) { <S2SV_EndBug> IPADBG ( "hdr_hdl<S2SV_blank>%x<S2SV_blank>ref_cnt<S2SV_blank>%d\\n" , hdr_hdl , entry -> ref_cnt ) ; return 0 ; } if ( entry -> is_hdr_proc_ctx ) { dma_unmap_single ( ipa3_ctx -> pdev , entry -> phys_base , entry -> hdr_len , DMA_TO_DEVICE ) ; __ipa3_del_hdr_proc_ctx ( entry -> proc_ctx -> id , false , false ) ; } else { list_move ( & entry -> offset_entry -> link , & htbl -> head_free_offset_list [ entry -> offset_entry -> bin ] ) ; } list_del ( & entry -> link ) ; htbl -> hdr_cnt -- ; entry -> cookie = 0 ; kmem_cache_free ( ipa3_ctx -> hdr_cache , entry ) ; ipa3_id_remove ( hdr_hdl ) ; return 0 ; } | <S2SV_ModStart> ( by_user ) { if ( ! strcmp ( entry -> name , IPA_LAN_RX_HDR_NAME ) ) { IPADBG ( "Trying<S2SV_blank>to<S2SV_blank>delete<S2SV_blank>hdr<S2SV_blank>%s<S2SV_blank>offset=%u\\n" , entry -> name , entry -> offset_entry -> offset ) ; if ( ! entry -> offset_entry -> offset ) { IPAERR ( "User<S2SV_blank>cannot<S2SV_blank>delete<S2SV_blank>default<S2SV_blank>header\\n" ) ; return - EPERM ; } } <S2SV_ModStart> = true ; } |
1,776 | CWE-000 VOID UnprotectUefiImage ( IN EFI_LOADED_IMAGE_PROTOCOL * LoadedImage , IN EFI_DEVICE_PATH_PROTOCOL * LoadedImageDevicePath ) { <S2SV_StartBug> if ( PcdGet32 ( PcdImageProtectionPolicy ) != 0 ) { <S2SV_EndBug> <S2SV_StartBug> ProtectUefiImageCommon ( LoadedImage , LoadedImageDevicePath , FALSE ) ; <S2SV_EndBug> } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> LoadedImageDevicePath ) { IMAGE_PROPERTIES_RECORD * ImageRecord ; LIST_ENTRY * ImageRecordLink ; <S2SV_ModStart> 0 ) { for ( ImageRecordLink = mProtectedImageRecordList . ForwardLink ; ImageRecordLink != & mProtectedImageRecordList ; ImageRecordLink = ImageRecordLink -> ForwardLink ) { ImageRecord = CR ( ImageRecordLink , IMAGE_PROPERTIES_RECORD , Link , IMAGE_PROPERTIES_RECORD_SIGNATURE ) ; if ( ImageRecord -> ImageBase == ( EFI_PHYSICAL_ADDRESS ) ( UINTN ) LoadedImage -> ImageBase ) { SetUefiImageMemoryAttributes ( ImageRecord -> ImageBase , ImageRecord -> ImageSize , 0 ) ; FreeImageRecord ( ImageRecord ) ; return <S2SV_ModEnd> ; } } <S2SV_ModStart> ; } } } } |
1,777 | CWE-000 static int handle_ack_frame ( quicly_conn_t * conn , size_t epoch , quicly_ack_frame_t * frame ) { quicly_acks_iter_t iter ; uint64_t packet_number = frame -> smallest_acknowledged ; uint32_t bytes_in_flight = ( uint32_t ) conn -> egress . cc . bytes_in_flight ; struct { uint64_t packet_number ; int64_t sent_at ; } largest_newly_acked = { UINT64_MAX , INT64_MAX } ; int ret ; if ( epoch == 1 ) return QUICLY_ERROR_PROTOCOL_VIOLATION ; conn -> egress . cc . this_ack . nsegs = 0 ; conn -> egress . cc . this_ack . nbytes = 0 ; init_acks_iter ( conn , & iter ) ; size_t gap_index = frame -> num_gaps ; while ( 1 ) { uint64_t block_length = frame -> ack_block_lengths [ gap_index ] ; if ( block_length != 0 ) { while ( quicly_acks_get ( & iter ) -> packet_number < packet_number ) quicly_acks_next ( & iter ) ; do { quicly_ack_t * ack ; if ( ( ack = quicly_acks_get ( & iter ) ) -> packet_number == packet_number ) { ++ conn -> super . num_packets . ack_received ; <S2SV_StartBug> int apply = epoch == 3 || ack_is_handshake_flow ( ack , epoch ) ; <S2SV_EndBug> if ( apply ) { largest_newly_acked . packet_number = packet_number ; largest_newly_acked . sent_at = ack -> sent_at ; } LOG_CONNECTION_EVENT ( conn , QUICLY_EVENT_TYPE_PACKET_ACKED , INT_EVENT_ATTR ( PACKET_NUMBER , packet_number ) , INT_EVENT_ATTR ( NEWLY_ACKED , apply ) ) ; do { if ( apply ) { if ( ( ret = quicly_acks_on_ack ( & conn -> egress . acks , 1 , ack , conn ) ) != 0 ) return ret ; quicly_acks_release ( & conn -> egress . acks , & iter ) ; } quicly_acks_next ( & iter ) ; } while ( ( ack = quicly_acks_get ( & iter ) ) -> packet_number == packet_number ) ; } ++ packet_number ; } while ( -- block_length != 0 ) ; } if ( gap_index -- == 0 ) break ; packet_number += frame -> gaps [ gap_index ] ; } assert ( conn -> egress . cc . bytes_in_flight >= conn -> egress . cc . this_ack . nbytes ) ; conn -> egress . cc . bytes_in_flight -= conn -> egress . cc . this_ack . nbytes ; uint32_t latest_rtt = UINT32_MAX , ack_delay = 0 ; if ( largest_newly_acked . packet_number == frame -> largest_acknowledged ) { int64_t t = now - largest_newly_acked . sent_at ; if ( 0 <= t && t < 100000 ) { latest_rtt = ( uint32_t ) t ; ack_delay = ( uint32_t ) ( ( ( frame -> ack_delay << ( conn -> super . peer . transport_params . ack_delay_exponent + 1 ) ) + 1 ) / 2000 ) ; } } quicly_loss_on_ack_received ( & conn -> egress . loss , frame -> largest_acknowledged , latest_rtt , ack_delay , 0 ) ; uint32_t cc_type = 0 ; if ( quicly_loss_on_packet_acked ( & conn -> egress . loss , frame -> largest_acknowledged ) ) { cc_type = CC_RTO ; conn -> egress . cc . in_first_rto = 0 ; } else if ( conn -> egress . cc . in_first_rto ) { cc_type = CC_RTO_ERR ; conn -> egress . cc . in_first_rto = 0 ; } if ( cc_type != 0 ) cc_cong_signal ( & conn -> egress . cc . ccv , cc_type , bytes_in_flight ) ; int exit_recovery = frame -> largest_acknowledged >= conn -> egress . cc . end_of_recovery ; cc_ack_received ( & conn -> egress . cc . ccv , CC_ACK , bytes_in_flight , ( uint16_t ) conn -> egress . cc . this_ack . nsegs , ( uint32_t ) conn -> egress . cc . this_ack . nbytes , conn -> egress . loss . rtt . smoothed / 10 , exit_recovery ) ; LOG_CONNECTION_EVENT ( conn , QUICLY_EVENT_TYPE_CC_ACK_RECEIVED , INT_EVENT_ATTR ( PACKET_NUMBER , frame -> largest_acknowledged ) , INT_EVENT_ATTR ( ACKED_PACKETS , conn -> egress . cc . this_ack . nsegs ) , INT_EVENT_ATTR ( ACKED_BYTES , conn -> egress . cc . this_ack . nbytes ) , INT_EVENT_ATTR ( CC_TYPE , cc_type ) , INT_EVENT_ATTR ( CC_EXIT_RECOVERY , exit_recovery ) , INT_EVENT_ATTR ( CWND , cc_get_cwnd ( & conn -> egress . cc . ccv ) ) , INT_EVENT_ATTR ( BYTES_IN_FLIGHT , bytes_in_flight ) ) ; if ( exit_recovery ) conn -> egress . cc . end_of_recovery = UINT64_MAX ; quicly_loss_detect_loss ( & conn -> egress . loss , frame -> largest_acknowledged , do_detect_loss ) ; update_loss_alarm ( conn ) ; return 0 ; } | <S2SV_ModStart> = epoch == ack -> ack_epoch <S2SV_ModEnd> ; if ( |
1,778 | CWE-000 void prepare_sprite_map ( size_t size ) { if ( sprite_map == NULL || size + 1 > sprite_map_max_items ) { # ifdef VERBOSE printf ( "%s<S2SV_blank>%p\\n" , "prepare_sprite_map<S2SV_blank>was" , sprite_map ) ; # endif sprite_map_max_items = ( ( ( size + 1 ) >> 8 ) + 1 ) << 8 ; sprite_map = realloc ( sprite_map , sizeof ( * sprite_map ) * sprite_map_max_items ) ; if ( sprite_map == NULL ) { <S2SV_StartBug> shutdown ( 1 , "Out<S2SV_blank>Of<S2SV_blank>Memory!<S2SV_blank><S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>a<S2SV_blank>new<S2SV_blank>sprite_map\\n" ) ; <S2SV_EndBug> } } } | <S2SV_ModStart> NULL ) { borShutdown <S2SV_ModEnd> ( 1 , |
1,779 | CWE-000 size_t ft_strlcat ( char * dst , const char * src , size_t size ) { size_t i ; size_t j ; i = 0 ; j = 0 ; while ( dst [ i ] && i < size ) i ++ ; <S2SV_StartBug> while ( src [ j ] && ( i + j ) < ( size - 1 ) ) <S2SV_EndBug> { dst [ i + j ] = src [ j ] ; j ++ ; } if ( i < size ) dst [ i + j ] = 0 ; return ( i + ft_strlen ( src ) ) ; } | <S2SV_ModStart> i + j + 1 ) < size <S2SV_ModEnd> ) { dst |
1,780 | CWE-000 status parse_exchange_id ( client c , buffer b ) { <S2SV_StartBug> verify_and_adv ( c , b , 0 ) ; <S2SV_EndBug> memcpy ( & c -> clientid , b -> contents + b -> start , sizeof ( c -> clientid ) ) ; b -> start += sizeof ( c -> clientid ) ; c -> server_sequence = read_beu32 ( b ) ; return STATUS_OK ; } | <S2SV_ModStart> b ) { <S2SV_ModEnd> memcpy ( & |
1,781 | CWE-000 cpSymbolTableNode * constructSymbolTable ( cpBaseNode * in_pNode , cpSymbolTableNode * table ) { if ( gSymbolTable == NULL ) { cpSymbolTableNode * node = new cpSymbolTableNode ( ) ; node -> m_pParentScope = NULL ; node -> m_vSymbolTable . push_back ( new cpSymbolAttribute ( "gl_FragColor" , ecpTerminalType_float4 , ecpFunctionQualifier_Result ) ) ; node -> m_vSymbolTable . push_back ( new cpSymbolAttribute ( "gl_FragDepth" , ecpTerminalType_bool1 , ecpFunctionQualifier_Result ) ) ; node -> m_vSymbolTable . push_back ( new cpSymbolAttribute ( "gl_FragCoord" , ecpTerminalType_float4 , ecpFunctionQualifier_Result ) ) ; node -> m_vSymbolTable . push_back ( new cpSymbolAttribute ( "gl_TexCoord" , ecpTerminalType_float4 , ecpFunctionQualifier_Attribute ) ) ; node -> m_vSymbolTable . push_back ( new cpSymbolAttribute ( "gl_Color" , ecpTerminalType_float4 , ecpFunctionQualifier_Attribute ) ) ; node -> m_vSymbolTable . push_back ( new cpSymbolAttribute ( "gl_Secondary" , ecpTerminalType_float4 , ecpFunctionQualifier_Attribute ) ) ; node -> m_vSymbolTable . push_back ( new cpSymbolAttribute ( "gl_FogFragCoord" , ecpTerminalType_float4 , ecpFunctionQualifier_Attribute ) ) ; node -> m_vSymbolTable . push_back ( new cpSymbolAttribute ( "gl_Light_Half" , ecpTerminalType_float4 , ecpFunctionQualifier_Uniform ) ) ; node -> m_vSymbolTable . push_back ( new cpSymbolAttribute ( "gl_Light_Ambient" , ecpTerminalType_float4 , ecpFunctionQualifier_Uniform ) ) ; node -> m_vSymbolTable . push_back ( new cpSymbolAttribute ( "gl_Material_Shininess" , ecpTerminalType_float4 , ecpFunctionQualifier_Uniform ) ) ; node -> m_vSymbolTable . push_back ( new cpSymbolAttribute ( "env1" , ecpTerminalType_float4 , ecpFunctionQualifier_Uniform ) ) ; <S2SV_StartBug> node -> m_vSymbolTable . push_back ( new cpSymbolAttribute ( "env1" , ecpTerminalType_float4 , ecpFunctionQualifier_Uniform ) ) ; <S2SV_EndBug> <S2SV_StartBug> node -> m_vSymbolTable . push_back ( new cpSymbolAttribute ( "env1" , ecpTerminalType_float4 , ecpFunctionQualifier_Uniform ) ) ; <S2SV_EndBug> gSymbolTable = node ; table = node ; } if ( in_pNode == NULL ) { return NULL ; } if ( in_pNode -> getNodeType ( ) == ecpBaseNodeType_Leaf && in_pNode -> getNodeKind ( ) != IDENT_NODE ) { return NULL ; } else { gSymbolLookUpTable [ in_pNode ] = table ; cpSymbolTableNode * ret = NULL ; if ( in_pNode -> getNodeKind ( ) == IDENT_NODE ) { cpSymbolAttribute * attr = lookupSymbolTable ( ( ( cpIdentifierNode * ) in_pNode ) -> m_value , in_pNode ) ; if ( attr == NULL ) { in_pNode -> setTerminalType ( ecpTerminalType_Invalid ) ; <S2SV_StartBug> } <S2SV_EndBug> else { in_pNode -> setTerminalType ( attr -> m_iType ) ; } } else { if ( in_pNode -> getNodeKind ( ) == SCOPE_NODE ) { cpSymbolTableNode * node = new cpSymbolTableNode ( ) ; node -> m_pParentScope = table ; table -> m_pChildScopes . push_back ( node ) ; table = node ; ret = node ; <S2SV_StartBug> } <S2SV_EndBug> if ( in_pNode -> getNodeKind ( ) == DECLARATION_NODE ) { <S2SV_StartBug> if ( lookupSymbolTable ( ( ( cpDeclarationNode * ) in_pNode ) -> m_sIdentifierName , in_pNode ) == NULL ) { <S2SV_EndBug> cpSymbolAttribute * new_attribute = new cpSymbolAttribute ( ) ; initSymbolAttributeFromDeclarationNode ( ( cpDeclarationNode * ) in_pNode , new_attribute ) ; table -> m_vSymbolTable . push_back ( new_attribute ) ; } else { <S2SV_StartBug> in_pNode -> setTerminalType ( ecpTerminalType_Unknown ) ; <S2SV_EndBug> } } int num_of_child_nodes = ( ( cpNormalNode * ) in_pNode ) -> getNumOfChildNodes ( ) ; for ( int i = 0 ; i < num_of_child_nodes ; i ++ ) { constructSymbolTable ( ( ( cpNormalNode * ) in_pNode ) -> getChildNode ( i ) , table ) ; } } return ret ; } } | <S2SV_ModStart> new cpSymbolAttribute ( "env2" <S2SV_ModEnd> , ecpTerminalType_float4 , <S2SV_ModStart> new cpSymbolAttribute ( "env3" <S2SV_ModEnd> , ecpTerminalType_float4 , <S2SV_ModStart> ecpTerminalType_Invalid ) ; std : : string name = ( ( cpIdentifierNode * ) in_pNode ) -> m_value ; <S2SV_ModStart> = node ; printf ( "table<S2SV_blank>address:%x\\n" , table ) ; <S2SV_ModStart> { if ( SearchInScope <S2SV_ModEnd> ( ( ( <S2SV_ModStart> -> m_sIdentifierName , table <S2SV_ModEnd> ) == NULL <S2SV_ModStart> -> setTerminalType ( ecpTerminalType_Invalid <S2SV_ModEnd> ) ; } |
1,782 | CWE-000 static int start_list ( ) { <S2SV_StartBug> if ( nk_thread_start ( list , 0 , 0 , 1 , PAGE_SIZE_4KB , & list_tid , - 1 ) ) { <S2SV_EndBug> ERROR ( "Failed<S2SV_blank>to<S2SV_blank>launch<S2SV_blank>VC<S2SV_blank>list\\n" ) ; return - 1 ; } while ( ! __sync_fetch_and_add ( & vc_list_inited , 0 ) ) { } INFO ( "List<S2SV_blank>launched\\n" ) ; return 0 ; } | <S2SV_ModStart> & list_tid , 0 <S2SV_ModEnd> ) ) { |
1,783 | CWE-000 void UsartSetStatusCR1 ( USART_TypeDef * USARTx , uint16_t USART_IT ) { <S2SV_StartBug> USARTx -> CR1 = USARTx -> CR1 | USART_IT ; <S2SV_EndBug> } | <S2SV_ModStart> USARTx -> CR1 |= <S2SV_ModEnd> USART_IT ; } |
1,784 | CWE-000 <S2SV_StartBug> PyObject * sensor_python ( const struct smc_sensor sensors [ ] ) { <S2SV_EndBug> if ( ! detection_has_run ) { detected_temperature_sensors = detect_sensors ( temperature_sensors ) ; detected_fan_sensors = detect_sensors ( fan_sensors ) ; detected_other_sensors = detect_sensors ( other_sensors ) ; } PyObject * py_retdict = PyDict_New ( ) ; for ( int i = 0 ; i < sizeof ( sensors ) ; i ++ ) { <S2SV_StartBug> PyDict_SetItemString ( py_retdict , sensors [ i ] . name , <S2SV_EndBug> Py_BuildValue ( "d" , ( * sensors [ i ] . get_function ) ( ( char * ) sensors [ i ] . key ) ) ) ; } return py_retdict ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static <S2SV_ModStart> . name , Py_BuildValue <S2SV_ModEnd> ( "d" , |
1,785 | CWE-000 void add_table ( const gchar * filename , struct configuration * conf ) { struct job * j = g_new0 ( struct job , 1 ) ; struct restore_job * rj = g_new ( struct restore_job , 1 ) ; j -> job_data = ( void * ) rj ; rj -> filename = g_strdup ( filename ) ; j -> type = JOB_RESTORE ; gchar * * split_file = g_strsplit ( filename , "." , 0 ) ; rj -> database = g_strdup ( split_file [ 0 ] ) ; rj -> table = g_strdup ( split_file [ 1 ] ) ; if ( split_file [ 2 ] != NULL && ! strcmp ( split_file [ 2 ] , "sql" ) ) { rj -> part = g_strdup ( split_file [ 2 ] ) ; } if ( split_file [ 3 ] != NULL && ! strcmp ( split_file [ 3 ] , "sql" ) ) { g_free ( rj -> part ) ; <S2SV_StartBug> rj -> part = g_strjoin ( "." , split_file [ 2 ] , split_file [ 3 ] ) ; <S2SV_EndBug> } g_async_queue_push ( conf -> queue , j ) ; return ; } | <S2SV_ModStart> [ 3 ] , NULL |
1,786 | CWE-000 static void st_scroll_view_init ( StScrollView * self ) { StScrollViewPrivate * priv = self -> priv = SCROLL_VIEW_PRIVATE ( self ) ; priv -> hscrollbar_policy = GTK_POLICY_AUTOMATIC ; priv -> vscrollbar_policy = GTK_POLICY_AUTOMATIC ; priv -> hadjustment = g_object_new ( ST_TYPE_ADJUSTMENT , NULL ) ; priv -> hscroll = g_object_new ( ST_TYPE_SCROLL_BAR , "adjustment" , priv -> hadjustment , "vertical" , FALSE , NULL ) ; priv -> vadjustment = g_object_new ( ST_TYPE_ADJUSTMENT , NULL ) ; priv -> vscroll = g_object_new ( ST_TYPE_SCROLL_BAR , "adjustment" , priv -> vadjustment , "vertical" , TRUE , NULL ) ; clutter_actor_add_child ( CLUTTER_ACTOR ( self ) , priv -> hscroll ) ; clutter_actor_add_child ( CLUTTER_ACTOR ( self ) , priv -> vscroll ) ; <S2SV_StartBug> g_signal_connect_swapped ( priv -> hadjustment , <S2SV_EndBug> "changed" , G_CALLBACK ( clutter_actor_queue_redraw ) , CLUTTER_ACTOR ( self ) ) ; g_signal_connect_swapped ( priv -> vadjustment , "changed" , G_CALLBACK ( clutter_actor_queue_redraw ) , CLUTTER_ACTOR ( self ) ) ; priv -> mouse_scroll = TRUE ; g_object_set ( G_OBJECT ( self ) , "reactive" , TRUE , NULL ) ; priv -> auto_scroll = FALSE ; priv -> auto_scroll_timeout_id = 0 ; priv -> mouse_pointer = clutter_device_manager_get_core_device ( clutter_device_manager_get_default ( ) , CLUTTER_POINTER_DEVICE ) ; priv -> settings = g_settings_new ( "org.cinnamon" ) ; priv -> setting_connect_id = g_signal_connect ( priv -> settings , "changed::enable-vfade" , G_CALLBACK ( vfade_setting_changed_cb ) , self ) ; } | <S2SV_ModStart> vscroll ) ; <S2SV_ModEnd> priv -> mouse_scroll |
1,787 | CWE-000 int main ( int argc , char * argv [ ] ) { char * dir = getDirName ( ) ; readRooms ( rooms , dir ) ; gameCont = 1 ; currId = startRoom ; char input [ 15 ] ; char timeStr [ 50 ] ; stepCnt = 0 ; FILE * file ; pthread_t thread ; pthread_mutex_init ( & mutex , NULL ) ; <S2SV_StartBug> pthread_create ( & thread , NULL , & timeThread , & close ) ; <S2SV_EndBug> pthread_mutex_lock ( & mutex ) ; while ( gameCont != 0 ) { printf ( "CURRENT<S2SV_blank>LOCATION:<S2SV_blank>%s\\n" , rooms [ currId ] . name ) ; printf ( "POSSIBLE<S2SV_blank>CONNECTIONS:<S2SV_blank>" ) ; printConnections ( rooms [ currId ] ) ; printf ( "WHERE<S2SV_blank>TO?>" ) ; fgets ( input , 15 , stdin ) ; strtok ( input , "\\n" ) ; if ( strcmp ( input , "time" ) == 0 ) { pthread_mutex_unlock ( & mutex ) ; usleep ( 50 ) ; pthread_mutex_lock ( & mutex ) ; file = fopen ( "./currentTime.txt" , "r" ) ; fgets ( timeStr , 50 , file ) ; printf ( "\\n%s\\n\\n" , timeStr ) ; fclose ( file ) ; } else if ( isConnected ( input , rooms [ currId ] ) == 0 ) { steps [ stepCnt ] = currId ; stepCnt ++ ; currId = getRoom ( input ) -> id ; if ( currId == endRoom ) { printWin ( ) ; return 0 ; } } else { printf ( "\\nHUH?<S2SV_blank>I<S2SV_blank>DON’T<S2SV_blank>UNDERSTAND<S2SV_blank>THAT<S2SV_blank>ROOM.<S2SV_blank>TRY<S2SV_blank>AGAIN.\\n\\n" ) ; } } return 0 ; } | <S2SV_ModStart> , NULL , <S2SV_ModEnd> timeThread , & |
1,788 | CWE-000 int btrfs_find_orphan_roots ( struct btrfs_root * tree_root ) { struct extent_buffer * leaf ; struct btrfs_path * path ; struct btrfs_key key ; struct btrfs_key root_key ; struct btrfs_root * root ; int err = 0 ; int ret ; bool can_recover = true ; if ( tree_root -> fs_info -> sb -> s_flags & MS_RDONLY ) can_recover = false ; path = btrfs_alloc_path ( ) ; if ( ! path ) return - ENOMEM ; key . objectid = BTRFS_ORPHAN_OBJECTID ; key . type = BTRFS_ORPHAN_ITEM_KEY ; key . offset = 0 ; root_key . type = BTRFS_ROOT_ITEM_KEY ; root_key . offset = ( u64 ) - 1 ; while ( 1 ) { ret = btrfs_search_slot ( NULL , tree_root , & key , path , 0 , 0 ) ; if ( ret < 0 ) { err = ret ; break ; } leaf = path -> nodes [ 0 ] ; if ( path -> slots [ 0 ] >= btrfs_header_nritems ( leaf ) ) { ret = btrfs_next_leaf ( tree_root , path ) ; if ( ret < 0 ) err = ret ; if ( ret != 0 ) break ; leaf = path -> nodes [ 0 ] ; } btrfs_item_key_to_cpu ( leaf , & key , path -> slots [ 0 ] ) ; btrfs_release_path ( path ) ; if ( key . objectid != BTRFS_ORPHAN_OBJECTID || key . type != BTRFS_ORPHAN_ITEM_KEY ) break ; root_key . objectid = key . offset ; key . offset ++ ; <S2SV_StartBug> root = btrfs_read_fs_root ( tree_root , & root_key ) ; <S2SV_EndBug> err = PTR_ERR_OR_ZERO ( root ) ; if ( err && err != - ENOENT ) { break ; } else if ( err == - ENOENT ) { struct btrfs_trans_handle * trans ; btrfs_release_path ( path ) ; trans = btrfs_join_transaction ( tree_root ) ; if ( IS_ERR ( trans ) ) { err = PTR_ERR ( trans ) ; btrfs_handle_fs_error ( tree_root -> fs_info , err , "Failed<S2SV_blank>to<S2SV_blank>start<S2SV_blank>trans<S2SV_blank>to<S2SV_blank>delete<S2SV_blank>" "orphan<S2SV_blank>item" ) ; break ; } err = btrfs_del_orphan_item ( trans , tree_root , root_key . objectid ) ; btrfs_end_transaction ( trans , tree_root ) ; if ( err ) { btrfs_handle_fs_error ( tree_root -> fs_info , err , "Failed<S2SV_blank>to<S2SV_blank>delete<S2SV_blank>root<S2SV_blank>orphan<S2SV_blank>" "item" ) ; break ; } continue ; } err = btrfs_init_fs_root ( root ) ; if ( err ) { btrfs_free_fs_root ( root ) ; break ; } set_bit ( BTRFS_ROOT_ORPHAN_ITEM_INSERTED , & root -> state ) ; err = btrfs_insert_fs_root ( root -> fs_info , root ) ; <S2SV_StartBug> if ( err == - EEXIST ) <S2SV_EndBug> <S2SV_StartBug> err = 0 ; <S2SV_EndBug> if ( err ) { btrfs_free_fs_root ( root ) ; break ; } if ( btrfs_root_refs ( & root -> root_item ) == 0 ) btrfs_add_dead_root ( root ) ; } btrfs_free_path ( path ) ; return err ; } | <S2SV_ModStart> ; root = btrfs_lookup_fs_root ( tree_root -> fs_info , root_key . objectid ) ; if ( root ) { WARN_ON ( ! test_bit ( BTRFS_ROOT_ORPHAN_ITEM_INSERTED , & root -> state ) ) ; if ( btrfs_root_refs ( & root -> root_item ) == 0 ) btrfs_add_dead_root ( root ) ; continue ; } root = <S2SV_ModStart> if ( err ) { BUG_ON ( err <S2SV_ModStart> - EEXIST ) ; <S2SV_ModEnd> btrfs_free_fs_root ( root |
1,789 | CWE-000 void ttm_object_file_release ( struct ttm_object_file * * p_tfile ) { struct ttm_ref_object * ref ; struct list_head * list ; unsigned int i ; struct ttm_object_file * tfile = * p_tfile ; * p_tfile = NULL ; spin_lock ( & tfile -> lock ) ; while ( ! list_empty ( & tfile -> ref_list ) ) { list = tfile -> ref_list . next ; ref = list_entry ( list , struct ttm_ref_object , head ) ; ttm_ref_object_release ( & ref -> kref ) ; } <S2SV_StartBug> for ( i = 0 ; i < TTM_REF_NUM ; ++ i ) <S2SV_EndBug> drm_ht_remove ( & tfile -> ref_hash [ i ] ) ; <S2SV_StartBug> spin_unlock ( & tfile -> lock ) ; <S2SV_EndBug> ttm_object_file_unref ( & tfile ) ; } | <S2SV_ModStart> ) ; } spin_unlock ( & tfile -> lock ) ; <S2SV_ModStart> ] ) ; <S2SV_ModEnd> ttm_object_file_unref ( & |
1,790 | CWE-000 static void lmdes ( pmix_dmdx_local_t * p ) <S2SV_StartBug> { <S2SV_EndBug> PMIX_INFO_FREE ( p -> info , p -> ninfo ) ; <S2SV_StartBug> PMIX_LIST_DESTRUCT ( & p -> loc_reqs ) ; <S2SV_EndBug> } | <S2SV_ModStart> * p ) { if ( NULL != p -> info ) <S2SV_ModStart> ninfo ) ; } |
1,791 | CWE-000 <S2SV_StartBug> static PHP_METHOD ( Phalcon_Mvc_Collection , validationHasFailed ) { <S2SV_EndBug> zval _0 ; <S2SV_StartBug> zval * this_ptr = getThis ( ) ; <S2SV_EndBug> ZVAL_UNDEF ( & _0 ) ; zephir_read_property ( & _0 , this_ptr , SL ( "_errorMessages" ) , PH_NOISY_CC | PH_READONLY ) ; RETURN_BOOL ( ( zephir_fast_count_int ( & _0 TSRMLS_CC ) > 0 ) ) ; } | <S2SV_ModStart> static PHP_METHOD ( Phalcon_Mvc_Model_Manager , getLastInitialized ) { RETURN_MEMBER ( <S2SV_ModEnd> getThis ( ) <S2SV_ModStart> getThis ( ) , "_lastInitialized" <S2SV_ModEnd> ) ; } |
1,792 | CWE-000 void find_command ( const char * name , struct cmdentry * entry , int act , const char * path ) { struct tblentry * cmdp , loc_cmd ; int idx ; <S2SV_StartBug> char * fullname ; <S2SV_EndBug> struct stat statb ; int e ; int i ; int spec ; int cd ; if ( strchr ( name , '/' ) != NULL ) { entry -> cmdtype = CMDNORMAL ; entry -> u . index = 0 ; entry -> special = 0 ; return ; } cd = 0 ; if ( ( cmdp = cmdlookup ( name , 0 ) ) != NULL ) { if ( cmdp -> cmdtype == CMDFUNCTION && act & DO_NOFUNC ) cmdp = NULL ; else goto success ; } if ( ( i = find_builtin ( name , & spec ) ) >= 0 ) { INTOFF ; cmdp = cmdlookup ( name , 1 ) ; if ( cmdp -> cmdtype == CMDFUNCTION ) cmdp = & loc_cmd ; cmdp -> cmdtype = CMDBUILTIN ; cmdp -> param . index = i ; cmdp -> special = spec ; INTON ; goto success ; } e = ENOENT ; idx = - 1 ; <S2SV_StartBug> for ( ; ( fullname = padvance ( & path , name ) ) != NULL ; stunalloc ( fullname ) ) { <S2SV_EndBug> idx ++ ; <S2SV_StartBug> if ( pathopt ) { <S2SV_EndBug> <S2SV_StartBug> if ( strncmp ( pathopt , "func" , 4 ) == 0 ) { <S2SV_EndBug> } else { continue ; } } if ( fullname [ 0 ] != '/' ) cd = 1 ; if ( stat ( fullname , & statb ) < 0 ) { if ( errno != ENOENT && errno != ENOTDIR ) e = errno ; continue ; } e = EACCES ; if ( ! S_ISREG ( statb . st_mode ) ) continue ; <S2SV_StartBug> if ( pathopt ) { <S2SV_EndBug> readcmdfile ( fullname ) ; if ( ( cmdp = cmdlookup ( name , 0 ) ) == NULL || cmdp -> cmdtype != CMDFUNCTION ) error ( "%s<S2SV_blank>not<S2SV_blank>defined<S2SV_blank>in<S2SV_blank>%s" , name , fullname ) ; stunalloc ( fullname ) ; goto success ; } # ifdef notdef if ( statb . st_uid == geteuid ( ) ) { if ( ( statb . st_mode & 0100 ) == 0 ) goto loop ; } else if ( statb . st_gid == getegid ( ) ) { if ( ( statb . st_mode & 010 ) == 0 ) goto loop ; } else { if ( ( statb . st_mode & 01 ) == 0 ) goto loop ; } # endif TRACE ( ( "searchexec<S2SV_blank>\\"%s\\"<S2SV_blank>returns<S2SV_blank>\\"%s\\"\\n" , name , fullname ) ) ; INTOFF ; stunalloc ( fullname ) ; cmdp = cmdlookup ( name , 1 ) ; if ( cmdp -> cmdtype == CMDFUNCTION ) cmdp = & loc_cmd ; cmdp -> cmdtype = CMDNORMAL ; cmdp -> param . index = idx ; cmdp -> special = 0 ; INTON ; goto success ; } if ( act & DO_ERR ) { if ( e == ENOENT || e == ENOTDIR ) outfmt ( out2 , "%s:<S2SV_blank>not<S2SV_blank>found\\n" , name ) ; else outfmt ( out2 , "%s:<S2SV_blank>%s\\n" , name , strerror ( e ) ) ; } entry -> cmdtype = CMDUNKNOWN ; entry -> u . index = 0 ; entry -> special = 0 ; return ; success : if ( cd ) cmdtable_cd = 1 ; entry -> cmdtype = cmdp -> cmdtype ; entry -> u = cmdp -> param ; entry -> special = cmdp -> special ; } | <S2SV_ModStart> int idx ; const char * opt ; <S2SV_ModStart> & path , & opt , <S2SV_ModStart> ; if ( opt <S2SV_ModEnd> ) { if <S2SV_ModStart> ( strncmp ( opt <S2SV_ModEnd> , "func" , <S2SV_ModStart> ; if ( opt <S2SV_ModEnd> ) { readcmdfile |
1,793 | CWE-000 static void process_map_input ( void ) { int mv_x , mv_y ; person_t * person ; int i ; kb_clear_queue ( ) ; for ( i = 0 ; i < PLAYER_MAX ; ++ i ) { person = s_players [ i ] . person ; if ( person != NULL ) { if ( kb_is_key_down ( get_player_key ( i , PLAYER_KEY_A ) ) || kb_is_key_down ( s_players [ i ] . talk_key ) || joy_is_button_down ( i , s_talk_button ) ) { if ( s_players [ i ] . is_talk_allowed ) person_talk ( person ) ; s_players [ i ] . is_talk_allowed = false ; } <S2SV_StartBug> else <S2SV_EndBug> <S2SV_StartBug> s_players [ i ] . is_talk_allowed = true ; <S2SV_EndBug> mv_x = 0 ; mv_y = 0 ; if ( person -> num_commands == 0 && person -> leader == NULL ) { if ( kb_is_key_down ( get_player_key ( i , PLAYER_KEY_UP ) ) || joy_position ( i , 1 ) <= - 0.5 ) mv_y = - 1 ; if ( kb_is_key_down ( get_player_key ( i , PLAYER_KEY_RIGHT ) ) || joy_position ( i , 0 ) >= 0.5 ) mv_x = 1 ; if ( kb_is_key_down ( get_player_key ( i , PLAYER_KEY_DOWN ) ) || joy_position ( i , 1 ) >= 0.5 ) mv_y = 1 ; if ( kb_is_key_down ( get_player_key ( i , PLAYER_KEY_LEFT ) ) || joy_position ( i , 0 ) <= - 0.5 ) mv_x = - 1 ; } switch ( mv_x + mv_y * 3 ) { case - 3 : person_queue_command ( person , COMMAND_MOVE_NORTH , true ) ; person_queue_command ( person , COMMAND_FACE_NORTH , true ) ; person_queue_command ( person , COMMAND_ANIMATE , false ) ; break ; case - 2 : person_queue_command ( person , COMMAND_MOVE_NORTHEAST , true ) ; person_queue_command ( person , COMMAND_FACE_NORTHEAST , true ) ; person_queue_command ( person , COMMAND_ANIMATE , false ) ; break ; case 1 : person_queue_command ( person , COMMAND_MOVE_EAST , true ) ; person_queue_command ( person , COMMAND_FACE_EAST , true ) ; person_queue_command ( person , COMMAND_ANIMATE , false ) ; break ; case 4 : person_queue_command ( person , COMMAND_MOVE_SOUTHEAST , true ) ; person_queue_command ( person , COMMAND_FACE_SOUTHEAST , true ) ; person_queue_command ( person , COMMAND_ANIMATE , false ) ; break ; case 3 : person_queue_command ( person , COMMAND_MOVE_SOUTH , true ) ; person_queue_command ( person , COMMAND_FACE_SOUTH , true ) ; person_queue_command ( person , COMMAND_ANIMATE , false ) ; break ; case 2 : person_queue_command ( person , COMMAND_MOVE_SOUTHWEST , true ) ; person_queue_command ( person , COMMAND_FACE_SOUTHWEST , true ) ; person_queue_command ( person , COMMAND_ANIMATE , false ) ; break ; case - 1 : person_queue_command ( person , COMMAND_MOVE_WEST , true ) ; person_queue_command ( person , COMMAND_FACE_WEST , true ) ; person_queue_command ( person , COMMAND_ANIMATE , false ) ; break ; case - 4 : person_queue_command ( person , COMMAND_MOVE_NORTHWEST , true ) ; person_queue_command ( person , COMMAND_FACE_NORTHWEST , true ) ; person_queue_command ( person , COMMAND_ANIMATE , false ) ; break ; } } } update_bound_keys ( true ) ; } | <S2SV_ModStart> ; } else { <S2SV_ModStart> = true ; } |
1,794 | CWE-000 static int cxgbe_vi_attach ( device_t dev , struct vi_info * vi ) { struct ifnet * ifp ; struct sbuf * sb ; vi -> xact_addr_filt = - 1 ; callout_init ( & vi -> tick , 1 ) ; ifp = if_alloc ( IFT_ETHER ) ; if ( ifp == NULL ) { device_printf ( dev , "Cannot<S2SV_blank>allocate<S2SV_blank>ifnet\\n" ) ; return ( ENOMEM ) ; } vi -> ifp = ifp ; ifp -> if_softc = vi ; if_initname ( ifp , device_get_name ( dev ) , device_get_unit ( dev ) ) ; ifp -> if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST ; ifp -> if_init = cxgbe_init ; ifp -> if_ioctl = cxgbe_ioctl ; ifp -> if_transmit = cxgbe_transmit ; ifp -> if_qflush = cxgbe_qflush ; ifp -> if_get_counter = cxgbe_get_counter ; # ifdef RATELIMIT ifp -> if_snd_tag_alloc = cxgbe_snd_tag_alloc ; ifp -> if_snd_tag_modify = cxgbe_snd_tag_modify ; ifp -> if_snd_tag_query = cxgbe_snd_tag_query ; ifp -> if_snd_tag_free = cxgbe_snd_tag_free ; # endif ifp -> if_capabilities = T4_CAP ; <S2SV_StartBug> # ifdef TCP_OFFLOAD <S2SV_EndBug> if ( vi -> nofldrxq != 0 ) ifp -> if_capabilities |= IFCAP_TOE ; # endif # ifdef DEV_NETMAP if ( vi -> nnmrxq != 0 ) ifp -> if_capabilities |= IFCAP_NETMAP ; # endif # ifdef RATELIMIT <S2SV_StartBug> if ( is_ethoffload ( vi -> pi -> adapter ) && vi -> nofldtxq != 0 ) <S2SV_EndBug> ifp -> if_capabilities |= IFCAP_TXRTLMT ; <S2SV_StartBug> # endif <S2SV_EndBug> <S2SV_StartBug> ifp -> if_capenable = T4_CAP_ENABLE ; <S2SV_EndBug> ifp -> if_hwassist = CSUM_TCP | CSUM_UDP | CSUM_IP | CSUM_TSO | CSUM_UDP_IPV6 | CSUM_TCP_IPV6 ; ifp -> if_hw_tsomax = 65536 - ( ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN ) ; ifp -> if_hw_tsomaxsegcount = TX_SGL_SEGS ; ifp -> if_hw_tsomaxsegsize = 65536 ; ether_ifattach ( ifp , vi -> hw_addr ) ; # ifdef DEV_NETMAP if ( ifp -> if_capabilities & IFCAP_NETMAP ) cxgbe_nm_attach ( vi ) ; # endif sb = sbuf_new_auto ( ) ; sbuf_printf ( sb , "%d<S2SV_blank>txq,<S2SV_blank>%d<S2SV_blank>rxq<S2SV_blank>(NIC)" , vi -> ntxq , vi -> nrxq ) ; # if defined ( TCP_OFFLOAD ) || defined ( RATELIMIT ) switch ( ifp -> if_capabilities & ( IFCAP_TOE | IFCAP_TXRTLMT ) ) { case IFCAP_TOE : sbuf_printf ( sb , ";<S2SV_blank>%d<S2SV_blank>txq<S2SV_blank>(TOE)" , vi -> nofldtxq ) ; break ; case IFCAP_TOE | IFCAP_TXRTLMT : sbuf_printf ( sb , ";<S2SV_blank>%d<S2SV_blank>txq<S2SV_blank>(TOE/ETHOFLD)" , vi -> nofldtxq ) ; break ; case IFCAP_TXRTLMT : sbuf_printf ( sb , ";<S2SV_blank>%d<S2SV_blank>txq<S2SV_blank>(ETHOFLD)" , vi -> nofldtxq ) ; break ; } # endif # ifdef TCP_OFFLOAD if ( ifp -> if_capabilities & IFCAP_TOE ) sbuf_printf ( sb , ",<S2SV_blank>%d<S2SV_blank>rxq<S2SV_blank>(TOE)" , vi -> nofldrxq ) ; # endif # ifdef DEV_NETMAP if ( ifp -> if_capabilities & IFCAP_NETMAP ) sbuf_printf ( sb , ";<S2SV_blank>%d<S2SV_blank>txq,<S2SV_blank>%d<S2SV_blank>rxq<S2SV_blank>(netmap)" , vi -> nnmtxq , vi -> nnmrxq ) ; # endif sbuf_finish ( sb ) ; device_printf ( dev , "%s\\n" , sbuf_data ( sb ) ) ; sbuf_delete ( sb ) ; vi_sysctls ( vi ) ; return ( 0 ) ; } | <S2SV_ModStart> = T4_CAP ; ifp -> if_capenable = T4_CAP_ENABLE ; <S2SV_ModStart> != 0 ) { <S2SV_ModStart> |= IFCAP_TXRTLMT ; <S2SV_ModEnd> ifp -> if_capenable <S2SV_ModStart> ifp -> if_capenable |= IFCAP_TXRTLMT ; } # endif <S2SV_ModEnd> ifp -> if_hwassist |
1,795 | CWE-000 void tlb_gather_mmu ( struct mmu_gather * tlb , struct mm_struct * mm , unsigned long start , unsigned long end ) { arch_tlb_gather_mmu ( tlb , mm , start , end ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> end ) ; inc_tlb_flush_pending ( tlb -> mm ) ; |
1,796 | CWE-000 int SysLogger_Start ( void ) { pid_t sysloggerPid ; char * filename ; if ( ! Logging_collector ) return 0 ; # ifndef WIN32 if ( syslogPipe [ 0 ] < 0 ) { if ( pipe ( syslogPipe ) < 0 ) ereport ( FATAL , ( errcode_for_socket_access ( ) , ( errmsg ( "could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>pipe<S2SV_blank>for<S2SV_blank>syslog:<S2SV_blank>%m" ) ) ) ) ; } # else if ( ! syslogPipe [ 0 ] ) { SECURITY_ATTRIBUTES sa ; memset ( & sa , 0 , sizeof ( SECURITY_ATTRIBUTES ) ) ; sa . nLength = sizeof ( SECURITY_ATTRIBUTES ) ; sa . bInheritHandle = TRUE ; if ( ! CreatePipe ( & syslogPipe [ 0 ] , & syslogPipe [ 1 ] , & sa , 32768 ) ) ereport ( FATAL , ( errcode_for_file_access ( ) , ( errmsg ( "could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>pipe<S2SV_blank>for<S2SV_blank>syslog:<S2SV_blank>%m" ) ) ) ) ; } # endif mkdir ( Log_directory , S_IRWXU ) ; first_syslogger_file_time = time ( NULL ) ; filename = logfile_getname ( first_syslogger_file_time , NULL , Log_directory , Log_filename ) ; syslogFile = logfile_open ( filename , "a" , false ) ; open_alert_log_file ( ) ; pfree ( filename ) ; if ( Log_destination & LOG_DESTINATION_CSVLOG ) { <S2SV_StartBug> filename = logfile_getname ( first_syslogger_file_time , ".csv" ) ; <S2SV_EndBug> csvlogFile = logfile_open ( filename , "a" , false ) ; pfree ( filename ) ; } # ifdef EXEC_BACKEND switch ( ( sysloggerPid = syslogger_forkexec ( ) ) ) # else switch ( ( sysloggerPid = fork_process ( ) ) ) # endif { case - 1 : ereport ( LOG , ( errmsg ( "could<S2SV_blank>not<S2SV_blank>fork<S2SV_blank>system<S2SV_blank>logger:<S2SV_blank>%m" ) ) ) ; return 0 ; # ifndef EXEC_BACKEND case 0 : ClosePostmasterPorts ( true ) ; on_exit_reset ( ) ; dsm_detach_all ( ) ; PGSharedMemoryDetach ( ) ; SysLoggerMain ( 0 , NULL ) ; break ; # endif default : if ( ! redirection_done ) { # ifdef WIN32 int fd ; # endif ereport ( LOG , ( errmsg ( "redirecting<S2SV_blank>log<S2SV_blank>output<S2SV_blank>to<S2SV_blank>logging<S2SV_blank>collector<S2SV_blank>process" ) , errhint ( "Future<S2SV_blank>log<S2SV_blank>output<S2SV_blank>will<S2SV_blank>appear<S2SV_blank>in<S2SV_blank>directory<S2SV_blank>\\"%s\\"." , Log_directory ) ) ) ; # ifndef WIN32 fflush ( stdout ) ; if ( dup2 ( syslogPipe [ 1 ] , fileno ( stdout ) ) < 0 ) ereport ( FATAL , ( errcode_for_file_access ( ) , errmsg ( "could<S2SV_blank>not<S2SV_blank>redirect<S2SV_blank>stdout:<S2SV_blank>%m" ) ) ) ; fflush ( stderr ) ; if ( dup2 ( syslogPipe [ 1 ] , fileno ( stderr ) ) < 0 ) ereport ( FATAL , ( errcode_for_file_access ( ) , errmsg ( "could<S2SV_blank>not<S2SV_blank>redirect<S2SV_blank>stderr:<S2SV_blank>%m" ) ) ) ; close ( syslogPipe [ 1 ] ) ; syslogPipe [ 1 ] = - 1 ; # else fflush ( stderr ) ; fd = _open_osfhandle ( ( intptr_t ) syslogPipe [ 1 ] , _O_APPEND | _O_BINARY ) ; if ( dup2 ( fd , _fileno ( stderr ) ) < 0 ) ereport ( FATAL , ( errcode_for_file_access ( ) , errmsg ( "could<S2SV_blank>not<S2SV_blank>redirect<S2SV_blank>stderr:<S2SV_blank>%m" ) ) ) ; close ( fd ) ; _setmode ( _fileno ( stderr ) , _O_BINARY ) ; syslogPipe [ 1 ] = 0 ; # endif redirection_done = true ; } fclose ( syslogFile ) ; syslogFile = NULL ; if ( alertLogFile != NULL ) { fclose ( alertLogFile ) ; alertLogFile = NULL ; } if ( csvlogFile != NULL ) { fclose ( csvlogFile ) ; csvlogFile = NULL ; } return ( int ) sysloggerPid ; } return 0 ; } | <S2SV_ModStart> first_syslogger_file_time , ".csv" , Log_directory , Log_filename |
1,797 | CWE-000 static inline size_t get_size_name ( unsigned name ) { char path [ 2048 ] ; int written ; <S2SV_StartBug> written = snprintf ( & path [ 0 ] , sizeof ( path ) , "%s%d/" , "/tmp/bop/" , getuniqueid ( ) ) ; <S2SV_EndBug> if ( written > sizeof ( path ) || written < 0 ) { noomr_perror ( "Unable<S2SV_blank>to<S2SV_blank>write<S2SV_blank>directory<S2SV_blank>name" ) ; abort ( ) ; } if ( rmkdir ( & path [ 0 ] ) != 0 && errno != EEXIST ) { noomr_perror ( "Unable<S2SV_blank>to<S2SV_blank>make<S2SV_blank>the<S2SV_blank>directory" ) ; abort ( ) ; } written = snprintf ( & path [ 0 ] , sizeof ( path ) , "%s%d/%u" , "/tmp/bop/" , getuniqueid ( ) , name ) ; if ( written > sizeof ( path ) || written < 0 ) { noomr_perror ( "Unable<S2SV_blank>to<S2SV_blank>write<S2SV_blank>the<S2SV_blank>output<S2SV_blank>path" ) ; abort ( ) ; } <S2SV_StartBug> int fd = open ( path , O_RDWR | O_SYNC , S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP ) ; <S2SV_EndBug> if ( fd == - 1 ) { noomr_perror ( "Unable<S2SV_blank>to<S2SV_blank>open<S2SV_blank>existing<S2SV_blank>file" ) ; } size_t size = get_size_fd ( fd ) ; if ( close ( fd ) ) { noomr_perror ( "Unable<S2SV_blank>to<S2SV_blank>close<S2SV_blank>fd<S2SV_blank>used<S2SV_blank>for<S2SV_blank>temp<S2SV_blank>size<S2SV_blank>pole" ) ; } return size ; } | <S2SV_ModStart> int written ; <S2SV_ModEnd> written = snprintf <S2SV_ModStart> ( path , O_RDONLY <S2SV_ModEnd> ) ; if |
1,798 | CWE-000 static uint32_t get_valid_cpufreq ( uint32_t cpu , uint32_t freq ) { struct cpufreq_frequency_table * table ; struct cpufreq_policy policy ; <S2SV_StartBug> uint32_t index , ret ; <S2SV_EndBug> ret = cpufreq_get_policy ( & policy , cpu ) ; if ( ret ) return freq ; table = cpufreq_frequency_get_table ( cpu ) ; if ( ! table ) return freq ; cpufreq_frequency_table_target ( & policy , table , freq , CPUFREQ_RELATION_L , & index ) ; return table [ index ] . frequency ; } | <S2SV_ModStart> ; uint32_t index ; int32_t <S2SV_ModEnd> ret ; ret |
1,799 | CWE-000 void kprint ( int type , const char * fmt , ... ) { spinlock_acquire ( & kprint_lock ) ; va_list args ; va_start ( args , fmt ) ; print_timestamp ( type ) ; char * str ; <S2SV_StartBug> for ( ; ; ) { <S2SV_EndBug> char c ; while ( * fmt && * fmt != '%' ) { kputchar ( * fmt ) ; if ( * fmt == '\\n' ) print_timestamp ( type ) ; fmt ++ ; } if ( ! * fmt ++ ) { va_end ( args ) ; kputchar ( '\\n' ) ; goto out ; } switch ( * fmt ++ ) { case 's' : str = ( char * ) va_arg ( args , const char * ) ; if ( ! str ) kputs ( "(null)" ) ; else kputs ( str ) ; break ; <S2SV_StartBug> case 'd' : <S2SV_EndBug> kprn_i ( ( int64_t ) va_arg ( args , int ) ) ; break ; case 'D' : kprn_i ( ( int64_t ) va_arg ( args , int64_t ) ) ; break ; case 'u' : kprn_ui ( ( uint64_t ) va_arg ( args , unsigned int ) ) ; break ; case 'U' : kprn_ui ( ( uint64_t ) va_arg ( args , uint64_t ) ) ; break ; case 'x' : kprn_x ( ( uint64_t ) va_arg ( args , unsigned int ) ) ; break ; case 'X' : kprn_x ( ( uint64_t ) va_arg ( args , uint64_t ) ) ; break ; case 'c' : c = ( char ) va_arg ( args , int ) ; kputchar ( c ) ; break ; default : kputchar ( '?' ) ; break ; } } out : kprint_buf_flush ( ) ; spinlock_release ( & kprint_lock ) ; return ; } | <S2SV_ModStart> * str ; size_t str_len ; <S2SV_ModStart> break ; case 'S' : str_len = va_arg ( args , size_t ) ; str = ( char * ) va_arg ( args , const char * ) ; knputs ( str , str_len ) ; break ; case |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.