Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
400
|
CWE-000 static void friend_purge_old_ack ( struct bt_mesh_friend * frnd , u64_t * seq_auth , u16_t src ) { sys_snode_t * cur , * prev = NULL ; BT_DBG ( "SeqAuth<S2SV_blank>%llx<S2SV_blank>src<S2SV_blank>0x%04x" , * seq_auth , src ) ; for ( cur = sys_slist_peek_head ( & frnd -> queue ) ; cur != NULL ; prev = cur , cur = sys_slist_peek_next ( cur ) ) { struct net_buf * buf = ( void * ) cur ; if ( BT_MESH_ADV ( buf ) -> addr == src && <S2SV_StartBug> buf_seq_auth [ net_buf_id ( buf ) ] == * seq_auth ) { <S2SV_EndBug> BT_DBG ( "Removing<S2SV_blank>old<S2SV_blank>ack<S2SV_blank>from<S2SV_blank>Friend<S2SV_blank>Queue" ) ; sys_slist_remove ( & frnd -> queue , prev , cur ) ; buf -> frags = NULL ; net_buf_unref ( buf ) ; break ; } } }
|
<S2SV_ModStart> == src && FRIEND_ADV <S2SV_ModEnd> ( buf ) <S2SV_ModStart> ( buf ) -> seq_auth <S2SV_ModEnd> == * seq_auth
|
401
|
CWE-000 double ncVar1DGetLinear ( NcVar1D * var , double x ) { size_t i ; <S2SV_StartBug> double xi , xj , yi , yj , par [ 2 ] ; <S2SV_EndBug> i = ncDataSet1DSearch ( var -> dataSet , & x ) ; if ( i == var -> dataSet -> dim - 1 ) i -- ; if ( ! linearCacheSearch ( ( Item * ) ( var -> parameterCache ) , i , par ) ) { <S2SV_StartBug> var -> pCacheStat [ 1 ] ++ ; <S2SV_EndBug> xi = ncDataSet1DGetItem ( var -> dataSet , i ) ; yi = ncVar1DGetItem ( var , i ) ; xj = ncDataSet1DGetItem ( var -> dataSet , ++ i ) ; yj = ncVar1DGetItem ( var , i ) ; assert ( ( xi != xj ) ) ; par [ 0 ] = ( yj - yi ) / ( xj - xi ) ; par [ 1 ] = yi - par [ 0 ] * xi ; if ( var -> parameterCache ) linearCacheSet ( ( Item * * ) ( & ( var -> parameterCache ) ) , -- i , par ) ; } else var -> pCacheStat [ 0 ] ++ ; return par [ 0 ] * x + par [ 1 ] ; }
|
<S2SV_ModStart> i ; double <S2SV_ModEnd> par [ 2 <S2SV_ModStart> ) ) { double xi , xj , yi , yj ;
|
402
|
CWE-000 char * next_path_entry ( const char * path ) { int plen = 0 ; <S2SV_StartBug> while ( text [ plen ] != 0 && text [ plen ] != '\\\\' ) { <S2SV_EndBug> plen += 1 ; } }
|
<S2SV_ModStart> ; while ( path <S2SV_ModEnd> [ plen ] <S2SV_ModStart> != 0 && path <S2SV_ModEnd> [ plen ]
|
403
|
CWE-000 static void ibmvnic_handle_crq ( union ibmvnic_crq * crq , struct ibmvnic_adapter * adapter ) { struct ibmvnic_generic_crq * gen_crq = & crq -> generic ; struct net_device * netdev = adapter -> netdev ; struct device * dev = & adapter -> vdev -> dev ; <S2SV_StartBug> long rc ; <S2SV_EndBug> netdev_dbg ( netdev , "Handling<S2SV_blank>CRQ:<S2SV_blank>%016lx<S2SV_blank>%016lx\\n" , <S2SV_StartBug> ( ( unsigned long int * ) crq ) [ 0 ] , <S2SV_EndBug> <S2SV_StartBug> ( ( unsigned long int * ) crq ) [ 1 ] ) ; <S2SV_EndBug> switch ( gen_crq -> first ) { case IBMVNIC_CRQ_INIT_RSP : switch ( gen_crq -> cmd ) { case IBMVNIC_CRQ_INIT : dev_info ( dev , "Partner<S2SV_blank>initialized\\n" ) ; rc = ibmvnic_send_crq_init_complete ( adapter ) ; if ( ! rc ) schedule_work ( & adapter -> ibmvnic_failover ) ; else dev_err ( dev , "Can\'t<S2SV_blank>send<S2SV_blank>initrsp<S2SV_blank>rc=%ld\\n" , rc ) ; break ; case IBMVNIC_CRQ_INIT_COMPLETE : dev_info ( dev , "Partner<S2SV_blank>initialization<S2SV_blank>complete\\n" ) ; send_version_xchg ( adapter ) ; break ; default : dev_err ( dev , "Unknown<S2SV_blank>crq<S2SV_blank>cmd:<S2SV_blank>%d\\n" , gen_crq -> cmd ) ; } return ; case IBMVNIC_CRQ_XPORT_EVENT : if ( gen_crq -> cmd == IBMVNIC_PARTITION_MIGRATED ) { netif_carrier_off ( netdev ) ; dev_info ( dev , "Re-enabling<S2SV_blank>adapter\\n" ) ; adapter -> migrated = true ; adapter -> is_up = false ; schedule_delayed_work ( & adapter -> ibmvnic_xport , 2 * HZ ) ; } else if ( gen_crq -> cmd == IBMVNIC_DEVICE_FAILOVER ) { if ( adapter -> migrated ) { rc = cancel_delayed_work ( & adapter -> ibmvnic_xport ) ; if ( rc ) adapter -> migrated = false ; } dev_info ( dev , "Backing<S2SV_blank>device<S2SV_blank>failover<S2SV_blank>detected\\n" ) ; netif_carrier_off ( netdev ) ; adapter -> failover = true ; adapter -> is_up = false ; } else { dev_err ( dev , "Virtual<S2SV_blank>Adapter<S2SV_blank>failed<S2SV_blank>(rc=%d)\\n" , gen_crq -> cmd ) ; schedule_delayed_work ( & adapter -> ibmvnic_xport , 2 * HZ ) ; } return ; case IBMVNIC_CRQ_CMD_RSP : break ; default : dev_err ( dev , "Got<S2SV_blank>an<S2SV_blank>invalid<S2SV_blank>msg<S2SV_blank>type<S2SV_blank>0x%02x\\n" , gen_crq -> first ) ; return ; } switch ( gen_crq -> cmd ) { case VERSION_EXCHANGE_RSP : rc = crq -> version_exchange_rsp . rc . code ; if ( rc ) { dev_err ( dev , "Error<S2SV_blank>%ld<S2SV_blank>in<S2SV_blank>VERSION_EXCHG_RSP\\n" , rc ) ; break ; } dev_info ( dev , "Partner<S2SV_blank>protocol<S2SV_blank>version<S2SV_blank>is<S2SV_blank>%d\\n" , crq -> version_exchange_rsp . version ) ; if ( be16_to_cpu ( crq -> version_exchange_rsp . version ) < ibmvnic_version ) ibmvnic_version = be16_to_cpu ( crq -> version_exchange_rsp . version ) ; send_cap_queries ( adapter ) ; break ; case QUERY_CAPABILITY_RSP : handle_query_cap_rsp ( crq , adapter ) ; break ; case QUERY_MAP_RSP : handle_query_map_rsp ( crq , adapter ) ; break ; case REQUEST_MAP_RSP : handle_request_map_rsp ( crq , adapter ) ; break ; case REQUEST_UNMAP_RSP : handle_request_unmap_rsp ( crq , adapter ) ; break ; case REQUEST_CAPABILITY_RSP : handle_request_cap_rsp ( crq , adapter ) ; break ; case LOGIN_RSP : netdev_dbg ( netdev , "Got<S2SV_blank>Login<S2SV_blank>Response\\n" ) ; handle_login_rsp ( crq , adapter ) ; break ; case LOGICAL_LINK_STATE_RSP : netdev_dbg ( netdev , "Got<S2SV_blank>Logical<S2SV_blank>Link<S2SV_blank>State<S2SV_blank>Response\\n" ) ; adapter -> logical_link_state = crq -> logical_link_state_rsp . link_state ; break ; case LINK_STATE_INDICATION : netdev_dbg ( netdev , "Got<S2SV_blank>Logical<S2SV_blank>Link<S2SV_blank>State<S2SV_blank>Indication\\n" ) ; adapter -> phys_link_state = crq -> link_state_indication . phys_link_state ; adapter -> logical_link_state = crq -> link_state_indication . logical_link_state ; break ; case CHANGE_MAC_ADDR_RSP : netdev_dbg ( netdev , "Got<S2SV_blank>MAC<S2SV_blank>address<S2SV_blank>change<S2SV_blank>Response\\n" ) ; handle_change_mac_rsp ( crq , adapter ) ; break ; case ERROR_INDICATION : netdev_dbg ( netdev , "Got<S2SV_blank>Error<S2SV_blank>Indication\\n" ) ; handle_error_indication ( crq , adapter ) ; break ; case REQUEST_ERROR_RSP : netdev_dbg ( netdev , "Got<S2SV_blank>Error<S2SV_blank>Detail<S2SV_blank>Response\\n" ) ; handle_error_info_rsp ( crq , adapter ) ; break ; case REQUEST_STATISTICS_RSP : netdev_dbg ( netdev , "Got<S2SV_blank>Statistics<S2SV_blank>Response\\n" ) ; complete ( & adapter -> stats_done ) ; break ; case REQUEST_DUMP_SIZE_RSP : netdev_dbg ( netdev , "Got<S2SV_blank>Request<S2SV_blank>Dump<S2SV_blank>Size<S2SV_blank>Response\\n" ) ; handle_dump_size_rsp ( crq , adapter ) ; break ; case REQUEST_DUMP_RSP : netdev_dbg ( netdev , "Got<S2SV_blank>Request<S2SV_blank>Dump<S2SV_blank>Response\\n" ) ; complete ( & adapter -> fw_done ) ; break ; case QUERY_IP_OFFLOAD_RSP : netdev_dbg ( netdev , "Got<S2SV_blank>Query<S2SV_blank>IP<S2SV_blank>offload<S2SV_blank>Response\\n" ) ; handle_query_ip_offload_rsp ( adapter ) ; break ; case MULTICAST_CTRL_RSP : netdev_dbg ( netdev , "Got<S2SV_blank>multicast<S2SV_blank>control<S2SV_blank>Response\\n" ) ; break ; case CONTROL_IP_OFFLOAD_RSP : netdev_dbg ( netdev , "Got<S2SV_blank>Control<S2SV_blank>IP<S2SV_blank>offload<S2SV_blank>Response\\n" ) ; dma_unmap_single ( dev , adapter -> ip_offload_ctrl_tok , sizeof ( adapter -> ip_offload_ctrl ) , DMA_TO_DEVICE ) ; complete ( & adapter -> init_done ) ; break ; case REQUEST_RAS_COMP_NUM_RSP : netdev_dbg ( netdev , "Got<S2SV_blank>Request<S2SV_blank>RAS<S2SV_blank>Comp<S2SV_blank>Num<S2SV_blank>Response\\n" ) ; if ( crq -> request_ras_comp_num_rsp . rc . code == 10 ) { netdev_dbg ( netdev , "Request<S2SV_blank>RAS<S2SV_blank>Comp<S2SV_blank>Num<S2SV_blank>not<S2SV_blank>supported\\n" ) ; break ; } adapter -> ras_comp_num = be32_to_cpu ( crq -> request_ras_comp_num_rsp . num_components ) ; handle_request_ras_comp_num_rsp ( crq , adapter ) ; break ; case REQUEST_RAS_COMPS_RSP : netdev_dbg ( netdev , "Got<S2SV_blank>Request<S2SV_blank>RAS<S2SV_blank>Comps<S2SV_blank>Response\\n" ) ; handle_request_ras_comps_rsp ( crq , adapter ) ; break ; case CONTROL_RAS_RSP : netdev_dbg ( netdev , "Got<S2SV_blank>Control<S2SV_blank>RAS<S2SV_blank>Response\\n" ) ; handle_control_ras_rsp ( crq , adapter ) ; break ; case COLLECT_FW_TRACE_RSP : netdev_dbg ( netdev , "Got<S2SV_blank>Collect<S2SV_blank>firmware<S2SV_blank>trace<S2SV_blank>Response\\n" ) ; complete ( & adapter -> fw_done ) ; break ; default : netdev_err ( netdev , "Got<S2SV_blank>an<S2SV_blank>invalid<S2SV_blank>cmd<S2SV_blank>type<S2SV_blank>0x%02x\\n" , gen_crq -> cmd ) ; } }
|
<S2SV_ModStart> -> dev ; u64 * u64_crq = ( u64 * ) crq ; <S2SV_ModStart> , "Handling<S2SV_blank>CRQ:<S2SV_blank>%016lx<S2SV_blank>%016lx\\n" , <S2SV_ModEnd> ( unsigned long <S2SV_ModStart> unsigned long int ) cpu_to_be64 ( u64_crq <S2SV_ModEnd> [ 0 ] <S2SV_ModStart> [ 0 ] ) , <S2SV_ModEnd> ( unsigned long <S2SV_ModStart> unsigned long int ) cpu_to_be64 ( u64_crq <S2SV_ModEnd> [ 1 ] <S2SV_ModStart> [ 1 ] )
|
404
|
CWE-000 static sql_exp * _rel_nop ( mvc * sql , sql_schema * s , char * fname , list * tl , list * exps , sql_subtype * obj_type , int nr_args , exp_kind ek ) { sql_subfunc * f = NULL ; int table_func = ( ek . card == card_relation ) ; int type = ( ek . card == card_loader ) ? F_LOADER : ( ( ek . card == card_none ) ? F_PROC : ( ( ek . card == card_relation ) ? F_UNION : F_FUNC ) ) ; int filt = ( type == F_FUNC ) ? F_FILT : type ; f = bind_func_ ( sql , s , fname , tl , type ) ; if ( f ) { return exp_op ( sql -> sa , exps , f ) ; } else if ( obj_type && ( f = bind_member_func ( sql , s , fname , obj_type , nr_args , NULL ) ) != NULL ) { sql_subfunc * prev = NULL ; node * n , * m ; list * nexps ; while ( ( f = bind_member_func ( sql , s , fname , obj_type , nr_args , prev ) ) != NULL ) { prev = f ; if ( f -> func -> type != type && f -> func -> type != filt ) continue ; if ( f -> func -> vararg ) return exp_op ( sql -> sa , exps , f ) ; nexps = new_exp_list ( sql -> sa ) ; for ( n = exps -> h , m = f -> func -> ops -> h ; n && m ; n = n -> next , m = m -> next ) { sql_arg * a = m -> data ; sql_exp * e = n -> data ; <S2SV_StartBug> if ( a -> type . type -> eclass == EC_ANY ) { <S2SV_EndBug> sql_subtype * st = & e -> tpe ; <S2SV_StartBug> sql_init_subtype ( & a -> type , st -> type , st -> digits , st -> scale ) ; <S2SV_EndBug> } <S2SV_StartBug> e = rel_check_type ( sql , & a -> type , e , type_equal ) ; <S2SV_EndBug> if ( ! e ) { nexps = NULL ; break ; } if ( table_func && e -> card > CARD_ATOM ) { sql_subaggr * zero_or_one = sql_bind_aggr ( sql -> sa , sql -> session -> schema , "zero_or_one" , exp_subtype ( e ) ) ; e = exp_aggr1 ( sql -> sa , e , zero_or_one , 0 , 0 , CARD_ATOM , 0 ) ; } append ( nexps , e ) ; } if ( nexps ) return exp_op ( sql -> sa , nexps , f ) ; } } else if ( ( f = find_func ( sql , s , fname , nr_args , type , NULL ) ) != NULL ) { sql_subfunc * prev = NULL ; node * n , * m ; list * nexps ; while ( ( f = find_func ( sql , s , fname , nr_args , type , prev ) ) != NULL ) { prev = f ; if ( f -> func -> type != type && f -> func -> type != filt ) continue ; if ( f -> func -> vararg ) return exp_op ( sql -> sa , exps , f ) ; nexps = new_exp_list ( sql -> sa ) ; for ( n = exps -> h , m = f -> func -> ops -> h ; n && m ; n = n -> next , m = m -> next ) { sql_arg * a = m -> data ; sql_exp * e = n -> data ; if ( a -> type . type -> eclass == EC_ANY ) { sql_subtype * st = & e -> tpe ; sql_init_subtype ( & a -> type , st -> type , st -> digits , st -> scale ) ; } e = rel_check_type ( sql , & a -> type , e , type_equal ) ; if ( ! e ) { nexps = NULL ; break ; } if ( table_func && e -> card > CARD_ATOM ) { sql_subaggr * zero_or_one = sql_bind_aggr ( sql -> sa , sql -> session -> schema , "zero_or_one" , exp_subtype ( e ) ) ; e = exp_aggr1 ( sql -> sa , e , zero_or_one , 0 , 0 , CARD_ATOM , 0 ) ; } append ( nexps , e ) ; } if ( nexps ) return exp_op ( sql -> sa , nexps , f ) ; } } return sql_error ( sql , 02 , "SELECT:<S2SV_blank>no<S2SV_blank>such<S2SV_blank>operator<S2SV_blank>\'%s\'" , fname ) ; }
|
<S2SV_ModStart> -> data ; sql_subtype anytype = a -> type ; <S2SV_ModStart> sql_init_subtype ( & anytype <S2SV_ModEnd> , st -> <S2SV_ModStart> sql , & anytype <S2SV_ModEnd> , e ,
|
405
|
CWE-000 void compare ( boolean * b , address * a1 , address * a2 ) { int i ; i = 0 ; * b = TRUE ; while ( * b && i < q ) { chkdef ( * a1 + i ) ; chkdef ( * a2 + i ) ; <S2SV_StartBug> if ( store [ * a1 + i ] = store [ * a2 + i ] ) i = i + 1 ; <S2SV_EndBug> else * b = FALSE ; } if ( i == q ) i = i - 1 ; * a1 = * a1 + i ; * a2 = * a2 + i ; }
|
<S2SV_ModStart> + i ] == <S2SV_ModEnd> store [ *
|
406
|
CWE-000 filesystem_t * tmpfs_init ( ) { dev . bus . get_inode = tmpfs_get_inode ; <S2SV_StartBug> dev . root . contents = list_new ( ) ; <S2SV_EndBug> <S2SV_StartBug> dev . freeNodes = 0 ; <S2SV_EndBug> module_register ( & mod , "tmpfs" , NULL , NULL ) ; device_register ( & dev . dev , & mod ) ; device_register_bus ( & dev . dev , FILESYSTEM , & dev . bus ) ; dev . bus . dev = & dev . dev ; return & dev . bus ; }
|
<S2SV_ModStart> ; dev . bus . mkdir = tmpfs_mkdir ; dev . bus . dir_open = tmpfs_dir_open ; dev . bus . dir_close = tmpfs_dir_close ; dev . bus . dir_next = tmpfs_dir_next ; dev . root . node . id = 0 ; dev . root . node . name [ 0 ] = '\\0' ; dev . root . node . type = FDIR ; dev . <S2SV_ModStart> freeNodes = 0 ; dev . nodes = list_new ( ) ; list_add ( dev . nodes , & dev . root )
|
407
|
CWE-000 int monologue_offer_answer ( struct call_monologue * other_ml , GQueue * streams , const struct sdp_ng_flags * flags ) { struct stream_params * sp ; GList * media_iter , * ml_media , * other_ml_media ; struct call_media * media , * other_media ; unsigned int num_ports ; unsigned int rr_calls_ports ; struct call_monologue * monologue = other_ml -> active_dialogue ; struct endpoint_map * em ; struct call * call ; call = monologue -> call ; call -> last_signal = poller_now ; call -> deleted = 0 ; rr_calls_ports = get_algorithm_num_ports ( streams , ALGORITHM_ROUND_ROBIN_CALLS ) ; if ( ! other_ml ) { ilog ( LOG_ERROR , "Incomplete<S2SV_blank>dialogue<S2SV_blank>association" ) ; return - 1 ; } __C_DBG ( "this=" STR_FORMAT "<S2SV_blank>other=" STR_FORMAT , STR_FMT ( & monologue -> tag ) , STR_FMT ( & other_ml -> tag ) ) ; __tos_change ( call , flags ) ; ml_media = other_ml_media = NULL ; str * pcap_path = setup_recording_file ( call , monologue ) ; <S2SV_StartBug> if ( pcap_path != NULL ) { <S2SV_EndBug> fprintf ( call -> meta_fp , "%s\\n" , pcap_path -> s ) ; } for ( media_iter = streams -> head ; media_iter ; media_iter = media_iter -> next ) { sp = media_iter -> data ; __C_DBG ( "processing<S2SV_blank>media<S2SV_blank>stream<S2SV_blank>#%u" , sp -> index ) ; __C_DBG ( "free<S2SV_blank>ports<S2SV_blank>needed<S2SV_blank>for<S2SV_blank>round-robin-calls,<S2SV_blank>left<S2SV_blank>for<S2SV_blank>this<S2SV_blank>call<S2SV_blank>%u" , rr_calls_ports ) ; media = __get_media ( monologue , & ml_media , sp ) ; other_media = __get_media ( other_ml , & other_ml_media , sp ) ; if ( flags && flags -> opmode == OP_OFFER && flags -> reset ) { MEDIA_CLEAR ( media , INITIALIZED ) ; MEDIA_CLEAR ( other_media , INITIALIZED ) ; if ( media -> ice_agent ) ice_restart ( media -> ice_agent ) ; if ( other_media -> ice_agent ) ice_restart ( other_media -> ice_agent ) ; } if ( other_media -> protocol != sp -> protocol ) { other_media -> protocol = sp -> protocol ; media -> protocol = NULL ; } if ( ! media -> protocol ) media -> protocol = other_media -> protocol ; if ( flags && flags -> transport_protocol && other_media -> protocol && other_media -> protocol -> rtp ) media -> protocol = flags -> transport_protocol ; if ( sp -> rtp_endpoint . port ) { bf_copy_same ( & other_media -> media_flags , & sp -> sp_flags , SHARED_FLAG_RTCP_MUX | SHARED_FLAG_ASYMMETRIC | SHARED_FLAG_UNIDIRECTIONAL | SHARED_FLAG_ICE | SHARED_FLAG_TRICKLE_ICE | SHARED_FLAG_ICE_LITE ) ; crypto_params_copy ( & other_media -> sdes_in . params , & sp -> crypto , 1 ) ; other_media -> sdes_in . tag = sp -> sdes_tag ; if ( other_media -> sdes_in . params . crypto_suite ) MEDIA_SET ( other_media , SDES ) ; } __rtp_payload_types ( media , & sp -> rtp_payload_types ) ; bf_copy_same ( & media -> media_flags , & sp -> sp_flags , SP_FLAG_SEND | SP_FLAG_RECV ) ; bf_copy ( & other_media -> media_flags , MEDIA_FLAG_RECV , & sp -> sp_flags , SP_FLAG_SEND ) ; bf_copy ( & other_media -> media_flags , MEDIA_FLAG_SEND , & sp -> sp_flags , SP_FLAG_RECV ) ; if ( sp -> rtp_endpoint . port ) { __dtls_logic ( flags , other_media , sp ) ; __rtcp_mux_logic ( flags , media , other_media ) ; __generate_crypto ( flags , media , other_media ) ; other_media -> desired_family = sp -> rtp_endpoint . address . family ; if ( ! media -> desired_family ) media -> desired_family = other_media -> desired_family ; if ( sp -> desired_family ) media -> desired_family = sp -> desired_family ; } __init_interface ( media , & sp -> direction [ 1 ] , rr_calls_ports ) ; __init_interface ( other_media , & sp -> direction [ 0 ] , rr_calls_ports ) ; if ( media -> logical_intf == NULL || other_media -> logical_intf == NULL ) { goto error_intf ; } __ice_offer ( flags , media , other_media ) ; __ice_start ( other_media ) ; __ice_start ( media ) ; MEDIA_SET ( other_media , INITIALIZED ) ; num_ports = sp -> consecutive_ports ; num_ports *= 2 ; if ( ! sp -> rtp_endpoint . port ) { __disable_streams ( media , num_ports ) ; __disable_streams ( other_media , num_ports ) ; goto init ; } if ( is_addr_unspecified ( & sp -> rtp_endpoint . address ) && ! is_trickle_ice_address ( & sp -> rtp_endpoint ) ) { MEDIA_CLEAR ( media , RECV ) ; MEDIA_CLEAR ( other_media , SEND ) ; } em = __get_endpoint_map ( media , num_ports , & sp -> rtp_endpoint , flags ) ; if ( ! em ) { goto error_ports ; } else { if ( str_cmp ( & sp -> direction [ 1 ] , ALGORITHM_ROUND_ROBIN_CALLS ) == 0 ) { rr_calls_ports -= num_ports ; } } __num_media_streams ( media , num_ports ) ; __assign_stream_fds ( media , & em -> intf_sfds ) ; if ( __num_media_streams ( other_media , num_ports ) ) { if ( __wildcard_endpoint_map ( other_media , num_ports ) ) goto error_ports ; if ( str_cmp ( & sp -> direction [ 0 ] , ALGORITHM_ROUND_ROBIN_CALLS ) == 0 ) { rr_calls_ports -= num_ports ; } } init : if ( __init_streams ( media , other_media , NULL ) ) return - 1 ; if ( __init_streams ( other_media , media , sp ) ) return - 1 ; ice_update ( other_media -> ice_agent , sp ) ; ice_update ( media -> ice_agent , NULL ) ; } return 0 ; error_ports : ilog ( LOG_ERR , "Error<S2SV_blank>allocating<S2SV_blank>media<S2SV_blank>ports" ) ; return ERROR_NO_FREE_PORTS ; error_intf : ilog ( LOG_ERR , "Error<S2SV_blank>finding<S2SV_blank>logical<S2SV_blank>interface<S2SV_blank>with<S2SV_blank>free<S2SV_blank>ports" ) ; return ERROR_NO_FREE_LOGS ; }
|
<S2SV_ModStart> if ( pcap_path != NULL && call -> meta_fp
|
408
|
CWE-000 static void grub_ieee1275_find_options ( void ) { grub_ieee1275_phandle_t root ; grub_ieee1275_phandle_t options ; grub_ieee1275_phandle_t openprom ; grub_ieee1275_phandle_t bootrom ; int rc ; grub_uint32_t realmode = 0 ; char tmp [ 256 ] ; int is_smartfirmware = 0 ; int is_olpc = 0 ; int is_qemu = 0 ; grub_ssize_t actual ; # ifdef __sparc__ grub_ieee1275_set_flag ( GRUB_IEEE1275_FLAG_NO_PARTITION_0 ) ; # endif grub_ieee1275_finddevice ( "/" , & root ) ; grub_ieee1275_finddevice ( "/options" , & options ) ; grub_ieee1275_finddevice ( "/openprom" , & openprom ) ; rc = grub_ieee1275_get_integer_property ( options , "real-mode?" , & realmode , sizeof realmode , 0 ) ; if ( ( ( rc >= 0 ) && realmode ) || ( grub_ieee1275_mmu == 0 ) ) grub_ieee1275_set_flag ( GRUB_IEEE1275_FLAG_REAL_MODE ) ; rc = grub_ieee1275_get_property ( openprom , "CodeGen-copyright" , tmp , sizeof ( tmp ) , 0 ) ; if ( rc >= 0 && ! grub_strncmp ( tmp , "SmartFirmware(tm)" , sizeof ( "SmartFirmware(tm)" ) - 1 ) ) is_smartfirmware = 1 ; rc = grub_ieee1275_get_property ( root , "architecture" , tmp , sizeof ( tmp ) , 0 ) ; if ( rc >= 0 && ! grub_strcmp ( tmp , "OLPC" ) ) is_olpc = 1 ; rc = grub_ieee1275_get_property ( root , "model" , tmp , sizeof ( tmp ) , 0 ) ; if ( rc >= 0 && ( ! grub_strcmp ( tmp , "Emulated<S2SV_blank>PC" ) || ! grub_strcmp ( tmp , "IBM<S2SV_blank>pSeries<S2SV_blank>(emulated<S2SV_blank>by<S2SV_blank>qemu)" ) ) ) { is_qemu = 1 ; } if ( rc >= 0 && grub_strncmp ( tmp , "IBM" , 3 ) == 0 ) <S2SV_StartBug> grub_ieee1275_set_flag ( GRUB_IEEE1275_FLAG_NO_TREE_SCANNING_FOR_DISKS ) ; <S2SV_EndBug> if ( rc >= 0 && grub_strcmp ( tmp , "PowerBook3,3" ) == 0 ) grub_ieee1275_set_flag ( GRUB_IEEE1275_FLAG_BROKEN_REPEAT ) ; rc = grub_ieee1275_get_property ( root , "compatible" , tmp , sizeof ( tmp ) , & actual ) ; if ( rc >= 0 ) { char * ptr ; for ( ptr = tmp ; ptr - tmp < actual ; ptr += grub_strlen ( ptr ) + 1 ) { if ( grub_memcmp ( ptr , "MacRISC" , sizeof ( "MacRISC" ) - 1 ) == 0 && ( ptr [ sizeof ( "MacRISC" ) - 1 ] == 0 || grub_isdigit ( ptr [ sizeof ( "MacRISC" ) - 1 ] ) ) ) { grub_ieee1275_set_flag ( GRUB_IEEE1275_FLAG_BROKEN_ADDRESS_CELLS ) ; grub_ieee1275_set_flag ( GRUB_IEEE1275_FLAG_NO_OFNET_SUFFIX ) ; grub_ieee1275_set_flag ( GRUB_IEEE1275_FLAG_VIRT_TO_REAL_BROKEN ) ; grub_ieee1275_set_flag ( GRUB_IEEE1275_FLAG_CURSORONOFF_ANSI_BROKEN ) ; break ; } } } if ( is_smartfirmware ) { grub_ieee1275_set_flag ( GRUB_IEEE1275_FLAG_BROKEN_OUTPUT ) ; rc = grub_ieee1275_get_property ( openprom , "SmartFirmware-version" , tmp , sizeof ( tmp ) , 0 ) ; if ( rc < 0 ) rc = grub_ieee1275_get_property ( openprom , "firmware-version" , tmp , sizeof ( tmp ) , 0 ) ; if ( rc >= 0 ) { if ( ! grub_strcmp ( tmp , "1.0" ) || ! grub_strcmp ( tmp , "1.1" ) || ! grub_strcmp ( tmp , "1.2" ) || ! grub_strcmp ( tmp , "1.3" ) ) { grub_ieee1275_set_flag ( GRUB_IEEE1275_FLAG_NO_PARTITION_0 ) ; grub_ieee1275_set_flag ( GRUB_IEEE1275_FLAG_0_BASED_PARTITIONS ) ; } } } if ( is_olpc ) { grub_ieee1275_set_flag ( GRUB_IEEE1275_FLAG_OFDISK_SDCARD_ONLY ) ; grub_ieee1275_set_flag ( GRUB_IEEE1275_FLAG_HAS_CURSORONOFF ) ; } if ( is_qemu ) { grub_ieee1275_set_flag ( GRUB_IEEE1275_FLAG_NO_PRE1_5M_CLAIM ) ; grub_ieee1275_set_flag ( GRUB_IEEE1275_FLAG_HAS_CURSORONOFF ) ; } if ( ! grub_ieee1275_finddevice ( "/rom/boot-rom" , & bootrom ) || ! grub_ieee1275_finddevice ( "/boot-rom" , & bootrom ) ) { rc = grub_ieee1275_get_property ( bootrom , "model" , tmp , sizeof ( tmp ) , 0 ) ; if ( rc >= 0 && ! grub_strncmp ( tmp , "PPC<S2SV_blank>Open<S2SV_blank>Hack\'Ware" , sizeof ( "PPC<S2SV_blank>Open<S2SV_blank>Hack\'Ware" ) - 1 ) ) { grub_ieee1275_set_flag ( GRUB_IEEE1275_FLAG_BROKEN_OUTPUT ) ; grub_ieee1275_set_flag ( GRUB_IEEE1275_FLAG_CANNOT_SET_COLORS ) ; grub_ieee1275_set_flag ( GRUB_IEEE1275_FLAG_CANNOT_INTERPRET ) ; grub_ieee1275_set_flag ( GRUB_IEEE1275_FLAG_FORCE_CLAIM ) ; grub_ieee1275_set_flag ( GRUB_IEEE1275_FLAG_NO_ANSI ) ; } } }
|
<S2SV_ModStart> == 0 ) { <S2SV_ModStart> GRUB_IEEE1275_FLAG_NO_TREE_SCANNING_FOR_DISKS ) ; grub_ieee1275_set_flag ( GRUB_IEEE1275_FLAG_DISABLE_VIDEO_SUPPORT ) ; }
|
409
|
CWE-000 int TkpUseWindow ( Tcl_Interp * interp , Tk_Window tkwin , CONST char * string ) { TkWindow * winPtr = ( TkWindow * ) tkwin ; TkWindow * usePtr ; MacDrawable * parent , * macWin ; <S2SV_StartBug> Container * containerPtr ; <S2SV_EndBug> XEvent event ; if ( winPtr -> window != None ) { Tcl_AppendResult ( interp , "can\'t<S2SV_blank>modify<S2SV_blank>container<S2SV_blank>after<S2SV_blank>widget<S2SV_blank>is<S2SV_blank>" "created" , NULL ) ; return TCL_ERROR ; } if ( Tcl_GetInt ( interp , string , ( int * ) & parent ) != TCL_OK ) { return TCL_ERROR ; } usePtr = ( TkWindow * ) Tk_IdToWindow ( winPtr -> display , ( Window ) parent ) ; if ( usePtr != NULL ) { if ( ! ( usePtr -> flags & TK_CONTAINER ) ) { Tcl_AppendResult ( interp , "window<S2SV_blank>\\"" , usePtr -> pathName , "\\"<S2SV_blank>doesn\'t<S2SV_blank>have<S2SV_blank>-container<S2SV_blank>option<S2SV_blank>set" , NULL ) ; return TCL_ERROR ; } } for ( containerPtr = firstContainerPtr ; containerPtr != NULL ; containerPtr = containerPtr -> nextPtr ) { if ( containerPtr -> parent == ( Window ) parent ) { winPtr -> flags |= TK_BOTH_HALVES ; containerPtr -> parentPtr -> flags |= TK_BOTH_HALVES ; break ; } } macWin = ( MacDrawable * ) ckalloc ( sizeof ( MacDrawable ) ) ; if ( macWin == NULL ) { winPtr -> privatePtr = NULL ; return TCL_ERROR ; } macWin -> winPtr = winPtr ; winPtr -> privatePtr = macWin ; macWin -> grafPtr = NULL ; macWin -> context = NULL ; macWin -> clipRgn = NewRgn ( ) ; macWin -> aboveClipRgn = NewRgn ( ) ; macWin -> drawRgn = NewRgn ( ) ; macWin -> referenceCount = 0 ; macWin -> flags = TK_CLIP_INVALID ; macWin -> toplevel = macWin ; macWin -> toplevel -> referenceCount ++ ; winPtr -> flags |= TK_EMBEDDED ; macWin -> flags |= TK_EMBEDDED ; if ( containerPtr == NULL ) { if ( tkMacOSXEmbedHandler == NULL || tkMacOSXEmbedHandler -> registerWinProc ( ( int ) parent , ( Tk_Window ) winPtr ) != TCL_OK ) { Tcl_AppendResult ( interp , "The<S2SV_blank>window<S2SV_blank>ID<S2SV_blank>" , string , "<S2SV_blank>does<S2SV_blank>not<S2SV_blank>correspond<S2SV_blank>to<S2SV_blank>a<S2SV_blank>valid<S2SV_blank>Tk<S2SV_blank>Window." , NULL ) ; return TCL_ERROR ; } else { containerPtr = ( Container * ) ckalloc ( sizeof ( Container ) ) ; containerPtr -> parentPtr = NULL ; containerPtr -> embedded = ( Window ) macWin ; containerPtr -> embeddedPtr = macWin -> winPtr ; containerPtr -> nextPtr = firstContainerPtr ; firstContainerPtr = containerPtr ; } } else { macWin -> xOff = parent -> winPtr -> privatePtr -> xOff + parent -> winPtr -> changes . border_width + winPtr -> changes . x ; macWin -> yOff = parent -> winPtr -> privatePtr -> yOff + parent -> winPtr -> changes . border_width + winPtr -> changes . y ; containerPtr -> embedded = ( Window ) macWin ; containerPtr -> embeddedPtr = macWin -> winPtr ; Tk_CreateEventHandler ( tkwin , StructureNotifyMask , EmbeddedEventProc , ( ClientData ) winPtr ) ; } <S2SV_StartBug> event . xany . serial = Tk_Display ( winPtr ) -> request ; <S2SV_EndBug> event . xany . send_event = False ; event . xany . display = Tk_Display ( winPtr ) ; event . xvisibility . type = VisibilityNotify ; event . xvisibility . window = ( Window ) macWin ; ; event . xvisibility . state = VisibilityUnobscured ; Tk_QueueWindowEvent ( & event , TCL_QUEUE_TAIL ) ; event . xany . serial = Tk_Display ( winPtr ) -> request ; event . xany . send_event = False ; event . xany . display = Tk_Display ( winPtr ) ; event . xvisibility . type = VisibilityNotify ; event . xvisibility . window = ( Window ) macWin ; ; event . xvisibility . state = VisibilityUnobscured ; Tk_QueueWindowEvent ( & event , TCL_QUEUE_TAIL ) ; return TCL_OK ; }
|
<S2SV_ModStart> Container * containerPtr <S2SV_ModEnd> ; if ( <S2SV_ModStart> ) ; } <S2SV_ModEnd> return TCL_OK ;
|
410
|
CWE-000 static int disassemble_lisp_time ( Lisp_Object specified_time , Lisp_Object * phigh , Lisp_Object * plow , Lisp_Object * pusec , Lisp_Object * ppsec ) { Lisp_Object high = make_fixnum ( 0 ) ; Lisp_Object low = specified_time ; Lisp_Object usec = make_fixnum ( 0 ) ; Lisp_Object psec = make_fixnum ( 0 ) ; int len = 4 ; if ( CONSP ( specified_time ) ) { high = XCAR ( specified_time ) ; low = XCDR ( specified_time ) ; if ( CONSP ( low ) ) { Lisp_Object low_tail = XCDR ( low ) ; low = XCAR ( low ) ; if ( CONSP ( low_tail ) ) { usec = XCAR ( low_tail ) ; low_tail = XCDR ( low_tail ) ; if ( CONSP ( low_tail ) ) psec = XCAR ( low_tail ) ; else len = 3 ; } else if ( ! NILP ( low_tail ) ) { usec = low_tail ; len = 3 ; } else len = 2 ; } else len = 2 ; <S2SV_StartBug> if ( ! FIXNUMP ( low ) ) <S2SV_EndBug> return 0 ; } <S2SV_StartBug> else if ( FIXNUMP ( specified_time ) ) <S2SV_EndBug> len = 2 ; * phigh = high ; * plow = low ; * pusec = usec ; * ppsec = psec ; return len ; }
|
<S2SV_ModStart> if ( ! INTEGERP <S2SV_ModEnd> ( low ) <S2SV_ModStart> else if ( INTEGERP <S2SV_ModEnd> ( specified_time )
|
411
|
CWE-000 CO_ReturnError_t CO_NMT_init ( CO_NMT_t * NMT , uint8_t nodeId , void * OD , void ( * state_changed_callback ) ( CO_NMT_internalState_t previous_state , CO_NMT_internalState_t requested_state ) , uint16_t CANidRxNMT , void * CANdev ) { if ( NMT == NULL || CANdev == NULL || NULL == state_changed_callback ) { return CO_ERROR_ILLEGAL_ARGUMENT ; } <S2SV_StartBug> NMT -> operatingState = CO_NMT_INITIALIZING ; <S2SV_EndBug> NMT -> nodeId = nodeId ; NMT -> OD = OD ; NMT -> state_changed_callback = state_changed_callback ; void * nmt_startup = CO_OD_find ( NMT -> OD , 0x1f80 ) ; CO_CANtx_t TXbuff ; TXbuff . ident = CO_CAN_ID_BOOTUP | nodeId ; TXbuff . DLC = 1 ; TXbuff . data [ 0 ] = 0 ; co_driver_send ( NMT -> CANdev , & TXbuff ) ; if ( nmt_startup ) { uint32_t configuration = * ( uint32_t * ) CO_OD_getDataPointer ( nmt_startup , 0 ) ; if ( 0x2 == configuration ) { } else if ( 0x8 == configuration ) { <S2SV_StartBug> NMT -> operatingState = CO_NMT_OPERATIONAL ; <S2SV_EndBug> } else if ( 0x22 == configuration ) { } else if ( 0x28 == configuration ) { } else { <S2SV_StartBug> NMT -> operatingState = CO_NMT_PRE_OPERATIONAL ; <S2SV_EndBug> } } else { <S2SV_StartBug> NMT -> operatingState = CO_NMT_PRE_OPERATIONAL ; <S2SV_EndBug> } NMT -> state_changed_callback ( CO_NMT_INITIALIZING , <S2SV_StartBug> NMT -> operatingState ) ; <S2SV_EndBug> return CO_ERROR_NO ; }
|
<S2SV_ModStart> } NMT -> operating_state <S2SV_ModEnd> = CO_NMT_INITIALIZING ; <S2SV_ModStart> { NMT -> operating_state <S2SV_ModEnd> = CO_NMT_OPERATIONAL ; <S2SV_ModStart> { NMT -> operating_state <S2SV_ModEnd> = CO_NMT_PRE_OPERATIONAL ; <S2SV_ModStart> { NMT -> operating_state <S2SV_ModEnd> = CO_NMT_PRE_OPERATIONAL ; <S2SV_ModStart> , NMT -> operating_state <S2SV_ModEnd> ) ; return
|
412
|
CWE-000 static void init_sessiontable ( struct hash_table * sessions , unsigned int size ) { <S2SV_StartBug> memset ( sessions , 0 , sizeof ( sessions ) ) ; <S2SV_EndBug> sessions -> size = size ; hash_table_init ( sessions ) ; }
|
<S2SV_ModStart> ( sessions , '\\0' <S2SV_ModEnd> , sizeof ( <S2SV_ModStart> , sizeof ( *
|
413
|
CWE-000 static int probe_deint_filters ( struct MPContext * mpctx ) { if ( check_output_format ( mpctx , IMGFMT_VDPAU ) ) { char filter [ 80 ] = "vdpaupp:deint=yes" ; int pref = 0 ; vo_control ( mpctx -> video_out , VOCTRL_GET_PREF_DEINT , & pref ) ; pref = pref < 0 ? - pref : pref ; if ( pref > 0 && pref <= 4 ) { const char * types [ ] = { "" , "first-field" , "bob" , "temporal" , "temporal-spatial" } ; mp_snprintf_cat ( filter , sizeof ( filter ) , ":deint-mode=%s" , types [ pref ] ) ; } probe_deint_filter ( mpctx , filter ) ; return 0 ; } if ( check_output_format ( mpctx , IMGFMT_VAAPI ) && probe_deint_filter ( mpctx , "vavpp" ) ) return 0 ; <S2SV_StartBug> if ( probe_deint_filter ( mpctx , "yadif:mode=field:interlaced-only=yes" ) ) <S2SV_EndBug> return 0 ; return - 1 ; }
|
<S2SV_ModStart> ( mpctx , "yadif" <S2SV_ModEnd> ) ) return
|
414
|
CWE-000 void scan_file ( FILE * fp ) { int ch ; int line_number = 1 ; int column = 0 ; while ( ( ch = getc ( fp ) ) != EOF ) { ++ column ; switch ( ch ) { case LEFT_PARENTHESIS : case LEFT_BRACKET : case LEFT_BRACE : add_to_top ( ch , line_number , column ) ; break ; case RIGHT_PARENTHESIS : case RIGHT_BRACKET : case RIGHT_BRACE : remove_from_top ( ch , line_number , column ) ; break ; case '\\n' : ++ line_number ; column = 0 ; break ; default : break ; } } if ( ! is_empty ( ) ) { fprintf ( stderr , "Error:<S2SV_blank>There<S2SV_blank>are<S2SV_blank>open<S2SV_blank>tag(s)<S2SV_blank>that<S2SV_blank>are<S2SV_blank>not<S2SV_blank>closed\\n" ) ; <S2SV_StartBug> fprintf ( stderr , "Tag:<S2SV_blank>%c<S2SV_blank>on<S2SV_blank>line<S2SV_blank>%d<S2SV_blank>column<S2SV_blank>%d\\n" , get_top_tag ( ) , get_top_line ( ) , get_top_col ( ) ) ; <S2SV_EndBug> exit ( EXIT_FAILURE ) ; } printf ( "Tags<S2SV_blank>are<S2SV_blank>nested<S2SV_blank>properly\\n" ) ; }
|
<S2SV_ModStart> "Error:<S2SV_blank>There<S2SV_blank>are<S2SV_blank>open<S2SV_blank>tag(s)<S2SV_blank>that<S2SV_blank>are<S2SV_blank>not<S2SV_blank>closed\\n" ) ; <S2SV_ModEnd> exit ( EXIT_FAILURE
|
415
|
CWE-000 void do_cycles ( void ) { struct timeval start , last , now ; unsigned long x , sum ; gettimeofday ( & start , NULL ) ; last = start ; count [ myid ] = 0 ; total [ myid ] = 0 ; iter [ myid ] = 0 ; do { sum = 1 ; for ( x = 1 ; x < 250000 ; x ++ ) { if ( ( x % 5000 ) == 0 ) pthread_kill ( pthread_self ( ) , SIGUSR1 ) ; sum += x ; } iter [ myid ] ++ ; gettimeofday ( & now , NULL ) ; if ( now . tv_sec > last . tv_sec ) { printf ( "%ld:<S2SV_blank>myid<S2SV_blank>=<S2SV_blank>%3d,<S2SV_blank>fd<S2SV_blank>=<S2SV_blank>%3d,<S2SV_blank>count<S2SV_blank>=<S2SV_blank>%4ld,<S2SV_blank>iter<S2SV_blank>=<S2SV_blank>%4ld,<S2SV_blank>rate<S2SV_blank>=<S2SV_blank>%ld/Kiter\\n" , <S2SV_StartBug> now . tv_sec - start . tv_sec , <S2SV_EndBug> myid , fd2ov [ myid ] . fd , count [ myid ] , iter [ myid ] , ( 1000 * count [ myid ] ) / iter [ myid ] ) ; count [ myid ] = 0 ; iter [ myid ] = 0 ; last = now ; } } while ( now . tv_sec < start . tv_sec + program_time ) ; }
|
<S2SV_ModStart> ( "%ld:<S2SV_blank>myid<S2SV_blank>=<S2SV_blank>%3d,<S2SV_blank>fd<S2SV_blank>=<S2SV_blank>%3d,<S2SV_blank>count<S2SV_blank>=<S2SV_blank>%4ld,<S2SV_blank>iter<S2SV_blank>=<S2SV_blank>%4ld,<S2SV_blank>rate<S2SV_blank>=<S2SV_blank>%ld/Kiter\\n" , ( long ) ( <S2SV_ModStart> start . tv_sec )
|
416
|
CWE-000 int recvall ( int s , unsigned char * buf , int * len ) { int total = 0 ; int bytesleft = * len ; <S2SV_StartBug> int n ; <S2SV_EndBug> while ( total < * len ) { n = recv ( s , buf + total , bytesleft , 0 ) ; if ( n == - 1 ) { break ; } total += n ; bytesleft -= n ; } * len = total ; return n == - 1 ? - 1 : 0 ; }
|
<S2SV_ModStart> ; int n = 0
|
417
|
CWE-000 int amdgpu_vcn_dec_ring_test_ib ( struct amdgpu_ring * ring , long timeout ) { struct dma_fence * fence ; long r ; r = amdgpu_vcn_dec_get_create_msg ( ring , 1 , NULL ) ; if ( r ) { DRM_ERROR ( "amdgpu:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>create<S2SV_blank>msg<S2SV_blank>(%ld).\\n" , r ) ; goto error ; } <S2SV_StartBug> r = amdgpu_vcn_dec_get_destroy_msg ( ring , 1 , true , & fence ) ; <S2SV_EndBug> if ( r ) { DRM_ERROR ( "amdgpu:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>destroy<S2SV_blank>ib<S2SV_blank>(%ld).\\n" , r ) ; goto error ; } r = dma_fence_wait_timeout ( fence , false , timeout ) ; if ( r == 0 ) { DRM_ERROR ( "amdgpu:<S2SV_blank>IB<S2SV_blank>test<S2SV_blank>timed<S2SV_blank>out.\\n" ) ; r = - ETIMEDOUT ; } else if ( r < 0 ) { DRM_ERROR ( "amdgpu:<S2SV_blank>fence<S2SV_blank>wait<S2SV_blank>failed<S2SV_blank>(%ld).\\n" , r ) ; } else { DRM_DEBUG ( "ib<S2SV_blank>test<S2SV_blank>on<S2SV_blank>ring<S2SV_blank>%d<S2SV_blank>succeeded\\n" , ring -> idx ) ; r = 0 ; } dma_fence_put ( fence ) ; error : return r ; }
|
<S2SV_ModStart> ring , 1 <S2SV_ModEnd> , & fence
|
418
|
CWE-000 int main ( int argc , char * * argv ) { <S2SV_StartBug> float a , b , c , x1 , x2 ; <S2SV_EndBug> printf ( "\\nEnter<S2SV_blank>values<S2SV_blank>for<S2SV_blank>a,<S2SV_blank>b<S2SV_blank>and<S2SV_blank>c:\\n" ) ; <S2SV_StartBug> scanf ( "%f<S2SV_blank>%f<S2SV_blank>%f" , & a , & b , & c ) ; <S2SV_EndBug> <S2SV_StartBug> x1 = - b + sqrt ( b * b - ( 2 * a * c ) ) / ( 2 * a ) ; <S2SV_EndBug> <S2SV_StartBug> x2 = - b - sqrt ( pow ( b , 2 ) - 2 * a * c ) / ( 2 * a ) ; <S2SV_EndBug> printf ( "Solution:<S2SV_blank>x1<S2SV_blank>=<S2SV_blank>%f,<S2SV_blank>x2<S2SV_blank>=<S2SV_blank>%f.\\n\\n" , x1 , x2 ) ; }
|
<S2SV_ModStart> argv ) { double <S2SV_ModEnd> a , b <S2SV_ModStart> ; scanf ( "%1f<S2SV_blank>%1f<S2SV_blank>%1f" <S2SV_ModEnd> , & a <S2SV_ModStart> ; x1 = ( <S2SV_ModStart> - b + ( <S2SV_ModEnd> sqrt ( pow <S2SV_ModStart> a * c ) ) ) / ( 2 * a ) ; x2 = ( - b - ( sqrt ( pow ( b , 2 ) - 2 * a * c ) )
|
419
|
CWE-000 static void script_read_file ( js_State * J ) { <S2SV_StartBug> int limit = js_isundefined ( J , 2 ) ? - 1 : js_tonumber ( J , 2 ) ; <S2SV_EndBug> push_file_content ( J , js_tostring ( J , 1 ) , limit ) ; }
|
<S2SV_ModStart> - 1 : jsL_checkint <S2SV_ModEnd> ( J ,
|
420
|
CWE-000 static int xlator_members_free ( xlator_t * xl ) { volume_opt_list_t * vol_opt = NULL ; volume_opt_list_t * tmp = NULL ; if ( ! xl ) return 0 ; GF_FREE ( xl -> name ) ; GF_FREE ( xl -> type ) ; <S2SV_StartBug> if ( xl -> dlhandle ) <S2SV_EndBug> dlclose ( xl -> dlhandle ) ; if ( xl -> options ) dict_unref ( xl -> options ) ; xlator_list_destroy ( xl -> children ) ; xlator_list_destroy ( xl -> parents ) ; list_for_each_entry_safe ( vol_opt , tmp , & xl -> volume_options , list ) { list_del_init ( & vol_opt -> list ) ; GF_FREE ( vol_opt ) ; } return 0 ; }
|
<S2SV_ModStart> ; if ( ! ( xl -> ctx && xl -> ctx -> cmd_args . valgrind ) &&
|
421
|
CWE-000 char * * get_arr ( int y , int x ) { char * * res ; int len ; res = ( char * * ) malloc ( ++ y * sizeof ( char * ) ) ; res [ -- y ] = NULL ; while ( -- y >= 0 ) { <S2SV_StartBug> res [ y ] = ft_strnew ( x ) ; <S2SV_EndBug> len = - 1 ; while ( ++ len < x ) res [ y ] [ len ] = '.' ; } return ( res ) ; }
|
<S2SV_ModStart> ft_strnew ( x + 1
|
422
|
CWE-000 TPiece addPiece ( int pathCount , int times ) { <S2SV_StartBug> if ( pieceCount >= maxPieces ) { <S2SV_EndBug> maxPieces = maxPieces ? maxPieces * 2 : 4 ; pieces = ( const TPiece * ) realloc ( ( TPiece * ) pieces , maxPieces * sizeof ( TPiece ) ) ; pieceMaxInstances = ( int * ) realloc ( pieceMaxInstances , maxPieces * sizeof ( int ) ) ; if ( pieceCount == 1 ) { ( ( TPiece * ) pieces ) [ 0 ] = ( const TPiece ) malloc ( sizeof ( TPiece ) ) ; <S2SV_StartBug> ( ( TPiece * ) pieces ) [ 0 ] [ 0 ] = 0 ; <S2SV_EndBug> pieceMaxInstances [ 0 ] = 0 ; } } if ( pathCount > maxPathCount ) { maxPathCount = pathCount ; } ( ( TPiece * ) pieces ) [ pieceCount ] = ( const TPiece ) malloc ( ( pathCount + 1 ) * sizeof ( TPiece ) ) ; <S2SV_StartBug> pieceMaxInstances [ pieceCount ] = times ; <S2SV_EndBug> ++ pieceCount ; return ( ( TPiece * ) pieces ) [ pieceCount - 1 ] ; }
|
<S2SV_ModStart> times ) { extendPieces ( pathCount <S2SV_ModEnd> ) ; ( <S2SV_ModStart> pieces ) [ pieceCount - 1 <S2SV_ModEnd> ] = ( <S2SV_ModStart> pieceMaxInstances [ pieceCount - 1 <S2SV_ModStart> ] = times <S2SV_ModEnd> ; return (
|
423
|
CWE-000 static const char * image_format_to_string ( aom_img_fmt_t f ) { switch ( f ) { case AOM_IMG_FMT_I420 : return "I420" ; case AOM_IMG_FMT_I422 : return "I422" ; case AOM_IMG_FMT_I444 : return "I444" ; case AOM_IMG_FMT_YV12 : return "YV12" ; <S2SV_StartBug> case AOM_IMG_FMT_I42016 : return "I42016" ; <S2SV_EndBug> case AOM_IMG_FMT_I42216 : return "I42216" ; case AOM_IMG_FMT_I44416 : return "I44416" ; default : return "Other" ; } }
|
<S2SV_ModStart> "YV12" ; case AOM_IMG_FMT_YV1216 : return "YV1216" ; case
|
424
|
CWE-000 static bfd_reloc_status_type ppc64_elf_ha_reloc ( bfd * abfd , arelent * reloc_entry , asymbol * symbol , void * data , asection * input_section , bfd * output_bfd , char * * error_message ) { enum elf_ppc64_reloc_type r_type ; long insn ; bfd_size_type octets ; <S2SV_StartBug> bfd_vma value ; <S2SV_EndBug> if ( output_bfd != NULL ) return bfd_elf_generic_reloc ( abfd , reloc_entry , symbol , data , input_section , output_bfd , error_message ) ; reloc_entry -> addend += 0x8000 ; r_type = reloc_entry -> howto -> type ; if ( r_type != R_PPC64_REL16DX_HA ) return bfd_reloc_continue ; value = 0 ; if ( ! bfd_is_com_section ( symbol -> section ) ) value = symbol -> value ; value += ( reloc_entry -> addend + symbol -> section -> output_offset + symbol -> section -> output_section -> vma ) ; value -= ( reloc_entry -> address + input_section -> output_offset + input_section -> output_section -> vma ) ; <S2SV_StartBug> value = ( bfd_signed_vma ) value >> 16 ; <S2SV_EndBug> octets = reloc_entry -> address * bfd_octets_per_byte ( abfd ) ; insn = bfd_get_32 ( abfd , ( bfd_byte * ) data + octets ) ; insn &= ~ 0x1fffc1 ; <S2SV_StartBug> insn |= ( value & 0xffc1 ) | ( ( value & 0x3e ) << 15 ) ; <S2SV_EndBug> bfd_put_32 ( abfd , insn , ( bfd_byte * ) data + octets ) ; <S2SV_StartBug> if ( value + 0x8000 > 0xffff ) <S2SV_EndBug> return bfd_reloc_overflow ; return bfd_reloc_ok ; }
|
<S2SV_ModStart> ; bfd_vma value , field <S2SV_ModStart> vma ) ; field <S2SV_ModEnd> = ( bfd_signed_vma <S2SV_ModStart> insn |= ( field <S2SV_ModEnd> & 0xffc1 ) <S2SV_ModStart> | ( ( field <S2SV_ModEnd> & 0x3e ) <S2SV_ModStart> ( value + 0x80000000 > 0xffffffff <S2SV_ModEnd> ) return bfd_reloc_overflow
|
425
|
CWE-000 int perform_file ( instruction_t * opchecker , char * input ) { FILE * opn ; char * uop , * ptr = NULL ; size_t n ; stack_t * stack = NULL ; unsigned int i , lnum = 0 ; opn = info . file = fopen ( input , "r" ) ; if ( opn == NULL ) { fprintf ( stderr , "Error:<S2SV_blank>Can\'t<S2SV_blank>open<S2SV_blank>file<S2SV_blank><file>\\n" ) ; exit ( EXIT_FAILURE ) ; } while ( getline ( & ptr , & n , opn ) != - 1 ) { lnum ++ ; info . buf = ptr ; uop = strtok ( ptr , DELIMITERS ) ; <S2SV_StartBug> if ( uop [ 0 ] == '#' ) <S2SV_EndBug> continue ; for ( i = 0 ; opchecker [ i ] . opcode != NULL ; i ++ ) { if ( strcmp ( uop , opchecker [ i ] . opcode ) == 0 ) { opchecker [ i ] . f ( & stack , lnum ) ; break ; } } if ( opchecker [ i ] . opcode == NULL ) { fprintf ( stderr , "L%u:<S2SV_blank>unknown<S2SV_blank>instruction<S2SV_blank>%s\\n" , lnum , uop ) ; freeit ( & stack ) ; exit ( EXIT_FAILURE ) ; } } freeit ( & stack ) ; return ( EXIT_SUCCESS ) ; }
|
<S2SV_ModStart> if ( uop == NULL || uop
|
426
|
CWE-000 DFA new_DFA ( int nstates ) { <S2SV_StartBug> DFA newDFA = ( DFA ) malloc ( sizeof ( struct DFA ) ) ; <S2SV_EndBug> newDFA -> startState = 0 ; newDFA -> states = nstates ; <S2SV_StartBug> return newDFA ; <S2SV_EndBug> }
|
<S2SV_ModStart> nstates ) { struct DFA * <S2SV_ModEnd> newDFA = ( <S2SV_ModStart> newDFA = ( struct DFA * <S2SV_ModEnd> ) malloc ( <S2SV_ModStart> = nstates ; newDFA -> acceptingStates = ( bool * ) calloc ( nstates , sizeof ( bool ) ) ; newDFA -> transition = ( char * * ) calloc ( 128 , sizeof ( char ) ) ;
|
427
|
CWE-000 static PyObject * array_can_cast_safely ( PyObject * NPY_UNUSED ( self ) , PyObject * args , PyObject * kwds ) { PyObject * from_obj = NULL ; PyArray_Descr * d1 = NULL ; PyArray_Descr * d2 = NULL ; npy_bool ret ; PyObject * retobj = NULL ; NPY_CASTING casting = NPY_SAFE_CASTING ; <S2SV_StartBug> static char * kwlist [ ] = { "from" , "to" , "casting" , NULL } ; <S2SV_EndBug> if ( ! PyArg_ParseTupleAndKeywords ( args , kwds , "OO&|O&:can_cast" , kwlist , & from_obj , PyArray_DescrConverter2 , & d2 , PyArray_CastingConverter , & casting ) ) { goto finish ; } if ( d2 == NULL ) { PyErr_SetString ( PyExc_TypeError , "did<S2SV_blank>not<S2SV_blank>understand<S2SV_blank>one<S2SV_blank>of<S2SV_blank>the<S2SV_blank>types;<S2SV_blank>\'None\'<S2SV_blank>not<S2SV_blank>accepted" ) ; goto finish ; } if ( PyArray_Check ( from_obj ) ) { ret = PyArray_CanCastArrayTo ( ( PyArrayObject * ) from_obj , d2 , casting ) ; } else if ( PyArray_IsScalar ( from_obj , Generic ) || PyArray_IsPythonNumber ( from_obj ) ) { PyArrayObject * arr ; arr = ( PyArrayObject * ) PyArray_FROM_O ( from_obj ) ; if ( arr == NULL ) { goto finish ; } ret = PyArray_CanCastArrayTo ( arr , d2 , casting ) ; Py_DECREF ( arr ) ; } else { if ( ! PyArray_DescrConverter2 ( from_obj , & d1 ) || d1 == NULL ) { PyErr_SetString ( PyExc_TypeError , "did<S2SV_blank>not<S2SV_blank>understand<S2SV_blank>one<S2SV_blank>of<S2SV_blank>the<S2SV_blank>types;<S2SV_blank>\'None\'<S2SV_blank>not<S2SV_blank>accepted" ) ; goto finish ; } ret = PyArray_CanCastTypeTo ( d1 , d2 , casting ) ; } retobj = ret ? Py_True : Py_False ; Py_INCREF ( retobj ) ; finish : Py_XDECREF ( d1 ) ; Py_XDECREF ( d2 ) ; return retobj ; }
|
<S2SV_ModStart> ] = { "from_" <S2SV_ModEnd> , "to" ,
|
428
|
CWE-000 <S2SV_StartBug> void sdb_data_series_write_chunk ( sdb_data_series_t * series , <S2SV_EndBug> sdb_data_chunk_t * chunk , sdb_data_point_t * points , int count ) { if ( count == 0 ) { <S2SV_StartBug> return ; <S2SV_EndBug> } if ( chunk -> end < points [ 0 ] . time ) { <S2SV_StartBug> sdb_data_series_chunk_memcpy ( series , chunk , chunk -> number_of_points , points , count ) ; <S2SV_EndBug> } else { int buffer_count = count + chunk -> number_of_points ; sdb_data_points_range_t range = sdb_data_chunk_read ( chunk , SDB_TIMESTAMP_MIN , SDB_TIMESTAMP_MAX ) ; sdb_data_point_t * buffer = ( sdb_data_point_t * ) sdb_alloc ( buffer_count * sizeof ( sdb_data_point_t ) ) ; sdb_data_point_t * content = range . points ; int points_pos = count - 1 ; int content_pos = range . number_of_points - 1 ; int duplicated_count = 0 ; for ( int i = buffer_count - 1 ; i >= duplicated_count ; i -- ) { if ( points_pos < 0 ) { buffer [ i ] = content [ content_pos -- ] ; } else if ( content_pos < 0 ) { buffer [ i ] = points [ points_pos -- ] ; } else if ( points [ points_pos ] . time < content [ content_pos ] . time ) { buffer [ i ] = content [ content_pos -- ] ; } else if ( points [ points_pos ] . time == content [ content_pos ] . time ) { buffer [ i ] = points [ points_pos -- ] ; content_pos -- ; duplicated_count ++ ; } else { buffer [ i ] = points [ points_pos -- ] ; } } <S2SV_StartBug> sdb_data_series_chunk_memcpy ( series , chunk , 0 , buffer + duplicated_count , buffer_count - duplicated_count ) ; <S2SV_EndBug> sdb_free ( buffer ) ; } <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> int <S2SV_ModEnd> sdb_data_series_write_chunk ( sdb_data_series_t <S2SV_ModStart> ) { return 0 ; } int write_result = - 1 ; <S2SV_ModEnd> if ( chunk <S2SV_ModStart> time ) { write_result = <S2SV_ModStart> ; } } write_result = <S2SV_ModStart> ) ; } return write_result ;
|
429
|
CWE-000 EC_BOOL cflv_content_direct_header_out_rsp_status_filter ( const UINT32 cflv_md_id ) { CFLV_MD * cflv_md ; ; const char * k ; char * v ; uint32_t status ; # if ( SWITCH_ON == CFLV_DEBUG_SWITCH ) if ( CFLV_MD_ID_CHECK_INVALID ( cflv_md_id ) ) { sys_log ( LOGSTDOUT , "error:cflv_content_direct_header_out_rsp_status_filter:<S2SV_blank>cflv<S2SV_blank>module<S2SV_blank>#0x%lx<S2SV_blank>not<S2SV_blank>started.\\n" , cflv_md_id ) ; dbg_exit ( MD_CFLV , cflv_md_id ) ; } # endif cflv_md = CFLV_MD_GET ( cflv_md_id ) ; k = ( const char * ) "Response-Status" ; v = chttp_rsp_get_header ( CFLV_MD_CHTTP_RSP ( cflv_md ) , k ) ; if ( NULL_PTR != v ) { uint32_t response_status ; chttp_rsp_del_header ( CFLV_MD_CHTTP_RSP ( cflv_md ) , k ) ; response_status = c_str_to_uint32_t ( v ) ; if ( CHTTP_NOT_FOUND == response_status ) { cflv_set_ngx_rc ( cflv_md_id , CHTTP_NOT_FOUND , LOC_CFLV_0031 ) ; CHTTP_RSP_STATUS ( CFLV_MD_CHTTP_RSP ( cflv_md ) ) = response_status ; dbg_log ( SEC_0146_CFLV , 9 ) ( LOGSTDOUT , "[DEBUG]<S2SV_blank>cflv_content_direct_header_out_rsp_status_filter:<S2SV_blank>" "[cngx]<S2SV_blank>found<S2SV_blank>404<S2SV_blank>=><S2SV_blank>response<S2SV_blank>status<S2SV_blank>=<S2SV_blank>%ld\\n" , <S2SV_StartBug> k , <S2SV_EndBug> CHTTP_RSP_STATUS ( CFLV_MD_CHTTP_RSP ( cflv_md ) ) ) ; return ( EC_TRUE ) ; } } status = CHTTP_RSP_STATUS ( CFLV_MD_CHTTP_RSP ( cflv_md ) ) ; dbg_log ( SEC_0146_CFLV , 9 ) ( LOGSTDOUT , "[DEBUG]<S2SV_blank>cflv_content_direct_header_out_rsp_status_filter:<S2SV_blank>" "response<S2SV_blank>status<S2SV_blank>=<S2SV_blank>%u<S2SV_blank>[before]\\n" , status ) ; if ( CHTTP_OK != status && CHTTP_PARTIAL_CONTENT != status ) { dbg_log ( SEC_0146_CFLV , 9 ) ( LOGSTDOUT , "[DEBUG]<S2SV_blank>cflv_content_direct_header_out_rsp_status_filter:<S2SV_blank>" "unchangeable<S2SV_blank>=><S2SV_blank>response<S2SV_blank>status<S2SV_blank>=<S2SV_blank>%u<S2SV_blank>[after]\\n" , CHTTP_RSP_STATUS ( CFLV_MD_CHTTP_RSP ( cflv_md ) ) ) ; return ( EC_TRUE ) ; } if ( BIT_TRUE == CFLV_MD_CNGX_RANGE_EXIST_FLAG ( cflv_md ) ) { CHTTP_RSP_STATUS ( CFLV_MD_CHTTP_RSP ( cflv_md ) ) = CHTTP_PARTIAL_CONTENT ; dbg_log ( SEC_0146_CFLV , 9 ) ( LOGSTDOUT , "[DEBUG]<S2SV_blank>cflv_content_direct_header_out_rsp_status_filter:<S2SV_blank>" "range<S2SV_blank>exist<S2SV_blank>=><S2SV_blank>response<S2SV_blank>status<S2SV_blank>=<S2SV_blank>%u<S2SV_blank>[after]\\n" , CHTTP_RSP_STATUS ( CFLV_MD_CHTTP_RSP ( cflv_md ) ) ) ; return ( EC_TRUE ) ; } CHTTP_RSP_STATUS ( CFLV_MD_CHTTP_RSP ( cflv_md ) ) = CHTTP_OK ; dbg_log ( SEC_0146_CFLV , 9 ) ( LOGSTDOUT , "[DEBUG]<S2SV_blank>cflv_content_direct_header_out_rsp_status_filter:<S2SV_blank>" "response<S2SV_blank>status<S2SV_blank>=<S2SV_blank>%u<S2SV_blank>[after]\\n" , CHTTP_RSP_STATUS ( CFLV_MD_CHTTP_RSP ( cflv_md ) ) ) ; return ( EC_TRUE ) ; }
|
<S2SV_ModStart> "[DEBUG]<S2SV_blank>cflv_content_direct_header_out_rsp_status_filter:<S2SV_blank>" "[cngx]<S2SV_blank>found<S2SV_blank>404<S2SV_blank>=><S2SV_blank>response<S2SV_blank>status<S2SV_blank>=<S2SV_blank>%ld\\n" , <S2SV_ModEnd> CHTTP_RSP_STATUS ( CFLV_MD_CHTTP_RSP
|
430
|
CWE-000 static struct tlv_extra * msg_tlv_prepare ( struct ptp_message * msg , int length ) { struct tlv_extra * extra , * tmp ; uint8_t * ptr ; ptr = msg_suffix ( msg ) ; if ( ! ptr ) { pr_err ( "TLV<S2SV_blank>on<S2SV_blank>%s<S2SV_blank>not<S2SV_blank>allowed" , msg_type_string ( msg_type ( msg ) ) ) ; return NULL ; } tmp = TAILQ_LAST ( & msg -> tlv_list , tlv_list ) ; if ( tmp ) { <S2SV_StartBug> ptr = ( uint8_t * ) tmp -> tlv ; <S2SV_EndBug> ptr += tmp -> tlv -> length ; } if ( ( unsigned long ) ( ptr + length ) > ( unsigned long ) ( & msg -> tail_room ) ) { pr_debug ( "cannot<S2SV_blank>fit<S2SV_blank>TLV<S2SV_blank>of<S2SV_blank>length<S2SV_blank>%d<S2SV_blank>into<S2SV_blank>message" , length ) ; return NULL ; } extra = tlv_extra_alloc ( ) ; if ( ! extra ) { pr_err ( "failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>TLV<S2SV_blank>descriptor" ) ; return NULL ; } extra -> tlv = ( struct TLV * ) ptr ; return extra ; }
|
<S2SV_ModStart> tmp -> tlv ; ptr += sizeof ( tmp -> tlv -> type ) ; ptr += sizeof ( tmp -> tlv -> length )
|
431
|
CWE-000 BankAccount * new_BankAccount ( int idAccount , int dni , int isStudent ) { BankAccount * bankAccount = malloc ( sizeof ( BankAccount ) ) ; bankAccount -> idBankAccount = idAccount ; bankAccount -> dni = dni ; bankAccount -> isStudent = isStudent ; if ( isStudent ) bankAccount -> maintenance = 0 ; else bankAccount -> maintenance = 100 ; <S2SV_StartBug> time_t now = time ( 0 ) ; <S2SV_EndBug> bankAccount -> openingDate = localtime ( & now ) ; return bankAccount ; }
|
<S2SV_ModStart> = 100 ; bankAccount -> openingDate <S2SV_ModEnd> = time ( <S2SV_ModStart> time ( 0 <S2SV_ModEnd> ) ; return
|
432
|
CWE-000 static int qseecom_load_external_elf ( struct qseecom_dev_handle * data , void __user * argp ) { struct ion_handle * ihandle ; struct qseecom_load_img_req load_img_req ; int ret ; int set_cpu_ret = 0 ; ion_phys_addr_t pa = 0 ; size_t len ; struct cpumask mask ; struct qseecom_load_app_ireq load_req ; struct qseecom_command_scm_resp resp ; if ( copy_from_user ( & load_img_req , ( void __user * ) argp , sizeof ( struct qseecom_load_img_req ) ) ) { pr_err ( "copy_from_user<S2SV_blank>failed\\n" ) ; return - EFAULT ; } ihandle = ion_import_dma_buf ( qseecom . ion_clnt , load_img_req . ifd_data_fd ) ; if ( IS_ERR_OR_NULL ( ihandle ) ) { pr_err ( "Ion<S2SV_blank>client<S2SV_blank>could<S2SV_blank>not<S2SV_blank>retrieve<S2SV_blank>the<S2SV_blank>handle\\n" ) ; return - ENOMEM ; } ret = ion_phys ( qseecom . ion_clnt , ihandle , & pa , & len ) ; if ( ret ) { pr_err ( "Cannot<S2SV_blank>get<S2SV_blank>phys_addr<S2SV_blank>for<S2SV_blank>the<S2SV_blank>Ion<S2SV_blank>Client,<S2SV_blank>ret<S2SV_blank>=<S2SV_blank>%d\\n" , ret ) ; return ret ; } load_req . qsee_cmd_id = QSEOS_LOAD_EXTERNAL_ELF_COMMAND ; load_req . mdt_len = load_img_req . mdt_len ; load_req . img_len = load_img_req . img_len ; load_req . phy_addr = ( uint32_t ) pa ; mask = CPU_MASK_CPU0 ; set_cpu_ret = set_cpus_allowed_ptr ( current , & mask ) ; if ( set_cpu_ret ) { pr_err ( "set_cpus_allowed_ptr<S2SV_blank>failed<S2SV_blank>:<S2SV_blank>ret<S2SV_blank>%d\\n" , set_cpu_ret ) ; ret = - EFAULT ; goto exit_ion_free ; } if ( qseecom . support_bus_scaling ) { mutex_lock ( & qsee_bw_mutex ) ; ret = __qseecom_register_bus_bandwidth_needs ( data , MEDIUM ) ; mutex_unlock ( & qsee_bw_mutex ) ; if ( ret ) { ret = - EIO ; goto exit_cpu_restore ; } } ret = __qseecom_enable_clk_scale_up ( data ) ; if ( ret ) { ret = - EIO ; goto exit_register_bus_bandwidth_needs ; } <S2SV_StartBug> msm_ion_do_cache_op ( qseecom . ion_clnt , ihandle , NULL , len , <S2SV_EndBug> ION_IOC_CLEAN_INV_CACHES ) ; <S2SV_StartBug> ret = qseecom_scm_call ( SCM_SVC_TZSCHEDULER , 1 , & load_req , <S2SV_EndBug> sizeof ( struct qseecom_load_app_ireq ) , & resp , sizeof ( resp ) ) ; if ( ret ) { pr_err ( "scm_call<S2SV_blank>to<S2SV_blank>load<S2SV_blank>failed<S2SV_blank>:<S2SV_blank>ret<S2SV_blank>%d\\n" , ret ) ; ret = - EFAULT ; goto exit_disable_clock ; } <S2SV_StartBug> switch ( resp . result ) { <S2SV_EndBug> case QSEOS_RESULT_SUCCESS : break ; case QSEOS_RESULT_INCOMPLETE : pr_err ( "%s:<S2SV_blank>qseos<S2SV_blank>result<S2SV_blank>incomplete\\n" , __func__ ) ; ret = __qseecom_process_incomplete_cmd ( data , & resp ) ; if ( ret ) pr_err ( "process_incomplete_cmd<S2SV_blank>failed:<S2SV_blank>err:<S2SV_blank>%d\\n" , ret ) ; break ; case QSEOS_RESULT_FAILURE : pr_err ( "scm_call<S2SV_blank>rsp.result<S2SV_blank>is<S2SV_blank>QSEOS_RESULT_FAILURE\\n" ) ; ret = - EFAULT ; break ; default : pr_err ( "scm_call<S2SV_blank>response<S2SV_blank>result<S2SV_blank>%d<S2SV_blank>not<S2SV_blank>supported\\n" , resp . result ) ; ret = - EFAULT ; break ; } exit_disable_clock : __qseecom_disable_clk_scale_down ( data ) ; exit_register_bus_bandwidth_needs : if ( qseecom . support_bus_scaling ) { mutex_lock ( & qsee_bw_mutex ) ; ret = qseecom_unregister_bus_bandwidth_needs ( data ) ; mutex_unlock ( & qsee_bw_mutex ) ; } exit_cpu_restore : mask = CPU_MASK_ALL ; set_cpu_ret = set_cpus_allowed_ptr ( current , & mask ) ; if ( set_cpu_ret ) { pr_err ( "set_cpus_allowed_ptr<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>restore<S2SV_blank>mask:<S2SV_blank>ret<S2SV_blank>%d\\n" , set_cpu_ret ) ; ret = - EFAULT ; } exit_ion_free : if ( ! IS_ERR_OR_NULL ( ihandle ) ) ion_free ( qseecom . ion_clnt , ihandle ) ; return ret ; }
|
<S2SV_ModStart> exit_register_bus_bandwidth_needs ; } ret = <S2SV_ModStart> ION_IOC_CLEAN_INV_CACHES ) ; if ( ret ) { pr_err ( "cache<S2SV_blank>operation<S2SV_blank>failed<S2SV_blank>%d\\n" , ret ) <S2SV_ModEnd> ; goto exit_disable_clock <S2SV_ModStart> exit_disable_clock ; } ret = qseecom_scm_call ( SCM_SVC_TZSCHEDULER , 1 , & load_req , sizeof ( struct qseecom_load_app_ireq ) , & resp , sizeof ( resp ) ) ; if ( ret ) { pr_err ( "scm_call<S2SV_blank>to<S2SV_blank>load<S2SV_blank>failed<S2SV_blank>:<S2SV_blank>ret<S2SV_blank>%d\\n" , ret ) ; ret = - EFAULT ; goto exit_disable_clock ; }
|
433
|
CWE-000 static void _sde_sspp_setup_rgb ( struct sde_mdss_cfg * sde_cfg , struct sde_sspp_cfg * sspp , struct sde_sspp_sub_blks * sblk , bool * prop_exists , struct sde_prop_value * prop_value , u32 * rgb_count ) { sblk -> maxupscale = MAX_SSPP_UPSCALE ; sblk -> maxdwnscale = MAX_SSPP_DOWNSCALE ; sblk -> format_list = plane_formats ; sspp -> id = SSPP_RGB0 + * rgb_count ; <S2SV_StartBug> snprintf ( sspp -> name , SDE_HW_BLK_NAME_LEN , "sspp_%u" , sspp -> id ) ; <S2SV_EndBug> sspp -> clk_ctrl = SDE_CLK_CTRL_RGB0 + * rgb_count ; sspp -> type = SSPP_TYPE_RGB ; set_bit ( SDE_SSPP_QOS , & sspp -> features ) ; ( * rgb_count ) ++ ; if ( ! prop_value ) return ; if ( sde_cfg -> qseed_type == SDE_SSPP_SCALER_QSEED2 ) { set_bit ( SDE_SSPP_SCALER_RGB , & sspp -> features ) ; sblk -> scaler_blk . id = SDE_SSPP_SCALER_QSEED2 ; sblk -> scaler_blk . base = PROP_VALUE_ACCESS ( prop_value , RGB_SCALER_OFF , 0 ) ; sblk -> scaler_blk . len = PROP_VALUE_ACCESS ( prop_value , RGB_SCALER_LEN , 0 ) ; snprintf ( sblk -> scaler_blk . name , SDE_HW_BLK_NAME_LEN , <S2SV_StartBug> "sspp_scaler%u" , sspp -> id ) ; <S2SV_EndBug> } else if ( sde_cfg -> qseed_type == SDE_SSPP_SCALER_QSEED3 ) { set_bit ( SDE_SSPP_SCALER_RGB , & sspp -> features ) ; sblk -> scaler_blk . id = SDE_SSPP_SCALER_QSEED3 ; sblk -> scaler_blk . base = PROP_VALUE_ACCESS ( prop_value , RGB_SCALER_LEN , 0 ) ; sblk -> scaler_blk . len = PROP_VALUE_ACCESS ( prop_value , SSPP_SCALE_SIZE , 0 ) ; snprintf ( sblk -> scaler_blk . name , SDE_HW_BLK_NAME_LEN , <S2SV_StartBug> "sspp_scaler%u" , sspp -> id ) ; <S2SV_EndBug> } sblk -> pcc_blk . id = SDE_SSPP_PCC ; if ( prop_exists [ RGB_PCC_PROP ] ) { sblk -> pcc_blk . base = PROP_VALUE_ACCESS ( prop_value , RGB_PCC_PROP , 0 ) ; sblk -> pcc_blk . version = PROP_VALUE_ACCESS ( prop_value , RGB_PCC_PROP , 1 ) ; sblk -> pcc_blk . len = 0 ; set_bit ( SDE_SSPP_PCC , & sspp -> features ) ; } snprintf ( sspp -> name , sizeof ( sspp -> name ) , "rgb%d" , * rgb_count - 1 ) ; }
|
<S2SV_ModStart> , "sspp_%u" , sspp -> id - SSPP_VIG0 <S2SV_ModEnd> ) ; sspp <S2SV_ModStart> sspp -> id - SSPP_VIG0 <S2SV_ModStart> sspp -> id - SSPP_VIG0
|
434
|
CWE-000 static void adjust_offsets ( BevelParams * bp ) { BevVert * bv , * bvcur ; BoundVert * v , * vanchor , * vchainstart , * vnext ; EdgeHalf * enext ; GHashIterator giter ; bool iscycle ; GHASH_ITER ( giter , bp -> vert_hash ) { bv = bvcur = BLI_ghashIterator_getValue ( & giter ) ; vanchor = bv -> vmesh -> boundstart ; do { if ( vanchor -> visited || ! vanchor -> eon ) continue ; v = vchainstart = vanchor ; iscycle = false ; while ( v -> eon && ! v -> visited && ! iscycle ) { enext = find_other_end_edge_half ( bp , v -> efirst , & bvcur ) ; BLI_assert ( enext != NULL ) ; vnext = enext -> leftv ; v -> adjchain = vnext ; v -> visited = true ; if ( vnext -> visited ) { if ( vnext != vchainstart ) { <S2SV_StartBug> printf ( "WHOOPS,<S2SV_blank>adjusting<S2SV_blank>offsets,<S2SV_blank>expected<S2SV_blank>cycle!\\n" ) ; <S2SV_EndBug> break ; } adjust_the_cycle_or_chain ( vchainstart , true ) ; iscycle = true ; } v = vnext ; } if ( ! iscycle ) { v = vchainstart ; bvcur = bv ; do { enext = find_other_end_edge_half ( bp , v -> elast , & bvcur ) ; BLI_assert ( enext != NULL ) ; vnext = enext -> rightv ; vnext -> adjchain = v ; vchainstart = vnext ; v -> visited = true ; v = vnext ; } while ( ! v -> visited && v -> eon ) ; adjust_the_cycle_or_chain ( vchainstart , false ) ; } } while ( ( vanchor = vanchor -> next ) != bv -> vmesh -> boundstart ) ; } GHASH_ITER ( giter , bp -> vert_hash ) { bv = BLI_ghashIterator_getValue ( & giter ) ; build_boundary ( bp , bv , false ) ; } }
|
<S2SV_ModStart> vchainstart ) { <S2SV_ModEnd> break ; }
|
435
|
CWE-000 inline static const char * str_to_int ( const char * const string , int * res ) { assert ( string && string [ 0 ] != '\\0' && res ) ; long long int tmp_res ; const char * const error_string = str_to_llint ( string , & tmp_res ) ; if ( error_string ) { return error_string ; } <S2SV_StartBug> if ( ! IN_RANGE_INCL ( tmp_res , INT_MIN , INT_MAX ) ) { <S2SV_EndBug> errno = ERANGE ; return strerror ( errno ) ; } <S2SV_StartBug> * res = tmp_res ; <S2SV_EndBug> return NULL ; }
|
<S2SV_ModStart> error_string ; } # if LLONG_MIN != INT_MIN || LLONG_MAX != INT_MAX <S2SV_ModStart> ) ; } # endif
|
436
|
CWE-000 int pfe ( char * * argv ) { <S2SV_StartBug> int sectOne = argv [ 1 ] , sectTwo = argv [ 2 ] , i ; <S2SV_EndBug> char * buffer ; <S2SV_StartBug> if ( checkRange ( sectOne , sectTwo ) == FALSE ) <S2SV_EndBug> { printf ( "Error:<S2SV_blank>invalid<S2SV_blank>range\\n" ) ; return EXIT_FAILURE ; } for ( i = sectOne ; i <= sectTwo ; i ++ ) { <S2SV_StartBug> buffer = readFAT12Table ( i , buffer ) ; <S2SV_EndBug> printf ( "Entry<S2SV_blank>%i:<S2SV_blank>%c" , i , buffer [ 0 ] ) ; free ( buffer ) ; } return EXIT_SUCCESS ; }
|
<S2SV_ModStart> int sectOne = atoi ( <S2SV_ModStart> [ 1 ] ) <S2SV_ModStart> , sectTwo = atoi ( <S2SV_ModStart> [ 2 ] ) <S2SV_ModStart> , sectTwo ) <S2SV_ModEnd> ) { printf <S2SV_ModStart> ++ ) { <S2SV_ModEnd> } return EXIT_SUCCESS
|
437
|
CWE-000 static void dumpCast ( Archive * fout , CastInfo * cast ) { DumpOptions * dopt = fout -> dopt ; PQExpBuffer defqry ; PQExpBuffer delqry ; PQExpBuffer labelq ; FuncInfo * funcInfo = NULL ; char * sourceType ; char * targetType ; if ( ! cast -> dobj . dump || dopt -> dataOnly ) return ; if ( OidIsValid ( cast -> castfunc ) ) { funcInfo = findFuncByOid ( cast -> castfunc ) ; if ( funcInfo == NULL ) exit_horribly ( NULL , "could<S2SV_blank>not<S2SV_blank>find<S2SV_blank>function<S2SV_blank>definition<S2SV_blank>for<S2SV_blank>function<S2SV_blank>with<S2SV_blank>OID<S2SV_blank>%u\\n" , cast -> castfunc ) ; } selectSourceSchema ( fout , "pg_catalog" ) ; defqry = createPQExpBuffer ( ) ; delqry = createPQExpBuffer ( ) ; labelq = createPQExpBuffer ( ) ; sourceType = getFormattedTypeName ( fout , cast -> castsource , zeroAsNone ) ; targetType = getFormattedTypeName ( fout , cast -> casttarget , zeroAsNone ) ; appendPQExpBuffer ( delqry , "DROP<S2SV_blank>CAST<S2SV_blank>(%s<S2SV_blank>AS<S2SV_blank>%s);\\n" , sourceType , targetType ) ; appendPQExpBuffer ( defqry , "CREATE<S2SV_blank>CAST<S2SV_blank>(%s<S2SV_blank>AS<S2SV_blank>%s)<S2SV_blank>" , sourceType , targetType ) ; switch ( cast -> castmethod ) { case COERCION_METHOD_BINARY : appendPQExpBufferStr ( defqry , "WITHOUT<S2SV_blank>FUNCTION" ) ; break ; case COERCION_METHOD_INOUT : appendPQExpBufferStr ( defqry , "WITH<S2SV_blank>INOUT" ) ; break ; case COERCION_METHOD_FUNCTION : if ( funcInfo ) { char * fsig = format_function_signature ( fout , funcInfo , true ) ; appendPQExpBuffer ( defqry , "WITH<S2SV_blank>FUNCTION<S2SV_blank>%s.%s" , fmtId ( funcInfo -> dobj . namespace -> dobj . name ) , fsig ) ; free ( fsig ) ; } else write_msg ( NULL , "WARNING:<S2SV_blank>bogus<S2SV_blank>value<S2SV_blank>in<S2SV_blank>pg_cast.castfunc<S2SV_blank>or<S2SV_blank>pg_cast.castmethod<S2SV_blank>field\\n" ) ; break ; default : write_msg ( NULL , "WARNING:<S2SV_blank>bogus<S2SV_blank>value<S2SV_blank>in<S2SV_blank>pg_cast.castmethod<S2SV_blank>field\\n" ) ; } if ( cast -> castcontext == 'a' ) appendPQExpBufferStr ( defqry , "<S2SV_blank>AS<S2SV_blank>ASSIGNMENT" ) ; else if ( cast -> castcontext == 'i' ) appendPQExpBufferStr ( defqry , "<S2SV_blank>AS<S2SV_blank>IMPLICIT" ) ; appendPQExpBufferStr ( defqry , ";\\n" ) ; appendPQExpBuffer ( labelq , "CAST<S2SV_blank>(%s<S2SV_blank>AS<S2SV_blank>%s)" , sourceType , targetType ) ; if ( dopt -> binary_upgrade ) binary_upgrade_extension_member ( defqry , & cast -> dobj , labelq -> data ) ; if ( cast -> dobj . dump & DUMP_COMPONENT_DEFINITION ) ArchiveEntry ( fout , cast -> dobj . catId , cast -> dobj . dumpId , labelq -> data , "pg_catalog" , NULL , "" , false , "CAST" , SECTION_PRE_DATA , defqry -> data , delqry -> data , NULL , NULL , 0 , NULL , NULL ) ; if ( cast -> dobj . dump & DUMP_COMPONENT_COMMENT ) dumpComment ( fout , labelq -> data , <S2SV_StartBug> NULL , "" , <S2SV_EndBug> cast -> dobj . catId , 0 , cast -> dobj . dumpId ) ; free ( sourceType ) ; free ( targetType ) ; destroyPQExpBuffer ( defqry ) ; destroyPQExpBuffer ( delqry ) ; destroyPQExpBuffer ( labelq ) ; }
|
<S2SV_ModStart> -> data , "pg_catalog" <S2SV_ModEnd> , "" ,
|
438
|
CWE-000 void huge_pmd_set_accessed ( struct vm_fault * vmf , pmd_t orig_pmd ) { pmd_t entry ; <S2SV_StartBug> unsigned long haddr ; <S2SV_EndBug> vmf -> ptl = pmd_lock ( vmf -> vma -> vm_mm , vmf -> pmd ) ; if ( unlikely ( ! pmd_same ( * vmf -> pmd , orig_pmd ) ) ) goto unlock ; entry = pmd_mkyoung ( orig_pmd ) ; <S2SV_StartBug> haddr = vmf -> address & HPAGE_PMD_MASK ; <S2SV_EndBug> if ( pmdp_set_access_flags ( vmf -> vma , haddr , vmf -> pmd , entry , <S2SV_StartBug> vmf -> flags & FAULT_FLAG_WRITE ) ) <S2SV_EndBug> update_mmu_cache_pmd ( vmf -> vma , vmf -> address , vmf -> pmd ) ; unlock : spin_unlock ( vmf -> ptl ) ; }
|
<S2SV_ModStart> unsigned long haddr ; bool write = vmf -> flags & FAULT_FLAG_WRITE <S2SV_ModStart> orig_pmd ) ; if ( write ) entry = pmd_mkdirty ( entry ) ; <S2SV_ModStart> , entry , write <S2SV_ModEnd> ) ) update_mmu_cache_pmd
|
439
|
CWE-000 int main ( void ) { int cases ; <S2SV_StartBug> scanf ( "%d" , & cases ) ; <S2SV_EndBug> printf ( "cases<S2SV_blank>%d\\n" , cases ) ; while ( cases -- > 0 ) testcase ( ) ; exit ( 0 ) ; }
|
<S2SV_ModStart> "%d" , & <S2SV_ModEnd> cases ) ;
|
440
|
CWE-000 static void __vr_flow_reset_entry ( struct vrouter * router , struct vr_flow_entry * fe ) { if ( fe -> fe_hold_list ) { <S2SV_StartBug> vr_printf ( "vrouter:<S2SV_blank>Potential<S2SV_blank>memory<S2SV_blank>leak<S2SV_blank>@<S2SV_blank>%s:%d\\n" , <S2SV_EndBug> __FILE__ , __LINE__ ) ; } fe -> fe_hold_list = NULL ; fe -> fe_key . flow_key_len = 0 ; vr_flow_reset_mirror ( router , fe , fe -> fe_hentry . hentry_index ) ; fe -> fe_ecmp_nh_index = - 1 ; fe -> fe_src_nh_index = NH_DISCARD_ID ; fe -> fe_rflow = - 1 ; fe -> fe_action = VR_FLOW_ACTION_DROP ; fe -> fe_udp_src_port = 0 ; fe -> fe_tcp_flags = 0 ; fe -> fe_flags &= ( VR_FLOW_FLAG_ACTIVE | VR_FLOW_FLAG_EVICTED | VR_FLOW_FLAG_NEW_FLOW | VR_FLOW_FLAG_DELETE_MARKED ) ; return ; }
|
<S2SV_ModStart> { vr_printf ( "vrouter:<S2SV_blank>Potential<S2SV_blank>memory<S2SV_blank>leak<S2SV_blank>for<S2SV_blank>flow<S2SV_blank>%d<S2SV_blank>tcp_flags<S2SV_blank>0x%x" "<S2SV_blank>action<S2SV_blank>%d<S2SV_blank>flags<S2SV_blank>0x%x<S2SV_blank>with<S2SV_blank>rflow<S2SV_blank>id<S2SV_blank>%d<S2SV_blank>ecmp<S2SV_blank>nh<S2SV_blank>id<S2SV_blank>%d" "<S2SV_blank>src<S2SV_blank>nh<S2SV_blank>%d\\n" , fe -> fe_hentry . hentry_index , fe -> fe_tcp_flags , fe -> fe_action , fe -> fe_flags , fe -> fe_rflow , fe -> fe_ecmp_nh_index , fe -> fe_src_nh_index <S2SV_ModEnd> ) ; }
|
441
|
CWE-000 int control_init ( ) { int ret ; int fd ; PRINT ( "control:<S2SV_blank>Initializing<S2SV_blank>GPIO<S2SV_blank>banks.\\n" ) ; ret = gpio_wakeup ( TRUE ) ; if ( ret != 0 ) { return ret ; } for ( int i = 0 ; i < GPIO_COUNT ; i ++ ) { ret = gpio_init ( & gGPIOBanks [ i ] , i ) ; if ( ret != 0 ) { return ret ; } } PRINT ( "control:<S2SV_blank>Initializing<S2SV_blank>GPIO<S2SV_blank>extender<S2SV_blank>banks.\\n" ) ; for ( int i = 0 ; i < GPIO_EXT_COUNT ; i ++ ) { ret = i2c_init ( & gI2C [ i ] , I2C1 , PCF8575_I2C_ADDR ( i ) ) ; if ( ret != 0 ) { return ret ; } <S2SV_StartBug> ret = gpio_ext_init ( & gGPIOExtBanks [ i ] , PCF8575 , & gI2C [ i ] ) ; <S2SV_EndBug> if ( ret != 0 ) { return ret ; } } PRINT ( "control:<S2SV_blank>Initializing<S2SV_blank>switch<S2SV_blank>matrix.\\n" ) ; ret = mt8809_init ( & gSwitchMatrix ) ; if ( ret != 0 ) { return ret ; } PRINT ( "control:<S2SV_blank>Initializing<S2SV_blank>control<S2SV_blank>mutex.\\n" ) ; pthread_mutex_init ( & gConfigMutex , NULL ) ; ret = pthread_mutex_lock ( & gConfigMutex ) ; if ( ret != 0 ) { PRINT_LOG ( "pthread_mutex_lock()<S2SV_blank>failed!" ) ; return - 1 ; } PRINT ( "control:<S2SV_blank>Initializing<S2SV_blank>button<S2SV_blank>control.\\n" ) ; ret = button_control_init ( & gButtonControl , & button_control_update , NULL ) ; if ( ret != 0 ) { pthread_mutex_unlock ( & gConfigMutex ) ; return ret ; } PRINT ( "control:<S2SV_blank>Initializing<S2SV_blank>presence<S2SV_blank>control.\\n" ) ; ret = presence_control_init ( & gPresenceControl , & presence_control_update , NULL , & gPresenceDetect [ 0 ] [ 0 ] ) ; if ( ret != 0 ) { pthread_mutex_unlock ( & gConfigMutex ) ; return ret ; } PRINT ( "control:<S2SV_blank>Mapping<S2SV_blank>config<S2SV_blank>into<S2SV_blank>non-volatile<S2SV_blank>memory.\\n" ) ; fd = open ( CONFIG_FILE , O_RDWR | O_CREAT ) ; if ( fd == - 1 ) { PRINT_LOG ( "open()<S2SV_blank>failed!" ) ; pthread_mutex_unlock ( & gConfigMutex ) ; return - 1 ; } ret = lseek ( fd , sizeof ( * gConfig ) , SEEK_SET ) ; if ( ret != sizeof ( * gConfig ) ) { PRINT_LOG ( "lseek()<S2SV_blank>failed!" ) ; pthread_mutex_unlock ( & gConfigMutex ) ; return - 1 ; } ret = write ( fd , "" , 1 ) ; if ( ret < 1 ) { PRINT_LOG ( "write()<S2SV_blank>failed!" ) ; pthread_mutex_unlock ( & gConfigMutex ) ; return - 1 ; } gConfig = mmap ( NULL , sizeof ( * gConfig ) , PROT_READ | PROT_WRITE , MAP_SHARED , fd , 0 ) ; close ( fd ) ; if ( gConfig == MAP_FAILED ) { PRINT_LOG ( "mmap()<S2SV_blank>failed!" ) ; pthread_mutex_unlock ( & gConfigMutex ) ; return - 1 ; } PRINT ( "control:<S2SV_blank>Setting<S2SV_blank>initial<S2SV_blank>device<S2SV_blank>configuration.\\n" ) ; ret = apply_control ( gConfig -> controlEnabled ) ; ret = apply_switch_configuration ( gConfig -> currPreset . pedalOrder , gConfig -> currPreset . enabled , gPresenceDetect , gConfig -> bypassEnabled , gConfig -> muteEnabled ) ; if ( ret != 0 ) { pthread_mutex_unlock ( & gConfigMutex ) ; return - 1 ; } bool ledOn [ AE_LED_COUNT ] = { 0 } ; if ( gConfig -> pedalMode ) { ledOn [ AE_LED_BU ] = gConfig -> controlEnabled [ TIP ] ; ledOn [ AE_LED_BD ] = gConfig -> controlEnabled [ RING ] ; for ( int i = 0 ; i < AE_MAX_EFFECTS ; i ++ ) { ledOn [ i ] = gConfig -> currPreset . enabled [ i ] ; } } else { ledOn [ gConfig -> currPreset . preset ] = TRUE ; } PRINT ( "control:<S2SV_blank>Initializing<S2SV_blank>led<S2SV_blank>control.\\n" ) ; ret = led_control_init ( & gLedControl , ledOn ) ; if ( ret != 0 ) { pthread_mutex_unlock ( & gConfigMutex ) ; return ret ; } pthread_mutex_unlock ( & gConfigMutex ) ; return 0 ; }
|
<S2SV_ModStart> [ i ] , PCF8575_INT_DEBOUNCE_TIME ( i )
|
442
|
CWE-000 static void compute_geom_coef_blended_T ( const struct Simulation * const sim , struct Solver_Volume_T * const s_vol ) { <S2SV_StartBug> const struct const_Multiarray_R * xyz_s = constructor_xyz_s_ho ( s_vol , sim ) ; <S2SV_EndBug> const struct const_Multiarray_R * xyz = constructor_xyz_blended_T ( 'g' , xyz_s , s_vol , sim ) ; destructor_const_Multiarray_R ( xyz_s ) ; destructor_const_Multiarray_R ( s_vol -> geom_coef ) ; <S2SV_StartBug> const_constructor_move_const_Multiarray_R ( & s_vol -> geom_coef , constructor_geom_coef_ho ( xyz , s_vol , sim ) ) ; <S2SV_EndBug> destructor_const_Multiarray_R ( xyz ) ; }
|
<S2SV_ModStart> * xyz_s = constructor_xyz_s_ho_T ( 'v' , <S2SV_ModEnd> s_vol , sim <S2SV_ModStart> -> geom_coef , constructor_geom_coef_ho_T <S2SV_ModEnd> ( xyz ,
|
443
|
CWE-000 static void _mdns_search_result_add_srv ( mdns_search_once_t * search , const char * hostname , uint16_t port , tcpip_adapter_if_t tcpip_if , mdns_ip_protocol_t ip_protocol ) { mdns_result_t * r = search -> result ; while ( r ) { if ( r -> tcpip_if == tcpip_if && r -> ip_protocol == ip_protocol && ! _str_null_or_empty ( r -> hostname ) && ! strcasecmp ( hostname , r -> hostname ) ) { return ; } r = r -> next ; } if ( ! search -> max_results || search -> num_results < search -> max_results ) { r = ( mdns_result_t * ) malloc ( sizeof ( mdns_result_t ) ) ; if ( ! r ) { <S2SV_StartBug> return ; <S2SV_EndBug> } memset ( r , 0 , sizeof ( mdns_result_t ) ) ; r -> hostname = strdup ( hostname ) ; if ( ! r -> hostname ) { free ( r ) ; return ; } r -> port = port ; r -> tcpip_if = tcpip_if ; r -> ip_protocol = ip_protocol ; r -> next = search -> result ; search -> result = r ; search -> num_results ++ ; } }
|
<S2SV_ModStart> r ) { HOOK_MALLOC_FAILED ;
|
444
|
CWE-000 int boot_link_transport_usb_close ( link_transport_phy_t * handle ) { <S2SV_StartBug> return mcu_usb_close ( & usb_dev ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> return mcu_usb_close ( m_context -> handle <S2SV_ModEnd> ) ; }
|
445
|
CWE-000 static void legacy_dvb_usb_read_remote_control ( struct work_struct * work ) { struct dvb_usb_device * d = container_of ( work , struct dvb_usb_device , rc_query_work . work ) ; u32 event ; int state ; if ( dvb_usb_disable_rc_polling ) return ; if ( d -> props . rc . legacy . rc_query ( d , & event , & state ) ) { err ( "error<S2SV_blank>while<S2SV_blank>querying<S2SV_blank>for<S2SV_blank>an<S2SV_blank>remote<S2SV_blank>control<S2SV_blank>event." ) ; goto schedule ; } switch ( state ) { case REMOTE_NO_KEY_PRESSED : break ; case REMOTE_KEY_PRESSED : deb_rc ( "key<S2SV_blank>pressed\\n" ) ; d -> last_event = event ; <S2SV_StartBug> case REMOTE_KEY_REPEAT : <S2SV_EndBug> deb_rc ( "key<S2SV_blank>repeated\\n" ) ; input_event ( d -> input_dev , EV_KEY , event , 1 ) ; input_sync ( d -> input_dev ) ; input_event ( d -> input_dev , EV_KEY , d -> last_event , 0 ) ; input_sync ( d -> input_dev ) ; break ; default : break ; } schedule : schedule_delayed_work ( & d -> rc_query_work , msecs_to_jiffies ( d -> props . rc . legacy . rc_interval ) ) ; }
|
<S2SV_ModStart> = event ; input_event ( d -> input_dev , EV_KEY , event , 1 ) ; input_sync ( d -> input_dev ) ; input_event ( d -> input_dev , EV_KEY , d -> last_event , 0 ) ; input_sync ( d -> input_dev ) ; break ;
|
446
|
CWE-000 static int enduser_setup_stop ( lua_State * L ) { ENDUSER_SETUP_DEBUG ( "enduser_setup_stop" ) ; if ( ! manual ) { enduser_setup_ap_stop ( ) ; } <S2SV_StartBug> enduser_setup_dns_stop ( ) ; <S2SV_EndBug> enduser_setup_http_stop ( ) ; enduser_setup_free ( ) ; return 0 ; }
|
<S2SV_ModStart> ) ; } if ( state -> success && ! state -> callbackDone ) { wifi_set_opmode ( STATION_MODE | wifi_get_opmode ( ) ) ; wifi_station_connect ( ) ; enduser_setup_connected_callback ( ) ; }
|
447
|
CWE-000 u8 checkGrid ( ) { u8 completeAmount = 0 ; <S2SV_StartBug> u8 completeLines [ 10 ] = { [ 0 ... 9 ] = 1 } ; <S2SV_EndBug> <S2SV_StartBug> u8 completeColumns [ 10 ] = { [ 0 ... 9 ] = 1 } ; <S2SV_EndBug> for ( int i = 0 ; i < 10 ; i ++ ) { for ( int j = 0 ; j < 10 ; j ++ ) { if ( grid [ i ] [ j ] == 0 ) { completeLines [ i ] = 0 ; } if ( grid [ j ] [ i ] == 0 ) { completeColumns [ i ] = 0 ; } } completeAmount += completeColumns [ i ] + completeLines [ i ] ; } if ( completeAmount == 0 ) return 0 ; for ( int i = 0 ; i < 10 ; i ++ ) { for ( int j = 0 ; j < 10 ; j ++ ) { grid [ i ] [ j ] = ( grid [ i ] [ j ] & ~ ( completeColumns [ j ] | completeLines [ i ] ) ) ; } } return 10 * ( completeAmount * ( completeAmount + 1 ) ) / 2 ; }
|
<S2SV_ModStart> 9 ] = 3 <S2SV_ModEnd> } ; u8 <S2SV_ModStart> 9 ] = 3 <S2SV_ModEnd> } ; for
|
448
|
CWE-000 static int _server_read ( eio_obj_t * obj , List objs ) { struct server_io_info * s = ( struct server_io_info * ) obj -> arg ; void * buf ; int n ; debug4 ( "Entering<S2SV_blank>_server_read" ) ; if ( s -> in_msg == NULL ) { if ( _outgoing_buf_free ( s -> cio ) ) { s -> in_msg = list_dequeue ( s -> cio -> free_outgoing ) ; } else { debug ( "List<S2SV_blank>free_outgoing<S2SV_blank>is<S2SV_blank>empty!" ) ; return SLURM_ERROR ; } n = io_hdr_read_fd ( obj -> fd , & s -> header ) ; if ( n <= 0 ) { if ( n < 0 ) { <S2SV_StartBug> if ( getenv ( "SLURM_PTY_PORT" ) == NULL ) { <S2SV_EndBug> error ( "%s:<S2SV_blank>fd<S2SV_blank>%d<S2SV_blank>error<S2SV_blank>reading<S2SV_blank>header:<S2SV_blank>%m" , __func__ , obj -> fd ) ; } if ( s -> cio -> sls ) { step_launch_notify_io_failure ( <S2SV_StartBug> s -> cio -> sls , s -> node_id ) ; <S2SV_EndBug> } } close ( obj -> fd ) ; obj -> fd = - 1 ; s -> in_eof = true ; s -> out_eof = true ; list_enqueue ( s -> cio -> free_outgoing , s -> in_msg ) ; s -> in_msg = NULL ; return SLURM_SUCCESS ; } if ( s -> header . type == SLURM_IO_CONNECTION_TEST ) { if ( s -> cio -> sls ) step_launch_clear_questionable_state ( s -> cio -> sls , s -> node_id ) ; list_enqueue ( s -> cio -> free_outgoing , s -> in_msg ) ; s -> in_msg = NULL ; s -> testing_connection = false ; return SLURM_SUCCESS ; } else if ( s -> header . length == 0 ) { if ( s -> header . type == SLURM_IO_STDOUT ) { s -> remote_stdout_objs -- ; debug3 ( "got<S2SV_blank>eof-stdout<S2SV_blank>msg<S2SV_blank>on<S2SV_blank>_server_read<S2SV_blank>" "header" ) ; } else if ( s -> header . type == SLURM_IO_STDERR ) { s -> remote_stderr_objs -- ; debug3 ( "got<S2SV_blank>eof-stderr<S2SV_blank>msg<S2SV_blank>on<S2SV_blank>_server_read<S2SV_blank>" "header" ) ; } else error ( "Unrecognized<S2SV_blank>output<S2SV_blank>message<S2SV_blank>type" ) ; if ( s -> remote_stdout_objs == 0 && s -> remote_stderr_objs == 0 ) { obj -> shutdown = true ; } list_enqueue ( s -> cio -> free_outgoing , s -> in_msg ) ; s -> in_msg = NULL ; return SLURM_SUCCESS ; } s -> in_remaining = s -> header . length ; s -> in_msg -> length = s -> header . length ; s -> in_msg -> header = s -> header ; } if ( s -> header . length != 0 ) { buf = s -> in_msg -> data + ( s -> in_msg -> length - s -> in_remaining ) ; again : if ( ( n = read ( obj -> fd , buf , s -> in_remaining ) ) < 0 ) { if ( errno == EINTR ) goto again ; if ( ( errno == EAGAIN ) || ( errno == EWOULDBLOCK ) ) return SLURM_SUCCESS ; if ( errno == ECONNRESET ) { debug ( "Stdout/err<S2SV_blank>from<S2SV_blank>task<S2SV_blank>%u<S2SV_blank>may<S2SV_blank>be<S2SV_blank>" "incomplete<S2SV_blank>due<S2SV_blank>to<S2SV_blank>a<S2SV_blank>network<S2SV_blank>error" , s -> header . gtaskid ) ; } else { debug3 ( "_server_read<S2SV_blank>error:<S2SV_blank>%m" ) ; } } if ( n <= 0 ) { error ( "%s:<S2SV_blank>fd<S2SV_blank>%d<S2SV_blank>got<S2SV_blank>error<S2SV_blank>or<S2SV_blank>unexpected<S2SV_blank>eof<S2SV_blank>reading<S2SV_blank>message<S2SV_blank>body" , __func__ , obj -> fd ) ; if ( s -> cio -> sls ) step_launch_notify_io_failure ( s -> cio -> sls , s -> node_id ) ; close ( obj -> fd ) ; obj -> fd = - 1 ; s -> in_eof = true ; s -> out_eof = true ; list_enqueue ( s -> cio -> free_outgoing , s -> in_msg ) ; s -> in_msg = NULL ; return SLURM_SUCCESS ; } s -> in_remaining -= n ; if ( s -> in_remaining > 0 ) return SLURM_SUCCESS ; } else { debug3 ( "*****<S2SV_blank>passing<S2SV_blank>on<S2SV_blank>eof<S2SV_blank>message" ) ; } { eio_obj_t * obj ; struct file_write_info * info ; s -> in_msg -> ref_count = 1 ; if ( s -> in_msg -> header . type == SLURM_IO_STDOUT ) obj = s -> cio -> stdout_obj ; else obj = s -> cio -> stderr_obj ; info = ( struct file_write_info * ) obj -> arg ; if ( info -> eof ) list_enqueue ( s -> cio -> free_outgoing , s -> in_msg ) ; else list_enqueue ( info -> msg_queue , s -> in_msg ) ; s -> in_msg = NULL ; } return SLURM_SUCCESS ; }
|
<S2SV_ModStart> { if ( obj -> shutdown ) { verbose ( "%s:<S2SV_blank>Dropped<S2SV_blank>pending<S2SV_blank>I/O<S2SV_blank>for<S2SV_blank>terminated<S2SV_blank>task" , __func__ ) ; } else { if ( <S2SV_ModStart> node_id ) ; }
|
449
|
CWE-000 static int virtio_input_init ( struct vmctx * ctx , struct pci_vdev * dev , char * opts ) { struct virtio_input * vi ; pthread_mutexattr_t attr ; bool mutex_initialized = false ; char * opt ; int flags , ver ; int rc ; if ( ! opts ) { WPRINTF ( ( "%s:<S2SV_blank>evdev<S2SV_blank>path<S2SV_blank>is<S2SV_blank>NULL\\n" , __func__ ) ) ; return - 1 ; } vi = calloc ( 1 , sizeof ( struct virtio_input ) ) ; if ( ! vi ) { WPRINTF ( ( "%s:<S2SV_blank>out<S2SV_blank>of<S2SV_blank>memory\\n" , __func__ ) ) ; return - 1 ; } opt = strsep ( & opts , "," ) ; if ( ! opt ) { WPRINTF ( ( "%s:<S2SV_blank>evdev<S2SV_blank>path<S2SV_blank>is<S2SV_blank>NULL\\n" , __func__ ) ) ; goto fail ; } vi -> evdev = strdup ( opt ) ; if ( ! vi -> evdev ) { WPRINTF ( ( "%s:<S2SV_blank>strdup<S2SV_blank>failed\\n" , __func__ ) ) ; goto fail ; } if ( opts ) { vi -> serial = strdup ( opts ) ; if ( ! vi -> serial ) { WPRINTF ( ( "%s:<S2SV_blank>strdup<S2SV_blank>serial<S2SV_blank>failed\\n" , __func__ ) ) ; goto fail ; } } vi -> fd = open ( vi -> evdev , O_RDWR ) ; if ( vi -> fd < 0 ) { WPRINTF ( ( "open<S2SV_blank>%s<S2SV_blank>failed<S2SV_blank>%d\\n" , vi -> evdev , errno ) ) ; goto fail ; } flags = fcntl ( vi -> fd , F_GETFL ) ; fcntl ( vi -> fd , F_SETFL , flags | O_NONBLOCK ) ; rc = ioctl ( vi -> fd , EVIOCGVERSION , & ver ) ; if ( rc < 0 ) { WPRINTF ( ( "%s:<S2SV_blank>get<S2SV_blank>version<S2SV_blank>failed\\n" , vi -> evdev ) ) ; goto fail ; } rc = ioctl ( vi -> fd , EVIOCGRAB , 1 ) ; if ( rc < 0 ) { WPRINTF ( ( "%s:<S2SV_blank>grab<S2SV_blank>device<S2SV_blank>failed<S2SV_blank>%d\\n" , vi -> evdev , errno ) ) ; goto fail ; } rc = pthread_mutexattr_init ( & attr ) ; if ( rc ) DPRINTF ( ( "mutexattr<S2SV_blank>init<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>erro<S2SV_blank>%d!\\n" , rc ) ) ; rc = pthread_mutexattr_settype ( & attr , PTHREAD_MUTEX_RECURSIVE ) ; if ( rc ) DPRINTF ( ( "vtinput:<S2SV_blank>mutexattr_settype<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>" "error<S2SV_blank>%d!\\n" , rc ) ) ; rc = pthread_mutex_init ( & vi -> mtx , & attr ) ; if ( rc ) DPRINTF ( ( "vtinput:<S2SV_blank>pthread_mutex_init<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>" "error<S2SV_blank>%d!\\n" , rc ) ) ; mutex_initialized = ( rc == 0 ) ? true : false ; vi -> event_qsize = VIRTIO_INPUT_PACKET_SIZE ; vi -> event_qindex = 0 ; vi -> event_queue = calloc ( vi -> event_qsize , sizeof ( struct virtio_input_event_elem ) ) ; if ( ! vi -> event_queue ) { WPRINTF ( ( "vtinput:<S2SV_blank>could<S2SV_blank>not<S2SV_blank>alloc<S2SV_blank>event<S2SV_blank>queue<S2SV_blank>buf\\n" ) ) ; goto fail ; } <S2SV_StartBug> vi -> mevp = mevent_add ( vi -> fd , EVF_READ , virtio_input_read_event , vi ) ; <S2SV_EndBug> if ( vi -> mevp == NULL ) { WPRINTF ( ( "vtinput:<S2SV_blank>could<S2SV_blank>not<S2SV_blank>register<S2SV_blank>event\\n" ) ) ; goto fail ; } virtio_linkup ( & vi -> base , & virtio_input_ops , vi , dev , vi -> queues ) ; vi -> base . mtx = & vi -> mtx ; vi -> base . device_caps = VIRTIO_INPUT_S_HOSTCAPS ; vi -> queues [ VIRTIO_INPUT_EVENT_QUEUE ] . qsize = VIRTIO_INPUT_RINGSZ ; vi -> queues [ VIRTIO_INPUT_EVENT_QUEUE ] . notify = virtio_input_notify_event_vq ; vi -> queues [ VIRTIO_INPUT_STATUS_QUEUE ] . qsize = VIRTIO_INPUT_RINGSZ ; vi -> queues [ VIRTIO_INPUT_STATUS_QUEUE ] . notify = virtio_input_notify_status_vq ; pci_set_cfgdata16 ( dev , PCIR_DEVICE , 0x1040 + VIRTIO_TYPE_INPUT ) ; pci_set_cfgdata16 ( dev , PCIR_VENDOR , VIRTIO_VENDOR ) ; pci_set_cfgdata8 ( dev , PCIR_CLASS , PCIC_INPUTDEV ) ; pci_set_cfgdata8 ( dev , PCIR_SUBCLASS , PCIS_INPUTDEV_OTHER ) ; pci_set_cfgdata16 ( dev , PCIR_SUBDEV_0 , 0x1040 + VIRTIO_TYPE_INPUT ) ; pci_set_cfgdata16 ( dev , PCIR_SUBVEND_0 , VIRTIO_VENDOR ) ; if ( virtio_interrupt_init ( & vi -> base , virtio_uses_msix ( ) ) ) { DPRINTF ( ( "%s,<S2SV_blank>interrupt_init<S2SV_blank>failed!\\n" , __func__ ) ) ; goto fail ; } rc = virtio_set_modern_bar ( & vi -> base , true ) ; return rc ; fail : if ( vi ) { if ( mutex_initialized ) pthread_mutex_destroy ( & vi -> mtx ) ; if ( vi -> event_queue ) { free ( vi -> event_queue ) ; vi -> event_queue = NULL ; } if ( vi -> mevp ) { mevent_delete ( vi -> mevp ) ; vi -> mevp = NULL ; } if ( vi -> fd > 0 ) { close ( vi -> fd ) ; vi -> fd = - 1 ; } if ( vi -> serial ) { free ( vi -> serial ) ; vi -> serial = NULL ; } if ( vi -> evdev ) { free ( vi -> evdev ) ; vi -> evdev = NULL ; } free ( vi ) ; vi = NULL ; } return - 1 ; }
|
<S2SV_ModStart> virtio_input_read_event , vi , NULL , NULL
|
450
|
CWE-000 FHandler * FHandlerCreate ( const char * path , const char * name ) { FHandler * fsys = NULL ; if ( name == NULL ) { FERROR ( "Name<S2SV_blank>parameter<S2SV_blank>is<S2SV_blank>NULL!\\n" ) ; return NULL ; } int nameLen = strlen ( name ) ; if ( nameLen < 4 ) { FERROR ( "Name<S2SV_blank>size<S2SV_blank><<S2SV_blank>4<S2SV_blank><S2SV_blank>\'%s\'\\n" , name ) ; return NULL ; } const char * suffix = & ( name [ nameLen - 4 ] ) ; DEBUG ( "FSYS<S2SV_blank>create<S2SV_blank>%s<S2SV_blank><S2SV_blank>suffix<S2SV_blank>%s\\n" , path , suffix ) ; if ( strcmp ( suffix , "fsys" ) != 0 ) { DEBUG ( "FSYS<S2SV_blank>create<S2SV_blank>suffix<S2SV_blank>%s\\n" , suffix ) ; return NULL ; } if ( ( fsys = FCalloc ( sizeof ( FHandler ) , 1 ) ) != NULL ) { if ( ( fsys -> Name = FCalloc ( nameLen + 1 , sizeof ( char ) ) ) != NULL ) { memcpy ( fsys -> Name , name , nameLen ) ; } int len = strlen ( path ) ; if ( ( fsys -> Path = FCalloc ( len + 1 , sizeof ( char ) ) ) != NULL ) { memcpy ( fsys -> Path , path , len ) ; } <S2SV_StartBug> if ( ( fsys -> handle = dlopen ( path , RTLD_NOW | RTLD_GLOBAL ) ) != NULL ) <S2SV_EndBug> { DEBUG ( "SYSTEMLIB<S2SV_blank>FSYSCREATE,<S2SV_blank>getting<S2SV_blank>pointer<S2SV_blank>to<S2SV_blank>libs\\n" ) ; fsys -> GetSuffix = dlsym ( fsys -> handle , "GetSuffix" ) ; fsys -> GetPrefix = dlsym ( fsys -> handle , "GetPrefix" ) ; fsys -> init = dlsym ( fsys -> handle , "init" ) ; fsys -> deinit = dlsym ( fsys -> handle , "deinit" ) ; fsys -> Mount = dlsym ( fsys -> handle , "Mount" ) ; fsys -> UnMount = dlsym ( fsys -> handle , "UnMount" ) ; fsys -> Release = dlsym ( fsys -> handle , "Release" ) ; fsys -> FileOpen = dlsym ( fsys -> handle , "FileOpen" ) ; fsys -> FileClose = dlsym ( fsys -> handle , "FileClose" ) ; fsys -> FileRead = dlsym ( fsys -> handle , "FileRead" ) ; fsys -> FileWrite = dlsym ( fsys -> handle , "FileWrite" ) ; fsys -> FileSeek = dlsym ( fsys -> handle , "FileSeek" ) ; fsys -> Info = dlsym ( fsys -> handle , "Info" ) ; fsys -> Call = dlsym ( fsys -> handle , "Call" ) ; fsys -> MakeDir = dlsym ( fsys -> handle , "MakeDir" ) ; fsys -> Delete = dlsym ( fsys -> handle , "Delete" ) ; fsys -> Rename = dlsym ( fsys -> handle , "Rename" ) ; fsys -> Execute = dlsym ( fsys -> handle , "Execute" ) ; fsys -> Copy = dlsym ( fsys -> handle , "Copy" ) ; fsys -> InfoGet = dlsym ( fsys -> handle , "InfoGet" ) ; fsys -> InfoSet = dlsym ( fsys -> handle , "InfoSet" ) ; fsys -> Dir = dlsym ( fsys -> handle , "Dir" ) ; fsys -> init ( fsys ) ; } else { char * error = dlerror ( ) ; FERROR ( "[ERROR]:<S2SV_blank>Cannot<S2SV_blank>open<S2SV_blank>filesystem<S2SV_blank>%s<S2SV_blank>-<S2SV_blank>error<S2SV_blank>%s\\n" , path , error ) ; if ( fsys -> Path ) FFree ( fsys -> Path ) ; if ( fsys -> Name ) FFree ( fsys -> Name ) ; FFree ( fsys ) ; return NULL ; } } return fsys ; }
|
<S2SV_ModStart> ( path , RTLD_LAZY <S2SV_ModEnd> ) ) !=
|
451
|
CWE-000 static int data_send ( struct userdata * u , pa_memchunk * chunk ) { char * data ; char * socket_dir ; char * sink_socket ; int bytes ; int sent ; int fd ; struct header h ; struct sockaddr_un s ; if ( u -> fd == 0 ) { if ( u -> failed_connect_time != 0 ) { if ( pa_rtclock_now ( ) - u -> failed_connect_time < 1000000 ) { return 0 ; } } fd = socket ( PF_LOCAL , SOCK_STREAM , 0 ) ; memset ( & s , 0 , sizeof ( s ) ) ; s . sun_family = AF_UNIX ; bytes = sizeof ( s . sun_path ) - 1 ; socket_dir = getenv ( "XRDP_SOCKET_PATH" ) ; if ( socket_dir == NULL || socket_dir [ 0 ] == '\\0' ) { socket_dir = "/tmp/.xrdp" ; } sink_socket = getenv ( "XRDP_PULSE_SINK_SOCKET" ) ; if ( sink_socket == NULL || sink_socket [ 0 ] == '\\0' ) { pa_log_debug ( "Could<S2SV_blank>not<S2SV_blank>obtain<S2SV_blank>sink_socket<S2SV_blank>from<S2SV_blank>environment." ) ; <S2SV_StartBug> snprintf ( sink_socket , bytes , "xrdp_chansrv_audio_out_socket_%d" , u -> display_num ) ; <S2SV_EndBug> } else { pa_log_debug ( "Obtained<S2SV_blank>sink_socket<S2SV_blank>from<S2SV_blank>environment." ) ; } snprintf ( s . sun_path , bytes , "%s/%s" , socket_dir , sink_socket ) ; pa_log_debug ( "trying<S2SV_blank>to<S2SV_blank>connect<S2SV_blank>to<S2SV_blank>%s" , s . sun_path ) ; if ( connect ( fd , ( struct sockaddr * ) & s , sizeof ( struct sockaddr_un ) ) != 0 ) { u -> failed_connect_time = pa_rtclock_now ( ) ; pa_log_debug ( "Connected<S2SV_blank>failed" ) ; close ( fd ) ; return 0 ; } u -> failed_connect_time = 0 ; pa_log ( "Connected<S2SV_blank>ok<S2SV_blank>fd<S2SV_blank>%d" , fd ) ; u -> fd = fd ; } bytes = chunk -> length ; pa_log_debug ( "bytes<S2SV_blank>%d" , bytes ) ; if ( u -> skip_bytes > 0 ) { if ( bytes > u -> skip_bytes ) { bytes -= u -> skip_bytes ; u -> skip_bytes = 0 ; } else { u -> skip_bytes -= bytes ; return bytes ; } } h . code = 0 ; h . bytes = bytes + 8 ; if ( lsend ( u -> fd , ( char * ) ( & h ) , 8 ) != 8 ) { pa_log ( "data_send:<S2SV_blank>send<S2SV_blank>failed" ) ; close ( u -> fd ) ; u -> fd = 0 ; return 0 ; } else { pa_log_debug ( "data_send:<S2SV_blank>sent<S2SV_blank>header<S2SV_blank>ok<S2SV_blank>bytes<S2SV_blank>%d" , bytes ) ; } data = ( char * ) pa_memblock_acquire ( chunk -> memblock ) ; data += chunk -> index ; sent = lsend ( u -> fd , data , bytes ) ; pa_memblock_release ( chunk -> memblock ) ; if ( sent != bytes ) { pa_log ( "data_send:<S2SV_blank>send<S2SV_blank>failed<S2SV_blank>sent<S2SV_blank>%d<S2SV_blank>bytes<S2SV_blank>%d" , sent , bytes ) ; close ( u -> fd ) ; u -> fd = 0 ; return 0 ; } return sent ; }
|
<S2SV_ModStart> ; snprintf ( s . sun_path , bytes , "%s/xrdp_chansrv_audio_out_socket_%d" , socket_dir , u -> display_num ) ; } else { pa_log_debug ( "Obtained<S2SV_blank>sink_socket<S2SV_blank>from<S2SV_blank>environment." ) ; snprintf ( s . sun_path , bytes , "%s/%s" , socket_dir , sink_socket ) ; } <S2SV_ModEnd> pa_log_debug ( "trying<S2SV_blank>to<S2SV_blank>connect<S2SV_blank>to<S2SV_blank>%s"
|
452
|
CWE-000 static int open_f ( BlockBackend * blk , int argc , char * * argv ) { int flags = BDRV_O_UNMAP ; int readonly = 0 ; bool writethrough = true ; int c ; QemuOpts * qopts ; QDict * opts ; bool force_share = false ; while ( ( c = getopt ( argc , argv , "snro:kt:d:U" ) ) != - 1 ) { switch ( c ) { case 's' : flags |= BDRV_O_SNAPSHOT ; break ; case 'n' : flags |= BDRV_O_NOCACHE ; writethrough = false ; break ; case 'r' : readonly = 1 ; break ; case 'k' : flags |= BDRV_O_NATIVE_AIO ; break ; case 't' : if ( bdrv_parse_cache_mode ( optarg , & flags , & writethrough ) < 0 ) { error_report ( "Invalid<S2SV_blank>cache<S2SV_blank>option:<S2SV_blank>%s" , optarg ) ; qemu_opts_reset ( & empty_opts ) ; return 0 ; } break ; case 'd' : if ( bdrv_parse_discard_flags ( optarg , & flags ) < 0 ) { error_report ( "Invalid<S2SV_blank>discard<S2SV_blank>option:<S2SV_blank>%s" , optarg ) ; qemu_opts_reset ( & empty_opts ) ; return 0 ; } break ; case 'o' : if ( imageOpts ) { printf ( "--image-opts<S2SV_blank>and<S2SV_blank>\'open<S2SV_blank>-o\'<S2SV_blank>are<S2SV_blank>mutually<S2SV_blank>exclusive\\n" ) ; qemu_opts_reset ( & empty_opts ) ; return 0 ; } if ( ! qemu_opts_parse_noisily ( & empty_opts , optarg , false ) ) { qemu_opts_reset ( & empty_opts ) ; return 0 ; } break ; case 'U' : force_share = true ; break ; default : qemu_opts_reset ( & empty_opts ) ; return qemuio_command_usage ( & open_cmd ) ; } } if ( ! readonly ) { flags |= BDRV_O_RDWR ; } if ( imageOpts && ( optind == argc - 1 ) ) { if ( ! qemu_opts_parse_noisily ( & empty_opts , argv [ optind ] , false ) ) { qemu_opts_reset ( & empty_opts ) ; return 0 ; } optind ++ ; } qopts = qemu_opts_find ( & empty_opts , NULL ) ; opts = qopts ? qemu_opts_to_qdict ( qopts , NULL ) : NULL ; qemu_opts_reset ( & empty_opts ) ; if ( optind == argc - 1 ) { <S2SV_StartBug> return openfile ( argv [ optind ] , flags , writethrough , force_share , opts ) ; <S2SV_EndBug> } else if ( optind == argc ) { <S2SV_StartBug> return openfile ( NULL , flags , writethrough , force_share , opts ) ; <S2SV_EndBug> } else { QDECREF ( opts ) ; <S2SV_StartBug> return qemuio_command_usage ( & open_cmd ) ; <S2SV_EndBug> } <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> 1 ) { <S2SV_ModEnd> openfile ( argv <S2SV_ModStart> argc ) { <S2SV_ModEnd> openfile ( NULL <S2SV_ModStart> opts ) ; <S2SV_ModEnd> qemuio_command_usage ( & <S2SV_ModStart> ) ; } return 0 ;
|
453
|
CWE-000 void tfw_connection_release ( TfwConnection * conn ) { TFW_CONN_HOOK_CALL ( conn , conn_release ) ; BUG_ON ( ( TFW_CONN_TYPE ( conn ) & Conn_Clnt ) <S2SV_StartBug> && ! list_empty ( & conn -> msg_queue ) ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> & conn -> seq_queue <S2SV_ModEnd> ) ) ;
|
454
|
CWE-000 void createToken ( char * input , int newFile , char * fileName ) { char * token = ( char * ) malloc ( sizeof ( char ) ) ; char storeChar [ 1 ] = "" ; <S2SV_StartBug> while ( read ( input , storeChar , 1 ) != 0 ) { <S2SV_EndBug> if ( isdigit ( storeChar [ 0 ] ) ) { if ( token == NULL ) { continue ; } } if ( ! isalnum ( storeChar [ 0 ] ) ) { if ( token == NULL ) { continue ; } int index = token [ 0 ] - 'a' ; sortWord ( token , fileName , index ) ; sortFile ( fileName , index ) ; token = NULL ; } <S2SV_StartBug> storeChar = tolower ( storeChar ) ; <S2SV_EndBug> memcpy ( token , storeChar , 1 ) ; char * temp = ( char * ) realloc ( token , sizeof ( char ) ) ; token = temp ; } }
|
<S2SV_ModStart> = "" ; int fd = open ( input , O_RDONLY ) ; <S2SV_ModStart> ( read ( fd <S2SV_ModEnd> , storeChar , <S2SV_ModStart> ; } storeChar [ 0 ] <S2SV_ModStart> tolower ( storeChar [ 0 ]
|
455
|
CWE-000 void print_reg_data ( const struct TaghaScript * script ) { puts ( "\\n\\tPRINTING<S2SV_blank>REGISTER<S2SV_blank>DATA<S2SV_blank>==========================\\n" ) ; for ( uint8_t i = 0 ; i < regsize ; i ++ ) printf ( "register[%s]<S2SV_blank>==<S2SV_blank>%" PRIu64 "\\n" , regid_to_str ( i ) , script -> m_Regs [ i ] . UInt64 ) ; <S2SV_StartBug> printf ( "RSP<S2SV_blank>value<S2SV_blank>==<S2SV_blank>%" PRIu64 "\\n" , script -> m_Regs [ rsp ] . SelfPtr -> UInt64 ) ; <S2SV_EndBug> printf ( "RBP<S2SV_blank>value<S2SV_blank>==<S2SV_blank>%" PRIu64 "\\n" , script -> m_Regs [ rbp ] . SelfPtr -> UInt64 ) ; puts ( "\\tEND<S2SV_blank>OF<S2SV_blank>PRINTING<S2SV_blank>REGISTER<S2SV_blank>DATA<S2SV_blank>===============\\n" ) ; }
|
<S2SV_ModStart> UInt64 ) ; <S2SV_ModEnd> puts ( "\\tEND<S2SV_blank>OF<S2SV_blank>PRINTING<S2SV_blank>REGISTER<S2SV_blank>DATA<S2SV_blank>===============\\n"
|
456
|
CWE-000 static int send_impl ( pk_endpoint_t * ept , int sock , const u8 * data , const size_t length , pk_loop_t * loop , void * poll_handle , client_node_t * node ) { struct iovec iov [ 1 ] = { 0 } ; struct msghdr msg = { 0 } ; iov [ 0 ] . iov_base = ( u8 * ) data ; iov [ 0 ] . iov_len = length ; msg . msg_iov = iov ; msg . msg_iovlen = 1 ; void close_socket_helper ( ) { if ( loop != NULL ) { ASSERT_TRACE ( poll_handle != NULL ) ; ASSERT_TRACE ( node != NULL ) ; pk_loop_poll_remove ( loop , poll_handle ) ; record_disconnect ( ept , node ) ; } shutdown ( sock , SHUT_RDWR ) ; close ( sock ) ; } ; while ( 1 ) { int written = sendmsg ( sock , & msg , 0 ) ; int error = errno ; if ( written != - 1 ) { ASSERT_TRACE ( written == length ) ; return 0 ; } else if ( error == EAGAIN || error == EWOULDBLOCK ) { int queued_input = - 1 ; int error = ioctl ( sock , SIOCINQ , & queued_input ) ; <S2SV_StartBug> if ( error < 0 ) pk_log_anno ( LOG_DEBUG , "unable<S2SV_blank>to<S2SV_blank>read<S2SV_blank>SIOCINQ:<S2SV_blank>%s" , strerror ( errno ) ) ; <S2SV_EndBug> int queued_output = - 1 ; error = ioctl ( sock , SIOCOUTQ , & queued_output ) ; <S2SV_StartBug> if ( error < 0 ) pk_log_anno ( LOG_DEBUG , "unable<S2SV_blank>to<S2SV_blank>read<S2SV_blank>SIOCOUTQ:<S2SV_blank>%s" , strerror ( errno ) ) ; <S2SV_EndBug> <S2SV_StartBug> pk_log_anno ( LOG_WARNING , <S2SV_EndBug> "sendmsg<S2SV_blank>returned<S2SV_blank>EAGAIN,<S2SV_blank>dropping<S2SV_blank>%d<S2SV_blank>bytes<S2SV_blank>" "(path:<S2SV_blank>%s,<S2SV_blank>node:<S2SV_blank>%p,<S2SV_blank>queued<S2SV_blank>input:<S2SV_blank>%d,<S2SV_blank>queued<S2SV_blank>output:<S2SV_blank>%d)" , length , ept -> path , node , queued_input , queued_output ) ; close_socket_helper ( ) ; return 0 ; } else if ( error == EINTR ) { <S2SV_StartBug> pk_log_anno ( LOG_DEBUG , "sendmsg<S2SV_blank>returned<S2SV_blank>with<S2SV_blank>EINTR" ) ; <S2SV_EndBug> continue ; } else { close_socket_helper ( ) ; if ( error != EPIPE && error != ECONNRESET ) { <S2SV_StartBug> pk_log_anno ( LOG_ERR , "error<S2SV_blank>in<S2SV_blank>sendmsg:<S2SV_blank>%s" , strerror ( error ) ) ; <S2SV_EndBug> } return - 1 ; } } }
|
<S2SV_ModStart> < 0 ) PK_LOG_ANNO ( LOG_WARNING <S2SV_ModEnd> , "unable<S2SV_blank>to<S2SV_blank>read<S2SV_blank>SIOCINQ:<S2SV_blank>%s" , <S2SV_ModStart> < 0 ) PK_LOG_ANNO ( LOG_WARNING <S2SV_ModEnd> , "unable<S2SV_blank>to<S2SV_blank>read<S2SV_blank>SIOCOUTQ:<S2SV_blank>%s" , <S2SV_ModStart> ) ) ; PK_LOG_ANNO <S2SV_ModEnd> ( LOG_WARNING , <S2SV_ModStart> EINTR ) { ENDPOINT_DEBUG_LOG ( <S2SV_ModEnd> "sendmsg<S2SV_blank>returned<S2SV_blank>with<S2SV_blank>EINTR" ) ; <S2SV_ModStart> ECONNRESET ) { PK_LOG_ANNO <S2SV_ModEnd> ( LOG_ERR ,
|
457
|
CWE-000 static void binder_transaction_buffer_release ( struct binder_proc * proc , struct binder_buffer * buffer , size_t * failed_at ) { size_t * offp , * off_end ; int debug_id = buffer -> debug_id ; binder_debug ( BINDER_DEBUG_TRANSACTION , "binder:<S2SV_blank>%d<S2SV_blank>buffer<S2SV_blank>release<S2SV_blank>%d,<S2SV_blank>size<S2SV_blank>%zd-%zd,<S2SV_blank>failed<S2SV_blank>at<S2SV_blank>%p\\n" , proc -> pid , buffer -> debug_id , buffer -> data_size , buffer -> offsets_size , failed_at ) ; if ( buffer -> target_node ) binder_dec_node ( buffer -> target_node , 1 , 0 ) ; offp = ( size_t * ) ( buffer -> data + ALIGN ( buffer -> data_size , sizeof ( void * ) ) ) ; if ( failed_at ) off_end = failed_at ; else off_end = ( void * ) offp + buffer -> offsets_size ; for ( ; offp < off_end ; offp ++ ) { struct flat_binder_object * fp ; if ( * offp > buffer -> data_size - sizeof ( * fp ) || buffer -> data_size < sizeof ( * fp ) || ! IS_ALIGNED ( * offp , sizeof ( void * ) ) ) { printk ( KERN_ERR "binder:<S2SV_blank>transaction<S2SV_blank>release<S2SV_blank>%d<S2SV_blank>bad" "offset<S2SV_blank>%zd,<S2SV_blank>size<S2SV_blank>%zd\\n" , debug_id , * offp , buffer -> data_size ) ; continue ; } fp = ( struct flat_binder_object * ) ( buffer -> data + * offp ) ; switch ( fp -> type ) { case BINDER_TYPE_BINDER : case BINDER_TYPE_WEAK_BINDER : { struct binder_node * node = binder_get_node ( proc , fp -> binder ) ; if ( node == NULL ) { printk ( KERN_ERR "binder:<S2SV_blank>transaction<S2SV_blank>release<S2SV_blank>%d" "<S2SV_blank>bad<S2SV_blank>node<S2SV_blank>%p\\n" , debug_id , fp -> binder ) ; break ; } binder_debug ( BINDER_DEBUG_TRANSACTION , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>node<S2SV_blank>%d<S2SV_blank>u%p\\n" , node -> debug_id , node -> ptr ) ; binder_dec_node ( node , fp -> type == BINDER_TYPE_BINDER , 0 ) ; } break ; case BINDER_TYPE_HANDLE : case BINDER_TYPE_WEAK_HANDLE : { struct binder_ref * ref = binder_get_ref ( proc , fp -> handle , fp -> type == BINDER_TYPE_HANDLE ) ; if ( ref == NULL ) { printk ( KERN_ERR "binder:<S2SV_blank>transaction<S2SV_blank>release<S2SV_blank>%d" "<S2SV_blank>bad<S2SV_blank>handle<S2SV_blank>%ld\\n" , debug_id , fp -> handle ) ; break ; } binder_debug ( BINDER_DEBUG_TRANSACTION , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>ref<S2SV_blank>%d<S2SV_blank>desc<S2SV_blank>%d<S2SV_blank>(node<S2SV_blank>%d)\\n" , ref -> debug_id , ref -> desc , ref -> node -> debug_id ) ; <S2SV_StartBug> binder_dec_ref ( ref , fp -> type == BINDER_TYPE_HANDLE ) ; <S2SV_EndBug> } break ; case BINDER_TYPE_FD : binder_debug ( BINDER_DEBUG_TRANSACTION , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>fd<S2SV_blank>%ld\\n" , fp -> handle ) ; if ( failed_at ) task_close_fd ( proc , fp -> handle ) ; break ; default : printk ( KERN_ERR "binder:<S2SV_blank>transaction<S2SV_blank>release<S2SV_blank>%d<S2SV_blank>bad<S2SV_blank>" "object<S2SV_blank>type<S2SV_blank>%lx\\n" , debug_id , fp -> type ) ; break ; } } }
|
<S2SV_ModStart> ; binder_dec_ref ( &
|
458
|
CWE-000 double bin_validate ( ) { int pred [ 1 ] ; int correct_preds = 0 ; <S2SV_StartBug> for ( int i = num_train ; i < num_train + num_val ; ++ i ) <S2SV_EndBug> { <S2SV_StartBug> bin_convolution ( & input_images , & conv_t , 1 , fil_bin_w , alphas , fil_b , i , shuffle_index ) ; <S2SV_EndBug> <S2SV_StartBug> max_pooling ( & conv_t , & pool_t , NULL , NULL , 1 , 'V' ) ; <S2SV_EndBug> <S2SV_StartBug> feed_forward ( & pool_t , & fully_con_out , & fully_con_w , & fully_con_b , 1 ) ; <S2SV_EndBug> <S2SV_StartBug> softmax ( & fully_con_out , & softmax_out , pred , 1 ) ; <S2SV_EndBug> <S2SV_StartBug> correct_preds += ( labels [ shuffle_index [ i ] ] == pred [ 0 ] ) ; <S2SV_EndBug> } return ( correct_preds * 100.0 ) / num_val ; }
|
<S2SV_ModStart> num_train ; i + 1 <S2SV_ModStart> + num_val ; i = i + 2 <S2SV_ModEnd> ) { bin_convolution <S2SV_ModStart> & conv_t , 2 <S2SV_ModEnd> , fil_bin_w , <S2SV_ModStart> , NULL , 2 <S2SV_ModEnd> , 'V' ) <S2SV_ModStart> & fully_con_b , 2 <S2SV_ModEnd> ) ; softmax <S2SV_ModStart> , pred , 2 <S2SV_ModEnd> ) ; correct_preds <S2SV_ModStart> 0 ] ) + ( labels [ shuffle_index [ i + 1 ] ] == pred [ 1 ] )
|
459
|
CWE-000 void sqlite3FinishCoding ( Parse * pParse ) { sqlite3 * db ; Vdbe * v ; assert ( pParse -> pToplevel == 0 ) ; db = pParse -> db ; if ( pParse -> nested ) return ; if ( db -> mallocFailed || pParse -> nErr ) { if ( pParse -> rc == SQLITE_OK ) pParse -> rc = SQLITE_ERROR ; return ; } v = sqlite3GetVdbe ( pParse ) ; assert ( ! pParse -> isMultiWrite || sqlite3VdbeAssertMayAbort ( v , pParse -> mayAbort ) ) ; if ( v ) { sqlite3VdbeAddOp0 ( v , OP_Halt ) ; if ( db -> mallocFailed == 0 && ( DbMaskNonZero ( pParse -> cookieMask ) || pParse -> pConstExpr ) ) { int i ; assert ( sqlite3VdbeGetOp ( v , 0 ) -> opcode == OP_Init ) ; sqlite3VdbeJumpHere ( v , 0 ) ; if ( DbMaskTest ( pParse -> cookieMask , 0 ) != 0 ) { if ( pParse -> initiateTTrans ) sqlite3VdbeAddOp0 ( v , OP_TTransaction ) ; if ( db -> init . busy == 0 ) <S2SV_StartBug> sqlite3VdbeChangeP5 ( v , 1 ) ; <S2SV_EndBug> VdbeComment ( ( v , "usesStmtJournal=%d" , pParse -> mayAbort && pParse -> isMultiWrite ) ) ; } if ( pParse -> pConstExpr ) { ExprList * pEL = pParse -> pConstExpr ; pParse -> okConstFactor = 0 ; for ( i = 0 ; i < pEL -> nExpr ; i ++ ) { sqlite3ExprCode ( pParse , pEL -> a [ i ] . pExpr , pEL -> a [ i ] . u . iConstExprReg ) ; } } sqlite3VdbeGoto ( v , 1 ) ; } } if ( v && pParse -> nErr == 0 && ! db -> mallocFailed ) { assert ( pParse -> iCacheLevel == 0 ) ; if ( pParse -> pAinc != 0 && pParse -> nTab == 0 ) pParse -> nTab = 1 ; sqlite3VdbeMakeReady ( v , pParse ) ; pParse -> rc = SQLITE_DONE ; } else { pParse -> rc = SQLITE_ERROR ; } }
|
<S2SV_ModStart> v , 1 <S2SV_ModEnd> ) ; }
|
460
|
CWE-000 Error_Code ext2_inode_get_data_block_number ( Ext2_Filesystem * ext2fs , Ext2_Inode * inode , uint32_t block_index , uint32_t * result ) { uint32_t EXT2_INODE_DIRECT_BLOCK_COUNT = 12 ; uint32_t block_numbers_per_block = ext2fs -> block_size / sizeof ( uint32_t ) ; uint32_t max_indirect1_block_number = EXT2_INODE_DIRECT_BLOCK_COUNT + block_numbers_per_block ; uint32_t max_indirect2_block_number = EXT2_INODE_DIRECT_BLOCK_COUNT + ( block_numbers_per_block * block_numbers_per_block ) ; if ( block_index < EXT2_INODE_DIRECT_BLOCK_COUNT ) { <S2SV_StartBug> return block_index ; <S2SV_EndBug> } else if ( block_index < max_indirect2_block_number ) { uint8_t buffer [ 4096 ] ; <S2SV_StartBug> if ( ext2_block_read ( ext2fs , inode -> singly_indirect_block_pointer , buffer ) ) { <S2SV_EndBug> return Error_Code_FAILED_READ ; } uint32_t index = block_index - EXT2_INODE_DIRECT_BLOCK_COUNT ; uint32_t * block_number_array = ( uint32_t * ) buffer ; * result = block_number_array [ index ] ; return Error_Code_NONE ; } kassert ( false ) ; return Error_Code_NONE ; }
|
<S2SV_ModStart> EXT2_INODE_DIRECT_BLOCK_COUNT ) { * result = inode -> direct_block_pointers [ block_index ] ; return Error_Code_NONE <S2SV_ModEnd> ; } else <S2SV_ModStart> ) ) { log_error ( VFS , "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>singly_indirect_block_pointer<S2SV_blank>block" ) ;
|
461
|
CWE-000 static int try_to_freeze_tasks ( bool sig_only ) { struct task_struct * g , * p ; unsigned long end_time ; unsigned int todo ; bool wq_busy = false ; struct timeval start , end ; u64 elapsed_csecs64 ; unsigned int elapsed_csecs ; bool wakeup = false ; do_gettimeofday ( & start ) ; end_time = jiffies + TIMEOUT ; if ( ! sig_only ) freeze_workqueues_begin ( ) ; while ( true ) { todo = 0 ; read_lock ( & tasklist_lock ) ; do_each_thread ( g , p ) { if ( frozen ( p ) || ! freezable ( p ) ) continue ; if ( ! freeze_task ( p , sig_only ) ) continue ; if ( ! task_is_stopped_or_traced ( p ) && ! freezer_should_skip ( p ) ) todo ++ ; } while_each_thread ( g , p ) ; read_unlock ( & tasklist_lock ) ; if ( ! sig_only ) { wq_busy = freeze_workqueues_busy ( ) ; todo += wq_busy ; } if ( todo && has_wake_lock ( WAKE_LOCK_SUSPEND ) ) { wakeup = 1 ; break ; } if ( ! todo || time_after ( jiffies , end_time ) ) break ; if ( pm_wakeup_pending ( ) ) { wakeup = true ; break ; } msleep ( 10 ) ; } do_gettimeofday ( & end ) ; elapsed_csecs64 = timeval_to_ns ( & end ) - timeval_to_ns ( & start ) ; do_div ( elapsed_csecs64 , NSEC_PER_SEC / 100 ) ; elapsed_csecs = elapsed_csecs64 ; if ( todo ) { if ( wakeup ) { printk ( "\\n" ) ; printk ( KERN_ERR "Freezing<S2SV_blank>of<S2SV_blank>%s<S2SV_blank>aborted\\n" , sig_only ? "user<S2SV_blank>space<S2SV_blank>" : "tasks<S2SV_blank>" ) ; } else { printk ( "\\n" ) ; printk ( KERN_ERR "Freezing<S2SV_blank>of<S2SV_blank>tasks<S2SV_blank>failed<S2SV_blank>after<S2SV_blank>%d.%02d<S2SV_blank>seconds<S2SV_blank>" "(%d<S2SV_blank>tasks<S2SV_blank>refusing<S2SV_blank>to<S2SV_blank>freeze,<S2SV_blank>wq_busy=%d):\\n" , elapsed_csecs / 100 , elapsed_csecs % 100 , todo - wq_busy , wq_busy ) ; } thaw_workqueues ( ) ; read_lock ( & tasklist_lock ) ; do_each_thread ( g , p ) { <S2SV_StartBug> task_lock ( p ) ; <S2SV_EndBug> <S2SV_StartBug> if ( freezing ( p ) && ! freezer_should_skip ( p ) && <S2SV_EndBug> elapsed_csecs > 100 ) sched_show_task ( p ) ; <S2SV_StartBug> cancel_freezing ( p ) ; <S2SV_EndBug> task_unlock ( p ) ; } while_each_thread ( g , p ) ; read_unlock ( & tasklist_lock ) ; } else { printk ( "(elapsed<S2SV_blank>%d.%02d<S2SV_blank>seconds)<S2SV_blank>" , elapsed_csecs / 100 , elapsed_csecs % 100 ) ; } return todo ? - EBUSY : 0 ; }
|
<S2SV_ModStart> p ) { if ( ! wakeup && <S2SV_ModEnd> freezing ( p <S2SV_ModStart> ( p ) <S2SV_ModEnd> ) sched_show_task ( <S2SV_ModStart> ) ; cancel_freezing <S2SV_ModEnd> ( p )
|
462
|
CWE-000 static NTSTATUS get_subvol_path ( device_extension * Vcb , UINT64 id , WCHAR * out , ULONG outlen , PIRP Irp ) { LIST_ENTRY * le ; root * r = NULL ; NTSTATUS Status ; file_ref * fr ; UNICODE_STRING us ; le = Vcb -> roots . Flink ; while ( le != & Vcb -> roots ) { root * r2 = CONTAINING_RECORD ( le , root , list_entry ) ; if ( r2 -> id == id ) { r = r2 ; break ; } le = le -> Flink ; } if ( ! r ) { ERR ( "couldn\'t<S2SV_blank>find<S2SV_blank>subvol<S2SV_blank>%llx\\n" , id ) ; return STATUS_INTERNAL_ERROR ; } ExAcquireResourceSharedLite ( & Vcb -> fcb_lock , TRUE ) ; Status = open_fileref_by_inode ( Vcb , r , r -> root_item . objid , & fr , Irp ) ; if ( ! NT_SUCCESS ( Status ) ) { ExReleaseResourceLite ( & Vcb -> fcb_lock ) ; ERR ( "open_fileref_by_inode<S2SV_blank>returned<S2SV_blank>%08x\\n" , Status ) ; return Status ; } us . Buffer = out ; us . Length = 0 ; us . MaximumLength = ( USHORT ) min ( 0xffff , outlen ) - sizeof ( WCHAR ) ; Status = fileref_get_filename ( fr , & us , NULL , NULL ) ; <S2SV_StartBug> if ( NT_SUCCESS ( Status ) || STATUS_BUFFER_OVERFLOW ) <S2SV_EndBug> out [ us . Length / sizeof ( WCHAR ) ] = 0 ; else ERR ( "fileref_get_filename<S2SV_blank>returned<S2SV_blank>%08x\\n" , Status ) ; free_fileref ( Vcb , fr ) ; ExReleaseResourceLite ( & Vcb -> fcb_lock ) ; return Status ; }
|
<S2SV_ModStart> Status ) || Status ==
|
463
|
CWE-000 static int create_fixed_stream_quirk ( struct snd_usb_audio * chip , struct usb_interface * iface , struct usb_driver * driver , const struct snd_usb_audio_quirk * quirk ) { struct audioformat * fp ; struct usb_host_interface * alts ; int stream , err ; unsigned * rate_table = NULL ; fp = kmemdup ( quirk -> data , sizeof ( * fp ) , GFP_KERNEL ) ; if ( ! fp ) { snd_printk ( KERN_ERR "cannot<S2SV_blank>memdup\\n" ) ; return - ENOMEM ; <S2SV_StartBug> } <S2SV_EndBug> if ( fp -> nr_rates > MAX_NR_RATES ) { kfree ( fp ) ; return - EINVAL ; } if ( fp -> nr_rates > 0 ) { rate_table = kmemdup ( fp -> rate_table , sizeof ( int ) * fp -> nr_rates , GFP_KERNEL ) ; if ( ! rate_table ) { kfree ( fp ) ; return - ENOMEM ; } fp -> rate_table = rate_table ; } stream = ( fp -> endpoint & USB_DIR_IN ) ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK ; err = snd_usb_add_audio_stream ( chip , stream , fp ) ; if ( err < 0 ) { <S2SV_StartBug> kfree ( fp ) ; <S2SV_EndBug> kfree ( rate_table ) ; return err ; } if ( fp -> iface != get_iface_desc ( & iface -> altsetting [ 0 ] ) -> bInterfaceNumber || fp -> altset_idx >= iface -> num_altsetting ) { <S2SV_StartBug> kfree ( fp ) ; <S2SV_EndBug> kfree ( rate_table ) ; return - EINVAL ; } alts = & iface -> altsetting [ fp -> altset_idx ] ; if ( fp -> datainterval == 0 ) fp -> datainterval = snd_usb_parse_datainterval ( chip , alts ) ; if ( fp -> maxpacksize == 0 ) fp -> maxpacksize = le16_to_cpu ( get_endpoint ( alts , 0 ) -> wMaxPacketSize ) ; usb_set_interface ( chip -> dev , fp -> iface , 0 ) ; snd_usb_init_pitch ( chip , fp -> iface , alts , fp ) ; snd_usb_init_sample_rate ( chip , fp -> iface , alts , fp , fp -> rate_max ) ; return 0 ; }
|
<S2SV_ModStart> ENOMEM ; } INIT_LIST_HEAD ( & fp -> list ) ; <S2SV_ModStart> 0 ) { list_del ( & fp -> list ) ; <S2SV_ModStart> num_altsetting ) { list_del ( & fp -> list ) ;
|
464
|
CWE-000 static void ReleaseClassContents ( Tcl_Interp * interp , Object * oPtr ) { FOREACH_HASH_DECLS ; int i ; Class * clsPtr = oPtr -> classPtr , * mixinSubclassPtr , * subclassPtr ; Object * instancePtr ; Method * mPtr ; Foundation * fPtr = oPtr -> fPtr ; Tcl_Obj * variableObj ; if ( ! Deleted ( oPtr ) ) { if ( IsRootClass ( oPtr ) ) { Tcl_Panic ( "deleting<S2SV_blank>class<S2SV_blank>structure<S2SV_blank>for<S2SV_blank>non-deleted<S2SV_blank>%s" , "::oo::class" ) ; } else if ( IsRootObject ( oPtr ) ) { Tcl_Panic ( "deleting<S2SV_blank>class<S2SV_blank>structure<S2SV_blank>for<S2SV_blank>non-deleted<S2SV_blank>%s" , "::oo::object" ) ; } else { Tcl_Panic ( "deleting<S2SV_blank>class<S2SV_blank>structure<S2SV_blank>for<S2SV_blank>non-deleted<S2SV_blank>%s" , "general<S2SV_blank>object" ) ; } } FOREACH ( mixinSubclassPtr , clsPtr -> mixinSubs ) { if ( mixinSubclassPtr != NULL ) { AddRef ( mixinSubclassPtr ) ; AddRef ( mixinSubclassPtr -> thisPtr ) ; } } FOREACH ( subclassPtr , clsPtr -> subclasses ) { if ( subclassPtr != NULL && ! IsRoot ( subclassPtr ) ) { AddRef ( subclassPtr ) ; AddRef ( subclassPtr -> thisPtr ) ; } } if ( ! IsRootClass ( oPtr ) ) { <S2SV_StartBug> FOREACH ( instancePtr , clsPtr -> instances ) { <S2SV_EndBug> int j ; if ( instancePtr -> selfCls == clsPtr ) { instancePtr -> flags |= CLASS_GONE ; } for ( j = 0 ; j < instancePtr -> mixins . num ; j ++ ) { Class * mixin = instancePtr -> mixins . list [ j ] ; Class * nextMixin = NULL ; if ( mixin == clsPtr ) { if ( j < instancePtr -> mixins . num - 1 ) { nextMixin = instancePtr -> mixins . list [ j + 1 ] ; } if ( j == 0 ) { instancePtr -> mixins . num = 0 ; instancePtr -> mixins . list = NULL ; } else { instancePtr -> mixins . list [ j - 1 ] = nextMixin ; } instancePtr -> mixins . num -= 1 ; } } if ( instancePtr != NULL && ! IsRoot ( instancePtr ) ) { AddRef ( instancePtr ) ; } } } <S2SV_StartBug> FOREACH ( mixinSubclassPtr , clsPtr -> mixinSubs ) { <S2SV_EndBug> if ( ! Deleted ( mixinSubclassPtr -> thisPtr ) ) { Tcl_DeleteCommandFromToken ( interp , mixinSubclassPtr -> thisPtr -> command ) ; } ClearMixins ( mixinSubclassPtr ) ; DelRef ( mixinSubclassPtr -> thisPtr ) ; DelRef ( mixinSubclassPtr ) ; } <S2SV_StartBug> if ( clsPtr -> mixinSubs . list != NULL ) { <S2SV_EndBug> ckfree ( clsPtr -> mixinSubs . list ) ; clsPtr -> mixinSubs . list = NULL ; clsPtr -> mixinSubs . num = 0 ; } FOREACH ( subclassPtr , clsPtr -> subclasses ) { if ( IsRoot ( subclassPtr ) ) { continue ; } if ( ! Deleted ( subclassPtr -> thisPtr ) ) { Tcl_DeleteCommandFromToken ( interp , subclassPtr -> thisPtr -> command ) ; } ClearSuperclasses ( subclassPtr ) ; DelRef ( subclassPtr -> thisPtr ) ; DelRef ( subclassPtr ) ; } if ( clsPtr -> subclasses . list != NULL ) { ckfree ( clsPtr -> subclasses . list ) ; clsPtr -> subclasses . list = NULL ; clsPtr -> subclasses . num = 0 ; } if ( ! IsRootClass ( oPtr ) ) { FOREACH ( instancePtr , clsPtr -> instances ) { <S2SV_StartBug> if ( instancePtr == NULL || IsRoot ( instancePtr ) ) { <S2SV_EndBug> continue ; } if ( ! Deleted ( instancePtr ) ) { Tcl_DeleteCommandFromToken ( interp , instancePtr -> command ) ; i -- ; continue ; } <S2SV_StartBug> DelRef ( instancePtr ) ; <S2SV_EndBug> } } if ( clsPtr -> instances . list != NULL ) { ckfree ( clsPtr -> instances . list ) ; clsPtr -> instances . list = NULL ; clsPtr -> instances . num = 0 ; } if ( IsRootClass ( oPtr ) && ! Deleted ( fPtr -> objectCls -> thisPtr ) ) { Tcl_DeleteCommandFromToken ( interp , fPtr -> objectCls -> thisPtr -> command ) ; } if ( clsPtr -> constructorChainPtr ) { TclOODeleteChain ( clsPtr -> constructorChainPtr ) ; clsPtr -> constructorChainPtr = NULL ; } if ( clsPtr -> destructorChainPtr ) { TclOODeleteChain ( clsPtr -> destructorChainPtr ) ; clsPtr -> destructorChainPtr = NULL ; } if ( clsPtr -> classChainCache ) { CallChain * callPtr ; FOREACH_HASH_VALUE ( callPtr , clsPtr -> classChainCache ) { TclOODeleteChain ( callPtr ) ; } Tcl_DeleteHashTable ( clsPtr -> classChainCache ) ; ckfree ( clsPtr -> classChainCache ) ; clsPtr -> classChainCache = NULL ; } if ( clsPtr -> filters . num ) { Tcl_Obj * filterObj ; FOREACH ( filterObj , clsPtr -> filters ) { TclDecrRefCount ( filterObj ) ; } ckfree ( clsPtr -> filters . list ) ; clsPtr -> filters . num = 0 ; } if ( clsPtr -> metadataPtr != NULL ) { Tcl_ObjectMetadataType * metadataTypePtr ; ClientData value ; FOREACH_HASH ( metadataTypePtr , value , clsPtr -> metadataPtr ) { metadataTypePtr -> deleteProc ( value ) ; } Tcl_DeleteHashTable ( clsPtr -> metadataPtr ) ; ckfree ( clsPtr -> metadataPtr ) ; clsPtr -> metadataPtr = NULL ; } ClearMixins ( clsPtr ) ; ClearSuperclasses ( clsPtr ) ; FOREACH_HASH_VALUE ( mPtr , & clsPtr -> classMethods ) { TclOODelMethodRef ( mPtr ) ; } Tcl_DeleteHashTable ( & clsPtr -> classMethods ) ; TclOODelMethodRef ( clsPtr -> constructorPtr ) ; TclOODelMethodRef ( clsPtr -> destructorPtr ) ; FOREACH ( variableObj , clsPtr -> variables ) { TclDecrRefCount ( variableObj ) ; } if ( i ) { ckfree ( clsPtr -> variables . list ) ; } <S2SV_StartBug> DelRef ( clsPtr ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> clsPtr -> instances ) { if ( instancePtr != oPtr <S2SV_ModStart> } } } } <S2SV_ModStart> clsPtr -> mixinSubs ) { if ( mixinSubclassPtr != clsPtr <S2SV_ModStart> ) ; } } <S2SV_ModStart> if ( instancePtr != oPtr ) { if ( instancePtr <S2SV_ModStart> instancePtr ) ; } <S2SV_ModStart> ) ; } oPtr -> flags |= CLASS_GONE ;
|
465
|
CWE-000 static int indirect_load3 ( t_map * map , t_process * proc , t_bin * bin , int * result ) { if ( ( OCP . param1 == 'D' || OCP . param1 == 'I' ) && OCP . param2 == 'R' ) { if ( ! is_reg ( ( int ) ARENA [ ( POS + 4 ) % MEM_SIZE ] , proc , 6 ) || ! is_reg ( ( int ) ARENA [ ( POS + 5 ) % MEM_SIZE ] , proc , 6 ) ) return ( 0 ) ; <S2SV_StartBug> * result = ( short ) hex_to_int ( 0x00 , 0x00 , ARENA [ ( POS + 2 ) % MEM_SIZE ] , <S2SV_EndBug> <S2SV_StartBug> ARENA [ ( POS + 3 ) % MEM_SIZE ] ) ; <S2SV_EndBug> * result += proc -> reg [ ( int ) ARENA [ ( POS + 4 ) % MEM_SIZE ] - 1 ] ; proc -> reg [ ( int ) ARENA [ ( POS + 5 ) % MEM_SIZE ] - 1 ] = read_in_arena ( map , ( POS + ( * result % IDX_MOD ) ) % MEM_SIZE ) ; proc -> pc = proc -> pc + 6 ; } else if ( ( OCP . param1 == 'D' || OCP . param1 == 'I' ) && OCP . param2 == 'D' ) <S2SV_StartBug> { <S2SV_EndBug> if ( ! is_reg ( ( int ) ARENA [ ( POS + 6 ) % MEM_SIZE ] , proc , 7 ) ) return ( 0 ) ; * result = ( short ) hex_to_int ( 0x00 , 0x00 , ARENA [ ( POS + 2 ) % MEM_SIZE ] , ARENA [ ( POS + 3 ) % MEM_SIZE ] ) ; * result += ( short ) hex_to_int ( 0x00 , 0x00 , ARENA [ ( POS + 4 ) % MEM_SIZE ] , ARENA [ ( POS + 5 ) % MEM_SIZE ] ) ; proc -> reg [ ( int ) ARENA [ ( POS + 6 ) % MEM_SIZE ] - 1 ] = <S2SV_StartBug> read_in_arena ( map , ( POS + ( * result % IDX_MOD ) ) % MEM_SIZE ) ; <S2SV_EndBug> proc -> pc = proc -> pc + 7 ; } return ( 1 ) ; }
|
<S2SV_ModStart> 0 ) ; if ( OCP . param1 == 'D' ) <S2SV_ModStart> % MEM_SIZE ] ) ; else * result = read_in_arena ( map , POS + ( short ) hex_to_int ( 0x00 , 0x00 , ARENA [ ( POS + 2 ) % MEM_SIZE ] , ARENA [ ( POS + 3 ) % MEM_SIZE ] ) % IDX_MOD <S2SV_ModStart> == 'D' ) return ( indirect_load4 <S2SV_ModEnd> ( map , <S2SV_ModStart> ( map , proc , bin , result ) ) ; <S2SV_ModEnd> return ( 1
|
466
|
CWE-000 static void find_abbrev_len_for_pack ( struct packed_git * p , struct min_abbrev_data * mad ) { int match = 0 ; uint32_t num , last , first = 0 ; struct object_id oid ; if ( open_pack_index ( p ) || ! p -> num_objects ) return ; num = p -> num_objects ; last = num ; while ( first < last ) { uint32_t mid = first + ( last - first ) / 2 ; const unsigned char * current ; int cmp ; current = nth_packed_object_sha1 ( p , mid ) ; cmp = hashcmp ( mad -> hash , current ) ; if ( ! cmp ) { match = 1 ; first = mid ; break ; } if ( cmp > 0 ) { first = mid + 1 ; continue ; } last = mid ; } mad -> init_len = 0 ; <S2SV_StartBug> if ( ! match ) { <S2SV_EndBug> <S2SV_StartBug> nth_packed_object_oid ( & oid , p , first ) ; <S2SV_EndBug> extend_abbrev_len ( & oid , mad ) ; <S2SV_StartBug> } else if ( first < num - 1 ) { <S2SV_EndBug> <S2SV_StartBug> nth_packed_object_oid ( & oid , p , first + 1 ) ; <S2SV_EndBug> extend_abbrev_len ( & oid , mad ) ; <S2SV_StartBug> } <S2SV_EndBug> <S2SV_StartBug> if ( first > 0 ) { <S2SV_EndBug> <S2SV_StartBug> nth_packed_object_oid ( & oid , p , first - 1 ) ; <S2SV_EndBug> extend_abbrev_len ( & oid , mad ) ; <S2SV_StartBug> } <S2SV_EndBug> mad -> init_len = mad -> cur_len ; }
|
<S2SV_ModStart> ( ! match && <S2SV_ModEnd> nth_packed_object_oid ( & <S2SV_ModStart> , first ) ) <S2SV_ModEnd> extend_abbrev_len ( & <S2SV_ModStart> mad ) ; <S2SV_ModEnd> if ( first <S2SV_ModStart> num - 1 && <S2SV_ModEnd> nth_packed_object_oid ( & <S2SV_ModStart> + 1 ) ) <S2SV_ModEnd> extend_abbrev_len ( & <S2SV_ModStart> mad ) ; <S2SV_ModEnd> if ( first <S2SV_ModStart> first > 0 && <S2SV_ModEnd> nth_packed_object_oid ( & <S2SV_ModStart> - 1 ) ) <S2SV_ModEnd> extend_abbrev_len ( & <S2SV_ModStart> mad ) ; <S2SV_ModEnd> mad -> init_len
|
467
|
CWE-000 ODBC_TEST ( aliases_tests ) <S2SV_StartBug> { <S2SV_EndBug> char connstr4dsn [ 512 ] ; unsigned int options = 0xf0f0f0f0 ; unsigned int option = ~ options ; FAIL_IF ( ! MADB_DSN_Exists ( DsnName ) , "Something<S2SV_blank>went<S2SV_blank>wrong<S2SV_blank>-<S2SV_blank>DSN<S2SV_blank>does<S2SV_blank>not<S2SV_blank>exsist" ) ; RESET_DSN ( Dsn ) ; <S2SV_StartBug> _snprintf ( connstr4dsn , sizeof ( connstr4dsn ) , "DSN=%s;DRIVER=%s;UID=%s;PWD=%s;SERVER=%s%s;DATABASE=%s;OPTIONS=%u" , DsnName , <S2SV_EndBug> my_drivername , my_uid , my_pwd , my_servername , ma_strport , my_schema , options ) ; IS ( MADB_ParseConnString ( Dsn , connstr4dsn , SQL_NTS , ';' ) ) ; <S2SV_StartBug> IS ( MADB_SaveDSN ( Dsn ) ) ; <S2SV_EndBug> RESET_DSN ( Dsn ) ; <S2SV_StartBug> IS ( MADB_ReadConnString ( Dsn , DsnConnStr , SQL_NTS , TRUE ) ) ; <S2SV_EndBug> FAIL_IF ( Dsn -> UserName == NULL || strncmp ( Dsn -> UserName , my_uid , strlen ( my_uid ) + 1 ) , "Uid<S2SV_blank>stored<S2SV_blank>in/read<S2SV_blank>from<S2SV_blank>DSN<S2SV_blank>incorrectly" ) FAIL_IF ( Dsn -> Password == NULL || strncmp ( Dsn -> Password , my_pwd , strlen ( my_pwd ) + 1 ) , "Pwd<S2SV_blank>stored<S2SV_blank>in/read<S2SV_blank>from<S2SV_blank>DSN<S2SV_blank>incorrectly" ) IS_STR ( Dsn -> ServerName , my_servername , strlen ( my_servername ) + 1 ) ; IS_STR ( Dsn -> Catalog , my_schema , strlen ( my_schema ) + 1 ) ; is_num ( Dsn -> Options , options ) ; <S2SV_StartBug> _snprintf ( connstr4dsn , sizeof ( connstr4dsn ) , "DSN=%s;USER=user;PASSWORD=password;SERVERNAME=servername;DB=randomdbname;OPTION=%u" , DsnName , option ) ; <S2SV_EndBug> IS ( MADB_ReadConnString ( Dsn , connstr4dsn , SQL_NTS , TRUE ) ) ; IS_STR ( Dsn -> UserName , "user" , sizeof ( "user" ) ) ; IS_STR ( Dsn -> Password , "password" , sizeof ( "password" ) ) ; IS_STR ( Dsn -> ServerName , "servername" , sizeof ( "servername" ) ) ; IS_STR ( Dsn -> Catalog , "randomdbname" , sizeof ( "randomdbname" ) ) ; <S2SV_StartBug> is_num ( Dsn -> Options , option ) ; <S2SV_EndBug> return OK ; }
|
<S2SV_ModStart> aliases_tests ) { const char * LocalDSName = "madb_connstr_aliases_test" ; const char * LocalConnStr = "DSN=madb_connstr_aliases_test" ; <S2SV_ModStart> , "DSN=%s;DRIVER=%s;UID=%s;PWD=%s;SERVER=%s%s;DATABASE=%s;OPTIONS=%u" , LocalDSName <S2SV_ModEnd> , my_drivername , <S2SV_ModStart> ; IS ( CreateTestDsn <S2SV_ModEnd> ( Dsn ) <S2SV_ModStart> ( Dsn , LocalConnStr <S2SV_ModEnd> , SQL_NTS , <S2SV_ModStart> , "DSN=%s;USER=user;PASSWORD=password;SERVERNAME=servername;DB=randomdbname;OPTION=%u" , LocalDSName <S2SV_ModEnd> , option ) <S2SV_ModStart> Options , option ) ; FAIL_IF ( PopDSN ( ) , "Could<S2SV_blank>not<S2SV_blank>remove<S2SV_blank>DSN"
|
468
|
CWE-000 static void handle_caw_read_cbk ( struct tcmu_device * dev , struct tcmulib_cmd * readcmd , int ret ) { struct tcmur_device * rdev = tcmu_get_daemon_dev_private ( dev ) ; uint32_t cmp_offset ; struct caw_state * state = readcmd -> cmdstate ; struct tcmulib_cmd * origcmd = state -> origcmd ; uint8_t * sense = origcmd -> sense_buf ; if ( ret != SAM_STAT_GOOD ) { memcpy ( origcmd -> sense_buf , readcmd -> sense_buf , sizeof ( origcmd -> sense_buf ) ) ; goto finish_err ; } cmp_offset = tcmu_compare_with_iovec ( state -> read_buf , origcmd -> iovec , state -> requested ) ; if ( cmp_offset != - 1 ) { ret = tcmu_set_sense_data ( sense , MISCOMPARE , ASC_MISCOMPARE_DURING_VERIFY_OPERATION , & cmp_offset ) ; goto finish_err ; } <S2SV_StartBug> tcmu_seek_in_iovec ( origcmd -> iovec , state -> requested ) ; <S2SV_EndBug> origcmd -> done = handle_caw_write_cbk ; ret = async_handle_cmd ( dev , origcmd , write_work_fn ) ; if ( ret != TCMU_ASYNC_HANDLED ) goto finish_err ; caw_free_readcmd ( readcmd ) ; return ; finish_err : pthread_mutex_unlock ( & rdev -> caw_lock ) ; aio_command_finish ( dev , origcmd , ret ) ; caw_free_readcmd ( readcmd ) ; }
|
<S2SV_ModStart> finish_err ; } tcmu_seek_in_cmd_iovec ( origcmd <S2SV_ModEnd> , state ->
|
469
|
CWE-000 bool dylib_load_for_task ( dylib_t * dylib , pcb_t * pcb ) { dylib_list_t * list = kmalloc ( sizeof ( dylib_list_t ) ) ; if ( ! list ) return false ; down ( & dylib -> lock ) ; page_list_map_list ( dylib -> page_list , true ) ; memset ( list , 0 , sizeof ( dylib_list_t ) ) ; list -> dylib = dylib ; page_list_t * p = dylib -> page_list ; page_list_t * pl = NULL ; uint32_t num_pages = 0 ; uint32_t offset = ( uint32_t ) - 1 ; while ( p ) { page_list_t * page = page_list_add_copy ( & pl , p ) ; if ( ! page ) { page_list_dealloc ( pl ) ; kfree ( list ) ; page_list_unmap_list ( dylib -> page_list , true ) ; up ( & dylib -> lock ) ; return false ; } num_pages ++ ; if ( offset > page -> vaddr ) offset = page -> vaddr ; p = p -> next ; } page_list_unmap_list ( dylib -> page_list , true ) ; up ( & dylib -> lock ) ; <S2SV_StartBug> set_current_task ( pcb ) ; <S2SV_EndBug> vm_lock ( ) ; uint32_t vaddr = vm_get_next_unmapped_pages ( num_pages , VIRTUAL_MEMORY_USER ) ; if ( ! vaddr ) { vm_unlock ( ) ; page_list_dealloc ( pl ) ; kfree ( list ) ; return false ; } list -> offset = vaddr ; p = pl ; while ( p ) { p -> vaddr += vaddr - offset ; p = p -> next ; } page_list_t * pl_end = pl ; while ( pl_end && pl_end -> next ) pl_end = pl_end -> next ; pl_end -> next = pcb -> page_list ; if ( pcb -> page_list ) pcb -> page_list -> prev = pl_end ; pcb -> page_list = pl ; p = pl ; while ( p && p != pl_end -> next ) { page_list_map ( p , true ) ; p = p -> next ; } vm_unlock ( ) ; down ( & pcb -> lock ) ; dylib_list_push_back ( & pcb -> dylibs , list ) ; up ( & pcb -> lock ) ; dylib -> num_instances ++ ; return true ; }
|
<S2SV_ModStart> lock ) ; page_list_map_list ( pcb -> page_list , false ) ; page_list_map_list ( pcb -> temporary_mappings , false <S2SV_ModEnd> ) ; vm_lock
|
470
|
CWE-000 void getVendor ( int fd ) { char tx_cmd [ 50 ] ; char rx_cmd [ 256 ] ; char dststr [ 256 ] ; char * res ; int nread ; <S2SV_StartBug> strcpy ( tx_cmd , "AT+COPS?\\r\\n\\0" ) ; <S2SV_EndBug> write ( fd , tx_cmd , strlen ( tx_cmd ) ) ; usleep ( 100000 ) ; nread = read ( fd , rx_cmd , sizeof ( rx_cmd ) ) ; res = strstr ( rx_cmd , "ERROR" ) ; if ( res != NULL ) { sprintf ( dststr , "Vendor:<S2SV_blank>NA\\n\\0" ) ; printf ( "%s" , dststr ) ; setConfigFile ( dststr ) ; return ; } <S2SV_StartBug> strcpy ( dststr , "Vendor:<S2SV_blank>" ) ; <S2SV_EndBug> res = strstr ( rx_cmd , "CMCC" ) ; if ( res != NULL ) { <S2SV_StartBug> strcat ( dststr , "CMCC" ) ; <S2SV_EndBug> } res = strstr ( rx_cmd , "UNICOM" ) ; if ( res != NULL ) { <S2SV_StartBug> strcat ( dststr , "UNICOM" ) ; <S2SV_EndBug> } res = strstr ( rx_cmd , "CHN-CT" ) ; if ( res != NULL ) { <S2SV_StartBug> strcat ( dststr , "CHN-CT" ) ; <S2SV_EndBug> } strcat ( dststr , "\\n\\0" ) ; printf ( "%s" , dststr ) ; setConfigFile ( dststr ) ; }
|
<S2SV_ModStart> int nread ; memset ( dststr , 0 , sizeof ( dststr ) ) ; <S2SV_ModStart> return ; } strncpy <S2SV_ModEnd> ( dststr , <S2SV_ModStart> dststr , "Vendor:<S2SV_blank>" , 8 <S2SV_ModStart> ( dststr , "CMCC\\n\\0" <S2SV_ModEnd> ) ; } <S2SV_ModStart> ( dststr , "UNICOM\\n\\0" <S2SV_ModEnd> ) ; } <S2SV_ModStart> ( dststr , "CHN-CT\\n\\0" ) ; } <S2SV_ModEnd> printf ( "%s"
|
471
|
CWE-000 static void GPENCIL_cache_populate ( void * vedata , Object * ob ) <S2SV_StartBug> { <S2SV_EndBug> GPENCIL_StorageList * stl = ( ( GPENCIL_Data * ) vedata ) -> stl ; const DRWContextState * draw_ctx = DRW_context_state_get ( ) ; Scene * scene = draw_ctx -> scene ; ToolSettings * ts = scene -> toolsettings ; bool playing = ( bool ) stl -> storage -> playing ; if ( ob -> type == OB_GPENCIL && ob -> data ) { if ( ( stl -> g_data -> session_flag & GP_DRW_PAINT_READY ) == 0 ) { if ( G . debug_value == 665 ) { printf ( "GPENCIL_cache_populate:<S2SV_blank>%s\\n" , ob -> id . name ) ; } stl -> g_data -> gp_object_cache = gpencil_object_cache_allocate ( stl -> g_data -> gp_object_cache , & stl -> g_data -> gp_cache_size , & stl -> g_data -> gp_cache_used ) ; gpencil_object_cache_add ( stl -> g_data -> gp_object_cache , ob , & stl -> g_data -> gp_cache_used ) ; if ( ! GP_SIMPLIFY_MODIF ( ts , playing ) ) { gpencil_array_modifiers ( stl , ob ) ; } } DRW_gpencil_populate_buffer_strokes ( & e_data , vedata , ts , ob ) ; } }
|
<S2SV_ModStart> ob ) { if ( ! BKE_object_is_visible ( ob ) ) { return ; }
|
472
|
CWE-000 const u8 * ReadRealDisc ( u32 * Length , u32 Offset , bool NeedSync ) { u32 CachedBlockStart = 0 ; u32 ReadDiff = 0 ; u32 TmpLen = * Length ; <S2SV_StartBug> u64 TmpOffset = ( u64 ) Offset + ISOShift64 ; <S2SV_EndBug> if ( RealDiscCMD == DIP_CMD_DVDR ) { u64 AlignedOffset = ALIGN_BACKWARD ( TmpOffset , 0x800 ) ; ReadDiff = ( u32 ) ( TmpOffset - AlignedOffset ) ; if ( AlignedOffset == DVD_OFFSET64 ) { sync_before_read ( DISC_TMP_CACHE , 0x800 ) ; memcpy ( DISC_FRONT_CACHE , DISC_TMP_CACHE , 0x800 ) ; CachedBlockStart = 0x800 ; u32 AlignedLength = ALIGN_FORWARD ( TmpLen + ReadDiff , 0x800 ) ; if ( AlignedLength > 0 && AlignedLength == CachedBlockStart ) return ( DISC_FRONT_CACHE + ReadDiff ) ; } } if ( NeedSync ) { WaitForWrite = 1 ; while ( WaitForWrite == 1 ) udelay ( 20 ) ; } <S2SV_StartBug> if ( access_led ) set32 ( HW_GPIO_OUT , GPIO_SLOT_LED ) ; <S2SV_EndBug> if ( TmpLen > DISC_DRIVE_BUFFER_LENGTH - ReadDiff ) { TmpLen = DISC_DRIVE_BUFFER_LENGTH - ReadDiff ; * Length = TmpLen ; } <S2SV_StartBug> write32 ( DIP_STATUS , 0x54 ) ; <S2SV_EndBug> if ( RealDiscCMD == DIP_CMD_DVDR ) { TmpLen = ALIGN_FORWARD ( TmpLen + ReadDiff , 0x800 ) - CachedBlockStart ; TmpOffset = ALIGN_BACKWARD ( TmpOffset , 0x800 ) + CachedBlockStart ; write32 ( DIP_CMD_0 , DIP_CMD_DVDR << 24 ) ; write32 ( DIP_CMD_1 , ( u32 ) ( TmpOffset >> 11 ) ) ; write32 ( DIP_CMD_2 , TmpLen >> 11 ) ; } else { write32 ( DIP_CMD_0 , DIP_CMD_NORMAL << 24 ) ; write32 ( DIP_CMD_1 , ( u32 ) ( TmpOffset >> 2 ) ) ; write32 ( DIP_CMD_2 , TmpLen ) ; } sync_before_read ( DISC_DRIVE_BUFFER , TmpLen ) ; write32 ( DIP_DMA_ADR , ( u32 ) DISC_DRIVE_BUFFER ) ; write32 ( DIP_DMA_LEN , TmpLen ) ; write32 ( DIP_CONTROL , 3 ) ; udelay ( 70 ) ; if ( NeedSync ) { WaitForRead = 1 ; while ( WaitForRead == 1 ) udelay ( 200 ) ; } else { while ( read32 ( DIP_CONTROL ) & 1 ) udelay ( 200 ) ; write32 ( DIP_STATUS , 0x54 ) ; udelay ( 70 ) ; } <S2SV_StartBug> if ( access_led ) clear32 ( HW_GPIO_OUT , GPIO_SLOT_LED ) ; <S2SV_EndBug> if ( RealDiscCMD == DIP_CMD_DVDR ) { u64 LastBlockStart = ( ( u64 ) ( read32 ( DIP_CMD_2 ) ) - 1 ) << 11 ; DVD_OFFSET64 = ( ( u64 ) ( read32 ( DIP_CMD_1 ) ) << 11 ) + LastBlockStart ; memcpy ( DISC_TMP_CACHE , DISC_DRIVE_BUFFER + LastBlockStart , 0x800 ) ; sync_after_write ( DISC_TMP_CACHE , 0x800 ) ; if ( CachedBlockStart ) return ( DISC_FRONT_CACHE + ReadDiff ) ; } return DISC_DRIVE_BUFFER + ReadDiff ; }
|
<S2SV_ModStart> + ISOShift64 ; if ( RealDiscCMD != DIP_CMD_WIIVC ) { <S2SV_ModStart> ) ; } } <S2SV_ModStart> TmpLen ; } if ( RealDiscCMD == DIP_CMD_WIIVC ) { sync_before_read ( DISC_DRIVE_BUFFER , TmpLen ) ; WDVD_FST_Read ( DISC_DRIVE_BUFFER , TmpOffset , TmpLen ) ; } else { <S2SV_ModStart> ) ; } }
|
473
|
CWE-000 static inline int l2cap_config_req ( struct l2cap_conn * conn , struct l2cap_cmd_hdr * cmd , u16 cmd_len , u8 * data ) { struct l2cap_conf_req * req = ( struct l2cap_conf_req * ) data ; u16 dcid , flags ; u8 rsp [ 64 ] ; struct l2cap_chan * chan ; int len , err = 0 ; if ( cmd_len < sizeof ( * req ) ) return - EPROTO ; dcid = __le16_to_cpu ( req -> dcid ) ; flags = __le16_to_cpu ( req -> flags ) ; BT_DBG ( "dcid<S2SV_blank>0x%4.4x<S2SV_blank>flags<S2SV_blank>0x%2.2x" , dcid , flags ) ; chan = l2cap_get_chan_by_scid ( conn , dcid ) ; if ( ! chan ) { cmd_reject_invalid_cid ( conn , cmd -> ident , dcid , 0 ) ; return 0 ; } if ( chan -> state != BT_CONFIG && chan -> state != BT_CONNECT2 ) { cmd_reject_invalid_cid ( conn , cmd -> ident , chan -> scid , chan -> dcid ) ; goto unlock ; } len = cmd_len - sizeof ( * req ) ; if ( chan -> conf_len + len > sizeof ( chan -> conf_req ) ) { l2cap_send_cmd ( conn , cmd -> ident , L2CAP_CONF_RSP , l2cap_build_conf_rsp ( chan , rsp , L2CAP_CONF_REJECT , flags ) , rsp ) ; goto unlock ; } memcpy ( chan -> conf_req + chan -> conf_len , req -> data , len ) ; chan -> conf_len += len ; if ( flags & L2CAP_CONF_FLAG_CONTINUATION ) { l2cap_send_cmd ( conn , cmd -> ident , L2CAP_CONF_RSP , l2cap_build_conf_rsp ( chan , rsp , L2CAP_CONF_SUCCESS , flags ) , rsp ) ; goto unlock ; } <S2SV_StartBug> len = l2cap_parse_conf_req ( chan , rsp ) ; <S2SV_EndBug> if ( len < 0 ) { l2cap_send_disconn_req ( chan , ECONNRESET ) ; goto unlock ; } chan -> ident = cmd -> ident ; l2cap_send_cmd ( conn , cmd -> ident , L2CAP_CONF_RSP , len , rsp ) ; chan -> num_conf_rsp ++ ; chan -> conf_len = 0 ; if ( ! test_bit ( CONF_OUTPUT_DONE , & chan -> conf_state ) ) goto unlock ; if ( test_bit ( CONF_INPUT_DONE , & chan -> conf_state ) ) { set_default_fcs ( chan ) ; if ( chan -> mode == L2CAP_MODE_ERTM || chan -> mode == L2CAP_MODE_STREAMING ) err = l2cap_ertm_init ( chan ) ; if ( err < 0 ) l2cap_send_disconn_req ( chan , - err ) ; else l2cap_chan_ready ( chan ) ; goto unlock ; } if ( ! test_and_set_bit ( CONF_REQ_SENT , & chan -> conf_state ) ) { u8 buf [ 64 ] ; l2cap_send_cmd ( conn , l2cap_get_ident ( conn ) , L2CAP_CONF_REQ , <S2SV_StartBug> l2cap_build_conf_req ( chan , buf ) , buf ) ; <S2SV_EndBug> chan -> num_conf_req ++ ; } if ( test_bit ( CONF_REM_CONF_PEND , & chan -> conf_state ) && test_bit ( CONF_LOC_CONF_PEND , & chan -> conf_state ) ) { if ( ! chan -> hs_hcon ) l2cap_send_efs_conf_rsp ( chan , rsp , cmd -> ident , flags ) ; else chan -> ident = cmd -> ident ; } unlock : l2cap_chan_unlock ( chan ) ; return err ; }
|
<S2SV_ModStart> chan , rsp , sizeof ( rsp ) <S2SV_ModStart> chan , buf , sizeof ( buf )
|
474
|
CWE-000 static const char * get_name ( unsigned int bank , struct threshold_block * b ) { <S2SV_StartBug> unsigned int bank_type ; <S2SV_EndBug> if ( ! mce_flags . smca ) { if ( b && bank == 4 ) return bank4_names ( b ) ; return th_names [ bank ] ; } <S2SV_StartBug> if ( ! smca_banks [ bank ] . hwid ) <S2SV_EndBug> <S2SV_StartBug> return NULL ; <S2SV_EndBug> bank_type = smca_banks [ bank ] . hwid -> bank_type ; if ( b && bank_type == SMCA_UMC ) { if ( b -> block < ARRAY_SIZE ( smca_umc_block_names ) ) return smca_umc_block_names [ b -> block ] ; return NULL ; } if ( smca_banks [ bank ] . hwid -> count == 1 ) return smca_get_name ( bank_type ) ; snprintf ( buf_mcatype , MAX_MCATYPE_NAME_LEN , "%s_%x" , smca_get_name ( bank_type ) , smca_banks [ bank ] . sysfs_id ) ; return buf_mcatype ; }
|
<S2SV_ModStart> b ) { enum smca_bank_types <S2SV_ModEnd> bank_type ; if <S2SV_ModStart> ] ; } bank_type = smca_get_bank_type ( bank ) ; if ( bank_type >= N_SMCA_BANK_TYPES <S2SV_ModEnd> ) return NULL <S2SV_ModStart> ) return NULL <S2SV_ModEnd> ; if (
|
475
|
CWE-000 static int efifb_setcolreg ( unsigned regno , unsigned red , unsigned green , unsigned blue , unsigned transp , struct fb_info * info ) { if ( regno >= info -> cmap . len ) return 1 ; if ( regno < 16 ) { <S2SV_StartBug> red >>= 8 ; <S2SV_EndBug> <S2SV_StartBug> green >>= 8 ; <S2SV_EndBug> <S2SV_StartBug> blue >>= 8 ; <S2SV_EndBug> ( ( u32 * ) ( info -> pseudo_palette ) ) [ regno ] = ( red << info -> var . red . offset ) | ( green << info -> var . green . offset ) | ( blue << info -> var . blue . offset ) ; } return 0 ; }
|
<S2SV_ModStart> { red >>= 16 - info -> var . red . length <S2SV_ModEnd> ; green >>= <S2SV_ModStart> ; green >>= 16 - info -> var . green . length <S2SV_ModEnd> ; blue >>= <S2SV_ModStart> ; blue >>= 16 - info -> var . blue . length <S2SV_ModEnd> ; ( (
|
476
|
CWE-000 void instr_handler_BEQ ( ) { uint32_t instr = mem_read_32 ( CURRENT_STATE . PC ) ; uint8_t rs = GET_RS ( instr ) ; uint8_t rt = GET_RT ( instr ) ; <S2SV_StartBug> uint16_t immed = GET_IMMED ( instr ) ; <S2SV_EndBug> uint32_t rs_val = CURRENT_STATE . REGS [ rs ] ; uint32_t rt_val = CURRENT_STATE . REGS [ rt ] ; if ( rs_val == rt_val ) { NEXT_STATE . PC = ( CURRENT_STATE . PC + immed ) ; } else { NEXT_STATE . PC += 4 ; } }
|
<S2SV_ModStart> instr ) ; int16_t <S2SV_ModEnd> immed = GET_IMMED
|
477
|
CWE-000 void read_3d_dataset_file ( const char * filename , hsize_t dataset_size [ ] , hsize_t buffer_size [ ] ) { int buffer_length = buffer_size [ 0 ] * buffer_size [ 1 ] * buffer_size [ 2 ] ; int * read_buffer = malloc ( sizeof ( int ) * buffer_length ) ; hid_t file_identifier = H5Fopen ( filename , H5F_ACC_RDONLY , H5P_DEFAULT ) ; hid_t dataset_identifier = H5Dopen2 ( file_identifier , "image_data" , H5P_DEFAULT ) ; hid_t dataspace_identifier = H5Dget_space ( dataset_identifier ) ; hid_t memspace_identifier = H5Screate_simple ( 3 , buffer_size , NULL ) ; <S2SV_StartBug> hsize_t stride [ ] = { 1 , 1 , 1 } ; <S2SV_EndBug> hsize_t block [ ] = { 1 , 1 , 1 } ; hsize_t offset [ ] = { 0 , 0 , 0 } ; int n_of_chunks = dataset_size [ 0 ] / buffer_size [ 0 ] ; for ( int z = 0 ; z < n_of_chunks ; z ++ ) { <S2SV_StartBug> offset [ 0 ] = z * buffer_size [ 0 ] ; <S2SV_EndBug> H5Sselect_hyperslab ( dataspace_identifier , H5S_SELECT_SET , offset , stride , buffer_size , block ) ; H5Dread ( dataset_identifier , H5T_NATIVE_INT , memspace_identifier , dataspace_identifier , H5P_DEFAULT , & read_buffer [ 0 ] ) ; # ifdef DEBUG int n_frames_in_chunk = dataset_size [ 0 ] / n_of_chunks ; for ( int f = 0 ; f < n_frames_in_chunk ; f ++ ) { int current_frame = ( z * n_frames_in_chunk ) + f ; printf ( "Frame<S2SV_blank>%d,<S2SV_blank>File<S2SV_blank>%s\\n" , current_frame , filename ) ; for ( int y = 0 ; y < dataset_size [ 1 ] ; y ++ ) { for ( int x = 0 ; x < dataset_size [ 2 ] ; x ++ ) { int offset = ( f * dataset_size [ 1 ] * dataset_size [ 2 ] ) + ( y * dataset_size [ 2 ] ) + x ; printf ( "%d<S2SV_blank>" , read_buffer [ offset ] ) ; } printf ( "\\n" ) ; } printf ( "\\n" ) ; } # endif } H5Sclose ( memspace_identifier ) ; H5Sclose ( dataspace_identifier ) ; H5Dclose ( dataset_identifier ) ; H5Fclose ( file_identifier ) ; free ( read_buffer ) ; }
|
<S2SV_ModStart> NULL ) ; <S2SV_ModEnd> int n_of_chunks = <S2SV_ModStart> ++ ) { read_3d_dataset_chunk ( dataset_identifier , dataspace_identifier , memspace_identifier , z * buffer_size [ 0 ] , buffer_size <S2SV_ModEnd> , & read_buffer
|
478
|
CWE-000 retcode_t iota_consensus_transaction_solidifier_init ( transaction_solidifier_t * const ts , iota_consensus_conf_t * const conf , <S2SV_StartBug> tangle_t * const tangle , requester_state_t * const requester , <S2SV_EndBug> tips_cache_t * const tips ) { ts -> conf = conf ; ts -> tangle = tangle ; <S2SV_StartBug> ts -> requester = requester ; <S2SV_EndBug> ts -> running = false ; ts -> newly_set_solid_transactions = NULL ; ts -> solid_transactions_candidates = NULL ; ts -> tips = tips ; lock_handle_init ( & ts -> lock ) ; logger_helper_init ( TRANSACTION_SOLIDIFIER_LOGGER_ID , LOGGER_DEBUG , true ) ; return RC_OK ; }
|
<S2SV_ModStart> const tangle , transaction_requester_t * const transaction_requester <S2SV_ModEnd> , tips_cache_t * <S2SV_ModStart> ; ts -> transaction_requester = transaction_requester <S2SV_ModEnd> ; ts ->
|
479
|
CWE-000 static void radeon_pci_shutdown ( struct pci_dev * pdev ) { <S2SV_StartBug> radeon_pci_remove ( pdev ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> pdev ) { if ( radeon_device_is_virtual ( ) )
|
480
|
CWE-000 static GHashTable * _geocode_location_to_params ( GeocodeLocation * location ) { <S2SV_StartBug> GHashTable * ht ; <S2SV_EndBug> char lat [ G_ASCII_DTOSTR_BUF_SIZE ] ; char lon [ G_ASCII_DTOSTR_BUF_SIZE ] ; g_ascii_dtostr ( lat , G_ASCII_DTOSTR_BUF_SIZE , geocode_location_get_latitude ( location ) ) ; g_ascii_dtostr ( lon , G_ASCII_DTOSTR_BUF_SIZE , geocode_location_get_longitude ( location ) ) ; ht = g_hash_table_new_full ( g_str_hash , g_str_equal , NULL , ( GDestroyNotify ) free_value ) ; <S2SV_StartBug> g_hash_table_insert ( ht , ( gpointer ) "lat" , str_to_value ( lat ) ) ; <S2SV_EndBug> <S2SV_StartBug> g_hash_table_insert ( ht , ( gpointer ) "lon" , str_to_value ( lon ) ) ; <S2SV_EndBug> return ht ; }
|
<S2SV_ModStart> GHashTable * ht <S2SV_ModEnd> ; ht = <S2SV_ModStart> ) "lat" , double_to_value ( geocode_location_get_latitude ( location ) <S2SV_ModEnd> ) ) ; <S2SV_ModStart> ) "lon" , double_to_value ( geocode_location_get_longitude ( location ) <S2SV_ModEnd> ) ) ;
|
481
|
CWE-000 void pipe_init ( void ) { <S2SV_StartBug> pool_init ( & pipe_cache , sizeof ( pipe_t ) , pipe_ctor , pipe_dtor ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> void ) { pipe_cache = pool_create ( "Pool<S2SV_blank>cache<S2SV_blank>for<S2SV_blank>pipe" <S2SV_ModEnd> , sizeof (
|
482
|
CWE-000 static void largest_contiguous_chunk ( struct loop_arguments * largs , struct connection * conn , const void * * position , size_t * available_header , size_t * available_body ) { off_t * current_offset = & conn -> write_offset ; size_t accessible_size = conn -> data . total_size ; size_t available = accessible_size - * current_offset ; if ( conn -> traffic_ongoing . bytes_rcvd == 0 && conn -> traffic_ongoing . bytes_sent <= conn -> data . ws_hdr_size && conn -> ws_state == WSTATE_SENDING_HTTP_UPGRADE && largs -> params . websocket_enable ) { accessible_size = conn -> data . ws_hdr_size ; size_t available = accessible_size - * current_offset ; * position = conn -> data . ptr + * current_offset ; * available_header = available ; * available_body = 0 ; return ; } if ( conn -> traffic_ongoing . bytes_sent < conn -> data . once_size ) { * available_header = conn -> data . once_size - conn -> traffic_ongoing . bytes_sent ; assert ( available ) ; } else { * available_header = 0 ; } if ( available ) { * position = conn -> data . ptr + * current_offset ; * available_body = available - * available_header ; } else { <S2SV_StartBug> if ( largs -> params . message_collection . most_dynamic_expression <S2SV_EndBug> == DS_PER_MESSAGE && ( conn -> conn_type == CONN_OUTGOING || ( largs -> params . listen_mode & _LMODE_SND_MASK ) ) ) { <S2SV_StartBug> explode_data_template_override ( & largs -> params . message_collection , <S2SV_EndBug> ( conn -> conn_type == CONN_OUTGOING ) ? TWS_SIDE_CLIENT : TWS_SIDE_SERVER , & conn -> data , largs , conn ) ; accessible_size = conn -> data . total_size ; } size_t off = conn -> data . once_size ; * position = conn -> data . ptr + off ; * available_body = accessible_size - off ; * current_offset = off ; } if ( largs -> params . message_marker ) { if ( * position < conn -> data . marker_token_ptr ) { struct timeval tp ; gettimeofday ( & tp , NULL ) ; unsigned long long ts = ( unsigned long long ) tp . tv_sec * 1000000 + tp . tv_usec ; override_timestamp ( conn -> data . marker_token_ptr , ( * available_body ) , ts ) ; } else { update_timestamps ( ( char * ) * position , * available_body ) ; } } }
|
<S2SV_ModStart> { if ( conn -> <S2SV_ModEnd> message_collection . most_dynamic_expression <S2SV_ModStart> explode_data_template_override ( & conn -> <S2SV_ModEnd> message_collection , (
|
483
|
CWE-000 int main ( ) { GPIOAddress address [ ] = { { 0 , 0 } , { 0 , 1 } , { 0 , 2 } , { 0 , 3 } , { 0 , 4 } , { 0 , 5 } , { 0 , 6 } , { 0 , 7 } , { 1 , 0 } , { 1 , 1 } , { 2 , 0 } , { 2 , 1 } , { 2 , 2 } , { 2 , 3 } , { 2 , 4 } , { 2 , 5 } } ; GPIOSettings settings = { GPIO_DIR_IN , GPIO_STATE_LOW , GPIO_RES_NONE , GPIO_ALTFN_ANALOG } ; gpio_init ( ) ; interrupt_init ( ) ; for ( uint8_t i = 0 ; i < 16 ; i ++ ) { gpio_init_pin ( & address [ i ] , & settings ) ; } uint16_t adc_readings [ NUM_ADC_CHANNEL ] ; memset ( adc_readings , 0 , sizeof ( adc_readings ) ) ; adc_init ( ADC_MODE_CONTINUOUS ) ; <S2SV_StartBug> adc_set_channel ( ADC_CHANNEL_10 , 1 ) ; <S2SV_EndBug> adc_set_channel ( ADC_CHANNEL_11 , 1 ) ; adc_set_channel ( ADC_CHANNEL_12 , 1 ) ; adc_set_channel ( ADC_CHANNEL_13 , 1 ) ; <S2SV_StartBug> adc_set_channel ( ADC_CHANNEL_REF , 1 ) ; <S2SV_EndBug> adc_register_callback ( ADC_CHANNEL_10 , test_callback , & adc_readings [ ADC_CHANNEL_10 ] ) ; adc_register_callback ( ADC_CHANNEL_11 , test_callback , & adc_readings [ ADC_CHANNEL_11 ] ) ; adc_register_callback ( ADC_CHANNEL_12 , test_callback , & adc_readings [ ADC_CHANNEL_12 ] ) ; adc_register_callback ( ADC_CHANNEL_13 , test_callback , & adc_readings [ ADC_CHANNEL_13 ] ) ; adc_register_callback ( ADC_CHANNEL_REF , test_callback , & adc_readings [ ADC_CHANNEL_REF ] ) ; while ( 1 ) { LOG_DEBUG ( "{" ) ; for ( int i = ADC_CHANNEL_0 ; i < NUM_ADC_CHANNEL ; i ++ ) { printf ( "<S2SV_blank>%d<S2SV_blank>" , adc_readings [ i ] ) ; } printf ( "}\\n" ) ; } }
|
<S2SV_ModStart> ; adc_set_channel ( <S2SV_ModEnd> ADC_CHANNEL_REF , 1 <S2SV_ModStart> ADC_CHANNEL_REF , 1 <S2SV_ModEnd> ) ; adc_register_callback
|
484
|
CWE-000 static int qede_vxlan_enable ( struct rte_eth_dev * eth_dev , uint8_t clss , bool enable , bool mask ) { struct qede_dev * qdev = QEDE_INIT_QDEV ( eth_dev ) ; struct ecore_dev * edev = QEDE_INIT_EDEV ( qdev ) ; enum _ecore_status_t rc = ECORE_INVAL ; struct ecore_ptt * p_ptt ; struct ecore_tunnel_info tunn ; struct ecore_hwfn * p_hwfn ; int i ; memset ( & tunn , 0 , sizeof ( struct ecore_tunnel_info ) ) ; tunn . vxlan . b_update_mode = enable ; tunn . vxlan . b_mode_enabled = mask ; tunn . b_update_rx_cls = true ; tunn . b_update_tx_cls = true ; tunn . vxlan . tun_cls = clss ; for_each_hwfn ( edev , i ) { p_hwfn = & edev -> hwfns [ i ] ; <S2SV_StartBug> p_ptt = IS_PF ( edev ) ? ecore_ptt_acquire ( p_hwfn ) : NULL ; <S2SV_EndBug> rc = ecore_sp_pf_update_tunn_cfg ( p_hwfn , p_ptt , & tunn , ECORE_SPQ_MODE_CB , NULL ) ; if ( rc != ECORE_SUCCESS ) { DP_ERR ( edev , "Failed<S2SV_blank>to<S2SV_blank>update<S2SV_blank>tunn_clss<S2SV_blank>%u\\n" , tunn . vxlan . tun_cls ) ; if ( IS_PF ( edev ) ) ecore_ptt_release ( p_hwfn , p_ptt ) ; break ; } } if ( rc == ECORE_SUCCESS ) { qdev -> vxlan . enable = enable ; qdev -> vxlan . udp_port = ( enable ) ? QEDE_VXLAN_DEF_PORT : 0 ; DP_INFO ( edev , "vxlan<S2SV_blank>is<S2SV_blank>%s\\n" , enable ? "enabled" : "disabled" ) ; } return rc ; }
|
<S2SV_ModStart> i ] ; if ( <S2SV_ModEnd> IS_PF ( edev <S2SV_ModStart> ( edev ) ) { p_ptt = <S2SV_ModEnd> ecore_ptt_acquire ( p_hwfn <S2SV_ModStart> ( p_hwfn ) ; if ( ! p_ptt ) return - EAGAIN ; } else { p_ptt = NULL ; } <S2SV_ModEnd> rc = ecore_sp_pf_update_tunn_cfg
|
485
|
CWE-000 static void parse_event_log_entry ( struct amd_iommu * iommu , u32 entry [ ] ) { u16 domain_id , device_id , flags ; unsigned int bdf ; u32 code ; u64 * addr ; int count = 0 ; static const char * const event_str [ ] = { # define EVENT_STR ( name ) [ IOMMU_EVENT_ ## name - 1 ] = # name EVENT_STR ( ILLEGAL_DEV_TABLE_ENTRY ) , EVENT_STR ( IO_PAGE_FAULT ) , EVENT_STR ( DEV_TABLE_HW_ERROR ) , EVENT_STR ( PAGE_TABLE_HW_ERROR ) , EVENT_STR ( ILLEGAL_COMMAND_ERROR ) , EVENT_STR ( COMMAND_HW_ERROR ) , EVENT_STR ( IOTLB_INV_TIMEOUT ) , EVENT_STR ( INVALID_DEV_REQUEST ) # undef EVENT_STR } ; code = get_field_from_reg_u32 ( entry [ 1 ] , IOMMU_EVENT_CODE_MASK , IOMMU_EVENT_CODE_SHIFT ) ; while ( code == 0 ) { if ( unlikely ( ++ count == IOMMU_LOG_ENTRY_TIMEOUT ) ) { AMD_IOMMU_DEBUG ( "AMD-Vi:<S2SV_blank>No<S2SV_blank>event<S2SV_blank>written<S2SV_blank>to<S2SV_blank>log\\n" ) ; return ; } udelay ( 1 ) ; <S2SV_StartBug> rmb ( ) ; <S2SV_EndBug> code = get_field_from_reg_u32 ( entry [ 1 ] , IOMMU_EVENT_CODE_MASK , IOMMU_EVENT_CODE_SHIFT ) ; } if ( code == IOMMU_EVENT_IO_PAGE_FAULT ) { device_id = iommu_get_devid_from_event ( entry [ 0 ] ) ; domain_id = get_field_from_reg_u32 ( entry [ 1 ] , IOMMU_EVENT_DOMAIN_ID_MASK , IOMMU_EVENT_DOMAIN_ID_SHIFT ) ; flags = get_field_from_reg_u32 ( entry [ 1 ] , IOMMU_EVENT_FLAGS_MASK , IOMMU_EVENT_FLAGS_SHIFT ) ; addr = ( u64 * ) ( entry + 2 ) ; printk ( XENLOG_ERR "AMD-Vi:<S2SV_blank>" "%s:<S2SV_blank>domain<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>device<S2SV_blank>id<S2SV_blank>=<S2SV_blank>%#x,<S2SV_blank>" "fault<S2SV_blank>address<S2SV_blank>=<S2SV_blank>%#" PRIx64 ",<S2SV_blank>flags<S2SV_blank>=<S2SV_blank>%#x\\n" , event_str [ code - 1 ] , domain_id , device_id , * addr , flags ) ; for ( bdf = 0 ; bdf < ivrs_bdf_entries ; bdf ++ ) if ( get_dma_requestor_id ( iommu -> seg , bdf ) == device_id ) pci_check_disable_device ( iommu -> seg , PCI_BUS ( bdf ) , PCI_DEVFN2 ( bdf ) ) ; } else { AMD_IOMMU_DEBUG ( "%s<S2SV_blank>%08x<S2SV_blank>%08x<S2SV_blank>%08x<S2SV_blank>%08x\\n" , code <= ARRAY_SIZE ( event_str ) ? event_str [ code - 1 ] : "event" , entry [ 0 ] , entry [ 1 ] , entry [ 2 ] , entry [ 3 ] ) ; } memset ( entry , 0 , IOMMU_EVENT_LOG_ENTRY_SIZE ) ; }
|
<S2SV_ModStart> 1 ) ; barrier <S2SV_ModEnd> ( ) ;
|
486
|
CWE-000 void freeObject ( Obj * obj ) { if ( obj == NULL ) return ; ASSERT ( ! obj -> noGC ) ; TRACE_GC_FUNC_START ( "freeObject" ) ; GC_TRACE_FREE ( obj ) ; switch ( obj -> type ) { case OBJ_BOUND_METHOD : { GC_TRACE_DEBUG ( "Freeing<S2SV_blank>bound<S2SV_blank>method:<S2SV_blank>p=%p" , obj ) ; FREE ( ObjBoundMethod , obj ) ; break ; } case OBJ_CLASS : { ObjClass * klass = ( ObjClass * ) obj ; GC_TRACE_DEBUG ( "Freeing<S2SV_blank>class<S2SV_blank>method<S2SV_blank>table" ) ; freeTable ( & klass -> methods ) ; GC_TRACE_DEBUG ( "Freeing<S2SV_blank>class:<S2SV_blank>p=%p" , obj ) ; FREE ( ObjClass , obj ) ; break ; } case OBJ_FUNCTION : { ObjFunction * func = ( ObjFunction * ) obj ; GC_TRACE_DEBUG ( "Freeing<S2SV_blank>ObjFunction<S2SV_blank>chunk:<S2SV_blank>p=%p" , & func -> chunk ) ; freeChunk ( & func -> chunk ) ; GC_TRACE_DEBUG ( "Freeing<S2SV_blank>ObjFunction<S2SV_blank>chunk:<S2SV_blank>p=%p" , obj ) ; FREE ( ObjFunction , obj ) ; break ; } case OBJ_NATIVE_FUNCTION : { GC_TRACE_DEBUG ( "Freeing<S2SV_blank>ObjNative:<S2SV_blank>p=%p" , obj ) ; FREE ( ObjNative , obj ) ; break ; } case OBJ_INSTANCE : { ObjInstance * instance = ( ObjInstance * ) obj ; GC_TRACE_DEBUG ( "Freeing<S2SV_blank>instance<S2SV_blank>fields<S2SV_blank>table:<S2SV_blank>p=%p" , & instance -> fields ) ; freeTable ( & instance -> fields ) ; GC_TRACE_DEBUG ( "Freeing<S2SV_blank>instance<S2SV_blank>hidden<S2SV_blank>fields<S2SV_blank>table:<S2SV_blank>p=%p" , & instance -> hiddenFields ) ; freeTable ( & instance -> hiddenFields ) ; GC_TRACE_DEBUG ( "Freeing<S2SV_blank>ObjInstance:<S2SV_blank>p=%p" , obj ) ; FREE ( ObjInstance , obj ) ; break ; } case OBJ_INTERNAL : { ObjInternal * internal = ( ObjInternal * ) obj ; if ( internal -> freeFunc ) { GC_TRACE_DEBUG ( "Freeing<S2SV_blank>internal<S2SV_blank>object\'s<S2SV_blank>references:<S2SV_blank>p=%p,<S2SV_blank>datap=%p" , internal , internal -> data ) ; internal -> freeFunc ( obj ) ; } GC_TRACE_DEBUG ( "Freeing<S2SV_blank>internal<S2SV_blank>object:<S2SV_blank>p=%p,<S2SV_blank>" , internal ) ; FREE ( ObjInternal , internal ) ; break ; } case OBJ_STRING : { <S2SV_StartBug> ObjString * string = ( ObjString * ) obj ; <S2SV_EndBug> GC_TRACE_DEBUG ( "Freeing<S2SV_blank>string<S2SV_blank>chars:<S2SV_blank>p=%p" , string -> chars ) ; GC_TRACE_DEBUG ( "Freeing<S2SV_blank>string<S2SV_blank>chars:<S2SV_blank>s=%s" , string -> chars ) ; FREE_ARRAY ( char , string -> chars , string -> length + 1 ) ; <S2SV_StartBug> GC_TRACE_DEBUG ( "Freeing<S2SV_blank>ObjString:<S2SV_blank>p=%p" , obj ) ; <S2SV_EndBug> FREE ( ObjString , obj ) ; break ; } default : { ASSERT ( 0 ) ; } } TRACE_GC_FUNC_END ( "freeObject" ) ; }
|
<S2SV_ModStart> * ) obj ; ASSERT ( string -> chars ) <S2SV_ModStart> 1 ) ; string -> chars = NULL ;
|
487
|
CWE-000 static void input_ctrl_ptr_set_west_focus ( struct seat_ctx * ctx_seat , struct weston_pointer * pointer , struct weston_view * w_view , int rel_x , int rel_y ) { struct weston_view * view ; struct surface_ctx * surf_ctx ; struct input_context * ctx = ctx_seat -> input_ctx ; const struct ivi_layout_interface * lyt_if = ctx -> ivi_layout_interface ; struct seat_focus * st_focus ; uint32_t ivi_surf_id ; wl_fixed_t sx , sy ; if ( NULL == w_view ) { view = weston_compositor_pick_view ( pointer -> seat -> compositor , pointer -> x , pointer -> y , & sx , & sy ) ; } else { view = w_view ; sx = wl_fixed_from_int ( rel_x ) ; sy = wl_fixed_from_int ( rel_y ) ; } if ( pointer -> focus != view ) { if ( NULL != pointer -> focus ) { surf_ctx = input_ctrl_get_surf_ctx_from_surf ( ctx , pointer -> focus -> surface ) ; ivi_surf_id = lyt_if -> get_id_of_surface ( surf_ctx -> layout_surface ) ; st_focus = get_accepted_seat ( surf_ctx , ctx_seat -> name_seat ) ; if ( NULL != st_focus ) st_focus -> focus &= ~ ILM_INPUT_DEVICE_POINTER ; send_input_focus ( ctx , ivi_surf_id , ILM_INPUT_DEVICE_POINTER , ILM_FALSE ) ; } <S2SV_StartBug> surf_ctx = input_ctrl_get_surf_ctx_from_surf ( ctx , view -> surface ) ; <S2SV_EndBug> st_focus = get_accepted_seat ( surf_ctx , ctx_seat -> name_seat ) ; if ( st_focus != NULL ) { st_focus -> focus |= ILM_INPUT_DEVICE_POINTER ; send_input_focus ( ctx , lyt_if -> get_id_of_surface ( surf_ctx -> layout_surface ) , ILM_INPUT_DEVICE_POINTER , ILM_TRUE ) ; weston_pointer_set_focus ( pointer , view , sx , sy ) ; } else { if ( pointer -> focus != NULL ) { weston_pointer_clear_focus ( pointer ) ; } } <S2SV_StartBug> } <S2SV_EndBug> }
|
<S2SV_ModStart> ) ; } if ( NULL != view ) { <S2SV_ModStart> } } } else { if ( pointer -> focus != NULL ) { weston_pointer_clear_focus ( pointer ) ; } } }
|
488
|
CWE-000 void result_destroy ( MediaScanResult * r ) { int i ; if ( r -> path ) free ( r -> path ) ; if ( r -> error ) error_destroy ( r -> error ) ; if ( r -> video ) video_destroy ( r -> video ) ; if ( r -> audio ) audio_destroy ( r -> audio ) ; if ( r -> image ) image_destroy ( r -> image ) ; if ( r -> _tag ) tag_destroy ( r -> _tag ) ; if ( r -> _avf ) { <S2SV_StartBug> av_close_input_file ( r -> _avf ) ; <S2SV_EndBug> } if ( r -> _fp ) fclose ( r -> _fp ) ; if ( r -> _buf ) { buffer_free ( ( Buffer * ) r -> _buf ) ; LOG_MEM ( "destroy<S2SV_blank>result<S2SV_blank>buffer<S2SV_blank>@<S2SV_blank>%p\\n" , r -> _buf ) ; free ( r -> _buf ) ; } for ( i = 0 ; i < r -> nthumbnails ; i ++ ) image_destroy ( r -> _thumbs [ i ] ) ; LOG_MEM ( "destroy<S2SV_blank>MediaScanResult<S2SV_blank>@<S2SV_blank>%p\\n" , r ) ; free ( r ) ; }
|
<S2SV_ModStart> _avf ) { avformat_close_input <S2SV_ModEnd> ( r ->
|
489
|
CWE-000 visplane_t * R_FindPlane ( fixed_t height , int picnum , int lightlevel , fixed_t xoffs , fixed_t yoffs ) { visplane_t * check ; unsigned int hash ; if ( picnum == skyflatnum || ( picnum & PL_SKYFLAT ) ) { height = 0 ; lightlevel = 0 ; } hash = visplane_hash ( picnum , lightlevel , height ) ; for ( check = visplanes [ hash ] ; check ; check = check -> next ) if ( height == check -> height && picnum == check -> picnum && lightlevel == check -> lightlevel && xoffs == check -> xoffs && yoffs == check -> yoffs ) return check ; check = new_visplane ( hash ) ; check -> height = height ; check -> picnum = picnum ; check -> lightlevel = lightlevel ; check -> minx = viewwidth ; check -> maxx = - 1 ; <S2SV_StartBug> if ( isliquid [ picnum ] && r_liquid_current && ! xoffs && ! yoffs ) <S2SV_EndBug> { check -> xoffs = animatedliquidxoffs ; check -> yoffs = animatedliquidyoffs ; } else { check -> xoffs = xoffs ; check -> yoffs = yoffs ; } memset ( check -> top , USHRT_MAX , sizeof ( check -> top ) ) ; return check ; }
|
<S2SV_ModStart> ; if ( ! ( picnum & PL_SKYFLAT ) &&
|
490
|
CWE-000 int ilpSolver ( Board * boardPtr , Board * solBoardPtr ) { GRBenv * env = NULL ; GRBmodel * model = NULL ; int error = 0 ; int optimstatus ; char * vtype ; double * sol ; unsigned int m = boardPtr -> m ; unsigned int n = boardPtr -> n ; unsigned int N = m * n ; unsigned int N3 = N * N * N ; unsigned int ret = TRUE ; vtype = ( char * ) malloc ( N3 * sizeof ( char ) ) ; if ( vtype == NULL ) { printf ( "Error:<S2SV_blank>malloc<S2SV_blank>has<S2SV_blank>failed\\n" ) ; exit ( 1 ) ; } sol = ( double * ) calloc ( N * N * N , sizeof ( double ) ) ; if ( sol == NULL ) { printf ( "Error:<S2SV_blank>calloc<S2SV_blank>has<S2SV_blank>failed\\n" ) ; exit ( 1 ) ; } <S2SV_StartBug> error = createGurobiEnvModel ( env , & model ) ; <S2SV_EndBug> if ( error ) { ret = - 1 ; } if ( ret ) { error = initObjectiveFunction ( env , & model , N , vtype ) ; if ( error ) { ret = - 1 ; } } if ( ret ) { error = addConstraints ( env , model , boardPtr , m , n ) ; if ( error ) { ret = - 1 ; } } if ( ret ) { error = GRBoptimize ( model ) ; if ( error ) { printf ( "ERROR<S2SV_blank>%d<S2SV_blank>GRBoptimize():<S2SV_blank>%s\\n" , error , GRBgeterrormsg ( env ) ) ; ret = - 1 ; } } if ( ret ) { error = GRBgetintattr ( model , GRB_INT_ATTR_STATUS , & optimstatus ) ; if ( error ) { printf ( "ERROR<S2SV_blank>%d<S2SV_blank>GRBgetintattr():<S2SV_blank>%s\\n" , error , GRBgeterrormsg ( env ) ) ; ret = - 1 ; } } if ( ret ) { if ( optimstatus == GRB_OPTIMAL ) { error = GRBgetdblattrarray ( model , GRB_DBL_ATTR_X , 0 , N3 , sol ) ; if ( error ) { printf ( "ERROR<S2SV_blank>%d<S2SV_blank>GRBgetdblattrarray():<S2SV_blank>%s\\n" , error , GRBgeterrormsg ( env ) ) ; ret = - 1 ; } ret = TRUE ; updateSolution ( solBoardPtr , sol , N ) ; } else { ret = FALSE ; } } GRBfreemodel ( model ) ; GRBfreeenv ( env ) ; free ( sol ) ; free ( vtype ) ; return ret ; }
|
<S2SV_ModStart> = createGurobiEnvModel ( &
|
491
|
CWE-000 char default_cell_lt ( lmm_llcell * c1 , lmm_llcell * c2 ) { if ( c1 -> other < c2 -> other ) return ( - 1 ) ; <S2SV_StartBug> if ( c1 -> val == c2 -> val ) <S2SV_EndBug> return ( 0 ) ; return ( 1 ) ; }
|
<S2SV_ModStart> ( c1 -> other <S2SV_ModEnd> == c2 -> <S2SV_ModStart> == c2 -> other <S2SV_ModEnd> ) return (
|
492
|
CWE-000 int IMU_calb_init ( uint16_t * id , IMU_calb_config * * pntr ) { <S2SV_StartBug> if ( numInstCalb >= IMU_MAX_INST ) <S2SV_EndBug> return IMU_CALB_INST_OVERFLOW ; <S2SV_StartBug> state [ numInstCalb ] . fnc = IMU_calb_defaultFnc ; <S2SV_EndBug> <S2SV_StartBug> * id = numInstCalb ; <S2SV_EndBug> * pntr = & config [ * id ] ; <S2SV_StartBug> numInstCalb ++ ; <S2SV_EndBug> return 0 ; }
|
<S2SV_ModStart> { if ( numInst <S2SV_ModEnd> >= IMU_MAX_INST ) <S2SV_ModStart> ; state [ numInst <S2SV_ModEnd> ] . fnc <S2SV_ModStart> * id = numInst <S2SV_ModEnd> ; * pntr <S2SV_ModStart> id ] ; numInst <S2SV_ModEnd> ++ ; return
|
493
|
CWE-000 int uStrLen ( const wchar_t * u ) { <S2SV_StartBug> int i = 0 ; <S2SV_EndBug> while ( * u != ( wchar_t ) 0 ) { u ++ ; i ++ ; } return i ; }
|
<S2SV_ModStart> ) { int i ; if ( u == NULL ) return 0 ;
|
494
|
CWE-000 int play ( SDL_Renderer * renderer , SDL_Window * window , int mapnumber , int difficulty ) { GameObject game = { . enemies = NULL , . turrets = NULL , . fireObjects = NULL , . explosions = NULL , . factoryStaff = 0 , . priority = 0 , . missionProgress = 0 , . wavetime = 1100 , . speed = 1 , . frame = 1 , . spawntimes = malloc ( 500 * sizeof ( int ) ) , . credit = 50 , . totalcredit = 0 } ; if ( game . spawntimes == NULL ) { return - 2 ; } game . spawntimes [ 0 ] = 1 ; game . spawntimes [ 1 ] = 0 ; Graphics graphics = { . renderer = renderer } ; Audio audio ; Field map [ 560 ] ; printf ( "init\\n" ) ; if ( loadTextures ( & graphics , mapnumber ) ) { printf ( "tx<S2SV_blank>fail\\n" ) ; return - 2 ; } else { printf ( "tx<S2SV_blank>success\\n" ) ; } if ( loadAudio ( & audio ) ) { printf ( "audio<S2SV_blank>fail\\n" ) ; return - 2 ; } else { printf ( "audio<S2SV_blank>success\\n" ) ; } if ( loadMap ( & game , map , mapnumber , difficulty ) ) { printf ( "map<S2SV_blank>fail\\n" ) ; cleanupAll ( & game ) ; unloadTextures ( & graphics ) ; return - 2 ; } printf ( "map<S2SV_blank>success\\n" ) ; int basesearch = 0 ; while ( map [ basesearch ] . type != 3 ) { basesearch ++ ; } graphics . baseRec . x = ( basesearch % 28 ) * 35 + 10 ; graphics . baseRec . y = ( basesearch / 28 ) * 35 + 10 ; graphics . baseRec . w = 140 ; graphics . baseRec . h = 70 ; int state = 0 ; Turret * selected = NULL ; turretType building ; <S2SV_StartBug> SDL_Event event ; <S2SV_EndBug> SDL_Point click ; int playing = 1 ; clock_t framestart ; while ( playing && game . missionStaff > 0 && game . missionProgress < game . missionEnd ) { framestart = clock ( ) ; while ( SDL_PollEvent ( & event ) ) { if ( event . type == SDL_QUIT || ( event . type == SDL_KEYDOWN && event . key . keysym . scancode == SDL_SCANCODE_ESCAPE ) ) { playing = 0 ; } else if ( event . type == SDL_MOUSEBUTTONDOWN && event . button . button == SDL_BUTTON_LEFT ) { click . x = event . button . x ; click . y = event . button . y ; if ( SDL_PointInRect ( & click , & fullscreenRec ) ) { if ( SDL_GetWindowFlags ( window ) & SDL_WINDOW_FULLSCREEN ) { SDL_SetWindowFullscreen ( window , 0 ) ; } else { SDL_SetWindowFullscreen ( window , SDL_WINDOW_FULLSCREEN ) ; } } handleClick ( & game , & click , & state , & selected , & building , map ) ; } else if ( event . type == SDL_MOUSEBUTTONDOWN && event . button . button == SDL_BUTTON_RIGHT ) { click . x = event . button . x ; click . y = event . button . y ; handleRightClick ( & game , & click ) ; } } cycle ( & graphics , & game , state , selected , building , map , & audio ) ; SDL_RenderPresent ( graphics . renderer ) ; if ( clock ( ) < framestart + fastFPSwait_SDL ) { SDL_Delay ( framestart + fastFPSwait_SDL - clock ( ) ) ; } while ( clock ( ) < framestart + fastFPSwait ) { } } int score = countPersons ( & game ) ; cleanupAll ( & game ) ; unloadTextures ( & graphics ) ; if ( playing ) { return score ; } else { return - 1 ; } }
|
<S2SV_ModStart> turretType building ; changePriority ( & game , 1 ) ;
|
495
|
CWE-000 static int32_t msm_actuator_move_focus ( struct msm_actuator_ctrl_t * a_ctrl , struct msm_actuator_move_params_t * move_params ) { int32_t rc = 0 ; struct damping_params_t ringing_params_kernel ; int8_t sign_dir = move_params -> sign_dir ; uint16_t step_boundary = 0 ; uint16_t target_step_pos = 0 ; uint16_t target_lens_pos = 0 ; int16_t dest_step_pos = move_params -> dest_step_pos ; uint16_t curr_lens_pos = 0 ; int dir = move_params -> dir ; int32_t num_steps = move_params -> num_steps ; struct msm_camera_i2c_reg_setting reg_setting ; if ( a_ctrl -> step_position_table == NULL ) { pr_err ( "Step<S2SV_blank>Position<S2SV_blank>Table<S2SV_blank>is<S2SV_blank>NULL" ) ; return - EFAULT ; } if ( copy_from_user ( & ringing_params_kernel , & ( move_params -> ringing_params [ a_ctrl -> curr_region_index ] ) , sizeof ( struct damping_params_t ) ) ) { pr_err ( "copy_from_user<S2SV_blank>failed\\n" ) ; return - EFAULT ; } CDBG ( "called,<S2SV_blank>dir<S2SV_blank>%d,<S2SV_blank>num_steps<S2SV_blank>%d\\n" , dir , num_steps ) ; if ( dest_step_pos == a_ctrl -> curr_step_pos ) return rc ; if ( ( sign_dir > MSM_ACTUATOR_MOVE_SIGNED_NEAR ) || ( sign_dir < MSM_ACTUATOR_MOVE_SIGNED_FAR ) ) { pr_err ( "Invalid<S2SV_blank>sign_dir<S2SV_blank>=<S2SV_blank>%d\\n" , sign_dir ) ; return - EFAULT ; } if ( ( dir > MOVE_FAR ) || ( dir < MOVE_NEAR ) ) { pr_err ( "Invalid<S2SV_blank>direction<S2SV_blank>=<S2SV_blank>%d\\n" , dir ) ; return - EFAULT ; } if ( a_ctrl -> i2c_reg_tbl == NULL ) { <S2SV_StartBug> pr_err ( "failed.<S2SV_blank>i2c<S2SV_blank>reg<S2SV_blank>tabl<S2SV_blank>is<S2SV_blank>NULL" ) ; <S2SV_EndBug> return - EFAULT ; } if ( dest_step_pos > a_ctrl -> total_steps ) { pr_err ( "Step<S2SV_blank>pos<S2SV_blank>greater<S2SV_blank>than<S2SV_blank>total<S2SV_blank>steps<S2SV_blank>=<S2SV_blank>%d\\n" , dest_step_pos ) ; return - EFAULT ; } curr_lens_pos = a_ctrl -> step_position_table [ a_ctrl -> curr_step_pos ] ; a_ctrl -> i2c_tbl_index = 0 ; CDBG ( "curr_step_pos<S2SV_blank>=%d<S2SV_blank>dest_step_pos<S2SV_blank>=%d<S2SV_blank>curr_lens_pos=%d\\n" , a_ctrl -> curr_step_pos , dest_step_pos , curr_lens_pos ) ; while ( a_ctrl -> curr_step_pos != dest_step_pos ) { if ( a_ctrl -> curr_region_index >= a_ctrl -> region_size ) break ; step_boundary = a_ctrl -> region_params [ a_ctrl -> curr_region_index ] . step_bound [ dir ] ; if ( ( dest_step_pos * sign_dir ) <= ( step_boundary * sign_dir ) ) { target_step_pos = dest_step_pos ; target_lens_pos = a_ctrl -> step_position_table [ target_step_pos ] ; a_ctrl -> func_tbl -> actuator_write_focus ( a_ctrl , curr_lens_pos , & ringing_params_kernel , sign_dir , target_lens_pos ) ; curr_lens_pos = target_lens_pos ; } else { target_step_pos = step_boundary ; target_lens_pos = a_ctrl -> step_position_table [ target_step_pos ] ; a_ctrl -> func_tbl -> actuator_write_focus ( a_ctrl , curr_lens_pos , & ringing_params_kernel , sign_dir , target_lens_pos ) ; curr_lens_pos = target_lens_pos ; a_ctrl -> curr_region_index += sign_dir ; } a_ctrl -> curr_step_pos = target_step_pos ; } move_params -> curr_lens_pos = curr_lens_pos ; reg_setting . reg_setting = a_ctrl -> i2c_reg_tbl ; reg_setting . data_type = a_ctrl -> i2c_data_type ; reg_setting . size = a_ctrl -> i2c_tbl_index ; rc = a_ctrl -> i2c_client . i2c_func_tbl -> i2c_write_table_w_microdelay ( & a_ctrl -> i2c_client , & reg_setting ) ; if ( rc < 0 ) { pr_err ( "i2c<S2SV_blank>write<S2SV_blank>error:%d\\n" , rc ) ; return rc ; } a_ctrl -> i2c_tbl_index = 0 ; CDBG ( "Exit\\n" ) ; return rc ; }
|
<S2SV_ModStart> { pr_err ( "failed.<S2SV_blank>i2c<S2SV_blank>reg<S2SV_blank>table<S2SV_blank>is<S2SV_blank>NULL" <S2SV_ModEnd> ) ; return
|
496
|
CWE-000 static void Cat ( const char * pcParameterBuffer ) { PARAMETERLIST stList ; char Name [ 30 ] ; InitializeParameter ( & stList , pcParameterBuffer ) ; GetNextParameter ( & stList , Name ) ; FL_FILE * fd = fl_fopen ( Name , "r" ) ; if ( fd == 0 ) { Printf ( "fail<S2SV_blank>file<S2SV_blank>open<S2SV_blank>[%s]\\n" , Name ) ; return ; } <S2SV_StartBug> Printf ( "[%s]<S2SV_blank>size<S2SV_blank>%d<S2SV_blank>%d\\n" , fd -> filelength , fd -> bytenum ) ; <S2SV_EndBug> int i ; for ( i = 0 ; i < fd -> filelength ; i ++ ) Printf ( "%c" , fl_fgetc ( fd ) ) ; fl_fclose ( fd ) ; }
|
<S2SV_ModStart> } Printf ( "size<S2SV_blank>%d<S2SV_blank>%d\\n" <S2SV_ModEnd> , fd ->
|
497
|
CWE-000 int lys_copy_union_leafrefs ( struct lys_module * mod , struct lys_node * parent , struct lys_type * type , struct lys_type * prev_new , struct unres_schema * unres ) { struct lys_type new ; int i , top_type ; struct lys_ext_instance * * ext ; uint8_t ext_size ; void * reloc ; if ( ! prev_new ) { top_type = 1 ; memset ( & new , 0 , sizeof new ) ; new . module_name = lydict_insert ( mod -> ctx , type -> module_name , 0 ) ; new . base = type -> base ; new . parent = ( struct lys_tpdf * ) parent ; prev_new = & new ; } else { top_type = 0 ; } assert ( type -> der ) ; if ( type -> der -> module ) { ext_size = type -> ext_size ; if ( lys_ext_dup ( mod , type -> ext , type -> ext_size , ( prev_new ? prev_new : & new ) , LYEXT_PAR_TYPE , & ext , 0 , unres ) ) { return - 1 ; } if ( prev_new -> ext ) { reloc = realloc ( prev_new -> ext , ( prev_new -> ext_size + ext_size ) * sizeof * prev_new -> ext ) ; <S2SV_StartBug> LY_CHECK_ERR_RETURN ( ! reloc , LOGMEM , - 1 ) ; <S2SV_EndBug> memcpy ( prev_new -> ext + prev_new -> ext_size , ext , ext_size * sizeof * ext ) ; free ( ext ) ; prev_new -> ext_size += ext_size ; } else { prev_new -> ext = ext ; prev_new -> ext_size = ext_size ; } if ( lys_copy_union_leafrefs ( mod , parent , & type -> der -> type , prev_new , unres ) ) { return - 1 ; } } else { switch ( type -> base ) { case LY_TYPE_UNION : prev_new -> info . uni . has_ptr_type = type -> info . uni . has_ptr_type ; prev_new -> info . uni . count = type -> info . uni . count ; assert ( prev_new -> info . uni . count ) ; prev_new -> info . uni . types = calloc ( prev_new -> info . uni . count , sizeof * prev_new -> info . uni . types ) ; LY_CHECK_ERR_RETURN ( ! prev_new -> info . uni . types , LOGMEM , - 1 ) ; for ( i = 0 ; i < prev_new -> info . uni . count ; i ++ ) { if ( lys_copy_union_leafrefs ( mod , parent , & ( type -> info . uni . types [ i ] ) , & ( prev_new -> info . uni . types [ i ] ) , unres ) ) { return - 1 ; } } prev_new -> der = type -> der ; break ; default : if ( lys_type_dup ( mod , parent , prev_new , type , 0 , 0 , unres ) ) { return - 1 ; } break ; } } if ( top_type ) { memcpy ( type , prev_new , sizeof * type ) ; } return EXIT_SUCCESS ; }
|
<S2SV_ModStart> - 1 ) ; prev_new -> ext = reloc
|
498
|
CWE-000 iERR _ion_writer_text_write_double ( ION_WRITER * pwriter , double value ) { iENTER ; char image [ 64 ] , * mark ; int fpc ; IONCHECK ( _ion_writer_text_start_value ( pwriter ) ) ; fpc = FLOAT_CLASS ( value ) ; switch ( fpc ) { # if defined ( _MSC_VER ) case _FPCLASS_SNAN : case _FPCLASS_QNAN : # elif defined ( __GNUC__ ) case FP_NAN : # endif IONCHECK ( _ion_writer_text_append_ascii_cstr ( pwriter -> output , "nan" ) ) ; break ; # if defined ( _MSC_VER ) case _FPCLASS_PINF : IONCHECK ( _ion_writer_text_append_ascii_cstr ( pwriter -> output , "+inf" ) ) ; break ; case _FPCLASS_NINF : IONCHECK ( _ion_writer_text_append_ascii_cstr ( pwriter -> output , "-inf" ) ) ; break ; case _FPCLASS_PZ : IONCHECK ( _ion_writer_text_append_ascii_cstr ( pwriter -> output , "0e0" ) ) ; break ; case _FPCLASS_NZ : IONCHECK ( _ion_writer_text_append_ascii_cstr ( pwriter -> output , "-0e0" ) ) ; break ; # elif defined ( __GNUC__ ) case FP_INFINITE : IONCHECK ( _ion_writer_text_append_ascii_cstr ( pwriter -> output , value == INFINITY ? "+inf" : "-inf" ) ) ; break ; case FP_ZERO : IONCHECK ( _ion_writer_text_append_ascii_cstr ( pwriter -> output , signbit ( value ) ? "-0e0" : "0e0" ) ) ; break ; # endif # if defined ( _MSC_VER ) case _FPCLASS_NN : case _FPCLASS_ND : case _FPCLASS_PD : case _FPCLASS_PN : # elif defined ( __GNUC__ ) case FP_NORMAL : case FP_SUBNORMAL : # endif <S2SV_StartBug> sprintf ( image , "%20g" , value ) ; <S2SV_EndBug> assert ( strlen ( image ) < sizeof ( image ) ) ; mark = strchr ( image , 'e' ) ; if ( ! mark ) { strcat ( image , "e+0" ) ; } for ( mark = image ; * mark == '<S2SV_blank>' ; mark ++ ) ; IONCHECK ( _ion_writer_text_append_ascii_cstr ( pwriter -> output , mark ) ) ; break ; default : FAILWITH ( IERR_UNRECOGNIZED_FLOAT ) ; } IONCHECK ( _ion_writer_text_close_value ( pwriter ) ) ; iRETURN ; }
|
<S2SV_ModStart> ( image , "%.20g" <S2SV_ModEnd> , value )
|
499
|
CWE-000 static int viewer_get_packet ( struct relay_connection * conn ) { int ret ; <S2SV_StartBug> char * reply = NULL ; <S2SV_EndBug> struct lttng_viewer_get_packet get_packet_info ; struct lttng_viewer_trace_packet reply_header ; struct relay_viewer_stream * vstream = NULL ; uint32_t reply_size = sizeof ( reply_header ) ; uint32_t packet_data_len = 0 ; ssize_t read_len ; DBG2 ( "Relay<S2SV_blank>get<S2SV_blank>data<S2SV_blank>packet" ) ; health_code_update ( ) ; ret = recv_request ( conn -> sock , & get_packet_info , sizeof ( get_packet_info ) ) ; if ( ret < 0 ) { goto end ; } health_code_update ( ) ; memset ( & reply_header , 0 , sizeof ( reply_header ) ) ; vstream = viewer_stream_get_by_id ( be64toh ( get_packet_info . stream_id ) ) ; if ( ! vstream ) { DBG ( "Client<S2SV_blank>requested<S2SV_blank>packet<S2SV_blank>of<S2SV_blank>unknown<S2SV_blank>stream<S2SV_blank>id<S2SV_blank>%" PRIu64 , be64toh ( get_packet_info . stream_id ) ) ; reply_header . status = htobe32 ( LTTNG_VIEWER_GET_PACKET_ERR ) ; goto send_reply_nolock ; } else { packet_data_len = be32toh ( get_packet_info . len ) ; reply_size += packet_data_len ; } reply = zmalloc ( reply_size ) ; if ( ! reply ) { PERROR ( "packet<S2SV_blank>reply<S2SV_blank>zmalloc" ) ; reply_size = sizeof ( reply_header ) ; goto error ; } pthread_mutex_lock ( & vstream -> stream -> lock ) ; <S2SV_StartBug> ret = lseek ( vstream -> stream_fd -> fd , be64toh ( get_packet_info . offset ) , <S2SV_EndBug> SEEK_SET ) ; <S2SV_StartBug> if ( ret < 0 ) { <S2SV_EndBug> PERROR ( "lseek<S2SV_blank>fd<S2SV_blank>%d<S2SV_blank>to<S2SV_blank>offset<S2SV_blank>%" PRIu64 , vstream -> stream_fd -> fd , be64toh ( get_packet_info . offset ) ) ; goto error ; } read_len = lttng_read ( vstream -> stream_fd -> fd , reply + sizeof ( reply_header ) , packet_data_len ) ; if ( read_len < packet_data_len ) { PERROR ( "Relay<S2SV_blank>reading<S2SV_blank>trace<S2SV_blank>file,<S2SV_blank>fd:<S2SV_blank>%d,<S2SV_blank>offset:<S2SV_blank>%" PRIu64 , vstream -> stream_fd -> fd , be64toh ( get_packet_info . offset ) ) ; goto error ; } reply_header . status = htobe32 ( LTTNG_VIEWER_GET_PACKET_OK ) ; reply_header . len = htobe32 ( packet_data_len ) ; goto send_reply ; error : reply_header . status = htobe32 ( LTTNG_VIEWER_GET_PACKET_ERR ) ; send_reply : if ( vstream ) { pthread_mutex_unlock ( & vstream -> stream -> lock ) ; } send_reply_nolock : health_code_update ( ) ; if ( reply ) { memcpy ( reply , & reply_header , sizeof ( reply_header ) ) ; ret = send_response ( conn -> sock , reply , reply_size ) ; } else { ret = send_response ( conn -> sock , & reply_header , reply_size ) ; } health_code_update ( ) ; if ( ret < 0 ) { PERROR ( "sendmsg<S2SV_blank>of<S2SV_blank>packet<S2SV_blank>data<S2SV_blank>failed" ) ; goto end_free ; } DBG ( "Sent<S2SV_blank>%u<S2SV_blank>bytes<S2SV_blank>for<S2SV_blank>stream<S2SV_blank>%" PRIu64 , reply_size , be64toh ( get_packet_info . stream_id ) ) ; end_free : free ( reply ) ; end : if ( vstream ) { viewer_stream_put ( vstream ) ; } return ret ; }
|
<S2SV_ModStart> int ret ; off_t lseek_ret ; <S2SV_ModStart> lock ) ; lseek_ret <S2SV_ModEnd> = lseek ( <S2SV_ModStart> ; if ( lseek_ret <S2SV_ModEnd> < 0 )
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.