Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
5,600 | CWE-000 int main ( int argc , char * * argv ) { float dr , dtheta , dphi ; float rdim [ 2 ] , thetadim [ 2 ] , phidim [ 2 ] ; float * rVec , * thetaVec , * phiVec ; dr = 5.0 ; dtheta = 180.0 ; dphi = 180.0 ; rdim [ 0 ] = 0.0 , rdim [ 1 ] = 10.0 ; thetadim [ 0 ] = 0.0 , thetadim [ 1 ] = 360.0 ; phidim [ 0 ] = 0.0 , phidim [ 1 ] = 360.0 ; nr = numberCells ( dr , rdim ) ; ntheta = numberCells ( dtheta , thetadim ) ; nphi = numberCells ( dphi , phidim ) ; rVec = ( float * ) malloc ( sizeof ( float ) * nr ) ; thetaVec = ( float * ) malloc ( sizeof ( float ) * ntheta ) ; phiVec = ( float * ) malloc ( sizeof ( float ) * nphi ) ; setVector ( nr , dr , rdim , rVec ) ; setVector ( ntheta , dtheta , thetadim , thetaVec ) ; setVector ( nphi , dphi , phidim , phiVec ) ; perr = 0.0 ; gamma1 = 1.0 ; vGoal = 100.0 ; vObst = - 100.0 ; vMove = - 1.0 ; vInitial = 0.0 ; float * isobst , * isgoal ; isobst = ( float * ) calloc ( nr * ntheta * nphi , sizeof ( float ) ) ; isgoal = ( float * ) calloc ( nr * ntheta * nphi , sizeof ( float ) ) ; setObst ( isobst ) ; setGoal ( thetaVec , phiVec , isgoal ) ; float * J ; char * U ; J = ( float * ) calloc ( nr * ntheta * nphi , sizeof ( float ) ) ; U = ( char * ) calloc ( nr * ntheta * nphi , sizeof ( char ) ) ; setInitialValue ( isobst , isgoal , J , vObst , vGoal , vInitial ) ; setInitialPolicy ( isobst , isgoal , U ) ; <S2SV_StartBug> int T = 100 ; <S2SV_EndBug> float * Jprev ; char * Uprev ; Jprev = ( float * ) calloc ( nr * ntheta * nphi , sizeof ( float ) ) ; Uprev = ( char * ) calloc ( nr * ntheta * nphi , sizeof ( char ) ) ; memcpy ( Jprev , J , sizeof ( float ) * nr * ntheta * nphi ) ; memcpy ( Uprev , U , sizeof ( char ) * nr * ntheta * nphi ) ; for ( int t = 0 ; t < T ; t ++ ) { memcpy ( Jprev , J , sizeof ( float ) * nr * ntheta * nphi ) ; memcpy ( Uprev , U , sizeof ( char ) * nr * ntheta * nphi ) ; valueIteration ( isobst , isgoal , J , U , Jprev ) ; for ( int x = 0 ; x < nr * ntheta * nphi ; x ++ ) { printf ( "%d<S2SV_blank>J=%f<S2SV_blank>U=%d\\n" , x , J [ x ] , U [ x ] ) ; } printf ( "\\n" ) ; } return ( 0 ) ; } | <S2SV_ModStart> int T = 10 <S2SV_ModEnd> ; float * |
5,601 | CWE-000 bool listForeignServers ( const char * pattern , bool verbose ) { PQExpBufferData buf ; PGresult * res ; printQueryOpt myopt = pset . popt ; if ( pset . sversion < 80400 ) { char sverbuf [ 32 ] ; psql_error ( "The<S2SV_blank>server<S2SV_blank>(version<S2SV_blank>%s)<S2SV_blank>does<S2SV_blank>not<S2SV_blank>support<S2SV_blank>foreign<S2SV_blank>servers.\\n" , formatPGVersionNumber ( pset . sversion , false , sverbuf , sizeof ( sverbuf ) ) ) ; return true ; } initPQExpBuffer ( & buf ) ; printfPQExpBuffer ( & buf , "SELECT<S2SV_blank>s.srvname<S2SV_blank>AS<S2SV_blank>\\"%s\\",\\n" "<S2SV_blank><S2SV_blank>pg_catalog.pg_get_userbyid(s.srvowner)<S2SV_blank>AS<S2SV_blank>\\"%s\\",\\n" "<S2SV_blank><S2SV_blank>f.fdwname<S2SV_blank>AS<S2SV_blank>\\"%s\\"" , gettext_noop ( "Name" ) , gettext_noop ( "Owner" ) , gettext_noop ( "Foreign-data<S2SV_blank>wrapper" ) ) ; if ( verbose ) { appendPQExpBufferStr ( & buf , ",\\n<S2SV_blank><S2SV_blank>" ) ; printACLColumn ( & buf , "s.srvacl" ) ; appendPQExpBuffer ( & buf , ",\\n" "<S2SV_blank><S2SV_blank>s.srvtype<S2SV_blank>AS<S2SV_blank>\\"%s\\",\\n" "<S2SV_blank><S2SV_blank>s.srvversion<S2SV_blank>AS<S2SV_blank>\\"%s\\",\\n" "<S2SV_blank><S2SV_blank>CASE<S2SV_blank>WHEN<S2SV_blank>srvoptions<S2SV_blank>IS<S2SV_blank>NULL<S2SV_blank>THEN<S2SV_blank>\'\'<S2SV_blank>ELSE<S2SV_blank>" <S2SV_StartBug> "<S2SV_blank><S2SV_blank>\'(\'<S2SV_blank>||<S2SV_blank>array_to_string(ARRAY(SELECT<S2SV_blank>" <S2SV_EndBug> "<S2SV_blank><S2SV_blank>quote_ident(option_name)<S2SV_blank>||<S2SV_blank><S2SV_blank>\'<S2SV_blank>\'<S2SV_blank>||<S2SV_blank>" "<S2SV_blank><S2SV_blank>quote_literal(option_value)<S2SV_blank><S2SV_blank>FROM<S2SV_blank>" "<S2SV_blank><S2SV_blank>pg_options_to_table(srvoptions)),<S2SV_blank><S2SV_blank>\',<S2SV_blank>\')<S2SV_blank>||<S2SV_blank>\')\'<S2SV_blank>" "<S2SV_blank><S2SV_blank>END<S2SV_blank>AS<S2SV_blank>\\"%s\\",\\n" "<S2SV_blank><S2SV_blank>d.description<S2SV_blank>AS<S2SV_blank>\\"%s\\"" , gettext_noop ( "Type" ) , gettext_noop ( "Version" ) , gettext_noop ( "FDW<S2SV_blank>Options" ) , gettext_noop ( "Description" ) ) ; } appendPQExpBufferStr ( & buf , "\\nFROM<S2SV_blank>pg_catalog.pg_foreign_server<S2SV_blank>s\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>JOIN<S2SV_blank>pg_catalog.pg_foreign_data_wrapper<S2SV_blank>f<S2SV_blank>ON<S2SV_blank>f.oid=s.srvfdw\\n" ) ; if ( verbose ) appendPQExpBufferStr ( & buf , <S2SV_StartBug> "LEFT<S2SV_blank>JOIN<S2SV_blank>pg_description<S2SV_blank>d\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" <S2SV_EndBug> "ON<S2SV_blank>d.classoid<S2SV_blank>=<S2SV_blank>s.tableoid<S2SV_blank>AND<S2SV_blank>d.objoid<S2SV_blank>=<S2SV_blank>s.oid<S2SV_blank>" "AND<S2SV_blank>d.objsubid<S2SV_blank>=<S2SV_blank>0\\n" ) ; processSQLNamePattern ( pset . db , & buf , pattern , false , false , NULL , "s.srvname" , NULL , NULL ) ; appendPQExpBufferStr ( & buf , "ORDER<S2SV_blank>BY<S2SV_blank>1;" ) ; res = PSQLexec ( buf . data ) ; termPQExpBuffer ( & buf ) ; if ( ! res ) return false ; myopt . nullPrint = NULL ; myopt . title = _ ( "List<S2SV_blank>of<S2SV_blank>foreign<S2SV_blank>servers" ) ; myopt . translate_header = true ; printQuery ( res , & myopt , pset . queryFout , false , pset . logfile ) ; PQclear ( res ) ; return true ; } | <S2SV_ModStart> "<S2SV_blank><S2SV_blank>s.srvtype<S2SV_blank>AS<S2SV_blank>\\"%s\\",\\n" "<S2SV_blank><S2SV_blank>s.srvversion<S2SV_blank>AS<S2SV_blank>\\"%s\\",\\n" "<S2SV_blank><S2SV_blank>CASE<S2SV_blank>WHEN<S2SV_blank>srvoptions<S2SV_blank>IS<S2SV_blank>NULL<S2SV_blank>THEN<S2SV_blank>\'\'<S2SV_blank>ELSE<S2SV_blank>" "<S2SV_blank><S2SV_blank>\'(\'<S2SV_blank>||<S2SV_blank>pg_catalog.array_to_string(ARRAY(SELECT<S2SV_blank>" "<S2SV_blank><S2SV_blank>pg_catalog.quote_ident(option_name)<S2SV_blank>||<S2SV_blank><S2SV_blank>\'<S2SV_blank>\'<S2SV_blank>||<S2SV_blank>" "<S2SV_blank><S2SV_blank>pg_catalog.quote_literal(option_value)<S2SV_blank><S2SV_blank>FROM<S2SV_blank>" "<S2SV_blank><S2SV_blank>pg_catalog.pg_options_to_table(srvoptions)),<S2SV_blank><S2SV_blank>\',<S2SV_blank>\')<S2SV_blank>||<S2SV_blank>\')\'<S2SV_blank>" <S2SV_ModEnd> "<S2SV_blank><S2SV_blank>END<S2SV_blank>AS<S2SV_blank>\\"%s\\",\\n" "<S2SV_blank><S2SV_blank>d.description<S2SV_blank>AS<S2SV_blank>\\"%s\\"" , <S2SV_ModStart> & buf , "LEFT<S2SV_blank>JOIN<S2SV_blank>pg_catalog.pg_description<S2SV_blank>d\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" <S2SV_ModEnd> "ON<S2SV_blank>d.classoid<S2SV_blank>=<S2SV_blank>s.tableoid<S2SV_blank>AND<S2SV_blank>d.objoid<S2SV_blank>=<S2SV_blank>s.oid<S2SV_blank>" "AND<S2SV_blank>d.objsubid<S2SV_blank>=<S2SV_blank>0\\n" ) |
5,602 | CWE-000 int main ( int argc , char * argv [ ] ) { g_test_init ( & argc , & argv , NULL ) ; g_setenv ( "GIO_EXTRA_MODULES" , TOP_BUILDDIR "/proxy/gnome/.libs" , TRUE ) ; g_setenv ( "GIO_USE_PROXY_RESOLVER" , "gnome" , TRUE ) ; g_setenv ( "GSETTINGS_BACKEND" , "memory" , TRUE ) ; <S2SV_StartBug> g_setenv ( "DESKTOP_SESSION" , "gnome" , TRUE ) ; <S2SV_EndBug> g_test_add_vtable ( "/proxy/gnome/uri" , 0 , NULL , reset_proxy_settings , test_proxy_uri , NULL ) ; g_test_add_vtable ( "/proxy/gnome/socks" , 0 , NULL , reset_proxy_settings , test_proxy_socks , NULL ) ; g_test_add_vtable ( "/proxy/gnome/ignore" , 0 , NULL , reset_proxy_settings , test_proxy_ignore , NULL ) ; return g_test_run ( ) ; } | <S2SV_ModStart> ; g_setenv ( "XDG_CURRENT_DESKTOP" , "GNOME" <S2SV_ModEnd> , TRUE ) |
5,603 | CWE-000 bool recvline ( int fd , char * line , size_t len ) { char * newline = NULL ; if ( ! fd ) <S2SV_StartBug> abort ( ) ; <S2SV_EndBug> while ( ! ( newline = memchr ( buffer , '\\n' , blen ) ) ) { int result = recv ( fd , buffer + blen , sizeof buffer - blen , 0 ) ; if ( result == - 1 && sockerrno == EINTR ) continue ; else if ( result <= 0 ) return false ; blen += result ; } if ( newline - buffer >= len ) return false ; len = newline - buffer ; memcpy ( line , buffer , len ) ; line [ len ] = 0 ; memmove ( buffer , newline + 1 , blen - len - 1 ) ; blen -= len + 1 ; return true ; } | <S2SV_ModStart> ! fd ) return false <S2SV_ModEnd> ; while ( |
5,604 | CWE-000 <S2SV_StartBug> static void pbe_buffer_alloc ( void ) <S2SV_EndBug> { <S2SV_StartBug> if ( handle > 0 ) <S2SV_EndBug> return ; unsigned int total_len = ( B0_SIZE + B2_SIZE + B3_SIZE ) * 2 ; <S2SV_StartBug> handle = core_alloc ( "dsp_pbe_buffer" , sizeof ( int32_t ) * total_len ) ; <S2SV_EndBug> if ( handle < 0 ) { pbe_strength = 0 ; return ; } memset ( core_get_data ( handle ) , 0 , sizeof ( int32_t ) * total_len ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> static int <S2SV_ModEnd> pbe_buffer_alloc ( void <S2SV_ModStart> void ) { <S2SV_ModEnd> handle = core_alloc <S2SV_ModStart> ( "dsp_pbe_buffer" , PBE_BUFSIZE ) ; return handle <S2SV_ModEnd> ; } <S2SV_null> |
5,605 | CWE-000 Card get_lowest_non_trump_card ( GameInfo * game , int cards ) { Card card ; card . value = JOKER_VALUE + 1 ; card . suit = 0 ; Card * * deckSplit = malloc ( 4 * sizeof ( Card * ) ) ; int * suitCount = malloc ( 4 * sizeof ( Card ) ) ; split_deck ( game , & deckSplit , & suitCount , cards ) ; for ( Trump i = 0 ; i < 4 ; i ++ ) { if ( i == game -> suit || suitCount [ i ] == 0 ) { continue ; } if ( deckSplit [ i ] [ suitCount [ i ] - 1 ] . value < card . value ) { card = deckSplit [ i ] [ suitCount [ i ] - 1 ] ; } } <S2SV_StartBug> free ( deckSplit ) ; <S2SV_EndBug> free ( suitCount ) ; return card ; } | <S2SV_ModStart> ; } } if ( card . value == JOKER_VALUE + 1 ) { card = deckSplit [ game -> suit ] [ suitCount [ game -> suit ] - 1 ] ; } |
5,606 | CWE-000 Process * rrpSchedule ( Process * plist ) { Process * p ; int prio = 7 ; int found = 0 ; <S2SV_StartBug> while ( prio >= 0 ) { <S2SV_EndBug> p = plist ; while ( p != NULL ) { RRPrioParams * params = processGetSchedParams ( p ) ; if ( params -> prio == prio && params -> done == 0 ) { if ( processGetStatus ( p ) == PROC_READY ) { found = 1 ; params -> done = 1 ; Process * next = processGetNext ( p ) ; while ( next != NULL ) { RRPrioParams * nextParams = processGetSchedParams ( next ) ; if ( nextParams -> prio == prio ) { break ; } next = processGetNext ( next ) ; } if ( next == NULL ) { Process * undoneAll = plist ; while ( undoneAll != NULL ) { RRPrioParams * undoneParams = processGetSchedParams ( undoneAll ) ; if ( undoneParams -> prio == prio ) { undoneParams -> done = 0 ; } undoneAll = processGetNext ( undoneAll ) ; } } break ; } else { params -> done = 1 ; Process * next = processGetNext ( p ) ; while ( next != NULL ) { RRPrioParams * nextParams = processGetSchedParams ( next ) ; if ( nextParams -> prio == prio ) { break ; } next = processGetNext ( next ) ; } if ( next == NULL ) { Process * undoneAll = plist ; while ( undoneAll != NULL ) { RRPrioParams * undoneParams = processGetSchedParams ( undoneAll ) ; if ( undoneParams -> prio == prio ) { undoneParams -> done = 0 ; } undoneAll = processGetNext ( undoneAll ) ; } } } } p = processGetNext ( p ) ; } if ( found ) break ; <S2SV_StartBug> prio -- ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> return p ; } | <S2SV_ModStart> = 0 ; int chance = 0 ; <S2SV_ModStart> ) break ; if ( ! found && chance ) <S2SV_ModStart> prio -- ; else { printf ( "#<S2SV_blank>Chance<S2SV_blank>dada<S2SV_blank>#" ) ; chance = 1 ; } |
5,607 | CWE-000 <S2SV_StartBug> wrp_err_t wrp_end_of_buf ( wrp_buf_t * buf ) <S2SV_EndBug> { return ( buf -> pos == buf -> sz ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> bool <S2SV_ModEnd> wrp_end_of_buf ( wrp_buf_t |
5,608 | CWE-000 static vaddr_t __page_bump_valloc ( struct cos_compinfo * ci , size_t sz ) { <S2SV_StartBug> return __page_bump_mem_alloc ( ci , & ci -> vas_frontier , & ci -> vasrange_frontier , sz ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> sz ) { vaddr_t ret_addr = 0 ; ps_lock_take ( & ci -> va_lock ) ; ret_addr = <S2SV_ModEnd> __page_bump_mem_alloc ( ci <S2SV_ModStart> sz ) ; ps_lock_release ( & ci -> va_lock ) ; return ret_addr ; |
5,609 | CWE-000 <S2SV_StartBug> static int walk_hugetlb_range ( struct vm_area_struct * vma , <S2SV_EndBug> unsigned long addr , unsigned long end , struct mm_walk * walk ) { return 0 ; } | <S2SV_ModStart> int walk_hugetlb_range ( <S2SV_ModEnd> unsigned long addr |
5,610 | CWE-000 static gf_boolean_t afr_is_special_xattr ( const char * name , fop_getxattr_cbk_t * cbk , gf_boolean_t is_fgetxattr ) { gf_boolean_t is_spl = _gf_true ; GF_ASSERT ( cbk ) ; if ( ! cbk || ! name ) { is_spl = _gf_false ; goto out ; } if ( ! strcmp ( name , GF_XATTR_PATHINFO_KEY ) || ! strcmp ( name , GF_XATTR_USER_PATHINFO_KEY ) ) { if ( is_fgetxattr ) { * cbk = afr_fgetxattr_pathinfo_cbk ; } else { * cbk = afr_getxattr_pathinfo_cbk ; } } else if ( ! strncmp ( name , GF_XATTR_CLRLK_CMD , strlen ( GF_XATTR_CLRLK_CMD ) ) ) { if ( is_fgetxattr ) { * cbk = afr_fgetxattr_clrlk_cbk ; } else { * cbk = afr_getxattr_clrlk_cbk ; } } else if ( ! strncmp ( name , GF_XATTR_LOCKINFO_KEY , strlen ( GF_XATTR_LOCKINFO_KEY ) ) ) { if ( is_fgetxattr ) { * cbk = afr_fgetxattr_lockinfo_cbk ; } else { * cbk = afr_getxattr_lockinfo_cbk ; } } else if ( fnmatch ( GF_XATTR_STIME_PATTERN , name , FNM_NOESCAPE ) == 0 ) { * cbk = afr_common_getxattr_stime_cbk ; } else if ( strcmp ( name , QUOTA_SIZE_KEY ) == 0 ) { * cbk = afr_getxattr_quota_size_cbk ; <S2SV_StartBug> } else { <S2SV_EndBug> is_spl = _gf_false ; } out : return is_spl ; } | <S2SV_ModStart> ; } else if ( ! strcmp ( name , GF_XATTR_NODE_UUID_KEY ) ) { * cbk = afr_getxattr_node_uuid_cbk ; } else |
5,611 | CWE-000 int main ( int argc , char * argv [ ] ) { FILE * ifp ; FILE * ofp ; unsigned char * input_data ; unsigned char * output_data ; size_t input_size ; size_t output_size ; size_t partial_counter ; size_t total_counter ; <S2SV_StartBug> char * output_name ; <S2SV_EndBug> int i , j ; if ( argc == 1 ) printf ( "\\nZX7<S2SV_blank>Backwards<S2SV_blank>compressor<S2SV_blank>v1.01<S2SV_blank>by<S2SV_blank>Einar<S2SV_blank>Saukas/AntonioVillena,<S2SV_blank>28<S2SV_blank>Dec<S2SV_blank>2013\\n\\n" "<S2SV_blank><S2SV_blank>zx7b<S2SV_blank><input_file><S2SV_blank><output_file>\\n\\n" "<S2SV_blank><S2SV_blank><input_file><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Raw<S2SV_blank>input<S2SV_blank>file\\n" "<S2SV_blank><S2SV_blank><output_file><S2SV_blank><S2SV_blank><S2SV_blank>Compressed<S2SV_blank>output<S2SV_blank>file\\n\\n" "Example:<S2SV_blank>zx7b<S2SV_blank>Cobra.scr<S2SV_blank>Cobra.zx7b\\n" ) , exit ( 0 ) ; if ( argc != 3 ) printf ( "\\nInvalid<S2SV_blank>number<S2SV_blank>of<S2SV_blank>parameters\\n" ) , exit ( - 1 ) ; ifp = fopen ( argv [ 1 ] , "rb" ) ; if ( ! ifp ) fprintf ( stderr , "Error:<S2SV_blank>Cannot<S2SV_blank>access<S2SV_blank>input<S2SV_blank>file<S2SV_blank>%s\\n" , argv [ 1 ] ) , exit ( 1 ) ; fseek ( ifp , 0L , SEEK_END ) ; input_size = ftell ( ifp ) ; fseek ( ifp , 0L , SEEK_SET ) ; if ( ! input_size ) fprintf ( stderr , "Error:<S2SV_blank>Empty<S2SV_blank>input<S2SV_blank>file<S2SV_blank>%s\\n" , argv [ 1 ] ) , exit ( 1 ) ; input_data = ( unsigned char * ) malloc ( input_size ) ; if ( ! input_data ) fprintf ( stderr , "Error:<S2SV_blank>Insufficient<S2SV_blank>memory\\n" ) , exit ( 1 ) ; total_counter = 0 ; do { partial_counter = fread ( input_data + total_counter , sizeof ( char ) , input_size - total_counter , ifp ) ; total_counter += partial_counter ; } while ( partial_counter > 0 ) ; if ( total_counter != input_size ) fprintf ( stderr , "Error:<S2SV_blank>Cannot<S2SV_blank>read<S2SV_blank>input<S2SV_blank>file<S2SV_blank>%s\\n" , argv [ 1 ] ) , exit ( 1 ) ; fclose ( ifp ) ; ofp = fopen ( argv [ 2 ] , "wb" ) ; if ( ! ofp ) fprintf ( stderr , "Error:<S2SV_blank>Cannot<S2SV_blank>create<S2SV_blank>output<S2SV_blank>file<S2SV_blank>%s\\n" , argv [ 2 ] ) , exit ( 1 ) ; for ( i = 0 ; i < input_size >> 1 ; i ++ ) j = input_data [ i ] , input_data [ i ] = input_data [ input_size - 1 - i ] , input_data [ input_size - 1 - i ] = j ; output_data = compress ( optimize ( input_data , input_size ) , input_data , input_size , & output_size ) ; for ( i = 0 ; i < output_size >> 1 ; i ++ ) j = output_data [ i ] , output_data [ i ] = output_data [ output_size - 1 - i ] , output_data [ output_size - 1 - i ] = j ; if ( fwrite ( output_data , sizeof ( char ) , output_size , ofp ) != output_size ) <S2SV_StartBug> fprintf ( stderr , "Error:<S2SV_blank>Cannot<S2SV_blank>write<S2SV_blank>output<S2SV_blank>file<S2SV_blank>%s\\n" , output_name ) , <S2SV_EndBug> exit ( 1 ) ; fclose ( ofp ) ; printf ( "\\nFile<S2SV_blank>%s<S2SV_blank>compressed<S2SV_blank>from<S2SV_blank>%s<S2SV_blank>(%d<S2SV_blank>to<S2SV_blank>%d<S2SV_blank>bytes)\\n" , argv [ 2 ] , argv [ 1 ] , ( int ) input_size , ( int ) output_size ) ; return 0 ; } | <S2SV_ModStart> size_t total_counter ; <S2SV_ModEnd> int i , <S2SV_ModStart> , "Error:<S2SV_blank>Cannot<S2SV_blank>write<S2SV_blank>output<S2SV_blank>file<S2SV_blank>%s\\n" , argv [ 2 ] <S2SV_ModEnd> ) , exit |
5,612 | CWE-000 void imap_filter_sieve_context_free ( struct imap_filter_sieve_context * * _sctx ) { struct imap_filter_sieve_context * sctx = * _sctx ; struct imap_filter_sieve_script * scripts ; unsigned int i ; * _sctx = NULL ; if ( sctx == NULL ) return ; scripts = sctx -> scripts ; for ( i = 0 ; i < sctx -> scripts_count ; i ++ ) { if ( scripts [ i ] . binary != NULL ) sieve_close ( & scripts [ i ] . binary ) ; if ( scripts [ i ] . script != NULL ) sieve_script_unref ( & scripts [ i ] . script ) ; } <S2SV_StartBug> str_free ( & sctx -> errors ) ; <S2SV_EndBug> } | <S2SV_ModStart> ) ; } if ( sctx -> errors != NULL ) |
5,613 | CWE-000 int unit_adler ( int argc , char * argv [ ] ) { <S2SV_StartBug> ( void ) argc ; <S2SV_EndBug> ( void * ) argv ; RETURN_ON_ERROR ( test_init ( ) ) ; RETURN_ON_ERROR ( test_get ( ) ) ; RETURN_ON_ERROR ( test_adler_single_call ( ) ) ; RETURN_ON_ERROR ( test_adler_multi_call ( ) ) ; RETURN_ON_ERROR ( test_adler_1M_buffer ( ) ) ; return 0 ; } | <S2SV_ModStart> ] ) { UNUSED ( argc ) ; UNUSED ( argv ) <S2SV_ModEnd> ; RETURN_ON_ERROR ( |
5,614 | CWE-000 static int virHostdevRestoreNetConfig ( virDomainHostdevDefPtr hostdev , const char * stateDir , const char * oldStateDir ) { char * linkdev = NULL ; virNetDevVPortProfilePtr virtPort ; int ret = - 1 ; int vf = - 1 ; bool port_profile_associate = false ; if ( ! virHostdevIsPCINetDevice ( hostdev ) ) return 0 ; if ( virHostdevIsVirtualFunction ( hostdev ) != 1 ) { virReportError ( VIR_ERR_CONFIG_UNSUPPORTED , "%s" , _ ( "Interface<S2SV_blank>type<S2SV_blank>hostdev<S2SV_blank>is<S2SV_blank>currently<S2SV_blank>supported<S2SV_blank>on" "<S2SV_blank>SR-IOV<S2SV_blank>Virtual<S2SV_blank>Functions<S2SV_blank>only" ) ) ; return ret ; } <S2SV_StartBug> if ( virHostdevNetDevice ( hostdev , & linkdev , & vf ) < 0 ) <S2SV_EndBug> return ret ; virtPort = virDomainNetGetActualVirtPortProfile ( hostdev -> parent . data . net ) ; if ( virtPort ) { ret = virHostdevNetConfigVirtPortProfile ( linkdev , vf , virtPort , & hostdev -> parent . data . net -> mac , NULL , port_profile_associate ) ; } else { virMacAddrPtr MAC = NULL ; virMacAddrPtr adminMAC = NULL ; virNetDevVlanPtr vlan = NULL ; ret = virNetDevReadNetConfig ( linkdev , vf , stateDir , & adminMAC , & vlan , & MAC ) ; if ( ret < 0 && oldStateDir ) ret = virNetDevReadNetConfig ( linkdev , vf , oldStateDir , & adminMAC , & vlan , & MAC ) ; <S2SV_StartBug> if ( ret == 0 ) { <S2SV_EndBug> if ( MAC ) { VIR_FREE ( adminMAC ) ; adminMAC = MAC ; MAC = NULL ; } ignore_value ( virNetDevSetNetConfig ( linkdev , vf , adminMAC , vlan , MAC , true ) ) ; } VIR_FREE ( MAC ) ; VIR_FREE ( adminMAC ) ; virNetDevVlanFree ( vlan ) ; } VIR_FREE ( linkdev ) ; return ret ; } | <S2SV_ModStart> virHostdevNetDevice ( hostdev , 0 <S2SV_ModStart> if ( ret < 0 ) { VIR_FREE ( linkdev ) ; if ( virHostdevNetDevice ( hostdev , 1 , & linkdev , & vf ) >= 0 ) { ret = virNetDevReadNetConfig ( linkdev , vf , stateDir , & adminMAC , & vlan , & MAC ) ; } } if ( ret |
5,615 | CWE-000 static herr_t H5F_efc_remove_ent ( H5F_efc_t * efc , H5F_efc_ent_t * ent ) { herr_t ret_value = SUCCEED ; FUNC_ENTER_NOAPI_NOINIT HDassert ( efc ) ; HDassert ( efc -> slist ) ; HDassert ( ent ) ; if ( ent != H5SL_remove ( efc -> slist , ent -> name ) ) HGOTO_ERROR ( H5E_FILE , H5E_CANTDELETE , FAIL , "can\'t<S2SV_blank>delete<S2SV_blank>entry<S2SV_blank>from<S2SV_blank>skip<S2SV_blank>list" ) if ( ent -> LRU_next ) ent -> LRU_next -> LRU_prev = ent -> LRU_prev ; else { HDassert ( efc -> LRU_tail == ent ) ; efc -> LRU_tail = ent -> LRU_prev ; } if ( ent -> LRU_prev ) ent -> LRU_prev -> LRU_next = ent -> LRU_next ; else { HDassert ( efc -> LRU_head == ent ) ; efc -> LRU_head = ent -> LRU_next ; } efc -> nfiles -- ; if ( ent -> file -> shared -> efc ) ent -> file -> shared -> efc -> nrefs -- ; ent -> name = ( char * ) H5MM_xfree ( ent -> name ) ; ent -> file -> nopen_objs -- ; <S2SV_StartBug> if ( H5F_try_close ( ent -> file ) < 0 ) <S2SV_EndBug> HGOTO_ERROR ( H5E_FILE , H5E_CANTCLOSEFILE , FAIL , "can\'t<S2SV_blank>close<S2SV_blank>external<S2SV_blank>file" ) ent -> file = NULL ; done : FUNC_LEAVE_NOAPI ( ret_value ) } | <S2SV_ModStart> ent -> file , NULL |
5,616 | CWE-000 int getMissileType ( float missile_bearing , float missile_distance ) { float missle_heading ; int missile_type ; if ( missile_bearing > M_PI ) { missle_heading = missile_bearing - 2 * M_PI ; } if ( missile_distance <= 270 ) { <S2SV_StartBug> if ( ( - 0.1 <= missle_heading <= front_limit_pos_1 ) || ( - 1 * M_PI <= missle_heading <= back_limit_neg_1 ) ) { <S2SV_EndBug> missile_type = 1 ; } <S2SV_StartBug> else if ( ( front_limit_neg_1 <= missle_heading < 0 ) || ( back_limit_pos_1 <= missle_heading <= ( M_PI + 0.1 ) ) ) { <S2SV_EndBug> missile_type = 2 ; } else if ( ( front_limit_pos_1 < missle_heading <= front_limit_pos_2 ) || ( back_limit_neg_1 < missle_heading <= back_limit_neg_2 ) ) { missile_type = 3 ; } else if ( ( front_limit_neg_2 < missle_heading < front_limit_neg_1 ) || ( back_limit_pos_2 < missle_heading < back_limit_pos_1 ) ) { missile_type = 4 ; } else { missile_type = 5 ; } } else { if ( ( 0 <= missle_heading <= front_limit_pos_2 ) || ( - 1 * M_PI <= missle_heading <= back_limit_neg_2 ) ) { missile_type = 6 ; } else if ( ( front_limit_neg_2 <= missle_heading < 0 ) || ( back_limit_pos_2 <= missle_heading <= M_PI ) ) { missile_type = 7 ; } else { missile_type = 5 ; } } return missile_type ; } | <S2SV_ModStart> ( ( - 0.0 <S2SV_ModEnd> <= missle_heading <= <S2SV_ModStart> <= ( M_PI <S2SV_ModEnd> ) ) ) |
5,617 | CWE-000 static void help ( void ) { print_version ( ) ; puts ( "Usage:<S2SV_blank>BASICloader<S2SV_blank>[options]<S2SV_blank>[filename]" ) ; puts ( "" ) ; puts ( "<S2SV_blank><S2SV_blank>-o<S2SV_blank><S2SV_blank>--output<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Output<S2SV_blank>filename" ) ; puts ( "<S2SV_blank><S2SV_blank>-m<S2SV_blank><S2SV_blank>--machine<S2SV_blank><S2SV_blank><S2SV_blank>Target<S2SV_blank>machine<S2SV_blank>(coco/dragon/c64)" ) ; puts ( "<S2SV_blank><S2SV_blank>-f<S2SV_blank><S2SV_blank>--format<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Input<S2SV_blank>file<S2SV_blank>format<S2SV_blank>(binary/rsdos/dragon/prg)" ) ; puts ( "<S2SV_blank><S2SV_blank>-c<S2SV_blank><S2SV_blank>--case<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Output<S2SV_blank>case<S2SV_blank>(upper/lower)" ) ; puts ( "<S2SV_blank><S2SV_blank>-r<S2SV_blank><S2SV_blank>--remarks<S2SV_blank><S2SV_blank><S2SV_blank>Add<S2SV_blank>remarks<S2SV_blank>to<S2SV_blank>output<S2SV_blank>program" ) ; puts ( "<S2SV_blank><S2SV_blank>-t<S2SV_blank><S2SV_blank>--typable<S2SV_blank><S2SV_blank><S2SV_blank>Unpack<S2SV_blank>the<S2SV_blank>program<S2SV_blank>and<S2SV_blank>use<S2SV_blank>spaces" ) ; <S2SV_StartBug> puts ( "<S2SV_blank><S2SV_blank>-y<S2SV_blank><S2SV_blank>--verify<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Verify<S2SV_blank>the<S2SV_blank>success<S2SV_blank>of<S2SV_blank>each<S2SV_blank>POKE" ) ; <S2SV_EndBug> <S2SV_StartBug> puts ( "<S2SV_blank><S2SV_blank>-k<S2SV_blank><S2SV_blank>--checksum<S2SV_blank><S2SV_blank>Calculate<S2SV_blank>and<S2SV_blank>verify<S2SV_blank>checksums" ) ; <S2SV_EndBug> <S2SV_StartBug> puts ( "<S2SV_blank><S2SV_blank>-x<S2SV_blank><S2SV_blank>--extbas<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Assume<S2SV_blank>Extended<S2SV_blank>Color<S2SV_blank>BASIC<S2SV_blank>(coco<S2SV_blank>only)" ) ; <S2SV_EndBug> puts ( "<S2SV_blank><S2SV_blank>-s<S2SV_blank><S2SV_blank>--start<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Start<S2SV_blank>memory<S2SV_blank>location" ) ; puts ( "<S2SV_blank><S2SV_blank>-e<S2SV_blank><S2SV_blank>--exec<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Exec<S2SV_blank>memory<S2SV_blank>location" ) ; puts ( "<S2SV_blank><S2SV_blank>-p<S2SV_blank><S2SV_blank>--print<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Print<S2SV_blank>some<S2SV_blank>diagnostic<S2SV_blank>info" ) ; puts ( "<S2SV_blank><S2SV_blank>-n<S2SV_blank><S2SV_blank>--nowarn<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Don\'t<S2SV_blank>warn<S2SV_blank>about<S2SV_blank>RAM<S2SV_blank>requirements" ) ; puts ( "<S2SV_blank><S2SV_blank>-d<S2SV_blank><S2SV_blank>--defaults<S2SV_blank><S2SV_blank>Print<S2SV_blank>option<S2SV_blank>defaults" ) ; puts ( "<S2SV_blank><S2SV_blank>-l<S2SV_blank><S2SV_blank>--license<S2SV_blank><S2SV_blank><S2SV_blank>Your<S2SV_blank>license<S2SV_blank>to<S2SV_blank>use<S2SV_blank>these<S2SV_blank>programs" ) ; puts ( "<S2SV_blank><S2SV_blank>-i<S2SV_blank><S2SV_blank>--info<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Info<S2SV_blank>about<S2SV_blank>what<S2SV_blank>this<S2SV_blank>program<S2SV_blank>does" ) ; puts ( "<S2SV_blank><S2SV_blank>-h<S2SV_blank><S2SV_blank>--help<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>This<S2SV_blank>help<S2SV_blank>information" ) ; puts ( "<S2SV_blank><S2SV_blank>-v<S2SV_blank><S2SV_blank>--version<S2SV_blank><S2SV_blank><S2SV_blank>Version<S2SV_blank>of<S2SV_blank>this<S2SV_blank>program" ) ; puts ( "" ) ; exit ( EXIT_SUCCESS ) ; } | <S2SV_ModStart> ; puts ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--verify<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Verify<S2SV_blank>the<S2SV_blank>success<S2SV_blank>of<S2SV_blank>each<S2SV_blank>POKE" <S2SV_ModEnd> ) ; puts <S2SV_ModStart> ; puts ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--checksum<S2SV_blank><S2SV_blank>Calculate<S2SV_blank>and<S2SV_blank>verify<S2SV_blank>checksums" <S2SV_ModEnd> ) ; puts <S2SV_ModStart> ; puts ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--extbas<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Assume<S2SV_blank>Extended<S2SV_blank>Color<S2SV_blank>BASIC<S2SV_blank>(coco<S2SV_blank>only)" <S2SV_ModEnd> ) ; puts |
5,618 | CWE-000 int pam_sm_setcred ( pam_handle_t * pamh , int flags , int argc , const char * * argv ) { char keygrip [ KEYGRIP_LENGTH + 1 ] ; <S2SV_StartBug> const char * tok ; <S2SV_EndBug> <S2SV_StartBug> struct userinfo * user ; <S2SV_EndBug> struct sigaction * handlers = NULL ; FILE * file = NULL ; char * line = NULL ; size_t len = 0 ; int ret = PAM_SUCCESS ; if ( flags & PAM_DELETE_CRED ) { return PAM_SUCCESS ; } if ( pam_get_data ( pamh , "pam-gnupg-token" , ( const void * * ) & tok ) != PAM_SUCCESS || tok == NULL ) { return PAM_SUCCESS ; } if ( ! get_userinfo ( pamh , & user ) ) { return PAM_IGNORE ; } if ( ( file = open_keygrip_file ( user ) ) == NULL ) { goto end ; } setup_sigs ( & handlers ) ; if ( handlers == NULL ) { ret = PAM_IGNORE ; goto end ; } while ( getline ( & line , & len , file ) != - 1 ) { if ( ! extract_keygrip ( line , keygrip ) ) { continue ; } if ( ! preset_passphrase ( user , keygrip , tok ) ) { ret = PAM_IGNORE ; goto end ; } } pam_set_data ( pamh , "pam-gnupg-token" , NULL , NULL ) ; end : if ( file != NULL ) { fclose ( file ) ; } if ( line != NULL ) { free ( line ) ; } restore_sigs ( handlers ) ; free_userinfo ( user ) ; return ret ; } | <S2SV_ModStart> char * tok = NULL <S2SV_ModStart> userinfo * user = NULL |
5,619 | CWE-000 int htt_h2t_dbg_stats_get ( struct htt_pdev_t * pdev , u_int32_t stats_type_upload_mask , u_int32_t stats_type_reset_mask , u_int8_t cfg_stat_type , u_int32_t cfg_val , <S2SV_StartBug> u_int64_t cookie ) <S2SV_EndBug> { struct htt_htc_pkt * pkt ; adf_nbuf_t msg ; u_int32_t * msg_word ; uint16_t htc_tag = 1 ; int tx_credit_availablity = A_EINVAL ; if ( ( pdev -> cfg . is_high_latency ) && ( ! pdev -> cfg . default_tx_comp_req ) ) { tx_credit_availablity = ol_tx_target_credit_dec ( pdev -> txrx_pdev , 1 ) ; if ( tx_credit_availablity == A_ERROR ) { return A_ERROR ; } } pkt = htt_htc_pkt_alloc ( pdev ) ; if ( ! pkt ) { if ( tx_credit_availablity == A_OK ) { ol_tx_target_credit_update ( pdev -> txrx_pdev , 1 ) ; } return A_ERROR ; } if ( stats_type_upload_mask >= 1 << HTT_DBG_NUM_STATS || stats_type_reset_mask >= 1 << HTT_DBG_NUM_STATS ) { adf_os_print ( "%#x<S2SV_blank>%#x<S2SV_blank>stats<S2SV_blank>not<S2SV_blank>supported\\n" , stats_type_upload_mask , stats_type_reset_mask ) ; htt_htc_pkt_free ( pdev , pkt ) ; if ( tx_credit_availablity == A_OK ) { ol_tx_target_credit_update ( pdev -> txrx_pdev , 1 ) ; } return A_ERROR ; } if ( stats_type_reset_mask ) htc_tag = HTC_TX_PACKET_TAG_RUNTIME_PUT ; pkt -> msdu_id = HTT_TX_COMPL_INV_MSDU_ID ; pkt -> pdev_ctxt = NULL ; msg = adf_nbuf_alloc ( pdev -> osdev , HTT_MSG_BUF_SIZE ( HTT_H2T_STATS_REQ_MSG_SZ ) , HTC_HEADER_LEN + HTC_HDR_ALIGNMENT_PADDING , 4 , FALSE ) ; if ( ! msg ) { htt_htc_pkt_free ( pdev , pkt ) ; if ( tx_credit_availablity == A_OK ) { ol_tx_target_credit_update ( pdev -> txrx_pdev , 1 ) ; } return A_ERROR ; } adf_nbuf_put_tail ( msg , HTT_H2T_STATS_REQ_MSG_SZ ) ; msg_word = ( u_int32_t * ) adf_nbuf_data ( msg ) ; adf_nbuf_push_head ( msg , HTC_HDR_ALIGNMENT_PADDING ) ; * msg_word = 0 ; HTT_H2T_MSG_TYPE_SET ( * msg_word , HTT_H2T_MSG_TYPE_STATS_REQ ) ; HTT_H2T_STATS_REQ_UPLOAD_TYPES_SET ( * msg_word , stats_type_upload_mask ) ; msg_word ++ ; * msg_word = 0 ; HTT_H2T_STATS_REQ_RESET_TYPES_SET ( * msg_word , stats_type_reset_mask ) ; msg_word ++ ; * msg_word = 0 ; HTT_H2T_STATS_REQ_CFG_VAL_SET ( * msg_word , cfg_val ) ; HTT_H2T_STATS_REQ_CFG_STAT_TYPE_SET ( * msg_word , cfg_stat_type ) ; msg_word ++ ; <S2SV_StartBug> * msg_word = cookie & 0xffffffff ; <S2SV_EndBug> msg_word ++ ; <S2SV_StartBug> * msg_word = cookie >> 32 ; <S2SV_EndBug> SET_HTC_PACKET_INFO_TX ( & pkt -> htc_pkt , htt_h2t_send_complete_free_netbuf , adf_nbuf_data ( msg ) , adf_nbuf_len ( msg ) , pdev -> htc_endpoint , htc_tag ) ; SET_HTC_PACKET_NET_BUF_CONTEXT ( & pkt -> htc_pkt , msg ) ; # ifdef ATH_11AC_TXCOMPACT if ( HTCSendPkt ( pdev -> htc_pdev , & pkt -> htc_pkt ) == A_OK ) { htt_htc_misc_pkt_list_add ( pdev , pkt ) ; } # else HTCSendPkt ( pdev -> htc_pdev , & pkt -> htc_pkt ) ; # endif return 0 ; } | <S2SV_ModStart> u_int32_t cfg_val , u_int8_t <S2SV_ModEnd> cookie ) { <S2SV_ModStart> msg_word = cookie <S2SV_ModEnd> ; msg_word ++ <S2SV_ModStart> * msg_word = 0 <S2SV_ModEnd> ; SET_HTC_PACKET_INFO_TX ( |
5,620 | CWE-000 GENERATOR ( points_gen_prime ) { <S2SV_StartBug> GEN primes = subgroups_prime ( curve -> order , cfg ) ; <S2SV_EndBug> <S2SV_StartBug> return points_from_orders ( curve , cfg , primes ) ; <S2SV_EndBug> } | <S2SV_ModStart> subgroups_prime ( curve <S2SV_ModEnd> , cfg ) <S2SV_ModStart> ( curve , <S2SV_ModEnd> primes ) ; |
5,621 | CWE-000 int main ( int argc , char * argv [ ] ) { char * buf = memalign16 ( 5 ) ; buf [ 0 ] = 'a' ; buf [ 1 ] = 'b' ; buf [ 2 ] = 'c' ; buf [ 3 ] = 'd' ; buf [ 4 ] = '\\0' ; if ( aligned_strlen ( buf ) == 4 ) foo ( 44 ) ; buf [ 4 ] = 'x' ; if ( aligned_strlen ( buf ) == 0 ) foo ( 37 ) ; free ( buf ) ; <S2SV_StartBug> UWord * words = malloc ( 3 * sizeof ( UWord ) ) ; <S2SV_EndBug> free ( words ) ; <S2SV_StartBug> UWord w = words [ 1 ] ; <S2SV_EndBug> if ( w == 0x31415927 ) { fprintf ( stderr , "Elvis<S2SV_blank>is<S2SV_blank>alive<S2SV_blank>and<S2SV_blank>well<S2SV_blank>and<S2SV_blank>living<S2SV_blank>in<S2SV_blank>Milton<S2SV_blank>Keynes.\\n" ) ; } return 0 ; } | <S2SV_ModStart> buf ) ; RegWord <S2SV_ModEnd> * words = <S2SV_ModStart> * sizeof ( RegWord <S2SV_ModEnd> ) ) ; <S2SV_ModStart> words ) ; RegWord <S2SV_ModEnd> w = words |
5,622 | CWE-000 int platform_send_audio_calibration ( void * platform , snd_device_t snd_device ) { struct platform_data * my_data = ( struct platform_data * ) platform ; int acdb_dev_id , acdb_dev_type ; int sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE ; acdb_dev_id = acdb_device_table [ audio_extn_get_spkr_prot_snd_device ( snd_device ) ] ; if ( acdb_dev_id < 0 ) { ALOGE ( "%s:<S2SV_blank>Could<S2SV_blank>not<S2SV_blank>find<S2SV_blank>acdb<S2SV_blank>id<S2SV_blank>for<S2SV_blank>device(%d)" , __func__ , snd_device ) ; return - EINVAL ; } ALOGV ( "%s:<S2SV_blank>sending<S2SV_blank>audio<S2SV_blank>calibration<S2SV_blank>for<S2SV_blank>snd_device(%d)<S2SV_blank>acdb_id(%d)" , __func__ , snd_device , acdb_dev_id ) ; if ( snd_device >= SND_DEVICE_OUT_BEGIN && snd_device < SND_DEVICE_OUT_END ) acdb_dev_type = ACDB_DEV_TYPE_OUT ; else acdb_dev_type = ACDB_DEV_TYPE_IN ; <S2SV_StartBug> if ( ( my_data -> acdb_send_audio_cal_v3 ) && <S2SV_EndBug> ( snd_device == SND_DEVICE_IN_VOICE_SPEAKER_MIC_HFP ) && ! audio_extn_tfa_98xx_is_supported ( ) ) { my_data -> acdb_send_audio_cal_v3 ( acdb_dev_id , ACDB_DEV_TYPE_IN , DEFAULT_APP_TYPE_TX_PATH , sample_rate , BUFF_IDX_0 ) ; my_data -> acdb_send_audio_cal_v3 ( acdb_dev_id , ACDB_DEV_TYPE_OUT , DEFAULT_APP_TYPE_RX_PATH , sample_rate , BUFF_IDX_0 ) ; } else if ( ( my_data -> acdb_send_audio_cal_v3 ) && ( snd_device == SND_DEVICE_OUT_VOICE_SPEAKER_HFP ) && ! audio_extn_tfa_98xx_is_supported ( ) ) { ALOGV ( "%s:<S2SV_blank>sending<S2SV_blank>audio<S2SV_blank>calibration<S2SV_blank>for<S2SV_blank>snd_device(%d)<S2SV_blank>acdb_id(%d)" , __func__ , snd_device , acdb_dev_id ) ; my_data -> acdb_send_audio_cal_v3 ( acdb_dev_id , ACDB_DEV_TYPE_IN , DEFAULT_APP_TYPE_TX_PATH , sample_rate , BUFF_IDX_1 ) ; my_data -> acdb_send_audio_cal_v3 ( acdb_dev_id , ACDB_DEV_TYPE_OUT , DEFAULT_APP_TYPE_RX_PATH , sample_rate , BUFF_IDX_1 ) ; <S2SV_StartBug> } else if ( my_data -> acdb_send_audio_cal ) { <S2SV_EndBug> my_data -> acdb_send_audio_cal ( acdb_dev_id , acdb_dev_type ) ; <S2SV_StartBug> } <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> ; if ( <S2SV_ModEnd> my_data -> acdb_send_audio_cal <S2SV_ModStart> -> acdb_send_audio_cal ) <S2SV_ModEnd> my_data -> acdb_send_audio_cal <S2SV_ModStart> acdb_dev_type ) ; <S2SV_ModEnd> return 0 ; |
5,623 | CWE-000 void odp_key_to_pkt_metadata ( const struct nlattr * key , size_t key_len , struct pkt_metadata * md ) { const struct nlattr * nla ; size_t left ; uint32_t wanted_attrs = 1u << OVS_KEY_ATTR_PRIORITY | 1u << OVS_KEY_ATTR_SKB_MARK | 1u << OVS_KEY_ATTR_TUNNEL | <S2SV_StartBug> 1u << OVS_KEY_ATTR_IN_PORT ; <S2SV_EndBug> pkt_metadata_init ( md , ODPP_NONE ) ; NL_ATTR_FOR_EACH ( nla , left , key , key_len ) { uint16_t type = nl_attr_type ( nla ) ; size_t len = nl_attr_get_size ( nla ) ; int expected_len = odp_key_attr_len ( ovs_flow_key_attr_lens , OVS_KEY_ATTR_MAX , type ) ; if ( len != expected_len && expected_len >= 0 ) { continue ; } switch ( type ) { case OVS_KEY_ATTR_RECIRC_ID : md -> recirc_id = nl_attr_get_u32 ( nla ) ; wanted_attrs &= ~ ( 1u << OVS_KEY_ATTR_RECIRC_ID ) ; break ; case OVS_KEY_ATTR_DP_HASH : md -> dp_hash = nl_attr_get_u32 ( nla ) ; wanted_attrs &= ~ ( 1u << OVS_KEY_ATTR_DP_HASH ) ; break ; case OVS_KEY_ATTR_PRIORITY : md -> skb_priority = nl_attr_get_u32 ( nla ) ; wanted_attrs &= ~ ( 1u << OVS_KEY_ATTR_PRIORITY ) ; break ; case OVS_KEY_ATTR_SKB_MARK : md -> pkt_mark = nl_attr_get_u32 ( nla ) ; wanted_attrs &= ~ ( 1u << OVS_KEY_ATTR_SKB_MARK ) ; break ; case OVS_KEY_ATTR_CT_STATE : md -> ct_state = odp_to_ovs_ct_state ( nl_attr_get_u32 ( nla ) ) ; wanted_attrs &= ~ ( 1u << OVS_KEY_ATTR_CT_STATE ) ; break ; case OVS_KEY_ATTR_CT_ZONE : md -> ct_zone = nl_attr_get_u16 ( nla ) ; wanted_attrs &= ~ ( 1u << OVS_KEY_ATTR_CT_ZONE ) ; break ; case OVS_KEY_ATTR_CT_MARK : md -> ct_mark = nl_attr_get_u32 ( nla ) ; wanted_attrs &= ~ ( 1u << OVS_KEY_ATTR_CT_MARK ) ; break ; case OVS_KEY_ATTR_CT_LABELS : { const ovs_u128 * cl = nl_attr_get ( nla ) ; md -> ct_label = * cl ; wanted_attrs &= ~ ( 1u << OVS_KEY_ATTR_CT_LABELS ) ; break ; } case OVS_KEY_ATTR_TUNNEL : { enum odp_key_fitness res ; res = odp_tun_key_from_attr ( nla , true , & md -> tunnel ) ; if ( res == ODP_FIT_ERROR ) { memset ( & md -> tunnel , 0 , sizeof md -> tunnel ) ; } else if ( res == ODP_FIT_PERFECT ) { wanted_attrs &= ~ ( 1u << OVS_KEY_ATTR_TUNNEL ) ; } break ; } case OVS_KEY_ATTR_IN_PORT : md -> in_port . odp_port = nl_attr_get_odp_port ( nla ) ; wanted_attrs &= ~ ( 1u << OVS_KEY_ATTR_IN_PORT ) ; break ; default : break ; } if ( ! wanted_attrs ) { return ; } } } | <S2SV_ModStart> 1u << OVS_KEY_ATTR_IN_PORT | 1u << OVS_KEY_ATTR_CT_STATE | 1u << OVS_KEY_ATTR_CT_ZONE | 1u << OVS_KEY_ATTR_CT_MARK | 1u << OVS_KEY_ATTR_CT_LABELS |
5,624 | CWE-000 double chi2_NonLocRSPk ( double * params , int Nparams , struct DataNonLocPk * gal , struct DataNonLocPk * data , struct LinNonLocPk * lin ) { double b1 , b2 ; double bs2 , b3nl ; b1 = params [ 0 ] ; b2 = params [ 1 ] ; bs2 = ( - 4.0 / 7.0 ) * ( b1 - 1.0 ) ; b3nl = ( 32.0 / 315.0 ) * ( b1 - 1.0 ) ; int i ; int Nktab = 150 ; double * ktab = allocate_double_vector ( Nktab ) ; double * Pb2delta = allocate_double_vector ( Nktab ) ; double * Pbs2delta = allocate_double_vector ( Nktab ) ; double * Pb2s2delta = allocate_double_vector ( Nktab ) ; double * Pbs22delta = allocate_double_vector ( Nktab ) ; double * Pb22delta = allocate_double_vector ( Nktab ) ; double * Sigma_2_3 = allocate_double_vector ( Nktab ) ; for ( i = 0 ; i < Nktab ; i ++ ) { <S2SV_StartBug> Pb2delta [ i ] = compute_cquad ( ktab [ i ] , & Pb2delta_r_integrand , lin ) ; <S2SV_EndBug> Pbs2delta [ i ] = compute_cquad ( ktab [ i ] , & Pbs2delta_r_integrand , lin ) ; Pb2s2delta [ i ] = compute_cquad ( ktab [ i ] , & Pb2s2delta_r_integrand , lin ) ; Pbs22delta [ i ] = compute_cquad ( ktab [ i ] , & Pbs22delta_r_integrand , lin ) ; Pb22delta [ i ] = compute_cquad ( ktab [ i ] , & Pb22delta_r_integrand , lin ) ; Sigma_2_3 [ i ] = compute_cquad ( ktab [ i ] , & Sigma_2_3_r_integrand , lin ) ; } if ( status != SUCCESS ) return - 1 ; double Mod ; double diff ; double chi2 = 0.0 ; for ( i = 0 ; i < data -> Nk ; i ++ ) { Mod = b1 * b1 * data -> pk [ i ] + 2.0 * b1 * b2 * PSPL ( data -> k [ i ] , ktab , Pb2delta , Nktab ) + 2.0 * bs2 * b1 * PSPL ( data -> k [ i ] , ktab , Pbs2delta , Nktab ) + b2 * b2 * PSPL ( data -> k [ i ] , ktab , Pb22delta , Nktab ) + 2.0 * b2 * bs2 * PSPL ( data -> k [ i ] , ktab , Pb2s2delta , Nktab ) + bs2 * bs2 * PSPL ( data -> k [ i ] , ktab , Pbs22delta , Nktab ) <S2SV_StartBug> + 2.0 * b1 * b3nl * PSPL ( data -> k [ i ] , ktab , Sigma_2_3 , Nktab ) * P_at_k ( data -> k [ i ] , lin ) ; <S2SV_EndBug> diff = ( gal -> pk [ i ] - Mod ) / gal -> err [ i ] ; chi2 += diff * diff ; } <S2SV_StartBug> if ( ! check_for_nan_and_inf ( chi2 , "Cole05pk<S2SV_blank>chi2" ) ) return - 1 ; <S2SV_EndBug> # ifdef DEBUG printf ( "chi2<S2SV_blank>=<S2SV_blank>%e\\n" , chi2 ) ; # endif free ( ktab ) ; free ( Pb2delta ) ; free ( Pbs2delta ) ; free ( Pb2s2delta ) ; free ( Pbs22delta ) ; free ( Pb22delta ) ; free ( Sigma_2_3 ) ; return chi2 ; } | <S2SV_ModStart> ++ ) { ktab [ i ] = exp ( log ( 1e-4 ) + i * log ( 2.0 / 1e-4 ) / ( double ) ( Nktab - 1 ) ) ; <S2SV_ModStart> Nktab ) * PSPL ( data -> k [ i ] , lin -> k , lin -> pk , lin -> Nk <S2SV_ModEnd> ) ; diff <S2SV_ModStart> ( chi2 , "NonLocalBias<S2SV_blank>RS<S2SV_blank>chi2" <S2SV_ModEnd> ) ) return |
5,625 | CWE-000 s32 spi_MOSI_init ( u32 spi_id ) { u32 Register = 0x22A0 ; if ( spi_id == 1 ) { Xil_Out32 ( XSLCR_MOSI_SPI_1_ADDR , Register ) ; Register = Xil_In32 ( XSLCR_MOSI_SPI_1_ADDR ) ; <S2SV_StartBug> xil_printf ( "address<S2SV_blank>0x%08x<S2SV_blank>:<S2SV_blank>0x%08x\\r\\n" , XSLCR_MOSI_SPI_1_ADDR , Register ) ; <S2SV_EndBug> return XST_SUCCESS ; } else if ( spi_id == 0 ) { Xil_Out32 ( XSLCR_MOSI_SPI_0_ADDR , Register ) ; Register = Xil_In32 ( XSLCR_MOSI_SPI_0_ADDR ) ; <S2SV_StartBug> xil_printf ( "address<S2SV_blank>0x%08x<S2SV_blank>:<S2SV_blank>0x%08x\\r\\n" , XSLCR_MOSI_SPI_0_ADDR , Register ) ; <S2SV_EndBug> return XST_SUCCESS ; } else { <S2SV_StartBug> xil_printf ( "spi_id<S2SV_blank>error!\\r\\n" ) ; <S2SV_EndBug> return XST_FAILURE ; } } | <S2SV_ModStart> XSLCR_MOSI_SPI_1_ADDR ) ; <S2SV_ModEnd> return XST_SUCCESS ; <S2SV_ModStart> XSLCR_MOSI_SPI_0_ADDR ) ; <S2SV_ModEnd> return XST_SUCCESS ; <S2SV_ModStart> } else { Print_Err <S2SV_ModEnd> ( "spi_id<S2SV_blank>error!\\r\\n" ) |
5,626 | CWE-000 static void xfocus ( XEvent * e ) { if ( X . xic ) ( e -> type == FocusIn ? XSetICFocus : XUnsetICFocus ) ( X . xic ) ; <S2SV_StartBug> Buf * buf = win_buf ( EDIT ) ; <S2SV_EndBug> } | <S2SV_ModStart> xic ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
5,627 | CWE-000 static bool IsRequestFromDevOwner ( SRMRequestContext_t * context ) { bool retVal = false ; OicSecDoxm_t * doxm = NULL ; if ( NULL == context ) { return false ; } if ( IsNilUuid ( & context -> subjectUuid ) ) { retVal = false ; goto exit ; } doxm = ( OicSecDoxm_t * ) GetDoxmResourceData ( ) ; if ( doxm ) { retVal = UuidCmp ( & doxm -> owner , & context -> subjectUuid ) ; if ( ! retVal ) { OIC_LOG ( DEBUG , TAG , "Owner<S2SV_blank>UUID<S2SV_blank><S2SV_blank>:" ) ; <S2SV_StartBug> OIC_LOG_BUFFER ( DEBUG , TAG , ( const uint8_t * ) & doxm -> owner . id , sizeof ( & doxm -> owner . id ) ) ; <S2SV_EndBug> OIC_LOG ( DEBUG , TAG , "Request<S2SV_blank>UUID:" ) ; <S2SV_StartBug> OIC_LOG_BUFFER ( DEBUG , TAG , ( const uint8_t * ) & context -> subjectUuid . id , sizeof ( & context -> subjectUuid . id ) ) ; <S2SV_EndBug> } } exit : OIC_LOG_V ( DEBUG , TAG , "%s:<S2SV_blank>request<S2SV_blank>was<S2SV_blank>%sreceived<S2SV_blank>from<S2SV_blank>device<S2SV_blank>owner" , __func__ , retVal ? "" : "NOT<S2SV_blank>" ) ; return retVal ; } | <S2SV_ModStart> , sizeof ( OicUuid_t <S2SV_ModEnd> ) ) ; <S2SV_ModStart> , sizeof ( OicUuid_t <S2SV_ModEnd> ) ) ; |
5,628 | CWE-000 void restore_resume_state ( void ) { DB_output_t * output = plug_get_output ( ) ; <S2SV_StartBug> if ( conf_get_int ( "resume_last_session" , 0 ) && output -> state ( ) == OUTPUT_STATE_STOPPED ) { <S2SV_EndBug> int plt = conf_get_int ( "resume.playlist" , - 1 ) ; int track = conf_get_int ( "resume.track" , - 1 ) ; float pos = conf_get_float ( "resume.position" , - 1 ) ; int paused = conf_get_int ( "resume.paused" , 0 ) ; trace ( "resume:<S2SV_blank>track<S2SV_blank>%d<S2SV_blank>pos<S2SV_blank>%f<S2SV_blank>playlist<S2SV_blank>%d\\n" , track , pos , plt ) ; if ( plt >= 0 && track >= 0 && pos >= 0 ) { <S2SV_StartBug> streamer_lock ( ) ; <S2SV_EndBug> <S2SV_StartBug> streamer_set_current_playlist ( plt ) ; <S2SV_EndBug> streamer_set_nextsong ( track , paused ? 2 : 3 ) ; <S2SV_StartBug> streamer_set_seek ( pos ) ; <S2SV_EndBug> <S2SV_StartBug> streamer_unlock ( ) ; <S2SV_EndBug> } } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ( "resume_last_session" , 1 <S2SV_ModEnd> ) && output <S2SV_ModStart> 0 ) { output -> pause <S2SV_ModEnd> ( ) ; <S2SV_ModStart> streamer_set_current_playlist ( plt ) ; streamer_yield ( <S2SV_ModStart> 3 ) ; streamer_yield ( ) ; <S2SV_ModStart> pos ) ; streamer_yield ( ) ; if ( ! paused ) { output -> play <S2SV_ModEnd> ( ) ; <S2SV_ModStart> } } } } |
5,629 | CWE-000 void enableRawMode ( ) { <S2SV_StartBug> tcgetattr ( STDIN_FILENO , & orig_termios ) ; <S2SV_EndBug> atexit ( disableRawMode ) ; struct termios raw = orig_termios ; raw . c_lflag &= ~ ( ECHO | ICANON | ISIG | IEXTEN ) ; raw . c_oflag &= ~ ( OPOST ) ; raw . c_iflag &= ~ ( BRKINT | ICRNL | INPCK | ISTRIP | IXON ) ; raw . c_cflag |= ( CS8 ) ; raw . c_cc [ VMIN ] = 0 ; raw . c_cc [ VTIME ] = 1 ; <S2SV_StartBug> tcsetattr ( STDIN_FILENO , TCSAFLUSH , & raw ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( ) { if ( <S2SV_ModStart> & orig_termios ) == - 1 ) { die ( "tcgetattr" ) ; } <S2SV_ModEnd> atexit ( disableRawMode <S2SV_ModStart> = 1 ; if ( <S2SV_ModStart> & raw ) == - 1 ) { die ( "tcsetattr" ) ; } } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
5,630 | CWE-000 void set_default_action_ue_selector_table ( ) { char buffer [ 2048 ] ; struct p4_header * h ; struct p4_set_default_action * sda ; struct p4_action * a ; printf ( "Generate<S2SV_blank>set_default_action<S2SV_blank>message<S2SV_blank>for<S2SV_blank>table<S2SV_blank>ue_lpm<S2SV_blank>table\\n" ) ; h = create_p4_header ( buffer , 0 , sizeof ( buffer ) ) ; sda = create_p4_set_default_action ( buffer , 0 , sizeof ( buffer ) ) ; strcpy ( sda -> table_name , "ue_selector" ) ; a = & ( sda -> action ) ; <S2SV_StartBug> strcpy ( a -> description . name , "drop" ) ; <S2SV_EndBug> netconv_p4_header ( h ) ; netconv_p4_set_default_action ( sda ) ; netconv_p4_action ( a ) ; send_p4_msg ( c , buffer , sizeof ( buffer ) ) ; } | <S2SV_ModStart> . name , "MyIngressdrop" <S2SV_ModEnd> ) ; netconv_p4_header |
5,631 | CWE-000 static Direction get_optimal_move_towards ( Monster * m , RoomMatrix * rm , const Position * dest ) { int x_dist , y_dist ; Position mPos ; mPos = position_to_matrix_coords ( & m -> sprite -> pos ) ; unsigned int currentScore = 100 ; unsigned int chosenDirection = UP ; for ( unsigned int i = 0 ; i < 4 ; ++ i ) { Position next = mPos ; unsigned int nextScore = 0 ; switch ( i ) { case UP : next . y -= 1 ; break ; case DOWN : next . y += 1 ; break ; case LEFT : next . x -= 1 ; break ; case RIGHT : next . x += 1 ; break ; } if ( position_equals ( & next , dest ) ) { chosenDirection = ( Direction ) i ; break ; } if ( ! position_in_roommatrix ( & next ) ) continue ; x_dist = abs ( next . x - dest -> x ) ; y_dist = abs ( next . y - dest -> y ) ; <S2SV_StartBug> if ( rm -> spaces [ next . x ] [ next . y ] . occupied || rm -> spaces [ next . x ] [ next . y ] . lethal ) { <S2SV_EndBug> nextScore += 50 ; } nextScore += x_dist > y_dist ? x_dist : y_dist ; if ( nextScore < currentScore ) { currentScore = nextScore ; chosenDirection = ( Direction ) i ; } } return chosenDirection ; } | <S2SV_ModStart> ] . lethal || rm -> spaces [ next . x ] [ next . y ] . trap |
5,632 | CWE-000 bool irq_work_needs_cpu ( void ) { struct llist_head * raised , * lazy ; raised = this_cpu_ptr ( & raised_list ) ; lazy = this_cpu_ptr ( & lazy_list ) ; <S2SV_StartBug> if ( llist_empty_relaxed ( raised ) || arch_irq_work_has_interrupt ( ) ) <S2SV_EndBug> if ( llist_empty ( lazy ) ) return false ; WARN_ON_ONCE ( cpu_is_offline ( smp_processor_id ( ) ) ) ; return true ; } | <S2SV_ModStart> ( llist_empty_relaxed ( this_list <S2SV_ModEnd> ) ) return |
5,633 | CWE-000 void parseInputArgsForConnectParams ( int argc , char * * argv ) { int opt ; while ( - 1 != ( opt = getopt ( argc , argv , "h:p:c:x:" ) ) ) { switch ( opt ) { case 'h' : <S2SV_StartBug> strcpy ( HostAddress , optarg ) ; <S2SV_EndBug> IOT_DEBUG ( "Host<S2SV_blank>%s" , optarg ) ; break ; case 'p' : port = atoi ( optarg ) ; IOT_DEBUG ( "arg<S2SV_blank>%s" , optarg ) ; break ; case 'c' : <S2SV_StartBug> strcpy ( certDirectory , optarg ) ; <S2SV_EndBug> IOT_DEBUG ( "cert<S2SV_blank>root<S2SV_blank>directory<S2SV_blank>%s" , optarg ) ; break ; case 'x' : publishCount = atoi ( optarg ) ; IOT_DEBUG ( "publish<S2SV_blank>%s<S2SV_blank>times\\n" , optarg ) ; break ; case '?' : if ( optopt == 'c' ) { IOT_ERROR ( "Option<S2SV_blank>-%c<S2SV_blank>requires<S2SV_blank>an<S2SV_blank>argument." , optopt ) ; } else if ( isprint ( optopt ) ) { IOT_WARN ( "Unknown<S2SV_blank>option<S2SV_blank>`-%c\'." , optopt ) ; } else { IOT_WARN ( "Unknown<S2SV_blank>option<S2SV_blank>character<S2SV_blank>`\\\\x%x\'." , optopt ) ; } break ; default : IOT_ERROR ( "Error<S2SV_blank>in<S2SV_blank>command<S2SV_blank>line<S2SV_blank>argument<S2SV_blank>parsing" ) ; break ; } } } | <S2SV_ModStart> case 'h' : strncpy <S2SV_ModEnd> ( HostAddress , <S2SV_ModStart> HostAddress , optarg , HOST_ADDRESS_SIZE <S2SV_ModStart> case 'c' : strncpy <S2SV_ModEnd> ( certDirectory , <S2SV_ModStart> certDirectory , optarg , PATH_MAX + 1 |
5,634 | CWE-000 static gboolean ufo_device_info_task_process ( UfoTask * task , UfoBuffer * * inputs , UfoBuffer * output , UfoRequisition * requisition ) { cl_platform_id platform_id ; cl_device_id device_id = 0 ; cl_uint work_item_dim ; size_t work_item_sizes [ 3 ] ; size_t work_group_size ; cl_ulong local_mem_size ; cl_uint max_compute_units ; clGetPlatformIDs ( 1 , & platform_id , NULL ) ; clGetDeviceIDs ( platform_id , CL_DEVICE_TYPE_GPU , 1 , & device_id , NULL ) ; clGetDeviceInfo ( device_id , CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS , sizeof ( cl_uint ) , & work_item_dim , NULL ) ; clGetDeviceInfo ( device_id , CL_DEVICE_MAX_WORK_ITEM_SIZES , sizeof ( work_item_sizes ) , work_item_sizes , NULL ) ; clGetDeviceInfo ( device_id , CL_DEVICE_MAX_WORK_GROUP_SIZE , sizeof ( size_t ) , & work_group_size , NULL ) ; clGetDeviceInfo ( device_id , CL_DEVICE_LOCAL_MEM_SIZE , sizeof ( cl_ulong ) , & local_mem_size , NULL ) ; clGetDeviceInfo ( device_id , CL_DEVICE_MAX_COMPUTE_UNITS , sizeof ( cl_uint ) , & max_compute_units , NULL ) ; <S2SV_StartBug> g_message ( "device<S2SV_blank>id:<S2SV_blank>%u" , device_id ) ; <S2SV_EndBug> g_message ( "work_item_dim:<S2SV_blank>%d" , work_item_dim ) ; <S2SV_StartBug> g_message ( "work_item_sizes:<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d" , work_item_sizes [ 0 ] , work_item_sizes [ 1 ] , work_item_sizes [ 2 ] ) ; <S2SV_EndBug> <S2SV_StartBug> g_message ( "work_group_size:<S2SV_blank>%d" , work_group_size ) ; <S2SV_EndBug> g_message ( "local_mem_size:<S2SV_blank>%lu" , local_mem_size ) ; g_message ( "maximum<S2SV_blank>compute<S2SV_blank>units:<S2SV_blank>%u" , max_compute_units ) ; return TRUE ; } | <S2SV_ModStart> ; g_message ( "device<S2SV_blank>id:<S2SV_blank>%p" , ( gpointer ) <S2SV_ModEnd> device_id ) ; <S2SV_ModStart> ; g_message ( "work_item_sizes:<S2SV_blank>%zu<S2SV_blank>%zu<S2SV_blank>%zu" <S2SV_ModEnd> , work_item_sizes [ <S2SV_ModStart> ; g_message ( "work_group_size:<S2SV_blank>%zu" <S2SV_ModEnd> , work_group_size ) |
5,635 | CWE-000 int read_network ( const char * chem_file , net_t * network , const int verbose ) { FILE * f ; char line [ MAX_LINE ] ; char chem_file1 [ MAX_LINE ] ; strcpy ( chem_file1 , chem_file ) ; f = fopen ( chem_file1 , "r" ) ; if ( ! f ) { strncpy ( chem_file1 , PKGDATADIR , sizeof ( chem_file1 ) - 1 ) ; strncat ( chem_file1 , "/" , sizeof ( chem_file1 ) - strlen ( chem_file1 ) - 1 ) ; strncat ( chem_file1 , chem_file , sizeof ( chem_file1 ) - strlen ( chem_file1 ) - 1 ) ; f = fopen ( chem_file1 , "r" ) ; if ( ! f ) { fprintf ( stderr , "astrochem:<S2SV_blank>error:<S2SV_blank>can\'t<S2SV_blank>find<S2SV_blank>%s.\\n" , chem_file ) ; return EXIT_FAILURE ; } } fclose ( f ) ; int n_reactions = get_nb_active_line ( chem_file1 ) ; fprintf ( stdout , "n_reactions=%i\\n" , n_reactions ) ; if ( n_reactions == - 1 ) { return EXIT_FAILURE ; } if ( n_reactions == 0 ) { fprintf ( stderr , "astrochem:<S2SV_blank>error:<S2SV_blank>the<S2SV_blank>number<S2SV_blank>of<S2SV_blank>reactions<S2SV_blank>is<S2SV_blank>zero.\\n" ) ; return EXIT_FAILURE ; } <S2SV_StartBug> int n_alloc_species = n_reactions / 10 ; <S2SV_EndBug> if ( n_alloc_species == 0 ) { n_alloc_species = 1 ; } if ( alloc_network ( network , n_alloc_species , n_reactions ) != EXIT_SUCCESS ) { return EXIT_FAILURE ; } network -> n_species = 0 ; if ( verbose >= 1 ) { fprintf ( stdout , "Reading<S2SV_blank>reactions<S2SV_blank>network<S2SV_blank>from<S2SV_blank>%s...<S2SV_blank>" , chem_file1 ) ; fflush ( stdout ) ; } f = fopen ( chem_file1 , "r" ) ; int n = 0 ; while ( fgets ( line , MAX_LINE , f ) != NULL ) { if ( line [ 0 ] == '#' || line [ 0 ] == '\\n' ) continue ; if ( n >= network -> n_reactions ) { fprintf ( stderr , "astrochem:<S2SV_blank>error:<S2SV_blank>incorect<S2SV_blank>number<S2SV_blank>of<S2SV_blank>reactions<S2SV_blank>exceed<S2SV_blank>%i," "file<S2SV_blank>%s<S2SV_blank>may<S2SV_blank>be<S2SV_blank>corrupt.\\n" , network -> n_reactions , chem_file ) ; return EXIT_FAILURE ; } char * tmpLine = line ; char * reaction_arrow = strchr ( tmpLine , '>' ) ; * ( reaction_arrow - 2 ) = '\\0' ; char * reactants = tmpLine ; char * products = reaction_arrow + 1 ; char * specie ; int nreactants = 0 ; specie = strtok ( reactants , "<S2SV_blank>" ) ; while ( specie != NULL ) { if ( strcmp ( specie , "+" ) != 0 ) { if ( nreactants == MAX_REACTANTS ) { fprintf ( stderr , "astrochem:<S2SV_blank>error:<S2SV_blank>number<S2SV_blank>of<S2SV_blank>reactant<S2SV_blank>%i,<S2SV_blank>is<S2SV_blank>greater<S2SV_blank>than<S2SV_blank>%i," "file<S2SV_blank>%s<S2SV_blank>may<S2SV_blank>be<S2SV_blank>corrupt.\\n" , nreactants + 1 , MAX_REACTANTS , chem_file1 ) ; return EXIT_FAILURE ; } if ( ( strcmp ( specie , "cosmic-ray" ) != 0 ) && ( strcmp ( specie , "uv-photon" ) != 0 ) && ( strcmp ( specie , "photon" ) != 0 ) ) { network -> reactions [ n ] . reactants [ nreactants ] = add_species ( specie , network ) ; if ( network -> reactions [ n ] . reactants [ nreactants ] == - 1 ) { return EXIT_FAILURE ; } nreactants ++ ; } } specie = strtok ( NULL , "<S2SV_blank>" ) ; } int nproducts = 0 ; bool specie_ready = true ; specie = strtok ( products , "<S2SV_blank>" ) ; while ( specie != NULL ) { if ( strcmp ( specie , "+" ) == 0 ) { specie_ready = true ; } else if ( specie_ready ) { specie_ready = false ; if ( nproducts == MAX_PRODUCTS ) { fprintf ( stderr , "astrochem:<S2SV_blank>error:<S2SV_blank>number<S2SV_blank>of<S2SV_blank>products<S2SV_blank>%i,<S2SV_blank>is<S2SV_blank>greater<S2SV_blank>than<S2SV_blank>%i," "file<S2SV_blank>%s<S2SV_blank>may<S2SV_blank>be<S2SV_blank>corrupt.\\n" , nproducts + 1 , MAX_PRODUCTS , chem_file1 ) ; return EXIT_FAILURE ; } if ( ( strcmp ( specie , "cosmic-ray" ) != 0 ) && ( strcmp ( specie , "uv-photon" ) != 0 ) && ( strcmp ( specie , "photon" ) != 0 ) ) { network -> reactions [ n ] . products [ nproducts ] = add_species ( specie , network ) ; if ( network -> reactions [ n ] . products [ nproducts ] == - 1 ) { return EXIT_FAILURE ; } nproducts ++ ; } } else { break ; } specie = strtok ( NULL , "<S2SV_blank>" ) ; } if ( sscanf ( specie , "%lf" , & network -> reactions [ n ] . alpha ) != 1 ) { fprintf ( stderr , "astrochem:<S2SV_blank>error:<S2SV_blank>incorrect<S2SV_blank>network<S2SV_blank>file<S2SV_blank>in<S2SV_blank>%s<S2SV_blank>line<S2SV_blank>%i.\\n" , chem_file1 , n + 1 ) ; return EXIT_FAILURE ; } char * params = strtok ( NULL , "" ) ; if ( sscanf ( params , "%lf<S2SV_blank>%lf<S2SV_blank>%d<S2SV_blank>%d" , & network -> reactions [ n ] . beta , & network -> reactions [ n ] . gamma , & network -> reactions [ n ] . reaction_type , & network -> reactions [ n ] . reaction_no ) != 4 ) { fprintf ( stderr , "astrochem:<S2SV_blank>error:<S2SV_blank>incorrect<S2SV_blank>network<S2SV_blank>file<S2SV_blank>in<S2SV_blank>%s<S2SV_blank>line<S2SV_blank>%i.\\n" , chem_file1 , n + 1 ) ; return EXIT_FAILURE ; } n ++ ; } if ( n != network -> n_reactions ) { fprintf ( stderr , "astrochem:<S2SV_blank>error:<S2SV_blank>incorect<S2SV_blank>number<S2SV_blank>of<S2SV_blank>reactions<S2SV_blank>%i,<S2SV_blank>different<S2SV_blank>from<S2SV_blank>%i," "file<S2SV_blank>%s<S2SV_blank>may<S2SV_blank>be<S2SV_blank>corrupt.\\n" , n , network -> n_reactions , chem_file1 ) ; return EXIT_FAILURE ; } if ( realloc_network_species ( network , network -> n_species ) != EXIT_SUCCESS ) { return EXIT_FAILURE ; } if ( verbose >= 1 ) { fprintf ( stdout , "Found<S2SV_blank>%d<S2SV_blank>reactions<S2SV_blank>involving<S2SV_blank>%d<S2SV_blank>species.\\n" , network -> n_reactions , network -> n_species ) ; } fclose ( f ) ; return EXIT_SUCCESS ; } | <S2SV_ModStart> n_alloc_species = n_reactions * ( MAX_REACTANTS + MAX_PRODUCTS ) <S2SV_ModEnd> ; if ( |
5,636 | CWE-000 static void * notes_init ( Elf64_Phdr * phdr , void * ptr , u64 notes_offset ) { struct save_area_ext * sa_ext ; void * ptr_start = ptr ; int i ; ptr = nt_prpsinfo ( ptr ) ; for ( i = 0 ; i < dump_save_areas . count ; i ++ ) { sa_ext = dump_save_areas . areas [ i ] ; if ( sa_ext -> sa . pref_reg == 0 ) continue ; ptr = fill_cpu_elf_notes ( ptr , & sa_ext -> sa , sa_ext -> vx_regs ) ; } ptr = nt_vmcoreinfo ( ptr ) ; <S2SV_StartBug> memset ( phdr , 0 , sizeof ( * phdr ) ) ; <S2SV_EndBug> phdr -> p_type = PT_NOTE ; phdr -> p_offset = notes_offset ; phdr -> p_filesz = ( unsigned long ) PTR_SUB ( ptr , ptr_start ) ; phdr -> p_memsz = phdr -> p_filesz ; return ptr ; } | <S2SV_ModStart> ptr ) ; ptr = nt_final ( ptr ) ; |
5,637 | CWE-000 static int gpiote_find_channel ( struct device * dev , u32_t pin , u32_t port ) { volatile struct _gpiote * gpiote = ( void * ) NRF_GPIOTE_BASE ; int i ; <S2SV_StartBug> for ( i = 0 ; i < GPIOTE_CHAN_COUNT ; i ++ ) { <S2SV_EndBug> if ( ( gpiote_chan_mask & BIT ( i ) ) && ( GPIOTE_CFG_PIN_GET ( gpiote -> CONFIG [ i ] ) == pin ) && ( GPIOTE_CFG_PORT_GET ( gpiote -> CONFIG [ i ] ) == port ) ) { return i ; } } return - ENODEV ; } | <S2SV_ModStart> ( i = GPIOTE_CH_BASE <S2SV_ModEnd> ; i < <S2SV_ModStart> ; i < GPIOTE_CH_NUM <S2SV_ModEnd> ; i ++ |
5,638 | CWE-000 void myfree ( void * address , char * file , int line ) { block * ptr = ( block * ) mainMemory ; if ( ptr != NULL && ptr -> address != ptr + 1 ) { printf ( "No<S2SV_blank>blocks<S2SV_blank>allocated<S2SV_blank>as<S2SV_blank>of<S2SV_blank>yet.<S2SV_blank>Please<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>before<S2SV_blank>freeing.\\n" ) ; } while ( ptr != NULL ) { if ( ptr -> address == address ) { if ( ptr -> assigned == '0' ) { printf ( "Error<S2SV_blank>in<S2SV_blank>%s<S2SV_blank>on<S2SV_blank>line<S2SV_blank>%d:<S2SV_blank>tried<S2SV_blank>to<S2SV_blank>free<S2SV_blank>already<S2SV_blank>free\'d<S2SV_blank>memory.<S2SV_blank>\\n" , file , line ) ; return ; } ptr -> assigned = '0' ; block * prev = ptr -> prev ; block * next = ptr -> next ; <S2SV_StartBug> while ( next != NULL && next -> assigned == '0' ) { <S2SV_EndBug> ptr -> size += next -> size + sizeof ( block ) ; ptr -> next = next -> next ; <S2SV_StartBug> next = ptr -> next ; <S2SV_EndBug> } while ( prev != NULL && prev -> assigned == '0' ) { prev -> size += ptr -> size + sizeof ( block ) ; prev -> next = ptr -> next ; <S2SV_StartBug> prev = prev -> prev ; <S2SV_EndBug> } return ; } ptr = ptr -> next ; } printf ( "Error<S2SV_blank>in<S2SV_blank>%s<S2SV_blank>on<S2SV_blank>line<S2SV_blank>%d:<S2SV_blank>tried<S2SV_blank>to<S2SV_blank>free<S2SV_blank>memory<S2SV_blank>that<S2SV_blank>was<S2SV_blank>not<S2SV_blank>allocated<S2SV_blank>by<S2SV_blank>malloc.<S2SV_blank>\\n" , file , line ) ; } | <S2SV_ModStart> -> next ; if <S2SV_ModEnd> ( next != <S2SV_ModStart> -> next ; if ( next -> next != NULL ) { next -> next -> prev = ptr ; } } if <S2SV_ModEnd> ( prev != <S2SV_ModStart> -> next ; if ( ptr -> next != NULL ) { ptr -> next -> prev = prev ; } <S2SV_ModEnd> } return ; |
5,639 | CWE-000 <S2SV_StartBug> SQLITE_PRIVATE void * sqlite3HashFind ( const Hash * pH , const char * pKey , int nKey ) { <S2SV_EndBug> HashElem * elem ; unsigned int h ; assert ( pH != 0 ) ; assert ( pKey != 0 ) ; <S2SV_StartBug> assert ( nKey >= 0 ) ; <S2SV_EndBug> if ( pH -> ht ) { h = strHash ( pKey , nKey ) % pH -> htsize ; } else { h = 0 ; } <S2SV_StartBug> elem = findElementGivenHash ( pH , pKey , nKey , h ) ; <S2SV_EndBug> return elem ? elem -> data : 0 ; } | <S2SV_ModStart> char * pKey <S2SV_ModEnd> ) { HashElem <S2SV_ModStart> 0 ) ; elem = findElementWithHash <S2SV_ModEnd> ( pH , <S2SV_ModStart> , pKey , & <S2SV_ModEnd> h ) ; |
5,640 | CWE-000 void l2cble_scanner_conn_comp ( UINT16 handle , BD_ADDR bda , tBLE_ADDR_TYPE type , UINT16 conn_interval , UINT16 conn_latency , UINT16 conn_timeout ) { int i ; tL2C_LCB * p_lcb ; tBTM_SEC_DEV_REC * p_dev_rec = btm_find_or_alloc_dev ( bda ) ; L2CAP_TRACE_DEBUG ( "l2cble_scanner_conn_comp:<S2SV_blank>HANDLE=%d<S2SV_blank>addr_type=%d<S2SV_blank>conn_interval=%d<S2SV_blank>slave_latency=%d<S2SV_blank>supervision_tout=%d" , handle , type , conn_interval , conn_latency , conn_timeout ) ; l2cb . is_ble_connecting = FALSE ; p_lcb = l2cu_find_lcb_by_bd_addr ( bda , BT_TRANSPORT_LE ) ; if ( ! p_lcb ) { p_lcb = l2cu_allocate_lcb ( bda , FALSE , BT_TRANSPORT_LE ) ; if ( ! p_lcb ) { btm_sec_disconnect ( handle , HCI_ERR_NO_CONNECTION ) ; L2CAP_TRACE_ERROR ( "l2cble_scanner_conn_comp<S2SV_blank>-<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>LCB" ) ; return ; } else { if ( ! l2cu_initialize_fixed_ccb ( p_lcb , L2CAP_ATT_CID , & l2cb . fixed_reg [ L2CAP_ATT_CID - L2CAP_FIRST_FIXED_CHNL ] . fixed_chnl_opts ) ) { btm_sec_disconnect ( handle , HCI_ERR_NO_CONNECTION ) ; L2CAP_TRACE_WARNING ( "l2cble_scanner_conn_comp<S2SV_blank>-<S2SV_blank>LCB<S2SV_blank>but<S2SV_blank>no<S2SV_blank>CCB" ) ; return ; } } } else if ( p_lcb -> link_state != LST_CONNECTING ) { L2CAP_TRACE_ERROR ( "L2CAP<S2SV_blank>got<S2SV_blank>BLE<S2SV_blank>scanner<S2SV_blank>conn_comp<S2SV_blank>in<S2SV_blank>bad<S2SV_blank>state:<S2SV_blank>%d" , p_lcb -> link_state ) ; return ; } btu_stop_timer ( & p_lcb -> timer_entry ) ; p_lcb -> handle = handle ; p_lcb -> link_role = HCI_ROLE_MASTER ; p_lcb -> transport = BT_TRANSPORT_LE ; p_lcb -> min_interval = p_lcb -> max_interval = conn_interval ; p_lcb -> timeout = conn_timeout ; p_lcb -> latency = conn_latency ; p_lcb -> conn_update_mask = L2C_BLE_NOT_DEFAULT_PARAM ; <S2SV_StartBug> if ( ( p_dev_rec -> conn_params . min_conn_int >= BTM_BLE_CONN_INT_MIN ) && <S2SV_EndBug> ( p_dev_rec -> conn_params . min_conn_int <= BTM_BLE_CONN_INT_MAX ) && ( p_dev_rec -> conn_params . max_conn_int >= BTM_BLE_CONN_INT_MIN ) && ( p_dev_rec -> conn_params . max_conn_int <= BTM_BLE_CONN_INT_MAX ) && ( p_dev_rec -> conn_params . slave_latency <= BTM_BLE_CONN_LATENCY_MAX ) && ( p_dev_rec -> conn_params . supervision_tout >= BTM_BLE_CONN_SUP_TOUT_MIN ) && ( p_dev_rec -> conn_params . supervision_tout <= BTM_BLE_CONN_SUP_TOUT_MAX ) && ( ( conn_interval < p_dev_rec -> conn_params . min_conn_int && p_dev_rec -> conn_params . min_conn_int != BTM_BLE_CONN_PARAM_UNDEF ) || ( conn_interval > p_dev_rec -> conn_params . max_conn_int ) || ( conn_latency > p_dev_rec -> conn_params . slave_latency ) || ( conn_timeout > p_dev_rec -> conn_params . supervision_tout ) ) ) { L2CAP_TRACE_ERROR ( "upd_ll_conn_params:<S2SV_blank>HANDLE=%d<S2SV_blank>min_conn_int=%d<S2SV_blank>max_conn_int=%d<S2SV_blank>slave_latency=%d<S2SV_blank>supervision_tout=%d" , handle , p_dev_rec -> conn_params . min_conn_int , p_dev_rec -> conn_params . max_conn_int , p_dev_rec -> conn_params . slave_latency , p_dev_rec -> conn_params . supervision_tout ) ; p_lcb -> min_interval = p_dev_rec -> conn_params . min_conn_int ; p_lcb -> max_interval = p_dev_rec -> conn_params . max_conn_int ; p_lcb -> timeout = p_dev_rec -> conn_params . supervision_tout ; p_lcb -> latency = p_dev_rec -> conn_params . slave_latency ; btsnd_hcic_ble_upd_ll_conn_params ( handle , p_dev_rec -> conn_params . min_conn_int , p_dev_rec -> conn_params . max_conn_int , p_dev_rec -> conn_params . slave_latency , p_dev_rec -> conn_params . supervision_tout , 0 , 0 ) ; } btm_acl_created ( bda , NULL , p_dev_rec -> sec_bd_name , handle , p_lcb -> link_role , BT_TRANSPORT_LE ) ; p_lcb -> peer_chnl_mask [ 0 ] = L2CAP_FIXED_CHNL_ATT_BIT | L2CAP_FIXED_CHNL_BLE_SIG_BIT | L2CAP_FIXED_CHNL_SMP_BIT ; btm_ble_set_conn_st ( BLE_CONN_IDLE ) ; # if BLE_PRIVACY_SPT == TRUE btm_ble_disable_resolving_list ( BTM_BLE_RL_INIT , TRUE ) ; # endif } | <S2SV_ModStart> = L2C_BLE_NOT_DEFAULT_PARAM ; <S2SV_ModEnd> btm_acl_created ( bda |
5,641 | CWE-000 GrTemperatureUnit gr_convert_get_temperature_unit ( void ) { <S2SV_StartBug> int unit ; <S2SV_EndBug> GSettings * settings = gr_settings_get ( ) ; unit = g_settings_get_enum ( settings , "temperature-unit" ) ; <S2SV_StartBug> if ( unit == GR_TEMPERATURE_UNIT_LOCALE ) { <S2SV_EndBug> # ifdef LC_MEASUREMENT const char * fmt ; fmt = nl_langinfo ( _NL_MEASUREMENT_MEASUREMENT ) ; if ( fmt && * fmt == 2 ) unit = GR_TEMPERATURE_UNIT_FAHRENHEIT ; else # endif unit = GR_TEMPERATURE_UNIT_CELSIUS ; } <S2SV_StartBug> return unit ; <S2SV_EndBug> } | <S2SV_ModStart> void ) { GrPreferredUnit pref = gr_convert_metric_or_imperial ( <S2SV_ModEnd> "temperature-unit" ) ; <S2SV_ModStart> ; if ( pref == GR_PREFERRED_UNIT_IMPERIAL ) { return GR_TEMPERATURE_UNIT_FAHRENHEIT ; } else if ( pref == GR_PREFERRED_UNIT_METRIC ) { return <S2SV_ModEnd> GR_TEMPERATURE_UNIT_CELSIUS ; } <S2SV_ModStart> GR_TEMPERATURE_UNIT_CELSIUS ; } else { return GR_TEMPERATURE_UNIT_CELSIUS ; } } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
5,642 | CWE-000 START_TEST ( check_journal_file_prune ) { int rc = 0 ; struct TelemJournal * j = open_journal ( journal_file ) ; insert_n_records ( j -> record_count_limit * 2 , j ) ; ck_assert_int_gt ( j -> record_count , j -> record_count_limit ) ; <S2SV_StartBug> rc = prune_journal ( j , TESTOOPSDIR ) ; <S2SV_EndBug> ck_assert ( rc == 0 ) ; ck_assert_int_lt ( j -> record_count , j -> record_count_limit + DEVIATION ) ; close_journal ( j ) ; } | <S2SV_ModStart> ( j , "./" <S2SV_ModEnd> ) ; ck_assert |
5,643 | CWE-000 WINDOW * InitDisplay ( void ) { WINDOW * mainwin ; int Channel ; if ( ( mainwin = initscr ( ) ) == NULL ) { fprintf ( stderr , "Error<S2SV_blank>initialising<S2SV_blank>ncurses.\\n" ) ; exit ( EXIT_FAILURE ) ; } start_color ( ) ; init_pair ( 1 , COLOR_WHITE , COLOR_BLUE ) ; init_pair ( 2 , COLOR_YELLOW , COLOR_BLUE ) ; <S2SV_StartBug> color_set ( 1 , NULL ) ; <S2SV_EndBug> <S2SV_StartBug> char title [ 80 ] ; <S2SV_EndBug> <S2SV_StartBug> sprintf ( title , "LoRa<S2SV_blank>Habitat<S2SV_blank>and<S2SV_blank>SSDV<S2SV_blank>Gateway<S2SV_blank>by<S2SV_blank>M0RPI,<S2SV_blank>M0RJX<S2SV_blank>-<S2SV_blank>" VERSION ) ; <S2SV_EndBug> <S2SV_StartBug> mvaddstr ( 0 , ( 80 - strlen ( title ) ) / 2 , title ) ; <S2SV_EndBug> refresh ( ) ; for ( Channel = 0 ; Channel <= 1 ; Channel ++ ) { Config . LoRaDevices [ Channel ] . Window = newwin ( 14 , 38 , 1 , Channel ? 41 : 1 ) ; wbkgd ( Config . LoRaDevices [ Channel ] . Window , COLOR_PAIR ( 2 ) ) ; wrefresh ( Config . LoRaDevices [ Channel ] . Window ) ; } curs_set ( 0 ) ; return mainwin ; } | <S2SV_ModStart> COLOR_BLUE ) ; init_pair ( 3 , COLOR_YELLOW , COLOR_BLACK ) ; <S2SV_ModStart> ) ; char buffer <S2SV_ModEnd> [ 80 ] <S2SV_ModStart> ; sprintf ( buffer <S2SV_ModEnd> , "LoRa<S2SV_blank>Habitat<S2SV_blank>and<S2SV_blank>SSDV<S2SV_blank>Gateway<S2SV_blank>by<S2SV_blank>M0RPI,<S2SV_blank>M0RJX<S2SV_blank>-<S2SV_blank>" VERSION <S2SV_ModStart> - strlen ( buffer <S2SV_ModEnd> ) ) / <S2SV_ModStart> / 2 , buffer ) ; sprintf ( buffer , "Press<S2SV_blank>(H)<S2SV_blank>for<S2SV_blank>Help" ) ; color_set ( 3 , NULL ) ; mvaddstr ( 15 , ( 80 - strlen ( buffer ) ) / 2 , buffer ) ; color_set ( 1 , NULL <S2SV_ModEnd> ) ; refresh |
5,644 | CWE-000 void import_ownertrust ( const char * fname ) { estream_t fp ; int is_stdin = 0 ; char line [ 256 ] ; char * p ; size_t n , fprlen ; unsigned int otrust ; byte fpr [ 20 ] ; int any = 0 ; int rc ; <S2SV_StartBug> init_trustdb ( ) ; <S2SV_EndBug> if ( iobuf_is_pipe_filename ( fname ) ) { fp = es_stdin ; fname = "[stdin]" ; is_stdin = 1 ; } else if ( ! ( fp = es_fopen ( fname , "r" ) ) ) { log_error ( _ ( "can\'t<S2SV_blank>open<S2SV_blank>\'%s\':<S2SV_blank>%s\\n" ) , fname , strerror ( errno ) ) ; return ; } if ( is_secured_file ( es_fileno ( fp ) ) ) { es_fclose ( fp ) ; gpg_err_set_errno ( EPERM ) ; log_error ( _ ( "can\'t<S2SV_blank>open<S2SV_blank>\'%s\':<S2SV_blank>%s\\n" ) , fname , strerror ( errno ) ) ; return ; } while ( es_fgets ( line , DIM ( line ) - 1 , fp ) ) { TRUSTREC rec ; if ( ! * line || * line == '#' ) continue ; n = strlen ( line ) ; if ( line [ n - 1 ] != '\\n' ) { log_error ( _ ( "error<S2SV_blank>in<S2SV_blank>\'%s\':<S2SV_blank>%s\\n" ) , fname , _ ( "line<S2SV_blank>too<S2SV_blank>long" ) ) ; break ; } for ( p = line ; * p && * p != ':' ; p ++ ) if ( ! hexdigitp ( p ) ) break ; if ( * p != ':' ) { log_error ( _ ( "error<S2SV_blank>in<S2SV_blank>\'%s\':<S2SV_blank>%s\\n" ) , fname , _ ( "colon<S2SV_blank>missing" ) ) ; continue ; } fprlen = p - line ; if ( fprlen != 32 && fprlen != 40 ) { log_error ( _ ( "error<S2SV_blank>in<S2SV_blank>\'%s\':<S2SV_blank>%s\\n" ) , fname , _ ( "invalid<S2SV_blank>fingerprint" ) ) ; continue ; } if ( sscanf ( p , ":%u:" , & otrust ) != 1 ) { log_error ( _ ( "error<S2SV_blank>in<S2SV_blank>\'%s\':<S2SV_blank>%s\\n" ) , fname , _ ( "ownertrust<S2SV_blank>value<S2SV_blank>missing" ) ) ; continue ; } if ( ! otrust ) continue ; for ( p = line , fprlen = 0 ; fprlen < 20 && * p != ':' ; p += 2 ) fpr [ fprlen ++ ] = HEXTOBIN ( p [ 0 ] ) * 16 + HEXTOBIN ( p [ 1 ] ) ; while ( fprlen < 20 ) fpr [ fprlen ++ ] = 0 ; rc = tdbio_search_trust_byfpr ( fpr , & rec ) ; if ( ! rc ) { if ( rec . r . trust . ownertrust != otrust ) { if ( ! opt . quiet ) { if ( rec . r . trust . ownertrust ) log_info ( "changing<S2SV_blank>ownertrust<S2SV_blank>from<S2SV_blank>%u<S2SV_blank>to<S2SV_blank>%u\\n" , rec . r . trust . ownertrust , otrust ) ; else log_info ( "setting<S2SV_blank>ownertrust<S2SV_blank>to<S2SV_blank>%u\\n" , otrust ) ; } rec . r . trust . ownertrust = otrust ; write_record ( & rec ) ; any = 1 ; } } else if ( gpg_err_code ( rc ) == GPG_ERR_NOT_FOUND ) { if ( ! opt . quiet ) log_info ( "inserting<S2SV_blank>ownertrust<S2SV_blank>of<S2SV_blank>%u\\n" , otrust ) ; memset ( & rec , 0 , sizeof rec ) ; rec . recnum = tdbio_new_recnum ( ) ; rec . rectype = RECTYPE_TRUST ; memcpy ( rec . r . trust . fingerprint , fpr , 20 ) ; rec . r . trust . ownertrust = otrust ; write_record ( & rec ) ; any = 1 ; } else log_error ( _ ( "error<S2SV_blank>finding<S2SV_blank>trust<S2SV_blank>record<S2SV_blank>in<S2SV_blank>\'%s\':<S2SV_blank>%s\\n" ) , fname , gpg_strerror ( rc ) ) ; } if ( es_ferror ( fp ) ) log_error ( _ ( "read<S2SV_blank>error<S2SV_blank>in<S2SV_blank>\'%s\':<S2SV_blank>%s\\n" ) , fname , strerror ( errno ) ) ; if ( ! is_stdin ) es_fclose ( fp ) ; if ( any ) { revalidation_mark ( ) ; rc = tdbio_sync ( ) ; if ( rc ) log_error ( _ ( "trustdb:<S2SV_blank>sync<S2SV_blank>failed:<S2SV_blank>%s\\n" ) , gpg_strerror ( rc ) ) ; } } | <S2SV_ModStart> ; init_trustdb ( 0 |
5,645 | CWE-000 int bdb_osql_trn_get_oldest_asof_reflsn ( DB_LSN * lsnout ) { <S2SV_StartBug> bdb_osql_trn_t * trn = NULL ; <S2SV_EndBug> int rc = 0 ; tran_type * shadow_tran = NULL ; lsnout -> file = 0 ; lsnout -> offset = 1 ; Pthread_mutex_lock ( & trn_repo_mtx ) ; if ( trn_repo ) { LISTC_FOR_EACH ( & trn_repo -> trns , trn , lnk ) { assert ( trn -> shadow_tran -> tranclass == TRANCLASS_SNAPISOL || trn -> shadow_tran -> tranclass == TRANCLASS_SERIALIZABLE ) ; shadow_tran = trn -> shadow_tran ; assert ( shadow_tran ) ; if ( shadow_tran -> asof_ref_lsn . file != 0 && shadow_tran -> asof_ref_lsn . offset != 1 ) { if ( lsnout -> file == 0 ) * lsnout = shadow_tran -> asof_ref_lsn ; else if ( log_compare ( & shadow_tran -> asof_ref_lsn , lsnout ) < 0 ) * lsnout = shadow_tran -> asof_ref_lsn ; } } } else { logmsg ( LOGMSG_WARN , "%s:<S2SV_blank>No<S2SV_blank>trn<S2SV_blank>repo???\\n" , __func__ ) ; } <S2SV_StartBug> done : <S2SV_EndBug> Pthread_mutex_unlock ( & trn_repo_mtx ) ; <S2SV_StartBug> return rc ; <S2SV_EndBug> } | <S2SV_ModStart> trn = NULL <S2SV_ModEnd> ; tran_type * <S2SV_ModStart> ) ; } <S2SV_ModEnd> Pthread_mutex_unlock ( & <S2SV_ModStart> ) ; return 0 <S2SV_ModEnd> ; } <S2SV_null> |
5,646 | CWE-000 void mmc_request_done ( struct mmc_host * host , struct mmc_request * mrq ) { struct mmc_command * cmd = mrq -> cmd ; int err = cmd -> error ; if ( err && cmd -> retries && mmc_host_is_spi ( host ) ) { if ( cmd -> resp [ 0 ] & R1_SPI_ILLEGAL_COMMAND ) cmd -> retries = 0 ; } if ( err && cmd -> retries && ! mmc_card_removed ( host -> card ) ) { if ( mrq -> done ) mrq -> done ( mrq ) ; } else { mmc_should_fail_request ( host , mrq ) ; led_trigger_event ( host -> led , LED_OFF ) ; pr_debug ( "%s:<S2SV_blank>req<S2SV_blank>done<S2SV_blank>(CMD%u):<S2SV_blank>%d:<S2SV_blank>%08x<S2SV_blank>%08x<S2SV_blank>%08x<S2SV_blank>%08x\\n" , mmc_hostname ( host ) , cmd -> opcode , err , cmd -> resp [ 0 ] , cmd -> resp [ 1 ] , cmd -> resp [ 2 ] , cmd -> resp [ 3 ] ) ; if ( mrq -> data ) { pr_debug ( "%s:<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%d<S2SV_blank>bytes<S2SV_blank>transferred:<S2SV_blank>%d\\n" , mmc_hostname ( host ) , mrq -> data -> bytes_xfered , mrq -> data -> error ) ; <S2SV_StartBug> trace_mmc_blk_rw_end ( cmd -> opcode , cmd -> arg , mrq -> data ) ; <S2SV_EndBug> } if ( mrq -> stop ) { pr_debug ( "%s:<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>(CMD%u):<S2SV_blank>%d:<S2SV_blank>%08x<S2SV_blank>%08x<S2SV_blank>%08x<S2SV_blank>%08x\\n" , mmc_hostname ( host ) , mrq -> stop -> opcode , mrq -> stop -> error , mrq -> stop -> resp [ 0 ] , mrq -> stop -> resp [ 1 ] , mrq -> stop -> resp [ 2 ] , mrq -> stop -> resp [ 3 ] ) ; } if ( mrq -> done ) mrq -> done ( mrq ) ; mmc_host_clk_release ( host ) ; } } | <S2SV_ModStart> error ) ; if ( mrq -> lat_hist_enabled ) { ktime_t completion ; u_int64_t delta_us ; completion = ktime_get ( ) ; delta_us = ktime_us_delta ( completion , mrq -> io_start ) ; blk_update_latency_hist ( & host -> io_lat_s , ( mrq -> data -> flags & MMC_DATA_READ ) , delta_us ) ; } |
5,647 | CWE-000 int submodule_move_head ( const char * path , const char * old , const char * new , unsigned flags ) { int ret = 0 ; struct child_process cp = CHILD_PROCESS_INIT ; const struct submodule * sub ; sub = submodule_from_path ( null_sha1 , path ) ; if ( ! sub ) die ( "BUG:<S2SV_blank>could<S2SV_blank>not<S2SV_blank>get<S2SV_blank>submodule<S2SV_blank>information<S2SV_blank>for<S2SV_blank>\'%s\'" , path ) ; if ( old && ! ( flags & SUBMODULE_MOVE_HEAD_FORCE ) ) { if ( submodule_has_dirty_index ( sub ) ) return error ( _ ( "submodule<S2SV_blank>\'%s\'<S2SV_blank>has<S2SV_blank>dirty<S2SV_blank>index" ) , path ) ; } if ( ! ( flags & SUBMODULE_MOVE_HEAD_DRY_RUN ) ) { if ( old ) { if ( ! submodule_uses_gitfile ( path ) ) absorb_git_dir_into_superproject ( "" , path , ABSORB_GITDIR_RECURSE_SUBMODULES ) ; } else { struct strbuf sb = STRBUF_INIT ; strbuf_addf ( & sb , "%s/modules/%s" , get_git_common_dir ( ) , sub -> name ) ; connect_work_tree_and_git_dir ( path , sb . buf ) ; strbuf_release ( & sb ) ; submodule_reset_index ( path ) ; } } <S2SV_StartBug> prepare_submodule_repo_env_no_git_dir ( & cp . env_array ) ; <S2SV_EndBug> cp . git_cmd = 1 ; cp . no_stdin = 1 ; cp . dir = path ; argv_array_pushf ( & cp . args , "--super-prefix=%s%s/" , get_super_prefix_or_empty ( ) , path ) ; argv_array_pushl ( & cp . args , "read-tree" , NULL ) ; if ( flags & SUBMODULE_MOVE_HEAD_DRY_RUN ) argv_array_push ( & cp . args , "-n" ) ; else argv_array_push ( & cp . args , "-u" ) ; if ( flags & SUBMODULE_MOVE_HEAD_FORCE ) argv_array_push ( & cp . args , "--reset" ) ; else argv_array_push ( & cp . args , "-m" ) ; argv_array_push ( & cp . args , old ? old : EMPTY_TREE_SHA1_HEX ) ; argv_array_push ( & cp . args , new ? new : EMPTY_TREE_SHA1_HEX ) ; if ( run_command ( & cp ) ) { ret = - 1 ; goto out ; } if ( ! ( flags & SUBMODULE_MOVE_HEAD_DRY_RUN ) ) { if ( new ) { struct child_process cp1 = CHILD_PROCESS_INIT ; cp1 . git_cmd = 1 ; cp1 . no_stdin = 1 ; cp1 . dir = path ; argv_array_pushl ( & cp1 . args , "update-ref" , "HEAD" , new , NULL ) ; if ( run_command ( & cp1 ) ) { ret = - 1 ; goto out ; } } else { struct strbuf sb = STRBUF_INIT ; strbuf_addf ( & sb , "%s/.git" , path ) ; unlink_or_warn ( sb . buf ) ; strbuf_release ( & sb ) ; if ( is_empty_dir ( path ) ) rmdir_or_warn ( path ) ; } } out : return ret ; } | <S2SV_ModStart> ; } } prepare_submodule_repo_env <S2SV_ModEnd> ( & cp |
5,648 | CWE-000 NecroCoreAST_Expression * necro_transform_if_then_else ( NecroTransformToCore * core_transform , NecroAST_Node_Reified * necro_ast_node ) { assert ( core_transform ) ; assert ( necro_ast_node ) ; assert ( necro_ast_node -> type == NECRO_AST_IF_THEN_ELSE ) ; if ( core_transform -> transform_state != NECRO_CORE_TRANSFORMING ) return NULL ; NecroAST_IfThenElse_Reified * ast_if_then_else = & necro_ast_node -> if_then_else ; NecroCoreAST_Expression * core_expr = necro_paged_arena_alloc ( & core_transform -> core_ast -> arena , sizeof ( NecroCoreAST_Expression ) ) ; core_expr -> expr_type = NECRO_CORE_EXPR_CASE ; NecroCoreAST_Case * core_case = & core_expr -> case_expr ; core_case -> expr = necro_transform_to_core_impl ( core_transform , ast_if_then_else -> if_expr ) ; <S2SV_StartBug> core_case -> type = necro_ast_node -> necro_type ; <S2SV_EndBug> NecroCoreAST_CaseAlt * true_alt = necro_paged_arena_alloc ( & core_transform -> core_ast -> arena , sizeof ( NecroCoreAST_CaseAlt ) ) ; true_alt -> expr = necro_transform_to_core_impl ( core_transform , ast_if_then_else -> then_expr ) ; true_alt -> altCon = necro_paged_arena_alloc ( & core_transform -> core_ast -> arena , sizeof ( NecroCoreAST_Expression ) ) ; true_alt -> altCon -> lit . boolean_literal = true ; true_alt -> altCon -> lit . type = NECRO_AST_CONSTANT_BOOL ; true_alt -> altCon -> expr_type = NECRO_CORE_EXPR_LIT ; true_alt -> next = NULL ; NecroCoreAST_CaseAlt * false_alt = necro_paged_arena_alloc ( & core_transform -> core_ast -> arena , sizeof ( NecroCoreAST_CaseAlt ) ) ; false_alt -> expr = necro_transform_to_core_impl ( core_transform , ast_if_then_else -> else_expr ) ; false_alt -> altCon = necro_paged_arena_alloc ( & core_transform -> core_ast -> arena , sizeof ( NecroCoreAST_Expression ) ) ; false_alt -> altCon -> lit . boolean_literal = false ; false_alt -> altCon -> lit . type = NECRO_AST_CONSTANT_BOOL ; false_alt -> altCon -> expr_type = NECRO_CORE_EXPR_LIT ; false_alt -> next = NULL ; true_alt -> next = false_alt ; core_case -> alts = true_alt ; return core_expr ; } | <S2SV_ModStart> ; core_case -> expr -> necro_type = ast_if_then_else -> if_expr -> necro_type ; core_case -> |
5,649 | CWE-000 char * mus_getcwd ( void ) { int i , path_max = 0 ; char * pwd = NULL , * res = NULL ; # if HAVE_PATHCONF path_max = pathconf ( "/" , _PC_PATH_MAX ) ; <S2SV_StartBug> # endif <S2SV_EndBug> <S2SV_StartBug> if ( path_max < 1024 ) <S2SV_EndBug> { <S2SV_StartBug> # if defined ( PATH_MAX ) <S2SV_EndBug> path_max = PATH_MAX ; <S2SV_StartBug> # endif <S2SV_EndBug> if ( path_max < 1024 ) <S2SV_StartBug> path_max = 1024 ; <S2SV_EndBug> } # if HAVE_GETCWD for ( i = path_max ; ; i *= 2 ) { if ( pwd ) FREE ( pwd ) ; pwd = ( char * ) CALLOC ( i , sizeof ( char ) ) ; res = getcwd ( pwd , i ) ; if ( res ) break ; } # else # if HAVE_GETWD pwd = ( char * ) CALLOC ( path_max , sizeof ( char ) ) ; getwd ( pwd ) ; # endif # endif return ( pwd ) ; } | <S2SV_ModStart> _PC_PATH_MAX ) ; <S2SV_ModEnd> if ( path_max <S2SV_ModStart> < 1024 ) # endif <S2SV_ModStart> ( PATH_MAX ) && PATH_MAX >= 1024 <S2SV_ModStart> PATH_MAX ; # else <S2SV_ModEnd> path_max = 1024 <S2SV_ModStart> = 1024 ; # endif |
5,650 | CWE-000 int dns_decode_data_query ( struct dns_packet * q , uint8_t * td , uint8_t * out , size_t * outlen ) { if ( q -> qdcount != 1 ) { return 0 ; } struct dns_question * qs = & q -> q [ 0 ] ; uint8_t * qtd = qs -> name + qs -> namelen - HOSTLEN ( td ) ; if ( memcmp ( qtd , td , HOSTLEN ( td ) ) != 0 ) { DEBUG ( 1 , "invalid<S2SV_blank>topdomain:<S2SV_blank>%s;<S2SV_blank>expected<S2SV_blank>%s" , format_host ( qtd , HOSTLEN ( td ) , 0 ) , format_host ( td , HOSTLEN ( td ) , 1 ) ) ; return 0 ; } uint8_t * p = qs -> name ; <S2SV_StartBug> size_t len = readname ( qs -> name , qs -> namelen , & p , out , * outlen , 1 , 0 ) ; <S2SV_EndBug> * outlen = len ; return 1 ; } | <S2SV_ModStart> qs -> namelen - HOSTLEN ( td ) |
5,651 | CWE-000 uint64_t evict_range ( struct msb_data * data , struct msb_range * range , uint64_t last_offset ) { int first_bit = 0 , next_zero_bit = 0 , cur_bit = 0 ; uint64_t first_sector ; int sectors ; uint64_t offset = last_offset ; int res = 0 ; pr_debug ( "Start<S2SV_blank>evicting<S2SV_blank>range<S2SV_blank>range=%p<S2SV_blank>start_lba_main=%llu,<S2SV_blank>start_lba_aux=%llu,<S2SV_blank>offset=%llu\\n" , range , range -> start_lba_main , range -> start_lba_aux , offset ) ; <S2SV_StartBug> cur_bit = lba2bit ( range , range -> start_lba_main + offset ) ; <S2SV_EndBug> first_bit = find_next_bit ( range -> bitmap , data -> range_bitmap_size , cur_bit ) ; next_zero_bit = find_next_zero_bit ( range -> bitmap , data -> range_bitmap_size , first_bit ) ; pr_debug ( "for<S2SV_blank>range<S2SV_blank>=<S2SV_blank>%p,<S2SV_blank>cur_bit<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>first_bit<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>next_zero_bit<S2SV_blank>=<S2SV_blank>%d\\n" , range , cur_bit , first_bit , next_zero_bit ) ; while ( first_bit != data -> range_bitmap_size ) { <S2SV_StartBug> first_sector = bit2lba ( range , first_bit ) ; <S2SV_EndBug> sectors = bit2lba ( range , next_zero_bit ) - first_sector ; if ( sectors > BIO_MAX_PAGES * PAGE_SIZE / KERNEL_SECT_SIZE ) { sectors = BIO_MAX_PAGES * PAGE_SIZE / KERNEL_SECT_SIZE ; } pr_debug ( "Generate<S2SV_blank>evict<S2SV_blank>bio<S2SV_blank>first_sect=%llu,<S2SV_blank>len=%d\\n" , first_sector , sectors ) ; res = generate_evict_bio ( first_sector , sectors , data -> dev , range ) ; if ( res != 0 ) { <S2SV_StartBug> pr_debug ( "Cannot<S2SV_blank>create<S2SV_blank>evict<S2SV_blank>io<S2SV_blank>while<S2SV_blank>evicting<S2SV_blank>range=%p" , range ) ; <S2SV_EndBug> return offset ; } atomic_inc ( & data -> num_evict_cmd ) ; pr_debug ( "Current<S2SV_blank>number<S2SV_blank>of<S2SV_blank>evict<S2SV_blank>cmd<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>of<S2SV_blank>%llu\\n" , atomic_read ( & data -> num_evict_cmd ) , data -> max_num_evict_cmd ) ; <S2SV_StartBug> cur_bit = lba2bit ( range , first_sector + sectors ) ; <S2SV_EndBug> first_bit = find_next_bit ( range -> bitmap , data -> range_bitmap_size , cur_bit ) ; next_zero_bit = find_next_zero_bit ( range -> bitmap , data -> range_bitmap_size , first_bit ) ; pr_debug ( "for<S2SV_blank>range<S2SV_blank>=<S2SV_blank>%p,<S2SV_blank>cur_bit<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>first_bit<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>next_zero_bit<S2SV_blank>=<S2SV_blank>%d\\n" , range , cur_bit , first_bit , next_zero_bit ) ; if ( atomic_read ( & data -> num_evict_cmd ) >= data -> max_num_evict_cmd ) { if ( first_bit == data -> range_bitmap_size ) { pr_debug ( "Max<S2SV_blank>allowed<S2SV_blank>number<S2SV_blank>of<S2SV_blank>evict<S2SV_blank>cmd<S2SV_blank>achieved<S2SV_blank>for<S2SV_blank>range=%p,<S2SV_blank>returned<S2SV_blank>offset=%llu,<S2SV_blank>finish<S2SV_blank>with<S2SV_blank>this<S2SV_blank>range\\n" , range , data -> range_bitmap_size ) ; return data -> range_size_sectors ; } else { <S2SV_StartBug> offset = first_sector + sectors - range -> start_lba_main ; <S2SV_EndBug> pr_debug ( "Max<S2SV_blank>allowed<S2SV_blank>number<S2SV_blank>of<S2SV_blank>evict<S2SV_blank>cmd<S2SV_blank>achieved<S2SV_blank>for<S2SV_blank>range=%p,<S2SV_blank>returned<S2SV_blank>offset=%llu\\n" , range , offset ) ; <S2SV_StartBug> return offset ; <S2SV_EndBug> } } } pr_debug ( "All<S2SV_blank>eviction<S2SV_blank>commands<S2SV_blank>to<S2SV_blank>range=%p,<S2SV_blank>start_lba_main=%llu,<S2SV_blank>start_lba_aux=%llu<S2SV_blank>has<S2SV_blank>been<S2SV_blank>submited\\n" , range , range -> start_lba_main , range -> start_lba_aux ) ; return data -> range_size_sectors ; } | <S2SV_ModStart> ; cur_bit = lba_aux2bit ( range , range -> start_lba_aux <S2SV_ModEnd> + offset ) <S2SV_ModStart> { first_sector = bit2lba_aux ( range , first_bit ) ; sectors = bit2lba_aux <S2SV_ModEnd> ( range , <S2SV_ModStart> 0 ) { pr_err <S2SV_ModEnd> ( "Cannot<S2SV_blank>create<S2SV_blank>evict<S2SV_blank>io<S2SV_blank>while<S2SV_blank>evicting<S2SV_blank>range=%p" , <S2SV_ModStart> ; cur_bit = lba_aux2bit <S2SV_ModEnd> ( range , <S2SV_ModStart> - range -> start_lba_aux ; pr_debug ( "Max<S2SV_blank>allowed<S2SV_blank>number<S2SV_blank>of<S2SV_blank>evict<S2SV_blank>cmd<S2SV_blank>achieved<S2SV_blank>for<S2SV_blank>range=%p,<S2SV_blank>returned<S2SV_blank>offset=%llu\\n" , range , offset ) ; return offset ; } } } pr_debug ( "All<S2SV_blank>eviction<S2SV_blank>commands<S2SV_blank>to<S2SV_blank>range=%p,<S2SV_blank>start_lba_main=%llu,<S2SV_blank>start_lba_aux=%llu<S2SV_blank>has<S2SV_blank>been<S2SV_blank>submited\\n" , range , range -> start_lba_main , range -> start_lba_aux <S2SV_ModEnd> ) ; return <S2SV_ModStart> ) ; return <S2SV_ModEnd> data -> range_size_sectors |
5,652 | CWE-000 int render_text ( LAYER_RUNTIME * oneLayer , GLfloat * theMatrix ) { log_this ( 10 , "Entering<S2SV_blank>renderText\\n" ) ; int i ; GLfloat * color ; GLfloat c [ 4 ] ; int ndims = oneLayer -> n_dims ; int offset = 0 ; ; char * txt ; glGenBuffers ( 1 , & text_vbo ) ; GLfloat point_coord [ 2 ] ; GLESSTRUCT * rb = oneLayer -> res_buf ; POINT_LIST * point = oneLayer -> points ; glUseProgram ( txt_program ) ; glUniformMatrix4fv ( txt_matrix , 1 , GL_FALSE , theMatrix ) ; GLfloat sx = ( GLfloat ) ( 2.0 / CURR_WIDTH ) ; GLfloat sy = ( GLfloat ) ( 2.0 / CURR_HEIGHT ) ; if ( oneLayer -> show_text && oneLayer -> text -> used_n_vals != point -> point_start_indexes -> used ) { printf ( "There<S2SV_blank>is<S2SV_blank>a<S2SV_blank>mismatch<S2SV_blank>between<S2SV_blank>number<S2SV_blank>of<S2SV_blank>labels<S2SV_blank>and<S2SV_blank>number<S2SV_blank>of<S2SV_blank>corresponding<S2SV_blank>points\\n" ) ; printf ( "%d<S2SV_blank>vs<S2SV_blank>%d\\n" , oneLayer -> text -> used_n_vals , point -> point_start_indexes -> used ) ; } int used = 0 ; <S2SV_StartBug> n_words = point -> point_start_indexes -> used ; <S2SV_EndBug> <S2SV_StartBug> for ( i = 0 ; i < n_words ; i ++ ) <S2SV_EndBug> { total_points += 1 ; int psz = * ( oneLayer -> text -> size + i ) ; Uint32 styleID = * ( point -> style_id -> list + i ) ; if ( styleID < length_global_styles && global_styles [ styleID ] . styleID == styleID ) color = global_styles [ styleID ] . color ; else { c [ 0 ] = c [ 1 ] = c [ 2 ] = 100 ; c [ 3 ] = 255 ; color = c ; } point_coord [ 0 ] = * ( point -> points -> list + offset ) ; point_coord [ 1 ] = * ( point -> points -> list + offset + 1 ) ; offset = * ( point -> point_start_indexes -> list + i ) ; txt = oneLayer -> text -> char_array + used ; used += strlen ( txt ) + 1 ; draw_it ( color , point_coord , psz , txt_box , txt_color , txt_coord2d , txt , sx , sy ) ; } return 0 ; } | <S2SV_ModStart> = 0 ; int nw = point -> point_start_indexes -> used ; n_words += nw ; total_points += nw <S2SV_ModEnd> ; for ( <S2SV_ModStart> ; i < nw <S2SV_ModEnd> ; i ++ |
5,653 | CWE-000 int in_loop_call ( commandlisttype * * currentcommand , translation_unit * * other_units , int * commandnum , translation_unit * * current_unit , int * c ) { commandlisttype * currentcommandt ; translation_unit * current_unitt ; activationrecord inrecord ; current_unitt = NULL ; currentcommandt = NULL ; currentcommandt = * currentcommand ; current_unitt = * current_unit ; if ( strcmp ( currentcommandt -> paramlist -> list -> val [ 0 ] , "$scanf" ) == 0 || strcmp ( currentcommandt -> paramlist -> list -> val [ 0 ] , "$printf" ) == 0 ) { call ( currentcommandt -> paramlist -> list -> val [ 0 ] , currentcommandt -> paramlist -> list -> int_val [ 1 ] ) ; return 0 ; } else { int d ; for ( d = 0 ; d < MAX_FUNCTIONS && other_units [ d ] != NULL ; d ++ ) { if ( strcmp ( currentcommandt -> paramlist -> list -> val [ 0 ] , other_units [ d ] -> name ) == 0 ) { break ; } } if ( other_units [ d ] != NULL ) { void * tempvalue [ 10 ] ; typecg temptype [ 10 ] ; int * in_off ; in_off = NULL ; for ( int g = 0 ; g < 10 ; g ++ ) { tempvalue [ g ] = NULL ; temptype [ g ] = GENERIC ; } REQUESTMEM ( in_off , int , INT ) for ( int g = 0 ; g < currentcommandt -> paramlist -> list -> int_val [ 1 ] ; g ++ ) { tempvalue [ g ] = pop ( & used_type5 , 3 ) ; temptype [ g ] = used_type5 ; # ifdef DEBUG # endif * in_off = * in_off + 1 ; } init_activation_record ( & inrecord ) ; <S2SV_StartBug> inrecord . access_link = & vm_memstack . stack [ 0 ] ; <S2SV_EndBug> inrecord . alloc_amount = currentcommandt -> paramlist -> list -> int_val [ 1 ] ; inrecord . last_command_instruction = * commandnum ; strcpy ( inrecord . last_command_name , current_unitt -> name ) ; strcpy ( inrecord . returnvalue , "0.0" ) ; push_activation_record ( & vm_memstack , inrecord ) ; for ( int g = inrecord . alloc_amount - 1 ; g >= 0 ; g -- ) push_onto_stack ( & vm_memstack , tempvalue [ g ] , temptype [ g ] ) ; current_unitt = other_units [ d ] ; currentcommandt = current_unitt -> commandlist -> list ; * currentcommand = currentcommandt ; * current_unit = current_unitt ; * commandnum = 1 ; * c = d ; return 1 ; } return - 1 ; } } | <S2SV_ModStart> . access_link = ( char * ) |
5,654 | CWE-000 static file_t * reserve_lun ( uint8_t lun ) { uint8_t i ; for ( i = 0 ; i < MAX_OPEN_FILES ; i ++ ) { if ( ! files [ i ] . used ) { files [ i ] . used = TRUE ; <S2SV_StartBug> open_files ++ ; <S2SV_EndBug> set_busy_led ( TRUE ) ; return & ( files [ i ] . file ) ; } } return NULL ; } | <S2SV_ModStart> = TRUE ; files [ i ] . lun = lun ; |
5,655 | CWE-000 static value_t pr_str_cons ( value_t x ) { value_t r = NIL ; <S2SV_StartBug> while ( ! nilp ( car ( x ) ) ) <S2SV_EndBug> { if ( nilp ( r ) ) { r = cons ( RCHAR ( '(' ) , NIL ) ; } else { nconc ( r , cons ( RCHAR ( '<S2SV_blank>' ) , NIL ) ) ; } nconc ( r , pr_str ( car ( x ) ) ) ; x = cdr ( x ) ; <S2SV_StartBug> } <S2SV_EndBug> nconc ( r , cons ( RCHAR ( ')' ) , NIL ) ) ; <S2SV_StartBug> r . type . main = STR_T ; <S2SV_EndBug> return r ; } | <S2SV_ModStart> = NIL ; if ( nilp <S2SV_ModEnd> ( x ) <S2SV_ModStart> x ) ) { r = cons ( RCHAR ( 'n' ) , cons ( RCHAR ( 'i' ) , cons ( RCHAR ( 'l' ) , NIL ) ) ) ; } else { do <S2SV_ModEnd> { if ( <S2SV_ModStart> ) ; } while ( ! nilp ( car ( x ) ) ) ; <S2SV_ModStart> ) ) ; } |
5,656 | CWE-000 int64_t fsp_opal_read_sensor ( uint32_t sensor_hndl , int token , uint32_t * sensor_data ) { struct opal_sensor_data * attr ; int64_t rc ; prlog ( PR_INSANE , "fsp_opal_read_sensor<S2SV_blank>[%08x]\\n" , sensor_hndl ) ; <S2SV_StartBug> if ( sensor_state == SENSOR_PERMANENT_ERROR ) { <S2SV_EndBug> rc = OPAL_HARDWARE ; goto out ; } if ( ! sensor_hndl ) { rc = OPAL_PARAMETER ; goto out ; } lock ( & sensor_lock ) ; if ( prev_msg_consumed ) { attr = zalloc ( sizeof ( * attr ) ) ; if ( ! attr ) { log_simple_error ( & e_info ( OPAL_RC_SENSOR_READ ) , "SENSOR:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory\\n" ) ; rc = OPAL_NO_MEM ; goto out_lock ; } rc = parse_sensor_id ( sensor_hndl , attr ) ; if ( rc ) { log_simple_error ( & e_info ( OPAL_RC_SENSOR_READ ) , "SENSOR:<S2SV_blank>%s:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>parse<S2SV_blank>the<S2SV_blank>sensor<S2SV_blank>" "handle[0x%08x]\\n" , __func__ , sensor_hndl ) ; goto out_free ; } attr -> sensor_data = sensor_data ; attr -> async_token = token ; rc = fsp_sensor_send_read_request ( attr ) ; if ( rc != OPAL_ASYNC_COMPLETION ) { log_simple_error ( & e_info ( OPAL_RC_SENSOR_READ ) , "SENSOR:<S2SV_blank>%s:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>queue<S2SV_blank>the<S2SV_blank>read<S2SV_blank>" "request<S2SV_blank>to<S2SV_blank>fsp\\n" , __func__ ) ; goto out_free ; } prev_msg_consumed = false ; } else { rc = OPAL_BUSY_EVENT ; } unlock ( & sensor_lock ) ; return rc ; out_free : free ( attr ) ; out_lock : unlock ( & sensor_lock ) ; out : return rc ; } | <S2SV_ModStart> ; if ( fsp_in_rr ( ) ) return OPAL_BUSY ; if ( |
5,657 | CWE-000 int zsdb_foreach ( struct zsdb * db , const char * prefix , size_t prefixlen , foreach_p * p , foreach_cb * cb , void * cbdata , struct txn * * txn ) { int ret = ZS_OK ; struct zsdb_priv * priv ; struct zsdb_iter_data * data ; struct zsdb_iter * tempiter = NULL ; int newtxn = 0 ; int found = 0 ; assert_zsdb ( db ) ; if ( db ) priv = db -> priv ; if ( ! priv -> open ) { zslog ( LOGWARNING , "DB<S2SV_blank>`%s`<S2SV_blank>not<S2SV_blank>open!\\n" , priv -> dbdir . buf ) ; return ZS_NOT_OPEN ; } if ( prefixlen ) { assert ( prefix ) ; } if ( txn && * txn && ( * txn ) -> iter ) { tempiter = ( * txn ) -> iter ; } else { zs_iterator_new ( db , & tempiter ) ; if ( prefix ) ret = zs_iterator_begin_at_key ( & tempiter , ( unsigned char * ) prefix , <S2SV_StartBug> prefixlen , & found , <S2SV_EndBug> NULL , NULL ) ; else zs_iterator_begin ( & tempiter ) ; newtxn = 1 ; } do { unsigned char * key = NULL , * val = NULL ; size_t keylen = 0 , vallen = 0 ; struct zs_key krec ; struct zs_val vrec ; data = zs_iterator_get ( tempiter ) ; if ( ! data ) break ; if ( data -> deleted ) continue ; switch ( data -> type ) { case ZSDB_BE_ACTIVE : case ZSDB_BE_FINALISED : key = data -> data . iter -> record -> key ; keylen = data -> data . iter -> record -> keylen ; val = data -> data . iter -> record -> val ; vallen = data -> data . iter -> record -> vallen ; break ; case ZSDB_BE_PACKED : { struct zsdb_file * f = data -> data . f ; size_t offset = f -> index -> data [ f -> indexpos ] ; zs_read_key_val_record_from_file_offset ( f , & offset , & krec , & vrec ) ; key = krec . data ; keylen = ( krec . base . type == REC_TYPE_KEY || krec . base . type == REC_TYPE_DELETED ) ? krec . base . slen : krec . base . llen ; val = vrec . data ; vallen = vrec . base . type == REC_TYPE_VALUE ? vrec . base . slen : vrec . base . llen ; } break ; default : abort ( ) ; } if ( prefixlen ) { if ( memcmp_raw ( key , prefixlen , prefix , prefixlen ) ) break ; } if ( ! p || p ( cbdata , key , keylen , val , vallen ) ) { <S2SV_StartBug> ret = cb ( cbdata , key , keylen , val , vallen ) ; <S2SV_EndBug> if ( ret ) break ; } } while ( zs_iterator_next ( tempiter , data ) ) ; if ( newtxn ) zs_iterator_end ( & tempiter ) ; return ret ; } | <S2SV_ModStart> , & found <S2SV_ModEnd> ) ; else <S2SV_ModStart> ) ) { if ( <S2SV_ModEnd> cb ( cbdata <S2SV_ModStart> , vallen ) <S2SV_ModEnd> ) break ; |
5,658 | CWE-000 DEFUN ( "move-to-window-line" , Fmove_to_window_line , Smove_to_window_line , 1 , 1 , "P" , doc : ) ( Lisp_Object arg ) { struct window * w = XWINDOW ( selected_window ) ; int lines , start ; Lisp_Object window ; # if false int this_scroll_margin ; # endif if ( ! ( BUFFERP ( w -> contents ) && XBUFFER ( w -> contents ) == current_buffer ) ) error ( "move-to-window-line<S2SV_blank>called<S2SV_blank>from<S2SV_blank>unrelated<S2SV_blank>buffer" ) ; window = selected_window ; start = marker_position ( w -> start ) ; if ( start < BEGV || start > ZV ) { int height = window_internal_height ( w ) ; Fvertical_motion ( make_number ( - ( height / 2 ) ) , window , Qnil ) ; set_marker_both ( w -> start , w -> contents , PT , PT_BYTE ) ; w -> start_at_line_beg = ! NILP ( Fbolp ( ) ) ; w -> force_start = true ; } else Fgoto_char ( w -> start ) ; lines = displayed_window_lines ( w ) ; <S2SV_StartBug> # if false <S2SV_EndBug> this_scroll_margin = max ( 0 , min ( scroll_margin , lines / 4 ) ) ; # endif if ( NILP ( arg ) ) XSETFASTINT ( arg , lines / 2 ) ; else { EMACS_INT iarg = XINT ( Fprefix_numeric_value ( arg ) ) ; if ( iarg < 0 ) iarg = iarg + lines ; <S2SV_StartBug> # if false <S2SV_EndBug> iarg = max ( iarg , this_scroll_margin ) ; iarg = min ( iarg , lines - this_scroll_margin - 1 ) ; # endif arg = make_number ( iarg ) ; } if ( w -> vscroll ) XSETINT ( arg , XINT ( arg ) + 1 ) ; return Fvertical_motion ( arg , window , Qnil ) ; } | <S2SV_ModStart> w ) ; <S2SV_ModEnd> if ( NILP <S2SV_ModStart> # if false this_scroll_margin = window_scroll_margin ( w , MARGIN_IN_LINES ) ; |
5,659 | CWE-000 static void armv7m_nvic_reset ( DeviceState * dev ) { int resetprio ; <S2SV_StartBug> NVICState * s = NVIC ( dev ) ; <S2SV_EndBug> s -> vectors [ ARMV7M_EXCP_NMI ] . enabled = 1 ; s -> vectors [ ARMV7M_EXCP_SVC ] . enabled = 1 ; s -> vectors [ ARMV7M_EXCP_DEBUG ] . enabled = 1 ; s -> vectors [ ARMV7M_EXCP_PENDSV ] . enabled = 1 ; s -> vectors [ ARMV7M_EXCP_SYSTICK ] . enabled = 1 ; resetprio = arm_feature ( & s -> cpu -> env , ARM_FEATURE_V8 ) ? - 4 : - 3 ; s -> vectors [ ARMV7M_EXCP_RESET ] . prio = resetprio ; s -> vectors [ ARMV7M_EXCP_NMI ] . prio = - 2 ; s -> vectors [ ARMV7M_EXCP_HARD ] . prio = - 1 ; if ( arm_feature ( & s -> cpu -> env , ARM_FEATURE_M_SECURITY ) ) { s -> sec_vectors [ ARMV7M_EXCP_HARD ] . enabled = 1 ; s -> sec_vectors [ ARMV7M_EXCP_SVC ] . enabled = 1 ; s -> sec_vectors [ ARMV7M_EXCP_PENDSV ] . enabled = 1 ; s -> sec_vectors [ ARMV7M_EXCP_SYSTICK ] . enabled = 1 ; s -> sec_vectors [ ARMV7M_EXCP_HARD ] . prio = - 1 ; s -> vectors [ ARMV7M_EXCP_HARD ] . enabled = 0 ; } else { s -> vectors [ ARMV7M_EXCP_HARD ] . enabled = 1 ; } s -> exception_prio = NVIC_NOEXC_PRIO ; s -> vectpending = 0 ; s -> vectpending_is_s_banked = false ; s -> vectpending_prio = NVIC_NOEXC_PRIO ; if ( arm_feature ( & s -> cpu -> env , ARM_FEATURE_M_SECURITY ) ) { memset ( s -> itns , 0 , sizeof ( s -> itns ) ) ; } else { int i ; for ( i = NVIC_FIRST_IRQ ; i < ARRAY_SIZE ( s -> itns ) ; i ++ ) { s -> itns [ i ] = true ; } } } | <S2SV_ModStart> ( dev ) ; memset ( s -> vectors , 0 , sizeof ( s -> vectors ) ) ; memset ( s -> sec_vectors , 0 , sizeof ( s -> sec_vectors ) ) ; s -> prigroup [ M_REG_NS ] = 0 ; s -> prigroup [ M_REG_S ] = 0 |
5,660 | CWE-000 char * mono_aot_get_plt_symbol ( MonoJumpInfoType type , gconstpointer data ) { MonoJumpInfo * ji = ( MonoJumpInfo * ) mono_mempool_alloc ( llvm_acfg -> mempool , sizeof ( MonoJumpInfo ) ) ; MonoPltEntry * plt_entry ; const char * sym = NULL ; ji -> type = type ; ji -> data . target = data ; if ( ! can_encode_patch ( llvm_acfg , ji ) ) return NULL ; if ( llvm_acfg -> aot_opts . direct_icalls ) { if ( type == MONO_PATCH_INFO_JIT_ICALL_ADDR ) { sym = mono_lookup_jit_icall_symbol ( ( const char * ) data ) ; } else if ( type == MONO_PATCH_INFO_ICALL_ADDR_CALL ) { MonoMethod * method = ( MonoMethod * ) data ; if ( ! ( method -> flags & METHOD_ATTRIBUTE_PINVOKE_IMPL ) ) sym = mono_lookup_icall_symbol ( method ) ; } if ( sym ) return g_strdup ( sym ) ; } plt_entry = get_plt_entry ( llvm_acfg , ji ) ; plt_entry -> llvm_used = TRUE ; # if defined ( TARGET_MACH ) <S2SV_StartBug> return g_strdup_printf ( plt_entry -> llvm_symbol + strlen ( llvm_acfg -> llvm_label_prefix ) ) ; <S2SV_EndBug> # else <S2SV_StartBug> return g_strdup_printf ( plt_entry -> llvm_symbol ) ; <S2SV_EndBug> # endif } | <S2SV_ModStart> TARGET_MACH ) return g_strdup <S2SV_ModEnd> ( plt_entry -> <S2SV_ModStart> # else return g_strdup <S2SV_ModEnd> ( plt_entry -> |
5,661 | CWE-000 int smsc9220_send_by_chunks ( unsigned int total_packet_length , int is_new_packet , const char * data , unsigned int current_size ) { static unsigned int ongoing_packet_length = 0 ; static unsigned int ongoing_packet_length_sent = 0 ; int is_first_segment = 0 ; int is_last_segment = 0 ; unsigned int txcmd_a , txcmd_b = 0 ; unsigned int dwords_to_write = 0 ; <S2SV_StartBug> unsigned int * pktptr = 0 ; <S2SV_EndBug> unsigned int xmit_inf = 0 ; unsigned int tx_buffer_free_space = 0 ; volatile unsigned int xmit_stat = 0 ; if ( ! data ) { return - 1 ; } if ( is_new_packet ) { is_first_segment = 1 ; ongoing_packet_length = total_packet_length ; ongoing_packet_length_sent = 0 ; } else if ( ongoing_packet_length != total_packet_length || ongoing_packet_length_sent >= total_packet_length ) { return - 1 ; } xmit_inf = SMSC9220 -> TX_FIFO_INF ; tx_buffer_free_space = xmit_inf & 0xFFFF ; if ( current_size > tx_buffer_free_space ) { return - 1 ; } if ( ( ongoing_packet_length_sent + current_size ) == total_packet_length ) { is_last_segment = 1 ; } <S2SV_StartBug> pktptr = ( unsigned int * ) data ; <S2SV_EndBug> txcmd_a = 0 ; txcmd_b = 0 ; txcmd_a |= ( is_last_segment << 12 ) | ( is_first_segment << 13 ) ; txcmd_a |= current_size & 0x7FF ; txcmd_b |= ( ( current_size & 0xFFFF ) << 16 ) ; txcmd_b |= current_size & 0x7FF ; SMSC9220 -> TX_DATA_PORT = txcmd_a ; SMSC9220 -> TX_DATA_PORT = txcmd_b ; dwords_to_write = ( current_size + 3 ) >> 2 ; <S2SV_StartBug> while ( dwords_to_write > 0 ) { <S2SV_EndBug> SMSC9220 -> TX_DATA_PORT = * pktptr ; pktptr ++ ; dwords_to_write -- ; } if ( is_last_segment ) { xmit_stat = SMSC9220 -> TX_STAT_PORT ; } ongoing_packet_length_sent += current_size ; return 0 ; } | <S2SV_ModStart> ; unsigned int <S2SV_ModEnd> xmit_inf = 0 <S2SV_ModStart> 1 ; } <S2SV_ModEnd> txcmd_a = 0 <S2SV_ModStart> >> 2 ; if ( ( ( unsigned int ) data % sizeof ( uint32_t ) ) == 0 ) { fill_tx_fifo_aligned ( ( unsigned int * ) data , dwords_to_write ) ; } else { fill_tx_fifo_unaligned ( ( uint8_t * ) data , dwords_to_write ) <S2SV_ModEnd> ; } if |
5,662 | CWE-000 int main ( int num_arg , char * vec_arg [ ] ) { int i , j , k , it , planetes , N , pop , pit , Neval = 0 ; char noms [ MAX_PLA ] [ MAX_CAD ] , f_ini [ 20 ] ; real masses [ MAX_PLA ] , q [ MAX_PLA ] [ COMP ] , p [ MAX_PLA ] [ COMP ] ; real H0 , H , DH , Hemax = 0.0 , gT , gV ; real h ; int s = 6 ; real a [ s ] , ah [ s ] ; real b [ s + 1 ] , bh [ s + 1 ] ; double t0 , t = 0.0 ; FILE * fit_pl [ MAX_PLA + 1 ] ; carregar_configuracio ( num_arg , vec_arg , & h , & N , & pop , & pit , f_ini ) ; planetes = carregar_planetes ( f_ini , masses , noms , q , p ) ; H0 = energia ( masses , q , p , planetes ) ; obrir_fitxers ( fit_pl , noms , f_ini , vec_arg [ 0 ] , planetes ) ; a [ 0 ] = a [ 5 ] = 0.2095151066133620L ; a [ 1 ] = a [ 4 ] = - 0.143851773179818L ; a [ 2 ] = a [ 3 ] = 0.5 - ( a [ 0 ] + a [ 1 ] ) ; b [ 0 ] = b [ 6 ] = 0.0792036964311956L ; b [ 1 ] = b [ 5 ] = 0.3531729060497740L ; b [ 2 ] = b [ 4 ] = - 0.042065080357719L ; b [ 3 ] = 1.0 - ( 2.0 * ( b [ 0 ] + b [ 1 ] + b [ 2 ] ) ) ; for ( i = 0 ; i < s ; i ++ ) { ah [ i ] = a [ i ] * h ; bh [ i ] = b [ i ] * h ; } bh [ 6 ] = b [ 6 ] * h ; for ( it = 0 ; it < N ; it ++ ) { t0 = temps ( ) ; for ( k = 0 ; k < s ; k ++ ) { for ( i = 1 ; i < planetes ; i ++ ) { for ( j = 0 ; j < COMP ; j ++ ) { gT = ( p [ i ] [ j ] / masses [ i ] ) ; q [ i ] [ j ] += bh [ k ] * gT ; } } for ( i = 1 ; i < planetes ; i ++ ) { for ( j = 0 ; j < COMP ; j ++ ) { gV = gradV ( masses , q , i , j , planetes ) ; p [ i ] [ j ] -= ah [ k ] * gV ; } } } for ( i = 1 ; i < planetes ; i ++ ) { for ( j = 0 ; j < COMP ; j ++ ) { gT = ( p [ i ] [ j ] / masses [ i ] ) ; q [ i ] [ j ] += bh [ 6 ] * gT ; } } <S2SV_StartBug> Neval += ( 3 * ( planetes - 1 ) ) ; <S2SV_EndBug> t += temps ( ) - t0 ; H = energia ( masses , q , p , planetes ) ; DH = fabs ( H - H0 ) ; if ( DH > Hemax ) Hemax = DH ; if ( ( it % pit ) == 0 ) escriure_fitxers ( fit_pl , pop , ( ( real ) it ) * h , q , p , H0 , H , planetes ) ; } tancar_fitxers ( fit_pl , planetes ) ; print_info ( h , t , Neval , Hemax / H0 ) ; return 0 ; } | <S2SV_ModStart> Neval += ( ( s + 1 ) <S2SV_ModEnd> * ( planetes |
5,663 | CWE-000 static void device_state_changed ( NMDevice * device , NMDeviceState new_state , NMDeviceState old_state , NMDeviceStateReason reason , gpointer user_data ) { NMPolicyPrivate * priv = user_data ; NMPolicy * self = _PRIV_TO_SELF ( priv ) ; NMActiveConnection * ac ; NMSettingsConnection * connection = nm_device_get_settings_connection ( device ) ; const char * ip_iface = nm_device_get_ip_iface ( device ) ; NMIP4Config * ip4_config ; NMIP6Config * ip6_config ; NMSettingConnection * s_con = NULL ; switch ( nm_device_state_reason_check ( reason ) ) { case NM_DEVICE_STATE_REASON_GSM_REGISTRATION_DENIED : case NM_DEVICE_STATE_REASON_GSM_REGISTRATION_NOT_SEARCHING : case NM_DEVICE_STATE_REASON_GSM_SIM_NOT_INSERTED : case NM_DEVICE_STATE_REASON_GSM_SIM_PIN_REQUIRED : case NM_DEVICE_STATE_REASON_GSM_SIM_PUK_REQUIRED : case NM_DEVICE_STATE_REASON_GSM_SIM_WRONG : case NM_DEVICE_STATE_REASON_SIM_PIN_INCORRECT : case NM_DEVICE_STATE_REASON_MODEM_INIT_FAILED : case NM_DEVICE_STATE_REASON_GSM_APN_FAILED : if ( connection ) { nm_settings_connection_autoconnect_blocked_reason_set ( connection , NM_SETTINGS_AUTO_CONNECT_BLOCKED_REASON_FAILED , TRUE ) ; } break ; default : break ; } switch ( new_state ) { case NM_DEVICE_STATE_FAILED : if ( connection && old_state >= NM_DEVICE_STATE_PREPARE && old_state <= NM_DEVICE_STATE_ACTIVATED ) { gboolean block_no_secrets = FALSE ; int tries ; guint64 con_v ; if ( nm_device_state_reason_check ( reason ) == NM_DEVICE_STATE_REASON_NO_SECRETS ) { con_v = nm_settings_connection_get_last_secret_agent_version_id ( connection ) ; if ( con_v == 0 <S2SV_StartBug> || con_v != nm_agent_manager_get_agent_version_id ( priv -> agent_mgr ) ) <S2SV_EndBug> block_no_secrets = TRUE ; } if ( block_no_secrets ) { _LOGD ( LOGD_DEVICE , "connection<S2SV_blank>\'%s\'<S2SV_blank>now<S2SV_blank>blocked<S2SV_blank>from<S2SV_blank>autoconnect<S2SV_blank>due<S2SV_blank>to<S2SV_blank>no<S2SV_blank>secrets" , nm_settings_connection_get_id ( connection ) ) ; nm_settings_connection_autoconnect_blocked_reason_set ( connection , NM_SETTINGS_AUTO_CONNECT_BLOCKED_REASON_NO_SECRETS , TRUE ) ; } else { tries = nm_settings_connection_autoconnect_retries_get ( connection ) ; if ( tries > 0 ) { _LOGD ( LOGD_DEVICE , "connection<S2SV_blank>\'%s\'<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>autoconnect;<S2SV_blank>%d<S2SV_blank>tries<S2SV_blank>left" , nm_settings_connection_get_id ( connection ) , tries - 1 ) ; _connection_autoconnect_retries_set ( self , connection , tries - 1 ) ; } else if ( tries != 0 ) { _LOGD ( LOGD_DEVICE , "connection<S2SV_blank>\'%s\'<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>autoconnect;<S2SV_blank>infinite<S2SV_blank>tries<S2SV_blank>left" , nm_settings_connection_get_id ( connection ) ) ; } } nm_connection_clear_secrets ( NM_CONNECTION ( connection ) ) ; } break ; case NM_DEVICE_STATE_ACTIVATED : if ( connection ) { nm_settings_connection_autoconnect_retries_reset ( connection ) ; nm_connection_clear_secrets ( NM_CONNECTION ( connection ) ) ; } nm_dns_manager_begin_updates ( priv -> dns_manager , __func__ ) ; ip4_config = nm_device_get_ip4_config ( device ) ; if ( ip4_config ) nm_dns_manager_add_ip_config ( priv -> dns_manager , ip_iface , ip4_config , NM_DNS_IP_CONFIG_TYPE_DEFAULT ) ; ip6_config = nm_device_get_ip6_config ( device ) ; if ( ip6_config ) nm_dns_manager_add_ip_config ( priv -> dns_manager , ip_iface , ip6_config , NM_DNS_IP_CONFIG_TYPE_DEFAULT ) ; update_routing_and_dns ( self , FALSE ) ; nm_dns_manager_end_updates ( priv -> dns_manager , __func__ ) ; break ; case NM_DEVICE_STATE_UNMANAGED : case NM_DEVICE_STATE_UNAVAILABLE : if ( old_state > NM_DEVICE_STATE_DISCONNECTED ) update_routing_and_dns ( self , FALSE ) ; break ; case NM_DEVICE_STATE_DEACTIVATING : if ( connection ) { NMSettingsAutoconnectBlockedReason blocked_reason = NM_SETTINGS_AUTO_CONNECT_BLOCKED_REASON_NONE ; switch ( nm_device_state_reason_check ( reason ) ) { case NM_DEVICE_STATE_REASON_USER_REQUESTED : blocked_reason = NM_SETTINGS_AUTO_CONNECT_BLOCKED_REASON_USER_REQUEST ; break ; case NM_DEVICE_STATE_REASON_DEPENDENCY_FAILED : blocked_reason = NM_SETTINGS_AUTO_CONNECT_BLOCKED_REASON_FAILED ; break ; default : break ; } if ( blocked_reason != NM_SETTINGS_AUTO_CONNECT_BLOCKED_REASON_NONE ) { _LOGD ( LOGD_DEVICE , "blocking<S2SV_blank>autoconnect<S2SV_blank>of<S2SV_blank>connection<S2SV_blank>\'%s\':<S2SV_blank>%s" , nm_settings_connection_get_id ( connection ) , NM_UTILS_LOOKUP_STR ( nm_device_state_reason_to_str , nm_device_state_reason_check ( reason ) ) ) ; nm_settings_connection_autoconnect_blocked_reason_set ( connection , blocked_reason , TRUE ) ; } } ip6_remove_device_prefix_delegations ( self , device ) ; break ; case NM_DEVICE_STATE_DISCONNECTED : if ( nm_device_state_reason_check ( reason ) == NM_DEVICE_STATE_REASON_CARRIER && old_state == NM_DEVICE_STATE_UNAVAILABLE ) reset_autoconnect_all ( self , device , FALSE ) ; if ( old_state > NM_DEVICE_STATE_DISCONNECTED ) update_routing_and_dns ( self , FALSE ) ; schedule_activate_check ( self , device ) ; break ; case NM_DEVICE_STATE_PREPARE : activate_slave_connections ( self , device ) ; ac = ( NMActiveConnection * ) nm_device_get_act_request ( device ) ; if ( ac && g_hash_table_remove ( priv -> pending_active_connections , ac ) ) { g_signal_handlers_disconnect_by_func ( ac , pending_ac_state_changed , self ) ; g_object_weak_unref ( G_OBJECT ( ac ) , pending_ac_gone , self ) ; g_object_unref ( self ) ; } break ; case NM_DEVICE_STATE_IP_CONFIG : if ( connection ) nm_settings_connection_autoconnect_blocked_reason_set ( connection , NM_SETTINGS_AUTO_CONNECT_BLOCKED_REASON_ALL , FALSE ) ; break ; case NM_DEVICE_STATE_SECONDARIES : if ( connection ) s_con = nm_connection_get_setting_connection ( NM_CONNECTION ( connection ) ) ; if ( s_con && nm_setting_connection_get_num_secondaries ( s_con ) > 0 ) { update_routing_and_dns ( self , FALSE ) ; if ( ! activate_secondary_connections ( self , NM_CONNECTION ( connection ) , device ) ) nm_device_queue_state ( device , NM_DEVICE_STATE_FAILED , NM_DEVICE_STATE_REASON_SECONDARY_CONNECTION_FAILED ) ; } else nm_device_queue_state ( device , NM_DEVICE_STATE_ACTIVATED , NM_DEVICE_STATE_REASON_NONE ) ; break ; default : break ; } check_activating_devices ( self ) ; } | <S2SV_ModStart> 0 || con_v == <S2SV_ModEnd> nm_agent_manager_get_agent_version_id ( priv |
5,664 | CWE-000 static int xpsgtr_phy_init ( struct phy * phy ) { struct xpsgtr_phy * gtr_phy = phy_get_drvdata ( phy ) ; struct xpsgtr_dev * gtr_dev = gtr_phy -> data ; int ret = 0 ; u32 offset ; u32 reg ; u32 nsw ; u32 timeout = 500 ; mutex_lock ( & gtr_dev -> gtr_mutex ) ; xpsgtr_controller_reset ( gtr_phy ) ; if ( gtr_dev -> tx_term_fix ) { reg = readl ( gtr_dev -> serdes + TM_CMN_RST ) ; reg = ( reg & ~ TM_CMN_RST_MASK ) | TM_CMN_RST_SET ; writel ( reg , gtr_dev -> serdes + TM_CMN_RST ) ; reg = readl ( gtr_dev -> serdes + TM_CMN_RST ) ; reg = ( reg & ~ TM_CMN_RST_MASK ) | TM_CMN_RST_EN ; writel ( reg , gtr_dev -> serdes + TM_CMN_RST ) ; writel ( 0x00 , gtr_dev -> serdes + L3_TM_CALIB_DIG18 ) ; writel ( TM_OVERRIDE_NSW_CODE , gtr_dev -> serdes + L3_TM_CALIB_DIG19 ) ; <S2SV_StartBug> writel ( 1 , gtr_dev -> serdes + ICM_CFG0 ) ; <S2SV_EndBug> reg = readl ( gtr_dev -> serdes + TM_CMN_RST ) ; reg = ( reg & ~ TM_CMN_RST_MASK ) | TM_CMN_RST_SET ; writel ( reg , gtr_dev -> serdes + TM_CMN_RST ) ; dev_dbg ( gtr_dev -> dev , "calibrating...\\n" ) ; do { reg = readl ( gtr_dev -> serdes + L3_CALIB_DONE_STATUS ) ; if ( ( reg & CALIB_DONE ) == CALIB_DONE ) break ; if ( ! -- timeout ) { dev_err ( gtr_dev -> dev , "calibration<S2SV_blank>time<S2SV_blank>out\\n" ) ; ret = - ETIMEDOUT ; goto out ; } udelay ( 1 ) ; } while ( 1 ) ; dev_dbg ( gtr_dev -> dev , "calibration<S2SV_blank>done\\n" ) ; nsw = readl ( gtr_dev -> serdes + L0_TXPMA_ST_3 ) ; reg = readl ( gtr_dev -> serdes + TM_CMN_RST ) ; reg = ( reg & ~ TM_CMN_RST_MASK ) | TM_CMN_RST_EN ; writel ( reg , gtr_dev -> serdes + TM_CMN_RST ) ; nsw = nsw & DN_CALIB_CODE ; reg = nsw >> DN_CALIB_SHIFT ; writel ( reg , gtr_dev -> serdes + L3_TM_CALIB_DIG19 ) ; reg = ( ( nsw & 0x7 ) << NSW_SHIFT ) | ( 1 << NSW_PIPE_SHIFT ) ; writel ( reg , gtr_dev -> serdes + L3_TM_CALIB_DIG18 ) ; reg = readl ( gtr_dev -> serdes + TM_CMN_RST ) ; reg = ( reg & ~ TM_CMN_RST_MASK ) | TM_CMN_RST_SET ; writel ( reg , gtr_dev -> serdes + TM_CMN_RST ) ; gtr_dev -> tx_term_fix = false ; } offset = gtr_phy -> lane * TM_PLL_DIG_37_OFFSET + L0_TM_PLL_DIG_37 ; writel ( TM_COARSE_CODE_LIMIT , gtr_dev -> serdes + offset ) ; xpsgtr_configure_pll ( gtr_phy ) ; xpsgtr_lane_setprotocol ( gtr_phy ) ; if ( gtr_phy -> protocol == ICM_PROTOCOL_SATA ) xpsgtr_misc_sata ( gtr_phy ) ; if ( gtr_phy -> protocol == ICM_PROTOCOL_SGMII ) xpsgtr_misc_sgmii ( gtr_phy ) ; xpsgtr_controller_release_reset ( gtr_phy ) ; if ( gtr_phy -> protocol != ICM_PROTOCOL_DP ) { ret = xpsgtr_wait_pll_lock ( phy ) ; if ( ret != 0 ) goto out ; } else { offset = gtr_phy -> lane * TXPMD_TM_45_OFFSET + L0_TXPMD_TM_45 ; reg = L0_TXPMD_TM_45_OVER_DP_MAIN | L0_TXPMD_TM_45_ENABLE_DP_MAIN | L0_TXPMD_TM_45_OVER_DP_POST1 | L0_TXPMD_TM_45_OVER_DP_POST2 | L0_TXPMD_TM_45_ENABLE_DP_POST2 ; writel ( reg , gtr_dev -> serdes + offset ) ; offset = gtr_phy -> lane * TX_ANA_TM_118_OFFSET + L0_TX_ANA_TM_118 ; writel ( L0_TX_ANA_TM_118_FORCE_17_0 , gtr_dev -> serdes + offset ) ; } if ( gtr_phy -> protocol == ICM_PROTOCOL_USB ) xpsgtr_ulpi_reset ( gtr_phy ) ; if ( gtr_phy -> protocol == ICM_PROTOCOL_SGMII ) ret = xpsgtr_set_sgmii_pcs ( gtr_phy ) ; out : mutex_unlock ( & gtr_dev -> gtr_mutex ) ; return ret ; } | <S2SV_ModStart> ; writel ( TX_TERM_FIX_VAL , gtr_dev -> serdes + ICM_CFG1 <S2SV_ModEnd> ) ; reg |
5,665 | CWE-000 static void fts5SegIterLoadNPos ( Fts5Index * p , Fts5SegIter * pIter ) { if ( p -> rc == SQLITE_OK ) { int iOff = pIter -> iLeafOffset ; int nSz ; ASSERT_SZLEAF_OK ( pIter -> pLeaf ) ; fts5FastGetVarint32 ( pIter -> pLeaf -> p , iOff , nSz ) ; pIter -> bDel = ( nSz & 0x0001 ) ; pIter -> nPos = nSz >> 1 ; pIter -> iLeafOffset = iOff ; <S2SV_StartBug> } <S2SV_EndBug> } | <S2SV_ModStart> = iOff ; assert_nc ( pIter -> nPos >= 0 ) ; |
5,666 | CWE-000 void push ( stack_t * * stack , unsigned int line_number ) { stack_t * node ; char * value ; int i = 0 , j = 0 ; value = malloc ( sizeof ( char ) * 12 ) ; if ( value == NULL ) return ; while ( line [ i ] < '0' || line [ i ] > '9' ) { if ( line [ i ] == '\\0' ) { printf ( "L%u:<S2SV_blank>usage:<S2SV_blank>push<S2SV_blank>integer\\n" , line_number ) ; <S2SV_StartBug> exit ( EXIT_FAILURE ) ; <S2SV_EndBug> } if ( line [ i ] == '-' ) { value [ j ] = line [ i ] ; j ++ ; } i ++ ; } while ( line [ i ] != '<S2SV_blank>' && line [ i ] != '\\0' && line [ i ] >= '0' && line [ i ] <= '9' ) { value [ j ] = line [ i ] ; i ++ ; j ++ ; } <S2SV_StartBug> value [ j ] = '\\0' ; <S2SV_EndBug> node = malloc ( sizeof ( stack_t ) ) ; if ( node == NULL ) { printf ( "Error:<S2SV_blank>malloc<S2SV_blank>failed\\n" ) ; <S2SV_StartBug> exit ( EXIT_FAILURE ) ; <S2SV_EndBug> } node -> n = atoi ( value ) ; node -> prev = NULL ; if ( * stack == NULL ) node -> next = NULL ; else { node -> next = * stack ; ( * stack ) -> prev = node ; } * stack = node ; free ( value ) ; } | <S2SV_ModStart> line_number ) ; free_stack ( * stack ) ; <S2SV_ModStart> ++ ; } if ( line [ i ] != '<S2SV_blank>' && line [ i ] != '\\0' ) { printf ( "L%u:<S2SV_blank>usage:<S2SV_blank>push<S2SV_blank>integer\\n" , line_number ) ; free_stack ( * stack ) ; exit ( EXIT_FAILURE ) ; } value [ j ] = '\\0' <S2SV_ModEnd> ; node = <S2SV_ModStart> "Error:<S2SV_blank>malloc<S2SV_blank>failed\\n" ) ; free_stack ( * stack ) ; |
5,667 | CWE-000 void print_times_table ( int n ) { int num , mult , prod ; if ( n >= 0 && n <= 15 ) { for ( num = 0 ; num <= n ; num ++ ) { _putchar ( '0' ) ; _putchar ( ',' ) ; _putchar ( '<S2SV_blank>' ) ; for ( mult = 1 ; mult <= n ; mult ++ ) { prod = num * mult ; if ( prod < 100 ) _putchar ( '<S2SV_blank>' ) ; if ( prod < 10 ) _putchar ( '<S2SV_blank>' ) ; if ( prod >= 100 ) { _putchar ( ( prod / 100 ) + '0' ) ; <S2SV_StartBug> _putchar ( ( ( prod / 10 ) % 10 ) + '0' ) ; <S2SV_EndBug> } else if ( prod < 100 && prod >= 10 ) { _putchar ( ( prod / 10 ) + '0' ) ; } _putchar ( ( prod % 10 ) + '0' ) ; if ( mult == n ) continue ; _putchar ( ',' ) ; _putchar ( '<S2SV_blank>' ) ; } _putchar ( '\\n' ) ; } } <S2SV_StartBug> else <S2SV_EndBug> return ; } | <S2SV_ModStart> _putchar ( ( <S2SV_ModEnd> prod / 10 <S2SV_ModStart> ) % 10 <S2SV_ModEnd> + '0' ) <S2SV_ModStart> ; } } <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
5,668 | CWE-000 void * alloc_page ( void ) { <S2SV_StartBug> return alloc_pages ( 1 ) ; <S2SV_EndBug> } | <S2SV_ModStart> return alloc_pages ( 1U <S2SV_ModEnd> ) ; } |
5,669 | CWE-000 static inline int POG_alignEndpoint ( int line , char fullMatrix , int len ) { char verbose = 0 ; int i ; <S2SV_StartBug> int best_Letter = 0 ; <S2SV_EndBug> int best_Score = 0 ; for ( i = 1 ; i < line ; i ++ ) { if ( alMatrix_Letter [ i ] -> ml [ len ] > best_Score ) { best_Letter = i ; best_Score = alMatrix_Letter [ i ] -> ml [ len ] ; } } if ( best_Score < 0 ) { printf ( "Matrix<S2SV_blank>End<S2SV_blank>was<S2SV_blank>not<S2SV_blank>calculated\\n" ) ; exit ( 1 ) ; } if ( ! fullMatrix && best_Score < ( len * SM1 [ 0 ] [ 0 ] ) * 0.98 ) { return - 1 ; } return best_Letter ; } | <S2SV_ModStart> int best_Letter = - 1 <S2SV_ModEnd> ; int best_Score |
5,670 | CWE-000 int Get_Device_Data ( libusb_device_handle * dev_handle , unsigned short addr , unsigned char * out , unsigned int out_buf_len ) { int counter = 0 ; while ( 1 ) { if ( ResuBuf_isReady ( dev_handle ) ) { unsigned short length ; telink_usb_r_mem ( dev_handle , RESU_BUF_LENGTH , & length , 2 ) ; # if debug_mode printf ( "length<S2SV_blank>=<S2SV_blank>%d\\n" , length ) ; # endif if ( length > out_buf_len ) { length = out_buf_len ; } telink_usb_r_mem ( dev_handle , addr , out , length ) ; # if debug_mode { int i ; for ( i = 0 ; i < length ; i ++ ) { printf ( "%x<S2SV_blank>" , out [ i ] ) ; } printf ( "\\n" ) ; } # endif <S2SV_StartBug> # if debug_mode <S2SV_EndBug> # endif ResuBuf_reset ( dev_handle ) ; return length ; } else { if ( counter == 10 ) { out [ 0 ] = 2 ; out [ 1 ] = 0x55 ; out [ 2 ] = 0xaa ; return 3 ; } else { usleep ( 100000 ) ; counter ++ ; } } } } | <S2SV_ModStart> # if debug_mode usleep ( 100000 ) ; |
5,671 | CWE-000 static const char * get_usage ( zfs_help_t idx ) { switch ( idx ) { case HELP_CLONE : return ( gettext ( "\\tclone<S2SV_blank>[-p]<S2SV_blank>[-o<S2SV_blank>property=value]<S2SV_blank>...<S2SV_blank>" "<snapshot><S2SV_blank><filesystem|volume>\\n" ) ) ; case HELP_CREATE : return ( gettext ( "\\tcreate<S2SV_blank>[-p]<S2SV_blank>[-o<S2SV_blank>property=value]<S2SV_blank>...<S2SV_blank>" "<filesystem>\\n" "\\tcreate<S2SV_blank>[-ps]<S2SV_blank>[-b<S2SV_blank>blocksize]<S2SV_blank>[-o<S2SV_blank>property=value]<S2SV_blank>...<S2SV_blank>" "-V<S2SV_blank><size><S2SV_blank><volume>\\n" ) ) ; case HELP_DESTROY : return ( gettext ( "\\tdestroy<S2SV_blank>[-fnpRrv]<S2SV_blank><filesystem|volume>\\n" "\\tdestroy<S2SV_blank>[-dnpRrv]<S2SV_blank>" "<filesystem|volume>@<snap>[%<snap>][,...]\\n" "\\tdestroy<S2SV_blank><filesystem|volume>#<bookmark>\\n" ) ) ; case HELP_GET : return ( gettext ( "\\tget<S2SV_blank>[-rHp]<S2SV_blank>[-d<S2SV_blank>max]<S2SV_blank>" "[-o<S2SV_blank>\\"all\\"<S2SV_blank>|<S2SV_blank>field[,...]]\\n" "\\t<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[-t<S2SV_blank>type[,...]]<S2SV_blank>[-s<S2SV_blank>source[,...]]\\n" "\\t<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><\\"all\\"<S2SV_blank>|<S2SV_blank>property[,...]><S2SV_blank>" "[filesystem|volume|snapshot|bookmark]<S2SV_blank>...\\n" ) ) ; case HELP_INHERIT : return ( gettext ( "\\tinherit<S2SV_blank>[-rS]<S2SV_blank><property><S2SV_blank>" "<filesystem|volume|snapshot><S2SV_blank>...\\n" ) ) ; case HELP_UPGRADE : return ( gettext ( "\\tupgrade<S2SV_blank>[-v]\\n" "\\tupgrade<S2SV_blank>[-r]<S2SV_blank>[-V<S2SV_blank>version]<S2SV_blank><-a<S2SV_blank>|<S2SV_blank>filesystem<S2SV_blank>...>\\n" ) ) ; case HELP_LIST : return ( gettext ( "\\tlist<S2SV_blank>[-Hp]<S2SV_blank>[-r|-d<S2SV_blank>max]<S2SV_blank>[-o<S2SV_blank>property[,...]]<S2SV_blank>" "[-s<S2SV_blank>property]...\\n\\t<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[-S<S2SV_blank>property]...<S2SV_blank>[-t<S2SV_blank>type[,...]]<S2SV_blank>" "[filesystem|volume|snapshot]<S2SV_blank>...\\n" ) ) ; case HELP_MOUNT : return ( gettext ( "\\tmount\\n" "\\tmount<S2SV_blank>[-lvO]<S2SV_blank>[-o<S2SV_blank>opts]<S2SV_blank><-a<S2SV_blank>|<S2SV_blank>filesystem>\\n" ) ) ; case HELP_PROMOTE : return ( gettext ( "\\tpromote<S2SV_blank><clone-filesystem>\\n" ) ) ; case HELP_RECEIVE : return ( gettext ( "\\treceive<S2SV_blank>[-vnsFu]<S2SV_blank>" "[-o<S2SV_blank><property>=<value>]<S2SV_blank>...<S2SV_blank>[-x<S2SV_blank><property>]<S2SV_blank>...\\n" "\\t<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><filesystem|volume|snapshot>\\n" "\\treceive<S2SV_blank>[-vnsFu]<S2SV_blank>[-o<S2SV_blank><property>=<value>]<S2SV_blank>...<S2SV_blank>" "[-x<S2SV_blank><property>]<S2SV_blank>...<S2SV_blank>\\n" "\\t<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[-d<S2SV_blank>|<S2SV_blank>-e]<S2SV_blank><filesystem>\\n" "\\treceive<S2SV_blank>-A<S2SV_blank><filesystem|volume>\\n" ) ) ; case HELP_RENAME : return ( gettext ( "\\trename<S2SV_blank>[-f]<S2SV_blank><filesystem|volume|snapshot><S2SV_blank>" "<filesystem|volume|snapshot>\\n" "\\trename<S2SV_blank>[-f]<S2SV_blank>-p<S2SV_blank><filesystem|volume><S2SV_blank><filesystem|volume>\\n" "\\trename<S2SV_blank>-r<S2SV_blank><snapshot><S2SV_blank><snapshot>\\n" ) ) ; case HELP_ROLLBACK : return ( gettext ( "\\trollback<S2SV_blank>[-rRf]<S2SV_blank><snapshot>\\n" ) ) ; case HELP_SEND : return ( gettext ( "\\tsend<S2SV_blank>[-DnPpRvLecwb]<S2SV_blank>[-[i|I]<S2SV_blank>snapshot]<S2SV_blank>" "<snapshot>\\n" "\\tsend<S2SV_blank>[-nvPLecw]<S2SV_blank>[-i<S2SV_blank>snapshot|bookmark]<S2SV_blank>" "<filesystem|volume|snapshot>\\n" "\\tsend<S2SV_blank>[-nvPe]<S2SV_blank>-t<S2SV_blank><receive_resume_token>\\n" ) ) ; case HELP_SET : return ( gettext ( "\\tset<S2SV_blank><property=value><S2SV_blank>...<S2SV_blank>" "<filesystem|volume|snapshot><S2SV_blank>...\\n" ) ) ; case HELP_SHARE : return ( gettext ( "\\tshare<S2SV_blank>[-l]<S2SV_blank><-a<S2SV_blank>[nfs|smb]<S2SV_blank>|<S2SV_blank>filesystem>\\n" ) ) ; case HELP_SNAPSHOT : return ( gettext ( "\\tsnapshot<S2SV_blank>[-r]<S2SV_blank>[-o<S2SV_blank>property=value]<S2SV_blank>...<S2SV_blank>" "<filesystem|volume>@<snap><S2SV_blank>...\\n" ) ) ; case HELP_UNMOUNT : return ( gettext ( "\\tunmount<S2SV_blank>[-f]<S2SV_blank>" "<-a<S2SV_blank>|<S2SV_blank>filesystem|mountpoint>\\n" ) ) ; case HELP_UNSHARE : return ( gettext ( "\\tunshare<S2SV_blank>" "<-a<S2SV_blank>[nfs|smb]<S2SV_blank>|<S2SV_blank>filesystem|mountpoint>\\n" ) ) ; case HELP_ALLOW : return ( gettext ( "\\tallow<S2SV_blank><filesystem|volume>\\n" "\\tallow<S2SV_blank>[-ldug]<S2SV_blank>" "<\\"everyone\\"|user|group>[,...]<S2SV_blank><perm|@setname>[,...]\\n" "\\t<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><filesystem|volume>\\n" "\\tallow<S2SV_blank>[-ld]<S2SV_blank>-e<S2SV_blank><perm|@setname>[,...]<S2SV_blank>" "<filesystem|volume>\\n" "\\tallow<S2SV_blank>-c<S2SV_blank><perm|@setname>[,...]<S2SV_blank><filesystem|volume>\\n" "\\tallow<S2SV_blank>-s<S2SV_blank>@setname<S2SV_blank><perm|@setname>[,...]<S2SV_blank>" "<filesystem|volume>\\n" ) ) ; case HELP_UNALLOW : return ( gettext ( "\\tunallow<S2SV_blank>[-rldug]<S2SV_blank>" "<\\"everyone\\"|user|group>[,...]\\n" "\\t<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<perm|@setname>[,...]]<S2SV_blank><filesystem|volume>\\n" "\\tunallow<S2SV_blank>[-rld]<S2SV_blank>-e<S2SV_blank>[<perm|@setname>[,...]]<S2SV_blank>" "<filesystem|volume>\\n" "\\tunallow<S2SV_blank>[-r]<S2SV_blank>-c<S2SV_blank>[<perm|@setname>[,...]]<S2SV_blank>" "<filesystem|volume>\\n" "\\tunallow<S2SV_blank>[-r]<S2SV_blank>-s<S2SV_blank>@setname<S2SV_blank>[<perm|@setname>[,...]]<S2SV_blank>" "<filesystem|volume>\\n" ) ) ; case HELP_USERSPACE : return ( gettext ( "\\tuserspace<S2SV_blank>[-Hinp]<S2SV_blank>[-o<S2SV_blank>field[,...]]<S2SV_blank>" "[-s<S2SV_blank>field]<S2SV_blank>...\\n" "\\t<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[-S<S2SV_blank>field]<S2SV_blank>...<S2SV_blank>[-t<S2SV_blank>type[,...]]<S2SV_blank>" "<filesystem|snapshot>\\n" ) ) ; case HELP_GROUPSPACE : return ( gettext ( "\\tgroupspace<S2SV_blank>[-Hinp]<S2SV_blank>[-o<S2SV_blank>field[,...]]<S2SV_blank>" "[-s<S2SV_blank>field]<S2SV_blank>...\\n" "\\t<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[-S<S2SV_blank>field]<S2SV_blank>...<S2SV_blank>[-t<S2SV_blank>type[,...]]<S2SV_blank>" "<filesystem|snapshot>\\n" ) ) ; case HELP_PROJECTSPACE : return ( gettext ( "\\tprojectspace<S2SV_blank>[-Hp]<S2SV_blank>[-o<S2SV_blank>field[,...]]<S2SV_blank>" "[-s<S2SV_blank>field]<S2SV_blank>...<S2SV_blank>\\n" "\\t<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[-S<S2SV_blank>field]<S2SV_blank>...<S2SV_blank><filesystem|snapshot>\\n" ) ) ; case HELP_PROJECT : return ( gettext ( "\\tproject<S2SV_blank>[-d|-r]<S2SV_blank><directory|file<S2SV_blank>...>\\n" "\\tproject<S2SV_blank>-c<S2SV_blank>[-0]<S2SV_blank>[-d|-r]<S2SV_blank>[-p<S2SV_blank>id]<S2SV_blank><directory|file<S2SV_blank>...>\\n" "\\tproject<S2SV_blank>-C<S2SV_blank>[-k]<S2SV_blank>[-r]<S2SV_blank><directory<S2SV_blank>...>\\n" "\\tproject<S2SV_blank>[-p<S2SV_blank>id]<S2SV_blank>[-r]<S2SV_blank>[-s]<S2SV_blank><directory<S2SV_blank>...>\\n" ) ) ; case HELP_HOLD : return ( gettext ( "\\thold<S2SV_blank>[-r]<S2SV_blank><tag><S2SV_blank><snapshot><S2SV_blank>...\\n" ) ) ; case HELP_HOLDS : return ( gettext ( "\\tholds<S2SV_blank>[-r]<S2SV_blank><snapshot><S2SV_blank>...\\n" ) ) ; case HELP_RELEASE : return ( gettext ( "\\trelease<S2SV_blank>[-r]<S2SV_blank><tag><S2SV_blank><snapshot><S2SV_blank>...\\n" ) ) ; case HELP_DIFF : return ( gettext ( "\\tdiff<S2SV_blank>[-FHt]<S2SV_blank><snapshot><S2SV_blank>" "[snapshot|filesystem]\\n" ) ) ; <S2SV_StartBug> case HELP_BOOKMARK : <S2SV_EndBug> return ( gettext ( "\\tbookmark<S2SV_blank><snapshot><S2SV_blank><bookmark>\\n" ) ) ; case HELP_CHANNEL_PROGRAM : return ( gettext ( "\\tprogram<S2SV_blank>[-jn]<S2SV_blank>[-t<S2SV_blank><instruction<S2SV_blank>limit>]<S2SV_blank>" "[-m<S2SV_blank><memory<S2SV_blank>limit<S2SV_blank>(b)>]<S2SV_blank><pool><S2SV_blank><program<S2SV_blank>file><S2SV_blank>" "[lua<S2SV_blank>args...]\\n" ) ) ; case HELP_LOAD_KEY : return ( gettext ( "\\tload-key<S2SV_blank>[-rn]<S2SV_blank>[-L<S2SV_blank><keylocation>]<S2SV_blank>" "<-a<S2SV_blank>|<S2SV_blank>filesystem|volume>\\n" ) ) ; case HELP_UNLOAD_KEY : return ( gettext ( "\\tunload-key<S2SV_blank>[-r]<S2SV_blank>" "<-a<S2SV_blank>|<S2SV_blank>filesystem|volume>\\n" ) ) ; case HELP_CHANGE_KEY : return ( gettext ( "\\tchange-key<S2SV_blank>[-l]<S2SV_blank>[-o<S2SV_blank>keyformat=<value>]\\n" "\\t<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[-o<S2SV_blank>keylocation=<value>]<S2SV_blank>[-o<S2SV_blank>pbkfd2iters=<value>]\\n" "\\t<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><filesystem|volume>\\n" "\\tchange-key<S2SV_blank>-i<S2SV_blank>[-l]<S2SV_blank><filesystem|volume>\\n" ) ) ; } abort ( ) ; } | <S2SV_ModStart> ) ; case HELP_REMAP : return ( gettext ( "\\tremap<S2SV_blank><filesystem<S2SV_blank>|<S2SV_blank>volume>\\n" ) ) ; case |
5,672 | CWE-000 int main ( int argc , char * argv [ ] ) { unsigned short port = 1337 ; <S2SV_StartBug> if ( argc > 1 ) tryOrDie ( ( port = atoi ( argv [ 1 ] ) ) == 0 , "Invalid<S2SV_blank>port.\\n" ) ; <S2SV_EndBug> else printf ( "usage:<S2SV_blank>%s<S2SV_blank>port\\n" , argv [ 0 ] ) , exit ( EXIT_FAILURE ) ; int socket_fd = initServer ( port ) ; fcntl ( socket_fd , F_SETFL , O_NONBLOCK ) ; printf ( "stage<S2SV_blank>1<S2SV_blank>program<S2SV_blank>by<S2SV_blank>(ma995)<S2SV_blank>listening<S2SV_blank>on<S2SV_blank>port<S2SV_blank>(%d)\\n" , port ) ; while ( 1 ) { int client_fd = accept ( socket_fd , NULL , NULL ) , i = 0 , found = 0 ; if ( client_fd >= 0 ) { fcntl ( client_fd , F_SETFL , O_NONBLOCK ) ; for ( i = 0 ; i < CLIENTS_MAX ; i ++ ) { if ( clients [ i ] ) continue ; <S2SV_StartBug> clients [ i ] = malloc ( sizeof ( struct client_connection ) ) ; <S2SV_EndBug> <S2SV_StartBug> memset ( clients [ i ] , 0 , sizeof ( struct client_connection ) ) ; <S2SV_EndBug> clients [ i ] -> client_fd = client_fd ; clients [ i ] -> lastReceived = time ( NULL ) ; found = 1 ; break ; } if ( found ) printf ( "CONNECTED:<S2SV_blank>fd=%2d\\n" , client_fd ) ; else close ( client_fd ) , printf ( "REJECTED:<S2SV_blank>reached<S2SV_blank>max<S2SV_blank>32<S2SV_blank>fds\\n" ) ; } for ( i = 0 ; i < CLIENTS_MAX ; i ++ ) { if ( ! clients [ i ] ) continue ; if ( handleClient ( clients [ i ] ) ) { printf ( "CLOSED:<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>fd=%2d\\n" , clients [ i ] -> client_fd ) ; if ( clients [ i ] -> header ) freeHttpReqHeader ( clients [ i ] -> header ) ; close ( clients [ i ] -> client_fd ) ; free ( clients [ i ] ) ; clients [ i ] = NULL ; } } nanosleep ( & ( struct timespec ) { . tv_sec = 0 , . tv_nsec = 1000000000L / 10 } , NULL ) ; } close ( socket_fd ) ; } | <S2SV_ModStart> if ( argc == 2 && isdigit ( * argv [ 1 ] ) ) <S2SV_ModEnd> port = atoi <S2SV_ModStart> [ 1 ] <S2SV_ModEnd> ) ; else <S2SV_ModStart> i ] = calloc ( 1 , <S2SV_ModEnd> sizeof ( struct <S2SV_ModStart> ) ) ; <S2SV_ModEnd> clients [ i |
5,673 | CWE-000 static gboolean InitializeHubStatusReader ( gpointer userdata ) { int fd ; int wd ; ssize_t length ; size_t i = 0 ; char buffer [ EVENT_BUF_LEN ] ; struct stat fdStat ; bool retVal = TRUE ; int result = stat ( HUBD_READY_FILE , & fdStat ) ; if ( result == 0 ) { HeavyOperationRoutineAdd ( & heavy_routine , registration , NULL , LunaRegistration , NULL ) ; return retVal ; } fd = inotify_init ( ) ; if ( fd < 0 ) { DbgPrint ( "error<S2SV_blank>while<S2SV_blank>inotify_init" ) ; return FALSE ; } wd = inotify_add_watch ( fd , INOTIFY_WATCH_PATH , IN_CREATE ) ; if ( wd == - 1 ) { DbgPrint ( "error<S2SV_blank>while<S2SV_blank>inotify_add_watch" ) ; close ( fd ) ; return FALSE ; } <S2SV_StartBug> length = read ( fd , buffer , EVENT_BUF_LEN ) ; <S2SV_EndBug> if ( length <= 0 ) { DbgPrint ( "error<S2SV_blank>while<S2SV_blank>reading" ) ; retVal = FALSE ; } else { while ( i >= 0 && i < length ) <S2SV_StartBug> { <S2SV_EndBug> struct inotify_event * event = ( struct inotify_event * ) & buffer [ i ] ; if ( ( event -> len ) && ( event -> mask & IN_CREATE ) ) { HeavyOperationRoutineAdd ( & heavy_routine , registration , NULL , LunaRegistration , NULL ) ; } i += EVENT_SIZE + event -> len ; } } inotify_rm_watch ( fd , wd ) ; close ( fd ) ; return retVal ; } | <S2SV_ModStart> FALSE ; } memset ( buffer , 0 , sizeof ( buffer ) ) ; <S2SV_ModStart> length ) { if ( ( i + EVENT_SIZE ) >= length ) { retVal = FALSE ; break ; } |
5,674 | CWE-000 void stop_decode_thread_omx ( aml_audio_dec_t * audec ) { audec -> exit_decode_thread = 1 ; int ret = amthreadpool_pthread_join ( audec -> sn_threadid , NULL ) ; <S2SV_StartBug> audec -> exit_decode_thread = 0 ; <S2SV_EndBug> audec -> sn_threadid = - 1 ; audec -> sn_getpackage_threadid = - 1 ; } | <S2SV_ModStart> ; audec -> <S2SV_ModEnd> sn_threadid = - |
5,675 | CWE-000 sctp_disposition_t sctp_sf_do_asconf_ack ( const struct sctp_endpoint * ep , const struct sctp_association * asoc , const sctp_subtype_t type , void * arg , sctp_cmd_seq_t * commands ) { struct sctp_chunk * asconf_ack = arg ; struct sctp_chunk * last_asconf = asoc -> addip_last_asconf ; struct sctp_chunk * abort ; struct sctp_paramhdr * err_param = NULL ; sctp_addiphdr_t * addip_hdr ; __u32 sent_serial , rcvd_serial ; if ( ! sctp_vtag_verify ( asconf_ack , asoc ) ) { sctp_add_cmd_sf ( commands , SCTP_CMD_REPORT_BAD_TAG , SCTP_NULL ( ) ) ; return sctp_sf_pdiscard ( ep , asoc , type , arg , commands ) ; } if ( ! sctp_addip_noauth && ! asconf_ack -> auth ) return sctp_sf_discard_chunk ( ep , asoc , type , arg , commands ) ; if ( ! sctp_chunk_length_valid ( asconf_ack , sizeof ( sctp_addip_chunk_t ) ) ) return sctp_sf_violation_chunklen ( ep , asoc , type , arg , commands ) ; addip_hdr = ( sctp_addiphdr_t * ) asconf_ack -> skb -> data ; rcvd_serial = ntohl ( addip_hdr -> serial ) ; if ( ! sctp_verify_asconf ( asoc , <S2SV_StartBug> ( sctp_paramhdr_t * ) addip_hdr -> params , <S2SV_EndBug> ( void * ) asconf_ack -> chunk_end , & err_param ) ) <S2SV_StartBug> return sctp_sf_violation_paramlen ( ep , asoc , type , arg , <S2SV_EndBug> ( void * ) err_param , commands ) ; if ( last_asconf ) { addip_hdr = ( sctp_addiphdr_t * ) last_asconf -> subh . addip_hdr ; sent_serial = ntohl ( addip_hdr -> serial ) ; } else { sent_serial = asoc -> addip_serial - 1 ; } if ( ADDIP_SERIAL_gte ( rcvd_serial , sent_serial + 1 ) && ! ( asoc -> addip_last_asconf ) ) { abort = sctp_make_abort ( asoc , asconf_ack , sizeof ( sctp_errhdr_t ) ) ; if ( abort ) { sctp_init_cause ( abort , SCTP_ERROR_ASCONF_ACK , 0 ) ; sctp_add_cmd_sf ( commands , SCTP_CMD_REPLY , SCTP_CHUNK ( abort ) ) ; } sctp_add_cmd_sf ( commands , SCTP_CMD_TIMER_STOP , SCTP_TO ( SCTP_EVENT_TIMEOUT_T4_RTO ) ) ; sctp_add_cmd_sf ( commands , SCTP_CMD_DISCARD_PACKET , SCTP_NULL ( ) ) ; sctp_add_cmd_sf ( commands , SCTP_CMD_SET_SK_ERR , SCTP_ERROR ( ECONNABORTED ) ) ; sctp_add_cmd_sf ( commands , SCTP_CMD_ASSOC_FAILED , SCTP_PERR ( SCTP_ERROR_ASCONF_ACK ) ) ; SCTP_INC_STATS ( SCTP_MIB_ABORTEDS ) ; SCTP_DEC_STATS ( SCTP_MIB_CURRESTAB ) ; return SCTP_DISPOSITION_ABORT ; } if ( ( rcvd_serial == sent_serial ) && asoc -> addip_last_asconf ) { sctp_add_cmd_sf ( commands , SCTP_CMD_TIMER_STOP , SCTP_TO ( SCTP_EVENT_TIMEOUT_T4_RTO ) ) ; if ( ! sctp_process_asconf_ack ( ( struct sctp_association * ) asoc , asconf_ack ) ) { sctp_add_cmd_sf ( commands , SCTP_CMD_SEND_NEXT_ASCONF , SCTP_NULL ( ) ) ; return SCTP_DISPOSITION_CONSUME ; } abort = sctp_make_abort ( asoc , asconf_ack , sizeof ( sctp_errhdr_t ) ) ; if ( abort ) { sctp_init_cause ( abort , SCTP_ERROR_RSRC_LOW , 0 ) ; sctp_add_cmd_sf ( commands , SCTP_CMD_REPLY , SCTP_CHUNK ( abort ) ) ; } sctp_add_cmd_sf ( commands , SCTP_CMD_DISCARD_PACKET , SCTP_NULL ( ) ) ; sctp_add_cmd_sf ( commands , SCTP_CMD_SET_SK_ERR , SCTP_ERROR ( ECONNABORTED ) ) ; sctp_add_cmd_sf ( commands , SCTP_CMD_ASSOC_FAILED , SCTP_PERR ( SCTP_ERROR_ASCONF_ACK ) ) ; SCTP_INC_STATS ( SCTP_MIB_ABORTEDS ) ; SCTP_DEC_STATS ( SCTP_MIB_CURRESTAB ) ; return SCTP_DISPOSITION_ABORT ; } return SCTP_DISPOSITION_DISCARD ; } | <S2SV_ModStart> ( asoc , asconf_ack , false , <S2SV_ModEnd> & err_param ) <S2SV_ModStart> return sctp_sf_violation_paramlen ( net , |
5,676 | CWE-000 allocator_t * allocator_create ( uint8_t allocator_type , uint8_t lock_type ) { allocator_t * p ; p = ( allocator_t * ) malloc ( sizeof ( allocator_t ) ) ; if ( p == NULL ) { dbg_str ( DBG_ERROR , "allocator_create" ) ; return p ; } p -> allocator_type = allocator_type ; p -> lock_type = lock_type ; p -> alloc_count = 0 ; <S2SV_StartBug> return p ; <S2SV_EndBug> } | <S2SV_ModStart> = 0 ; sync_lock_init ( & p -> head_lock , lock_type ) ; |
5,677 | CWE-000 uint32_t VisionDataStale ( void ) { <S2SV_StartBug> return vision_error_bits_ & VISION_ERROR_BIT_STALE ; <S2SV_EndBug> } | <S2SV_ModStart> ) { return error_bits_ <S2SV_ModEnd> & VISION_ERROR_BIT_STALE ; |
5,678 | CWE-000 static int unix_bind ( struct socket * sock , struct sockaddr * uaddr , int addr_len ) { struct sock * sk = sock -> sk ; struct net * net = sock_net ( sk ) ; struct unix_sock * u = unix_sk ( sk ) ; struct sockaddr_un * sunaddr = ( struct sockaddr_un * ) uaddr ; char * sun_path = sunaddr -> sun_path ; int err ; <S2SV_StartBug> unsigned int hash ; <S2SV_EndBug> struct unix_address * addr ; struct hlist_head * list ; err = - EINVAL ; if ( sunaddr -> sun_family != AF_UNIX ) goto out ; if ( addr_len == sizeof ( short ) ) { err = unix_autobind ( sock ) ; goto out ; } err = unix_mkname ( sunaddr , addr_len , & hash ) ; if ( err < 0 ) goto out ; addr_len = err ; err = mutex_lock_interruptible ( & u -> readlock ) ; if ( err ) goto out ; err = - EINVAL ; if ( u -> addr ) goto out_up ; err = - ENOMEM ; addr = kmalloc ( sizeof ( * addr ) + addr_len , GFP_KERNEL ) ; if ( ! addr ) goto out_up ; memcpy ( addr -> name , sunaddr , addr_len ) ; addr -> len = addr_len ; addr -> hash = hash ^ sk -> sk_type ; atomic_set ( & addr -> refcnt , 1 ) ; if ( sun_path [ 0 ] ) { struct path path ; umode_t mode = S_IFSOCK | ( SOCK_INODE ( sock ) -> i_mode & ~ current_umask ( ) ) ; path . dentry = NULL ; path . mnt = NULL ; err = unix_mknod ( sun_path , mode , & path ) ; if ( err ) { if ( err == - EEXIST ) err = - EADDRINUSE ; unix_release_addr ( addr ) ; goto out_up ; } addr -> hash = UNIX_HASH_SIZE ; hash = path . dentry -> d_inode -> i_ino & ( UNIX_HASH_SIZE - 1 ) ; spin_lock ( & unix_table_lock ) ; u -> path = path ; list = & unix_socket_table [ hash ] ; } else { spin_lock ( & unix_table_lock ) ; err = - EADDRINUSE ; if ( __unix_find_socket_byname ( net , sunaddr , addr_len , sk -> sk_type , hash ) ) { unix_release_addr ( addr ) ; goto out_unlock ; } list = & unix_socket_table [ addr -> hash ] ; } err = 0 ; __unix_remove_socket ( sk ) ; u -> addr = addr ; __unix_insert_socket ( list , sk ) ; out_unlock : spin_unlock ( & unix_table_lock ) ; out_up : mutex_unlock ( & u -> readlock ) ; out : return err ; } | <S2SV_ModStart> unsigned int hash = 0 |
5,679 | CWE-000 void proc_root_init ( void ) { procfs = 0 ; <S2SV_StartBug> void * p = malloc ( sizeof ( struct proc_dir_entry ) + 5 ) ; <S2SV_EndBug> root = ( struct proc_dir_entry * ) p ; root -> name = ( char * ) ( p + sizeof ( struct proc_dir_entry ) ) ; <S2SV_StartBug> strcpy ( root -> name , "proc" ) ; <S2SV_EndBug> root -> namelen = 4 ; root -> type = PDE_DIR ; root -> data = 0 ; root -> read_proc = read_dir_list ; root -> subdir = 0 ; root -> parent = root ; root -> next = 0 ; } | <S2SV_ModStart> = 0 ; root = pde_alloc ( PDE_DIR ) ; safestrcpy <S2SV_ModEnd> ( root -> <S2SV_ModStart> name , "proc" , 5 |
5,680 | CWE-000 static int dns_res_nameserv_cmp ( struct dns_rr * a , struct dns_rr * b , struct dns_rr_i * i , struct dns_packet * P ) { <S2SV_StartBug> _Bool glued [ 2 ] = { 0 } ; <S2SV_EndBug> struct dns_rr x = { 0 } , y = { 0 } ; struct dns_ns ns ; int cmp , error ; if ( ! ( error = dns_ns_parse ( & ns , a , P ) ) ) glued [ 0 ] = ! ! dns_rr_grep ( & x , 1 , dns_rr_i_new ( P , . section = ( DNS_S_ALL & ~ DNS_S_QD ) , . name = ns . host , . type = DNS_T_A ) , P , & error ) ; if ( ! ( error = dns_ns_parse ( & ns , b , P ) ) ) glued [ 1 ] = ! ! dns_rr_grep ( & y , 1 , dns_rr_i_new ( P , . section = ( DNS_S_ALL & ~ DNS_S_QD ) , . name = ns . host , . type = DNS_T_A ) , P , & error ) ; if ( ( cmp = glued [ 1 ] - glued [ 0 ] ) ) { return cmp ; } else if ( ( cmp = ( dns_rr_offset ( & y ) < i -> args [ 0 ] ) - ( dns_rr_offset ( & x ) < i -> args [ 0 ] ) ) ) { return cmp ; } else { return dns_rr_i_shuffle ( a , b , i , P ) ; } } | <S2SV_ModStart> P ) { dns_bool <S2SV_ModEnd> glued [ 2 |
5,681 | CWE-000 SYSCALL_DEFINE3 ( sched_setattr , pid_t , pid , struct sched_attr __user * , uattr , unsigned int , flags ) { struct sched_attr attr ; struct task_struct * p ; int retval ; if ( ! uattr || pid < 0 || flags ) return - EINVAL ; <S2SV_StartBug> if ( sched_copy_attr ( uattr , & attr ) ) <S2SV_EndBug> return - EFAULT ; rcu_read_lock ( ) ; retval = - ESRCH ; p = find_process_by_pid ( pid ) ; if ( p != NULL ) retval = sched_setattr ( p , & attr ) ; rcu_read_unlock ( ) ; return retval ; } | <S2SV_ModStart> - EINVAL ; retval = <S2SV_ModEnd> sched_copy_attr ( uattr <S2SV_ModStart> & attr ) ; if ( retval ) return retval <S2SV_ModEnd> ; rcu_read_lock ( |
5,682 | CWE-000 int c_4 ( _CMD_FSM_CB * cb ) { if ( cb -> token_value < _NUMBER_OF_CHANNELS ) { cb -> w_channel = cb -> token_value ; cb -> w_minutes = 0 ; cb -> w_hours = 0 ; strcpy ( cb -> prompt_buffer , "enter<S2SV_blank>action<S2SV_blank>for<S2SV_blank>channel<S2SV_blank>" ) ; strcat ( cb -> prompt_buffer , cb -> token ) ; <S2SV_StartBug> # if defined ( _ATRACE ) || defined ( _FTRACE ) <S2SV_EndBug> sprintf ( trace_buf , "c_4<S2SV_blank>called:<S2SV_blank>token<S2SV_blank><%s>,<S2SV_blank>token<S2SV_blank>value<S2SV_blank><%i>,<S2SV_blank>token<S2SV_blank>type<S2SV_blank><%i>,<S2SV_blank>state<S2SV_blank><%i>\\n" , cb -> token , cb -> token_value , cb -> token_type , cb -> state ) ; strace ( _TRACE_FILE_NAME , trace_buf , trace_flag ) ; sprintf ( trace_buf , "c_4<S2SV_blank>set<S2SV_blank>working<S2SV_blank>channel<S2SV_blank>to<S2SV_blank>%i\\n" , cb -> w_channel ) ; strace ( _TRACE_FILE_NAME , trace_buf , trace_flag ) ; # endif return 0 ; <S2SV_StartBug> } <S2SV_EndBug> <S2SV_StartBug> strcpy ( cb -> prompt_buffer , "channel<S2SV_blank>number<S2SV_blank>must<S2SV_blank>be<S2SV_blank>0<S2SV_blank>to<S2SV_blank>15\\r\\n><S2SV_blank>" ) ; <S2SV_EndBug> return 1 ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> token ) ; <S2SV_ModEnd> return 0 ; <S2SV_ModStart> 0 ; } else { <S2SV_ModStart> -> prompt_buffer , "channel<S2SV_blank>number<S2SV_blank>must<S2SV_blank>be<S2SV_blank>0<S2SV_blank>to<S2SV_blank>15\\r\\nenter<S2SV_blank>a<S2SV_blank>command" <S2SV_ModEnd> ) ; return <S2SV_ModStart> 1 ; } } |
5,683 | CWE-000 int xprt_rdma_bc_setup ( struct rpc_xprt * xprt , unsigned int reqs ) { struct rpcrdma_xprt * r_xprt = rpcx_to_rdmax ( xprt ) ; struct rpcrdma_buffer * buffer = & r_xprt -> rx_buf ; struct rpc_rqst * rqst ; unsigned int i ; int rc ; if ( reqs > RPCRDMA_BACKWARD_WRS >> 1 ) goto out_err ; for ( i = 0 ; i < ( reqs << 1 ) ; i ++ ) { rqst = kzalloc ( sizeof ( * rqst ) , GFP_KERNEL ) ; if ( ! rqst ) { pr_err ( "RPC:<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%s:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>bc<S2SV_blank>rpc_rqst\\n" , __func__ ) ; goto out_free ; } <S2SV_StartBug> rqst -> rq_xprt = & r_xprt -> rx_xprt ; <S2SV_EndBug> INIT_LIST_HEAD ( & rqst -> rq_list ) ; INIT_LIST_HEAD ( & rqst -> rq_bc_list ) ; if ( rpcrdma_bc_setup_rqst ( r_xprt , rqst ) ) goto out_free ; spin_lock_bh ( & xprt -> bc_pa_lock ) ; list_add ( & rqst -> rq_bc_pa_list , & xprt -> bc_pa_list ) ; spin_unlock_bh ( & xprt -> bc_pa_lock ) ; } rc = rpcrdma_bc_setup_reps ( r_xprt , reqs ) ; if ( rc ) goto out_free ; rc = rpcrdma_ep_post_extra_recv ( r_xprt , reqs ) ; if ( rc ) goto out_free ; buffer -> rb_bc_srv_max_requests = reqs ; request_module ( "svcrdma" ) ; return 0 ; out_free : xprt_rdma_bc_destroy ( xprt , reqs ) ; out_err : pr_err ( "RPC:<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%s:<S2SV_blank>setup<S2SV_blank>backchannel<S2SV_blank>transport<S2SV_blank>failed\\n" , __func__ ) ; return - ENOMEM ; } | <S2SV_ModStart> out_free ; } dprintk ( "RPC:<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%s:<S2SV_blank>new<S2SV_blank>rqst<S2SV_blank>%p\\n" , __func__ , rqst ) ; |
5,684 | CWE-000 static int vr_interface_change ( struct vr_interface * vif , vr_interface_req * req ) { <S2SV_StartBug> int ret = 0 ; <S2SV_EndBug> if ( req -> vifr_flags & VIF_FLAG_SERVICE_IF && ! ( vif -> vif_flags & VIF_FLAG_SERVICE_IF ) ) { ret = vr_interface_service_enable ( vif ) ; if ( ret ) return ret ; } else if ( ( vif -> vif_flags & VIF_FLAG_SERVICE_IF ) && ! ( req -> vifr_flags & VIF_FLAG_SERVICE_IF ) ) { vr_interface_service_disable ( vif ) ; } ret = vif_set_flags ( vif , req ) ; if ( ret ) return ret ; vif -> vif_mirror_id = req -> vifr_mir_id ; if ( ! ( vif -> vif_flags & VIF_FLAG_MIRROR_RX ) && ! ( vif -> vif_flags & VIF_FLAG_MIRROR_TX ) ) { vif -> vif_mirror_id = VR_MAX_MIRROR_INDICES ; } if ( req -> vifr_vrf >= 0 ) vif -> vif_vrf = req -> vifr_vrf ; if ( req -> vifr_mtu ) vif -> vif_mtu = req -> vifr_mtu ; vif -> vif_nh_id = ( unsigned short ) req -> vifr_nh_id ; vif -> vif_qos_map_index = req -> vifr_qos_map_index ; vif -> vif_isid = req -> vifr_isid ; if ( req -> vifr_pbb_mac_size ) VR_MAC_COPY ( vif -> vif_pbb_mac , req -> vifr_pbb_mac ) ; <S2SV_StartBug> ret = vr_interface_mirror_md_set ( vif , req ) ; <S2SV_EndBug> if ( ret ) return ret ; if ( ( ret = vif_fat_flow_add ( vif , req ) ) ) return ret ; return vlan_sub_interface_manage ( vif -> vif_parent , vif , req -> vifr_src_mac_size / VR_ETHER_ALEN , req -> vifr_src_mac ) ; } | <S2SV_ModStart> ret = 0 ; uint64_t * ip6 <S2SV_ModStart> vifr_pbb_mac ) ; vif -> vif_ip = req -> vifr_ip ; ip6 = ( uint64_t * ) ( vif -> vif_ip6 ) ; * ip6 = req -> vifr_ip6_u ; * ( ip6 + 1 ) = req -> vifr_ip6_l ; |
5,685 | CWE-000 int wolfTPM2_CreatePrimaryKey ( WOLFTPM2_DEV * dev , WOLFTPM2_KEY * key , TPM_HANDLE primaryHandle , TPMT_PUBLIC * publicTemplate , const byte * auth , int authSz ) { int rc ; CreatePrimary_In createPriIn ; CreatePrimary_Out createPriOut ; if ( dev == NULL || key == NULL || publicTemplate == NULL ) return BAD_FUNC_ARG ; XMEMSET ( key , 0 , sizeof ( WOLFTPM2_KEY ) ) ; XMEMSET ( & createPriIn , 0 , sizeof ( createPriIn ) ) ; createPriIn . primaryHandle = primaryHandle ; if ( auth && authSz > 0 ) { createPriIn . inSensitive . sensitive . userAuth . size = authSz ; XMEMCPY ( createPriIn . inSensitive . sensitive . userAuth . buffer , auth , createPriIn . inSensitive . sensitive . userAuth . size ) ; } XMEMCPY ( & createPriIn . inPublic . publicArea , publicTemplate , sizeof ( TPMT_PUBLIC ) ) ; rc = TPM2_CreatePrimary ( & createPriIn , & createPriOut ) ; if ( rc != TPM_RC_SUCCESS ) { printf ( "TPM2_CreatePrimary:<S2SV_blank>failed<S2SV_blank>%d:<S2SV_blank>%s\\n" , rc , wolfTPM2_GetRCString ( rc ) ) ; return rc ; } <S2SV_StartBug> key -> handle . hndl = createPriOut . objectHandle ; <S2SV_EndBug> key -> handle . auth = createPriIn . inSensitive . sensitive . userAuth ; key -> pub = createPriOut . outPublic ; key -> name = createPriOut . name ; # ifdef DEBUG_WOLFTPM printf ( "TPM2_CreatePrimary:<S2SV_blank>0x%x<S2SV_blank>(%d<S2SV_blank>bytes)\\n" , key -> handle . hndl , key -> pub . size ) ; # endif return rc ; } | <S2SV_ModStart> -> handle . dev = dev ; key -> handle . |
5,686 | CWE-000 <S2SV_StartBug> float test ( ) <S2SV_EndBug> { int a ; <S2SV_StartBug> int i ; <S2SV_EndBug> <S2SV_StartBug> for ( ; i > 2 ; i = 3 ) { <S2SV_EndBug> <S2SV_StartBug> i = 2 ; <S2SV_EndBug> } a = （3 + 4 ) * 5 ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> inline <S2SV_ModStart> ; int i = 0 ; a = ( i + 1 ) * 2 + a * 3 / 2 - 4 ; a = ( i + 1 ) * 2 + a * 3 / 2 - 4 <S2SV_ModStart> ; for ( i = 0 ; i < 100 ; i += 2 <S2SV_ModEnd> ) { i <S2SV_ModStart> ) { i += b ; } int b = 1 <S2SV_ModEnd> ; } <S2SV_null> |
5,687 | CWE-000 static void close_delayed_work ( struct work_struct * work ) { struct snd_soc_pcm_runtime * rtd = container_of ( work , struct snd_soc_pcm_runtime , delayed_work . work ) ; struct snd_soc_dai * codec_dai = rtd -> codec_dai ; mutex_lock_nested ( & rtd -> pcm_mutex , rtd -> pcm_subclass ) ; dev_dbg ( rtd -> dev , "ASoC:<S2SV_blank>pop<S2SV_blank>wq<S2SV_blank>checking:<S2SV_blank>%s<S2SV_blank>status:<S2SV_blank>%s<S2SV_blank>waiting:<S2SV_blank>%s\\n" , codec_dai -> driver -> playback . stream_name , codec_dai -> playback_active ? "active" : "inactive" , <S2SV_StartBug> codec_dai -> pop_wait ? "yes" : "no" ) ; <S2SV_EndBug> <S2SV_StartBug> if ( codec_dai -> pop_wait == 1 ) { <S2SV_EndBug> <S2SV_StartBug> codec_dai -> pop_wait = 0 ; <S2SV_EndBug> snd_soc_dapm_stream_event ( rtd , SNDRV_PCM_STREAM_PLAYBACK , SND_SOC_DAPM_STREAM_STOP ) ; } mutex_unlock ( & rtd -> pcm_mutex ) ; } | <S2SV_ModStart> : "inactive" , rtd <S2SV_ModEnd> -> pop_wait ? <S2SV_ModStart> ; if ( rtd <S2SV_ModEnd> -> pop_wait == <S2SV_ModStart> 1 ) { rtd <S2SV_ModEnd> -> pop_wait = |
5,688 | CWE-000 static PyObject * chain_next ( chainobject * lz ) { PyObject * item ; <S2SV_StartBug> if ( lz -> source == NULL ) <S2SV_EndBug> return NULL ; if ( lz -> active == NULL ) { PyObject * iterable = PyIter_Next ( lz -> source ) ; if ( iterable == NULL ) { Py_CLEAR ( lz -> source ) ; return NULL ; } lz -> active = PyObject_GetIter ( iterable ) ; Py_DECREF ( iterable ) ; if ( lz -> active == NULL ) { Py_CLEAR ( lz -> source ) ; return NULL ; } } <S2SV_StartBug> item = PyIter_Next ( lz -> active ) ; <S2SV_EndBug> if ( item != NULL ) return item ; if ( PyErr_Occurred ( ) ) { if ( PyErr_ExceptionMatches ( PyExc_StopIteration ) ) PyErr_Clear ( ) ; else return NULL ; } Py_CLEAR ( lz -> active ) ; <S2SV_StartBug> return chain_next ( lz ) ; <S2SV_EndBug> } | <S2SV_ModStart> * item ; while <S2SV_ModEnd> ( lz -> <S2SV_ModStart> lz -> source != NULL ) { <S2SV_ModEnd> if ( lz <S2SV_ModStart> } item = ( * Py_TYPE ( lz -> active ) -> tp_iternext ) <S2SV_ModEnd> ( lz -> <S2SV_ModStart> active ) ; } return NULL <S2SV_ModEnd> ; } <S2SV_null> |
5,689 | CWE-000 static void process_monitor ( ) { int i = 0 ; int ret = - 1 ; pid_t pid ; float memrate = 0.0 ; float cpurate = 0.0 ; long memvalue = 0 ; for ( i = 0 ; i < MAX_DAMEON_PROGRAMS_NUMS ; i ++ ) { if ( ! g_daemon_config -> prog_list [ i ] . dameon_switch ) { continue ; } if ( g_daemon_config -> prog_list [ i ] . safe_restart ) { fprintf ( log_stream , "INFO:<S2SV_blank>program<S2SV_blank>%s<S2SV_blank>received<S2SV_blank>update<S2SV_blank>restart<S2SV_blank>cmd,<S2SV_blank>now<S2SV_blank>try<S2SV_blank>to<S2SV_blank>restart\\n" , g_daemon_config -> prog_list [ i ] . program_name ) ; process_restart ( g_daemon_config -> prog_list [ i ] . program_name , g_daemon_config -> prog_list [ i ] . cmdline ) ; g_prog_state_list [ i ] . reboot_times ++ ; g_prog_state_list [ i ] . uptime = time ( NULL ) ; g_daemon_config -> prog_list [ i ] . safe_restart = false ; <S2SV_StartBug> continue ; <S2SV_EndBug> } ret = process_status_get ( g_daemon_config -> prog_list [ i ] . program_name ) ; if ( ret == 0 ) { ret = process_pid_get ( g_daemon_config -> prog_list [ i ] . program_name , & pid ) ; if ( ret == 0 ) { process_mem_rate_get ( pid , & memvalue , & memrate ) ; g_prog_state_list [ i ] . memrate = memrate * 100 * 1000 ; } else { fprintf ( log_stream , "ERROR:<S2SV_blank>can\'t<S2SV_blank>get<S2SV_blank>program<S2SV_blank>%s\'s<S2SV_blank>memory<S2SV_blank>info\\n\\n" , g_daemon_config -> prog_list [ i ] . program_name ) ; } } else { fprintf ( log_stream , "ERROR:<S2SV_blank>can\'t<S2SV_blank>get<S2SV_blank>program<S2SV_blank>%s\'s<S2SV_blank>status,<S2SV_blank>now<S2SV_blank>try<S2SV_blank>to<S2SV_blank>restart\\n" , g_daemon_config -> prog_list [ i ] . program_name ) ; process_restart ( g_daemon_config -> prog_list [ i ] . program_name , g_daemon_config -> prog_list [ i ] . cmdline ) ; g_prog_state_list [ i ] . reboot_times ++ ; g_prog_state_list [ i ] . uptime = time ( NULL ) ; } } } | <S2SV_ModStart> false ; continue ; } if ( g_remote_control_flag == REMOTE_CONTROL_ENABLE ) { process_remote_control ( REMOTE_CONTROL_ENABLE ) ; fprintf ( log_stream , "INFO:enable<S2SV_blank>remote<S2SV_blank>control<S2SV_blank>successful\\n" ) ; g_remote_control_flag = REMOTE_CONTROL_DISABLE |
5,690 | CWE-000 static zfs_acl_t * zfs_acl_inherit ( zfsvfs_t * zfsvfs , vtype_t vtype , zfs_acl_t * paclp , <S2SV_StartBug> uint64_t mode ) <S2SV_EndBug> { void * pacep = NULL ; void * acep ; zfs_acl_node_t * aclnode ; zfs_acl_t * aclp = NULL ; uint64_t who ; uint32_t access_mask ; uint16_t iflags , newflags , type ; size_t ace_size ; void * data1 , * data2 ; size_t data1sz , data2sz ; uint_t aclinherit ; <S2SV_StartBug> boolean_t isdir = ( vtype == VDIR ) ; <S2SV_EndBug> aclp = zfs_acl_alloc ( paclp -> z_version ) ; aclinherit = zfsvfs -> z_acl_inherit ; if ( aclinherit == ZFS_ACL_DISCARD || vtype == VLNK ) return ( aclp ) ; while ( pacep = zfs_acl_next_ace ( paclp , pacep , & who , & access_mask , & iflags , & type ) ) { if ( ! zfs_acl_valid_ace_type ( type , iflags ) ) continue ; if ( ( aclinherit == ZFS_ACL_NOALLOW && type == ALLOW ) || ! zfs_ace_can_use ( vtype , iflags ) ) <S2SV_StartBug> continue ; <S2SV_EndBug> if ( aclinherit == ZFS_ACL_PASSTHROUGH_X && type == ALLOW && ! isdir && ( ( mode & ( S_IXUSR | S_IXGRP | S_IXOTH ) ) == 0 ) ) { access_mask &= ~ ACE_EXECUTE ; } if ( aclinherit == ZFS_ACL_RESTRICTED && type == ALLOW ) { access_mask &= ~ RESTRICTED_CLEAR ; } ace_size = aclp -> z_ops . ace_size ( pacep ) ; aclnode = zfs_acl_node_alloc ( ace_size ) ; list_insert_tail ( & aclp -> z_acl , aclnode ) ; acep = aclnode -> z_acldata ; zfs_set_ace ( aclp , acep , access_mask , type , who , iflags | ACE_INHERITED_ACE ) ; if ( ( data1sz = paclp -> z_ops . ace_data ( pacep , & data1 ) ) != 0 ) { VERIFY ( ( data2sz = aclp -> z_ops . ace_data ( acep , & data2 ) ) == data1sz ) ; bcopy ( data1 , data2 , data2sz ) ; } aclp -> z_acl_count ++ ; aclnode -> z_ace_count ++ ; aclp -> z_acl_bytes += aclnode -> z_size ; newflags = aclp -> z_ops . ace_flags_get ( acep ) ; if ( ! isdir || ( iflags & ACE_NO_PROPAGATE_INHERIT_ACE ) ) { newflags &= ~ ALL_INHERIT ; aclp -> z_ops . ace_flags_set ( acep , newflags | ACE_INHERITED_ACE ) ; continue ; } aclp -> z_hints |= ZFS_INHERIT_ACE ; if ( ( iflags & ( ACE_FILE_INHERIT_ACE | ACE_DIRECTORY_INHERIT_ACE ) ) == ACE_FILE_INHERIT_ACE ) { newflags |= ACE_INHERIT_ONLY_ACE ; aclp -> z_ops . ace_flags_set ( acep , newflags | ACE_INHERITED_ACE ) ; } else { newflags &= ~ ACE_INHERIT_ONLY_ACE ; aclp -> z_ops . ace_flags_set ( acep , newflags | ACE_INHERITED_ACE ) ; } } return ( aclp ) ; } | <S2SV_ModStart> , uint64_t mode , boolean_t * need_chmod <S2SV_ModStart> == VDIR ) ; boolean_t isreg = ( vtype == VREG ) ; * need_chmod = B_TRUE <S2SV_ModStart> ) ) continue ; if ( ( aclinherit == ZFS_ACL_PASSTHROUGH || aclinherit == ZFS_ACL_PASSTHROUGH_X ) && ( ( iflags & ( ACE_OWNER | ACE_EVERYONE ) ) || ( ( iflags & OWNING_GROUP ) == OWNING_GROUP ) ) && ( isreg || ( isdir && ( iflags & ACE_DIRECTORY_INHERIT_ACE ) ) ) ) * need_chmod = B_FALSE |
5,691 | CWE-000 int main ( int InputArgumentsQ , char * * InputArguments ) { c_about ( ) ; writeln ; char * MENU [ 5 ] = { "EXIT" , "SHOW<S2SV_blank>VERBS<S2SV_blank>LIST" , "LEARNING<S2SV_blank>TEST" , "RESULT<S2SV_blank>TEST" , "ABOUT" } ; FILE * f ; int BoolOpen = 1 ; GLOBAL_VAR * GLOBAL = malloc ( sizeof ( GLOBAL_VAR ) ) ; GLOBAL -> preprevious = 0 ; GLOBAL -> previous = 0 ; GLOBAL -> d = malloc ( sizeof ( DATA ) * 99 ) ; if ( ( InputArgumentsQ > 1 ) && ( ! strcmp ( InputArguments [ 1 ] , "-n" ) ) ) BoolOpen = 0 ; if ( fileExists ( RUNFILE ) && BoolOpen ) { f = fopen ( RUNFILE , "rb" ) ; if ( f == NULL ) printf ( "Cann\'t<S2SV_blank>open<S2SV_blank>runfile\\n" ) ; else { fread ( GLOBAL , sizeof ( GLOBAL ) , 1 , f ) ; fclose ( f ) ; GLOBAL -> Console = 0 ; } } if ( ImportData ( GLOBAL ) == 0 ) { printf ( "Cann\'t<S2SV_blank>open<S2SV_blank>database<S2SV_blank>file.<S2SV_blank>App<S2SV_blank>will<S2SV_blank>be<S2SV_blank>closed\\n" ) ; return 1 ; } cls ; int GoToExit = 0 ; char choice ; while ( ! GoToExit ) { printf ( "Choose<S2SV_blank>action:\\n\\n" ) ; for ( int i = 0 ; i < 6 ; ++ i ) { printf ( "\\t(%d)<S2SV_blank>%s\\n" , i , MENU [ i ] ) ; } choice = '6' ; <S2SV_StartBug> while ( choice > '5' || choice < '0' ) <S2SV_EndBug> scanf ( "%c" , & choice ) ; if ( choice == '0' ) { writeln ; printf ( "Are<S2SV_blank>you<S2SV_blank>sure<S2SV_blank>you<S2SV_blank>want<S2SV_blank>to<S2SV_blank>quit?<S2SV_blank>y/n\\n" ) ; getchar ( ) ; choice = getchar ( ) ; if ( choice == 'y' ) GoToExit = 1 ; } switch ( choice ) { case '1' : <S2SV_StartBug> c_db ( ) ; <S2SV_EndBug> break ; case '2' : GLOBAL -> LearnTest = 1 ; c_test ( GLOBAL ) ; break ; case '3' : GLOBAL -> LearnTest = 0 ; c_test ( GLOBAL ) ; break ; <S2SV_StartBug> case '5' : <S2SV_EndBug> GLOBAL -> Console = 1 ; break ; case '6' : c_about ( ) ; break ; } cls ; } FILE * f = fopen ( RUNFILE , "wb+" ) ; if ( f != NULL ) { fwrite ( GLOBAL , sizeof ( GLOBAL_VAR ) , 1 , f ) ; fclose ( f ) ; } else { puts ( "Cann\'t<S2SV_blank>save<S2SV_blank>to<S2SV_blank>\'runfile.iv\'.<S2SV_blank>Press<S2SV_blank>any<S2SV_blank>key<S2SV_blank>to<S2SV_blank>continue..." ) ; getchar ( ) ; getchar ( ) ; } free ( GLOBAL ) ; return 0 ; } | <S2SV_ModStart> while ( choice <= '4' || choice >= <S2SV_ModEnd> '0' ) scanf <S2SV_ModStart> : c_db ( GLOBAL <S2SV_ModStart> break ; case '4' <S2SV_ModEnd> : c_about ( |
5,692 | CWE-000 REBTYPE ( Tuple ) { REBVAL * value ; REBVAL * arg ; <S2SV_StartBug> REBYTE * vp ; <S2SV_EndBug> <S2SV_StartBug> REBYTE * ap ; <S2SV_EndBug> REBINT len ; REBINT alen ; REBINT v ; REBINT a ; REBDEC dec ; value = D_ARG ( 1 ) ; if ( IS_TUPLE ( value ) ) { vp = VAL_TUPLE ( value ) ; len = VAL_TUPLE_LEN ( value ) ; } arg = D_ARG ( 2 ) ; if ( IS_BINARY_ACT ( action ) ) { if ( IS_INTEGER ( arg ) ) { a = VAL_INT32 ( arg ) ; ap = 0 ; } else if ( IS_DECIMAL ( arg ) || IS_PERCENT ( arg ) ) { dec = VAL_DECIMAL ( arg ) ; a = ( REBINT ) dec ; ap = 0 ; } else if ( IS_TUPLE ( arg ) ) { ap = VAL_TUPLE ( arg ) ; alen = VAL_TUPLE_LEN ( arg ) ; if ( len < alen ) len = VAL_TUPLE_LEN ( value ) = alen ; } else Trap_Math_Args ( REB_TUPLE , action ) ; for ( ; len > 0 ; len -- , vp ++ ) { v = * vp ; if ( ap ) a = ( REBINT ) * ap ++ ; switch ( action ) { case A_ADD : v += a ; break ; case A_SUBTRACT : v -= a ; break ; case A_MULTIPLY : if ( IS_DECIMAL ( arg ) || IS_PERCENT ( arg ) ) v = ( REBINT ) ( v * dec ) ; else v *= a ; break ; case A_DIVIDE : if ( IS_DECIMAL ( arg ) || IS_PERCENT ( arg ) ) { if ( dec == 0.0 ) Trap0 ( RE_ZERO_DIVIDE ) ; v = ( REBINT ) Round_Dec ( v / dec , 0 , 1.0 ) ; } else { if ( a == 0 ) Trap0 ( RE_ZERO_DIVIDE ) ; v /= a ; } break ; case A_REMAINDER : if ( a == 0 ) Trap0 ( RE_ZERO_DIVIDE ) ; v %= a ; break ; case A_AND : v &= a ; break ; case A_OR : v |= a ; break ; case A_XOR : v ^= a ; break ; default : Trap_Action ( REB_TUPLE , action ) ; } if ( v > 255 ) v = 255 ; else if ( v < 0 ) v = 0 ; * vp = ( REBYTE ) v ; } goto ret_value ; } if ( action == A_COMPLEMENT ) { for ( ; len > 0 ; len -- , vp ++ ) * vp = ( REBYTE ) ~ * vp ; goto ret_value ; } if ( action == A_RANDOM ) { if ( D_REF ( 2 ) ) Trap0 ( RE_BAD_REFINES ) ; for ( ; len > 0 ; len -- , vp ++ ) { if ( * vp ) * vp = ( REBYTE ) ( Random_Int ( D_REF ( 3 ) ) % ( 1 + * vp ) ) ; } goto ret_value ; } switch ( action ) { case A_LENGTHQ : len = MAX ( len , 3 ) ; DS_RET_INT ( len ) ; return R_RET ; case A_PICK : Pick_Path ( value , arg , 0 ) ; return R_TOS ; case A_REVERSE : if ( D_REF ( 2 ) ) { len = Get_Num_Arg ( D_ARG ( 3 ) ) ; if ( len < 0 ) Trap_Range ( D_ARG ( 3 ) ) ; len = MIN ( len , VAL_TUPLE_LEN ( value ) ) ; } if ( len > 0 ) { for ( v = 0 ; v < len / 2 ; v ++ ) { a = vp [ len - v - 1 ] ; vp [ len - v - 1 ] = vp [ v ] ; vp [ v ] = a ; } } goto ret_value ; case A_MAKE : case A_TO : if ( IS_TUPLE ( arg ) ) { return R_ARG2 ; } if ( IS_STRING ( arg ) ) { ap = Qualify_String ( arg , 11 * 4 + 1 , & len , FALSE ) ; if ( Scan_Tuple ( ap , len , D_RET ) ) return R_RET ; goto bad_arg ; } if ( ANY_BLOCK ( arg ) ) { if ( ! MT_Tuple ( D_RET , VAL_BLK_DATA ( arg ) , REB_TUPLE ) ) Trap_Make ( REB_TUPLE , arg ) ; return R_RET ; } VAL_SET ( value , REB_TUPLE ) ; vp = VAL_TUPLE ( value ) ; if ( IS_ISSUE ( arg ) ) { REBUNI c ; ap = Get_Word_Name ( arg ) ; len = LEN_BYTES ( ap ) ; if ( len & 1 ) goto bad_arg ; len /= 2 ; if ( len > MAX_TUPLE ) goto bad_arg ; VAL_TUPLE_LEN ( value ) = len ; for ( alen = 0 ; alen < len ; alen ++ ) { if ( ! Scan_Hex2 ( ap , & c , 0 ) ) goto bad_arg ; * vp ++ = ( REBYTE ) c ; ap += 2 ; } } else if ( IS_BINARY ( arg ) ) { ap = VAL_BIN_DATA ( arg ) ; len = VAL_LEN ( arg ) ; if ( len > MAX_TUPLE ) len = MAX_TUPLE ; VAL_TUPLE_LEN ( value ) = len ; for ( alen = 0 ; alen < len ; alen ++ ) * vp ++ = * ap ++ ; } else goto bad_arg ; for ( ; alen < MAX_TUPLE ; alen ++ ) * vp ++ = 0 ; goto ret_value ; bad_arg : Trap_Make ( REB_TUPLE , arg ) ; } Trap_Action ( REB_TUPLE , action ) ; ret_value : * DS_RETURN = * value ; return R_RET ; } | <S2SV_ModStart> REBYTE * vp = NULL <S2SV_ModStart> REBYTE * ap = NULL |
5,693 | CWE-000 static struct sk_buff * ixgbe_run_xdp ( struct ixgbe_adapter * adapter , struct ixgbe_ring * rx_ring , struct xdp_buff * xdp ) { <S2SV_StartBug> int result = IXGBE_XDP_PASS ; <S2SV_EndBug> struct bpf_prog * xdp_prog ; u32 act ; rcu_read_lock ( ) ; xdp_prog = READ_ONCE ( rx_ring -> xdp_prog ) ; if ( ! xdp_prog ) goto xdp_out ; act = bpf_prog_run_xdp ( xdp_prog , xdp ) ; switch ( act ) { case XDP_PASS : break ; case XDP_TX : <S2SV_StartBug> result = ixgbe_xmit_xdp_ring ( adapter , xdp ) ; <S2SV_EndBug> break ; default : bpf_warn_invalid_xdp_action ( act ) ; case XDP_ABORTED : trace_xdp_exception ( rx_ring -> netdev , xdp_prog , act ) ; case XDP_DROP : result = IXGBE_XDP_CONSUMED ; break ; } xdp_out : rcu_read_unlock ( ) ; return ERR_PTR ( - result ) ; } | <S2SV_ModStart> ) { int err , <S2SV_ModStart> , xdp ) ; break ; case XDP_REDIRECT : err = xdp_do_redirect ( adapter -> netdev , xdp , xdp_prog ) ; if ( ! err ) result = IXGBE_XDP_TX ; else result = IXGBE_XDP_CONSUMED |
5,694 | CWE-000 int main ( int argc , char * * argv ) { clock_t clockstart , clockdiff ; uint32_t msec = 0 ; uint64_t code_addr = 0 ; uint32_t code_len = 0 ; uint32_t offset = 0 ; printf ( "\\nDisassembler<S2SV_blank>Benchmark:<S2SV_blank>%s\\n\\n" , argv [ 0 ] ) ; devnull = fopen ( "nul" , "w" ) ; if ( devnull == NULL ) { fputs ( "could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>\'nul\'" , stderr ) ; return 1 ; } disas_init ( ) ; code_len = 1024 * 1024 ; code_addr = 0x00007fff00000000 + ( uint32_t ) GetModuleHandleA ( "kernelbase.dll" ) + 0x1000 ; printf ( "target:<S2SV_blank>kernelbase.dll<S2SV_blank>.text\\n" ) ; printf ( "<S2SV_blank><S2SV_blank>addr:<S2SV_blank>0x%llx\\n" , code_addr ) ; printf ( "length:<S2SV_blank>%d<S2SV_blank>bytes\\n\\n" , code_len ) ; printf ( "Benchmark:<S2SV_blank>decode<S2SV_blank>to<S2SV_blank>struct<S2SV_blank>speed..<S2SV_blank>\\n" ) ; clockstart = clock ( ) ; benchmark_decode_bytes ( code_addr , code_len ) ; clockdiff = clock ( ) - clockstart ; msec = clockdiff * 1000 / CLOCKS_PER_SEC ; <S2SV_StartBug> printf ( "Time<S2SV_blank>elapsed:<S2SV_blank>%d.%ds\\n\\n" , msec / 1000 , msec % 1000 ) ; <S2SV_EndBug> printf ( "Benchmark:<S2SV_blank>decode<S2SV_blank>to<S2SV_blank>ascii<S2SV_blank>speed..<S2SV_blank>\\n" ) ; clockstart = clock ( ) ; benchmark_decode_ascii ( code_addr , code_len ) ; clockdiff = clock ( ) - clockstart ; msec = clockdiff * 1000 / CLOCKS_PER_SEC ; <S2SV_StartBug> printf ( "Time<S2SV_blank>elapsed:<S2SV_blank>%d.%ds\\n\\n" , msec / 1000 , msec % 1000 ) ; <S2SV_EndBug> printf ( "Benchmark:<S2SV_blank>print<S2SV_blank>ascii<S2SV_blank>to<S2SV_blank>/dev/null<S2SV_blank>speed..<S2SV_blank>\\n" ) ; clockstart = clock ( ) ; benchmark_decode_print ( code_addr , code_len ) ; clockdiff = clock ( ) - clockstart ; msec = clockdiff * 1000 / CLOCKS_PER_SEC ; <S2SV_StartBug> printf ( "Time<S2SV_blank>elapsed:<S2SV_blank>%d.%ds\\n\\n" , msec / 1000 , msec % 1000 ) ; <S2SV_EndBug> printf ( "Benchmark:<S2SV_blank>decoder<S2SV_blank>accuracy..<S2SV_blank>\\n" ) ; clockstart = clock ( ) ; benchmark_accuracy ( code_addr , code_len ) ; clockdiff = clock ( ) - clockstart ; msec = clockdiff * 1000 / CLOCKS_PER_SEC ; printf ( "%d<S2SV_blank>decoded,<S2SV_blank>%d<S2SV_blank>errors\\n" , insn_count , error_count ) ; <S2SV_StartBug> printf ( "Time<S2SV_blank>elapsed:<S2SV_blank>%d.%ds\\n\\n" , msec / 1000 , msec % 1000 ) ; <S2SV_EndBug> printf ( "Disassembler<S2SV_blank>Benchmark<S2SV_blank>complete.\\n\\n" ) ; fclose ( devnull ) ; disas_fini ( ) ; return 0 ; } | <S2SV_ModStart> ; printf ( "Time<S2SV_blank>elapsed:<S2SV_blank>%d.%03ds\\n\\n" <S2SV_ModEnd> , msec / <S2SV_ModStart> ; printf ( "Time<S2SV_blank>elapsed:<S2SV_blank>%d.%03ds\\n\\n" <S2SV_ModEnd> , msec / <S2SV_ModStart> ; printf ( "Time<S2SV_blank>elapsed:<S2SV_blank>%d.%03ds\\n\\n" <S2SV_ModEnd> , msec / <S2SV_ModStart> ; printf ( "Time<S2SV_blank>elapsed:<S2SV_blank>%d.%03ds\\n\\n" <S2SV_ModEnd> , msec / |
5,695 | CWE-000 static void usb_release_dev ( struct device * dev ) { struct usb_device * udev ; struct usb_hcd * hcd ; udev = to_usb_device ( dev ) ; hcd = bus_to_hcd ( udev -> bus ) ; usb_destroy_configuration ( udev ) ; usb_release_bos_descriptor ( udev ) ; <S2SV_StartBug> if ( udev -> parent ) <S2SV_EndBug> of_node_put ( dev -> of_node ) ; usb_put_hcd ( hcd ) ; kfree ( udev -> product ) ; kfree ( udev -> manufacturer ) ; kfree ( udev -> serial ) ; kfree ( udev ) ; } | <S2SV_ModStart> udev ) ; <S2SV_ModEnd> of_node_put ( dev |
5,696 | CWE-000 <S2SV_StartBug> void char_set_login_all_offline ( void ) <S2SV_EndBug> { WFIFOHEAD ( chr -> login_fd , 2 ) ; WFIFOW ( chr -> login_fd , 0 ) = 0x2737 ; WFIFOSET ( chr -> login_fd , 2 ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static |
5,697 | CWE-000 void graph_breadth_first_traverse ( struct graph * g , int start_node , traverse_cb cb , void * arg ) { int curnode ; struct list_node queue , * adj_nodes ; struct hash_table * t = create_hash_table ( 20 , traverse_hash_code , traverse_key_match_cb , traverse_key_removed_cb ) ; queue_init ( & queue ) ; enqueue ( & queue , INT_TO_PTR ( start_node ) ) ; while ( ! queue_empty ( & queue ) ) { curnode = PTR_TO_INT ( dequeue ( & queue ) ) ; if ( hash_table_key_exist ( t , INT_TO_PTR ( curnode ) ) ) { adj_nodes = hash_table_get ( t , INT_TO_PTR ( curnode ) ) ; } else { cb ( curnode , arg ) ; adj_nodes = ( struct list_node * ) malloc ( sizeof ( * adj_nodes ) ) ; list_init ( adj_nodes ) ; graph_get_adjacent_nodes ( g , curnode , adj_nodes ) ; hash_table_put ( t , INT_TO_PTR ( curnode ) , ( void * ) adj_nodes ) ; } list_delete_by_cond ( adj_nodes , remove_visited_adj , t ) ; list_iterate ( adj_nodes , enqueue_adj_iterate , & queue ) ; if ( ! list_empty ( adj_nodes ) ) { enqueue ( & queue , INT_TO_PTR ( curnode ) ) ; } } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ; } } release_hash_table ( t ) ; queue_clear ( & queue ) ; |
5,698 | CWE-000 FAR struct inode * inode_find ( FAR const char * path , FAR const char * * relpath , bool nofollow ) { struct inode_search_s desc ; FAR struct inode * node = NULL ; int ret ; if ( path == NULL || * path != '/' ) { return NULL ; } <S2SV_StartBug> memset ( & desc , 0 , sizeof ( struct inode_search_s ) ) ; <S2SV_EndBug> desc . path = path ; # ifdef CONFIG_PSEUDOFS_SOFTLINKS desc . nofollow = nofollow ; # endif inode_semtake ( ) ; ret = inode_search ( & desc ) ; if ( ret >= 0 ) { node = desc . node ; DEBUGASSERT ( node != NULL ) ; node -> i_crefs ++ ; if ( relpath != NULL ) { * relpath = desc . relpath ; } } inode_semgive ( ) ; return node ; } | <S2SV_ModStart> NULL ; } RESET_SEARCH <S2SV_ModEnd> ( & desc <S2SV_ModStart> ( & desc <S2SV_ModEnd> ) ; desc |
5,699 | CWE-000 ssize_t ib_uverbs_destroy_qp ( struct ib_uverbs_file * file , struct ib_device * ib_dev , const char __user * buf , int in_len , int out_len ) { struct ib_uverbs_destroy_qp cmd ; struct ib_uverbs_destroy_qp_resp resp ; struct ib_uobject * uobj ; <S2SV_StartBug> struct ib_qp * qp ; <S2SV_EndBug> struct ib_uqp_object * obj ; int ret = - EINVAL ; if ( copy_from_user ( & cmd , buf , sizeof cmd ) ) return - EFAULT ; memset ( & resp , 0 , sizeof resp ) ; uobj = uobj_get_write ( uobj_get_type ( qp ) , cmd . qp_handle , file -> ucontext ) ; if ( IS_ERR ( uobj ) ) return PTR_ERR ( uobj ) ; <S2SV_StartBug> qp = uobj -> object ; <S2SV_EndBug> obj = container_of ( uobj , struct ib_uqp_object , uevent . uobject ) ; uverbs_uobject_get ( uobj ) ; ret = uobj_remove_commit ( uobj ) ; if ( ret ) { uverbs_uobject_put ( uobj ) ; return ret ; } resp . events_reported = obj -> uevent . events_reported ; uverbs_uobject_put ( uobj ) ; if ( copy_to_user ( ( void __user * ) ( unsigned long ) cmd . response , & resp , sizeof resp ) ) return - EFAULT ; return in_len ; } | <S2SV_ModStart> uobj ; struct <S2SV_ModEnd> ib_uqp_object * obj <S2SV_ModStart> uobj ) ; <S2SV_ModEnd> obj = container_of |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.