Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
500 | CWE-000 static void mono_w32handle_lock_handles ( MonoW32Handle * * handles_data , gsize nhandles ) { gint i , j , iter = 0 ; # ifndef HOST_WIN32 struct timespec sleepytime ; # endif again : for ( i = 0 ; i < nhandles ; i ++ ) { if ( ! mono_w32handle_trylock ( handles_data [ i ] ) ) { for ( j = i - 1 ; j >= 0 ; j -- ) mono_w32handle_unlock ( handles_data [ j ] ) ; iter += 10 ; if ( iter == 1000 ) iter = 10 ; <S2SV_StartBug> # ifdef HOST_WIN32 <S2SV_EndBug> SleepEx ( iter , TRUE ) ; # else g_assert ( iter < 1000 ) ; sleepytime . tv_sec = 0 ; sleepytime . tv_nsec = iter * 1000000 ; nanosleep ( & sleepytime , NULL ) ; # endif <S2SV_StartBug> goto again ; <S2SV_EndBug> } } mono_trace ( G_LOG_LEVEL_DEBUG , MONO_TRACE_IO_LAYER_HANDLE , "%s:<S2SV_blank>Locked<S2SV_blank>all<S2SV_blank>handles" , __func__ ) ; } | <S2SV_ModStart> = 10 ; MONO_ENTER_GC_SAFE ; <S2SV_ModStart> ; # endif MONO_EXIT_GC_SAFE ; |
501 | CWE-000 static void PrintGeneralInfo ( void ) { DBUG_ENTER ( "PrintGeneralInfo" ) ; printf ( "\\n\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>civicc<S2SV_blank><S2SV_blank>--<S2SV_blank><S2SV_blank>Programming<S2SV_blank>C,<S2SV_blank><S2SV_blank>the<S2SV_blank>civilised<S2SV_blank>way\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>------------------------------------------------\\n" ) ; printf ( "\\n\\nSPECIAL<S2SV_blank>OPTIONS:\\n\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-h<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Display<S2SV_blank>this<S2SV_blank>helptext.\\n" ) ; printf ( "\\n\\nGENERAL<S2SV_blank>OPTIONS:\\n\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><filename><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Name<S2SV_blank>of<S2SV_blank>program<S2SV_blank>file<S2SV_blank>to<S2SV_blank>compile.\\n\\n" <S2SV_StartBug> "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-ep<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Enable<S2SV_blank>pre-processor.\\n\\n" <S2SV_EndBug> "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-I<S2SV_blank><dirame><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Name<S2SV_blank>of<S2SV_blank>the<S2SV_blank>directory<S2SV_blank>containing<S2SV_blank>the<S2SV_blank>CiviC<S2SV_blank>system<S2SV_blank>header<S2SV_blank>files.<S2SV_blank>Use<S2SV_blank>in<S2SV_blank>conjunstion<S2SV_blank>with<S2SV_blank>the<S2SV_blank>\'-ep\'<S2SV_blank>flag.\\n\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-o<S2SV_blank><filename><S2SV_blank><S2SV_blank><S2SV_blank>Name<S2SV_blank>of<S2SV_blank>output<S2SV_blank>file.\\n\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-v<S2SV_blank><n><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Verbosity<S2SV_blank>level<S2SV_blank>(default:<S2SV_blank>%d).\\n\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-eap<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Enable<S2SV_blank>printing<S2SV_blank>of<S2SV_blank>the<S2SV_blank>AST<S2SV_blank>in<S2SV_blank>C-style.\\n\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-dstp<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Disable<S2SV_blank>printing<S2SV_blank>of<S2SV_blank>the<S2SV_blank>symbol<S2SV_blank>table<S2SV_blank>information.\\n\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-pvd<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Prints<S2SV_blank>variable<S2SV_blank>details<S2SV_blank>from<S2SV_blank>the<S2SV_blank>symbol<S2SV_blank>table<S2SV_blank>at<S2SV_blank>variable<S2SV_blank>usage.\\n\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-tc<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Apply<S2SV_blank>syntax<S2SV_blank>tree<S2SV_blank>consistency<S2SV_blank>checks.\\n\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-#d,<id><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Print<S2SV_blank>debugging<S2SV_blank>information<S2SV_blank>for<S2SV_blank>tag<S2SV_blank><id>.\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Supported<S2SV_blank>tags<S2SV_blank>are:\\n\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>MAKE<S2SV_blank>-<S2SV_blank>prints<S2SV_blank>debug<S2SV_blank>information<S2SV_blank>of<S2SV_blank>tree<S2SV_blank>constructors.\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>SA<S2SV_blank><S2SV_blank><S2SV_blank>-<S2SV_blank>prints<S2SV_blank>debug<S2SV_blank>information<S2SV_blank>of<S2SV_blank>scope<S2SV_blank>analysis.\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>SV<S2SV_blank><S2SV_blank><S2SV_blank>-<S2SV_blank>prints<S2SV_blank>debug<S2SV_blank>information<S2SV_blank>of<S2SV_blank>Split<S2SV_blank>VarDef<S2SV_blank>transformation.\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>GI<S2SV_blank><S2SV_blank><S2SV_blank>-<S2SV_blank>prints<S2SV_blank>debug<S2SV_blank>information<S2SV_blank>of<S2SV_blank>Global<S2SV_blank>Init<S2SV_blank>transformation.\\n" <S2SV_StartBug> "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>UTIL<S2SV_blank>-<S2SV_blank>prints<S2SV_blank>debug<S2SV_blank>information<S2SV_blank>of<S2SV_blank>miscellaneous<S2SV_blank>utils.\\n" <S2SV_EndBug> "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>FREE<S2SV_blank>-<S2SV_blank>prints<S2SV_blank>debug<S2SV_blank>information<S2SV_blank>of<S2SV_blank>tree<S2SV_blank>destructors.\\n" , global . verbosity ) ; DBUG_VOID_RETURN ; } | <S2SV_ModStart> ( "\\n\\nGENERAL<S2SV_blank>OPTIONS:\\n\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><filename><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Name<S2SV_blank>of<S2SV_blank>program<S2SV_blank>file<S2SV_blank>to<S2SV_blank>compile.\\n\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-epp<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Enable<S2SV_blank>pre-processor.\\n\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-kppf<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Keep<S2SV_blank>the<S2SV_blank>pre-processed<S2SV_blank>file.<S2SV_blank>(The<S2SV_blank>pre-processor<S2SV_blank>uses<S2SV_blank>a<S2SV_blank>hidden<S2SV_blank>file<S2SV_blank>for<S2SV_blank>storing<S2SV_blank>its<S2SV_blank>output.\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>This<S2SV_blank>file<S2SV_blank>is<S2SV_blank>removed<S2SV_blank>by<S2SV_blank>default,<S2SV_blank>but<S2SV_blank>this<S2SV_blank>flag<S2SV_blank>can<S2SV_blank>be<S2SV_blank>used<S2SV_blank>to<S2SV_blank>disable<S2SV_blank>this<S2SV_blank>removal.)\\n\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-I<S2SV_blank><dirame><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Name<S2SV_blank>of<S2SV_blank>the<S2SV_blank>directory<S2SV_blank>containing<S2SV_blank>the<S2SV_blank>CiviC<S2SV_blank>system<S2SV_blank>header<S2SV_blank>files.<S2SV_blank>Use<S2SV_blank>in<S2SV_blank>conjunction<S2SV_blank>with<S2SV_blank>the<S2SV_blank>\'-epp\'<S2SV_blank>flag.\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>The<S2SV_blank>compiler<S2SV_blank>uses<S2SV_blank>the<S2SV_blank>environment<S2SV_blank>variable<S2SV_blank>\'C_INCLUDE_PATH\'<S2SV_blank>or<S2SV_blank>\'.\'<S2SV_blank>if<S2SV_blank>it<S2SV_blank>is<S2SV_blank>not<S2SV_blank>set.\\n\\n" <S2SV_ModEnd> "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-o<S2SV_blank><filename><S2SV_blank><S2SV_blank><S2SV_blank>Name<S2SV_blank>of<S2SV_blank>output<S2SV_blank>file.\\n\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-v<S2SV_blank><n><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Verbosity<S2SV_blank>level<S2SV_blank>(default:<S2SV_blank>%d).\\n\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-eap<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Enable<S2SV_blank>printing<S2SV_blank>of<S2SV_blank>the<S2SV_blank>AST<S2SV_blank>in<S2SV_blank>C-style.\\n\\n" <S2SV_ModStart> "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>SA<S2SV_blank><S2SV_blank><S2SV_blank>-<S2SV_blank>prints<S2SV_blank>debug<S2SV_blank>information<S2SV_blank>of<S2SV_blank>scope<S2SV_blank>analysis.\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>SV<S2SV_blank><S2SV_blank><S2SV_blank>-<S2SV_blank>prints<S2SV_blank>debug<S2SV_blank>information<S2SV_blank>of<S2SV_blank>Split<S2SV_blank>VarDef<S2SV_blank>transformation.\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>GI<S2SV_blank><S2SV_blank><S2SV_blank>-<S2SV_blank>prints<S2SV_blank>debug<S2SV_blank>information<S2SV_blank>of<S2SV_blank>Global<S2SV_blank>Init<S2SV_blank>transformation.\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>OP<S2SV_blank><S2SV_blank><S2SV_blank>-<S2SV_blank>prints<S2SV_blank>debug<S2SV_blank>information<S2SV_blank>of<S2SV_blank>optimisations.\\n" |
502 | CWE-000 void __cimplog ( const char * module , int level , const char * msg , ... ) { static const char * _level [ ] = { "Error" , "Info" , "Debug" , "Unknown" } ; va_list arg_ptr ; char buf [ MAX_BUF_SIZE ] ; int nbytes ; <S2SV_StartBug> struct timespec ts ; <S2SV_EndBug> printf ( "cimplog<S2SV_blank>--<S2SV_blank>cimplog_debug_level<S2SV_blank>=<S2SV_blank>%d\\n" , cimplog_debug_level ) ; if ( level <= cimplog_debug_level ) { va_start ( arg_ptr , msg ) ; nbytes = vsnprintf ( buf , MAX_BUF_SIZE , msg , arg_ptr ) ; va_end ( arg_ptr ) ; if ( nbytes >= MAX_BUF_SIZE ) { buf [ MAX_BUF_SIZE - 1 ] = '\\0' ; } else { buf [ nbytes ] = '\\0' ; } clock_gettime ( CLOCK_REALTIME , & ts ) ; printf ( "[%09ld][%s][%s]:<S2SV_blank>%s" , ts . tv_sec , module , _level [ 0x3 & level ] , buf ) ; } } | <S2SV_ModStart> struct timespec ts <S2SV_ModEnd> ; if ( |
503 | CWE-000 int start_shmem ( int argc , char * * argv , unsigned char * raw , int len , callback_ptr cb ) { int i ; <S2SV_StartBug> if ( raw ) SHMEM_UseMemory ( raw , len ) ; <S2SV_EndBug> if ( ! Atari800_Initialise ( & argc , argv ) ) return 3 ; <S2SV_StartBug> input_template_t * input = SHMEM_GetInputArray ( ) ; <S2SV_EndBug> i = 0 ; for ( ; ; ) { for ( ; ; ) { if ( input -> main_semaphore == 0 ) { # ifdef DEBUG printf ( "Found<S2SV_blank>0;<S2SV_blank>getting<S2SV_blank>frame" ) ; # endif break ; } else if ( input -> main_semaphore == 0xff | input -> main_semaphore == 2 ) { # ifdef DEBUG printf ( "Found<S2SV_blank>0xff;<S2SV_blank>stopping!\\n" ) ; # endif return 0 ; } # ifdef DEBUG printf ( "didn\'t<S2SV_blank>find<S2SV_blank>0<S2SV_blank>or<S2SV_blank>0xff:<S2SV_blank>%d\\n" , input -> main_semaphore ) ; # endif Util_sleep ( 0.001 ) ; } SHMEM_TakeInputArraySnapshot ( ) ; INPUT_key_code = PLATFORM_Keyboard ( ) ; SHMEM_Mouse ( ) ; Atari800_Frame ( ) ; if ( Atari800_display_screen ) PLATFORM_DisplayScreen ( ) ; i ++ ; input -> main_semaphore = 1 ; if ( i > 100 ) { if ( cb ) { ( * cb ) ( shared_memory ) ; } } } return 0 ; } | <S2SV_ModStart> int i ; input_template_t * input ; <S2SV_ModStart> return 3 ; <S2SV_ModEnd> input = SHMEM_GetInputArray |
504 | CWE-000 int test_leftBitCount ( int x ) { int result = 0 ; int i ; <S2SV_StartBug> for ( i = 31 ; i >= 0 ; i -- ) { <S2SV_EndBug> <S2SV_StartBug> int bit = ( x >> i ) & 0x1 ; <S2SV_EndBug> if ( ! bit ) break ; result ++ ; } <S2SV_StartBug> return result ; <S2SV_EndBug> } | <S2SV_ModStart> ; i >= 1 <S2SV_ModEnd> ; i -- <S2SV_ModStart> ( x >> ( i - 1 ) >> 1 <S2SV_ModEnd> ) & 0x1 <S2SV_ModStart> ++ ; } int bit = ( x >> 0 ) & 0x1 ; if ( bit ) result ++ ; |
505 | CWE-000 { { util . g_ctx_t ( ) } } * { { g . name } } _create ( ) { # ifdef CNC_DEBUG_LOG if ( ! cncDebugLog ) { cncDebugLog = fopen ( CNC_DEBUG_LOG , "w" ) ; } # endif ocrGuid_t contextGuid ; { { util . g_ctx_param ( ) } } ; u64 ctxBytes = sizeof ( * { { util . g_ctx_var ( ) } } ) ; # ifdef CNC_AFFINITIES u64 affinityCount ; ocrAffinityCount ( AFFINITY_PD , & affinityCount ) ; ctxBytes += sizeof ( ocrGuid_t ) * affinityCount ; # endif ocrDbCreate ( & contextGuid , ( void * * ) & { { util . g_ctx_var ( ) } } , ctxBytes , DB_PROP_NONE , NULL_HINT , NO_ALLOC ) ; { { util . g_ctx_var ( ) } } -> _guids . self = contextGuid ; ocrEventCreate ( & { { util . g_ctx_var ( ) } } -> _guids . finalizedEvent , OCR_EVENT_STICKY_T , EVT_PROP_TAKES_ARG ) ; ocrEventCreate ( & { { util . g_ctx_var ( ) } } -> _guids . quiescedEvent , OCR_EVENT_STICKY_T , EVT_PROP_NONE ) ; ocrEventCreate ( & { { util . g_ctx_var ( ) } } -> _guids . doneEvent , OCR_EVENT_STICKY_T , EVT_PROP_TAKES_ARG ) ; ocrEventCreate ( & { { util . g_ctx_var ( ) } } -> _guids . awaitTag , OCR_EVENT_ONCE_T , EVT_PROP_TAKES_ARG ) ; ocrEventCreate ( & { { util . g_ctx_var ( ) } } -> _guids . contextReady , OCR_EVENT_LATCH_T , EVT_PROP_NONE ) ; # ifdef CNC_AFFINITIES { { util . g_ctx_var ( ) } } -> _affinityCount = affinityCount ; { const ocrGuid_t currentLoc = _cncCurrentAffinity ( ) ; ocrAffinityGet ( AFFINITY_PD , & affinityCount , { { util . g_ctx_var ( ) } } -> _affinities ) ; assert ( affinityCount == { { util . g_ctx_var ( ) } } -> _affinityCount ) ; u32 i ; void * data ; for ( i = 0 ; i < affinityCount ; i ++ ) { ocrGuid_t a = { { util . g_ctx_var ( ) } } -> _affinities [ i ] ; if ( ocrGuidIsEq ( a , currentLoc ) ) { { { util . g_ctx_var ( ) } } -> _affinities [ i ] = contextGuid ; } else { ocrHint_t hint ; const u16 flags = DB_PROP_NONE ; ocrDbCreate ( & { { util . g_ctx_var ( ) } } -> _affinities [ i ] , & data , ctxBytes , flags , _cncDbAffinityHint ( & hint , a ) , NO_ALLOC ) ; <S2SV_StartBug> } <S2SV_EndBug> } } # endif return { { util . g_ctx_var ( ) } } ; } | <S2SV_ModStart> NO_ALLOC ) ; ocrDbRelease ( ctx -> _affinities [ i ] ) ; |
506 | CWE-000 static void lex_get_lparen ( lex_t * lex , tok_t * tok ) { lex_get_character_tok ( lex , tok , LPAREN ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> LPAREN ) ; lex_skip_insignificant ( lex ) ; |
507 | CWE-000 static struct mdss_rot_hw_resource * mdss_rotator_hw_alloc ( struct mdss_rot_mgr * mgr , u32 pipe_id , u32 wb_id ) { struct mdss_rot_hw_resource * hw ; struct mdss_data_type * mdata = mdss_mdp_get_mdata ( ) ; u32 pipe_ndx , offset = mdss_mdp_get_wb_ctl_support ( mdata , true ) ; <S2SV_StartBug> int ret ; <S2SV_EndBug> hw = devm_kzalloc ( & mgr -> pdev -> dev , sizeof ( struct mdss_rot_hw_resource ) , GFP_KERNEL ) ; if ( ! hw ) return ERR_PTR ( - ENOMEM ) ; hw -> ctl = mdss_mdp_ctl_alloc ( mdata , offset ) ; if ( IS_ERR_OR_NULL ( hw -> ctl ) ) { pr_err ( "unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>ctl\\n" ) ; ret = - ENODEV ; goto error ; } if ( wb_id == MDSS_ROTATION_HW_ANY ) hw -> wb = mdss_mdp_wb_alloc ( MDSS_MDP_WB_ROTATOR , hw -> ctl -> num ) ; else hw -> wb = mdss_mdp_wb_assign ( wb_id , hw -> ctl -> num ) ; if ( IS_ERR_OR_NULL ( hw -> wb ) ) { pr_err ( "unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>wb\\n" ) ; ret = - ENODEV ; goto error ; } hw -> ctl -> wb = hw -> wb ; hw -> mixer = mdss_mdp_mixer_assign ( hw -> wb -> num , true , true ) ; if ( IS_ERR_OR_NULL ( hw -> mixer ) ) { pr_err ( "unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>wb<S2SV_blank>mixer\\n" ) ; ret = - ENODEV ; goto error ; } hw -> ctl -> mixer_left = hw -> mixer ; hw -> mixer -> ctl = hw -> ctl ; hw -> mixer -> rotator_mode = true ; switch ( hw -> mixer -> num ) { case MDSS_MDP_WB_LAYERMIXER0 : hw -> ctl -> opmode = MDSS_MDP_CTL_OP_ROT0_MODE ; break ; case MDSS_MDP_WB_LAYERMIXER1 : hw -> ctl -> opmode = MDSS_MDP_CTL_OP_ROT1_MODE ; break ; default : pr_err ( "invalid<S2SV_blank>layer<S2SV_blank>mixer=%d\\n" , hw -> mixer -> num ) ; ret = - EINVAL ; goto error ; } hw -> ctl -> ops . start_fnc = mdss_mdp_writeback_start ; hw -> ctl -> power_state = MDSS_PANEL_POWER_ON ; hw -> ctl -> wb_type = MDSS_MDP_WB_CTL_TYPE_BLOCK ; if ( hw -> ctl -> ops . start_fnc ) { ret = hw -> ctl -> ops . start_fnc ( hw -> ctl ) ; if ( ret ) goto error ; } if ( pipe_id >= mdata -> ndma_pipes ) goto error ; pipe_ndx = mdata -> dma_pipes [ pipe_id ] . ndx ; hw -> pipe = mdss_mdp_pipe_assign ( mdata , hw -> mixer , pipe_ndx , MDSS_MDP_PIPE_RECT0 ) ; if ( IS_ERR_OR_NULL ( hw -> pipe ) ) { pr_err ( "dma<S2SV_blank>pipe<S2SV_blank>allocation<S2SV_blank>failed\\n" ) ; ret = - ENODEV ; goto error ; } hw -> pipe -> mixer_left = hw -> mixer ; hw -> pipe_id = hw -> wb -> num ; hw -> wb_id = hw -> wb -> num ; return hw ; error : if ( ! IS_ERR_OR_NULL ( hw -> pipe ) ) mdss_mdp_pipe_destroy ( hw -> pipe ) ; if ( ! IS_ERR_OR_NULL ( hw -> ctl ) ) { if ( hw -> ctl -> ops . stop_fnc ) hw -> ctl -> ops . stop_fnc ( hw -> ctl , MDSS_PANEL_POWER_OFF ) ; mdss_mdp_ctl_free ( hw -> ctl ) ; } devm_kfree ( & mgr -> pdev -> dev , hw ) ; return ERR_PTR ( ret ) ; } | <S2SV_ModStart> ; int ret = 0 |
508 | CWE-000 void print_ret ( pid_t pid , unsigned long long int param , int i ) { char * string ; printf ( ")<S2SV_blank>=<S2SV_blank>" ) ; if ( syscalls_64_g [ i ] . ret == CHAR_P ) { string = read_string ( pid , param ) ; if ( string == NULL ) return ; <S2SV_StartBug> printf ( "\\"%s\\"" , string ) ; <S2SV_EndBug> free ( string ) ; } else if ( syscalls_64_g [ i ] . ret == VARARGS ) printf ( "...\\n" ) ; else if ( syscalls_64_g [ i ] . ret == INT ) printf ( "%d\\n" , ( int ) param ) ; else if ( syscalls_64_g [ i ] . ret == SIZE_T ) printf ( "%zd\\n" , ( size_t ) param ) ; else if ( syscalls_64_g [ i ] . ret == LONG ) printf ( "%ld\\n" , ( long ) param ) ; else if ( syscalls_64_g [ i ] . ret == SSIZE_T ) printf ( "%zu\\n" , ( ssize_t ) param ) ; else if ( syscalls_64_g [ i ] . ret == U64 ) printf ( "%llu\\n" , ( __u64 ) param ) ; else if ( syscalls_64_g [ i ] . ret == UINT32_T ) printf ( "%u\\n" , ( uint32_t ) param ) ; else if ( syscalls_64_g [ i ] . ret == UNSIGNED_INT ) printf ( "%u\\n" , ( unsigned int ) param ) ; else if ( syscalls_64_g [ i ] . ret == UNSIGNED_LONG ) printf ( "%lu\\n" , ( unsigned long ) param ) ; else if ( syscalls_64_g [ i ] . ret == PID_T ) printf ( "%d\\n" , ( pid_t ) param ) ; else if ( syscalls_64_g [ i ] . ret == VOID_P && param == 0 ) printf ( "NULL" ) ; else if ( param != 0 ) printf ( "0x%llx\\n" , param ) ; else printf ( "0\\n" ) ; } | <S2SV_ModStart> ; printf ( "\\"%s\\"\\n" <S2SV_ModEnd> , string ) |
509 | CWE-000 esp_gatt_status_t esp_ble_gattc_get_char_by_uuid ( esp_gatt_if_t gattc_if , uint16_t conn_id , uint16_t start_handle , uint16_t end_handle , esp_bt_uuid_t char_uuid , esp_gattc_char_elem_t * result , uint16_t * count ) { ESP_BLUEDROID_STATUS_CHECK ( ESP_BLUEDROID_STATUS_ENABLED ) ; <S2SV_StartBug> if ( start_handle == 0 && end_handle == 0 ) { <S2SV_EndBug> return ESP_GATT_INVALID_HANDLE ; } if ( result == NULL || count == NULL || * count == 0 ) { return ESP_GATT_INVALID_PDU ; } uint16_t conn_hdl = BTC_GATT_CREATE_CONN_ID ( gattc_if , conn_id ) ; return btc_ble_gattc_get_char_by_uuid ( conn_hdl , start_handle , end_handle , char_uuid , result , count ) ; } | <S2SV_ModStart> 0 ) { * count = 0 ; |
510 | CWE-000 void idle ( ) { <S2SV_StartBug> Yaw ( 1 , & totalRotation , & cameradir , & horizontalAxis , & verticalAxis , & depthAxis ) ; <S2SV_EndBug> loadMandelbulbVars ( mandelbulb_shader , fov , camerapos , cameradir , color , step , bail , power , phi , theta , totalRotation ) ; render ( ) ; } | <S2SV_ModStart> ( ) { power += 0.01 <S2SV_ModEnd> ; loadMandelbulbVars ( |
511 | CWE-000 int main ( int argc , char * * argv ) { printf ( "Conjugate<S2SV_blank>Gradient<S2SV_blank>Method<S2SV_blank>for<S2SV_blank>Solving<S2SV_blank>Linear<S2SV_blank>Systems!\\n" ) ; double * pMatrix ; double * pVector ; double * pResult ; int size ; if ( argc > 1 ) size = atoi ( argv [ 1 ] ) ; else { printf ( "Invalid<S2SV_blank>number<S2SV_blank>of<S2SV_blank>arguments!" ) ; exit ( EXIT_FAILURE ) ; } ProcessInitialization ( & pMatrix , & pVector , & pResult , & size ) ; <S2SV_StartBug> ParallelResultCalculation ( & pMatrix , & pVector , & pResult , & size ) ; <S2SV_EndBug> ProcessTerminations ( & pMatrix , & pVector , & pResult , & size ) ; <S2SV_StartBug> _getch ( ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> size ) ; double time = omp_get_wtime ( ) ; <S2SV_ModStart> & size ) ; time = omp_get_wtime ( ) - time <S2SV_ModStart> size ) ; printf ( "\\Elapsed<S2SV_blank>time:<S2SV_blank>%f<S2SV_blank>(sec)\\n" , time <S2SV_ModEnd> ) ; return |
512 | CWE-000 void rssyl_opml_import_func ( gchar * title , gchar * url , gint depth , gpointer data ) { OPMLImportCtx * ctx = ( OPMLImportCtx * ) data ; gchar * tmp = NULL ; FolderItem * new_item ; gboolean nulltitle = FALSE ; gint i = 1 ; debug_print ( "depth<S2SV_blank>%d,<S2SV_blank>ctx->depth<S2SV_blank>%d\\n" , depth , ctx -> depth ) ; while ( depth < ctx -> depth ) { ctx -> current = g_slist_delete_link ( ctx -> current , ctx -> current ) ; ctx -> depth -- ; } debug_print ( "OPML_IMPORT:<S2SV_blank>%s<S2SV_blank>%s<S2SV_blank>(%s)\\n" , ( url != NULL ? "feed" : "folder" ) , title , url ) ; if ( title == NULL ) { debug_print ( "NULL<S2SV_blank>title<S2SV_blank>received,<S2SV_blank>substituting<S2SV_blank>a<S2SV_blank>placeholder<S2SV_blank>title\\n" ) ; title = g_strdup ( _ ( "Untitled" ) ) ; nulltitle = TRUE ; } if ( url == NULL ) { tmp = g_strdup ( title ) ; while ( folder_find_child_item_by_name ( ( FolderItem * ) ctx -> current -> data , tmp ) ) { debug_print ( "RSSyl:<S2SV_blank>Folder<S2SV_blank>\'%s\'<S2SV_blank>already<S2SV_blank>exists,<S2SV_blank>trying<S2SV_blank>another<S2SV_blank>name\\n" , title ) ; g_free ( tmp ) ; tmp = g_strdup_printf ( "%s__%d" , title , ++ i ) ; } new_item = folder_create_folder ( ( FolderItem * ) ctx -> current -> data , tmp ) ; if ( ! new_item ) { alertpanel_error ( _ ( "Can\'t<S2SV_blank>create<S2SV_blank>the<S2SV_blank>folder<S2SV_blank>\'%s\'." ) , tmp ) ; g_free ( tmp ) ; } if ( nulltitle ) { g_free ( title ) ; title = NULL ; } ctx -> current = g_slist_prepend ( ctx -> current , new_item ) ; ctx -> depth ++ ; } else { <S2SV_StartBug> new_item = rssyl_feed_subscribe_new ( ( FolderItem * ) ctx -> current -> data , <S2SV_EndBug> url , TRUE ) ; if ( new_item != NULL && strcmp ( title , new_item -> name ) ) { if ( folder_item_rename ( new_item , title ) < 0 ) { alertpanel_error ( _ ( "Error<S2SV_blank>while<S2SV_blank>subscribing<S2SV_blank>feed\\n" "%s\\n\\nFolder<S2SV_blank>name<S2SV_blank>\'%s\'<S2SV_blank>is<S2SV_blank>not<S2SV_blank>allowed." ) , url , title ) ; } } } } | <S2SV_ModStart> { new_item = rssyl_subscribe <S2SV_ModEnd> ( ( FolderItem |
513 | CWE-000 int main ( ) { char * pathname = "Directory1" ; char * pathname2 = "Directory2" ; char * filename = "Arquivo1" ; char * filename2 = "Vamooo" ; LGA_LOGGER_TEST ( "Creating<S2SV_blank>Directory1<S2SV_blank>on<S2SV_blank>root<S2SV_blank>directory" ) ; if ( mkdir2 ( pathname ) != 0 ) { LGA_LOGGER_TEST ( "mkdir<S2SV_blank>FAILED" ) ; return - 1 ; } LGA_LOGGER_TEST ( "mkdir<S2SV_blank>SUCCEEDED" ) ; printAllEntries ( openDirectory ) ; LGA_LOGGER_TEST ( "Changing<S2SV_blank>to<S2SV_blank>/Directory1<S2SV_blank>" ) ; if ( chdir2 ( "/Directory1" ) != 0 ) { LGA_LOGGER_TEST ( "chdir<S2SV_blank>FAILED<S2SV_blank>-<S2SV_blank>Returning<S2SV_blank>to<S2SV_blank>previous<S2SV_blank>openDirectory" ) ; printAllEntries ( openDirectory ) ; return FAILED ; } ; LGA_LOGGER_TEST ( "chdir<S2SV_blank>to<S2SV_blank>/Directory1<S2SV_blank>SUCCEEDED" ) ; printAllEntries ( openDirectory ) ; LGA_LOGGER_TEST ( "Creating<S2SV_blank>file<S2SV_blank>on<S2SV_blank>Directory1" ) ; if ( create2 ( filename ) < 0 ) { LGA_LOGGER_TEST ( "1<S2SV_blank>creating<S2SV_blank>FAILED" ) ; return - 1 ; } printAllEntries ( openDirectory ) ; LGA_LOGGER_TEST ( "create2<S2SV_blank>SUCCEEDED" ) ; LGA_LOGGER_TEST ( "Creating<S2SV_blank>Directory2<S2SV_blank>on<S2SV_blank>Directory1" ) ; if ( mkdir2 ( pathname2 ) != 0 ) { LGA_LOGGER_TEST ( "mkdir<S2SV_blank>FAILED" ) ; return - 1 ; } LGA_LOGGER_TEST ( "mkdir<S2SV_blank>SUCCEEDED" ) ; printAllEntries ( openDirectory ) ; LGA_LOGGER_TEST ( "Changing<S2SV_blank>to<S2SV_blank>/Directory1/Directory2" ) ; if ( chdir2 ( "/Directory1/Directory2" ) != 0 ) { LGA_LOGGER_TEST ( "chdir<S2SV_blank>FAILED<S2SV_blank>-<S2SV_blank>Returning<S2SV_blank>to<S2SV_blank>previous<S2SV_blank>openDirectory" ) ; printAllEntries ( openDirectory ) ; return FAILED ; } LGA_LOGGER_TEST ( "chdir<S2SV_blank>SUCCEEDED" ) ; printAllEntries ( openDirectory ) ; LGA_LOGGER_TEST ( "Creating<S2SV_blank>file<S2SV_blank>on<S2SV_blank>Directory2" ) ; if ( create2 ( filename2 ) < 0 ) { LGA_LOGGER_TEST ( "1<S2SV_blank>creating<S2SV_blank>FAILED" ) ; return - 1 ; } printAllEntries ( openDirectory ) ; LGA_LOGGER_TEST ( "create2<S2SV_blank>SUCCEEDED" ) ; <S2SV_StartBug> LGA_LOGGER_TEST ( "Changing<S2SV_blank>to<S2SV_blank>./../../" ) ; <S2SV_EndBug> <S2SV_StartBug> if ( chdir2 ( "./../.." ) != 0 ) <S2SV_EndBug> { LGA_LOGGER_TEST ( "chdir<S2SV_blank>FAILED<S2SV_blank>-<S2SV_blank>Returning<S2SV_blank>to<S2SV_blank>previous<S2SV_blank>openDirectory" ) ; printAllEntries ( openDirectory ) ; return FAILED ; } LGA_LOGGER_TEST ( "chdir<S2SV_blank>SUCCEEDED" ) ; printAllEntries ( openDirectory ) ; LGA_LOGGER_TEST ( "Changing<S2SV_blank>/Directory1/Directory2" ) ; if ( chdir2 ( "Directory1/Directory2" ) != 0 ) { LGA_LOGGER_TEST ( "chdir<S2SV_blank>FAILED<S2SV_blank>-<S2SV_blank>Returning<S2SV_blank>to<S2SV_blank>previous<S2SV_blank>openDirectory" ) ; printAllEntries ( openDirectory ) ; return FAILED ; } LGA_LOGGER_TEST ( "chdir<S2SV_blank>SUCCEEDED" ) ; printAllEntries ( openDirectory ) ; } | <S2SV_ModStart> ; LGA_LOGGER_TEST ( "Changing<S2SV_blank>to<S2SV_blank>root<S2SV_blank>/" <S2SV_ModEnd> ) ; if <S2SV_ModStart> ( chdir2 ( "/" <S2SV_ModEnd> ) != 0 |
514 | CWE-000 static void invokeArm11Function ( void ( * func ) ( ) ) { static bool hasCopiedStub = false ; if ( ! hasCopiedStub ) { <S2SV_StartBug> arm11Entry = ( vu32 * ) ( ( ISSIGHAX ) ? 0x1FFFFFFC : 0x1FFFFFF8 ) ; <S2SV_EndBug> memcpy ( ( void * ) ARM11_STUB_ADDRESS , arm11Stub , 0x2C ) ; hasCopiedStub = true ; } * arm11Entry = ( u32 ) func ; while ( * arm11Entry ) ; * arm11Entry = ARM11_STUB_ADDRESS ; while ( * arm11Entry ) ; } | <S2SV_ModStart> 0x1FFFFFFC : 0x1FFFFFF8 ) ; flushDCacheRange ( & arm11Entry , 4 |
515 | CWE-000 CborError cbor_encode_tag ( CborEncoder * encoder , CborTag tag ) { <S2SV_StartBug> return encode_number ( encoder , tag , TagType << MajorTypeShift ) ; <S2SV_EndBug> } | <S2SV_ModStart> ) { return encode_number_no_update <S2SV_ModEnd> ( encoder , |
516 | CWE-000 int KeyMng_ShmWrite ( int shmhdl , int maxnodenum , NodeSHMInfo * pNodeInfo ) { int ret = 0 , i = 0 ; NodeSHMInfo * CurNode = NULL ; NodeSHMInfo ZeroNode ; char * addr = NULL ; memset ( & ZeroNode , 0x00 , sizeof ( ZeroNode ) ) ; if ( pNodeInfo == NULL ) { ret = MngClt_ParamErr ; KeyMng_Log ( __FILE__ , __LINE__ , KeyMngLevel [ 4 ] , ret , "func<S2SV_blank>KeyMng_ShmWrite()<S2SV_blank>err:" ) ; goto END ; } ret = IPC_MapShm ( shmhdl , ( void * * ) & addr ) ; if ( addr == NULL ) { printf ( "addr<S2SV_blank>NULL\\n" ) ; goto END ; } if ( ret != 0 ) { KeyMng_Log ( __FILE__ , __LINE__ , KeyMngLevel [ 4 ] , ret , "func<S2SV_blank>IPC_MapShm()<S2SV_blank>err:" ) ; goto END ; } for ( i = 0 ; i < maxnodenum ; i ++ ) { CurNode = ( NodeSHMInfo * ) ( addr + i * sizeof ( NodeSHMInfo ) ) ; if ( CurNode -> status == 1 && strcmp ( pNodeInfo -> serverId , CurNode -> serverId ) == 0 && strcmp ( pNodeInfo -> clientId , CurNode -> clientId ) == 0 ) { printf ( "密钥已经存在,更新密钥\\n" ) ; memcpy ( CurNode , pNodeInfo , sizeof ( NodeSHMInfo ) ) ; <S2SV_StartBug> KeyMng_Log ( __FILE__ , __LINE__ , KeyMngLevel [ 2 ] , ret , "网点密钥已经存在,已重新覆盖密钥信息" ) ; <S2SV_EndBug> goto END ; } } for ( i = 0 ; i < maxnodenum ; i ++ ) { CurNode = ( NodeSHMInfo * ) ( addr + i * sizeof ( NodeSHMInfo ) ) ; if ( CurNode -> status == 0 || memcmp ( CurNode , & ZeroNode , sizeof ( NodeSHMInfo ) ) == 0 ) { printf ( "密钥不存在,新增密钥\\n" ) ; memcpy ( CurNode , pNodeInfo , sizeof ( NodeSHMInfo ) ) ; <S2SV_StartBug> KeyMng_Log ( __FILE__ , __LINE__ , KeyMngLevel [ 2 ] , ret , "插入新的网点信息" ) ; <S2SV_EndBug> goto END ; } } if ( i == maxnodenum ) { KeyMng_Log ( __FILE__ , __LINE__ , KeyMngLevel [ 4 ] , ret , "网点信息已满" ) ; goto END ; } END : if ( addr != NULL ) IPC_UnMapShm ( addr ) ; return ret ; } | <S2SV_ModStart> ) ) ; CurNode -> status = 1 ; <S2SV_ModStart> ) ) ; CurNode -> status = 1 ; |
517 | CWE-000 void * __nf_ct_ext_add_length ( struct nf_conn * ct , enum nf_ct_ext_id id , size_t var_alloc_len , gfp_t gfp ) { struct nf_ct_ext * old , * new ; int i , newlen , newoff ; struct nf_ct_ext_type * t ; NF_CT_ASSERT ( ! nf_ct_is_confirmed ( ct ) ) ; old = ct -> ext ; if ( ! old ) return nf_ct_ext_create ( & ct -> ext , id , var_alloc_len , gfp ) ; if ( __nf_ct_ext_exist ( old , id ) ) return NULL ; rcu_read_lock ( ) ; t = rcu_dereference ( nf_ct_ext_types [ id ] ) ; <S2SV_StartBug> BUG_ON ( t == NULL ) ; <S2SV_EndBug> newoff = ALIGN ( old -> len , t -> align ) ; newlen = newoff + t -> len + var_alloc_len ; rcu_read_unlock ( ) ; new = __krealloc ( old , newlen , gfp ) ; if ( ! new ) return NULL ; if ( new != old ) { for ( i = 0 ; i < NF_CT_EXT_NUM ; i ++ ) { if ( ! __nf_ct_ext_exist ( old , i ) ) continue ; rcu_read_lock ( ) ; t = rcu_dereference ( nf_ct_ext_types [ i ] ) ; if ( t && t -> move ) t -> move ( ( void * ) new + new -> offset [ i ] , ( void * ) old + old -> offset [ i ] ) ; rcu_read_unlock ( ) ; } kfree_rcu ( old , rcu ) ; ct -> ext = new ; } new -> offset [ id ] = newoff ; new -> len = newlen ; memset ( ( void * ) new + newoff , 0 , newlen - newoff ) ; return ( void * ) new + newoff ; } | <S2SV_ModStart> ] ) ; if ( ! t ) { rcu_read_unlock ( ) ; return NULL ; } <S2SV_ModEnd> newoff = ALIGN |
518 | CWE-000 void testTortureExecute ( void ) { <S2SV_StartBug> # if ! defined ( __SDCC_hc08 ) && ! defined ( __SDCC_s08 ) <S2SV_EndBug> long long x ; int n ; if ( sizeof ( long long ) < 8 ) return ; n = 9 ; x = ( ( ( long long ) n ) << 55 ) / 0xff ; if ( x == 0 ) ASSERT ( 0 ) ; x = ( ( ( long long ) 9 ) << 55 ) / 0xff ; if ( x == 0 ) ASSERT ( 0 ) ; return ; <S2SV_StartBug> # endif <S2SV_EndBug> } | <S2SV_ModStart> void ) { <S2SV_ModEnd> long long x <S2SV_ModStart> ; return ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
519 | CWE-000 <S2SV_StartBug> void nd_default_filelog ( const char * text ) <S2SV_EndBug> { int size = 0 ; const char * logfile_name = ND_LOG_FILE ; FILE * log_fp = fopen ( logfile_name , "a" ) ; if ( ! log_fp ) { <S2SV_StartBug> return ; <S2SV_EndBug> } size = fprintf ( log_fp , "%s" , text ) ; fclose ( log_fp ) ; if ( size <= 0 ) { <S2SV_StartBug> return ; <S2SV_EndBug> } nd_atomic_add ( & __log_write_len , size ) ; if ( ( NDUINT32 ) __log_write_len >= __log_file_length && __log_file_length != 0 ) { char aimFile [ 1024 ] ; int i = 1 ; char * p = aimFile ; size = snprintf ( p , sizeof ( aimFile ) , "%s." , logfile_name ) ; p += size ; do { snprintf ( p , sizeof ( aimFile ) - size , "%d" , i ) ; ++ i ; } while ( nd_existfile ( aimFile ) ) ; nd_renfile ( logfile_name , aimFile ) ; nd_atomic_set ( & __log_write_len , 0 ) ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> int <S2SV_ModEnd> nd_default_filelog ( const <S2SV_ModStart> ) { return 0 <S2SV_ModStart> ) { return 0 <S2SV_ModStart> ) ; } return size ; |
520 | CWE-000 static void submitVertices ( GLenum mode , GLsizei first , GLsizei count , GLenum type , const GLvoid * indices ) { static GLfloat normal [ 3 ] = { 0.0f , 0.0f , - 1.0f } ; static GLfloat eye_P [ 3 ] ; static GLfloat eye_N [ 3 ] ; if ( ! ( ENABLED_VERTEX_ATTRIBUTES & VERTEX_ENABLED_FLAG ) ) { return ; } const GLsizei elements = ( mode == GL_QUADS ) ? 4 : ( mode == GL_TRIANGLES ) ? 3 : ( mode == GL_LINES ) ? 2 : count ; PVRCommand * dst = ( PVRCommand * ) aligned_vector_extend ( & activePolyList ( ) -> vector , count + 1 ) ; pvr_poly_hdr_t * hdr = ( pvr_poly_hdr_t * ) dst ; dst ++ ; pvr_poly_cxt_t cxt = * getPVRContext ( ) ; cxt . list_type = activePolyList ( ) -> list_type ; updatePVRTextureContext ( & cxt , getTexture0 ( ) ) ; pvr_poly_compile ( hdr , & cxt ) ; GLubyte vstride = ( VERTEX_POINTER . stride ) ? VERTEX_POINTER . stride : VERTEX_POINTER . size * byte_size ( VERTEX_POINTER . type ) ; const GLubyte * vptr = VERTEX_POINTER . ptr ; GLubyte cstride = ( DIFFUSE_POINTER . stride ) ? DIFFUSE_POINTER . stride : DIFFUSE_POINTER . size * byte_size ( DIFFUSE_POINTER . type ) ; const GLubyte * cptr = DIFFUSE_POINTER . ptr ; GLubyte uvstride = ( UV_POINTER . stride ) ? UV_POINTER . stride : UV_POINTER . size * byte_size ( UV_POINTER . type ) ; const GLubyte * uvptr = UV_POINTER . ptr ; GLubyte nstride = ( NORMAL_POINTER . stride ) ? NORMAL_POINTER . stride : NORMAL_POINTER . size * byte_size ( NORMAL_POINTER . type ) ; const GLubyte * nptr = NORMAL_POINTER . ptr ; const GLubyte * indices_as_bytes = ( GLubyte * ) indices ; GLboolean lighting_enabled = isLightingEnabled ( ) ; GLushort i ; for ( i = first ; i < count ; ++ i ) { pvr_vertex_t * vertex = ( pvr_vertex_t * ) dst ; vertex -> u = vertex -> v = 0.0f ; vertex -> argb = 0 ; vertex -> oargb = 0 ; vertex -> flags = PVR_CMD_VERTEX ; if ( ( ( i + 1 ) % elements ) == 0 ) { vertex -> flags = PVR_CMD_VERTEX_EOL ; } GLshort idx = i ; if ( indices ) { _parseIndex ( & idx , & indices_as_bytes [ byte_size ( type ) * i ] , type ) ; } _parseFloats ( & vertex -> x , vptr + ( idx * vstride ) , VERTEX_POINTER . size , VERTEX_POINTER . type ) ; if ( ENABLED_VERTEX_ATTRIBUTES & DIFFUSE_ENABLED_FLAG ) { _parseColour ( & vertex -> argb , cptr + ( idx * cstride ) , DIFFUSE_POINTER . size , DIFFUSE_POINTER . type ) ; } if ( ENABLED_VERTEX_ATTRIBUTES & UV_ENABLED_FLAG ) { _parseFloats ( & vertex -> u , uvptr + ( idx * uvstride ) , UV_POINTER . size , UV_POINTER . type ) ; } if ( ENABLED_VERTEX_ATTRIBUTES & NORMAL_ENABLED_FLAG ) { _parseFloats ( normal , nptr + ( idx * nstride ) , NORMAL_POINTER . size , NORMAL_POINTER . type ) ; } else { normal [ 0 ] = normal [ 1 ] = 0.0f ; normal [ 2 ] = - 1.0f ; } if ( lighting_enabled ) { GLfloat contribution [ ] = { 0.0f , 0.0f , 0.0f , 0.0f } ; GLfloat to_add [ ] = { 0.0f , 0.0f , 0.0f , 0.0f } ; eye_P [ 0 ] = vertex -> x ; eye_P [ 1 ] = vertex -> y ; eye_P [ 2 ] = vertex -> z ; eye_N [ 0 ] = normal [ 0 ] ; eye_N [ 1 ] = normal [ 1 ] ; eye_N [ 2 ] = normal [ 2 ] ; transformToEyeSpace ( eye_P ) ; transformNormalToEyeSpace ( eye_N ) ; GLubyte j ; for ( j = 0 ; j < MAX_LIGHTS ; ++ j ) { <S2SV_StartBug> if ( isLightEnabled ( i ) ) { <S2SV_EndBug> calculateLightingContribution ( j , eye_P , eye_N , to_add ) ; contribution [ 0 ] += to_add [ 0 ] ; contribution [ 1 ] += to_add [ 1 ] ; contribution [ 2 ] += to_add [ 2 ] ; contribution [ 3 ] += to_add [ 3 ] ; } } vertex -> argb = PVR_PACK_COLOR ( contribution [ 3 ] , contribution [ 0 ] , contribution [ 1 ] , contribution [ 2 ] ) ; } _applyRenderMatrix ( ) ; transformVertex ( & vertex -> x , & vertex -> x , & vertex -> y , & vertex -> z ) ; ++ dst ; } } | <S2SV_ModStart> ( isLightEnabled ( j <S2SV_ModEnd> ) ) { |
521 | CWE-000 static void schedule_frame_handle_idle_timer ( void * data ) { struct wlr_output * output = data ; <S2SV_StartBug> wlr_output_send_frame ( output ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> = data ; output -> idle_frame = NULL ; if ( ! output -> frame_pending ) { <S2SV_ModStart> ) ; } } |
522 | CWE-000 <S2SV_StartBug> char st_cleantext ( unsigned char c ) <S2SV_EndBug> { switch ( c ) { case 13 : return ( '\\n' ) ; case 0x87 : return 0xE1 ; case 0x88 : return 0xE0 ; case 0x8E : return 0xE9 ; case 0x8F : return 0xE8 ; case 0x91 : return ( '`' ) ; case 0x92 : return ( '\\'' ) ; case 0x93 : return ( \'\\"\' ) ; case 0x94 : return ( \'\\"\' ) ; case 0x95 : return ( '*' ) ; case 0x96 : return ( '-' ) ; case 0x97 : return ( '-' ) ; case 0xA5 : return ( '*' ) ; case 0xD0 : return ( '-' ) ; case 0xD1 : return ( '-' ) ; case 0xD2 : return ( \'\\"\' ) ; case 0xD3 : return ( \'\\"\' ) ; case 0xD4 : return ( '\\'' ) ; case 0xD5 : return ( '\\'' ) ; default : return ( c ) ; } } | <S2SV_ModStart> char st_cleantext ( char c ) { switch ( ( unsigned char ) <S2SV_ModEnd> c ) { |
523 | CWE-000 int main ( int argc , char * argv [ ] ) { clock_t start , end , diff ; int i , j , hit , rej , err , K , max_tr_lines , max_te_lines , * pred ; char train_file [ NAMEBUFFER ] , test_file [ NAMEBUFFER ] ; struct dataset * train , * test ; if ( argc == 4 ) { strcpy ( train_file , argv [ 1 ] ) ; strcpy ( test_file , argv [ 2 ] ) ; K = atoi ( argv [ 3 ] ) ; max_tr_lines = 0 ; max_te_lines = 0 ; } else if ( argc == 6 ) { strcpy ( train_file , argv [ 1 ] ) ; strcpy ( test_file , argv [ 2 ] ) ; K = atoi ( argv [ 3 ] ) ; max_tr_lines = atoi ( argv [ 4 ] ) ; max_te_lines = atoi ( argv [ 5 ] ) ; } else { printf ( "Wrong<S2SV_blank>number<S2SV_blank>of<S2SV_blank>parameters.\\nExiting.\\n" ) ; exit ( 0 ) ; } start = clock ( ) ; train = read_dataset ( train_file , max_tr_lines ) ; test = read_dataset ( test_file , max_te_lines ) ; hit = rej = err = 0 ; pred = ( int * ) malloc ( test -> num_points * sizeof ( int ) ) ; printf ( "TR:<S2SV_blank>%d\\t<S2SV_blank>TE:<S2SV_blank>%d\\n" , train -> num_points , test -> num_points ) ; for ( i = 0 ; i < test -> num_points ; i ++ ) { pred [ i ] = 0 ; if ( pred [ i ] == - 1 ) rej ++ ; else if ( pred [ i ] == test -> points [ i ] . label ) hit ++ ; else err ++ ; } err = test -> num_points - ( hit + rej ) ; printf ( "TR:<S2SV_blank>%d\\t<S2SV_blank>TE:<S2SV_blank>%d\\n" , train -> num_points , test -> num_points ) ; printf ( "acc:<S2SV_blank>%5d<S2SV_blank>\\t<S2SV_blank>%f\\n" , hit , ( float ) hit / test -> num_points ) ; printf ( "rej:<S2SV_blank>%5d<S2SV_blank>\\t<S2SV_blank>%f\\n" , rej , ( float ) rej / test -> num_points ) ; printf ( "err:<S2SV_blank>%5d<S2SV_blank>\\t<S2SV_blank>%5d\\n" , err , hit + rej + err ) ; get_confusion_matrix ( test , pred ) ; struct tree_node * kdtree = build_kdtree ( test -> points , test -> num_attrs , 0 , test -> num_points , 0 ) ; <S2SV_StartBug> nearest_node ( kdtree ) <S2SV_EndBug> free ( pred ) ; free_dataset ( train ) ; free_dataset ( test ) ; end = clock ( ) ; printf ( "Time:<S2SV_blank>%f\\n" , ( double ) ( end - start ) / CLOCKS_PER_SEC ) ; return 0 ; } | <S2SV_ModStart> 0 ) ; free_kdtree <S2SV_ModEnd> ( kdtree ) <S2SV_ModStart> ( kdtree ) ; |
524 | CWE-000 int main ( ) { setvbuf ( stdout , NULL , _IONBF , 0 ) ; SPCHESSGame * game = spChessGameCreate ( HISTORY_SIZE , DEFAULT_GAME_MODE , DEFAULT_USER_COLOR , DEFAULT_DIFFICULTY ) ; bool userIsWhite ; if ( ! game ) { printf ( "spChessGameCreate<S2SV_blank>has<S2SV_blank>failed\\n" ) ; spChessGameDestroy ( game ) ; exit ( 1 ) ; } printf ( "Specify<S2SV_blank>game<S2SV_blank>setting<S2SV_blank>to<S2SV_blank>type<S2SV_blank>\'start\'<S2SV_blank>to<S2SV_blank>begin<S2SV_blank>a<S2SV_blank>game<S2SV_blank>with<S2SV_blank>the<S2SV_blank>current<S2SV_blank>setting:\\n" ) ; settingState ( game ) ; while ( true ) { if ( game -> gameMode == 2 ) { spChessGamePrintBoard ( game ) ; printTurn ( game ) ; if ( userTurn ( game ) == SPCHESS_RESET ) continue ; } else { userIsWhite = ( game -> colorUser == 1 ) ; if ( userIsWhite ) { <S2SV_StartBug> spChessGamePrintBoard ( game ) ; <S2SV_EndBug> printTurn ( game ) ; if ( userTurn ( game ) == SPCHESS_RESET ) continue ; <S2SV_StartBug> computerTurn ( game ) ; <S2SV_EndBug> } else { <S2SV_StartBug> computerTurn ( game ) ; <S2SV_EndBug> <S2SV_StartBug> spChessGamePrintBoard ( game ) ; <S2SV_EndBug> printTurn ( game ) ; if ( userTurn ( game ) == SPCHESS_RESET ) <S2SV_StartBug> continue ; <S2SV_EndBug> } } } return 0 ; } | <S2SV_ModStart> userIsWhite ) { if ( game -> currentPlayer == SPCHESS_GAME_PLAYER_1_SYMBOL ) { <S2SV_ModStart> ) continue ; } else <S2SV_ModStart> } else { if ( game -> currentPlayer == SPCHESS_GAME_PLAYER_2_SYMBOL ) <S2SV_ModStart> game ) ; else { <S2SV_ModStart> ) continue ; } |
525 | CWE-000 wifi_utils_result_e wifi_profile_write ( wifi_manager_ap_config_s * config ) { <S2SV_StartBug> char buf [ 256 ] ; <S2SV_EndBug> int ret = 0 ; int len = 0 ; <S2SV_StartBug> len = _wifi_profile_serialize ( buf , 256 , config ) ; <S2SV_EndBug> if ( len < 0 ) { return WIFI_UTILS_FAIL ; } nvdbg ( "store<S2SV_blank>data<S2SV_blank>to<S2SV_blank>file:<S2SV_blank>buffer<S2SV_blank>len(%d)\\n" , len ) ; # ifdef CONFIG_WIFI_PROFILE_SECURESTORAGE ret = see_write_secure_storage ( ( unsigned char * ) buf , ( unsigned int ) len , WIFI_PROFILE_SS_INDEX ) ; if ( ret != SEE_OK ) { ndbg ( "Write<S2SV_blank>SS<S2SV_blank>fail(%d)\\n" , ret ) ; return WIFI_UTILS_FILE_ERROR ; } # else ret = _wifi_profile_store_file ( buf , len ) ; if ( ret < 0 ) { return WIFI_UTILS_FILE_ERROR ; } # endif return WIFI_UTILS_SUCCESS ; } | <S2SV_ModStart> char buf [ WIFI_PROFILE_BUFSIZE <S2SV_ModEnd> ] ; int <S2SV_ModStart> ( buf , WIFI_PROFILE_BUFSIZE <S2SV_ModEnd> , config ) |
526 | CWE-000 static int rte_init ( void ) { int ret ; <S2SV_StartBug> char * error = NULL ; <S2SV_EndBug> char * * hosts = NULL ; orte_ess_base_signal_t * sig ; int idx ; if ( ORTE_SUCCESS != ( ret = orte_ess_base_std_prolog ( ) ) ) { error = "orte_ess_base_std_prolog" ; goto error ; } slurm_set_name ( ) ; if ( ORTE_PROC_IS_DAEMON ) { <S2SV_StartBug> if ( NULL != orte_node_regex ) { <S2SV_EndBug> if ( ORTE_SUCCESS != ( ret = <S2SV_StartBug> orte_regex_extract_node_names ( orte_node_regex , & hosts ) ) || <S2SV_EndBug> NULL == hosts ) { error = "orte_regex_extract_node_names" ; goto error ; } } if ( 0 < ( idx = opal_list_get_size ( & orte_ess_base_signals ) ) ) { <S2SV_StartBug> forward_signals_events = ( opal_event_t * ) malloc ( sizeof ( opal_event_t ) * idx ) ; <S2SV_EndBug> if ( NULL == forward_signals_events ) { ret = ORTE_ERR_OUT_OF_RESOURCE ; error = "unable<S2SV_blank>to<S2SV_blank>malloc" ; goto error ; } idx = 0 ; OPAL_LIST_FOREACH ( sig , & orte_ess_base_signals , orte_ess_base_signal_t ) { setup_sighandler ( sig -> signal , forward_signals_events + idx , signal_forward_callback ) ; ++ idx ; } } signals_set = true ; ret = orte_ess_base_orted_setup ( hosts ) ; if ( NULL != hosts ) { opal_argv_free ( hosts ) ; } if ( ORTE_SUCCESS != ret ) { error = "orte_ess_base_orted_setup" ; goto error ; } return ORTE_SUCCESS ; } if ( ORTE_PROC_IS_TOOL ) { if ( ORTE_SUCCESS != ( ret = orte_ess_base_tool_setup ( ) ) ) { ORTE_ERROR_LOG ( ret ) ; error = "orte_ess_base_tool_setup" ; goto error ; } return ORTE_SUCCESS ; } error = "ess_error" ; ret = ORTE_ERROR ; error : if ( ORTE_ERR_SILENT != ret && ! orte_report_silent_errors ) { orte_show_help ( "help-orte-runtime.txt" , "orte_init:startup:internal-failure" , true , error , ORTE_ERROR_NAME ( ret ) , ret ) ; } return ret ; } | <S2SV_ModStart> error = NULL <S2SV_ModEnd> ; if ( <S2SV_ModStart> { if ( <S2SV_ModEnd> ORTE_SUCCESS != ( <S2SV_ModStart> ( ret = orte_ess_base_orted_setup ( <S2SV_ModEnd> ) ) ) <S2SV_ModStart> ) ) { ORTE_ERROR_LOG ( ret ) ; <S2SV_ModEnd> error = "orte_ess_base_orted_setup" |
527 | CWE-000 unsigned int next_prime_after ( unsigned int val ) { static BIGNUM * p = NULL ; static BN_CTX * ctx = NULL ; if ( ! ctx ) ctx = BN_CTX_new ( ) ; if ( ! p ) p = BN_new ( ) ; if ( val & 0x1 ) val += 2 ; else val += 1 ; while ( 1 ) { BN_set_word ( p , val ) ; <S2SV_StartBug> if ( BN_is_prime ( p , BN_prime_checks , NULL , ctx , NULL ) > 0 ) <S2SV_EndBug> break ; val += 2 ; } return val ; } | <S2SV_ModStart> ; if ( BN_is_prime_ex <S2SV_ModEnd> ( p , <S2SV_ModStart> p , BN_prime_checks <S2SV_ModEnd> , ctx , |
528 | CWE-000 void __obliv_c__gateAND ( OblivBit * dest , const OblivBit * a , const OblivBit * b ) { # ifdef DEBUG_METRICS_ON __debug__AND_count ++ ; # endif # ifdef POOL_EVAL <S2SV_StartBug> dest -> pool . wE = PoolAnd ( a -> pool . wE , a -> pool . wE ) ; <S2SV_EndBug> # else # ifdef POOL_GARB <S2SV_StartBug> dest -> pool . w = PoolAnd ( a -> pool . w , a -> pool . w ) ; <S2SV_EndBug> # endif dest -> knownValue = ( a -> knownValue && b -> knownValue ) ; # endif dest -> unknown = true ; } | <S2SV_ModStart> . wE = * ( WireE * ) <S2SV_ModStart> . w = * ( Wire * ) |
529 | CWE-000 static void tcp_sack_remove ( struct tcp_sock * tp ) { struct tcp_sack_block * sp = & tp -> selective_acks [ 0 ] ; int num_sacks = tp -> rx_opt . num_sacks ; int this_sack ; if ( skb_queue_empty ( & tp -> out_of_order_queue ) ) { tp -> rx_opt . num_sacks = 0 ; return ; } for ( this_sack = 0 ; this_sack < num_sacks ; ) { if ( ! before ( tp -> rcv_nxt , sp -> start_seq ) ) { int i ; WARN_ON ( before ( tp -> rcv_nxt , sp -> end_seq ) ) ; for ( i = this_sack + 1 ; i < num_sacks ; i ++ ) <S2SV_StartBug> tp -> selective_acks [ i - 1 ] = tp -> selective_acks [ i ] ; <S2SV_EndBug> num_sacks -- ; continue ; } this_sack ++ ; sp ++ ; } tp -> rx_opt . num_sacks = num_sacks ; } | <S2SV_ModStart> selective_acks [ i - 1 |
530 | CWE-000 static int e1000_set_ringparam ( struct net_device * netdev , struct ethtool_ringparam * ring ) { struct e1000_adapter * adapter = netdev_priv ( netdev ) ; struct e1000_hw * hw = & adapter -> hw ; e1000_mac_type mac_type = hw -> mac_type ; struct e1000_tx_ring * txdr , * tx_old ; struct e1000_rx_ring * rxdr , * rx_old ; int i , err ; if ( ( ring -> rx_mini_pending ) || ( ring -> rx_jumbo_pending ) ) return - EINVAL ; while ( test_and_set_bit ( __E1000_RESETTING , & adapter -> flags ) ) msleep ( 1 ) ; if ( netif_running ( adapter -> netdev ) ) e1000_down ( adapter ) ; tx_old = adapter -> tx_ring ; rx_old = adapter -> rx_ring ; err = - ENOMEM ; txdr = kcalloc ( adapter -> num_tx_queues , sizeof ( struct e1000_tx_ring ) , GFP_KERNEL ) ; if ( ! txdr ) goto err_alloc_tx ; rxdr = kcalloc ( adapter -> num_rx_queues , sizeof ( struct e1000_rx_ring ) , GFP_KERNEL ) ; if ( ! rxdr ) goto err_alloc_rx ; adapter -> tx_ring = txdr ; adapter -> rx_ring = rxdr ; rxdr -> count = max ( ring -> rx_pending , ( u32 ) E1000_MIN_RXD ) ; rxdr -> count = min ( rxdr -> count , ( u32 ) ( mac_type < e1000_82544 ? E1000_MAX_RXD : E1000_MAX_82544_RXD ) ) ; rxdr -> count = ALIGN ( rxdr -> count , REQ_RX_DESCRIPTOR_MULTIPLE ) ; txdr -> count = max ( ring -> tx_pending , ( u32 ) E1000_MIN_TXD ) ; txdr -> count = min ( txdr -> count , ( u32 ) ( mac_type < e1000_82544 ? E1000_MAX_TXD : E1000_MAX_82544_TXD ) ) ; txdr -> count = ALIGN ( txdr -> count , REQ_TX_DESCRIPTOR_MULTIPLE ) ; for ( i = 0 ; i < adapter -> num_tx_queues ; i ++ ) txdr [ i ] . count = txdr -> count ; for ( i = 0 ; i < adapter -> num_rx_queues ; i ++ ) rxdr [ i ] . count = rxdr -> count ; if ( netif_running ( adapter -> netdev ) ) { err = e1000_setup_all_rx_resources ( adapter ) ; if ( err ) goto err_setup_rx ; err = e1000_setup_all_tx_resources ( adapter ) ; if ( err ) goto err_setup_tx ; adapter -> rx_ring = rx_old ; adapter -> tx_ring = tx_old ; e1000_free_all_rx_resources ( adapter ) ; e1000_free_all_tx_resources ( adapter ) ; kfree ( tx_old ) ; kfree ( rx_old ) ; adapter -> rx_ring = rxdr ; adapter -> tx_ring = txdr ; err = e1000_up ( adapter ) ; if ( err ) goto err_setup ; } clear_bit ( __E1000_RESETTING , & adapter -> flags ) ; return 0 ; err_setup_tx : e1000_free_all_rx_resources ( adapter ) ; err_setup_rx : adapter -> rx_ring = rx_old ; adapter -> tx_ring = tx_old ; kfree ( rxdr ) ; err_alloc_rx : kfree ( txdr ) ; err_alloc_tx : <S2SV_StartBug> e1000_up ( adapter ) ; <S2SV_EndBug> err_setup : clear_bit ( __E1000_RESETTING , & adapter -> flags ) ; return err ; } | <S2SV_ModStart> ; err_alloc_tx : if ( netif_running ( adapter -> netdev ) ) |
531 | CWE-000 int serve_request ( struct conndata * cdata ) { struct httpread * httpr ; httpr = read_request ( cdata -> socketint ) ; if ( httpr -> dimArray == 0 ) { destroy_httpread ( httpr ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } if ( httpr -> dimArray == - 1 ) { <S2SV_StartBug> destroy_httpread ( httpr ) ; <S2SV_EndBug> http_500 ( cdata ) ; return ERROR ; } if ( method_parse ( * ( httpr -> array ) , cdata ) == ERROR ) { http_400 ( cdata ) ; destroy_httpread ( httpr ) ; return ERROR ; } if ( path_parse ( * ( httpr -> array ) , cdata ) == ERROR ) { http_400 ( cdata ) ; destroy_httpread ( httpr ) ; return ERROR ; } int i ; int v = 0 , w = 0 ; for ( i = 1 ; i < httpr -> dimArray ; i ++ ) { printf ( "accheck<S2SV_blank>iniziata\\n" ) ; v += accheck ( * ( httpr -> array + i ) , cdata ) ; printf ( "accheck<S2SV_blank>completata\\n" ) ; w += uacheck ( * ( httpr -> array + i ) , cdata ) ; } if ( ( v == 0 ) || ( w == 0 ) ) { http_400 ( cdata ) ; destroy_httpread ( httpr ) ; return ERROR ; } if ( send_response ( cdata ) != 0 ) return ERROR ; return 1 ; } | <S2SV_ModStart> httpr ) ; printf ( "Niente<S2SV_blank>da<S2SV_blank>leggere\\n" ) ; return ERROR <S2SV_ModEnd> ; } if <S2SV_ModStart> destroy_httpread ( httpr <S2SV_ModEnd> ) ; return |
532 | CWE-000 static int ramdisk_read ( mipos_pdrv_t pdrv , char * buf , mipos_sec_t sector , mipos_sec_t count ) { if ( pdrv != 0 || _disk_status & MIPOS_DISK_STS_NOINIT ) { return MIPOS_DISK_RES_NOTRDY ; } <S2SV_StartBug> memcpy ( buf , ( & ram_disk [ sector * SECTOR_SIZE ] ) , count * SECTOR_SIZE ) ; <S2SV_EndBug> return MIPOS_DISK_RES_OK ; } | <S2SV_ModStart> , ( & ramdisk_ptr <S2SV_ModEnd> [ sector * |
533 | CWE-000 bool cmp_object_as_long ( cmp_object_t * obj , int64_t * d ) { switch ( obj -> type ) { case CMP_TYPE_POSITIVE_FIXNUM : case CMP_TYPE_NEGATIVE_FIXNUM : case CMP_TYPE_SINT8 : * d = obj -> as . s8 ; return true ; case CMP_TYPE_UINT8 : * d = obj -> as . u8 ; return true ; case CMP_TYPE_SINT16 : * d = obj -> as . s16 ; return true ; case CMP_TYPE_UINT16 : * d = obj -> as . u16 ; return true ; case CMP_TYPE_SINT32 : * d = obj -> as . s32 ; return true ; case CMP_TYPE_UINT32 : * d = obj -> as . u32 ; return true ; case CMP_TYPE_SINT64 : * d = obj -> as . s64 ; return true ; case CMP_TYPE_UINT64 : if ( obj -> as . u64 <= 9223372036854775807 ) { * d = obj -> as . u64 ; return true ; } <S2SV_StartBug> } <S2SV_EndBug> return false ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> true ; } default : <S2SV_ModEnd> return false ; <S2SV_ModStart> false ; } } |
534 | CWE-000 void StartSweep ( unsigned long Start , unsigned long Stop , unsigned long Sweep , double Delta ) { if ( Start < Stop ) { <S2SV_StartBug> Start_Fre_value = Start ; <S2SV_EndBug> <S2SV_StartBug> Stop_Fre_value = Stop ; <S2SV_EndBug> Sweep_Time_value = Sweep ; Delta_Fre_value = Delta ; Sweep_Time_Counter = 0 ; Current_Fre = Start_Fre_value ; Sweep_DIR_Flag = 0 ; RF_Fre_Value = Start_Fre_value ; RF_OUT ( ) ; SweepTimerStart ( ) ; } } | <S2SV_ModStart> Start_Fre_value = Start / 1000.0 <S2SV_ModStart> Stop_Fre_value = Stop / 1000.0 |
535 | CWE-000 void GL_UploadWarpImage ( void ) { int oldsize ; int mark ; gltexture_t * glt ; byte * dummy ; oldsize = gl_warpimage_size ; if ( ( int ) gl_warp_image_size . value < 32 ) Cvar_SetValue ( "gl_warp_image_size" , 32 ) ; gl_warpimage_size = GL_CheckSize ( ( int ) gl_warp_image_size . value ) ; while ( gl_warpimage_size > vid . width ) gl_warpimage_size >>= 1 ; while ( gl_warpimage_size > vid . height ) gl_warpimage_size >>= 1 ; if ( gl_warpimage_size != gl_warp_image_size . value ) Cvar_SetValue ( "gl_warp_image_size" , gl_warpimage_size ) ; if ( gl_warpimage_size == oldsize ) return ; mark = Hunk_LowMark ( ) ; dummy = Hunk_Alloc ( gl_warpimage_size * gl_warpimage_size * 4 ) ; for ( glt = active_gltextures ; glt ; glt = glt -> next ) { if ( glt -> flags & TEXPREF_WARPIMAGE ) { GL_Bind ( glt ) ; glTexImage2D ( GL_TEXTURE_2D , 0 , GL_RGB , gl_warpimage_size , gl_warpimage_size , 0 , GL_RGBA , GL_UNSIGNED_BYTE , dummy ) ; glt -> width = glt -> height = gl_warpimage_size ; <S2SV_StartBug> } <S2SV_EndBug> } Hunk_FreeToLowMark ( mark ) ; } | <S2SV_ModStart> = gl_warpimage_size ; GL_SetFilterModes ( glt ) ; |
536 | CWE-000 static void populate_properties ( const void * blob , int offset , void * * mem , struct device_node * np , const char * nodename , bool dryrun ) { struct property * pp , * * pprev = NULL ; int cur ; bool has_name = false ; <S2SV_StartBug> pprev = & np -> properties ; <S2SV_EndBug> for ( cur = fdt_first_property_offset ( blob , offset ) ; cur >= 0 ; cur = fdt_next_property_offset ( blob , cur ) ) { const __be32 * val ; const char * pname ; u32 sz ; val = fdt_getprop_by_offset ( blob , cur , & pname , & sz ) ; if ( ! val ) { pr_warn ( "Cannot<S2SV_blank>locate<S2SV_blank>property<S2SV_blank>at<S2SV_blank>0x%x\\n" , cur ) ; continue ; } if ( ! pname ) { pr_warn ( "Cannot<S2SV_blank>find<S2SV_blank>property<S2SV_blank>name<S2SV_blank>at<S2SV_blank>0x%x\\n" , cur ) ; continue ; } if ( ! strcmp ( pname , "name" ) ) has_name = true ; <S2SV_StartBug> pp = unflatten_dt_alloc ( mem , sizeof ( struct property ) , <S2SV_EndBug> __alignof__ ( struct property ) ) ; <S2SV_StartBug> if ( dryrun ) <S2SV_EndBug> continue ; <S2SV_StartBug> if ( ! strcmp ( pname , "phandle" ) || <S2SV_EndBug> ! strcmp ( pname , "linux,phandle" ) ) { if ( ! np -> phandle ) np -> phandle = be32_to_cpup ( val ) ; } <S2SV_StartBug> if ( ! strcmp ( pname , "ibm,phandle" ) ) <S2SV_EndBug> np -> phandle = be32_to_cpup ( val ) ; pp -> name = ( char * ) pname ; pp -> length = sz ; pp -> value = ( __be32 * ) val ; * pprev = pp ; <S2SV_StartBug> pprev = & pp -> next ; <S2SV_EndBug> } if ( ! has_name ) { const char * p = nodename , * ps = p , * pa = NULL ; int len ; while ( * p ) { if ( ( * p ) == '@' ) pa = p ; else if ( ( * p ) == '/' ) ps = p + 1 ; p ++ ; } if ( pa < ps ) pa = p ; len = ( pa - ps ) + 1 ; pp = unflatten_dt_alloc ( mem , sizeof ( struct property ) + len , __alignof__ ( struct property ) ) ; if ( ! dryrun ) { pp -> name = "name" ; pp -> length = len ; pp -> value = pp + 1 ; * pprev = pp ; pprev = & pp -> next ; memcpy ( pp -> value , ps , len - 1 ) ; ( ( char * ) pp -> value ) [ len - 1 ] = 0 ; pr_debug ( "fixed<S2SV_blank>up<S2SV_blank>name<S2SV_blank>for<S2SV_blank>%s<S2SV_blank>-><S2SV_blank>%s\\n" , nodename , ( char * ) pp -> value ) ; } } if ( ! dryrun ) * pprev = NULL ; } | <S2SV_ModStart> = false ; bool prop_is_phandle = false ; <S2SV_ModStart> = true ; if ( strcmp ( pname , "phandle" ) && strcmp ( pname , "linux,phandle" ) && strcmp ( pname , "ibm,phandle" ) ) <S2SV_ModStart> ) ) ; else prop_is_phandle = true ; <S2SV_ModStart> ; if ( prop_is_phandle <S2SV_ModEnd> ) { if <S2SV_ModStart> ) ; } else { pp -> name = ( char * ) pname ; pp -> length = sz ; pp -> value = ( __be32 * ) val <S2SV_ModEnd> ; * pprev <S2SV_ModStart> -> next ; } |
537 | CWE-000 int i40e_napi_poll ( struct napi_struct * napi , int budget ) { struct i40e_q_vector * q_vector = container_of ( napi , struct i40e_q_vector , napi ) ; struct i40e_vsi * vsi = q_vector -> vsi ; struct i40e_ring * ring ; bool clean_complete = true ; bool arm_wb = false ; int budget_per_ring ; int work_done = 0 ; if ( test_bit ( __I40E_VSI_DOWN , vsi -> state ) ) { napi_complete ( napi ) ; return 0 ; } i40e_for_each_ring ( ring , q_vector -> tx ) { bool wd = ring -> xsk_umem ? i40e_clean_xdp_tx_irq ( vsi , ring , budget ) : i40e_clean_tx_irq ( vsi , ring , budget ) ; if ( ! wd ) { clean_complete = false ; continue ; } arm_wb |= ring -> arm_wb ; ring -> arm_wb = false ; } if ( budget <= 0 ) goto tx_only ; budget_per_ring = max ( budget / q_vector -> num_ringpairs , 1 ) ; i40e_for_each_ring ( ring , q_vector -> rx ) { int cleaned = ring -> xsk_umem ? i40e_clean_rx_irq_zc ( ring , budget_per_ring ) : i40e_clean_rx_irq ( ring , budget_per_ring ) ; work_done += cleaned ; if ( cleaned >= budget_per_ring ) clean_complete = false ; } if ( ! clean_complete ) { int cpu_id = smp_processor_id ( ) ; if ( ! cpumask_test_cpu ( cpu_id , & q_vector -> affinity_mask ) ) { napi_complete_done ( napi , work_done ) ; i40e_force_wb ( vsi , q_vector ) ; return budget - 1 ; } tx_only : if ( arm_wb ) { q_vector -> tx . ring [ 0 ] . tx_stats . tx_force_wb ++ ; i40e_enable_wb_on_itr ( vsi , q_vector ) ; } return budget ; } if ( vsi -> back -> flags & I40E_TXR_FLAGS_WB_ON_ITR ) q_vector -> arm_wb_state = false ; <S2SV_StartBug> napi_complete_done ( napi , work_done ) ; <S2SV_EndBug> i40e_update_enable_itr ( vsi , q_vector ) ; return min ( work_done , budget - 1 ) ; } | <S2SV_ModStart> = false ; if ( likely ( <S2SV_ModStart> , work_done ) ) ) <S2SV_ModEnd> i40e_update_enable_itr ( vsi |
538 | CWE-000 rd_kafka_resp_err_t rd_kafka_msgset_parse ( rd_kafka_buf_t * rkbuf , rd_kafka_buf_t * request , rd_kafka_toppar_t * rktp , const struct rd_kafka_toppar_ver * tver ) { rd_kafka_msgset_reader_t msetr ; <S2SV_StartBug> rd_kafka_msgset_reader_init ( & msetr , rkbuf , rktp , tver ) ; <S2SV_EndBug> return rd_kafka_msgset_reader_run ( & msetr ) ; } | <S2SV_ModStart> rktp , tver , rktp -> rktp_fetchq |
539 | CWE-000 expanded_location <S2SV_StartBug> expand_location_to_spelling_point ( source_location loc ) <S2SV_EndBug> { return expand_location_1 ( loc , false , <S2SV_StartBug> LOCATION_ASPECT_CARET ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( source_location loc , enum location_aspect aspect <S2SV_ModStart> , false , aspect <S2SV_ModEnd> ) ; } |
540 | CWE-000 int swProcessPool_create ( swProcessPool * pool , int worker_num , int max_request , key_t msgqueue_key , int ipc_mode ) { bzero ( pool , sizeof ( swProcessPool ) ) ; pool -> worker_num = worker_num ; pool -> max_request = max_request ; pool -> workers = SwooleG . memory_pool -> alloc ( SwooleG . memory_pool , worker_num * sizeof ( swWorker ) ) ; if ( pool -> workers == NULL ) { swSysError ( "malloc[1]<S2SV_blank>failed." ) ; return SW_ERR ; } if ( ipc_mode == SW_IPC_MSGQUEUE ) { pool -> use_msgqueue = 1 ; pool -> msgqueue_key = msgqueue_key ; pool -> queue = sw_malloc ( sizeof ( swMsgQueue ) ) ; if ( pool -> queue == NULL ) { swSysError ( "malloc[2]<S2SV_blank>failed." ) ; return SW_ERR ; } <S2SV_StartBug> if ( swMsgQueue_create ( pool -> queue , 1 , pool -> msgqueue_key , 1 ) < 0 ) <S2SV_EndBug> { return SW_ERR ; } } else if ( ipc_mode == SW_IPC_SOCKET ) { pool -> use_socket = 1 ; pool -> stream = sw_malloc ( sizeof ( swStreamInfo ) ) ; if ( pool -> stream == NULL ) { swWarn ( "malloc[2]<S2SV_blank>failed." ) ; return SW_ERR ; } bzero ( pool -> stream , sizeof ( swStreamInfo ) ) ; } else if ( ipc_mode == SW_IPC_UNIXSOCK ) { pool -> pipes = sw_calloc ( worker_num , sizeof ( swPipe ) ) ; if ( pool -> pipes == NULL ) { swWarn ( "malloc[2]<S2SV_blank>failed." ) ; return SW_ERR ; } swPipe * pipe ; int i ; for ( i = 0 ; i < worker_num ; i ++ ) { pipe = & pool -> pipes [ i ] ; if ( swPipeUnsock_create ( pipe , 1 , SOCK_DGRAM ) < 0 ) { return SW_ERR ; } pool -> workers [ i ] . pipe_master = pipe -> getFd ( pipe , SW_PIPE_MASTER ) ; pool -> workers [ i ] . pipe_worker = pipe -> getFd ( pipe , SW_PIPE_WORKER ) ; pool -> workers [ i ] . pipe_object = pipe ; } } else { ipc_mode = SW_IPC_NONE ; } pool -> map = swHashMap_new ( SW_HASHMAP_INIT_BUCKET_N , NULL ) ; if ( pool -> map == NULL ) { swProcessPool_free ( pool ) ; return SW_ERR ; } pool -> ipc_mode = ipc_mode ; if ( ipc_mode > SW_IPC_NONE ) { pool -> main_loop = swProcessPool_worker_loop ; } return SW_OK ; } | <S2SV_ModStart> -> msgqueue_key , 0 <S2SV_ModEnd> ) < 0 |
541 | CWE-000 static int mse_packetizer_cvf_h264_packetize ( int index , void * packet , size_t * packet_size , void * buffer , size_t buffer_size , size_t * buffer_processed , unsigned int * timestamp ) { struct cvf_h264_packetizer * h264 ; int data_len ; u32 data_offset ; u32 nal_size , nal_header ; u32 start_code = htonl ( START_CODE ) ; unsigned char * buf = ( unsigned char * ) buffer ; unsigned char * cur_nal ; unsigned char * payload ; if ( index >= ARRAY_SIZE ( cvf_h264_packetizer_table ) ) return - EPERM ; h264 = & cvf_h264_packetizer_table [ index ] ; mse_debug ( "index=%d<S2SV_blank>seqnum=%d<S2SV_blank>process=%zu/%zu<S2SV_blank>t=%u\\n" , index , h264 -> send_seq_num , * buffer_processed , buffer_size , * timestamp ) ; cur_nal = buf + * buffer_processed ; if ( ! h264 -> next_nal ) { if ( h264 -> f_start_code ) { for ( h264 -> next_nal = cur_nal + 1 ; h264 -> next_nal < buf + buffer_size - sizeof ( u32 ) ; h264 -> next_nal ++ ) { if ( ! memcmp ( h264 -> next_nal , & start_code , sizeof ( u32 ) ) ) break ; } if ( h264 -> next_nal >= buf + buffer_size - sizeof ( u32 ) ) h264 -> next_nal = buf + buffer_size ; cur_nal += sizeof ( u32 ) ; nal_size = h264 -> next_nal - cur_nal ; } else { memcpy ( & nal_header , cur_nal , sizeof ( nal_header ) ) ; nal_size = ntohl ( nal_header ) ; cur_nal += sizeof ( u32 ) ; h264 -> next_nal = cur_nal + nal_size ; } mse_debug ( "seqnum=%d<S2SV_blank>process=%zu/%zu<S2SV_blank>t=%u<S2SV_blank>nal=%d\\n" , h264 -> send_seq_num , * buffer_processed , buffer_size , * timestamp , nal_size ) ; switch ( * cur_nal & NALU_TYPE_MASK ) { case NALU_TYPE_UNSPECIFIED0 : case NALU_TYPE_UNSPECIFIED30 : case NALU_TYPE_UNSPECIFIED31 : mse_err ( "NAL<S2SV_blank>format<S2SV_blank>error\\n" ) ; return MSE_PACKETIZE_STATUS_CONTINUE ; default : break ; } h264 -> fu_indicator = ( * cur_nal & FU_I_F_NRI_MASK ) | NALU_TYPE_FU_A ; h264 -> fu_header = FU_H_S_BIT | ( * cur_nal & NALU_TYPE_MASK ) ; # if defined ( CONFIG_MSE_PACKETIZER_CVF_H264_SINGLE_NAL ) if ( h264 -> next_nal - cur_nal < h264 -> data_len_max ) { h264 -> fu_indicator = * cur_nal & ( FU_I_F_NRI_MASK | NALU_TYPE_MASK ) ; } # endif cur_nal ++ ; ( * buffer_processed ) += sizeof ( u32 ) + 1 ; } else { h264 -> fu_header &= ~ FU_H_S_BIT ; } data_len = h264 -> next_nal - cur_nal ; if ( data_len > h264 -> data_len_max ) { data_len = h264 -> data_len_max ; <S2SV_StartBug> } else { <S2SV_EndBug> h264 -> fu_header |= FU_H_E_BIT ; h264 -> next_nal = NULL ; } memcpy ( packet , h264 -> packet_template , h264 -> header_size ) ; data_offset = is_single_nal ( h264 -> fu_indicator ) ? 1 : FU_HEADER_LEN ; avtp_set_sequence_num ( packet , h264 -> send_seq_num ++ ) ; avtp_set_timestamp ( packet , ( u32 ) * timestamp ) ; avtp_set_stream_data_length ( packet , data_len + data_offset + h264 -> additional_header_size ) ; payload = packet + h264 -> header_size ; payload [ FU_ADDR_INDICATOR ] = h264 -> fu_indicator ; if ( data_offset == FU_HEADER_LEN ) payload [ FU_ADDR_HEADER ] = h264 -> fu_header ; memcpy ( payload + data_offset , cur_nal , data_len ) ; * packet_size = h264 -> header_size + data_offset + data_len ; ( * buffer_processed ) += data_len ; <S2SV_StartBug> if ( * buffer_processed >= buffer_size ) { <S2SV_EndBug> ( ( unsigned char * ) packet ) [ MBIT_ADDR ] |= MBIT_SET ; return MSE_PACKETIZE_STATUS_COMPLETE ; } ( ( unsigned char * ) packet ) [ MBIT_ADDR ] &= ~ MBIT_SET ; return MSE_PACKETIZE_STATUS_CONTINUE ; } | <S2SV_ModStart> ; } else if ( is_single_nal ( h264 -> fu_indicator ) || ! ( h264 -> fu_header & FU_H_S_BIT ) ) <S2SV_ModStart> buffer_processed >= buffer_size && h264 -> fu_header & FU_H_E_BIT |
542 | CWE-000 List * pg_rangercheck_batch ( List * arg_list ) { List * aclresults = NIL ; List * requestargs = NIL ; ListCell * arg ; foreach ( arg , arg_list ) { RangerPrivilegeArgs * arg_ptr = ( RangerPrivilegeArgs * ) lfirst ( arg ) ; AclObjectKind objkind = arg_ptr -> objkind ; Oid object_oid = arg_ptr -> object_oid ; char * objectname = getNameFromOid ( objkind , object_oid ) ; char * rolename = getRoleName ( arg_ptr -> roleid ) ; List * actions = getActionName ( arg_ptr -> mask ) ; bool isAll = ( arg_ptr -> how == ACLMASK_ALL ) ? true : false ; RangerPrivilegeResults * aclresult = ( RangerPrivilegeResults * ) palloc ( sizeof ( RangerPrivilegeResults ) ) ; aclresult -> result = - 1 ; aclresult -> relOid = object_oid ; aclresults = lappend ( aclresults , aclresult ) ; RangerRequestJsonArgs * requestarg = ( RangerRequestJsonArgs * ) palloc ( sizeof ( RangerRequestJsonArgs ) ) ; requestarg -> user = rolename ; requestarg -> kind = objkind ; requestarg -> object = objectname ; requestarg -> actions = actions ; <S2SV_StartBug> requestarg -> how = isAll ; <S2SV_EndBug> requestargs = lappend ( requestargs , requestarg ) ; } RangerACLResult ret = check_privilege_from_ranger_batch ( requestargs ) ; ListCell * result ; int k = 0 ; foreach ( result , aclresults ) { RangerPrivilegeResults * result_ptr = ( RangerPrivilegeResults * ) lfirst ( result ) ; result_ptr -> result = ret ; ++ k ; } if ( requestargs ) { ListCell * cell = list_head ( requestargs ) ; while ( cell != NULL ) { ListCell * tmp = cell ; cell = lnext ( cell ) ; RangerRequestJsonArgs * requestarg = ( RangerRequestJsonArgs * ) lfirst ( tmp ) ; pfree ( requestarg -> user ) ; pfree ( requestarg -> object ) ; pfree ( requestarg -> actions ) ; } list_free_deep ( requestargs ) ; requestargs = NULL ; } if ( ret != RANGERCHECK_OK ) { elog ( ERROR , "ACL<S2SV_blank>check<S2SV_blank>failed\\n" ) ; } elog ( LOG , "oids%d\\n" , arg_list -> length ) ; return aclresults ; } | <S2SV_ModStart> ; requestarg -> isAll <S2SV_ModEnd> = isAll ; |
543 | CWE-000 void XCopyArea ( Display * display , Drawable src , Drawable dst , GC gc , int src_x , int src_y , unsigned int width , unsigned int height , int dest_x , int dest_y ) { TkMacOSXDrawingContext dc ; MacDrawable * srcDraw = ( MacDrawable * ) src ; NSBitmapImageRep * bitmap_rep = NULL ; CGImageRef img = NULL ; <S2SV_StartBug> display -> request ++ ; <S2SV_EndBug> if ( ! width || ! height ) { return ; } if ( ! TkMacOSXSetupDrawingContext ( dst , gc , 1 , & dc ) ) { <S2SV_StartBug> return ; <S2SV_EndBug> } if ( dc . context ) { if ( srcDraw -> flags & TK_IS_PIXMAP ) { img = TkMacOSXCreateCGImageWithDrawable ( src ) ; } else if ( TkMacOSXDrawableWindow ( src ) ) { bitmap_rep = TkMacOSXBitmapRepFromDrawableRect ( src , src_x , src_y , width , height ) ; if ( bitmap_rep ) { img = [ bitmap_rep CGImage ] ; } } else { TkMacOSXDbgMsg ( "Invalid<S2SV_blank>source<S2SV_blank>drawable<S2SV_blank>-<S2SV_blank>neither<S2SV_blank>window<S2SV_blank>nor<S2SV_blank>pixmap." ) ; } if ( img ) { <S2SV_StartBug> TkMacOSXDrawCGImage ( dst , gc , dc . context , img , gc -> foreground , gc -> background , <S2SV_EndBug> <S2SV_StartBug> CGRectMake ( 0 , 0 , srcDraw -> size . width , srcDraw -> size . height ) , <S2SV_EndBug> CGRectMake ( src_x , src_y , width , height ) , CGRectMake ( dest_x , dest_y , width , height ) ) ; CFRelease ( img ) ; } else { TkMacOSXDbgMsg ( "Failed<S2SV_blank>to<S2SV_blank>construct<S2SV_blank>CGImage." ) ; } } else { TkMacOSXDbgMsg ( "Invalid<S2SV_blank>destination<S2SV_blank>drawable<S2SV_blank>-<S2SV_blank>no<S2SV_blank>context." ) ; return ; } TkMacOSXRestoreDrawingContext ( & dc ) ; } | <S2SV_ModStart> = NULL ; CGRect bounds , srcRect , dstRect ; <S2SV_ModStart> ) { return ; TkMacOSXDbgMsg ( "Failed<S2SV_blank>to<S2SV_blank>setup<S2SV_blank>drawing<S2SV_blank>context." ) <S2SV_ModStart> img ) { bounds = CGRectMake ( 0 , 0 , srcDraw -> size . width , srcDraw -> size . height ) ; srcRect = CGRectMake ( src_x , src_y , width , height ) ; dstRect = CGRectMake ( dest_x , dest_y , width , height ) ; <S2SV_ModStart> -> background , bounds , srcRect , dstRect <S2SV_ModEnd> ) ; CFRelease |
544 | CWE-000 static void tcp_v6_reqsk_send_ack ( struct sock * sk , struct sk_buff * skb , struct request_sock * req ) { tcp_v6_send_ack ( skb , tcp_rsk ( req ) -> snt_isn + 1 , tcp_rsk ( req ) -> rcv_isn + 1 , req -> rcv_wnd , req -> ts_recent , <S2SV_StartBug> tcp_v6_md5_do_lookup ( sk , & ipv6_hdr ( skb ) -> daddr ) , 0 ) ; <S2SV_EndBug> } | <S2SV_ModStart> skb ) -> saddr <S2SV_ModEnd> ) , 0 |
545 | CWE-000 void kmain ( ) { isr_install ( ) ; irq_install ( ) ; clear_screen ( ) ; <S2SV_StartBug> int offset = get_offset ( 0 , 15 ) ; <S2SV_EndBug> set_cursor_offset ( offset ) ; kprint ( "Type<S2SV_blank>something.<S2SV_blank><S2SV_blank>It<S2SV_blank>will<S2SV_blank>go<S2SV_blank>through<S2SV_blank>the<S2SV_blank>kernel." ) ; <S2SV_StartBug> kprint ( ( u8 * ) '\\n' ) ; <S2SV_EndBug> kprint ( "><S2SV_blank>" ) ; } | <S2SV_ModStart> = get_offset ( 1 , 1 <S2SV_ModEnd> ) ; set_cursor_offset <S2SV_ModStart> "Type<S2SV_blank>something.<S2SV_blank><S2SV_blank>It<S2SV_blank>will<S2SV_blank>go<S2SV_blank>through<S2SV_blank>the<S2SV_blank>kernel." ) ; kprint_newline ( <S2SV_ModEnd> ) ; kprint |
546 | CWE-000 void check_variation_switches ( void ) { if ( button [ BASIC_VAR_A_SW ] . state ) { button [ BASIC_VAR_A_SW ] . state ^= button [ BASIC_VAR_A_SW ] . state ; switch ( sequencer . variation_mode ) { case VAR_A : if ( sequencer . SHIFT ) { sequencer . variation_mode = VAR_AB ; if ( sequencer . START ) flag . variation_change ; } else { sequencer . variation_mode = VAR_B ; if ( sequencer . START ) { flag . variation_change = 1 ; } else { <S2SV_StartBug> sequencer . variation = VAR_B ; <S2SV_EndBug> } } break ; case VAR_B : if ( sequencer . SHIFT ) { sequencer . variation_mode = VAR_AB ; if ( sequencer . START ) flag . variation_change = 1 ; } else { sequencer . variation_mode = VAR_A ; if ( sequencer . START ) { flag . variation_change = 1 ; } else { <S2SV_StartBug> sequencer . variation = VAR_A ; <S2SV_EndBug> } } break ; case VAR_AB : if ( sequencer . SHIFT ) { sequencer . variation_mode = VAR_B ; if ( sequencer . START ) { flag . variation_change = 1 ; } else { <S2SV_StartBug> sequencer . variation = VAR_B ; <S2SV_EndBug> } } else { sequencer . variation_mode = VAR_A ; if ( sequencer . START ) { flag . variation_change = 1 ; } else { sequencer . variation = VAR_A ; } } break ; } } } | <S2SV_ModStart> { sequencer . current_variation <S2SV_ModEnd> = VAR_B ; <S2SV_ModStart> { sequencer . current_variation <S2SV_ModEnd> = VAR_A ; <S2SV_ModStart> { sequencer . current_variation = VAR_B ; } } else { sequencer . variation_mode = VAR_A ; if ( sequencer . START ) { flag . variation_change = 1 ; } else { sequencer . current_variation <S2SV_ModEnd> = VAR_A ; |
547 | CWE-000 rd_kafka_resp_err_t rd_kafka_seek ( rd_kafka_topic_t * app_rkt , int32_t partition , int64_t offset , int timeout_ms ) { rd_kafka_itopic_t * rkt = rd_kafka_topic_a2i ( app_rkt ) ; shptr_rd_kafka_toppar_t * s_rktp ; rd_kafka_toppar_t * rktp ; rd_kafka_q_t * tmpq = NULL ; rd_kafka_resp_err_t err ; <S2SV_StartBug> if ( partition == RD_KAFKA_PARTITION_UA ) <S2SV_EndBug> return RD_KAFKA_RESP_ERR__INVALID_ARG ; rd_kafka_topic_rdlock ( rkt ) ; if ( ! ( s_rktp = rd_kafka_toppar_get ( rkt , partition , 0 ) ) && ! ( s_rktp = rd_kafka_toppar_desired_get ( rkt , partition ) ) ) { rd_kafka_topic_rdunlock ( rkt ) ; return RD_KAFKA_RESP_ERR__UNKNOWN_PARTITION ; } rd_kafka_topic_rdunlock ( rkt ) ; <S2SV_StartBug> if ( timeout_ms ) <S2SV_EndBug> tmpq = rd_kafka_q_new ( rkt -> rkt_rk ) ; <S2SV_StartBug> rktp = rd_kafka_toppar_s2i ( s_rktp ) ; <S2SV_EndBug> if ( ( err = rd_kafka_toppar_op_seek ( rktp , offset , <S2SV_StartBug> RD_KAFKA_REPLYQ ( tmpq , 0 ) ) ) ) { <S2SV_EndBug> if ( tmpq ) rd_kafka_q_destroy_owner ( tmpq ) ; rd_kafka_toppar_destroy ( s_rktp ) ; return err ; } rd_kafka_toppar_destroy ( s_rktp ) ; if ( tmpq ) { err = rd_kafka_q_wait_result ( tmpq , timeout_ms ) ; rd_kafka_q_destroy_owner ( tmpq ) ; return err ; } return RD_KAFKA_RESP_ERR_NO_ERROR ; } | <S2SV_ModStart> rd_kafka_resp_err_t err ; rd_kafka_replyq_t replyq = RD_KAFKA_NO_REPLYQ ; <S2SV_ModStart> ( timeout_ms ) { <S2SV_ModStart> rkt_rk ) ; replyq = RD_KAFKA_REPLYQ ( tmpq , 0 ) ; } <S2SV_ModStart> , offset , replyq <S2SV_ModEnd> ) ) ) |
548 | CWE-000 pgp_errcode_t init_stdout_dest ( pgp_dest_t * dst ) { pgp_dest_file_param_t * param ; if ( ( param = calloc ( 1 , sizeof ( * param ) ) ) == NULL ) { return RNP_ERROR_OUT_OF_MEMORY ; } dst -> param = param ; param -> fd = STDOUT_FILENO ; <S2SV_StartBug> dst -> writefunc = file_dst_write ; <S2SV_EndBug> <S2SV_StartBug> dst -> closefunc = file_dst_close ; <S2SV_EndBug> dst -> type = PGP_STREAM_STDOUT ; <S2SV_StartBug> dst -> write = 0 ; <S2SV_EndBug> return RNP_SUCCESS ; } | <S2SV_ModStart> ; dst -> write <S2SV_ModEnd> = file_dst_write ; <S2SV_ModStart> ; dst -> close <S2SV_ModEnd> = file_dst_close ; <S2SV_ModStart> ; dst -> writeb <S2SV_ModEnd> = 0 ; |
549 | CWE-000 <S2SV_StartBug> void canhit ( uint8_t * health ) { <S2SV_EndBug> gpio_isr_handler_add ( recep , hit_register_isr , health ) ; } | <S2SV_ModStart> void canhit ( bool <S2SV_ModEnd> * health ) |
550 | CWE-000 struct ik_chain_t * chain_create ( void ) { struct ik_chain_t * chain = ( struct ik_chain_t * ) MALLOC ( sizeof * chain ) ; if ( chain == NULL ) ik_log_message ( "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>chain:<S2SV_blank>out<S2SV_blank>of<S2SV_blank>memory" ) ; <S2SV_StartBug> return chain ; <S2SV_EndBug> } | <S2SV_ModStart> "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>chain:<S2SV_blank>out<S2SV_blank>of<S2SV_blank>memory" ) ; chain_construct ( chain ) ; |
551 | CWE-000 void x_ae_context_add_polygon ( X_AE_Context * context , X_Polygon3_fp16x16 * polygon , X_BspSurface * bspSurface , X_BspBoundBoxFrustumFlags geoFlags , int * edgeIds ) { X_Vec3 clippedV [ X_POLYGON3_MAX_VERTS ] ; X_Polygon3 clipped = x_polygon3_make ( clippedV , X_POLYGON3_MAX_VERTS ) ; ++ context -> renderContext -> renderer -> totalSurfacesRendered ; <S2SV_StartBug> int tempEdgeIds [ X_POLYGON3_MAX_VERTS ] ; <S2SV_EndBug> int * clippedEdgeIds = tempEdgeIds ; if ( geoFlags == X_BOUNDBOX_TOTALLY_INSIDE_FRUSTUM ) { clipped = * polygon ; clippedEdgeIds = edgeIds ; } else if ( ! x_polygon3_fp16x16_clip_to_frustum_edge_ids ( polygon , context -> renderContext -> viewFrustum , & clipped , geoFlags , edgeIds , clippedEdgeIds ) ) { return ; } X_AE_Surface * surface = context -> nextAvailableSurface ++ ; surface -> totalSpans = 0 ; surface -> bspKey = context -> nextBspKey ++ ; surface -> bspSurface = bspSurface ; surface -> crossCount = 0 ; surface -> closestZ = 0x7FFFFFFF ; X_Vec2 v2d [ 100 ] ; for ( int i = 0 ; i < clipped . totalVertices ; ++ i ) { X_Vec3 transformed ; x_mat4x4_transform_vec3_fp16x16 ( context -> renderContext -> viewMatrix , clipped . vertices + i , & transformed ) ; clipped . vertices [ i ] = transformed ; surface -> closestZ = X_MIN ( surface -> closestZ , transformed . z ) ; if ( surface -> closestZ < x_fp16x16_from_float ( 16 ) ) return ; X_Vec3 temp = x_vec3_fp16x16_to_vec3 ( & transformed ) ; x_viewport_project_vec3 ( & context -> renderContext -> cam -> viewport , & temp , v2d + i ) ; x_viewport_clamp_vec2 ( & context -> renderContext -> cam -> viewport , v2d + i ) ; } x_ae_surface_calculate_inverse_z_gradient ( surface , & context -> renderContext -> camPos , & context -> renderContext -> cam -> viewport , context -> renderContext -> viewMatrix ) ; x_polygon3_fp16x16_to_polygon3 ( & clipped , & clipped ) ; for ( int i = 0 ; i < clipped . totalVertices ; ++ i ) { int edgeId = abs ( clippedEdgeIds [ i ] ) ; X_BspEdge * bspEdge = context -> renderContext -> level -> edges + edgeId ; if ( edgeId != 0 ) { X_AE_Edge * cachedEdge = get_cached_edge ( context , bspEdge , context -> renderContext -> currentFrame ) ; if ( cachedEdge != NULL ) { <S2SV_StartBug> X_AE_Surface * s = X_MAX ( cachedEdge -> surfaces [ 0 ] , cachedEdge -> surfaces [ 1 ] ) ; <S2SV_EndBug> x_ae_context_emit_cached_edge ( cachedEdge , surface ) ; continue ; } } int next = ( i + 1 < clipped . totalVertices ? i + 1 : 0 ) ; x_ae_context_add_edge ( context , v2d + i , v2d + next , surface , bspEdge ) ; } } | <S2SV_ModStart> [ X_POLYGON3_MAX_VERTS ] = { 0 } <S2SV_ModStart> NULL ) { <S2SV_ModEnd> x_ae_context_emit_cached_edge ( cachedEdge |
552 | CWE-000 void virt_VCF1_LEVEL ( ) { <S2SV_StartBug> process_param_log_add ( VCF1_LEVEL , 0xFFFF - ( int32_t ) synth_param [ MASTER_LEVEL ] . last ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( VCF1_LEVEL , <S2SV_ModEnd> ( int32_t ) <S2SV_ModStart> ] . last - 0xFFFF |
553 | CWE-000 H5_ATTR_PURE int <S2SV_StartBug> print_objname ( diff_opt_t * options , hsize_t nfound ) <S2SV_EndBug> { <S2SV_StartBug> return ( ( options -> m_verbose || nfound ) && ! options -> m_quiet ) ? 1 : 0 ; <S2SV_EndBug> } | <S2SV_ModStart> ( diff_opt_t * opts <S2SV_ModEnd> , hsize_t nfound <S2SV_ModStart> return ( ( opts <S2SV_ModEnd> -> m_verbose || <S2SV_ModStart> ) && ! opts <S2SV_ModEnd> -> m_quiet ) |
554 | CWE-000 static void keyboard_mousepress ( t_keyboard * x , t_float xpix , t_float ypix ) { if ( x -> glist -> gl_edit ) return ; <S2SV_StartBug> if ( ( int ) xpix < x -> x_obj . te_xpix + 40 <S2SV_EndBug> <S2SV_StartBug> || ( int ) xpix > x -> x_obj . te_xpix + x -> width + 40 <S2SV_EndBug> || ( int ) ypix < x -> x_obj . te_ypix || ( int ) ypix > x -> x_obj . te_ypix + x -> height ) return ; keyboard_mapclick ( x , xpix , ypix , MOUSE_PRESS ) ; keyboard_play ( x ) ; } | <S2SV_ModStart> x_obj . te_xpix <S2SV_ModEnd> || ( int <S2SV_ModStart> x -> width <S2SV_ModEnd> || ( int |
555 | CWE-000 static s32 __wl_cfg80211_down ( struct wl_priv * wl ) { s32 err = 0 ; unsigned long flags ; struct net_info * iter , * next ; struct net_device * ndev = wl_to_prmry_ndev ( wl ) ; # if defined ( WL_CFG80211 ) && defined ( WL_ENABLE_P2P_IF ) struct net_device * p2p_net = wl -> p2p_net ; # endif u32 bssidx = 0 ; # ifdef PROP_TXSTATUS_VSDB dhd_pub_t * dhd = ( dhd_pub_t * ) ( wl -> pub ) ; # endif WL_DBG ( ( "In\\n" ) ) ; if ( wl -> pm_enable_work_on ) { cancel_delayed_work_sync ( & wl -> pm_enable_work ) ; wl -> pm_enable_work_on = false ; } <S2SV_StartBug> if ( wl -> p2p_supported ) { <S2SV_EndBug> wl_clr_p2p_status ( wl , GO_NEG_PHASE ) ; # ifdef PROP_TXSTATUS_VSDB if ( wl -> p2p -> vif_created ) { if ( dhd -> wlfc_enabled && wl -> wlfc_on ) { dhd -> wlfc_enabled = false ; dhd_wlfc_deinit ( dhd ) ; if ( dhd -> plat_deinit ) dhd -> plat_deinit ( ( void * ) dhd ) ; wl -> wlfc_on = false ; } } # endif } if ( ! ( wl_cfgp2p_find_idx ( wl , ndev , & bssidx ) ) && wl_cfgp2p_bss_isup ( ndev , bssidx ) ) { if ( wl_cfgp2p_bss ( wl , ndev , bssidx , 0 ) < 0 ) WL_ERR ( ( "BSS<S2SV_blank>down<S2SV_blank>failed<S2SV_blank>\\n" ) ) ; } if ( ! wl_get_drv_status ( wl , READY , ndev ) ) return err ; for_each_ndev ( wl , iter , next ) wl_set_drv_status ( wl , SCAN_ABORTING , iter -> ndev ) ; wl_term_iscan ( wl ) ; spin_lock_irqsave ( & wl -> cfgdrv_lock , flags ) ; if ( wl -> scan_request ) { cfg80211_scan_done ( wl -> scan_request , true ) ; wl -> scan_request = NULL ; } spin_unlock_irqrestore ( & wl -> cfgdrv_lock , flags ) ; for_each_ndev ( wl , iter , next ) { wl_clr_drv_status ( wl , READY , iter -> ndev ) ; wl_clr_drv_status ( wl , SCANNING , iter -> ndev ) ; wl_clr_drv_status ( wl , SCAN_ABORTING , iter -> ndev ) ; wl_clr_drv_status ( wl , CONNECTING , iter -> ndev ) ; wl_clr_drv_status ( wl , CONNECTED , iter -> ndev ) ; wl_clr_drv_status ( wl , DISCONNECTING , iter -> ndev ) ; wl_clr_drv_status ( wl , AP_CREATED , iter -> ndev ) ; wl_clr_drv_status ( wl , AP_CREATING , iter -> ndev ) ; } wl_to_prmry_ndev ( wl ) -> ieee80211_ptr -> iftype = NL80211_IFTYPE_STATION ; # if defined ( WL_CFG80211 ) && defined ( WL_ENABLE_P2P_IF ) if ( p2p_net ) dev_close ( p2p_net ) ; # endif DNGL_FUNC ( dhd_cfg80211_down , ( wl ) ) ; wl_flush_eq ( wl ) ; wl_link_down ( wl ) ; <S2SV_StartBug> if ( wl -> p2p_supported ) <S2SV_EndBug> wl_cfgp2p_down ( wl ) ; dhd_monitor_uninit ( ) ; return err ; } | <S2SV_ModStart> } if ( wl_cfgp2p_check_enabled ( wl ) <S2SV_ModEnd> ) { wl_clr_p2p_status <S2SV_ModStart> ; if ( wl_cfgp2p_check_enabled ( wl ) <S2SV_ModEnd> ) wl_cfgp2p_down ( |
556 | CWE-000 static int romfs_statfs ( struct dentry * dentry , struct kstatfs * buf ) { struct super_block * sb = dentry -> d_sb ; <S2SV_StartBug> u64 id = huge_encode_dev ( sb -> s_bdev -> bd_dev ) ; <S2SV_EndBug> buf -> f_type = ROMFS_MAGIC ; buf -> f_namelen = ROMFS_MAXFN ; buf -> f_bsize = ROMBSIZE ; buf -> f_bfree = buf -> f_bavail = buf -> f_ffree ; buf -> f_blocks = ( romfs_maxsize ( dentry -> d_sb ) + ROMBSIZE - 1 ) >> ROMBSBITS ; buf -> f_fsid . val [ 0 ] = ( u32 ) id ; buf -> f_fsid . val [ 1 ] = ( u32 ) ( id >> 32 ) ; return 0 ; } | <S2SV_ModStart> u64 id = 0 ; if ( sb -> s_bdev ) id = <S2SV_ModStart> s_bdev -> bd_dev ) ; else if ( sb -> s_dev ) id = huge_encode_dev ( sb -> s_dev |
557 | CWE-000 void l2c_link_processs_ble_num_bufs ( UINT16 num_lm_ble_bufs ) { if ( num_lm_ble_bufs == 0 ) { num_lm_ble_bufs = L2C_DEF_NUM_BLE_BUF_SHARED ; l2cb . num_lm_acl_bufs -= L2C_DEF_NUM_BLE_BUF_SHARED ; } <S2SV_StartBug> L2CAP_TRACE_ERROR ( "#####################################num_lm_ble_bufs<S2SV_blank>=<S2SV_blank>%d" , num_lm_ble_bufs ) ; <S2SV_EndBug> l2cb . num_lm_ble_bufs = l2cb . controller_le_xmit_window = num_lm_ble_bufs ; } | <S2SV_ModStart> L2C_DEF_NUM_BLE_BUF_SHARED ; } L2CAP_TRACE_DEBUG <S2SV_ModEnd> ( "#####################################num_lm_ble_bufs<S2SV_blank>=<S2SV_blank>%d" , |
558 | CWE-000 int l2tp_tunnel_delete ( struct l2tp_tunnel * tunnel ) { <S2SV_StartBug> l2tp_tunnel_closeall ( tunnel ) ; <S2SV_EndBug> <S2SV_StartBug> return ( false == queue_work ( l2tp_wq , & tunnel -> del_work ) ) ; <S2SV_EndBug> } | <S2SV_ModStart> tunnel ) { l2tp_tunnel_inc_refcount ( tunnel ) ; <S2SV_ModStart> tunnel ) ; if <S2SV_ModEnd> ( false == <S2SV_ModStart> del_work ) ) { l2tp_tunnel_dec_refcount ( tunnel ) ; return 1 ; } return 0 |
559 | CWE-000 cairo_int_status_t _cairo_image_info_get_jpeg_info ( cairo_image_info_t * info , const unsigned char * data , long length ) { const unsigned char * p = data ; info -> is_adobe_jpeg = FALSE ; while ( p + 1 < data + length ) { if ( * p != 0xff ) return CAIRO_INT_STATUS_UNSUPPORTED ; p ++ ; switch ( * p ) { case 0xff : p ++ ; break ; case TEM : case SOI : case EOI : p ++ ; break ; case SOF0 : case SOF1 : case SOF2 : case SOF3 : case SOF5 : case SOF6 : case SOF7 : case SOF9 : case SOF10 : case SOF11 : case SOF13 : case SOF14 : case SOF15 : if ( p + 8 > data + length ) return CAIRO_INT_STATUS_UNSUPPORTED ; _jpeg_extract_info ( info , p ) ; return CAIRO_STATUS_SUCCESS ; case APP14 : if ( p + 12 > data + length ) return CAIRO_INT_STATUS_UNSUPPORTED ; info -> is_adobe_jpeg = ( 0 == strncmp ( ( const char * ) ( p + 3 ) , "Adobe" , 5 ) ) ; p = _jpeg_skip_segment ( p ) ; break ; default : if ( * p >= RST_begin && * p <= RST_end ) { p ++ ; break ; } <S2SV_StartBug> if ( p + 2 > data + length ) <S2SV_EndBug> return CAIRO_INT_STATUS_UNSUPPORTED ; p = _jpeg_skip_segment ( p ) ; break ; } } return CAIRO_STATUS_SUCCESS ; } | <S2SV_ModStart> ( p + 3 <S2SV_ModEnd> > data + |
560 | CWE-000 Bool RAMP_Server_init ( void ) { Int i ; RAMP_ELEM * msg ; Error_Block eb ; UART_Params uartParams ; Task_Params taskParams ; <S2SV_StartBug> uint32_t baudRate = ( GPIO_read ( Board_GPIO_DIP_SW2 ) == 0 ) ? 1000000 : 400000 ; <S2SV_EndBug> UART_Params_init ( & uartParams ) ; uartParams . readMode = UART_MODE_BLOCKING ; uartParams . writeMode = UART_MODE_BLOCKING ; uartParams . readTimeout = 2000 ; uartParams . writeTimeout = BIOS_WAIT_FOREVER ; uartParams . readCallback = NULL ; uartParams . writeCallback = NULL ; uartParams . readReturnMode = UART_RETURN_FULL ; uartParams . writeDataMode = UART_DATA_BINARY ; uartParams . readDataMode = UART_DATA_BINARY ; uartParams . readEcho = UART_ECHO_OFF ; uartParams . baudRate = baudRate ; uartParams . stopBits = UART_STOP_ONE ; uartParams . parityType = UART_PAR_NONE ; g_svr . uartHandle = UART_open ( Board_UART_RS422_REMOTE , & uartParams ) ; if ( g_svr . uartHandle == NULL ) System_abort ( "Error<S2SV_blank>initializing<S2SV_blank>UART\\n" ) ; GPIO_write ( Board_RS422_DE , PIN_HIGH ) ; GPIO_write ( Board_RS422_RE_N , PIN_LOW ) ; g_svr . txFreeQue = Queue_create ( NULL , NULL ) ; g_svr . txDataQue = Queue_create ( NULL , NULL ) ; g_svr . rxFreeQue = Queue_create ( NULL , NULL ) ; g_svr . rxDataQue = Queue_create ( NULL , NULL ) ; g_svr . txFreeSem = Semaphore_create ( MAX_WINDOW , NULL , NULL ) ; g_svr . txDataSem = Semaphore_create ( 0 , NULL , NULL ) ; g_svr . rxFreeSem = Semaphore_create ( MAX_WINDOW , NULL , NULL ) ; g_svr . rxDataSem = Semaphore_create ( 0 , NULL , NULL ) ; Error_init ( & eb ) ; g_svr . ackEvent = Event_create ( NULL , NULL ) ; Error_init ( & eb ) ; g_svr . txBuf = ( RAMP_ELEM * ) Memory_alloc ( NULL , sizeof ( RAMP_ELEM ) * MAX_WINDOW , 0 , & eb ) ; if ( g_svr . txBuf == NULL ) System_abort ( "TxBuf<S2SV_blank>allocation<S2SV_blank>failed" ) ; msg = g_svr . txBuf ; for ( i = 0 ; i < MAX_WINDOW ; i ++ , msg ++ ) { Queue_enqueue ( g_svr . txFreeQue , ( Queue_Elem * ) msg ) ; } Error_init ( & eb ) ; g_svr . rxBuf = ( RAMP_ELEM * ) Memory_alloc ( NULL , sizeof ( RAMP_ELEM ) * MAX_WINDOW , 0 , & eb ) ; if ( g_svr . rxBuf == NULL ) System_abort ( "RxBuf<S2SV_blank>allocation<S2SV_blank>failed" ) ; msg = g_svr . rxBuf ; for ( i = 0 ; i < MAX_WINDOW ; i ++ , msg ++ ) { Queue_enqueue ( g_svr . rxFreeQue , ( Queue_Elem * ) msg ) ; } Error_init ( & eb ) ; g_svr . ackBuf = ( RAMP_ACK * ) Memory_alloc ( NULL , sizeof ( RAMP_ACK ) * MAX_WINDOW , 0 , & eb ) ; if ( g_svr . ackBuf == NULL ) System_abort ( "AckBuf<S2SV_blank>allocation<S2SV_blank>failed" ) ; g_svr . txErrors = 0 ; g_svr . txCount = 0 ; g_svr . txNumFreeMsgs = MAX_WINDOW ; g_svr . txNextSeq = MIN_SEQ_NUM ; g_svr . rxErrors = 0 ; g_svr . rxCount = 0 ; g_svr . rxNumFreeMsgs = MAX_WINDOW ; g_svr . rxLastSeq = 0 ; g_svr . rxExpectedSeq = MIN_SEQ_NUM ; Error_init ( & eb ) ; Task_Params_init ( & taskParams ) ; taskParams . stackSize = 700 ; taskParams . priority = 8 ; taskParams . arg0 = ( UArg ) & g_svr ; taskParams . arg1 = 0 ; Task_create ( ( Task_FuncPtr ) RAMPWriterTaskFxn , & taskParams , & eb ) ; Error_init ( & eb ) ; Task_Params_init ( & taskParams ) ; taskParams . stackSize = 700 ; taskParams . priority = 9 ; taskParams . arg0 = ( UArg ) & g_svr ; taskParams . arg1 = 0 ; Task_create ( ( Task_FuncPtr ) RAMPReaderTaskFxn , & taskParams , & eb ) ; Error_init ( & eb ) ; Task_Params_init ( & taskParams ) ; taskParams . stackSize = 700 ; taskParams . priority = 10 ; taskParams . arg0 = ( UArg ) & g_svr ; taskParams . arg1 = 0 ; Task_create ( ( Task_FuncPtr ) RAMPWorkerTaskFxn , & taskParams , & eb ) ; return TRUE ; } | <S2SV_ModStart> 0 ) ? 1500000 <S2SV_ModEnd> : 400000 ; |
561 | CWE-000 static void its_cpu_init_lpis ( void ) { void __iomem * rbase = gic_data_rdist_rd_base ( ) ; struct page * pend_page ; u64 val , tmp ; pend_page = gic_data_rdist ( ) -> pend_page ; if ( ! pend_page ) { phys_addr_t paddr ; <S2SV_StartBug> pend_page = its_allocate_pending_table ( GFP_NOWAIT ) ; <S2SV_EndBug> if ( ! pend_page ) { pr_err ( "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>PENDBASE<S2SV_blank>for<S2SV_blank>CPU%d\\n" , smp_processor_id ( ) ) ; return ; <S2SV_StartBug> } <S2SV_EndBug> paddr = page_to_phys ( pend_page ) ; pr_info ( "CPU%d:<S2SV_blank>using<S2SV_blank>LPI<S2SV_blank>pending<S2SV_blank>table<S2SV_blank>@%pa\\n" , smp_processor_id ( ) , & paddr ) ; gic_data_rdist ( ) -> pend_page = pend_page ; } val = readl_relaxed ( rbase + GICR_CTLR ) ; val &= ~ GICR_CTLR_ENABLE_LPIS ; writel_relaxed ( val , rbase + GICR_CTLR ) ; dsb ( sy ) ; val = ( page_to_phys ( gic_rdists -> prop_page ) | GICR_PROPBASER_InnerShareable | GICR_PROPBASER_RaWaWb | ( ( LPI_NRBITS - 1 ) & GICR_PROPBASER_IDBITS_MASK ) ) ; gicr_write_propbaser ( val , rbase + GICR_PROPBASER ) ; tmp = gicr_read_propbaser ( rbase + GICR_PROPBASER ) ; if ( ( tmp ^ val ) & GICR_PROPBASER_SHAREABILITY_MASK ) { if ( ! ( tmp & GICR_PROPBASER_SHAREABILITY_MASK ) ) { val &= ~ ( GICR_PROPBASER_SHAREABILITY_MASK | GICR_PROPBASER_CACHEABILITY_MASK ) ; val |= GICR_PROPBASER_nC ; gicr_write_propbaser ( val , rbase + GICR_PROPBASER ) ; } pr_info_once ( "GIC:<S2SV_blank>using<S2SV_blank>cache<S2SV_blank>flushing<S2SV_blank>for<S2SV_blank>LPI<S2SV_blank>property<S2SV_blank>table\\n" ) ; gic_rdists -> flags |= RDIST_FLAGS_PROPBASE_NEEDS_FLUSHING ; } val = ( page_to_phys ( pend_page ) | GICR_PENDBASER_InnerShareable | GICR_PENDBASER_RaWaWb ) ; gicr_write_pendbaser ( val , rbase + GICR_PENDBASER ) ; tmp = gicr_read_pendbaser ( rbase + GICR_PENDBASER ) ; if ( ! ( tmp & GICR_PENDBASER_SHAREABILITY_MASK ) ) { val &= ~ ( GICR_PENDBASER_SHAREABILITY_MASK | GICR_PENDBASER_CACHEABILITY_MASK ) ; val |= GICR_PENDBASER_nC ; gicr_write_pendbaser ( val , rbase + GICR_PENDBASER ) ; } val = readl_relaxed ( rbase + GICR_CTLR ) ; val |= GICR_CTLR_ENABLE_LPIS ; writel_relaxed ( val , rbase + GICR_CTLR ) ; dsb ( sy ) ; } | <S2SV_ModStart> phys_addr_t paddr ; if ( its_prop_phys ) { paddr = readq_relaxed ( rbase + GICR_PENDBASER ) ; val = readl_relaxed ( rbase + GICR_CTLR ) ; if ( val & GICR_CTLR_ENABLE_LPIS ) { paddr &= GENMASK ( 51 , 16 ) ; pend_page = phys_to_page ( paddr ) ; memset ( page_address ( pend_page ) , 0 , SZ_64K ) ; gic_flush_dcache_to_poc ( page_address ( pend_page ) , LPI_PENDBASE_SZ ) ; goto reuse_pend_page ; } } <S2SV_ModStart> return ; } reuse_pend_page : |
562 | CWE-000 CeCommandStatus_t command_show_yanks ( CeCommand_t * command , void * user_data ) { if ( command -> arg_count != 0 ) return CE_COMMAND_PRINT_HELP ; CeApp_t * app = user_data ; <S2SV_StartBug> CommandContext_t command_context ; <S2SV_EndBug> if ( ! get_command_context ( app , & command_context ) ) return CE_COMMAND_NO_ACTION ; ce_view_switch_buffer ( command_context . view , app -> yank_list_buffer , & app -> vim , & app -> config_options , true ) ; return CE_COMMAND_SUCCESS ; } | <S2SV_ModStart> ; CommandContext_t command_context = { } |
563 | CWE-000 static void _eit_module_load_config ( eit_module_t * mod ) { if ( ! mod -> scrape_episode ) { tvhinfo ( LS_TBL_EIT , "module<S2SV_blank>%s<S2SV_blank>-<S2SV_blank>scraper<S2SV_blank>disabled<S2SV_blank>by<S2SV_blank>config" , mod -> id ) ; return ; } <S2SV_StartBug> const char config_path [ ] = "epggrab/eit/fixup/%s" ; <S2SV_EndBug> <S2SV_StartBug> const char * config_file = mod -> id ; <S2SV_EndBug> htsmsg_t * m = hts_settings_load ( config_path , config_file ) ; char * generic_name = NULL ; if ( ! m ) { <S2SV_StartBug> generic_name = strdup ( mod -> id ) ; <S2SV_EndBug> if ( generic_name ) { char * underscore = strstr ( generic_name , "_" ) ; if ( underscore ) { * underscore = 0 ; config_file = generic_name ; m = hts_settings_load ( config_path , config_file ) ; } } } if ( m ) { <S2SV_StartBug> const int r = _eit_fixup_load_one ( m , mod ) ; <S2SV_EndBug> if ( r > 0 ) <S2SV_StartBug> tvhinfo ( LS_TBL_EIT , "scraper<S2SV_blank>%s<S2SV_blank>loaded<S2SV_blank>config<S2SV_blank>%s" , mod -> id , config_file ) ; <S2SV_EndBug> else <S2SV_StartBug> tvhwarn ( LS_TBL_EIT , "scraper<S2SV_blank>%s<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>load" , mod -> id ) ; <S2SV_EndBug> htsmsg_destroy ( m ) ; } else { <S2SV_StartBug> tvhinfo ( LS_TBL_EIT , "no<S2SV_blank>scraper<S2SV_blank>config<S2SV_blank>files<S2SV_blank>loaded<S2SV_blank>for<S2SV_blank>%s" , mod -> id ) ; <S2SV_EndBug> } if ( generic_name ) free ( generic_name ) ; } | <S2SV_ModStart> [ ] = "epggrab/eit/scrape/%s" <S2SV_ModEnd> ; const char <S2SV_ModStart> = mod -> scrape_config && * mod -> scrape_config ? mod -> scrape_config : mod -> id ; tvhinfo ( LS_TBL_EIT , "scraper<S2SV_blank>%s<S2SV_blank>attempt<S2SV_blank>to<S2SV_blank>load<S2SV_blank>config<S2SV_blank>\\"%s\\"" , mod -> id , config_file ) <S2SV_ModEnd> ; htsmsg_t * <S2SV_ModStart> = strdup ( config_file <S2SV_ModEnd> ) ; if <S2SV_ModStart> int r = _eit_scrape_load_one <S2SV_ModEnd> ( m , <S2SV_ModStart> ( LS_TBL_EIT , "scraper<S2SV_blank>%s<S2SV_blank>loaded<S2SV_blank>config<S2SV_blank>\\"%s\\"" <S2SV_ModEnd> , mod -> <S2SV_ModStart> ( LS_TBL_EIT , "scraper<S2SV_blank>%s<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>load<S2SV_blank>config<S2SV_blank>\\"%s\\"" , mod -> id , config_file <S2SV_ModEnd> ) ; htsmsg_destroy <S2SV_ModStart> ( LS_TBL_EIT , "scraper<S2SV_blank>%s<S2SV_blank>no<S2SV_blank>scraper<S2SV_blank>config<S2SV_blank>files<S2SV_blank>found" <S2SV_ModEnd> , mod -> |
564 | CWE-000 int tetris_best_move ( ws2811_led_t * gamefield , struct tetris_piece piece , int loc ) { ws2811_led_t * fakegamefield ; fakegamefield = malloc ( sizeof ( ws2811_led_t ) * width * height ) ; memcpy ( fakegamefield , gamefield , sizeof ( ws2811_led_t ) * width * height ) ; int fakeloc = loc ; int rotated = 0 ; int scores [ 4 * width ] ; int i ; for ( i = 0 ; i < 4 * width ; i ++ ) { scores [ i ] = 0 ; } while ( rotated < 4 ) { for ( i = 0 ; i < width ; i ++ ) { while ( tetris_render_fit_piece ( fakegamefield , fakeloc , piece , 0 ) ) { fakeloc += width ; } if ( fakeloc > width ) { fakeloc -= width ; tetris_render_fit_piece ( fakegamefield , loc , piece , 1 ) ; tetris_remove_line ( fakegamefield ) ; scores [ ( rotated * width ) + i ] = tetris_eval_gamestate ( fakegamefield ) ; } memcpy ( fakegamefield , gamefield , sizeof ( ws2811_led_t ) * width * height ) ; fakeloc = loc ; } rotate_tetris_piece ( & piece ) ; rotated ++ ; } free ( fakegamefield ) ; int bestmove = 0 ; int bestscore = 0 ; <S2SV_StartBug> printf ( "TETRIS:<S2SV_blank>evaluated<S2SV_blank>scores:<S2SV_blank>---------\\n" ) ; <S2SV_EndBug> for ( i = 0 ; i < 4 * width ; i ++ ) { printf ( "move<S2SV_blank>%i,<S2SV_blank>score:<S2SV_blank>%i\\n" , i , scores [ i ] ) ; if ( scores [ i ] > bestscore ) { bestscore = scores [ i ] ; bestmove = i ; } } printf ( "----------------------\\n" ) ; if ( bestmove > ( width - 1 ) ) { printf ( "TETRIS:<S2SV_blank>optimal<S2SV_blank>move:<S2SV_blank>rotate,<S2SV_blank>score:<S2SV_blank>%i\\n" , bestscore ) ; return 3 ; } else { if ( bestmove > loc % width ) { printf ( "TETRIS:<S2SV_blank>optimal<S2SV_blank>move:<S2SV_blank>left,<S2SV_blank>score:<S2SV_blank>%i\\n" , bestscore ) ; return 0 ; } if ( bestmove < loc % width ) { printf ( "TETRIS:<S2SV_blank>optimal<S2SV_blank>move:<S2SV_blank>right,<S2SV_blank>score:<S2SV_blank>%i\\n" , bestscore ) ; return 1 ; } else { return 2 ; } } } | <S2SV_ModStart> ; printf ( "TETRIS:<S2SV_blank>loc:<S2SV_blank>%i,<S2SV_blank>evaluated<S2SV_blank>scores:<S2SV_blank>---------\\n" , loc <S2SV_ModEnd> ) ; for |
565 | CWE-000 void robot_sfree ( void ) { <S2SV_StartBug> write_cmd ( "sfree<S2SV_blank>%s\\n" ) ; <S2SV_EndBug> } | <S2SV_ModStart> { write_cmd ( "sfree\\n" <S2SV_ModEnd> ) ; } |
566 | CWE-000 mongoc_async_cmd_result_t _mongoc_async_cmd_phase_recv_len ( mongoc_async_cmd_t * acmd ) { ssize_t bytes = _mongoc_buffer_try_append_from_stream ( & acmd -> buffer , acmd -> stream , acmd -> bytes_to_read , 0 ) ; uint32_t msg_len ; <S2SV_StartBug> if ( bytes < 0 ) { <S2SV_EndBug> bson_set_error ( & acmd -> error , MONGOC_ERROR_STREAM , MONGOC_ERROR_STREAM_SOCKET , "Failed<S2SV_blank>to<S2SV_blank>receive<S2SV_blank>length<S2SV_blank>header<S2SV_blank>from<S2SV_blank>server." ) ; return MONGOC_ASYNC_CMD_ERROR ; } if ( bytes == 0 ) { bson_set_error ( & acmd -> error , MONGOC_ERROR_STREAM , MONGOC_ERROR_STREAM_SOCKET , "Server<S2SV_blank>closed<S2SV_blank>connection." ) ; return MONGOC_ASYNC_CMD_ERROR ; } <S2SV_StartBug> acmd -> bytes_to_read -= bytes ; <S2SV_EndBug> if ( ! acmd -> bytes_to_read ) { memcpy ( & msg_len , acmd -> buffer . data , 4 ) ; msg_len = BSON_UINT32_FROM_LE ( msg_len ) ; <S2SV_StartBug> if ( ( msg_len < 16 ) || ( msg_len > MONGOC_DEFAULT_MAX_MSG_SIZE ) ) { <S2SV_EndBug> bson_set_error ( & acmd -> error , MONGOC_ERROR_PROTOCOL , MONGOC_ERROR_PROTOCOL_INVALID_REPLY , "Invalid<S2SV_blank>reply<S2SV_blank>from<S2SV_blank>server." ) ; return MONGOC_ASYNC_CMD_ERROR ; } <S2SV_StartBug> acmd -> bytes_to_read = msg_len - 4 ; <S2SV_EndBug> acmd -> state = MONGOC_ASYNC_CMD_RECV_RPC ; return _mongoc_async_cmd_phase_recv_rpc ( acmd ) ; } return MONGOC_ASYNC_CMD_IN_PROGRESS ; } | <S2SV_ModStart> if ( bytes <= 0 && mongoc_stream_should_retry ( acmd -> stream ) ) { return MONGOC_ASYNC_CMD_IN_PROGRESS ; } if ( bytes <S2SV_ModStart> acmd -> bytes_to_read = ( size_t ) ( acmd -> bytes_to_read - bytes ) <S2SV_ModEnd> ; if ( <S2SV_ModStart> ; if ( <S2SV_ModEnd> msg_len < 16 <S2SV_ModStart> msg_len < 16 || <S2SV_ModEnd> msg_len > MONGOC_DEFAULT_MAX_MSG_SIZE <S2SV_ModStart> msg_len > MONGOC_DEFAULT_MAX_MSG_SIZE || msg_len < acmd -> buffer . len <S2SV_ModEnd> ) { bson_set_error <S2SV_ModStart> = msg_len - acmd -> buffer . len <S2SV_ModEnd> ; acmd -> |
567 | CWE-000 static void gen_vmassignment ( codegen_scope * s , node * tree , int rhs , int val ) { int n = 0 , post = 0 ; node * t , * p ; if ( tree -> car ) { t = tree -> car ; n = 0 ; while ( t ) { genop ( s , MKOP_ABC ( OP_AREF , cursp ( ) , rhs , n ) ) ; gen_assignment ( s , t -> car , cursp ( ) , NOVAL ) ; n ++ ; t = t -> cdr ; } } t = tree -> cdr ; if ( t ) { if ( t -> cdr ) { p = t -> cdr -> car ; while ( p ) { post ++ ; p = p -> cdr ; } } if ( val ) { genop ( s , MKOP_AB ( OP_MOVE , cursp ( ) , rhs ) ) ; } else { pop ( ) ; } push_n ( post ) ; pop_n ( post ) ; genop ( s , MKOP_ABC ( OP_APOST , cursp ( ) , n , post ) ) ; n = 1 ; if ( t -> car ) { gen_assignment ( s , t -> car , cursp ( ) , NOVAL ) ; } if ( t -> cdr && t -> cdr -> car ) { t = t -> cdr -> car ; while ( t ) { gen_assignment ( s , t -> car , cursp ( ) + n , NOVAL ) ; t = t -> cdr ; n ++ ; } } <S2SV_StartBug> push ( ) ; <S2SV_EndBug> } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ; } } if ( ! val ) { <S2SV_ModStart> ; } } } |
568 | CWE-000 ANSC_STATUS CosaDmlGetCloudUIReachableStatus ( CHAR * pCloudPersonalizationURL , BOOL * pValue ) { ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS ; BOOL bProcessFuther = TRUE ; if ( NULL == pCloudPersonalizationURL ) { * pValue = FALSE ; returnStatus = ANSC_STATUS_FAILURE ; bProcessFuther = FALSE ; } if ( bProcessFuther ) { FILE * fp ; char cmdBuff [ 512 ] = { 0 } , retBuff [ 256 ] = { 0 } ; int curlResponse = 0 ; snprintf ( cmdBuff , sizeof ( cmdBuff ) , "curl<S2SV_blank>--connect-timeout<S2SV_blank>10<S2SV_blank>--interface<S2SV_blank>erouter0<S2SV_blank>--write-out<S2SV_blank>%%{http_code}<S2SV_blank>--silent<S2SV_blank>--output<S2SV_blank>/dev/null<S2SV_blank>%s" , pCloudPersonalizationURL ) ; fp = popen ( cmdBuff , "r" ) ; if ( NULL != fp ) { fgets ( retBuff , sizeof ( retBuff ) , fp ) ; <S2SV_StartBug> fclose ( fp ) ; <S2SV_EndBug> curlResponse = atoi ( retBuff ) ; CcspTraceInfo ( ( "URL[<S2SV_blank>%s<S2SV_blank>]<S2SV_blank>curlResponse[<S2SV_blank>%d<S2SV_blank>]\\n" , pCloudPersonalizationURL , curlResponse ) ) ; if ( ( curlResponse >= 200 ) && ( curlResponse < 400 ) ) { * pValue = TRUE ; } else { * pValue = FALSE ; } } else { * pValue = FALSE ; } } return returnStatus ; } | <S2SV_ModStart> fp ) ; pclose <S2SV_ModEnd> ( fp ) |
569 | CWE-000 static inline struct page * __alloc_pages_direct_compact ( gfp_t gfp_mask , unsigned int order , unsigned int alloc_flags , const struct alloc_context * ac , enum migrate_mode mode , enum compact_result * compact_result ) { <S2SV_StartBug> return NULL ; <S2SV_EndBug> } | <S2SV_ModStart> compact_result ) { * compact_result = COMPACT_SKIPPED ; |
570 | CWE-000 const redisAsyncContext * redis_pool_get_context ( struct redis_pool * p ) { <S2SV_StartBug> int orig = p -> cur ; <S2SV_EndBug> do { <S2SV_StartBug> p -> cur ++ ; <S2SV_EndBug> <S2SV_StartBug> p -> cur %= p -> count ; <S2SV_EndBug> <S2SV_StartBug> if ( p -> ac [ p -> cur ] != NULL ) { <S2SV_EndBug> <S2SV_StartBug> return p -> ac [ p -> cur ] ; <S2SV_EndBug> } else { if ( p -> connecting < p -> count ) { struct redis_pool_conn_req * req = redis_pool_conn_req_new ( p ) ; redis_pool_connect ( req ) ; } } <S2SV_StartBug> } while ( p -> cur != orig ) ; <S2SV_EndBug> return NULL ; } | <S2SV_ModStart> = p -> current <S2SV_ModEnd> ; do { <S2SV_ModStart> { p -> current <S2SV_ModEnd> ++ ; p <S2SV_ModStart> ; p -> current <S2SV_ModEnd> %= p -> <S2SV_ModStart> [ p -> current <S2SV_ModEnd> ] != NULL <S2SV_ModStart> [ p -> current <S2SV_ModEnd> ] ; } <S2SV_ModStart> ( p -> current <S2SV_ModEnd> != orig ) |
571 | CWE-000 void si_flush_gfx_cs ( struct si_context * ctx , unsigned flags , struct pipe_fence_handle * * fence ) { struct radeon_cmdbuf * cs = ctx -> gfx_cs ; struct radeon_winsys * ws = ctx -> ws ; unsigned wait_flags = 0 ; if ( ctx -> gfx_flush_in_progress ) return ; if ( ! ctx -> screen -> info . kernel_flushes_tc_l2_after_ib ) { wait_flags |= SI_CONTEXT_PS_PARTIAL_FLUSH | SI_CONTEXT_CS_PARTIAL_FLUSH | SI_CONTEXT_INV_GLOBAL_L2 ; } else if ( ctx -> chip_class == SI ) { wait_flags |= SI_CONTEXT_PS_PARTIAL_FLUSH | SI_CONTEXT_CS_PARTIAL_FLUSH ; } else if ( ! ( flags & RADEON_FLUSH_START_NEXT_GFX_IB_NOW ) ) { wait_flags |= SI_CONTEXT_PS_PARTIAL_FLUSH | SI_CONTEXT_CS_PARTIAL_FLUSH ; } if ( ! radeon_emitted ( cs , ctx -> initial_gfx_cs_size ) && ( ! wait_flags || ! ctx -> gfx_last_ib_is_busy ) ) return ; if ( si_check_device_reset ( ctx ) ) return ; if ( ctx -> screen -> debug_flags & DBG ( CHECK_VM ) ) flags &= ~ PIPE_FLUSH_ASYNC ; if ( radeon_emitted ( ctx -> dma_cs , 0 ) ) { assert ( fence == NULL ) ; si_flush_dma_cs ( ctx , flags , NULL ) ; } ctx -> gfx_flush_in_progress = true ; if ( ! LIST_IS_EMPTY ( & ctx -> active_queries ) ) si_suspend_queries ( ctx ) ; ctx -> streamout . suspended = false ; if ( ctx -> streamout . begin_emitted ) { si_emit_streamout_end ( ctx ) ; ctx -> streamout . suspended = true ; } if ( ctx -> chip_class >= CIK ) si_cp_dma_wait_for_idle ( ctx ) ; if ( wait_flags ) { ctx -> flags |= wait_flags ; si_emit_cache_flush ( ctx ) ; } ctx -> gfx_last_ib_is_busy = wait_flags == 0 ; if ( ctx -> current_saved_cs ) { si_trace_emit ( ctx ) ; <S2SV_StartBug> si_log_hw_flush ( ctx ) ; <S2SV_EndBug> si_save_cs ( ws , cs , & ctx -> current_saved_cs -> gfx , true ) ; ctx -> current_saved_cs -> flushed = true ; ctx -> current_saved_cs -> time_flush = os_time_get_nano ( ) ; } ws -> cs_flush ( cs , flags , & ctx -> last_gfx_fence ) ; if ( fence ) ws -> fence_reference ( fence , ctx -> last_gfx_fence ) ; ctx -> num_gfx_cs_flushes ++ ; if ( ctx -> screen -> debug_flags & DBG ( CHECK_VM ) ) { ctx -> ws -> fence_wait ( ctx -> ws , ctx -> last_gfx_fence , 800 * 1000 * 1000 ) ; si_check_vm_faults ( ctx , & ctx -> current_saved_cs -> gfx , RING_GFX ) ; } if ( ctx -> current_saved_cs ) si_saved_cs_reference ( & ctx -> current_saved_cs , NULL ) ; si_begin_new_gfx_cs ( ctx ) ; ctx -> gfx_flush_in_progress = false ; } | <S2SV_ModStart> ctx ) ; si_save_cs ( ws , cs , & ctx -> current_saved_cs -> gfx , true ) ; ctx -> current_saved_cs -> flushed = true ; ctx -> current_saved_cs -> time_flush = os_time_get_nano ( ) ; <S2SV_ModStart> si_log_hw_flush ( ctx <S2SV_ModEnd> ) ; } |
572 | CWE-000 int smtp_hdlr_ehlo ( struct smtp_server_context * ctx , const char * cmd , const char * arg , bfd_t * stream ) { <S2SV_StartBug> char * domain ; <S2SV_EndBug> domain = ( char * ) arg ; domain [ strcspn ( domain , "\\r\\n" ) ] = '\\0' ; jsval ret = call_js_handler_with_arg ( cmd , arg ) ; ctx -> code = js_get_code ( ret ) ; ctx -> message = js_get_message ( ret ) ; return js_get_disconnect ( ret ) ; } | <S2SV_ModStart> stream ) { <S2SV_ModEnd> jsval ret = |
573 | CWE-000 static int map_frame_to_surface ( const AVFrame * frame , mfxFrameSurface1 * surface ) { switch ( frame -> format ) { case AV_PIX_FMT_NV12 : <S2SV_StartBug> surface -> Data . Y = frame -> data [ 0 ] ; <S2SV_EndBug> surface -> Data . UV = frame -> data [ 1 ] ; break ; case AV_PIX_FMT_YUV420P : surface -> Data . Y = frame -> data [ 0 ] ; surface -> Data . U = frame -> data [ 1 ] ; surface -> Data . V = frame -> data [ 2 ] ; break ; case AV_PIX_FMT_YUYV422 : surface -> Data . Y = frame -> data [ 0 ] ; surface -> Data . U = frame -> data [ 0 ] + 1 ; surface -> Data . V = frame -> data [ 0 ] + 3 ; break ; case AV_PIX_FMT_RGB32 : surface -> Data . B = frame -> data [ 0 ] ; surface -> Data . G = frame -> data [ 0 ] + 1 ; surface -> Data . R = frame -> data [ 0 ] + 2 ; surface -> Data . A = frame -> data [ 0 ] + 3 ; break ; default : return MFX_ERR_UNSUPPORTED ; } surface -> Data . Pitch = frame -> linesize [ 0 ] ; surface -> Data . TimeStamp = frame -> pts ; return 0 ; } | <S2SV_ModStart> case AV_PIX_FMT_NV12 : case AV_PIX_FMT_P010 : |
574 | CWE-000 static void ngx_http_upstream_send_request ( ngx_http_request_t * r , ngx_http_upstream_t * u , ngx_uint_t do_write ) { ngx_int_t rc ; ngx_connection_t * c ; c = u -> peer . connection ; ngx_log_debug0 ( NGX_LOG_DEBUG_HTTP , c -> log , 0 , "http<S2SV_blank>upstream<S2SV_blank>send<S2SV_blank>request" ) ; if ( u -> state -> connect_time == ( ngx_msec_t ) - 1 ) { u -> state -> connect_time = ngx_current_msec - u -> state -> response_time ; } if ( ! u -> request_sent && ngx_http_upstream_test_connect ( c ) != NGX_OK ) { ngx_http_upstream_next ( r , u , NGX_HTTP_UPSTREAM_FT_ERROR ) ; return ; } c -> log -> action = "sending<S2SV_blank>request<S2SV_blank>to<S2SV_blank>upstream" ; rc = ngx_http_upstream_send_request_body ( r , u , do_write ) ; if ( rc == NGX_ERROR ) { ngx_http_upstream_next ( r , u , NGX_HTTP_UPSTREAM_FT_ERROR ) ; return ; } if ( rc >= NGX_HTTP_SPECIAL_RESPONSE ) { ngx_http_upstream_finalize_request ( r , u , rc ) ; return ; } if ( rc == NGX_AGAIN ) { if ( ! c -> write -> ready || u -> request_body_blocked ) { ngx_add_timer ( c -> write , u -> conf -> send_timeout ) ; } else if ( c -> write -> timer_set ) { ngx_del_timer ( c -> write ) ; } if ( ngx_handle_write_event ( c -> write , u -> conf -> send_lowat ) != NGX_OK ) { ngx_http_upstream_finalize_request ( r , u , NGX_HTTP_INTERNAL_SERVER_ERROR ) ; return ; } return ; } <S2SV_StartBug> u -> request_body_sent = 1 ; <S2SV_EndBug> if ( c -> write -> timer_set ) { ngx_del_timer ( c -> write ) ; } if ( c -> tcp_nopush == NGX_TCP_NOPUSH_SET ) { if ( ngx_tcp_push ( c -> fd ) == - 1 ) { ngx_log_error ( NGX_LOG_CRIT , c -> log , ngx_socket_errno , ngx_tcp_push_n "<S2SV_blank>failed" ) ; ngx_http_upstream_finalize_request ( r , u , NGX_HTTP_INTERNAL_SERVER_ERROR ) ; return ; } c -> tcp_nopush = NGX_TCP_NOPUSH_UNSET ; } if ( ! u -> conf -> preserve_output ) { u -> write_event_handler = ngx_http_upstream_dummy_handler ; } if ( ngx_handle_write_event ( c -> write , 0 ) != NGX_OK ) { ngx_http_upstream_finalize_request ( r , u , NGX_HTTP_INTERNAL_SERVER_ERROR ) ; return ; } <S2SV_StartBug> ngx_add_timer ( c -> read , u -> conf -> read_timeout ) ; <S2SV_EndBug> if ( c -> read -> ready ) { ngx_http_upstream_process_header ( r , u ) ; return ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> return ; } <S2SV_ModEnd> if ( c <S2SV_ModStart> return ; } if ( ! u -> request_body_sent ) { u -> request_body_sent = 1 ; if ( u -> header_sent ) { return ; } <S2SV_ModStart> ; } } } |
575 | CWE-000 char * handleNodeArrayDeclarationList ( Node * node ) { NodeList * current_list = ( NodeList * ) node ; const size_t buffer_length = 1000 ; char * buffer = malloc ( buffer_length ) ; buffer [ 0 ] = '\\0' ; if ( current_list == NULL || current_list -> node == NULL ) return buffer ; <S2SV_StartBug> char * bufPoint = buffer ; <S2SV_EndBug> do { Node * current_node = ( Node * ) current_list -> node ; if ( node == NULL ) break ; <S2SV_StartBug> snprintf ( bufPoint , buffer_length , "(%s)," , eval ( current_node ) ) ; <S2SV_EndBug> <S2SV_StartBug> bufPoint = bufPoint + strlen ( buffer ) ; <S2SV_EndBug> } while ( ( current_list = current_list -> next ) != NULL ) ; return buffer ; } | <S2SV_ModStart> return buffer ; <S2SV_ModEnd> do { Node <S2SV_ModStart> ) break ; strcat ( buffer , "(" ) ; strcat ( buffer <S2SV_ModEnd> , eval ( <S2SV_ModStart> ) ) ; strcat ( buffer , ")," <S2SV_ModEnd> ) ; } |
576 | CWE-000 int main ( ) { int size_of_int = sizeof ( int ) ; int size_of_long_long_int = sizeof ( long long int ) ; int size_of_float = sizeof ( float ) ; int size_of_double = sizeof ( double ) ; printf ( "sizeof<S2SV_blank>int<S2SV_blank>is<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>\\n" , size_of_int ) ; <S2SV_StartBug> printf ( "sizeof<S2SV_blank>int<S2SV_blank>is<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>\\n" , size_of_long_long_int ) ; <S2SV_EndBug> <S2SV_StartBug> printf ( "sizeof<S2SV_blank>int<S2SV_blank>is<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>\\n" , size_of_float ) ; <S2SV_EndBug> <S2SV_StartBug> printf ( "sizeof<S2SV_blank>int<S2SV_blank>is<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>\\n" , size_of_double ) ; <S2SV_EndBug> } | <S2SV_ModStart> ; printf ( "sizeof<S2SV_blank>long<S2SV_blank>long<S2SV_blank>int<S2SV_blank>is<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>\\n" <S2SV_ModEnd> , size_of_long_long_int ) <S2SV_ModStart> ; printf ( "sizeof<S2SV_blank>float<S2SV_blank>is<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>\\n" <S2SV_ModEnd> , size_of_float ) <S2SV_ModStart> ; printf ( "sizeof<S2SV_blank>double<S2SV_blank>is<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>\\n" <S2SV_ModEnd> , size_of_double ) |
577 | CWE-000 void stm32_clock_init ( void ) { # if ! STM32_NO_INIT RCC -> APB1ENR = RCC_APB1ENR_PWREN ; # if defined ( STM32F4XX ) || defined ( __DOXYGEN__ ) PWR -> CR = STM32_VOS ; # else PWR -> CR = 0 ; # endif RCC -> CR |= RCC_CR_HSION ; while ( ! ( RCC -> CR & RCC_CR_HSIRDY ) ) ; RCC -> CFGR &= ~ RCC_CFGR_SW ; RCC -> CFGR |= RCC_CFGR_SWS_HSI ; while ( ( RCC -> CFGR & RCC_CFGR_SWS ) != RCC_CFGR_SWS_HSI ) ; RCC -> CR &= RCC_CR_HSITRIM | RCC_CR_HSION ; RCC -> CFGR = 0 ; # if STM32_HSE_ENABLED # if defined ( STM32_HSE_BYPASS ) RCC -> CR |= RCC_CR_HSEON | RCC_CR_HSEBYP ; # else RCC -> CR |= RCC_CR_HSEON ; # endif while ( ( RCC -> CR & RCC_CR_HSERDY ) == 0 ) ; # endif # if STM32_LSI_ENABLED RCC -> CSR |= RCC_CSR_LSION ; while ( ( RCC -> CSR & RCC_CSR_LSIRDY ) == 0 ) ; # endif # if STM32_ACTIVATE_PLL RCC -> PLLCFGR = STM32_PLLQ | STM32_PLLSRC | STM32_PLLP | STM32_PLLN | STM32_PLLM ; RCC -> CR |= RCC_CR_PLLON ; # if defined ( STM32F4XX ) while ( ( PWR -> CSR & PWR_CSR_VOSRDY ) == 0 ) ; # if STM32_OVERDRIVE_REQUIRED PWR -> CR |= PWR_CR_ODEN ; while ( ! ( PWR -> CSR & PWR_CSR_ODRDY ) ) ; PWR -> CR |= PWR_CR_ODSWEN ; while ( ! ( PWR -> CSR & PWR_CSR_ODSWRDY ) ) ; # endif # endif while ( ! ( RCC -> CR & RCC_CR_PLLRDY ) ) ; # endif # if STM32_ACTIVATE_PLLI2S RCC -> PLLI2SCFGR = STM32_PLLI2SR | STM32_PLLI2SN ; RCC -> CR |= RCC_CR_PLLI2SON ; while ( ! ( RCC -> CR & RCC_CR_PLLI2SRDY ) ) ; # endif # if STM32_ACTIVATE_PLLSAI RCC -> PLLSAICFGR = STM32_PLLSAIN | STM32_PLLSAIR | STM32_PLLSAIQ ; <S2SV_StartBug> RCC -> DCKCFGR = ( RCC -> DCKCFGR & ~ RCC_DCKCFGR_PLLSAIDIVR ) | STM32_PLLSAIR_POST ; <S2SV_EndBug> RCC -> CR |= RCC_CR_PLLSAION ; while ( ! ( RCC -> CR & RCC_CR_PLLSAIRDY ) ) ; # endif RCC -> CFGR = STM32_MCO2PRE | STM32_MCO2SEL | STM32_MCO1PRE | STM32_MCO1SEL | STM32_I2SSRC | STM32_RTCPRE | STM32_PPRE2 | STM32_PPRE1 | STM32_HPRE ; # if defined ( STM32_USE_REVISION_A_FIX ) if ( ( DBGMCU -> IDCODE == 0x20006411 ) && ( SCB -> CPUID == 0x410FC241 ) ) FLASH -> ACR = FLASH_ACR_PRFTEN | STM32_FLASHBITS ; else FLASH -> ACR = FLASH_ACR_PRFTEN | FLASH_ACR_ICEN | FLASH_ACR_DCEN | STM32_FLASHBITS ; # else FLASH -> ACR = FLASH_ACR_PRFTEN | FLASH_ACR_ICEN | FLASH_ACR_DCEN | STM32_FLASHBITS ; # endif # if ( STM32_SW != STM32_SW_HSI ) RCC -> CFGR |= STM32_SW ; while ( ( RCC -> CFGR & RCC_CFGR_SWS ) != ( STM32_SW << 2 ) ) ; # endif # endif rccEnableAPB2 ( RCC_APB2ENR_SYSCFGEN , TRUE ) ; } | <S2SV_ModStart> ; RCC -> <S2SV_ModEnd> CR |= RCC_CR_PLLSAION |
578 | CWE-000 <S2SV_StartBug> void send_Pressure_to_phone ( float f ) <S2SV_EndBug> { uint8_t t = 0xFF ; mySerial_send_single_byte ( & t ) ; mySerial_send_single_byte ( & t ) ; mySerial_send_single_byte ( & t ) ; mySerial_send_single_byte ( & t ) ; t = 0x03 ; mySerial_send_single_byte ( & t ) ; <S2SV_StartBug> mySerial_send_float ( f ) ; <S2SV_EndBug> } | <S2SV_ModStart> send_Pressure_to_phone ( float * fptr <S2SV_ModEnd> ) { uint8_t <S2SV_ModStart> ; mySerial_send_float ( fptr <S2SV_ModEnd> ) ; } |
579 | CWE-000 static void ixv_setup_vlan_support ( if_ctx_t ctx ) { <S2SV_StartBug> struct adapter * adapter = iflib_get_softc ( ctx ) ; <S2SV_EndBug> struct ixgbe_hw * hw = & adapter -> hw ; u32 ctrl , vid , vfta , retry ; if ( adapter -> num_vlans == 0 ) return ; <S2SV_StartBug> for ( int i = 0 ; i < adapter -> num_rx_queues ; i ++ ) { <S2SV_EndBug> ctrl = IXGBE_READ_REG ( hw , IXGBE_VFRXDCTL ( i ) ) ; ctrl |= IXGBE_RXDCTL_VME ; IXGBE_WRITE_REG ( hw , IXGBE_VFRXDCTL ( i ) , ctrl ) ; adapter -> rx_queues [ i ] . rxr . vtag_strip = TRUE ; <S2SV_StartBug> } <S2SV_EndBug> for ( int i = 0 ; i < IXGBE_VFTA_SIZE ; i ++ ) { if ( ixv_shadow_vfta [ i ] == 0 ) continue ; vfta = ixv_shadow_vfta [ i ] ; for ( int j = 0 ; j < 32 ; j ++ ) { retry = 0 ; if ( ( vfta & ( 1 << j ) ) == 0 ) continue ; vid = ( i * 32 ) + j ; while ( hw -> mac . ops . set_vfta ( hw , vid , 0 , TRUE , FALSE ) ) { if ( ++ retry > 5 ) break ; } } } } | <S2SV_ModStart> ) { struct ifnet * ifp = iflib_get_ifp ( ctx ) ; struct <S2SV_ModStart> ) return ; if ( ifp -> if_capenable & IFCAP_VLAN_HWTAGGING ) { <S2SV_ModStart> TRUE ; } } if ( ( ifp -> if_capenable & IFCAP_VLAN_HWFILTER ) == 0 ) return ; |
580 | CWE-000 int16_t rf69_sampleRssi ( void ) { int16_t lastRssi ; if ( _mode != RFM69_MODE_RX ) <S2SV_StartBug> { <S2SV_EndBug> return 0 ; <S2SV_StartBug> } <S2SV_EndBug> rf69_spiWrite ( RFM69_REG_23_RSSI_CONFIG , RF_RSSI_START ) ; <S2SV_StartBug> while ( ! ( RF_RSSI_DONE && rf69_spiRead ( RFM69_REG_23_RSSI_CONFIG ) ) ) { } ; <S2SV_EndBug> lastRssi = - ( rf69_spiRead ( RFM69_REG_24_RSSI_VALUE ) / 2 ) ; return lastRssi ; } | <S2SV_ModStart> != RFM69_MODE_RX ) <S2SV_ModEnd> return 0 ; <S2SV_ModStart> return 0 ; <S2SV_ModEnd> rf69_spiWrite ( RFM69_REG_23_RSSI_CONFIG <S2SV_ModStart> ) ) ) <S2SV_ModEnd> ; lastRssi = |
581 | CWE-000 GArray * <S2SV_StartBug> gb_beautifier_config_get_entries ( GbBeautifierEditorAddin * self ) <S2SV_EndBug> { IdeContext * context ; IdeVcs * vcs ; GArray * entries ; GArray * map = NULL ; g_autofree gchar * project_config_path = NULL ; g_autofree gchar * user_config_path = NULL ; const gchar * datadir ; g_autofree gchar * configdir = NULL ; <S2SV_StartBug> g_assert ( GB_IS_BEAUTIFIER_EDITOR_ADDIN ( self ) ) ; <S2SV_EndBug> entries = g_array_new ( TRUE , TRUE , sizeof ( GbBeautifierConfigEntry ) ) ; g_array_set_clear_func ( entries , config_entry_clear_func ) ; user_config_path = g_build_filename ( g_get_user_config_dir ( ) , ide_get_program_name ( ) , "beautifier_plugin" , NULL ) ; map = gb_beautifier_config_get_map ( self , user_config_path ) ; <S2SV_StartBug> add_entries_from_base_path ( self , user_config_path , entries , map ) ; <S2SV_EndBug> if ( map != NULL ) g_array_free ( map , TRUE ) ; if ( NULL != ( context = self -> context ) && NULL != ( vcs = ide_context_get_vcs ( context ) ) ) { GFile * workdir ; g_autofree gchar * workdir_path = NULL ; workdir = ide_vcs_get_working_directory ( vcs ) ; workdir_path = g_file_get_path ( workdir ) ; project_config_path = g_build_filename ( workdir_path , ".beautifier" , NULL ) ; map = gb_beautifier_config_get_map ( self , project_config_path ) ; <S2SV_StartBug> add_entries_from_base_path ( self , project_config_path , entries , map ) ; <S2SV_EndBug> if ( map != NULL ) g_array_free ( map , TRUE ) ; } if ( NULL != ( datadir = get_datadir ( ) ) ) { configdir = g_build_filename ( datadir , "data" , NULL ) ; map = gb_beautifier_config_get_map ( self , configdir ) ; <S2SV_StartBug> add_entries_from_base_path ( self , configdir , entries , map ) ; <S2SV_EndBug> if ( map != NULL ) g_array_free ( map , TRUE ) ; } return entries ; } | <S2SV_ModStart> GbBeautifierEditorAddin * self , gboolean * has_default <S2SV_ModStart> = NULL ; gboolean ret_has_default ; <S2SV_ModStart> entries , map , & ret_has_default ) ; * has_default |= ret_has_default <S2SV_ModEnd> ; if ( <S2SV_ModStart> entries , map , & ret_has_default ) ; * has_default |= ret_has_default <S2SV_ModEnd> ; if ( <S2SV_ModStart> entries , map , & ret_has_default ) ; * has_default |= ret_has_default <S2SV_ModEnd> ; if ( |
582 | CWE-000 int main ( int argc , char * * argv ) { bool daemonize = false ; long count = - 1 ; int option ; char * udphostport [ MAX_UDP_DEST ] ; flags = WATCH_ENABLE ; while ( ( option = getopt ( argc , argv , "?habnjvc:l:u:d:" ) ) != - 1 ) { switch ( option ) { case 'd' : debug = atoi ( optarg ) ; if ( ( debug < 1 ) || ( debug > 2 ) ) { usage ( ) ; exit ( 1 ) ; } break ; case 'n' : if ( debug > 0 ) ( void ) fprintf ( stdout , "NMEA<S2SV_blank>selected\\n" ) ; flags |= WATCH_NMEA ; break ; case 'j' : if ( debug > 0 ) ( void ) fprintf ( stdout , "JSON<S2SV_blank>selected\\n" ) ; flags |= WATCH_JSON ; break ; case 'a' : aisonly = true ; break ; case 'c' : count = atol ( optarg ) ; break ; case 'b' : daemonize = true ; break ; case 'u' : if ( udpchannel >= MAX_UDP_DEST ) { ( void ) fprintf ( stderr , "gps2udp:<S2SV_blank>too<S2SV_blank>many<S2SV_blank>UDP<S2SV_blank>destinations<S2SV_blank>(max=%d)\\n" , MAX_UDP_DEST ) ; } else { udphostport [ udpchannel ++ ] = optarg ; } break ; case 'v' : ( void ) fprintf ( stderr , "%s:<S2SV_blank>%s<S2SV_blank>(revision<S2SV_blank>%s)\\n" , argv [ 0 ] , VERSION , REVISION ) ; exit ( 0 ) ; case '?' : case 'h' : default : usage ( ) ; exit ( 1 ) ; } } if ( optind < argc ) gpsd_source_spec ( argv [ optind ] , & gpsd_source ) ; else gpsd_source_spec ( NULL , & gpsd_source ) ; if ( gpsd_source . device != NULL ) flags |= WATCH_DEVICE ; connect2gpsd ( false ) ; if ( udpchannel > 0 ) { int status = open_udp ( udphostport ) ; if ( status != 0 ) exit ( 1 ) ; } if ( daemonize ) { if ( os_daemon ( 0 , 0 ) != 0 ) { ( void ) fprintf ( stderr , <S2SV_StartBug> "gps2udp:<S2SV_blank>demonization<S2SV_blank>failed:<S2SV_blank>%s\\n" , <S2SV_EndBug> strerror ( errno ) ) ; } } for ( ; ; ) { char buffer [ 512 ] ; ssize_t len ; len = read_gpsd ( buffer , sizeof ( buffer ) ) ; if ( len > 3 ) { if ( debug > 0 ) { ( void ) fprintf ( stdout , "---><S2SV_blank>[%s]<S2SV_blank>--<S2SV_blank>%s" , time2string ( ) , buffer ) ; if ( str_starts_with ( buffer , "!AIVDM" ) ) { # define MAX_INFO 6 int i , j ; unsigned char packet [ 512 ] ; unsigned char * adrpkt = packet ; unsigned char * info [ MAX_INFO ] ; unsigned int mmsi ; unsigned char bitstrings [ 255 ] ; ( void ) strlcpy ( ( char * ) packet , buffer , sizeof ( packet ) ) ; for ( j = 0 ; j < MAX_INFO ; j ++ ) { info [ j ] = ( unsigned char * ) strsep ( ( char * * ) & adrpkt , "," ) ; } for ( i = 0 ; i < ( int ) strlen ( ( char * ) info [ 5 ] ) ; i ++ ) { if ( i > ( int ) sizeof ( bitstrings ) ) break ; bitstrings [ i ] = AISto6bit ( info [ 5 ] [ i ] ) ; } mmsi = AISGetInt ( bitstrings , 9 , 30 ) ; ( void ) fprintf ( stdout , "<S2SV_blank>MMSI=%9u" , mmsi ) ; } ( void ) fprintf ( stdout , "\\n" ) ; } if ( udpchannel > 0 ) ( void ) send_udp ( buffer , ( size_t ) len ) ; if ( count >= 0 ) { if ( count -- == 0 ) { ( void ) fprintf ( stderr , "gpsd2udp:<S2SV_blank>normal<S2SV_blank>exit<S2SV_blank>after<S2SV_blank>counted<S2SV_blank>packets\\n" ) ; exit ( 0 ) ; } } } } ( void ) fprintf ( stderr , "gpsd2udp<S2SV_blank>ERROR<S2SV_blank>abnormal<S2SV_blank>exit\\n" ) ; exit ( - 1 ) ; } | <S2SV_ModStart> ( stderr , "gps2udp:<S2SV_blank>daemonization<S2SV_blank>failed:<S2SV_blank>%s\\n" <S2SV_ModEnd> , strerror ( |
583 | CWE-000 int main ( ) { int i , namedFifo , fd ; pid_t pid , sid ; fd_set active_fdset , read_fdset ; char portBuf [ PORT_DIGIT_MAX + 1 ] , readBuf [ PATH_MAX + 1 ] ; reservation resList [ NUM_PORTS ] ; list_node * udsList ; res * r ; pid = fork ( ) ; if ( pid < 0 ) { perror ( "fork<S2SV_blank>failed" ) ; syslog ( LOG_MAKEPRI ( LOG_DAEMON , LOG_CRIT ) , "Unable<S2SV_blank>to<S2SV_blank>fork<S2SV_blank>daemon<S2SV_blank>child<S2SV_blank>process" ) ; exit ( EXIT_FAILURE ) ; } if ( pid > 0 ) { exit ( EXIT_SUCCESS ) ; } umask ( 0 ) ; openlog ( "sprd" , 0 , LOG_DAEMON ) ; sid = setsid ( ) ; if ( sid < 0 ) { syslog ( LOG_CRIT , "Unable<S2SV_blank>to<S2SV_blank>run<S2SV_blank>daemon<S2SV_blank>child<S2SV_blank>process<S2SV_blank>in<S2SV_blank>a<S2SV_blank>new<S2SV_blank>session" ) ; exit ( EXIT_FAILURE ) ; } if ( chdir ( "/" ) < 0 ) { syslog ( LOG_CRIT , "Unable<S2SV_blank>to<S2SV_blank>change<S2SV_blank>daemon<S2SV_blank>process\'s<S2SV_blank>current<S2SV_blank>working<S2SV_blank>directory<S2SV_blank>to<S2SV_blank>\'/\'" ) ; exit ( EXIT_FAILURE ) ; } FD_ZERO ( & active_fdset ) ; close ( STDIN_FILENO ) ; close ( STDOUT_FILENO ) ; close ( STDERR_FILENO ) ; r = parse_config ( "/home/smithdo/CS493/secure-port-reservation/sprd.conf" ) ; memset ( & resList , 0 , sizeof ( resList ) ) ; struct sockaddr_in sockInfo ; while ( r != NULL ) { range_node * ports = r -> port_head ; while ( ports != NULL ) { int portNum = ports -> range [ 0 ] ; if ( portNum > LOWER_PORT_LIMIT && portNum < NUM_PORTS ) { memset ( & sockInfo , 0 , sizeof ( sockInfo ) ) ; sockInfo . sin_family = AF_INET ; sockInfo . sin_port = htons ( portNum ) ; if ( ( fd = socket ( AF_INET , SOCK_STREAM , 0 ) ) < 0 ) { syslog ( LOG_ALERT , "Unable<S2SV_blank>to<S2SV_blank>acquire<S2SV_blank>a<S2SV_blank>file<S2SV_blank>descriptor<S2SV_blank>for<S2SV_blank>port<S2SV_blank>%d" , portNum ) ; syslog ( LOG_ALERT , "Unable<S2SV_blank>to<S2SV_blank>reserve<S2SV_blank>port<S2SV_blank>%d" , portNum ) ; } else if ( bind ( fd , ( struct sockaddr * ) & sockInfo , sizeof ( sockInfo ) ) < 0 ) { syslog ( LOG_ALERT , "Unable<S2SV_blank>to<S2SV_blank>reserve<S2SV_blank>port<S2SV_blank>%d" , portNum ) ; } else { resList [ portNum ] . fd = fd ; resList [ portNum ] . uid_head = r -> uid_head ; resList [ portNum ] . gid_head = r -> gid_head ; } } else { syslog ( LOG_WARNING , "Invalid<S2SV_blank>port<S2SV_blank>number:<S2SV_blank>%d" , portNum ) ; } for ( i = portNum + 1 ; i <= ports -> range [ 1 ] ; i ++ ) { portNum = i ; if ( portNum > LOWER_PORT_LIMIT && portNum < NUM_PORTS ) { memset ( & sockInfo , 0 , sizeof ( sockInfo ) ) ; sockInfo . sin_family = AF_INET ; sockInfo . sin_port = htons ( portNum ) ; if ( ( fd = socket ( AF_INET , SOCK_STREAM , 0 ) ) < 0 ) { syslog ( LOG_ALERT , "Unable<S2SV_blank>to<S2SV_blank>acquire<S2SV_blank>a<S2SV_blank>file<S2SV_blank>descriptor<S2SV_blank>for<S2SV_blank>port<S2SV_blank>%d" , portNum ) ; syslog ( LOG_ALERT , "Unable<S2SV_blank>to<S2SV_blank>reserve<S2SV_blank>port<S2SV_blank>%d" , portNum ) ; } else if ( bind ( fd , ( struct sockaddr * ) & sockInfo , sizeof ( sockInfo ) ) < 0 ) { syslog ( LOG_ALERT , "Unable<S2SV_blank>to<S2SV_blank>reserve<S2SV_blank>port<S2SV_blank>%d" , portNum ) ; } else { resList [ portNum ] . fd = fd ; resList [ portNum ] . uid_head = r -> uid_head ; resList [ portNum ] . gid_head = r -> gid_head ; } } else { syslog ( LOG_WARNING , "Invalid<S2SV_blank>port<S2SV_blank>number:<S2SV_blank>%d" , portNum ) ; } } ports = ports -> next ; } r = r -> next ; } if ( unlink ( NAMED_FIFO ) < 0 ) { if ( errno != ENOENT ) { syslog ( LOG_NOTICE , "Unable<S2SV_blank>to<S2SV_blank>unlink<S2SV_blank>the<S2SV_blank>named<S2SV_blank>fifo<S2SV_blank>\'%s\'" , NAMED_FIFO ) ; } } udsList = make_linked_list ( ) ; if ( ( mkfifo ( NAMED_FIFO , S_IRUSR | S_IWUSR | S_IWGRP | S_IWOTH ) ) < 0 ) { syslog ( LOG_CRIT , "Failed<S2SV_blank>to<S2SV_blank>make<S2SV_blank>the<S2SV_blank>named<S2SV_blank>fifo<S2SV_blank>\'%s\'" , NAMED_FIFO ) ; exit ( EXIT_FAILURE ) ; } if ( ( namedFifo = open ( NAMED_FIFO , O_RDWR | O_NOCTTY | O_NONBLOCK ) ) < 0 ) { syslog ( LOG_CRIT , "Failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>named<S2SV_blank>fifo<S2SV_blank>\'%s\'" , NAMED_FIFO ) ; exit ( EXIT_FAILURE ) ; } FD_SET ( namedFifo , & active_fdset ) ; while ( 1 ) { read_fdset = active_fdset ; if ( ( select ( FD_SETSIZE , & read_fdset , NULL , NULL , NULL ) ) > 0 ) { for ( i = 0 ; i < FD_SETSIZE ; i ++ ) { if ( FD_ISSET ( i , & read_fdset ) ) { if ( i == namedFifo ) { memset ( readBuf , 0 , sizeof ( readBuf ) ) ; if ( ( read ( namedFifo , readBuf , PATH_MAX ) ) == 0 ) { syslog ( LOG_NOTICE , "No<S2SV_blank>data<S2SV_blank>read<S2SV_blank>from<S2SV_blank>named<S2SV_blank>FIFO" ) ; } else if ( strlen ( readBuf ) != 0 ) { handleNewConnection ( namedFifo , readBuf , & active_fdset ) ; } } else { memset ( portBuf , 0 , sizeof ( portBuf ) ) ; if ( ( recv ( i , portBuf , PORT_DIGIT_MAX , MSG_PEEK ) ) < 0 ) { syslog ( LOG_ERR , "Failed<S2SV_blank>to<S2SV_blank>recieve<S2SV_blank>data<S2SV_blank>from<S2SV_blank>file<S2SV_blank>descriptor<S2SV_blank>%d" , i ) ; break ; } else if ( strlen ( portBuf ) == 0 ) { <S2SV_StartBug> setFree ( i , udsList , resList ) ; <S2SV_EndBug> if ( close ( i ) < 0 ) { syslog ( LOG_CRIT , "Failed<S2SV_blank>to<S2SV_blank>close<S2SV_blank>the<S2SV_blank>file<S2SV_blank>descriptor<S2SV_blank>%d" , i ) ; } FD_CLR ( i , & active_fdset ) ; } else { if ( ( handleExistingConnection ( i , portBuf , udsList , resList ) ) < 0 ) { FD_CLR ( i , & active_fdset ) ; if ( ( close ( i ) ) < 0 ) { syslog ( LOG_CRIT , "Failed<S2SV_blank>to<S2SV_blank>shut<S2SV_blank>down<S2SV_blank>the<S2SV_blank>file<S2SV_blank>descriptor<S2SV_blank>%d" , i ) ; } } } } } } } else { syslog ( LOG_INFO , "Failed<S2SV_blank>to<S2SV_blank>select<S2SV_blank>a<S2SV_blank>file<S2SV_blank>descriptor<S2SV_blank>from<S2SV_blank>the<S2SV_blank>read_fdset" ) ; } } } | <S2SV_ModStart> 0 ) { if ( ( recv ( i , portBuf , PORT_DIGIT_MAX , 0 ) ) ) { syslog ( LOG_NOTICE , "Failed<S2SV_blank>to<S2SV_blank>clear<S2SV_blank>TCP<S2SV_blank>buffer<S2SV_blank>after<S2SV_blank>closed<S2SV_blank>uds<S2SV_blank>%d" , i ) ; } |
584 | CWE-000 static void begin_entry ( int esym ) { int tmp ; exp_header ( esym ) ; if ( esym == 0 && gbl . multiversion > 1 ) setfile ( 1 , SYMNAME ( gbl . currsub ) , ilmb . globalilmstart ) ; if ( ! gbl . outlined && ! ISTASKDUPG ( GBL_CURRFUNC ) ) ccff_open_unit ( ) ; if ( esym == 0 ) entry_sptr = gbl . currsub ; else entry_sptr = esym ; if ( gbl . vfrets ) { if ( esym == 0 ) { tmp = getccsym ( 'Q' , expb . gentmps ++ , ST_VAR ) ; SCP ( tmp , SC_STATIC ) ; DTYPEP ( tmp , DT_DCMPLX ) ; vf_addr = mk_address ( tmp ) ; } tmp = ad1ili ( IL_FPSAVE , vf_addr ) ; chk_block ( tmp ) ; } if ( gbl . arets && esym == 0 ) { expb . aret_tmp = getccsym ( 'Q' , expb . gentmps ++ , ST_VAR ) ; SCP ( expb . aret_tmp , SC_AUTO ) ; DTYPEP ( expb . aret_tmp , DT_INT ) ; } if ( gbl . denorm ) { int addr , mask ; int sym , arg ; if ( esym == 0 ) { expb . mxcsr_tmp = getccsym ( 'Q' , expb . gentmps ++ , ST_VAR ) ; SCP ( expb . mxcsr_tmp , SC_AUTO ) ; DTYPEP ( expb . mxcsr_tmp , DT_INT ) ; ADDRTKNP ( expb . mxcsr_tmp , 1 ) ; } <S2SV_StartBug> mask = ad_icon ( 0xffff7fbf ) ; <S2SV_EndBug> addr = ad_acon ( expb . mxcsr_tmp , 0 ) ; <S2SV_StartBug> sym = mkfunc ( "__pgi_mask_mxcsr" ) ; <S2SV_EndBug> arg = ad1ili ( IL_NULL , 0 ) ; # if defined ( TARGET_X8664 ) arg = ad3ili ( IL_DAIR , mask , ARG_IR ( 0 ) , arg ) ; arg = ad3ili ( IL_DAAR , addr , ARG_IR ( 1 ) , arg ) ; # else arg = ad3ili ( IL_ARGAR , addr , arg , 0 ) ; arg = ad2ili ( IL_ARGIR , mask , arg ) ; # endif tmp = ad2ili ( IL_JSR , sym , arg ) ; iltb . callfg = 1 ; chk_block ( tmp ) ; } } | <S2SV_ModStart> ) ; } # if defined ( TARGET_ARM64 ) <S2SV_ModStart> = ad_icon ( 0x0 ) ; addr = ad_acon ( expb . mxcsr_tmp , 0 ) ; sym = mkfunc ( "__fenv_mask_fz" ) ; # else mask = ad_icon ( <S2SV_ModStart> = mkfunc ( "__fenv_mask_mxcsr" ) ; # endif <S2SV_ModEnd> arg = ad1ili |
585 | CWE-000 int pllua_resume_function ( lua_State * L ) { pllua_activation_record * act = lua_touserdata ( L , 1 ) ; FunctionCallInfo fcinfo = act -> fcinfo ; ReturnSetInfo * rsi = ( ReturnSetInfo * ) fcinfo -> resultinfo ; pllua_func_activation * fact = fcinfo -> flinfo -> fn_extra ; lua_State * thr = fact -> thread ; int rc ; Assert ( thr != NULL ) ; Assert ( lua_gettop ( L ) == 1 ) ; <S2SV_StartBug> rc = lua_resume ( thr , L , 0 ) ; <S2SV_EndBug> if ( rc == LUA_OK ) { lua_xmove ( thr , L , lua_gettop ( thr ) ) ; pllua_deactivate_thread ( L , fact , rsi -> econtext ) ; rsi -> isDone = ExprEndResult ; act -> retval = ( Datum ) 0 ; fcinfo -> isnull = true ; return 0 ; } else if ( rc == LUA_YIELD ) { lua_xmove ( thr , L , lua_gettop ( thr ) ) ; rsi -> isDone = ExprMultipleResult ; } else { lua_xmove ( thr , L , 1 ) ; pllua_deactivate_thread ( L , fact , rsi -> econtext ) ; pllua_rethrow_from_lua ( L , rc ) ; } act -> retval = pllua_return_result ( L , lua_gettop ( L ) - 1 , fact , & fcinfo -> isnull ) ; return 0 ; } | <S2SV_ModStart> 1 ) ; fact -> onstack = true ; <S2SV_ModStart> , 0 ) ; fact -> onstack = false |
586 | CWE-000 void ia32_setregs ( struct thread * td , struct image_params * imgp , u_long stack ) { <S2SV_StartBug> struct trapframe * regs = td -> td_frame ; <S2SV_EndBug> struct pcb * pcb = td -> td_pcb ; <S2SV_StartBug> mtx_lock ( & dt_lock ) ; <S2SV_EndBug> if ( td -> td_proc -> p_md . md_ldt != NULL ) user_ldt_free ( td ) ; else mtx_unlock ( & dt_lock ) ; # ifdef COMPAT_43 setup_lcall_gate ( ) ; # endif pcb -> pcb_fsbase = 0 ; pcb -> pcb_gsbase = 0 ; pcb -> pcb_initial_fpucw = __INITIAL_FPUCW_I386__ ; <S2SV_StartBug> bzero ( ( char * ) regs , sizeof ( struct trapframe ) ) ; <S2SV_EndBug> regs -> tf_rip = imgp -> entry_addr ; regs -> tf_rsp = stack ; <S2SV_StartBug> regs -> tf_rflags = PSL_USER | ( regs -> tf_rflags & PSL_T ) ; <S2SV_EndBug> regs -> tf_ss = _udatasel ; regs -> tf_cs = _ucode32sel ; regs -> tf_rbx = imgp -> ps_strings ; regs -> tf_ds = _udatasel ; regs -> tf_es = _udatasel ; regs -> tf_fs = _ufssel ; regs -> tf_gs = _ugssel ; regs -> tf_flags = TF_HASSEGS ; fpstate_drop ( td ) ; set_pcb_flags ( pcb , PCB_32BIT | PCB_FULL_IRET ) ; td -> td_retval [ 1 ] = 0 ; } | <S2SV_ModStart> trapframe * regs ; struct pcb * pcb ; register_t saved_rflags <S2SV_ModEnd> ; mtx_lock ( <S2SV_ModStart> & dt_lock ) ; regs = td -> td_frame ; pcb = td -> td_pcb <S2SV_ModStart> = __INITIAL_FPUCW_I386__ ; saved_rflags = <S2SV_ModEnd> regs -> tf_rflags <S2SV_ModStart> tf_rflags & PSL_T ; bzero ( ( char * ) regs , sizeof ( struct trapframe ) ) ; regs -> tf_rip = imgp -> entry_addr ; regs -> tf_rsp = stack ; regs -> tf_rflags = PSL_USER | saved_rflags <S2SV_ModEnd> ; regs -> |
587 | CWE-000 struct scm_fp_list * scm_fp_dup ( struct scm_fp_list * fpl ) { struct scm_fp_list * new_fpl ; int i ; if ( ! fpl ) return NULL ; new_fpl = kmemdup ( fpl , offsetof ( struct scm_fp_list , fp [ fpl -> count ] ) , GFP_KERNEL ) ; if ( new_fpl ) { for ( i = 0 ; i < fpl -> count ; i ++ ) get_file ( fpl -> fp [ i ] ) ; new_fpl -> max = new_fpl -> count ; <S2SV_StartBug> } <S2SV_EndBug> return new_fpl ; } | <S2SV_ModStart> -> count ; new_fpl -> user = get_uid ( fpl -> user ) ; |
588 | CWE-000 int mod_pmon_xml ( ipm_mod_t * mod , void * ptr , struct region * reg ) { int res = 0 ; double hz = 0 ; double version = 0 ; double startup = 0 ; <S2SV_StartBug> parse_pm_counter ( "/sys/cray/pm_counters/raw_scan_hz" , & hz ) ; <S2SV_EndBug> parse_pm_counter ( "/sys/cray/pm_counters/version" , & version ) ; parse_pm_counter ( "/sys/cray/pm_counters/startup" , & startup ) ; <S2SV_StartBug> res += ipm_printf ( ptr , "<module<S2SV_blank>name=\\"%s\\"<S2SV_blank>scan_hz=\\"%lf\\"<S2SV_blank>version=\\"%lf\\"\\\n<S2SV_blank><S2SV_blank>startup=\\"%lf\\">\\n" , "PMON" , hz , version , startup ) ; <S2SV_EndBug> return res ; } | <S2SV_ModStart> = 0 ; double time = 0 ; if ( reg ) time = pmondata [ reg -> id ] . mtime ; <S2SV_ModStart> ( ptr , "<module<S2SV_blank>name=\\"%s\\"<S2SV_blank>time=\\"%lf\\"<S2SV_blank>scan_hz=\\"%lf\\"<S2SV_blank>version=\\"%lf\\"\\\n<S2SV_blank>startup=\\"%lf\\"></module>\\n" , "PMON" , time <S2SV_ModEnd> , hz , |
589 | CWE-000 static vo_context_t * alloc_vo_context ( vo_wrapper_t * wrapper ) { vo_context_t * voc = ( vo_context_t * ) malloc ( sizeof ( vo_context_t ) ) ; if ( ! voc ) { return NULL ; <S2SV_StartBug> } <S2SV_EndBug> if ( wrapper -> private_data_size > 0 ) { voc -> private_data = malloc ( wrapper -> private_data_size ) ; if ( ! voc -> private_data ) { free ( voc ) ; return NULL ; } <S2SV_StartBug> } <S2SV_EndBug> voc -> wrapper = wrapper ; return voc ; } | <S2SV_ModStart> NULL ; } memset ( voc , 0 , sizeof ( vo_context_t ) ) ; <S2SV_ModStart> NULL ; } memset ( voc -> private_data , 0 , sizeof ( wrapper -> private_data_size ) ) ; |
590 | CWE-000 void hl_print_next ( t_dlist * list , void ( * print ) ( ) ) { while ( list ) { print ( list ) ; list = list -> next ; } <S2SV_StartBug> printf ( "\\n" ) ; <S2SV_EndBug> } | <S2SV_ModStart> next ; } ft_printf <S2SV_ModEnd> ( "\\n" ) |
591 | CWE-000 void LoadConfiguration ( ) { <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ( ) { Renderer_AddResource ( PATH_TO_ZOMBIE_IMG , ZOMBIE_CLASS ) ; Renderer_AddResource ( PATH_TO_HUMAN_IMG , HUMAN_CLASS ) ; Renderer_AddResource ( PATH_TO_DEFAULT_TILE_IMG , "tile" ) ; |
592 | CWE-000 <S2SV_StartBug> void bn_muld_low ( dig_t * c , dig_t * a , int sizea , dig_t * b , int sizeb , <S2SV_EndBug> int low , int high ) { ( void ) low ; ( void ) high ; mpn_mul ( c , a , sizea , b , sizeb ) ; } | <S2SV_ModStart> * c , const <S2SV_ModStart> int sizea , const |
593 | CWE-000 <S2SV_StartBug> void fp_prime_clean ( ) { <S2SV_EndBug> ctx_t * ctx = core_get ( ) ; ctx -> fp_id = 0 ; # if FP_RDC == QUICK || ! defined ( STRIP ) ctx -> sps_len = 0 ; memset ( ctx -> sps , 0 , sizeof ( ctx -> sps ) ) ; # endif # if FP_RDC == MONTY || ! defined ( STRIP ) bn_clean ( & ( ctx -> one ) ) ; bn_clean ( & ( ctx -> conv ) ) ; # endif bn_clean ( & ( ctx -> prime ) ) ; } | <S2SV_ModStart> void fp_prime_clean ( void |
594 | CWE-000 errno_t allocateSpace ( Data * object ) { switch ( object -> type ) { case INT8_DATA : object -> data_arrays . i8_data = mxMalloc ( object -> num_elems * object -> elem_size ) ; break ; case UINT8_DATA : object -> data_arrays . ui8_data = mxMalloc ( object -> num_elems * object -> elem_size ) ; break ; case INT16_DATA : object -> data_arrays . i16_data = mxMalloc ( object -> num_elems * object -> elem_size ) ; break ; case UINT16_DATA : object -> data_arrays . ui16_data = mxMalloc ( object -> num_elems * object -> elem_size ) ; break ; case INT32_DATA : object -> data_arrays . i32_data = mxMalloc ( object -> num_elems * object -> elem_size ) ; break ; case UINT32_DATA : object -> data_arrays . ui32_data = mxMalloc ( object -> num_elems * object -> elem_size ) ; break ; case INT64_DATA : object -> data_arrays . i64_data = mxMalloc ( object -> num_elems * object -> elem_size ) ; break ; case UINT64_DATA : object -> data_arrays . ui64_data = mxMalloc ( object -> num_elems * object -> elem_size ) ; break ; case SINGLE_DATA : object -> data_arrays . single_data = mxMalloc ( object -> num_elems * object -> elem_size ) ; break ; case DOUBLE_DATA : object -> data_arrays . double_data = mxMalloc ( object -> num_elems * object -> elem_size ) ; break ; case REF_DATA : object -> data_arrays . sub_object_header_offsets = malloc ( object -> num_elems * object -> elem_size ) ; break ; case STRUCT_DATA : case FUNCTION_HANDLE_DATA : object -> num_elems = 1 ; object -> num_dims = 2 ; object -> dims [ 0 ] = 1 ; object -> dims [ 1 ] = 1 ; object -> dims [ 2 ] = 0 ; break ; case TABLE_DATA : <S2SV_StartBug> break ; <S2SV_EndBug> case NULLTYPE_DATA : default : error_flag = TRUE ; sprintf ( error_id , "getmatvar:thisShouldntHappen" ) ; sprintf ( error_message , "Allocated<S2SV_blank>space<S2SV_blank>ran<S2SV_blank>with<S2SV_blank>an<S2SV_blank>NULLTYPE_DATA<S2SV_blank>for<S2SV_blank>some<S2SV_blank>reason.\\n\\n" ) ; return 1 ; } return 0 ; } | <S2SV_ModStart> case TABLE_DATA : case SPARSE_DATA : |
595 | CWE-000 val_t * apply ( val_t * l , val_t * r , env_t * e ) { switch ( l -> type ) { case TYPE_ERR : return l ; case TYPE_LMD : envDeBind ( l -> s , l -> innerEnv ) ; envBind ( l -> s , r , l -> innerEnv ) ; return eval ( l -> body , l -> innerEnv ) ; case TYPE_APL : case TYPE_SYM : <S2SV_StartBug> return apply ( eval ( l , e ) , eval ( r , e ) , e ) ; <S2SV_EndBug> case TYPE_NUM : case TYPE_STR : default : return valErr ( "Not<S2SV_blank>a<S2SV_blank>lambda!" ) ; } } | <S2SV_ModStart> e ) , r <S2SV_ModEnd> , e ) |
596 | CWE-000 static void parse_genroot_cli ( int argc , char * * argv , struct cli_params * params ) { params -> privkey = "root_priv.bin" ; params -> pubkey = "root_pub.bin" ; params -> id = NULL ; params -> rootcert = "root_cert.bin" ; const char * usage_str = "Generate<S2SV_blank>a<S2SV_blank>root<S2SV_blank>certificate.\\n\\n" "Usage:<S2SV_blank>%s<S2SV_blank>%s<S2SV_blank>[-h]<S2SV_blank>[-v<S2SV_blank><file>]<S2SV_blank>[-b<S2SV_blank><file>]<S2SV_blank>[-d<S2SV_blank><file>]<S2SV_blank>[-c<S2SV_blank><file>]\\n" "\\tOptions:\\n" "\\t\\t-h<S2SV_blank>--help<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Display<S2SV_blank>this<S2SV_blank>message.\\n" <S2SV_StartBug> "\\t\\t-v<S2SV_blank>--rpriv<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Root\'s<S2SV_blank>private<S2SV_blank>key<S2SV_blank>output<S2SV_blank>location<S2SV_blank>[default<S2SV_blank>=<S2SV_blank>root_priv.bin]\\n" <S2SV_EndBug> "\\t\\t-b<S2SV_blank>--rpub<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Root\'s<S2SV_blank>public<S2SV_blank>key<S2SV_blank>output<S2SV_blank>location<S2SV_blank>[default<S2SV_blank>=<S2SV_blank>root_pub.bin]\\n" "\\t\\t-d<S2SV_blank>--rid<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Root\'s<S2SV_blank>ID<S2SV_blank>input<S2SV_blank>location<S2SV_blank>[default<S2SV_blank>generates<S2SV_blank>a<S2SV_blank>random<S2SV_blank>ID]\\n" "\\t\\t-c<S2SV_blank>--rcert<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Root\'s<S2SV_blank>public<S2SV_blank>key<S2SV_blank>output<S2SV_blank>location<S2SV_blank>[default<S2SV_blank>=<S2SV_blank>root_cert.bin]\\n" ; static struct option cli_options [ ] = { { "rpriv" , required_argument , NULL , 'v' } , { "rpub" , required_argument , NULL , 'b' } , { "rid" , required_argument , NULL , 'd' } , { "rcert" , required_argument , NULL , 'c' } , { "help" , no_argument , NULL , 'h' } , { NULL , 0 , NULL , 0 } } ; int c ; while ( ( c = getopt_long ( argc , argv , "v:b:d:c:h" , cli_options , NULL ) ) != - 1 ) { switch ( c ) { case 'v' : params -> privkey = optarg ; break ; case 'b' : params -> pubkey = optarg ; break ; case 'd' : params -> id = optarg ; break ; case 'c' : params -> rootcert = optarg ; break ; case 'h' : printf ( usage_str , argv [ 0 ] , argv [ 1 ] ) ; exit ( 1 ) ; } } } | <S2SV_ModStart> "Usage:<S2SV_blank>%s<S2SV_blank>%s<S2SV_blank>[-h]<S2SV_blank>[-v<S2SV_blank><file>]<S2SV_blank>[-b<S2SV_blank><file>]<S2SV_blank>[-d<S2SV_blank><file>]<S2SV_blank>[-c<S2SV_blank><file>]\\n" "\\tOptions:\\n" "\\t\\t-h<S2SV_blank>--help<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Display<S2SV_blank>this<S2SV_blank>message.\\n" "\\t\\t-v<S2SV_blank>--rpriv<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Root\'s<S2SV_blank>private<S2SV_blank>key<S2SV_blank>input<S2SV_blank>location<S2SV_blank>[default<S2SV_blank>=<S2SV_blank>root_priv.bin]\\n" "\\t\\t-b<S2SV_blank>--rpub<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Root\'s<S2SV_blank>public<S2SV_blank>key<S2SV_blank>input<S2SV_blank>location<S2SV_blank>[default<S2SV_blank>=<S2SV_blank>root_pub.bin]\\n" "\\t\\t-d<S2SV_blank>--rid<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Root\'s<S2SV_blank>ID<S2SV_blank>input<S2SV_blank>location<S2SV_blank>[default<S2SV_blank>generates<S2SV_blank>a<S2SV_blank>random<S2SV_blank>ID]\\n" "\\t\\t-c<S2SV_blank>--rcert<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Root\'s<S2SV_blank>certificate<S2SV_blank>key<S2SV_blank>output<S2SV_blank>location<S2SV_blank>[default<S2SV_blank>=<S2SV_blank>root_cert.bin]\\n" <S2SV_ModEnd> ; static struct |
597 | CWE-000 static void n_tty_set_termios ( struct tty_struct * tty , struct ktermios * old ) { struct n_tty_data * ldata = tty -> disc_data ; <S2SV_StartBug> if ( ! old || ( old -> c_lflag ^ tty -> termios . c_lflag ) & ICANON ) { <S2SV_EndBug> bitmap_zero ( ldata -> read_flags , N_TTY_BUF_SIZE ) ; ldata -> line_start = ldata -> read_tail ; if ( ! L_ICANON ( tty ) || ! read_cnt ( ldata ) ) { ldata -> canon_head = ldata -> read_tail ; ldata -> push = 0 ; } else { set_bit ( ( ldata -> read_head - 1 ) & ( N_TTY_BUF_SIZE - 1 ) , ldata -> read_flags ) ; ldata -> canon_head = ldata -> read_head ; ldata -> push = 1 ; } ldata -> erasing = 0 ; ldata -> lnext = 0 ; } ldata -> icanon = ( L_ICANON ( tty ) != 0 ) ; if ( I_ISTRIP ( tty ) || I_IUCLC ( tty ) || I_IGNCR ( tty ) || I_ICRNL ( tty ) || I_INLCR ( tty ) || L_ICANON ( tty ) || I_IXON ( tty ) || L_ISIG ( tty ) || L_ECHO ( tty ) || I_PARMRK ( tty ) ) { bitmap_zero ( ldata -> char_map , 256 ) ; if ( I_IGNCR ( tty ) || I_ICRNL ( tty ) ) set_bit ( '\\r' , ldata -> char_map ) ; if ( I_INLCR ( tty ) ) set_bit ( '\\n' , ldata -> char_map ) ; if ( L_ICANON ( tty ) ) { set_bit ( ERASE_CHAR ( tty ) , ldata -> char_map ) ; set_bit ( KILL_CHAR ( tty ) , ldata -> char_map ) ; set_bit ( EOF_CHAR ( tty ) , ldata -> char_map ) ; set_bit ( '\\n' , ldata -> char_map ) ; set_bit ( EOL_CHAR ( tty ) , ldata -> char_map ) ; if ( L_IEXTEN ( tty ) ) { set_bit ( WERASE_CHAR ( tty ) , ldata -> char_map ) ; set_bit ( LNEXT_CHAR ( tty ) , ldata -> char_map ) ; set_bit ( EOL2_CHAR ( tty ) , ldata -> char_map ) ; if ( L_ECHO ( tty ) ) set_bit ( REPRINT_CHAR ( tty ) , ldata -> char_map ) ; } } if ( I_IXON ( tty ) ) { set_bit ( START_CHAR ( tty ) , ldata -> char_map ) ; set_bit ( STOP_CHAR ( tty ) , ldata -> char_map ) ; } if ( L_ISIG ( tty ) ) { set_bit ( INTR_CHAR ( tty ) , ldata -> char_map ) ; set_bit ( QUIT_CHAR ( tty ) , ldata -> char_map ) ; set_bit ( SUSP_CHAR ( tty ) , ldata -> char_map ) ; } clear_bit ( __DISABLED_CHAR , ldata -> char_map ) ; ldata -> raw = 0 ; ldata -> real_raw = 0 ; } else { ldata -> raw = 1 ; if ( ( I_IGNBRK ( tty ) || ( ! I_BRKINT ( tty ) && ! I_PARMRK ( tty ) ) ) && ( I_IGNPAR ( tty ) || ! I_INPCK ( tty ) ) && ( tty -> driver -> flags & TTY_DRIVER_REAL_RAW ) ) ldata -> real_raw = 1 ; else ldata -> real_raw = 0 ; } n_tty_set_room ( tty ) ; if ( ! I_IXON ( tty ) && old && ( old -> c_iflag & IXON ) && ! tty -> flow_stopped ) { start_tty ( tty ) ; process_echoes ( tty ) ; } wake_up_interruptible ( & tty -> write_wait ) ; wake_up_interruptible ( & tty -> read_wait ) ; } | <S2SV_ModStart> c_lflag ) & ( ICANON | EXTPROC ) <S2SV_ModEnd> ) { bitmap_zero |
598 | CWE-000 int main ( void ) { pthread_t threads [ 2 ] ; int rc ; fd = socket_init ( 52001 ) ; <S2SV_StartBug> read_socket ( NULL ) ; <S2SV_EndBug> <S2SV_StartBug> while ( 1 ) ; <S2SV_EndBug> } | <S2SV_ModStart> 52001 ) ; # ifndef __OF_TEST__ pthread_create ( & threads [ 0 ] , NULL , write_socket , NULL ) ; pthread_create ( & threads [ 1 ] , NULL , read_socket , NULL ) ; # else <S2SV_ModStart> NULL ) ; # endif <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
599 | CWE-000 int render_draw_button_internal_onto ( SDL_Surface * surface , button_desc * button ) { log_error ( "render_draw_button_internal_onto():<S2SV_blank>About<S2SV_blank>to<S2SV_blank>render<S2SV_blank>button...\\n" ) ; Sint16 x1 = button -> bounds . x ; Sint16 y1 = button -> bounds . y ; Sint16 x2 = button -> bounds . x + button -> bounds . w ; Sint16 y2 = button -> bounds . y + button -> bounds . h ; SDL_Color * bgColor = button -> pressed ? & button -> clickedColor : & button -> backgroundColor ; if ( button -> cornerRadius > 0 ) { roundedBoxRGBA ( surface , x1 , y1 , x2 , y2 , button -> cornerRadius , bgColor -> r , bgColor -> g , bgColor -> b , 255 ) ; roundedRectangleRGBA ( surface , x1 , y1 , x2 , y2 , button -> cornerRadius , button -> borderColor . r , button -> borderColor . g , button -> borderColor . b , 255 ) ; } else { boxRGBA ( surface , x1 , y1 , x2 , y2 , bgColor -> r , bgColor -> g , bgColor -> b , 255 ) ; rectangleRGBA ( surface , x1 , y1 , x2 , y2 , button -> borderColor . r , button -> borderColor . g , button -> borderColor . b , 255 ) ; } int textWidth ; int textHeight ; if ( button -> text == NULL ) { render_error ( "render_draw_button_internal_onto():<S2SV_blank>Button<S2SV_blank>has<S2SV_blank>no<S2SV_blank>text<S2SV_blank>assigned?" ) ; return 0 ; } int result = TTF_SizeText ( font , button -> text , & textWidth , & textHeight ) ; if ( result != 0 ) { log_error ( "render_draw_button_internal_onto():<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>size<S2SV_blank>text\\n" ) ; render_error ( "Failed<S2SV_blank>to<S2SV_blank>size<S2SV_blank>text" ) ; return 0 ; } int textX = button -> bounds . x + button -> bounds . w / 2 - textWidth / 2 ; int textY = button -> bounds . y + button -> bounds . h / 2 - textHeight / 2 ; log_error ( "render_draw_button_internal_onto():<S2SV_blank>Rendering<S2SV_blank>text<S2SV_blank>at<S2SV_blank>(%d,%d)<S2SV_blank>with<S2SV_blank>w=%d,h=%d\\n" , textX , textY , textWidth , textHeight ) ; <S2SV_StartBug> render_text_args * text = malloc ( sizeof ( render_text_args ) ) ; <S2SV_EndBug> if ( text == NULL ) { render_error ( "render_draw_button_internal_onto():<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>alloc<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>render_text_args" ) ; return 0 ; } text -> text = strdup ( button -> text ) ; if ( text -> text == NULL ) { render_error ( "render_draw_button_internal_onto():<S2SV_blank>strdup()<S2SV_blank>failed" ) ; free ( text ) ; return 0 ; } text -> x = textX ; text -> y = textY ; <S2SV_StartBug> text -> color = button -> textColor ; <S2SV_EndBug> return render_render_text_internal_onto ( surface , text ) ; } | <S2SV_ModStart> * text = calloc ( 1 , <S2SV_ModEnd> sizeof ( render_text_args <S2SV_ModStart> text -> color . r <S2SV_ModStart> button -> textColor . r ; text -> color . g = button -> textColor . g ; text -> color . b = button -> textColor . b |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.