Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
6,900 | CWE-000 static void create_breakpoints_sal ( struct gdbarch * gdbarch , struct linespec_result * canonical , <S2SV_StartBug> char * cond_string , char * extra_string , <S2SV_EndBug> enum bptype type , enum bpdisp disposition , int thread , int task , int ignore_count , const struct breakpoint_ops * ops , int from_tty , int enabled , int internal , unsigned flags ) { int i ; struct linespec_sals * lsal ; if ( canonical -> pre_expanded ) gdb_assert ( VEC_length ( linespec_sals , canonical -> sals ) == 1 ) ; for ( i = 0 ; VEC_iterate ( linespec_sals , canonical -> sals , i , lsal ) ; ++ i ) { event_location_up location = ( canonical -> location != NULL ? copy_event_location ( canonical -> location . get ( ) ) : NULL ) ; <S2SV_StartBug> char * filter_string = lsal -> canonical ? xstrdup ( lsal -> canonical ) : NULL ; <S2SV_EndBug> make_cleanup ( xfree , filter_string ) ; create_breakpoint_sal ( gdbarch , lsal -> sals , std : : move ( location ) , filter_string , cond_string , extra_string , type , disposition , thread , task , ignore_count , ops , from_tty , enabled , internal , flags , canonical -> special_display ) ; } } | <S2SV_ModStart> * canonical , gdb : : unique_xmalloc_ptr < char > cond_string , gdb : : unique_xmalloc_ptr < char > <S2SV_ModEnd> extra_string , enum <S2SV_ModStart> NULL ) ; gdb : : unique_xmalloc_ptr < char > filter_string ( lsal -> canonical != NULL <S2SV_ModEnd> ? xstrdup ( <S2SV_ModStart> ) : NULL ) ; create_breakpoint_sal ( gdbarch , lsal -> sals , std : : move ( location ) , std : : move ( filter_string ) , std : : move ( cond_string ) , std : : move ( extra_string ) <S2SV_ModEnd> , type , |
6,901 | CWE-000 static int cpufreq_sched_policy_exit ( struct cpufreq_policy * policy ) <S2SV_StartBug> { <S2SV_EndBug> struct gov_data * gd = policy -> governor_data ; if ( ! gd ) return - EBUSY ; clear_sched_freq ( ) ; if ( cpufreq_driver_slow ) { kthread_stop ( gd -> task ) ; put_task_struct ( gd -> task ) ; } <S2SV_StartBug> sysfs_remove_group ( get_governor_parent_kobj ( policy ) , get_sysfs_attr ( ) ) ; <S2SV_EndBug> policy -> governor_data = NULL ; kfree ( gd ) ; return 0 ; } | <S2SV_ModStart> policy ) { unsigned int count ; <S2SV_ModStart> ) ; } count = gov_attr_set_put ( & gd -> tunables -> attr_set , & gd -> tunables_hook ) ; if ( ! count ) { if ( ! have_governor_per_policy <S2SV_ModEnd> ( ) ) <S2SV_ModStart> ( ) ) global_tunables = NULL ; kfree ( gd -> tunables ) ; } <S2SV_ModEnd> policy -> governor_data |
6,902 | CWE-000 enum htc_status_e HTC_RxStuff ( struct http_conn * htc , htc_complete_f * func , double * t1 , double * t2 , double ti , double tn , int maxbytes ) { double tmo ; double now ; enum htc_status_e hs ; ssize_t z ; CHECK_OBJ_NOTNULL ( htc , HTTP_CONN_MAGIC ) ; AN ( htc -> rfd ) ; assert ( * htc -> rfd > 0 ) ; AN ( htc -> ws -> r ) ; AN ( htc -> rxbuf_b ) ; assert ( htc -> rxbuf_b <= htc -> rxbuf_e ) ; AZ ( isnan ( tn ) ) ; if ( t1 != NULL ) assert ( isnan ( * t1 ) ) ; if ( htc -> rxbuf_e == htc -> ws -> r ) { WS_ReleaseP ( htc -> ws , htc -> rxbuf_b ) ; return ( HTC_S_OVERFLOW ) ; } z = ( htc -> ws -> r - htc -> rxbuf_b ) ; if ( z < maxbytes ) maxbytes = z ; while ( 1 ) { now = VTIM_real ( ) ; AZ ( htc -> pipeline_b ) ; AZ ( htc -> pipeline_e ) ; assert ( htc -> rxbuf_e <= htc -> ws -> r ) ; hs = func ( htc ) ; if ( hs == HTC_S_OVERFLOW || hs == HTC_S_JUNK ) { WS_ReleaseP ( htc -> ws , htc -> rxbuf_b ) ; return ( hs ) ; } if ( hs == HTC_S_COMPLETE ) { WS_ReleaseP ( htc -> ws , htc -> rxbuf_e ) ; if ( t1 != NULL && isnan ( * t1 ) ) * t1 = now ; if ( t2 != NULL ) * t2 = now ; return ( HTC_S_COMPLETE ) ; } if ( hs == HTC_S_MORE ) { if ( t1 != NULL && isnan ( * t1 ) ) * t1 = now ; } else if ( hs == HTC_S_EMPTY ) htc -> rxbuf_e = htc -> rxbuf_b ; else WRONG ( "htc_status_e" ) ; tmo = tn - now ; <S2SV_StartBug> if ( ! isnan ( ti ) && ti < tn ) <S2SV_EndBug> tmo = ti - now ; z = maxbytes - ( htc -> rxbuf_e - htc -> rxbuf_b ) ; assert ( z >= 0 ) ; if ( z == 0 ) { WS_ReleaseP ( htc -> ws , htc -> rxbuf_b ) ; return ( HTC_S_OVERFLOW ) ; } if ( tmo <= 0.0 ) tmo = 1e-3 ; z = VTCP_read ( * htc -> rfd , htc -> rxbuf_e , z , tmo ) ; if ( z == 0 || z == - 1 ) { WS_ReleaseP ( htc -> ws , htc -> rxbuf_b ) ; return ( HTC_S_EOF ) ; } else if ( z > 0 ) htc -> rxbuf_e += z ; else if ( z == - 2 ) { if ( hs == HTC_S_EMPTY && ti <= now ) { WS_ReleaseP ( htc -> ws , htc -> rxbuf_b ) ; return ( HTC_S_IDLE ) ; } if ( tn <= now ) { WS_ReleaseP ( htc -> ws , htc -> rxbuf_b ) ; return ( HTC_S_TIMEOUT ) ; } } } } | <S2SV_ModStart> ti < tn && hs == HTC_S_EMPTY |
6,903 | CWE-000 static PyObject * _crc16_sick ( PyObject * self , PyObject * args ) { const unsigned char * data = NULL ; unsigned int data_len = 0x00000000L ; unsigned short crc16 = 0x0000 ; unsigned short result = 0x0000 ; # if PY_MAJOR_VERSION >= 3 <S2SV_StartBug> if ( ! PyArg_ParseTuple ( args , "y#|I" , & data , & data_len , & crc16 ) ) <S2SV_EndBug> return NULL ; # else <S2SV_StartBug> if ( ! PyArg_ParseTuple ( args , "s#|I" , & data , & data_len , & crc16 ) ) <S2SV_EndBug> return NULL ; # endif result = hz_calc_crc16_sick ( data , data_len , crc16 ) ; <S2SV_StartBug> return Py_BuildValue ( "I" , result ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( args , "y#|H" <S2SV_ModEnd> , & data <S2SV_ModStart> ( args , "s#|H" <S2SV_ModEnd> , & data <S2SV_ModStart> return Py_BuildValue ( "H" <S2SV_ModEnd> , result ) |
6,904 | CWE-000 int get_width ( t_m * m ) { int w ; int l ; int a ; w = 0 ; if ( ( a = ( m -> format [ m -> pos_f ] == '*' ) ) ) m -> place -> width = ( w = va_arg ( m -> ap , int ) ) ; else if ( m -> format [ m -> pos_f ] >= '0' && m -> format [ m -> pos_f ] <= '9' ) m -> place -> width = ( w = ft_atoi ( m -> format + m -> pos_f ) ) ; <S2SV_StartBug> l = 1 ; <S2SV_EndBug> while ( w /= 10 && ! a ) l ++ ; m -> pos_f += l ; return ( l ) ; } | <S2SV_ModStart> ) ) ; else return ( 0 ) ; |
6,905 | CWE-000 PHP_FUNCTION ( trie_filter_free ) { Trie * trie ; <S2SV_StartBug> zval * trie_resource ; <S2SV_EndBug> int resource_id ; if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , "r" , & trie_resource ) == FAILURE ) { RETURN_FALSE ; } ZEND_FETCH_RESOURCE ( trie , Trie * , & trie_resource , - 1 , PHP_TRIE_FILTER_RES_NAME , le_trie_filter ) ; <S2SV_StartBug> resource_id = Z_RESVAL_P ( trie_resource ) ; <S2SV_EndBug> if ( zend_list_delete ( resource_id ) == SUCCESS ) { RETURN_TRUE ; } <S2SV_StartBug> RETURN_FALSE ; <S2SV_EndBug> } | <S2SV_ModStart> zval * trie_resource <S2SV_ModEnd> ; if ( <S2SV_ModStart> le_trie_filter ) ; zend_hash_index_del ( & EG ( regular_list ) , <S2SV_ModEnd> Z_RESVAL_P ( trie_resource <S2SV_ModStart> ( trie_resource ) ) ; <S2SV_ModEnd> RETURN_TRUE ; } <S2SV_ModStart> RETURN_TRUE ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
6,906 | CWE-000 int is_greater_mint_in ( mint * numa , mint * numb ) { <S2SV_StartBug> unsigned long sizea = size_mint ( numa ) ; <S2SV_EndBug> <S2SV_StartBug> unsigned long sizeb = size_mint ( numb ) ; <S2SV_EndBug> unsigned long count = max ( sizea , sizeb ) ; while ( count -- ) { mint_cell numca = get_mint ( count , 0 , numa ) ; mint_cell numcb = get_mint ( count , 0 , numb ) ; if ( numca == 0 && numcb == 0 ) continue ; if ( numca > numcb ) return 1 ; return 0 ; } return 0 ; } | <S2SV_ModStart> long sizea = real_size_mint <S2SV_ModEnd> ( numa ) <S2SV_ModStart> long sizeb = real_size_mint <S2SV_ModEnd> ( numb ) |
6,907 | CWE-000 <S2SV_StartBug> static int s_exec_display ( t_proc * p ) <S2SV_EndBug> { if ( option_is_set ( & p -> bltin_opt_head , ST_BLTIN_ENV_OPT_I ) == 1 ) { ft_memdel_tab ( ( void * * * ) & p -> envp ) ; if ( ( p -> envp = ( char * * ) malloc ( sizeof ( char * ) * 1 ) ) == NULL ) return ( ST_MALLOC ) ; p -> envp [ 0 ] = NULL ; } if ( option_is_set ( & p -> bltin_opt_head , ST_BLTIN_ENV_OPT_U ) == 1 ) s_remove_variables ( & p -> envp , option_get_values ( & p -> bltin_opt_head , ST_BLTIN_ENV_OPT_U ) ) ; p -> argc -- ; ft_array_pop ( & p -> argv , 0 , 1 ) ; <S2SV_StartBug> env_or_var_update_from_cmd_line ( & p , NULL ) ; <S2SV_EndBug> if ( p -> argc == 0 ) { while ( * p -> envp ) { ft_putendl_fd ( * p -> envp , STDOUT_FILENO ) ; p -> envp ++ ; } exit ( EXIT_SUCCESS ) ; } return ( ST_OK ) ; } | <S2SV_ModStart> t_proc * p , t_sh * sh <S2SV_ModStart> & p , & sh <S2SV_ModEnd> ) ; if |
6,908 | CWE-000 int searchreg ( reg * regout , char * searchstr , char * filepath ) { FILE * fp = fopen ( filepath , "rb" ) ; char block_temp [ BLKSIZE ] ; char reg_temp [ REGSIZE ] ; char buffer [ 128 ] ; if ( ! fp ) return 0 ; else { while ( fread ( block_temp , BLKSIZE , 1 , fp ) ) { <S2SV_StartBug> if ( ! strncmp ( block_temp , "#!" , 2 ) ) { <S2SV_EndBug> int OFFBLK = 2 ; int found = 0 ; while ( OFFBLK < BLKSIZE && ! found ) { <S2SV_StartBug> if ( strncmp ( block_temp + OFFBLK , "\\x7F" , 1 ) && strncmp ( block_temp + OFFBLK , "\\0" , 1 ) ) { <S2SV_EndBug> int OFFREG = 0 ; memcpy ( reg_temp , block_temp + OFFBLK , REGSIZE ) ; memset ( buffer , 0 , sizeof ( buffer ) ) ; memcpy ( buffer , reg_temp + OFFREG , KEYSIZE ) ; found = ( ! strncmp ( buffer , searchstr , strlen ( searchstr ) ) ) ? 1 : 0 ; OFFREG += KEYSIZE ; memset ( buffer , 0 , sizeof ( buffer ) ) ; memcpy ( buffer , reg_temp + OFFREG , TITLESIZE ) ; found = ( found == 1 ) ? 1 : teststr ( buffer , searchstr , "<S2SV_blank>" ) ; OFFREG += TITLESIZE ; memset ( buffer , 0 , sizeof ( buffer ) ) ; memcpy ( buffer , reg_temp + OFFREG , AUTHORSIZE ) ; found = ( found == 1 ) ? 1 : teststr ( buffer , searchstr , "<S2SV_blank>" ) ; OFFREG += AUTHORSIZE ; memset ( buffer , 0 , sizeof ( buffer ) ) ; memcpy ( buffer , reg_temp + OFFREG , LINKSIZE ) ; found = ( found == 1 ) ? 1 : teststr ( buffer , searchstr , "." ) ; } OFFBLK += REGSIZE ; if ( found ) { int OFFREG = 0 ; memcpy ( regout -> key , reg_temp + OFFREG , KEYSIZE ) ; OFFREG += KEYSIZE ; memcpy ( regout -> title , reg_temp + OFFREG , TITLESIZE ) ; OFFREG += TITLESIZE ; memcpy ( regout -> author , reg_temp + OFFREG , AUTHORSIZE ) ; OFFREG += AUTHORSIZE ; memcpy ( regout -> link , reg_temp + OFFREG , LINKSIZE ) ; fclose ( fp ) ; return 1 ; } } } else { printf ( "Block<S2SV_blank>consistence<S2SV_blank>bit<S2SV_blank>unconfirmed,<S2SV_blank>file<S2SV_blank>might<S2SV_blank>have<S2SV_blank>been<S2SV_blank>corrupted.\\n" ) ; } } fclose ( fp ) ; return 0 ; } } | <S2SV_ModStart> { if ( block_temp [ 0 ] == '#' && block_temp [ 1 ] == '!' <S2SV_ModEnd> ) { int <S2SV_ModStart> { if ( ! ( block_temp [ OFFBLK ] == '\\x7F' ) && ! ( block_temp [ OFFBLK ] == 0 <S2SV_ModEnd> ) ) { |
6,909 | CWE-000 static void rc_random_vector ( unsigned char * vector ) { int randno ; int i ; # if defined ( HAVE_GNUTLS ) if ( gnutls_rnd ( GNUTLS_RND_NONCE , vector , AUTH_VECTOR_LEN ) >= 0 ) { return ; } # elif defined ( HAVE_GETENTROPY ) if ( getentropy ( vector , AUTH_VECTOR_LEN ) >= 0 ) { return ; } # elif defined ( HAVE_DEV_URANDOM ) int fd ; if ( ( fd = open ( _PATH_DEV_URANDOM , O_RDONLY ) ) >= 0 ) { unsigned char * pos ; int readcount ; i = AUTH_VECTOR_LEN ; pos = vector ; while ( i > 0 ) { readcount = read ( fd , ( char * ) pos , i ) ; if ( readcount >= 0 ) { pos += readcount ; i -= readcount ; } else { if ( errno != EINTR && errno != EAGAIN ) goto fallback ; } } close ( fd ) ; return ; } <S2SV_StartBug> # endif <S2SV_EndBug> fallback : for ( i = 0 ; i < AUTH_VECTOR_LEN ; ) { randno = random ( ) ; memcpy ( ( char * ) vector , ( char * ) & randno , sizeof ( int ) ) ; vector += sizeof ( int ) ; i += sizeof ( int ) ; } return ; } | <S2SV_ModStart> return ; } fallback : # endif <S2SV_ModEnd> for ( i |
6,910 | CWE-000 static void pc_1245_keyrelease ( uint16_t key ) { keyboard_count . id = 0 ; keyboard_count . kbd = 0 ; keyboard_count . count = 0 ; if ( key < 0x20 ) return ; if ( ( key >= 0x20 ) && ( key < 0xB0 ) ) porta_kbd [ key_map [ key - 0x20 ] . row ] &= ~ ( key_map [ key - 0x20 ] . mask ) ; switch ( key ) { case 0xFF0D : porta_kbd [ KEYBOARD_PORTA_INDEX_A6 ] &= ~ KEYBOARD_PORTA_BIT_A8 ; break ; case 0xFF52 : porta_kbd [ KEYBOARD_PORTA_INDEX_A1 ] &= ~ KEYBOARD_PORTA_BIT_A5 ; break ; case 0xFF54 : porta_kbd [ KEYBOARD_PORTB_INDEX_B1 ] &= ~ KEYBOARD_PORTA_BIT_A5 ; break ; case 0xFF51 : porta_kbd [ KEYBOARD_PORTA_INDEX_A2 ] &= ~ KEYBOARD_PORTA_BIT_A5 ; break ; case 0xFF53 : porta_kbd [ KEYBOARD_PORTA_INDEX_A3 ] &= ~ KEYBOARD_PORTA_BIT_A5 ; break ; case 0xFFAB : porta_kbd [ KEYBOARD_PORTB_INDEX_B2 ] &= ~ KEYBOARD_PORTA_BIT_A1 ; break ; case 0xFFE1 : case 0xFFE2 : porta_kbd [ KEYBOARD_PORTB_INDEX_B2 ] &= ~ KEYBOARD_PORTA_BIT_A5 ; break ; <S2SV_StartBug> default : <S2SV_EndBug> g_print ( "Unhandled<S2SV_blank>Key<S2SV_blank>Released<S2SV_blank>-<S2SV_blank>%04X,<S2SV_blank>(%d)\\r\\n" , key , ( int16_t ) key ) ; break ; } } | <S2SV_ModStart> ; break ; case 0xFFFF : porta_kbd [ KEYBOARD_PORTB_INDEX_B1 ] &= ~ KEYBOARD_PORTA_BIT_A2 ; break ; |
6,911 | CWE-000 int patch_Boot2 ( ) { # ifndef CAS_OS puts ( "Non-CAS<S2SV_blank>OS<S2SV_blank>mode" ) ; # else puts ( "CAS<S2SV_blank>OS<S2SV_blank>mode" ) ; # endif uint32_t id = * ( ( uint32_t * ) ( 0x11800020 ) ) ; uint8_t index = getBoot2Index ( id ) ; if ( index < NBOOT2 ) { if ( boot2_patches [ index ] [ IB2_B2VER ] ) { <S2SV_StartBug> PATCH_SETW ( 0xA4012EB4 , 0x04040008 ) ; <S2SV_EndBug> PATCH_SETW ( boot2_patches [ index ] [ IB2_B2VER ] , 0 ) ; } if ( boot2_patches [ index ] [ IB2_NBOOT ] ) PATCH_SETW ( boot2_patches [ index ] [ IB2_NBOOT ] , 0 ) ; <S2SV_StartBug> # define CAS_OS <S2SV_EndBug> # ifndef CAS_OS uint32_t fakeasic1 = 0 ; uint32_t fakeasic2 = 0xE3A04000 ; # define modelid 0x10 # else # define modelid 0x0F uint32_t fakeasic1 = 0x00010105 ; uint32_t fakeasic2 = 0xE3A04341 ; # endif if ( boot2_patches [ index ] [ IB2_MANUF ] ) PATCH_SETW ( boot2_patches [ index ] [ IB2_MANUF ] , 0xE3A00000 | modelid ) ; if ( boot2_patches [ index ] [ IB2_ASIC ] ) { PATCH_SETB ( boot2_patches [ index ] [ IB2_ASIC ] , 0x54 ) ; PATCH_SETW ( boot2_patches [ index ] [ IB2_ASIC ] + 0x17 , fakeasic2 ) ; PATCH_SETW ( boot2_patches [ index ] [ IB2_ASIC ] + 0x1B , NOP ) ; PATCH_SETW ( boot2_patches [ index ] [ IB2_ASIC ] + 0x48B , fakeasic1 ) ; } return 1 ; } else { return 0 ; } } | <S2SV_ModStart> ( 0xA4012EB4 , 0x04400008 <S2SV_ModEnd> ) ; PATCH_SETW <S2SV_ModStart> 0 ) ; <S2SV_ModEnd> # ifndef CAS_OS |
6,912 | CWE-000 struct nc_server_reply * op_validate ( struct lyd_node * rpc , struct nc_session * ncs ) { struct np2_sessions * sessions ; struct ly_set * nodeset = NULL ; struct nc_server_error * e = NULL ; <S2SV_StartBug> struct nc_server_reply * ereply ; <S2SV_EndBug> struct lyd_node * config = NULL ; struct lyd_node_anydata * any ; const char * dsname ; sr_datastore_t ds = SR_DS_CANDIDATE ; sessions = ( struct np2_sessions * ) nc_session_get_data ( ncs ) ; if ( np2srv_sr_check_exec_permission ( sessions -> srs , "/ietf-netconf:validate" , & ereply ) ) { goto finish ; } nodeset = lyd_find_path ( rpc , "/ietf-netconf:validate/source/*" ) ; dsname = nodeset -> set . d [ 0 ] -> schema -> name ; if ( ! strcmp ( dsname , "running" ) ) { ds = SR_DS_RUNNING ; } else if ( ! strcmp ( dsname , "startup" ) ) { ds = SR_DS_STARTUP ; } else if ( ! strcmp ( dsname , "candidate" ) ) { ds = SR_DS_CANDIDATE ; } else if ( ! strcmp ( dsname , "config" ) ) { any = ( struct lyd_node_anydata * ) nodeset -> set . d [ 0 ] ; ly_errno = LY_SUCCESS ; switch ( any -> value_type ) { case LYD_ANYDATA_CONSTSTRING : case LYD_ANYDATA_STRING : case LYD_ANYDATA_SXML : config = lyd_parse_mem ( np2srv . ly_ctx , any -> value . str , LYD_XML , LYD_OPT_CONFIG | LYD_OPT_DESTRUCT | LYD_OPT_STRICT ) ; break ; case LYD_ANYDATA_DATATREE : config = any -> value . tree ; any -> value . tree = NULL ; lyd_validate ( & config , LYD_OPT_CONFIG , np2srv . ly_ctx ) ; break ; case LYD_ANYDATA_XML : config = lyd_parse_xml ( np2srv . ly_ctx , & any -> value . xml , LYD_OPT_CONFIG | LYD_OPT_DESTRUCT | LYD_OPT_STRICT ) ; break ; case LYD_ANYDATA_JSON : case LYD_ANYDATA_JSOND : case LYD_ANYDATA_SXMLD : EINT ; e = nc_err ( NC_ERR_OP_FAILED , NC_ERR_TYPE_APP ) ; nc_err_set_msg ( e , np2log_lasterr ( np2srv . ly_ctx ) , "en" ) ; ereply = nc_server_reply_err ( e ) ; goto finish ; } lyd_free_withsiblings ( config ) ; if ( ly_errno != LY_SUCCESS ) { e = nc_err_libyang ( np2srv . ly_ctx ) ; ereply = nc_server_reply_err ( e ) ; goto finish ; } ereply = nc_server_reply_ok ( ) ; goto finish ; } if ( ds != sessions -> ds ) { if ( np2srv_sr_session_switch_ds ( sessions -> srs , ds , & ereply ) ) { goto finish ; } sessions -> ds = ds ; } if ( ds != SR_DS_CANDIDATE ) { if ( np2srv_sr_session_refresh ( sessions -> srs , & ereply ) ) { goto finish ; } } if ( np2srv_sr_validate ( sessions -> srs , & ereply ) ) { goto finish ; } ereply = nc_server_reply_ok ( ) ; finish : ly_set_free ( nodeset ) ; return ereply ; } | <S2SV_ModStart> nc_server_reply * ereply = NULL |
6,913 | CWE-000 static RSdpResult <S2SV_StartBug> r_sdp_bandwidth_parse ( RStrKV * bandwidth , rchar * str , rsize size ) <S2SV_EndBug> { <S2SV_StartBug> return r_str_kv_parse ( bandwidth , str , size , ":" , NULL ) == R_STR_PARSE_OK ? <S2SV_EndBug> R_SDP_OK : R_SDP_BAD_DATA ; } | <S2SV_ModStart> ( RStrKV * bw <S2SV_ModEnd> , rchar * <S2SV_ModStart> return r_str_kv_parse ( bw <S2SV_ModEnd> , str , |
6,914 | CWE-000 int intel_modeset_init ( struct drm_device * dev ) { struct drm_i915_private * dev_priv = to_i915 ( dev ) ; struct i915_ggtt * ggtt = & dev_priv -> ggtt ; enum pipe pipe ; <S2SV_StartBug> struct intel_crtc * crtc ; <S2SV_EndBug> dev_priv -> modeset_wq = alloc_ordered_workqueue ( "i915_modeset" , 0 ) ; drm_mode_config_init ( dev ) ; dev -> mode_config . min_width = 0 ; dev -> mode_config . min_height = 0 ; dev -> mode_config . preferred_depth = 24 ; dev -> mode_config . prefer_shadow = 1 ; dev -> mode_config . allow_fb_modifiers = true ; dev -> mode_config . funcs = & intel_mode_funcs ; init_llist_head ( & dev_priv -> atomic_helper . free_list ) ; INIT_WORK ( & dev_priv -> atomic_helper . free_work , intel_atomic_helper_free_state_worker ) ; intel_init_quirks ( dev ) ; intel_init_pm ( dev_priv ) ; if ( INTEL_INFO ( dev_priv ) -> num_pipes == 0 ) return 0 ; if ( HAS_PCH_IBX ( dev_priv ) || HAS_PCH_CPT ( dev_priv ) ) { bool bios_lvds_use_ssc = ! ! ( I915_READ ( PCH_DREF_CONTROL ) & DREF_SSC1_ENABLE ) ; if ( dev_priv -> vbt . lvds_use_ssc != bios_lvds_use_ssc ) { DRM_DEBUG_KMS ( "SSC<S2SV_blank>%sabled<S2SV_blank>by<S2SV_blank>BIOS,<S2SV_blank>overriding<S2SV_blank>VBT<S2SV_blank>which<S2SV_blank>says<S2SV_blank>%sabled\\n" , bios_lvds_use_ssc ? "en" : "dis" , dev_priv -> vbt . lvds_use_ssc ? "en" : "dis" ) ; dev_priv -> vbt . lvds_use_ssc = bios_lvds_use_ssc ; } } if ( IS_GEN2 ( dev_priv ) ) { dev -> mode_config . max_width = 2048 ; dev -> mode_config . max_height = 2048 ; } else if ( IS_GEN3 ( dev_priv ) ) { dev -> mode_config . max_width = 4096 ; dev -> mode_config . max_height = 4096 ; } else { dev -> mode_config . max_width = 8192 ; dev -> mode_config . max_height = 8192 ; } if ( IS_I845G ( dev_priv ) || IS_I865G ( dev_priv ) ) { dev -> mode_config . cursor_width = IS_I845G ( dev_priv ) ? 64 : 512 ; dev -> mode_config . cursor_height = 1023 ; } else if ( IS_GEN2 ( dev_priv ) ) { dev -> mode_config . cursor_width = 64 ; dev -> mode_config . cursor_height = 64 ; } else { dev -> mode_config . cursor_width = 256 ; dev -> mode_config . cursor_height = 256 ; } dev -> mode_config . fb_base = ggtt -> gmadr . start ; DRM_DEBUG_KMS ( "%d<S2SV_blank>display<S2SV_blank>pipe%s<S2SV_blank>available.\\n" , INTEL_INFO ( dev_priv ) -> num_pipes , INTEL_INFO ( dev_priv ) -> num_pipes > 1 ? "s" : "" ) ; for_each_pipe ( dev_priv , pipe ) { <S2SV_StartBug> int ret ; <S2SV_EndBug> ret = intel_crtc_init ( dev_priv , pipe ) ; if ( ret ) { drm_mode_config_cleanup ( dev ) ; return ret ; } } intel_shared_dpll_init ( dev ) ; intel_update_fdi_pll_freq ( dev_priv ) ; intel_update_czclk ( dev_priv ) ; intel_modeset_init_hw ( dev ) ; if ( dev_priv -> max_cdclk_freq == 0 ) intel_update_max_cdclk ( dev_priv ) ; i915_disable_vga ( dev_priv ) ; intel_setup_outputs ( dev_priv ) ; drm_modeset_lock_all ( dev ) ; intel_modeset_setup_hw_state ( dev , dev -> mode_config . acquire_ctx ) ; drm_modeset_unlock_all ( dev ) ; for_each_intel_crtc ( dev , crtc ) { struct intel_initial_plane_config plane_config = { } ; if ( ! crtc -> active ) continue ; dev_priv -> display . get_initial_plane_config ( crtc , & plane_config ) ; intel_find_initial_plane_obj ( crtc , & plane_config ) ; } if ( ! HAS_GMCH_DISPLAY ( dev_priv ) ) sanitize_watermarks ( dev ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> intel_crtc * crtc ; int ret <S2SV_ModStart> pipe ) { <S2SV_ModEnd> ret = intel_crtc_init <S2SV_ModStart> dev ) ; ret = intel_initial_commit ( dev ) ; if ( ret ) DRM_DEBUG_KMS ( "Initial<S2SV_blank>commit<S2SV_blank>in<S2SV_blank>probe<S2SV_blank>failed.\\n" ) ; |
6,915 | CWE-000 void session_deinit ( void ) { FUNC_CALL_ENTRY ; if ( session_exist_status == ESTABLISHED ) { ASE_INFO ( "Deinitializing<S2SV_blank>simulation<S2SV_blank>session<S2SV_blank>\\n" ) ; session_exist_status = NOT_ESTABLISHED ; if ( umas_exist_status == ESTABLISHED ) { ASE_MSG ( "Closing<S2SV_blank>Watcher<S2SV_blank>threads\\n" ) ; umas_exist_status = NOT_ESTABLISHED ; pthread_cancel ( umsg_watch_tid ) ; ASE_MSG ( "Deallocating<S2SV_blank>UMAS\\n" ) ; deallocate_buffer ( umas_region ) ; } # ifdef ASE_DEBUG else { ASE_MSG ( "No<S2SV_blank>UMAS<S2SV_blank>established\\n" ) ; } # endif ASE_MSG ( "Deallocating<S2SV_blank>MMIO<S2SV_blank>map\\n" ) ; if ( mmio_exist_status == ESTABLISHED ) { deallocate_buffer ( mmio_region ) ; mmio_exist_status = NOT_ESTABLISHED ; if ( pthread_cancel ( mmio_watch_tid ) != 0 ) { printf ( "MMIO<S2SV_blank>pthread_cancel<S2SV_blank>failed<S2SV_blank>--<S2SV_blank>Ignoring\\n" ) ; } <S2SV_StartBug> } <S2SV_EndBug> ase_portctrl ( ASE_SIMKILL , 0 ) ; # ifdef ASE_DEBUG fclose ( fp_pagetable_log ) ; fclose ( fp_mmioaccess_log ) ; # endif } else { ASE_MSG ( "Session<S2SV_blank>already<S2SV_blank>deinitialized,<S2SV_blank>call<S2SV_blank>ignored<S2SV_blank>!\\n" ) ; } mqueue_close ( app2sim_mmioreq_tx ) ; mqueue_close ( sim2app_mmiorsp_rx ) ; mqueue_close ( app2sim_alloc_tx ) ; mqueue_close ( sim2app_alloc_rx ) ; mqueue_close ( app2sim_umsg_tx ) ; mqueue_close ( app2sim_portctrl_req_tx ) ; mqueue_close ( app2sim_dealloc_tx ) ; mqueue_close ( sim2app_dealloc_rx ) ; mqueue_close ( sim2app_portctrl_rsp_rx ) ; if ( pthread_mutex_unlock ( & mmio_port_lock ) != 0 ) { ASE_MSG ( "Trying<S2SV_blank>to<S2SV_blank>shutdown<S2SV_blank>mutex<S2SV_blank>unlock\\n" ) ; } pthread_cancel ( umsg_watch_tid ) ; pthread_join ( umsg_watch_tid , NULL ) ; pthread_cancel ( mmio_watch_tid ) ; pthread_join ( mmio_watch_tid , NULL ) ; clock_gettime ( CLOCK_MONOTONIC , & end_time_snapshot ) ; runtime_nsec = 1e9 * ( end_time_snapshot . tv_sec - start_time_snapshot . tv_sec ) + ( end_time_snapshot . tv_nsec - start_time_snapshot . tv_nsec ) ; char * oldLocale = setlocale ( LC_NUMERIC , NULL ) ; setlocale ( LC_NUMERIC , "" ) ; ASE_INFO ( "\\tTook<S2SV_blank>%\'llu<S2SV_blank>nsec<S2SV_blank>\\n" , runtime_nsec ) ; setlocale ( LC_NUMERIC , oldLocale ) ; <S2SV_StartBug> free_buffers ( ) ; <S2SV_EndBug> if ( access ( app_ready_lockpath , F_OK ) == 0 ) { if ( unlink ( app_ready_lockpath ) == 0 ) { ASE_INFO ( "Session<S2SV_blank>ended<S2SV_blank>\\n" ) ; } } FUNC_CALL_EXIT ; } | <S2SV_ModStart> ; } } free_buffers ( ) ; <S2SV_ModStart> oldLocale ) ; <S2SV_ModEnd> if ( access |
6,916 | CWE-000 static void process_linkages ( Sentence sent , extractor_t * pex , bool overflowed , Parse_Options opts ) { if ( 0 == sent -> num_linkages_found ) return ; bool pick_randomly = overflowed || ( sent -> num_linkages_found > ( int ) sent -> num_linkages_alloced ) ; sent -> num_valid_linkages = 0 ; size_t N_invalid_morphism = 0 ; size_t itry = 0 ; size_t in = 0 ; <S2SV_StartBug> size_t maxtries = sent -> num_linkages_alloced ; <S2SV_EndBug> if ( pick_randomly ) maxtries = sent -> num_linkages_found ; # define MAX_TRIES 250000 <S2SV_StartBug> if ( MAX_TRIES < maxtries ) maxtries = MAX_TRIES ; <S2SV_EndBug> bool need_init = true ; for ( itry = 0 ; itry < maxtries ; itry ++ ) { Linkage lkg = & sent -> lnkages [ in ] ; Linkage_info * lifo = & lkg -> lifo ; lifo -> index = pick_randomly ? - ( itry + 1 ) : itry ; if ( need_init ) { partial_init_linkage ( sent , lkg , sent -> length ) ; need_init = false ; } extract_links ( pex , lkg ) ; compute_link_names ( lkg , sent -> string_set ) ; remove_empty_words ( lkg ) ; if ( sane_linkage_morphism ( sent , lkg , opts ) ) { need_init = true ; in ++ ; sent -> num_valid_linkages ++ ; if ( in >= sent -> num_linkages_alloced ) break ; } else { N_invalid_morphism ++ ; lkg -> num_links = 0 ; lkg -> num_words = sent -> length ; memset ( lkg -> chosen_disjuncts , 0 , sent -> length * sizeof ( Disjunct * ) ) ; } } if ( ! need_init ) free_linkage ( & sent -> lnkages [ in ] ) ; sent -> num_linkages_alloced = sent -> num_valid_linkages ; if ( verbosity_level ( 5 ) ) { prt_error ( "Info:<S2SV_blank>sane_morphism():<S2SV_blank>%zu<S2SV_blank>of<S2SV_blank>%zu<S2SV_blank>linkages<S2SV_blank>had<S2SV_blank>" "invalid<S2SV_blank>morphology<S2SV_blank>construction\\n" , N_invalid_morphism , sent -> num_linkages_alloced ) ; } } | <S2SV_ModStart> ; size_t maxtries <S2SV_ModEnd> ; # define <S2SV_ModStart> 250000 if ( pick_randomly ) { maxtries = MIN ( ( int ) sent -> num_linkages_alloced + MAX_TRIES , sent -> num_linkages_found ) ; } else { maxtries = sent -> num_linkages_alloced ; } <S2SV_ModEnd> bool need_init = |
6,917 | CWE-000 void store_list ( struct record * head , FILE * infile ) { struct record * current = head ; <S2SV_StartBug> while ( current -> next != NULL ) <S2SV_EndBug> { fprintf ( infile , "%s,%s,%s,%s,%d:%d,%d,%d\\n" , current -> artist , current -> album , current -> title , current -> genre , current -> length . minutes , current -> length . seconds , current -> num_plays , current -> rating ) ; <S2SV_StartBug> current = current -> next ; <S2SV_EndBug> } } | <S2SV_ModStart> current -> next != NULL ) { current = current -> next ; } while ( current -> previous <S2SV_ModStart> = current -> previous <S2SV_ModEnd> ; } } |
6,918 | CWE-000 char * * ft_strsplit ( char const * str , char c ) { char * * ptr ; char * temp ; int size ; if ( ! str ) return ( NULL ) ; temp = ft_strnew ( ft_strlen ( str ) ) ; size = ft_strcleanup ( str , temp , c ) ; ptr = ( char * * ) malloc ( sizeof ( char * ) * ( size + 1 ) ) ; <S2SV_StartBug> if ( ! ptr || ! temp ) <S2SV_EndBug> return ( NULL ) ; <S2SV_StartBug> if ( str [ 0 ] == '\\0' || size == 1 ) <S2SV_EndBug> { ptr [ 0 ] = 0 ; <S2SV_StartBug> return ( ptr ) ; <S2SV_EndBug> } split ( temp , ptr , c ) ; <S2SV_StartBug> int i ; <S2SV_EndBug> i = 0 ; return ( ptr ) ; } | <S2SV_ModStart> ) ) ; ptr [ size + 1 ] = 0 ; <S2SV_ModStart> ] == '\\0' ) <S2SV_ModEnd> ptr [ 0 <S2SV_ModStart> = 0 ; else if ( size == 1 ) ptr [ 0 ] = temp ; else <S2SV_ModEnd> split ( temp <S2SV_ModStart> c ) ; <S2SV_ModEnd> return ( ptr |
6,919 | CWE-000 static void defineNativeClasses ( void ) { ObjClass * objClass = addGlobalClass ( "Object" , NULL ) ; addNativeMethod ( objClass , "dup" , lxObjectDup ) ; addNativeGetter ( objClass , "_class" , lxObjectGetClass ) ; addNativeGetter ( objClass , "objectId" , lxObjectGetObjectId ) ; lxObjClass = objClass ; ObjClass * modClass = addGlobalClass ( "Module" , objClass ) ; lxModuleClass = modClass ; ObjClass * classClass = addGlobalClass ( "Class" , objClass ) ; lxClassClass = classClass ; objClass -> klass = classClass ; modClass -> klass = classClass ; classClass -> klass = classClass ; Init_StringClass ( ) ; addNativeMethod ( classClass , "init" , lxClassInit ) ; addNativeMethod ( classClass , "include" , lxClassInclude ) ; addNativeGetter ( classClass , "_superClass" , lxClassGetSuperclass ) ; addNativeGetter ( classClass , "name" , lxClassGetName ) ; <S2SV_StartBug> Init_ArrayClass ( ) ; <S2SV_EndBug> Init_MapClass ( ) ; ObjClass * iterClass = addGlobalClass ( "Iterator" , objClass ) ; lxIteratorClass = iterClass ; addNativeMethod ( iterClass , "init" , lxIteratorInit ) ; addNativeMethod ( iterClass , "next" , lxIteratorNext ) ; ObjClass * errClass = addGlobalClass ( "Error" , objClass ) ; lxErrClass = errClass ; addNativeMethod ( errClass , "init" , lxErrInit ) ; ObjClass * argErrClass = addGlobalClass ( "ArgumentError" , errClass ) ; lxArgErrClass = argErrClass ; ObjClass * typeErrClass = addGlobalClass ( "TypeError" , errClass ) ; lxTypeErrClass = typeErrClass ; ObjClass * nameErrClass = addGlobalClass ( "NameError" , errClass ) ; lxNameErrClass = nameErrClass ; ObjClass * syntaxErrClass = addGlobalClass ( "SyntaxError" , errClass ) ; lxSyntaxErrClass = syntaxErrClass ; ObjClass * loadErrClass = addGlobalClass ( "LoadError" , errClass ) ; lxLoadErrClass = loadErrClass ; ObjClass * threadClass = addGlobalClass ( "Thread" , objClass ) ; lxThreadClass = threadClass ; ObjModule * GCModule = addGlobalModule ( "GC" ) ; ObjClass * GCClassStatic = moduleSingletonClass ( GCModule ) ; addNativeMethod ( GCClassStatic , "stats" , lxGCStats ) ; addNativeMethod ( GCClassStatic , "collect" , lxGCCollect ) ; lxGCModule = GCModule ; Init_ProcessModule ( ) ; Init_FileClass ( ) ; Init_IOModule ( ) ; } | <S2SV_ModStart> lxClassGetName ) ; addNativeMethod ( modClass , "init" , lxModuleInit ) ; |
6,920 | CWE-000 void clavier ( unsigned char touche , int x , int y ) { <S2SV_StartBug> int o ; <S2SV_EndBug> switch ( touche ) { case 'q' : angle -= 0.05 ; visX = sin ( angle ) ; visZ = - cos ( angle ) ; break ; case 'd' : angle += 0.05 ; visX = sin ( angle ) ; visZ = - cos ( angle ) ; break ; case 'z' : if ( appartient ( posX + visX * 0.3 , posZ + visZ * 0.3 ) == TRUE ) break ; o = toucheObjectif ( posX + visX * 0.3 , posZ + visZ * 0.3 ) ; if ( o > - 1 ) { objectif_liste [ o ] . cache = FALSE ; objectifFin ( ) ; } if ( dansPlateau ( posX + visX * 0.3 , posZ + visZ * 0.3 ) == TRUE ) { posX += visX * 0.3 ; posZ += visZ * 0.3 ; } break ; case 's' : if ( appartient ( posX - visX * 0.3 , posZ - visZ * 0.3 ) == TRUE ) break ; o = toucheObjectif ( posX - visX * 0.3 , posZ - visZ * 0.3 ) ; if ( o > - 1 ) { objectif_liste [ o ] . cache = FALSE ; objectifFin ( ) ; } if ( dansPlateau ( posX - visX * 0.3 , posZ - visZ * 0.3 ) == TRUE ) { posX -= visX * 0.3 ; posZ -= visZ * 0.3 ; } break ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> y ) { if ( perdu == FALSE && finDuJeu == FALSE ) { <S2SV_ModStart> ; } } } |
6,921 | CWE-000 int sfs_releasedir ( const char * path , struct fuse_file_info * fi ) { int retstat = 0 ; <S2SV_StartBug> << << << < HEAD <S2SV_EndBug> == == == = >> >> >> > 8d02090126b3a28a5b7c34ed22f4e1c04a806879 return retstat ; } | <S2SV_ModStart> = 0 ; <S2SV_ModEnd> return retstat ; |
6,922 | CWE-000 FL_STATE GameTargetsReached ( uint16_t firstTarget , uint8_t index ) { FL_STATE retState = STATE_IDLE ; uint8_t i ; switch ( FlightData . State [ index ] ) { case STATE_FINAL : FlightData . State [ index ] = STATE_LANDED ; for ( i = 0 ; i < GAME_MAX_RUNWAYS ; i ++ ) { if ( GameUsedRwy [ i ] == firstTarget ) { GameUsedRwy [ i ] = 0 ; } } break ; case STATE_TAXIING : if ( FlightData . FlightDirection [ index ] == DEPARTURE ) { FlightData . State [ index ] = STATE_HOLDING_RWY ; } else if ( FlightData . FlightDirection [ index ] == ARRIVAL ) { FlightData . State [ index ] = STATE_UNBOARDING ; } break ; case STATE_TAKEOFF : FlightData . State [ index ] = STATE_CLIMBING ; break ; <S2SV_StartBug> case STATE_HOLDING_RWY : <S2SV_EndBug> FlightData . State [ index ] = STATE_READY_FOR_TAKEOFF ; break ; default : break ; } return retState ; } | <S2SV_ModStart> break ; case STATE_ENTERING_RWY <S2SV_ModEnd> : FlightData . |
6,923 | CWE-000 static int read_wrapper_data ( WavpackContext * wpc , WavpackMetadata * wpmd ) { if ( ( wpc -> open_flags & OPEN_WRAPPER ) && wpc -> wrapper_bytes < MAX_WRAPPER_BYTES && wpmd -> byte_length ) { <S2SV_StartBug> wpc -> wrapper_data = realloc ( wpc -> wrapper_data , wpc -> wrapper_bytes + wpmd -> byte_length ) ; <S2SV_EndBug> if ( ! wpc -> wrapper_data ) return FALSE ; memcpy ( wpc -> wrapper_data + wpc -> wrapper_bytes , wpmd -> data , wpmd -> byte_length ) ; wpc -> wrapper_bytes += wpmd -> byte_length ; } return TRUE ; } | <S2SV_ModStart> -> wrapper_data = ( unsigned char * ) |
6,924 | CWE-000 int ReqServApp ( ) { enum { ini , idle , busy } State ; int fd , newfd , afd ; fd_set rfds ; int maxfd , counter ; maxfd = ( udp_fp > STDIN ) ? udp_fp : STDIN ; while ( 1 ) { FD_ZERO ( & rfds ) ; FD_SET ( udp_fp , & rfds ) ; FD_SET ( STDIN , & rfds ) ; if ( State == busy ) { FD_SET ( afd , & rfds ) ; maxfd = max ( maxfd , afd ) ; } counter = select ( maxfd + 1 , & rfds , ( fd_set * ) NULL , ( fd_set * ) NULL , ( struct timeval * ) NULL ) ; if ( counter <= 0 ) myerr ( 158 , "Failed<S2SV_blank>in<S2SV_blank>appRun()" ) ; if ( FD_ISSET ( STDIN , & rfds ) ) { if ( userIns ( ) ) return 0 ; } if ( FD_ISSET ( udp_fp , & rfds ) ) { switch ( state . state ) { case get : if ( Ans_get_ds_server ( ) ) { my_service_ON ( ) , state . state = myON ; } else { state . state = zero ; } break ; case myON : if ( Ans_myON ( ) ) { printf ( "Service<S2SV_blank>is<S2SV_blank>ON\\n" ) ; state . service = on ; state . state = zero ; } else { state . state = zero ; } case myOFF : if ( Ans_myOFF ( ) ) { printf ( "Service<S2SV_blank>OFF\\n" ) ; state . service = off ; state . state = zero ; } else { state . state = zero ; } break ; default : break ; } } <S2SV_StartBug> return - 1 ; <S2SV_EndBug> } <S2SV_StartBug> void appConfg ( int argc , char * * argv ) { <S2SV_EndBug> int i = 0 ; char * SName = DV_csName ; cspt = DV_cspt ; int argCheck = 0 ; while ( argv [ i ] != NULL ) { if ( strcmp ( argv [ i ] , "-i" ) == 0 && argc > i ) { i ++ ; SName = argv [ i ] ; } else if ( strcmp ( argv [ i ] , "-p" ) == 0 && argc > i ) { i ++ ; cspt = atoi ( argv [ i ] ) ; } i ++ ; } csh = gethostbyname ( SName ) ; if ( csh == NULL ) myerr ( 2 , "Fail<S2SV_blank>to<S2SV_blank>gethostbyname" ) ; csa = ( struct in_addr * ) csh -> h_addr_list [ 0 ] ; fprintf ( stderr , "Service:\\n\\tid:<S2SV_blank>%d\\n\\tip:<S2SV_blank>%s\\n\\tupt:<S2SV_blank>%d\\n\\ttpt:<S2SV_blank>%d\\n" , id , ip , upt , tpt ) ; fprintf ( stderr , "\\nCentralServer:\\n\\t<%s:%d>\\n" , SName , cspt ) ; fprintf ( stderr , "\\tofficial<S2SV_blank>host<S2SV_blank>name:<S2SV_blank>%s\\n" , csh -> h_name ) ; fprintf ( stderr , "\\tinternet<S2SV_blank>address:<S2SV_blank>%s<S2SV_blank>(%08lX)\\n" , inet_ntoa ( * csa ) , ( long unsigned int ) ntohl ( csa -> s_addr ) ) ; return ; } | <S2SV_ModStart> ; } } } <S2SV_ModStart> 1 ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
6,925 | CWE-000 static int __diff_to_buf ( unsigned long gfn , struct page * page1 , struct page * page2 , uint8_t * buf ) { c16x8_header_t * header ; uint8_t * block ; char * backup = kmap_atomic ( page1 ) ; char * page = kmap_atomic ( page2 ) ; int i ; header = ( c16x8_header_t * ) buf ; block = buf + sizeof ( * header ) ; header -> gfn = gfn << 12 | 1 ; memset ( header -> h , 0 , sizeof ( header -> h ) ) ; kernel_fpu_begin ( ) ; for ( i = 0 ; i < 4096 ; i += 32 ) { if ( memcmp_avx_32 ( backup + i , page + i ) ) { header -> h [ i / 256 ] |= ( 1 << ( ( i % 256 ) / 32 ) ) ; memcpy ( block , page + i , 32 ) ; block += 32 ; } } <S2SV_StartBug> if ( block == buf + sizeof ( * header ) ) { <S2SV_EndBug> # ifdef ft_debug_mode_enable printk ( "warning:<S2SV_blank>not<S2SV_blank>found<S2SV_blank>diff<S2SV_blank>page\\n" ) ; # endif memset ( header -> h , 0xff , 16 * sizeof ( __u8 ) ) ; memcpy ( block , page , 4096 ) ; block += 4096 ; } <S2SV_StartBug> kernel_fpu_end ( ) ; <S2SV_EndBug> kunmap_atomic ( backup ) ; kunmap_atomic ( page ) ; if ( block == buf + sizeof ( * header ) ) return 0 ; header -> size = sizeof ( header -> h ) + ( block - ( buf + sizeof ( * header ) ) ) ; return block - buf ; } | <S2SV_ModStart> ; } } kernel_fpu_end ( ) ; <S2SV_ModStart> 4096 ; } <S2SV_ModEnd> kunmap_atomic ( backup |
6,926 | CWE-000 WimaEditor wima_editor_register ( const char * const name , WimaEditorFuncs funcs , WimaIcon icon , uint32_t allocSize , int nRegions , WimaRegion regions [ ] ) { wima_assert_init ; wassert ( nRegions > 0 && nRegions <= WIMA_EDITOR_MAX_REGIONS , WIMA_ASSERT_EDITOR_NUM_REGIONS ) ; size_t idx = dvec_len ( wg . editors ) ; wassert ( idx < WIMA_EDITOR_MAX , WIMA_ASSERT_EDITOR_MAX ) ; WimaEdtr edtr ; edtr . name = dstr_create ( name ) ; <S2SV_StartBug> if ( yunlikely ( edtr . name == NULL ) ) { <S2SV_EndBug> <S2SV_StartBug> wima_error ( WIMA_STATUS_MALLOC_ERR ) ; <S2SV_EndBug> return WIMA_EDITOR_INVALID ; } edtr . user = NULL ; edtr . funcs = funcs ; edtr . icon = icon ; edtr . allocSize = allocSize ; uint32_t sum = 0 ; for ( int i = 0 ; i < nRegions ; ++ i ) { WimaReg * reg = dvec_get ( wg . regions , i ) ; sum += reg -> itemCap ; } edtr . itemCap = sum ; memcpy ( edtr . regions , regions , nRegions * sizeof ( WimaRegion ) ) ; DynaStatus status = dvec_push ( wg . editors , & edtr ) ; <S2SV_StartBug> if ( yunlikely ( status ) ) { <S2SV_EndBug> <S2SV_StartBug> dstr_free ( edtr . name ) ; <S2SV_EndBug> wima_error ( WIMA_STATUS_MALLOC_ERR ) ; return WIMA_EDITOR_INVALID ; } <S2SV_StartBug> return ( WimaEditor ) idx ; <S2SV_EndBug> } | <S2SV_ModStart> ; if ( yerror <S2SV_ModEnd> ( edtr . <S2SV_ModStart> ) ) { goto wima_edtr_reg_name_err <S2SV_ModEnd> ; } edtr <S2SV_ModStart> ; if ( yerror <S2SV_ModEnd> ( status ) <S2SV_ModStart> ) ) { goto wima_edtr_reg_vec_err ; } return ( WimaEditor ) idx ; wima_edtr_reg_vec_err : <S2SV_ModStart> name ) ; wima_edtr_reg_name_err : <S2SV_ModStart> WIMA_EDITOR_INVALID ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
6,927 | CWE-000 task main ( ) { while ( true ) { motor [ leftDriveMotors ] = vexRT [ Ch3 ] ; motor [ rightDriveMotors ] = vexRT [ Ch2 ] ; if ( vexRT [ Btn6U ] == 1 ) { nBtn6U += 1 ; if ( nBtn6U % 2 == 0 ) { motor [ intakeMotor ] = 0 ; } else { motor [ intakeMotor ] = - 127 ; } wait1Msec ( 200 ) ; } if ( vexRT [ Btn6D ] == 1 ) { nBtn6D += 1 ; if ( nBtn6D % 2 == 0 ) { motor [ intakeMotor ] = 0 ; } else { motor [ intakeMotor ] = 127 ; } wait1Msec ( 200 ) ; } <S2SV_StartBug> if ( vexRT [ Btn7U ] == 1 ) { <S2SV_EndBug> nBtn7U += 1 ; if ( nBtn7U % 2 == 0 ) { motor [ innerWheelMotor ] = 0 ; } else { motor [ innerWheelMotor ] = 127 ; } wait1Msec ( 200 ) ; } if ( vexRT [ Btn7L ] == 1 ) { nBtn7L += 1 ; if ( nBtn7L % 2 == 0 ) { motor [ treadMotor ] = 0 ; } else { motor [ treadMotor ] = 127 ; } wait1Msec ( 200 ) ; } if ( vexRT [ Btn8U ] == 1 ) { nBtn8U += 1 ; if ( nBtn8U % 2 == 0 ) { runShooter ( 0 ) ; } else { runShooter ( 127 ) ; } wait1Msec ( 200 ) ; } if ( vexRT [ Btn8R ] == 1 ) { nBtn8R += 1 ; if ( nBtn8R % 2 == 0 ) { runShooter ( 0 ) ; } else { runShooter ( 60 ) ; } wait1Msec ( 200 ) ; } if ( vexRT [ Btn8L ] == 1 ) { runDriveMotors ( 0 , 127 ) ; wait1Msec ( 30 ) ; runDriveMotors ( 127 , - 1 ) ; wait1Msec ( 10 ) ; runDriveMotors ( 0 , 0 ) ; } if ( vexRT [ Btn7R ] == 1 ) { runDriveMotors ( 127 , 0 ) ; wait1Msec ( 30 ) ; runDriveMotors ( - 1 , 127 ) ; wait1Msec ( 10 ) ; runDriveMotors ( 0 , 0 ) ; } } } | <S2SV_ModStart> ( vexRT [ Btn8D ] == 1 ) { nBtn8D += 1 ; if ( nBtn8D % 2 == 0 ) { motor [ intakeMotor ] = 0 ; } else { runShooter ( 127 ) ; motor [ intakeMotor ] = 127 ; motor [ treadMotor ] = 127 ; wait1Msec ( 500 ) ; motor [ innerWheelMotor ] = 127 ; } wait1Msec ( 200 ) ; } if ( vexRT [ |
6,928 | CWE-000 int mutt_is_quote_line ( char * line , regmatch_t * pmatch ) { bool is_quote = false ; <S2SV_StartBug> regmatch_t pmatch_internal [ 1 ] , smatch [ 1 ] ; <S2SV_EndBug> char c ; if ( ! pmatch ) pmatch = pmatch_internal ; if ( QuoteRegex && QuoteRegex -> regex && regexec ( QuoteRegex -> regex , line , 1 , pmatch , 0 ) == 0 ) { if ( Smileys && Smileys -> regex && regexec ( Smileys -> regex , line , 1 , smatch , 0 ) == 0 ) { if ( smatch [ 0 ] . rm_so > 0 ) { <S2SV_StartBug> c = line [ smatch [ 0 ] . rm_so ] ; <S2SV_EndBug> line [ smatch [ 0 ] . rm_so ] = 0 ; if ( regexec ( QuoteRegex -> regex , line , 1 , pmatch , 0 ) == 0 ) is_quote = true ; line [ smatch [ 0 ] . rm_so ] = c ; } } else is_quote = true ; } return is_quote ; } | <S2SV_ModStart> [ 1 ] <S2SV_ModEnd> ; if ( <S2SV_ModStart> 0 ) { char |
6,929 | CWE-000 static void khttpd_fcgi_attach_conn ( void * arg ) { struct khttpd_fcgi_begin_request_record * record ; struct khttpd_fcgi_conn * conn = arg ; struct khttpd_fcgi_xchg_data * xchg_data ; struct mbuf * m ; long space ; KHTTPD_ENTRY ( "%s(%p)" , __func__ , conn ) ; KASSERT ( ! conn -> active , ( "active" ) ) ; KASSERT ( khttpd_fcgi_conn_on_worker_thread ( conn ) , ( "conn<S2SV_blank>wrong<S2SV_blank>thread" ) ) ; if ( ( xchg_data = conn -> xchg_data ) == NULL ) { <S2SV_StartBug> khttpd_task_schedule ( conn -> release_task ) ; <S2SV_EndBug> return ; } KASSERT ( khttpd_fcgi_xchg_data_on_worker_thread ( xchg_data ) , ( "xchg_data<S2SV_blank>wrong<S2SV_blank>thread" ) ) ; <S2SV_StartBug> if ( conn -> recv_eof ) { <S2SV_EndBug> conn -> xchg_data = NULL ; xchg_data -> conn = NULL ; khttpd_task_schedule ( conn -> release_task ) ; khttpd_fcgi_choose_conn ( xchg_data -> exchange ) ; return ; } xchg_data -> active = conn -> active = true ; m = m_get ( M_WAITOK , MT_DATA ) ; m -> m_len = sizeof ( * record ) ; record = mtod ( m , struct khttpd_fcgi_begin_request_record * ) ; CTASSERT ( sizeof ( * record ) % KHTTPD_FCGI_RECORD_ALIGN == 0 ) ; khttpd_fcgi_init_record_header ( & record -> hdr , KHTTPD_FCGI_TYPE_BEGIN_REQUEST , sizeof ( struct khttpd_fcgi_begin_request_record ) - offsetof ( struct khttpd_fcgi_begin_request_record , role ) ) ; record -> role = htons ( KHTTPD_FCGI_ROLE_RESPONDER ) ; record -> flags = KHTTPD_FCGI_FLAGS_KEEP_CONN ; bzero ( record -> reserved , sizeof ( record -> reserved ) ) ; khttpd_fcgi_append_params ( xchg_data , m ) ; khttpd_stream_send_bufstat ( & conn -> stream , NULL , NULL , & space ) ; space -= m_length ( m , NULL ) ; khttpd_stream_send ( & conn -> stream , m , 0 ) ; xchg_data -> put_busy = true ; khttpd_fcgi_send_stdin ( xchg_data , space ) ; } | <S2SV_ModStart> NULL ) { KHTTPD_NOTE ( "%s<S2SV_blank>exchange<S2SV_blank>has<S2SV_blank>gone" , __func__ ) ; <S2SV_ModStart> recv_eof ) { KHTTPD_NOTE ( "%s<S2SV_blank>eof" , __func__ ) ; |
6,930 | CWE-000 static bool parse_seckey ( pgp_keydata_key_t * keydata , s_exp_t * s_exp , pgp_pubkey_alg_t alg ) { keydata -> seckey . pubkey . version = PGP_V4 ; keydata -> seckey . pubkey . birthtime = time ( NULL ) ; keydata -> seckey . pubkey . duration = 0 ; keydata -> seckey . pubkey . alg = alg ; keydata -> seckey . s2k_usage = PGP_S2KU_NONE ; switch ( alg ) { case PGP_PKA_DSA : keydata -> seckey . key . dsa . x = read_bignum ( s_exp , "x" ) ; if ( keydata -> seckey . key . dsa . x == NULL ) { return false ; } break ; case PGP_PKA_RSA : keydata -> seckey . key . rsa . d = read_bignum ( s_exp , "d" ) ; if ( keydata -> seckey . key . rsa . d == NULL ) { return false ; } keydata -> seckey . key . rsa . p = read_bignum ( s_exp , "p" ) ; if ( keydata -> seckey . key . rsa . p == NULL ) { PGPV_BN_free ( keydata -> seckey . key . rsa . d ) ; return false ; } keydata -> seckey . key . rsa . q = read_bignum ( s_exp , "q" ) ; if ( keydata -> seckey . key . rsa . q == NULL ) { PGPV_BN_free ( keydata -> seckey . key . rsa . d ) ; PGPV_BN_free ( keydata -> seckey . key . rsa . p ) ; return false ; } keydata -> seckey . key . rsa . u = read_bignum ( s_exp , "u" ) ; if ( keydata -> seckey . key . rsa . u == NULL ) { PGPV_BN_free ( keydata -> seckey . key . rsa . d ) ; PGPV_BN_free ( keydata -> seckey . key . rsa . p ) ; PGPV_BN_free ( keydata -> seckey . key . rsa . q ) ; return false ; } break ; case PGP_PKA_ELGAMAL : keydata -> seckey . key . elgamal . x = read_bignum ( s_exp , "x" ) ; if ( keydata -> seckey . key . elgamal . x == NULL ) { return false ; } break ; default : fprintf ( stderr , "Unsupported<S2SV_blank>public<S2SV_blank>key<S2SV_blank>algorithm:<S2SV_blank>%d\\n" , alg ) ; <S2SV_StartBug> free ( keydata ) ; <S2SV_EndBug> return NULL ; } return true ; } | <S2SV_ModStart> alg ) ; <S2SV_ModEnd> return NULL ; |
6,931 | CWE-000 PyObject * eval_args_2 ( const char * funcname , uint16_t namelen , PyNameSpace * local_ns , PyFunctionObject * func , PyTupleObject * args , PyTupleObject * kwargs ) { PyNameObject * param ; uint16_t nparams = func -> argspec . args ? py_iter_object_length ( func -> argspec . args ) : 0 ; uint16_t nkwparams = func -> argspec . kwargs ? py_iter_object_length ( func -> argspec . kwargs ) : 0 ; if ( nkwparams ) { if ( py_iter_object_length ( args ) < nparams ) { return RAISE_TYPEERROR_TAKES_AT_LEAST_ARGUMENTS ( funcname , nparams , py_iter_object_length ( args ) ) ; } else if ( py_iter_object_length ( args ) + py_iter_object_length ( kwargs ) > nparams + nkwparams ) { return RAISE_TYPEERROR_TAKES_AT_MOST_ARGUMENTS ( funcname , nparams + nkwparams , py_iter_object_length ( args ) + py_iter_object_length ( kwargs ) ) ; } } else { if ( nparams != py_iter_object_length ( args ) ) { return RAISE_TYPEERROR_TAKES_EXACTLY_ARGUMENTS ( funcname , nparams , py_iter_object_length ( args ) ) ; } } <S2SV_StartBug> ( void ) funcname ; <S2SV_EndBug> ( void ) namelen ; if ( args ) { for ( uint16_t i = 0 ; i < py_iter_object_length ( args ) ; i ++ ) { param = ( PyNameObject * ) copy_name ( args -> items [ i ] , ( PyNameObject * ) func -> argspec . args -> items [ i ] ) ; if ( pyc_is_exception ( ( PyObject * ) param ) ) { return ( PyObject * ) param ; } register_name ( local_ns , param ) ; } } if ( kwargs ) { for ( uint16_t i = 0 ; i < py_iter_object_length ( kwargs ) ; i ++ ) { param = ( PyNameObject * ) copy_name ( kwargs -> items [ i ] , ( PyNameObject * ) func -> argspec . kwargs -> items [ i ] ) ; if ( pyc_is_exception ( ( PyObject * ) param ) ) { return ( PyObject * ) param ; } register_name ( local_ns , param ) ; } } return NULL ; } | <S2SV_ModStart> ; } } <S2SV_ModEnd> if ( args |
6,932 | CWE-000 int create_new_subflow_output_slave ( ) { int sockfd ; uint16_t sfl_port ; create_socket_call_connect ( & sockfd , & sfl_port ) ; <S2SV_StartBug> struct fourtuple ft ; <S2SV_EndBug> ft . ip_loc = packd . ft . ip_loc ; <S2SV_StartBug> ft . ip_rem = packd . ft . ip_rem ; <S2SV_EndBug> <S2SV_StartBug> ft . prt_rem = packd . ft . prt_rem ; <S2SV_EndBug> <S2SV_StartBug> ft . prt_loc = sfl_port ; <S2SV_EndBug> unsigned i = 0 ; unsigned char addr_id_loc ; struct session * sess = packd . sess ; while ( i < sess -> pA_addrid_loc . number && ( ( struct addrid * ) get_pnt_pA ( & sess -> pA_addrid_loc , i ) ) -> addr != ft -> ip_loc ) i ++ ; if ( i == sess -> pA_addrid_loc . number || ( ( struct addrid * ) get_pnt_pA ( & sess -> pA_addrid_loc , i ) ) -> addr != ft -> ip_loc ) { struct addrid * addrid_loc = malloc ( sizeof ( struct addrid ) ) ; addrid_loc -> addr = ft -> ip_loc ; sess -> largest_addr_id_loc ++ ; addrid_loc -> id = sess -> largest_addr_id_loc ; add_pnt_pA ( & sess -> pA_addrid_loc , addrid_loc ) ; addr_id_loc = addrid_loc -> id ; } else { addr_id_loc = ( ( struct addrid * ) get_pnt_pA ( & sess -> pA_addrid_loc , i ) ) -> id ; } snprintf ( msg_buf , MAX_MSG_LENGTH , "initiate_cand_subflow:<S2SV_blank>finding<S2SV_blank>local<S2SV_blank>addrid=%u" , addr_id_loc ) ; add_msg ( msg_buf ) ; i = 0 ; while ( i < sess -> pA_addrid_rem . number && ( ( struct addrid * ) get_pnt_pA ( & sess -> pA_addrid_rem , i ) ) -> addr != ft -> ip_rem ) i ++ ; unsigned char addr_id_rem = ( ( struct addrid * ) get_pnt_pA ( & sess -> pA_addrid_rem , i ) ) -> id ; snprintf ( msg_buf , MAX_MSG_LENGTH , "initiate_cand_subflow:<S2SV_blank>finding<S2SV_blank>remote<S2SV_blank>addrid=%u" , addr_id_rem ) ; add_msg ( msg_buf ) ; int found = 0 ; for ( unsigned i = 0 ; i < if_tab1 . nb_if ; ++ i ) { if ( ft -> ip_loc == if_tab1 . ipaddr [ i ] ) { found = 1 ; break ; } } if ( found == 0 ) { char buf_ip [ 34 ] ; sprintIPaddr ( buf_ip , ft -> ip_loc ) ; snprintf ( msg_buf , MAX_MSG_LENGTH , "initiate_cand_subflow:<S2SV_blank>local<S2SV_blank>IP=%s<S2SV_blank>not<S2SV_blank>found<S2SV_blank>-<S2SV_blank>ABORT" , buf_ip ) ; add_msg ( msg_buf ) ; return 0 ; } struct subflow * curr_sfl ; int same = 0 ; int dst_known = 0 ; for ( unsigned i = 0 ; i < sess -> pA_sflows . number ; i ++ ) { curr_sfl = ( struct subflow * ) get_pnt_pA ( & sess -> pA_sflows , i ) ; if ( memcmp ( & curr_sfl -> ft , & ft , sizeof ( struct fourtuple ) ) == 0 ) same = 1 ; if ( ( curr_sfl -> ft . ip_rem == ft -> ip_rem ) && ( curr_sfl -> ft . prt_rem == ft -> prt_rem ) ) dst_known = 1 ; } if ( same == 1 ) { snprintf ( msg_buf , MAX_MSG_LENGTH , "initiate_cand_subflow:<S2SV_blank>fourtuple<S2SV_blank>already<S2SV_blank>exists<S2SV_blank>-<S2SV_blank>ABORT" ) ; add_msg ( msg_buf ) ; return 0 ; } if ( dst_known == 0 ) { snprintf ( msg_buf , MAX_MSG_LENGTH , "initiate_cand_subflow:<S2SV_blank>ip_rem<S2SV_blank>or<S2SV_blank>prt_rem<S2SV_blank>not<S2SV_blank>known<S2SV_blank>-<S2SV_blank>ABORT" ) ; add_msg ( msg_buf ) ; return 0 ; } struct subflow * sfl1 ; sfl1 = create_subflow ( ft , addr_id_loc , addr_id_rem , sockfd , SYN_SENT , CANDIDATE , 0 , 0 , 0 , 0 , get_rand ( ) , 0 , 0 ) ; if ( sfl1 == NULL ) { snprintf ( msg_buf , MAX_MSG_LENGTH , "initiate_cand_subflow:<S2SV_blank>returns<S2SV_blank>NULL<S2SV_blank>when<S2SV_blank>creating<S2SV_blank>subflow" ) ; add_msg ( msg_buf ) ; return 0 ; } add_subflow_to_session ( sfl1 , sess ) ; sess -> slav_subflow = sfl1 ; } | <S2SV_ModStart> ; struct fourtuple ft_sfl ; ft_sfl <S2SV_ModEnd> . ip_loc = <S2SV_ModStart> . ip_loc ; ft_sfl <S2SV_ModEnd> . ip_rem = <S2SV_ModStart> . ip_rem ; ft_sfl <S2SV_ModEnd> . prt_rem = <S2SV_ModStart> . prt_rem ; ft_sfl <S2SV_ModEnd> . prt_loc = <S2SV_ModStart> prt_loc = sfl_port ; struct fourtuple * ft = & ft_sfl |
6,933 | CWE-000 int i915_gem_busy_ioctl ( struct drm_device * dev , void * data , struct drm_file * file ) { struct drm_i915_gem_busy * args = data ; struct drm_i915_gem_object * obj ; int ret ; ret = i915_mutex_lock_interruptible ( dev ) ; if ( ret ) return ret ; obj = to_intel_bo ( drm_gem_object_lookup ( dev , file , args -> handle ) ) ; if ( & obj -> base == NULL ) { ret = - ENOENT ; goto unlock ; } args -> busy = obj -> active ; if ( args -> busy ) { if ( obj -> base . write_domain & I915_GEM_GPU_DOMAINS ) { ret = i915_gem_flush_ring ( obj -> ring , 0 , obj -> base . write_domain ) ; } else if ( obj -> ring -> outstanding_lazy_request == obj -> last_rendering_seqno ) { struct drm_i915_gem_request * request ; request = kzalloc ( sizeof ( * request ) , GFP_KERNEL ) ; <S2SV_StartBug> if ( request ) <S2SV_EndBug> ret = i915_add_request ( obj -> ring , NULL , request ) ; <S2SV_StartBug> else <S2SV_EndBug> ret = - ENOMEM ; } i915_gem_retire_requests_ring ( obj -> ring ) ; args -> busy = obj -> active ; } drm_gem_object_unreference ( & obj -> base ) ; unlock : mutex_unlock ( & dev -> struct_mutex ) ; return ret ; } | <S2SV_ModStart> ( request ) { <S2SV_ModStart> request ) ; if ( ret ) kfree ( request ) ; } |
6,934 | CWE-000 BDD check_BDD ( smc_model_t * model , ctl_node_t * formula ) { switch ( formula -> type ) { case CTL_ATOM : return check_BDD_atom ( model , formula ) ; case CTL_NEGATION : return check_BDD_negation ( model , formula ) ; case CTL_CONJUNCTION : return check_BDD_conjunction ( model , formula ) ; case CTL_DISJUNCTION : return check_BDD_disjunction ( model , formula ) ; case CTL_EX : return check_BDD_EX ( model , formula ) ; case CTL_EU : return check_BDD_EU ( model , formula ) ; case CTL_EG : return check_BDD_EG ( model , formula ) ; default : printf ( "Unknown<S2SV_blank>case<S2SV_blank>in<S2SV_blank>check_BDD\\n" ) ; <S2SV_StartBug> return null ; <S2SV_EndBug> } } | <S2SV_ModStart> ) ; return ( BDD ) NULL <S2SV_ModEnd> ; } } |
6,935 | CWE-000 int hfi1_reset_device ( int unit ) { int ret , i ; struct hfi1_devdata * dd = hfi1_lookup ( unit ) ; struct hfi1_pportdata * ppd ; unsigned long flags ; int pidx ; if ( ! dd ) { ret = - ENODEV ; goto bail ; } dd_dev_info ( dd , "Reset<S2SV_blank>on<S2SV_blank>unit<S2SV_blank>%u<S2SV_blank>requested\\n" , unit ) ; <S2SV_StartBug> if ( ! dd -> kregbase || ! ( dd -> flags & HFI1_PRESENT ) ) { <S2SV_EndBug> dd_dev_info ( dd , "Invalid<S2SV_blank>unit<S2SV_blank>number<S2SV_blank>%u<S2SV_blank>or<S2SV_blank>not<S2SV_blank>initialized<S2SV_blank>or<S2SV_blank>not<S2SV_blank>present\\n" , unit ) ; ret = - ENXIO ; goto bail ; } spin_lock_irqsave ( & dd -> uctxt_lock , flags ) ; if ( dd -> rcd ) for ( i = dd -> first_dyn_alloc_ctxt ; i < dd -> num_rcv_contexts ; i ++ ) { if ( ! dd -> rcd [ i ] ) continue ; spin_unlock_irqrestore ( & dd -> uctxt_lock , flags ) ; ret = - EBUSY ; goto bail ; } spin_unlock_irqrestore ( & dd -> uctxt_lock , flags ) ; for ( pidx = 0 ; pidx < dd -> num_pports ; ++ pidx ) { ppd = dd -> pport + pidx ; shutdown_led_override ( ppd ) ; } if ( dd -> flags & HFI1_HAS_SEND_DMA ) sdma_exit ( dd ) ; hfi1_reset_cpu_counters ( dd ) ; ret = hfi1_init ( dd , 1 ) ; if ( ret ) dd_dev_err ( dd , "Reinitialize<S2SV_blank>unit<S2SV_blank>%u<S2SV_blank>after<S2SV_blank>reset<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>%d\\n" , unit , ret ) ; else dd_dev_info ( dd , "Reinitialized<S2SV_blank>unit<S2SV_blank>%u<S2SV_blank>after<S2SV_blank>resetting\\n" , unit ) ; bail : return ret ; } | <S2SV_ModStart> ! dd -> kregbase1 <S2SV_ModEnd> || ! ( |
6,936 | CWE-000 void modify_roi_out ( dt_iop_module_t * self , dt_dev_pixelpipe_iop_t * piece , dt_iop_roi_t * roi_out , const dt_iop_roi_t * const roi_in ) { * roi_out = * roi_in ; dt_iop_rawprepare_data_t * d = ( dt_iop_rawprepare_data_t * ) piece -> data ; roi_out -> x = roi_out -> y = 0 ; int32_t x = d -> x + d -> width , y = d -> y + d -> height ; const float scale = roi_in -> scale / piece -> iscale ; <S2SV_StartBug> roi_out -> width -= ( int ) roundf ( ( float ) x * scale ) ; <S2SV_EndBug> <S2SV_StartBug> roi_out -> height -= ( int ) roundf ( ( float ) y * scale ) ; <S2SV_EndBug> } | <S2SV_ModStart> -> width -= round_smart <S2SV_ModEnd> ( ( float <S2SV_ModStart> x * scale , x <S2SV_ModStart> -> height -= round_smart <S2SV_ModEnd> ( ( float <S2SV_ModStart> y * scale , y |
6,937 | CWE-000 int <S2SV_StartBug> hn_rndis_attach ( struct hn_softc * sc , int mtu ) <S2SV_EndBug> { <S2SV_StartBug> int error ; <S2SV_EndBug> error = hn_rndis_init ( sc ) ; if ( error ) return ( error ) ; <S2SV_StartBug> hn_rndis_conf_offload ( sc , mtu ) ; <S2SV_EndBug> return ( 0 ) ; } | <S2SV_ModStart> , int mtu , int * init_done <S2SV_ModStart> { int error ; * init_done = 0 <S2SV_ModStart> error ) ; * init_done = 1 ; |
6,938 | CWE-000 static int seaslog_init_request_variable ( TSRMLS_D ) { zval * client_ip ; zval * domain ; SEASLOG_G ( request_variable ) = ecalloc ( sizeof ( request_variable_t ) , 1 ) ; if ( ! strncmp ( sapi_module . name , "cli" , sizeof ( "cli" ) - 1 ) ) { SEASLOG_G ( request_variable ) -> request_uri = seaslog_request_query ( SEASLOG_GLOBAL_VARS_SERVER , ZEND_STRL ( "SCRIPT_NAME" ) TSRMLS_CC ) ; SEASLOG_G ( request_variable ) -> request_method = seaslog_request_query ( SEASLOG_GLOBAL_VARS_SERVER , ZEND_STRL ( "SHELL" ) TSRMLS_CC ) ; SEASLOG_G ( request_variable ) -> domain_port_len = spprintf ( & SEASLOG_G ( request_variable ) -> domain_port , 0 , "cli" ) ; <S2SV_StartBug> SEASLOG_G ( request_variable ) -> client_ip_len = spprintf ( & SEASLOG_G ( request_variable ) -> client_ip , 0 , "local" ) ; <S2SV_EndBug> } else { domain = seaslog_request_query ( SEASLOG_GLOBAL_VARS_SERVER , ZEND_STRL ( "HTTP_HOST" ) TSRMLS_CC ) ; SEASLOG_G ( request_variable ) -> domain_port_len = spprintf ( & SEASLOG_G ( request_variable ) -> domain_port , 0 , "%s" , Z_STRVAL_P ( domain ) ) ; SEASLOG_ZVAL_PTR_DTOR ( domain ) ; SEASLOG_G ( request_variable ) -> request_uri = seaslog_request_query ( SEASLOG_GLOBAL_VARS_SERVER , ZEND_STRL ( "REQUEST_URI" ) TSRMLS_CC ) ; SEASLOG_G ( request_variable ) -> request_method = seaslog_request_query ( SEASLOG_GLOBAL_VARS_SERVER , ZEND_STRL ( "REQUEST_METHOD" ) TSRMLS_CC ) ; client_ip = seaslog_request_query ( SEASLOG_GLOBAL_VARS_SERVER , ZEND_STRL ( "HTTP_X_REAL_IP" ) TSRMLS_CC ) ; if ( client_ip != NULL && Z_TYPE_P ( client_ip ) == IS_STRING ) { SEASLOG_G ( request_variable ) -> client_ip_len = spprintf ( & SEASLOG_G ( request_variable ) -> client_ip , 0 , "%s" , Z_STRVAL_P ( client_ip ) ) ; SEASLOG_ZVAL_PTR_DTOR ( client_ip ) ; return SUCCESS ; } client_ip = seaslog_request_query ( SEASLOG_GLOBAL_VARS_SERVER , ZEND_STRL ( "HTTP_X_FORWARDED_FOR" ) TSRMLS_CC ) ; if ( client_ip != NULL && Z_TYPE_P ( client_ip ) == IS_STRING ) { SEASLOG_G ( request_variable ) -> client_ip_len = spprintf ( & SEASLOG_G ( request_variable ) -> client_ip , 0 , "%s" , Z_STRVAL_P ( client_ip ) ) ; SEASLOG_ZVAL_PTR_DTOR ( client_ip ) ; return SUCCESS ; } client_ip = seaslog_request_query ( SEASLOG_GLOBAL_VARS_SERVER , ZEND_STRL ( "REMOTE_ADDR" ) TSRMLS_CC ) ; if ( client_ip != NULL && Z_TYPE_P ( client_ip ) == IS_STRING ) { SEASLOG_G ( request_variable ) -> client_ip_len = spprintf ( & SEASLOG_G ( request_variable ) -> client_ip , 0 , "%s" , Z_STRVAL_P ( client_ip ) ) ; SEASLOG_ZVAL_PTR_DTOR ( client_ip ) ; return SUCCESS ; } } return SUCCESS ; } | <S2SV_ModStart> "local" ) ; } else if ( ! strncmp ( sapi_module . name , "phpdbg" , sizeof ( "phpdbg" ) - 1 ) ) { |
6,939 | CWE-000 static sql_rel * rewrite_topdown ( mvc * sql , sql_rel * rel , rewrite_fptr rewriter , int * has_changes ) { if ( ! rel ) return rel ; rel = rewriter ( has_changes , sql , rel ) ; switch ( rel -> op ) { case op_basetable : case op_table : if ( rel -> op == op_table && rel -> l ) rel -> l = rewrite ( sql , rel -> l , rewriter , has_changes ) ; if ( rel -> op == op_table && rel -> l ) rel -> l = rewrite_topdown ( sql , rel -> l , rewriter , has_changes ) ; break ; case op_join : case op_left : case op_right : case op_full : case op_apply : case op_semi : case op_anti : case op_union : case op_inter : case op_except : rel -> l = rewrite_topdown ( sql , rel -> l , rewriter , has_changes ) ; rel -> r = rewrite_topdown ( sql , rel -> r , rewriter , has_changes ) ; break ; case op_project : case op_select : case op_groupby : case op_topn : case op_sample : rel -> l = rewrite_topdown ( sql , rel -> l , rewriter , has_changes ) ; break ; case op_ddl : <S2SV_StartBug> rel -> l = rewrite_topdown ( sql , rel -> l , rewriter , has_changes ) ; <S2SV_EndBug> if ( rel -> r ) rel -> r = rewrite_topdown ( sql , rel -> r , rewriter , has_changes ) ; break ; case op_insert : case op_update : case op_delete : rel -> l = rewrite_topdown ( sql , rel -> l , rewriter , has_changes ) ; rel -> r = rewrite_topdown ( sql , rel -> r , rewriter , has_changes ) ; break ; } return rel ; } | <S2SV_ModStart> case op_ddl : if ( rel -> flag == DDL_PSM && rel -> exps ) rewrite_exps ( sql , rel -> exps , & rewrite_topdown , rewriter , has_changes ) ; |
6,940 | CWE-000 t_format * get_format ( char * str , int j ) { char * split ; t_format * format ; split = ft_strsub ( str , 0 , j ) ; if ( split == NULL ) return ( NULL ) ; <S2SV_StartBug> format = ( t_format * ) malloc ( sizeof ( t_format ) ) ; <S2SV_EndBug> if ( format == NULL ) return ( NULL ) ; read_format_string ( split , format ) ; free ( split ) ; return ( format ) ; } | <S2SV_ModStart> ; format = new_t_format ( <S2SV_ModEnd> ) ; if |
6,941 | CWE-000 int main ( void ) { char * devpath = find_touch_device ( ) ; printf ( "Device<S2SV_blank>found:<S2SV_blank>%s\\n" , devpath ) ; <S2SV_StartBug> get_device_event_loop ( devpath , "./config" ) ; <S2SV_EndBug> free ( devpath ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> devpath ) ; char * config = get_conf_path ( CONFIG_PATH ) ; char * display = get_conf_path ( DISPLAYCONF ) ; <S2SV_ModStart> ( devpath , config , display <S2SV_ModEnd> ) ; free <S2SV_ModStart> devpath ) ; free ( config ) ; free ( display ) ; |
6,942 | CWE-000 OMX_ERRORTYPE PROXY_EventHandler ( OMX_HANDLETYPE hComponent , <S2SV_StartBug> OMX_PTR pAppData , OMX_EVENTTYPE eEvent , OMX_U32 nData1 , OMX_U32 nData2 , <S2SV_EndBug> OMX_PTR pEventData ) { OMX_ERRORTYPE eError = OMX_ErrorNone ; PROXY_COMPONENT_PRIVATE * pCompPrv = NULL ; OMX_COMPONENTTYPE * hComp = ( OMX_COMPONENTTYPE * ) hComponent ; OMX_PTR pTmpData = NULL ; pCompPrv = ( PROXY_COMPONENT_PRIVATE * ) hComp -> pComponentPrivate ; PROXY_require ( ( hComp -> pComponentPrivate != NULL ) , OMX_ErrorBadParameter , "This<S2SV_blank>is<S2SV_blank>fatal<S2SV_blank>error,<S2SV_blank>processing<S2SV_blank>cant<S2SV_blank>proceed<S2SV_blank>-<S2SV_blank>please<S2SV_blank>debug" ) ; DOMX_ENTER ( "hComponent=%p,<S2SV_blank>pCompPrv=%p,<S2SV_blank>eEvent=%p,<S2SV_blank>nData1=%p,<S2SV_blank>nData2=%p,<S2SV_blank>pEventData=%p" , hComponent , pCompPrv , eEvent , nData1 , nData2 , pEventData ) ; switch ( eEvent ) { # if 0 case OMX_TI_EventBufferRefCount : DOMX_DEBUG ( "Received<S2SV_blank>Ref<S2SV_blank>Count<S2SV_blank>Event" ) ; PROXY_assert ( ( nData1 != 0 ) , OMX_ErrorBadParameter , "Received<S2SV_blank>NULL<S2SV_blank>buffer<S2SV_blank>header<S2SV_blank>from<S2SV_blank>OMX<S2SV_blank>component" ) ; for ( count = 0 ; count < pCompPrv -> nTotalBuffers ; ++ count ) { if ( pCompPrv -> tBufList [ count ] . pBufHeaderRemote == nData1 ) { pLocalBufHdr = pCompPrv -> tBufList [ count ] . pBufHeader ; pLocalBufHdr -> pBuffer = ( OMX_U8 * ) pCompPrv -> tBufList [ count ] . pBufferActual ; break ; } } PROXY_assert ( ( count != pCompPrv -> nTotalBuffers ) , OMX_ErrorBadParameter , "Received<S2SV_blank>invalid-buffer<S2SV_blank>header<S2SV_blank>from<S2SV_blank>OMX<S2SV_blank>component" ) ; nData1 = ( OMX_U32 ) pLocalBufHdr ; break ; # endif case OMX_EventMark : DOMX_DEBUG ( "Received<S2SV_blank>Mark<S2SV_blank>Event" ) ; PROXY_assert ( ( pEventData != NULL ) , OMX_ErrorUndefined , "MarkData<S2SV_blank>corrupted" ) ; pTmpData = pEventData ; pEventData = ( ( PROXY_MARK_DATA * ) pEventData ) -> pMarkDataActual ; TIMM_OSAL_Free ( pTmpData ) ; break ; default : break ; } EXIT : if ( eError == OMX_ErrorNone ) { pCompPrv -> tCBFunc . EventHandler ( hComponent , pCompPrv -> pILAppData , eEvent , nData1 , nData2 , pEventData ) ; } else if ( pCompPrv ) { pCompPrv -> tCBFunc . EventHandler ( hComponent , pCompPrv -> pILAppData , OMX_EventError , eError , 0 , NULL ) ; } DOMX_EXIT ( "eError:<S2SV_blank>%d" , eError ) ; return OMX_ErrorNone ; } | <S2SV_ModStart> OMX_HANDLETYPE hComponent , __unused |
6,943 | CWE-000 void yield_cpu ( void ) <S2SV_StartBug> { <S2SV_EndBug> asm volatile ( "int<S2SV_blank>%0;" : : "i" ( CPU_YIELD_TRAP_VECTOR ) ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> void ) { struct x86_cpustate * cpu ; push_cpu_state ( cpu ) ; <S2SV_ModStart> ) ) ; pop_cpu_state ( cpu ) ; |
6,944 | CWE-000 void internalRunPreInitInstructions ( J9Class * ramClass , J9VMThread * vmThread ) { J9JavaVM * vm = vmThread -> javaVM ; J9ROMClass * romClass = ramClass -> romClass ; UDATA methodTypeIndex = 0 ; UDATA ramConstantPoolCount = romClass -> ramConstantPoolCount ; if ( ramConstantPoolCount != 0 ) { J9ConstantPool * ramConstantPool = J9_CP_FROM_CLASS ( ramClass ) ; J9ROMConstantPoolItem * romConstantPool = ramConstantPool -> romConstantPool ; U_32 * cpShapeDescription = J9ROMCLASS_CPSHAPEDESCRIPTION ( romClass ) ; J9UTF8 * className = J9ROMCLASS_CLASSNAME ( romClass ) ; UDATA descriptionCount = 0 ; U_32 description = 0 ; UDATA i ; BOOLEAN isAnonClass = J9_ARE_ANY_BITS_SET ( romClass -> extraModifiers , J9AccClassAnonClass ) ; for ( i = 0 ; i < ramConstantPoolCount ; ++ i ) { if ( descriptionCount == 0 ) { description = * cpShapeDescription ++ ; descriptionCount = J9_CP_DESCRIPTIONS_PER_U32 ; } switch ( description & J9_CP_DESCRIPTION_MASK ) { J9ROMMethodRef * romMethodRef ; J9ROMNameAndSignature * nas ; case J9CPTYPE_CLASS : if ( isAnonClass ) { J9ROMClassRef * classEntry = ( ( J9ROMClassRef * ) & ( romConstantPool [ i ] ) ) ; if ( SRP_GET ( classEntry -> name , J9UTF8 * ) == className ) { ( ( J9RAMClassRef * ) ramConstantPool ) [ i ] . value = ramClass ; } } break ; case J9CPTYPE_INT : case J9CPTYPE_FLOAT : * ( ( U_32 * ) & ( ( ( J9RAMSingleSlotConstantRef * ) ramConstantPool ) [ i ] . value ) ) = ( ( J9ROMSingleSlotConstantRef * ) romConstantPool ) [ i ] . data ; break ; case J9CPTYPE_FIELD : ( ( J9RAMFieldRef * ) ramConstantPool ) [ i ] . valueOffset = - 1 ; break ; case J9CPTYPE_HANDLE_METHOD : romMethodRef = ( ( J9ROMMethodRef * ) romConstantPool ) + i ; nas = J9ROMMETHODREF_NAMEANDSIGNATURE ( romMethodRef ) ; ( ( J9RAMMethodRef * ) ramConstantPool ) [ i ] . methodIndexAndArgCount = ( methodTypeIndex << 8 ) + getSendSlotsFromSignature ( J9UTF8_DATA ( J9ROMNAMEANDSIGNATURE_SIGNATURE ( nas ) ) ) ; methodTypeIndex ++ ; ( ( J9RAMMethodRef * ) ramConstantPool ) [ i ] . method = vm -> initialMethods . initialStaticMethod ; break ; case J9CPTYPE_INSTANCE_METHOD : <S2SV_StartBug> romMethodRef = ( ( J9ROMMethodRef * ) romConstantPool ) + i ; <S2SV_EndBug> nas = J9ROMMETHODREF_NAMEANDSIGNATURE ( romMethodRef ) ; ( ( J9RAMMethodRef * ) ramConstantPool ) [ i ] . methodIndexAndArgCount = ( ( sizeof ( J9Class ) + sizeof ( UDATA ) ) << 8 ) + getSendSlotsFromSignature ( J9UTF8_DATA ( J9ROMNAMEANDSIGNATURE_SIGNATURE ( nas ) ) ) ; ( ( J9RAMMethodRef * ) ramConstantPool ) [ i ] . method = vm -> initialMethods . initialSpecialMethod ; break ; <S2SV_StartBug> case J9CPTYPE_STATIC_METHOD : <S2SV_EndBug> romMethodRef = ( ( J9ROMMethodRef * ) romConstantPool ) + i ; nas = J9ROMMETHODREF_NAMEANDSIGNATURE ( romMethodRef ) ; ( ( J9RAMMethodRef * ) ramConstantPool ) [ i ] . methodIndexAndArgCount = ( ( sizeof ( J9Class ) + sizeof ( UDATA ) ) << 8 ) + getSendSlotsFromSignature ( J9UTF8_DATA ( J9ROMNAMEANDSIGNATURE_SIGNATURE ( nas ) ) ) ; ( ( J9RAMStaticMethodRef * ) ramConstantPool ) [ i ] . method = vm -> initialMethods . initialStaticMethod ; break ; case J9CPTYPE_INTERFACE_METHOD : romMethodRef = ( ( J9ROMMethodRef * ) romConstantPool ) + i ; nas = J9ROMMETHODREF_NAMEANDSIGNATURE ( romMethodRef ) ; ( ( J9RAMInterfaceMethodRef * ) ramConstantPool ) [ i ] . methodIndexAndArgCount = getSendSlotsFromSignature ( J9UTF8_DATA ( J9ROMNAMEANDSIGNATURE_SIGNATURE ( nas ) ) ) ; break ; case J9CPTYPE_METHOD_TYPE : { J9ROMMethodTypeRef * romMethodTypeRef = ( ( J9ROMMethodTypeRef * ) romConstantPool ) + i ; J9UTF8 * signature = J9ROMMETHODTYPEREF_SIGNATURE ( romMethodTypeRef ) ; ( ( J9RAMMethodTypeRef * ) ramConstantPool ) [ i ] . type = 0 ; ( ( J9RAMMethodTypeRef * ) ramConstantPool ) [ i ] . slotCount = getSendSlotsFromSignature ( J9UTF8_DATA ( signature ) ) ; break ; } } description >>= J9_CP_BITS_PER_DESCRIPTION ; -- descriptionCount ; } } } | <S2SV_ModStart> case J9CPTYPE_INSTANCE_METHOD : case J9CPTYPE_INTERFACE_INSTANCE_METHOD : <S2SV_ModStart> ; case J9CPTYPE_STATIC_METHOD : case J9CPTYPE_INTERFACE_STATIC_METHOD |
6,945 | CWE-000 bool FCW_CheckBlobValid ( const gsl_matrix * imgy , const gsl_matrix * vedge_imgy , blob * cur ) { if ( ! imgy || ! cur ) { dbg ( ) ; return false ; } if ( cur && cur -> valid == false ) return false ; <S2SV_StartBug> FCW_CheckBlobByArea ( imgy , cur ) ; <S2SV_EndBug> FCW_CheckBlobByVerticalEdge ( vedge_imgy , cur ) ; return true ; } | <S2SV_ModStart> return false ; <S2SV_ModEnd> FCW_CheckBlobByVerticalEdge ( vedge_imgy |
6,946 | CWE-000 pcap_t * pcap_open ( const char * source , int snaplen , int flags , int read_timeout , struct pcap_rmtauth * auth , char * errbuf ) { char name [ PCAP_BUF_SIZE ] ; int type ; pcap_t * fp ; int status ; if ( strlen ( source ) > PCAP_BUF_SIZE ) { pcap_snprintf ( errbuf , PCAP_ERRBUF_SIZE , "The<S2SV_blank>source<S2SV_blank>string<S2SV_blank>is<S2SV_blank>too<S2SV_blank>long.<S2SV_blank>Cannot<S2SV_blank>handle<S2SV_blank>it<S2SV_blank>correctly." ) ; return NULL ; } <S2SV_StartBug> if ( pcap_parsesrcstr ( source , & type , NULL , NULL , name , errbuf ) == - 1 ) <S2SV_EndBug> return NULL ; switch ( type ) { case PCAP_SRC_FILE : return pcap_open_offline ( name , errbuf ) ; case PCAP_SRC_IFLOCAL : fp = pcap_create ( name , errbuf ) ; break ; case PCAP_SRC_IFREMOTE : return pcap_open_rpcap ( source , snaplen , flags , read_timeout , auth , errbuf ) ; default : strlcpy ( errbuf , "Source<S2SV_blank>type<S2SV_blank>not<S2SV_blank>supported" , PCAP_ERRBUF_SIZE ) ; return NULL ; } if ( fp == NULL ) return ( NULL ) ; status = pcap_set_snaplen ( fp , snaplen ) ; if ( status < 0 ) goto fail ; if ( flags & PCAP_OPENFLAG_PROMISCUOUS ) { status = pcap_set_promisc ( fp , 1 ) ; if ( status < 0 ) goto fail ; } if ( flags & PCAP_OPENFLAG_MAX_RESPONSIVENESS ) { status = pcap_set_immediate_mode ( fp , 1 ) ; if ( status < 0 ) goto fail ; } # ifdef _WIN32 if ( flags & PCAP_OPENFLAG_NOCAPTURE_LOCAL ) fp -> opt . nocapture_local = 1 ; # endif status = pcap_set_timeout ( fp , read_timeout ) ; if ( status < 0 ) goto fail ; status = pcap_activate ( fp ) ; if ( status < 0 ) goto fail ; return fp ; fail : if ( status == PCAP_ERROR ) pcap_snprintf ( errbuf , PCAP_ERRBUF_SIZE , "%s:<S2SV_blank>%s" , name , fp -> errbuf ) ; else if ( status == PCAP_ERROR_NO_SUCH_DEVICE || status == PCAP_ERROR_PERM_DENIED || status == PCAP_ERROR_PROMISC_PERM_DENIED ) pcap_snprintf ( errbuf , PCAP_ERRBUF_SIZE , "%s:<S2SV_blank>%s<S2SV_blank>(%s)" , name , pcap_statustostr ( status ) , fp -> errbuf ) ; else pcap_snprintf ( errbuf , PCAP_ERRBUF_SIZE , "%s:<S2SV_blank>%s" , name , pcap_statustostr ( status ) ) ; pcap_close ( fp ) ; return NULL ; } | <S2SV_ModStart> , name , NULL , |
6,947 | CWE-000 int main ( void ) { << << << < HEAD ret_code_t err_code = 0 ; nrf_delay_ms ( 10 ) ; == == == = ret_code_t err_code = NRF_SUCCESS ; >> >> >> > b490eae ... Reinit NFC after connection , Advertise faster at boot err_code |= init_log ( ) ; err_code |= init_leds ( ) ; nrf_gpio_pin_clear ( LED_RED ) ; nrf_delay_ms ( 10 ) ; NRF_LOG_INFO ( "LOG<S2SV_blank>INIT<S2SV_blank>\\r\\n" ) ; if ( NRF_SUCCESS == init_sensors ( ) ) { NRF_LOG_INFO ( "SENSORS<S2SV_blank>INIT<S2SV_blank>\\r\\n" ) ; model_plus = true ; } nrf_delay_ms ( 10 ) ; << << << < HEAD == == == = <S2SV_StartBug> set_nfc_callback ( nfc_callback ) ; <S2SV_EndBug> err_code |= init_nfc ( ) ; if ( NRF_SUCCESS == init_sensors ( ) ) { model_plus = true ; } err_code |= init_ble ( ) ; bluetooth_configure_advertisement_type ( APPLICATION_ADVERTISEMENT_TYPE ) ; bluetooth_tx_power_set ( BLE_TX_POWER ) ; bluetooth_configure_advertising_interval ( ADVERTISING_INTERVAL_STARTUP ) ; >> >> >> > b490eae ... Reinit NFC after connection , Advertise faster at boot err_code |= init_nfc ( ) ; NRF_LOG_INFO ( "NFC<S2SV_blank>INIT<S2SV_blank>\\r\\n" ) ; nrf_delay_ms ( 10 ) ; err_code |= pin_interrupt_init ( ) ; nrf_delay_ms ( 10 ) ; err_code |= pin_interrupt_enable ( BSP_BUTTON_0 , NRF_GPIOTE_POLARITY_HITOLO , button_press_handler ) ; nrf_delay_ms ( 10 ) ; err_code |= pin_interrupt_enable ( INT_ACC1_PIN , NRF_GPIOTE_POLARITY_LOTOHI , lis2dh12_int1_handler ) ; NRF_LOG_INFO ( "INTERRUPT<S2SV_blank>INIT<S2SV_blank>\\r\\n" ) ; nrf_delay_ms ( 10 ) ; if ( model_plus ) { lis2dh12_reset ( ) ; nrf_delay_ms ( 10 ) ; lis2dh12_enable ( ) ; lis2dh12_set_scale ( LIS2DH12_SCALE2G ) ; << << << < HEAD lis2dh12_set_sample_rate ( LIS2DH12_RATE_1 ) ; lis2dh12_set_resolution ( LIS2DH12_RES12BIT ) ; NRF_LOG_INFO ( "LIS<S2SV_blank>INIT<S2SV_blank>\\r\\n" ) ; nrf_delay_ms ( 10 ) ; == == == = lis2dh12_set_sample_rate ( LIS2DH12_SAMPLERATE_RAW ) ; lis2dh12_set_resolution ( LIS2DH12_RESOLUTION ) ; # include "lis2dh12_registers.h" uint8_t ctrl [ 1 ] ; ctrl [ 0 ] = LIS2DH12_HPIS2_MASK ; lis2dh12_write_register ( LIS2DH12_CTRL_REG2 , ctrl , 1 ) ; ctrl [ 0 ] = 0x7F ; lis2dh12_write_register ( LIS2DH12_INT2_CFG , ctrl , 1 ) ; ctrl [ 0 ] = LIS2DH12_ACTIVITY_THRESHOLD ; lis2dh12_write_register ( LIS2DH12_INT2_THS , ctrl , 1 ) ; err_code |= pin_interrupt_enable ( INT_ACC2_PIN , NRF_GPIOTE_POLARITY_LOTOHI , lis2dh12_int2_handler ) ; lis2dh12_set_interrupts ( LIS2DH12_I2C_INT2_MASK , 2 ) ; >> >> >> > b490eae ... Reinit NFC after connection , Advertise faster at boot bme280_set_oversampling_hum ( BME280_OVERSAMPLING_1 ) ; bme280_set_oversampling_temp ( BME280_OVERSAMPLING_1 ) ; bme280_set_oversampling_press ( BME280_OVERSAMPLING_1 ) ; bme280_set_iir ( BME280_IIR_16 ) ; bme280_set_interval ( BME280_STANDBY_1000_MS ) ; bme280_set_mode ( BME280_MODE_NORMAL ) ; NRF_LOG_INFO ( "BME280<S2SV_blank>configuration<S2SV_blank>done\\r\\n" ) ; nrf_delay_ms ( 10 ) ; } err_code |= init_ble ( ) ; nrf_delay_ms ( 10 ) ; err_code |= bluetooth_tx_power_set ( BLE_TX_POWER ) ; err_code |= bluetooth_configure_advertising_interval ( MAIN_LOOP_INTERVAL_RAW ) ; err_code |= bluetooth_configure_advertisement_type ( BLE_GAP_ADV_TYPE_ADV_NONCONN_IND ) ; NRF_LOG_INFO ( "BLE<S2SV_blank>INIT<S2SV_blank>\\r\\n" ) ; nrf_delay_ms ( 10 ) ; init_watchdog ( NULL ) ; NRF_LOG_INFO ( "WATCHDOG<S2SV_blank>INIT<S2SV_blank>\\r\\n" ) ; nrf_delay_ms ( 10 ) ; err_code |= init_rtc ( ) ; NRF_LOG_INFO ( "RTC<S2SV_blank>INIT<S2SV_blank>\\r\\n" ) ; nrf_delay_ms ( 10 ) ; err_code |= init_timer ( main_timer_id , MAIN_LOOP_INTERVAL_RAW , main_timer_handler ) ; NRF_LOG_INFO ( "TIMER<S2SV_blank>INIT<S2SV_blank>\\r\\n" ) ; nrf_delay_ms ( 10 ) ; init_blink_status ( err_code ) ; nrf_gpio_pin_set ( LED_RED ) ; if ( model_plus ) { nrf_gpio_pin_clear ( LED_GREEN ) ; } nrf_delay_ms ( MAIN_LOOP_INTERVAL_RAW + 100 ) ; bluetooth_advertising_start ( ) ; NRF_LOG_INFO ( "ADVERTISING<S2SV_blank>START<S2SV_blank><S2SV_blank>\\r\\n" ) ; nrf_delay_ms ( 10 ) ; for ( ; ; ) { app_sched_execute ( ) ; power_manage ( ) ; } } | <S2SV_ModStart> = set_nfc_callback ( app_nfc_callback <S2SV_ModEnd> ) ; err_code |
6,948 | CWE-000 int changelog_init ( void ) { BackLogsNumber = cfg_getuint32 ( "BACK_LOGS" , 50 ) ; if ( BackLogsNumber > MAXLOGNUMBER ) { fprintf ( stderr , "BACK_LOGS<S2SV_blank>value<S2SV_blank>too<S2SV_blank>big<S2SV_blank>!!!" ) ; return - 1 ; } <S2SV_StartBug> ChangelogSecondsToRemember = cfg_getuint16 ( "CHANGELOG_PRESERVE_SECONDS" , 600 ) ; <S2SV_EndBug> if ( ChangelogSecondsToRemember > 3600 ) { syslog ( LOG_WARNING , "Number<S2SV_blank>of<S2SV_blank>seconds<S2SV_blank>of<S2SV_blank>change<S2SV_blank>logs<S2SV_blank>to<S2SV_blank>be<S2SV_blank>preserved<S2SV_blank>in<S2SV_blank>master<S2SV_blank>is<S2SV_blank>too<S2SV_blank>big<S2SV_blank>(%" PRIu16 ")<S2SV_blank>-<S2SV_blank>decreasing<S2SV_blank>to<S2SV_blank>3600<S2SV_blank>seconds" , ChangelogSecondsToRemember ) ; ChangelogSecondsToRemember = 3600 ; } main_reload_register ( changelog_reload ) ; currentfd = NULL ; return 0 ; } | <S2SV_ModStart> ( "CHANGELOG_PRESERVE_SECONDS" , 1800 <S2SV_ModEnd> ) ; if |
6,949 | CWE-000 static void pl_shader_ootf ( struct pl_shader * s , enum pl_color_light light , <S2SV_StartBug> float peak ) <S2SV_EndBug> { if ( ! light || light == PL_COLOR_LIGHT_DISPLAY ) return ; GLSL ( "//<S2SV_blank>pl_shader_ootf<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n" "color.rgb<S2SV_blank>*=<S2SV_blank>vec3(%f);<S2SV_blank>\\n" , peak ) ; switch ( light ) { case PL_COLOR_LIGHT_SCENE_HLG : <S2SV_StartBug> GLSL ( "color.rgb<S2SV_blank>*=<S2SV_blank>vec3(%f<S2SV_blank>*<S2SV_blank>pow(dot(src_luma,<S2SV_blank>color.rgb),<S2SV_blank>0.2));\\n" , <S2SV_EndBug> <S2SV_StartBug> ( 1000 / PL_COLOR_REF_WHITE ) / pow ( 12 , 1.2 ) ) ; <S2SV_EndBug> break ; case PL_COLOR_LIGHT_SCENE_709_1886 : GLSL ( "color.rgb<S2SV_blank>=<S2SV_blank>mix(color.rgb<S2SV_blank>*<S2SV_blank>vec3(4.5),<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>\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>vec3(1.0993)<S2SV_blank>*<S2SV_blank>pow(color.rgb,<S2SV_blank>vec3(0.45))<S2SV_blank>\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-<S2SV_blank>vec3(0.0993),<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>\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>lessThan(vec3(0.0181),<S2SV_blank>color.rgb));<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n" "color.rgb<S2SV_blank>=<S2SV_blank>pow(color.rgb,<S2SV_blank>vec3(2.4));<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>\\n" ) ; break ; case PL_COLOR_LIGHT_SCENE_1_2 : GLSL ( "color.rgb<S2SV_blank>=<S2SV_blank>pow(color.rgb,<S2SV_blank>vec3(1.2));\\n" ) ; break ; default : abort ( ) ; } GLSL ( "color.rgb<S2SV_blank>*=<S2SV_blank>vec3(1.0/%f);\\n" , peak ) ; } | <S2SV_ModStart> , float peak , var_t luma <S2SV_ModStart> : GLSL ( "color.rgb<S2SV_blank>*=<S2SV_blank>vec3(%f<S2SV_blank>*<S2SV_blank>pow(dot(%s,<S2SV_blank>color.rgb),<S2SV_blank>0.2));\\n" <S2SV_ModEnd> , ( 1000 <S2SV_ModStart> , 1.2 ) , luma |
6,950 | CWE-000 static int master_score ( resource_t * rsc , node_t * node , int not_set_value ) { char * name = rsc -> id ; const char * attr_value = NULL ; int score = not_set_value ; <S2SV_StartBug> if ( rsc -> children ) { <S2SV_EndBug> GListPtr gIter = rsc -> children ; for ( ; gIter != NULL ; gIter = gIter -> next ) { resource_t * child = ( resource_t * ) gIter -> data ; int c_score = master_score ( child , node , not_set_value ) ; if ( score == not_set_value ) { score = c_score ; } else { score += c_score ; } } return score ; } <S2SV_StartBug> if ( node == NULL ) { <S2SV_EndBug> if ( rsc -> fns -> state ( rsc , TRUE ) < RSC_ROLE_STARTED ) { pe_rsc_trace ( rsc , "Ignoring<S2SV_blank>master<S2SV_blank>score<S2SV_blank>for<S2SV_blank>%s:<S2SV_blank>unknown<S2SV_blank>state" , rsc -> id ) ; return score ; } } else { node_t * match = NULL ; if ( is_not_set ( rsc -> flags , pe_rsc_unique ) && filter_anonymous_instance ( rsc , node ) ) { pe_rsc_trace ( rsc , "Anonymous<S2SV_blank>clone<S2SV_blank>%s<S2SV_blank>is<S2SV_blank>allowed<S2SV_blank>on<S2SV_blank>%s" , rsc -> id , node -> details -> uname ) ; } else if ( rsc -> running_on || g_hash_table_size ( rsc -> known_on ) ) { node_t * known = pe_hash_table_lookup ( rsc -> known_on , node -> details -> id ) ; match = pe_find_node_id ( rsc -> running_on , node -> details -> id ) ; if ( ( match == NULL ) && ( known == NULL ) ) { pe_rsc_trace ( rsc , "skipping<S2SV_blank>%s<S2SV_blank>(aka.<S2SV_blank>%s)<S2SV_blank>master<S2SV_blank>score<S2SV_blank>on<S2SV_blank>%s<S2SV_blank>because<S2SV_blank>inactive" , rsc -> id , rsc -> clone_name , node -> details -> uname ) ; return score ; } } match = pe_hash_table_lookup ( rsc -> allowed_nodes , node -> details -> id ) ; if ( match == NULL ) { return score ; } else if ( match -> weight < 0 ) { pe_rsc_trace ( rsc , "%s<S2SV_blank>on<S2SV_blank>%s<S2SV_blank>has<S2SV_blank>score:<S2SV_blank>%d<S2SV_blank>-<S2SV_blank>ignoring" , rsc -> id , match -> details -> uname , match -> weight ) ; return score ; } <S2SV_StartBug> } <S2SV_EndBug> if ( rsc -> clone_name ) { name = rsc -> clone_name ; } attr_value = lookup_master_score ( rsc , node , name ) ; pe_rsc_trace ( rsc , "master<S2SV_blank>score<S2SV_blank>for<S2SV_blank>%s<S2SV_blank>on<S2SV_blank>%s<S2SV_blank>=<S2SV_blank>%s" , name , node -> details -> uname , crm_str ( attr_value ) ) ; if ( ( attr_value == NULL ) && is_not_set ( rsc -> flags , pe_rsc_unique ) ) { name = clone_strip ( rsc -> id ) ; if ( strcmp ( rsc -> id , name ) ) { attr_value = lookup_master_score ( rsc , node , name ) ; pe_rsc_trace ( rsc , "stripped<S2SV_blank>master<S2SV_blank>score<S2SV_blank>for<S2SV_blank>%s<S2SV_blank>on<S2SV_blank>%s<S2SV_blank>=<S2SV_blank>%s" , name , node -> details -> uname , crm_str ( attr_value ) ) ; } free ( name ) ; } if ( attr_value != NULL ) { score = char2score ( attr_value ) ; } return score ; } | <S2SV_ModStart> = not_set_value ; node_t * match = NULL ; CRM_CHECK ( node != NULL , return not_set_value ) ; <S2SV_ModStart> score ; } <S2SV_ModEnd> if ( is_not_set <S2SV_ModStart> score ; } <S2SV_ModEnd> if ( rsc |
6,951 | CWE-000 static void receiveFileChunks ( const char * sql ) { PGresult * res ; if ( PQsendQueryParams ( conn , sql , 0 , NULL , NULL , NULL , NULL , 1 ) != 1 ) pg_fatal ( "could<S2SV_blank>not<S2SV_blank>send<S2SV_blank>query:<S2SV_blank>%s" , PQerrorMessage ( conn ) ) ; pg_log ( PG_DEBUG , "getting<S2SV_blank>file<S2SV_blank>chunks\\n" ) ; if ( PQsetSingleRowMode ( conn ) != 1 ) pg_fatal ( "could<S2SV_blank>not<S2SV_blank>set<S2SV_blank>libpq<S2SV_blank>connection<S2SV_blank>to<S2SV_blank>single<S2SV_blank>row<S2SV_blank>mode\\n" ) ; while ( ( res = PQgetResult ( conn ) ) != NULL ) { char * filename ; int filenamelen ; <S2SV_StartBug> int chunkoff ; <S2SV_EndBug> int chunksize ; char * chunk ; switch ( PQresultStatus ( res ) ) { case PGRES_SINGLE_TUPLE : break ; case PGRES_TUPLES_OK : PQclear ( res ) ; continue ; default : pg_fatal ( "unexpected<S2SV_blank>result<S2SV_blank>while<S2SV_blank>fetching<S2SV_blank>remote<S2SV_blank>files:<S2SV_blank>%s" , PQresultErrorMessage ( res ) ) ; } if ( PQnfields ( res ) != 3 || PQntuples ( res ) != 1 ) pg_fatal ( "unexpected<S2SV_blank>result<S2SV_blank>set<S2SV_blank>size<S2SV_blank>while<S2SV_blank>fetching<S2SV_blank>remote<S2SV_blank>files\\n" ) ; if ( PQftype ( res , 0 ) != TEXTOID || <S2SV_StartBug> PQftype ( res , 1 ) != INT4OID || <S2SV_EndBug> PQftype ( res , 2 ) != BYTEAOID ) { pg_fatal ( "unexpected<S2SV_blank>data<S2SV_blank>types<S2SV_blank>in<S2SV_blank>result<S2SV_blank>set<S2SV_blank>while<S2SV_blank>fetching<S2SV_blank>remote<S2SV_blank>files:<S2SV_blank>%u<S2SV_blank>%u<S2SV_blank>%u\\n" , PQftype ( res , 0 ) , PQftype ( res , 1 ) , PQftype ( res , 2 ) ) ; } if ( PQfformat ( res , 0 ) != 1 && PQfformat ( res , 1 ) != 1 && PQfformat ( res , 2 ) != 1 ) { pg_fatal ( "unexpected<S2SV_blank>result<S2SV_blank>format<S2SV_blank>while<S2SV_blank>fetching<S2SV_blank>remote<S2SV_blank>files\\n" ) ; } if ( PQgetisnull ( res , 0 , 0 ) || PQgetisnull ( res , 0 , 1 ) ) { pg_fatal ( "unexpected<S2SV_blank>null<S2SV_blank>values<S2SV_blank>in<S2SV_blank>result<S2SV_blank>while<S2SV_blank>fetching<S2SV_blank>remote<S2SV_blank>files\\n" ) ; } <S2SV_StartBug> if ( PQgetlength ( res , 0 , 1 ) != sizeof ( int32 ) ) <S2SV_EndBug> pg_fatal ( "unexpected<S2SV_blank>result<S2SV_blank>length<S2SV_blank>while<S2SV_blank>fetching<S2SV_blank>remote<S2SV_blank>files\\n" ) ; <S2SV_StartBug> memcpy ( & chunkoff , PQgetvalue ( res , 0 , 1 ) , sizeof ( int32 ) ) ; <S2SV_EndBug> <S2SV_StartBug> chunkoff = ntohl ( chunkoff ) ; <S2SV_EndBug> chunksize = PQgetlength ( res , 0 , 2 ) ; filenamelen = PQgetlength ( res , 0 , 0 ) ; filename = pg_malloc ( filenamelen + 1 ) ; memcpy ( filename , PQgetvalue ( res , 0 , 0 ) , filenamelen ) ; filename [ filenamelen ] = '\\0' ; chunk = PQgetvalue ( res , 0 , 2 ) ; if ( PQgetisnull ( res , 0 , 2 ) ) { pg_log ( PG_DEBUG , "received<S2SV_blank>null<S2SV_blank>value<S2SV_blank>for<S2SV_blank>chunk<S2SV_blank>for<S2SV_blank>file<S2SV_blank>\\"%s\\",<S2SV_blank>file<S2SV_blank>has<S2SV_blank>been<S2SV_blank>deleted\\n" , filename ) ; pg_free ( filename ) ; PQclear ( res ) ; continue ; } <S2SV_StartBug> pg_log ( PG_DEBUG , "received<S2SV_blank>chunk<S2SV_blank>for<S2SV_blank>file<S2SV_blank>\\"%s\\",<S2SV_blank>offset<S2SV_blank>%d,<S2SV_blank>size<S2SV_blank>%d\\n" , <S2SV_EndBug> filename , chunkoff , chunksize ) ; open_target_file ( filename , false ) ; write_target_range ( chunk , chunkoff , chunksize ) ; pg_free ( filename ) ; PQclear ( res ) ; } } | <S2SV_ModStart> int filenamelen ; int64 <S2SV_ModEnd> chunkoff ; int <S2SV_ModStart> 1 ) != INT8OID <S2SV_ModEnd> || PQftype ( <S2SV_ModStart> != sizeof ( int64 <S2SV_ModEnd> ) ) pg_fatal <S2SV_ModStart> , sizeof ( int64 <S2SV_ModEnd> ) ) ; <S2SV_ModStart> ; chunkoff = pg_recvint64 <S2SV_ModEnd> ( chunkoff ) <S2SV_ModStart> ( PG_DEBUG , "received<S2SV_blank>chunk<S2SV_blank>for<S2SV_blank>file<S2SV_blank>\\"%s\\",<S2SV_blank>offset<S2SV_blank>" INT64_FORMAT ",<S2SV_blank>size<S2SV_blank>%d\\n" <S2SV_ModEnd> , filename , |
6,952 | CWE-000 static PyObject * compress ( PyObject * Py_UNUSED ( self ) , PyObject * args , PyObject * kwargs ) { const char * mode = "default" ; size_t dest_size , total_size ; int acceleration = 1 ; int compression = 9 ; int store_size = 1 ; PyObject * py_dest ; char * dest , * dest_start ; compression_type comp ; size_t output_size ; Py_buffer source ; size_t source_size ; int return_bytearray = 0 ; Py_buffer dict = { NULL , NULL } ; static char * argnames [ ] = { "source" , "mode" , "store_size" , "acceleration" , "compression" , "return_bytearray" , "dict" , NULL } ; # if IS_PY3 if ( ! PyArg_ParseTupleAndKeywords ( args , kwargs , "y*|spiipz*" , argnames , & source , & mode , & store_size , & acceleration , & compression , & return_bytearray , & dict ) ) { return NULL ; } # else if ( ! PyArg_ParseTupleAndKeywords ( args , kwargs , "s*|siiiiz*" , argnames , & source , & mode , & store_size , & acceleration , & compression , & return_bytearray , & dict ) ) { return NULL ; } # endif source_size = ( size_t ) source . len ; if ( store_size && source_size > UINT_MAX ) { PyBuffer_Release ( & source ) ; PyBuffer_Release ( & dict ) ; PyErr_Format ( PyExc_OverflowError , "Input<S2SV_blank>too<S2SV_blank>large<S2SV_blank>for<S2SV_blank>storing<S2SV_blank>size<S2SV_blank>in<S2SV_blank>4<S2SV_blank>byte<S2SV_blank>header" ) ; return NULL ; } if ( ! strncmp ( mode , "default" , sizeof ( "default" ) ) ) { comp = DEFAULT ; } else if ( ! strncmp ( mode , "fast" , sizeof ( "fast" ) ) ) { comp = FAST ; } else if ( ! strncmp ( mode , "high_compression" , sizeof ( "high_compression" ) ) ) { comp = HIGH_COMPRESSION ; } else { PyBuffer_Release ( & source ) ; PyBuffer_Release ( & dict ) ; PyErr_Format ( PyExc_ValueError , "Invalid<S2SV_blank>mode<S2SV_blank>argument:<S2SV_blank>%s.<S2SV_blank>Must<S2SV_blank>be<S2SV_blank>one<S2SV_blank>of:<S2SV_blank>standard,<S2SV_blank>fast,<S2SV_blank>high_compression" , mode ) ; return NULL ; } dest_size = LZ4_compressBound ( source_size ) ; if ( store_size ) { total_size = dest_size + hdr_size ; } else { total_size = dest_size ; } dest = PyMem_Malloc ( total_size * sizeof * dest ) ; if ( dest == NULL ) { return PyErr_NoMemory ( ) ; } Py_BEGIN_ALLOW_THREADS if ( store_size ) { store_le32 ( dest , source_size ) ; dest_start = dest + hdr_size ; } else { dest_start = dest ; } output_size = lz4_compress_generic ( comp , source . buf , dest_start , source_size , dest_size , dict . buf , dict . len , acceleration , compression ) ; Py_END_ALLOW_THREADS PyBuffer_Release ( & source ) ; PyBuffer_Release ( & dict ) ; <S2SV_StartBug> if ( output_size <= 0 ) <S2SV_EndBug> { PyErr_SetString ( PyExc_ValueError , "Compression<S2SV_blank>failed" ) ; PyMem_Free ( dest ) ; return NULL ; } if ( store_size ) { output_size += hdr_size ; } if ( return_bytearray ) { py_dest = PyByteArray_FromStringAndSize ( dest , ( Py_ssize_t ) output_size ) ; } else { py_dest = PyBytes_FromStringAndSize ( dest , ( Py_ssize_t ) output_size ) ; } PyMem_Free ( dest ) ; if ( py_dest == NULL ) { return PyErr_NoMemory ( ) ; } return py_dest ; } | <S2SV_ModStart> ; if ( ( ssize_t ) |
6,953 | CWE-000 <S2SV_StartBug> void pktReleaseBufferSemaphore ( radio_unit_t radio ) { <S2SV_EndBug> packet_svc_t * handler = pktGetServiceObject ( radio ) ; chDbgAssert ( handler != NULL , "invalid<S2SV_blank>radio<S2SV_blank>ID" ) ; chFactoryReleaseSemaphore ( handler -> tx_packet_sem ) ; handler -> tx_packet_sem = NULL ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> radio ) { # if USE_CCM_FOR_PKT_POOL != TRUE <S2SV_ModStart> = NULL ; # else ( void ) radio ; # endif |
6,954 | CWE-000 int LLVMFuzzerTestOneInput ( const uint8_t * data , size_t size ) { const char * stream = ( const char * ) data ; <S2SV_StartBug> if ( size < 3 || stream [ size - 1 ] != '\\0' || strchr ( stream , '\\n' ) ) { <S2SV_EndBug> return 0 ; } static bool isInit = false ; if ( ! isInit ) { vlog_set_verbosity ( "off" ) ; isInit = true ; } bool oxm = stream [ 0 ] % 2 ; enum ofp_version ver = ( stream [ 0 ] % OFP16_VERSION ) + 1 ; const char * input = & stream [ 1 ] ; ofctl_parse_nxm ( oxm , ver , input ) ; return 0 ; } | <S2SV_ModStart> stream , '\\n' ) || ( strlen ( stream ) != size - 1 |
6,955 | CWE-000 static void kpatch_create_dynamic_rela_sections ( struct kpatch_elf * kelf , struct lookup_table * table , char * hint , char * objname ) { int nr , index , objname_offset ; struct section * sec , * dynsec , * relasec ; struct rela * rela , * dynrela , * safe ; struct symbol * strsym ; struct lookup_result result ; struct kpatch_patch_dynrela * dynrelas ; int vmlinux , external , ret ; vmlinux = ! strcmp ( objname , "vmlinux" ) ; nr = 0 ; list_for_each_entry ( sec , & kelf -> sections , list ) { if ( ! is_rela_section ( sec ) ) continue ; if ( ! strcmp ( sec -> name , ".rela.kpatch.funcs" ) ) continue ; list_for_each_entry ( rela , & sec -> relas , list ) nr ++ ; } dynsec = create_section_pair ( kelf , ".kpatch.dynrelas" , sizeof ( * dynrelas ) , nr ) ; relasec = dynsec -> rela ; dynrelas = dynsec -> data -> d_buf ; strsym = find_symbol_by_name ( & kelf -> symbols , ".kpatch.strings" ) ; if ( ! strsym ) ERROR ( "can\'t<S2SV_blank>find<S2SV_blank>.kpatch.strings<S2SV_blank>symbol" ) ; objname_offset = offset_of_string ( & kelf -> strings , objname ) ; index = 0 ; list_for_each_entry ( sec , & kelf -> sections , list ) { if ( ! is_rela_section ( sec ) ) continue ; if ( ! strcmp ( sec -> name , ".rela.kpatch.funcs" ) || ! strcmp ( sec -> name , ".rela.kpatch.dynrelas" ) ) continue ; list_for_each_entry_safe ( rela , safe , & sec -> relas , list ) { if ( rela -> sym -> sec ) continue ; if ( kpatch_is_core_module_symbol ( rela -> sym -> name ) ) continue ; external = 0 ; if ( rela -> sym -> bind == STB_LOCAL ) { ret = lookup_local_symbol ( table , <S2SV_StartBug> rela -> sym -> name , hint , & result ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ret == 2 ) <S2SV_EndBug> ERROR ( "lookup_local_symbol:<S2SV_blank>ambiguous<S2SV_blank>%s:%s<S2SV_blank>relocation,<S2SV_blank>needed<S2SV_blank>for<S2SV_blank>%s" , hint , rela -> sym -> name , sec -> base -> name ) ; else if ( ret ) ERROR ( "lookup_local_symbol<S2SV_blank>%s:%s<S2SV_blank>needed<S2SV_blank>for<S2SV_blank>%s" , hint , rela -> sym -> name , sec -> base -> name ) ; } else if ( vmlinux ) { if ( lookup_is_exported_symbol ( table , rela -> sym -> name ) ) continue ; if ( lookup_global_symbol ( table , rela -> sym -> name , & result ) ) continue ; } else { if ( ! strcmp ( rela -> sym -> name , "__fentry__" ) ) continue ; if ( lookup_global_symbol ( table , rela -> sym -> name , & result ) ) external = 1 ; } log_debug ( "lookup<S2SV_blank>for<S2SV_blank>%s<S2SV_blank>@<S2SV_blank>0x%016lx<S2SV_blank>len<S2SV_blank>%lu\\n" , rela -> sym -> name , result . value , result . size ) ; if ( vmlinux ) dynrelas [ index ] . src = result . value ; else dynrelas [ index ] . src = 0 ; dynrelas [ index ] . addend = rela -> addend ; dynrelas [ index ] . type = rela -> type ; dynrelas [ index ] . external = external ; dynrelas [ index ] . sympos = result . pos ; ALLOC_LINK ( dynrela , & relasec -> relas ) ; if ( sec -> base -> sym ) dynrela -> sym = sec -> base -> sym ; else if ( sec -> base -> secsym ) dynrela -> sym = sec -> base -> secsym ; else ERROR ( "can\'t<S2SV_blank>create<S2SV_blank>dynrela<S2SV_blank>for<S2SV_blank>section<S2SV_blank>%s<S2SV_blank>(symbol<S2SV_blank>%s):<S2SV_blank>no<S2SV_blank>bundled<S2SV_blank>section<S2SV_blank>or<S2SV_blank>section<S2SV_blank>symbol" , sec -> name , rela -> sym -> name ) ; dynrela -> type = R_X86_64_64 ; dynrela -> addend = rela -> offset ; dynrela -> offset = index * sizeof ( * dynrelas ) ; ALLOC_LINK ( dynrela , & relasec -> relas ) ; dynrela -> sym = strsym ; dynrela -> type = R_X86_64_64 ; dynrela -> addend = offset_of_string ( & kelf -> strings , rela -> sym -> name ) ; dynrela -> offset = index * sizeof ( * dynrelas ) + offsetof ( struct kpatch_patch_dynrela , name ) ; ALLOC_LINK ( dynrela , & relasec -> relas ) ; dynrela -> sym = strsym ; dynrela -> type = R_X86_64_64 ; dynrela -> addend = objname_offset ; dynrela -> offset = index * sizeof ( * dynrelas ) + offsetof ( struct kpatch_patch_dynrela , objname ) ; rela -> sym -> strip = 1 ; list_del ( & rela -> list ) ; free ( rela ) ; index ++ ; } } dynsec -> data -> d_size = index * sizeof ( struct kpatch_patch_dynrela ) ; dynsec -> sh . sh_size = dynsec -> data -> d_size ; } | <S2SV_ModStart> -> name , <S2SV_ModEnd> & result ) <S2SV_ModStart> result ) ; <S2SV_ModEnd> if ( ret |
6,956 | CWE-000 int sc_pkcs15init_add_app ( struct sc_card * card , struct sc_profile * profile , struct sc_pkcs15init_initargs * args ) { struct sc_context * ctx = card -> ctx ; struct sc_pkcs15_card * p15card = profile -> p15_spec ; struct sc_pkcs15_auth_info pin_ainfo , puk_ainfo ; struct sc_pkcs15_pin_attributes * pin_attrs = & pin_ainfo . attrs . pin ; struct sc_pkcs15_object * pin_obj = NULL ; struct sc_app_info * app ; struct sc_file * df = profile -> df_info -> file ; <S2SV_StartBug> int r = SC_SUCCESS ; <S2SV_EndBug> LOG_FUNC_CALLED ( ctx ) ; p15card -> card = card ; p15card -> opts . use_pin_cache = 1 ; if ( card -> app_count >= SC_MAX_CARD_APPS ) LOG_TEST_RET ( ctx , SC_ERROR_TOO_MANY_OBJECTS , "Too<S2SV_blank>many<S2SV_blank>applications<S2SV_blank>on<S2SV_blank>this<S2SV_blank>card." ) ; <S2SV_StartBug> if ( args -> so_pin_len ) { <S2SV_EndBug> const char * pin_label ; <S2SV_StartBug> sc_profile_get_pin_info ( profile , SC_PKCS15INIT_SO_PIN , & pin_ainfo ) ; <S2SV_EndBug> r = sc_pkcs15init_qualify_pin ( card , "SO<S2SV_blank>PIN" , args -> so_pin_len , & pin_ainfo ) ; <S2SV_StartBug> LOG_TEST_RET ( ctx , r , "Failed<S2SV_blank>to<S2SV_blank>qualify<S2SV_blank>SO<S2SV_blank>PIN" ) ; <S2SV_EndBug> if ( pin_attrs -> flags & SC_PKCS15_PIN_FLAG_LOCAL ) pin_ainfo . path = df -> path ; if ( profile -> ops -> select_pin_reference ) { r = profile -> ops -> select_pin_reference ( profile , p15card , & pin_ainfo ) ; LOG_TEST_RET ( ctx , r , "Failed<S2SV_blank>to<S2SV_blank>select<S2SV_blank>card<S2SV_blank>specific<S2SV_blank>PIN<S2SV_blank>reference" ) ; } sc_profile_get_pin_info ( profile , SC_PKCS15INIT_SO_PUK , & puk_ainfo ) ; r = sc_pkcs15init_qualify_pin ( card , "SO<S2SV_blank>PUK" , args -> so_puk_len , & puk_ainfo ) ; LOG_TEST_RET ( ctx , r , "Failed<S2SV_blank>to<S2SV_blank>qualify<S2SV_blank>SO<S2SV_blank>PUK" ) ; if ( ! ( pin_label = args -> so_pin_label ) ) { if ( pin_attrs -> flags & SC_PKCS15_PIN_FLAG_SO_PIN ) pin_label = "Security<S2SV_blank>Officer<S2SV_blank>PIN" ; else pin_label = "User<S2SV_blank>PIN" ; } if ( args -> so_puk_len == 0 ) pin_attrs -> flags |= SC_PKCS15_PIN_FLAG_UNBLOCK_DISABLED ; pin_obj = sc_pkcs15init_new_object ( SC_PKCS15_TYPE_AUTH_PIN , pin_label , NULL , & pin_ainfo ) ; if ( pin_obj ) { sc_log ( ctx , "Add<S2SV_blank>virtual<S2SV_blank>SO_PIN(\'%.*s\',flags:%X,reference:%i,path:\'%s\')" , ( int ) sizeof pin_obj -> label , pin_obj -> label , pin_attrs -> flags , pin_attrs -> reference , sc_print_path ( & pin_ainfo . path ) ) ; r = sc_pkcs15_add_object ( p15card , pin_obj ) ; LOG_TEST_RET ( ctx , r , "Failed<S2SV_blank>to<S2SV_blank>add<S2SV_blank>\'SOPIN\'<S2SV_blank>AUTH<S2SV_blank>object" ) ; } } if ( profile -> ops -> init_card ) { r = profile -> ops -> init_card ( profile , p15card ) ; if ( r < 0 && pin_obj ) { sc_pkcs15_remove_object ( p15card , pin_obj ) ; sc_pkcs15_free_object ( pin_obj ) ; } LOG_TEST_RET ( ctx , r , "Card<S2SV_blank>specific<S2SV_blank>init<S2SV_blank>failed" ) ; } if ( profile -> ops -> create_dir ) r = profile -> ops -> create_dir ( profile , p15card , df ) ; LOG_TEST_RET ( ctx , r , "Create<S2SV_blank>\'DIR\'<S2SV_blank>error" ) ; if ( pin_obj && profile -> ops -> create_pin ) r = profile -> ops -> create_pin ( profile , p15card , df , pin_obj , args -> so_pin , args -> so_pin_len , args -> so_puk , args -> so_puk_len ) ; if ( pin_obj ) sc_pkcs15_remove_object ( p15card , pin_obj ) ; if ( r < 0 ) sc_pkcs15_free_object ( pin_obj ) ; LOG_TEST_RET ( ctx , r , "Card<S2SV_blank>specific<S2SV_blank>create<S2SV_blank>application<S2SV_blank>DF<S2SV_blank>failed" ) ; app = ( struct sc_app_info * ) calloc ( 1 , sizeof ( * app ) ) ; if ( app == NULL ) LOG_TEST_RET ( ctx , SC_ERROR_OUT_OF_MEMORY , "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>application<S2SV_blank>info" ) ; app -> path = p15card -> file_app -> path ; if ( p15card -> file_app -> namelen <= SC_MAX_AID_SIZE ) { app -> aid . len = p15card -> file_app -> namelen ; memcpy ( app -> aid . value , p15card -> file_app -> name , app -> aid . len ) ; } if ( args -> serial ) { sc_pkcs15init_set_serial ( profile , args -> serial ) ; } else { struct sc_serial_number serialnr ; r = sc_card_ctl ( card , SC_CARDCTL_GET_SERIALNR , & serialnr ) ; if ( r == SC_SUCCESS ) { char hex_serial [ SC_MAX_SERIALNR * 2 + 1 ] ; sc_bin_to_hex ( serialnr . value , serialnr . len , hex_serial , sizeof ( hex_serial ) , 0 ) ; sc_pkcs15init_set_serial ( profile , hex_serial ) ; } } if ( args -> label ) { if ( p15card -> tokeninfo -> label ) free ( p15card -> tokeninfo -> label ) ; p15card -> tokeninfo -> label = strdup ( args -> label ) ; } app -> label = strdup ( p15card -> tokeninfo -> label ) ; r = sc_pkcs15init_add_object ( p15card , profile , SC_PKCS15_AODF , pin_obj ) ; if ( r >= 0 ) { r = sc_pkcs15init_update_dir ( p15card , profile , app ) ; if ( r >= 0 ) { r = sc_pkcs15init_update_tokeninfo ( p15card , profile ) ; } else { free ( app -> label ) ; free ( app ) ; } } else { free ( app -> label ) ; free ( app ) ; } sc_pkcs15init_write_info ( p15card , profile , pin_obj ) ; LOG_FUNC_RETURN ( ctx , r ) ; } | <S2SV_ModStart> r = SC_SUCCESS ; int has_so_pin = args -> so_pin_len != 0 <S2SV_ModStart> ; if ( ! has_so_pin && ( card -> reader -> capabilities & SC_READER_CAP_PIN_PAD ) ) { sc_profile_get_pin_info ( profile , SC_PKCS15INIT_SO_PIN , & pin_ainfo ) ; has_so_pin = pin_ainfo . attrs . pin . reference != - 1 ; } if ( has_so_pin <S2SV_ModEnd> ) { const <S2SV_ModStart> * pin_label ; if ( args -> so_pin_len ) { <S2SV_ModStart> "Failed<S2SV_blank>to<S2SV_blank>qualify<S2SV_blank>SO<S2SV_blank>PIN" ) ; } |
6,957 | CWE-000 lwm2mcore_Sid_t lwm2mcore_GetParam ( lwm2mcore_Param_t paramId , uint8_t * bufferPtr , size_t * lenPtr ) { FILE * fPtr = NULL ; <S2SV_StartBug> int bsize = * lenPtr ; <S2SV_EndBug> int rsize = 0 ; char fname0 [ CONFIG_FILENAME_MAX_LENGTH ] ; char fname1 [ CONFIG_FILENAME_MAX_LENGTH ] ; if ( ( LWM2MCORE_MAX_PARAM <= paramId ) || ( NULL == bufferPtr ) || ( NULL == lenPtr ) ) { return LWM2MCORE_ERR_INVALID_ARG ; } <S2SV_StartBug> sprintf ( fname0 , "%s%d.txt" , CONFIG_FILENAME , paramId ) ; <S2SV_EndBug> sprintf ( fname1 , "%s%d.bak" , CONFIG_FILENAME , paramId ) ; if ( NULL != ( fPtr = fopen ( fname0 , "r" ) ) ) { if ( ( rsize = fread ( bufferPtr , 1 , bsize , fPtr ) ) == 0 ) { printf ( "Failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>file<S2SV_blank>%s\\n" , fname0 ) ; fclose ( fPtr ) ; return LWM2MCORE_ERR_GENERAL_ERROR ; } fclose ( fPtr ) ; } if ( rsize == 0 ) { if ( NULL != ( fPtr = fopen ( fname1 , "r" ) ) ) { if ( 0 == ( rsize = fread ( bufferPtr , 1 , bsize , fPtr ) ) ) { printf ( "Failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>file<S2SV_blank>%s\\n" , fname1 ) ; bsize = - 1 ; fclose ( fPtr ) ; return LWM2MCORE_ERR_GENERAL_ERROR ; } fclose ( fPtr ) ; } } * lenPtr = ( size_t ) rsize ; if ( ! rsize ) { return LWM2MCORE_ERR_GENERAL_ERROR ; } return LWM2MCORE_ERR_COMPLETED_OK ; } | <S2SV_ModStart> ; int bsize <S2SV_ModEnd> ; int rsize <S2SV_ModStart> LWM2MCORE_ERR_INVALID_ARG ; } bsize = * lenPtr ; |
6,958 | CWE-000 void drw_type_init ( void ) { # ifdef DRW_TYPE_PROVIDER_ENABLE_HPVEC drw_type_hpvec_initialize ( ) ; # endif # ifdef DRW_TYPE_PROVIDER_ENABLE_FTGLES drw_type_ftgles_initialize ( ) ; # endif # ifdef DRW_TYPE_PROVIDER_ENABLE_FTGL drw_type_ftgl_initialize ( ) ; # endif <S2SV_StartBug> drw_type_provider_select ( 0 ) ; <S2SV_EndBug> } | <S2SV_ModStart> ; # endif int n = drw_type_provider_count ( ) ; if ( n > 0 ) drw_type_provider_select ( n - 1 ) ; drw_type_set_align ( DRW_TYPE_ALIGN_H_RIGHT , DRW_TYPE_ALIGN_V_BOTTOM <S2SV_ModEnd> ) ; } |
6,959 | CWE-000 static int window_tree_command_callback ( struct client * c , void * modedata , const char * s , __unused int done ) { struct window_tree_modedata * data = modedata ; <S2SV_StartBug> if ( data -> dead ) <S2SV_EndBug> return ( 0 ) ; data -> entered = s ; mode_tree_each_tagged ( data -> data , window_tree_command_each , c , KEYC_NONE , 1 ) ; data -> entered = NULL ; data -> references ++ ; cmdq_append ( c , cmdq_get_callback ( window_tree_command_done , data ) ) ; return ( 0 ) ; } | <S2SV_ModStart> ; if ( s == NULL || |
6,960 | CWE-000 static void insert_theme ( GtkIconTheme * icon_theme , const gchar * theme_name ) { gint i ; GList * l ; gchar * * dirs ; gchar * * scaled_dirs ; gchar * * themes ; GtkIconThemePrivate * priv ; IconTheme * theme = NULL ; gchar * path ; GKeyFile * theme_file ; GError * error = NULL ; IconThemeDirMtime * dir_mtime ; GStatBuf stat_buf ; priv = icon_theme -> priv ; for ( l = priv -> themes ; l != NULL ; l = l -> next ) { theme = l -> data ; if ( strcmp ( theme -> name , theme_name ) == 0 ) return ; } for ( i = 0 ; i < priv -> search_path_len ; i ++ ) { path = g_build_filename ( priv -> search_path [ i ] , theme_name , NULL ) ; dir_mtime = g_slice_new ( IconThemeDirMtime ) ; dir_mtime -> cache = NULL ; dir_mtime -> dir = path ; if ( g_stat ( path , & stat_buf ) == 0 && S_ISDIR ( stat_buf . st_mode ) ) { dir_mtime -> mtime = stat_buf . st_mtime ; dir_mtime -> exists = TRUE ; } else { dir_mtime -> mtime = 0 ; dir_mtime -> exists = FALSE ; } priv -> dir_mtimes = g_list_prepend ( priv -> dir_mtimes , dir_mtime ) ; } <S2SV_StartBug> priv -> dir_mtimes = g_list_reverse ( priv -> dir_mtimes ) ; <S2SV_EndBug> theme_file = NULL ; for ( i = 0 ; i < priv -> search_path_len && ! theme_file ; i ++ ) { path = g_build_filename ( priv -> search_path [ i ] , theme_name , "index.theme" , NULL ) ; if ( g_file_test ( path , G_FILE_TEST_IS_REGULAR ) ) { theme_file = g_key_file_new ( ) ; g_key_file_set_list_separator ( theme_file , ',' ) ; if ( ! g_key_file_load_from_file ( theme_file , path , 0 , & error ) ) { g_key_file_free ( theme_file ) ; theme_file = NULL ; g_error_free ( error ) ; error = NULL ; } } g_free ( path ) ; } if ( theme_file || strcmp ( theme_name , FALLBACK_ICON_THEME ) == 0 ) { theme = g_new0 ( IconTheme , 1 ) ; theme -> name = g_strdup ( theme_name ) ; priv -> themes = g_list_prepend ( priv -> themes , theme ) ; if ( ! theme_file ) { theme_file = g_key_file_new ( ) ; g_key_file_set_list_separator ( theme_file , ',' ) ; g_key_file_load_from_data ( theme_file , builtin_hicolor_index , - 1 , 0 , NULL ) ; } } if ( theme_file == NULL ) return ; theme -> display_name = g_key_file_get_locale_string ( theme_file , "Icon<S2SV_blank>Theme" , "Name" , NULL , NULL ) ; if ( ! theme -> display_name ) g_warning ( "Theme<S2SV_blank>file<S2SV_blank>for<S2SV_blank>%s<S2SV_blank>has<S2SV_blank>no<S2SV_blank>name" , theme_name ) ; dirs = g_key_file_get_string_list ( theme_file , "Icon<S2SV_blank>Theme" , "Directories" , NULL , NULL ) ; if ( ! dirs ) { g_warning ( "Theme<S2SV_blank>file<S2SV_blank>for<S2SV_blank>%s<S2SV_blank>has<S2SV_blank>no<S2SV_blank>directories" , theme_name ) ; priv -> themes = g_list_remove ( priv -> themes , theme ) ; g_free ( theme -> name ) ; g_free ( theme -> display_name ) ; g_free ( theme ) ; g_key_file_free ( theme_file ) ; return ; } scaled_dirs = g_key_file_get_string_list ( theme_file , "Icon<S2SV_blank>Theme" , "ScaledDirectories" , NULL , NULL ) ; theme -> comment = g_key_file_get_locale_string ( theme_file , "Icon<S2SV_blank>Theme" , "Comment" , NULL , NULL ) ; theme -> example = g_key_file_get_string ( theme_file , "Icon<S2SV_blank>Theme" , "Example" , NULL ) ; theme -> dirs = NULL ; for ( i = 0 ; dirs [ i ] != NULL ; i ++ ) theme_subdir_load ( icon_theme , theme , theme_file , dirs [ i ] ) ; if ( scaled_dirs ) { for ( i = 0 ; scaled_dirs [ i ] != NULL ; i ++ ) theme_subdir_load ( icon_theme , theme , theme_file , scaled_dirs [ i ] ) ; } g_strfreev ( dirs ) ; g_strfreev ( scaled_dirs ) ; theme -> dirs = g_list_reverse ( theme -> dirs ) ; themes = g_key_file_get_string_list ( theme_file , "Icon<S2SV_blank>Theme" , "Inherits" , NULL , NULL ) ; if ( themes ) { for ( i = 0 ; themes [ i ] != NULL ; i ++ ) insert_theme ( icon_theme , themes [ i ] ) ; g_strfreev ( themes ) ; } g_key_file_free ( theme_file ) ; } | <S2SV_ModStart> ) ; } <S2SV_ModEnd> theme_file = NULL |
6,961 | CWE-000 static int intr_event_schedule_thread ( struct intr_event * ie ) { struct intr_entropy entropy ; struct intr_thread * it ; struct thread * td ; struct thread * ctd ; <S2SV_StartBug> if ( ie == NULL || TAILQ_EMPTY ( & ie -> ie_handlers ) || <S2SV_EndBug> ie -> ie_thread == NULL ) return ( EINVAL ) ; ctd = curthread ; it = ie -> ie_thread ; td = it -> it_thread ; if ( ie -> ie_flags & IE_ENTROPY ) { entropy . event = ( uintptr_t ) ie ; entropy . td = ctd ; random_harvest_queue ( & entropy , sizeof ( entropy ) , 2 , RANDOM_INTERRUPT ) ; } KASSERT ( td -> td_proc != NULL , ( "ithread<S2SV_blank>%s<S2SV_blank>has<S2SV_blank>no<S2SV_blank>process" , ie -> ie_name ) ) ; atomic_store_rel_int ( & it -> it_need , 1 ) ; thread_lock ( td ) ; if ( TD_AWAITING_INTR ( td ) ) { CTR3 ( KTR_INTR , "%s:<S2SV_blank>schedule<S2SV_blank>pid<S2SV_blank>%d<S2SV_blank>(%s)" , __func__ , td -> td_proc -> p_pid , td -> td_name ) ; TD_CLR_IWAIT ( td ) ; sched_add ( td , SRQ_INTR ) ; } else { CTR5 ( KTR_INTR , "%s:<S2SV_blank>pid<S2SV_blank>%d<S2SV_blank>(%s):<S2SV_blank>it_need<S2SV_blank>%d,<S2SV_blank>state<S2SV_blank>%d" , __func__ , td -> td_proc -> p_pid , td -> td_name , it -> it_need , td -> td_state ) ; } thread_unlock ( td ) ; return ( 0 ) ; } | <S2SV_ModStart> == NULL || CK_SLIST_EMPTY <S2SV_ModEnd> ( & ie |
6,962 | CWE-000 void bdbm_page_ftl_destroy ( bdbm_drv_info_t * bdi ) { bdbm_page_ftl_private_t * p = _ftl_page_ftl . ptr_private ; if ( ! p ) return ; if ( p -> gc_hlm_w . llm_reqs ) { hlm_reqs_pool_release_llm_reqs ( p -> gc_hlm_w . llm_reqs , p -> nr_punits_pages , RP_MEM_PHY ) ; bdbm_sema_free ( & p -> gc_hlm_w . done ) ; bdbm_free ( p -> gc_hlm_w . llm_reqs ) ; } if ( p -> gc_hlm . llm_reqs ) { hlm_reqs_pool_release_llm_reqs ( p -> gc_hlm . llm_reqs , p -> nr_punits_pages , RP_MEM_PHY ) ; bdbm_sema_free ( & p -> gc_hlm . done ) ; bdbm_free ( p -> gc_hlm . llm_reqs ) ; } if ( p -> gc_bab ) bdbm_free ( p -> gc_bab ) ; if ( p -> ac_bab ) __bdbm_page_ftl_destroy_active_blocks ( p -> ac_bab ) ; if ( p -> ptr_mapping_table ) __bdbm_page_ftl_destroy_mapping_table ( p -> ptr_mapping_table ) ; if ( p -> bai ) bdbm_abm_destroy ( p -> bai ) ; bdbm_free ( p ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> p ) ; int count ; destroy_c = bdbm_queue_get_nr_items ( fifo ) ; pr_info ( "Destroy<S2SV_blank>:<S2SV_blank>%d\\n" , destroy_c ) ; for ( count = 0 ; count < destroy_c ; count ++ ) { check = bdbm_queue_dequeue ( fifo , QID ) ; kfree ( check ) ; } bdbm_queue_destroy ( fifo ) ; |
6,963 | CWE-000 static void evict ( struct inode * inode ) { const struct super_operations * op = inode -> i_sb -> s_op ; BUG_ON ( ! ( inode -> i_state & I_FREEING ) ) ; BUG_ON ( ! list_empty ( & inode -> i_lru ) ) ; if ( ! list_empty ( & inode -> i_wb_list ) ) inode_wb_list_del ( inode ) ; inode_sb_list_del ( inode ) ; <S2SV_StartBug> inode_sync_wait ( inode ) ; <S2SV_EndBug> if ( op -> evict_inode ) { op -> evict_inode ( inode ) ; } else { if ( inode -> i_data . nrpages ) truncate_inode_pages ( & inode -> i_data , 0 ) ; clear_inode ( inode ) ; } if ( S_ISBLK ( inode -> i_mode ) && inode -> i_bdev ) bd_forget ( inode ) ; if ( S_ISCHR ( inode -> i_mode ) && inode -> i_cdev ) cd_forget ( inode ) ; remove_inode_hash ( inode ) ; spin_lock ( & inode -> i_lock ) ; wake_up_bit ( & inode -> i_state , __I_NEW ) ; BUG_ON ( inode -> i_state != ( I_FREEING | I_CLEAR ) ) ; spin_unlock ( & inode -> i_lock ) ; destroy_inode ( inode ) ; } | <S2SV_ModStart> inode ) ; inode_wait_for_writeback <S2SV_ModEnd> ( inode ) |
6,964 | CWE-000 int main_console ( ) { FILE * pfile ; <S2SV_StartBug> pfile = fopen ( "./data/profile/.profile.txt" , "r" ) ; <S2SV_EndBug> if ( pfile == NULL ) { hello_console ( ) ; } else { if ( load_profile ( ) == - 1 ) { hello_console ( ) ; } else { if ( load_max_index ( ) == - 1 ) { wprintf ( L"ERROR<S2SV_blank>OPEN<S2SV_blank>DATA!\\n" ) ; return 0 ; } <S2SV_StartBug> i_words = 1 ; <S2SV_EndBug> if ( learn_rand ( ) == - 1 ) { system ( "clear" ) ; exit ( 0 ) ; } learn_console ( ) ; } } return 0 ; } | <S2SV_ModStart> = fopen ( "./data/profile/profile.txt" <S2SV_ModEnd> , "r" ) <S2SV_ModStart> 0 ; } correct_start_program ( ) ; correct_index_console ( ) ; |
6,965 | CWE-000 int main ( int argc , char * argv [ ] ) { plan ( NO_PLAN ) ; commit_mgr_basic_tests ( ) ; commit_mgr_merge_tests ( ) ; commit_basic_tests ( ) ; commit_basic_commit_process_test ( ) ; commit_basic_commit_process_test_multiple_fences ( ) ; commit_basic_commit_process_test_multiple_fences_merge ( ) ; commit_basic_commit_process_test_invalid_commit ( ) ; commit_basic_root_not_dir ( ) ; commit_basic_iter_not_ready_tests ( ) ; commit_process_root_missing ( ) ; commit_process_missing_ref ( ) ; commit_process_error_callbacks ( ) ; commit_process_error_callbacks_partway ( ) ; commit_process_invalid_operation ( ) ; commit_process_malformed_operation ( ) ; commit_process_invalid_hash ( ) ; commit_process_follow_link ( ) ; commit_process_dirval_test ( ) ; commit_process_delete_test ( ) ; commit_process_delete_nosubdir_test ( ) ; commit_process_delete_filevalinpath_test ( ) ; commit_process_bad_dirrefs ( ) ; commit_process_big_fileval ( ) ; commit_process_giant_dir ( ) ; commit_process_append ( ) ; commit_process_append_errors ( ) ; <S2SV_StartBug> done_testing ( ) ; <S2SV_EndBug> return ( 0 ) ; } | <S2SV_ModStart> ( ) ; commit_process_revert_merge ( ) ; |
6,966 | CWE-000 struct dst_entry * fib6_rule_lookup ( struct net * net , struct flowi6 * fl6 , int flags , pol_lookup_t lookup ) { <S2SV_StartBug> struct rt6_info * rt ; <S2SV_EndBug> struct fib_lookup_arg arg = { . lookup_ptr = lookup , . flags = FIB_LOOKUP_NOREF , } ; fib_rules_lookup ( net -> ipv6 . fib6_rules_ops , flowi6_to_flowi ( fl6 ) , flags , & arg ) ; <S2SV_StartBug> rt = arg . result ; <S2SV_EndBug> <S2SV_StartBug> if ( ! rt ) { <S2SV_EndBug> dst_hold ( & net -> ipv6 . ip6_null_entry -> dst ) ; return & net -> ipv6 . ip6_null_entry -> dst ; } <S2SV_StartBug> if ( rt -> rt6i_flags & RTF_REJECT && <S2SV_EndBug> rt -> dst . error == - EAGAIN ) { ip6_rt_put ( rt ) ; rt = net -> ipv6 . ip6_null_entry ; dst_hold ( & rt -> dst ) ; } return & rt -> dst ; } | <S2SV_ModStart> lookup ) { <S2SV_ModEnd> struct fib_lookup_arg arg <S2SV_ModStart> arg ) ; if ( arg . result ) return <S2SV_ModEnd> arg . result <S2SV_ModStart> . result ; <S2SV_ModEnd> dst_hold ( & <S2SV_ModStart> dst ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
6,967 | CWE-000 void * communication_handler ( void * arg ) { ssize_t rd , wt ; struct srv_pthread_args t_args = * ( ( struct srv_pthread_args * ) arg ) ; char buffer [ BUFFER_MAX_SIZE ] ; char address [ ADDR_STR_MAX_SIZE ] ; <S2SV_StartBug> while ( 1 ) { <S2SV_EndBug> <S2SV_StartBug> memset ( buffer , 0 , sizeof ( buffer ) ) ; <S2SV_EndBug> memset ( address , 0 , sizeof ( address ) ) ; rd = read ( t_args . sockfd , buffer , sizeof ( buffer ) ) ; if ( rd < 0 ) { fprintf ( stderr , "ERROR:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; exit ( EXIT_FAILURE ) ; } else if ( rd == 0 ) { <S2SV_StartBug> puts ( "ALERT:<S2SV_blank>Closing<S2SV_blank>a<S2SV_blank>connection." ) ; <S2SV_EndBug> break ; } <S2SV_StartBug> sprintf ( address , "[%s:%hu]" , inet_ntoa ( t_args . cli_addr . sin_addr ) , t_args <S2SV_EndBug> . cli_addr . sin_port ) ; printf ( "%s:<S2SV_blank>%s" , address , buffer ) ; wt = write ( t_args . sockfd , "Recebi<S2SV_blank>a<S2SV_blank>mensagem!" , 18 ) ; if ( wt < 0 ) { fprintf ( stderr , "ERROR:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; exit ( EXIT_FAILURE ) ; } else if ( wt == 0 ) { <S2SV_StartBug> puts ( "ALERT:<S2SV_blank>Closing<S2SV_blank>a<S2SV_blank>connection." ) ; <S2SV_EndBug> break ; } } close ( t_args . sockfd ) ; return NULL ; } | <S2SV_ModStart> ADDR_STR_MAX_SIZE ] ; memset ( address , 0 , sizeof ( address ) ) ; sprintf ( address , "%s:%hu" , inet_ntoa ( t_args . cli_addr . sin_addr ) , t_args . cli_addr . sin_port ) ; printf ( "Client<S2SV_blank>%s<S2SV_blank>has<S2SV_blank>logged<S2SV_blank>in.\\n" , address ) ; <S2SV_ModStart> sizeof ( buffer <S2SV_ModEnd> ) ) ; <S2SV_ModStart> 0 ) { printf ( "Client<S2SV_blank>%s<S2SV_blank>has<S2SV_blank>logged<S2SV_blank>out.\\n" , address <S2SV_ModEnd> ) ; break <S2SV_ModStart> break ; } printf ( "[%s]:<S2SV_blank>%s" <S2SV_ModEnd> , address , <S2SV_ModStart> 0 ) { printf ( "Client<S2SV_blank>%s<S2SV_blank>has<S2SV_blank>logged<S2SV_blank>out.\\n" , address <S2SV_ModEnd> ) ; break |
6,968 | CWE-000 <S2SV_StartBug> static SERVER_CONNECT_REC * create ( void ) { <S2SV_EndBug> debug ( ) ; <S2SV_StartBug> return g_new0 ( SERVER_CONNECT_REC , 1 ) ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> static DISCORD_SERVER_CONNECT_REC <S2SV_ModEnd> * create ( <S2SV_ModStart> return g_new0 ( DISCORD_SERVER_CONNECT_REC <S2SV_ModEnd> , 1 ) |
6,969 | CWE-000 shadow_ulong_t __ShadowSystem_GetEpochNanoTime ( void ) { <S2SV_StartBug> return GetNanoTime ( CLOCK_REALTIME ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> void ) { # ifdef SHADOW_WINDOWS union { shadow_ulong_t actual ; FILETIME ft ; } now ; GetSystemTimeAsFileTime ( & now . ft ) ; return ( now . actual - OFFSET_FROM_1601_TO_1970 ) * 100 ; # elif SHADOW_MAC return get_nano_time ( CALENDAR_CLOCK ) ; # else return get_nano_time <S2SV_ModEnd> ( CLOCK_REALTIME ) <S2SV_ModStart> CLOCK_REALTIME ) ; # endif |
6,970 | CWE-000 static void qp_shutdown ( struct usiw_qp * qp ) { struct ibv_qp_attr qp_attr ; struct ibv_modify_qp cmd ; <S2SV_StartBug> int ret ; <S2SV_EndBug> send_trp_fin ( qp ) ; atomic_store ( & qp -> shm_qp -> conn_state , usiw_qp_error ) ; memset ( & qp_attr , 0 , sizeof ( qp_attr ) ) ; qp_attr . qp_state = IBV_QPS_ERR ; ibv_cmd_modify_qp ( & qp -> ib_qp , & qp_attr , IBV_QP_STATE , & cmd , sizeof ( cmd ) ) ; <S2SV_StartBug> sq_flush ( qp ) ; <S2SV_EndBug> rq_flush ( qp ) ; } | <S2SV_ModStart> ; int ret ; pthread_mutex_lock ( & qp -> shm_qp -> conn_event_lock ) <S2SV_ModStart> ) ) ; pthread_mutex_unlock ( & qp -> shm_qp -> conn_event_lock ) ; |
6,971 | CWE-000 void celix_arrayList_removeLong ( celix_array_list_t * list , long val ) { <S2SV_StartBug> celix_array_list_entry_t entry = { . longVal = val } ; <S2SV_EndBug> celix_arrayList_removeEntry ( list , entry ) ; } | <S2SV_ModStart> { celix_array_list_entry_t entry ; memset ( & entry , 0 , sizeof ( entry ) ) ; entry <S2SV_ModEnd> . longVal = <S2SV_ModStart> longVal = val <S2SV_ModEnd> ; celix_arrayList_removeEntry ( |
6,972 | CWE-000 void HandleCmd ( char * buf ) { addToHistory ( buf ) ; char correctedBuf [ MAX_BUF_SIZE ] ; char varName [ MAX_VAR_SIZE ] ; char varValue [ MAX_BUF_SIZE ] ; int i ; int j ; int correctedBufIndex = 0 ; for ( i = 0 ; i < strlen ( buf ) ; i ++ ) { if ( buf [ i ] == '$' ) { i ++ ; int startVarIndex = i ; while ( ! IsEndOfVar ( buf [ i ] ) ) { if ( ! IsCharValidVar ( buf [ i ] ) ) { printf ( 2 , "invalid<S2SV_blank>variable\\n" ) ; return ; } if ( i - startVarIndex >= MAX_VAR_SIZE ) { printf ( 2 , "variable<S2SV_blank>too<S2SV_blank>long\\n" ) ; return ; } varName [ i - startVarIndex ] = buf [ i ] ; i ++ ; } <S2SV_StartBug> varName [ i ] = 0 ; <S2SV_EndBug> if ( getVariable ( varName , varValue ) == 0 ) { int valueLength = strlen ( varValue ) ; for ( j = 0 ; j < valueLength ; j ++ ) { correctedBuf [ correctedBufIndex ++ ] = varValue [ j ] ; } <S2SV_StartBug> } <S2SV_EndBug> else { printf ( 2 , "variable<S2SV_blank>not<S2SV_blank>found\\n" ) ; return ; } } else { correctedBuf [ correctedBufIndex ++ ] = buf [ i ] ; } } for ( i = 0 ; i < MAX_BUF_SIZE ; i ++ ) { if ( correctedBuf [ i ] == '\\n' ) { break ; } if ( correctedBuf [ i ] == '=' ) { if ( i == 0 ) { printf ( 2 , "no<S2SV_blank>variable<S2SV_blank>name\\n" ) ; return ; } if ( i >= MAX_VAR_SIZE ) { printf ( 2 , "variable<S2SV_blank>too<S2SV_blank>long\\n" ) ; return ; } <S2SV_StartBug> correctedBuf [ i ] = 0 ; <S2SV_EndBug> <S2SV_StartBug> correctedBuf [ strlen ( correctedBuf ) - 1 ] = 0 ; <S2SV_EndBug> int setVarRet = setVariable ( correctedBuf , correctedBuf + i + 1 ) ; if ( setVarRet == - 1 ) { printf ( 2 , "no<S2SV_blank>room<S2SV_blank>for<S2SV_blank>aditional<S2SV_blank>variables\\n" ) ; } if ( setVarRet == - 2 ) { printf ( 2 , "input<S2SV_blank>is<S2SV_blank>illegal\\n" ) ; } return ; } } if ( correctedBuf [ 0 ] == 'c' && correctedBuf [ 1 ] == 'd' && correctedBuf [ 2 ] == '<S2SV_blank>' ) { correctedBuf [ strlen ( correctedBuf ) - 1 ] = 0 ; if ( chdir ( correctedBuf + 3 ) < 0 ) printf ( 2 , "cannot<S2SV_blank>cd<S2SV_blank>%s\\n" , correctedBuf + 3 ) ; return ; } if ( correctedBuf [ 0 ] == 'h' && correctedBuf [ 1 ] == 'i' && correctedBuf [ 2 ] == 's' && correctedBuf [ 3 ] == 't' && correctedBuf [ 4 ] == 'o' && correctedBuf [ 5 ] == 'r' && correctedBuf [ 6 ] == 'y' ) { if ( correctedBuf [ 7 ] == '\\n' ) { printHistory ( ) ; } else if ( correctedBuf [ 7 ] == '<S2SV_blank>' && correctedBuf [ 8 ] == '-' && correctedBuf [ 9 ] == 'l' && correctedBuf [ 10 ] == '<S2SV_blank>' ) { int index = atoi ( correctedBuf + 11 ) ; char cmdText [ MAX_BUF_SIZE ] ; char * fromHistory = getFromHistory ( index ) ; if ( fromHistory == 0 ) { printf ( 2 , "error:<S2SV_blank>invalid<S2SV_blank>hisotry<S2SV_blank>index\\n" ) ; return ; } strcpy ( cmdText , fromHistory ) ; HandleCmd ( cmdText ) ; } else { printf ( 2 , "cannot<S2SV_blank>history<S2SV_blank>%s\\n" , correctedBuf + 7 ) ; } return ; } if ( fork1 ( ) == 0 ) runcmd ( parsecmd ( correctedBuf ) ) ; wait ( ) ; } | <S2SV_ModStart> varName [ i - startVarIndex <S2SV_ModStart> ] ; } i -- ; <S2SV_ModStart> } correctedBuf [ <S2SV_ModEnd> strlen ( correctedBuf <S2SV_ModStart> ) - 1 ] = 0 ; correctedBuf [ i |
6,973 | CWE-000 void * batch_wrapper ( void * param ) { <S2SV_StartBug> linked_list_t * list = ( linked_list_t * ) ( param -> op ) ; <S2SV_EndBug> <S2SV_StartBug> op_t * curr_op = ( op_t * ) ( param -> op ) ; <S2SV_EndBug> <S2SV_StartBug> int current_key = ( ( curr_op ) -> key <S2SV_EndBug> if ( curr_op -> op == INSERT ) { curr_op -> result = list_insert ( list , current_key , ( curr_op -> data ) ) ; } if ( ( curr_op ) -> op == REMOVE ) { curr_op -> result = list_remove ( list , current_key ) ; } if ( curr_op -> op == CONTAINS ) { curr_op -> result = list_find ( list , current_key ) ; } if ( curr_op -> op == UPDATE ) { curr_op -> result = list_update ( list , current_key , curr_op -> data ) ; } int compute_result ; if ( curr_op -> op == COMPUTE ) { curr_op -> result = list_compute ( list , current_key , curr_op -> compute_func , & compute_result ) ; curr_op -> data = ( void * ) ( long long ) compute_result ; } free ( param ) ; } | <S2SV_ModStart> param ) { op_wrapper_t * wrapper = ( op_wrapper_t * ) param ; <S2SV_ModStart> * ) ( wrapper <S2SV_ModEnd> -> op ) <S2SV_ModStart> * ) ( wrapper <S2SV_ModEnd> -> op ) <S2SV_ModStart> current_key = ( <S2SV_ModEnd> curr_op ) -> <S2SV_ModStart> ) -> key ; |
6,974 | CWE-000 static int check_unlock ( struct task_struct * curr , struct lockdep_map * lock , unsigned long ip ) { if ( unlikely ( ! debug_locks ) ) return 0 ; if ( DEBUG_LOCKS_WARN_ON ( ! irqs_disabled ( ) ) ) return 0 ; if ( curr -> lockdep_depth <= 0 ) <S2SV_StartBug> return print_unlock_inbalance_bug ( curr , lock , ip ) ; <S2SV_EndBug> return 1 ; } | <S2SV_ModStart> 0 ) return print_unlock_imbalance_bug <S2SV_ModEnd> ( curr , |
6,975 | CWE-000 static Suite * gst_uri_suite ( void ) { Suite * s = suite_create ( "GstURI" ) ; TCase * tc_chain = tcase_create ( "uri" ) ; tcase_set_timeout ( tc_chain , 20 ) ; suite_add_tcase ( s , tc_chain ) ; tcase_add_test ( tc_chain , test_protocol_case ) ; <S2SV_StartBug> tcase_add_test ( tc_chain , test_uri_get_location ) ; <S2SV_EndBug> tcase_add_test ( tc_chain , test_uri_misc ) ; tcase_add_test ( tc_chain , test_element_make_from_uri ) ; # ifdef G_OS_WIN32 tcase_add_test ( tc_chain , test_win32_uri ) ; # endif tcase_add_test ( tc_chain , test_url_parsing ) ; tcase_add_test ( tc_chain , test_url_presenting ) ; tcase_add_test ( tc_chain , test_url_normalization ) ; tcase_add_test ( tc_chain , test_url_joining ) ; tcase_add_test ( tc_chain , test_url_equality ) ; tcase_add_test ( tc_chain , test_url_constructors ) ; tcase_add_test ( tc_chain , test_url_get_set ) ; tcase_add_test ( tc_chain , test_url_get_media_fragment_table ) ; return s ; } | <S2SV_ModStart> test_uri_get_location ) ; # ifndef GST_REMOVE_DEPRECATED tcase_add_test ( tc_chain , test_gst_uri_construct ) ; # endif |
6,976 | CWE-000 int thread_get_recent_cpu ( void ) { <S2SV_StartBug> return FP_INT ( FP_MUL_MIX ( thread_current ( ) -> recent_cpu , 100 ) ) ; <S2SV_EndBug> } | <S2SV_ModStart> , 100 ) + thread_current ( ) -> recent_cpu >= 0 ? ( 1 << FP_SHIFT_AMOUNT - 1 ) : - ( 1 << FP_SHIFT_AMOUNT - 1 ) |
6,977 | CWE-000 static int cpufreq_power2state ( struct thermal_cooling_device * cdev , struct thermal_zone_device * tz , u32 power , unsigned long * state ) { unsigned int cpu , cur_freq , target_freq ; int ret ; s32 dyn_power ; u32 last_load , normalised_power , static_power ; struct cpufreq_cooling_device * cpufreq_device = cdev -> devdata ; cpu = cpumask_any_and ( & cpufreq_device -> allowed_cpus , cpu_online_mask ) ; if ( cpu >= nr_cpu_ids ) return - ENODEV ; cur_freq = cpufreq_quick_get ( cpu ) ; ret = get_static_power ( cpufreq_device , tz , cur_freq , & static_power ) ; if ( ret ) return ret ; dyn_power = power - static_power ; dyn_power = dyn_power > 0 ? dyn_power : 0 ; last_load = cpufreq_device -> last_load ? : 1 ; normalised_power = ( dyn_power * 100 ) / last_load ; target_freq = cpu_power_to_freq ( cpufreq_device , normalised_power ) ; * state = cpufreq_cooling_get_level ( cpu , target_freq ) ; if ( * state == THERMAL_CSTATE_INVALID ) { <S2SV_StartBug> dev_warn_ratelimited ( & cdev -> device , <S2SV_EndBug> "Failed<S2SV_blank>to<S2SV_blank>convert<S2SV_blank>%dKHz<S2SV_blank>for<S2SV_blank>cpu<S2SV_blank>%d<S2SV_blank>into<S2SV_blank>a<S2SV_blank>cdev<S2SV_blank>state\\n" , target_freq , cpu ) ; return - EINVAL ; } trace_thermal_power_cpu_limit ( & cpufreq_device -> allowed_cpus , target_freq , * state , power ) ; return 0 ; } | <S2SV_ModStart> THERMAL_CSTATE_INVALID ) { dev_err_ratelimited <S2SV_ModEnd> ( & cdev |
6,978 | CWE-000 void process_bottom_halves ( void ) { unsigned int i ; unsigned int lid_receiver ; msg_t * msg_to_process ; msg_t * matched_msg ; for ( i = 0 ; i < n_prc_per_thread ; i ++ ) { while ( ( msg_to_process = ( msg_t * ) get_BH ( LPS_bound [ i ] -> lid ) ) != NULL ) { <S2SV_StartBug> lid_receiver = msg_to_process -> receiver ; <S2SV_EndBug> switch ( msg_to_process -> message_kind ) { case negative : statistics_post_lp_data ( msg_to_process -> receiver , STAT_ANTIMESSAGE , 1.0 ) ; matched_msg = list_tail ( LPS [ lid_receiver ] -> queue_in ) ; while ( matched_msg != NULL && matched_msg -> mark != msg_to_process -> mark ) { matched_msg = list_prev ( matched_msg ) ; } if ( matched_msg == NULL ) { rootsim_error ( false , "LP<S2SV_blank>%d<S2SV_blank>Received<S2SV_blank>an<S2SV_blank>antimessage<S2SV_blank>with<S2SV_blank>mark<S2SV_blank>%llu<S2SV_blank>at<S2SV_blank>LP<S2SV_blank>%u<S2SV_blank>from<S2SV_blank>LP<S2SV_blank>%u,<S2SV_blank>but<S2SV_blank>no<S2SV_blank>such<S2SV_blank>mark<S2SV_blank>found<S2SV_blank>in<S2SV_blank>the<S2SV_blank>input<S2SV_blank>queue!\\n" , LPS_bound [ i ] -> lid , msg_to_process -> mark , msg_to_process -> receiver , msg_to_process -> sender ) ; printf ( "Message<S2SV_blank>Content:" "sender:<S2SV_blank>%d\\n" "receiver:<S2SV_blank>%d\\n" "type:<S2SV_blank>%d\\n" "timestamp:<S2SV_blank>%f\\n" "send<S2SV_blank>time:<S2SV_blank>%f\\n" "is<S2SV_blank>antimessage<S2SV_blank>%d\\n" "mark:<S2SV_blank>%llu\\n" "rendezvous<S2SV_blank>mark<S2SV_blank>%llu\\n" , msg_to_process -> sender , msg_to_process -> receiver , msg_to_process -> type , msg_to_process -> timestamp , msg_to_process -> send_time , msg_to_process -> message_kind , msg_to_process -> mark , msg_to_process -> rendezvous_mark ) ; fflush ( stdout ) ; abort ( ) ; } else { if ( matched_msg -> timestamp <= lvt ( lid_receiver ) ) { LPS [ lid_receiver ] -> bound = list_prev ( matched_msg ) ; while ( ( LPS [ lid_receiver ] -> bound != NULL ) && LPS [ lid_receiver ] -> bound -> timestamp == msg_to_process -> timestamp ) { LPS [ lid_receiver ] -> bound = list_prev ( LPS [ lid_receiver ] -> bound ) ; } LPS [ lid_receiver ] -> state = LP_STATE_ROLLBACK ; } list_delete_by_content ( matched_msg -> sender , LPS [ lid_receiver ] -> queue_in , matched_msg ) ; list_deallocate_node_buffer ( LPS_bound [ i ] -> lid , msg_to_process ) ; } break ; case positive : list_place_by_content ( lid_receiver , LPS [ lid_receiver ] -> queue_in , timestamp , msg_to_process ) ; if ( msg_to_process -> timestamp < lvt ( lid_receiver ) ) { LPS [ lid_receiver ] -> bound = list_prev ( msg_to_process ) ; while ( ( LPS [ lid_receiver ] -> bound != NULL ) && LPS [ lid_receiver ] -> bound -> timestamp == msg_to_process -> timestamp ) { LPS [ lid_receiver ] -> bound = list_prev ( LPS [ lid_receiver ] -> bound ) ; } LPS [ lid_receiver ] -> state = LP_STATE_ROLLBACK ; } break ; default : rootsim_error ( true , "Received<S2SV_blank>a<S2SV_blank>message<S2SV_blank>which<S2SV_blank>is<S2SV_blank>neither<S2SV_blank>positive<S2SV_blank>nor<S2SV_blank>negative.<S2SV_blank>Aborting...\\n" ) ; } } } # ifdef HAVE_PREEMPTION reset_min_in_transit ( tid ) ; # endif } | <S2SV_ModStart> { lid_receiver = GidToLid ( <S2SV_ModStart> msg_to_process -> receiver ) |
6,979 | CWE-000 void cache_destroy ( CACHE * cache , int del_files ) { if ( cache != NULL ) { if ( del_files ) { errno = 0 ; if ( access ( cache -> path , F_OK ) == 0 ) { if ( rmdir_recursive ( cache -> path ) != 0 ) { printf ( "cache:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>delete<S2SV_blank>cache.\\n" ) ; } } else { perror ( "cache:<S2SV_blank>access()" ) ; } } <S2SV_StartBug> if ( cache -> name != NULL ) { <S2SV_EndBug> free ( cache -> name ) ; } if ( cache -> path != NULL ) { free ( cache -> path ) ; } free ( cache ) ; } } | <S2SV_ModStart> ; } } cache_db_destroy ( cache ) ; |
6,980 | CWE-000 static Query * transformValuesClause ( ParseState * pstate , SelectStmt * stmt ) { Query * qry = makeNode ( Query ) ; List * exprsLists = NIL ; List * * coltype_lists = NULL ; Oid * coltypes = NULL ; int sublist_length = - 1 ; List * newExprsLists ; RangeTblEntry * rte ; RangeTblRef * rtr ; ListCell * lc ; ListCell * lc2 ; int i ; qry -> commandType = CMD_SELECT ; Assert ( stmt -> distinctClause == NIL ) ; Assert ( stmt -> targetList == NIL ) ; Assert ( stmt -> fromClause == NIL ) ; Assert ( stmt -> whereClause == NULL ) ; Assert ( stmt -> groupClause == NIL ) ; Assert ( stmt -> havingClause == NULL ) ; Assert ( stmt -> scatterClause == NIL ) ; Assert ( stmt -> op == SETOP_NONE ) ; if ( stmt -> withClause ) { qry -> hasRecursive = stmt -> withClause -> recursive ; qry -> cteList = transformWithClause ( pstate , stmt -> withClause ) ; } foreach ( lc , stmt -> valuesLists ) { List * sublist = ( List * ) lfirst ( lc ) ; sublist = transformExpressionList ( pstate , sublist ) ; if ( sublist_length < 0 ) { sublist_length = list_length ( sublist ) ; coltype_lists = ( List * * ) palloc0 ( sublist_length * sizeof ( List * ) ) ; coltypes = ( Oid * ) palloc0 ( sublist_length * sizeof ( Oid ) ) ; } else if ( sublist_length != list_length ( sublist ) ) { ereport ( ERROR , ( errcode ( ERRCODE_SYNTAX_ERROR ) , errmsg ( "VALUES<S2SV_blank>lists<S2SV_blank>must<S2SV_blank>all<S2SV_blank>be<S2SV_blank>the<S2SV_blank>same<S2SV_blank>length" ) , parser_errposition ( pstate , exprLocation ( ( Node * ) sublist ) ) ) ) ; } exprsLists = lappend ( exprsLists , sublist ) ; i = 0 ; foreach ( lc2 , sublist ) { Node * col = ( Node * ) lfirst ( lc2 ) ; if ( IsA ( col , SetToDefault ) ) ereport ( ERROR , ( errcode ( ERRCODE_SYNTAX_ERROR ) , errmsg ( "DEFAULT<S2SV_blank>can<S2SV_blank>only<S2SV_blank>appear<S2SV_blank>in<S2SV_blank>a<S2SV_blank>VALUES<S2SV_blank>list<S2SV_blank>within<S2SV_blank>INSERT" ) ) ) ; coltype_lists [ i ] = lappend_oid ( coltype_lists [ i ] , exprType ( col ) ) ; i ++ ; } } for ( i = 0 ; i < sublist_length ; i ++ ) { coltypes [ i ] = select_common_type ( coltype_lists [ i ] , "VALUES" ) ; } newExprsLists = NIL ; foreach ( lc , exprsLists ) { List * sublist = ( List * ) lfirst ( lc ) ; List * newsublist = NIL ; i = 0 ; foreach ( lc2 , sublist ) { Node * col = ( Node * ) lfirst ( lc2 ) ; col = coerce_to_common_type ( pstate , col , coltypes [ i ] , "VALUES" ) ; newsublist = lappend ( newsublist , col ) ; i ++ ; } newExprsLists = lappend ( newExprsLists , newsublist ) ; } rte = addRangeTableEntryForValues ( pstate , newExprsLists , NULL , true ) ; rtr = makeNode ( RangeTblRef ) ; rtr -> rtindex = list_length ( pstate -> p_rtable ) ; Assert ( rte == rt_fetch ( rtr -> rtindex , pstate -> p_rtable ) ) ; pstate -> p_joinlist = lappend ( pstate -> p_joinlist , rtr ) ; pstate -> p_relnamespace = lappend ( pstate -> p_relnamespace , rte ) ; pstate -> p_varnamespace = lappend ( pstate -> p_varnamespace , rte ) ; Assert ( pstate -> p_next_resno == 1 ) ; qry -> targetList = expandRelAttrs ( pstate , rte , rtr -> rtindex , 0 , - 1 ) ; qry -> sortClause = transformSortClause ( pstate , stmt -> sortClause , & qry -> targetList , true , false ) ; qry -> limitOffset = transformLimitClause ( pstate , stmt -> limitOffset , "OFFSET" ) ; qry -> limitCount = transformLimitClause ( pstate , stmt -> limitCount , "LIMIT" ) ; if ( stmt -> lockingClause ) ereport ( ERROR , ( errcode ( ERRCODE_FEATURE_NOT_SUPPORTED ) , <S2SV_StartBug> errmsg ( "SELECT<S2SV_blank>FOR<S2SV_blank>UPDATE/SHARE<S2SV_blank>cannot<S2SV_blank>be<S2SV_blank>applied<S2SV_blank>to<S2SV_blank>VALUES" ) ) ) ; <S2SV_EndBug> if ( stmt -> distributedBy && Gp_role == GP_ROLE_DISPATCH ) setQryDistributionPolicy ( stmt , qry ) ; <S2SV_StartBug> qry -> intoClause = NULL ; <S2SV_EndBug> if ( stmt -> intoClause ) { qry -> intoClause = stmt -> intoClause ; if ( stmt -> intoClause -> colNames ) applyColumnNames ( qry -> targetList , stmt -> intoClause -> colNames ) ; } if ( list_length ( pstate -> p_joinlist ) != 1 ) ereport ( ERROR , ( errcode ( ERRCODE_FEATURE_NOT_SUPPORTED ) , errmsg ( "VALUES<S2SV_blank>must<S2SV_blank>not<S2SV_blank>contain<S2SV_blank>table<S2SV_blank>references" ) , parser_errposition ( pstate , locate_var_of_level ( ( Node * ) newExprsLists , 0 ) ) ) ) ; if ( list_length ( pstate -> p_rtable ) != 1 && contain_vars_of_level ( ( Node * ) newExprsLists , 0 ) ) ereport ( ERROR , ( errcode ( ERRCODE_FEATURE_NOT_SUPPORTED ) , errmsg ( "VALUES<S2SV_blank>must<S2SV_blank>not<S2SV_blank>contain<S2SV_blank>OLD<S2SV_blank>or<S2SV_blank>NEW<S2SV_blank>references" ) , errhint ( "Use<S2SV_blank>SELECT<S2SV_blank>...<S2SV_blank>UNION<S2SV_blank>ALL<S2SV_blank>...<S2SV_blank>instead." ) , parser_errposition ( pstate , locate_var_of_level ( ( Node * ) newExprsLists , 0 ) ) ) ) ; qry -> rtable = pstate -> p_rtable ; qry -> jointree = makeFromExpr ( pstate -> p_joinlist , NULL ) ; qry -> hasSubLinks = pstate -> p_hasSubLinks ; if ( pstate -> p_hasAggs ) ereport ( ERROR , ( errcode ( ERRCODE_GROUPING_ERROR ) , errmsg ( "cannot<S2SV_blank>use<S2SV_blank>aggregate<S2SV_blank>function<S2SV_blank>in<S2SV_blank>VALUES" ) , parser_errposition ( pstate , locate_agg_of_level ( ( Node * ) newExprsLists , 0 ) ) ) ) ; if ( pstate -> p_hasWindowFuncs ) ereport ( ERROR , ( errcode ( ERRCODE_WINDOWING_ERROR ) , errmsg ( "cannot<S2SV_blank>use<S2SV_blank>window<S2SV_blank>function<S2SV_blank>in<S2SV_blank>VALUES" ) , parser_errposition ( pstate , locate_windowfunc ( ( Node * ) newExprsLists ) ) ) ) ; return qry ; } | <S2SV_ModStart> ) ) ; qry -> intoClause = NULL ; if ( stmt -> intoClause ) { qry -> intoClause = stmt -> intoClause ; if ( stmt -> intoClause -> colNames ) applyColumnNames ( qry -> targetList , stmt -> intoClause -> colNames ) ; } <S2SV_ModStart> qry ) ; <S2SV_ModEnd> if ( list_length |
6,981 | CWE-000 void orb_avatar_step ( NVGcontext * vg , orb_data * orb , orb_avatar * av ) { orb_motion_step ( orb , & orb -> motion , & av -> x_pos , & av -> y_pos ) ; if ( av -> env > 0.001 ) { <S2SV_StartBug> av -> radius = orb_grid_size ( orb ) + <S2SV_EndBug> <S2SV_StartBug> ( 0.5 * ( 1 + cos ( av -> phs ) ) * orb_grid_size ( orb ) * 0.04 ) * av -> env ; <S2SV_EndBug> av -> phs = fmod ( av -> phs + ( av -> env * 25.0 * orb -> dtime ) , 2 * M_PI ) ; av -> env *= pow ( 0.3 , orb -> dtime ) ; } orb_motion_bounce_edges ( orb , & orb -> motion , & av -> x_pos , & av -> y_pos , <S2SV_StartBug> orb_grid_size ( orb ) ) ; <S2SV_EndBug> nvgBeginPath ( vg ) ; nvgArc ( vg , av -> x_pos , av -> y_pos , av -> radius , 0 , 2 * M_PI , NVG_CCW ) ; nvgClosePath ( vg ) ; nvgFillColor ( vg , orb -> color1 ) ; nvgFill ( vg ) ; } | <S2SV_ModStart> -> radius = av -> ir <S2SV_ModEnd> + ( 0.5 <S2SV_ModStart> ) ) * av -> ir <S2SV_ModEnd> * 0.04 ) <S2SV_ModStart> -> y_pos , av -> ir <S2SV_ModEnd> ) ; nvgBeginPath |
6,982 | CWE-000 int parse_portmap ( tcpedit_portmap_t * * portmap , const char * ourstr ) { tcpedit_portmap_t * portmap_ptr ; <S2SV_StartBug> char * substr = NULL , * ourstrcpy = NULL , * token = NULL ; <S2SV_EndBug> assert ( ourstr ) ; ourstrcpy = safe_strdup ( ourstr ) ; substr = strtok_r ( ourstrcpy , "," , & token ) ; if ( ( * portmap = ports2PORT ( substr ) ) == NULL ) { safe_free ( ourstrcpy ) ; return 0 ; } portmap_ptr = * portmap ; while ( portmap_ptr -> next != NULL ) portmap_ptr = portmap_ptr -> next ; while ( 1 ) { substr = strtok_r ( NULL , "," , & token ) ; if ( substr == NULL ) break ; portmap_ptr -> next = ports2PORT ( substr ) ; while ( portmap_ptr -> next != NULL ) portmap_ptr = portmap_ptr -> next ; } safe_free ( ourstrcpy ) ; return 1 ; } | <S2SV_ModStart> char * substr <S2SV_ModEnd> , * ourstrcpy <S2SV_ModStart> , * ourstrcpy <S2SV_ModEnd> , * token |
6,983 | CWE-000 id0_int_t ext_LoadShape ( const id0_char_t * Filename , struct Shape * SHP ) { # define CHUNK ( Name ) ( ( * ptr == * Name ) && ( * ( ptr + 1 ) == * ( Name + 1 ) ) && ( * ( ptr + 2 ) == * ( Name + 2 ) ) && ( * ( ptr + 3 ) == * ( Name + 3 ) ) ) id0_int_t RT_CODE ; id0_char_t id0_far * ptr ; memptr IFFfile = NULL ; id0_unsigned_long_t FileLen , size , ChunkLen ; RT_CODE = 1 ; if ( ! ( FileLen = ext_BLoad ( Filename , & IFFfile ) ) ) TrashProg ( "Can\'t<S2SV_blank>load<S2SV_blank>Compressed<S2SV_blank>Shape<S2SV_blank>-<S2SV_blank>Possibly<S2SV_blank>corrupt<S2SV_blank>file!" ) ; ptr = ( id0_char_t * ) IFFfile ; if ( ! CHUNK ( "FORM" ) ) goto EXIT_FUNC ; ptr += 4 ; FileLen = BE_Cross_Swap32BE ( * ( id0_long_t id0_far * ) ptr ) ; ptr += 4 ; if ( ! CHUNK ( "ILBM" ) ) goto EXIT_FUNC ; ptr += 4 ; FileLen += 4 ; while ( FileLen ) { <S2SV_StartBug> ChunkLen = BE_Cross_Swap32BE ( * ( id0_long_t id0_far * ) ( ptr + 4 ) ) ; <S2SV_EndBug> ChunkLen = ( ChunkLen + 1 ) & 0xFFFFFFFE ; if ( CHUNK ( "BMHD" ) ) { ptr += 8 ; SHP -> bmHdr . w = BE_Cross_Swap16BE ( ( ( struct BitMapHeader id0_far * ) ptr ) -> w ) ; SHP -> bmHdr . h = BE_Cross_Swap16BE ( ( ( struct BitMapHeader id0_far * ) ptr ) -> h ) ; SHP -> bmHdr . x = BE_Cross_Swap16BE ( ( ( struct BitMapHeader id0_far * ) ptr ) -> x ) ; SHP -> bmHdr . y = BE_Cross_Swap16BE ( ( ( struct BitMapHeader id0_far * ) ptr ) -> y ) ; # if 0 SHP -> bmHdr . w = ( ( struct BitMapHeader id0_far * ) ptr ) -> w ; SHP -> bmHdr . h = ( ( struct BitMapHeader id0_far * ) ptr ) -> h ; SHP -> bmHdr . x = ( ( struct BitMapHeader id0_far * ) ptr ) -> x ; SHP -> bmHdr . y = ( ( struct BitMapHeader id0_far * ) ptr ) -> y ; # endif SHP -> bmHdr . d = ( ( struct BitMapHeader id0_far * ) ptr ) -> d ; SHP -> bmHdr . trans = ( ( struct BitMapHeader id0_far * ) ptr ) -> trans ; SHP -> bmHdr . comp = ( ( struct BitMapHeader id0_far * ) ptr ) -> comp ; SHP -> bmHdr . pad = ( ( struct BitMapHeader id0_far * ) ptr ) -> pad ; # if 0 SwapWord ( & SHP -> bmHdr . w ) ; SwapWord ( & SHP -> bmHdr . h ) ; SwapWord ( & SHP -> bmHdr . x ) ; SwapWord ( & SHP -> bmHdr . y ) ; # endif ptr += ChunkLen ; } else if ( CHUNK ( "BODY" ) ) { ptr += 4 ; size = BE_Cross_Swap32BE ( * ( ( id0_long_t id0_far * ) ptr ) ) ; ptr += 4 ; SHP -> BPR = ( SHP -> bmHdr . w + 7 ) >> 3 ; SHP -> Data = malloc ( size ) ; if ( ! SHP -> Data ) goto EXIT_FUNC ; memcpy ( SHP -> Data , ptr , size ) ; ptr += ChunkLen ; break ; } else ptr += ChunkLen + 8 ; FileLen -= ChunkLen + 8 ; } RT_CODE = 0 ; EXIT_FUNC : ; if ( IFFfile ) { free ( IFFfile ) ; } return ( RT_CODE ) ; } | <S2SV_ModStart> FileLen ) { memcpy ( & ChunkLen , ptr + 4 , 4 ) ; <S2SV_ModStart> = BE_Cross_Swap32BE ( ChunkLen <S2SV_ModEnd> ) ; ChunkLen |
6,984 | CWE-000 static void storeData ( ) { IAPFile * file = IAPFile_new ( ) ; unsigned char i , buffer [ 8 ] ; <S2SV_StartBug> Debug ( DEBUG , HERE , "storeData()" ) ; <S2SV_EndBug> IAPFile_open ( file , "Snake.txt" ) ; for ( i = 1 ; i < 17 ; i ++ ) { sprintf ( buffer , "%u\\n" , dp -> highScore [ i ] ) ; IAPFile_write ( file , buffer , strlen ( buffer ) ) ; } sprintf ( buffer , "%u\\n" , dp -> level ) ; IAPFile_write ( file , buffer , strlen ( buffer ) ) ; IAPFile_close ( file ) ; IAPFile_delete ( file ) ; } | <S2SV_ModStart> Debug ( DEBUG <S2SV_ModEnd> , "storeData()" ) |
6,985 | CWE-000 void mostrar_espaciado ( ) { printf ( "\\n" ) ; <S2SV_StartBug> printf ( "///////////////////////////////////////////////////////////////<S2SV_blank>\\n" ) ; <S2SV_EndBug> printf ( "\\n" ) ; } | <S2SV_ModStart> ; printf ( "///////////////////////////////////////////////////////////////\\n" <S2SV_ModEnd> ) ; printf |
6,986 | CWE-000 uint8_t USBD_MIDI_TransmitPacket ( USBD_HandleTypeDef * pdev ) { <S2SV_StartBug> USBD_MIDI_HandleTypeDef * hcdc = ( USBD_MIDI_HandleTypeDef * ) pdev -> pClassData ; <S2SV_EndBug> if ( pdev -> pClassData != NULL ) { <S2SV_StartBug> if ( hcdc -> TxState == 0 ) <S2SV_EndBug> { <S2SV_StartBug> hcdc -> TxState = 1 ; <S2SV_EndBug> USBD_LL_Transmit ( pdev , USB_MIDI_DATA_IN_EP , <S2SV_StartBug> hcdc -> TxBuffer , <S2SV_EndBug> <S2SV_StartBug> hcdc -> TxLength ) ; <S2SV_EndBug> return USBD_OK ; } else { return USBD_BUSY ; } } else { return USBD_FAIL ; } } | <S2SV_ModStart> { USBD_MIDI_HandleTypeDef * hmidi <S2SV_ModEnd> = ( USBD_MIDI_HandleTypeDef <S2SV_ModStart> { if ( hmidi <S2SV_ModEnd> -> TxState == <S2SV_ModStart> 0 ) { hmidi <S2SV_ModEnd> -> TxState = <S2SV_ModStart> , USB_MIDI_DATA_IN_EP , hmidi <S2SV_ModEnd> -> TxBuffer , <S2SV_ModStart> -> TxBuffer , hmidi <S2SV_ModEnd> -> TxLength ) |
6,987 | CWE-000 static int action ( const nlmsg_t * msg ) { int i ; <S2SV_StartBug> printk ( KERN_INFO "Entering:<S2SV_blank>%s\\n" , __FUNCTION__ ) ; <S2SV_EndBug> for ( i = 0 ; i < IPE_COMMAND_COUNT ; ++ i ) { if ( dict [ i ] . command == msg -> command ) { dict [ i ] . handler ( msg ) ; return IPE_OK ; } } return IPE_UNKNOWN_ACTION ; } | <S2SV_ModStart> int i ; # ifdef IPE_DEBUG printk ( KERN_DEBUG "entering:<S2SV_blank>%s\\n" <S2SV_ModEnd> , __FUNCTION__ ) <S2SV_ModStart> __FUNCTION__ ) ; # endif |
6,988 | CWE-000 int ft_pwd ( t_env * e , char * * args ) { char buff [ PATH_MAX ] ; int option ; char * cwd ; if ( ( option = ft_pwd_check_option ( & args ) ) == - 1 ) return ( - 1 ) ; if ( option == 1 ) { cwd = getcwd ( buff , PATH_MAX ) ; if ( ! cwd ) return ( ft_error ( "cd:<S2SV_blank>error<S2SV_blank>retrieving<S2SV_blank>current<S2SV_blank>directory:<S2SV_blank>getcwd:<S2SV_blank>" , "cannot<S2SV_blank>access<S2SV_blank>parent<S2SV_blank>directories:<S2SV_blank>" , "No<S2SV_blank>such<S2SV_blank>file<S2SV_blank>or<S2SV_blank>directory" ) ) ; } else cwd = ft_getenv ( e -> env , "PWD" ) ; ft_putstr_fd ( cwd , STDOUT_FILENO ) ; ft_putchar_fd ( '\\n' , STDOUT_FILENO ) ; if ( option != 1 ) ft_strdel ( & cwd ) ; <S2SV_StartBug> return ( 0 ) ; <S2SV_EndBug> } | <S2SV_ModStart> ; return ( 1 <S2SV_ModEnd> ) ; } |
6,989 | CWE-000 static int mariadb_db_my_login ( pTHX_ SV * dbh , imp_dbh_t * imp_dbh ) { SV * sv ; HV * hv ; char * dbname ; char * host ; char * port ; char * user ; char * password ; char * mysql_socket ; int result ; D_imp_xxh ( dbh ) ; # define TAKE_IMP_DATA_VERSION 1 # if TAKE_IMP_DATA_VERSION if ( DBIc_has ( imp_dbh , DBIcf_IMPSET ) ) { if ( DBIc_has ( imp_dbh , DBIcf_ACTIVE ) ) { if ( DBIc_TRACE_LEVEL ( imp_xxh ) >= 2 ) PerlIO_printf ( DBIc_LOGPIO ( imp_xxh ) , "mariadb_db_my_login<S2SV_blank>skip<S2SV_blank>connect\\n" ) ; ++ DBIc_ACTIVE_KIDS ( DBIc_PARENT_COM ( imp_dbh ) ) ; return TRUE ; } if ( DBIc_TRACE_LEVEL ( imp_xxh ) >= 2 ) PerlIO_printf ( DBIc_LOGPIO ( imp_xxh ) , "mariadb_db_my_login<S2SV_blank>IMPSET<S2SV_blank>but<S2SV_blank>not<S2SV_blank>ACTIVE<S2SV_blank>so<S2SV_blank>connect<S2SV_blank>not<S2SV_blank>skipped\\n" ) ; } # endif sv = DBIc_IMP_DATA ( imp_dbh ) ; if ( ! sv || ! SvROK ( sv ) ) return FALSE ; hv = ( HV * ) SvRV ( sv ) ; if ( SvTYPE ( hv ) != SVt_PVHV ) return FALSE ; host = safe_hv_fetch ( aTHX_ hv , "host" , 4 ) ; port = safe_hv_fetch ( aTHX_ hv , "port" , 4 ) ; user = safe_hv_fetch ( aTHX_ hv , "user" , 4 ) ; password = safe_hv_fetch ( aTHX_ hv , "password" , 8 ) ; dbname = safe_hv_fetch ( aTHX_ hv , "database" , 8 ) ; mysql_socket = safe_hv_fetch ( aTHX_ hv , "mariadb_socket" , strlen ( "mariadb_socket" ) ) ; if ( DBIc_TRACE_LEVEL ( imp_xxh ) >= 2 ) PerlIO_printf ( DBIc_LOGPIO ( imp_xxh ) , "imp_dbh->mariadb_db_my_login<S2SV_blank>:<S2SV_blank>dbname<S2SV_blank>=<S2SV_blank>%s,<S2SV_blank>uid<S2SV_blank>=<S2SV_blank>%s,<S2SV_blank>pwd<S2SV_blank>=<S2SV_blank>%s," "host<S2SV_blank>=<S2SV_blank>%s,<S2SV_blank>port<S2SV_blank>=<S2SV_blank>%s\\n" , dbname ? dbname : "NULL" , user ? user : "NULL" , password ? password : "NULL" , host ? host : "NULL" , port ? port : "NULL" ) ; if ( ! imp_dbh -> pmysql ) { Newz ( 908 , imp_dbh -> pmysql , 1 , MYSQL ) ; <S2SV_StartBug> imp_dbh -> pmysql -> net . fd = - 1 ; <S2SV_EndBug> } result = mariadb_dr_connect ( dbh , imp_dbh -> pmysql , mysql_socket , host , port , user , password , dbname , imp_dbh ) ? TRUE : FALSE ; return result ; } | <S2SV_ModStart> MYSQL ) ; mysql_init ( imp_dbh -> pmysql ) ; |
6,990 | CWE-000 void vfs_cache_node_ref ( struct vfs_cache_node * node ) { if ( node ) { <S2SV_StartBug> print_path ( & node -> name ) ; <S2SV_EndBug> refcount_inc ( & node -> refcnt ) ; } } | <S2SV_ModStart> node ) { <S2SV_ModEnd> refcount_inc ( & |
6,991 | CWE-000 static void init_data_hidpp20 ( struct ratbag * ratbag , GKeyFile * keyfile , struct ratbag_device_data * data ) { const char * group = "Driver/hidpp20" ; GError * error = NULL ; int num ; data -> hidpp20 . index = - 1 ; num = g_key_file_get_integer ( keyfile , group , "DeviceIndex" , & error ) ; if ( num != 0 || ! error ) data -> hidpp20 . index = num ; if ( error ) g_error_free ( error ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> error ) ; data -> hidpp20 . is_wireless = g_key_file_get_boolean ( keyfile , group , "IsWireless" , NULL ) ; if ( data -> hidpp20 . is_wireless ) { free ( data -> svg ) ; data -> svg = NULL ; } |
6,992 | CWE-000 static void convert_version1 ( FILE * fdb_s , FILE * fdb_t ) { filedb1 fdb1 ; fseek ( fdb_s , 0L , SEEK_SET ) ; <S2SV_StartBug> while ( ! feof ( fdb_s ) ) { <S2SV_EndBug> <S2SV_StartBug> fread ( & fdb1 , sizeof ( filedb1 ) , 1 , fdb_s ) ; <S2SV_EndBug> if ( ! feof ( fdb_s ) ) { if ( ! ( fdb1 . stat & FILE_UNUSED ) ) { filedb_entry * fdbe = malloc_fdbe ( ) ; fdbe -> stat = fdb1 . stat ; if ( fdb1 . filename [ 0 ] ) malloc_strcpy ( fdbe -> filename , fdb1 . filename ) ; if ( fdb1 . desc [ 0 ] ) malloc_strcpy ( fdbe -> desc , fdb1 . desc ) ; if ( fdb1 . uploader [ 0 ] ) malloc_strcpy ( fdbe -> uploader , fdb1 . uploader ) ; if ( fdb1 . flags_req [ 0 ] ) malloc_strcpy ( fdbe -> flags_req , ( char * ) fdb1 . flags_req ) ; fdbe -> uploaded = fdb1 . uploaded ; fdbe -> size = fdb1 . size ; fdbe -> gots = fdb1 . gots ; if ( fdb1 . sharelink [ 0 ] ) malloc_strcpy ( fdbe -> sharelink , fdb1 . sharelink ) ; <S2SV_StartBug> filedb_addfile ( fdb_s , fdbe ) ; <S2SV_EndBug> free_fdbe ( & fdbe ) ; <S2SV_StartBug> } <S2SV_EndBug> } } } | <S2SV_ModStart> ( fdb_s ) && <S2SV_ModEnd> fread ( & <S2SV_ModStart> fdb1 , sizeof fdb1 <S2SV_ModEnd> , 1 , <S2SV_ModStart> , fdb_s ) && ! ferror <S2SV_ModEnd> ( fdb_s ) <S2SV_ModStart> ; filedb_addfile ( fdb_t <S2SV_ModEnd> , fdbe ) <S2SV_ModStart> fdbe ) ; <S2SV_ModEnd> } } } |
6,993 | CWE-000 void mm_map_kernel ( ) { memset ( & bootspace , 0 , sizeof ( bootspace ) ) ; mm_map_head ( ) ; <S2SV_StartBug> mm_map_segments ( ) ; <S2SV_EndBug> mm_map_boot ( ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ( ) ; print_state ( true , "Head<S2SV_blank>region<S2SV_blank>mapped" ) ; mm_map_segments ( ) ; print_state ( true , "Segments<S2SV_blank>mapped" <S2SV_ModEnd> ) ; mm_map_boot <S2SV_ModStart> ( ) ; print_state ( true , "Boot<S2SV_blank>region<S2SV_blank>mapped" ) ; |
6,994 | CWE-000 static Rboolean XFig_Open ( pDevDesc dd , XFigDesc * pd ) { char buf [ 512 ] , * tmp ; if ( strlen ( pd -> filename ) == 0 ) { XFig_cleanup ( dd , pd ) ; error ( _ ( "empty<S2SV_blank>file<S2SV_blank>name" ) ) ; return FALSE ; } else { snprintf ( buf , 512 , pd -> filename , pd -> pageno + 1 ) ; pd -> psfp = R_fopen ( R_ExpandFileName ( buf ) , "w" ) ; } if ( ! pd -> psfp ) { XFig_cleanup ( dd , pd ) ; error ( _ ( "cannot<S2SV_blank>open<S2SV_blank>file<S2SV_blank>\'%s\'" ) , buf ) ; return FALSE ; } tmp = R_tmpnam ( "Rxfig" , R_TempDir ) ; strcpy ( pd -> tmpname , tmp ) ; free ( tmp ) ; pd -> tmpfp = R_fopen ( pd -> tmpname , "w" ) ; if ( ! pd -> tmpfp ) { fclose ( pd -> psfp ) ; <S2SV_StartBug> XFig_cleanup ( dd , pd ) ; <S2SV_EndBug> <S2SV_StartBug> error ( _ ( "cannot<S2SV_blank>open<S2SV_blank>file<S2SV_blank>\'%s\'" ) , R_tmpnam ( "Rxfig" , R_TempDir ) ) ; <S2SV_EndBug> return FALSE ; } XF_FileHeader ( pd -> psfp , pd -> papername , pd -> landscape , pd -> onefile ) ; pd -> pageno = 0 ; return TRUE ; } | <S2SV_ModStart> psfp ) ; char errbuf [ strlen ( pd -> tmpname ) + 1 ] ; strcpy ( errbuf , pd -> tmpname ) ; <S2SV_ModStart> "cannot<S2SV_blank>open<S2SV_blank>file<S2SV_blank>\'%s\'" ) , errbuf <S2SV_ModEnd> ) ; return |
6,995 | CWE-000 int checkTetrimino ( t_tetris * tetris , t_pos pos ) { extern int map [ H ] [ W ] ; extern int tetrimino [ 24 ] [ 5 ] [ 5 ] ; int y ; int x ; for ( y = 0 ; y < 5 ; y ++ ) { for ( x = 0 ; x < 5 ; x ++ ) { if ( ( map [ pos . y + y ] [ pos . x + x ] + tetrimino [ tetris -> tetriminoType ] [ y ] [ x ] ) > 9 ) { <S2SV_StartBug> if ( y == 0 ) <S2SV_EndBug> { putTextMessage ( tetris , "YOU<S2SV_blank>LOSE" , ( SDL_Rect ) { ( WID - INFO ) / 2 , HEIG / 2 - WIDOFCUBE , INFO , WIDOFCUBE * 2 } ) ; SDL_RenderPresent ( tetris -> sdl . renderer ) ; SDL_Delay ( 1000 ) ; sdlDestroy ( tetris ) ; exit ( 0 ) ; } return ( 0 ) ; } } } return ( 1 ) ; } | <S2SV_ModStart> { if ( pos . y + |
6,996 | CWE-000 <S2SV_StartBug> float main ( ) { <S2SV_EndBug> float percent = 12 ; int days = 365 ; float deposit = 1000 ; printf ( "\\nВведите<S2SV_blank>изначальный<S2SV_blank>депозит:<S2SV_blank>" ) ; scanf ( "%100f" , & deposit ) ; printf ( "\\nВведите<S2SV_blank>кол-во<S2SV_blank>дней<S2SV_blank>с<S2SV_blank>момента<S2SV_blank>внесения:<S2SV_blank>" ) ; scanf ( "%3d" , & days ) ; if ( deposit < 1000 || days > 365 ) { printf ( "\\nВведены<S2SV_blank>некоректные<S2SV_blank>данные!\\n" ) ; return 0 ; } if ( days <= 30 ) { percent = - 10 ; } else if ( days <= 120 ) { percent = 2 ; } else if ( days <= 240 ) { percent = 6 ; } else if ( days > 240 ) { percent = 12 ; } float current = deposit + ( deposit / 100 * percent ) ; printf ( "\\nТекущий<S2SV_blank>баланс<S2SV_blank>счёта:<S2SV_blank>%2.3f\\n<S2SV_blank>Доход<S2SV_blank>по<S2SV_blank>вкладу:<S2SV_blank>%2.3f\\n" , current , profit ( deposit , current ) ) ; <S2SV_StartBug> return current ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> int <S2SV_ModEnd> main ( ) <S2SV_ModStart> ) ; return 0 <S2SV_ModEnd> ; } <S2SV_null> |
6,997 | CWE-000 static void ble_gap_test_util_update_l2cap ( struct ble_gap_upd_params * params , uint8_t hci_status , int event_status , uint16_t l2cap_result ) { struct ble_l2cap_sig_update_params l2cap_params ; struct ble_hs_conn * conn ; uint8_t id ; int rc ; uint8_t peer_addr [ 6 ] = { 1 , 2 , 3 , 4 , 5 , 6 } ; ble_gap_test_util_init ( ) ; ble_hs_test_util_create_conn ( 2 , peer_addr , ble_gap_test_util_connect_cb , NULL ) ; ble_hs_lock ( ) ; conn = ble_hs_conn_find ( 2 ) ; TEST_ASSERT_FATAL ( conn != NULL ) ; conn -> bhc_flags &= ~ BLE_HS_CONN_F_MASTER ; ble_hs_unlock ( ) ; ble_gap_test_util_reset_cb_info ( ) ; rc = ble_hs_test_util_conn_update ( 2 , params , hci_status ) ; TEST_ASSERT ( rc == 0 ) ; ble_gap_test_util_verify_tx_update_conn ( params ) ; switch ( hci_status ) { case 0 : ble_gap_test_util_rx_update_complete ( event_status , params ) ; break ; case BLE_ERR_UNKNOWN_HCI_CMD : break ; default : TEST_ASSERT_FATAL ( 0 ) ; break ; } TEST_ASSERT ( ble_gap_dbg_update_active ( 2 ) ) ; <S2SV_StartBug> l2cap_params . itvl_min = params -> itvl_min ; <S2SV_EndBug> l2cap_params . itvl_max = params -> itvl_max ; l2cap_params . slave_latency = params -> latency ; l2cap_params . timeout_multiplier = params -> supervision_timeout ; id = ble_hs_test_util_verify_tx_l2cap_update_req ( & l2cap_params ) ; ble_hs_test_util_rx_l2cap_update_rsp ( 2 , id , l2cap_result ) ; if ( l2cap_result == BLE_L2CAP_SIG_UPDATE_RSP_RESULT_ACCEPT ) { TEST_ASSERT ( ble_gap_dbg_update_active ( 2 ) ) ; ble_gap_test_util_rx_update_complete ( 0 , params ) ; } TEST_ASSERT ( ! ble_gap_dbg_update_active ( 2 ) ) ; TEST_ASSERT ( ble_gap_test_event . type == BLE_GAP_EVENT_CONN_UPDATE ) ; if ( l2cap_result != BLE_L2CAP_SIG_UPDATE_RSP_RESULT_ACCEPT ) { TEST_ASSERT ( ble_gap_test_conn_status == BLE_HS_EREJECT ) ; } else { TEST_ASSERT ( ble_gap_test_conn_status == 0 ) ; TEST_ASSERT ( ble_gap_test_conn_desc . conn_itvl == params -> itvl_max ) ; TEST_ASSERT ( ble_gap_test_conn_desc . conn_latency == params -> latency ) ; TEST_ASSERT ( ble_gap_test_conn_desc . supervision_timeout == params -> supervision_timeout ) ; } TEST_ASSERT ( ble_gap_test_conn_desc . conn_handle == 2 ) ; TEST_ASSERT ( memcmp ( ble_gap_test_conn_desc . peer_id_addr . val , peer_addr , 6 ) == 0 ) ; } | <S2SV_ModStart> ) ) ; rc = ble_hs_test_util_conn_update ( 2 , params , 0 ) ; TEST_ASSERT ( rc == BLE_HS_EALREADY ) ; rc = ble_hs_test_util_conn_update ( 2 , params , 0 ) ; TEST_ASSERT ( rc == BLE_HS_EALREADY ) ; |
6,998 | CWE-000 void cd ( uint8_t argNum , char * argStrings [ ] ) { printf ( "Found<S2SV_blank>cd\\n" ) ; <S2SV_StartBug> char * previousDirectory = currentFilePath ; <S2SV_EndBug> if ( argNum > 2 ) { safe_printf ( "Error.<S2SV_blank>Cd<S2SV_blank>must<S2SV_blank>require<S2SV_blank>at<S2SV_blank>most<S2SV_blank>one<S2SV_blank>argument\\n" ) ; return ; } else if ( argNum == 2 ) { char * directoryToMoveTo = argStrings [ 1 ] ; FILINFO fno ; strcat ( currentFilePath , "/" ) ; strcat ( currentFilePath , directoryToMoveTo ) ; FRESULT directoryResult = f_stat ( currentFilePath , & fno ) ; FRESULT changingDirectory ; switch ( directoryResult ) { case FR_OK : changingDirectory = f_chdir ( currentFilePath ) ; if ( changingDirectory != FR_OK ) { safe_printf ( "Something<S2SV_blank>went<S2SV_blank>wrong<S2SV_blank>when<S2SV_blank>changing<S2SV_blank>directory.\\n" ) ; strcpy ( currentFilePath , previousDirectory ) ; } else { safe_printf ( "Changed<S2SV_blank>directory<S2SV_blank>to<S2SV_blank>%s\\n" , currentFilePath ) ; } break ; case FR_NO_FILE : { safe_printf ( "Error.<S2SV_blank>Directory<S2SV_blank>does<S2SV_blank>not<S2SV_blank>exist\\n" ) ; strcpy ( currentFilePath , previousDirectory ) ; break ; } default : { safe_printf ( "Error.<S2SV_blank>Something<S2SV_blank>went<S2SV_blank>wrong.\\n" ) ; strcpy ( currentFilePath , previousDirectory ) ; } } } else { <S2SV_StartBug> previousDirectory = currentFilePath ; <S2SV_EndBug> strcpy ( currentFilePath , "/" ) ; FRESULT changingDirectory = f_chdir ( currentFilePath ) ; if ( changingDirectory != FR_OK ) { safe_printf ( "Error.<S2SV_blank>Could<S2SV_blank>not<S2SV_blank>transfer<S2SV_blank>back<S2SV_blank>to<S2SV_blank>root\\n" ) ; strcpy ( currentFilePath , previousDirectory ) ; } else { safe_printf ( "Moved<S2SV_blank>to<S2SV_blank>Root\\n" ) ; } } } | <S2SV_ModStart> ) ; char previousDirectory [ 256 ] ; strcpy ( previousDirectory , currentFilePath ) <S2SV_ModEnd> ; if ( <S2SV_ModStart> } else { strcpy ( previousDirectory , "/" ) <S2SV_ModEnd> ; strcpy ( |
6,999 | CWE-000 size_t hists__fprintf ( struct hists * self , struct hists * pair , bool show_displacement , FILE * fp ) { struct sort_entry * se ; struct rb_node * nd ; size_t ret = 0 ; unsigned long position = 1 ; long displacement = 0 ; unsigned int width ; const char * sep = symbol_conf . field_sep ; const char * col_width = symbol_conf . col_width_list_str ; init_rem_hits ( ) ; fprintf ( fp , "#<S2SV_blank>%s" , pair ? "Baseline" : "Overhead" ) ; if ( symbol_conf . show_nr_samples ) { if ( sep ) fprintf ( fp , "%cSamples" , * sep ) ; else fputs ( "<S2SV_blank><S2SV_blank>Samples<S2SV_blank><S2SV_blank>" , fp ) ; } if ( symbol_conf . show_cpu_utilization ) { if ( sep ) { ret += fprintf ( fp , "%csys" , * sep ) ; ret += fprintf ( fp , "%cus" , * sep ) ; if ( perf_guest ) { ret += fprintf ( fp , "%cguest<S2SV_blank>sys" , * sep ) ; ret += fprintf ( fp , "%cguest<S2SV_blank>us" , * sep ) ; } } else { ret += fprintf ( fp , "<S2SV_blank><S2SV_blank>sys<S2SV_blank><S2SV_blank>" ) ; ret += fprintf ( fp , "<S2SV_blank><S2SV_blank>us<S2SV_blank><S2SV_blank>" ) ; if ( perf_guest ) { ret += fprintf ( fp , "<S2SV_blank><S2SV_blank>guest<S2SV_blank>sys<S2SV_blank><S2SV_blank>" ) ; ret += fprintf ( fp , "<S2SV_blank><S2SV_blank>guest<S2SV_blank>us<S2SV_blank><S2SV_blank>" ) ; } } } if ( pair ) { if ( sep ) ret += fprintf ( fp , "%cDelta" , * sep ) ; else ret += fprintf ( fp , "<S2SV_blank><S2SV_blank>Delta<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" ) ; if ( show_displacement ) { if ( sep ) ret += fprintf ( fp , "%cDisplacement" , * sep ) ; else ret += fprintf ( fp , "<S2SV_blank>Displ" ) ; } } list_for_each_entry ( se , & hist_entry__sort_list , list ) { if ( se -> elide ) continue ; if ( sep ) { fprintf ( fp , "%c%s" , * sep , se -> se_header ) ; continue ; } width = strlen ( se -> se_header ) ; if ( se -> se_width ) { if ( symbol_conf . col_width_list_str ) { if ( col_width ) { * se -> se_width = atoi ( col_width ) ; col_width = strchr ( col_width , ',' ) ; if ( col_width ) ++ col_width ; } } width = * se -> se_width = max ( * se -> se_width , width ) ; } fprintf ( fp , "<S2SV_blank><S2SV_blank>%*s" , width , se -> se_header ) ; } fprintf ( fp , "\\n" ) ; if ( sep ) goto print_entries ; fprintf ( fp , "#<S2SV_blank>........" ) ; if ( symbol_conf . show_nr_samples ) fprintf ( fp , "<S2SV_blank>.........." ) ; if ( pair ) { fprintf ( fp , "<S2SV_blank>.........." ) ; if ( show_displacement ) fprintf ( fp , "<S2SV_blank>....." ) ; } list_for_each_entry ( se , & hist_entry__sort_list , list ) { unsigned int i ; if ( se -> elide ) continue ; fprintf ( fp , "<S2SV_blank><S2SV_blank>" ) ; if ( se -> se_width ) width = * se -> se_width ; else width = strlen ( se -> se_header ) ; for ( i = 0 ; i < width ; i ++ ) fprintf ( fp , "." ) ; } fprintf ( fp , "\\n#\\n" ) ; print_entries : for ( nd = rb_first ( & self -> entries ) ; nd ; nd = rb_next ( nd ) ) { struct hist_entry * h = rb_entry ( nd , struct hist_entry , rb_node ) ; <S2SV_StartBug> if ( show_displacement ) { <S2SV_EndBug> if ( h -> pair != NULL ) displacement = ( ( long ) h -> pair -> position - ( long ) position ) ; else displacement = 0 ; ++ position ; } <S2SV_StartBug> ret += hist_entry__fprintf ( h , pair , show_displacement , <S2SV_EndBug> <S2SV_StartBug> displacement , fp , self -> stats . total_period ) ; <S2SV_EndBug> if ( symbol_conf . use_callchain ) ret += hist_entry__fprintf_callchain ( h , fp , self -> stats . total_period ) ; if ( h -> ms . map == NULL && verbose > 1 ) { __map_groups__fprintf_maps ( & h -> thread -> mg , MAP__FUNCTION , verbose , fp ) ; fprintf ( fp , "%.10s<S2SV_blank>end\\n" , graph_dotted_line ) ; } } free ( rem_sq_bracket ) ; return ret ; } | <S2SV_ModStart> rb_node ) ; int cnt ; <S2SV_ModStart> position ; } cnt = <S2SV_ModEnd> hist_entry__fprintf ( h <S2SV_ModStart> . total_period ) ; if ( ! cnt ) continue ; ret += cnt |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.