Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
2,100 | CWE-000 <S2SV_StartBug> int isCloseTo ( float reqTemp , float roomTemp ) { <S2SV_EndBug> return abs ( reqTemp - roomTemp ) <= MAX_RANGE ? 1 : 0 ; } | <S2SV_ModStart> ( float reqTemp <S2SV_ModEnd> ) { return |
2,101 | CWE-000 void add_sig ( int sig ) { struct sigaction sa ; memset ( & sa , '\\0' , sizeof ( sa ) ) ; sa . sa_handler = sig_action ; sa . sa_flags |= SA_RESTART ; <S2SV_StartBug> sigfillset ( & sa . sa_mask ) ; <S2SV_EndBug> if ( - 1 == sigaction ( sig , & sa , NULL ) ) { printf ( "add<S2SV_blank>sig<S2SV_blank>failed\\n" ) ; } } | <S2SV_ModStart> |= SA_RESTART ; if ( - 1 == <S2SV_ModStart> . sa_mask ) ) { printf ( "sig<S2SV_blank>fillset<S2SV_blank>errolr\\n" ) ; } <S2SV_ModEnd> if ( - |
2,102 | CWE-000 <S2SV_StartBug> int <S2SV_EndBug> main ( int argc , char * * argv ) { BrainInt result = EXIT_FAILURE ; const BrainNetwork network = new_network_from_context ( TEST_CREATE_NETWORK ) ; if ( network != NULL ) { BrainLayer layer = NULL ; BrainUint number_of_layers = 0 ; do { layer = get_network_layer ( network , number_of_layers ) ; if ( layer ) { BrainUint number_of_neurons = get_layer_number_of_neuron ( layer ) ; if ( number_of_neurons == NUMBER_OF_NEURONS [ number_of_layers ] ) { BrainUint index = 0 ; for ( index = 0 ; index < number_of_neurons ; ++ index ) { const BrainNeuron neuron = get_layer_neuron ( layer , index ) ; if ( neuron != NULL ) { const BrainUint number_of_inputs = get_neuron_number_of_input ( neuron ) ; if ( number_of_inputs != NUMBER_OF_INPUTS [ number_of_layers ] ) { BRAIN_CRITICAL ( "%s" , "Number<S2SV_blank>of<S2SV_blank>inputs<S2SV_blank>is<S2SV_blank>not<S2SV_blank>valid" ) ; break ; } } else { BRAIN_CRITICAL ( "%s" , "Neuron<S2SV_blank>is<S2SV_blank>not<S2SV_blank>valid" ) ; break ; } } ++ number_of_layers ; } else { BRAIN_CRITICAL ( "%s" , "Number<S2SV_blank>of<S2SV_blank>neurons<S2SV_blank>is<S2SV_blank>not<S2SV_blank>valid" ) ; } } } while ( layer != NULL ) ; if ( number_of_layers == NUMBER_OF_LAYERS ) { result = EXIT_SUCCESS ; } delete_network ( network ) ; } return result ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> BrainInt <S2SV_ModEnd> main ( int |
2,103 | CWE-000 unsigned char edidCheckMonitorInputSignal ( unsigned char * pEDIDBuffer ) { <S2SV_StartBug> unsigned char version ; <S2SV_EndBug> unsigned short index ; version = edidGetVersion ( pEDIDBuffer , ( unsigned char * ) 0 ) ; if ( version == 1 ) return ( unsigned char ) ( ( edid_version_1_t * ) pEDIDBuffer ) -> videoInputDefinition . analogSignal . inputSignal ; return 0 ; } | <S2SV_ModStart> unsigned char version <S2SV_ModEnd> ; version = |
2,104 | CWE-000 static uint32_t s3c2410_usbdev_read ( void * opaque , target_phys_addr_t offset ) { s3c2410_usbdev_t * usbdev = opaque ; s3c2410_offset_t * reg ; # ifdef QEMU_OLD offset -= S3C2410_USBDEV_BASE ; # endif if ( ! S3C2410_OFFSET_OK ( usbdev , offset ) ) { return ~ ( 0 ) ; } reg = S3C2410_OFFSET_ENTRY ( usbdev , offset ) ; # ifdef DEBUG_S3C2410_USBDEV <S2SV_StartBug> printf ( "read<S2SV_blank><S2SV_blank>%s<S2SV_blank>[%08x]<S2SV_blank>%s<S2SV_blank>[%08x]<S2SV_blank>data<S2SV_blank>%08x\\n" , <S2SV_EndBug> "s3c2410-usbdev" , S3C2410_USBDEV_BASE , <S2SV_StartBug> reg -> name , offset , * ( reg -> datap ) ) ; <S2SV_EndBug> # endif return * ( reg -> datap ) ; } | <S2SV_ModStart> DEBUG_S3C2410_USBDEV printf ( "read<S2SV_blank><S2SV_blank>%s<S2SV_blank>[%08x]<S2SV_blank>%s<S2SV_blank>[%08lx]<S2SV_blank>data<S2SV_blank>%08x\\n" <S2SV_ModEnd> , "s3c2410-usbdev" , <S2SV_ModStart> -> name , ( unsigned long ) |
2,105 | CWE-000 static boolean_t sccp_wrapper_asterisk115_setWriteFormat ( constChannelPtr channel , skinny_codec_t codec ) { if ( ! channel ) { return FALSE ; } struct ast_format * ast_format = sccp_asterisk115_skinny2ast_format ( codec ) ; <S2SV_StartBug> if ( ast_format != ast_format_none ) { <S2SV_EndBug> struct ast_format_cap * cap = ast_format_cap_alloc ( AST_FORMAT_CAP_FLAG_DEFAULT ) ; if ( ! cap ) { ao2_cleanup ( cap ) ; return FALSE ; } unsigned int framing = ast_format_get_default_ms ( ast_format ) ; ast_format_cap_append ( cap , ast_format , framing ) ; <S2SV_StartBug> ast_set_write_format_from_cap ( channel -> owner , cap ) ; <S2SV_EndBug> ao2_ref ( cap , - 1 ) ; cap = NULL ; } else { return FALSE ; } if ( NULL != channel -> rtp . audio . instance ) { ast_rtp_instance_set_write_format ( channel -> rtp . audio . instance , ast_format ) ; } return TRUE ; } | <S2SV_ModStart> codec ) ; ast_set_write_format <S2SV_ModEnd> ( channel -> <S2SV_ModStart> -> owner , ast_format ) ; <S2SV_ModEnd> if ( NULL |
2,106 | CWE-000 static int __handle_mm_fault ( struct mm_struct * mm , struct vm_area_struct * vma , unsigned long address , unsigned int flags ) { pgd_t * pgd ; pud_t * pud ; pmd_t * pmd ; pte_t * pte ; if ( unlikely ( is_vm_hugetlb_page ( vma ) ) ) return hugetlb_fault ( mm , vma , address , flags ) ; retry : pgd = pgd_offset ( mm , address ) ; pud = pud_alloc ( mm , pgd , address ) ; if ( ! pud ) return VM_FAULT_OOM ; pmd = pmd_alloc ( mm , pud , address ) ; if ( ! pmd ) return VM_FAULT_OOM ; if ( pmd_none ( * pmd ) && transparent_hugepage_enabled ( vma ) ) { if ( ! vma -> vm_ops ) return do_huge_pmd_anonymous_page ( mm , vma , address , pmd , flags ) ; } else { pmd_t orig_pmd = * pmd ; int ret ; barrier ( ) ; if ( pmd_trans_huge ( orig_pmd ) ) { unsigned int dirty = flags & FAULT_FLAG_WRITE ; if ( pmd_trans_splitting ( orig_pmd ) ) return 0 ; if ( pmd_numa ( orig_pmd ) ) return do_huge_pmd_numa_page ( mm , vma , address , orig_pmd , pmd ) ; if ( dirty && ! pmd_write ( orig_pmd ) ) { ret = do_huge_pmd_wp_page ( mm , vma , address , pmd , orig_pmd ) ; if ( unlikely ( ret & VM_FAULT_OOM ) ) goto retry ; return ret ; } else { huge_pmd_set_accessed ( mm , vma , address , pmd , orig_pmd , dirty ) ; } return 0 ; } } if ( pmd_numa ( * pmd ) ) return do_pmd_numa_page ( mm , vma , address , pmd ) ; if ( unlikely ( pmd_none ( * pmd ) ) && unlikely ( __pte_alloc ( mm , vma , pmd , address ) ) ) return VM_FAULT_OOM ; <S2SV_StartBug> if ( unlikely ( pmd_trans_huge ( * pmd ) ) ) <S2SV_EndBug> return 0 ; pte = pte_offset_map ( pmd , address ) ; return handle_pte_fault ( mm , vma , address , pte , pmd , flags ) ; } | <S2SV_ModStart> ( unlikely ( pmd_trans_unstable ( <S2SV_ModEnd> pmd ) ) |
2,107 | CWE-000 static __be32 * encode_entryplus_baggage ( struct nfsd3_readdirres * cd , __be32 * p , const char * name , int namlen ) { struct svc_fh fh ; <S2SV_StartBug> int err ; <S2SV_EndBug> fh_init ( & fh , NFS3_FHSIZE ) ; err = compose_entry_fh ( cd , & fh , name , namlen ) ; if ( err ) { * p ++ = 0 ; * p ++ = 0 ; goto out ; } p = encode_post_op_attr ( cd -> rqstp , p , & fh ) ; * p ++ = xdr_one ; p = encode_fh ( p , & fh ) ; out : fh_put ( & fh ) ; return p ; } | <S2SV_ModStart> svc_fh fh ; __be32 <S2SV_ModEnd> err ; fh_init |
2,108 | CWE-000 int parseCommandAuth ( clientDataType * theClientData ) { int i , theAuthIndex ; char theAuth [ FTP_COMMAND_ELABORATE_CHAR_BUFFER ] ; memset ( theAuth , 0 , FTP_COMMAND_ELABORATE_CHAR_BUFFER ) ; theAuthIndex = 0 ; for ( i = strlen ( "AUTH" ) + 1 ; i < theClientData -> commandIndex ; i ++ ) { if ( theClientData -> theCommandReceived [ i ] == '\\r' || <S2SV_StartBug> theClientData -> theCommandReceived [ i ] == '\\n' ) <S2SV_EndBug> { break ; } if ( theClientData -> theCommandReceived [ i ] != '<S2SV_blank>' && theAuthIndex < FTP_COMMAND_ELABORATE_CHAR_BUFFER ) { theAuth [ theAuthIndex ++ ] = theClientData -> theCommandReceived [ i ] ; } } <S2SV_StartBug> printf ( "\\n<S2SV_blank>The<S2SV_blank>Auth<S2SV_blank>is:<S2SV_blank>%s" , theAuth ) ; <S2SV_EndBug> char * theResponse = "502<S2SV_blank>Auth<S2SV_blank>command<S2SV_blank>is<S2SV_blank>not<S2SV_blank>supported.\\r\\n" ; write ( theClientData -> socketDescriptor , theResponse , strlen ( theResponse ) ) ; return 1 ; } | <S2SV_ModStart> i ] == '\\0' || theClientData -> theCommandReceived [ i ] == <S2SV_ModStart> ; } } printTimeStamp ( ) ; printf ( "The<S2SV_blank>Auth<S2SV_blank>is:<S2SV_blank>%s" <S2SV_ModEnd> , theAuth ) |
2,109 | CWE-000 void * writer ( void * args ) { cargs_t * cargs = ( cargs_t * ) args ; spec_t * spec = ( spec_t * ) cargs -> spec ; int blkcnt = spec -> blockcnt ; int blklen = spec -> blocklen ; int num_blocks = ( blkcnt - 16 ) ; ISTGT_LU_CMD_Ptr lu_cmd ; int rc , count = 0 ; uint64_t blk_offset , offset ; int len_in_blocks , len ; struct timespec now , start , prev ; pthread_mutex_t * mtx = cargs -> mtx ; pthread_cond_t * cv = cargs -> cv ; int * cnt = cargs -> count ; SBC_OPCODE opcode ; clock_gettime ( CLOCK_MONOTONIC , & now ) ; srandom ( now . tv_sec ) ; snprintf ( tinfo , 50 , "mcwrite%d" , cargs -> workerid ) ; prctl ( PR_SET_NAME , tinfo , 0 , 0 , 0 ) ; clock_gettime ( CLOCK_MONOTONIC , & start ) ; clock_gettime ( CLOCK_MONOTONIC , & prev ) ; lu_cmd = ( ISTGT_LU_CMD_Ptr ) malloc ( sizeof ( ISTGT_LU_CMD ) ) ; memset ( lu_cmd , 0 , sizeof ( ISTGT_LU_CMD ) ) ; while ( 1 ) { check_settings ( spec ) ; opcode = SBC_WRITE_16 ; blk_offset = random ( ) % num_blocks ; offset = blk_offset * blklen ; len_in_blocks = random ( ) % 15 ; len = len_in_blocks * blklen ; if ( ( random ( ) % 200 ) == 0 ) { opcode = SBC_SYNCHRONIZE_CACHE_16 ; len = 0 ; } build_cmd ( cargs , lu_cmd , opcode , len ) ; rc = replicate ( spec , lu_cmd , offset , len ) ; if ( rc != len && ! ignore_io_error ) goto end ; count ++ ; clock_gettime ( CLOCK_MONOTONIC , & now ) ; if ( now . tv_sec - start . tv_sec > 120 ) break ; if ( now . tv_sec - prev . tv_sec > 1 ) { prev = now ; REPLICA_ERRLOG ( "wrote<S2SV_blank>%d<S2SV_blank>from<S2SV_blank>%s\\n" , count , tinfo ) ; } } end : <S2SV_StartBug> REPLICA_ERRLOG ( "exiting<S2SV_blank>wrote<S2SV_blank>%d<S2SV_blank>from<S2SV_blank>%s\\n" , count , tinfo ) ; <S2SV_EndBug> MTX_LOCK ( mtx ) ; * cnt = * cnt + 1 ; pthread_cond_signal ( cv ) ; MTX_UNLOCK ( mtx ) ; return NULL ; } | <S2SV_ModStart> } end : free ( lu_cmd ) ; |
2,110 | CWE-000 UBYTE getChar ( void ) { if ( FERR || OERR ) { CREN = 0 ; NOP ( ) ; CREN = 1 ; } <S2SV_StartBug> while ( ! RCIF ) ; <S2SV_EndBug> return RCREG ; } | <S2SV_ModStart> 1 ; } set_timer_counter_only_getChar ( 0 ) ; <S2SV_ModStart> ! RCIF ) { if ( get_timer_counter_only_getChar ( ) > 1000 ) break ; } <S2SV_ModEnd> return RCREG ; |
2,111 | CWE-000 API int lyd_merge ( struct lyd_node * target , const struct lyd_node * source , int options ) { struct lyd_node * node = NULL , * node2 , * trg_merge_start , * src_merge_start = NULL ; const struct lyd_node * iter ; struct lys_node * src_snode ; <S2SV_StartBug> int i , src_depth , depth , first_iter , ret , dflt = 1 ; <S2SV_EndBug> if ( ! target || ! source || ( target -> schema -> module -> ctx != source -> schema -> module -> ctx ) ) { ly_errno = LY_EINVAL ; return - 1 ; } <S2SV_StartBug> if ( lys_parent ( target -> schema ) ) { <S2SV_EndBug> LOGERR ( LY_EINVAL , "Target<S2SV_blank>not<S2SV_blank>a<S2SV_blank>top-level<S2SV_blank>data<S2SV_blank>tree." ) ; return - 1 ; } for ( src_snode = source -> schema , src_depth = 0 ; lys_parent ( src_snode ) ; src_snode = lys_parent ( src_snode ) , ++ src_depth ) ; trg_merge_start = target ; depth = 0 ; first_iter = 1 ; if ( src_depth ) { if ( options & LYD_OPT_NOSIBLINGS ) { dflt = source -> dflt ; } else { LY_TREE_FOR ( source , iter ) { if ( ! iter -> dflt ) { dflt = 0 ; break ; } } } } while ( 1 ) { do { for ( src_snode = source -> schema , i = 0 ; i < src_depth - depth ; src_snode = lys_parent ( src_snode ) , ++ i ) ; ++ depth ; } while ( src_snode != source -> schema && ( src_snode -> nodetype & ( LYS_CHOICE | LYS_CASE | LYS_USES ) ) ) ; if ( src_snode == source -> schema ) { break ; } if ( src_snode -> nodetype != LYS_CONTAINER ) { LOGERR ( LY_EINVAL , "Cannot<S2SV_blank>create<S2SV_blank>%s<S2SV_blank>\\"%s\\"<S2SV_blank>for<S2SV_blank>the<S2SV_blank>merge." , strnodetype ( src_snode -> nodetype ) , src_snode -> name ) ; goto error ; } if ( ! src_merge_start ) { if ( first_iter ) { node = trg_merge_start ; first_iter = 0 ; } else { node = trg_merge_start -> child ; } LY_TREE_FOR ( node , node ) { if ( node -> schema == src_snode ) { trg_merge_start = node ; break ; } } } if ( ! node ) { src_merge_start = _lyd_new ( src_merge_start , src_snode , dflt ) ; } } if ( options & LYD_OPT_DESTRUCT ) { node = ( struct lyd_node * ) source ; if ( ( node -> prev != node ) && ( options & LYD_OPT_NOSIBLINGS ) ) { node2 = node -> prev ; lyd_unlink ( node ) ; lyd_free_withsiblings ( node2 ) ; } } else { node = NULL ; for ( ; source ; source = source -> next ) { node2 = lyd_dup ( source , 1 ) ; if ( ! node2 ) { goto error ; } if ( node ) { if ( lyd_insert_after ( node -> prev , node2 ) ) { goto error ; } } else { node = node2 ; } if ( options & LYD_OPT_NOSIBLINGS ) { break ; } } } if ( src_merge_start ) { src_merge_start -> child = node ; LY_TREE_FOR ( node , node ) { node -> parent = src_merge_start ; } } else { src_merge_start = node ; } if ( ! first_iter ) { ret = lyd_merge_parent_children ( trg_merge_start , src_merge_start , options ) ; } else { ret = lyd_merge_siblings ( trg_merge_start , src_merge_start , options ) ; } if ( target -> schema -> nodetype == LYS_RPC ) { lyd_schema_sort ( target , 1 ) ; } return ret ; error : lyd_free_withsiblings ( node ) ; lyd_free_withsiblings ( src_merge_start ) ; return - 1 ; } | <S2SV_ModStart> dflt = 1 ; const struct lys_node * parent = NULL <S2SV_ModStart> 1 ; } parent = <S2SV_ModEnd> lys_parent ( target <S2SV_ModStart> -> schema ) ; while ( parent && ( parent -> nodetype == LYS_USES ) ) { parent = lys_parent ( parent ) ; } if ( parent |
2,112 | CWE-000 GHashTable * MRC_fixed_rate_empty ( SHARDS * shards ) { GList * keys = g_hash_table_get_keys ( shards -> dist_histogram ) ; keys = g_list_sort ( keys , ( GCompareFunc ) intcmp ) ; GList * tmp_keys = keys ; GList * remove_link = NULL ; GHashTable * tabla = g_hash_table_new_full ( g_int_hash , g_int_equal , ( GDestroyNotify ) free , ( GDestroyNotify ) free ) ; double * missrate = NULL ; int * cache_size = NULL ; unsigned int part_sum = 0 ; unsigned int total_sum = * ( int * ) ( g_hash_table_lookup ( shards -> dist_histogram , keys -> data ) ) ; int hist_size = g_hash_table_size ( shards -> dist_histogram ) ; if ( hist_size > 1 ) { remove_link = keys ; keys = g_list_remove_link ( keys , remove_link ) ; g_hash_table_remove ( shards -> dist_histogram , remove_link -> data ) ; free ( remove_link -> data ) ; g_list_free ( remove_link ) ; while ( keys != NULL ) { missrate = malloc ( sizeof ( double ) ) ; part_sum = part_sum + * ( int * ) ( g_hash_table_lookup ( shards -> dist_histogram , keys -> data ) ) ; * missrate = ( double ) part_sum ; cache_size = ( keys -> data ) ; g_hash_table_insert ( tabla , cache_size , missrate ) ; remove_link = keys ; keys = g_list_remove_link ( keys , remove_link ) ; g_hash_table_remove ( shards -> dist_histogram , remove_link -> data ) ; g_list_free ( remove_link ) ; } keys = g_hash_table_get_keys ( tabla ) ; keys = g_list_sort ( keys , ( GCompareFunc ) intcmp ) ; total_sum = total_sum + part_sum ; missrate = NULL ; tmp_keys = keys ; while ( keys != NULL ) { missrate = g_hash_table_lookup ( tabla , keys -> data ) ; * missrate = 1.0 - ( * missrate / total_sum ) ; keys = keys -> next ; } } else if ( hist_size == 1 ) { cache_size = malloc ( sizeof ( int ) ) ; missrate = malloc ( sizeof ( double ) ) ; * cache_size = * ( int * ) ( keys -> data ) ; * missrate = 1.0 ; g_hash_table_insert ( tabla , cache_size , missrate ) ; <S2SV_StartBug> } else { <S2SV_EndBug> return NULL ; } g_list_free ( tmp_keys ) ; keys = g_hash_table_get_keys ( shards -> time_table ) ; g_hash_table_remove_all ( shards -> time_table ) ; g_list_free_full ( keys , ( GDestroyNotify ) free ) ; keys = NULL ; freetree ( shards -> dist_tree ) ; shards -> dist_tree = NULL ; shards -> total_objects = 0 ; shards -> num_obj = 0 ; return tabla ; } | <S2SV_ModStart> missrate ) ; remove_link = keys ; keys = g_list_remove_link ( keys , remove_link ) ; g_hash_table_remove ( shards -> dist_histogram , remove_link -> data ) ; free ( remove_link -> data ) ; g_list_free ( remove_link ) ; remove_link = NULL ; |
2,113 | CWE-000 char * ft_strncpy ( char * dst , const char * src , size_t len ) { <S2SV_StartBug> int i ; <S2SV_EndBug> i = - 1 ; <S2SV_StartBug> while ( len -- ) <S2SV_EndBug> dst [ i ] = src [ i ] ; dst [ i ] = '\\0' ; return ( dst ) ; } | <S2SV_ModStart> len ) { size_t <S2SV_ModEnd> i ; i <S2SV_ModStart> ; while ( ++ i < ( len ) <S2SV_ModEnd> ) dst [ |
2,114 | CWE-000 static int async_io ( struct async * as , int doread ) { int mfd = - 1 ; fd_set fsr ; fd_set fsw ; fd_set fse ; int dosomething = 0 ; struct timeval tval ; struct asfd * asfd ; static int s = 0 ; as -> now = time ( NULL ) ; if ( ! as -> last_time ) as -> last_time = as -> now ; if ( as -> doing_estimate ) goto end ; FD_ZERO ( & fsr ) ; FD_ZERO ( & fsw ) ; FD_ZERO ( & fse ) ; tval . tv_sec = as -> setsec ; tval . tv_usec = as -> setusec ; for ( asfd = as -> asfd ; asfd ; asfd = asfd -> next ) { if ( asfd -> attempt_reads ) asfd -> doread = doread ; else asfd -> doread = 0 ; asfd -> dowrite = 0 ; if ( doread ) { if ( asfd -> parse_readbuf ( asfd ) ) return asfd_problem ( asfd ) ; if ( asfd -> rbuf -> buf || asfd -> read_blocked_on_write ) asfd -> doread = 0 ; } if ( asfd -> writebuflen && ! asfd -> write_blocked_on_read ) asfd -> dowrite ++ ; if ( ! asfd -> doread && ! asfd -> dowrite ) continue ; add_fd_to_sets ( asfd -> fd , asfd -> doread ? & fsr : NULL , asfd -> dowrite ? & fsw : NULL , & fse , & mfd ) ; dosomething ++ ; } if ( ! dosomething ) goto end ; errno = 0 ; s = select ( mfd + 1 , & fsr , & fsw , & fse , & tval ) ; if ( errno == EAGAIN || errno == EINTR ) goto end ; if ( s < 0 ) { logp ( "select<S2SV_blank>error<S2SV_blank>in<S2SV_blank>%s:<S2SV_blank>%s\\n" , __func__ , strerror ( errno ) ) ; as -> last_time = as -> now ; return - 1 ; } for ( asfd = as -> asfd ; asfd ; asfd = asfd -> next ) { if ( FD_ISSET ( asfd -> fd , & fse ) ) { switch ( asfd -> fdtype ) { case ASFD_FD_SERVER_LISTEN_MAIN : case ASFD_FD_SERVER_LISTEN_STATUS : as -> last_time = as -> now ; return - 1 ; default : <S2SV_StartBug> logp ( "%s:<S2SV_blank>had<S2SV_blank>an<S2SV_blank>exception\\n" , <S2SV_EndBug> asfd -> desc ) ; <S2SV_StartBug> return asfd_problem ( asfd ) ; <S2SV_EndBug> } } if ( asfd -> doread && FD_ISSET ( asfd -> fd , & fsr ) ) { asfd -> network_timeout = asfd -> max_network_timeout ; switch ( asfd -> fdtype ) { case ASFD_FD_SERVER_LISTEN_MAIN : case ASFD_FD_SERVER_LISTEN_STATUS : asfd -> new_client ++ ; break ; default : if ( asfd -> do_read ( asfd ) || asfd -> parse_readbuf ( asfd ) ) return asfd_problem ( asfd ) ; break ; } } if ( asfd -> dowrite && FD_ISSET ( asfd -> fd , & fsw ) ) { asfd -> network_timeout = asfd -> max_network_timeout ; if ( asfd -> do_write ( asfd ) ) return asfd_problem ( asfd ) ; } if ( ( ! asfd -> doread || ! FD_ISSET ( asfd -> fd , & fsr ) ) && ( ! asfd -> dowrite || ! FD_ISSET ( asfd -> fd , & fsw ) ) ) { if ( ( as -> setsec || as -> setusec ) && asfd -> max_network_timeout > 0 && as -> now - as -> last_time > 0 && asfd -> network_timeout -- <= 0 ) { logp ( "%s:<S2SV_blank>no<S2SV_blank>activity<S2SV_blank>for<S2SV_blank>%d<S2SV_blank>seconds.\\n" , asfd -> desc , asfd -> max_network_timeout ) ; return asfd_problem ( asfd ) ; } } } end : as -> last_time = as -> now ; return 0 ; } | <S2SV_ModStart> ; default : # ifdef _AIX if ( strncmp ( asfd -> desc , "stats<S2SV_blank>file" , sizeof ( "stats<S2SV_blank>file" ) ) ) { <S2SV_ModStart> asfd ) ; } # else logp ( "%s:<S2SV_blank>had<S2SV_blank>an<S2SV_blank>exception\\n" , asfd -> desc ) ; return asfd_problem ( asfd ) ; # endif |
2,115 | CWE-000 static void gattlib_async_connect_ready_cb ( GObject * source_object , GAsyncResult * res , gpointer user_data ) { GError * error = NULL ; gatt_connection_t * connptr ; DEBUG_GATTLIB ( "gattlib_async_connect_ready_cb\\n" ) ; <S2SV_StartBug> if ( gattlib_async_global_state . connection_done_cb ) { <S2SV_EndBug> connptr = g_task_propagate_pointer ( G_TASK ( res ) , & error ) ; gattlib_async_connect_trigger_conn_cb ( connptr ) ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> "gattlib_async_connect_ready_cb\\n" ) ; <S2SV_ModEnd> connptr = g_task_propagate_pointer <S2SV_ModStart> ) ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
2,116 | CWE-000 static gboolean is_node_match_yx ( GNode * node , int y , int x ) { cell_data_t * data = CHUNK ( node ) ; GArray * coord = data -> coord ; if ( data -> str ) { message_assert ( coord -> len % 3 == 0 ) ; for ( int i = 0 ; i < coord -> len ; i += 3 ) { <S2SV_StartBug> int y1 = g_array_index ( coord , int , 0 ) ; <S2SV_EndBug> <S2SV_StartBug> int x1 = g_array_index ( coord , int , 1 ) ; <S2SV_EndBug> <S2SV_StartBug> int x2 = g_array_index ( coord , int , 2 ) ; <S2SV_EndBug> if ( y1 == y && x >= x1 && x < x2 ) { return TRUE ; } } return FALSE ; } else { message_assert ( coord -> len == 4 ) ; int y1 = g_array_index ( coord , int , 0 ) ; int x1 = g_array_index ( coord , int , 1 ) ; int y2 = g_array_index ( coord , int , 2 ) ; int x2 = g_array_index ( coord , int , 3 ) ; if ( y == y1 ) { if ( x >= x1 ) return TRUE ; else return FALSE ; } else if ( y == y2 ) { if ( x <= x2 ) { return TRUE ; } else { return FALSE ; } } else if ( y > y1 && y < y2 ) { return TRUE ; } else { return FALSE ; } } } | <S2SV_ModStart> , int , i + <S2SV_ModStart> , int , i + <S2SV_ModStart> , int , i + |
2,117 | CWE-000 void set_led ( ) { if ( screen_state ) { <S2SV_StartBug> PORTD = ( 1 << PORTD7 ) ; <S2SV_EndBug> <S2SV_StartBug> } else { <S2SV_EndBug> PORTD = ( 1 << PORTD6 ) ; } } | <S2SV_ModStart> ) { PORTD |= ( 1 << PORTD7 ) ; PORTD &= ~ ( 1 << PORTD6 ) ; } else { PORTD |= ( 1 << PORTD6 ) ; PORTD &= ~ <S2SV_ModEnd> ( 1 << <S2SV_ModStart> ) ; } <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
2,118 | CWE-000 static stbin_status_t stbin_exec_nvm_item_inv ( tU16 len , tUChar * msg , const stbin_req_msg_parms * parms_in ) { stbin_status_t result = STBIN_OK ; gnsslibid_t idx ; stbin_exec_nvm_item_inv_MAP ( req , msg , len , & result ) ; if ( result == STBIN_OK ) { <S2SV_StartBug> if ( ( req -> sat_id != 0U ) && ( ( req -> nvm_id == GNSS_NVMID_ALMANACS ) || ( req -> nvm_id == GNSS_NVMID_EPHEMERIDES ) ) ) <S2SV_EndBug> { idx = GNSS_NAV_SAT_ID_TO_GNSSLIB_ID ( req -> sat_id ) ; if ( idx != GNSSLIB_ID_NOT_VALID ) { if ( nvm_set_item_invalid ( req -> nvm_id , ( tInt ) ( 1U + idx ) ) == NVM_ERROR ) { result = STBIN_FAILED ; } } else { result = STBIN_FAILED ; } } else { if ( nvm_set_item_invalid ( req -> nvm_id , req -> item_number ) == NVM_ERROR ) { result = STBIN_FAILED ; } } } return result ; } | <S2SV_ModStart> -> nvm_id == 1 <S2SV_ModEnd> ) || ( <S2SV_ModStart> -> nvm_id == 2 <S2SV_ModEnd> ) ) ) |
2,119 | CWE-000 void _setup ( void ) { int ret = 0 ; hints = fi_allocinfo ( ) ; cr_assert ( hints , "fi_allocinfo<S2SV_blank>failed." ) ; <S2SV_StartBug> hints -> mode = mode_bits ; <S2SV_EndBug> hints -> fabric_attr -> prov_name = strdup ( "gni" ) ; ret = fi_getinfo ( fi_version ( ) , NULL , 0 , 0 , hints , & fi ) ; cr_assert_eq ( ret , FI_SUCCESS , "fi_getinfo<S2SV_blank>failed." ) ; ret = fi_fabric ( fi -> fabric_attr , & fab , NULL ) ; cr_assert_eq ( ret , FI_SUCCESS , "fi_fabric<S2SV_blank>failed." ) ; } | <S2SV_ModStart> mode = mode_bits ; hints -> domain_attr -> mr_mode = GNIX_DEFAULT_MR_MODE |
2,120 | CWE-000 static bool js_Spriteset_finalize ( jsal_ref_t * me , int num_args , bool is_ctor , int magic ) { spriteset_t * spriteset ; <S2SV_StartBug> spriteset = jsal_require_class_obj ( 0 , "ssSpriteset" ) ; <S2SV_EndBug> spriteset_unref ( spriteset ) ; return false ; } | <S2SV_ModStart> * spriteset ; jsal_push_this ( ) ; <S2SV_ModStart> = jsal_require_class_obj ( - 1 <S2SV_ModEnd> , "ssSpriteset" ) |
2,121 | CWE-000 void down_tongs ( uint8_t sonar_id ) { int max_speed , speed ; uint8_t dsn ; <S2SV_StartBug> if ( get_avg_distance ( sonar_id , 5 ) < 40 ) return ; <S2SV_EndBug> while ( ev3_tacho_init ( ) < 1 ) Sleep ( 1000 ) ; if ( ev3_search_tacho_plugged_in ( UP_DOWN_TONG_PORT , 0 , & dsn , 0 ) ) { set_tacho_stop_action_inx ( dsn , TACHO_HOLD ) ; get_tacho_max_speed ( dsn , & max_speed ) ; speed = ( int ) ( ( float ) max_speed * UP_DOWN_SPEED / 100.0 + 0.5 ) ; set_tacho_speed_sp ( dsn , speed ) ; set_tacho_ramp_up_sp ( dsn , 25 ) ; set_tacho_ramp_down_sp ( dsn , 100 ) ; set_tacho_position_sp ( dsn , - TONGS_UP_DOWN_DISTANCE ) ; set_tacho_command_inx ( dsn , TACHO_RUN_TO_REL_POS ) ; } } | <S2SV_ModStart> ( sonar_id , NB_SENSOR_MESURE ) < 50 <S2SV_ModEnd> ) return ; |
2,122 | CWE-000 int virgl_encode_host_debug_flagstring ( struct virgl_context * ctx , <S2SV_StartBug> char * flagstring ) <S2SV_EndBug> { unsigned long slen = strlen ( flagstring ) + 1 ; uint32_t sslen ; uint32_t string_length ; if ( ! slen ) return 0 ; if ( slen > 4 * 0xffff ) { debug_printf ( "VIRGL:<S2SV_blank>host<S2SV_blank>debug<S2SV_blank>flag<S2SV_blank>string<S2SV_blank>too<S2SV_blank>long,<S2SV_blank>will<S2SV_blank>be<S2SV_blank>truncated\\n" ) ; slen = 4 * 0xffff ; } sslen = ( uint32_t ) ( slen + 3 ) / 4 ; string_length = ( uint32_t ) MIN2 ( sslen * 4 , slen ) ; virgl_encoder_write_cmd_dword ( ctx , VIRGL_CMD0 ( VIRGL_CCMD_SET_DEBUG_FLAGS , 0 , sslen ) ) ; <S2SV_StartBug> virgl_encoder_write_block ( ctx -> cbuf , ( uint8_t * ) flagstring , string_length ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> * ctx , const <S2SV_ModStart> cbuf , ( const |
2,123 | CWE-000 BIGNUM * BN_copy ( BIGNUM * dest , const BIGNUM * src ) { if ( src == dest ) { return dest ; } <S2SV_StartBug> if ( ! bn_wexpand ( dest , src -> top ) ) { <S2SV_EndBug> return NULL ; } <S2SV_StartBug> OPENSSL_memcpy ( dest -> d , src -> d , sizeof ( src -> d [ 0 ] ) * src -> top ) ; <S2SV_EndBug> <S2SV_StartBug> dest -> top = src -> top ; <S2SV_EndBug> dest -> neg = src -> neg ; return dest ; } | <S2SV_ModStart> , src -> width <S2SV_ModEnd> ) ) { <S2SV_ModStart> * src -> width <S2SV_ModEnd> ) ; dest <S2SV_ModStart> ; dest -> width <S2SV_ModEnd> = src -> <S2SV_ModStart> = src -> width <S2SV_ModEnd> ; dest -> |
2,124 | CWE-000 bool bus_send_message ( sBus_t * psBus , uint16_t uReceiver , uint8_t uLen , uint8_t * puMsg ) { uint8_t overall_msg_len ; do { if ( eMod_Sleeping == psBus -> eModuleState ) { bus_send_wakeupbyte ( psBus ) ; psBus -> eModuleState = eMod_Running ; bus_flush_bus ( psBus ) ; } if ( uLen == 0 || uLen > BUS_MAXSENDMSGLEN ) { break ; } if ( q_get_free ( & psBus -> tx_queue ) < uLen + 6 ) { break ; } overall_msg_len = uLen + 5 ; q_put_byte ( & psBus -> tx_queue , overall_msg_len ) ; q_put_byte ( & psBus -> tx_queue , BUS_SYNCBYTE ) ; q_put_byte ( & psBus -> tx_queue , psBus -> sCfg . uOwnNodeAddress & 0x007F ) ; q_put_byte ( & psBus -> tx_queue , uLen + 4 ) ; q_put_byte ( & psBus -> tx_queue , uReceiver & 0x007F ) ; q_put_byte ( & psBus -> tx_queue , ( ( uReceiver & 0x0F00 ) >> 8 ) | <S2SV_StartBug> ( ( psBus -> sCfg . uOwnNodeAddress & 0x0F00 ) >> 4 ) ) ; <S2SV_EndBug> while ( uLen -- ) { q_put_byte ( & psBus -> tx_queue , * puMsg ++ ) ; } return true ; } while ( false ) ; return false ; } | <S2SV_ModStart> ) | ( <S2SV_ModEnd> psBus -> sCfg <S2SV_ModStart> -> sCfg . uOwnExtAddress << <S2SV_ModEnd> 4 ) ) |
2,125 | CWE-000 int largeUdp_sendto ( largeUdp_pt handle , int fd , void * buf , size_t count , int flags , struct sockaddr_in * dest_addr , size_t addrlen ) { int n ; int nr_buffers = ( count / MAX_PART_SIZE ) + 1 ; int result = 0 ; msg_part_header_t header ; int written = 0 ; <S2SV_StartBug> header . msg_ident = rand ( ) ; <S2SV_EndBug> header . total_msg_size = count ; char * databuf = buf ; struct iovec msg_iovec [ 2 ] ; struct msghdr msg ; msg . msg_name = dest_addr ; msg . msg_namelen = addrlen ; msg . msg_flags = 0 ; msg . msg_iov = msg_iovec ; msg . msg_iovlen = 2 ; msg . msg_control = NULL ; msg . msg_controllen = 0 ; msg . msg_iov [ 0 ] . iov_base = & header ; msg . msg_iov [ 0 ] . iov_len = sizeof ( header ) ; for ( n = 0 ; n < nr_buffers ; n ++ ) { header . part_msg_size = ( ( ( header . total_msg_size - n * MAX_PART_SIZE ) > MAX_PART_SIZE ) ? MAX_PART_SIZE : ( header . total_msg_size - n * MAX_PART_SIZE ) ) ; header . offset = n * MAX_PART_SIZE ; msg . msg_iov [ 1 ] . iov_base = & databuf [ header . offset ] ; msg . msg_iov [ 1 ] . iov_len = header . part_msg_size ; int w = sendmsg ( fd , & msg , 0 ) ; if ( w == - 1 ) { perror ( "send()" ) ; result = - 1 ; break ; } written += w ; } return ( result == 0 ? written : result ) ; } | <S2SV_ModStart> . msg_ident = ( unsigned int ) random <S2SV_ModEnd> ( ) ; |
2,126 | CWE-000 static void gtk_menu_set_submenu_navigation_region ( GtkMenu * menu , GtkMenuItem * menu_item , GdkEventCrossing * event ) { GtkMenuPrivate * priv = menu -> priv ; gint submenu_left = 0 ; gint submenu_right = 0 ; gint submenu_top = 0 ; gint submenu_bottom = 0 ; <S2SV_StartBug> gint width = 0 ; <S2SV_EndBug> GtkWidget * event_widget ; GtkMenuPopdownData * popdown_data ; GdkWindow * window ; g_return_if_fail ( menu_item -> priv -> submenu != NULL ) ; g_return_if_fail ( event != NULL ) ; event_widget = gtk_get_event_widget ( ( GdkEvent * ) event ) ; window = gtk_widget_get_window ( menu_item -> priv -> submenu ) ; gdk_window_get_origin ( window , & submenu_left , & submenu_top ) ; submenu_right = submenu_left + gdk_window_get_width ( window ) ; submenu_bottom = submenu_top + gdk_window_get_height ( window ) ; width = gdk_window_get_width ( gtk_widget_get_window ( event_widget ) ) ; <S2SV_StartBug> if ( event -> x >= 0 && event -> x < width ) <S2SV_EndBug> { gtk_menu_stop_navigating_submenu ( menu ) ; if ( menu_item -> priv -> submenu_direction == GTK_DIRECTION_RIGHT ) { priv -> navigation_x = submenu_left ; <S2SV_StartBug> priv -> navigation_width = event -> x_root - submenu_left ; <S2SV_EndBug> } else { priv -> navigation_x = submenu_right ; <S2SV_StartBug> priv -> navigation_width = event -> x_root - submenu_right ; <S2SV_EndBug> } if ( event -> y < 0 ) { <S2SV_StartBug> priv -> navigation_y = event -> y_root ; <S2SV_EndBug> <S2SV_StartBug> priv -> navigation_height = submenu_top - event -> y_root - NAVIGATION_REGION_OVERSHOOT ; <S2SV_EndBug> if ( priv -> navigation_height >= 0 ) return ; } else { <S2SV_StartBug> priv -> navigation_y = event -> y_root ; <S2SV_EndBug> <S2SV_StartBug> priv -> navigation_height = submenu_bottom - event -> y_root + NAVIGATION_REGION_OVERSHOOT ; <S2SV_EndBug> if ( priv -> navigation_height <= 0 ) return ; } popdown_data = g_new ( GtkMenuPopdownData , 1 ) ; popdown_data -> menu = menu ; popdown_data -> device = gdk_event_get_device ( ( GdkEvent * ) event ) ; priv -> navigation_timeout = gdk_threads_add_timeout_full ( G_PRIORITY_DEFAULT , MENU_POPDOWN_DELAY , gtk_menu_stop_navigating_submenu_cb , popdown_data , ( GDestroyNotify ) g_free ) ; g_source_set_name_by_id ( priv -> navigation_timeout , "[gtk+]<S2SV_blank>gtk_menu_stop_navigating_submenu_cb" ) ; } } | <S2SV_ModStart> ; gint width = 0 ; gint x_root = 0 ; gint y_root <S2SV_ModStart> ) ) ; x_root = floor ( event -> x_root ) ; y_root = floor ( event -> y_root ) ; <S2SV_ModStart> -> navigation_width = <S2SV_ModEnd> x_root - submenu_left <S2SV_ModStart> -> navigation_width = <S2SV_ModEnd> x_root - submenu_right <S2SV_ModStart> -> navigation_y = <S2SV_ModEnd> y_root ; priv <S2SV_ModStart> = submenu_top - <S2SV_ModEnd> y_root - NAVIGATION_REGION_OVERSHOOT <S2SV_ModStart> -> navigation_y = <S2SV_ModEnd> y_root ; priv <S2SV_ModStart> = submenu_bottom - <S2SV_ModEnd> y_root + NAVIGATION_REGION_OVERSHOOT |
2,127 | CWE-000 void sofree ( struct socket * so ) { <S2SV_StartBug> Slirp * slirp = so -> slirp ; <S2SV_EndBug> if ( so -> so_emu == EMU_RSH && so -> extra ) { sofree ( so -> extra ) ; so -> extra = NULL ; } if ( so == slirp -> tcp_last_so ) { slirp -> tcp_last_so = & slirp -> tcb ; } else if ( so == slirp -> udp_last_so ) { slirp -> udp_last_so = & slirp -> udb ; } else if ( so == slirp -> icmp_last_so ) { slirp -> icmp_last_so = & slirp -> icmp ; } m_free ( so -> so_m ) ; if ( so -> so_next && so -> so_prev ) remque ( so ) ; free ( so ) ; } | <S2SV_ModStart> so -> slirp ; soqfree ( so , & slirp -> if_fastq ) ; soqfree ( so , & slirp -> if_batchq ) |
2,128 | CWE-000 static Evas_Object * _entrance_gui_user_content_get ( void * data EINA_UNUSED , Evas_Object * obj , const char * part ) { Evas_Object * ic = NULL , * o ; Entrance_Login * eu ; eu = data ; if ( eu && ! strcmp ( part , "elm.swallow.icon" ) ) { ic = entrance_gui_theme_get ( obj , "entrance/user" ) ; if ( ( ! eu -> image . path ) && ( ! eu -> image . group ) ) { o = _entrance_gui_user_icon_random_get ( obj , eu -> login ) ; <S2SV_StartBug> elm_image_file_get ( o , & ( eu -> image . path ) , & ( eu -> image . group ) ) ; <S2SV_EndBug> eu -> tmp_icon = EINA_TRUE ; } <S2SV_StartBug> else if ( eu -> image . path && ( ! eu -> image . group ) ) <S2SV_EndBug> { o = elm_icon_add ( obj ) ; elm_image_file_set ( o , eu -> image . path , NULL ) ; } else { o = entrance_gui_theme_get ( obj , eu -> image . group ) ; } evas_object_size_hint_weight_set ( o , EVAS_HINT_EXPAND , EVAS_HINT_EXPAND ) ; evas_object_show ( o ) ; elm_object_part_content_set ( ic , "entrance.icon" , o ) ; } return ic ; } | <S2SV_ModStart> login ) ; if ( eu -> image . path || eu -> image . group ) { <S2SV_ModStart> EINA_TRUE ; } } |
2,129 | CWE-000 <S2SV_StartBug> int ft_pow ( int base , int exp ) <S2SV_EndBug> { if ( exp == 0 ) return ( 1 ) ; return ( base * ft_pow ( base , exp - 1 ) ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> intmax_t <S2SV_ModEnd> ft_pow ( int |
2,130 | CWE-000 void primSprtS ( unsigned char * baseAddr ) { unsigned long * gpuData = ( ( unsigned long * ) baseAddr ) ; short * sgpuData = ( ( short * ) baseAddr ) ; short s ; unsigned short sTypeRest = 0 ; sprtX = sgpuData [ 2 ] ; sprtY = sgpuData [ 3 ] ; sprtW = sgpuData [ 6 ] & 0x3ff ; sprtH = sgpuData [ 7 ] & 0x1ff ; if ( ! sprtH ) return ; if ( ! sprtW ) return ; iSpriteTex = 1 ; gl_ux [ 0 ] = gl_ux [ 3 ] = baseAddr [ 8 ] ; gl_vy [ 0 ] = gl_vy [ 1 ] = baseAddr [ 9 ] ; if ( usMirror & 0x1000 ) { s = gl_ux [ 0 ] ; s -= sprtW - 1 ; if ( s < 0 ) { s = 0 ; } gl_ux [ 0 ] = gl_ux [ 3 ] = s ; } if ( usMirror & 0x2000 ) { s = gl_vy [ 0 ] ; s -= sprtH - 1 ; if ( s < 0 ) { s = 0 ; } gl_vy [ 0 ] = gl_vy [ 1 ] = s ; } sSprite_ux2 = s = gl_ux [ 0 ] + sprtW ; if ( s ) s -- ; if ( s > 255 ) s = 255 ; gl_ux [ 1 ] = gl_ux [ 2 ] = s ; sSprite_vy2 = s = gl_vy [ 0 ] + sprtH ; if ( s ) s -- ; if ( s > 255 ) s = 255 ; gl_vy [ 2 ] = gl_vy [ 3 ] = s ; if ( ! bUsingTWin ) { if ( sSprite_ux2 > 256 ) { sprtW = 256 - gl_ux [ 0 ] ; sSprite_ux2 = 256 ; sTypeRest += 1 ; } if ( sSprite_vy2 > 256 ) { sprtH = 256 - gl_vy [ 0 ] ; sSprite_vy2 = 256 ; sTypeRest += 2 ; } } lx0 = sprtX ; ly0 = sprtY ; <S2SV_StartBug> offsetST ( ) ; <S2SV_EndBug> ulClutID = ( gpuData [ 2 ] >> 16 ) ; bDrawTextured = TRUE ; bDrawSmoothShaded = FALSE ; SetRenderState ( gpuData [ 0 ] ) ; SetRenderMode ( gpuData [ 0 ] , TRUE ) ; SetZMask4SP ( ) ; if ( ( dwActFixes & 1 ) && gTexFrameName && gTexName == gTexFrameName ) { iSpriteTex = 0 ; return ; } sSprite_ux2 = gl_ux [ 0 ] + sprtW ; sSprite_vy2 = gl_vy [ 0 ] + sprtH ; assignTextureSprite ( ) ; if ( iFilterType > 4 ) DrawMultiFilterSprite ( ) ; else PRIMdrawTexturedQuad ( & vertex [ 0 ] , & vertex [ 1 ] , & vertex [ 2 ] , & vertex [ 3 ] ) ; if ( bDrawMultiPass ) { SetSemiTransMulti ( 1 ) ; PRIMdrawTexturedQuad ( & vertex [ 0 ] , & vertex [ 1 ] , & vertex [ 2 ] , & vertex [ 3 ] ) ; } if ( ubOpaqueDraw ) { SetZMask4O ( ) ; if ( bUseMultiPass ) SetOpaqueColor ( gpuData [ 0 ] ) ; DEFOPAQUEON PRIMdrawTexturedQuad ( & vertex [ 0 ] , & vertex [ 1 ] , & vertex [ 2 ] , & vertex [ 3 ] ) ; DEFOPAQUEOFF } if ( sTypeRest ) { if ( sTypeRest & 1 ) primSprtSRest ( baseAddr , 1 ) ; if ( sTypeRest & 2 ) primSprtSRest ( baseAddr , 2 ) ; if ( sTypeRest == 3 ) primSprtSRest ( baseAddr , 3 ) ; } iSpriteTex = 0 ; iDrawnSomething = 1 ; } | <S2SV_ModStart> ; offsetST ( baseAddr |
2,131 | CWE-000 static void zephir_is_basic_charset ( zval * return_value , const zval * param ) { unsigned int i ; unsigned int ch ; int iso88591 = 0 ; for ( i = 0 ; i < Z_STRLEN_P ( param ) ; i ++ ) { ch = Z_STRVAL_P ( param ) [ i ] ; if ( ch != '\\0' ) { if ( ch == 172 || ( ch >= 128 && ch <= 159 ) ) { continue ; } if ( ch >= 160 && ch <= 255 ) { iso88591 = 1 ; continue ; } } RETURN_FALSE ; } if ( ! iso88591 ) { <S2SV_StartBug> RETURN_STRING ( "ASCII" ) ; <S2SV_EndBug> } <S2SV_StartBug> RETURN_STRING ( "ISO-8859-1" ) ; <S2SV_EndBug> } | <S2SV_ModStart> RETURN_STRING ( "ASCII" , 1 <S2SV_ModStart> RETURN_STRING ( "ISO-8859-1" , 1 |
2,132 | CWE-000 char * length_z ( t_print * form , va_list ap , char c ) { if ( c == 'd' || c == 'i' || c == 'u' || c == 'o' || c == 'x' || c == 'X' ) <S2SV_StartBug> return ( pull_sizet ( form , ap ) ) ; <S2SV_EndBug> if ( c == 'n' ) return ( pull_sizetp ( form , ap ) ) ; return ( length_none ( form , ap , c ) ) ; } | <S2SV_ModStart> form , ap , c |
2,133 | CWE-000 bool apply_push_options ( struct options * options , struct buffer * buf , unsigned int permission_mask , unsigned int * option_types_found , struct env_set * es ) { char line [ OPTION_PARM_SIZE ] ; int line_num = 0 ; const char * file = "[PUSH-OPTIONS]" ; const int msglevel = D_PUSH_ERRORS | M_OPTERR ; while ( buf_parse ( buf , ',' , line , sizeof ( line ) ) ) { char * p [ MAX_PARMS ] ; CLEAR ( p ) ; ++ line_num ; <S2SV_StartBug> if ( parse_line ( line , p , SIZE ( p ) , file , line_num , msglevel , & options -> gc ) ) <S2SV_EndBug> { add_option ( options , p , file , line_num , 0 , msglevel , permission_mask , option_types_found , es ) ; } } return true ; } | <S2SV_ModStart> ; if ( ! apply_pull_filter ( options , line ) ) { return false ; } if ( |
2,134 | CWE-000 <S2SV_StartBug> gchar * <S2SV_EndBug> gepub_text_chunk_type_str ( GepubTextChunk * chunk ) { switch ( chunk -> type ) { case GEPUBTextBold : return "bold" ; case GEPUBTextItalic : return "italic" ; case GEPUBTextHeader : return "header" ; default : return "normal" ; } } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> const char <S2SV_ModEnd> * gepub_text_chunk_type_str ( |
2,135 | CWE-000 int format_kairosdb_value_list ( char * buffer , size_t * ret_buffer_fill , size_t * ret_buffer_free , const data_set_t * ds , const value_list_t * vl , int store_rates , char const * const * http_attrs , <S2SV_StartBug> size_t http_attrs_num , int data_ttl ) { <S2SV_EndBug> if ( ( buffer == NULL ) || ( ret_buffer_fill == NULL ) || ( ret_buffer_free == NULL ) || ( ds == NULL ) || ( vl == NULL ) ) return - EINVAL ; if ( * ret_buffer_free < 3 ) return - ENOMEM ; return format_kairosdb_value_list_nocheck ( buffer , ret_buffer_fill , ret_buffer_free , ds , vl , store_rates , <S2SV_StartBug> ( * ret_buffer_free ) - 2 , http_attrs , http_attrs_num , data_ttl ) ; <S2SV_EndBug> } | <S2SV_ModStart> , int data_ttl , char * metrics_prefix <S2SV_ModStart> http_attrs_num , data_ttl , metrics_prefix |
2,136 | CWE-000 static int provenance_inode_symlink ( struct inode * dir , struct dentry * dentry , const char * name ) { struct provenance * cprov = get_cred_provenance ( ) ; struct provenance * tprov = get_task_provenance ( ) ; struct provenance * iprov = NULL ; struct provenance * dprov = NULL ; unsigned long irqflags ; int rc ; iprov = dentry_provenance ( dentry , true ) ; if ( ! iprov ) <S2SV_StartBug> return - ENOMEM ; <S2SV_EndBug> dprov = inode_provenance ( dir , true ) ; if ( ! dprov ) <S2SV_StartBug> return - ENOMEM ; <S2SV_EndBug> spin_lock_irqsave_nested ( prov_lock ( cprov ) , irqflags , PROVENANCE_LOCK_PROC ) ; spin_lock_nested ( prov_lock ( dprov ) , PROVENANCE_LOCK_DIR ) ; spin_lock_nested ( prov_lock ( iprov ) , PROVENANCE_LOCK_INODE ) ; <S2SV_StartBug> rc = generates ( RL_UNLINK , cprov , tprov , dprov , NULL , 0 ) ; <S2SV_EndBug> if ( rc < 0 ) goto out ; <S2SV_StartBug> rc = generates ( RL_UNLINK , cprov , tprov , iprov , NULL , 0 ) ; <S2SV_EndBug> out : spin_unlock ( prov_lock ( iprov ) ) ; spin_unlock ( prov_lock ( dprov ) ) ; spin_unlock_irqrestore ( prov_lock ( cprov ) , irqflags ) ; return rc ; } | <S2SV_ModStart> iprov ) return 0 <S2SV_ModEnd> ; dprov = <S2SV_ModStart> dprov ) return 0 <S2SV_ModEnd> ; spin_lock_irqsave_nested ( <S2SV_ModStart> = generates ( RL_SYMLINK <S2SV_ModEnd> , cprov , <S2SV_ModStart> = generates ( RL_SYMLINK <S2SV_ModEnd> , cprov , |
2,137 | CWE-000 static int check_func_arg ( struct bpf_verifier_env * env , u32 regno , enum bpf_arg_type arg_type , struct bpf_call_arg_meta * meta ) { struct bpf_reg_state * regs = cur_regs ( env ) , * reg = & regs [ regno ] ; enum bpf_reg_type expected_type , type = reg -> type ; int err = 0 ; if ( arg_type == ARG_DONTCARE ) return 0 ; err = check_reg_arg ( env , regno , SRC_OP ) ; if ( err ) return err ; if ( arg_type == ARG_ANYTHING ) { if ( is_pointer_value ( env , regno ) ) { verbose ( env , "R%d<S2SV_blank>leaks<S2SV_blank>addr<S2SV_blank>into<S2SV_blank>helper<S2SV_blank>function\\n" , regno ) ; return - EACCES ; } return 0 ; } if ( type_is_pkt_pointer ( type ) && ! may_access_direct_pkt_data ( env , meta , BPF_READ ) ) { verbose ( env , "helper<S2SV_blank>access<S2SV_blank>to<S2SV_blank>the<S2SV_blank>packet<S2SV_blank>is<S2SV_blank>not<S2SV_blank>allowed\\n" ) ; return - EACCES ; } if ( arg_type == ARG_PTR_TO_MAP_KEY || arg_type == ARG_PTR_TO_MAP_VALUE ) { expected_type = PTR_TO_STACK ; if ( ! type_is_pkt_pointer ( type ) && type != PTR_TO_MAP_VALUE && type != expected_type ) goto err_type ; } else if ( arg_type == ARG_CONST_SIZE || arg_type == ARG_CONST_SIZE_OR_ZERO ) { expected_type = SCALAR_VALUE ; if ( type != expected_type ) goto err_type ; } else if ( arg_type == ARG_CONST_MAP_PTR ) { expected_type = CONST_PTR_TO_MAP ; if ( type != expected_type ) goto err_type ; } else if ( arg_type == ARG_PTR_TO_CTX ) { expected_type = PTR_TO_CTX ; if ( type != expected_type ) goto err_type ; <S2SV_StartBug> } else if ( arg_type_is_mem_ptr ( arg_type ) ) { <S2SV_EndBug> expected_type = PTR_TO_STACK ; if ( register_is_null ( reg ) && arg_type == ARG_PTR_TO_MEM_OR_NULL ) ; else if ( ! type_is_pkt_pointer ( type ) && type != PTR_TO_MAP_VALUE && type != expected_type ) goto err_type ; meta -> raw_mode = arg_type == ARG_PTR_TO_UNINIT_MEM ; } else { verbose ( env , "unsupported<S2SV_blank>arg_type<S2SV_blank>%d\\n" , arg_type ) ; return - EFAULT ; } if ( arg_type == ARG_CONST_MAP_PTR ) { meta -> map_ptr = reg -> map_ptr ; } else if ( arg_type == ARG_PTR_TO_MAP_KEY ) { if ( ! meta -> map_ptr ) { verbose ( env , "invalid<S2SV_blank>map_ptr<S2SV_blank>to<S2SV_blank>access<S2SV_blank>map->key\\n" ) ; return - EACCES ; } err = check_helper_mem_access ( env , regno , meta -> map_ptr -> key_size , false , NULL ) ; } else if ( arg_type == ARG_PTR_TO_MAP_VALUE ) { if ( ! meta -> map_ptr ) { verbose ( env , "invalid<S2SV_blank>map_ptr<S2SV_blank>to<S2SV_blank>access<S2SV_blank>map->value\\n" ) ; return - EACCES ; } err = check_helper_mem_access ( env , regno , meta -> map_ptr -> value_size , false , NULL ) ; } else if ( arg_type_is_mem_size ( arg_type ) ) { bool zero_size_allowed = ( arg_type == ARG_CONST_SIZE_OR_ZERO ) ; meta -> msize_smax_value = reg -> smax_value ; meta -> msize_umax_value = reg -> umax_value ; if ( ! tnum_is_const ( reg -> var_off ) ) meta = NULL ; if ( reg -> smin_value < 0 ) { verbose ( env , "R%d<S2SV_blank>min<S2SV_blank>value<S2SV_blank>is<S2SV_blank>negative,<S2SV_blank>either<S2SV_blank>use<S2SV_blank>unsigned<S2SV_blank>or<S2SV_blank>\'var<S2SV_blank>&=<S2SV_blank>const\'\\n" , regno ) ; return - EACCES ; } if ( reg -> umin_value == 0 ) { err = check_helper_mem_access ( env , regno - 1 , 0 , zero_size_allowed , meta ) ; if ( err ) return err ; } if ( reg -> umax_value >= BPF_MAX_VAR_SIZ ) { verbose ( env , "R%d<S2SV_blank>unbounded<S2SV_blank>memory<S2SV_blank>access,<S2SV_blank>use<S2SV_blank>\'var<S2SV_blank>&=<S2SV_blank>const\'<S2SV_blank>or<S2SV_blank>\'if<S2SV_blank>(var<S2SV_blank><<S2SV_blank>const)\'\\n" , regno ) ; return - EACCES ; } err = check_helper_mem_access ( env , regno - 1 , reg -> umax_value , zero_size_allowed , meta ) ; } return err ; err_type : verbose ( env , "R%d<S2SV_blank>type=%s<S2SV_blank>expected=%s\\n" , regno , reg_type_str [ type ] , reg_type_str [ expected_type ] ) ; return - EACCES ; } | <S2SV_ModStart> goto err_type ; err = check_ctx_reg ( env , reg , regno ) ; if ( err < 0 ) return err ; |
2,138 | CWE-000 void SceneSingleplayer_destroy ( Scene_Singleplayer * s ) { WD_TextureDestroy ( s -> iniciar ) ; WD_TextureDestroy ( s -> continuar ) ; WD_TextureDestroy ( s -> voltar ) ; WD_TextureDestroy ( s -> background ) ; WD_TextureDestroy ( s -> mensagem ) ; WD_TextureDestroy ( s -> sim ) ; WD_TextureDestroy ( s -> nao ) ; WD_TextureDestroy ( s -> bemVindo ) ; WD_TextureDestroy ( s -> nome ) ; WD_TextureDestroy ( s -> pontu ) ; <S2SV_StartBug> free ( s ) ; <S2SV_EndBug> } | <S2SV_ModStart> pontu ) ; WD_TextureDestroy ( s -> boxbox ) ; |
2,139 | CWE-000 static fsal_status_t read_dirents ( struct fsal_obj_handle * dir_hdl , fsal_cookie_t * whence , void * dir_state , fsal_readdir_cb cb , <S2SV_StartBug> bool * eof ) <S2SV_EndBug> { struct pseudo_fsal_obj_handle * myself , * hdl ; struct avltree_node * node ; fsal_cookie_t seekloc ; if ( whence != NULL ) seekloc = * whence ; else seekloc = 2 ; * eof = true ; myself = container_of ( dir_hdl , struct pseudo_fsal_obj_handle , obj_handle ) ; LogDebug ( COMPONENT_FSAL , "hdl=%p,<S2SV_blank>name=%s" , myself , myself -> name ) ; PTHREAD_RWLOCK_rdlock ( & dir_hdl -> lock ) ; op_ctx -> fsal_private = dir_hdl ; for ( node = avltree_first ( & myself -> avl_index ) ; node != NULL ; node = avltree_next ( node ) ) { hdl = avltree_container_of ( node , struct pseudo_fsal_obj_handle , avl_i ) ; if ( hdl -> index < seekloc ) continue ; <S2SV_StartBug> if ( ! cb ( hdl -> name , dir_state , hdl -> index ) ) { <S2SV_EndBug> * eof = false ; break ; } } op_ctx -> fsal_private = NULL ; PTHREAD_RWLOCK_unlock ( & dir_hdl -> lock ) ; return fsalstat ( ERR_FSAL_NO_ERROR , 0 ) ; } | <S2SV_ModStart> bool * eof , uint64_t num_entries <S2SV_ModStart> hdl -> index , NULL |
2,140 | CWE-000 static void Init_b ( long long * gradIns , int moduleNum , long long * gradOut , long long * primitives , long long * channels , int N , int H , int W ) { dnnError_t err ; dnnLayout_t layout = ( dnnLayout_t ) gradOut [ MKLLayout ] ; if ( layout == 0 ) { layout = ( dnnLayout_t ) primitives [ CONCAT_LAYOUT_OUTPUT ] ; } size_t * split_channels = malloc ( moduleNum * sizeof ( size_t ) ) ; for ( int i = 0 ; i < moduleNum ; ++ i ) { split_channels [ i ] = ( size_t ) ( channels [ i ] ) ; } dnnPrimitive_t concat_split = NULL ; CHECK_ERR ( dnnSplitCreate_F32 ( & concat_split , NULL , moduleNum , layout , split_channels ) , err ) ; primitives [ CONCAT_BACKWARD ] = ( long long ) concat_split ; long long * pMem = malloc ( moduleNum * sizeof ( long long ) ) ; primitives [ CONCAT_BUF_BRANCHES ] = ( long long ) pMem ; long long * pLayout = malloc ( moduleNum * sizeof ( long long ) ) ; primitives [ CONCAT_LT_BRANCHES ] = ( long long ) pLayout ; for ( int i = 0 ; i < moduleNum ; ++ i ) { long long * ptr = ( long long * ) gradIns + i * 4 ; int C = ( int ) channels [ i ] ; size_t outputSize [ DIM4 ] = { W , H , C , N } ; size_t outputStrides1 [ DIM4 ] = { 1 , W , W * H , C * W * H } ; size_t outputStrides [ DIM4 ] = { N , N * W , N * W * H , 1 } ; dnnLayout_t lt_usr = NULL ; CHECK_ERR ( dnnLayoutCreate_F32 ( & lt_usr , DIM4 , outputSize , outputStrides ) , err ) ; ptr [ CPULayout ] = ( long long ) lt_usr ; dnnLayout_t lt_out_branch = NULL ; CHECK_ERR ( dnnLayoutCreateFromPrimitive_F32 ( & lt_out_branch , concat_split , dnnResourceMultipleDst + i ) , err ) ; float * buf = NULL ; CHECK_ERR ( dnnAllocateBuffer_F32 ( ( void * * ) & buf , lt_out_branch ) , err ) ; pLayout [ i ] = ( long long ) lt_out_branch ; pMem [ i ] = ( long long ) buf ; } <S2SV_StartBug> free ( split_channels ) ; <S2SV_EndBug> } | <S2SV_ModStart> buf ; } ERR_RETURN : if ( split_channels != NULL ) |
2,141 | CWE-000 static struct page * adjust_pages ( struct page * pages , u32 lo_order , u32 hi_order , struct free_area_t * area ) { struct page * tmp_pages ; u32 page_idx ; u32 size ; size = 1 << hi_order ; page_idx = pages -> pfn ; if ( lo_order == hi_order ) goto out ; while ( lo_order < hi_order ) { area -- ; hi_order -- ; size >>= 1 ; tmp_pages = & pages [ size ] ; tmp_pages -> order = hi_order ; add_area_pages ( area , tmp_pages ) ; } out : pages -> order = lo_order ; <S2SV_StartBug> return pages ; <S2SV_EndBug> } | <S2SV_ModStart> = lo_order ; pages -> count ++ ; |
2,142 | CWE-000 void MenuScreenStateMachine ( void ) { switch ( _CurrentState ) { case MENU_SCREEN_STATE_INIT : { if ( NUMTIMERS == _MenuScreenInputTimeoutTimer ) { _MenuScreenInputTimeoutTimer = get_timer ( ) ; } init_timer ( _MenuScreenInputTimeoutTimer , MENU_SCREEN_INPUT_TIMEOUT_TIMER_VALUE ) ; _CurrentScreenDetails = & _ScreenDetails [ MAIN_SCREEN ] ; ResetScreenDetails ( ) ; } break ; case MENU_SCREEN_STATE_UPDATE_DISPLAY : { DisplayMangerRequestDisplay ( DISPLAY_MNGR_RQST_UI_MENU , _CurrentScreenDetails ) ; _CurrentState = MENU_SCREEN_STATE_WAITING_KEY_EVENT ; } break ; case MENU_SCREEN_STATE_WAITING_KEY_EVENT : { if ( ( SCREEN_TYPE_LIVE_STATUS == _CurrentScreenDetails -> ScreenType ) && ( NULL != _CurrentScreenDetails -> fPtrCheckORCancelLiveStatus ) ) { MenuScreenListTYPE next_screen = _CurrentScreenDetails -> fPtrCheckORCancelLiveStatus ( MENU_STATUS_REQUEST_CHECK_STATUS ) ; if ( NO_SCREEN != next_screen ) { _SwitchToScreen ( next_screen ) ; ResetScreenDetails ( ) ; break ; } else if ( 0x00 == check_timer ( _MenuScreenStatusTimer ) ) { next_screen = _CurrentScreenDetails -> fPtrCheckORCancelLiveStatus ( MENU_STATUS_REQUEST_CANCEL_TIMEOUT ) ; if ( NO_SCREEN != next_screen ) { _SwitchToScreen ( next_screen ) ; ResetScreenDetails ( ) ; break ; } } else if ( 0x00 == check_timer ( _MenuScreenStatusRefreshTimer ) ) { _CurrentState = MENU_SCREEN_STATE_UPDATE_DISPLAY ; break ; } } if ( ( NUMTIMERS != _MenuScreenInputTimeoutTimer ) && ( 0x00 == check_timer ( _MenuScreenInputTimeoutTimer ) ) ) { _SwitchToScreen ( MAIN_SCREEN ) ; free_timer ( _MenuScreenInputTimeoutTimer ) ; _MenuScreenInputTimeoutTimer = NUMTIMERS ; return ; } switch ( GetKeyEvent ( ) ) { case SCAN_LEFT_KEY : { _CurrentState = MENU_SCREEN_STATE_PROCESS_LEFT_KEY ; goto GOTO_RELOAD_INPUT_TIMER ; } break ; case SCAN_RIGHT_KEY : { _CurrentState = MENU_SCREEN_STATE_PROCESS_RIGHT_KEY ; goto GOTO_RELOAD_INPUT_TIMER ; } break ; case SCAN_UP_KEY : { _CurrentState = MENU_SCREEN_STATE_PROCESS_UP_KEY ; goto GOTO_RELOAD_INPUT_TIMER ; } break ; case SCAN_DOWN_KEY : { _CurrentState = MENU_SCREEN_STATE_PROCESS_DOWN_KEY ; goto GOTO_RELOAD_INPUT_TIMER ; } break ; case SCAN_ENTER_KEY : { _CurrentState = MENU_SCREEN_STATE_PROCESS_ENT_KEY ; goto GOTO_RELOAD_INPUT_TIMER ; } break ; case SCAN_BACK_KEY : { _CurrentState = MENU_SCREEN_STATE_PROCESS_BACK_KEY ; goto GOTO_RELOAD_INPUT_TIMER ; } break ; case SCAN_MENU_KEY : { _CurrentState = MENU_SCREEN_STATE_PROCESS_MENU_KEY ; goto GOTO_RELOAD_INPUT_TIMER ; } break ; case SCAN_HOME_KEY : { _CurrentState = MENU_SCREEN_STATE_PROCESS_HOME_KEY ; goto GOTO_RELOAD_INPUT_TIMER ; } break ; default : { } break ; GOTO_RELOAD_INPUT_TIMER : if ( NUMTIMERS != _MenuScreenInputTimeoutTimer ) { init_timer ( _MenuScreenInputTimeoutTimer , MENU_SCREEN_INPUT_TIMEOUT_TIMER_VALUE ) ; } } } break ; case MENU_SCREEN_STATE_PROCESS_LEFT_KEY : { _UpdateCursorPosition ( MENU_SCREEN_UPDATE_CURSOR_LEFT ) ; _CurrentState = MENU_SCREEN_STATE_UPDATE_DISPLAY ; } break ; case MENU_SCREEN_STATE_PROCESS_RIGHT_KEY : { _UpdateCursorPosition ( MENU_SCREEN_UPDATE_CURSOR_RIGHT ) ; _CurrentState = MENU_SCREEN_STATE_UPDATE_DISPLAY ; } break ; case MENU_SCREEN_STATE_PROCESS_UP_KEY : { switch ( _CurrentScreenDetails -> ScreenType ) { case SCREEN_TYPE_OPTIONS : case SCREEN_TYPE_ENUM_INPUT_VALUE : case SCREEN_TYPE_ENUM_STATUS_LIST : { if ( 0x00 <= ( _CurrentScreenDetails -> ScrollPosition - 1 ) ) { _CurrentScreenDetails -> ScrollPosition -- ; _CurrentState = MENU_SCREEN_STATE_UPDATE_DISPLAY ; } else { _CurrentState = MENU_SCREEN_STATE_WAITING_KEY_EVENT ; } } break ; case SCREEN_TYPE_INPUT_VALUE : { _UpdateInputVal ( MENU_SCREEN_VALUE_UPDATE_INCREMENT_NORMAL ) ; _CurrentState = MENU_SCREEN_STATE_UPDATE_DISPLAY ; } break ; default : { _CurrentState = MENU_SCREEN_STATE_WAITING_KEY_EVENT ; } break ; } } break ; case MENU_SCREEN_STATE_PROCESS_DOWN_KEY : { switch ( _CurrentScreenDetails -> ScreenType ) { case SCREEN_TYPE_OPTIONS : case SCREEN_TYPE_ENUM_INPUT_VALUE : case SCREEN_TYPE_ENUM_STATUS_LIST : { if ( _CurrentScreenDetails -> ScreenLineCount > ( _CurrentScreenDetails -> ScrollPosition + 1 ) ) { _CurrentScreenDetails -> ScrollPosition ++ ; _CurrentState = MENU_SCREEN_STATE_UPDATE_DISPLAY ; } else { _CurrentState = MENU_SCREEN_STATE_WAITING_KEY_EVENT ; } } break ; case SCREEN_TYPE_INPUT_VALUE : { _UpdateInputVal ( MENU_SCREEN_VALUE_UPDATE_DECREMENT_NORMAL ) ; _CurrentState = MENU_SCREEN_STATE_UPDATE_DISPLAY ; } break ; default : { _CurrentState = MENU_SCREEN_STATE_WAITING_KEY_EVENT ; } break ; } } break ; case MENU_SCREEN_STATE_PROCESS_ENT_KEY : { switch ( _CurrentScreenDetails -> ScreenType ) { case SCREEN_TYPE_OPTIONS : case SCREEN_TYPE_STATUS : { if ( NO_SCREEN != _CurrentScreenDetails -> pCurrentScreenDetails [ _CurrentScreenDetails -> ScrollPosition ] . NextScreen ) { _SwitchToScreen ( _CurrentScreenDetails -> pCurrentScreenDetails [ _CurrentScreenDetails -> ScrollPosition ] . NextScreen ) ; ResetScreenDetails ( ) ; } else { _CurrentState = MENU_SCREEN_STATE_WAITING_KEY_EVENT ; } } break ; case SCREEN_TYPE_INPUT_VALUE : case SCREEN_TYPE_ENUM_INPUT_VALUE : case SCREEN_TYPE_LIVE_STATUS : { if ( NULL != _CurrentScreenDetails -> fPtrSaveValue ) { _CurrentOptionValue . Value . EnumListDetails . SelectedEnum = _CurrentScreenDetails -> ScrollPosition ; _SwitchToScreen ( _CurrentScreenDetails -> fPtrSaveValue ( & _CurrentOptionValue ) ) ; <S2SV_StartBug> ResetScreenDetails ( ) ; <S2SV_EndBug> } else if ( NO_SCREEN != _CurrentScreenDetails -> pCurrentScreenDetails [ _CurrentScreenDetails -> ScrollPosition ] . NextScreen ) { _SwitchToScreen ( _CurrentScreenDetails -> pCurrentScreenDetails [ _CurrentScreenDetails -> ScrollPosition ] . NextScreen ) ; ResetScreenDetails ( ) ; } else { _CurrentState = MENU_SCREEN_STATE_WAITING_KEY_EVENT ; } } break ; default : { _CurrentState = MENU_SCREEN_STATE_WAITING_KEY_EVENT ; } break ; } } break ; case MENU_SCREEN_STATE_PROCESS_BACK_KEY : { if ( ( SCREEN_TYPE_LIVE_STATUS == _CurrentScreenDetails -> ScreenType ) && ( NULL != _CurrentScreenDetails -> fPtrCheckORCancelLiveStatus ) ) { MenuScreenListTYPE next_screen = _CurrentScreenDetails -> fPtrCheckORCancelLiveStatus ( MENU_STATUS_REQUEST_CANCEL_USER ) ; if ( NO_SCREEN != next_screen ) { _SwitchToScreen ( next_screen ) ; ResetScreenDetails ( ) ; break ; } } if ( NO_SCREEN != _CurrentScreenDetails -> PrevScreen ) { _SwitchToScreen ( _CurrentScreenDetails -> PrevScreen ) ; _CurrentState = MENU_SCREEN_STATE_UPDATE_DISPLAY ; } else { _CurrentState = MENU_SCREEN_STATE_WAITING_KEY_EVENT ; } } break ; default : { _CurrentState = MENU_SCREEN_STATE_WAITING_KEY_EVENT ; } break ; } run ( MenuScreenStateMachine ) ; } | <S2SV_ModStart> ) ) ; _CurrentState = MENU_SCREEN_STATE_UPDATE_DISPLAY <S2SV_ModEnd> ; } else |
2,143 | CWE-000 int unmap_page ( uintptr_t * pd , uintptr_t vma ) { <S2SV_StartBug> if ( vma & PAGE_4K_OFFSET != 0 ) { <S2SV_EndBug> return PAGE_ALIGNMENT_ERROR ; } uintptr_t pdindex = vma >> 22 ; if ( ! ( pd [ pdindex ] & PAGE_PRESENT ) ) { return PAGE_ALREADY_VACANT ; } if ( pd [ pdindex ] & PAGE_MAPS_4M ) { <S2SV_StartBug> if ( vma & PAGE_4M_OFFSET != 0 ) { <S2SV_EndBug> return PAGE_ALIGNMENT_ERROR ; } pd [ pdindex ] &= ~ PAGE_PRESENT ; physical_memory_map [ pdindex ] &= ~ PHY_PAGE_MAPPED ; } else { uintptr_t ptindex = vma >> 12 & 0x3FF ; <S2SV_StartBug> uintptr_t * pt = ( uintptr_t * ) ( pd [ pdindex ] & 0xFFC00000 + ptindex ) ; <S2SV_EndBug> pt [ ptindex ] &= ~ PAGE_PRESENT ; } return 0 ; } | <S2SV_ModStart> { if ( ( <S2SV_ModStart> vma & PAGE_4K_OFFSET ) <S2SV_ModStart> { if ( ( <S2SV_ModStart> vma & PAGE_4M_OFFSET ) <S2SV_ModStart> pdindex ] & ( <S2SV_ModStart> 0xFFC00000 + ptindex ) |
2,144 | CWE-000 static void runge_kutta_ks ( real_t * ks , real_t * y , real_t x , unsigned int n , real_t h , fun_t derivs ) { <S2SV_StartBug> unsigned int i , j , l ; <S2SV_EndBug> real_t ytemp [ n ] ; assert ( n > 0 ) ; assert ( K1_is_derivs ( K ( 1 ) , y , x , n , derivs ) ) ; for ( i = 2 ; i <= RKN ; i ++ ) { <S2SV_StartBug> for ( l = 0 ; l < n ; l ++ ) { <S2SV_EndBug> <S2SV_StartBug> ytemp [ l ] = B ( i , 1 ) * K ( 1 ) [ l ] ; <S2SV_EndBug> for ( j = 2 ; j < i ; j ++ ) { <S2SV_StartBug> ytemp [ l ] += B ( i , j ) * K ( j ) [ l ] ; <S2SV_EndBug> } <S2SV_StartBug> ytemp [ l ] = y [ l ] + h * ytemp [ l ] ; <S2SV_EndBug> } derivs ( K ( i ) , x + h * A ( i ) , ytemp ) ; } } | <S2SV_ModStart> , j , k <S2SV_ModEnd> ; real_t ytemp <S2SV_ModStart> { for ( k <S2SV_ModEnd> = 0 ; <S2SV_ModStart> = 0 ; k <S2SV_ModEnd> < n ; <S2SV_ModStart> < n ; k <S2SV_ModEnd> ++ ) { <S2SV_ModStart> { ytemp [ k <S2SV_ModEnd> ] = B <S2SV_ModStart> 1 ) [ k <S2SV_ModEnd> ] ; for <S2SV_ModStart> { ytemp [ k <S2SV_ModEnd> ] += B <S2SV_ModStart> j ) [ k ] ; } ytemp [ k <S2SV_ModEnd> ] = y <S2SV_ModStart> = y [ k <S2SV_ModEnd> ] + h <S2SV_ModStart> * ytemp [ k <S2SV_ModEnd> ] ; } |
2,145 | CWE-000 static void perf_install_in_context ( struct perf_event_context * ctx , struct perf_event * event , int cpu ) { struct task_struct * task = READ_ONCE ( ctx -> task ) ; lockdep_assert_held ( & ctx -> mutex ) ; if ( event -> cpu != - 1 ) event -> cpu = cpu ; smp_store_release ( & event -> ctx , ctx ) ; if ( ! task ) { cpu_function_call ( cpu , __perf_install_in_context , event ) ; return ; } if ( WARN_ON_ONCE ( task == TASK_TOMBSTONE ) ) return ; <S2SV_StartBug> again : <S2SV_EndBug> <S2SV_StartBug> if ( ! cpu_function_call ( task_cpu ( task ) , __perf_install_in_context , event ) ) <S2SV_EndBug> return ; raw_spin_lock_irq ( & ctx -> lock ) ; task = ctx -> task ; if ( WARN_ON_ONCE ( task == TASK_TOMBSTONE ) ) { raw_spin_unlock_irq ( & ctx -> lock ) ; return ; } <S2SV_StartBug> raw_spin_unlock_irq ( & ctx -> lock ) ; <S2SV_EndBug> goto again ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ) return ; smp_mb ( ) ; <S2SV_ModStart> if ( ! task_function_call ( task <S2SV_ModEnd> , __perf_install_in_context , <S2SV_ModStart> return ; } if ( task_curr ( task ) ) { <S2SV_ModStart> again ; } add_event_to_ctx ( event , ctx ) ; raw_spin_unlock_irq ( & ctx -> lock ) ; } |
2,146 | CWE-000 static ssize_t store_pwm ( struct device * dev , struct device_attribute * devattr , const char * buf , size_t count ) { int index = to_sensor_dev_attr ( devattr ) -> index ; struct nct7904_data * data = dev_get_drvdata ( dev ) ; unsigned long val ; int ret ; if ( kstrtoul ( buf , 10 , & val ) < 0 ) return - EINVAL ; if ( val > 255 ) return - EINVAL ; ret = nct7904_write_reg ( data , BANK_3 , FANCTL1_OUT_REG + index , val ) ; <S2SV_StartBug> return ret ? ret : count ; <S2SV_EndBug> } | <S2SV_ModStart> val ) ; if ( ret == 0 ) record_pwm [ index ] = ( int ) val ; |
2,147 | CWE-000 static void copyData ( const ModifierData * md , ModifierData * target ) { GpencilThickModifierData * gmd = ( GpencilThickModifierData * ) md ; GpencilThickModifierData * tgmd = ( GpencilThickModifierData * ) target ; if ( tgmd -> cur_thickness != NULL ) { curvemapping_free ( tgmd -> cur_thickness ) ; <S2SV_StartBug> } <S2SV_EndBug> modifier_copyData_generic ( md , target ) ; tgmd -> cur_thickness = curvemapping_copy ( gmd -> cur_thickness ) ; } | <S2SV_ModStart> cur_thickness ) ; tgmd -> cur_thickness = NULL ; |
2,148 | CWE-000 int main ( ) { test_push_back ( ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> ( ) ; test_pop_front ( ) ; |
2,149 | CWE-000 static void ft_print_map ( t_map m ) { ft_dprintf ( 2 , "\\n\\n\\n" ) ; m . row = 0 ; while ( m . row < m . height ) { m . col = 0 ; while ( m . col < m . width ) { if ( m . map [ m . row ] [ m . col ] == m . player ) ft_dprintf ( 2 , "%s%c%s" , C , m . map [ m . row ] [ m . col ] , W ) ; else if ( m . map [ m . row ] [ m . col ] == m . enemy ) ft_dprintf ( 2 , "%s%c%s" , B , m . map [ m . row ] [ m . col ] , W ) ; else if ( m . map [ m . row ] [ m . col ] > '3' ) ft_dprintf ( 2 , "%s%c%s" , R , m . map [ m . row ] [ m . col ] , W ) ; else if ( m . map [ m . row ] [ m . col ] == '2' ) ft_dprintf ( 2 , "%s%c%s" , Y , m . map [ m . row ] [ m . col ] , W ) ; else if ( m . map [ m . row ] [ m . col ] == '1' ) ft_dprintf ( 2 , "%s%c%s" , G , m . map [ m . row ] [ m . col ] , W ) ; <S2SV_StartBug> else if ( m . map [ m . row ] [ m . col ] > '' ) <S2SV_EndBug> ft_dprintf ( 2 , "%s%c%s" , G , m . map [ m . row ] [ m . col ] , W ) ; m . col ++ ; } ft_dprintf ( 2 , "\\n" ) ; m . row ++ ; } } | <S2SV_ModStart> ) ; else <S2SV_ModEnd> ft_dprintf ( 2 |
2,150 | CWE-000 static int run_specific_rebase ( struct rebase_options * opts ) { const char * argv [ ] = { NULL , NULL } ; struct strbuf script_snippet = STRBUF_INIT ; int status ; const char * backend , * backend_func ; add_var ( & script_snippet , "GIT_DIR" , absolute_path ( get_git_dir ( ) ) ) ; add_var ( & script_snippet , "state_dir" , opts -> state_dir ) ; if ( opts -> upstream_name ) add_var ( & script_snippet , "upstream_name" , opts -> upstream_name ) ; if ( opts -> upstream ) add_var ( & script_snippet , "upstream" , oid_to_hex ( & opts -> upstream -> object . oid ) ) ; add_var ( & script_snippet , "head_name" , opts -> head_name ) ; add_var ( & script_snippet , "orig_head" , oid_to_hex ( & opts -> orig_head ) ) ; add_var ( & script_snippet , "onto" , oid_to_hex ( & opts -> onto -> object . oid ) ) ; if ( opts -> onto_name ) add_var ( & script_snippet , "onto_name" , opts -> onto_name ) ; if ( opts -> revisions ) add_var ( & script_snippet , "revisions" , opts -> revisions ) ; add_var ( & script_snippet , "GIT_QUIET" , opts -> flags & REBASE_VERBOSE ? "" : "t" ) ; if ( opts -> git_am_opt ) add_var ( & script_snippet , "git_am_opt" , opts -> git_am_opt ) ; add_var ( & script_snippet , "verbose" , opts -> flags & REBASE_VERBOSE ? "t" : "" ) ; add_var ( & script_snippet , "diffstat" , opts -> flags & REBASE_DIFFSTAT ? "t" : "" ) ; add_var ( & script_snippet , "action" , opts -> action ? opts -> action : "" ) ; <S2SV_StartBug> if ( opts -> strategy ) <S2SV_EndBug> add_var ( & script_snippet , "strategy" , opts -> strategy ) ; add_var ( & script_snippet , "do_merge" , opts -> flags & REBASE_DO_MERGE ? "t" : "" ) ; switch ( opts -> type ) { case REBASE_AM : backend = "git-rebase--am" ; backend_func = "git_rebase__am" ; break ; case REBASE_INTERACTIVE : backend = "git-rebase--interactive" ; backend_func = "git_rebase__interactive" ; break ; case REBASE_MERGE : backend = "git-rebase--merge" ; backend_func = "git_rebase__merge" ; break ; case REBASE_PRESERVE_MERGES : backend = "git-rebase--preserve-merges" ; backend_func = "git_rebase__preserve_merges" ; break ; default : BUG ( "Unhandled<S2SV_blank>rebase<S2SV_blank>type<S2SV_blank>%d" , opts -> type ) ; break ; } strbuf_addf ( & script_snippet , "set<S2SV_blank>-x<S2SV_blank>&&<S2SV_blank>.<S2SV_blank>git-rebase--common<S2SV_blank>&&<S2SV_blank>.<S2SV_blank>%s<S2SV_blank>&&<S2SV_blank>%s" , backend , backend_func ) ; argv [ 0 ] = script_snippet . buf ; status = run_command_v_opt ( argv , RUN_USING_SHELL ) ; if ( status == 0 ) finish_rebase ( opts ) ; else if ( status == 2 ) { struct strbuf dir = STRBUF_INIT ; apply_autostash ( ) ; strbuf_addstr ( & dir , opts -> state_dir ) ; remove_dir_recursively ( & dir , 0 ) ; strbuf_release ( & dir ) ; die ( "Nothing<S2SV_blank>to<S2SV_blank>do" ) ; } strbuf_release ( & script_snippet ) ; return status ? - 1 : 0 ; } | <S2SV_ModStart> "" ) ; add_var ( & script_snippet , "allow_rerere_autoupdate" , opts -> allow_rerere_autoupdate <S2SV_ModEnd> ) ; switch |
2,151 | CWE-000 void e2e_c2d_with_svc_fault_ctrl ( IOTHUB_CLIENT_TRANSPORT_PROVIDER protocol , bool checkFaultConfirmation , const char * faultOperationType , const char * faultOperationCloseReason , const char * faultOperationDelayInSecs ) { IOTHUB_SERVICE_CLIENT_AUTH_HANDLE iotHubServiceClientHandle ; IOTHUB_MESSAGING_CLIENT_HANDLE iotHubMessagingHandle ; IOTHUB_CLIENT_HANDLE iotHubClientHandle ; IOTHUB_MESSAGING_RESULT iotHubMessagingResult ; IOTHUB_CLIENT_RESULT result ; EXPECTED_RECEIVE_DATA * receiveUserContext ; D2C_MESSAGE_HANDLE d2cMessage ; IOTHUB_PROVISIONED_DEVICE * deviceToUse = IoTHubAccount_GetSASDevice ( g_iothubAcctInfo ) ; MAP_HANDLE propMap = Map_Create ( NULL ) ; if ( Map_AddOrUpdate ( propMap , "AzIoTHub_FaultOperationType" , faultOperationType ) != MAP_OK ) { ASSERT_FAIL ( "Map_AddOrUpdate<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>AzIoTHub_FaultOperationType!" ) ; } if ( Map_AddOrUpdate ( propMap , "AzIoTHub_FaultOperationCloseReason" , faultOperationCloseReason ) != MAP_OK ) { ASSERT_FAIL ( "Map_AddOrUpdate<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>AzIoTHub_FaultOperationCloseReason!" ) ; } if ( Map_AddOrUpdate ( propMap , "AzIoTHub_FaultOperationDelayInSecs" , faultOperationDelayInSecs ) != MAP_OK ) { ASSERT_FAIL ( "Map_AddOrUpdate<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>AzIoTHub_FaultOperationDelayInSecs!" ) ; } iotHubClientHandle = client_connect_to_hub ( deviceToUse , protocol ) ; receiveUserContext = service_create_c2d ( MSG_CONTENT ) ; result = IoTHubClient_SetMessageCallback ( iotHubClientHandle , ReceiveMessageCallback , receiveUserContext ) ; ASSERT_ARE_EQUAL_WITH_MSG ( IOTHUB_CLIENT_RESULT , IOTHUB_CLIENT_OK , result , "Setting<S2SV_blank>message<S2SV_blank>callback<S2SV_blank>failed" ) ; iotHubServiceClientHandle = IoTHubServiceClientAuth_CreateFromConnectionString ( IoTHubAccount_GetIoTHubConnString ( g_iothubAcctInfo ) ) ; ASSERT_IS_NOT_NULL_WITH_MSG ( iotHubServiceClientHandle , "Could<S2SV_blank>not<S2SV_blank>initialize<S2SV_blank>IoTHubServiceClient<S2SV_blank>to<S2SV_blank>send<S2SV_blank>C2D<S2SV_blank>messages<S2SV_blank>to<S2SV_blank>the<S2SV_blank>device" ) ; iotHubMessagingHandle = IoTHubMessaging_Create ( iotHubServiceClientHandle ) ; ASSERT_IS_NOT_NULL_WITH_MSG ( iotHubMessagingHandle , "Could<S2SV_blank>not<S2SV_blank>initialize<S2SV_blank>IoTHubMessaging<S2SV_blank>to<S2SV_blank>send<S2SV_blank>C2D<S2SV_blank>messages<S2SV_blank>to<S2SV_blank>the<S2SV_blank>device" ) ; iotHubMessagingResult = IoTHubMessaging_Open ( iotHubMessagingHandle , openCompleteCallback , ( void * ) "Context<S2SV_blank>string<S2SV_blank>for<S2SV_blank>open" ) ; ASSERT_ARE_EQUAL ( int , IOTHUB_MESSAGING_OK , iotHubMessagingResult ) ; service_send_c2d ( iotHubMessagingHandle , receiveUserContext , deviceToUse ) ; client_wait_for_c2d_event_arrival ( receiveUserContext ) ; ASSERT_IS_TRUE_WITH_MSG ( receiveUserContext -> wasFound , "Failure<S2SV_blank>retrieving<S2SV_blank>data<S2SV_blank>from<S2SV_blank>C2D" ) ; ( void ) printf ( "Send<S2SV_blank>server<S2SV_blank>fault<S2SV_blank>control<S2SV_blank>message...\\r\\n" ) ; clear_connection_status_info_flags ( ) ; d2cMessage = client_create_with_properies_and_send_d2c ( iotHubClientHandle , propMap ) ; if ( checkFaultConfirmation ) { ( void ) printf ( "Wait<S2SV_blank>for<S2SV_blank>fault<S2SV_blank>control<S2SV_blank>message<S2SV_blank>confirmation...\\r\\n" ) ; bool dataWasRecv = client_wait_for_d2c_confirmation ( d2cMessage ) ; ASSERT_IS_TRUE_WITH_MSG ( dataWasRecv , "Failure<S2SV_blank>sending<S2SV_blank>fault<S2SV_blank>control<S2SV_blank>message<S2SV_blank>to<S2SV_blank>IotHub" ) ; } ThreadAPI_Sleep ( 10000 ) ; receiveUserContext -> wasFound = false ; service_send_c2d ( iotHubMessagingHandle , receiveUserContext , deviceToUse ) ; client_wait_for_c2d_event_arrival ( receiveUserContext ) ; ASSERT_IS_TRUE_WITH_MSG ( receiveUserContext -> wasFound , "Failure<S2SV_blank>retrieving<S2SV_blank>data<S2SV_blank>from<S2SV_blank>C2D" ) ; <S2SV_StartBug> IoTHubMessaging_Close ( iotHubMessagingHandle ) ; <S2SV_EndBug> IoTHubMessaging_Destroy ( iotHubMessagingHandle ) ; IoTHubServiceClientAuth_Destroy ( iotHubServiceClientHandle ) ; IoTHubClient_Destroy ( iotHubClientHandle ) ; ReceiveUserContext_Destroy ( receiveUserContext ) ; } | <S2SV_ModStart> "Failure<S2SV_blank>retrieving<S2SV_blank>data<S2SV_blank>from<S2SV_blank>C2D" ) ; Map_Destroy ( propMap ) ; |
2,152 | CWE-000 int main ( ) { pid_t pid ; FILE * datafile = fopen ( "data.txt" , "wt" ) ; if ( datafile == NULL ) { perror ( "FAIL<S2SV_blank>WITH<S2SV_blank>FAIL!" ) ; return 1 ; } switch ( pid = fork ( ) ) { case - 1 : { perror ( "fork" ) ; exit ( 2 ) ; } case 0 : { fprintf ( datafile , "It\'s<S2SV_blank>child<S2SV_blank>PID<S2SV_blank>=<S2SV_blank>%d\\n" , getpid ( ) ) ; fprintf ( datafile , "It\'s<S2SV_blank>parent<S2SV_blank>PID<S2SV_blank>=<S2SV_blank>%d\\n\\n" , getppid ( ) ) ; register int i ; unsigned int sum = 1024 * 1024 * 10 ; for ( i = 0 ; i < sum ; i ++ ) fprintf ( datafile , "1" ) ; exit ( 0 ) ; } default : { int * status = NULL ; struct timespec mt1 , mt2 ; <S2SV_StartBug> long double t_1 ; <S2SV_EndBug> clock_gettime ( CLOCK_REALTIME , & mt1 ) ; waitpid ( pid , status , 0 ) ; clock_gettime ( CLOCK_REALTIME , & mt2 ) ; <S2SV_StartBug> t_1 = 100000000 * ( mt2 . tv_sec - mt1 . tv_sec ) + ( mt2 . tv_nsec - mt1 . tv_nsec ) ; <S2SV_EndBug> t_1 = t_1 / 1000000 ; fprintf ( datafile , "\\n\\nkek<S2SV_blank>time<S2SV_blank>=<S2SV_blank>%Lf<S2SV_blank>ms\\n" , t_1 ) ; } } fclose ( datafile ) ; return 0 ; } | <S2SV_ModStart> long double t_1 = 0.0 <S2SV_ModStart> ; t_1 = 1000000000 <S2SV_ModEnd> * ( mt2 |
2,153 | CWE-000 void do_instance_list ( char_data * ch , char * argument ) { char buf [ MAX_STRING_LENGTH ] , line [ MAX_STRING_LENGTH ] ; struct instance_data * inst ; adv_data * adv = NULL ; adv_vnum vnum ; int num = 0 , count = 0 ; if ( ! ch -> desc ) { return ; } if ( ! * argument ) { do_instance_list_all ( ch ) ; return ; } if ( * argument && ( ! isdigit ( * argument ) || ( vnum = atoi ( argument ) ) < 0 || ! ( adv = adventure_proto ( vnum ) ) ) ) { msg_to_char ( ch , "Invalid<S2SV_blank>adventure<S2SV_blank>vnum<S2SV_blank>\'%s\'.\\r\\n" , argument ) ; return ; } * buf = '\\0' ; <S2SV_StartBug> for ( inst = instance_list ; inst ; inst = inst -> next ) { <S2SV_EndBug> ++ num ; <S2SV_StartBug> if ( ! adv || adv == inst -> adventure ) { <S2SV_EndBug> ++ count ; instance_list_row ( inst , num , line , sizeof ( line ) ) ; if ( snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) , "%s" , line ) < strlen ( line ) ) { break ; } } } snprintf ( buf + strlen ( buf ) , sizeof ( buf ) - strlen ( buf ) , "%d<S2SV_blank>total<S2SV_blank>instances<S2SV_blank>shown\\r\\n" , count ) ; page_string ( ch -> desc , buf , TRUE ) ; } | <S2SV_ModStart> = '\\0' ; LL_FOREACH ( instance_list , inst <S2SV_ModEnd> ) { ++ <S2SV_ModStart> || adv == INST_ADVENTURE ( inst ) <S2SV_ModEnd> ) { ++ |
2,154 | CWE-000 static void SetPartitionSchemeAndTargetSystem ( BOOL only_target ) { BOOL allowed_partition_scheme [ 3 ] = { TRUE , TRUE , FALSE } ; BOOL allowed_target_system [ 3 ] = { TRUE , TRUE , FALSE } ; BOOL is_windows_to_go_selected ; if ( ! only_target ) IGNORE_RETVAL ( ComboBox_ResetContent ( hPartitionScheme ) ) ; IGNORE_RETVAL ( ComboBox_ResetContent ( hTargetSystem ) ) ; bt = ( int ) ComboBox_GetItemData ( hBootType , ComboBox_GetCurSel ( hBootType ) ) ; is_windows_to_go_selected = ( bt == BT_IMAGE ) && ( image_path != NULL ) && HAS_WINTOGO ( img_report ) && ( ComboBox_GetCurSel ( GetDlgItem ( hMainDialog , IDC_IMAGE_OPTION ) ) == 1 ) ; if ( ComboBox_GetCurSel ( hDeviceList ) < 0 ) return ; switch ( bt ) { case BT_NON_BOOTABLE : allowed_partition_scheme [ PARTITION_STYLE_SFD ] = TRUE ; allowed_target_system [ 0 ] = FALSE ; allowed_target_system [ 1 ] = FALSE ; allowed_target_system [ 2 ] = TRUE ; break ; case BT_IMAGE : if ( image_path == NULL ) break ; if ( ! IS_EFI_BOOTABLE ( img_report ) ) { allowed_partition_scheme [ PARTITION_STYLE_GPT ] = FALSE ; allowed_target_system [ 1 ] = FALSE ; break ; } if ( IS_BIOS_BOOTABLE ( img_report ) ) { if ( ! HAS_WINDOWS ( img_report ) || allow_dual_uefi_bios || is_windows_to_go_selected ) { allowed_target_system [ 0 ] = FALSE ; allowed_target_system [ 1 ] = TRUE ; allowed_target_system [ 2 ] = TRUE ; } } else { allowed_target_system [ 0 ] = FALSE ; } break ; case BT_MSDOS : case BT_FREEDOS : case BT_SYSLINUX_V4 : case BT_SYSLINUX_V6 : case BT_REACTOS : case BT_GRUB4DOS : case BT_GRUB2 : allowed_partition_scheme [ PARTITION_STYLE_GPT ] = FALSE ; allowed_target_system [ 1 ] = FALSE ; break ; case BT_UEFI_NTFS : allowed_target_system [ 0 ] = FALSE ; break ; } if ( ! only_target ) { int preferred_pt = SelectedDrive . PartitionStyle ; if ( allowed_partition_scheme [ PARTITION_STYLE_MBR ] ) IGNORE_RETVAL ( ComboBox_SetItemData ( hPartitionScheme , ComboBox_AddStringU ( hPartitionScheme , "MBR" ) , PARTITION_STYLE_MBR ) ) ; if ( allowed_partition_scheme [ PARTITION_STYLE_GPT ] ) IGNORE_RETVAL ( ComboBox_SetItemData ( hPartitionScheme , ComboBox_AddStringU ( hPartitionScheme , "GPT" ) , PARTITION_STYLE_GPT ) ) ; if ( allowed_partition_scheme [ PARTITION_STYLE_SFD ] ) IGNORE_RETVAL ( ComboBox_SetItemData ( hPartitionScheme , ComboBox_AddStringU ( hPartitionScheme , sfd_name ) , PARTITION_STYLE_SFD ) ) ; if ( bt == BT_NON_BOOTABLE ) preferred_pt = ( selected_pt >= 0 ) ? selected_pt : PARTITION_STYLE_MBR ; else if ( bt == BT_UEFI_NTFS ) preferred_pt = ( selected_pt >= 0 ) ? selected_pt : PARTITION_STYLE_GPT ; else if ( ( bt == BT_IMAGE ) && ( image_path != NULL ) && ( img_report . is_iso ) ) { if ( HAS_WINDOWS ( img_report ) && img_report . has_efi ) <S2SV_StartBug> preferred_pt = allow_dual_uefi_bios ? PARTITION_STYLE_MBR : PARTITION_STYLE_GPT ; <S2SV_EndBug> if ( img_report . is_bootable_img ) preferred_pt = ( selected_pt >= 0 ) ? selected_pt : PARTITION_STYLE_MBR ; } SetComboEntry ( hPartitionScheme , preferred_pt ) ; pt = ( int ) ComboBox_GetItemData ( hPartitionScheme , ComboBox_GetCurSel ( hPartitionScheme ) ) ; } has_uefi_csm = FALSE ; if ( allowed_target_system [ 0 ] && ( pt != PARTITION_STYLE_GPT ) ) { IGNORE_RETVAL ( ComboBox_SetItemData ( hTargetSystem , ComboBox_AddStringU ( hTargetSystem , lmprintf ( MSG_031 ) ) , TT_BIOS ) ) ; has_uefi_csm = TRUE ; } if ( allowed_target_system [ 1 ] && ! ( ( pt == PARTITION_STYLE_MBR ) && IS_BIOS_BOOTABLE ( img_report ) && IS_EFI_BOOTABLE ( img_report ) ) ) IGNORE_RETVAL ( ComboBox_SetItemData ( hTargetSystem , ComboBox_AddStringU ( hTargetSystem , lmprintf ( MSG_032 ) ) , TT_UEFI ) ) ; if ( allowed_target_system [ 2 ] && ( ( pt != PARTITION_STYLE_GPT ) || ( bt == BT_NON_BOOTABLE ) ) ) IGNORE_RETVAL ( ComboBox_SetItemData ( hTargetSystem , ComboBox_AddStringU ( hTargetSystem , lmprintf ( MSG_033 ) ) , TT_BIOS ) ) ; IGNORE_RETVAL ( ComboBox_SetCurSel ( hTargetSystem , 0 ) ) ; tt = ( int ) ComboBox_GetItemData ( hTargetSystem , ComboBox_GetCurSel ( hTargetSystem ) ) ; SendMessage ( hMainDialog , UM_UPDATE_CSM_TOOLTIP , 0 , 0 ) ; } | <S2SV_ModStart> ? PARTITION_STYLE_MBR : ( ( selected_pt >= 0 ) ? selected_pt : PARTITION_STYLE_GPT ) <S2SV_ModEnd> ; if ( |
2,155 | CWE-000 char * ft_strtrim ( char const * s ) { char * trimstr ; int count ; int start ; start = 0 ; count = 0 ; while ( s [ start ] == '<S2SV_blank>' || s [ start ] == '\\n' || s [ start ] == '\\t' ) start ++ ; count = get_count ( s , count , start ) ; <S2SV_StartBug> trimstr = ( char ) malloc ( sizeof ( char ) * ( count + 1 ) ) ; <S2SV_EndBug> if ( trimstr ) { while ( count -- ) * trimstr ++ = s [ start ++ ] ; * trimstr = '\\0' ; return ( trimstr ) ; } return ( NULL ) ; } | <S2SV_ModStart> = ( char * <S2SV_ModStart> sizeof ( char * |
2,156 | CWE-000 int32_t hash_delete ( hm_node_ptr node , str_t key ) { if ( ! node ) { return 0 ; } int32_t mid_key = hash ( key , node -> dep ) ; while ( 1 ) { if ( node -> len_of_list [ mid_key ] < MAX_HASH_DEP ) { avlnode_ptr new_avl_node ; avl_new_node ( & new_avl_node , key , NULL ) ; avl_remove_node ( node -> top [ mid_key ] , new_avl_node ) ; free ( new_avl_node ) ; <S2SV_StartBug> } else { <S2SV_EndBug> node = node -> top [ mid_key ] ; mid_key = hash ( key , node -> dep ) ; } } return 1 ; } | <S2SV_ModStart> new_avl_node ) ; node -> len_of_list [ mid_key ] -- ; break ; |
2,157 | CWE-000 int main ( int argc , char * * argv ) { cellgrid * cgrid ; initscr ( ) ; start_color ( ) ; cbreak ( ) ; noecho ( ) ; nonl ( ) ; intrflush ( stdscr , FALSE ) ; keypad ( stdscr , TRUE ) ; assume_default_colors ( COLOR_GREEN , COLOR_BLACK ) ; clear ( ) ; gol_set_default_rules ( ) ; cgrid = create_cellgrid ( LINES - 2 , COLS - 1 ) ; <S2SV_StartBug> generate_random_cells ( cgrid ) ; <S2SV_EndBug> while ( 1 ) { draw_cells ( cgrid ) ; gol_do_iteration ( & cgrid ) ; if ( cgrid -> iteration % 5 == 0 ) { if ( gol_is_repeating ( cgrid ) == TRUE ) { sleep ( 2 ) ; free_cellgrid ( cgrid ) ; cgrid = create_cellgrid ( LINES - 2 , COLS - 1 ) ; generate_random_cells ( cgrid ) ; } } } sleep ( 3 ) ; endwin ( ) ; return 0 ; } | <S2SV_ModStart> 1 ) ; generate_pulsar ( cgrid ) ; draw_blinker ( cgrid , 20 , 20 , TRUE <S2SV_ModEnd> ) ; while |
2,158 | CWE-000 void TMR1handler ( ) { ball . done_waiting = 1 ; TMR1H = ball_high_byte ; TMR1L = ball_low_byte ; PIR1bits . TMR1IF = 0 ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> = 0 ; T0CONbits . TMR0ON = 0 ; |
2,159 | CWE-000 void decompress_images ( void ) { gfx_image_t * tmp_ptr ; <S2SV_StartBug> tmp_ptr = gfx_MallocSprite ( 40 , 32 ) ; <S2SV_EndBug> <S2SV_StartBug> dzx7_Standard ( kong_standing_compressed , tmp_ptr ) ; <S2SV_EndBug> <S2SV_StartBug> kong_sprite [ 0 ] = tmp_ptr ; <S2SV_EndBug> <S2SV_StartBug> tmp_ptr = gfx_MallocSprite ( 43 , 32 ) ; <S2SV_EndBug> dzx7_Standard ( kong_left_compressed , tmp_ptr ) ; kong_sprite [ 1 ] = tmp_ptr ; tmp_ptr = gfx_MallocSprite ( 40 , 32 ) ; dzx7_Standard ( kong_holding_compressed , tmp_ptr ) ; kong_sprite [ 2 ] = tmp_ptr ; tmp_ptr = gfx_MallocSprite ( 43 , 32 ) ; dzx7_Standard ( kong_right_compressed , tmp_ptr ) ; kong_sprite [ 3 ] = tmp_ptr ; tmp_ptr = gfx_MallocSprite ( 46 , 32 ) ; dzx7_Standard ( kong_arm_left_compressed , tmp_ptr ) ; kong_sprite [ 4 ] = tmp_ptr ; tmp_ptr = gfx_MallocSprite ( 46 , 32 ) ; dzx7_Standard ( kong_arm_right_compressed , tmp_ptr ) ; kong_sprite [ 5 ] = tmp_ptr ; tmp_ptr = gfx_MallocSprite ( 33 , 36 ) ; dzx7_Standard ( kong_climbing_left0_compressed , tmp_ptr ) ; kong_sprite [ 6 ] = tmp_ptr ; tmp_ptr = gfx_MallocSprite ( 33 , 36 ) ; dzx7_Standard ( kong_climbing_right0_compressed , tmp_ptr ) ; kong_sprite [ 7 ] = tmp_ptr ; tmp_ptr = gfx_MallocSprite ( 38 , 36 ) ; dzx7_Standard ( kong_climbing_left1_compressed , tmp_ptr ) ; kong_sprite [ 8 ] = tmp_ptr ; tmp_ptr = gfx_MallocSprite ( 43 , 36 ) ; dzx7_Standard ( kong_climbing_right1_compressed , tmp_ptr ) ; kong_sprite [ 9 ] = tmp_ptr ; tmp_ptr = gfx_MallocSprite ( 40 , 32 ) ; dzx7_Standard ( kong_onhead_compressed , tmp_ptr ) ; kong_sprite [ 10 ] = tmp_ptr ; tmp_ptr = gfx_MallocSprite ( 40 , 32 ) ; dzx7_Standard ( kong_knockedout_compressed , tmp_ptr ) ; kong_sprite [ 11 ] = tmp_ptr ; tmp_ptr = gfx_MallocSprite ( 40 , 32 ) ; kong_sprite [ 12 ] = gfx_RotateSpriteHalf ( kong_sprite [ 10 ] , tmp_ptr ) ; kong_goofy = gfx_MallocSprite ( 46 , 32 ) ; dzx7_Standard ( kong_goofy_compressed , kong_goofy ) ; } | <S2SV_ModStart> * tmp_ptr ; uint8_t i ; for ( i = 0 ; i < 12 ; i ++ ) { <S2SV_ModStart> = gfx_MallocSprite ( * kong_compressed_images [ i ] , * ( kong_compressed_images [ i ] + 2 ) <S2SV_ModEnd> ) ; dzx7_Standard <S2SV_ModStart> ; dzx7_Standard ( kong_compressed_images [ i ] <S2SV_ModEnd> , tmp_ptr ) <S2SV_ModStart> ; kong_sprite [ i <S2SV_ModEnd> ] = tmp_ptr <S2SV_ModStart> = tmp_ptr ; } <S2SV_ModEnd> tmp_ptr = gfx_MallocSprite |
2,160 | CWE-000 struct dst_entry * ip6_sk_dst_lookup_flow ( struct sock * sk , struct flowi6 * fl6 , const struct in6_addr * final_dst ) { struct dst_entry * dst = sk_dst_check ( sk , inet6_sk ( sk ) -> dst_cookie ) ; <S2SV_StartBug> int err ; <S2SV_EndBug> dst = ip6_sk_dst_check ( sk , dst , fl6 ) ; <S2SV_StartBug> err = ip6_dst_lookup_tail ( sk , & dst , fl6 ) ; <S2SV_EndBug> if ( err ) return ERR_PTR ( err ) ; if ( final_dst ) fl6 -> daddr = * final_dst ; return xfrm_lookup_route ( sock_net ( sk ) , dst , flowi6_to_flowi ( fl6 ) , sk , 0 ) ; } | <S2SV_ModStart> dst_cookie ) ; <S2SV_ModEnd> dst = ip6_sk_dst_check <S2SV_ModStart> fl6 ) ; if ( ! dst ) dst = ip6_dst_lookup_flow <S2SV_ModEnd> ( sk , <S2SV_ModStart> ( sk , fl6 , final_dst ) ; return dst <S2SV_ModEnd> ; } <S2SV_null> |
2,161 | CWE-000 static int onopen ( WSPipeOut * pipeout , WSClient * client ) { uint32_t hsize = sizeof ( uint32_t ) * 3 ; char * hdr = calloc ( hsize , sizeof ( char ) ) ; char * ptr = hdr ; <S2SV_StartBug> ptr += pack_uint32 ( ptr , client -> listener ) ; <S2SV_EndBug> ptr += pack_uint32 ( ptr , 0x10 ) ; ptr += pack_uint32 ( ptr , INET6_ADDRSTRLEN ) ; ws_write_fifo ( pipeout , hdr , hsize ) ; ws_write_fifo ( pipeout , client -> remote_ip , INET6_ADDRSTRLEN ) ; free ( hdr ) ; return 0 ; } | <S2SV_ModStart> ( ptr , ( uint32_t ) |
2,162 | CWE-000 void readallPhys ( int physPin ) { # ifdef CONFIG_ORANGEPI <S2SV_StartBug> if ( physPin < 0 || physPin > 40 ) <S2SV_EndBug> return ; # endif int pin ; int val ; ( physPinToGpio ( physPin ) > 0 ) ? printf ( "<S2SV_blank>|<S2SV_blank>%3d<S2SV_blank>" , physPinToGpio ( physPin ) ) : printf ( "<S2SV_blank>|<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" ) ; ( physPinToPin ( physPin ) > 0 ) ? printf ( "<S2SV_blank>|<S2SV_blank>%3d<S2SV_blank>" , physPinToPin ( physPin ) ) : printf ( "<S2SV_blank>|<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" ) ; printf ( "<S2SV_blank>|<S2SV_blank>%s" , physNames [ physPin ] ) ; if ( physPinToPin ( physPin ) > 0 ) { if ( wpMode == WPI_MODE_GPIO ) pin = physPinToGpio ( physPin ) ; else if ( wpMode == WPI_MODE_PHYS ) pin = physPin ; else if ( wpMode == WPI_MODE_PINS ) pin = physPinToPin ( physPin ) ; else pin = - 1 ; int alt = getAlt ( pin ) ; ( alt >= 0 && alt < ALT_COUNT ) ? printf ( "<S2SV_blank>|<S2SV_blank>%4s" , alts [ alt ] ) : printf ( "<S2SV_blank>|<S2SV_blank>INVALID" ) ; val = digitalRead ( pin ) ; if ( val == - 1 ) printf ( "<S2SV_blank>|<S2SV_blank>0" ) ; else printf ( "<S2SV_blank>|<S2SV_blank>%d" , val ) ; } else { printf ( "<S2SV_blank>|<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>|<S2SV_blank><S2SV_blank>" ) ; } printf ( "<S2SV_blank>|<S2SV_blank>%2d" , physPin ) ; ++ physPin ; printf ( "<S2SV_blank>||<S2SV_blank>%-2d" , physPin ) ; if ( physPinToPin ( physPin ) > 0 ) { if ( wpMode == WPI_MODE_GPIO ) pin = physPinToGpio ( physPin ) ; else if ( wpMode == WPI_MODE_PHYS ) pin = physPin ; else if ( wpMode == WPI_MODE_PINS ) pin = physPinToPin ( physPin ) ; else pin = - 1 ; val = digitalRead ( pin ) ; if ( val == - 1 ) printf ( "<S2SV_blank>|<S2SV_blank>0" ) ; else printf ( "<S2SV_blank>|<S2SV_blank>%d" , val ) ; int alt = getAlt ( pin ) ; ( alt >= 0 && alt < ALT_COUNT ) ? printf ( "<S2SV_blank>|<S2SV_blank>%-4s" , alts [ alt ] ) : printf ( "<S2SV_blank>|<S2SV_blank>INVALID" ) ; } else { printf ( "<S2SV_blank>|<S2SV_blank><S2SV_blank><S2SV_blank>|<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" ) ; } printf ( "<S2SV_blank>|<S2SV_blank>%-5s" , physNames [ physPin ] ) ; ( physPinToGpio ( physPin ) > 0 ) ? printf ( "<S2SV_blank>|<S2SV_blank>%-3d<S2SV_blank>" , physPinToGpio ( physPin ) ) : printf ( "<S2SV_blank>|<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" ) ; ( physPinToPin ( physPin ) > 0 ) ? printf ( "<S2SV_blank>|<S2SV_blank>%-3d<S2SV_blank>" , physPinToPin ( physPin ) ) : printf ( "<S2SV_blank>|<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" ) ; printf ( "<S2SV_blank>|\\n" ) ; } | <S2SV_ModStart> || physPin > GPIO_PHY_NUM <S2SV_ModEnd> ) return ; |
2,163 | CWE-000 int main ( int argc , char * argv [ ] ) { if ( argc != 2 ) { fprintf ( stderr , "Usage:<S2SV_blank>%s<S2SV_blank>[input-file]\\n" , argv [ 0 ] ) ; fprintf ( stderr , "The<S2SV_blank>input<S2SV_blank>file<S2SV_blank>provided<S2SV_blank>is<S2SV_blank>the<S2SV_blank>y86<S2SV_blank>binary<S2SV_blank>program<S2SV_blank>to<S2SV_blank>be<S2SV_blank>simulated\\n" ) ; return - 1 ; } if ( access ( argv [ 1 ] , F_OK ) == - 1 ) { <S2SV_StartBug> fprintf ( stderr , "The<S2SV_blank>file<S2SV_blank>provided<S2SV_blank>does<S2SV_blank>not<S2SV_blank>exist.<S2SV_blank>Try<S2SV_blank>with<S2SV_blank>a<S2SV_blank>different<S2SV_blank>file." ) ; <S2SV_EndBug> return - 1 ; } state_t * state = parse ( argv [ 1 ] ) ; state_print ( state , stdout ) ; y86addr_t stat ; state_get_stat ( state , & stat ) ; while ( stat == STAT_AOK ) { execute_next_instruction ( state ) ; state_get_stat ( state , & stat ) ; } printf ( "\\nFinal<S2SV_blank>State:\\n==================================\\n\\n" ) ; state_print ( state , stdout ) ; state_destroy ( state ) ; return 0 ; } | <S2SV_ModStart> ( stderr , "The<S2SV_blank>file<S2SV_blank>provided<S2SV_blank>does<S2SV_blank>not<S2SV_blank>exist.<S2SV_blank>Try<S2SV_blank>with<S2SV_blank>a<S2SV_blank>different<S2SV_blank>file.\\n" <S2SV_ModEnd> ) ; return |
2,164 | CWE-000 static void gdlm_bast ( void * arg , int mode ) { struct gfs2_glock * gl = arg ; switch ( mode ) { case DLM_LOCK_EX : gfs2_glock_cb ( gl , LM_ST_UNLOCKED ) ; break ; case DLM_LOCK_CW : gfs2_glock_cb ( gl , LM_ST_DEFERRED ) ; break ; case DLM_LOCK_PR : gfs2_glock_cb ( gl , LM_ST_SHARED ) ; break ; default : <S2SV_StartBug> pr_err ( "unknown<S2SV_blank>bast<S2SV_blank>mode<S2SV_blank>%d\\n" , mode ) ; <S2SV_EndBug> BUG ( ) ; } } | <S2SV_ModStart> ; default : fs_err ( gl -> gl_name . ln_sbd , <S2SV_ModEnd> "unknown<S2SV_blank>bast<S2SV_blank>mode<S2SV_blank>%d\\n" , mode |
2,165 | CWE-000 int orangefs_inode_check_changed ( struct inode * inode ) { struct orangefs_inode_s * orangefs_inode = ORANGEFS_I ( inode ) ; struct orangefs_kernel_op_s * new_op ; int ret ; gossip_debug ( GOSSIP_UTILS_DEBUG , "%s:<S2SV_blank>called<S2SV_blank>on<S2SV_blank>inode<S2SV_blank>%pU\\n" , __func__ , get_khandle_from_ino ( inode ) ) ; new_op = op_alloc ( ORANGEFS_VFS_OP_GETATTR ) ; if ( ! new_op ) return - ENOMEM ; new_op -> upcall . req . getattr . refn = orangefs_inode -> refn ; new_op -> upcall . req . getattr . mask = ORANGEFS_ATTR_SYS_TYPE | ORANGEFS_ATTR_SYS_LNK_TARGET ; ret = service_operation ( new_op , __func__ , get_interruptible_flag ( inode ) ) ; if ( ret != 0 ) goto out ; <S2SV_StartBug> ret = orangefs_inode_is_stale ( inode , 0 , <S2SV_EndBug> & new_op -> downcall . resp . getattr . attributes , new_op -> downcall . resp . getattr . link_target ) ; out : op_release ( new_op ) ; return ret ; } | <S2SV_ModStart> ( inode , <S2SV_ModEnd> & new_op -> |
2,166 | CWE-000 int loop ( void * arg ) { for ( ; ; ) { unsigned nevents = epoll_wait ( epfd , events , MAX_EVENTS , 0 ) ; unsigned i ; for ( i = 0 ; i < nevents ; ++ i ) { struct epoll_event event = events [ i ] ; int clientfd = event . data . fd ; if ( isContains ( clientfd , sockfds , servPorts ) ) { while ( 1 ) { <S2SV_StartBug> int nclientfd = accept ( sockfd , NULL , NULL ) ; <S2SV_EndBug> if ( nclientfd < 0 ) { break ; } ev . data . fd = nclientfd ; ev . events = EPOLLIN ; if ( epoll_ctl ( epfd , EPOLL_CTL_ADD , nclientfd , & ev ) != 0 ) { printf ( "ff_epoll_ctl<S2SV_blank>failed:%d,<S2SV_blank>%s\\n" , errno , strerror ( errno ) ) ; break ; } if ( ( ++ nConn & 0x3ff ) == 0x3ff ) { printf ( "nConn=%d,time=%ld\\n" , nConn , time ( NULL ) ) ; } } } else { if ( event . events & EPOLLERR ) { epoll_ctl ( epfd , EPOLL_CTL_DEL , clientfd , NULL ) ; close ( clientfd ) ; if ( ( -- nConn & 0x3ff ) == 0x3ff ) { printf ( "nConn=%d,time=%ld\\n" , nConn , time ( NULL ) ) ; } } else if ( event . events & EPOLLIN ) { char buf [ 256 ] ; size_t readlen = read ( clientfd , buf , sizeof ( buf ) ) ; if ( readlen > 0 ) { if ( ( ++ nReceiveMsg & 0x3fff ) == 0x3fff ) { printf ( "nReceiveMsg=%d,time=%ld\\n" , nReceiveMsg , time ( NULL ) ) ; } write ( events [ i ] . data . fd , html , sizeof ( html ) ) ; } else { epoll_ctl ( epfd , EPOLL_CTL_DEL , events [ i ] . data . fd , NULL ) ; close ( events [ i ] . data . fd ) ; if ( ( -- nConn & 0x3ff ) == 0x3ff ) { printf ( "nConn=%d,time=%ld\\n" , nConn , time ( NULL ) ) ; } } } else { printf ( "unknown<S2SV_blank>event:<S2SV_blank>%8.8X\\n" , events [ i ] . events ) ; } } } } } | <S2SV_ModStart> = accept ( clientfd <S2SV_ModEnd> , NULL , |
2,167 | CWE-000 double random_coal ( ) { <S2SV_StartBug> return 47 * gsl_ran_beta ( r , 0.5 , 0.5 ) ; <S2SV_EndBug> } | <S2SV_ModStart> gsl_ran_beta ( r [ omp_get_thread_num ( ) ] |
2,168 | CWE-000 static int msm_isp_buf_mgr_debug ( struct msm_isp_buf_mgr * buf_mgr ) { struct msm_isp_buffer * bufs = NULL ; uint32_t i = 0 , j = 0 , k = 0 , rc = 0 ; <S2SV_StartBug> char * print_buf = NULL , temp_buf [ 512 ] ; <S2SV_EndBug> <S2SV_StartBug> uint32_t print_buf_size = 2000 ; <S2SV_EndBug> <S2SV_StartBug> unsigned long start_addr = 0 , end_addr = 0 ; <S2SV_EndBug> if ( ! buf_mgr ) { pr_err_ratelimited ( "%s:<S2SV_blank>%d]<S2SV_blank>NULL<S2SV_blank>buf_mgr\\n" , __func__ , __LINE__ ) ; return - EINVAL ; } print_buf = kzalloc ( print_buf_size , GFP_ATOMIC ) ; if ( ! print_buf ) { pr_err ( "%s<S2SV_blank>failed:<S2SV_blank>no<S2SV_blank>memory" , __func__ ) ; return - ENOMEM ; } snprintf ( print_buf , print_buf_size , "%s\\n" , __func__ ) ; for ( i = 0 ; i < BUF_MGR_NUM_BUF_Q ; i ++ ) { if ( buf_mgr -> bufq [ i ] . bufq_handle != 0 ) { snprintf ( temp_buf , sizeof ( temp_buf ) , "handle<S2SV_blank>%x<S2SV_blank>stream<S2SV_blank>%x<S2SV_blank>num_bufs<S2SV_blank>%d\\n" , buf_mgr -> bufq [ i ] . bufq_handle , buf_mgr -> bufq [ i ] . stream_id , buf_mgr -> bufq [ i ] . num_bufs ) ; strlcat ( print_buf , temp_buf , print_buf_size ) ; for ( j = 0 ; j < buf_mgr -> bufq [ i ] . num_bufs ; j ++ ) { bufs = & buf_mgr -> bufq [ i ] . bufs [ j ] ; if ( ! bufs ) break ; for ( k = 0 ; k < bufs -> num_planes ; k ++ ) { start_addr = bufs -> mapped_info [ k ] . paddr ; end_addr = bufs -> mapped_info [ k ] . paddr + bufs -> mapped_info [ k ] . len ; snprintf ( temp_buf , sizeof ( temp_buf ) , "<S2SV_blank>buf<S2SV_blank>%d<S2SV_blank>plane<S2SV_blank>%d<S2SV_blank>start_addr<S2SV_blank>%pK<S2SV_blank>end_addr<S2SV_blank>%pK\\n" , j , k , ( void * ) start_addr , ( void * ) end_addr ) ; strlcat ( print_buf , temp_buf , print_buf_size ) ; } } start_addr = 0 ; end_addr = 0 ; } } pr_err ( "%s\\n" , print_buf ) ; kfree ( print_buf ) ; return rc ; } | <S2SV_ModStart> , temp_buf [ 100 ] ; uint32_t start_addr = 0 , end_addr = 0 , <S2SV_ModEnd> print_buf_size = 2000 <S2SV_ModStart> print_buf_size = 2000 ; int buf_addr_delta = - 1 ; int temp_delta = 0 ; uint32_t debug_stream_id = 0 ; uint32_t debug_buf_idx = 0 ; uint32_t debug_buf_plane = 0 ; uint32_t debug_start_addr = 0 ; uint32_t debug_end_addr = 0 ; uint32_t debug_frame_id = 0 ; enum msm_isp_buffer_state debug_state = 0 <S2SV_ModStart> ; unsigned long flags ; struct msm_isp_bufq * bufq = NULL <S2SV_ModEnd> ; if ( |
2,169 | CWE-000 static int EventHandler ( lwm2mcore_Status_t status ) { int result = 0 ; switch ( status . event ) { case LWM2MCORE_EVENT_SESSION_STARTED : LE_DEBUG ( "Session<S2SV_blank>start" ) ; break ; case LWM2MCORE_EVENT_SESSION_FAILED : LE_ERROR ( "Session<S2SV_blank>failure" ) ; if ( LE_AVC_BOOTSTRAP_SESSION == le_avc_GetSessionType ( ) ) { avcServer_UpdateStatus ( LE_AVC_SESSION_FAILED , LE_AVC_UNKNOWN_UPDATE , - 1 , - 1 , LE_AVC_ERR_NONE ) ; LE_ERROR ( "Session<S2SV_blank>failure<S2SV_blank>on<S2SV_blank>bootstrap<S2SV_blank>server" ) ; le_event_Report ( BsFailureEventId , NULL , 0 ) ; } break ; case LWM2MCORE_EVENT_SESSION_FINISHED : LE_DEBUG ( "Session<S2SV_blank>finished" ) ; avcServer_UpdateStatus ( LE_AVC_SESSION_STOPPED , LE_AVC_UNKNOWN_UPDATE , - 1 , - 1 , LE_AVC_ERR_NONE ) ; SessionStarted = false ; <S2SV_StartBug> break ; <S2SV_EndBug> case LWM2MCORE_EVENT_LWM2M_SESSION_TYPE_START : if ( status . u . session . type == LWM2MCORE_SESSION_BOOTSTRAP ) { LE_DEBUG ( "Connected<S2SV_blank>to<S2SV_blank>bootstrap" ) ; avcServer_UpdateStatus ( LE_AVC_SESSION_BS_STARTED , LE_AVC_UNKNOWN_UPDATE , - 1 , - 1 , LE_AVC_ERR_NONE ) ; } else { LE_DEBUG ( "Connected<S2SV_blank>to<S2SV_blank>DM" ) ; avcServer_UpdateStatus ( LE_AVC_SESSION_STARTED , LE_AVC_UNKNOWN_UPDATE , - 1 , - 1 , LE_AVC_ERR_NONE ) ; SessionStarted = true ; } AuthenticationPhase = false ; break ; case LWM2MCORE_EVENT_PACKAGE_DOWNLOAD_DETAILS : case LWM2MCORE_EVENT_DOWNLOAD_PROGRESS : case LWM2MCORE_EVENT_PACKAGE_DOWNLOAD_FINISHED : case LWM2MCORE_EVENT_PACKAGE_DOWNLOAD_FAILED : case LWM2MCORE_EVENT_UPDATE_STARTED : case LWM2MCORE_EVENT_UPDATE_FINISHED : case LWM2MCORE_EVENT_UPDATE_FAILED : case LWM2MCORE_EVENT_PACKAGE_CERTIFICATION_OK : case LWM2MCORE_EVENT_PACKAGE_CERTIFICATION_NOT_OK : result = PackageEventHandler ( status ) ; break ; case LWM2MCORE_EVENT_AUTHENTICATION_STARTED : if ( status . u . session . type == LWM2MCORE_SESSION_BOOTSTRAP ) { LE_DEBUG ( "Authentication<S2SV_blank>to<S2SV_blank>BS<S2SV_blank>started" ) ; } else { LE_DEBUG ( "Authentication<S2SV_blank>to<S2SV_blank>DM<S2SV_blank>started" ) ; } AuthenticationPhase = true ; avcServer_UpdateStatus ( LE_AVC_AUTH_STARTED , LE_AVC_UNKNOWN_UPDATE , - 1 , - 1 , LE_AVC_ERR_NONE ) ; break ; case LWM2MCORE_EVENT_AUTHENTICATION_FAILED : if ( status . u . session . type == LWM2MCORE_SESSION_BOOTSTRAP ) { LE_WARN ( "Authentication<S2SV_blank>to<S2SV_blank>BS<S2SV_blank>failed" ) ; } else { LE_WARN ( "Authentication<S2SV_blank>to<S2SV_blank>DM<S2SV_blank>failed" ) ; } <S2SV_StartBug> avcServer_UpdateStatus ( LE_AVC_AUTH_FAILED , LE_AVC_UNKNOWN_UPDATE , <S2SV_EndBug> - 1 , - 1 , LE_AVC_ERR_NONE ) ; break ; default : if ( LWM2MCORE_EVENT_LAST <= status . event ) { LE_ERROR ( "Unsupported<S2SV_blank>event<S2SV_blank>%d" , status . event ) ; result = - 1 ; } break ; } return result ; } | <S2SV_ModStart> = false ; AuthenticationPhase = false ; <S2SV_ModStart> ) ; } AuthenticationPhase = false ; |
2,170 | CWE-000 int tls_sw_sendmsg ( struct sock * sk , struct msghdr * msg , size_t size ) { struct tls_context * tls_ctx = tls_get_ctx ( sk ) ; struct tls_sw_context * ctx = tls_sw_ctx ( tls_ctx ) ; int ret = 0 ; long timeo = sock_sndtimeo ( sk , msg -> msg_flags & MSG_DONTWAIT ) ; bool eor = ! ( msg -> msg_flags & MSG_MORE ) ; struct sk_buff * skb = NULL ; size_t copy , copied = 0 ; unsigned char record_type = TLS_RECORD_TYPE_DATA ; lock_sock ( sk ) ; if ( msg -> msg_flags & MSG_OOB ) { if ( ! eor || ctx -> unsent ) { ret = - EINVAL ; goto send_end ; } ret = copy_from_iter ( & record_type , 1 , & msg -> msg_iter ) ; if ( ret != 1 ) { return - EFAULT ; goto send_end ; } } while ( msg_data_left ( msg ) ) { bool merge = true ; int i ; struct page_frag * pfrag ; if ( sk -> sk_err ) goto send_end ; if ( ! sk_stream_memory_free ( sk ) ) goto wait_for_memory ; skb = skb_peek_tail ( & ctx -> tx_queue ) ; if ( ! skb && ! skb_frag_page ( & ctx -> tx_frag ) && eor ) { int pages ; int err ; int page_count = iov_iter_npages ( & msg -> msg_iter , ALG_MAX_PAGES ) ; struct scatterlist sgin [ ALG_MAX_PAGES + 1 ] ; int bytes ; sg_init_table ( sgin , ALG_MAX_PAGES + 1 ) ; if ( page_count >= ALG_MAX_PAGES ) goto reg_send ; err = zerocopy_from_iter ( & msg -> msg_iter , & sgin [ 0 ] , <S2SV_StartBug> & bytes ) ; <S2SV_EndBug> pages = err ; ctx -> unsent += bytes ; if ( err < 0 ) goto send_end ; tls_push_zerocopy ( sk , sgin , pages , bytes , record_type , msg -> msg_flags ) ; for ( ; pages > 0 ; pages -- ) put_page ( sg_page ( & sgin [ pages - 1 ] ) ) ; if ( err < 0 ) { tls_err_abort ( sk ) ; goto send_end ; } continue ; } reg_send : while ( ! skb ) { skb = alloc_skb ( 0 , sk -> sk_allocation ) ; if ( skb ) __skb_queue_tail ( & ctx -> tx_queue , skb ) ; } i = skb_shinfo ( skb ) -> nr_frags ; pfrag = sk_page_frag ( sk ) ; if ( ! sk_page_frag_refill ( sk , pfrag ) ) goto wait_for_memory ; if ( ! skb_can_coalesce ( skb , i , pfrag -> page , pfrag -> offset ) ) { if ( i == ALG_MAX_PAGES ) { struct sk_buff * tskb ; tskb = alloc_skb ( 0 , sk -> sk_allocation ) ; if ( ! tskb ) goto wait_for_memory ; if ( skb ) skb -> next = tskb ; else __skb_queue_tail ( & ctx -> tx_queue , tskb ) ; skb = tskb ; skb -> ip_summed = CHECKSUM_UNNECESSARY ; continue ; } merge = false ; } copy = min_t ( int , msg_data_left ( msg ) , pfrag -> size - pfrag -> offset ) ; copy = min_t ( int , copy , TLS_MAX_PAYLOAD_SIZE - ctx -> unsent ) ; if ( ! sk_wmem_schedule ( sk , copy ) ) goto wait_for_memory ; ret = skb_copy_to_page_nocache ( sk , & msg -> msg_iter , skb , pfrag -> page , pfrag -> offset , copy ) ; ctx -> wmem_len += copy ; if ( ret ) goto send_end ; if ( merge ) { skb_frag_size_add ( & skb_shinfo ( skb ) -> frags [ i - 1 ] , copy ) ; } else { skb_fill_page_desc ( skb , i , pfrag -> page , pfrag -> offset , copy ) ; get_page ( pfrag -> page ) ; } pfrag -> offset += copy ; copied += copy ; ctx -> unsent += copy ; if ( ctx -> unsent >= TLS_MAX_PAYLOAD_SIZE ) { ret = tls_push ( sk , record_type , msg -> msg_flags ) ; if ( ret ) goto send_end ; } continue ; wait_for_memory : set_bit ( SOCK_NOSPACE , & sk -> sk_socket -> flags ) ; ret = sk_stream_wait_memory ( sk , & timeo ) ; if ( ret ) goto send_end ; } if ( eor ) ret = tls_push ( sk , record_type , msg -> msg_flags ) ; send_end : ret = sk_stream_error ( sk , msg -> msg_flags , ret ) ; if ( unlikely ( skb_queue_len ( & ctx -> tx_queue ) == 0 && ret == - EAGAIN ) ) sk -> sk_write_space ( sk ) ; release_sock ( sk ) ; return ret < 0 ? ret : size ; } | <S2SV_ModStart> , & bytes , page_count |
2,171 | CWE-000 void create_performance_spin ( GtkWidget * window , const char * text , GtkWidget * table , int row , int parameter , int max , int init ) { GtkWidget * label ; GtkObject * spin_button_adj ; GtkWidget * spin_button ; label = gtk_label_new ( text ) ; gtk_widget_ref ( label ) ; gtk_object_set_data_full ( GTK_OBJECT ( window ) , "performance<S2SV_blank>label" , label , ( GtkDestroyNotify ) gtk_widget_unref ) ; gtk_widget_show ( label ) ; gtk_table_attach ( GTK_TABLE ( table ) , label , 0 , 1 , row , row + 1 , ( GtkAttachOptions ) ( GTK_FILL ) , ( GtkAttachOptions ) ( 0 ) , 0 , 0 ) ; gtk_misc_set_alignment ( GTK_MISC ( label ) , 0 , 0.5 ) ; gtk_misc_set_padding ( GTK_MISC ( label ) , 2 , 0 ) ; spin_button_adj = gtk_adjustment_new ( init , 0 , max , 1 , 10 , 0 ) ; performance_spin_adjustments [ parameter ] = spin_button_adj ; spin_button = gtk_spin_button_new ( GTK_ADJUSTMENT ( spin_button_adj ) , 1 , 0 ) ; gtk_widget_ref ( spin_button ) ; gtk_object_set_data_full ( GTK_OBJECT ( main_window ) , "performance<S2SV_blank>spin" , spin_button , ( GtkDestroyNotify ) gtk_widget_unref ) ; gtk_widget_show ( spin_button ) ; gtk_table_attach ( GTK_TABLE ( table ) , spin_button , 1 , 2 , row , row + 1 , ( GtkAttachOptions ) ( GTK_EXPAND | GTK_FILL ) , ( GtkAttachOptions ) ( GTK_FILL ) , 0 , 0 ) ; gtk_spin_button_set_update_policy ( GTK_SPIN_BUTTON ( spin_button ) , GTK_UPDATE_IF_VALID ) ; gtk_spin_button_set_numeric ( GTK_SPIN_BUTTON ( spin_button ) , TRUE ) ; gtk_signal_connect ( GTK_OBJECT ( spin_button_adj ) , "value_changed" , GTK_SIGNAL_FUNC ( on_performance_spin_change ) , <S2SV_StartBug> ( gpointer ) parameter ) ; <S2SV_EndBug> } | <S2SV_ModStart> on_performance_spin_change ) , GINT_TO_POINTER ( parameter ) <S2SV_ModEnd> ) ; } |
2,172 | CWE-000 static void limit_cpu_freqs ( uint32_t max_freq ) { unsigned int cpu ; if ( info . limited_max_freq == max_freq ) return ; info . limited_max_freq = max_freq ; info . pending_change = true ; <S2SV_StartBug> get_online_cpus ( ) ; <S2SV_EndBug> for_each_online_cpu ( cpu ) cpufreq_update_policy ( cpu ) ; put_online_cpus ( ) ; <S2SV_StartBug> info . pending_change = false ; <S2SV_EndBug> } | <S2SV_ModStart> = true ; pr_info_ratelimited ( "%s:<S2SV_blank>Setting<S2SV_blank>cpu<S2SV_blank>max<S2SV_blank>frequency<S2SV_blank>to<S2SV_blank>%u\\n" , KBUILD_MODNAME , max_freq ) ; if ( num_online_cpus ( ) < NR_CPUS ) { if ( max_freq > FREQ_NOTE_7 ) cpu_online_wrapper ( 2 ) ; if ( max_freq > FREQ_HELL ) cpu_online_wrapper ( 3 ) ; } <S2SV_ModStart> ( ) ; if ( max_freq == FREQ_HELL ) cpu_offline_wrapper ( 3 ) ; else if ( max_freq == FREQ_NOTE_7 ) cpu_offline_wrapper ( 2 ) ; |
2,173 | CWE-000 void karma_buf_modify ( t_karma * x , t_buffer_obj * b ) { double modbsr , modbmsr ; t_ptr_int modchans , modframes ; if ( b ) { modbsr = buffer_getsamplerate ( b ) ; modchans = buffer_getchannelcount ( b ) ; modframes = buffer_getframecount ( b ) ; modbmsr = buffer_getmillisamplerate ( b ) ; if ( ( ( x -> bchans != modchans ) || ( x -> bframes != modframes ) ) || ( x -> bmsr != modbmsr ) ) { x -> bsr = modbsr ; x -> bmsr = modbmsr ; x -> srscale = modbsr / x -> ssr ; x -> bframes = modframes ; x -> bchans = modchans ; x -> nchans = ( modchans < x -> ochans ) ? modchans : x -> ochans ; x -> minloop = x -> startloop = 0.0 ; <S2SV_StartBug> x -> maxloop = x -> endloop = ( x -> bframes - 1 ) * x -> bchans ; <S2SV_EndBug> x -> bvsnorm = x -> vsnorm * ( modbsr / ( double ) modframes ) ; karma_select_size ( x , x -> selection ) ; karma_select_start ( x , x -> selstart ) ; post ( "buff<S2SV_blank>modify<S2SV_blank>called" ) ; } } } | <S2SV_ModStart> * x -> nchans <S2SV_ModEnd> ; x -> |
2,174 | CWE-000 static void boot_find_cobjs ( struct cobj_header * h , int n ) { int i ; vaddr_t start , end ; start = ( vaddr_t ) h ; hs [ 0 ] = h ; for ( i = 1 ; i < n ; i ++ ) { int j = 0 , size = 0 , tot = 0 ; size = h -> size ; for ( j = 0 ; j < ( int ) h -> nsect ; j ++ ) { tot += cobj_sect_size ( h , j ) ; } <S2SV_StartBug> printc ( "cobj<S2SV_blank>%s:%d<S2SV_blank>found<S2SV_blank>at<S2SV_blank>%p:%x,<S2SV_blank>-><S2SV_blank>%x\\n" , h -> name , h -> id , hs [ i - 1 ] , size , <S2SV_EndBug> cobj_sect_get ( hs [ i - 1 ] , 0 ) -> vaddr ) ; end = start + round_up_to_cacheline ( size ) ; hs [ i ] = h = ( struct cobj_header * ) end ; start = end ; } hs [ n ] = NULL ; <S2SV_StartBug> printc ( "cobj<S2SV_blank>%s:%d<S2SV_blank>found<S2SV_blank>at<S2SV_blank>%p:%x<S2SV_blank>-><S2SV_blank>%x\\n" , hs [ n - 1 ] -> name , hs [ n - 1 ] -> id , hs [ n - 1 ] , hs [ n - 1 ] -> size , <S2SV_EndBug> cobj_sect_get ( hs [ n - 1 ] , 0 ) -> vaddr ) ; } | <S2SV_ModStart> ) ; } PRINTC <S2SV_ModEnd> ( "cobj<S2SV_blank>%s:%d<S2SV_blank>found<S2SV_blank>at<S2SV_blank>%p:%x,<S2SV_blank>-><S2SV_blank>%x\\n" , <S2SV_ModStart> = NULL ; PRINTC <S2SV_ModEnd> ( "cobj<S2SV_blank>%s:%d<S2SV_blank>found<S2SV_blank>at<S2SV_blank>%p:%x<S2SV_blank>-><S2SV_blank>%x\\n" , |
2,175 | CWE-000 ctest_return_t aRgbCreationTestCase ( ctest_t * test , void * arg ) { struct Rgb * rgb = malloc ( sizeof ( struct Rgb ) ) ; rgb -> r = 50 ; rgb -> g = 10 ; rgb -> b = 95 ; struct Xyz * xyz = generateXyzFromRgb ( rgb , adobeRgb ) ; struct aRgb * argb = getARgbFromXyz ( xyz ) ; CTAssertEqual ( test , 19.6f , roundDigit ( argb -> r * 100 , 100 ) , "Expect<S2SV_blank>R<S2SV_blank>to<S2SV_blank>be<S2SV_blank>equal<S2SV_blank>to<S2SV_blank>X<S2SV_blank>but<S2SV_blank>got<S2SV_blank>%f" , roundDigit ( argb -> r * 100 , 100 ) ) ; CTAssertEqual ( test , 3.89f , roundDigit ( argb -> g * 100 , 100 ) , "Expect<S2SV_blank>R<S2SV_blank>to<S2SV_blank>be<S2SV_blank>equal<S2SV_blank>to<S2SV_blank>X<S2SV_blank>but<S2SV_blank>got<S2SV_blank>%f" , roundDigit ( argb -> g * 100 , 100 ) ) ; CTAssertEqual ( test , 37.25f , roundDigit ( argb -> b * 100 , 100 ) , "Expect<S2SV_blank>R<S2SV_blank>to<S2SV_blank>be<S2SV_blank>equal<S2SV_blank>to<S2SV_blank>X<S2SV_blank>but<S2SV_blank>got<S2SV_blank>%f" , roundDigit ( argb -> b * 100 , 100 ) ) ; <S2SV_StartBug> free ( rgb ) ; <S2SV_EndBug> free ( argb ) ; } | <S2SV_ModStart> ; free ( <S2SV_ModEnd> argb ) ; |
2,176 | CWE-000 static void binder_transaction_buffer_release ( struct binder_proc * proc , struct binder_buffer * buffer , size_t * failed_at ) { size_t * offp , * off_end ; int debug_id = buffer -> debug_id ; binder_debug ( BINDER_DEBUG_TRANSACTION , "binder:<S2SV_blank>%d<S2SV_blank>buffer<S2SV_blank>release<S2SV_blank>%d,<S2SV_blank>size<S2SV_blank>%zd-%zd,<S2SV_blank>failed<S2SV_blank>at<S2SV_blank>%p\\n" , proc -> pid , buffer -> debug_id , buffer -> data_size , buffer -> offsets_size , failed_at ) ; if ( buffer -> target_node ) binder_dec_node ( buffer -> target_node , 1 , 0 ) ; offp = ( size_t * ) ( buffer -> data + ALIGN ( buffer -> data_size , sizeof ( void * ) ) ) ; if ( failed_at ) off_end = failed_at ; else off_end = ( void * ) offp + buffer -> offsets_size ; for ( ; offp < off_end ; offp ++ ) { struct flat_binder_object * fp ; if ( * offp > buffer -> data_size - sizeof ( * fp ) || buffer -> data_size < sizeof ( * fp ) || ! IS_ALIGNED ( * offp , sizeof ( u32 ) ) ) { pr_err ( "transaction<S2SV_blank>release<S2SV_blank>%d<S2SV_blank>bad<S2SV_blank>offset<S2SV_blank>%zd,<S2SV_blank>size<S2SV_blank>%zd\\n" , debug_id , * offp , buffer -> data_size ) ; continue ; } fp = ( struct flat_binder_object * ) ( buffer -> data + * offp ) ; switch ( fp -> type ) { case BINDER_TYPE_BINDER : case BINDER_TYPE_WEAK_BINDER : { struct binder_node * node = binder_get_node ( proc , fp -> binder ) ; if ( node == NULL ) { binder_debug ( BINDER_DEBUG_TOP_ERRORS , "binder:<S2SV_blank>transaction<S2SV_blank>release<S2SV_blank>%d" "<S2SV_blank>bad<S2SV_blank>node<S2SV_blank>%p\\n" , debug_id , fp -> binder ) ; break ; } binder_debug ( BINDER_DEBUG_TRANSACTION , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>node<S2SV_blank>%d<S2SV_blank>u%p\\n" , node -> debug_id , node -> ptr ) ; binder_dec_node ( node , fp -> type == BINDER_TYPE_BINDER , 0 ) ; } break ; case BINDER_TYPE_HANDLE : case BINDER_TYPE_WEAK_HANDLE : { struct binder_ref * ref = binder_get_ref ( proc , fp -> handle , fp -> type == BINDER_TYPE_HANDLE ) ; if ( ref == NULL ) { binder_debug ( BINDER_DEBUG_TOP_ERRORS , <S2SV_StartBug> "binder:<S2SV_blank>transaction<S2SV_blank>release<S2SV_blank>%d" <S2SV_EndBug> "<S2SV_blank>bad<S2SV_blank>handle<S2SV_blank>%ld\\n" , debug_id , fp -> handle ) ; break ; } binder_debug ( BINDER_DEBUG_TRANSACTION , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>ref<S2SV_blank>%d<S2SV_blank>desc<S2SV_blank>%d<S2SV_blank>(node<S2SV_blank>%d)\\n" , ref -> debug_id , ref -> desc , ref -> node -> debug_id ) ; binder_dec_ref ( ref , fp -> type == BINDER_TYPE_HANDLE ) ; } break ; case BINDER_TYPE_FD : binder_debug ( BINDER_DEBUG_TRANSACTION , <S2SV_StartBug> "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>fd<S2SV_blank>%ld\\n" , fp -> handle ) ; <S2SV_EndBug> if ( failed_at ) task_close_fd ( proc , fp -> handle ) ; break ; default : binder_debug ( BINDER_DEBUG_TOP_ERRORS , <S2SV_StartBug> "binder:<S2SV_blank>transaction<S2SV_blank>release<S2SV_blank>%d<S2SV_blank>bad<S2SV_blank>" <S2SV_EndBug> "object<S2SV_blank>type<S2SV_blank>%lx\\n" , debug_id , fp -> type ) ; break ; } } } | <S2SV_ModStart> ( BINDER_DEBUG_TOP_ERRORS , "transaction<S2SV_blank>release<S2SV_blank>%d<S2SV_blank>bad<S2SV_blank>handle<S2SV_blank>%d\\n" , debug_id , <S2SV_ModEnd> fp -> handle <S2SV_ModStart> ( BINDER_DEBUG_TRANSACTION , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>fd<S2SV_blank>%d\\n" <S2SV_ModEnd> , fp -> <S2SV_ModStart> ( BINDER_DEBUG_TOP_ERRORS , "transaction<S2SV_blank>release<S2SV_blank>%d<S2SV_blank>bad<S2SV_blank>object<S2SV_blank>type<S2SV_blank>%x\\n" , <S2SV_ModEnd> debug_id , fp |
2,177 | CWE-000 void initDrawing ( ) { logg ( "Initiate<S2SV_blank>drawing." ) ; <S2SV_StartBug> pvr_set_pal_format ( PVR_PAL_ARGB4444 ) ; <S2SV_EndBug> setDrawingParametersToIdentity ( ) ; gData . mMatrixStack = new_vector ( ) ; gData . mIsDisabled = 0 ; } | <S2SV_ModStart> ; pvr_set_pal_format ( PVR_PAL_ARGB8888 <S2SV_ModEnd> ) ; setDrawingParametersToIdentity |
2,178 | CWE-000 static void collect_points ( Sight * sight ) { int16_t y , x ; <S2SV_StartBug> for ( double deg = 0 ; deg < 360 ; deg ++ ) { <S2SV_EndBug> y = sight -> center . y + ( int16_t ) ( sight -> radius * sin ( deg ) ) ; x = sight -> center . x + ( int16_t ) ( sight -> radius * cos ( deg ) ) ; if ( y >= 0 && x >= 0 ) { ray_cast ( sight , point_new ( y , x ) ) ; } } add_point ( sight , sight -> center ) ; } | <S2SV_ModStart> ; for ( int <S2SV_ModEnd> deg = 0 |
2,179 | CWE-000 static uint32_t event_mask_to_epoll_events ( uint32_t events ) { uint32_t mask = 0 ; if ( events & EVENT_IO_READ ) { mask |= EVENT_EPOLL_READ ; } if ( events & EVENT_IO_WRITE ) { mask |= EVENT_EPOLL_WRITE ; } <S2SV_StartBug> if ( events & EVENT_IO_HANGUP ) { <S2SV_EndBug> mask |= EVENT_EPOLL_HANGUP ; } return mask ; } | <S2SV_ModStart> ( events & EVENT_IO_DISCONNECT <S2SV_ModEnd> ) { mask |
2,180 | CWE-000 static int lan9303_disable_processing ( struct lan9303 * chip ) { int p ; <S2SV_StartBug> for ( p = 0 ; p < LAN9303_NUM_PORTS ; p ++ ) { <S2SV_EndBug> int ret = lan9303_disable_processing_port ( chip , p ) ; if ( ret ) return ret ; } return 0 ; } | <S2SV_ModStart> ( p = 1 <S2SV_ModEnd> ; p < |
2,181 | CWE-000 static void * crack_thread ( void * arg ) { struct crack_job * j = arg ; struct random_data * buf = calloc ( 1 , sizeof ( struct random_data ) ) ; char * rand_statebuf = calloc ( 128 , 1 ) ; uint32_t seed = j -> start ; uint32_t limit = job_control . end ; initstate_r ( seed , rand_statebuf , 128 , buf ) ; int32_t res = 0 ; <S2SV_StartBug> while ( ! job_control . print_seed ) { <S2SV_EndBug> srandom_r ( seed , buf ) ; unsigned int i ; for ( i = 0 ; i < 4 ; i ++ ) { random_r ( buf , & res ) ; if ( ( uint32_t ) res != job_control . randr_enonce [ i ] ) break ; } if ( i == 4 ) { <S2SV_StartBug> job_control . print_seed = seed ; <S2SV_EndBug> <S2SV_StartBug> DEBUG_PRINT ( "Seed<S2SV_blank>found" ) ; <S2SV_EndBug> } if ( seed == 0 ) break ; seed -- ; if ( seed < j -> start - SECS_PER_JOB_BLOCK ) { long long tmp = j -> start - SECS_PER_JOB_BLOCK * job_control . jobs ; if ( tmp < 0 ) break ; j -> start = tmp ; seed = j -> start ; if ( seed < limit ) break ; } } free ( buf ) ; free ( rand_statebuf ) ; return 0 ; } | <S2SV_ModStart> ! job_control . nonce_seed <S2SV_ModEnd> ) { srandom_r <S2SV_ModStart> { job_control . nonce_seed <S2SV_ModEnd> = seed ; <S2SV_ModStart> ; DEBUG_PRINT ( "Seed<S2SV_blank>found<S2SV_blank>%u" , seed <S2SV_ModEnd> ) ; } |
2,182 | CWE-000 static fz_draw_state * fz_knockout_begin ( fz_context * ctx , fz_draw_device * dev ) { fz_irect bbox ; fz_pixmap * dest , * shape ; fz_draw_state * state = & dev -> stack [ dev -> top ] ; int isolated = state -> blendmode & FZ_BLEND_ISOLATED ; if ( ( state -> blendmode & FZ_BLEND_KNOCKOUT ) == 0 ) return state ; state = push_stack ( ctx , dev ) ; STACK_PUSHED ( "knockout" ) ; fz_pixmap_bbox ( ctx , state -> dest , & bbox ) ; fz_intersect_irect ( & bbox , & state -> scissor ) ; <S2SV_StartBug> dest = fz_new_pixmap_with_bbox ( ctx , state -> dest -> colorspace , & bbox , state -> dest -> seps , state -> dest -> alpha || isolated ) ; <S2SV_EndBug> if ( isolated ) { fz_clear_pixmap ( ctx , dest ) ; } else { int i = dev -> top - 1 ; fz_pixmap * prev = state -> dest ; while ( i > 0 ) { prev = dev -> stack [ -- i ] . dest ; if ( prev != state -> dest ) break ; } if ( prev ) fz_copy_pixmap_rect ( ctx , dest , prev , & bbox , dev -> default_cs ) ; else fz_clear_pixmap ( ctx , dest ) ; } <S2SV_StartBug> if ( ( state -> blendmode & FZ_BLEND_MODEMASK ) == 0 && isolated ) <S2SV_EndBug> { shape = state -> shape ; } else { shape = fz_new_pixmap_with_bbox ( ctx , NULL , & bbox , NULL , 1 ) ; fz_clear_pixmap ( ctx , shape ) ; <S2SV_StartBug> } <S2SV_EndBug> # ifdef DUMP_GROUP_BLENDS dump_spaces ( dev -> top - 1 , "" ) ; <S2SV_StartBug> { <S2SV_EndBug> char text [ 80 ] ; sprintf ( text , "Knockout<S2SV_blank>begin%s:<S2SV_blank>background<S2SV_blank>is<S2SV_blank>" , isolated ? "<S2SV_blank>(isolated)" : "" ) ; <S2SV_StartBug> fz_dump_blend ( ctx , text , dest ) ; <S2SV_EndBug> } if ( shape ) fz_dump_blend ( ctx , "/" , shape ) ; printf ( "\\n" ) ; # endif state [ 1 ] . scissor = bbox ; state [ 1 ] . dest = dest ; state [ 1 ] . shape = shape ; <S2SV_StartBug> state [ 1 ] . blendmode &= ~ FZ_BLEND_MODEMASK ; <S2SV_EndBug> return & state [ 1 ] ; } | <S2SV_ModStart> dest -> alpha <S2SV_ModEnd> ) ; if <S2SV_ModStart> ) ; } <S2SV_ModEnd> shape = fz_new_pixmap_with_bbox <S2SV_ModStart> shape ) ; <S2SV_ModEnd> # ifdef DUMP_GROUP_BLENDS <S2SV_ModStart> "" ) ; <S2SV_ModEnd> fz_dump_blend ( ctx <S2SV_ModStart> ( ctx , "Knockout<S2SV_blank>begin:<S2SV_blank>background<S2SV_blank>is<S2SV_blank>" , dest ) ; <S2SV_ModEnd> if ( shape <S2SV_ModStart> blendmode &= ~ ( FZ_BLEND_MODEMASK | FZ_BLEND_ISOLATED ) <S2SV_ModEnd> ; return & |
2,183 | CWE-000 void naiA_1d ( double * A , int l1 , int l2 , double PAx , double PBx , double CPx , double eta ) { int i , r , u , I ; <S2SV_StartBug> double f [ 2 * MAXL ] ; <S2SV_EndBug> <S2SV_StartBug> double CPx_pow [ 2 * MAXL ] ; <S2SV_EndBug> <S2SV_StartBug> double eta_pow [ 2 * MAXL ] ; <S2SV_EndBug> f_coef ( f , l1 , l2 , PAx , PBx ) ; eta = eta / 4.0 ; A [ 0 ] = 0.0 ; eta_pow [ 0 ] = 1.0 ; CPx_pow [ 0 ] = 1.0 ; for ( I = 1 ; I < l1 + l2 + 1 ; I ++ ) { A [ I ] = 0.0 ; eta_pow [ I ] = eta_pow [ I - 1 ] * eta ; CPx_pow [ I ] = CPx_pow [ I - 1 ] * CPx / I ; } for ( i = 0 ; i < ( l1 + l2 ) + 1 ; i ++ ) for ( r = 0 ; r < i / 2 + 1 ; r ++ ) for ( u = 0 ; u < ( i - r - r ) / 2 + 1 ; u ++ ) { I = i - r - r - u ; A [ I ] += f [ i ] * ( ( i + u ) & 1 ? - 1 : 1 ) * FACT [ i ] / ( FACT [ r ] * FACT [ u ] ) * CPx_pow [ I - u ] * eta_pow [ r + u ] ; } return ; } | <S2SV_ModStart> 2 * MAXL + 1 <S2SV_ModStart> 2 * MAXL + 1 <S2SV_ModStart> 2 * MAXL + 1 |
2,184 | CWE-000 int msgarrvd ( void * context , char * topicName , int topicLen , MQTTClient_message * message ) { char * payloadptr ; cJSON * root ; UNUSED ( payloadptr ) ; UNUSED ( context ) ; UNUSED ( topicLen ) ; <S2SV_StartBug> bool I_paquet = false ; <S2SV_EndBug> int select_meters ; char payload [ message -> payloadlen + 1 ] ; memcpy ( payload , message -> payload , message -> payloadlen ) ; payload [ message -> payloadlen ] = 0 ; printf ( "payload<S2SV_blank>display<S2SV_blank>:<S2SV_blank>%s\\n" , payload ) ; int offset = 0 ; char * dst = payload ; do { while ( dst [ offset ] == '[' ) ++ offset ; * dst = dst [ offset ] ; } while ( * dst ++ ) ; offset = 0 ; do { while ( dst [ offset ] == ']' ) ++ offset ; * dst = dst [ offset ] ; } while ( * dst ++ ) ; select_meters = parse_energy_meters ( payload ) ; printf ( "payload<S2SV_blank>display<S2SV_blank>:<S2SV_blank>%s\\n" , payload ) ; <S2SV_StartBug> if ( I_paquet ) { <S2SV_EndBug> root = cJSON_Parse ( payload ) ; printf ( "receive<S2SV_blank>paylaod<S2SV_blank>with<S2SV_blank>mqtt<S2SV_blank>:<S2SV_blank>%s\\n" , payload ) ; printf ( "palyoad<S2SV_blank>parsed<S2SV_blank>:<S2SV_blank>%s\\n" , cJSON_Print ( root ) ) ; cJSON * data = cJSON_GetObjectItemCaseSensitive ( root , "data" ) ; if ( cJSON_IsNumber ( data ) ) { meters [ select_meters ] = data -> valuedouble ; } Ppv = meters [ 0 ] + meters [ 1 ] + meters [ 2 ] ; Pl = meters [ 3 ] + meters [ 4 ] + meters [ 5 ] + meters [ 6 ] + meters [ 7 ] + meters [ 8 ] + meters [ 9 ] ; Kg = meters [ 11 ] ; Ps_opti = meters [ 14 ] ; } if ( strstr ( payload , XCOM_ID_CHARGER ) != NULL ) { root = cJSON_Parse ( payload ) ; cJSON * data = cJSON_GetObjectItemCaseSensitive ( root , "data" ) ; parse_studer_message ( payload , data ) ; } else if ( strstr ( payload , XCOM_ID_BAT ) != NULL ) { root = cJSON_Parse ( payload ) ; cJSON * data = cJSON_GetObjectItemCaseSensitive ( root , "data" ) ; UNUSED ( data ) ; parse_batt_message ( payload , data ) ; } MQTTClient_freeMessage ( & message ) ; MQTTClient_free ( topicName ) ; return 1 ; } | <S2SV_ModStart> topicLen ) ; <S2SV_ModEnd> int select_meters ; <S2SV_ModStart> ; if ( select_meters != - 1 <S2SV_ModEnd> ) { root |
2,185 | CWE-000 static int output ( void ) { if ( uip_ipaddr_cmp ( & last_sender , & UIP_IP_BUF -> srcipaddr ) ) { <S2SV_StartBug> PRINTF ( "slip-bridge:<S2SV_blank>Destination<S2SV_blank>off-link<S2SV_blank>but<S2SV_blank>no<S2SV_blank>route<S2SV_blank>src=" ) ; <S2SV_EndBug> PRINT6ADDR ( & UIP_IP_BUF -> srcipaddr ) ; PRINTF ( "<S2SV_blank>dst=" ) ; PRINT6ADDR ( & UIP_IP_BUF -> destipaddr ) ; PRINTF ( "\\n" ) ; } else { <S2SV_StartBug> PRINTF ( "Got<S2SV_blank>things<S2SV_blank>to<S2SV_blank>send<S2SV_blank>to<S2SV_blank>PC\\n" ) ; <S2SV_EndBug> PRINTF ( "<S2SV_blank>dst=" ) ; PRINT6ADDR ( & UIP_IP_BUF -> destipaddr ) ; PRINTF ( "\\n" ) ; PRINTF ( "packet_length:%d<S2SV_blank>\\n" , UIP_IP_BUF -> len [ 1 ] ) ; uint8_t ip_payload_length = UIP_IP_BUF -> len [ 1 ] ; uint8_t coap_packet_start_location = UIP_IPH_LEN + ip_payload_length - 132 ; uint8_t flag1 = ( ( uint8_t * ) ( UIP_IP_BUF ) ) [ coap_packet_start_location ] ; uint8_t flag2 = ( ( uint8_t * ) ( UIP_IP_BUF ) ) [ coap_packet_start_location + 1 ] ; if ( flag1 == 0x54 && flag2 == 0x66 ) { PRINTF ( "\\nFound_flag:%02x<S2SV_blank>%02x\\n" , flag1 , flag2 ) ; PRINTF ( "Source_IP_Address:" ) ; PRINT6ADDR ( & UIP_IP_BUF -> srcipaddr ) ; UIP_UDP_BUF -> udpchksum = 0 ; uint16_t new_udp_checksum = ~ ( uip_udpchksum ( ) ) ; UIP_UDP_BUF -> udpchksum = new_udp_checksum ; PRINTF ( "\\nnew_checksum:%04x\\n" , new_udp_checksum ) ; uint8_t ndx ; for ( ndx = coap_packet_start_location ; ndx < UIP_IP_BUF -> len [ 1 ] + UIP_IPH_LEN ; ndx ++ ) { uint8_t data = ( ( uint8_t * ) ( UIP_IP_BUF ) ) [ ndx ] ; PRINTF ( "%02x" , data ) ; } PRINTF ( "\\n" ) ; } else { uint8_t ndx ; for ( ndx = coap_packet_start_location ; ndx < UIP_IP_BUF -> len [ 1 ] + UIP_IPH_LEN ; ndx ++ ) { uint8_t data = ( ( uint8_t * ) ( UIP_IP_BUF ) ) [ ndx ] ; PRINTF ( "%02x" , data ) ; } PRINTF ( "\\n" ) ; } slip_send ( ) ; } return 0 ; } | <S2SV_ModStart> { PRINTF ( "\\nslip-bridge:<S2SV_blank>Destination<S2SV_blank>off-link<S2SV_blank>but<S2SV_blank>no<S2SV_blank>route<S2SV_blank>src=" <S2SV_ModEnd> ) ; PRINT6ADDR <S2SV_ModStart> { PRINTF ( "\\nGot<S2SV_blank>things<S2SV_blank>to<S2SV_blank>send<S2SV_blank>to<S2SV_blank>PC\\n" <S2SV_ModEnd> ) ; PRINTF |
2,186 | CWE-000 <S2SV_StartBug> void splittriangle ( m , b , badtri ) <S2SV_EndBug> struct mesh * m ; struct behavior * b ; struct badtriang * badtri ; # endif { struct otri badotri ; vertex borg , bdest , bapex ; vertex newvertex ; REAL xi , eta ; enum insertvertexresult success ; int errorflag ; int i ; decode ( badtri -> poortri , badotri ) ; org ( badotri , borg ) ; dest ( badotri , bdest ) ; apex ( badotri , bapex ) ; if ( ! deadtri ( badotri . tri ) && ( borg == badtri -> triangorg ) && ( bdest == badtri -> triangdest ) && ( bapex == badtri -> triangapex ) ) { if ( b -> verbose > 1 ) { printf ( "<S2SV_blank><S2SV_blank>Splitting<S2SV_blank>this<S2SV_blank>triangle<S2SV_blank>at<S2SV_blank>its<S2SV_blank>circumcenter:\\n" ) ; printf ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>(%.12g,<S2SV_blank>%.12g)<S2SV_blank>(%.12g,<S2SV_blank>%.12g)<S2SV_blank>(%.12g,<S2SV_blank>%.12g)\\n" , borg [ 0 ] , borg [ 1 ] , bdest [ 0 ] , bdest [ 1 ] , bapex [ 0 ] , bapex [ 1 ] ) ; } errorflag = 0 ; newvertex = ( vertex ) poolalloc ( & m -> vertices ) ; findcircumcenter ( m , b , borg , bdest , bapex , newvertex , & xi , & eta , 1 ) ; if ( ( ( newvertex [ 0 ] == borg [ 0 ] ) && ( newvertex [ 1 ] == borg [ 1 ] ) ) || ( ( newvertex [ 0 ] == bdest [ 0 ] ) && ( newvertex [ 1 ] == bdest [ 1 ] ) ) || ( ( newvertex [ 0 ] == bapex [ 0 ] ) && ( newvertex [ 1 ] == bapex [ 1 ] ) ) ) { if ( ! b -> quiet ) { printf ( "Warning:<S2SV_blank><S2SV_blank>New<S2SV_blank>vertex<S2SV_blank>(%.12g,<S2SV_blank>%.12g)<S2SV_blank>falls<S2SV_blank>on<S2SV_blank>existing<S2SV_blank>vertex.\\n" , newvertex [ 0 ] , newvertex [ 1 ] ) ; errorflag = 1 ; } vertexdealloc ( m , newvertex ) ; } else { for ( i = 2 ; i < 2 + m -> nextras ; i ++ ) { newvertex [ i ] = borg [ i ] + xi * ( bdest [ i ] - borg [ i ] ) + eta * ( bapex [ i ] - borg [ i ] ) ; } setvertexmark ( newvertex , 0 ) ; setvertextype ( newvertex , FREEVERTEX ) ; if ( eta < xi ) { lprevself ( badotri ) ; } success = insertvertex ( m , b , newvertex , & badotri , ( struct osub * ) NULL , 1 , 1 ) ; if ( success == SUCCESSFULVERTEX ) { if ( m -> steinerleft > 0 ) { m -> steinerleft -- ; } } else if ( success == ENCROACHINGVERTEX ) { undovertex ( m , b ) ; if ( b -> verbose > 1 ) { printf ( "<S2SV_blank><S2SV_blank>Rejecting<S2SV_blank>(%.12g,<S2SV_blank>%.12g).\\n" , newvertex [ 0 ] , newvertex [ 1 ] ) ; } vertexdealloc ( m , newvertex ) ; } else if ( success == VIOLATINGVERTEX ) { vertexdealloc ( m , newvertex ) ; } else { if ( ! b -> quiet ) { printf ( "Warning:<S2SV_blank><S2SV_blank>New<S2SV_blank>vertex<S2SV_blank>(%.12g,<S2SV_blank>%.12g)<S2SV_blank>falls<S2SV_blank>on<S2SV_blank>existing<S2SV_blank>vertex.\\n" , newvertex [ 0 ] , newvertex [ 1 ] ) ; errorflag = 1 ; } vertexdealloc ( m , newvertex ) ; } } if ( errorflag ) { if ( b -> verbose ) { printf ( "<S2SV_blank><S2SV_blank>The<S2SV_blank>new<S2SV_blank>vertex<S2SV_blank>is<S2SV_blank>at<S2SV_blank>the<S2SV_blank>circumcenter<S2SV_blank>of<S2SV_blank>triangle\\n" ) ; printf ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>(%.12g,<S2SV_blank>%.12g)<S2SV_blank>(%.12g,<S2SV_blank>%.12g)<S2SV_blank>(%.12g,<S2SV_blank>%.12g)\\n" , borg [ 0 ] , borg [ 1 ] , bdest [ 0 ] , bdest [ 1 ] , bapex [ 0 ] , bapex [ 1 ] ) ; } printf ( "This<S2SV_blank>probably<S2SV_blank>means<S2SV_blank>that<S2SV_blank>I<S2SV_blank>am<S2SV_blank>trying<S2SV_blank>to<S2SV_blank>refine<S2SV_blank>triangles\\n" ) ; printf ( "<S2SV_blank><S2SV_blank>to<S2SV_blank>a<S2SV_blank>smaller<S2SV_blank>size<S2SV_blank>than<S2SV_blank>can<S2SV_blank>be<S2SV_blank>accommodated<S2SV_blank>by<S2SV_blank>the<S2SV_blank>finite\\n" ) ; printf ( "<S2SV_blank><S2SV_blank>precision<S2SV_blank>of<S2SV_blank>floating<S2SV_blank>point<S2SV_blank>arithmetic.<S2SV_blank><S2SV_blank>(You<S2SV_blank>can<S2SV_blank>be\\n" ) ; printf ( "<S2SV_blank><S2SV_blank>sure<S2SV_blank>of<S2SV_blank>this<S2SV_blank>if<S2SV_blank>I<S2SV_blank>fail<S2SV_blank>to<S2SV_blank>terminate.)\\n" ) ; precisionerror ( ) ; } } } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> void splittriangle ( struct mesh * m , struct behavior * b , struct badtriang * badtri ) # else |
2,187 | CWE-000 static bool key_method_2_write ( struct buffer * buf , struct tls_session * session ) { struct key_state * ks = & session -> key [ KS_PRIMARY ] ; ASSERT ( session -> opt -> key_method == 2 ) ; ASSERT ( buf_init ( buf , 0 ) ) ; if ( ! buf_write_u32 ( buf , 0 ) ) { goto error ; } if ( ! buf_write_u8 ( buf , ( session -> opt -> key_method & KEY_METHOD_MASK ) ) ) { goto error ; } if ( ! key_source2_randomize_write ( ks -> key_src , buf , session -> opt -> server ) ) { goto error ; } { if ( ! write_string ( buf , local_options_string ( session ) , TLS_OPTIONS_LEN ) ) { goto error ; } } if ( auth_user_pass_enabled ) { # ifdef ENABLE_MANAGEMENT auth_user_pass_setup ( session -> opt -> auth_user_pass_file , session -> opt -> sci ) ; # else auth_user_pass_setup ( session -> opt -> auth_user_pass_file , NULL ) ; # endif <S2SV_StartBug> if ( ! write_string ( buf , auth_user_pass . username , - 1 ) ) <S2SV_EndBug> { goto error ; } <S2SV_StartBug> if ( ! write_string ( buf , auth_user_pass . password , - 1 ) ) <S2SV_EndBug> { goto error ; } if ( ! auth_user_pass . wait_for_push ) { purge_user_pass ( & auth_user_pass , false ) ; } } else { if ( ! write_empty_string ( buf ) ) { goto error ; } if ( ! write_empty_string ( buf ) ) { goto error ; } } if ( ! push_peer_info ( buf , session ) ) { goto error ; } if ( session -> opt -> server && ! ( session -> opt -> ncp_enabled && session -> opt -> mode == MODE_SERVER && ks -> key_id <= 0 ) ) { if ( ks -> authenticated ) { if ( ! tls_session_generate_data_channel_keys ( session ) ) { msg ( D_TLS_ERRORS , "TLS<S2SV_blank>Error:<S2SV_blank>server<S2SV_blank>generate_key_expansion<S2SV_blank>failed" ) ; goto error ; } } } return true ; error : msg ( D_TLS_ERRORS , "TLS<S2SV_blank>Error:<S2SV_blank>Key<S2SV_blank>Method<S2SV_blank>#2<S2SV_blank>write<S2SV_blank>failed" ) ; secure_memzero ( ks -> key_src , sizeof ( * ks -> key_src ) ) ; return false ; } | <S2SV_ModStart> ; # endif struct user_pass * up = & auth_user_pass ; if ( auth_token . defined ) up = & auth_token ; <S2SV_ModStart> ( buf , up -> <S2SV_ModEnd> username , - <S2SV_ModStart> error ; } else <S2SV_ModStart> ( buf , up -> <S2SV_ModEnd> password , - |
2,188 | CWE-000 void * unwrap_asymmetric ( size_t * clear_secret_size , const void * wrapped_secret_data , size_t wrapped_secret_size , const void * issuer , size_t issuer_size , const void * sn , size_t sn_size , void * pwfn_arg , GError * * error ) { CERTIssuerAndSN isn ; CERTCertificate * cert ; PK11SlotInfo * slot ; SECKEYPrivateKey * private_key ; SECItem wrapped_secret_item , * clear_secret_item ; PK11SymKey * secret_key ; void * ret ; isn . derIssuer . data = ( void * ) issuer ; isn . derIssuer . len = issuer_size ; memset ( & isn . issuer , 0 , sizeof ( isn . issuer ) ) ; isn . serialNumber . data = ( void * ) sn ; isn . serialNumber . len = sn_size ; cert = CERT_FindCertByIssuerAndSN ( CERT_GetDefaultCertDB ( ) , & isn ) ; if ( cert == NULL ) { <S2SV_StartBug> error_from_pr ( error ) ; <S2SV_EndBug> goto err ; } slot = PK11_GetInternalKeySlot ( ) ; if ( slot == NULL ) { error_from_pr ( error ) ; CERT_DestroyCertificate ( cert ) ; goto err ; } private_key = PK11_FindPrivateKeyFromCert ( slot , cert , pwfn_arg ) ; PK11_FreeSlot ( slot ) ; CERT_DestroyCertificate ( cert ) ; if ( private_key == NULL ) { error_from_pr ( error ) ; goto err ; } wrapped_secret_item . data = ( void * ) wrapped_secret_data ; wrapped_secret_item . len = wrapped_secret_size ; secret_key = PK11_PubUnwrapSymKey ( private_key , & wrapped_secret_item , CKM_GENERIC_SECRET_KEY_GEN , CKA_UNWRAP , 0 ) ; SECKEY_DestroyPrivateKey ( private_key ) ; if ( secret_key == NULL ) { error_from_pr ( error ) ; goto err ; } if ( PK11_ExtractKeyValue ( secret_key ) != SECSuccess ) { error_from_pr ( error ) ; goto err_secret_key ; } clear_secret_item = PK11_GetKeyData ( secret_key ) ; ret = g_memdup ( clear_secret_item -> data , clear_secret_item -> len ) ; * clear_secret_size = clear_secret_item -> len ; PK11_FreeSymKey ( secret_key ) ; return ret ; err_secret_key : PK11_FreeSymKey ( secret_key ) ; err : return NULL ; } | <S2SV_ModStart> NULL ) { g_set_error ( error , LIBVK_ERROR , LIBVK_ERROR_CRYPTO , _ ( "Unable<S2SV_blank>to<S2SV_blank>find<S2SV_blank>the<S2SV_blank>certificate<S2SV_blank>necessary<S2SV_blank>for<S2SV_blank>" "decryption" ) <S2SV_ModEnd> ) ; goto |
2,189 | CWE-000 static void iomux_check_inputs ( void ) { uint8_t iomux_inputs [ IOMUX_BYTECOUNT ] ; memcpy ( iomux_inputs , iomux_input_array ( ) , IOMUX_BYTECOUNT ) ; <S2SV_StartBug> if ( memcmp ( iomux_inputs , iomux_last_inputs , IOMUX_BYTECOUNT ) ) { <S2SV_EndBug> return ; } for ( int i = 0 ; i < IOMUX_OUTPUTS ; i ++ ) { bool new_value = iomux_get_input_from ( iomux_inputs , i ) ; if ( i && ( ( i % 8 ) == 0 ) ) { printf ( "<S2SV_blank><S2SV_blank>" ) ; } printf ( "%c" , new_value ? '1' : '0' ) ; } printf ( "<S2SV_blank><S2SV_blank>" ) ; for ( int i = 0 ; i < IOMUX_OUTPUTS ; i ++ ) { bool old_value = iomux_get_input_from ( iomux_last_inputs , i ) ; bool new_value = iomux_get_input_from ( iomux_inputs , i ) ; if ( old_value != new_value ) { printf ( "%c%d" , new_value ? '+' : '-' , i ) ; } } printf ( "\\n" ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ; if ( ! <S2SV_ModStart> "\\n" ) ; memcpy ( iomux_last_inputs , iomux_inputs , IOMUX_BYTECOUNT ) ; |
2,190 | CWE-000 int swoole_sync_readfile ( int fd , void * buf , int len ) { int n = 0 ; int count = len , toread , readn = 0 ; while ( count > 0 ) { toread = count ; if ( toread > SW_FILE_CHUNK_SIZE ) { toread = SW_FILE_CHUNK_SIZE ; } n = read ( fd , buf , toread ) ; if ( n > 0 ) { <S2SV_StartBug> ( char * ) buf += n ; <S2SV_EndBug> count -= n ; readn += n ; } else if ( n == 0 ) { break ; } else { if ( errno == EINTR || errno == EAGAIN ) { continue ; } swWarn ( "read()<S2SV_blank>failed.<S2SV_blank>Error:<S2SV_blank>%s[%d]" , strerror ( errno ) , errno ) ; break ; } } return readn ; } | <S2SV_ModStart> 0 ) { buf = <S2SV_ModStart> * ) buf + <S2SV_ModEnd> n ; count |
2,191 | CWE-000 static void print_object_or_die ( struct batch_options * opt , struct expand_data * data ) { const struct object_id * oid = & data -> oid ; assert ( data -> info . typep ) ; if ( data -> type == OBJ_BLOB ) { if ( opt -> buffer_output ) fflush ( stdout ) ; if ( opt -> cmdmode ) { char * contents ; unsigned long size ; if ( ! data -> rest ) die ( "missing<S2SV_blank>path<S2SV_blank>for<S2SV_blank>\'%s\'" , oid_to_hex ( oid ) ) ; if ( opt -> cmdmode == 'w' ) { if ( filter_object ( data -> rest , 0100644 , oid , & contents , & size ) ) die ( "could<S2SV_blank>not<S2SV_blank>convert<S2SV_blank>\'%s\'<S2SV_blank>%s" , oid_to_hex ( oid ) , data -> rest ) ; } else if ( opt -> cmdmode == 'c' ) { enum object_type type ; if ( ! textconv_object ( data -> rest , 0100644 , oid , 1 , & contents , & size ) ) contents = read_object_file ( oid , & type , & size ) ; if ( ! contents ) die ( "could<S2SV_blank>not<S2SV_blank>convert<S2SV_blank>\'%s\'<S2SV_blank>%s" , oid_to_hex ( oid ) , data -> rest ) ; } else <S2SV_StartBug> die ( "BUG:<S2SV_blank>invalid<S2SV_blank>cmdmode:<S2SV_blank>%c" , opt -> cmdmode ) ; <S2SV_EndBug> batch_write ( opt , contents , size ) ; free ( contents ) ; } else if ( stream_blob_to_fd ( 1 , oid , NULL , 0 ) < 0 ) die ( "unable<S2SV_blank>to<S2SV_blank>stream<S2SV_blank>%s<S2SV_blank>to<S2SV_blank>stdout" , oid_to_hex ( oid ) ) ; } else { enum object_type type ; unsigned long size ; void * contents ; contents = read_object_file ( oid , & type , & size ) ; if ( ! contents ) die ( "object<S2SV_blank>%s<S2SV_blank>disappeared" , oid_to_hex ( oid ) ) ; if ( type != data -> type ) die ( "object<S2SV_blank>%s<S2SV_blank>changed<S2SV_blank>type!?" , oid_to_hex ( oid ) ) ; if ( data -> info . sizep && size != data -> size ) die ( "object<S2SV_blank>%s<S2SV_blank>changed<S2SV_blank>size!?" , oid_to_hex ( oid ) ) ; batch_write ( opt , contents , size ) ; free ( contents ) ; } } | <S2SV_ModStart> ; } else BUG ( "invalid<S2SV_blank>cmdmode:<S2SV_blank>%c" <S2SV_ModEnd> , opt -> |
2,192 | CWE-000 static int _strcmp_8_16 ( KOS_STRING * a , unsigned a_begin , unsigned a_len , KOS_STRING * b , unsigned b_begin , unsigned b_len ) { const unsigned cmp_len = KOS_min ( a_len , b_len ) ; const uint8_t * pa = ( const uint8_t * ) _KOS_get_string_buffer ( a ) + a_begin ; const uint16_t * pb = ( const uint16_t * ) _KOS_get_string_buffer ( b ) + b_begin ; const uint8_t * pend = pa + cmp_len ; int result = 0 ; for ( ; ; ) { if ( pa < pend ) { const uint8_t ca = * pa ; const uint16_t cb = * pb ; if ( ca != cb ) { result = _KOS_unicode_compare ( ca , cb ) ; break ; } } else { <S2SV_StartBug> result = a_len - b_len ; <S2SV_EndBug> break ; } ++ pa ; ++ pb ; } return result ; } | <S2SV_ModStart> { result = ( int ) ( <S2SV_ModStart> a_len - b_len ) |
2,193 | CWE-000 int main ( void ) { int sockfd ; int connd ; struct sockaddr_in servAddr ; struct sockaddr_in clientAddr ; socklen_t size = sizeof ( clientAddr ) ; char buff [ 256 ] ; size_t len ; int shutdown = 0 ; WOLFSSL_CTX * ctx ; WOLFSSL * ssl ; puts ( "This<S2SV_blank>is<S2SV_blank>the<S2SV_blank>wolfSSL<S2SV_blank>Server!" ) ; puts ( "Server<S2SV_blank>is<S2SV_blank>running<S2SV_blank>on<S2SV_blank>127.0.0.1<S2SV_blank>and<S2SV_blank>listening<S2SV_blank>on<S2SV_blank>port<S2SV_blank>11111" ) ; if ( ( sockfd = socket ( AF_INET , SOCK_STREAM , 0 ) ) == - 1 ) { fprintf ( stderr , "ERROR:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>the<S2SV_blank>socket\\n" ) ; return - 1 ; } memset ( & servAddr , 0 , sizeof ( servAddr ) ) ; servAddr . sin_family = AF_INET ; servAddr . sin_port = htons ( DEFAULT_PORT ) ; servAddr . sin_addr . s_addr = INADDR_ANY ; if ( bind ( sockfd , ( struct sockaddr * ) & servAddr , sizeof ( servAddr ) ) == - 1 ) { fprintf ( stderr , "ERROR:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>bind\\n" ) ; return - 1 ; } if ( listen ( sockfd , 5 ) == - 1 ) { fprintf ( stderr , "ERROR:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>listen\\n" ) ; return - 1 ; } wolfSSL_Init ( ) ; if ( ( ctx = wolfSSL_CTX_new ( wolfTLSv1_2_server_method ( ) ) ) == NULL ) { fprintf ( stderr , "ERROR:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>WOLFSSL_CTX\\n" ) ; return - 1 ; } if ( wolfSSL_CTX_use_certificate_buffer ( ctx , server_cert_der_2048 , sizeof_server_cert_der_2048 , SSL_FILETYPE_ASN1 ) != SSL_SUCCESS ) { fprintf ( stderr , "ERROR:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>load<S2SV_blank>server_cert_der_2048\\n" ) ; return - 1 ; } if ( wolfSSL_CTX_use_PrivateKey_buffer ( ctx , server_key_der_2048 , sizeof_server_key_der_2048 , SSL_FILETYPE_ASN1 ) != SSL_SUCCESS ) { fprintf ( stderr , "ERROR:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>load<S2SV_blank>server_key_der_2048\\n" ) ; return - 1 ; } while ( ! shutdown ) { printf ( "Waiting<S2SV_blank>for<S2SV_blank>a<S2SV_blank>connection...\\n" ) ; if ( ( connd = accept ( sockfd , ( struct sockaddr * ) & clientAddr , & size ) ) == - 1 ) { fprintf ( stderr , "ERROR:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>accept<S2SV_blank>the<S2SV_blank>connection\\n\\n" ) ; return - 1 ; } if ( ( ssl = wolfSSL_new ( ctx ) ) == NULL ) { fprintf ( stderr , "ERROR:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>WOLFSSL<S2SV_blank>object\\n" ) ; return - 1 ; } wolfSSL_set_fd ( ssl , connd ) ; printf ( "Client<S2SV_blank>connected<S2SV_blank>successfully\\n" ) ; memset ( buff , 0 , sizeof ( buff ) ) ; if ( wolfSSL_read ( ssl , buff , sizeof ( buff ) - 1 ) == - 1 ) { fprintf ( stderr , "ERROR:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>read\\n" ) ; return - 1 ; } printf ( "Client<S2SV_blank>sent<S2SV_blank>a<S2SV_blank>message!\\n" ) ; printf ( "Client<S2SV_blank>said:<S2SV_blank>%s\\n" , buff ) ; if ( strncmp ( buff , "shutdown" , 8 ) == 0 ) { printf ( "Shutdown<S2SV_blank>command<S2SV_blank>issued!\\n" ) ; shutdown = 1 ; } memset ( buff , 0 , sizeof ( buff ) ) ; <S2SV_StartBug> memcpy ( buff , "I<S2SV_blank>hear<S2SV_blank>ya<S2SV_blank>fa<S2SV_blank>shizzle!\\n" , sizeof ( buff ) ) ; <S2SV_EndBug> len = strnlen ( buff , sizeof ( buff ) ) ; printf ( "Sending<S2SV_blank>reply<S2SV_blank>to<S2SV_blank>client,<S2SV_blank>reply<S2SV_blank>reads:<S2SV_blank>%s\\n" , buff ) ; if ( wolfSSL_write ( ssl , buff , len ) != ( int ) len ) { fprintf ( stderr , "ERROR:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>write\\n" ) ; return - 1 ; } wolfSSL_free ( ssl ) ; close ( connd ) ; } printf ( "Shutdown<S2SV_blank>complete\\n" ) ; wolfSSL_CTX_free ( ctx ) ; wolfSSL_Cleanup ( ) ; close ( sockfd ) ; return 0 ; } | <S2SV_ModStart> ) ) ; strncpy <S2SV_ModEnd> ( buff , <S2SV_ModStart> ( buff ) - 1 |
2,194 | CWE-000 void xen_swiotlb_free_coherent ( struct device * hwdev , size_t size , void * vaddr , dma_addr_t dev_addr , struct dma_attrs * attrs ) { int order = get_order ( size ) ; phys_addr_t phys ; u64 dma_mask = DMA_BIT_MASK ( 32 ) ; if ( dma_release_from_coherent ( hwdev , order , vaddr ) ) return ; if ( hwdev && hwdev -> coherent_dma_mask ) dma_mask = hwdev -> coherent_dma_mask ; phys = virt_to_phys ( vaddr ) ; <S2SV_StartBug> if ( ( ( dev_addr + size - 1 > dma_mask ) ) || <S2SV_EndBug> range_straddles_page_boundary ( phys , size ) ) xen_destroy_contiguous_region ( ( unsigned long ) vaddr , order ) ; free_pages ( ( unsigned long ) vaddr , order ) ; } | <S2SV_ModStart> size - 1 <= <S2SV_ModEnd> dma_mask ) ) |
2,195 | CWE-000 void all_error ( char * string ) { FILE * fp ; <S2SV_StartBug> fp = fopen ( "log.txt" , "w+" ) ; <S2SV_EndBug> if ( fp == NULL ) { printf ( "Cannot<S2SV_blank>open<S2SV_blank>log.txt\\n" ) ; } printf ( "%s<S2SV_blank>\\n" , string ) ; fprintf ( fp , "%s<S2SV_blank>\\n" , string ) ; sem_wait ( & end_s ) ; end = 1 ; sem_post ( & end_s ) ; } | <S2SV_ModStart> ( "log.txt" , "a" <S2SV_ModEnd> ) ; if |
2,196 | CWE-000 static inline int cmd_address_audit ( struct parser_exec_state * s , unsigned long guest_gma , int op_size , bool index_mode ) { struct intel_vgpu * vgpu = s -> vgpu ; u32 max_surface_size = vgpu -> gvt -> device_info . max_surface_size ; int i ; int ret ; if ( op_size > max_surface_size ) { <S2SV_StartBug> gvt_err ( "command<S2SV_blank>address<S2SV_blank>audit<S2SV_blank>fail<S2SV_blank>name<S2SV_blank>%s\\n" , s -> info -> name ) ; <S2SV_EndBug> return - EINVAL ; } if ( index_mode ) { if ( guest_gma >= GTT_PAGE_SIZE / sizeof ( u64 ) ) { ret = - EINVAL ; goto err ; } } else if ( ( ! vgpu_gmadr_is_valid ( s -> vgpu , guest_gma ) ) || ( ! vgpu_gmadr_is_valid ( s -> vgpu , guest_gma + op_size - 1 ) ) ) { ret = - EINVAL ; goto err ; } return 0 ; err : <S2SV_StartBug> gvt_err ( "cmd_parser:<S2SV_blank>Malicious<S2SV_blank>%s<S2SV_blank>detected,<S2SV_blank>addr=0x%lx,<S2SV_blank>len=%d!\\n" , <S2SV_EndBug> s -> info -> name , guest_gma , op_size ) ; pr_err ( "cmd<S2SV_blank>dump:<S2SV_blank>" ) ; for ( i = 0 ; i < cmd_length ( s ) ; i ++ ) { if ( ! ( i % 4 ) ) pr_err ( "\\n%08x<S2SV_blank>" , cmd_val ( s , i ) ) ; else pr_err ( "%08x<S2SV_blank>" , cmd_val ( s , i ) ) ; } pr_err ( "\\nvgpu%d:<S2SV_blank>aperture<S2SV_blank>0x%llx<S2SV_blank>-<S2SV_blank>0x%llx,<S2SV_blank>hidden<S2SV_blank>0x%llx<S2SV_blank>-<S2SV_blank>0x%llx\\n" , vgpu -> id , vgpu_aperture_gmadr_base ( vgpu ) , vgpu_aperture_gmadr_end ( vgpu ) , vgpu_hidden_gmadr_base ( vgpu ) , vgpu_hidden_gmadr_end ( vgpu ) ) ; return ret ; } | <S2SV_ModStart> max_surface_size ) { gvt_vgpu_err <S2SV_ModEnd> ( "command<S2SV_blank>address<S2SV_blank>audit<S2SV_blank>fail<S2SV_blank>name<S2SV_blank>%s\\n" , <S2SV_ModStart> ; err : gvt_vgpu_err <S2SV_ModEnd> ( "cmd_parser:<S2SV_blank>Malicious<S2SV_blank>%s<S2SV_blank>detected,<S2SV_blank>addr=0x%lx,<S2SV_blank>len=%d!\\n" , |
2,197 | CWE-000 enum mCc_ast_data_type getCurrentReturnType ( struct symbolTable * table ) { assert ( table ) ; if ( table -> firstElement && table -> firstElement -> isFunction ) { <S2SV_StartBug> printf ( "<S2SV_blank>\\tReturn<S2SV_blank>type<S2SV_blank>%i\\n" , table -> firstElement -> type ) ; <S2SV_EndBug> return table -> firstElement -> type ; } else if ( table -> previousTable ) { <S2SV_StartBug> printf ( "<S2SV_blank>\\tReturn<S2SV_blank>type<S2SV_blank>möp<S2SV_blank>%i\\n" , table -> firstElement -> type ) ; <S2SV_EndBug> assert ( table -> previousTable ) ; return getCurrentReturnType ( table -> previousTable ) ; } else { <S2SV_StartBug> printf ( "<S2SV_blank>\\tReturn<S2SV_blank>type<S2SV_blank>here<S2SV_blank>%s<S2SV_blank>%i\\n" , table -> firstElement -> identifier , table -> firstElement -> type ) ; <S2SV_EndBug> return UINT_MAX ; } } | <S2SV_ModStart> isFunction ) { <S2SV_ModEnd> return table -> <S2SV_ModStart> previousTable ) { <S2SV_ModEnd> assert ( table <S2SV_ModStart> } else { <S2SV_ModEnd> return UINT_MAX ; |
2,198 | CWE-000 HOOKDEF ( NTSTATUS , WINAPI , NtOpenFile , __out PHANDLE FileHandle , __in ACCESS_MASK DesiredAccess , __in POBJECT_ATTRIBUTES ObjectAttributes , __out PIO_STATUS_BLOCK IoStatusBlock , __in ULONG ShareAccess , __in ULONG OpenOptions ) { NTSTATUS ret ; check_for_logging_resumption ( ObjectAttributes ) ; if ( is_protected_objattr ( ObjectAttributes ) ) return STATUS_ACCESS_DENIED ; ret = Old_NtOpenFile ( FileHandle , DesiredAccess , ObjectAttributes , IoStatusBlock , ShareAccess | FILE_SHARE_READ , OpenOptions ) ; LOQ_ntstatus ( "filesystem" , "PhOi" , "FileHandle" , FileHandle , "DesiredAccess" , DesiredAccess , "FileName" , ObjectAttributes , "ShareAccess" , ShareAccess ) ; if ( NT_SUCCESS ( ret ) ) { add_file_to_log_tracking ( * FileHandle ) ; if ( DesiredAccess & DUMP_FILE_MASK ) <S2SV_StartBug> handle_new_file ( * FileHandle , ObjectAttributes ) ; <S2SV_EndBug> } <S2SV_StartBug> return ret ; <S2SV_EndBug> } | <S2SV_ModStart> & DUMP_FILE_MASK ) { DoOutputDebugString ( "NtOpenFile<S2SV_blank>hook:<S2SV_blank>DesiredAccess<S2SV_blank>0x%x<S2SV_blank>&<S2SV_blank>DUMP_FILE_MASK<S2SV_blank>0x%x.\\n" , DesiredAccess , DUMP_FILE_MASK ) ; <S2SV_ModStart> ) ; } } |
2,199 | CWE-000 <S2SV_StartBug> VOID processBugs ( HDC * backbuffDC ) { <S2SV_EndBug> <S2SV_StartBug> eraseBugs ( backbuffDC ) ; <S2SV_EndBug> doCycleStuff ( ) ; selectNewDirection ( ) ; moveBugs ( ) ; <S2SV_StartBug> bugsEatBacteria ( backbuffDC ) ; <S2SV_EndBug> <S2SV_StartBug> drawBugs ( backbuffDC ) ; <S2SV_EndBug> } | <S2SV_ModStart> VOID processBugs ( <S2SV_ModEnd> ) { eraseBugs <S2SV_ModStart> { eraseBugs ( <S2SV_ModEnd> ) ; doCycleStuff <S2SV_ModStart> ; bugsEatBacteria ( <S2SV_ModEnd> ) ; drawBugs <S2SV_ModStart> ; drawBugs ( <S2SV_ModEnd> ) ; } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.