Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
1,000
|
CWE-000 static void setup_collation ( void ) { # if defined ( HAVE_LOCALE_T ) && ! defined ( WIN32 ) int i ; FILE * locale_a_handle ; char localebuf [ NAMEDATALEN ] ; int count = 0 ; PG_CMD_DECL ; # endif fputs ( _ ( "creating<S2SV_blank>collations<S2SV_blank>...<S2SV_blank>" ) , stdout ) ; fflush ( stdout ) ; # if defined ( HAVE_LOCALE_T ) && ! defined ( WIN32 ) snprintf ( cmd , sizeof ( cmd ) , "\\"%s\\"<S2SV_blank>%s<S2SV_blank>template1<S2SV_blank>>%s" , backend_exec , backend_options , DEVNULL ) ; locale_a_handle = popen_check ( "locale<S2SV_blank>-a" , "r" ) ; if ( ! locale_a_handle ) return ; PG_CMD_OPEN ; PG_CMD_PUTS ( "CREATE<S2SV_blank>TEMP<S2SV_blank>TABLE<S2SV_blank>tmp_pg_collation<S2SV_blank>(<S2SV_blank>" "\tcollname<S2SV_blank>name,<S2SV_blank>" "\tlocale<S2SV_blank>name,<S2SV_blank>" "\tencoding<S2SV_blank>int)<S2SV_blank>WITHOUT<S2SV_blank>OIDS;\\n" ) ; while ( fgets ( localebuf , sizeof ( localebuf ) , locale_a_handle ) ) { size_t len ; int enc ; bool skip ; char * quoted_locale ; char alias [ NAMEDATALEN ] ; len = strlen ( localebuf ) ; if ( len == 0 || localebuf [ len - 1 ] != '\\n' ) { if ( debug ) fprintf ( stderr , _ ( "%s:<S2SV_blank>locale<S2SV_blank>name<S2SV_blank>too<S2SV_blank>long,<S2SV_blank>skipped:<S2SV_blank>\\"%s\\"\\n" ) , progname , localebuf ) ; continue ; } localebuf [ len - 1 ] = '\\0' ; skip = false ; for ( i = 0 ; i < len ; i ++ ) { if ( IS_HIGHBIT_SET ( localebuf [ i ] ) ) { skip = true ; break ; } } if ( skip ) { if ( debug ) fprintf ( stderr , _ ( "%s:<S2SV_blank>locale<S2SV_blank>name<S2SV_blank>has<S2SV_blank>non-ASCII<S2SV_blank>characters,<S2SV_blank>skipped:<S2SV_blank>\\"%s\\"\\n" ) , progname , localebuf ) ; continue ; } enc = pg_get_encoding_from_locale ( localebuf , debug ) ; if ( enc < 0 ) { continue ; } if ( ! PG_VALID_BE_ENCODING ( enc ) ) continue ; if ( enc == PG_SQL_ASCII ) continue ; count ++ ; quoted_locale = escape_quotes ( localebuf ) ; PG_CMD_PRINTF3 ( "INSERT<S2SV_blank>INTO<S2SV_blank>tmp_pg_collation<S2SV_blank>VALUES<S2SV_blank>(E\'%s\',<S2SV_blank>E\'%s\',<S2SV_blank>%d);\\n" , quoted_locale , quoted_locale , enc ) ; if ( normalize_locale_name ( alias , localebuf ) ) <S2SV_StartBug> PG_CMD_PRINTF3 ( "INSERT<S2SV_blank>INTO<S2SV_blank>tmp_pg_collation<S2SV_blank>VALUES<S2SV_blank>(E\'%s\',<S2SV_blank>E\'%s\',<S2SV_blank>%d);\\n" , <S2SV_EndBug> <S2SV_StartBug> escape_quotes ( alias ) , quoted_locale , enc ) ; <S2SV_EndBug> } PG_CMD_PRINTF1 ( "INSERT<S2SV_blank>INTO<S2SV_blank>tmp_pg_collation<S2SV_blank>VALUES<S2SV_blank>(\'ucs_basic\',<S2SV_blank>\'C\',<S2SV_blank>%d);\\n" , PG_UTF8 ) ; PG_CMD_PUTS ( "INSERT<S2SV_blank>INTO<S2SV_blank>pg_collation<S2SV_blank>(collname,<S2SV_blank>collnamespace,<S2SV_blank>collowner,<S2SV_blank>collencoding,<S2SV_blank>collcollate,<S2SV_blank>collctype)<S2SV_blank>" "<S2SV_blank>SELECT<S2SV_blank>DISTINCT<S2SV_blank>ON<S2SV_blank>(collname,<S2SV_blank>encoding)" "<S2SV_blank><S2SV_blank><S2SV_blank>collname,<S2SV_blank>" "<S2SV_blank><S2SV_blank><S2SV_blank>(SELECT<S2SV_blank>oid<S2SV_blank>FROM<S2SV_blank>pg_namespace<S2SV_blank>WHERE<S2SV_blank>nspname<S2SV_blank>=<S2SV_blank>\'pg_catalog\')<S2SV_blank>AS<S2SV_blank>collnamespace,<S2SV_blank>" "<S2SV_blank><S2SV_blank><S2SV_blank>(SELECT<S2SV_blank>relowner<S2SV_blank>FROM<S2SV_blank>pg_class<S2SV_blank>WHERE<S2SV_blank>relname<S2SV_blank>=<S2SV_blank>\'pg_collation\')<S2SV_blank>AS<S2SV_blank>collowner,<S2SV_blank>" "<S2SV_blank><S2SV_blank><S2SV_blank>encoding,<S2SV_blank>locale,<S2SV_blank>locale<S2SV_blank>" "<S2SV_blank><S2SV_blank>FROM<S2SV_blank>tmp_pg_collation" "<S2SV_blank><S2SV_blank>WHERE<S2SV_blank>NOT<S2SV_blank>EXISTS<S2SV_blank>(SELECT<S2SV_blank>1<S2SV_blank>FROM<S2SV_blank>pg_collation<S2SV_blank>WHERE<S2SV_blank>collname<S2SV_blank>=<S2SV_blank>tmp_pg_collation.collname)" "<S2SV_blank><S2SV_blank>ORDER<S2SV_blank>BY<S2SV_blank>collname,<S2SV_blank>encoding,<S2SV_blank>(collname<S2SV_blank>=<S2SV_blank>locale)<S2SV_blank>DESC,<S2SV_blank>locale;\\n" ) ; pclose ( locale_a_handle ) ; PG_CMD_CLOSE ; check_ok ( ) ; if ( count == 0 && ! debug ) { printf ( _ ( "No<S2SV_blank>usable<S2SV_blank>system<S2SV_blank>locales<S2SV_blank>were<S2SV_blank>found.\\n" ) ) ; printf ( _ ( "Use<S2SV_blank>the<S2SV_blank>option<S2SV_blank>\\"--debug\\"<S2SV_blank>to<S2SV_blank>see<S2SV_blank>details.\\n" ) ) ; } # else printf ( _ ( "not<S2SV_blank>supported<S2SV_blank>on<S2SV_blank>this<S2SV_blank>platform\\n" ) ) ; fflush ( stdout ) ; # endif }
|
<S2SV_ModStart> localebuf ) ) { char * quoted_alias = escape_quotes ( alias ) ; <S2SV_ModStart> ( "INSERT<S2SV_blank>INTO<S2SV_blank>tmp_pg_collation<S2SV_blank>VALUES<S2SV_blank>(E\'%s\',<S2SV_blank>E\'%s\',<S2SV_blank>%d);\\n" , quoted_alias <S2SV_ModEnd> , quoted_locale , <S2SV_ModStart> quoted_locale , enc ) ; free ( quoted_alias ) ; } free ( quoted_locale
|
1,001
|
CWE-000 void get_recipe ( recipe * my_recipe ) { <S2SV_StartBug> my_recipe -> ordered = 0 ; <S2SV_EndBug> my_recipe -> ingredients [ 0 ] . amount = 100 ; my_recipe -> ingredients [ 0 ] . order = 2 ; my_recipe -> ingredients [ 1 ] . amount = 100 ; my_recipe -> ingredients [ 1 ] . order = 1 ; my_recipe -> ingredients [ 2 ] . amount = 100 ; my_recipe -> ingredients [ 2 ] . order = 0 ; }
|
<S2SV_ModStart> my_recipe ) { read ( ( void * ) my_recipe , sizeof ( recipe ) ) <S2SV_ModEnd> ; } <S2SV_null>
|
1,002
|
CWE-000 void WP_SaberLoadParms ( void ) { int len , totallen , saberExtFNLen , fileCnt , i ; char * holdChar , * marker ; char saberExtensionListBuf [ 2048 ] ; fileHandle_t f ; len = 0 ; totallen = len ; marker = saberParms + totallen ; * marker = 0 ; fileCnt = trap -> FS_GetFileList ( "ext_data/sabers" , ".sab" , saberExtensionListBuf , sizeof ( saberExtensionListBuf ) ) ; holdChar = saberExtensionListBuf ; for ( i = 0 ; i < fileCnt ; i ++ , holdChar += saberExtFNLen + 1 ) { saberExtFNLen = strlen ( holdChar ) ; len = trap -> FS_Open ( va ( "ext_data/sabers/%s" , holdChar ) , & f , FS_READ ) ; <S2SV_StartBug> if ( len == - 1 ) { <S2SV_EndBug> Com_Printf ( "WP_SaberLoadParms:<S2SV_blank>error<S2SV_blank>reading<S2SV_blank>file:<S2SV_blank>%s\\n" , holdChar ) ; continue ; } <S2SV_StartBug> if ( ( totallen + len + 1 ) >= MAX_SABER_DATA_SIZE ) { <S2SV_EndBug> # ifdef UI_BUILD Com_Error ( ERR_FATAL , "WP_SaberLoadParms:<S2SV_blank>Saber<S2SV_blank>extensions<S2SV_blank>(*.sab)<S2SV_blank>are<S2SV_blank>too<S2SV_blank>large!\\nRan<S2SV_blank>out<S2SV_blank>of<S2SV_blank>space<S2SV_blank>before<S2SV_blank>reading<S2SV_blank>%s" , holdChar ) ; # else Com_Error ( ERR_DROP , "WP_SaberLoadParms:<S2SV_blank>Saber<S2SV_blank>extensions<S2SV_blank>(*.sab)<S2SV_blank>are<S2SV_blank>too<S2SV_blank>large!\\nRan<S2SV_blank>out<S2SV_blank>of<S2SV_blank>space<S2SV_blank>before<S2SV_blank>reading<S2SV_blank>%s" , holdChar ) ; # endif } trap -> FS_Read ( bgSaberParseTBuffer , len , f ) ; bgSaberParseTBuffer [ len ] = 0 ; len = COM_Compress ( bgSaberParseTBuffer ) ; Q_strcat ( marker , MAX_SABER_DATA_SIZE - totallen , bgSaberParseTBuffer ) ; trap -> FS_Close ( f ) ; Q_strcat ( marker , MAX_SABER_DATA_SIZE - totallen , "\\n" ) ; len ++ ; totallen += len ; marker = saberParms + totallen ; } }
|
<S2SV_ModStart> ; if ( ! f <S2SV_ModEnd> ) { Com_Printf <S2SV_ModStart> MAX_SABER_DATA_SIZE ) { trap -> FS_Close ( f ) ;
|
1,003
|
CWE-000 str wkbCoordinateFromMBR ( dbl * coordinateValue , mbr * * geomMBR , int * coordinateIdx ) { if ( mbr_isnil ( * geomMBR ) || * coordinateIdx == int_nil ) { * coordinateValue = dbl_nil ; return MAL_SUCCEED ; } switch ( * coordinateIdx ) { case 1 : * coordinateValue = ( * geomMBR ) -> xmin ; break ; case 2 : * coordinateValue = ( * geomMBR ) -> ymin ; break ; case 3 : * coordinateValue = ( * geomMBR ) -> xmax ; break ; case 4 : * coordinateValue = ( * geomMBR ) -> ymax ; break ; default : <S2SV_StartBug> throw ( MAL , "geom.coordinateFromMBR" , "SQLSTATE<S2SV_blank>38000<S2SV_blank>!" "Geos<S2SV_blank>unrecognized<S2SV_blank>coordinateIdx:<S2SV_blank>%d\\n" , * coordinateIdx ) ; <S2SV_EndBug> } return MAL_SUCCEED ; }
|
<S2SV_ModStart> , "geom.coordinateFromMBR" , SQLSTATE ( 38000 ) <S2SV_ModEnd> "Geos<S2SV_blank>unrecognized<S2SV_blank>coordinateIdx:<S2SV_blank>%d\\n" , *
|
1,004
|
CWE-000 void * demo_log ( void * arg ) { <S2SV_StartBug> int i = random ( ) % 5 ; <S2SV_EndBug> while ( ( i -- ) > 0 ) { <S2SV_StartBug> usleep ( random ( ) % 500 ) ; <S2SV_EndBug> <S2SV_StartBug> log_v ( "tid<S2SV_blank>=<S2SV_blank>%u,<S2SV_blank>test<S2SV_blank>log" , pthread_self ( ) ) ; <S2SV_EndBug> usleep ( random ( ) % 500 ) ; log_d ( "tid<S2SV_blank>=<S2SV_blank>%u,<S2SV_blank>test<S2SV_blank>log" , pthread_self ( ) ) ; <S2SV_StartBug> usleep ( random ( ) % 500 ) ; <S2SV_EndBug> <S2SV_StartBug> log_i ( "tid<S2SV_blank>=<S2SV_blank>%u,<S2SV_blank>test<S2SV_blank>log" , pthread_self ( ) ) ; <S2SV_EndBug> usleep ( random ( ) % 500 ) ; log_w ( "tid<S2SV_blank>=<S2SV_blank>%u,<S2SV_blank>test<S2SV_blank>log" , pthread_self ( ) ) ; <S2SV_StartBug> usleep ( random ( ) % 500 ) ; <S2SV_EndBug> <S2SV_StartBug> log_e ( "tid<S2SV_blank>=<S2SV_blank>%u,<S2SV_blank>test<S2SV_blank>log" , pthread_self ( ) ) ; <S2SV_EndBug> usleep ( random ( ) % 500 ) ; log_f ( "tid<S2SV_blank>=<S2SV_blank>%u,<S2SV_blank>test<S2SV_blank>log" , pthread_self ( ) ) ; <S2SV_StartBug> usleep ( random ( ) % 500 ) ; <S2SV_EndBug> } return NULL ; }
|
<S2SV_ModStart> int i = 10000 <S2SV_ModEnd> ; while ( <S2SV_ModStart> 0 ) { <S2SV_ModEnd> log_v ( "tid<S2SV_blank>=<S2SV_blank>%u,<S2SV_blank>test<S2SV_blank>log" <S2SV_ModStart> pthread_self ( ) <S2SV_ModEnd> ) ; log_d <S2SV_ModStart> ) ) ; <S2SV_ModEnd> log_i ( "tid<S2SV_blank>=<S2SV_blank>%u,<S2SV_blank>test<S2SV_blank>log" <S2SV_ModStart> pthread_self ( ) <S2SV_ModEnd> ) ; log_w <S2SV_ModStart> ) ) ; <S2SV_ModEnd> log_e ( "tid<S2SV_blank>=<S2SV_blank>%u,<S2SV_blank>test<S2SV_blank>log" <S2SV_ModStart> pthread_self ( ) <S2SV_ModEnd> ) ; log_f <S2SV_ModStart> ) ) ; <S2SV_ModEnd> } return NULL
|
1,005
|
CWE-000 static Ast * parse_binop_semantics ( Scope * scope , Ast * ast ) { ast -> binary -> left = parse_semantics ( scope , ast -> binary -> left ) ; ast -> binary -> right = parse_semantics ( scope , ast -> binary -> right ) ; Ast * l = ast -> binary -> left ; Ast * r = ast -> binary -> right ; Type * lt = l -> var_type ; Type * rt = r -> var_type ; switch ( ast -> binary -> op ) { case OP_PLUS : { int numeric = is_numeric ( lt ) && is_numeric ( rt ) ; int strings = is_string ( lt ) && is_string ( rt ) ; if ( ! numeric && ! strings ) { <S2SV_StartBug> error ( ast -> line , ast -> file , "Operator<S2SV_blank>\'%s\'<S2SV_blank>is<S2SV_blank>valid<S2SV_blank>only<S2SV_blank>for<S2SV_blank>numeric<S2SV_blank>or<S2SV_blank>string<S2SV_blank>arguments,<S2SV_blank>not<S2SV_blank>for<S2SV_blank>type<S2SV_blank>\'%s\'." , <S2SV_EndBug> <S2SV_StartBug> op_to_str ( ast -> binary -> op ) , type_to_string ( lt ) ) ; <S2SV_EndBug> } break ; } case OP_MINUS : case OP_MUL : case OP_DIV : case OP_XOR : case OP_BINAND : case OP_BINOR : case OP_GT : case OP_GTE : case OP_LT : case OP_LTE : if ( ! is_numeric ( lt ) ) { error ( ast -> line , ast -> file , "LHS<S2SV_blank>of<S2SV_blank>operator<S2SV_blank>\'%s\'<S2SV_blank>has<S2SV_blank>invalid<S2SV_blank>non-numeric<S2SV_blank>type<S2SV_blank>\'%s\'." , op_to_str ( ast -> binary -> op ) , type_to_string ( lt ) ) ; } else if ( ! is_numeric ( rt ) ) { error ( ast -> line , ast -> file , "RHS<S2SV_blank>of<S2SV_blank>operator<S2SV_blank>\'%s\'<S2SV_blank>has<S2SV_blank>invalid<S2SV_blank>non-numeric<S2SV_blank>type<S2SV_blank>\'%s\'." , op_to_str ( ast -> binary -> op ) , type_to_string ( rt ) ) ; } break ; case OP_AND : case OP_OR : if ( lt -> id != base_type ( BOOL_T ) -> id ) { error ( ast -> line , ast -> file , "Operator<S2SV_blank>\'%s\'<S2SV_blank>is<S2SV_blank>not<S2SV_blank>valid<S2SV_blank>for<S2SV_blank>non-bool<S2SV_blank>arguments<S2SV_blank>of<S2SV_blank>type<S2SV_blank>\'%s\'." , op_to_str ( ast -> binary -> op ) , type_to_string ( lt ) ) ; } break ; case OP_EQUALS : case OP_NEQUALS : if ( ! ( check_type ( lt , rt ) || can_coerce_type ( scope , lt , ast -> binary -> right ) ) ) { error ( ast -> line , ast -> file , "Cannot<S2SV_blank>compare<S2SV_blank>equality<S2SV_blank>of<S2SV_blank>non-comparable<S2SV_blank>types<S2SV_blank>\'%s\'<S2SV_blank>and<S2SV_blank>\'%s\'." , type_to_string ( lt ) , type_to_string ( rt ) ) ; } break ; } if ( l -> type == AST_LITERAL && r -> type == AST_LITERAL ) { return eval_const_binop ( ast ) ; } if ( is_comparison ( ast -> binary -> op ) ) { ast -> var_type = base_type ( BOOL_T ) ; } else if ( ast -> binary -> op != OP_ASSIGN && is_numeric ( lt ) ) { ast -> var_type = promote_number_type ( lt , l -> type == AST_LITERAL , rt , r -> type == AST_LITERAL ) ; } else { ast -> var_type = lt ; } return ast ; }
|
<S2SV_ModStart> -> file , "Operator<S2SV_blank>\'%s\'<S2SV_blank>is<S2SV_blank>not<S2SV_blank>valid<S2SV_blank>between<S2SV_blank>types<S2SV_blank>\'%s\'<S2SV_blank>and<S2SV_blank>\'%s\'." <S2SV_ModEnd> , op_to_str ( <S2SV_ModStart> type_to_string ( lt ) , type_to_string ( rt
|
1,006
|
CWE-000 int __wt_reconcile ( WT_SESSION_IMPL * session , WT_REF * ref , WT_SALVAGE_COOKIE * salvage , uint32_t flags , bool * lookaside_retryp ) { WT_DECL_RET ; WT_PAGE * page ; WT_PAGE_MODIFY * mod ; WT_RECONCILE * r ; uint64_t oldest_id ; page = ref -> page ; mod = page -> modify ; if ( lookaside_retryp != NULL ) * lookaside_retryp = false ; __wt_verbose ( session , WT_VERB_RECONCILE , "%s" , __wt_page_type_string ( page -> type ) ) ; WT_ASSERT ( session , __wt_page_is_modified ( page ) ) ; __wt_writelock ( session , & page -> page_lock ) ; oldest_id = __wt_txn_oldest_id ( session ) ; if ( LF_ISSET ( WT_EVICTING ) ) mod -> last_eviction_id = oldest_id ; # ifdef HAVE_DIAGNOSTIC WT_ASSERT ( session , WT_TXNID_LE ( mod -> last_oldest_id , oldest_id ) ) ; mod -> last_oldest_id = oldest_id ; # endif if ( ( ret = __rec_write_init ( session , ref , flags , salvage , & session -> reconcile ) ) != 0 ) { __wt_writeunlock ( session , & page -> page_lock ) ; return ( ret ) ; } r = session -> reconcile ; switch ( page -> type ) { case WT_PAGE_COL_FIX : if ( salvage != NULL ) ret = __rec_col_fix_slvg ( session , r , ref , salvage ) ; else ret = __rec_col_fix ( session , r , ref ) ; break ; case WT_PAGE_COL_INT : WT_WITH_PAGE_INDEX ( session , ret = __rec_col_int ( session , r , ref ) ) ; break ; case WT_PAGE_COL_VAR : ret = __rec_col_var ( session , r , ref , salvage ) ; break ; case WT_PAGE_ROW_INT : WT_WITH_PAGE_INDEX ( session , ret = __rec_row_int ( session , r , page ) ) ; break ; case WT_PAGE_ROW_LEAF : ret = __rec_row_leaf ( session , r , page , salvage ) ; break ; WT_ILLEGAL_VALUE_SET ( session ) ; } if ( ret == 0 ) ret = __rec_write_check_complete ( session , r ) ; if ( ret == 0 && ( ret = __rec_write_wrapup ( session , r , page ) ) == 0 ) __rec_write_page_status ( session , r ) ; else WT_TRET ( __rec_write_wrapup_err ( session , r , page ) ) ; __wt_writeunlock ( session , & page -> page_lock ) ; <S2SV_StartBug> if ( lookaside_retryp != NULL && r -> update_cnt == r -> update_skip_cnt ) <S2SV_EndBug> * lookaside_retryp = true ; WT_STAT_CONN_INCR ( session , rec_pages ) ; WT_STAT_DATA_INCR ( session , rec_pages ) ; if ( LF_ISSET ( WT_EVICTING ) ) { WT_STAT_CONN_INCR ( session , rec_pages_eviction ) ; WT_STAT_DATA_INCR ( session , rec_pages_eviction ) ; } if ( r -> cache_write_lookaside ) { WT_STAT_CONN_INCR ( session , cache_write_lookaside ) ; WT_STAT_DATA_INCR ( session , cache_write_lookaside ) ; } if ( r -> cache_write_restore ) { WT_STAT_CONN_INCR ( session , cache_write_restore ) ; WT_STAT_DATA_INCR ( session , cache_write_restore ) ; } if ( WT_SESSION_IS_CHECKPOINT ( session ) ) __rec_bnd_cleanup ( session , r , false ) ; else { if ( session -> block_manager_cleanup != NULL ) WT_TRET ( session -> block_manager_cleanup ( session ) ) ; WT_TRET ( __rec_destroy_session ( session ) ) ; } WT_RET ( ret ) ; if ( __wt_ref_is_root ( ref ) ) { WT_WITH_PAGE_INDEX ( session , ret = __rec_root_write ( session , page , flags ) ) ; return ( ret ) ; } return ( __wt_page_parent_modify_set ( session , ref , true ) ) ; }
|
<S2SV_ModStart> && r -> update_mem_skipped == 0 <S2SV_ModEnd> ) * lookaside_retryp
|
1,007
|
CWE-000 void lockdep_reset ( void ) { unsigned long flags ; int i ; raw_local_irq_save ( flags ) ; current -> curr_chain_key = 0 ; current -> lockdep_depth = 0 ; current -> lockdep_recursion = 0 ; memset ( current -> held_locks , 0 , MAX_LOCK_DEPTH * sizeof ( struct held_lock ) ) ; nr_hardirq_chains = 0 ; nr_softirq_chains = 0 ; nr_process_chains = 0 ; debug_locks = 1 ; for ( i = 0 ; i < CHAINHASH_SIZE ; i ++ ) <S2SV_StartBug> INIT_LIST_HEAD ( chainhash_table + i ) ; <S2SV_EndBug> raw_local_irq_restore ( flags ) ; }
|
<S2SV_ModStart> i ++ ) INIT_HLIST_HEAD <S2SV_ModEnd> ( chainhash_table +
|
1,008
|
CWE-000 int compress ( char * inputStart , int inputLength , char * outputStart , int outputLength ) { char * input = inputStart ; char * inputEnd = input + inputLength ; char * output = outputStart ; <S2SV_StartBug> * ( int * ) output = inputLength ; <S2SV_EndBug> output += sizeof ( int ) ; while ( input < inputEnd ) { char * windowStart = input - windowSize < inputStart ? inputStart : input - windowSize ; char * matchPos = NULL ; int matchLength = match ( windowStart , input , input , inputEnd , & matchPos ) ; if ( matchLength > 1 ) { <S2SV_StartBug> * output ++ = matchLength ; <S2SV_EndBug> <S2SV_StartBug> * ( short * ) output = ( short ) ( input - matchPos ) ; <S2SV_EndBug> <S2SV_StartBug> output += sizeof ( short ) ; <S2SV_EndBug> input += matchLength ; } else { * output ++ = 0 ; * output ++ = * input ; input ++ ; } } return ( int ) ( output - outputStart ) ; }
|
<S2SV_ModStart> = outputStart ; char * outputEnd = output + outputLength ; <S2SV_ModStart> output ++ = ( unsigned char ) matchLength ; * ( unsigned <S2SV_ModEnd> short * ) <S2SV_ModStart> output = ( unsigned <S2SV_ModStart> += sizeof ( unsigned
|
1,009
|
CWE-000 object alloc_pair_gc ( object a , object b ) { <S2SV_StartBug> size_t bytes = sizeof ( object ) ; <S2SV_EndBug> <S2SV_StartBug> size_t alloc_size = ( bytes & ~ ( HEAP_ALIGNMENT - 1 ) ) + ( ( bytes & ( HEAP_ALIGNMENT - 1 ) ) ? HEAP_ALIGNMENT : 0 ) ; <S2SV_EndBug> if ( ( interpreter . heap_position + alloc_size ) > interpreter . heap . size ) { push_gc_stack ( STACK , a ) ; push_gc_stack ( STACK , b ) ; <S2SV_StartBug> garbage_collect ( sizeof ( object ) ) ; <S2SV_EndBug> b = pop_gc_stack ( STACK ) ; a = pop_gc_stack ( STACK ) ; } void * ret = ( void * ) ( ( size_t ) interpreter . heap . ptr + ( size_t ) interpreter . heap_position ) ; interpreter . heap_position += alloc_size ; pair * c = ( pair * ) ret ; c -> first = a ; c -> rest = b ; return ( object ) { ( uint64_t ) ( c ) } ; }
|
<S2SV_ModStart> ) { size_t <S2SV_ModEnd> alloc_size = ( <S2SV_ModStart> alloc_size = ( sizeof ( pair ) + HEAP_ALIGNMENT - 1 ) <S2SV_ModEnd> & ~ ( <S2SV_ModStart> HEAP_ALIGNMENT - 1 <S2SV_ModEnd> ) ; if <S2SV_ModStart> ( sizeof ( pair <S2SV_ModEnd> ) ) ;
|
1,010
|
CWE-000 <S2SV_StartBug> void platform_set_all_led ( const char state ) { <S2SV_EndBug> int i ; int j ; for ( i = 0 ; i < 3 ; i ++ ) { for ( j = 0 ; j < 3 ; j ++ ) { platform_set_led ( i , j , state ) ; } } }
|
<S2SV_ModStart> platform_set_all_led ( const unsigned
|
1,011
|
CWE-000 char * rp_strerror ( int error ) { <S2SV_StartBug> static char s [ 100 ] ; <S2SV_EndBug> int i = 0 ; while ( rp_errors [ i ] . desc != NULL ) { if ( rp_errors [ i ] . error == error ) { <S2SV_StartBug> strcpy ( s , rp_errors [ i ] . desc ) ; <S2SV_EndBug> } i ++ ; } if ( s [ 0 ] == '\\0' ) sprintf ( s , "unknown<S2SV_blank>(error=%d)" , error ) ; return ( s ) ; }
|
<S2SV_ModStart> [ 100 ] ; size_t space = sizeof ( s ) <S2SV_ModStart> error ) { strlcpy <S2SV_ModEnd> ( s , <S2SV_ModStart> ( s , rp_errors [ i ] . desc , space ) ; space -= strlen (
|
1,012
|
CWE-000 VALUE rb_mutex_lock ( VALUE self ) { rb_thread_t * th = GET_THREAD ( ) ; rb_mutex_t * mutex ; GetMutexPtr ( self , mutex ) ; if ( ! mutex -> allow_trap && th -> interrupt_mask & TRAP_INTERRUPT_MASK ) { rb_raise ( rb_eThreadError , "can\'t<S2SV_blank>be<S2SV_blank>called<S2SV_blank>from<S2SV_blank>trap<S2SV_blank>context" ) ; } if ( rb_mutex_trylock ( self ) == Qfalse ) { if ( mutex -> th == th ) { rb_raise ( rb_eThreadError , "deadlock;<S2SV_blank>recursive<S2SV_blank>locking" ) ; } while ( mutex -> th != th ) { int interrupted ; enum rb_thread_status prev_status = th -> status ; volatile int timeout_ms = 0 ; struct rb_unblock_callback oldubf ; set_unblock_function ( th , lock_interrupt , mutex , & oldubf , FALSE ) ; th -> status = THREAD_STOPPED_FOREVER ; th -> locking_mutex = self ; native_mutex_lock ( & mutex -> lock ) ; th -> vm -> sleeper ++ ; if ( ( vm_living_thread_num ( th -> vm ) == th -> vm -> sleeper ) && ! patrol_thread ) { timeout_ms = 100 ; patrol_thread = th ; } GVL_UNLOCK_BEGIN ( ) ; interrupted = lock_func ( th , mutex , ( int ) timeout_ms ) ; native_mutex_unlock ( & mutex -> lock ) ; GVL_UNLOCK_END ( ) ; if ( patrol_thread == th ) patrol_thread = NULL ; reset_unblock_function ( th , & oldubf ) ; th -> locking_mutex = Qfalse ; if ( mutex -> th && interrupted == 2 ) { rb_check_deadlock ( th -> vm ) ; } if ( th -> status == THREAD_STOPPED_FOREVER ) { th -> status = prev_status ; } th -> vm -> sleeper -- ; if ( mutex -> th == th ) mutex_locked ( th , self ) ; if ( interrupted ) { RUBY_VM_CHECK_INTS_BLOCKING ( th ) ; <S2SV_StartBug> } <S2SV_EndBug> } } return self ; }
|
<S2SV_ModStart> th ) ; if ( ! mutex -> th ) { mutex -> th = th ; mutex_locked ( th , self ) ; }
|
1,013
|
CWE-000 void verstage_main ( void ) { struct vb2_context ctx ; struct region_device fw_main ; int rv ; timestamp_add_now ( TS_START_VBOOT ) ; vb2_init_work_context ( & ctx ) ; vbnv_init ( ctx . nvdata ) ; if ( IS_ENABLED ( CONFIG_RESUME_PATH_SAME_AS_BOOT ) && IS_ENABLED ( CONFIG_VBOOT_STARTS_IN_BOOTBLOCK ) && vboot_platform_is_resuming ( ) ) ctx . flags |= VB2_CONTEXT_S3_RESUME ; timestamp_add_now ( TS_START_TPMINIT ) ; antirollback_read_space_firmware ( & ctx ) ; timestamp_add_now ( TS_END_TPMINIT ) ; if ( IS_ENABLED ( CONFIG_VBOOT_PHYSICAL_DEV_SWITCH ) && get_developer_mode_switch ( ) ) ctx . flags |= VB2_CONTEXT_FORCE_DEVELOPER_MODE ; if ( get_recovery_mode_switch ( ) ) { ctx . flags |= VB2_CONTEXT_FORCE_RECOVERY_MODE ; if ( IS_ENABLED ( CONFIG_VBOOT_DISABLE_DEV_ON_RECOVERY ) ) ctx . flags |= VB2_DISABLE_DEVELOPER_MODE ; } if ( IS_ENABLED ( CONFIG_VBOOT_WIPEOUT_SUPPORTED ) && get_wipeout_mode_switch ( ) ) ctx . flags |= VB2_CONTEXT_FORCE_WIPEOUT_MODE ; if ( IS_ENABLED ( CONFIG_VBOOT_LID_SWITCH ) && ! get_lid_switch ( ) ) ctx . flags |= VB2_CONTEXT_NOFAIL_BOOT ; printk ( BIOS_INFO , "Phase<S2SV_blank>1\\n" ) ; rv = vb2api_fw_phase1 ( & ctx ) ; if ( rv ) { if ( rv == VB2_ERROR_API_PHASE1_RECOVERY ) { printk ( BIOS_INFO , "Recovery<S2SV_blank>requested<S2SV_blank>(%x)\\n" , rv ) ; save_if_needed ( & ctx ) ; extend_pcrs ( & ctx ) ; timestamp_add_now ( TS_END_VBOOT ) ; return ; } <S2SV_StartBug> printk ( BIOS_INFO , "Reboot<S2SV_blank>reqested<S2SV_blank>(%x)\\n" , rv ) ; <S2SV_EndBug> save_if_needed ( & ctx ) ; vboot_reboot ( ) ; } printk ( BIOS_INFO , "Phase<S2SV_blank>2\\n" ) ; rv = vb2api_fw_phase2 ( & ctx ) ; if ( rv ) { printk ( BIOS_INFO , "Reboot<S2SV_blank>requested<S2SV_blank>(%x)\\n" , rv ) ; save_if_needed ( & ctx ) ; vboot_reboot ( ) ; } printk ( BIOS_INFO , "Phase<S2SV_blank>3\\n" ) ; timestamp_add_now ( TS_START_VERIFY_SLOT ) ; rv = vb2api_fw_phase3 ( & ctx ) ; timestamp_add_now ( TS_END_VERIFY_SLOT ) ; if ( rv ) { printk ( BIOS_INFO , "Reboot<S2SV_blank>requested<S2SV_blank>(%x)\\n" , rv ) ; save_if_needed ( & ctx ) ; vboot_reboot ( ) ; } printk ( BIOS_INFO , "Phase<S2SV_blank>4\\n" ) ; rv = locate_firmware ( & ctx , & fw_main ) ; if ( rv ) die ( "Failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>FMAP<S2SV_blank>to<S2SV_blank>locate<S2SV_blank>firmware" ) ; rv = hash_body ( & ctx , & fw_main ) ; save_if_needed ( & ctx ) ; if ( rv ) { printk ( BIOS_INFO , "Reboot<S2SV_blank>requested<S2SV_blank>(%x)\\n" , rv ) ; vboot_reboot ( ) ; } timestamp_add_now ( TS_START_TPMPCR ) ; rv = extend_pcrs ( & ctx ) ; if ( rv ) { printk ( BIOS_WARNING , "Failed<S2SV_blank>to<S2SV_blank>extend<S2SV_blank>TPM<S2SV_blank>PCRs<S2SV_blank>(%#x)\\n" , rv ) ; vb2api_fail ( & ctx , VB2_RECOVERY_RO_TPM_U_ERROR , rv ) ; save_if_needed ( & ctx ) ; vboot_reboot ( ) ; } timestamp_add_now ( TS_END_TPMPCR ) ; timestamp_add_now ( TS_START_TPMLOCK ) ; rv = antirollback_lock_space_firmware ( ) ; if ( rv ) { printk ( BIOS_INFO , "Failed<S2SV_blank>to<S2SV_blank>lock<S2SV_blank>TPM<S2SV_blank>(%x)\\n" , rv ) ; vb2api_fail ( & ctx , VB2_RECOVERY_RO_TPM_L_ERROR , 0 ) ; save_if_needed ( & ctx ) ; vboot_reboot ( ) ; } timestamp_add_now ( TS_END_TPMLOCK ) ; if ( IS_ENABLED ( CONFIG_VBOOT_HAS_REC_HASH_SPACE ) ) { rv = antirollback_lock_space_rec_hash ( ) ; if ( rv ) { printk ( BIOS_INFO , "Failed<S2SV_blank>to<S2SV_blank>lock<S2SV_blank>rec<S2SV_blank>hash<S2SV_blank>space(%x)\\n" , rv ) ; vb2api_fail ( & ctx , VB2_RECOVERY_RO_TPM_REC_HASH_L_ERROR , 0 ) ; save_if_needed ( & ctx ) ; vboot_reboot ( ) ; } } printk ( BIOS_INFO , "Slot<S2SV_blank>%c<S2SV_blank>is<S2SV_blank>selected\\n" , is_slot_a ( & ctx ) ? 'A' : 'B' ) ; vb2_set_selected_region ( region_device_region ( & fw_main ) ) ; timestamp_add_now ( TS_END_VBOOT ) ; }
|
<S2SV_ModStart> ( BIOS_INFO , "Reboot<S2SV_blank>requested<S2SV_blank>(%x)\\n" <S2SV_ModEnd> , rv )
|
1,014
|
CWE-000 int valid_msg ( char * buffer , int seq_no , int last_seq_no ) { <S2SV_StartBug> int valid_dheaders = validate_seq_headers ( buffer ) ; <S2SV_EndBug> <S2SV_StartBug> int valid_sheaders = validate_data_headers ( buffer ) ; <S2SV_EndBug> <S2SV_StartBug> int seq_in_order = is_seq_in_order ( seq_no , last_seq_no ) ; <S2SV_EndBug> <S2SV_StartBug> return valid_dheaders && valid_sheaders && seq_in_order ; <S2SV_EndBug> }
|
<S2SV_ModStart> ) { int is_valid <S2SV_ModEnd> = validate_seq_headers ( <S2SV_ModStart> buffer ) ; is_valid &= <S2SV_ModEnd> validate_data_headers ( buffer <S2SV_ModStart> buffer ) ; is_valid &= <S2SV_ModEnd> is_seq_in_order ( seq_no <S2SV_ModStart> ) ; return is_valid <S2SV_ModEnd> ; } <S2SV_null>
|
1,015
|
CWE-000 void bnxt_disable_int ( struct bnxt * bp ) { struct bnxt_cp_ring_info * cpr = bp -> def_cp_ring ; if ( cpr != NULL && cpr -> cp_doorbell != NULL ) <S2SV_StartBug> B_CP_DIS_DB ( cpr , cpr -> cp_raw_cons ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> != NULL ) B_CP_DB_DISARM ( cpr <S2SV_ModEnd> ) ; }
|
1,016
|
CWE-000 static bool lwj_targets_this_node ( flux_t * h , const char * kvspath ) { char key [ MAX_JOB_PATH ] ; flux_future_t * f = NULL ; const flux_kvsdir_t * dir ; bool result = false ; snprintf ( key , sizeof ( key ) , "%s.rank" , kvspath ) ; if ( ! ( f = flux_kvs_lookup ( h , FLUX_KVS_READDIR , key ) ) || flux_kvs_lookup_get_dir ( f , & dir ) < 0 ) { <S2SV_StartBug> flux_log ( h , LOG_INFO , "No<S2SV_blank>dir<S2SV_blank>%s.rank:<S2SV_blank>%s" , <S2SV_EndBug> kvspath , flux_strerror ( errno ) ) ; goto done ; } snprintf ( key , sizeof ( key ) , "%d" , broker_rank ) ; if ( flux_kvsdir_isdir ( dir , key ) ) result = true ; done : flux_future_destroy ( f ) ; return result ; }
|
<S2SV_ModStart> ( h , LOG_DEBUG <S2SV_ModEnd> , "No<S2SV_blank>dir<S2SV_blank>%s.rank:<S2SV_blank>%s" ,
|
1,017
|
CWE-000 double transport_LLE_eval_func ( int k , _PARAMETERS_ ) { int j ; double _tmp ; static int n1st = 1 ; static double * rhs_flux , * y_1 , * y_2 , * dlnphi_1 , * dlnphi_2 ; double V_1 , V_2 ; if ( n1st ) { n1st = 0 ; _NEW_ ( rhs_flux , double , n ) ; _NEW_ ( dlnphi_1 , double , n * n ) ; _NEW_ ( dlnphi_2 , double , n * n ) ; _NEW_ ( y_1 , double , n ) ; _NEW_ ( y_2 , double , n ) ; } for ( j = 0 ; j < n ; j ++ ) { if ( x_1 [ j ] < 0 ) x_1 [ j ] = - x_1 [ j ] ; if ( x_2 [ j ] < 0 ) x_2 [ j ] = - x_2 [ j ] ; } transport_LLE_core ( P , T_s , k , n , Pc , Tc , w , kij , x_1 , x_2 ) ; <S2SV_StartBug> fugacities_n_its_derivatives3_ ( & P , & T_s , & n , Pc , Tc , w , x_1 , kij , lnphi_1 , dlnphi_1 , & V_1 ) ; <S2SV_EndBug> <S2SV_StartBug> new_tlsm_diffusion_krishna_model_ ( & P , & T_s , & n , Pc , Tc , Vc , w , MW , kij , x_1 , Dij_1 ) ; <S2SV_EndBug> <S2SV_StartBug> fugacities_n_its_derivatives3_ ( & P , & T_s , & n , Pc , Tc , w , x_2 , kij , lnphi_2 , dlnphi_2 , & V_2 ) ; <S2SV_EndBug> new_tlsm_diffusion_krishna_model_ ( & P , & T_s , & n , Pc , Tc , Vc , w , MW , kij , x_2 , Dij_2 ) ; x2y ( n , MW , x_1 , y_1 ) ; x2y ( n , MW , x_2 , y_2 ) ; { for ( j = 0 ; j < n ; j ++ ) { double xm = x_1 [ j ] ; if ( xm < 0 ) { if ( x_2 [ j ] < xm ) xm = x_2 [ j ] ; } else { if ( x_2 [ j ] < 0 ) xm = x_2 [ j ] ; } if ( xm < 0 ) return - xm * 1e5 ; } for ( j = 0 ; j < n ; j ++ ) { double xm = x_1 [ j ] ; if ( xm > 1 ) { if ( x_2 [ j ] > xm ) xm = x_2 [ j ] ; } else { if ( x_2 [ j ] > 1 ) xm = x_2 [ j ] ; } if ( xm > 1 ) return ( xm - 1 ) * 1e5 ; } } calc_MS_flux_interface ( n_flux_type , dL , dR , P , T_s , n , MW , x_1 , x_L , x_2 , x_R , dlnphi_1 , dlnphi_2 , Dij_1 , Dij_2 , V_1 , V_2 , rhs_flux , flux_m_1 , flux_m_2 , flux_umf ) ; _tmp = transport_evaluation_func ( n , y_1 , y_2 , flux_m_1 , flux_m_2 ) ; return _tmp ; }
|
<S2SV_ModStart> x_2 ) ; if ( n_flux_type >= 0 ) { <S2SV_ModStart> V_1 ) ; } else { molar_volume2_ ( & P , & T_s , & n , Pc , Tc , w , kij , x_1 , & V_1 ) ; } <S2SV_ModStart> Dij_1 ) ; if ( n_flux_type >= 0 ) { <S2SV_ModStart> V_2 ) ; } else { molar_volume2_ ( & P , & T_s , & n , Pc , Tc , w , kij , x_2 , & V_2 ) ; }
|
1,018
|
CWE-000 s32 load_class ( ClassLoader * loader , Utf8String * pClassName , Runtime * runtime ) { if ( ! loader ) return 0 ; s32 iret = 0 ; Utf8String * clsName = utf8_create_copy ( pClassName ) ; utf8_replace_c ( clsName , "." , "/" ) ; JClass * tmpclazz = classes_get ( clsName ) ; if ( utf8_indexof_c ( clsName , "[" ) == 0 ) { tmpclazz = array_class_get ( clsName ) ; } if ( ! tmpclazz ) { ByteBuf * bytebuf = NULL ; utf8_append_c ( clsName , ".class" ) ; bytebuf = load_file_from_classpath ( loader , clsName ) ; if ( bytebuf != NULL ) { tmpclazz = class_create ( ) ; iret = tmpclazz -> _load_class_from_bytes ( tmpclazz , bytebuf ) ; bytebuf_destory ( bytebuf ) ; if ( iret == 0 ) { <S2SV_StartBug> classes_put ( tmpclazz ) ; <S2SV_EndBug> # if _JVM_DEBUG_BYTECODE_DETAIL > 5 jvm_printf ( "load<S2SV_blank>class:<S2SV_blank><S2SV_blank>%s<S2SV_blank>\\n" , utf8_cstr ( clsName ) ) ; # endif <S2SV_StartBug> class_prepar ( tmpclazz , runtime ) ; <S2SV_EndBug> } else { class_destory ( tmpclazz ) ; } } } if ( ! tmpclazz ) { jvm_printf ( "class<S2SV_blank>not<S2SV_blank>found:<S2SV_blank><S2SV_blank>%s<S2SV_blank>\\n" , utf8_cstr ( clsName ) ) ; } utf8_destory ( clsName ) ; return iret ; }
|
<S2SV_ModStart> ) { classes_put ( tmpclazz ) ; class_prepar ( tmpclazz , runtime ) ; garbage_refer_hold ( tmpclazz ) ; garbage_refer_reg <S2SV_ModStart> ; # endif <S2SV_ModEnd> } else {
|
1,019
|
CWE-000 <S2SV_StartBug> Pnil find_node ( Plist list_inst , int pid ) { <S2SV_EndBug> <S2SV_StartBug> if ( list_inst -> first_node = NULL ) return ; <S2SV_EndBug> nil nodes ; <S2SV_StartBug> nodes . cur_node = list_inst -> first_node ; <S2SV_EndBug> nodes . prev_node = NULL ; nodes . next_node = nodes . cur_node -> next ; int found = ( pid == nodes . cur_node -> job_elem -> pid ) ; while ( ! found && ( nodes . cur_node != NULL ) ) { nodes . prev_node = nodes . cur_node ; nodes . cur_node = nodes . cur_node -> next ; nodes . next_node = nodes . cur_node -> next ; found = ( pid == nodes . cur_node -> job_elem -> pid ) ; } if ( nodes . cur_node == NULL ) return NULL ; else return nodes ; }
|
<S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> nil <S2SV_ModEnd> find_node ( Plist <S2SV_ModStart> pid ) { nil nodes ; nodes . cur_node = NULL ; nodes . prev_node = NULL ; nodes . next_node = NULL ; <S2SV_ModStart> list_inst -> first_node == <S2SV_ModEnd> NULL ) return <S2SV_ModStart> NULL ) return <S2SV_ModEnd> nodes ; nodes <S2SV_ModStart> list_inst -> first_node <S2SV_ModEnd> ; nodes .
|
1,020
|
CWE-000 int dhcp6_lease_get_serverid ( sd_dhcp6_lease * lease , uint8_t * * id , size_t * len ) { assert_return ( lease , - EINVAL ) ; <S2SV_StartBug> assert_return ( id , - EINVAL ) ; <S2SV_EndBug> assert_return ( len , - EINVAL ) ; <S2SV_StartBug> * id = lease -> serverid ; <S2SV_EndBug> * len = lease -> serverid_len ; return 0 ; }
|
<S2SV_ModStart> EINVAL ) ; if ( ! lease -> serverid ) return - ENOMSG ; if ( id ) <S2SV_ModEnd> * id = <S2SV_ModStart> -> serverid ; if ( len )
|
1,021
|
CWE-000 bufptr bread ( uint16_t dev , blkno_t blk , bool rewrite ) { regptr bufptr bp ; if ( ( bp = bfind ( dev , blk ) ) == NULL ) { bp = freebuf ( ) ; bp -> bf_dev = dev ; bp -> bf_blk = blk ; if ( ! rewrite ) { if ( bdread ( bp ) != BLKSIZE ) { udata . u_error = EIO ; bp -> bf_dev = NO_DEVICE ; <S2SV_StartBug> bunlock ( bp ) ; <S2SV_EndBug> return ( NULL ) ; } } } bp -> bf_time = ++ bufclock ; return bp ; }
|
<S2SV_ModStart> = NO_DEVICE ; bp -> bf_dirty = false ;
|
1,022
|
CWE-000 <S2SV_StartBug> static void round_begin_sniffer ( chaos_header_t * header ) { <S2SV_EndBug> if ( ! IS_CLUSTER_HEAD ( ) ) { header -> join = ! chaos_has_node_index ; } <S2SV_StartBug> if ( IS_INITIATOR ( ) ) { <S2SV_EndBug> header -> join |= pending ; } }
|
<S2SV_ModStart> header ) { # if CHAOS_CLUSTER <S2SV_ModStart> chaos_has_node_index ; } # else header -> join = ! chaos_has_node_index ; # endif
|
1,023
|
CWE-000 static void scsi_handle_inquiry_reply ( SCSIGenericReq * r , SCSIDevice * s ) <S2SV_StartBug> { <S2SV_EndBug> if ( s -> scsi_version == - 1 && ! ( r -> req . cmd . buf [ 1 ] & 0x01 ) ) { s -> scsi_version = r -> buf [ 2 ] & 0x07 ; if ( s -> scsi_version > 2 ) { s -> scsi_version = r -> buf [ 2 ] ; } } <S2SV_StartBug> if ( s -> type == TYPE_DISK && r -> req . cmd . buf [ 2 ] == 0xb0 ) { <S2SV_EndBug> uint32_t max_transfer = blk_get_max_transfer ( s -> conf . blk ) / s -> blocksize ; assert ( max_transfer ) ; stl_be_p ( & r -> buf [ 8 ] , max_transfer ) ; stl_be_p ( & r -> buf [ 12 ] , MIN_NON_ZERO ( max_transfer , ldl_be_p ( & r -> buf [ 12 ] ) ) ) ; <S2SV_StartBug> } <S2SV_EndBug> }
|
<S2SV_ModStart> s ) { uint8_t page , page_len ; <S2SV_ModStart> == TYPE_DISK && ( <S2SV_ModStart> . buf [ 1 ] & 0x01 ) ) { page = r -> req . cmd . buf [ 2 ] ; if ( page <S2SV_ModEnd> == 0xb0 ) <S2SV_ModStart> ) ; } else if ( page == 0x00 && s -> needs_vpd_bl_emulation ) { page_len = r -> buf [ 3 ] ; r -> buf [ page_len + 4 ] = 0xb0 ; r -> buf [ 3 ] = ++ page_len ; } }
|
1,024
|
CWE-000 static void cpa_flush_array ( unsigned long * start , int numpages , int cache , int in_flags , struct page * * pages ) { unsigned int i , level ; <S2SV_StartBug> unsigned long do_wbinvd = cache && numpages >= 1024 ; <S2SV_EndBug> BUG_ON ( irqs_disabled ( ) ) ; on_each_cpu ( __cpa_flush_all , ( void * ) do_wbinvd , 1 ) ; if ( ! cache || do_wbinvd ) return ; for ( i = 0 ; i < numpages ; i ++ ) { unsigned long addr ; pte_t * pte ; if ( in_flags & CPA_PAGES_ARRAY ) addr = ( unsigned long ) page_address ( pages [ i ] ) ; else addr = start [ i ] ; pte = lookup_address ( addr , & level ) ; if ( pte && ( pte_val ( * pte ) & _PAGE_PRESENT ) ) clflush_cache_range ( ( void * ) addr , PAGE_SIZE ) ; } }
|
<S2SV_ModStart> , level ; # ifdef CONFIG_PREEMPT unsigned long do_wbinvd = 0 ; # else <S2SV_ModStart> >= 1024 ; # endif
|
1,025
|
CWE-000 int main ( int ac , char * * av , char * * ev ) { sev_t sev ; int exitcode = 0 ; ( void ) ac ; initialize_shell_env ( & sev , av , ev ) ; while ( sev . good2go ) { display_prompt ( sev ) ; getcommand ( & sev ) ; if ( ! check_builtin ( & sev ) ) action ( & sev ) ; display_error ( & sev ) ; } write_log ( & sev ) ; exitcode = sev . error ; clean_sev ( & sev ) ; <S2SV_StartBug> return ( exitcode ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> sev ) ; _exit <S2SV_ModEnd> ( exitcode )
|
1,026
|
CWE-000 int autosuspend_disable ( void ) { int ret ; ret = autosuspend_init ( ) ; if ( ret ) { return ret ; } <S2SV_StartBug> ALOGV ( "autosuspend_disable\\n" ) ; <S2SV_EndBug> if ( ! autosuspend_enabled ) { return 0 ; } ret = autosuspend_ops -> disable ( ) ; if ( ret ) { return ret ; } autosuspend_enabled = false ; return 0 ; }
|
<S2SV_ModStart> } ALOGV ( "autosuspend_disable" <S2SV_ModEnd> ) ; if
|
1,027
|
CWE-000 char * handle_flags ( char * length_flag , char * flag , va_list * args ) { char * ret ; char flag_letter ; ret = 0 ; flag_letter = flag [ ft_strlen ( flag ) - 1 ] ; <S2SV_StartBug> if ( flag_letter == '%' && flag [ 0 ] == '%' ) <S2SV_EndBug> ret = "%" ; else if ( flag_letter == 'd' || flag_letter == 'i' || flag_letter == 'D' ) { if ( ! ft_strcmp ( length_flag , "l" ) || flag_letter == 'D' ) ret = ft_intmaxtoa ( va_arg ( * args , long ) ) ; else if ( ! ft_strcmp ( length_flag , "hh" ) ) ret = ft_itoa ( ( signed char ) va_arg ( * args , int ) ) ; else if ( ! ft_strcmp ( length_flag , "h" ) ) ret = ft_itoa ( ( short ) va_arg ( * args , int ) ) ; else if ( ! ft_strcmp ( length_flag , "ll" ) ) ret = ft_intmaxtoa ( va_arg ( * args , long long ) ) ; else if ( ! ft_strcmp ( length_flag , "j" ) ) ret = ft_intmaxtoa ( va_arg ( * args , intmax_t ) ) ; else if ( ! ft_strcmp ( length_flag , "z" ) ) ret = ft_intmaxtoa ( va_arg ( * args , size_t ) ) ; else ret = ft_itoa ( va_arg ( * args , int ) ) ; } else if ( flag_letter == 'x' || flag_letter == 'X' ) { if ( ! ft_strcmp ( length_flag , "hh" ) ) ret = ft_itoa_base ( ( unsigned char ) va_arg ( * args , int ) , 16 ) ; else if ( ! ft_strcmp ( length_flag , "h" ) ) ret = ft_itoa_base ( ( unsigned short ) va_arg ( * args , int ) , 16 ) ; else if ( ! ft_strcmp ( length_flag , "l" ) ) ret = ft_uintmaxtoa_base ( va_arg ( * args , unsigned long ) , 16 ) ; else if ( ! ft_strcmp ( length_flag , "ll" ) ) ret = ft_uintmaxtoa_base ( va_arg ( * args , unsigned long long ) , 16 ) ; else if ( ! ft_strcmp ( length_flag , "j" ) ) ret = ft_uintmaxtoa_base ( va_arg ( * args , uintmax_t ) , 16 ) ; else if ( ! ft_strcmp ( length_flag , "z" ) ) ret = ft_uintmaxtoa_base ( va_arg ( * args , size_t ) , 16 ) ; else ret = ft_itoa_base ( va_arg ( * args , unsigned int ) , 16 ) ; if ( flag_letter == 'x' ) ret = ft_strtolower ( ret ) ; } else if ( flag_letter == 'o' || flag_letter == 'O' ) { if ( ! ft_strcmp ( length_flag , "l" ) || flag_letter == 'O' ) ret = ft_uintmaxtoa_base ( va_arg ( * args , unsigned long ) , 8 ) ; else if ( ! ft_strcmp ( length_flag , "hh" ) ) ret = ft_itoa_base ( ( unsigned char ) va_arg ( * args , int ) , 8 ) ; else if ( ! ft_strcmp ( length_flag , "h" ) ) ret = ft_itoa_base ( ( unsigned short ) va_arg ( * args , int ) , 8 ) ; else if ( ! ft_strcmp ( length_flag , "ll" ) ) ret = ft_uintmaxtoa_base ( va_arg ( * args , unsigned long long ) , 8 ) ; else if ( ! ft_strcmp ( length_flag , "j" ) ) ret = ft_uintmaxtoa_base ( va_arg ( * args , uintmax_t ) , 8 ) ; else if ( ! ft_strcmp ( length_flag , "z" ) ) ret = ft_uintmaxtoa_base ( va_arg ( * args , unsigned long long ) , 8 ) ; else ret = ft_itoa_base ( va_arg ( * args , unsigned int ) , 8 ) ; } else if ( flag_letter == 'u' || flag_letter == 'U' ) { if ( ! ft_strcmp ( length_flag , "l" ) || flag_letter == 'U' ) ret = ft_uintmaxtoa ( va_arg ( * args , unsigned long ) ) ; else if ( ! ft_strcmp ( length_flag , "hh" ) ) ret = ft_itoa ( ( unsigned char ) va_arg ( * args , int ) ) ; else if ( ! ft_strcmp ( length_flag , "h" ) ) ret = ft_itoa ( ( unsigned short ) va_arg ( * args , int ) ) ; else if ( ! ft_strcmp ( length_flag , "ll" ) ) ret = ft_uintmaxtoa ( va_arg ( * args , unsigned long long ) ) ; else if ( ! ft_strcmp ( length_flag , "j" ) ) ret = ft_uintmaxtoa ( va_arg ( * args , uintmax_t ) ) ; else if ( ! ft_strcmp ( length_flag , "z" ) ) ret = ft_uintmaxtoa ( va_arg ( * args , unsigned long long ) ) ; else ret = ft_intmaxtoa ( va_arg ( * args , unsigned int ) ) ; } else if ( flag_letter == 's' ) { if ( ! ft_strcmp ( length_flag , "l" ) ) { flag = replacestr ( flag , "s" , "S" ) ; return ( handle_other_flags ( flag , args ) ) ; } else ret = va_arg ( * args , char * ) ; } else if ( flag_letter == 'c' ) { if ( ! ft_strcmp ( length_flag , "l" ) ) { flag = replacestr ( flag , "c" , "C" ) ; return ( handle_other_flags ( flag , args ) ) ; } else ret = ft_ctos ( va_arg ( * args , int ) ) ; } else ret = handle_other_flags ( flag , args ) ; return ( ret ) ; }
|
<S2SV_ModStart> ] == '%' && flag [ 1 ]
|
1,028
|
CWE-000 static int mmap_register ( void ) { <S2SV_StartBug> mca_sshmem_mmap_component . priority = 20 ; <S2SV_EndBug> mca_base_component_var_register ( & mca_sshmem_mmap_component . super . base_version , "priority" , "Priority<S2SV_blank>for<S2SV_blank>sshmem<S2SV_blank>mmap<S2SV_blank>" <S2SV_StartBug> "component<S2SV_blank>(default:<S2SV_blank>20)" , MCA_BASE_VAR_TYPE_INT , <S2SV_EndBug> NULL , 0 , MCA_BASE_VAR_FLAG_SETTABLE , OPAL_INFO_LVL_3 , MCA_BASE_VAR_SCOPE_ALL_EQ , & mca_sshmem_mmap_component . priority ) ; mca_sshmem_mmap_component . is_anonymous = 1 ; mca_base_component_var_register ( & mca_sshmem_mmap_component . super . base_version , "anonymous" , "Select<S2SV_blank>whether<S2SV_blank>anonymous<S2SV_blank>sshmem<S2SV_blank>is<S2SV_blank>used<S2SV_blank>for<S2SV_blank>mmap<S2SV_blank>" "component<S2SV_blank>(default:<S2SV_blank>1)" , MCA_BASE_VAR_TYPE_INT , NULL , 0 , MCA_BASE_VAR_FLAG_SETTABLE , OPAL_INFO_LVL_4 , MCA_BASE_VAR_SCOPE_ALL_EQ , & mca_sshmem_mmap_component . is_anonymous ) ; mca_sshmem_mmap_component . is_start_addr_fixed = 1 ; mca_base_component_var_register ( & mca_sshmem_mmap_component . super . base_version , "fixed" , "Select<S2SV_blank>whether<S2SV_blank>fixed<S2SV_blank>start<S2SV_blank>address<S2SV_blank>is<S2SV_blank>used<S2SV_blank>for<S2SV_blank>shmem<S2SV_blank>" "(default:<S2SV_blank>1)" , MCA_BASE_VAR_TYPE_INT , NULL , 0 , MCA_BASE_VAR_FLAG_SETTABLE , OPAL_INFO_LVL_4 , MCA_BASE_VAR_SCOPE_ALL_EQ , & mca_sshmem_mmap_component . is_start_addr_fixed ) ; return OSHMEM_SUCCESS ; }
|
<S2SV_ModStart> . priority = 40 <S2SV_ModEnd> ; mca_base_component_var_register ( <S2SV_ModStart> "priority" , "Priority<S2SV_blank>for<S2SV_blank>sshmem<S2SV_blank>mmap<S2SV_blank>" "component<S2SV_blank>(default:<S2SV_blank>40)" <S2SV_ModEnd> , MCA_BASE_VAR_TYPE_INT ,
|
1,029
|
CWE-000 float extract_n_CA ( c_queue * a , int idx ) { <S2SV_StartBug> float elem ; <S2SV_EndBug> sem_wait ( & a -> mtx ) ; elem = a -> array [ idx ] ; sem_post ( & a -> mtx ) ; return elem ; }
|
<S2SV_ModStart> { float elem = 0
|
1,030
|
CWE-000 static int32_t trusty_std_call32 ( struct trusty_dev * dev , uint32_t smcnr , uint32_t a0 , uint32_t a1 , uint32_t a2 ) { int ret ; trusty_assert ( dev ) ; trusty_assert ( ! SMC_IS_FASTCALL ( smcnr ) ) ; if ( smcnr != SMC_SC_NOP ) { trusty_lock ( dev ) ; } <S2SV_StartBug> trusty_debug ( "%s(0x%x<S2SV_blank>0x%x<S2SV_blank>0x%x<S2SV_blank>0x%x)<S2SV_blank>started\\n" , __func__ , <S2SV_EndBug> smcnr , a0 , a1 , a2 ) ; ret = trusty_std_call_helper ( dev , smcnr , a0 , a1 , a2 ) ; while ( ret == SM_ERR_INTERRUPTED || ret == SM_ERR_CPU_IDLE ) { <S2SV_StartBug> trusty_debug ( "%s(0x%x<S2SV_blank>0x%x<S2SV_blank>0x%x<S2SV_blank>0x%x)<S2SV_blank>interrupted\\n" , __func__ , <S2SV_EndBug> smcnr , a0 , a1 , a2 ) ; if ( ret == SM_ERR_CPU_IDLE ) { trusty_idle ( dev ) ; } ret = trusty_std_call_helper ( dev , SMC_SC_RESTART_LAST , 0 , 0 , 0 ) ; } <S2SV_StartBug> trusty_debug ( "%s(0x%x<S2SV_blank>0x%x<S2SV_blank>0x%x<S2SV_blank>0x%x)<S2SV_blank>returned<S2SV_blank>0x%x\\n" , <S2SV_EndBug> __func__ , smcnr , a0 , a1 , a2 , ret ) ; if ( smcnr != SMC_SC_NOP ) { trusty_unlock ( dev ) ; } return ret ; }
|
<S2SV_ModStart> } trusty_debug ( "%a(0x%x<S2SV_blank>0x%x<S2SV_blank>0x%x<S2SV_blank>0x%x)<S2SV_blank>started\\n" <S2SV_ModEnd> , __func__ , <S2SV_ModStart> { trusty_debug ( "%a(0x%x<S2SV_blank>0x%x<S2SV_blank>0x%x<S2SV_blank>0x%x)<S2SV_blank>interrupted\\n" <S2SV_ModEnd> , __func__ , <S2SV_ModStart> } trusty_debug ( "%a(0x%x<S2SV_blank>0x%x<S2SV_blank>0x%x<S2SV_blank>0x%x)<S2SV_blank>returned<S2SV_blank>0x%x\\n" <S2SV_ModEnd> , __func__ ,
|
1,031
|
CWE-000 static ssize_t opal_nvram_write ( char * buf , size_t count , loff_t * index ) { s64 rc = OPAL_BUSY ; int off ; if ( * index >= nvram_size ) return 0 ; off = * index ; if ( ( off + count ) > nvram_size ) count = nvram_size - off ; while ( rc == OPAL_BUSY || rc == OPAL_BUSY_EVENT ) { rc = opal_write_nvram ( __pa ( buf ) , count , off ) ; if ( rc == OPAL_BUSY_EVENT ) { <S2SV_StartBug> msleep ( OPAL_BUSY_DELAY_MS ) ; <S2SV_EndBug> opal_poll_events ( NULL ) ; <S2SV_StartBug> } else if ( rc == OPAL_BUSY ) { <S2SV_EndBug> msleep ( OPAL_BUSY_DELAY_MS ) ; } } if ( rc ) return - EIO ; * index += count ; return count ; }
|
<S2SV_ModStart> OPAL_BUSY_EVENT ) { if ( in_interrupt ( ) || irqs_disabled ( ) ) mdelay ( OPAL_BUSY_DELAY_MS ) ; else <S2SV_ModStart> OPAL_BUSY ) { if ( in_interrupt ( ) || irqs_disabled ( ) ) mdelay ( OPAL_BUSY_DELAY_MS ) ; else
|
1,032
|
CWE-000 void testSubop ( unsigned int subop , unsigned long line ) { if ( subop > 2 ) { <S2SV_StartBug> printf ( "SYNTAX<S2SV_blank>ERROR:<S2SV_blank>Invalid<S2SV_blank>Subop,<S2SV_blank>instruction<S2SV_blank>%d\\n" , line ) ; <S2SV_EndBug> exit ( 1 ) ; } }
|
<S2SV_ModStart> { printf ( "SYNTAX<S2SV_blank>ERROR:<S2SV_blank>Invalid<S2SV_blank>Subop,<S2SV_blank>instruction<S2SV_blank>%lu\\n" <S2SV_ModEnd> , line )
|
1,033
|
CWE-000 static int entry_retrieve ( const char * path , void * * buf , size_t * * count ) { int status ; struct stat sb ; printf ( "entry_retrieve(%s)\\n" , path ) ; status = stat ( path , & sb ) ; if ( status == - 1 ) { perror ( "stat" ) ; return - 1 ; } int fd = open ( path , O_RDONLY | S_IWUSR | S_IRUSR | S_IWGRP | S_IRGRP | S_IROTH ) ; * count = malloc ( sizeof ( size_t ) ) ; <S2SV_StartBug> * buf ; <S2SV_EndBug> if ( fd != - 1 ) { * buf = ( void * ) malloc ( sb . st_size + 1 ) ; char * cbuf = ( char * ) buf ; cbuf [ sb . st_size ] = 0 ; read ( fd , * buf , sb . st_size ) ; close ( fd ) ; } printf ( "Entry<S2SV_blank>content:<S2SV_blank>%s\\n" , ( char * ) * buf ) ; return 0 ; }
|
<S2SV_ModStart> ) ; * * count = sb . st_size ; *
|
1,034
|
CWE-000 void cond_compute_av ( struct avtab * ctab , struct avtab_key * key , struct av_decision * avd , struct extended_perms * xperms ) { struct avtab_node * node ; if ( IS_ERR_OR_NULL ( ctab ) || IS_ERR_OR_NULL ( key ) || <S2SV_StartBug> IS_ERR_OR_NULL ( avd ) || IS_ERR_OR_NULL ( xperms ) ) <S2SV_EndBug> return ; # define is_specified ( nkey ) ( ( node -> key . specified & ( nkey | AVTAB_ENABLED ) ) == ( u16 ) ( nkey | AVTAB_ENABLED ) ) for ( node = avtab_search_node ( ctab , key ) ; node != NULL ; node = avtab_search_node_next ( node , key -> specified ) ) { if ( is_specified ( AVTAB_ALLOWED ) ) avd -> allowed |= node -> datum . u . data ; if ( is_specified ( AVTAB_AUDITDENY ) ) avd -> auditdeny &= node -> datum . u . data ; if ( is_specified ( AVTAB_AUDITALLOW ) ) avd -> auditallow |= node -> datum . u . data ; <S2SV_StartBug> if ( is_specified ( AVTAB_XPERMS ) ) <S2SV_EndBug> services_compute_xperms_drivers ( xperms , node ) ; } }
|
<S2SV_ModStart> IS_ERR_OR_NULL ( avd <S2SV_ModEnd> ) ) return <S2SV_ModStart> ; if ( xperms &&
|
1,035
|
CWE-000 static inline void crypto_destroy_session ( struct csession * ses_ptr ) { if ( ! mutex_trylock ( & ses_ptr -> sem ) ) { ddebug ( 2 , "Waiting<S2SV_blank>for<S2SV_blank>semaphore<S2SV_blank>of<S2SV_blank>sid=0x%08X" , ses_ptr -> sid ) ; mutex_lock ( & ses_ptr -> sem ) ; } ddebug ( 2 , "Removed<S2SV_blank>session<S2SV_blank>0x%08X" , ses_ptr -> sid ) ; cryptodev_cipher_deinit ( & ses_ptr -> cdata ) ; cryptodev_hash_deinit ( & ses_ptr -> hdata ) ; <S2SV_StartBug> cryptodev_compr_deinit ( & ses_new -> comprdata ) ; <S2SV_EndBug> ddebug ( 2 , "freeing<S2SV_blank>space<S2SV_blank>for<S2SV_blank>%d<S2SV_blank>user<S2SV_blank>pages" , ses_ptr -> array_size ) ; kfree ( ses_ptr -> pages ) ; kfree ( ses_ptr -> sg ) ; mutex_unlock ( & ses_ptr -> sem ) ; mutex_destroy ( & ses_ptr -> sem ) ; kfree ( ses_ptr ) ; }
|
<S2SV_ModStart> cryptodev_compr_deinit ( & ses_ptr <S2SV_ModEnd> -> comprdata )
|
1,036
|
CWE-000 static int qeth_setup_channel ( struct qeth_channel * channel ) { int cnt ; QETH_DBF_TEXT ( SETUP , 2 , "setupch" ) ; for ( cnt = 0 ; cnt < QETH_CMD_BUFFER_NO ; cnt ++ ) { channel -> iob [ cnt ] . data = kzalloc ( QETH_BUFSIZE , GFP_DMA | GFP_KERNEL ) ; if ( channel -> iob [ cnt ] . data == NULL ) break ; channel -> iob [ cnt ] . state = BUF_STATE_FREE ; channel -> iob [ cnt ] . channel = channel ; channel -> iob [ cnt ] . callback = qeth_send_control_data_cb ; channel -> iob [ cnt ] . rc = 0 ; } if ( cnt < QETH_CMD_BUFFER_NO ) { while ( cnt -- > 0 ) kfree ( channel -> iob [ cnt ] . data ) ; return - ENOMEM ; } <S2SV_StartBug> channel -> buf_no = 0 ; <S2SV_EndBug> channel -> io_buf_no = 0 ; atomic_set ( & channel -> irq_pending , 0 ) ; spin_lock_init ( & channel -> iob_lock ) ; init_waitqueue_head ( & channel -> wait_q ) ; return 0 ; }
|
<S2SV_ModStart> } channel -> <S2SV_ModEnd> io_buf_no = 0
|
1,037
|
CWE-000 int sock_domain ( struct fid_fabric * fabric , struct fi_info * info , struct fid_domain * * dom , void * context ) { struct sock_domain * sock_domain ; struct sock_fabric * fab ; int ret ; fab = container_of ( fabric , struct sock_fabric , fab_fid ) ; if ( info && info -> domain_attr ) { ret = sock_verify_domain_attr ( fabric -> api_version , info ) ; if ( ret ) return - FI_EINVAL ; } sock_domain = calloc ( 1 , sizeof ( * sock_domain ) ) ; if ( ! sock_domain ) return - FI_ENOMEM ; fastlock_init ( & sock_domain -> lock ) ; ofi_atomic_initialize32 ( & sock_domain -> ref , 0 ) ; if ( info ) { sock_domain -> info = * info ; } else { SOCK_LOG_ERROR ( "invalid<S2SV_blank>fi_info\\n" ) ; goto err1 ; } sock_domain -> dom_fid . fid . fclass = FI_CLASS_DOMAIN ; sock_domain -> dom_fid . fid . context = context ; sock_domain -> dom_fid . fid . ops = & sock_dom_fi_ops ; sock_domain -> dom_fid . ops = & sock_dom_ops ; sock_domain -> dom_fid . mr = & sock_dom_mr_ops ; if ( ! info -> domain_attr || info -> domain_attr -> data_progress == FI_PROGRESS_UNSPEC ) sock_domain -> progress_mode = FI_PROGRESS_AUTO ; else sock_domain -> progress_mode = info -> domain_attr -> data_progress ; sock_domain -> pe = sock_pe_init ( sock_domain ) ; if ( ! sock_domain -> pe ) { SOCK_LOG_ERROR ( "Failed<S2SV_blank>to<S2SV_blank>init<S2SV_blank>PE\\n" ) ; goto err1 ; } sock_domain -> fab = fab ; * dom = & sock_domain -> dom_fid ; if ( info -> domain_attr ) sock_domain -> attr = * ( info -> domain_attr ) ; else sock_domain -> attr = sock_domain_attr ; ret = ofi_mr_map_init ( & sock_prov , sock_domain -> attr . mr_mode , & sock_domain -> mr_map ) ; if ( ret ) goto err2 ; <S2SV_StartBug> sock_dom_add_to_list ( sock_domain ) ; <S2SV_EndBug> return 0 ; err2 : sock_pe_finalize ( sock_domain -> pe ) ; err1 : fastlock_destroy ( & sock_domain -> lock ) ; free ( sock_domain ) ; return - FI_EINVAL ; }
|
<S2SV_ModStart> goto err2 ; ret = sock_conn_start_listener_thread ( & sock_domain -> conn_listener ) ; if ( ret ) goto err2 ;
|
1,038
|
CWE-000 int SPDeleteRecord ( RedisModuleCtx * ctx , SPNamespace * ns , const char * id ) { SPRecordSet * rs = ns -> rs ; SPUpReadLock ( rs -> lock ) ; khint_t k ; SPRecordId rid ; SPRecord * rec ; int res = 0 ; k = kh_get ( MSTDOC , rs -> docs , id ) ; if ( k != kh_end ( rs -> docs ) ) { rid = kh_value ( rs -> docs , k ) ; rec = rid . record ; if ( rec -> exists ) { res = 1 ; SPUpgradeLock ( rs -> lock ) ; <S2SV_StartBug> SPWriteLock ( rs -> lzwLock ) ; <S2SV_EndBug> SPReleasePackCont ( ctx , rs , rid ) ; <S2SV_StartBug> SPWriteUnlock ( rs -> lzwLock ) ; <S2SV_EndBug> SPWriteLock ( rs -> deleteLock ) ; if ( rid . record -> rawDoc . unpacked ) { RedisModule_Free ( rid . record -> rawDoc . unpacked ) ; rid . record -> rawDoc . unpacked = NULL ; } rid . record -> rawDoc . oSize = 0 ; rid . record -> pc = NULL ; rec -> exists = 0 ; kh_del ( MSTDOC , rs -> docs , k ) ; SPWriteUnlockRP ( rs -> lock ) ; SPDoUnIndexFields ( ns , rid , rid . record -> fields ) ; RedisModule_Free ( rid . record -> fields ) ; rid . record -> fields = NULL ; SPDeletedRecord dr = { . rid = rid , . date = RedisModule_Milliseconds ( ) } ; kv_push ( SPDeletedRecord , rs -> deleted , dr ) ; SPWriteUnlock ( rs -> deleteLock ) ; } } SPWriteUnlockRP ( rs -> lock ) ; return res ; }
|
<S2SV_ModStart> ( rs -> deleteLock ) ; SPWriteLock ( rs -> <S2SV_ModStart> rs -> lzwLock <S2SV_ModEnd> ) ; if
|
1,039
|
CWE-000 static void fallback_to_root_output ( void ) { root_output -> active = true ; output_init_con ( root_output ) ; <S2SV_StartBug> init_ws_for_output ( root_output , output_get_content ( root_output -> con ) ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> init_ws_for_output ( root_output <S2SV_ModEnd> ) ; }
|
1,040
|
CWE-000 static void ripemd160 ( uint8_t digest [ ] , const void * data , size_t data_size ) { uint32_t state [ 5 ] = { 0x67452301UL , 0xefcdab89UL , 0x98badcfeUL , 0x10325476UL , 0xc3d2e1f0UL } ; size_t data_rem = data_size ; while ( data_rem >= 64 ) { _ripemd160_update ( state , data ) ; data = ( uint8_t * ) data + 64 , data_rem -= 64 ; } union { uint8_t b [ 64 ] ; uint32_t l [ 16 ] ; } block ; memcpy ( block . b , data , data_rem ) ; block . b [ data_rem ++ ] = 0x80 ; if ( data_rem > sizeof block - sizeof ( uint64_t ) ) { memset ( block . b + data_rem , 0 , sizeof block - data_rem ) ; _ripemd160_update ( state , block . b ) ; data_rem = 0 ; } memset ( block . b + data_rem , 0 , sizeof block - sizeof ( uint64_t ) - data_rem ) ; block . l [ 14 ] = bswap32 ( data_size << 3 ) ; block . l [ 15 ] = 0 ; _ripemd160_update ( state , block . b ) ; <S2SV_StartBug> for ( size_t i = 0 ; i < 5 ; ++ i ) { <S2SV_EndBug> state [ i ] = bswap32 ( state [ i ] ) ; } memcpy ( digest , state , sizeof state ) ; }
|
<S2SV_ModStart> b ) ; size_t i ; for ( <S2SV_ModEnd> i = 0
|
1,041
|
CWE-000 static void clnt_dg_destroy ( CLIENT * clnt ) { <S2SV_StartBug> struct rpc_dplx_rec * rec = ( struct rpc_dplx_rec * ) clnt -> cl_p2 ; <S2SV_EndBug> struct cx_data * cx = CX_DATA ( clnt ) ; struct cu_data * cu = CU_DATA ( cx ) ; <S2SV_StartBug> sigset_t mask , newmask ; <S2SV_EndBug> sigfillset ( & newmask ) ; thr_sigsetmask ( SIG_SETMASK , & newmask , & mask ) ; rpc_dplx_swc ( clnt , rpc_flag_clear ) ; rpc_dplx_rwc ( clnt , rpc_flag_clear ) ; XDR_DESTROY ( & cu -> cu_outxdrs ) ; <S2SV_StartBug> rpc_dplx_ssc ( clnt , RPC_DPLX_FLAG_NONE ) ; <S2SV_EndBug> rpc_dplx_rsc ( clnt , RPC_DPLX_FLAG_NONE ) ; rpc_dplx_unref ( rec , RPC_DPLX_FLAG_NONE ) ; free_cx_data ( cx ) ; <S2SV_StartBug> SVC_RELEASE ( & cx -> cx_rec -> xprt , SVC_RELEASE_FLAG_NONE ) ; <S2SV_EndBug> thr_sigsetmask ( SIG_SETMASK , & mask , NULL ) ; }
|
<S2SV_ModStart> clnt ) { <S2SV_ModEnd> struct cx_data * <S2SV_ModStart> cx ) ; struct rpc_dplx_rec * rec = cx -> cx_rec <S2SV_ModEnd> ; XDR_DESTROY ( <S2SV_ModStart> cu_outxdrs ) ; SVC_RELEASE ( & rec -> xprt , SVC_RELEASE_FLAG_NONE <S2SV_ModEnd> ) ; free_cx_data <S2SV_ModStart> cx ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null>
|
1,042
|
CWE-000 static int msm_csiphy_release ( struct csiphy_device * csiphy_dev , void * arg ) { int i = 0 ; struct msm_camera_csi_lane_params * csi_lane_params ; uint16_t csi_lane_mask ; csi_lane_params = ( struct msm_camera_csi_lane_params * ) arg ; if ( ! csiphy_dev || ! csiphy_dev -> ref_count ) { pr_err ( "%s<S2SV_blank>csiphy<S2SV_blank>dev<S2SV_blank>NULL<S2SV_blank>/<S2SV_blank>ref_count<S2SV_blank>ZERO\\n" , __func__ ) ; return 0 ; } if ( csiphy_dev -> csiphy_state != CSIPHY_POWER_UP ) { pr_err ( "%s:<S2SV_blank>csiphy<S2SV_blank>invalid<S2SV_blank>state<S2SV_blank>%d\\n" , __func__ , csiphy_dev -> csiphy_state ) ; return - EINVAL ; } if ( csiphy_dev -> hw_version < CSIPHY_VERSION_V30 ) { csiphy_dev -> lane_mask [ csiphy_dev -> pdev -> id ] = 0 ; for ( i = 0 ; i < 4 ; i ++ ) msm_camera_io_w ( 0x0 , csiphy_dev -> base + csiphy_dev -> ctrl_reg -> csiphy_reg . mipi_csiphy_lnn_cfg2_addr + 0x40 * i ) ; } else { if ( ! csi_lane_params ) { <S2SV_StartBug> pr_err ( "%s:%d<S2SV_blank>failed:<S2SV_blank>csi_lane_params<S2SV_blank>%p\\n" , __func__ , <S2SV_EndBug> __LINE__ , csi_lane_params ) ; return - EINVAL ; } csi_lane_mask = ( csi_lane_params -> csi_lane_mask & 0x1F ) ; CDBG ( "%s<S2SV_blank>csiphy_params,<S2SV_blank>lane<S2SV_blank>assign<S2SV_blank>0x%x<S2SV_blank>mask<S2SV_blank>=<S2SV_blank>0x%x\\n" , __func__ , csi_lane_params -> csi_lane_assign , csi_lane_params -> csi_lane_mask ) ; if ( ! csi_lane_mask ) csi_lane_mask = 0x1f ; csiphy_dev -> lane_mask [ csiphy_dev -> pdev -> id ] &= ~ ( csi_lane_mask ) ; i = 0 ; while ( csi_lane_mask ) { if ( csi_lane_mask & 0x1 ) { msm_camera_io_w ( 0x0 , csiphy_dev -> base + csiphy_dev -> ctrl_reg -> csiphy_reg . mipi_csiphy_lnn_cfg2_addr + 0x40 * i ) ; } csi_lane_mask >>= 1 ; i ++ ; } } if ( -- csiphy_dev -> ref_count ) { CDBG ( "%s<S2SV_blank>csiphy<S2SV_blank>refcount<S2SV_blank>=<S2SV_blank>%d\\n" , __func__ , csiphy_dev -> ref_count ) ; return 0 ; } msm_camera_io_w ( 0x0 , csiphy_dev -> base + csiphy_dev -> ctrl_reg -> csiphy_reg . mipi_csiphy_lnck_cfg2_addr ) ; msm_camera_io_w ( 0x0 , csiphy_dev -> base + csiphy_dev -> ctrl_reg -> csiphy_reg . mipi_csiphy_glbl_pwr_cfg_addr ) ; if ( csiphy_dev -> hw_dts_version <= CSIPHY_VERSION_V22 ) { msm_cam_clk_enable ( & csiphy_dev -> pdev -> dev , csiphy_clk_info , csiphy_dev -> csiphy_clk , csiphy_dev -> num_clk , 0 ) ; } else if ( csiphy_dev -> hw_dts_version >= CSIPHY_VERSION_V30 ) { msm_cam_clk_enable ( & csiphy_dev -> pdev -> dev , csiphy_clk_info , csiphy_dev -> csiphy_clk , csiphy_dev -> num_clk , 0 ) ; iounmap ( csiphy_dev -> clk_mux_base ) ; } iounmap ( csiphy_dev -> base ) ; csiphy_dev -> base = NULL ; csiphy_dev -> csiphy_state = CSIPHY_POWER_DOWN ; return 0 ; }
|
<S2SV_ModStart> { pr_err ( "%s:%d<S2SV_blank>failed:<S2SV_blank>csi_lane_params<S2SV_blank>%pK\\n" <S2SV_ModEnd> , __func__ ,
|
1,043
|
CWE-000 static const struct apsd_result * smblib_update_usb_type ( struct smb_charger * chg ) { const struct apsd_result * apsd_result = smblib_get_apsd_result ( chg ) ; if ( chg -> pd_active ) { chg -> real_charger_type = POWER_SUPPLY_TYPE_USB_PD ; } else { if ( ! ( apsd_result -> pst == POWER_SUPPLY_TYPE_USB_FLOAT && chg -> real_charger_type == POWER_SUPPLY_TYPE_USB ) ) chg -> real_charger_type = apsd_result -> pst ; } <S2SV_StartBug> smblib_dbg ( chg , PR_MISC , "APSD=%s<S2SV_blank>PD=%d\\n" , <S2SV_EndBug> apsd_result -> name , chg -> pd_active ) ; return apsd_result ; }
|
<S2SV_ModStart> pst ; } chg -> usb_psy_desc . type = chg -> real_charger_type ;
|
1,044
|
CWE-000 static int assign_ ( int op , char * state , int event , char * * next_state , _context * context ) { if ( ! command_mode ( 0 , 0 , ExecutionMode ) ) return 0 ; AssignmentMode mode = context -> assignment . mode ; switch ( op ) { case ResetAll : resetVariables ( context ) ; break ; case Reset : resetVariable ( NULL , context ) ; break ; <S2SV_StartBug> case AssignToExpression : <S2SV_EndBug> ; Expression * e = context -> expression . ptr ; context -> expression . ptr = NULL ; if ( ( e ) && e -> sub [ 1 ] . result . none && e -> sub [ 3 ] . result . none && <S2SV_StartBug> ( e -> sub [ 0 ] . e == NULL ) && ! flagged ( e , 0 ) ) <S2SV_EndBug> { ValueType type = e -> sub [ 0 ] . result . identifier . type ; listItem * value = e -> sub [ 0 ] . result . identifier . value ; switch ( type ) { case DefaultIdentifier : case NullIdentifier : case VariableIdentifier : assign_variable ( mode , NULL , e , ExpressionValue , context ) ; break ; case ExpressionCollect : if ( value -> next == NULL ) { assign_variable ( mode , NULL , value -> ptr , ExpressionValue , context ) ; freeListItem ( & value ) ; break ; } default : assign_variable ( mode , NULL , value , type , context ) ; e -> sub [ 0 ] . result . identifier . value = NULL ; freeExpression ( e ) ; } } else assign_variable ( mode , NULL , e , ExpressionValue , context ) ; break ; <S2SV_StartBug> case AssignToExpressionResults : <S2SV_EndBug> ; ValueType type = ( context -> expression . mode == ReadMode ) ? LiteralResults : EntityResults ; assign_variable ( mode , NULL , context -> expression . results , type , context ) ; context -> expression . results = NULL ; break ; <S2SV_StartBug> case AssignToValueAccount : <S2SV_EndBug> if ( strcmp ( get_identifier ( context , 2 ) , "literal" ) ) return output ( Error , "currently<S2SV_blank>only<S2SV_blank>\'literal\'<S2SV_blank>values<S2SV_blank>can<S2SV_blank>be<S2SV_blank>assigned<S2SV_blank>to<S2SV_blank>variables" ) ; <S2SV_StartBug> case AssignToLiteralValue : <S2SV_EndBug> if ( ( context -> expression . results ) && ( context -> expression . mode != ReadMode ) ) E2L ( & context -> expression . results , NULL , context ) ; assign_variable ( mode , NULL , context -> expression . results , LiteralResults , context ) ; context -> expression . results = NULL ; break ; <S2SV_StartBug> case AssignToNarrative : <S2SV_EndBug> ; Registry * registry = NULL ; if ( test_identifier ( context , 1 ) && ( context -> expression . results ) ) { if ( context -> expression . mode == ReadMode ) L2E ( & context -> expression . results , NULL , context ) ; char * narrative = get_identifier ( context , 1 ) ; registry = newRegistry ( IndexedByAddress ) ; for ( listItem * i = context -> expression . results ; i != NULL ; i = i -> next ) { Entity * e = ( Entity * ) i -> ptr ; Narrative * n = lookupNarrative ( e , narrative ) ; if ( n != NULL ) registryRegister ( registry , e , n -> name ) ; } if ( registry -> value == NULL ) freeRegistry ( & registry ) ; } assign_variable ( mode , NULL , registry , NarrativeIdentifiers , context ) ; break ; } context -> assignment . mode = 0 ; return 0 ; }
|
<S2SV_ModStart> break ; case AssignExpression <S2SV_ModEnd> : ; Expression <S2SV_ModStart> , 0 ) && ! ( e -> result . mark & 7 ) && ! e -> result . as_sub && ! e -> result . as_sup <S2SV_ModStart> break ; case AssignExpressionResults <S2SV_ModEnd> : ; ValueType <S2SV_ModStart> break ; case AssignValueAccount <S2SV_ModEnd> : if ( <S2SV_ModStart> ) ; case AssignLiteralValue <S2SV_ModEnd> : if ( <S2SV_ModStart> break ; case AssignNarrative <S2SV_ModEnd> : ; Registry
|
1,045
|
CWE-000 TYPE_DESC function_type ( TYPE_DESC tp ) { TYPE_DESC ftp ; ftp = new_type_desc ( ) ; TYPE_BASIC_TYPE ( ftp ) = TYPE_FUNCTION ; FUNCTION_TYPE_RETURN_TYPE ( ftp ) = tp ; if ( tp != NULL ) { if ( TYPE_IS_EXTERNAL ( tp ) ) { TYPE_SET_EXTERNAL ( ftp ) ; TYPE_UNSET_EXTERNAL ( tp ) ; } if ( TYPE_IS_USED_EXPLICIT ( tp ) ) { TYPE_SET_USED_EXPLICIT ( ftp ) ; TYPE_UNSET_USED_EXPLICIT ( tp ) ; } if ( TYPE_IS_OVERRIDDEN ( tp ) ) { TYPE_SET_OVERRIDDEN ( ftp ) ; TYPE_UNSET_OVERRIDDEN ( tp ) ; } if ( TYPE_IS_PUBLIC ( tp ) ) { TYPE_SET_PUBLIC ( ftp ) ; TYPE_UNSET_PUBLIC ( tp ) ; } if ( TYPE_IS_PRIVATE ( tp ) ) { TYPE_SET_PRIVATE ( ftp ) ; TYPE_UNSET_PRIVATE ( tp ) ; } if ( TYPE_IS_PROTECTED ( tp ) ) { TYPE_SET_PROTECTED ( ftp ) ; TYPE_UNSET_PROTECTED ( tp ) ; } if ( TYPE_IS_RECURSIVE ( tp ) ) { TYPE_SET_RECURSIVE ( ftp ) ; TYPE_UNSET_RECURSIVE ( tp ) ; } if ( TYPE_IS_PURE ( tp ) ) { TYPE_SET_PURE ( ftp ) ; TYPE_UNSET_PURE ( tp ) ; } if ( TYPE_IS_ELEMENTAL ( tp ) ) { TYPE_SET_ELEMENTAL ( ftp ) ; TYPE_UNSET_ELEMENTAL ( tp ) ; } if ( TYPE_IS_MODULE ( tp ) ) { TYPE_SET_MODULE ( ftp ) ; TYPE_UNSET_MODULE ( tp ) ; } TYPE_UNSET_SAVE ( tp ) ; <S2SV_StartBug> } <S2SV_EndBug> return ftp ; }
|
<S2SV_ModStart> tp ) ; if ( FUNCTION_TYPE_IS_VISIBLE_INTRINSIC ( tp ) ) { FUNCTION_TYPE_SET_VISIBLE_INTRINSIC ( ftp ) ; } FUNCTION_TYPE_UNSET_VISIBLE_INTRINSIC ( tp ) ;
|
1,046
|
CWE-000 static dictEntry * dictGenericDelete ( dict * d , const void * key , int nofree ) { <S2SV_StartBug> unsigned int h , idx ; <S2SV_EndBug> dictEntry * he , * prevHe ; int table ; if ( d -> ht [ 0 ] . used == 0 && d -> ht [ 1 ] . used == 0 ) return NULL ; if ( dictIsRehashing ( d ) ) _dictRehashStep ( d ) ; h = dictHashKey ( d , key ) ; for ( table = 0 ; table <= 1 ; table ++ ) { idx = h & d -> ht [ table ] . sizemask ; he = d -> ht [ table ] . table [ idx ] ; prevHe = NULL ; while ( he ) { if ( key == he -> key || dictCompareKeys ( d , key , he -> key ) ) { if ( prevHe ) prevHe -> next = he -> next ; else d -> ht [ table ] . table [ idx ] = he -> next ; if ( ! nofree ) { dictFreeKey ( d , he ) ; dictFreeVal ( d , he ) ; zfree ( he ) ; } d -> ht [ table ] . used -- ; return he ; } prevHe = he ; he = he -> next ; } if ( ! dictIsRehashing ( d ) ) break ; } return NULL ; }
|
<S2SV_ModStart> nofree ) { uint64_t <S2SV_ModEnd> h , idx
|
1,047
|
CWE-000 static void * _memory_allocate_from_heap_core ( heap_t * heap , size_t size ) { const size_t base_idx = ( size <= SMALL_SIZE_LIMIT ) ? ( ( size + ( SMALL_GRANULARITY - 1 ) ) >> SMALL_GRANULARITY_SHIFT ) : SMALL_CLASS_COUNT + ( ( size - SMALL_SIZE_LIMIT + ( MEDIUM_GRANULARITY - 1 ) ) >> MEDIUM_GRANULARITY_SHIFT ) ; assert ( ! base_idx || ( ( base_idx - 1 ) < SIZE_CLASS_COUNT ) ) ; const size_t class_idx = _memory_size_class [ base_idx ? ( base_idx - 1 ) : 0 ] . class_idx ; span_block_t * active_block = heap -> active_block + class_idx ; size_class_t * size_class = _memory_size_class + class_idx ; const count_t class_size = size_class -> size ; use_active : if ( active_block -> free_count ) { span_t * span = heap -> active_span [ class_idx ] ; count_t offset = class_size * active_block -> free_list ; <S2SV_StartBug> uint32_t * block = pointer_offset ( span , SPAN_HEADER_SIZE + offset ) ; <S2SV_EndBug> assert ( span && ( atomic_load32 ( & span -> heap_id ) == heap -> id ) ) ; if ( active_block -> free_count == 1 ) { span -> data . block . free_count = active_block -> free_count = 0 ; span -> data . block . first_autolink = 0xFFFF ; heap -> active_span [ class_idx ] = 0 ; } else { ++ active_block -> free_list ; if ( active_block -> free_list <= active_block -> first_autolink ) active_block -> free_list = ( uint16_t ) ( * block ) ; assert ( active_block -> free_list < size_class -> block_count ) ; -- active_block -> free_count ; } return block ; } _memory_deallocate_deferred ( heap ) ; if ( heap -> size_cache [ class_idx ] ) { span_t * span = heap -> size_cache [ class_idx ] ; atomic_store32 ( & span -> heap_id , heap -> id ) ; atomic_thread_fence_release ( ) ; * active_block = span -> data . block ; assert ( active_block -> free_count > 0 ) ; heap -> size_cache [ class_idx ] = span -> next_span ; heap -> active_span [ class_idx ] = span ; goto use_active ; } span_t * span = _memory_heap_cache_extract ( heap , 1 ) ; if ( ! span ) { span = _memory_map_spans ( heap , 1 ) ; } assert ( span -> span_count == 1 ) ; span -> size_class = ( uint16_t ) class_idx ; atomic_store32 ( & span -> heap_id , heap -> id ) ; atomic_thread_fence_release ( ) ; if ( size_class -> block_count > 1 ) { active_block -> free_count = ( uint16_t ) ( size_class -> block_count - 1 ) ; active_block -> free_list = 1 ; active_block -> first_autolink = 1 ; heap -> active_span [ class_idx ] = span ; } else { span -> data . block . free_count = 0 ; span -> data . block . first_autolink = 0xFFFF ; } return pointer_offset ( span , SPAN_HEADER_SIZE ) ; }
|
<S2SV_ModStart> * block = ( uint32_t * )
|
1,048
|
CWE-000 ssize_t onebyte_read ( struct file * filep , char * buf , size_t count , loff_t * f_pos ) { <S2SV_StartBug> int bytes_read = 0 ; <S2SV_EndBug> if ( * onebyte_data == 0 ) return 0 ; <S2SV_StartBug> while ( count && * onebyte_data ) { <S2SV_EndBug> <S2SV_StartBug> put_user ( * ( onebyte_data ++ ) , buf ++ ) ; <S2SV_EndBug> count -- ; bytes_read ++ ; printk ( KERN_INFO "%s<S2SV_blank>\\n" , onebyte_data ) ; <S2SV_StartBug> return bytes_read ; <S2SV_EndBug> } return bytes_read ; }
|
<S2SV_ModStart> f_pos ) { char * toRead ; char c <S2SV_ModEnd> ; if ( <S2SV_ModStart> return 0 ; toRead = onebyte_data ; c = * toRead ; <S2SV_ModEnd> put_user ( * <S2SV_ModStart> put_user ( * onebyte_data , buf <S2SV_ModEnd> ) ; return <S2SV_ModStart> ) ; return 1 <S2SV_ModEnd> ; } <S2SV_null>
|
1,049
|
CWE-000 static PHP_METHOD ( Phalcon_Flash , getAutoescape ) { <S2SV_StartBug> zval * this_ptr = getThis ( ) ; <S2SV_EndBug> RETURN_MEMBER ( getThis ( ) , "_autoescape" ) ; }
|
<S2SV_ModStart> getAutoescape ) { <S2SV_ModEnd> RETURN_MEMBER ( getThis
|
1,050
|
CWE-000 static gboolean process_frame ( StackFrameInfo * info , MonoContext * ctx , gpointer user_data ) { ComputeFramesUserData * ud = ( ComputeFramesUserData * ) user_data ; StackFrame * frame ; MonoMethod * method , * actual_method , * api_method ; SeqPoint sp ; int flags = 0 ; mono_loader_lock ( ) ; if ( info -> type != FRAME_TYPE_MANAGED && info -> type != FRAME_TYPE_INTERP && info -> type != FRAME_TYPE_MANAGED_TO_NATIVE ) { if ( info -> type == FRAME_TYPE_DEBUGGER_INVOKE ) { <S2SV_StartBug> if ( ud -> frames ) <S2SV_EndBug> ( ( StackFrame * ) g_slist_last ( ud -> frames ) -> data ) -> flags |= FRAME_FLAG_DEBUGGER_INVOKE ; } mono_loader_unlock ( ) ; return FALSE ; } if ( info -> ji ) method = jinfo_get_method ( info -> ji ) ; else method = info -> method ; actual_method = info -> actual_method ; api_method = method ; if ( ! method ) { mono_loader_unlock ( ) ; return FALSE ; } if ( ! method || ( method -> wrapper_type && method -> wrapper_type != MONO_WRAPPER_DYNAMIC_METHOD && method -> wrapper_type != MONO_WRAPPER_MANAGED_TO_NATIVE ) ) { mono_loader_unlock ( ) ; return FALSE ; } if ( info -> il_offset == - 1 ) { if ( ud -> frames == NULL ) { if ( mono_find_prev_seq_point_for_native_offset ( info -> domain , method , info -> native_offset , NULL , & sp ) ) info -> il_offset = sp . il_offset ; } if ( info -> il_offset == - 1 ) info -> il_offset = mono_debug_il_offset_from_address ( method , info -> domain , info -> native_offset ) ; } DEBUG_PRINTF ( 1 , "\\tFrame:<S2SV_blank>%s:[il=0x%x,<S2SV_blank>native=0x%x]<S2SV_blank>%d\\n" , mono_method_full_name ( method , TRUE ) , info -> il_offset , info -> native_offset , info -> managed ) ; if ( method -> wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE ) { if ( ! CHECK_PROTOCOL_VERSION ( 2 , 17 ) ) { mono_loader_unlock ( ) ; return FALSE ; } api_method = mono_marshal_method_from_wrapper ( method ) ; if ( ! api_method ) { mono_loader_unlock ( ) ; return FALSE ; } actual_method = api_method ; flags |= FRAME_FLAG_NATIVE_TRANSITION ; } frame = g_new0 ( StackFrame , 1 ) ; frame -> method = method ; frame -> actual_method = actual_method ; frame -> api_method = api_method ; frame -> il_offset = info -> il_offset ; frame -> native_offset = info -> native_offset ; frame -> flags = flags ; frame -> ji = info -> ji ; frame -> interp_frame = info -> interp_frame ; frame -> frame_addr = info -> frame_addr ; if ( info -> reg_locations ) memcpy ( frame -> reg_locations , info -> reg_locations , MONO_MAX_IREGS * sizeof ( mgreg_t * ) ) ; if ( ctx ) { frame -> ctx = * ctx ; frame -> has_ctx = TRUE ; } frame -> domain = info -> domain ; ud -> frames = g_slist_append ( ud -> frames , frame ) ; <S2SV_StartBug> mono_loader_unlock ( ) ; <S2SV_EndBug> return FALSE ; }
|
<S2SV_ModStart> FRAME_TYPE_DEBUGGER_INVOKE ) { ud -> set_debugger_flag = TRUE <S2SV_ModEnd> ; } mono_loader_unlock <S2SV_ModStart> frame ) ; if ( ud -> set_debugger_flag ) { ( ( StackFrame * ) g_slist_last ( ud -> frames ) -> data ) -> flags |= FRAME_FLAG_DEBUGGER_INVOKE ; ud -> set_debugger_flag = FALSE ; }
|
1,051
|
CWE-000 static int CdbMergeComparator ( Datum lhs , Datum rhs , void * context ) { int lSegIdx = DatumGetInt32 ( lhs ) ; <S2SV_StartBug> int rSegIdx = DatumGetInt32 ( lhs ) ; <S2SV_EndBug> CdbMergeComparatorContext * ctx = ( CdbMergeComparatorContext * ) context ; CdbTupleHeapInfo * linfo = ( CdbTupleHeapInfo * ) & ctx -> tupleheap_entries [ lSegIdx ] ; CdbTupleHeapInfo * rinfo = ( CdbTupleHeapInfo * ) & ctx -> tupleheap_entries [ rSegIdx ] ; GenericTuple ltup = linfo -> tuple ; GenericTuple rtup = rinfo -> tuple ; SortSupport sortKeys = ctx -> sortKeys ; TupleDesc tupDesc ; int nkey ; int numSortCols = ctx -> numSortCols ; int compare ; Assert ( ltup && rtup ) ; tupDesc = ctx -> tupDesc ; compare = ApplySortComparator ( linfo -> datum1 , linfo -> isnull1 , rinfo -> datum1 , rinfo -> isnull1 , & sortKeys [ 0 ] ) ; if ( compare != 0 ) <S2SV_StartBug> return compare ; <S2SV_EndBug> for ( nkey = 1 ; nkey < numSortCols ; nkey ++ ) { SortSupport ssup = & sortKeys [ nkey ] ; AttrNumber attno = ssup -> ssup_attno ; Datum datum1 , datum2 ; bool isnull1 , isnull2 ; if ( is_memtuple ( ltup ) ) datum1 = memtuple_getattr ( ( MemTuple ) ltup , ctx -> mt_bind , attno , & isnull1 ) ; else datum1 = heap_getattr ( ( HeapTuple ) ltup , attno , tupDesc , & isnull1 ) ; if ( is_memtuple ( rtup ) ) datum2 = memtuple_getattr ( ( MemTuple ) rtup , ctx -> mt_bind , attno , & isnull2 ) ; else datum2 = heap_getattr ( ( HeapTuple ) rtup , attno , tupDesc , & isnull2 ) ; compare = ApplySortComparator ( datum1 , isnull1 , datum2 , isnull2 , ssup ) ; if ( compare != 0 ) <S2SV_StartBug> return compare ; <S2SV_EndBug> } return 0 ; }
|
<S2SV_ModStart> = DatumGetInt32 ( rhs <S2SV_ModEnd> ) ; CdbMergeComparatorContext <S2SV_ModStart> 0 ) return - <S2SV_ModStart> 0 ) return -
|
1,052
|
CWE-000 void live ( t_data * * data , t_process * * process , int cycle ) { t_player * pl ; int val ; int shift ; shift = 1 ; val = 0 ; pl = ( * data ) -> player ; val = get_dir_value ( & ( * data ) , ( * process ) , & shift , 4 ) ; <S2SV_StartBug> while ( pl ) <S2SV_EndBug> { if ( pl -> number == val ) { pl -> live ++ ; pl -> last_live = cycle ; <S2SV_StartBug> } <S2SV_EndBug> pl = pl -> next ; } <S2SV_StartBug> ( * process ) -> position = ( ( * process ) -> position + shift ) % MEM_SIZE ; <S2SV_EndBug> }
|
<S2SV_ModStart> 4 ) ; ( * process ) -> f = 0 ; <S2SV_ModStart> = cycle ; ( * data ) -> win = pl ; printf ( "\\nPlayer<S2SV_blank>%d<S2SV_blank>(%s)<S2SV_blank>is<S2SV_blank>said<S2SV_blank>to<S2SV_blank>be<S2SV_blank>alive" , pl -> id , pl -> header -> prog_name ) ; <S2SV_ModStart> -> position + 5 <S2SV_ModEnd> ) % MEM_SIZE
|
1,053
|
CWE-000 static void mdf_blufi_network_task ( void * arg ) { esp_err_t ret = ESP_OK ; network_config_t network_config = { 0 } ; network_config_t old_network_config = { 0 } ; <S2SV_StartBug> vTaskDelay ( 10000 / portTICK_RATE_MS ) ; <S2SV_EndBug> if ( mdf_wifi_mesh_is_connect ( ) ) { goto EXIT ; } if ( ! g_network_config_queue ) { g_network_config_queue = xQueueCreate ( 1 , sizeof ( network_config_t ) ) ; } MDF_LOGD ( "start<S2SV_blank>blue<S2SV_blank>network<S2SV_blank>configured" ) ; <S2SV_StartBug> mdf_info_load ( MDF_NETWORK_CONFIG_KEY , & old_network_config , sizeof ( network_config_t ) ) ; <S2SV_EndBug> ret = mdf_blufi_init ( ) ; MDF_ERROR_GOTO ( ret < 0 , EXIT , "mdf_blufi_init,<S2SV_blank>ret:<S2SV_blank>%d" , ret ) ; esp_mesh_set_self_organized ( false , false ) ; while ( ! mdf_wifi_mesh_is_connect ( ) ) { if ( xQueueReceive ( g_network_config_queue , & network_config , 3000 / portTICK_RATE_MS ) ) { ret = mdf_channel_get ( network_config . ssid , & network_config . channel ) ; MDF_ERROR_CONTINUE ( ret < 0 , "mdf_channel_get,<S2SV_blank>ret:<S2SV_blank>%d" , ret ) ; ret = mdf_reconfig_network ( & network_config ) ; MDF_ERROR_CONTINUE ( ret < 0 , "mdf_reconfig_network,<S2SV_blank>ret:<S2SV_blank>%d" , ret ) ; break ; } <S2SV_StartBug> if ( ! mdf_blufi_connecting_wifi ( ) ) { <S2SV_EndBug> uint8_t channel = 0 ; ret = mdf_channel_get ( old_network_config . ssid , & channel ) ; MDF_ERROR_CONTINUE ( ret < 0 , "mdf_channel_get,<S2SV_blank>ret:<S2SV_blank>%d" , ret ) ; if ( channel != old_network_config . channel ) { old_network_config . channel = channel ; ret = mdf_reconfig_network ( & old_network_config ) ; MDF_ERROR_CONTINUE ( ret < 0 , "mdf_reconfig_network,<S2SV_blank>ret:<S2SV_blank>%d" , ret ) ; } break ; } } esp_mesh_set_self_organized ( true , true ) ; ret = mdf_blufi_deinit ( ) ; MDF_ERROR_GOTO ( ret < 0 , EXIT , "mdf_blufi_deinit,<S2SV_blank>ret:<S2SV_blank>%d" , ret ) ; MDF_LOGD ( "end<S2SV_blank>blue<S2SV_blank>network<S2SV_blank>configured" ) ; EXIT : if ( g_network_config_queue ) { vQueueDelete ( g_network_config_queue ) ; g_network_config_queue = NULL ; } g_mdf_network_enable_blufi_flag = false ; mdf_network_delete_whitelist ( ) ; vTaskDelete ( NULL ) ; }
|
<S2SV_ModStart> 0 } ; size_t old_config_len = 0 ; <S2SV_ModStart> "start<S2SV_blank>blue<S2SV_blank>network<S2SV_blank>configured" ) ; old_config_len = <S2SV_ModStart> mdf_blufi_connecting_wifi ( ) && old_config_len > 0
|
1,054
|
CWE-000 static int prefix_LRE ( struct ccw1 * ccw , struct PFX_eckd_data * pfxdata , unsigned int trk , unsigned int totrk , int cmd , struct dasd_device * basedev , struct dasd_device * startdev , unsigned char format , unsigned int rec_on_trk , int count , unsigned int blksize , unsigned int tlf ) { struct dasd_eckd_private * basepriv , * startpriv ; struct DE_eckd_data * dedata ; struct LRE_eckd_data * lredata ; u32 begcyl , endcyl ; u16 heads , beghead , endhead ; int rc = 0 ; basepriv = basedev -> private ; startpriv = startdev -> private ; dedata = & pfxdata -> define_extent ; lredata = & pfxdata -> locate_record ; ccw -> cmd_code = DASD_ECKD_CCW_PFX ; ccw -> flags = 0 ; if ( cmd == DASD_ECKD_CCW_WRITE_FULL_TRACK ) { ccw -> count = sizeof ( * pfxdata ) + 2 ; ccw -> cda = ( __u32 ) __pa ( pfxdata ) ; memset ( pfxdata , 0 , sizeof ( * pfxdata ) + 2 ) ; } else { ccw -> count = sizeof ( * pfxdata ) ; ccw -> cda = ( __u32 ) __pa ( pfxdata ) ; memset ( pfxdata , 0 , sizeof ( * pfxdata ) ) ; } if ( format > 1 ) { DBF_DEV_EVENT ( DBF_ERR , basedev , "PFX<S2SV_blank>LRE<S2SV_blank>unknown<S2SV_blank>format<S2SV_blank>0x%x" , format ) ; BUG ( ) ; return - EINVAL ; } pfxdata -> format = format ; pfxdata -> base_address = basepriv -> ned -> unit_addr ; pfxdata -> base_lss = basepriv -> ned -> ID ; pfxdata -> validity . define_extent = 1 ; <S2SV_StartBug> if ( startpriv -> uid . type != UA_BASE_DEVICE ) { <S2SV_EndBug> pfxdata -> validity . verify_base = 1 ; <S2SV_StartBug> if ( startpriv -> uid . type == UA_HYPER_PAV_ALIAS ) <S2SV_EndBug> pfxdata -> validity . hyper_pav = 1 ; } switch ( cmd ) { case DASD_ECKD_CCW_READ_HOME_ADDRESS : case DASD_ECKD_CCW_READ_RECORD_ZERO : case DASD_ECKD_CCW_READ : case DASD_ECKD_CCW_READ_MT : case DASD_ECKD_CCW_READ_CKD : case DASD_ECKD_CCW_READ_CKD_MT : case DASD_ECKD_CCW_READ_KD : case DASD_ECKD_CCW_READ_KD_MT : dedata -> mask . perm = 0x1 ; dedata -> attributes . operation = basepriv -> attrib . operation ; break ; case DASD_ECKD_CCW_READ_COUNT : dedata -> mask . perm = 0x1 ; dedata -> attributes . operation = DASD_BYPASS_CACHE ; break ; case DASD_ECKD_CCW_READ_TRACK : case DASD_ECKD_CCW_READ_TRACK_DATA : dedata -> mask . perm = 0x1 ; dedata -> attributes . operation = basepriv -> attrib . operation ; dedata -> blk_size = 0 ; break ; case DASD_ECKD_CCW_WRITE : case DASD_ECKD_CCW_WRITE_MT : case DASD_ECKD_CCW_WRITE_KD : case DASD_ECKD_CCW_WRITE_KD_MT : dedata -> mask . perm = 0x02 ; dedata -> attributes . operation = basepriv -> attrib . operation ; rc = check_XRC_on_prefix ( pfxdata , basedev ) ; break ; case DASD_ECKD_CCW_WRITE_CKD : case DASD_ECKD_CCW_WRITE_CKD_MT : dedata -> attributes . operation = DASD_BYPASS_CACHE ; rc = check_XRC_on_prefix ( pfxdata , basedev ) ; break ; case DASD_ECKD_CCW_ERASE : case DASD_ECKD_CCW_WRITE_HOME_ADDRESS : case DASD_ECKD_CCW_WRITE_RECORD_ZERO : dedata -> mask . perm = 0x3 ; dedata -> mask . auth = 0x1 ; dedata -> attributes . operation = DASD_BYPASS_CACHE ; rc = check_XRC_on_prefix ( pfxdata , basedev ) ; break ; case DASD_ECKD_CCW_WRITE_FULL_TRACK : dedata -> mask . perm = 0x03 ; dedata -> attributes . operation = basepriv -> attrib . operation ; dedata -> blk_size = 0 ; break ; case DASD_ECKD_CCW_WRITE_TRACK_DATA : dedata -> mask . perm = 0x02 ; dedata -> attributes . operation = basepriv -> attrib . operation ; dedata -> blk_size = blksize ; rc = check_XRC_on_prefix ( pfxdata , basedev ) ; break ; default : DBF_DEV_EVENT ( DBF_ERR , basedev , "PFX<S2SV_blank>LRE<S2SV_blank>unknown<S2SV_blank>opcode<S2SV_blank>0x%x" , cmd ) ; BUG ( ) ; return - EINVAL ; } dedata -> attributes . mode = 0x3 ; if ( ( basepriv -> rdc_data . cu_type == 0x2105 || basepriv -> rdc_data . cu_type == 0x2107 || basepriv -> rdc_data . cu_type == 0x1750 ) && ! ( basepriv -> uses_cdl && trk < 2 ) ) dedata -> ga_extended |= 0x40 ; heads = basepriv -> rdc_data . trk_per_cyl ; begcyl = trk / heads ; beghead = trk % heads ; endcyl = totrk / heads ; endhead = totrk % heads ; if ( dedata -> attributes . operation == DASD_SEQ_PRESTAGE || dedata -> attributes . operation == DASD_SEQ_ACCESS ) { if ( endcyl + basepriv -> attrib . nr_cyl < basepriv -> real_cyl ) endcyl += basepriv -> attrib . nr_cyl ; else endcyl = ( basepriv -> real_cyl - 1 ) ; } set_ch_t ( & dedata -> beg_ext , begcyl , beghead ) ; set_ch_t ( & dedata -> end_ext , endcyl , endhead ) ; if ( format == 1 ) { fill_LRE_data ( lredata , trk , rec_on_trk , count , cmd , basedev , blksize , tlf ) ; } return rc ; }
|
<S2SV_ModStart> uid . type == UA_BASE_PAV_ALIAS ) <S2SV_ModEnd> pfxdata -> validity <S2SV_ModStart> == UA_HYPER_PAV_ALIAS ) { pfxdata -> validity . verify_base = 1 ;
|
1,055
|
CWE-000 void tss_init ( ) { tss0 . back_link = 0 ; tss0 . ss0 = 0x08 ; tss0 . esp0 = ( u32 ) kern_stack + sizeof ( kern_stack ) ; <S2SV_StartBug> set_seg_gate_desc ( 5 , ( u32 ) & tss0 , sizeof ( tss0 ) , 0x89 , 0x04 ) ; <S2SV_EndBug> ltr ( 5 * 8 ) ; extern u32 _intrs [ ] ; <S2SV_StartBug> set_intr_gate_desc ( 120 , _intrs [ 120 ] , 0x08 , IGD , 0x03 , 1 ) ; <S2SV_EndBug> handlers [ 120 ] = switch_to_user_handler ; handlers [ 121 ] = switch_to_kern_handler ; }
|
<S2SV_ModStart> tss0 ) , 0x8B <S2SV_ModEnd> , 0x04 ) <S2SV_ModStart> ; set_intr_gate_desc ( 121 <S2SV_ModEnd> , _intrs [ <S2SV_ModStart> , _intrs [ 121 <S2SV_ModEnd> ] , 0x08
|
1,056
|
CWE-000 static void print_raw_task_rstack ( struct uftrace_dump_ops * ops , struct ftrace_task_handle * task , char * name ) { struct uftrace_record * frs = task -> rstack ; struct uftrace_raw_dump * raw = container_of ( ops , typeof ( * raw ) , ops ) ; pr_time ( frs -> time ) ; pr_out ( "%5d:<S2SV_blank>[%s]<S2SV_blank>%s(%" PRIx64 ")<S2SV_blank>depth:<S2SV_blank>%u\\n" , task -> tid , rstack_type ( frs ) , name , frs -> addr , frs -> depth ) ; pr_hex ( & raw -> file_offset , frs , sizeof ( * frs ) ) ; if ( frs -> more ) { if ( frs -> type == UFTRACE_ENTRY ) { pr_time ( frs -> time ) ; pr_out ( "%5d:<S2SV_blank>[%s]<S2SV_blank>length<S2SV_blank>=<S2SV_blank>%d\\n" , task -> tid , "args<S2SV_blank>" , task -> args . len ) ; pr_args ( & task -> args ) ; pr_hex ( & raw -> file_offset , task -> args . data , ALIGN ( task -> args . len , 8 ) ) ; } else if ( frs -> type == UFTRACE_EXIT ) { pr_time ( frs -> time ) ; pr_out ( "%5d:<S2SV_blank>[%s]<S2SV_blank>length<S2SV_blank>=<S2SV_blank>%d\\n" , task -> tid , "retval" , task -> args . len ) ; pr_retval ( & task -> args ) ; pr_hex ( & raw -> file_offset , task -> args . data , ALIGN ( task -> args . len , 8 ) ) ; } <S2SV_StartBug> else <S2SV_EndBug> abort ( ) ; } }
|
<S2SV_ModStart> ; } else if ( frs -> type == UFTRACE_EVENT ) { pr_time ( frs -> time ) ; pr_out ( "%5d:<S2SV_blank>[%s]<S2SV_blank>length<S2SV_blank>=<S2SV_blank>%d\\n" , task -> tid , "data<S2SV_blank>" , task -> args . len ) ; pr_event ( frs -> addr , task -> args . data , task -> args . len ) ; pr_hex ( & raw -> file_offset , task -> args . data , ALIGN ( task -> args . len , 8 ) ) ; } else
|
1,057
|
CWE-000 static int __curfile_remove ( WT_CURSOR * cursor ) { WT_CURSOR_BTREE * cbt ; WT_DECL_RET ; WT_SESSION_IMPL * session ; cbt = ( WT_CURSOR_BTREE * ) cursor ; CURSOR_REMOVE_API_CALL ( cursor , session , cbt -> btree ) ; WT_ERR ( __cursor_checkkey ( cursor ) ) ; WT_ERR ( __wt_btcur_remove ( cbt ) ) ; WT_ASSERT ( session , <S2SV_StartBug> F_MASK ( cursor , WT_CURSTD_KEY_SET ) == 0 || <S2SV_EndBug> F_MASK ( cursor , WT_CURSTD_KEY_SET ) == WT_CURSTD_KEY_INT ) ; WT_ASSERT ( session , F_MASK ( cursor , WT_CURSTD_VALUE_SET ) == 0 ) ; err : CURSOR_UPDATE_API_END ( session , ret ) ; return ( ret ) ; }
|
<S2SV_ModStart> ( session , <S2SV_ModEnd> F_MASK ( cursor
|
1,058
|
CWE-000 static void MX_TIM3_Init ( void ) { TIM_ClockConfigTypeDef sClockSourceConfig ; TIM_MasterConfigTypeDef sMasterConfig ; TIM_OC_InitTypeDef sConfigOC ; htim3 . Instance = TIM3 ; htim3 . Init . Prescaler = 128 ; htim3 . Init . CounterMode = TIM_COUNTERMODE_UP ; <S2SV_StartBug> htim3 . Init . Period = 10000 ; <S2SV_EndBug> htim3 . Init . ClockDivision = TIM_CLOCKDIVISION_DIV1 ; htim3 . Init . AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE ; if ( HAL_TIM_Base_Init ( & htim3 ) != HAL_OK ) { _Error_Handler ( __FILE__ , __LINE__ ) ; } sClockSourceConfig . ClockSource = TIM_CLOCKSOURCE_INTERNAL ; if ( HAL_TIM_ConfigClockSource ( & htim3 , & sClockSourceConfig ) != HAL_OK ) { _Error_Handler ( __FILE__ , __LINE__ ) ; } if ( HAL_TIM_PWM_Init ( & htim3 ) != HAL_OK ) { _Error_Handler ( __FILE__ , __LINE__ ) ; } sMasterConfig . MasterOutputTrigger = TIM_TRGO_RESET ; sMasterConfig . MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE ; if ( HAL_TIMEx_MasterConfigSynchronization ( & htim3 , & sMasterConfig ) != HAL_OK ) { _Error_Handler ( __FILE__ , __LINE__ ) ; } sConfigOC . OCMode = TIM_OCMODE_PWM1 ; sConfigOC . Pulse = 750 ; sConfigOC . OCPolarity = TIM_OCPOLARITY_HIGH ; sConfigOC . OCFastMode = TIM_OCFAST_DISABLE ; if ( HAL_TIM_PWM_ConfigChannel ( & htim3 , & sConfigOC , TIM_CHANNEL_2 ) != HAL_OK ) { _Error_Handler ( __FILE__ , __LINE__ ) ; } HAL_TIM_MspPostInit ( & htim3 ) ; HAL_TIM_PWM_Start ( & htim3 , TIM_CHANNEL_2 ) ; }
|
<S2SV_ModStart> . Period = 9999 <S2SV_ModEnd> ; htim3 .
|
1,059
|
CWE-000 FAR void * pthread_getspecific ( pthread_key_t key ) { <S2SV_StartBug> # if CONFIG_NPTHREAD_KEYS > 0 <S2SV_EndBug> FAR struct pthread_tcb_s * rtcb = ( FAR struct pthread_tcb_s * ) this_task ( ) ; FAR struct task_group_s * group = rtcb -> cmn . group ; FAR void * ret = NULL ; DEBUGASSERT ( group && ( rtcb -> cmn . flags & TCB_FLAG_TTYPE_MASK ) == TCB_FLAG_TTYPE_PTHREAD ) ; <S2SV_StartBug> if ( key < group -> tg_nkeys ) { <S2SV_EndBug> <S2SV_StartBug> ret = rtcb -> pthread_data [ key ] ; <S2SV_EndBug> } return ret ; <S2SV_StartBug> # else <S2SV_EndBug> return NULL ; # endif }
|
<S2SV_ModStart> key ) { <S2SV_ModEnd> FAR struct pthread_tcb_s <S2SV_ModStart> ( key < PTHREAD_KEYS_MAX && group -> tg_keys [ key ] == IN_USE <S2SV_ModEnd> ) { ret <S2SV_ModStart> [ key ] . data <S2SV_ModStart> return ret ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null>
|
1,060
|
CWE-000 void pcat_model_eval ( int NX , int NY , int numbphon , int numbpixlpsfnside , int numbparaspix , float * A , float * B , float * C , int * x , int * y , float * image , float * ref , float * weight , double * diff2 , int regsize , int margin , int offsetx , int offsety , int numbtime , int booltimebins , float * lcpr ) { int i , m , t , imax , j , r , jmax , rad , p , xposthis , yposthis ; float alpha , beta ; int numbpixlpsfn = numbpixlpsfnside * numbpixlpsfnside ; rad = numbpixlpsfnside / 2 ; alpha = 1. ; beta = 0. ; int hash [ NY * NX ] ; for ( i = 0 ; i < NY * NX ; i ++ ) hash [ i ] = - 1 ; int numbphonshrt = 0 ; for ( p = 0 ; p < numbphon ; p ++ ) { xposthis = x [ p ] ; yposthis = y [ p ] ; int idx = yposthis * NX + xposthis ; if ( hash [ idx ] != - 1 ) { for ( i = 0 ; i < numbparaspix ; i ++ ) { A [ hash [ idx ] * numbparaspix + i ] += A [ p * numbparaspix + i ] ; } } else { hash [ idx ] = numbphonshrt ; for ( i = 0 ; i < numbparaspix ; i ++ ) A [ numbphonshrt * numbparaspix + i ] = A [ p * numbparaspix + i ] ; x [ numbphonshrt ] = x [ p ] ; y [ numbphonshrt ] = y [ p ] ; numbphonshrt ++ ; } } numbphon = numbphonshrt ; int c ; double summ ; for ( p = 0 ; p < numbphon ; p ++ ) { for ( i = 0 ; i < numbpixlpsfn ; i ++ ) { summ = 0. ; for ( c = 0 ; c < numbparaspix ; c ++ ) { summ = summ + A [ p * numbparaspix + c ] * B [ c * numbpixlpsfn + i ] ; } C [ p * numbpixlpsfn + i ] = summ ; } } for ( p = 0 ; p < numbphon ; p ++ ) { xposthis = x [ p ] ; yposthis = y [ p ] ; imax = min ( xposthis + rad , NX - 1 ) ; jmax = min ( yposthis + rad , NY - 1 ) ; for ( j = max ( yposthis - rad , 0 ) , r = ( p * numbpixlpsfnside + j - yposthis + rad ) * numbpixlpsfnside ; j <= jmax ; j ++ , r += numbpixlpsfnside ) { for ( i = max ( xposthis - rad , 0 ) , m = i - xposthis + rad ; i <= imax ; i ++ , m ++ ) { if ( booltimebins > 0 ) { for ( t = 0 ; t < numbtime ; t ++ ) { if ( t == 0 ) { image [ t , j * NX + i ] += C [ m + r ] ; } else { <S2SV_StartBug> image [ t , j * NX + i ] += C [ m + r ] * lcpr [ t - 1 ] ; <S2SV_EndBug> } } } else { image [ j * NX + i ] += C [ m + r ] ; } } } } pcat_like_eval ( NX , NY , image , ref , weight , diff2 , regsize , margin , offsetx , offsety ) ; }
|
<S2SV_ModStart> lcpr [ t <S2SV_ModEnd> ] ; }
|
1,061
|
CWE-000 static void iser_sched_rdma_rd ( struct event_data * evt ) { struct iser_conn * conn = ( struct iser_conn * ) evt -> data ; struct iser_work_req * first_wr = NULL ; struct iser_task * prev_task = NULL ; struct iser_task * task = NULL ; int num_reqs = 0 ; <S2SV_StartBug> int err ; <S2SV_EndBug> if ( unlikely ( conn -> h . state != STATE_FULL ) ) { dprintf ( "conn:%p<S2SV_blank>closing,<S2SV_blank>ignoring<S2SV_blank>rdma_rd\\n" , conn ) ; return ; } while ( ! list_empty ( & conn -> rdma_rd_list ) ) { task = list_first_entry ( & conn -> rdma_rd_list , struct iser_task , rdma_list ) ; list_del ( & task -> rdma_list ) ; iser_prep_rdma_rd_send_req ( task , NULL , 1 ) ; if ( first_wr == NULL ) first_wr = & task -> rdmad ; else prev_task -> rdmad . send_wr . next = & task -> rdmad . send_wr ; prev_task = task ; num_reqs ++ ; } if ( prev_task ) { prev_task -> rdmad . send_wr . next = NULL ; <S2SV_StartBug> err = iser_post_send ( conn , first_wr , num_reqs ) ; <S2SV_EndBug> } }
|
<S2SV_ModStart> = 0 ; <S2SV_ModEnd> if ( unlikely <S2SV_ModStart> = NULL ; <S2SV_ModEnd> iser_post_send ( conn
|
1,062
|
CWE-000 int calcMeaningfulNumber ( ) { <S2SV_StartBug> return 41 ; <S2SV_EndBug> }
|
<S2SV_ModStart> ) { return 42 <S2SV_ModEnd> ; } <S2SV_null>
|
1,063
|
CWE-000 void printCode ( Node * root ) { if ( root == NULL ) { return ; } <S2SV_StartBug> switch ( root -> type ) <S2SV_EndBug> { case IF_NODE : printf ( "if(" ) ; printCode ( root -> children [ 0 ] ) ; printf ( ")\\n" ) ; printCode ( root -> children [ 1 ] ) ; break ; case WHILE_NODE : printf ( "while(" ) ; printCode ( root -> children [ 0 ] ) ; printf ( ")\\n" ) ; printCode ( root -> children [ 1 ] ) ; break ; case LINE_NODE : printCode ( root -> children [ 0 ] ) ; printf ( ";\\n" ) ; break ; case ASSIGN_NODE_INT : printf ( "integer<S2SV_blank>%s<S2SV_blank>=<S2SV_blank>" , root -> nodeValue ) ; printCode ( root -> children [ 0 ] ) ; printf ( ";\\n" ) ; break ; case ASSIGN_NODE_F : printf ( "float<S2SV_blank>%s<S2SV_blank>=<S2SV_blank>" , root -> nodeValue ) ; printCode ( root -> children [ 0 ] ) ; printf ( ";\\n" ) ; break ; case ASSIGN_NODE : printf ( "%s<S2SV_blank>=<S2SV_blank>" , root -> nodeValue ) ; printCode ( root -> children [ 0 ] ) ; printf ( ";\\n" ) ; break ; case MULTI_NODE1 : printCode ( root -> children [ 0 ] ) ; break ; case MULTI_NODE2 : printCode ( root -> children [ 0 ] ) ; printCode ( root -> children [ 1 ] ) ; break ; case KEYS_NODE : printf ( "{\\n" ) ; printCode ( root -> children [ 1 ] ) ; printf ( "}\\n" ) ; break ; case INTEGER_NODE : printf ( "%s" , root -> nodeValue ) ; break ; case FLOAT_NODE : printf ( "%s" , root -> nodeValue ) ; break ; case PLUS_NODE : printCode ( root -> children [ 0 ] ) ; printf ( "<S2SV_blank>=<S2SV_blank>" ) ; printCode ( root -> children [ 1 ] ) ; break ; case SUB_NODE : printCode ( root -> children [ 0 ] ) ; printf ( "<S2SV_blank>-<S2SV_blank>" ) ; printCode ( root -> children [ 1 ] ) ; break ; case DIV_NODE : printCode ( root -> children [ 0 ] ) ; printf ( "<S2SV_blank>/<S2SV_blank>" ) ; printCode ( root -> children [ 1 ] ) ; break ; case PROD_NODE : printCode ( root -> children [ 0 ] ) ; printf ( "<S2SV_blank>*<S2SV_blank>" ) ; printCode ( root -> children [ 1 ] ) ; break ; case MOD_NODE : printf ( "<S2SV_blank><S2SV_blank>Math.abs(<S2SV_blank>(float)<S2SV_blank>%s<S2SV_blank>)<S2SV_blank>" , root -> children [ 0 ] -> nodeValue ) ; break ; case LOG_NODE : printf ( "<S2SV_blank><S2SV_blank>Math.log(<S2SV_blank>(float)<S2SV_blank>%s<S2SV_blank>)<S2SV_blank>" , root -> children [ 0 ] -> nodeValue ) ; break ; case SIN_NODE : printf ( "<S2SV_blank><S2SV_blank>Math.sin(<S2SV_blank>(float)<S2SV_blank>%s<S2SV_blank>)<S2SV_blank>" , root -> children [ 0 ] -> nodeValue ) ; break ; case COS_NODE : printf ( "<S2SV_blank><S2SV_blank>Math.cos(<S2SV_blank>(float)<S2SV_blank>%s<S2SV_blank>)<S2SV_blank>" , root -> children [ 0 ] -> nodeValue ) ; break ; case TAN_NODE : printf ( "<S2SV_blank><S2SV_blank>Math.tan(<S2SV_blank>(float)<S2SV_blank>%s<S2SV_blank>)<S2SV_blank>" , root -> children [ 0 ] -> nodeValue ) ; break ; case GRAPH_NODE : break ; default : break ; } }
|
<S2SV_ModStart> ( root -> nType <S2SV_ModEnd> ) { case
|
1,064
|
CWE-000 <S2SV_StartBug> PHP_METHOD ( rocksdb , getApproximateSizes ) { <S2SV_EndBug> }
|
<S2SV_ModStart> ( rocksdb , disableFileDeletions ) { if ( zend_parse_parameters_none ( ) == FAILURE ) { return ; } char * err = NULL ; php_rocksdb_db_object * this = Z_ROCKSDB_DB_P ( getThis ( ) TSRMLS_CC ) ; rocksdb_disable_file_deletions ( this -> db , & err ) ; if ( err != NULL ) { zend_throw_exception ( zend_ce_exception , err , 0 ) ; } <S2SV_ModEnd> } <S2SV_null> <S2SV_null>
|
1,065
|
CWE-000 struct List * concat_list ( struct List * list1 , struct List * list2 ) { int size2 = list2 -> currPos ; int i ; switch ( list1 -> type ) { case INT : for ( i = 0 ; i < size2 ; i ++ ) { <S2SV_StartBug> list1 = plus_list ( list1 , voidToint ( list2 -> value + i ) ) ; <S2SV_EndBug> } break ; case BOOL : for ( i = 0 ; i < size2 ; i ++ ) { <S2SV_StartBug> list1 = plus_list ( list1 , voidTobool ( list2 -> value + i ) ) ; <S2SV_EndBug> } break ; case FLOAT : for ( i = 0 ; i < size2 ; i ++ ) { <S2SV_StartBug> list1 = plus_list ( list1 , voidTofloat ( list2 -> value + i ) ) ; <S2SV_EndBug> } break ; case STRING : for ( i = 0 ; i < size2 ; i ++ ) { <S2SV_StartBug> list1 = plus_list ( list1 , voidTostring ( list2 -> value + i ) ) ; <S2SV_EndBug> } break ; case NODE : for ( i = 0 ; i < size2 ; i ++ ) { <S2SV_StartBug> list1 = plus_list ( list1 , voidTonode ( list2 -> value + i ) ) ; <S2SV_EndBug> } break ; case GRAPH : for ( i = 0 ; i < size2 ; i ++ ) { <S2SV_StartBug> list1 = plus_list ( list1 , voidTograph ( list2 -> value + i ) ) ; <S2SV_EndBug> } break ; default : break ; } return list1 ; }
|
<S2SV_ModStart> , voidToint ( * ( list2 -> value + i ) <S2SV_ModEnd> ) ) ; <S2SV_ModStart> , voidTobool ( * ( list2 -> value + i ) <S2SV_ModEnd> ) ) ; <S2SV_ModStart> , voidTofloat ( * ( list2 -> value + i ) <S2SV_ModEnd> ) ) ; <S2SV_ModStart> , voidTostring ( * ( list2 -> value + i ) <S2SV_ModEnd> ) ) ; <S2SV_ModStart> , voidTonode ( * ( list2 -> value + i ) <S2SV_ModEnd> ) ) ; <S2SV_ModStart> , voidTograph ( * ( list2 -> value + i ) <S2SV_ModEnd> ) ) ;
|
1,066
|
CWE-000 static gboolean ecc_init_sqlite_functions ( ECalCache * cal_cache , GCancellable * cancellable , GError * * error ) { gint ret ; gpointer sqlitedb ; g_return_val_if_fail ( E_IS_CAL_CACHE ( cal_cache ) , FALSE ) ; sqlitedb = e_cache_get_sqlitedb ( E_CACHE ( cal_cache ) ) ; g_return_val_if_fail ( sqlitedb != NULL , FALSE ) ; ret = sqlite3_create_function ( sqlitedb , "check_sexp" , 2 , SQLITE_UTF8 | SQLITE_DETERMINISTIC , cal_cache , ecc_check_sexp_func , NULL , NULL ) ; if ( ret == SQLITE_OK ) { ret = sqlite3_create_function ( sqlitedb , "negate" , 1 , SQLITE_UTF8 | SQLITE_DETERMINISTIC , NULL , ecc_negate_func , NULL , NULL ) ; } if ( ret != SQLITE_OK ) { const gchar * errmsg = sqlite3_errmsg ( sqlitedb ) ; g_set_error ( error , E_CACHE_ERROR , E_CACHE_ERROR_ENGINE , <S2SV_StartBug> _ ( "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>SQLite<S2SV_blank>function,<S2SV_blank>error<S2SV_blank>code<S2SV_blank>\'%d\':<S2SV_blank>%s" ) , <S2SV_EndBug> ret , errmsg ? errmsg : _ ( "Unknown<S2SV_blank>error" ) ) ; return FALSE ; } return TRUE ; }
|
<S2SV_ModStart> , _ ( "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>SQLite<S2SV_blank>function,<S2SV_blank>error<S2SV_blank>code<S2SV_blank>“%d”:<S2SV_blank>%s" <S2SV_ModEnd> ) , ret
|
1,067
|
CWE-000 void blkstatus ( void * ptr ) { if ( ptr < mem_heap_lo ( ) || ptr > mem_heap_hi ( ) || ( long ) ( ptr + 4 ) & 0x7 ) { <S2SV_StartBug> printf ( "pointer<S2SV_blank>invalid,<S2SV_blank>%p\\n" , ptr ) ; <S2SV_EndBug> return ; } if ( ! header_valid ( ptr ) ) { <S2SV_StartBug> printf ( "header<S2SV_blank>invalid!\\n" ) ; <S2SV_EndBug> return ; } if ( ALLOCATED ( ptr ) ) <S2SV_StartBug> printf ( "Allocated<S2SV_blank>block<S2SV_blank>%p\\n" , ptr ) ; <S2SV_EndBug> else <S2SV_StartBug> printf ( "free<S2SV_blank>block<S2SV_blank>%p,<S2SV_blank>prev:<S2SV_blank>%p<S2SV_blank>next:<S2SV_blank>%p\\n" , ptr , LINKEDPREV ( ptr ) , LINKEDNEXT ( ptr ) ) ; <S2SV_EndBug> printf ( "size:<S2SV_blank>%x,<S2SV_blank>before:<S2SV_blank>%p<S2SV_blank>after:<S2SV_blank>%p\\n" , GETSIZE ( ptr ) , BEFORE ( ptr ) , AFTER ( ptr ) ) ; }
|
<S2SV_ModStart> { printf ( "blkstatus:<S2SV_blank>pointer<S2SV_blank>invalid,<S2SV_blank>%p\\n" <S2SV_ModEnd> , ptr ) <S2SV_ModStart> { printf ( "blkstatus:<S2SV_blank>header<S2SV_blank>invalid,<S2SV_blank>%p\\n" , ptr <S2SV_ModEnd> ) ; return <S2SV_ModStart> ) printf ( "blkstatus:<S2SV_blank>Allocated<S2SV_blank>block<S2SV_blank>%p\\n" <S2SV_ModEnd> , ptr ) <S2SV_ModStart> else printf ( "blkstatus:<S2SV_blank>free<S2SV_blank>block<S2SV_blank>%p,<S2SV_blank>prev:<S2SV_blank>%p<S2SV_blank>next:<S2SV_blank>%p\\n" <S2SV_ModEnd> , ptr ,
|
1,068
|
CWE-000 static int boost_migration_notify ( struct notifier_block * nb , unsigned long dest_cpu , void * arg ) { unsigned long flags ; struct cpu_sync * s = & per_cpu ( sync_info , dest_cpu ) ; <S2SV_StartBug> if ( ! boost_ms ) <S2SV_EndBug> return NOTIFY_OK ; pr_debug ( "Migration:<S2SV_blank>CPU%d<S2SV_blank>--><S2SV_blank>CPU%d\\n" , ( int ) arg , ( int ) dest_cpu ) ; spin_lock_irqsave ( & s -> lock , flags ) ; s -> pending = true ; s -> src_cpu = ( int ) arg ; spin_unlock_irqrestore ( & s -> lock , flags ) ; wake_up ( & s -> sync_wq ) ; return NOTIFY_OK ; }
|
<S2SV_ModStart> ( ! boost_ms ) return NOTIFY_OK ; if ( s -> thread == current
|
1,069
|
CWE-000 static int gthreads_init ( void ) { <S2SV_StartBug> if ( gthreads_init_timer ( ) ) <S2SV_EndBug> return 1 ; if ( ! ( head = malloc ( sizeof ( struct thread_info ) ) ) ) return 1 ; head -> sender = - 1 ; head -> id = 0 ; <S2SV_StartBug> head -> next = head -> prev = head ; <S2SV_EndBug> total_threads = 1 ; cur_thread = head ; nextid = 1 ; return 0 ; }
|
<S2SV_ModStart> if ( gthreads_init_timer ( ) ) return 1 ; if ( gthreads_init_finaliser <S2SV_ModStart> ; head -> delete = 0 ; head ->
|
1,070
|
CWE-000 static int abd_copy_from_buf_off_cb ( void * buf , size_t size , void * private ) { struct buf_arg * ba_ptr = private ; <S2SV_StartBug> # ifdef DEBUG <S2SV_EndBug> VERIFY3P ( ( ( abd_t * ) buf ) -> abd_magic , != , ABD_DEBUG_MAGIC ) ; # endif ( void ) memcpy ( buf , ba_ptr -> arg_buf , size ) ; ba_ptr -> arg_buf = ( char * ) ba_ptr -> arg_buf + size ; return ( 0 ) ; }
|
<S2SV_ModStart> = private ; <S2SV_ModEnd> ( void )
|
1,071
|
CWE-000 int main ( int argc , char * argv [ ] ) { int ret = 0 ; int opt ; struct sigaction sigAct ; struct rlimit maxFiles ; static char buf [ 1024 ] ; srand ( time ( NULL ) ) ; memset ( & sigAct , 0 , sizeof ( sigAct ) ) ; sigemptyset ( & sigAct . sa_mask ) ; sigAct . sa_handler = SIG_IGN ; sigaction ( SIGPIPE , & sigAct , NULL ) ; setvbuf ( stdout , buf , _IONBF , 48 ) ; while ( ( opt = getopt ( argc , argv , "b:ef:F:t:p:c:C:m:i:I:P:d:Dn:l:L:M:rsBR:S:T:XW:yYz:Z:j:Ov" ) ) != - 1 ) { switch ( opt ) { case 'b' : batchsize = atoll ( optarg ) ; break ; case 't' : targetIP = optarg ; break ; case 'p' : targetPort = atoi ( optarg ) ; break ; case 'n' : numTargetPorts = atoi ( optarg ) ; break ; case 'c' : numConnections = atoi ( optarg ) ; if ( numConnections < 0 ) { numConnections *= - 1 ; softLimitConnections = 1 ; } break ; case 'C' : numFileIterations = atoi ( optarg ) ; break ; case 'm' : numMsgsToSend = atoi ( optarg ) ; break ; case 'i' : msgNum = atoi ( optarg ) ; break ; case 'P' : msgPRI = optarg ; break ; case 'j' : jsonCookie = optarg ; break ; case 'd' : extraDataLen = atoi ( optarg ) ; if ( extraDataLen > MAX_EXTRADATA_LEN ) { fprintf ( stderr , "-d<S2SV_blank>max<S2SV_blank>is<S2SV_blank>%d!\\n" , MAX_EXTRADATA_LEN ) ; exit ( 1 ) ; } break ; case 'D' : bRandConnDrop = 1 ; break ; case 'l' : dbRandConnDrop = atof ( optarg ) ; printf ( "RandConnDrop<S2SV_blank>Level:<S2SV_blank>\'%lf\'<S2SV_blank>\\n" , dbRandConnDrop ) ; break ; case 'r' : bRandomizeExtraData = 1 ; break ; case 'f' : dynFileIDs = atoi ( optarg ) ; break ; case 'F' : frameDelim = atoi ( optarg ) ; break ; case 'L' : tlsLogLevel = atoi ( optarg ) ; break ; case 'M' : MsgToSend = optarg ; break ; case 'I' : dataFile = optarg ; numMsgsToSend = 1000000 ; break ; case 's' : bSilent = 1 ; break ; case 'B' : bBinaryFile = 1 ; break ; case 'R' : numRuns = atoi ( optarg ) ; break ; case 'S' : sleepBetweenRuns = atoi ( optarg ) ; break ; case 'X' : bStatsRecords = 1 ; break ; case 'e' : bCSVoutput = 1 ; break ; case 'T' : if ( ! strcmp ( optarg , "udp" ) ) { transport = TP_UDP ; } else if ( ! strcmp ( optarg , "tcp" ) ) { transport = TP_TCP ; } else if ( ! strcmp ( optarg , "tls" ) ) { # if defined ( ENABLE_GNUTLS ) transport = TP_TLS ; # else fprintf ( stderr , "compiled<S2SV_blank>without<S2SV_blank>TLS<S2SV_blank>support:<S2SV_blank>" "\\"-Ttls\\"<S2SV_blank>not<S2SV_blank>supported!\\n" ) ; exit ( 1 ) ; # endif } else if ( ! strcmp ( optarg , "relp-plain" ) ) { # if defined ( ENABLE_RELP ) transport = TP_RELP_PLAIN ; # else fprintf ( stderr , "compiled<S2SV_blank>without<S2SV_blank>RELP<S2SV_blank>support:<S2SV_blank>" "\\"-Trelp-plain\\"<S2SV_blank>not<S2SV_blank>supported!\\n" ) ; exit ( 1 ) ; # endif } else { fprintf ( stderr , "unknown<S2SV_blank>transport<S2SV_blank>\'%s\'\\n" , optarg ) ; exit ( 1 ) ; } break ; case 'W' : waittime = atoi ( optarg ) ; break ; case 'Y' : runMultithreaded = 1 ; break ; case 'y' : useRFC5424Format = 1 ; break ; case 'z' : tlsKeyFile = optarg ; break ; case 'Z' : tlsCertFile = optarg ; break ; case 'O' : octateCountFramed = 1 ; break ; case 'v' : verbose = 1 ; break ; default : printf ( "invalid<S2SV_blank>option<S2SV_blank>\'%c\'<S2SV_blank>or<S2SV_blank>value<S2SV_blank>missing<S2SV_blank>-<S2SV_blank>terminating...\\n" , opt ) ; exit ( 1 ) ; break ; } } if ( bStatsRecords && waittime ) { fprintf ( stderr , "warning:<S2SV_blank>generating<S2SV_blank>performance<S2SV_blank>stats<S2SV_blank>and<S2SV_blank>using<S2SV_blank>a<S2SV_blank>waittime<S2SV_blank>" "is<S2SV_blank>somewhat<S2SV_blank>contradictory!\\n" ) ; } if ( ! isatty ( 1 ) || bSilent ) bShowProgress = 0 ; if ( numConnections > 20 ) { maxFiles . rlim_cur = numConnections + 20 ; maxFiles . rlim_max = numConnections + 20 ; if ( setrlimit ( RLIMIT_NOFILE , & maxFiles ) < 0 ) { perror ( "setrlimit<S2SV_blank>to<S2SV_blank>increase<S2SV_blank>file<S2SV_blank>handles<S2SV_blank>failed" ) ; fprintf ( stderr , "could<S2SV_blank>net<S2SV_blank>set<S2SV_blank>sufficiently<S2SV_blank>large<S2SV_blank>number<S2SV_blank>of<S2SV_blank>" "open<S2SV_blank>files<S2SV_blank>for<S2SV_blank>required<S2SV_blank>connection<S2SV_blank>count!\\n" ) ; exit ( 1 ) ; } } if ( dataFile != NULL ) { if ( ( dataFP = fopen ( dataFile , "r" ) ) == NULL ) { perror ( dataFile ) ; exit ( 1 ) ; } } if ( transport == TP_TLS ) { initTLS ( ) ; } else if ( transport == TP_RELP_PLAIN ) { initRELP_PLAIN ( ) ; } if ( openConnections ( ) != 0 ) { printf ( "error<S2SV_blank>opening<S2SV_blank>connections\\n" ) ; exit ( 1 ) ; } if ( runTests ( ) != 0 ) { printf ( "error<S2SV_blank>running<S2SV_blank>tests\\n" ) ; exit ( 1 ) ; } closeConnections ( ) ; <S2SV_StartBug> if ( nConnDrops > 0 && ! bSilent ) <S2SV_EndBug> printf ( "-D<S2SV_blank>option<S2SV_blank>initiated<S2SV_blank>%ld<S2SV_blank>connection<S2SV_blank>closures\\n" , nConnDrops ) ; if ( ! bSilent ) printf ( "End<S2SV_blank>of<S2SV_blank>tcpflood<S2SV_blank>Run\\n" ) ; <S2SV_StartBug> if ( transport == TP_TLS ) { <S2SV_EndBug> CHKRELP ( relpEngineDestruct ( & pRelpEngine ) ) ; } exit ( ret ) ; }
|
<S2SV_ModStart> ; if ( transport == TP_RELP_PLAIN ) { CHKRELP ( relpEngineDestruct ( & pRelpEngine ) ) ; } if ( <S2SV_ModStart> "End<S2SV_blank>of<S2SV_blank>tcpflood<S2SV_blank>Run\\n" ) ; <S2SV_ModEnd> exit ( ret
|
1,072
|
CWE-000 int l2tp_tunnel_create ( struct net * net , int fd , int version , u32 tunnel_id , u32 peer_tunnel_id , struct l2tp_tunnel_cfg * cfg , struct l2tp_tunnel * * tunnelp ) { struct l2tp_tunnel * tunnel = NULL ; int err ; struct socket * sock = NULL ; struct sock * sk = NULL ; struct l2tp_net * pn ; enum l2tp_encap_type encap = L2TP_ENCAPTYPE_UDP ; if ( fd < 0 ) { err = l2tp_tunnel_sock_create ( net , tunnel_id , peer_tunnel_id , cfg , & sock ) ; if ( err < 0 ) goto err ; } else { sock = sockfd_lookup ( fd , & err ) ; if ( ! sock ) { pr_err ( "tunl<S2SV_blank>%u:<S2SV_blank>sockfd_lookup(fd=%d)<S2SV_blank>returned<S2SV_blank>%d\\n" , tunnel_id , fd , err ) ; err = - EBADF ; goto err ; } if ( ! net_eq ( sock_net ( sock -> sk ) , net ) ) { pr_err ( "tunl<S2SV_blank>%u:<S2SV_blank>netns<S2SV_blank>mismatch\\n" , tunnel_id ) ; err = - EINVAL ; goto err ; } } sk = sock -> sk ; if ( cfg != NULL ) encap = cfg -> encap ; <S2SV_StartBug> switch ( encap ) { <S2SV_EndBug> case L2TP_ENCAPTYPE_UDP : <S2SV_StartBug> err = - EPROTONOSUPPORT ; <S2SV_EndBug> if ( sk -> sk_protocol != IPPROTO_UDP ) { pr_err ( "tunl<S2SV_blank>%hu:<S2SV_blank>fd<S2SV_blank>%d<S2SV_blank>wrong<S2SV_blank>protocol,<S2SV_blank>got<S2SV_blank>%d,<S2SV_blank>expected<S2SV_blank>%d\\n" , tunnel_id , fd , sk -> sk_protocol , IPPROTO_UDP ) ; goto err ; } break ; case L2TP_ENCAPTYPE_IP : <S2SV_StartBug> err = - EPROTONOSUPPORT ; <S2SV_EndBug> if ( sk -> sk_protocol != IPPROTO_L2TP ) { pr_err ( "tunl<S2SV_blank>%hu:<S2SV_blank>fd<S2SV_blank>%d<S2SV_blank>wrong<S2SV_blank>protocol,<S2SV_blank>got<S2SV_blank>%d,<S2SV_blank>expected<S2SV_blank>%d\\n" , tunnel_id , fd , sk -> sk_protocol , IPPROTO_L2TP ) ; goto err ; } break ; } tunnel = l2tp_tunnel ( sk ) ; if ( tunnel != NULL ) { err = - EBUSY ; goto err ; } tunnel = kzalloc ( sizeof ( struct l2tp_tunnel ) , GFP_KERNEL ) ; if ( tunnel == NULL ) { err = - ENOMEM ; goto err ; } tunnel -> version = version ; tunnel -> tunnel_id = tunnel_id ; tunnel -> peer_tunnel_id = peer_tunnel_id ; tunnel -> debug = L2TP_DEFAULT_DEBUG_FLAGS ; tunnel -> magic = L2TP_TUNNEL_MAGIC ; sprintf ( & tunnel -> name [ 0 ] , "tunl<S2SV_blank>%u" , tunnel_id ) ; rwlock_init ( & tunnel -> hlist_lock ) ; tunnel -> l2tp_net = net ; pn = l2tp_pernet ( net ) ; if ( cfg != NULL ) tunnel -> debug = cfg -> debug ; # if IS_ENABLED ( CONFIG_IPV6 ) if ( sk -> sk_family == PF_INET6 ) { struct ipv6_pinfo * np = inet6_sk ( sk ) ; if ( ipv6_addr_v4mapped ( & np -> saddr ) && ipv6_addr_v4mapped ( & sk -> sk_v6_daddr ) ) { struct inet_sock * inet = inet_sk ( sk ) ; tunnel -> v4mapped = true ; inet -> inet_saddr = np -> saddr . s6_addr32 [ 3 ] ; inet -> inet_rcv_saddr = sk -> sk_v6_rcv_saddr . s6_addr32 [ 3 ] ; inet -> inet_daddr = sk -> sk_v6_daddr . s6_addr32 [ 3 ] ; } else { tunnel -> v4mapped = false ; } } # endif tunnel -> encap = encap ; if ( encap == L2TP_ENCAPTYPE_UDP ) { struct udp_tunnel_sock_cfg udp_cfg ; udp_cfg . sk_user_data = tunnel ; udp_cfg . encap_type = UDP_ENCAP_L2TPINUDP ; udp_cfg . encap_rcv = l2tp_udp_encap_recv ; udp_cfg . encap_destroy = l2tp_udp_encap_destroy ; setup_udp_tunnel_sock ( net , sock , & udp_cfg ) ; } else { sk -> sk_user_data = tunnel ; } tunnel -> old_sk_destruct = sk -> sk_destruct ; sk -> sk_destruct = & l2tp_tunnel_destruct ; tunnel -> sock = sk ; tunnel -> fd = fd ; lockdep_set_class_and_name ( & sk -> sk_lock . slock , & l2tp_socket_class , "l2tp_sock" ) ; sk -> sk_allocation = GFP_ATOMIC ; INIT_WORK ( & tunnel -> del_work , l2tp_tunnel_del_work ) ; INIT_LIST_HEAD ( & tunnel -> list ) ; atomic_inc ( & l2tp_tunnel_count ) ; l2tp_tunnel_inc_refcount ( tunnel ) ; spin_lock_bh ( & pn -> l2tp_tunnel_list_lock ) ; list_add_rcu ( & tunnel -> list , & pn -> l2tp_tunnel_list ) ; spin_unlock_bh ( & pn -> l2tp_tunnel_list_lock ) ; err = 0 ; err : if ( tunnelp ) * tunnelp = tunnel ; if ( sock && sock -> file ) sockfd_put ( sock ) ; return err ; }
|
<S2SV_ModStart> -> encap ; err = - EPROTONOSUPPORT ; if ( sk -> sk_type != SOCK_DGRAM ) { pr_debug ( "tunl<S2SV_blank>%hu:<S2SV_blank>fd<S2SV_blank>%d<S2SV_blank>wrong<S2SV_blank>socket<S2SV_blank>type\\n" , tunnel_id , fd ) ; goto err ; } <S2SV_ModStart> case L2TP_ENCAPTYPE_UDP : <S2SV_ModEnd> if ( sk <S2SV_ModStart> case L2TP_ENCAPTYPE_IP : <S2SV_ModEnd> if ( sk
|
1,073
|
CWE-000 VOID GetSmmLoadedImage ( VOID ) { EFI_STATUS Status ; UINTN NoHandles ; UINTN HandleBufferSize ; EFI_HANDLE * HandleBuffer ; UINTN Index ; EFI_LOADED_IMAGE_PROTOCOL * LoadedImage ; CHAR16 * PathStr ; EFI_SMM_DRIVER_ENTRY * LoadedImagePrivate ; <S2SV_StartBug> UINTN EntryPoint ; <S2SV_EndBug> VOID * EntryPointInImage ; EFI_GUID Guid ; CHAR8 * PdbString ; <S2SV_StartBug> UINTN RealImageBase ; <S2SV_EndBug> HandleBufferSize = 0 ; HandleBuffer = NULL ; Status = gSmst -> SmmLocateHandle ( ByProtocol , & gEfiLoadedImageProtocolGuid , NULL , & HandleBufferSize , HandleBuffer ) ; if ( Status != EFI_BUFFER_TOO_SMALL ) { return ; } HandleBuffer = AllocateZeroPool ( HandleBufferSize ) ; if ( HandleBuffer == NULL ) { return ; } Status = gSmst -> SmmLocateHandle ( ByProtocol , & gEfiLoadedImageProtocolGuid , NULL , & HandleBufferSize , HandleBuffer ) ; if ( EFI_ERROR ( Status ) ) { return ; } NoHandles = HandleBufferSize / sizeof ( EFI_HANDLE ) ; <S2SV_StartBug> mImageStructCountMax = NoHandles ; <S2SV_EndBug> mImageStruct = AllocateZeroPool ( mImageStructCountMax * sizeof ( IMAGE_STRUCT ) ) ; if ( mImageStruct == NULL ) { goto Done ; } for ( Index = 0 ; Index < NoHandles ; Index ++ ) { Status = gSmst -> SmmHandleProtocol ( HandleBuffer [ Index ] , & gEfiLoadedImageProtocolGuid , ( VOID * * ) & LoadedImage ) ; if ( EFI_ERROR ( Status ) ) { continue ; } PathStr = ConvertDevicePathToText ( LoadedImage -> FilePath , TRUE , TRUE ) ; GetDriverGuid ( LoadedImage , & Guid ) ; DEBUG ( ( DEBUG_INFO , "Image:<S2SV_blank>%g<S2SV_blank>" , & Guid ) ) ; EntryPoint = 0 ; LoadedImagePrivate = BASE_CR ( LoadedImage , EFI_SMM_DRIVER_ENTRY , SmmLoadedImage ) ; RealImageBase = ( UINTN ) LoadedImage -> ImageBase ; if ( LoadedImagePrivate -> Signature == EFI_SMM_DRIVER_ENTRY_SIGNATURE ) { <S2SV_StartBug> EntryPoint = ( UINTN ) LoadedImagePrivate -> ImageEntryPoint ; <S2SV_EndBug> <S2SV_StartBug> if ( ( EntryPoint != 0 ) && ( ( EntryPoint < ( UINTN ) LoadedImage -> ImageBase ) || ( EntryPoint >= ( ( UINTN ) LoadedImage -> ImageBase + ( UINTN ) LoadedImage -> ImageSize ) ) ) ) { <S2SV_EndBug> Status = InternalPeCoffGetEntryPoint ( LoadedImage -> ImageBase , & EntryPointInImage ) ; ASSERT_EFI_ERROR ( Status ) ; RealImageBase = ( UINTN ) LoadedImage -> ImageBase + EntryPoint - ( UINTN ) EntryPointInImage ; } } <S2SV_StartBug> DEBUG ( ( DEBUG_INFO , "(0x%x<S2SV_blank>-<S2SV_blank>0x%x" , RealImageBase , ( UINTN ) LoadedImage -> ImageSize ) ) ; <S2SV_EndBug> if ( EntryPoint != 0 ) { <S2SV_StartBug> DEBUG ( ( DEBUG_INFO , ",<S2SV_blank>EntryPoint:0x%x" , EntryPoint ) ) ; <S2SV_EndBug> } DEBUG ( ( DEBUG_INFO , ")\\n" ) ) ; if ( RealImageBase != 0 ) { PdbString = PeCoffLoaderGetPdbPointer ( ( VOID * ) ( UINTN ) RealImageBase ) ; DEBUG ( ( DEBUG_INFO , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>pdb<S2SV_blank>-<S2SV_blank>%a\\n" , PdbString ) ) ; } else { PdbString = NULL ; } DEBUG ( ( DEBUG_INFO , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>(%s)\\n" , PathStr ) ) ; <S2SV_StartBug> AddImageStruct ( ( UINTN ) RealImageBase , ( UINTN ) LoadedImage -> ImageSize , EntryPoint , & Guid , PdbString ) ; <S2SV_EndBug> } Done : FreePool ( HandleBuffer ) ; return ; }
|
<S2SV_ModStart> * LoadedImagePrivate ; PHYSICAL_ADDRESS <S2SV_ModEnd> EntryPoint ; VOID <S2SV_ModStart> * PdbString ; PHYSICAL_ADDRESS <S2SV_ModEnd> RealImageBase ; HandleBufferSize <S2SV_ModStart> ; mImageStructCountMax = ( UINT32 ) <S2SV_ModStart> { EntryPoint = <S2SV_ModEnd> LoadedImagePrivate -> ImageEntryPoint <S2SV_ModStart> -> ImageBase + <S2SV_ModEnd> LoadedImage -> ImageSize <S2SV_ModStart> ( DEBUG_INFO , "(0x%lx<S2SV_blank>-<S2SV_blank>0x%lx" , RealImageBase , <S2SV_ModEnd> LoadedImage -> ImageSize <S2SV_ModStart> ( DEBUG_INFO , ",<S2SV_blank>EntryPoint:0x%lx" <S2SV_ModEnd> , EntryPoint ) <S2SV_ModStart> ; AddImageStruct ( RealImageBase , <S2SV_ModEnd> LoadedImage -> ImageSize
|
1,074
|
CWE-000 pthreads_stream_t * _pthreads_stream_new ( const pthreads_stream_ops * ops , void * abstract , const char * mode , const char * key , zend_class_entry * stream_ce ) { <S2SV_StartBug> printf ( "_pthreads_stream_new<S2SV_blank>\\n" ) ; <S2SV_EndBug> pthreads_stream_t * threaded_stream = NULL ; pthreads_stream * stream = NULL ; pthreads_hashtable * streams_list ; zend_string * str ; if ( stream_ce == NULL ) { stream_ce = pthreads_stream_entry ; } if ( ! instanceof_function ( stream_ce , pthreads_stream_entry ) ) { php_error_docref ( NULL , E_WARNING , "Class<S2SV_blank>\\"%s\\"<S2SV_blank>must<S2SV_blank>be<S2SV_blank>an<S2SV_blank>instance<S2SV_blank>of<S2SV_blank>Stream" , ZSTR_VAL ( stream_ce -> name ) ) ; return NULL ; } threaded_stream = pthreads_object_init ( stream_ce ) ; stream = pthreads_stream_alloc ( ops , abstract , mode ) ; stream -> readfilters . stream = threaded_stream ; stream -> writefilters . stream = threaded_stream ; PTHREADS_FETCH_STREAMS_STREAM ( threaded_stream ) = stream ; <S2SV_StartBug> printf ( "apply<S2SV_blank>stream(%p)<S2SV_blank>to<S2SV_blank>threaded_stream(%p)<S2SV_blank>base(%p)<S2SV_blank>state(%i)<S2SV_blank>\\n" , stream , threaded_stream , threaded_stream -> store . streams , stream -> state ) ; <S2SV_EndBug> if ( key ) { streams_list = & PTHREADS_STREAMG ( streams_list ) ; str = zend_string_init ( key , strlen ( key ) , 1 ) ; if ( MONITOR_LOCK ( streams_list ) ) { zend_hash_add_ptr ( & streams_list -> ht , str , threaded_stream ) ; MONITOR_UNLOCK ( streams_list ) ; } zend_string_release ( str ) ; } return threaded_stream ; }
|
<S2SV_ModStart> stream_ce ) { <S2SV_ModEnd> pthreads_stream_t * threaded_stream <S2SV_ModStart> = stream ; <S2SV_ModEnd> if ( key
|
1,075
|
CWE-000 static void process_tcp_packet ( server * srv , user_packet * packet ) { if ( srv -> opts -> mode == P_RAW ) { <S2SV_StartBug> push_tcp_packet_to_user ( srv , packet ) ; <S2SV_EndBug> } else { record_simple_latency ( srv , packet ) ; } }
|
<S2SV_ModStart> P_RAW ) { push_packet_to_user <S2SV_ModEnd> ( srv ,
|
1,076
|
CWE-000 static struct Qdisc * qdisc_create ( struct net_device * dev , struct netdev_queue * dev_queue , struct Qdisc * p , u32 parent , u32 handle , struct nlattr * * tca , int * errp ) { int err ; struct nlattr * kind = tca [ TCA_KIND ] ; struct Qdisc * sch ; struct Qdisc_ops * ops ; struct qdisc_size_table * stab ; ops = qdisc_lookup_ops ( kind ) ; # ifdef CONFIG_MODULES if ( ops == NULL && kind != NULL ) { char name [ IFNAMSIZ ] ; if ( nla_strlcpy ( name , kind , IFNAMSIZ ) < IFNAMSIZ ) { rtnl_unlock ( ) ; request_module ( "sch_%s" , name ) ; rtnl_lock ( ) ; ops = qdisc_lookup_ops ( kind ) ; if ( ops != NULL ) { module_put ( ops -> owner ) ; err = - EAGAIN ; goto err_out ; } } } # endif err = - ENOENT ; if ( ops == NULL ) goto err_out ; sch = qdisc_alloc ( dev_queue , ops ) ; if ( IS_ERR ( sch ) ) { err = PTR_ERR ( sch ) ; goto err_out2 ; } sch -> parent = parent ; if ( handle == TC_H_INGRESS ) { sch -> flags |= TCQ_F_INGRESS ; handle = TC_H_MAKE ( TC_H_INGRESS , 0 ) ; lockdep_set_class ( qdisc_lock ( sch ) , & qdisc_rx_lock ) ; } else { if ( handle == 0 ) { handle = qdisc_alloc_handle ( dev ) ; err = - ENOMEM ; if ( handle == 0 ) goto err_out3 ; } lockdep_set_class ( qdisc_lock ( sch ) , & qdisc_tx_lock ) ; if ( ! netif_is_multiqueue ( dev ) ) sch -> flags |= TCQ_F_ONETXQUEUE ; } sch -> handle = handle ; if ( ! ops -> init || ( err = ops -> init ( sch , tca [ TCA_OPTIONS ] ) ) == 0 ) { if ( tca [ TCA_STAB ] ) { stab = qdisc_get_stab ( tca [ TCA_STAB ] ) ; if ( IS_ERR ( stab ) ) { err = PTR_ERR ( stab ) ; goto err_out4 ; } rcu_assign_pointer ( sch -> stab , stab ) ; } if ( tca [ TCA_RATE ] ) { spinlock_t * root_lock ; err = - EOPNOTSUPP ; if ( sch -> flags & TCQ_F_MQROOT ) goto err_out4 ; if ( ( sch -> parent != TC_H_ROOT ) && ! ( sch -> flags & TCQ_F_INGRESS ) && ( ! p || ! ( p -> flags & TCQ_F_MQROOT ) ) ) root_lock = qdisc_root_sleeping_lock ( sch ) ; else root_lock = qdisc_lock ( sch ) ; err = gen_new_estimator ( & sch -> bstats , & sch -> rate_est , root_lock , tca [ TCA_RATE ] ) ; if ( err ) goto err_out4 ; } qdisc_list_add ( sch ) ; return sch ; } <S2SV_StartBug> err_out3 : <S2SV_EndBug> dev_put ( dev ) ; kfree ( ( char * ) sch - sch -> padded ) ; err_out2 : module_put ( ops -> owner ) ; err_out : * errp = err ; return NULL ; err_out4 : qdisc_put_stab ( rtnl_dereference ( sch -> stab ) ) ; if ( ops -> destroy ) ops -> destroy ( sch ) ; goto err_out3 ; }
|
<S2SV_ModStart> sch ; } ops -> destroy ( sch ) ;
|
1,077
|
CWE-000 static void xilinx_enet_realize ( DeviceState * dev , Error * * errp ) { XilinxAXIEnet * s = XILINX_AXI_ENET ( dev ) ; XilinxAXIEnetStreamSlave * ds = XILINX_AXI_ENET_DATA_STREAM ( & s -> rx_data_dev ) ; XilinxAXIEnetStreamSlave * cs = XILINX_AXI_ENET_CONTROL_STREAM ( & s -> rx_control_dev ) ; Error * local_err = NULL ; object_property_add_link ( OBJECT ( ds ) , "enet" , "xlnx.axi-ethernet" , ( Object * * ) & ds -> enet , object_property_allow_set_link , <S2SV_StartBug> OBJ_PROP_LINK_UNREF_ON_RELEASE , <S2SV_EndBug> & local_err ) ; object_property_add_link ( OBJECT ( cs ) , "enet" , "xlnx.axi-ethernet" , ( Object * * ) & cs -> enet , object_property_allow_set_link , <S2SV_StartBug> OBJ_PROP_LINK_UNREF_ON_RELEASE , <S2SV_EndBug> & local_err ) ; if ( local_err ) { goto xilinx_enet_realize_fail ; } object_property_set_link ( OBJECT ( ds ) , OBJECT ( s ) , "enet" , & local_err ) ; object_property_set_link ( OBJECT ( cs ) , OBJECT ( s ) , "enet" , & local_err ) ; if ( local_err ) { goto xilinx_enet_realize_fail ; } qemu_macaddr_default_if_unset ( & s -> conf . macaddr ) ; s -> nic = qemu_new_nic ( & net_xilinx_enet_info , & s -> conf , object_get_typename ( OBJECT ( dev ) ) , dev -> id , s ) ; qemu_format_nic_info_str ( qemu_get_queue ( s -> nic ) , s -> conf . macaddr . a ) ; tdk_init ( & s -> TEMAC . phy ) ; mdio_attach ( & s -> TEMAC . mdio_bus , & s -> TEMAC . phy , s -> c_phyaddr ) ; s -> TEMAC . parent = s ; s -> rxmem = g_malloc ( s -> c_rxmem ) ; return ; xilinx_enet_realize_fail : error_propagate ( errp , local_err ) ; }
|
<S2SV_ModStart> , object_property_allow_set_link , OBJ_PROP_LINK_STRONG <S2SV_ModEnd> , & local_err <S2SV_ModStart> , object_property_allow_set_link , OBJ_PROP_LINK_STRONG <S2SV_ModEnd> , & local_err
|
1,078
|
CWE-000 int search ( element * fs , char * path , char * name ) { char * newPath = ( char * ) malloc ( ( MAXHEIGHT * MAXNAME + MAXHEIGHT ) * sizeof ( char ) ) ; element * el ; int i , finishedFlag = 0 ; for ( i = 0 ; i < fs -> nChilds ; i ++ ) { strcpy ( newPath , path ) ; el = ( element * ) fs -> childs [ i ] ; strcat ( newPath , "/" ) ; strcat ( newPath , el -> name ) ; if ( 0 == strcmp ( name , el -> name ) ) { <S2SV_StartBug> printf ( "si<S2SV_blank>%s\\n" , newPath ) ; <S2SV_EndBug> if ( finishedFlag == 0 ) finishedFlag ++ ; } if ( el -> type == dir && el -> nChilds > 0 ) { if ( 0 != search ( el , newPath , name ) && finishedFlag == 0 ) finishedFlag ++ ; } } return finishedFlag ; }
|
<S2SV_ModStart> { printf ( "ok<S2SV_blank>%s\\n" <S2SV_ModEnd> , newPath )
|
1,079
|
CWE-000 char * encrypt_base64 ( char * line , size_t ln , size_t i , size_t j ) { unsigned char res ; unsigned char rem ; char * fin ; const char st [ ] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "abcdefghijklmnopqrstuvwxyz0123456789+/" ; ln = ( ( ( ( ln % 3 ) && ( ln % 3 ) == 2 ) ? ( ln + 1 ) : ( ln + 2 ) ) / 3 * 4 ) ; fin = ( char * ) malloc ( sizeof ( char ) * ( ln + ln / 64 + 1 ) ) ; while ( i < ln ) { <S2SV_StartBug> res = line [ j ] >> 2 ; <S2SV_EndBug> fin [ i ++ ] = st [ res ] ; rem = line [ j ++ ] << 6 ; <S2SV_StartBug> res = ( line [ j ] >> 4 ) << 2 ; <S2SV_EndBug> <S2SV_StartBug> fin [ i ++ ] = st [ ( res | rem ) >> 2 ] ; <S2SV_EndBug> rem = line [ j ++ ] << 4 ; <S2SV_StartBug> res = ( line [ j ] ? ( ( line [ j ] >> 6 ) << 2 ) : 0 ) ; <S2SV_EndBug> fin [ i ++ ] = ( ( line [ j ] || res || rem ) ? ( st [ ( ( res | rem ) >> 2 ) ] ) : '=' ) ; <S2SV_StartBug> rem = ( line [ j ] ? ( line [ j ++ ] << 2 ) : 0 ) ; <S2SV_EndBug> <S2SV_StartBug> fin [ i ++ ] = ( ( line [ j ] || res || rem ) ? ( st [ rem >> 2 ] ) : '=' ) ; <S2SV_EndBug> if ( ! ( i % 64 ) ) fin [ i ++ ] = '\\n' ; } fin [ i ] = '\\0' ; return ( fin ) ; }
|
<S2SV_ModStart> { res = ( unsigned char ) line [ j ] >> 2 ; fin [ i ++ ] = st [ res ] ; rem = ( unsigned char ) <S2SV_ModEnd> line [ j <S2SV_ModStart> res = ( ( unsigned char ) <S2SV_ModStart> st [ ( ( <S2SV_ModStart> ) >> 2 ) ] ; rem = ( unsigned char ) <S2SV_ModEnd> line [ j <S2SV_ModStart> ? ( ( ( unsigned char ) <S2SV_ModStart> ] ? ( ( unsigned char ) <S2SV_ModStart> ( st [ ( rem >> 2 ) <S2SV_ModEnd> ] ) :
|
1,080
|
CWE-000 <S2SV_StartBug> void alt_composite ( t_mlx_data * data , int resolution , unsigned int samples ) <S2SV_EndBug> { double Lw = 0.0 ; for ( int i = 0 ; i < resolution ; i ++ ) { <S2SV_StartBug> double scale = 1.0 / ( double ) samples ; <S2SV_EndBug> data -> pixels [ i ] . x = data -> total_clr [ i ] . x * scale ; data -> pixels [ i ] . y = data -> total_clr [ i ] . y * scale ; data -> pixels [ i ] . z = data -> total_clr [ i ] . z * scale ; double this_lw = log ( 0.1 + 0.2126 * data -> pixels [ i ] . x + 0.7152 * data -> pixels [ i ] . y + 0.0722 * data -> pixels [ i ] . z ) ; if ( this_lw == this_lw ) Lw += this_lw ; else printf ( "NaN<S2SV_blank>alert\\n" ) ; } Lw /= ( double ) resolution ; Lw = exp ( Lw ) ; for ( int i = 0 ; i < resolution ; i ++ ) { data -> pixels [ i ] . x = data -> pixels [ i ] . x * 0.36 / Lw ; data -> pixels [ i ] . y = data -> pixels [ i ] . y * 0.36 / Lw ; data -> pixels [ i ] . z = data -> pixels [ i ] . z * 0.36 / Lw ; data -> pixels [ i ] . x = data -> pixels [ i ] . x / ( data -> pixels [ i ] . x + 1.0 ) ; data -> pixels [ i ] . y = data -> pixels [ i ] . y / ( data -> pixels [ i ] . y + 1.0 ) ; data -> pixels [ i ] . z = data -> pixels [ i ] . z / ( data -> pixels [ i ] . z + 1.0 ) ; } }
|
<S2SV_ModStart> int resolution , cl_int * count <S2SV_ModEnd> ) { double <S2SV_ModStart> ( double ) ( count [ i ] ) <S2SV_ModEnd> ; data ->
|
1,081
|
CWE-000 static int sacn_listener ( char * host , char * port , uint8_t fd_flags ) { int fd = - 1 , status , yes = 1 , flags ; struct addrinfo hints = { . ai_family = AF_UNSPEC , . ai_socktype = SOCK_DGRAM , . ai_flags = AI_PASSIVE } ; struct addrinfo * info ; struct addrinfo * addr_it ; if ( global_cfg . fds >= MAX_FDS ) { fprintf ( stderr , "sACN<S2SV_blank>backend<S2SV_blank>descriptor<S2SV_blank>limit<S2SV_blank>reached\\n" ) ; return - 1 ; } status = getaddrinfo ( host , port , & hints , & info ) ; if ( status ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>socket<S2SV_blank>info<S2SV_blank>for<S2SV_blank>%s<S2SV_blank>port<S2SV_blank>%s:<S2SV_blank>%s\\n" , host , port , gai_strerror ( status ) ) ; return - 1 ; } for ( addr_it = info ; addr_it != NULL ; addr_it = addr_it -> ai_next ) { fd = socket ( addr_it -> ai_family , addr_it -> ai_socktype , addr_it -> ai_protocol ) ; if ( fd < 0 ) { continue ; } yes = 1 ; if ( setsockopt ( fd , SOL_SOCKET , SO_REUSEADDR , ( void * ) & yes , sizeof ( yes ) ) < 0 ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>SO_REUSEADDR<S2SV_blank>on<S2SV_blank>socket\\n" ) ; } yes = 1 ; if ( setsockopt ( fd , SOL_SOCKET , SO_BROADCAST , ( void * ) & yes , sizeof ( yes ) ) < 0 ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>SO_BROADCAST<S2SV_blank>on<S2SV_blank>socket\\n" ) ; } yes = 0 ; if ( setsockopt ( fd , IPPROTO_IP , IP_MULTICAST_LOOP , ( void * ) & yes , sizeof ( yes ) ) < 0 ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>unset<S2SV_blank>IP_MULTICAST_LOOP<S2SV_blank>option:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; } status = bind ( fd , addr_it -> ai_addr , addr_it -> ai_addrlen ) ; if ( status < 0 ) { close ( fd ) ; continue ; } break ; } freeaddrinfo ( info ) ; if ( ! addr_it ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>listening<S2SV_blank>socket<S2SV_blank>for<S2SV_blank>%s<S2SV_blank>port<S2SV_blank>%s\\n" , host , port ) ; return - 1 ; } flags = fcntl ( fd , F_GETFL , 0 ) ; if ( fcntl ( fd , F_SETFL , flags | O_NONBLOCK ) < 0 ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>sACN<S2SV_blank>descriptor<S2SV_blank>nonblocking\\n" ) ; return - 1 ; } global_cfg . fd = realloc ( global_cfg . fd , ( global_cfg . fds + 1 ) * sizeof ( sacn_fd ) ) ; if ( ! global_cfg . fd ) { <S2SV_StartBug> fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory\\n" ) ; <S2SV_EndBug> return - 1 ; } fprintf ( stderr , "sACN<S2SV_blank>backend<S2SV_blank>interface<S2SV_blank>%zu<S2SV_blank>bound<S2SV_blank>to<S2SV_blank>%s<S2SV_blank>port<S2SV_blank>%s\\n" , global_cfg . fds , host , port ) ; global_cfg . fd [ global_cfg . fds ] . fd = fd ; global_cfg . fd [ global_cfg . fds ] . flags = fd_flags ; global_cfg . fd [ global_cfg . fds ] . universes = 0 ; global_cfg . fd [ global_cfg . fds ] . universe = NULL ; global_cfg . fd [ global_cfg . fds ] . last_frame = NULL ; global_cfg . fds ++ ; return 0 ; }
|
<S2SV_ModStart> fd ) { close ( fd ) ;
|
1,082
|
CWE-000 bool pix_to_add ( struct Pixel * pix , struct Zone * zt ) { int diff_R , diff_G , diff_B ; <S2SV_StartBug> diff_R = ( ( abs ( ( int ) ( * zt ) . R - ( int ) ( * pix ) . R ) ) * 100 / 255 ) ; <S2SV_EndBug> <S2SV_StartBug> diff_G = ( ( abs ( ( int ) ( * zt ) . G - ( int ) ( * pix ) . G ) ) * 100 / 255 ) ; <S2SV_EndBug> <S2SV_StartBug> diff_B = ( ( abs ( ( int ) ( * zt ) . B - ( int ) ( * pix ) . B ) ) * 100 / 255 ) ; <S2SV_EndBug> return ( ( ( diff_R + diff_G + diff_B ) / 3 ) <= TOLERANCE ) ; }
|
<S2SV_ModStart> diff_R = ( abs ( ( int ) zt -> R - ( int ) * pix -> R ) * 100 ) / 255 ; diff_G = <S2SV_ModStart> ( int ) zt -> G <S2SV_ModEnd> - ( int <S2SV_ModStart> ( int ) * pix -> G <S2SV_ModEnd> ) * 100 <S2SV_ModStart> ) * 100 ) / 255 ; diff_B = <S2SV_ModEnd> ( abs ( <S2SV_ModStart> ( int ) zt -> <S2SV_ModEnd> B - ( <S2SV_ModStart> ( int ) * pix -> B <S2SV_ModEnd> ) * 100 <S2SV_ModStart> ) * 100 ) / 255 <S2SV_ModEnd> ; return (
|
1,083
|
CWE-000 static int FUNC ( user_data ) ( CodedBitstreamContext * ctx , RWContext * rw , MPEG2RawUserData * current ) { size_t k ; int err ; HEADER ( "User<S2SV_blank>Data" ) ; ui ( 8 , user_data_start_code ) ; # ifdef READ k = get_bits_left ( rw ) ; av_assert0 ( k % 8 == 0 ) ; current -> user_data_length = k /= 8 ; if ( k > 0 ) { <S2SV_StartBug> current -> user_data_ref = av_buffer_alloc ( k ) ; <S2SV_EndBug> if ( ! current -> user_data_ref ) return AVERROR ( ENOMEM ) ; current -> user_data = current -> user_data_ref -> data ; } # endif for ( k = 0 ; k < current -> user_data_length ; k ++ ) xui ( 8 , user_data , current -> user_data [ k ] , 0 ) ; return 0 ; }
|
<S2SV_ModStart> -> user_data_ref = av_buffer_allocz ( k + AV_INPUT_BUFFER_PADDING_SIZE <S2SV_ModEnd> ) ; if
|
1,084
|
CWE-000 static void AVR_Opcode_SUB ( AVR_CPU * pstCPU_ ) { uint8_t u8Rd = * pstCPU_ -> Rd ; uint8_t u8Rr = * pstCPU_ -> Rr ; <S2SV_StartBug> uint8_t u8Result = u8Rd - u8Rr ; <S2SV_EndBug> SUB_Half_Carry ( pstCPU_ , u8Rd , u8Rr , u8Result ) ; SUB_Full_Carry ( pstCPU_ , u8Rd , u8Rr , u8Result ) ; SUB_Overflow_Flag ( pstCPU_ , u8Rd , u8Rr , u8Result ) ; R8_Negative_Flag ( pstCPU_ , u8Result ) ; R8_Zero_Flag ( pstCPU_ , u8Result ) ; Signed_Flag ( pstCPU_ ) ; }
|
<S2SV_ModStart> u8Rd - u8Rr ; * pstCPU_ -> Rd = u8Result
|
1,085
|
CWE-000 static void fb_api_cb_mqtt_connect ( FbMqtt * mqtt , gpointer data ) { FbApi * api = data ; FbApiPrivate * priv = api -> priv ; gchar * json ; JsonBuilder * bldr ; bldr = fb_json_bldr_new ( JSON_NODE_OBJECT ) ; fb_json_bldr_add_bool ( bldr , "foreground" , TRUE ) ; fb_json_bldr_add_int ( bldr , "keepalive_timeout" , FB_MQTT_KA ) ; json = fb_json_bldr_close ( bldr , JSON_NODE_OBJECT , NULL ) ; fb_api_publish ( api , "/foreground_state" , "%s" , json ) ; g_free ( json ) ; fb_mqtt_subscribe ( mqtt , "/inbox" , 0 , "/mercury" , 0 , "/messaging_events" , 0 , "/orca_presence" , 0 , "/orca_typing_notifications" , 0 , "/pp" , 0 , "/t_ms" , 0 , "/t_p" , 0 , "/t_rtc" , 0 , "/webrtc" , 0 , "/webrtc_response" , 0 , NULL ) ; fb_mqtt_unsubscribe ( mqtt , "/orca_message_notifications" , NULL ) ; if ( priv -> sid == 0 ) { bldr = fb_json_bldr_new ( JSON_NODE_OBJECT ) ; <S2SV_StartBug> fb_json_bldr_add_str ( bldr , "1" , "0" ) ; <S2SV_EndBug> fb_api_http_query ( api , FB_API_QUERY_THREADS , bldr , fb_api_cb_seqid ) ; } else { fb_api_connect_queue ( api ) ; } }
|
<S2SV_ModStart> , "1" , "1" <S2SV_ModEnd> ) ; fb_api_http_query
|
1,086
|
CWE-000 static int fast_classifier_device_event ( struct notifier_block * this , unsigned long event , void * ptr ) { struct net_device * dev = SFE_DEV_EVENT_PTR ( ptr ) ; if ( dev && ( event == NETDEV_DOWN ) ) { sfe_ipv4_destroy_all_rules_for_dev ( dev ) ; <S2SV_StartBug> sfe_ipv6_destroy_all_rules_for_dev ( dev ) ; <S2SV_EndBug> } return NOTIFY_DONE ; }
|
<S2SV_ModStart> dev ) ; <S2SV_ModEnd> } return NOTIFY_DONE
|
1,087
|
CWE-000 int op_write8_2 ( instn_t * instn , vm_t * vm ) { <S2SV_StartBug> uint32_t ref = lref32 ( instn -> args [ 0 ] . ptr ) ; <S2SV_EndBug> uint8_t * mem = deref_mem_ptr ( ref , 1 , vm ) ; if ( ! mem ) { return - 1 ; } * mem = arg_value ( instn , 1 ) ; return 0 ; }
|
<S2SV_ModStart> uint32_t ref = arg_value ( instn , 0 <S2SV_ModEnd> ) ; uint8_t
|
1,088
|
CWE-000 void d4est_vtk_context_destroy ( d4est_vtk_context_t * context ) { # ifdef D4EST_VTK_DEBUG printf ( "[D4EST_VTK]:<S2SV_blank>Starting<S2SV_blank>d4est_vtk_context_destroy<S2SV_blank>\\n" ) ; # endif P4EST_ASSERT ( context != NULL ) ; P4EST_ASSERT ( context -> p4est != NULL ) ; P4EST_ASSERT ( context -> filename != NULL ) ; free ( context -> filename ) ; <S2SV_StartBug> if ( context -> nodes != NULL ) { <S2SV_EndBug> p4est_nodes_destroy ( context -> nodes ) ; } P4EST_FREE ( context -> node_to_corner ) ; if ( context -> vtufile != NULL ) { if ( fclose ( context -> vtufile ) ) { P4EST_LERRORF ( P4EST_STRING "_vtk:<S2SV_blank>Error<S2SV_blank>closing<S2SV_blank><%s>.\\n" , context -> vtufilename ) ; } context -> vtufile = NULL ; } if ( context -> pvtufile != NULL ) { P4EST_ASSERT ( context -> p4est -> mpirank == 0 ) ; if ( fclose ( context -> pvtufile ) ) { P4EST_LERRORF ( P4EST_STRING "_vtk:<S2SV_blank>Error<S2SV_blank>closing<S2SV_blank><%s>.\\n" , context -> pvtufilename ) ; } context -> pvtufile = NULL ; } if ( context -> visitfile != NULL ) { P4EST_ASSERT ( context -> p4est -> mpirank == 0 ) ; if ( fclose ( context -> visitfile ) ) { P4EST_LERRORF ( P4EST_STRING "_vtk:<S2SV_blank>Error<S2SV_blank>closing<S2SV_blank><%s>.\\n" , context -> visitfilename ) ; } context -> visitfile = NULL ; } P4EST_FREE ( context ) ; }
|
<S2SV_ModStart> filename ) ; free ( context -> input_section ) ; free ( context -> geometry_section ) ;
|
1,089
|
CWE-000 static void free_ocp_nlp_in_nonlinear_constraints ( ocp_nlp_in * const nlp ) { <S2SV_StartBug> free ( nlp -> path_constraints ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> nlp ) { for ( int_t i = 0 ; i <= nlp -> N ; i ++ ) { free ( ( void * ) nlp -> lg [ i ] ) ; free ( ( void * ) nlp -> ug [ i ] ) ; } free ( nlp -> lg ) ; free ( nlp -> ug ) ;
|
1,090
|
CWE-000 int32_t ashell_print_file ( char * buf ) { char filename [ MAX_FILENAME_SIZE ] ; char data [ READ_BUFFER_SIZE ] ; fs_file_t * file ; size_t count ; size_t line = 1 ; bool hidden = ashell_check_parameter ( buf , 'v' ) ; bool lines = ashell_check_parameter ( buf , 'n' ) ; if ( lines ) printk ( "<S2SV_blank>Print<S2SV_blank>lines<S2SV_blank>\\n" ) ; if ( hidden ) printk ( "<S2SV_blank>Print<S2SV_blank>hidden<S2SV_blank>\\n" ) ; if ( ashell_get_filename_buffer ( buf , filename ) <= 0 ) { return RET_ERROR ; } <S2SV_StartBug> if ( ! fs_exist ( filename ) ) { <S2SV_EndBug> printf ( ERROR_FILE_NOT_FOUND ) ; return RET_ERROR ; } file = fs_open_alloc ( filename , "r" ) ; if ( ! file ) { comms_println ( ERROR_FILE_NOT_FOUND ) ; return RET_ERROR ; } ssize_t size = fs_size ( file ) ; if ( size == 0 ) { comms_println ( "Empty<S2SV_blank>file" ) ; fs_close_alloc ( file ) ; return RET_OK ; } fs_seek ( file , 0 , SEEK_SET ) ; if ( lines ) comms_printf ( "%5d<S2SV_blank><S2SV_blank>" , line ++ ) ; do { count = fs_read ( file , data , 4 ) ; for ( int t = 0 ; t < count ; t ++ ) { uint8_t byte = data [ t ] ; if ( byte == '\\n' || byte == '\\r' ) { comms_write_buf ( "\\r\\n" , 2 ) ; if ( lines ) comms_printf ( "%5d<S2SV_blank><S2SV_blank>" , line ++ ) ; } else { if ( hidden && ! isprint ( byte ) ) { comms_printf ( "(%x)" , byte ) ; } else comms_writec ( byte ) ; } } } while ( count > 0 ) ; comms_write_buf ( "\\r\\n" , 2 ) ; fs_close ( file ) ; return RET_OK ; }
|
<S2SV_ModStart> RET_ERROR ; } <S2SV_ModEnd> file = fs_open_alloc
|
1,091
|
CWE-000 <S2SV_StartBug> static bool try_serialize_array ( papuga_lua_CallArgs * as , papuga_Serialization * result , lua_State * ls , int li ) <S2SV_EndBug> { size_t start_size = result -> arsize ; int idx = 0 ; STACKTRACE ( ls , "loop<S2SV_blank>before<S2SV_blank>serialize<S2SV_blank>array" ) ; lua_pushvalue ( ls , li ) ; lua_pushnil ( ls ) ; while ( lua_next ( ls , - 2 ) ) { STACKTRACE ( ls , "loop<S2SV_blank>next<S2SV_blank>serialize<S2SV_blank>array" ) ; if ( ! lua_isinteger ( ls , - 2 ) || lua_tointeger ( ls , - 2 ) != ++ idx ) goto ERROR ; serialize_value ( as , result , ls , - 1 ) ; lua_pop ( ls , 1 ) ; } lua_pop ( ls , 1 ) ; STACKTRACE ( ls , "loop<S2SV_blank>after<S2SV_blank>serialize<S2SV_blank>array" ) ; return true ; ERROR : lua_pop ( ls , 3 ) ; result -> arsize = start_size ; STACKTRACE ( ls , "loop<S2SV_blank>after<S2SV_blank>try<S2SV_blank>serialize<S2SV_blank>array" ) ; return false ; }
|
<S2SV_ModStart> bool try_serialize_array ( papuga_CallArgs <S2SV_ModEnd> * as ,
|
1,092
|
CWE-000 static int mca_btl_uct_component_register ( void ) { mca_btl_uct_module_t * module = & mca_btl_uct_module_template ; mca_btl_uct_component . memory_domains = "none" ; ( void ) mca_base_component_var_register ( & mca_btl_uct_component . super . btl_version , "memory_domains" , "Comma-delimited<S2SV_blank>list<S2SV_blank>of<S2SV_blank>memory<S2SV_blank>domains<S2SV_blank>of<S2SV_blank>the<S2SV_blank>form<S2SV_blank>" "to<S2SV_blank>use<S2SV_blank>for<S2SV_blank>communication.<S2SV_blank>Memory<S2SV_blank>domains<S2SV_blank>MUST<S2SV_blank>provide<S2SV_blank>transports<S2SV_blank>that<S2SV_blank>" "support<S2SV_blank>put,<S2SV_blank>get,<S2SV_blank>and<S2SV_blank>amos.<S2SV_blank>Special<S2SV_blank>values:<S2SV_blank>all<S2SV_blank>(all<S2SV_blank>available),<S2SV_blank>none." "<S2SV_blank>(default:<S2SV_blank>none)" , MCA_BASE_VAR_TYPE_STRING , NULL , 0 , MCA_BASE_VAR_FLAG_SETTABLE , OPAL_INFO_LVL_3 , MCA_BASE_VAR_SCOPE_LOCAL , & mca_btl_uct_component . memory_domains ) ; <S2SV_StartBug> mca_btl_uct_component . allowed_transports = "dc_mlx5,rc_mlx5,ud,any" ; <S2SV_EndBug> ( void ) mca_base_component_var_register ( & mca_btl_uct_component . super . btl_version , "transports" , "Comma-delimited<S2SV_blank>list<S2SV_blank>of<S2SV_blank>transports<S2SV_blank>to<S2SV_blank>use<S2SV_blank>sorted<S2SV_blank>by<S2SV_blank>increasing<S2SV_blank>" "priority.<S2SV_blank>The<S2SV_blank>list<S2SV_blank>of<S2SV_blank>transports<S2SV_blank>available<S2SV_blank>can<S2SV_blank>be<S2SV_blank>queried<S2SV_blank>using<S2SV_blank>ucx_info.<S2SV_blank>Special" "values:<S2SV_blank>any<S2SV_blank>(any<S2SV_blank>available)<S2SV_blank>(default:<S2SV_blank>dc_mlx5,rc_mlx5,ud,any)" , MCA_BASE_VAR_TYPE_STRING , NULL , 0 , MCA_BASE_VAR_FLAG_SETTABLE , OPAL_INFO_LVL_3 , MCA_BASE_VAR_SCOPE_LOCAL , & mca_btl_uct_component . allowed_transports ) ; mca_btl_uct_component . num_contexts_per_module = 0 ; ( void ) mca_base_component_var_register ( & mca_btl_uct_component . super . btl_version , "num_contexts_per_module" , "Number<S2SV_blank>of<S2SV_blank>UCT<S2SV_blank>worker<S2SV_blank>contexts<S2SV_blank>" "to<S2SV_blank>create<S2SV_blank>for<S2SV_blank>each<S2SV_blank>BTL<S2SV_blank>module.<S2SV_blank>Larger<S2SV_blank>numbers<S2SV_blank>will<S2SV_blank>improve<S2SV_blank>" "multi-threaded<S2SV_blank>performance<S2SV_blank>but<S2SV_blank>may<S2SV_blank>increase<S2SV_blank>memory<S2SV_blank>usage.<S2SV_blank>" "A<S2SV_blank>good<S2SV_blank>rule<S2SV_blank>of<S2SV_blank>thumb<S2SV_blank>is<S2SV_blank>one<S2SV_blank>context<S2SV_blank>per<S2SV_blank>application<S2SV_blank>thread<S2SV_blank>" "that<S2SV_blank>will<S2SV_blank>be<S2SV_blank>calling<S2SV_blank>into<S2SV_blank>MPI.<S2SV_blank>(default:<S2SV_blank>0<S2SV_blank>--<S2SV_blank>autoselect<S2SV_blank>" "based<S2SV_blank>on<S2SV_blank>the<S2SV_blank>number<S2SV_blank>of<S2SV_blank>cores)" , MCA_BASE_VAR_TYPE_INT , NULL , 0 , MCA_BASE_VAR_FLAG_SETTABLE , OPAL_INFO_LVL_3 , MCA_BASE_VAR_SCOPE_ALL , & mca_btl_uct_component . num_contexts_per_module ) ; mca_btl_uct_component . disable_ucx_memory_hooks = true ; ( void ) mca_base_component_var_register ( & mca_btl_uct_component . super . btl_version , "disable_ucx_memory_hooks" , "Disable<S2SV_blank>the<S2SV_blank>munmap<S2SV_blank>memory<S2SV_blank>hook<S2SV_blank>" "inside<S2SV_blank>UCX.<S2SV_blank>These<S2SV_blank>hooks<S2SV_blank>are<S2SV_blank>not<S2SV_blank>necessary<S2SV_blank>when<S2SV_blank>using<S2SV_blank>the<S2SV_blank>" "uct<S2SV_blank>btl<S2SV_blank>and<S2SV_blank>tend<S2SV_blank>to<S2SV_blank>cause<S2SV_blank>performance<S2SV_blank>problems<S2SV_blank>when<S2SV_blank>using<S2SV_blank>" "multiple<S2SV_blank>threads<S2SV_blank>(default:<S2SV_blank>true)" , MCA_BASE_VAR_TYPE_BOOL , NULL , 0 , MCA_BASE_VAR_FLAG_SETTABLE , OPAL_INFO_LVL_3 , MCA_BASE_VAR_SCOPE_ALL , & mca_btl_uct_component . disable_ucx_memory_hooks ) ; # if OPAL_C_HAVE__THREAD_LOCAL mca_btl_uct_component . bind_threads_to_contexts = true ; ( void ) mca_base_component_var_register ( & mca_btl_uct_component . super . btl_version , "bind_threads_to_contexts" , "Bind<S2SV_blank>threads<S2SV_blank>to<S2SV_blank>device<S2SV_blank>contexts.<S2SV_blank>" "In<S2SV_blank>general<S2SV_blank>this<S2SV_blank>should<S2SV_blank>improve<S2SV_blank>the<S2SV_blank>multi-threaded<S2SV_blank>performance<S2SV_blank>" "when<S2SV_blank>threads<S2SV_blank>are<S2SV_blank>used.<S2SV_blank>(default:<S2SV_blank>true)" , MCA_BASE_VAR_TYPE_BOOL , NULL , 0 , MCA_BASE_VAR_FLAG_SETTABLE , OPAL_INFO_LVL_3 , MCA_BASE_VAR_SCOPE_ALL , & mca_btl_uct_component . bind_threads_to_contexts ) ; # endif module -> super . btl_exclusivity = MCA_BTL_EXCLUSIVITY_HIGH ; return mca_btl_base_param_register ( & mca_btl_uct_component . super . btl_version , & module -> super ) ; }
|
<S2SV_ModStart> . allowed_transports = "dc_mlx5,rc_mlx5,ud,ugni_rdma,ugni_smsg,any" <S2SV_ModEnd> ; ( void
|
1,093
|
CWE-000 wifi_utils_result_e wifi_profile_read ( wifi_manager_ap_config_s * config ) { <S2SV_StartBug> char buf [ 256 ] = { 0 , } ; <S2SV_EndBug> int ret = - 1 ; # ifdef CONFIG_WIFI_PROFILE_SECURESTORAGE <S2SV_StartBug> unsigned int readlen = 256 ; <S2SV_EndBug> ret = see_read_secure_storage ( ( unsigned char * ) buf , & readlen , WIFI_PROFILE_SS_INDEX ) ; if ( ret != SEE_OK ) { return WIFI_UTILS_FILE_ERROR ; <S2SV_StartBug> } else if ( readlen == 1 ) { <S2SV_EndBug> return WIFI_UTILS_FILE_ERROR ; } # else <S2SV_StartBug> ret = _wifi_profile_read_file ( buf , 256 ) ; <S2SV_EndBug> if ( ret < 0 ) { return WIFI_UTILS_FILE_ERROR ; } # endif _wifi_profile_deserialize ( config , buf ) ; return WIFI_UTILS_SUCCESS ; }
|
<S2SV_ModStart> char buf [ 128 <S2SV_ModEnd> ] = { <S2SV_ModStart> int readlen = 128 <S2SV_ModEnd> ; ret = <S2SV_ModStart> WIFI_UTILS_FILE_ERROR ; } <S2SV_ModEnd> # else ret <S2SV_ModStart> ( buf , 128 <S2SV_ModEnd> ) ; if
|
1,094
|
CWE-000 StatusCode thermistor_get_temp ( ThermistorStorage * storage , uint32_t * temperature_millicelcius ) { uint16_t reading = 0 ; uint32_t thermistor_resistance_milliohms = 0 ; uint16_t vdda = 0 ; status_ok_or_return ( adc_read_converted ( ADC_CHANNEL_REF , & vdda ) ) ; status_ok_or_return ( adc_read_converted ( storage -> adc_channel , & reading ) ) ; if ( vdda == 0 ) { * temperature_millicelcius = UINT_MAX ; return status_msg ( STATUS_CODE_INTERNAL_ERROR , "No<S2SV_blank>source<S2SV_blank>voltage<S2SV_blank>detected." ) ; } <S2SV_StartBug> if ( reading == 0 ) { <S2SV_EndBug> * temperature_millicelcius = UINT_MAX ; return status_msg ( STATUS_CODE_INTERNAL_ERROR , "No<S2SV_blank>node<S2SV_blank>voltage<S2SV_blank>detected." ) ; } if ( storage -> position == PRECEEDING ) { thermistor_resistance_milliohms = <S2SV_StartBug> ( ( uint32_t ) ( vdda - reading ) ) * ( uint32_t ) SIBLING_RESISTANCE / reading * 1000 ; <S2SV_EndBug> } else { thermistor_resistance_milliohms = <S2SV_StartBug> ( ( uint32_t ) SIBLING_RESISTANCE * reading ) / ( uint32_t ) ( vdda - reading ) * 1000 ; <S2SV_EndBug> } return thermistor_calculate_temp ( thermistor_resistance_milliohms , temperature_millicelcius ) ; }
|
<S2SV_ModStart> ) ; } else <S2SV_ModStart> ( uint32_t ) FIXED_RESISTANCE_OHMS <S2SV_ModEnd> / reading * <S2SV_ModStart> ( uint32_t ) FIXED_RESISTANCE_OHMS <S2SV_ModEnd> * reading )
|
1,095
|
CWE-000 void call_three ( void ) { <S2SV_StartBug> PRINTLOG ( PRINT_DEBUG , "In<S2SV_blank>call_three()<S2SV_blank>in<S2SV_blank>pong<S2SV_blank>interface,<S2SV_blank>client:%u\\n" , cos_inv_token ( ) ) ; <S2SV_EndBug> return ; }
|
<S2SV_ModStart> ( PRINT_DEBUG , "In<S2SV_blank>call_three()<S2SV_blank>in<S2SV_blank>pong<S2SV_blank>interface,<S2SV_blank>client:%lu\\n" <S2SV_ModEnd> , cos_inv_token (
|
1,096
|
CWE-000 static uint32_t ppd42ns_pulse_in ( const ppd42ns_context dev , bool high_low_value ) { assert ( dev != NULL ) ; <S2SV_StartBug> upm_clock_t max_time ; <S2SV_EndBug> upm_clock_t pulse_time ; uint32_t total_pulse_time = 0 ; <S2SV_StartBug> upm_clock_init ( & max_time ) ; <S2SV_EndBug> bool pin_level ; bool is_timing = false ; do { pin_level = ( bool ) mraa_gpio_read ( dev -> gpio ) ; if ( ! is_timing && pin_level == high_low_value ) { <S2SV_StartBug> upm_clock_init ( & pulse_time ) ; <S2SV_EndBug> is_timing = true ; } else if ( is_timing && pin_level != high_low_value ) { total_pulse_time += upm_elapsed_us ( & pulse_time ) ; is_timing = false ; } else { upm_delay_us ( 10 ) ; } } while ( upm_elapsed_ms ( & max_time ) < 1000 ) ; if ( is_timing ) { total_pulse_time += upm_elapsed_us ( & pulse_time ) ; } return total_pulse_time ; }
|
<S2SV_ModStart> ) ; upm_clock_t <S2SV_ModEnd> pulse_time ; uint32_t <S2SV_ModStart> = 0 ; upm_clock_t max_time = upm_clock_init ( <S2SV_ModEnd> ) ; bool <S2SV_ModStart> high_low_value ) { pulse_time = upm_clock_init ( <S2SV_ModEnd> ) ; is_timing
|
1,097
|
CWE-000 job_array * ghost_create_jobs_array ( job * pjob , const char * array_id ) { job_array * pa = new job_array ( ) ; long array_size = DEFAULT_ARRAY_RECOV_SIZE ; char log_buf [ LOCAL_LOG_BUF_SIZE ] ; char file_prefix_work [ PBS_JOBBASE + 1 ] ; long slot_limit = NO_SLOT_LIMIT ; if ( LOGLEVEL >= 2 ) { snprintf ( log_buf , sizeof ( log_buf ) , "Array<S2SV_blank>%s<S2SV_blank>was<S2SV_blank>not<S2SV_blank>successfully<S2SV_blank>recovered,<S2SV_blank>but<S2SV_blank>we<S2SV_blank>are<S2SV_blank>creating<S2SV_blank>it<S2SV_blank>automatically<S2SV_blank>to<S2SV_blank>not<S2SV_blank>lose<S2SV_blank>the<S2SV_blank>sub-jobs.<S2SV_blank>Slot<S2SV_blank>limits<S2SV_blank>and<S2SV_blank>or<S2SV_blank>dependencies<S2SV_blank>may<S2SV_blank>not<S2SV_blank>work<S2SV_blank>correctly.<S2SV_blank>This<S2SV_blank>behavior<S2SV_blank>can<S2SV_blank>be<S2SV_blank>disabled<S2SV_blank>by<S2SV_blank>setting<S2SV_blank>ghost_array_recovery<S2SV_blank>to<S2SV_blank>false<S2SV_blank>in<S2SV_blank>qmgr." , array_id ) ; log_event ( PBSEVENT_JOB , PBS_EVENTCLASS_JOB , pjob -> ji_qs . ji_jobid , log_buf ) ; } lock_ai_mutex ( pa , __func__ , NULL , LOGLEVEL ) ; pa -> set_array_id ( array_id ) ; get_svr_attr_l ( SRV_ATR_MaxSlotLimit , & slot_limit ) ; pa -> ai_qs . slot_limit = slot_limit ; snprintf ( file_prefix_work , sizeof ( file_prefix_work ) , "%s" , array_id ) ; char * open = strchr ( file_prefix_work , '[' ) ; char * dot = strchr ( file_prefix_work , '.' ) ; if ( open != NULL ) { * open = '\\0' ; if ( dot != NULL ) snprintf ( pa -> ai_qs . fileprefix , sizeof ( pa -> ai_qs . fileprefix ) , "%s%s" , file_prefix_work , dot ) ; else snprintf ( pa -> ai_qs . fileprefix , sizeof ( pa -> ai_qs . fileprefix ) , "%s" , file_prefix_work ) ; } else snprintf ( pa -> ai_qs . fileprefix , sizeof ( pa -> ai_qs . fileprefix ) , "%s" , file_prefix_work ) ; pa -> set_owner ( pjob -> ji_wattr [ JOB_ATR_job_owner ] . at_val . at_str ) ; snprintf ( pa -> ai_qs . submit_host , sizeof ( pa -> ai_qs . submit_host ) , "%s" , get_variable ( pjob , pbs_o_host ) ) ; if ( pjob -> ji_wattr [ JOB_ATR_job_array_id ] . at_val . at_long > array_size ) <S2SV_StartBug> array_size = pjob -> ji_wattr [ JOB_ATR_job_array_id ] . at_val . at_long ; <S2SV_EndBug> pa -> job_ids = ( char * * ) calloc ( array_size , sizeof ( char * ) ) ; pa -> job_ids [ ( int ) pjob -> ji_wattr [ JOB_ATR_job_array_id ] . at_val . at_long ] = strdup ( pjob -> ji_qs . ji_jobid ) ; <S2SV_StartBug> pa -> ai_qs . array_size = array_size ; <S2SV_EndBug> array_save ( pa ) ; insert_array ( pa ) ; return ( pa ) ; }
|
<S2SV_ModStart> at_val . at_long + 1 <S2SV_ModStart> array_size = array_size ; pa -> ai_ghost_recovered = true
|
1,098
|
CWE-000 int main ( int argc , char * * argv ) { char * path = ( argc > 1 ) ? argv [ 1 ] : "smw.sfc" ; int dd = open ( path , O_RDONLY | O_DIRECTORY | __O_PATH ) ; DIR * dp = opendir ( path ) ; if ( ! dp ) { fprintf ( stderr , "Error:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>input<S2SV_blank>directory<S2SV_blank>\\"%s\\"\\n" , strerror ( errno ) ) ; exit ( 1 ) ; } vfs_t vfs ; vfs_init ( & vfs , 4 ) ; struct dirent * de ; while ( ( de = readdir ( dp ) ) ) { printf ( "File:<S2SV_blank>%s\\n" , de -> d_name ) ; if ( ! strcmp ( de -> d_name , "." ) ) continue ; if ( ! strcmp ( de -> d_name , ".." ) ) continue ; vfs_entry_t entry = { 0 } ; int fd = openat ( dd , de -> d_name , O_RDONLY ) ; FILE * fp = fdopen ( fd , "r" ) ; if ( ! fp ) { fprintf ( stderr , "Error:<S2SV_blank>could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>file<S2SV_blank>\\"%s\\"\\n" , de -> d_name ) ; exit ( 1 ) ; } entry . name = string_from_c_string ( basename ( de -> d_name ) ) ; fseek ( fp , 0 , SEEK_END ) ; long int file_size = ftell ( fp ) ; u8 * data = malloc ( file_size + 1 ) ; rewind ( fp ) ; fread ( data , file_size , 1 , fp ) ; fclose ( fp ) ; data [ file_size ] = 0 ; entry . buffer = ( buffer_t ) { . begin = data , . end = data + file_size } ; printf ( "%016lx<S2SV_blank>%016lx\\n" , ( u64 ) entry . buffer . begin , ( u64 ) entry . buffer . end ) ; vfs_insert ( & vfs , entry ) ; } <S2SV_StartBug> r65816_rom_t rom ; <S2SV_EndBug> <S2SV_StartBug> r65816_rom_init ( & rom , & vfs ) ; <S2SV_EndBug> smw_t smw ; <S2SV_StartBug> smw_init_all ( & smw , & rom ) ; <S2SV_EndBug> smw_deinit_all ( & smw ) ; <S2SV_StartBug> r65816_rom_free ( & rom ) ; <S2SV_EndBug> return 0 ; }
|
<S2SV_ModStart> ) ; } wdc65816_rom_t rom ; arena_t arena = arena_create ( MB ( 128 ) ) ; wdc65816_rom_init <S2SV_ModEnd> ( & rom <S2SV_ModStart> , & vfs , & arena <S2SV_ModStart> , & rom , & arena ) ; smw_deinit <S2SV_ModEnd> ( & smw <S2SV_ModStart> smw ) ; wdc65816_rom_free <S2SV_ModEnd> ( & rom
|
1,099
|
CWE-000 static void disassemble ( CELL start , CELL end ) { <S2SV_StartBug> CELL a , * p = ( CELL * ) ( M0 + start ) ; <S2SV_EndBug> BYTE i ; const char * token ; <S2SV_StartBug> while ( ( BYTE * ) p < M0 + end ) { <S2SV_EndBug> <S2SV_StartBug> printf ( "%08" PRIX32 "h:<S2SV_blank>" , ( UCELL ) ( ( BYTE * ) p - M0 ) ) ; <S2SV_EndBug> a = * p ++ ; do { i = ( BYTE ) a ; ARSHIFT ( a , 8 ) ; token = disass ( i ) ; if ( strcmp ( token , "" ) ) printf ( "%s" , token ) ; else printf ( "Undefined<S2SV_blank>instruction" ) ; if ( load_op ( i ) ) { if ( i != O_LITERAL ) printf ( "<S2SV_blank>%" PRIX32 "h" , ( UCELL ) * p ) ; else printf ( "<S2SV_blank>%" PRId32 "<S2SV_blank>(%" PRIX32 "h)" , * p , ( UCELL ) * p ) ; p ++ ; } else { if ( imm_op ( i ) ) { if ( i != O_LITERALI ) <S2SV_StartBug> printf ( "<S2SV_blank>%" PRIX32 "h" , a * 4 + ( UCELL ) ( ( BYTE * ) p - M0 ) ) ; <S2SV_EndBug> else printf ( "<S2SV_blank>%" PRId32 "<S2SV_blank>(%" PRIX32 "h)" , a , ( UCELL ) a ) ; a = 0 ; } } printf ( "\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" ) ; } while ( a != 0 && a != - 1 ) ; putchar ( '\\r' ) ; } }
|
<S2SV_ModStart> * p = <S2SV_ModEnd> M0 + start <S2SV_ModStart> M0 + start <S2SV_ModEnd> ; BYTE i <S2SV_ModStart> ; while ( <S2SV_ModEnd> p < M0 <S2SV_ModStart> ) ( ( <S2SV_ModEnd> p - M0 <S2SV_ModStart> p - M0 ) * CELL_W <S2SV_ModStart> PRIX32 "h" , ( UCELL ) ( ( p - M0 + a ) * CELL_W <S2SV_ModEnd> ) ) ;
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.