Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
1,900 | CWE-000 void _XMP_reflect_pack_dim ( _XMP_array_t * a , int i , int * lwidth , int * uwidth , int * is_periodic , <S2SV_StartBug> int is_reduce_shadow ) <S2SV_EndBug> { char * pack_dst_lo , * pack_src_lo ; char * pack_dst_hi , * pack_src_hi ; <S2SV_StartBug> if ( ! is_reduce_shadow ) { <S2SV_EndBug> if ( a -> order == MPI_ORDER_FORTRAN ) { if ( i == a -> dim - 1 ) return ; } else if ( a -> order == MPI_ORDER_C ) { if ( i == 0 ) return ; } else { _XMP_fatal ( "cannot<S2SV_blank>determin<S2SV_blank>the<S2SV_blank>base<S2SV_blank>language." ) ; } } _XMP_array_info_t * ai = & ( a -> info [ i ] ) ; _XMP_reflect_sched_t * reflect = ai -> reflect_sched ; <S2SV_StartBug> if ( is_reduce_shadow ) { <S2SV_EndBug> pack_dst_lo = ( char * ) reflect -> lo_recv_buf ; pack_src_lo = ( char * ) reflect -> lo_recv_array ; pack_dst_hi = ( char * ) reflect -> hi_recv_buf ; pack_src_hi = ( char * ) reflect -> hi_recv_array ; } else { pack_dst_lo = ( char * ) reflect -> lo_send_buf ; pack_src_lo = ( char * ) reflect -> lo_send_array ; pack_dst_hi = ( char * ) reflect -> hi_send_buf ; pack_src_hi = ( char * ) reflect -> hi_send_array ; } if ( ai -> shadow_type == _XMP_N_SHADOW_NORMAL ) { if ( lwidth [ i ] ) { _XMP_pack_vector ( pack_dst_lo , pack_src_lo , reflect -> count , lwidth [ i ] * reflect -> blocklength , reflect -> stride ) ; } if ( uwidth [ i ] ) { _XMP_pack_vector ( pack_dst_hi , pack_src_hi , reflect -> count , uwidth [ i ] * reflect -> blocklength , reflect -> stride ) ; } } } | <S2SV_ModStart> is_periodic , int shadow_comm_type <S2SV_ModEnd> ) { char <S2SV_ModStart> ; if ( shadow_comm_type == _XMP_COMM_REFLECT <S2SV_ModEnd> ) { if <S2SV_ModStart> ; if ( shadow_comm_type == _XMP_COMM_REDUCE_SHADOW <S2SV_ModEnd> ) { pack_dst_lo |
1,901 | CWE-000 static void _decorate_all_item_realize ( Elm_Gen_Item * it , Eina_Bool effect_on ) { char buf [ 1024 ] ; const char * stacking ; const char * stacking_even ; if ( ! it ) return ; ELM_GENLIST_DATA_GET_FROM_ITEM ( it , sd ) ; if ( it -> item -> decorate_all_item_realized ) return ; it -> deco_all_view = edje_object_add ( evas_object_evas_get ( WIDGET ( it ) ) ) ; edje_object_scale_set ( it -> deco_all_view , efl_gfx_entity_scale_get ( WIDGET ( it ) ) * elm_config_scale_get ( ) ) ; evas_object_smart_member_add ( it -> deco_all_view , sd -> pan_obj ) ; elm_widget_sub_object_add ( WIDGET ( it ) , it -> deco_all_view ) ; if ( it -> item -> type & ELM_GENLIST_ITEM_TREE ) strncpy ( buf , "tree" , sizeof ( buf ) ) ; else strncpy ( buf , "item" , sizeof ( buf ) ) ; if ( sd -> mode == ELM_LIST_COMPRESS ) strncat ( buf , "_compress" , sizeof ( buf ) - strlen ( buf ) - 1 ) ; strncat ( buf , "/" , sizeof ( buf ) - strlen ( buf ) - 1 ) ; strncat ( buf , it -> itc -> decorate_all_item_style , sizeof ( buf ) - strlen ( buf ) - 1 ) ; elm_widget_theme_object_set ( WIDGET ( it ) , it -> deco_all_view , "genlist" , buf , elm_widget_style_get ( WIDGET ( it ) ) ) ; stacking_even = edje_object_data_get ( VIEW ( it ) , "stacking_even" ) ; if ( ! stacking_even ) stacking_even = "above" ; it -> item -> stacking_even = ! ! strcmp ( "above" , stacking_even ) ; stacking = edje_object_data_get ( VIEW ( it ) , "stacking" ) ; if ( ! stacking ) stacking = "yes" ; it -> item -> nostacking = ! ! strcmp ( "yes" , stacking ) ; edje_object_mirrored_set ( it -> deco_all_view , efl_ui_mirrored_get ( WIDGET ( it ) ) ) ; _elm_genlist_item_position_state_update ( it ) ; _elm_genlist_item_state_update ( it ) ; if ( it -> item -> wsd -> reorder_mode ) { edje_object_signal_emit ( it -> deco_all_view , SIGNAL_REORDER_MODE_UNSET , "elm" ) ; } if ( effect_on ) edje_object_signal_emit ( it -> deco_all_view , SIGNAL_DECORATE_ENABLED_EFFECT , "elm" ) ; else edje_object_signal_emit ( it -> deco_all_view , SIGNAL_DECORATE_ENABLED , "elm" ) ; _item_mouse_callbacks_del ( it , VIEW ( it ) ) ; _item_mouse_callbacks_add ( it , it -> deco_all_view ) ; if ( it -> flipped ) edje_object_signal_emit ( it -> deco_all_view , SIGNAL_FLIP_ENABLED , "elm" ) ; <S2SV_StartBug> _view_inflate ( it -> deco_all_view , it , NULL , & ( it -> item -> deco_all_contents ) ) ; <S2SV_EndBug> edje_object_part_swallow ( it -> deco_all_view , "elm.swallow.decorate.content" , VIEW ( it ) ) ; _decorate_all_item_position ( it , it -> item -> scrl_x , it -> item -> scrl_y ) ; evas_object_show ( it -> deco_all_view ) ; if ( it -> selected ) edje_object_signal_emit ( it -> deco_all_view , SIGNAL_SELECTED , "elm" ) ; it -> item -> decorate_all_item_realized = EINA_TRUE ; it -> want_unrealize = EINA_FALSE ; } | <S2SV_ModStart> -> deco_all_contents ) , EINA_FALSE |
1,902 | CWE-000 <S2SV_StartBug> uint32_t HELPER ( advsimd_acgt_f16 ) ( float16 a , float16 b , void * fpstp ) <S2SV_EndBug> { float_status * fpst = fpstp ; float16 f0 = float16_abs ( a ) ; float16 f1 = float16_abs ( b ) ; int compare = float16_compare ( f0 , f1 , fpst ) ; return ADVSIMD_CMPRES ( compare == float_relation_greater ) ; } | <S2SV_ModStart> advsimd_acgt_f16 ) ( uint32_t a , uint32_t <S2SV_ModEnd> b , void |
1,903 | CWE-000 cstl_error cstl_slist_push_back ( struct cstl_slist * pSlist , void * elem , size_t elem_size ) { <S2SV_StartBug> struct cstl_slist_node * current = ( struct cstl_slist_node * ) 0 ; <S2SV_EndBug> struct cstl_slist_node * new_node = ( struct cstl_slist_node * ) 0 ; new_node = ( struct cstl_slist_node * ) calloc ( 1 , sizeof ( struct cstl_slist_node ) ) ; new_node -> elem = cstl_object_new ( elem , elem_size ) ; <S2SV_StartBug> if ( ! new_node -> elem ) { <S2SV_EndBug> return CSTL_SLIST_INSERT_FAILED ; } new_node -> next = ( struct cstl_slist_node * ) 0 ; if ( pSlist -> head == ( struct cstl_slist_node * ) 0 ) { pSlist -> head = new_node ; pSlist -> size ++ ; return CSTL_ERROR_SUCCESS ; } current = pSlist -> head ; while ( current -> next != ( struct cstl_slist_node * ) 0 ) { current = current -> next ; } current -> next = new_node ; pSlist -> size ++ ; return CSTL_ERROR_SUCCESS ; } | <S2SV_ModStart> elem_size ) { return cstl_slist_insert ( pSlist , pSlist -> size , <S2SV_ModEnd> elem , elem_size <S2SV_ModStart> elem_size ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
1,904 | CWE-000 static int mv88e6xxx_port_check_hw_vlan ( struct dsa_switch * ds , int port , u16 vid_begin , u16 vid_end ) { struct mv88e6xxx_chip * chip = ds -> priv ; struct mv88e6xxx_vtu_entry vlan ; int i , err ; if ( ! vid_begin ) return - EOPNOTSUPP ; mutex_lock ( & chip -> reg_lock ) ; err = _mv88e6xxx_vtu_vid_write ( chip , vid_begin - 1 ) ; if ( err ) goto unlock ; do { err = _mv88e6xxx_vtu_getnext ( chip , & vlan ) ; if ( err ) goto unlock ; if ( ! vlan . valid ) break ; if ( vlan . vid > vid_end ) break ; for ( i = 0 ; i < mv88e6xxx_num_ports ( chip ) ; ++ i ) { if ( dsa_is_dsa_port ( ds , i ) || dsa_is_cpu_port ( ds , i ) ) continue ; <S2SV_StartBug> if ( vlan . data [ i ] == <S2SV_EndBug> GLOBAL_VTU_DATA_MEMBER_TAG_NON_MEMBER ) continue ; if ( chip -> ports [ i ] . bridge_dev == chip -> ports [ port ] . bridge_dev ) <S2SV_StartBug> break ; <S2SV_EndBug> netdev_warn ( ds -> ports [ port ] . netdev , "hardware<S2SV_blank>VLAN<S2SV_blank>%d<S2SV_blank>already<S2SV_blank>used<S2SV_blank>by<S2SV_blank>%s\\n" , vlan . vid , netdev_name ( chip -> ports [ i ] . bridge_dev ) ) ; err = - EOPNOTSUPP ; goto unlock ; } } while ( vlan . vid < vid_end ) ; unlock : mutex_unlock ( & chip -> reg_lock ) ; return err ; } | <S2SV_ModStart> ; if ( ! ds -> ports [ port ] . netdev ) continue ; if ( <S2SV_ModStart> bridge_dev ) break ; if ( ! chip -> ports [ i ] . bridge_dev ) continue |
1,905 | CWE-000 int app_handle_timeout ( void * srv , int uid , char type ) { USER_T * u = getUser ( uid ) ; if ( u == NULL ) return - 1 ; USER_T * pu = getPeerUser ( u ) ; debug_log ( "%s" , "enter" ) ; buffer * bnotify = buffer_init ( ) ; if ( ( type == TIMER_TYPE_STEP || type == TIMER_TYPE_RESUME || type == TIMER_TYPE_DIANMU ) && isInGame ( u ) ) { int winner = 1 ; buffer_append_string ( bnotify , "notify:timeout,step," ) ; buffer_append_long ( bnotify , u -> sid ) ; buffer_append_string ( bnotify , ",\\r\\n\\r\\n" ) ; buffer_append_string ( bnotify , "notify:game_end," ) ; if ( u -> sid == 1 ) winner = 2 ; buffer_append_long ( bnotify , winner ) ; buffer_append_string ( bnotify , "," ) ; buffer_append_long ( bnotify , 0 ) ; buffer_append_string ( bnotify , "," ) ; buffer_append_long ( bnotify , 0 ) ; buffer_append_string ( bnotify , "," ) ; if ( u != NULL ) { setUserStatus ( u , USER_JOIN ) ; startWaitTimer ( srv , u , MAX_JOIN_TIMEOUT ) ; setTimer ( u , time ( NULL ) , MAX_JOIN_TIMEOUT , TIMER_TYPE_JOIN ) ; } if ( pu != NULL ) { setUserStatus ( pu , USER_JOIN ) ; startWaitTimer ( srv , pu , MAX_JOIN_TIMEOUT ) ; setTimer ( pu , time ( NULL ) , MAX_JOIN_TIMEOUT , TIMER_TYPE_JOIN ) ; } void * game = getGame ( u -> did ) ; buffer * bRecord = buffer_init ( ) ; if ( game != NULL ) { dprintf ( "FIXME:<S2SV_blank>game<S2SV_blank>is<S2SV_blank>null<S2SV_blank>when<S2SV_blank>timeout\\n" ) ; getRecord ( game , bRecord ) ; } endGoGame ( srv , u -> did , u -> puid , u -> id , bRecord ) ; rank_map_t * rmap = getRankMap ( u -> rank ) ; buffer_append_long ( bnotify , u -> id ) ; buffer_append_string ( bnotify , "," ) ; buffer_append_string ( bnotify , rmap -> label ) ; buffer_append_string ( bnotify , "," ) ; rmap = getRankMap ( pu -> rank ) ; buffer_append_long ( bnotify , pu -> id ) ; buffer_append_string ( bnotify , "," ) ; buffer_append_string ( bnotify , rmap -> label ) ; buffer_append_string ( bnotify , "," ) ; buffer_append_string ( bnotify , bRecord -> ptr ) ; buffer_free ( bRecord ) ; notify_user ( srv , u , bnotify ) ; notify_user ( srv , pu , bnotify ) ; setDeskStatus ( u -> did , DESK_FULL ) ; } else if ( type == TIMER_TYPE_JOIN ) { <S2SV_StartBug> buffer_append_string ( bnotify , "notify:timeout,join," ) ; <S2SV_EndBug> buffer_append_long ( bnotify , u -> sid ) ; buffer_append_string ( bnotify , ",\\r\\n\\r\\n" ) ; notify_user ( srv , u , bnotify ) ; <S2SV_StartBug> app_handle_leave ( srv , u ) ; <S2SV_EndBug> } else if ( type == TIMER_TYPE_RESUME ) { clearAllTimer ( u ) ; if ( isInDesk ( u ) == 1 ) { app_handle_leave ( srv , u ) ; } removeUser ( u ) ; } # if ( 0 ) else if ( type == TIMER_TYPE_DIANMU ) { void * game = getGame ( u -> did ) ; int next = getCurTurn ( game ) ; buffer_append_string ( bnotify , "notify:timeout,dianmu," ) ; buffer_append_long ( bnotify , u -> sid ) ; buffer_append_string ( bnotify , ",\\r\\n\\r\\n" ) ; buffer_append_string ( bnotify , "notify:next," ) ; buffer_append_long ( bnotify , next ) ; buffer_append_string ( bnotify , ",\\r\\n\\r\\n" ) ; notify_user ( srv , u , bnotify ) ; notify_user ( srv , pu , bnotify ) ; if ( u -> sid == next ) { stopWaitTimer ( srv , pu ) ; startWaitTimer ( srv , u , MAX_STEP_TIMEOUT ) ; setTimer ( u , time ( NULL ) , getMaxStepTimeout ( u -> did ) , TIMER_TYPE_STEP ) ; } else { stopWaitTimer ( srv , u ) ; startWaitTimer ( srv , pu , MAX_STEP_TIMEOUT ) ; setTimer ( pu , time ( NULL ) , getMaxStepTimeout ( pu -> did ) , TIMER_TYPE_STEP ) ; } if ( pu != NULL ) { setUserStatus ( pu , USER_STEP ) ; } if ( u != NULL ) { setUserStatus ( u , USER_STEP ) ; } setDeskStatus ( u -> did , DESK_PLAYING ) ; } # endif buffer_free ( bnotify ) ; } | <S2SV_ModStart> TIMER_TYPE_JOIN ) { if ( strstr ( u -> email , "robot-" ) > 0 ) { clearTimer ( u , TIMER_TYPE_JOIN ) ; } else { app_handle_leave ( srv , u ) ; <S2SV_ModStart> bnotify ) ; } <S2SV_ModEnd> } else if |
1,906 | CWE-000 static int uhurricane_listener ( unsigned int port ) { unsigned char buf [ 256 ] ; char ipstr [ INET6_ADDRSTRLEN ] ; struct sockaddr_in6 from ; double pdr ; MOTE_REPORT * n , * r , * c ; MOTE_REPORT_NEI * nei , * neir ; const unsigned char * bufaddr ; ssize_t recvlen , i ; socklen_t fromlen ; unsigned short sid ; int sfd ; sfd = socket ( AF_INET6 , SOCK_DGRAM , 0 ) ; if ( sfd < 0 ) { printf ( "socket<S2SV_blank>creat<S2SV_blank>erro\\n" ) ; return - 1 ; } motes = AVL_Create ( cmp , _releaser ) ; connections = AVL_Create ( cmpNei , _releaser ) ; memset ( & from , 0 , sizeof ( struct sockaddr_in6 ) ) ; from . sin6_family = AF_INET6 ; from . sin6_port = htons ( port ) ; from . sin6_addr = in6addr_any ; bind ( sfd , ( const struct sockaddr * ) & ( from ) , sizeof ( from ) ) ; fromlen = sizeof ( from ) ; while ( ( recvlen = recvfrom ( sfd , buf , sizeof ( buf ) , 0 , ( struct sockaddr * ) & from , & fromlen ) ) != - 1 ) { inet_ntop ( from . sin6_family , & ( from . sin6_addr ) , ipstr , sizeof ( ipstr ) ) ; sid = ( unsigned short ) ( ( buf [ 1 ] << 8 ) + ( buf [ 2 ] << 0 ) ) ; bufaddr = ushortid_server_getAddrById ( sid ) ; if ( bufaddr ) { n = malloc ( sizeof ( * n ) ) ; memcpy ( n -> addr64b , bufaddr , sizeof ( n -> addr64b ) ) ; r = AVL_Retrieve ( motes , n ) ; if ( ! r ) { n -> lastUpdate = time ( 0 ) ; AVL_Insert ( motes , n ) ; } else { free ( n ) ; r -> lastUpdate = time ( 0 ) ; n = r ; } c = n ; for ( i = 7 ; i < recvlen ; i += 6 ) { sid = ( unsigned short ) ( ( buf [ i + 0 ] << 8 ) + ( buf [ i + 1 ] << 0 ) ) ; bufaddr = ushortid_server_getAddrById ( sid ) ; if ( bufaddr ) { n = malloc ( sizeof ( * n ) ) ; memcpy ( n -> addr64b , bufaddr , sizeof ( n -> addr64b ) ) ; r = n ; if ( * ( ( unsigned char * ) buf + ( i + 4 ) ) > 0 ) pdr = ( double ) ( * ( ( unsigned char * ) buf + ( i + 5 ) ) ) / ( double ) ( * ( ( unsigned char * ) buf + ( i + 4 ) ) ) ; else pdr = 0.0 ; nei = ( MOTE_REPORT_NEI * ) malloc ( sizeof ( * nei ) ) ; nei -> pdr = pdr ; if ( cmp ( c , r ) > 0 ) { memcpy ( nei -> addr1 , r -> addr64b , sizeof ( nei -> addr1 ) ) ; memcpy ( nei -> addr2 , c -> addr64b , sizeof ( nei -> addr2 ) ) ; } else { memcpy ( nei -> addr1 , c -> addr64b , sizeof ( nei -> addr1 ) ) ; memcpy ( nei -> addr2 , r -> addr64b , sizeof ( nei -> addr2 ) ) ; } neir = AVL_Retrieve ( connections , nei ) ; if ( neir ) { neir -> lastUpdate = time ( 0 ) ; <S2SV_StartBug> neir -> pdr = pdr + neir -> pdr ; <S2SV_EndBug> free ( nei ) ; } else { AVL_Insert ( connections , nei ) ; nei -> lastUpdate = time ( 0 ) ; } free ( n ) ; } } } } close ( sfd ) ; AVL_Destroy ( motes ) ; AVL_Destroy ( connections ) ; return 0 ; } | <S2SV_ModStart> pdr = pdr <S2SV_ModEnd> ; free ( |
1,907 | CWE-000 static int bup_ulong_from_py ( unsigned long * x , PyObject * py , const char * name ) { <S2SV_StartBug> if ( PyInt_Check ( py ) ) <S2SV_EndBug> <S2SV_StartBug> return bup_ulong_from_pyint ( x , py , name ) ; <S2SV_EndBug> if ( ! PyLong_Check ( py ) ) { PyErr_Format ( PyExc_TypeError , "expected<S2SV_blank>integer<S2SV_blank>%s" , name ) ; return 0 ; } const unsigned long tmp = PyLong_AsUnsignedLong ( py ) ; if ( PyErr_Occurred ( ) ) { if ( PyErr_ExceptionMatches ( PyExc_OverflowError ) ) PyErr_Format ( PyExc_OverflowError , "%s<S2SV_blank>too<S2SV_blank>big<S2SV_blank>for<S2SV_blank>unsigned<S2SV_blank>long" , name ) ; return 0 ; } * x = tmp ; return 1 ; } | <S2SV_ModStart> name ) { # if PY_MAJOR_VERSION < 3 <S2SV_ModStart> name ) ; # endif |
1,908 | CWE-000 static int __parse_config_parse_value ( char * buf , int pos , void * val , int * off , int len , int cnt ) { int i , j = 0 , flag = 0 , ret , tmpval ; u8 dst [ 8 ] ; <S2SV_StartBug> char tmpbuf [ 32 ] ; <S2SV_EndBug> memset ( dst , 0 , 8 ) ; for ( i = 0 ; pos + i < len ; i ++ ) { if ( buf [ pos + i ] == 0x20 || buf [ pos + i ] == 0 ) { if ( flag == 0 ) { continue ; } else { if ( j == 0 || j > 17 ) return RU_PARSE_STATUS_ERROR ; tmpbuf [ j ] = 0 ; pr_err ( "j=%d,<S2SV_blank>i=%d,<S2SV_blank>buf=%s,<S2SV_blank>tmpbuf=%s\\n" , j , i , buf , tmpbuf ) ; <S2SV_StartBug> ret = kstrtoint ( tmpbuf , 16 , tmpval ) ; <S2SV_EndBug> if ( ret ) return RU_PARSE_STATUS_ERROR ; pr_err ( "tmp<S2SV_blank>val=%d\\n" , tmpval ) ; pr_err ( "dst=%u,%u,%u,%u,%u,%u,%u,%u\\n" , dst [ 0 ] , dst [ 1 ] , dst [ 2 ] , dst [ 3 ] , dst [ 4 ] , dst [ 5 ] , dst [ 6 ] , dst [ 7 ] ) ; if ( cnt == 1 ) { * ( u8 * ) val = ( u8 ) tmpval ; } else if ( cnt == 2 ) { * ( u16 * ) val = ( u16 ) tmpval ; } else if ( cnt == 4 ) { * ( u32 * ) val = ( u32 ) tmpval ; } else if ( cnt == 8 ) { * ( u64 * ) val = ( u64 ) tmpval ; } else return RU_PARSE_STATUS_ERROR ; * off = i ; return RU_PARSE_STATUS_SPACE ; } } else { flag = 1 ; tmpbuf [ j ++ ] = buf [ pos + i ] ; } } return RU_PARSE_STATUS_ERROR ; } | <S2SV_ModStart> char tmpbuf [ 17 <S2SV_ModEnd> ] ; memset <S2SV_ModStart> , 16 , & |
1,909 | CWE-000 int bdb_clean_pglogs_queues ( bdb_state_type * bdb_state ) { struct pglogs_queue_heads qh ; DB_LSN lsn ; int count , i ; <S2SV_StartBug> Pthread_mutex_lock ( & del_queue_lk ) ; <S2SV_EndBug> bdb_pglogs_min_lsn ( bdb_state , & lsn ) ; Pthread_mutex_lock ( & pglogs_queue_lk ) ; if ( ! pglogs_queue_fileid_hash ) { Pthread_mutex_unlock ( & pglogs_queue_lk ) ; Pthread_mutex_unlock ( & del_queue_lk ) ; return 0 ; } hash_info ( pglogs_queue_fileid_hash , NULL , NULL , NULL , NULL , & count , NULL , NULL ) ; qh . fileids = malloc ( count * sizeof ( unsigned char * ) ) ; for ( i = 0 ; i < count ; i ++ ) qh . fileids [ i ] = malloc ( sizeof ( unsigned char ) * DB_FILE_ID_LEN ) ; qh . index = 0 ; hash_for ( pglogs_queue_fileid_hash , collect_queue_fileids , & qh ) ; Pthread_mutex_unlock ( & pglogs_queue_lk ) ; for ( i = 0 ; i < count ; i ++ ) { struct fileid_pglogs_queue * queue ; unsigned char * fileid = qh . fileids [ i ] ; if ( ! ( queue = retrieve_fileid_pglogs_queue ( fileid , 0 ) ) ) abort ( ) ; bdb_clean_pglog_queue ( bdb_state , queue , lsn , NULL ) ; free ( qh . fileids [ i ] ) ; } free ( qh . fileids ) ; Pthread_mutex_unlock ( & del_queue_lk ) ; return 0 ; } | <S2SV_ModStart> , i ; if ( ! gbl_new_snapisol ) return 0 ; |
1,910 | CWE-000 static NTSTATUS cm_connect_netlogon_transport ( struct winbindd_domain * domain , enum dcerpc_transport_t transport , struct rpc_pipe_client * * cli ) { struct messaging_context * msg_ctx = server_messaging_context ( ) ; struct winbindd_cm_conn * conn ; NTSTATUS result ; enum netr_SchannelType sec_chan_type ; struct cli_credentials * creds = NULL ; * cli = NULL ; result = init_dc_connection_rpc ( domain , domain -> rodc ) ; if ( ! NT_STATUS_IS_OK ( result ) ) { return result ; } conn = & domain -> conn ; if ( rpccli_is_connected ( conn -> netlogon_pipe ) ) { * cli = conn -> netlogon_pipe ; return NT_STATUS_OK ; } TALLOC_FREE ( conn -> netlogon_pipe ) ; <S2SV_StartBug> conn -> netlogon_flags = 0 ; <S2SV_EndBug> TALLOC_FREE ( conn -> netlogon_creds_ctx ) ; result = get_trust_credentials ( domain , talloc_tos ( ) , true , & creds ) ; if ( ! NT_STATUS_IS_OK ( result ) ) { DBG_DEBUG ( "No<S2SV_blank>user<S2SV_blank>available<S2SV_blank>for<S2SV_blank>domain<S2SV_blank>%s<S2SV_blank>when<S2SV_blank>trying<S2SV_blank>" "schannel\\n" , domain -> name ) ; return NT_STATUS_CANT_ACCESS_DOMAIN_INFO ; } if ( cli_credentials_is_anonymous ( creds ) ) { DBG_WARNING ( "get_trust_credential<S2SV_blank>only<S2SV_blank>gave<S2SV_blank>anonymous<S2SV_blank>for<S2SV_blank>%s,<S2SV_blank>" "unable<S2SV_blank>to<S2SV_blank>make<S2SV_blank>get<S2SV_blank>NETLOGON<S2SV_blank>credentials\\n" , domain -> name ) ; return NT_STATUS_CANT_ACCESS_DOMAIN_INFO ; } sec_chan_type = cli_credentials_get_secure_channel_type ( creds ) ; if ( sec_chan_type == SEC_CHAN_NULL ) { if ( transport == NCACN_IP_TCP ) { DBG_NOTICE ( "get_secure_channel_type<S2SV_blank>gave<S2SV_blank>SEC_CHAN_NULL<S2SV_blank>" "for<S2SV_blank>%s,<S2SV_blank>deny<S2SV_blank>NCACN_IP_TCP<S2SV_blank>and<S2SV_blank>let<S2SV_blank>the<S2SV_blank>" "caller<S2SV_blank>fallback<S2SV_blank>to<S2SV_blank>NCACN_NP.\\n" , domain -> name ) ; return NT_STATUS_CANT_ACCESS_DOMAIN_INFO ; } DBG_NOTICE ( "get_secure_channel_type<S2SV_blank>gave<S2SV_blank>SEC_CHAN_NULL<S2SV_blank>for<S2SV_blank>%s,<S2SV_blank>" "fallback<S2SV_blank>to<S2SV_blank>noauth<S2SV_blank>on<S2SV_blank>NCACN_NP.\\n" , domain -> name ) ; result = cli_rpc_pipe_open_noauth_transport ( conn -> cli , transport , & ndr_table_netlogon , & conn -> netlogon_pipe ) ; if ( ! NT_STATUS_IS_OK ( result ) ) { invalidate_cm_connection ( domain ) ; return result ; } * cli = conn -> netlogon_pipe ; return NT_STATUS_OK ; } result = rpccli_create_netlogon_creds_ctx ( creds , domain -> dcname , msg_ctx , domain , & conn -> netlogon_creds_ctx ) ; if ( ! NT_STATUS_IS_OK ( result ) ) { DEBUG ( 1 , ( "rpccli_create_netlogon_creds<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>%s,<S2SV_blank>" "unable<S2SV_blank>to<S2SV_blank>create<S2SV_blank>NETLOGON<S2SV_blank>credentials:<S2SV_blank>%s\\n" , domain -> name , nt_errstr ( result ) ) ) ; return result ; } result = rpccli_connect_netlogon ( conn -> cli , transport , conn -> netlogon_creds_ctx , conn -> netlogon_force_reauth , creds , & conn -> netlogon_pipe ) ; if ( ! NT_STATUS_IS_OK ( result ) ) { DBG_DEBUG ( "rpccli_connect_netlogon<S2SV_blank>failed:<S2SV_blank>%s\\n" , nt_errstr ( result ) ) ; return result ; } * cli = conn -> netlogon_pipe ; return NT_STATUS_OK ; } | <S2SV_ModStart> netlogon_pipe ) ; <S2SV_ModEnd> TALLOC_FREE ( conn |
1,911 | CWE-000 int TclCompileDictUpdateCmd ( Tcl_Interp * interp , Tcl_Parse * parsePtr , Command * cmdPtr , CompileEnv * envPtr ) { Proc * procPtr = envPtr -> procPtr ; DefineLineInformation ; const char * name ; int i , nameChars , dictIndex , numVars , range , infoIndex ; Tcl_Token * * keyTokenPtrs , * dictVarTokenPtr , * bodyTokenPtr , * tokenPtr ; DictUpdateInfo * duiPtr ; JumpFixup jumpFixup ; if ( parsePtr -> numWords < 5 || procPtr == NULL ) { return TCL_ERROR ; } if ( ( parsePtr -> numWords - 1 ) & 1 ) { return TCL_ERROR ; } numVars = ( parsePtr -> numWords - 3 ) / 2 ; dictVarTokenPtr = TokenAfter ( parsePtr -> tokenPtr ) ; if ( dictVarTokenPtr -> type != TCL_TOKEN_SIMPLE_WORD ) { return TCL_ERROR ; } name = dictVarTokenPtr [ 1 ] . start ; nameChars = dictVarTokenPtr [ 1 ] . size ; if ( ! TclIsLocalScalar ( name , nameChars ) ) { return TCL_ERROR ; } dictIndex = TclFindCompiledLocal ( name , nameChars , 1 , procPtr ) ; duiPtr = ( DictUpdateInfo * ) ckalloc ( sizeof ( DictUpdateInfo ) + sizeof ( int ) * ( numVars - 1 ) ) ; duiPtr -> length = numVars ; keyTokenPtrs = ( Tcl_Token * * ) TclStackAlloc ( interp , sizeof ( Tcl_Token * ) * numVars ) ; tokenPtr = TokenAfter ( dictVarTokenPtr ) ; for ( i = 0 ; i < numVars ; i ++ ) { keyTokenPtrs [ i ] = tokenPtr ; tokenPtr = TokenAfter ( tokenPtr ) ; if ( tokenPtr -> type != TCL_TOKEN_SIMPLE_WORD ) { ckfree ( ( char * ) duiPtr ) ; TclStackFree ( interp , keyTokenPtrs ) ; return TCL_ERROR ; } name = tokenPtr [ 1 ] . start ; nameChars = tokenPtr [ 1 ] . size ; if ( ! TclIsLocalScalar ( name , nameChars ) ) { ckfree ( ( char * ) duiPtr ) ; TclStackFree ( interp , keyTokenPtrs ) ; return TCL_ERROR ; } duiPtr -> varIndices [ i ] = TclFindCompiledLocal ( name , nameChars , 1 , procPtr ) ; tokenPtr = TokenAfter ( tokenPtr ) ; } if ( tokenPtr -> type != TCL_TOKEN_SIMPLE_WORD ) { ckfree ( ( char * ) duiPtr ) ; TclStackFree ( interp , keyTokenPtrs ) ; return TCL_ERROR ; } bodyTokenPtr = tokenPtr ; infoIndex = TclCreateAuxData ( duiPtr , & tclDictUpdateInfoType , envPtr ) ; for ( i = 0 ; i < numVars ; i ++ ) { CompileWord ( envPtr , keyTokenPtrs [ i ] , interp , i ) ; } TclEmitInstInt4 ( INST_LIST , numVars , envPtr ) ; TclEmitInstInt4 ( INST_DICT_UPDATE_START , dictIndex , envPtr ) ; TclEmitInt4 ( infoIndex , envPtr ) ; range = DeclareExceptionRange ( envPtr , CATCH_EXCEPTION_RANGE ) ; TclEmitInstInt4 ( INST_BEGIN_CATCH4 , range , envPtr ) ; ExceptionRangeStarts ( envPtr , range ) ; <S2SV_StartBug> CompileBody ( envPtr , bodyTokenPtr , interp ) ; <S2SV_EndBug> ExceptionRangeEnds ( envPtr , range ) ; TclEmitOpcode ( INST_END_CATCH , envPtr ) ; TclEmitInstInt4 ( INST_REVERSE , 2 , envPtr ) ; TclEmitInstInt4 ( INST_DICT_UPDATE_END , dictIndex , envPtr ) ; TclEmitInt4 ( infoIndex , envPtr ) ; TclEmitForwardJump ( envPtr , TCL_UNCONDITIONAL_JUMP , & jumpFixup ) ; ExceptionRangeTarget ( envPtr , range , catchOffset ) ; TclEmitOpcode ( INST_PUSH_RESULT , envPtr ) ; TclEmitOpcode ( INST_PUSH_RETURN_OPTIONS , envPtr ) ; TclEmitOpcode ( INST_END_CATCH , envPtr ) ; TclEmitInstInt4 ( INST_REVERSE , 3 , envPtr ) ; TclEmitInstInt4 ( INST_DICT_UPDATE_END , dictIndex , envPtr ) ; TclEmitInt4 ( infoIndex , envPtr ) ; TclEmitOpcode ( INST_RETURN_STK , envPtr ) ; if ( TclFixupForwardJumpToHere ( envPtr , & jumpFixup , 127 ) ) { Tcl_Panic ( "TclCompileDictCmd(update):<S2SV_blank>bad<S2SV_blank>jump<S2SV_blank>distance<S2SV_blank>%d" , ( int ) ( CurrentOffset ( envPtr ) - jumpFixup . codeOffset ) ) ; } TclStackFree ( interp , keyTokenPtrs ) ; return TCL_OK ; } | <S2SV_ModStart> range ) ; SetLineInformation ( parsePtr -> numWords - 1 ) ; |
1,912 | CWE-000 static void handle_chl_int2_v3_hw ( struct hisi_hba * hisi_hba , int phy_no ) { u32 irq_msk = hisi_sas_phy_read32 ( hisi_hba , phy_no , CHL_INT2_MSK ) ; u32 irq_value = hisi_sas_phy_read32 ( hisi_hba , phy_no , CHL_INT2 ) ; struct hisi_sas_phy * phy = & hisi_hba -> phy [ phy_no ] ; struct pci_dev * pci_dev = hisi_hba -> pci_dev ; struct device * dev = hisi_hba -> dev ; irq_value &= ~ irq_msk ; if ( ! irq_value ) return ; if ( irq_value & BIT ( CHL_INT2_SL_IDAF_TOUT_CONF_OFF ) ) { dev_warn ( dev , "phy%d<S2SV_blank>identify<S2SV_blank>timeout\\n" , phy_no ) ; hisi_sas_notify_phy_event ( phy , HISI_PHYE_LINK_RESET ) ; } if ( irq_value & BIT ( CHL_INT2_STP_LINK_TIMEOUT_OFF ) ) { u32 reg_value = hisi_sas_phy_read32 ( hisi_hba , phy_no , STP_LINK_TIMEOUT_STATE ) ; dev_warn ( dev , "phy%d<S2SV_blank>stp<S2SV_blank>link<S2SV_blank>timeout<S2SV_blank>(0x%x)\\n" , phy_no , reg_value ) ; if ( reg_value & BIT ( 4 ) ) hisi_sas_notify_phy_event ( phy , HISI_PHYE_LINK_RESET ) ; } <S2SV_StartBug> hisi_sas_phy_write32 ( hisi_hba , phy_no , CHL_INT2 , irq_value ) ; <S2SV_EndBug> if ( ( irq_value & BIT ( CHL_INT2_RX_INVLD_DW_OFF ) ) && ( pci_dev -> revision == 0x20 ) ) { u32 reg_value ; int rc ; rc = hisi_sas_read32_poll_timeout_atomic ( HILINK_ERR_DFX , reg_value , ! ( ( reg_value >> 8 ) & BIT ( phy_no ) ) , 1000 , 10000 ) ; <S2SV_StartBug> if ( rc ) { <S2SV_EndBug> disable_phy_v3_hw ( hisi_hba , phy_no ) ; hisi_sas_phy_write32 ( hisi_hba , phy_no , CHL_INT2 , <S2SV_StartBug> BIT ( CHL_INT2_RX_INVLD_DW_OFF ) ) ; <S2SV_EndBug> hisi_sas_phy_read32 ( hisi_hba , phy_no , ERR_CNT_INVLD_DW ) ; mdelay ( 1 ) ; enable_phy_v3_hw ( hisi_hba , phy_no ) ; } } } | <S2SV_ModStart> ) ; } <S2SV_ModEnd> if ( ( <S2SV_ModStart> ( rc ) hisi_sas_notify_phy_event ( phy , HISI_PHYE_LINK_RESET ) ; } <S2SV_ModEnd> hisi_sas_phy_write32 ( hisi_hba <S2SV_ModStart> , CHL_INT2 , irq_value ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
1,913 | CWE-000 char * virStorageBackendStablePath ( virStoragePoolObjPtr pool , const char * devpath , bool loop ) { DIR * dh ; struct dirent * dent ; char * stablepath ; int opentries = 0 ; int retry = 0 ; int direrr ; if ( pool -> def -> type == VIR_STORAGE_POOL_LOGICAL || ! virStorageBackendPoolPathIsStable ( pool -> def -> target . path ) ) goto ret_strdup ; reopen : if ( virDirOpenQuiet ( & dh , pool -> def -> target . path ) < 0 ) { opentries ++ ; if ( loop && errno == ENOENT && opentries < 50 ) { usleep ( 100 * 1000 ) ; goto reopen ; } virReportSystemError ( errno , _ ( "cannot<S2SV_blank>read<S2SV_blank>dir<S2SV_blank>\'%s\'" ) , pool -> def -> target . path ) ; return NULL ; } retry : while ( ( direrr = virDirRead ( dh , & dent , NULL ) ) > 0 ) { if ( virAsprintf ( & stablepath , "%s/%s" , pool -> def -> target . path , <S2SV_StartBug> dent -> d_name ) == - 1 ) { <S2SV_EndBug> VIR_DIR_CLOSE ( dh ) ; return NULL ; } if ( virFileLinkPointsTo ( stablepath , devpath ) ) { VIR_DIR_CLOSE ( dh ) ; return stablepath ; } VIR_FREE ( stablepath ) ; } if ( ! direrr && loop && ++ retry < 100 ) { usleep ( 100 * 1000 ) ; goto retry ; } VIR_DIR_CLOSE ( dh ) ; ret_strdup : ignore_value ( VIR_STRDUP ( stablepath , devpath ) ) ; return stablepath ; } | <S2SV_ModStart> -> d_name ) < 0 <S2SV_ModEnd> ) { VIR_DIR_CLOSE |
1,914 | CWE-000 char * * trie_approx ( trie_t * trie , char * prefix , int max_edit_dist , int num_matches ) { redisReply * reply ; unsigned int i ; if ( ! trie_connected ( trie ) ) { <S2SV_StartBug> trie -> context = apiConnect ( IP , PORT ) ; <S2SV_EndBug> } reply = redisCommand ( trie -> context , "TRIE.APPROXMATCH<S2SV_blank>%s<S2SV_blank>%s<S2SV_blank>%d<S2SV_blank>%d" , trie -> name , prefix , max_edit_dist , num_matches ) ; if ( reply == NULL ) { handle_error ( reply ) ; trie -> context = NULL ; return NULL ; } char * * completes = malloc ( sizeof ( char * ) * ( reply -> elements + 1 ) ) ; for ( i = 0 ; i < reply -> elements ; ++ i ) { completes [ i ] = ( char * ) malloc ( sizeof ( char ) * 80 ) ; if ( reply -> element [ i ] -> str == NULL ) completes [ i ] = NULL ; else strncpy ( completes [ i ] , reply -> element [ i ] -> str , ( sizeof ( char ) * 80 ) ) ; } completes [ i ] = NULL ; freeReplyObject ( reply ) ; return completes ; } | <S2SV_ModStart> PORT ) ; reply = redisCommand ( trie -> context , "MODULE<S2SV_blank>LIST" ) ; if ( reply -> elements == 0 ) reply = redisCommand ( trie -> context , "MODULE<S2SV_blank>LOAD<S2SV_blank>api/lib/redis-tries/module/trie.so" ) ; if ( reply == NULL ) { handle_error ( reply ) ; trie -> context = NULL ; return NULL ; } |
1,915 | CWE-000 void pure_phaseShiftLocal ( QubitRegister qureg , const int targetQubit , REAL angle ) { long long int sizeBlock , sizeHalfBlock ; long long int thisBlock , indexUp , indexLo ; REAL stateRealLo , stateImagLo ; long long int thisTask ; const long long int numTasks = qureg . numAmpsPerChunk >> 1 ; sizeHalfBlock = 1LL << targetQubit ; sizeBlock = 2LL * sizeHalfBlock ; REAL * stateVecReal = qureg . deviceStateVec . real ; REAL * stateVecImag = qureg . deviceStateVec . imag ; const REAL cosAngle = cos ( angle ) ; const REAL sinAngle = sin ( angle ) ; # ifdef _OPENMP <S2SV_StartBug> # pragma omp parallel default ( none ) shared ( numTasks , sizeBlock , sizeHalfBlock , stateVecReal , stateVecImag , cosAngle , sinAngle ) private ( thisTask , thisBlock , indexUp , indexLo , stateRealLo , stateImagLo ) <S2SV_EndBug> # endif { # ifdef _OPENMP # pragma omp for schedule ( static ) # endif for ( thisTask = 0 ; thisTask < numTasks ; thisTask ++ ) { thisBlock = thisTask / sizeHalfBlock ; indexUp = thisBlock * sizeBlock + thisTask % sizeHalfBlock ; indexLo = indexUp + sizeHalfBlock ; stateRealLo = stateVecReal [ indexLo ] ; stateImagLo = stateVecImag [ indexLo ] ; stateVecReal [ indexLo ] = cosAngle * stateRealLo - sinAngle * stateImagLo ; stateVecImag [ indexLo ] = sinAngle * stateRealLo + cosAngle * stateImagLo ; } } } | <S2SV_ModStart> ) shared ( sizeBlock , sizeHalfBlock , stateVecReal , stateVecImag <S2SV_ModEnd> ) private ( |
1,916 | CWE-000 void lpm_drop ( ) { uint8_t max_pm ; <S2SV_StartBug> rtimer_clock_t next_timer ; <S2SV_EndBug> ti_lib_int_master_disable ( ) ; <S2SV_StartBug> max_pm = setup_sleep_mode ( & next_timer ) ; <S2SV_EndBug> if ( max_pm == LPM_MODE_SLEEP ) { lpm_sleep ( ) ; } else if ( max_pm == LPM_MODE_DEEP_SLEEP ) { <S2SV_StartBug> deep_sleep ( next_timer ) ; <S2SV_EndBug> } ti_lib_int_master_enable ( ) ; } | <S2SV_ModStart> uint8_t max_pm ; <S2SV_ModEnd> ti_lib_int_master_disable ( ) <S2SV_ModStart> = setup_sleep_mode ( <S2SV_ModEnd> ) ; if <S2SV_ModStart> { deep_sleep ( <S2SV_ModEnd> ) ; } |
1,917 | CWE-000 static void compose_response_to_packetbuf ( uint8_t * radio_request , uint8_t seqno , linkaddr_t * ereceiver ) { static uint8_t packet_buffer [ 128 ] ; uint8_t * packet = packet_buffer ; uint8_t * header = NULL ; uint8_t req ; uint8_t reqlen ; uint8_t response ; uint8_t responselen ; uint8_t i ; reqlen = * radio_request ++ ; req = * radio_request ++ ; responselen = 2 ; if ( req == CONECTRIC_ROUTE_REQUEST ) { response = CONECTRIC_ROUTE_REPLY ; linkaddr_copy ( ereceiver , & trickle_message_recv . esender ) ; } if ( req == CONECTRIC_ROUTE_REQUEST_BY_SN ) { response = CONECTRIC_ROUTE_REPLY ; linkaddr_copy ( ereceiver , & trickle_message_recv . esender ) ; } if ( req == CONECTRIC_MULTIHOP_PING ) { response = CONECTRIC_MULTIHOP_PING_REPLY ; linkaddr_copy ( ereceiver , & mhop_message_recv . esender ) ; } if ( req == CONECTRIC_POLL_RS485 ) { response = CONECTRIC_POLL_RS485_REPLY ; linkaddr_copy ( ereceiver , & mhop_message_recv . esender ) ; } if ( req == CONECTRIC_POLL_SENSORS ) { response = CONECTRIC_POLL_SENSORS_REPLY ; linkaddr_copy ( ereceiver , & mhop_message_recv . esender ) ; } if ( req == CONECTRIC_GET_LONG_MAC ) { response = CONECTRIC_GET_LONG_MAC_REPLY ; responselen += 8 ; linkaddr_copy ( ereceiver , & mhop_message_recv . esender ) ; } memset ( packet_buffer , 0 , sizeof ( packet_buffer ) ) ; * packet ++ = responselen ; * packet ++ = response ; i = responselen - 2 ; if ( req == CONECTRIC_GET_LONG_MAC ) { gmacp = X_IEEE_ADDR ; while ( i -- ) { * packet ++ = gmacp [ i ] ; puthex ( gmacp [ i ] ) ; } putstring ( "\\n" ) ; } packetbuf_copyfrom ( packet_buffer , responselen ) ; packetbuf_hdralloc ( 6 ) ; header = ( uint8_t * ) packetbuf_hdrptr ( ) ; * header ++ = 6 ; * header ++ = seqno ; * header ++ = 0 ; <S2SV_StartBug> * header ++ = 0 ; <S2SV_EndBug> * header ++ = ereceiver -> u8 [ 1 ] ; <S2SV_StartBug> * header ++ = ereceiver -> u8 [ 0 ] ; <S2SV_EndBug> } | <S2SV_ModStart> ++ = 0 ; * header ++ = ereceiver -> u8 [ 0 ] <S2SV_ModStart> 1 ] ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
1,918 | CWE-000 void perf_hpp__setup_output_field ( struct perf_hpp_list * list ) { struct perf_hpp_fmt * fmt ; perf_hpp_list__for_each_sort_list ( list , fmt ) { <S2SV_StartBug> struct perf_hpp_fmt * pos ; <S2SV_EndBug> perf_hpp_list__for_each_format ( list , pos ) { if ( fmt_equal ( fmt , pos ) ) goto next ; } perf_hpp__column_register ( fmt ) ; next : continue ; } } | <S2SV_ModStart> perf_hpp_fmt * pos ; if ( ! fmt -> entry && ! fmt -> color ) continue |
1,919 | CWE-000 static bool init ( TSS2_SYS_CONTEXT * sapi_context ) { <S2SV_StartBug> if ( ! ( ( ctx . flags . k || ctx . flags . c ) && ctx . flags . I ) ) { <S2SV_EndBug> <S2SV_StartBug> LOG_ERR ( "Expected<S2SV_blank>options<S2SV_blank>I<S2SV_blank>and<S2SV_blank>(k<S2SV_blank>or<S2SV_blank>c)" ) ; <S2SV_EndBug> return false ; } if ( ctx . flags . c ) { bool result = files_load_tpm_context_from_file ( sapi_context , & ctx . key_handle , ctx . context_key_file ) ; if ( ! result ) { return false ; } } <S2SV_StartBug> return true ; <S2SV_EndBug> } | <S2SV_ModStart> ( ! ( <S2SV_ModEnd> ctx . flags <S2SV_ModStart> . c ) <S2SV_ModEnd> ) { LOG_ERR <S2SV_ModStart> { LOG_ERR ( "Expected<S2SV_blank>options<S2SV_blank>k<S2SV_blank>or<S2SV_blank>c" <S2SV_ModEnd> ) ; return <S2SV_ModStart> ; } } ctx . message . t . size = BUFFER_SIZE ( TPM2B_PUBLIC_KEY_RSA , buffer ) ; return files_load_bytes_from_file_or_stdin ( ctx . input_path , & ctx . message . t . size , ctx . message . t . buffer ) <S2SV_ModEnd> ; } <S2SV_null> |
1,920 | CWE-000 char * oyReadFileToMem_ ( const char * name , size_t * size ) { <S2SV_StartBug> FILE * fp = 0 ; <S2SV_EndBug> <S2SV_StartBug> char * mem = 0 ; <S2SV_EndBug> const char * filename = name ; if ( filename && filename [ 0 ] && strlen ( filename ) > 7 && memcmp ( filename , "file://" , 7 ) == 0 ) <S2SV_StartBug> filename = & filename [ 7 ] ; <S2SV_EndBug> { fp = fopen ( filename , "rb" ) ; if ( fp ) { mem = oyReadFilepToMem_ ( fp , size ) ; } else { fprintf ( stderr , "%s:<S2SV_blank>%s\\n" , "Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>file" , filename ? filename : "" ) ; } } if ( fp ) fclose ( fp ) ; return mem ; } | <S2SV_ModStart> * fp = NULL <S2SV_ModEnd> ; char * <S2SV_ModStart> * mem = NULL <S2SV_ModEnd> ; const char <S2SV_ModStart> 7 ] ; if ( filename ) |
1,921 | CWE-000 static char * find_encoded_word ( char * s , enum ContentEncoding * enc , char * * charset , size_t * charsetlen , char * * text , size_t * textlen ) { static struct Regex * re = NULL ; regmatch_t match [ 4 ] ; size_t nmatch = 4 ; if ( re == NULL ) { re = mutt_regex_compile ( "=\\\\?" <S2SV_StartBug> "([^][()<>@,;:\\"/\\\\?,<S2SV_blank>=]+)" <S2SV_EndBug> "\\\\?" "([qQbB])" "\\\\?" <S2SV_StartBug> "([^?]*)" <S2SV_EndBug> "\\\\?=" , REG_EXTENDED ) ; assert ( re && "Something<S2SV_blank>is<S2SV_blank>wrong<S2SV_blank>with<S2SV_blank>your<S2SV_blank>RE<S2SV_blank>engine." ) ; } int rc = regexec ( re -> regex , s , nmatch , match , 0 ) ; if ( rc != 0 ) { return NULL ; } * charset = s + match [ 1 ] . rm_so ; * charsetlen = match [ 1 ] . rm_eo - match [ 1 ] . rm_so ; * enc = ( s [ match [ 2 ] . rm_so ] == 'Q' || s [ match [ 2 ] . rm_so ] == 'q' ) ? ENCQUOTEDPRINTABLE : ENCBASE64 ; * text = s + match [ 3 ] . rm_so ; * textlen = match [ 3 ] . rm_eo - match [ 3 ] . rm_so ; return s + match [ 0 ] . rm_so ; } | <S2SV_ModStart> mutt_regex_compile ( "=\\\\?" "([^][()<>@,;:\\\\\\"/?.<S2SV_blank>=]+)" <S2SV_ModEnd> "\\\\?" "([qQbB])" "\\\\?" <S2SV_ModStart> "\\\\?" "([qQbB])" "\\\\?" "([^?<S2SV_blank>]+)" <S2SV_ModEnd> "\\\\?=" , REG_EXTENDED |
1,922 | CWE-000 int prismelrenderer_push_prismel ( prismelrenderer_t * renderer , char * name , prismel_t * * prismel_ptr ) { int err ; ARRAY_PUSH_NEW ( prismel_t , * renderer , prismels , prismel ) <S2SV_StartBug> err = prismel_init ( prismel , name , renderer -> space ) ; <S2SV_EndBug> if ( err ) return err ; * prismel_ptr = prismel ; return 0 ; } | <S2SV_ModStart> , prismel ) if ( ! name ) { name = generate_indexed_name ( "prismel" , renderer -> prismels_len - 1 ) ; } |
1,923 | CWE-000 static void biji_webkit_editor_content_changed ( BijiWebkitEditor * self , const char * html , const char * text ) { BijiNoteObj * note = self -> priv -> note ; gchar * * rows ; biji_note_obj_set_html ( note , ( char * ) html ) ; biji_note_obj_set_raw_text ( note , ( char * ) text ) ; g_signal_emit ( self , biji_editor_signals [ CONTENT_CHANGED ] , 0 , NULL ) ; rows = g_strsplit ( text , "\\n" , 2 ) ; <S2SV_StartBug> if ( rows && rows [ 0 ] && rows [ 1 ] ) <S2SV_EndBug> { gchar * title ; gchar * unique_title ; title = rows [ 0 ] ; if ( g_strcmp0 ( title , biji_item_get_title ( BIJI_ITEM ( note ) ) ) != 0 ) { unique_title = biji_manager_get_unique_title ( biji_item_get_manager ( BIJI_ITEM ( note ) ) , title ) ; biji_note_obj_set_title ( note , unique_title ) ; g_free ( unique_title ) ; } } g_strfreev ( rows ) ; biji_note_obj_set_mtime ( note , g_get_real_time ( ) / G_USEC_PER_SEC ) ; biji_note_obj_save_note ( note ) ; } | <S2SV_ModStart> [ 0 ] <S2SV_ModEnd> ) { gchar |
1,924 | CWE-000 <S2SV_StartBug> pte_t * huge_pte_offset ( struct mm_struct * mm , unsigned long addr ) <S2SV_EndBug> { pgd_t * pgd ; pud_t * pud ; pmd_t * pmd ; pgd = pgd_offset ( mm , addr ) ; pr_debug ( "%s:<S2SV_blank>addr:0x%lx<S2SV_blank>pgd:%p\\n" , __func__ , addr , pgd ) ; if ( ! pgd_present ( * pgd ) ) return NULL ; pud = pud_offset ( pgd , addr ) ; if ( pud_none ( * pud ) ) return NULL ; if ( ! pud_present ( * pud ) || pud_huge ( * pud ) ) return ( pte_t * ) pud ; pmd = pmd_offset ( pud , addr ) ; if ( pmd_none ( * pmd ) ) return NULL ; if ( ! pmd_present ( * pmd ) || pmd_huge ( * pmd ) ) return ( pte_t * ) pmd ; return NULL ; } | <S2SV_ModStart> unsigned long addr , unsigned long sz |
1,925 | CWE-000 static int32_t q6asm_srvc_callback ( struct apr_client_data * data , void * priv ) { uint32_t dir = 0 ; uint32_t i = IN ; uint32_t * payload ; unsigned long dsp_flags ; struct asm_buffer_node * buf_node = NULL ; struct list_head * ptr , * next ; union asm_token_struct asm_token ; struct audio_client * ac = NULL ; struct audio_port_data * port ; <S2SV_StartBug> int session_id ; <S2SV_EndBug> if ( ! data ) { pr_err ( "%s:<S2SV_blank>Invalid<S2SV_blank>CB\\n" , __func__ ) ; return 0 ; } payload = data -> payload ; if ( data -> opcode == RESET_EVENTS ) { pr_debug ( "%s:<S2SV_blank>Reset<S2SV_blank>event<S2SV_blank>is<S2SV_blank>received:<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>apr[%pK]\\n" , __func__ , data -> reset_event , data -> reset_proc , this_mmap . apr ) ; atomic_set ( & this_mmap . ref_cnt , 0 ) ; apr_reset ( this_mmap . apr ) ; this_mmap . apr = NULL ; for ( ; i <= OUT ; i ++ ) { list_for_each_safe ( ptr , next , & common_client . port [ i ] . mem_map_handle ) { buf_node = list_entry ( ptr , struct asm_buffer_node , list ) ; if ( buf_node -> buf_phys_addr == common_client . port [ i ] . buf -> phys ) { list_del ( & buf_node -> list ) ; kfree ( buf_node ) ; } } pr_debug ( "%s:<S2SV_blank>Clearing<S2SV_blank>custom<S2SV_blank>topology\\n" , __func__ ) ; } cal_utils_clear_cal_block_q6maps ( ASM_MAX_CAL_TYPES , cal_data ) ; common_client . mmap_apr = NULL ; mutex_lock ( & cal_data [ ASM_CUSTOM_TOP_CAL ] -> lock ) ; set_custom_topology = 1 ; mutex_unlock ( & cal_data [ ASM_CUSTOM_TOP_CAL ] -> lock ) ; topology_map_handle = 0 ; rtac_clear_mapping ( ASM_RTAC_CAL ) ; return 0 ; } asm_token . token = data -> token ; <S2SV_StartBug> session_id = asm_token . _token . session_id ; <S2SV_EndBug> if ( ( session_id > 0 && session_id <= ASM_ACTIVE_STREAMS_ALLOWED ) ) spin_lock ( & ( session [ session_id ] . session_lock ) ) ; ac = q6asm_get_audio_client ( session_id ) ; dir = q6asm_get_flag_from_token ( & asm_token , ASM_DIRECTION_OFFSET ) ; if ( ! ac ) { pr_debug ( "%s:<S2SV_blank>session[%d]<S2SV_blank>already<S2SV_blank>freed\\n" , __func__ , session_id ) ; if ( ( session_id > 0 && session_id <= ASM_ACTIVE_STREAMS_ALLOWED ) ) spin_unlock ( & ( session [ session_id ] . session_lock ) ) ; return 0 ; } if ( data -> payload_size > sizeof ( int ) ) { pr_debug ( "%s:ptr0[0x%x]ptr1[0x%x]opcode[0x%x]<S2SV_blank>token[0x%x]payload_s[%d]<S2SV_blank>src[%d]<S2SV_blank>dest[%d]sid[%d]dir[%d]\\n" , __func__ , payload [ 0 ] , payload [ 1 ] , data -> opcode , data -> token , data -> payload_size , data -> src_port , data -> dest_port , asm_token . _token . session_id , dir ) ; pr_debug ( "%s:Payload<S2SV_blank>=<S2SV_blank>[0x%x]<S2SV_blank>status[0x%x]\\n" , __func__ , payload [ 0 ] , payload [ 1 ] ) ; } else if ( data -> payload_size == sizeof ( int ) ) { pr_debug ( "%s:ptr0[0x%x]opcode[0x%x]<S2SV_blank>token[0x%x]payload_s[%d]<S2SV_blank>src[%d]<S2SV_blank>dest[%d]sid[%d]dir[%d]\\n" , __func__ , payload [ 0 ] , data -> opcode , data -> token , data -> payload_size , data -> src_port , data -> dest_port , asm_token . _token . session_id , dir ) ; pr_debug ( "%s:Payload<S2SV_blank>=<S2SV_blank>[0x%x]\\n" , __func__ , payload [ 0 ] ) ; } if ( data -> opcode == APR_BASIC_RSP_RESULT ) { switch ( payload [ 0 ] ) { case ASM_CMD_SHARED_MEM_MAP_REGIONS : case ASM_CMD_SHARED_MEM_UNMAP_REGIONS : case ASM_CMD_ADD_TOPOLOGIES : if ( payload [ 1 ] != 0 ) { pr_err ( "%s:<S2SV_blank>cmd<S2SV_blank>=<S2SV_blank>0x%x<S2SV_blank>returned<S2SV_blank>error<S2SV_blank>=<S2SV_blank>0x%x<S2SV_blank>sid:%d\\n" , __func__ , payload [ 0 ] , payload [ 1 ] , asm_token . _token . session_id ) ; if ( payload [ 0 ] == ASM_CMD_SHARED_MEM_UNMAP_REGIONS ) atomic_set ( & ac -> unmap_cb_success , 0 ) ; atomic_set ( & ac -> mem_state , payload [ 1 ] ) ; wake_up ( & ac -> mem_wait ) ; } else { if ( payload [ 0 ] == ASM_CMD_SHARED_MEM_UNMAP_REGIONS ) atomic_set ( & ac -> unmap_cb_success , 1 ) ; } if ( atomic_cmpxchg ( & ac -> mem_state , - 1 , 0 ) == - 1 ) wake_up ( & ac -> mem_wait ) ; dev_vdbg ( ac -> dev , "%s:<S2SV_blank>Payload<S2SV_blank>=<S2SV_blank>[0x%x]<S2SV_blank>status[0x%x]\\n" , __func__ , payload [ 0 ] , payload [ 1 ] ) ; break ; default : pr_debug ( "%s:<S2SV_blank>command[0x%x]<S2SV_blank>not<S2SV_blank>expecting<S2SV_blank>rsp\\n" , __func__ , payload [ 0 ] ) ; break ; } <S2SV_StartBug> if ( ( session_id > 0 && <S2SV_EndBug> session_id <= ASM_ACTIVE_STREAMS_ALLOWED ) ) spin_unlock ( & ( session [ session_id ] . session_lock ) ) ; return 0 ; } port = & ac -> port [ dir ] ; switch ( data -> opcode ) { case ASM_CMDRSP_SHARED_MEM_MAP_REGIONS : { pr_debug ( "%s:PL#0[0x%x]<S2SV_blank>dir=0x%x<S2SV_blank>s_id=0x%x\\n" , __func__ , payload [ 0 ] , dir , asm_token . _token . session_id ) ; spin_lock_irqsave ( & port -> dsp_lock , dsp_flags ) ; if ( atomic_cmpxchg ( & ac -> mem_state , - 1 , 0 ) == - 1 ) { ac -> port [ dir ] . tmp_hdl = payload [ 0 ] ; wake_up ( & ac -> mem_wait ) ; } spin_unlock_irqrestore ( & port -> dsp_lock , dsp_flags ) ; break ; } case ASM_CMD_SHARED_MEM_UNMAP_REGIONS : { pr_debug ( "%s:<S2SV_blank>PL#0[0x%x]PL#1<S2SV_blank>[0x%x]\\n" , __func__ , payload [ 0 ] , payload [ 1 ] ) ; spin_lock_irqsave ( & port -> dsp_lock , dsp_flags ) ; if ( atomic_cmpxchg ( & ac -> mem_state , - 1 , 0 ) == - 1 ) wake_up ( & ac -> mem_wait ) ; spin_unlock_irqrestore ( & port -> dsp_lock , dsp_flags ) ; break ; } default : pr_debug ( "%s:<S2SV_blank>command[0x%x]success<S2SV_blank>[0x%x]\\n" , __func__ , payload [ 0 ] , payload [ 1 ] ) ; } if ( ac -> cb ) ac -> cb ( data -> opcode , data -> token , data -> payload , ac -> priv ) ; <S2SV_StartBug> if ( ( session_id > 0 && session_id <= ASM_ACTIVE_STREAMS_ALLOWED ) ) <S2SV_EndBug> spin_unlock ( & ( session [ session_id ] . session_lock ) ) ; return 0 ; } | <S2SV_ModStart> * port ; <S2SV_ModEnd> if ( ! <S2SV_ModStart> -> token ; ac = q6asm_get_audio_client ( asm_token . _token . session_id ) ; dir = q6asm_get_flag_from_token ( & asm_token , ASM_DIRECTION_OFFSET ) ; if ( ! ac ) { pr_debug ( "%s:<S2SV_blank>session[%d]<S2SV_blank>already<S2SV_blank>freed\\n" , __func__ , asm_token <S2SV_ModEnd> . _token . <S2SV_ModStart> _token . session_id <S2SV_ModEnd> ) ; return <S2SV_ModStart> break ; } <S2SV_ModEnd> return 0 ; <S2SV_ModStart> priv ) ; <S2SV_ModEnd> return 0 ; |
1,926 | CWE-000 size_t fs_init_free_list ( Storage * disk_p , size_t free_start , size_t free_end ) { size_t current_free = free_start ; while ( free_end > current_free ) { uint16_t * data = ( uint16_t * ) write_lba ( disk_p , current_free ) ; assert ( free_end > ( current_free + 1 ) ) ; size_t delta = free_end - current_free - 1 ; uint16_t next_free_list = current_free + 1 ; uint16_t free_sector_count = FS_FREE_ARRAY_MAX - 1 ; if ( delta <= free_sector_count ) { next_free_list = 0 ; free_sector_count = delta ; <S2SV_StartBug> } <S2SV_EndBug> data [ 0 ] = next_free_list ; data [ 1 ] = free_sector_count ; for ( int i = 0 ; i < delta ; i ++ ) { free_end -- ; data [ i + 2 ] = free_end ; } current_free ++ ; } buffer_flush_all ( disk_p ) ; return current_free - free_start ; } | <S2SV_ModStart> delta ; } else { delta = FS_FREE_ARRAY_MAX - 1 ; } |
1,927 | CWE-000 int at86rf2xx_init ( at86rf2xx_t * dev ) <S2SV_StartBug> { <S2SV_EndBug> dev -> idle_state = AT86RF2XX_STATE_TRX_OFF ; dev -> state = AT86RF2XX_STATE_SLEEP ; at86rf2xx_hal_delay ( & dev -> hal , 10 ) ; at86rf2xx_hal_sleep ( & dev -> hal , 0 ) ; at86rf2xx_hal_reset ( & dev -> hal , 1 ) ; at86rf2xx_hal_cs ( & dev -> hal , 1 ) ; at86rf2xx_assert_awake ( dev ) ; uint8_t part_num = at86rf2xx_reg_read ( dev , AT86RF2XX_REG__PART_NUM ) ; if ( part_num != AT86RF233_PARTNUM ) { printf ( "[at86rf2xx]<S2SV_blank>Error:<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>read<S2SV_blank>correct<S2SV_blank>part<S2SV_blank>number<S2SV_blank>(%x).\\r\\n" , part_num ) ; return - 1 ; } printf ( "[at86rf2xx]<S2SV_blank>Detected<S2SV_blank>part<S2SV_blank>#:<S2SV_blank>0x%x\\r\\n" , part_num ) ; printf ( "[at86rf2xx]<S2SV_blank>Version:<S2SV_blank>0x%x\\r\\n" , at86rf2xx_reg_read ( dev , AT86RF2XX_REG__VERSION_NUM ) ) ; at86rf2xx_reset ( dev ) ; return 0 ; } | <S2SV_ModStart> dev ) { dev -> events = 0 ; |
1,928 | CWE-000 static int nntp_date ( NNTP_SERVER * nserv , time_t * now ) { if ( nserv -> hasDATE ) { NNTP_DATA nntp_data ; char buf [ LONG_STRING ] ; struct tm tm ; nntp_data . nserv = nserv ; nntp_data . group = NULL ; strfcpy ( buf , "DATE\\r\\n" , sizeof ( buf ) ) ; if ( nntp_query ( & nntp_data , buf , sizeof ( buf ) ) < 0 ) return - 1 ; if ( sscanf ( buf , "111<S2SV_blank>%4d%2d%2d%2d%2d%2d%*s" , & tm . tm_year , & tm . tm_mon , & tm . tm_mday , & tm . tm_hour , & tm . tm_min , & tm . tm_sec ) == 6 ) { tm . tm_year -= 1900 ; tm . tm_mon -- ; * now = timegm ( & tm ) ; if ( * now >= 0 ) { <S2SV_StartBug> mutt_debug ( 1 , "nntp_date:<S2SV_blank>server<S2SV_blank>time<S2SV_blank>is<S2SV_blank>%d\\n" , * now ) ; <S2SV_EndBug> return 0 ; } } } time ( now ) ; return 0 ; } | <S2SV_ModStart> ( 1 , "nntp_date:<S2SV_blank>server<S2SV_blank>time<S2SV_blank>is<S2SV_blank>%lu\\n" <S2SV_ModEnd> , * now |
1,929 | CWE-000 __int128 t ( void ) { <S2SV_StartBug> return ( __int128 ) 1 << 80 ; <S2SV_EndBug> } | <S2SV_ModStart> { return ( ( __int128 ) 0x123456789abcdef << 64 ) | 0xfedcba987654321 <S2SV_ModEnd> ; } <S2SV_null> |
1,930 | CWE-000 static void snmp_collator_create_semaphore ( void ) { if ( ( stats_sem = sem_open ( stats_sem_name , O_CREAT | O_EXCL , SLAPD_DEFAULT_FILE_MODE , 1 ) ) == SEM_FAILED ) { if ( errno == EEXIST ) { if ( sem_unlink ( stats_sem_name ) != 0 ) { slapi_log_err ( SLAPI_LOG_EMERG , "snmp_collator_create_semaphore" , <S2SV_StartBug> "Failed<S2SV_blank>to<S2SV_blank>delete<S2SV_blank>old<S2SV_blank>semaphore<S2SV_blank>for<S2SV_blank>stats<S2SV_blank>file<S2SV_blank>(%s).<S2SV_blank>" <S2SV_EndBug> <S2SV_StartBug> "Error<S2SV_blank>%d<S2SV_blank>(%s).\\n" , stats_sem_name , errno , slapd_system_strerror ( errno ) ) ; <S2SV_EndBug> exit ( 1 ) ; } if ( ( stats_sem = sem_open ( stats_sem_name , O_CREAT | O_EXCL , SLAPD_DEFAULT_FILE_MODE , 1 ) ) == SEM_FAILED ) { slapi_log_err ( SLAPI_LOG_EMERG , "snmp_collator_create_semaphore" , <S2SV_StartBug> "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>semaphore<S2SV_blank>for<S2SV_blank>stats<S2SV_blank>file<S2SV_blank>(%s).<S2SV_blank>Error<S2SV_blank>%d<S2SV_blank>(%s).\\n" , <S2SV_EndBug> stats_sem_name , errno , slapd_system_strerror ( errno ) ) ; exit ( 1 ) ; } } else { slapi_log_err ( SLAPI_LOG_EMERG , "snmp_collator_create_semaphore" , <S2SV_StartBug> "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>semaphore<S2SV_blank>for<S2SV_blank>stats<S2SV_blank>file<S2SV_blank>(%s).<S2SV_blank>Error<S2SV_blank>%d.(%s)\\n" , <S2SV_EndBug> stats_sem_name , errno , slapd_system_strerror ( errno ) ) ; exit ( 1 ) ; } } return ; } | <S2SV_ModStart> , "snmp_collator_create_semaphore" , "Failed<S2SV_blank>to<S2SV_blank>delete<S2SV_blank>old<S2SV_blank>semaphore<S2SV_blank>for<S2SV_blank>stats<S2SV_blank>file<S2SV_blank>(/dev/shm/sem.%s).<S2SV_blank>" <S2SV_ModEnd> "Error<S2SV_blank>%d<S2SV_blank>(%s).\\n" , stats_sem_name <S2SV_ModStart> "Error<S2SV_blank>%d<S2SV_blank>(%s).\\n" , stats_sem_name + 1 <S2SV_ModStart> , "snmp_collator_create_semaphore" , "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>semaphore<S2SV_blank>for<S2SV_blank>stats<S2SV_blank>file<S2SV_blank>(/dev/shm/sem.%s).<S2SV_blank>Error<S2SV_blank>%d<S2SV_blank>(%s).\\n" , stats_sem_name + 1 <S2SV_ModEnd> , errno , <S2SV_ModStart> , "snmp_collator_create_semaphore" , "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>semaphore<S2SV_blank>for<S2SV_blank>stats<S2SV_blank>file<S2SV_blank>(/dev/shm/sem.%s).<S2SV_blank>Error<S2SV_blank>%d.(%s)\\n" , stats_sem_name + 1 <S2SV_ModEnd> , errno , |
1,931 | CWE-000 CommandList * read_file ( FILE * file ) { CommandList * list = new_command_list ( ) ; Stack * loop_stack = new_stack ( ) ; Changelist * changes = new_changelist ( ) ; int c , cur_pos = 0 ; while ( ( c = fgetc ( file ) ) != EOF ) { switch ( c ) { case '-' : add_change ( changes , cur_pos , - 1 ) ; break ; case '+' : add_change ( changes , cur_pos , 1 ) ; break ; case '<' : cur_pos -- ; break ; case '>' : cur_pos ++ ; break ; case '[' : push_changes_to_commands ( list , changes , cur_pos ) ; cur_pos = 0 ; if ( list -> num_cmds == 0 || list -> cmds [ list -> num_cmds - 1 ] . type == CMD_LOOP_END || ( list -> cmds [ list -> num_cmds - 1 ] . type == CMD_SET && list -> cmds [ list -> num_cmds - 1 ] . change_val == 0 ) ) { int loop_level = 1 ; while ( loop_level > 0 && ( c = fgetc ( file ) ) != EOF ) { if ( c == '[' ) loop_level ++ ; else if ( c == ']' ) loop_level -- ; } if ( loop_level > 0 ) { fprintf ( stderr , "Error!<S2SV_blank>Unmatched<S2SV_blank>\'[\'<S2SV_blank>found<S2SV_blank>in<S2SV_blank>the<S2SV_blank>code!\\n" ) ; exit ( 1 ) ; } } else { add_command ( list , CMD_LOOP_BEGIN , 0 , 0 ) ; stack_push ( loop_stack , list -> num_cmds - 1 ) ; } break ; case ']' : if ( stack_empty ( loop_stack ) ) { fprintf ( stderr , "Error!<S2SV_blank>Unmatched<S2SV_blank>\']\'<S2SV_blank>found<S2SV_blank>in<S2SV_blank>the<S2SV_blank>code.\\n" ) ; exit ( 1 ) ; } else { push_changes_to_commands ( list , changes , cur_pos ) ; cur_pos = 0 ; add_loop_end ( list , stack_pop ( loop_stack ) ) ; } break ; case '.' : push_changes_to_commands ( list , changes , cur_pos ) ; cur_pos = 0 ; add_command ( list , CMD_OUTPUT , 0 , 0 ) ; break ; case ',' : push_changes_to_commands ( list , changes , cur_pos ) ; cur_pos = 0 ; add_command ( list , CMD_INPUT , 0 , 0 ) ; break ; } } if ( ! stack_empty ( loop_stack ) ) { <S2SV_StartBug> fprintf ( stderr , "Error!<S2SV_blank>Unmatched<S2SV_blank>\']\'<S2SV_blank>found<S2SV_blank>in<S2SV_blank>the<S2SV_blank>code.\\n" ) ; <S2SV_EndBug> exit ( 1 ) ; } fclose ( file ) ; free_stack ( loop_stack ) ; free_changes ( changes ) ; return list ; } | <S2SV_ModStart> ( stderr , "Error!<S2SV_blank>Unmatched<S2SV_blank>\'[\'<S2SV_blank>found<S2SV_blank>in<S2SV_blank>the<S2SV_blank>code.\\n" <S2SV_ModEnd> ) ; exit |
1,932 | CWE-000 void intel_pmu_lbr_enable ( struct perf_event * event ) { struct cpu_hw_events * cpuc = & __get_cpu_var ( cpu_hw_events ) ; if ( ! x86_pmu . lbr_nr ) <S2SV_StartBug> return ; <S2SV_EndBug> WARN_ON_ONCE ( cpuc -> enabled ) ; if ( event -> ctx -> task && cpuc -> lbr_context != event -> ctx ) { intel_pmu_lbr_reset ( ) ; cpuc -> lbr_context = event -> ctx ; } cpuc -> lbr_users ++ ; } | <S2SV_ModStart> lbr_nr ) return <S2SV_ModEnd> ; if ( |
1,933 | CWE-000 static void nc_sshcb_auth_password ( struct nc_session * session , ssh_message msg ) { char * pass_hash ; pass_hash = auth_password_get_pwd_hash ( session -> username ) ; if ( pass_hash && ! auth_password_compare_pwd ( pass_hash , ssh_message_auth_password ( msg ) ) ) { VRB ( "User<S2SV_blank>\\"%s\\"<S2SV_blank>authenticated." , session -> username ) ; ssh_message_auth_reply_success ( msg , 0 ) ; session -> flags |= NC_SESSION_SSH_AUTHENTICATED ; free ( pass_hash ) ; return ; } free ( pass_hash ) ; ++ session -> ssh_auth_attempts ; <S2SV_StartBug> VRB ( "Failed<S2SV_blank>user<S2SV_blank>\\"\'%s\\"<S2SV_blank>authentication<S2SV_blank>attempt<S2SV_blank>(#%d)." , session -> username , session -> ssh_auth_attempts ) ; <S2SV_EndBug> ssh_message_reply_default ( msg ) ; } | <S2SV_ModStart> ; VRB ( "Failed<S2SV_blank>user<S2SV_blank>\\"%s\\"<S2SV_blank>authentication<S2SV_blank>attempt<S2SV_blank>(#%d)." <S2SV_ModEnd> , session -> |
1,934 | CWE-000 enum act_return process_use_service ( struct act_rule * rule , struct proxy * px , struct session * sess , struct stream * s , int flags ) { struct appctx * appctx ; if ( flags & ACT_FLAG_FIRST ) { s -> target = & rule -> applet . obj_type ; if ( unlikely ( ! stream_int_register_handler ( & s -> si [ 1 ] , objt_applet ( s -> target ) ) ) ) return ACT_RET_ERR ; appctx = si_appctx ( & s -> si [ 1 ] ) ; memset ( & appctx -> ctx , 0 , sizeof ( appctx -> ctx ) ) ; appctx -> rule = rule ; <S2SV_StartBug> } <S2SV_EndBug> else appctx = si_appctx ( & s -> si [ 1 ] ) ; appctx_pause ( appctx ) ; si_applet_stop_get ( & s -> si [ 1 ] ) ; if ( rule -> applet . init ) switch ( rule -> applet . init ( appctx , px , s ) ) { case 0 : return ACT_RET_ERR ; case 1 : break ; default : return ACT_RET_YIELD ; } si_applet_cant_get ( & s -> si [ 1 ] ) ; appctx_wakeup ( appctx ) ; if ( sess -> fe == s -> be ) sess -> fe -> fe_counters . intercepted_req ++ ; s -> flags |= SF_ASSIGNED ; return ACT_RET_STOP ; } | <S2SV_ModStart> = rule ; if ( rule -> from == ACT_F_HTTP_REQ ) { s -> req . analysers &= AN_REQ_FLT_HTTP_HDRS | AN_REQ_FLT_END ; s -> req . analysers |= AN_REQ_HTTP_XFER_BODY ; } |
1,935 | CWE-000 void emu3_print_sample_info ( struct emu3_sample * sample , sf_count_t nframes ) { for ( int i = 0 ; i < SAMPLE_PARAMETERS ; i ++ ) emu3_log ( 2 , 1 , "0x%08x<S2SV_blank>" , sample -> parameters [ i ] ) ; <S2SV_StartBug> emu3_log ( 2 , 1 , "\\n" ) ; <S2SV_EndBug> emu3_log ( 1 , 1 , "Channels:<S2SV_blank>%d\\n" , emu3_get_sample_channels ( sample ) ) ; emu3_log ( 1 , 1 , "Frames:<S2SV_blank>%" PRId64 "\\n" , nframes ) ; emu3_log ( 1 , 1 , "Sample<S2SV_blank>rate:<S2SV_blank>%dHz\\n" , sample -> sample_rate ) ; emu3_log ( 1 , 1 , "Loop<S2SV_blank>enabled:<S2SV_blank>%s\\n" , sample -> format & LOOP ? "on" : "off" ) ; emu3_log ( 1 , 1 , "Loop<S2SV_blank>in<S2SV_blank>release:<S2SV_blank>%s\\n" , sample -> format & LOOP_RELEASE ? "on" : "off" ) ; } | <S2SV_ModStart> 1 , "\\n" ) ; emu3_log ( 2 , 1 , "Sample<S2SV_blank>format:<S2SV_blank>0x%08x\\n" , sample -> format |
1,936 | CWE-000 void run_operation ( const rtg_operation * operation ) { fprintf ( stderr , "----><S2SV_blank>%s:%u<S2SV_blank>(%s)\\n" , __FILE__ , __LINE__ , "void<S2SV_blank>run_operation(const<S2SV_blank>operation<S2SV_blank>*)" ) ; if ( operation -> type_ == RTG_OPERATION_TYPE_PRINT || operation -> type_ == RTG_OPERATION_TYPE_PRINT_NO_CRLF ) { assertion ( operation -> args_ != NULL ) ; <S2SV_StartBug> assertion ( rtg_operation_args_simple_list_size ( <S2SV_EndBug> operation -> args_ ) == 1 ) ; assertion ( operation -> args_ -> first != NULL ) ; assertion ( operation -> args_ -> first -> type_ != RTG_OPERATION_ARG_TYPE_INVALID ) ; <S2SV_StartBug> assertion ( operation -> args_ -> first -> type_ == <S2SV_EndBug> <S2SV_StartBug> RTG_OPERATION_ARG_TYPE_STRING_LITERAL ) ; <S2SV_EndBug> assertion ( operation -> args_ -> first -> string_literal_ != NULL ) ; assertion ( operation -> args_ -> first -> string_literal_ -> value_ != NULL ) ; printf ( "%s" , operation -> args_ -> first -> string_literal_ -> value_ ) ; <S2SV_StartBug> if ( operation -> type_ == RTG_OPERATION_TYPE_PRINT ) { <S2SV_EndBug> printf ( "\\n" ) ; } else { assertion ( operation -> type_ == RTG_OPERATION_TYPE_PRINT_NO_CRLF ) ; } } else { assertion ( operation -> type_ == RTG_OPERATION_TYPE_INVALID ) ; printf ( "!!!\\n" ) ; } } | <S2SV_ModStart> ; assertion ( rtg_operation_args_simple_list_length <S2SV_ModEnd> ( operation -> <S2SV_ModStart> RTG_OPERATION_ARG_TYPE_INVALID ) ; if <S2SV_ModEnd> ( operation -> <S2SV_ModStart> == RTG_OPERATION_ARG_TYPE_STRING_LITERAL ) { <S2SV_ModEnd> assertion ( operation <S2SV_ModStart> value_ ) ; } else { assertion ( operation -> args_ -> first -> type_ == RTG_OPERATION_ARG_TYPE_NATURAL_LITERAL ) ; assertion ( operation -> args_ -> first -> natural_literal_ != NULL ) ; assertion ( operation -> args_ -> first -> natural_literal_ -> value_ != NULL ) ; printf ( "%s" , operation -> args_ -> first -> natural_literal_ -> value_ ) ; } |
1,937 | CWE-000 int ft_board_setup ( void * blob , bd_t * bd ) { phys_addr_t base ; phys_size_t size ; ft_cpu_setup ( blob , bd ) ; <S2SV_StartBug> base = getenv_bootm_low ( ) ; <S2SV_EndBug> <S2SV_StartBug> size = getenv_bootm_size ( ) ; <S2SV_EndBug> fdt_fixup_memory ( blob , ( u64 ) base , ( u64 ) size ) ; # ifdef CONFIG_PCI pci_of_setup ( blob , bd ) ; # endif fdt_fixup_liodn ( blob ) ; # ifdef CONFIG_HAS_FSL_DR_USB fsl_fdt_fixup_dr_usb ( blob , bd ) ; # endif # ifdef CONFIG_SYS_DPAA_FMAN fdt_fixup_fman_ethernet ( blob ) ; fdt_fixup_board_enet ( blob ) ; # endif fdt_fixup_spi_mux ( blob ) ; return 0 ; } | <S2SV_ModStart> ; base = env_get_bootm_low <S2SV_ModEnd> ( ) ; <S2SV_ModStart> ; size = env_get_bootm_size <S2SV_ModEnd> ( ) ; |
1,938 | CWE-000 char * qdSerializeDtxContextInfo ( int * size , bool wantSnapshot , bool inCursor , int txnOptions , char * debugCaller ) { char * serializedDtxContextInfo ; Snapshot snapshot = NULL ; int serializedLen ; DtxContextInfo * pDtxContextInfo = NULL ; * size = 0 ; <S2SV_StartBug> if ( wantSnapshot ) <S2SV_EndBug> { if ( ! FirstSnapshotSet && ! IsAbortInProgress ( ) ) { <S2SV_StartBug> elog ( ( Debug_print_full_dtm ? LOG : DEBUG5 ) , <S2SV_EndBug> <S2SV_StartBug> "qdSerializeDtxContextInfo<S2SV_blank>calling<S2SV_blank>GetTransactionSnapshot<S2SV_blank>to<S2SV_blank>make<S2SV_blank>snapshot" ) ; <S2SV_EndBug> GetTransactionSnapshot ( ) ; } snapshot = GetLatestSnapshot ( ) ; } switch ( DistributedTransactionContext ) { case DTX_CONTEXT_QD_DISTRIBUTED_CAPABLE : case DTX_CONTEXT_LOCAL_ONLY : DtxContextInfo_CreateOnMaster ( & TempQDDtxContextInfo , txnOptions , snapshot ) ; TempQDDtxContextInfo . cursorContext = inCursor ; if ( DistributedTransactionContext == DTX_CONTEXT_QD_DISTRIBUTED_CAPABLE && snapshot != NULL ) { updateSharedLocalSnapshot ( & TempQDDtxContextInfo , snapshot , "qdSerializeDtxContextInfo" ) ; } pDtxContextInfo = & TempQDDtxContextInfo ; break ; case DTX_CONTEXT_QD_RETRY_PHASE_2 : case DTX_CONTEXT_QE_ENTRY_DB_SINGLETON : case DTX_CONTEXT_QE_AUTO_COMMIT_IMPLICIT : case DTX_CONTEXT_QE_TWO_PHASE_EXPLICIT_WRITER : case DTX_CONTEXT_QE_TWO_PHASE_IMPLICIT_WRITER : case DTX_CONTEXT_QE_READER : case DTX_CONTEXT_QE_PREPARED : case DTX_CONTEXT_QE_FINISH_PREPARED : elog ( FATAL , "Unexpected<S2SV_blank>distribute<S2SV_blank>transaction<S2SV_blank>context:<S2SV_blank>\'%s\'" , DtxContextToString ( DistributedTransactionContext ) ) ; default : elog ( FATAL , "Unrecognized<S2SV_blank>DTX<S2SV_blank>transaction<S2SV_blank>context:<S2SV_blank>%d" , ( int ) DistributedTransactionContext ) ; } serializedLen = DtxContextInfo_SerializeSize ( pDtxContextInfo ) ; Assert ( serializedLen > 0 ) ; * size = serializedLen ; serializedDtxContextInfo = palloc ( * size ) ; DtxContextInfo_Serialize ( serializedDtxContextInfo , pDtxContextInfo ) ; elog ( ( Debug_print_full_dtm ? LOG : DEBUG5 ) , "qdSerializeDtxContextInfo<S2SV_blank>(called<S2SV_blank>by<S2SV_blank>%s)<S2SV_blank>returning<S2SV_blank>a<S2SV_blank>snapshot<S2SV_blank>of<S2SV_blank>%d<S2SV_blank>bytes<S2SV_blank>(ptr<S2SV_blank>is<S2SV_blank>%s)" , debugCaller , * size , ( serializedDtxContextInfo != NULL ? "Non-NULL" : "NULL" ) ) ; return serializedDtxContextInfo ; } | <S2SV_ModStart> if ( wantSnapshot <S2SV_ModEnd> && ! IsAbortInProgress <S2SV_ModStart> ) ) { if ( ActiveSnapshotSet ( ) ) { snapshot = GetActiveSnapshot ( ) ; elog ( ( Debug_print_snapshot_dtm ? LOG : DEBUG5 ) , "[Distributed<S2SV_blank>Snapshot<S2SV_blank>#%u]<S2SV_blank>*QD<S2SV_blank>Use<S2SV_blank>Active*<S2SV_blank>currcid<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>(gxid<S2SV_blank>=<S2SV_blank>%u,<S2SV_blank>\'%s\')" , snapshot -> distribSnapshotWithLocalMapping . ds . distribSnapshotId , snapshot -> curcid , getDistributedTransactionId ( ) , DtxContextToString ( DistributedTransactionContext ) ) ; } else { snapshot = GetTransactionSnapshot ( ) ; <S2SV_ModStart> DEBUG5 ) , "qdSerializeDtxContextInfo<S2SV_blank>called<S2SV_blank>GetTransactionSnapshot<S2SV_blank>to<S2SV_blank>make<S2SV_blank>snapshot" ) ; } <S2SV_ModEnd> } switch ( |
1,939 | CWE-000 static int ip_av_insert_nodesym ( struct util_av * av , const char * node , size_t nodecnt , const char * service , size_t svccnt , fi_addr_t * fi_addr , void * context ) { char name [ FI_NAME_MAX ] ; char svc [ FI_NAME_MAX ] ; size_t name_len , n , s ; int fi , ret , name_index , svc_index , success_cnt = 0 ; for ( name_len = strlen ( node ) ; isdigit ( node [ name_len - 1 ] ) ; ) name_len -- ; memcpy ( name , node , name_len ) ; name_index = atoi ( node + name_len ) ; svc_index = atoi ( service ) ; for ( n = 0 , fi = 0 ; n < nodecnt ; n ++ ) { if ( nodecnt == 1 ) { strncpy ( name , node , sizeof ( name ) - 1 ) ; name [ FI_NAME_MAX - 1 ] = '\\0' ; } else { snprintf ( name + name_len , sizeof ( name ) - name_len - 1 , <S2SV_StartBug> "%d" , name_index + n ) ; <S2SV_EndBug> } for ( s = 0 ; s < svccnt ; s ++ , fi ++ ) { if ( svccnt == 1 ) { strncpy ( svc , service , sizeof ( svc ) - 1 ) ; svc [ FI_NAME_MAX - 1 ] = '\\0' ; } else { snprintf ( svc , sizeof ( svc ) - 1 , <S2SV_StartBug> "%d" , svc_index + s ) ; <S2SV_EndBug> } ret = ip_av_insert_svc ( av , name , svc , fi_addr ? & fi_addr [ fi ] : NULL , context ) ; if ( ! ret ) success_cnt ++ ; else if ( av -> eq ) ofi_av_write_event ( av , fi , - ret , context ) ; } } return success_cnt ; } | <S2SV_ModStart> - 1 , "%zu" <S2SV_ModEnd> , name_index + <S2SV_ModStart> - 1 , "%zu" <S2SV_ModEnd> , svc_index + |
1,940 | CWE-000 BcStatus bc_parse_return ( BcParse * p , BcVec * code ) { BcStatus s ; BcLexType t ; bool paren ; if ( ! BC_PARSE_FUNC ( p ) ) return BC_STATUS_PARSE_BAD_TOKEN ; if ( ( s = bc_lex_next ( & p -> lex ) ) ) return s ; t = p -> lex . t . t ; paren = t == BC_LEX_LPAREN ; if ( t == BC_LEX_NLINE || t == BC_LEX_SCOLON ) { s = bc_vec_pushByte ( code , BC_INST_RET0 ) ; } else { <S2SV_StartBug> paren = paren && p -> lex . t . last == BC_LEX_RPAREN ; <S2SV_EndBug> <S2SV_StartBug> s = bc_parse_expr ( p , code , 0 , bc_parse_next_expr ) ; <S2SV_EndBug> if ( paren ) { if ( ! s ) s = bc_vec_pushByte ( code , BC_INST_RET ) ; else if ( s == BC_STATUS_PARSE_EMPTY_EXP ) s = bc_vec_pushByte ( code , BC_INST_RET0 ) ; } <S2SV_StartBug> else s = bc_vec_pushByte ( code , BC_INST_RET ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> if ( ! s && t != BC_LEX_NLINE && t != BC_LEX_SCOLON && ! paren && ( s = bc_vm_posix_error ( BC_STATUS_POSIX_RETURN_PARENS , p -> lex . file , p -> lex . line , NULL ) ) ) { return s ; } return s ; } | <S2SV_ModStart> } else { if ( ( s = bc_parse_expr ( p , code , 0 , bc_parse_next_expr ) ) ) return s ; <S2SV_ModStart> == BC_LEX_RPAREN ; if ( ! paren && ( s = bc_vm_posix_error ( BC_STATUS_POSIX_RETURN_PARENS , p -> lex . file , p -> lex . line , NULL ) ) ) { return s ; } <S2SV_ModEnd> if ( paren <S2SV_ModStart> ; } else if ( ! s ) <S2SV_ModStart> BC_INST_RET ) ; if ( s ) <S2SV_ModEnd> return s ; |
1,941 | CWE-000 static av_cold int nvenc_setup_encoder ( AVCodecContext * avctx ) { NvencContext * ctx = avctx -> priv_data ; NvencDynLoadFunctions * dl_fn = & ctx -> nvenc_dload_funcs ; NV_ENCODE_API_FUNCTION_LIST * p_nvenc = & dl_fn -> nvenc_funcs ; NV_ENC_PRESET_CONFIG preset_config = { 0 } ; NVENCSTATUS nv_status = NV_ENC_SUCCESS ; AVCPBProperties * cpb_props ; <S2SV_StartBug> int res = 0 ; <S2SV_EndBug> int dw , dh ; ctx -> encode_config . version = NV_ENC_CONFIG_VER ; ctx -> init_encode_params . version = NV_ENC_INITIALIZE_PARAMS_VER ; ctx -> init_encode_params . encodeHeight = avctx -> height ; ctx -> init_encode_params . encodeWidth = avctx -> width ; ctx -> init_encode_params . encodeConfig = & ctx -> encode_config ; nvenc_map_preset ( ctx ) ; preset_config . version = NV_ENC_PRESET_CONFIG_VER ; preset_config . presetCfg . version = NV_ENC_CONFIG_VER ; nv_status = p_nvenc -> nvEncGetEncodePresetConfig ( ctx -> nvencoder , ctx -> init_encode_params . encodeGUID , ctx -> init_encode_params . presetGUID , & preset_config ) ; if ( nv_status != NV_ENC_SUCCESS ) return nvenc_print_error ( avctx , nv_status , "Cannot<S2SV_blank>get<S2SV_blank>the<S2SV_blank>preset<S2SV_blank>configuration" ) ; memcpy ( & ctx -> encode_config , & preset_config . presetCfg , sizeof ( ctx -> encode_config ) ) ; ctx -> encode_config . version = NV_ENC_CONFIG_VER ; dw = avctx -> width ; dh = avctx -> height ; if ( avctx -> sample_aspect_ratio . num > 0 && avctx -> sample_aspect_ratio . den > 0 ) { dw *= avctx -> sample_aspect_ratio . num ; dh *= avctx -> sample_aspect_ratio . den ; } av_reduce ( & dw , & dh , dw , dh , 1024 * 1024 ) ; ctx -> init_encode_params . darHeight = dh ; ctx -> init_encode_params . darWidth = dw ; ctx -> init_encode_params . frameRateNum = avctx -> time_base . den ; ctx -> init_encode_params . frameRateDen = avctx -> time_base . num * avctx -> ticks_per_frame ; ctx -> init_encode_params . enableEncodeAsync = 0 ; ctx -> init_encode_params . enablePTD = 1 ; if ( ctx -> weighted_pred == 1 ) ctx -> init_encode_params . enableWeightedPrediction = 1 ; if ( ctx -> bluray_compat ) { ctx -> aud = 1 ; avctx -> refs = FFMIN ( FFMAX ( avctx -> refs , 0 ) , 6 ) ; avctx -> max_b_frames = FFMIN ( avctx -> max_b_frames , 3 ) ; switch ( avctx -> codec -> id ) { case AV_CODEC_ID_H264 : break ; case AV_CODEC_ID_HEVC : ctx -> level = NV_ENC_LEVEL_HEVC_51 ; ctx -> tier = NV_ENC_TIER_HEVC_HIGH ; break ; } } if ( avctx -> gop_size > 0 ) { if ( avctx -> max_b_frames >= 0 ) { ctx -> encode_config . frameIntervalP = avctx -> max_b_frames + 1 ; } ctx -> encode_config . gopLength = avctx -> gop_size ; } else if ( avctx -> gop_size == 0 ) { ctx -> encode_config . frameIntervalP = 0 ; ctx -> encode_config . gopLength = 1 ; } ctx -> initial_pts [ 0 ] = AV_NOPTS_VALUE ; ctx -> initial_pts [ 1 ] = AV_NOPTS_VALUE ; nvenc_recalc_surfaces ( avctx ) ; nvenc_setup_rate_control ( avctx ) ; if ( avctx -> flags & AV_CODEC_FLAG_INTERLACED_DCT ) { ctx -> encode_config . frameFieldMode = NV_ENC_PARAMS_FRAME_FIELD_MODE_FIELD ; } else { ctx -> encode_config . frameFieldMode = NV_ENC_PARAMS_FRAME_FIELD_MODE_FRAME ; } res = nvenc_setup_codec_config ( avctx ) ; if ( res ) return res ; <S2SV_StartBug> nv_status = p_nvenc -> nvEncInitializeEncoder ( ctx -> nvencoder , & ctx -> init_encode_params ) ; <S2SV_EndBug> if ( nv_status != NV_ENC_SUCCESS ) { return nvenc_print_error ( avctx , nv_status , "InitializeEncoder<S2SV_blank>failed" ) ; } if ( ctx -> encode_config . frameIntervalP > 1 ) avctx -> has_b_frames = 2 ; if ( ctx -> encode_config . rcParams . averageBitRate > 0 ) avctx -> bit_rate = ctx -> encode_config . rcParams . averageBitRate ; cpb_props = ff_add_cpb_side_data ( avctx ) ; if ( ! cpb_props ) return AVERROR ( ENOMEM ) ; cpb_props -> max_bitrate = ctx -> encode_config . rcParams . maxBitRate ; cpb_props -> avg_bitrate = avctx -> bit_rate ; cpb_props -> buffer_size = ctx -> encode_config . rcParams . vbvBufferSize ; return 0 ; } | <S2SV_ModStart> * cpb_props ; CUresult cu_res ; CUcontext dummy ; <S2SV_ModStart> return res ; cu_res = dl_fn -> cuda_dl -> cuCtxPushCurrent ( ctx -> cu_context ) ; if ( cu_res != CUDA_SUCCESS ) { av_log ( avctx , AV_LOG_ERROR , "cuCtxPushCurrent<S2SV_blank>failed\\n" ) ; return AVERROR_EXTERNAL ; } <S2SV_ModStart> init_encode_params ) ; cu_res = dl_fn -> cuda_dl -> cuCtxPopCurrent ( & dummy ) ; if ( cu_res != CUDA_SUCCESS ) { av_log ( avctx , AV_LOG_ERROR , "cuCtxPopCurrent<S2SV_blank>failed\\n" ) ; return AVERROR_EXTERNAL ; } |
1,942 | CWE-000 static int dav_svn__translate_name ( request_rec * r ) { const char * fs_path , * repos_basename , * repos_path ; const char * ignore_cleaned_uri , * ignore_relative_path ; int ignore_had_slash ; dir_conf_t * conf = ap_get_module_config ( r -> per_dir_config , & dav_svn_module ) ; if ( ! conf -> fs_path && ! conf -> fs_parent_path ) return DECLINED ; if ( dav_svn__is_parentpath_list ( r ) ) { repos_basename = "" ; repos_path = NULL ; } else { dav_error * err = dav_svn_split_uri ( r , r -> uri , conf -> root_dir , & ignore_cleaned_uri , & ignore_had_slash , & repos_basename , & ignore_relative_path , & repos_path ) ; if ( err ) { dav_svn__log_err ( r , err , APLOG_ERR ) ; return err -> status ; } } if ( conf -> fs_parent_path ) { fs_path = svn_dirent_join ( conf -> fs_parent_path , repos_basename , r -> pool ) ; } else { fs_path = conf -> fs_path ; } if ( repos_path && '/' == repos_path [ 0 ] && '\\0' == repos_path [ 1 ] ) repos_path = NULL ; r -> filename = apr_pstrcat ( r -> pool , "dav_svn:" , fs_path , repos_path , SVN_VA_NULL ) ; <S2SV_StartBug> apr_table_setn ( r -> notes , NO_MAP_TO_STORAGE_NOTE , ( const char * ) 1 ) ; <S2SV_EndBug> return OK ; } | <S2SV_ModStart> , NO_MAP_TO_STORAGE_NOTE , "1" <S2SV_ModEnd> ) ; return |
1,943 | CWE-000 static void test_trivial_utf8 ( const char * string , size_t n_string , size_t n_bytes ) { uint64_t ts ; const char * res ; ts = test_get_time ( ) ; res = trivial_utf8_is_valid ( string ) ; <S2SV_StartBug> fprintf ( stderr , "UTF-8<S2SV_blank>verify<S2SV_blank>string<S2SV_blank>of<S2SV_blank>%zu-byte<S2SV_blank>characters<S2SV_blank>(trivial):<S2SV_blank>%lu<S2SV_blank>Mchar/s\\n" , n_bytes , n_string / n_bytes * 1000 * 1000 * 1000 / 1024 / 1024 / ( test_get_time ( ) - ts ) ) ; <S2SV_EndBug> assert ( res == string ) ; } | <S2SV_ModStart> ( stderr , "UTF-8<S2SV_blank>verify<S2SV_blank>string<S2SV_blank>of<S2SV_blank>%zu-byte<S2SV_blank>characters<S2SV_blank>(trivial):<S2SV_blank>%zu<S2SV_blank>Mchar/s\\n" <S2SV_ModEnd> , n_bytes , |
1,944 | CWE-000 static int ath6kl_cfg80211_sscan_start ( struct wiphy * wiphy , struct net_device * dev , struct cfg80211_sched_scan_request * request ) { struct ath6kl * ar = ath6kl_priv ( dev ) ; struct ath6kl_vif * vif = netdev_priv ( dev ) ; u16 interval ; int ret , rssi_thold ; <S2SV_StartBug> if ( ar -> state != ATH6KL_STATE_ON ) <S2SV_EndBug> return - EIO ; if ( vif -> sme_state != SME_DISCONNECTED ) return - EBUSY ; ath6kl_cfg80211_scan_complete_event ( vif , true ) ; ret = ath6kl_set_probed_ssids ( ar , vif , request -> ssids , request -> n_ssids , request -> match_sets , <S2SV_StartBug> request -> n_match_sets ) ; <S2SV_EndBug> if ( ret < 0 ) return ret ; <S2SV_StartBug> if ( ! request -> n_match_sets ) { <S2SV_EndBug> ret = ath6kl_wmi_bssfilter_cmd ( ar -> wmi , vif -> fw_vif_idx , ALL_BSS_FILTER , 0 ) ; if ( ret < 0 ) return ret ; } else { ret = ath6kl_wmi_bssfilter_cmd ( ar -> wmi , vif -> fw_vif_idx , MATCHED_SSID_FILTER , 0 ) ; if ( ret < 0 ) return ret ; } if ( test_bit ( ATH6KL_FW_CAPABILITY_RSSI_SCAN_THOLD , ar -> fw_capabilities ) ) { <S2SV_StartBug> if ( request -> rssi_thold <= NL80211_SCAN_RSSI_THOLD_OFF ) <S2SV_EndBug> rssi_thold = 0 ; <S2SV_StartBug> else if ( request -> rssi_thold < - 127 ) <S2SV_EndBug> rssi_thold = - 127 ; else <S2SV_StartBug> rssi_thold = request -> rssi_thold ; <S2SV_EndBug> ret = ath6kl_wmi_set_rssi_filter_cmd ( ar -> wmi , vif -> fw_vif_idx , rssi_thold ) ; if ( ret ) { ath6kl_err ( "failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>RSSI<S2SV_blank>threshold<S2SV_blank>for<S2SV_blank>scan\\n" ) ; return ret ; } } interval = max_t ( u16 , 1 , request -> interval / 1000 ) ; ath6kl_wmi_scanparams_cmd ( ar -> wmi , vif -> fw_vif_idx , interval , interval , 10 , 0 , 0 , 0 , 3 , 0 , 0 , 0 ) ; ret = ath6kl_wmi_set_wow_mode_cmd ( ar -> wmi , vif -> fw_vif_idx , ATH6KL_WOW_MODE_ENABLE , WOW_FILTER_SSID , WOW_HOST_REQ_DELAY ) ; if ( ret ) { ath6kl_warn ( "Failed<S2SV_blank>to<S2SV_blank>enable<S2SV_blank>wow<S2SV_blank>with<S2SV_blank>ssid<S2SV_blank>filter:<S2SV_blank>%d\\n" , ret ) ; return ret ; } ret = ath6kl_wmi_set_appie_cmd ( ar -> wmi , vif -> fw_vif_idx , WMI_FRAME_PROBE_REQ , request -> ie , request -> ie_len ) ; if ( ret ) { ath6kl_warn ( "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>probe<S2SV_blank>request<S2SV_blank>IE<S2SV_blank>for<S2SV_blank>scheduled<S2SV_blank>scan:<S2SV_blank>%d" , ret ) ; return ret ; } ret = ath6kl_wmi_set_host_sleep_mode_cmd ( ar -> wmi , vif -> fw_vif_idx , ATH6KL_HOST_MODE_ASLEEP ) ; if ( ret ) { ath6kl_warn ( "Failed<S2SV_blank>to<S2SV_blank>enable<S2SV_blank>host<S2SV_blank>sleep<S2SV_blank>mode<S2SV_blank>for<S2SV_blank>sched<S2SV_blank>scan:<S2SV_blank>%d\\n" , ret ) ; return ret ; } ar -> state = ATH6KL_STATE_SCHED_SCAN ; return ret ; } | <S2SV_ModStart> , rssi_thold ; int n_match_sets = request -> n_match_sets ; if ( n_match_sets == 1 && ! request -> match_sets [ 0 ] . ssid . ssid_len ) n_match_sets = 0 ; <S2SV_ModStart> -> match_sets , <S2SV_ModEnd> n_match_sets ) ; <S2SV_ModStart> if ( ! <S2SV_ModEnd> n_match_sets ) { <S2SV_ModStart> ( request -> min_rssi_thold <S2SV_ModEnd> <= NL80211_SCAN_RSSI_THOLD_OFF ) <S2SV_ModStart> ( request -> min_rssi_thold <S2SV_ModEnd> < - 127 <S2SV_ModStart> = request -> min_rssi_thold <S2SV_ModEnd> ; ret = |
1,945 | CWE-000 static int its_vpe_irq_domain_activate ( struct irq_domain * domain , struct irq_data * d , bool early ) { struct its_vpe * vpe = irq_data_get_irq_chip_data ( d ) ; struct its_node * its ; if ( its_list_map ) <S2SV_StartBug> return true ; <S2SV_EndBug> vpe -> col_idx = cpumask_first ( cpu_online_mask ) ; list_for_each_entry ( its , & its_nodes , entry ) { if ( ! its -> is_v4 ) continue ; its_send_vmapp ( its , vpe , true ) ; its_send_vinvall ( its , vpe ) ; } irq_data_update_effective_affinity ( d , cpumask_of ( vpe -> col_idx ) ) ; return 0 ; } | <S2SV_ModStart> its_list_map ) return 0 <S2SV_ModEnd> ; vpe -> |
1,946 | CWE-000 <S2SV_StartBug> void add_array_row ( t_parse * meta , char * * argv ) <S2SV_EndBug> { char * * * db ; char * * * new ; <S2SV_StartBug> if ( ( access ( argv [ 2 ] , F_OK ) ) != - 1 ) <S2SV_EndBug> { ft_printf ( "[.green.Add<S2SV_blank>Row.]<S2SV_blank>-<S2SV_blank>" ) ; <S2SV_StartBug> if ( argv [ 3 ] ) <S2SV_EndBug> { <S2SV_StartBug> ft_printf ( "[.green.%s.]\\n" , argv [ 3 ] ) ; <S2SV_EndBug> <S2SV_StartBug> db = get_db ( meta , argv [ 2 ] ) ; <S2SV_EndBug> <S2SV_StartBug> new = add_row ( meta , db , argv [ 3 ] ) ; <S2SV_EndBug> meta -> rows ++ ; if ( meta -> opt_l == 1 ) <S2SV_StartBug> display_db ( meta , new , argv [ 2 ] ) ; <S2SV_EndBug> <S2SV_StartBug> update_db ( meta , new , argv [ 2 ] ) ; <S2SV_EndBug> delete_db ( db ) ; delete_db ( new ) ; } else ft_printf ( "[.red.Need<S2SV_blank>argument.]\\n" ) ; } else ft_printf ( "[.red.File<S2SV_blank>error.]\\n" ) ; } | <S2SV_ModStart> , char * source , char * content <S2SV_ModEnd> ) { char <S2SV_ModStart> ( access ( source <S2SV_ModEnd> , F_OK ) <S2SV_ModStart> ; if ( content <S2SV_ModEnd> ) { ft_printf <S2SV_ModStart> ( "[.green.%s.]\\n" , content <S2SV_ModEnd> ) ; db <S2SV_ModStart> ( meta , source <S2SV_ModEnd> ) ; new <S2SV_ModStart> , db , content <S2SV_ModEnd> ) ; meta <S2SV_ModStart> , new , source <S2SV_ModEnd> ) ; update_db <S2SV_ModStart> , new , source <S2SV_ModEnd> ) ; delete_db |
1,947 | CWE-000 void gp_debug_time_printf ( const char * format , ... ) { va_list varargs ; <S2SV_StartBug> fprintf ( stderr , "%s" , gp_debug_timestamp ( ) ) ; <S2SV_EndBug> va_start ( varargs , format ) ; vfprintf ( stderr , format , varargs ) ; va_end ( varargs ) ; } | <S2SV_ModStart> ( stderr , "%s%s" , gp_debug_conn_id ( ) <S2SV_ModEnd> , gp_debug_timestamp ( |
1,948 | CWE-000 int do_fork ( uint32_t clone_flags , uintptr_t stack , struct trapframe * tf ) { int ret = - E_NO_FREE_PROC ; struct proc_struct * proc ; if ( nr_process >= MAX_PROCESS ) { goto fork_out ; } ret = - E_NO_MEM ; proc = alloc_proc ( ) ; if ( proc == NULL ) { cprintf ( "Failed<S2SV_blank>to<S2SV_blank>alloc<S2SV_blank>process\\n" ) ; return NULL ; } assert ( current -> wait_state == 0 ) ; proc -> parent = current ; if ( setup_kstack ( proc ) ) { cprintf ( "Failed<S2SV_blank>to<S2SV_blank>setup<S2SV_blank>kstack\\n" ) ; goto bad_fork_cleanup_kstack ; } if ( copy_mm ( clone_flags , proc ) ) { cprintf ( "Failed<S2SV_blank>to<S2SV_blank>copy<S2SV_blank>mm\\n" ) ; } copy_thread ( proc , stack , tf ) ; <S2SV_StartBug> proc -> pid = get_pid ( ) ; <S2SV_EndBug> hash_proc ( proc ) ; <S2SV_StartBug> list_add ( & proc_list , & proc -> list_link ) ; <S2SV_EndBug> nr_process ++ ; set_links ( proc ) ; wakeup_proc ( proc ) ; ret = proc -> pid ; fork_out : return ret ; bad_fork_cleanup_kstack : put_kstack ( proc ) ; bad_fork_cleanup_proc : kfree ( proc ) ; goto fork_out ; } | <S2SV_ModStart> tf ) ; bool intr_flag ; local_intr_save ( intr_flag ) ; { <S2SV_ModStart> proc ) ; } local_intr_restore ( intr_flag ) <S2SV_ModEnd> ; set_links ( |
1,949 | CWE-000 void up_wlan_init ( struct netif * dev ) { <S2SV_StartBug> struct ip_addr ipaddr ; <S2SV_EndBug> <S2SV_StartBug> struct ip_addr netmask ; <S2SV_EndBug> <S2SV_StartBug> struct ip_addr gw ; <S2SV_EndBug> ipaddr . addr = inet_addr ( "0.0.0.0" ) ; netmask . addr = inet_addr ( "255.255.255.255" ) ; gw . addr = inet_addr ( "0.0.0.0" ) ; netif_set_default ( dev ) ; wlan_netif = netif_add ( dev , & ipaddr , & netmask , & gw , NULL , wlan_init , tcpip_input ) ; } | <S2SV_ModStart> ) { struct ip4_addr <S2SV_ModEnd> ipaddr ; struct <S2SV_ModStart> ipaddr ; struct ip4_addr <S2SV_ModEnd> netmask ; struct <S2SV_ModStart> netmask ; struct ip4_addr <S2SV_ModEnd> gw ; ipaddr |
1,950 | CWE-000 int collect_user_ns ( struct ns_id * ns , void * oarg ) { <S2SV_StartBug> int status , stack_size ; <S2SV_EndBug> struct ns_id * p_ns ; <S2SV_StartBug> pid_t pid = - 1 ; <S2SV_EndBug> <S2SV_StartBug> UsernsEntry * e ; <S2SV_EndBug> char * stack ; p_ns = ns -> parent ; e = xmalloc ( sizeof ( * e ) ) ; if ( ! e ) return - 1 ; userns_entry__init ( e ) ; ns -> user . e = e ; if ( ns -> type == NS_ROOT ) { userns_entry = e ; root_user_ns = ns ; } if ( p_ns ) { <S2SV_StartBug> stack_size = 2 * 1024 * 1024 ; <S2SV_EndBug> stack = mmap ( NULL , stack_size , PROT_WRITE | PROT_READ , MAP_ANONYMOUS | MAP_PRIVATE , - 1 , 0 ) ; if ( stack == MAP_FAILED ) { pr_perror ( "Can\'t<S2SV_blank>allocate<S2SV_blank>stack" ) ; return - 1 ; } <S2SV_StartBug> pid = clone ( dump_user_ns , stack + stack_size , CLONE_VM | CLONE_FILES | SIGCHLD , ns ) ; <S2SV_EndBug> if ( pid == - 1 ) { pr_perror ( "Can\'t<S2SV_blank>clone" ) ; return - 1 ; } if ( waitpid ( pid , & status , 0 ) != pid ) { pr_perror ( "Unable<S2SV_blank>to<S2SV_blank>wait<S2SV_blank>the<S2SV_blank>%d<S2SV_blank>process" , pid ) ; return - 1 ; } if ( ! WIFEXITED ( status ) || WEXITSTATUS ( status ) ) { pr_err ( "Can\'t<S2SV_blank>dump<S2SV_blank>nested<S2SV_blank>user_ns:<S2SV_blank>%x\\n" , status ) ; return - 1 ; } munmap ( stack , stack_size ) ; return 0 ; } else { if ( __dump_user_ns ( ns ) ) return - 1 ; } return 0 ; } | <S2SV_ModStart> oarg ) { <S2SV_ModEnd> struct ns_id * <S2SV_ModStart> * p_ns ; <S2SV_ModEnd> UsernsEntry * e <S2SV_ModStart> UsernsEntry * e <S2SV_ModEnd> ; p_ns = <S2SV_ModStart> p_ns ) { return call_in_child_process <S2SV_ModEnd> ( dump_user_ns , <S2SV_ModStart> ( dump_user_ns , ns ) <S2SV_ModEnd> ; } else |
1,951 | CWE-000 struct mux_control * mux_control_get ( struct device * dev , const char * mux_name ) { struct device_node * np = dev -> of_node ; struct of_phandle_args args ; struct mux_chip * mux_chip ; unsigned int controller ; int index = 0 ; int ret ; if ( mux_name ) { index = of_property_match_string ( np , "mux-control-names" , mux_name ) ; if ( index < 0 ) { dev_err ( dev , "mux<S2SV_blank>controller<S2SV_blank>\'%s\'<S2SV_blank>not<S2SV_blank>found\\n" , mux_name ) ; return ERR_PTR ( index ) ; } } ret = of_parse_phandle_with_args ( np , "mux-controls" , "#mux-control-cells" , index , & args ) ; if ( ret ) { dev_err ( dev , "%pOF:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>mux-control<S2SV_blank>%s(%i)\\n" , np , mux_name ? : "" , index ) ; return ERR_PTR ( ret ) ; } mux_chip = of_find_mux_chip_by_node ( args . np ) ; of_node_put ( args . np ) ; if ( ! mux_chip ) return ERR_PTR ( - EPROBE_DEFER ) ; if ( args . args_count > 1 || ( ! args . args_count && ( mux_chip -> controllers > 1 ) ) ) { dev_err ( dev , "%pOF:<S2SV_blank>wrong<S2SV_blank>#mux-control-cells<S2SV_blank>for<S2SV_blank>%pOF\\n" , np , args . np ) ; <S2SV_StartBug> return ERR_PTR ( - EINVAL ) ; <S2SV_EndBug> } controller = 0 ; if ( args . args_count ) controller = args . args [ 0 ] ; if ( controller >= mux_chip -> controllers ) { dev_err ( dev , "%pOF:<S2SV_blank>bad<S2SV_blank>mux<S2SV_blank>controller<S2SV_blank>%u<S2SV_blank>specified<S2SV_blank>in<S2SV_blank>%pOF\\n" , np , controller , args . np ) ; <S2SV_StartBug> return ERR_PTR ( - EINVAL ) ; <S2SV_EndBug> } <S2SV_StartBug> get_device ( & mux_chip -> dev ) ; <S2SV_EndBug> return & mux_chip -> mux [ controller ] ; } | <S2SV_ModStart> np ) ; put_device ( & mux_chip -> dev ) ; <S2SV_ModStart> np ) ; put_device ( & mux_chip -> dev ) ; <S2SV_ModStart> ) ; } <S2SV_ModEnd> return & mux_chip |
1,952 | CWE-000 static int sctp_send_asconf_del_ip ( struct sock * sk , struct sockaddr * addrs , int addrcnt ) { struct net * net = sock_net ( sk ) ; struct sctp_sock * sp ; struct sctp_endpoint * ep ; struct sctp_association * asoc ; struct sctp_transport * transport ; struct sctp_bind_addr * bp ; struct sctp_chunk * chunk ; union sctp_addr * laddr ; void * addr_buf ; struct sctp_af * af ; struct sctp_sockaddr_entry * saddr ; int i ; int retval = 0 ; int stored = 0 ; chunk = NULL ; if ( ! net -> sctp . addip_enable ) return retval ; sp = sctp_sk ( sk ) ; ep = sp -> ep ; SCTP_DEBUG_PRINTK ( "%s:<S2SV_blank>(sk:<S2SV_blank>%p,<S2SV_blank>addrs:<S2SV_blank>%p,<S2SV_blank>addrcnt:<S2SV_blank>%d)\\n" , __func__ , sk , addrs , addrcnt ) ; list_for_each_entry ( asoc , & ep -> asocs , asocs ) { if ( ! asoc -> peer . asconf_capable ) continue ; if ( asoc -> peer . addip_disabled_mask & SCTP_PARAM_DEL_IP ) continue ; if ( ! sctp_state ( asoc , ESTABLISHED ) ) continue ; addr_buf = addrs ; for ( i = 0 ; i < addrcnt ; i ++ ) { laddr = addr_buf ; af = sctp_get_af_specific ( laddr -> v4 . sin_family ) ; if ( ! af ) { retval = - EINVAL ; goto out ; } if ( ! sctp_assoc_lookup_laddr ( asoc , laddr ) ) break ; addr_buf += af -> sockaddr_len ; } if ( i < addrcnt ) continue ; bp = & asoc -> base . bind_addr ; laddr = sctp_find_unmatch_addr ( bp , ( union sctp_addr * ) addrs , addrcnt , sp ) ; if ( ( laddr == NULL ) && ( addrcnt == 1 ) ) { if ( asoc -> asconf_addr_del_pending ) continue ; asoc -> asconf_addr_del_pending = kzalloc ( sizeof ( union sctp_addr ) , GFP_ATOMIC ) ; if ( asoc -> asconf_addr_del_pending == NULL ) { retval = - ENOMEM ; goto out ; } asoc -> asconf_addr_del_pending -> sa . sa_family = addrs -> sa_family ; asoc -> asconf_addr_del_pending -> v4 . sin_port = htons ( bp -> port ) ; if ( addrs -> sa_family == AF_INET ) { struct sockaddr_in * sin ; sin = ( struct sockaddr_in * ) addrs ; asoc -> asconf_addr_del_pending -> v4 . sin_addr . s_addr = sin -> sin_addr . s_addr ; } else if ( addrs -> sa_family == AF_INET6 ) { struct sockaddr_in6 * sin6 ; sin6 = ( struct sockaddr_in6 * ) addrs ; asoc -> asconf_addr_del_pending -> v6 . sin6_addr = sin6 -> sin6_addr ; } SCTP_DEBUG_PRINTK_IPADDR ( "send_asconf_del_ip:<S2SV_blank>keep<S2SV_blank>the<S2SV_blank>last<S2SV_blank>address<S2SV_blank>asoc:<S2SV_blank>%p<S2SV_blank>" , "<S2SV_blank>at<S2SV_blank>%p\\n" , asoc , asoc -> asconf_addr_del_pending , asoc -> asconf_addr_del_pending ) ; asoc -> src_out_of_asoc_ok = 1 ; stored = 1 ; goto skip_mkasconf ; } <S2SV_StartBug> chunk = sctp_make_asconf_update_ip ( asoc , laddr , addrs , addrcnt , <S2SV_EndBug> SCTP_PARAM_DEL_IP ) ; if ( ! chunk ) { retval = - ENOMEM ; goto out ; } skip_mkasconf : addr_buf = addrs ; for ( i = 0 ; i < addrcnt ; i ++ ) { laddr = addr_buf ; af = sctp_get_af_specific ( laddr -> v4 . sin_family ) ; list_for_each_entry ( saddr , & bp -> address_list , list ) { if ( sctp_cmp_addr_exact ( & saddr -> a , laddr ) ) saddr -> state = SCTP_ADDR_DEL ; } addr_buf += af -> sockaddr_len ; } list_for_each_entry ( transport , & asoc -> peer . transport_addr_list , transports ) { dst_release ( transport -> dst ) ; sctp_transport_route ( transport , NULL , sctp_sk ( asoc -> base . sk ) ) ; } if ( stored ) continue ; retval = sctp_send_asconf ( asoc , chunk ) ; } out : return retval ; } | <S2SV_ModStart> skip_mkasconf ; } if ( laddr == NULL ) return - EINVAL ; |
1,953 | CWE-000 char parse_command ( char * in1 ) { unsigned int len , i ; char * ptr = in1 ; len = * ( ptr ++ ) - 32 ; if ( strlen ( in1 ) != len ) { printf ( "packet[0]<S2SV_blank>len<S2SV_blank>is<S2SV_blank>%d,<S2SV_blank>but<S2SV_blank>in<S2SV_blank>fact<S2SV_blank>len<S2SV_blank>is<S2SV_blank>%d\\r\\n" , len , strlen ( in1 ) ) ; return - 1 ; } if ( * ( ptr ) == 'S' && * ( ptr + 1 ) == 'Z' ) { ptr += 2 ; if ( * ( ptr ++ ) == SEND_DIRECTION_OPTION_FLAG ) { switch ( * ( ptr ++ ) ) { case SEND_DIRECTION_P2P : if ( ( * ptr ) >= 'a' && ( * ptr ) <= 'z' ) cmd_send_msg . dest = ( 0x01 << 8 | ( * ptr ) - 'a' ) ; else { printf ( "error<S2SV_blank>dst<S2SV_blank>number,<S2SV_blank>drop.\\r\\n" ) ; return - 1 ; } break ; case SEND_DIRECTION_BOARDCAST : cmd_send_msg . dest = 0xff ; break ; default : printf ( "error<S2SV_blank>dst<S2SV_blank>number,<S2SV_blank>drop.\\r\\n" ) ; return - 1 ; } ptr += 2 ; for ( i = 0 ; i < len - 7 ; ++ i ) { <S2SV_StartBug> cmd_send_msg . msg [ i ] = * ( ptr + i ) ; <S2SV_EndBug> } cmd_send_msg . msg [ i ] = 0 ; } else { printf ( "no<S2SV_blank>dst<S2SV_blank>flag,<S2SV_blank>drop.\\r\\n" ) ; return - 1 ; } return CMD_SEND_MSG ; } else if ( * ( ptr ) == 'Z' && * ( ptr + 1 ) == 'T' ) { printf ( "uploading<S2SV_blank>route<S2SV_blank>table.\\r\\n" ) ; return CMD_REQUEST_ROUTETABLE ; } else if ( * ( ptr ) == 'S' && * ( ptr + 1 ) == 'C' ) { printf ( "uploading<S2SV_blank>self<S2SV_blank>check<S2SV_blank>status\\r\\n" ) ; return CMD_SELF_CHECK ; } else if ( * ( ptr ) == 'T' && * ( ptr + 1 ) == 'N' ) { return CMD_SEND_TEST ; } else { printf ( "invalid<S2SV_blank>command<S2SV_blank>from<S2SV_blank>PC,<S2SV_blank>drop.\\r\\n" ) ; return - 1 ; } } | <S2SV_ModStart> i ] = ( * ( ptr + i ) == '\\\\' ) ? ( '<S2SV_blank>' ) : ( * ( ptr + i ) <S2SV_ModEnd> ) ; } |
1,954 | CWE-000 static void load_config ( ) { char cfg_fmt [ ] = "serverhost=%s\\n" "serverport=%d\\n" "port_vrecv=%d\\n" "port_vrecv_c=%d\\n" "port_arecv=%d\\n" "port_arecv_c=%d\\n" "port_vsend=%d\\n" "port_vsend_c=%d\\n" "port_asend=%d\\n" "port_asend_c=%d\\n" "port_toserver=%d\\n" ; <S2SV_StartBug> char * cfg_dir = ".dsshare" ; <S2SV_EndBug> char * cfg_name = "dsconfig" ; char * cfg_path , * home_path ; char buf [ BUFSIZ ] , * cfg_str ; int fd ; FILE * file ; DIR * dp ; size_t n , sn = 0 , size = 0 ; struct stat cfg_stat ; home_path = getpwuid ( getuid ( ) ) -> pw_dir ; cfg_path = malloc ( strlen ( home_path ) + strlen ( cfg_dir ) + strlen ( cfg_name ) + 3 ) ; if ( ! cfg_path ) { perror ( "malloc" ) ; exit ( EXIT_FAILURE ) ; } strcpy ( cfg_path , home_path ) ; strcat ( cfg_path , DELIMITER ) ; strcat ( cfg_path , cfg_dir ) ; if ( ! ( dp = opendir ( cfg_path ) ) && errno == ENOENT && mkdir ( cfg_path , RWXRWXRX ) ) { perror ( "mkdir" ) ; fprintf ( stderr , "use<S2SV_blank>default<S2SV_blank>config\\n" ) ; default_config ( ) ; free ( cfg_path ) ; return ; } strcat ( cfg_path , DELIMITER ) ; strcat ( cfg_path , cfg_name ) ; fd = open ( cfg_path , O_RDWR | O_CREAT , RWRWR ) ; fstat ( fd , & cfg_stat ) ; if ( cfg_stat . st_size == 0 ) { file = fdopen ( fd , "r+" ) ; fprintf ( file , cfg_fmt , DEFAULT_SERVER_HOST , DEFAULT_SERVER_PORT , DEFAULT_VRECV , DEFAULT_VRECV_C , DEFAULT_ARECV , DEFAULT_ARECV_C , DEFAULT_VSEND , DEFAULT_VSEND_C , DEFAULT_ASEND , <S2SV_StartBug> DEFAULT_ARECV_C , DEFAULT_TOSERVER ) ; <S2SV_EndBug> default_config ( ) ; free ( cfg_path ) ; fclose ( file ) ; closedir ( dp ) ; return ; } while ( ( n = read ( fd , buf , BUFSIZ ) ) > 0 ) { if ( sn + n > size ) { <S2SV_StartBug> if ( ( cfg_str = realloc ( cfg_str , size + BUFSIZ ) ) ) { <S2SV_EndBug> perror ( "realloc" ) ; exit ( EXIT_FAILURE ) ; } size += BUFSIZ ; } memmove ( cfg_str + sn , buf , n ) ; sn += n ; } if ( ! serverhost && ! ( serverhost = malloc ( NI_MAXHOST ) ) ) { perror ( "malloc" ) ; exit ( EXIT_FAILURE ) ; } n = sscanf ( cfg_str , cfg_fmt , serverhost , & serverport , & port_vrecv , & port_vrecv_c , & port_arecv , & port_arecv_c , & port_vsend , & port_vsend_c , & port_asend , & port_asend_c , & port_toserver ) ; if ( n != CFG_NUM ) { fprintf ( stderr , "wrong<S2SV_blank>config<S2SV_blank>file<S2SV_blank>format,<S2SV_blank>use<S2SV_blank>default\\n" ) ; default_config ( ) ; free ( cfg_path ) ; free ( cfg_str ) ; close ( fd ) ; closedir ( dp ) ; return ; } free ( cfg_path ) ; free ( cfg_str ) ; close ( fd ) ; closedir ( dp ) ; } | <S2SV_ModStart> * cfg_dir = ".deskshare" <S2SV_ModEnd> ; char * <S2SV_ModStart> , DEFAULT_ASEND , DEFAULT_ASEND_C <S2SV_ModEnd> , DEFAULT_TOSERVER ) <S2SV_ModStart> { if ( ! |
1,955 | CWE-000 static void on_bus_acquired ( GDBusConnection * connection , const gchar * name , gpointer user_data ) { EosObjectSkeleton * object = NULL ; EosUpdater * updater = NULL ; LocalData * local_data = user_data ; GError * error = NULL ; g_autofree gchar * src = NULL ; g_autofree gchar * ref = NULL ; g_autofree gchar * sum = NULL ; message ( "Acquired<S2SV_blank>a<S2SV_blank>message<S2SV_blank>bus<S2SV_blank>connection" ) ; local_data -> manager = g_dbus_object_manager_server_new ( "/com/endlessm" ) ; object = eos_object_skeleton_new ( "/com/endlessm/Updater" ) ; local_data -> updater = eos_updater_skeleton_new ( ) ; updater = local_data -> updater ; eos_object_skeleton_set_updater ( object , updater ) ; sum = eos_updater_get_booted_checksum ( & error ) ; if ( sum != NULL ) { eos_updater_set_current_id ( updater , sum ) ; eos_updater_set_download_size ( updater , 0 ) ; eos_updater_set_downloaded_bytes ( updater , 0 ) ; eos_updater_set_unpacked_size ( updater , 0 ) ; eos_updater_set_update_id ( updater , "" ) ; eos_updater_clear_error ( updater , EOS_UPDATER_STATE_READY ) ; } else if ( g_error_matches ( error , G_IO_ERROR , G_IO_ERROR_NOT_FOUND ) ) { g_clear_error ( & error ) ; g_set_error ( & error , EOS_UPDATER_ERROR , EOS_UPDATER_ERROR_NOT_OSTREE_SYSTEM , "Not<S2SV_blank>an<S2SV_blank>OSTree-based<S2SV_blank>system:<S2SV_blank>cannot<S2SV_blank>update<S2SV_blank>it." ) ; eos_updater_set_error ( updater , error ) ; g_clear_error ( & error ) ; } else { eos_updater_set_error ( updater , error ) ; g_clear_error ( & error ) ; } if ( ! is_installed_system ( & error ) ) { g_signal_connect ( updater , "handle-fetch" , G_CALLBACK ( handle_on_live_boot ) , local_data -> data ) ; g_signal_connect ( updater , "handle-poll" , G_CALLBACK ( handle_on_live_boot ) , local_data -> data ) ; <S2SV_StartBug> g_signal_connect ( updater , "handle-apply" , G_CALLBACK ( handle_on_live_boot ) , local_data -> data ) ; <S2SV_EndBug> eos_updater_set_error ( updater , error ) ; g_clear_error ( & error ) ; } else { g_signal_connect ( updater , "handle-fetch" , G_CALLBACK ( handle_fetch ) , local_data -> data ) ; g_signal_connect ( updater , "handle-poll" , G_CALLBACK ( handle_poll ) , local_data -> data ) ; <S2SV_StartBug> g_signal_connect ( updater , "handle-apply" , G_CALLBACK ( handle_apply ) , local_data -> data ) ; <S2SV_EndBug> } g_dbus_object_manager_server_export ( local_data -> manager , G_DBUS_OBJECT_SKELETON ( object ) ) ; g_object_unref ( object ) ; message ( "Exporting<S2SV_blank>objects" ) ; g_dbus_object_manager_server_set_connection ( local_data -> manager , connection ) ; } | <S2SV_ModStart> ( updater , "handle-poll-volume" , G_CALLBACK ( handle_on_live_boot ) , local_data -> data ) ; g_signal_connect ( updater , <S2SV_ModStart> ( updater , "handle-poll-volume" , G_CALLBACK ( handle_poll_volume ) , local_data -> data ) ; g_signal_connect ( updater , |
1,956 | CWE-000 char * substring ( char * str , int start , int length ) { char * substring = malloc ( length + 1 ) ; int subPos ; if ( substring == NULL ) { <S2SV_StartBug> printf ( "str<S2SV_blank>in<S2SV_blank>substring<S2SV_blank>method<S2SV_blank>is<S2SV_blank>NULL.\\n" ) ; <S2SV_EndBug> <S2SV_StartBug> delay ( 100 ) ; <S2SV_EndBug> exit ( 1 ) ; } for ( subPos = 0 ; subPos < length ; subPos ++ ) { * ( substring + subPos ) = * ( str + start - 1 ) ; str ++ ; } * ( substring + subPos ) = '\\0' ; return substring ; } | <S2SV_ModStart> NULL ) { # if ( DEBUG_MODE == 1 ) <S2SV_ModStart> 100 ) ; # endif |
1,957 | CWE-000 void gtk_entry_set_icon_from_icon_name ( GtkEntry * entry , GtkEntryIconPosition icon_pos , const gchar * icon_name ) { GtkEntryPrivate * priv ; EntryIconInfo * icon_info ; g_return_if_fail ( GTK_IS_ENTRY ( entry ) ) ; g_return_if_fail ( IS_VALID_ICON_POSITION ( icon_pos ) ) ; priv = entry -> priv ; if ( ( icon_info = priv -> icons [ icon_pos ] ) == NULL ) icon_info = construct_icon_info ( GTK_WIDGET ( entry ) , icon_pos ) ; g_object_freeze_notify ( G_OBJECT ( entry ) ) ; if ( icon_name != NULL ) { _gtk_icon_helper_set_icon_name ( GTK_ICON_HELPER ( icon_info -> gadget ) , icon_name , GTK_ICON_SIZE_MENU ) ; if ( icon_pos == GTK_ENTRY_ICON_PRIMARY ) { g_object_notify_by_pspec ( G_OBJECT ( entry ) , entry_props [ PROP_ICON_NAME_PRIMARY ] ) ; g_object_notify_by_pspec ( G_OBJECT ( entry ) , entry_props [ PROP_STORAGE_TYPE_PRIMARY ] ) ; } else { g_object_notify_by_pspec ( G_OBJECT ( entry ) , entry_props [ PROP_ICON_NAME_SECONDARY ] ) ; g_object_notify_by_pspec ( G_OBJECT ( entry ) , entry_props [ PROP_STORAGE_TYPE_SECONDARY ] ) ; } if ( gtk_widget_get_mapped ( GTK_WIDGET ( entry ) ) ) gdk_window_show_unraised ( icon_info -> window ) ; } else gtk_entry_clear_icon ( entry , icon_pos ) ; if ( gtk_widget_get_visible ( GTK_WIDGET ( entry ) ) ) <S2SV_StartBug> gtk_widget_queue_resize ( GTK_WIDGET ( entry ) ) ; <S2SV_EndBug> g_object_thaw_notify ( G_OBJECT ( entry ) ) ; } | <S2SV_ModStart> ) ) ) gtk_widget_queue_allocate <S2SV_ModEnd> ( GTK_WIDGET ( |
1,958 | CWE-000 <S2SV_StartBug> void init_crypto_stuctures ( int print ) <S2SV_EndBug> { if ( print ) printf ( "Initializing<S2SV_blank>crypto<S2SV_blank>structures.\\n" ) ; EVP_CIPHER_CTX_init ( & aes_ctx ) ; # if mac_algorithm == 1 EVP_EncryptInit_ex ( & aes_ctx , EVP_aes_128_ecb ( ) , NULL , aes_key , NULL ) ; EVP_CIPHER_CTX_set_padding ( & aes_ctx , 0 ) ; BN_init ( & bn_a ) ; BN_init ( & bn_b ) ; BN_init ( & bn_temp ) ; BN_init ( & bn_useful_data ) ; BN_init ( & bn_mac ) ; BN_dec2bn ( & bn_2power128 , str_2power128 ) ; bn_ctx = BN_CTX_new ( ) ; # endif AES_set_encrypt_key ( aes_key , 128 , & aes_enc_key ) ; # if mac_algorithm == 2 cmac_ctx = CMAC_CTX_new ( ) ; CMAC_Init ( cmac_ctx , aes_key , 16 , EVP_aes_128_cbc ( ) , NULL ) ; # endif # if mac_algorithm == 3 || mac_algorithm == 4 EVP_EncryptInit_ex ( & aes_ctx , EVP_aes_128_cbc ( ) , NULL , aes_key , initialization_vector ) ; # if mac_algorithm == 4 EVP_CIPHER_CTX_set_padding ( & aes_ctx , 0 ) ; # endif # endif memset ( mac_in_bytes , 0 , safe_length_for_buffer_storage ) ; memset ( encrypted_data , 0 , safe_length_for_buffer_storage ) ; memset ( intermediate_buf_for_macing , 0 , safe_length_for_buffer_storage ) ; if ( number_of_mac_bytes > 0 ) { memset ( mac_to_be_verified , 99 , number_of_mac_bytes ) ; if ( num_of_cached_blocks_of_code > 0 ) { init_code_cache ( ) ; } if ( num_of_cached_blocks_of_data > 0 ) { init_data_cache ( ) ; } } # if count_mac_invocations == 1 int i ; for ( i = 0 ; i < 1024 ; i ++ ) mac_size_invocation_counters [ i ] = 0 ; count_mac_invocations_in_this_code_part = 0 ; # endif <S2SV_StartBug> if ( use_code_cache_with_unsplit_blocks ) <S2SV_EndBug> { unsplit_block_addr_file = fopen ( "./addresses_of_unsplit_blocks.txt" , "r" ) ; if ( unsplit_block_addr_file == NULL ) { fprintf ( stderr , "!!!!!!!!!!!!!!!!File<S2SV_blank>addresses_of_unsplit_blocks.txt<S2SV_blank>not<S2SV_blank>found!!!!!!!!!!!!!!!!!!!!!!\\n" ) ; } else { num_of_addresses_of_unsplit_blocks = 0 ; while ( ! feof ( unsplit_block_addr_file ) ) { int scanf_retval = fscanf ( unsplit_block_addr_file , "%ld" , & addresses_of_unsplit_blocks [ num_of_addresses_of_unsplit_blocks ] ) ; if ( scanf_retval > 0 ) num_of_addresses_of_unsplit_blocks ++ ; } find_addr_of_first_block_of_code ( ) ; } } if ( print ) printf ( "Crypto<S2SV_blank>structures<S2SV_blank>initialized.\\n" ) ; } | <S2SV_ModStart> ( int print , int find_addr_of_first_code_block <S2SV_ModStart> if ( use_code_cache_with_unsplit_blocks && find_addr_of_first_code_block |
1,959 | CWE-000 void main ( void ) # else int main ( int argc , char * argv [ ] ) # endif { # ifndef ZJS_SNAPSHOT_BUILD char * file_name = NULL ; size_t file_name_len = 0 ; # ifdef ZJS_LINUX_BUILD char * script = NULL ; file_name = argv [ 1 ] ; file_name_len = strlen ( argv [ 1 ] ) ; # elif defined ZJS_ASHELL char * script = NULL ; # else const char * script = NULL ; # endif jerry_value_t code_eval ; u32_t script_len = 0 ; # endif # ifndef ZJS_LINUX_BUILD DBG_PRINT ( "Main<S2SV_blank>Thread<S2SV_blank>ID:<S2SV_blank>%p\\n" , ( void * ) k_current_get ( ) ) ; zjs_loop_init ( ) ; # endif jerry_value_t result ; ZJS_PRINT ( "\\n" ) ; jerry_init ( JERRY_INIT_EMPTY ) ; zjs_modules_init ( ) ; # ifdef BUILD_MODULE_OCF zjs_register_service_routine ( NULL , main_poll_routine ) ; # endif # ifdef ZJS_ASHELL if ( config_mode_detected ( ) ) { ashell_mode = true ; } else { char filename [ MAX_FILENAME_SIZE ] ; if ( fs_get_boot_cfg_filename ( NULL , filename ) == 0 ) { fs_file_t * js_file = fs_open_alloc ( filename , "r" ) ; if ( ! js_file ) { <S2SV_StartBug> ZJS_PRINT ( "\\nFile<S2SV_blank>%s<S2SV_blank>not<S2SV_blank>found<S2SV_blank>on<S2SV_blank>filesystem,<S2SV_blank>\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>please<S2SV_blank>boot<S2SV_blank>into<S2SV_blank>IDE<S2SV_blank>mode,<S2SV_blank>exiting!\\n" , <S2SV_EndBug> filename ) ; goto error ; } script_len = fs_size ( js_file ) ; script = zjs_malloc ( script_len + 1 ) ; ssize_t count = fs_read ( js_file , script , script_len ) ; if ( script_len != count ) { ZJS_PRINT ( "\\nfailed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>JS<S2SV_blank>file\\n" ) ; zjs_free ( script ) ; goto error ; } script [ script_len ] = '\\0' ; ZJS_PRINT ( "JS<S2SV_blank>boot<S2SV_blank>config<S2SV_blank>found,<S2SV_blank>booting<S2SV_blank>JS<S2SV_blank>%s...\\n\\n\\n" , filename ) ; } else { ZJS_PRINT ( "\\nNo<S2SV_blank>JS<S2SV_blank>found,<S2SV_blank>please<S2SV_blank>boot<S2SV_blank>into<S2SV_blank>IDE<S2SV_blank>mode,<S2SV_blank>exiting!\\n" ) ; goto error ; } } # endif # ifndef ZJS_SNAPSHOT_BUILD # ifdef ZJS_LINUX_BUILD if ( argc > 1 ) { if ( process_cmd_line ( argc - 1 , argv + 1 ) == 0 ) { ERR_PRINT ( "command<S2SV_blank>line<S2SV_blank>options<S2SV_blank>error\\n" ) ; goto error ; } if ( zjs_read_script ( argv [ 1 ] , & script , & script_len ) ) { ERR_PRINT ( "could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>script<S2SV_blank>file<S2SV_blank>%s\\n" , argv [ 1 ] ) ; goto error ; } } else # endif { # ifdef ZJS_LINUX_BUILD script = zjs_malloc ( script_len + 1 ) ; memcpy ( script , script_jscode , script_len ) ; script [ script_len ] = '\\0' ; # else # ifndef ZJS_ASHELL script_len = strnlen ( script_jscode , MAX_SCRIPT_SIZE ) ; script = script_jscode ; # endif # endif if ( script_len == MAX_SCRIPT_SIZE ) { ERR_PRINT ( "Script<S2SV_blank>size<S2SV_blank>too<S2SV_blank>large!<S2SV_blank>Increase<S2SV_blank>MAX_SCRIPT_SIZE.\\n" ) ; goto error ; } } # endif # ifdef ZJS_DEBUGGER if ( start_debug_server ) { jerry_debugger_init ( debug_port ) ; } # endif # ifndef ZJS_SNAPSHOT_BUILD code_eval = jerry_parse_named_resource ( ( jerry_char_t * ) file_name , file_name_len , ( jerry_char_t * ) script , script_len , false ) ; if ( jerry_value_has_error_flag ( code_eval ) ) { DBG_PRINT ( "Error<S2SV_blank>parsing<S2SV_blank>JS\\n" ) ; zjs_print_error_message ( code_eval , ZJS_UNDEFINED ) ; goto error ; } # endif # ifdef ZJS_LINUX_BUILD zjs_free_script ( script ) ; # endif # ifdef ZJS_SNAPSHOT_BUILD result = jerry_exec_snapshot ( snapshot_bytecode , snapshot_len , false ) ; # else # ifdef ZJS_DEBUGGER ZJS_PRINT ( "Debugger<S2SV_blank>mode:<S2SV_blank>connect<S2SV_blank>using<S2SV_blank>jerry-client-ws.py\\n" ) ; # endif result = jerry_run ( code_eval ) ; # endif if ( jerry_value_has_error_flag ( result ) ) { DBG_PRINT ( "Error<S2SV_blank>running<S2SV_blank>JS\\n" ) ; zjs_print_error_message ( result , ZJS_UNDEFINED ) ; goto error ; } # ifndef ZJS_LINUX_BUILD # ifndef ZJS_ASHELL <S2SV_StartBug> # ifndef BUILD_MODULE_OCF <S2SV_EndBug> # ifdef BUILD_MODULE_BLE <S2SV_StartBug> if ( bt_enable ( ble_bt_ready ) ) { <S2SV_EndBug> <S2SV_StartBug> ERR_PRINT ( "Failed<S2SV_blank>to<S2SV_blank>enable<S2SV_blank>Bluetooth\\n" ) ; <S2SV_EndBug> goto error ; } # endif # ifdef CONFIG_NET_L2_BT <S2SV_StartBug> if ( bt_enable ( NULL ) ) { <S2SV_EndBug> ERR_PRINT ( "Failed<S2SV_blank>to<S2SV_blank>enable<S2SV_blank>Bluetooth\\n" ) ; goto error ; } ipss_init ( ) ; ipss_advertise ( ) ; net_ble_enabled = 1 ; <S2SV_StartBug> # endif <S2SV_EndBug> # endif # endif # endif # ifndef ZJS_SNAPSHOT_BUILD jerry_release_value ( code_eval ) ; # endif jerry_release_value ( result ) ; # ifdef ZJS_LINUX_BUILD u8_t last_serviced = 1 ; # endif # ifdef ZJS_ASHELL if ( ashell_mode ) { DBG_PRINT ( "Config<S2SV_blank>mode<S2SV_blank>detected,<S2SV_blank>booting<S2SV_blank>into<S2SV_blank>the<S2SV_blank>IDE...\\n\\n\\n" ) ; zjs_ashell_init ( ) ; } # endif while ( 1 ) { # ifdef ZJS_ASHELL if ( ashell_mode ) { zjs_ashell_process ( ) ; } # endif s32_t wait_time = ZJS_TICKS_FOREVER ; u8_t serviced = 0 ; if ( zjs_service_callbacks ( ) ) { serviced = 1 ; } u64_t wait = zjs_service_routines ( ) ; if ( wait != ZJS_TICKS_FOREVER ) { serviced = 1 ; wait_time = ( wait < wait_time ) ? wait : wait_time ; } if ( zjs_service_callbacks ( ) ) { serviced = 1 ; } # ifdef BUILD_MODULE_PROMISE result = jerry_run_all_enqueued_jobs ( ) ; if ( jerry_value_has_error_flag ( result ) ) { DBG_PRINT ( "Error<S2SV_blank>running<S2SV_blank>JS<S2SV_blank>in<S2SV_blank>promise<S2SV_blank>jobqueue\\n" ) ; zjs_print_error_message ( result , ZJS_UNDEFINED ) ; goto error ; } # endif # ifndef ZJS_LINUX_BUILD zjs_loop_block ( wait_time ) ; # endif # ifdef ZJS_LINUX_BUILD if ( ! no_exit ) { if ( last_serviced == 0 && serviced == 0 ) { ZJS_PRINT ( "\\njslinux:<S2SV_blank>no<S2SV_blank>more<S2SV_blank>timers<S2SV_blank>or<S2SV_blank>callbacks<S2SV_blank>found,<S2SV_blank>exiting!\\n" ) ; ZJS_PRINT ( "<S2SV_blank><S2SV_blank><S2SV_blank>*<S2SV_blank>to<S2SV_blank>run<S2SV_blank>your<S2SV_blank>script<S2SV_blank>indefinitely,<S2SV_blank>use<S2SV_blank>--noexit\\n" ) ; ZJS_PRINT ( "<S2SV_blank><S2SV_blank><S2SV_blank>*<S2SV_blank>to<S2SV_blank>run<S2SV_blank>your<S2SV_blank>script<S2SV_blank>for<S2SV_blank>a<S2SV_blank>set<S2SV_blank>timeout,<S2SV_blank>use<S2SV_blank>-t<S2SV_blank><ms>\\n" ) ; return 0 ; } } if ( exit_after != 0 ) { struct timespec now ; clock_gettime ( CLOCK_MONOTONIC , & now ) ; u32_t elapsed = ( 1000 * ( now . tv_sec - exit_timer . tv_sec ) ) + ( ( now . tv_nsec / 1000000 ) - ( exit_timer . tv_nsec / 1000000 ) ) ; if ( elapsed >= exit_after ) { ZJS_PRINT ( "%u<S2SV_blank>milliseconds<S2SV_blank>have<S2SV_blank>passed,<S2SV_blank>exiting!\\n" , ( unsigned int ) elapsed ) ; return 0 ; } } last_serviced = serviced ; # endif } error : # ifdef ZJS_LINUX_BUILD return 1 ; # else return ; # endif } | <S2SV_ModStart> { ZJS_PRINT ( "\\nFile<S2SV_blank>%s<S2SV_blank>not<S2SV_blank>found<S2SV_blank>on<S2SV_blank>filesystem,<S2SV_blank>\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>please<S2SV_blank>boot<S2SV_blank>into<S2SV_blank>IDE<S2SV_blank>mode,<S2SV_blank>exiting!\\n" <S2SV_ModEnd> , filename ) <S2SV_ModStart> ZJS_ASHELL # ifndef CONFIG_NET_APP_AUTO_INIT int err = 0 ; <S2SV_ModEnd> # ifdef BUILD_MODULE_BLE <S2SV_ModStart> # ifdef BUILD_MODULE_BLE err = <S2SV_ModEnd> bt_enable ( ble_bt_ready <S2SV_ModStart> ( ble_bt_ready ) ; # elif CONFIG_NET_L2_BT err = bt_enable ( NULL ) ; # endif if ( err <S2SV_ModStart> { ERR_PRINT ( "Failed<S2SV_blank>to<S2SV_blank>enable<S2SV_blank>Bluetooth,<S2SV_blank>error<S2SV_blank>%d\\n" , err <S2SV_ModEnd> ) ; goto <S2SV_ModStart> # ifdef CONFIG_NET_L2_BT <S2SV_ModEnd> ipss_init ( ) <S2SV_ModStart> = 1 ; <S2SV_ModEnd> # endif # |
1,960 | CWE-000 static int32_t mm_jpeg_check_resolution_change ( mm_jpeg_obj * my_obj , uint32_t work_bufs_need , int32_t curr_width , int32_t curr_height , int32_t prev_width , int32_t prev_height ) { <S2SV_StartBug> int32_t rc = 0 ; <S2SV_EndBug> if ( my_obj -> work_buf_cnt > work_bufs_need ) { CDBG_ERROR ( "%s:<S2SV_blank>%d]<S2SV_blank>Unexpected<S2SV_blank>work<S2SV_blank>buffer<S2SV_blank>count" , __func__ , __LINE__ ) ; return - 1 ; } if ( ( my_obj -> work_buf_cnt == work_bufs_need ) && ( ( curr_width * curr_height ) != ( prev_width * prev_height ) ) ) { CDBG_HIGH ( "%s:<S2SV_blank>%d]<S2SV_blank>curr_width<S2SV_blank>%d<S2SV_blank>curr_height<S2SV_blank>%d<S2SV_blank>prev_width<S2SV_blank>%d<S2SV_blank>prev_height<S2SV_blank>%d" , __func__ , __LINE__ , curr_width , curr_height , prev_width , prev_height ) ; while ( my_obj -> work_buf_cnt ) { my_obj -> work_buf_cnt -- ; buffer_deallocate ( & my_obj -> ionBuffer [ my_obj -> work_buf_cnt ] ) ; } } return 0 ; } | <S2SV_ModStart> prev_height ) { <S2SV_ModEnd> if ( my_obj |
1,961 | CWE-000 <S2SV_StartBug> int main ( int argc , char const * * argv ) <S2SV_EndBug> { pid_t pidInit , pidChild ; int wstatus ; if ( argc <= 1 ) { showHelp ( argv [ 0 ] ) ; return 1 ; } <S2SV_StartBug> if ( geteuid ( ) != 0 ) <S2SV_EndBug> { missingSetuidRoot ( ) ; return 1 ; } <S2SV_StartBug> if ( loadKernelModule ( ) ) <S2SV_EndBug> return 1 ; g_originalUid = getuid ( ) ; g_originalGid = getgid ( ) ; prefix = getenv ( "DPREFIX" ) ; if ( ! prefix ) prefix = defaultPrefixPath ( ) ; if ( ! prefix ) return 1 ; unsetenv ( "DPREFIX" ) ; if ( ! checkPrefixDir ( ) ) setupPrefix ( ) ; checkPrefixOwner ( ) ; int c ; while ( 1 ) { static struct option long_options [ ] = { { "help" , no_argument , 0 , 0 } , { "version" , no_argument , 0 , 0 } , { 0 , 0 , 0 , 0 } } ; int option_index = 0 ; <S2SV_StartBug> c = getopt_long ( argc , ( char * const * ) argv , "" , long_options , & option_index ) ; <S2SV_EndBug> if ( c == - 1 ) { break ; } switch ( c ) { case 0 : if ( strcmp ( long_options [ option_index ] . name , "help" ) == 0 ) { showHelp ( argv [ 0 ] ) ; exit ( EXIT_SUCCESS ) ; } else if ( strcmp ( long_options [ option_index ] . name , "version" ) == 0 ) { showVersion ( argv [ 0 ] ) ; exit ( EXIT_SUCCESS ) ; } break ; case '?' : break ; default : abort ( ) ; } } pidInit = getInitProcess ( ) ; if ( strcmp ( argv [ 1 ] , "shutdown" ) == 0 ) { if ( pidInit == 0 ) { fprintf ( stderr , "Darling<S2SV_blank>container<S2SV_blank>is<S2SV_blank>not<S2SV_blank>running\\n" ) ; return 1 ; } kill ( pidInit , SIGKILL ) ; return 0 ; } if ( pidInit == 0 ) { setupWorkdir ( ) ; pidInit = spawnInitProcess ( ) ; putInitPid ( pidInit ) ; } if ( strcmp ( argv [ 1 ] , "shell" ) != 0 ) { char * path = realpath ( argv [ 1 ] , NULL ) ; char * fullPath ; if ( path == NULL ) { fprintf ( stderr , "Cannot<S2SV_blank>resolve<S2SV_blank>path:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; exit ( 1 ) ; } const char * argv_child [ argc + 1 ] ; argv_child [ 0 ] = SYSTEM_ROOT DYLD_PATH ; fullPath = malloc ( strlen ( SYSTEM_ROOT ) + strlen ( path ) + 1 ) ; strcpy ( fullPath , SYSTEM_ROOT ) ; strcat ( fullPath , path ) ; argv_child [ 1 ] = fullPath ; for ( int i = 2 ; i < argc ; i ++ ) argv_child [ i ] = argv [ i ] ; argv_child [ argc ] = NULL ; pidChild = spawnChild ( pidInit , SYSTEM_ROOT DYLD_PATH , argv_child ) ; free ( path ) ; free ( fullPath ) ; } else { if ( argc > 2 ) { size_t total_len = 0 ; for ( int i = 2 ; i < argc ; i ++ ) total_len += strlen ( argv [ i ] ) ; char buffer [ total_len + argc ] ; char * to = buffer ; for ( int i = 2 ; i < argc ; i ++ ) to = stpcpy ( stpcpy ( to , argv [ i ] ) , "<S2SV_blank>" ) ; * ( to - 1 ) = '\\0' ; pidChild = spawnChild ( pidInit , SYSTEM_ROOT DYLD_PATH , ( const char * [ 5 ] ) { SYSTEM_ROOT DYLD_PATH , "/bin/bash" , "-c" , buffer , NULL } ) ; } else pidChild = spawnChild ( pidInit , SYSTEM_ROOT DYLD_PATH , ( const char * [ 3 ] ) { SYSTEM_ROOT DYLD_PATH , "/bin/bash" , NULL } ) ; } seteuid ( g_originalUid ) ; waitpid ( pidChild , & wstatus , 0 ) ; if ( WIFEXITED ( wstatus ) ) return WEXITSTATUS ( wstatus ) ; if ( WIFSIGNALED ( wstatus ) ) return WTERMSIG ( wstatus ) ; return 0 ; } | <S2SV_ModStart> argc , char * * argv , char * * envp <S2SV_ModEnd> ) { pid_t <S2SV_ModStart> 1 ; } g_argv = argv ; g_envp = envp ; <S2SV_ModStart> 1 ; } g_originalUid = getuid ( ) ; g_originalGid = getgid ( ) ; setuid ( 0 ) ; setgid ( 0 ) ; if ( ! isModuleLoaded ( ) ) loadKernelModule <S2SV_ModEnd> ( ) ; <S2SV_ModStart> ( argc , <S2SV_ModEnd> argv , "" |
1,962 | CWE-000 void CL_ParseStartSoundPacket ( void ) { vec3_t pos ; int channel , ent , sound_num , volume , i ; int tracknum ; float attenuation ; channel = MSG_ReadShort ( ) ; volume = ( channel & SND_VOLUME ) ? MSG_ReadByte ( ) : DEFAULT_SOUND_PACKET_VOLUME ; attenuation = ( channel & SND_ATTENUATION ) ? MSG_ReadByte ( ) / 64.0 : DEFAULT_SOUND_PACKET_ATTENUATION ; sound_num = MSG_ReadByte ( ) ; for ( i = 0 ; i < 3 ; i ++ ) pos [ i ] = MSG_ReadCoord ( ) ; ent = ( channel >> 3 ) & 1023 ; channel &= 7 ; if ( ent > CL_MAX_EDICTS ) Host_Error ( "CL_ParseStartSoundPacket:<S2SV_blank>ent<S2SV_blank>=<S2SV_blank>%i" , ent ) ; if ( cls . mvdplayback ) { tracknum = Cam_TrackNum ( ) ; if ( cl . spectator && tracknum != - 1 && ent == tracknum + 1 && cl_multiview . value < 2 ) { ent = cl . playernum + 1 ; } } <S2SV_StartBug> if ( CL_Demo_SkipMessage ( ) ) <S2SV_EndBug> return ; S_StartSound ( ent , channel , cl . sound_precache [ sound_num ] , pos , volume / 255.0 , attenuation ) ; if ( ent == cl . playernum + 1 ) TP_CheckPickupSound ( cl . sound_name [ sound_num ] , pos ) ; } | <S2SV_ModStart> ( CL_Demo_SkipMessage ( true |
1,963 | CWE-000 uint16_t MEM_If_Write_FS ( uint8_t * src , uint8_t * dest , uint32_t Len ) { uint32_t i = 0 ; if ( dest < ( uint8_t * ) BOOTLOADER_APP_START_ADDRESS ) { return 3 ; } for ( i = 0 ; i < Len ; i += 4 ) { if ( HAL_FLASH_Program ( FLASH_TYPEPROGRAM_WORD , ( uint32_t ) ( dest + i ) , * ( uint32_t * ) ( src + i ) ) == HAL_OK ) { if ( * ( uint32_t * ) ( src + i ) != * ( uint32_t * ) ( dest + i ) ) { return 2 ; } } else { return 1 ; } <S2SV_StartBug> } <S2SV_EndBug> return ( USBD_OK ) ; } | <S2SV_ModStart> 1 ; } HAL_GPIO_TogglePin ( GPIOC , GPIO_PIN_13 ) ; |
1,964 | CWE-000 void bombs ( ushort sig ) { long * procinfo = ( long * ) 0x380L ; int i ; CONTEXT * crash ; if ( sig >= NSIG ) { ALERT ( "bombs(%d):<S2SV_blank>sig<S2SV_blank>out<S2SV_blank>of<S2SV_blank>range" , sig ) ; } else if ( signames [ sig ] ) { # ifdef WITH_MMU_SUPPORT if ( ! no_mem_prot && sig == SIGBUS ) { } else # endif { BASEPAGE * base = curproc -> p_mem -> base ; long ptext = 0 ; long pdata = 0 ; long pbss = 0 ; if ( base ) { ptext = base -> p_tbase ; pdata = base -> p_dbase ; pbss = base -> p_bbase ; } if ( sig == SIGSEGV || sig == SIGBUS ) { ALERT ( "%s:<S2SV_blank>User<S2SV_blank>PC=%lx,<S2SV_blank>Address:<S2SV_blank>%lx<S2SV_blank>(basepage=%lx,<S2SV_blank>text=%lx,<S2SV_blank>data=%lx,<S2SV_blank>bss=%lx)" , signames [ sig ] , curproc -> exception_pc , curproc -> exception_addr , <S2SV_StartBug> base , ptext , pdata , pbss ) ; <S2SV_EndBug> } else { ALERT ( "%s:<S2SV_blank>User<S2SV_blank>PC=%lx<S2SV_blank>(basepage=%lx,<S2SV_blank>text=%lx,<S2SV_blank>data=%lx,<S2SV_blank>bss=%lx)" , signames [ sig ] , curproc -> exception_pc , <S2SV_StartBug> base , ptext , pdata , pbss ) ; <S2SV_EndBug> } } crash = & curproc -> ctxt [ SYSCALL ] ; * procinfo ++ = 0x12345678L ; for ( i = 0 ; i < 15 ; i ++ ) * procinfo ++ = crash -> regs [ i ] ; * procinfo ++ = curproc -> exception_ssp ; * procinfo ++ = ( ( long ) excep_num [ sig ] ) << 24L ; * procinfo = crash -> usp ; } else { TRACE ( ( "bombs(%d)" , sig ) ) ; } } | <S2SV_ModStart> -> exception_addr , ( unsigned long ) <S2SV_ModStart> -> exception_pc , ( unsigned long ) |
1,965 | CWE-000 static void bcmgenet_update_mib_counters ( struct bcmgenet_priv * priv ) { int i , j = 0 ; for ( i = 0 ; i < BCMGENET_STATS_LEN ; i ++ ) { const struct bcmgenet_stats * s ; u8 offset = 0 ; u32 val = 0 ; char * p ; s = & bcmgenet_gstrings_stats [ i ] ; switch ( s -> type ) { case BCMGENET_STAT_NETDEV : case BCMGENET_STAT_SOFT : continue ; case BCMGENET_STAT_MIB_RX : case BCMGENET_STAT_MIB_TX : case BCMGENET_STAT_RUNT : if ( s -> type != BCMGENET_STAT_MIB_RX ) offset = BCMGENET_STAT_OFFSET ; val = bcmgenet_umac_readl ( priv , UMAC_MIB_START + j + offset ) ; break ; case BCMGENET_STAT_MISC : <S2SV_StartBug> val = bcmgenet_umac_readl ( priv , s -> reg_offset ) ; <S2SV_EndBug> if ( val == ~ 0 ) <S2SV_StartBug> bcmgenet_umac_writel ( priv , 0 , s -> reg_offset ) ; <S2SV_EndBug> break ; } j += s -> stat_sizeof ; p = ( char * ) priv + s -> stat_offset ; * ( u32 * ) p = val ; } } | <S2SV_ModStart> case BCMGENET_STAT_MISC : if ( GENET_IS_V1 ( priv ) ) { <S2SV_ModStart> reg_offset ) ; } else { val = bcmgenet_update_stat_misc ( priv , s -> reg_offset ) ; } |
1,966 | CWE-000 int create_packet_sched ( struct trace_packet * packet , struct tcb_s * prev , struct tcb_s * next ) { int ret = TTRACE_VALID ; int msg_len = sizeof ( struct sched_message ) ; <S2SV_StartBug> gettimeofday ( & ( packet -> ts ) ) ; <S2SV_EndBug> packet -> event_type = ( int8_t ) 's' ; packet -> pid = getpid ( ) ; packet -> codelen = TTRACE_CODE_VARIABLE | msg_len ; packet -> pad = - 1 ; packet -> msg . sched_msg . pad = - 1 ; if ( prev != NULL ) { memcpy ( packet -> msg . sched_msg . prev_comm , prev -> name , TTRACE_COMM_BYTES ) ; packet -> msg . sched_msg . prev_pid = prev -> pid ; packet -> msg . sched_msg . prev_prio = prev -> sched_priority ; packet -> msg . sched_msg . prev_state = prev -> task_state ; } else { memcpy ( packet -> msg . sched_msg . prev_comm , "Idle<S2SV_blank>Task" , TTRACE_COMM_BYTES ) ; packet -> msg . sched_msg . prev_pid = 0 ; packet -> msg . sched_msg . prev_prio = 0 ; packet -> msg . sched_msg . prev_state = 3 ; } if ( next != NULL ) { memcpy ( packet -> msg . sched_msg . next_comm , next -> name , TTRACE_COMM_BYTES ) ; packet -> msg . sched_msg . next_pid = next -> pid ; packet -> msg . sched_msg . next_prio = next -> sched_priority ; } else { memcpy ( packet -> msg . sched_msg . next_comm , "Idle<S2SV_blank>Task" , TTRACE_COMM_BYTES ) ; packet -> msg . sched_msg . next_pid = 0 ; packet -> msg . sched_msg . next_prio = 0 ; } return ret ; } | <S2SV_ModStart> -> ts ) , NULL |
1,967 | CWE-000 <S2SV_StartBug> static int dev_cons_write ( vnode_t * t , uio_t * uio ) { <S2SV_EndBug> char buffer [ UART_BUF_MAX ] ; size_t n = uio -> uio_resid ; int res = uiomove ( buffer , UART_BUF_MAX - 1 , uio ) ; if ( res ) return res ; size_t moved = n - uio -> uio_resid ; cn_write ( buffer , moved ) ; return 0 ; } | <S2SV_ModStart> uio ) { ( void ) t ; |
1,968 | CWE-000 void invKine ( HANDJnt ref_jnt_ang , HANDJnt prepare_jnt_ang1 , double time , double stime , double angle , double xm , double ym , double zm , int finger_type ) { double L2 = 0.0365 ; if ( finger_type == MIDDLE_FINGER ) { L2 = 0.0525 ; } double Lw0 = 0.105 ; if ( finger_type == MIDDLE_FINGER ) { Lw0 += 0.03 ; } double Lpr = 0.03 ; double Lpl = - 0.03 ; double Lp = 0.03 ; if ( finger_type == RIGHT_FINGER ) { Lp = Lpr ; } else if ( finger_type == LEFT_FINGER ) { Lp = Lpl ; } else if ( finger_type == MIDDLE_FINGER ) { Lp = Lpl ; } double qw1 = ( atan2 ( xm , zm ) - atan2 ( sqrt ( xm * xm + zm * zm - Lw0 * Lw0 ) , Lw0 ) ) ; if ( xm * xm + zm * zm - Lw0 * Lw0 < 0.0 ) { return ; } double ta = xm * cos ( qw1 ) - zm * sin ( qw1 ) - Lw1 ; double tb = ym - Lr + Lp ; <S2SV_StartBug> if ( finger_type == RIGHT_FINGER ) <S2SV_EndBug> { tb = ym + Lr + Lp ; } else if ( finger_type == MIDDLE_FINGER ) { tb = ym + Lr + Lp ; } double C3 = ( ta * ta + tb * tb - L1 * L1 - L2 * L2 ) / ( 2 * L1 * L2 ) ; if ( C3 > 1.0 || C3 < - 1.0 ) { return ; } double S3 = sqrt ( 1 - C3 * C3 ) ; double q3 = atan2 ( S3 , C3 ) ; double A = L2 * C3 + L1 ; double B = L2 * S3 ; double C = - ym + Lr - Lp ; if ( finger_type == RIGHT_FINGER ) { C = ym + Lr + Lp ; } <S2SV_StartBug> else if ( finger_type == MIDDLE_FINGER ) <S2SV_EndBug> { C = ym + Lr + Lp ; } if ( A * A + B * B - C * C < 0.0 ) { return ; } double q2 = atan2 ( A , B ) - atan2 ( sqrt ( A * A + B * B - C * C ) , C ) ; if ( finger_type == LEFT_FINGER ) { ref_jnt_ang [ HAND02_M10 ] = - qw1 ; ref_jnt_ang [ HAND02_M1 ] = q2 ; ref_jnt_ang [ HAND02_M2 ] = q3 ; } else if ( finger_type == RIGHT_FINGER ) { ref_jnt_ang [ HAND02_M10 ] = - qw1 ; ref_jnt_ang [ HAND02_M5 ] = q2 ; ref_jnt_ang [ HAND02_M6 ] = q3 ; } else if ( finger_type == MIDDLE_FINGER ) { ref_jnt_ang [ HAND02_M10 ] = - qw1 ; ref_jnt_ang [ HAND02_M3 ] = q2 ; ref_jnt_ang [ HAND02_M4 ] = q3 ; } } | <S2SV_ModStart> finger_type == RIGHT_FINGER <S2SV_ModEnd> ) { tb <S2SV_ModStart> Lp ; } <S2SV_ModEnd> if ( A |
1,969 | CWE-000 void <S2SV_StartBug> lra_register_new_scratch_op ( rtx_insn * insn , int nop ) <S2SV_EndBug> { lra_insn_recog_data_t id = lra_get_insn_recog_data ( insn ) ; rtx op = * id -> operand_loc [ nop ] ; sloc_t loc = XNEW ( struct sloc ) ; lra_assert ( REG_P ( op ) ) ; loc -> insn = insn ; loc -> nop = nop ; <S2SV_StartBug> scratches . safe_push ( loc ) ; <S2SV_EndBug> bitmap_set_bit ( & scratch_bitmap , REGNO ( op ) ) ; bitmap_set_bit ( & scratch_operand_bitmap , INSN_UID ( insn ) * MAX_RECOG_OPERANDS + nop ) ; add_reg_note ( insn , REG_UNUSED , op ) ; } | <S2SV_ModStart> , int nop , int icode <S2SV_ModStart> = nop ; loc -> icode = icode ; |
1,970 | CWE-000 int initServo ( ServoHandler * servoh ) { servoh -> mutex = osMutexCreate ( osMutex ( servosAcces ) ) ; if ( servoh -> mutex == NULL ) return 0 ; <S2SV_StartBug> servoh -> timer = osTimerCreate ( osTimer ( servosPower ) , osTimerOnce , ( void * ) servoh ) ; <S2SV_EndBug> if ( servoh -> timer == NULL ) return 0 ; <S2SV_StartBug> HAL_TIM_Base_Start ( servoh -> timh ) ; <S2SV_EndBug> <S2SV_StartBug> HAL_TIM_PWM_Start ( servoh -> timh , TIM_CHANNEL_ALL ) ; <S2SV_EndBug> return 1 ; } | <S2SV_ModStart> , osTimerOnce , <S2SV_ModEnd> servoh ) ; <S2SV_ModStart> return 0 ; HAL_TIM_PWM_Start <S2SV_ModEnd> ( servoh -> <S2SV_ModStart> servoh -> timh , TIM_CHANNEL_1 <S2SV_ModStart> -> timh , TIM_CHANNEL_2 ) ; HAL_TIM_PWM_Start ( servoh -> timh , TIM_CHANNEL_3 <S2SV_ModEnd> ) ; return |
1,971 | CWE-000 static int print_handler ( char * fmt , va_list * args , int * i ) { int * flags ; int width_prec_lmod [ 3 ] ; int out ; t_lmod lmod ; flags = ( int * ) malloc ( 3 * sizeof ( int ) ) ; ft_bzero ( flags , 3 * sizeof ( int ) ) ; ft_memset ( width_prec_lmod , - 1 , 3 * sizeof ( int ) ) ; out = 0 ; while ( IS_PRE ( fmt [ * i ] ) ) { flag_handler ( & flags , fmt , i ) ; width_prec_lmod [ 0 ] = ( ft_isdigit ( fmt [ * i ] ) ) ? wp_handler ( fmt , i ) : - 1 ; width_prec_lmod [ 1 ] = ( fmt [ * i ] == '.' ) ? wp_handler ( fmt , i ) : - 1 ; if ( width_prec_lmod [ 1 ] > 0 && flags [ 1 ] == 1 ) flags [ 1 ] = 0 ; lmod = ( IS_LMOD ( fmt [ * i ] ) ) ? lmod_handler ( fmt , i ) : N ; width_prec_lmod [ 2 ] = ( int ) lmod ; } if ( IS_NUM ( fmt [ * i ] ) || IS_LON ( fmt [ * i ] ) ) out = num_handler ( fmt [ ( * i ) ++ ] , args , flags , width_prec_lmod ) ; <S2SV_StartBug> if ( IS_CHR ( fmt [ * i ] ) || fmt [ * i ] == '%' ) <S2SV_EndBug> out = chr_handler ( fmt [ ( * i ) ++ ] , args , flags , width_prec_lmod ) ; free ( flags ) ; return ( out ) ; } | <S2SV_ModStart> width_prec_lmod ) ; else |
1,972 | CWE-000 int fsck_chk_didnode_blk ( struct f2fs_sb_info * sbi , struct f2fs_inode * inode , enum FILE_TYPE ftype , struct f2fs_node * node_blk , u32 * blk_cnt , struct child_info * child ) { int i = 0 ; <S2SV_StartBug> int need_fix = 0 , ret = 0 ; <S2SV_EndBug> for ( i = 0 ; i < NIDS_PER_BLOCK ; i ++ ) { if ( le32_to_cpu ( node_blk -> in . nid [ i ] ) == 0x0 ) goto skip ; ret = fsck_chk_node_blk ( sbi , inode , le32_to_cpu ( node_blk -> in . nid [ i ] ) , ftype , TYPE_INDIRECT_NODE , blk_cnt , child ) ; if ( ! ret ) * blk_cnt = * blk_cnt + 1 ; else if ( ret == - EINVAL ) { if ( ! c . fix_on ) printf ( "should<S2SV_blank>delete<S2SV_blank>in.nid[i]<S2SV_blank>=<S2SV_blank>0;\\n" ) ; else { node_blk -> in . nid [ i ] = 0 ; need_fix = 1 ; FIX_MSG ( "Set<S2SV_blank>double<S2SV_blank>indirect<S2SV_blank>node<S2SV_blank>0x%x<S2SV_blank>-><S2SV_blank>0" , i ) ; } skip : child -> pgofs += ADDRS_PER_BLOCK * NIDS_PER_BLOCK ; } } if ( need_fix && ! c . ro ) { struct node_info ni ; nid_t nid = le32_to_cpu ( node_blk -> footer . nid ) ; get_node_info ( sbi , nid , & ni ) ; ret = dev_write_block ( node_blk , ni . blk_addr ) ; ASSERT ( ret >= 0 ) ; } return 0 ; } | <S2SV_ModStart> ret = 0 ; fsck_reada_all_direct_node_blocks ( sbi , node_blk ) |
1,973 | CWE-000 void animation_previous ( ) { <S2SV_StartBug> stop_animation ( ) ; <S2SV_EndBug> current_animation = decrement ( current_animation , 1 , 0 , animation_LAST ) ; dprintf ( "animation_previous:<S2SV_blank>%u\\n" , current_animation ) ; set_animation ( current_animation ) ; start_animation ( ) ; } | <S2SV_ModStart> stop_animation ( ) ; if ( current_animation == 0 ) current_animation = animation_LAST |
1,974 | CWE-000 <S2SV_StartBug> void error_response ( int errcode , char * err , size_t errlen , char * err_extended , int sockfd ) { <S2SV_EndBug> int num_headers ; struct http_pairs res_headers [ MAX_HEADERS ] ; char * response ; char body [ MAX_CHAR ] ; header_build ( so , NULL , NULL , 0 , 0 , 0 , res_headers , & num_headers ) ; sprintf ( body , "<HTML><HEAD><title>%d<S2SV_blank>Error<S2SV_blank>Page</title></HEAD><BODY><p<S2SV_blank>align=\\"center\\"><h1>Error<S2SV_blank>%d</h1><br>%s<p></BODY></HTML>" , errcode , errcode , err_extended ) ; <S2SV_StartBug> http_response_build ( & response , 1 , errcode , err , errlen , num_headers , res_headers , body , strlen ( body ) ) ; <S2SV_EndBug> if ( tcp_send ( sockfd , ( const void * ) response , strlen ( response ) ) < 0 ) { print ( "could<S2SV_blank>not<S2SV_blank>send<S2SV_blank>response<S2SV_blank>(%s:%d)." , __FILE__ , __LINE__ ) ; print ( "errno<S2SV_blank>(send):<S2SV_blank>%s." , strerror ( errno ) ) ; mutex_lock ( & nconn_lock ) ; n_conn -- ; mutex_unlock ( & nconn_lock ) ; conc_exit ( ) ; } free ( response ) ; } | <S2SV_ModStart> void error_response ( int version , <S2SV_ModStart> & response , version <S2SV_ModEnd> , errcode , |
1,975 | CWE-000 void FS_reformat ( void ) { write28 ( 1 , DISK_SIGNATURE , 512 ) ; flush ( ) ; write28 ( 2 , get_lang ( ) , 512 ) ; flush ( ) ; <S2SV_StartBug> write28 ( 3 , "ff" , 512 ) ; <S2SV_EndBug> flush ( ) ; write28 ( 4 , "Jeff" , 512 ) ; flush ( ) ; write28 ( 19 , FS_write_number_u32 ( 0 ) , 4 ) ; flush ( ) ; } | <S2SV_ModStart> ( 3 , "fff" <S2SV_ModEnd> , 512 ) |
1,976 | CWE-000 void TkpInitKeymapInfo ( TkDisplay * dispPtr ) { XModifierKeymap * modMapPtr ; KeyCode * codePtr ; KeySym keysym ; int count , i , j , max , arraySize ; # define KEYCODE_ARRAY_SIZE 20 dispPtr -> bindInfoStale = 0 ; modMapPtr = XGetModifierMapping ( dispPtr -> display ) ; dispPtr -> lockUsage = LU_IGNORE ; codePtr = modMapPtr -> modifiermap + modMapPtr -> max_keypermod * LockMapIndex ; for ( count = modMapPtr -> max_keypermod ; count > 0 ; count -- , codePtr ++ ) { if ( * codePtr == 0 ) { continue ; } <S2SV_StartBug> keysym = XKeycodeToKeysym ( dispPtr -> display , * codePtr , 0 ) ; <S2SV_EndBug> if ( keysym == XK_Shift_Lock ) { dispPtr -> lockUsage = LU_SHIFT ; break ; } if ( keysym == XK_Caps_Lock ) { dispPtr -> lockUsage = LU_CAPS ; break ; } } dispPtr -> modeModMask = 0 ; dispPtr -> metaModMask = 0 ; dispPtr -> altModMask = 0 ; codePtr = modMapPtr -> modifiermap ; max = 8 * modMapPtr -> max_keypermod ; for ( i = 0 ; i < max ; i ++ , codePtr ++ ) { if ( * codePtr == 0 ) { continue ; } <S2SV_StartBug> keysym = XKeycodeToKeysym ( dispPtr -> display , * codePtr , 0 ) ; <S2SV_EndBug> if ( keysym == XK_Mode_switch ) { dispPtr -> modeModMask |= ShiftMask << ( i / modMapPtr -> max_keypermod ) ; } if ( ( keysym == XK_Meta_L ) || ( keysym == XK_Meta_R ) ) { dispPtr -> metaModMask |= ShiftMask << ( i / modMapPtr -> max_keypermod ) ; } if ( ( keysym == XK_Alt_L ) || ( keysym == XK_Alt_R ) ) { dispPtr -> altModMask |= ShiftMask << ( i / modMapPtr -> max_keypermod ) ; } } if ( dispPtr -> modKeyCodes != NULL ) { ckfree ( dispPtr -> modKeyCodes ) ; } dispPtr -> numModKeyCodes = 0 ; arraySize = KEYCODE_ARRAY_SIZE ; dispPtr -> modKeyCodes = ckalloc ( KEYCODE_ARRAY_SIZE * sizeof ( KeyCode ) ) ; for ( i = 0 , codePtr = modMapPtr -> modifiermap ; i < max ; i ++ , codePtr ++ ) { if ( * codePtr == 0 ) { continue ; } for ( j = 0 ; j < dispPtr -> numModKeyCodes ; j ++ ) { if ( dispPtr -> modKeyCodes [ j ] == * codePtr ) { goto nextModCode ; } } if ( dispPtr -> numModKeyCodes >= arraySize ) { KeyCode * newCodes ; arraySize *= 2 ; newCodes = ckalloc ( arraySize * sizeof ( KeyCode ) ) ; memcpy ( newCodes , dispPtr -> modKeyCodes , dispPtr -> numModKeyCodes * sizeof ( KeyCode ) ) ; ckfree ( dispPtr -> modKeyCodes ) ; dispPtr -> modKeyCodes = newCodes ; } dispPtr -> modKeyCodes [ dispPtr -> numModKeyCodes ] = * codePtr ; dispPtr -> numModKeyCodes ++ ; nextModCode : continue ; } XFreeModifiermap ( modMapPtr ) ; } | <S2SV_ModStart> } keysym = XkbKeycodeToKeysym <S2SV_ModEnd> ( dispPtr -> <S2SV_ModStart> , * codePtr , 0 <S2SV_ModStart> } keysym = XkbKeycodeToKeysym <S2SV_ModEnd> ( dispPtr -> <S2SV_ModStart> , * codePtr , 0 |
1,977 | CWE-000 static int add_port ( struct ports_device * portdev , u32 id ) { char debugfs_name [ 16 ] ; struct port * port ; <S2SV_StartBug> struct port_buffer * buf ; <S2SV_EndBug> dev_t devt ; unsigned int nr_added_bufs ; int err ; port = kmalloc ( sizeof ( * port ) , GFP_KERNEL ) ; if ( ! port ) { err = - ENOMEM ; goto fail ; } kref_init ( & port -> kref ) ; port -> portdev = portdev ; port -> id = id ; port -> name = NULL ; port -> inbuf = NULL ; port -> cons . hvc = NULL ; port -> async_queue = NULL ; port -> cons . ws . ws_row = port -> cons . ws . ws_col = 0 ; port -> host_connected = port -> guest_connected = false ; port -> stats = ( struct port_stats ) { 0 } ; port -> outvq_full = false ; port -> in_vq = portdev -> in_vqs [ port -> id ] ; port -> out_vq = portdev -> out_vqs [ port -> id ] ; port -> cdev = cdev_alloc ( ) ; if ( ! port -> cdev ) { dev_err ( & port -> portdev -> vdev -> dev , "Error<S2SV_blank>allocating<S2SV_blank>cdev\\n" ) ; err = - ENOMEM ; goto free_port ; } port -> cdev -> ops = & port_fops ; devt = MKDEV ( portdev -> chr_major , id ) ; err = cdev_add ( port -> cdev , devt , 1 ) ; if ( err < 0 ) { dev_err ( & port -> portdev -> vdev -> dev , "Error<S2SV_blank>%d<S2SV_blank>adding<S2SV_blank>cdev<S2SV_blank>for<S2SV_blank>port<S2SV_blank>%u\\n" , err , id ) ; goto free_cdev ; } port -> dev = device_create ( pdrvdata . class , & port -> portdev -> vdev -> dev , devt , port , "vport%up%u" , port -> portdev -> vdev -> index , id ) ; if ( IS_ERR ( port -> dev ) ) { err = PTR_ERR ( port -> dev ) ; dev_err ( & port -> portdev -> vdev -> dev , "Error<S2SV_blank>%d<S2SV_blank>creating<S2SV_blank>device<S2SV_blank>for<S2SV_blank>port<S2SV_blank>%u\\n" , err , id ) ; goto free_cdev ; } spin_lock_init ( & port -> inbuf_lock ) ; spin_lock_init ( & port -> outvq_lock ) ; init_waitqueue_head ( & port -> waitqueue ) ; nr_added_bufs = fill_queue ( port -> in_vq , & port -> inbuf_lock ) ; if ( ! nr_added_bufs ) { dev_err ( port -> dev , "Error<S2SV_blank>allocating<S2SV_blank>inbufs\\n" ) ; err = - ENOMEM ; goto free_device ; } if ( is_rproc_serial ( port -> portdev -> vdev ) ) port -> host_connected = true ; else if ( ! use_multiport ( port -> portdev ) ) { err = init_port_console ( port ) ; if ( err ) goto free_inbufs ; } spin_lock_irq ( & portdev -> ports_lock ) ; list_add_tail ( & port -> list , & port -> portdev -> ports ) ; spin_unlock_irq ( & portdev -> ports_lock ) ; send_control_msg ( port , VIRTIO_CONSOLE_PORT_READY , 1 ) ; if ( pdrvdata . debugfs_dir ) { sprintf ( debugfs_name , "vport%up%u" , port -> portdev -> vdev -> index , id ) ; port -> debugfs_file = debugfs_create_file ( debugfs_name , 0444 , pdrvdata . debugfs_dir , port , & port_debugfs_ops ) ; } return 0 ; free_inbufs : <S2SV_StartBug> while ( ( buf = virtqueue_detach_unused_buf ( port -> in_vq ) ) ) <S2SV_EndBug> free_buf ( buf , true ) ; free_device : device_destroy ( pdrvdata . class , port -> dev -> devt ) ; free_cdev : cdev_del ( port -> cdev ) ; free_port : kfree ( port ) ; fail : __send_control_msg ( portdev , id , VIRTIO_CONSOLE_PORT_READY , 0 ) ; return err ; } | <S2SV_ModStart> * port ; <S2SV_ModEnd> dev_t devt ; <S2SV_ModStart> ; free_inbufs : <S2SV_ModEnd> free_device : device_destroy |
1,978 | CWE-000 void bdt_enable ( void ) { bdt_log ( "ENABLE<S2SV_blank>BT" ) ; if ( bt_enabled ) { bdt_log ( "Bluetooth<S2SV_blank>is<S2SV_blank>already<S2SV_blank>enabled" ) ; return ; } <S2SV_StartBug> status = sBtInterface -> enable ( ) ; <S2SV_EndBug> check_return_status ( status ) ; } | <S2SV_ModStart> -> enable ( false |
1,979 | CWE-000 static rpmRC runExtScript ( rpmPlugins plugins , ARGV_const_t prefixes , const char * sname , rpmlogLvl lvl , FD_t scriptFd , ARGV_t * argvp , const char * script , int arg1 , int arg2 , scriptNextFileFunc nextFileFunc ) { FD_t out = NULL ; char * fn = NULL ; pid_t pid , reaped ; int status ; int inpipe [ 2 ] ; FILE * in = NULL ; const char * line ; char * mline = NULL ; rpmRC rc = RPMRC_FAIL ; <S2SV_StartBug> struct sigaction newact , oldact ; <S2SV_EndBug> rpmlog ( RPMLOG_DEBUG , "%s:<S2SV_blank>scriptlet<S2SV_blank>start\\n" , sname ) ; if ( script ) { fn = writeScript ( * argvp [ 0 ] , script ) ; if ( fn == NULL ) { rpmlog ( RPMLOG_ERR , _ ( "Couldn\'t<S2SV_blank>create<S2SV_blank>temporary<S2SV_blank>file<S2SV_blank>for<S2SV_blank>%s:<S2SV_blank>%s\\n" ) , sname , strerror ( errno ) ) ; goto exit ; } argvAdd ( argvp , fn ) ; if ( arg1 >= 0 ) { argvAddNum ( argvp , arg1 ) ; } if ( arg2 >= 0 ) { argvAddNum ( argvp , arg2 ) ; } } if ( pipe ( inpipe ) < 0 ) { rpmlog ( RPMLOG_ERR , ( "Couldn\'t<S2SV_blank>create<S2SV_blank>pipe:<S2SV_blank>%s\\n" ) , strerror ( errno ) ) ; goto exit ; } in = fdopen ( inpipe [ 1 ] , "w" ) ; inpipe [ 1 ] = 0 ; if ( scriptFd != NULL ) { if ( rpmIsVerbose ( ) ) { out = fdDup ( Fileno ( scriptFd ) ) ; } else { out = Fopen ( "/dev/null" , "w.fdio" ) ; if ( Ferror ( out ) ) { out = fdDup ( Fileno ( scriptFd ) ) ; } } } else { out = fdDup ( STDOUT_FILENO ) ; } if ( out == NULL ) { rpmlog ( RPMLOG_ERR , _ ( "Couldn\'t<S2SV_blank>duplicate<S2SV_blank>file<S2SV_blank>descriptor:<S2SV_blank>%s:<S2SV_blank>%s\\n" ) , sname , strerror ( errno ) ) ; goto exit ; } <S2SV_StartBug> sigemptyset ( & newact . sa_mask ) ; <S2SV_EndBug> newact . sa_flags = 0 ; newact . sa_handler = SIG_IGN ; sigaction ( SIGPIPE , & newact , & oldact ) ; pid = fork ( ) ; if ( pid == ( pid_t ) - 1 ) { rpmlog ( RPMLOG_ERR , _ ( "Couldn\'t<S2SV_blank>fork<S2SV_blank>%s:<S2SV_blank>%s\\n" ) , sname , strerror ( errno ) ) ; goto exit ; } else if ( pid == 0 ) { rpmlog ( RPMLOG_DEBUG , "%s:<S2SV_blank>execv(%s)<S2SV_blank>pid<S2SV_blank>%d\\n" , sname , * argvp [ 0 ] , ( unsigned ) getpid ( ) ) ; fclose ( in ) ; dup2 ( inpipe [ 0 ] , STDIN_FILENO ) ; if ( rpmpluginsCallScriptletForkPost ( plugins , * argvp [ 0 ] , RPMSCRIPTLET_FORK | RPMSCRIPTLET_EXEC ) != RPMRC_FAIL ) { doScriptExec ( * argvp , prefixes , scriptFd , out ) ; } else { _exit ( 126 ) ; } } close ( inpipe [ 0 ] ) ; inpipe [ 0 ] = 0 ; if ( nextFileFunc -> func ) { while ( ( line = nextFileFunc -> func ( nextFileFunc -> param ) ) != NULL ) { size_t size = strlen ( line ) ; size_t ret_size ; mline = xstrdup ( line ) ; mline [ size ] = '\\n' ; ret_size = fwrite ( mline , size + 1 , 1 , in ) ; mline = _free ( mline ) ; if ( ret_size != 1 ) { if ( errno == EPIPE ) { break ; } else { rpmlog ( RPMLOG_ERR , _ ( "Fwrite<S2SV_blank>failed:<S2SV_blank>%s" ) , strerror ( errno ) ) ; rc = RPMRC_FAIL ; goto exit ; } } } } fclose ( in ) ; in = NULL ; do { reaped = waitpid ( pid , & status , 0 ) ; } while ( reaped == - 1 && errno == EINTR ) ; rpmlog ( RPMLOG_DEBUG , "%s:<S2SV_blank>waitpid(%d)<S2SV_blank>rc<S2SV_blank>%d<S2SV_blank>status<S2SV_blank>%x\\n" , sname , ( unsigned ) pid , ( unsigned ) reaped , status ) ; if ( reaped < 0 ) { rpmlog ( lvl , _ ( "%s<S2SV_blank>scriptlet<S2SV_blank>failed,<S2SV_blank>waitpid(%d)<S2SV_blank>rc<S2SV_blank>%d:<S2SV_blank>%s\\n" ) , sname , pid , reaped , strerror ( errno ) ) ; } else if ( ! WIFEXITED ( status ) || WEXITSTATUS ( status ) ) { if ( WIFSIGNALED ( status ) ) { rpmlog ( lvl , _ ( "%s<S2SV_blank>scriptlet<S2SV_blank>failed,<S2SV_blank>signal<S2SV_blank>%d\\n" ) , sname , WTERMSIG ( status ) ) ; } else { rpmlog ( lvl , _ ( "%s<S2SV_blank>scriptlet<S2SV_blank>failed,<S2SV_blank>exit<S2SV_blank>status<S2SV_blank>%d\\n" ) , sname , WEXITSTATUS ( status ) ) ; } } else { rc = RPMRC_OK ; } exit : if ( in ) fclose ( in ) ; if ( inpipe [ 0 ] ) close ( inpipe [ 0 ] ) ; if ( out ) Fclose ( out ) ; if ( fn ) { if ( ! rpmIsDebug ( ) ) unlink ( fn ) ; free ( fn ) ; } free ( mline ) ; <S2SV_StartBug> sigaction ( SIGPIPE , & oldact , NULL ) ; <S2SV_EndBug> return rc ; } | <S2SV_ModStart> = RPMRC_FAIL ; <S2SV_ModEnd> rpmlog ( RPMLOG_DEBUG <S2SV_ModStart> exit ; } <S2SV_ModEnd> pid = fork <S2SV_ModStart> mline ) ; <S2SV_ModEnd> return rc ; |
1,980 | CWE-000 void cling_error_destroy ( struct cling_error * self ) { switch ( self -> kind ) { case CL_EREDEFINED : free ( self -> redefined . name ) ; break ; case CL_EUNDEFINED : free ( self -> undefined . name ) ; break ; case CL_ENOTLVALUE : free ( self -> not_lvalue . value ) ; break ; case CL_EARGCUNMAT : free ( self -> argc_unmat . func_name ) ; break ; case CL_EINVEXPR : free ( self -> invexpr . expr ) ; break ; <S2SV_StartBug> } <S2SV_EndBug> free ( self ) ; } | <S2SV_ModStart> ; break ; case CL_EDUPCASE : free ( self -> dupcase . label ) ; break ; |
1,981 | CWE-000 int ft_where ( t_env * e ) { int i ; char * * paths ; char * path ; i = 0 ; paths = ft_find_paths ( e -> env ) ; while ( ++ i < ( int ) e -> cmd_len ) { if ( ft_isbuiltin ( e -> cmd [ i ] ) ) ft_error ( e -> cmd [ i ] , "is<S2SV_blank>a<S2SV_blank>shell<S2SV_blank>built-in" , NULL ) ; if ( ( path = ft_find_exec ( paths , e -> cmd [ i ] ) ) ) { ft_putendl ( path ) ; <S2SV_StartBug> free ( path ) ; <S2SV_EndBug> } } ft_free_tab ( paths ) ; return ( 0 ) ; } | <S2SV_ModStart> path ) ; strfree ( & <S2SV_ModEnd> path ) ; |
1,982 | CWE-000 static gboolean rspamd_symbols_cache_check_symbol ( struct rspamd_task * task , struct symbols_cache * cache , struct rspamd_symcache_item * item , struct cache_savepoint * checkpoint ) { double t1 = 0 ; struct rspamd_task * * ptask ; lua_State * L ; gboolean check = TRUE ; if ( item -> func ) { g_assert ( item -> func != NULL ) ; <S2SV_StartBug> setbit ( checkpoint -> processed_bits , item -> id * 2 ) ; <S2SV_EndBug> if ( ! item -> enabled || ( RSPAMD_TASK_IS_EMPTY ( task ) && ! ( item -> type & SYMBOL_TYPE_EMPTY ) ) ) { check = FALSE ; } else if ( item -> condition_cb != - 1 ) { L = task -> cfg -> lua_state ; lua_rawgeti ( L , LUA_REGISTRYINDEX , item -> condition_cb ) ; ptask = lua_newuserdata ( L , sizeof ( struct rspamd_task * ) ) ; rspamd_lua_setclass ( L , "rspamd{task}" , - 1 ) ; * ptask = task ; if ( lua_pcall ( L , 1 , 1 , 0 ) != 0 ) { msg_info_task ( "call<S2SV_blank>to<S2SV_blank>condition<S2SV_blank>for<S2SV_blank>%s<S2SV_blank>failed:<S2SV_blank>%s" , item -> symbol , lua_tostring ( L , - 1 ) ) ; lua_pop ( L , 1 ) ; } else { check = lua_toboolean ( L , - 1 ) ; lua_pop ( L , 1 ) ; } } if ( check ) { msg_debug_cache_task ( "execute<S2SV_blank>%s,<S2SV_blank>%d" , item -> symbol , item -> id ) ; # ifdef HAVE_EVENT_NO_CACHE_TIME_FUNC struct timeval tv ; event_base_update_cache_time ( task -> ev_base ) ; event_base_gettimeofday_cached ( task -> ev_base , & tv ) ; t1 = tv_to_double ( & tv ) ; # else t1 = rspamd_get_ticks ( FALSE ) ; # endif item -> start_ticks = t1 ; item -> async_events = 0 ; g_assert ( checkpoint -> cur_item == NULL ) ; checkpoint -> cur_item = item ; checkpoint -> items_inflight ++ ; item -> func ( task , item , item -> user_data ) ; <S2SV_StartBug> if ( checkpoint -> items_inflight == 0 ) { <S2SV_EndBug> return TRUE ; } return FALSE ; } else { msg_debug_cache_task ( "skipping<S2SV_blank>check<S2SV_blank>of<S2SV_blank>%s<S2SV_blank>as<S2SV_blank>its<S2SV_blank>start<S2SV_blank>condition<S2SV_blank>is<S2SV_blank>false" , item -> symbol ) ; setbit ( checkpoint -> processed_bits , item -> id * 2 + 1 ) ; return TRUE ; } } else { setbit ( checkpoint -> processed_bits , item -> id * 2 ) ; setbit ( checkpoint -> processed_bits , item -> id * 2 + 1 ) ; return TRUE ; } } | <S2SV_ModStart> NULL ) ; g_assert ( ! isset ( checkpoint -> processed_bits , item -> id * 2 ) ) ; <S2SV_ModStart> user_data ) ; checkpoint -> cur_item = NULL ; |
1,983 | CWE-000 int test_algorithm ( int key_algorithm , const char * keys_dir ) { char filename [ 1024 ] ; enum vb2_signature_algorithm sig_alg = vb2_crypto_to_signature ( key_algorithm ) ; enum vb2_hash_algorithm hash_alg = vb2_crypto_to_hash ( key_algorithm ) ; struct vb2_private_key * prik = NULL ; struct vb21_signature * sig2 = NULL ; <S2SV_StartBug> struct vb2_public_key * pubk = NULL ; <S2SV_EndBug> struct vb21_packed_key * key2 = NULL ; printf ( "***Testing<S2SV_blank>algorithm:<S2SV_blank>%s\\n" , vb2_get_crypto_algorithm_name ( key_algorithm ) ) ; snprintf ( filename , sizeof ( filename ) , "%s/key_%s.pem" , keys_dir , vb2_get_crypto_algorithm_file ( key_algorithm ) ) ; TEST_SUCC ( vb2_private_key_read_pem ( & prik , filename ) , "Read<S2SV_blank>private<S2SV_blank>key" ) ; prik -> hash_alg = hash_alg ; prik -> sig_alg = sig_alg ; vb2_private_key_set_desc ( prik , "private<S2SV_blank>key" ) ; <S2SV_StartBug> snprintf ( filename , sizeof ( filename ) , "%s/key_%s.keyb" , <S2SV_EndBug> keys_dir , vb2_get_crypto_algorithm_file ( key_algorithm ) ) ; TEST_SUCC ( vb2_public_key_read_keyb ( & pubk , filename ) , "Read<S2SV_blank>public<S2SV_blank>key" ) ; pubk -> hash_alg = hash_alg ; vb2_public_key_set_desc ( pubk , "public<S2SV_blank>key" ) ; TEST_SUCC ( vb21_public_key_pack ( & key2 , pubk ) , "Pack<S2SV_blank>public<S2SV_blank>key" ) ; TEST_SUCC ( vb21_sign_data ( & sig2 , test_data , test_size , prik , "" ) , "Make<S2SV_blank>test<S2SV_blank>signature" ) ; test_unpack_key ( key2 ) ; test_verify_data ( pubk , sig2 ) ; test_verify_signature ( sig2 ) ; free ( key2 ) ; free ( sig2 ) ; vb2_private_key_free ( prik ) ; vb2_public_key_free ( pubk ) ; return 0 ; } | <S2SV_ModStart> vb2_public_key * pubk ; uint8_t * pubk_buf = 0 ; uint8_t * keyb_data = 0 ; uint32_t keyb_size <S2SV_ModEnd> ; struct vb21_packed_key <S2SV_ModStart> "private<S2SV_blank>key" ) ; TEST_SUCC ( vb2_public_key_alloc ( & pubk , sig_alg ) , "Allocate<S2SV_blank>public<S2SV_blank>key" ) ; TEST_SUCC ( vb_keyb_from_rsa ( prik -> rsa_private_key , & keyb_data , & keyb_size ) , "Extract<S2SV_blank>public<S2SV_blank>key" ) ; pubk_buf = vb2_public_key_packed_data ( pubk ) ; memcpy ( pubk_buf , keyb_data , keyb_size ) ; TEST_SUCC ( vb2_unpack_key_data ( pubk , pubk_buf , keyb_size ) , "unpack<S2SV_blank>public<S2SV_blank>key<S2SV_blank>blob" <S2SV_ModEnd> ) ; pubk |
1,984 | CWE-000 char * ft_strjoin ( char const * s1 , char const * s2 ) { char * mas ; int i ; int j ; if ( ! s1 || ! s2 ) return ( NULL ) ; <S2SV_StartBug> mas = ft_strnew ( ft_strlen ( s1 ) + ft_strlen ( s2 ) ) ; <S2SV_EndBug> if ( ! mas ) { ft_memdel ( ( void * ) & mas ) ; return ( NULL ) ; <S2SV_StartBug> } <S2SV_EndBug> i = - 1 ; while ( s1 [ ++ i ] != '\\0' ) mas [ i ] = s1 [ i ] ; j = - 1 ; while ( s2 [ ++ j ] != '\\0' ) { mas [ i ] = s2 [ j ] ; i ++ ; } mas [ i ] = '\\0' ; return ( mas ) ; } | <S2SV_ModStart> NULL ) ; if ( ! ( <S2SV_ModStart> s2 ) ) ) ) <S2SV_ModEnd> return ( NULL <S2SV_ModStart> NULL ) ; <S2SV_ModEnd> i = - |
1,985 | CWE-000 static void prvSOCKETS_SendRecv_VaryLength ( Server_t xConn ) { BaseType_t xResult ; uint32_t ulIndex ; uint32_t ulTxCount ; <S2SV_StartBug> const uint32_t ulMaxLoopCount = 10 ; <S2SV_EndBug> uint32_t i ; uint8_t * pucTxBuffer = ( uint8_t * ) cTxBuffer ; uint8_t * pucRxBuffer = ( uint8_t * ) cRxBuffer ; size_t xMessageLengths [ ] = { 1 , 2 , 7 , 8 , 9 , 1199 , 1200 , 1201 } ; tcptestPRINTF ( ( "Starting<S2SV_blank>%s.\\r\\n" , __FUNCTION__ ) ) ; xResult = pdPASS ; ulTxCount = 0 ; for ( ulIndex = 0 ; ulIndex < sizeof ( xMessageLengths ) / sizeof ( size_t ) ; ulIndex ++ ) { xResult = prvConnectHelperWithRetry ( & xSocket , xConn , xReceiveTimeOut , xSendTimeOut , & xSocketOpen ) ; TEST_ASSERT_EQUAL_INT32_MESSAGE ( SOCKETS_ERROR_NONE , xResult , "Failed<S2SV_blank>to<S2SV_blank>connect" ) ; for ( i = 0 ; i < ulMaxLoopCount ; i ++ ) { memset ( pucTxBuffer , tcptestTX_BUFFER_FILLER , tcptestBUFFER_SIZE ) ; prvCreateTxData ( ( char * ) pucTxBuffer , xMessageLengths [ ulIndex ] , ulTxCount ) ; ulTxCount ++ ; xResult = prvSendHelper ( xSocket , pucTxBuffer , xMessageLengths [ ulIndex ] ) ; TEST_ASSERT_EQUAL_INT32_MESSAGE ( pdPASS , xResult , "Data<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>send\\r\\n" ) ; memset ( pucRxBuffer , tcptestRX_BUFFER_FILLER , tcptestBUFFER_SIZE ) ; xResult = prvRecvHelper ( xSocket , pucRxBuffer , xMessageLengths [ ulIndex ] ) ; TEST_ASSERT_EQUAL_INT32_MESSAGE ( pdPASS , xResult , "Data<S2SV_blank>was<S2SV_blank>not<S2SV_blank>received<S2SV_blank>\\r\\n" ) ; xResult = prvCheckRxTxBuffers ( pucTxBuffer , pucRxBuffer , xMessageLengths [ ulIndex ] ) ; } xResult = prvShutdownHelper ( xSocket ) ; TEST_ASSERT_EQUAL_INT32_MESSAGE ( SOCKETS_ERROR_NONE , xResult , "Socket<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>shutdown" ) ; xResult = prvCloseHelper ( xSocket , & xSocketOpen ) ; TEST_ASSERT_EQUAL_INT32_MESSAGE ( SOCKETS_ERROR_NONE , xResult , "Socket<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>close" ) ; tcptestPRINTF ( ( "<S2SV_blank>Sending<S2SV_blank>messages<S2SV_blank>with<S2SV_blank>length<S2SV_blank>%d<S2SV_blank>complete\\r\\n" , xMessageLengths [ ulIndex ] ) ) ; vTaskDelay ( tcptestLOOP_DELAY ) ; } tcptestPRINTF ( ( "%s<S2SV_blank>passed\\r\\n" , __FUNCTION__ ) ) ; } | <S2SV_ModStart> uint32_t ulMaxLoopCount = 5 <S2SV_ModEnd> ; uint32_t i |
1,986 | CWE-000 UA_StatusCode UA_SecureChannel_sendAsymmetricOPNMessage ( UA_SecureChannel * channel , UA_UInt32 requestId , const void * content , const UA_DataType * contentType ) { const UA_SecurityPolicy * const securityPolicy = channel -> securityPolicy ; UA_Connection * connection = channel -> connection ; if ( ! connection ) return UA_STATUSCODE_BADINTERNALERROR ; UA_ByteString buf = UA_BYTESTRING_NULL ; UA_StatusCode retval = connection -> getSendBuffer ( connection , connection -> localConf . sendBufferSize , & buf ) ; if ( retval != UA_STATUSCODE_GOOD ) return retval ; UA_Byte * buf_pos = buf . data ; const UA_Byte * buf_end = & buf . data [ buf . length ] ; hideBytesAsym ( channel , & buf_pos , & buf_end ) ; UA_NodeId typeId = UA_NODEID_NUMERIC ( 0 , contentType -> binaryEncodingId ) ; retval = UA_encodeBinary ( & typeId , & UA_TYPES [ UA_TYPES_NODEID ] , & buf_pos , & buf_end , NULL , NULL ) ; retval |= UA_encodeBinary ( content , contentType , & buf_pos , & buf_end , NULL , NULL ) ; if ( retval != UA_STATUSCODE_GOOD ) { connection -> releaseSendBuffer ( connection , & buf ) ; return retval ; } const size_t securityHeaderLength = calculateAsymAlgSecurityHeaderLength ( channel ) ; if ( channel -> securityMode == UA_MESSAGESECURITYMODE_SIGN || channel -> securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT ) { const UA_Byte * buf_body_start = & buf . data [ UA_SECURE_CONVERSATION_MESSAGE_HEADER_LENGTH + UA_SEQUENCE_HEADER_LENGTH + securityHeaderLength ] ; const size_t bytesToWrite = ( uintptr_t ) buf_pos - ( uintptr_t ) buf_body_start + UA_SEQUENCE_HEADER_LENGTH ; UA_Byte paddingSize = 0 ; UA_Byte extraPaddingSize = 0 ; UA_UInt16 totalPaddingSize = calculatePaddingAsym ( securityPolicy , channel -> channelContext , bytesToWrite , & paddingSize , & extraPaddingSize ) ; <S2SV_StartBug> for ( UA_UInt16 i = 0 ; i < totalPaddingSize ; ++ i ) { <S2SV_EndBug> * buf_pos = paddingSize ; ++ buf_pos ; } if ( extraPaddingSize > 0 ) { * buf_pos = extraPaddingSize ; ++ buf_pos ; } } size_t pre_sig_length = ( uintptr_t ) buf_pos - ( uintptr_t ) buf . data ; size_t total_length = pre_sig_length ; if ( channel -> securityMode == UA_MESSAGESECURITYMODE_SIGN || channel -> securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT ) total_length += securityPolicy -> asymmetricModule . cryptoModule . getLocalSignatureSize ( securityPolicy , channel -> channelContext ) ; UA_Byte * header_pos = buf . data ; size_t dataToEncryptLength = total_length - ( UA_SECURE_CONVERSATION_MESSAGE_HEADER_LENGTH + securityHeaderLength ) ; UA_SecureConversationMessageHeader respHeader ; respHeader . messageHeader . messageTypeAndChunkType = UA_MESSAGETYPE_OPN + UA_CHUNKTYPE_FINAL ; respHeader . messageHeader . messageSize = ( UA_UInt32 ) ( total_length + securityPolicy -> channelModule . getRemoteAsymEncryptionBufferLengthOverhead ( channel -> channelContext , dataToEncryptLength ) ) ; respHeader . secureChannelId = channel -> securityToken . channelId ; retval = UA_encodeBinary ( & respHeader , & UA_TRANSPORT [ UA_TRANSPORT_SECURECONVERSATIONMESSAGEHEADER ] , & header_pos , & buf_end , NULL , NULL ) ; UA_AsymmetricAlgorithmSecurityHeader asymHeader ; UA_AsymmetricAlgorithmSecurityHeader_init ( & asymHeader ) ; asymHeader . securityPolicyUri = channel -> securityPolicy -> policyUri ; if ( channel -> securityMode == UA_MESSAGESECURITYMODE_SIGN || <S2SV_StartBug> channel -> securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT ) <S2SV_EndBug> asymHeader . senderCertificate = channel -> securityPolicy -> localCertificate ; <S2SV_StartBug> if ( channel -> securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT ) { <S2SV_EndBug> asymHeader . receiverCertificateThumbprint . length = 20 ; asymHeader . receiverCertificateThumbprint . data = channel -> remoteCertificateThumbprint ; } retval |= UA_encodeBinary ( & asymHeader , & UA_TRANSPORT [ UA_TRANSPORT_ASYMMETRICALGORITHMSECURITYHEADER ] , & header_pos , & buf_end , NULL , NULL ) ; UA_SequenceHeader seqHeader ; seqHeader . requestId = requestId ; seqHeader . sequenceNumber = UA_atomic_add ( & channel -> sendSequenceNumber , 1 ) ; retval |= UA_encodeBinary ( & seqHeader , & UA_TRANSPORT [ UA_TRANSPORT_SEQUENCEHEADER ] , & header_pos , & buf_end , NULL , NULL ) ; if ( retval != UA_STATUSCODE_GOOD ) { connection -> releaseSendBuffer ( connection , & buf ) ; return retval ; } if ( channel -> securityMode == UA_MESSAGESECURITYMODE_SIGN || channel -> securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT ) { const UA_ByteString dataToSign = { pre_sig_length , buf . data } ; size_t sigsize = securityPolicy -> asymmetricModule . cryptoModule . getLocalSignatureSize ( securityPolicy , channel -> channelContext ) ; UA_ByteString signature = { sigsize , buf . data + pre_sig_length } ; retval = securityPolicy -> asymmetricModule . cryptoModule . sign ( securityPolicy , channel -> channelContext , & dataToSign , & signature ) ; if ( retval != UA_STATUSCODE_GOOD ) { connection -> releaseSendBuffer ( connection , & buf ) ; return retval ; } } if ( channel -> securityMode == UA_MESSAGESECURITYMODE_SIGN || channel -> securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT ) { size_t unencrypted_length = UA_SECURE_CONVERSATION_MESSAGE_HEADER_LENGTH + securityHeaderLength ; UA_ByteString dataToEncrypt = { total_length - unencrypted_length , & buf . data [ unencrypted_length ] } ; retval = securityPolicy -> asymmetricModule . cryptoModule . encrypt ( securityPolicy , channel -> channelContext , & dataToEncrypt ) ; if ( retval != UA_STATUSCODE_GOOD ) { connection -> releaseSendBuffer ( connection , & buf ) ; return retval ; } } buf . length = respHeader . messageHeader . messageSize ; return connection -> send ( connection , & buf ) ; } | <S2SV_ModStart> 0 ; i <= <S2SV_ModEnd> totalPaddingSize ; ++ <S2SV_ModStart> == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT ) { <S2SV_ModStart> -> localCertificate ; <S2SV_ModEnd> asymHeader . receiverCertificateThumbprint |
1,987 | CWE-000 void wemed_panel_load_doc ( WemedPanel * wp , WemedPanelDoc doc ) { GET_D ( wp ) ; wemed_panel_clear ( wp ) ; gtk_text_buffer_set_text ( d -> headertext , doc . headers . str , doc . headers . len ) ; gtk_text_buffer_set_modified ( d -> headertext , FALSE ) ; gtk_widget_set_sensitive ( d -> headerview , TRUE ) ; if ( doc . content . str && doc . content_type ) { <S2SV_StartBug> GBytes * bytes = g_bytes_new ( doc . content . str , doc . content . len ) ; <S2SV_EndBug> if ( strncmp ( doc . content_type , "text/" , 5 ) == 0 ) { if ( strncmp ( & doc . content_type [ 5 ] , "html" , 4 ) == 0 && ! d -> view_source ) { <S2SV_StartBug> webkit_web_view_load_bytes ( WEBKIT_WEB_VIEW ( d -> webview ) , bytes , doc . content_type , doc . charset , NULL ) ; <S2SV_EndBug> webkit_web_view_set_editable ( WEBKIT_WEB_VIEW ( d -> webview ) , TRUE ) ; gtk_widget_show ( d -> toolbar ) ; gtk_widget_show ( d -> progress_bar ) ; } else { GString src = doc . content ; if ( doc . charset && strcmp ( doc . charset , "utf8" ) != 0 ) { gsize sz ; char * converted = g_convert ( src . str , src . len , "utf8" , doc . charset , NULL , & sz , NULL ) ; if ( converted ) { free ( src . str ) ; src . str = converted ; src . len = sz ; } else fprintf ( stderr , "Conversion<S2SV_blank>from<S2SV_blank>%s<S2SV_blank>to<S2SV_blank>utf8<S2SV_blank>failed\\n" , doc . charset ) ; } gtk_text_buffer_set_text ( d -> sourcetext , src . str , src . len ) ; gtk_source_buffer_set_language ( GTK_SOURCE_BUFFER ( d -> sourcetext ) , gtk_source_language_manager_guess_language ( gtk_source_language_manager_get_default ( ) , NULL , doc . content_type ) ) ; gtk_text_buffer_set_modified ( d -> sourcetext , FALSE ) ; gtk_widget_show ( d -> sourceview ) ; } } else if ( webkit_web_view_can_show_mime_type ( WEBKIT_WEB_VIEW ( d -> webview ) , doc . content_type ) ) { <S2SV_StartBug> webkit_web_view_load_bytes ( WEBKIT_WEB_VIEW ( d -> webview ) , bytes , doc . content_type , doc . charset , NULL ) ; <S2SV_EndBug> } else { char * label = NULL ; asprintf ( & label , _ ( "Edit<S2SV_blank>with<S2SV_blank>%s" ) , doc . mimeapp_name ) ; gtk_button_set_label ( GTK_BUTTON ( d -> open_ext_btn ) , label ) ; free ( label ) ; gtk_widget_show ( d -> open_ext_box ) ; } } g_signal_connect ( G_OBJECT ( d -> headertext ) , "modified-changed" , G_CALLBACK ( dirtied_cb ) , wp ) ; g_signal_connect ( G_OBJECT ( d -> sourcetext ) , "modified-changed" , G_CALLBACK ( dirtied_cb ) , wp ) ; } | <S2SV_ModStart> content_type ) { <S2SV_ModEnd> if ( strncmp <S2SV_ModStart> view_source ) { GBytes * bytes = g_bytes_new ( doc . content . str , doc . content . len + 1 ) ; <S2SV_ModStart> charset , NULL ) ; g_bytes_unref ( bytes <S2SV_ModStart> ) ) { GBytes * bytes = g_bytes_new ( doc . content . str , doc . content . len ) ; <S2SV_ModStart> charset , NULL ) ; g_bytes_unref ( bytes |
1,988 | CWE-000 static replication_level_t * get_replication ( nvlist_t * nvroot , boolean_t fatal ) { nvlist_t * * top ; uint_t t , toplevels ; nvlist_t * * child ; uint_t c , children ; nvlist_t * nv ; char * type ; replication_level_t lastrep = { 0 } ; replication_level_t rep ; replication_level_t * ret ; replication_level_t * raidz , * mirror ; boolean_t dontreport ; ret = safe_malloc ( sizeof ( replication_level_t ) ) ; verify ( nvlist_lookup_nvlist_array ( nvroot , ZPOOL_CONFIG_CHILDREN , & top , & toplevels ) == 0 ) ; for ( t = 0 ; t < toplevels ; t ++ ) { uint64_t is_log = B_FALSE ; nv = top [ t ] ; ( void ) nvlist_lookup_uint64 ( nv , ZPOOL_CONFIG_IS_LOG , & is_log ) ; if ( is_log ) continue ; verify ( nvlist_lookup_string ( nv , ZPOOL_CONFIG_TYPE , & type ) == 0 ) ; if ( nvlist_lookup_nvlist_array ( nv , ZPOOL_CONFIG_CHILDREN , & child , & children ) != 0 ) { rep . zprl_type = type ; rep . zprl_children = 1 ; rep . zprl_parity = 0 ; } else { uint64_t vdev_size ; rep . zprl_type = type ; rep . zprl_children = 0 ; if ( strcmp ( type , VDEV_TYPE_RAIDZ ) == 0 ) { verify ( nvlist_lookup_uint64 ( nv , ZPOOL_CONFIG_NPARITY , & rep . zprl_parity ) == 0 ) ; assert ( rep . zprl_parity != 0 ) ; } else { rep . zprl_parity = 0 ; } type = NULL ; dontreport = 0 ; vdev_size = - 1ULL ; for ( c = 0 ; c < children ; c ++ ) { nvlist_t * cnv = child [ c ] ; char * path ; struct stat64 statbuf ; uint64_t size = - 1ULL ; char * childtype ; int fd , err ; rep . zprl_children ++ ; verify ( nvlist_lookup_string ( cnv , ZPOOL_CONFIG_TYPE , & childtype ) == 0 ) ; if ( strcmp ( childtype , VDEV_TYPE_REPLACING ) == 0 || strcmp ( childtype , VDEV_TYPE_SPARE ) == 0 ) { nvlist_t * * rchild ; uint_t rchildren ; verify ( nvlist_lookup_nvlist_array ( cnv , ZPOOL_CONFIG_CHILDREN , & rchild , & rchildren ) == 0 ) ; assert ( rchildren == 2 ) ; cnv = rchild [ 0 ] ; verify ( nvlist_lookup_string ( cnv , ZPOOL_CONFIG_TYPE , & childtype ) == 0 ) ; } verify ( nvlist_lookup_string ( cnv , ZPOOL_CONFIG_PATH , & path ) == 0 ) ; if ( ! dontreport && type != NULL && strcmp ( type , childtype ) != 0 ) { if ( ret != NULL ) free ( ret ) ; ret = NULL ; if ( fatal ) vdev_error ( gettext ( "mismatched<S2SV_blank>replication<S2SV_blank>" "level:<S2SV_blank>%s<S2SV_blank>contains<S2SV_blank>both<S2SV_blank>" "files<S2SV_blank>and<S2SV_blank>devices\\n" ) , rep . zprl_type ) ; else return ( NULL ) ; dontreport = B_TRUE ; } if ( ( fd = open ( path , O_RDONLY ) ) >= 0 ) { <S2SV_StartBug> err = fstat64 ( fd , & statbuf ) ; <S2SV_EndBug> ( void ) close ( fd ) ; } else { err = stat64 ( path , & statbuf ) ; } if ( err != 0 || statbuf . st_size == 0 || statbuf . st_size == MAXOFFSET_T ) continue ; size = statbuf . st_size ; if ( ! dontreport && ( vdev_size != - 1ULL && ( labs ( size - vdev_size ) > ZPOOL_FUZZ ) ) ) { if ( ret != NULL ) free ( ret ) ; ret = NULL ; if ( fatal ) vdev_error ( gettext ( "%s<S2SV_blank>contains<S2SV_blank>devices<S2SV_blank>of<S2SV_blank>" "different<S2SV_blank>sizes\\n" ) , rep . zprl_type ) ; else return ( NULL ) ; dontreport = B_TRUE ; } type = childtype ; vdev_size = size ; } } if ( lastrep . zprl_type != NULL ) { if ( is_raidz_mirror ( & lastrep , & rep , & raidz , & mirror ) || is_raidz_mirror ( & rep , & lastrep , & raidz , & mirror ) ) { if ( raidz -> zprl_parity != mirror -> zprl_children - 1 ) { if ( ret != NULL ) free ( ret ) ; ret = NULL ; if ( fatal ) vdev_error ( gettext ( "mismatched<S2SV_blank>replication<S2SV_blank>" "level:<S2SV_blank>" "%s<S2SV_blank>and<S2SV_blank>%s<S2SV_blank>vdevs<S2SV_blank>with<S2SV_blank>" "different<S2SV_blank>redundancy,<S2SV_blank>" "%llu<S2SV_blank>vs.<S2SV_blank>%llu<S2SV_blank>(%llu-way)<S2SV_blank>" "are<S2SV_blank>present\\n" ) , raidz -> zprl_type , mirror -> zprl_type , raidz -> zprl_parity , mirror -> zprl_children - 1 , mirror -> zprl_children ) ; else return ( NULL ) ; } } else if ( strcmp ( lastrep . zprl_type , rep . zprl_type ) != 0 ) { if ( ret != NULL ) free ( ret ) ; ret = NULL ; if ( fatal ) vdev_error ( gettext ( "mismatched<S2SV_blank>replication<S2SV_blank>level:<S2SV_blank>" "both<S2SV_blank>%s<S2SV_blank>and<S2SV_blank>%s<S2SV_blank>vdevs<S2SV_blank>are<S2SV_blank>" "present\\n" ) , lastrep . zprl_type , rep . zprl_type ) ; else return ( NULL ) ; } else if ( lastrep . zprl_parity != rep . zprl_parity ) { if ( ret ) free ( ret ) ; ret = NULL ; if ( fatal ) vdev_error ( gettext ( "mismatched<S2SV_blank>replication<S2SV_blank>level:<S2SV_blank>" "both<S2SV_blank>%llu<S2SV_blank>and<S2SV_blank>%llu<S2SV_blank>device<S2SV_blank>parity<S2SV_blank>" "%s<S2SV_blank>vdevs<S2SV_blank>are<S2SV_blank>present\\n" ) , lastrep . zprl_parity , rep . zprl_parity , rep . zprl_type ) ; else return ( NULL ) ; } else if ( lastrep . zprl_children != rep . zprl_children ) { if ( ret ) free ( ret ) ; ret = NULL ; if ( fatal ) vdev_error ( gettext ( "mismatched<S2SV_blank>replication<S2SV_blank>level:<S2SV_blank>" "both<S2SV_blank>%llu-way<S2SV_blank>and<S2SV_blank>%llu-way<S2SV_blank>%s<S2SV_blank>" "vdevs<S2SV_blank>are<S2SV_blank>present\\n" ) , lastrep . zprl_children , rep . zprl_children , rep . zprl_type ) ; else return ( NULL ) ; } } lastrep = rep ; } if ( ret != NULL ) * ret = rep ; return ( ret ) ; } | <S2SV_ModStart> { err = fstat64_blk <S2SV_ModEnd> ( fd , |
1,989 | CWE-000 static void gen_onoff_set_unack ( struct bt_mesh_model * model , struct bt_mesh_msg_ctx * ctx , struct net_buf_simple * buf ) { u8_t tid , tmp8 ; struct net_buf_simple * msg = model -> pub -> msg ; struct generic_onoff_state * state = model -> user_data ; tmp8 = net_buf_simple_pull_u8 ( buf ) ; tid = net_buf_simple_pull_u8 ( buf ) ; if ( state -> last_tid == tid && state -> last_tx_addr == ctx -> addr ) { return ; } state -> last_tid = tid ; state -> last_tx_addr = ctx -> addr ; <S2SV_StartBug> if ( tmp8 > 0x01 ) { <S2SV_EndBug> return ; } state -> onoff = tmp8 ; if ( state -> model_instance == 0x01 ) { <S2SV_StartBug> state_binding ( ONOFF , ONOFF_t ) ; <S2SV_EndBug> update_light_state ( ) ; } else if ( state -> model_instance == 0x02 ) { } if ( model -> pub -> addr != BT_MESH_ADDR_UNASSIGNED ) { int err ; bt_mesh_model_msg_init ( msg , BT_MESH_MODEL_OP_GEN_ONOFF_STATUS ) ; net_buf_simple_add_u8 ( msg , state -> onoff ) ; err = bt_mesh_model_publish ( model ) ; if ( err ) { printk ( "bt_mesh_model_publish<S2SV_blank>err<S2SV_blank>%d\\n" , err ) ; } } } | <S2SV_ModStart> if ( tmp8 == state -> previous ) { return ; } state -> previous = tmp8 ; if ( tmp8 <S2SV_ModStart> ( ONOFF , ONOFF_TEMP <S2SV_ModEnd> ) ; update_light_state |
1,990 | CWE-000 void client_close ( Client client ) { close ( client -> fd ) ; free ( client ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> client ) ; syslog ( LOG_DEBUG , "[CLIENT]<S2SV_blank>disconnected" ) ; |
1,991 | CWE-000 size_t jose_b64_dec_buf ( const void * i , size_t il , void * o , size_t ol ) <S2SV_StartBug> { <S2SV_EndBug> const char * e = i ; uint8_t * d = o ; uint8_t rem = 0 ; size_t oo = 0 ; if ( il == SIZE_MAX ) return SIZE_MAX ; if ( ! o ) return b64_dlen ( il ) ; if ( ol < b64_dlen ( il ) ) return SIZE_MAX ; for ( size_t io = 0 ; io < il ; io ++ ) { uint8_t v = 0 ; <S2SV_StartBug> for ( char c = e [ io ] ; v < sizeof ( map ) - 1 && map [ v ] != c ; v ++ ) <S2SV_EndBug> continue ; <S2SV_StartBug> if ( v >= sizeof ( map ) - 1 ) <S2SV_EndBug> return SIZE_MAX ; switch ( io % JOSE_B64_ENC_BLK ) { case 0 : <S2SV_StartBug> if ( ! e [ io + 1 ] ) <S2SV_EndBug> return SIZE_MAX ; rem = v << 2 ; break ; case 1 : d [ oo ++ ] = rem | ( v >> 4 ) ; rem = v << 4 ; break ; case 2 : d [ oo ++ ] = rem | ( v >> 2 ) ; rem = v << 6 ; break ; case 3 : d [ oo ++ ] = rem | v ; <S2SV_StartBug> break ; <S2SV_EndBug> } } <S2SV_StartBug> return oo ; <S2SV_EndBug> } | <S2SV_ModStart> ol ) { const size_t len = strlen ( map ) ; <S2SV_ModStart> ; for ( const <S2SV_ModStart> ; v < len && c != map [ v ] <S2SV_ModEnd> ; v ++ <S2SV_ModStart> ( v >= len <S2SV_ModEnd> ) return SIZE_MAX <S2SV_ModStart> + 1 ] || rem > 0 <S2SV_ModStart> | v ; rem = 0 ; <S2SV_ModStart> } } return rem > 0 ? SIZE_MAX : |
1,992 | CWE-000 <S2SV_StartBug> void editorMoveCursorEOL ( ) { <S2SV_EndBug> int fr = get_filerow ( ) ; int y = E . cy + 1 ; for ( ; ; ) { if ( get_filerow_by_line ( y ) != fr ) break ; y ++ ; } E . cy = y - 1 ; int size = E . row [ fr ] . size ; if ( size == 0 ) { E . cx = 0 ; return ; } E . cx = E . row [ fr ] . size % E . screencols - 1 ; if ( E . cx == 0 ) E . cx = E . screencols - 1 ; } | <S2SV_ModStart> void editorMoveCursorEOL ( void |
1,993 | CWE-000 static void test_cr2res_demod ( void ) { cpl_table * trace_wave = create_test_table ( ) ; cpl_image * sum1 = create_test_image ( ) ; cpl_image * sum2 = create_test_image ( ) ; hdrl_image * sum1_hdrl = hdrl_image_create ( sum1 , NULL ) ; hdrl_image * sum2_hdrl = hdrl_image_create ( sum2 , NULL ) ; cpl_table * res ; cpl_test ( res = cr2res_demod ( sum1_hdrl , sum2_hdrl , trace_wave ) ) ; cpl_test_abs ( 0. , cpl_table_get_column_max ( res , "POL_X_7" ) , DBL_EPSILON ) ; cpl_test_abs ( 0. , cpl_table_get_column_max ( res , "POL_N_7" ) , DBL_EPSILON ) ; <S2SV_StartBug> cpl_test_abs ( 12494.8323090149976 , cpl_table_get_column_mean ( res , "POL_I_7" ) , DBL_EPSILON ) ; <S2SV_EndBug> cpl_table_save ( res , NULL , NULL , "./demod_table.fits" , CPL_IO_CREATE ) ; cpl_table_delete ( res ) ; cpl_table_delete ( trace_wave ) ; cpl_image_delete ( sum1 ) ; cpl_image_delete ( sum2 ) ; hdrl_image_delete ( sum1_hdrl ) ; hdrl_image_delete ( sum2_hdrl ) ; return ; } | <S2SV_ModStart> ; cpl_test_abs ( 15919.8 <S2SV_ModEnd> , cpl_table_get_column_mean ( <S2SV_ModStart> "POL_I_7" ) , 0.1 <S2SV_ModEnd> ) ; cpl_table_save |
1,994 | CWE-000 static const char * pgstat_get_wait_ipc ( WaitEventIPC w ) { const char * event_name = "unknown<S2SV_blank>wait<S2SV_blank>event" ; switch ( w ) { case WAIT_EVENT_BGWORKER_SHUTDOWN : event_name = "BgWorkerShutdown" ; break ; case WAIT_EVENT_BGWORKER_STARTUP : event_name = "BgWorkerStartup" ; break ; case WAIT_EVENT_BTREE_PAGE : event_name = "BtreePage" ; break ; case WAIT_EVENT_EXECUTE_GATHER : event_name = "ExecuteGather" ; break ; <S2SV_StartBug> case WAIT_EVENT_MQ_INTERNAL : <S2SV_EndBug> event_name = "MessageQueueInternal" ; break ; case WAIT_EVENT_MQ_PUT_MESSAGE : event_name = "MessageQueuePutMessage" ; break ; case WAIT_EVENT_MQ_RECEIVE : event_name = "MessageQueueReceive" ; break ; case WAIT_EVENT_MQ_SEND : event_name = "MessageQueueSend" ; break ; case WAIT_EVENT_PARALLEL_FINISH : event_name = "ParallelFinish" ; break ; case WAIT_EVENT_PARALLEL_BITMAP_SCAN : event_name = "ParallelBitmapScan" ; break ; case WAIT_EVENT_PROCARRAY_GROUP_UPDATE : event_name = "ProcArrayGroupUpdate" ; break ; <S2SV_StartBug> case WAIT_EVENT_SAFE_SNAPSHOT : <S2SV_EndBug> event_name = "SafeSnapshot" ; break ; case WAIT_EVENT_SYNC_REP : <S2SV_StartBug> event_name = "SyncRep" ; <S2SV_EndBug> break ; case WAIT_EVENT_LOGICAL_SYNC_DATA : event_name = "LogicalSyncData" ; break ; case WAIT_EVENT_LOGICAL_SYNC_STATE_CHANGE : event_name = "LogicalSyncStateChange" ; break ; } return event_name ; } | <S2SV_ModStart> break ; case WAIT_EVENT_LOGICAL_SYNC_DATA : event_name = "LogicalSyncData" ; break ; case WAIT_EVENT_LOGICAL_SYNC_STATE_CHANGE : event_name = "LogicalSyncStateChange" ; break ; case <S2SV_ModStart> break ; case WAIT_EVENT_REPLICATION_SLOT_DROP : event_name = "ReplicationSlotDrop" ; break ; case <S2SV_ModStart> event_name = "SyncRep" <S2SV_ModEnd> ; break ; |
1,995 | CWE-000 static void http_basic_cb ( struct evhttp_request * req , void * arg ) { struct evbuffer * evb = evbuffer_new ( ) ; struct evhttp_connection * evcon ; int empty = evhttp_find_header ( evhttp_request_get_input_headers ( req ) , "Empty" ) != NULL ; <S2SV_StartBug> event_debug ( ( "%s:<S2SV_blank>called\\n" , __func__ ) ) ; <S2SV_EndBug> evbuffer_add_printf ( evb , BASIC_REQUEST_BODY ) ; evcon = evhttp_request_get_connection ( req ) ; tt_assert ( evhttp_connection_get_server ( evcon ) == arg ) ; { const struct sockaddr * sa ; char addrbuf [ 128 ] ; sa = evhttp_connection_get_addr ( evcon ) ; tt_assert ( sa ) ; if ( sa -> sa_family == AF_INET ) { evutil_format_sockaddr_port_ ( ( struct sockaddr * ) sa , addrbuf , sizeof ( addrbuf ) ) ; tt_assert ( ! strncmp ( addrbuf , "127.0.0.1:" , strlen ( "127.0.0.1:" ) ) ) ; } else if ( sa -> sa_family == AF_INET6 ) { evutil_format_sockaddr_port_ ( ( struct sockaddr * ) sa , addrbuf , sizeof ( addrbuf ) ) ; tt_assert ( ! strncmp ( addrbuf , "[::1]:" , strlen ( "[::1]:" ) ) ) ; } else { tt_fail_msg ( "Unsupported<S2SV_blank>family" ) ; } } { const char * multi = evhttp_find_header ( evhttp_request_get_input_headers ( req ) , "X-Multi" ) ; if ( multi ) { found_multi = ! strcmp ( multi , "aaaaaaaa<S2SV_blank>a<S2SV_blank>END" ) ; if ( strcmp ( "END" , multi + strlen ( multi ) - 3 ) == 0 ) test_ok ++ ; if ( evhttp_find_header ( evhttp_request_get_input_headers ( req ) , "X-Last" ) ) test_ok ++ ; } } { const char * multi2 = evhttp_find_header ( evhttp_request_get_input_headers ( req ) , "X-Multi-Extra-WS" ) ; if ( multi2 ) { found_multi2 = ! strcmp ( multi2 , "libevent<S2SV_blank>2.1" ) ; } } if ( evhttp_find_header ( evhttp_request_get_input_headers ( req ) , "X-Negative" ) ) evhttp_add_header ( evhttp_request_get_output_headers ( req ) , "Content-Length" , "-100" ) ; evhttp_send_reply ( req , HTTP_OK , "Everything<S2SV_blank>is<S2SV_blank>fine" , ! empty ? evb : NULL ) ; end : evbuffer_free ( evb ) ; } | <S2SV_ModStart> != NULL ; TT_BLATHER <S2SV_ModEnd> ( ( "%s:<S2SV_blank>called\\n" |
1,996 | CWE-000 SDL_Surface * SDLTest_ImageBlitAlpha ( ) { SDL_Surface * surface = SDL_CreateRGBSurfaceFrom ( ( void * ) SDLTest_imageBlitAlpha . pixel_data , SDLTest_imageBlitAlpha . width , SDLTest_imageBlitAlpha . height , SDLTest_imageBlitAlpha . bytes_per_pixel * 8 , SDLTest_imageBlitAlpha . width * SDLTest_imageBlitAlpha . bytes_per_pixel , # if ( SDL_BYTEORDER == SDL_BIG_ENDIAN ) <S2SV_StartBug> 0xff000000 , <S2SV_EndBug> 0x00ff0000 , 0x0000ff00 , <S2SV_StartBug> 0x000000ff <S2SV_EndBug> # else 0x000000ff , 0x0000ff00 , 0x00ff0000 , 0xff000000 # endif ) ; return surface ; } | <S2SV_ModStart> == SDL_BIG_ENDIAN ) <S2SV_ModEnd> 0x00ff0000 , 0x0000ff00 <S2SV_ModStart> 0x0000ff00 , 0x000000ff , 0x00000000 |
1,997 | CWE-000 void TriggerStuff ( void ) { touchplatetype * temp ; int i , touchcomplete , j ; int playeron ; <S2SV_StartBug> void ( * tempact ) ( int ) ; <S2SV_EndBug> boolean wallmessage , doormessage , columnmessage ; for ( i = 0 ; i < lasttouch ; i ++ ) { playeron = false ; for ( j = 0 ; j < numplayers ; j ++ ) { if ( i == touchindices [ PLAYER [ j ] -> tilex ] [ PLAYER [ j ] -> tiley ] - 1 ) { playeron = true ; break ; } } if ( ! TRIGGER [ i ] ) continue ; else if ( touchplate [ i ] -> complete ) { if ( ! playeron ) TRIGGER [ i ] = 0 ; continue ; } if ( touchplate [ i ] -> done ) { if ( ! playeron ) { for ( temp = touchplate [ i ] ; temp ; temp = temp -> nextaction ) temp -> triggered = false ; TRIGGER [ i ] = 0 ; touchplate [ i ] -> done = false ; } } else { wallmessage = false ; doormessage = false ; columnmessage = false ; for ( temp = touchplate [ i ] ; temp ; temp = temp -> nextaction ) { if ( temp -> action && ( ! temp -> triggered ) ) { if ( ! temp -> ticcount ) { temp -> action ( temp -> whichobj ) ; if ( temp -> action == ActivateMoveWall ) { int tilex , tiley ; tilex = pwallobjlist [ temp -> whichobj ] -> tilex ; tiley = pwallobjlist [ temp -> whichobj ] -> tiley ; tilemap [ tilex ] [ tiley ] = 0 ; } if ( gamestate . difficulty == gd_baby ) { DisplayMessageForAction ( temp , & wallmessage , & doormessage , & columnmessage ) ; } tempact = temp -> action ; temp -> action = temp -> swapaction ; temp -> swapaction = tempact ; temp -> ticcount = temp -> tictime ; temp -> triggered = true ; } else temp -> ticcount -- ; } } touchcomplete = 1 ; for ( temp = touchplate [ i ] ; temp ; temp = temp -> nextaction ) { if ( temp -> action ) { touchcomplete = 0 ; break ; } } if ( touchcomplete ) touchplate [ i ] -> complete = 1 ; else { touchplate [ i ] -> done = true ; for ( temp = touchplate [ i ] ; temp ; temp = temp -> nextaction ) { if ( temp -> action && ( ! temp -> triggered ) ) { touchplate [ i ] -> done = false ; break ; } } } } } } | <S2SV_ModStart> tempact ) ( long <S2SV_ModEnd> ) ; boolean |
1,998 | CWE-000 static int _core_if ( mb_interpreter_t * s , void * * l ) { int result = MB_FUNC_OK ; _ls_node_t * ast = 0 ; _object_t * val = 0 ; _object_t * obj = 0 ; bool_t multi_line = false ; bool_t skip = false ; _running_context_t * running = 0 ; mb_assert ( s && l ) ; running = s -> running_context ; ast = ( _ls_node_t * ) * l ; ast = ast -> next ; val = _create_object ( ) ; _elseif : _MAKE_NIL ( val ) ; result = _calc_expression ( s , & ast , & val ) ; if ( result != MB_FUNC_OK ) goto _exit ; obj = ( _object_t * ) ast -> data ; if ( val -> data . integer ) { skip = true ; if ( ! _IS_FUNC ( obj , _core_then ) ) { _handle_error_on_obj ( s , SE_RN_INTEGER_EXPECTED , s -> source_file , DON ( ast ) , MB_FUNC_ERR , _exit , result ) ; } if ( ast && ast -> next && _IS_EOS ( ast -> next -> data ) ) multi_line = true ; else s -> skip_to_eoi = _ls_back ( s -> sub_stack ) ; do { ast = ast -> next ; while ( ast && _IS_EOS ( ast -> data ) ) ast = ast -> next ; if ( ast && _IS_FUNC ( ast -> data , _core_endif ) ) { ast = ast -> prev ; break ; } <S2SV_StartBug> if ( multi_line && ast && _IS_FUNC ( ast -> data , _core_elseif ) ) <S2SV_EndBug> break ; result = _execute_statement ( s , & ast , true ) ; if ( result != MB_FUNC_OK ) goto _exit ; if ( ast ) ast = ast -> prev ; } while ( ast && ( ( ! multi_line && _IS_SEP ( ast -> data , ':' ) ) || ( multi_line && ast -> next && ( ! _IS_FUNC ( ast -> next -> data , _core_elseif ) && ! _IS_FUNC ( ast -> next -> data , _core_else ) && ! _IS_FUNC ( ast -> next -> data , _core_endif ) ) ) ) ) ; if ( ! ast ) goto _exit ; obj = ( _object_t * ) ast -> data ; if ( obj -> type != _DT_EOS ) { s -> skip_to_eoi = 0 ; result = _skip_to ( s , & ast , 0 , _DT_EOS ) ; if ( result != MB_FUNC_OK ) goto _exit ; } } else { if ( ast && ast -> next && _IS_EOS ( ast -> next -> data ) ) { multi_line = true ; _skip_if_chunk ( s , & ast ) ; } if ( multi_line && ast && _IS_FUNC ( ast -> data , _core_elseif ) ) { ast = ast -> next ; goto _elseif ; } if ( multi_line && ast && _IS_FUNC ( ast -> data , _core_endif ) ) goto _exit ; result = _skip_to ( s , & ast , _core_else , _DT_EOS ) ; if ( result != MB_FUNC_OK ) goto _exit ; obj = ( _object_t * ) ast -> data ; if ( obj -> type != _DT_EOS ) { skip = true ; if ( ! _IS_FUNC ( obj , _core_else ) ) { _handle_error_on_obj ( s , SE_RN_ELSE_EXPECTED , s -> source_file , DON ( ast ) , MB_FUNC_ERR , _exit , result ) ; } do { _ls_node_t * la = 0 ; la = ast = ast -> next ; while ( ast && _IS_EOS ( ast -> data ) ) { ast = ast -> next ; if ( ast ) la = ast ; } if ( ! ast ) { mb_get_last_error ( s ) ; _handle_error_on_obj ( s , SE_RN_ENDIF_EXPECTED , s -> source_file , DON ( la ) , MB_FUNC_ERR , _exit , result ) ; } if ( ast && _IS_FUNC ( ast -> data , _core_endif ) ) { ast = ast -> prev ; break ; } result = _execute_statement ( s , & ast , true ) ; if ( result != MB_FUNC_OK ) goto _exit ; if ( ast ) ast = ast -> prev ; } while ( ast && ( ( ! multi_line && _IS_SEP ( ast -> data , ':' ) ) || ( multi_line && ! _IS_FUNC ( ast -> next -> data , _core_endif ) ) ) ) ; } } _exit : if ( result == MB_SUB_RETURN ) { if ( ast ) ast = ast -> prev ; } else { if ( multi_line ) { int ret = MB_FUNC_OK ; if ( skip ) ret = _skip_struct ( s , & ast , _core_if , _core_endif ) ; if ( result != MB_FUNC_END && result != MB_LOOP_BREAK && result != MB_LOOP_CONTINUE && result != MB_SUB_RETURN ) { if ( ret != MB_FUNC_OK ) result = ret ; } } } * l = ast ; if ( val -> type != _DT_UNKNOWN ) _destroy_object ( val , 0 ) ; return result ; } | <S2SV_ModStart> && ast && ( _IS_FUNC ( ast -> data , _core_else ) || <S2SV_ModStart> data , _core_elseif ) |
1,999 | CWE-000 static void CopyInFilteredOrder ( NFBSP_LoaderConfig_t * config , size_t filteredItemCount ) { LoadModelItemGroupPair_t pair = ItemGroupPair ( Resources -> loadModel , config -> loadModelItemGroup ) ; size_t originalItemCount = ProcessorItemInfo [ config -> processorId ] . itemCount ; size_t * filterIndices = ProcessorFilterIndices [ config -> processorId ] ; qboolean * copied = ( qboolean * ) Mem_Alloc ( Resources -> loadModel -> mempool , filteredItemCount * sizeof ( qboolean ) ) ; byte * sourceData = ProcessorPrototypeItems [ config -> processorId ] ; size_t sourceItemSize = ProcessorItemInfo [ config -> processorId ] . sizeOfItem ; byte * targetData = ( byte * ) ( * pair . itemData ) ; size_t targetItemSize = NFBSP_LoadModelItemSize [ config -> loadModelItemGroup ] ; size_t index ; Q_memset ( copied , 0 , filteredItemCount * sizeof ( qboolean ) ) ; if ( targetItemSize < 1 ) { targetItemSize = sourceItemSize ; } ASSERT ( sourceItemSize == targetItemSize ) ; for ( index = 0 ; index < originalItemCount ; ++ index ) { size_t remappedIndex = filterIndices ? filterIndices [ index ] : index ; if ( remappedIndex == NFBSP_LOADERCONFIG_NOT_APPLICABLE ) { continue ; } if ( remappedIndex > filteredItemCount ) { <S2SV_StartBug> Host_Error ( "NFBSP_Loader<S2SV_blank>(%s):<S2SV_blank>Loadmodel<S2SV_blank>group<S2SV_blank>%lu<S2SV_blank>remapped<S2SV_blank>index<S2SV_blank>%lu<S2SV_blank>was<S2SV_blank>out<S2SV_blank>of<S2SV_blank>expected<S2SV_blank>range<S2SV_blank>(0-%lu)." , <S2SV_EndBug> config -> debugName , config -> loadModelItemGroup , remappedIndex , <S2SV_StartBug> filteredItemCount - 1 ) ; <S2SV_EndBug> } if ( copied [ remappedIndex ] ) { Host_Error ( "NFBSP_Loader<S2SV_blank>(%s):<S2SV_blank>Loadmodel<S2SV_blank>group<S2SV_blank>%lu<S2SV_blank>remapped<S2SV_blank>index<S2SV_blank>%lu<S2SV_blank>conflicts<S2SV_blank>with<S2SV_blank>previously<S2SV_blank>copied<S2SV_blank>data." , config -> debugName , config -> loadModelItemGroup , remappedIndex ) ; } Q_memcpy ( targetData + ( remappedIndex * targetItemSize ) , sourceData + ( index * sourceItemSize ) , targetItemSize ) ; copied [ remappedIndex ] = true ; } for ( index = 0 ; index < filteredItemCount ; ++ index ) { if ( ! copied [ index ] ) { <S2SV_StartBug> Host_Error ( "NFBSP_Loader<S2SV_blank>(%s):<S2SV_blank>Loadmodel<S2SV_blank>group<S2SV_blank>%lu<S2SV_blank>index<S2SV_blank>%lu<S2SV_blank>did<S2SV_blank>not<S2SV_blank>receive<S2SV_blank>any<S2SV_blank>copied<S2SV_blank>data." , <S2SV_EndBug> config -> debugName , config -> loadModelItemGroup , index ) ; } } Mem_Free ( copied ) ; } | <S2SV_ModStart> filteredItemCount ) { FATAL_ERROR ( "Loadmodel<S2SV_blank>remapped<S2SV_blank>index<S2SV_blank>%lu<S2SV_blank>was<S2SV_blank>out<S2SV_blank>of<S2SV_blank>expected<S2SV_blank>range<S2SV_blank>(0-%lu)<S2SV_blank>for<S2SV_blank>item<S2SV_blank>group<S2SV_blank>\'%s\'." , config -> processorId <S2SV_ModEnd> , remappedIndex , <S2SV_ModStart> filteredItemCount - 1 , NFBSP_LoadModelItemGroupName [ config -> loadModelItemGroup ] ) ; } if ( copied [ remappedIndex ] ) { FATAL_ERROR ( "Cannot<S2SV_blank>copy<S2SV_blank>data<S2SV_blank>to<S2SV_blank>index<S2SV_blank>%lu<S2SV_blank>in<S2SV_blank>item<S2SV_blank>group<S2SV_blank>\'%s\',<S2SV_blank>as<S2SV_blank>data<S2SV_blank>has<S2SV_blank>already<S2SV_blank>been<S2SV_blank>copied<S2SV_blank>to<S2SV_blank>that<S2SV_blank>location." , config -> processorId , remappedIndex , NFBSP_LoadModelItemGroupName [ config -> loadModelItemGroup ] <S2SV_ModEnd> ) ; } <S2SV_ModStart> ] ) { FATAL_ERROR ( "Loadmodel<S2SV_blank>index<S2SV_blank>%lu<S2SV_blank>in<S2SV_blank>item<S2SV_blank>group<S2SV_blank>\'%s\'<S2SV_blank>did<S2SV_blank>not<S2SV_blank>receive<S2SV_blank>any<S2SV_blank>copied<S2SV_blank>data." , config -> processorId , index , NFBSP_LoadModelItemGroupName [ config -> loadModelItemGroup ] <S2SV_ModEnd> ) ; } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.