Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
7,000 | CWE-000 START_TEST ( test_4_2 ) { chidb * db ; BTreeNode * btn ; BTreeCell btc ; char * fname = create_copy ( TESTFILE_STRINGS1 , "btree-test-4-2.dat" ) ; db = malloc ( sizeof ( chidb ) ) ; chidb_Btree_open ( fname , db , & db -> bt ) ; chidb_Btree_getNodeByPage ( db -> bt , 5 , & btn ) ; chidb_Btree_getCell ( btn , 2 , & btc ) ; ck_assert ( btc . type == PGTYPE_TABLE_LEAF ) ; ck_assert ( btc . key == 127 ) ; <S2SV_StartBug> ck_assert ( ! memcmp ( btc . fields . tableLeaf . data , "foo127" , 6 ) ) ; <S2SV_EndBug> chidb_Btree_close ( db -> bt ) ; delete_copy ( fname ) ; free ( db ) ; } | <S2SV_ModStart> ; ck_assert ( btc . fields . tableLeaf . data_size == 128 ) ; ck_assert ( |
7,001 | CWE-000 void * ERR_PTR ( long error ) { <S2SV_StartBug> uint64_t val = error ; <S2SV_EndBug> return ( void * ) val ; } | <S2SV_ModStart> error ) { uintptr_t <S2SV_ModEnd> val = error |
7,002 | CWE-000 static void _initialize_socket_values ( struct oonf_viewer_template * template , struct oonf_socket_entry * sock ) { strscpy ( _value_stat_name , sock -> name , sizeof ( _value_stat_name ) ) ; <S2SV_StartBug> isonumber_from_u64 ( & _value_socket_recv , oonf_socket_get_recv ( sock ) , "" , 0 , template -> create_raw ) ; <S2SV_EndBug> <S2SV_StartBug> isonumber_from_u64 ( & _value_socket_send , oonf_socket_get_send ( sock ) , "" , 0 , template -> create_raw ) ; <S2SV_EndBug> <S2SV_StartBug> isonumber_from_u64 ( & _value_socket_long , oonf_socket_get_long ( sock ) , "" , 0 , template -> create_raw ) ; <S2SV_EndBug> } | <S2SV_ModStart> , "" , 1 <S2SV_ModEnd> , template -> <S2SV_ModStart> , "" , 1 <S2SV_ModEnd> , template -> <S2SV_ModStart> , "" , 1 <S2SV_ModEnd> , template -> |
7,003 | CWE-000 static void * hb_thread_cluster_reader ( UNUSED_ARG void * arg ) { int error ; ER_MSG_INFO * er_msg ; SOCKET sfd ; char buffer [ HB_BUFFER_SZ + MAX_ALIGNMENT ] , * aligned_buffer ; int len ; struct pollfd po [ 1 ] = { { 0 , 0 , 0 } } ; struct sockaddr_in from ; socklen_t from_len ; er_msg = malloc ( sizeof ( ER_MSG_INFO ) ) ; error = er_set_msg_info ( er_msg ) ; if ( error != NO_ERROR ) { assert ( false ) ; return NULL ; } aligned_buffer = PTR_ALIGN ( buffer , MAX_ALIGNMENT ) ; sfd = hb_Cluster -> sfd ; while ( hb_Cluster -> shutdown == false ) { po [ 0 ] . fd = sfd ; po [ 0 ] . events = POLLIN ; error = poll ( po , 1 , 1 ) ; if ( error <= 0 ) { continue ; } if ( ( po [ 0 ] . revents & POLLIN ) && sfd == hb_Cluster -> sfd ) { from_len = sizeof ( from ) ; len = recvfrom ( sfd , ( void * ) aligned_buffer , HB_BUFFER_SZ , 0 , ( struct sockaddr * ) & from , & from_len ) ; if ( len > 0 ) { hb_cluster_receive_heartbeat ( aligned_buffer , len , & from , from_len ) ; } <S2SV_StartBug> FI_TEST_ARG_INT ( NULL , FI_TEST_HB_SLOW_HEARTBEAT_MESSAGE , 5000 , 0 ) ; <S2SV_EndBug> } } return NULL ; } | <S2SV_ModStart> ) ; } error = |
7,004 | CWE-000 <S2SV_StartBug> int upprod ( int grid [ ] ) { <S2SV_EndBug> int max = 0 ; for ( int i = 0 ; i <= SIZE ; i ++ ) { for ( int j = 3 ; j <= SIZE ; j ++ ) { <S2SV_StartBug> if ( ( grid [ i , j - 3 ] * grid [ i , j - 2 ] * grid [ i , j - 1 ] * grid [ i , j ] ) > max ) { <S2SV_EndBug> <S2SV_StartBug> max = grid [ i , j - 3 ] * grid [ i , j - 2 ] * grid [ i , j - 1 ] * grid [ i , j ] ; <S2SV_EndBug> } } } return max ; } | <S2SV_ModStart> int grid [ ] [ SIZE <S2SV_ModStart> grid [ i ] [ <S2SV_ModEnd> j - 3 <S2SV_ModStart> grid [ i ] [ <S2SV_ModEnd> j - 2 <S2SV_ModStart> grid [ i ] [ <S2SV_ModEnd> j - 1 <S2SV_ModStart> grid [ i ] [ <S2SV_ModEnd> j ] ) <S2SV_ModStart> grid [ i ] [ <S2SV_ModEnd> j - 3 <S2SV_ModStart> grid [ i ] [ <S2SV_ModEnd> j - 2 <S2SV_ModStart> grid [ i ] [ <S2SV_ModEnd> j - 1 <S2SV_ModStart> grid [ i ] [ <S2SV_ModEnd> j ] ; |
7,005 | CWE-000 void handle_static_action_clicked ( Tile * tile , TileEvent * event , gpointer data ) { AppShellData * app_data = ( AppShellData * ) data ; MateDesktopItem * item = ( MateDesktopItem * ) g_object_get_data ( G_OBJECT ( tile ) , APP_ACTION_KEY ) ; GSettings * settings ; <S2SV_StartBug> if ( event -> type == TILE_EVENT_ACTIVATED_DOUBLE_CLICK ) <S2SV_EndBug> { return ; } open_desktop_item_exec ( item ) ; settings = g_settings_new ( CONTROL_CENTER_SCHEMA ) ; if ( g_settings_get_boolean ( settings , EXIT_SHELL_ON_STATIC_ACTION ) ) { if ( app_data -> exit_on_close ) { <S2SV_StartBug> gtk_main_quit ( ) ; <S2SV_EndBug> } else { hide_shell ( app_data ) ; } } g_object_unref ( settings ) ; } | <S2SV_ModStart> * settings ; # if GTK_CHECK_VERSION ( 3 , 0 , 0 ) GApplication * app ; # endif <S2SV_ModStart> exit_on_close ) { # if GTK_CHECK_VERSION ( 3 , 0 , 0 ) app = g_application_get_default ( ) ; g_application_quit ( app ) ; # else <S2SV_ModStart> ( ) ; # endif |
7,006 | CWE-000 int ieee80211_mgd_deauth ( struct ieee80211_sub_if_data * sdata , struct cfg80211_deauth_request * req ) { struct ieee80211_if_managed * ifmgd = & sdata -> u . mgd ; u8 frame_buf [ IEEE80211_DEAUTH_FRAME_LEN ] ; bool tx = ! req -> local_state_change ; if ( ifmgd -> auth_data && ether_addr_equal ( ifmgd -> auth_data -> bss -> bssid , req -> bssid ) ) { sdata_info ( sdata , "aborting<S2SV_blank>authentication<S2SV_blank>with<S2SV_blank>%pM<S2SV_blank>by<S2SV_blank>local<S2SV_blank>choice<S2SV_blank>(Reason:<S2SV_blank>%u=%s)\\n" , req -> bssid , req -> reason_code , ieee80211_get_reason_code_string ( req -> reason_code ) ) ; drv_mgd_prepare_tx ( sdata -> local , sdata ) ; ieee80211_send_deauth_disassoc ( sdata , req -> bssid , IEEE80211_STYPE_DEAUTH , req -> reason_code , tx , frame_buf ) ; ieee80211_destroy_auth_data ( sdata , false ) ; ieee80211_report_disconnect ( sdata , frame_buf , sizeof ( frame_buf ) , true , req -> reason_code ) ; return 0 ; } if ( ifmgd -> assoc_data && ether_addr_equal ( ifmgd -> assoc_data -> bss -> bssid , req -> bssid ) ) { sdata_info ( sdata , "aborting<S2SV_blank>association<S2SV_blank>with<S2SV_blank>%pM<S2SV_blank>by<S2SV_blank>local<S2SV_blank>choice<S2SV_blank>(Reason:<S2SV_blank>%u=%s)\\n" , req -> bssid , req -> reason_code , ieee80211_get_reason_code_string ( req -> reason_code ) ) ; drv_mgd_prepare_tx ( sdata -> local , sdata ) ; ieee80211_send_deauth_disassoc ( sdata , req -> bssid , IEEE80211_STYPE_DEAUTH , req -> reason_code , tx , frame_buf ) ; <S2SV_StartBug> ieee80211_destroy_assoc_data ( sdata , false ) ; <S2SV_EndBug> ieee80211_report_disconnect ( sdata , frame_buf , sizeof ( frame_buf ) , true , req -> reason_code ) ; return 0 ; } if ( ifmgd -> associated && ether_addr_equal ( ifmgd -> associated -> bssid , req -> bssid ) ) { sdata_info ( sdata , "deauthenticating<S2SV_blank>from<S2SV_blank>%pM<S2SV_blank>by<S2SV_blank>local<S2SV_blank>choice<S2SV_blank>(Reason:<S2SV_blank>%u=%s)\\n" , req -> bssid , req -> reason_code , ieee80211_get_reason_code_string ( req -> reason_code ) ) ; ieee80211_set_disassoc ( sdata , IEEE80211_STYPE_DEAUTH , req -> reason_code , tx , frame_buf ) ; ieee80211_report_disconnect ( sdata , frame_buf , sizeof ( frame_buf ) , true , req -> reason_code ) ; return 0 ; } return - ENOTCONN ; } | <S2SV_ModStart> sdata , false , true |
7,007 | CWE-000 bool <S2SV_StartBug> rcl_subscription_is_valid ( const rcl_subscription_t * subscription ) <S2SV_EndBug> { <S2SV_StartBug> const rcl_subscription_options_t * options ; <S2SV_EndBug> RCL_CHECK_ARGUMENT_FOR_NULL ( subscription , false , rcl_get_default_allocator ( ) ) ; <S2SV_StartBug> options = _subscription_get_options ( subscription ) ; <S2SV_EndBug> RCL_CHECK_FOR_NULL_WITH_MSG ( options , "subscription\'s<S2SV_blank>option<S2SV_blank>pointer<S2SV_blank>is<S2SV_blank>invalid" , return false , <S2SV_StartBug> rcl_get_default_allocator ( ) ) ; <S2SV_EndBug> <S2SV_StartBug> RCL_CHECK_FOR_NULL_WITH_MSG ( subscription -> impl , <S2SV_EndBug> "subscription<S2SV_blank>implementation<S2SV_blank>is<S2SV_blank>invalid" , return false , options -> allocator ) ; RCL_CHECK_FOR_NULL_WITH_MSG ( subscription -> impl -> rmw_handle , <S2SV_StartBug> "subscription<S2SV_blank>implementation<S2SV_blank>rmw_handle<S2SV_blank>is<S2SV_blank>invalid" , <S2SV_EndBug> return false , <S2SV_StartBug> options -> allocator ) ; <S2SV_EndBug> return true ; } | <S2SV_ModStart> rcl_subscription_t * subscription , rcl_allocator_t * error_msg_allocator <S2SV_ModStart> rcl_subscription_options_t * options ; rcl_allocator_t alloc = error_msg_allocator ? * error_msg_allocator : rcl_get_default_allocator ( ) ; RCL_CHECK_ALLOCATOR_WITH_MSG ( & alloc , "allocator<S2SV_blank>is<S2SV_blank>invalid" , return false ) <S2SV_ModStart> ) ) ; RCL_CHECK_FOR_NULL_WITH_MSG ( subscription -> impl , "subscription\'s<S2SV_blank>implementation<S2SV_blank>is<S2SV_blank>invalid" , return false , alloc ) ; <S2SV_ModStart> return false , alloc <S2SV_ModEnd> ) ; RCL_CHECK_FOR_NULL_WITH_MSG <S2SV_ModStart> ; RCL_CHECK_FOR_NULL_WITH_MSG ( <S2SV_ModEnd> subscription -> impl <S2SV_ModStart> -> rmw_handle , "subscription\'s<S2SV_blank>rmw<S2SV_blank>handle<S2SV_blank>is<S2SV_blank>invalid" <S2SV_ModEnd> , return false <S2SV_ModStart> return false , alloc <S2SV_ModEnd> ) ; return |
7,008 | CWE-000 static char * test_decode_addi ( ) { <S2SV_StartBug> pipeline_init ( & ifid , & idex , & dummy_exmem , & dummy_memwb , & dummy_pc , & dummy_stall , 0 ) ; <S2SV_EndBug> i = 0x22a8ff9c ; p = 0x4 ; ifid -> opCode = OPC_ADDI ; ifid -> regRs = REG_S5 ; ifid -> regRt = REG_T0 ; ifid -> pcNext = p + 4 ; decode ( ifid , idex ) ; mu_assert ( _FL "instruction<S2SV_blank>addi<S2SV_blank>$t0,<S2SV_blank>$s5,<S2SV_blank>-100<S2SV_blank>bad<S2SV_blank>regDst" , idex -> regDst == 0 ) ; mu_assert ( _FL "instruction<S2SV_blank>addi<S2SV_blank>$t0,<S2SV_blank>$s5,<S2SV_blank>-100<S2SV_blank>bad<S2SV_blank>regWrite" , idex -> regWrite == 1 ) ; mu_assert ( _FL "instruction<S2SV_blank>addi<S2SV_blank>$t0,<S2SV_blank>$s5,<S2SV_blank>-100<S2SV_blank>bad<S2SV_blank>ALUSrc" , idex -> ALUSrc == 1 ) ; mu_assert ( _FL "instruction<S2SV_blank>addi<S2SV_blank>$t0,<S2SV_blank>$s5,<S2SV_blank>-100<S2SV_blank>bad<S2SV_blank>PCSrc" , idex -> PCSrc == 0 ) ; mu_assert ( _FL "instruction<S2SV_blank>addi<S2SV_blank>$t0,<S2SV_blank>$s5,<S2SV_blank>-100<S2SV_blank>bad<S2SV_blank>memRead" , idex -> memRead == 0 ) ; mu_assert ( _FL "instruction<S2SV_blank>addi<S2SV_blank>$t0,<S2SV_blank>$s5,<S2SV_blank>-100<S2SV_blank>bad<S2SV_blank>memWrite" , idex -> memWrite == 0 ) ; mu_assert ( _FL "instruction<S2SV_blank>addi<S2SV_blank>$t0,<S2SV_blank>$s5,<S2SV_blank>-100<S2SV_blank>bad<S2SV_blank>memToReg" , idex -> memToReg == 0 ) ; mu_assert ( _FL "instruction<S2SV_blank>addi<S2SV_blank>$t0,<S2SV_blank>$s5,<S2SV_blank>-100<S2SV_blank>bad<S2SV_blank>ALUop" , idex -> ALUop == OPR_ADD ) ; mu_assert ( _FL "instruction<S2SV_blank>addi<S2SV_blank>$t0,<S2SV_blank>$s5,<S2SV_blank>-100<S2SV_blank>bad<S2SV_blank>jump" , idex -> jump == 0 ) ; mu_assert ( _FL "instruction<S2SV_blank>addi<S2SV_blank>$t0,<S2SV_blank>$s5,<S2SV_blank>-100<S2SV_blank>bad<S2SV_blank>regRsValue" , idex -> regRsValue == 21 ) ; pipeline_destroy ( & ifid , & idex , & dummy_exmem , & dummy_memwb ) ; return 0 ; } | <S2SV_ModStart> & dummy_pc , <S2SV_ModEnd> 0 ) ; |
7,009 | CWE-000 LUA_API void lua_seti ( lua_State * L , int index , lua_Integer n ) { <S2SV_StartBug> lua_pushinteger ( L , n ) ; <S2SV_EndBug> <S2SV_StartBug> lua_insert ( L , lua_gettop ( L ) - 1 ) ; <S2SV_EndBug> lua_settable ( L , index ) ; } | <S2SV_ModStart> n ) { index = lua_absindex ( L , index ) ; <S2SV_ModStart> n ) ; lua_swaptoptwo ( L <S2SV_ModEnd> ) ; lua_settable |
7,010 | CWE-000 int connections ( Map g , LocationID start , LocationID end , TransportID type [ ] ) { assert ( g != NULL ) ; int index = 0 ; for ( VList this = g -> connections [ start ] ; this != NULL ; this = this -> next ) { if ( this -> v == end ) { type [ index ] = this -> type ; index ++ ; } <S2SV_StartBug> } <S2SV_EndBug> return index ; } | <S2SV_ModStart> ++ ; } else if ( this -> type == BOAT ) { for ( VList sea = g -> connections [ this -> v ] ; sea != NULL ; sea = sea -> next ) { if ( sea -> v == end && ( isLand ( start ) && isLand ( end ) && isSea ( sea -> v ) ) ) { type [ index ] = BOAT ; index ++ ; break ; } } } |
7,011 | CWE-000 void terra_visual_labels ( ssize_t const width , ssize_t const height , terra_visual_bounds const * const bounds ) { # ifdef NCURSES float y_val ; float y_step ; terra_time tt ; size_t x_min ; size_t x_max ; size_t x_val ; size_t x_step ; ssize_t mlen ; char buf [ 10 ] ; ssize_t lbls ; ssize_t i ; lbls = DRAW_HEIGHT / GRID_MARKER_Y ; if ( lbls * GRID_MARKER_Y < DRAW_HEIGHT ) { lbls ++ ; } y_step = ( bounds -> ymax - bounds -> ymin ) / ( lbls - 1 ) ; y_val = bounds -> ymin ; for ( i = 0 ; i < lbls ; i ++ , y_val += y_step ) { <S2SV_StartBug> mvprintw ( height - GRID_OFFSET_BOTTOM - i * GRID_MARKER_Y , 1 , "%.1f" , y_val ) ; <S2SV_EndBug> } x_min = terra_time_to_int ( & bounds -> xmin ) ; x_max = terra_time_to_int ( & bounds -> xmax ) ; lbls = DRAW_WIDTH / GRID_MARKER_X ; if ( lbls * GRID_MARKER_X < DRAW_WIDTH ) { lbls ++ ; } x_step = ( x_max - x_min ) / ( lbls - 1 ) ; x_val = x_min ; for ( i = 0 ; i < lbls ; i ++ , x_val += x_step ) { terra_time_from_int ( & tt , x_val ) ; terra_time_to_arr ( buf , & tt ) ; mlen = labels_remove_secs ( buf ) ; <S2SV_StartBug> mvprintw ( height - GRID_OFFSET_BOTTOM + 1 , GRID_OFFSET_LEFT + i * GRID_MARKER_X - ( mlen / 2 ) , "%s" , buf ) ; <S2SV_EndBug> } # endif } | <S2SV_ModStart> - GRID_OFFSET_BOTTOM - 1 - <S2SV_ModStart> height - GRID_OFFSET_BOTTOM <S2SV_ModEnd> , GRID_OFFSET_LEFT + |
7,012 | CWE-000 static int dw_i2c_plat_probe ( struct platform_device * pdev ) { struct dw_i2c_platform_data * pdata = dev_get_platdata ( & pdev -> dev ) ; struct dw_i2c_dev * dev ; struct i2c_adapter * adap ; struct resource * mem ; int irq , r ; u32 acpi_speed , ht = 0 ; irq = platform_get_irq ( pdev , 0 ) ; if ( irq < 0 ) return irq ; dev = devm_kzalloc ( & pdev -> dev , sizeof ( struct dw_i2c_dev ) , GFP_KERNEL ) ; if ( ! dev ) return - ENOMEM ; mem = platform_get_resource ( pdev , IORESOURCE_MEM , 0 ) ; dev -> base = devm_ioremap_resource ( & pdev -> dev , mem ) ; if ( IS_ERR ( dev -> base ) ) return PTR_ERR ( dev -> base ) ; dev -> dev = & pdev -> dev ; dev -> irq = irq ; platform_set_drvdata ( pdev , dev ) ; dev -> rst = devm_reset_control_get_optional_exclusive ( & pdev -> dev , NULL ) ; if ( IS_ERR ( dev -> rst ) ) { if ( PTR_ERR ( dev -> rst ) == - EPROBE_DEFER ) return - EPROBE_DEFER ; } else { reset_control_deassert ( dev -> rst ) ; } if ( pdata ) { dev -> clk_freq = pdata -> i2c_scl_freq ; } else { device_property_read_u32 ( & pdev -> dev , "i2c-sda-hold-time-ns" , & ht ) ; device_property_read_u32 ( & pdev -> dev , "i2c-sda-falling-time-ns" , & dev -> sda_falling_time ) ; device_property_read_u32 ( & pdev -> dev , "i2c-scl-falling-time-ns" , & dev -> scl_falling_time ) ; device_property_read_u32 ( & pdev -> dev , "clock-frequency" , & dev -> clk_freq ) ; <S2SV_StartBug> } <S2SV_EndBug> acpi_speed = i2c_acpi_find_bus_speed ( & pdev -> dev ) ; if ( acpi_speed && dev -> clk_freq ) dev -> clk_freq = min ( dev -> clk_freq , acpi_speed ) ; else if ( acpi_speed || dev -> clk_freq ) dev -> clk_freq = max ( dev -> clk_freq , acpi_speed ) ; else dev -> clk_freq = 400000 ; if ( has_acpi_companion ( & pdev -> dev ) ) dw_i2c_acpi_configure ( pdev ) ; if ( dev -> clk_freq != 100000 && dev -> clk_freq != 400000 && dev -> clk_freq != 1000000 && dev -> clk_freq != 3400000 ) { dev_err ( & pdev -> dev , "Only<S2SV_blank>100kHz,<S2SV_blank>400kHz,<S2SV_blank>1MHz<S2SV_blank>and<S2SV_blank>3.4MHz<S2SV_blank>supported" ) ; r = - EINVAL ; goto exit_reset ; } r = i2c_dw_eval_lock_support ( dev ) ; if ( r ) goto exit_reset ; dev -> functionality = I2C_FUNC_10BIT_ADDR | DW_IC_DEFAULT_FUNCTIONALITY ; dev -> master_cfg = DW_IC_CON_MASTER | DW_IC_CON_SLAVE_DISABLE | DW_IC_CON_RESTART_EN ; switch ( dev -> clk_freq ) { case 100000 : dev -> master_cfg |= DW_IC_CON_SPEED_STD ; break ; case 3400000 : dev -> master_cfg |= DW_IC_CON_SPEED_HIGH ; break ; default : dev -> master_cfg |= DW_IC_CON_SPEED_FAST ; } <S2SV_StartBug> dev -> clk = devm_clk_get ( & pdev -> dev , NULL ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ! i2c_dw_plat_prepare_clk ( dev , true ) ) { <S2SV_EndBug> dev -> get_clk_rate_khz = i2c_dw_get_clk_rate_khz ; if ( ! dev -> sda_hold_time && ht ) dev -> sda_hold_time = div_u64 ( ( u64 ) dev -> get_clk_rate_khz ( dev ) * ht + 500000 , 1000000 ) ; } dw_i2c_set_fifo_size ( dev , pdev -> id ) ; adap = & dev -> adapter ; adap -> owner = THIS_MODULE ; adap -> class = I2C_CLASS_DEPRECATED ; ACPI_COMPANION_SET ( & adap -> dev , ACPI_COMPANION ( & pdev -> dev ) ) ; adap -> dev . of_node = pdev -> dev . of_node ; if ( dev -> pm_runtime_disabled ) { pm_runtime_forbid ( & pdev -> dev ) ; } else { pm_runtime_set_autosuspend_delay ( & pdev -> dev , 1000 ) ; pm_runtime_use_autosuspend ( & pdev -> dev ) ; pm_runtime_set_active ( & pdev -> dev ) ; pm_runtime_enable ( & pdev -> dev ) ; } r = i2c_dw_probe ( dev ) ; if ( r ) goto exit_probe ; return r ; exit_probe : if ( ! dev -> pm_runtime_disabled ) pm_runtime_disable ( & pdev -> dev ) ; exit_reset : if ( ! IS_ERR_OR_NULL ( dev -> rst ) ) reset_control_assert ( dev -> rst ) ; return r ; } | <S2SV_ModStart> clk_freq ) ; device_property_read_u32 ( & pdev -> dev , "refclk-frequency" , & dev -> ref_clk_freq ) ; <S2SV_ModStart> DW_IC_CON_SPEED_FAST ; } if ( ! dev -> ref_clk_freq ) <S2SV_ModStart> ; if ( dev -> ref_clk_freq || |
7,013 | CWE-000 int pnv_tce_build ( struct iommu_table * tbl , long index , long npages , unsigned long uaddr , enum dma_data_direction direction , unsigned long attrs ) { u64 proto_tce = iommu_direction_to_tce_perm ( direction ) ; u64 rpn = __pa ( uaddr ) >> tbl -> it_page_shift ; long i ; if ( proto_tce & TCE_PCI_WRITE ) proto_tce |= TCE_PCI_READ ; for ( i = 0 ; i < npages ; i ++ ) { unsigned long newtce = proto_tce | ( ( rpn + i ) << tbl -> it_page_shift ) ; unsigned long idx = index - tbl -> it_offset + i ; <S2SV_StartBug> * ( pnv_tce ( tbl , false , idx ) ) = cpu_to_be64 ( newtce ) ; <S2SV_EndBug> } return 0 ; } | <S2SV_ModStart> false , idx , true |
7,014 | CWE-000 static void fd_chr_update_read_handler ( Chardev * chr , GMainContext * context ) { FDChardev * s = FD_CHARDEV ( chr ) ; <S2SV_StartBug> remove_fd_in_watch ( chr , NULL ) ; <S2SV_EndBug> if ( s -> ioc_in ) { <S2SV_StartBug> chr -> fd_in_tag = io_add_watch_poll ( chr , s -> ioc_in , <S2SV_EndBug> fd_chr_read_poll , fd_chr_read , chr , context ) ; } } | <S2SV_ModStart> remove_fd_in_watch ( chr <S2SV_ModEnd> ) ; if <S2SV_ModStart> { chr -> gsource <S2SV_ModEnd> = io_add_watch_poll ( |
7,015 | CWE-000 PROCESS_THREAD ( node_process , ev , data ) { static struct etimer etaa ; static char * collect_data ; char * rxdata ; PROCESS_BEGIN ( ) ; uart_set_input ( 1 , serial_line_input_byte ) ; while ( 1 ) { <S2SV_StartBug> # if DEBUG <S2SV_EndBug> PROCESS_WAIT_EVENT ( ) ; if ( ev == serial_line_event_message ) { leds_toggle ( LEDS_RED ) ; rxdata = data ; PRINTF ( "Data<S2SV_blank>received<S2SV_blank>over<S2SV_blank>UART<S2SV_blank>%s\\n" , rxdata ) ; collect_data_send ( rxdata ) ; PRINTF ( "Received<S2SV_blank>Done.\\n" ) ; } else { PRINTF ( "Nothing...<S2SV_blank>\\n" ) ; } # endif } PROCESS_END ( ) ; } | <S2SV_ModStart> { # if haveArduino <S2SV_ModEnd> PROCESS_WAIT_EVENT ( ) |
7,016 | CWE-000 connection * create_new_connection ( connection_storage * connection_storage ) { connection * new_connection = 0 ; if ( connection_storage -> count < connection_storage -> capacity ) { new_connection = ( connection_storage -> connections + connection_storage -> count ++ ) ; new_connection -> socket = 0 ; new_connection -> socket_initialized = 0 ; new_connection -> pending_disconnect = 0 ; <S2SV_StartBug> new_connection -> send_bytes = 0 ; <S2SV_EndBug> new_connection -> transfer_in_progress = 0 ; memset ( & new_connection -> transfer , 0 , sizeof ( connection_file_transfer ) ) ; } return new_connection ; } | <S2SV_ModStart> ; new_connection -> send_data_count <S2SV_ModEnd> = 0 ; |
7,017 | CWE-000 int main ( int argc , char * argv [ ] ) { int ages [ ] = { 23 , 43 , 12 , 89 , 2 } ; char * names [ ] = { "Alan" , "Frank" , "Mary" , "John" , <S2SV_StartBug> "Lisa" , <S2SV_EndBug> } ; int count = sizeof ( ages ) / sizeof ( int ) ; int i = 0 ; for ( i = 0 ; i < count ; i ++ ) { <S2SV_StartBug> printf ( "%s<S2SV_blank>has<S2SV_blank>%d<S2SV_blank>years<S2SV_blank>alive.\\n" , names [ i ] , ages [ i ] ) ; <S2SV_EndBug> } printf ( "---\\n" ) ; int * cur_age = ages ; char * * cur_name = names ; for ( i = 0 ; i < count ; i ++ ) { printf ( "%s<S2SV_blank>is<S2SV_blank>%d<S2SV_blank>years<S2SV_blank>old.\\n" , * ( cur_name + i ) , * ( cur_age + i ) ) ; } <S2SV_StartBug> for ( i = 0 ; i < count ; i ++ ) { <S2SV_EndBug> printf ( "%s<S2SV_blank>is<S2SV_blank>%d<S2SV_blank>years<S2SV_blank>old.\\n" , cur_name [ i ] , cur_age [ i ] ) ; } for ( cur_name = names , cur_age = ages ; ( cur_age - ages ) < count ; cur_name ++ , cur_age ++ ) { <S2SV_StartBug> printf ( "%s<S2SV_blank>lived<S2SV_blank>%d<S2SV_blank>years<S2SV_blank>so<S2SV_blank>far.<S2SV_blank>loc:<S2SV_blank>%p\\n" , * cur_name , * cur_age , cur_name ) ; <S2SV_EndBug> } return 0 ; } | <S2SV_ModStart> "John" , "Lisa" <S2SV_ModEnd> } ; int <S2SV_ModStart> { printf ( "%s<S2SV_blank>has<S2SV_blank>%d<S2SV_blank>years.\\n" <S2SV_ModEnd> , names [ <S2SV_ModStart> ) ; } printf ( "---\\n" ) ; for ( i = 0 ; i < count ; i ++ ) { printf ( "%s<S2SV_blank>is<S2SV_blank>%d<S2SV_blank>years<S2SV_blank>old<S2SV_blank>again.\\n" , cur_name [ i ] , cur_age [ i ] ) ; } printf ( "---\\n" ) ; for ( cur_age = ages , cur_name = names <S2SV_ModEnd> ; ( cur_age <S2SV_ModStart> { printf ( "%s<S2SV_blank>lived<S2SV_blank>%d<S2SV_blank>years,<S2SV_blank>at<S2SV_blank>address<S2SV_blank>%p.\\n" , * cur_name , * cur_age , cur_age <S2SV_ModEnd> ) ; } |
7,018 | CWE-000 static int _history_copy_and_paste_on_image_merge ( int32_t imgid , int32_t dest_imgid , GList * ops ) { GList * modules_used = NULL ; dt_develop_t _dev_src = { 0 } ; dt_develop_t _dev_dest = { 0 } ; dt_develop_t * dev_src = & _dev_src ; dt_develop_t * dev_dest = & _dev_dest ; dt_dev_init ( dev_src , FALSE ) ; dt_dev_init ( dev_dest , FALSE ) ; dev_src -> iop = dt_iop_load_modules_ext ( dev_src , TRUE ) ; dev_dest -> iop = dt_iop_load_modules_ext ( dev_dest , TRUE ) ; dt_masks_read_forms_ext ( dev_src , imgid , TRUE ) ; dt_masks_read_forms_ext ( dev_dest , dest_imgid , TRUE ) ; dt_dev_read_history_ext ( dev_src , imgid , TRUE ) ; dt_dev_read_history_ext ( dev_dest , dest_imgid , TRUE ) ; <S2SV_StartBug> dt_dev_pop_history_items_ext ( dev_src , dev_src -> history_end , TRUE ) ; <S2SV_EndBug> <S2SV_StartBug> dt_dev_pop_history_items_ext ( dev_dest , dev_dest -> history_end , TRUE ) ; <S2SV_EndBug> guint nbf = g_list_length ( dev_src -> forms ) ; int * forms_used_replace = calloc ( nbf , sizeof ( int ) ) ; if ( ops ) { GList * l = g_list_last ( ops ) ; while ( l ) { unsigned int num = GPOINTER_TO_UINT ( l -> data ) ; dt_dev_history_item_t * hist = g_list_nth_data ( dev_src -> history , num ) ; if ( hist ) { _history_merge_module_into_history ( dev_dest , hist -> module , & modules_used , FALSE ) ; if ( hist -> module -> flags ( ) & IOP_FLAGS_SUPPORTS_BLENDING ) { if ( hist -> module -> blend_params -> mask_id > 0 ) _fill_used_forms ( dev_src -> forms , hist -> module -> blend_params -> mask_id , forms_used_replace , nbf ) ; } } l = g_list_previous ( l ) ; } } else { GList * modules_src = g_list_first ( dev_src -> iop ) ; while ( modules_src ) { dt_iop_module_t * mod_src = ( dt_iop_module_t * ) ( modules_src -> data ) ; if ( _search_history_by_module ( dev_src , mod_src ) != NULL ) { _history_merge_module_into_history ( dev_dest , mod_src , & modules_used , FALSE ) ; if ( mod_src -> flags ( ) & IOP_FLAGS_SUPPORTS_BLENDING ) { if ( mod_src -> blend_params -> mask_id > 0 ) _fill_used_forms ( dev_src -> forms , mod_src -> blend_params -> mask_id , forms_used_replace , nbf ) ; } } modules_src = g_list_next ( modules_src ) ; } } for ( int i = 0 ; i < nbf && forms_used_replace [ i ] > 0 ; i ++ ) { dt_masks_form_t * form = dt_masks_get_from_id_ext ( dev_src -> forms , forms_used_replace [ i ] ) ; if ( form ) { dt_masks_form_t * form_dest = dt_masks_get_from_id_ext ( dev_dest -> forms , forms_used_replace [ i ] ) ; if ( form_dest ) { dev_dest -> forms = g_list_remove ( dev_dest -> forms , form_dest ) ; } dev_dest -> forms = g_list_append ( dev_dest -> forms , form ) ; } else fprintf ( stderr , "[_history_copy_and_paste_on_image_merge]<S2SV_blank>form<S2SV_blank>%i<S2SV_blank>not<S2SV_blank>found<S2SV_blank>in<S2SV_blank>source<S2SV_blank>image\\n" , forms_used_replace [ i ] ) ; } dt_masks_write_forms_ext ( dev_dest , dest_imgid , FALSE ) ; dt_dev_write_history_ext ( dev_dest , dest_imgid ) ; dt_dev_cleanup ( dev_src ) ; dt_dev_cleanup ( dev_dest ) ; g_list_free ( modules_used ) ; free ( forms_used_replace ) ; return 0 ; } | <S2SV_ModStart> dev_src -> history_end <S2SV_ModEnd> ) ; dt_dev_pop_history_items_ext <S2SV_ModStart> dev_dest -> history_end <S2SV_ModEnd> ) ; guint |
7,019 | CWE-000 static u32 map_id_up ( struct uid_gid_map * map , u32 id ) { unsigned idx , extents ; u32 first , last ; extents = map -> nr_extents ; <S2SV_StartBug> smp_read_barrier_depends ( ) ; <S2SV_EndBug> for ( idx = 0 ; idx < extents ; idx ++ ) { first = map -> extent [ idx ] . lower_first ; last = first + map -> extent [ idx ] . count - 1 ; if ( id >= first && id <= last ) break ; } if ( idx < extents ) id = ( id - first ) + map -> extent [ idx ] . first ; else id = ( u32 ) - 1 ; return id ; } | <S2SV_ModStart> -> nr_extents ; smp_rmb <S2SV_ModEnd> ( ) ; |
7,020 | CWE-000 int addFileToUser ( int file_id , int user_id ) { char * line = NULL ; size_t len = 0 ; ssize_t read ; rename ( "userdata.txt" , "userdata_temp.txt" ) ; FILE * fp_temp = fopen ( "userdata_temp.txt" , "r+" ) ; if ( fp_temp == NULL ) { perror ( "userdata_temp.txt<S2SV_blank>open" ) ; return - 3 ; } <S2SV_StartBug> FILE * fp = fopen ( "userdata.txt" , "w" ) ; <S2SV_EndBug> if ( fp == NULL ) { perror ( "userdatatxt<S2SV_blank>open" ) ; return - 2 ; <S2SV_StartBug> } <S2SV_EndBug> int i = 1 ; while ( ( read = getline ( & line , & len , fp_temp ) ) != - 1 ) { if ( i == user_id ) { fprintf ( fp , "%s" , line ) ; if ( strstr ( line , "\\n" ) != NULL ) { fseek ( fp , - 1 , SEEK_CUR ) ; fprintf ( fp , ":%d\\n" , file_id ) ; } else { fprintf ( fp , ":%d" , file_id ) ; } } else { fprintf ( fp , "%s" , line ) ; } i ++ ; } <S2SV_StartBug> fclose ( fp_temp ) ; <S2SV_EndBug> fclose ( fp ) ; int err = 0 ; if ( remove ( "userdata_temp.txt" ) != 0 ) { perror ( "delete<S2SV_blank>userdata_temp.txt" ) ; err = - 1 ; } return err ; } | <S2SV_ModStart> 3 ; } int fd_temp = fileno ( fp_temp ) ; flock ( fd_temp , LOCK_EX ) ; <S2SV_ModStart> 2 ; } int fd = fileno ( fp ) ; flock ( fd , LOCK_EX ) ; <S2SV_ModStart> ++ ; } flock ( fd_temp , LOCK_UN ) ; flock ( fd , LOCK_UN ) ; |
7,021 | CWE-000 static int TraversePMNS ( const char * name , void ( * func ) ( const char * ) , void ( * func_r ) ( const char * , void * ) , void * closure ) { <S2SV_StartBug> int sts ; <S2SV_EndBug> int pmns_location ; __pmContext * ctxp ; ctx_ctl_t ctx_ctl = { NULL , 0 , 0 } ; lock_ctx_and_pmns ( NULL , & ctx_ctl ) ; ctxp = ctx_ctl . ctxp ; pmns_location = pmGetPMNSLocation_ctx ( ctx_ctl . ctxp ) ; if ( pmns_location < 0 ) { sts = pmns_location ; goto pmapi_return ; } if ( name == NULL ) { sts = PM_ERR_NAME ; goto pmapi_return ; } if ( pmns_location == PMNS_LOCAL || pmns_location == PMNS_ARCHIVE ) { <S2SV_StartBug> int numnames = 0 ; <S2SV_EndBug> char * * namelist = NULL ; int sz_namelist = 0 ; int i ; sts = TraversePMNS_local ( ctxp , ( char * ) name , & numnames , & namelist , & sz_namelist ) ; if ( ctx_ctl . need_pmns_unlock ) { PM_UNLOCK ( pmns_lock ) ; ctx_ctl . need_pmns_unlock = 0 ; } if ( ctx_ctl . need_ctx_unlock ) { PM_UNLOCK ( ctx_ctl . ctxp -> c_lock ) ; ctx_ctl . need_ctx_unlock = 0 ; } for ( i = 0 ; i < numnames ; i ++ ) { if ( func_r == NULL ) ( * func ) ( namelist [ i ] ) ; else ( * func_r ) ( namelist [ i ] , closure ) ; free ( namelist [ i ] ) ; } if ( namelist != NULL ) free ( namelist ) ; } else { __pmPDU * pb ; if ( ctxp == NULL ) { sts = PM_ERR_NOCONTEXT ; goto pmapi_return ; } sts = __pmSendTraversePMNSReq ( ctxp -> c_pmcd -> pc_fd , __pmPtrToHandle ( ctxp ) , name ) ; if ( sts < 0 ) { sts = __pmMapErrno ( sts ) ; goto pmapi_return ; } else { <S2SV_StartBug> int numnames ; <S2SV_EndBug> int i ; int xtra ; char * * namelist ; int pinpdu ; PM_FAULT_POINT ( "libpcp/" __FILE__ ":4" , PM_FAULT_TIMEOUT ) ; pinpdu = sts = __pmGetPDU ( ctxp -> c_pmcd -> pc_fd , ANY_SIZE , TIMEOUT_DEFAULT , & pb ) ; if ( ctx_ctl . need_pmns_unlock ) { PM_UNLOCK ( pmns_lock ) ; ctx_ctl . need_pmns_unlock = 0 ; } if ( ctx_ctl . need_ctx_unlock ) { PM_UNLOCK ( ctx_ctl . ctxp -> c_lock ) ; ctx_ctl . need_ctx_unlock = 0 ; } if ( sts == PDU_PMNS_NAMES ) { sts = __pmDecodeNameList ( pb , & numnames , & namelist , NULL ) ; if ( sts > 0 ) { for ( i = 0 ; i < numnames ; i ++ ) { if ( func_r == NULL ) ( * func ) ( namelist [ i ] ) ; else ( * func_r ) ( namelist [ i ] , closure ) ; } <S2SV_StartBug> numnames = sts ; <S2SV_EndBug> free ( namelist ) ; } else { __pmUnpinPDUBuf ( pb ) ; goto pmapi_return ; } } else if ( sts == PDU_ERROR ) { __pmDecodeError ( pb , & sts ) ; if ( sts != PM_ERR_NAME ) { __pmUnpinPDUBuf ( pb ) ; goto pmapi_return ; } numnames = 0 ; } else { if ( pinpdu > 0 ) __pmUnpinPDUBuf ( pb ) ; if ( sts != PM_ERR_TIMEOUT ) sts = PM_ERR_IPC ; goto pmapi_return ; } if ( pinpdu > 0 ) __pmUnpinPDUBuf ( pb ) ; xtra = __dmtraverse ( ctxp , name , & namelist ) ; if ( xtra > 0 ) { sts = 0 ; for ( i = 0 ; i < xtra ; i ++ ) { if ( func_r == NULL ) ( * func ) ( namelist [ i ] ) ; else ( * func_r ) ( namelist [ i ] , closure ) ; } numnames += xtra ; free ( namelist ) ; } if ( sts > 0 ) { sts = numnames ; goto pmapi_return ; } } } pmapi_return : if ( ctx_ctl . need_pmns_unlock ) PM_UNLOCK ( pmns_lock ) ; if ( ctx_ctl . need_ctx_unlock ) PM_UNLOCK ( ctx_ctl . ctxp -> c_lock ) ; <S2SV_StartBug> return sts ; <S2SV_EndBug> } | <S2SV_ModStart> { int sts ; int numnames = 0 <S2SV_ModStart> PMNS_ARCHIVE ) { <S2SV_ModEnd> char * * <S2SV_ModStart> else { int <S2SV_ModEnd> i ; int <S2SV_ModStart> ) ; } <S2SV_ModEnd> free ( namelist <S2SV_ModStart> ; return sts < 0 ? sts : numnames |
7,022 | CWE-000 PetscErrorCode PostEventFunction ( TS ts , PetscInt nevents , PetscInt event_list [ ] , PetscReal t , Vec U , PetscBool forwardsolve , void * ctx ) { PetscErrorCode ierr ; PetscScalar * u ; PetscMPIInt rank ; PetscFunctionBegin ; ierr = MPI_Comm_rank ( PETSC_COMM_WORLD , & rank ) ; CHKERRQ ( ierr ) ; if ( nevents ) { <S2SV_StartBug> ierr = PetscPrintf ( PETSC_COMM_SELF , "Processor<S2SV_blank>[%d]:<S2SV_blank>Ball<S2SV_blank>hit<S2SV_blank>the<S2SV_blank>ground<S2SV_blank>at<S2SV_blank>t<S2SV_blank>=<S2SV_blank>%5.2f<S2SV_blank>seconds\\n" , rank , ( double ) t ) ; CHKERRQ ( ierr ) ; <S2SV_EndBug> ierr = VecGetArray ( U , & u ) ; CHKERRQ ( ierr ) ; u [ 0 ] = 1.0 * rank ; u [ 1 ] = - 0.9 * u [ 1 ] ; ierr = VecRestoreArray ( U , & u ) ; CHKERRQ ( ierr ) ; } PetscFunctionReturn ( 0 ) ; } | <S2SV_ModStart> ( PETSC_COMM_SELF , "Ball<S2SV_blank>hit<S2SV_blank>the<S2SV_blank>ground<S2SV_blank>at<S2SV_blank>t<S2SV_blank>=<S2SV_blank>%5.2f<S2SV_blank>seconds<S2SV_blank>-><S2SV_blank>Processor[%d]\\n" <S2SV_ModEnd> , ( double <S2SV_ModStart> double ) t , rank |
7,023 | CWE-000 int ssdp_discovery ( sockets * s ) { char * reply = "NOTIFY<S2SV_blank>*<S2SV_blank>HTTP/1.1\\r\\n" "HOST:<S2SV_blank>%s:1900\\r\\n" "CACHE-CONTROL:<S2SV_blank>max-age=1800\\r\\n" "LOCATION:<S2SV_blank>http://%s/%s\\r\\n" "NT:<S2SV_blank>%s\\r\\n" "NTS:<S2SV_blank>ssdp:alive<S2SV_blank>\\r\\n" "SERVER:<S2SV_blank>Linux/1.0<S2SV_blank>UPnP/1.1<S2SV_blank>%s/%s\\r\\n" "USN:<S2SV_blank>uuid:%s%s\\r\\n" "BOOTID.UPNP.ORG:<S2SV_blank>%d\\r\\n" "CONFIGID.UPNP.ORG:<S2SV_blank>0\\r\\n" "DEVICEID.SES.COM:<S2SV_blank>%d\\r\\n\\r\\n\\0" ; char buf [ 500 ] , mac [ 15 ] = "00000000000000" ; char nt [ 3 ] [ 50 ] ; char uuid1 [ ] = "11223344-9999-0000-b7ae" ; socklen_t salen ; int i ; s -> wtime = getTick ( ) ; if ( uuidi == 0 ) { uuidi = 1 ; get_mac_address ( mac ) ; sprintf ( uuid , "%s-%s" , uuid1 , mac ) ; fill_sockaddr ( & ssdp_sa , opts . disc_host , 1900 ) ; } strcpy ( nt [ 0 ] , "::upnp:rootdevice" ) ; sprintf ( nt [ 1 ] , "::uuid:%s" , uuid ) ; strcpy ( nt [ 2 ] , "::urn:ses-com:device:SatIPServer:1" ) ; if ( s -> type != TYPE_UDP ) return 0 ; LOGM ( "ssdp_discovery:<S2SV_blank>bootid:<S2SV_blank>%d<S2SV_blank>deviceid:<S2SV_blank>%d<S2SV_blank>http:<S2SV_blank>%s" , opts . bootid , opts . device_id , opts . http_host ) ; for ( i = 0 ; i < 3 ; i ++ ) { sprintf ( buf , reply , opts . disc_host , opts . http_host , opts . xml_path , nt [ i ] + 2 , app_name , version , uuid , i == 1 ? "" : nt [ i ] , opts . bootid , opts . device_id ) ; salen = sizeof ( ssdp_sa ) ; LOGM ( "Discovery<S2SV_blank>packet<S2SV_blank>%d:\\n%s" , i + 1 , buf ) ; <S2SV_StartBug> sendto ( s -> sock , buf , strlen ( buf ) , MSG_NOSIGNAL , <S2SV_EndBug> ( const struct sockaddr * ) & ssdp_sa , salen ) ; <S2SV_StartBug> } <S2SV_EndBug> s -> rtime = getTick ( ) ; return 0 ; } | <S2SV_ModStart> buf ) ; int wb = <S2SV_ModStart> salen ) ; if ( wb != strlen ( buf ) ) LOG ( "incomplete<S2SV_blank>ssdp_discovery:<S2SV_blank>wrote<S2SV_blank>%d<S2SV_blank>out<S2SV_blank>of<S2SV_blank>%d:<S2SV_blank>error<S2SV_blank>%d:<S2SV_blank>%s" , wb , strlen ( buf ) , errno , strerror ( errno ) ) ; |
7,024 | CWE-000 void swapBytes ( ByteList * list , uint first , uint second ) <S2SV_StartBug> { <S2SV_EndBug> ByteListElement temp = list -> elements [ first ] ; list -> elements [ first ] = list -> elements [ second ] ; <S2SV_StartBug> list -> elements [ second ] = list -> elements [ first ] ; <S2SV_EndBug> } | <S2SV_ModStart> second ) { if ( first == second ) return ; printf ( "Swap<S2SV_blank>I1=%u<S2SV_blank>V1=%c<S2SV_blank>I2=%u<S2SV_blank>V2=%c\\n" , first , list -> elements [ first ] . data , second , list -> elements [ second ] . data ) ; <S2SV_ModStart> second ] = temp <S2SV_ModEnd> ; } <S2SV_null> |
7,025 | CWE-000 static int skl_tplg_mfest_fill_dmactrl ( struct device * dev , struct skl_dmactrl_config * dmactrl_cfg , struct snd_soc_tplg_vendor_value_elem * tkn_elem ) { u32 cfg_idx = dmactrl_cfg -> idx ; struct skl_dmctrl_hdr * hdr = & dmactrl_cfg -> hdr [ cfg_idx ] ; switch ( tkn_elem -> token ) { case SKL_TKN_U32_FMT_CH : hdr -> ch = tkn_elem -> value ; break ; case SKL_TKN_U32_FMT_FREQ : hdr -> freq = tkn_elem -> value ; break ; case SKL_TKN_U32_FMT_BIT_DEPTH : hdr -> fmt = tkn_elem -> value ; break ; case SKL_TKN_U32_PIPE_DIRECTION : hdr -> direction = tkn_elem -> value ; break ; case SKL_TKN_U8_TIME_SLOT : hdr -> tdm_slot = tkn_elem -> value ; break ; case SKL_TKN_U32_VBUS_ID : hdr -> vbus_id = tkn_elem -> value ; break ; case SKL_TKN_U32_DMACTRL_CFG_IDX : dmactrl_cfg -> idx = tkn_elem -> value ; break ; case SKL_TKN_U32_DMACTRL_CFG_SIZE : if ( tkn_elem -> value && ! hdr -> data ) { hdr -> data = devm_kzalloc ( dev , tkn_elem -> value , GFP_KERNEL ) ; if ( ! hdr -> data ) return - ENOMEM ; hdr -> data_size = tkn_elem -> value ; <S2SV_StartBug> } else { <S2SV_EndBug> hdr -> data_size = 0 ; dev_err ( dev , "Invalid<S2SV_blank>dmactrl<S2SV_blank>info<S2SV_blank>\\n" ) ; } break ; default : dev_err ( dev , "Invalid<S2SV_blank>token<S2SV_blank>%d\\n" , tkn_elem -> token ) ; return - EINVAL ; } return 0 ; } | <S2SV_ModStart> -> value ; dmactrl_cfg -> size = hdr -> data_size ; |
7,026 | CWE-000 __attribute__ ( ( nonnull ( 1 ) , nothrow , warn_unused_result ) ) static int test4 ( darr_t * restrict darr ) { int num ; size_t k ; size_t sz = darr -> n ; <S2SV_StartBug> printf ( "test4<S2SV_blank>()<S2SV_blank>sz:<S2SV_blank>%d\\n" , ( int ) sz ) ; <S2SV_EndBug> if ( darr -> n == 0 ) k = 0 ; else k = ( size_t ) rand ( ) % ( darr -> n + 1 ) ; num = rand ( ) ; error_check ( insert_front_darr ( darr , k , & num ) != 0 ) { puts ( "error<S2SV_blank>-12" ) ; fflush ( stdout ) ; return - 12 ; } error_check ( sz + 1 != darr -> n ) return - 1 ; darr_print ( & darr ) ; return 0 ; } | <S2SV_ModStart> int ) sz ) ; fflush ( stdout |
7,027 | CWE-000 static int s_vsnprintf_real ( char * s , size_t n , const char * fmt , va_list ap ) { <S2SV_StartBug> int r ; <S2SV_EndBug> # ifdef HAVE_NO_SNPRINTF FILE * fdevnull ; # endif s_memzero ( s , n ) ; # ifdef HAVE_NO_SNPRINTF fdevnull = fopen ( "/dev/null" , "w" ) ; if ( ! fdevnull ) xexits ( "s_vsnprintf:<S2SV_blank>/dev/null<S2SV_blank>is<S2SV_blank>not<S2SV_blank>available!" ) ; <S2SV_StartBug> r = vfprintf ( fdevnull , fmt , ap ) ; <S2SV_EndBug> fclose ( fdevnull ) ; if ( r < 0 || r >= n ) return r ; <S2SV_StartBug> if ( n && s ) r = vsprintf ( s , fmt , ap ) ; <S2SV_EndBug> <S2SV_StartBug> # else <S2SV_EndBug> <S2SV_StartBug> r = vsnprintf ( s , n , fmt , ap ) ; <S2SV_EndBug> # endif return r ; } | <S2SV_ModStart> { int r ; va_list t <S2SV_ModStart> "s_vsnprintf:<S2SV_blank>/dev/null<S2SV_blank>is<S2SV_blank>not<S2SV_blank>available!" ) ; va_copy ( t , ap ) ; <S2SV_ModStart> , fmt , t ) ; va_end ( t <S2SV_ModEnd> ) ; fclose <S2SV_ModStart> , fmt , t <S2SV_ModEnd> ) ; # <S2SV_ModStart> ; # else va_copy ( t , ap ) ; <S2SV_ModStart> , fmt , t ) ; va_end ( t <S2SV_ModEnd> ) ; # |
7,028 | CWE-000 static struct hmr_rdma_transport * hmr_rdma_transport_create ( struct hmr_context * ctx ) { struct hmr_rdma_transport * rdma_trans ; rdma_trans = ( struct hmr_rdma_transport * ) calloc ( 1 , sizeof ( struct hmr_rdma_transport ) ) ; if ( ! rdma_trans ) { ERROR_LOG ( "allocate<S2SV_blank>hmr_rdma_transport<S2SV_blank>memory<S2SV_blank>error." ) ; return NULL ; } <S2SV_StartBug> rdma_trans -> ctx = ctx ; <S2SV_EndBug> hmr_init_rdma_event_channel ( rdma_trans ) ; return rdma_trans ; } | <S2SV_ModStart> } rdma_trans -> trans_state = HMR_RDMA_TRANSPORT_STATE_INIT ; rdma_trans -> |
7,029 | CWE-000 void __attribute__ ( ( noreturn ) ) task_execve ( virtaddr_t function , char UNUSED ( * argv [ ] ) , unsigned int UNUSED ( flags ) ) { struct task * self = percpu_get ( current ) ; if ( self -> mmu == & kernel_mmu ) { <S2SV_StartBug> self -> mmu = kmalloc ( sizeof ( struct mmu_info ) , KM_NONE ) ; <S2SV_EndBug> self -> mmu -> p4 = page_to_virt ( pmm_alloc_order ( 0 , GFP_NONE ) ) ; copy_kernel_mappings ( self -> mmu -> p4 ) ; change_cr3 ( virt_to_phys ( self -> mmu -> p4 ) ) ; } else { vmm_destroy_low_mappings ( self -> mmu ) ; } # define UTASK_ENTRY 0x1000 # define UTASK_STACK_BOTTOM 0x3000 # define UTASK_STACK_TOP 0x5000 uintptr_t entry = UTASK_ENTRY ; vmm_map_page ( self -> mmu , kern_to_phys ( function ) , ( virtaddr_t ) entry , PAGE_EXECUTABLE | PAGE_USER_ACCESSIBLE ) ; vmm_map_page ( self -> mmu , kern_to_phys ( function ) + PAGE_SIZE , ( virtaddr_t ) ( entry + PAGE_SIZE ) , PAGE_EXECUTABLE | PAGE_USER_ACCESSIBLE ) ; entry += ( ( uintptr_t ) function & 0xFFF ) ; for ( size_t i = 0 ; i < 2 ; i ++ ) { size_t off = i * PAGE_SIZE ; uintptr_t page = ( uintptr_t ) page_to_virt ( pmm_alloc_order ( 0 , GFP_NONE ) ) ; vmm_map_page ( self -> mmu , virt_to_phys ( ( virtaddr_t ) ( page + off ) ) , ( virtaddr_t ) ( UTASK_STACK_BOTTOM + off ) , PAGE_WRITABLE | PAGE_USER_ACCESSIBLE ) ; } struct vm_area * code = kmalloc ( sizeof ( struct vm_area ) , KM_NONE ) ; memset ( code , 0 , sizeof * code ) ; code -> base = UTASK_ENTRY ; code -> len = 2 * PAGE_SIZE ; code -> type = VM_AREA_TEXT ; code -> flags = VM_AREA_EXECUTABLE ; area_add ( self -> mmu , code ) ; struct vm_area * stack = kmalloc ( sizeof ( struct vm_area ) , KM_NONE ) ; memset ( stack , 0 , sizeof * stack ) ; stack -> base = UTASK_STACK_TOP ; stack -> len = UTASK_STACK_TOP - UTASK_STACK_BOTTOM ; stack -> type = VM_AREA_STACK ; stack -> flags = VM_AREA_WRITABLE ; area_add ( self -> mmu , stack ) ; slist_foreach ( cur , list , self -> mmu -> areas ) { klog_verbose ( "task" , "Added<S2SV_blank>area<S2SV_blank>at<S2SV_blank>%p,<S2SV_blank>size<S2SV_blank>%zu\\n" , ( void * ) cur -> base , cur -> len ) ; } reload_cr3 ( ) ; ret_from_execve ( ( virtaddr_t ) entry , UTASK_STACK_TOP ) ; } | <S2SV_ModStart> -> mmu = vmm_mmu_alloc ( <S2SV_ModEnd> ) ; self |
7,030 | CWE-000 static Split * select_payment_split ( GtkWidget * parent , Transaction * txn ) { GList * payment_splits = xaccTransGetPaymentAcctSplitList ( txn ) ; if ( ! payment_splits ) { <S2SV_StartBug> GtkWidget * dialog = gtk_message_dialog_new ( GTK_WINDOW ( parent ) , <S2SV_EndBug> GTK_DIALOG_DESTROY_WITH_PARENT , GTK_MESSAGE_INFO , GTK_BUTTONS_CLOSE , "%s" , _ ( "The<S2SV_blank>selected<S2SV_blank>transaction<S2SV_blank>doesn\'t<S2SV_blank>have<S2SV_blank>splits<S2SV_blank>that<S2SV_blank>can<S2SV_blank>be<S2SV_blank>assigned<S2SV_blank>as<S2SV_blank>a<S2SV_blank>payment" ) ) ; gtk_dialog_run ( GTK_DIALOG ( dialog ) ) ; gtk_widget_destroy ( dialog ) ; g_message ( "No<S2SV_blank>asset<S2SV_blank>splits<S2SV_blank>in<S2SV_blank>txn<S2SV_blank>\\"%s\\";<S2SV_blank>cannot<S2SV_blank>use<S2SV_blank>this<S2SV_blank>for<S2SV_blank>assigning<S2SV_blank>a<S2SV_blank>payment." , xaccTransGetDescription ( txn ) ) ; return NULL ; } if ( g_list_length ( payment_splits ) > 1 ) { Split * selected_split = NULL ; GList * node ; GtkWidget * first_rb ; int answer = GTK_BUTTONS_OK ; const char * message = _ ( "While<S2SV_blank>this<S2SV_blank>transaction<S2SV_blank>has<S2SV_blank>multiple<S2SV_blank>splits<S2SV_blank>that<S2SV_blank>can<S2SV_blank>be<S2SV_blank>considered\\nas<S2SV_blank>\'the<S2SV_blank>payment<S2SV_blank>split\',<S2SV_blank>gnucash<S2SV_blank>only<S2SV_blank>knows<S2SV_blank>how<S2SV_blank>to<S2SV_blank>handle<S2SV_blank>one.\\n" "Please<S2SV_blank>select<S2SV_blank>one,<S2SV_blank>the<S2SV_blank>others<S2SV_blank>will<S2SV_blank>be<S2SV_blank>ignored.\\n\\n" ) ; GtkDialog * dialog = GTK_DIALOG ( gtk_dialog_new_with_buttons ( _ ( "Warning" ) , GTK_WINDOW ( parent ) , GTK_DIALOG_DESTROY_WITH_PARENT , _ ( "Continue" ) , GTK_BUTTONS_OK , _ ( "Cancel" ) , GTK_BUTTONS_CANCEL , NULL ) ) ; GtkWidget * content = gtk_dialog_get_content_area ( dialog ) ; GtkWidget * label = gtk_label_new ( message ) ; gtk_box_pack_start ( GTK_BOX ( content ) , label , FALSE , TRUE , 0 ) ; for ( node = payment_splits ; node ; node = node -> next ) { GtkWidget * rbutton ; Split * split = node -> data ; char * split_str = gen_split_desc ( txn , split ) ; if ( node == payment_splits ) { first_rb = gtk_radio_button_new_with_label ( NULL , split_str ) ; rbutton = first_rb ; } else rbutton = gtk_radio_button_new_with_label_from_widget ( GTK_RADIO_BUTTON ( first_rb ) , split_str ) ; g_object_set_data ( G_OBJECT ( rbutton ) , "split" , split ) ; gtk_box_pack_start ( GTK_BOX ( content ) , rbutton , FALSE , FALSE , 0 ) ; g_free ( split_str ) ; } gtk_dialog_set_default_response ( dialog , GTK_BUTTONS_CANCEL ) ; gtk_widget_show_all ( GTK_WIDGET ( dialog ) ) ; answer = gtk_dialog_run ( dialog ) ; if ( answer == GTK_BUTTONS_OK ) { GSList * rbgroup = gtk_radio_button_get_group ( GTK_RADIO_BUTTON ( first_rb ) ) ; GSList * rbnode ; for ( rbnode = rbgroup ; rbnode ; rbnode = rbnode -> next ) { GtkWidget * rbutton = rbnode -> data ; if ( gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON ( rbutton ) ) ) { selected_split = g_object_get_data ( G_OBJECT ( rbutton ) , "split" ) ; break ; } } } gtk_widget_destroy ( GTK_WIDGET ( dialog ) ) ; return selected_split ; } else return payment_splits -> data ; } | <S2SV_ModStart> { GtkWidget * dialog ; if ( xaccTransGetTxnType ( txn ) == TXN_TYPE_LINK ) return NULL ; |
7,031 | CWE-000 uint32_t get_pixel ( unsigned x , unsigned y , const uint8_t * nt , const uint8_t * bg ) { const unsigned id = ( x >> 3 ) + ( y >> 3 ) * 32 ; const uint32_t name = nt [ id ] ; const uint8_t * nowp0 = bg + name * 16 ; const uint8_t * nowp1 = nowp0 + 8 ; <S2SV_StartBug> const int offset = y & 0x7 ; <S2SV_EndBug> const uint8_t p0 = nowp0 [ offset ] ; const uint8_t p1 = nowp1 [ offset ] ; const uint8_t shift = ( ~ x ) & 0x7 ; const uint8_t mask = 1 << shift ; const uint8_t low = ( ( p0 & mask ) >> shift ) | ( ( p1 & mask ) >> shift << 1 ) ; const unsigned aid = ( x >> 5 ) + ( y >> 5 ) * 8 ; const uint8_t attr = nt [ aid + ( 32 * 30 ) ] ; const uint8_t aoffset = ( ( x & 0x10 ) >> 3 ) | ( ( y & 0x10 ) >> 2 ) ; const uint8_t high = ( attr & ( 3 << aoffset ) ) >> aoffset << 2 ; const uint8_t index = high | low ; return palette_data [ index ] ; } | <S2SV_ModStart> 8 ; const uint8_t p0 = nowp0 [ y & 0x7 ] ; const uint8_t p1 = nowp1 [ y & 0x7 ] ; const uint8_t shift = ( ~ x ) & 0x7 ; const uint8_t mask = 1 << shift ; const uint8_t low = ( ( p0 & mask ) >> shift ) | ( ( p1 & mask ) >> shift << 1 ) ; if ( name == 0xb5 && low == 0 ) { int bk = 9 ; } <S2SV_ModEnd> const unsigned aid |
7,032 | CWE-000 ZEND_METHOD ( Deferred , combine ) { async_deferred * defer ; async_deferred_awaitable * awaitable ; async_deferred_combine * combined ; async_task * task ; async_deferred_awaitable * inner ; zend_class_entry * ce ; zend_fcall_info fci ; zend_fcall_info_cache fcc ; uint32_t count ; zval * args ; zend_ulong i ; zend_string * k ; zval key ; zval * entry ; zval obj ; ZEND_PARSE_PARAMETERS_START_EX ( ZEND_PARSE_PARAMS_THROW , 2 , 2 ) Z_PARAM_ARRAY ( args ) Z_PARAM_FUNC_EX ( fci , fcc , 1 , 0 ) ZEND_PARSE_PARAMETERS_END ( ) ; count = zend_array_count ( Z_ARRVAL_P ( args ) ) ; if ( count == 0 ) { zend_throw_error ( zend_ce_argument_count_error , "At<S2SV_blank>least<S2SV_blank>one<S2SV_blank>awaitable<S2SV_blank>is<S2SV_blank>required" ) ; return ; } fci . no_separation = 1 ; ZEND_HASH_FOREACH_VAL ( Z_ARRVAL_P ( args ) , entry ) { <S2SV_StartBug> if ( Z_TYPE_P ( entry ) != IS_OBJECT ) { <S2SV_EndBug> zend_throw_error ( zend_ce_type_error , "All<S2SV_blank>input<S2SV_blank>elements<S2SV_blank>must<S2SV_blank>be<S2SV_blank>awaitable" ) ; return ; } <S2SV_StartBug> ce = Z_OBJCE_P ( entry ) ; <S2SV_EndBug> if ( ce != async_task_ce && ce != async_deferred_awaitable_ce ) { zend_throw_error ( zend_ce_type_error , "All<S2SV_blank>input<S2SV_blank>elements<S2SV_blank>must<S2SV_blank>be<S2SV_blank>awaitable" ) ; return ; } } ZEND_HASH_FOREACH_END ( ) ; defer = emalloc ( sizeof ( async_deferred ) ) ; ZEND_SECURE_ZERO ( defer , sizeof ( async_deferred ) ) ; zend_object_std_init ( & defer -> std , async_deferred_ce ) ; defer -> std . handlers = & async_deferred_handlers ; defer -> status = ASYNC_DEFERRED_STATUS_PENDING ; awaitable = async_deferred_awaitable_object_create ( defer ) ; ZVAL_OBJ ( & obj , & awaitable -> std ) ; combined = emalloc ( sizeof ( async_deferred_combine ) ) ; combined -> defer = defer ; combined -> counter = count ; combined -> fci = fci ; combined -> fcc = fcc ; Z_TRY_ADDREF_P ( & combined -> fci . function_name ) ; ZEND_HASH_FOREACH_KEY_VAL_IND ( Z_ARRVAL_P ( args ) , i , k , entry ) { ce = Z_OBJCE_P ( entry ) ; if ( k == NULL ) { ZVAL_LONG ( & key , i ) ; } else { ZVAL_STR ( & key , k ) ; } if ( ce == async_task_ce ) { task = ( async_task * ) Z_OBJ_P ( entry ) ; if ( task -> fiber . status == ASYNC_FIBER_STATUS_FINISHED ) { async_deferred_combine_continuation ( combined , & key , & task -> result , 1 ) ; } else if ( task -> fiber . status == ASYNC_FIBER_STATUS_DEAD ) { async_deferred_combine_continuation ( combined , & key , & task -> result , 0 ) ; } else { async_awaitable_register_continuation ( & task -> continuation , combined , & key , async_deferred_combine_continuation ) ; } } else { inner = ( async_deferred_awaitable * ) Z_OBJ_P ( entry ) ; if ( inner -> defer -> status == ASYNC_DEFERRED_STATUS_RESOLVED ) { async_deferred_combine_continuation ( combined , & key , & inner -> defer -> result , 1 ) ; } else if ( inner -> defer -> status == ASYNC_DEFERRED_STATUS_FAILED ) { async_deferred_combine_continuation ( combined , & key , & inner -> defer -> result , 0 ) ; } else { async_awaitable_register_continuation ( & inner -> defer -> continuation , combined , & key , async_deferred_combine_continuation ) ; } } zval_ptr_dtor ( & key ) ; } ZEND_HASH_FOREACH_END ( ) ; RETURN_ZVAL ( & obj , 1 , 1 ) ; } | <S2SV_ModStart> entry ) { ce = <S2SV_ModEnd> ( Z_TYPE_P ( <S2SV_ModStart> ( entry ) == IS_OBJECT ) ? <S2SV_ModEnd> Z_OBJCE_P ( entry <S2SV_ModStart> ( entry ) : NULL |
7,033 | CWE-000 void printLinkedList ( LList * list ) { LLNode * iterator ; int count = 1 ; printf ( "List<S2SV_blank>contents:<S2SV_blank>\\n" ) ; for ( iterator = list -> first ; iterator ; iterator = iterator -> next ) { <S2SV_StartBug> printf ( "<S2SV_blank><S2SV_blank>%d:<S2SV_blank><%s>\\n" , count iterator -> string ) ; <S2SV_EndBug> count ++ ; } } | <S2SV_ModStart> { printf ( "<S2SV_blank><S2SV_blank>%d:<S2SV_blank><%s><S2SV_blank>\\n" , count , <S2SV_ModEnd> iterator -> string |
7,034 | CWE-000 s6_accessrules_result_t s6_accessrules_backend_cdb ( char const * key , size_t keylen , void * data , s6_accessrules_params_t * params ) { struct cdb * c = data ; size_t execbase ; unsigned int n ; uint16_t envlen , execlen ; int r = cdb_find ( c , key , keylen ) ; if ( r < 0 ) return S6_ACCESSRULES_ERROR ; else if ( ! r ) return S6_ACCESSRULES_NOTFOUND ; n = cdb_datalen ( c ) ; <S2SV_StartBug> if ( ( n < 5U ) || ( n > 8197U ) ) return ( errno = EINVAL , S6_ACCESSRULES_ERROR ) ; <S2SV_EndBug> if ( ! stralloc_readyplus ( & params -> exec , n ) ) return S6_ACCESSRULES_ERROR ; execbase = params -> exec . len ; if ( cdb_read ( c , params -> exec . s + execbase , n , cdb_datapos ( c ) ) < 0 ) return S6_ACCESSRULES_ERROR ; if ( params -> exec . s [ execbase ] == 'D' ) return S6_ACCESSRULES_DENY ; else if ( params -> exec . s [ execbase ] != 'A' ) return S6_ACCESSRULES_NOTFOUND ; <S2SV_StartBug> uint16_unpack_big ( params -> exec . s + execbase + 1U , & envlen ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ( envlen > 4096U ) || ( envlen + 5U > n ) ) return ( errno = EINVAL , S6_ACCESSRULES_ERROR ) ; <S2SV_EndBug> uint16_unpack_big ( params -> exec . s + execbase + 3 + envlen , & execlen ) ; <S2SV_StartBug> if ( ( execlen > 4096U ) || ( 5U + envlen + execlen != n ) ) return ( errno = EINVAL , S6_ACCESSRULES_ERROR ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ! stralloc_catb ( & params -> env , params -> exec . s + execbase + 3U , envlen ) ) return S6_ACCESSRULES_ERROR ; <S2SV_EndBug> <S2SV_StartBug> memcpy ( params -> exec . s + execbase , params -> exec . s + execbase + 5U + envlen , execlen ) ; <S2SV_EndBug> if ( execlen ) { params -> exec . len += execlen ; params -> exec . s [ params -> exec . len ++ ] = 0 ; } return S6_ACCESSRULES_ALLOW ; } | <S2SV_ModStart> ; if ( ! n || n > 8197 <S2SV_ModEnd> ) return ( <S2SV_ModStart> return S6_ACCESSRULES_NOTFOUND ; else if ( n < 5 ) return ( errno = EINVAL , S6_ACCESSRULES_ERROR ) ; <S2SV_ModStart> + execbase + 1 <S2SV_ModEnd> , & envlen <S2SV_ModStart> ( envlen > 4096 <S2SV_ModEnd> ) || ( <S2SV_ModStart> ( envlen + 5 <S2SV_ModEnd> > n ) <S2SV_ModStart> ( execlen > 4096 <S2SV_ModEnd> ) || ( <S2SV_ModStart> ) || ( 5 <S2SV_ModEnd> + envlen + <S2SV_ModStart> + execbase + 3 <S2SV_ModEnd> , envlen ) <S2SV_ModStart> + execbase + 5 <S2SV_ModEnd> + envlen , |
7,035 | CWE-000 <S2SV_StartBug> DaoxCanvas * DaoxCanvas_New ( ) <S2SV_EndBug> { DaoxCanvas * self = ( DaoxCanvas * ) dao_calloc ( 1 , sizeof ( DaoxCanvas ) ) ; <S2SV_StartBug> DaoCstruct_Init ( ( DaoCstruct * ) self , daox_type_canvas ) ; <S2SV_EndBug> self -> transform = DaoxMatrix3D_Identity ( ) ; self -> brushes = DList_New ( DAO_DATA_VALUE ) ; self -> nodes = DList_New ( DAO_DATA_VALUE ) ; self -> actives = DList_New ( 0 ) ; <S2SV_StartBug> self -> auxPath = DaoxPath_New ( ) ; <S2SV_EndBug> DaoGC_IncRC ( ( DaoValue * ) self -> auxPath ) ; <S2SV_StartBug> self -> pathCache = DaoxPathCache_New ( ) ; <S2SV_EndBug> DaoGC_IncRC ( ( DaoValue * ) self -> pathCache ) ; return self ; } | <S2SV_ModStart> * DaoxCanvas_New ( DaoVmSpace * vmspace <S2SV_ModStart> ) self , DaoVmSpace_GetType ( vmspace , & daoCanvasCore ) <S2SV_ModEnd> ) ; self <S2SV_ModStart> = DaoxPath_New ( vmspace <S2SV_ModStart> = DaoxPathCache_New ( vmspace |
7,036 | CWE-000 void e_editor_dom_selection_set_monospace ( EEditorPage * editor_page , gboolean value ) { WebKitDOMDocument * document ; WebKitDOMRange * range = NULL ; EEditorHistoryEvent * ev = NULL ; EEditorUndoRedoManager * manager ; guint font_size = 0 ; g_return_if_fail ( E_IS_EDITOR_PAGE ( editor_page ) ) ; if ( ( e_editor_dom_selection_is_monospace ( editor_page ) ? 1 : 0 ) == ( value ? 1 : 0 ) ) return ; document = e_editor_page_get_document ( editor_page ) ; range = e_editor_dom_get_current_range ( editor_page ) ; if ( ! range ) return ; manager = e_editor_page_get_undo_redo_manager ( editor_page ) ; if ( ! e_editor_undo_redo_manager_is_operation_in_progress ( manager ) ) { ev = g_new0 ( EEditorHistoryEvent , 1 ) ; ev -> type = HISTORY_MONOSPACE ; e_editor_dom_selection_get_coordinates ( editor_page , & ev -> before . start . x , & ev -> before . start . y , & ev -> before . end . x , & ev -> before . end . y ) ; ev -> data . style . from = ! value ; ev -> data . style . to = value ; } font_size = e_editor_page_get_font_size ( editor_page ) ; if ( font_size == 0 ) font_size = E_CONTENT_EDITOR_FONT_SIZE_NORMAL ; if ( value ) { WebKitDOMElement * monospace ; monospace = webkit_dom_document_create_element ( document , "font" , NULL ) ; webkit_dom_element_set_attribute ( monospace , "face" , "monospace" , NULL ) ; if ( font_size != 0 ) { gchar * font_size_str ; font_size_str = g_strdup_printf ( "%d" , font_size ) ; webkit_dom_element_set_attribute ( monospace , "size" , font_size_str , NULL ) ; g_free ( font_size_str ) ; } if ( ! webkit_dom_range_get_collapsed ( range , NULL ) ) monospace_selection ( editor_page , monospace ) ; else { webkit_dom_element_set_inner_html ( monospace , UNICODE_ZERO_WIDTH_SPACE , NULL ) ; webkit_dom_range_insert_node ( range , WEBKIT_DOM_NODE ( monospace ) , NULL ) ; e_editor_dom_move_caret_into_element ( editor_page , monospace , FALSE ) ; } } else { gboolean is_bold = FALSE , is_italic = FALSE ; gboolean is_underline = FALSE , is_strikethrough = FALSE ; <S2SV_StartBug> guint font_size = 0 ; <S2SV_EndBug> WebKitDOMElement * tt_element ; WebKitDOMNode * node ; node = webkit_dom_range_get_end_container ( range , NULL ) ; if ( WEBKIT_DOM_IS_ELEMENT ( node ) && is_monospace_element ( WEBKIT_DOM_ELEMENT ( node ) ) ) { tt_element = WEBKIT_DOM_ELEMENT ( node ) ; } else { tt_element = dom_node_find_parent_element ( node , "FONT" ) ; if ( ! is_monospace_element ( tt_element ) ) { g_clear_object ( & range ) ; g_free ( ev ) ; return ; } } is_bold = e_editor_page_get_bold ( editor_page ) ; is_italic = e_editor_page_get_italic ( editor_page ) ; is_underline = e_editor_page_get_underline ( editor_page ) ; is_strikethrough = e_editor_page_get_strikethrough ( editor_page ) ; if ( ! e_editor_dom_selection_is_collapsed ( editor_page ) ) unmonospace_selection ( editor_page ) ; else { e_editor_dom_selection_save ( editor_page ) ; set_font_style ( document , "" , FALSE ) ; e_editor_dom_selection_restore ( editor_page ) ; } if ( is_bold ) e_editor_dom_selection_set_bold ( editor_page , TRUE ) ; if ( is_italic ) e_editor_dom_selection_set_italic ( editor_page , TRUE ) ; if ( is_underline ) e_editor_dom_selection_set_underline ( editor_page , TRUE ) ; if ( is_strikethrough ) e_editor_dom_selection_set_strikethrough ( editor_page , TRUE ) ; if ( font_size ) e_editor_dom_selection_set_font_size ( editor_page , font_size ) ; } if ( ev ) { e_editor_dom_selection_get_coordinates ( editor_page , & ev -> after . start . x , & ev -> after . start . y , & ev -> after . end . x , & ev -> after . end . y ) ; e_editor_undo_redo_manager_insert_history_event ( manager , ev ) ; } e_editor_dom_force_spell_check_for_current_paragraph ( editor_page ) ; g_clear_object ( & range ) ; } | <S2SV_ModStart> = FALSE ; <S2SV_ModEnd> WebKitDOMElement * tt_element |
7,037 | CWE-000 static int suspend_prepare ( suspend_state_t state ) { int error ; unsigned int free_pages ; if ( ! pm_ops || ! pm_ops -> enter ) return - EPERM ; pm_prepare_console ( ) ; if ( freeze_processes ( ) ) { error = - EAGAIN ; goto Thaw ; } if ( ( free_pages = global_page_state ( NR_FREE_PAGES ) ) < FREE_PAGE_NUMBER ) { pr_debug ( "PM:<S2SV_blank>free<S2SV_blank>some<S2SV_blank>memory\\n" ) ; shrink_all_memory ( FREE_PAGE_NUMBER - free_pages ) ; if ( nr_free_pages ( ) < FREE_PAGE_NUMBER ) { error = - ENOMEM ; printk ( KERN_ERR "PM:<S2SV_blank>No<S2SV_blank>enough<S2SV_blank>memory\\n" ) ; goto Thaw ; } } <S2SV_StartBug> suspend_console ( ) ; <S2SV_EndBug> error = device_suspend ( PMSG_SUSPEND ) ; if ( error ) { printk ( KERN_ERR "Some<S2SV_blank>devices<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>suspend\\n" ) ; goto Resume_console ; } if ( pm_ops -> prepare ) { if ( ( error = pm_ops -> prepare ( state ) ) ) goto Resume_devices ; } error = disable_nonboot_cpus ( ) ; if ( ! error ) return 0 ; enable_nonboot_cpus ( ) ; pm_finish ( state ) ; Resume_devices : device_resume ( ) ; Resume_console : resume_console ( ) ; Thaw : thaw_processes ( ) ; pm_restore_console ( ) ; return error ; } | <S2SV_ModStart> ; } } if ( pm_ops -> set_target ) { error = pm_ops -> set_target ( state ) ; if ( error ) goto Thaw ; } |
7,038 | CWE-000 static int dhd_open ( struct net_device * net ) { dhd_info_t * dhd = DHD_DEV_INFO ( net ) ; # ifdef TOE uint32 toe_ol ; # endif int ifidx ; int32 ret = 0 ; DHD_OS_WAKE_LOCK ( & dhd -> pub ) ; DHD_PERIM_LOCK ( & dhd -> pub ) ; dhd -> pub . dongle_trap_occured = 0 ; dhd -> pub . hang_was_sent = 0 ; # if ! defined ( WL_CFG80211 ) ret = wl_control_wl_start ( net ) ; if ( ret != 0 ) { DHD_ERROR ( ( "%s:<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>code<S2SV_blank>%d\\n" , __FUNCTION__ , ret ) ) ; ret = - 1 ; goto exit ; } # endif ifidx = dhd_net2idx ( dhd , net ) ; DHD_TRACE ( ( "%s:<S2SV_blank>ifidx<S2SV_blank>%d\\n" , __FUNCTION__ , ifidx ) ) ; if ( ifidx < 0 ) { DHD_ERROR ( ( "%s:<S2SV_blank>Error:<S2SV_blank>called<S2SV_blank>with<S2SV_blank>invalid<S2SV_blank>IF\\n" , __FUNCTION__ ) ) ; ret = - 1 ; goto exit ; } if ( ! dhd -> iflist [ ifidx ] ) { DHD_ERROR ( ( "%s:<S2SV_blank>Error:<S2SV_blank>called<S2SV_blank>when<S2SV_blank>IF<S2SV_blank>already<S2SV_blank>deleted\\n" , __FUNCTION__ ) ) ; ret = - 1 ; goto exit ; } if ( ifidx == 0 ) { # if defined ( BCMPCIE ) && defined ( CONFIG_WIFI_CONTROL_FUNC ) if ( ! dhd -> register_if_done ) { DHD_ERROR ( ( "%s:<S2SV_blank>Registering<S2SV_blank>interface<S2SV_blank>has<S2SV_blank>not<S2SV_blank>done<S2SV_blank>yet\\n" , __FUNCTION__ ) ) ; return - 1 ; } # endif atomic_set ( & dhd -> pend_8021x_cnt , 0 ) ; # if defined ( WL_CFG80211 ) if ( ! dhd_download_fw_on_driverload ) { DHD_ERROR ( ( "\\n%s\\n" , dhd_version ) ) ; # if defined ( USE_INITIAL_2G_SCAN ) || defined ( USE_INITIAL_SHORT_DWELL_TIME ) g_first_broadcast_scan = TRUE ; # endif ret = wl_android_wifi_on ( net ) ; if ( ret != 0 ) { DHD_ERROR ( ( "%s<S2SV_blank>:<S2SV_blank>wl_android_wifi_on<S2SV_blank>failed<S2SV_blank>(%d)\\n" , __FUNCTION__ , ret ) ) ; ret = - 1 ; goto exit ; } } # endif if ( dhd -> pub . busstate != DHD_BUS_DATA ) { DHD_PERIM_UNLOCK ( & dhd -> pub ) ; ret = dhd_bus_start ( & dhd -> pub ) ; DHD_PERIM_LOCK ( & dhd -> pub ) ; if ( ret ) { DHD_ERROR ( ( "%s:<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>code<S2SV_blank>%d\\n" , __FUNCTION__ , ret ) ) ; ret = - 1 ; goto exit ; } } memcpy ( net -> dev_addr , dhd -> pub . mac . octet , ETHER_ADDR_LEN ) ; # ifdef TOE if ( dhd_toe_get ( dhd , ifidx , & toe_ol ) >= 0 && ( toe_ol & TOE_TX_CSUM_OL ) != 0 ) dhd -> iflist [ ifidx ] -> net -> features |= NETIF_F_IP_CSUM ; else dhd -> iflist [ ifidx ] -> net -> features &= ~ NETIF_F_IP_CSUM ; # endif # if defined ( WL_CFG80211 ) <S2SV_StartBug> if ( unlikely ( wl_cfg80211_up ( NULL ) ) ) { <S2SV_EndBug> DHD_ERROR ( ( "%s:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>bring<S2SV_blank>up<S2SV_blank>cfg80211\\n" , __FUNCTION__ ) ) ; ret = - 1 ; goto exit ; } # endif } netif_start_queue ( net ) ; dhd -> pub . up = 1 ; # ifdef BCMDBGFS dhd_dbgfs_init ( & dhd -> pub ) ; # endif OLD_MOD_INC_USE_COUNT ; exit : if ( ret ) dhd_stop ( net ) ; DHD_PERIM_UNLOCK ( & dhd -> pub ) ; DHD_OS_WAKE_UNLOCK ( & dhd -> pub ) ; return ret ; } | <S2SV_ModStart> ( wl_cfg80211_up ( net <S2SV_ModEnd> ) ) ) |
7,039 | CWE-000 void bta_dm_ble_set_rand_address ( tBTA_DM_MSG * p_data ) <S2SV_StartBug> { <S2SV_EndBug> if ( p_data -> set_addr . addr_type != BLE_ADDR_RANDOM ) { APPL_TRACE_ERROR ( "Invalid<S2SV_blank>random<S2SV_blank>adress<S2SV_blank>type<S2SV_blank>=<S2SV_blank>%d\\n" , p_data -> set_addr . addr_type ) ; return ; } <S2SV_StartBug> BTM_BleSetRandAddress ( p_data -> set_addr . address ) ; <S2SV_EndBug> } | <S2SV_ModStart> p_data ) { BOOLEAN set_flag = false ; <S2SV_ModStart> return ; } if ( ( set_flag = <S2SV_ModStart> . address ) != TRUE ) ) { APPL_TRACE_ERROR ( "%s,set<S2SV_blank>random<S2SV_blank>address<S2SV_blank>fail." ) ; } } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
7,040 | CWE-000 void test_the_machine_expect_Nice_to_meet_you_GarbageBoy ( void ) { <S2SV_StartBug> char * Reply = TheMachine ( "My<S2SV_blank>Name<S2SV_blank>is<S2SV_blank>GarbageBoy" ) ; <S2SV_EndBug> <S2SV_StartBug> TEST_ASSERT_EQUAL_STRING ( "Nice<S2SV_blank>to<S2SV_blank>meet<S2SV_blank>you<S2SV_blank>Garbage" , Reply ) ; <S2SV_EndBug> } | <S2SV_ModStart> = TheMachine ( "My<S2SV_blank>Name<S2SV_blank>is<S2SV_blank>Boy" <S2SV_ModEnd> ) ; TEST_ASSERT_EQUAL_STRING <S2SV_ModStart> ; TEST_ASSERT_EQUAL_STRING ( "Nice<S2SV_blank>to<S2SV_blank>meet<S2SV_blank>you<S2SV_blank>Boy" <S2SV_ModEnd> , Reply ) |
7,041 | CWE-000 STATIC void tryexec ( char * cmd , char * * argv , char * * envp ) { <S2SV_StartBug> char * const path_bshell = _PATH_BSHELL ; <S2SV_EndBug> repeat : # ifdef SYSV do { execve ( cmd , argv , envp ) ; } while ( errno == EINTR ) ; # else execve ( cmd , argv , envp ) ; # endif <S2SV_StartBug> if ( cmd != path_bshell && errno == ENOEXEC ) { <S2SV_EndBug> * argv -- = cmd ; * argv = cmd = path_bshell ; goto repeat ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> envp ) { static <S2SV_ModStart> path_bshell = _PATH_BSHELL ; char * save_argv0 = NULL <S2SV_ModStart> endif if ( <S2SV_ModEnd> errno == ENOEXEC <S2SV_ModStart> errno == ENOEXEC && save_argv0 == NULL ) { save_argv0 = * argv ; <S2SV_ModEnd> * argv -- <S2SV_ModStart> repeat ; } if ( save_argv0 != NULL ) { * ++ argv = save_argv0 ; errno = ENOEXEC ; } |
7,042 | CWE-000 static int packet_set_ring ( struct sock * sk , union tpacket_req_u * req_u , int closing , int tx_ring ) { struct pgv * pg_vec = NULL ; struct packet_sock * po = pkt_sk ( sk ) ; int was_running , order = 0 ; struct packet_ring_buffer * rb ; struct sk_buff_head * rb_queue ; __be16 num ; int err = - EINVAL ; struct tpacket_req * req = & req_u -> req ; lock_sock ( sk ) ; if ( ! closing && tx_ring && ( po -> tp_version > TPACKET_V2 ) ) { net_warn_ratelimited ( "Tx-ring<S2SV_blank>is<S2SV_blank>not<S2SV_blank>supported.\\n" ) ; goto out ; } rb = tx_ring ? & po -> tx_ring : & po -> rx_ring ; rb_queue = tx_ring ? & sk -> sk_write_queue : & sk -> sk_receive_queue ; err = - EBUSY ; if ( ! closing ) { if ( atomic_read ( & po -> mapped ) ) goto out ; if ( packet_read_pending ( rb ) ) goto out ; } if ( req -> tp_block_nr ) { err = - EBUSY ; if ( unlikely ( rb -> pg_vec ) ) goto out ; switch ( po -> tp_version ) { case TPACKET_V1 : po -> tp_hdrlen = TPACKET_HDRLEN ; break ; case TPACKET_V2 : po -> tp_hdrlen = TPACKET2_HDRLEN ; break ; case TPACKET_V3 : po -> tp_hdrlen = TPACKET3_HDRLEN ; break ; } err = - EINVAL ; if ( unlikely ( ( int ) req -> tp_block_size <= 0 ) ) goto out ; if ( unlikely ( ! PAGE_ALIGNED ( req -> tp_block_size ) ) ) goto out ; if ( po -> tp_version >= TPACKET_V3 && <S2SV_StartBug> ( int ) ( req -> tp_block_size - <S2SV_EndBug> <S2SV_StartBug> BLK_PLUS_PRIV ( req_u -> req3 . tp_sizeof_priv ) ) <= 0 ) <S2SV_EndBug> goto out ; if ( unlikely ( req -> tp_frame_size < po -> tp_hdrlen + po -> tp_reserve ) ) goto out ; if ( unlikely ( req -> tp_frame_size & ( TPACKET_ALIGNMENT - 1 ) ) ) goto out ; rb -> frames_per_block = req -> tp_block_size / req -> tp_frame_size ; if ( unlikely ( rb -> frames_per_block == 0 ) ) goto out ; if ( unlikely ( ( rb -> frames_per_block * req -> tp_block_nr ) != req -> tp_frame_nr ) ) goto out ; err = - ENOMEM ; order = get_order ( req -> tp_block_size ) ; pg_vec = alloc_pg_vec ( req , order ) ; if ( unlikely ( ! pg_vec ) ) goto out ; switch ( po -> tp_version ) { case TPACKET_V3 : if ( ! tx_ring ) init_prb_bdqc ( po , rb , pg_vec , req_u ) ; break ; default : break ; } } else { err = - EINVAL ; if ( unlikely ( req -> tp_frame_nr ) ) goto out ; } spin_lock ( & po -> bind_lock ) ; was_running = po -> running ; num = po -> num ; if ( was_running ) { po -> num = 0 ; __unregister_prot_hook ( sk , false ) ; } spin_unlock ( & po -> bind_lock ) ; synchronize_net ( ) ; err = - EBUSY ; mutex_lock ( & po -> pg_vec_lock ) ; if ( closing || atomic_read ( & po -> mapped ) == 0 ) { err = 0 ; spin_lock_bh ( & rb_queue -> lock ) ; swap ( rb -> pg_vec , pg_vec ) ; rb -> frame_max = ( req -> tp_frame_nr - 1 ) ; rb -> head = 0 ; rb -> frame_size = req -> tp_frame_size ; spin_unlock_bh ( & rb_queue -> lock ) ; swap ( rb -> pg_vec_order , order ) ; swap ( rb -> pg_vec_len , req -> tp_block_nr ) ; rb -> pg_vec_pages = req -> tp_block_size / PAGE_SIZE ; po -> prot_hook . func = ( po -> rx_ring . pg_vec ) ? tpacket_rcv : packet_rcv ; skb_queue_purge ( rb_queue ) ; if ( atomic_read ( & po -> mapped ) ) pr_err ( "packet_mmap:<S2SV_blank>vma<S2SV_blank>is<S2SV_blank>busy:<S2SV_blank>%d\\n" , atomic_read ( & po -> mapped ) ) ; } mutex_unlock ( & po -> pg_vec_lock ) ; spin_lock ( & po -> bind_lock ) ; if ( was_running ) { po -> num = num ; register_prot_hook ( sk ) ; } spin_unlock ( & po -> bind_lock ) ; if ( closing && ( po -> tp_version > TPACKET_V2 ) ) { if ( ! tx_ring ) prb_shutdown_retire_blk_timer ( po , rb_queue ) ; } if ( pg_vec ) free_pg_vec ( pg_vec , order , req -> tp_block_nr ) ; out : release_sock ( sk ) ; return err ; } | <S2SV_ModStart> >= TPACKET_V3 && <S2SV_ModEnd> req -> tp_block_size <S2SV_ModStart> req -> tp_block_size <= BLK_PLUS_PRIV ( ( u64 ) <S2SV_ModEnd> req_u -> req3 <S2SV_ModStart> tp_sizeof_priv ) ) <S2SV_ModEnd> goto out ; |
7,043 | CWE-000 static Cache * cache_test_create ( ) { CacheCtl cacheCtl ; MemSet ( & cacheCtl , 0 , sizeof ( CacheCtl ) ) ; cacheCtl . entrySize = sizeof ( TestCacheElt ) ; cacheCtl . keySize = TEST_NAME_LENGTH ; cacheCtl . keyOffset = GPDB_OFFSET ( TestCacheElt , key ) ; cacheCtl . hash = string_hash ; <S2SV_StartBug> cacheCtl . keyCopy = ( HashCopyFunc ) strncpy ; <S2SV_EndBug> cacheCtl . match = ( HashCompareFunc ) strncmp ; cacheCtl . cleanupEntry = cacheEltCleanup ; cacheCtl . populateEntry = cacheEltPopulate ; cacheCtl . maxSize = TEST_HT_NUM_ELEMENTS ; cacheCtl . cacheName = "Test<S2SV_blank>Cache" ; cacheCtl . baseLWLockId = FirstWorkfileMgrLock ; cacheCtl . numPartitions = NUM_WORKFILEMGR_PARTITIONS ; Cache * cache = NULL ; cache = Cache_Create ( & cacheCtl ) ; Assert ( cache ) ; RegisterXactCallbackOnce ( Cache_TeardownCallback , cache ) ; return cache ; } | <S2SV_ModStart> ( HashCopyFunc ) strlcpy <S2SV_ModEnd> ; cacheCtl . |
7,044 | CWE-000 int gnupg_pk_is_compliant ( enum gnupg_compliance_mode compliance , int algo , gcry_mpi_t key [ ] , unsigned int keylength , const char * curvename ) { enum { is_rsa , is_dsa , is_pgp5 , is_elg_sign , is_ecc } algotype ; int result = 0 ; if ( ! initialized ) return 0 ; switch ( algo ) { case PUBKEY_ALGO_RSA : case PUBKEY_ALGO_RSA_E : case PUBKEY_ALGO_RSA_S : algotype = is_rsa ; break ; case PUBKEY_ALGO_DSA : algotype = is_dsa ; break ; case PUBKEY_ALGO_ELGAMAL_E : algotype = is_pgp5 ; break ; case PUBKEY_ALGO_ECDH : case PUBKEY_ALGO_ECDSA : case PUBKEY_ALGO_EDDSA : algotype = is_ecc ; break ; case PUBKEY_ALGO_ELGAMAL : algotype = is_elg_sign ; break ; default : return 0 ; } if ( compliance == CO_DE_VS ) { char * curve = NULL ; switch ( algotype ) { case is_pgp5 : result = 0 ; break ; case is_rsa : result = ( keylength == 2048 || keylength == 3072 || keylength == 4096 ) ; break ; case is_dsa : if ( key ) { <S2SV_StartBug> size_t L = gcry_mpi_get_nbits ( key [ 0 ] ) ; <S2SV_EndBug> <S2SV_StartBug> size_t N = gcry_mpi_get_nbits ( key [ 1 ] ) ; <S2SV_EndBug> <S2SV_StartBug> result = ( L == 256 <S2SV_EndBug> <S2SV_StartBug> && ( N == 2048 || N == 3072 ) ) ; <S2SV_EndBug> } break ; case is_ecc : if ( ! curvename && key ) { curve = openpgp_oid_to_str ( key [ 0 ] ) ; curvename = openpgp_oid_to_curve ( curve , 0 ) ; if ( ! curvename ) curvename = curve ; } result = ( curvename <S2SV_StartBug> && algo != PUBKEY_ALGO_EDDSA <S2SV_EndBug> && ( ! strcmp ( curvename , "brainpoolP256r1" ) || ! strcmp ( curvename , "brainpoolP384r1" ) || ! strcmp ( curvename , "brainpoolP512r1" ) ) ) ; break ; default : result = 0 ; } xfree ( curve ) ; } else if ( algotype == is_elg_sign ) { result = ( compliance == CO_RFC2440 ) ; } else { result = 1 ; } return result ; } | <S2SV_ModStart> ) { size_t P <S2SV_ModEnd> = gcry_mpi_get_nbits ( <S2SV_ModStart> ) ; size_t Q <S2SV_ModEnd> = gcry_mpi_get_nbits ( <S2SV_ModStart> result = ( Q <S2SV_ModEnd> == 256 && <S2SV_ModStart> 256 && ( P <S2SV_ModEnd> == 2048 || <S2SV_ModStart> == 2048 || P <S2SV_ModEnd> == 3072 ) <S2SV_ModStart> ( curvename && ( algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA ) <S2SV_ModEnd> && ( ! |
7,045 | CWE-000 void SpscBufferWrite ( SpscRingBuffer * buffer , const char * data , size_t size ) { <S2SV_StartBug> int64 write_loc = my_atomic_load64 ( & buffer -> write_loc ) ; <S2SV_EndBug> int64 read_loc_required = ( write_loc + sizeof ( size ) + size ) % buffer -> buf_size ; while ( SpscBufferDataSize ( buffer ) + size > buffer -> buf_size ) { } write_loc = WrapIfNecessary ( buffer -> buf_size , write_loc , sizeof ( size ) ) ; write_loc = WriteValue ( buffer -> buffer , write_loc , size ) ; write_loc = WrapIfNecessary ( buffer -> buf_size , write_loc , size ) ; memcpy ( buffer -> buffer + write_loc , data , size ) ; my_atomic_store64 ( & buffer -> write_loc , write_loc + size ) ; } | <S2SV_ModStart> -> write_loc ) <S2SV_ModEnd> ; while ( |
7,046 | CWE-000 void free_c ( _PTR p ) { <S2SV_StartBug> _PTR real_block = p - ( sizeof ( size_t ) ) ; <S2SV_EndBug> size_t size ; memcpy ( & size , real_block , sizeof ( size_t ) ) ; if ( size > 10000 ) { Log_Message ( "err" ) ; } size_allocated -= size ; free ( real_block ) ; } | <S2SV_ModStart> p ) { free_ex ( p , pool <S2SV_ModEnd> ) ; } |
7,047 | CWE-000 int ethtool_enable_cluster ( unsigned remoteClus , unsigned if_id , odp_rpc_answer_t * answer ) { const int eth_if = if_id % 4 ; const int noc_if = status [ eth_if ] . cluster [ remoteClus ] . nocIf ; const int tx_id = status [ eth_if ] . cluster [ remoteClus ] . txId ; const eth_cluster_policy_t policy = status [ eth_if ] . cluster [ remoteClus ] . policy ; if ( noc_if < 0 || status [ eth_if ] . cluster [ remoteClus ] . enabled ) { ETH_RPC_ERR_MSG ( answer , "Trying<S2SV_blank>to<S2SV_blank>enable<S2SV_blank>lane<S2SV_blank>%d<S2SV_blank>which<S2SV_blank>is<S2SV_blank>closed<S2SV_blank>or<S2SV_blank>already<S2SV_blank>enabled\\n" , eth_if ) ; return - 1 ; } if ( if_id < 4 && status [ eth_if ] . cluster [ remoteClus ] . opened == ETH_CLUS_STATUS_40G ) { ETH_RPC_ERR_MSG ( answer , "Trying<S2SV_blank>to<S2SV_blank>enable<S2SV_blank>lane<S2SV_blank>%d<S2SV_blank>in<S2SV_blank>1/10G<S2SV_blank>mode<S2SV_blank>while<S2SV_blank>lanes<S2SV_blank>are<S2SV_blank>open<S2SV_blank>in<S2SV_blank>40G<S2SV_blank>mode\\n" , eth_if ) ; return - 1 ; } if ( if_id == 4 && status [ eth_if ] . cluster [ remoteClus ] . opened == ETH_CLUS_STATUS_ON ) { ETH_RPC_ERR_MSG ( answer , "Trying<S2SV_blank>to<S2SV_blank>enable<S2SV_blank>lane<S2SV_blank>%d<S2SV_blank>in<S2SV_blank>40G<S2SV_blank>while<S2SV_blank>lane<S2SV_blank>is<S2SV_blank>open<S2SV_blank>in<S2SV_blank>1/10G<S2SV_blank>mode\\n" , eth_if ) ; return - 1 ; } if ( ! lb_status . loopback ) { enum mppa_eth_mac_ethernet_mode_e link_speed = ethtool_get_mac_speed ( if_id , answer ) ; if ( ( int ) link_speed == - 1 ) return - 1 ; unsigned long long start = __k1_read_dsu_timestamp ( ) ; int up = 0 ; while ( __k1_read_dsu_timestamp ( ) - start < 3ULL * __bsp_frequency ) { if ( ! mppa_eth_utils_mac_poll_state ( eth_if , link_speed ) ) { up = 1 ; break ; } } if ( ! up ) { ETH_RPC_ERR_MSG ( answer , "No<S2SV_blank>carrier<S2SV_blank>on<S2SV_blank>lane<S2SV_blank>%d\\n" , eth_if ) ; return - 1 ; } } status [ eth_if ] . cluster [ remoteClus ] . enabled = 1 ; <S2SV_StartBug> status [ eth_if ] . refcounts . policy [ policy ] ++ ; <S2SV_EndBug> status [ eth_if ] . refcounts . enabled ++ ; if ( ! status [ eth_if ] . cluster [ remoteClus ] . rx_enabled ) return 0 ; switch ( policy ) { case ETH_CLUS_POLICY_HASH : if ( ! status [ eth_if ] . rx_refcounts . policy [ ETH_CLUS_POLICY_HASH ] ) { } status [ eth_if ] . rx_refcounts . policy [ ETH_CLUS_POLICY_HASH ] ++ ; update_lut ( if_id ) ; break ; case ETH_CLUS_POLICY_FALLTHROUGH : if ( ! status [ eth_if ] . rx_refcounts . policy [ ETH_CLUS_POLICY_FALLTHROUGH ] ) { mppabeth_lb_cfg_default_dispatch_policy ( ( void * ) & ( mppa_ethernet [ 0 ] -> lb ) , eth_if , MPPABETHLB_DISPATCH_DEFAULT_POLICY_RR ) ; } status [ eth_if ] . rx_refcounts . policy [ ETH_CLUS_POLICY_FALLTHROUGH ] ++ ; mppabeth_lb_cfg_default_rr_dispatch_channel ( ( void * ) & ( mppa_ethernet [ 0 ] -> lb ) , eth_if , noc_if - ETH_BASE_TX , tx_id , ( 1 << ETH_DEFAULT_CTX ) ) ; break ; case ETH_CLUS_POLICY_MAC_MATCH : if ( ! status [ eth_if ] . rx_refcounts . policy [ ETH_CLUS_POLICY_MAC_MATCH ] ) { <S2SV_StartBug> const uint64_t mac = 0ULL ; <S2SV_EndBug> mppabeth_lb_cfg_rule ( ( void * ) & ( mppa_ethernet [ 0 ] -> lb ) , <S2SV_StartBug> eth_if , ETH_MATCHALL_RULE_ID , <S2SV_EndBug> 0 , 0x3f , h2n_order ( mac , 0x3f ) , 0 ) ; mppabeth_lb_cfg_extract_table_mode ( ( void * ) & ( mppa_ethernet [ 0 ] -> lb ) , <S2SV_StartBug> ETH_MATCHALL_TABLE_ID , 0 , <S2SV_EndBug> MPPABETHLB_DISPATCH_POLICY_RR ) ; } status [ eth_if ] . rx_refcounts . policy [ ETH_CLUS_POLICY_MAC_MATCH ] ++ ; mppabeth_lb_cfg_table_rr_dispatch_channel ( ( void * ) & ( mppa_ethernet [ 0 ] -> lb ) , eth_if , eth_if , noc_if - ETH_BASE_TX , tx_id , ( 1 << ETH_DEFAULT_CTX ) ) ; break ; default : ETH_RPC_ERR_MSG ( answer , "Internal<S2SV_blank>error\\n" ) ; return - 1 ; } status [ eth_if ] . rx_refcounts . enabled ++ ; return 0 ; } | <S2SV_ModStart> . refcounts . <S2SV_ModEnd> enabled ++ ; <S2SV_ModStart> ] ) { ethtool_add_mac_match_entry ( eth_if , ethtool_mac_to_64 ( eth_if ) ) ; mppabeth_lb_cfg_extract_table_mode <S2SV_ModEnd> ( ( void <S2SV_ModStart> lb ) , ETH_MATCHALL_TABLE_ID , 0 , MPPABETHLB_DISPATCH_POLICY_RR ) ; } status [ eth_if ] . rx_refcounts . policy [ ETH_CLUS_POLICY_MAC_MATCH ] ++ ; mppabeth_lb_cfg_table_rr_dispatch_channel <S2SV_ModEnd> ( ( void <S2SV_ModStart> lb ) , <S2SV_ModEnd> eth_if , eth_if |
7,048 | CWE-000 int join_inter_op_l ( int num , int * l ) { int i ; <S2SV_StartBug> int sid = - 1 , eid = - 1 ; <S2SV_EndBug> int eid = inter_op_table [ k [ num - 1 ] ] . op_end ; int s1id , e1id ; for ( i = 0 ; i < num ; i ++ ) { if ( sid == - 1 && inter_op_table [ l [ i ] ] . op_start ) { sid = s1id ; } if ( i != 0 && e1id != - 1 ) eid = inter_op_table [ l [ i - 1 ] ] . op_end ; if ( i != 0 && inter_op_table [ l [ i ] ] . op_start != - 1 ) { inter_op_list [ e1id ] [ 0 ] = inter_op_table [ l [ i ] ] . op_start ; } } return inter_new_op_block ( sid , eid ) ; } | <S2SV_ModStart> = - 1 <S2SV_ModEnd> ; int s1id |
7,049 | CWE-000 static void BinWriteMem ( BinDesc * D , MemoryArea * M ) { unsigned I ; unsigned long Addr = M -> Start ; if ( ftell ( D -> F ) != ( long ) M -> FileOffs ) { Internal ( "Invalid<S2SV_blank>file<S2SV_blank>offset<S2SV_blank>for<S2SV_blank>memory<S2SV_blank>area<S2SV_blank>%s:<S2SV_blank>%ld/%lu" , GetString ( M -> Name ) , ftell ( D -> F ) , M -> FileOffs ) ; } for ( I = 0 ; I < CollCount ( & M -> SegList ) ; ++ I ) { int DoWrite ; SegDesc * S = CollAtUnchecked ( & M -> SegList , I ) ; Print ( stdout , 1 , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Writing<S2SV_blank>`%s\'\\n" , GetString ( S -> Name ) ) ; DoWrite = ( S -> Flags & SF_BSS ) == 0 && S -> Load == M && S -> Seg -> Dumped == 0 ; PrintBoolVal ( "bss" , S -> Flags & SF_BSS ) ; PrintBoolVal ( "LoadArea" , S -> Load == M ) ; PrintBoolVal ( "Dumped" , S -> Seg -> Dumped ) ; PrintBoolVal ( "DoWrite" , DoWrite ) ; PrintNumVal ( "Address" , Addr ) ; PrintNumVal ( "FileOffs" , ( unsigned long ) ftell ( D -> F ) ) ; if ( S -> Run == M ) { if ( S -> Flags & SF_ALIGN ) { unsigned long NewAddr = AlignAddr ( Addr , S -> RunAlignment ) ; if ( DoWrite || ( M -> Flags & MF_FILL ) != 0 ) { WriteMult ( D -> F , M -> FillVal , NewAddr - Addr ) ; PrintNumVal ( "SF_ALIGN" , NewAddr - Addr ) ; } Addr = NewAddr ; } else if ( S -> Flags & ( SF_OFFSET | SF_START ) ) { unsigned long NewAddr = S -> Addr ; if ( S -> Flags & SF_OFFSET ) { NewAddr += M -> Start ; } if ( DoWrite || ( M -> Flags & MF_FILL ) != 0 ) { <S2SV_StartBug> if ( S -> Flags & SF_OVERLAY ) { <S2SV_EndBug> fseek ( D -> F , NewAddr - M -> Start , SEEK_SET ) ; } else { WriteMult ( D -> F , M -> FillVal , NewAddr - Addr ) ; PrintNumVal ( "SF_OFFSET" , NewAddr - Addr ) ; } } Addr = NewAddr ; } } else if ( S -> Load == M ) { if ( S -> Flags & SF_ALIGN_LOAD ) { unsigned long NewAddr = AlignAddr ( Addr , S -> LoadAlignment ) ; if ( DoWrite || ( M -> Flags & MF_FILL ) != 0 ) { WriteMult ( D -> F , M -> FillVal , NewAddr - Addr ) ; PrintNumVal ( "SF_ALIGN_LOAD" , NewAddr - Addr ) ; } Addr = NewAddr ; } } if ( DoWrite ) { unsigned long P = ftell ( D -> F ) ; SegWrite ( D -> Filename , D -> F , S -> Seg , BinWriteExpr , D ) ; PrintNumVal ( "Wrote" , ( unsigned long ) ( ftell ( D -> F ) - P ) ) ; } else if ( M -> Flags & MF_FILL ) { WriteMult ( D -> F , S -> Seg -> FillVal , S -> Seg -> Size ) ; PrintNumVal ( "Filled" , ( unsigned long ) S -> Seg -> Size ) ; } if ( S -> Load == M ) { S -> Seg -> Dumped = 1 ; } Addr += S -> Seg -> Size ; } if ( ( M -> Flags & MF_FILL ) != 0 && M -> FillLevel < M -> Size ) { unsigned long ToFill = M -> Size - M -> FillLevel ; Print ( stdout , 2 , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Filling<S2SV_blank>0x%lx<S2SV_blank>bytes<S2SV_blank>with<S2SV_blank>0x%02x\\n" , ToFill , M -> FillVal ) ; WriteMult ( D -> F , M -> FillVal , ToFill ) ; M -> FillLevel = M -> Size ; } } | <S2SV_ModStart> -> Flags & SF_REPLACE <S2SV_ModEnd> ) { fseek |
7,050 | CWE-000 void gen_load_lvalue ( List * instr_list , AstNode * node ) { assert ( node -> gen == Ast_gen1 ) ; if ( node -> kind == AstNode_var_occur ) { DataArea * link = ATTR ( node , symbol , occur_sym ) -> data_area ; DataArea * data = ATTR ( node , symbol , decl_sym ) -> data_area ; emit_instr_reg ( instr_list , Opcode_PUSH_REG , RegName_FP ) ; if ( link && link -> decl_scope_offset > 0 ) { <S2SV_StartBug> assert ( link -> loc < 0 ) ; <S2SV_EndBug> emit_instr_int32 ( instr_list , Opcode_PUSH_INT32 , link -> loc ) ; emit_instr ( instr_list , Opcode_ADD_INT32 ) ; emit_instr_int32 ( instr_list , Opcode_LOAD , 4 ) ; } <S2SV_StartBug> emit_instr_int32 ( instr_list , Opcode_PUSH_INT32 , data -> loc ) ; <S2SV_EndBug> emit_instr ( instr_list , Opcode_ADD_INT32 ) ; } else if ( node -> kind == AstNode_un_expr ) { AstNode * operand = ATTR ( node , ast_node , operand ) ; OperatorKind un_op = ATTR ( node , op_kind , op_kind ) ; if ( un_op == Operator_deref ) { assert ( ATTR ( operand , type , eval_type ) -> kind == Type_pointer ) ; gen_load_rvalue ( instr_list , operand ) ; } else assert ( 0 ) ; } else if ( node -> kind == AstNode_bin_expr ) { Type * type = ATTR ( node , type , eval_type ) ; AstNode * left_operand = ATTR ( node , ast_node , left_operand ) ; AstNode * right_operand = ATTR ( node , ast_node , right_operand ) ; OperatorKind bin_op = ATTR ( node , op_kind , op_kind ) ; if ( bin_op == Operator_index ) { gen_load_lvalue ( instr_list , left_operand ) ; gen_load_rvalue ( instr_list , right_operand ) ; emit_instr_int32 ( instr_list , Opcode_PUSH_INT32 , type -> width ) ; emit_instr ( instr_list , Opcode_MUL_INT32 ) ; emit_instr ( instr_list , Opcode_ADD_INT32 ) ; } else assert ( 0 ) ; } else assert ( 0 ) ; } | <S2SV_ModStart> 0 ) { int offset = link -> decl_scope_offset ; while ( offset -- > 0 ) { <S2SV_ModStart> ) ; } } |
7,051 | CWE-000 static int krping_setup_buffers ( struct krping_cb * cb ) { int ret ; DEBUG_LOG ( "\\n->%s();\\n" , __func__ ) ; DEBUG_LOG ( PFX "krping_setup_buffers<S2SV_blank>called<S2SV_blank>on<S2SV_blank>cb<S2SV_blank>%p\\n" , cb ) ; cb -> recv_dma_addr = dma_map_single ( cb -> pd -> device -> dma_device , & cb -> recv_buf , sizeof ( cb -> recv_buf ) , DMA_BIDIRECTIONAL ) ; pci_unmap_addr_set ( cb , recv_mapping , cb -> recv_dma_addr ) ; cb -> send_dma_addr = dma_map_single ( cb -> pd -> device -> dma_device , & cb -> send_buf , sizeof ( cb -> send_buf ) , DMA_BIDIRECTIONAL ) ; pci_unmap_addr_set ( cb , send_mapping , cb -> send_dma_addr ) ; cb -> rdma_buf = kmalloc ( cb -> size , GFP_KERNEL ) ; if ( ! cb -> rdma_buf ) { DEBUG_LOG ( PFX "rdma_buf<S2SV_blank>malloc<S2SV_blank>failed\\n" ) ; ret = - ENOMEM ; goto bail ; } DEBUG_LOG ( "@@@<S2SV_blank>cb->rdma_buf<S2SV_blank>=<S2SV_blank>0x%llx<S2SV_blank>Jack\\n" , cb -> rdma_buf ) ; cb -> rdma_dma_addr = dma_map_single ( cb -> pd -> device -> dma_device , cb -> rdma_buf , cb -> size , DMA_BIDIRECTIONAL ) ; pci_unmap_addr_set ( cb , rdma_mapping , cb -> rdma_dma_addr ) ; cb -> page_list_len = ( ( ( cb -> size - 1 ) & PAGE_MASK ) + PAGE_SIZE ) >> PAGE_SHIFT ; cb -> reg_mr = ib_alloc_mr ( cb -> pd , IB_MR_TYPE_MEM_REG , cb -> page_list_len ) ; if ( IS_ERR ( cb -> reg_mr ) ) { ret = PTR_ERR ( cb -> reg_mr ) ; DEBUG_LOG ( PFX "recv_buf<S2SV_blank>reg_mr<S2SV_blank>failed<S2SV_blank>%d\\n" , ret ) ; goto bail ; } DEBUG_LOG ( PFX "@@@<S2SV_blank>reg<S2SV_blank>rkey<S2SV_blank>0x%x<S2SV_blank>page_list_len<S2SV_blank>%u\\n" , cb -> reg_mr -> rkey , cb -> page_list_len ) ; DEBUG_LOG ( PFX "@@@<S2SV_blank>Jack<S2SV_blank>lkey<S2SV_blank>0x%x<S2SV_blank>from<S2SV_blank>mr<S2SV_blank>\\n" , cb -> reg_mr -> lkey ) ; cb -> send_sgl . lkey = cb -> reg_mr -> lkey ; <S2SV_StartBug> cb -> recv_sgl . lkey = cb -> reg_mr -> lkey ; <S2SV_EndBug> if ( ! cb -> server || cb -> wlat || cb -> rlat || cb -> bw ) { cb -> start_buf = kmalloc ( cb -> size , GFP_KERNEL ) ; if ( ! cb -> start_buf ) { DEBUG_LOG ( PFX "start_buf<S2SV_blank>malloc<S2SV_blank>failed\\n" ) ; ret = - ENOMEM ; goto bail ; } cb -> start_dma_addr = dma_map_single ( cb -> pd -> device -> dma_device , cb -> start_buf , cb -> size , DMA_BIDIRECTIONAL ) ; DEBUG_LOG ( "@@@<S2SV_blank>cb->start_dma_addr<S2SV_blank>=<S2SV_blank>0x%llx<S2SV_blank>Jack\\n" , cb -> start_dma_addr ) ; pci_unmap_addr_set ( cb , start_mapping , cb -> start_dma_addr ) ; } krping_setup_wr ( cb ) ; DEBUG_LOG ( PFX "allocated<S2SV_blank>&<S2SV_blank>registered<S2SV_blank>buffers...\\n" ) ; DEBUG_LOG ( "\\n\\n" ) ; return 0 ; bail : if ( cb -> reg_mr && ! IS_ERR ( cb -> reg_mr ) ) ib_dereg_mr ( cb -> reg_mr ) ; if ( cb -> rdma_mr && ! IS_ERR ( cb -> rdma_mr ) ) ib_dereg_mr ( cb -> rdma_mr ) ; if ( cb -> dma_mr && ! IS_ERR ( cb -> dma_mr ) ) ib_dereg_mr ( cb -> dma_mr ) ; if ( cb -> rdma_buf ) kfree ( cb -> rdma_buf ) ; if ( cb -> start_buf ) kfree ( cb -> start_buf ) ; return ret ; } | <S2SV_ModStart> reg_mr -> lkey ; DEBUG_LOG ( PFX "@@@<S2SV_blank>Jack<S2SV_blank>lkey<S2SV_blank>0x%x<S2SV_blank>from<S2SV_blank>mr<S2SV_blank>\\n" , cb -> reg_mr -> lkey ) |
7,052 | CWE-000 int client_rpc_notify ( struct rpc_clnt * rpc , void * mydata , rpc_clnt_event_t event , void * data ) { xlator_t * this = NULL ; char * handshake = NULL ; clnt_conf_t * conf = NULL ; int ret = 0 ; this = mydata ; if ( ! this || ! this -> private ) { gf_msg ( "client" , GF_LOG_ERROR , EINVAL , PC_MSG_INVALID_ENTRY , ( this != NULL ) ? "private<S2SV_blank>structure<S2SV_blank>of<S2SV_blank>the<S2SV_blank>xlator<S2SV_blank>is<S2SV_blank>NULL" : "xlator<S2SV_blank>is<S2SV_blank>NULL" ) ; goto out ; } conf = this -> private ; switch ( event ) { case RPC_CLNT_CONNECT : { conf -> connected = 1 ; gf_msg_debug ( this -> name , 0 , "got<S2SV_blank>RPC_CLNT_CONNECT" ) ; ret = client_handshake ( this , rpc ) ; if ( ret ) gf_msg ( this -> name , GF_LOG_WARNING , 0 , PC_MSG_HANDSHAKE_RETURN , "handshake<S2SV_blank>" "msg<S2SV_blank>returned<S2SV_blank>%d" , ret ) ; pthread_mutex_lock ( & conf -> lock ) ; { conf -> grace_timer_needed = _gf_true ; if ( conf -> grace_timer ) { gf_msg ( this -> name , GF_LOG_WARNING , 0 , PC_MSG_GRACE_TIMER_CANCELLED , "Cancelling<S2SV_blank>the<S2SV_blank>grace<S2SV_blank>timer" ) ; gf_timer_call_cancel ( this -> ctx , conf -> grace_timer ) ; conf -> grace_timer = NULL ; } } pthread_mutex_unlock ( & conf -> lock ) ; break ; } case RPC_CLNT_DISCONNECT : gf_msg_debug ( this -> name , 0 , "got<S2SV_blank>RPC_CLNT_DISCONNECT" ) ; if ( ! conf -> lk_heal ) client_mark_fd_bad ( this ) ; else client_register_grace_timer ( this , conf ) ; if ( ! conf -> skip_notify ) { if ( conf -> connected ) { if ( ! conf -> disconnect_err_logged ) { gf_msg ( this -> name , GF_LOG_INFO , 0 , PC_MSG_CLIENT_DISCONNECTED , "disconnected<S2SV_blank>from<S2SV_blank>%s.<S2SV_blank>Client<S2SV_blank>" "process<S2SV_blank>will<S2SV_blank>keep<S2SV_blank>trying<S2SV_blank>to<S2SV_blank>" "connect<S2SV_blank>to<S2SV_blank>glusterd<S2SV_blank>until<S2SV_blank>" "brick\'s<S2SV_blank>port<S2SV_blank>is<S2SV_blank>available" , conf -> rpc -> conn . name ) ; } else { gf_msg_debug ( this -> name , 0 , "disconnected<S2SV_blank>from<S2SV_blank>%s.<S2SV_blank>" "Client<S2SV_blank>process<S2SV_blank>will<S2SV_blank>keep" "<S2SV_blank>trying<S2SV_blank>to<S2SV_blank>connect<S2SV_blank>to<S2SV_blank>" "glusterd<S2SV_blank>until<S2SV_blank>brick\'s<S2SV_blank>" "port<S2SV_blank>is<S2SV_blank>available" , conf -> rpc -> conn . name ) ; } if ( conf -> portmap_err_logged ) conf -> disconnect_err_logged = 1 ; } ret = client_notify_dispatch_uniq ( this , GF_EVENT_CHILD_DOWN , NULL ) ; if ( ret ) gf_msg ( this -> name , GF_LOG_INFO , 0 , PC_MSG_CHILD_DOWN_NOTIFY_FAILED , "CHILD_DOWN<S2SV_blank>notify<S2SV_blank>failed" ) ; } else { if ( conf -> connected ) gf_msg_debug ( this -> name , 0 , "disconnected<S2SV_blank>(skipped<S2SV_blank>notify)" ) ; } conf -> connected = 0 ; conf -> skip_notify = 0 ; if ( conf -> quick_reconnect ) { conf -> quick_reconnect = 0 ; <S2SV_StartBug> rpc_clnt_start ( rpc ) ; <S2SV_EndBug> } else { rpc -> conn . config . remote_port = 0 ; } break ; case RPC_CLNT_DESTROY : ret = client_fini_complete ( this ) ; break ; default : gf_msg_trace ( this -> name , 0 , "got<S2SV_blank>some<S2SV_blank>other<S2SV_blank>RPC<S2SV_blank>event<S2SV_blank>%d" , event ) ; break ; } out : return 0 ; } | <S2SV_ModStart> = 0 ; rpc_clnt_cleanup_and_start <S2SV_ModEnd> ( rpc ) |
7,053 | CWE-000 void hdd_conn_set_connection_state ( hdd_adapter_t * adapter , eConnectionState conn_state ) { hdd_station_ctx_t * hdd_sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR ( adapter ) ; hdd_context_t * hdd_ctx = WLAN_HDD_GET_CTX ( adapter ) ; char * connect_time ; uint32_t time_buffer_size ; <S2SV_StartBug> hdd_debug ( "%pS<S2SV_blank>Changed<S2SV_blank>conn<S2SV_blank>state<S2SV_blank>from<S2SV_blank>old:%d<S2SV_blank>to<S2SV_blank>new:%d<S2SV_blank>for<S2SV_blank>dev<S2SV_blank>%s" , <S2SV_EndBug> ( void * ) _RET_IP_ , hdd_sta_ctx -> conn_info . connState , conn_state , adapter -> dev -> name ) ; hdd_tsf_notify_wlan_state_change ( adapter , hdd_sta_ctx -> conn_info . connState , conn_state ) ; hdd_sta_ctx -> conn_info . connState = conn_state ; connect_time = hdd_sta_ctx -> conn_info . connect_time ; time_buffer_size = sizeof ( hdd_sta_ctx -> conn_info . connect_time ) ; if ( conn_state == eConnectionState_Associated ) qdf_get_time_of_the_day_in_hr_min_sec_usec ( connect_time , time_buffer_size ) ; else qdf_mem_set ( connect_time , 0x00 , time_buffer_size ) ; if ( conn_state != eConnectionState_NdiConnected ) schedule_delayed_work ( & hdd_ctx -> roc_req_work , 0 ) ; } | <S2SV_ModStart> ; hdd_debug ( "Changed<S2SV_blank>conn<S2SV_blank>state<S2SV_blank>from<S2SV_blank>old:%d<S2SV_blank>to<S2SV_blank>new:%d<S2SV_blank>for<S2SV_blank>dev<S2SV_blank>%s" , <S2SV_ModEnd> hdd_sta_ctx -> conn_info |
7,054 | CWE-000 int readFromDisk ( char * content_buffer , int fd ) { FILE * file = fdopen ( fd , "r" ) ; int bytes_read ; if ( file == NULL ) { <S2SV_StartBug> perror ( "Error<S2SV_blank>opening<S2SV_blank>file" ) <S2SV_EndBug> <S2SV_StartBug> return - 1 <S2SV_EndBug> } <S2SV_StartBug> if ( ( bytes_read = read ( fd , content_buffer , BUFF_SIZE ) ) > 0 ) { <S2SV_EndBug> <S2SV_StartBug> return bytes_read <S2SV_EndBug> } else { <S2SV_StartBug> perror ( "Error<S2SV_blank>reading<S2SV_blank>file" ) <S2SV_EndBug> <S2SV_StartBug> return - 1 <S2SV_EndBug> } } | <S2SV_ModStart> ( "Error<S2SV_blank>opening<S2SV_blank>file" ) ; <S2SV_ModStart> return - 1 ; <S2SV_ModStart> ( bytes_read = fread <S2SV_ModEnd> ( fd , <S2SV_ModStart> { return bytes_read ; <S2SV_ModStart> ( "Error<S2SV_blank>reading<S2SV_blank>file" ) ; <S2SV_ModStart> return - 1 ; |
7,055 | CWE-000 int storage_main ( void * _st ) { routine_t * st = _st ; for ( packet_t * pkt = packets ; pkt ; pkt = pkt -> next ) { if ( pkt -> state == READY ) { DEBUG ( zlog_debug ( st -> tag , "%04llx:<S2SV_blank>POST<S2SV_blank>%.1fkB" , ( unsigned long long ) pkt % 0x10000 , ( float ) pkt -> size / BPKB ) ) ; if ( post ( pkt ) < 0 ) { DEBUG ( zlog_debug ( st -> tag , "Fails" ) ) ; st -> delay = ( st -> delay << 1 ) | ! ( st -> delay << 1 ) ; if ( pkt -> type == METRIC && pkt -> attempt >= 3 ) { pkt -> state = DONE ; } return - 1 ; } else { DEBUG ( zlog_debug ( st -> tag , "Success" ) ) ; st -> delay = 1 ; pkt -> state = DONE ; } st -> tick = STORAGE_TICK * st -> delay ; <S2SV_StartBug> } <S2SV_EndBug> } return 0 ; } | <S2SV_ModStart> delay ; } else if ( pkt -> state == DONE ) { __sync_bool_compare_and_swap ( & pkt -> state , DONE , FREE ) ; } else if ( pkt -> state == FREE ) { } |
7,056 | CWE-000 static int rpcrdma_conn_upcall ( struct rdma_cm_id * id , struct rdma_cm_event * event ) { struct rpcrdma_xprt * xprt = id -> context ; struct rpcrdma_ia * ia = & xprt -> rx_ia ; struct rpcrdma_ep * ep = & xprt -> rx_ep ; int connstate = 0 ; trace_xprtrdma_conn_upcall ( xprt , event ) ; switch ( event -> event ) { case RDMA_CM_EVENT_ADDR_RESOLVED : case RDMA_CM_EVENT_ROUTE_RESOLVED : ia -> ri_async_rc = 0 ; complete ( & ia -> ri_done ) ; break ; case RDMA_CM_EVENT_ADDR_ERROR : <S2SV_StartBug> ia -> ri_async_rc = - EHOSTUNREACH ; <S2SV_EndBug> complete ( & ia -> ri_done ) ; break ; case RDMA_CM_EVENT_ROUTE_ERROR : ia -> ri_async_rc = - ENETUNREACH ; complete ( & ia -> ri_done ) ; break ; case RDMA_CM_EVENT_DEVICE_REMOVAL : # if IS_ENABLED ( CONFIG_SUNRPC_DEBUG ) pr_info ( "rpcrdma:<S2SV_blank>removing<S2SV_blank>device<S2SV_blank>%s<S2SV_blank>for<S2SV_blank>%s:%s\\n" , ia -> ri_device -> name , rpcrdma_addrstr ( xprt ) , rpcrdma_portstr ( xprt ) ) ; # endif set_bit ( RPCRDMA_IAF_REMOVING , & ia -> ri_flags ) ; ep -> rep_connected = - ENODEV ; xprt_force_disconnect ( & xprt -> rx_xprt ) ; wait_for_completion ( & ia -> ri_remove_done ) ; ia -> ri_id = NULL ; ia -> ri_device = NULL ; return 1 ; case RDMA_CM_EVENT_ESTABLISHED : ++ xprt -> rx_xprt . connect_cookie ; connstate = 1 ; rpcrdma_update_connect_private ( xprt , & event -> param . conn ) ; goto connected ; case RDMA_CM_EVENT_CONNECT_ERROR : connstate = - ENOTCONN ; goto connected ; case RDMA_CM_EVENT_UNREACHABLE : <S2SV_StartBug> connstate = - ENETDOWN ; <S2SV_EndBug> goto connected ; case RDMA_CM_EVENT_REJECTED : dprintk ( "rpcrdma:<S2SV_blank>connection<S2SV_blank>to<S2SV_blank>%s:%s<S2SV_blank>rejected:<S2SV_blank>%s\\n" , rpcrdma_addrstr ( xprt ) , rpcrdma_portstr ( xprt ) , rdma_reject_msg ( id , event -> status ) ) ; connstate = - ECONNREFUSED ; if ( event -> status == IB_CM_REJ_STALE_CONN ) connstate = - EAGAIN ; goto connected ; case RDMA_CM_EVENT_DISCONNECTED : ++ xprt -> rx_xprt . connect_cookie ; connstate = - ECONNABORTED ; connected : xprt -> rx_buf . rb_credits = 1 ; ep -> rep_connected = connstate ; rpcrdma_conn_func ( ep ) ; wake_up_all ( & ep -> rep_connect_wait ) ; default : dprintk ( "RPC:<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%s:<S2SV_blank>%s:%s<S2SV_blank>on<S2SV_blank>%s/%s<S2SV_blank>(ep<S2SV_blank>0x%p):<S2SV_blank>%s\\n" , __func__ , rpcrdma_addrstr ( xprt ) , rpcrdma_portstr ( xprt ) , ia -> ri_device -> name , ia -> ri_ops -> ro_displayname , ep , rdma_event_msg ( event -> event ) ) ; break ; } return 0 ; } | <S2SV_ModStart> ri_async_rc = - EPROTO <S2SV_ModEnd> ; complete ( <S2SV_ModStart> connstate = - ENETUNREACH <S2SV_ModEnd> ; goto connected |
7,057 | CWE-000 static void get_home_dir ( char * str , size_t size ) { char * home = os_getenv ( HOME_ENV ) ; if ( home ) { int r = snprintf ( str , size , "%s" , home ) ; if ( r < 0 ) <S2SV_StartBug> RPMEMD_FATAL ( "!snprintf" ) ; <S2SV_EndBug> } else { uid_t uid = getuid ( ) ; struct passwd * pw = getpwuid ( uid ) ; if ( pw == NULL ) RPMEMD_FATAL ( "!getpwuid" ) ; int r = snprintf ( str , size , "%s" , pw -> pw_dir ) ; if ( r < 0 ) <S2SV_StartBug> RPMEMD_FATAL ( "!snprintf" ) ; <S2SV_EndBug> } } | <S2SV_ModStart> ) RPMEMD_FATAL ( "snprintf:<S2SV_blank>%d" , r <S2SV_ModEnd> ) ; } <S2SV_ModStart> ) RPMEMD_FATAL ( "snprintf:<S2SV_blank>%d" , r <S2SV_ModEnd> ) ; } |
7,058 | CWE-000 size_t iotjs_https_curl_read_callback ( void * contents , size_t size , size_t nmemb , void * userp ) { iotjs_https_t * https_data = ( iotjs_https_t * ) userp ; IOTJS_VALIDATED_STRUCT_METHOD ( iotjs_https_t , https_data ) ; printf ( "Entered<S2SV_blank>iotjs_https_curl_read_callback<S2SV_blank>%zu<S2SV_blank>\\n" , _this -> cur_read_index ) ; if ( ! _this -> is_stream_writable ) { _this -> is_stream_writable = true ; iotjs_https_jcallback ( https_data , IOTJS_MAGIC_STRING_ONWRITABLE , iotjs_jargs_get_empty ( ) ) ; printf ( "Made<S2SV_blank>Stream<S2SV_blank>Writeable!!!<S2SV_blank>\\n" ) ; } if ( _this -> data_to_read ) { size_t real_size = size * nmemb ; size_t chunk_size = iotjs_string_size ( & ( _this -> read_chunk ) ) ; size_t left_to_copy_size = chunk_size - _this -> cur_read_index ; if ( real_size < 1 ) return 0 ; if ( _this -> cur_read_index < chunk_size ) { size_t num_to_copy = ( left_to_copy_size < real_size ) ? left_to_copy_size : real_size ; printf ( "in<S2SV_blank>iotjs_https_curl_read_callback<S2SV_blank>%zu<S2SV_blank><S2SV_blank>\\n" , _this -> cur_read_index ) ; const char * buf = iotjs_string_data ( & ( _this -> read_chunk ) ) ; buf = & buf [ _this -> cur_read_index ] ; strncpy ( ( char * ) contents , buf , num_to_copy ) ; _this -> cur_read_index = _this -> cur_read_index + num_to_copy ; printf ( "*****************<S2SV_blank>Wrote<S2SV_blank>%zu<S2SV_blank>bytes<S2SV_blank>of<S2SV_blank>data<S2SV_blank>******************\\n" , num_to_copy ) ; return num_to_copy ; } _this -> cur_read_index = 0 ; _this -> data_to_read = false ; <S2SV_StartBug> iotjs_string_destroy ( & ( _this -> read_chunk ) ) ; <S2SV_EndBug> iotjs_https_call_read_onwrite_async ( https_data ) ; } if ( ! _this -> stream_ended ) { printf ( "Pausing<S2SV_blank>Read<S2SV_blank>\\n" ) ; return CURL_READFUNC_PAUSE ; } <S2SV_StartBug> printf ( "Exiting<S2SV_blank>iotjs_https_curl_read_callback<S2SV_blank>Finally\\n\\n" ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> = false ; printf ( "about<S2SV_blank>to<S2SV_blank>destroy<S2SV_blank>read_chunk<S2SV_blank>\\n" ) ; <S2SV_ModStart> CURL_READFUNC_PAUSE ; } if ( _this -> to_destroy_read_onwrite ) { _this -> to_destroy_read_onwrite = false ; iotjs_jval_destroy ( & ( _this -> read_onwrite ) ) ; iotjs_jval_destroy ( & ( _this -> read_callback ) ) ; } |
7,059 | CWE-000 int multinet_bridgeUpInst ( int l2netInst , int bFirewallRestart ) { <S2SV_StartBug> L2Net l2net ; <S2SV_EndBug> if ( ! ep_netIsStarted ( l2netInst ) ) { MNET_DEBUG ( "Found<S2SV_blank>%d<S2SV_blank>is<S2SV_blank>not<S2SV_blank>started.<S2SV_blank>Starting.\\n" COMMA l2netInst ) nv_get_bridge ( l2netInst , & l2net ) ; MNET_DEBUG ( "nv<S2SV_blank>fetch<S2SV_blank>complete<S2SV_blank>for<S2SV_blank>%d.<S2SV_blank>Name:<S2SV_blank>%s,<S2SV_blank>Vid:<S2SV_blank>%d\\n" COMMA l2netInst COMMA l2net . name COMMA l2net . vid ) multinet_bridgeUp ( & l2net , bFirewallRestart ) ; MNET_DEBUG ( "multinet_bridgeUp<S2SV_blank>for<S2SV_blank>%d<S2SV_blank>complete.<S2SV_blank>\\n" COMMA l2netInst ) if ( 2 == l2netInst ) { MNET_DEBUG ( "brlan1<S2SV_blank>case<S2SV_blank>creating<S2SV_blank>%s<S2SV_blank>file<S2SV_blank>\\n" COMMA LOCAL_BRLAN1UP_FILE ) <S2SV_StartBug> if ( creat ( LOCAL_BRLAN1UP_FILE , S_IRUSR | S_IWUSR ) == - 1 ) <S2SV_EndBug> { MNET_DEBUG ( "%s<S2SV_blank>file<S2SV_blank>creation<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>error:%d\\n" COMMA LOCAL_BRLAN1UP_FILE COMMA errno ) } else { <S2SV_StartBug> MNET_DEBUG ( "%s<S2SV_blank>file<S2SV_blank>creation<S2SV_blank>is<S2SV_blank>successful<S2SV_blank>\\n" COMMA LOCAL_BRLAN1UP_FILE ) <S2SV_EndBug> } } # if defined ( MOCA_HOME_ISOLATION ) if ( 9 == l2netInst ) { ConfigureMoCABridge ( l2net ) ; MNET_DEBUG ( "MoCA<S2SV_blank>Bridge<S2SV_blank>case<S2SV_blank>creating<S2SV_blank>%s<S2SV_blank>file<S2SV_blank>\\n" COMMA LOCAL_MOCABR_UP_FILE ) if ( creat ( LOCAL_MOCABR_UP_FILE , S_IRUSR | S_IWUSR ) == - 1 ) { MNET_DEBUG ( "%s<S2SV_blank>file<S2SV_blank>creation<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>error:%d\\n" COMMA LOCAL_MOCABR_UP_FILE COMMA errno ) } else { MNET_DEBUG ( "%s<S2SV_blank>file<S2SV_blank>creation<S2SV_blank>is<S2SV_blank>successful<S2SV_blank>\\n" COMMA LOCAL_MOCABR_UP_FILE ) } } # endif } return 0 ; } | <S2SV_ModStart> { L2Net l2net ; int fd = 0 ; memset ( & l2net , 0 , sizeof ( l2net ) ) <S2SV_ModStart> ) if ( ( fd = <S2SV_ModStart> | S_IWUSR ) ) <S2SV_ModStart> COMMA LOCAL_BRLAN1UP_FILE ) close ( fd ) ; |
7,060 | CWE-000 void * cleanup_scanned_list ( void * param ) { struct List_Entry * list_pointers , * save_list_pointers ; ScannedDevice * temp ; bool is_empty = false ; # ifdef Debugging zlog_debug ( category_debug , ">><S2SV_blank>cleanup_scanned_list<S2SV_blank>" ) ; # endif while ( true == ready_to_work ) { pthread_mutex_lock ( & exec_lock ) ; while ( true != reach_cln_scanned_list ) { pthread_cond_wait ( & cond_cln_scanned_list , & exec_lock ) ; } reach_cln_scanned_list = false ; pthread_mutex_unlock ( & exec_lock ) ; # ifdef Debugging zlog_debug ( category_debug , "cleanup<S2SV_blank>scanned<S2SV_blank>list<S2SV_blank>in<S2SV_blank>cleanup_scanned_list<S2SV_blank>function" ) ; # endif pthread_mutex_lock ( & list_lock ) ; if ( false == is_entry_list_empty ( & scanned_list_head . list_entry ) ) { list_for_each_safe ( list_pointers , save_list_pointers , & scanned_list_head . list_entry ) { temp = ListEntry ( list_pointers , ScannedDevice , sc_list_entry ) ; if ( get_system_time ( ) - temp -> initial_scanned_time > INTERVAL_HANDLE_SCANNED_LIST_IN_SEC ) { remove_list_node ( & temp -> sc_list_entry ) ; if ( is_isolated_node ( & temp -> tr_list_entry ) ) { mp_free ( & mempool , temp ) ; } } } } pthread_mutex_unlock ( & list_lock ) ; <S2SV_StartBug> } <S2SV_EndBug> # ifdef Debugging zlog_debug ( category_debug , "<<<S2SV_blank>cleanup_scanned_list<S2SV_blank>" ) ; # endif } | <S2SV_ModStart> list_lock ) ; cln_scanned_list_last_time = get_system_time ( ) ; |
7,061 | CWE-000 <S2SV_StartBug> printpt ( const char * format , ... ) { <S2SV_EndBug> char buf [ 256 ] ; va_list args ; va_start ( args , format ) ; vsprintf ( buf , format , args ) ; setproctitle ( buf ) ; va_end ( args ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> void |
7,062 | CWE-000 static inline VALUE invoke_iseq_block_from_c ( rb_execution_context_t * ec , const struct rb_captured_block * captured , VALUE self , int argc , const VALUE * argv , VALUE passed_block_handler , <S2SV_StartBug> const rb_cref_t * cref , int is_lambda ) <S2SV_EndBug> { const rb_iseq_t * iseq = rb_iseq_check ( captured -> code . iseq ) ; int i , opt_pc ; VALUE type = VM_FRAME_MAGIC_BLOCK | ( is_lambda ? VM_FRAME_FLAG_LAMBDA : 0 ) ; rb_control_frame_t * cfp = ec -> cfp ; VALUE * sp = cfp -> sp ; <S2SV_StartBug> const rb_callable_method_entry_t * me = ec -> passed_bmethod_me ; <S2SV_EndBug> ec -> passed_bmethod_me = NULL ; stack_check ( ec ) ; CHECK_VM_STACK_OVERFLOW ( cfp , argc ) ; cfp -> sp = sp + argc ; for ( i = 0 ; i < argc ; i ++ ) { sp [ i ] = argv [ i ] ; } opt_pc = vm_yield_setup_args ( ec , iseq , argc , sp , passed_block_handler , ( is_lambda ? arg_setup_method : arg_setup_block ) ) ; cfp -> sp = sp ; if ( me == NULL ) { return invoke_block ( ec , iseq , self , captured , cref , type , opt_pc ) ; } else { return invoke_bmethod ( ec , iseq , self , captured , me , type , opt_pc ) ; } } | <S2SV_ModStart> , int is_lambda , const rb_callable_method_entry_t * me <S2SV_ModStart> -> sp ; <S2SV_ModEnd> stack_check ( ec |
7,063 | CWE-000 void * omrvmem_reserve_memory_ex ( struct OMRPortLibrary * portLibrary , struct J9PortVmemIdentifier * identifier , struct J9PortVmemParams * params ) { void * memoryPointer = NULL ; OMRMemCategory * category = omrmem_get_category ( portLibrary , params -> category ) ; Trc_PRT_vmem_omrvmem_reserve_memory_Entry_replacement ( params -> startAddress , params -> byteAmount , params -> pageSize ) ; Assert_PRT_true ( params -> startAddress <= params -> endAddress ) ; ASSERT_VALUE_IS_PAGE_SIZE_ALIGNED ( params -> byteAmount , params -> pageSize ) ; if ( 0 == params -> pageSize ) { update_vmemIdentifier ( identifier , NULL , NULL , 0 , 0 , 0 , 0 , 0 , NULL ) ; Trc_PRT_vmem_omrvmem_reserve_memory_invalid_input ( ) ; } else if ( PPG_vmem_pageSize [ 0 ] == params -> pageSize ) { uintptr_t alignmentInBytes = OMR_MAX ( params -> pageSize , params -> alignmentInBytes ) ; uintptr_t minimumGranule = OMR_MIN ( params -> pageSize , params -> alignmentInBytes ) ; if ( ( 0 == minimumGranule ) || ( 0 == ( alignmentInBytes % minimumGranule ) ) ) { memoryPointer = getMemoryInRangeForDefaultPages ( portLibrary , identifier , category , params -> byteAmount , params -> startAddress , params -> endAddress , alignmentInBytes , params -> options , params -> mode ) ; } } else if ( PPG_vmem_pageSize [ 1 ] == params -> pageSize ) { uintptr_t largePageAlignmentInBytes = OMR_MAX ( params -> pageSize , params -> alignmentInBytes ) ; uintptr_t largePageMinimumGranule = OMR_MIN ( params -> pageSize , params -> alignmentInBytes ) ; if ( ( 0 == largePageMinimumGranule ) || ( 0 == ( largePageAlignmentInBytes % largePageMinimumGranule ) ) ) { memoryPointer = reserveLargePages ( portLibrary , identifier , category , params -> byteAmount , params -> startAddress , params -> endAddress , params -> pageSize , largePageAlignmentInBytes , params -> options , params -> mode ) ; } if ( NULL == memoryPointer ) { if ( 0 == ( OMRPORT_VMEM_STRICT_PAGE_SIZE & params -> options ) ) { # if defined ( OMRVMEM_DEBUG ) <S2SV_StartBug> printf ( "\\t\\t\\t<S2SV_blank>NULL<S2SV_blank>==<S2SV_blank>memoryPointer,<S2SV_blank>reverting<S2SV_blank>to<S2SV_blank>default<S2SV_blank>pages\\n" ) ; <S2SV_EndBug> fflush ( stdout ) ; # endif uintptr_t defaultPageSize = PPG_vmem_pageSize [ 0 ] ; uintptr_t alignmentInBytes = OMR_MAX ( defaultPageSize , params -> alignmentInBytes ) ; uintptr_t minimumGranule = OMR_MIN ( defaultPageSize , params -> alignmentInBytes ) ; if ( ( 0 == minimumGranule ) || ( 0 == ( alignmentInBytes % minimumGranule ) ) ) { memoryPointer = getMemoryInRangeForDefaultPages ( portLibrary , identifier , category , params -> byteAmount , params -> startAddress , params -> endAddress , alignmentInBytes , params -> options , params -> mode ) ; } } else { update_vmemIdentifier ( identifier , NULL , NULL , 0 , 0 , 0 , 0 , 0 , NULL ) ; } } } else { update_vmemIdentifier ( identifier , NULL , NULL , 0 , 0 , 0 , 0 , 0 , NULL ) ; Trc_PRT_vmem_omrvmem_reserve_memory_unsupported_page_size ( params -> pageSize ) ; } # if defined ( OMR_PORT_NUMA_SUPPORT ) if ( NULL != memoryPointer ) { port_numa_interleave_memory ( portLibrary , memoryPointer , params -> byteAmount ) ; } # endif # if defined ( OMRVMEM_DEBUG ) printf ( "\\tomrvmem_reserve_memory_ex<S2SV_blank>returning<S2SV_blank>%p\\n" , memoryPointer ) ; fflush ( stdout ) ; # endif Trc_PRT_vmem_omrvmem_reserve_memory_Exit_replacement ( memoryPointer , params -> startAddress ) ; return memoryPointer ; } | <S2SV_ModStart> ) printf ( "\\t\\t\\tNULL<S2SV_blank>==<S2SV_blank>memoryPointer,<S2SV_blank>reverting<S2SV_blank>to<S2SV_blank>default<S2SV_blank>pages\\n" <S2SV_ModEnd> ) ; fflush |
7,064 | CWE-000 void itemdb_reload ( void ) { struct s_mapiterator * iter ; struct map_session_data * sd ; itemdb_group -> clear ( itemdb_group , itemdb_group_free ) ; itemdb_randomopt -> clear ( itemdb_randomopt , itemdb_randomopt_free ) ; <S2SV_StartBug> itemdb -> clear ( itemdb , itemdb_final_sub ) ; <S2SV_EndBug> db_clear ( itemdb_combo ) ; if ( battle_config . feature_roulette ) itemdb_roulette_free ( ) ; itemdb_read ( ) ; cashshop_reloaddb ( ) ; if ( battle_config . feature_roulette ) itemdb_parse_roulette_db ( ) ; itemdb_reload_itemmob_data ( ) ; iter = mapit_geteachpc ( ) ; for ( sd = ( struct map_session_data * ) mapit_first ( iter ) ; mapit_exists ( iter ) ; sd = ( struct map_session_data * ) mapit_next ( iter ) ) { memset ( sd -> item_delay , 0 , sizeof ( sd -> item_delay ) ) ; pc_setinventorydata ( sd ) ; pc_check_available_item ( sd , ITMCHK_ALL ) ; if ( sd -> combos . count ) { aFree ( sd -> combos . bonus ) ; aFree ( sd -> combos . id ) ; aFree ( sd -> combos . pos ) ; sd -> combos . bonus = NULL ; sd -> combos . id = NULL ; sd -> combos . pos = NULL ; sd -> combos . count = 0 ; if ( pc_load_combo ( sd ) > 0 ) status_calc_pc ( sd , SCO_FORCE ) ; } } mapit_free ( iter ) ; } | <S2SV_ModStart> itemdb_randomopt_free ) ; itemdb_randomopt_group -> clear ( itemdb_randomopt_group , itemdb_randomopt_group_free ) ; |
7,065 | CWE-000 iERR ion_timestamp_set_local_offset ( ION_TIMESTAMP * ptime , int offset_minutes ) { iENTER ; if ( ! ptime ) FAILWITH ( IERR_INVALID_ARG ) ; if ( offset_minutes <= - 24 * 60 ) FAILWITH ( IERR_INVALID_ARG ) ; if ( offset_minutes >= 24 * 60 ) FAILWITH ( IERR_INVALID_ARG ) ; <S2SV_StartBug> SET_FLAG_ON ( ptime -> precision , ION_TT_BIT_TZ ) ; <S2SV_EndBug> ptime -> tz_offset = offset_minutes ; <S2SV_StartBug> iRETURN ; <S2SV_EndBug> } | <S2SV_ModStart> IERR_INVALID_ARG ) ; if ( IS_FLAG_ON ( ptime -> precision , ION_TT_BIT_MIN ) ) { <S2SV_ModStart> = offset_minutes ; } |
7,066 | CWE-000 static void pci_restore_config_space_range ( struct pci_dev * pdev , <S2SV_StartBug> int start , int end , int retry ) <S2SV_EndBug> { int index ; for ( index = end ; index >= start ; index -- ) pci_restore_config_dword ( pdev , 4 * index , pdev -> saved_config_space [ index ] , <S2SV_StartBug> retry ) ; <S2SV_EndBug> } | <S2SV_ModStart> , int retry , bool force <S2SV_ModStart> ] , retry , force |
7,067 | CWE-000 void receive_master_data_packet ( logg_data_packet_t * logg_data_packet ) { uint8_t i ; <S2SV_StartBug> spi_tx ( CMD_SEND_LOGGING_DATA ) ; <S2SV_EndBug> for ( i = 0 ; i < 4 ; i ++ ) { <S2SV_StartBug> logg_data_packet -> roll . bytes [ i ] = spi_trx ( 0x00 ) ; <S2SV_EndBug> } for ( i = 0 ; i < 4 ; i ++ ) { <S2SV_StartBug> logg_data_packet -> pitch . bytes [ i ] = spi_trx ( 0x00 ) ; <S2SV_EndBug> } for ( i = 0 ; i < 4 ; i ++ ) { <S2SV_StartBug> logg_data_packet -> yaw_vel . bytes [ i ] = spi_trx ( 0x00 ) ; <S2SV_EndBug> } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> spi_tx ( CMD_SEND_LOGGING_DATA ) ; _delay_us ( 5 <S2SV_ModStart> spi_trx ( 0x00 + i ) ; _delay_us ( 5 <S2SV_ModStart> = spi_trx ( 0x04 + i ) ; _delay_us ( 5 <S2SV_ModEnd> ) ; } <S2SV_ModStart> = spi_trx ( 0x08 + i ) ; _delay_us ( 5 <S2SV_ModEnd> ) ; } <S2SV_ModStart> ) ; } printf ( "Roll:<S2SV_blank>%d,<S2SV_blank>Pitch:<S2SV_blank>%d,<S2SV_blank>Yaw<S2SV_blank>velocity:<S2SV_blank>%d\\n" , ( int ) logg_data_packet -> roll . value , ( int ) logg_data_packet -> pitch . value , ( int ) logg_data_packet -> yaw_vel . value ) ; |
7,068 | CWE-000 static void zend_begin_func_decl ( znode * result , zend_op_array * op_array , zend_ast_decl * decl ) { zend_ast * params_ast = decl -> child [ 0 ] ; zend_string * name = decl -> name , * lcname ; zend_op * opline ; op_array -> function_name = name = zend_prefix_with_ns ( name ) ; lcname = zend_string_tolower ( name ) ; if ( FC ( imports_function ) ) { zend_string * import_name = zend_hash_find_ptr ( FC ( imports_function ) , lcname ) ; if ( import_name && ! zend_string_equals_ci ( lcname , import_name ) ) { zend_error_noreturn ( E_COMPILE_ERROR , "Cannot<S2SV_blank>declare<S2SV_blank>function<S2SV_blank>%s<S2SV_blank>" "because<S2SV_blank>the<S2SV_blank>name<S2SV_blank>is<S2SV_blank>already<S2SV_blank>in<S2SV_blank>use" , ZSTR_VAL ( name ) ) ; } } if ( zend_string_equals_literal ( lcname , ZEND_AUTOLOAD_FUNC_NAME ) && zend_ast_get_list ( params_ast ) -> children != 1 ) { zend_error_noreturn ( E_COMPILE_ERROR , "%s()<S2SV_blank>must<S2SV_blank>take<S2SV_blank>exactly<S2SV_blank>1<S2SV_blank>argument" , ZEND_AUTOLOAD_FUNC_NAME ) ; } if ( op_array -> fn_flags & ZEND_ACC_CLOSURE ) { opline = zend_emit_op_tmp ( result , ZEND_DECLARE_LAMBDA_FUNCTION , NULL , NULL ) ; } else { opline = get_next_op ( CG ( active_op_array ) ) ; opline -> opcode = ZEND_DECLARE_FUNCTION ; opline -> op2_type = IS_CONST ; LITERAL_STR ( opline -> op2 , zend_string_copy ( lcname ) ) ; } { <S2SV_StartBug> zend_string * key = zend_build_runtime_definition_key ( lcname , decl -> lex_pos ) ; <S2SV_EndBug> opline -> op1_type = IS_CONST ; LITERAL_STR ( opline -> op1 , key ) ; zend_hash_update_ptr ( CG ( function_table ) , key , op_array ) ; } zend_string_release ( lcname ) ; } | <S2SV_ModStart> = zend_build_runtime_definition_key ( CG ( function_table ) , |
7,069 | CWE-000 _public_ int sd_bus_emit_signal ( sd_bus * bus , const char * path , const char * interface , const char * member , const char * types , ... ) { _cleanup_ ( sd_bus_message_unrefp ) sd_bus_message * m = NULL ; int r ; <S2SV_StartBug> assert_return ( bus , - EINVAL ) ; <S2SV_EndBug> assert_return ( ! bus_pid_changed ( bus ) , - ECHILD ) ; if ( ! BUS_IS_OPEN ( bus -> state ) ) return - ENOTCONN ; r = sd_bus_message_new_signal ( bus , & m , path , interface , member ) ; if ( r < 0 ) return r ; if ( ! isempty ( types ) ) { va_list ap ; va_start ( ap , types ) ; r = sd_bus_message_appendv ( m , types , ap ) ; va_end ( ap ) ; if ( r < 0 ) return r ; } return sd_bus_send ( bus , m , NULL ) ; } | <S2SV_ModStart> int r ; bus_ensure <S2SV_ModEnd> ( bus , |
7,070 | CWE-000 <S2SV_StartBug> bool pdb_set_group_sid_from_rid ( struct samu * sampass , uint32 grid , enum pdb_value_state flag ) <S2SV_EndBug> { struct dom_sid g_sid ; const struct dom_sid * global_sam_sid ; if ( ! sampass ) return False ; if ( ! ( global_sam_sid = get_global_sam_sid ( ) ) ) { DEBUG ( 1 , ( "pdb_set_user_sid_from_rid:<S2SV_blank>Could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>global<S2SV_blank>sam<S2SV_blank>sid!\\n" ) ) ; return False ; } if ( ! sid_compose ( & g_sid , global_sam_sid , grid ) ) { return False ; } if ( ! pdb_set_group_sid ( sampass , & g_sid , flag ) ) return False ; DEBUG ( 10 , ( "pdb_set_group_sid_from_rid:\\n\\tsetting<S2SV_blank>group<S2SV_blank>sid<S2SV_blank>%s<S2SV_blank>from<S2SV_blank>rid<S2SV_blank>%d\\n" , sid_string_dbg ( & g_sid ) , grid ) ) ; return True ; } | <S2SV_ModStart> * sampass , uint32_t <S2SV_ModEnd> grid , enum |
7,071 | CWE-000 static sqInt genPrimitiveAsFloat ( void ) { <S2SV_StartBug> AbstractInstruction * jumpFailAlloc ; <S2SV_EndBug> genoperandoperand ( MoveRR , ReceiverResultReg , TempReg ) ; genConvertSmallIntegerToIntegerInReg ( TempReg ) ; genoperandoperand ( ConvertRRd , TempReg , DPFPReg0 ) ; jumpFailAlloc = genAllocFloatValueintoscratchRegscratchReg ( DPFPReg0 , SendNumArgsReg , ClassReg , TempReg ) ; genoperandoperand ( MoveRR , SendNumArgsReg , ReceiverResultReg ) ; assert ( methodOrBlockNumArgs <= ( numRegArgs ( ) ) ) ; genoperand ( RetN , 0 ) ; jmpTarget ( jumpFailAlloc , gLabel ( ) ) ; return 0 ; } | <S2SV_ModStart> AbstractInstruction * jumpFailAlloc ; |
7,072 | CWE-000 bool analyze_requires_snapshot ( Node * parseTree ) { <S2SV_StartBug> bool result ; <S2SV_EndBug> if ( parseTree == NULL ) return false ; switch ( nodeTag ( parseTree ) ) { case T_InsertStmt : case T_DeleteStmt : case T_UpdateStmt : case T_SelectStmt : result = true ; break ; case T_DeclareCursorStmt : result = true ; break ; case T_ExplainStmt : case T_CreateTableAsStmt : result = true ; break ; default : result = false ; break ; } return result ; } | <S2SV_ModStart> { bool result <S2SV_ModEnd> ; switch ( |
7,073 | CWE-000 void iperf_check_throttle ( struct iperf_stream * sp , struct timeval * nowP ) { double seconds ; uint64_t bits_per_second ; if ( sp -> test -> done ) return ; <S2SV_StartBug> seconds = timeval_diff ( & sp -> result -> start_time , nowP ) ; <S2SV_EndBug> bits_per_second = sp -> result -> bytes_sent * 8 / seconds ; if ( bits_per_second < sp -> test -> settings -> rate ) { sp -> green_light = 1 ; FD_SET ( sp -> socket , & sp -> test -> write_set ) ; } else { sp -> green_light = 0 ; FD_CLR ( sp -> socket , & sp -> test -> write_set ) ; } } | <S2SV_ModStart> -> result -> start_time_fixed <S2SV_ModEnd> , nowP ) |
7,074 | CWE-000 SEXP ccf_score_graph_wrapper ( SEXP Graph , SEXP Df , SEXP ScoreType , SEXP Dims ) { int * edges = calculate_edges_ptr ( Graph ) ; int n_nodes = length ( VECTOR_ELT ( Graph , NODES ) ) ; int n_edges = nrows ( VECTOR_ELT ( Graph , EDGES ) ) ; cgraph_ptr cg_ptr = create_cgraph ( n_nodes ) ; fill_in_cgraph ( cg_ptr , n_edges , edges ) ; free ( edges ) ; <S2SV_StartBug> int n_var = ncols ( Df ) ; <S2SV_EndBug> <S2SV_StartBug> int n_obs = nrows ( Df ) ; <S2SV_EndBug> int * dims = INTEGER ( Dims ) ; void * * df = malloc ( n_var * sizeof ( void * ) ) ; for ( int i = 0 ; i < n_var ; ++ i ) { if ( dims [ i ] ) df [ i ] = INTEGER ( VECTOR_ELT ( Df , i ) ) ; else df [ i ] = REAL ( VECTOR_ELT ( Df , i ) ) ; } double ( * score_fp ) ( void * * , int * dims , int n_par , int n_obs ) ; <S2SV_StartBug> if ( ! strcmp ( CHAR ( ScoreType ) , BIC_SCORE ) ) <S2SV_EndBug> score_fp = bic_score ; <S2SV_StartBug> else if ( ! strcmp ( CHAR ( ScoreType ) , BDEU_SCORE ) ) <S2SV_EndBug> <S2SV_StartBug> score_fp = bdue_score ; <S2SV_EndBug> else error ( "nope\\n" ) ; <S2SV_StartBug> double score = score_graph ( cg_ptr , df , dims , n_obs , score_fp ) ; <S2SV_EndBug> <S2SV_StartBug> free ( df ) ; <S2SV_EndBug> free_cgraph ( cg_ptr ) ; return ( ScalarReal ( score ) ) ; } | <S2SV_ModStart> int n_var = length <S2SV_ModEnd> ( Df ) <S2SV_ModStart> int n_obs = length ( VECTOR_ELT ( Df , 0 ) <S2SV_ModEnd> ) ; int <S2SV_ModStart> ( CHAR ( STRING_ELT ( ScoreType , 0 ) <S2SV_ModEnd> ) , BIC_SCORE <S2SV_ModStart> ( CHAR ( STRING_ELT ( ScoreType , 0 ) <S2SV_ModEnd> ) , BDEU_SCORE <S2SV_ModStart> ) score_fp = bdeu_score <S2SV_ModEnd> ; else error <S2SV_ModStart> "nope\\n" ) ; TIME_FUNC ( score_timer , <S2SV_ModStart> score_fp ) ; ) ; PRINT_TIMER ( score_timer ) ; |
7,075 | CWE-000 static int meson_drv_bind_master ( struct device * dev , bool has_components ) { struct platform_device * pdev = to_platform_device ( dev ) ; struct meson_drm * priv ; struct drm_device * drm ; struct resource * res ; void __iomem * regs ; int ret ; if ( ! meson_vpu_has_available_connectors ( dev ) ) { dev_err ( dev , "No<S2SV_blank>output<S2SV_blank>connector<S2SV_blank>available\\n" ) ; return - ENODEV ; } drm = drm_dev_alloc ( & meson_driver , dev ) ; if ( IS_ERR ( drm ) ) return PTR_ERR ( drm ) ; priv = devm_kzalloc ( dev , sizeof ( * priv ) , GFP_KERNEL ) ; if ( ! priv ) { ret = - ENOMEM ; goto free_drm ; } drm -> dev_private = priv ; priv -> drm = drm ; priv -> dev = dev ; res = platform_get_resource_byname ( pdev , IORESOURCE_MEM , "vpu" ) ; regs = devm_ioremap_resource ( dev , res ) ; if ( IS_ERR ( regs ) ) return PTR_ERR ( regs ) ; priv -> io_base = regs ; res = platform_get_resource_byname ( pdev , IORESOURCE_MEM , "hhi" ) ; regs = devm_ioremap ( dev , res -> start , resource_size ( res ) ) ; if ( ! regs ) return - EADDRNOTAVAIL ; priv -> hhi = devm_regmap_init_mmio ( dev , regs , & meson_regmap_config ) ; if ( IS_ERR ( priv -> hhi ) ) { dev_err ( & pdev -> dev , "Couldn\'t<S2SV_blank>create<S2SV_blank>the<S2SV_blank>HHI<S2SV_blank>regmap\\n" ) ; return PTR_ERR ( priv -> hhi ) ; } res = platform_get_resource_byname ( pdev , IORESOURCE_MEM , "dmc" ) ; regs = devm_ioremap ( dev , res -> start , resource_size ( res ) ) ; if ( ! regs ) return - EADDRNOTAVAIL ; priv -> dmc = devm_regmap_init_mmio ( dev , regs , & meson_regmap_config ) ; if ( IS_ERR ( priv -> dmc ) ) { dev_err ( & pdev -> dev , "Couldn\'t<S2SV_blank>create<S2SV_blank>the<S2SV_blank>DMC<S2SV_blank>regmap\\n" ) ; return PTR_ERR ( priv -> dmc ) ; } priv -> vsync_irq = platform_get_irq ( pdev , 0 ) ; <S2SV_StartBug> drm_vblank_init ( drm , 1 ) ; <S2SV_EndBug> drm_mode_config_init ( drm ) ; drm -> mode_config . max_width = 3840 ; drm -> mode_config . max_height = 2160 ; drm -> mode_config . funcs = & meson_mode_config_funcs ; meson_vpu_init ( priv ) ; meson_venc_init ( priv ) ; meson_vpp_init ( priv ) ; meson_viu_init ( priv ) ; ret = meson_venc_cvbs_create ( priv ) ; if ( ret ) goto free_drm ; if ( has_components ) { ret = component_bind_all ( drm -> dev , drm ) ; if ( ret ) { dev_err ( drm -> dev , "Couldn\'t<S2SV_blank>bind<S2SV_blank>all<S2SV_blank>components\\n" ) ; goto free_drm ; } } ret = meson_plane_create ( priv ) ; if ( ret ) goto free_drm ; ret = meson_crtc_create ( priv ) ; if ( ret ) goto free_drm ; ret = drm_irq_install ( drm , priv -> vsync_irq ) ; if ( ret ) goto free_drm ; drm_mode_config_reset ( drm ) ; priv -> fbdev = drm_fbdev_cma_init ( drm , 32 , drm -> mode_config . num_connector ) ; if ( IS_ERR ( priv -> fbdev ) ) { ret = PTR_ERR ( priv -> fbdev ) ; goto free_drm ; } drm_kms_helper_poll_init ( drm ) ; platform_set_drvdata ( pdev , priv ) ; ret = drm_dev_register ( drm , 0 ) ; if ( ret ) goto free_drm ; return 0 ; free_drm : drm_dev_unref ( drm ) ; return ret ; } | <S2SV_ModStart> 0 ) ; ret = <S2SV_ModStart> , 1 ) ; if ( ret ) goto free_drm |
7,076 | CWE-000 <S2SV_StartBug> void cec_rx_buf_check ( void ) <S2SV_EndBug> { if ( 0xf == aocec_rd_reg ( CEC_RX_NUM_MSG ) ) { aocec_wr_reg ( CEC_RX_CLEAR_BUF , 0x1 ) ; aocec_wr_reg ( CEC_RX_CLEAR_BUF , 0x0 ) ; <S2SV_StartBug> } <S2SV_EndBug> aocec_wr_reg ( CEC_RX_MSG_CMD , RX_ACK_CURRENT ) ; aocec_wr_reg ( CEC_RX_MSG_CMD , RX_NO_OP ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> int <S2SV_ModEnd> cec_rx_buf_check ( void <S2SV_ModStart> 0x0 ) ; hdmi_print ( INF , CEC "rx<S2SV_blank>buf<S2SV_blank>clean\\n" ) ; return 1 ; } return 0 <S2SV_ModEnd> ; } <S2SV_null> |
7,077 | CWE-000 void grpc_rb_compression_options_algorithm_name_to_value_internal ( grpc_compression_algorithm * algorithm_value , VALUE algorithm_name ) { grpc_slice name_slice ; VALUE algorithm_name_as_string = Qnil ; Check_Type ( algorithm_name , T_SYMBOL ) ; algorithm_name_as_string = rb_funcall ( algorithm_name , rb_intern ( "to_s" ) , 0 ) ; name_slice = grpc_slice_from_copied_buffer ( RSTRING_PTR ( algorithm_name_as_string ) , RSTRING_LEN ( algorithm_name_as_string ) ) ; if ( ! grpc_compression_algorithm_parse ( name_slice , algorithm_value ) ) { char * name_slice_str = grpc_slice_to_c_string ( name_slice ) ; char * error_message_str = NULL ; VALUE error_message_ruby_str = Qnil ; GPR_ASSERT ( gpr_asprintf ( & error_message_str , "Invalid<S2SV_blank>compression<S2SV_blank>algorithm<S2SV_blank>name:<S2SV_blank>%s" , name_slice_str ) != - 1 ) ; gpr_free ( name_slice_str ) ; error_message_ruby_str = rb_str_new ( error_message_str , strlen ( error_message_str ) ) ; gpr_free ( error_message_str ) ; <S2SV_StartBug> rb_raise ( rb_eNameError , StringValueCStr ( error_message_ruby_str ) ) ; <S2SV_EndBug> } grpc_slice_unref ( name_slice ) ; } | <S2SV_ModStart> ( rb_eNameError , "%s" , |
7,078 | CWE-000 static int cgi_create_env ( server * srv , connection * con , plugin_data * p , handler_ctx * hctx , buffer * cgi_handler ) { char_array env ; char * args [ 3 ] ; int to_cgi_fds [ 2 ] ; int from_cgi_fds [ 2 ] ; int dfd = - 1 ; UNUSED ( p ) ; if ( ! buffer_string_is_empty ( cgi_handler ) ) { struct stat st ; if ( - 1 == ( stat ( cgi_handler -> ptr , & st ) ) ) { log_error_write ( srv , __FILE__ , __LINE__ , "sbss" , "stat<S2SV_blank>for<S2SV_blank>cgi-handler" , cgi_handler , "failed:" , strerror ( errno ) ) ; return - 1 ; } } if ( pipe_cloexec ( to_cgi_fds ) ) { log_error_write ( srv , __FILE__ , __LINE__ , "ss" , "pipe<S2SV_blank>failed:" , strerror ( errno ) ) ; return - 1 ; } if ( pipe_cloexec ( from_cgi_fds ) ) { close ( to_cgi_fds [ 0 ] ) ; close ( to_cgi_fds [ 1 ] ) ; log_error_write ( srv , __FILE__ , __LINE__ , "ss" , "pipe<S2SV_blank>failed:" , strerror ( errno ) ) ; return - 1 ; } fdevent_setfd_cloexec ( to_cgi_fds [ 1 ] ) ; fdevent_setfd_cloexec ( from_cgi_fds [ 0 ] ) ; { int i = 0 ; const char * s ; http_cgi_opts opts = { 0 , 0 , NULL , NULL } ; env . ptr = NULL ; env . size = 0 ; env . used = 0 ; http_cgi_headers ( srv , con , & opts , cgi_env_add , & env ) ; if ( NULL != ( s = getenv ( "LD_PRELOAD" ) ) ) { cgi_env_add ( & env , CONST_STR_LEN ( "LD_PRELOAD" ) , s , strlen ( s ) ) ; } if ( NULL != ( s = getenv ( "LD_LIBRARY_PATH" ) ) ) { cgi_env_add ( & env , CONST_STR_LEN ( "LD_LIBRARY_PATH" ) , s , strlen ( s ) ) ; } # ifdef __CYGWIN__ if ( NULL != ( s = getenv ( "SYSTEMROOT" ) ) ) { cgi_env_add ( & env , CONST_STR_LEN ( "SYSTEMROOT" ) , s , strlen ( s ) ) ; } # endif if ( env . size == env . used ) { env . size += 16 ; env . ptr = realloc ( env . ptr , env . size * sizeof ( * env . ptr ) ) ; } env . ptr [ env . used ] = NULL ; i = 0 ; if ( ! buffer_string_is_empty ( cgi_handler ) ) { args [ i ++ ] = cgi_handler -> ptr ; } args [ i ++ ] = con -> physical . path -> ptr ; args [ i ] = NULL ; } dfd = fdevent_open_dirname ( con -> physical . path -> ptr ) ; if ( - 1 == dfd ) { log_error_write ( srv , __FILE__ , __LINE__ , "ssb" , "open<S2SV_blank>dirname<S2SV_blank>failed:" , strerror ( errno ) , con -> physical . path ) ; } <S2SV_StartBug> hctx -> pid = ( dfd >= 0 ) ? fdevent_fork_execve ( con -> physical . path -> ptr , args , env . ptr , to_cgi_fds [ 0 ] , from_cgi_fds [ 1 ] , - 1 , dfd ) : - 1 ; <S2SV_EndBug> for ( size_t i = 0 ; i < env . used ; ++ i ) free ( env . ptr [ i ] ) ; free ( env . ptr ) ; if ( - 1 == hctx -> pid ) { log_error_write ( srv , __FILE__ , __LINE__ , "ss" , "fork<S2SV_blank>failed:" , strerror ( errno ) ) ; if ( - 1 != dfd ) close ( dfd ) ; close ( from_cgi_fds [ 0 ] ) ; close ( from_cgi_fds [ 1 ] ) ; close ( to_cgi_fds [ 0 ] ) ; close ( to_cgi_fds [ 1 ] ) ; return - 1 ; } else { if ( - 1 != dfd ) close ( dfd ) ; close ( from_cgi_fds [ 1 ] ) ; close ( to_cgi_fds [ 0 ] ) ; hctx -> fd = from_cgi_fds [ 0 ] ; hctx -> fde_ndx = - 1 ; ++ srv -> cur_fds ; if ( 0 == con -> request . content_length ) { close ( to_cgi_fds [ 1 ] ) ; } else { if ( - 1 == fdevent_fcntl_set_nb ( srv -> ev , to_cgi_fds [ 1 ] ) ) { log_error_write ( srv , __FILE__ , __LINE__ , "ss" , "fcntl<S2SV_blank>failed:<S2SV_blank>" , strerror ( errno ) ) ; close ( to_cgi_fds [ 1 ] ) ; cgi_connection_close ( srv , hctx ) ; return - 1 ; } if ( 0 != cgi_write_request ( srv , hctx , to_cgi_fds [ 1 ] ) ) { close ( to_cgi_fds [ 1 ] ) ; cgi_connection_close ( srv , hctx ) ; return - 1 ; } ++ srv -> cur_fds ; } fdevent_register ( srv -> ev , hctx -> fd , cgi_handle_fdevent , hctx ) ; if ( - 1 == fdevent_fcntl_set_nb ( srv -> ev , hctx -> fd ) ) { log_error_write ( srv , __FILE__ , __LINE__ , "ss" , "fcntl<S2SV_blank>failed:<S2SV_blank>" , strerror ( errno ) ) ; cgi_connection_close ( srv , hctx ) ; return - 1 ; } fdevent_event_set ( srv -> ev , & ( hctx -> fde_ndx ) , hctx -> fd , FDEVENT_IN ) ; return 0 ; } } | <S2SV_ModStart> ? fdevent_fork_execve ( args [ 0 ] <S2SV_ModEnd> , args , |
7,079 | CWE-000 static OPJ_BOOL opj_j2k_decode_one_tile ( opj_j2k_t * p_j2k , opj_stream_private_t * p_stream , opj_event_mgr_t * p_manager ) { OPJ_BOOL l_go_on = OPJ_TRUE ; OPJ_UINT32 l_current_tile_no ; OPJ_UINT32 l_tile_no_to_dec ; OPJ_UINT32 l_data_size , l_max_data_size ; OPJ_INT32 l_tile_x0 , l_tile_y0 , l_tile_x1 , l_tile_y1 ; OPJ_UINT32 l_nb_comps ; <S2SV_StartBug> OPJ_BYTE * l_current_data ; <S2SV_EndBug> l_current_data = ( OPJ_BYTE * ) opj_malloc ( 1000 ) ; if ( ! l_current_data ) { opj_event_msg ( p_manager , EVT_ERROR , "Not<S2SV_blank>enough<S2SV_blank>memory<S2SV_blank>to<S2SV_blank>decode<S2SV_blank>one<S2SV_blank>tile\\n" ) ; return OPJ_FALSE ; } l_max_data_size = 1000 ; if ( ! p_j2k -> cstr_index -> tile_index ) { if ( ! opj_j2k_allocate_tile_element_cstr_index ( p_j2k ) ) { opj_free ( l_current_data ) ; return OPJ_FALSE ; } } l_tile_no_to_dec = ( OPJ_UINT32 ) p_j2k -> m_specific_param . m_decoder . m_tile_ind_to_dec ; if ( p_j2k -> cstr_index -> tile_index ) if ( p_j2k -> cstr_index -> tile_index -> tp_index ) { if ( ! p_j2k -> cstr_index -> tile_index [ l_tile_no_to_dec ] . nb_tps ) { if ( ! ( opj_stream_read_seek ( p_stream , p_j2k -> m_specific_param . m_decoder . m_last_sot_read_pos + 2 , p_manager ) ) ) { opj_event_msg ( p_manager , EVT_ERROR , "Problem<S2SV_blank>with<S2SV_blank>seek<S2SV_blank>function\\n" ) ; opj_free ( l_current_data ) ; return OPJ_FALSE ; } } else { if ( ! ( opj_stream_read_seek ( p_stream , p_j2k -> cstr_index -> tile_index [ l_tile_no_to_dec ] . tp_index [ 0 ] . start_pos + 2 , p_manager ) ) ) { opj_event_msg ( p_manager , EVT_ERROR , "Problem<S2SV_blank>with<S2SV_blank>seek<S2SV_blank>function\\n" ) ; opj_free ( l_current_data ) ; return OPJ_FALSE ; } } if ( p_j2k -> m_specific_param . m_decoder . m_state == J2K_STATE_EOC ) { p_j2k -> m_specific_param . m_decoder . m_state = J2K_STATE_TPHSOT ; } } <S2SV_StartBug> for ( ; ; ) { <S2SV_EndBug> if ( ! opj_j2k_read_tile_header ( p_j2k , & l_current_tile_no , & l_data_size , & l_tile_x0 , & l_tile_y0 , & l_tile_x1 , & l_tile_y1 , & l_nb_comps , & l_go_on , p_stream , p_manager ) ) { opj_free ( l_current_data ) ; return OPJ_FALSE ; } if ( ! l_go_on ) { break ; } if ( l_data_size > l_max_data_size ) { OPJ_BYTE * l_new_current_data = ( OPJ_BYTE * ) opj_realloc ( l_current_data , l_data_size ) ; if ( ! l_new_current_data ) { opj_free ( l_current_data ) ; l_current_data = NULL ; opj_event_msg ( p_manager , EVT_ERROR , "Not<S2SV_blank>enough<S2SV_blank>memory<S2SV_blank>to<S2SV_blank>decode<S2SV_blank>tile<S2SV_blank>%d/%d\\n" , l_current_tile_no + 1 , p_j2k -> m_cp . th * p_j2k -> m_cp . tw ) ; return OPJ_FALSE ; } l_current_data = l_new_current_data ; l_max_data_size = l_data_size ; } if ( ! opj_j2k_decode_tile ( p_j2k , l_current_tile_no , l_current_data , l_data_size , p_stream , p_manager ) ) { opj_free ( l_current_data ) ; return OPJ_FALSE ; } opj_event_msg ( p_manager , EVT_INFO , "Tile<S2SV_blank>%d/%d<S2SV_blank>has<S2SV_blank>been<S2SV_blank>decoded.\\n" , l_current_tile_no + 1 , p_j2k -> m_cp . th * p_j2k -> m_cp . tw ) ; if ( ! opj_j2k_update_image_data ( p_j2k -> m_tcd , l_current_data , p_j2k -> m_output_image ) ) { opj_free ( l_current_data ) ; return OPJ_FALSE ; } opj_event_msg ( p_manager , EVT_INFO , "Image<S2SV_blank>data<S2SV_blank>has<S2SV_blank>been<S2SV_blank>updated<S2SV_blank>with<S2SV_blank>tile<S2SV_blank>%d.\\n\\n" , l_current_tile_no + 1 ) ; if ( l_current_tile_no == l_tile_no_to_dec ) { if ( ! ( opj_stream_read_seek ( p_stream , p_j2k -> cstr_index -> main_head_end + 2 , p_manager ) ) ) { opj_event_msg ( p_manager , EVT_ERROR , "Problem<S2SV_blank>with<S2SV_blank>seek<S2SV_blank>function\\n" ) ; opj_free ( l_current_data ) ; return OPJ_FALSE ; } break ; } else { opj_event_msg ( p_manager , EVT_WARNING , "Tile<S2SV_blank>read,<S2SV_blank>decoded<S2SV_blank>and<S2SV_blank>updated<S2SV_blank>is<S2SV_blank>not<S2SV_blank>the<S2SV_blank>desired<S2SV_blank>one<S2SV_blank>(%d<S2SV_blank>vs<S2SV_blank>%d).\\n" , l_current_tile_no + 1 , l_tile_no_to_dec + 1 ) ; } } opj_free ( l_current_data ) ; return OPJ_TRUE ; } | <S2SV_ModStart> OPJ_BYTE * l_current_data ; OPJ_UINT32 l_nb_tiles ; OPJ_UINT32 i <S2SV_ModStart> ; } } l_nb_tiles = p_j2k -> m_cp . tw * p_j2k -> m_cp . th ; for ( i = 0 ; i < l_nb_tiles ; ++ i ) { p_j2k -> m_cp . tcps [ i ] . m_current_tile_part_number = - 1 ; } |
7,080 | CWE-000 int cruise_fid_store_fixed_extend ( int fid , cruise_filemeta_t * meta , off_t length ) { off_t maxsize = meta -> chunks << cruise_chunk_bits ; if ( length > maxsize ) { off_t additional = length - maxsize ; while ( additional > 0 ) { <S2SV_StartBug> if ( meta -> chunks == cruise_max_chunks ) { <S2SV_EndBug> debug ( "failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>chunk\\n" ) ; return CRUISE_ERR_NOSPC ; } int rc = cruise_chunk_alloc ( fid , meta , meta -> chunks ) ; if ( rc != CRUISE_SUCCESS ) { debug ( "failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>chunk\\n" ) ; return CRUISE_ERR_NOSPC ; } meta -> chunks ++ ; additional -= cruise_chunk_size ; } } return CRUISE_SUCCESS ; } | <S2SV_ModStart> chunks == cruise_max_chunks + cruise_spillover_max_chunks |
7,081 | CWE-000 static int ipoib_hard_header ( struct sk_buff * skb , struct net_device * dev , unsigned short type , const void * daddr , const void * saddr , unsigned len ) { struct ipoib_pseudo_header * phdr ; struct ipoib_header * header ; header = ( struct ipoib_header * ) skb_push ( skb , sizeof * header ) ; header -> proto = htons ( type ) ; header -> reserved = 0 ; <S2SV_StartBug> phdr = ( struct ipoib_pseudo_header * ) skb_push ( skb , sizeof ( * phdr ) ) ; <S2SV_EndBug> memcpy ( phdr -> hwaddr , daddr , INFINIBAND_ALEN ) ; return IPOIB_HARD_LEN ; } | <S2SV_ModStart> = 0 ; push_pseudo_header <S2SV_ModEnd> ( skb , <S2SV_ModStart> ( skb , daddr <S2SV_ModEnd> ) ; return |
7,082 | CWE-000 static int ctrldev_release ( struct inode * inode , struct file * f ) { struct ctrldev_priv * priv = ( struct ctrldev_priv * ) f -> private_data ; struct rfifo * pmsgs ; mutex_lock ( & irati_ctrl_dm . general_lock ) ; LOG_DBG ( "Releasing<S2SV_blank>file<S2SV_blank>descriptor<S2SV_blank>associated<S2SV_blank>to<S2SV_blank>port-id<S2SV_blank>%d" , priv -> port_id ) ; list_del_init ( & priv -> node ) ; mutex_unlock ( & irati_ctrl_dm . general_lock ) ; spin_lock ( & priv -> pending_msgs_lock ) ; pmsgs = priv -> pending_msgs ; priv -> pending_msgs = 0 ; spin_unlock ( & priv -> pending_msgs_lock ) ; <S2SV_StartBug> if ( rfifo_destroy ( pmsgs , ( void ( * ) ( void * ) ) rkfree ) ) { <S2SV_EndBug> LOG_ERR ( "Ctrl-dev<S2SV_blank>%u<S2SV_blank>FIFO<S2SV_blank>has<S2SV_blank>not<S2SV_blank>been<S2SV_blank>destroyed" , priv -> port_id ) ; } if ( priv -> port_id == 1 ) { LOG_WARN ( "IPC<S2SV_blank>Manager<S2SV_blank>process<S2SV_blank>has<S2SV_blank>been<S2SV_blank>destroyed" ) ; } LOG_DBG ( "Instance<S2SV_blank>of<S2SV_blank>control<S2SV_blank>device<S2SV_blank>bound<S2SV_blank>to<S2SV_blank>port<S2SV_blank>%d<S2SV_blank>released" , priv -> port_id ) ; wake_up_interruptible_poll ( & priv -> read_wqueue , POLLIN | POLLRDNORM | POLLRDBAND ) ; rkfree ( priv ) ; return 0 ; } | <S2SV_ModStart> * ) ) msg_queue_entry_destroy <S2SV_ModEnd> ) ) { |
7,083 | CWE-000 static void start_exit_async ( void ) <S2SV_StartBug> { <S2SV_EndBug> ibus_bus_exit_async ( bus , TRUE , - 1 , NULL , finish_exit_async , NULL ) ; } | <S2SV_ModStart> void ) { g_usleep ( G_USEC_PER_SEC ) ; |
7,084 | CWE-000 SDL_Renderer * DirectFB_CreateRenderer ( SDL_Window * window , Uint32 flags ) { SDL_DFB_WINDOWDATA ( window ) ; SDL_VideoDisplay * display = SDL_GetDisplayFromWindow ( window ) ; SDL_Renderer * renderer = NULL ; DirectFB_RenderData * data = NULL ; DFBResult ret ; DFBSurfaceCapabilities scaps ; char * p ; SDL_DFB_CALLOC ( renderer , 1 , sizeof ( * renderer ) ) ; SDL_DFB_CALLOC ( data , 1 , sizeof ( * data ) ) ; renderer -> DisplayModeChanged = DirectFB_DisplayModeChanged ; renderer -> ActivateRenderer = DirectFB_ActivateRenderer ; renderer -> CreateTexture = DirectFB_CreateTexture ; renderer -> QueryTexturePixels = DirectFB_QueryTexturePixels ; renderer -> SetTexturePalette = DirectFB_SetTexturePalette ; renderer -> GetTexturePalette = DirectFB_GetTexturePalette ; renderer -> SetTextureAlphaMod = DirectFB_SetTextureAlphaMod ; renderer -> SetTextureColorMod = DirectFB_SetTextureColorMod ; renderer -> SetTextureBlendMode = DirectFB_SetTextureBlendMode ; renderer -> SetTextureScaleMode = DirectFB_SetTextureScaleMode ; renderer -> UpdateTexture = DirectFB_UpdateTexture ; renderer -> LockTexture = DirectFB_LockTexture ; renderer -> UnlockTexture = DirectFB_UnlockTexture ; renderer -> DirtyTexture = DirectFB_DirtyTexture ; renderer -> RenderFill = DirectFB_RenderFill ; renderer -> RenderCopy = DirectFB_RenderCopy ; renderer -> RenderPresent = DirectFB_RenderPresent ; renderer -> DestroyTexture = DirectFB_DestroyTexture ; renderer -> DestroyRenderer = DirectFB_DestroyRenderer ; renderer -> info = DirectFB_RenderDriver . info ; renderer -> window = window -> id ; renderer -> driverdata = data ; renderer -> info . flags = SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTDISCARD ; data -> surface = windata -> surface ; data -> surface -> AddRef ( data -> surface ) ; data -> flipflags = DSFLIP_PIPELINE | DSFLIP_BLIT ; if ( flags & SDL_RENDERER_PRESENTVSYNC ) { <S2SV_StartBug> data -> flipflags = DSFLIP_ONSYNC ; <S2SV_EndBug> renderer -> info . flags |= SDL_RENDERER_PRESENTVSYNC ; } SDL_DFB_CHECKERR ( data -> surface -> GetCapabilities ( data -> surface , & scaps ) ) ; if ( scaps & DSCAPS_DOUBLE ) renderer -> info . flags |= SDL_RENDERER_PRESENTFLIP2 ; else if ( scaps & DSCAPS_TRIPLE ) renderer -> info . flags |= SDL_RENDERER_PRESENTFLIP3 ; else renderer -> info . flags |= SDL_RENDERER_SINGLEBUFFER ; data -> isyuvdirect = 0 ; p = getenv ( DFBENV_USE_YUV_DIRECT ) ; if ( p ) data -> isyuvdirect = atoi ( p ) ; if ( display -> palette ) { SDL_AddPaletteWatch ( display -> palette , DisplayPaletteChanged , data ) ; } return renderer ; error : SDL_DFB_FREE ( renderer ) ; SDL_DFB_FREE ( data ) ; return NULL ; } | <S2SV_ModStart> data -> flipflags |= DSFLIP_WAITFORSYNC ; renderer -> info . flags |= SDL_RENDERER_PRESENTVSYNC ; } else data -> flipflags |= DSFLIP_ONSYNC ; <S2SV_ModEnd> SDL_DFB_CHECKERR ( data |
7,085 | CWE-000 int vmw_getparam_ioctl ( struct drm_device * dev , void * data , struct drm_file * file_priv ) { struct vmw_private * dev_priv = vmw_priv ( dev ) ; struct drm_vmw_getparam_arg * param = ( struct drm_vmw_getparam_arg * ) data ; struct vmw_fpriv * vmw_fp = vmw_fpriv ( file_priv ) ; switch ( param -> param ) { case DRM_VMW_PARAM_NUM_STREAMS : param -> value = vmw_overlay_num_overlays ( dev_priv ) ; break ; case DRM_VMW_PARAM_NUM_FREE_STREAMS : param -> value = vmw_overlay_num_free_overlays ( dev_priv ) ; break ; case DRM_VMW_PARAM_3D : param -> value = vmw_fifo_have_3d ( dev_priv ) ? 1 : 0 ; break ; case DRM_VMW_PARAM_HW_CAPS : param -> value = dev_priv -> capabilities ; break ; case DRM_VMW_PARAM_FIFO_CAPS : param -> value = dev_priv -> fifo . capabilities ; break ; case DRM_VMW_PARAM_MAX_FB_SIZE : param -> value = dev_priv -> prim_bb_mem ; break ; case DRM_VMW_PARAM_FIFO_HW_VERSION : { u32 * fifo_mem = dev_priv -> mmio_virt ; const struct vmw_fifo_state * fifo = & dev_priv -> fifo ; if ( ( dev_priv -> capabilities & SVGA_CAP_GBOBJECTS ) ) { param -> value = SVGA3D_HWVERSION_WS8_B1 ; break ; } param -> value = vmw_mmio_read ( fifo_mem + ( ( fifo -> capabilities & SVGA_FIFO_CAP_3D_HWVERSION_REVISED ) ? SVGA_FIFO_3D_HWVERSION_REVISED : SVGA_FIFO_3D_HWVERSION ) ) ; break ; } case DRM_VMW_PARAM_MAX_SURF_MEMORY : if ( ( dev_priv -> capabilities & SVGA_CAP_GBOBJECTS ) && ! vmw_fp -> gb_aware ) param -> value = dev_priv -> max_mob_pages * PAGE_SIZE / 2 ; else param -> value = dev_priv -> memory_size ; break ; case DRM_VMW_PARAM_3D_CAPS_SIZE : if ( ( dev_priv -> capabilities & SVGA_CAP_GBOBJECTS ) && vmw_fp -> gb_aware ) param -> value = SVGA3D_DEVCAP_MAX * sizeof ( uint32_t ) ; else if ( dev_priv -> capabilities & SVGA_CAP_GBOBJECTS ) param -> value = sizeof ( struct svga_3d_compat_cap ) + sizeof ( uint32_t ) ; else param -> value = ( SVGA_FIFO_3D_CAPS_LAST - SVGA_FIFO_3D_CAPS + 1 ) * sizeof ( uint32_t ) ; break ; case DRM_VMW_PARAM_MAX_MOB_MEMORY : vmw_fp -> gb_aware = true ; param -> value = dev_priv -> max_mob_pages * PAGE_SIZE ; break ; case DRM_VMW_PARAM_MAX_MOB_SIZE : param -> value = dev_priv -> max_mob_size ; break ; case DRM_VMW_PARAM_SCREEN_TARGET : param -> value = ( dev_priv -> active_display_unit == vmw_du_screen_target ) ; break ; case DRM_VMW_PARAM_DX : param -> value = dev_priv -> has_dx ; break ; default : <S2SV_StartBug> DRM_ERROR ( "Illegal<S2SV_blank>vmwgfx<S2SV_blank>get<S2SV_blank>param<S2SV_blank>request:<S2SV_blank>%d\\n" , <S2SV_EndBug> param -> param ) ; return - EINVAL ; } return 0 ; } | <S2SV_ModStart> ; default : <S2SV_ModEnd> return - EINVAL |
7,086 | CWE-000 void test_normalise_signal ( void ) { <S2SV_StartBug> float * sigarr = array_from_scrappie_matrix ( signal ) ; <S2SV_EndBug> <S2SV_StartBug> size_t n = signal -> nc ; <S2SV_EndBug> CU_ASSERT_PTR_NOT_NULL_FATAL ( sigarr ) ; medmad_normalise_array ( sigarr , n ) ; CU_ASSERT_TRUE ( equality_arrayf ( sigarr , normsig_arr , n , 1e-5 ) ) ; free ( sigarr ) ; } | <S2SV_ModStart> = array_from_scrappie_matrix ( trimsignal <S2SV_ModEnd> ) ; size_t <S2SV_ModStart> size_t n = trimsignal <S2SV_ModEnd> -> nc ; |
7,087 | CWE-000 LIBTEST_API gpointer STDCALL mono_test_marshal_return_fnptr ( void ) { <S2SV_StartBug> return & add_delegate ; <S2SV_EndBug> } | <S2SV_ModStart> ) { return ( gpointer ) |
7,088 | CWE-000 int __wt_session_release_btree ( WT_SESSION_IMPL * session ) { WT_BTREE * btree ; WT_DATA_HANDLE * dhandle ; WT_DATA_HANDLE_CACHE * dhandle_cache ; WT_DECL_RET ; bool locked , write_locked ; btree = S2BT ( session ) ; dhandle = session -> dhandle ; write_locked = F_ISSET ( dhandle , WT_DHANDLE_EXCLUSIVE ) ; locked = true ; if ( F_ISSET ( dhandle , WT_DHANDLE_DISCARD | WT_DHANDLE_DISCARD_FORCE ) ) { <S2SV_StartBug> __session_find_dhandle ( session , <S2SV_EndBug> <S2SV_StartBug> dhandle -> name , dhandle -> checkpoint , & dhandle_cache ) ; <S2SV_EndBug> if ( dhandle_cache != NULL ) __session_discard_dhandle ( session , dhandle_cache ) ; } if ( F_ISSET ( dhandle , WT_DHANDLE_DISCARD_FORCE ) ) { ret = __wt_conn_btree_sync_and_close ( session , false , true ) ; F_CLR ( dhandle , WT_DHANDLE_DISCARD_FORCE ) ; } else if ( F_ISSET ( btree , WT_BTREE_BULK ) ) { WT_ASSERT ( session , F_ISSET ( dhandle , WT_DHANDLE_EXCLUSIVE ) && ! F_ISSET ( dhandle , WT_DHANDLE_DISCARD ) ) ; WT_WITH_SCHEMA_LOCK ( session , ret = __wt_conn_btree_sync_and_close ( session , false , false ) ) ; } else if ( F_ISSET ( dhandle , WT_DHANDLE_DISCARD ) || F_ISSET ( btree , WT_BTREE_SPECIAL_FLAGS ) ) { WT_ASSERT ( session , F_ISSET ( dhandle , WT_DHANDLE_EXCLUSIVE ) ) ; ret = __wt_conn_btree_sync_and_close ( session , false , false ) ; F_CLR ( dhandle , WT_DHANDLE_DISCARD ) ; } if ( session == dhandle -> excl_session ) { if ( -- dhandle -> excl_ref == 0 ) dhandle -> excl_session = NULL ; else locked = false ; } if ( locked ) { if ( write_locked ) { F_CLR ( dhandle , WT_DHANDLE_EXCLUSIVE ) ; __wt_writeunlock ( session , & dhandle -> rwlock ) ; } else __wt_readunlock ( session , & dhandle -> rwlock ) ; } session -> dhandle = NULL ; return ( ret ) ; } | <S2SV_ModStart> ) ) { WT_SAVE_DHANDLE ( session , <S2SV_ModStart> , & dhandle_cache ) |
7,089 | CWE-000 static int provenance_socket_bind ( struct socket * sock , struct sockaddr * address , int addrlen ) { <S2SV_StartBug> struct provenance * cprov = current_provenance ( ) ; <S2SV_EndBug> struct provenance * iprov = socket_inode_provenance ( sock ) ; struct sockaddr_in * ipv4_addr ; uint8_t op ; int rc ; if ( ! iprov ) return - ENOMEM ; if ( provenance_is_opaque ( prov_elt ( cprov ) ) ) return 0 ; if ( address -> sa_family == PF_INET ) { if ( addrlen < sizeof ( struct sockaddr_in ) ) return - EINVAL ; ipv4_addr = ( struct sockaddr_in * ) address ; op = prov_ipv4_ingressOP ( ipv4_addr -> sin_addr . s_addr , ipv4_addr -> sin_port ) ; if ( ( op & PROV_SET_TRACKED ) != 0 ) { set_tracked ( prov_elt ( iprov ) ) ; set_tracked ( prov_elt ( cprov ) ) ; } if ( ( op & PROV_SET_PROPAGATE ) != 0 ) { set_propagate ( prov_elt ( iprov ) ) ; set_propagate ( prov_elt ( cprov ) ) ; } if ( ( op & PROV_SET_RECORD ) != 0 ) set_record_packet ( prov_elt ( iprov ) ) ; } rc = provenance_record_address ( address , addrlen , iprov ) ; if ( rc < 0 ) return rc ; rc = flow_from_activity ( RL_BIND , cprov , iprov , NULL ) ; return rc ; } | <S2SV_ModStart> * cprov = get_current_provenance <S2SV_ModEnd> ( ) ; |
7,090 | CWE-000 static void payload1 ( ) { uint32_t count = val_peripheral_get_info ( NUM_UART , 0 ) ; <S2SV_StartBug> uint32_t index = val_pe_get_index_mpid ( val_pe_get_mpid ( ) ) ; <S2SV_EndBug> if ( count == 0 ) { val_set_status ( index , RESULT_SKIP ( g_sbsa_level , TEST_NUM2 , 01 ) ) ; return ; } while ( count != 0 ) { int_id = val_peripheral_get_info ( UART_GSIV , count - 1 ) ; if ( int_id != 0x0 ) { val_set_status ( index , RESULT_PENDING ( g_sbsa_level , TEST_NUM2 ) ) ; val_gic_install_isr ( int_id , isr ) ; uart_enable_txintr ( ) ; val_print ( g_print_level , "\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Test<S2SV_blank>Message<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" , 0 ) ; <S2SV_StartBug> if ( IS_RESULT_PENDING ( val_get_status ( index ) ) ) { <S2SV_EndBug> val_print ( AVS_PRINT_ERR , "\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Did<S2SV_blank>not<S2SV_blank>receive<S2SV_blank>UART<S2SV_blank>interrupt<S2SV_blank>on<S2SV_blank>%d<S2SV_blank><S2SV_blank>" , int_id ) ; val_set_status ( index , RESULT_FAIL ( g_sbsa_level , TEST_NUM2 , 02 ) ) ; <S2SV_StartBug> } <S2SV_EndBug> } else { val_set_status ( index , RESULT_SKIP ( g_sbsa_level , TEST_NUM2 , 01 ) ) ; } count -- ; } return ; } | <S2SV_ModStart> ( ) ) ; uint32_t timeout = TIMEOUT_MEDIUM <S2SV_ModStart> 0 ) ; while ( ( -- timeout > 0 ) && ( IS_RESULT_PENDING ( val_get_status ( index ) ) ) ) ; if ( timeout == 0 <S2SV_ModEnd> ) { val_print <S2SV_ModStart> ) ) ; return ; |
7,091 | CWE-000 <S2SV_StartBug> int picoquic_queue_misc_frame ( picoquic_cnx_t * cnx , uint8_t * bytes , size_t length ) <S2SV_EndBug> { int ret = 0 ; uint8_t * misc_frame = ( uint8_t * ) malloc ( sizeof ( picoquic_misc_frame_header_t ) + length ) ; if ( misc_frame == NULL ) { ret = PICOQUIC_ERROR_MEMORY ; } else { picoquic_misc_frame_header_t * head = ( picoquic_misc_frame_header_t * ) misc_frame ; head -> length = length ; memcpy ( misc_frame + sizeof ( picoquic_misc_frame_header_t ) , bytes , length ) ; head -> next_misc_frame = cnx -> first_misc_frame ; cnx -> first_misc_frame = head ; } return ret ; } | <S2SV_ModStart> * cnx , const |
7,092 | CWE-000 static int ssl3_send_client_certificate ( SSL_HANDSHAKE * hs ) { SSL * const ssl = hs -> ssl ; if ( hs -> state == SSL3_ST_CW_CERT_B ) { return ssl -> method -> write_message ( ssl ) ; } assert ( hs -> state == SSL3_ST_CW_CERT_A ) ; if ( ssl -> cert -> cert_cb ) { int ret = ssl -> cert -> cert_cb ( ssl , ssl -> cert -> cert_cb_arg ) ; if ( ret < 0 ) { ssl -> rwstate = SSL_X509_LOOKUP ; return - 1 ; } if ( ret == 0 ) { OPENSSL_PUT_ERROR ( SSL , SSL_R_CERT_CB_ERROR ) ; ssl3_send_alert ( ssl , SSL3_AL_FATAL , SSL_AD_INTERNAL_ERROR ) ; return - 1 ; } } if ( ! ssl_has_certificate ( ssl ) ) { <S2SV_StartBug> hs -> cert_request = 0 ; <S2SV_EndBug> ssl3_free_handshake_buffer ( ssl ) ; if ( ssl -> version == SSL3_VERSION ) { ssl3_send_alert ( ssl , SSL3_AL_WARNING , SSL_AD_NO_CERTIFICATE ) ; return 1 ; } } if ( ! ssl_auto_chain_if_needed ( ssl ) || ! ssl3_output_cert_chain ( ssl ) ) { return - 1 ; } hs -> state = SSL3_ST_CW_CERT_B ; return ssl -> method -> write_message ( ssl ) ; } | <S2SV_ModStart> ) ) { <S2SV_ModEnd> ssl3_free_handshake_buffer ( ssl |
7,093 | CWE-000 struct ib_umem * ib_umem_get ( struct ib_ucontext * context , unsigned long addr , size_t size , int access , int dmasync ) { struct ib_umem * umem ; struct page * * page_list ; struct vm_area_struct * * vma_list ; struct ib_umem_chunk * chunk ; unsigned long locked ; unsigned long lock_limit ; unsigned long cur_base ; unsigned long npages ; int ret ; int off ; int i ; DEFINE_DMA_ATTRS ( attrs ) ; if ( dmasync ) dma_set_attr ( DMA_ATTR_WRITE_BARRIER , & attrs ) ; if ( ! can_do_mlock ( ) ) return ERR_PTR ( - EPERM ) ; umem = kmalloc ( sizeof * umem , GFP_KERNEL ) ; if ( ! umem ) return ERR_PTR ( - ENOMEM ) ; umem -> context = context ; umem -> length = size ; umem -> offset = addr & ~ PAGE_MASK ; umem -> page_size = PAGE_SIZE ; umem -> writable = ! ! ( access & ~ IB_ACCESS_REMOTE_READ ) ; umem -> hugetlb = 1 ; INIT_LIST_HEAD ( & umem -> chunk_list ) ; page_list = ( struct page * * ) __get_free_page ( GFP_KERNEL ) ; if ( ! page_list ) { kfree ( umem ) ; return ERR_PTR ( - ENOMEM ) ; } vma_list = ( struct vm_area_struct * * ) __get_free_page ( GFP_KERNEL ) ; if ( ! vma_list ) umem -> hugetlb = 0 ; npages = PAGE_ALIGN ( size + umem -> offset ) >> PAGE_SHIFT ; down_write ( & current -> mm -> mmap_sem ) ; locked = npages + current -> mm -> locked_vm ; <S2SV_StartBug> lock_limit = current -> signal -> rlim [ RLIMIT_MEMLOCK ] . rlim_cur >> PAGE_SHIFT ; <S2SV_EndBug> if ( ( locked > lock_limit ) && ! capable ( CAP_IPC_LOCK ) ) { ret = - ENOMEM ; goto out ; } cur_base = addr & PAGE_MASK ; ret = 0 ; while ( npages ) { ret = get_user_pages ( current , current -> mm , cur_base , min_t ( unsigned long , npages , PAGE_SIZE / sizeof ( struct page * ) ) , 1 , ! umem -> writable , page_list , vma_list ) ; if ( ret < 0 ) goto out ; cur_base += ret * PAGE_SIZE ; npages -= ret ; off = 0 ; while ( ret ) { chunk = kmalloc ( sizeof * chunk + sizeof ( struct scatterlist ) * min_t ( int , ret , IB_UMEM_MAX_PAGE_CHUNK ) , GFP_KERNEL ) ; if ( ! chunk ) { ret = - ENOMEM ; goto out ; } chunk -> nents = min_t ( int , ret , IB_UMEM_MAX_PAGE_CHUNK ) ; sg_init_table ( chunk -> page_list , chunk -> nents ) ; for ( i = 0 ; i < chunk -> nents ; ++ i ) { if ( vma_list && ! is_vm_hugetlb_page ( vma_list [ i + off ] ) ) umem -> hugetlb = 0 ; sg_set_page ( & chunk -> page_list [ i ] , page_list [ i + off ] , PAGE_SIZE , 0 ) ; } chunk -> nmap = ib_dma_map_sg_attrs ( context -> device , & chunk -> page_list [ 0 ] , chunk -> nents , DMA_BIDIRECTIONAL , & attrs ) ; if ( chunk -> nmap <= 0 ) { for ( i = 0 ; i < chunk -> nents ; ++ i ) put_page ( sg_page ( & chunk -> page_list [ i ] ) ) ; kfree ( chunk ) ; ret = - ENOMEM ; goto out ; } ret -= chunk -> nents ; off += chunk -> nents ; list_add_tail ( & chunk -> list , & umem -> chunk_list ) ; } ret = 0 ; } out : if ( ret < 0 ) { __ib_umem_release ( context -> device , umem , 0 ) ; kfree ( umem ) ; } else current -> mm -> locked_vm = locked ; up_write ( & current -> mm -> mmap_sem ) ; if ( vma_list ) free_page ( ( unsigned long ) vma_list ) ; free_page ( ( unsigned long ) page_list ) ; return ret < 0 ? ERR_PTR ( ret ) : umem ; } | <S2SV_ModStart> ; lock_limit = rlimit ( RLIMIT_MEMLOCK ) <S2SV_ModEnd> >> PAGE_SHIFT ; |
7,094 | CWE-000 void beeperOffSet ( uint32_t mask ) <S2SV_StartBug> { <S2SV_EndBug> beeperConfigMutable ( ) -> beeper_off_flags |= mask ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> mask ) { # ifdef BEEPER <S2SV_ModStart> |= mask ; # else UNUSED ( mask ) ; # endif |
7,095 | CWE-000 static void flagbars ( RCore * core , const char * glob ) { int cols = r_cons_get_size ( NULL ) ; RListIter * iter ; RFlagItem * flag ; cols -= 80 ; if ( cols < 0 ) { cols += 80 ; } r_list_foreach ( core -> flags -> flags , iter , flag ) { ut64 min = 0 , max = r_io_size ( core -> io ) ; <S2SV_StartBug> RIOSection * s = r_io_section_vget ( core -> io , flag -> offset ) ; <S2SV_EndBug> if ( s ) { min = s -> vaddr ; max = s -> vaddr + s -> size ; } if ( r_str_glob ( flag -> name , glob ) ) { r_cons_printf ( "0x%08" PFMT64x "<S2SV_blank>" , flag -> offset ) ; r_print_rangebar ( core -> print , flag -> offset , flag -> offset + flag -> size , min , max , cols ) ; r_cons_printf ( "<S2SV_blank><S2SV_blank>%s\\n" , flag -> name ) ; } } } | <S2SV_ModStart> io ) ; SdbList * secs = r_io_section_vget_secs_at ( core -> io , flag -> offset ) ; <S2SV_ModStart> * s = secs ? ls_pop ( secs ) : NULL ; ls_free ( secs <S2SV_ModEnd> ) ; if |
7,096 | CWE-000 static int virt2_dispatch_block ( virt2_instance_t * inst , const VMInfo * vm ) { value_t vals [ 2 ] ; for ( size_t j = 0 ; j < vm -> block . nstats ; j ++ ) { const BlockStats * stats = ( vm -> block . xstats ) ? vm -> block . xstats : vm -> block . stats ; const char * name = stats [ j ] . xname ? stats [ j ] . xname : stats [ j ] . name ; <S2SV_StartBug> if ( inst -> state -> il_block_devices && <S2SV_EndBug> ignore_device_match ( inst -> state -> il_block_devices , vm -> name , name ) != 0 ) continue ; vals [ 0 ] . derive = stats [ j ] . rd_reqs ; vals [ 1 ] . derive = stats [ j ] . wr_reqs ; virt2_submit ( inst -> conf , vm , "disk_ops" , name , vals , STATIC_ARRAY_SIZE ( vals ) ) ; vals [ 0 ] . derive = stats [ j ] . rd_bytes ; vals [ 1 ] . derive = stats [ j ] . wr_bytes ; virt2_submit ( inst -> conf , vm , "disk_octets" , name , vals , STATIC_ARRAY_SIZE ( vals ) ) ; } return 0 ; } | <S2SV_ModStart> state -> il_block_devices != NULL |
7,097 | CWE-000 void sh_fault ( int sig , siginfo_t * info , void * context ) { UNUSED ( context ) ; int saved_errno = errno ; Shell_t * shp = sh_getinterp ( ) ; int flag = 0 ; char * trap ; struct checkpt * pp = ( struct checkpt * ) shp -> jmplist ; <S2SV_StartBug> int action = 0 ; <S2SV_EndBug> if ( sig == SIGABRT ) { sh_signal ( sig , ( sh_sigfun_t ) ( SIG_DFL ) ) ; sh_sigaction ( sig , SIG_UNBLOCK ) ; kill ( getpid ( ) , sig ) ; } if ( sig == SIGSEGV ) { dump_backtrace ( 100 , 0 ) ; sh_signal ( sig , ( sh_sigfun_t ) ( SIG_DFL ) ) ; sh_sigaction ( sig , SIG_UNBLOCK ) ; kill ( getpid ( ) , sig ) ; } if ( sig == SIGCHLD ) sfprintf ( sfstdout , "childsig\\n" ) ; # ifdef SIGWINCH if ( sig == SIGWINCH ) shp -> winch = 1 ; # endif trap = shp -> st . trapcom [ sig ] ; if ( sig == SIGBUS ) { sh_signal ( sig , ( sh_sigfun_t ) ( SIG_DFL ) ) ; sh_sigaction ( sig , SIG_UNBLOCK ) ; kill ( getpid ( ) , sig ) ; } if ( shp -> savesig ) { if ( ! ( shp -> sigflag [ sig ] & SH_SIGIGNORE ) ) shp -> savesig = sig ; goto done ; } if ( trap && * trap == 0 ) goto done ; flag = shp -> sigflag [ sig ] & ~ SH_SIGOFF ; if ( ! trap ) { if ( sig == SIGINT && ( shp -> trapnote & SH_SIGIGNORE ) ) goto done ; if ( flag & SH_SIGIGNORE ) { if ( shp -> subshell ) shp -> ignsig = sig ; goto done ; } if ( flag & SH_SIGDONE ) { <S2SV_StartBug> void * ptr = 0 ; <S2SV_EndBug> if ( shp -> bltinfun ) action = notify_builtin ( shp , sig ) ; if ( ( flag & SH_SIGINTERACTIVE ) && sh_isstate ( shp , SH_INTERACTIVE ) && ! sh_isstate ( shp , SH_FORKED ) && ! shp -> subshell ) { if ( sig == SIGTERM && job . in_critical ) shp -> trapnote |= SH_SIGTERM ; goto done ; } shp -> lastsig = sig ; sh_sigaction ( sig , SIG_UNBLOCK ) ; if ( pp -> mode != SH_JMPSUB ) { if ( pp -> mode < SH_JMPSUB ) { pp -> mode = shp -> subshell ? SH_JMPSUB : SH_JMPFUN ; } else { pp -> mode = SH_JMPEXIT ; } } if ( shp -> subshell ) sh_exit ( shp , SH_EXITSIG ) ; if ( sig == SIGABRT || ( abortsig ( sig ) && ( ptr = malloc ( 1 ) ) ) ) { if ( ptr ) free ( ptr ) ; sh_done ( shp , sig ) ; } shp -> trapnote |= SH_SIGSET ; if ( sig < shp -> gd -> sigmax ) shp -> sigflag [ sig ] |= SH_SIGSET ; goto done ; } } errno = 0 ; if ( pp -> mode == SH_JMPCMD || ( ( pp -> mode == 1 && shp -> bltinfun ) && ! ( flag & SH_SIGIGNORE ) ) ) { shp -> lastsig = sig ; } if ( trap ) { set_trapinfo ( shp , sig , info ) ; if ( sig == SIGHUP && job . curpgid ) killpg ( job . curpgid , SIGHUP ) ; flag = SH_SIGTRAP ; } else { shp -> lastsig = sig ; flag = SH_SIGSET ; # ifdef SIGTSTP if ( sig == SIGTSTP ) { shp -> trapnote |= SH_SIGTSTP ; if ( pp -> mode == SH_JMPCMD && sh_isstate ( shp , SH_STOPOK ) ) { sh_sigaction ( sig , SIG_UNBLOCK ) ; sh_exit ( shp , SH_EXITSIG ) ; goto done ; } } # endif } <S2SV_StartBug> if ( shp -> bltinfun ) action = notify_builtin ( shp , sig ) ; <S2SV_EndBug> if ( action > 0 ) goto done ; shp -> trapnote |= flag ; if ( sig < shp -> gd -> sigmax ) shp -> sigflag [ sig ] |= flag ; if ( pp -> mode == SH_JMPCMD && sh_isstate ( shp , SH_STOPOK ) ) { if ( action < 0 ) goto done ; sh_sigaction ( sig , SIG_UNBLOCK ) ; sh_exit ( shp , SH_EXITSIG ) ; } done : errno = saved_errno ; } | <S2SV_ModStart> -> jmplist ; <S2SV_ModEnd> if ( sig <S2SV_ModStart> * ptr = NULL ; ( void ) <S2SV_ModEnd> notify_builtin ( shp <S2SV_ModStart> # endif } int <S2SV_ModEnd> action = notify_builtin |
7,098 | CWE-000 int read_header_values ( char * buff , int * i , int dst_size , int src_size ) { int j = * i ; if ( rcv_bitmap . version ) { rcv_header_values . version = ( uint8_t ) buff [ j ] ; j ++ ; } if ( rcv_bitmap . destination1 || rcv_bitmap . destination2 ) { if ( dst_size == 2 ) { rcv_header_values . destination_addr = ( uint8_t ) buff [ j ] << 8 | ( uint8_t ) buff [ j + 1 ] ; j += 2 ; } if ( dst_size == 4 ) { rcv_header_values . destination_addr = ( uint8_t ) buff [ j ] << 24 | ( uint8_t ) buff [ j + 1 ] << 16 | ( uint8_t ) buff [ j + 2 ] << 8 | ( uint8_t ) buff [ j + 3 ] ; j += 4 ; } if ( dst_size == 16 ) { j += 16 ; } } if ( rcv_bitmap . length ) { rcv_header_values . length = ( uint8_t ) buff [ j ] << 8 | ( uint8_t ) buff [ j + 1 ] ; j += 2 ; } if ( rcv_bitmap . ttl ) { rcv_header_values . ttl = ( uint8_t ) buff [ j ] ; j ++ ; } if ( rcv_bitmap . flow ) { rcv_header_values . flow = ( uint8_t ) buff [ j ] << 24 | ( uint8_t ) buff [ j + 1 ] << 16 | ( uint8_t ) buff [ j + 2 ] << 8 | ( uint8_t ) buff [ j + 3 ] ; j += 4 ; } if ( rcv_bitmap . source1 || rcv_bitmap . source2 ) { if ( src_size == 2 ) { rcv_header_values . source_addr = ( uint8_t ) buff [ j ] << 8 | ( uint8_t ) buff [ j + 1 ] ; j += 2 ; } if ( src_size == 4 ) { rcv_header_values . source_addr = ( uint8_t ) buff [ j ] << 24 | ( uint8_t ) buff [ j + 1 ] << 16 | ( uint8_t ) buff [ j + 2 ] << 8 | ( uint8_t ) buff [ j + 3 ] ; j += 4 ; } if ( src_size == 16 ) { j += 16 ; } } if ( rcv_bitmap . protocol ) { rcv_header_values . protocol = ( uint8_t ) buff [ j ] ; j ++ ; } if ( rcv_bitmap . checksum ) { rcv_header_values . checksum = ( uint8_t ) buff [ j ] << 8 | ( uint8_t ) buff [ j + 1 ] ; j += 2 ; } <S2SV_StartBug> i * = j ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> 2 ; } * i <S2SV_ModEnd> = j ; |
7,099 | CWE-000 void va_TraceInit ( VADisplay dpy ) { <S2SV_StartBug> char env_value [ 1024 ] ; <S2SV_EndBug> unsigned short suffix = 0xffff & ( ( unsigned int ) time ( NULL ) ) ; FILE * tmp ; struct trace_context * trace_ctx = calloc ( sizeof ( struct trace_context ) , 1 ) ; if ( trace_ctx == NULL ) return ; <S2SV_StartBug> if ( va_parseConfig ( "LIBVA_TRACE" , & env_value [ 0 ] ) == 0 ) { <S2SV_EndBug> FILE_NAME_SUFFIX ( env_value ) ; trace_ctx -> trace_log_fn = strdup ( env_value ) ; tmp = fopen ( env_value , "w" ) ; if ( tmp ) { trace_ctx -> trace_fp_log = tmp ; va_infoMessage ( "LIBVA_TRACE<S2SV_blank>is<S2SV_blank>on,<S2SV_blank>save<S2SV_blank>log<S2SV_blank>into<S2SV_blank>%s\\n" , trace_ctx -> trace_log_fn ) ; trace_flag = VA_TRACE_FLAG_LOG ; } else va_errorMessage ( "Open<S2SV_blank>file<S2SV_blank>%s<S2SV_blank>failed<S2SV_blank>(%s)\\n" , env_value , strerror ( errno ) ) ; } if ( ( trace_flag & VA_TRACE_FLAG_LOG ) && ( va_parseConfig ( "LIBVA_TRACE_BUFDATA" , NULL ) == 0 ) ) { trace_flag |= VA_TRACE_FLAG_BUFDATA ; va_infoMessage ( "LIBVA_TRACE_BUFDATA<S2SV_blank>is<S2SV_blank>on,<S2SV_blank>dump<S2SV_blank>buffer<S2SV_blank>into<S2SV_blank>log<S2SV_blank>file\\n" ) ; } if ( va_parseConfig ( "LIBVA_TRACE_CODEDBUF" , & env_value [ 0 ] ) == 0 ) { FILE_NAME_SUFFIX ( env_value ) ; trace_ctx -> trace_codedbuf_fn = strdup ( env_value ) ; va_infoMessage ( "LIBVA_TRACE_CODEDBUF<S2SV_blank>is<S2SV_blank>on,<S2SV_blank>save<S2SV_blank>codedbuf<S2SV_blank>into<S2SV_blank>log<S2SV_blank>file<S2SV_blank>%s\\n" , trace_ctx -> trace_codedbuf_fn ) ; trace_flag |= VA_TRACE_FLAG_CODEDBUF ; } if ( va_parseConfig ( "LIBVA_TRACE_SURFACE" , & env_value [ 0 ] ) == 0 ) { FILE_NAME_SUFFIX ( env_value ) ; trace_ctx -> trace_surface_fn = strdup ( env_value ) ; va_infoMessage ( "LIBVA_TRACE_SURFACE<S2SV_blank>is<S2SV_blank>on,<S2SV_blank>save<S2SV_blank>surface<S2SV_blank>into<S2SV_blank>%s\\n" , trace_ctx -> trace_surface_fn ) ; if ( strstr ( env_value , "dec" ) ) trace_flag |= VA_TRACE_FLAG_SURFACE_DECODE ; if ( strstr ( env_value , "enc" ) ) trace_flag |= VA_TRACE_FLAG_SURFACE_ENCODE ; if ( strstr ( env_value , "jpeg" ) || strstr ( env_value , "jpg" ) ) trace_flag |= VA_TRACE_FLAG_SURFACE_JPEG ; if ( va_parseConfig ( "LIBVA_TRACE_SURFACE_GEOMETRY" , & env_value [ 0 ] ) == 0 ) { char * p = env_value , * q ; trace_ctx -> trace_surface_width = strtod ( p , & q ) ; p = q + 1 ; trace_ctx -> trace_surface_height = strtod ( p , & q ) ; p = q + 1 ; trace_ctx -> trace_surface_xoff = strtod ( p , & q ) ; p = q + 1 ; trace_ctx -> trace_surface_yoff = strtod ( p , & q ) ; va_infoMessage ( "LIBVA_TRACE_SURFACE_GEOMETRY<S2SV_blank>is<S2SV_blank>on,<S2SV_blank>only<S2SV_blank>dump<S2SV_blank>surface<S2SV_blank>%dx%d+%d+%d<S2SV_blank>content\\n" , trace_ctx -> trace_surface_width , trace_ctx -> trace_surface_height , trace_ctx -> trace_surface_xoff , trace_ctx -> trace_surface_yoff ) ; } } ( ( VADisplayContextP ) dpy ) -> vatrace = trace_ctx ; } | <S2SV_ModStart> [ 1024 ] = { 0 } ; char va_value [ 1024 ] = { 0 } <S2SV_ModStart> "LIBVA_TRACE" , & va_value <S2SV_ModEnd> [ 0 ] <S2SV_ModStart> 0 ) { strcpy ( env_value , LIBVA_TRACE_FILE ) ; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.