Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
5,400 | CWE-000 void mlx5_start_health_poll ( struct mlx5_core_dev * dev ) { struct mlx5_core_health * health = & dev -> priv . health ; init_timer ( & health -> timer ) ; <S2SV_StartBug> health -> sick = 0 ; <S2SV_EndBug> health -> health = & dev -> iseg -> health ; health -> health_counter = & dev -> iseg -> health_counter ; setup_timer ( & health -> timer , poll_health , ( unsigned long ) dev ) ; mod_timer ( & health -> timer , round_jiffies ( jiffies + MLX5_HEALTH_POLL_INTERVAL ) ) ; } | <S2SV_ModStart> sick = 0 ; clear_bit ( MLX5_DROP_NEW_HEALTH_WORK , & health -> flags ) |
5,401 | CWE-000 int main ( ) { printf ( "Specify<S2SV_blank>game<S2SV_blank>setting<S2SV_blank>or<S2SV_blank>type<S2SV_blank>\'start\'<S2SV_blank>to<S2SV_blank>begin<S2SV_blank>a<S2SV_blank>game<S2SV_blank>with<S2SV_blank>the<S2SV_blank>current<S2SV_blank>setting:\\n" ) ; CHESS_MATCH * match = createNewChessMatch ( ) ; if ( match == NULL ) { return 0 ; } <S2SV_StartBug> bool initGame = initiateChessGame ( match ) ; <S2SV_EndBug> if ( initGame == false ) { destroyChessMatch ( match ) ; return 0 ; } printf ( "The<S2SV_blank>Game<S2SV_blank>has<S2SV_blank>initiated\\n" ) ; printChessGameBoard ( match -> game ) ; } | <S2SV_ModStart> = initiateChessGame ( & |
5,402 | CWE-000 static int32_t msm_sensor_driver_create_v4l_subdev ( struct msm_sensor_ctrl_t * s_ctrl ) { int32_t rc = 0 ; uint32_t session_id = 0 ; rc = camera_init_v4l2 ( & s_ctrl -> pdev -> dev , & session_id ) ; if ( rc < 0 ) { pr_err ( "failed:<S2SV_blank>camera_init_v4l2<S2SV_blank>rc<S2SV_blank>%d" , rc ) ; return rc ; } CDBG ( "rc<S2SV_blank>%d<S2SV_blank>session_id<S2SV_blank>%d" , rc , session_id ) ; s_ctrl -> sensordata -> sensor_info -> session_id = session_id ; v4l2_subdev_init ( & s_ctrl -> msm_sd . sd , s_ctrl -> sensor_v4l2_subdev_ops ) ; snprintf ( s_ctrl -> msm_sd . sd . name , sizeof ( s_ctrl -> msm_sd . sd . name ) , "%s" , s_ctrl -> sensordata -> sensor_name ) ; v4l2_set_subdevdata ( & s_ctrl -> msm_sd . sd , s_ctrl -> pdev ) ; s_ctrl -> msm_sd . sd . flags |= V4L2_SUBDEV_FL_HAS_DEVNODE ; media_entity_init ( & s_ctrl -> msm_sd . sd . entity , 0 , NULL , 0 ) ; s_ctrl -> msm_sd . sd . entity . type = MEDIA_ENT_T_V4L2_SUBDEV ; s_ctrl -> msm_sd . sd . entity . group_id = MSM_CAMERA_SUBDEV_SENSOR ; s_ctrl -> msm_sd . sd . entity . name = s_ctrl -> msm_sd . sd . name ; s_ctrl -> msm_sd . close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x3 ; msm_sd_register ( & s_ctrl -> msm_sd ) ; msm_cam_copy_v4l2_subdev_fops ( & msm_sensor_v4l2_subdev_fops ) ; <S2SV_StartBug> # ifdef CONFIG_COMPAT <S2SV_EndBug> msm_sensor_v4l2_subdev_fops . compat_ioctl32 = msm_sensor_subdev_fops_ioctl ; # endif s_ctrl -> msm_sd . sd . devnode -> fops = & msm_sensor_v4l2_subdev_fops ; return rc ; } | <S2SV_ModStart> msm_sensor_v4l2_subdev_fops ) ; rc = msm_sd_register ( & s_ctrl -> msm_sd ) ; if ( rc < 0 ) { pr_err ( "failed:<S2SV_blank>msm_sd_register<S2SV_blank>rc<S2SV_blank>%d" , rc ) ; return rc ; } msm_sensor_v4l2_subdev_fops = v4l2_subdev_fops ; |
5,403 | CWE-000 static int fixup_msghdr ( REF struct msghdr * * pmsghdr ) { int result = 0 ; bool is_valid_ptr ; if ( fixup_ptr ( REF ( void * * ) pmsghdr , OUT & is_valid_ptr ) < 0 ) result = - 2 ; if ( ! is_valid_ptr ) return - 1 ; struct msghdr * msghdr = * pmsghdr ; <S2SV_StartBug> g_is_running_nested_fixups = true ; <S2SV_EndBug> LOG ( "Fixing<S2SV_blank>up<S2SV_blank>msghdr:\\n" ) ; DUMP_VAR_MEM ( * msghdr ) ; <S2SV_StartBug> LOG ( "msg_name...\\n" ) ; <S2SV_EndBug> <S2SV_StartBug> if ( fixup_ptr ( ( void * * ) & msghdr -> msg_name , OUT_IGNORE ) < 0 ) { <S2SV_EndBug> LOG ( "Failed<S2SV_blank>to<S2SV_blank>fix-up<S2SV_blank>msg_name<S2SV_blank>of<S2SV_blank>msghdr<S2SV_blank>%p\\n" , ( void * ) msghdr ) ; result -- ; } LOG ( "msg_iov...\\n" ) ; <S2SV_StartBug> if ( fixup_iovec_array ( REF & msghdr -> msg_iov , msghdr -> msg_iovlen ) != 0 ) { <S2SV_EndBug> LOG ( "Failed<S2SV_blank>to<S2SV_blank>fix-up<S2SV_blank>msg_iov<S2SV_blank>of<S2SV_blank>msghdr<S2SV_blank>%p\\n" , ( void * ) msghdr ) ; result -- ; } LOG ( "msg_control...\\n" ) ; <S2SV_StartBug> if ( fixup_ptr ( msghdr -> msg_control , OUT_IGNORE ) < 0 ) { <S2SV_EndBug> LOG ( "Failed<S2SV_blank>to<S2SV_blank>fix-up<S2SV_blank>msg_control<S2SV_blank>of<S2SV_blank>msghdr<S2SV_blank>%p\\n" , ( void * ) msghdr ) ; result -- ; } <S2SV_StartBug> g_is_running_nested_fixups = false ; <S2SV_EndBug> LOG ( "Done,<S2SV_blank>result:<S2SV_blank>%d\\n" , result ) ; return result ; } | <S2SV_ModStart> * pmsghdr ; <S2SV_ModEnd> LOG ( "Fixing<S2SV_blank>up<S2SV_blank>msghdr:\\n" <S2SV_ModStart> msghdr ) ; FIXUP_SCOPE ( pmsghdr ) { <S2SV_ModStart> ( fixup_ptr ( REF <S2SV_ModStart> -> msg_iovlen ) < <S2SV_ModEnd> 0 ) { <S2SV_ModStart> ( fixup_ptr ( REF & <S2SV_ModStart> -- ; } } <S2SV_ModEnd> LOG ( "Done,<S2SV_blank>result:<S2SV_blank>%d\\n" |
5,404 | CWE-000 void soft_reset_device ( struct device * dev ) { <S2SV_StartBug> add_interupt_event ( HW2_INT , 0 ) ; <S2SV_EndBug> <S2SV_StartBug> add_interupt_event ( NMI_INT , 50000000 ) ; <S2SV_EndBug> } | <S2SV_ModStart> dev ) { add_interrupt_event ( & dev -> r4300 . cp0 , <S2SV_ModEnd> HW2_INT , 0 <S2SV_ModStart> 0 ) ; add_interrupt_event ( & dev -> r4300 . cp0 , <S2SV_ModEnd> NMI_INT , 50000000 |
5,405 | CWE-000 void ce_buffer_node_free ( CeBufferNode_t * * head ) { CeBufferNode_t * itr = * head ; while ( itr ) { CeBufferNode_t * tmp = itr ; itr = itr -> next ; <S2SV_StartBug> free ( tmp -> buffer -> app_data ) ; <S2SV_EndBug> ce_buffer_free ( tmp -> buffer ) ; free ( tmp -> buffer ) ; free ( tmp ) ; } * head = NULL ; } | <S2SV_ModStart> -> next ; free_buffer_node <S2SV_ModEnd> ( tmp ) |
5,406 | CWE-000 static void load_themes ( GtkIconTheme * icon_theme ) { GtkIconThemePrivate * priv ; GDir * gdir ; gint base ; gchar * dir ; const gchar * file ; GTimeVal tv ; IconThemeDirMtime * dir_mtime ; GStatBuf stat_buf ; GList * d ; priv = icon_theme -> priv ; if ( priv -> current_theme ) insert_theme ( icon_theme , priv -> current_theme ) ; insert_theme ( icon_theme , DEFAULT_ICON_THEME ) ; insert_theme ( icon_theme , "gnome" ) ; insert_theme ( icon_theme , FALLBACK_ICON_THEME ) ; priv -> themes = g_list_reverse ( priv -> themes ) ; priv -> unthemed_icons = g_hash_table_new_full ( g_str_hash , g_str_equal , g_free , ( GDestroyNotify ) free_unthemed_icon ) ; for ( base = 0 ; base < icon_theme -> priv -> search_path_len ; base ++ ) { dir = icon_theme -> priv -> search_path [ base ] ; dir_mtime = g_slice_new ( IconThemeDirMtime ) ; <S2SV_StartBug> priv -> dir_mtimes = g_list_append ( priv -> dir_mtimes , dir_mtime ) ; <S2SV_EndBug> dir_mtime -> dir = g_strdup ( dir ) ; dir_mtime -> mtime = 0 ; dir_mtime -> exists = FALSE ; dir_mtime -> cache = NULL ; if ( g_stat ( dir , & stat_buf ) != 0 || ! S_ISDIR ( stat_buf . st_mode ) ) continue ; dir_mtime -> mtime = stat_buf . st_mtime ; dir_mtime -> exists = TRUE ; dir_mtime -> cache = gtk_icon_cache_new_for_path ( dir ) ; if ( dir_mtime -> cache != NULL ) continue ; gdir = g_dir_open ( dir , 0 , NULL ) ; if ( gdir == NULL ) continue ; while ( ( file = g_dir_read_name ( gdir ) ) ) add_unthemed_icon ( icon_theme , dir , file , FALSE ) ; g_dir_close ( gdir ) ; } <S2SV_StartBug> for ( d = priv -> resource_paths ; d ; d = d -> next ) <S2SV_EndBug> { gchar * * children ; gint i ; dir = d -> data ; children = g_resources_enumerate_children ( dir , 0 , NULL ) ; if ( ! children ) continue ; for ( i = 0 ; children [ i ] ; i ++ ) add_unthemed_icon ( icon_theme , dir , children [ i ] , TRUE ) ; g_strfreev ( children ) ; } priv -> themes_valid = TRUE ; g_get_current_time ( & tv ) ; priv -> last_stat_time = tv . tv_sec ; GTK_DISPLAY_NOTE ( icon_theme -> priv -> display , ICONTHEME , { GList * l ; GString * s ; s = g_string_new ( "Current<S2SV_blank>icon<S2SV_blank>themes<S2SV_blank>" ) ; for ( l = icon_theme -> priv -> themes ; l ; l = l -> next ) { IconTheme * theme = l -> data ; g_string_append ( s , theme -> name ) ; g_string_append_c ( s , '<S2SV_blank>' ) ; } g_message ( "%s" , s -> str ) ; g_string_free ( s , TRUE ) ; } ) ; } | <S2SV_ModStart> -> dir_mtimes = g_list_prepend <S2SV_ModEnd> ( priv -> <S2SV_ModStart> ) ; } priv -> dir_mtimes = g_list_reverse ( priv -> dir_mtimes ) ; |
5,407 | CWE-000 Token malar_next_token ( void ) { Token t = { 0 } ; unsigned char c ; int state = 0 ; short lexstart = 0 ; short lexend = 0 ; int accept = NOAS ; int isRelationalOperator = 0 ; while ( 1 ) { if ( ! sc_buf ) return generateErrorToken ( ) ; c = b_getc ( sc_buf ) ; switch ( c ) { case '\\0' : t . attribute . seof = SEOF1 ; t . code = SEOF_T ; return t ; case 255 : t . attribute . seof = SEOF2 ; t . code = SEOF_T ; return t ; case '\\n' : line ++ ; case '\\t' : case '<S2SV_blank>' : continue ; case '!' : c = b_getc ( sc_buf ) ; if ( c == '!' ) { while ( c != '\\n' ) c = b_getc ( sc_buf ) ; line ++ ; continue ; } else { t . attribute . err_lex [ 0 ] = '!' ; t . attribute . err_lex [ 1 ] = c ; <S2SV_StartBug> while ( c != '\\n' ) <S2SV_EndBug> <S2SV_StartBug> c = b_getc ( sc_buf ) ; <S2SV_EndBug> line ++ ; t . code = ERR_T ; return t ; } case '(' : t . code = LPR_T ; return t ; case ')' : t . code = RPR_T ; return t ; case '{' : t . code = LBR_T ; return t ; case '}' : t . code = RBR_T ; return t ; case ',' : t . code = COM_T ; return t ; case ';' : t . code = EOS_T ; return t ; case '+' : t . code = ART_OP_T ; t . attribute . arr_op = PLUS ; return t ; case '-' : t . code = ART_OP_T ; t . attribute . arr_op = MINUS ; return t ; case '/' : t . code = ART_OP_T ; t . attribute . arr_op = DIV ; return t ; case '*' : t . code = ART_OP_T ; t . attribute . arr_op = MULT ; return t ; case '<' : c = b_getc ( sc_buf ) ; if ( c == '>' ) t . attribute . rel_op = NE ; else { b_retract ( sc_buf ) ; t . attribute . rel_op = LT ; } t . code = REL_OP_T ; return t ; case '>' : t . code = REL_OP_T ; t . attribute . rel_op = GT ; return t ; case '#' : t . code = SCC_OP_T ; return t ; case '=' : c = b_getc ( sc_buf ) ; if ( c == '=' ) { t . code = REL_OP_T ; t . attribute . rel_op = EQ ; } else { b_retract ( sc_buf ) ; t . code = ASS_OP_T ; } return t ; case '.' : isRelationalOperator = isAndOr ( ) ; if ( isRelationalOperator == RT_FAIL_1 ) return generateErrorToken ( ) ; if ( isRelationalOperator ) { if ( isRelationalOperator == 1 ) t . attribute . log_op = AND ; else if ( isRelationalOperator == 2 ) t . attribute . log_op = OR ; t . code = LOG_OP_T ; return t ; } } lexstart = b_mark ( sc_buf , b_getcoffset ( sc_buf ) - 1 ) ; <S2SV_StartBug> if ( lexstart == RT_FAIL_1 ) { <S2SV_EndBug> return generateErrorToken ( ) ; } short capacity ; <S2SV_StartBug> while ( accept == NOAS ) { <S2SV_EndBug> state = get_next_state ( state , c , & accept ) ; if ( accept == ASWR || accept == ASNR ) break ; c = b_getc ( sc_buf ) ; } if ( accept == ASWR ) { if ( b_retract ( sc_buf ) == RT_FAIL_1 ) return generateErrorToken ( ) ; } lexend = b_getcoffset ( sc_buf ) ; if ( lexend == RT_FAIL_1 ) return generateErrorToken ( ) ; capacity = lexend - lexstart ; lex_buf = b_allocate ( capacity + 1 , 0 , 'f' ) ; if ( ! lex_buf ) return generateErrorToken ( ) ; if ( ( b_reset ( sc_buf ) ) == RT_FAIL_1 ) return generateErrorToken ( ) ; for ( int i = lexstart ; i < lexend ; i ++ ) { c = b_getc ( sc_buf ) ; if ( ! b_addc ( lex_buf , c ) ) return generateErrorToken ( ) ; } b_addc ( lex_buf , '\\0' ) ; t = aa_table [ state ] ( b_location ( lex_buf , 0 ) ) ; b_free ( lex_buf ) ; return t ; } } | <S2SV_ModStart> c != '\\n' && c != '\\0' && c != 255 ) { <S2SV_ModEnd> c = b_getc <S2SV_ModStart> sc_buf ) ; } <S2SV_ModStart> 1 ) ; <S2SV_ModEnd> short capacity ; <S2SV_ModStart> ; while ( 1 <S2SV_ModEnd> ) { state |
5,408 | CWE-000 SCM_DEFINE ( scm_fluid_ref , "fluid-ref" , 1 , 0 , 0 , ( SCM fluid ) , "Return<S2SV_blank>the<S2SV_blank>value<S2SV_blank>associated<S2SV_blank>with<S2SV_blank>@var{fluid}<S2SV_blank>in<S2SV_blank>the<S2SV_blank>current\\n" "dynamic<S2SV_blank>root.<S2SV_blank><S2SV_blank>If<S2SV_blank>@var{fluid}<S2SV_blank>has<S2SV_blank>not<S2SV_blank>been<S2SV_blank>set,<S2SV_blank>then<S2SV_blank>return\\n" <S2SV_StartBug> "@code{#f}." ) <S2SV_EndBug> # define FUNC_NAME s_scm_fluid_ref { SCM ret ; SCM_VALIDATE_FLUID ( 1 , fluid ) ; ret = fluid_ref ( SCM_I_CURRENT_THREAD -> dynamic_state , fluid ) ; if ( SCM_UNBNDP ( ret ) ) scm_misc_error ( "fluid-ref" , "unbound<S2SV_blank>fluid:<S2SV_blank>~S" , scm_list_1 ( fluid ) ) ; return ret ; } | <S2SV_ModStart> , "Return<S2SV_blank>the<S2SV_blank>value<S2SV_blank>associated<S2SV_blank>with<S2SV_blank>@var{fluid}<S2SV_blank>in<S2SV_blank>the<S2SV_blank>current\\n" "dynamic<S2SV_blank>root.<S2SV_blank><S2SV_blank>If<S2SV_blank>@var{fluid}<S2SV_blank>has<S2SV_blank>not<S2SV_blank>been<S2SV_blank>set,<S2SV_blank>then<S2SV_blank>return\\n" "its<S2SV_blank>default<S2SV_blank>value." <S2SV_ModEnd> ) # define |
5,409 | CWE-000 const char * necro_lex_token_type_string ( NECRO_LEX_TOKEN_TYPE token ) { switch ( token ) { case NECRO_LEX_ADD : return "ADD" ; case NECRO_LEX_SUB : return "SUB" ; case NECRO_LEX_MUL : return "MUL" ; case NECRO_LEX_DIV : return "DIV" ; case NECRO_LEX_MOD : return "MOD" ; case NECRO_LEX_GT : return "GT" ; case NECRO_LEX_LT : return "LT" ; case NECRO_LEX_GTE : return "GTE" ; case NECRO_LEX_LTE : return "LTE" ; case NECRO_LEX_COLON : return "COLON" ; case NECRO_LEX_SEMI_COLON : return "SEMI_COLON" ; case NECRO_LEX_INTEGER_LITERAL : return "INT" ; case NECRO_LEX_FLOAT_LITERAL : return "FLOAT" ; case NECRO_LEX_IDENTIFIER : return "IDENTIFIER" ; case NECRO_LEX_LEFT_ARROW : return "LEFT_ARROW" ; case NECRO_LEX_RIGHT_ARROW : return "RIGHT_ARROW" ; case NECRO_LEX_FAT_RIGHT_ARROW : return "FAT_RIGHT_ARROW" ; case NECRO_LEX_LEFT_BRACKET : return "LEFT_BRACKET" ; case NECRO_LEX_RIGHT_BRACKET : return "RIGHT_BRACKET" ; case NECRO_LEX_LEFT_PAREN : return "LEFT_PAREN" ; case NECRO_LEX_RIGHT_PAREN : return "RIGHT_PAREN" ; case NECRO_LEX_LEFT_BRACE : return "LEFT_BRACE" ; case NECRO_LEX_RIGHT_BRACE : return "RIGHT_BRACE" ; case NECRO_LEX_COMMA : return "COMMA" ; case NECRO_LEX_UNDER_SCORE : return "UNDER_SCORE" ; case NECRO_LEX_EQUALS : return "EQUALS" ; case NECRO_LEX_NOT_EQUALS : return "NOT_EQUALS" ; case NECRO_LEX_ASSIGN : return "ASSIGN" ; case NECRO_LEX_QUESTION_MARK : return "QUESTION_MARK" ; case NECRO_LEX_EXCLAMATION : return "EXCLAMATION" ; case NECRO_LEX_HASH : return "HASH" ; case NECRO_LEX_DOUBLE_COLON : return "DOUBLE_COLON" ; case NECRO_LEX_LEFT_SHIFT : return "LEFT_SHIFT" ; case NECRO_LEX_RIGHT_SHIFT : return "RIGHT_SHIFT" ; case NECRO_LEX_PIPE : return "PIPE" ; case NECRO_LEX_FORWARD_PIPE : return "FORWARD_PIPE" ; case NECRO_LEX_BACK_PIPE : return "BACK_PIPE" ; case NECRO_LEX_DOT : return "DOT" ; case NECRO_LEX_DOUBLE_DOT : return "DOUBLE_DOT" ; case NECRO_LEX_AMPERSAND : return "AMPERSAND" ; case NECRO_LEX_AT : return "AT" ; case NECRO_LEX_DOLLAR : return "DOLLAR" ; case NECRO_LEX_CARET : return "CARET" ; case NECRO_LEX_BACK_SLASH : return "BACK_SLASH" ; case NECRO_LEX_TILDE : return "TILDE" ; case NECRO_LEX_AND : return "AND" ; case NECRO_LEX_OR : return "OR" ; case NECRO_LEX_BIND_RIGHT : return "BIND_RIGHT" ; case NECRO_LEX_BIND_LEFT : return "BIND_LEFT" ; case NECRO_LEX_UNIT : return "UNIT" ; case NECRO_LEX_DOUBLE_EXCLAMATION : return "DOUBLE_EXCLAMATION" ; case NECRO_LEX_APPEND : return "APPEND" ; case NECRO_LEX_ACCENT : return "ACCENT" ; case NECRO_LEX_END_OF_STREAM : return "END<S2SV_blank>OF<S2SV_blank>STREAM" ; case NECRO_LEX_CASE : return "CASE" ; case NECRO_LEX_OF : return "OF" ; case NECRO_LEX_CLASS : return "CLASS" ; case NECRO_LEX_DATA : return "DATA" ; case NECRO_LEX_DERIVING : return "DERIVING" ; case NECRO_LEX_FORALL : return "FORALL" ; case NECRO_LEX_DO : return "DO," ; case NECRO_LEX_IF : return "IF" ; case NECRO_LEX_ELSE : return "ELSE" ; case NECRO_LEX_THEN : return "THEN" ; case NECRO_LEX_IMPORT : return "IMPORT" ; case NECRO_LEX_INSTANCE : return "INSTANCE" ; case NECRO_LEX_LET : return "LET" ; case NECRO_LEX_IN : return "IN" ; case NECRO_LEX_MODULE : return "MODULE" ; case NECRO_LEX_NEWTYPE : return "NEWTYPE" ; case NECRO_LEX_TYPE : return "TYPE" ; case NECRO_LEX_PAT : return "PAT" ; <S2SV_StartBug> case NECRO_LEX_DELAY : return "DELAY" ; <S2SV_EndBug> case NECRO_LEX_TRIM_DELAY : return "TRIM_DELAY" ; case NECRO_LEX_WHERE : return "WHERE" ; default : return "UNRECOGNIZED<S2SV_blank>TOKEN" ; } } | <S2SV_ModStart> "PAT" ; case <S2SV_ModEnd> NECRO_LEX_WHERE : return |
5,410 | CWE-000 static int wcn36xx_dxe_ch_alloc_skb ( struct wcn36xx * wcn , struct wcn36xx_dxe_ch * wcn_ch ) { int i ; struct wcn36xx_dxe_ctl * cur_ctl = NULL ; cur_ctl = wcn_ch -> head_blk_ctl ; for ( i = 0 ; i < wcn_ch -> desc_num ; i ++ ) { <S2SV_StartBug> wcn36xx_dxe_fill_skb ( wcn -> dev , cur_ctl ) ; <S2SV_EndBug> cur_ctl = cur_ctl -> next ; } return 0 ; } | <S2SV_ModStart> dev , cur_ctl , GFP_KERNEL |
5,411 | CWE-000 static void snd_ak4113_free ( struct ak4113 * chip ) { <S2SV_StartBug> chip -> init = 1 ; <S2SV_EndBug> mb ( ) ; cancel_delayed_work_sync ( & chip -> work ) ; kfree ( chip ) ; } | <S2SV_ModStart> chip ) { atomic_inc ( & chip -> wq_processing <S2SV_ModEnd> ) ; cancel_delayed_work_sync |
5,412 | CWE-000 static REBOOL Subparse_Throws ( REBOOL * interrupted_out , REBVAL * out , RELVAL * input , REBSPC * input_specifier , const RELVAL * rules , REBSPC * rules_specifier , REBCNT find_flags ) { assert ( ANY_ARRAY ( rules ) ) ; assert ( ANY_SERIES ( input ) ) ; if ( VAL_INDEX ( rules ) >= VAL_LEN_HEAD ( rules ) ) { * interrupted_out = FALSE ; Init_Integer ( out , VAL_INDEX ( input ) ) ; return FALSE ; } DECLARE_FRAME ( f ) ; SET_END ( out ) ; f -> out = out ; f -> gotten = END_NODE ; SET_FRAME_VALUE ( f , VAL_ARRAY_AT ( rules ) ) ; f -> specifier = Derive_Specifier ( rules_specifier , rules ) ; <S2SV_StartBug> f -> source . vaptr = NULL ; <S2SV_EndBug> <S2SV_StartBug> f -> source . array = VAL_ARRAY ( rules ) ; <S2SV_EndBug> <S2SV_StartBug> f -> source . index = VAL_INDEX ( rules ) + 1 ; <S2SV_EndBug> <S2SV_StartBug> f -> source . pending = f -> value + 1 ; <S2SV_EndBug> f -> flags = Endlike_Header ( 0 ) ; Push_Frame_Core ( f ) ; Reuse_Varlist_If_Available ( f ) ; Push_Action ( f , NAT_ACTION ( subparse ) , UNBOUND ) ; Begin_Action ( f , Canon ( SYM_SUBPARSE ) , m_cast ( REBVAL * , END_NODE ) ) ; f -> param = END_NODE ; f -> arg = m_cast ( REBVAL * , END_NODE ) ; assert ( f -> refine == END_NODE ) ; f -> special = END_NODE ; # if defined ( NDEBUG ) assert ( ACT_NUM_PARAMS ( NAT_ACTION ( subparse ) ) == 2 ) ; # else assert ( ACT_NUM_PARAMS ( NAT_ACTION ( subparse ) ) == 3 ) ; Prep_Stack_Cell ( FRM_ARGS_HEAD ( f ) + 2 ) ; Init_Nulled ( FRM_ARGS_HEAD ( f ) + 2 ) ; # endif Prep_Stack_Cell ( FRM_ARGS_HEAD ( f ) + 0 ) ; Derelativize ( FRM_ARGS_HEAD ( f ) + 0 , input , input_specifier ) ; Prep_Stack_Cell ( FRM_ARGS_HEAD ( f ) + 1 ) ; Init_Integer ( FRM_ARGS_HEAD ( f ) + 1 , find_flags ) ; REB_R r = N_subparse ( f ) ; assert ( NOT_END ( out ) ) ; Drop_Action ( f ) ; Drop_Frame_Core ( f ) ; if ( r == R_THROWN ) { assert ( THROWN ( out ) ) ; if ( IS_ACTION ( out ) ) { if ( VAL_ACTION ( out ) == NAT_ACTION ( parse_reject ) ) { CATCH_THROWN ( out , out ) ; assert ( IS_BLANK ( out ) ) ; * interrupted_out = TRUE ; return FALSE ; } if ( VAL_ACTION ( out ) == NAT_ACTION ( parse_accept ) ) { CATCH_THROWN ( out , out ) ; assert ( IS_INTEGER ( out ) ) ; * interrupted_out = TRUE ; return FALSE ; } } return TRUE ; } assert ( r == out ) ; * interrupted_out = FALSE ; return FALSE ; } | <S2SV_ModStart> f -> source -> vaptr = nullptr <S2SV_ModEnd> ; f -> <S2SV_ModStart> f -> source -> <S2SV_ModEnd> array = VAL_ARRAY <S2SV_ModStart> f -> source -> <S2SV_ModEnd> index = VAL_INDEX <S2SV_ModStart> f -> source -> <S2SV_ModEnd> pending = f |
5,413 | CWE-000 void dht11_sendStartDone ( void * data ) { dht11 * this = ( dht11 * ) data ; <S2SV_StartBug> this -> setOutput ( 0 ) ; <S2SV_EndBug> <S2SV_StartBug> this -> out ( 255 ) ; <S2SV_EndBug> enable_external_interrupt_input ( this -> extIrq , falling ) ; dht11_setState ( this , DHT11_WAITING_FOR_ACK ) ; } | <S2SV_ModStart> -> setOutput ( io_PIN_INPUT <S2SV_ModEnd> ) ; this <S2SV_ModStart> -> out ( io_PIN_HIGH <S2SV_ModEnd> ) ; enable_external_interrupt_input |
5,414 | CWE-000 static int redis_pool_cron ( struct aeEventLoop * el , long long id , void * privdata ) { redis_pool * pool = privdata ; redis_connection * conn , * tvar ; int * hz = & pool -> hz ; int * cronloops = & pool -> cronloops ; GW_NOTUSED ( el ) ; GW_NOTUSED ( id ) ; run_with_period ( 1000 ) { TAILQ_FOREACH_SAFE ( conn , & pool -> conn_in_disconnect_q , conn_tqe , tvar ) { close_connection ( conn ) ; connect_redis ( pool , conn ) ; } } run_with_period ( LATENCY_STAT_SAMPLE_MSEC ) { dictIterator * di ; dictEntry * de ; track_latency_histogram ( & pool -> latency_histo ) ; di = dictGetIterator ( pool -> redis_servers ) ; while ( ( de = dictNext ( di ) ) != NULL ) { redis_server * server = dictGetVal ( de ) ; track_latency_stat ( & server -> latency_stat ) ; } dictReleaseIterator ( di ) ; } <S2SV_StartBug> run_with_period ( 100 ) <S2SV_EndBug> { <S2SV_StartBug> long long curtime = mstime ( ) ; <S2SV_EndBug> TAILQ_FOREACH_SAFE ( conn , & pool -> conn_in_service_q , conn_tqe , tvar ) { <S2SV_StartBug> if ( curtime - conn -> last_active_mstime < pool -> conn_inactive_timeout ) <S2SV_EndBug> { break ; } if ( conn -> nsendq + conn -> nrecvq > 0 ) { sds conn_info = get_sds_conn_info ( conn ) ; gwlog ( GW_WARNING , "Redis<S2SV_blank>is<S2SV_blank>not<S2SV_blank>responding.<S2SV_blank>elapsed:%lld,<S2SV_blank>%s" , <S2SV_StartBug> curtime - conn -> last_active_mstime , conn_info ) ; <S2SV_EndBug> sdsfree ( conn_info ) ; close_conn_and_reconfigure_pool ( conn ) ; } } } if ( pool -> stop_after_init && is_wait_init_time_expired ( pool ) ) { stop_wait_init ( pool ) ; } ( * cronloops ) ++ ; return 1000 / * hz ; } | <S2SV_ModStart> } run_with_period ( 500 <S2SV_ModEnd> ) { long <S2SV_ModStart> long long curtime , redline = pool -> conn_inactive_timeout ; curtime <S2SV_ModStart> tvar ) { long long rgap ; if ( conn -> nsendq + conn -> nrecvq == 0 ) { conn -> last_active_rts = conn -> last_active_wts = curtime ; continue ; } rgap = <S2SV_ModEnd> curtime - conn <S2SV_ModStart> - conn -> last_active_rts ; if ( rgap >= redline <S2SV_ModEnd> ) { sds <S2SV_ModStart> , "Redis<S2SV_blank>is<S2SV_blank>not<S2SV_blank>responding.<S2SV_blank>elapsed:%lld,<S2SV_blank>%s" , rgap <S2SV_ModEnd> , conn_info ) |
5,415 | CWE-000 static int mdss_dsi_ctrl_probe ( struct platform_device * pdev ) { int rc = 0 , i = 0 ; u32 index ; struct mdss_dsi_ctrl_pdata * ctrl_pdata = NULL ; struct device_node * dsi_pan_node = NULL ; <S2SV_StartBug> char panel_cfg [ MDSS_MAX_PANEL_LEN ] ; <S2SV_EndBug> const char * ctrl_name ; bool cmd_cfg_cont_splash = true ; struct mdss_panel_cfg * pan_cfg = NULL ; struct mdss_util_intf * util ; util = mdss_get_util_intf ( ) ; if ( util == NULL ) { pr_err ( "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>mdss<S2SV_blank>utility<S2SV_blank>functions\\n" ) ; return - ENODEV ; } if ( ! util -> mdp_probe_done ) { pr_err ( "%s:<S2SV_blank>MDP<S2SV_blank>not<S2SV_blank>probed<S2SV_blank>yet!\\n" , __func__ ) ; return - EPROBE_DEFER ; } if ( ! pdev -> dev . of_node ) { pr_err ( "DSI<S2SV_blank>driver<S2SV_blank>only<S2SV_blank>supports<S2SV_blank>device<S2SV_blank>tree<S2SV_blank>probe\\n" ) ; return - ENOTSUPP ; } pan_cfg = util -> panel_intf_type ( MDSS_PANEL_INTF_HDMI ) ; if ( IS_ERR ( pan_cfg ) ) { return PTR_ERR ( pan_cfg ) ; } else if ( pan_cfg ) { pr_debug ( "%s:<S2SV_blank>HDMI<S2SV_blank>is<S2SV_blank>primary\\n" , __func__ ) ; return - ENODEV ; } ctrl_pdata = platform_get_drvdata ( pdev ) ; if ( ! ctrl_pdata ) { ctrl_pdata = devm_kzalloc ( & pdev -> dev , sizeof ( struct mdss_dsi_ctrl_pdata ) , GFP_KERNEL ) ; if ( ! ctrl_pdata ) { pr_err ( "%s:<S2SV_blank>FAILED:<S2SV_blank>cannot<S2SV_blank>alloc<S2SV_blank>dsi<S2SV_blank>ctrl\\n" , __func__ ) ; rc = - ENOMEM ; goto error_no_mem ; } platform_set_drvdata ( pdev , ctrl_pdata ) ; } ctrl_pdata -> mdss_util = util ; atomic_set ( & ctrl_pdata -> te_irq_ready , 0 ) ; ctrl_name = of_get_property ( pdev -> dev . of_node , "label" , NULL ) ; if ( ! ctrl_name ) pr_info ( "%s:%d,<S2SV_blank>DSI<S2SV_blank>Ctrl<S2SV_blank>name<S2SV_blank>not<S2SV_blank>specified\\n" , __func__ , __LINE__ ) ; else pr_info ( "%s:<S2SV_blank>DSI<S2SV_blank>Ctrl<S2SV_blank>name<S2SV_blank>=<S2SV_blank>%s\\n" , __func__ , ctrl_name ) ; rc = of_property_read_u32 ( pdev -> dev . of_node , "cell-index" , & index ) ; if ( rc ) { dev_err ( & pdev -> dev , "%s:<S2SV_blank>Cell-index<S2SV_blank>not<S2SV_blank>specified,<S2SV_blank>rc=%d\\n" , __func__ , rc ) ; goto error_no_mem ; } if ( index == 0 ) pdev -> id = 1 ; else pdev -> id = 2 ; rc = of_platform_populate ( pdev -> dev . of_node , NULL , NULL , & pdev -> dev ) ; if ( rc ) { dev_err ( & pdev -> dev , "%s:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>add<S2SV_blank>child<S2SV_blank>nodes,<S2SV_blank>rc=%d\\n" , __func__ , rc ) ; goto error_no_mem ; } rc = mdss_dsi_pinctrl_init ( pdev ) ; if ( rc ) pr_warn ( "%s:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>pin<S2SV_blank>resources\\n" , __func__ ) ; for ( i = 0 ; i < DSI_MAX_PM ; i ++ ) { rc = mdss_dsi_get_dt_vreg_data ( & pdev -> dev , & ctrl_pdata -> power_data [ i ] , i ) ; if ( rc ) { DEV_ERR ( "%s:<S2SV_blank>\'%s\'<S2SV_blank>get_dt_vreg_data<S2SV_blank>failed.rc=%d\\n" , __func__ , __mdss_dsi_pm_name ( i ) , rc ) ; goto error_vreg ; } } ctrl_pdata -> panel_bias_vreg = of_property_read_bool ( pdev -> dev . of_node , "qcom,dsi-panel-bias-vreg" ) ; # ifdef VENDOR_EDIT ctrl_pdata -> use_external_ic_power = of_property_read_bool ( pdev -> dev . of_node , "qcom,use_external_ic_power" ) ; # endif rc = mdss_dsi_get_panel_cfg ( panel_cfg , ctrl_pdata ) ; if ( ! rc ) pr_warn ( "%s:%d:dsi<S2SV_blank>specific<S2SV_blank>cfg<S2SV_blank>not<S2SV_blank>present\\n" , __func__ , __LINE__ ) ; dsi_pan_node = mdss_dsi_find_panel_of_node ( pdev , panel_cfg ) ; if ( ! dsi_pan_node ) { pr_err ( "%s:<S2SV_blank>can\'t<S2SV_blank>find<S2SV_blank>panel<S2SV_blank>node<S2SV_blank>%s\\n" , __func__ , panel_cfg ) ; goto error_pan_node ; } cmd_cfg_cont_splash = mdss_panel_get_boot_cfg ( ) ? true : false ; rc = mdss_dsi_panel_init ( dsi_pan_node , ctrl_pdata , cmd_cfg_cont_splash ) ; if ( rc ) { pr_err ( "%s:<S2SV_blank>dsi<S2SV_blank>panel<S2SV_blank>init<S2SV_blank>failed\\n" , __func__ ) ; goto error_pan_node ; } rc = dsi_panel_device_register ( dsi_pan_node , ctrl_pdata ) ; if ( rc ) { pr_err ( "%s:<S2SV_blank>dsi<S2SV_blank>panel<S2SV_blank>dev<S2SV_blank>reg<S2SV_blank>failed\\n" , __func__ ) ; goto error_pan_node ; } ctrl_pdata -> cmd_clk_ln_recovery_en = of_property_read_bool ( pdev -> dev . of_node , "qcom,dsi-clk-ln-recovery" ) ; if ( mdss_dsi_is_te_based_esd ( ctrl_pdata ) ) { rc = devm_request_irq ( & pdev -> dev , gpio_to_irq ( ctrl_pdata -> disp_te_gpio ) , hw_vsync_handler , IRQF_TRIGGER_FALLING , "VSYNC_GPIO" , ctrl_pdata ) ; if ( rc ) { pr_err ( "TE<S2SV_blank>request_irq<S2SV_blank>failed.\\n" ) ; goto error_pan_node ; } disable_irq ( gpio_to_irq ( ctrl_pdata -> disp_te_gpio ) ) ; } mdss_dsi_pm_qos_add_request ( ctrl_pdata ) ; pr_debug ( "%s:<S2SV_blank>Dsi<S2SV_blank>Ctrl->%d<S2SV_blank>initialized\\n" , __func__ , index ) ; return 0 ; error_pan_node : mdss_dsi_unregister_bl_settings ( ctrl_pdata ) ; of_node_put ( dsi_pan_node ) ; i -- ; error_vreg : for ( ; i >= 0 ; i -- ) mdss_dsi_put_dt_vreg_data ( & pdev -> dev , & ctrl_pdata -> power_data [ i ] ) ; error_no_mem : devm_kfree ( & pdev -> dev , ctrl_pdata ) ; return rc ; } | <S2SV_ModStart> panel_cfg [ MDSS_MAX_PANEL_LEN + 1 |
5,416 | CWE-000 int unfreeze_proc_exp_single_core_mode ( tracer * curr_tracer ) { struct timeval now ; s64 now_ns ; s64 start_ns ; int i = 0 ; unsigned long flags ; struct poll_helper_struct * task_poll_helper = NULL ; struct select_helper_struct * task_select_helper = NULL ; struct sleep_helper_struct * task_sleep_helper = NULL ; s64 rem_n_insns = 0 ; s64 total_insns = 0 ; lxc_schedule_elem * curr_elem ; if ( ! curr_tracer ) return FAIL ; <S2SV_StartBug> refresh_tracer_schedule_queue ( curr_tracer ) ; <S2SV_EndBug> clean_up_all_irrelevant_processes ( curr_tracer ) ; resume_all_syscall_blocked_processes ( curr_tracer ) ; update_all_runnable_task_timeslices ( curr_tracer ) ; flush_buffer ( curr_tracer -> run_q_buffer , BUF_MAX_SIZE ) ; print_schedule_list ( curr_tracer ) ; curr_tracer -> buf_tail_ptr = 0 ; total_insns = curr_tracer -> quantum_n_insns ; while ( rem_n_insns < total_insns ) { curr_elem = get_next_runnable_task ( curr_tracer ) ; if ( ! curr_elem ) break ; add_task_to_tracer_run_queue ( curr_tracer , curr_elem ) ; if ( rem_n_insns > 0 ) update_task_virtual_time ( curr_tracer , curr_elem -> curr_task , rem_n_insns ) ; rem_n_insns += curr_elem -> n_insns_curr_round ; curr_elem -> n_insns_curr_round = 0 ; } if ( rem_n_insns >= total_insns ) { signal_tracer_resume ( curr_tracer ) ; wait_for_tracer_completion ( curr_tracer ) ; } curr_tracer -> tracer_task -> freeze_time = curr_tracer -> tracer_task -> freeze_time + curr_tracer -> freeze_quantum ; return SUCCESS ; } | <S2SV_ModStart> return FAIL ; if ( curr_tracer -> quantum_n_insns == 0 ) return SUCCESS ; |
5,417 | CWE-000 gboolean goa_kerberos_identity_sign_in ( GoaKerberosIdentity * self , const char * principal_name , gconstpointer initial_password , const char * preauth_source , GoaIdentitySignInFlags flags , GoaIdentityInquiryFunc inquiry_func , gpointer inquiry_data , GDestroyNotify destroy_notify , GCancellable * cancellable , GError * * error ) { SignInOperation * operation ; krb5_principal principal ; krb5_error_code error_code ; krb5_creds new_credentials ; krb5_get_init_creds_opt * options ; krb5_deltat start_time ; char * service_name ; gboolean signed_in ; if ( g_cancellable_set_error_if_cancelled ( cancellable , error ) ) return FALSE ; error_code = krb5_get_init_creds_opt_alloc ( self -> priv -> kerberos_context , & options ) ; if ( error_code != 0 ) { <S2SV_StartBug> set_error_from_krb5_error_code ( self , <S2SV_EndBug> error , GOA_IDENTITY_ERROR_ALLOCATING_CREDENTIALS , <S2SV_StartBug> error_code , "%k" ) ; <S2SV_EndBug> if ( destroy_notify ) destroy_notify ( inquiry_data ) ; return FALSE ; } signed_in = FALSE ; operation = sign_in_operation_new ( self , inquiry_func , inquiry_data , destroy_notify , cancellable ) ; if ( g_strcmp0 ( self -> priv -> identifier , principal_name ) != 0 ) { g_free ( self -> priv -> identifier ) ; self -> priv -> identifier = g_strdup ( principal_name ) ; } error_code = krb5_parse_name ( self -> priv -> kerberos_context , principal_name , & principal ) ; if ( error_code != 0 ) { <S2SV_StartBug> set_error_from_krb5_error_code ( self , <S2SV_EndBug> error , GOA_IDENTITY_ERROR_PARSING_IDENTIFIER , error_code , <S2SV_StartBug> "%k" ) ; <S2SV_EndBug> if ( destroy_notify ) destroy_notify ( inquiry_data ) ; return FALSE ; } if ( ( flags & GOA_IDENTITY_SIGN_IN_FLAGS_DISALLOW_FORWARDING ) == 0 ) krb5_get_init_creds_opt_set_forwardable ( options , TRUE ) ; if ( ( flags & GOA_IDENTITY_SIGN_IN_FLAGS_DISALLOW_PROXYING ) == 0 ) krb5_get_init_creds_opt_set_proxiable ( options , TRUE ) ; if ( ( flags & GOA_IDENTITY_SIGN_IN_FLAGS_DISALLOW_RENEWAL ) == 0 ) krb5_get_init_creds_opt_set_renew_life ( options , G_MAXINT ) ; if ( preauth_source != NULL ) { krb5_get_init_creds_opt_set_pa ( self -> priv -> kerberos_context , options , "X509_user_identity" , preauth_source ) ; } res_init ( ) ; start_time = 0 ; service_name = NULL ; error_code = krb5_get_init_creds_password ( self -> priv -> kerberos_context , & new_credentials , principal , ( char * ) initial_password , ( krb5_prompter_fct ) on_kerberos_inquiry , operation , start_time , service_name , options ) ; if ( error_code == KRB5_LIBOS_PWDINTR ) g_cancellable_cancel ( operation -> cancellable ) ; if ( g_cancellable_set_error_if_cancelled ( cancellable , error ) ) { if ( destroy_notify ) destroy_notify ( inquiry_data ) ; sign_in_operation_free ( operation ) ; krb5_free_principal ( self -> priv -> kerberos_context , principal ) ; goto done ; } if ( error_code != 0 ) { <S2SV_StartBug> set_error_from_krb5_error_code ( self , <S2SV_EndBug> error , GOA_IDENTITY_ERROR_AUTHENTICATION_FAILED , error_code , <S2SV_StartBug> "%k" ) ; <S2SV_EndBug> if ( destroy_notify ) destroy_notify ( inquiry_data ) ; sign_in_operation_free ( operation ) ; krb5_free_principal ( self -> priv -> kerberos_context , principal ) ; goto done ; } if ( destroy_notify ) destroy_notify ( inquiry_data ) ; sign_in_operation_free ( operation ) ; if ( ! goa_kerberos_identity_update_credentials ( self , principal , & new_credentials , error ) ) { krb5_free_principal ( self -> priv -> kerberos_context , principal ) ; goto done ; } krb5_free_principal ( self -> priv -> kerberos_context , principal ) ; g_debug ( "GoaKerberosIdentity:<S2SV_blank>identity<S2SV_blank>signed<S2SV_blank>in" ) ; signed_in = TRUE ; done : return signed_in ; } | <S2SV_ModStart> 0 ) { set_and_prefix_error_from_krb5_error_code <S2SV_ModEnd> ( self , <S2SV_ModStart> , error_code , "%s" , "" <S2SV_ModEnd> ) ; if <S2SV_ModStart> 0 ) { set_and_prefix_error_from_krb5_error_code <S2SV_ModEnd> ( self , <S2SV_ModStart> , error_code , "%s" , "" <S2SV_ModEnd> ) ; if <S2SV_ModStart> 0 ) { set_and_prefix_error_from_krb5_error_code <S2SV_ModEnd> ( self , <S2SV_ModStart> , error_code , "%s" , "" <S2SV_ModEnd> ) ; if |
5,418 | CWE-000 int pciehp_sysfs_enable_slot ( struct slot * p_slot ) { struct controller * ctrl = p_slot -> ctrl ; mutex_lock ( & p_slot -> lock ) ; switch ( p_slot -> state ) { case BLINKINGON_STATE : cancel_delayed_work ( & p_slot -> work ) ; <S2SV_StartBug> case STATIC_STATE : <S2SV_EndBug> pciehp_request_enable_slot ( p_slot ) ; mutex_unlock ( & p_slot -> lock ) ; synchronize_irq ( ctrl -> pcie -> irq ) ; return ctrl -> request_result ; case POWERON_STATE : ctrl_info ( ctrl , "Slot(%s):<S2SV_blank>Already<S2SV_blank>in<S2SV_blank>powering<S2SV_blank>on<S2SV_blank>state\\n" , slot_name ( p_slot ) ) ; break ; <S2SV_StartBug> case BLINKINGOFF_STATE : <S2SV_EndBug> case POWEROFF_STATE : ctrl_info ( ctrl , "Slot(%s):<S2SV_blank>Already<S2SV_blank>enabled\\n" , slot_name ( p_slot ) ) ; break ; default : ctrl_err ( ctrl , "Slot(%s):<S2SV_blank>Invalid<S2SV_blank>state<S2SV_blank>%#x\\n" , slot_name ( p_slot ) , p_slot -> state ) ; break ; } mutex_unlock ( & p_slot -> lock ) ; return - ENODEV ; } | <S2SV_ModStart> ) ; case OFF_STATE <S2SV_ModEnd> : pciehp_request_enable_slot ( <S2SV_ModStart> ; case BLINKINGOFF_STATE : case ON_STATE |
5,419 | CWE-000 int mysql_drv_thread_done ( int thread_id ) { ( void ) thread_id ; <S2SV_StartBug> mysql_thread_end ( ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> ) thread_id ; DEBUG ( "mysql_thread_end(%s)" , "" ) ; |
5,420 | CWE-000 static void spdk_iscsi_queue_task ( struct spdk_iscsi_conn * conn , struct spdk_iscsi_task * task ) { spdk_trace_record ( TRACE_ISCSI_TASK_QUEUE , conn -> id , task -> scsi . length , ( uintptr_t ) task , ( uintptr_t ) task -> pdu ) ; <S2SV_StartBug> spdk_scsi_dev_queue_task ( conn -> dev , & task -> scsi ) ; <S2SV_EndBug> } | <S2SV_ModStart> pdu ) ; task -> is_queued = true ; |
5,421 | CWE-000 int main ( int argc , char * argv [ ] ) { if ( argc < 3 ) { <S2SV_StartBug> die ( "USAGE:<S2SV_blank>ex177<S2SV_blank><dbfile><S2SV_blank><action><S2SV_blank>[action<S2SV_blank>params]" ) ; <S2SV_EndBug> } char * filename = argv [ 1 ] ; char action = argv [ 2 ] [ 0 ] ; struct Connection * conn = Database_open ( filename , action ) ; int id = 0 ; if ( argc > 3 ) id = atoi ( argv [ 3 ] ) ; <S2SV_StartBug> if ( id >= MAX_ROWS ) die ( "There\'s<S2SV_blank>not<S2SV_blank>that<S2SV_blank>many<S2SV_blank>records." ) ; <S2SV_EndBug> switch ( action ) { case 'c' : Database_create ( conn ) ; Database_write ( conn ) ; break ; case 'g' : if ( argc != 4 ) { <S2SV_StartBug> die ( "Need<S2SV_blank>an<S2SV_blank>id<S2SV_blank>to<S2SV_blank>get" ) ; <S2SV_EndBug> } Database_get ( conn , id ) ; break ; case 's' : if ( argc != 6 ) { <S2SV_StartBug> die ( "Need<S2SV_blank>id,<S2SV_blank>name,<S2SV_blank>and<S2SV_blank>email<S2SV_blank>to<S2SV_blank>set" ) ; <S2SV_EndBug> } Database_set ( conn , id , argv [ 4 ] , argv [ 5 ] ) ; Database_write ( conn ) ; break ; case 'd' : if ( argc != 4 ) { <S2SV_StartBug> die ( "Need<S2SV_blank>id<S2SV_blank>to<S2SV_blank>delete" ) ; <S2SV_EndBug> } Database_delete ( conn , id ) ; Database_write ( conn ) ; break ; case 'l' : Database_list ( conn ) ; break ; default : <S2SV_StartBug> die ( "Invalid<S2SV_blank>action:<S2SV_blank>c=create,<S2SV_blank>g=get,<S2SV_blank>s=set,<S2SV_blank>d=del,<S2SV_blank>l=list" ) ; <S2SV_EndBug> } Database_close ( conn ) ; return 0 ; } | <S2SV_ModStart> die ( "USAGE:<S2SV_blank>ex177<S2SV_blank><dbfile><S2SV_blank><action><S2SV_blank>[action<S2SV_blank>params]" , NULL <S2SV_ModStart> die ( "There\'s<S2SV_blank>not<S2SV_blank>that<S2SV_blank>many<S2SV_blank>records." , conn <S2SV_ModStart> die ( "Need<S2SV_blank>an<S2SV_blank>id<S2SV_blank>to<S2SV_blank>get" , conn <S2SV_ModStart> die ( "Need<S2SV_blank>id,<S2SV_blank>name,<S2SV_blank>and<S2SV_blank>email<S2SV_blank>to<S2SV_blank>set" , conn <S2SV_ModStart> die ( "Need<S2SV_blank>id<S2SV_blank>to<S2SV_blank>delete" , conn <S2SV_ModStart> die ( "Invalid<S2SV_blank>action:<S2SV_blank>c=create,<S2SV_blank>g=get,<S2SV_blank>s=set,<S2SV_blank>d=del,<S2SV_blank>l=list" , conn |
5,422 | CWE-000 Private void handleButtonDown ( void ) { if ( priv_active_bar -> value > priv_active_bar -> min_value ) { priv_active_bar -> value -- ; } <S2SV_StartBug> drawBarGraph ( ) ; <S2SV_EndBug> } | <S2SV_ModStart> -- ; } updateBargraph <S2SV_ModEnd> ( ) ; |
5,423 | CWE-000 BAMtlLibrary * BAMtlLibraryNew ( const char * filename ) { char path [ LINE_MAX ] = { } ; <S2SV_StartBug> if ( MCFileGetPath ( filename , "mtl" , path ) ) { <S2SV_EndBug> return null ; } const char * assetbuff = MCFileCopyContentWithPath ( path ) ; if ( assetbuff != null ) { BAMtlLibrary * lib = BAMtlLibraryAlloc ( ) ; if ( lib == null ) { error_log ( "MC3DObjParser<S2SV_blank>-<S2SV_blank>MC3DMtlLibraryAlloc<S2SV_blank>failed.\\n" ) ; return null ; } char line [ LINE_MAX ] ; char * c = ( char * ) assetbuff ; while ( * c != NUL ) { if ( * c == MCNewLineN || * c == MCNewLineR || * c == MCTab || * c == MCWhiteSpace ) { c ++ ; continue ; } for ( int i = 0 ; ! isNewLine ( c ) ; c ++ ) { line [ i ++ ] = * c ; line [ i ] = NUL ; } processMtlLine ( lib , line ) ; } free ( ( void * ) assetbuff ) ; MCStringFill ( lib -> name , filename ) ; return lib ; } else { error_log ( "MC3DObjParser<S2SV_blank>-<S2SV_blank>AAssetManager_open<S2SV_blank>%s<S2SV_blank>failed\\n" , filename ) ; return null ; } } | <S2SV_ModStart> MCFileGetPath ( filename <S2SV_ModEnd> , path ) |
5,424 | CWE-000 static void sc_cngrab ( struct consdev * cp ) { scr_stat * scp ; if ( ! cold && sc_console -> sc -> cur_scp -> index != sc_console -> index && sc_console -> sc -> cur_scp -> smode . mode == VT_AUTO && sc_console -> smode . mode == VT_AUTO ) sc_switch_scr ( sc_console -> sc , sc_console -> index ) ; scp = sc_console -> sc -> cur_scp ; if ( scp -> sc -> kbd == NULL ) return ; <S2SV_StartBug> if ( scp -> grabbed ++ > 0 ) <S2SV_EndBug> return ; kbdd_enable ( scp -> sc -> kbd ) ; scp -> kbd_prev_mode = scp -> kbd_mode ; scp -> kbd_mode = K_XLATE ; ( void ) kbdd_ioctl ( scp -> sc -> kbd , KDSKBMODE , ( caddr_t ) & scp -> kbd_mode ) ; kbdd_poll ( scp -> sc -> kbd , TRUE ) ; } | <S2SV_ModStart> ( scp -> sc -> grab_level <S2SV_ModEnd> ++ > 0 |
5,425 | CWE-000 <S2SV_StartBug> struct ata_chip_id * <S2SV_EndBug> <S2SV_StartBug> ata_match_chip ( device_t dev , struct ata_chip_id * index ) <S2SV_EndBug> { while ( index -> chipid != 0 ) { if ( pci_get_devid ( dev ) == index -> chipid && pci_get_revid ( dev ) >= index -> chiprev ) return index ; index ++ ; } return NULL ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> const <S2SV_ModStart> device_t dev , const |
5,426 | CWE-000 static HitTransitionHashTable * findInHitTransitionHT ( HitTransitionHashTable * hitTransitionht , HitTransition * hitTrans ) { HitTransitionHashTable * s = NULL ; <S2SV_StartBug> HASH_FIND ( hh_hitTrans , hitTransitionht , hitTrans , 4 , s ) ; <S2SV_EndBug> return s ; } | <S2SV_ModStart> , hitTransitionht , & |
5,427 | CWE-000 int main ( int argc , char * * argv ) { jobInit ( ) ; initShell ( ) ; int status = 0 ; struct sigaction sa ; sa . sa_sigaction = & sigchld_handler ; sigemptyset ( & sa . sa_mask ) ; sa . sa_flags = SA_SIGINFO | SA_RESTART ; sigaction ( SIGCHLD , & sa , NULL ) ; sigset_t block_mask ; sigaddset ( & block_mask , SIGTSTP ) ; sigaddset ( & block_mask , SIGTERM ) ; sigaddset ( & block_mask , SIGQUIT ) ; sigaddset ( & block_mask , SIGTTOU ) ; sigaddset ( & block_mask , SIGTTIN ) ; sigprocmask ( SIG_BLOCK , & block_mask , NULL ) ; sigemptyset ( & child_mask ) ; sigaddset ( & child_mask , SIGINT ) ; sigaddset ( & child_mask , SIGTSTP ) ; sigaddset ( & child_mask , SIGTERM ) ; sigaddset ( & child_mask , SIGQUIT ) ; sigaddset ( & child_mask , SIGTTOU ) ; sigaddset ( & child_mask , SIGTTIN ) ; sigaddset ( & child_mask , SIGCHLD ) ; signal ( SIGINT , SIG_IGN ) ; int numCommands ; int numArguments ; int numSegments ; while ( 1 ) { ourPrompt ( ) ; command = ( char * * ) malloc ( MAXLINE * sizeof ( char * ) ) ; <S2SV_StartBug> if ( ( line = readline ( "" ) ) == NULL ) { <S2SV_EndBug> perror ( "IO<S2SV_blank>error\\n" ) ; free ( command ) ; freeJobList ( ) ; exit ( 1 ) ; } numCommands = parseCommands ( line , command ) ; for ( int i = 0 ; i < numCommands ; i ++ ) { jobLine = ( char * ) malloc ( sizeof ( char ) * strlen ( command [ i ] ) ) ; args_without_pipe = ( char * * ) malloc ( sizeof ( char * ) * MAXLEN ) ; strcpy ( jobLine , command [ i ] ) ; bzero ( args_without_pipe , MAXLEN ) ; numArguments = parseArguments ( command [ i ] , args_without_pipe ) ; Process * toAdd = ( Process * ) malloc ( sizeof ( Process ) ) ; toAdd -> args = args_without_pipe ; toAdd -> argn = numArguments ; toAdd -> next = NULL ; int field ; int status ; if ( numArguments < 0 ) { field = JOBBACK ; } else { field = JOBFORE ; } status = JOBRUN ; Job * job = createJob ( jobLine , toAdd , status , field ) ; if ( jobInsert ( job ) == FALSE ) { printf ( "Add<S2SV_blank>job<S2SV_blank>fail!\\n" ) ; exit ( 1 ) ; } executing_command_without_pipe ( job , child_mask ) ; } } return 0 ; } | <S2SV_ModStart> ) ) ; bzero ( command , MAXLINE ) ; |
5,428 | CWE-000 void main ( void ) { ppu_addr = PPU_PALETTE ; ppu_data = PALETTES ; ppu_data_size = sizeof ( PALETTES ) ; WritePPU ( ) ; DrawBackground ( ) ; curr_sprite = 0 ; ship_level [ 0 ] = 0x00 ; ship_level [ 1 ] = 0x01 ; ship_level [ 2 ] = 0x02 ; ship_level [ 3 ] = 0x10 ; ship_level [ 4 ] = 0x11 ; ship_level [ 5 ] = 0x12 ; ship_bank_up [ 0 ] = 0x03 ; ship_bank_up [ 1 ] = 0x04 ; ship_bank_up [ 2 ] = 0x05 ; ship_bank_up [ 3 ] = 0x13 ; ship_bank_up [ 4 ] = 0x14 ; ship_bank_up [ 5 ] = 0x15 ; ship_bank_down [ 0 ] = 0x06 ; ship_bank_down [ 1 ] = 0x07 ; ship_bank_down [ 2 ] = 0x08 ; ship_bank_down [ 3 ] = 0x16 ; ship_bank_down [ 4 ] = 0x17 ; ship_bank_down [ 5 ] = 0x18 ; player . left_x = ( MIN_X + SPRITE_WIDTH * 2 ) ; player . top_y = ( MAX_Y / 2 - SPRITE_HEIGHT / 2 ) ; player . num_h_sprites = SHIP_SPRITE_HOR_TILES ; player . num_v_sprites = SHIP_SPRITE_VERT_TILES ; player . sprite_offsets = ship_level ; WriteMetaSpriteToOAM ( & player ) ; laser_count = 0 ; for ( i = 0 ; i < MAX_LASERS ; ++ i ) { <S2SV_StartBug> lasers [ i ] . tile_idx = LASER_SPRITE ; <S2SV_EndBug> } ResetScroll ( ) ; EnablePPU ( ) ; while ( 1 ) { <S2SV_StartBug> WaitFrame ( ) ; <S2SV_EndBug> curr_sprite = 0 ; offscreen_lasers = 0 ; UpdateInput ( ) ; if ( ( JoyPad1 & BUTTON_UP ) && player . sprite_offsets != ship_bank_up ) { player . sprite_offsets = ship_bank_up ; } else if ( ( JoyPad1 & BUTTON_DOWN ) && ( player . sprite_offsets != ship_bank_down ) ) { player . sprite_offsets = ship_bank_down ; } else if ( ! ( JoyPad1 & BUTTON_UP ) && ! ( JoyPad1 & BUTTON_DOWN ) && ( player . sprite_offsets != ship_level ) ) { player . sprite_offsets = ship_level ; } if ( ( JoyPad1 & BUTTON_UP ) && ( player . top_y > ( MIN_Y + SPRITE_HEIGHT ) ) ) { player . top_y -= 2 ; } if ( ( JoyPad1 & BUTTON_DOWN ) && ( ( player . top_y + player . num_v_sprites + SPRITE_HEIGHT ) < ( MAX_Y - 2 * SPRITE_HEIGHT ) ) ) { player . top_y += 2 ; } if ( ( JoyPad1 & BUTTON_RIGHT ) && ( ( player . left_x + player . num_h_sprites + SPRITE_WIDTH ) < ( MAX_X - 2 * SPRITE_WIDTH ) ) ) { player . left_x += 2 ; } if ( ( JoyPad1 & BUTTON_LEFT ) && ( ( player . left_x ) > ( MIN_X + SPRITE_WIDTH ) ) ) { player . left_x -= 1 ; } if ( JoyPad1 & BUTTON_A && ! ( PrevJoyPad1 & BUTTON_A ) ) { <S2SV_StartBug> if ( laser_count < MAX_LASERS ) { <S2SV_EndBug> lasers [ laser_count ] . x = player . left_x + player . num_h_sprites + SPRITE_WIDTH ; lasers [ laser_count ] . y = player . top_y ; ++ laser_count ; } } for ( i = 0 ; i < laser_count ; ++ i ) { overflow_checker = ( uint16_t ) lasers [ i ] . x ; overflow_checker += 24 ; if ( overflow_checker > MAX_X ) { lasers [ i ] . y = MIN_Y - SPRITE_HEIGHT ; ++ offscreen_lasers ; } else { lasers [ i ] . x = ( uint8_t ) overflow_checker ; } } laser_count -= offscreen_lasers ; WriteMetaSpriteToOAM ( & player ) ; for ( i = 0 ; i < laser_count ; ++ i ) { WriteSpriteToOAM ( & ( lasers [ i ] ) ) ; } } } | <S2SV_ModStart> i ] . y = 0xff ; lasers [ i ] . <S2SV_ModStart> 1 ) { curr_sprite = 0 ; <S2SV_ModStart> WaitFrame ( ) <S2SV_ModEnd> ; UpdateInput ( <S2SV_ModStart> ) ) { AddLaser ( ) ; } laser_count -= CheckOffscreenLasers ( ) ; WriteMetaSpriteToOAM ( & player ) ; for ( i = 0 ; i < MAX_LASERS ; ++ i ) { WriteSpriteToOAM ( & ( lasers [ i ] ) ) ; } ResetScroll ( ) ; <S2SV_ModEnd> } } <S2SV_null> |
5,429 | CWE-000 static void checkFood ( void ) { if ( food . row == snakeHead -> row && food . col == snakeHead -> col ) { struct SnakeSegment * newSegment = malloc ( sizeof ( struct SnakeSegment ) ) ; newSegment -> row = snakeTail -> row ; newSegment -> col = snakeTail -> col ; newSegment -> direction = NONE ; newSegment -> next = NULL ; snakeTail -> next = newSegment ; snakeTail = newSegment ; <S2SV_StartBug> food . row = rand ( ) % HEIGHT ; <S2SV_EndBug> food . col = rand ( ) % WIDTH ; } } | <S2SV_ModStart> = newSegment ; score ++ ; |
5,430 | CWE-000 static int hep_queue_cb ( void * data ) { RAII_VAR ( struct module_config * , config , ao2_global_obj_ref ( global_config ) , ao2_cleanup ) ; RAII_VAR ( struct hepv3_runtime_data * , hepv3_data , ao2_global_obj_ref ( global_data ) , ao2_cleanup ) ; RAII_VAR ( struct hepv3_capture_info * , capture_info , data , ao2_cleanup ) ; struct hep_generic hg_pkt ; unsigned int packet_len = 0 , sock_buffer_len ; struct hep_chunk_ip4 ipv4_src , ipv4_dst ; struct hep_chunk_ip6 ipv6_src , ipv6_dst ; struct hep_chunk auth_key , payload , uuid ; void * sock_buffer ; int res ; if ( ! capture_info || ! config || ! hepv3_data ) { return 0 ; } <S2SV_StartBug> if ( ast_sockaddr_is_ipv4 ( & capture_info -> src_addr ) != ast_sockaddr_is_ipv4 ( & capture_info -> dst_addr ) ) { <S2SV_EndBug> ast_log ( AST_LOG_NOTICE , "Unable<S2SV_blank>to<S2SV_blank>send<S2SV_blank>packet:<S2SV_blank>Address<S2SV_blank>Family<S2SV_blank>mismatch<S2SV_blank>between<S2SV_blank>source/destination\\n" ) ; return - 1 ; } packet_len = sizeof ( hg_pkt ) ; memcpy ( hg_pkt . header . id , "\\x48\\x45\\x50\\x33" , 4 ) ; INITIALIZE_GENERIC_HEP_CHUNK_DATA ( & hg_pkt . ip_proto , CHUNK_TYPE_IP_PROTOCOL_ID , 0x11 ) ; INITIALIZE_GENERIC_HEP_CHUNK_DATA ( & hg_pkt . src_port , CHUNK_TYPE_SRC_PORT , htons ( ast_sockaddr_port ( & capture_info -> src_addr ) ) ) ; INITIALIZE_GENERIC_HEP_CHUNK_DATA ( & hg_pkt . dst_port , CHUNK_TYPE_DST_PORT , htons ( ast_sockaddr_port ( & capture_info -> dst_addr ) ) ) ; INITIALIZE_GENERIC_HEP_CHUNK_DATA ( & hg_pkt . time_sec , CHUNK_TYPE_TIMESTAMP_SEC , htonl ( capture_info -> capture_time . tv_sec ) ) ; INITIALIZE_GENERIC_HEP_CHUNK_DATA ( & hg_pkt . time_usec , CHUNK_TYPE_TIMESTAMP_USEC , htonl ( capture_info -> capture_time . tv_usec ) ) ; INITIALIZE_GENERIC_HEP_CHUNK_DATA ( & hg_pkt . proto_t , CHUNK_TYPE_PROTOCOL_TYPE , capture_info -> capture_type ) ; INITIALIZE_GENERIC_HEP_CHUNK_DATA ( & hg_pkt . capt_id , CHUNK_TYPE_CAPTURE_AGENT_ID , htonl ( config -> general -> capture_id ) ) ; if ( ast_sockaddr_is_ipv4 ( & capture_info -> src_addr ) ) { INITIALIZE_GENERIC_HEP_CHUNK_DATA ( & hg_pkt . ip_family , CHUNK_TYPE_IP_PROTOCOL_FAMILY , AF_INET ) ; INITIALIZE_GENERIC_HEP_CHUNK ( & ipv4_src , CHUNK_TYPE_IPV4_SRC_ADDR ) ; inet_pton ( AF_INET , ast_sockaddr_stringify_addr ( & capture_info -> src_addr ) , & ipv4_src . data ) ; INITIALIZE_GENERIC_HEP_CHUNK ( & ipv4_dst , CHUNK_TYPE_IPV4_DST_ADDR ) ; inet_pton ( AF_INET , ast_sockaddr_stringify_addr ( & capture_info -> dst_addr ) , & ipv4_dst . data ) ; packet_len += ( sizeof ( ipv4_src ) + sizeof ( ipv4_dst ) ) ; } else { INITIALIZE_GENERIC_HEP_CHUNK_DATA ( & hg_pkt . ip_family , CHUNK_TYPE_IP_PROTOCOL_FAMILY , AF_INET6 ) ; INITIALIZE_GENERIC_HEP_CHUNK ( & ipv6_src , CHUNK_TYPE_IPV6_SRC_ADDR ) ; inet_pton ( AF_INET6 , ast_sockaddr_stringify_addr ( & capture_info -> src_addr ) , & ipv6_src . data ) ; INITIALIZE_GENERIC_HEP_CHUNK ( & ipv6_dst , CHUNK_TYPE_IPV6_DST_ADDR ) ; inet_pton ( AF_INET6 , ast_sockaddr_stringify_addr ( & capture_info -> dst_addr ) , & ipv6_dst . data ) ; packet_len += ( sizeof ( ipv6_src ) + sizeof ( ipv6_dst ) ) ; } if ( ! ast_strlen_zero ( config -> general -> capture_password ) ) { INITIALIZE_GENERIC_HEP_IDS_VAR ( & auth_key , CHUNK_TYPE_AUTH_KEY , strlen ( config -> general -> capture_password ) ) ; packet_len += ( sizeof ( auth_key ) + strlen ( config -> general -> capture_password ) ) ; } INITIALIZE_GENERIC_HEP_IDS_VAR ( & uuid , CHUNK_TYPE_UUID , strlen ( capture_info -> uuid ) ) ; packet_len += ( sizeof ( uuid ) + strlen ( capture_info -> uuid ) ) ; INITIALIZE_GENERIC_HEP_IDS_VAR ( & payload , capture_info -> zipped ? CHUNK_TYPE_PAYLOAD_ZIP : CHUNK_TYPE_PAYLOAD , capture_info -> len ) ; packet_len += ( sizeof ( payload ) + capture_info -> len ) ; hg_pkt . header . length = htons ( packet_len ) ; sock_buffer = ast_malloc ( packet_len ) ; if ( ! sock_buffer ) { return - 1 ; } memcpy ( sock_buffer , & hg_pkt , sizeof ( hg_pkt ) ) ; sock_buffer_len = sizeof ( hg_pkt ) ; if ( ast_sockaddr_is_ipv4 ( & capture_info -> src_addr ) ) { memcpy ( sock_buffer + sock_buffer_len , & ipv4_src , sizeof ( ipv4_src ) ) ; sock_buffer_len += sizeof ( ipv4_src ) ; memcpy ( sock_buffer + sock_buffer_len , & ipv4_dst , sizeof ( ipv4_dst ) ) ; sock_buffer_len += sizeof ( ipv4_dst ) ; } else { memcpy ( sock_buffer + sock_buffer_len , & ipv6_src , sizeof ( ipv6_src ) ) ; sock_buffer_len += sizeof ( ipv6_src ) ; memcpy ( sock_buffer + sock_buffer_len , & ipv6_dst , sizeof ( ipv6_dst ) ) ; sock_buffer_len += sizeof ( ipv6_dst ) ; } if ( ! ast_strlen_zero ( config -> general -> capture_password ) ) { memcpy ( sock_buffer + sock_buffer_len , & auth_key , sizeof ( auth_key ) ) ; sock_buffer_len += sizeof ( auth_key ) ; memcpy ( sock_buffer + sock_buffer_len , config -> general -> capture_password , strlen ( config -> general -> capture_password ) ) ; sock_buffer_len += strlen ( config -> general -> capture_password ) ; } memcpy ( sock_buffer + sock_buffer_len , & uuid , sizeof ( uuid ) ) ; sock_buffer_len += sizeof ( uuid ) ; memcpy ( sock_buffer + sock_buffer_len , capture_info -> uuid , strlen ( capture_info -> uuid ) ) ; sock_buffer_len += strlen ( capture_info -> uuid ) ; memcpy ( sock_buffer + sock_buffer_len , & payload , sizeof ( payload ) ) ; sock_buffer_len += sizeof ( payload ) ; memcpy ( sock_buffer + sock_buffer_len , capture_info -> payload , capture_info -> len ) ; sock_buffer_len += capture_info -> len ; ast_assert ( sock_buffer_len == packet_len ) ; res = ast_sendto ( hepv3_data -> sockfd , sock_buffer , sock_buffer_len , 0 , & hepv3_data -> remote_addr ) ; if ( res < 0 ) { ast_log ( AST_LOG_ERROR , "Error<S2SV_blank>[%d]<S2SV_blank>while<S2SV_blank>sending<S2SV_blank>packet<S2SV_blank>to<S2SV_blank>HEPv3<S2SV_blank>server:<S2SV_blank>%s\\n" , errno , strerror ( errno ) ) ; } else if ( res != sock_buffer_len ) { ast_log ( AST_LOG_WARNING , "Failed<S2SV_blank>to<S2SV_blank>send<S2SV_blank>complete<S2SV_blank>packet<S2SV_blank>to<S2SV_blank>HEPv3<S2SV_blank>server:<S2SV_blank>%d<S2SV_blank>of<S2SV_blank>%u<S2SV_blank>sent\\n" , res , sock_buffer_len ) ; res = - 1 ; } ast_free ( sock_buffer ) ; return res ; } | <S2SV_ModStart> 0 ; } <S2SV_ModEnd> packet_len = sizeof |
5,431 | CWE-000 void * task_a ( void * arg ) { struct timespec my_period ; int my_sig , received_sig ; struct itimerspec timerdata ; struct itimerspec timergetdata ; timer_t timer_id ; time_t clock ; struct sigevent event ; sigset_t set ; struct periodic_params * params ; params = arg ; my_period = params -> period ; my_sig = params -> signo ; event . sigev_notify = SIGEV_SIGNAL ; event . sigev_signo = my_sig ; if ( timer_create ( CLOCK_REALTIME , & event , & timer_id ) == - 1 ) { perror ( "Error<S2SV_blank>in<S2SV_blank>timer<S2SV_blank>creation\\n" ) ; rtems_test_exit ( 0 ) ; } sigemptyset ( & set ) ; sigaddset ( & set , my_sig ) ; pthread_sigmask ( SIG_BLOCK , & set , NULL ) ; timerdata . it_interval = my_period ; timerdata . it_value = my_period ; timerdata . it_value . tv_sec *= 2 ; if ( timer_settime ( timer_id , POSIX_TIMER_RELATIVE , & timerdata , & timergetdata ) == - 1 ) { perror ( "Error<S2SV_blank>in<S2SV_blank>timer<S2SV_blank>setting\\n" ) ; rtems_test_exit ( 0 ) ; } printf ( "task<S2SV_blank>A:<S2SV_blank>timer_settime<S2SV_blank>-<S2SV_blank>value=%" PRIdtime_t ":%ld<S2SV_blank>interval=%" PRIdtime_t ":%ld\\n" , timergetdata . it_value . tv_sec , timergetdata . it_value . tv_nsec , timergetdata . it_interval . tv_sec , timergetdata . it_interval . tv_nsec ) ; while ( 1 ) { if ( sigwait ( & set , & received_sig ) == - 1 ) { perror ( "Error<S2SV_blank>in<S2SV_blank>sigwait\\n" ) ; } if ( timer_gettime ( timer_id , & timerdata ) == - 1 ) { perror ( "Error<S2SV_blank>in<S2SV_blank>timer_gettime\\n" ) ; rtems_test_exit ( 0 ) ; } if ( ! _Timespec_Equal_to ( & timerdata . it_value , & my_period ) ) { <S2SV_StartBug> perror ( "Error<S2SV_blank>in<S2SV_blank>Task<S2SV_blank>A<S2SV_blank>timer_gettime\\n" ) ; <S2SV_EndBug> } clock = time ( NULL ) ; printf ( "Executing<S2SV_blank>task<S2SV_blank>A<S2SV_blank>with<S2SV_blank>count<S2SV_blank>=<S2SV_blank>%2i<S2SV_blank>%s" , params -> count , ctime ( & clock ) ) ; params -> count -- ; if ( params -> count == 0 ) StopTimer ( timer_id , & timerdata ) ; } return NULL ; } | <S2SV_ModStart> ) ) { fprintf ( stderr , "Error<S2SV_blank>in<S2SV_blank>Task<S2SV_blank>A<S2SV_blank>timer_gettime:\\n" "<S2SV_blank><S2SV_blank>re-armed<S2SV_blank>timer:<S2SV_blank>%" PRIdtime_t ":%ld<S2SV_blank>does<S2SV_blank>not<S2SV_blank>match<S2SV_blank>interval:<S2SV_blank>%" PRIdtime_t ":%ld\\n" , timerdata . it_value . tv_sec , timerdata . it_value . tv_nsec , my_period . tv_sec , my_period . tv_nsec <S2SV_ModEnd> ) ; } |
5,432 | CWE-000 int _our_safe_pcap_next_ex ( pcap_t * pcap , struct pcap_pkthdr * * pkthdr , const u_char * * pktdata , const char * funcname , const int line , const char * file ) { int res = pcap_next_ex ( pcap , pkthdr , pktdata ) ; if ( * pktdata && * pkthdr ) { if ( ( * pkthdr ) -> len > MAXPACKET ) { fprintf ( stderr , "safe_pcap_next_ex<S2SV_blank>ERROR:<S2SV_blank>Invalid<S2SV_blank>packet<S2SV_blank>length<S2SV_blank>in<S2SV_blank>%s:%s()<S2SV_blank>line<S2SV_blank>%d:<S2SV_blank>%u<S2SV_blank>is<S2SV_blank>greater<S2SV_blank>than<S2SV_blank>maximum<S2SV_blank>%u\\n" , file , funcname , line , ( * pkthdr ) -> len , MAXPACKET ) ; exit ( - 1 ) ; } <S2SV_StartBug> if ( ( * pkthdr ) -> len < ( * pkthdr ) -> caplen ) { <S2SV_EndBug> <S2SV_StartBug> fprintf ( stderr , "safe_pcap_next_ex<S2SV_blank>ERROR:<S2SV_blank>Invalid<S2SV_blank>packet<S2SV_blank>length<S2SV_blank>in<S2SV_blank>%s:%s()<S2SV_blank>line<S2SV_blank>%d:<S2SV_blank>packet<S2SV_blank>length<S2SV_blank>%u<S2SV_blank>is<S2SV_blank>less<S2SV_blank>than<S2SV_blank>capture<S2SV_blank>length<S2SV_blank>%u\\n" , <S2SV_EndBug> file , funcname , line , ( * pkthdr ) -> len , ( * pkthdr ) -> caplen ) ; exit ( - 1 ) ; } } return res ; } | <S2SV_ModStart> } if ( ! ( * pkthdr ) -> len || <S2SV_ModStart> ( stderr , "safe_pcap_next_ex<S2SV_blank>ERROR:<S2SV_blank>Invalid<S2SV_blank>packet<S2SV_blank>length<S2SV_blank>in<S2SV_blank>%s:%s()<S2SV_blank>line<S2SV_blank>%d:<S2SV_blank>packet<S2SV_blank>length=%u<S2SV_blank>capture<S2SV_blank>length=%u\\n" <S2SV_ModEnd> , file , |
5,433 | CWE-000 static int parse_quoted_strings ( const char * line , char * * * result ) { char word [ PARSER_MAX_LINE_SIZE ] ; int nchar = 0 ; int nwords = 0 ; char quote = '\\0' ; char * * strings ; <S2SV_StartBug> strings = ( char * * ) malloc ( 10 * sizeof ( char * ) ) ; <S2SV_EndBug> int count = 10 ; word [ 0 ] = '\\0' ; for ( unsigned int i = 0 ; i < strlen ( line ) ; i ++ ) { char c = line [ i ] ; if ( c == \'"\' || c == '\\'' ) { if ( c == quote ) { quote = '\\0' ; } else if ( ! quote ) { quote = c ; } else { word [ nchar ++ ] = c ; } } else if ( c == ',' ) { if ( ! quote ) { word [ nchar ++ ] = '\\0' ; if ( count <= nwords ) { <S2SV_StartBug> count += 10 ; <S2SV_EndBug> <S2SV_StartBug> strings = ( char * * ) realloc ( strings , count * sizeof ( char ) ) ; <S2SV_EndBug> } strings [ nwords ] = ( char * ) malloc ( ( strlen ( word ) + 1 ) * sizeof ( char ) ) ; strcpy ( strings [ nwords ] , trim_both ( word ) ) ; nwords ++ ; nchar = 0 ; word [ 0 ] = '\\0' ; } else { word [ nchar ++ ] = c ; } } else { word [ nchar ++ ] = c ; } } if ( nchar > 0 ) { word [ nchar ] = '\\0' ; if ( count <= nwords ) { count += 1 ; strings = ( char * * ) realloc ( strings , count * sizeof ( char ) ) ; } strings [ nwords ] = ( char * ) malloc ( ( strlen ( word ) + 1 ) * sizeof ( char ) ) ; strcpy ( strings [ nwords ] , trim_both ( word ) ) ; nwords ++ ; } * result = strings ; return nwords ; } | <S2SV_ModStart> * strings ; int count = CHUNK ; <S2SV_ModStart> ) malloc ( count <S2SV_ModEnd> * sizeof ( <S2SV_ModStart> * ) ) <S2SV_ModEnd> ; word [ <S2SV_ModStart> { count += CHUNK <S2SV_ModEnd> ; strings = <S2SV_ModStart> sizeof ( char * |
5,434 | CWE-000 <S2SV_StartBug> void char_set_account_online ( int account_id ) <S2SV_EndBug> { WFIFOHEAD ( chr -> login_fd , 6 ) ; WFIFOW ( chr -> login_fd , 0 ) = 0x272b ; WFIFOL ( chr -> login_fd , 2 ) = account_id ; WFIFOSET ( chr -> login_fd , 6 ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static |
5,435 | CWE-000 static int drv_ps_liteon_ltr553_ioctl ( int cmd , unsigned long arg ) { int ret = 0 ; switch ( cmd ) { case SENSOR_IOCTL_SET_POWER : ret = drv_ps_liteon_ltr553_set_power_mode ( & ltr553_ctx , arg ) ; if ( unlikely ( ret ) ) { return - 1 ; } break ; case SENSOR_IOCTL_GET_INFO : dev_sensor_info_t * info = ( dev_sensor_info_t * ) arg ; <S2SV_StartBug> info -> model = "LTR553" ; <S2SV_EndBug> info -> unit = cm ; break ; default : return - 1 ; } LOG ( "%s<S2SV_blank>%s<S2SV_blank>successfully<S2SV_blank>\\n" , SENSOR_STR , __func__ ) ; return 0 ; } | <S2SV_ModStart> ) arg ; if ( <S2SV_ModStart> info -> model ) strcpy ( info -> model , "LTR553" ) <S2SV_ModEnd> ; info -> |
5,436 | CWE-000 void player_deinit ( void ) { int ret ; player_exit = 1 ; commands_base_destroy ( cmdbase ) ; ret = pthread_join ( tid_player , NULL ) ; if ( ret != 0 ) { DPRINTF ( E_LOG , L_PLAYER , "Could<S2SV_blank>not<S2SV_blank>join<S2SV_blank>player<S2SV_blank>thread:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; return ; } free ( history ) ; pb_timer_stop ( ) ; <S2SV_StartBug> # if defined ( __linux__ ) <S2SV_EndBug> close ( pb_timer_fd ) ; # else timer_delete ( pb_timer ) ; # endif evbuffer_free ( audio_buf ) ; outputs_deinit ( ) ; event_base_free ( evbase_player ) ; } | <S2SV_ModStart> ) ; # ifdef HAVE_TIMERFD <S2SV_ModEnd> close ( pb_timer_fd |
5,437 | CWE-000 static int match_mnt_path_str ( struct aa_profile * profile , const struct path * mntpath , char * buffer , const char * devname , const char * type , unsigned long flags , void * data , bool binary , const char * devinfo ) { struct aa_perms perms = { } ; const char * mntpnt = NULL , * info = NULL ; int pos , error ; AA_BUG ( ! profile ) ; AA_BUG ( ! mntpath ) ; AA_BUG ( ! buffer ) ; error = aa_path_name ( mntpath , path_flags ( profile , mntpath ) , buffer , & mntpnt , & info , profile -> disconnected ) ; if ( error ) goto audit ; if ( IS_ERR ( devname ) ) { <S2SV_StartBug> error = PTR_ERR ( devname ) ; <S2SV_EndBug> info = devinfo ; goto audit ; } error = - EACCES ; pos = do_match_mnt ( profile -> policy . dfa , profile -> policy . start [ AA_CLASS_MOUNT ] , mntpnt , devname , type , flags , data , binary , & perms ) ; if ( pos ) { info = mnt_info_table [ pos ] ; goto audit ; } error = 0 ; audit : return audit_mount ( profile , OP_MOUNT , mntpnt , devname , type , NULL , flags , data , AA_MAY_MOUNT , & perms , info , error ) ; } | <S2SV_ModStart> ( devname ) ; devname = NULL |
5,438 | CWE-000 EC_BOOL cvendor_override_ngx_rc ( const UINT32 cvendor_md_id , const ngx_int_t rc , const UINT32 location ) { CVENDOR_MD * cvendor_md ; <S2SV_StartBug> # if ( SWITCH_ON == CVENDOR_DEBUG_SWITCH ) <S2SV_EndBug> if ( CVENDOR_MD_ID_CHECK_INVALID ( cvendor_md_id ) ) { sys_log ( LOGSTDOUT , "error:cvendor_override_ngx_rc:<S2SV_blank>cvendor<S2SV_blank>module<S2SV_blank>#0x%lx<S2SV_blank>not<S2SV_blank>started.\\n" , cvendor_md_id ) ; dbg_exit ( MD_CVENDOR , cvendor_md_id ) ; } # endif cvendor_md = CVENDOR_MD_GET ( cvendor_md_id ) ; if ( rc == CVENDOR_MD_NGX_RC ( cvendor_md ) ) { dbg_log ( SEC_0175_CVENDOR , 9 ) ( LOGSTDOUT , "[DEBUG]<S2SV_blank>cvendor_override_ngx_rc:<S2SV_blank>" "ignore<S2SV_blank>same<S2SV_blank>rc<S2SV_blank>%d\\n" , rc ) ; return ( EC_TRUE ) ; } <S2SV_StartBug> if ( NGX_OK != CVENDOR_MD_NGX_RC ( cvendor_md ) ) <S2SV_EndBug> { dbg_log ( SEC_0175_CVENDOR , 9 ) ( LOGSTDOUT , "[DEBUG]<S2SV_blank>cvendor_override_ngx_rc:<S2SV_blank>" "modify<S2SV_blank>rc<S2SV_blank>%d<S2SV_blank>=><S2SV_blank>%d\\n" , CVENDOR_MD_NGX_RC ( cvendor_md ) , rc ) ; CVENDOR_MD_NGX_RC ( cvendor_md ) = rc ; CVENDOR_MD_NGX_LOC ( cvendor_md ) = location ; return ( EC_TRUE ) ; } dbg_log ( SEC_0175_CVENDOR , 9 ) ( LOGSTDOUT , "[DEBUG]<S2SV_blank>cvendor_override_ngx_rc:<S2SV_blank>" "set<S2SV_blank>rc<S2SV_blank>%d\\n" , rc ) ; CVENDOR_MD_NGX_RC ( cvendor_md ) = rc ; CVENDOR_MD_NGX_LOC ( cvendor_md ) = location ; return ( EC_TRUE ) ; } | <S2SV_ModStart> * cvendor_md ; ngx_http_request_t * r ; <S2SV_ModStart> ) ; } r = CVENDOR_MD_NGX_HTTP_REQ ( cvendor_md ) ; if ( EC_FALSE == cngx_need_send_header ( r ) ) { dbg_log ( SEC_0175_CVENDOR , 9 ) ( LOGSTDOUT , "[DEBUG]<S2SV_blank>cvendor_override_ngx_rc:<S2SV_blank>" "ignore<S2SV_blank>rc<S2SV_blank>%d<S2SV_blank>due<S2SV_blank>to<S2SV_blank>header<S2SV_blank>had<S2SV_blank>sent<S2SV_blank>out\\n" , rc ) ; return ( EC_TRUE ) ; } |
5,439 | CWE-000 int swFactory_end ( swFactory * factory , int fd ) { swServer * serv = factory -> ptr ; swSendData _send ; swDataHead info ; bzero ( & _send , sizeof ( _send ) ) ; _send . info . fd = fd ; _send . info . len = 0 ; _send . info . type = SW_EVENT_CLOSE ; swConnection * conn = swWorker_get_connection ( serv , fd ) ; if ( conn == NULL || conn -> active == 0 ) { return SW_ERR ; } else if ( conn -> close_force ) { goto do_close ; } else if ( conn -> closing ) { swWarn ( "The<S2SV_blank>connection[%d]<S2SV_blank>is<S2SV_blank>closing." , fd ) ; return SW_ERR ; } else if ( conn -> closed ) { return SW_ERR ; } else { do_close : conn -> closing = 1 ; if ( serv -> onClose != NULL ) { info . fd = fd ; <S2SV_StartBug> info . from_id = - 1 ; <S2SV_EndBug> info . from_fd = conn -> from_fd ; serv -> onClose ( serv , & info ) ; } conn -> closing = 0 ; conn -> closed = 1 ; conn -> close_errno = 0 ; if ( swBuffer_empty ( conn -> out_buffer ) || conn -> removed ) { swReactor * reactor = & serv -> reactor_threads [ SwooleTG . id ] . reactor ; return swReactorThread_close ( reactor , conn -> fd ) ; } else { swBuffer_trunk * trunk = swBuffer_new_trunk ( conn -> out_buffer , SW_CHUNK_CLOSE , 0 ) ; trunk -> store . data . val1 = _send . info . type ; return SW_OK ; } } } | <S2SV_ModStart> = fd ; if ( conn -> close_actively ) { <S2SV_ModStart> - 1 ; } else { info . from_id = conn -> from_id ; } |
5,440 | CWE-000 void generateTileMap ( GameStatePtr state ) { for ( int i = 0 ; i < TOTAL_GAME_TILES ; i ++ ) { state -> gameScreen . tileMap [ i ] . tilesetPosition = 0 ; state -> gameScreen . tileMap [ i ] . x = i % GAME_WIDTH ; state -> gameScreen . tileMap [ i ] . y = i / GAME_WIDTH ; } for ( int i = 0 ; i < TOTAL_ROOMS ; i ++ ) { state -> gameScreen . rooms [ i ] . location . x = 0 ; state -> gameScreen . rooms [ i ] . location . y = 0 ; state -> gameScreen . rooms [ i ] . location . w = 0 ; state -> gameScreen . rooms [ i ] . location . h = 0 ; } int i = 0 ; state -> gameScreen . rooms [ i ] . location . x = 0 ; state -> gameScreen . rooms [ i ] . location . y = 0 ; state -> gameScreen . rooms [ i ] . location . w = 40 ; state -> gameScreen . rooms [ i ++ ] . location . h = 20 ; state -> gameScreen . rooms [ i ] . location . x = 40 ; state -> gameScreen . rooms [ i ] . location . y = 10 ; state -> gameScreen . rooms [ i ] . location . w = 5 ; state -> gameScreen . rooms [ i ++ ] . location . h = 2 ; state -> gameScreen . rooms [ i ] . location . x = 0 ; state -> gameScreen . rooms [ i ] . location . y = 20 ; state -> gameScreen . rooms [ i ] . location . w = 2 ; state -> gameScreen . rooms [ i ++ ] . location . h = 2 ; state -> gameScreen . rooms [ i ] . location . x = 3 ; state -> gameScreen . rooms [ i ] . location . y = 20 ; state -> gameScreen . rooms [ i ] . location . w = 2 ; state -> gameScreen . rooms [ i ++ ] . location . h = 2 ; state -> gameScreen . rooms [ i ] . location . x = 5 ; state -> gameScreen . rooms [ i ] . location . y = 20 ; state -> gameScreen . rooms [ i ] . location . w = 5 ; state -> gameScreen . rooms [ i ++ ] . location . h = 10 ; state -> gameScreen . rooms [ i ] . location . x = 95 ; state -> gameScreen . rooms [ i ] . location . y = 20 ; state -> gameScreen . rooms [ i ] . location . w = 10 ; state -> gameScreen . rooms [ i ++ ] . location . h = 10 ; state -> gameScreen . rooms [ i ] . location . x = 102 ; state -> gameScreen . rooms [ i ] . location . y = 20 ; state -> gameScreen . rooms [ i ] . location . w = 10 ; state -> gameScreen . rooms [ i ++ ] . location . h = 10 ; state -> gameScreen . rooms [ i ] . location . x = 45 ; state -> gameScreen . rooms [ i ] . location . y = 5 ; state -> gameScreen . rooms [ i ] . location . w = 100 ; state -> gameScreen . rooms [ i ++ ] . location . h = 30 ; for ( int i = 0 ; i < TOTAL_ROOMS ; i ++ ) { SDL_Rect * rect = & state -> gameScreen . rooms [ i ] . location ; if ( rect -> x >= GAME_WIDTH - 1 ) { rect -> x = 0 ; rect -> y = 0 ; rect -> w = 0 ; rect -> h = 0 ; continue ; } if ( rect -> y >= GAME_HEIGHT - 1 ) { rect -> x = 0 ; rect -> y = 0 ; rect -> w = 0 ; rect -> h = 0 ; continue ; } <S2SV_StartBug> rect -> x += rect -> x + 2 < GAME_WIDTH ? 1 : 0 ; <S2SV_EndBug> rect -> w = GAME_WIDTH - rect -> x - 1 > rect -> w ? rect -> w : GAME_WIDTH - rect -> x - 1 ; rect -> y += rect -> y + 2 < GAME_WIDTH ? 1 : 0 ; rect -> h = GAME_HEIGHT - rect -> y - 1 > rect -> h ? rect -> h : GAME_HEIGHT - rect -> y - 1 ; state -> gameScreen . rooms [ i ] . location . y ++ ; } generateTileMapRooms ( state ) ; } | <S2SV_ModStart> continue ; } <S2SV_ModEnd> } generateTileMapRooms ( |
5,441 | CWE-000 <S2SV_StartBug> CFGFUN ( bar_modifier , const char * modifiers ) { <S2SV_EndBug> <S2SV_StartBug> current_bar -> modifier = modifiers ? event_state_from_str ( modifiers ) : XCB_NONE ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> CFGFUN ( bar_verbose <S2SV_ModEnd> , const char <S2SV_ModStart> const char * verbose <S2SV_ModEnd> ) { current_bar <S2SV_ModStart> { current_bar -> verbose = eval_boolstr ( verbose ) <S2SV_ModEnd> ; } <S2SV_null> |
5,442 | CWE-000 static void stopOverdubbing ( void ) { cc . track = looper -> selectedTrack ; cc . group = looper -> selectedGroup ; looper -> tracks [ cc . track ] . repeat = cc . repeat ; if ( looper -> tracks [ cc . track ] . endIdx < looper -> tracks [ cc . track ] . currIdx ) { looper -> tracks [ cc . track ] . endIdx = looper -> tracks [ cc . track ] . currIdx ; } <S2SV_StartBug> if ( looper -> masterLength < looper -> masterCurrIdx ) <S2SV_EndBug> { <S2SV_StartBug> looper -> masterLength = looper -> masterCurrIdx ; <S2SV_EndBug> looper -> masterCurrIdx = 0 ; } looper -> state = SYSTEM_STATE_PLAYBACK ; looper -> tracks [ cc . track ] . state = TRACK_STATE_PLAYBACK ; printf ( "Playing<S2SV_blank>track<S2SV_blank>%d\\n" , cc . track ) ; } | <S2SV_ModStart> looper -> masterLength [ cc . group ] <S2SV_ModStart> looper -> masterLength [ cc . group ] |
5,443 | CWE-000 static void vpic_notify_intr ( struct vpic * vpic ) { struct pic * pic ; int pin ; pic = & vpic -> pic [ 1 ] ; pin = vpic_get_highest_irrpin ( pic ) ; if ( ! pic -> intr_raised && pin != - 1 ) { dev_dbg ( ACRN_DBG_PIC , "pic<S2SV_blank>slave<S2SV_blank>notify<S2SV_blank>pin<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>(imr<S2SV_blank>0x%x<S2SV_blank>irr<S2SV_blank>0x%x<S2SV_blank>isr<S2SV_blank>0x%x)\\n" , pin , pic -> mask , pic -> request , pic -> service ) ; pic -> intr_raised = true ; vpic_set_pinstate ( vpic , 2 , true ) ; vpic_set_pinstate ( vpic , 2 , false ) ; } else { dev_dbg ( ACRN_DBG_PIC , "pic<S2SV_blank>slave<S2SV_blank>no<S2SV_blank>eligible<S2SV_blank>interrupt<S2SV_blank>(imr<S2SV_blank>0x%x<S2SV_blank>irr<S2SV_blank>0x%x<S2SV_blank>isr<S2SV_blank>0x%x)" , pic -> mask , pic -> request , pic -> service ) ; } pic = & vpic -> pic [ 0 ] ; pin = vpic_get_highest_irrpin ( pic ) ; if ( ! pic -> intr_raised && pin != - 1 ) { dev_dbg ( ACRN_DBG_PIC , "pic<S2SV_blank>master<S2SV_blank>notify<S2SV_blank>pin<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>(imr<S2SV_blank>0x%x<S2SV_blank>irr<S2SV_blank>0x%x<S2SV_blank>isr<S2SV_blank>0x%x)\\n" , pin , pic -> mask , pic -> request , pic -> service ) ; pic -> intr_raised = true ; if ( vpic -> vm -> vpic_wire_mode == VPIC_WIRE_INTR ) { struct vcpu * vcpu = vcpu_from_vid ( vpic -> vm , 0 ) ; ASSERT ( vcpu != NULL , "vm%d,<S2SV_blank>vcpu0" , vpic -> vm -> attr . id ) ; vcpu_inject_extint ( vcpu ) ; } else { <S2SV_StartBug> vlapic_set_local_intr ( vpic -> vm , - 1 , APIC_LVT_LINT0 ) ; <S2SV_EndBug> vioapic_pulse_irq ( vpic -> vm , 0 ) ; } } else { dev_dbg ( ACRN_DBG_PIC , "pic<S2SV_blank>master<S2SV_blank>no<S2SV_blank>eligible<S2SV_blank>interrupt<S2SV_blank>(imr<S2SV_blank>0x%x<S2SV_blank>irr<S2SV_blank>0x%x<S2SV_blank>isr<S2SV_blank>0x%x)" , pic -> mask , pic -> request , pic -> service ) ; } } | <S2SV_ModStart> -> vm , BROADCAST_PCPU_ID <S2SV_ModEnd> , APIC_LVT_LINT0 ) |
5,444 | CWE-000 static void poll_eventloop_run_once ( getdns_eventloop * loop , int blocking ) { _getdns_poll_eventloop * poll_loop = ( _getdns_poll_eventloop * ) loop ; struct mem_funcs * mf = & poll_loop -> mf ; _getdns_eventloop_info * s , * tmp ; uint64_t now , timeout = TIMEOUT_FOREVER ; size_t i = 0 ; int poll_timeout = 0 ; unsigned int num_pfds = 0 ; _getdns_eventloop_info * timeout_timeout_cbs = NULL ; _getdns_eventloop_info * fd_timeout_cbs = NULL ; if ( ! loop ) return ; now = get_now_plus ( 0 ) ; HASH_ITER ( hh , poll_loop -> timeout_events , s , tmp ) { if ( now > s -> timeout_time ) add_event ( mf , & timeout_timeout_cbs , s -> id , s ) ; else if ( s -> timeout_time < timeout ) timeout = s -> timeout_time ; } HASH_ITER ( hh , timeout_timeout_cbs , s , tmp ) { getdns_eventloop_event * event = s -> event ; delete_event ( mf , & timeout_timeout_cbs , s ) ; poll_timeout_cb ( - 1 , event ) ; } HASH_ITER ( hh , poll_loop -> fd_events , s , tmp ) { if ( s -> event -> read_cb || s -> event -> write_cb ) num_pfds ++ ; if ( s -> timeout_time < timeout ) timeout = s -> timeout_time ; } if ( ( timeout == TIMEOUT_FOREVER ) && ( num_pfds == 0 ) ) return ; if ( num_pfds > poll_loop -> pfds_capacity ) { poll_loop -> pfds_capacity = up_pow2 ( num_pfds ) ; if ( poll_loop -> pfds ) { poll_loop -> pfds = GETDNS_XMALLOC ( poll_loop -> mf , struct pollfd , poll_loop -> pfds_capacity ) ; } else poll_loop -> pfds = GETDNS_XREALLOC ( poll_loop -> mf , poll_loop -> pfds , struct pollfd , poll_loop -> pfds_capacity ) ; } i = 0 ; HASH_ITER ( hh , poll_loop -> fd_events , s , tmp ) { <S2SV_StartBug> if ( s -> event -> read_cb ) { <S2SV_EndBug> <S2SV_StartBug> poll_loop -> pfds [ i ] . fd = s -> id ; <S2SV_EndBug> poll_loop -> pfds [ i ] . events |= POLLIN ; <S2SV_StartBug> } <S2SV_EndBug> <S2SV_StartBug> if ( s -> event -> write_cb ) { <S2SV_EndBug> poll_loop -> pfds [ i ] . fd = s -> id ; poll_loop -> pfds [ i ] . events |= POLLOUT ; <S2SV_StartBug> } <S2SV_EndBug> i ++ ; <S2SV_StartBug> } <S2SV_EndBug> if ( timeout == TIMEOUT_FOREVER ) { poll_timeout = - 1 ; } else if ( ! blocking || now > timeout ) { poll_timeout = 0 ; } else { poll_timeout = ( timeout - now ) / 1000 ; } # ifdef USE_WINSOCK if ( WSAPoll ( poll_loop -> pfds , num_pfds , poll_timeout ) < 0 ) { # else if ( poll ( poll_loop -> pfds , num_pfds , poll_timeout ) < 0 ) { # endif perror ( "poll()<S2SV_blank>failed" ) ; exit ( EXIT_FAILURE ) ; } now = get_now_plus ( 0 ) ; for ( i = 0 ; i < num_pfds ; i ++ ) { int fd = poll_loop -> pfds [ i ] . fd ; _getdns_eventloop_info * fd_event = find_event ( & poll_loop -> fd_events , fd ) ; if ( fd_event && fd_event -> event ) { getdns_eventloop_event * event = fd_event -> event ; if ( event -> read_cb && ( poll_loop -> pfds [ i ] . revents & POLLIN ) ) poll_read_cb ( fd , event ) ; if ( event -> write_cb && ( poll_loop -> pfds [ i ] . revents & POLLOUT ) ) poll_write_cb ( fd , event ) ; } } HASH_ITER ( hh , poll_loop -> fd_events , s , tmp ) { if ( s -> event && s -> event -> timeout_cb && now > s -> timeout_time ) add_event ( mf , & fd_timeout_cbs , s -> id , s ) ; } HASH_ITER ( hh , fd_timeout_cbs , s , tmp ) { int fd = s -> id ; getdns_eventloop_event * event = s -> event ; delete_event ( mf , & fd_timeout_cbs , s ) ; poll_timeout_cb ( fd , event ) ; } HASH_ITER ( hh , poll_loop -> timeout_events , s , tmp ) { if ( s -> event && s -> event -> timeout_cb && now > s -> timeout_time ) add_event ( mf , & timeout_timeout_cbs , s -> id , s ) ; } HASH_ITER ( hh , timeout_timeout_cbs , s , tmp ) { getdns_eventloop_event * event = s -> event ; delete_event ( mf , & timeout_timeout_cbs , s ) ; poll_timeout_cb ( - 1 , event ) ; } } | <S2SV_ModStart> { if ( ! <S2SV_ModStart> event -> read_cb && ! s -> event -> write_cb ) continue ; <S2SV_ModEnd> poll_loop -> pfds <S2SV_ModStart> -> id ; poll_loop -> pfds [ i ] . events = 0 ; poll_loop -> pfds [ i ] . revents = 0 ; if ( s -> event -> read_cb ) <S2SV_ModStart> |= POLLIN ; <S2SV_ModEnd> if ( s <S2SV_ModStart> -> write_cb ) <S2SV_ModEnd> poll_loop -> pfds <S2SV_ModStart> |= POLLOUT ; <S2SV_ModEnd> i ++ ; <S2SV_ModStart> ++ ; } assert ( i == num_pfds ) ; |
5,445 | CWE-000 int fdReady ( int fd , int write , int msecs , int isSock ) { Time endTime = 0 ; if ( msecs > 0 ) { endTime = getProcessElapsedTime ( ) + MSToTime ( msecs ) ; } # if ! defined ( _WIN32 ) struct pollfd fds [ 1 ] ; fds [ 0 ] . fd = fd ; fds [ 0 ] . events = write ? POLLOUT : POLLIN ; fds [ 0 ] . revents = 0 ; Time remaining = MSToTime ( msecs ) ; int res ; while ( ( res = poll ( fds , 1 , TimeToMS ( remaining ) ) ) < 0 ) { if ( errno == EINTR ) { if ( msecs > 0 ) { Time now = getProcessElapsedTime ( ) ; if ( now >= endTime ) return 0 ; remaining = endTime - now ; } } else { return ( - 1 ) ; } } return ( res > 0 ) ; # else if ( isSock ) { int maxfd , ready ; fd_set rfd , wfd ; struct timeval remaining_tv ; if ( ( fd >= ( int ) FD_SETSIZE ) || ( fd < 0 ) ) { barf ( "fdReady:<S2SV_blank>fd<S2SV_blank>is<S2SV_blank>too<S2SV_blank>big:<S2SV_blank>%d<S2SV_blank>but<S2SV_blank>FD_SETSIZE<S2SV_blank>is<S2SV_blank>%d" , fd , ( int ) FD_SETSIZE ) ; } FD_ZERO ( & rfd ) ; FD_ZERO ( & wfd ) ; if ( write ) { FD_SET ( fd , & wfd ) ; } else { FD_SET ( fd , & rfd ) ; } maxfd = fd + 1 ; Time remaining = MSToTime ( msecs ) ; remaining_tv . tv_sec = TimeToMS ( remaining ) / 1000 ; remaining_tv . tv_usec = TimeToUS ( remaining ) % 1000000 ; while ( ( ready = select ( maxfd , & rfd , & wfd , NULL , & remaining_tv ) ) < 0 ) { if ( errno == EINTR ) { if ( msecs > 0 ) { Time now = getProcessElapsedTime ( ) ; if ( now >= endTime ) return 0 ; remaining = endTime - now ; remaining_tv . tv_sec = TimeToMS ( remaining ) / 1000 ; remaining_tv . tv_usec = TimeToUS ( remaining ) % 1000000 ; } } else { return ( - 1 ) ; } } return ( ready ) ; } else { DWORD rc ; HANDLE hFile = ( HANDLE ) _get_osfhandle ( fd ) ; DWORD avail = 0 ; Time remaining = MSToTime ( msecs ) ; switch ( GetFileType ( hFile ) ) { case FILE_TYPE_CHAR : { INPUT_RECORD buf [ 1 ] ; DWORD count ; while ( 1 ) { DWORD wait_ms = ( DWORD ) max ( 0 , TimeToMS ( remaining ) ) ; rc = WaitForSingleObject ( hFile , wait_ms ) ; switch ( rc ) { case WAIT_TIMEOUT : return 0 ; case WAIT_OBJECT_0 : break ; default : maperrno ( ) ; return - 1 ; } while ( 1 ) { <S2SV_StartBug> rc = PeekConsoleInput ( hFile , buf , 1 , & count ) ; <S2SV_EndBug> <S2SV_StartBug> if ( rc == 0 ) { <S2SV_EndBug> rc = GetLastError ( ) ; if ( rc == ERROR_INVALID_HANDLE || rc == ERROR_INVALID_FUNCTION ) { return 1 ; } else { maperrno ( ) ; return - 1 ; } } if ( count == 0 ) break ; if ( buf [ 0 ] . EventType == KEY_EVENT && buf [ 0 ] . Event . KeyEvent . bKeyDown && buf [ 0 ] . Event . KeyEvent . uChar . AsciiChar != '\\0' ) { return 1 ; } else { <S2SV_StartBug> rc = ReadConsoleInput ( hFile , buf , 1 , & count ) ; <S2SV_EndBug> <S2SV_StartBug> if ( rc == 0 ) { <S2SV_EndBug> rc = GetLastError ( ) ; if ( rc == ERROR_INVALID_HANDLE || rc == ERROR_INVALID_FUNCTION ) { return 1 ; } else { maperrno ( ) ; return - 1 ; } } } } Time now = getProcessElapsedTime ( ) ; remaining = endTime - now ; } } case FILE_TYPE_DISK : return 1 ; case FILE_TYPE_PIPE : while ( avail == 0 ) { <S2SV_StartBug> rc = PeekNamedPipe ( hFile , NULL , 0 , NULL , & avail , NULL ) ; <S2SV_EndBug> <S2SV_StartBug> if ( rc != 0 ) { <S2SV_EndBug> if ( avail != 0 ) { return 1 ; } else { if ( msecs > 0 ) { Time now = getProcessElapsedTime ( ) ; if ( now >= endTime ) return 0 ; Sleep ( 1 ) ; continue ; } else { return 0 ; } } } else { rc = GetLastError ( ) ; if ( rc == ERROR_BROKEN_PIPE ) { return 1 ; } if ( rc != ERROR_INVALID_HANDLE && rc != ERROR_INVALID_FUNCTION ) { maperrno ( ) ; return - 1 ; } } } default : <S2SV_StartBug> rc = WaitForSingleObject ( hFile , msecs ) ; <S2SV_EndBug> switch ( rc ) { case WAIT_TIMEOUT : return 0 ; case WAIT_OBJECT_0 : return 1 ; default : maperrno ( ) ; return - 1 ; } } } # endif } | <S2SV_ModStart> 1 ) { BOOL success <S2SV_ModEnd> = PeekConsoleInput ( <S2SV_ModStart> ; if ( ! success <S2SV_ModEnd> ) { rc <S2SV_ModStart> } else { BOOL success <S2SV_ModEnd> = ReadConsoleInput ( <S2SV_ModStart> ; if ( ! success <S2SV_ModEnd> ) { rc <S2SV_ModStart> 0 ) { BOOL success <S2SV_ModEnd> = PeekNamedPipe ( <S2SV_ModStart> ; if ( success <S2SV_ModEnd> ) { if <S2SV_ModStart> ( hFile , ( DWORD ) |
5,446 | CWE-000 void cursorremove ( struct mace * m , struct cursor * c ) { <S2SV_StartBug> struct cursor * p ; <S2SV_EndBug> if ( m -> cursors == c ) { m -> cursors = c -> next ; } else { <S2SV_StartBug> for ( p = m -> cursors ; p -> next != c && p -> next != NULL ; p = p -> next ) <S2SV_EndBug> ; <S2SV_StartBug> if ( p -> next == c ) { <S2SV_EndBug> p -> next = c -> next ; <S2SV_StartBug> } <S2SV_EndBug> } free ( c ) ; } | <S2SV_ModStart> struct cursor * * p ; <S2SV_ModEnd> for ( p <S2SV_ModStart> ( p = & <S2SV_ModStart> -> cursors ; * p != NULL && * p != c <S2SV_ModEnd> ; p = <S2SV_ModStart> ; p = & ( * p ) <S2SV_ModEnd> -> next ) <S2SV_ModStart> next ) ; * p <S2SV_ModEnd> = c -> <S2SV_ModStart> -> next ; <S2SV_ModEnd> free ( c |
5,447 | CWE-000 static gboolean _test_output ( DnfSwdb * self , gint tid , const gchar * o_type ) { <S2SV_StartBug> const gint type = dnf_swdb_get_output_type ( self , o_type ) ; <S2SV_EndBug> sqlite3_stmt * res ; const gchar * sql = LOAD_OUTPUT ; DB_PREP ( self -> db , sql , res ) ; DB_BIND_INT ( res , "@tid" , tid ) ; DB_BIND_INT ( res , "@type" , type ) ; if ( sqlite3_step ( res ) == SQLITE_ROW ) { sqlite3_finalize ( res ) ; return 1 ; } sqlite3_finalize ( res ) ; return 0 ; } | <S2SV_ModStart> o_type ) { DB_TRANS_BEGIN <S2SV_ModEnd> gint type = <S2SV_ModStart> o_type ) ; DB_TRANS_END |
5,448 | CWE-000 static void mirror_start_job ( const char * job_id , BlockDriverState * bs , int creation_flags , BlockDriverState * target , const char * replaces , int64_t speed , uint32_t granularity , int64_t buf_size , BlockMirrorBackingMode backing_mode , BlockdevOnError on_source_error , BlockdevOnError on_target_error , bool unmap , BlockCompletionFunc * cb , void * opaque , const BlockJobDriver * driver , bool is_none_mode , BlockDriverState * base , bool auto_complete , const char * filter_node_name , bool is_mirror , MirrorCopyMode copy_mode , Error * * errp ) { MirrorBlockJob * s ; MirrorBDSOpaque * bs_opaque ; BlockDriverState * mirror_top_bs ; bool target_graph_mod ; bool target_is_backing ; Error * local_err = NULL ; int ret ; if ( granularity == 0 ) { granularity = bdrv_get_default_bitmap_granularity ( target ) ; } assert ( is_power_of_2 ( granularity ) ) ; if ( buf_size < 0 ) { error_setg ( errp , "Invalid<S2SV_blank>parameter<S2SV_blank>\'buf-size\'" ) ; return ; } if ( buf_size == 0 ) { <S2SV_StartBug> buf_size = DEFAULT_MIRROR_BUF_SIZE ; <S2SV_EndBug> } mirror_top_bs = bdrv_new_open_driver ( & bdrv_mirror_top , filter_node_name , BDRV_O_RDWR , errp ) ; if ( mirror_top_bs == NULL ) { return ; } if ( ! filter_node_name ) { mirror_top_bs -> implicit = true ; } mirror_top_bs -> total_sectors = bs -> total_sectors ; mirror_top_bs -> supported_write_flags = BDRV_REQ_WRITE_UNCHANGED ; mirror_top_bs -> supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED ; bs_opaque = g_new0 ( MirrorBDSOpaque , 1 ) ; mirror_top_bs -> opaque = bs_opaque ; bdrv_set_aio_context ( mirror_top_bs , bdrv_get_aio_context ( bs ) ) ; bdrv_ref ( mirror_top_bs ) ; bdrv_drained_begin ( bs ) ; bdrv_append ( mirror_top_bs , bs , & local_err ) ; bdrv_drained_end ( bs ) ; if ( local_err ) { bdrv_unref ( mirror_top_bs ) ; error_propagate ( errp , local_err ) ; return ; } s = block_job_create ( job_id , driver , NULL , mirror_top_bs , BLK_PERM_CONSISTENT_READ , BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED | BLK_PERM_WRITE | BLK_PERM_GRAPH_MOD , speed , creation_flags , cb , opaque , errp ) ; if ( ! s ) { goto fail ; } bs_opaque -> job = s ; bdrv_unref ( mirror_top_bs ) ; s -> mirror_top_bs = mirror_top_bs ; target_is_backing = bdrv_chain_contains ( bs , target ) ; target_graph_mod = ( backing_mode != MIRROR_LEAVE_BACKING_CHAIN ) ; s -> target = blk_new ( BLK_PERM_WRITE | BLK_PERM_RESIZE | ( target_graph_mod ? BLK_PERM_GRAPH_MOD : 0 ) , BLK_PERM_WRITE_UNCHANGED | ( target_is_backing ? BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE | BLK_PERM_GRAPH_MOD : 0 ) ) ; ret = blk_insert_bs ( s -> target , target , errp ) ; if ( ret < 0 ) { goto fail ; } if ( is_mirror ) { blk_set_force_allow_inactivate ( s -> target ) ; } s -> replaces = g_strdup ( replaces ) ; s -> on_source_error = on_source_error ; s -> on_target_error = on_target_error ; s -> is_none_mode = is_none_mode ; s -> backing_mode = backing_mode ; s -> copy_mode = copy_mode ; s -> base = base ; s -> granularity = granularity ; s -> buf_size = ROUND_UP ( buf_size , granularity ) ; s -> unmap = unmap ; if ( auto_complete ) { s -> should_complete = true ; } s -> dirty_bitmap = bdrv_create_dirty_bitmap ( bs , granularity , NULL , errp ) ; if ( ! s -> dirty_bitmap ) { goto fail ; } block_job_add_bdrv ( & s -> common , "target" , target , 0 , BLK_PERM_ALL , & error_abort ) ; if ( target_is_backing ) { BlockDriverState * iter ; for ( iter = backing_bs ( bs ) ; iter != target ; iter = backing_bs ( iter ) ) { ret = block_job_add_bdrv ( & s -> common , "intermediate<S2SV_blank>node" , iter , 0 , BLK_PERM_WRITE_UNCHANGED | BLK_PERM_WRITE , errp ) ; if ( ret < 0 ) { goto fail ; } } } QTAILQ_INIT ( & s -> ops_in_flight ) ; trace_mirror_start ( bs , s , opaque ) ; job_start ( & s -> common . job ) ; return ; fail : if ( s ) { bdrv_ref ( mirror_top_bs ) ; g_free ( s -> replaces ) ; blk_unref ( s -> target ) ; bs_opaque -> job = NULL ; job_early_fail ( & s -> common . job ) ; } bdrv_child_try_set_perm ( mirror_top_bs -> backing , 0 , BLK_PERM_ALL , & error_abort ) ; bdrv_replace_node ( mirror_top_bs , backing_bs ( mirror_top_bs ) , & error_abort ) ; bdrv_unref ( mirror_top_bs ) ; } | <S2SV_ModStart> buf_size = DEFAULT_MIRROR_BUF_SIZE ; } if ( bs == target ) { error_setg ( errp , "Can\'t<S2SV_blank>mirror<S2SV_blank>node<S2SV_blank>into<S2SV_blank>itself" ) ; return |
5,449 | CWE-000 static void tlbi_aa64_alle3is_write ( CPUARMState * env , const ARMCPRegInfo * ri , uint64_t value ) { <S2SV_StartBug> CPUState * other_cs ; <S2SV_EndBug> CPU_FOREACH ( other_cs ) { tlb_flush_by_mmuidx ( other_cs , ( 1 << ARMMMUIdx_S1E3 ) ) ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> { CPUState * cs = ENV_GET_CPU ( env ) ; tlb_flush_by_mmuidx_all_cpus_synced ( cs <S2SV_ModEnd> , ( 1 <S2SV_ModStart> ) ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
5,450 | CWE-000 static ssize_t keychord_write ( struct file * file , const char __user * buffer , size_t count , loff_t * ppos ) { struct keychord_device * kdev = file -> private_data ; struct input_keychord * keychords = 0 ; struct input_keychord * keychord ; int ret , i , key ; unsigned long flags ; size_t resid = count ; size_t key_bytes ; if ( count < sizeof ( struct input_keychord ) ) return - EINVAL ; keychords = kzalloc ( count , GFP_KERNEL ) ; if ( ! keychords ) return - ENOMEM ; if ( copy_from_user ( keychords , buffer , count ) ) { kfree ( keychords ) ; return - EFAULT ; } <S2SV_StartBug> if ( kdev -> registered ) { <S2SV_EndBug> input_unregister_handler ( & kdev -> input_handler ) ; kdev -> registered = 0 ; } spin_lock_irqsave ( & kdev -> lock , flags ) ; kfree ( kdev -> keychords ) ; kdev -> keychords = 0 ; kdev -> keychord_count = 0 ; kdev -> key_down = 0 ; memset ( kdev -> keybit , 0 , sizeof ( kdev -> keybit ) ) ; memset ( kdev -> keystate , 0 , sizeof ( kdev -> keystate ) ) ; kdev -> head = kdev -> tail = 0 ; keychord = keychords ; while ( resid > 0 ) { if ( resid < sizeof ( struct input_keychord ) ) { pr_err ( "keychord:<S2SV_blank>Insufficient<S2SV_blank>bytes<S2SV_blank>present<S2SV_blank>for<S2SV_blank>header<S2SV_blank>%lu\\n" , resid ) ; goto err_unlock_return ; } resid -= sizeof ( struct input_keychord ) ; if ( keychord -> count <= 0 ) { pr_err ( "keychord:<S2SV_blank>invalid<S2SV_blank>keycode<S2SV_blank>count<S2SV_blank>%d\\n" , keychord -> count ) ; goto err_unlock_return ; } key_bytes = keychord -> count * sizeof ( keychord -> keycodes [ 0 ] ) ; if ( resid < key_bytes ) { pr_err ( "keychord:<S2SV_blank>Insufficient<S2SV_blank>bytes<S2SV_blank>present<S2SV_blank>for<S2SV_blank>keycount<S2SV_blank>%lu\\n" , resid ) ; goto err_unlock_return ; } resid -= key_bytes ; if ( keychord -> version != KEYCHORD_VERSION ) { pr_err ( "keychord:<S2SV_blank>unsupported<S2SV_blank>version<S2SV_blank>%d\\n" , keychord -> version ) ; goto err_unlock_return ; } for ( i = 0 ; i < keychord -> count ; i ++ ) { key = keychord -> keycodes [ i ] ; if ( key < 0 || key >= KEY_CNT ) { pr_err ( "keychord:<S2SV_blank>keycode<S2SV_blank>%d<S2SV_blank>out<S2SV_blank>of<S2SV_blank>range\\n" , key ) ; goto err_unlock_return ; } __set_bit ( key , kdev -> keybit ) ; } kdev -> keychord_count ++ ; keychord = NEXT_KEYCHORD ( keychord ) ; } kdev -> keychords = keychords ; spin_unlock_irqrestore ( & kdev -> lock , flags ) ; ret = input_register_handler ( & kdev -> input_handler ) ; if ( ret ) { kfree ( keychords ) ; kdev -> keychords = 0 ; <S2SV_StartBug> return ret ; <S2SV_EndBug> } kdev -> registered = 1 ; <S2SV_StartBug> return count ; <S2SV_EndBug> err_unlock_return : spin_unlock_irqrestore ( & kdev -> lock , flags ) ; <S2SV_StartBug> kfree ( keychords ) ; <S2SV_EndBug> return - EINVAL ; } | <S2SV_ModStart> EFAULT ; } ret = keychord_write_lock ( kdev ) ; if ( ret ) { kfree ( keychords ) ; return ret ; } <S2SV_ModStart> = 0 ; keychord_write_unlock ( kdev ) ; <S2SV_ModStart> = 1 ; keychord_write_unlock ( kdev ) ; <S2SV_ModStart> kfree ( keychords ) ; keychord_write_unlock ( kdev |
5,451 | CWE-000 static int mkv_write_tags ( AVFormatContext * s ) { MatroskaMuxContext * mkv = s -> priv_data ; int i , ret ; ff_metadata_conv_ctx ( s , ff_mkv_metadata_conv , NULL ) ; if ( mkv_check_tag ( s -> metadata , 0 ) ) { ret = mkv_write_tag ( s , s -> metadata , 0 , 0 , & mkv -> tags ) ; if ( ret < 0 ) return ret ; } for ( i = 0 ; i < s -> nb_streams ; i ++ ) { AVStream * st = s -> streams [ i ] ; if ( st -> codecpar -> codec_type == AVMEDIA_TYPE_ATTACHMENT ) continue ; if ( ! mkv_check_tag ( st -> metadata , MATROSKA_ID_TAGTARGETS_TRACKUID ) ) continue ; ret = mkv_write_tag ( s , st -> metadata , MATROSKA_ID_TAGTARGETS_TRACKUID , i + 1 , & mkv -> tags ) ; if ( ret < 0 ) return ret ; } if ( s -> pb -> seekable && ! mkv -> is_live ) { for ( i = 0 ; i < s -> nb_streams ; i ++ ) { AVIOContext * pb ; AVStream * st = s -> streams [ i ] ; ebml_master tag_target ; ebml_master tag ; if ( st -> codecpar -> codec_type == AVMEDIA_TYPE_ATTACHMENT ) continue ; mkv_write_tag_targets ( s , MATROSKA_ID_TAGTARGETS_TRACKUID , i + 1 , & mkv -> tags , & tag_target ) ; pb = mkv -> tags_bc ; tag = start_ebml_master ( pb , MATROSKA_ID_SIMPLETAG , 0 ) ; put_ebml_string ( pb , MATROSKA_ID_TAGNAME , "DURATION" ) ; mkv -> stream_duration_offsets [ i ] = avio_tell ( pb ) ; put_ebml_void ( pb , 23 ) ; end_ebml_master ( pb , tag ) ; end_ebml_master ( pb , tag_target ) ; } } for ( i = 0 ; i < s -> nb_chapters ; i ++ ) { AVChapter * ch = s -> chapters [ i ] ; if ( ! mkv_check_tag ( ch -> metadata , MATROSKA_ID_TAGTARGETS_CHAPTERUID ) ) continue ; ret = mkv_write_tag ( s , ch -> metadata , MATROSKA_ID_TAGTARGETS_CHAPTERUID , ch -> id + mkv -> chapter_id_offset , & mkv -> tags ) ; if ( ret < 0 ) return ret ; } if ( mkv -> have_attachments ) { for ( i = 0 ; i < mkv -> attachments -> num_entries ; i ++ ) { mkv_attachment * attachment = & mkv -> attachments -> entries [ i ] ; AVStream * st = s -> streams [ attachment -> stream_idx ] ; if ( ! mkv_check_tag ( st -> metadata , MATROSKA_ID_TAGTARGETS_ATTACHUID ) ) continue ; ret = mkv_write_tag ( s , st -> metadata , MATROSKA_ID_TAGTARGETS_ATTACHUID , attachment -> fileuid , & mkv -> tags ) ; if ( ret < 0 ) return ret ; } } if ( mkv -> tags . pos ) { if ( s -> pb -> seekable && ! mkv -> is_live ) <S2SV_StartBug> put_ebml_void ( s -> pb , avio_tell ( mkv -> tags_bc ) ) ; <S2SV_EndBug> else end_ebml_master_crc32 ( s -> pb , & mkv -> tags_bc , mkv , mkv -> tags ) ; } return 0 ; } | <S2SV_ModStart> -> is_live ) end_ebml_master_crc32_preliminary ( s -> pb , & <S2SV_ModEnd> mkv -> tags_bc <S2SV_ModStart> mkv -> tags_bc , mkv , mkv -> tags <S2SV_ModEnd> ) ; else |
5,452 | CWE-000 off_t riomap ( int socket , void * buf , size_t len , int prot , int flags , off_t offset ) { struct rsocket * rs ; struct rs_iomap_mr * iomr ; int access = IBV_ACCESS_LOCAL_WRITE ; rs = idm_at ( & idm , socket ) ; <S2SV_StartBug> if ( ! rs -> cm_id -> pd || ( prot & ~ ( PROT_WRITE | PROT_NONE ) ) ) <S2SV_EndBug> return ERR ( EINVAL ) ; fastlock_acquire ( & rs -> map_lock ) ; if ( prot & PROT_WRITE ) { iomr = rs_get_iomap_mr ( rs ) ; access |= IBV_ACCESS_REMOTE_WRITE ; } else { iomr = calloc ( 1 , sizeof ( * iomr ) ) ; iomr -> index = - 1 ; } if ( ! iomr ) { offset = ERR ( ENOMEM ) ; goto out ; } iomr -> mr = ibv_reg_mr ( rs -> cm_id -> pd , buf , len , access ) ; if ( ! iomr -> mr ) { if ( iomr -> index < 0 ) free ( iomr ) ; offset = - 1 ; goto out ; } if ( offset == - 1 ) offset = ( uintptr_t ) buf ; iomr -> offset = offset ; atomic_store ( & iomr -> refcnt , 1 ) ; if ( iomr -> index >= 0 ) { dlist_insert_tail ( & iomr -> entry , & rs -> iomap_queue ) ; rs -> iomap_pending = 1 ; } else { dlist_insert_tail ( & iomr -> entry , & rs -> iomap_list ) ; } out : fastlock_release ( & rs -> map_lock ) ; return offset ; } | <S2SV_ModStart> ( ! rs ) return ERR ( EBADF ) ; if ( ! rs |
5,453 | CWE-000 static int msm_cci_probe ( struct platform_device * pdev ) { struct cci_device * new_cci_dev ; int rc = 0 ; <S2SV_StartBug> CDBG ( "%s:<S2SV_blank>pdev<S2SV_blank>%p<S2SV_blank>device<S2SV_blank>id<S2SV_blank>=<S2SV_blank>%d\\n" , __func__ , pdev , pdev -> id ) ; <S2SV_EndBug> new_cci_dev = kzalloc ( sizeof ( struct cci_device ) , GFP_KERNEL ) ; if ( ! new_cci_dev ) { CDBG ( "%s:<S2SV_blank>no<S2SV_blank>enough<S2SV_blank>memory\\n" , __func__ ) ; return - ENOMEM ; } v4l2_subdev_init ( & new_cci_dev -> msm_sd . sd , & msm_cci_subdev_ops ) ; new_cci_dev -> msm_sd . sd . internal_ops = & msm_cci_internal_ops ; snprintf ( new_cci_dev -> msm_sd . sd . name , ARRAY_SIZE ( new_cci_dev -> msm_sd . sd . name ) , "msm_cci" ) ; v4l2_set_subdevdata ( & new_cci_dev -> msm_sd . sd , new_cci_dev ) ; platform_set_drvdata ( pdev , & new_cci_dev -> msm_sd . sd ) ; <S2SV_StartBug> CDBG ( "%s<S2SV_blank>sd<S2SV_blank>%p\\n" , __func__ , & new_cci_dev -> msm_sd . sd ) ; <S2SV_EndBug> if ( pdev -> dev . of_node ) of_property_read_u32 ( ( & pdev -> dev ) -> of_node , "cell-index" , & pdev -> id ) ; new_cci_dev -> reg_ptr = NULL ; rc = msm_cci_get_clk_info ( new_cci_dev , pdev ) ; if ( rc < 0 ) { pr_err ( "%s:<S2SV_blank>msm_cci_get_clk_info()<S2SV_blank>failed" , __func__ ) ; return - EFAULT ; } new_cci_dev -> cycles_per_us = msm_get_cycles_per_ms ( ) ; new_cci_dev -> ref_count = 0 ; new_cci_dev -> mem = platform_get_resource_byname ( pdev , IORESOURCE_MEM , "cci" ) ; if ( ! new_cci_dev -> mem ) { CDBG ( "%s:<S2SV_blank>no<S2SV_blank>mem<S2SV_blank>resource?\\n" , __func__ ) ; rc = - ENODEV ; goto cci_no_resource ; } new_cci_dev -> irq = platform_get_resource_byname ( pdev , IORESOURCE_IRQ , "cci" ) ; CDBG ( "%s<S2SV_blank>line<S2SV_blank>%d<S2SV_blank>cci<S2SV_blank>irq<S2SV_blank>start<S2SV_blank>%d<S2SV_blank>end<S2SV_blank>%d\\n" , __func__ , __LINE__ , ( int ) new_cci_dev -> irq -> start , ( int ) new_cci_dev -> irq -> end ) ; if ( ! new_cci_dev -> irq ) { CDBG ( "%s:<S2SV_blank>no<S2SV_blank>irq<S2SV_blank>resource?\\n" , __func__ ) ; rc = - ENODEV ; goto cci_no_resource ; } new_cci_dev -> io = request_mem_region ( new_cci_dev -> mem -> start , resource_size ( new_cci_dev -> mem ) , pdev -> name ) ; if ( ! new_cci_dev -> io ) { CDBG ( "%s:<S2SV_blank>no<S2SV_blank>valid<S2SV_blank>mem<S2SV_blank>region\\n" , __func__ ) ; rc = - EBUSY ; goto cci_no_resource ; } new_cci_dev -> base = ioremap ( new_cci_dev -> mem -> start , resource_size ( new_cci_dev -> mem ) ) ; if ( ! new_cci_dev -> base ) { rc = - ENOMEM ; goto cci_release_mem ; } rc = request_irq ( new_cci_dev -> irq -> start , msm_cci_irq , IRQF_TRIGGER_RISING , "cci" , new_cci_dev ) ; if ( rc < 0 ) { CDBG ( "%s:<S2SV_blank>irq<S2SV_blank>request<S2SV_blank>fail\\n" , __func__ ) ; rc = - EBUSY ; goto cci_release_mem ; } disable_irq ( new_cci_dev -> irq -> start ) ; new_cci_dev -> msm_sd . close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x6 ; msm_sd_register ( & new_cci_dev -> msm_sd ) ; new_cci_dev -> pdev = pdev ; msm_cci_init_cci_params ( new_cci_dev ) ; msm_cci_init_clk_params ( new_cci_dev ) ; msm_cci_init_gpio_params ( new_cci_dev ) ; rc = of_platform_populate ( pdev -> dev . of_node , NULL , NULL , & pdev -> dev ) ; if ( rc ) pr_err ( "%s:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>add<S2SV_blank>child<S2SV_blank>nodes,<S2SV_blank>rc=%d\\n" , __func__ , rc ) ; new_cci_dev -> cci_state = CCI_STATE_DISABLED ; g_cci_subdev = & new_cci_dev -> msm_sd . sd ; mutex_init ( & new_cci_dev -> mutex ) ; <S2SV_StartBug> CDBG ( "%s<S2SV_blank>cci<S2SV_blank>subdev<S2SV_blank>%p\\n" , __func__ , & new_cci_dev -> msm_sd . sd ) ; <S2SV_EndBug> CDBG ( "%s<S2SV_blank>line<S2SV_blank>%d\\n" , __func__ , __LINE__ ) ; return 0 ; cci_release_mem : release_mem_region ( new_cci_dev -> mem -> start , resource_size ( new_cci_dev -> mem ) ) ; cci_no_resource : kfree ( new_cci_dev ) ; return 0 ; } | <S2SV_ModStart> ; CDBG ( "%s:<S2SV_blank>pdev<S2SV_blank>%pK<S2SV_blank>device<S2SV_blank>id<S2SV_blank>=<S2SV_blank>%d\\n" <S2SV_ModEnd> , __func__ , <S2SV_ModStart> ; CDBG ( "%s<S2SV_blank>sd<S2SV_blank>%pK\\n" <S2SV_ModEnd> , __func__ , <S2SV_ModStart> ; CDBG ( "%s<S2SV_blank>cci<S2SV_blank>subdev<S2SV_blank>%pK\\n" <S2SV_ModEnd> , __func__ , |
5,454 | CWE-000 void _error ( struct wrap * all , char * string ) { char * code ; int len = 0 , len1 = 0 , len2 = 0 , len3 = 0 ; while ( all -> cmdarray [ 0 ] [ len ] ) len ++ ; while ( all -> argvzero [ len1 ] != '\\0' ) len1 ++ ; code = intostring ( all -> loop ) ; while ( code [ len2 ] ) len2 ++ ; while ( string [ len3 ] ) len3 ++ ; <S2SV_StartBug> write ( 1 , all -> argvzero , len1 ) ; <S2SV_EndBug> <S2SV_StartBug> write ( 1 , ":<S2SV_blank>" , 2 ) ; <S2SV_EndBug> <S2SV_StartBug> write ( 1 , code , len2 ) ; <S2SV_EndBug> write ( 1 , ":<S2SV_blank>" , 2 ) ; <S2SV_StartBug> write ( 1 , all -> cmdarray [ 0 ] , len ) ; <S2SV_EndBug> <S2SV_StartBug> write ( 1 , ":<S2SV_blank>" , 2 ) ; <S2SV_EndBug> <S2SV_StartBug> write ( 1 , string , len3 ) ; <S2SV_EndBug> <S2SV_StartBug> write ( 1 , "\\n" , 2 ) ; <S2SV_EndBug> free ( code ) ; } | <S2SV_ModStart> ; write ( STDERR_FILENO <S2SV_ModEnd> , all -> <S2SV_ModStart> ; write ( STDERR_FILENO <S2SV_ModEnd> , ":<S2SV_blank>" , <S2SV_ModStart> ; write ( STDERR_FILENO , code , len2 ) ; write ( STDERR_FILENO <S2SV_ModEnd> , ":<S2SV_blank>" , <S2SV_ModStart> ; write ( STDERR_FILENO <S2SV_ModEnd> , all -> <S2SV_ModStart> ; write ( STDERR_FILENO <S2SV_ModEnd> , ":<S2SV_blank>" , <S2SV_ModStart> ; write ( STDERR_FILENO <S2SV_ModEnd> , string , <S2SV_ModStart> ; write ( STDERR_FILENO <S2SV_ModEnd> , "\\n" , |
5,455 | CWE-000 static void do_radix_tree_search ( ulong node , ulong slot , const char * path , ulong index , void * private ) { struct do_radix_tree_info * info = private ; <S2SV_StartBug> struct radix_tree_pair * rtp = info -> data ; <S2SV_EndBug> if ( rtp -> index == index ) { rtp -> value = ( void * ) slot ; info -> count = 1 ; } } | <S2SV_ModStart> private ; struct list_pair <S2SV_ModEnd> * rtp = |
5,456 | CWE-000 int jsal_push_new_iterator ( int for_index ) { <S2SV_StartBug> jsal_push_known_symbol ( "iterator" ) ; <S2SV_EndBug> <S2SV_StartBug> jsal_get_prop ( for_index ) ; <S2SV_EndBug> jsal_dup ( for_index ) ; jsal_call_method ( 0 ) ; <S2SV_StartBug> return jsal_get_top ( ) - 1 ; <S2SV_EndBug> } | <S2SV_ModStart> for_index ) { JsValueRef key_list ; JsValueRef object ; for_index = jsal_normalize_index ( for_index ) ; <S2SV_ModStart> "iterator" ) ; if ( <S2SV_ModStart> ( for_index ) ) { <S2SV_ModEnd> jsal_dup ( for_index <S2SV_ModStart> 0 ) ; } else { jsal_pop ( 1 ) ; object = get_value ( for_index ) ; JsGetOwnPropertyNames ( object , & key_list ) ; push_value ( key_list ) ; jsal_push_new_iterator ( - 1 ) ; jsal_remove ( - 2 ) ; } |
5,457 | CWE-000 static int add_search_paths ( sd_journal * j ) { static const char search_paths [ ] = "/run/log/journal\\0" "/var/log/journal\\0" ; const char * p ; assert ( j ) ; NULSTR_FOREACH ( p , search_paths ) ( void ) add_root_directory ( j , p , true ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> true ) ; if ( ! ( j -> flags & SD_JOURNAL_LOCAL_ONLY ) ) ( void ) add_root_directory ( j , "/var/log/journal/remote" , true ) ; |
5,458 | CWE-000 G_DEFINE_TYPE ( StackHelpGtkWindow , stack_help_gtk_window , G_TYPE_OBJECT ) static void stack_help_gtk_window_finalize ( GObject * ) ; <S2SV_StartBug> static void stack_help_gtk_window_on_destroy ( StackHelpGtkWindow * ) ; <S2SV_EndBug> static void stack_help_gtk_window_class_init ( StackHelpGtkWindowClass * klass ) { GObjectClass * gobject_class ; gobject_class = G_OBJECT_CLASS ( klass ) ; gobject_class -> finalize = stack_help_gtk_window_finalize ; stack_help_gtk_window_signals [ DESTROY_SIGNAL ] = g_signal_new ( g_intern_static_string ( "destroy-signal" ) , G_TYPE_FROM_CLASS ( gobject_class ) , G_SIGNAL_RUN_LAST , 0 , NULL , NULL , g_cclosure_marshal_VOID__VOID , G_TYPE_NONE , 0 ) ; } | <S2SV_ModStart> void stack_help_gtk_window_on_destroy ( GtkWindow * , gpointer <S2SV_ModEnd> ) ; static |
5,459 | CWE-000 static unsigned int ndpi_tg ( struct sk_buff * skb , const struct xt_action_param * par ) { const struct xt_ndpi_tginfo * info = par -> targinfo ; ndpi_protocol proto = NDPI_PROTOCOL_NULL ; struct ndpi_net * n = ndpi_pernet ( dev_net ( skb -> dev ? : skb_dst ( skb ) -> dev ) ) ; int mode = 0 ; if ( info -> p_proto_id || info -> m_proto_id || info -> any_proto_id ) { enum ip_conntrack_info ctinfo ; struct nf_conn * ct ; struct nf_ct_ext_ndpi * ct_ndpi ; ct = nf_ct_get ( skb , & ctinfo ) ; <S2SV_StartBug> # if LINUX_VERSION_CODE < KERNEL_VERSION ( 4 , 12 , 0 ) <S2SV_EndBug> <S2SV_StartBug> if ( ct && ! nf_ct_is_untracked ( ct ) ) <S2SV_EndBug> # else if ( ctinfo != IP_CT_UNTRACKED ) # endif { ct_ndpi = nf_ct_ext_find_ndpi ( ct ) ; if ( ct_ndpi ) { spin_lock_bh ( & ct_ndpi -> lock ) ; proto = ct_ndpi -> proto ; <S2SV_StartBug> spin_unlock_bh ( & ct_ndpi -> lock ) ; <S2SV_EndBug> } } if ( info -> m_proto_id ) mode |= 1 ; if ( info -> p_proto_id ) mode |= 2 ; if ( info -> any_proto_id ) mode |= 3 ; } if ( info -> t_mark ) { skb -> mark = ( skb -> mark & ~ info -> mask ) | info -> mark ; if ( mode ) ndpi_proto_markmask ( n , & skb -> mark , & proto , mode ) ; } if ( info -> t_clsf ) { skb -> priority = ( skb -> priority & ~ info -> mask ) | info -> mark ; if ( mode ) ndpi_proto_markmask ( n , & skb -> priority , & proto , mode ) ; } return info -> t_accept ? NF_ACCEPT : XT_CONTINUE ; } | <S2SV_ModStart> ctinfo ) ; if ( ct ) { <S2SV_ModStart> ) if ( <S2SV_ModEnd> ! nf_ct_is_untracked ( <S2SV_ModStart> lock ) ; } |
5,460 | CWE-000 static void _run_ast_sub ( AST * main ) { stdin = fopen ( ctermid ( NULL ) , "r" ) ; frame_stack = calloc ( 1 , sizeof * frame_stack ) ; <S2SV_StartBug> _run_func_decl ( main ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> frame_stack ) ; AST * fn_header = main -> getChildren <S2SV_ModEnd> ( main ) <S2SV_ModStart> main ) ; struct frame_t * frame = _initialize_frame ( main ) ; current_frame = frame ; _push_frame ( frame_stack , frame ) ; _run_func_body ( fn_header -> next_sibiling ) ; frame = _pop_frame ( frame_stack ) ; _delete_frame ( frame ) ; |
5,461 | CWE-000 static struct s_action_key * get_array_action_key ( void ) { static struct s_action_key actionk [ LE_NB_KEYS ] = { { LE_ARROW_RIGHT , & actionk_cursor_move_right } , { LE_ARROW_LEFT , & actionk_cursor_move_left } , { LE_CTRL_A , & actionk_move_cursor_start } , { LE_HOME , & actionk_move_cursor_start } , { LE_CTRL_E , & actionk_move_cursor_end } , { LE_END , & actionk_move_cursor_end } , { LE_ALT_RIGHT , & actionk_move_cursor_by_word_right } , { LE_ALT_LEFT , & actionk_move_cursor_by_word_left } , { LE_BACKSPACE , & actionk_delete_character } , { LE_DELETE , & actionk_delete_character } , { LE_CTRL_UP , & actionk_move_cursor_line_up } , { LE_CTRL_DOWN , & actionk_move_cursor_line_down } , { LE_CTRL_B , & actionk_copy_to_start } , { LE_CTRL_F , & actionk_copy_to_end } , { LE_CTRL_R , & actionk_copy_all } , { LE_CTRL_P , & actionk_past_clipboard } , { LE_CTRL_U , & actionk_delete_current_input } , { LE_CTRL_DASH , & actionk_cut_all } , { LE_CTRL_OPEN_SQUARE_BRACKET , & actionk_cut_to_start } , { LE_CTRL_CLOSE_SQUARE_BRACKET , & actionk_cut_to_end } , { LE_ARROW_UP , & actionk_history_up } , { LE_ARROW_DOWN , & actionk_history_down } , <S2SV_StartBug> { LE_CTRL_D , & actionk_eof } <S2SV_EndBug> } ; return ( actionk ) ; } | <S2SV_ModStart> & actionk_eof } , { LE_CTRL_L , & actionk_clear_screen } |
5,462 | CWE-000 static void gst_adaptive_demux_update_streams_segment ( GstAdaptiveDemux * demux , GList * streams , gint64 period_start , GstSeekType start_type , GstSeekType stop_type ) { GList * iter ; for ( iter = streams ; iter ; iter = g_list_next ( iter ) ) { GstAdaptiveDemuxStream * stream = iter -> data ; GstEvent * seg_evt ; GstClockTime offset ; stream -> segment = demux -> segment ; offset = gst_adaptive_demux_stream_get_presentation_offset ( demux , stream ) ; stream -> segment . start += offset - period_start ; if ( GST_CLOCK_TIME_IS_VALID ( demux -> segment . stop ) ) stream -> segment . stop += offset - period_start ; if ( demux -> segment . rate > 0 && start_type != GST_SEEK_TYPE_NONE ) stream -> segment . position = stream -> segment . start ; else if ( demux -> segment . rate < 0 && stop_type != GST_SEEK_TYPE_NONE ) stream -> segment . position = stream -> segment . stop ; seg_evt = gst_event_new_segment ( & stream -> segment ) ; gst_event_set_seqnum ( seg_evt , demux -> priv -> segment_seqnum ) ; gst_event_replace ( & stream -> pending_segment , seg_evt ) ; <S2SV_StartBug> GST_DEBUG_OBJECT ( stream -> pad , "Pending<S2SV_blank>segment<S2SV_blank>now<S2SV_blank>%" GST_SEGMENT_FORMAT , <S2SV_EndBug> & stream -> pending_segment ) ; gst_event_unref ( seg_evt ) ; stream -> discont = TRUE ; stream -> qos_earliest_time = GST_CLOCK_TIME_NONE ; } } | <S2SV_ModStart> pad , "Pending<S2SV_blank>segment<S2SV_blank>now<S2SV_blank>%" GST_PTR_FORMAT , <S2SV_ModEnd> stream -> pending_segment |
5,463 | CWE-000 int bt_mesh_net_decode ( struct net_buf_simple * data , enum bt_mesh_net_if net_if , struct bt_mesh_net_rx * rx , struct net_buf_simple * buf , struct net_buf_simple_state * state ) { if ( data -> len < 18 ) { BT_WARN ( "Dropping<S2SV_blank>too<S2SV_blank>short<S2SV_blank>mesh<S2SV_blank>packet<S2SV_blank>(len<S2SV_blank>%u)" , data -> len ) ; BT_WARN ( "%s" , bt_hex ( data -> data , data -> len ) ) ; return - EINVAL ; } if ( net_if == BT_MESH_NET_IF_ADV && check_dup ( data ) ) { return - EINVAL ; } BT_DBG ( "%u<S2SV_blank>bytes:<S2SV_blank>%s" , data -> len , bt_hex ( data -> data , data -> len ) ) ; rx -> net_if = net_if ; if ( net_if == BT_MESH_NET_IF_ADV ) { rx -> hash = msg_hash ( data ) ; } if ( ! net_find_and_decrypt ( data -> data , data -> len , rx , buf ) ) { BT_DBG ( "Unable<S2SV_blank>to<S2SV_blank>find<S2SV_blank>matching<S2SV_blank>net<S2SV_blank>for<S2SV_blank>packet" ) ; return - ENOENT ; } rx -> ctx . app_idx = BT_MESH_KEY_UNUSED ; if ( state ) { net_buf_simple_save ( buf , state ) ; } rx -> ctx . recv_ttl = TTL ( buf -> data ) ; if ( rx -> ctx . recv_ttl == 0 ) { rx -> ctx . send_ttl = 0 ; } else { rx -> ctx . send_ttl = BT_MESH_TTL_DEFAULT ; } rx -> ctl = CTL ( buf -> data ) ; net_buf_simple_pull ( buf , 2 ) ; rx -> seq = net_seq ( buf ) ; net_buf_simple_pull ( buf , 2 ) ; rx -> dst = net_buf_simple_pull_be16 ( buf ) ; BT_DBG ( "Decryption<S2SV_blank>successful.<S2SV_blank>Payload<S2SV_blank>len<S2SV_blank>%u" , buf -> len ) ; <S2SV_StartBug> if ( net_if != BT_MESH_NET_IF_LOCAL && bt_mesh_elem_find ( rx -> ctx . addr ) ) { <S2SV_EndBug> BT_DBG ( "Dropping<S2SV_blank>locally<S2SV_blank>originated<S2SV_blank>packet" ) ; return - EBADMSG ; } if ( net_if == BT_MESH_NET_IF_ADV ) { msg_cache_add ( rx -> hash ) ; } BT_DBG ( "src<S2SV_blank>0x%04x<S2SV_blank>dst<S2SV_blank>0x%04x<S2SV_blank>ttl<S2SV_blank>%u" , rx -> ctx . addr , rx -> dst , rx -> ctx . recv_ttl ) ; BT_DBG ( "PDU:<S2SV_blank>%s" , bt_hex ( buf -> data , buf -> len ) ) ; return 0 ; } | <S2SV_ModStart> ; if ( rx -> dst == BT_MESH_ADDR_UNASSIGNED ) { BT_ERR ( "Destination<S2SV_blank>address<S2SV_blank>is<S2SV_blank>unassigned;<S2SV_blank>dropping<S2SV_blank>packet" ) ; return - EBADMSG ; } if ( BT_MESH_ADDR_IS_RFU ( rx -> dst ) ) { BT_ERR ( "Destination<S2SV_blank>address<S2SV_blank>is<S2SV_blank>RFU;<S2SV_blank>dropping<S2SV_blank>packet" ) ; return - EBADMSG ; } if ( |
5,464 | CWE-000 char * open_file_dialog ( void ) { # ifndef _USE_GTK return NULL ; # else gulong response_handler ; char * filename = NULL ; static int old_dir_set = 0 ; static char file [ PATH_MAX ] ; static char old_dir [ PATH_MAX ] ; GtkWidget * file_dialog ; GtkFileFilter * file_filter_all ; GtkFileFilter * file_filter_zip ; file_filter_all = gtk_file_filter_new ( ) ; gtk_file_filter_add_pattern ( file_filter_all , "*" ) ; gtk_file_filter_set_name ( file_filter_all , "*" ) ; file_filter_zip = gtk_file_filter_new ( ) ; gtk_file_filter_add_pattern ( file_filter_zip , "*.zip" ) ; gtk_file_filter_add_pattern ( file_filter_zip , "main.lua" ) ; gtk_file_filter_add_pattern ( file_filter_zip , "main3.lua" ) ; gtk_file_filter_add_pattern ( file_filter_zip , "*.idf" ) ; gtk_file_filter_set_name ( file_filter_zip , "main?.lua;<S2SV_blank>*.zip;<S2SV_blank>*.idf" ) ; file [ 0 ] = 0 ; file_dialog = gtk_file_chooser_dialog_new ( BROWSE_MENU , NULL , GTK_FILE_CHOOSER_ACTION_OPEN , <S2SV_StartBug> GTK_STOCK_CANCEL , GTK_RESPONSE_CANCEL , <S2SV_EndBug> <S2SV_StartBug> GTK_STOCK_OPEN , GTK_RESPONSE_ACCEPT , NULL ) ; <S2SV_EndBug> if ( old_dir_set ) gtk_file_chooser_set_current_folder ( GTK_FILE_CHOOSER ( file_dialog ) , old_dir ) ; gtk_window_set_icon ( GTK_WINDOW ( file_dialog ) , create_pixbuf ( ICON_PATH "/sdl_instead.png" ) ) ; gtk_file_chooser_add_filter ( GTK_FILE_CHOOSER ( file_dialog ) , file_filter_all ) ; gtk_file_chooser_add_filter ( GTK_FILE_CHOOSER ( file_dialog ) , file_filter_zip ) ; gtk_file_chooser_set_filter ( GTK_FILE_CHOOSER ( file_dialog ) , file_filter_zip ) ; response_handler = g_signal_connect ( file_dialog , "response" , G_CALLBACK ( run_response_handler ) , NULL ) ; gtk_window_set_modal ( GTK_WINDOW ( file_dialog ) , TRUE ) ; gtk_widget_show ( file_dialog ) ; gtk_response = - 1 ; while ( gtk_response == - 1 ) { struct inp_event ev ; memset ( & ev , 0 , sizeof ( struct inp_event ) ) ; while ( gtk_events_pending ( ) ) { gtk_main_iteration ( ) ; while ( ( input ( & ev , 0 ) ) == AGAIN ) ; } while ( ( input ( & ev , 0 ) ) == AGAIN ) ; usleep ( HZ * 100 ) ; } if ( gtk_response == GTK_RESPONSE_ACCEPT ) { filename = gtk_file_chooser_get_filename ( GTK_FILE_CHOOSER ( file_dialog ) ) ; if ( filename ) { strcpy ( file , filename ) ; g_free ( filename ) ; } filename = gtk_file_chooser_get_current_folder ( GTK_FILE_CHOOSER ( file_dialog ) ) ; if ( filename ) { strcpy ( old_dir , filename ) ; g_free ( filename ) ; old_dir_set = 1 ; } } if ( gtk_response != GTK_RESPONSE_DELETE_EVENT ) { g_signal_handler_disconnect ( GTK_WIDGET ( file_dialog ) , response_handler ) ; gtk_widget_destroy ( GTK_WIDGET ( file_dialog ) ) ; } while ( gtk_events_pending ( ) ) gtk_main_iteration ( ) ; return ( file [ 0 ] ) ? file : NULL ; # endif } | <S2SV_ModStart> , GTK_FILE_CHOOSER_ACTION_OPEN , "_Cancel" <S2SV_ModEnd> , GTK_RESPONSE_CANCEL , <S2SV_ModStart> , GTK_RESPONSE_CANCEL , "_Open" <S2SV_ModEnd> , GTK_RESPONSE_ACCEPT , |
5,465 | CWE-000 void xwl_present_cleanup ( WindowPtr window ) { struct xwl_window * xwl_window = xwl_window_from_window ( window ) ; struct xwl_present_window * xwl_present_window = xwl_present_window_priv ( window ) ; struct xwl_present_event * event , * tmp ; if ( ! xwl_present_window ) return ; if ( xwl_window && xwl_window -> present_window == window ) xwl_window -> present_window = NULL ; RRCrtcDestroy ( xwl_present_window -> crtc_fake ) ; if ( xwl_present_window -> frame_callback ) { wl_callback_destroy ( xwl_present_window -> frame_callback ) ; xwl_present_window -> frame_callback = NULL ; } xorg_list_for_each_entry_safe ( event , tmp , & xwl_present_window -> event_list , list ) { xorg_list_del ( & event -> list ) ; free ( event ) ; } xorg_list_for_each_entry_safe ( event , tmp , & xwl_present_window -> release_queue , list ) { xorg_list_del ( & event -> list ) ; event -> abort = TRUE ; } xwl_present_free_timer ( xwl_present_window ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> xwl_present_window ) ; free ( xwl_present_window ) ; |
5,466 | CWE-000 TypeAST * parse_relation_term ( TypeAST * termType1 ) { check_int_float_type ( termType1 -> typeClass ) ; <S2SV_StartBug> TypeAST * termType2 = NULL , relationType = NULL ; <S2SV_EndBug> TokenType binOp = look_ahead -> type ; switch ( binOp ) { case T_LT : match_token ( T_LT ) ; termType2 = parse_term ( ) ; check_type_equality ( termType1 -> typeClass , termType2 -> typeClass ) ; relationType = parse_relation_term ( termType1 ) ; break ; case T_LTEQ : match_token ( T_LTEQ ) ; break ; termType2 = parse_term ( ) ; check_type_equality ( termType1 , termType2 ) ; relationType = parse_relation_term ( termType1 ) ; case T_GT : match_token ( T_GT ) ; termType2 = parse_term ( ) ; check_type_equality ( termType1 , termType2 ) ; relationType = parse_relation_term ( termType1 ) ; break ; case T_GTEQ : match_token ( T_GTEQ ) ; termType2 = parse_term ( ) ; check_type_equality ( termType1 , termType2 ) ; relationType = parse_relation_term ( termType1 ) ; break ; case T_EQ : match_token ( T_EQ ) ; termType2 = parse_term ( ) ; check_type_equality ( termType1 , termType2 ) ; relationType = parse_relation_term ( termType1 ) ; break ; case T_NEQ : match_token ( T_NEQ ) ; termType2 = parse_term ( ) ; check_type_equality ( termType1 , termType2 ) ; relationType = parse_relation_term ( termType1 ) ; break ; case T_PLUS : case T_MINUS : case T_AND : case T_OR : case T_COMMA : case T_RPAREN : case T_RBRACKET : case T_SEMI_COLON : relationType = termType1 ; break ; default : throw_error ( E_INVALID_RELATION , look_ahead -> lineNo , look_ahead -> columnNo ) ; break ; } return termType1 ; } | <S2SV_ModStart> termType2 = NULL ; TypeAST * <S2SV_ModEnd> relationType = NULL |
5,467 | CWE-000 <S2SV_StartBug> int pthread_attr_getstacksize ( const pthread_attr_t * attr , size_t * stacksize ) { <S2SV_EndBug> * stacksize = attr -> stack_size ; return 0 ; } | <S2SV_ModStart> pthread_attr_getstacksize ( const _pthread_attr_t <S2SV_ModEnd> * attr , |
5,468 | CWE-000 int BotVisibleEnemies ( bot_state_t * bs ) { int i ; aas_entityinfo_t entinfo ; <S2SV_StartBug> for ( i = 0 ; i < MAX_CLIENTS ; i ++ ) { <S2SV_EndBug> if ( i == bs -> client ) { continue ; } if ( BotSameTeam ( bs , i ) ) { continue ; } BotEntityInfo ( i , & entinfo ) ; if ( ! entinfo . valid ) { continue ; } if ( entinfo . number == bs -> entitynum ) { continue ; } if ( EntityIsDead ( & entinfo ) ) { continue ; } if ( EntityIsInvisible ( & entinfo ) ) { continue ; } if ( BotEntityVisible ( & bs -> cur_ps , 360 , i ) ) { return qtrue ; } } return qfalse ; } | <S2SV_ModStart> ; i < level . maxclients <S2SV_ModEnd> ; i ++ |
5,469 | CWE-000 char * str_tolower ( const char * buff , size_t nbytes , Oid collid ) { char * result ; if ( ! buff ) return NULL ; if ( lc_ctype_is_c ( collid ) ) { result = asc_tolower ( buff , nbytes ) ; } # ifdef USE_WIDE_UPPER_LOWER else { pg_locale_t mylocale = 0 ; if ( collid != DEFAULT_COLLATION_OID ) { if ( ! OidIsValid ( collid ) ) { ereport ( ERROR , ( errcode ( ERRCODE_INDETERMINATE_COLLATION ) , errmsg ( "could<S2SV_blank>not<S2SV_blank>determine<S2SV_blank>which<S2SV_blank>collation<S2SV_blank>to<S2SV_blank>use<S2SV_blank>for<S2SV_blank>lower()<S2SV_blank>function" ) , errhint ( "Use<S2SV_blank>the<S2SV_blank>COLLATE<S2SV_blank>clause<S2SV_blank>to<S2SV_blank>set<S2SV_blank>the<S2SV_blank>collation<S2SV_blank>explicitly." ) ) ) ; } mylocale = pg_newlocale_from_collation ( collid ) ; } # ifdef USE_ICU if ( mylocale && mylocale -> provider == COLLPROVIDER_ICU ) { int32_t len_uchar ; int32_t len_conv ; UChar * buff_uchar ; UChar * buff_conv ; len_uchar = icu_to_uchar ( & buff_uchar , buff , nbytes ) ; len_conv = icu_convert_case ( u_strToLower , mylocale , & buff_conv , buff_uchar , len_uchar ) ; icu_from_uchar ( & result , buff_conv , len_conv ) ; <S2SV_StartBug> } <S2SV_EndBug> else # endif { if ( pg_database_encoding_max_length ( ) > 1 ) { wchar_t * workspace ; size_t curr_char ; size_t result_size ; if ( ( nbytes + 1 ) > ( INT_MAX / sizeof ( wchar_t ) ) ) ereport ( ERROR , ( errcode ( ERRCODE_OUT_OF_MEMORY ) , errmsg ( "out<S2SV_blank>of<S2SV_blank>memory" ) ) ) ; workspace = ( wchar_t * ) palloc ( ( nbytes + 1 ) * sizeof ( wchar_t ) ) ; char2wchar ( workspace , nbytes + 1 , buff , nbytes , mylocale ) ; for ( curr_char = 0 ; workspace [ curr_char ] != 0 ; curr_char ++ ) { # ifdef HAVE_LOCALE_T if ( mylocale ) workspace [ curr_char ] = towlower_l ( workspace [ curr_char ] , mylocale -> info . lt ) ; else # endif workspace [ curr_char ] = towlower ( workspace [ curr_char ] ) ; } result_size = curr_char * pg_database_encoding_max_length ( ) + 1 ; result = palloc ( result_size ) ; wchar2char ( result , workspace , result_size , mylocale ) ; pfree ( workspace ) ; } # endif else { char * p ; result = pnstrdup ( buff , nbytes ) ; for ( p = result ; * p ; p ++ ) { # ifdef HAVE_LOCALE_T if ( mylocale ) * p = tolower_l ( ( unsigned char ) * p , mylocale -> info . lt ) ; else # endif * p = pg_tolower ( ( unsigned char ) * p ) ; } } } | <S2SV_ModStart> len_conv ) ; pfree ( buff_uchar ) ; |
5,470 | CWE-000 static bool differential_addr ( int * lead , uint32_t absolute , uint32_t differential ) { <S2SV_StartBug> int aclz = __builtin_clz ( absolute ) ; <S2SV_EndBug> <S2SV_StartBug> int aclo = __builtin_clz ( ~ absolute ) ; <S2SV_EndBug> <S2SV_StartBug> int dclz = __builtin_clz ( differential ) ; <S2SV_EndBug> int dclo = __builtin_clz ( ~ differential ) ; int abs = aclz > aclo ? aclz : aclo ; int diff = dclz > dclo ? dclz : dclo ; * lead = diff > abs ? diff : abs ; return diff > abs ; } | <S2SV_ModStart> ) { int abs = sign_extendable_bits <S2SV_ModEnd> ( absolute ) <S2SV_ModStart> ) ; int diff = sign_extendable_bits <S2SV_ModEnd> ( differential ) <S2SV_ModStart> ( differential ) <S2SV_ModEnd> ; * lead |
5,471 | CWE-000 axiom_xpath_node_test_t * axiom_xpath_compile_node_test ( const axutil_env_t * env , axiom_xpath_expression_t * expr ) { axis2_char_t * name ; axiom_xpath_node_test_t * node_test ; node_test = AXIS2_MALLOC ( env -> allocator , sizeof ( axiom_xpath_node_test_t ) ) ; node_test -> type = AXIOM_XPATH_NODE_TEST_NONE ; node_test -> prefix = NULL ; node_test -> name = NULL ; node_test -> lit = NULL ; if ( AXIOM_XPATH_CURRENT == '*' ) { AXIOM_XPATH_READ ( 1 ) ; node_test -> type = AXIOM_XPATH_NODE_TEST_ALL ; return node_test ; } name = axiom_xpath_compile_ncname ( env , expr ) ; if ( ! name ) { AXIS2_LOG_ERROR ( env -> log , AXIS2_LOG_SI , "Parse<S2SV_blank>error:<S2SV_blank>NCName<S2SV_blank>expected<S2SV_blank>-<S2SV_blank><S2SV_blank>%s" , expr -> expr_str + expr -> expr_ptr ) ; AXIS2_FREE ( env -> allocator , node_test ) ; return NULL ; } if ( AXIOM_XPATH_CURRENT == '(' ) { AXIOM_XPATH_READ ( 1 ) ; if ( axutil_strcmp ( name , "comment" ) == 0 ) { node_test -> type = AXIOM_XPATH_NODE_TYPE_COMMENT ; } if ( axutil_strcmp ( name , "node" ) == 0 ) { node_test -> type = AXIOM_XPATH_NODE_TYPE_NODE ; } if ( axutil_strcmp ( name , "processing-instruction" ) == 0 ) { node_test -> type = AXIOM_XPATH_NODE_TYPE_PI ; node_test -> lit = axiom_xpath_compile_literal ( env , expr ) ; } if ( axutil_strcmp ( name , "text" ) == 0 ) { node_test -> type = AXIOM_XPATH_NODE_TYPE_TEXT ; node_test -> name = name ; } AXIOM_XPATH_SKIP_WHITESPACES ; if ( node_test -> type == AXIOM_XPATH_NODE_TEST_NONE || AXIOM_XPATH_CURRENT != ')' ) { AXIS2_LOG_ERROR ( env -> log , AXIS2_LOG_SI , "Parse<S2SV_blank>error:<S2SV_blank>Invalid<S2SV_blank>node<S2SV_blank>type<S2SV_blank>-<S2SV_blank><S2SV_blank>%s" , name ) ; <S2SV_StartBug> AXIS2_FREE ( env -> allocator , node_test ) ; <S2SV_EndBug> return NULL ; } AXIOM_XPATH_READ ( 1 ) ; } else { node_test -> type = AXIOM_XPATH_NODE_TEST_STANDARD ; if ( AXIOM_XPATH_CURRENT == ':' ) { AXIOM_XPATH_READ ( 1 ) ; node_test -> prefix = name ; if ( AXIOM_XPATH_CURRENT == '*' ) { AXIOM_XPATH_READ ( 1 ) ; node_test -> type = AXIOM_XPATH_NODE_TEST_ALL ; return node_test ; } node_test -> name = axiom_xpath_compile_ncname ( env , expr ) ; if ( ! node_test -> name ) { AXIS2_LOG_ERROR ( env -> log , AXIS2_LOG_SI , "Parse<S2SV_blank>error:<S2SV_blank>NCName<S2SV_blank>expected<S2SV_blank>-<S2SV_blank><S2SV_blank>%s" , expr -> expr_str + expr -> expr_ptr ) ; AXIS2_FREE ( env -> allocator , node_test ) ; return NULL ; } } else { node_test -> name = name ; } } return node_test ; } | <S2SV_ModStart> -> allocator , name ) ; AXIS2_FREE ( env -> allocator , |
5,472 | CWE-000 void replicationWithServer ( void * data ) { event * ev = data ; thread_contex * th = ev -> contex ; int fd = ev -> fd ; int n , i ; int left ; int extra ; while ( 1 ) { left = th -> replicationBufSize - ( th -> replicationBufLast - th -> replicationBuf ) ; if ( left == 0 ) { int used = th -> replicationBufPos - th -> replicationBuf ; th -> replicationBuf = realloc ( th -> replicationBuf , th -> replicationBufSize * 2 ) ; th -> replicationBufPos = th -> replicationBuf + used ; th -> replicationBufLast = th -> replicationBuf + th -> replicationBufSize ; th -> replicationBufSize *= 2 ; } n = read ( fd , th -> replicationBufLast , left ) ; if ( n < 0 ) { return ; } th -> replicationBufLast += n ; while ( th -> replicationBufPos != th -> replicationBufLast ) { if ( th -> inputMode == - 1 ) { if ( th -> replicationBuf [ 0 ] == '*' ) { th -> inputMode = 1 ; } else { th -> inputMode = 0 ; } } if ( th -> inputMode == 1 ) { n = processMulti ( th ) ; } else { n = processSingle ( th ) ; } if ( n == - 1 ) { break ; } if ( th -> type == REDIS_CMD_PING || th -> type == REDIS_CMD_SELECTDB ) { resetState ( th ) ; continue ; } uint32_t hash = server_hash ( server . new_config , th -> key , th -> key_length ) ; int index = dispatch ( server . new_config , hash ) ; server_conf * from = th -> sc ; server_conf * to = array_get ( server . new_config -> servers , index ) ; char t [ 1000 ] ; snprintf ( t , th -> key_length + 1 , "%s" , th -> key ) ; Log ( LOG_DEBUG , "the<S2SV_blank>key<S2SV_blank>%s,<S2SV_blank>from<S2SV_blank>%s:%d" , t , from -> pname , from -> port ) ; Log ( LOG_DEBUG , "the<S2SV_blank>key<S2SV_blank>%s<S2SV_blank>should<S2SV_blank>goto<S2SV_blank>%s:%d" , t , to -> pname , to -> port ) ; if ( strcmp ( from -> pname , to -> pname ) == 0 && from -> port == to -> port ) { Log ( LOG_DEBUG , "the<S2SV_blank>key<S2SV_blank>%s<S2SV_blank>server<S2SV_blank>not<S2SV_blank>change<S2SV_blank>" , t ) ; resetState ( th ) ; continue ; } <S2SV_StartBug> buf_t * output = getBuf ( th -> replicationBufPos - th -> replicationBuf ) ; <S2SV_EndBug> if ( ! output ) { Log ( LOG_ERROR , "get<S2SV_blank>buf<S2SV_blank>error" ) ; exit ( 1 ) ; } memcpy ( output -> start , th -> replicationBuf , th -> replicationBufPos - th -> replicationBuf ) ; output -> start [ th -> replicationBufPos - th -> replicationBuf ] = '\\0' ; output -> position = output -> start + ( th -> replicationBufPos - th -> replicationBuf ) ; appendToOutBuf ( to -> contex , output ) ; resetState ( th ) ; } } } | <S2SV_ModStart> th -> replicationBuf + 10 |
5,473 | CWE-000 static void process_ncq_command ( AHCIState * s , int port , uint8_t * cmd_fis , int slot ) { NCQFrame * ncq_fis = ( NCQFrame * ) cmd_fis ; uint8_t tag = ncq_fis -> tag >> 3 ; NCQTransferState * ncq_tfs = & s -> dev [ port ] . ncq_tfs [ tag ] ; if ( ncq_tfs -> used ) { fprintf ( stderr , "%s:<S2SV_blank>tag<S2SV_blank>%d<S2SV_blank>already<S2SV_blank>used\\n" , __FUNCTION__ , tag ) ; return ; } ncq_tfs -> used = 1 ; ncq_tfs -> drive = & s -> dev [ port ] ; ncq_tfs -> slot = slot ; ncq_tfs -> lba = ( ( uint64_t ) ncq_fis -> lba5 << 40 ) | ( ( uint64_t ) ncq_fis -> lba4 << 32 ) | ( ( uint64_t ) ncq_fis -> lba3 << 24 ) | ( ( uint64_t ) ncq_fis -> lba2 << 16 ) | ( ( uint64_t ) ncq_fis -> lba1 << 8 ) | ( uint64_t ) ncq_fis -> lba0 ; ncq_tfs -> sector_count = ( ( uint16_t ) ncq_fis -> sector_count_high << 8 ) | ncq_fis -> sector_count_low ; DPRINTF ( port , "NCQ<S2SV_blank>transfer<S2SV_blank>LBA<S2SV_blank>from<S2SV_blank>%" PRId64 "<S2SV_blank>to<S2SV_blank>%" PRId64 ",<S2SV_blank>" "drive<S2SV_blank>max<S2SV_blank>%" PRId64 "\\n" , ncq_tfs -> lba , ncq_tfs -> lba + ncq_tfs -> sector_count - 2 , s -> dev [ port ] . port . ifs [ 0 ] . nb_sectors - 1 ) ; <S2SV_StartBug> ahci_populate_sglist ( & s -> dev [ port ] , & ncq_tfs -> sglist ) ; <S2SV_EndBug> ncq_tfs -> tag = tag ; switch ( ncq_fis -> command ) { case READ_FPDMA_QUEUED : DPRINTF ( port , "NCQ<S2SV_blank>reading<S2SV_blank>%d<S2SV_blank>sectors<S2SV_blank>from<S2SV_blank>LBA<S2SV_blank>%" PRId64 ",<S2SV_blank>" "tag<S2SV_blank>%d\\n" , ncq_tfs -> sector_count - 1 , ncq_tfs -> lba , ncq_tfs -> tag ) ; DPRINTF ( port , "tag<S2SV_blank>%d<S2SV_blank>aio<S2SV_blank>read<S2SV_blank>%" PRId64 "\\n" , ncq_tfs -> tag , ncq_tfs -> lba ) ; dma_acct_start ( ncq_tfs -> drive -> port . ifs [ 0 ] . bs , & ncq_tfs -> acct , & ncq_tfs -> sglist , BDRV_ACCT_READ ) ; ncq_tfs -> aiocb = dma_bdrv_read ( ncq_tfs -> drive -> port . ifs [ 0 ] . bs , & ncq_tfs -> sglist , ncq_tfs -> lba , ncq_cb , ncq_tfs ) ; break ; case WRITE_FPDMA_QUEUED : DPRINTF ( port , "NCQ<S2SV_blank>writing<S2SV_blank>%d<S2SV_blank>sectors<S2SV_blank>to<S2SV_blank>LBA<S2SV_blank>%" PRId64 ",<S2SV_blank>tag<S2SV_blank>%d\\n" , ncq_tfs -> sector_count - 1 , ncq_tfs -> lba , ncq_tfs -> tag ) ; DPRINTF ( port , "tag<S2SV_blank>%d<S2SV_blank>aio<S2SV_blank>write<S2SV_blank>%" PRId64 "\\n" , ncq_tfs -> tag , ncq_tfs -> lba ) ; dma_acct_start ( ncq_tfs -> drive -> port . ifs [ 0 ] . bs , & ncq_tfs -> acct , & ncq_tfs -> sglist , BDRV_ACCT_WRITE ) ; ncq_tfs -> aiocb = dma_bdrv_write ( ncq_tfs -> drive -> port . ifs [ 0 ] . bs , & ncq_tfs -> sglist , ncq_tfs -> lba , ncq_cb , ncq_tfs ) ; break ; default : DPRINTF ( port , "error:<S2SV_blank>tried<S2SV_blank>to<S2SV_blank>process<S2SV_blank>non-NCQ<S2SV_blank>command<S2SV_blank>as<S2SV_blank>NCQ\\n" ) ; qemu_sglist_destroy ( & ncq_tfs -> sglist ) ; break ; } } | <S2SV_ModStart> ncq_tfs -> sglist , 0 |
5,474 | CWE-000 int seaf_repo_manager_revert_file ( SeafRepoManager * mgr , const char * repo_id , const char * old_commit_id , const char * file_path , const char * user , GError * * error ) { SeafRepo * repo = NULL ; SeafCommit * head_commit = NULL , * old_commit = NULL ; char * parent_dir = NULL , * filename = NULL ; SeafDirent * old_dent = NULL ; char * canon_path = NULL , * root_id = NULL ; char buf [ SEAF_PATH_MAX ] ; char time_str [ 512 ] ; gboolean parent_dir_exist = FALSE ; gboolean revert_to_root = FALSE ; gboolean skipped = FALSE ; int ret = 0 ; GET_REPO_OR_FAIL ( repo , repo_id ) ; GET_COMMIT_OR_FAIL ( head_commit , repo -> id , repo -> version , repo -> head -> commit_id ) ; if ( strcmp ( repo -> head -> commit_id , old_commit_id ) == 0 ) { g_debug ( "[revert<S2SV_blank>file]<S2SV_blank>commit<S2SV_blank>is<S2SV_blank>head,<S2SV_blank>do<S2SV_blank>nothing\\n" ) ; goto out ; } if ( ! old_commit ) { GET_COMMIT_OR_FAIL ( old_commit , repo -> id , repo -> version , old_commit_id ) ; if ( strcmp ( old_commit -> repo_id , repo_id ) != 0 ) { g_set_error ( error , SEAFILE_DOMAIN , SEAF_ERR_BAD_COMMIT , "bad<S2SV_blank>commit<S2SV_blank>id" ) ; ret = - 1 ; goto out ; } } if ( ! canon_path ) { canon_path = get_canonical_path ( file_path ) ; if ( canon_path [ strlen ( canon_path ) - 1 ] == '/' ) { g_set_error ( error , SEAFILE_DOMAIN , SEAF_ERR_BAD_COMMIT , "bad<S2SV_blank>target<S2SV_blank>file<S2SV_blank>path" ) ; ret = - 1 ; goto out ; } parent_dir = g_path_get_dirname ( canon_path ) ; filename = g_path_get_basename ( canon_path ) ; old_dent = get_dirent_by_path ( repo , old_commit -> root_id , parent_dir , filename , error ) ; <S2SV_StartBug> if ( S_ISDIR ( old_dent -> mode ) ) { <S2SV_EndBug> ret = - 1 ; goto out ; } if ( * error ) { seaf_warning ( "[revert<S2SV_blank>file]<S2SV_blank>error:<S2SV_blank>%s\\n" , ( * error ) -> message ) ; g_clear_error ( error ) ; g_set_error ( error , SEAFILE_DOMAIN , SEAF_ERR_GENERAL , "internal<S2SV_blank>error" ) ; ret = - 1 ; goto out ; } } parent_dir_exist = detect_path_exist ( repo , head_commit -> root_id , parent_dir , error ) ; if ( * error ) { seaf_warning ( "[revert<S2SV_blank>file]<S2SV_blank>error:<S2SV_blank>%s\\n" , ( * error ) -> message ) ; g_clear_error ( error ) ; g_set_error ( error , SEAFILE_DOMAIN , SEAF_ERR_GENERAL , "internal<S2SV_blank>error" ) ; ret = - 1 ; goto out ; } if ( ! parent_dir_exist ) { revert_to_root = TRUE ; root_id = revert_file_to_root ( repo , head_commit -> root_id , old_dent , & skipped , error ) ; } else { revert_to_root = FALSE ; root_id = revert_file_to_parent_dir ( repo , head_commit -> root_id , parent_dir , old_dent , & skipped , error ) ; } if ( * error ) { seaf_warning ( "[revert<S2SV_blank>file]<S2SV_blank>error:<S2SV_blank>%s\\n" , ( * error ) -> message ) ; g_clear_error ( error ) ; g_set_error ( error , SEAFILE_DOMAIN , SEAF_ERR_GENERAL , "internal<S2SV_blank>error" ) ; ret = - 1 ; goto out ; } if ( skipped ) { goto out ; } if ( ! root_id ) { seaf_warning ( "[revert<S2SV_blank>file]<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>revert<S2SV_blank>file.\\n" ) ; g_set_error ( error , SEAFILE_DOMAIN , SEAF_ERR_GENERAL , "Failed<S2SV_blank>to<S2SV_blank>revert<S2SV_blank>file" ) ; ret = - 1 ; goto out ; } # ifndef WIN32 strftime ( time_str , sizeof ( time_str ) , "%F<S2SV_blank>%T" , localtime ( ( time_t * ) ( & old_commit -> ctime ) ) ) ; # else strftime ( time_str , sizeof ( time_str ) , "%Y-%m-%d<S2SV_blank>%H:%M:%S" , localtime ( ( time_t * ) ( & old_commit -> ctime ) ) ) ; # endif snprintf ( buf , SEAF_PATH_MAX , "Reverted<S2SV_blank>file<S2SV_blank>\\"%s\\"<S2SV_blank>to<S2SV_blank>status<S2SV_blank>at<S2SV_blank>%s" , filename , time_str ) ; if ( gen_new_commit ( repo_id , head_commit , root_id , user , buf , NULL , error ) < 0 ) { ret = - 1 ; goto out ; } seaf_repo_manager_merge_virtual_repo ( mgr , repo_id , NULL ) ; out : if ( repo ) seaf_repo_unref ( repo ) ; if ( head_commit ) seaf_commit_unref ( head_commit ) ; if ( old_commit ) seaf_commit_unref ( old_commit ) ; g_free ( root_id ) ; g_free ( parent_dir ) ; g_free ( filename ) ; g_free ( canon_path ) ; seaf_dirent_free ( old_dent ) ; # define REVERT_TO_ROOT 0x1 if ( ret == 0 ) { if ( revert_to_root ) ret |= REVERT_TO_ROOT ; update_repo_size ( repo_id ) ; } return ret ; } | <S2SV_ModStart> ; if ( ! old_dent || |
5,475 | CWE-000 static void nl_parse_flower_tunnel ( struct nlattr * * attrs , struct tc_flower * flower ) { if ( attrs [ TCA_FLOWER_KEY_ENC_KEY_ID ] ) { ovs_be32 id = nl_attr_get_be32 ( attrs [ TCA_FLOWER_KEY_ENC_KEY_ID ] ) ; flower -> tunnel . id = be32_to_be64 ( id ) ; } <S2SV_StartBug> if ( attrs [ TCA_FLOWER_KEY_ENC_IPV4_SRC ] ) { <S2SV_EndBug> <S2SV_StartBug> flower -> tunnel . ipv4_src = <S2SV_EndBug> nl_attr_get_be32 ( attrs [ TCA_FLOWER_KEY_ENC_IPV4_SRC ] ) ; } <S2SV_StartBug> if ( attrs [ TCA_FLOWER_KEY_ENC_IPV4_DST ] ) { <S2SV_EndBug> <S2SV_StartBug> flower -> tunnel . ipv4_dst = <S2SV_EndBug> <S2SV_StartBug> nl_attr_get_be32 ( attrs [ TCA_FLOWER_KEY_ENC_IPV4_DST ] ) ; <S2SV_EndBug> } if ( attrs [ TCA_FLOWER_KEY_ENC_UDP_DST_PORT ] ) { flower -> tunnel . tp_dst = nl_attr_get_be16 ( attrs [ TCA_FLOWER_KEY_ENC_UDP_DST_PORT ] ) ; } } | <S2SV_ModStart> ( attrs [ TCA_FLOWER_KEY_ENC_IPV4_SRC_MASK <S2SV_ModEnd> ] ) { <S2SV_ModStart> flower -> tunnel . ipv4 <S2SV_ModStart> ( attrs [ TCA_FLOWER_KEY_ENC_IPV4_DST_MASK <S2SV_ModEnd> ] ) { <S2SV_ModStart> flower -> tunnel . ipv4 <S2SV_ModStart> attrs [ TCA_FLOWER_KEY_ENC_IPV4_DST ] ) ; } if ( attrs [ TCA_FLOWER_KEY_ENC_IPV6_SRC_MASK ] ) { flower -> tunnel . ipv6 . ipv6_src = nl_attr_get_in6_addr ( attrs [ TCA_FLOWER_KEY_ENC_IPV6_SRC ] ) ; } if ( attrs [ TCA_FLOWER_KEY_ENC_IPV6_DST_MASK ] ) { flower -> tunnel . ipv6 . ipv6_dst = nl_attr_get_in6_addr ( attrs [ TCA_FLOWER_KEY_ENC_IPV6_DST |
5,476 | CWE-000 uint32_t atoio ( char * input ) { <S2SV_StartBug> uint32_t ret = 0 ; <S2SV_EndBug> <S2SV_StartBug> for ( uint32_t i = 0 ; i < strlen ( input ) ; i ++ ) <S2SV_EndBug> { <S2SV_StartBug> switch ( input [ i ] ) <S2SV_EndBug> { case '0' : ret += i * 0 ; break ; case '1' : ret += i * 1 ; break ; case '2' : ret += i * 2 ; break ; case '3' : ret += i * 3 ; break ; case '4' : ret += i * 4 ; break ; case '5' : ret += i * 5 ; break ; case '6' : ret += i * 6 ; break ; case '7' : ret += i * 7 ; break ; case '8' : ret += i * 8 ; break ; case '9' : ret += i * 9 ; break ; default : break ; } } return ret ; } | <S2SV_ModStart> ) { uint32_t c , n ; n <S2SV_ModEnd> = 0 ; <S2SV_ModStart> ; for ( c <S2SV_ModEnd> = 0 ; <S2SV_ModStart> = 0 ; input [ c ] != '\\0' ; c <S2SV_ModEnd> ++ ) { <S2SV_ModStart> ++ ) { n = n * 10 + input [ c ] - '0' ; } return n <S2SV_ModEnd> ; } <S2SV_null> |
5,477 | CWE-000 func ( vardec ) { <S2SV_StartBug> DefType * tmp ; <S2SV_EndBug> if ( ! dtype ) return NULL ; log ( "VarDec<S2SV_blank>found,type=%d\\n" , dtype -> kind ) ; symbol * symb ; Node * q = p -> child ; if ( q -> type == Id ) { if ( ( symb = search_table ( Variables -> data , q -> id_value ) ) ) { if ( ! struct_to_insert ) error ( "Error<S2SV_blank>type<S2SV_blank>3<S2SV_blank>at<S2SV_blank>Line<S2SV_blank>%d:<S2SV_blank>Redefined<S2SV_blank>variable<S2SV_blank>\\"%s\\".\\n" , p -> line , q -> id_value ) ; else error ( "Error<S2SV_blank>type<S2SV_blank>15<S2SV_blank>at<S2SV_blank>Line<S2SV_blank>%d:<S2SV_blank>Redefined<S2SV_blank>field<S2SV_blank>\\"%s\\".\\n" , p -> line , q -> id_value ) ; return NULL ; } symb = insert_stack ( Variables , q -> id_value ) ; symb -> type = dtype ; log ( "Variable<S2SV_blank>\\"%s\\"<S2SV_blank>inserted.\\n" , q -> id_value ) ; return ( void * ) symb ; } else if ( q -> type == VarDec ) { symb = analyze_node ( q , dtype ) ; <S2SV_StartBug> tmp = malloc ( sizeof ( DefType ) ) ; <S2SV_EndBug> tmp -> kind = ARRAY ; tmp -> elem = symb -> type ; tmp -> size = q -> next -> next -> int_value ; symb -> type = tmp ; <S2SV_StartBug> log ( "Variable<S2SV_blank>\\"%s\\"<S2SV_blank>type<S2SV_blank>changed<S2SV_blank>to<S2SV_blank>ARRAY<S2SV_blank>of<S2SV_blank>%d\\n." , q -> id_value , q -> next -> next -> int_value ) ; <S2SV_EndBug> return ( void * ) symb ; } else log ( "VarDec<S2SV_blank>ERROR.\\n" ) ; return NULL ; } | <S2SV_ModStart> DefType * tmp , * tmp2 <S2SV_ModStart> ; tmp = symb -> type ; tmp2 = NULL ; while ( tmp -> kind == ARRAY ) { tmp2 = tmp ; tmp = tmp -> elem ; } if ( ! tmp2 ) { tmp = <S2SV_ModStart> = tmp ; } else { tmp = malloc ( sizeof ( DefType ) ) ; tmp -> kind = ARRAY ; tmp -> elem = tmp2 -> elem ; tmp -> size = q -> next -> next -> int_value ; tmp2 -> elem = tmp ; } |
5,478 | CWE-000 char * cmdRunner ( char * a ) { FILE * pipe = popen ( a , "r" ) ; if ( pipe ) { char buffer [ 128 ] ; while ( ! feof ( pipe ) ) { if ( fgets ( buffer , 128 , pipe ) != NULL ) { } } pclose ( pipe ) ; buffer [ strlen ( buffer ) - 1 ] = '\\0' ; buffer_out [ strlen ( buffer ) - 1 ] = '\\0' ; strcpy ( buffer_out , buffer ) ; } <S2SV_StartBug> return buffer_out ; <S2SV_EndBug> } | <S2SV_ModStart> ) ; } printf ( "%s" , buffer_out ) ; |
5,479 | CWE-000 int sendCommand ( ssh_session session , GtkWidget * parent , GtkWidget * txtView , char * command ) { ssh_channel channel ; int rc ; char buffer [ 1024 ] ; char * out = ( char * ) malloc ( sizeof ( char ) * 1024 ) ; int nbytes ; GtkTextBuffer * gtkBuf ; gtkBuf = gtk_text_buffer_new ( NULL ) ; <S2SV_StartBug> channel = ssh_channel_new ( session ) ; <S2SV_EndBug> if ( channel == NULL ) { makeDialog ( parent , "Error" , "There<S2SV_blank>was<S2SV_blank>an<S2SV_blank>error<S2SV_blank>during<S2SV_blank>channel<S2SV_blank>creation." ) ; return SSH_ERROR ; } rc = ssh_channel_open_session ( channel ) ; if ( rc != SSH_OK ) { makeDialog ( parent , "Error" , "There<S2SV_blank>was<S2SV_blank>an<S2SV_blank>error<S2SV_blank>during<S2SV_blank>channel<S2SV_blank>opening" ) ; ssh_channel_free ( channel ) ; return rc ; } rc = ssh_channel_request_exec ( channel , command ) ; if ( rc != SSH_OK ) { makeDialog ( parent , "Error" , "There<S2SV_blank>was<S2SV_blank>an<S2SV_blank>error<S2SV_blank>during<S2SV_blank>command<S2SV_blank>execution." ) ; ssh_channel_close ( channel ) ; ssh_channel_free ( channel ) ; return rc ; } FILE * output ; output = fopen ( "output.txt" , "w" ) ; if ( output == NULL ) { g_print ( "Errore\\n" ) ; return - 1 ; } nbytes = ssh_channel_read ( channel , buffer , sizeof ( buffer ) , 0 ) ; while ( nbytes > 0 ) { if ( write ( 1 , buffer , nbytes ) != ( unsigned int ) nbytes ) { makeDialog ( parent , "Error" , "There<S2SV_blank>was<S2SV_blank>an<S2SV_blank>error<S2SV_blank>during<S2SV_blank>output<S2SV_blank>reading." ) ; ssh_channel_close ( channel ) ; ssh_channel_free ( channel ) ; return SSH_ERROR ; } nbytes = ssh_channel_read ( channel , buffer , sizeof ( buffer ) , 0 ) ; fprintf ( output , "%s" , buffer ) ; } fclose ( output ) ; if ( nbytes < 0 ) { makeDialog ( parent , "Error" , "There<S2SV_blank>was<S2SV_blank>an<S2SV_blank>error<S2SV_blank>during<S2SV_blank>output<S2SV_blank>reading(2)." ) ; ssh_channel_close ( channel ) ; ssh_channel_free ( channel ) ; return SSH_ERROR ; } FILE * outfile ; outfile = fopen ( "output.txt" , "r" ) ; if ( outfile == NULL ) { makeDialog ( parent , "Error" , "Error:<S2SV_blank>can\'t<S2SV_blank>find<S2SV_blank>\\"output.txt\\"<S2SV_blank>file." ) ; return - 1 ; } while ( fscanf ( outfile , "%s" , out ) != EOF ) { gtk_text_buffer_insert_at_cursor ( gtkBuf , out , strlen ( out ) ) ; gtk_text_buffer_insert_at_cursor ( gtkBuf , "\\n" , 1 ) ; } gtk_text_view_set_buffer ( GTK_TEXT_VIEW ( txtView ) , gtkBuf ) ; ssh_channel_send_eof ( channel ) ; ssh_channel_close ( channel ) ; ssh_channel_free ( channel ) ; return SSH_OK ; } | <S2SV_ModStart> NULL ) ; if ( session == NULL ) { makeDialog ( parent , "Error" , "Error:<S2SV_blank>the<S2SV_blank>client<S2SV_blank>is<S2SV_blank>not<S2SV_blank>connected<S2SV_blank>to<S2SV_blank>a<S2SV_blank>host." ) ; return - 1 ; } |
5,480 | CWE-000 static future_t * start_up ( void ) { LOG_INFO ( LOG_TAG , "%s" , __func__ ) ; command_credits = 1 ; firmware_is_configured = false ; char prop_lpm_config [ PROPERTY_VALUE_MAX ] ; osi_property_get ( "persist.service.bdroid.lpmcfg" , prop_lpm_config , "all" ) ; if ( ! strcmp ( prop_lpm_config , "all" ) ) { lpm_config = LPM_CONFIG_ALL ; } else if ( ! strcmp ( prop_lpm_config , "tx" ) ) { lpm_config = LPM_CONFIG_TX ; } else { lpm_config = LPM_CONFIG_NONE ; } LOG_INFO ( LOG_TAG , "%s<S2SV_blank>lpm<S2SV_blank>configure<S2SV_blank>value<S2SV_blank>=<S2SV_blank>%d." , __func__ , lpm_config ) ; pthread_mutex_init ( & commands_pending_response_lock , NULL ) ; period_ms_t startup_timeout_ms = DEFAULT_STARTUP_TIMEOUT_MS ; char timeout_prop [ PROPERTY_VALUE_MAX ] ; if ( ! osi_property_get ( "bluetooth.enable_timeout_ms" , timeout_prop , STRING_VALUE_OF ( DEFAULT_STARTUP_TIMEOUT_MS ) ) || ( startup_timeout_ms = atoi ( timeout_prop ) ) < 100 ) startup_timeout_ms = DEFAULT_STARTUP_TIMEOUT_MS ; startup_timer = alarm_new ( "hci.startup_timer" ) ; if ( ! startup_timer ) { LOG_ERROR ( LOG_TAG , "%s<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>create<S2SV_blank>startup<S2SV_blank>timer." , __func__ ) ; goto error ; } epilog_timer = alarm_new ( "hci.epilog_timer" ) ; if ( ! epilog_timer ) { LOG_ERROR ( LOG_TAG , "%s<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>create<S2SV_blank>epilog<S2SV_blank>timer." , __func__ ) ; goto error ; } command_response_timer = alarm_new ( "hci.command_response_timer" ) ; if ( ! command_response_timer ) { LOG_ERROR ( LOG_TAG , "%s<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>create<S2SV_blank>command<S2SV_blank>response<S2SV_blank>timer." , __func__ ) ; goto error ; } command_queue = fixed_queue_new ( SIZE_MAX ) ; if ( ! command_queue ) { LOG_ERROR ( LOG_TAG , "%s<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>create<S2SV_blank>pending<S2SV_blank>command<S2SV_blank>queue." , __func__ ) ; goto error ; } packet_queue = fixed_queue_new ( SIZE_MAX ) ; if ( ! packet_queue ) { LOG_ERROR ( LOG_TAG , "%s<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>create<S2SV_blank>pending<S2SV_blank>packet<S2SV_blank>queue." , __func__ ) ; goto error ; } thread = thread_new ( "hci_thread" ) ; if ( ! thread ) { LOG_ERROR ( LOG_TAG , "%s<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>create<S2SV_blank>thread." , __func__ ) ; goto error ; } commands_pending_response = list_new ( NULL ) ; if ( ! commands_pending_response ) { LOG_ERROR ( LOG_TAG , "%s<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>create<S2SV_blank>list<S2SV_blank>for<S2SV_blank>commands<S2SV_blank>pending<S2SV_blank>response." , __func__ ) ; goto error ; } <S2SV_StartBug> memset ( incoming_packets , 0 , sizeof ( incoming_packets ) ) ; <S2SV_EndBug> future_t * local_startup_future = future_new ( ) ; startup_future = local_startup_future ; alarm_set ( startup_timer , startup_timeout_ms , startup_timer_expired , NULL ) ; packet_fragmenter -> init ( & packet_fragmenter_callbacks ) ; fixed_queue_register_dequeue ( command_queue , thread_get_reactor ( thread ) , event_command_ready , NULL ) ; fixed_queue_register_dequeue ( packet_queue , thread_get_reactor ( thread ) , event_packet_ready , NULL ) ; vendor -> open ( btif_local_bd_addr . address , & interface ) ; hal -> init ( & hal_callbacks , thread ) ; low_power_manager -> init ( thread ) ; vendor -> set_callback ( VENDOR_CONFIGURE_FIRMWARE , firmware_config_callback ) ; vendor -> set_callback ( VENDOR_CONFIGURE_SCO , sco_config_callback ) ; vendor -> set_callback ( VENDOR_DO_EPILOG , epilog_finished_callback ) ; if ( ! hci_inject -> open ( & interface ) ) { } int power_state = BT_VND_PWR_OFF ; # if ( defined ( BT_CLEAN_TURN_ON_DISABLED ) && BT_CLEAN_TURN_ON_DISABLED == TRUE ) LOG_WARN ( LOG_TAG , "%s<S2SV_blank>not<S2SV_blank>turning<S2SV_blank>off<S2SV_blank>the<S2SV_blank>chip<S2SV_blank>before<S2SV_blank>turning<S2SV_blank>on." , __func__ ) ; # else vendor -> send_command ( VENDOR_CHIP_POWER_CONTROL , & power_state ) ; # endif power_state = BT_VND_PWR_ON ; vendor -> send_command ( VENDOR_CHIP_POWER_CONTROL , & power_state ) ; LOG_DEBUG ( LOG_TAG , "%s<S2SV_blank>starting<S2SV_blank>async<S2SV_blank>portion" , __func__ ) ; thread_post ( thread , event_finish_startup , NULL ) ; hci_state = HCI_STARTED ; return local_startup_future ; error : shut_down ( ) ; return future_new_immediate ( FUTURE_FAIL ) ; } | <S2SV_ModStart> error ; } commands_pending_in_queue = list_new ( NULL ) ; if ( ! commands_pending_in_queue ) { LOG_ERROR ( "%s<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>create<S2SV_blank>list<S2SV_blank>for<S2SV_blank>commands<S2SV_blank>pending<S2SV_blank>response." , __func__ ) ; goto error ; } |
5,481 | CWE-000 void menu ( ) { char field [ FIELD_HEIGHT ] [ FIELD_WIDTH ] ; while ( 1 ) { field_init ( field ) ; menu_print ( ) ; char chose ; while ( 1 ) { char temp [ 2 ] ; scanf ( "%s" , temp ) ; if ( ! check_input ( temp ) ) { chose = temp [ 0 ] ; break ; } else { <S2SV_StartBug> printf ( "Wrong<S2SV_blank>input,<S2SV_blank>please<S2SV_blank>input<S2SV_blank>1-3\\n" ) ; <S2SV_EndBug> } } switch ( chose ) { case '1' : random_fill ( field ) ; mainloop ( field ) ; break ; case '2' : mainloop ( field ) ; break ; case '3' : mainloop ( field ) ; break ; case '4' : return ; } } } | <S2SV_ModStart> { printf ( "Wrong<S2SV_blank>input,<S2SV_blank>please<S2SV_blank>input<S2SV_blank>1-4\\n" <S2SV_ModEnd> ) ; } |
5,482 | CWE-000 static void init_init_window ( ) { init_win -> window = gtk_window_new ( GTK_WINDOW_TOPLEVEL ) ; init_win -> entry = gtk_entry_new ( ) ; init_win -> label = gtk_label_new ( "Enter<S2SV_blank>server<S2SV_blank>address\\n\\taddress:port" ) ; init_win -> button = gtk_button_new_with_label ( "Connect" ) ; init_win -> vbox = gtk_box_new ( GTK_ORIENTATION_VERTICAL , INIT_WINDOW_SPACING ) ; gtk_window_set_title ( GTK_WINDOW ( init_win -> window ) , "Enter<S2SV_blank>IP<S2SV_blank>window" ) ; <S2SV_StartBug> gtk_container_set_border_width ( GTK_CONTAINER ( init_win -> window ) , WINDOW_BORDER_SIZE ) ; <S2SV_EndBug> gtk_window_set_resizable ( GTK_WINDOW ( init_win -> window ) , FALSE ) ; gtk_widget_set_size_request ( init_win -> window , INIT_WINDOW_WIDTH , INIT_WINDOW_HEIGHT ) ; gtk_box_pack_start ( GTK_BOX ( init_win -> vbox ) , init_win -> label , TRUE , TRUE , INIT_WINDOW_SPACING ) ; gtk_box_pack_start ( GTK_BOX ( init_win -> vbox ) , init_win -> entry , FALSE , FALSE , INIT_WINDOW_SPACING ) ; gtk_box_pack_start ( GTK_BOX ( init_win -> vbox ) , init_win -> button , FALSE , FALSE , INIT_WINDOW_SPACING ) ; gtk_container_add ( GTK_CONTAINER ( init_win -> window ) , init_win -> vbox ) ; } | <S2SV_ModStart> "Enter<S2SV_blank>IP<S2SV_blank>window" ) ; gtk_window_set_position ( GTK_WINDOW ( init_win -> window ) , GTK_WIN_POS_CENTER ) ; |
5,483 | CWE-000 int nvec_fillSkip ( DynaNVector v , uint32_t amount , uint32_t skip ) { size_t s ; uint32_t i ; int errors = 0 ; const void * ptrs [ 2 ] = { & i , & s } ; <S2SV_StartBug> bool passed = false ; <S2SV_EndBug> for ( i = 0 ; i < amount ; ++ i ) { if ( i != skip ) { <S2SV_StartBug> s = passed ? ( ( size_t ) i - 1 ) : ( size_t ) i ; <S2SV_EndBug> errors += dnvec_push ( v , ptrs ) ? 1 : 0 ; } <S2SV_StartBug> else { <S2SV_EndBug> passed = true ; } } return errors ; } | <S2SV_ModStart> s } ; <S2SV_ModEnd> for ( i <S2SV_ModStart> { s = <S2SV_ModEnd> ( size_t ) <S2SV_ModStart> 0 ; } <S2SV_ModEnd> } return errors |
5,484 | CWE-000 void * queue_peekFront ( queue_t * this ) { <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> this ) { return NULL ; |
5,485 | CWE-000 static void headers_stream_on_push_promise ( void * ctx , struct uncompressed_headers * uh ) { struct full_conn * conn = ctx ; lsquic_stream_t * stream ; assert ( ! ( conn -> fc_flags & FC_SERVER ) ) ; LSQ_DEBUG ( "push<S2SV_blank>promise<S2SV_blank>for<S2SV_blank>stream<S2SV_blank>%u<S2SV_blank>in<S2SV_blank>response<S2SV_blank>to<S2SV_blank>%u" , uh -> uh_oth_stream_id , uh -> uh_stream_id ) ; if ( 0 == ( uh -> uh_stream_id & 1 ) || 0 != ( uh -> uh_oth_stream_id & 1 ) ) { ABORT_ERROR ( "invalid<S2SV_blank>push<S2SV_blank>promise<S2SV_blank>stream<S2SV_blank>IDs:<S2SV_blank>%u,<S2SV_blank>%u" , uh -> uh_oth_stream_id , uh -> uh_stream_id ) ; <S2SV_StartBug> free ( uh ) ; <S2SV_EndBug> return ; } if ( ! ( conn_is_stream_closed ( conn , uh -> uh_stream_id ) || find_stream_by_id ( conn , uh -> uh_stream_id ) ) ) { ABORT_ERROR ( "invalid<S2SV_blank>push<S2SV_blank>promise<S2SV_blank>original<S2SV_blank>stream<S2SV_blank>ID<S2SV_blank>%u<S2SV_blank>never<S2SV_blank>" "initiated" , uh -> uh_stream_id ) ; <S2SV_StartBug> free ( uh ) ; <S2SV_EndBug> return ; } if ( conn_is_stream_closed ( conn , uh -> uh_oth_stream_id ) || find_stream_by_id ( conn , uh -> uh_oth_stream_id ) ) { ABORT_ERROR ( "invalid<S2SV_blank>promised<S2SV_blank>stream<S2SV_blank>ID<S2SV_blank>%u<S2SV_blank>already<S2SV_blank>used" , uh -> uh_oth_stream_id ) ; <S2SV_StartBug> free ( uh ) ; <S2SV_EndBug> return ; } stream = new_stream_ext ( conn , uh -> uh_oth_stream_id , STREAM_IF_STD , SCF_DI_AUTOSWITCH | ( conn -> fc_enpub -> enp_settings . es_rw_once ? SCF_DISP_RW_ONCE : 0 ) ) ; if ( ! stream ) { ABORT_ERROR ( "cannot<S2SV_blank>create<S2SV_blank>stream:<S2SV_blank>%s" , strerror ( errno ) ) ; <S2SV_StartBug> free ( uh ) ; <S2SV_EndBug> <S2SV_StartBug> return ; <S2SV_EndBug> } lsquic_stream_push_req ( stream , uh ) ; lsquic_stream_call_on_new ( stream ) ; return ; } | <S2SV_ModStart> uh_stream_id ) ; goto free_uh <S2SV_ModEnd> ; } if <S2SV_ModStart> uh_stream_id ) ; goto free_uh <S2SV_ModEnd> ; } if <S2SV_ModStart> uh_oth_stream_id ) ; goto free_uh <S2SV_ModEnd> ; } stream <S2SV_ModStart> ) ) ; goto free_uh ; } lsquic_stream_push_req ( stream , uh ) ; lsquic_stream_call_on_new ( stream ) ; return ; free_uh : if ( uh -> uh_hset ) conn -> fc_enpub -> enp_hsi_if -> hsi_discard_header_set ( uh -> uh_hset ) ; <S2SV_ModStart> uh ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
5,486 | CWE-000 static char * compile_tr ( char * old , char * * transtab ) { int i ; <S2SV_StartBug> char delimiter , check [ UCHAR_MAX ] ; <S2SV_EndBug> char * new , * end ; memset ( check , 0 , sizeof ( check ) ) ; delimiter = * old ; if ( delimiter == '\\\\' ) error ( COMPILE , "\\\\<S2SV_blank>can<S2SV_blank>not<S2SV_blank>be<S2SV_blank>used<S2SV_blank>as<S2SV_blank>a<S2SV_blank>string<S2SV_blank>delimiter" ) ; else if ( delimiter == '\\n' || delimiter == '\\0' ) error ( COMPILE , "newline<S2SV_blank>can<S2SV_blank>not<S2SV_blank>be<S2SV_blank>used<S2SV_blank>as<S2SV_blank>a<S2SV_blank>string<S2SV_blank>delimiter" ) ; new = old ++ ; do { if ( ( new = strchr ( new + 1 , delimiter ) ) == NULL ) error ( COMPILE , "unterminated<S2SV_blank>transform<S2SV_blank>source<S2SV_blank>string" ) ; } while ( * ( new - 1 ) == '\\\\' && * ( new - 2 ) != '\\\\' ) ; * new = '\\0' ; end = new ++ ; do { if ( ( end = strchr ( end + 1 , delimiter ) ) == NULL ) error ( COMPILE , "unterminated<S2SV_blank>transform<S2SV_blank>target<S2SV_blank>string" ) ; } while ( * ( end - 1 ) == '\\\\' && * ( end - 2 ) != '\\\\' ) ; * end = '\\0' ; * transtab = xmalloc ( UCHAR_MAX + 1 ) ; for ( i = 0 ; i <= UCHAR_MAX ; i ++ ) ( * transtab ) [ i ] = ( char ) i ; while ( * old != '\\0' && * new != '\\0' ) { if ( * old == '\\\\' ) { old ++ ; if ( * old == 'n' ) * old = '\\n' ; else if ( * old != delimiter && * old != '\\\\' ) error ( COMPILE , "Unexpected<S2SV_blank>character<S2SV_blank>after<S2SV_blank>" "backslash" ) ; } if ( * new == '\\\\' ) { new ++ ; if ( * new == 'n' ) * new = '\\n' ; else if ( * new != delimiter && * new != '\\\\' ) error ( COMPILE , "Unexpected<S2SV_blank>character<S2SV_blank>after<S2SV_blank>" "backslash" ) ; } if ( check [ * old ] == 1 ) error ( COMPILE , "Repeated<S2SV_blank>character<S2SV_blank>in<S2SV_blank>source<S2SV_blank>string" ) ; check [ * old ] = 1 ; <S2SV_StartBug> ( * transtab ) [ * old ++ ] = * new ++ ; <S2SV_EndBug> } if ( * old != '\\0' || * new != '\\0' ) error ( COMPILE , "transform<S2SV_blank>strings<S2SV_blank>are<S2SV_blank>not<S2SV_blank>the<S2SV_blank>same<S2SV_blank>length" ) ; return end + 1 ; } | <S2SV_ModStart> check [ UCHAR_MAX + 1 <S2SV_ModStart> transtab ) [ ( u_char ) |
5,487 | CWE-000 int test_invoke ( TSS2_SYS_CONTEXT * sapi_context ) { TSS2_RC rc ; TPMI_SH_AUTH_SESSION session_handle = 0 , session_handle_load = 0 ; <S2SV_StartBug> TPMS_CONTEXT context = { 0 , } ; <S2SV_EndBug> g_info ( "Starting<S2SV_blank>unbound,<S2SV_blank>unsalted<S2SV_blank>auth<S2SV_blank>session" ) ; rc = start_auth_session ( sapi_context , & session_handle ) ; if ( rc != TSS2_RC_SUCCESS ) { g_error ( "Tss2_Sys_StartAuthSession<S2SV_blank>failed:<S2SV_blank>0x%" PRIxHANDLE , rc ) ; } g_info ( "StartAuthSession<S2SV_blank>for<S2SV_blank>TPM_SE_POLICY<S2SV_blank>success!<S2SV_blank>Session<S2SV_blank>handle:<S2SV_blank>" "0x%08" PRIx32 , session_handle ) ; g_info ( "Saving<S2SV_blank>context<S2SV_blank>for<S2SV_blank>session:<S2SV_blank>0x%" PRIxHANDLE , session_handle ) ; rc = Tss2_Sys_ContextSave ( sapi_context , session_handle , & context ) ; if ( rc != TSS2_RC_SUCCESS ) { g_error ( "Tss2_Sys_ContextSave<S2SV_blank>failed:<S2SV_blank>0x%" PRIxHANDLE , rc ) ; } g_info ( "Successfully<S2SV_blank>saved<S2SV_blank>context<S2SV_blank>for<S2SV_blank>session:<S2SV_blank>0x%" PRIxHANDLE , session_handle ) ; prettyprint_context ( & context ) ; g_info ( "Loading<S2SV_blank>context<S2SV_blank>for<S2SV_blank>session:<S2SV_blank>0x%" PRIxHANDLE , session_handle ) ; rc = Tss2_Sys_ContextLoad ( sapi_context , & context , & session_handle_load ) ; if ( rc != TSS2_RC_SUCCESS ) { g_error ( "Tss2_Sys_ContextLoad<S2SV_blank>failed:<S2SV_blank>0x%" PRIxHANDLE , rc ) ; } g_info ( "Successfully<S2SV_blank>loaded<S2SV_blank>context<S2SV_blank>for<S2SV_blank>session:<S2SV_blank>0x%" PRIxHANDLE , session_handle_load ) ; if ( session_handle_load == session_handle ) { g_info ( "session_handle<S2SV_blank>==<S2SV_blank>session_handle_load" ) ; } else { g_error ( "session_handle<S2SV_blank>!=<S2SV_blank>session_handle_load" ) ; } return 0 ; } | <S2SV_ModStart> TPMS_CONTEXT context = TPMS_CONTEXT_STATIC_INIT <S2SV_ModEnd> ; g_info ( |
5,488 | CWE-000 YY_BUFFER_STATE yy_create_buffer ( FILE * file , int size ) { YY_BUFFER_STATE b ; b = ( YY_BUFFER_STATE ) yyalloc ( sizeof ( struct yy_buffer_state ) ) ; if ( ! b ) YY_FATAL_ERROR ( "out<S2SV_blank>of<S2SV_blank>dynamic<S2SV_blank>memory<S2SV_blank>in<S2SV_blank>yy_create_buffer()" ) ; <S2SV_StartBug> b -> yy_buf_size = size ; <S2SV_EndBug> <S2SV_StartBug> b -> yy_ch_buf = ( char * ) yyalloc ( ( yy_size_t ) ( b -> yy_buf_size + 2 ) ) ; <S2SV_EndBug> if ( ! b -> yy_ch_buf ) YY_FATAL_ERROR ( "out<S2SV_blank>of<S2SV_blank>dynamic<S2SV_blank>memory<S2SV_blank>in<S2SV_blank>yy_create_buffer()" ) ; b -> yy_is_our_buffer = 1 ; yy_init_buffer ( b , file ) ; return b ; } | <S2SV_ModStart> -> yy_buf_size = ( yy_size_t ) <S2SV_ModStart> ) yyalloc ( <S2SV_ModEnd> b -> yy_buf_size <S2SV_ModStart> yy_buf_size + 2 <S2SV_ModEnd> ) ; if |
5,489 | CWE-000 int http_body_drop ( int fd , rr_data_t response ) { <S2SV_StartBug> int bodylen , rc = 1 ; <S2SV_EndBug> bodylen = http_has_body ( NULL , response ) ; if ( bodylen ) { if ( hlist_subcmp ( response -> headers , "Transfer-Encoding" , "chunked" ) ) { if ( debug ) printf ( "Discarding<S2SV_blank>chunked<S2SV_blank>body.\\n" ) ; rc = chunked_data_send ( - 1 , fd ) ; } else { if ( debug ) <S2SV_StartBug> printf ( "Discarding<S2SV_blank>%d<S2SV_blank>bytes.\\n" , bodylen ) ; <S2SV_EndBug> rc = data_send ( - 1 , fd , bodylen ) ; } } return rc ; } | <S2SV_ModStart> response ) { length_t bodylen ; int <S2SV_ModEnd> rc = 1 <S2SV_ModStart> ) printf ( "Discarding<S2SV_blank>%lld<S2SV_blank>bytes.\\n" <S2SV_ModEnd> , bodylen ) |
5,490 | CWE-000 GHashTable * modulemd_yaml_parse_string_set ( yaml_parser_t * parser , GError * * error ) { MMD_INIT_YAML_EVENT ( event ) ; gboolean done = FALSE ; gboolean in_list = FALSE ; g_autoptr ( GHashTable ) result = g_hash_table_new_full ( g_str_hash , g_str_equal , g_free , NULL ) ; while ( ! done ) { YAML_PARSER_PARSE_WITH_EXIT ( parser , & event , error ) ; switch ( event . type ) { case YAML_SEQUENCE_START_EVENT : in_list = TRUE ; break ; case YAML_SEQUENCE_END_EVENT : if ( ! in_list ) MMD_YAML_ERROR_EVENT_EXIT ( error , event , "Unexpected<S2SV_blank>end<S2SV_blank>of<S2SV_blank>list" ) ; in_list = FALSE ; done = TRUE ; break ; case YAML_SCALAR_EVENT : g_debug ( "Parsing<S2SV_blank>scalar:<S2SV_blank>%s" , ( const gchar * ) event . data . scalar . value ) ; g_hash_table_add ( result , g_strdup ( ( const gchar * ) event . data . scalar . value ) ) ; if ( ! in_list ) { done = TRUE ; } break ; default : MMD_YAML_ERROR_EVENT_EXIT ( <S2SV_StartBug> error , event , "Unspected<S2SV_blank>YAML<S2SV_blank>event<S2SV_blank>in<S2SV_blank>list" ) ; <S2SV_EndBug> break ; } yaml_event_delete ( & event ) ; } return g_steal_pointer ( & result ) ; } | <S2SV_ModStart> , event , "Unexpected<S2SV_blank>YAML<S2SV_blank>event<S2SV_blank>in<S2SV_blank>list" <S2SV_ModEnd> ) ; break |
5,491 | CWE-000 void cmd_untar ( Volume * volume , int argc , const char * argv [ ] ) { AbstractFile * inFile ; if ( argc < 2 ) { printf ( "Not<S2SV_blank>enough<S2SV_blank>arguments" ) ; return ; } inFile = createAbstractFileFromFile ( fopen ( argv [ 1 ] , "rb" ) ) ; if ( inFile == NULL ) { printf ( "file<S2SV_blank>to<S2SV_blank>untar<S2SV_blank>not<S2SV_blank>found" ) ; } hfs_untar ( volume , inFile ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> inFile ) ; inFile -> close ( inFile ) ; |
5,492 | CWE-000 void print_dict ( ObjDict * dict , bool new_line ) { const char * nl = ( new_line ) ? "\\n" : "" ; const char * tab = ( new_line ) ? "\\t" : "" ; HashTable ht = dict -> content ; printf ( "{%s" , nl ) ; bool first = true ; for ( uint32_t i = 0 ; i < ht . cap ; ++ i ) { HTItem * bucket = ht . buckets [ i ] ; while ( bucket ) { if ( first ) { first = false ; } else { printf ( ",<S2SV_blank>" ) ; } <S2SV_StartBug> printf ( "%s" , tab ) ; <S2SV_EndBug> print_ht_key ( ht . key_type , bucket -> key ) ; <S2SV_StartBug> printf ( ":<S2SV_blank>" ) ; <S2SV_EndBug> <S2SV_StartBug> print_value ( bucket -> value , new_line ) ; <S2SV_EndBug> bucket = bucket -> next ; } } printf ( "}%s" , nl ) ; } | <S2SV_ModStart> } printf ( "%s\\"" <S2SV_ModEnd> , tab ) <S2SV_ModStart> ; printf ( "\\":<S2SV_blank>" <S2SV_ModEnd> ) ; print_value <S2SV_ModStart> value , new_line , true |
5,493 | CWE-000 static struct dst_entry * xfrm6_dst_lookup ( struct net * net , int tos , int oif , const xfrm_address_t * saddr , const xfrm_address_t * daddr ) { struct flowi6 fl6 ; struct dst_entry * dst ; int err ; memset ( & fl6 , 0 , sizeof ( fl6 ) ) ; <S2SV_StartBug> fl6 . flowi6_oif = oif ; <S2SV_EndBug> fl6 . flowi6_flags = FLOWI_FLAG_SKIP_NH_OIF ; memcpy ( & fl6 . daddr , daddr , sizeof ( fl6 . daddr ) ) ; if ( saddr ) memcpy ( & fl6 . saddr , saddr , sizeof ( fl6 . saddr ) ) ; dst = ip6_route_output ( net , NULL , & fl6 ) ; err = dst -> error ; if ( dst -> error ) { dst_release ( dst ) ; dst = ERR_PTR ( err ) ; } return dst ; } | <S2SV_ModStart> . flowi6_oif = l3mdev_master_ifindex_by_index ( net , oif ) <S2SV_ModEnd> ; fl6 . |
5,494 | CWE-000 int ata_host_register ( struct ata_host * host , struct scsi_host_template * sht ) { int i , rc ; <S2SV_StartBug> if ( sht -> can_queue > ATA_MAX_QUEUE ) { <S2SV_EndBug> dev_err ( host -> dev , "BUG:<S2SV_blank>the<S2SV_blank>hardware<S2SV_blank>max<S2SV_blank>queue<S2SV_blank>is<S2SV_blank>too<S2SV_blank>large\\n" ) ; WARN_ON ( 1 ) ; <S2SV_StartBug> return - EINVAL ; <S2SV_EndBug> } if ( ! ( host -> flags & ATA_HOST_STARTED ) ) { dev_err ( host -> dev , "BUG:<S2SV_blank>trying<S2SV_blank>to<S2SV_blank>register<S2SV_blank>unstarted<S2SV_blank>host\\n" ) ; WARN_ON ( 1 ) ; return - EINVAL ; } for ( i = host -> n_ports ; host -> ports [ i ] ; i ++ ) kfree ( host -> ports [ i ] ) ; for ( i = 0 ; i < host -> n_ports ; i ++ ) host -> ports [ i ] -> print_id = atomic_inc_return ( & ata_print_id ) ; for ( i = 0 ; i < host -> n_ports ; i ++ ) { rc = ata_tport_add ( host -> dev , host -> ports [ i ] ) ; if ( rc ) { goto err_tadd ; } } rc = ata_scsi_add_hosts ( host , sht ) ; if ( rc ) goto err_tadd ; ata_acpi_associate ( host ) ; for ( i = 0 ; i < host -> n_ports ; i ++ ) { struct ata_port * ap = host -> ports [ i ] ; unsigned long xfer_mask ; if ( ap -> cbl == ATA_CBL_NONE && ( ap -> flags & ATA_FLAG_SATA ) ) ap -> cbl = ATA_CBL_SATA ; sata_link_init_spd ( & ap -> link ) ; if ( ap -> slave_link ) sata_link_init_spd ( ap -> slave_link ) ; xfer_mask = ata_pack_xfermask ( ap -> pio_mask , ap -> mwdma_mask , ap -> udma_mask ) ; if ( ! ata_port_is_dummy ( ap ) ) { ata_port_info ( ap , "%cATA<S2SV_blank>max<S2SV_blank>%s<S2SV_blank>%s\\n" , ( ap -> flags & ATA_FLAG_SATA ) ? 'S' : 'P' , ata_mode_string ( xfer_mask ) , ap -> link . eh_info . desc ) ; ata_ehi_clear_desc ( & ap -> link . eh_info ) ; } else ata_port_info ( ap , "DUMMY\\n" ) ; } for ( i = 0 ; i < host -> n_ports ; i ++ ) { struct ata_port * ap = host -> ports [ i ] ; async_schedule ( async_port_probe , ap ) ; } return 0 ; err_tadd : while ( -- i >= 0 ) { ata_tport_delete ( host -> ports [ i ] ) ; } return rc ; } | <S2SV_ModStart> , rc ; host -> n_tags = clamp <S2SV_ModEnd> ( sht -> <S2SV_ModStart> sht -> can_queue , 1 , ATA_MAX_QUEUE - <S2SV_ModEnd> 1 ) ; <S2SV_ModStart> 1 ) ; <S2SV_ModEnd> if ( ! |
5,495 | CWE-000 int main ( ) { enum MAIN_STATES main_state = main_start ; <S2SV_StartBug> enum WRITE_STATES write_state = write_start ; <S2SV_EndBug> while ( 1 ) { main_state = main_tick ( main_state ) ; write_state = write_tick ( write_state ) ; <S2SV_StartBug> } <S2SV_EndBug> } | <S2SV_ModStart> write_state = write_start ; enum READ_STATES read_state = read_start <S2SV_ModStart> write_state ) ; read_state = read_tick ( read_state ) ; |
5,496 | CWE-000 gpg_error_t ks_hkp_help ( ctrl_t ctrl , parsed_uri_t uri ) { <S2SV_StartBug> const char const data [ ] = <S2SV_EndBug> "Handler<S2SV_blank>for<S2SV_blank>HKP<S2SV_blank>URLs:\\n" "<S2SV_blank><S2SV_blank>hkp://\\n" # if HTTP_USE_GNUTLS || HTTP_USE_NTBTLS "<S2SV_blank><S2SV_blank>hkps://\\n" # endif "Supported<S2SV_blank>methods:<S2SV_blank>search,<S2SV_blank>get,<S2SV_blank>put\\n" ; gpg_error_t err ; # if HTTP_USE_GNUTLS || HTTP_USE_NTBTLS const char data2 [ ] = "<S2SV_blank><S2SV_blank>hkp\\n<S2SV_blank><S2SV_blank>hkps" ; # else const char data2 [ ] = "<S2SV_blank><S2SV_blank>hkp" ; # endif if ( ! uri ) err = ks_print_help ( ctrl , data2 ) ; else if ( uri -> is_http && ( ! strcmp ( uri -> scheme , "hkp" ) || ! strcmp ( uri -> scheme , "hkps" ) ) ) err = ks_print_help ( ctrl , data ) ; else err = 0 ; return err ; } | <S2SV_ModStart> { const char <S2SV_ModEnd> data [ ] |
5,497 | CWE-000 <S2SV_StartBug> int wdt_enable ( int mode ) { } <S2SV_EndBug> | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> void <S2SV_ModEnd> wdt_enable ( int |
5,498 | CWE-000 int main ( int argc , char * argv [ ] ) { if ( argc != 2 ) { fprintf ( stderr , "error:<S2SV_blank>too<S2SV_blank>few<S2SV_blank>or<S2SV_blank>too<S2SV_blank>many<S2SV_blank>argmuents\\n" ) ; exit ( 1 ) ; } SDL_Init ( SDL_INIT_VIDEO ) ; SDL_CreateWindowAndRenderer ( 512 , 256 , 0 , & window , & renderer ) ; SDL_SetRenderDrawColor ( renderer , 0x00 , 0x00 , 0x00 , 0x00 ) ; SDL_RenderClear ( renderer ) ; SDL_RenderPresent ( renderer ) ; key = SDL_GetKeyboardState ( NULL ) ; load ( argv [ 1 ] ) ; srand ( time ( 0 ) ) ; for ( int cycles = 0 ; ! key [ SDL_SCANCODE_END ] ; cycles ++ ) { SDL_PumpEvents ( ) ; charge ( ) ; cycle ( ) ; if ( cycles % 10 == 0 ) output ( ) ; discharge ( ) ; SDL_Delay ( 1 ) ; } SDL_Quit ( ) ; SDL_DestroyRenderer ( renderer ) ; SDL_DestroyWindow ( window ) ; <S2SV_StartBug> dump ( ) ; <S2SV_EndBug> } | <S2SV_ModStart> window ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
5,499 | CWE-000 <S2SV_StartBug> void TY_ ( ReplacePreformattedSpaces ) ( TidyDocImpl * doc , Node * node ) <S2SV_EndBug> { Node * next ; while ( node ) { next = node -> next ; <S2SV_StartBug> if ( node -> tag && node -> tag -> parser == TY_ ( ParsePre ) ) <S2SV_EndBug> { TY_ ( NormalizeSpaces ) ( doc -> lexer , node -> content ) ; node = next ; continue ; } if ( node -> content ) <S2SV_StartBug> TY_ ( ReplacePreformattedSpaces ) ( doc , node -> content ) ; <S2SV_EndBug> node = next ; } } | <S2SV_ModStart> void TY_ ( ConvertCDATANodes <S2SV_ModEnd> ) ( TidyDocImpl <S2SV_ModStart> ( node -> type == CDATATag ) node -> type = TextNode ; <S2SV_ModEnd> if ( node <S2SV_ModStart> ) TY_ ( ConvertCDATANodes <S2SV_ModEnd> ) ( doc |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.