Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
2,900 | CWE-000 int main ( int argc , const char * argv [ ] ) { if ( argc > 1 ) { printf ( "%s\\n" , "No<S2SV_blank>arguments<S2SV_blank>required" ) ; return 0 ; } char size [ 1 ] ; srand ( time ( 0 ) ) ; int boardSize = 0 ; int legalSize = 0 ; while ( legalSize == 0 ) { printf ( "%s\\n" , "Choose<S2SV_blank>your<S2SV_blank>board<S2SV_blank>size,<S2SV_blank>(S)mall,<S2SV_blank>(M)edium,<S2SV_blank>or<S2SV_blank>(L)arge" ) ; scanf ( "%s" , size ) ; if ( 0 == strcmp ( size , "s" ) || 0 == strcmp ( size , "S" ) ) { printf ( "%s\\n" , "Making<S2SV_blank>Small<S2SV_blank>board..." ) ; legalSize = 1 ; boardSize = 5 ; mines = 4 ; } else if ( legalSize == 0 && ( 0 == strcmp ( size , "m" ) || 0 == strcmp ( size , "M" ) ) ) { printf ( "%s\\n" , "Making<S2SV_blank>Medium<S2SV_blank>board..." ) ; legalSize = 1 ; boardSize = 10 ; mines = 15 ; } else if ( legalSize == 0 && ( 0 == strcmp ( size , "l" ) || 0 == strcmp ( size , "L" ) ) ) { printf ( "%s\\n" , "Making<S2SV_blank>Large<S2SV_blank>board..." ) ; legalSize = 1 ; boardSize = 15 ; mines = 25 ; } else if ( legalSize == 0 && ( 0 == strcmp ( size , "f" ) || 0 == strcmp ( size , "F" ) ) ) { printf ( "%s\\n" , "respects<S2SV_blank>paid,<S2SV_blank>thanks<S2SV_blank>for<S2SV_blank>the<S2SV_blank>royalties" ) ; } else { printf ( "%s\\n" , "That<S2SV_blank>isn\'t<S2SV_blank>a<S2SV_blank>size,<S2SV_blank>maybe<S2SV_blank>try<S2SV_blank>a<S2SV_blank>different<S2SV_blank>one." ) ; } } rows = boardSize ; cols = boardSize ; Board info = generate_mines ( ) ; Board covered ; covered . width = cols ; covered . height = rows ; int i , j ; for ( i = 0 ; i < rows ; i ++ ) { for ( j = 0 ; j < cols ; j ++ ) { covered . cboard [ i ] [ j ] = "X" ; } } initscr ( ) ; noecho ( ) ; curs_set ( 0 ) ; cbreak ( ) ; printw ( "Minesweeper:<S2SV_blank>Press<S2SV_blank>SPACE<S2SV_blank>to<S2SV_blank>reveal<S2SV_blank>a<S2SV_blank>cell<S2SV_blank>and<S2SV_blank>\'M\'<S2SV_blank>to<S2SV_blank>flag<S2SV_blank>a<S2SV_blank>cell.<S2SV_blank>Press<S2SV_blank>\'N\'<S2SV_blank>to<S2SV_blank>start<S2SV_blank>a<S2SV_blank>new<S2SV_blank>game,<S2SV_blank>or<S2SV_blank>Press<S2SV_blank>\'X\'<S2SV_blank>to<S2SV_blank>exit." ) ; print_board ( covered ) ; int input ; winCount = 0 ; char buf [ 16 ] ; loseBool = False ; int infoTemp ; while ( 1 ) { input = getch ( ) ; switch ( input ) { case 'n' : loseBool = False ; winCount = 0 ; <S2SV_StartBug> info = generate_mines ( ) ; <S2SV_EndBug> covered . width = cols ; covered . height = rows ; mvprintw ( 5 , 34 , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" ) ; for ( i = 0 ; i < rows ; i ++ ) { for ( j = 0 ; j < cols ; j ++ ) { covered . cboard [ i ] [ j ] = "X" ; } } print_board ( covered ) ; case 'w' : if ( highlightX > 1 ) highlightX -- ; break ; case 's' : if ( highlightX < rows ) highlightX ++ ; break ; case 'a' : if ( highlightY > 1 ) highlightY -- ; break ; case 'd' : if ( highlightY < cols ) highlightY ++ ; break ; case '<S2SV_blank>' : reveal_cell ( & covered , info , highlightX - 1 , highlightY - 1 ) ; check_win ( & covered , info ) ; break ; case 'm' : case 'M' : if ( covered . cboard [ highlightY - 1 ] [ highlightX - 1 ] == "X" ) { covered . cboard [ highlightY - 1 ] [ highlightX - 1 ] = "M" ; } else if ( covered . cboard [ highlightY - 1 ] [ highlightX - 1 ] == "M" ) { covered . cboard [ highlightY - 1 ] [ highlightX - 1 ] = "X" ; } break ; default : break ; } print_board ( covered ) ; if ( input == 'X' || input == 'x' ) break ; } endwin ( ) ; return 0 ; } | <S2SV_ModStart> = 0 ; highlightX = 1 ; highlightY = 1 ; |
2,901 | CWE-000 static struct fw_task_info * get_task_info ( unsigned short tid ) { struct fw_task_info * task_info = NULL ; unsigned long lock_flag ; spin_lock_irqsave ( & task_ctl . lock , lock_flag ) ; list_for_each_entry ( task_info , & task_ctl . list , list ) { if ( task_info -> tid == tid ) break ; } spin_unlock_irqrestore ( & task_ctl . lock , lock_flag ) ; if ( task_info ) { if ( ( task_info == ( struct fw_task_info * ) & task_ctl . list ) || <S2SV_StartBug> ( task_info -> tid != tid ) ) { <S2SV_EndBug> task_info = NULL ; } } return task_info ; } | <S2SV_ModStart> list ) || <S2SV_ModEnd> task_info -> tid <S2SV_ModStart> tid != tid <S2SV_ModEnd> ) { task_info |
2,902 | CWE-000 static int append_cgroup ( sd_bus_message * reply , const char * p , Set * pids ) { _cleanup_closedir_ DIR * d = NULL ; _cleanup_fclose_ FILE * f = NULL ; int r ; assert ( reply ) ; assert ( p ) ; r = cg_enumerate_processes ( SYSTEMD_CGROUP_CONTROLLER , p , & f ) ; if ( r == ENOENT ) return 0 ; if ( r < 0 ) return r ; for ( ; ; ) { pid_t pid ; r = cg_read_pid ( f , & pid ) ; if ( r < 0 ) return r ; if ( r == 0 ) break ; if ( is_kernel_thread ( pid ) > 0 ) continue ; r = append_process ( reply , p , pid , pids ) ; if ( r < 0 ) return r ; } r = cg_enumerate_subgroups ( SYSTEMD_CGROUP_CONTROLLER , p , & d ) ; if ( r == - ENOENT ) return 0 ; if ( r < 0 ) return r ; for ( ; ; ) { _cleanup_free_ char * g = NULL , * j = NULL ; r = cg_read_subgroup ( d , & g ) ; if ( r < 0 ) return r ; if ( r == 0 ) break ; <S2SV_StartBug> j = strjoin ( p , "/" , g , NULL ) ; <S2SV_EndBug> if ( ! j ) return - ENOMEM ; r = append_cgroup ( reply , j , pids ) ; if ( r < 0 ) return r ; } return 0 ; } | <S2SV_ModStart> "/" , g <S2SV_ModEnd> ) ; if |
2,903 | CWE-000 static bool test_read_var ( const char * name , const char * val ) { char buf [ 128 ] ; int fd , ret ; ret = snprintf ( buf , sizeof ( buf ) , "#vars/%s" , name ) ; <S2SV_StartBug> if ( snprintf_overflow ( ret , buf , sizeof ( buf ) ) ) <S2SV_EndBug> UT_ASSERT_FMT ( "snprintf<S2SV_blank>failed!" , FALSE ) ; fd = open ( buf , O_READ ) ; UT_ASSERT_FMT ( "Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>vars<S2SV_blank>file<S2SV_blank>%s,<S2SV_blank>check<S2SV_blank>CONFIG_DEVVARS_TEST" , fd >= 0 , buf ) ; ret = read ( fd , buf , sizeof ( buf ) ) ; UT_ASSERT_FMT ( "Could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>vars<S2SV_blank>file<S2SV_blank>%s" , ret > 0 , buf ) ; UT_ASSERT_FMT ( "Value<S2SV_blank>differs,<S2SV_blank>got<S2SV_blank>%s,<S2SV_blank>wanted<S2SV_blank>%s" , strcmp ( buf , val ) == 0 , buf , val ) ; return TRUE ; } | <S2SV_ModStart> ; if ( snprintf_error ( ret <S2SV_ModEnd> , sizeof ( |
2,904 | CWE-000 boolean HU_Responder ( event_t * ev ) { static char lastmessage [ HU_MAXLINELENGTH + 1 ] ; char * macromessage ; boolean eatkey = false ; <S2SV_StartBug> static boolean shiftdown = false ; <S2SV_EndBug> static boolean altdown = false ; int c ; int i ; int numplayers ; static char destination_keys [ MAXPLAYERS ] = { HUSTR_KEYGREEN , HUSTR_KEYINDIGO , HUSTR_KEYBROWN , HUSTR_KEYRED } ; static int num_nobrainers = 0 ; numplayers = 0 ; for ( i = 0 ; i < MAXPLAYERS ; i ++ ) numplayers += playeringame [ i ] ; <S2SV_StartBug> if ( ev -> data1 == KEY_RSHIFT ) <S2SV_EndBug> { <S2SV_StartBug> shiftdown = ev -> type == ev_keydown ; <S2SV_EndBug> return false ; } else if ( ev -> data1 == KEY_RALT || ev -> data1 == KEY_LALT ) { altdown = ev -> type == ev_keydown ; return false ; } <S2SV_StartBug> if ( ev -> type != ev_keydown ) <S2SV_EndBug> <S2SV_StartBug> return false ; <S2SV_EndBug> if ( ! chat_on ) { if ( ev -> data1 == HU_MSGREFRESH ) { message_on = true ; message_counter = HU_MSGTIMEOUT ; eatkey = true ; } else if ( netgame && ev -> data1 == HU_INPUTTOGGLE ) { eatkey = chat_on = true ; HUlib_resetIText ( & w_chat ) ; HU_queueChatChar ( HU_BROADCAST ) ; } else if ( netgame && numplayers > 2 ) { for ( i = 0 ; i < MAXPLAYERS ; i ++ ) { if ( ev -> data1 == destination_keys [ i ] ) { if ( playeringame [ i ] && i != consoleplayer ) { eatkey = chat_on = true ; HUlib_resetIText ( & w_chat ) ; HU_queueChatChar ( i + 1 ) ; break ; } else if ( i == consoleplayer ) { num_nobrainers ++ ; if ( num_nobrainers < 3 ) plr -> message = HUSTR_TALKTOSELF1 ; else if ( num_nobrainers < 6 ) plr -> message = HUSTR_TALKTOSELF2 ; else if ( num_nobrainers < 9 ) plr -> message = HUSTR_TALKTOSELF3 ; else if ( num_nobrainers < 32 ) plr -> message = HUSTR_TALKTOSELF4 ; else plr -> message = HUSTR_TALKTOSELF5 ; } } } } } else { <S2SV_StartBug> c = ev -> data2 ; <S2SV_EndBug> if ( c == - 1 ) return false ; if ( altdown ) { c = c - '0' ; if ( c < 0 || c > 9 ) return false ; macromessage = chat_macros [ c ] ; HU_queueChatChar ( KEY_ENTER ) ; while ( * macromessage ) HU_queueChatChar ( * macromessage ++ ) ; HU_queueChatChar ( KEY_ENTER ) ; chat_on = false ; strcpy ( lastmessage , chat_macros [ c ] ) ; plr -> message = lastmessage ; eatkey = true ; } else { eatkey = HUlib_keyInIText ( & w_chat , c ) ; if ( eatkey ) { HU_queueChatChar ( c ) ; } if ( c == KEY_ENTER ) { chat_on = false ; if ( w_chat . l . len ) { strcpy ( lastmessage , w_chat . l . l ) ; plr -> message = lastmessage ; } } else if ( c == KEY_ESCAPE ) chat_on = false ; } } return eatkey ; } | <S2SV_ModStart> ; static boolean <S2SV_ModEnd> altdown = false <S2SV_ModStart> i ] ; switch ( <S2SV_ModEnd> ev -> type <S2SV_ModStart> ev -> type ) { case ev_keydown : case ev_keyup : <S2SV_ModEnd> if ( ev <S2SV_ModStart> false ; } case ev_char : break ; default : <S2SV_ModEnd> return false ; <S2SV_ModStart> return false ; } <S2SV_ModStart> = ev -> data1 <S2SV_ModEnd> ; if ( |
2,905 | CWE-000 void read_exif_time_digitized_data ( FileData * file ) { <S2SV_StartBug> if ( file -> exifdate > 0 ) <S2SV_EndBug> { DEBUG_1 ( "%s<S2SV_blank>set_exif_time_digitized_data:<S2SV_blank>Already<S2SV_blank>exists<S2SV_blank>for<S2SV_blank>%s" , get_exec_time ( ) , file -> path ) ; return ; } file -> exif = exif_read_fd ( file ) ; if ( file -> exif ) { gchar * tmp = exif_get_data_as_text ( file -> exif , "Exif.Photo.DateTimeDigitized" ) ; DEBUG_2 ( "%s<S2SV_blank>set_exif_time_digitized_data:<S2SV_blank>reading<S2SV_blank>%p<S2SV_blank>%s" , get_exec_time ( ) , file , file -> path ) ; if ( tmp ) { struct tm time_str ; uint year , month , day , hour , min , sec ; sscanf ( tmp , "%4d:%2d:%2d<S2SV_blank>%2d:%2d:%2d" , & year , & month , & day , & hour , & min , & sec ) ; time_str . tm_year = year - 1900 ; time_str . tm_mon = month - 1 ; time_str . tm_mday = day ; time_str . tm_hour = hour ; time_str . tm_min = min ; time_str . tm_sec = sec ; time_str . tm_isdst = 0 ; file -> exifdate_digitized = mktime ( & time_str ) ; g_free ( tmp ) ; } } } | <S2SV_ModStart> ( file -> exifdate_digitized <S2SV_ModEnd> > 0 ) |
2,906 | CWE-000 struct htx_blk * htx_replace_reqline ( struct htx * htx , struct htx_blk * blk , const union h1_sl sl ) { enum htx_blk_type type ; uint32_t size ; type = htx_get_blk_type ( blk ) ; if ( type != HTX_BLK_REQ_SL ) return NULL ; <S2SV_StartBug> size = sizeof ( sl ) + sl . rq . m . len + sl . rq . u . len + sl . rq . v . len ; <S2SV_EndBug> blk = htx_new_blk_value ( htx , blk , size ) ; if ( ! blk ) return NULL ; blk -> info = ( type << 28 ) + size ; htx_set_blk_reqline ( htx , blk , sl ) ; return blk ; } | <S2SV_ModStart> = sizeof ( union htx_sl <S2SV_ModEnd> ) + sl |
2,907 | CWE-000 int ynode_get_with_origin ( ynode * src , int origin , ynode_log * log ) { int n = 0 ; if ( ! src ) return 0 ; if ( src -> type == YNODE_TYPE_VAL ) { if ( src -> origin != origin && origin >= 0 ) return 0 ; n += 1 ; } <S2SV_StartBug> ynode_log_print ( log , src ) ; <S2SV_EndBug> switch ( src -> type ) { case YNODE_TYPE_MAP : { ytree_iter * iter = ytree_first ( src -> map ) ; for ( ; iter != NULL ; iter = ytree_next ( src -> map , iter ) ) { ynode * src_child = ytree_data ( iter ) ; n += ynode_get_with_origin ( src_child , origin , log ) ; } break ; } case YNODE_TYPE_OMAP : { ymap_iter * iter = ymap_first ( src -> omap ) ; for ( ; iter != NULL ; iter = ymap_next ( src -> omap , iter ) ) { ynode * src_child = ymap_data ( iter ) ; n += ynode_get_with_origin ( src_child , origin , log ) ; } break ; } case YNODE_TYPE_LIST : { ylist_iter * iter ; for ( iter = ylist_first ( src -> list ) ; ! ylist_done ( src -> list , iter ) ; iter = ylist_next ( src -> list , iter ) ) { ynode * src_child = ylist_data ( iter ) ; n += ynode_get_with_origin ( src_child , origin , log ) ; } break ; } case YNODE_TYPE_VAL : break ; default : assert ( ! YDB_E_TYPE_ERR ) ; } return n ; } | <S2SV_ModStart> log , src , NULL |
2,908 | CWE-000 void exec_multiply ( uint32_t code , const memory_t * const memory , uint32_t * const regs ) { log ( ( "%s\\n" , "Execution<S2SV_blank>of<S2SV_blank>a<S2SV_blank>MULTIPLY<S2SV_blank>instruction<S2SV_blank>is<S2SV_blank>starting." ) ) ; multiply_instr instr = * ( ( multiply_instr * ) & code ) ; if ( ! cond_check ( instr . cond , * ( regs + FLAG_REG ) ) ) { return ; } <S2SV_StartBug> int accumulator = ( instr . s & 1 ) ? instr . rn : 0 ; <S2SV_EndBug> uint32_t rm = * ( regs + instr . rm ) ; uint32_t rs = * ( regs + instr . rs ) ; uint32_t rd = rm * rs + accumulator ; * ( regs + instr . rd ) = rd ; if ( instr . s ) { set_negative ( regs + FLAG_REG , ( rd & MSB_MASK ) != 0 ) ; if ( rd == 0 ) { set_zero ( regs + FLAG_REG , 1 ) ; } } log ( ( "%s\\n" , "Execution<S2SV_blank>of<S2SV_blank>a<S2SV_blank>MULTIPLY<S2SV_blank>instruction<S2SV_blank>is<S2SV_blank>ending." ) ) ; } | <S2SV_ModStart> ( instr . a <S2SV_ModEnd> & 1 ) <S2SV_ModStart> 1 ) ? * ( regs + <S2SV_ModStart> instr . rn ) |
2,909 | CWE-000 static unsigned int msm_fd_poll ( struct file * file , struct poll_table_struct * wait ) { struct fd_ctx * ctx = msm_fd_ctx_from_fh ( file -> private_data ) ; unsigned int ret ; <S2SV_StartBug> ret = vb2_poll ( & ctx -> vb2_q , file , wait ) ; <S2SV_EndBug> if ( atomic_read ( & ctx -> subscribed_for_event ) ) { poll_wait ( file , & ctx -> fh . wait , wait ) ; if ( v4l2_event_pending ( & ctx -> fh ) ) ret |= POLLPRI ; } return ret ; } | <S2SV_ModStart> int ret ; mutex_lock ( & ctx -> lock ) ; <S2SV_ModStart> file , wait ) ; mutex_unlock ( & ctx -> lock |
2,910 | CWE-000 static bool socks4_proxy_forward_data ( Socks4Proxy * proxy , int from_fd , int to_fd ) { char buffer [ 0xFF ] ; Direction direction ; int read_size = utils_read_up_to_n ( from_fd , buffer , 0xFF ) ; if ( read_size == - 1 ) return false ; else if ( read_size == 0 ) return true ; send ( to_fd , buffer , read_size , 0 ) ; socks4_proxy_set_last_use_time ( proxy ) ; <S2SV_StartBug> if ( proxy -> log_handle ) <S2SV_EndBug> { <S2SV_StartBug> direction = to_fd == proxy -> base . client_fd ? DIRECTION_TO_CLIENT : DIRECTION_TO_SERVER ; <S2SV_EndBug> log_handle_add_data ( proxy -> log_handle , direction , buffer , read_size ) ; <S2SV_StartBug> } <S2SV_EndBug> return true ; } | <S2SV_ModStart> ; if ( <S2SV_ModEnd> to_fd == proxy <S2SV_ModStart> base . client_fd ) direction = DIRECTION_TO_CLIENT ; else direction = DIRECTION_TO_SERVER ; if ( proxy -> log_handle ) <S2SV_ModEnd> log_handle_add_data ( proxy <S2SV_ModStart> read_size ) ; socks4_proxy_aug_bytes_transfered ( proxy , ( uint64_t ) read_size , direction ) ; <S2SV_ModEnd> return true ; |
2,911 | CWE-000 G_DEFINE_TYPE_WITH_PRIVATE ( Gls2Handle , gls2_handle , G_TYPE_OBJECT ) enum { PROP_0 , <S2SV_StartBug> PROP_SERVICE_NAME ; <S2SV_EndBug> PROP_APP_ID ; LAST_PROP } ; static void gls2_handle_dispose ( GObject * parent ) { G_OBJECT_CLASS ( gls2_handle_parent_class ) -> dispose ( parent ) ; } | <S2SV_ModStart> PROP_0 , PROP_SERVICE_NAME , PROP_APP_ID , <S2SV_ModEnd> LAST_PROP } ; |
2,912 | CWE-000 void debug_msg_uint ( uint32_t i ) { # ifdef DEBUG_OUTPUT_RTT char msg_int [ 11 ] = { 0 } ; if ( i == 0 ) { msg_int [ 0 ] = '0' ; msg_int [ 1 ] = '\\0' ; SEGGER_RTT_WriteString ( 0 , msg_int ) ; return ; } uint32_t temp = i ; uint32_t digits = 0 ; while ( temp > 0 ) { digits ++ ; temp = temp / 10 ; } temp = i ; <S2SV_StartBug> int index = 1 ; <S2SV_EndBug> for ( ; index <= digits ; index ++ ) { msg_int [ digits - index ] = ( char ) ( '0' + ( temp % 10 ) ) ; temp = temp / 10 ; } msg_int [ index - 1 ] = '\\0' ; SEGGER_RTT_WriteString ( 0 , msg_int ) ; # endif } | <S2SV_ModStart> = i ; uint32_t <S2SV_ModEnd> index = 1 |
2,913 | CWE-000 static void tg_update_disptime ( struct throtl_grp * tg ) { struct throtl_service_queue * sq = & tg -> service_queue ; unsigned long read_wait = - 1 , write_wait = - 1 , min_wait = - 1 , disptime ; struct bio * bio ; <S2SV_StartBug> if ( ( bio = throtl_peek_queued ( & sq -> queued [ READ ] ) ) ) <S2SV_EndBug> tg_may_dispatch ( tg , bio , & read_wait ) ; <S2SV_StartBug> if ( ( bio = throtl_peek_queued ( & sq -> queued [ WRITE ] ) ) ) <S2SV_EndBug> tg_may_dispatch ( tg , bio , & write_wait ) ; min_wait = min ( read_wait , write_wait ) ; disptime = jiffies + min_wait ; throtl_dequeue_tg ( tg ) ; tg -> disptime = disptime ; throtl_enqueue_tg ( tg ) ; tg -> flags &= ~ THROTL_TG_WAS_EMPTY ; } | <S2SV_ModStart> * bio ; <S2SV_ModEnd> bio = throtl_peek_queued <S2SV_ModStart> READ ] ) ; if ( bio <S2SV_ModEnd> ) tg_may_dispatch ( <S2SV_ModStart> read_wait ) ; <S2SV_ModEnd> bio = throtl_peek_queued <S2SV_ModStart> WRITE ] ) ; if ( bio <S2SV_ModEnd> ) tg_may_dispatch ( |
2,914 | CWE-000 void blklarge_free ( blklarge * bl ) { <S2SV_StartBug> munmap ( bl -> base , bl -> size ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( bl -> bl_base <S2SV_ModEnd> , bl -> <S2SV_ModStart> , bl -> bl_size <S2SV_ModEnd> ) ; } |
2,915 | CWE-000 void parse_se ( t_lem * s , int se , char * * tm ) { char * tmp ; get_next_line ( 0 , & tmp ) ; tm = ft_strsplit ( tmp , '<S2SV_blank>' ) ; if ( split_cnt ( tm ) == 3 ) check_room ( tm ) ; else print_error ( "invalid<S2SV_blank>room<S2SV_blank>expression." ) ; new_room ( s , tm [ 0 ] , ft_atoi ( tm [ 1 ] ) , ft_atoi ( tm [ 2 ] ) ) ; <S2SV_StartBug> if ( se == 1 ) <S2SV_EndBug> { s -> r -> room -> s = 1 ; s -> r -> room -> e = 0 ; s -> hs = 1 ; } else { s -> r -> room -> e = 1 ; s -> r -> room -> s = 0 ; s -> he = 1 ; } ft_strdel ( & tm [ 1 ] ) ; ft_strdel ( & tm [ 2 ] ) ; free ( tm ) ; s -> tmp = ft_strdup ( tmp ) ; ft_strdel ( & tmp ) ; } | <S2SV_ModStart> ) ) ; case_se ( s , se ) ; <S2SV_ModEnd> ft_strdel ( & |
2,916 | CWE-000 void draw_piece ( const struct piece * p ) { int i ; for ( i = 0 ; i < NPARTS ; i ++ ) if ( p -> parts [ i ] . y < HEIGHT ) <S2SV_StartBug> draw ( p -> parts [ i ] , p -> type ) ; <S2SV_EndBug> } | <S2SV_ModStart> , p -> image <S2SV_ModEnd> ) ; } |
2,917 | CWE-000 static struct dm_stats * _dm_stats_search_region ( struct dm_names * names , struct dm_stats * dms ) { <S2SV_StartBug> uint64_t nr_regions ; <S2SV_EndBug> if ( ! ( dms = dm_stats_create ( DM_STATS_ALL_PROGRAMS ) ) ) goto nostats ; if ( ! dm_stats_bind_name ( dms , names -> name ) ) goto nostats ; if ( ! dm_stats_list ( dms , DM_STATS_ALL_PROGRAMS ) ) goto nostats ; <S2SV_StartBug> if ( ! ( nr_regions = dm_stats_get_nr_regions ( dms ) ) ) <S2SV_EndBug> goto nostats ; return dms ; nostats : dm_stats_destroy ( dms ) ; return NULL ; } | <S2SV_ModStart> dms ) { <S2SV_ModEnd> if ( ! <S2SV_ModStart> if ( ! <S2SV_ModEnd> dm_stats_get_nr_regions ( dms <S2SV_ModStart> dm_stats_get_nr_regions ( dms <S2SV_ModEnd> ) ) goto |
2,918 | CWE-000 static ssize_t bmi160_acc_range_store ( struct device * dev , struct device_attribute * attr , const char * buf , size_t count ) { int err ; <S2SV_StartBug> unsigned long range ; <S2SV_EndBug> err = kstrtoul ( buf , 10 , & range ) ; if ( err ) return err ; err = BMI_CALL_API ( set_accel_range ) ( range ) ; if ( err ) return - EIO ; return count ; } | <S2SV_ModStart> unsigned long range ; struct iio_dev * indio_dev = dev_get_drvdata ( dev ) ; struct bmi_client_data * client_data = iio_priv ( indio_dev ) ; err = bmi160_check_acc_early_buff_enable_flag ( client_data ) ; if ( err ) return count |
2,919 | CWE-000 int kgsl_pwrctrl_init ( struct kgsl_device * device ) { int i , k , m , n = 0 , result ; struct platform_device * pdev = device -> pdev ; struct kgsl_pwrctrl * pwr = & device -> pwrctrl ; struct device_node * ocmem_bus_node ; struct msm_bus_scale_pdata * ocmem_scale_table = NULL ; struct msm_bus_scale_pdata * bus_scale_table ; <S2SV_StartBug> struct device_node * gpubw_dev_node ; <S2SV_EndBug> struct platform_device * p2dev ; bus_scale_table = msm_bus_cl_get_pdata ( device -> pdev ) ; if ( bus_scale_table == NULL ) return - EINVAL ; result = _get_clocks ( device ) ; if ( result ) return result ; if ( pwr -> grp_clks [ 0 ] == NULL ) pwr -> grp_clks [ 0 ] = pwr -> grp_clks [ 1 ] ; if ( of_property_read_u32 ( pdev -> dev . of_node , "qcom,deep-nap-timeout" , & pwr -> deep_nap_timeout ) ) pwr -> deep_nap_timeout = 20 ; pwr -> gx_retention = of_property_read_bool ( pdev -> dev . of_node , "qcom,gx-retention" ) ; if ( pwr -> gx_retention ) { pwr -> dummy_mx_clk = clk_get ( & pdev -> dev , "mx_clk" ) ; if ( IS_ERR ( pwr -> dummy_mx_clk ) ) { pwr -> gx_retention = 0 ; pwr -> dummy_mx_clk = NULL ; KGSL_CORE_ERR ( "Couldn\'t<S2SV_blank>get<S2SV_blank>clock:<S2SV_blank>mx_clk\\n" ) ; } } if ( ! of_property_read_u32 ( pdev -> dev . of_node , "qcom,gpu-bimc-interface-clk-freq" , & pwr -> gpu_bimc_int_clk_freq ) ) pwr -> gpu_bimc_int_clk = devm_clk_get ( & pdev -> dev , "bimc_gpu_clk" ) ; pwr -> power_flags = BIT ( KGSL_PWRFLAGS_RETENTION_ON ) ; if ( pwr -> num_pwrlevels == 0 ) { KGSL_PWR_ERR ( device , "No<S2SV_blank>power<S2SV_blank>levels<S2SV_blank>are<S2SV_blank>defined\\n" ) ; return - EINVAL ; } pwr -> max_pwrlevel = 0 ; pwr -> min_pwrlevel = pwr -> num_pwrlevels - 2 ; pwr -> thermal_pwrlevel = 0 ; pwr -> wakeup_maxpwrlevel = 0 ; for ( i = 0 ; i < pwr -> num_pwrlevels ; i ++ ) { unsigned int freq = pwr -> pwrlevels [ i ] . gpu_freq ; if ( freq > 0 ) freq = clk_round_rate ( pwr -> grp_clks [ 0 ] , freq ) ; pwr -> pwrlevels [ i ] . gpu_freq = freq ; } clk_set_rate ( pwr -> grp_clks [ 0 ] , pwr -> pwrlevels [ pwr -> num_pwrlevels - 1 ] . gpu_freq ) ; clk_set_rate ( pwr -> grp_clks [ 6 ] , clk_round_rate ( pwr -> grp_clks [ 6 ] , KGSL_RBBMTIMER_CLK_FREQ ) ) ; result = get_regulators ( device ) ; if ( result ) return result ; pwr -> power_flags = 0 ; if ( kgsl_property_read_u32 ( device , "qcom,pm-qos-active-latency" , & pwr -> pm_qos_active_latency ) ) pwr -> pm_qos_active_latency = 501 ; if ( kgsl_property_read_u32 ( device , "qcom,pm-qos-wakeup-latency" , & pwr -> pm_qos_wakeup_latency ) ) pwr -> pm_qos_wakeup_latency = 101 ; kgsl_property_read_u32 ( device , "qcom,l2pc-cpu-mask" , & pwr -> l2pc_cpus_mask ) ; pm_runtime_enable ( & pdev -> dev ) ; ocmem_bus_node = of_find_node_by_name ( device -> pdev -> dev . of_node , "qcom,ocmem-bus-client" ) ; if ( ocmem_bus_node ) { ocmem_scale_table = msm_bus_pdata_from_node ( device -> pdev , ocmem_bus_node ) ; if ( ocmem_scale_table ) pwr -> ocmem_pcl = msm_bus_scale_register_client ( ocmem_scale_table ) ; if ( ! pwr -> ocmem_pcl ) return - EINVAL ; } if ( of_property_read_u32 ( pdev -> dev . of_node , "qcom,bus-width" , & pwr -> bus_width ) ) pwr -> bus_width = 0 ; if ( pwr -> bus_control ) gpubw_dev_node = of_parse_phandle ( pdev -> dev . of_node , "qcom,gpubw-dev" , 0 ) ; if ( gpubw_dev_node ) { p2dev = of_find_device_by_node ( gpubw_dev_node ) ; if ( p2dev ) pwr -> devbw = & p2dev -> dev ; } else { pwr -> pcl = msm_bus_scale_register_client ( bus_scale_table ) ; if ( pwr -> pcl == 0 ) return - EINVAL ; } pwr -> bus_ib = kzalloc ( bus_scale_table -> num_usecases * sizeof ( * pwr -> bus_ib ) , GFP_KERNEL ) ; if ( pwr -> bus_ib == NULL ) return - ENOMEM ; for ( i = 0 ; i < bus_scale_table -> num_usecases ; i ++ ) { struct msm_bus_paths * usecase = & bus_scale_table -> usecase [ i ] ; struct msm_bus_vectors * vector = & usecase -> vectors [ 0 ] ; if ( vector -> dst == MSM_BUS_SLAVE_EBI_CH0 && vector -> ib != 0 ) { if ( i < KGSL_MAX_BUSLEVELS ) { ib_votes [ i ] = DIV_ROUND_UP_ULL ( vector -> ib , 1048576 ) - 1 ; if ( ib_votes [ i ] > ib_votes [ max_vote_buslevel ] ) max_vote_buslevel = i ; } for ( k = 0 ; k < n ; k ++ ) if ( vector -> ib == pwr -> bus_ib [ k ] ) break ; if ( k == n ) { pwr -> bus_ib [ k ] = vector -> ib ; n ++ ; for ( m = 0 ; m < pwr -> num_pwrlevels - 1 ; m ++ ) { if ( bus_scale_table -> usecase [ pwr -> pwrlevels [ m ] . bus_freq ] . vectors [ 0 ] . ib == vector -> ib ) pwr -> bus_index [ m ] = k ; } } } } INIT_WORK ( & pwr -> thermal_cycle_ws , kgsl_thermal_cycle ) ; setup_timer ( & pwr -> thermal_timer , kgsl_thermal_timer , ( unsigned long ) device ) ; INIT_LIST_HEAD ( & pwr -> limits ) ; spin_lock_init ( & pwr -> limits_lock ) ; pwr -> sysfs_pwr_limit = kgsl_pwr_limits_add ( KGSL_DEVICE_3D0 ) ; setup_timer ( & pwr -> deep_nap_timer , kgsl_deep_nap_timer , ( unsigned long ) device ) ; devfreq_vbif_register_callback ( kgsl_get_bw ) ; return result ; } | <S2SV_ModStart> device_node * gpubw_dev_node = NULL |
2,920 | CWE-000 int ompi_coll_base_bcast_intra_basic_linear ( void * buff , int count , struct ompi_datatype_t * datatype , int root , struct ompi_communicator_t * comm , mca_coll_base_module_t * module ) { int i , size , rank , err ; ompi_request_t * * preq , * * reqs ; size = ompi_comm_size ( comm ) ; rank = ompi_comm_rank ( comm ) ; OPAL_OUTPUT ( ( ompi_coll_base_framework . framework_output , "ompi_coll_base_bcast_intra_basic_linear<S2SV_blank>rank<S2SV_blank>%d<S2SV_blank>root<S2SV_blank>%d" , rank , root ) ) ; if ( 1 == size ) return OMPI_SUCCESS ; if ( rank != root ) { return MCA_PML_CALL ( recv ( buff , count , datatype , root , MCA_COLL_BASE_TAG_BCAST , comm , MPI_STATUS_IGNORE ) ) ; } <S2SV_StartBug> preq = reqs = coll_base_comm_get_reqs ( module -> base_data , size - 1 ) ; <S2SV_EndBug> if ( NULL == reqs ) { err = OMPI_ERR_OUT_OF_RESOURCE ; goto err_hndl ; } for ( i = 0 ; i < size ; ++ i ) { if ( i == rank ) { continue ; } err = MCA_PML_CALL ( isend ( buff , count , datatype , i , MCA_COLL_BASE_TAG_BCAST , MCA_PML_BASE_SEND_STANDARD , comm , preq ++ ) ) ; if ( MPI_SUCCESS != err ) { goto err_hndl ; } } -- i ; err = ompi_request_wait_all ( i , reqs , MPI_STATUSES_IGNORE ) ; err_hndl : if ( MPI_SUCCESS != err ) { ompi_coll_base_free_reqs ( reqs , i ) ; } return err ; } | <S2SV_ModStart> = reqs = ompi_coll_base_comm_get_reqs <S2SV_ModEnd> ( module -> |
2,921 | CWE-000 int main ( int argc , char * * argv ) { int fd ; int ret ; char file [ BUFF_SIZE ] ; <S2SV_StartBug> fd = open ( argv [ 1 ] , O_RDONLY ) ; <S2SV_EndBug> <S2SV_StartBug> if ( argc != 2 ) <S2SV_EndBug> ft_putstr ( "error\\n" ) ; else { ret = read_tetriminos ( fd , file ) ; if ( ret < 0 ) <S2SV_StartBug> ft_putstr ( "error\\n" ) ; <S2SV_EndBug> else { if ( ! check_tetriminos ( file ) ) <S2SV_StartBug> ft_putstr ( "error\\n" ) ; <S2SV_EndBug> if ( ! setup_puzzle ( file ) ) <S2SV_StartBug> ft_putstr ( "error\\n" ) ; <S2SV_EndBug> } } printf ( "File<S2SV_blank>OK\\n" ) ; return ( 0 ) ; } | <S2SV_ModStart> BUFF_SIZE ] ; if ( argc != 2 ) error ( ) ; <S2SV_ModStart> ; if ( fd < 0 ) error ( <S2SV_ModEnd> ) ; else <S2SV_ModStart> < 0 ) error ( <S2SV_ModEnd> ) ; else <S2SV_ModStart> file ) ) error ( <S2SV_ModEnd> ) ; if <S2SV_ModStart> file ) ) error ( <S2SV_ModEnd> ) ; } |
2,922 | CWE-000 static int list_insert_new ( PMEMobjpool * pop , size_t pe_offset , struct list_head * user_head , PMEMoid dest , int before , size_t size , int ( * constructor ) ( void * ctx , void * ptr , size_t usable_size , void * arg ) , void * arg , PMEMoid * oidp ) { LOG ( 3 , NULL ) ; ASSERT ( user_head != NULL ) ; int ret ; struct lane_section * lane_section ; # ifdef DEBUG int r = pmemobj_mutex_assert_locked ( pop , & user_head -> lock ) ; ASSERTeq ( r , 0 ) ; # endif lane_hold ( pop , & lane_section , LANE_SECTION_LIST ) ; ASSERTne ( lane_section , NULL ) ; ASSERTne ( lane_section -> layout , NULL ) ; size += OBJ_OOB_SIZE ; struct lane_list_layout * section = ( struct lane_list_layout * ) lane_section -> layout ; struct redo_log * redo = section -> redo ; size_t redo_index = 0 ; uint64_t sec_off_off = OBJ_PTR_TO_OFF ( pop , & section -> obj_offset ) ; if ( constructor ) { if ( ( ret = pmalloc_construct ( pop , & section -> obj_offset , size , constructor , arg ) ) ) { ERR ( "!pmalloc_construct" ) ; goto err_pmalloc ; } } else { ret = pmalloc ( pop , & section -> obj_offset , size ) ; if ( ret ) { ERR ( "!pmalloc" ) ; goto err_pmalloc ; } } uint64_t obj_doffset = section -> obj_offset ; ASSERT ( ( ssize_t ) pe_offset >= 0 ) ; dest = list_get_dest ( pop , user_head , dest , ( ssize_t ) pe_offset , before ) ; struct list_entry * entry_ptr = ( struct list_entry * ) OBJ_OFF_TO_PTR ( pop , obj_doffset + pe_offset ) ; struct list_entry * dest_entry_ptr = ( struct list_entry * ) OBJ_OFF_TO_PTR ( pop , dest . off + pe_offset ) ; struct list_args_insert args = { . dest = dest , . dest_entry_ptr = dest_entry_ptr , . head = user_head , . before = before , } ; struct list_args_common args_common = { . obj_doffset = obj_doffset , . entry_ptr = entry_ptr , . pe_offset = ( ssize_t ) pe_offset , } ; uint64_t next_offset ; uint64_t prev_offset ; redo_index = list_insert_user ( pop , redo , redo_index , & args , & args_common , & next_offset , & prev_offset ) ; list_fill_entry_persist ( pop , entry_ptr , next_offset , prev_offset ) ; if ( oidp != NULL ) { <S2SV_StartBug> if ( OBJ_PTR_IS_VALID ( pop , oidp ) ) <S2SV_EndBug> redo_index = list_set_oid_redo_log ( pop , redo , redo_index , oidp , obj_doffset , 0 ) ; <S2SV_StartBug> else { <S2SV_EndBug> oidp -> off = obj_doffset ; oidp -> pool_uuid_lo = pop -> uuid_lo ; } } redo_log_store_last ( pop -> redo , redo , redo_index , sec_off_off , 0 ) ; redo_log_process ( pop -> redo , redo , REDO_NUM_ENTRIES ) ; ret = 0 ; err_pmalloc : lane_release ( pop ) ; <S2SV_StartBug> return ret ; <S2SV_EndBug> } | <S2SV_ModStart> oidp ) ) { <S2SV_ModStart> 0 ) ; } <S2SV_ModStart> pop ) ; ASSERT ( ret == 0 || ret == - 1 ) ; |
2,923 | CWE-000 void CuePointClear ( size_t index ) { <S2SV_StartBug> Semaphore_pend ( g_semaCue , BIOS_WAIT_FOREVER ) ; <S2SV_EndBug> if ( index <= MAX_CUE_POINTS ) { g_sysData . cuePoint [ index ] . ipos = 0 ; g_sysData . cuePoint [ index ] . flags = 0x00 ; } Semaphore_post ( g_semaCue ) ; } | <S2SV_ModStart> g_semaCue , BIOS_WAIT_FOREVER ) ; CLI_printf ( "CLEAR<S2SV_blank>Cue<S2SV_blank>Point<S2SV_blank>%d\\r\\n" , index |
2,924 | CWE-000 int gpio_allowed ( int gpio ) { int rtnval = - 1 ; pins_t * p ; int tmpgpio = - 1 ; for ( p = pins_info ; p -> key != NULL ; ++ p ) { tmpgpio = gpio_number ( p ) ; if ( tmpgpio == gpio ) { if ( DEBUG ) printf ( "<S2SV_blank>**<S2SV_blank>gpio_allowed:<S2SV_blank>found<S2SV_blank>match\\n" ) ; if ( ( ( p -> sbc_type == CHIP ) || ( p -> sbc_type == BOTH ) ) && ( is_this_chippro ( ) == 0 ) ) { if ( DEBUG ) <S2SV_StartBug> printf ( "<S2SV_blank>**<S2SV_blank>gpio_allowed:<S2SV_blank>pin<S2SV_blank>allowed<S2SV_blank>for<S2SV_blank>chip<S2SV_blank>or<S2SV_blank>bth<S2SV_blank>and<S2SV_blank>we\'re<S2SV_blank>a<S2SV_blank>chip\\n" ) ; <S2SV_EndBug> rtnval = 1 ; } else if ( ( ( p -> sbc_type == CHIPPRO ) || ( p -> sbc_type == BOTH ) ) && ( is_this_chippro ( ) == 1 ) ) { if ( DEBUG ) printf ( "<S2SV_blank>**<S2SV_blank>gpio_allowed:<S2SV_blank>pin<S2SV_blank>allowed<S2SV_blank>for<S2SV_blank>chip<S2SV_blank>pro<S2SV_blank>or<S2SV_blank>both<S2SV_blank>and<S2SV_blank>we\'re<S2SV_blank>a<S2SV_blank>chip<S2SV_blank>pro\\n" ) ; rtnval = 1 ; } else { if ( DEBUG ) printf ( "<S2SV_blank>**<S2SV_blank>gpio_allowed:<S2SV_blank>pin<S2SV_blank>is<S2SV_blank>not<S2SV_blank>allowed<S2SV_blank>on<S2SV_blank>hardware\\n" ) ; rtnval = 0 ; } } } return rtnval ; } | <S2SV_ModStart> ) printf ( "<S2SV_blank>**<S2SV_blank>gpio_allowed:<S2SV_blank>pin<S2SV_blank>allowed<S2SV_blank>for<S2SV_blank>chip<S2SV_blank>or<S2SV_blank>both<S2SV_blank>and<S2SV_blank>we\'re<S2SV_blank>a<S2SV_blank>chip\\n" <S2SV_ModEnd> ) ; rtnval |
2,925 | CWE-000 int main ( ) { <S2SV_StartBug> int i , j , k , flag ; <S2SV_EndBug> addPrime ( ) ; printf ( "GOLDBACH\'S<S2SV_blank>CONJECTURE:\\nEvery<S2SV_blank>even<S2SV_blank>number<S2SV_blank>n>=4<S2SV_blank>is<S2SV_blank>the<S2SV_blank>sum<S2SV_blank>of<S2SV_blank>two<S2SV_blank>primes.\\n" ) ; <S2SV_StartBug> for ( i = BEGIN ; i <= END ; i ++ ) { <S2SV_EndBug> flag = 0 ; <S2SV_StartBug> for ( j = 0 ; j < END && prime [ j ] && ! flag ; j ++ ) { <S2SV_EndBug> <S2SV_StartBug> for ( k = 0 ; k < END && prime [ k ] ; k ++ ) { <S2SV_EndBug> <S2SV_StartBug> if ( prime [ j ] + prime [ k ] == i ) { <S2SV_EndBug> <S2SV_StartBug> printf ( "%d=%d+%d\\n" , i , prime [ j ] , prime [ k ] ) ; <S2SV_EndBug> flag = 1 ; } } } } <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> k , flag <S2SV_ModEnd> ; printf ( <S2SV_ModStart> END ; i += 2 <S2SV_ModEnd> ) { flag <S2SV_ModStart> ( j = 2 <S2SV_ModEnd> ; j < <S2SV_ModStart> j < END <S2SV_ModEnd> && ! flag <S2SV_ModStart> ++ ) { if ( isPrime ( j ) ) { <S2SV_ModStart> ( k = 2 <S2SV_ModEnd> ; k < <S2SV_ModStart> k < END <S2SV_ModEnd> ; k ++ <S2SV_ModStart> { if ( isPrime ( k ) && j + k <S2SV_ModEnd> == i ) <S2SV_ModStart> , i , j , k <S2SV_ModEnd> ) ; flag <S2SV_ModStart> } } } } |
2,926 | CWE-000 static int logm_change_bufsize ( void ) { int buflen ; <S2SV_StartBug> logm_get ( LOGM_NEW_BUFSIZE , & buflen ) ; <S2SV_EndBug> if ( buflen < 0 ) { LOGM_STATUS_CLEAR ( LOGM_BUFFER_RESIZE_REQ ) ; return 0 ; } g_logm_rsvbuf = ( char * ) realloc ( g_logm_rsvbuf , buflen ) ; if ( ! g_logm_rsvbuf ) { return - 1 ; } memset ( g_logm_rsvbuf , 0 , buflen ) ; lmdbg ( "logm<S2SV_blank>new<S2SV_blank>malloced<S2SV_blank>address<S2SV_blank>is<S2SV_blank>0x%x\\n" , g_logm_rsvbuf ) ; g_logm_head = 0 ; g_logm_tail = 0 ; logm_bufsize = buflen ; g_logm_available = buflen ; g_logm_enqueued_count = 0 ; g_logm_dropmsg_count = 0 ; g_logm_overflow_offset = - 1 ; LOGM_STATUS_CLEAR ( LOGM_BUFFER_RESIZE_REQ ) ; return 0 ; } | <S2SV_ModStart> int buflen ; if ( new_logm_bufsize <= <S2SV_ModEnd> 0 ) { |
2,927 | CWE-000 void MurmurHash3_x86_128_update ( MurmurHash3_x86_128_state * const state , const void * restrict key , const size_t len ) { state -> len += len ; uint8_t * data = ( uint8_t * ) key ; const uint8_t * stop = data + len ; if ( state -> xs_len > 0 ) { MURMUR_FILL_XS ( state -> xs , state -> xs_len , 16 , data , len ) ; } while ( state -> xs_len == 16 || data + 16 <= stop ) { uint32_t k1 ; uint32_t k2 ; uint32_t k3 ; uint32_t k4 ; if ( state -> xs_len == 16 ) { k1 = GET_UINT32 ( & state -> xs [ 0 ] ) ; k2 = GET_UINT32 ( & state -> xs [ 4 ] ) ; k3 = GET_UINT32 ( & state -> xs [ 8 ] ) ; k4 = GET_UINT32 ( & state -> xs [ 12 ] ) ; state -> xs_len = 0 ; } else { k1 = GET_UINT32 ( data ) ; k2 = GET_UINT32 ( data + 4 ) ; k3 = GET_UINT32 ( data + 8 ) ; k4 = GET_UINT32 ( data + 12 ) ; data += 16 ; } <S2SV_StartBug> MURMUR_UPDATE_H1_X86_128 ( state -> h1 ) ; <S2SV_EndBug> MURMUR_MIX ( state -> h1 , state -> h2 , 19 , 0x561ccd1b ) ; <S2SV_StartBug> MURMUR_UPDATE_H2_X86_128 ( state -> h2 ) ; <S2SV_EndBug> MURMUR_MIX ( state -> h2 , state -> h3 , 17 , 0x0bcaa747 ) ; <S2SV_StartBug> MURMUR_UPDATE_H3_X86_128 ( state -> h3 ) ; <S2SV_EndBug> MURMUR_MIX ( state -> h3 , state -> h4 , 15 , 0x96cd1c35 ) ; <S2SV_StartBug> MURMUR_UPDATE_H4_X86_128 ( state -> h4 ) ; <S2SV_EndBug> MURMUR_MIX ( state -> h4 , state -> h1 , 13 , 0x32ac3b17 ) ; } if ( state -> xs_len == 0 && stop > data ) { state -> xs_len = stop - data ; memcpy ( state -> xs , data , state -> xs_len ) ; } } | <S2SV_ModStart> state -> h1 , k1 ) ; MURMUR_MIX_X86 <S2SV_ModEnd> ( state -> <S2SV_ModStart> state -> h2 , k2 ) ; MURMUR_MIX_X86 <S2SV_ModEnd> ( state -> <S2SV_ModStart> state -> h3 , k3 ) ; MURMUR_MIX_X86 <S2SV_ModEnd> ( state -> <S2SV_ModStart> state -> h4 , k4 ) ; MURMUR_MIX_X86 <S2SV_ModEnd> ( state -> |
2,928 | CWE-000 void init_modules ( const enum modules module ) { if ( modules [ module ] . state == UNKN ) { if ( modules [ module ] . self -> num_deps == modules [ module ] . self -> satisfied_deps ) { <S2SV_StartBug> if ( ( conf . single_capture_mode && ! modules [ module ] . self -> standalone ) || modules [ module ] . check ( ) ) { <S2SV_EndBug> disable_module ( module ) ; } else { modules [ module ] . init ( ) ; } } } else if ( is_disabled ( module ) ) { modules [ module ] . state = UNKN ; disable_module ( module ) ; } } | <S2SV_ModStart> . self -> enabled_single_capture <S2SV_ModEnd> ) || modules |
2,929 | CWE-000 static int st_register_resource ( st_resource_info_t * resource_info ) { st_print_log ( "[St_rsc_mgr]<S2SV_blank>st_register_resource<S2SV_blank>IN\\n" ) ; st_print_log ( "[St_rsc_mgr]<S2SV_blank>uri<S2SV_blank>:<S2SV_blank>%s\\n" , oc_string ( resource_info -> uri ) ) ; oc_resource_t * resource = oc_new_resource ( NULL , oc_string ( resource_info -> uri ) , oc_string_array_get_allocated_size ( resource_info -> types ) , resource_info -> device_idx ) ; if ( ! resource ) return - 1 ; int i ; int rw = 0 ; for ( i = 0 ; i < ( int ) oc_string_array_get_allocated_size ( resource_info -> types ) ; i ++ ) { char * value = oc_string_array_get_item ( resource_info -> types , i ) ; oc_resource_bind_resource_type ( resource , value ) ; st_print_log ( "[St_rsc_mgr]<S2SV_blank>rt<S2SV_blank>:<S2SV_blank>%s\\n" , value ) ; if ( rw < ( ST_RSC_READABLE | ST_RSC_WRITABLE ) ) { st_resource_type_t * rt_info = st_data_mgr_get_rsc_type_info ( value ) ; st_property_t * prop = oc_list_head ( rt_info -> properties ) ; <S2SV_StartBug> if ( prop ) { <S2SV_EndBug> if ( rw < prop -> rw ) rw = prop -> rw ; prop = prop -> next ; } } } st_print_log ( "[St_rsc_mgr]<S2SV_blank>interface<S2SV_blank>:<S2SV_blank>%d\\n" , resource_info -> interfaces ) ; oc_resource_bind_resource_interface ( resource , resource_info -> interfaces ) ; st_print_log ( "[St_rsc_mgr]<S2SV_blank>default_interface<S2SV_blank>:<S2SV_blank>%d\\n" , resource_info -> default_interface ) ; oc_resource_set_default_interface ( resource , resource_info -> default_interface ) ; st_print_log ( "[St_rsc_mgr]<S2SV_blank>policy<S2SV_blank>:<S2SV_blank>%d\\n" , resource_info -> policy ) ; oc_resource_set_discoverable ( resource , resource_info -> policy & OC_DISCOVERABLE ? true : false ) ; oc_resource_set_observable ( resource , resource_info -> policy & OC_OBSERVABLE ? true : false ) ; st_print_log ( "[St_rsc_mgr]<S2SV_blank>read<S2SV_blank>:<S2SV_blank>%s,<S2SV_blank>write<S2SV_blank>%s\\n" , rw & ST_RSC_READABLE ? "true" : "false" , rw & ST_RSC_WRITABLE ? "true" : "false" ) ; if ( rw & ST_RSC_READABLE ) { oc_resource_set_request_handler ( resource , OC_GET , st_resource_get_handler , NULL ) ; } if ( rw & ST_RSC_WRITABLE ) { oc_resource_set_request_handler ( resource , OC_POST , st_resource_post_handler , NULL ) ; } st_print_log ( "[St_rsc_mgr]<S2SV_blank>st_register_resource<S2SV_blank>OUT\\n" ) ; return oc_add_resource ( resource ) ? 0 : - 1 ; } | <S2SV_ModStart> properties ) ; while <S2SV_ModEnd> ( prop ) |
2,930 | CWE-000 void get_bipartite_concurrence ( Vec dm , double * concurrence ) { VecScatter ctx_dm ; PetscInt i , dm_size , levels ; PetscScalar * dm_a , val ; PetscReal max ; Mat dm_mat , dm_tilde , result_mat , sigy_sigy ; Vec dm_local ; PetscScalar * work , * eigs , sdummy , * array ; PetscReal * rwork ; PetscBLASInt idummy , lwork , lierr , nb ; levels = 4 ; VecGetSize ( dm , & dm_size ) ; if ( dm_size != levels * levels ) { if ( nid == 0 ) { printf ( "ERROR!<S2SV_blank>The<S2SV_blank>input<S2SV_blank>density<S2SV_blank>matrix<S2SV_blank>is<S2SV_blank>not<S2SV_blank>4x4!\\n" ) ; printf ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Concurrence<S2SV_blank>cannot<S2SV_blank>be<S2SV_blank>calculated.\\n" ) ; exit ( 0 ) ; } } VecScatterCreateToZero ( dm , & ctx_dm , & dm_local ) ; VecScatterBegin ( ctx_dm , dm , dm_local , INSERT_VALUES , SCATTER_FORWARD ) ; VecScatterEnd ( ctx_dm , dm , dm_local , INSERT_VALUES , SCATTER_FORWARD ) ; if ( nid == 0 ) { levels = sqrt ( dm_size ) ; VecGetArray ( dm_local , & dm_a ) ; MatCreateSeqDense ( PETSC_COMM_SELF , levels , levels , dm_a , & dm_mat ) ; MatCreateSeqDense ( PETSC_COMM_SELF , levels , levels , NULL , & sigy_sigy ) ; val = - 1.0 ; MatSetValue ( sigy_sigy , 0 , 3 , val , INSERT_VALUES ) ; MatSetValue ( sigy_sigy , 3 , 0 , val , INSERT_VALUES ) ; val = 1.0 ; MatSetValue ( sigy_sigy , 1 , 2 , val , INSERT_VALUES ) ; MatSetValue ( sigy_sigy , 2 , 1 , val , INSERT_VALUES ) ; MatAssemblyBegin ( sigy_sigy , MAT_FINAL_ASSEMBLY ) ; MatAssemblyEnd ( sigy_sigy , MAT_FINAL_ASSEMBLY ) ; MatDuplicate ( dm_mat , MAT_COPY_VALUES , & dm_tilde ) ; MatConjugate ( dm_tilde ) ; MatMatMult ( sigy_sigy , dm_tilde , MAT_INITIAL_MATRIX , PETSC_DEFAULT , & result_mat ) ; MatMatMult ( result_mat , sigy_sigy , MAT_REUSE_MATRIX , PETSC_DEFAULT , & dm_tilde ) ; MatMatMult ( dm_mat , dm_tilde , MAT_REUSE_MATRIX , PETSC_DEFAULT , & result_mat ) ; MatDenseGetArray ( result_mat , & array ) ; idummy = levels ; lwork = 5 * levels ; PetscMalloc1 ( 5 * levels , & work ) ; PetscMalloc1 ( 2 * levels , & rwork ) ; PetscMalloc1 ( levels , & eigs ) ; PetscBLASIntCast ( levels , & nb ) ; LAPACKgeev_ ( "N" , "N" , & nb , array , & nb , eigs , & sdummy , & idummy , & sdummy , & idummy , work , & lwork , rwork , & lierr ) ; <S2SV_StartBug> max = - 1 ; <S2SV_EndBug> * concurrence = 0 ; for ( i = 0 ; i < levels ; i ++ ) { <S2SV_StartBug> * concurrence = * concurrence + PetscRealPart ( eigs [ i ] ) ; <S2SV_EndBug> <S2SV_StartBug> if ( PetscRealPart ( eigs [ i ] ) > max ) { <S2SV_EndBug> <S2SV_StartBug> max = PetscRealPart ( eigs [ i ] ) ; <S2SV_EndBug> } } * concurrence = 2 * max - * concurrence ; VecRestoreArray ( dm_local , & dm_a ) ; MatDenseRestoreArray ( result_mat , & array ) ; MatDestroy ( & dm_mat ) ; MatDestroy ( & sigy_sigy ) ; MatDestroy ( & dm_tilde ) ; MatDestroy ( & result_mat ) ; PetscFree ( work ) ; PetscFree ( rwork ) ; PetscFree ( eigs ) ; } MPI_Bcast ( concurrence , 1 , MPI_DOUBLE , 0 , PETSC_COMM_WORLD ) ; VecDestroy ( & dm_local ) ; VecScatterDestroy ( & ctx_dm ) ; } | <S2SV_ModStart> lierr ) ; for ( i = 0 ; i < levels ; i ++ ) { max = PetscRealPart ( eigs [ i ] ) ; if ( max < 1e-14 ) { eigs [ i ] = 0.0 ; } } <S2SV_ModStart> * concurrence + sqrt ( <S2SV_ModStart> i ] ) ) <S2SV_ModStart> ; if ( sqrt ( <S2SV_ModStart> [ i ] ) <S2SV_ModStart> { max = sqrt ( <S2SV_ModStart> [ i ] ) |
2,931 | CWE-000 VAL_T * get ( MEM_T * this ) { <S2SV_StartBug> return this -> values ; <S2SV_EndBug> } | <S2SV_ModStart> this -> values + this -> index |
2,932 | CWE-000 asmlinkage void kasan_unpoison_task_stack_below ( const void * watermark ) { <S2SV_StartBug> __kasan_unpoison_stack ( current , watermark ) ; <S2SV_EndBug> } | <S2SV_ModStart> watermark ) { void * base = ( void * ) ( ( unsigned long ) watermark & ~ ( THREAD_SIZE - 1 ) ) ; kasan_unpoison_shadow ( base , watermark - base <S2SV_ModEnd> ) ; } |
2,933 | CWE-000 int main ( int argc , char * * argv ) { const char * opt_configfile = ISNS_DEFAULT_ISNSADM_CONFIG ; isns_client_t * clnt ; isns_attr_list_t * attrs ; isns_simple_t * reg ; isns_portal_info_t portal_info ; uint32_t status ; int opt_replace = 1 ; int c ; while ( ( c = getopt ( argc , argv , "c:d:n" ) ) != - 1 ) { switch ( c ) { case 'c' : opt_configfile = optarg ; break ; case 'd' : isns_enable_debugging ( optarg ) ; break ; case 'n' : opt_replace = 0 ; break ; default : isns_fatal ( "Unknown<S2SV_blank>option\\n" ) ; } } isns_read_config ( opt_configfile ) ; isns_assign_string ( & isns_config . ic_source_name , "iqn.1991-05.com.microsoft:orange" ) ; clnt = isns_create_default_client ( NULL ) ; reg = isns_simple_create ( ISNS_SCN_DEREGISTER , clnt -> ic_source , NULL ) ; attrs = & reg -> is_message_attrs ; STR ( ISCSI_NAME , "iqn.1991-05.com.microsoft:orange" ) ; status = isns_client_call ( clnt , & reg ) ; if ( status != ISNS_SUCCESS ) isns_error ( "SCNDereg<S2SV_blank>failed:<S2SV_blank>%s\\n" , isns_strerror ( status ) ) ; isns_simple_free ( reg ) ; reg = isns_simple_create ( ISNS_DEVICE_DEREGISTER , clnt -> ic_source , NULL ) ; attrs = & reg -> is_operating_attrs ; STR ( ENTITY_IDENTIFIER , "troopa.nki.nl" ) ; U32 ( ENTITY_PROTOCOL , 2 ) ; isns_portal_parse ( & portal_info , "192.168.1.40:3229/tcp" , NULL ) ; isns_portal_to_attr_list ( & portal_info , ISNS_TAG_PORTAL_IP_ADDRESS , ISNS_TAG_PORTAL_TCP_UDP_PORT , attrs ) ; STR ( ISCSI_NAME , "iqn.1991-05.com.microsoft:orange" ) ; status = isns_client_call ( clnt , & reg ) ; if ( status != ISNS_SUCCESS ) isns_fatal ( "DevDereg<S2SV_blank>failed:<S2SV_blank>%s\\n" , isns_strerror ( status ) ) ; isns_simple_free ( reg ) ; reg = isns_simple_create ( ISNS_DEVICE_ATTRIBUTE_REGISTER , clnt -> ic_source , NULL ) ; reg -> is_replace = opt_replace ; attrs = & reg -> is_operating_attrs ; STR ( ENTITY_IDENTIFIER , "troopa.nki.nl" ) ; U32 ( ENTITY_PROTOCOL , 2 ) ; isns_portal_parse ( & portal_info , "192.168.1.40:3229/tcp" , NULL ) ; isns_portal_to_attr_list ( & portal_info , ISNS_TAG_PORTAL_IP_ADDRESS , ISNS_TAG_PORTAL_TCP_UDP_PORT , attrs ) ; U32 ( SCN_PORT , 3230 ) ; U32 ( ESI_PORT , 3230 ) ; U32 ( PG_TAG , 1 ) ; STR ( PG_ISCSI_NAME , "iqn.1991-05.com.microsoft:orange" ) ; STR ( ISCSI_NAME , "iqn.1991-05.com.microsoft:orange" ) ; U32 ( ISCSI_NODE_TYPE , ISNS_ISCSI_INITIATOR_MASK ) ; STR ( ISCSI_ALIAS , "<MS<S2SV_blank>SW<S2SV_blank>iSCSI<S2SV_blank>Initiator>" ) ; status = isns_client_call ( clnt , & reg ) ; if ( status != ISNS_SUCCESS ) isns_fatal ( "DevAttrReg<S2SV_blank>failed:<S2SV_blank>%s\\n" , isns_strerror ( status ) ) ; isns_simple_free ( reg ) ; reg = isns_simple_create ( ISNS_DEVICE_GET_NEXT , clnt -> ic_source , NULL ) ; attrs = & reg -> is_message_attrs ; NIL ( ISCSI_NAME ) ; attrs = & reg -> is_operating_attrs ; <S2SV_StartBug> U32 ( ISCSI_NODE_TYPE , ISNS_ISCSI_TARGET_MASK ) ; <S2SV_EndBug> NIL ( ISCSI_NODE_TYPE ) ; status = isns_client_call ( clnt , & reg ) ; if ( status != ISNS_SUCCESS ) isns_fatal ( "DevGetNext<S2SV_blank>failed:<S2SV_blank>%s\\n" , isns_strerror ( status ) ) ; isns_simple_free ( reg ) ; return 0 ; } | <S2SV_ModStart> ( ISCSI_NODE_TYPE , ISNS_ISCSI_INITIATOR_MASK <S2SV_ModEnd> ) ; NIL |
2,934 | CWE-000 static void btf_int_bits_seq_show ( const struct btf * btf , const struct btf_type * t , void * data , u8 bits_offset , struct seq_file * m ) { u16 left_shift_bits , right_shift_bits ; u32 int_data = btf_type_int ( t ) ; <S2SV_StartBug> u16 nr_bits = BTF_INT_BITS ( int_data ) ; <S2SV_EndBug> <S2SV_StartBug> u16 total_bits_offset ; <S2SV_EndBug> u16 nr_copy_bytes ; u16 nr_copy_bits ; u64 print_num ; total_bits_offset = bits_offset + BTF_INT_OFFSET ( int_data ) ; data += BITS_ROUNDDOWN_BYTES ( total_bits_offset ) ; bits_offset = BITS_PER_BYTE_MASKED ( total_bits_offset ) ; nr_copy_bits = nr_bits + bits_offset ; nr_copy_bytes = BITS_ROUNDUP_BYTES ( nr_copy_bits ) ; print_num = 0 ; memcpy ( & print_num , data , nr_copy_bytes ) ; # ifdef __BIG_ENDIAN_BITFIELD left_shift_bits = bits_offset ; # else left_shift_bits = BITS_PER_U64 - nr_copy_bits ; # endif right_shift_bits = BITS_PER_U64 - nr_bits ; print_num <<= left_shift_bits ; print_num >>= right_shift_bits ; seq_printf ( m , "0x%llx" , print_num ) ; } | <S2SV_ModStart> t ) ; u8 <S2SV_ModEnd> nr_bits = BTF_INT_BITS <S2SV_ModStart> int_data ) ; u8 total_bits_offset ; u8 nr_copy_bytes ; u8 <S2SV_ModEnd> nr_copy_bits ; u64 |
2,935 | CWE-000 void init_student ( struct student * student , char * name , int id , float gpa ) { <S2SV_StartBug> char new_name ; <S2SV_EndBug> <S2SV_StartBug> new_name = ( char * ) malloc ( sizeof ( char ) * ( strlen ( names ) + 1 ) ) ; <S2SV_EndBug> strcopy ( name , new_name ) ; student -> name = new_name ; student -> id = id ; student -> gpa = gpa ; } | <S2SV_ModStart> ) { char * <S2SV_ModStart> ; new_name = <S2SV_ModEnd> malloc ( sizeof <S2SV_ModStart> malloc ( sizeof * new_name <S2SV_ModEnd> * ( strlen |
2,936 | CWE-000 static SECStatus blake2b_Begin ( BLAKE2BContext * ctx , uint8_t outlen , const uint8_t * key , size_t keylen ) { PORT_Assert ( ctx != NULL ) ; if ( ! ctx ) { goto failure ; } if ( outlen == 0 || outlen > BLAKE2B512_LENGTH ) { goto failure ; } if ( key && keylen > BLAKE2B_KEY_SIZE ) { goto failure ; } if ( ( key == NULL && keylen > 0 ) || keylen > BLAKE2B_KEY_SIZE || ( key != NULL && keylen == 0 ) ) { goto failure ; } uint64_t param = outlen ^ ( keylen << 8 ) ^ ( 1 << 16 ) ^ ( 1 << 24 ) ; PORT_Memcpy ( ctx -> h , iv , 8 * 8 ) ; ctx -> h [ 0 ] ^= param ; ctx -> outlen = outlen ; if ( keylen > 0 && keylen <= BLAKE2B_KEY_SIZE && key ) { uint8_t block [ BLAKE2B_BLOCK_LENGTH ] = { 0 } ; PORT_Memcpy ( block , key , keylen ) ; BLAKE2B_Update ( ctx , block , BLAKE2B_BLOCK_LENGTH ) ; PORT_Memset ( block , 0 , BLAKE2B_BLOCK_LENGTH ) ; } return SECSuccess ; failure : <S2SV_StartBug> PORT_Memset ( & ctx , 0 , sizeof ( ctx ) ) ; <S2SV_EndBug> PORT_SetError ( SEC_ERROR_INVALID_ARGS ) ; return SECFailure ; } | <S2SV_ModStart> : PORT_Memset ( <S2SV_ModEnd> ctx , 0 <S2SV_ModStart> , sizeof ( * |
2,937 | CWE-000 void mod_plus ( t_pf * st , char * spaces , char * zeros , char * ptr , long long znak ) { char * tmp ; if ( find ( st -> flag , '-' ) || find ( st -> flag , '0' ) ) { <S2SV_StartBug> if ( znak > 0 ) <S2SV_EndBug> { tmp = ft_strjoin ( "+" , st -> buffer ) ; if ( st -> width > st -> precision && st -> width > ft_strlen ( st -> buffer ) ) tmp [ ft_strlen ( tmp ) - 1 ] = '\\0' ; st -> buffer = tmp ; } } else if ( ft_strlen ( spaces ) > 0 && zeros == NULL && spaces != NULL ) { <S2SV_StartBug> if ( znak > 0 ) <S2SV_EndBug> tmp = ft_strjoin ( "+" , st -> buffer ) ; else tmp = ft_strjoin ( "-" , st -> buffer ) ; ptr ++ ; st -> buffer = ft_strjoin ( ptr , tmp ) ; ft_strdel ( & ( tmp ) ) ; } else mod_plus1 ( st , spaces , zeros , ptr , znak ) ; if ( st -> specifier == 'u' || st -> specifier == 'x' || st -> specifier == 'X' || st -> specifier == 'o' ) ( st -> buffer ) ++ ; } | <S2SV_ModStart> if ( znak >= <S2SV_ModEnd> 0 ) { <S2SV_ModStart> if ( znak >= <S2SV_ModEnd> 0 ) tmp |
2,938 | CWE-000 void set_taskbar_state ( Taskbar * taskbar , TaskbarState state ) { taskbar -> area . bg = panels [ 0 ] . g_taskbar . background [ state ] ; if ( taskbarname_enabled ) { taskbar -> bar_name . area . bg = panels [ 0 ] . g_taskbar . background_name [ state ] ; } <S2SV_StartBug> update_one_taskbar_visibility ( taskbar ) ; <S2SV_EndBug> if ( taskbar -> area . on_screen ) { schedule_redraw ( & taskbar -> area ) ; if ( taskbarname_enabled ) { schedule_redraw ( & taskbar -> bar_name . area ) ; } if ( taskbar_mode == MULTI_DESKTOP && panels [ 0 ] . g_taskbar . background [ TASKBAR_NORMAL ] != panels [ 0 ] . g_taskbar . background [ TASKBAR_ACTIVE ] ) { GList * l = taskbar -> area . children ; if ( taskbarname_enabled ) l = l -> next ; for ( ; l ; l = l -> next ) schedule_redraw ( ( Area * ) l -> data ) ; } } panel_refresh = TRUE ; } | <S2SV_ModStart> ] ; } update_taskbar_visibility <S2SV_ModEnd> ( taskbar ) |
2,939 | CWE-000 void M_io_posix_fd_set_closeonexec ( int fd ) { int flags = fcntl ( fd , F_GETFD ) ; <S2SV_StartBug> if ( flags == - 1 ) <S2SV_EndBug> return ; <S2SV_StartBug> fcntl ( fd , F_SETFD , flags | FD_CLOEXEC ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> F_GETFD ) ; int rv ; <S2SV_ModStart> ) return ; rv = <S2SV_ModStart> FD_CLOEXEC ) ; ( void ) rv ; |
2,940 | CWE-000 Class * classes_get ( Utf8String * clsName ) { Class * cl = NULL ; <S2SV_StartBug> ThreadLock * tl = sys_classloader -> JVM_CLASS -> mb . thread_lock ; <S2SV_EndBug> thread_lock ( tl ) ; if ( clsName ) { cl = hashtable_get ( sys_classloader -> classes , clsName ) ; } <S2SV_StartBug> thread_unlock ( tl ) ; <S2SV_EndBug> return cl ; } | <S2SV_ModStart> = NULL ; garbage_thread_lock ( <S2SV_ModEnd> ) ; if <S2SV_ModStart> ) ; } garbage_thread_unlock ( <S2SV_ModEnd> ) ; return |
2,941 | CWE-000 void WiseAgent_Write ( char * deviceMac , WiseAgentData * data , int count ) { int number = 0 ; int index = 0 ; char * pos = NULL ; WiseAgentData * d ; int otherInfo = 0 ; char deviceId [ 32 ] = { 0 } ; char * topic = NULL ; char * message = NULL ; char * senhublist = NULL ; char * infoString = NULL ; char * netString = NULL ; char * actionString = NULL ; if ( strlen ( deviceMac ) == 16 ) { snprintf ( deviceId , 32 , "%s" , deviceMac ) ; } else if ( strlen ( deviceMac ) > 12 ) { snprintf ( deviceId , 32 , "%s" , deviceMac ) ; } else { snprintf ( deviceId , 32 , "0017%s" , deviceMac ) ; } ToUpper ( deviceId ) ; if ( WiseAccess_FindDevice ( deviceId ) < 0 ) return ; topic = ( char * ) WiseMem_Alloc ( 128 ) ; message = ( char * ) WiseMem_Alloc ( 8192 ) ; senhublist = ( char * ) WiseMem_Alloc ( 4096 ) ; infoString = ( char * ) WiseMem_Alloc ( 1024 ) ; netString = ( char * ) WiseMem_Alloc ( 1024 ) ; actionString = ( char * ) WiseMem_Alloc ( 1024 ) ; pos = senhublist ; for ( index = 0 ; index < count ; index ++ ) { d = & data [ index ] ; if ( d -> name [ 0 ] != '/' ) { sprintf ( message , "%s" , d -> name ) ; } else { sprintf ( message , "%s" , d -> name ) ; otherInfo ++ ; } WiseAccess_Update ( deviceId , message , d ) ; } sprintf ( topic , WA_PUB_DEVINFO_TOPIC , deviceId ) ; for ( index = 0 ; index < count ; index ++ ) { d = & data [ index ] ; if ( d -> name [ 0 ] != '/' ) { if ( number != 0 ) pos += sprintf ( pos , "," ) ; switch ( d -> type ) { case WISE_VALUE : pos += sprintf ( pos , SEN_DEVINFO_SENDATA_V_JSON , d -> name , ( int ) d -> value ) ; break ; case WISE_FLOAT : pos += sprintf ( pos , SEN_DEVINFO_SENDATA_FV_JSON , d -> name , d -> value ) ; break ; case WISE_BOOL : pos += sprintf ( pos , SEN_DEVINFO_SENDATA_BV_JSON , d -> name , d -> value > 0 ? "true" : "false" ) ; break ; case WISE_STRING : pos += sprintf ( pos , SEN_DEVINFO_SENDATA_SV_JSON , d -> name , d -> string ) ; break ; default : wiseprint ( "Datatype<S2SV_blank>error!!\\n" ) ; infiniteloop ( ) ; break ; } number ++ ; } } if ( otherInfo ) { WiseAccess_GenerateTokenDataInfo ( deviceId , "Info" , infoString , WiseMem_Size ( infoString ) ) ; WiseAccess_GenerateTokenDataInfo ( deviceId , "Net" , netString , WiseMem_Size ( netString ) ) ; WiseAccess_GenerateTokenDataInfo ( deviceId , "Action" , actionString , WiseMem_Size ( actionString ) ) ; <S2SV_StartBug> sprintf ( message , SEN_DEVINFO_JSON , senhublist , infoString , netString , actionString , deviceId , timestamp ++ ) ; <S2SV_EndBug> } else { <S2SV_StartBug> sprintf ( message , SEN_DEVINFO_JSON , senhublist , "" , "" , "" , deviceId , timestamp ++ ) ; <S2SV_EndBug> } wiseprint ( "message:\\033[33m\\"%s\\"\\033[0m\\r\\n" , message ) ; core_publish ( topic , message , strlen ( message ) , 0 , 0 ) ; WiseMem_Release ( ) ; } | <S2SV_ModStart> , actionString , timestamp ++ , deviceId , timestamp <S2SV_ModEnd> ) ; } <S2SV_ModStart> "" , "" <S2SV_ModEnd> , timestamp ++ <S2SV_ModStart> , timestamp ++ , deviceId , timestamp |
2,942 | CWE-000 u_char * ngx_http_vhost_traffic_status_display_prometheus_set_server_node ( ngx_http_request_t * r , u_char * buf , ngx_str_t * key , ngx_http_vhost_traffic_status_node_t * vtsn ) { ngx_log_error ( NGX_LOG_ERR , r -> connection -> log , 0 , "Logging<S2SV_blank>from<S2SV_blank>ngx_http_vhost_traffic_status_display_prometheus_set_server_node" ) ; <S2SV_StartBug> uint32_t decode_status = ngx_utf8_decode ( key -> data , key -> len ) ; <S2SV_EndBug> <S2SV_StartBug> if ( decode_status < 0x80 || decode_status > 0x10ffff ) { <S2SV_EndBug> return buf ; } ngx_str_t server ; ngx_uint_t i , n ; ngx_http_vhost_traffic_status_loc_conf_t * vtscf ; ngx_http_vhost_traffic_status_node_histogram_bucket_t * b ; vtscf = ngx_http_get_module_loc_conf ( r , ngx_http_vhost_traffic_status_module ) ; server = * key ; ( void ) ngx_http_vhost_traffic_status_node_position_key ( & server , 1 ) ; buf = ngx_sprintf ( buf , NGX_HTTP_VHOST_TRAFFIC_STATUS_PROMETHEUS_FMT_SERVER , & server , vtsn -> stat_in_bytes , & server , vtsn -> stat_out_bytes , & server , vtsn -> stat_1xx_counter , & server , vtsn -> stat_2xx_counter , & server , vtsn -> stat_3xx_counter , & server , vtsn -> stat_4xx_counter , & server , vtsn -> stat_5xx_counter , & server , vtsn -> stat_request_counter , & server , ( double ) vtsn -> stat_request_time_counter / 1000 , & server , ( double ) ngx_http_vhost_traffic_status_node_time_queue_average ( & vtsn -> stat_request_times , vtscf -> average_method , vtscf -> average_period ) / 1000 ) ; b = & vtsn -> stat_request_buckets ; n = b -> len ; if ( n > 0 ) { for ( i = 0 ; i < n ; i ++ ) { buf = ngx_sprintf ( buf , NGX_HTTP_VHOST_TRAFFIC_STATUS_PROMETHEUS_FMT_SERVER_HISTOGRAM_BUCKET , & server , ( double ) b -> buckets [ i ] . msec / 1000 , b -> buckets [ i ] . counter ) ; } buf = ngx_sprintf ( buf , NGX_HTTP_VHOST_TRAFFIC_STATUS_PROMETHEUS_FMT_SERVER_HISTOGRAM_BUCKET_E , & server , vtsn -> stat_request_counter ) ; buf = ngx_sprintf ( buf , NGX_HTTP_VHOST_TRAFFIC_STATUS_PROMETHEUS_FMT_SERVER_HISTOGRAM_SUM , & server , ( double ) vtsn -> stat_request_time_counter / 1000 ) ; buf = ngx_sprintf ( buf , NGX_HTTP_VHOST_TRAFFIC_STATUS_PROMETHEUS_FMT_SERVER_HISTOGRAM_COUNT , & server , vtsn -> stat_request_counter ) ; } # if ( NGX_HTTP_CACHE ) buf = ngx_sprintf ( buf , NGX_HTTP_VHOST_TRAFFIC_STATUS_PROMETHEUS_FMT_SERVER_CACHE , & server , vtsn -> stat_cache_miss_counter , & server , vtsn -> stat_cache_bypass_counter , & server , vtsn -> stat_cache_expired_counter , & server , vtsn -> stat_cache_stale_counter , & server , vtsn -> stat_cache_updating_counter , & server , vtsn -> stat_cache_revalidated_counter , & server , vtsn -> stat_cache_hit_counter , & server , vtsn -> stat_cache_scarce_counter ) ; # endif return buf ; } | <S2SV_ModStart> "Logging<S2SV_blank>from<S2SV_blank>ngx_http_vhost_traffic_status_display_prometheus_set_server_node" ) ; size_t decode_status = ngx_utf8_length <S2SV_ModEnd> ( key -> <S2SV_ModStart> if ( decode_status == 0xffffffff || decode_status == 0xfffffffe <S2SV_ModEnd> ) { return |
2,943 | CWE-000 static int config_write_network ( struct vty * vty , struct eigrp * eigrp ) { <S2SV_StartBug> struct route_node * rn ; <S2SV_EndBug> for ( rn = route_top ( eigrp -> networks ) ; rn ; rn = route_next ( rn ) ) if ( rn -> info ) { vty_outln ( vty , "<S2SV_blank>network<S2SV_blank>%s/%d<S2SV_blank>" , inet_ntoa ( rn -> p . u . prefix4 ) , rn -> p . prefixlen ) ; } if ( eigrp -> max_paths != EIGRP_MAX_PATHS_DEFAULT ) vty_outln ( vty , "<S2SV_blank>maximum-paths<S2SV_blank>%d" , eigrp -> max_paths ) ; if ( eigrp -> variance != EIGRP_VARIANCE_DEFAULT ) vty_outln ( vty , "<S2SV_blank>variance<S2SV_blank>%d" , eigrp -> variance ) ; <S2SV_StartBug> vty_outln ( vty , "!" ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> route_node * rn ; int i <S2SV_ModStart> variance ) ; for ( i = 0 ; i < ZEBRA_ROUTE_MAX ; i ++ ) if ( i != zclient -> redist_default && vrf_bitmap_check ( zclient -> redist [ AFI_IP ] [ i ] , VRF_DEFAULT ) ) vty_outln ( vty , "<S2SV_blank>redistribute<S2SV_blank>%s" , zebra_route_string ( i ) ) ; |
2,944 | CWE-000 bool leaf_block_has_space ( int num_of_records , int len1 , int len2 ) { <S2SV_StartBug> int used_space = sizeof ( bool ) + 3 * sizeof ( int ) + num_of_records * ( len1 + len2 ) ; <S2SV_EndBug> <S2SV_StartBug> int free_space = BF_BLOCK_SIZE - used_space ; <S2SV_EndBug> return free_space > 0 ? true : false ; } | <S2SV_ModStart> ) { int new_used_space <S2SV_ModEnd> = sizeof ( <S2SV_ModStart> int ) + ( num_of_records + 1 ) <S2SV_ModEnd> * ( len1 <S2SV_ModStart> = BF_BLOCK_SIZE - new_used_space <S2SV_ModEnd> ; return free_space |
2,945 | CWE-000 <S2SV_StartBug> ATF_TC_CLEANUP ( setrlimit_failure , tc ) <S2SV_EndBug> { cleanup ( ) ; } | <S2SV_ModStart> <S2SV_null> ATF_TC_CLEANUP ( setrlimit_success <S2SV_ModEnd> , tc ) |
2,946 | CWE-000 static WhereTerm * whereScanInit ( WhereScan * pScan , WhereClause * pWC , int iCur , int iColumn , u32 opMask , Index * pIdx ) { int j ; pScan -> pOrigWC = pWC ; pScan -> pWC = pWC ; if ( pIdx && iColumn >= 0 ) { pScan -> idxaff = pIdx -> pTable -> aCol [ iColumn ] . affinity ; for ( j = 0 ; pIdx -> aiColumn [ j ] != iColumn ; j ++ ) { <S2SV_StartBug> if ( NEVER ( j >= pIdx -> nColumn ) ) return 0 ; <S2SV_EndBug> } pScan -> zCollName = pIdx -> azColl [ j ] ; } else { pScan -> idxaff = 0 ; pScan -> zCollName = 0 ; } pScan -> opMask = opMask ; pScan -> k = 0 ; pScan -> aEquiv [ 0 ] = iCur ; pScan -> aEquiv [ 1 ] = iColumn ; pScan -> nEquiv = 2 ; pScan -> iEquiv = 2 ; return whereScanNext ( pScan ) ; } | <S2SV_ModStart> >= pIdx -> nKeyCol <S2SV_ModEnd> ) ) return |
2,947 | CWE-000 static void realize ( DeviceState * d , Error * * errp ) { sPAPRDRConnector * drc = SPAPR_DR_CONNECTOR ( d ) ; Object * root_container ; gchar * link_name ; gchar * child_name ; Error * err = NULL ; trace_spapr_drc_realize ( spapr_drc_index ( drc ) ) ; root_container = container_get ( object_get_root ( ) , DRC_CONTAINER_PATH ) ; link_name = g_strdup_printf ( "%x" , spapr_drc_index ( drc ) ) ; child_name = object_get_canonical_path_component ( OBJECT ( drc ) ) ; trace_spapr_drc_realize_child ( spapr_drc_index ( drc ) , child_name ) ; object_property_add_alias ( root_container , link_name , drc -> owner , child_name , & err ) ; g_free ( child_name ) ; g_free ( link_name ) ; if ( err ) { error_propagate ( errp , err ) ; return ; } vmstate_register ( DEVICE ( drc ) , spapr_drc_index ( drc ) , & vmstate_spapr_drc , drc ) ; <S2SV_StartBug> qemu_register_reset ( drc_reset , drc ) ; <S2SV_EndBug> trace_spapr_drc_realize_complete ( spapr_drc_index ( drc ) ) ; } | <S2SV_ModStart> drc ) ; <S2SV_ModEnd> trace_spapr_drc_realize_complete ( spapr_drc_index |
2,948 | CWE-000 static int display_event ( int fd , uint32_t mask , void * data ) { if ( mask & WL_EVENT_HANGUP ) { sway_terminate ( 0 ) ; } <S2SV_StartBug> if ( wl_display_dispatch ( state . display ) < 0 ) { <S2SV_EndBug> <S2SV_StartBug> wlr_log_errno ( WLR_ERROR , "wl_display_dispatch<S2SV_blank>failed,<S2SV_blank>exiting" ) ; <S2SV_EndBug> sway_terminate ( 0 ) ; } wl_display_flush ( state . display ) ; return 0 ; } | <S2SV_ModStart> } if ( wl_display_read_events <S2SV_ModEnd> ( state . <S2SV_ModStart> ( WLR_ERROR , "wl_display_read_events<S2SV_blank>failed,<S2SV_blank>exiting" ) ; sway_terminate ( 0 ) ; } else if ( wl_display_dispatch_pending ( state . display ) < 0 ) { wlr_log_errno ( WLR_ERROR , "wl_display_dispatch_pending<S2SV_blank>failed,<S2SV_blank>exiting" <S2SV_ModEnd> ) ; sway_terminate |
2,949 | CWE-000 int main ( int argc , char * const * argv ) { snd_pcm_stream_t direction ; enum subcmds subcmd ; int err = 0 ; if ( ! decide_direction ( argc , argv , & direction ) ) subcmd = SUBCMD_HELP ; else decide_subcmd ( argc , argv , & subcmd ) ; if ( subcmd == SUBCMD_TRANSFER ) <S2SV_StartBug> printf ( "execute<S2SV_blank>\'transfer\'<S2SV_blank>subcmd.\\n" ) ; <S2SV_EndBug> else if ( subcmd == SUBCMD_LIST ) err = subcmd_list ( argc , argv , direction ) ; else if ( subcmd == SUBCMD_VERSION ) print_version ( argv [ 0 ] ) ; else print_help ( ) ; if ( err < 0 ) return EXIT_FAILURE ; return EXIT_SUCCESS ; } | <S2SV_ModStart> == SUBCMD_TRANSFER ) err = subcmd_transfer ( argc , argv , direction <S2SV_ModEnd> ) ; else |
2,950 | CWE-000 void f2fs_evict_inode ( struct inode * inode ) { struct f2fs_sb_info * sbi = F2FS_I_SB ( inode ) ; nid_t xnid = F2FS_I ( inode ) -> i_xattr_nid ; int err = 0 ; if ( f2fs_is_atomic_file ( inode ) ) drop_inmem_pages ( inode ) ; trace_f2fs_evict_inode ( inode ) ; truncate_inode_pages_final ( & inode -> i_data ) ; if ( inode -> i_ino == F2FS_NODE_INO ( sbi ) || inode -> i_ino == F2FS_META_INO ( sbi ) ) goto out_clear ; f2fs_bug_on ( sbi , get_dirty_pages ( inode ) ) ; remove_dirty_inode ( inode ) ; f2fs_destroy_extent_tree ( inode ) ; if ( inode -> i_nlink || is_bad_inode ( inode ) ) goto no_delete ; dquot_initialize ( inode ) ; remove_ino_entry ( sbi , inode -> i_ino , APPEND_INO ) ; remove_ino_entry ( sbi , inode -> i_ino , UPDATE_INO ) ; remove_ino_entry ( sbi , inode -> i_ino , FLUSH_INO ) ; sb_start_intwrite ( inode -> i_sb ) ; set_inode_flag ( inode , FI_NO_ALLOC ) ; i_size_write ( inode , 0 ) ; retry : if ( F2FS_HAS_BLOCKS ( inode ) ) err = f2fs_truncate ( inode ) ; # ifdef CONFIG_F2FS_FAULT_INJECTION if ( time_to_inject ( sbi , FAULT_EVICT_INODE ) ) { f2fs_show_injection_info ( FAULT_EVICT_INODE ) ; err = - EIO ; } # endif if ( ! err ) { f2fs_lock_op ( sbi ) ; err = remove_inode_page ( inode ) ; f2fs_unlock_op ( sbi ) ; if ( err == - ENOENT ) err = 0 ; } if ( err == - ENOMEM ) { err = 0 ; goto retry ; } if ( err ) update_inode_page ( inode ) ; dquot_free_inode ( inode ) ; sb_end_intwrite ( inode -> i_sb ) ; no_delete : dquot_drop ( inode ) ; stat_dec_inline_xattr ( inode ) ; stat_dec_inline_dir ( inode ) ; stat_dec_inline_inode ( inode ) ; if ( likely ( ! is_set_ckpt_flags ( sbi , CP_ERROR_FLAG ) ) ) f2fs_bug_on ( sbi , is_inode_flag_set ( inode , FI_DIRTY_INODE ) ) ; else f2fs_inode_synced ( inode ) ; if ( inode -> i_ino ) invalidate_mapping_pages ( NODE_MAPPING ( sbi ) , inode -> i_ino , inode -> i_ino ) ; if ( xnid ) invalidate_mapping_pages ( NODE_MAPPING ( sbi ) , xnid , xnid ) ; if ( inode -> i_nlink ) { if ( is_inode_flag_set ( inode , FI_APPEND_WRITE ) ) add_ino_entry ( sbi , inode -> i_ino , APPEND_INO ) ; if ( is_inode_flag_set ( inode , FI_UPDATE_WRITE ) ) add_ino_entry ( sbi , inode -> i_ino , UPDATE_INO ) ; } if ( is_inode_flag_set ( inode , FI_FREE_NID ) ) { alloc_nid_failed ( sbi , inode -> i_ino ) ; clear_inode_flag ( inode , FI_FREE_NID ) ; } else { <S2SV_StartBug> f2fs_bug_on ( sbi , err && <S2SV_EndBug> ! exist_written_data ( sbi , inode -> i_ino , ORPHAN_INO ) ) ; } out_clear : fscrypt_put_encryption_info ( inode ) ; clear_inode ( inode ) ; } | <S2SV_ModStart> } else { <S2SV_ModEnd> } out_clear : |
2,951 | CWE-000 static PyObject * GMPy_Rational_FloorDiv ( PyObject * x , PyObject * y , CTXT_Object * context ) { MPZ_Object * result ; MPQ_Object * tempq ; CHECK_CONTEXT ( context ) ; result = GMPy_MPZ_New ( context ) ; tempq = GMPy_MPQ_New ( context ) ; if ( ! result || ! tempq ) { Py_XDECREF ( ( PyObject * ) result ) ; Py_XDECREF ( ( PyObject * ) tempq ) ; return NULL ; } if ( MPQ_Check ( x ) && MPQ_Check ( y ) ) { if ( mpq_sgn ( MPQ ( y ) ) == 0 ) { ZERO_ERROR ( "division<S2SV_blank>or<S2SV_blank>modulo<S2SV_blank>by<S2SV_blank>zero" ) ; goto error ; } mpq_div ( tempq -> q , MPQ ( x ) , MPQ ( y ) ) ; mpz_fdiv_q ( result -> z , mpq_numref ( tempq -> q ) , mpq_denref ( tempq -> q ) ) ; Py_DECREF ( ( PyObject * ) tempq ) ; return ( PyObject * ) result ; } if ( IS_RATIONAL ( x ) && IS_RATIONAL ( y ) ) { MPQ_Object * tempx , * tempy ; tempx = GMPy_MPQ_From_Number ( x , context ) ; tempy = GMPy_MPQ_From_Number ( y , context ) ; if ( ! tempx || ! tempy ) { Py_XDECREF ( ( PyObject * ) tempx ) ; Py_XDECREF ( ( PyObject * ) tempy ) ; goto error ; } if ( mpq_sgn ( tempy -> q ) == 0 ) { ZERO_ERROR ( "division<S2SV_blank>or<S2SV_blank>modulo<S2SV_blank>by<S2SV_blank>zero" ) ; Py_DECREF ( ( PyObject * ) tempx ) ; Py_DECREF ( ( PyObject * ) tempy ) ; goto error ; } mpq_div ( tempq -> q , tempx -> q , tempy -> q ) ; <S2SV_StartBug> mpz_fdiv_q ( result -> z , mpq_numref ( tempx -> q ) , mpq_denref ( tempy -> q ) ) ; <S2SV_EndBug> Py_DECREF ( ( PyObject * ) tempx ) ; Py_DECREF ( ( PyObject * ) tempy ) ; Py_DECREF ( ( PyObject * ) tempq ) ; return ( PyObject * ) result ; } Py_DECREF ( ( PyObject * ) result ) ; Py_RETURN_NOTIMPLEMENTED ; error : Py_DECREF ( ( PyObject * ) result ) ; Py_DECREF ( ( PyObject * ) tempq ) ; return NULL ; } | <S2SV_ModStart> , mpq_numref ( tempq <S2SV_ModEnd> -> q ) <S2SV_ModStart> , mpq_denref ( tempq <S2SV_ModEnd> -> q ) |
2,952 | CWE-000 instruction decode ( uint32_t instr ) { instruction decoded ; if ( instr == 0 ) { decoded . type = HALT ; decoded . code = 0 ; } else { uint32_t BRANCH_MASK = 1 << 27 ; uint32_t DATA_TRANSFER_MASK = 1 << 26 ; uint32_t MULTIPLY_MASK = 9 << 4 ; decoded . code = instr ; if ( instr & BRANCH_MASK ) { decoded . type = BRANCH ; } else if ( instr & DATA_TRANSFER_MASK ) { decoded . type = DATA_TRANSFER ; <S2SV_StartBug> } else if ( ( instr & MULTIPLY_MASK ) == MULTIPLY_MASK ) { <S2SV_EndBug> decoded . type = MULTIPLY ; } else { decoded . type = DATA_PROCESSING ; } } return decoded ; } | <S2SV_ModStart> ) == MULTIPLY_MASK && ( ( instr >> 22 ) & 0x3F == 0 ) |
2,953 | CWE-000 char * get_sharing_options ( runtimeConfEntry * conf , int container_slot , bool * has_error , char * * uds_dir ) { char * res = NULL ; * has_error = false ; if ( conf -> nSharedDirs >= 0 ) { char * * volumes = NULL ; int totallen = 0 ; char * pos ; int i ; int j ; char comma = '<S2SV_blank>' ; volumes = palloc ( ( conf -> nSharedDirs + 1 ) * sizeof ( char * ) ) ; for ( i = 0 ; i < conf -> nSharedDirs ; i ++ ) { volumes [ i ] = palloc ( 10 + strlen ( conf -> sharedDirs [ i ] . host ) + strlen ( conf -> sharedDirs [ i ] . container ) ) ; if ( i > 0 ) comma = ',' ; if ( conf -> sharedDirs [ i ] . mode == PLC_ACCESS_READONLY ) { sprintf ( volumes [ i ] , "<S2SV_blank>%c\\"%s:%s:ro\\"" , comma , conf -> sharedDirs [ i ] . host , conf -> sharedDirs [ i ] . container ) ; } else if ( conf -> sharedDirs [ i ] . mode == PLC_ACCESS_READWRITE ) { sprintf ( volumes [ i ] , "<S2SV_blank>%c\\"%s:%s:rw\\"" , comma , conf -> sharedDirs [ i ] . host , conf -> sharedDirs [ i ] . container ) ; } else { snprintf ( backend_error_message , sizeof ( backend_error_message ) , "Cannot<S2SV_blank>determine<S2SV_blank>directory<S2SV_blank>sharing<S2SV_blank>mode:<S2SV_blank>%d" , conf -> sharedDirs [ i ] . mode ) ; * has_error = true ; for ( j = 0 ; j <= i ; j ++ ) { pfree ( volumes [ i ] ) ; } pfree ( volumes ) ; return NULL ; } totallen += strlen ( volumes [ i ] ) ; } if ( ! conf -> useContainerNetwork ) { <S2SV_StartBug> if ( i > 0 ) <S2SV_EndBug> comma = ',' ; int gpdb_dir_sz ; gpdb_dir_sz = strlen ( IPC_GPDB_BASE_DIR ) + 1 + 16 + 1 + 16 + 1 + 4 + 1 ; * uds_dir = pmalloc ( gpdb_dir_sz ) ; sprintf ( * uds_dir , "%s.%d.%d.%d" , IPC_GPDB_BASE_DIR , getpid ( ) , domain_socket_no ++ , container_slot ) ; volumes [ i ] = pmalloc ( 10 + gpdb_dir_sz + strlen ( IPC_CLIENT_DIR ) ) ; sprintf ( volumes [ i ] , "<S2SV_blank>%c\\"%s:%s:rw\\"" , comma , * uds_dir , IPC_CLIENT_DIR ) ; totallen += strlen ( volumes [ i ] ) ; if ( mkdir ( * uds_dir , S_IRWXU ) < 0 && errno != EEXIST ) { snprintf ( backend_error_message , sizeof ( backend_error_message ) , "Cannot<S2SV_blank>create<S2SV_blank>directory<S2SV_blank>%s:<S2SV_blank>%s" , * uds_dir , strerror ( errno ) ) ; * has_error = true ; for ( j = 0 ; j <= i ; j ++ ) { pfree ( volumes [ i ] ) ; } pfree ( volumes ) ; return NULL ; } } res = palloc ( totallen + conf -> nSharedDirs + 1 + 1 ) ; pos = res ; for ( i = 0 ; i < ( conf -> useContainerNetwork ? conf -> nSharedDirs : conf -> nSharedDirs + 1 ) ; i ++ ) { memcpy ( pos , volumes [ i ] , strlen ( volumes [ i ] ) ) ; pos += strlen ( volumes [ i ] ) ; * pos = '<S2SV_blank>' ; pos ++ ; pfree ( volumes [ i ] ) ; } * pos = '\\0' ; pfree ( volumes ) ; } return res ; } | <S2SV_ModStart> useContainerNetwork ) { int gpdb_dir_sz ; if ( i > 0 ) comma = ',' <S2SV_ModEnd> ; gpdb_dir_sz = |
2,954 | CWE-000 int main ( void ) { printf ( "Please<S2SV_blank>enter<S2SV_blank>a<S2SV_blank>name<S2SV_blank>under<S2SV_blank>%d<S2SV_blank>characters:<S2SV_blank>" , MAX_INPUT_LENGTH ) ; scanf ( "%s" , name ) ; if ( strlen ( name ) > MAX_INPUT_LENGTH ) { printf ( "Error:<S2SV_blank>You<S2SV_blank>name<S2SV_blank>had<S2SV_blank>%d<S2SV_blank>characters.<S2SV_blank>You<S2SV_blank>should<S2SV_blank>have<S2SV_blank>up<S2SV_blank>to<S2SV_blank>%d.<S2SV_blank>Please<S2SV_blank>retry" , strlen ( name ) , MAX_INPUT_LENGTH ) ; exit ( 1 ) ; } name [ 0 ] = toupper ( name [ 0 ] ) ; printf ( "Hey<S2SV_blank>%s!<S2SV_blank>Choose<S2SV_blank>GROCERIES,<S2SV_blank>ENTERTAINMENT<S2SV_blank>or<S2SV_blank>EXIT<S2SV_blank>if<S2SV_blank>done:<S2SV_blank>" , name ) ; scanf ( "%s" , usrin ) ; while ( ( strcmp ( usrin , "GROCERIES" ) ) & ( strcmp ( usrin , "ENTERTAINMENT" ) ) ) { printf ( "Try<S2SV_blank>again.<S2SV_blank>Please<S2SV_blank>enter<S2SV_blank>GROCERIES,<S2SV_blank>ENTERTAINMENT<S2SV_blank>or<S2SV_blank>EXIT<S2SV_blank>if<S2SV_blank>done:<S2SV_blank>" ) ; scanf ( "%s" , usrin ) ; } while ( 1 ) { if ( ! strcmp ( usrin , "GROCERIES" ) ) { groc_flag = 1 ; printf ( "GROCERIES<S2SV_blank>selected\\n" ) ; while ( 1 ) { printf ( "%s,<S2SV_blank>please<S2SV_blank>select<S2SV_blank>FRUITS/VEGETABLES,<S2SV_blank>OTHERS<S2SV_blank>or<S2SV_blank>back<S2SV_blank>to<S2SV_blank>main<S2SV_blank>menu<S2SV_blank>for<S2SV_blank>item<S2SV_blank>entry:" , name ) ; <S2SV_StartBug> gets ( usrin ) ; <S2SV_EndBug> if ( ! strcmp ( usrin , "FRUITS/VEGETABLES" ) ) { printf ( "Enter<S2SV_blank>amount<S2SV_blank>spent<S2SV_blank>on<S2SV_blank>FRUITS/VEGETABLES<S2SV_blank>this<S2SV_blank>week:<S2SV_blank>" ) ; scanf ( "%d" , & fruit_cost ) ; if ( ! value_check ( fruit_cost ) ) { fruit_flag = 1 ; } } else if ( ! strcmp ( usrin , "OTHERS" ) ) { printf ( "Enter<S2SV_blank>amount<S2SV_blank>spent<S2SV_blank>on<S2SV_blank>other<S2SV_blank>groceries<S2SV_blank>this<S2SV_blank>week:<S2SV_blank>" ) ; scanf ( "%d" , & groc_other_cost ) ; if ( ! value_check ( groc_other_cost ) ) { groc_other_flag = 1 ; } } else if ( ! strcmp ( usrin , "back<S2SV_blank>to<S2SV_blank>main<S2SV_blank>menu" ) ) { if ( ( fruit_flag ) & ( groc_other_flag ) ) { break ; } else { printf ( "You<S2SV_blank>have<S2SV_blank>not<S2SV_blank>entered<S2SV_blank>at<S2SV_blank>least<S2SV_blank>one<S2SV_blank>value<S2SV_blank>for<S2SV_blank>each<S2SV_blank>section\\n" ) ; } } else { printf ( "Not<S2SV_blank>all<S2SV_blank>subcategories<S2SV_blank>filled<S2SV_blank>out\\n" ) ; } } printf ( "Thanks<S2SV_blank>for<S2SV_blank>adding<S2SV_blank>your<S2SV_blank>weekly<S2SV_blank>grocery<S2SV_blank>costs.<S2SV_blank>Back<S2SV_blank>to<S2SV_blank>main<S2SV_blank>menu\\n" ) ; } else if ( ! strcmp ( usrin , "ENTERTAINMENT" ) ) { etmt_flag = 1 ; printf ( "ENTERTAINMENT<S2SV_blank>selected\\n" ) ; while ( 1 ) { printf ( "%s,<S2SV_blank>please<S2SV_blank>select<S2SV_blank>ENTERTAINMENT<S2SV_blank>COST<S2SV_blank>or<S2SV_blank>back<S2SV_blank>to<S2SV_blank>main<S2SV_blank>menu<S2SV_blank>for<S2SV_blank>item<S2SV_blank>entry:" , name ) ; <S2SV_StartBug> gets ( usrin ) ; <S2SV_EndBug> if ( ! strcmp ( usrin , "ENTERTAINMENT<S2SV_blank>COST" ) ) { printf ( "Enter<S2SV_blank>amount<S2SV_blank>spent<S2SV_blank>on<S2SV_blank>entertainment<S2SV_blank>cost<S2SV_blank>this<S2SV_blank>week:<S2SV_blank>" ) ; scanf ( "%d" , & etmt_cost ) ; if ( ! value_check ( etmt_cost ) ) { etmt_cost_flag = 1 ; } } else if ( ! strcmp ( usrin , "back<S2SV_blank>to<S2SV_blank>main<S2SV_blank>menu" ) ) { if ( etmt_cost_flag ) { break ; } else { printf ( "You<S2SV_blank>have<S2SV_blank>not<S2SV_blank>entered<S2SV_blank>at<S2SV_blank>least<S2SV_blank>one<S2SV_blank>value<S2SV_blank>for<S2SV_blank>ENTERTAINMENT\\n" ) ; } } else { printf ( "Not<S2SV_blank>all<S2SV_blank>subcategories<S2SV_blank>filled<S2SV_blank>out\\n" ) ; } } printf ( "Thanks<S2SV_blank>for<S2SV_blank>adding<S2SV_blank>your<S2SV_blank>weekly<S2SV_blank>entertainment<S2SV_blank>costs.<S2SV_blank>Back<S2SV_blank>to<S2SV_blank>main<S2SV_blank>menu\\n" ) ; } else if ( ! strcmp ( usrin , "EXIT" ) ) { if ( groc_flag & etmt_flag ) { <S2SV_StartBug> printf ( "\\n\\nFRUIT/VEGETABLES<S2SV_blank>cost<S2SV_blank>%d\\nOTHERS<S2SV_blank>cost<S2SV_blank>%d\\nENTERTAINMENT<S2SV_blank>cost<S2SV_blank>%d\\n" , fruit_cost , groc_other_cost , etmt_cost ) ; <S2SV_EndBug> exit ( 1 ) ; } else { printf ( "Need<S2SV_blank>to<S2SV_blank>fill<S2SV_blank>out<S2SV_blank>weekly<S2SV_blank>GROCERIES/ENTERTAINMENT<S2SV_blank>cost<S2SV_blank>before<S2SV_blank>exiting\\n" ) ; printf ( "Hey<S2SV_blank>%s!<S2SV_blank>Choose<S2SV_blank>GROCERIES,<S2SV_blank>ENTERTAINMENT<S2SV_blank>or<S2SV_blank>EXIT<S2SV_blank>if<S2SV_blank>done:<S2SV_blank>" , name ) ; scanf ( "%s" , usrin ) ; } } else { printf ( "Hey<S2SV_blank>%s!<S2SV_blank>Choose<S2SV_blank>GROCERIES,<S2SV_blank>ENTERTAINMENT<S2SV_blank>or<S2SV_blank>EXIT<S2SV_blank>if<S2SV_blank>done:<S2SV_blank>" , name ) ; scanf ( "%s" , usrin ) ; } } } | <S2SV_ModStart> name ) ; fflush ( stdin ) ; <S2SV_ModStart> name ) ; fflush ( stdin ) ; <S2SV_ModStart> { printf ( "\\n\\nFRUIT/VEGETABLES<S2SV_blank>cost:<S2SV_blank>%d\\nOTHERS<S2SV_blank>cost:<S2SV_blank>%d\\nENTERTAINMENT<S2SV_blank>cost:<S2SV_blank>%d\\n" <S2SV_ModEnd> , fruit_cost , |
2,955 | CWE-000 void compile_EXTERNAL_decl ( expr id_list ) { list lp ; expr ident ; ID id ; if ( id_list == NULL ) { return ; } FOR_ITEMS_IN_LIST ( lp , id_list ) { ident = LIST_ITEM ( lp ) ; if ( ident == NULL ) { break ; } if ( EXPR_CODE ( ident ) != IDENT ) { fatal ( "compile_EXTERNAL_decl:not<S2SV_blank>ident" ) ; } if ( ( id = declare_ident ( EXPR_SYM ( ident ) , CL_VAR ) ) == NULL ) { continue ; } ID_CLASS ( id ) = CL_PROC ; if ( PROC_CLASS ( id ) == P_UNKNOWN ) { PROC_CLASS ( id ) = P_EXTERNAL ; if ( ID_TYPE ( id ) != NULL && ( ! IS_PROCEDURE_TYPE ( ID_TYPE ( id ) ) || IS_PROCEDURE_POINTER ( ID_TYPE ( id ) ) ) ) { ID_TYPE ( id ) = function_type ( ID_TYPE ( id ) ) ; } TYPE_SET_EXTERNAL ( id ) ; } else if ( PROC_CLASS ( id ) != P_EXTERNAL ) { error_at_node ( id_list , "invalid<S2SV_blank>external<S2SV_blank>declaration,<S2SV_blank>%s" , ID_NAME ( id ) ) ; continue ; } if ( ID_IS_DUMMY_ARG ( id ) ) { <S2SV_StartBug> ID_TYPE ( id ) = type_VOID ; <S2SV_EndBug> } if ( ! ( ID_IS_DUMMY_ARG ( id ) ) ) ID_STORAGE ( id ) = STG_EXT ; } } | <S2SV_ModStart> ) ) { if ( ID_TYPE ( id ) ) { if ( IS_PROCEDURE_TYPE ( ID_TYPE ( id ) ) ) { TYPE_BASIC_TYPE ( FUNCTION_TYPE_RETURN_TYPE ( ID_TYPE ( id ) ) ) = TYPE_GNUMERIC_ALL ; TYPE_SET_IMPLICIT ( ID_TYPE ( id ) ) ; } else { TYPE_BASIC_TYPE ( ID_TYPE ( id ) ) = TYPE_GNUMERIC_ALL ; TYPE_SET_IMPLICIT ( ID_TYPE ( id ) ) ; } } else { ID_TYPE ( id ) = wrap_type ( type_GNUMERIC_ALL ) ; TYPE_SET_IMPLICIT ( ID_TYPE ( id ) ) ; } <S2SV_ModEnd> } if ( |
2,956 | CWE-000 static void dma_pi_write ( struct pi_controller * pi ) { unsigned int longueur , i ; uint32_t dram_address ; uint32_t rom_address ; uint8_t * dram ; const uint8_t * rom ; if ( pi -> regs [ PI_CART_ADDR_REG ] < 0x10000000 ) { if ( pi -> regs [ PI_CART_ADDR_REG ] >= 0x08000000 && pi -> regs [ PI_CART_ADDR_REG ] < 0x08010000 ) { if ( pi -> use_flashram != 1 ) { dma_read_sram ( pi ) ; pi -> use_flashram = - 1 ; } else { dma_read_flashram ( pi ) ; } } else if ( pi -> regs [ PI_CART_ADDR_REG ] >= 0x06000000 && pi -> regs [ PI_CART_ADDR_REG ] < 0x08000000 ) { } else { DebugMessage ( M64MSG_WARNING , "Unknown<S2SV_blank>dma<S2SV_blank>write<S2SV_blank>0x%" PRIX32 "<S2SV_blank>in<S2SV_blank>dma_pi_write()" , pi -> regs [ PI_CART_ADDR_REG ] ) ; } pi -> regs [ PI_STATUS_REG ] |= PI_STATUS_DMA_BUSY ; cp0_update_count ( ) ; <S2SV_StartBug> add_interupt_event ( PI_INT , 0x1000 ) ; <S2SV_EndBug> return ; } if ( pi -> regs [ PI_CART_ADDR_REG ] >= 0x1fc00000 ) { pi -> regs [ PI_STATUS_REG ] |= PI_STATUS_DMA_BUSY ; cp0_update_count ( ) ; <S2SV_StartBug> add_interupt_event ( PI_INT , 0x1000 ) ; <S2SV_EndBug> return ; } longueur = ( pi -> regs [ PI_WR_LEN_REG ] & 0xFFFFFF ) + 1 ; i = ( pi -> regs [ PI_CART_ADDR_REG ] - 0x10000000 ) & 0x3FFFFFF ; longueur = ( i + longueur ) > pi -> cart_rom . rom_size ? ( pi -> cart_rom . rom_size - i ) : longueur ; longueur = ( pi -> regs [ PI_DRAM_ADDR_REG ] + longueur ) > 0x7FFFFF ? ( 0x7FFFFF - pi -> regs [ PI_DRAM_ADDR_REG ] ) : longueur ; if ( i > pi -> cart_rom . rom_size || pi -> regs [ PI_DRAM_ADDR_REG ] > 0x7FFFFF ) { pi -> regs [ PI_STATUS_REG ] |= PI_STATUS_DMA_BUSY | PI_STATUS_IO_BUSY ; cp0_update_count ( ) ; <S2SV_StartBug> add_interupt_event ( PI_INT , longueur / 8 ) ; <S2SV_EndBug> return ; } dram_address = pi -> regs [ PI_DRAM_ADDR_REG ] ; rom_address = ( pi -> regs [ PI_CART_ADDR_REG ] - 0x10000000 ) & 0x3ffffff ; dram = ( uint8_t * ) pi -> ri -> rdram . dram ; rom = pi -> cart_rom . rom ; for ( i = 0 ; i < longueur ; ++ i ) { dram [ ( dram_address + i ) ^ S8 ] = rom [ ( rom_address + i ) ^ S8 ] ; } <S2SV_StartBug> invalidate_r4300_cached_code ( 0x80000000 + dram_address , longueur ) ; <S2SV_EndBug> <S2SV_StartBug> invalidate_r4300_cached_code ( 0xa0000000 + dram_address , longueur ) ; <S2SV_EndBug> if ( pi -> regs [ PI_CART_ADDR_REG ] == 0x10001000 ) { force_detected_rdram_size_hack ( ) ; } pi -> regs [ PI_STATUS_REG ] |= PI_STATUS_DMA_BUSY | PI_STATUS_IO_BUSY ; cp0_update_count ( ) ; <S2SV_StartBug> add_interupt_event ( PI_INT , longueur / 8 ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( ) ; add_interrupt_event ( & pi -> r4300 -> cp0 , <S2SV_ModEnd> PI_INT , 0x1000 <S2SV_ModStart> ( ) ; add_interrupt_event ( & pi -> r4300 -> cp0 , <S2SV_ModEnd> PI_INT , 0x1000 <S2SV_ModStart> ( ) ; add_interrupt_event ( & pi -> r4300 -> cp0 , <S2SV_ModEnd> PI_INT , longueur <S2SV_ModStart> } invalidate_r4300_cached_code ( pi -> r4300 , <S2SV_ModStart> ; invalidate_r4300_cached_code ( pi -> r4300 , <S2SV_ModStart> ( ) ; add_interrupt_event ( & pi -> r4300 -> cp0 , <S2SV_ModEnd> PI_INT , longueur |
2,957 | CWE-000 static struct b6b_obj * b6b_socket_client_new ( struct b6b_interp * interp , const struct addrinfo * res , const struct b6b_strm_ops * ops , const char * type ) { struct sockaddr_storage ss = { . ss_family = res -> ai_socktype } ; <S2SV_StartBug> socklen_t sslen ; <S2SV_EndBug> struct b6b_obj * o ; int fd , err ; fd = socket ( res -> ai_family , res -> ai_socktype | SOCK_NONBLOCK | SOCK_CLOEXEC , res -> ai_protocol ) ; if ( fd < 0 ) { b6b_return_strerror ( interp , errno ) ; return NULL ; } if ( ( ( connect ( fd , res -> ai_addr , res -> ai_addrlen ) < 0 ) && ( errno != EINPROGRESS ) ) || ( getsockname ( fd , ( struct sockaddr * ) & ss , & sslen ) < 0 ) ) { err = errno ; close ( fd ) ; b6b_return_strerror ( interp , err ) ; return NULL ; } <S2SV_StartBug> o = b6b_socket_new ( interp , <S2SV_EndBug> fd , ( const struct sockaddr * ) & ss , sslen , res -> ai_addr , res -> ai_addrlen , type , ops ) ; <S2SV_StartBug> if ( b6b_unlikely ( ! o ) ) <S2SV_EndBug> close ( fd ) ; return o ; } | <S2SV_ModStart> ; socklen_t sslen = sizeof ( ss ) <S2SV_ModEnd> ; int fd <S2SV_ModStart> NULL ; } return <S2SV_ModEnd> b6b_socket_new ( interp <S2SV_ModStart> ops ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
2,958 | CWE-000 static int _spdk_blob_serialize ( const struct spdk_blob_data * blob , struct spdk_blob_md_page * * pages , uint32_t * page_count ) { struct spdk_blob_md_page * cur_page ; const struct spdk_xattr * xattr ; int rc ; uint8_t * buf ; size_t remaining_sz ; uint64_t last_cluster ; assert ( pages != NULL ) ; assert ( page_count != NULL ) ; assert ( blob != NULL ) ; assert ( blob -> state == SPDK_BLOB_STATE_SYNCING ) ; * pages = NULL ; * page_count = 0 ; rc = _spdk_blob_serialize_add_page ( blob , pages , page_count , & cur_page ) ; if ( rc < 0 ) { return rc ; } buf = ( uint8_t * ) cur_page -> descriptors ; remaining_sz = sizeof ( cur_page -> descriptors ) ; _spdk_blob_serialize_flags ( blob , buf , & remaining_sz ) ; <S2SV_StartBug> TAILQ_FOREACH ( xattr , & blob -> xattrs , link ) { <S2SV_EndBug> size_t required_sz = 0 ; rc = _spdk_blob_serialize_xattr ( xattr , buf , remaining_sz , & required_sz ) ; if ( rc < 0 ) { rc = _spdk_blob_serialize_add_page ( blob , pages , page_count , & cur_page ) ; if ( rc < 0 ) { spdk_dma_free ( * pages ) ; * pages = NULL ; * page_count = 0 ; return rc ; } buf = ( uint8_t * ) cur_page -> descriptors ; remaining_sz = sizeof ( cur_page -> descriptors ) ; required_sz = 0 ; rc = _spdk_blob_serialize_xattr ( xattr , buf , remaining_sz , & required_sz ) ; if ( rc < 0 ) { spdk_dma_free ( * pages ) ; * pages = NULL ; * page_count = 0 ; return - 1 ; } } remaining_sz -= required_sz ; buf += required_sz ; } last_cluster = 0 ; while ( last_cluster < blob -> active . num_clusters ) { _spdk_blob_serialize_extent ( blob , last_cluster , & last_cluster , buf , remaining_sz ) ; if ( last_cluster == blob -> active . num_clusters ) { break ; } rc = _spdk_blob_serialize_add_page ( blob , pages , page_count , & cur_page ) ; if ( rc < 0 ) { return rc ; } buf = ( uint8_t * ) cur_page -> descriptors ; remaining_sz = sizeof ( cur_page -> descriptors ) ; } return 0 ; } | <S2SV_ModStart> remaining_sz ) ; buf += sizeof ( struct spdk_blob_md_descriptor_flags ) ; |
2,959 | CWE-000 static int fastrpc_device_open ( struct inode * inode , struct file * filp ) { int cid = MINOR ( inode -> i_rdev ) ; int err = 0 , session ; int event ; struct fastrpc_apps * me = & gfa ; struct fastrpc_file * fl = 0 ; if ( me -> pending_free ) { event = wait_event_interruptible_timeout ( wait_queue , me -> pending_free , RPC_TIMEOUT ) ; if ( event == 0 ) pr_err ( "timed<S2SV_blank>out..list<S2SV_blank>is<S2SV_blank>still<S2SV_blank>not<S2SV_blank>empty\\n" ) ; } VERIFY ( err , fl = kzalloc ( sizeof ( * fl ) , GFP_KERNEL ) ) ; if ( err ) return err ; filp -> private_data = fl ; mutex_lock ( & me -> smd_mutex ) ; context_list_ctor ( & fl -> clst ) ; spin_lock_init ( & fl -> hlock ) ; INIT_HLIST_HEAD ( & fl -> maps ) ; INIT_HLIST_HEAD ( & fl -> bufs ) ; INIT_HLIST_NODE ( & fl -> hn ) ; fl -> tgid = current -> tgid ; fl -> apps = me ; fl -> cid = cid ; VERIFY ( err , ! fastrpc_session_alloc ( & me -> channel [ cid ] , & session ) ) ; if ( err ) goto bail ; fl -> sctx = & me -> channel [ cid ] . session [ session ] ; fl -> ssrcount = me -> channel [ cid ] . ssrcount ; if ( ( kref_get_unless_zero ( & me -> channel [ cid ] . kref ) == 0 ) || ( me -> channel [ cid ] . chan == 0 ) ) { if ( me -> glink ) { VERIFY ( err , 0 == fastrpc_glink_open ( cid , me ) ) ; } else { VERIFY ( err , ! smd_named_open_on_edge ( FASTRPC_SMD_GUID , gcinfo [ cid ] . channel , ( smd_channel_t * * ) & me -> channel [ cid ] . chan , ( void * ) ( uintptr_t ) cid , smd_event_handler ) ) ; } if ( err ) goto bail ; VERIFY ( err , wait_for_completion_timeout ( & me -> channel [ cid ] . work , RPC_TIMEOUT ) ) ; if ( err ) { me -> channel [ cid ] . chan = 0 ; goto bail ; } kref_init ( & me -> channel [ cid ] . kref ) ; pr_info ( "\'opened<S2SV_blank>/dev/%s<S2SV_blank>c<S2SV_blank>%d<S2SV_blank>%d\'\\n" , gcinfo [ cid ] . name , MAJOR ( me -> dev_no ) , cid ) ; if ( me -> channel [ cid ] . ssrcount != me -> channel [ cid ] . prevssrcount ) { if ( fastrpc_mmap_remove_ssr ( fl ) ) pr_err ( "ADSPRPC:<S2SV_blank>SSR:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>unmap<S2SV_blank>remote<S2SV_blank>heap\\n" ) ; me -> channel [ cid ] . prevssrcount = me -> channel [ cid ] . ssrcount ; } } <S2SV_StartBug> spin_lock ( & me -> hlock ) ; <S2SV_EndBug> hlist_add_head ( & fl -> hn , & me -> drivers ) ; spin_unlock ( & me -> hlock ) ; bail : mutex_unlock ( & me -> smd_mutex ) ; if ( err && fl ) fastrpc_device_release ( inode , filp ) ; return err ; } | <S2SV_ModStart> ; } } mutex_init ( & fl -> map_mutex ) ; |
2,960 | CWE-000 void USART2_Handler ( void ) { uint32_t uc_char ; uint16_t tmphead ; uint16_t tmptail ; uint32_t ul_status ; ul_status = usart_get_status ( USART2 ) ; if ( ul_status & ( UART_IER_TXRDY | UART_IER_TXEMPTY ) ) { if ( UART_buffer_pointers [ USART2_buffer ] [ UART_TxHead ] != UART_buffer_pointers [ USART2_buffer ] [ UART_TxTail ] ) { tmptail = ( UART_buffer_pointers [ USART2_buffer ] [ UART_TxTail ] + 1 ) & 0xFF ; usart_write ( USART2 , UART_TxBuf [ USART2_buffer ] [ tmptail ] ) ; UART_buffer_pointers [ USART2_buffer ] [ UART_TxTail ] = tmptail ; } else { usart_disable_interrupt ( USART2 , ( UART_IER_TXRDY | UART_IER_TXEMPTY ) ) ; usart_disable_tx ( USART2 ) ; } } if ( ul_status & US_CSR_RXRDY ) { tmphead = ( UART_buffer_pointers [ USART2_buffer ] [ UART_RxHead ] + 1 ) & 0xFF ; if ( tmphead != UART_buffer_pointers [ USART2_buffer ] [ UART_RxTail ] ) { <S2SV_StartBug> uint32_t status = usart_read ( USART2 , & uc_char ) ; <S2SV_EndBug> UART_RxBuf [ USART2_buffer ] [ tmphead ] = uc_char ; UART_buffer_pointers [ USART2_buffer ] [ UART_RxHead ] = tmphead ; } } } | <S2SV_ModStart> ] ) { <S2SV_ModEnd> usart_read ( USART2 |
2,961 | CWE-000 void warp_real_mouse_y ( Uint32 my ) { struct buffered_status * status = store_status ( ) ; int mx_real , my_real , y = my / 14 ; status -> mouse_y = y ; status -> real_mouse_y = my ; set_screen_coords ( status -> real_mouse_x , my , & mx_real , & my_real ) ; <S2SV_StartBug> real_warp_mouse ( mx_real , my_real ) ; <S2SV_EndBug> } | <S2SV_ModStart> ; real_warp_mouse ( - 1 <S2SV_ModEnd> , my_real ) |
2,962 | CWE-000 static void <S2SV_StartBug> argument_kw_error ( rb_thread_t * th , const rb_iseq_t * iseq , const char * error , const VALUE keys ) <S2SV_EndBug> { <S2SV_StartBug> raise_argument_error ( th , iseq , rb_keyword_error_new ( error , keys ) ) ; <S2SV_EndBug> } | <S2SV_ModStart> void argument_kw_error ( rb_execution_context_t * ec <S2SV_ModEnd> , const rb_iseq_t <S2SV_ModStart> { raise_argument_error ( ec <S2SV_ModEnd> , iseq , |
2,963 | CWE-000 void inapp_second_downpass <S2SV_StartBug> ( int * dat , int * app , int * act , int * parent , int * child , <S2SV_EndBug> int * n_edge , int * n_char , int * end_char , int * inapp , int * pars ) { int i , parent_i = 0 ; for ( i = 0 ; i < * n_edge ; i += 2 ) { parent_i = parent [ i ] ; <S2SV_StartBug> Rprintf ( "<S2SV_blank>-<S2SV_blank>Calling<S2SV_blank>second<S2SV_blank>downnode<S2SV_blank>at<S2SV_blank>%i:\\n" , parent_i - 1 ) ; <S2SV_EndBug> inapp_second_downnode ( & dat [ ( parent_i - 1 ) * ( * n_char ) ] , <S2SV_StartBug> & app [ ( parent_i - 1 ) * ( * n_char ) ] , <S2SV_EndBug> & dat [ ( child [ i + 1 ] - 1 ) * ( * n_char ) ] , & dat [ ( child [ i ] - 1 ) * ( * n_char ) ] , & act [ ( parent_i - 1 ) * ( * n_char ) ] , & act [ ( child [ i + 1 ] - 1 ) * ( * n_char ) ] , & act [ ( child [ i ] - 1 ) * ( * n_char ) ] , end_char , inapp , pars ) ; } inapp_second_root ( & dat [ ( parent_i - 1 ) * ( * n_char ) ] , <S2SV_StartBug> & app [ ( parent_i - 1 ) * ( * n_char ) ] , inapp , end_char ) ; <S2SV_EndBug> } | <S2SV_ModStart> , int * upp1 <S2SV_ModEnd> , int * <S2SV_ModStart> ; Rprintf ( "[NODE<S2SV_blank>%i]<S2SV_blank>2nd<S2SV_blank>down:" <S2SV_ModEnd> , parent_i - <S2SV_ModStart> ] , & upp1 <S2SV_ModEnd> [ ( parent_i <S2SV_ModStart> ] , & upp1 <S2SV_ModEnd> [ ( parent_i |
2,964 | CWE-000 int gvm_migrate_secinfo ( int feed_type ) { int lockfile , ret ; gchar * lockfile_name ; const gchar * lockfile_basename ; if ( feed_type == SCAP_FEED ) lockfile_basename = "gvm-sync-scap" ; else if ( feed_type == CERT_FEED ) lockfile_basename = "gvm-sync-cert" ; else { g_warning ( "%s:<S2SV_blank>unsupported<S2SV_blank>feed_type" , __FUNCTION__ ) ; return - 1 ; } lockfile_name = g_build_filename ( g_get_tmp_dir ( ) , lockfile_basename , NULL ) ; lockfile = open ( lockfile_name , O_RDWR | O_CREAT | O_APPEND , S_IWUSR | S_IRUSR | S_IROTH | S_IRGRP ) ; if ( lockfile == - 1 ) { g_warning ( "Failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>lock<S2SV_blank>file<S2SV_blank>\'%s\':<S2SV_blank>%s" , lockfile_name , strerror ( errno ) ) ; g_free ( lockfile_name ) ; return - 1 ; } if ( flock ( lockfile , LOCK_EX | LOCK_NB ) ) { if ( errno == EWOULDBLOCK ) { g_free ( lockfile_name ) ; return 1 ; } g_debug ( "%s:<S2SV_blank>flock:<S2SV_blank>%s" , __FUNCTION__ , strerror ( errno ) ) ; g_free ( lockfile_name ) ; return - 1 ; } if ( feed_type == SCAP_FEED ) ret = check_scap_db_version ( ) ; else ret = check_cert_db_version ( ) ; if ( close ( lockfile ) ) { g_free ( lockfile_name ) ; g_warning ( "Failed<S2SV_blank>to<S2SV_blank>close<S2SV_blank>lock<S2SV_blank>file:<S2SV_blank>%s" , strerror ( errno ) ) ; return - 1 ; } <S2SV_StartBug> if ( unlink ( lockfile_name ) ) <S2SV_EndBug> { g_free ( lockfile_name ) ; g_warning ( "Failed<S2SV_blank>to<S2SV_blank>remove<S2SV_blank>lock<S2SV_blank>file:<S2SV_blank>%s" , strerror ( errno ) ) ; return - 1 ; } g_free ( lockfile_name ) ; return ret ; } | <S2SV_ModStart> 1 ; } <S2SV_ModEnd> g_free ( lockfile_name |
2,965 | CWE-000 <S2SV_StartBug> ATF_TC_CLEANUP ( ktrace_success , tc ) <S2SV_EndBug> { cleanup ( ) ; } | <S2SV_ModStart> <S2SV_null> ATF_TC_CLEANUP ( ptrace_failure <S2SV_ModEnd> , tc ) |
2,966 | CWE-000 static int _sdmmc_config_tuning_once ( sdmmc_t * sdmmc , u32 cmd ) { if ( sdmmc -> no_sd ) return 0 ; if ( ! _sdmmc_wait_prnsts_type0 ( sdmmc , 1 ) ) return 0 ; _sdmmc_setup_read_small_block ( sdmmc ) ; sdmmc -> regs -> norintstsen |= TEGRA_MMC_NORINTSTSEN_BUFFER_READ_READY ; sdmmc -> regs -> norintsts = sdmmc -> regs -> norintsts ; sdmmc -> regs -> clkcon &= ~ TEGRA_MMC_CLKCON_SD_CLOCK_ENABLE ; _sdmmc_parse_cmd_48 ( sdmmc , cmd ) ; _sdmmc_get_clkcon ( sdmmc ) ; sleep ( 1 ) ; _sdmmc_reset ( sdmmc ) ; sdmmc -> regs -> clkcon |= TEGRA_MMC_CLKCON_SD_CLOCK_ENABLE ; _sdmmc_get_clkcon ( sdmmc ) ; <S2SV_StartBug> u32 timeout = get_tmr ( ) + 5000 ; <S2SV_EndBug> <S2SV_StartBug> while ( get_tmr ( ) < timeout ) <S2SV_EndBug> { if ( sdmmc -> regs -> norintsts & 0x20 ) { sdmmc -> regs -> norintsts = 0x20 ; sdmmc -> regs -> norintstsen &= 0xFFDF ; _sdmmc_get_clkcon ( sdmmc ) ; sleep ( ( 1000 * 8 + sdmmc -> divisor - 1 ) / sdmmc -> divisor ) ; return 1 ; } } _sdmmc_reset ( sdmmc ) ; sdmmc -> regs -> norintstsen &= 0xFFDF ; _sdmmc_get_clkcon ( sdmmc ) ; sleep ( ( 1000 * 8 + sdmmc -> divisor - 1 ) / sdmmc -> divisor ) ; return 0 ; } | <S2SV_ModStart> u32 timeout = get_tmr_us <S2SV_ModEnd> ( ) + <S2SV_ModStart> ; while ( get_tmr_us <S2SV_ModEnd> ( ) < |
2,967 | CWE-000 ops_arg ops_arg_dat_opt ( ops_dat dat , int dim , ops_stencil stencil , char const * type , ops_access acc , int flag ) { ops_arg temp = ops_arg_dat_core ( dat , stencil , acc ) ; ( & temp ) -> dim = dim ; <S2SV_StartBug> ( & temp ) -> opt = flag ; <S2SV_EndBug> return temp ; } | <S2SV_ModStart> -> opt = ! ( flag == 0 ) <S2SV_ModEnd> ; return temp |
2,968 | CWE-000 static int cpu_getCoreNum ( void ) { struct dirent * direntry ; DIR * dirp = opendir ( "/dev" ) ; int r = 0 ; int high = 0 ; if ( dirp == NULL ) { r = - 1 ; <S2SV_StartBug> } else { <S2SV_EndBug> while ( ( direntry = readdir ( dirp ) ) != NULL ) { if ( direntry -> d_namlen == 0 ) continue ; if ( ! strncmp ( direntry -> d_name , "cpuctl" , 6 ) ) { int x = atoi ( direntry -> d_name + 6 ) ; if ( x > high ) high = x ; } } r = closedir ( dirp ) ; } r = ( r ) ? - 1 : ++ high ; return r ; } | <S2SV_ModStart> } else { modload ( "cpuctl" ) ; |
2,969 | CWE-000 int main ( int argc , char * argv [ ] ) { srand ( time ( 0 ) ) ; uint64_t start , end ; uint64_t time_pthreads , time_openmp , time_single_thread ; Matrix_t A = genmatrix ( 100 , 100 ) ; Matrix_t B = genmatrix ( 100 , 100 ) ; size_t * tt = matrix_sparsity ( A ) ; <S2SV_StartBug> for ( int sample = 0 ; sample < 10 ; sample ++ ) <S2SV_EndBug> { time_single_thread = 0 ; for ( int i = 0 ; i < NUM_EXEC ; i ++ ) { start = get_time ( ) ; matrix_mult ( A , B ) ; end = get_time ( ) ; time_single_thread += ( end - start ) ; } time_pthreads = 0 ; for ( int i = 0 ; i < NUM_EXEC ; i ++ ) { start = get_time ( ) ; <S2SV_StartBug> matrix_mult_pthread ( A , B , tt ) ; <S2SV_EndBug> end = get_time ( ) ; time_pthreads += ( end - start ) ; } time_openmp = 0 ; for ( int i = 0 ; i < NUM_EXEC ; i ++ ) { start = get_time ( ) ; matrix_mult_openmp ( A , B , NUM_THREADS , CHUNKS ) ; end = get_time ( ) ; time_openmp += ( end - start ) ; } printf ( "Avg<S2SV_blank>single<S2SV_blank>thread:<S2SV_blank>%d\\n" , time_single_thread / NUM_EXEC ) ; printf ( "Avg<S2SV_blank>pthreads.....:<S2SV_blank>%d\\n" , time_pthreads / NUM_EXEC ) ; printf ( "Avg<S2SV_blank>openmp.......:<S2SV_blank>%d\\n\\n" , time_openmp / NUM_EXEC ) ; } } | <S2SV_ModStart> A ) ; size_t size_of_sp = matrix_size_of_sparsity ( tt , A . rows ) ; <S2SV_ModStart> B , tt , size_of_sp |
2,970 | CWE-000 int main ( ) { const struct CMUnitTest tests [ ] = { cmocka_unit_test ( md_test_init_and_destroy ) , cmocka_unit_test ( md_test_insert_module ) , <S2SV_StartBug> cmocka_unit_test ( md_test_insert_module_2 ) , <S2SV_EndBug> cmocka_unit_test ( md_test_insert_module_5 ) , cmocka_unit_test ( md_test_remove_modules ) , cmocka_unit_test ( md_test_grouping_and_uses ) , cmocka_unit_test ( md_test_has_data ) , } ; watchdog_start ( 300 ) ; int ret = cmocka_run_group_tests ( tests , md_tests_setup , md_tests_teardown ) ; watchdog_stop ( ) ; return ret ; } | <S2SV_ModStart> cmocka_unit_test ( md_test_insert_module_2 ) , cmocka_unit_test ( md_test_insert_module_4 |
2,971 | CWE-000 int TclFileAttrsCmd ( Tcl_Interp * interp , int objc , Tcl_Obj * CONST objv [ ] ) { int result ; CONST char * * attributeStrings ; Tcl_Obj * objStrings = NULL ; int numObjStrings = - 1 , didAlloc = 0 ; Tcl_Obj * filePtr ; if ( objc < 3 ) { Tcl_WrongNumArgs ( interp , 2 , objv , "name<S2SV_blank>?option?<S2SV_blank>?value?<S2SV_blank>?option<S2SV_blank>value<S2SV_blank>...?" ) ; return TCL_ERROR ; } filePtr = objv [ 2 ] ; if ( Tcl_FSConvertToPathType ( interp , filePtr ) != TCL_OK ) { return TCL_ERROR ; } objc -= 3 ; objv += 3 ; result = TCL_ERROR ; Tcl_SetErrno ( 0 ) ; attributeStrings = Tcl_FSFileAttrStrings ( filePtr , & objStrings ) ; if ( attributeStrings == NULL ) { int index ; Tcl_Obj * objPtr ; if ( objStrings == NULL ) { if ( Tcl_GetErrno ( ) != 0 ) { Tcl_AppendResult ( interp , "could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>\\"" , TclGetString ( filePtr ) , "\\":<S2SV_blank>" , Tcl_PosixError ( interp ) , NULL ) ; } return TCL_ERROR ; } Tcl_IncrRefCount ( objStrings ) ; if ( Tcl_ListObjLength ( interp , objStrings , & numObjStrings ) != TCL_OK ) { goto end ; } attributeStrings = ( CONST char * * ) TclStackAlloc ( interp , ( 1 + numObjStrings ) * sizeof ( char * ) ) ; didAlloc = 1 ; for ( index = 0 ; index < numObjStrings ; index ++ ) { Tcl_ListObjIndex ( interp , objStrings , index , & objPtr ) ; attributeStrings [ index ] = TclGetString ( objPtr ) ; } attributeStrings [ index ] = NULL ; } else if ( objStrings != NULL ) { Tcl_Panic ( "must<S2SV_blank>not<S2SV_blank>update<S2SV_blank>objPtrRef\'s<S2SV_blank>variable<S2SV_blank>and<S2SV_blank>return<S2SV_blank>non-NULL" ) ; } if ( objc == 0 ) { int index , res = TCL_OK , nbAtts = 0 ; Tcl_Obj * listPtr ; listPtr = Tcl_NewListObj ( 0 , NULL ) ; for ( index = 0 ; attributeStrings [ index ] != NULL ; index ++ ) { Tcl_Obj * objPtrAttr ; if ( res != TCL_OK ) { Tcl_ResetResult ( interp ) ; } res = Tcl_FSFileAttrsGet ( interp , index , filePtr , & objPtrAttr ) ; if ( res == TCL_OK ) { Tcl_Obj * objPtr = Tcl_NewStringObj ( attributeStrings [ index ] , - 1 ) ; Tcl_ListObjAppendElement ( interp , listPtr , objPtr ) ; Tcl_ListObjAppendElement ( interp , listPtr , objPtrAttr ) ; nbAtts ++ ; } } if ( index > 0 && nbAtts == 0 ) { Tcl_DecrRefCount ( listPtr ) ; goto end ; } Tcl_SetObjResult ( interp , listPtr ) ; } else if ( objc == 1 ) { int index ; Tcl_Obj * objPtr = NULL ; if ( numObjStrings == 0 ) { Tcl_AppendResult ( interp , "bad<S2SV_blank>option<S2SV_blank>\\"" , TclGetString ( objv [ 0 ] ) , "\\",<S2SV_blank>there<S2SV_blank>are<S2SV_blank>no<S2SV_blank>file<S2SV_blank>attributes<S2SV_blank>in<S2SV_blank>this<S2SV_blank>filesystem." , NULL ) ; goto end ; } if ( Tcl_GetIndexFromObj ( interp , objv [ 0 ] , attributeStrings , "option" , 0 , & index ) != TCL_OK ) { goto end ; } if ( didAlloc ) { TclFreeIntRep ( objv [ 0 ] ) ; <S2SV_StartBug> } <S2SV_EndBug> if ( Tcl_FSFileAttrsGet ( interp , index , filePtr , & objPtr ) != TCL_OK ) { goto end ; } Tcl_SetObjResult ( interp , objPtr ) ; } else { int i , index ; if ( numObjStrings == 0 ) { Tcl_AppendResult ( interp , "bad<S2SV_blank>option<S2SV_blank>\\"" , TclGetString ( objv [ 0 ] ) , "\\",<S2SV_blank>there<S2SV_blank>are<S2SV_blank>no<S2SV_blank>file<S2SV_blank>attributes<S2SV_blank>in<S2SV_blank>this<S2SV_blank>filesystem." , NULL ) ; goto end ; } for ( i = 0 ; i < objc ; i += 2 ) { if ( Tcl_GetIndexFromObj ( interp , objv [ i ] , attributeStrings , "option" , 0 , & index ) != TCL_OK ) { goto end ; } if ( didAlloc ) { <S2SV_StartBug> TclFreeIntRep ( objv [ i ] ) ; <S2SV_EndBug> } if ( i + 1 == objc ) { Tcl_AppendResult ( interp , "value<S2SV_blank>for<S2SV_blank>\\"" , TclGetString ( objv [ i ] ) , "\\"<S2SV_blank>missing" , NULL ) ; goto end ; } if ( Tcl_FSFileAttrsSet ( interp , index , filePtr , objv [ i + 1 ] ) != TCL_OK ) { goto end ; } } } result = TCL_OK ; end : if ( didAlloc ) { TclStackFree ( interp , ( void * ) attributeStrings ) ; } if ( objStrings != NULL ) { Tcl_DecrRefCount ( objStrings ) ; } return result ; } | <S2SV_ModStart> ] ) ; objv [ 0 ] -> typePtr = NULL ; <S2SV_ModStart> i ] ) ; objv [ i ] -> typePtr = NULL |
2,972 | CWE-000 test_f test_bits_operations ( void ) { <S2SV_StartBug> int a ; <S2SV_EndBug> <S2SV_StartBug> long long b ; <S2SV_EndBug> a = BIT ( 5 ) ; b = BIT ( 50 ) ; T_ASSERT ( a , 1 << 5 ) ; T_ASSERT ( b , 1ull << 50 ) ; SET_BIT ( a , 3 ) ; SET_BIT ( a , 3 ) ; SET_BIT ( b , 54 ) ; SET_BIT ( b , 54 ) ; T_ASSERT ( a , 1 << 5 | 1 << 3 ) ; <S2SV_StartBug> T_ASSERT ( b , ( long long ) ( 1ull << 50 | 1ull << 54 ) ) ; <S2SV_EndBug> T_EXPECT ( GET_BIT ( a , 3 ) , 1 ) ; T_EXPECT ( GET_BIT ( a , 4 ) , 0 ) ; T_EXPECT ( GET_BIT ( b , 54 ) , 1 ) ; T_EXPECT ( GET_BIT ( b , 60 ) , 0 ) ; CLEAR_BIT ( a , 3 ) ; CLEAR_BIT ( a , 10 ) ; CLEAR_BIT ( b , 50 ) ; CLEAR_BIT ( b , 11 ) ; T_ASSERT ( a , 1 << 5 ) ; T_ASSERT ( b , 1ull << 54 ) ; a = 0x1010 ; SET_BIT_VALUE ( a , 2 , 1 ) ; T_ASSERT ( a , 0x1014 ) ; SET_BIT_VALUE ( a , 4 , 0 ) ; T_ASSERT ( a , 0x1004 ) ; a = 0x1010 ; FLIP_BIT ( a , 0 ) ; FLIP_BIT ( a , 4 ) ; T_ASSERT ( a , 0x1001 ) ; } | <S2SV_ModStart> void ) { unsigned <S2SV_ModStart> int a ; unsigned <S2SV_ModStart> b , ( unsigned |
2,973 | CWE-000 static void decode_phase ( struct Flex * flex , char PhaseNo ) { if ( flex == NULL ) return ; uint32_t * phaseptr = NULL ; int i , j ; switch ( PhaseNo ) { case 'A' : phaseptr = flex -> Data . PhaseA . buf ; break ; case 'B' : phaseptr = flex -> Data . PhaseB . buf ; break ; case 'C' : phaseptr = flex -> Data . PhaseC . buf ; break ; case 'D' : phaseptr = flex -> Data . PhaseD . buf ; break ; } for ( i = 0 ; i < 88 ; i ++ ) { int decode_error = bch3121_fix_errors ( flex , & phaseptr [ i ] , PhaseNo ) ; if ( decode_error ) { verbprintf ( 3 , "FLEX:<S2SV_blank>Garbled<S2SV_blank>message<S2SV_blank>at<S2SV_blank>block<S2SV_blank>%i\\n" , i ) ; return ; } phaseptr [ i ] &= 0x001FFFFF ; } uint32_t biw = phaseptr [ 0 ] ; if ( biw == 0 || biw == 0x001FFFFF ) { verbprintf ( 3 , "FLEX:<S2SV_blank>Nothing<S2SV_blank>to<S2SV_blank>see<S2SV_blank>here,<S2SV_blank>please<S2SV_blank>move<S2SV_blank>along\\n" ) ; return ; } int voffset = ( biw >> 10 ) & 0x3f ; int aoffset = ( ( biw >> 8 ) & 0x03 ) + 1 ; verbprintf ( 3 , "FLEX:<S2SV_blank>BlockInfoWord:<S2SV_blank>(Phase<S2SV_blank>%c)<S2SV_blank>BIW:%08X<S2SV_blank>AW:%02i-%02i<S2SV_blank>(%i<S2SV_blank>pages)\\n" , PhaseNo , biw , aoffset , voffset , voffset - aoffset ) ; int flex_groupmessage = 0 ; for ( i = aoffset ; i < voffset ; i ++ ) { j = voffset + i - aoffset ; if ( phaseptr [ i ] == 0x00000000 || phaseptr [ i ] == 0x001FFFFF ) { verbprintf ( 3 , "FLEX:<S2SV_blank>Idle<S2SV_blank>codewords,<S2SV_blank>invalid<S2SV_blank>address\\n" ) ; continue ; } parse_capcode ( flex , phaseptr [ i ] ) ; if ( flex -> Decode . long_address ) i ++ ; if ( ( flex -> Decode . capcode >= 2029568 ) && ( flex -> Decode . capcode <= 2029583 ) ) { flex_groupmessage = 1 ; } if ( flex -> Decode . capcode > 4297068542ll || flex -> Decode . capcode < 0 ) { verbprintf ( 3 , "FLEX:<S2SV_blank>Invalid<S2SV_blank>address\\n" ) ; continue ; } verbprintf ( 3 , "FLEX:<S2SV_blank>CAPCODE:%016lx\\n" , flex -> Decode . capcode ) ; uint32_t viw = phaseptr [ j ] ; flex -> Decode . type = ( ( viw >> 4 ) & 0x00000007 ) ; int mw1 = ( viw >> 7 ) & 0x00000007F ; int len = ( viw >> 14 ) & 0x0000007F ; int mw2 = mw1 + ( len - 1 ) ; <S2SV_StartBug> if ( is_numeric_page ( flex ) ) <S2SV_EndBug> mw2 ++ ; if ( mw1 == 0 && mw2 == 0 ) { verbprintf ( 3 , "FLEX:<S2SV_blank>Invalid<S2SV_blank>VIW\\n" ) ; continue ; } if ( is_tone_page ( flex ) ) mw1 = mw2 = 0 ; if ( mw1 > 87 || mw2 > 87 ) { verbprintf ( 3 , "FLEX:<S2SV_blank>Invalid<S2SV_blank>Offsets\\n" ) ; continue ; } if ( flex -> Decode . type == FLEX_PAGETYPE_SHORT_INSTRUCTION ) { int iAssignedFrame = ( int ) ( ( viw >> 10 ) & 0x7f ) ; int groupbit = ( int ) ( ( viw >> 17 ) & 0x7f ) ; flex -> GroupHandler . aGroupCodes [ groupbit ] [ CAPCODES_INDEX ] ++ ; flex -> GroupHandler . aGroupCodes [ groupbit ] [ flex -> GroupHandler . aGroupCodes [ groupbit ] [ CAPCODES_INDEX ] ] = flex -> Decode . capcode ; flex -> GroupHandler . GroupFrame [ groupbit ] = iAssignedFrame ; continue ; } if ( is_alphanumeric_page ( flex ) ) parse_alphanumeric ( flex , phaseptr , PhaseNo , mw1 , mw2 , flex_groupmessage ) ; else if ( is_numeric_page ( flex ) ) <S2SV_StartBug> parse_numeric ( flex , phaseptr , PhaseNo , mw1 , mw2 , j ) ; <S2SV_EndBug> else if ( is_tone_page ( flex ) ) parse_tone_only ( flex , PhaseNo ) ; else parse_unknown ( flex , phaseptr , PhaseNo , mw1 , mw2 ) ; } } | <S2SV_ModStart> ; if ( <S2SV_ModEnd> mw1 == 0 <S2SV_ModStart> , PhaseNo , j ) ; else if ( is_tone_page ( flex ) ) parse_tone_only ( flex , PhaseNo ) ; else parse_unknown ( flex , phaseptr , PhaseNo , <S2SV_ModStart> mw1 , mw2 <S2SV_ModEnd> ) ; } |
2,974 | CWE-000 GRAPH * decodeMultiCode ( unsigned short * code , GRAPH_INPUT_OPTIONS * options ) { int i , j , currentVertex , vertexCount , maxn , maxval ; vertexCount = code [ 0 ] ; if ( options -> maxn > 0 ) { maxn = options -> maxn ; } else if ( options -> maxnFactor > 0 ) { maxn = vertexCount * options -> maxnFactor ; } else { maxn = vertexCount + options -> maxnOffset ; } int degrees [ vertexCount ] ; for ( i = 0 ; i < vertexCount ; i ++ ) { degrees [ i ] = 0 ; } maxval = j = 0 ; i = 1 ; currentVertex = 0 ; <S2SV_StartBug> while ( currentVertex < vertexCount ) { <S2SV_EndBug> if ( code [ i ] == 0 ) { if ( degrees [ currentVertex ] > maxval ) maxval = degrees [ currentVertex ] ; currentVertex ++ ; } else { degrees [ currentVertex ] ++ ; degrees [ code [ i ] - 1 ] ++ ; } i ++ ; } <S2SV_StartBug> if ( options -> maxval > 0 ) { <S2SV_EndBug> maxval = options -> maxval ; } else if ( options -> maxvalFactor > 0 ) { maxval *= options -> maxvalFactor ; } else { maxval += options -> maxvalOffset ; } GRAPH * graph = newGraph ( maxn , maxval ) ; prepareGraph ( graph , vertexCount ) ; i = 1 ; currentVertex = 0 ; <S2SV_StartBug> while ( currentVertex < vertexCount ) { <S2SV_EndBug> if ( code [ i ] == 0 ) { currentVertex ++ ; } else { addEdge ( graph , currentVertex , code [ i ] - 1 ) ; } i ++ ; } return graph ; } | <S2SV_ModStart> currentVertex < vertexCount - 1 <S2SV_ModStart> } if ( degrees [ currentVertex ] > maxval ) maxval = degrees [ currentVertex ] ; if ( <S2SV_ModStart> currentVertex < vertexCount - 1 |
2,975 | CWE-000 int main ( int argc , char * * argv ) { Result ret = 0 ; u32 pos ; Handle kproc_handledup = 0 ; gfxInitDefault ( ) ; consoleInit ( GFX_BOTTOM , NULL ) ; printf ( "hblauncher_loader<S2SV_blank>%s<S2SV_blank>by<S2SV_blank>yellows8.\\n" , VERSION ) ; ret = svcDuplicateHandle ( & kproc_handledup , 0xffff8001 ) ; if ( ret != 0 ) printf ( "svcDuplicateHandle()<S2SV_blank>with<S2SV_blank>the<S2SV_blank>current<S2SV_blank>proc-handle<S2SV_blank>failed:<S2SV_blank>0x%08x.\\n" , ( unsigned int ) ret ) ; if ( ret == 0 ) { for ( pos = 0 ; pos < PAYLOAD_TEXTMAXSIZE ; pos += 0x1000 ) { ret = svcControlProcessMemory ( kproc_handledup , ( u32 ) & PAYLOAD_TEXTADDR [ pos >> 2 ] , 0x0 , 0x1000 , MEMOP_PROT , MEMPERM_READ | MEMPERM_WRITE | MEMPERM_EXECUTE ) ; if ( ret != 0 ) { printf ( "svcControlProcessMemory<S2SV_blank>with<S2SV_blank>pos=0x%x<S2SV_blank>failed:<S2SV_blank>0x%08x.\\n" , ( unsigned int ) pos , ( unsigned int ) ret ) ; break ; } } } <S2SV_StartBug> ret = httpcInit ( 0 ) ; <S2SV_EndBug> if ( ret != 0 ) { printf ( "Failed<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>HTTPC:<S2SV_blank>0x%08x.\\n" , ( unsigned int ) ret ) ; if ( ret == 0xd8e06406 ) { printf ( "The<S2SV_blank>HTTPC<S2SV_blank>service<S2SV_blank>is<S2SV_blank>inaccessible.\\n" ) ; } } if ( ret == 0 ) { filebuffer_maxsize = PAYLOAD_TEXTMAXSIZE ; filebuffer = ( u8 * ) malloc ( filebuffer_maxsize ) ; if ( filebuffer == NULL ) { printf ( "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory.\\n" ) ; ret = - 1 ; } else { memset ( filebuffer , 0 , filebuffer_maxsize ) ; } } <S2SV_StartBug> ret = load_hblauncher ( ) ; <S2SV_EndBug> free ( filebuffer ) ; <S2SV_StartBug> httpcExit ( ) ; <S2SV_EndBug> if ( ret != 0 && ret != 0xd8a0a046 ) printf ( "An<S2SV_blank>error<S2SV_blank>occured,<S2SV_blank>please<S2SV_blank>report<S2SV_blank>this<S2SV_blank>to<S2SV_blank>here<S2SV_blank>if<S2SV_blank>it<S2SV_blank>persists(or<S2SV_blank>comment<S2SV_blank>on<S2SV_blank>an<S2SV_blank>already<S2SV_blank>existing<S2SV_blank>issue<S2SV_blank>if<S2SV_blank>needed),<S2SV_blank>with<S2SV_blank>an<S2SV_blank>image<S2SV_blank>of<S2SV_blank>your<S2SV_blank>3DS<S2SV_blank>system:<S2SV_blank>https://github.com/yellows8/hblauncher_loader/issues\\n" ) ; printf ( "Press<S2SV_blank>the<S2SV_blank>START<S2SV_blank>button<S2SV_blank>to<S2SV_blank>exit.\\n" ) ; while ( aptMainLoop ( ) ) { gspWaitForVBlank ( ) ; hidScanInput ( ) ; u32 kDown = hidKeysDown ( ) ; if ( kDown & KEY_START ) break ; } gfxExit ( ) ; return 0 ; } | <S2SV_ModStart> } } } if ( ret == 0 ) { <S2SV_ModStart> ; } } if ( ret == 0 ) <S2SV_ModStart> ( ) ; } |
2,976 | CWE-000 int main ( void ) { int num [ ] = { 3 , 2 , 1 , 4 , 5 } ; GST * gst = newGST ( displayInt , compareInt , freeInt ) ; for ( int i = 0 ; i < 5 ; i ++ ) { insertGST ( gst , & num [ i ] ) ; } printf ( "Printing<S2SV_blank>GST<S2SV_blank>stats<S2SV_blank>\\n" ) ; statisticsGST ( gst , stdout ) ; printf ( "\\n" ) ; printf ( "Printing<S2SV_blank>displayGST()\\n" ) ; displayGST ( gst , stdout ) ; printf ( "\\n" ) ; fflush ( stdout ) ; printf ( "Printing<S2SV_blank>displayGSTdebug()\\n" ) ; displayGSTdebug ( gst , stdout ) ; deleteGST ( gst , & num [ 0 ] ) ; deleteGST ( gst , & num [ 3 ] ) ; printf ( "\\n" ) ; printf ( "Printing<S2SV_blank>displayGSTdebug()<S2SV_blank>after<S2SV_blank>deletes\\n" ) ; displayGSTdebug ( gst , stdout ) ; <S2SV_StartBug> freeGST ( gst ) ; <S2SV_EndBug> } | <S2SV_ModStart> stdout ) ; printf ( "\\n" ) ; displayGST ( gst , stdout ) ; fflush ( stdout ) ; |
2,977 | CWE-000 int main ( int argc , char * argv [ ] ) { int c ; int keep_alive ; int non_local ; struct netif * netif ; int dns_count ; char * str ; char * endptr ; int mtu ; int fd_in ; int fd_out ; ip4_addr_t ipaddr ; ip4_addr_t netmask ; ip4_addr_t gateway ; ip4_addr_t dns ; struct event_base * base ; char * pcap_file ; struct conn_info * local ; struct conn_info * remote ; struct conn_info * socks ; struct conn_info * info ; ip_addr_set_zero ( & ipaddr ) ; ip_addr_set_zero ( & netmask ) ; ip_addr_set_zero ( & gateway ) ; local = remote = socks = NULL ; dns_count = 0 ; keep_alive = 0 ; fd_in = 0 ; fd_out = 1 ; mtu = 0 ; pcap_file = NULL ; non_local = 0 ; signal ( SIGPIPE , SIG_IGN ) ; base = event_base_new ( ) ; lwip_init ( ) ; libevent_timeouts_init ( base ) ; if ( ( str = getenv ( "INTERNAL_IP4_ADDRESS" ) ) ) ip4addr_aton ( str , & ipaddr ) ; if ( ( str = getenv ( "INTERNAL_IP4_MTU" ) ) ) mtu = strtoul ( str , NULL , 0 ) ; if ( ( str = getenv ( "VPNFD" ) ) ) fd_in = fd_out = strtoul ( str , NULL , 0 ) ; if ( ( str = getenv ( "CISCO_DEF_DOMAIN" ) ) ) { endptr = str ; while ( ( str = tokenize ( endptr , ",<S2SV_blank>" , & endptr ) ) ) host_add_search ( str ) ; } if ( ( str = getenv ( "INTERNAL_IP4_DNS" ) ) ) { endptr = str ; while ( ( str = tokenize ( endptr , ",<S2SV_blank>" , & endptr ) ) ) { ip4addr_aton ( str , & dns ) ; dns_setserver ( dns_count ++ , & dns ) ; free ( str ) ; } } while ( ( c = getopt ( argc , argv , "L:D:R:k:m:s:d:i:n:G:p:gh" ) ) != - 1 ) { switch ( c ) { case 'L' : <S2SV_StartBug> info = parse_conn_info ( optarg , 4 ) ; <S2SV_EndBug> if ( ! info ) print_usage ( argv [ 0 ] ) ; info -> next = local ; local = info ; break ; case 'D' : <S2SV_StartBug> info = parse_conn_info ( optarg , 2 ) ; <S2SV_EndBug> if ( ! info ) print_usage ( argv [ 0 ] ) ; info -> next = socks ; socks = info ; break ; case 'R' : <S2SV_StartBug> info = parse_conn_info ( optarg , 3 ) ; <S2SV_EndBug> if ( ! info ) print_usage ( argv [ 0 ] ) ; info -> next = remote ; remote = info ; break ; case 'k' : keep_alive = strtoul ( optarg , & endptr , 0 ) ; if ( * endptr ) print_usage ( argv [ 0 ] ) ; keep_alive *= 1000 ; break ; case 'm' : mtu = strtoul ( optarg , & endptr , 0 ) ; if ( * endptr ) print_usage ( argv [ 0 ] ) ; break ; case 's' : while ( ( str = tokenize ( optarg , ",<S2SV_blank>" , & optarg ) ) ) host_add_search ( str ) ; break ; case 'd' : while ( ( str = tokenize ( optarg , ",<S2SV_blank>" , & optarg ) ) ) { ip4addr_aton ( str , & dns ) ; dns_setserver ( dns_count ++ , & dns ) ; free ( str ) ; } break ; case 'i' : ip4addr_aton ( optarg , & ipaddr ) ; break ; case 'n' : ip4addr_aton ( optarg , & netmask ) ; break ; case 'G' : ip4addr_aton ( optarg , & gateway ) ; break ; # ifdef USE_PCAP case 'p' : pcap_file = strdup ( optarg ) ; break ; # endif case 'g' : non_local = 1 ; break ; default : print_usage ( argv [ 0 ] ) ; } } while ( local ) { info = local ; str = info -> bind && info -> bind [ 0 ] ? info -> bind : NULL ; if ( ! non_local ) str = str ? : "localhost" ; if ( forward_local ( base , str , info -> bind_port , info -> host , info -> host_port , keep_alive ) < 0 ) return - 1 ; local = info -> next ; free_conn_info ( info ) ; } while ( socks ) { info = socks ; str = info -> bind && info -> bind [ 0 ] ? info -> bind : NULL ; if ( ! non_local ) str = str ? : "localhost" ; if ( socks_listen ( base , str , info -> bind_port , keep_alive ) < 0 ) return - 1 ; socks = socks -> next ; free_conn_info ( info ) ; } while ( remote ) { info = remote ; if ( forward_remote ( base , info -> bind_port , info -> host , info -> host_port , keep_alive ) < 0 ) return - 1 ; remote = info -> next ; free_conn_info ( info ) ; } netif = tunif_add ( base , fd_in , fd_out , pcap_file ) ; netif_set_ipaddr ( netif , & ipaddr ) ; netif_set_netmask ( netif , & netmask ) ; netif_set_gw ( netif , & gateway ) ; if ( mtu ) netif -> mtu = mtu ; netif_set_up ( netif ) ; event_base_dispatch ( base ) ; return 0 ; } | <S2SV_ModStart> ( optarg , 3 , <S2SV_ModStart> ( optarg , 1 , <S2SV_ModStart> parse_conn_info ( optarg , 3 |
2,978 | CWE-000 static gboolean player_bus_watch ( GstBus * bus , GstMessage * msg , struct player * self ) { const GstStructure * s ; GError * error ; gchar * debug = NULL ; const gchar * name ; gint i ; switch ( GST_MESSAGE_TYPE ( msg ) ) { case GST_MESSAGE_EOS : utils_info ( PLR , "we<S2SV_blank>got<S2SV_blank>EOS,<S2SV_blank>which<S2SV_blank>means<S2SV_blank>there<S2SV_blank>is<S2SV_blank>no<S2SV_blank>file<S2SV_blank>" "in<S2SV_blank>the<S2SV_blank>play<S2SV_blank>queue;<S2SV_blank>exiting...\\n" ) ; g_main_loop_quit ( self -> loop ) ; break ; case GST_MESSAGE_INFO : gst_message_parse_info ( msg , & error , & debug ) ; utils_info ( PLR , "INFO<S2SV_blank>from<S2SV_blank>element<S2SV_blank>%s:<S2SV_blank>%s\\n" , GST_OBJECT_NAME ( GST_MESSAGE_SRC ( msg ) ) , error -> message ) ; g_clear_error ( & error ) ; if ( debug ) { utils_info ( PLR , "INFO<S2SV_blank>debug<S2SV_blank>message:<S2SV_blank>%s\\n" , debug ) ; g_free ( debug ) ; } break ; case GST_MESSAGE_WARNING : gst_message_parse_warning ( msg , & error , & debug ) ; utils_wrn ( PLR , "WARNING<S2SV_blank>from<S2SV_blank>element<S2SV_blank>%s:<S2SV_blank>%s\\n" , GST_OBJECT_NAME ( GST_MESSAGE_SRC ( msg ) ) , error -> message ) ; g_clear_error ( & error ) ; if ( debug ) { utils_wrn ( PLR , "WARNING<S2SV_blank>debug<S2SV_blank>message:<S2SV_blank>%s\\n" , debug ) ; g_free ( debug ) ; } break ; case GST_MESSAGE_ERROR : { struct play_queue_item * item = self -> playlist -> next ? self -> playlist -> next : self -> playlist ; gst_message_parse_error ( msg , & error , & debug ) ; utils_wrn ( PLR , "ERROR<S2SV_blank>from<S2SV_blank>element<S2SV_blank>%s:<S2SV_blank>%s\\n" , GST_OBJECT_NAME ( GST_MESSAGE_SRC ( msg ) ) , error -> message ) ; g_clear_error ( & error ) ; if ( debug ) { utils_wrn ( PLR , "ERROR<S2SV_blank>debug<S2SV_blank>message:<S2SV_blank>%s\\n" , debug ) ; g_free ( debug ) ; } if ( gst_object_has_as_ancestor ( GST_MESSAGE_SRC ( msg ) , GST_OBJECT ( item -> decodebin ) ) ) { utils_info ( PLR , "error<S2SV_blank>message<S2SV_blank>originated<S2SV_blank>from<S2SV_blank>the<S2SV_blank>next<S2SV_blank>" "item\'s<S2SV_blank>decodebin;<S2SV_blank>recycling<S2SV_blank>item\\n" ) ; <S2SV_StartBug> player_recycle_item ( item ) ; <S2SV_EndBug> } else if ( self -> playlist -> next && gst_object_has_as_ancestor ( GST_MESSAGE_SRC ( msg ) , GST_OBJECT ( self -> playlist -> decodebin ) ) ) { utils_info ( PLR , "error<S2SV_blank>message<S2SV_blank>originated<S2SV_blank>from<S2SV_blank>the<S2SV_blank>current<S2SV_blank>" "item\'s<S2SV_blank>decodebin;<S2SV_blank>recycling<S2SV_blank>the<S2SV_blank>whole<S2SV_blank>playlist\\n" ) ; play_queue_item_free ( self -> playlist -> next ) ; self -> playlist -> next = NULL ; player_recycle_item ( self -> playlist ) ; <S2SV_StartBug> } else { <S2SV_EndBug> utils_err ( PLR , "error<S2SV_blank>originated<S2SV_blank>from<S2SV_blank>a<S2SV_blank>critical<S2SV_blank>element;<S2SV_blank>" "the<S2SV_blank>pipeline<S2SV_blank>cannot<S2SV_blank>continue<S2SV_blank>working,<S2SV_blank>sorry!\\n" ) ; g_main_loop_quit ( self -> loop ) ; } break ; } default : break ; } return G_SOURCE_CONTINUE ; } | <S2SV_ModStart> player_recycle_item ( item ) ; gst_element_set_state ( self -> pipeline , GST_STATE_PLAYING <S2SV_ModStart> playlist ) ; gst_element_set_state ( self -> pipeline , GST_STATE_PLAYING ) ; |
2,979 | CWE-000 static int eth_ixgbe_pci_probe ( struct rte_pci_driver * pci_drv __rte_unused , struct rte_pci_device * pci_dev ) { char name [ RTE_ETH_NAME_MAX_LEN ] ; <S2SV_StartBug> struct rte_eth_devargs eth_da ; <S2SV_EndBug> int i , retval ; if ( pci_dev -> device . devargs ) { retval = rte_eth_devargs_parse ( pci_dev -> device . devargs -> args , & eth_da ) ; if ( retval ) return retval ; } <S2SV_StartBug> snprintf ( name , sizeof ( name ) , "net_%s_%d" , pci_dev -> device . name , 0 ) ; <S2SV_EndBug> <S2SV_StartBug> retval = rte_eth_dev_create ( & pci_dev -> device , name , <S2SV_EndBug> sizeof ( struct ixgbe_adapter ) , eth_dev_pci_specific_init , pci_dev , eth_ixgbe_dev_init , NULL ) ; if ( retval || eth_da . nb_representor_ports < 1 ) return retval ; <S2SV_StartBug> struct rte_eth_dev * pf_ethdev = rte_eth_dev_allocated ( name ) ; <S2SV_EndBug> for ( i = 0 ; i < eth_da . nb_representor_ports ; i ++ ) { struct ixgbe_vf_info * vfinfo ; struct ixgbe_vf_representor representor ; vfinfo = * IXGBE_DEV_PRIVATE_TO_P_VFDATA ( pf_ethdev -> data -> dev_private ) ; if ( vfinfo == NULL ) { PMD_DRV_LOG ( ERR , "no<S2SV_blank>virtual<S2SV_blank>functions<S2SV_blank>supported<S2SV_blank>by<S2SV_blank>PF" ) ; break ; } representor . vf_id = eth_da . representor_ports [ i ] ; representor . switch_domain_id = vfinfo -> switch_domain_id ; representor . pf_ethdev = pf_ethdev ; snprintf ( name , sizeof ( name ) , "net_%s_representor_%d" , pci_dev -> device . name , eth_da . representor_ports [ i ] ) ; retval = rte_eth_dev_create ( & pci_dev -> device , name , sizeof ( struct ixgbe_vf_representor ) , NULL , NULL , ixgbe_vf_representor_init , & representor ) ; if ( retval ) PMD_DRV_LOG ( ERR , "failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>ixgbe<S2SV_blank>vf<S2SV_blank>" "representor<S2SV_blank>%s." , name ) ; } return 0 ; } | <S2SV_ModStart> ] ; struct rte_eth_dev * pf_ethdev ; struct <S2SV_ModStart> retval ; } <S2SV_ModEnd> retval = rte_eth_dev_create <S2SV_ModStart> -> device , pci_dev -> device . <S2SV_ModStart> return retval ; <S2SV_ModEnd> pf_ethdev = rte_eth_dev_allocated <S2SV_ModStart> = rte_eth_dev_allocated ( pci_dev -> device . |
2,980 | CWE-000 int main ( int argc , char * argv [ ] ) { int sock ; struct sockaddr_in server ; char message [ 1000 ] ; char server_reply [ 2000 ] ; int recvlength ; sock = socket ( AF_INET , SOCK_STREAM , 0 ) ; if ( sock == - 1 ) { printf ( "could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>socket" ) ; <S2SV_StartBug> } <S2SV_EndBug> puts ( "created<S2SV_blank>socket" ) ; server . sin_addr . s_addr = inet_addr ( "127.0.0.1" ) ; server . sin_family = AF_INET ; server . sin_port = htons ( 8888 ) ; if ( connect ( sock , ( struct sockaddr * ) & server , sizeof ( server ) ) < 0 ) { perror ( "connect<S2SV_blank>failed.error." ) ; return 1 ; } puts ( "connected." ) ; while ( 1 ) { printf ( "enter<S2SV_blank>massage:<S2SV_blank>" ) ; <S2SV_StartBug> if ( fgets ( message , 4000 , stdin ) == NULL ) <S2SV_EndBug> { puts ( "could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>from<S2SV_blank>stdin" ) ; } puts ( "read<S2SV_blank>from<S2SV_blank>stdin." ) ; if ( strncmp ( message , "end_comm" , 8 ) == 0 ) { puts ( "client<S2SV_blank>terminated." ) ; break ; } if ( send ( sock , message , strlen ( message ) , 0 ) < 0 ) { puts ( "send<S2SV_blank>fialed." ) ; return 1 ; } puts ( "message<S2SV_blank>sent." ) ; puts ( message ) ; sleep ( 1 ) ; fflush ( stdin ) ; # if defined ( __DBG ) puts ( "checkpoint<S2SV_blank>1" ) ; # endif recvlength = recv ( sock , server_reply , 2000 , 0 ) ; # if defined ( __DBG ) puts ( "checkpoint<S2SV_blank>2" ) ; # endif if ( recvlength < 0 ) { puts ( "recv<S2SV_blank>failed." ) ; break ; } else if ( recvlength == 0 ) { puts ( "server<S2SV_blank>sent<S2SV_blank>no<S2SV_blank>output." ) ; } else { puts ( "server<S2SV_blank>reply:<S2SV_blank>" ) ; puts ( server_reply ) ; } for ( int i = 0 ; i < 2000 ; ++ i ) { server_reply [ i ] = 0 ; } fflush ( stdout ) ; } close ( sock ) ; return 0 ; } | <S2SV_ModStart> "could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>socket" ) ; exit ( EXIT_FAILURE ) ; <S2SV_ModStart> ( message , 1000 <S2SV_ModEnd> , stdin ) |
2,981 | CWE-000 void add ( uint8_t instruction ) { uint8_t summand = 0 ; uint16_t addr = 0 ; switch ( instruction ) { case ADD_AA : summand = a_reg ; break ; case ADD_AB : summand = b_reg ; break ; case ADD_AC : summand = c_reg ; break ; case ADD_AD : summand = d_reg ; break ; case ADD_AE : summand = e_reg ; break ; case ADD_AH : summand = h_reg ; break ; case ADD_AL : summand = l_reg ; break ; case ADD_A_IND : addr = ( ( ( uint16_t ) h_reg ) << 8 ) | l_reg ; summand = readMemory ( addr ) ; break ; case ADD_A_d8 : summand = readMemory ( pc + 1 ) ; break ; } if ( ( ( uint16_t ) a_reg ) + summand > 0xff ) { flags |= 0x10 ; } <S2SV_StartBug> flags &= ~ ( 0x40 ) ; <S2SV_EndBug> if ( ( ( a_reg & 0xf ) + ( summand & 0xf ) ) & 0x10 ) { flags |= 0x20 ; } <S2SV_StartBug> if ( a_reg + summand == 0 ) <S2SV_EndBug> { <S2SV_StartBug> flags |= 0x80 ; <S2SV_EndBug> } a_reg += summand ; if ( instruction != ADD_A_d8 ) { pc += ALU_REG_ARGLEN ; } else { pc += ALU_IMM_ARGLEN ; } } | <S2SV_ModStart> 0x10 ; } else { <S2SV_ModStart> &= ~ ( 0x10 ) ; } flags &= ~ ( <S2SV_ModStart> 0x20 ; } else { flags &= ~ ( 0x20 ) ; } <S2SV_ModStart> flags |= 0x80 ; } else { flags &= ~ ( 0x80 ) |
2,982 | CWE-000 static void ssu100_update_lsr ( struct usb_serial_port * port , u8 lsr , char * tty_flag ) { struct ssu100_port_private * priv = usb_get_serial_port_data ( port ) ; unsigned long flags ; spin_lock_irqsave ( & priv -> status_lock , flags ) ; priv -> shadowLSR = lsr ; spin_unlock_irqrestore ( & priv -> status_lock , flags ) ; * tty_flag = TTY_NORMAL ; if ( lsr & UART_LSR_BRK_ERROR_BITS ) { if ( lsr & UART_LSR_BI ) { port -> icount . brk ++ ; * tty_flag = TTY_BREAK ; usb_serial_handle_break ( port ) ; } if ( lsr & UART_LSR_PE ) { port -> icount . parity ++ ; if ( * tty_flag == TTY_NORMAL ) * tty_flag = TTY_PARITY ; } if ( lsr & UART_LSR_FE ) { port -> icount . frame ++ ; if ( * tty_flag == TTY_NORMAL ) * tty_flag = TTY_FRAME ; } if ( lsr & UART_LSR_OE ) { port -> icount . overrun ++ ; <S2SV_StartBug> if ( * tty_flag == TTY_NORMAL ) <S2SV_EndBug> * tty_flag = TTY_OVERRUN ; } } } | <S2SV_ModStart> overrun ++ ; tty_insert_flip_char ( & port -> port , 0 , TTY_OVERRUN ) <S2SV_ModEnd> ; } } |
2,983 | CWE-000 void position_updated_cb ( double latitude , double longitude , double altitude , time_t timestamp , void * user_data ) <S2SV_StartBug> { <S2SV_EndBug> if ( timestamp ) { appdata_s * ad = user_data ; set_position ( latitude , longitude , altitude , timestamp , ad ) ; if ( ad -> visor . go_position ) { show_map_point ( ad ) ; ad -> visor . go_position = 0 ; } print_gps_data ( latitude , longitude , altitude , timestamp , ad , true , false ) ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> * user_data ) <S2SV_ModEnd> { appdata_s * <S2SV_ModStart> ) ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
2,984 | CWE-000 static int encode_frame ( AVCodecContext * avctx , QSVEncContext * q , const AVFrame * frame ) { AVPacket new_pkt = { 0 } ; mfxBitstream * bs ; mfxFrameSurface1 * surf = NULL ; mfxSyncPoint * sync = NULL ; QSVFrame * qsv_frame = NULL ; mfxEncodeCtrl * enc_ctrl = NULL ; int ret ; if ( frame ) { ret = submit_frame ( q , frame , & qsv_frame ) ; if ( ret < 0 ) { av_log ( avctx , AV_LOG_ERROR , "Error<S2SV_blank>submitting<S2SV_blank>the<S2SV_blank>frame<S2SV_blank>for<S2SV_blank>encoding.\\n" ) ; return ret ; } } if ( qsv_frame ) { surf = & qsv_frame -> surface ; enc_ctrl = & qsv_frame -> enc_ctrl ; } ret = av_new_packet ( & new_pkt , q -> packet_size ) ; if ( ret < 0 ) { av_log ( avctx , AV_LOG_ERROR , "Error<S2SV_blank>allocating<S2SV_blank>the<S2SV_blank>output<S2SV_blank>packet\\n" ) ; return ret ; } bs = av_mallocz ( sizeof ( * bs ) ) ; if ( ! bs ) { av_packet_unref ( & new_pkt ) ; return AVERROR ( ENOMEM ) ; } bs -> Data = new_pkt . data ; bs -> MaxLength = new_pkt . size ; <S2SV_StartBug> if ( q -> set_encode_ctrl_cb ) { <S2SV_EndBug> q -> set_encode_ctrl_cb ( avctx , frame , & qsv_frame -> enc_ctrl ) ; } sync = av_mallocz ( sizeof ( * sync ) ) ; if ( ! sync ) { av_freep ( & bs ) ; av_packet_unref ( & new_pkt ) ; return AVERROR ( ENOMEM ) ; } do { ret = MFXVideoENCODE_EncodeFrameAsync ( q -> session , enc_ctrl , surf , bs , sync ) ; if ( ret == MFX_WRN_DEVICE_BUSY ) av_usleep ( 500 ) ; } while ( ret == MFX_WRN_DEVICE_BUSY || ret == MFX_WRN_IN_EXECUTION ) ; if ( ret > 0 ) ff_qsv_print_warning ( avctx , ret , "Warning<S2SV_blank>during<S2SV_blank>encoding" ) ; if ( ret < 0 ) { av_packet_unref ( & new_pkt ) ; av_freep ( & bs ) ; av_freep ( & sync ) ; return ( ret == MFX_ERR_MORE_DATA ) ? 0 : ff_qsv_print_error ( avctx , ret , "Error<S2SV_blank>during<S2SV_blank>encoding" ) ; <S2SV_StartBug> } <S2SV_EndBug> if ( ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM && frame -> interlaced_frame ) print_interlace_msg ( avctx , q ) ; <S2SV_StartBug> if ( * sync ) { <S2SV_EndBug> av_fifo_generic_write ( q -> async_fifo , & new_pkt , sizeof ( new_pkt ) , NULL ) ; av_fifo_generic_write ( q -> async_fifo , & sync , sizeof ( sync ) , NULL ) ; av_fifo_generic_write ( q -> async_fifo , & bs , sizeof ( bs ) , NULL ) ; } else { av_freep ( & sync ) ; av_packet_unref ( & new_pkt ) ; av_freep ( & bs ) ; } return 0 ; } | <S2SV_ModStart> ; if ( ( NULL != qsv_frame ) && <S2SV_ModStart> ) ; } if ( NULL != frame ) { <S2SV_ModStart> q ) ; } |
2,985 | CWE-000 static gchar * * parse_gwt ( SoupMessage * msg , gboolean * ok , guint * count ) { GError * error = NULL ; JsonArray * body , * strings ; JsonNode * node ; JsonParser * parser ; const gchar * ctype ; gchar * * fields = NULL ; guint i , length , max ; * count = 0 ; ctype = soup_message_headers_get_content_type ( msg -> response_headers , NULL ) ; if ( g_strcmp0 ( ctype , "application/json" ) || ! msg -> response_body || msg -> response_body -> length < 5 || ! g_str_has_prefix ( msg -> response_body -> data , "//" ) ) { chime_debug ( "Unexpected<S2SV_blank>GWT<S2SV_blank>response<S2SV_blank>format\\n" ) ; return fields ; } * ok = ! strncmp ( msg -> response_body -> data + 2 , "OK" , 2 ) ; parser = json_parser_new ( ) ; if ( ! json_parser_load_from_data ( parser , msg -> response_body -> data + 4 , msg -> response_body -> length - 4 , & error ) ) { chime_debug ( "GWT-JSON<S2SV_blank>parsing<S2SV_blank>error:<S2SV_blank>%s\\n" , error -> message ) ; goto out ; } node = json_parser_get_root ( parser ) ; if ( ! JSON_NODE_HOLDS_ARRAY ( node ) ) { chime_debug ( "Unexpected<S2SV_blank>GWT-JSON<S2SV_blank>type<S2SV_blank>%d\\n" , JSON_NODE_TYPE ( node ) ) ; goto out ; } body = json_node_get_array ( node ) ; length = json_array_get_length ( body ) ; if ( length < 4 ) { chime_debug ( "GWT<S2SV_blank>response<S2SV_blank>array<S2SV_blank>length<S2SV_blank>%d<S2SV_blank>too<S2SV_blank>short\\n" , length ) ; goto out ; } length -= 3 ; node = json_array_get_element ( body , length ) ; if ( ! JSON_NODE_HOLDS_ARRAY ( node ) ) { chime_debug ( "Could<S2SV_blank>not<S2SV_blank>find<S2SV_blank>GWT<S2SV_blank>response<S2SV_blank>strings<S2SV_blank>table\\n" ) ; goto out ; } strings = json_node_get_array ( node ) ; max = json_array_get_length ( strings ) ; * count = length ; fields = g_new0 ( gchar * , length + 1 ) ; for ( i = 0 ; i < length ; i ++ ) { const gchar * value = NULL ; gint64 j = json_array_get_int_element ( body , length - i - 1 ) ; if ( j > 0 && j <= max ) value = json_array_get_string_element ( strings , j - 1 ) ; fields [ i ] = g_strdup ( value ) ; } out : <S2SV_StartBug> g_error_free ( error ) ; <S2SV_EndBug> g_object_unref ( parser ) ; return fields ; } | <S2SV_ModStart> } out : g_clear_error ( & <S2SV_ModEnd> error ) ; |
2,986 | CWE-000 START_TEST ( Server_publishCallback ) { UA_CreateSubscriptionRequest request ; UA_CreateSubscriptionResponse response ; UA_CreateSubscriptionRequest_init ( & request ) ; request . publishingEnabled = true ; UA_CreateSubscriptionResponse_init ( & response ) ; Service_CreateSubscription ( server , & adminSession , & request , & response ) ; ck_assert_uint_eq ( response . responseHeader . serviceResult , UA_STATUSCODE_GOOD ) ; UA_UInt32 subscriptionId1 = response . subscriptionId ; UA_CreateSubscriptionResponse_deleteMembers ( & response ) ; UA_CreateSubscriptionRequest_init ( & request ) ; request . publishingEnabled = true ; UA_CreateSubscriptionResponse_init ( & response ) ; Service_CreateSubscription ( server , & adminSession , & request , & response ) ; ck_assert_uint_eq ( response . responseHeader . serviceResult , UA_STATUSCODE_GOOD ) ; UA_UInt32 subscriptionId2 = response . subscriptionId ; UA_Double publishingInterval = response . revisedPublishingInterval ; ck_assert ( publishingInterval > 0.0f ) ; UA_CreateSubscriptionResponse_deleteMembers ( & response ) ; usleep ( ( useconds_t ) ( publishingInterval * 1000 ) + 1000 ) ; UA_Subscription * sub ; LIST_FOREACH ( sub , & adminSession . serverSubscriptions , listEntry ) ck_assert_uint_eq ( sub -> currentKeepAliveCount , sub -> maxKeepAliveCount ) ; UA_Server_run_iterate ( server , false ) ; # ifdef UA_ENABLE_MULTITHREADING usleep ( ( useconds_t ) ( publishingInterval * 1000 ) + 1000 ) ; UA_Server_run_iterate ( server , false ) ; usleep ( ( useconds_t ) ( publishingInterval * 1000 ) + 1000 ) ; # endif LIST_FOREACH ( sub , & adminSession . serverSubscriptions , listEntry ) ck_assert_uint_eq ( sub -> currentKeepAliveCount , sub -> maxKeepAliveCount + 1 ) ; UA_DeleteSubscriptionsRequest del_request ; UA_DeleteSubscriptionsRequest_init ( & del_request ) ; UA_UInt32 removeIds [ 2 ] = { subscriptionId1 , subscriptionId2 } ; del_request . subscriptionIdsSize = 2 ; del_request . subscriptionIds = removeIds ; UA_DeleteSubscriptionsResponse del_response ; UA_DeleteSubscriptionsResponse_init ( & del_response ) ; Service_DeleteSubscriptions ( server , & adminSession , & del_request , & del_response ) ; <S2SV_StartBug> ck_assert_uint_eq ( del_response . resultsSize , 2 ) ; <S2SV_EndBug> ck_assert_uint_eq ( del_response . results [ 0 ] , UA_STATUSCODE_GOOD ) ; ck_assert_uint_eq ( del_response . results [ 1 ] , UA_STATUSCODE_GOOD ) ; UA_DeleteSubscriptionsResponse_deleteMembers ( & del_response ) ; } | <S2SV_ModStart> ( del_response . responseHeader . serviceResult , UA_STATUSCODE_GOOD ) ; ck_assert_uint_eq ( del_response . |
2,987 | CWE-000 static void schedule_event_now_cb ( evutil_socket_t fd UNUSED , short events UNUSED , void * arg ) { struct now_event * ne = ( struct now_event * ) arg ; DBG ( DBG_CONTROLMORE , DBG_log ( "executing<S2SV_blank>now-event<S2SV_blank>%s<S2SV_blank>for<S2SV_blank>%lu" , ne -> ne_name , ne -> ne_serialno ) ) ; pexpect ( ne -> ne_event != NULL ) ; <S2SV_StartBug> ne -> ne_callback ( ne -> ne_context ) ; <S2SV_EndBug> passert ( ne -> ne_event != NULL ) ; event_del ( ne -> ne_event ) ; pfree ( ne ) ; } | <S2SV_ModStart> NULL ) ; struct state * st = state_with_serialno ( ne -> ne_serialno ) ; if ( st == NULL ) { <S2SV_ModStart> -> ne_callback ( NULL , NULL , <S2SV_ModStart> ne_context ) ; } else { struct msg_digest * md = unsuspend_md ( st ) ; so_serial_t old_state = push_cur_state ( st ) ; ne -> ne_callback ( st , & md , ne -> ne_context ) ; release_any_md ( & md ) ; pop_cur_state ( old_state ) ; } |
2,988 | CWE-000 int main ( int ac , char * * av ) { signal ( SIGINT , & sig_handler ) ; setbuf ( stdout , NULL ) ; setbuf ( stderr , NULL ) ; init ( ac , av ) ; while ( get_shell_env ( ) -> should_run ) main_loop ( ) ; <S2SV_StartBug> print_name_and_error ( get_error ( ) ) ; <S2SV_EndBug> <S2SV_StartBug> if ( get_error ( ) == NO_ERROR ) <S2SV_EndBug> return ( EXIT_SUCCESS ) ; else <S2SV_StartBug> return ( EXIT_FAILURE ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ( ) ; if ( get_error ( ) == CHILD_FAILURE ) return ( get_last_exit_status <S2SV_ModEnd> ( ) ) <S2SV_ModStart> ) ) ; else <S2SV_ModStart> ) ; else { print_name_and_error ( get_error ( ) ) ; return ( get_error ( ) <S2SV_ModEnd> ) ; } <S2SV_ModStart> ) ; } } |
2,989 | CWE-000 void huffTestCases ( ) { <S2SV_StartBug> HuffTree * t = createHuffTree ( "tp.c" ) ; <S2SV_EndBug> inorder ( t -> root ) ; } | <S2SV_ModStart> = createHuffTree ( getFrequencyQueue ( "tp.c" ) <S2SV_ModEnd> ) ; inorder |
2,990 | CWE-000 static inline struct page * __alloc_pages_direct_reclaim ( gfp_t gfp_mask , unsigned int order , struct zonelist * zonelist , enum zone_type high_zoneidx , nodemask_t * nodemask , int alloc_flags , struct zone * preferred_zone , int classzone_idx , int migratetype , unsigned long * did_some_progress ) { struct page * page = NULL ; <S2SV_StartBug> bool drained = false ; <S2SV_EndBug> vm_swappiness = 0 ; * did_some_progress = __perform_reclaim ( gfp_mask , order , zonelist , nodemask ) ; if ( unlikely ( ! ( * did_some_progress ) ) ) return NULL ; if ( IS_ENABLED ( CONFIG_NUMA ) ) zlc_clear_zones_full ( zonelist ) ; retry : page = get_page_from_freelist ( gfp_mask , nodemask , order , zonelist , high_zoneidx , alloc_flags & ~ ALLOC_NO_WATERMARKS , preferred_zone , classzone_idx , migratetype ) ; if ( ! page && ! drained ) { drain_all_pages ( ) ; drained = true ; goto retry ; } if ( page ) set_page_owner ( page , order , gfp_mask ) ; return page ; } | <S2SV_ModStart> drained = false <S2SV_ModEnd> ; * did_some_progress |
2,991 | CWE-000 PHP_METHOD ( PhalconPlus_Logger_Adapter_FilePlus , __construct ) { zend_long ZEPHIR_LAST_CALL_STATUS ; zephir_fcall_cache_entry * _0 = NULL ; zval options ; zval * filePath_param = NULL , * options_param = NULL , mode , _4 , _5 , _6 , _7 , _8 , _1$$3 , _2$$3 , _3$$6 ; zval filePath ; zval * this_ptr = getThis ( ) ; ZVAL_UNDEF ( & filePath ) ; ZVAL_UNDEF ( & mode ) ; ZVAL_UNDEF ( & _4 ) ; ZVAL_UNDEF ( & _5 ) ; ZVAL_UNDEF ( & _6 ) ; ZVAL_UNDEF ( & _7 ) ; ZVAL_UNDEF ( & _8 ) ; ZVAL_UNDEF ( & _1$$3 ) ; ZVAL_UNDEF ( & _2$$3 ) ; ZVAL_UNDEF ( & _3$$6 ) ; ZVAL_UNDEF ( & options ) ; ZEPHIR_MM_GROW ( ) ; zephir_fetch_params ( 1 , 1 , 1 , & filePath_param , & options_param ) ; if ( UNEXPECTED ( Z_TYPE_P ( filePath_param ) != IS_STRING && Z_TYPE_P ( filePath_param ) != IS_NULL ) ) { zephir_throw_exception_string ( spl_ce_InvalidArgumentException , SL ( "Parameter<S2SV_blank>\'filePath\'<S2SV_blank>must<S2SV_blank>be<S2SV_blank>a<S2SV_blank>string" ) TSRMLS_CC ) ; RETURN_MM_NULL ( ) ; } if ( EXPECTED ( Z_TYPE_P ( filePath_param ) == IS_STRING ) ) { zephir_get_strval ( & filePath , filePath_param ) ; } else { ZEPHIR_INIT_VAR ( & filePath ) ; ZVAL_EMPTY_STRING ( & filePath ) ; } if ( ! options_param ) { ZEPHIR_INIT_VAR ( & options ) ; array_init ( & options ) ; } else { zephir_get_arrval ( & options , options_param ) ; } ZEPHIR_CALL_CE_STATIC ( NULL , phalconplus_assert_assertion_ce , "notempty" , & _0 , 0 , & filePath ) ; zephir_check_call_status ( ) ; ZEPHIR_OBS_VAR ( & mode ) ; if ( zephir_array_isset_string_fetch ( & mode , & options , SL ( "mode" ) , 0 ) ) { ZEPHIR_INIT_VAR ( & _1$$3 ) ; ZVAL_STRING ( & _1$$3 , "r" ) ; ZEPHIR_INIT_VAR ( & _2$$3 ) ; zephir_fast_strpos ( & _2$$3 , & mode , & _1$$3 , 0 ) ; if ( ZEPHIR_IS_FALSE_IDENTICAL ( & _2$$3 ) ) { zephir_update_property_zval ( this_ptr , SL ( "mode" ) , & mode ) ; } else { <S2SV_StartBug> ZEPHIR_THROW_EXCEPTION_DEBUG_STR ( spl_ce_InvalidArgumentException , "Logger<S2SV_blank>must<S2SV_blank>be<S2SV_blank>opened<S2SV_blank>in<S2SV_blank>append<S2SV_blank>or<S2SV_blank>write<S2SV_blank>mode" , "phalconplus/Logger/Adapter/FilePlus.zep" , 24 ) ; <S2SV_EndBug> return ; } } else { ZEPHIR_INIT_VAR ( & _3$$6 ) ; ZEPHIR_INIT_NVAR ( & _3$$6 ) ; ZVAL_STRING ( & _3$$6 , "ab" ) ; zephir_update_property_zval ( this_ptr , SL ( "mode" ) , & _3$$6 ) ; } ZEPHIR_CALL_METHOD ( & _4 , this_ptr , "open" , NULL , 52 , & filePath ) ; zephir_check_call_status ( ) ; zephir_update_property_zval ( this_ptr , SL ( "_fileHandler" ) , & _4 ) ; zephir_update_property_zval ( this_ptr , SL ( "_path" ) , & filePath ) ; zephir_update_property_zval ( this_ptr , SL ( "_options" ) , & options ) ; zephir_read_property ( & _5 , this_ptr , SL ( "_fileHandler" ) , PH_NOISY_CC | PH_READONLY ) ; ZEPHIR_INIT_VAR ( & _6 ) ; ZVAL_LONG ( & _6 , - 1 ) ; zephir_update_property_array ( this_ptr , SL ( "type2Handler" ) , & _6 , & _5 TSRMLS_CC ) ; ZEPHIR_INIT_VAR ( & _7 ) ; ZVAL_LONG ( & _7 , - 1 ) ; ZEPHIR_INIT_VAR ( & _8 ) ; ZVAL_STRING ( & _8 , "" ) ; zephir_update_property_array ( this_ptr , SL ( "type2Ext" ) , & _7 , & _8 TSRMLS_CC ) ; ZEPHIR_MM_RESTORE ( ) ; } | <S2SV_ModStart> , "phalconplus/Logger/Adapter/FilePlus.zep" , 25 <S2SV_ModEnd> ) ; return |
2,992 | CWE-000 LTTNG_HIDDEN int utils_create_lock_file ( const char * filepath ) { int ret ; int fd ; struct flock lock ; assert ( filepath ) ; memset ( & lock , 0 , sizeof ( lock ) ) ; fd = open ( filepath , O_CREAT | O_WRONLY , S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP ) ; if ( fd < 0 ) { PERROR ( "open<S2SV_blank>lock<S2SV_blank>file<S2SV_blank>%s" , filepath ) ; <S2SV_StartBug> ret = - 1 ; <S2SV_EndBug> goto error ; } lock . l_whence = SEEK_SET ; lock . l_type = F_WRLCK ; ret = fcntl ( fd , F_SETLK , & lock ) ; if ( ret == - 1 ) { PERROR ( "fcntl<S2SV_blank>lock<S2SV_blank>file" ) ; ERR ( "Could<S2SV_blank>not<S2SV_blank>get<S2SV_blank>lock<S2SV_blank>file<S2SV_blank>%s,<S2SV_blank>another<S2SV_blank>instance<S2SV_blank>is<S2SV_blank>running." , filepath ) ; if ( close ( fd ) ) { PERROR ( "close<S2SV_blank>lock<S2SV_blank>file" ) ; } fd = ret ; goto error ; } error : return fd ; } | <S2SV_ModStart> filepath ) ; fd <S2SV_ModEnd> = - 1 |
2,993 | CWE-000 static PyObject * py_check_visibility_all ( PyObject * self , PyObject * args ) { Py_buffer arg1 ; room_t * room ; if ( ! PyArg_ParseTuple ( args , "w*" , & arg1 ) ) return NULL ; if ( arg1 . len != sizeof ( room_t ) ) { PyErr_SetString ( PyExc_TypeError , "wrong<S2SV_blank>buffer<S2SV_blank>size" ) ; return NULL ; } room = arg1 . buf ; check_visibility_all ( room ) ; PyBuffer_Release ( & arg1 ) ; <S2SV_StartBug> return Py_None ; <S2SV_EndBug> } | <S2SV_ModStart> arg1 ) ; Py_INCREF ( Py_None ) ; |
2,994 | CWE-000 int main ( int argc , char * argv [ ] ) { if ( argc >= 2 ) { iqfile = fopen ( argv [ 1 ] , "r" ) ; char ManchesterFileName [ 255 ] ; strcpy ( ManchesterFileName , argv [ 1 ] ) ; strcat ( ManchesterFileName , ".man" ) ; ManchesterFile = fopen ( ManchesterFileName , "wb" ) ; } else iqfile = fopen ( "omniup325.cu8" , "r" ) ; <S2SV_StartBug> DebugIQ = fopen ( "debug.cu8" , "wb" ) ; <S2SV_EndBug> if ( DebugIQ == NULL ) { printf ( "Error<S2SV_blank>opeing<S2SV_blank>output<S2SV_blank>file\\n" ) ; exit ( 0 ) ; } if ( argc >= 4 ) { mlot = atol ( argv [ 2 ] ) ; mtid = atol ( argv [ 3 ] ) ; } <S2SV_StartBug> # ifdef DEBUG_FM <S2SV_EndBug> DebugFM = fopen ( "debugfm.cf32" , "wb" ) ; # endif if ( iqfile == NULL ) { printf ( "Missing<S2SV_blank>input<S2SV_blank>file\\n" ) ; exit ( 0 ) ; } InitNounce ( mlot , mtid , 0 ) ; InitRF ( ) ; while ( ProcessRF ( ) ) { } # ifdef DEBUG_FM if ( DebugFM != NULL ) fclose ( DebugFM ) ; # endif if ( DebugIQ != NULL ) fclose ( DebugIQ ) ; if ( iqfile != NULL ) fclose ( iqfile ) ; return 0 ; } | <S2SV_ModStart> "r" ) ; <S2SV_ModEnd> if ( argc <S2SV_ModStart> ) ; } if ( strcmp ( argv [ 1 ] , "debug.cu8" ) != 0 ) { DebugIQ = fopen ( "debug.cu8" , "wb" ) ; if ( DebugIQ == NULL ) { printf ( "Error<S2SV_blank>opeing<S2SV_blank>output<S2SV_blank>file\\n" ) ; exit ( 0 ) ; } } |
2,995 | CWE-000 int reload_vrmr_interfaces_check ( const int debuglvl , struct vrmr_ctx * vctx , struct vrmr_interface * iface_ptr ) { int retval = 0 ; int check_result = 0 ; struct vrmr_interface * new_iface_ptr = NULL ; int status = 0 ; struct vrmr_list_node * protect_d_node_orig = NULL , * protect_d_node_new = NULL ; struct vrmr_rule * org_rule_ptr = NULL , * new_rule_ptr = NULL ; if ( ! iface_ptr ) { vrmr_error ( - 1 , "Internal<S2SV_blank>Error" , "parameter<S2SV_blank>problem<S2SV_blank>(in:<S2SV_blank>%s:%d)." , __FUNC__ , __LINE__ ) ; return ( - 1 ) ; } if ( ! ( new_iface_ptr = vrmr_interface_malloc ( debuglvl ) ) ) { vrmr_error ( - 1 , "Internal<S2SV_blank>Error" , "vrmr_interface_malloc()<S2SV_blank>failed:<S2SV_blank>%s<S2SV_blank>(in:<S2SV_blank>%s:%d)." , strerror ( errno ) , __FUNC__ , __LINE__ ) ; return ( - 1 ) ; } <S2SV_StartBug> if ( strlcpy ( new_iface_ptr -> name , iface_ptr -> name , sizeof ( new_iface_ptr -> name ) ) >= sizeof ( new_iface_ptr -> name ) ) <S2SV_EndBug> { vrmr_error ( - 1 , "Error" , "buffer<S2SV_blank>overflow<S2SV_blank>(in:<S2SV_blank>%s:%d)." , __FUNC__ , __LINE__ ) ; return ( - 1 ) ; } status = VRMR_ST_KEEP ; if ( vrmr_read_interface_info ( debuglvl , vctx , new_iface_ptr ) != 0 ) { vrmr_error ( - 1 , "Error" , "getting<S2SV_blank>interface<S2SV_blank>information<S2SV_blank>for<S2SV_blank>\'%s\'<S2SV_blank>failed<S2SV_blank>(in:<S2SV_blank>%s)." , iface_ptr -> name , __FUNC__ ) ; status = VRMR_ST_REMOVED ; } else { check_result = vrmr_interfaces_check ( debuglvl , new_iface_ptr ) ; if ( check_result != 1 || iface_ptr -> active == new_iface_ptr -> active ) { if ( strcmp ( iface_ptr -> device , new_iface_ptr -> device ) == 0 ) { if ( iface_ptr -> dynamic == new_iface_ptr -> dynamic ) { if ( iface_ptr -> device_virtual == new_iface_ptr -> device_virtual ) { if ( strcmp ( iface_ptr -> ipv4 . ipaddress , new_iface_ptr -> ipv4 . ipaddress ) == 0 ) { if ( iface_ptr -> up == new_iface_ptr -> up ) { if ( iface_ptr -> ProtectList . len != new_iface_ptr -> ProtectList . len ) { vrmr_info ( "Info" , "Interface<S2SV_blank>\'%s\':<S2SV_blank>the<S2SV_blank>number<S2SV_blank>of<S2SV_blank>protectrules<S2SV_blank>has<S2SV_blank>been<S2SV_blank>changed." , iface_ptr -> name ) ; status = VRMR_ST_CHANGED ; } protect_d_node_new = new_iface_ptr -> ProtectList . top ; protect_d_node_orig = iface_ptr -> ProtectList . top ; if ( ! protect_d_node_new && ! protect_d_node_orig ) { } else if ( ( ! protect_d_node_new && protect_d_node_orig ) || ( protect_d_node_new && ! protect_d_node_orig ) ) { if ( ! protect_d_node_orig ) vrmr_info ( "Info" , "Interface<S2SV_blank>\'%s\':<S2SV_blank>interface<S2SV_blank>now<S2SV_blank>has<S2SV_blank>(an)<S2SV_blank>protectrule(s)." , iface_ptr -> name ) ; if ( ! protect_d_node_new ) vrmr_info ( "Info" , "Interface<S2SV_blank>\'%s\':<S2SV_blank>interface<S2SV_blank>no<S2SV_blank>longer<S2SV_blank>has<S2SV_blank>(an)<S2SV_blank>protectrule(s)." , iface_ptr -> name ) ; status = VRMR_ST_CHANGED ; } else { for ( ; protect_d_node_new && protect_d_node_orig ; protect_d_node_new = protect_d_node_new -> next , protect_d_node_orig = protect_d_node_orig -> next ) { <S2SV_StartBug> if ( ! ( new_rule_ptr = protect_d_node_new -> data ) ) <S2SV_EndBug> { vrmr_error ( - 1 , "Internal<S2SV_blank>Error" , "NULL<S2SV_blank>pointer<S2SV_blank>(in:<S2SV_blank>%s:%d)." , __FUNC__ , __LINE__ ) ; return ( - 1 ) ; } <S2SV_StartBug> if ( ! ( org_rule_ptr = protect_d_node_orig -> data ) ) <S2SV_EndBug> { vrmr_error ( - 1 , "Internal<S2SV_blank>Error" , "NULL<S2SV_blank>pointer<S2SV_blank>(in:<S2SV_blank>%s:%d)." , __FUNC__ , __LINE__ ) ; return ( - 1 ) ; } if ( strcmp ( org_rule_ptr -> danger , new_rule_ptr -> danger ) != 0 || strcmp ( org_rule_ptr -> source , new_rule_ptr -> source ) != 0 ) { vrmr_info ( "Info" , "Interface<S2SV_blank>\'%s\':<S2SV_blank>protectrules<S2SV_blank>not<S2SV_blank>in<S2SV_blank>the<S2SV_blank>same<S2SV_blank>order." , iface_ptr -> name ) ; status = VRMR_ST_CHANGED ; break ; } } } } else { vrmr_info ( "Info" , "Interface<S2SV_blank>\'%s\'<S2SV_blank>is<S2SV_blank>now:<S2SV_blank>%s." , iface_ptr -> name , new_iface_ptr -> up ? "up" : "down" ) ; status = VRMR_ST_CHANGED ; } } else { vrmr_info ( "Info" , "Interface<S2SV_blank>\'%s\'<S2SV_blank>has<S2SV_blank>a<S2SV_blank>new<S2SV_blank>ipaddress:<S2SV_blank>\'%s\'." , iface_ptr -> name , new_iface_ptr -> ipv4 . ipaddress ) ; status = VRMR_ST_CHANGED ; } # ifdef IPV6_ENABLED if ( strcmp ( iface_ptr -> ipv6 . ip6 , new_iface_ptr -> ipv6 . ip6 ) != 0 ) { vrmr_info ( "Info" , "Interface<S2SV_blank>\'%s\'<S2SV_blank>has<S2SV_blank>a<S2SV_blank>new<S2SV_blank>ipv6<S2SV_blank>ipaddress:<S2SV_blank>\'%s\'." , iface_ptr -> name , new_iface_ptr -> ipv6 . ip6 ) ; status = VRMR_ST_CHANGED ; } # endif } else { if ( new_iface_ptr -> dynamic == TRUE ) vrmr_info ( "Info" , "Interface<S2SV_blank>\'%s\'<S2SV_blank>now<S2SV_blank>has<S2SV_blank>a<S2SV_blank>dynamic<S2SV_blank>ipaddress." , iface_ptr -> name ) ; else vrmr_info ( "Info" , "Interface<S2SV_blank>\'%s\'<S2SV_blank>no<S2SV_blank>longer<S2SV_blank>has<S2SV_blank>a<S2SV_blank>dynamic<S2SV_blank>ipaddress." , iface_ptr -> name ) ; status = VRMR_ST_CHANGED ; } } else { if ( new_iface_ptr -> device_virtual == TRUE ) vrmr_info ( "Info" , "Interface<S2SV_blank>\'%s\'<S2SV_blank>is<S2SV_blank>now<S2SV_blank>\'virtual\'." , iface_ptr -> name ) ; else vrmr_info ( "Info" , "Interface<S2SV_blank>\'%s\'<S2SV_blank>is<S2SV_blank>no<S2SV_blank>longer<S2SV_blank>\'virtual\'." , iface_ptr -> name ) ; status = VRMR_ST_CHANGED ; } } else { vrmr_info ( "Info" , "Interface<S2SV_blank>\'%s\'<S2SV_blank>has<S2SV_blank>a<S2SV_blank>new<S2SV_blank>system<S2SV_blank>device:<S2SV_blank>\'%s\'." , iface_ptr -> name , new_iface_ptr -> device ) ; status = VRMR_ST_CHANGED ; } } else { if ( new_iface_ptr -> active == TRUE ) { vrmr_info ( "Info" , "Interface<S2SV_blank>\'%s\'<S2SV_blank>has<S2SV_blank>been<S2SV_blank>activated." , iface_ptr -> name ) ; status = VRMR_ST_ACTIVATED ; } else { vrmr_info ( "Info" , "Interface<S2SV_blank>\'%s\'<S2SV_blank>has<S2SV_blank>been<S2SV_blank>deactivated." , iface_ptr -> name ) ; status = VRMR_ST_DEACTIVATED ; } } if ( ( status == VRMR_ST_CHANGED || status == VRMR_ST_ACTIVATED || status == VRMR_ST_DEACTIVATED ) && check_result != 1 ) { vrmr_info ( "Info" , "Interface<S2SV_blank>\'%s\'<S2SV_blank>has<S2SV_blank>been<S2SV_blank>deactivated<S2SV_blank>because<S2SV_blank>of<S2SV_blank>errors<S2SV_blank>while<S2SV_blank>checking<S2SV_blank>it." , iface_ptr -> name ) ; new_iface_ptr -> active = FALSE ; } } if ( status == VRMR_ST_CHANGED || status == VRMR_ST_ACTIVATED || status == VRMR_ST_DEACTIVATED ) { vrmr_list_cleanup ( debuglvl , & iface_ptr -> ProtectList ) ; * iface_ptr = * new_iface_ptr ; retval = 1 ; } else if ( status == VRMR_ST_KEEP || status == VRMR_ST_REMOVED ) { vrmr_list_cleanup ( debuglvl , & new_iface_ptr -> ProtectList ) ; } free ( new_iface_ptr ) ; new_iface_ptr = NULL ; iface_ptr -> status = status ; return ( retval ) ; } | <S2SV_ModStart> ) ; } ( void ) <S2SV_ModEnd> strlcpy ( new_iface_ptr <S2SV_ModStart> name ) ) ; <S2SV_ModEnd> status = VRMR_ST_KEEP <S2SV_ModStart> next ) { <S2SV_ModEnd> new_rule_ptr = protect_d_node_new <S2SV_ModStart> protect_d_node_new -> data ; <S2SV_ModEnd> org_rule_ptr = protect_d_node_orig <S2SV_ModStart> protect_d_node_orig -> data ; if ( new_rule_ptr == NULL || org_rule_ptr == NULL ) continue ; <S2SV_ModEnd> if ( strcmp |
2,996 | CWE-000 void timer3Init ( void ) { TCCR3A = ( ( TIMER3_COMPA & 0x03 ) << 6 ) | ( ( TIMER3_COMPB & 0x03 ) << 4 ) | ( ( TIMER3_WGM & 0x03 ) << 0 ) ; TCCR3B = ( ( TIMER3_FOCA & 0x01 ) << 7 ) | ( ( TIMER3_FOCB & 0x01 ) << 6 ) | ( ( TIMER3_WGM & 0x04 ) << 1 ) | ( ( TIMER3_CLKSEL & 0x07 ) << 0 ) ; <S2SV_StartBug> TIMSK <S2SV_EndBug> <S2SV_StartBug> = ( ( TIMER3_OCBIE & 0x01 ) << 2 ) <S2SV_EndBug> <S2SV_StartBug> | ( ( TIMER3_OCAIE & 0x01 ) << 1 ) <S2SV_EndBug> | ( ( TIMER3_OVIE & 0x01 ) << 0 ) ; OCR3A = TIMER3_OCR0A ; OCR3B = TIMER3_OCR0B ; } | <S2SV_ModStart> 0 ) ; ETIMSK <S2SV_ModEnd> = ( ( <S2SV_ModStart> 0x01 ) << 3 <S2SV_ModEnd> ) | ( <S2SV_ModStart> 0x01 ) << 4 <S2SV_ModEnd> ) ; OCR3A |
2,997 | CWE-000 void antd_task_schedule ( ) { antd_task_item_t it = NULL ; pthread_mutex_lock ( & scheduler . scheduler_lock ) ; for ( int i = 0 ; i < N_PRIORITY ; i ++ ) { it = dequeue ( & scheduler . task_queue [ i ] ) ; if ( it ) break ; } pthread_mutex_unlock ( & scheduler . scheduler_lock ) ; if ( ! it ) { return ; } if ( it -> task -> type == LIGHT || scheduler . n_workers <= 0 ) { antd_execute_task ( it ) ; } else { <S2SV_StartBug> LOG ( "delegate<S2SV_blank>to<S2SV_blank>workers\\n" ) ; <S2SV_EndBug> pthread_mutex_lock ( & scheduler . queue_lock ) ; enqueue ( & scheduler . workers_queue , it -> task ) ; free ( it ) ; pthread_mutex_unlock ( & scheduler . queue_lock ) ; } } | <S2SV_ModStart> } else { <S2SV_ModEnd> pthread_mutex_lock ( & |
2,998 | CWE-000 <S2SV_StartBug> void oyun ( int o ) <S2SV_EndBug> { printf ( "O<S2SV_blank>azili<S2SV_blank>robotla<S2SV_blank>karsi<S2SV_blank>karsiyasin.\\n" ) ; printf ( "Sana<S2SV_blank>kivilcim<S2SV_blank>sacan<S2SV_blank>gozleriyle<S2SV_blank>bakiyor.\\n" ) ; printf ( "Hamle<S2SV_blank>yapmanin<S2SV_blank>tam<S2SV_blank>zamani.\\n" ) ; printf ( "Unutma<S2SV_blank>tas<S2SV_blank>icin<S2SV_blank>1<S2SV_blank>makas<S2SV_blank>icin<S2SV_blank>2<S2SV_blank>kagit<S2SV_blank>icin<S2SV_blank>3.\\n" ) ; printf ( "Musabakayi<S2SV_blank>bitirmek<S2SV_blank>icin<S2SV_blank>4<S2SV_blank>tuslamalisin.\\n\\n\\n" ) ; while ( secim != 4 ) { printf ( "Bir<S2SV_blank>acik<S2SV_blank>yakaladin<S2SV_blank>yap<S2SV_blank>hamleni!!!\\n\\n" ) ; scanf ( "%d" , & secim ) ; <S2SV_StartBug> switch ( o ) <S2SV_EndBug> { case 1 : if ( secim == 1 ) { printf ( "Tas<S2SV_blank>roketleriniz<S2SV_blank>havada<S2SV_blank>carpisti<S2SV_blank>ve<S2SV_blank>ortada<S2SV_blank>patladi.\\n" ) ; printf ( "Yenisemediniz!<S2SV_blank>Hemen<S2SV_blank>toparlan<S2SV_blank>ve<S2SV_blank>yeni<S2SV_blank>bir<S2SV_blank>acik<S2SV_blank>kolla.\\n" ) ; beraberlik ++ ; skor += 1 ; } if ( secim == 2 ) { printf ( "Hananin<S2SV_blank>tas<S2SV_blank>roketini<S2SV_blank>atlattin<S2SV_blank>ve<S2SV_blank>kagit<S2SV_blank>patlayicini<S2SV_blank>arkasina<S2SV_blank>yerlestirdin\\n" ) ; printf ( "Bip<S2SV_blank>..<S2SV_blank>Bip<S2SV_blank>..<S2SV_blank>Bip<S2SV_blank>..<S2SV_blank>BOOM\\n" ) ; printf ( "Bu<S2SV_blank>onu<S2SV_blank>sersemletti<S2SV_blank>aferin.\\n" ) ; printf ( "Dikkati<S2SV_blank>elden<S2SV_blank>birakma<S2SV_blank>ve<S2SV_blank>yeni<S2SV_blank>bir<S2SV_blank>firsat<S2SV_blank>bul!\\n\\n\\n" ) ; skor += 3 ; galibiyet ++ ; } if ( secim == 3 ) { printf ( "Ahhh!<S2SV_blank>Anlik<S2SV_blank>bir<S2SV_blank>dikkatsizlik<S2SV_blank>sana<S2SV_blank>pahaliya<S2SV_blank>mal<S2SV_blank>oldu.\\n" ) ; printf ( "Makas-droidin<S2SV_blank>kontrolunu<S2SV_blank>kaybettin<S2SV_blank>ve<S2SV_blank>roketin<S2SV_blank>hedefi<S2SV_blank>oldun.\\n" ) ; printf ( "Yaralarini<S2SV_blank>sar<S2SV_blank>ve<S2SV_blank>hemen<S2SV_blank>savasa<S2SV_blank>don<S2SV_blank>Hana<S2SV_blank>durdurulmali!\\n\\n\\n" ) ; skor -= 2 ; yenilgi ++ ; } break ; case 2 : if ( secim == 1 ) { printf ( "Hananin<S2SV_blank>kagit<S2SV_blank>jiletleri<S2SV_blank>tas<S2SV_blank>duvarlarindan<S2SV_blank>gecti.\\n" ) ; printf ( "Sol<S2SV_blank>kolun<S2SV_blank>kesiklerle<S2SV_blank>dolu<S2SV_blank>ama<S2SV_blank>aylaklik<S2SV_blank>yapacak<S2SV_blank>zaman<S2SV_blank>yok!!\\n" ) ; printf ( "Hananin<S2SV_blank>omzunda<S2SV_blank>bir<S2SV_blank>kivilcim<S2SV_blank>kesfettin<S2SV_blank>belki<S2SV_blank>bunu<S2SV_blank>degerlendirebilirsin.\\n\\n\\n" ) ; skor -= 2 ; yenilgi ++ ; } if ( secim == 2 ) { printf ( "Kagittan<S2SV_blank>tsunamin<S2SV_blank>hanain<S2SV_blank>kagit<S2SV_blank>gemilerini<S2SV_blank>batiramadi.\\n" ) ; printf ( "Bu<S2SV_blank>tur<S2SV_blank>galip<S2SV_blank>yok<S2SV_blank>ama<S2SV_blank>vazgecemezsin.\\n" ) ; printf ( "Soluklan<S2SV_blank>ve<S2SV_blank>yeni<S2SV_blank>hamleni<S2SV_blank>dusun.\\n\\n\\n" ) ; skor += 1 ; beraberlik ++ ; } if ( secim == 3 ) { printf ( "Hananin<S2SV_blank>kagit<S2SV_blank>kopyalarini<S2SV_blank>makas<S2SV_blank>kilicinla<S2SV_blank>kestin<S2SV_blank>ve<S2SV_blank>gercek<S2SV_blank>hanaya<S2SV_blank>ulastin.\\n" ) ; printf ( "Bi<S2SV_blank>anda<S2SV_blank>arkasina<S2SV_blank>gectin<S2SV_blank>ve<S2SV_blank>devrelerinin<S2SV_blank>bazilarini<S2SV_blank>kesip<S2SV_blank>attın.\\n" ) ; printf ( "Bu<S2SV_blank>eski<S2SV_blank>moda<S2SV_blank>silahlarin<S2SV_blank>hala<S2SV_blank>ise<S2SV_blank>yaramasi<S2SV_blank>cok<S2SV_blank>ilginc<S2SV_blank>degil<S2SV_blank>mi<S2SV_blank>?\\n" ) ; printf ( "Mesafenizi<S2SV_blank>yeniden<S2SV_blank>ayarladin<S2SV_blank>ve<S2SV_blank>bi<S2SV_blank>atak<S2SV_blank>sansi<S2SV_blank>beklemeye<S2SV_blank>basladin\\n\\n\\n" ) ; skor += 3 ; galibiyet ++ ; } break ; case 3 : if ( secim == 1 ) { printf ( "Tas<S2SV_blank>ellerinle<S2SV_blank>hananin<S2SV_blank>makas-dronlarini<S2SV_blank>yakaladin<S2SV_blank>ve<S2SV_blank>birbirlerine<S2SV_blank>vurarak<S2SV_blank>yok<S2SV_blank>ettin.\\n" ) ; printf ( "Bu<S2SV_blank>sana<S2SV_blank>da<S2SV_blank>biraz<S2SV_blank>vahsi<S2SV_blank>gelmedi<S2SV_blank>mi<S2SV_blank>?\\n" ) ; printf ( "Hana<S2SV_blank>ne<S2SV_blank>oldugunu<S2SV_blank>anlayamadan<S2SV_blank>bir<S2SV_blank>strateji<S2SV_blank>bulmalisin\\n\\n\\n" ) ; skor += 3 ; galibiyet ++ ; } if ( secim == 2 ) { printf ( "Celiklerin<S2SV_blank>carpismasiyla<S2SV_blank>kulaklari<S2SV_blank>tirmalayan<S2SV_blank>bir<S2SV_blank>ses<S2SV_blank>cikti.\\n" ) ; printf ( "Kivilcimlar<S2SV_blank>ve<S2SV_blank>toz<S2SV_blank>bulutu<S2SV_blank>kalktiginda<S2SV_blank>hasar<S2SV_blank>alanin<S2SV_blank>olmadigi<S2SV_blank>anlasildi\\n" ) ; printf ( "Hana<S2SV_blank>sana<S2SV_blank>dehset<S2SV_blank>dolu<S2SV_blank>gozlerle<S2SV_blank>bakti\\n" ) ; printf ( "Yiktigi<S2SV_blank>sehirlerin<S2SV_blank>intikamini<S2SV_blank>alacagina<S2SV_blank>yemin<S2SV_blank>ettin.\\n\\n\\n" ) ; skor += 1 ; beraberlik ++ ; } if ( secim == 3 ) { printf ( "Kagit<S2SV_blank>kalkanin<S2SV_blank>kolayca<S2SV_blank>kesildi!\\n" ) ; printf ( "Kim<S2SV_blank>kagittan<S2SV_blank>kalkan<S2SV_blank>yapar<S2SV_blank>ki<S2SV_blank>zaten<S2SV_blank>?\\n" ) ; printf ( "Güclükle<S2SV_blank>yerinden<S2SV_blank>kalkmayi<S2SV_blank>basardin.\\n\\n\\n" ) ; skor -= 1 ; yenilgi ++ ; } break ; } int onceki = hana ; hana = rand ( ) ; <S2SV_StartBug> karmahana = hana + rand ( ) ; <S2SV_EndBug> if ( karmahana % 2 == 0 ) { while ( hana == onceki ) { hana = ( rand ( ) % 3 ) + 1 ; } } else hana = ( rand ( ) % 3 ) + 1 ; o = hana ; } } | <S2SV_ModStart> void oyun ( void ) { int o ; <S2SV_ModEnd> printf ( "O<S2SV_blank>azili<S2SV_blank>robotla<S2SV_blank>karsi<S2SV_blank>karsiyasin.\\n" <S2SV_ModStart> secim ) ; o = hana_secim <S2SV_ModEnd> ( ) ; <S2SV_ModStart> ( ) ; kapisma ( secim , o ) <S2SV_ModEnd> ; } } |
2,999 | CWE-000 static void DisplayPrect ( Tk_PathCanvas canvas , Tk_PathItem * itemPtr , Display * display , Drawable drawable , int x , int y , int width , int height ) { PrectItem * prectPtr = ( PrectItem * ) itemPtr ; TMatrix m = GetCanvasTMatrix ( canvas ) ; PathAtom * atomPtr ; Tk_PathStyle style ; TkPathSetCoordOffsets ( m . tx , m . ty ) ; style = TkPathCanvasInheritStyle ( itemPtr , 0 ) ; atomPtr = MakePathAtoms ( prectPtr ) ; TkPathDrawPath ( Tk_PathCanvasTkwin ( canvas ) , drawable , atomPtr , <S2SV_StartBug> & style , & m , & prectPtr -> rect ) ; <S2SV_EndBug> TkPathFreeAtoms ( atomPtr ) ; TkPathCanvasFreeInheritedStyle ( & style ) ; } | <S2SV_ModStart> m , & itemPtr -> bbox <S2SV_ModEnd> ) ; TkPathFreeAtoms |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.