Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
3,000 | CWE-000 int group_peername ( const Group_Chats * g_c , uint32_t groupnumber , int peernumber , uint8_t * name ) { Group_c * g = get_group_c ( g_c , groupnumber ) ; if ( ! g ) { return - 1 ; } if ( ( uint32_t ) peernumber >= g -> numpeers ) { return - 2 ; } if ( g -> group [ peernumber ] . nick_len == 0 ) { <S2SV_StartBug> memcpy ( name , "Tox<S2SV_blank>User" , 8 ) ; <S2SV_EndBug> <S2SV_StartBug> return 8 ; <S2SV_EndBug> } memcpy ( name , g -> group [ peernumber ] . nick , g -> group [ peernumber ] . nick_len ) ; return g -> group [ peernumber ] . nick_len ; } | <S2SV_ModStart> ( name , "" , 0 <S2SV_ModEnd> ) ; return <S2SV_ModStart> ) ; return 0 <S2SV_ModEnd> ; } memcpy |
3,001 | CWE-000 void destroy_secure_world ( struct acrn_vm * vm , bool need_clr_mem ) { struct acrn_vm * vm0 ; uint64_t hpa = vm -> sworld_control . sworld_memory . base_hpa ; uint64_t gpa_sos = vm -> sworld_control . sworld_memory . base_gpa_in_sos ; uint64_t gpa_uos = vm -> sworld_control . sworld_memory . base_gpa_in_uos ; uint64_t size = vm -> sworld_control . sworld_memory . length ; if ( vm -> arch_vm . sworld_eptp == NULL ) { pr_err ( "sworld<S2SV_blank>eptp<S2SV_blank>is<S2SV_blank>NULL,<S2SV_blank>it\'s<S2SV_blank>not<S2SV_blank>created" ) ; return ; } if ( need_clr_mem ) { <S2SV_StartBug> ( void ) memset ( hpa2hva ( hpa ) , 0U , size ) ; <S2SV_EndBug> } ept_mr_del ( vm , vm -> arch_vm . sworld_eptp , gpa_uos , size ) ; sanitize_pte ( ( uint64_t * ) vm -> arch_vm . sworld_eptp ) ; vm -> arch_vm . sworld_eptp = NULL ; vm0 = get_vm_from_vmid ( 0U ) ; ept_mr_add ( vm0 , vm0 -> arch_vm . nworld_eptp , hpa , gpa_sos , size , EPT_RWX | EPT_WB ) ; ept_mr_add ( vm , vm -> arch_vm . nworld_eptp , hpa , gpa_uos , size , EPT_RWX | EPT_WB ) ; } | <S2SV_ModStart> need_clr_mem ) { stac ( ) ; <S2SV_ModStart> 0U , size ) ; clac ( |
3,002 | CWE-000 static int test_exit_val ( int exit_val ) { int pid ; <S2SV_StartBug> int status ; <S2SV_EndBug> pid = fork ( ) ; if ( pid == 0 ) rte_exit ( exit_val , __func__ ) ; else if ( pid < 0 ) { printf ( "Fork<S2SV_blank>Failed\\n" ) ; return - 1 ; } wait ( & status ) ; printf ( "Child<S2SV_blank>process<S2SV_blank>status:<S2SV_blank>%d\\n" , status ) ; # ifndef RTE_EAL_ALWAYS_PANIC_ON_ERROR if ( ! WIFEXITED ( status ) || WEXITSTATUS ( status ) != ( uint8_t ) exit_val ) { printf ( "Child<S2SV_blank>process<S2SV_blank>terminated<S2SV_blank>with<S2SV_blank>incorrect<S2SV_blank>status<S2SV_blank>(expected<S2SV_blank>=<S2SV_blank>%d)!\\n" , exit_val ) ; return - 1 ; } # endif return 0 ; } | <S2SV_ModStart> ; int status ; rte_service_finalize ( ) |
3,003 | CWE-000 bool build_init_dir ( build_t * it ) { char author [ 256 ] ; char * author_for_js ; directory_t * dir ; const path_t * in_path ; int num_overwriting = 0 ; path_t * origin_path ; path_t * out_path ; char * output ; char summary [ 256 ] ; char * summary_for_js ; char * template ; size_t template_len ; char title [ 256 ] ; char * title_for_js ; visor_begin_op ( it -> visor , "gathering<S2SV_blank>information" ) ; origin_path = path_new ( "#/template/" ) ; dir = directory_open ( it -> fs , path_cstr ( origin_path ) , true ) ; while ( in_path = directory_next ( dir ) ) { out_path = path_dup ( in_path ) ; path_relativize ( out_path , origin_path ) ; path_insert_hop ( out_path , 0 , "$" ) ; if ( fs_fexist ( it -> fs , path_cstr ( out_path ) ) ) { visor_print ( it -> visor , "found<S2SV_blank>existing<S2SV_blank>file<S2SV_blank>\'%s\'" , path_cstr ( out_path ) ) ; ++ num_overwriting ; } path_free ( out_path ) ; } if ( num_overwriting <= 0 ) { visor_prompt ( it -> visor , "title<S2SV_blank>of<S2SV_blank>new<S2SV_blank>game?" , title , sizeof title ) ; visor_prompt ( it -> visor , "author\'s<S2SV_blank>name?" , author , sizeof author ) ; visor_prompt ( it -> visor , "one-line<S2SV_blank>summary?" , summary , sizeof summary ) ; visor_end_op ( it -> visor ) ; } else { visor_error ( it -> visor , "initialization<S2SV_blank>would<S2SV_blank>overwrite<S2SV_blank>%d<S2SV_blank>existing<S2SV_blank>file(s)" , num_overwriting ) ; visor_end_op ( it -> visor ) ; directory_close ( dir ) ; path_free ( origin_path ) ; return false ; } <S2SV_StartBug> visor_begin_op ( it -> visor , "copying<S2SV_blank>in<S2SV_blank>template<S2SV_blank>files" ) ; <S2SV_EndBug> fs_mkdir ( it -> fs , "$/" ) ; directory_seek ( dir , 0 ) ; while ( in_path = directory_next ( dir ) ) { out_path = path_dup ( in_path ) ; path_relativize ( out_path , origin_path ) ; path_insert_hop ( out_path , 0 , "$" ) ; visor_begin_op ( it -> visor , "copying<S2SV_blank>in<S2SV_blank>\'%s\'" , path_cstr ( out_path ) ) ; fs_fcopy ( it -> fs , path_cstr ( out_path ) , path_cstr ( in_path ) , false ) ; visor_end_op ( it -> visor ) ; path_free ( out_path ) ; } directory_close ( dir ) ; path_free ( origin_path ) ; visor_end_op ( it -> visor ) ; <S2SV_StartBug> visor_begin_op ( it -> visor , "initializing<S2SV_blank>new<S2SV_blank>Cellscript" ) ; <S2SV_EndBug> <S2SV_StartBug> title_for_js = strescp ( title , \'"\' ) ; <S2SV_EndBug> <S2SV_StartBug> author_for_js = strescp ( author , \'"\' ) ; <S2SV_EndBug> <S2SV_StartBug> summary_for_js = strescp ( summary , \'"\' ) ; <S2SV_EndBug> template = fs_fslurp ( it -> fs , "$/Cellscript.tmpl" , & template_len ) ; output = strfmt ( template , title_for_js , author_for_js , summary_for_js , "320" , "240" , NULL ) ; fs_fspew ( it -> fs , "$/Cellscript.mjs" , output , strlen ( output ) ) ; fs_unlink ( it -> fs , "$/Cellscript.tmpl" ) ; free ( title_for_js ) ; free ( author_for_js ) ; free ( summary_for_js ) ; free ( output ) ; free ( template ) ; visor_end_op ( it -> visor ) ; return true ; } | <S2SV_ModStart> -> visor , "copying<S2SV_blank>in<S2SV_blank>project<S2SV_blank>files" <S2SV_ModEnd> ) ; fs_mkdir <S2SV_ModStart> -> visor , "preparing<S2SV_blank>Cellscript<S2SV_blank>for<S2SV_blank>use" <S2SV_ModEnd> ) ; title_for_js <S2SV_ModStart> ; title_for_js = strescq <S2SV_ModEnd> ( title , <S2SV_ModStart> ; author_for_js = strescq <S2SV_ModEnd> ( author , <S2SV_ModStart> ; summary_for_js = strescq <S2SV_ModEnd> ( summary , |
3,004 | CWE-000 static int bif_xtra_forall ( tpl_query * q ) { node * args = get_args ( q ) ; node * term1 = get_callable ( term1 ) ; node * term2 = get_callable ( term2 ) ; <S2SV_StartBug> if ( ! q -> subq ) <S2SV_EndBug> q -> subq = query_create_subquery ( q ) ; <S2SV_StartBug> if ( ! q -> subq ) { <S2SV_EndBug> QABORT ( ABORT_OUTOFMEMORY ) ; return 0 ; } <S2SV_StartBug> tpl_query * subq = q -> subq ; <S2SV_EndBug> int did_lock = 0 ; if ( is_dynamic ( term1 ) && ! q -> in_tran ) { did_lock = 1 ; DBLOCK ( q -> c . curr_db ) ; } begin_query ( subq , term1 ) ; int ok = query_run ( subq ) ; while ( ok && ! g_abort ) { <S2SV_StartBug> begin_query ( subq , term2 ) ; <S2SV_EndBug> <S2SV_StartBug> query_run ( subq ) ; <S2SV_EndBug> ok = query_continue ( subq ) ; } if ( did_lock ) DBUNLOCK ( q -> c . curr_db ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> term2 ) ; tpl_query * <S2SV_ModEnd> subq = query_create_subquery <S2SV_ModStart> if ( ! <S2SV_ModEnd> subq ) { <S2SV_ModStart> 0 ; } <S2SV_ModEnd> int did_lock = <S2SV_ModStart> g_abort ) { subq -> c . curr_frame = FUDGE_FACTOR ; <S2SV_ModStart> term2 ) ; run_me ( subq ) ; if ( ! subq -> ok ) break <S2SV_ModEnd> ; ok = <S2SV_ModStart> curr_db ) ; query_destroy ( subq ) ; return 1 <S2SV_ModEnd> ; } <S2SV_null> |
3,005 | CWE-000 ll get_word ( char s [ ] , FILE * in ) { ll c , begin_of_word = 0 , lim = MAX_LENGTH_OF_WORD ; char * w = s ; <S2SV_StartBug> while ( isspace ( c = f_getc ( in ) ) || isdigit ( c ) ) <S2SV_EndBug> ; <S2SV_StartBug> if ( c != EOF ) <S2SV_EndBug> <S2SV_StartBug> { <S2SV_EndBug> * w ++ = tolower ( c ) ; begin_of_word = current_pos ; <S2SV_StartBug> } <S2SV_EndBug> if ( ! isalpha ( c ) ) { * w = '\\0' ; return c ; } for ( ; -- lim > 0 ; ++ w ) { if ( ! isalpha ( c = f_getc ( in ) ) ) { break ; } * w = tolower ( c ) ; } * w = '\\0' ; printf ( "%s:<S2SV_blank>%lld<S2SV_blank>%zu<S2SV_blank>[%s]\\n" , __func__ , begin_of_word , strlen ( s ) , s ) ; return begin_of_word ; } | <S2SV_ModStart> ; while ( ! isalpha <S2SV_ModEnd> ( c = <S2SV_ModStart> in ) ) && c != EOF ) ; assert ( isalpha <S2SV_ModEnd> ( c ) <S2SV_ModStart> ( c ) || c == EOF <S2SV_ModStart> if ( c == <S2SV_ModEnd> EOF ) { <S2SV_ModStart> EOF ) { * w = '\\0' ; return c ; } <S2SV_ModStart> = current_pos ; <S2SV_ModEnd> for ( ; |
3,006 | CWE-000 int bitmap_pgettext ( int sx , int sy , int ex , int ey , void * fill , uint32_t * fg , uint32_t * bg ) { int x , y ; unsigned char * out ; uint32_t * fgout ; uint32_t * bgout ; WORD sch ; struct vstat_vmem * vmem_ptr ; if ( ! bitmap_initialized ) return ( 0 ) ; if ( sx < 1 || sy < 1 || ex < 1 || ey < 1 || sx > ex || sy > ey || ex > cio_textinfo . screenwidth || ey > cio_textinfo . screenheight || fill == NULL ) { return ( 0 ) ; } pthread_mutex_lock ( & blinker_lock ) ; pthread_mutex_lock ( & vstatlock ) ; vmem_ptr = get_vmem ( & vstat ) ; out = fill ; fgout = fg ; bgout = bg ; for ( y = sy - 1 ; y < ey ; y ++ ) { for ( x = sx - 1 ; x < ex ; x ++ ) { sch = vmem_ptr -> vmem [ y * cio_textinfo . screenwidth + x ] ; * ( out ++ ) = sch & 0xff ; * ( out ++ ) = sch >> 8 ; if ( fg ) * ( fgout ++ ) = vmem_ptr -> fgvmem [ y * cio_textinfo . screenwidth + x ] ; if ( bg ) * ( bgout ++ ) = vmem_ptr -> bgvmem [ y * cio_textinfo . screenwidth + x ] ; } } release_vmem ( vmem_ptr ) ; pthread_mutex_unlock ( & vstatlock ) ; <S2SV_StartBug> return ( 1 ) ; <S2SV_EndBug> } | <S2SV_ModStart> vstatlock ) ; pthread_mutex_unlock ( & blinker_lock ) ; |
3,007 | CWE-000 static int l_kvsdir_index ( lua_State * L ) { int rc ; flux_t * f ; flux_kvsdir_t * d ; const char * key = lua_tostring ( L , 2 ) ; char * fullkey = NULL ; char * json_str = NULL ; if ( key == NULL ) return luaL_error ( L , "kvsdir:<S2SV_blank>invalid<S2SV_blank>index" ) ; d = lua_get_kvsdir ( L , 1 ) ; f = flux_kvsdir_handle ( d ) ; fullkey = flux_kvsdir_key_at ( d , key ) ; <S2SV_StartBug> if ( kvs_get ( f , fullkey , & json_str ) == 0 ) <S2SV_EndBug> rc = json_object_string_to_lua ( L , json_str ) ; else if ( errno == EISDIR ) rc = l_kvsdir_kvsdir_new ( L ) ; else { lua_getmetatable ( L , 1 ) ; lua_getfield ( L , - 1 , key ) ; if ( lua_isnil ( L , - 1 ) ) { rc = lua_pusherror ( L , "Key<S2SV_blank>not<S2SV_blank>found." ) ; goto out ; } rc = 1 ; } out : free ( fullkey ) ; free ( json_str ) ; return ( rc ) ; } | <S2SV_ModStart> ; if ( flux_kvs_get <S2SV_ModEnd> ( f , |
3,008 | CWE-000 static int cpuset_allow_attach ( struct cgroup_subsys_state * css , struct cgroup_taskset * tset ) { const struct cred * cred = current_cred ( ) , * tcred ; struct task_struct * task ; cgroup_taskset_for_each ( task , tset ) { tcred = __task_cred ( task ) ; <S2SV_StartBug> if ( current != task && ! uid_eq ( cred -> euid , tcred -> uid ) && <S2SV_EndBug> <S2SV_StartBug> ! capable ( CAP_SYS_ADMIN ) && ! uid_eq ( cred -> euid , tcred -> suid ) ) <S2SV_EndBug> return - EACCES ; } return 0 ; } | <S2SV_ModStart> ; if ( ( <S2SV_ModStart> current != task <S2SV_ModEnd> ) && ! <S2SV_ModStart> CAP_SYS_ADMIN ) && <S2SV_ModEnd> cred -> euid <S2SV_ModStart> cred -> euid . val != tcred -> uid . val && cred -> euid . val != <S2SV_ModEnd> tcred -> suid <S2SV_ModStart> tcred -> suid . val <S2SV_ModEnd> ) return - |
3,009 | CWE-000 double sum_all_alignments ( char * v , char * w , Align_Params * params , int min_band_width ) { int lv = strlen ( v ) , lw = strlen ( w ) ; int len_diff = lv - lw ; if ( len_diff < 0 ) len_diff *= - 1 ; int band_width = min_band_width + len_diff ; int b1 , b2 ; double * lower_prev = calloc ( sizeof ( double ) , lw + 1 ) ; double * middle_prev = calloc ( sizeof ( double ) , lw + 1 ) ; double * upper_prev = calloc ( sizeof ( double ) , lw + 1 ) ; double * lower_curr = calloc ( sizeof ( double ) , lw + 1 ) ; double * middle_curr = calloc ( sizeof ( double ) , lw + 1 ) ; double * upper_curr = calloc ( sizeof ( double ) , lw + 1 ) ; double log0 = - 100000 ; int i = 0 , j = 0 ; for ( i = 0 ; i < lw + 1 ; i ++ ) { lower_prev [ i ] = log0 ; middle_prev [ i ] = log0 ; upper_prev [ i ] = log0 ; lower_curr [ i ] = log0 ; middle_curr [ i ] = log0 ; upper_curr [ i ] = log0 ; } middle_prev [ 0 ] = 0.0 ; if ( ALLOW_END_GAPS == 1 ) { upper_prev [ 1 ] = params -> TRS [ 0 ] [ 2 ] ; for ( j = 2 ; j < lw + 1 ; j ++ ) upper_prev [ j ] = upper_prev [ j - 1 ] + params -> TRS [ 2 ] [ 2 ] ; } for ( i = 1 ; i < lv ; i ++ ) { int band_middle = ( lw * i ) / lv ; int band_start = 1 ; if ( band_middle - band_width / 2 >= 1 ) band_start = band_middle - band_width / 2 ; int band_end = lw ; if ( band_middle + band_width / 2 <= lw ) band_end = band_middle + band_width / 2 ; if ( ALLOW_END_GAPS == 1 ) { if ( band_start == 1 ) { middle_curr [ 0 ] = log0 ; if ( i == 1 ) lower_curr [ 0 ] = params -> TRS [ 0 ] [ 1 ] ; else lower_curr [ 0 ] = lower_prev [ 0 ] + params -> TRS [ 1 ] [ 1 ] ; } } for ( j = band_start ; j < band_end + 1 ; j ++ ) { <S2SV_StartBug> int lower_continue = lower_prev [ j ] + params -> TRS [ 1 ] [ 1 ] ; <S2SV_EndBug> <S2SV_StartBug> int lower_from_middle = middle_prev [ j ] + params -> TRS [ 0 ] [ 1 ] ; <S2SV_EndBug> lower_curr [ j ] = params -> insertion + logsum ( lower_continue , lower_from_middle ) ; <S2SV_StartBug> int upper_continue = upper_curr [ j - 1 ] + params -> TRS [ 2 ] [ 2 ] ; <S2SV_EndBug> <S2SV_StartBug> int upper_from_middle = middle_curr [ j - 1 ] + params -> TRS [ 0 ] [ 2 ] ; <S2SV_EndBug> upper_curr [ j ] = params -> deletion + logsum ( upper_continue , upper_from_middle ) ; <S2SV_StartBug> int middle_from_lower = lower_prev [ j - 1 ] + params -> TRS [ 1 ] [ 0 ] ; <S2SV_EndBug> <S2SV_StartBug> int middle_continue = middle_prev [ j - 1 ] + params -> TRS [ 0 ] [ 0 ] ; <S2SV_EndBug> <S2SV_StartBug> int middle_from_upper = upper_prev [ j - 1 ] + params -> TRS [ 2 ] [ 0 ] ; <S2SV_EndBug> double s = logsum ( middle_from_lower , middle_continue ) ; double match_emission = params -> match ; if ( v [ i - 1 ] != w [ j - 1 ] ) match_emission = params -> mismatch ; b1 = BTI [ v [ i - 1 ] ] - 1 ; b2 = BTI [ w [ j - 1 ] ] - 1 ; if ( b1 >= 0 && b2 < 4 && b2 >= 0 && b2 < 4 ) { match_emission = params -> MEM [ b1 ] [ b2 ] ; } middle_curr [ j ] = match_emission + logsum ( s , middle_from_upper ) ; } for ( j = band_start ; j < band_end + 1 ; j ++ ) { upper_prev [ j ] = upper_curr [ j ] ; middle_prev [ j ] = middle_curr [ j ] ; lower_prev [ j ] = lower_curr [ j ] ; } upper_curr [ band_start ] = log0 ; middle_curr [ band_start ] = log0 ; lower_curr [ band_start ] = log0 ; } double ll = middle_prev [ lw ] ; free ( lower_prev ) ; free ( middle_prev ) ; free ( upper_prev ) ; free ( lower_curr ) ; free ( middle_curr ) ; free ( upper_curr ) ; <S2SV_StartBug> return ll / log ( 10 ) ; <S2SV_EndBug> } | <S2SV_ModStart> ++ ) { double <S2SV_ModEnd> lower_continue = lower_prev <S2SV_ModStart> 1 ] ; double <S2SV_ModEnd> lower_from_middle = middle_prev <S2SV_ModStart> lower_from_middle ) ; double <S2SV_ModEnd> upper_continue = upper_curr <S2SV_ModStart> 2 ] ; double <S2SV_ModEnd> upper_from_middle = middle_curr <S2SV_ModStart> upper_from_middle ) ; double <S2SV_ModEnd> middle_from_lower = lower_prev <S2SV_ModStart> 0 ] ; double <S2SV_ModEnd> middle_continue = middle_prev <S2SV_ModStart> 0 ] ; double <S2SV_ModEnd> middle_from_upper = upper_prev <S2SV_ModStart> ; return ll <S2SV_ModEnd> ; } <S2SV_null> |
3,010 | CWE-000 static OCEntityHandlerResult HandleCloudDeleteRequest ( OCEntityHandlerRequest * ehRequest ) { OIC_LOG_V ( DEBUG , TAG , "%s:<S2SV_blank>IN" , __func__ ) ; OCEntityHandlerResult ehRet = OC_EH_INTERNAL_SERVER_ERROR ; OicCloud_t * cloud = NULL ; OCRepPayload * payload = NULL ; bool isDeviceOwned = false ; OicCloud_t * p1 = NULL , * p2 = NULL ; OCEntityHandlerResponse response ; VERIFY_NOT_NULL ( TAG , ehRequest , ERROR ) ; VERIFY_NOT_NULL ( TAG , ehRequest -> payload , ERROR ) ; OCGetDeviceOwnedState ( & isDeviceOwned ) ; if ( ! isDeviceOwned ) { OIC_LOG_V ( ERROR , TAG , "%s:<S2SV_blank>device<S2SV_blank>is<S2SV_blank>not<S2SV_blank>owned" , __func__ ) ; ehRet = OC_EH_NOT_ACCEPTABLE ; goto exit ; } cloud = ( OicCloud_t * ) OICCalloc ( 1 , sizeof ( OicCloud_t ) ) ; VERIFY_NOT_NULL ( TAG , cloud , ERROR ) ; payload = ( OCRepPayload * ) ehRequest -> payload ; if ( ! cloud -> cis || ! OCRepPayloadGetPropString ( payload , OC_CLOUD_PROVISIONING_CIS , & cloud -> cis ) ) { OIC_LOG_V ( ERROR , TAG , "%s:<S2SV_blank>Can\'t<S2SV_blank>get:<S2SV_blank>%s" , __func__ , OC_CLOUD_PROVISIONING_CIS ) ; goto exit ; } if ( ! OCRepPayloadGetPropString ( payload , OC_CLOUD_PROVISIONING_APN , & cloud -> apn ) ) { OIC_LOG_V ( ERROR , TAG , "%s:<S2SV_blank>Can\'t<S2SV_blank>get:<S2SV_blank>%s" , __func__ , OC_CLOUD_PROVISIONING_APN ) ; } if ( ! OCRepPayloadGetPropString ( payload , OC_CLOUD_PROVISIONING_AT , & cloud -> at ) ) { OIC_LOG_V ( ERROR , TAG , "%s:<S2SV_blank>Can\'t<S2SV_blank>get:<S2SV_blank>%s" , __func__ , OC_CLOUD_PROVISIONING_AT ) ; } LL_FOREACH_SAFE ( gCloud , p1 , p2 ) { if ( p1 && p1 -> cis && 0 == strcmp ( p1 -> cis , cloud -> cis ) ) { OIC_LOG_V ( INFO , TAG , "%s:<S2SV_blank>delete<S2SV_blank>cloud:<S2SV_blank>%s" , __func__ , p1 -> cis ) ; p1 -> stat = OC_CLOUD_EXIT ; OCCloudSignOut ( p1 ) ; LL_DELETE ( gCloud , p1 ) ; ehRet = OC_EH_OK ; break ; } } exit : response . requestHandle = ehRequest ? ehRequest -> requestHandle : NULL ; response . ehResult = ehRet ; response . payload = ( OCPayload * ) OCRepPayloadCreate ( ) ; <S2SV_StartBug> response . payload -> type = PAYLOAD_TYPE_REPRESENTATION ; <S2SV_EndBug> response . persistentBufferFlag = 0 ; if ( OC_STACK_OK != OCDoResponse ( & response ) ) { OIC_LOG_V ( ERROR , TAG , "%s:<S2SV_blank>send<S2SV_blank>response" , __func__ ) ; ehRet = OC_EH_ERROR ; } <S2SV_StartBug> if ( cloud ) <S2SV_EndBug> { FreeCloud ( cloud ) ; } OIC_LOG_V ( DEBUG , TAG , "%s:<S2SV_blank>OUT" , __func__ ) ; return ehRet ; } | <S2SV_ModStart> ( ) ; if ( NULL != response . payload ) { <S2SV_ModStart> OC_EH_ERROR ; } } else { OIC_LOG_V ( ERROR , TAG , "%s:<S2SV_blank>response<S2SV_blank>payload<S2SV_blank>is<S2SV_blank>NULL" , __func__ ) ; ehRet = OC_EH_ERROR ; } |
3,011 | CWE-000 void ranmom ( ) { <S2SV_StartBug> register int i , j , mu ; <S2SV_EndBug> register site * s ; <S2SV_StartBug> complex grn ; <S2SV_EndBug> FORALLSITES ( i , s ) { FORALLDIR ( mu ) { clear_mat ( & ( s -> mom [ mu ] ) ) ; <S2SV_StartBug> # ifdef HYBRID <S2SV_EndBug> <S2SV_StartBug> for ( j = 0 ; j < ( DIMF - 1 ) ; j ++ ) { <S2SV_EndBug> <S2SV_StartBug> # else <S2SV_EndBug> for ( j = 0 ; j < DIMF ; j ++ ) { # endif # ifdef SITERAND grn . real = gaussian_rand_no ( & ( s -> site_prn ) ) ; grn . imag = gaussian_rand_no ( & ( s -> site_prn ) ) ; # else grn . real = gaussian_rand_no ( & ( s -> node_prn ) ) ; grn . imag = gaussian_rand_no ( & ( s -> node_prn ) ) ; # endif c_scalar_mult_sum_mat ( & ( Lambda [ j ] ) , & grn , & ( s -> mom [ mu ] ) ) ; } } } } | <S2SV_ModStart> j , mu , numgen <S2SV_ModStart> complex grn ; # ifdef TRUNCATED numgen = DIMF - 1 ; # else numgen = DIMF ; # endif <S2SV_ModStart> ) ) ; <S2SV_ModEnd> for ( j <S2SV_ModStart> ; j < numgen <S2SV_ModEnd> ; j ++ <S2SV_ModStart> ++ ) { <S2SV_ModEnd> # ifdef SITERAND |
3,012 | CWE-000 int main ( void ) { char buf [ 1 ] ; struct winsize ws ; <S2SV_StartBug> ioctl ( 1 , TIOCGWINSZ , & ws ) ; <S2SV_EndBug> init_term ( ) ; g_linei = ft_memalloc ( sizeof ( t_lineinfo ) ) ; <S2SV_StartBug> g_linei -> content = ft_strnew ( 20 ) ; <S2SV_EndBug> g_linei -> len = 0 ; g_linei -> len_max = 20 ; <S2SV_StartBug> g_linei -> pos . x = 0 ; <S2SV_EndBug> g_linei -> pos . y = 0 ; g_linei -> curs = 0 ; <S2SV_StartBug> while ( 1 ) <S2SV_EndBug> { ft_bzero ( buf , 1 ) ; read ( 0 , buf , 1 ) ; if ( buf [ 0 ] == 27 ) is_arrow ( ) ; else if ( buf [ 0 ] == 127 ) del_char ( ) ; else if ( ft_isprint ( buf [ 0 ] ) ) add_char_to_line ( buf [ 0 ] ) ; else if ( buf [ 0 ] == 10 ) { printf ( "\\nCURS<S2SV_blank>=<S2SV_blank>[%d]\\n" , g_linei -> curs ) ; printf ( "LINE<S2SV_blank>=<S2SV_blank>[%s]\\n" , g_linei -> content ) ; printf ( "LEN<S2SV_blank>=<S2SV_blank>[%d]\\n" , g_linei -> len ) ; printf ( "COL<S2SV_blank>=<S2SV_blank>[%d]\\n" , g_linei -> pos . x ) ; printf ( "SIZE<S2SV_blank>=<S2SV_blank>[%d]\\n" , ws . ws_col ) ; g_linei -> curs = 0 ; exit ( 0 ) ; } } <S2SV_StartBug> default_term ( ) ; <S2SV_EndBug> } | <S2SV_ModStart> winsize ws ; char * prompt ; prompt = "Hello<S2SV_blank>><S2SV_blank>" ; <S2SV_ModStart> ft_strnew ( 20 ) ; g_linei -> p_len = ft_strlen ( prompt <S2SV_ModStart> . x = g_linei -> p_len <S2SV_ModEnd> ; g_linei -> <S2SV_ModStart> = 0 ; ft_putstr ( prompt ) ; <S2SV_ModStart> ; } } ft_strdel ( & g_linei -> content ) ; free ( g_linei ) ; |
3,013 | CWE-000 odp_packet_t odp_packet_ref ( odp_packet_t pkt , uint32_t offset ) { odp_packet_t ref ; odp_packet_hdr_t * link_hdr ; odp_packet_hdr_t * next_hdr ; odp_packet_hdr_t * pkt_hdr = packet_hdr ( pkt ) ; odp_packet_hdr_t * hdr = pkt_hdr ; seg_entry_t * seg ; uint32_t seg_idx = 0 ; uint8_t idx = 0 ; uint32_t seg_offset = 0 ; int i , num_copy , segcount ; uint32_t len ; if ( offset >= pkt_hdr -> frame_len ) { ODP_DBG ( "offset<S2SV_blank>too<S2SV_blank>large\\n" ) ; return ODP_PACKET_INVALID ; } if ( packet_alloc ( pkt_hdr -> buf_hdr . pool_ptr , 0 , 1 , 1 , & ref ) != 1 ) { ODP_DBG ( "segment<S2SV_blank>alloc<S2SV_blank>failed\\n" ) ; return ODP_PACKET_INVALID ; } link_hdr = packet_hdr ( ref ) ; seg_entry_find_offset ( & hdr , & idx , & seg_offset , & seg_idx , offset ) ; num_copy = hdr -> buf_hdr . num_seg - idx ; segcount = pkt_hdr -> buf_hdr . segcount ; if ( seg_is_link ( hdr ) ) buffer_ref_inc ( ( odp_buffer_hdr_t * ) hdr ) ; seg = seg_entry_next ( & hdr , & idx ) ; link_hdr -> buf_hdr . num_seg = 1 ; link_hdr -> buf_hdr . seg [ 0 ] . hdr = seg -> hdr ; link_hdr -> buf_hdr . seg [ 0 ] . data = seg -> data + seg_offset ; link_hdr -> buf_hdr . seg [ 0 ] . len = seg -> len - seg_offset ; buffer_ref_inc ( seg -> hdr ) ; <S2SV_StartBug> for ( i = 1 ; i < num_copy ; i ++ ) { <S2SV_EndBug> if ( idx == 0 && seg_is_link ( hdr ) ) buffer_ref_inc ( ( odp_buffer_hdr_t * ) hdr ) ; seg = seg_entry_next ( & hdr , & idx ) ; link_hdr -> buf_hdr . num_seg ++ ; link_hdr -> buf_hdr . seg [ i ] . hdr = seg -> hdr ; link_hdr -> buf_hdr . seg [ i ] . data = seg -> data ; link_hdr -> buf_hdr . seg [ i ] . len = seg -> len ; buffer_ref_inc ( seg -> hdr ) ; } next_hdr = hdr ; for ( i = seg_idx + num_copy ; i < segcount ; i ++ ) { if ( idx == 0 && seg_is_link ( hdr ) ) buffer_ref_inc ( ( odp_buffer_hdr_t * ) hdr ) ; seg = seg_entry_next ( & hdr , & idx ) ; buffer_ref_inc ( seg -> hdr ) ; } len = pkt_hdr -> frame_len - offset ; link_hdr -> buf_hdr . next_seg = next_hdr ; link_hdr -> buf_hdr . last_seg = pkt_hdr -> buf_hdr . last_seg ; link_hdr -> buf_hdr . segcount = segcount - seg_idx ; link_hdr -> frame_len = len ; link_hdr -> tailroom = pkt_hdr -> tailroom ; link_hdr -> shared_len = len ; link_hdr -> headroom = 0 ; if ( pkt_hdr -> shared_len < len ) pkt_hdr -> shared_len = len ; return ref ; } | <S2SV_ModStart> = 1 ; CONFIG_PACKET_MAX_SEGS > 1 && |
3,014 | CWE-000 float Widget_GetFillAvailableWidth ( LCUI_Widget w ) { float width ; <S2SV_StartBug> if ( Widget_HasAutoWidth ( w -> parent ) ) { <S2SV_EndBug> return 0 ; } width = Widget_ComputeMaxWidth ( w ) ; width -= w -> margin . left + w -> margin . right ; return width ; } | <S2SV_ModStart> ; if ( ! w -> parent || |
3,015 | CWE-000 static int msm_vdec_start_streaming ( struct vb2_queue * q , unsigned int count ) { struct msm_vidc_inst * inst ; int rc = 0 ; struct hfi_device * hdev ; if ( ! q || ! q -> drv_priv ) { <S2SV_StartBug> dprintk ( VIDC_ERR , "Invalid<S2SV_blank>input,<S2SV_blank>q<S2SV_blank>=<S2SV_blank>%p\\n" , q ) ; <S2SV_EndBug> return - EINVAL ; } inst = q -> drv_priv ; if ( ! inst || ! inst -> core || ! inst -> core -> device ) { dprintk ( VIDC_ERR , "%s<S2SV_blank>invalid<S2SV_blank>parameters" , __func__ ) ; return - EINVAL ; } hdev = inst -> core -> device ; dprintk ( VIDC_DBG , "Streamon<S2SV_blank>called<S2SV_blank>on:<S2SV_blank>%d<S2SV_blank>capability\\n" , q -> type ) ; switch ( q -> type ) { case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE : if ( inst -> bufq [ CAPTURE_PORT ] . vb2_bufq . streaming ) rc = start_streaming ( inst ) ; break ; case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE : if ( inst -> bufq [ OUTPUT_PORT ] . vb2_bufq . streaming ) rc = start_streaming ( inst ) ; break ; default : dprintk ( VIDC_ERR , "Q-type<S2SV_blank>is<S2SV_blank>not<S2SV_blank>supported:<S2SV_blank>%d\\n" , q -> type ) ; rc = - EINVAL ; break ; } return rc ; } | <S2SV_ModStart> ( VIDC_ERR , "Invalid<S2SV_blank>input,<S2SV_blank>q<S2SV_blank>=<S2SV_blank>%pK\\n" <S2SV_ModEnd> , q ) |
3,016 | CWE-000 TL_exp transDec ( TL_level level , SB_table valueEV , SB_table typeEV , AST_dec d ) { SB_symbol sym ; AST_nametyList types ; AST_namety type ; struct exp_tp exp ; TP_tp tp ; TP_tp decTp ; TL_access access ; TL_exp tl_exp ; switch ( d -> kind ) { case AST_varDec : sym = d -> u . var . var ; if ( Loop_var_stack_look ( sym ) ) { SM_info ( FATAL , d -> pos , "the<S2SV_blank>name<S2SV_blank>of<S2SV_blank>loop<S2SV_blank>variable<S2SV_blank>\'%s\'<S2SV_blank>can<S2SV_blank>not<S2SV_blank>be<S2SV_blank>reused!" , SB_name ( sym ) ) ; } exp = transExp ( level , valueEV , typeEV , d -> u . var . init ) ; tp = actual_tp ( exp . tp ) ; if ( d -> u . var . typ != NULL ) { decTp = SB_look ( typeEV , d -> u . var . typ ) ; if ( decTp == NULL || ! looseTypeCompare ( tp , decTp ) ) { SM_info ( ERROR , d -> pos , "The<S2SV_blank>initializer<S2SV_blank>of<S2SV_blank>variable<S2SV_blank>\'%s\'<S2SV_blank>is<S2SV_blank>incompatible<S2SV_blank>with<S2SV_blank>the<S2SV_blank>declared<S2SV_blank>type!" , SB_name ( sym ) ) ; } } <S2SV_StartBug> access = TL_allocLocal ( level , TRUE ) ; <S2SV_EndBug> SB_enter ( valueEV , sym , EV_VarItem ( access , decTp ) ) ; tl_exp = TL_assignExp ( transVar ( level , valueEV , typeEV , AST_SimpleVar ( d -> pos , d -> u . var . var ) ) . exp , exp . exp ) ; break ; case AST_typeDec : Type_sym_stack_empty ( ) ; for ( types = d -> u . type ; types != NULL ; types = types -> tail ) { type = types -> head ; if ( type != NULL ) { if ( Type_sym_stack_look ( type -> name ) ) { SM_info ( FATAL , d -> pos , "the<S2SV_blank>type<S2SV_blank>name<S2SV_blank>\'%s\'<S2SV_blank>has<S2SV_blank>been<S2SV_blank>used<S2SV_blank>adjacently!" , SB_name ( type -> name ) ) ; } else { Type_sym_stack_push ( type -> name ) ; } SB_enter ( typeEV , type -> name , generateTp ( type -> ty ) ) ; } } for ( types = d -> u . type ; types != NULL ; types = types -> tail ) { type = types -> head ; if ( type != NULL ) { transTp ( typeEV , type -> name , type -> ty ) ; } } tl_exp = TL_voidExp ( ) ; break ; } return tl_exp ; } | <S2SV_ModStart> ; } } else { decTp = exp . tp ; } |
3,017 | CWE-000 void response_handler ( void * response ) { const uint8_t * chunk ; int temp = 0 ; char str [ 10 ] ; int len = coap_get_payload ( response , & chunk ) ; if ( len > 10 ) { printf ( "Too<S2SV_blank>long<S2SV_blank>for<S2SV_blank>number\\n" ) ; return ; } if ( ( ( char * ) chunk ) [ 0 ] == '0' ) { temp = 0 ; } else { sprintf ( str , "%.*s" , len , ( char * ) chunk ) ; temp = atoi ( str ) ; if ( temp == 0 ) printf ( "It<S2SV_blank>is<S2SV_blank>not<S2SV_blank>integer\\n" ) ; else { printf ( "Temperature<S2SV_blank>at<S2SV_blank>server<S2SV_blank>is:<S2SV_blank>%d\\n" , temp ) ; <S2SV_StartBug> if ( temp > 17 ) <S2SV_EndBug> if ( coap_change_profile_priority ( resource_url , PROFILE_LOWPOWER , & server_ipaddr , 1 ) == 0 ) printf ( "Profile<S2SV_blank>Changed\\n" ) ; else printf ( "Profile<S2SV_blank>cannot<S2SV_blank>be<S2SV_blank>changed\\n" ) ; } } } | <S2SV_ModStart> temp ) ; <S2SV_ModEnd> } } } |
3,018 | CWE-000 static bool proposed_ODXYZ_valid ( MRI_SURFACE * mris , MRISAsynchronousTimeStep_optionalDxDyDzUpdate_oneVertex_Context * ctx , int vno , float odx , float ody , float odz ) { struct MrisAsynchronousTimeStep_optionalDxDyDzUpdate_PerVertexInfo_t * vertexInfos = ! ctx ? NULL : ctx -> allVertexsContext -> vertexInfos ; if ( ! vertexInfos ) return true ; VERTEX const * v = & mris -> vertices [ vno ] ; float const x = v -> x + odx ; float const y = v -> y + ody ; float const z = v -> z + odz ; int current_svi = ctx -> allVertexsContext -> vnoToSvi [ vno ] ; <S2SV_StartBug> if ( current_svi == MRISAsynchronousTimeStep_optionalDxDyDzUpdate_numSubvolsPerThread - 1 ) return true ; <S2SV_EndBug> int proposed_svi = MRISAsynchronousTimeStep_optionalDxDyDzUpdate_svi ( ctx -> allVertexsContext , x , y , z ) ; return ( current_svi == proposed_svi ) ; } | <S2SV_ModStart> ( current_svi == svi_forThoseCrossingSubvols <S2SV_ModEnd> ) return true |
3,019 | CWE-000 static void DownloadCallback ( void * self ) { uiList_t * f = ( uiList_t * ) self ; if ( f == & m_downloadOptionsMenu . download_toggle ) cgi . Cvar_SetValue ( "allow_download" , f -> curValue , qFalse ) ; else if ( f == & m_downloadOptionsMenu . download_maps_toggle ) cgi . Cvar_SetValue ( "allow_download_maps" , f -> curValue , qFalse ) ; <S2SV_StartBug> else if ( f == & m_downloadOptionsMenu . download_models_toggle , qFalse ) <S2SV_EndBug> cgi . Cvar_SetValue ( "allow_download_models" , f -> curValue , qFalse ) ; else if ( f == & m_downloadOptionsMenu . download_players_toggle ) cgi . Cvar_SetValue ( "allow_download_players" , f -> curValue , qFalse ) ; else if ( f == & m_downloadOptionsMenu . download_sounds_box ) cgi . Cvar_SetValue ( "allow_download_sounds" , f -> curValue , qFalse ) ; } | <S2SV_ModStart> m_downloadOptionsMenu . download_models_toggle <S2SV_ModEnd> ) cgi . |
3,020 | CWE-000 static void ds_comment ( RDisasmState * ds , bool align , const char * format , ... ) { va_list ap ; va_start ( ap , format ) ; <S2SV_StartBug> _ds_comment ( ds , false , align , format , ap ) ; <S2SV_EndBug> va_end ( ap ) ; } | <S2SV_ModStart> format ) ; if ( ds -> show_comments && ds -> show_comment_right && align ) { ds_align_comment ( ds ) ; } r_cons_printf_list ( <S2SV_ModEnd> format , ap |
3,021 | CWE-000 int sendFile ( int opcode , char * filename , int client_sock ) { int lSize , bytes_sent , byte_read ; char buff [ BUFF_SIZE ] ; char * mess ; int i ; FILE * fp = fopen ( filename , "rb" ) ; if ( fp == NULL ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>file.\\n" ) ; return - 1 ; } fseek ( fp , 0 , SEEK_END ) ; lSize = ftell ( fp ) ; rewind ( fp ) ; bzero ( buff , BUFF_SIZE ) ; while ( lSize > 0 ) { if ( lSize > BUFF_SIZE ) { byte_read = fread ( buff , 1 , BUFF_SIZE , fp ) ; if ( byte_read != BUFF_SIZE ) { fputs ( "Reading<S2SV_blank>error" , stderr ) ; exit ( 3 ) ; } } else { byte_read = fread ( buff , 1 , lSize , fp ) ; if ( byte_read != lSize ) { fputs ( "Reading<S2SV_blank>error" , stderr ) ; exit ( 3 ) ; } } mess = makeMessage ( opcode , byte_read , buff ) ; <S2SV_StartBug> bytes_sent = send ( client_sock , mess , byte_read + 5 , 0 ) ; <S2SV_EndBug> free ( mess ) ; if ( bytes_sent <= 0 ) { printf ( "Error:<S2SV_blank>Connection<S2SV_blank>closed.\\n" ) ; return - 1 ; } lSize -= byte_read ; if ( lSize <= 0 ) { mess = makeMessage ( opcode , 0 , "" ) ; bytes_sent = send ( client_sock , mess , 5 , 0 ) ; free ( mess ) ; if ( bytes_sent <= 0 ) { printf ( "Error:<S2SV_blank>Connection<S2SV_blank>closed.\\n" ) ; return - 1 ; } } } fclose ( fp ) ; remove ( filename ) ; return 0 ; } | <S2SV_ModStart> , mess , BUFF_SIZE <S2SV_ModEnd> + 5 , |
3,022 | CWE-000 void FuncTsk ( VP_INT exinf ) { wai_sem ( Sdisp ) ; display_clear ( 0 ) ; sig_sem ( Sdisp ) ; ( * g_function ) ( ) ; Quit ( ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ( ) ; ter_tsk ( Tquit ) ; |
3,023 | CWE-000 static uint64 DistributedTableSizeOnWorker ( WorkerNode * workerNode , Oid relationId , char * sizeQuery ) { StringInfo tableSizeQuery = NULL ; StringInfo tableSizeStringInfo = NULL ; char * workerNodeName = workerNode -> workerName ; uint32 workerNodePort = workerNode -> workerPort ; char * tableSizeString ; uint64 tableSize = 0 ; MultiConnection * connection = NULL ; uint32 connectionFlag = 0 ; PGresult * result = NULL ; int queryResult = 0 ; List * sizeList = NIL ; <S2SV_StartBug> List * shardIntervalsOnNode = ShardIntervalsOnWorkerGroup ( workerNode , relationId ) ; <S2SV_EndBug> tableSizeQuery = GenerateSizeQueryOnMultiplePlacements ( relationId , shardIntervalsOnNode , sizeQuery ) ; connection = GetNodeConnection ( connectionFlag , workerNodeName , workerNodePort ) ; queryResult = ExecuteOptionalRemoteCommand ( connection , tableSizeQuery -> data , & result ) ; if ( queryResult != 0 ) { ereport ( ERROR , ( errcode ( ERRCODE_CONNECTION_FAILURE ) , errmsg ( "cannot<S2SV_blank>get<S2SV_blank>the<S2SV_blank>size<S2SV_blank>because<S2SV_blank>of<S2SV_blank>a<S2SV_blank>connection<S2SV_blank>error" ) ) ) ; } sizeList = ReadFirstColumnAsText ( result ) ; tableSizeStringInfo = ( StringInfo ) linitial ( sizeList ) ; tableSizeString = tableSizeStringInfo -> data ; tableSize = atol ( tableSizeString ) ; <S2SV_StartBug> return tableSize ; <S2SV_EndBug> } | <S2SV_ModStart> = NIL ; bool raiseErrors = true ; <S2SV_ModStart> tableSizeString ) ; ClearResults ( connection , raiseErrors ) ; |
3,024 | CWE-000 static void bnxt_shutdown ( struct pci_dev * pdev ) { struct net_device * dev = pci_get_drvdata ( pdev ) ; struct bnxt * bp ; if ( ! dev ) return ; rtnl_lock ( ) ; bp = netdev_priv ( dev ) ; if ( ! bp ) goto shutdown_exit ; if ( netif_running ( dev ) ) dev_close ( dev ) ; <S2SV_StartBug> if ( system_state == SYSTEM_POWER_OFF ) { <S2SV_EndBug> <S2SV_StartBug> bnxt_ulp_shutdown ( bp ) ; <S2SV_EndBug> bnxt_clear_int_mode ( bp ) ; pci_wake_from_d3 ( pdev , bp -> wol ) ; pci_set_power_state ( pdev , PCI_D3hot ) ; } shutdown_exit : rtnl_unlock ( ) ; } | <S2SV_ModStart> dev ) ; bnxt_ulp_shutdown ( bp ) ; <S2SV_ModStart> SYSTEM_POWER_OFF ) { <S2SV_ModEnd> bnxt_clear_int_mode ( bp |
3,025 | CWE-000 static int msm_vidc_remove ( struct platform_device * pdev ) { int rc = 0 ; struct msm_vidc_core * core ; if ( ! pdev ) { <S2SV_StartBug> dprintk ( VIDC_ERR , "%s<S2SV_blank>invalid<S2SV_blank>input<S2SV_blank>%p" , __func__ , pdev ) ; <S2SV_EndBug> return - EINVAL ; } core = dev_get_drvdata ( & pdev -> dev ) ; if ( ! core ) { dprintk ( VIDC_ERR , "%s<S2SV_blank>invalid<S2SV_blank>core" , __func__ ) ; return - EINVAL ; } if ( core -> resources . use_non_secure_pil ) venus_boot_deinit ( ) ; vidc_hfi_deinitialize ( core -> hfi_type , core -> device ) ; device_remove_file ( & core -> vdev [ MSM_VIDC_ENCODER ] . vdev . dev , & dev_attr_link_name ) ; video_unregister_device ( & core -> vdev [ MSM_VIDC_ENCODER ] . vdev ) ; device_remove_file ( & core -> vdev [ MSM_VIDC_DECODER ] . vdev . dev , & dev_attr_link_name ) ; video_unregister_device ( & core -> vdev [ MSM_VIDC_DECODER ] . vdev ) ; v4l2_device_unregister ( & core -> v4l2_dev ) ; msm_vidc_free_platform_resources ( & core -> resources ) ; sysfs_remove_group ( & pdev -> dev . kobj , & msm_vidc_core_attr_group ) ; dev_set_drvdata ( & pdev -> dev , NULL ) ; kfree ( core ) ; return rc ; } | <S2SV_ModStart> ( VIDC_ERR , "%s<S2SV_blank>invalid<S2SV_blank>input<S2SV_blank>%pK" <S2SV_ModEnd> , __func__ , |
3,026 | CWE-000 static void title_popover_close ( GtkWidget * popover , TerminalWindow * window ) { terminal_return_if_fail ( window -> priv -> title_popover != NULL ) ; if ( window -> drop_down ) terminal_util_activate_window ( GTK_WINDOW ( window ) ) ; gtk_widget_destroy ( window -> priv -> title_popover ) ; window -> priv -> title_popover = NULL ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> = NULL ; if ( G_LIKELY ( window -> priv -> active != NULL ) ) terminal_screen_focus ( window -> priv -> active ) ; |
3,027 | CWE-000 static bool mem_cgroup_event_ratelimit ( struct mem_cgroup * memcg , enum mem_cgroup_events_target target ) { unsigned long val , next ; <S2SV_StartBug> val = __this_cpu_read ( memcg -> stat -> nr_page_events ) ; <S2SV_EndBug> <S2SV_StartBug> next = __this_cpu_read ( memcg -> stat -> targets [ target ] ) ; <S2SV_EndBug> if ( ( long ) ( next - val ) < 0 ) { switch ( target ) { case MEM_CGROUP_TARGET_THRESH : next = val + THRESHOLDS_EVENTS_TARGET ; break ; case MEM_CGROUP_TARGET_SOFTLIMIT : next = val + SOFTLIMIT_EVENTS_TARGET ; break ; case MEM_CGROUP_TARGET_NUMAINFO : next = val + NUMAINFO_EVENTS_TARGET ; break ; default : break ; } <S2SV_StartBug> __this_cpu_write ( memcg -> stat -> targets [ target ] , next ) ; <S2SV_EndBug> return true ; } return false ; } | <S2SV_ModStart> ( memcg -> stat_cpu <S2SV_ModEnd> -> nr_page_events ) <S2SV_ModStart> ( memcg -> stat_cpu <S2SV_ModEnd> -> targets [ <S2SV_ModStart> ( memcg -> stat_cpu <S2SV_ModEnd> -> targets [ |
3,028 | CWE-000 int vsd_munmap ( void * addr , size_t offset ) { <S2SV_StartBug> size_t size = 0 ; <S2SV_EndBug> if ( vsd_get_size ( & size ) != 0 ) { return - 2 ; } return munmap ( addr , size - offset ) ; } | <S2SV_ModStart> offset ) { RUN_INIT_LOCKED ( int , vsd_munmap_impl , addr , <S2SV_ModEnd> offset ) ; |
3,029 | CWE-000 void primLineF2 ( unsigned char * baseAddr ) { unsigned long * gpuData = ( ( unsigned long * ) baseAddr ) ; short * sgpuData = ( ( short * ) baseAddr ) ; lx0 = sgpuData [ 2 ] ; ly0 = sgpuData [ 3 ] ; lx1 = sgpuData [ 4 ] ; ly1 = sgpuData [ 5 ] ; <S2SV_StartBug> if ( offsetline ( ) ) return ; <S2SV_EndBug> bDrawTextured = FALSE ; bDrawSmoothShaded = FALSE ; SetRenderState ( gpuData [ 0 ] ) ; SetRenderMode ( gpuData [ 0 ] , FALSE ) ; SetZMask4NT ( ) ; vertex [ 0 ] . c . lcol = gpuData [ 0 ] ; vertex [ 0 ] . c . col [ 3 ] = ubGloColAlpha ; PRIMdrawFlatLine ( & vertex [ 0 ] , & vertex [ 1 ] , & vertex [ 2 ] , & vertex [ 3 ] ) ; iDrawnSomething = 1 ; } | <S2SV_ModStart> ( offsetline ( baseAddr |
3,030 | CWE-000 <S2SV_StartBug> static VALUE rb_render_plaintext ( VALUE n , VALUE rb_options ) { <S2SV_EndBug> int options ; cmark_node * node ; Check_Type ( rb_options , T_FIXNUM ) ; options = FIX2INT ( rb_options ) ; Data_Get_Struct ( n , cmark_node , node ) ; <S2SV_StartBug> char * text = cmark_render_plaintext ( node , options , 120 ) ; <S2SV_EndBug> VALUE ruby_text = rb_str_new2 ( text ) ; free ( text ) ; return ruby_text ; } | <S2SV_ModStart> VALUE rb_render_plaintext ( int argc , VALUE * argv , VALUE n ) { VALUE rb_options , rb_width ; rb_scan_args ( argc , argv , "11" , & rb_options , & rb_width ) ; int width = 120 ; if ( ! NIL_P ( rb_width ) ) { Check_Type ( rb_width , T_FIXNUM ) ; width = FIX2INT ( rb_width ) ; } <S2SV_ModEnd> int options ; <S2SV_ModStart> , options , width <S2SV_ModEnd> ) ; VALUE |
3,031 | CWE-000 static int _get_assoc_mgr_tres_list ( void * db_conn , int enforce ) { slurmdb_tres_cond_t tres_q ; uid_t uid = getuid ( ) ; List new_list = NULL ; char * tres_req_str ; int changed ; assoc_mgr_lock_t locks = { WRITE_LOCK , NO_LOCK , WRITE_LOCK , NO_LOCK , WRITE_LOCK , NO_LOCK , NO_LOCK } ; memset ( & tres_q , 0 , sizeof ( slurmdb_tres_cond_t ) ) ; assoc_mgr_lock ( & locks ) ; if ( ( tres_req_str = slurm_get_accounting_storage_tres ( ) ) ) { tres_q . type_list = list_create ( slurm_destroy_char ) ; slurm_addto_char_list ( tres_q . type_list , tres_req_str ) ; xfree ( tres_req_str ) ; } new_list = acct_storage_g_get_tres ( db_conn , uid , & tres_q ) ; FREE_NULL_LIST ( tres_q . type_list ) ; if ( ! new_list ) { assoc_mgr_unlock ( & locks ) ; if ( enforce & ACCOUNTING_ENFORCE_ASSOCS ) { error ( "_get_assoc_mgr_tres_list:<S2SV_blank>" "no<S2SV_blank>list<S2SV_blank>was<S2SV_blank>made." ) ; return SLURM_ERROR ; } else { return SLURM_SUCCESS ; } } changed = _post_tres_list ( new_list , list_count ( new_list ) ) ; assoc_mgr_unlock ( & locks ) ; <S2SV_StartBug> if ( changed && init_setup . update_cluster_tres ) { <S2SV_EndBug> init_setup . update_cluster_tres ( ) ; } return SLURM_SUCCESS ; } | <S2SV_ModStart> ; if ( ! running_cache && |
3,032 | CWE-000 OsStatus_t SetVirtualPageMapping ( _In_ SystemMemorySpace_t * MemorySpace , _In_ PhysicalAddress_t pAddress , _In_ VirtualAddress_t vAddress , _In_ Flags_t Flags ) { PAGE_MASTER_LEVEL * ParentDirectory ; PAGE_MASTER_LEVEL * Directory ; PageTable_t * Table ; <S2SV_StartBug> uint32_t Mapping ; <S2SV_EndBug> <S2SV_StartBug> Flags_t ConvertedFlags ; <S2SV_EndBug> <S2SV_StartBug> int IsCurrent , Update ; <S2SV_EndBug> OsStatus_t Status = OsSuccess ; ConvertedFlags = ConvertSystemSpaceToPaging ( Flags ) ; Directory = MmVirtualGetMasterTable ( MemorySpace , ( vAddress & PAGE_MASK ) , & ParentDirectory , & IsCurrent ) ; Table = MmVirtualGetTable ( ParentDirectory , Directory , ( vAddress & PAGE_MASK ) , IsCurrent , 1 , ConvertedFlags , & Update ) ; if ( vAddress < MEMORY_LOCATION_KERNEL_END ) { if ( CpuHasFeatures ( 0 , CPUID_FEAT_EDX_PGE ) == OsSuccess ) { ConvertedFlags |= PAGE_GLOBAL ; } } assert ( Table != NULL ) ; Mapping = atomic_load ( & Table -> Pages [ PAGE_TABLE_INDEX ( ( vAddress & PAGE_MASK ) ) ] ) ; SyncTable : if ( Mapping != 0 ) { if ( ConvertedFlags & PAGE_PERSISTENT ) { if ( Mapping != ( pAddress & PAGE_MASK ) ) { FATAL ( FATAL_SCOPE_KERNEL , "Tried<S2SV_blank>to<S2SV_blank>remap<S2SV_blank>fixed<S2SV_blank>virtual<S2SV_blank>address<S2SV_blank>0x%x<S2SV_blank>=><S2SV_blank>0x%x<S2SV_blank>(Existing<S2SV_blank>0x%x)" , vAddress , pAddress , Mapping ) ; } } Status = OsExists ; goto LeaveFunction ; } if ( ! atomic_compare_exchange_weak ( & Table -> Pages [ PAGE_TABLE_INDEX ( ( vAddress & PAGE_MASK ) ) ] , & Mapping , ( pAddress & PAGE_MASK ) | ConvertedFlags ) ) { goto SyncTable ; } LeaveFunction : if ( IsCurrent || Update ) { if ( Update ) { memory_reload_cr3 ( ) ; } memory_invalidate_addr ( ( vAddress & PAGE_MASK ) ) ; } return Status ; } | <S2SV_ModStart> * Table ; uintptr_t <S2SV_ModEnd> Mapping ; Flags_t <S2SV_ModStart> ; Flags_t ConvertedFlags ; int Update <S2SV_ModStart> ; int IsCurrent <S2SV_ModEnd> ; OsStatus_t Status |
3,033 | CWE-000 <S2SV_StartBug> int mrir ( modbus_t * ctx , int addr , int nb , uint16_t * dest ) { <S2SV_EndBug> int r ; r = modbus_read_input_registers ( ctx , addr , nb , dest ) ; if ( r == - 1 ) { upslogx ( LOG_ERR , "mrir:<S2SV_blank>modbus_read_input_registers(addr:%d,<S2SV_blank>count:%d):<S2SV_blank>%s<S2SV_blank>(%s)" , addr , nb , modbus_strerror ( errno ) , device_path ) ; errcount ++ ; } errcount = 0 ; return r ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static |
3,034 | CWE-000 static bool thumb_legitimate_constant_p ( machine_mode mode ATTRIBUTE_UNUSED , rtx x ) { if ( TARGET_HAVE_MOVT && GET_CODE ( x ) == HIGH ) x = XEXP ( x , 0 ) ; return ( CONST_INT_P ( x ) || CONST_DOUBLE_P ( x ) || CONSTANT_ADDRESS_P ( x ) <S2SV_StartBug> || flag_pic ) ; <S2SV_EndBug> } | <S2SV_ModStart> x ) || ( TARGET_HAVE_MOVT && GET_CODE ( x ) == SYMBOL_REF ) || |
3,035 | CWE-000 u16 SPR_setVRAMTileIndex ( Sprite * sprite , s16 value ) { # ifdef SPR_PROFIL s32 prof = getSubTick ( ) ; # endif s16 newInd ; u16 status = sprite -> status ; u16 oldAttribut = sprite -> attribut ; if ( status & SPR_FLAG_AUTO_VRAM_ALLOC ) { if ( value != - 1 ) { status &= ~ SPR_FLAG_AUTO_VRAM_ALLOC ; VRAM_free ( & vram , oldAttribut & TILE_INDEX_MASK ) ; newInd = value ; # ifdef SPR_DEBUG KLog_U2 ( "SPR_setVRAMTileIndex:<S2SV_blank>#" , getSpriteIndex ( sprite ) , "<S2SV_blank>passed<S2SV_blank>to<S2SV_blank>manual<S2SV_blank>allocation,<S2SV_blank>VRAM<S2SV_blank>index<S2SV_blank>=" , value ) ; KLog_U3 ( "<S2SV_blank><S2SV_blank>released<S2SV_blank>" , sprite -> definition -> maxNumTile , "<S2SV_blank>tiles<S2SV_blank>in<S2SV_blank>VRAM<S2SV_blank>at<S2SV_blank>" , sprite -> attribut & TILE_INDEX_MASK , ",<S2SV_blank>remaining<S2SV_blank>VRAM:<S2SV_blank>" , VRAM_getFree ( & vram ) ) ; # endif } else { # ifdef SPR_PROFIL profil_time [ PROFIL_SET_VRAM_OR_SPRIND ] += getSubTick ( ) - prof ; # endif return TRUE ; } } else { if ( value == - 1 ) { status |= SPR_FLAG_AUTO_VRAM_ALLOC ; newInd = VRAM_alloc ( & vram , sprite -> definition -> maxNumTile ) ; # ifdef SPR_DEBUG KLog_U1_ ( "SPR_setVRAMTileIndex:<S2SV_blank>#" , getSpriteIndex ( sprite ) , "<S2SV_blank>passed<S2SV_blank>to<S2SV_blank>auto<S2SV_blank>allocation" ) ; KLog_U3 ( "<S2SV_blank><S2SV_blank>allocated<S2SV_blank>" , sprite -> definition -> maxNumTile , "<S2SV_blank>tiles<S2SV_blank>in<S2SV_blank>VRAM<S2SV_blank>at<S2SV_blank>" , newInd , ",<S2SV_blank>remaining<S2SV_blank>VRAM:<S2SV_blank>" , VRAM_getFree ( & vram ) ) ; # endif if ( newInd < 0 ) { sprite -> status = status ; # ifdef SPR_PROFIL profil_time [ PROFIL_SET_VRAM_OR_SPRIND ] += getSubTick ( ) - prof ; # endif return FALSE ; } } else newInd = value ; } if ( ( oldAttribut & TILE_INDEX_MASK ) != newInd ) { sprite -> attribut = ( oldAttribut & TILE_ATTR_MASK ) | newInd ; status |= NEED_ST_ATTR_UPDATE ; <S2SV_StartBug> } <S2SV_EndBug> sprite -> status = status ; # ifdef SPR_PROFIL profil_time [ PROFIL_SET_VRAM_OR_SPRIND ] += getSubTick ( ) - prof ; # endif return TRUE ; } | <S2SV_ModStart> |= NEED_ST_ATTR_UPDATE ; if ( status & SPR_FLAG_AUTO_TILE_UPLOAD ) status |= NEED_TILES_UPLOAD ; |
3,036 | CWE-000 <S2SV_StartBug> static void session_release ( struct worker_ctx * worker , struct session * s ) <S2SV_EndBug> { if ( ! s ) { <S2SV_StartBug> return ; <S2SV_EndBug> } if ( worker -> pool_sessions . len < MP_FREELIST_SIZE ) { session_clear ( s ) ; array_push ( worker -> pool_sessions , s ) ; kr_asan_poison ( s , sizeof ( * s ) ) ; } else { session_free ( s ) ; } } | <S2SV_ModStart> * worker , uv_handle_t * handle ) { if ( ! worker || ! handle ) { return ; } <S2SV_ModStart> session * s = handle -> data ; <S2SV_ModEnd> if ( ! <S2SV_ModStart> ) { return ; } if ( ! s -> outgoing && handle -> type == UV_TCP ) { worker_end_tcp ( worker , handle ) |
3,037 | CWE-000 void getIndexStats ( Index * index , IndexRouterStatCounters * counters ) { uint64_t cwAllocated = getChapterWriterMemoryAllocated ( index -> chapterWriter ) ; MasterIndexStats denseStats , sparseStats ; getMasterIndexStats ( index -> masterIndex , & denseStats , & sparseStats ) ; memset ( counters , 0 , sizeof ( IndexRouterStatCounters ) ) ; getCacheCounters ( index -> volume , & counters -> volumeCache ) ; counters -> entriesIndexed = ( denseStats . recordCount + sparseStats . recordCount ) ; counters -> memoryUsed = ( ( uint64_t ) denseStats . memoryAllocated + ( uint64_t ) sparseStats . memoryAllocated + ( uint64_t ) getCacheSize ( index -> volume ) + cwAllocated ) ; counters -> diskUsed = ( uint64_t ) getVolumeSize ( index -> volume ) ; <S2SV_StartBug> counters -> numDlists = ( ( uint64_t ) denseStats . numLists <S2SV_EndBug> + ( uint64_t ) sparseStats . numLists ) ; counters -> collisions = ( denseStats . collisionCount + sparseStats . collisionCount ) ; counters -> entriesDiscarded = ( denseStats . discardCount + sparseStats . discardCount ) ; counters -> checkpoints = getCheckpointCount ( index -> checkpoint ) ; } | <S2SV_ModStart> ; counters -> <S2SV_ModEnd> collisions = ( |
3,038 | CWE-000 static void lsp2lpc ( int16_t * lpc ) { int f1 [ LPC_ORDER / 2 + 1 ] ; int f2 [ LPC_ORDER / 2 + 1 ] ; int i , j ; for ( j = 0 ; j < LPC_ORDER ; j ++ ) { int index = ( lpc [ j ] >> 7 ) & 0x1FF ; int offset = lpc [ j ] & 0x7f ; int temp1 = cos_tab [ index ] * ( 1 << 16 ) ; int temp2 = ( cos_tab [ index + 1 ] - cos_tab [ index ] ) * ( ( ( offset << 8 ) + 0x80 ) << 1 ) ; lpc [ j ] = - ( av_sat_dadd32 ( 1 << 15 , temp1 + temp2 ) >> 16 ) ; } f1 [ 0 ] = 1 << 28 ; f1 [ 1 ] = ( lpc [ 0 ] + lpc [ 2 ] ) * ( 1 << 14 ) ; f1 [ 2 ] = lpc [ 0 ] * lpc [ 2 ] + ( 2 << 28 ) ; f2 [ 0 ] = 1 << 28 ; f2 [ 1 ] = ( lpc [ 1 ] + lpc [ 3 ] ) * ( 1 << 14 ) ; f2 [ 2 ] = lpc [ 1 ] * lpc [ 3 ] + ( 2 << 28 ) ; for ( i = 2 ; i < LPC_ORDER / 2 ; i ++ ) { <S2SV_StartBug> f1 [ i + 1 ] = f1 [ i - 1 ] + MULL2 ( f1 [ i ] , lpc [ 2 * i ] ) ; <S2SV_EndBug> <S2SV_StartBug> f2 [ i + 1 ] = f2 [ i - 1 ] + MULL2 ( f2 [ i ] , lpc [ 2 * i + 1 ] ) ; <S2SV_EndBug> for ( j = i ; j >= 2 ; j -- ) { f1 [ j ] = MULL2 ( f1 [ j - 1 ] , lpc [ 2 * i ] ) + ( f1 [ j ] >> 1 ) + ( f1 [ j - 2 ] >> 1 ) ; f2 [ j ] = MULL2 ( f2 [ j - 1 ] , lpc [ 2 * i + 1 ] ) + ( f2 [ j ] >> 1 ) + ( f2 [ j - 2 ] >> 1 ) ; } f1 [ 0 ] >>= 1 ; f2 [ 0 ] >>= 1 ; f1 [ 1 ] = ( ( lpc [ 2 * i ] * 65536 >> i ) + f1 [ 1 ] ) >> 1 ; f2 [ 1 ] = ( ( lpc [ 2 * i + 1 ] * 65536 >> i ) + f2 [ 1 ] ) >> 1 ; } for ( i = 0 ; i < LPC_ORDER / 2 ; i ++ ) { int64_t ff1 = f1 [ i + 1 ] + f1 [ i ] ; int64_t ff2 = f2 [ i + 1 ] - f2 [ i ] ; lpc [ i ] = av_clipl_int32 ( ( ( ff1 + ff2 ) * 8 ) + ( 1 << 15 ) ) >> 16 ; lpc [ LPC_ORDER - i - 1 ] = av_clipl_int32 ( ( ( ff1 - ff2 ) * 8 ) + ( 1 << 15 ) ) >> 16 ; } } | <S2SV_ModStart> 1 ] = av_clipl_int32 ( f1 [ i - 1 ] + ( int64_t ) <S2SV_ModEnd> MULL2 ( f1 <S2SV_ModStart> i ] ) ) ; f2 [ i + 1 ] = av_clipl_int32 ( f2 [ i - 1 ] + ( int64_t ) <S2SV_ModEnd> MULL2 ( f2 <S2SV_ModStart> + 1 ] ) |
3,039 | CWE-000 void closemutex ( int sig ) { Uint32 id = SDL_ThreadID ( ) ; int i ; printf ( "Process<S2SV_blank>%u:<S2SV_blank><S2SV_blank>Cleaning<S2SV_blank>up...\\n" , id == mainthread ? 0 : id ) ; <S2SV_StartBug> for ( i = 0 ; i < 6 ; ++ i ) <S2SV_EndBug> <S2SV_StartBug> SDL_KillThread ( threads [ i ] ) ; <S2SV_EndBug> SDL_DestroyMutex ( mutex ) ; exit ( sig ) ; } | <S2SV_ModStart> id ) ; doterminate = 1 ; <S2SV_ModStart> ++ i ) SDL_WaitThread <S2SV_ModEnd> ( threads [ <S2SV_ModStart> [ i ] , NULL |
3,040 | CWE-000 extern int insert_table ( TABTABLE_T * t ) { sqlite3_stmt * stmt ; char * ztail = NULL ; int ret = - 1 ; if ( t ) { ret = 0 ; if ( debugging ( ) ) { fprintf ( stderr , ">><S2SV_blank>insert_table(%s[%s])\\n" , t -> id , t -> name ) ; } _must_succeed ( "insert<S2SV_blank>table" , sqlite3_prepare_v2 ( G_db , "insert<S2SV_blank>into<S2SV_blank>tabTable(mwb_id," "name,comment_len,varid)" "<S2SV_blank>values(ltrim(rtrim(?1,\'}\'),\'{\'),lower(?2),?3,?4)" , - 1 , & stmt , ( const char * * ) & ztail ) ) ; if ( ( sqlite3_bind_text ( stmt , 1 , ( const char * ) t -> id , - 1 , SQLITE_STATIC ) != SQLITE_OK ) || ( sqlite3_bind_text ( stmt , 2 , ( const char * ) t -> name , - 1 , SQLITE_STATIC ) != SQLITE_OK ) || ( sqlite3_bind_int ( stmt , 3 , ( int ) t -> comment_len ) != SQLITE_OK ) || ( sqlite3_bind_int ( stmt , 4 , ( int ) t -> varid ) != SQLITE_OK ) || ( sqlite3_step ( stmt ) != SQLITE_DONE ) ) { char fail = 1 ; if ( ( sqlite3_errcode ( G_db ) == SQLITE_CONSTRAINT ) && ( sqlite3_extended_errcode ( G_db ) == SQLITE_CONSTRAINT_UNIQUE ) && ( strcmp ( t -> name , t -> id ) != 0 ) ) { <S2SV_StartBug> fail = 0 ; <S2SV_EndBug> sqlite3_finalize ( stmt ) ; _must_succeed ( "update<S2SV_blank>table" , sqlite3_prepare_v2 ( G_db , "update<S2SV_blank>tabTable" "<S2SV_blank>set<S2SV_blank>name=lower(?1)," "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>comment_len=?2" "<S2SV_blank>where<S2SV_blank>varid=?3" "<S2SV_blank>and<S2SV_blank>mwb_id=ltrim(rtrim(?4,\'}\'),\'{\')" , - 1 , & stmt , ( const char * * ) & ztail ) ) ; if ( ( sqlite3_bind_text ( stmt , 1 , ( const char * ) t -> name , - 1 , SQLITE_STATIC ) != SQLITE_OK ) || ( sqlite3_bind_int ( stmt , 2 , ( int ) t -> comment_len ) != SQLITE_OK ) || ( sqlite3_bind_int ( stmt , 3 , ( int ) t -> varid ) != SQLITE_OK ) || ( sqlite3_bind_text ( stmt , 4 , ( const char * ) t -> id , - 1 , SQLITE_STATIC ) != SQLITE_OK ) || ( sqlite3_step ( stmt ) != SQLITE_DONE ) ) { fail = 1 ; } } if ( fail ) { if ( strcmp ( t -> name , t -> id ) ) { fprintf ( stderr , "Failure<S2SV_blank>inserting/updating<S2SV_blank>table\\n" ) ; fprintf ( stderr , "%s<S2SV_blank>(err<S2SV_blank>code:<S2SV_blank>%d,<S2SV_blank>extended:<S2SV_blank>%d\\n" , sqlite3_errmsg ( G_db ) , sqlite3_errcode ( G_db ) , sqlite3_extended_errcode ( G_db ) ) ; } else { if ( debugging ( ) ) { fprintf ( stderr , "<S2SV_blank>%s<S2SV_blank>[%s]<S2SV_blank>already<S2SV_blank>known\\n" , t -> id , t -> name ) ; } } ret = - 1 ; } } sqlite3_finalize ( stmt ) ; } if ( debugging ( ) ) { fprintf ( stderr , "<<<S2SV_blank>insert_table<S2SV_blank>-<S2SV_blank>%s\\n" , ( ret == 0 ? "SUCCESS" : "FAILURE" ) ) ; } return ret ; } | <S2SV_ModStart> { fail = ( update_table ( t ) == - 1 ) ; <S2SV_ModEnd> } if ( |
3,041 | CWE-000 int nozzle_get_mtu ( const nozzle_t nozzle ) { int err = 0 , savederrno = 0 ; <S2SV_StartBug> if ( ! nozzle ) { <S2SV_EndBug> errno = EINVAL ; return - 1 ; } savederrno = pthread_mutex_lock ( & config_mutex ) ; if ( savederrno ) { errno = savederrno ; return - 1 ; } <S2SV_StartBug> if ( ! _check ( nozzle ) ) { <S2SV_EndBug> <S2SV_StartBug> errno = EINVAL ; <S2SV_EndBug> err = - 1 ; goto out_clean ; } err = _get_mtu ( nozzle ) ; savederrno = errno ; out_clean : pthread_mutex_unlock ( & config_mutex ) ; savederrno = errno ; return err ; } | <S2SV_ModStart> = 0 ; <S2SV_ModEnd> savederrno = pthread_mutex_lock <S2SV_ModStart> if ( ! is_valid_nozzle <S2SV_ModEnd> ( nozzle ) <S2SV_ModStart> ) ) { savederrno <S2SV_ModEnd> = EINVAL ; |
3,042 | CWE-000 void photonMovement ( Photon * p ) { if ( p -> active == 1 ) { activePhotons ++ ; p -> active = 2 ; p -> pos . x = ship . pos . x + SHIP_HEIGHT * - sin ( ship . phi ) ; p -> pos . y = ship . pos . y + SHIP_HEIGHT * cos ( ship . phi ) ; p -> dx = 4 * - sin ( ship . phi ) + ship . dx ; p -> dy = 4 * cos ( ship . phi ) + ship . dy ; } else if ( p -> active == 2 ) { p -> pos . x += p -> dx ; p -> pos . y += p -> dy ; for ( int i = 0 ; i < MAX_ASTEROIDS ; i ++ ) { <S2SV_StartBug> if ( checkCollision ( & asteroids [ i ] . pos , & p -> pos , asteroids [ i ] . r , 1 ) == 1 ) { <S2SV_EndBug> isHit ( 1 ) ; asteroids [ i ] . active = 0 ; <S2SV_StartBug> p -> active = 0 ; <S2SV_EndBug> activePhotons -- ; break ; } } if ( screenWrap ( & p -> pos , 0 ) == 1 ) { p -> active = 0 ; activePhotons -- ; } } } | <S2SV_ModStart> , 1 ) && asteroids [ i ] . active <S2SV_ModEnd> ) { isHit <S2SV_ModStart> active = 0 ; activeAsteroids -- |
3,043 | CWE-000 static void do_complete ( int flags , Comp_type type ) { char * * words ; int nwords ; int start , end , nlen , olen ; int is_command ; int completed = 0 ; nwords = x_cf_glob ( flags , xbuf , xep - xbuf , xcp - xbuf , & start , & end , & words , & is_command ) ; if ( nwords == 0 ) { x_e_putc2 ( 7 ) ; return ; } if ( type == CT_LIST ) { x_print_expansions ( nwords , words , is_command ) ; x_redraw ( 0 ) ; x_free_words ( nwords , words ) ; return ; } olen = end - start ; nlen = x_longest_prefix ( nwords , words ) ; if ( nwords == 1 || nlen > olen ) { x_goto ( xbuf + start ) ; x_delete ( olen , false ) ; <S2SV_StartBug> x_escape ( words [ 0 ] , nlen , x_emacs_putbuf ) ; <S2SV_EndBug> x_adjust ( ) ; completed = 1 ; } if ( nwords == 1 && words [ 0 ] [ nlen - 1 ] != '/' ) { x_ins ( space ) ; completed = 1 ; } if ( type == CT_COMPLIST && ! completed ) { x_print_expansions ( nwords , words , is_command ) ; completed = 1 ; } <S2SV_StartBug> if ( completed ) <S2SV_EndBug> x_redraw ( 0 ) ; <S2SV_StartBug> x_free_words ( nwords , words ) ; <S2SV_EndBug> } | <S2SV_ModStart> , nlen , x_do_ins <S2SV_ModEnd> ) ; x_adjust <S2SV_ModStart> ( completed ) { x_goto ( xcp ) ; <S2SV_ModStart> 0 ) ; } |
3,044 | CWE-000 int qpnp_adc_get_revid_version ( struct device * dev ) { struct pmic_revid_data * revid_data ; struct device_node * revid_dev_node ; revid_dev_node = of_parse_phandle ( dev -> of_node , "qcom,pmic-revid" , 0 ) ; if ( ! revid_dev_node ) { pr_debug ( "Missing<S2SV_blank>qcom,pmic-revid<S2SV_blank>property\\n" ) ; return - EINVAL ; } revid_data = get_revid_data ( revid_dev_node ) ; <S2SV_StartBug> if ( IS_ERR ( revid_data ) ) { <S2SV_EndBug> pr_debug ( "revid<S2SV_blank>error<S2SV_blank>rc<S2SV_blank>=<S2SV_blank>%ld\\n" , PTR_ERR ( revid_data ) ) ; return - EINVAL ; } if ( ( revid_data -> rev1 == PM8941_V3P1_REV1 ) && ( revid_data -> rev2 == PM8941_V3P1_REV2 ) && ( revid_data -> rev3 == PM8941_V3P1_REV3 ) && ( revid_data -> rev4 == PM8941_V3P1_REV4 ) && ( revid_data -> pmic_subtype == PM8941_SUBTYPE ) ) return QPNP_REV_ID_8941_3_1 ; else if ( ( revid_data -> rev1 == PM8941_V3P0_REV1 ) && ( revid_data -> rev2 == PM8941_V3P0_REV2 ) && ( revid_data -> rev3 == PM8941_V3P0_REV3 ) && ( revid_data -> rev4 == PM8941_V3P0_REV4 ) && ( revid_data -> pmic_subtype == PM8941_SUBTYPE ) ) return QPNP_REV_ID_8941_3_0 ; else if ( ( revid_data -> rev1 == PM8941_V2P0_REV1 ) && ( revid_data -> rev2 == PM8941_V2P0_REV2 ) && ( revid_data -> rev3 == PM8941_V2P0_REV3 ) && ( revid_data -> rev4 == PM8941_V2P0_REV4 ) && ( revid_data -> pmic_subtype == PM8941_SUBTYPE ) ) return QPNP_REV_ID_8941_2_0 ; else if ( ( revid_data -> rev1 == PM8226_V2P2_REV1 ) && ( revid_data -> rev2 == PM8226_V2P2_REV2 ) && ( revid_data -> rev3 == PM8226_V2P2_REV3 ) && ( revid_data -> rev4 == PM8226_V2P2_REV4 ) && ( revid_data -> pmic_subtype == PM8226_SUBTYPE ) ) return QPNP_REV_ID_8026_2_2 ; else if ( ( revid_data -> rev1 == PM8226_V2P1_REV1 ) && ( revid_data -> rev2 == PM8226_V2P1_REV2 ) && ( revid_data -> rev3 == PM8226_V2P1_REV3 ) && ( revid_data -> rev4 == PM8226_V2P1_REV4 ) && ( revid_data -> pmic_subtype == PM8226_SUBTYPE ) ) return QPNP_REV_ID_8026_2_1 ; else if ( ( revid_data -> rev1 == PM8226_V2P0_REV1 ) && ( revid_data -> rev2 == PM8226_V2P0_REV2 ) && ( revid_data -> rev3 == PM8226_V2P0_REV3 ) && ( revid_data -> rev4 == PM8226_V2P0_REV4 ) && ( revid_data -> pmic_subtype == PM8226_SUBTYPE ) ) return QPNP_REV_ID_8026_2_0 ; else if ( ( revid_data -> rev1 == PM8226_V1P0_REV1 ) && ( revid_data -> rev2 == PM8226_V1P0_REV2 ) && ( revid_data -> rev3 == PM8226_V1P0_REV3 ) && ( revid_data -> rev4 == PM8226_V1P0_REV4 ) && ( revid_data -> pmic_subtype == PM8226_SUBTYPE ) ) return QPNP_REV_ID_8026_1_0 ; else if ( ( revid_data -> rev1 == PM8110_V1P0_REV1 ) && ( revid_data -> rev2 == PM8110_V1P0_REV2 ) && ( revid_data -> rev3 == PM8110_V1P0_REV3 ) && ( revid_data -> rev4 == PM8110_V1P0_REV4 ) && ( revid_data -> pmic_subtype == PM8110_SUBTYPE ) ) return QPNP_REV_ID_8110_1_0 ; else if ( ( revid_data -> rev1 == PM8110_V2P0_REV1 ) && ( revid_data -> rev2 == PM8110_V2P0_REV2 ) && ( revid_data -> rev3 == PM8110_V2P0_REV3 ) && ( revid_data -> rev4 == PM8110_V2P0_REV4 ) && ( revid_data -> pmic_subtype == PM8110_SUBTYPE ) ) return QPNP_REV_ID_8110_2_0 ; else if ( ( revid_data -> rev1 == PM8916_V1P0_REV1 ) && ( revid_data -> rev2 == PM8916_V1P0_REV2 ) && ( revid_data -> rev3 == PM8916_V1P0_REV3 ) && ( revid_data -> rev4 == PM8916_V1P0_REV4 ) && ( revid_data -> pmic_subtype == PM8916_SUBTYPE ) ) return QPNP_REV_ID_8916_1_0 ; else if ( ( revid_data -> rev1 == PM8916_V1P1_REV1 ) && ( revid_data -> rev2 == PM8916_V1P1_REV2 ) && ( revid_data -> rev3 == PM8916_V1P1_REV3 ) && ( revid_data -> rev4 == PM8916_V1P1_REV4 ) && ( revid_data -> pmic_subtype == PM8916_SUBTYPE ) ) return QPNP_REV_ID_8916_1_1 ; else if ( ( revid_data -> rev1 == PM8916_V2P0_REV1 ) && ( revid_data -> rev2 == PM8916_V2P0_REV2 ) && ( revid_data -> rev3 == PM8916_V2P0_REV3 ) && ( revid_data -> rev4 == PM8916_V2P0_REV4 ) && ( revid_data -> pmic_subtype == PM8916_SUBTYPE ) ) return QPNP_REV_ID_8916_2_0 ; else if ( ( revid_data -> rev1 == PM8909_V1P0_REV1 ) && ( revid_data -> rev2 == PM8909_V1P0_REV2 ) && ( revid_data -> rev3 == PM8909_V1P0_REV3 ) && ( revid_data -> rev4 == PM8909_V1P0_REV4 ) && ( revid_data -> pmic_subtype == PM8909_SUBTYPE ) ) return QPNP_REV_ID_8909_1_0 ; else if ( ( revid_data -> rev1 == PM8909_V1P1_REV1 ) && ( revid_data -> rev2 == PM8909_V1P1_REV2 ) && ( revid_data -> rev3 == PM8909_V1P1_REV3 ) && ( revid_data -> rev4 == PM8909_V1P1_REV4 ) && ( revid_data -> pmic_subtype == PM8909_SUBTYPE ) ) return QPNP_REV_ID_8909_1_1 ; else if ( ( revid_data -> rev4 == PM8950_V1P0_REV4 ) && ( revid_data -> pmic_subtype == PM8950_SUBTYPE ) ) return QPNP_REV_ID_PM8950_1_0 ; else return - EINVAL ; } | <S2SV_ModStart> ; if ( IS_ERR_OR_NULL <S2SV_ModEnd> ( revid_data ) |
3,045 | CWE-000 INT wifi_getApEnable ( INT apIndex , BOOL * output_bool ) { <S2SV_StartBug> INT retValue ; <S2SV_EndBug> char cmd [ MAX_CMD_SIZE ] = { '\\0' } ; char HConf_file [ MAX_BUF_SIZE ] = { '\\0' } ; char path [ MAX_BUF_SIZE ] = { '\\0' } ; char IfName [ MAX_BUF_SIZE ] = { '\\0' } ; char buf [ MAX_BUF_SIZE ] = { '\\0' } ; char tmp_status [ MAX_BUF_SIZE ] = { '\\0' } ; int count = 0 ; FILE * fp = NULL ; <S2SV_StartBug> if ( ! output_bool ) <S2SV_EndBug> return RETURN_ERR ; if ( ( apIndex == 0 ) || ( apIndex == 1 ) || ( apIndex == 4 ) || ( apIndex == 5 ) ) { sprintf ( HConf_file , "%s%d%s" , "/nvram/hostapd" , apIndex , ".conf" ) ; GetInterfaceName ( IfName , HConf_file ) ; if ( NULL == output_bool ) { return RETURN_ERR ; } else { sprintf ( cmd , "%s%s%s" , "ifconfig<S2SV_blank>" , IfName , "<S2SV_blank>|<S2SV_blank>grep<S2SV_blank>RUNNING<S2SV_blank>|<S2SV_blank>tr<S2SV_blank>-s<S2SV_blank>\'<S2SV_blank>\'<S2SV_blank>|<S2SV_blank>cut<S2SV_blank>-d<S2SV_blank>\'<S2SV_blank>\'<S2SV_blank>-f4" ) ; _syscmd ( cmd , buf , sizeof ( buf ) ) ; if ( strlen ( buf ) > 0 ) { <S2SV_StartBug> * output_bool = 1 ; <S2SV_EndBug> } else { if ( apIndex == 0 ) fp = fopen ( "/tmp/Get2gssidEnable.txt" , "r" ) ; else if ( apIndex == 1 ) fp = fopen ( "/tmp/Get5gssidEnable.txt" , "r" ) ; else if ( apIndex == 4 ) fp = fopen ( "/tmp/GetPub2gssidEnable.txt" , "r" ) ; else if ( apIndex == 5 ) fp = fopen ( "/tmp/GetPub5gssidEnable.txt" , "r" ) ; if ( fp == NULL ) { * output_bool = 0 ; return RETURN_OK ; } if ( fgets ( path , sizeof ( path ) - 1 , fp ) != NULL ) { for ( count = 0 ; path [ count ] != '\\n' ; count ++ ) tmp_status [ count ] = path [ count ] ; tmp_status [ count ] = '\\0' ; } fclose ( fp ) ; if ( strcmp ( tmp_status , "0" ) == 0 ) * output_bool = 0 ; else * output_bool = 1 ; return RETURN_OK ; } } } <S2SV_StartBug> return retValue ; <S2SV_EndBug> } | <S2SV_ModStart> output_bool ) { <S2SV_ModEnd> char cmd [ <S2SV_ModStart> ; if ( ( <S2SV_ModStart> ! output_bool ) || ( apIndex < 0 ) ) <S2SV_ModStart> output_bool = 1 ; return RETURN_OK <S2SV_ModStart> } } } else { if ( ( apIndex > 5 ) && ( apIndex < 17 ) ) return RETURN_OK ; else return RETURN_ERR ; } <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
3,046 | CWE-000 int rcsvr_main_thread ( SceSize args , void * argp ) { <S2SV_StartBug> sceKernelDelayThread ( 5000000 ) ; <S2SV_EndBug> while ( running ) { checkInput ( ) ; static uint64_t last_tick = 0ULL ; uint64_t curr_tick = util_gettick ( ) ; net_kcp_process ( curr_tick ) ; last_tick = curr_tick ; } net_finish ( ) ; return sceKernelExitDeleteThread ( 0 ) ; } | <S2SV_ModStart> sceKernelDelayThread ( 5000000 ) ; debug_init ( DEBUG ) ; net_kcp_listen ( 9527 |
3,047 | CWE-000 uint64_t timer_ms ( ) { # ifdef LINUX struct timespec ts ; if ( clock_gettime ( CLOCK_MONOTONIC , & ts ) != 0 ) return ( uint64_t ) - 1 ; <S2SV_StartBug> return ( uint64_t ) ( ts . tv_sec * 1000 ) ; <S2SV_EndBug> # else return ( uint64_t ) ( timer_frequency ( ) / __timer_ms ) ; # endif } | <S2SV_ModStart> ( ts . tv_nsec * 1000000 + ts . |
3,048 | CWE-000 void getLegalMovesForBlackPawn ( SPCHESSGame * src , move * elem , <S2SV_StartBug> int legalMoves [ MAX_STEPS_PIECE ] [ 2 ] ) { <S2SV_EndBug> int ind = 0 ; int row_from = elem -> from [ 0 ] ; int col_from = elem -> from [ 1 ] ; int i , j ; bool isPiece ; char currentColor = getColorFromPiece ( elem -> piece ) ; i = row_from - 1 ; j = col_from - 1 ; isPiece = src -> gameBoard [ i ] [ j ] != EMPTY ; if ( isInBoard ( i , j ) && isPiece && ! isSameColorAsGiven ( src , i , j , currentColor ) ) { legalMoves [ ind ] [ 0 ] = i ; legalMoves [ ind ] [ 1 ] = j ; ind ++ ; } i = row_from - 1 ; j = col_from + 1 ; isPiece = src -> gameBoard [ i ] [ j ] != EMPTY ; if ( isInBoard ( i , j ) && isPiece && ! isSameColorAsGiven ( src , i , j , currentColor ) ) { legalMoves [ ind ] [ 0 ] = i ; legalMoves [ ind ] [ 1 ] = j ; ind ++ ; } i = row_from - 1 ; j = col_from ; if ( isInBoard ( i , j ) && src -> gameBoard [ i ] [ j ] == EMPTY ) { legalMoves [ ind ] [ 0 ] = i ; legalMoves [ ind ] [ 1 ] = j ; ind ++ ; } i = row_from - 2 ; j = col_from ; if ( row_from == BOARD_SIZE - 2 && src -> gameBoard [ i + 1 ] [ j ] == EMPTY && src -> gameBoard [ i ] [ j ] == EMPTY ) { legalMoves [ ind ] [ 0 ] = i ; legalMoves [ ind ] [ 1 ] = j ; ind ++ ; } } | <S2SV_ModStart> MAX_STEPS_PIECE ] [ DIM <S2SV_ModEnd> ] ) { |
3,049 | CWE-000 void dt_bauhaus_init ( ) { darktable . bauhaus = ( dt_bauhaus_t * ) calloc ( 1 , sizeof ( dt_bauhaus_t ) ) ; darktable . bauhaus -> keys_cnt = 0 ; darktable . bauhaus -> current = NULL ; darktable . bauhaus -> popup_area = gtk_drawing_area_new ( ) ; GtkWidget * root_window = dt_ui_main_window ( darktable . gui -> ui ) ; g_signal_connect ( G_OBJECT ( root_window ) , "motion-notify-event" , G_CALLBACK ( dt_bauhaus_root_motion_notify ) , ( gpointer ) NULL ) ; g_signal_connect ( G_OBJECT ( root_window ) , "button-press-event" , G_CALLBACK ( dt_bauhaus_root_button_press ) , ( gpointer ) NULL ) ; darktable . bauhaus -> line_space = 2 ; darktable . bauhaus -> line_height = 11 ; darktable . bauhaus -> marker_size = 0.3f ; darktable . bauhaus -> label_font_size = 0.6f ; darktable . bauhaus -> value_font_size = 0.6f ; g_strlcpy ( darktable . bauhaus -> label_font , "sans" , sizeof ( darktable . bauhaus -> label_font ) ) ; g_strlcpy ( darktable . bauhaus -> value_font , "sans" , sizeof ( darktable . bauhaus -> value_font ) ) ; darktable . bauhaus -> bg_normal = 0.145098f ; darktable . bauhaus -> bg_focus = 0.207843f ; darktable . bauhaus -> text = .792f ; darktable . bauhaus -> grid = .1f ; darktable . bauhaus -> indicator = .6f ; darktable . bauhaus -> insensitive = 0.2f ; GtkStyleContext * ctx = gtk_style_context_new ( ) ; GtkWidgetPath * path ; path = gtk_widget_path_new ( ) ; int pos = gtk_widget_path_append_type ( path , GTK_TYPE_WIDGET ) ; gtk_widget_path_iter_set_name ( path , pos , "iop-plugin-ui" ) ; gtk_style_context_set_path ( ctx , path ) ; gtk_style_context_set_screen ( ctx , gtk_widget_get_screen ( root_window ) ) ; GdkRGBA color , selected_color , bg_color , selected_bg_color ; gtk_style_context_get_color ( ctx , GTK_STATE_FLAG_NORMAL , & color ) ; { GdkRGBA * bc ; gtk_style_context_get ( ctx , GTK_STATE_FLAG_NORMAL , "background-color" , & bc , NULL ) ; bg_color = * bc ; gdk_rgba_free ( bc ) ; } gtk_style_context_get_color ( ctx , GTK_STATE_FLAG_SELECTED , & selected_color ) ; { GdkRGBA * sbc ; gtk_style_context_get ( ctx , GTK_STATE_FLAG_SELECTED , "background-color" , & sbc , NULL ) ; selected_bg_color = * sbc ; gdk_rgba_free ( sbc ) ; } PangoFontDescription * pfont = 0 ; gtk_style_context_get ( ctx , GTK_STATE_FLAG_NORMAL , "font" , & pfont , NULL ) ; darktable . bauhaus -> bg_normal = bg_color . red ; darktable . bauhaus -> bg_focus = selected_bg_color . red ; gtk_widget_path_free ( path ) ; darktable . bauhaus -> pango_font_desc = pfont ; PangoLayout * layout ; cairo_surface_t * cst = cairo_image_surface_create ( CAIRO_FORMAT_ARGB32 , 128 , 128 ) ; cairo_t * cr = cairo_create ( cst ) ; layout = pango_cairo_create_layout ( cr ) ; pango_layout_set_text ( layout , "X" , - 1 ) ; pango_layout_set_font_description ( layout , darktable . bauhaus -> pango_font_desc ) ; pango_cairo_context_set_resolution ( pango_layout_get_context ( layout ) , darktable . gui -> dpi ) ; int pango_width , pango_height ; pango_layout_get_size ( layout , & pango_width , & pango_height ) ; g_object_unref ( layout ) ; cairo_destroy ( cr ) ; cairo_surface_destroy ( cst ) ; darktable . bauhaus -> scale = ( pango_height + 0.0f ) / PANGO_SCALE / 8.5f ; darktable . bauhaus -> widget_space = 2.5f * darktable . bauhaus -> scale ; darktable . bauhaus -> keymap = g_hash_table_new_full ( g_str_hash , g_str_equal , g_free , NULL ) ; darktable . bauhaus -> key_mod = NULL ; darktable . bauhaus -> key_val = NULL ; memset ( darktable . bauhaus -> key_history , 0 , sizeof ( darktable . bauhaus -> key_history ) ) ; darktable . bauhaus -> popup_window = gtk_window_new ( GTK_WINDOW_POPUP ) ; dt_gui_key_accel_block_on_focus_connect ( darktable . bauhaus -> popup_area ) ; gtk_widget_set_size_request ( darktable . bauhaus -> popup_area , DT_PIXEL_APPLY_DPI ( 300 ) , DT_PIXEL_APPLY_DPI ( 300 ) ) ; gtk_window_set_resizable ( GTK_WINDOW ( darktable . bauhaus -> popup_window ) , FALSE ) ; <S2SV_StartBug> gtk_window_set_default_size ( GTK_WINDOW ( darktable . bauhaus -> popup_window ) , 260 , 260 ) ; <S2SV_EndBug> gtk_window_set_transient_for ( GTK_WINDOW ( darktable . bauhaus -> popup_window ) , GTK_WINDOW ( dt_ui_main_window ( darktable . gui -> ui ) ) ) ; gtk_container_add ( GTK_CONTAINER ( darktable . bauhaus -> popup_window ) , darktable . bauhaus -> popup_area ) ; gtk_window_set_keep_above ( GTK_WINDOW ( darktable . bauhaus -> popup_window ) , TRUE ) ; gtk_window_set_gravity ( GTK_WINDOW ( darktable . bauhaus -> popup_window ) , GDK_GRAVITY_STATIC ) ; gtk_widget_set_can_focus ( darktable . bauhaus -> popup_area , TRUE ) ; gtk_widget_add_events ( darktable . bauhaus -> popup_area , GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_SCROLL_MASK ) ; g_signal_connect ( G_OBJECT ( darktable . bauhaus -> popup_window ) , "show" , G_CALLBACK ( window_show ) , ( gpointer ) NULL ) ; g_signal_connect ( G_OBJECT ( darktable . bauhaus -> popup_area ) , "draw" , G_CALLBACK ( dt_bauhaus_popup_draw ) , ( gpointer ) NULL ) ; g_signal_connect ( G_OBJECT ( darktable . bauhaus -> popup_area ) , "motion-notify-event" , G_CALLBACK ( dt_bauhaus_popup_motion_notify ) , ( gpointer ) NULL ) ; g_signal_connect ( G_OBJECT ( darktable . bauhaus -> popup_area ) , "leave-notify-event" , G_CALLBACK ( dt_bauhaus_popup_leave_notify ) , ( gpointer ) NULL ) ; g_signal_connect ( G_OBJECT ( darktable . bauhaus -> popup_area ) , "button-press-event" , G_CALLBACK ( dt_bauhaus_popup_button_press ) , ( gpointer ) NULL ) ; g_signal_connect ( G_OBJECT ( darktable . bauhaus -> popup_area ) , "key-press-event" , G_CALLBACK ( dt_bauhaus_popup_key_press ) , ( gpointer ) NULL ) ; g_signal_connect ( G_OBJECT ( darktable . bauhaus -> popup_area ) , "scroll-event" , G_CALLBACK ( dt_bauhaus_popup_scroll ) , ( gpointer ) NULL ) ; } | <S2SV_ModStart> 260 , 260 ) ; gtk_window_set_modal ( GTK_WINDOW ( darktable . bauhaus -> popup_window ) , TRUE |
3,050 | CWE-000 void print_diagsums ( int * a , int size ) { <S2SV_StartBug> int sum1 = 0 ; <S2SV_EndBug> <S2SV_StartBug> int sum2 = 0 ; <S2SV_EndBug> int start = size * size - 1 ; <S2SV_StartBug> int size_copy = size - 1 ; ; <S2SV_EndBug> int i = size_copy ; while ( start >= 0 ) { sum1 = a [ start ] + sum1 ; start = start - ( size + 1 ) ; } while ( size > 0 ) { sum2 = sum2 + a [ size_copy ] ; size_copy = size_copy + i ; size -- ; } printf ( "%d,<S2SV_blank>%d\\n" , sum1 , sum2 ) ; } | <S2SV_ModStart> sum1 = 0 , <S2SV_ModEnd> sum2 = 0 <S2SV_ModStart> sum2 = 0 , i <S2SV_ModStart> - 1 ; <S2SV_ModEnd> i = size_copy |
3,051 | CWE-000 gboolean nm_settings_connection_new_secrets ( NMSettingsConnection * self , NMConnection * applied_connection , const char * setting_name , GVariant * secrets , GError * * error ) { <S2SV_StartBug> gs_free_error GError * local = NULL ; <S2SV_EndBug> if ( ! nm_settings_connection_has_unmodified_applied_connection ( self , applied_connection , NM_SETTING_COMPARE_FLAG_NONE ) ) { g_set_error_literal ( error , NM_SETTINGS_ERROR , NM_SETTINGS_ERROR_FAILED , "The<S2SV_blank>connection<S2SV_blank>was<S2SV_blank>modified<S2SV_blank>since<S2SV_blank>activation" ) ; return FALSE ; } if ( ! nm_connection_update_secrets ( NM_CONNECTION ( self ) , setting_name , secrets , error ) ) return FALSE ; update_system_secrets_cache ( self ) ; update_agent_secrets_cache ( self , NULL ) ; <S2SV_StartBug> if ( ! nm_settings_connection_commit_changes ( self , <S2SV_EndBug> <S2SV_StartBug> NM_SETTINGS_CONNECTION_COMMIT_REASON_NONE , <S2SV_EndBug> & local ) ) _LOGW ( "Error<S2SV_blank>saving<S2SV_blank>new<S2SV_blank>secrets<S2SV_blank>to<S2SV_blank>backing<S2SV_blank>storage:<S2SV_blank>%s" , local -> message ) ; return TRUE ; } | <S2SV_ModStart> error ) { <S2SV_ModEnd> if ( ! <S2SV_ModStart> NULL ) ; <S2SV_ModEnd> nm_settings_connection_commit_changes ( self <S2SV_ModStart> ( self , NULL , NM_SETTINGS_CONNECTION_COMMIT_REASON_NONE , NULL <S2SV_ModEnd> ) ; return |
3,052 | CWE-000 <S2SV_StartBug> int main ( ) { <S2SV_EndBug> char * Source = "../TestFiles/source.ascii" ; open_file ( Source ) ; int done = 0 ; <S2SV_StartBug> Reg [ PC ] = 0 ; <S2SV_EndBug> unsigned short fetched_instruction ; long int instruction_counter = 0 ; <S2SV_StartBug> while ( ! done ) { <S2SV_EndBug> <S2SV_StartBug> fetched_instruction = read_mem ( INSTRUCTION_FETCH , Reg [ PC ] ) ; <S2SV_EndBug> instruction_counter ++ ; } display ( ) ; <S2SV_StartBug> return ( 0 ) ; <S2SV_EndBug> } | <S2SV_ModStart> int main ( int argc , int argv <S2SV_ModStart> PC ] = ( argc == 2 ) ? argv : <S2SV_ModStart> = 0 ; FILE * trace = fopen ( "tracefile.txt" , "w" ) ; if ( trace == NULL ) { printf ( "Error<S2SV_blank>opening<S2SV_blank>trace<S2SV_blank>file!\\n" ) ; exit ( 1 ) ; } done = 1 ; <S2SV_ModStart> = read_mem ( trace , <S2SV_ModStart> ( ) ; fclose ( trace ) ; |
3,053 | CWE-000 void dict_put ( Dict dict , const void * key , const void * value ) { <S2SV_StartBug> assert ( key != NULL ) ; <S2SV_EndBug> int write_pos ; int found = find_key ( dict , key , & write_pos ) ; if ( found != - 1 ) { void * old = dict -> data [ found ] . value ; memcpy ( dict -> data [ found ] . value , value , dict -> value_size ) ; } else { if ( write_pos == - 1 ) { extend ( dict ) ; dict_put ( dict , key , value ) ; } else { dict -> data [ write_pos ] . key = malloc ( dict -> key_size ) ; assert ( dict -> data [ write_pos ] . key != NULL ) ; memcpy ( dict -> data [ write_pos ] . key , key , dict -> key_size ) ; dict -> data [ write_pos ] . value = malloc ( dict -> value_size ) ; assert ( dict -> data [ write_pos ] . value != NULL ) ; memcpy ( dict -> data [ write_pos ] . value , value , dict -> value_size ) ; dict -> length ++ ; } } } | <S2SV_ModStart> NULL ) ; if ( dict -> length == ( dict -> type == DictTypeLinear ? dict -> capacity : dict -> capacity / 4 * 3 ) ) { extend ( dict ) ; } |
3,054 | CWE-000 int main ( int c , char * * v ) { <S2SV_StartBug> int fd ; <S2SV_EndBug> t_asm bin [ 1 ] ; if ( c > 1 ) { if ( ( fd = open ( v [ c - 1 ] , O_RDONLY ) ) == - 1 ) ft_printf ( "Can\'t<S2SV_blank>read<S2SV_blank>source<S2SV_blank>file<S2SV_blank>%s\\n" , v [ c - 1 ] ) ; else { <S2SV_StartBug> go ( fd , ( t_asm * ) & bin , v [ 1 ] ) ; <S2SV_EndBug> ft_printf ( "Writing<S2SV_blank>output<S2SV_blank>program<S2SV_blank>to<S2SV_blank>%s\\n" , bin -> file_name ) ; } } else ft_printf ( "Usage:<S2SV_blank>./asm<S2SV_blank><sourcefile.s>\\n" ) ; return ( 0 ) ; } | <S2SV_ModStart> { int fd ; int i <S2SV_ModStart> ; else { i = ft_strlen ( v [ c - 1 ] ) ; if ( v [ c - 1 ] [ i - 1 ] != 's' && v [ c - 1 ] [ i - 2 ] != '.' ) error ( bin , 0 , 9 ) ; |
3,055 | CWE-000 static int rockchip_hdmi_parse_dt ( struct rockchip_hdmi * hdmi ) { struct device_node * np = hdmi -> dev -> of_node ; <S2SV_StartBug> int ret ; <S2SV_EndBug> hdmi -> regmap = syscon_regmap_lookup_by_phandle ( np , "rockchip,grf" ) ; if ( IS_ERR ( hdmi -> regmap ) ) { DRM_DEV_ERROR ( hdmi -> dev , "Unable<S2SV_blank>to<S2SV_blank>get<S2SV_blank>rockchip,grf\\n" ) ; return PTR_ERR ( hdmi -> regmap ) ; } hdmi -> vpll_clk = devm_clk_get ( hdmi -> dev , "vpll" ) ; if ( PTR_ERR ( hdmi -> vpll_clk ) == - ENOENT ) { hdmi -> vpll_clk = NULL ; } else if ( PTR_ERR ( hdmi -> vpll_clk ) == - EPROBE_DEFER ) { return - EPROBE_DEFER ; } else if ( IS_ERR ( hdmi -> vpll_clk ) ) { DRM_DEV_ERROR ( hdmi -> dev , "failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>grf<S2SV_blank>clock\\n" ) ; return PTR_ERR ( hdmi -> vpll_clk ) ; } hdmi -> grf_clk = devm_clk_get ( hdmi -> dev , "grf" ) ; if ( PTR_ERR ( hdmi -> grf_clk ) == - ENOENT ) { hdmi -> grf_clk = NULL ; } else if ( PTR_ERR ( hdmi -> grf_clk ) == - EPROBE_DEFER ) { return - EPROBE_DEFER ; } else if ( IS_ERR ( hdmi -> grf_clk ) ) { DRM_DEV_ERROR ( hdmi -> dev , "failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>grf<S2SV_blank>clock\\n" ) ; return PTR_ERR ( hdmi -> grf_clk ) ; } <S2SV_StartBug> ret = clk_prepare_enable ( hdmi -> vpll_clk ) ; <S2SV_EndBug> if ( ret ) { DRM_DEV_ERROR ( hdmi -> dev , "Failed<S2SV_blank>to<S2SV_blank>enable<S2SV_blank>HDMI<S2SV_blank>vpll:<S2SV_blank>%d\\n" , ret ) ; return ret ; } return 0 ; } | <S2SV_ModStart> -> of_node ; <S2SV_ModEnd> hdmi -> regmap <S2SV_ModStart> ) ; } <S2SV_ModEnd> return 0 ; |
3,056 | CWE-000 static void channel_tls_process_versions_cell ( var_cell_t * cell , channel_tls_t * chan ) { int highest_supported_version = 0 ; int started_here = 0 ; tor_assert ( cell ) ; tor_assert ( chan ) ; tor_assert ( chan -> conn ) ; if ( ( cell -> payload_len % 2 ) == 1 ) { log_fn ( LOG_PROTOCOL_WARN , LD_OR , "Received<S2SV_blank>a<S2SV_blank>VERSION<S2SV_blank>cell<S2SV_blank>with<S2SV_blank>odd<S2SV_blank>payload<S2SV_blank>length<S2SV_blank>%d;<S2SV_blank>" "closing<S2SV_blank>connection." , cell -> payload_len ) ; connection_or_close_for_error ( chan -> conn , 0 ) ; return ; } started_here = connection_or_nonopen_was_started_here ( chan -> conn ) ; if ( chan -> conn -> link_proto != 0 || ( chan -> conn -> handshake_state && chan -> conn -> handshake_state -> received_versions ) ) { log_fn ( LOG_PROTOCOL_WARN , LD_OR , "Received<S2SV_blank>a<S2SV_blank>VERSIONS<S2SV_blank>cell<S2SV_blank>on<S2SV_blank>a<S2SV_blank>connection<S2SV_blank>with<S2SV_blank>its<S2SV_blank>version<S2SV_blank>" "already<S2SV_blank>set<S2SV_blank>to<S2SV_blank>%d;<S2SV_blank>dropping" , ( int ) ( chan -> conn -> link_proto ) ) ; return ; } switch ( chan -> conn -> base_ . state ) { case OR_CONN_STATE_OR_HANDSHAKING_V2 : case OR_CONN_STATE_OR_HANDSHAKING_V3 : break ; case OR_CONN_STATE_TLS_HANDSHAKING : case OR_CONN_STATE_TLS_SERVER_RENEGOTIATING : default : log_fn ( LOG_PROTOCOL_WARN , LD_OR , "VERSIONS<S2SV_blank>cell<S2SV_blank>while<S2SV_blank>in<S2SV_blank>unexpected<S2SV_blank>state" ) ; return ; } tor_assert ( chan -> conn -> handshake_state ) ; { int i ; const uint8_t * cp = cell -> payload ; for ( i = 0 ; i < cell -> payload_len / 2 ; ++ i , cp += 2 ) { uint16_t v = ntohs ( get_uint16 ( cp ) ) ; if ( is_or_protocol_version_known ( v ) && v > highest_supported_version ) highest_supported_version = v ; } } if ( ! highest_supported_version ) { log_fn ( LOG_PROTOCOL_WARN , LD_OR , "Couldn\'t<S2SV_blank>find<S2SV_blank>a<S2SV_blank>version<S2SV_blank>in<S2SV_blank>common<S2SV_blank>between<S2SV_blank>my<S2SV_blank>version<S2SV_blank>list<S2SV_blank>and<S2SV_blank>the<S2SV_blank>" "list<S2SV_blank>in<S2SV_blank>the<S2SV_blank>VERSIONS<S2SV_blank>cell;<S2SV_blank>closing<S2SV_blank>connection." ) ; connection_or_close_for_error ( chan -> conn , 0 ) ; return ; } else if ( highest_supported_version == 1 ) { log_fn ( LOG_PROTOCOL_WARN , LD_OR , "Used<S2SV_blank>version<S2SV_blank>negotiation<S2SV_blank>protocol<S2SV_blank>to<S2SV_blank>negotiate<S2SV_blank>a<S2SV_blank>v1<S2SV_blank>connection.<S2SV_blank>" "That\'s<S2SV_blank>crazily<S2SV_blank>non-compliant.<S2SV_blank>Closing<S2SV_blank>connection." ) ; connection_or_close_for_error ( chan -> conn , 0 ) ; return ; } else if ( highest_supported_version < 3 && chan -> conn -> base_ . state == OR_CONN_STATE_OR_HANDSHAKING_V3 ) { log_fn ( LOG_PROTOCOL_WARN , LD_OR , "Negotiated<S2SV_blank>link<S2SV_blank>protocol<S2SV_blank>2<S2SV_blank>or<S2SV_blank>lower<S2SV_blank>after<S2SV_blank>doing<S2SV_blank>a<S2SV_blank>v3<S2SV_blank>TLS<S2SV_blank>" "handshake.<S2SV_blank>Closing<S2SV_blank>connection." ) ; connection_or_close_for_error ( chan -> conn , 0 ) ; return ; } else if ( highest_supported_version != 2 && chan -> conn -> base_ . state == OR_CONN_STATE_OR_HANDSHAKING_V2 ) { log_fn ( LOG_WARN , LD_OR , "Negotiated<S2SV_blank>link<S2SV_blank>with<S2SV_blank>non-2<S2SV_blank>protocol<S2SV_blank>after<S2SV_blank>doing<S2SV_blank>a<S2SV_blank>v2<S2SV_blank>TLS<S2SV_blank>" "handshake<S2SV_blank>with<S2SV_blank>%s.<S2SV_blank>Closing<S2SV_blank>connection." , fmt_addr ( & chan -> conn -> base_ . addr ) ) ; connection_or_close_for_error ( chan -> conn , 0 ) ; return ; } rep_hist_note_negotiated_link_proto ( highest_supported_version , started_here ) ; chan -> conn -> link_proto = highest_supported_version ; chan -> conn -> handshake_state -> received_versions = 1 ; if ( chan -> conn -> link_proto == 2 ) { log_info ( LD_OR , "Negotiated<S2SV_blank>version<S2SV_blank>%d<S2SV_blank>with<S2SV_blank>%s:%d;<S2SV_blank>sending<S2SV_blank>NETINFO." , highest_supported_version , safe_str_client ( chan -> conn -> base_ . address ) , chan -> conn -> base_ . port ) ; if ( connection_or_send_netinfo ( chan -> conn ) < 0 ) { connection_or_close_for_error ( chan -> conn , 0 ) ; return ; } } else { const int send_versions = ! started_here ; const int send_certs = ! started_here || public_server_mode ( get_options ( ) ) ; const int send_chall = ! started_here ; const int send_netinfo = ! started_here ; const int send_any = send_versions || send_certs || send_chall || send_netinfo ; tor_assert ( chan -> conn -> link_proto >= 3 ) ; log_info ( LD_OR , "Negotiated<S2SV_blank>version<S2SV_blank>%d<S2SV_blank>with<S2SV_blank>%s:%d;<S2SV_blank>%s%s%s%s%s" , highest_supported_version , safe_str_client ( chan -> conn -> base_ . address ) , chan -> conn -> base_ . port , send_any ? "Sending<S2SV_blank>cells:" : "Waiting<S2SV_blank>for<S2SV_blank>CERTS<S2SV_blank>cell" , send_versions ? "<S2SV_blank>VERSIONS" : "" , send_certs ? "<S2SV_blank>CERTS" : "" , send_chall ? "<S2SV_blank>AUTH_CHALLENGE" : "" , send_netinfo ? "<S2SV_blank>NETINFO" : "" ) ; # ifdef DISABLE_V3_LINKPROTO_SERVERSIDE if ( 1 ) { connection_or_close_normally ( chan -> conn , 1 ) ; return ; } # endif if ( send_versions ) { if ( connection_or_send_versions ( chan -> conn , 1 ) < 0 ) { log_warn ( LD_OR , "Couldn\'t<S2SV_blank>send<S2SV_blank>versions<S2SV_blank>cell" ) ; connection_or_close_for_error ( chan -> conn , 0 ) ; return ; } } <S2SV_StartBug> chan -> base_ . wide_circ_ids = <S2SV_EndBug> chan -> conn -> link_proto >= MIN_LINK_PROTO_FOR_WIDE_CIRC_IDS ; <S2SV_StartBug> chan -> conn -> wide_circ_ids = chan -> base_ . wide_circ_ids ; <S2SV_EndBug> chan -> base_ . padding_enabled = chan -> conn -> link_proto >= MIN_LINK_PROTO_FOR_CHANNEL_PADDING ; if ( send_certs ) { if ( connection_or_send_certs_cell ( chan -> conn ) < 0 ) { log_warn ( LD_OR , "Couldn\'t<S2SV_blank>send<S2SV_blank>certs<S2SV_blank>cell" ) ; connection_or_close_for_error ( chan -> conn , 0 ) ; return ; } } if ( send_chall ) { if ( connection_or_send_auth_challenge_cell ( chan -> conn ) < 0 ) { log_warn ( LD_OR , "Couldn\'t<S2SV_blank>send<S2SV_blank>auth_challenge<S2SV_blank>cell" ) ; connection_or_close_for_error ( chan -> conn , 0 ) ; return ; } } if ( send_netinfo ) { if ( connection_or_send_netinfo ( chan -> conn ) < 0 ) { log_warn ( LD_OR , "Couldn\'t<S2SV_blank>send<S2SV_blank>netinfo<S2SV_blank>cell" ) ; connection_or_close_for_error ( chan -> conn , 0 ) ; return ; } } } } | <S2SV_ModStart> ; } } TLS_CHAN_TO_BASE ( chan ) -> <S2SV_ModEnd> wide_circ_ids = chan <S2SV_ModStart> -> wide_circ_ids = TLS_CHAN_TO_BASE ( chan ) -> wide_circ_ids ; TLS_CHAN_TO_BASE ( chan ) -> <S2SV_ModEnd> padding_enabled = chan |
3,057 | CWE-000 void mlx5e_tc_update_neigh_used_value ( struct mlx5e_neigh_hash_entry * nhe ) { struct mlx5e_neigh * m_neigh = & nhe -> m_neigh ; u64 bytes , packets , lastuse = 0 , lastuse2 = 0 ; struct mlx5e_tc_flow * flow ; struct mlx5e_encap_entry * e ; struct mlx5_fc * counter ; struct neigh_table * tbl ; bool neigh_used = false ; struct neighbour * n ; if ( m_neigh -> family == AF_INET ) tbl = & arp_tbl ; # if IS_ENABLED ( CONFIG_IPV6 ) else if ( m_neigh -> family == AF_INET6 ) <S2SV_StartBug> tbl = ipv6_stub -> nd_tbl ; <S2SV_EndBug> # endif else return ; list_for_each_entry ( e , & nhe -> encap_list , encap_list ) { if ( ! ( e -> flags & MLX5_ENCAP_ENTRY_VALID ) ) continue ; list_for_each_entry ( flow , & e -> flows , encap ) { if ( flow -> flags & MLX5E_TC_FLOW_OFFLOADED ) { counter = mlx5_flow_rule_counter ( flow -> rule ) ; mlx5_fc_query_cached ( counter , & bytes , & packets , & lastuse ) ; } if ( flow -> peer_flow && ( flow -> peer_flow -> flags & MLX5E_TC_FLOW_OFFLOADED ) ) { counter = mlx5_flow_rule_counter ( flow -> peer_flow -> rule ) ; mlx5_fc_query_cached ( counter , & bytes , & packets , & lastuse2 ) ; } lastuse = max_t ( u64 , lastuse , lastuse2 ) ; if ( time_after ( ( unsigned long ) lastuse , nhe -> reported_lastuse ) ) { neigh_used = true ; break ; } } if ( neigh_used ) break ; } if ( neigh_used ) { nhe -> reported_lastuse = jiffies ; n = neigh_lookup ( tbl , & m_neigh -> dst_ip , m_neigh -> dev ) ; if ( ! n ) return ; neigh_event_send ( n , NULL ) ; neigh_release ( n ) ; } } | <S2SV_ModStart> ) tbl = & <S2SV_ModEnd> nd_tbl ; # |
3,058 | CWE-000 <S2SV_StartBug> static void MakeSeqName ( SEXP names , R_len_t nix , SEXP base , R_len_t seq_start , <S2SV_EndBug> R_len_t * first_in_seq ) { <S2SV_StartBug> if ( seq_start == 0 ) <S2SV_EndBug> <S2SV_StartBug> SET_STRING_ELT ( names , nix - 1 , base ) ; <S2SV_EndBug> <S2SV_StartBug> else if ( * first_in_seq == 0 ) { <S2SV_EndBug> <S2SV_StartBug> SET_STRING_ELT ( names , nix - 1 , base ) ; <S2SV_EndBug> <S2SV_StartBug> * first_in_seq = nix ; <S2SV_EndBug> } else { const char * strings [ 3 ] ; R_len_t lengths [ 2 ] ; char sno [ 31 ] ; const void * vmax = VMAXGET ( ) ; <S2SV_StartBug> integer_to_string ( sno , nix - seq_start + 1 ) ; <S2SV_EndBug> strings [ 0 ] = translateCharUTF8 ( base ) ; strings [ 1 ] = sno ; strings [ 2 ] = NULL ; lengths [ 0 ] = strlen ( strings [ 0 ] ) ; lengths [ 1 ] = strlen ( strings [ 1 ] ) ; <S2SV_StartBug> if ( nix > LENGTH ( names ) ) abort ( ) ; <S2SV_EndBug> <S2SV_StartBug> SET_STRING_ELT ( names , nix - 1 , <S2SV_EndBug> Rf_mkCharMulti ( strings , lengths , 0 , CE_UTF8 ) ) ; if ( * first_in_seq > 0 ) { <S2SV_StartBug> if ( * first_in_seq >= nix ) abort ( ) ; <S2SV_EndBug> <S2SV_StartBug> strings [ 1 ] = "1" ; <S2SV_EndBug> lengths [ 1 ] = 1 ; SET_STRING_ELT ( names , * first_in_seq - 1 , Rf_mkCharMulti ( strings , lengths , 0 , CE_UTF8 ) ) ; * first_in_seq = - 1 ; } VMAXSET ( vmax ) ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> names , R_len_t * <S2SV_ModStart> == 0 ) { <S2SV_ModStart> ( names , * <S2SV_ModStart> base ) ; } <S2SV_ModStart> ( names , * <S2SV_ModStart> * first_in_seq = * <S2SV_ModStart> ( sno , * <S2SV_ModStart> ; if ( * <S2SV_ModStart> ( names , * <S2SV_ModStart> * first_in_seq >= * <S2SV_ModStart> ( ) ; integer_to_string ( sno , * first_in_seq - seq_start + 1 ) ; strings [ 1 ] = sno ; lengths [ 1 ] = strlen ( strings [ 1 ] ) <S2SV_ModEnd> ; SET_STRING_ELT ( <S2SV_ModStart> ) ; } * nix += 1 ; |
3,059 | CWE-000 void _print_dumped_memory ( void * buffer , int bytes , int base , int two_column ) { char * fullhex = _format_dumped_memory ( buffer , bytes , two_column ) ; if ( base == 10 ) { unsigned long long base10 ; sscanf ( fullhex , "%llx" , & base10 ) ; printf ( "%llu" , base10 ) ; } else { printf ( "%-20.20s" , fullhex ) ; int hexlen = strlen ( fullhex ) ; char * space = strchr ( fullhex , '<S2SV_blank>' ) ; if ( space ) memmove ( space , space + 1 , strlen ( space ) ) ; <S2SV_StartBug> for ( int i = 0 ; i < hexlen ; i += 2 ) { <S2SV_EndBug> char char_str [ 3 ] ; sprintf ( char_str , "%c%c" , fullhex [ i ] , fullhex [ i + 1 ] ) ; unsigned int char_to_print ; sscanf ( char_str , "%x" , & char_to_print ) ; if ( isgraph ( char_to_print ) ) printf ( "%c<S2SV_blank>" , char_to_print ) ; else printf ( ".<S2SV_blank>" ) ; } } free ( fullhex ) ; } | <S2SV_ModStart> i < hexlen - 1 |
3,060 | CWE-000 static int fsl_sai_trigger ( struct snd_pcm_substream * substream , int cmd , struct snd_soc_dai * cpu_dai ) { struct fsl_sai * sai = snd_soc_dai_get_drvdata ( cpu_dai ) ; bool tx = substream -> stream == SNDRV_PCM_STREAM_PLAYBACK ; u8 channels = substream -> runtime -> channels ; u32 xcsr , count = 100 ; int i ; regmap_update_bits ( sai -> regmap , FSL_SAI_TCR2 , FSL_SAI_CR2_SYNC , sai -> synchronous [ TX ] ? FSL_SAI_CR2_SYNC : 0 ) ; regmap_update_bits ( sai -> regmap , FSL_SAI_RCR2 , FSL_SAI_CR2_SYNC , sai -> synchronous [ RX ] ? FSL_SAI_CR2_SYNC : 0 ) ; switch ( cmd ) { case SNDRV_PCM_TRIGGER_START : case SNDRV_PCM_TRIGGER_RESUME : case SNDRV_PCM_TRIGGER_PAUSE_RELEASE : regmap_update_bits ( sai -> regmap , FSL_SAI_xCSR ( tx ) , FSL_SAI_CSR_FRDE , FSL_SAI_CSR_FRDE ) ; for ( i = 0 ; tx && i < channels ; i ++ ) regmap_write ( sai -> regmap , FSL_SAI_TDR , 0x0 ) ; if ( tx ) udelay ( 10 ) ; regmap_update_bits ( sai -> regmap , FSL_SAI_RCSR , FSL_SAI_CSR_TERE , FSL_SAI_CSR_TERE ) ; regmap_update_bits ( sai -> regmap , FSL_SAI_TCSR , FSL_SAI_CSR_TERE , FSL_SAI_CSR_TERE ) ; regmap_update_bits ( sai -> regmap , FSL_SAI_xCSR ( tx ) , FSL_SAI_CSR_xIE_MASK , FSL_SAI_FLAGS ) ; break ; case SNDRV_PCM_TRIGGER_STOP : case SNDRV_PCM_TRIGGER_SUSPEND : case SNDRV_PCM_TRIGGER_PAUSE_PUSH : regmap_update_bits ( sai -> regmap , FSL_SAI_xCSR ( tx ) , FSL_SAI_CSR_FRDE , 0 ) ; regmap_update_bits ( sai -> regmap , FSL_SAI_xCSR ( tx ) , FSL_SAI_CSR_xIE_MASK , 0 ) ; regmap_read ( sai -> regmap , FSL_SAI_xCSR ( ! tx ) , & xcsr ) ; if ( ! ( xcsr & FSL_SAI_CSR_FRDE ) ) { regmap_update_bits ( sai -> regmap , FSL_SAI_TCSR , FSL_SAI_CSR_TERE , 0 ) ; regmap_update_bits ( sai -> regmap , FSL_SAI_RCSR , FSL_SAI_CSR_TERE , 0 ) ; do { udelay ( 10 ) ; regmap_read ( sai -> regmap , FSL_SAI_xCSR ( tx ) , & xcsr ) ; } while ( -- count && xcsr & FSL_SAI_CSR_TERE ) ; regmap_update_bits ( sai -> regmap , FSL_SAI_TCSR , FSL_SAI_CSR_FR , FSL_SAI_CSR_FR ) ; regmap_update_bits ( sai -> regmap , FSL_SAI_RCSR , FSL_SAI_CSR_FR , FSL_SAI_CSR_FR ) ; <S2SV_StartBug> regmap_write ( sai -> regmap , FSL_SAI_TCSR , FSL_SAI_CSR_SR ) ; <S2SV_EndBug> regmap_write ( sai -> regmap , FSL_SAI_RCSR , FSL_SAI_CSR_SR ) ; regmap_write ( sai -> regmap , FSL_SAI_TCSR , 0 ) ; <S2SV_StartBug> regmap_write ( sai -> regmap , FSL_SAI_RCSR , 0 ) ; <S2SV_EndBug> } break ; default : return - EINVAL ; } return 0 ; } | <S2SV_ModStart> FSL_SAI_CSR_FR ) ; if ( ! sai -> is_slave_mode ) { <S2SV_ModStart> 0 ) ; } |
3,061 | CWE-000 gboolean <S2SV_StartBug> _dm_create ( const gchar * const name , uint32_t udev_cookie , <S2SV_EndBug> const guint n_targets , const struct dm_target * const targets , GString * * mangled_name , GError * * const err ) { gboolean r = TRUE ; if ( mangled_name ) * mangled_name = NULL ; struct dm_task * const task = dm_task_create ( DM_DEVICE_CREATE ) ; if ( ! task ) { g_set_error ( err , LDM_ERROR , LDM_ERROR_EXTERNAL , "dm_task_create(DM_DEVICE_CREATE)<S2SV_blank>failed:<S2SV_blank>%s" , _dm_err_last_msg ) ; return FALSE ; } if ( ! dm_task_set_name ( task , name ) ) { g_set_error ( err , LDM_ERROR , LDM_ERROR_EXTERNAL , "DM_DEVICE_CREATE:<S2SV_blank>dm_task_set_name(%s)<S2SV_blank>failed:<S2SV_blank>%s" , <S2SV_StartBug> name , _dm_err_last_msg ) ; <S2SV_EndBug> r = FALSE ; goto out ; } for ( guint i = 0 ; i < n_targets ; i ++ ) { const struct dm_target * const target = & targets [ i ] ; if ( ! dm_task_add_target ( task , target -> start , target -> size , target -> type , target -> params -> str ) ) { g_set_error ( err , LDM_ERROR , LDM_ERROR_EXTERNAL , "DM_DEVICE_CREATE:<S2SV_blank>" "dm_task_add_target(%s,<S2SV_blank>%" PRIu64 ",<S2SV_blank>%" PRIu64 ",<S2SV_blank>" "%s,<S2SV_blank>%s)<S2SV_blank>failed:<S2SV_blank>%s" , name , target -> start , target -> size , target -> type , target -> params -> str , _dm_err_last_msg ) ; r = FALSE ; goto out ; } } if ( ! dm_task_set_cookie ( task , & udev_cookie , 0 ) ) { g_set_error ( err , LDM_ERROR , LDM_ERROR_EXTERNAL , "DM_DEVICE_CREATE:<S2SV_blank>dm_task_set_cookie(%08X)<S2SV_blank>failed:<S2SV_blank>%s" , udev_cookie , _dm_err_last_msg ) ; r = FALSE ; goto out ; } if ( ! dm_task_run ( task ) ) { g_set_error_literal ( err , LDM_ERROR , LDM_ERROR_EXTERNAL , _dm_err_last_msg ) ; r = FALSE ; goto out ; } if ( mangled_name ) { char * tmp = dm_task_get_name_mangled ( task ) ; * mangled_name = g_string_new ( tmp ) ; dm_free ( tmp ) ; } out : dm_task_destroy ( task ) ; return r ; } | <S2SV_ModStart> const name , const gchar * const uuid , <S2SV_ModStart> "DM_DEVICE_CREATE:<S2SV_blank>dm_task_set_name(%s)<S2SV_blank>failed:<S2SV_blank>%s" , name , _dm_err_last_msg ) ; r = FALSE ; goto out ; } if ( ! dm_task_set_uuid ( task , uuid ) ) { g_set_error ( err , LDM_ERROR , LDM_ERROR_EXTERNAL , "DM_DEVICE_CREATE:<S2SV_blank>dm_task_set_uuid(%s)<S2SV_blank>failed:<S2SV_blank>%s" , uuid |
3,062 | CWE-000 int main ( int ac , char * * av ) { t_opt opt ; uint8_t * data ; data = NULL ; bzero ( & opt , sizeof ( t_opt ) ) ; get_options ( & opt , & ac , av ) ; if ( opt . options & OPT_FILE ) { data = ( uint8_t * ) map_file ( & opt ) ; <S2SV_StartBug> } else { <S2SV_EndBug> <S2SV_StartBug> data = read_input ( ) ; <S2SV_EndBug> <S2SV_StartBug> opt . size = ( uint32_t ) strlen ( ( char const * ) data ) ; <S2SV_EndBug> } data = fit_data ( data , & opt ) ; return ( hash_this ( data , & opt ) ) ; } | <S2SV_ModStart> opt ) ; if ( data == NULL ) { return ( 1 ) ; } <S2SV_ModStart> ( ) ; if ( data == NULL ) { data = ( uint8_t * ) calloc ( 1 , 1 ) ; opt . size = 0 ; } else { <S2SV_ModStart> data ) ; } |
3,063 | CWE-000 int semanage_direct_mls_enabled ( semanage_handle_t * sh ) { sepol_policydb_t * p = NULL ; int retval ; retval = sepol_policydb_create ( & p ) ; if ( retval < 0 ) goto cleanup ; <S2SV_StartBug> retval = semanage_read_policydb ( sh , p ) ; <S2SV_EndBug> if ( retval < 0 ) goto cleanup ; retval = sepol_policydb_mls_enabled ( p ) ; cleanup : sepol_policydb_free ( p ) ; return retval ; } | <S2SV_ModStart> sh , p , SEMANAGE_STORE_KERNEL |
3,064 | CWE-000 int main ( int argc , char * argv [ ] ) { int pagesize , fd , sync , last_sync , flags ; long write_bytes ; char * temp_buf , * file_path , path_temp [ ] = "/tmp/disk-io-XXXXXX" ; if ( argc < 2 ) { printf ( "pagesize<S2SV_blank>is<S2SV_blank>needed.\\n" ) ; return 0 ; } pagesize = atoi ( argv [ 1 ] ) ; sync = 0 ; last_sync = 0 ; if ( argc > 2 ) sync = atoi ( argv [ 2 ] ) ; if ( argc > 3 ) last_sync = atoi ( argv [ 3 ] ) ; flags = O_CREAT | O_WRONLY ; if ( sync ) flags |= O_SYNC ; temp_buf = malloc ( pagesize ) ; memset ( temp_buf , 48 , pagesize ) ; file_path = mktemp ( path_temp ) ; if ( file_path == NULL ) { printf ( "create<S2SV_blank>temp<S2SV_blank>path<S2SV_blank>failed.\\n" ) ; return 0 ; } <S2SV_StartBug> fd = open ( file_path , flags , 644 ) ; <S2SV_EndBug> if ( fd == - 1 ) { printf ( "open<S2SV_blank>file<S2SV_blank>failed<S2SV_blank>%s.\\n" , strerror ( errno ) ) ; return 0 ; } write_bytes = 0 ; printf ( "write<S2SV_blank>to<S2SV_blank>temp<S2SV_blank>file<S2SV_blank>%s<S2SV_blank>.\\n" , file_path ) ; for ( int i = 0 ; i < test_size / pagesize ; i ++ ) { write_bytes += write ( fd , temp_buf , pagesize ) ; } if ( last_sync ) fsync ( fd ) ; printf ( "successfully<S2SV_blank>write<S2SV_blank>%ld<S2SV_blank>bytes.\\n" , write_bytes ) ; return 0 ; } | <S2SV_ModStart> , flags , 0644 <S2SV_ModEnd> ) ; if |
3,065 | CWE-000 static void bsmp_init_server ( void ) { uint8_t uiloop ; for ( uiloop = 0 ; uiloop < fbp_qtd ; uiloop ++ ) { bsmp_init ( uiloop ) ; <S2SV_StartBug> Init_BSMP_var ( 25 , uiloop , g_ipc_mtoc . ps_module [ uiloop ] . ps_soft_interlock . u8 ) ; <S2SV_EndBug> <S2SV_StartBug> Init_BSMP_var ( 26 , uiloop , g_ipc_mtoc . ps_module [ uiloop ] . ps_hard_interlock . u8 ) ; <S2SV_EndBug> } Init_BSMP_var ( 27 , PS1_ID , PS1_LOAD_CURRENT ) ; Init_BSMP_var ( 28 , PS1_ID , PS1_LOAD_VOLTAGE ) ; Init_BSMP_var ( 29 , PS1_ID , PS1_DCLINK_VOLTAGE ) ; Init_BSMP_var ( 30 , PS1_ID , PS1_TEMPERATURE ) ; Init_BSMP_var ( 27 , PS2_ID , PS2_LOAD_CURRENT ) ; Init_BSMP_var ( 28 , PS2_ID , PS2_LOAD_VOLTAGE ) ; Init_BSMP_var ( 29 , PS2_ID , PS2_DCLINK_VOLTAGE ) ; Init_BSMP_var ( 30 , PS2_ID , PS2_TEMPERATURE ) ; Init_BSMP_var ( 27 , PS3_ID , PS3_LOAD_CURRENT ) ; Init_BSMP_var ( 28 , PS3_ID , PS3_LOAD_VOLTAGE ) ; Init_BSMP_var ( 29 , PS3_ID , PS3_DCLINK_VOLTAGE ) ; Init_BSMP_var ( 30 , PS3_ID , PS3_TEMPERATURE ) ; Init_BSMP_var ( 27 , PS4_ID , PS4_LOAD_CURRENT ) ; Init_BSMP_var ( 28 , PS4_ID , PS4_LOAD_VOLTAGE ) ; Init_BSMP_var ( 29 , PS4_ID , PS4_DCLINK_VOLTAGE ) ; Init_BSMP_var ( 30 , PS4_ID , PS4_TEMPERATURE ) ; } | <S2SV_ModStart> , uiloop , g_ipc_ctom <S2SV_ModEnd> . ps_module [ <S2SV_ModStart> , uiloop , g_ipc_ctom <S2SV_ModEnd> . ps_module [ |
3,066 | CWE-000 <S2SV_StartBug> int startGame ( ) <S2SV_EndBug> { int fixedCells ; Cell * * generatedBoard ; Cell * * userBoard ; <S2SV_StartBug> int solveable ; <S2SV_EndBug> fixedCells = initialization ( ) ; if ( fixedCells == - 1 ) { printf ( "Exiting...\\n" ) ; exit ( 0 ) ; } generatedBoard = init ( BOARDSIZE ) ; solveable = randBacktracking ( 9 , generatedBoard ) ; userBoard = copyBoard ( generatedBoard , BOARDSIZE ) ; initUserBoard ( userBoard , fixedCells , BOARDSIZE ) ; <S2SV_StartBug> printBoard ( userBoard ) ; <S2SV_EndBug> read ( generatedBoard , userBoard ) ; return solveable ; } | <S2SV_ModStart> int startGame ( int n , int m <S2SV_ModStart> userBoard ; int N ; int solveable ; N = n * m <S2SV_ModEnd> ; fixedCells = <S2SV_ModStart> printBoard ( userBoard , N , n , m |
3,067 | CWE-000 static void poll_cq ( PVRDMADev * dev , struct ibv_cq * ibcq , bool one_poll ) { PCIDevice * pci_dev = PCI_DEVICE ( dev ) ; int i , j , ne ; BackendCtx * sctx ; struct ibv_wc wc [ 2 ] ; pr_dbg ( "Entering<S2SV_blank>poll_cq<S2SV_blank>loop<S2SV_blank>on<S2SV_blank>cq<S2SV_blank>%p\\n" , ibcq ) ; do { ne = ibv_poll_cq ( ibcq , 2 , wc ) ; if ( ne == 0 && one_poll ) { pr_dbg ( "CQ<S2SV_blank>is<S2SV_blank>empty\\n" ) ; return ; } } while ( ne < 0 ) ; pr_dbg ( "Got<S2SV_blank>%d<S2SV_blank>completion(s)<S2SV_blank>from<S2SV_blank>cq<S2SV_blank>%p\\n" , ne , ibcq ) ; for ( i = 0 ; i < ne ; ++ i ) { <S2SV_StartBug> pr_dbg ( "req_id=%ld\\n" , wc [ i ] . wr_id ) ; <S2SV_EndBug> pr_dbg ( "status=%d\\n" , wc [ i ] . status ) ; sctx = rm_get_cqe_ctx ( dev , wc [ i ] . wr_id ) ; if ( unlikely ( ! sctx ) ) { <S2SV_StartBug> pr_err ( "Fail<S2SV_blank>to<S2SV_blank>find<S2SV_blank>ctx<S2SV_blank>for<S2SV_blank>req<S2SV_blank>%ld\\n" , wc [ i ] . wr_id ) ; <S2SV_EndBug> continue ; } pr_dbg ( "Processing<S2SV_blank>%s<S2SV_blank>CQE\\n" , sctx -> is_tx_req ? "send" : "recv" ) ; for ( j = 0 ; j < sctx -> req . num_sge ; j ++ ) { pvrdma_pci_dma_unmap ( pci_dev , ( void * ) ( long ) sctx -> req . sge [ j ] . addr , sctx -> req . sge [ j ] . length ) ; } comp_handler ( wc [ i ] . status , wc [ i ] . vendor_err , sctx -> up_ctx ) ; rm_dealloc_cqe_ctx ( dev , wc [ i ] . wr_id ) ; free ( sctx ) ; } } | <S2SV_ModStart> { pr_dbg ( "req_id=%lld\\n" <S2SV_ModEnd> , wc [ <S2SV_ModStart> { pr_err ( "Fail<S2SV_blank>to<S2SV_blank>find<S2SV_blank>ctx<S2SV_blank>for<S2SV_blank>req<S2SV_blank>%lld\\n" <S2SV_ModEnd> , wc [ |
3,068 | CWE-000 int rxm_endpoint ( struct fid_domain * domain , struct fi_info * info , struct fid_ep * * ep_fid , void * context ) { struct util_domain * util_domain ; struct rxm_ep * rxm_ep ; int ret ; rxm_ep = calloc ( 1 , sizeof ( * rxm_ep ) ) ; if ( ! rxm_ep ) return - FI_ENOMEM ; rxm_ep -> rxm_info = fi_dupinfo ( info ) ; if ( ! rxm_ep -> rxm_info ) { ret = - FI_ENOMEM ; goto err1 ; } if ( ! fi_param_get_int ( & rxm_prov , "comp_per_progress" , ( int * ) & rxm_ep -> comp_per_progress ) ) { ret = ofi_endpoint_init ( domain , & rxm_util_prov , info , & rxm_ep -> util_ep , context , & rxm_ep_progress_multi ) ; } else { rxm_ep -> comp_per_progress = 1 ; ret = ofi_endpoint_init ( domain , & rxm_util_prov , info , & rxm_ep -> util_ep , context , & rxm_ep_progress_one ) ; if ( ret ) goto err1 ; } if ( ret ) goto err1 ; util_domain = container_of ( domain , struct util_domain , domain_fid ) ; <S2SV_StartBug> ret = rxm_ep_msg_res_open ( info , util_domain , rxm_ep ) ; <S2SV_EndBug> if ( ret ) goto err2 ; rxm_ep -> msg_mr_local = OFI_CHECK_MR_LOCAL ( rxm_ep -> msg_info ) ; rxm_ep -> rxm_mr_local = OFI_CHECK_MR_LOCAL ( rxm_ep -> rxm_info ) ; rxm_ep -> min_multi_recv_size = ( ( rxm_ep -> util_ep . rx_op_flags & FI_MULTI_RECV ) ? rxm_ep -> rxm_info -> tx_attr -> inject_size : 0 ) ; ret = rxm_ep_txrx_res_open ( rxm_ep ) ; if ( ret ) goto err3 ; * ep_fid = & rxm_ep -> util_ep . ep_fid ; ( * ep_fid ) -> fid . ops = & rxm_ep_fi_ops ; ( * ep_fid ) -> ops = & rxm_ops_ep ; ( * ep_fid ) -> cm = & rxm_ops_cm ; ( * ep_fid ) -> msg = & rxm_ops_msg ; ( * ep_fid ) -> tagged = & rxm_ops_tagged ; ( * ep_fid ) -> rma = & rxm_ops_rma ; return 0 ; err3 : rxm_ep_msg_res_close ( rxm_ep ) ; err2 : ofi_endpoint_close ( & rxm_ep -> util_ep ) ; err1 : if ( rxm_ep -> rxm_info ) fi_freeinfo ( rxm_ep -> rxm_info ) ; free ( rxm_ep ) ; return ret ; } | <S2SV_ModStart> = rxm_ep_msg_res_open ( <S2SV_ModEnd> util_domain , rxm_ep |
3,069 | CWE-000 CmdFunction getCommand ( char * cmd ) { CmdFunction func ; <S2SV_StartBug> if ( ! strcmp ( cmd , "rotate" ) ) <S2SV_EndBug> { func = rotate ; } <S2SV_StartBug> else if ( ! strcmp ( cmd , "move" ) ) <S2SV_EndBug> { func = move ; } <S2SV_StartBug> else if ( ! strcmp ( cmd , "draw" ) ) <S2SV_EndBug> { func = draw ; } <S2SV_StartBug> else if ( ! strcmp ( cmd , "fg" ) ) <S2SV_EndBug> { func = fg ; } <S2SV_StartBug> else if ( ! strcmp ( cmd , "bg" ) ) <S2SV_EndBug> { func = bg ; } <S2SV_StartBug> else if ( ! strcmp ( cmd , "pattern" ) ) <S2SV_EndBug> { func = pattern ; } else { func = NULL ; } return func ; } | <S2SV_ModStart> CmdFunction func ; uppercase ( cmd ) ; <S2SV_ModStart> ( cmd , "ROTATE" <S2SV_ModEnd> ) ) { <S2SV_ModStart> ( cmd , "MOVE" <S2SV_ModEnd> ) ) { <S2SV_ModStart> ( cmd , "DRAW" <S2SV_ModEnd> ) ) { <S2SV_ModStart> ( cmd , "FG" <S2SV_ModEnd> ) ) { <S2SV_ModStart> ( cmd , "BG" <S2SV_ModEnd> ) ) { <S2SV_ModStart> ( cmd , "PATTERN" <S2SV_ModEnd> ) ) { |
3,070 | CWE-000 void performer_init ( ) { instrument_init ( ) ; performer = ( Performer ) { . super = initObject ( ) , . call = NULL , . state = 0 , . position = 0 , . eighths_delay = 0 , <S2SV_StartBug> . period = MSEC ( ( unsigned int ) 60000 / ( 4 * 120 ) ) , <S2SV_EndBug> . key = 0 , . volume = 15 } ; performer . next . period = performer . period ; performer . next . key = performer . key ; } | <S2SV_ModStart> . period = SEC ( 1 ) <S2SV_ModEnd> / ( 4 <S2SV_ModStart> 4 * 120 <S2SV_ModEnd> ) , . |
3,071 | CWE-000 void getMlvRawFrameFloat ( mlvObject_t * video , uint64_t frameIndex , float * outputFrame ) { int bitdepth = video -> RAWI . raw_info . bits_per_pixel ; int width = video -> RAWI . xRes ; int height = video -> RAWI . yRes ; int pixels_count = width * height ; int raw_frame_size = ( width * height * bitdepth ) / 8 ; int unpacked_frame_size = width * height * sizeof ( uint16_t ) ; uint8_t * raw_frame = ( uint8_t * ) malloc ( raw_frame_size ) ; uint16_t * unpacked_frame = ( uint16_t * ) malloc ( unpacked_frame_size ) ; file_set_pos ( video -> file , video -> frame_offsets [ frameIndex ] , SEEK_SET ) ; if ( video -> MLVI . videoClass & MLV_VIDEO_CLASS_FLAG_LJ92 ) { int raw_data_size = video -> frame_sizes [ frameIndex ] ; fread ( raw_frame , sizeof ( uint8_t ) , raw_data_size , video -> file ) ; int components = 1 ; lj92 decoder_object ; lj92_open ( & decoder_object , raw_frame , raw_data_size , & width , & height , & bitdepth , & components ) ; lj92_decode ( decoder_object , unpacked_frame , 1 , 0 , NULL , 0 ) ; lj92_close ( decoder_object ) ; } else { fread ( raw_frame , sizeof ( uint8_t ) , raw_frame_size , video -> file ) ; uint32_t mask = ( 1 << bitdepth ) - 1 ; for ( int i = 0 ; i < pixels_count ; ++ i ) { uint32_t bits_offset = i * bitdepth ; uint32_t bits_address = bits_offset / 16 ; uint32_t bits_shift = bits_offset % 16 ; uint32_t rotate_value = 16 + ( ( 32 - bitdepth ) - bits_shift ) ; uint32_t uncorrected_data = * ( ( uint32_t * ) & ( ( uint16_t * ) raw_frame ) [ bits_address ] ) ; uint32_t data = ROR32 ( uncorrected_data , rotate_value ) ; unpacked_frame [ i ] = ( uint16_t ) ( data & mask ) ; } } applyLLRawProcObject ( video , unpacked_frame , unpacked_frame_size ) ; int shift_val = 16 - bitdepth ; <S2SV_StartBug> if ( video -> llrawproc -> dual_iso == 1 && video -> llrawproc -> is_dual_iso ) shift_val = 0 ; <S2SV_EndBug> for ( int i = 0 ; i < pixels_count ; ++ i ) { outputFrame [ i ] = ( float ) ( unpacked_frame [ i ] << shift_val ) ; } free ( unpacked_frame ) ; free ( raw_frame ) ; } | <S2SV_ModStart> -> llrawproc -> fix_raw && video -> llrawproc -> |
3,072 | CWE-000 static int ext2_link ( struct vop_link_args * ap ) { struct vnode * vp = ap -> a_vp ; struct vnode * tdvp = ap -> a_tdvp ; struct componentname * cnp = ap -> a_cnp ; struct inode * ip ; int error ; # ifdef INVARIANTS if ( ( cnp -> cn_flags & HASBUF ) == 0 ) panic ( "ext2_link:<S2SV_blank>no<S2SV_blank>name" ) ; # endif ip = VTOI ( vp ) ; <S2SV_StartBug> if ( ( nlink_t ) ip -> i_nlink >= ext2_max_nlink ( ip ) ) { <S2SV_EndBug> error = EMLINK ; goto out ; } if ( ip -> i_flags & ( IMMUTABLE | APPEND ) ) { error = EPERM ; goto out ; } ip -> i_nlink ++ ; ip -> i_flag |= IN_CHANGE ; error = ext2_update ( vp , ! DOINGASYNC ( vp ) ) ; if ( ! error ) error = ext2_direnter ( ip , tdvp , cnp ) ; if ( error ) { ip -> i_nlink -- ; ip -> i_flag |= IN_CHANGE ; } out : return ( error ) ; } | <S2SV_ModStart> -> i_nlink >= EXT4_LINK_MAX <S2SV_ModEnd> ) { error |
3,073 | CWE-000 <S2SV_StartBug> void <S2SV_EndBug> our_write ( int fd , const void * buffer , unsigned size ) { unsigned cnt = 0 ; <S2SV_StartBug> lock_acquire ( & syscall_lock ) ; <S2SV_EndBug> putbuf ( buffer , size ) ; <S2SV_StartBug> lock_release ( & syscall_lock ) ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> int <S2SV_ModEnd> our_write ( int <S2SV_ModStart> = 0 ; if ( fd == 1 ) { <S2SV_ModEnd> putbuf ( buffer <S2SV_ModStart> size ) ; return size ; } else return size <S2SV_ModEnd> ; } <S2SV_null> |
3,074 | CWE-000 static CharDriverState * qemu_chr_open_msmouse ( const char * id , ChardevBackend * backend , <S2SV_StartBug> ChardevReturn * ret , <S2SV_EndBug> Error * * errp ) { ChardevCommon * common = backend -> u . msmouse . data ; MouseState * mouse ; CharDriverState * chr ; chr = qemu_chr_alloc ( common , errp ) ; if ( ! chr ) { return NULL ; } chr -> chr_write = msmouse_chr_write ; <S2SV_StartBug> chr -> chr_close = msmouse_chr_close ; <S2SV_EndBug> chr -> chr_accept_input = msmouse_chr_accept_input ; <S2SV_StartBug> chr -> explicit_be_open = true ; <S2SV_EndBug> mouse = g_new0 ( MouseState , 1 ) ; mouse -> hs = qemu_input_handler_register ( ( DeviceState * ) mouse , & msmouse_handler ) ; mouse -> chr = chr ; chr -> opaque = mouse ; return chr ; } | <S2SV_ModStart> ChardevReturn * ret , bool * be_opened <S2SV_ModStart> ; chr -> chr_free = msmouse_chr_free <S2SV_ModEnd> ; chr -> <S2SV_ModStart> = msmouse_chr_accept_input ; * be_opened = false <S2SV_ModEnd> ; mouse = |
3,075 | CWE-000 static bool aarch64_vectorize_vec_perm_const_ok ( machine_mode vmode , vec_perm_indices sel ) { struct expand_vec_perm_d d ; unsigned int i , nelt , which ; bool ret ; d . vmode = vmode ; d . testing_p = true ; d . perm . safe_splice ( sel ) ; nelt = sel . length ( ) ; for ( i = which = 0 ; i < nelt ; ++ i ) { <S2SV_StartBug> unsigned char e = d . perm [ i ] ; <S2SV_EndBug> gcc_assert ( e < 2 * nelt ) ; which |= ( e < nelt ? 1 : 2 ) ; } if ( which == 2 ) for ( i = 0 ; i < nelt ; ++ i ) d . perm [ i ] -= nelt ; d . one_vector_p = ( which != 3 ) ; d . target = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + 1 ) ; d . op1 = d . op0 = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + 2 ) ; if ( ! d . one_vector_p ) d . op1 = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + 3 ) ; start_sequence ( ) ; ret = aarch64_expand_vec_perm_const_1 ( & d ) ; end_sequence ( ) ; return ret ; } | <S2SV_ModStart> ) { unsigned int <S2SV_ModEnd> e = d |
3,076 | CWE-000 void mp_archive_free ( struct mp_archive * mpa ) { mp_archive_close ( mpa ) ; <S2SV_StartBug> talloc_free ( mpa ) ; <S2SV_EndBug> } | <S2SV_ModStart> mpa ) ; if ( mpa && mpa -> locale ) freelocale ( mpa -> locale ) ; |
3,077 | CWE-000 static void Target_mouseDown ( unsigned int buttonNumber , float x , float y ) { Vector2f transformedPosition ; <S2SV_StartBug> transformedPosition = transformMousePosition_signedCenter ( VECTOR2f ( x , y ) , viewportWidth , viewportHeight , 1.0f / ( 0.0625f * scale ) ) ; <S2SV_EndBug> lastDragX = transformedPosition . x ; lastDragY = transformedPosition . y ; if ( clipping && controlKeyDown ) { if ( shiftKeyDown ) { draggingClipBounds2 = true ; } else { draggingClipBounds1 = true ; } } else if ( shiftKeyDown ) { draggingTextFlow = true ; } else { <S2SV_StartBug> queryIndexAtPosition ( x , y ) ; <S2SV_EndBug> } # if defined ( STEM_PLATFORM_iphonesimulator ) || defined ( STEM_PLATFORM_iphoneos ) if ( buttonNumber > 0 ) { EAGLShell_showKeyboard ( ) ; } # endif } | <S2SV_ModStart> viewportHeight , 1.0f <S2SV_ModEnd> ) ; lastDragX <S2SV_ModStart> { queryIndexAtPosition ( transformedPosition . x , transformedPosition . <S2SV_ModEnd> y ) ; |
3,078 | CWE-000 static inline bool rt2800usb_entry_txstatus_timeout ( struct queue_entry * entry ) { bool tout ; if ( ! test_bit ( ENTRY_DATA_STATUS_PENDING , & entry -> flags ) ) return false ; tout = time_after ( jiffies , entry -> last_action + msecs_to_jiffies ( 500 ) ) ; if ( unlikely ( tout ) ) <S2SV_StartBug> rt2x00_warn ( entry -> queue -> rt2x00dev , <S2SV_EndBug> "TX<S2SV_blank>status<S2SV_blank>timeout<S2SV_blank>for<S2SV_blank>entry<S2SV_blank>%d<S2SV_blank>in<S2SV_blank>queue<S2SV_blank>%d\\n" , entry -> entry_idx , entry -> queue -> qid ) ; return tout ; } | <S2SV_ModStart> tout ) ) rt2x00_dbg <S2SV_ModEnd> ( entry -> |
3,079 | CWE-000 int input_countObjects ( SWMM_Project * sp ) { char line [ MAXLINE + 1 ] ; char wLine [ MAXLINE + 1 ] ; char * tok ; int sect = - 1 , newsect ; int errcode = 0 ; int errsum = 0 ; int i ; long lineCount = 0 ; <S2SV_StartBug> TFile finp = sp -> Finp ; <S2SV_EndBug> if ( ErrorCode ) return ErrorCode ; error_setInpError ( 0 , "" ) ; for ( i = 0 ; i < MAX_OBJ_TYPES ; i ++ ) Nobjects [ i ] = 0 ; for ( i = 0 ; i < MAX_NODE_TYPES ; i ++ ) Nnodes [ i ] = 0 ; for ( i = 0 ; i < MAX_LINK_TYPES ; i ++ ) Nlinks [ i ] = 0 ; while ( fgets ( line , MAXLINE , finp . file ) != NULL ) { lineCount ++ ; strcpy ( wLine , line ) ; tok = strtok ( wLine , SEPSTR ) ; if ( tok == NULL ) continue ; if ( * tok == ';' ) continue ; if ( * tok == '[' ) { newsect = findmatch ( tok , SectWords ) ; if ( newsect >= 0 ) { sect = newsect ; continue ; } else { sect = - 1 ; errcode = ERR_KEYWORD ; } } if ( sect == s_OPTION ) errcode = readOption ( line ) ; else if ( sect >= 0 ) errcode = addObject ( sect , tok ) ; if ( errcode ) { report_writeInputErrorMsg ( sp , errcode , sect , line , lineCount ) ; errsum ++ ; if ( errsum >= MAXERRS ) break ; } } if ( errsum > 0 ) ErrorCode = ERR_INPUT ; return ErrorCode ; } | <S2SV_ModStart> = 0 ; if ( ErrorCode ) return ErrorCode ; error_setInpError ( 0 , "" ) ; for ( i = 0 ; i < MAX_OBJ_TYPES ; i ++ ) Nobjects [ i ] = 0 ; for ( i = 0 ; i < MAX_NODE_TYPES ; i ++ ) Nnodes [ i ] = 0 ; for ( i = 0 ; i < MAX_LINK_TYPES ; i ++ ) Nlinks [ i ] = 0 ; while ( fgets ( line , MAXLINE , <S2SV_ModEnd> sp -> Finp <S2SV_ModStart> sp -> Finp <S2SV_ModEnd> . file ) |
3,080 | CWE-000 <S2SV_StartBug> Elf64_Ehdr * elf_read_hdr ( Elf64_Ehdr * hdr ) { <S2SV_EndBug> uint32_t hdr_size ; uint8_t MAGBUF [ 4 ] = { 0x7f , 0x45 , 0x4c , 0x46 } ; int fd ; <S2SV_StartBug> if ( ! hdr ) { <S2SV_EndBug> <S2SV_StartBug> fprintf ( stderr , "[!]<S2SV_blank>Error<S2SV_blank>(elf_read_hdr):<S2SV_blank>null<S2SV_blank>argument\\n" ) ; <S2SV_EndBug> exit ( EXIT_FAILURE ) ; } if ( ! ei_table ) { fprintf ( stderr , "[!]<S2SV_blank>Error<S2SV_blank>(elf_read_hdr):<S2SV_blank>ei_table<S2SV_blank>has<S2SV_blank>not<S2SV_blank>been<S2SV_blank>initialized.\\n" ) ; return NULL ; } <S2SV_StartBug> fd = ei_table -> fd ; <S2SV_EndBug> hdr_size = sizeof ( Elf64_Ehdr ) ; memset ( hdr , 0 , hdr_size ) ; if ( ( read ( fd , hdr , hdr_size ) < hdr_size ) ) { printf ( "[!]<S2SV_blank>Error<S2SV_blank>reading<S2SV_blank>elf<S2SV_blank>header.\\n" ) ; exit ( EXIT_FAILURE ) ; } if ( ( memcmp ( MAGBUF , hdr -> e_ident , 4 ) ) != 0 ) { puts ( "[!]<S2SV_blank>Error:<S2SV_blank>Incorrect<S2SV_blank>ELF<S2SV_blank>magic<S2SV_blank>number" ) ; exit ( EXIT_FAILURE ) ; } if ( hdr -> e_version == 0 ) printf ( "[?]<S2SV_blank>Warning:<S2SV_blank>ELF<S2SV_blank>version<S2SV_blank>is<S2SV_blank>not<S2SV_blank>current<S2SV_blank>(e_version:<S2SV_blank>%d).\\n" , hdr -> e_version ) ; switch ( hdr -> e_machine ) { case EM_NONE : puts ( "EM_NONE:<S2SV_blank>no<S2SV_blank>machine" ) ; break ; case EM_M32 : puts ( "EM_M32:<S2SV_blank>AT&T<S2SV_blank>WE<S2SV_blank>32100" ) ; break ; case EM_SPARC : puts ( "EM_SPARC:<S2SV_blank>SPARC" ) ; break ; case EM_386 : puts ( "EM_386:<S2SV_blank>Intel<S2SV_blank>80386" ) ; break ; case EM_68K : puts ( "EM_68K:<S2SV_blank>Motorola<S2SV_blank>68000" ) ; break ; case EM_88K : puts ( "EM_88K:<S2SV_blank>Motorola<S2SV_blank>88000" ) ; break ; case EM_860 : puts ( "EM_860:<S2SV_blank>Intel<S2SV_blank>80860" ) ; break ; case EM_MIPS : puts ( "EM_MIPS:<S2SV_blank>MIPS<S2SV_blank>RS3000" ) ; break ; case EM_PARISC : puts ( "EM_PARISC:<S2SV_blank>HP/PA" ) ; break ; case EM_SPARC32PLUS : puts ( "EM_SPARC32PLUS:<S2SV_blank>SPARC<S2SV_blank>with<S2SV_blank>enhanced<S2SV_blank>instruction<S2SV_blank>set" ) ; break ; case EM_PPC : puts ( "EM_PPC:<S2SV_blank>PowerPC" ) ; break ; case EM_PPC64 : puts ( "EM_PPC64:<S2SV_blank>PowerPC<S2SV_blank>64-bit" ) ; break ; case EM_S390 : puts ( "EM_S390:<S2SV_blank>IBM<S2SV_blank>S/390" ) ; break ; case EM_ARM : puts ( "EM_ARM:<S2SV_blank>Advanced<S2SV_blank>RISC<S2SV_blank>Machines" ) ; break ; case EM_SH : puts ( "EM_SH:<S2SV_blank>Renesas<S2SV_blank>SuperH" ) ; break ; case EM_SPARCV9 : puts ( "EM_SPARCV9:<S2SV_blank>SPARC<S2SV_blank>v9<S2SV_blank>64-bit" ) ; break ; case EM_IA_64 : puts ( "EM_IA_64:<S2SV_blank>Intel<S2SV_blank>Itanium" ) ; break ; case EM_X86_64 : puts ( "EM_X86_64:<S2SV_blank>AMD<S2SV_blank>x86-64" ) ; break ; case EM_VAX : puts ( "EM_VAX:<S2SV_blank>DEC<S2SV_blank>Vax" ) ; break ; default : fprintf ( stderr , "[!]<S2SV_blank>Error<S2SV_blank>(elf_read_dr):<S2SV_blank>invalid<S2SV_blank>e_machine<S2SV_blank>value<S2SV_blank>%d\\n" , hdr -> e_machine ) ; exit ( EXIT_FAILURE ) ; } switch ( hdr -> e_ident [ EI_CLASS ] ) { case ELFCLASSNONE : puts ( "ELFCLASSNONE:<S2SV_blank>invalid<S2SV_blank>class!" ) ; break ; case ELFCLASS32 : puts ( "ELFCLASS32:<S2SV_blank>32-bit<S2SV_blank>object" ) ; break ; case ELFCLASS64 : puts ( "ELFCLASS64:<S2SV_blank>64-bit<S2SV_blank>object" ) ; break ; default : fprintf ( stderr , "[!]<S2SV_blank>Error<S2SV_blank>(elf_read_dr):<S2SV_blank>invalid<S2SV_blank>ELFCLASS<S2SV_blank>value<S2SV_blank>%d\\n" , hdr -> e_ident [ EI_CLASS ] ) ; exit ( EXIT_FAILURE ) ; } switch ( hdr -> e_type ) { case ET_NONE : puts ( "ET_NONE:<S2SV_blank>No<S2SV_blank>file<S2SV_blank>type" ) ; break ; case ET_REL : puts ( "ET_REL:<S2SV_blank>Relocatable<S2SV_blank>file" ) ; break ; case ET_EXEC : puts ( "ET_EXEC:<S2SV_blank>Executable<S2SV_blank>file" ) ; break ; case ET_DYN : puts ( "ET_DYN:<S2SV_blank>Shared<S2SV_blank>object<S2SV_blank>file" ) ; break ; case ET_CORE : puts ( "ET_CORE:<S2SV_blank>Core<S2SV_blank>file" ) ; break ; case ET_LOPROC : puts ( "ET_LOPROC:<S2SV_blank>0xff00<S2SV_blank>(Processor<S2SV_blank>Specific)" ) ; break ; case ET_HIPROC : puts ( "ET_HIPROC:<S2SV_blank>0xffff<S2SV_blank>(Processor<S2SV_blank>Specific)" ) ; break ; default : fprintf ( stderr , "[!]<S2SV_blank>Error<S2SV_blank>(elf_read_dr):<S2SV_blank>invalid<S2SV_blank>ELFTYPE<S2SV_blank>value<S2SV_blank>%d\\n" , hdr -> e_type ) ; exit ( EXIT_FAILURE ) ; } switch ( hdr -> e_ident [ EI_DATA ] ) { case ELFDATANONE : puts ( "ELFDATANONE:<S2SV_blank>invalid<S2SV_blank>data<S2SV_blank>encoding" ) ; break ; case ELFDATA2LSB : puts ( "ELFDATA2LSB:<S2SV_blank>2\'s<S2SV_blank>compliment,<S2SV_blank>Little-endian" ) ; break ; case ELFDATA2MSB : puts ( "ELFDATA2MSB:<S2SV_blank>2\'s<S2SV_blank>compliment,<S2SV_blank>Big-endian" ) ; break ; default : fprintf ( stderr , "[!]<S2SV_blank>Error<S2SV_blank>(elf_read_dr):<S2SV_blank>invalid<S2SV_blank>ELFDATA<S2SV_blank>value<S2SV_blank>%d\\n" , hdr -> e_ident [ EI_DATA ] ) ; exit ( EXIT_FAILURE ) ; } if ( hdr -> e_entry != 0 ) { printf ( "Entry<S2SV_blank>Point:\\t" ) ; if ( hdr -> e_ident [ EI_CLASS ] == ELFCLASS32 ) printf ( "0x%08x\\n" , hdr -> e_entry ) ; else if ( hdr -> e_ident [ EI_CLASS ] == ELFCLASS64 ) printf ( "%p\\n" , hdr -> e_entry ) ; } else { printf ( "[?]<S2SV_blank>Warning<S2SV_blank>(elf_read_hdr):<S2SV_blank>Null<S2SV_blank>entry-point<S2SV_blank>specified<S2SV_blank>in<S2SV_blank>ELF<S2SV_blank>header\\n" ) ; } return hdr ; } | <S2SV_ModStart> * elf_read_hdr ( elf_info * _ei_table ) { <S2SV_ModStart> Elf64_Ehdr * hdr ; <S2SV_ModEnd> uint32_t hdr_size ; <S2SV_ModStart> if ( ! _ei_table <S2SV_ModEnd> ) { fprintf <S2SV_ModStart> ( stderr , "[!]<S2SV_blank>Error<S2SV_blank>(elf_read_hdr):<S2SV_blank>null<S2SV_blank>argument.\\n" <S2SV_ModEnd> ) ; return <S2SV_ModStart> NULL ; } hdr = _ei_table -> hdr ; fd = _ei_table <S2SV_ModEnd> -> fd ; <S2SV_ModStart> -> fd ; if ( ! hdr ) { fprintf ( stderr , "[!]<S2SV_blank>Error<S2SV_blank>(elf_read_hdr):<S2SV_blank>null<S2SV_blank>ei_table<S2SV_blank>hdr.\\n" ) ; exit ( EXIT_FAILURE ) ; } |
3,081 | CWE-000 static void buttons_update ( void ) { const char * lang = "XX" ; lang_pref_t lang_pref ; bool_t disco_when_done = B_FALSE ; bool_t show_dev_menu = B_FALSE ; const char * radio_dev = "" , * sound_dev = "" ; ( void ) conf_get_str ( bp_conf , "lang" , & lang ) ; ( void ) conf_get_b ( bp_conf , "disco_when_done" , & disco_when_done ) ; ( void ) conf_get_b ( bp_conf , "show_dev_menu" , & show_dev_menu ) ; ( void ) conf_get_str ( bp_conf , "radio_device" , & radio_dev ) ; ( void ) conf_get_str ( bp_conf , "sound_device" , & sound_dev ) ; # define SET_LANG_BTN ( btn , l ) ( XPSetWidgetProperty ( buttons . btn , xpProperty_ButtonState , strcmp ( lang , l ) == 0 ) ) SET_LANG_BTN ( chinese , "cn" ) ; SET_LANG_BTN ( german , "de" ) ; SET_LANG_BTN ( english , "en" ) ; SET_LANG_BTN ( french , "fr" ) ; SET_LANG_BTN ( portuguese , "pt" ) ; SET_LANG_BTN ( spanish , "es" ) ; SET_LANG_BTN ( russian , "ru" ) ; SET_LANG_BTN ( xplang , "XX" ) ; # undef SET_LANG_BTN if ( ! conf_get_i ( bp_conf , "lang_pref" , ( int * ) & lang_pref ) ) lang_pref = LANG_PREF_MATCH_REAL ; XPSetWidgetProperty ( buttons . lang_pref_match_real , xpProperty_ButtonState , lang_pref == LANG_PREF_MATCH_REAL ) ; XPSetWidgetProperty ( buttons . lang_pref_native , xpProperty_ButtonState , lang_pref == LANG_PREF_NATIVE ) ; XPSetWidgetProperty ( buttons . lang_pref_match_english , xpProperty_ButtonState , lang_pref == LANG_PREF_MATCH_ENGLISH ) ; XPSetWidgetProperty ( buttons . disco_when_done , xpProperty_ButtonState , disco_when_done ) ; XPSetWidgetProperty ( buttons . show_dev_menu , xpProperty_ButtonState , show_dev_menu ) ; <S2SV_StartBug> XPSetWidgetProperty ( buttons . radio_boxes [ 0 ] , xpProperty_ButtonState , <S2SV_EndBug> * radio_dev == 0 ) ; for ( size_t i = 0 ; i < buttons . num_radio_devs ; i ++ ) { XPSetWidgetProperty ( buttons . radio_boxes [ i + 1 ] , xpProperty_ButtonState , strcmp ( radio_dev , buttons . radio_devs [ i ] ) == 0 ) ; } XPSetWidgetProperty ( buttons . sound_boxes [ 0 ] , xpProperty_ButtonState , * sound_dev == 0 ) ; for ( size_t i = 0 ; i < buttons . num_sound_devs ; i ++ ) { XPSetWidgetProperty ( buttons . sound_boxes [ i + 1 ] , xpProperty_ButtonState , strcmp ( sound_dev , buttons . sound_devs [ i ] ) == 0 ) ; } } | <S2SV_ModStart> show_dev_menu ) ; if ( bp_xp_ver >= 11000 ) { bool_t dont_hide = B_FALSE ; ( void ) conf_get_b ( bp_conf , "dont_hide_xp11_tug" , & dont_hide ) ; XPSetWidgetProperty ( buttons . hide_xp11_tug , xpProperty_ButtonState , ! dont_hide ) ; } |
3,082 | CWE-000 static int xcsi2rxss_set_format ( struct v4l2_subdev * sd , struct v4l2_subdev_pad_config * cfg , struct v4l2_subdev_format * fmt ) { struct v4l2_mbus_framefmt * __format ; struct xcsi2rxss_state * xcsi2rxss = to_xcsi2rxssstate ( sd ) ; struct xcsi2rxss_core * core = & xcsi2rxss -> core ; u32 code ; printk ( KERN_ERR "sjb:<S2SV_blank>xcsi2rxss:<S2SV_blank>%s:<S2SV_blank>entered\\n" , __func__ ) ; mutex_lock ( & xcsi2rxss -> lock ) ; __format = __xcsi2rxss_get_pad_format ( xcsi2rxss , cfg , fmt -> pad , fmt -> which ) ; code = __format -> code ; if ( ( ( fmt -> format . code == MEDIA_BUS_FMT_SBGGR8_1X8 ) || ( fmt -> format . code == MEDIA_BUS_FMT_SGBRG8_1X8 ) || ( fmt -> format . code == MEDIA_BUS_FMT_SGRBG8_1X8 ) || ( fmt -> format . code == MEDIA_BUS_FMT_SRGGB8_1X8 ) ) || ( ( core -> datatype == MIPI_CSI_DT_RAW_10 ) && ( ( fmt -> format . code == MEDIA_BUS_FMT_SBGGR10_1X10 ) || ( fmt -> format . code == MEDIA_BUS_FMT_SGBRG10_1X10 ) || ( fmt -> format . code == MEDIA_BUS_FMT_SGRBG10_1X10 ) || ( fmt -> format . code == MEDIA_BUS_FMT_SRGGB10_1X10 ) ) ) || ( ( core -> datatype == MIPI_CSI_DT_RAW_12 ) && ( ( fmt -> format . code == MEDIA_BUS_FMT_SBGGR12_1X12 ) || ( fmt -> format . code == MEDIA_BUS_FMT_SGBRG12_1X12 ) || ( fmt -> format . code == MEDIA_BUS_FMT_SGRBG12_1X12 ) || ( fmt -> format . code == MEDIA_BUS_FMT_SRGGB12_1X12 ) ) ) ) * __format = fmt -> format ; else { fmt -> format . code = code ; __format -> code = code ; } __format -> width = clamp_t ( unsigned int , fmt -> format . width , <S2SV_StartBug> XSCALER_MIN_WIDTH , XSCALER_MAX_WIDTH ) ; <S2SV_EndBug> __format -> height = clamp_t ( unsigned int , fmt -> format . height , <S2SV_StartBug> XSCALER_MIN_HEIGHT , XSCALER_MAX_HEIGHT ) ; <S2SV_EndBug> mutex_unlock ( & xcsi2rxss -> lock ) ; return 0 ; } | <S2SV_ModStart> . width , XCSI_MIN_WIDTH , XCSI_MAX_WIDTH <S2SV_ModEnd> ) ; __format <S2SV_ModStart> . height , XCSI_MIN_HEIGHT , XCSI_MAX_HEIGHT <S2SV_ModEnd> ) ; mutex_unlock |
3,083 | CWE-000 <S2SV_StartBug> VALUE <S2SV_EndBug> rb_hash_compare_by_id_p ( VALUE hash ) { if ( ! RHASH ( hash ) -> ntbl ) return Qfalse ; if ( RHASH ( hash ) -> ntbl -> type == & identhash ) { return Qtrue ; } return Qfalse ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> MJIT_FUNC_EXPORTED |
3,084 | CWE-000 static int _set_options ( uint32_t idx , pstd_option_param_t * params , uint32_t nparams , const pstd_option_t * options , uint32_t n , void * args ) { ( void ) nparams ; ( void ) n ; char what = options [ idx ] . short_opt ; context_t * ctx = ( context_t * ) args ; switch ( what ) { <S2SV_StartBug> case 'I' : <S2SV_EndBug> if ( params [ 0 ] . intval < 0 || params [ 0 ] . intval > PATH_MAX / 2 + 1 ) ERROR_RETURN_LOG ( int , "Invalid<S2SV_blank>prefix<S2SV_blank>level<S2SV_blank>%" PRId64 , params [ 0 ] . intval ) ; ctx -> prefix_level = ( uint32_t ) params [ 0 ] . intval ; return 0 ; case 'e' : ctx -> need_extname = 1 ; return 0 ; default : ERROR_RETURN_LOG ( int , "Invalid<S2SV_blank>option<S2SV_blank>%c" , what ) ; } } | <S2SV_ModStart> ) { case 'L' <S2SV_ModEnd> : if ( |
3,085 | CWE-000 static void _monitor_bridges_cb ( NMOvsdb * self , json_t * result , GError * error , gpointer user_data ) { if ( error ) { if ( ! nm_utils_error_is_cancelled ( error , TRUE ) ) { _LOGI ( "%s" , error -> message ) ; ovsdb_disconnect ( self , FALSE ) ; } <S2SV_StartBug> g_clear_error ( & error ) ; <S2SV_EndBug> return ; } ovsdb_got_update ( self , result ) ; } | <S2SV_ModStart> ) ; } <S2SV_ModEnd> return ; } |
3,086 | CWE-000 void memcached_thread_init ( int nthreads , struct event_base * main_base ) { int i ; int power ; <S2SV_StartBug> pthread_mutex_init ( & cache_lock , NULL ) ; <S2SV_EndBug> pthread_mutex_init ( & stats_lock , NULL ) ; pthread_mutex_init ( & worker_hang_lock , NULL ) ; pthread_mutex_init ( & init_lock , NULL ) ; pthread_cond_init ( & init_cond , NULL ) ; pthread_mutex_init ( & cqi_freelist_lock , NULL ) ; cqi_freelist = NULL ; if ( nthreads < 3 ) { power = 10 ; } else if ( nthreads < 4 ) { power = 11 ; } else if ( nthreads < 5 ) { power = 12 ; } else { power = 13 ; } if ( power >= hashpower ) { fprintf ( stderr , "Hash<S2SV_blank>table<S2SV_blank>power<S2SV_blank>size<S2SV_blank>(%d)<S2SV_blank>cannot<S2SV_blank>be<S2SV_blank>equal<S2SV_blank>to<S2SV_blank>or<S2SV_blank>less<S2SV_blank>than<S2SV_blank>item<S2SV_blank>lock<S2SV_blank>table<S2SV_blank>(%d)\\n" , hashpower , power ) ; fprintf ( stderr , "Item<S2SV_blank>lock<S2SV_blank>table<S2SV_blank>grows<S2SV_blank>with<S2SV_blank>`-t<S2SV_blank>N`<S2SV_blank>(worker<S2SV_blank>threadcount)\\n" ) ; fprintf ( stderr , "Hash<S2SV_blank>table<S2SV_blank>grows<S2SV_blank>with<S2SV_blank>`-o<S2SV_blank>hashpower=N`<S2SV_blank>\\n" ) ; exit ( 1 ) ; } item_lock_count = hashsize ( power ) ; item_lock_hashpower = power ; item_locks = calloc ( item_lock_count , sizeof ( pthread_mutex_t ) ) ; if ( ! item_locks ) { perror ( "Can\'t<S2SV_blank>allocate<S2SV_blank>item<S2SV_blank>locks" ) ; exit ( 1 ) ; } for ( i = 0 ; i < item_lock_count ; i ++ ) { pthread_mutex_init ( & item_locks [ i ] , NULL ) ; } threads = calloc ( nthreads , sizeof ( LIBEVENT_THREAD ) ) ; if ( ! threads ) { perror ( "Can\'t<S2SV_blank>allocate<S2SV_blank>thread<S2SV_blank>descriptors" ) ; exit ( 1 ) ; } dispatcher_thread . base = main_base ; dispatcher_thread . thread_id = pthread_self ( ) ; for ( i = 0 ; i < nthreads ; i ++ ) { int fds [ 2 ] ; if ( pipe ( fds ) ) { perror ( "Can\'t<S2SV_blank>create<S2SV_blank>notify<S2SV_blank>pipe" ) ; exit ( 1 ) ; } threads [ i ] . notify_receive_fd = fds [ 0 ] ; threads [ i ] . notify_send_fd = fds [ 1 ] ; setup_thread ( & threads [ i ] ) ; stats . reserved_fds += 5 ; } for ( i = 0 ; i < nthreads ; i ++ ) { create_worker ( worker_libevent , & threads [ i ] ) ; } pthread_mutex_lock ( & init_lock ) ; wait_for_thread_registration ( nthreads ) ; pthread_mutex_unlock ( & init_lock ) ; } | <S2SV_ModStart> ( & cache_lock <S2SV_ModEnd> , NULL ) |
3,087 | CWE-000 static void replace_args ( int argc , char * argv [ ] ) { int ii ; for ( ii = 1 ; ii < argc ; ii ++ ) { if ( strcasecmp ( argv [ ii ] , "-lrl" ) == 0 ) { argv [ ii ] = "--lrl" ; } else if ( strcasecmp ( argv [ ii ] , "-repopnewlrl" ) == 0 ) { argv [ ii ] = "--repopnewlrl" ; } else if ( strcasecmp ( argv [ ii ] , "-recovertotime" ) == 0 ) { argv [ ii ] = "--recovertotime" ; } else if ( strcasecmp ( argv [ ii ] , "-recovertolsn" ) == 0 ) { argv [ ii ] = "--recovertolsn" ; } else if ( strcasecmp ( argv [ ii ] , "-recovery_lsn" ) == 0 ) { <S2SV_StartBug> argv [ ii ] = "--recovery_lsn" ; <S2SV_EndBug> } else if ( strcasecmp ( argv [ ii ] , "-pidfile" ) == 0 ) { argv [ ii ] = "--pidfile" ; } else if ( strcasecmp ( argv [ ii ] , "-help" ) == 0 ) { argv [ ii ] = "--help" ; return ; } else if ( strcasecmp ( argv [ ii ] , "-create" ) == 0 ) { argv [ ii ] = "--create" ; } else if ( strcasecmp ( argv [ ii ] , "-fullrecovery" ) == 0 ) { argv [ ii ] = "--fullrecovery" ; } } } | <S2SV_ModStart> ii ] = "--recoverylsn" ; } else if ( strcasecmp ( argv [ ii ] , "-recoverylsn" ) == 0 ) { argv [ ii ] = "--recoverylsn" <S2SV_ModEnd> ; } else |
3,088 | CWE-000 int main ( int argc , char * argv [ ] ) { sigset_t signal_mask ; setting = & _setting ; service = & _service ; memset ( service , 0 , sizeof ( * service ) ) ; bolt_parse_options ( argc , argv ) ; if ( setting -> path == NULL || ! bolt_file_exists ( setting -> path ) ) { <S2SV_StartBug> fprintf ( stderr , "Fatal:<S2SV_blank>Image<S2SV_blank>source<S2SV_blank>path<S2SV_blank>must<S2SV_blank>be<S2SV_blank>set<S2SV_blank>" <S2SV_EndBug> "by<S2SV_blank>`path<S2SV_blank>=<S2SV_blank>xxx\'<S2SV_blank>configure<S2SV_blank>entry<S2SV_blank>" "and<S2SV_blank>the<S2SV_blank>path<S2SV_blank>must<S2SV_blank>be<S2SV_blank>exists\\n\\n" ) ; exit ( 1 ) ; } if ( setting -> daemon ) { bolt_daemonize ( ) ; } sigemptyset ( & signal_mask ) ; sigaddset ( & signal_mask , SIGPIPE ) ; pthread_sigmask ( SIG_BLOCK , & signal_mask , NULL ) ; if ( bolt_init_log ( setting -> logfile , setting -> logmark ) == - 1 || bolt_init_service ( ) == - 1 || bolt_init_connections ( ) == - 1 || bolt_init_workers ( setting -> workers ) == - 1 ) { exit ( 1 ) ; } bolt_clock_handler ( 0 , 0 , 0 ) ; event_base_dispatch ( service -> ebase ) ; bolt_destroy_log ( ) ; exit ( 0 ) ; } | <S2SV_ModStart> ( stderr , "Fatal:<S2SV_blank>Image<S2SV_blank>source<S2SV_blank>path<S2SV_blank>must<S2SV_blank>be<S2SV_blank>set<S2SV_blank>and<S2SV_blank>exists\\n\\n" <S2SV_ModEnd> ) ; exit |
3,089 | CWE-000 void GameLoop ( ) { int keysPressed [ 6 ] = { 0 , 0 , 0 , 0 , 0 , 0 } ; int close = 0 ; while ( ! close ) { ClearFrame ( ) ; RenderWalls ( ) ; PresentFrame ( ) ; SDL_Event event ; while ( SDL_PollEvent ( & event ) ) { switch ( event . type ) { case SDL_QUIT : close = 1 ; break ; case SDL_KEYUP : case SDL_KEYDOWN : switch ( event . key . keysym . sym ) { case SDLK_w : keysPressed [ 0 ] = event . type == SDL_KEYDOWN ? 1 : 0 ; break ; case SDLK_s : keysPressed [ 1 ] = event . type == SDL_KEYDOWN ? 1 : 0 ; break ; case SDLK_a : keysPressed [ 2 ] = event . type == SDL_KEYDOWN ? 1 : 0 ; break ; case SDLK_d : keysPressed [ 3 ] = event . type == SDL_KEYDOWN ? 1 : 0 ; break ; case SDLK_q : keysPressed [ 4 ] = event . type == SDL_KEYDOWN ? 1 : 0 ; break ; case SDLK_e : keysPressed [ 5 ] = event . type == SDL_KEYDOWN ? 1 : 0 ; break ; case SDLK_t : if ( event . type == SDL_KEYDOWN ) { showTextures = showTextures ? 0 : 1 ; } break ; case SDLK_ESCAPE : close = 1 ; break ; } } } player . velocity . x += keysPressed [ 0 ] ? MOVESPEED * cos ( player . angle ) : 0 ; player . velocity . y += keysPressed [ 0 ] ? MOVESPEED * sin ( player . angle ) : 0 ; player . velocity . x -= keysPressed [ 1 ] ? MOVESPEED * cos ( player . angle ) : 0 ; player . velocity . y -= keysPressed [ 1 ] ? MOVESPEED * sin ( player . angle ) : 0 ; player . velocity . x += keysPressed [ 2 ] ? MOVESPEED * sin ( player . angle ) : 0 ; player . velocity . y -= keysPressed [ 2 ] ? MOVESPEED * cos ( player . angle ) : 0 ; player . velocity . x -= keysPressed [ 3 ] ? MOVESPEED * sin ( player . angle ) : 0 ; player . velocity . y += keysPressed [ 3 ] ? MOVESPEED * cos ( player . angle ) : 0 ; if ( player . velocity . x || player . velocity . y ) { HandleCollision ( ) ; HeadBob ( ) ; } else { viewMovement = 0 ; playerView = 40 ; } HandleFalling ( ) ; player . angle -= keysPressed [ 4 ] ? 0.04f : 0 ; player . angle += keysPressed [ 5 ] ? 0.04f : 0 ; <S2SV_StartBug> SDL_Delay ( 10 ) ; <S2SV_EndBug> } } | <S2SV_ModStart> ; SDL_Delay ( 0 <S2SV_ModEnd> ) ; } |
3,090 | CWE-000 static void test_base64_urlsafe_decode ( void ) { char raw_buf [ 100 ] ; void * raw = ( void * ) raw_buf ; <S2SV_StartBug> size_t raw_len ; <S2SV_EndBug> int ret ; ret = spdk_base64_urlsafe_decode ( raw , & raw_len , text_A ) ; CU_ASSERT_EQUAL ( ret , 0 ) ; CU_ASSERT_EQUAL ( raw_len , sizeof ( raw_A ) ) ; CU_ASSERT ( memcmp ( raw , raw_A , sizeof ( raw_A ) ) == 0 ) ; ret = spdk_base64_urlsafe_decode ( raw , & raw_len , text_urlsafe_B ) ; CU_ASSERT_EQUAL ( ret , 0 ) ; CU_ASSERT_EQUAL ( raw_len , sizeof ( raw_B ) ) ; CU_ASSERT ( memcmp ( raw , raw_B , sizeof ( raw_B ) ) == 0 ) ; ret = spdk_base64_urlsafe_decode ( raw , & raw_len , text_urlsafe_C ) ; CU_ASSERT_EQUAL ( ret , 0 ) ; CU_ASSERT_EQUAL ( raw_len , sizeof ( raw_C ) ) ; CU_ASSERT ( memcmp ( raw , raw_C , sizeof ( raw_C ) ) == 0 ) ; ret = spdk_base64_urlsafe_decode ( raw , & raw_len , text_urlsafe_D ) ; CU_ASSERT_EQUAL ( ret , 0 ) ; CU_ASSERT_EQUAL ( raw_len , sizeof ( raw_D ) ) ; CU_ASSERT ( memcmp ( raw , raw_D , sizeof ( raw_D ) ) == 0 ) ; ret = spdk_base64_urlsafe_decode ( raw , & raw_len , text_E ) ; CU_ASSERT_EQUAL ( ret , - EINVAL ) ; ret = spdk_base64_urlsafe_decode ( raw , & raw_len , text_F ) ; CU_ASSERT_EQUAL ( ret , - EINVAL ) ; ret = spdk_base64_urlsafe_decode ( raw , & raw_len , text_G ) ; CU_ASSERT_EQUAL ( ret , - EINVAL ) ; ret = spdk_base64_urlsafe_decode ( raw , & raw_len , text_H ) ; CU_ASSERT_EQUAL ( ret , - EINVAL ) ; ret = spdk_base64_urlsafe_decode ( NULL , & raw_len , text_H ) ; CU_ASSERT_EQUAL ( ret , - EINVAL ) ; ret = spdk_base64_urlsafe_decode ( raw , & raw_len , NULL ) ; CU_ASSERT_EQUAL ( ret , - EINVAL ) ; } | <S2SV_ModStart> ; size_t raw_len = 0 |
3,091 | CWE-000 int daos_eq_lib_fini ( ) { int rc ; pthread_mutex_lock ( & daos_eq_lock ) ; if ( refcount == 0 ) D_GOTO ( unlock , rc = - DER_UNINIT ) ; if ( refcount > 1 ) { refcount -- ; D_GOTO ( unlock , rc = 0 ) ; <S2SV_StartBug> } <S2SV_EndBug> if ( daos_eq_ctx != NULL ) { rc = crt_context_destroy ( daos_eq_ctx , 1 ) ; if ( rc != 0 ) { D_ERROR ( "failed<S2SV_blank>to<S2SV_blank>destroy<S2SV_blank>client<S2SV_blank>context:<S2SV_blank>%d\\n" , rc ) ; D_GOTO ( unlock , rc ) ; } daos_eq_ctx = NULL ; } rc = crt_finalize ( ) ; if ( rc != 0 ) { D_ERROR ( "failed<S2SV_blank>to<S2SV_blank>shutdown<S2SV_blank>crt:<S2SV_blank>%d\\n" , rc ) ; D_GOTO ( unlock , rc ) ; } D_ASSERT ( daos_eq_hhash != NULL ) ; daos_hhash_destroy ( daos_eq_hhash ) ; refcount = 0 ; unlock : pthread_mutex_unlock ( & daos_eq_lock ) ; return rc ; } | <S2SV_ModStart> ) ; } daos_sched_complete ( & daos_sched_g , 0 , true ) ; |
3,092 | CWE-000 int usb_add_function ( struct usb_configuration * config , struct usb_function * function ) { int value = - EINVAL ; DBG ( config -> cdev , "adding<S2SV_blank>\'%s\'/%p<S2SV_blank>to<S2SV_blank>config<S2SV_blank>\'%s\'/%p\\n" , function -> name , function , config -> label , config ) ; if ( ! function -> set_alt || ! function -> disable ) goto done ; function -> config = config ; list_add_tail ( & function -> list , & config -> functions ) ; if ( function -> bind ) { value = function -> bind ( config , function ) ; if ( value < 0 ) { list_del ( & function -> list ) ; function -> config = NULL ; } } else value = 0 ; <S2SV_StartBug> if ( ! config -> fullspeed && function -> descriptors ) <S2SV_EndBug> config -> fullspeed = true ; if ( ! config -> highspeed && function -> hs_descriptors ) config -> highspeed = true ; if ( ! config -> superspeed && function -> ss_descriptors ) config -> superspeed = true ; done : if ( value ) DBG ( config -> cdev , "adding<S2SV_blank>\'%s\'/%p<S2SV_blank>--><S2SV_blank>%d\\n" , function -> name , function , value ) ; return value ; } | <S2SV_ModStart> && function -> fs_descriptors <S2SV_ModEnd> ) config -> |
3,093 | CWE-000 static int write_rcvrd_mst_node ( struct ubifs_info * c , struct ubifs_mst_node * mst ) { int err = 0 , lnum = UBIFS_MST_LNUM , sz = c -> mst_node_alsz ; <S2SV_StartBug> uint32_t save_flags ; <S2SV_EndBug> dbg_rcvry ( "recovery" ) ; save_flags = mst -> flags ; <S2SV_StartBug> mst -> flags = cpu_to_le32 ( le32_to_cpu ( mst -> flags ) | UBIFS_MST_RCVRY ) ; <S2SV_EndBug> ubifs_prepare_node ( c , mst , UBIFS_MST_NODE_SZ , 1 ) ; err = ubi_leb_change ( c -> ubi , lnum , mst , sz , UBI_SHORTTERM ) ; if ( err ) goto out ; err = ubi_leb_change ( c -> ubi , lnum + 1 , mst , sz , UBI_SHORTTERM ) ; if ( err ) goto out ; out : mst -> flags = save_flags ; return err ; } | <S2SV_ModStart> -> mst_node_alsz ; __le32 <S2SV_ModEnd> save_flags ; dbg_rcvry <S2SV_ModStart> mst -> flags |= cpu_to_le32 ( <S2SV_ModEnd> UBIFS_MST_RCVRY ) ; |
3,094 | CWE-000 static void gls2_handle_class_init ( Gls2HandleClass * klass ) { GObjectClass * object_klass = G_OBJECT_CLASS ( klass ) ; object_klass -> dispose = gls2_handle_dispose ; object_klass -> finalize = gls2_handle_finalize ; object_klass -> get_property = gls2_handle_get_property ; <S2SV_StartBug> object_klass -> set_property = gls2_handle_set_property ; <S2SV_EndBug> g_object_class_install_property ( object_klass , PROP_SERVICE_NAME , g_param_spec_string ( "service-name" , "Service<S2SV_blank>name<S2SV_blank>being<S2SV_blank>registered" , "The<S2SV_blank>service<S2SV_blank>name<S2SV_blank>that<S2SV_blank>will<S2SV_blank>be<S2SV_blank>registered" , NULL , G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE ) ) ; g_object_class_install_property ( object_klass , PROP_APP_ID , g_param_spec_string ( "app-id" , "App<S2SV_blank>name<S2SV_blank>being<S2SV_blank>registered" , "The<S2SV_blank>app<S2SV_blank>name<S2SV_blank>that<S2SV_blank>will<S2SV_blank>be<S2SV_blank>registered" , NULL , G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE ) ) ; } | <S2SV_ModStart> set_property = gls2_handle_set_property ; object_klass -> constructed = gls2_handle_constructed |
3,095 | CWE-000 static void spi_pump_messages ( struct kthread_work * work ) { struct spi_master * master = container_of ( work , struct spi_master , pump_messages ) ; unsigned long flags ; bool was_busy = false ; int ret ; spin_lock_irqsave ( & master -> queue_lock , flags ) ; if ( list_empty ( & master -> queue ) || ! master -> running ) { if ( ! master -> busy ) { spin_unlock_irqrestore ( & master -> queue_lock , flags ) ; return ; } master -> busy = false ; spin_unlock_irqrestore ( & master -> queue_lock , flags ) ; if ( master -> unprepare_transfer_hardware && master -> unprepare_transfer_hardware ( master ) ) dev_err ( & master -> dev , "failed<S2SV_blank>to<S2SV_blank>unprepare<S2SV_blank>transfer<S2SV_blank>hardware\\n" ) ; if ( master -> auto_runtime_pm ) { pm_runtime_mark_last_busy ( master -> dev . parent ) ; pm_runtime_put_autosuspend ( master -> dev . parent ) ; } return ; } if ( master -> cur_msg ) { spin_unlock_irqrestore ( & master -> queue_lock , flags ) ; return ; } master -> cur_msg = list_entry ( master -> queue . next , struct spi_message , queue ) ; list_del_init ( & master -> cur_msg -> queue ) ; if ( master -> busy ) was_busy = true ; else master -> busy = true ; spin_unlock_irqrestore ( & master -> queue_lock , flags ) ; if ( ! was_busy && master -> auto_runtime_pm ) { ret = pm_runtime_get_sync ( master -> dev . parent ) ; if ( ret < 0 ) { dev_err ( & master -> dev , "Failed<S2SV_blank>to<S2SV_blank>power<S2SV_blank>device:<S2SV_blank>%d\\n" , ret ) ; return ; } } if ( ! was_busy && master -> prepare_transfer_hardware ) { ret = master -> prepare_transfer_hardware ( master ) ; if ( ret ) { dev_err ( & master -> dev , "failed<S2SV_blank>to<S2SV_blank>prepare<S2SV_blank>transfer<S2SV_blank>hardware\\n" ) ; if ( master -> auto_runtime_pm ) pm_runtime_put ( master -> dev . parent ) ; return ; } } ret = master -> transfer_one_message ( master , master -> cur_msg ) ; if ( ret ) { dev_err ( & master -> dev , <S2SV_StartBug> "failed<S2SV_blank>to<S2SV_blank>transfer<S2SV_blank>one<S2SV_blank>message<S2SV_blank>from<S2SV_blank>queue:<S2SV_blank>%d\\n" , ret ) ; <S2SV_EndBug> master -> cur_msg -> status = ret ; spi_finalize_current_message ( master ) ; return ; } } | <S2SV_ModStart> -> dev , "failed<S2SV_blank>to<S2SV_blank>transfer<S2SV_blank>one<S2SV_blank>message<S2SV_blank>from<S2SV_blank>queue\\n" <S2SV_ModEnd> ) ; return |
3,096 | CWE-000 gint gimp_image_get_xcf_version ( GimpImage * image , gboolean zlib_compression , gint * gimp_version , const gchar * * version_string , gchar * * version_reason ) { GList * layers ; GList * list ; GList * reasons = NULL ; gint version = 0 ; const gchar * enum_desc ; <S2SV_StartBug> # define ADD_REASON ( _reason ) if ( version_reason ) { gchar * tmp = _reason ; if ( g_list_find_custom ( reasons , tmp , ( GCompareFunc ) strcmp ) ) g_free ( tmp ) ; else reasons = g_list_prepend ( reasons , ( _reason ) ) ; } else g_free ( _reason ) ; <S2SV_EndBug> if ( gimp_image_get_colormap ( image ) ) version = 1 ; layers = gimp_image_get_layer_list ( image ) ; for ( list = layers ; list ; list = g_list_next ( list ) ) { GimpLayer * layer = GIMP_LAYER ( list -> data ) ; switch ( gimp_layer_get_mode ( layer ) ) { case GIMP_LAYER_MODE_NORMAL_LEGACY : case GIMP_LAYER_MODE_DISSOLVE : case GIMP_LAYER_MODE_BEHIND_LEGACY : case GIMP_LAYER_MODE_MULTIPLY_LEGACY : case GIMP_LAYER_MODE_SCREEN_LEGACY : case GIMP_LAYER_MODE_OVERLAY_LEGACY : case GIMP_LAYER_MODE_DIFFERENCE_LEGACY : case GIMP_LAYER_MODE_ADDITION_LEGACY : case GIMP_LAYER_MODE_SUBTRACT_LEGACY : case GIMP_LAYER_MODE_DARKEN_ONLY_LEGACY : case GIMP_LAYER_MODE_LIGHTEN_ONLY_LEGACY : case GIMP_LAYER_MODE_HSV_HUE_LEGACY : case GIMP_LAYER_MODE_HSV_SATURATION_LEGACY : case GIMP_LAYER_MODE_HSL_COLOR_LEGACY : case GIMP_LAYER_MODE_HSV_VALUE_LEGACY : case GIMP_LAYER_MODE_DIVIDE_LEGACY : case GIMP_LAYER_MODE_DODGE_LEGACY : case GIMP_LAYER_MODE_BURN_LEGACY : case GIMP_LAYER_MODE_HARDLIGHT_LEGACY : break ; case GIMP_LAYER_MODE_SOFTLIGHT_LEGACY : case GIMP_LAYER_MODE_GRAIN_EXTRACT_LEGACY : case GIMP_LAYER_MODE_GRAIN_MERGE_LEGACY : case GIMP_LAYER_MODE_COLOR_ERASE_LEGACY : gimp_enum_get_value ( GIMP_TYPE_LAYER_MODE , gimp_layer_get_mode ( layer ) , NULL , NULL , & enum_desc , NULL ) ; ADD_REASON ( g_strdup_printf ( _ ( "Layer<S2SV_blank>mode<S2SV_blank>\'%s\'<S2SV_blank>was<S2SV_blank>added<S2SV_blank>in<S2SV_blank>%s" ) , enum_desc , "GIMP<S2SV_blank>2.6" ) ) ; version = MAX ( 2 , version ) ; break ; case GIMP_LAYER_MODE_OVERLAY : case GIMP_LAYER_MODE_LCH_HUE : case GIMP_LAYER_MODE_LCH_CHROMA : case GIMP_LAYER_MODE_LCH_COLOR : case GIMP_LAYER_MODE_LCH_LIGHTNESS : gimp_enum_get_value ( GIMP_TYPE_LAYER_MODE , gimp_layer_get_mode ( layer ) , NULL , NULL , & enum_desc , NULL ) ; ADD_REASON ( g_strdup_printf ( _ ( "Layer<S2SV_blank>mode<S2SV_blank>\'%s\'<S2SV_blank>was<S2SV_blank>added<S2SV_blank>in<S2SV_blank>%s" ) , enum_desc , "GIMP<S2SV_blank>2.10" ) ) ; version = MAX ( 9 , version ) ; break ; case GIMP_LAYER_MODE_NORMAL : case GIMP_LAYER_MODE_BEHIND : case GIMP_LAYER_MODE_MULTIPLY : case GIMP_LAYER_MODE_SCREEN : case GIMP_LAYER_MODE_DIFFERENCE : case GIMP_LAYER_MODE_ADDITION : case GIMP_LAYER_MODE_SUBTRACT : case GIMP_LAYER_MODE_DARKEN_ONLY : case GIMP_LAYER_MODE_LIGHTEN_ONLY : case GIMP_LAYER_MODE_HSV_HUE : case GIMP_LAYER_MODE_HSV_SATURATION : case GIMP_LAYER_MODE_HSL_COLOR : case GIMP_LAYER_MODE_HSV_VALUE : case GIMP_LAYER_MODE_DIVIDE : case GIMP_LAYER_MODE_DODGE : case GIMP_LAYER_MODE_BURN : case GIMP_LAYER_MODE_HARDLIGHT : case GIMP_LAYER_MODE_SOFTLIGHT : case GIMP_LAYER_MODE_GRAIN_EXTRACT : case GIMP_LAYER_MODE_GRAIN_MERGE : case GIMP_LAYER_MODE_VIVID_LIGHT : case GIMP_LAYER_MODE_PIN_LIGHT : case GIMP_LAYER_MODE_LINEAR_LIGHT : case GIMP_LAYER_MODE_HARD_MIX : case GIMP_LAYER_MODE_EXCLUSION : case GIMP_LAYER_MODE_LINEAR_BURN : case GIMP_LAYER_MODE_LUMA_DARKEN_ONLY : case GIMP_LAYER_MODE_LUMA_LIGHTEN_ONLY : case GIMP_LAYER_MODE_LUMINANCE : case GIMP_LAYER_MODE_COLOR_ERASE : case GIMP_LAYER_MODE_ERASE : case GIMP_LAYER_MODE_MERGE : case GIMP_LAYER_MODE_SPLIT : case GIMP_LAYER_MODE_PASS_THROUGH : gimp_enum_get_value ( GIMP_TYPE_LAYER_MODE , gimp_layer_get_mode ( layer ) , NULL , NULL , & enum_desc , NULL ) ; ADD_REASON ( g_strdup_printf ( _ ( "Layer<S2SV_blank>mode<S2SV_blank>\'%s\'<S2SV_blank>was<S2SV_blank>added<S2SV_blank>in<S2SV_blank>%s" ) , enum_desc , "GIMP<S2SV_blank>2.10" ) ) ; version = MAX ( 10 , version ) ; break ; case GIMP_LAYER_MODE_REPLACE : case GIMP_LAYER_MODE_ANTI_ERASE : case GIMP_LAYER_MODE_SEPARATOR : break ; } if ( gimp_viewable_get_children ( GIMP_VIEWABLE ( layer ) ) ) { ADD_REASON ( g_strdup_printf ( _ ( "Layer<S2SV_blank>groups<S2SV_blank>were<S2SV_blank>added<S2SV_blank>in<S2SV_blank>%s" ) , "GIMP<S2SV_blank>2.8" ) ) ; version = MAX ( 3 , version ) ; if ( gimp_layer_get_mask ( layer ) ) { ADD_REASON ( g_strdup_printf ( _ ( "Masks<S2SV_blank>on<S2SV_blank>layer<S2SV_blank>groups<S2SV_blank>were<S2SV_blank>" "added<S2SV_blank>in<S2SV_blank>%s" ) , "GIMP<S2SV_blank>2.10" ) ) ; version = MAX ( 13 , version ) ; } } } g_list_free ( layers ) ; if ( gimp_image_get_precision ( image ) != GIMP_PRECISION_U8_NON_LINEAR ) { ADD_REASON ( g_strdup_printf ( _ ( "High<S2SV_blank>bit-depth<S2SV_blank>images<S2SV_blank>were<S2SV_blank>added<S2SV_blank>" "in<S2SV_blank>%s" ) , "GIMP<S2SV_blank>2.10" ) ) ; version = MAX ( 7 , version ) ; } if ( gimp_image_get_component_type ( image ) > GIMP_COMPONENT_TYPE_U8 ) { ADD_REASON ( g_strdup_printf ( _ ( "Encoding<S2SV_blank>of<S2SV_blank>high<S2SV_blank>bit-depth<S2SV_blank>images<S2SV_blank>was<S2SV_blank>" "fixed<S2SV_blank>in<S2SV_blank>%s" ) , "GIMP<S2SV_blank>2.10" ) ) ; version = MAX ( 12 , version ) ; } if ( zlib_compression ) version = MAX ( 8 , version ) ; if ( version == 10 ) version = 11 ; if ( gimp_object_get_memsize ( GIMP_OBJECT ( image ) , NULL ) >= ( ( gint64 ) 1 << 32 ) ) { ADD_REASON ( g_strdup_printf ( _ ( "Support<S2SV_blank>for<S2SV_blank>image<S2SV_blank>files<S2SV_blank>larger<S2SV_blank>than<S2SV_blank>" "4GB<S2SV_blank>was<S2SV_blank>added<S2SV_blank>in<S2SV_blank>%s" ) , "GIMP<S2SV_blank>2.10" ) ) ; version = MAX ( 11 , version ) ; } # undef ADD_REASON switch ( version ) { case 0 : case 1 : case 2 : if ( gimp_version ) * gimp_version = 206 ; if ( version_string ) * version_string = "GIMP<S2SV_blank>2.6" ; break ; case 3 : if ( gimp_version ) * gimp_version = 208 ; if ( version_string ) * version_string = "GIMP<S2SV_blank>2.8" ; break ; case 4 : case 5 : case 6 : case 7 : case 8 : case 9 : case 10 : case 11 : case 12 : case 13 : if ( gimp_version ) * gimp_version = 210 ; if ( version_string ) * version_string = "GIMP<S2SV_blank>2.10" ; break ; } if ( version_reason && reasons ) { GString * reason = g_string_new ( NULL ) ; reasons = g_list_sort ( reasons , ( GCompareFunc ) strcmp ) ; for ( list = reasons ; list ; list = g_list_next ( list ) ) { g_string_append ( reason , list -> data ) ; if ( g_list_next ( list ) ) g_string_append_c ( reason , '\\n' ) ; } * version_reason = g_string_free ( reason , FALSE ) ; } if ( reasons ) g_list_free_full ( reasons , g_free ) ; return version ; } | <S2SV_ModStart> ( reasons , tmp ) ; } <S2SV_ModEnd> if ( gimp_image_get_colormap |
3,097 | CWE-000 BOOL is_mesh_enabled ( ) { int ret = FALSE ; char cmd [ ] = "/usr/bin/syscfg<S2SV_blank>get<S2SV_blank>mesh_enable" ; char * retBuf = NULL ; syscfg_executecmd ( __FUNCTION__ , cmd , & retBuf ) ; <S2SV_StartBug> if ( retBuf != NULL && strncmp ( retBuf , "true" , 4 ) != NULL ) { <S2SV_EndBug> ret = TRUE ; } if ( retBuf != NULL ) { free ( retBuf ) ; } return ret ; } | <S2SV_ModStart> , 4 ) == 0 <S2SV_ModEnd> ) { ret |
3,098 | CWE-000 G_DEFINE_TYPE ( IdeCompletionResultsWords , ide_completion_results_words , IDE_TYPE_COMPLETION_RESULTS ) static gint ide_completion_results_words_compare ( IdeCompletionResultsWords * results , IdeCompletionItem * left , IdeCompletionItem * right ) { IdeCompletionResultsWords * self = IDE_COMPLETION_RESULTS_WORDS ( results ) ; GtkSourceCompletionVimWordsProposal * p1 = ( GtkSourceCompletionVimWordsProposal * ) left ; GtkSourceCompletionVimWordsProposal * p2 = ( GtkSourceCompletionVimWordsProposal * ) right ; <S2SV_StartBug> if ( gtk_source_completion_vim_words_proposal_get_offset ( p1 ) < <S2SV_EndBug> gtk_source_completion_vim_words_proposal_get_offset ( p2 ) ) return - 1 ; else return 1 ; } | <S2SV_ModStart> ) right ; g_print ( "===========================Using<S2SV_blank>proper<S2SV_blank>compare===============" ) ; |
3,099 | CWE-000 void step ( FlowData * flow , LatticeConsts * lc , SimParams * params , ThreadData * tdata ) { int nThreads = params -> nThreads ; streamBlockBoundaries ( flow , lc , params ) ; pthread_create ( & ( tdata [ 0 ] . thread ) , NULL , updateFirstBlock , & tdata [ 0 ] ) ; pthread_create ( & ( tdata [ nThreads - 1 ] . thread ) , NULL , updateLastBlock , & tdata [ nThreads - 1 ] ) ; <S2SV_StartBug> for ( int i = 0 ; i < nThreads ; i ++ ) { <S2SV_EndBug> pthread_create ( & ( tdata [ i ] . thread ) , NULL , updateBlock , & tdata [ i ] ) ; } for ( int i = 0 ; i < nThreads ; i ++ ) { pthread_join ( tdata [ i ] . thread , NULL ) ; } bounce ( flow , lc , params ) ; } | <S2SV_ModStart> int i = 1 <S2SV_ModEnd> ; i < <S2SV_ModStart> i < nThreads - 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.