Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
3,300 | CWE-000 static void khttpd_fcgi_conn_release_locked ( struct khttpd_fcgi_location_data * loc_data , struct khttpd_fcgi_conn * conn ) { struct khttpd_fcgi_xchg_data * xchg_data ; KHTTPD_ENTRY ( "%s(%p,%p)" , __func__ , loc_data , conn ) ; mtx_assert ( & loc_data -> lock , MA_OWNED ) ; <S2SV_StartBug> KASSERT ( ! conn -> active , ( "active" ) ) ; <S2SV_EndBug> <S2SV_StartBug> KASSERT ( khttpd_fcgi_conn_on_worker_thread ( conn ) , ( "wrong<S2SV_blank>thread" ) ) ; <S2SV_EndBug> <S2SV_StartBug> KASSERT ( conn -> xchg_data == NULL , ( "xchg_data<S2SV_blank>%p" , conn -> xchg_data ) ) ; <S2SV_EndBug> if ( ( xchg_data = STAILQ_FIRST ( & loc_data -> queue ) ) == NULL ) { LIST_INSERT_HEAD ( & loc_data -> idle_conn , conn , idleliste ) ; mtx_unlock ( & loc_data -> lock ) ; return ; } KASSERT ( xchg_data -> waiting , ( "!waiting" ) ) ; xchg_data -> waiting = false ; STAILQ_REMOVE_HEAD ( & loc_data -> queue , link ) ; -- loc_data -> nwaiting ; conn -> xchg_data = xchg_data ; xchg_data -> conn = conn ; khttpd_task_queue_hand_over ( khttpd_socket_task_queue ( conn -> stream . down ) , khttpd_socket_task_queue ( khttpd_exchange_socket ( xchg_data -> exchange ) ) ) ; khttpd_task_schedule ( conn -> attach_task ) ; mtx_unlock ( & loc_data -> lock ) ; } | <S2SV_ModStart> ; KASSERT ( khttpd_fcgi_conn_on_worker_thread ( conn ) , ( "wrong<S2SV_blank>thread" ) ) ; KASSERT ( <S2SV_ModStart> ; KASSERT ( ! conn -> waiting_end , ( "waiting_end" ) ) ; KASSERT ( ! conn -> recv_eof , ( "recv_eof" <S2SV_ModEnd> ) ) ; <S2SV_ModStart> ) ) ; if ( conn -> recv_suspended ) { KHTTPD_NOTE ( "%s<S2SV_blank>recv_suspended<S2SV_blank>%p" , __func__ ) ; conn -> recv_suspended = false ; khttpd_stream_continue_receiving ( & conn -> stream , conn -> upstream -> idle_timeout ) ; } |
3,301 | CWE-000 parse_t * parse_empty ( char * source , size_t start , parse_t * parent ) { <S2SV_StartBug> parse_t * node = parse_init ( "__empty" , start , 0 ) ; <S2SV_EndBug> <S2SV_StartBug> parse_add_child ( parent , node ) ; <S2SV_EndBug> return node ; } | <S2SV_ModStart> parent ) { return <S2SV_ModEnd> parse_init ( "__empty" <S2SV_ModStart> 0 ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
3,302 | CWE-000 static int pdo_4d_stmt_param_hook ( pdo_stmt_t * stmt , struct pdo_bound_param_data * param , enum pdo_param_event event_type TSRMLS_DC ) { pdo_4d_stmt * S = ( pdo_4d_stmt * ) stmt -> driver_data ; if ( S -> state == NULL ) { return 1 ; } switch ( event_type ) { case PDO_PARAM_EVT_NORMALIZE : if ( param -> paramno < 0 ) { strcpy ( stmt -> error_code , "HY093" ) ; # if PHP_VERSION_ID >= 70000 pdo_raise_impl_error ( stmt -> dbh , stmt , "HY093" , param -> name -> val TSRMLS_CC ) ; # else pdo_raise_impl_error ( stmt -> dbh , stmt , "HY093" , param -> name TSRMLS_CC ) ; # endif return 0 ; } return 1 ; break ; case PDO_PARAM_EVT_EXEC_PRE : if ( param -> paramno < 0 ) { strcpy ( stmt -> error_code , "HY093" ) ; # if PHP_VERSION_ID >= 70000 pdo_raise_impl_error ( stmt -> dbh , stmt , "HY093" , param -> name -> val TSRMLS_CC ) ; # else pdo_raise_impl_error ( stmt -> dbh , stmt , "HY093" , param -> name TSRMLS_CC ) ; # endif return 0 ; } if ( param -> is_param ) { switch ( PDO_PARAM_TYPE ( param -> param_type ) ) { case PDO_PARAM_STMT : return 0 ; case PDO_PARAM_NULL : fourd_bind_param ( S -> state , param -> paramno , VK_STRING , NULL ) ; return 1 ; case PDO_PARAM_INT : { # if PHP_VERSION_ID >= 70000 FOURD_LONG val = Z_LVAL ( param -> parameter ) ; # else FOURD_LONG val = Z_LVAL_P ( param -> parameter ) ; # endif fourd_bind_param ( S -> state , param -> paramno , VK_LONG , & val ) ; } return 1 ; case PDO_PARAM_LOB : # if PHP_VERSION_ID >= 70000 if ( Z_TYPE ( param -> parameter ) == IS_RESOURCE ) { # else if ( Z_TYPE_P ( param -> parameter ) == IS_RESOURCE ) { # endif php_stream * stm ; php_stream_from_zval_no_verify ( stm , & param -> parameter ) ; if ( stm ) { SEPARATE_ZVAL ( & param -> parameter ) ; # if PHP_VERSION_ID >= 70000 param -> parameter . u1 . v . type = IS_STRING ; Z_STRLEN ( param -> parameter ) = php_stream_copy_to_mem ( stm , PHP_STREAM_COPY_ALL , 0 ) -> len ; # else Z_TYPE_P ( param -> parameter ) = IS_STRING ; Z_STRLEN_P ( param -> parameter ) = php_stream_copy_to_mem ( stm , & Z_STRVAL_P ( param -> parameter ) , PHP_STREAM_COPY_ALL , 0 ) ; # endif } else { pdo_raise_impl_error ( stmt -> dbh , stmt , "HY105" , "Expected<S2SV_blank>a<S2SV_blank>stream<S2SV_blank>resource" TSRMLS_CC ) ; return 0 ; } { FOURD_BLOB str ; # if PHP_VERSION_ID >= 70000 str . length = Z_STRLEN ( param -> parameter ) ; str . data = Z_STRVAL ( param -> parameter ) ; # else str . length = Z_STRLEN_P ( param -> parameter ) ; str . data = Z_STRVAL_P ( param -> parameter ) ; # endif fourd_bind_param ( S -> state , param -> paramno , VK_BLOB , & str ) ; } return 1 ; } case PDO_PARAM_STR : default : # if PHP_VERSION_ID >= 70000 switch ( Z_TYPE ( param -> parameter ) ) { # else switch ( Z_TYPE_P ( param -> parameter ) ) { # endif case IS_NULL : fourd_bind_param ( S -> state , param -> paramno , VK_STRING , NULL ) ; return 1 ; case IS_LONG : { # if PHP_VERSION_ID >= 70000 FOURD_LONG val = Z_LVAL ( param -> parameter ) ; # else FOURD_LONG val = Z_LVAL_P ( param -> parameter ) ; # endif fourd_bind_param ( S -> state , param -> paramno , VK_LONG , & val ) ; } return 1 ; case IS_DOUBLE : # if PHP_VERSION_ID >= 70000 fourd_bind_param ( S -> state , param -> paramno , VK_REAL , & Z_DVAL ( param -> parameter ) ) ; # else fourd_bind_param ( S -> state , param -> paramno , VK_REAL , & Z_DVAL_P ( param -> parameter ) ) ; # endif return 1 ; case IS_STRING : { FOURD_STRING str ; size_t len = 0 ; # if PHP_VERSION_ID >= 70000 <S2SV_StartBug> char * val = php_mb_convert_encoding ( Z_STRVAL ( param -> parameter ) , Z_STRLEN ( param -> parameter ) , FOURD_CHARSET_SERVEUR , S -> charset , & len TSRMLS_CC ) ; <S2SV_EndBug> # else char * val = php_mb_convert_encoding ( Z_STRVAL_P ( param -> parameter ) , Z_STRLEN_P ( param -> parameter ) , FOURD_CHARSET_SERVEUR , S -> charset , & len TSRMLS_CC ) ; # endif str . length = len / 2 ; str . data = val ; fourd_bind_param ( S -> state , param -> paramno , VK_STRING , & str ) ; } return 1 ; default : { FOURD_STRING str ; size_t len = 0 ; <S2SV_StartBug> char * val = NULL ; <S2SV_EndBug> # if PHP_VERSION_ID >= 70000 convert_to_string ( & param -> parameter ) ; <S2SV_StartBug> val = php_mb_convert_encoding ( Z_STRVAL ( param -> parameter ) , Z_STRLEN ( param -> parameter ) , FOURD_CHARSET_SERVEUR , S -> charset , & len TSRMLS_CC ) ; <S2SV_EndBug> # else convert_to_string ( param -> parameter ) ; val = php_mb_convert_encoding ( Z_STRVAL_P ( param -> parameter ) , Z_STRLEN_P ( param -> parameter ) , FOURD_CHARSET_SERVEUR , S -> charset , & len TSRMLS_CC ) ; # endif str . length = len / 2 ; str . data = val ; fourd_bind_param ( S -> state , param -> paramno , VK_STRING , & str ) ; } return 1 ; } } } break ; default : ; } return 1 ; } | <S2SV_ModStart> * val = <S2SV_ModEnd> Z_STRVAL ( param <S2SV_ModStart> -> parameter ) ; len = <S2SV_ModEnd> Z_STRLEN ( param <S2SV_ModStart> param -> parameter <S2SV_ModEnd> ) ; # <S2SV_ModStart> char * val ; size_t test_length = 0 ; char * test_value <S2SV_ModEnd> ; # if <S2SV_ModStart> parameter ) ; test_value = <S2SV_ModEnd> Z_STRVAL ( param <S2SV_ModStart> -> parameter ) ; test_length = <S2SV_ModEnd> Z_STRLEN ( param <S2SV_ModStart> -> parameter ) ; val = test_value ; len = Z_STRLEN ( param -> parameter <S2SV_ModEnd> ) ; # |
3,303 | CWE-000 void start_generator ( void ) { switch ( mode ) { case MODE_SIMPLE : TIMER_1_set_comp_a ( mode_simple_freq ) ; break ; } TCCR1A |= ( 0 << COM1A1 ) | ( 1 << COM1A0 ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> COM1A0 ) ; TCNT1 = mode_simple_freq - 1 ; TCCR1B |= ( 1 << CS10 ) ; |
3,304 | CWE-000 <S2SV_StartBug> static inline void decode_residual_chroma ( AVSContext * h ) <S2SV_EndBug> { <S2SV_StartBug> if ( h -> cbp & ( 1 << 4 ) ) <S2SV_EndBug> decode_residual_block ( h , & h -> gb , chroma_dec , 0 , ff_cavs_chroma_qp [ h -> qp ] , h -> cu , h -> c_stride ) ; <S2SV_StartBug> if ( h -> cbp & ( 1 << 5 ) ) <S2SV_EndBug> decode_residual_block ( h , & h -> gb , chroma_dec , 0 , ff_cavs_chroma_qp [ h -> qp ] , h -> cv , h -> c_stride ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> <S2SV_null> static inline int <S2SV_ModEnd> decode_residual_chroma ( AVSContext <S2SV_ModStart> 4 ) ) { int ret = <S2SV_ModStart> ; if ( ret < 0 ) return ret ; } if ( <S2SV_ModStart> 5 ) ) { int ret = <S2SV_ModStart> c_stride ) ; if ( ret < 0 ) return ret ; } return 0 ; |
3,305 | CWE-000 void syscall_getpinfo ( u32 ebx , u32 ecx , u32 edx ) { <S2SV_StartBug> if ( ! ptr_validate ( edx , current_process -> page_directory ) ) { asm ( "mov<S2SV_blank>%0,<S2SV_blank>%%eax<S2SV_blank>;<S2SV_blank>mov<S2SV_blank>%0,<S2SV_blank>%%ecx" : : "N" ( ERROR_INVALID_PTR ) ) ; return ; } <S2SV_EndBug> int pid = ( int ) ebx ; <S2SV_StartBug> if ( ( pid < 0 ) | ( pid > ( int ) processes_size ) ) { asm ( "mov<S2SV_blank>%0,<S2SV_blank>%%eax<S2SV_blank>;<S2SV_blank>mov<S2SV_blank>%0,<S2SV_blank>%%ecx" : : "N" ( ERROR_INVALID_PID ) ) ; return ; } <S2SV_EndBug> process_t * process = 0 ; if ( ! ebx ) process = current_process ; else process = processes [ ebx ] ; if ( ( ! process ) | ( ( process != current_process ) && ( process -> parent != current_process ) ) ) <S2SV_StartBug> { asm ( "mov<S2SV_blank>%0,<S2SV_blank>%%eax<S2SV_blank>;<S2SV_blank>mov<S2SV_blank>%0,<S2SV_blank>%%ecx" : : "N" ( ERROR_PERMISSION ) ) ; return ; } <S2SV_EndBug> switch ( ecx ) { case VK_PINFO_PID : { * ( ( int * ) edx ) = process -> pid ; break ; } case VK_PINFO_PPID : { if ( process -> parent ) * ( ( int * ) edx ) = process -> parent -> pid ; else * ( ( int * ) edx ) = - 1 ; break ; } case VK_PINFO_WORKING_DIRECTORY : { strcpy ( ( char * ) edx , process -> current_dir ) ; break ; } case VK_PINFO_GID : { * ( ( int * ) edx ) = process -> group -> gid ; break ; } <S2SV_StartBug> default : { asm ( "mov<S2SV_blank>%0,<S2SV_blank>%%eax<S2SV_blank>;<S2SV_blank>mov<S2SV_blank>%0,<S2SV_blank>%%ecx" : : "N" ( UNKNOWN_ERROR ) ) ; return ; } <S2SV_EndBug> } <S2SV_StartBug> asm ( "mov<S2SV_blank>%0,<S2SV_blank>%%eax<S2SV_blank>;<S2SV_blank>mov<S2SV_blank>%0,<S2SV_blank>%%ecx" : : "N" ( ERROR_NONE ) ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( ERROR_INVALID_PTR ) : "%eax" , "%ecx" <S2SV_ModStart> ( ERROR_INVALID_PID ) : "%eax" , "%ecx" <S2SV_ModStart> ( ERROR_PERMISSION ) : "%eax" , "%ecx" <S2SV_ModStart> ( UNKNOWN_ERROR ) : "%eax" , "%ecx" <S2SV_ModStart> ( ERROR_NONE ) : "%eax" , "%ecx" |
3,306 | CWE-000 void write_setting_i ( void * handle , const char * key , int value ) { <S2SV_StartBug> if ( handle ) <S2SV_EndBug> <S2SV_StartBug> RegSetValueEx ( ( HKEY ) handle , key , 0 , REG_DWORD , <S2SV_EndBug> ( CONST BYTE * ) & value , sizeof ( value ) ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> { if ( storagetype == 1 ) { file_write_setting_i ( <S2SV_ModEnd> handle , key <S2SV_ModStart> , key , value <S2SV_ModEnd> ) ; } <S2SV_ModStart> ) ; } else { reg_write_setting_i ( handle , key , value ) ; } } |
3,307 | CWE-000 void parallel_setup ( int id , uint16_t port ) { parallel_t * dev = & ports [ id - 1 ] ; # ifdef _DEBUG <S2SV_StartBug> pclog ( "PARALLE:<S2SV_blank>setting<S2SV_blank>up<S2SV_blank>LPT%d<S2SV_blank>as<S2SV_blank>%04X<S2SV_blank>[enabled=%d]\\n" , <S2SV_EndBug> id , port , parallel_enabled [ id - 1 ] ) ; # endif if ( ! parallel_enabled [ id - 1 ] ) return ; dev -> base = port ; } | <S2SV_ModStart> _DEBUG pclog ( "PARALLEL:<S2SV_blank>setting<S2SV_blank>up<S2SV_blank>LPT%d<S2SV_blank>as<S2SV_blank>%04X<S2SV_blank>[enabled=%d]\\n" <S2SV_ModEnd> , id , |
3,308 | CWE-000 static int prismesh_tostring ( lua_State * L ) { prismesh_t * m = lua_to_prismesh ( L , 1 ) ; <S2SV_StartBug> lua_pushfstring ( L , "prismesh<S2SV_blank>(%d<S2SV_blank>chunks,<S2SV_blank>%d<S2SV_blank>xy<S2SV_blank>chunks,<S2SV_blank>%d<S2SV_blank>z<S2SV_blank>chunks,<S2SV_blank>z1<S2SV_blank>=<S2SV_blank>%g,<S2SV_blank>z2<S2SV_blank>=<S2SV_blank>%g)" , <S2SV_EndBug> <S2SV_StartBug> ( int ) prismesh_num_chunks ( m ) , ( int ) prismesh_num_xy_chunks ( m ) , <S2SV_EndBug> <S2SV_StartBug> ( int ) prismesh_num_z_chunks ( m ) , ( double ) prismesh_z1 ( m ) , <S2SV_EndBug> ( double ) prismesh_z2 ( m ) ) ; return 1 ; } | <S2SV_ModStart> 1 ) ; size_t num_xy_chunks , num_z_chunks , nz_per_chunk ; prismesh_get_chunk_info ( m , & num_xy_chunks , & num_z_chunks , & nz_per_chunk ) ; <S2SV_ModStart> ( L , "prismesh<S2SV_blank>(%d<S2SV_blank>chunks,<S2SV_blank>%d<S2SV_blank>xy<S2SV_blank>chunks,<S2SV_blank>%d<S2SV_blank>z<S2SV_blank>chunks,<S2SV_blank>nz<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>z1<S2SV_blank>=<S2SV_blank>%g,<S2SV_blank>z2<S2SV_blank>=<S2SV_blank>%g)" <S2SV_ModEnd> , ( int <S2SV_ModStart> ( int ) num_xy_chunks , ( int ) num_z_chunks <S2SV_ModEnd> , ( int <S2SV_ModStart> ( int ) nz_per_chunk <S2SV_ModEnd> , ( double |
3,309 | CWE-000 static void traing_screen_keypad_event_handler ( hal_keypad_event_t * keypad_event , void * user_data ) { int32_t temp_index ; int32_t max_item_num ; int32_t temp_focus ; GRAPHICLOG ( "[chenchen<S2SV_blank>traing_screen_keypad_event_handler<S2SV_blank>key<S2SV_blank>state=%d,<S2SV_blank>position=%d\\r\\n" , ( int ) keypad_event -> state , ( int ) keypad_event -> key_data ) ; if ( keypad_event -> key_data == DEVICE_KEY_ENTER && keypad_event -> state == 0 ) { temp_index = 1 ; } else if ( keypad_event -> key_data == DEVICE_KEY_BACK && keypad_event -> state == 0 ) { temp_index = 2 ; <S2SV_StartBug> } else if ( keypad_event -> key_data == DEVICE_KEY_UP && keypad_event -> state == 0 ) { <S2SV_EndBug> temp_focus = traing_type_screen_cntx . focus_point_index + 1 ; max_item_num = traing_type_screen_cntx . total_item_num ; traing_type_screen_cntx . focus_point_index = temp_focus % max_item_num ; GRAPHICLOG ( "[chenchen[get<S2SV_blank>key]main_screen_cntx.focus_point_index=%d,\\r\\n" , traing_type_screen_cntx . focus_point_index ) ; if ( traing_type_screen_cntx . focus_point_index < 0 ) traing_type_screen_cntx . focus_point_index = 0 ; <S2SV_StartBug> } else if ( keypad_event -> key_data == DEVICE_KEY_DOWN && keypad_event -> state == 0 ) { <S2SV_EndBug> temp_focus = traing_type_screen_cntx . focus_point_index - 1 ; max_item_num = traing_type_screen_cntx . total_item_num ; traing_type_screen_cntx . focus_point_index = temp_focus % max_item_num ; if ( traing_type_screen_cntx . focus_point_index < 0 ) traing_type_screen_cntx . focus_point_index = 0 ; } switch ( temp_index ) { case - 1 : return ; case - 2 : break ; case - 3 : break ; case 0 : break ; case 1 : curr_event_handler = demo_traing_item [ traing_type_screen_cntx . focus_point_index ] . event_traing_handle_f ; if ( demo_traing_item [ traing_type_screen_cntx . focus_point_index ] . show_traing_screen_f ) { demo_traing_item [ traing_type_screen_cntx . focus_point_index ] . show_traing_screen_f ( ) ; } return ; default : break ; } if ( keypad_event -> key_data == DEVICE_KEY_BACK && keypad_event -> state == 0 ) { show_main_screen ( ) ; } else { traing_screen_draw ( ) ; } } | <S2SV_ModStart> -> key_data == DEVICE_KEY_DOWN <S2SV_ModEnd> && keypad_event -> <S2SV_ModStart> -> key_data == DEVICE_KEY_UP <S2SV_ModEnd> && keypad_event -> |
3,310 | CWE-000 int main ( int argc , char * * argv ) { char * i2c_device = "/dev/i2c-1" ; int address = 0x77 ; void * bmp = bmp180_init ( address , i2c_device ) ; if ( bmp != NULL ) { float temperature = bmp180_temperature ( bmp ) ; long pressure = bmp180_pressure ( bmp ) ; float altitude = bmp180_altitude ( bmp ) ; printf ( "temperature<S2SV_blank>=<S2SV_blank>%f,<S2SV_blank>pressure<S2SV_blank>=<S2SV_blank>%lu,<S2SV_blank>altitude<S2SV_blank>=<S2SV_blank>%f\\n" , temperature , pressure , altitude ) ; usleep ( 2 * 1000 * 1000 ) ; char text [ 100 ] ; time_t now = time ( NULL ) ; struct tm * t = localtime ( & now ) ; strftime ( text , sizeof ( text ) - 1 , "%d-%m-%Y" , t ) ; char prefix [ 50 ] = "/var/www/temphum/bmp180_" ; strcat ( prefix , text ) ; char suffix [ 50 ] = ".csv" ; strcat ( prefix , suffix ) ; FILE * fp ; fp = fopen ( prefix , "a" ) ; fprintf ( fp , "%u000,%f,%lu,%f\\n" , ( unsigned ) time ( NULL ) , temperature , pressure , altitude ) ; fclose ( fp ) ; FILE * fhc ; fhc = fopen ( "/var/www/temphum/bmp180_log.csv" , "a" ) ; <S2SV_StartBug> fprintf ( fhc , "%u000,%d%d,%d\\n" , ( unsigned ) time ( NULL ) , temperature , <S2SV_EndBug> pressure , altitude ) ; fclose ( fhc ) ; FILE * fh ; fh = fopen ( "/var/www/temphum/bmp180_current_pressure.csv" , "w" ) ; fprintf ( fh , "%lu\\n" , pressure ) ; fclose ( fh ) ; FILE * ft ; ft = fopen ( "/var/www/temphum/bmp180_current_temperature.csv" , "w" ) ; fprintf ( ft , "%f\\n" , temperature ) ; fclose ( ft ) ; FILE * fa ; fa = fopen ( "/var/www/temphum/bmp180_current_altitude.csv" , "w" ) ; fprintf ( fa , "%f\\n" , altitude ) ; fclose ( fa ) ; bmp180_close ( bmp ) ; } return 0 ; } | <S2SV_ModStart> ( fhc , "%u000,%d,%d,%d\\n" <S2SV_ModEnd> , ( unsigned |
3,311 | CWE-000 void user_Init ( T_INTERFACE_VTBL_TAG * pVtable ) { <S2SV_StartBug> g_InterfaceVtbl = pVtable ; <S2SV_EndBug> <S2SV_StartBug> int size = ( UINT32 ) & __user_rw_size ; <S2SV_EndBug> <S2SV_StartBug> memcpy ( & __user_rw_start , & __user_rw_lma , size ) ; <S2SV_EndBug> user_Main ( ) ; } | <S2SV_ModStart> pVtable ) { memset ( & __user_bss_start , 0 , <S2SV_ModEnd> ( UINT32 ) <S2SV_ModStart> UINT32 ) & __user_bss_size ) <S2SV_ModEnd> ; memcpy ( <S2SV_ModStart> & __user_rw_lma , ( UINT32 ) & __user_rw_size ) ; g_InterfaceVtbl = pVtable <S2SV_ModEnd> ; user_Main ( |
3,312 | CWE-000 void do_coredump ( const siginfo_t * siginfo ) { struct core_state core_state ; struct core_name cn ; struct mm_struct * mm = current -> mm ; struct linux_binfmt * binfmt ; const struct cred * old_cred ; struct cred * cred ; int retval = 0 ; int ispipe ; struct files_struct * displaced ; bool need_suid_safe = false ; bool core_dumped = false ; static atomic_t core_dump_count = ATOMIC_INIT ( 0 ) ; struct coredump_params cprm = { . siginfo = siginfo , . regs = signal_pt_regs ( ) , . limit = rlimit ( RLIMIT_CORE ) , . mm_flags = mm -> flags , } ; audit_core_dumps ( siginfo -> si_signo ) ; binfmt = mm -> binfmt ; if ( ! binfmt || ! binfmt -> core_dump ) goto fail ; if ( ! __get_dumpable ( cprm . mm_flags ) ) goto fail ; cred = prepare_creds ( ) ; if ( ! cred ) goto fail ; if ( __get_dumpable ( cprm . mm_flags ) == SUID_DUMP_ROOT ) { cred -> fsuid = GLOBAL_ROOT_UID ; need_suid_safe = true ; } retval = coredump_wait ( siginfo -> si_signo , & core_state ) ; if ( retval < 0 ) goto fail_creds ; old_cred = override_creds ( cred ) ; ispipe = format_corename ( & cn , & cprm ) ; if ( ispipe ) { int dump_count ; char * * helper_argv ; struct subprocess_info * sub_info ; if ( ispipe < 0 ) { printk ( KERN_WARNING "format_corename<S2SV_blank>failed\\n" ) ; printk ( KERN_WARNING "Aborting<S2SV_blank>core\\n" ) ; goto fail_unlock ; } if ( cprm . limit == 1 ) { printk ( KERN_WARNING "Process<S2SV_blank>%d(%s)<S2SV_blank>has<S2SV_blank>RLIMIT_CORE<S2SV_blank>set<S2SV_blank>to<S2SV_blank>1\\n" , task_tgid_vnr ( current ) , current -> comm ) ; printk ( KERN_WARNING "Aborting<S2SV_blank>core\\n" ) ; goto fail_unlock ; } cprm . limit = RLIM_INFINITY ; dump_count = atomic_inc_return ( & core_dump_count ) ; if ( core_pipe_limit && ( core_pipe_limit < dump_count ) ) { printk ( KERN_WARNING "Pid<S2SV_blank>%d(%s)<S2SV_blank>over<S2SV_blank>core_pipe_limit\\n" , task_tgid_vnr ( current ) , current -> comm ) ; printk ( KERN_WARNING "Skipping<S2SV_blank>core<S2SV_blank>dump\\n" ) ; goto fail_dropcount ; } helper_argv = argv_split ( GFP_KERNEL , cn . corename , NULL ) ; if ( ! helper_argv ) { printk ( KERN_WARNING "%s<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory\\n" , __func__ ) ; goto fail_dropcount ; } retval = - ENOMEM ; sub_info = call_usermodehelper_setup ( helper_argv [ 0 ] , helper_argv , NULL , GFP_KERNEL , umh_pipe_setup , NULL , & cprm ) ; if ( sub_info ) retval = call_usermodehelper_exec ( sub_info , UMH_WAIT_EXEC ) ; argv_free ( helper_argv ) ; if ( retval ) { printk ( KERN_INFO "Core<S2SV_blank>dump<S2SV_blank>to<S2SV_blank>|%s<S2SV_blank>pipe<S2SV_blank>failed\\n" , cn . corename ) ; goto close_fail ; } } else { <S2SV_StartBug> struct inode * inode ; <S2SV_EndBug> if ( cprm . limit < binfmt -> min_coredump ) goto fail_unlock ; if ( need_suid_safe && cn . corename [ 0 ] != '/' ) { printk ( KERN_WARNING "Pid<S2SV_blank>%d(%s)<S2SV_blank>can<S2SV_blank>only<S2SV_blank>dump<S2SV_blank>core<S2SV_blank>" "to<S2SV_blank>fully<S2SV_blank>qualified<S2SV_blank>path!\\n" , task_tgid_vnr ( current ) , current -> comm ) ; printk ( KERN_WARNING "Skipping<S2SV_blank>core<S2SV_blank>dump\\n" ) ; goto fail_unlock ; } if ( ! need_suid_safe ) { mm_segment_t old_fs ; old_fs = get_fs ( ) ; set_fs ( KERNEL_DS ) ; ( void ) sys_unlink ( ( const char __user * ) cn . corename ) ; set_fs ( old_fs ) ; } <S2SV_StartBug> cprm . file = filp_open ( cn . corename , <S2SV_EndBug> <S2SV_StartBug> O_CREAT | 2 | O_NOFOLLOW | <S2SV_EndBug> O_LARGEFILE | O_EXCL , <S2SV_StartBug> 0600 ) ; <S2SV_EndBug> if ( IS_ERR ( cprm . file ) ) goto fail_unlock ; inode = file_inode ( cprm . file ) ; if ( inode -> i_nlink > 1 ) goto close_fail ; if ( d_unhashed ( cprm . file -> f_path . dentry ) ) goto close_fail ; if ( ! S_ISREG ( inode -> i_mode ) ) goto close_fail ; if ( ! uid_eq ( inode -> i_uid , current_fsuid ( ) ) ) goto close_fail ; if ( ! ( cprm . file -> f_mode & FMODE_CAN_WRITE ) ) goto close_fail ; if ( do_truncate ( cprm . file -> f_path . dentry , 0 , 0 , cprm . file ) ) goto close_fail ; } retval = unshare_files ( & displaced ) ; if ( retval ) goto close_fail ; if ( displaced ) put_files_struct ( displaced ) ; if ( ! dump_interrupted ( ) ) { file_start_write ( cprm . file ) ; core_dumped = binfmt -> core_dump ( & cprm ) ; file_end_write ( cprm . file ) ; } if ( ispipe && core_pipe_limit ) wait_for_dump_helpers ( cprm . file ) ; close_fail : if ( cprm . file ) filp_close ( cprm . file , NULL ) ; fail_dropcount : if ( ispipe ) atomic_dec ( & core_dump_count ) ; fail_unlock : kfree ( cn . corename ) ; coredump_finish ( mm , core_dumped ) ; revert_creds ( old_cred ) ; fail_creds : put_cred ( cred ) ; fail : return ; } | <S2SV_ModStart> inode * inode ; int open_flags = O_CREAT | O_RDWR | O_NOFOLLOW | O_LARGEFILE | O_EXCL <S2SV_ModStart> ) ; } if ( need_suid_safe ) { struct path root ; task_lock ( & init_task ) ; get_fs_root ( init_task . fs , & root ) ; task_unlock ( & init_task ) ; cprm . file = file_open_root ( root . dentry , root . mnt , cn . corename , open_flags , 0600 ) ; path_put ( & root ) ; } else { <S2SV_ModStart> . corename , open_flags , <S2SV_ModEnd> 0600 ) ; <S2SV_ModStart> 0600 ) ; } |
3,313 | CWE-000 VOID efuse_ReadEFuse ( PADAPTER Adapter , u8 efuseType , u16 _offset , u16 _size_byte , u8 * pbuf , IN BOOLEAN bPseudoTest ) { <S2SV_StartBug> Adapter -> HalFunc . ReadEFuse ( Adapter , efuseType , _offset , _size_byte , pbuf , bPseudoTest ) ; <S2SV_EndBug> } | <S2SV_ModStart> { Adapter -> hal_func <S2SV_ModEnd> . ReadEFuse ( |
3,314 | CWE-000 static int hidg_bind ( struct usb_configuration * c , struct usb_function * f ) { struct usb_ep * ep ; struct f_hidg * hidg = func_to_hidg ( f ) ; struct usb_string * us ; struct device * device ; int status ; dev_t dev ; us = usb_gstrings_attach ( c -> cdev , ct_func_strings , ARRAY_SIZE ( ct_func_string_defs ) ) ; if ( IS_ERR ( us ) ) return PTR_ERR ( us ) ; hidg_interface_desc . iInterface = us [ CT_FUNC_HID_IDX ] . id ; status = usb_interface_id ( c , f ) ; if ( status < 0 ) goto fail ; hidg_interface_desc . bInterfaceNumber = status ; status = - ENODEV ; ep = usb_ep_autoconfig ( c -> cdev -> gadget , & hidg_fs_in_ep_desc ) ; if ( ! ep ) goto fail ; hidg -> in_ep = ep ; ep = usb_ep_autoconfig ( c -> cdev -> gadget , & hidg_fs_out_ep_desc ) ; if ( ! ep ) goto fail ; hidg -> out_ep = ep ; <S2SV_StartBug> status = - ENOMEM ; <S2SV_EndBug> hidg -> req = alloc_ep_req ( hidg -> in_ep , hidg -> report_length ) ; if ( ! hidg -> req ) goto fail ; hidg_interface_desc . bInterfaceSubClass = hidg -> bInterfaceSubClass ; hidg_interface_desc . bInterfaceProtocol = hidg -> bInterfaceProtocol ; hidg_hs_in_ep_desc . wMaxPacketSize = cpu_to_le16 ( hidg -> report_length ) ; hidg_fs_in_ep_desc . wMaxPacketSize = cpu_to_le16 ( hidg -> report_length ) ; hidg_hs_out_ep_desc . wMaxPacketSize = cpu_to_le16 ( hidg -> report_length ) ; hidg_fs_out_ep_desc . wMaxPacketSize = cpu_to_le16 ( hidg -> report_length ) ; hidg_desc . desc [ 0 ] . bDescriptorType = HID_DT_REPORT ; hidg_desc . desc [ 0 ] . wDescriptorLength = cpu_to_le16 ( hidg -> report_desc_length ) ; hidg_hs_in_ep_desc . bEndpointAddress = hidg_fs_in_ep_desc . bEndpointAddress ; hidg_hs_out_ep_desc . bEndpointAddress = hidg_fs_out_ep_desc . bEndpointAddress ; status = usb_assign_descriptors ( f , hidg_fs_descriptors , hidg_hs_descriptors , NULL , NULL ) ; if ( status ) goto fail ; spin_lock_init ( & hidg -> write_spinlock ) ; <S2SV_StartBug> spin_lock_init ( & hidg -> read_spinlock ) ; <S2SV_EndBug> init_waitqueue_head ( & hidg -> write_queue ) ; init_waitqueue_head ( & hidg -> read_queue ) ; INIT_LIST_HEAD ( & hidg -> completed_out_req ) ; cdev_init ( & hidg -> cdev , & f_hidg_fops ) ; dev = MKDEV ( major , hidg -> minor ) ; status = cdev_add ( & hidg -> cdev , dev , 1 ) ; if ( status ) goto fail_free_descs ; device = device_create ( hidg_class , NULL , dev , NULL , "%s%d" , "hidg" , hidg -> minor ) ; if ( IS_ERR ( device ) ) { status = PTR_ERR ( device ) ; goto del ; } return 0 ; del : cdev_del ( & hidg -> cdev ) ; fail_free_descs : usb_free_all_descriptors ( f ) ; fail : ERROR ( f -> config -> cdev , "hidg_bind<S2SV_blank>FAILED\\n" ) ; if ( hidg -> req != NULL ) free_ep_req ( hidg -> in_ep , hidg -> req ) ; return status ; } | <S2SV_ModStart> = ep ; <S2SV_ModEnd> hidg_interface_desc . bInterfaceSubClass <S2SV_ModStart> write_spinlock ) ; hidg -> write_pending = 1 ; hidg -> req = NULL ; |
3,315 | CWE-000 static void lp_jit_create_types ( struct lp_fragment_shader_variant * lp ) { struct gallivm_state * gallivm = lp -> gallivm ; LLVMContextRef lc = gallivm -> context ; LLVMTypeRef viewport_type , texture_type , sampler_type ; { LLVMTypeRef elem_types [ LP_JIT_VIEWPORT_NUM_FIELDS ] ; elem_types [ LP_JIT_VIEWPORT_MIN_DEPTH ] = elem_types [ LP_JIT_VIEWPORT_MAX_DEPTH ] = LLVMFloatTypeInContext ( lc ) ; viewport_type = LLVMStructTypeInContext ( lc , elem_types , ARRAY_SIZE ( elem_types ) , 0 ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_viewport , min_depth , gallivm -> target , viewport_type , LP_JIT_VIEWPORT_MIN_DEPTH ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_viewport , max_depth , gallivm -> target , viewport_type , LP_JIT_VIEWPORT_MAX_DEPTH ) ; LP_CHECK_STRUCT_SIZE ( struct lp_jit_viewport , gallivm -> target , viewport_type ) ; } { LLVMTypeRef elem_types [ LP_JIT_TEXTURE_NUM_FIELDS ] ; elem_types [ LP_JIT_TEXTURE_WIDTH ] = elem_types [ LP_JIT_TEXTURE_HEIGHT ] = elem_types [ LP_JIT_TEXTURE_DEPTH ] = elem_types [ LP_JIT_TEXTURE_FIRST_LEVEL ] = elem_types [ LP_JIT_TEXTURE_LAST_LEVEL ] = LLVMInt32TypeInContext ( lc ) ; elem_types [ LP_JIT_TEXTURE_BASE ] = LLVMPointerType ( LLVMInt8TypeInContext ( lc ) , 0 ) ; elem_types [ LP_JIT_TEXTURE_ROW_STRIDE ] = elem_types [ LP_JIT_TEXTURE_IMG_STRIDE ] = elem_types [ LP_JIT_TEXTURE_MIP_OFFSETS ] = LLVMArrayType ( LLVMInt32TypeInContext ( lc ) , LP_MAX_TEXTURE_LEVELS ) ; texture_type = LLVMStructTypeInContext ( lc , elem_types , ARRAY_SIZE ( elem_types ) , 0 ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_texture , width , gallivm -> target , texture_type , LP_JIT_TEXTURE_WIDTH ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_texture , height , gallivm -> target , texture_type , LP_JIT_TEXTURE_HEIGHT ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_texture , depth , gallivm -> target , texture_type , LP_JIT_TEXTURE_DEPTH ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_texture , first_level , gallivm -> target , texture_type , LP_JIT_TEXTURE_FIRST_LEVEL ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_texture , last_level , gallivm -> target , texture_type , LP_JIT_TEXTURE_LAST_LEVEL ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_texture , base , gallivm -> target , texture_type , LP_JIT_TEXTURE_BASE ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_texture , row_stride , gallivm -> target , texture_type , LP_JIT_TEXTURE_ROW_STRIDE ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_texture , img_stride , gallivm -> target , texture_type , LP_JIT_TEXTURE_IMG_STRIDE ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_texture , mip_offsets , gallivm -> target , texture_type , LP_JIT_TEXTURE_MIP_OFFSETS ) ; LP_CHECK_STRUCT_SIZE ( struct lp_jit_texture , gallivm -> target , texture_type ) ; } { LLVMTypeRef elem_types [ LP_JIT_SAMPLER_NUM_FIELDS ] ; elem_types [ LP_JIT_SAMPLER_MIN_LOD ] = elem_types [ LP_JIT_SAMPLER_MAX_LOD ] = elem_types [ LP_JIT_SAMPLER_LOD_BIAS ] = LLVMFloatTypeInContext ( lc ) ; elem_types [ LP_JIT_SAMPLER_BORDER_COLOR ] = LLVMArrayType ( LLVMFloatTypeInContext ( lc ) , 4 ) ; sampler_type = LLVMStructTypeInContext ( lc , elem_types , ARRAY_SIZE ( elem_types ) , 0 ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_sampler , min_lod , gallivm -> target , sampler_type , LP_JIT_SAMPLER_MIN_LOD ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_sampler , max_lod , gallivm -> target , sampler_type , LP_JIT_SAMPLER_MAX_LOD ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_sampler , lod_bias , gallivm -> target , sampler_type , LP_JIT_SAMPLER_LOD_BIAS ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_sampler , border_color , gallivm -> target , sampler_type , LP_JIT_SAMPLER_BORDER_COLOR ) ; LP_CHECK_STRUCT_SIZE ( struct lp_jit_sampler , gallivm -> target , sampler_type ) ; } { LLVMTypeRef elem_types [ LP_JIT_CTX_COUNT ] ; LLVMTypeRef context_type ; elem_types [ LP_JIT_CTX_CONSTANTS ] = LLVMArrayType ( LLVMPointerType ( LLVMFloatTypeInContext ( lc ) , 0 ) , LP_MAX_TGSI_CONST_BUFFERS ) ; elem_types [ LP_JIT_CTX_NUM_CONSTANTS ] = LLVMArrayType ( LLVMInt32TypeInContext ( lc ) , LP_MAX_TGSI_CONST_BUFFERS ) ; elem_types [ LP_JIT_CTX_ALPHA_REF ] = LLVMFloatTypeInContext ( lc ) ; elem_types [ LP_JIT_CTX_STENCIL_REF_FRONT ] = elem_types [ LP_JIT_CTX_STENCIL_REF_BACK ] = LLVMInt32TypeInContext ( lc ) ; elem_types [ LP_JIT_CTX_U8_BLEND_COLOR ] = LLVMPointerType ( LLVMInt8TypeInContext ( lc ) , 0 ) ; elem_types [ LP_JIT_CTX_F_BLEND_COLOR ] = LLVMPointerType ( LLVMFloatTypeInContext ( lc ) , 0 ) ; elem_types [ LP_JIT_CTX_VIEWPORTS ] = LLVMPointerType ( viewport_type , 0 ) ; elem_types [ LP_JIT_CTX_TEXTURES ] = LLVMArrayType ( texture_type , PIPE_MAX_SHADER_SAMPLER_VIEWS ) ; elem_types [ LP_JIT_CTX_SAMPLERS ] = LLVMArrayType ( sampler_type , PIPE_MAX_SAMPLERS ) ; context_type = LLVMStructTypeInContext ( lc , elem_types , ARRAY_SIZE ( elem_types ) , 0 ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_context , constants , gallivm -> target , context_type , LP_JIT_CTX_CONSTANTS ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_context , num_constants , gallivm -> target , context_type , LP_JIT_CTX_NUM_CONSTANTS ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_context , alpha_ref_value , gallivm -> target , context_type , LP_JIT_CTX_ALPHA_REF ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_context , stencil_ref_front , gallivm -> target , context_type , LP_JIT_CTX_STENCIL_REF_FRONT ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_context , stencil_ref_back , gallivm -> target , context_type , LP_JIT_CTX_STENCIL_REF_BACK ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_context , u8_blend_color , gallivm -> target , context_type , LP_JIT_CTX_U8_BLEND_COLOR ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_context , f_blend_color , gallivm -> target , context_type , LP_JIT_CTX_F_BLEND_COLOR ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_context , viewports , gallivm -> target , context_type , LP_JIT_CTX_VIEWPORTS ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_context , textures , gallivm -> target , context_type , LP_JIT_CTX_TEXTURES ) ; LP_CHECK_MEMBER_OFFSET ( struct lp_jit_context , samplers , gallivm -> target , context_type , LP_JIT_CTX_SAMPLERS ) ; LP_CHECK_STRUCT_SIZE ( struct lp_jit_context , gallivm -> target , context_type ) ; lp -> jit_context_ptr_type = LLVMPointerType ( context_type , 0 ) ; } { LLVMTypeRef elem_types [ LP_JIT_THREAD_DATA_COUNT ] ; LLVMTypeRef thread_data_type ; elem_types [ LP_JIT_THREAD_DATA_CACHE ] = LLVMPointerType ( lp_build_format_cache_type ( gallivm ) , 0 ) ; elem_types [ LP_JIT_THREAD_DATA_COUNTER ] = LLVMInt64TypeInContext ( lc ) ; elem_types [ LP_JIT_THREAD_DATA_RASTER_STATE_VIEWPORT_INDEX ] = LLVMInt32TypeInContext ( lc ) ; thread_data_type = LLVMStructTypeInContext ( lc , elem_types , ARRAY_SIZE ( elem_types ) , 0 ) ; lp -> jit_thread_data_ptr_type = LLVMPointerType ( thread_data_type , 0 ) ; } if ( gallivm_debug & GALLIVM_DEBUG_IR ) { <S2SV_StartBug> LLVMDumpModule ( gallivm -> module ) ; <S2SV_EndBug> } } | <S2SV_ModStart> GALLIVM_DEBUG_IR ) { # if HAVE_LLVM >= 0x304 char * str = LLVMPrintModuleToString <S2SV_ModEnd> ( gallivm -> <S2SV_ModStart> module ) ; fprintf ( stderr , "%s" , str ) ; LLVMDisposeMessage ( str ) ; # else DumpModule ( gallivm -> module ) ; # endif |
3,316 | CWE-000 void scatterwalk_done ( struct scatter_walk * walk , int out , int more ) { <S2SV_StartBug> if ( ! ( scatterwalk_pagelen ( walk ) & ( PAGE_SIZE - 1 ) ) || ! more ) <S2SV_EndBug> scatterwalk_pagedone ( walk , out , more ) ; } | <S2SV_ModStart> if ( ! more || walk -> offset >= walk -> sg -> offset + walk -> sg -> length || ! ( walk -> offset <S2SV_ModEnd> & ( PAGE_SIZE <S2SV_ModStart> 1 ) ) <S2SV_ModEnd> ) scatterwalk_pagedone ( |
3,317 | CWE-000 void Start10msTask ( void const * argument ) { for ( ; ; ) { ADCSensorMaincyclic ( ) ; <S2SV_StartBug> osDelay ( 10 ) ; <S2SV_EndBug> } } | <S2SV_ModStart> ; osDelay ( 5 <S2SV_ModEnd> ) ; } |
3,318 | CWE-000 static int session_device_start ( SessionDevice * sd ) { int r ; assert ( sd ) ; assert ( session_is_active ( sd -> session ) ) ; if ( sd -> active ) return 0 ; switch ( sd -> type ) { case DEVICE_TYPE_DRM : if ( sd -> fd < 0 ) { <S2SV_StartBug> sd -> fd = session_device_open ( sd , true ) ; <S2SV_EndBug> if ( sd -> fd < 0 ) return sd -> fd ; } else { r = sd_drmsetmaster ( sd -> fd ) ; if ( r < 0 ) return r ; <S2SV_StartBug> } <S2SV_EndBug> break ; case DEVICE_TYPE_EVDEV : r = session_device_open ( sd , true ) ; if ( r < 0 ) return r ; safe_close ( sd -> fd ) ; sd -> fd = r ; break ; case DEVICE_TYPE_UNKNOWN : default : break ; } sd -> active = true ; return 0 ; } | <S2SV_ModStart> 0 ) { log_error ( "Failed<S2SV_blank>to<S2SV_blank>re-activate<S2SV_blank>DRM<S2SV_blank>fd,<S2SV_blank>as<S2SV_blank>the<S2SV_blank>fd<S2SV_blank>was<S2SV_blank>lost<S2SV_blank>(maybe<S2SV_blank>logind<S2SV_blank>restart<S2SV_blank>went<S2SV_blank>wrong?)" ) ; return - EBADF ; } <S2SV_ModEnd> r = sd_drmsetmaster <S2SV_ModStart> return r ; <S2SV_ModEnd> break ; case |
3,319 | CWE-000 <S2SV_StartBug> void filters_activate ( void ) <S2SV_EndBug> { struct filter_entry * f ; struct expr * e , * expr = NULL ; int unchanged = 1 ; list_for_each_entry ( f , & filters_head , node ) { if ( f -> act_stat != f -> sel_stat ) unchanged = 0 ; } <S2SV_StartBug> if ( unchanged ) <S2SV_EndBug> <S2SV_StartBug> edit_sel_filter ( ) ; <S2SV_EndBug> list_for_each_entry ( f , & filters_head , node ) { f -> visited = 0 ; if ( f -> sel_stat == FS_IGNORE ) continue ; f -> visited = 1 ; e = expr_parse ( f -> filter ) ; if ( e == NULL ) { error_msg ( "error<S2SV_blank>parsing<S2SV_blank>filter<S2SV_blank>%s:<S2SV_blank>%s" , f -> name , expr_error ( ) ) ; if ( expr ) expr_free ( expr ) ; return ; } if ( f -> sel_stat == FS_NO ) { struct expr * not = xnew ( struct expr , 1 ) ; not -> type = EXPR_NOT ; not -> key = NULL ; not -> left = e ; not -> right = NULL ; e = not ; } if ( expr == NULL ) { expr = e ; } else { struct expr * and = xnew ( struct expr , 1 ) ; and -> type = EXPR_AND ; and -> key = NULL ; and -> left = expr ; and -> right = e ; expr -> parent = and ; e -> parent = and ; expr = and ; } } recursive_filter = NULL ; if ( expr && expr_check_leaves ( & expr , get_filter ) ) { if ( recursive_filter ) { error_msg ( "recursion<S2SV_blank>detected<S2SV_blank>in<S2SV_blank>filter<S2SV_blank>%s" , recursive_filter ) ; } else { error_msg ( "error<S2SV_blank>parsing<S2SV_blank>filter:<S2SV_blank>%s" , expr_error ( ) ) ; } expr_free ( expr ) ; return ; } list_for_each_entry ( f , & filters_head , node ) { f -> act_stat = f -> sel_stat ; } lib_set_filter ( expr ) ; filters_win -> changed = 1 ; } | <S2SV_ModStart> void filters_activate ( int win_activate <S2SV_ModEnd> ) { struct <S2SV_ModStart> ( unchanged ) { if ( win_activate ) <S2SV_ModStart> ( ) ; else return ; } |
3,320 | CWE-000 <S2SV_StartBug> void ptdev_softirq ( __unused int cpu ) <S2SV_EndBug> { while ( 1 ) { struct ptdev_remapping_info * entry = ptdev_dequeue_softirq ( ) ; struct vm * vm ; if ( entry == NULL ) break ; if ( ! is_entry_active ( entry ) ) { continue ; } vm = entry -> vm ; if ( entry -> type == PTDEV_INTR_INTX ) ptdev_intr_handle_irq ( vm , entry ) ; else { vlapic_intr_msi ( vm , entry -> ptdev_intr_info . msi . vmsi_addr , entry -> ptdev_intr_info . msi . vmsi_data ) ; dev_dbg ( ACRN_DBG_PTIRQ , "dev-assign:<S2SV_blank>irq=0x%x<S2SV_blank>MSI<S2SV_blank>VR:<S2SV_blank>0x%x-0x%x" , dev_to_irq ( entry -> node ) , entry -> ptdev_intr_info . msi . virt_vector , irq_to_vector ( dev_to_irq ( entry -> node ) ) ) ; dev_dbg ( ACRN_DBG_PTIRQ , "<S2SV_blank>vmsi_addr:<S2SV_blank>0x%x<S2SV_blank>vmsi_data:<S2SV_blank>0x%x" , entry -> ptdev_intr_info . msi . vmsi_addr , entry -> ptdev_intr_info . msi . vmsi_data ) ; } } } | <S2SV_ModStart> ptdev_softirq ( __unused uint16_t cpu_id <S2SV_ModEnd> ) { while |
3,321 | CWE-000 static int getNEVRA ( Header h , rpmtd td , nevraFlags flags ) { const char * val = NULL ; <S2SV_StartBug> char * res = NULL ; <S2SV_EndBug> if ( ( flags & NEVRA_NAME ) ) { val = headerGetString ( h , RPMTAG_NAME ) ; if ( val ) rstrscat ( & res , val , "-" , NULL ) ; } if ( ( flags & NEVRA_EPOCH ) ) { char * e = headerGetAsString ( h , RPMTAG_EPOCH ) ; if ( e ) rstrscat ( & res , e , ":" , NULL ) ; free ( e ) ; } if ( ( flags & NEVRA_VERSION ) ) { val = headerGetString ( h , RPMTAG_VERSION ) ; if ( val ) rstrscat ( & res , val , "-" , NULL ) ; } if ( ( flags & NEVRA_RELEASE ) ) { val = headerGetString ( h , RPMTAG_RELEASE ) ; if ( val ) rstrscat ( & res , val , NULL ) ; } if ( ( flags & NEVRA_ARCH ) ) { val = headerGetString ( h , RPMTAG_ARCH ) ; if ( headerIsSource ( h ) && val == NULL ) val = "src" ; if ( val ) rstrscat ( & res , "." , val , NULL ) ; } td -> type = RPM_STRING_TYPE ; td -> data = res ; td -> count = 1 ; td -> flags = RPMTD_ALLOCED ; return 1 ; } | <S2SV_ModStart> * res = xstrdup ( "" ) <S2SV_ModEnd> ; if ( |
3,322 | CWE-000 int main ( int argc , char * argv [ ] ) { int c ; int xflg = 0 , aflg = 0 , nflg = 0 , errflg = 0 , modflg = 0 ; char * bank_filename ; char * sample_filename ; char * rt_controls = NULL ; int level = - 1 ; int cutoff = - 1 ; int q = - 1 ; int filter = - 1 ; int pbr = - 1 ; int preset = - 1 ; extern char * optarg ; extern int optind , optopt ; int result = 0 ; while ( ( c = getopt ( argc , argv , "vna:xr:l:c:q:f:p:P:" ) ) != - 1 ) { switch ( c ) { case 'v' : verbosity ++ ; break ; case 'a' : aflg ++ ; sample_filename = optarg ; break ; case 'x' : xflg ++ ; modflg ++ ; break ; case 'n' : nflg ++ ; break ; case 'r' : rt_controls = optarg ; modflg ++ ; break ; case 'l' : level = get_positive_int ( optarg ) ; modflg ++ ; break ; case 'c' : cutoff = get_positive_int ( optarg ) ; modflg ++ ; break ; case 'q' : q = get_positive_int ( optarg ) ; modflg ++ ; break ; case 'f' : filter = get_positive_int ( optarg ) ; modflg ++ ; break ; case 'p' : pbr = get_positive_int ( optarg ) ; modflg ++ ; break ; case 'P' : preset = get_positive_int ( optarg ) ; break ; case '?' : fprintf ( stderr , "Unrecognized<S2SV_blank>option:<S2SV_blank>-%c\\n" , optopt ) ; errflg ++ ; } } if ( optind + 1 == argc ) bank_filename = argv [ optind ] ; else errflg ++ ; <S2SV_StartBug> if ( ( nflg || aflg ) && modflg ) <S2SV_EndBug> errflg ++ ; if ( errflg > 0 ) { fprintf ( stderr , "%s\\n" , PACKAGE_STRING ) ; fprintf ( stderr , "Usage:<S2SV_blank>%s<S2SV_blank>[OPTIONS]<S2SV_blank>bank_file.\\n" , basename ( argv [ 0 ] ) ) ; exit ( EXIT_FAILURE ) ; } if ( nflg ) <S2SV_StartBug> result = emu3_create_bank ( bank_filename ) ; <S2SV_EndBug> <S2SV_StartBug> if ( result ) <S2SV_EndBug> <S2SV_StartBug> exit ( result ) ; <S2SV_EndBug> struct emu3_file * file = emu3_open_file ( bank_filename ) ; if ( ! file ) exit ( result ) ; if ( aflg ) { result = emu3_add_sample ( file , sample_filename ) ; if ( result ) { emu3_close_file ( file ) ; exit ( result ) ; } } if ( ! nflg && ! aflg ) { result = emu3_process_bank ( file , preset , xflg , rt_controls , level , cutoff , q , filter , pbr ) ; if ( result ) { emu3_close_file ( file ) ; exit ( result ) ; } } if ( aflg || modflg ) emu3_write_file ( file ) ; emu3_close_file ( file ) ; exit ( result ) ; } | <S2SV_ModStart> ; if ( nflg && aflg ) errflg ++ ; if ( <S2SV_ModStart> ( nflg ) { <S2SV_ModStart> bank_filename ) ; <S2SV_ModEnd> exit ( result <S2SV_ModStart> result ) ; } |
3,323 | CWE-000 FONT_ATTR * fontviewer_get_attr_by_size ( FONTVIEWER * fv , int size ) { static ALLEGRO_FONT * font ; static size_t i , count ; static FONT_ATTR * attr ; assert ( fv != NULL ) ; count = vector_count ( fv -> fonts ) ; i = size - fv -> minsize ; if ( i < count ) { <S2SV_StartBug> assert ( vector_get ( fv -> fonts , i , & font ) ) ; <S2SV_EndBug> attr = al_malloc ( sizeof ( FONT_ATTR ) ) ; assert ( attr != NULL ) ; attr -> height = al_get_font_line_height ( font ) ; attr -> ascent = al_get_font_ascent ( font ) ; attr -> descent = al_get_font_descent ( font ) ; return attr ; } else return NULL ; } | <S2SV_ModStart> , i , ( void * * ) |
3,324 | CWE-000 <S2SV_StartBug> void make_fields ( ) { <S2SV_EndBug> # ifdef EIG_POT node0_printf ( "Single-trace<S2SV_blank>scalar<S2SV_blank>potential\\n" ) ; # else node0_printf ( "Double-trace<S2SV_blank>scalar<S2SV_blank>potential\\n" ) ; # endif # ifdef LINEAR_DET node0_printf ( "Supersymmetric<S2SV_blank>constraint<S2SV_blank>on<S2SV_blank>(det[plaq]<S2SV_blank>-<S2SV_blank>1)\\n" ) ; # else node0_printf ( "Supersymmetric<S2SV_blank>constraint<S2SV_blank>on<S2SV_blank>|det[plaq]<S2SV_blank>-<S2SV_blank>1|^2\\n" ) ; # endif Real size = ( Real ) ( 2.0 * sizeof ( complex ) ) ; FIELD_ALLOC ( tr_eta , complex ) ; FIELD_ALLOC ( tr_dest , complex ) ; size += ( Real ) ( 2.0 * ( 1 + NUMLINK + NPLAQ ) ) * sizeof ( matrix ) ; FIELD_ALLOC ( site_src , matrix ) ; FIELD_ALLOC ( site_dest , matrix ) ; FIELD_ALLOC_VEC ( link_src , matrix , NUMLINK ) ; FIELD_ALLOC_VEC ( link_dest , matrix , NUMLINK ) ; FIELD_ALLOC_VEC ( plaq_src , matrix , NPLAQ ) ; FIELD_ALLOC_VEC ( plaq_dest , matrix , NPLAQ ) ; size += ( Real ) ( 1.0 + NPLAQ + 3.0 * NUMLINK ) * sizeof ( matrix ) ; size += ( Real ) ( NUMLINK + 6.0 * NPLAQ ) * sizeof ( complex ) ; FIELD_ALLOC ( DmuUmu , matrix ) ; FIELD_ALLOC_VEC ( Tr_Uinv , complex , NUMLINK ) ; FIELD_ALLOC_VEC ( Fmunu , matrix , NPLAQ ) ; FIELD_ALLOC_VEC ( Uinv , matrix , NUMLINK ) ; FIELD_ALLOC_VEC ( Udag_inv , matrix , NUMLINK ) ; FIELD_ALLOC_VEC ( UpsiU , matrix , NUMLINK ) ; FIELD_ALLOC_MAT_OFFDIAG ( plaqdet , complex , NUMLINK ) ; FIELD_ALLOC_MAT_OFFDIAG ( tempdet , complex , NUMLINK ) ; FIELD_ALLOC_MAT_OFFDIAG ( ZWstar , complex , NUMLINK ) ; # ifndef LINEAR_DET size += ( Real ) ( 2.0 * NPLAQ * sizeof ( complex ) ) ; FIELD_ALLOC_MAT_OFFDIAG ( tempZW , complex , NUMLINK ) ; # endif size += ( Real ) ( 3.0 * sizeof ( Twist_Fermion ) ) ; FIELD_ALLOC ( mpm , Twist_Fermion ) ; FIELD_ALLOC ( pm0 , Twist_Fermion ) ; FIELD_ALLOC ( rm , Twist_Fermion ) ; size += ( Real ) ( 3.0 * sizeof ( matrix ) ) ; size += ( Real ) ( sizeof ( Twist_Fermion ) ) ; FIELD_ALLOC ( tempmat , matrix ) ; FIELD_ALLOC ( tempmat2 , matrix ) ; FIELD_ALLOC ( staple , matrix ) ; FIELD_ALLOC ( tempTF , Twist_Fermion ) ; # ifdef CORR int j ; size += ( Real ) ( N_B * NUMLINK * sizeof ( matrix ) ) ; size += ( Real ) ( N_K * NUMLINK * NUMLINK * sizeof ( Real ) ) ; size += ( Real ) ( 2.0 * sizeof ( Kops ) ) ; for ( j = 0 ; j < N_B ; j ++ ) FIELD_ALLOC_VEC ( Ba [ j ] , matrix , NUMLINK ) ; for ( j = 0 ; j < N_K ; j ++ ) FIELD_ALLOC_MAT ( traceBB [ j ] , Real , NUMLINK , NUMLINK ) ; FIELD_ALLOC ( tempops , Kops ) ; FIELD_ALLOC ( tempops2 , Kops ) ; # endif # ifdef SMEAR size += ( Real ) ( NUMLINK * sizeof ( anti_hermitmat ) ) ; FIELD_ALLOC_VEC ( Q , anti_hermitmat , NUMLINK ) ; # endif # if defined ( EIG ) || defined ( PHASE ) size += ( Real ) ( 2.0 * sizeof ( Twist_Fermion ) ) ; FIELD_ALLOC ( src , Twist_Fermion ) ; FIELD_ALLOC ( res , Twist_Fermion ) ; # endif # if defined ( CHEB ) || defined ( MODE ) size += ( Real ) ( sizeof ( Twist_Fermion ) ) ; FIELD_ALLOC ( z_rand , Twist_Fermion ) ; # endif # ifdef MODE size += ( Real ) ( 5.0 * sizeof ( Twist_Fermion ) ) ; FIELD_ALLOC ( XPXSq , Twist_Fermion ) ; FIELD_ALLOC ( hX , Twist_Fermion ) ; FIELD_ALLOC ( dest , Twist_Fermion ) ; FIELD_ALLOC ( bj , Twist_Fermion ) ; FIELD_ALLOC ( bjp1 , Twist_Fermion ) ; # endif size *= sites_on_node ; node0_printf ( "Mallocing<S2SV_blank>%.1f<S2SV_blank>MBytes<S2SV_blank>per<S2SV_blank>core<S2SV_blank>for<S2SV_blank>fields\\n" , size / 1e6 ) ; # ifdef PHASE Nmatvecs = volume * 16 * DIMF * volume * 4 * DIMF ; size = ( Real ) ( volume * 16.0 * DIMF * 16.0 * DIMF * sizeof ( complex ) ) ; size *= sites_on_node ; node0_printf ( "Q<S2SV_blank>has<S2SV_blank>%d<S2SV_blank>columns<S2SV_blank>--><S2SV_blank>%li<S2SV_blank>matvecs<S2SV_blank>and<S2SV_blank>%.1f<S2SV_blank>MBytes<S2SV_blank>per<S2SV_blank>core..." , volume * 16 * DIMF , Nmatvecs , size / 1e6 ) ; # endif } | <S2SV_ModStart> ( ) { # ifdef TRUNCATED node0_printf ( "Gauge<S2SV_blank>links<S2SV_blank>truncated<S2SV_blank>to<S2SV_blank>SL(N,C)\\n" ) ; # endif |
3,325 | CWE-000 static bool ParserExpression ( ) { bool flag = true ; StackPtr stack = StackCreate ( ) ; NEXTTOKEN ; while ( token -> lexem != EOL && token -> lexem != DO && token -> lexem != THEN && token -> lexem != EOFILE ) { if ( ! ParserExpressionCheckError ( flag ) ) return false ; <S2SV_StartBug> if ( ! StackPush ( stack , token ) ) <S2SV_EndBug> printf ( "ERROR:<S2SV_blank>StackPush()<S2SV_blank>Failed\\n" ) ; if ( token -> lexem != LEFT_B && token -> lexem != RIGHT_B ) flag = ! flag ; NEXTTOKEN ; } if ( flag == true ) printf ( "ERROR\\n" ) ; else { StackPtr infixStack = ParserExpressionRevInfixToPrefix ( stack ) ; TokenPtr tokenToPrint ; while ( ( tokenToPrint = StackPop ( infixStack ) ) != NULL ) { printf ( "SEMCALL:<S2SV_blank>Expression<S2SV_blank>token:" ) ; AuxPrintToken ( tokenToPrint ) ; printf ( "\\n" ) ; free ( tokenToPrint -> name ) ; free ( tokenToPrint ) ; } StackDestroy ( infixStack ) ; } StackDestroy ( stack ) ; switch ( token -> lexem ) { case EOL : FUNCTIONCALL ( ParserStatement ) ; break ; case THEN : case DO : break ; case EOFILE : break ; default : return false ; } return true ; } | <S2SV_ModStart> return false ; TokenPtr newToken = CopyToken ( token ) ; <S2SV_ModStart> ( stack , newToken <S2SV_ModEnd> ) ) printf |
3,326 | CWE-000 static int try_to_wake_up ( struct task_struct * p , unsigned int state , int wake_flags ) { unsigned long flags ; int cpu , success = 0 ; unsigned long src_cpu ; smp_mb__before_spinlock ( ) ; raw_spin_lock_irqsave ( & p -> pi_lock , flags ) ; src_cpu = cpu = task_cpu ( p ) ; if ( ! ( p -> state & state ) ) goto out ; success = 1 ; if ( p -> on_rq && ttwu_remote ( p , wake_flags ) ) goto stat ; # ifdef CONFIG_SMP <S2SV_StartBug> while ( p -> on_cpu ) <S2SV_EndBug> cpu_relax ( ) ; smp_rmb ( ) ; p -> sched_contributes_to_load = ! ! task_contributes_to_load ( p ) ; p -> state = TASK_WAKING ; if ( p -> sched_class -> task_waking ) p -> sched_class -> task_waking ( p ) ; cpu = select_task_rq ( p , SD_BALANCE_WAKE , wake_flags ) ; src_cpu = task_cpu ( p ) ; if ( src_cpu != cpu ) { wake_flags |= WF_MIGRATED ; set_task_cpu ( p , cpu ) ; } # endif ttwu_queue ( p , cpu ) ; stat : ttwu_stat ( p , cpu , wake_flags ) ; out : raw_spin_unlock_irqrestore ( & p -> pi_lock , flags ) ; if ( task_notify_on_migrate ( p ) ) { struct migration_notify_data mnd ; mnd . src_cpu = src_cpu ; mnd . dest_cpu = cpu ; mnd . load = pct_task_load ( p ) ; if ( ( src_cpu != cpu ) || ( mnd . load > sysctl_sched_wakeup_load_threshold ) ) atomic_notifier_call_chain ( & migration_notifier_head , 0 , ( void * ) & mnd ) ; } return success ; } | <S2SV_ModStart> # ifdef CONFIG_SMP smp_rmb ( ) ; |
3,327 | CWE-000 static void create_udata ( struct uverbs_attr_bundle * ctx , struct ib_udata * udata ) { const struct uverbs_attr * uhw_in = uverbs_attr_get ( ctx , UVERBS_UHW_IN ) ; const struct uverbs_attr * uhw_out = uverbs_attr_get ( ctx , UVERBS_UHW_OUT ) ; if ( ! IS_ERR ( uhw_in ) ) { <S2SV_StartBug> udata -> inbuf = uhw_in -> ptr_attr . ptr ; <S2SV_EndBug> udata -> inlen = uhw_in -> ptr_attr . len ; } else { udata -> inbuf = NULL ; udata -> inlen = 0 ; } if ( ! IS_ERR ( uhw_out ) ) { udata -> outbuf = uhw_out -> ptr_attr . ptr ; udata -> outlen = uhw_out -> ptr_attr . len ; } else { udata -> outbuf = NULL ; udata -> outlen = 0 ; } } | <S2SV_ModStart> { udata -> inlen = uhw_in -> ptr_attr . len ; if ( uverbs_attr_ptr_is_inline ( uhw_in ) ) udata -> inbuf = & uhw_in -> uattr -> data ; else udata -> <S2SV_ModStart> ptr_attr . ptr <S2SV_ModEnd> ; } else |
3,328 | CWE-000 void jam_set_timer ( jamstate_t * js , char * actid , int tval ) <S2SV_StartBug> { <S2SV_EndBug> activity_thread_t * athr = activity_getbyid ( js -> atable , actid ) ; if ( athr != NULL ) timer_add_event ( js -> maintimer , tval , 0 , actid , tcallback , athr ) ; else printf ( "ERROR!<S2SV_blank>Unable<S2SV_blank>to<S2SV_blank>find<S2SV_blank>the<S2SV_blank>activity<S2SV_blank>to<S2SV_blank>trigger<S2SV_blank>at<S2SV_blank>timer<S2SV_blank>event.\\n" ) ; } | <S2SV_ModStart> tval ) { printf ( "JAM-set-timer<S2SV_blank>for<S2SV_blank>actid<S2SV_blank>..<S2SV_blank>%s\\n" , actid ) ; |
3,329 | CWE-000 static int misc_vaapi_build_filter_params ( AVFilterContext * avctx ) { MiscVAAPIContext * ctx = avctx -> priv ; VAStatus vas ; VAProcFilterCap denoise_caps ; VAProcFilterCap sharpness_caps ; <S2SV_StartBug> unsigned int num_denoise_caps = 1 ; <S2SV_EndBug> <S2SV_StartBug> unsigned int num_sharpness_caps = 1 ; <S2SV_EndBug> VAProcFilterParameterBuffer denoise ; VAProcFilterParameterBuffer sharpness ; int err = 0 ; memset ( & denoise_caps , 0 , sizeof ( denoise_caps ) ) ; memset ( & sharpness_caps , 0 , sizeof ( sharpness_caps ) ) ; if ( ctx -> denoise != - 1 ) { vas = vaQueryVideoProcFilterCaps ( ctx -> vpp_ctx -> hwctx -> display , ctx -> vpp_ctx -> va_context , VAProcFilterNoiseReduction , & denoise_caps , & num_denoise_caps ) ; if ( vas != VA_STATUS_SUCCESS ) { av_log ( ctx , AV_LOG_ERROR , "Failed<S2SV_blank>to<S2SV_blank>query<S2SV_blank>denoise<S2SV_blank>caps<S2SV_blank>" "context:<S2SV_blank>%d<S2SV_blank>(%s).\\n" , vas , vaErrorStr ( vas ) ) ; err = AVERROR ( EIO ) ; return err ; } denoise . type = VAProcFilterNoiseReduction ; denoise . value = av_clip ( ctx -> denoise , denoise_caps . range . min_value , denoise_caps . range . max_value ) ; err = ff_vaapi_vpp_make_param_buffer ( ctx -> vpp_ctx , VAProcFilterParameterBufferType , & denoise , sizeof ( denoise ) ) ; if ( err < 0 ) return err ; } if ( ctx -> sharpness != - 1 ) { vas = vaQueryVideoProcFilterCaps ( ctx -> vpp_ctx -> hwctx -> display , ctx -> vpp_ctx -> va_context , VAProcFilterSharpening , & sharpness_caps , & num_sharpness_caps ) ; if ( vas != VA_STATUS_SUCCESS ) { av_log ( ctx , AV_LOG_ERROR , "Failed<S2SV_blank>to<S2SV_blank>query<S2SV_blank>sharpness<S2SV_blank>caps<S2SV_blank>" "context:<S2SV_blank>%d<S2SV_blank>(%s).\\n" , vas , vaErrorStr ( vas ) ) ; err = AVERROR ( EIO ) ; return err ; } sharpness . type = VAProcFilterSharpening ; sharpness . value = av_clip ( ctx -> sharpness , sharpness_caps . range . min_value , sharpness_caps . range . max_value ) ; err = ff_vaapi_vpp_make_param_buffer ( ctx -> vpp_ctx , VAProcFilterParameterBufferType , & sharpness , sizeof ( sharpness ) ) ; if ( err < 0 ) return err ; } return 0 ; } | <S2SV_ModStart> VAProcFilterCap sharpness_caps ; uint32_t <S2SV_ModEnd> num_denoise_caps = 1 <S2SV_ModStart> = 1 ; uint32_t <S2SV_ModEnd> num_sharpness_caps = 1 |
3,330 | CWE-000 int bloom_init ( struct bloom * bloom , int entries , double error ) { bloom -> ready = 0 ; <S2SV_StartBug> if ( entries < 1 || error == 0 ) { <S2SV_EndBug> return 1 ; } bloom -> entries = entries ; bloom -> error = error ; double num = log ( bloom -> error ) ; double denom = 0.480453013918201 ; bloom -> bpe = - ( num / denom ) ; double dentries = ( double ) entries ; bloom -> bits = ( int ) ( dentries * bloom -> bpe ) ; if ( bloom -> bits % 8 ) { bloom -> bytes = ( bloom -> bits / 8 ) + 1 ; } else { bloom -> bytes = bloom -> bits / 8 ; } bloom -> hashes = ( int ) ceil ( 0.693147180559945 * bloom -> bpe ) ; bloom -> bf = ( unsigned char * ) calloc ( bloom -> bytes , sizeof ( unsigned char ) ) ; if ( bloom -> bf == NULL ) { return 1 ; } bloom -> ready = 1 ; return 0 ; } | <S2SV_ModStart> ( entries < 1000 <S2SV_ModEnd> || error == |
3,331 | CWE-000 <S2SV_StartBug> static const char * alloc_listener ( process_rec * process , char * addr , <S2SV_EndBug> apr_port_t port , const char * proto , void * slave ) { <S2SV_StartBug> ap_listen_rec * * walk , * last ; <S2SV_EndBug> apr_status_t status ; apr_sockaddr_t * sa ; <S2SV_StartBug> int found_listener = 0 ; <S2SV_EndBug> for ( walk = & old_listeners ; * walk ; ) { sa = ( * walk ) -> bind_addr ; if ( sa ) { ap_listen_rec * new ; apr_port_t oldport ; oldport = sa -> port ; if ( port == oldport && ( ( ! addr && ! sa -> hostname ) || ( ( addr && sa -> hostname ) && ! strcmp ( sa -> hostname , addr ) ) ) ) { new = * walk ; * walk = new -> next ; new -> next = ap_listeners ; ap_listeners = new ; found_listener = 1 ; continue ; } } walk = & ( * walk ) -> next ; } if ( found_listener ) { if ( ap_listeners -> slave != slave ) { return "Cannot<S2SV_blank>define<S2SV_blank>a<S2SV_blank>slave<S2SV_blank>on<S2SV_blank>the<S2SV_blank>same<S2SV_blank>IP:port<S2SV_blank>as<S2SV_blank>a<S2SV_blank>Listener" ; } return NULL ; } if ( ( status = apr_sockaddr_info_get ( & sa , addr , APR_UNSPEC , port , 0 , process -> pool ) ) != APR_SUCCESS ) { ap_log_perror ( APLOG_MARK , APLOG_CRIT , status , process -> pool , APLOGNO ( 00077 ) "alloc_listener:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>up<S2SV_blank>sockaddr<S2SV_blank>for<S2SV_blank>%s" , addr ) ; return "Listen<S2SV_blank>setup<S2SV_blank>failed" ; } last = ap_listeners ; while ( last && last -> next ) { last = last -> next ; } while ( sa ) { ap_listen_rec * new ; new = apr_palloc ( process -> pool , sizeof ( ap_listen_rec ) ) ; new -> active = 0 ; new -> next = 0 ; new -> bind_addr = sa ; new -> protocol = apr_pstrdup ( process -> pool , proto ) ; sa = sa -> next ; status = apr_socket_create ( & new -> sd , new -> bind_addr -> family , SOCK_STREAM , 0 , process -> pool ) ; # if APR_HAVE_IPV6 if ( status != APR_SUCCESS && ! addr && new -> bind_addr -> family == APR_INET6 ) { continue ; } # endif if ( status != APR_SUCCESS ) { ap_log_perror ( APLOG_MARK , APLOG_CRIT , status , process -> pool , APLOGNO ( 00078 ) "alloc_listener:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>a<S2SV_blank>socket<S2SV_blank>for<S2SV_blank>%s" , addr ) ; return "Listen<S2SV_blank>setup<S2SV_blank>failed" ; } if ( last == NULL ) { ap_listeners = last = new ; } else { last -> next = new ; last = new ; } new -> slave = slave ; } return NULL ; } | <S2SV_ModStart> * process , const <S2SV_ModStart> { ap_listen_rec * <S2SV_ModEnd> last ; apr_status_t <S2SV_ModStart> * sa ; if ( find_listeners ( & ap_listeners , NULL , addr , port ) ) { return "Cannot<S2SV_blank>define<S2SV_blank>multiple<S2SV_blank>Listeners<S2SV_blank>on<S2SV_blank>the<S2SV_blank>same<S2SV_blank>IP:port" ; } if ( find_listeners ( & old_listeners , & ap_listeners , addr , port ) <S2SV_ModEnd> ) { if |
3,332 | CWE-000 static int lwm2m_callback ( lwm2m_object_instance_t * object , lwm2m_context_t * ctx ) { const ipso_sensor_t * sensor ; ipso_sensor_value_t * value ; value = ( ipso_sensor_value_t * ) object ; sensor = value -> sensor ; if ( ctx -> level == 1 ) { return 0 ; } if ( ctx -> level == 2 ) { return 0 ; } if ( ctx -> level == 3 ) { if ( ctx -> operation == LWM2M_OP_READ ) { switch ( ctx -> resource_id ) { case IPSO_SENSOR_UNIT : if ( sensor -> unit != NULL ) { lwm2m_object_write_string ( ctx , sensor -> unit , strlen ( sensor -> unit ) ) ; } break ; case IPSO_SENSOR_MAX_RANGE : lwm2m_object_write_float32fix ( ctx , ( sensor -> max_range * 1024 ) / 1000 , 10 ) ; break ; case IPSO_SENSOR_MIN_RANGE : lwm2m_object_write_float32fix ( ctx , ( sensor -> min_range * 1024 ) / 1000 , 10 ) ; break ; case IPSO_SENSOR_MAX_VALUE : lwm2m_object_write_float32fix ( ctx , ( value -> max_value * 1024 ) / 1000 , 10 ) ; break ; case IPSO_SENSOR_MIN_VALUE : lwm2m_object_write_float32fix ( ctx , ( value -> min_value * 1024 ) / 1000 , 10 ) ; break ; case IPSO_SENSOR_VALUE : if ( sensor -> get_value_in_millis != NULL ) { int32_t v ; if ( sensor -> get_value_in_millis ( & v ) == LWM2M_STATUS_OK ) { <S2SV_StartBug> update_last_value ( value , v ) ; <S2SV_EndBug> lwm2m_object_write_float32fix ( ctx , ( value -> last_value * 1024 ) / 1000 , 10 ) ; } } break ; default : return 0 ; } } else if ( ctx -> operation == LWM2M_OP_EXECUTE ) { if ( ctx -> resource_id == IPSO_SENSOR_RESET_MINMAX ) { value -> min_value = value -> last_value ; value -> max_value = value -> last_value ; } } } return 1 ; } | <S2SV_ModStart> value , v , 0 |
3,333 | CWE-000 struct page * read_swap_cache_async ( swp_entry_t entry , gfp_t gfp_mask , struct vm_area_struct * vma , unsigned long addr ) { struct page * found_page , * new_page = NULL ; int err ; do { found_page = find_get_page ( & swapper_space , entry . val ) ; if ( found_page ) break ; if ( ! new_page ) { new_page = alloc_page_vma ( gfp_mask , vma , addr ) ; if ( ! new_page ) break ; } <S2SV_StartBug> err = radix_tree_preload ( gfp_mask & GFP_KERNEL ) ; <S2SV_EndBug> if ( err ) break ; err = swapcache_prepare ( entry ) ; if ( err == - EEXIST ) { radix_tree_preload_end ( ) ; cond_resched ( ) ; continue ; } if ( err ) { radix_tree_preload_end ( ) ; break ; } __set_page_locked ( new_page ) ; SetPageSwapBacked ( new_page ) ; err = __add_to_swap_cache ( new_page , entry ) ; if ( likely ( ! err ) ) { radix_tree_preload_end ( ) ; lru_cache_add_anon ( new_page ) ; swap_readpage ( new_page ) ; return new_page ; } radix_tree_preload_end ( ) ; ClearPageSwapBacked ( new_page ) ; __clear_page_locked ( new_page ) ; swapcache_free ( entry , NULL ) ; } while ( err != - ENOMEM ) ; if ( new_page ) page_cache_release ( new_page ) ; return found_page ; } | <S2SV_ModStart> } err = radix_tree_maybe_preload <S2SV_ModEnd> ( gfp_mask & |
3,334 | CWE-000 lx_memery_Obj * lx_memery_Obj_new ( ) { lxMemeryContext * lxMCtx = lxOSMalloc ( sizeof ( lxMemeryContext ) ) ; if ( ! lxMCtx ) { LOG_ERROR_PRINT ( "init<S2SV_blank>lxMemeryContext<S2SV_blank>manager<S2SV_blank>faild\\n" ) ; return NULL ; } lxMCtx -> basePtr = lxOSMalloc ( MEMERY_POOL_SIZE ) ; if ( ! lxMCtx -> basePtr ) { lxOSFree ( lxMCtx ) ; return NULL ; } lxMCtx -> mLXLOBJ = lxlist_Obj_new ( ) ; if ( ! lxMCtx -> mLXLOBJ ) { lxOSFree ( lxMCtx -> basePtr ) ; lxOSFree ( lxMCtx ) ; return NULL ; } lxMCtx -> mlock = pthread_resource_lock_new ( ) ; if ( ! lxMCtx -> mlock ) { lxOSFree ( lxMCtx -> basePtr ) ; lxOSFree ( lxMCtx ) ; lxlist_Obj_delete ( lxMCtx -> mLXLOBJ ) ; return NULL ; } lxMCtx -> mLXMOBJ . lxfree = lxfree ; lxMCtx -> mLXMOBJ . lxmalloc = lxmalloc ; lxMCtx -> mLXMOBJ . lxrealloc = lxrealloc ; lxMCtx -> FreeSpace = lxMCtx -> basePtr ; lxMCtx -> FreeSpace -> mBlockHead . blockSize = MEMERY_POOL_SIZE - sizeof ( lxMemeryBlock_t ) - sizeof ( lxMemeryBlock_Tail_t ) ; lxMCtx -> FreeSpace -> mBlockHead . tag = MEMERYBLOCK_STATUS_FREE ; LXLIST_INIT ( lxMCtx -> mLXLOBJ , & lxMCtx -> FreeSpace -> mBlockHead . lxnode ) ; lxMCtx -> FreeSpace -> mBlockTail = ( char * ) lxMCtx -> FreeSpace + MEMERY_POOL_SIZE - sizeof ( lxMemeryBlock_Tail_t ) ; <S2SV_StartBug> lxMCtx -> FreeSpace -> mBlockTail -> tag = MEMERYBLOCK_STATUS_FREE ; <S2SV_EndBug> lxMCtx -> FreeSpace -> mBlockTail -> uplink = lxMCtx -> FreeSpace ; lxMCtx -> FreeSpace -> mDataSpace = ( char * ) lxMCtx -> FreeSpace + sizeof ( lxMemeryBlock_t ) ; return & lxMCtx -> mLXMOBJ ; } | <S2SV_ModStart> lxMemeryBlock_Tail_t ) ; LOG_ERROR_PRINT ( "[%p][%p]\\n" , <S2SV_ModStart> FreeSpace -> mBlockTail , ( char * ) lxMCtx -> FreeSpace + MEMERY_POOL_SIZE ) ; lxMCtx -> FreeSpace -> mBlockTail |
3,335 | CWE-000 static void * rmem_server ( void * args ) { int dma ; int inbox ; int inportal ; char pathname [ 16 ] ; dma = ( ( int * ) args ) [ 0 ] ; sprintf ( pathname , "/rmem%d" , dma ) ; pthread_mutex_lock ( & lock ) ; inbox = mailbox_create ( pathname ) ; inportal = portal_create ( pathname ) ; pthread_mutex_unlock ( & lock ) ; pthread_barrier_wait ( & barrier ) ; while ( 1 ) { struct rmem_message msg ; mailbox_read ( inbox , & msg ) ; switch ( msg . op ) { case RMEM_WRITE : <S2SV_StartBug> rmem_write ( input , msg . source , msg . blknum , msg . size ) ; <S2SV_EndBug> break ; case RMEM_READ : <S2SV_StartBug> rmem_read ( output , msg . source , msg . blknum , msg . size ) ; <S2SV_EndBug> break ; case RMEM_LOCK : rmem_lock ( msg . source , msg . blknum ) ; break ; case RMEM_UNLOCK : <S2SV_StartBug> rmem_unlock ( msg . source , msg . blknum ) <S2SV_EndBug> break ; } } pthread_mutex_lock ( & lock ) ; portal_unlink ( inportal ) ; mailbox_unlink ( inbox ) ; pthread_mutex_unlock ( & lock ) ; return ( NULL ) ; } | <S2SV_ModStart> : rmem_write ( inportal <S2SV_ModEnd> , msg . <S2SV_ModStart> : rmem_read ( <S2SV_ModEnd> msg . source <S2SV_ModStart> . blknum ) ; break ; default : |
3,336 | CWE-000 int curse_menu ( struct object * obj ) { menu_iter menu_f = { 0 , 0 , get_curse_display , get_curse_action , 0 } ; struct menu * m = menu_new ( MN_SKIN_SCROLL , & menu_f ) ; int row ; unsigned int length = 0 ; int i , count = 0 ; size_t array_size = z_info -> curse_max * sizeof ( struct curse_menu_data ) ; struct curse_menu_data * available = mem_zalloc ( array_size ) ; static region area = { 20 , 1 , - 1 , - 2 } ; for ( i = 1 ; i < z_info -> curse_max ; i ++ ) { <S2SV_StartBug> if ( obj -> curses [ i ] . power && player_knows_curse ( player , i ) ) { <S2SV_EndBug> available [ count ] . index = i ; available [ count ] . power = obj -> curses [ i ] . power ; length = MAX ( length , strlen ( curses [ i ] . name ) + 13 ) ; count ++ ; } } if ( ! count ) { mem_free ( available ) ; return 0 ; } menu_setpriv ( m , count , available ) ; m -> header = "<S2SV_blank>Remove<S2SV_blank>which<S2SV_blank>curse?" ; m -> selections = lower_case ; m -> flags = ( MN_PVT_TAGS ) ; m -> browse_hook = curse_menu_browser ; selection = 0 ; area . page_rows = m -> count + 2 ; area . row = 1 ; area . col = ( Term -> wid - 1 - length ) / 2 ; if ( area . col <= 3 ) area . col = 0 ; area . width = MAX ( length + 1 , strlen ( m -> header ) ) ; for ( row = area . row ; row < area . row + area . page_rows ; row ++ ) prt ( "" , row , MAX ( 0 , area . col - 1 ) ) ; menu_layout ( m , & area ) ; menu_select ( m , 0 , true ) ; mem_free ( available ) ; mem_free ( m ) ; return selection ; } | <S2SV_ModStart> { if ( ( obj -> known -> <S2SV_ModEnd> curses [ i <S2SV_ModStart> ] . power > 0 ) && ( obj -> known -> curses [ i ] . power < 100 ) && <S2SV_ModEnd> player_knows_curse ( player |
3,337 | CWE-000 static void bldrCoreProcessGetInfo ( APDU_CORE_COMMAND_APDU * commandAPDU , APDU_CORE_RESPONSE_APDU * responseAPDU ) { uint16_t sw ; uint32_t firmwareVersion ; uint32_t fileSystemVersion ; uint32_t bootloaderVersion ; uint32_t serialNumber ; uint16_t fileSystemUpdateInterrupted ; uint16_t firmwareValid ; uint16_t bootloaderValid ; if ( commandAPDU -> lcPresent != APDU_FALSE ) { sw = APDU_CORE_SW_WRONG_LENGTH ; goto END ; } if ( commandAPDU -> p1p2 != BLDR_CORE_P1P2_GET_INFO ) { sw = APDU_CORE_SW_WRONG_P1P2 ; goto END ; } if ( context . expectedCommand != BLDR_CORE_CONTEXT_EXPECTED_COMMAND_SET_IMAGE_INFO_OR_MISC_COMMANDS ) { sw = APDU_CORE_SW_CONDITIONS_NOT_SATISFIED ; goto END ; } bldrHalGetSerialNumber ( & serialNumber ) ; bldrHalGetFirmwareVersion ( & firmwareVersion ) ; bldrHalGetFileSystemVersion ( & fileSystemVersion ) ; bldrHalGetBootloaderVersion ( & bootloaderVersion ) ; bldrHalIsUpdateInterrupted ( & fileSystemUpdateInterrupted ) ; # if defined ( FIRMWARE ) firmwareValid = BLDR_TRUE ; # elif defined ( BOOTLOADER ) bldrHalIsFirmwareValid ( & firmwareValid ) ; # endif # if defined ( FIRMWARE ) bldrHalIsBootloaderValid ( & bootloaderValid ) ; # elif defined ( BOOTLOADER ) bootloaderValid = BLDR_TRUE ; # endif responseAPDU -> data [ 0 ] = BLDR_HIBYTE ( BLDR_HIWORD ( DEVICE_ID ) ) ; responseAPDU -> data [ 1 ] = BLDR_LOBYTE ( BLDR_HIWORD ( DEVICE_ID ) ) ; responseAPDU -> data [ 2 ] = BLDR_HIBYTE ( BLDR_LOWORD ( DEVICE_ID ) ) ; responseAPDU -> data [ 3 ] = BLDR_LOBYTE ( BLDR_LOWORD ( DEVICE_ID ) ) ; responseAPDU -> data [ 4 ] = BLDR_HIBYTE ( BLDR_HIWORD ( serialNumber ) ) ; responseAPDU -> data [ 5 ] = BLDR_LOBYTE ( BLDR_HIWORD ( serialNumber ) ) ; responseAPDU -> data [ 6 ] = BLDR_HIBYTE ( BLDR_LOWORD ( serialNumber ) ) ; responseAPDU -> data [ 7 ] = BLDR_LOBYTE ( BLDR_LOWORD ( serialNumber ) ) ; responseAPDU -> data [ 8 ] = BLDR_HIBYTE ( BLDR_HIWORD ( firmwareVersion ) ) ; responseAPDU -> data [ 9 ] = BLDR_LOBYTE ( BLDR_HIWORD ( firmwareVersion ) ) ; responseAPDU -> data [ 10 ] = BLDR_HIBYTE ( BLDR_LOWORD ( firmwareVersion ) ) ; responseAPDU -> data [ 11 ] = BLDR_LOBYTE ( BLDR_LOWORD ( firmwareVersion ) ) ; responseAPDU -> data [ 12 ] = BLDR_HIBYTE ( BLDR_HIWORD ( fileSystemVersion ) ) ; responseAPDU -> data [ 13 ] = BLDR_LOBYTE ( BLDR_HIWORD ( fileSystemVersion ) ) ; responseAPDU -> data [ 14 ] = BLDR_HIBYTE ( BLDR_LOWORD ( fileSystemVersion ) ) ; responseAPDU -> data [ 15 ] = BLDR_LOBYTE ( BLDR_LOWORD ( fileSystemVersion ) ) ; responseAPDU -> data [ 16 ] = BLDR_HIBYTE ( BLDR_HIWORD ( bootloaderVersion ) ) ; responseAPDU -> data [ 17 ] = BLDR_LOBYTE ( BLDR_HIWORD ( bootloaderVersion ) ) ; responseAPDU -> data [ 18 ] = BLDR_HIBYTE ( BLDR_LOWORD ( bootloaderVersion ) ) ; responseAPDU -> data [ 19 ] = BLDR_LOBYTE ( BLDR_LOWORD ( bootloaderVersion ) ) ; if ( fileSystemUpdateInterrupted == BLDR_TRUE ) { <S2SV_StartBug> responseAPDU -> data [ 10 ] = 1 ; <S2SV_EndBug> } else { responseAPDU -> data [ 20 ] = 0 ; } if ( firmwareValid == BLDR_TRUE ) { responseAPDU -> data [ 21 ] = 1 ; } else { responseAPDU -> data [ 21 ] = 0 ; } if ( bootloaderValid == BLDR_TRUE ) { responseAPDU -> data [ 22 ] = 1 ; } else { responseAPDU -> data [ 22 ] = 0 ; } responseAPDU -> dataLength = 23 ; sw = APDU_CORE_SW_NO_ERROR ; END : if ( sw != APDU_CORE_SW_NO_ERROR ) { bldrCoreInitContext ( ) ; } responseAPDU -> sw = sw ; } | <S2SV_ModStart> -> data [ 20 <S2SV_ModEnd> ] = 1 |
3,338 | CWE-000 t_str * handle_str_type ( t_format info , va_list args ) { char * str ; t_str * result ; <S2SV_StartBug> if ( info . len_flag == fl_l ) <S2SV_EndBug> <S2SV_StartBug> str = build_utf8 ( ( wchar_t * ) va_arg ( args , wchar_t * ) ) ; <S2SV_EndBug> else str = ft_strdup ( ( char * ) va_arg ( args , char * ) ) ; <S2SV_StartBug> if ( ! str || ! ( result = ( t_str * ) malloc ( sizeof ( t_str ) ) ) ) <S2SV_EndBug> <S2SV_StartBug> return ( str_to_t_str ( "(null)" ) ) ; <S2SV_EndBug> if ( info . prec != - 1 && ( t_u64 ) info . prec < ft_strlen ( str ) ) { if ( info . len_flag == fl_l ) while ( ( t_u8 ) str [ info . prec ] >> 6 == ( t_u8 ) 0x2 ) -- info . prec ; str [ info . prec ] = '\\0' ; } if ( info . width != - 1 && info . width > ( int ) ft_strlen ( str ) ) ( info . flags & FL_MINUS ) ? ft_strpad_right_inplace ( & str , '<S2SV_blank>' , info . width - ft_strlen ( str ) ) : ft_strpad_left_inplace ( & str , '<S2SV_blank>' , info . width - ft_strlen ( str ) ) ; result -> data = info . type_char == 'r' ? ft_str_toprint ( str ) : ft_strdup ( str ) ; ft_strdel ( & str ) ; result -> len = ft_strlen ( result -> data ) ; return ( result ) ; } | <S2SV_ModStart> * result ; str = <S2SV_ModEnd> info . len_flag <S2SV_ModStart> len_flag == fl_l ? <S2SV_ModEnd> build_utf8 ( ( <S2SV_ModStart> * ) ) : <S2SV_ModEnd> ft_strdup ( ( <S2SV_ModStart> ! str || ft_strequ ( str , "MB_CUR_MAX_ERROR" ) ) return ( str_to_t_str ( str ? NULL : "(null)" ) ) ; if ( <S2SV_ModStart> ) return ( NULL <S2SV_ModEnd> ) ; if |
3,339 | CWE-000 static int fts5ExprSynonymPoslist ( Fts5ExprTerm * pTerm , i64 iRowid , int * pbDel , u8 * * pa , int * pn ) { Fts5PoslistWriter writer = { 0 } ; Fts5PoslistReader aStatic [ 4 ] ; Fts5PoslistReader * aIter = aStatic ; int nIter = 0 ; int nAlloc = 4 ; int rc = SQLITE_OK ; Fts5ExprTerm * p ; assert ( pTerm -> pSynonym ) ; for ( p = pTerm ; p ; p = p -> pSynonym ) { Fts5IndexIter * pIter = p -> pIter ; if ( sqlite3Fts5IterEof ( pIter ) == 0 && sqlite3Fts5IterRowid ( pIter ) == iRowid ) { const u8 * a ; int n ; i64 dummy ; rc = sqlite3Fts5IterPoslist ( pIter , & a , & n , & dummy ) ; if ( rc != SQLITE_OK ) goto synonym_poslist_out ; if ( nIter == nAlloc ) { int nByte = sizeof ( Fts5PoslistReader ) * nAlloc * 2 ; Fts5PoslistReader * aNew = ( Fts5PoslistReader * ) sqlite3_malloc ( nByte ) ; if ( aNew == 0 ) { rc = SQLITE_NOMEM ; goto synonym_poslist_out ; } memcpy ( aNew , aIter , sizeof ( Fts5PoslistReader ) * nIter ) ; nAlloc = nAlloc * 2 ; aIter = aNew ; } <S2SV_StartBug> if ( sqlite3Fts5PoslistReaderInit ( - 1 , a , n , & aIter [ nIter ] ) == 0 ) { <S2SV_EndBug> nIter ++ ; <S2SV_StartBug> } <S2SV_EndBug> } } assert ( * pbDel == 0 ) ; if ( nIter == 1 ) { * pa = ( u8 * ) aIter [ 0 ] . a ; * pn = aIter [ 0 ] . n ; } else { Fts5PoslistWriter writer = { 0 } ; Fts5Buffer buf = { 0 , 0 , 0 } ; i64 iPrev = - 1 ; while ( 1 ) { int i ; i64 iMin = FTS5_LARGEST_INT64 ; for ( i = 0 ; i < nIter ; i ++ ) { if ( aIter [ i ] . bEof == 0 ) { if ( aIter [ i ] . iPos == iPrev ) { if ( sqlite3Fts5PoslistReaderNext ( & aIter [ i ] ) ) continue ; } if ( aIter [ i ] . iPos < iMin ) { iMin = aIter [ i ] . iPos ; } } } if ( iMin == FTS5_LARGEST_INT64 || rc != SQLITE_OK ) break ; rc = sqlite3Fts5PoslistWriterAppend ( & buf , & writer , iMin ) ; iPrev = iMin ; } if ( rc ) { sqlite3_free ( buf . p ) ; } else { * pa = buf . p ; * pn = buf . n ; * pbDel = 1 ; } } synonym_poslist_out : if ( aIter != aStatic ) sqlite3_free ( aIter ) ; return rc ; } | <S2SV_ModStart> aNew ; } <S2SV_ModEnd> sqlite3Fts5PoslistReaderInit ( - <S2SV_ModStart> nIter ] ) ; assert ( aIter [ nIter ] . bEof == 0 ) ; <S2SV_ModEnd> nIter ++ ; <S2SV_ModStart> nIter ++ ; <S2SV_ModEnd> } } assert |
3,340 | CWE-000 int main ( ) { pm_switch_to_osc0 ( & AVR32_PM , FOSC0 , OSC0_STARTUP ) ; initLED ( ) ; initBUTTON ( ) ; initUSART ( ) ; display_init ( ) ; <S2SV_StartBug> nQueue = 0 ; <S2SV_EndBug> Disable_global_interrupt ( ) ; INTC_init_interrupts ( ) ; INTC_register_interrupt ( & readana , AVR32_USART1_IRQ , AVR32_INTC_INT0 ) ; ( & AVR32_USART1 ) -> IER . rxrdy = 1 ; Enable_global_interrupt ( ) ; vSemaphoreCreateBinary ( xSemaphore ) ; if ( xSemaphore != NULL ) { writeUSART ( "Semaphore<S2SV_blank>created\\r\\n" ) ; } sizeQ = 8 ; Qhandle = xQueueCreate ( sizeQ , 1 ) ; xTaskCreate ( Reader , "producer" , configMINIMAL_STACK_SIZE , NULL , tskIDLE_PRIORITY + 1 , & pHandle ) ; vTaskStartScheduler ( ) ; return 0 ; } | <S2SV_ModStart> ) ; nQueue = 0 ; charSum |
3,341 | CWE-000 double ffplay_get_stream_curtime ( void ) { if ( m_curstream ) return get_master_clock ( m_curstream ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> m_curstream ) ; return 0.0 ; |
3,342 | CWE-000 static void fill_seq_with_data ( Relation rel , HeapTuple tuple ) { Buffer buf ; Page page ; sequence_magic * sm ; OffsetNumber offnum ; buf = ReadBuffer ( rel , P_NEW ) ; Assert ( BufferGetBlockNumber ( buf ) == 0 ) ; page = BufferGetPage ( buf ) ; PageInit ( page , BufferGetPageSize ( buf ) , sizeof ( sequence_magic ) , 0 , PD_DEFAULT_INIT_TRANS ) ; sm = ( sequence_magic * ) PageGetSpecialPointer ( page ) ; sm -> magic = SEQ_MAGIC ; LockBuffer ( buf , BUFFER_LOCK_EXCLUSIVE ) ; <S2SV_StartBug> HeapTupleHeaderSetXmin ( tuple -> t_data , FrozenTransactionId ) ; <S2SV_EndBug> HeapTupleHeaderSetXminFrozen ( tuple -> t_data ) ; HeapTupleHeaderSetCmin ( tuple -> t_data , FirstCommandId ) ; HeapTupleHeaderSetXmax ( tuple -> t_data , InvalidTransactionId ) ; tuple -> t_data -> t_infomask |= HEAP_XMAX_INVALID ; ItemPointerSet ( & tuple -> t_data -> t_ctid , 0 , FirstOffsetNumber ) ; if ( RelationNeedsWAL ( rel ) ) GetTopTransactionId ( ) ; START_CRIT_SECTION ( ) ; MarkBufferDirty ( buf ) ; offnum = PageAddItem ( page , ( Item ) tuple -> t_data , tuple -> t_len , InvalidOffsetNumber , false , false ) ; if ( offnum != FirstOffsetNumber ) elog ( ERROR , "failed<S2SV_blank>to<S2SV_blank>add<S2SV_blank>sequence<S2SV_blank>tuple<S2SV_blank>to<S2SV_blank>page" ) ; if ( RelationNeedsWAL ( rel ) ) { xl_seq_rec xlrec ; XLogRecPtr recptr ; XLogBeginInsert ( ) ; XLogRegisterBuffer ( 0 , buf , REGBUF_WILL_INIT ) ; xlrec . node = rel -> rd_node ; XLogRegisterData ( ( char * ) & xlrec , sizeof ( xl_seq_rec ) ) ; XLogRegisterData ( ( char * ) tuple -> t_data , tuple -> t_len ) ; recptr = XLogInsert ( RM_SEQ_ID , XLOG_SEQ_LOG ) ; PageSetLSN ( page , recptr ) ; } END_CRIT_SECTION ( ) ; UnlockReleaseBuffer ( buf ) ; } | <S2SV_ModStart> BUFFER_LOCK_EXCLUSIVE ) ; HeapTupleHeaderSetXactNumber <S2SV_ModEnd> ( tuple -> <S2SV_ModStart> -> t_data , 0 <S2SV_ModEnd> ) ; if |
3,343 | CWE-000 static void * task1 ( void * data ) { for ( int i = 0 ; i < 1000 ; i ++ ) { printk ( "task1\\n" ) ; <S2SV_StartBug> for ( volatile int j = 0 ; j < 100000 ; j ++ ) ; <S2SV_EndBug> } } | <S2SV_ModStart> ; j < 10000 <S2SV_ModEnd> ; j ++ |
3,344 | CWE-000 int main ( void ) { <S2SV_StartBug> int cp [ 3 ] = { 119128 , 119141 , 119153 } ; <S2SV_EndBug> int cp_elems = 3 ; get_collation_elements ( cp , cp_elems ) ; return 0 ; } | <S2SV_ModStart> ] = { 4019 , 3953 , 3968 <S2SV_ModEnd> } ; int |
3,345 | CWE-000 void * iot_worker ( void * data ) { iot_conf_t * conf = NULL ; xlator_t * this = NULL ; call_stub_t * stub = NULL ; struct timespec sleep_till = { 0 , } ; int ret = 0 ; int pri = - 1 ; gf_boolean_t bye = _gf_false ; conf = data ; this = conf -> this ; THIS = this ; for ( ; ; ) { pthread_mutex_lock ( & conf -> mutex ) ; { if ( pri != - 1 ) { conf -> ac_iot_count [ pri ] -- ; pri = - 1 ; } <S2SV_StartBug> while ( conf -> queue_size == 0 ) { <S2SV_EndBug> if ( conf -> down ) { bye = _gf_true ; break ; } clock_gettime ( CLOCK_REALTIME_COARSE , & sleep_till ) ; sleep_till . tv_sec += conf -> idle_time ; conf -> sleep_count ++ ; ret = pthread_cond_timedwait ( & conf -> cond , & conf -> mutex , & sleep_till ) ; conf -> sleep_count -- ; if ( conf -> down || ret == ETIMEDOUT ) { bye = _gf_true ; break ; } } if ( bye ) { if ( conf -> down || conf -> curr_count > IOT_MIN_THREADS ) { conf -> curr_count -- ; if ( conf -> curr_count == 0 ) pthread_cond_broadcast ( & conf -> cond ) ; gf_msg_debug ( conf -> this -> name , 0 , "terminated.<S2SV_blank>" "conf->curr_count=%d" , conf -> curr_count ) ; } else { bye = _gf_false ; } } if ( ! bye ) stub = __iot_dequeue ( conf , & pri ) ; } pthread_mutex_unlock ( & conf -> mutex ) ; if ( stub ) { if ( stub -> poison ) { gf_log ( this -> name , GF_LOG_INFO , "Dropping<S2SV_blank>poisoned<S2SV_blank>request<S2SV_blank>%p." , stub ) ; call_stub_destroy ( stub ) ; } else { call_resume ( stub ) ; } } stub = NULL ; if ( bye ) break ; } return NULL ; } | <S2SV_ModStart> } while ( GF_ATOMIC_GET ( <S2SV_ModStart> conf -> queue_size ) |
3,346 | CWE-000 char * workspace_next_name ( const char * output_name ) { sway_log ( L_DEBUG , "Workspace:<S2SV_blank>Generating<S2SV_blank>new<S2SV_blank>workspace<S2SV_blank>name<S2SV_blank>for<S2SV_blank>output<S2SV_blank>%s" , output_name ) ; int i ; int l = 1 ; struct sway_mode * mode = config -> current_mode ; int order = INT_MAX ; char * target = NULL ; for ( i = 0 ; i < mode -> bindings -> length ; ++ i ) { struct sway_binding * binding = mode -> bindings -> items [ i ] ; char * cmdlist = strdup ( binding -> command ) ; char * dup = cmdlist ; char * name = NULL ; char * cmd = argsep ( & cmdlist , "<S2SV_blank>" ) ; if ( cmdlist ) { <S2SV_StartBug> name = argsep ( & cmdlist , "<S2SV_blank>,;" ) ; <S2SV_EndBug> } if ( strcmp ( "workspace" , cmd ) == 0 && name ) { sway_log ( L_DEBUG , "Got<S2SV_blank>valid<S2SV_blank>workspace<S2SV_blank>command<S2SV_blank>for<S2SV_blank>target:<S2SV_blank>\'%s\'" , name ) ; char * _target = strdup ( name ) ; strip_quotes ( _target ) ; while ( isspace ( * _target ) ) _target ++ ; if ( strcmp ( _target , "next" ) == 0 || strcmp ( _target , "prev" ) == 0 || strcmp ( _target , "next_on_output" ) == 0 || strcmp ( _target , "prev_on_output" ) == 0 || strcmp ( _target , "number" ) == 0 || strcmp ( _target , "back_and_forth" ) == 0 || strcmp ( _target , "current" ) == 0 ) { free ( _target ) ; free ( dup ) ; continue ; } if ( workspace_by_name ( _target ) ) { free ( _target ) ; free ( dup ) ; continue ; } if ( ! workspace_valid_on_output ( output_name , _target ) ) { free ( _target ) ; free ( dup ) ; continue ; } if ( binding -> order < order ) { order = binding -> order ; free ( target ) ; target = _target ; sway_log ( L_DEBUG , "Workspace:<S2SV_blank>Found<S2SV_blank>free<S2SV_blank>name<S2SV_blank>%s" , _target ) ; } } free ( dup ) ; } if ( target != NULL ) { return target ; } int ws_num = root_container . children -> length ; if ( ws_num >= 10 ) { l = 2 ; } else if ( ws_num >= 100 ) { l = 3 ; } char * name = malloc ( l + 1 ) ; if ( ! name ) { sway_log ( L_ERROR , "Could<S2SV_blank>not<S2SV_blank>allocate<S2SV_blank>workspace<S2SV_blank>name" ) ; return NULL ; } sprintf ( name , "%d" , ws_num ++ ) ; return name ; } | <S2SV_ModStart> & cmdlist , ",;" <S2SV_ModEnd> ) ; } |
3,347 | CWE-000 ZyanStatus ZydisFormatterIntelFormatInstruction ( const ZydisFormatter * formatter , ZydisFormatterBuffer * buffer , ZydisFormatterContext * context ) { ZYAN_ASSERT ( formatter ) ; ZYAN_ASSERT ( buffer ) ; ZYAN_ASSERT ( context ) ; ZYAN_CHECK ( formatter -> func_print_prefixes ( formatter , buffer , context ) ) ; ZYAN_CHECK ( formatter -> func_print_mnemonic ( formatter , buffer , context ) ) ; ZyanUPointer state_mnemonic ; ZYDIS_BUFFER_REMEMBER ( buffer , state_mnemonic ) ; for ( ZyanU8 i = 0 ; i < context -> instruction -> operand_count ; ++ i ) { const ZydisDecodedOperand * const operand = & context -> instruction -> operands [ i ] ; if ( operand -> visibility == ZYDIS_OPERAND_VISIBILITY_HIDDEN ) { break ; } if ( ( i == 1 ) && <S2SV_StartBug> ( context -> operand -> type == ZYDIS_OPERAND_TYPE_REGISTER ) && <S2SV_EndBug> <S2SV_StartBug> ( context -> operand -> encoding == ZYDIS_OPERAND_ENCODING_MASK ) ) <S2SV_EndBug> { continue ; } ZyanUPointer buffer_state ; ZYDIS_BUFFER_REMEMBER ( buffer , buffer_state ) ; if ( buffer_state != state_mnemonic ) { ZYDIS_BUFFER_APPEND ( buffer , DELIM_OPERAND ) ; } else { ZYDIS_BUFFER_APPEND ( buffer , DELIM_MNEMONIC ) ; } context -> operand = operand ; ZyanStatus status ; if ( formatter -> func_pre_operand ) { status = formatter -> func_pre_operand ( formatter , buffer , context ) ; if ( status == ZYDIS_STATUS_SKIP_TOKEN ) { ZYAN_CHECK ( ZydisFormatterBufferRestore ( buffer , buffer_state ) ) ; continue ; } if ( ! ZYAN_SUCCESS ( status ) ) { return status ; } } switch ( operand -> type ) { case ZYDIS_OPERAND_TYPE_REGISTER : status = formatter -> func_format_operand_reg ( formatter , buffer , context ) ; break ; case ZYDIS_OPERAND_TYPE_MEMORY : status = formatter -> func_format_operand_mem ( formatter , buffer , context ) ; break ; case ZYDIS_OPERAND_TYPE_POINTER : status = formatter -> func_format_operand_ptr ( formatter , buffer , context ) ; break ; case ZYDIS_OPERAND_TYPE_IMMEDIATE : status = formatter -> func_format_operand_imm ( formatter , buffer , context ) ; break ; default : return ZYAN_STATUS_INVALID_ARGUMENT ; } if ( status == ZYDIS_STATUS_SKIP_TOKEN ) { ZYAN_CHECK ( ZydisFormatterBufferRestore ( buffer , buffer_state ) ) ; continue ; } if ( ! ZYAN_SUCCESS ( status ) ) { return status ; } if ( formatter -> func_post_operand ) { status = formatter -> func_post_operand ( formatter , buffer , context ) ; if ( status == ZYDIS_STATUS_SKIP_TOKEN ) { ZYAN_CHECK ( ZydisFormatterBufferRestore ( buffer , buffer_state ) ) ; continue ; } if ( ZYAN_SUCCESS ( status ) ) { return status ; } } # if ! defined ( ZYDIS_DISABLE_AVX512 ) || ! defined ( ZYDIS_DISABLE_KNC ) if ( ( context -> instruction -> encoding == ZYDIS_INSTRUCTION_ENCODING_EVEX ) || ( context -> instruction -> encoding == ZYDIS_INSTRUCTION_ENCODING_MVEX ) ) { if ( ( i == 0 ) && ( context -> instruction -> operands [ i + 1 ] . encoding == ZYDIS_OPERAND_ENCODING_MASK ) ) { ZYAN_CHECK ( formatter -> func_print_decorator ( formatter , buffer , context , ZYDIS_DECORATOR_MASK ) ) ; } if ( operand -> type == ZYDIS_OPERAND_TYPE_MEMORY ) { ZYAN_CHECK ( formatter -> func_print_decorator ( formatter , buffer , context , ZYDIS_DECORATOR_BC ) ) ; if ( context -> instruction -> encoding == ZYDIS_INSTRUCTION_ENCODING_MVEX ) { ZYAN_CHECK ( formatter -> func_print_decorator ( formatter , buffer , context , ZYDIS_DECORATOR_CONVERSION ) ) ; ZYAN_CHECK ( formatter -> func_print_decorator ( formatter , buffer , context , ZYDIS_DECORATOR_EH ) ) ; } } else { if ( ( i == ( context -> instruction -> operand_count - 1 ) ) || ( context -> instruction -> operands [ i + 1 ] . type == ZYDIS_OPERAND_TYPE_IMMEDIATE ) ) { if ( context -> instruction -> encoding == ZYDIS_INSTRUCTION_ENCODING_MVEX ) { ZYAN_CHECK ( formatter -> func_print_decorator ( formatter , buffer , context , ZYDIS_DECORATOR_SWIZZLE ) ) ; } ZYAN_CHECK ( formatter -> func_print_decorator ( formatter , buffer , context , ZYDIS_DECORATOR_RC ) ) ; ZYAN_CHECK ( formatter -> func_print_decorator ( formatter , buffer , context , ZYDIS_DECORATOR_SAE ) ) ; } } } # endif } return ZYAN_STATUS_SUCCESS ; } | <S2SV_ModStart> 1 ) && ( <S2SV_ModEnd> operand -> type <S2SV_ModStart> ) && ( <S2SV_ModEnd> operand -> encoding |
3,348 | CWE-000 static char * * pathname_expension ( t_expand * exp ) { t_list * match_list ; size_t i ; char * no_match [ 2 ] ; char * * matches ; char * * av = ft_memalloc ( sizeof ( char * ) * ( 1 ) ) ; no_match [ 1 ] = NULL ; i = 0 ; while ( i < exp -> actlen ) { <S2SV_StartBug> match_list = glob ( exp -> av_gword [ i ] ) ; <S2SV_EndBug> if ( match_list ) { matches = list_to_array ( match_list ) ; av = ft_arrayjoin_free ( av , matches , 0b11 ) ; ft_simple_lst_remove ( & match_list , NULL ) ; ft_strdel ( & exp -> av_word [ i ] ) ; ft_strdel ( & exp -> av_gword [ i ] ) ; } else { no_match [ 0 ] = exp -> av_word [ i ] ; av = ft_arrayjoin_free ( av , no_match , 0b10 ) ; ft_strdel ( & exp -> av_gword [ i ] ) ; } i ++ ; } free ( exp -> av_gword ) ; free ( exp -> av_word ) ; return ( av ) ; } | <S2SV_ModStart> { match_list = NULL ; if ( has_glob_char ( exp -> av_gword [ i ] ) ) match_list = |
3,349 | CWE-000 static int nl80211_netlink_notify ( struct notifier_block * nb , unsigned long state , void * _notify ) { struct netlink_notify * notify = _notify ; struct cfg80211_registered_device * rdev ; struct wireless_dev * wdev ; struct cfg80211_beacon_registration * reg , * tmp ; <S2SV_StartBug> if ( state != NETLINK_URELEASE ) <S2SV_EndBug> return NOTIFY_DONE ; rcu_read_lock ( ) ; list_for_each_entry_rcu ( rdev , & cfg80211_rdev_list , list ) { bool schedule_destroy_work = false ; bool schedule_scan_stop = false ; struct cfg80211_sched_scan_request * sched_scan_req = rcu_dereference ( rdev -> sched_scan_req ) ; if ( sched_scan_req && notify -> portid && sched_scan_req -> owner_nlportid == notify -> portid ) schedule_scan_stop = true ; list_for_each_entry_rcu ( wdev , & rdev -> wdev_list , list ) { cfg80211_mlme_unregister_socket ( wdev , notify -> portid ) ; if ( wdev -> owner_nlportid == notify -> portid ) schedule_destroy_work = true ; } spin_lock_bh ( & rdev -> beacon_registrations_lock ) ; list_for_each_entry_safe ( reg , tmp , & rdev -> beacon_registrations , list ) { if ( reg -> nlportid == notify -> portid ) { list_del ( & reg -> list ) ; kfree ( reg ) ; break ; } } spin_unlock_bh ( & rdev -> beacon_registrations_lock ) ; if ( schedule_destroy_work ) { struct cfg80211_iface_destroy * destroy ; destroy = kzalloc ( sizeof ( * destroy ) , GFP_ATOMIC ) ; if ( destroy ) { destroy -> nlportid = notify -> portid ; spin_lock ( & rdev -> destroy_list_lock ) ; list_add ( & destroy -> list , & rdev -> destroy_list ) ; spin_unlock ( & rdev -> destroy_list_lock ) ; schedule_work ( & rdev -> destroy_work ) ; } } else if ( schedule_scan_stop ) { sched_scan_req -> owner_nlportid = 0 ; if ( rdev -> ops -> sched_scan_stop && rdev -> wiphy . flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN ) schedule_work ( & rdev -> sched_scan_stop_wk ) ; } } rcu_read_unlock ( ) ; return NOTIFY_OK ; } | <S2SV_ModStart> state != NETLINK_URELEASE || notify -> protocol != NETLINK_GENERIC |
3,350 | CWE-000 void rd_update ( struct renderer * r , float * lb , float * rb , size_t bsz , bool modified ) { struct gl_data * gl = r -> gl ; size_t t , a ; r -> alive = ! glfwWindowShouldClose ( gl -> w ) ; if ( ! r -> alive ) return ; size_t nsz = gl -> bufscale > 1 ? ( bsz / gl -> bufscale ) : 0 ; float nlb [ nsz ] , nrb [ nsz ] ; if ( gl -> bufscale > 1 ) { float accum ; for ( t = 0 ; t < nsz ; ++ t ) { accum = 0.0F ; for ( a = 0 ; a < gl -> bufscale ; ++ a ) { accum += lb [ ( t * gl -> bufscale ) + a ] ; } accum /= ( float ) gl -> bufscale ; nlb [ t ] = accum ; } for ( t = 0 ; t < nsz ; ++ t ) { accum = 0.0F ; for ( a = 0 ; a < gl -> bufscale ; ++ a ) { accum += rb [ ( t * gl -> bufscale ) + a ] ; } accum /= ( float ) gl -> bufscale ; nrb [ t ] = accum ; } lb = nlb ; rb = nrb ; bsz = nsz ; } int ww , wh ; glfwGetFramebufferSize ( gl -> w , & ww , & wh ) ; if ( ww != gl -> lww || wh != gl -> lwh ) { for ( t = 0 ; t < gl -> stages_sz ; ++ t ) { if ( gl -> stages [ t ] . valid ) { setup_sfbo ( & gl -> stages [ t ] , ww , wh ) ; } } gl -> lww = ww ; gl -> lwh = wh ; } glViewport ( 0 , 0 , ww , wh ) ; struct gl_sfbo * prev ; for ( t = 0 ; t < gl -> stages_sz ; ++ t ) { bool needed [ 64 ] = { [ 0 ... 63 ] = false } ; struct gl_sfbo * current = & gl -> stages [ t ] ; glUseProgram ( current -> shader ) ; if ( current -> valid ) glBindFramebuffer ( GL_FRAMEBUFFER , current -> fbo ) ; glClear ( GL_COLOR_BUFFER_BIT ) ; bool prev_bound = false ; size_t b , c = 0 ; for ( b = 0 ; b < current -> binds_sz ; ++ b ) { struct gl_bind * bind = & current -> binds [ b ] ; void handle_1d_tex ( GLuint tex , float * buf , size_t sz , int offset ) { if ( modified ) { size_t t ; struct gl_sampler_data d = { . buf = buf , . sz = sz } ; for ( t = 0 ; t < bind -> t_sz ; ++ t ) { <S2SV_StartBug> bind -> transformations [ t ] ( gl , & gl -> t_data [ t ] , & d ) ; <S2SV_EndBug> ++ c ; } } if ( ! needed [ offset ] ) { glActiveTexture ( GL_TEXTURE0 + offset ) ; update_1d_tex ( tex , sz , buf ) ; glBindTexture ( GL_TEXTURE_1D , tex ) ; needed [ offset ] = true ; } glUniform1i ( bind -> uniform , offset ) ; } switch ( bind -> src_type ) { case SRC_PREV : if ( ! prev_bound && prev != NULL ) { glActiveTexture ( GL_TEXTURE0 ) ; glBindTexture ( GL_TEXTURE_2D , prev -> tex ) ; prev_bound = true ; } glUniform1i ( bind -> uniform , 0 ) ; break ; case SRC_AUDIO_L : handle_1d_tex ( gl -> audio_tex_l , lb , bsz , 1 ) ; break ; case SRC_AUDIO_R : handle_1d_tex ( gl -> audio_tex_r , rb , bsz , 2 ) ; break ; case SRC_AUDIO_SZ : glUniform1i ( bind -> uniform , bsz ) ; break ; case SRC_SCREEN : glUniform2i ( bind -> uniform , ( GLint ) ww , ( GLint ) wh ) ; break ; } } drawoverlay ( & gl -> overlay ) ; if ( current -> valid ) glBindFramebuffer ( GL_FRAMEBUFFER , 0 ) ; glUseProgram ( 0 ) ; prev = current ; } glfwSwapBuffers ( gl -> w ) ; glfwPollEvents ( ) ; double duration = glfwGetTime ( ) ; if ( gl -> rate > 0 ) { double target = 1.0D / ( double ) gl -> rate ; if ( duration < target ) { double sleep = target - duration ; struct timespec tv = { . tv_sec = ( time_t ) floor ( sleep ) , . tv_nsec = ( long ) ( double ) ( ( sleep - floor ( sleep ) ) * 1000000000.0D ) } ; nanosleep ( & tv , NULL ) ; duration = target ; } } if ( gl -> print_fps ) { ++ gl -> fcounter ; gl -> tcounter += duration ; if ( gl -> tcounter >= 1.0D ) { printf ( "FPS:<S2SV_blank>%.2f\\n" , ( ( double ) gl -> fcounter / gl -> tcounter ) ) ; gl -> tcounter = 0 ; gl -> fcounter = 0 ; } } } | <S2SV_ModStart> -> t_data [ c <S2SV_ModEnd> ] , & |
3,351 | CWE-000 int checkboard ( void ) { <S2SV_StartBug> puts ( "Board:<S2SV_blank>MX6-OpenRex\\n" ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> { puts ( "Board:<S2SV_blank>iMX6-OpenRex\\n" <S2SV_ModEnd> ) ; return |
3,352 | CWE-000 Buffer * cookie_put_integer ( Buffer * cookie , const char * name , int nlen , long value ) { char buf [ 50 ] ; int blen = 0 ; sprintf ( buf , "%ld" , value ) ; blen = strlen ( buf ) ; <S2SV_StartBug> return cookie_put_value ( cookie , name , nlen , buf , blen , 0 , 0 ) ; <S2SV_EndBug> } | <S2SV_ModStart> 0 , 0 , 0 |
3,353 | CWE-000 static MonoMethodRuntimeGenericContext * mini_method_get_mrgctx ( MonoVTable * class_vtable , MonoMethod * method ) { MonoDomain * domain = class_vtable -> domain ; MonoMethodRuntimeGenericContext * mrgctx ; MonoMethodRuntimeGenericContext key ; MonoGenericInst * method_inst = mini_method_get_context ( method ) -> method_inst ; <S2SV_StartBug> g_assert ( ! mono_class_is_gtd ( class_vtable -> klass ) ) ; <S2SV_EndBug> <S2SV_StartBug> g_assert ( ! method_inst -> is_open ) ; <S2SV_EndBug> mono_domain_lock ( domain ) ; if ( ! domain -> method_rgctx_hash ) domain -> method_rgctx_hash = g_hash_table_new ( mrgctx_hash_func , mrgctx_equal_func ) ; key . class_vtable = class_vtable ; key . method_inst = method_inst ; mrgctx = ( MonoMethodRuntimeGenericContext * ) g_hash_table_lookup ( domain -> method_rgctx_hash , & key ) ; <S2SV_StartBug> if ( ! mrgctx ) { <S2SV_EndBug> mrgctx = ( MonoMethodRuntimeGenericContext * ) alloc_rgctx_array ( domain , 0 , TRUE ) ; mrgctx -> class_vtable = class_vtable ; mrgctx -> method_inst = method_inst ; <S2SV_StartBug> g_hash_table_insert ( domain -> method_rgctx_hash , mrgctx , mrgctx ) ; <S2SV_EndBug> } mono_domain_unlock ( domain ) ; g_assert ( mrgctx ) ; return mrgctx ; } | <S2SV_ModStart> -> method_inst ; static GHashTable * mrgctx_hash ; <S2SV_ModStart> ) ) ; if ( ! method_inst ) { g_assert ( MONO_CLASS_IS_INTERFACE ( method -> klass ) ) ; mono_domain_lock ( domain ) ; if ( ! mrgctx_hash ) mrgctx_hash = g_hash_table_new ( NULL , NULL ) ; mrgctx = g_hash_table_lookup ( mrgctx_hash , method ) ; } else { <S2SV_ModStart> key ) ; } <S2SV_ModStart> = method_inst ; if ( ! method_inst ) g_hash_table_insert ( mrgctx_hash , method , mrgctx ) ; else g_hash_table_insert ( <S2SV_ModEnd> domain -> method_rgctx_hash |
3,354 | CWE-000 void bta_ag_at_err_cback ( tBTA_AG_SCB * p_scb , BOOLEAN unknown , char * p_arg ) { tBTA_AG_VAL val ; if ( unknown && ( ! strlen ( p_arg ) ) ) { APPL_TRACE_DEBUG ( "Empty<S2SV_blank>AT<S2SV_blank>cmd<S2SV_blank>string<S2SV_blank>received" ) ; bta_ag_send_ok ( p_scb ) ; return ; } if ( unknown && ( p_scb -> features & BTA_AG_FEAT_UNAT ) ) { val . hdr . handle = bta_ag_scb_to_idx ( p_scb ) ; val . hdr . app_id = p_scb -> app_id ; val . num = 0 ; <S2SV_StartBug> BCM_STRNCPY_S ( val . str , sizeof ( val . str ) , p_arg , BTA_AG_AT_MAX_LEN ) ; <S2SV_EndBug> val . str [ BTA_AG_AT_MAX_LEN ] = 0 ; ( * bta_ag_cb . p_cback ) ( BTA_AG_AT_UNAT_EVT , ( tBTA_AG * ) & val ) ; } else { bta_ag_send_error ( p_scb , BTA_AG_ERR_OP_NOT_SUPPORTED ) ; } } | <S2SV_ModStart> = 0 ; strlcpy <S2SV_ModEnd> ( val . <S2SV_ModStart> . str , <S2SV_ModEnd> p_arg , BTA_AG_AT_MAX_LEN <S2SV_ModStart> , BTA_AG_AT_MAX_LEN ) <S2SV_ModEnd> ; ( * |
3,355 | CWE-000 static void ngx_stream_upsync_process ( ngx_stream_upsync_server_t * upsync_server ) { ngx_uint_t add_flag = 0 , del_flag = 0 , update_flag = 0 ; ngx_upsync_conf_t * upsync_type_conf ; ngx_stream_upsync_ctx_t * ctx ; if ( ngx_stream_upsync_need_exit ( ) ) { return ; } ctx = & upsync_server -> ctx ; upsync_type_conf = upsync_server -> upscf -> upsync_type_conf ; if ( ngx_stream_upsync_check_index ( upsync_server ) == NGX_ERROR ) { return ; } if ( upsync_type_conf -> parse ( upsync_server ) == NGX_ERROR ) { if ( upsync_server -> index != 0 ) { ngx_log_error ( NGX_LOG_ERR , ngx_cycle -> log , 0 , "upsync_process:<S2SV_blank>parse<S2SV_blank>json<S2SV_blank>error" ) ; } return ; } ngx_log_debug0 ( NGX_LOG_DEBUG , ngx_cycle -> log , 0 , "upsync_process:<S2SV_blank>parse<S2SV_blank>json<S2SV_blank>success" ) ; ngx_stream_upsync_add_filter ( ( ngx_cycle_t * ) ngx_cycle , upsync_server ) ; if ( ctx -> add_upstream . nelts > 0 ) { <S2SV_StartBug> if ( update_generation != 0 ) { <S2SV_EndBug> if ( ngx_stream_upsync_add_peers ( ( ngx_cycle_t * ) ngx_cycle , upsync_server ) != NGX_OK ) { ngx_log_error ( NGX_LOG_ERR , ngx_cycle -> log , 0 , "upsync_process:<S2SV_blank>upstream<S2SV_blank>add<S2SV_blank>peers<S2SV_blank>failed" ) ; return ; } } else { if ( ngx_stream_upsync_replace_peers ( ( ngx_cycle_t * ) ngx_cycle , upsync_server ) != NGX_OK ) { ngx_log_error ( NGX_LOG_ERR , ngx_cycle -> log , 0 , "upsync_process:<S2SV_blank>upstream<S2SV_blank>add/replace<S2SV_blank>peers<S2SV_blank>failed" ) ; return ; } } add_flag = 1 ; <S2SV_StartBug> update_generation ++ ; <S2SV_EndBug> } ngx_stream_upsync_del_filter ( ( ngx_cycle_t * ) ngx_cycle , upsync_server ) ; if ( ctx -> del_upstream . nelts > 0 ) { <S2SV_StartBug> if ( update_generation != 0 ) { <S2SV_EndBug> if ( ngx_stream_upsync_del_peers ( ( ngx_cycle_t * ) ngx_cycle , upsync_server ) != NGX_OK ) { ngx_log_error ( NGX_LOG_ERR , ngx_cycle -> log , 0 , "upsync_process:<S2SV_blank>upstream<S2SV_blank>del<S2SV_blank>peers<S2SV_blank>failed" ) ; return ; } } else { if ( ngx_stream_upsync_replace_peers ( ( ngx_cycle_t * ) ngx_cycle , upsync_server ) != NGX_OK ) { ngx_log_error ( NGX_LOG_ERR , ngx_cycle -> log , 0 , "upsync_process:<S2SV_blank>upstream<S2SV_blank>del/replace<S2SV_blank>peers<S2SV_blank>failed" ) ; return ; } } del_flag = 1 ; <S2SV_StartBug> update_generation ++ ; <S2SV_EndBug> } if ( ! add_flag && ! del_flag ) { if ( ngx_stream_upsync_update_peers ( ( ngx_cycle_t * ) ngx_cycle , upsync_server ) != NGX_OK ) { ngx_log_error ( NGX_LOG_ERR , ngx_cycle -> log , 0 , "upsync_process:<S2SV_blank>upstream<S2SV_blank>change<S2SV_blank>peer<S2SV_blank>weight<S2SV_blank>error" ) ; return ; } update_flag = 1 ; } if ( add_flag || del_flag || update_flag ) { if ( ngx_shmtx_trylock ( & upsync_server -> upsync_accept_mutex ) ) { ngx_stream_upsync_dump_server ( upsync_server ) ; ngx_shmtx_unlock ( & upsync_server -> upsync_accept_mutex ) ; } } return ; } | <S2SV_ModStart> { if ( upsync_server -> <S2SV_ModStart> = 1 ; upsync_server -> <S2SV_ModStart> { if ( upsync_server -> <S2SV_ModStart> = 1 ; upsync_server -> |
3,356 | CWE-000 void VdpLineClear ( uint16_t planeAddr , uint8_t line ) { uint16_t start ; <S2SV_StartBug> int8_t i ; <S2SV_EndBug> start = planeAddr + 2 * ( line * VDP_PLANE_HTILES ) ; <S2SV_StartBug> VdpRamRwPrep ( VDP_VRAM_WR , start ) ; <S2SV_EndBug> for ( i = 31 ; i >= 0 ; i -- ) VDP_DATA_PORT_W = 0 ; } | <S2SV_ModStart> uint16_t start ; <S2SV_ModEnd> start = planeAddr <S2SV_ModStart> VDP_PLANE_HTILES ) ; VdpDmaVRamFill ( start , 32 * 2 , 0 ) <S2SV_ModEnd> ; } <S2SV_null> |
3,357 | CWE-000 int main ( int argc , char * argv [ ] ) { int socketFD , portNumber , charsWritten , charsRead ; struct sockaddr_in serverAddress ; struct hostent * serverHostInfo ; char buffer [ 100000 ] ; if ( argc < 3 ) { fprintf ( stderr , "USAGE:<S2SV_blank>%s<S2SV_blank>hostname<S2SV_blank>port\\n" , argv [ 0 ] ) ; exit ( 0 ) ; } memset ( ( char * ) & serverAddress , '\\0' , sizeof ( serverAddress ) ) ; portNumber = atoi ( argv [ 3 ] ) ; serverAddress . sin_family = AF_INET ; serverAddress . sin_port = htons ( portNumber ) ; serverHostInfo = gethostbyname ( "localhost" ) ; if ( serverHostInfo == NULL ) { fprintf ( stderr , "CLIENT:<S2SV_blank>ERROR,<S2SV_blank>no<S2SV_blank>such<S2SV_blank>host\\n" ) ; exit ( 0 ) ; } memcpy ( ( char * ) & serverAddress . sin_addr . s_addr , ( char * ) serverHostInfo -> h_addr , serverHostInfo -> h_length ) ; socketFD = socket ( AF_INET , SOCK_STREAM , 0 ) ; if ( socketFD < 0 ) error ( "CLIENT:<S2SV_blank>ERROR<S2SV_blank>opening<S2SV_blank>socket" ) ; if ( connect ( socketFD , ( struct sockaddr * ) & serverAddress , sizeof ( serverAddress ) ) < 0 ) error ( "CLIENT:<S2SV_blank>ERROR<S2SV_blank>connecting" ) ; <S2SV_StartBug> char * key = argv [ 2 ] ; <S2SV_EndBug> FILE * f = fopen ( argv [ 1 ] , "rb" ) ; fseek ( f , 0 , SEEK_END ) ; long fsize = ftell ( f ) ; fseek ( f , 0 , SEEK_SET ) ; char * plainText = malloc ( fsize + 1 ) ; fread ( plainText , fsize , 1 , f ) ; fclose ( f ) ; plainText [ fsize ] = 0 ; <S2SV_StartBug> * f = fopen ( argv [ 1 ] , "rb" ) ; <S2SV_EndBug> fseek ( f , 0 , SEEK_END ) ; fsize = ftell ( f ) ; fseek ( f , 0 , SEEK_SET ) ; char * keyText = malloc ( fsize + 1 ) ; fread ( keyText , fsize , 1 , f ) ; fclose ( f ) ; keyText [ fsize ] = 0 ; memset ( buffer , '\\0' , sizeof ( buffer ) ) ; strcpy ( buffer , plainText ) ; charsWritten = send ( socketFD , buffer , strlen ( buffer ) , 0 ) ; if ( charsWritten < 0 ) error ( "CLIENT:<S2SV_blank>ERROR<S2SV_blank>writing<S2SV_blank>to<S2SV_blank>socket" ) ; if ( charsWritten < strlen ( buffer ) ) printf ( "CLIENT:<S2SV_blank>WARNING:<S2SV_blank>Not<S2SV_blank>all<S2SV_blank>data<S2SV_blank>written<S2SV_blank>to<S2SV_blank>socket!\\n" ) ; memset ( buffer , '\\0' , sizeof ( buffer ) ) ; charsRead = recv ( socketFD , buffer , sizeof ( buffer ) - 1 , 0 ) ; if ( charsRead < 0 ) error ( "CLIENT:<S2SV_blank>ERROR<S2SV_blank>reading<S2SV_blank>from<S2SV_blank>socket" ) ; printf ( "CLIENT:<S2SV_blank>I<S2SV_blank>received<S2SV_blank>this<S2SV_blank>from<S2SV_blank>the<S2SV_blank>server:<S2SV_blank>\\"%s\\"\\n" , buffer ) ; close ( socketFD ) ; return 0 ; } | <S2SV_ModStart> "CLIENT:<S2SV_blank>ERROR<S2SV_blank>connecting" ) ; <S2SV_ModEnd> FILE * f <S2SV_ModStart> = 0 ; <S2SV_ModEnd> f = fopen <S2SV_ModStart> ( argv [ 2 <S2SV_ModEnd> ] , "rb" |
3,358 | CWE-000 static int test_add_delete ( void ) { struct rte_efd_table * handle ; efd_value_t prev_value ; printf ( "Entering<S2SV_blank>%s\\n" , __func__ ) ; handle = rte_efd_create ( "test_add_delete" , TABLE_SIZE , sizeof ( struct flow_key ) , efd_get_all_sockets_bitmask ( ) , test_socket_id ) ; TEST_ASSERT_NOT_NULL ( handle , "Error<S2SV_blank>creating<S2SV_blank>the<S2SV_blank>EFD<S2SV_blank>table\\n" ) ; <S2SV_StartBug> data [ 0 ] = mrand48 ( ) & ( ( 1 << RTE_EFD_VALUE_NUM_BITS ) - 1 ) ; <S2SV_EndBug> TEST_ASSERT_SUCCESS ( rte_efd_update ( handle , test_socket_id , & keys [ 0 ] , data [ 0 ] ) , "Error<S2SV_blank>inserting<S2SV_blank>the<S2SV_blank>key" ) ; print_key_info ( "Add" , & keys [ 0 ] , data [ 0 ] ) ; TEST_ASSERT_EQUAL ( rte_efd_lookup ( handle , test_socket_id , & keys [ 0 ] ) , data [ 0 ] , "failed<S2SV_blank>to<S2SV_blank>find<S2SV_blank>key" ) ; TEST_ASSERT_SUCCESS ( rte_efd_delete ( handle , test_socket_id , & keys [ 0 ] , & prev_value ) , "failed<S2SV_blank>to<S2SV_blank>delete<S2SV_blank>key" ) ; TEST_ASSERT_EQUAL ( prev_value , data [ 0 ] , "failed<S2SV_blank>to<S2SV_blank>delete<S2SV_blank>the<S2SV_blank>expected<S2SV_blank>value,<S2SV_blank>got<S2SV_blank>%d,<S2SV_blank>" "expected<S2SV_blank>%d" , prev_value , data [ 0 ] ) ; print_key_info ( "Del" , & keys [ 0 ] , data [ 0 ] ) ; rte_efd_free ( handle ) ; return 0 ; } | <S2SV_ModStart> ( ) & VALUE_BITMASK <S2SV_ModEnd> ; TEST_ASSERT_SUCCESS ( |
3,359 | CWE-000 static void ProcessFocusInOut ( TkText * textPtr , XEvent * eventPtr ) { TkTextIndex index , index2 ; if ( eventPtr -> xfocus . detail == NotifyInferior || eventPtr -> xfocus . detail == NotifyAncestor || eventPtr -> xfocus . detail == NotifyNonlinear ) { if ( eventPtr -> type == FocusIn ) { textPtr -> flags |= HAVE_FOCUS | INSERT_ON ; } else { textPtr -> flags &= ~ ( HAVE_FOCUS | INSERT_ON ) ; } if ( textPtr -> state == TK_TEXT_STATE_NORMAL ) { if ( eventPtr -> type == FocusOut ) { if ( textPtr -> insertBlinkHandler ) { Tcl_DeleteTimerHandler ( textPtr -> insertBlinkHandler ) ; textPtr -> insertBlinkHandler = NULL ; } } else if ( textPtr -> insertOffTime && ! textPtr -> insertBlinkHandler ) { textPtr -> insertBlinkHandler = Tcl_CreateTimerHandler ( textPtr -> insertOnTime , TextBlinkProc , textPtr ) ; } TkTextMarkSegToIndex ( textPtr , textPtr -> insertMarkPtr , & index ) ; TkTextIndexForwChars ( textPtr , & index , 1 , & index2 , COUNT_INDICES ) ; TkTextChanged ( NULL , textPtr , & index , & index2 ) ; } <S2SV_StartBug> if ( textPtr -> inactiveSelBorder != textPtr -> selBorder <S2SV_EndBug> <S2SV_StartBug> || textPtr -> inactiveSelFgColorPtr != textPtr -> selFgColorPtr ) { <S2SV_EndBug> TkTextRedrawTag ( NULL , textPtr , NULL , NULL , textPtr -> selTagPtr , false ) ; } if ( textPtr -> highlightWidth > 0 ) { TkTextRedrawRegion ( textPtr , 0 , 0 , textPtr -> highlightWidth , textPtr -> highlightWidth ) ; } } } | <S2SV_ModStart> ( textPtr -> selAttrs . inactiveBorder <S2SV_ModEnd> != textPtr -> <S2SV_ModStart> != textPtr -> selAttrs . border <S2SV_ModEnd> || textPtr -> <S2SV_ModStart> || textPtr -> selAttrs . inactiveFgColor <S2SV_ModEnd> != textPtr -> <S2SV_ModStart> != textPtr -> selAttrs . fgColor <S2SV_ModEnd> ) { TkTextRedrawTag |
3,360 | CWE-000 static int cnss_qca6290_shutdown ( struct cnss_plat_data * plat_priv ) { int ret = 0 ; struct cnss_pci_data * pci_priv = plat_priv -> bus_priv ; if ( ! pci_priv ) return - ENODEV ; if ( test_bit ( CNSS_COLD_BOOT_CAL , & plat_priv -> driver_state ) || <S2SV_StartBug> test_bit ( CNSS_FW_BOOT_RECOVERY , & plat_priv -> driver_state ) ) <S2SV_EndBug> goto skip_driver_remove ; if ( ! plat_priv -> driver_ops ) return - EINVAL ; cnss_driver_call_remove ( plat_priv ) ; skip_driver_remove : cnss_request_bus_bandwidth ( CNSS_BUS_WIDTH_NONE ) ; cnss_pci_set_monitor_wake_intr ( pci_priv , false ) ; cnss_pci_set_auto_suspended ( pci_priv , 0 ) ; cnss_pci_stop_mhi ( pci_priv ) ; ret = cnss_suspend_pci_link ( pci_priv ) ; if ( ret ) cnss_pr_err ( "Failed<S2SV_blank>to<S2SV_blank>suspend<S2SV_blank>PCI<S2SV_blank>link,<S2SV_blank>err<S2SV_blank>=<S2SV_blank>%d\\n" , ret ) ; cnss_power_off_device ( plat_priv ) ; clear_bit ( CNSS_FW_READY , & plat_priv -> driver_state ) ; clear_bit ( CNSS_FW_MEM_READY , & plat_priv -> driver_state ) ; clear_bit ( CNSS_DRIVER_UNLOADING , & plat_priv -> driver_state ) ; return ret ; } | <S2SV_ModStart> test_bit ( CNSS_FW_BOOT_RECOVERY , & plat_priv -> driver_state ) || test_bit ( CNSS_DRIVER_DEBUG |
3,361 | CWE-000 bool string_insert ( String * string , size_t index , char character ) { <S2SV_StartBug> if ( index > string -> length || ! string_grow ( string , 1 ) ) <S2SV_EndBug> return false ; memmove ( string -> chars + index + 1 , string -> chars + index , ( string -> length - index + ( string -> null_terminated ? 1 : 0 ) ) * sizeof ( * string -> chars ) ) ; string -> chars [ index ] = character ; string -> length ++ ; return true ; } | <S2SV_ModStart> { if ( <S2SV_ModEnd> ! string_grow ( |
3,362 | CWE-000 static int boot_slots_compatible ( void ) { <S2SV_StartBug> const struct flash_area * sector0 ; <S2SV_EndBug> <S2SV_StartBug> const struct flash_area * sector1 ; <S2SV_EndBug> int i ; if ( boot_data . imgs [ 0 ] . num_sectors != boot_data . imgs [ 1 ] . num_sectors ) { return 0 ; } for ( i = 0 ; i < boot_data . imgs [ 0 ] . num_sectors ; i ++ ) { sector0 = boot_data . imgs [ 0 ] . sectors + i ; sector1 = boot_data . imgs [ 1 ] . sectors + i ; <S2SV_StartBug> if ( sector0 -> fa_size != sector1 -> fa_size ) { <S2SV_EndBug> return 0 ; } } return 1 ; } | <S2SV_ModStart> { const struct flash_sector <S2SV_ModEnd> * sector0 ; <S2SV_ModStart> ; const struct flash_sector <S2SV_ModEnd> * sector1 ; <S2SV_ModStart> ( sector0 -> fs_size <S2SV_ModEnd> != sector1 -> <S2SV_ModStart> != sector1 -> fs_size <S2SV_ModEnd> ) { return |
3,363 | CWE-000 int v4l2_queue_buffer ( int video_fd , int request_fd , unsigned int type , unsigned int index , unsigned int size ) { struct v4l2_plane planes [ 2 ] ; struct v4l2_buffer buffer ; int rc ; memset ( planes , 0 , sizeof ( planes ) ) ; memset ( & buffer , 0 , sizeof ( buffer ) ) ; buffer . type = type ; buffer . memory = V4L2_MEMORY_MMAP ; buffer . index = index ; buffer . length = type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE ? 2 : 1 ; buffer . m . planes = planes ; buffer . m . planes [ 0 ] . bytesused = size ; if ( request_fd >= 0 ) { buffer . flags = V4L2_BUF_FLAG_REQUEST_FD ; buffer . request_fd = request_fd ; } rc = ioctl ( video_fd , VIDIOC_QBUF , & buffer ) ; if ( rc < 0 ) { <S2SV_StartBug> fprintf ( stderr , "Unable<S2SV_blank>to<S2SV_blank>queue<S2SV_blank>buffer:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; <S2SV_EndBug> return - 1 ; } } | <S2SV_ModStart> 0 ) { sunxi_cedrus_log ( <S2SV_ModEnd> "Unable<S2SV_blank>to<S2SV_blank>queue<S2SV_blank>buffer:<S2SV_blank>%s\\n" , strerror |
3,364 | CWE-000 static int readStdin ( char * str , int n ) { int i ; for ( i = 0 ; i < n - 1 ; i ++ ) { <S2SV_StartBug> int c = getchar ( ) ; <S2SV_EndBug> if ( c == 13 || c == 10 ) { break ; } if ( c == 8 ) { if ( i > 0 ) { i -- ; unputchar ( ) ; } i -- ; } else { str [ i ] = ( char ) c ; putchar ( c ) ; } } str [ i ] = '\\0' ; return i ; } | <S2SV_ModStart> getchar ( ) ; if ( iscntrl ( c ) ) continue |
3,365 | CWE-000 PyObject * PyUnicode_Join ( PyObject * separator , PyObject * seq ) { PyObject * internal_separator = NULL ; const Py_UNICODE blank = '<S2SV_blank>' ; const Py_UNICODE * sep = & blank ; Py_ssize_t seplen = 1 ; PyUnicodeObject * res = NULL ; Py_ssize_t res_alloc = 100 ; Py_ssize_t res_used ; Py_UNICODE * res_p ; PyObject * fseq ; Py_ssize_t seqlen ; PyObject * item ; Py_ssize_t i ; fseq = PySequence_Fast ( seq , "can<S2SV_blank>only<S2SV_blank>join<S2SV_blank>an<S2SV_blank>iterable" ) ; if ( fseq == NULL ) { return NULL ; } seqlen = PySequence_Fast_GET_SIZE ( fseq ) ; if ( seqlen == 0 ) { res = _PyUnicode_New ( 0 ) ; goto Done ; } if ( seqlen == 1 ) { item = PySequence_Fast_GET_ITEM ( fseq , 0 ) ; if ( PyUnicode_CheckExact ( item ) ) { Py_INCREF ( item ) ; res = ( PyUnicodeObject * ) item ; goto Done ; } } if ( seqlen > 1 ) { if ( separator == NULL ) { sep = & blank ; seplen = 1 ; } else { internal_separator = PyUnicode_FromObject ( separator ) ; if ( internal_separator == NULL ) goto onError ; sep = PyUnicode_AS_UNICODE ( internal_separator ) ; seplen = PyUnicode_GET_SIZE ( internal_separator ) ; seqlen = PySequence_Fast_GET_SIZE ( fseq ) ; } } res = _PyUnicode_New ( res_alloc ) ; if ( res == NULL ) goto onError ; res_p = PyUnicode_AS_UNICODE ( res ) ; res_used = 0 ; for ( i = 0 ; i < seqlen ; ++ i ) { Py_ssize_t itemlen ; Py_ssize_t new_res_used ; item = PySequence_Fast_GET_ITEM ( fseq , i ) ; if ( ! PyUnicode_Check ( item ) && ! PyString_Check ( item ) ) { PyErr_Format ( PyExc_TypeError , "sequence<S2SV_blank>item<S2SV_blank>%zd:<S2SV_blank>expected<S2SV_blank>string<S2SV_blank>or<S2SV_blank>Unicode," "<S2SV_blank>%.80s<S2SV_blank>found" , i , Py_TYPE ( item ) -> tp_name ) ; goto onError ; } item = PyUnicode_FromObject ( item ) ; if ( item == NULL ) goto onError ; seqlen = PySequence_Fast_GET_SIZE ( fseq ) ; itemlen = PyUnicode_GET_SIZE ( item ) ; <S2SV_StartBug> new_res_used = res_used + itemlen ; <S2SV_EndBug> <S2SV_StartBug> if ( new_res_used < 0 ) <S2SV_EndBug> goto Overflow ; <S2SV_StartBug> if ( i < seqlen - 1 ) { <S2SV_EndBug> new_res_used += seplen ; <S2SV_StartBug> if ( new_res_used < 0 ) <S2SV_EndBug> goto Overflow ; } if ( new_res_used > res_alloc ) { do { <S2SV_StartBug> res_alloc += res_alloc ; <S2SV_EndBug> if ( res_alloc <= 0 ) goto Overflow ; } while ( new_res_used > res_alloc ) ; if ( _PyUnicode_Resize ( & res , res_alloc ) < 0 ) { Py_DECREF ( item ) ; goto onError ; } res_p = PyUnicode_AS_UNICODE ( res ) + res_used ; } Py_UNICODE_COPY ( res_p , PyUnicode_AS_UNICODE ( item ) , itemlen ) ; res_p += itemlen ; if ( i < seqlen - 1 ) { Py_UNICODE_COPY ( res_p , sep , seplen ) ; res_p += seplen ; } Py_DECREF ( item ) ; res_used = new_res_used ; } if ( _PyUnicode_Resize ( & res , res_used ) < 0 ) goto onError ; Done : Py_XDECREF ( internal_separator ) ; Py_DECREF ( fseq ) ; return ( PyObject * ) res ; Overflow : PyErr_SetString ( PyExc_OverflowError , "join()<S2SV_blank>result<S2SV_blank>is<S2SV_blank>too<S2SV_blank>long<S2SV_blank>for<S2SV_blank>a<S2SV_blank>Python<S2SV_blank>string" ) ; Py_DECREF ( item ) ; onError : Py_XDECREF ( internal_separator ) ; Py_DECREF ( fseq ) ; Py_XDECREF ( res ) ; return NULL ; } | <S2SV_ModStart> item ) ; if ( res_used > PY_SSIZE_T_MAX - itemlen ) goto Overflow ; <S2SV_ModStart> ; if ( <S2SV_ModEnd> i < seqlen <S2SV_ModStart> 1 ) { if ( new_res_used > PY_SSIZE_T_MAX - seplen ) goto Overflow ; <S2SV_ModStart> += seplen ; <S2SV_ModEnd> } if ( <S2SV_ModStart> { do { if ( res_alloc > PY_SSIZE_T_MAX / 2 ) goto Overflow ; <S2SV_ModStart> res_alloc += res_alloc <S2SV_ModEnd> ; } while |
3,366 | CWE-000 static struct xio_cq * xio_cq_get ( struct xio_device * dev , struct xio_context * ctx ) { struct xio_cq * tcq ; int num_cores = num_online_cpus ( ) ; u32 alloc_sz ; int cpu ; read_lock_bh ( & dev -> cq_lock ) ; list_for_each_entry ( tcq , & dev -> cq_list , cq_list_entry ) { if ( tcq -> ctx == ctx ) { kref_get ( & tcq -> kref ) ; read_unlock_bh ( & dev -> cq_lock ) ; return tcq ; } } read_unlock_bh ( & dev -> cq_lock ) ; if ( ctx -> cpuid < 0 || ctx -> cpuid >= num_cores ) { ERROR_LOG ( "BUG,<S2SV_blank>wrong<S2SV_blank>cpuid(%d)<S2SV_blank>check<S2SV_blank>init\\n" , ctx -> cpuid ) ; goto cleanup0 ; } else { cpu = ctx -> cpuid ; } cpu = cpu % dev -> cqs_used ; tcq = kzalloc ( sizeof ( * tcq ) , GFP_KERNEL ) ; if ( ! tcq ) { ERROR_LOG ( "xio_cq_init<S2SV_blank>kzalloc<S2SV_blank>failed\\n" ) ; goto cleanup0 ; } tcq -> alloc_sz = min ( dev -> device_attr . max_cqe , CQE_ALLOC_SIZE ) ; alloc_sz = tcq -> alloc_sz ; tcq -> wc_array = kcalloc ( MAX_POLL_WC , sizeof ( struct ib_wc ) , GFP_KERNEL ) ; if ( ! tcq -> wc_array ) { xio_set_error ( ENOMEM ) ; ERROR_LOG ( "wc<S2SV_blank>array<S2SV_blank>allocation<S2SV_blank>failed\\n" ) ; goto cleanup1 ; } tcq -> ctx = ctx ; tcq -> dev = dev ; tcq -> max_cqe = dev -> device_attr . max_cqe ; tcq -> wc_array_len = MAX_POLL_WC ; INIT_LIST_HEAD ( & tcq -> trans_list ) ; INIT_LIST_HEAD ( & tcq -> cq_list_entry ) ; <S2SV_StartBug> # if LINUX_VERSION_CODE < KERNEL_VERSION ( 4 , 2 , 0 ) <S2SV_EndBug> tcq -> cq = ib_create_cq ( dev -> ib_dev , xio_cq_data_callback , xio_cq_event_callback , ( void * ) tcq , alloc_sz , cpu ) ; # else { struct ib_cq_init_attr ia = { . cqe = alloc_sz , . comp_vector = cpu , } ; tcq -> cq = ib_create_cq ( dev -> ib_dev , xio_cq_data_callback , xio_cq_event_callback , ( void * ) tcq , & ia ) ; } # endif if ( IS_ERR ( tcq -> cq ) ) { ERROR_LOG ( "ib_create_cq<S2SV_blank>err(%ld)\\n" , PTR_ERR ( tcq -> cq ) ) ; goto cleanup2 ; } tcq -> cq_depth = tcq -> cq -> cqe ; tcq -> cqe_avail = tcq -> cq -> cqe ; # if 0 if ( xio_rdma_cq_completions && xio_rdma_cq_timeout ) { if ( xio_rdma_cq_completions > 0xffff || xio_rdma_cq_timeout > 0xffff ) { ERROR_LOG ( "invalid<S2SV_blank>CQ<S2SV_blank>moderation<S2SV_blank>values\\n" ) ; } else { ret = ib_modify_cq ( tcq -> cq , xio_rdma_cq_completions , xio_rdma_cq_timeout ) ; if ( ret && ret != - ENOSYS ) { ERROR_LOG ( "failed<S2SV_blank>modifying<S2SV_blank>CQ<S2SV_blank>(%d)\\n" , ret ) ; goto cleanup3 ; } } } # endif if ( ib_req_notify_cq ( tcq -> cq , IB_CQ_NEXT_COMP | IB_CQ_REPORT_MISSED_EVENTS ) ) { ERROR_LOG ( "ib_req_notify_cq\\n" ) ; goto cleanup3 ; } write_lock_bh ( & dev -> cq_lock ) ; list_add ( & tcq -> cq_list_entry , & dev -> cq_list ) ; write_unlock_bh ( & dev -> cq_lock ) ; kref_init ( & tcq -> kref ) ; kref_get ( & tcq -> kref ) ; XIO_OBSERVER_INIT ( & tcq -> observer , tcq , xio_on_context_event ) ; xio_context_reg_observer ( ctx , & tcq -> observer ) ; xio_context_set_poll_completions_fn ( ctx , ( poll_completions_fn_t ) xio_rdma_poll_completions , tcq ) ; return tcq ; cleanup3 : ib_destroy_cq ( tcq -> cq ) ; cleanup2 : kfree ( tcq -> wc_array ) ; cleanup1 : kfree ( tcq ) ; cleanup0 : ERROR_LOG ( "xio_cq_init<S2SV_blank>failed\\n" ) ; return NULL ; } | <S2SV_ModStart> ( 4 , 5 <S2SV_ModEnd> , 0 ) |
3,367 | CWE-000 void sgw_cm_free_pdn_connection ( sgw_pdn_connection_t * pdn_connectionP ) { if ( pdn_connectionP ) { if ( pdn_connectionP -> apn_in_use ) { free_wrapper ( ( void * * ) & pdn_connectionP -> apn_in_use ) ; } for ( int ebix = 0 ; ebix < BEARERS_PER_UE ; ebix ++ ) { sgw_free_sgw_eps_bearer_context ( & pdn_connectionP -> sgw_eps_bearers_array [ ebix ] ) ; <S2SV_StartBug> } <S2SV_EndBug> } } | <S2SV_ModStart> ] ) ; pdn_connectionP -> sgw_eps_bearers_array [ ebix ] = NULL ; |
3,368 | CWE-000 static int unix_stream_sendmsg ( struct kiocb * kiocb , struct socket * sock , struct msghdr * msg , size_t len ) { struct sock_iocb * siocb = kiocb_to_siocb ( kiocb ) ; struct sock * sk = sock -> sk ; struct sock * other = NULL ; int err , size ; struct sk_buff * skb ; int sent = 0 ; struct scm_cookie tmp_scm ; bool fds_sent = false ; int max_level ; int data_len ; if ( NULL == siocb -> scm ) siocb -> scm = & tmp_scm ; wait_for_unix_gc ( ) ; err = scm_send ( sock , msg , siocb -> scm , false ) ; if ( err < 0 ) return err ; err = - EOPNOTSUPP ; if ( msg -> msg_flags & MSG_OOB ) goto out_err ; if ( msg -> msg_namelen ) { err = sk -> sk_state == TCP_ESTABLISHED ? - EISCONN : - EOPNOTSUPP ; goto out_err ; } else { err = - ENOTCONN ; other = unix_peer ( sk ) ; if ( ! other ) goto out_err ; } if ( sk -> sk_shutdown & SEND_SHUTDOWN ) goto pipe_err ; while ( sent < len ) { size = len - sent ; size = min_t ( int , size , ( sk -> sk_sndbuf >> 1 ) - 64 ) ; size = min_t ( int , size , SKB_MAX_HEAD ( 0 ) + UNIX_SKB_FRAGS_SZ ) ; data_len = max_t ( int , 0 , size - SKB_MAX_HEAD ( 0 ) ) ; skb = sock_alloc_send_pskb ( sk , size - data_len , data_len , msg -> msg_flags & MSG_DONTWAIT , & err ) ; if ( ! skb ) goto out_err ; err = unix_scm_to_skb ( siocb -> scm , skb , ! fds_sent ) ; if ( err < 0 ) { kfree_skb ( skb ) ; goto out_err ; } max_level = err + 1 ; fds_sent = true ; skb_put ( skb , size - data_len ) ; skb -> data_len = data_len ; skb -> len = size ; <S2SV_StartBug> err = skb_copy_datagram_from_iovec ( skb , 0 , msg -> msg_iov , 0 , size ) ; <S2SV_EndBug> if ( err ) { kfree_skb ( skb ) ; goto out_err ; } unix_state_lock ( other ) ; if ( sock_flag ( other , SOCK_DEAD ) || ( other -> sk_shutdown & RCV_SHUTDOWN ) ) goto pipe_err_free ; maybe_add_creds ( skb , sock , other ) ; skb_queue_tail ( & other -> sk_receive_queue , skb ) ; if ( max_level > unix_sk ( other ) -> recursion_level ) unix_sk ( other ) -> recursion_level = max_level ; unix_state_unlock ( other ) ; other -> sk_data_ready ( other , size ) ; sent += size ; } scm_destroy ( siocb -> scm ) ; siocb -> scm = NULL ; return sent ; pipe_err_free : unix_state_unlock ( other ) ; kfree_skb ( skb ) ; pipe_err : if ( sent == 0 && ! ( msg -> msg_flags & MSG_NOSIGNAL ) ) send_sig ( SIGPIPE , current , 0 ) ; err = - EPIPE ; out_err : scm_destroy ( siocb -> scm ) ; siocb -> scm = NULL ; return sent ? : err ; } | <S2SV_ModStart> -> msg_iov , sent <S2SV_ModEnd> , size ) |
3,369 | CWE-000 int main ( ) { f_info * file = get_file_content ( FILE_DIR ) ; size_t mod = file -> size % THREAD_NUMBER ; size_t work_per_thread = file -> size / THREAD_NUMBER ; size_t i = 0 ; static size_t palindrome = 0 ; m_pack m_palindrome ; mutex_package_init ( & m_palindrome , & palindrome ) ; pthread_t * t = ( pthread_t * ) malloc ( sizeof ( pthread_t ) * THREAD_NUMBER ) ; t_pack * per_thread = ( t_pack * ) malloc ( sizeof ( t_pack ) * THREAD_NUMBER ) ; # ifdef DEBUG printf ( "O<S2SV_blank>arquivo<S2SV_blank>tem<S2SV_blank>%u<S2SV_blank>letras.\\n" , ( unsigned int ) file -> size ) ; # endif for ( i = 0 ; i < THREAD_NUMBER ; i ++ ) { thread_package_init ( per_thread + i , file , i , work_per_thread , & m_palindrome ) ; <S2SV_StartBug> ( per_thread + i ) -> is_last_thread = ( i == THREAD_NUMBER - 1 && mod != 0 ) ; <S2SV_EndBug> <S2SV_StartBug> pthread_create ( t + i , NULL , thread_callback , per_thread + i ) ; <S2SV_EndBug> } <S2SV_StartBug> for ( i = 0 ; i < THREAD_NUMBER ; i ++ ) { <S2SV_EndBug> pthread_join ( * ( t + i ) , NULL ) ; } } | <S2SV_ModStart> m_palindrome ) ; pthread_create ( t + i , NULL , thread_callback , <S2SV_ModEnd> per_thread + i <S2SV_ModStart> + i ) ; } for ( i = 0 ; i < THREAD_NUMBER ; i ++ ) { pthread_join ( * <S2SV_ModEnd> ( t + <S2SV_ModStart> t + i ) , NULL <S2SV_ModEnd> ) ; } <S2SV_ModStart> ) ; } # ifdef SHOW_RESULT printf ( "PALINDROMOS<S2SV_blank>%u\\n" , ( unsigned int ) palindrome ) ; # endif <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
3,370 | CWE-000 int is_this_chippro ( void ) { int is_pro = 0 ; struct sysinfo si ; sysinfo ( & si ) ; <S2SV_StartBug> if ( ( si . totalram / MEGABYTE ) > RAMDETERMINER ) { <S2SV_EndBug> is_pro = 0 ; <S2SV_StartBug> } else { <S2SV_EndBug> <S2SV_StartBug> is_pro = 1 ; <S2SV_EndBug> } return is_pro ; } | <S2SV_ModStart> si ) ; const double megabyte = 1024 * 1024 ; if ( DEBUG ) printf ( "<S2SV_blank>**<S2SV_blank>is_this_chippro:<S2SV_blank>total<S2SV_blank>system<S2SV_blank>ram:<S2SV_blank>%5.1f<S2SV_blank>mb\\n" , si . totalram / megabyte ) ; <S2SV_ModStart> . totalram / megabyte <S2SV_ModEnd> ) > RAMDETERMINER <S2SV_ModStart> = 0 ; if ( DEBUG ) printf ( "<S2SV_blank>**<S2SV_blank>is_this_chippro:<S2SV_blank>we<S2SV_blank>are<S2SV_blank>a<S2SV_blank>chip\\n" ) ; <S2SV_ModStart> is_pro = 1 ; if ( DEBUG ) printf ( "<S2SV_blank>**<S2SV_blank>is_this_chippro:<S2SV_blank>we<S2SV_blank>are<S2SV_blank>a<S2SV_blank>chip<S2SV_blank>pro\\n" ) |
3,371 | CWE-000 static ssize_t mdss_debug_base_reg_read ( struct file * file , char __user * user_buf , size_t count , loff_t * ppos ) { struct mdss_debug_base * dbg = file -> private_data ; struct mdss_data_type * mdata = mdss_res ; size_t len ; if ( ! dbg || ! mdata ) { pr_err ( "invalid<S2SV_blank>handle\\n" ) ; return - ENODEV ; } <S2SV_StartBug> mutex_lock ( & mdss_debug_lock ) ; <S2SV_EndBug> if ( ! dbg -> buf ) { char dump_buf [ 64 ] ; char * ptr ; int cnt , tot ; dbg -> buf_len = sizeof ( dump_buf ) * DIV_ROUND_UP ( dbg -> cnt , ROW_BYTES ) ; dbg -> buf = kzalloc ( dbg -> buf_len , GFP_KERNEL ) ; if ( ! dbg -> buf ) { pr_err ( "not<S2SV_blank>enough<S2SV_blank>memory<S2SV_blank>to<S2SV_blank>hold<S2SV_blank>reg<S2SV_blank>dump\\n" ) ; <S2SV_StartBug> mutex_unlock ( & mdss_debug_lock ) ; <S2SV_EndBug> return - ENOMEM ; } ptr = dbg -> base + dbg -> off ; tot = 0 ; if ( mdata -> debug_inf . debug_enable_clock ) mdata -> debug_inf . debug_enable_clock ( 1 ) ; for ( cnt = dbg -> cnt ; cnt > 0 ; cnt -= ROW_BYTES ) { hex_dump_to_buffer ( ptr , min ( cnt , ROW_BYTES ) , ROW_BYTES , GROUP_BYTES , dump_buf , sizeof ( dump_buf ) , false ) ; len = scnprintf ( dbg -> buf + tot , dbg -> buf_len - tot , "0x%08x:<S2SV_blank>%s\\n" , ( ( int ) ( unsigned long ) ptr ) - ( ( int ) ( unsigned long ) dbg -> base ) , dump_buf ) ; ptr += ROW_BYTES ; tot += len ; if ( tot >= dbg -> buf_len ) break ; } if ( mdata -> debug_inf . debug_enable_clock ) mdata -> debug_inf . debug_enable_clock ( 0 ) ; dbg -> buf_len = tot ; } <S2SV_StartBug> if ( * ppos >= dbg -> buf_len ) { <S2SV_EndBug> mutex_unlock ( & mdss_debug_lock ) ; return 0 ; <S2SV_StartBug> } <S2SV_EndBug> len = min ( count , dbg -> buf_len - ( size_t ) * ppos ) ; if ( copy_to_user ( user_buf , dbg -> buf + * ppos , len ) ) { pr_err ( "failed<S2SV_blank>to<S2SV_blank>copy<S2SV_blank>to<S2SV_blank>user\\n" ) ; <S2SV_StartBug> mutex_unlock ( & mdss_debug_lock ) ; <S2SV_EndBug> return - EFAULT ; } * ppos += len ; <S2SV_StartBug> mutex_unlock ( & mdss_debug_lock ) ; <S2SV_EndBug> return len ; } | <S2SV_ModStart> ENODEV ; } <S2SV_ModEnd> if ( ! <S2SV_ModStart> "not<S2SV_blank>enough<S2SV_blank>memory<S2SV_blank>to<S2SV_blank>hold<S2SV_blank>reg<S2SV_blank>dump\\n" ) ; <S2SV_ModEnd> return - ENOMEM <S2SV_ModStart> -> buf_len ) <S2SV_ModEnd> return 0 ; <S2SV_ModStart> return 0 ; <S2SV_ModEnd> len = min <S2SV_ModStart> "failed<S2SV_blank>to<S2SV_blank>copy<S2SV_blank>to<S2SV_blank>user\\n" ) ; <S2SV_ModEnd> return - EFAULT <S2SV_ModStart> += len ; <S2SV_ModEnd> return len ; |
3,372 | CWE-000 void pktDisablePWM ( AFSKDemodDriver * myDriver ) { chDbgAssert ( myDriver -> icudriver != NULL , "no<S2SV_blank>ICU<S2SV_blank>driver" ) ; chSysLock ( ) ; <S2SV_StartBug> pktClosePWMChannelI ( myDriver -> icudriver , 0 , PWM_TERM_DECODE_STOP ) ; <S2SV_EndBug> icuStopCaptureI ( myDriver -> icudriver ) ; pktStopAllICUTimersI ( myDriver -> icudriver ) ; palDisableLineEventI ( LINE_CCA ) ; myDriver -> icustate = PKT_PWM_STOP ; chSchRescheduleS ( ) ; chSysUnlock ( ) ; } | <S2SV_ModStart> -> icudriver , EVT_NONE <S2SV_ModEnd> , PWM_TERM_DECODE_STOP ) |
3,373 | CWE-000 struct StringLst * tokenize ( struct String * vimbuf ) { char * cpy = malloc ( vimbuf -> len + 1 ) ; memcpy ( cpy , vimbuf -> s , vimbuf -> len ) ; cpy [ vimbuf -> len ] = '\\0' ; add_backup ( & backup_pointers , cpy ) ; struct StringLst * list = malloc ( sizeof * list ) ; * list = ( struct StringLst ) { . lst = nmalloc ( INIT_STRINGS , sizeof ( struct String * ) ) , . num = 0 , . max = INIT_STRINGS } ; # if 0 const struct cmp_funcs * f = & cmp_functions [ 0 ] ; for ( size_t i = 1 , size = ARRSIZ ( cmp_functions ) ; i < size ; ++ i ) { if ( streq ( lang , cmp_functions [ i ] . lang ) ) { f = & cmp_functions [ i ] ; break ; } } # endif <S2SV_StartBug> switch ( lang_id ) { <S2SV_EndBug> case _VIM_ : tokenize_vim ( list , cpy , vim_func ) ; break ; default : do_tokenize ( list , cpy , c_func ) ; break ; } return list ; } | <S2SV_ModStart> switch ( lang_id -> id |
3,374 | CWE-000 int mutt_get_tmp_attachment ( BODY * a ) { char type [ STRING ] ; char tempfile [ _POSIX_PATH_MAX ] ; <S2SV_StartBug> rfc1524_entry * entry = rfc1524_new_entry ( ) ; <S2SV_EndBug> FILE * fpin = NULL , * fpout = NULL ; struct stat st ; if ( a -> unlink ) <S2SV_StartBug> return 0 ; <S2SV_EndBug> snprintf ( type , sizeof ( type ) , "%s/%s" , TYPE ( a ) , a -> subtype ) ; rfc1524_mailcap_lookup ( a , type , entry , 0 ) ; rfc1524_expand_filename ( entry -> nametemplate , a -> filename , tempfile , sizeof ( tempfile ) ) ; rfc1524_free_entry ( & entry ) ; if ( stat ( a -> filename , & st ) == - 1 ) return - 1 ; if ( ( fpin = fopen ( a -> filename , "r" ) ) && ( fpout = safe_fopen ( tempfile , "w" ) ) ) { mutt_copy_stream ( fpin , fpout ) ; mutt_str_replace ( & a -> filename , tempfile ) ; a -> unlink = 1 ; if ( a -> stamp >= st . st_mtime ) mutt_stamp_attachment ( a ) ; } else mutt_perror ( fpin ? tempfile : a -> filename ) ; if ( fpin ) safe_fclose ( & fpin ) ; if ( fpout ) safe_fclose ( & fpout ) ; return a -> unlink ? 0 : - 1 ; } | <S2SV_ModStart> _POSIX_PATH_MAX ] ; <S2SV_ModEnd> FILE * fpin <S2SV_ModStart> ) return 0 ; rfc1524_entry * entry = rfc1524_new_entry ( ) |
3,375 | CWE-000 <S2SV_StartBug> static int _calc_add_hours ( jy * dt , int hours ) <S2SV_EndBug> { <S2SV_StartBug> int overflow ; <S2SV_EndBug> <S2SV_StartBug> overflow = ( dt -> jy_hour + hours ) / 24 ; <S2SV_EndBug> <S2SV_StartBug> dt -> jy_hour = ( dt -> jy_hour + hours ) % 24 ; <S2SV_EndBug> return overflow ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> static uint_fast64_t <S2SV_ModEnd> _calc_add_hours ( jy <S2SV_ModStart> * dt , uint_fast64_t <S2SV_ModEnd> hours ) { <S2SV_ModStart> hours ) { uint_fast64_t <S2SV_ModEnd> overflow ; overflow <S2SV_ModStart> ; overflow = <S2SV_ModEnd> dt -> jy_hour <S2SV_ModStart> jy_hour + hours <S2SV_ModEnd> / 24 ; <S2SV_ModStart> -> jy_hour = <S2SV_ModEnd> dt -> jy_hour <S2SV_ModStart> jy_hour + hours <S2SV_ModEnd> % 24 ; |
3,376 | CWE-000 static int socket_and_bind ( struct dhcpd * dd ) { if ( ( dd -> s = socket ( AF_INET , SOCK_DGRAM , 0 ) ) < 0 ) { perror ( "server<S2SV_blank>socket<S2SV_blank>open<S2SV_blank>error" ) ; exit ( 1 ) ; } <S2SV_StartBug> bzero ( & ( dd -> myskt ) , sizeof dd -> myskt ) ; <S2SV_EndBug> in_port_t portnum = DHCPSERVERPORT ; dd -> myskt . sin_family = AF_INET ; dd -> myskt . sin_port = htons ( portnum ) ; dd -> myskt . sin_addr . s_addr = htonl ( INADDR_ANY ) ; struct in_addr test ; test . s_addr = ntohl ( dd -> myskt . sin_addr . s_addr ) ; fprintf ( stderr , "DHCP<S2SV_blank>server<S2SV_blank><S2SV_blank>ip<S2SV_blank>is:<S2SV_blank>%s\\n" , inet_ntoa ( test ) ) ; int count ; if ( ( count = bind ( dd -> s , ( struct sockaddr * ) & ( dd -> myskt ) , sizeof dd -> myskt ) ) < 0 ) { perror ( "server<S2SV_blank>bind<S2SV_blank>error" ) ; exit ( 1 ) ; } return 0 ; } | <S2SV_ModStart> ) ; } <S2SV_ModEnd> in_port_t portnum = |
3,377 | CWE-000 int gettimeofday ( struct timeval * tv , void * tz ) { union { FILETIME ft ; unsigned long long ns ; } timehelper ; unsigned long long us ; GetSystemTimeAsFileTime ( & timehelper . ft ) ; <S2SV_StartBug> us = timehelper . ns - EPOCH_DELTA_US ; <S2SV_EndBug> <S2SV_StartBug> tv -> tv_sec = ( long ) ( us / RATE_DIFF ) ; <S2SV_EndBug> <S2SV_StartBug> tv -> tv_usec = ( long ) ( us % RATE_DIFF ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> ; us = ( <S2SV_ModStart> . ns - EPOCH_DELTA ) / 10 <S2SV_ModEnd> ; tv -> <S2SV_ModStart> ( us / USEC_IN_SEC <S2SV_ModEnd> ) ; tv <S2SV_ModStart> ( us % USEC_IN_SEC <S2SV_ModEnd> ) ; return |
3,378 | CWE-000 void gkRenderModel ( GkScene * scene , GkModelInst * modelInst , GkMatrix * pmat , GkProgInfo * pprog ) { GkModel * model ; GkPrimitive * primi ; GkMatrix * mat ; GkProgInfo * prog ; GkMaterial * modelMaterial ; model = modelInst -> model ; mat = modelInst -> matrix ; prog = model -> pinfo ; gkUniformMatrix ( modelInst ) ; <S2SV_StartBug> modelMaterial = NULL ; <S2SV_EndBug> if ( ! modelInst -> prims || modelInst -> material || modelInst -> model -> material ) { modelMaterial = modelInst -> material ; if ( ! modelMaterial ) <S2SV_StartBug> modelMaterial = modelInst -> model -> material ; <S2SV_EndBug> gkUniformMaterial ( prog , modelMaterial ) ; } if ( model -> events && model -> events -> onDraw ) model -> events -> onDraw ( model , NULL , false ) ; if ( scene -> currentProgram != model -> pinfo -> prog ) { glUseProgram ( model -> pinfo -> prog ) ; scene -> currentProgram = model -> pinfo -> prog ; } primi = model -> prim ; while ( primi ) { glBindVertexArray ( primi -> vao ) ; if ( modelInst -> prims ) { GkPrimInst * primInst ; GkMaterial * material ; primInst = rb_find ( modelInst -> prims , primi ) ; material = modelMaterial ; if ( primInst ) <S2SV_StartBug> material = primInst -> material ; <S2SV_EndBug> gkUniformMaterial ( prog , material ) ; } if ( primi -> flags & GK_DRAW_ELEMENTS ) glDrawElements ( primi -> mode , primi -> count , GL_UNSIGNED_INT , NULL ) ; else if ( primi -> flags & GK_DRAW_ARRAYS ) glDrawArrays ( primi -> mode , 0 , primi -> count ) ; primi = primi -> next ; } glBindVertexArray ( 0 ) ; if ( model -> events && model -> events -> onDraw ) model -> events -> onDraw ( model , NULL , true ) ; if ( ( model -> flags & GK_MODEL_FLAGS_DRAW_BBOX ) && model -> bbox ) gkDrawBBox ( scene , mat -> cmat , model -> bbox -> min , model -> bbox -> max ) ; } | <S2SV_ModStart> modelInst ) ; if ( prog -> updtLights ) gkUniformLights ( scene , prog ) ; <S2SV_ModStart> -> material ; if ( prog -> lastMaterial != modelMaterial || prog -> updtMaterials ) <S2SV_ModStart> -> material ; if ( prog -> lastMaterial != material || prog -> updtMaterials ) |
3,379 | CWE-000 int main ( int argc , char * * argv ) { <S2SV_StartBug> int i , limit ; <S2SV_EndBug> unsigned short * sieve ; unsigned long long * primes ; if ( argc < 2 ) { printf ( "Must<S2SV_blank>provide<S2SV_blank>limit<S2SV_blank>for<S2SV_blank>prime<S2SV_blank>calculations.<S2SV_blank>Usage:<S2SV_blank>sieve<S2SV_blank>LIMIT\\n" ) ; return 1 ; } <S2SV_StartBug> limit = atoi ( argv [ 1 ] ) ; <S2SV_EndBug> if ( limit < 5 ) { printf ( "limit<S2SV_blank>is<S2SV_blank>too<S2SV_blank>small.\\n" ) ; } <S2SV_StartBug> primes = calloc ( limit * 1 , sizeof ( unsigned long long ) ) ; <S2SV_EndBug> sieve = calloc ( limit + 1 , sizeof ( unsigned short ) ) ; sieve_atkin ( primes , sieve , limit ) ; } | <S2SV_ModStart> { int i ; long limit , approx_num_primes <S2SV_ModEnd> ; unsigned short <S2SV_ModStart> } limit = atoll <S2SV_ModEnd> ( argv [ <S2SV_ModStart> ) ; } approx_num_primes = ( unsigned long ) ( ( limit / log ( limit ) ) * ( 1 + ( 1.2762 / log ( limit ) ) ) ) ; <S2SV_ModStart> = calloc ( approx_num_primes <S2SV_ModEnd> , sizeof ( <S2SV_ModStart> sizeof ( unsigned <S2SV_ModEnd> long ) ) |
3,380 | CWE-000 static void unminimize_done ( ClutterActor * actor , MetaPlugin * plugin ) { g_signal_handlers_disconnect_by_func ( actor , unminimize_done , plugin ) ; meta_plugin_unminimize_completed ( plugin , META_WINDOW_ACTOR ( actor ) ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ) ) ; g_object_set_data ( G_OBJECT ( actor ) , "unminimizing" , ( gpointer ) FALSE ) ; |
3,381 | CWE-000 int Rx_Parse ( RxTx * ptr , u8 * data , u16 len , void * userdata ) { u16 i ; for ( i = 0 ; i < len ; i ++ ) { u8 c = data [ i ] ; ptr -> rx_ptr [ ptr -> rx_len ++ ] = c ; switch ( ptr -> rx_st ) { case RXS_PARSE_HDR : if ( ptr -> rx_len <= MAGIC_SIZE && c != pc_magic [ ptr -> rx_len - 1 ] ) { RTX_LOG ( "Magic<S2SV_blank>mismatch<S2SV_blank>%02X<S2SV_blank>!=<S2SV_blank>%02X" , c , pc_magic [ ptr -> rx_len - 1 ] ) ; ptr -> rx_len = 0 ; } else if ( ptr -> rx_len >= HDR_SIZE ) { memcpy ( & ptr -> rx_hdr , ptr -> rx_buf , HDR_SIZE ) ; if ( MSG_LEN ( ptr -> rx_hdr . msg_len ) > MAX_DATA_SIZE ) { RTX_LOG ( "Msg<S2SV_blank>too<S2SV_blank>long<S2SV_blank>%d" , MSG_LEN ( ptr -> rx_hdr . msg_len ) ) ; ptr -> rx_len = 0 ; } else if ( ptr -> rx_hdr . msg_type >= MSG_MAX_T ) { RTX_LOG ( "Unknown<S2SV_blank>msg<S2SV_blank>type<S2SV_blank>%d" , ptr -> rx_hdr . msg_type ) ; ptr -> rx_len = 0 ; } else if ( ptr -> rx_hdr . msg_len > 0 ) { ptr -> rx_ptr = ( u8 * ) ptr -> rx_buf + ptr -> rx_len ; ptr -> rx_len = 0 ; Rx_SetState ( ptr , RXS_PARSE_DATA ) ; } else { ptr -> rx_len = 0 ; ptr -> rx_ptr = ( u8 * ) & ptr -> rx_crc ; Rx_SetState ( ptr , RXS_PARSE_CRC ) ; } } break ; case RXS_PARSE_DATA : if ( ptr -> rx_len >= MSG_LEN ( ptr -> rx_hdr . msg_len ) ) { ptr -> rx_len = 0 ; ptr -> rx_ptr = ( u8 * ) & ptr -> rx_crc ; Rx_SetState ( ptr , RXS_PARSE_CRC ) ; } break ; case RXS_PARSE_CRC : if ( ptr -> rx_len >= CRC_SIZE ) { ptr -> rx_crc = ntohl ( ptr -> rx_crc ) ; if ( CRC_CHECK ( ptr -> rx_buf , MSG_LEN ( ptr -> rx_hdr . msg_len ) + HDR_SIZE , ptr -> rx_crc ) ) { int term = Rx_MsgProc ( ptr , userdata , ptr -> rx_crc ) ; if ( term != R_NO_ERR ) { return term ; } } <S2SV_StartBug> ptr -> rx_len = 0 ; <S2SV_EndBug> ptr -> rx_ptr = ptr -> rx_buf ; Rx_SetState ( ptr , RXS_START ) ; } break ; default : SL_ASSERT ( 0 ) ; break ; } } return R_NO_ERR ; } | <S2SV_ModStart> ; } } else { RTX_ERR ( "CRC<S2SV_blank>check<S2SV_blank>fail" ) ; } |
3,382 | CWE-000 void process_delete_object_notification ( plasma_manager_state * state , object_info object_info ) { object_id obj_id = object_info . obj_id ; available_object * entry ; HASH_FIND ( hh , state -> local_available_objects , & obj_id , sizeof ( obj_id ) , entry ) ; if ( entry != NULL ) { HASH_DELETE ( hh , state -> local_available_objects , entry ) ; free ( entry ) ; } if ( state -> db ) { retry_info retry = { . num_retries = NUM_RETRIES , . timeout = MANAGER_TIMEOUT , <S2SV_StartBug> . fail_callback = NULL , <S2SV_EndBug> } ; object_table_remove ( state -> db , obj_id , NULL , & retry , NULL , NULL ) ; } } | <S2SV_ModStart> . fail_callback = fatal_table_callback <S2SV_ModEnd> , } ; |
3,383 | CWE-000 int engine_set_moduledir ( struct engine * engine , const char * moduledir ) { if ( ! engine || ! moduledir ) { return kr_error ( EINVAL ) ; } char * new_moduledir = strdup ( moduledir ) ; if ( ! new_moduledir ) { return kr_error ( ENOMEM ) ; } if ( engine -> moduledir ) { free ( engine -> moduledir ) ; } engine -> moduledir = new_moduledir ; char l_paths [ MAXPATHLEN ] = { 0 } ; <S2SV_StartBug> snprintf ( l_paths , MAXPATHLEN - 1 , <S2SV_EndBug> "if<S2SV_blank>package._path<S2SV_blank>==<S2SV_blank>nil<S2SV_blank>then<S2SV_blank>package._path<S2SV_blank>=<S2SV_blank>package.path<S2SV_blank>end\\n" "package.path<S2SV_blank>=<S2SV_blank>\'%1$s/?.lua;%1$s/?/init.lua;\'..package._path\\n" "if<S2SV_blank>package._cpath<S2SV_blank>==<S2SV_blank>nil<S2SV_blank>then<S2SV_blank>package._cpath<S2SV_blank>=<S2SV_blank>package.cpath<S2SV_blank>end\\n" "package.cpath<S2SV_blank>=<S2SV_blank>\'%1$s/?%2$s;\'..package._cpath\\n" , <S2SV_StartBug> new_moduledir , LIBEXT ) ; <S2SV_EndBug> int ret = l_dobytecode ( engine -> L , l_paths , strlen ( l_paths ) , "" ) ; if ( ret != 0 ) { lua_pop ( engine -> L , 1 ) ; return ret ; } return 0 ; } | <S2SV_ModStart> 0 } ; # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wformat" <S2SV_ModStart> LIBEXT ) ; # pragma GCC diagnostic pop |
3,384 | CWE-000 static void power_suspend ( struct work_struct * work ) { struct power_suspend * pos ; unsigned long irqflags ; int abort = 0 ; <S2SV_StartBug> dprintk ( "[POWERSUSPEND]<S2SV_blank>entering<S2SV_blank>suspend...\\n" ) ; <S2SV_EndBug> mutex_lock ( & power_suspend_lock ) ; spin_lock_irqsave ( & state_lock , irqflags ) ; if ( state == POWER_SUSPEND_INACTIVE ) abort = 1 ; spin_unlock_irqrestore ( & state_lock , irqflags ) ; if ( abort ) goto abort_suspend ; <S2SV_StartBug> dprintk ( "[POWERSUSPEND]<S2SV_blank>suspending...\\n" ) ; <S2SV_EndBug> list_for_each_entry ( pos , & power_suspend_handlers , link ) { if ( pos -> suspend != NULL ) { pos -> suspend ( pos ) ; } } <S2SV_StartBug> dprintk ( "[POWERSUSPEND]<S2SV_blank>suspend<S2SV_blank>completed.\\n" ) ; <S2SV_EndBug> abort_suspend : mutex_unlock ( & power_suspend_lock ) ; } | <S2SV_ModStart> = 0 ; # ifdef POWER_SUSPEND_DEBUG pr_info <S2SV_ModEnd> ( "[POWERSUSPEND]<S2SV_blank>entering<S2SV_blank>suspend...\\n" ) <S2SV_ModStart> "[POWERSUSPEND]<S2SV_blank>entering<S2SV_blank>suspend...\\n" ) ; # endif <S2SV_ModStart> goto abort_suspend ; # ifdef POWER_SUSPEND_DEBUG pr_info <S2SV_ModEnd> ( "[POWERSUSPEND]<S2SV_blank>suspending...\\n" ) <S2SV_ModStart> "[POWERSUSPEND]<S2SV_blank>suspending...\\n" ) ; # endif <S2SV_ModStart> ; } } # ifdef POWER_SUSPEND_DEBUG pr_info <S2SV_ModEnd> ( "[POWERSUSPEND]<S2SV_blank>suspend<S2SV_blank>completed.\\n" ) <S2SV_ModStart> "[POWERSUSPEND]<S2SV_blank>suspend<S2SV_blank>completed.\\n" ) ; # endif |
3,385 | CWE-000 ASN1_INTEGER * c2i_ASN1_INTEGER ( ASN1_INTEGER * * a , const unsigned char * * pp , long len ) { ASN1_INTEGER * ret = NULL ; size_t r ; int neg ; r = c2i_ibuf ( NULL , NULL , * pp , len ) ; if ( r == 0 ) return NULL ; if ( ( a == NULL ) || ( ( * a ) == NULL ) ) { ret = ASN1_INTEGER_new ( ) ; if ( ret == NULL ) return NULL ; ret -> type = V_ASN1_INTEGER ; } else ret = * a ; <S2SV_StartBug> if ( ASN1_STRING_set ( ret , NULL , r ) == 0 ) <S2SV_EndBug> goto err ; c2i_ibuf ( ret -> data , & neg , * pp , len ) ; if ( neg ) ret -> type |= V_ASN1_NEG ; * pp += len ; if ( a != NULL ) ( * a ) = ret ; return ret ; err : ASN1err ( ASN1_F_C2I_ASN1_INTEGER , ERR_R_MALLOC_FAILURE ) ; if ( ( a == NULL ) || ( * a != ret ) ) ASN1_INTEGER_free ( ret ) ; return NULL ; } | <S2SV_ModStart> , NULL , ( int ) |
3,386 | CWE-000 void pretty_print_classless_routes ( unsigned char * src , size_t srclen , unsigned char * buf , size_t buflen ) { char bitsbuf [ 5 ] ; struct in_addr dest , netmask , gateway ; <S2SV_StartBug> unsigned int i , len ; <S2SV_EndBug> int rslt ; i = 0 ; while ( i < srclen ) { len = extract_classless_route ( & src [ i ] , srclen - i , & dest . s_addr , & netmask . s_addr , & gateway . s_addr ) ; if ( len == 0 ) goto bad ; i += len ; <S2SV_StartBug> rslt = snprintf ( bitsbuf , sizeof ( bitsbuf ) , "/%d<S2SV_blank>" , <S2SV_EndBug> <S2SV_StartBug> 33 - ffs ( netmask . s_addr ) ) ; <S2SV_EndBug> if ( rslt == - 1 || ( unsigned int ) rslt >= sizeof ( bitsbuf ) ) goto bad ; if ( strlen ( buf ) > 0 ) strlcat ( buf , ",<S2SV_blank>" , buflen ) ; strlcat ( buf , inet_ntoa ( dest ) , buflen ) ; strlcat ( buf , bitsbuf , buflen ) ; if ( strlcat ( buf , inet_ntoa ( gateway ) , buflen ) >= buflen ) goto bad ; } return ; bad : memset ( buf , 0 , buflen ) ; } | <S2SV_ModStart> ; unsigned int bits , i , len ; uint32_t m <S2SV_ModEnd> ; int rslt <S2SV_ModStart> += len ; m = ntohl ( netmask . s_addr ) ; bits = 32 ; while ( ( bits > 0 ) && ( ( m & 1 ) == 0 ) ) { m >>= 1 ; bits -- ; } <S2SV_ModStart> , "/%d<S2SV_blank>" , bits <S2SV_ModEnd> ) ; if |
3,387 | CWE-000 static int sslize ( struct mg_connection * conn , SSL_CTX * s , int ( * func ) ( SSL * ) , volatile int * stop_server ) { int ret , err ; int short_trust ; unsigned i ; if ( ! conn ) { return 0 ; } short_trust = ( conn -> ctx -> config [ SSL_SHORT_TRUST ] != NULL ) && ( mg_strcasecmp ( conn -> ctx -> config [ SSL_SHORT_TRUST ] , "yes" ) == 0 ) ; if ( short_trust ) { int trust_ret = refresh_trust ( conn ) ; if ( ! trust_ret ) { return trust_ret ; } } conn -> ssl = SSL_new ( s ) ; if ( conn -> ssl == NULL ) { return 0 ; } ret = SSL_set_fd ( conn -> ssl , conn -> client . sock ) ; if ( ret != 1 ) { err = SSL_get_error ( conn -> ssl , ret ) ; ( void ) err ; SSL_free ( conn -> ssl ) ; conn -> ssl = NULL ; # ifndef OPENSSL_API_1_1 ERR_remove_state ( 0 ) ; # endif return 0 ; } for ( i = 16 ; i <= 1024 ; i *= 2 ) { ret = func ( conn -> ssl ) ; if ( ret != 1 ) { err = SSL_get_error ( conn -> ssl , ret ) ; if ( ( err == SSL_ERROR_WANT_CONNECT ) || ( err == SSL_ERROR_WANT_ACCEPT ) || ( err == SSL_ERROR_WANT_READ ) <S2SV_StartBug> || ( err == SSL_ERROR_WANT_WRITE ) ) { <S2SV_EndBug> if ( * stop_server ) { break ; } mg_sleep ( i ) ; } else if ( err == SSL_ERROR_SYSCALL ) { err = errno ; break ; } else { break ; } } else { break ; } } if ( ret != 1 ) { SSL_free ( conn -> ssl ) ; conn -> ssl = NULL ; # ifndef OPENSSL_API_1_1 ERR_remove_state ( 0 ) ; # endif return 0 ; } return 1 ; } | <S2SV_ModStart> err == SSL_ERROR_WANT_WRITE ) || ( err == SSL_ERROR_ZERO_RETURN |
3,388 | CWE-000 void copy_file_by_name ( const char * filename ) { int fd = open ( filename , O_WRONLY | O_CREAT | O_EXCL , 0600 ) ; if ( fd < 0 ) { perror ( "open<S2SV_blank>file" ) ; exit ( 1 ) ; } <S2SV_StartBug> cleanup_filename = filename ; <S2SV_EndBug> atexit ( cleanup_file ) ; if ( ! copy_fd_all ( fd , 0 ) ) exit ( 1 ) ; close ( fd ) ; } | <S2SV_ModStart> } cleanup_filename = strdup ( filename ) <S2SV_ModEnd> ; atexit ( |
3,389 | CWE-000 static int var_replace ( int ifd , int ofd , int binmode ) { struct buf b ; char * p , * e ; if ( fslurp ( ifd , & b ) < 0 ) return - 1 ; p = b . s ; e = b . s + b . len ; do { char * at ; char * rat ; at = p ; while ( at < e && * at != '@' ) { at ++ ; } if ( write ( ofd , p , at - p ) != at - p ) { perror ( "write" ) ; return - 1 ; } if ( at >= e ) break ; p = at ; rat = p + 1 ; while ( rat < e && ( isalnum ( * rat ) || * rat == '_' ) ) { rat ++ ; } if ( rat < e && * rat == '@' ) { const char * value ; value = tup_config_var ( p + 1 , rat - ( p + 1 ) ) ; if ( value ) { int len ; len = strlen ( value ) ; if ( binmode && len == 1 ) { if ( value [ 0 ] == 'y' ) value = "1" ; else if ( value [ 0 ] == 'n' ) value = "0" ; } if ( write ( ofd , value , len ) != len ) { perror ( "write" ) ; return - 1 ; } } p = rat + 1 ; } else { if ( write ( ofd , p , rat - p ) != rat - p ) { perror ( "write" ) ; return - 1 ; } p = rat ; } } while ( p < e ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> e ) ; free ( b . s ) ; |
3,390 | CWE-000 static void dsl_scan_prefetch_thread ( void * arg ) { dsl_scan_t * scn = arg ; spa_t * spa = scn -> scn_dp -> dp_spa ; vdev_t * rvd = spa -> spa_root_vdev ; uint64_t maxinflight = rvd -> vdev_children * zfs_top_maxinflight ; scan_prefetch_issue_ctx_t * spic ; while ( ! scn -> scn_prefetch_stop ) { arc_flags_t flags = ARC_FLAG_NOWAIT | ARC_FLAG_PRESCIENT_PREFETCH | ARC_FLAG_PREFETCH ; int zio_flags = ZIO_FLAG_CANFAIL | ZIO_FLAG_SCAN_THREAD ; mutex_enter ( & spa -> spa_scrub_lock ) ; while ( ! scn -> scn_prefetch_stop && ( avl_numnodes ( & scn -> scn_prefetch_queue ) == 0 || spa -> spa_scrub_inflight >= scn -> scn_maxinflight_bytes ) ) { cv_wait ( & spa -> spa_scrub_io_cv , & spa -> spa_scrub_lock ) ; } if ( scn -> scn_prefetch_stop ) { mutex_exit ( & spa -> spa_scrub_lock ) ; break ; } spic = avl_first ( & scn -> scn_prefetch_queue ) ; spa -> spa_scrub_inflight += BP_GET_PSIZE ( & spic -> spic_bp ) ; avl_remove ( & scn -> scn_prefetch_queue , spic ) ; mutex_exit ( & spa -> spa_scrub_lock ) ; if ( BP_IS_PROTECTED ( & spic -> spic_bp ) ) { <S2SV_StartBug> ASSERT3U ( BP_GET_TYPE ( & spic -> spic_bp ) , == , DMU_OT_DNODE ) ; <S2SV_EndBug> ASSERT3U ( BP_GET_LEVEL ( & spic -> spic_bp ) , == , 0 ) ; zio_flags |= ZIO_FLAG_RAW ; } ( void ) arc_read ( scn -> scn_zio_root , scn -> scn_dp -> dp_spa , & spic -> spic_bp , dsl_scan_prefetch_cb , spic -> spic_spc , ZIO_PRIORITY_SCRUB , zio_flags , & flags , & spic -> spic_zb ) ; kmem_free ( spic , sizeof ( scan_prefetch_issue_ctx_t ) ) ; } ASSERT ( scn -> scn_prefetch_stop ) ; mutex_enter ( & spa -> spa_scrub_lock ) ; while ( ( spic = avl_first ( & scn -> scn_prefetch_queue ) ) != NULL ) { avl_remove ( & scn -> scn_prefetch_queue , spic ) ; scan_prefetch_ctx_rele ( spic -> spic_spc , scn ) ; kmem_free ( spic , sizeof ( scan_prefetch_issue_ctx_t ) ) ; } ASSERT0 ( avl_numnodes ( & scn -> scn_prefetch_queue ) ) ; mutex_exit ( & spa -> spa_scrub_lock ) ; } | <S2SV_ModStart> ) ) { ASSERT <S2SV_ModEnd> ( BP_GET_TYPE ( <S2SV_ModStart> -> spic_bp ) == DMU_OT_DNODE || BP_GET_TYPE ( & spic -> spic_bp ) == DMU_OT_OBJSET <S2SV_ModEnd> ) ; ASSERT3U |
3,391 | CWE-000 static void qla2x00_free_rsp_que ( struct qla_hw_data * ha , struct rsp_que * rsp ) <S2SV_StartBug> { <S2SV_EndBug> if ( IS_QLAFX00 ( ha ) ) { if ( rsp && rsp -> ring ) dma_free_coherent ( & ha -> pdev -> dev , ( rsp -> length_fx00 + 1 ) * sizeof ( request_t ) , rsp -> ring_fx00 , rsp -> dma_fx00 ) ; } else if ( rsp && rsp -> ring ) { dma_free_coherent ( & ha -> pdev -> dev , ( rsp -> length + 1 ) * sizeof ( response_t ) , rsp -> ring , rsp -> dma ) ; } <S2SV_StartBug> kfree ( rsp ) ; <S2SV_EndBug> } | <S2SV_ModStart> rsp ) { if ( ! ha -> rsp_q_map ) return ; <S2SV_ModStart> ) ; } if ( rsp ) |
3,392 | CWE-000 static void hev_scgi_handler_hello_handle ( HevSCGIHandler * self , GObject * scgi_task ) { <S2SV_StartBug> GObject * scgi_response = NULL ; <S2SV_EndBug> GOutputStream * output_stream = NULL ; GHashTable * res_hash_table = NULL ; g_debug ( "%s:%d[%s]" , __FILE__ , __LINE__ , __FUNCTION__ ) ; g_object_ref ( scgi_task ) ; <S2SV_StartBug> scgi_response = hev_scgi_task_get_response ( HEV_SCGI_TASK ( scgi_task ) ) ; <S2SV_EndBug> output_stream = hev_scgi_response_get_output_stream ( HEV_SCGI_RESPONSE ( scgi_response ) ) ; res_hash_table = hev_scgi_response_get_header_hash_table ( HEV_SCGI_RESPONSE ( scgi_response ) ) ; g_hash_table_insert ( res_hash_table , g_strdup ( "Status" ) , g_strdup ( "200<S2SV_blank>OK" ) ) ; g_hash_table_insert ( res_hash_table , g_strdup ( "Content-Type" ) , g_strdup ( "text/html" ) ) ; hev_scgi_response_write_header_async ( HEV_SCGI_RESPONSE ( scgi_response ) , NULL , hev_scgi_response_write_header_async_handler , scgi_task ) ; } | <S2SV_ModStart> GObject * scgi_response <S2SV_ModEnd> = NULL ; <S2SV_ModStart> HEV_SCGI_TASK ( scgi_task <S2SV_ModEnd> ) ) ; |
3,393 | CWE-000 static _Bool augment_sequence ( struct mapping_sequence * cur , void * begin , void * end , int prot , int flags , off_t offset , const char * filename , void * caller ) { _Bool ret ; if ( ! cur ) { ret = 0 ; goto out ; } <S2SV_StartBug> # define OVERLAPS ( b1 , e1 , b2 , e2 ) ( ( char * ) ( b1 ) < ( char * ) ( e2 ) && ( char * ) ( e1 ) >= ( char * ) ( b2 ) ) <S2SV_EndBug> _Bool is_clean_extension = ( ! cur -> end || cur -> end == begin ) ; _Bool bounds_would_remain_contiguous = is_clean_extension || OVERLAPS ( cur -> begin , cur -> end , begin , end ) ; _Bool begin_addr_unchanged = ( char * ) begin >= ( char * ) cur -> begin ; _Bool not_too_many = cur -> nused != MAPPING_SEQUENCE_MAX_LEN ; if ( bounds_would_remain_contiguous && begin_addr_unchanged && not_too_many ) { if ( is_clean_extension ) { _Bool filename_is_consistent = ( ! filename && ! cur -> filename ) || ( cur -> nused == 0 ) || ( ! filename && cur -> filename && ! ( cur -> mappings [ cur -> nused - 1 ] . is_anon ) && ( ( ! caller && ! cur -> mappings [ cur -> nused - 1 ] . caller ) || get_highest_loaded_object_below ( caller ) == get_highest_loaded_object_below ( cur -> mappings [ cur -> nused - 1 ] . caller ) ) ) || ( filename && cur -> filename && 0 == strcmp ( filename , cur -> filename ) ) ; if ( ! filename_is_consistent ) { ret = 0 ; goto out ; } if ( ! cur -> begin ) cur -> begin = begin ; cur -> end = end ; if ( ! cur -> filename ) cur -> filename = filename ? __liballocs_private_strdup ( filename ) : NULL ; cur -> mappings [ cur -> nused ] = ( struct mapping_entry ) { . begin = begin , . end = end , . flags = flags , . prot = prot , . offset = offset , . is_anon = ! filename , . caller = caller } ; ++ ( cur -> nused ) ; ret = 1 ; goto out ; } else { int i = 0 ; while ( ! ( OVERLAPS ( cur -> mappings [ i ] . begin , cur -> mappings [ i ] . end , begin , end ) ) ) ++ i ; int first_overlapped = i ; i = cur -> nused - 1 ; while ( ! ( OVERLAPS ( cur -> mappings [ i ] . begin , cur -> mappings [ i ] . end , begin , end ) ) ) -- i ; int last_overlapped = i ; _Bool begin_overlap_is_partial = cur -> mappings [ first_overlapped ] . begin != begin ; _Bool end_overlap_is_partial = cur -> mappings [ last_overlapped ] . end != end ; _Bool filename_is_consistent ; if ( ( ! filename && ! cur -> filename ) || ( cur -> nused == 0 ) ) { filename_is_consistent = 1 ; } else { if ( filename && cur -> filename && 0 != strcmp ( filename , cur -> filename ) ) { filename_is_consistent = 0 ; } else { int maybe_mapping_preceding_overlap = begin_overlap_is_partial ? first_overlapped : first_overlapped - 1 ; int maybe_mapping_following_overlap = end_overlap_is_partial ? last_overlapped : last_overlapped + 1 ; if ( maybe_mapping_following_overlap >= cur -> nused ) { maybe_mapping_following_overlap = - 1 ; } if ( ( maybe_mapping_preceding_overlap != - 1 && ( cur -> mappings [ maybe_mapping_preceding_overlap ] . is_anon && filename ) ) || ( maybe_mapping_following_overlap != - 1 && ( ! filename && ! cur -> mappings [ maybe_mapping_following_overlap ] . is_anon ) ) ) { filename_is_consistent = 0 ; } else filename_is_consistent = 1 ; filename_is_consistent &= ( ! caller || ! cur -> mappings [ first_overlapped ] . caller || get_highest_loaded_object_below ( caller ) == get_highest_loaded_object_below ( cur -> mappings [ first_overlapped ] . caller ) ) ; } } if ( ! filename_is_consistent ) { ret = 0 ; goto out ; } if ( begin_overlap_is_partial ) { copy_all_right_from_by ( cur , first_overlapped , 1 ) ; if ( first_overlapped != last_overlapped ) ++ last_overlapped ; cur -> mappings [ first_overlapped ] . end = begin ; cur -> mappings [ first_overlapped + 1 ] . begin = begin ; begin_overlap_is_partial = 0 ; if ( first_overlapped == last_overlapped ) ++ last_overlapped ; ++ first_overlapped ; } if ( end_overlap_is_partial ) { copy_all_right_from_by ( cur , last_overlapped , 1 ) ; cur -> mappings [ last_overlapped + 1 ] . begin = end ; cur -> mappings [ last_overlapped ] . end = end ; end_overlap_is_partial = 0 ; } # define N_OBSOLETE_MAPPINGS ( last_overlapped - first_overlapped ) + 1 assert ( N_OBSOLETE_MAPPINGS >= 1 ) ; if ( N_OBSOLETE_MAPPINGS > 1 ) { unsigned n = N_OBSOLETE_MAPPINGS - 1 ; copy_all_left_from_by ( cur , last_overlapped + 1 , n ) ; last_overlapped -= n ; } assert ( N_OBSOLETE_MAPPINGS == 1 ) ; assert ( first_overlapped == last_overlapped ) ; cur -> mappings [ first_overlapped ] = ( struct mapping_entry ) { . begin = begin , . end = end , . flags = flags , . prot = prot , . offset = offset , . is_anon = ! filename , . caller = caller } ; ret = 1 ; goto out ; } } else { ret = 0 ; goto out ; } abort ( ) ; out : check_mapping_sequence_sanity ( cur ) ; return ret ; } | <S2SV_ModStart> out ; } check_mapping_sequence_sanity ( cur ) ; |
3,394 | CWE-000 int amdgpu_gem_object_create ( struct amdgpu_device * adev , unsigned long size , int alignment , u32 initial_domain , u64 flags , enum ttm_bo_type type , struct reservation_object * resv , struct drm_gem_object * * obj ) { struct amdgpu_bo * bo ; int r ; * obj = NULL ; if ( alignment < PAGE_SIZE ) { alignment = PAGE_SIZE ; } <S2SV_StartBug> r = amdgpu_bo_create ( adev , size , alignment , initial_domain , <S2SV_EndBug> flags , type , resv , & bo ) ; if ( r ) { <S2SV_StartBug> DRM_DEBUG ( "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>GEM<S2SV_blank>object<S2SV_blank>(%ld,<S2SV_blank>%d,<S2SV_blank>%u,<S2SV_blank>%d)\\n" , <S2SV_EndBug> <S2SV_StartBug> size , initial_domain , alignment , r ) ; <S2SV_EndBug> return r ; } * obj = & bo -> gem_base ; return 0 ; } | <S2SV_ModStart> PAGE_SIZE ; } retry : <S2SV_ModStart> r ) { if ( r != - ERESTARTSYS ) { if ( flags & AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED ) { flags &= ~ AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED ; goto retry ; } if ( initial_domain == AMDGPU_GEM_DOMAIN_VRAM ) { initial_domain |= AMDGPU_GEM_DOMAIN_GTT ; goto retry ; } <S2SV_ModStart> r ) ; } |
3,395 | CWE-000 int mrbjit_uvoff ( mrb_state * mrb , int up ) { int off = 0 ; <S2SV_StartBug> struct RProc * proc = mrb -> c -> ci -> proc ; <S2SV_EndBug> mrb_callinfo * ci = mrb -> c -> ci ; mrb_callinfo * cb = mrb -> c -> cibase ; while ( up -- ) { proc = proc -> upper ; <S2SV_StartBug> if ( ! proc ) return - 1 ; <S2SV_EndBug> } while ( cb <= ci ) { if ( ci -> proc == proc ) { return off ; } ci -- ; off ++ ; } <S2SV_StartBug> return - 1 ; <S2SV_EndBug> } | <S2SV_ModStart> ci -> proc ; struct REnv * e <S2SV_ModStart> proc ) return 0 ; } e = MRB_PROC_ENV ( proc ) ; if ( e ) return - 2 ; <S2SV_ModEnd> while ( cb <S2SV_ModStart> ; } return 0 <S2SV_ModEnd> ; } <S2SV_null> |
3,396 | CWE-000 int hwloc_bitmap_compare ( const struct hwloc_bitmap_s * set1 , const struct hwloc_bitmap_s * set2 ) { unsigned count1 = set1 -> ulongs_count ; unsigned count2 = set2 -> ulongs_count ; unsigned max_count = count1 > count2 ? count1 : count2 ; unsigned min_count = count1 + count2 - max_count ; int i ; HWLOC__BITMAP_CHECK ( set1 ) ; HWLOC__BITMAP_CHECK ( set2 ) ; if ( ( ! set1 -> infinite ) != ( ! set2 -> infinite ) ) return ! ! set1 -> infinite - ! ! set2 -> infinite ; if ( count1 != count2 ) { if ( min_count < count2 ) { unsigned long val1 = set1 -> infinite ? HWLOC_SUBBITMAP_FULL : HWLOC_SUBBITMAP_ZERO ; <S2SV_StartBug> for ( i = max_count - 1 ; i >= ( signed ) min_count ; i -- ) { <S2SV_EndBug> unsigned long val2 = set2 -> ulongs [ i ] ; if ( val1 == val2 ) continue ; return val1 < val2 ? - 1 : 1 ; } } else { unsigned long val2 = set2 -> infinite ? HWLOC_SUBBITMAP_FULL : HWLOC_SUBBITMAP_ZERO ; <S2SV_StartBug> for ( i = max_count - 1 ; i >= ( signed ) min_count ; i -- ) { <S2SV_EndBug> unsigned long val1 = set1 -> ulongs [ i ] ; if ( val1 == val2 ) continue ; return val1 < val2 ? - 1 : 1 ; } } } <S2SV_StartBug> for ( i = min_count - 1 ; i >= 0 ; i -- ) { <S2SV_EndBug> unsigned long val1 = set1 -> ulongs [ i ] ; unsigned long val2 = set2 -> ulongs [ i ] ; if ( val1 == val2 ) continue ; return val1 < val2 ? - 1 : 1 ; } return 0 ; } | <S2SV_ModStart> ( i = ( int ) <S2SV_ModStart> i >= ( int <S2SV_ModEnd> ) min_count ; <S2SV_ModStart> ( i = ( int ) <S2SV_ModStart> i >= ( int <S2SV_ModEnd> ) min_count ; <S2SV_ModStart> ( i = ( int ) |
3,397 | CWE-000 int main ( int argc , char * * argv ) { starting_prompt ( ) ; int server_socket ; char buffer [ 1000 ] ; fd_set read_fds ; server_socket = client_setup ( IP ) ; int started = 1 ; while ( 1 ) { printf ( "enter<S2SV_blank>text<S2SV_blank>to<S2SV_blank>send:<S2SV_blank>" ) ; <S2SV_StartBug> FD_ZERO ( & read_fds ) ; <S2SV_EndBug> FD_SET ( STDIN_FILENO , & read_fds ) ; FD_SET ( server_socket , & read_fds ) ; select ( server_socket + 1 , & read_fds , NULL , NULL , NULL ) ; if ( FD_ISSET ( STDIN_FILENO , & read_fds ) ) { if ( started ) { started = 0 ; } else { battle_prompt ( ) ; } write ( server_socket , buffer , sizeof ( buffer ) ) ; } if ( FD_ISSET ( server_socket , & read_fds ) ) { read ( server_socket , buffer , sizeof ( buffer ) ) ; printf ( "recieved:<S2SV_blank>%s\\n" , buffer ) ; } } } | <S2SV_ModStart> "enter<S2SV_blank>text<S2SV_blank>to<S2SV_blank>send:<S2SV_blank>" ) ; fgets ( buffer , sizeof ( buffer ) , stdin ) ; |
3,398 | CWE-000 int inverse_cte_blur ( SingleGroup * rsz , SingleGroup * rsc , SingleGroup * fff , WF3CTEParams * cte , const int verbose , const double expstart ) { extern int status ; const double cte_ff = ( expstart - cte -> cte_date0 ) / ( cte -> cte_date1 - cte -> cte_date0 ) ; cte -> scale_frac = cte_ff ; if ( verbose ) { sprintf ( MsgText , "CTE_FF<S2SV_blank>(scaling<S2SV_blank>fraction<S2SV_blank>by<S2SV_blank>date)<S2SV_blank>=<S2SV_blank>%g" , cte_ff ) ; trlmessage ( MsgText ) ; } FloatTwoDArray cteRprof ; FloatTwoDArray cteCprof ; initFloatData ( & cteRprof ) ; initFloatData ( & cteCprof ) ; allocFloatData ( & cteRprof , cte -> baseParams . rprof -> data . ny , cte -> baseParams . rprof -> data . nx , False ) ; allocFloatData ( & cteCprof , cte -> baseParams . cprof -> data . ny , cte -> baseParams . cprof -> data . nx , False ) ; copyAndTransposeFloatData ( & cteRprof , & cte -> baseParams . rprof -> data ) ; <S2SV_StartBug> copyAndTransposeFloatData ( & cteCprof , & cte -> baseParams . cprof -> data ) ; <S2SV_EndBug> # pragma omp parallel <S2SV_StartBug> { <S2SV_EndBug> double * pix_observed = NULL ; double * pix_model = NULL ; double * pix_ctef = NULL ; assert ( pix_observed = ( double * ) malloc ( sizeof ( double ) * RAZ_ROWS ) ) ; assert ( pix_model = ( double * ) malloc ( sizeof ( double ) * RAZ_ROWS ) ) ; assert ( pix_ctef = ( double * ) malloc ( sizeof ( double ) * RAZ_ROWS ) ) ; unsigned i ; unsigned jmax = 0 ; # pragma omp parallel for schedule ( dynamic , 1 ) private ( i , jmax , pix_observed , pix_model , pix_ctef ) shared ( rsc , rsz , cte , cteRprof , cteCprof , fff ) for ( i = 0 ; i < RAZ_COLS ; ++ i ) <S2SV_StartBug> { <S2SV_EndBug> for ( unsigned j = 0 ; j < RAZ_ROWS ; ++ j ) { pix_observed [ j ] = Pix ( rsz -> sci . data , i , j ) ; } Bool hasFlux = False ; for ( unsigned j = 0 ; j < RAZ_ROWS ; ++ j ) { if ( pix_observed [ j ] > 0 ) { hasFlux = True ; break ; } } if ( hasFlux ) { for ( unsigned j = 0 ; j < RAZ_ROWS ; ++ j ) { pix_ctef [ j ] = Pix ( fff -> sci . data , i , j ) ; } unsigned NREDO = 0 ; Bool REDO = False ; do { memcpy ( pix_model , pix_observed , sizeof ( pix_observed ) * RAZ_ROWS ) ; for ( unsigned NITINV = 0 ; NITINV < cte -> baseParams . n_forward - 1 ; ++ NITINV ) { for ( unsigned NITCTE = 1 ; NITCTE <= cte -> baseParams . n_par ; ++ NITCTE ) { sim_colreadout_l ( pix_model , pix_ctef , & cte -> baseParams , & cteRprof , & cteCprof , RAZ_ROWS , True ) ; } } for ( unsigned NITCTE = 1 ; NITCTE <= cte -> baseParams . n_par ; ++ NITCTE ) { sim_colreadout_l ( pix_model , pix_ctef , & cte -> baseParams , & cteRprof , & cteCprof , RAZ_ROWS , False ) ; } correctCROverSubtraction ( pix_ctef , pix_model , pix_observed , RAZ_ROWS , & jmax , & REDO , & cte -> baseParams ) ; if ( REDO ) ++ NREDO ; if ( NREDO == 5 ) REDO = False ; } while ( REDO ) ; # pragma omp critical ( cte ) for ( unsigned j = 0 ; j < RAZ_ROWS ; ++ j ) { if ( Pix ( rsz -> dq . data , i , j ) ) { Pix ( rsc -> sci . data , i , j ) = pix_model [ j ] ; } } } } if ( pix_observed ) free ( pix_observed ) ; if ( pix_model ) free ( pix_model ) ; if ( pix_ctef ) free ( pix_ctef ) ; } freeFloatData ( & cteRprof ) ; freeFloatData ( & cteCprof ) ; return ( status ) ; } | <S2SV_ModStart> -> data ) ; { double * pix_observed = NULL ; double * pix_model = NULL ; double * pix_ctef = NULL ; unsigned i ; unsigned jmax = 0 <S2SV_ModStart> pragma omp parallel <S2SV_ModEnd> for schedule ( <S2SV_ModStart> i ) { assert ( pix_observed = ( double * ) malloc ( sizeof ( double ) * RAZ_ROWS ) ) ; assert ( pix_model = ( double * ) malloc ( sizeof ( double ) * RAZ_ROWS ) ) ; assert ( pix_ctef = ( double * ) malloc ( sizeof ( double ) * RAZ_ROWS ) ) ; |
3,399 | CWE-000 int check_screen_size ( ) <S2SV_StartBug> { <S2SV_EndBug> if ( CURR_WIDTH > 1000 ) { log_this ( 100 , "BIGSCREEN" ) ; screensize = BIGSCREEN ; size_factor = 2 ; <S2SV_StartBug> character_size = 4 ; <S2SV_EndBug> <S2SV_StartBug> text_size = 3 ; <S2SV_EndBug> } else if ( CURR_WIDTH > 500 ) { log_this ( 100 , "MIDDLESCREEN" ) ; screensize = MIDDLESCREEN ; size_factor = 1.5 ; <S2SV_StartBug> character_size = 3 ; <S2SV_EndBug> <S2SV_StartBug> text_size = 2 ; <S2SV_EndBug> } else { log_this ( 100 , "SMALLSCREEN" ) ; screensize = SMALLSCREEN ; size_factor = 1 ; <S2SV_StartBug> character_size = 2 ; <S2SV_EndBug> <S2SV_StartBug> text_size = 1 ; <S2SV_EndBug> } return 0 ; } | <S2SV_ModStart> ( ) { int character_size , text_size ; <S2SV_ModStart> ; character_size = 40 <S2SV_ModEnd> ; text_size = <S2SV_ModStart> ; text_size = 18 <S2SV_ModEnd> ; } else <S2SV_ModStart> ; character_size = 30 <S2SV_ModEnd> ; text_size = <S2SV_ModStart> ; text_size = 14 <S2SV_ModEnd> ; } else <S2SV_ModStart> ; character_size = 20 <S2SV_ModEnd> ; text_size = <S2SV_ModStart> ; text_size = 10 ; } text_font_normal = loadatlas ( "freesans" , NORMAL_TYPE , text_size ) ; text_font_bold = loadatlas ( "freesans" , BOLD_TYPE , text_size ) ; char_font = loadatlas ( "freesans" , BOLD_TYPE , character_size ) ; <S2SV_ModEnd> return 0 ; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.