Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
6,600 |
CWE-000 static s32 Handle_Get_InActiveTime ( struct wilc_vif * vif , struct sta_inactive_t * strHostIfStaInactiveT ) { s32 result = 0 ; u8 * stamac ; struct wid wid ; struct host_if_drv * hif_drv = vif -> hif_drv ; wid . id = ( u16 ) WID_SET_STA_MAC_INACTIVE_TIME ; wid . type = WID_STR ; wid . size = ETH_ALEN ; wid . val = kmalloc ( wid . size , GFP_KERNEL ) ; if ( ! wid . val ) return - ENOMEM ; stamac = wid . val ; ether_addr_copy ( stamac , strHostIfStaInactiveT -> mac ) ; PRINT_INFO ( vif -> ndev , CFG80211_DBG , "SETING<S2SV_blank>STA<S2SV_blank>inactive<S2SV_blank>time\\n" ) ; if ( ! hif_drv ) { PRINT_ER ( vif -> ndev , "Driver<S2SV_blank>is<S2SV_blank>null\\n" ) ; return - EFAULT ; } result = wilc_send_config_pkt ( vif , SET_CFG , & wid , 1 , wilc_get_vif_idx ( vif ) ) ; if ( result ) { <S2SV_StartBug> PRINT_ER ( vif -> ndev , "Failed<S2SV_blank>to<S2SV_blank>SET<S2SV_blank>incative<S2SV_blank>time\\n" ) ; <S2SV_EndBug> return - EFAULT ; } wid . id = ( u16 ) WID_GET_INACTIVE_TIME ; wid . type = WID_INT ; wid . val = ( s8 * ) & inactive_time ; wid . size = sizeof ( u32 ) ; result = wilc_send_config_pkt ( vif , GET_CFG , & wid , 1 , wilc_get_vif_idx ( vif ) ) ; if ( result ) { <S2SV_StartBug> PRINT_ER ( vif -> ndev , "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>incative<S2SV_blank>time\\n" ) ; <S2SV_EndBug> return - EFAULT ; } PRINT_INFO ( vif -> ndev , CFG80211_DBG , "Getting<S2SV_blank>inactive<S2SV_blank>time<S2SV_blank>:<S2SV_blank>%d\\n" , inactive_time ) ; complete ( & hif_drv -> comp_inactive_time ) ; return result ; }
|
<S2SV_ModStart> -> ndev , "Failed<S2SV_blank>to<S2SV_blank>SET<S2SV_blank>inactive<S2SV_blank>time\\n" <S2SV_ModEnd> ) ; return <S2SV_ModStart> -> ndev , "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>inactive<S2SV_blank>time\\n" <S2SV_ModEnd> ) ; return
|
6,601 |
CWE-000 t_dir * opn ( char * name , t_fl * fl ) { t_dir * dd ; t_stat * test ; test = ( t_stat * ) ft_memalloc ( sizeof ( t_stat ) ) ; <S2SV_StartBug> if ( lstat ( name , test ) == - 1 && freedom ( test ) && dprintf ( 2 , "./ft_ls:<S2SV_blank>%s:<S2SV_blank>%s\\n" , sta ( name ) , strerror ( errno ) ) ) <S2SV_EndBug> return ( NULL ) ; dd = ( t_dir * ) ft_memalloc ( sizeof ( t_dir ) ) ; dd -> title = ( char * ) ft_memalloc ( sizeof ( char ) * ( ft_strlen ( name ) + 1 ) ) ; ft_strcpy ( dd -> title , name ) ; <S2SV_StartBug> dd -> title_stat = test ; <S2SV_EndBug> <S2SV_StartBug> if ( ! fl -> d && S_ISDIR ( dd -> title_stat -> st_mode ) ) <S2SV_EndBug> { if ( openthisdir ( name , dd , fl ) ) { <S2SV_StartBug> dprintf ( 2 , "./ft_ls:<S2SV_blank>%s:<S2SV_blank>%s\\n" , sta ( name ) , strerror ( errno ) ) ; <S2SV_EndBug> free ( dd -> title ) ; <S2SV_StartBug> free ( dd -> title_stat ) ; <S2SV_EndBug> return ( NULL ) ; } statthisdir ( name , dd ) ; sort ( dd , NULL , 0 , fl ) ; } return ( dd ) ; }
|
<S2SV_ModStart> , "./ft_ls:<S2SV_blank>%s:<S2SV_blank>%s\\n" , name <S2SV_ModEnd> , strerror ( <S2SV_ModStart> ; dd -> tistat <S2SV_ModEnd> = test ; <S2SV_ModStart> ( dd -> tistat <S2SV_ModEnd> -> st_mode ) <S2SV_ModStart> , "./ft_ls:<S2SV_blank>%s:<S2SV_blank>%s\\n" , name <S2SV_ModEnd> , strerror ( <S2SV_ModStart> ( dd -> tistat <S2SV_ModEnd> ) ; return
|
6,602 |
CWE-000 static ndt_t * ndt_substitute ( const ndt_t * t , const symtable_t * tbl , ndt_context_t * ctx ) { symtable_entry_t v ; const ndt_t * w ; ndt_t * u ; int i ; switch ( t -> tag ) { case FixedDim : u = ndt_substitute ( t -> FixedDim . type , tbl , ctx ) ; if ( u == NULL ) { return NULL ; } assert ( ndt_is_concrete ( u ) ) ; <S2SV_StartBug> return ndt_fixed_dim ( u , t -> FixedDim . shape , t -> Concrete . FixedDim . stride , <S2SV_EndBug> ctx ) ; case SymbolicDim : v = symtable_find ( tbl , t -> SymbolicDim . name ) ; switch ( v . tag ) { case ShapeEntry : u = ndt_substitute ( t -> SymbolicDim . type , tbl , ctx ) ; if ( u == NULL ) { return NULL ; } assert ( ndt_is_concrete ( u ) ) ; return ndt_fixed_dim ( u , v . ShapeEntry , INT64_MAX , ctx ) ; default : ndt_err_format ( ctx , NDT_ValueError , "variable<S2SV_blank>is<S2SV_blank>not<S2SV_blank>found<S2SV_blank>or<S2SV_blank>has<S2SV_blank>incorrect<S2SV_blank>type" ) ; return NULL ; } case EllipsisDim : if ( t -> EllipsisDim . name == NULL ) { ndt_err_format ( ctx , NDT_ValueError , "cannot<S2SV_blank>substitute<S2SV_blank>unnamed<S2SV_blank>ellipsis<S2SV_blank>dimension" ) ; return NULL ; } u = ndt_substitute ( t -> EllipsisDim . type , tbl , ctx ) ; if ( u == NULL ) { return NULL ; } v = symtable_find ( tbl , t -> EllipsisDim . name ) ; switch ( v . tag ) { case DimListEntry : for ( i = 0 ; i < v . DimListEntry . size ; i ++ ) { w = v . DimListEntry . dims [ i ] ; switch ( w -> tag ) { case FixedDim : assert ( ndt_is_concrete ( w ) ) ; u = ndt_fixed_dim ( u , w -> FixedDim . shape , INT64_MAX , ctx ) ; if ( u == NULL ) { return NULL ; } break ; default : ndt_err_format ( ctx , NDT_NotImplementedError , "substitution<S2SV_blank>not<S2SV_blank>implemented<S2SV_blank>for<S2SV_blank>this<S2SV_blank>type" ) ; ndt_del ( u ) ; return NULL ; } } return u ; default : ndt_err_format ( ctx , NDT_ValueError , "variable<S2SV_blank>is<S2SV_blank>not<S2SV_blank>found<S2SV_blank>or<S2SV_blank>has<S2SV_blank>incorrect<S2SV_blank>type" ) ; return NULL ; } case Typevar : v = symtable_find ( tbl , t -> Typevar . name ) ; switch ( v . tag ) { case TypeEntry : return ndt_substitute ( v . TypeEntry , tbl , ctx ) ; default : ndt_err_format ( ctx , NDT_ValueError , "variable<S2SV_blank>is<S2SV_blank>not<S2SV_blank>found<S2SV_blank>or<S2SV_blank>has<S2SV_blank>incorrect<S2SV_blank>type" ) ; return NULL ; } case Ref : u = ndt_substitute ( t -> Ref . type , tbl , ctx ) ; if ( u == NULL ) { return NULL ; } return ndt_ref ( u , ctx ) ; case Int64 : case Float32 : case Float64 : return ndt_primitive ( t -> tag , 'L' , ctx ) ; default : ndt_err_format ( ctx , NDT_NotImplementedError , "substitution<S2SV_blank>not<S2SV_blank>implemented<S2SV_blank>for<S2SV_blank>this<S2SV_blank>type" ) ; return NULL ; } }
|
<S2SV_ModStart> . FixedDim . step <S2SV_ModEnd> , ctx )
|
6,603 |
CWE-000 network_mysqld_con * network_mysqld_con_new ( ) { network_mysqld_con * con ; con = g_new0 ( network_mysqld_con , 1 ) ; con -> parse . command = - 1 ; con -> max_retry_serv_cnt = 72 ; con -> auth_switch_to_method = g_string_new ( NULL ) ; con -> auth_switch_to_round = 0 ; con -> auth_switch_to_data = g_string_new ( NULL ) ; con -> is_auto_commit = 1 ; con -> orig_sql = g_string_new ( NULL ) ; con -> connect_timeout . tv_sec = 2 * SECONDS ; con -> connect_timeout . tv_usec = 0 ; con -> read_timeout . tv_sec = 10 * MINUTES ; con -> read_timeout . tv_usec = 0 ; <S2SV_StartBug> con -> write_timeout . tv_sec = 10 * MINUTES ; <S2SV_EndBug> con -> write_timeout . tv_usec = 0 ; con -> wait_clt_next_sql . tv_sec = 0 ; con -> wait_clt_next_sql . tv_usec = 256 * 1000 ; # ifdef NETWORK_DEBUG_TRACE_STATE_CHANGES con -> recent_queries = query_queue_new ( 20 ) ; # endif return con ; }
|
<S2SV_ModStart> ; con -> dist_tran_decided_read_timeout . tv_sec = 30 ; con -> dist_tran_decided_read_timeout . tv_usec = 0 ; con ->
|
6,604 |
CWE-000 static int setTestProcessGroupSignalHandler ( struct J9PortLibrary * portLibrary ) { PORT_ACCESS_FROM_PORT ( portLibrary ) ; int rc = - 1 ; # if defined ( WIN32 ) BOOL setConsoleCtrlHandlerRC = FALSE ; setConsoleCtrlHandlerRC = SetConsoleCtrlHandler ( consoleCtrlHandler , TRUE ) ; if ( FALSE == setConsoleCtrlHandlerRC ) { j9error_set_last_error ( GetLastError ( ) , 1 ) ; rc = - 1 ; } else { rc = 0 ; } # else <S2SV_StartBug> U_32 setAsyncRC = J9PORT_SIG_ERROR ; <S2SV_EndBug> setAsyncRC = j9sig_set_async_signal_handler ( processGroupSignalHandler , NULL , J9PORT_SIG_FLAG_SIGQUIT ) ; if ( J9PORT_SIG_ERROR == setAsyncRC ) { rc = - 1 ; } else { rc = 0 ; } # endif return rc ; }
|
<S2SV_ModStart> } # else I_32 <S2SV_ModEnd> setAsyncRC = J9PORT_SIG_ERROR
|
6,605 |
CWE-000 gint xmpp_connect ( void ) { const char * userjid , * password , * resource , * servername , * ssl_fpr ; char * dynresource = NULL ; <S2SV_StartBug> char fpr [ 16 ] ; <S2SV_EndBug> const char * proxy_host ; const char * resource_prefix = PACKAGE_NAME ; char * fjid ; int ssl , tls ; LmSSL * lssl ; unsigned int port ; <S2SV_StartBug> unsigned int ping ; <S2SV_EndBug> LmMessageHandler * handler ; GError * error = NULL ; xmpp_disconnect ( ) ; servername = settings_opt_get ( "server" ) ; userjid = settings_opt_get ( "jid" ) ; password = settings_opt_get ( "password" ) ; resource = settings_opt_get ( "resource" ) ; proxy_host = settings_opt_get ( "proxy_host" ) ; ssl_fpr = settings_opt_get ( "ssl_fingerprint" ) ; if ( ! userjid ) { scr_LogPrint ( LPRINT_LOGNORM , "Your<S2SV_blank>JID<S2SV_blank>has<S2SV_blank>not<S2SV_blank>been<S2SV_blank>specified!" ) ; return - 1 ; } if ( ! password ) { scr_LogPrint ( LPRINT_LOGNORM , "Your<S2SV_blank>password<S2SV_blank>has<S2SV_blank>not<S2SV_blank>been<S2SV_blank>specified!" ) ; return - 1 ; } lconnection = lm_connection_new_with_context ( NULL , main_context ) ; <S2SV_StartBug> g_log_set_handler ( "LM" , LM_LOG_LEVEL_ALL , lm_debug_handler , NULL ) ; <S2SV_EndBug> ping = 40 ; if ( settings_opt_get ( "pinginterval" ) ) ping = ( unsigned int ) settings_opt_get_int ( "pinginterval" ) ; lm_connection_set_keep_alive_rate ( lconnection , ping ) ; scr_LogPrint ( LPRINT_DEBUG , "Ping<S2SV_blank>interval<S2SV_blank>established:<S2SV_blank>%d<S2SV_blank>secs" , ping ) ; lm_connection_set_disconnect_function ( lconnection , connection_close_cb , NULL , NULL ) ; handler = lm_message_handler_new ( handle_messages , NULL , NULL ) ; lm_connection_register_message_handler ( lconnection , handler , LM_MESSAGE_TYPE_MESSAGE , LM_HANDLER_PRIORITY_NORMAL ) ; lm_message_handler_unref ( handler ) ; handler = lm_message_handler_new ( handle_iq , NULL , NULL ) ; lm_connection_register_message_handler ( lconnection , handler , LM_MESSAGE_TYPE_IQ , LM_HANDLER_PRIORITY_NORMAL ) ; lm_message_handler_unref ( handler ) ; handler = lm_message_handler_new ( handle_presence , NULL , NULL ) ; lm_connection_register_message_handler ( lconnection , handler , LM_MESSAGE_TYPE_PRESENCE , LM_HANDLER_PRIORITY_LAST ) ; lm_message_handler_unref ( handler ) ; handler = lm_message_handler_new ( handle_s10n , NULL , NULL ) ; lm_connection_register_message_handler ( lconnection , handler , LM_MESSAGE_TYPE_PRESENCE , LM_HANDLER_PRIORITY_NORMAL ) ; lm_message_handler_unref ( handler ) ; scr_LogPrint ( LPRINT_NORMAL | LPRINT_DEBUG , "Connecting<S2SV_blank>to<S2SV_blank>server%s%s" , servername ? ":<S2SV_blank>" : "" , servername ? servername : "" ) ; if ( ! resource ) resource = resource_prefix ; srandom ( time ( NULL ) ) ; if ( ! settings_opt_get ( "disable_random_resource" ) ) { # if HAVE_ARC4RANDOM dynresource = g_strdup_printf ( "%s.%08x" , resource , arc4random ( ) ) ; # else unsigned int tab [ 2 ] ; tab [ 0 ] = ( unsigned int ) ( 0xffff * ( random ( ) / ( RAND_MAX + 1.0 ) ) ) ; tab [ 1 ] = ( unsigned int ) ( 0xffff * ( random ( ) / ( RAND_MAX + 1.0 ) ) ) ; dynresource = g_strdup_printf ( "%s.%04x%04x" , resource , tab [ 0 ] , tab [ 1 ] ) ; # endif resource = dynresource ; } port = ( unsigned int ) settings_opt_get_int ( "port" ) ; if ( port ) scr_LogPrint ( LPRINT_NORMAL | LPRINT_DEBUG , "<S2SV_blank>using<S2SV_blank>port<S2SV_blank>%d" , port ) ; scr_LogPrint ( LPRINT_NORMAL | LPRINT_DEBUG , "<S2SV_blank>with<S2SV_blank>resource<S2SV_blank>%s" , resource ) ; if ( proxy_host ) { int proxy_port = settings_opt_get_int ( "proxy_port" ) ; if ( proxy_port <= 0 || proxy_port > 65535 ) { scr_LogPrint ( LPRINT_NORMAL | LPRINT_DEBUG , "Invalid<S2SV_blank>proxy<S2SV_blank>port:<S2SV_blank>%d" , proxy_port ) ; } else { const char * proxy_user , * proxy_pass ; LmProxy * lproxy ; proxy_user = settings_opt_get ( "proxy_user" ) ; proxy_pass = settings_opt_get ( "proxy_pass" ) ; lproxy = lm_proxy_new_with_server ( LM_PROXY_TYPE_HTTP , proxy_host , proxy_port ) ; lm_proxy_set_username ( lproxy , proxy_user ) ; lm_proxy_set_password ( lproxy , proxy_pass ) ; lm_connection_set_proxy ( lconnection , lproxy ) ; lm_proxy_unref ( lproxy ) ; scr_LogPrint ( LPRINT_NORMAL | LPRINT_DEBUG , "<S2SV_blank>using<S2SV_blank>proxy<S2SV_blank>%s:%d" , proxy_host , proxy_port ) ; } } fjid = compose_jid ( userjid , servername , resource ) ; lm_connection_set_jid ( lconnection , fjid ) ; if ( servername ) lm_connection_set_server ( lconnection , servername ) ; # if defined ( HAVE_LIBOTR ) otr_init ( fjid ) ; # endif g_free ( fjid ) ; g_free ( dynresource ) ; ssl = settings_opt_get_int ( "ssl" ) ; tls = settings_opt_get_int ( "tls" ) ; if ( ! lm_ssl_is_supported ( ) ) { if ( ssl || tls ) { scr_LogPrint ( LPRINT_LOGNORM , "**<S2SV_blank>Error:<S2SV_blank>SSL<S2SV_blank>is<S2SV_blank>NOT<S2SV_blank>available,<S2SV_blank>" "please<S2SV_blank>recompile<S2SV_blank>loudmouth<S2SV_blank>with<S2SV_blank>SSL<S2SV_blank>enabled." ) ; return - 1 ; } } if ( ssl && tls ) { scr_LogPrint ( LPRINT_LOGNORM , "You<S2SV_blank>can<S2SV_blank>only<S2SV_blank>set<S2SV_blank>ssl<S2SV_blank>or<S2SV_blank>tls,<S2SV_blank>not<S2SV_blank>both." ) ; return - 1 ; } if ( ! port ) port = ( ssl ? LM_CONNECTION_DEFAULT_PORT_SSL : LM_CONNECTION_DEFAULT_PORT ) ; lm_connection_set_port ( lconnection , port ) ; if ( ssl_fpr && ( ! hex_to_fingerprint ( ssl_fpr , fpr ) ) ) { scr_LogPrint ( LPRINT_LOGNORM , "**<S2SV_blank>Please<S2SV_blank>set<S2SV_blank>the<S2SV_blank>fingerprint<S2SV_blank>in<S2SV_blank>the<S2SV_blank>format<S2SV_blank>" "97:5C:00:3F:1D:77:45:25:E2:C5:70:EC:83:C8:87:EE" ) ; return - 1 ; } lssl = lm_ssl_new ( ( ssl_fpr ? fpr : NULL ) , ssl_cb , NULL , NULL ) ; if ( lssl ) { # ifdef HAVE_LM_SSL_CIPHER_LIST const char * ssl_ciphers = settings_opt_get ( "ssl_ciphers" ) ; lm_ssl_set_cipher_list ( lssl , ssl_ciphers ) ; # endif # ifdef HAVE_LM_SSL_CA const char * ssl_ca = settings_opt_get ( "ssl_ca" ) ; lm_ssl_set_ca ( lssl , ssl_ca ) ; # endif lm_ssl_use_starttls ( lssl , ! ssl , tls ) ; lm_connection_set_ssl ( lconnection , lssl ) ; lm_ssl_unref ( lssl ) ; } else if ( ssl || tls ) { scr_LogPrint ( LPRINT_LOGNORM , "**<S2SV_blank>Error:<S2SV_blank>Couldn\'t<S2SV_blank>create<S2SV_blank>SSL<S2SV_blank>struct." ) ; return - 1 ; } if ( ! lm_connection_open ( lconnection , connection_open_cb , NULL , FALSE , & error ) ) { _try_to_reconnect ( ) ; scr_LogPrint ( LPRINT_LOGNORM , "Failed<S2SV_blank>to<S2SV_blank>open:<S2SV_blank>%s" , error -> message ) ; g_error_free ( error ) ; } return 0 ; }
|
<S2SV_ModStart> char fpr [ 17 ] = { 0 } <S2SV_ModEnd> ; const char <S2SV_ModStart> unsigned int ping = 40 <S2SV_ModStart> , NULL ) <S2SV_ModEnd> ; if (
|
6,606 |
CWE-000 struct mArchiveExecReturn * mArchiveExec ( char * tblfile , char * inpath , int nrestart , int timeout , int debug ) { int i , c , stat , ncols , count , failed , nread ; int iurl ; int ifile ; int iimin , iimax , ijmin , ijmax ; int imin , imax , jmin , jmax ; int itmin , itmax , jtmin , jtmax ; int nx , ny , ix , jy ; char * ptr ; char url [ MAXSTR ] ; char urlbase [ MAXSTR ] ; char file [ MAXSTR ] ; char filebase [ MAXSTR ] ; char path [ MAXSTR ] ; char cmd [ MAXSTR ] ; char status [ 32 ] ; struct mArchiveExecReturn * returnStruct ; struct mArchiveGetReturn * archive ; returnStruct = ( struct mArchiveExecReturn * ) malloc ( sizeof ( struct mArchiveExecReturn ) ) ; memset ( ( void * ) returnStruct , 0 , sizeof ( returnStruct ) ) ; returnStruct -> status = 1 ; if ( inpath == ( char * ) NULL ) strcpy ( path , "." ) ; else strcpy ( path , inpath ) ; if ( debug ) { printf ( "DEBUG><S2SV_blank>tblfile<S2SV_blank>=<S2SV_blank>[%s]\\n" , tblfile ) ; fflush ( stdout ) ; } ncols = topen ( tblfile ) ; iurl = tcol ( "URL" ) ; if ( iurl < 0 ) iurl = tcol ( "url" ) ; ifile = tcol ( "fname" ) ; if ( ifile < 0 ) ifile = tcol ( "file" ) ; if ( debug ) { printf ( "DEBUG><S2SV_blank>iurl<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>=<S2SV_blank>%d\\n" , iurl ) ; printf ( "DEBUG><S2SV_blank>ifile<S2SV_blank><S2SV_blank><S2SV_blank>=<S2SV_blank>%d\\n" , ifile ) ; fflush ( stdout ) ; } iimin = tcol ( "imin" ) ; iimax = tcol ( "imax" ) ; ijmin = tcol ( "jmin" ) ; ijmax = tcol ( "jmax" ) ; if ( iurl < 0 ) { sprintf ( returnStruct -> msg , "Table<S2SV_blank>%s<S2SV_blank>needs<S2SV_blank>column<S2SV_blank>\'URL\'<S2SV_blank>or<S2SV_blank>\'url\'<S2SV_blank>and<S2SV_blank>can<S2SV_blank>optionally<S2SV_blank>have<S2SV_blank>columns<S2SV_blank>\'fname\'/\'file\'<S2SV_blank>and<S2SV_blank>pixel<S2SV_blank>ranges<S2SV_blank>\'imin\'..\'jmax\'" , tblfile ) ; return returnStruct ; } count = 0 ; failed = 0 ; nread = 0 ; chdir ( path ) ; while ( 1 ) { stat = tread ( ) ; ++ nread ; if ( nread < nrestart ) continue ; if ( stat < 0 ) break ; strcpy ( url , tval ( iurl ) ) ; if ( debug ) { printf ( "DEBUG><S2SV_blank>url<S2SV_blank><S2SV_blank>=<S2SV_blank>[%s]\\n" , url ) ; fflush ( stdout ) ; } if ( ifile >= 0 ) strcpy ( file , tval ( ifile ) ) ; else { ptr = url + strlen ( url ) - 1 ; while ( 1 ) { if ( ptr == url || * ptr == '/' ) { strcpy ( file , ptr + 1 ) ; break ; } -- ptr ; } } if ( debug ) { printf ( "DEBUG><S2SV_blank>file<S2SV_blank>=<S2SV_blank>[%s]\\n" , file ) ; fflush ( stdout ) ; } if ( iimin >= 0 && iimax >= 0 && ijmin >= 0 && ijmax >= 0 ) { strcpy ( filebase , file ) ; for ( i = 0 ; i < strlen ( filebase ) ; ++ i ) if ( filebase [ i ] == '.' ) filebase [ i ] = '\\0' ; strcpy ( urlbase , url ) ; for ( i = 0 ; i < strlen ( urlbase ) ; ++ i ) if ( urlbase [ i ] == '&' ) urlbase [ i ] = '\\0' ; imin = 1 ; imax = NPIX ; jmin = 1 ; jmax = NPIX ; imin = atoi ( tval ( iimin ) ) ; imax = atoi ( tval ( iimax ) ) ; jmin = atoi ( tval ( ijmin ) ) ; jmax = atoi ( tval ( ijmax ) ) ; nx = NPIX / 500 ; ny = NPIX / 500 ; for ( ix = 3 ; ix < nx - 3 ; ++ ix ) { for ( jy = 3 ; jy < nx - 3 ; ++ jy ) { itmin = ix * 500 - 50 ; jtmin = jy * 500 - 50 ; itmax = ( ix + 1 ) * 500 + 50 ; jtmax = ( jy + 1 ) * 500 + 50 ; if ( itmax < imin ) continue ; if ( itmin > imax ) continue ; if ( jtmax < jmin ) continue ; if ( jtmin > jmax ) continue ; sprintf ( url , "%s&X1=%d&X2=%d&Y1=%d&Y2=%d" , urlbase , itmin , itmax - itmin + 1 , jtmin , jtmax - jtmin + 1 ) ; sprintf ( file , "%s_%d_%d.fits" , filebase , ix , jy ) ; archive = mArchiveGet ( url , file , timeout , debug ) ; ++ count ; if ( archive -> status ) { ++ failed ; continue ; } if ( strcmp ( status , "ERROR" ) == 0 ) { ++ failed ; continue ; } } } } else { archive = mArchiveGet ( url , file , timeout , debug ) ; ++ count ; if ( archive -> status ) { ++ failed ; continue ; } if ( strlen ( file ) > 3 && strcmp ( file + strlen ( file ) - 3 , ".gz" ) == 0 ) { sprintf ( cmd , "gunzip<S2SV_blank>%s" , file ) ; system ( cmd ) ; } } } returnStruct -> status = 0 ; sprintf ( returnStruct -> msg , "count=%d,<S2SV_blank>failed=%d" , count , failed ) ; <S2SV_StartBug> sprintf ( returnStruct -> json , "{\\"count\\"=%d,<S2SV_blank>\\"failed\\"=%d}" , count , failed ) ; <S2SV_EndBug> returnStruct -> count = count ; returnStruct -> failed = failed ; return returnStruct ; }
|
<S2SV_ModStart> -> json , "{\\"count\\":%d,<S2SV_blank>\\"failed\\":%d}" <S2SV_ModEnd> , count ,
|
6,607 |
CWE-000 static void atombios_crtc_program_pll ( struct drm_crtc * crtc , u32 crtc_id , int pll_id , u32 encoder_mode , u32 encoder_id , u32 clock , u32 ref_div , u32 fb_div , u32 frac_fb_div , u32 post_div , int bpc , bool ss_enabled , struct radeon_atom_ss * ss ) { struct drm_device * dev = crtc -> dev ; struct radeon_device * rdev = dev -> dev_private ; u8 frev , crev ; int index = GetIndexIntoMasterTable ( COMMAND , SetPixelClock ) ; union set_pixel_clock args ; memset ( & args , 0 , sizeof ( args ) ) ; if ( ! atom_parse_cmd_header ( rdev -> mode_info . atom_context , index , & frev , & crev ) ) return ; switch ( frev ) { case 1 : switch ( crev ) { case 1 : if ( clock == ATOM_DISABLE ) return ; args . v1 . usPixelClock = cpu_to_le16 ( clock / 10 ) ; args . v1 . usRefDiv = cpu_to_le16 ( ref_div ) ; args . v1 . usFbDiv = cpu_to_le16 ( fb_div ) ; args . v1 . ucFracFbDiv = frac_fb_div ; args . v1 . ucPostDiv = post_div ; args . v1 . ucPpll = pll_id ; args . v1 . ucCRTC = crtc_id ; args . v1 . ucRefDivSrc = 1 ; break ; case 2 : args . v2 . usPixelClock = cpu_to_le16 ( clock / 10 ) ; args . v2 . usRefDiv = cpu_to_le16 ( ref_div ) ; args . v2 . usFbDiv = cpu_to_le16 ( fb_div ) ; args . v2 . ucFracFbDiv = frac_fb_div ; args . v2 . ucPostDiv = post_div ; args . v2 . ucPpll = pll_id ; args . v2 . ucCRTC = crtc_id ; args . v2 . ucRefDivSrc = 1 ; break ; case 3 : args . v3 . usPixelClock = cpu_to_le16 ( clock / 10 ) ; args . v3 . usRefDiv = cpu_to_le16 ( ref_div ) ; args . v3 . usFbDiv = cpu_to_le16 ( fb_div ) ; args . v3 . ucFracFbDiv = frac_fb_div ; args . v3 . ucPostDiv = post_div ; args . v3 . ucPpll = pll_id ; if ( crtc_id == ATOM_CRTC2 ) args . v3 . ucMiscInfo = PIXEL_CLOCK_MISC_CRTC_SEL_CRTC2 ; else args . v3 . ucMiscInfo = PIXEL_CLOCK_MISC_CRTC_SEL_CRTC1 ; if ( ss_enabled && ( ss -> type & ATOM_EXTERNAL_SS_MASK ) ) args . v3 . ucMiscInfo |= PIXEL_CLOCK_MISC_REF_DIV_SRC ; args . v3 . ucTransmitterId = encoder_id ; args . v3 . ucEncoderMode = encoder_mode ; break ; case 5 : args . v5 . ucCRTC = crtc_id ; args . v5 . usPixelClock = cpu_to_le16 ( clock / 10 ) ; args . v5 . ucRefDiv = ref_div ; args . v5 . usFbDiv = cpu_to_le16 ( fb_div ) ; args . v5 . ulFbDivDecFrac = cpu_to_le32 ( frac_fb_div * 100000 ) ; args . v5 . ucPostDiv = post_div ; args . v5 . ucMiscInfo = 0 ; if ( ss_enabled && ( ss -> type & ATOM_EXTERNAL_SS_MASK ) ) args . v5 . ucMiscInfo |= PIXEL_CLOCK_V5_MISC_REF_DIV_SRC ; <S2SV_StartBug> switch ( bpc ) { <S2SV_EndBug> case 8 : default : args . v5 . ucMiscInfo |= PIXEL_CLOCK_V5_MISC_HDMI_24BPP ; break ; case 10 : args . v5 . ucMiscInfo |= PIXEL_CLOCK_V5_MISC_HDMI_30BPP ; <S2SV_StartBug> break ; <S2SV_EndBug> } args . v5 . ucTransmitterID = encoder_id ; args . v5 . ucEncoderMode = encoder_mode ; args . v5 . ucPpll = pll_id ; break ; case 6 : args . v6 . ulDispEngClkFreq = cpu_to_le32 ( crtc_id << 24 | clock / 10 ) ; args . v6 . ucRefDiv = ref_div ; args . v6 . usFbDiv = cpu_to_le16 ( fb_div ) ; args . v6 . ulFbDivDecFrac = cpu_to_le32 ( frac_fb_div * 100000 ) ; args . v6 . ucPostDiv = post_div ; args . v6 . ucMiscInfo = 0 ; if ( ss_enabled && ( ss -> type & ATOM_EXTERNAL_SS_MASK ) ) args . v6 . ucMiscInfo |= PIXEL_CLOCK_V6_MISC_REF_DIV_SRC ; <S2SV_StartBug> switch ( bpc ) { <S2SV_EndBug> case 8 : default : args . v6 . ucMiscInfo |= PIXEL_CLOCK_V6_MISC_HDMI_24BPP ; break ; case 10 : args . v6 . ucMiscInfo |= PIXEL_CLOCK_V6_MISC_HDMI_30BPP ; break ; case 12 : args . v6 . ucMiscInfo |= PIXEL_CLOCK_V6_MISC_HDMI_36BPP ; break ; case 16 : args . v6 . ucMiscInfo |= PIXEL_CLOCK_V6_MISC_HDMI_48BPP ; <S2SV_StartBug> break ; <S2SV_EndBug> } args . v6 . ucTransmitterID = encoder_id ; args . v6 . ucEncoderMode = encoder_mode ; args . v6 . ucPpll = pll_id ; break ; default : DRM_ERROR ( "Unknown<S2SV_blank>table<S2SV_blank>version<S2SV_blank>%d<S2SV_blank>%d\\n" , frev , crev ) ; return ; } break ; default : DRM_ERROR ( "Unknown<S2SV_blank>table<S2SV_blank>version<S2SV_blank>%d<S2SV_blank>%d\\n" , frev , crev ) ; return ; } atom_execute_table ( rdev -> mode_info . atom_context , index , ( uint32_t * ) & args ) ; }
|
<S2SV_ModStart> |= PIXEL_CLOCK_V5_MISC_REF_DIV_SRC ; if ( encoder_mode == ATOM_ENCODER_MODE_HDMI ) { <S2SV_ModStart> ; break ; } <S2SV_ModStart> |= PIXEL_CLOCK_V6_MISC_REF_DIV_SRC ; if ( encoder_mode == ATOM_ENCODER_MODE_HDMI ) { <S2SV_ModStart> ; break ; }
|
6,608 |
CWE-000 int usb_phy_roothub_exit ( struct usb_phy_roothub * phy_roothub ) { struct usb_phy_roothub * roothub_entry ; struct list_head * head ; int err , ret = 0 ; if ( ! phy_roothub ) return 0 ; head = & phy_roothub -> list ; list_for_each_entry ( roothub_entry , head , list ) { err = phy_exit ( roothub_entry -> phy ) ; if ( err ) <S2SV_StartBug> ret = ret ; <S2SV_EndBug> } return ret ; }
|
<S2SV_ModStart> ) ret = err <S2SV_ModEnd> ; } return
|
6,609 |
CWE-000 int main ( void ) { window_data * screen ; line_data * line ; line = init_line ( ) ; screen = make_window ( ) ; <S2SV_StartBug> fill_line ( line , 20 , 20 , 380 , 380 ) ; <S2SV_EndBug> draw_line ( screen , line ) ; mlx_loop ( screen -> mlx ) ; return ( 0 ) ; }
|
<S2SV_ModStart> , 20 , 950 , 950 <S2SV_ModEnd> ) ; draw_line
|
6,610 |
CWE-000 static s32_t nrc_node_serial_in_deinit ( nrc_node_t slf ) { struct nrc_node_serial_in * self = ( struct nrc_node_serial_in * ) slf ; s32_t result = NRC_R_INVALID_IN_PARAM ; if ( ( self != NULL ) && ( self -> type == NRC_N_SERIAL_IN_TYPE ) ) { switch ( self -> state ) { case NRC_N_SERIAL_IN_S_INITIALISED : case NRC_N_SERIAL_IN_S_ERROR : nrc_port_heap_free ( self -> data_in ) ; self -> data_in = NULL ; self -> state = NRC_N_SERIAL_IN_S_CREATED ; <S2SV_StartBug> break ; <S2SV_EndBug> default : NRC_LOGE ( _tag , "deinit(%s):<S2SV_blank>invalid<S2SV_blank>state<S2SV_blank>%d" , self -> hdr . cfg_id , self -> state ) ; self -> state = NRC_N_SERIAL_IN_S_ERROR ; result = NRC_R_INVALID_STATE ; break ; } } return result ; }
|
<S2SV_ModStart> = NRC_N_SERIAL_IN_S_CREATED ; result = NRC_R_OK ;
|
6,611 |
CWE-000 <S2SV_StartBug> static int eeprom_write_ack_poll ( ) <S2SV_EndBug> { int tries = 5 ; chThdSleep ( MS2ST ( 10 ) ) ; while ( tries -- ) { uint8_t c ; if ( eeprom_read ( 0 , & c , 1 ) == 0 ) { return 0 ; } } return 1 ; }
|
<S2SV_ModStart> int eeprom_write_ack_poll ( void
|
6,612 |
CWE-000 <S2SV_StartBug> bool conform_rand ( float probability ) { <S2SV_EndBug> float next = rand ( ) / ( RAND_MAX + 1.0 ) ; if ( next < probability ) { return true ; } return false ; }
|
<S2SV_ModStart> probability ) { return true ;
|
6,613 |
CWE-000 char * get_data ( char * file_name , char * data ) { int file_desc ; int size ; if ( ( file_desc = open ( file_name , O_RDONLY ) ) < 1 ) return ( NULL ) ; if ( ( size = count_char ( file_desc ) ) < 0 ) { close ( file_desc ) ; return ( NULL ) ; } close ( file_desc ) ; <S2SV_StartBug> if ( ( file_desc = open ( file_name , O_RDONLY ) ) < 1 ) <S2SV_EndBug> return ( NULL ) ; data = ( char * ) malloc ( sizeof ( char ) * ( size + 1 ) ) ; if ( read ( file_desc , data , size ) < 0 ) return ( NULL ) ; <S2SV_StartBug> return ( data ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> file_desc ) ; printf ( "Size=%d<S2SV_blank>\\n\\n" , size ) ; <S2SV_ModStart> NULL ) ; data [ size ] = '\\0' ;
|
6,614 |
CWE-000 TEE_Result tee_fs_rpc_opendir ( uint32_t id , const TEE_UUID * uuid , struct tee_fs_dir * * d ) { TEE_Result res ; struct tee_fs_rpc_operation op = { . id = id , . num_params = 3 } ; struct mobj * mobj ; void * va ; uint64_t cookie ; struct tee_fs_dir * dir = calloc ( 1 , sizeof ( * dir ) ) ; if ( ! dir ) return TEE_ERROR_OUT_OF_MEMORY ; va = tee_fs_rpc_cache_alloc ( TEE_FS_NAME_MAX , & mobj , & cookie ) ; if ( ! va ) { res = TEE_ERROR_OUT_OF_MEMORY ; goto err_exit ; } op . params [ 0 ] . attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT ; op . params [ 0 ] . u . value . a = OPTEE_MRF_OPENDIR ; if ( ! msg_param_init_memparam ( op . params + 1 , mobj , 0 , TEE_FS_NAME_MAX , cookie , MSG_PARAM_MEM_DIR_IN ) ) <S2SV_StartBug> return TEE_ERROR_BAD_STATE ; <S2SV_EndBug> res = tee_svc_storage_create_dirname ( va , TEE_FS_NAME_MAX , uuid ) ; if ( res != TEE_SUCCESS ) <S2SV_StartBug> return res ; <S2SV_EndBug> op . params [ 2 ] . attr = OPTEE_MSG_ATTR_TYPE_VALUE_OUTPUT ; res = operation_commit ( & op ) ; if ( res != TEE_SUCCESS ) goto err_exit ; dir -> nw_dir = op . params [ 2 ] . u . value . a ; * d = dir ; return TEE_SUCCESS ; err_exit : free ( dir ) ; return res ; }
|
<S2SV_ModStart> MSG_PARAM_MEM_DIR_IN ) ) { res = TEE_ERROR_BAD_STATE ; goto err_exit ; } <S2SV_ModEnd> res = tee_svc_storage_create_dirname <S2SV_ModStart> != TEE_SUCCESS ) goto err_exit <S2SV_ModEnd> ; op .
|
6,615 |
CWE-000 REBARR * Gob_To_Array ( REBGOB * gob ) { REBARR * array = Make_Array ( 10 ) ; REBVAL * val ; REBSYM words [ ] = { SYM_OFFSET , SYM_SIZE , SYM_ALPHA , SYM_0 } ; REBVAL * vals [ 6 ] ; REBINT n = 0 ; REBVAL * val1 ; for ( n = 0 ; words [ n ] != SYM_0 ; ++ n ) { val = Alloc_Tail_Array ( array ) ; Init_Set_Word ( val , Canon ( words [ n ] ) ) ; vals [ n ] = Alloc_Tail_Array ( array ) ; SET_BLANK ( vals [ n ] ) ; } SET_PAIR ( vals [ 0 ] , GOB_X ( gob ) , GOB_Y ( gob ) ) ; SET_PAIR ( vals [ 1 ] , GOB_W ( gob ) , GOB_H ( gob ) ) ; SET_INTEGER ( vals [ 2 ] , GOB_ALPHA ( gob ) ) ; if ( ! GOB_TYPE ( gob ) ) return array ; if ( GOB_CONTENT ( gob ) ) { val1 = Alloc_Tail_Array ( array ) ; val = Alloc_Tail_Array ( array ) ; REBSYM sym ; switch ( GOB_TYPE ( gob ) ) { case GOBT_COLOR : sym = SYM_COLOR ; break ; case GOBT_IMAGE : sym = SYM_IMAGE ; break ; case GOBT_STRING : case GOBT_TEXT : sym = SYM_TEXT ; break ; case GOBT_DRAW : sym = SYM_DRAW ; break ; case GOBT_EFFECT : sym = SYM_EFFECT ; break ; <S2SV_StartBug> } <S2SV_EndBug> Init_Set_Word ( val1 , Canon ( sym ) ) ; Get_GOB_Var ( gob , val1 , val ) ; } return array ; }
|
<S2SV_ModStart> ; break ; default : fail ( Error_Misc_Raw ( ) ) ;
|
6,616 |
CWE-000 int main ( int argc , gchar * argv [ ] ) { funcOption fOptionAction = NULL ; if ( argc > 1 && checkOptions ( argv [ 1 ] , & fOptionAction ) && fOptionAction == onVersion ) onVersion ( ) ; gint i_all_ready_running = all_ready_running ( ) ; if ( i_all_ready_running == 1 ) { fprintf ( stderr , "Another<S2SV_blank>instance<S2SV_blank>is<S2SV_blank>already<S2SV_blank>running.\\n" ) ; exit ( EXIT_FAILURE ) ; } else if ( i_all_ready_running == 2 ) { fprintf ( stderr , "%s:<S2SV_blank>Error<S2SV_blank>in<S2SV_blank>routine<S2SV_blank>all_ready_running(),<S2SV_blank>" "will<S2SV_blank>quit.\\n" , argv [ 0 ] ) ; exit ( EXIT_FAILURE ) ; } if ( ! gtk_init_check ( & argc , & argv ) ) { fprintf ( stderr , "Error,<S2SV_blank>can\'t<S2SV_blank>initialize<S2SV_blank>gtk.\\n" ) ; exit ( EXIT_FAILURE ) ; } g_set_prgname ( PROGNAME ) ; gtk_window_set_default_icon_name ( PROGNAME ) ; guint i ; for ( i = 1 ; i < argc ; i ++ ) { if ( checkOptions ( argv [ i ] , NULL ) ) gl_nLastOption = i ; } argc -= gl_nLastOption ; argv += gl_nLastOption ; # if ! defined ( _GTKMENUPLUS_NO_FORMAT_ ) formattingInit ( & ( gl_FormattingSubMenu [ 0 ] ) , "\\0" , 0 ) ; # endif # if ! defined ( _GTKMENUPLUS_NO_FORMAT_ ) && ! defined ( _GTKMENUPLUS_NO_TOOLTIPS_ ) formattingInit ( & gl_FormattingTooltip , "\\0" , 0 ) ; # endif # if ! defined ( _GTKMENUPLUS_NO_LAUNCHERS_ ) * gl_sLauncherDirectory = '\\0' ; * gl_sLauncherArguments = '\\0' ; if ( regcomp ( & gl_rgxLauncherExecArg , gl_sLauncherExecArg , 0 ) ) <S2SV_StartBug> errorExit ( "failed<S2SV_blank>to<S2SV_blank>compile<S2SV_blank>regular<S2SV_blank>expression<S2SV_blank>for<S2SV_blank>launcher=" ) ; <S2SV_EndBug> # endif # if ! defined ( _GTKMENUPLUS_NO_ACTIVATION_LOG_ ) * gl_sActivationLogfile = '\\0' ; # endif if ( regcomp ( & gl_rgxIconExt , gl_sIconRegexPat , REG_EXTENDED | REG_ICASE ) ) <S2SV_StartBug> errorExit ( "failed<S2SV_blank>to<S2SV_blank>compile<S2SV_blank>regular<S2SV_blank>expression<S2SV_blank>for<S2SV_blank>icon<S2SV_blank>extensions" ) ; <S2SV_EndBug> if ( regcomp ( & gl_rgxUriSchema , gl_sUriSchema , REG_EXTENDED | REG_ICASE ) ) <S2SV_StartBug> errorExit ( "failed<S2SV_blank>to<S2SV_blank>compile<S2SV_blank>regular<S2SV_blank>expression<S2SV_blank>for<S2SV_blank>URI<S2SV_blank>schema" ) ; <S2SV_EndBug> if ( ! initPathRegex ( ) ) exit ( EXIT_FAILURE ) ; gl_uiCurItem = gl_uiCurDepth = 0 ; * gl_sScriptDirectory = * gl_sIconDirectory = * gl_sCmdLineConfig = '\\0' ; gchar * sFileName = get_cmdline_menu_desc_file ( argc , argv ) ; FILE * pFile = open_menu_desc_file ( sFileName ) ; if ( pFile == NULL && * gl_sCmdLineConfig == '\\0' ) exit ( EXIT_FAILURE ) ; if ( pFile ) { if ( ! initDirectory ( gl_sIconDirectory , MAX_PATH_LEN , sFileName ) ) exit ( EXIT_FAILURE ) ; strcpy ( gl_sScriptDirectory , gl_sIconDirectory ) ; # if ! defined ( _GTKMENUPLUS_NO_LAUNCHERS_ ) strcpy ( gl_sLauncherDirectory , gl_sScriptDirectory ) ; # endif } gl_gtkWmenu [ 0 ] = gtk_menu_new ( ) ; if ( ! gtk_icon_size_lookup ( GTK_ICON_SIZE_BUTTON , & gl_iW , & gl_iH ) ) gl_iW = gl_iH = 30 ; gl_sCmds = malloc ( gl_nMenuEntries * ( MAX_PATH_LEN + 1 ) * sizeof ( gchar ) ) ; if ( ! gl_sCmds ) errorExit ( "fatal<S2SV_blank>error:<S2SV_blank>can\'t<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>commands." ) ; memset ( gl_FormattingSubMenu , 0 , sizeof ( struct Formatting ) * MAX_SUBMENU_DEPTH ) ; if ( ! argv [ 1 ] || argv [ 1 ] [ 0 ] == '-' ) { argc = 0 ; } readFile ( pFile , argc , argv , FALSE , gl_bOptGatherComments , 0 , NULL ) ; # if ! defined ( _GTKMENUPLUS_NO_VARIABLES_ ) variablesClear ( ) ; # endif # if ! defined ( _GTKMENUPLUS_NO_LAUNCHERS_ ) regfree ( & gl_rgxLauncherExecArg ) ; # endif regfree ( & gl_rgxIconExt ) ; regfree ( & gl_rgxUriSchema ) ; <S2SV_StartBug> clearPathRegex ( ) ; <S2SV_EndBug> g_free ( gl_sCmds ) ; if ( gl_nHushedUpErrors ) fprintf ( stderr , "Error<S2SV_blank>messages<S2SV_blank>for<S2SV_blank>%d<S2SV_blank>lines<S2SV_blank>were<S2SV_blank>suppressed.<S2SV_blank>Rerun<S2SV_blank>with<S2SV_blank>option<S2SV_blank>-i<S2SV_blank>to<S2SV_blank>view.\\n" , gl_nHushedUpErrors ) ; if ( gl_nOptInfo == 1 ) fprintf ( stderr , "Adding<S2SV_blank>multiple<S2SV_blank>-i<S2SV_blank>options<S2SV_blank>may<S2SV_blank>give<S2SV_blank>you<S2SV_blank>more<S2SV_blank>information.\\n" ) ; return 0 ; }
|
<S2SV_ModStart> ) errorExit ( "failed<S2SV_blank>to<S2SV_blank>compile<S2SV_blank>regular<S2SV_blank>expression" <S2SV_ModEnd> ) ; # <S2SV_ModStart> ) errorExit ( "failed<S2SV_blank>to<S2SV_blank>compile<S2SV_blank>regular<S2SV_blank>expression" <S2SV_ModEnd> ) ; if <S2SV_ModStart> ) errorExit ( "failed<S2SV_blank>to<S2SV_blank>compile<S2SV_blank>regular<S2SV_blank>expression" ) ; # if ! defined ( _GTKMENUPLUS_NO_IF_ ) || ! defined ( _GTKMENUPLUS_NO_VARIABLES_ ) if ( regcomp ( & gl_rgxSharpIsntComment , gl_sSharpIsntComment , REG_EXTENDED | REG_ICASE ) ) errorExit ( "failed<S2SV_blank>to<S2SV_blank>compile<S2SV_blank>regular<S2SV_blank>expression" ) ; # endif <S2SV_ModEnd> if ( ! <S2SV_ModStart> gl_rgxUriSchema ) ; # if ! defined ( _GTKMENUPLUS_NO_IF_ ) || ! defined ( _GTKMENUPLUS_NO_VARIABLES_ ) regfree ( & gl_rgxSharpIsntComment ) ; # endif
|
6,617 |
CWE-000 static gboolean gst_vtdec_stop ( GstVideoDecoder * decoder ) { <S2SV_StartBug> GstVtdec * vtdec = GST_VTDEC ( decoder ) ; <S2SV_EndBug> if ( vtdec -> input_state ) gst_video_codec_state_unref ( vtdec -> input_state ) ; vtdec -> input_state = NULL ; if ( vtdec -> session ) gst_vtdec_invalidate_session ( vtdec ) ; if ( vtdec -> texture_cache ) gst_video_texture_cache_free ( vtdec -> texture_cache ) ; vtdec -> texture_cache = NULL ; GST_DEBUG_OBJECT ( vtdec , "stop" ) ; return TRUE ; }
|
<S2SV_ModStart> GST_VTDEC ( decoder ) ; gst_vtdec_push_frames_if_needed ( vtdec , TRUE , TRUE
|
6,618 |
CWE-000 static FILE * open_filename ( RASPIVID_STATE * pState , char * filename ) { FILE * new_handle = NULL ; char * tempname = NULL ; if ( pState -> segmentSize || pState -> splitWait ) { <S2SV_StartBug> if ( strstr ( filename , "%u" ) != NULL || strstr ( filename , "%d" ) != NULL ) <S2SV_EndBug> { asprintf ( & tempname , filename , pState -> segmentNumber ) ; } else { char temp_ts_str [ 100 ] ; time_t t = time ( NULL ) ; struct tm * tm = localtime ( & t ) ; strftime ( temp_ts_str , 100 , filename , tm ) ; asprintf ( & tempname , "%s" , temp_ts_str ) ; } filename = tempname ; } if ( filename ) { bool bNetwork = false ; int sfd = - 1 , socktype ; if ( ! strncmp ( "tcp://" , filename , 6 ) ) { bNetwork = true ; socktype = SOCK_STREAM ; } else if ( ! strncmp ( "udp://" , filename , 6 ) ) { if ( pState -> netListen ) { fprintf ( stderr , "No<S2SV_blank>support<S2SV_blank>for<S2SV_blank>listening<S2SV_blank>in<S2SV_blank>UDP<S2SV_blank>mode\\n" ) ; exit ( 131 ) ; } bNetwork = true ; socktype = SOCK_DGRAM ; } if ( bNetwork ) { unsigned short port ; filename += 6 ; char * colon ; if ( NULL == ( colon = strchr ( filename , ':' ) ) ) { fprintf ( stderr , "%s<S2SV_blank>is<S2SV_blank>not<S2SV_blank>a<S2SV_blank>valid<S2SV_blank>IPv4:port,<S2SV_blank>use<S2SV_blank>something<S2SV_blank>like<S2SV_blank>tcp://1.2.3.4:1234<S2SV_blank>or<S2SV_blank>udp://1.2.3.4:1234\\n" , filename ) ; exit ( 132 ) ; } if ( 1 != sscanf ( colon + 1 , "%hu" , & port ) ) { fprintf ( stderr , "Port<S2SV_blank>parse<S2SV_blank>failed.<S2SV_blank>%s<S2SV_blank>is<S2SV_blank>not<S2SV_blank>a<S2SV_blank>valid<S2SV_blank>network<S2SV_blank>file<S2SV_blank>name,<S2SV_blank>use<S2SV_blank>something<S2SV_blank>like<S2SV_blank>tcp://1.2.3.4:1234<S2SV_blank>or<S2SV_blank>udp://1.2.3.4:1234\\n" , filename ) ; exit ( 133 ) ; } char chTmp = * colon ; * colon = 0 ; struct sockaddr_in saddr = { } ; saddr . sin_family = AF_INET ; saddr . sin_port = htons ( port ) ; if ( 0 == inet_aton ( filename , & saddr . sin_addr ) ) { fprintf ( stderr , "inet_aton<S2SV_blank>failed.<S2SV_blank>%s<S2SV_blank>is<S2SV_blank>not<S2SV_blank>a<S2SV_blank>valid<S2SV_blank>IPv4<S2SV_blank>address\\n" , filename ) ; exit ( 134 ) ; } * colon = chTmp ; if ( pState -> netListen ) { int sockListen = socket ( AF_INET , SOCK_STREAM , 0 ) ; if ( sockListen >= 0 ) { int iTmp = 1 ; setsockopt ( sockListen , SOL_SOCKET , SO_REUSEADDR , & iTmp , sizeof ( int ) ) ; if ( bind ( sockListen , ( struct sockaddr * ) & saddr , sizeof ( saddr ) ) >= 0 ) { while ( ( - 1 == ( iTmp = listen ( sockListen , 0 ) ) ) && ( EINTR == errno ) ) ; if ( - 1 != iTmp ) { fprintf ( stderr , "Waiting<S2SV_blank>for<S2SV_blank>a<S2SV_blank>TCP<S2SV_blank>connection<S2SV_blank>on<S2SV_blank>%s:%" SCNu16 "..." , inet_ntoa ( saddr . sin_addr ) , ntohs ( saddr . sin_port ) ) ; struct sockaddr_in cli_addr ; socklen_t clilen = sizeof ( cli_addr ) ; while ( ( - 1 == ( sfd = accept ( sockListen , ( struct sockaddr * ) & cli_addr , & clilen ) ) ) && ( EINTR == errno ) ) ; if ( sfd >= 0 ) fprintf ( stderr , "Client<S2SV_blank>connected<S2SV_blank>from<S2SV_blank>%s:%" SCNu16 "\\n" , inet_ntoa ( cli_addr . sin_addr ) , ntohs ( cli_addr . sin_port ) ) ; else fprintf ( stderr , "Error<S2SV_blank>on<S2SV_blank>accept:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; } else { fprintf ( stderr , "Error<S2SV_blank>trying<S2SV_blank>to<S2SV_blank>listen<S2SV_blank>on<S2SV_blank>a<S2SV_blank>socket:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; } } else { fprintf ( stderr , "Error<S2SV_blank>on<S2SV_blank>binding<S2SV_blank>socket:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; } } else { fprintf ( stderr , "Error<S2SV_blank>creating<S2SV_blank>socket:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; } if ( sockListen >= 0 ) close ( sockListen ) ; } else { if ( 0 <= ( sfd = socket ( AF_INET , socktype , 0 ) ) ) { fprintf ( stderr , "Connecting<S2SV_blank>to<S2SV_blank>%s:%hu..." , inet_ntoa ( saddr . sin_addr ) , port ) ; int iTmp = 1 ; while ( ( - 1 == ( iTmp = connect ( sfd , ( struct sockaddr * ) & saddr , sizeof ( struct sockaddr_in ) ) ) ) && ( EINTR == errno ) ) ; if ( iTmp < 0 ) fprintf ( stderr , "error:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; else fprintf ( stderr , "connected,<S2SV_blank>sending<S2SV_blank>video...\\n" ) ; } else fprintf ( stderr , "Error<S2SV_blank>creating<S2SV_blank>socket:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; } if ( sfd >= 0 ) new_handle = fdopen ( sfd , "w" ) ; } else { new_handle = fopen ( filename , "wb" ) ; } } if ( pState -> verbose ) { if ( new_handle ) fprintf ( stderr , "Opening<S2SV_blank>output<S2SV_blank>file<S2SV_blank>\\"%s\\"\\n" , filename ) ; else fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>new<S2SV_blank>file<S2SV_blank>\\"%s\\"\\n" , filename ) ; } if ( tempname ) free ( tempname ) ; return new_handle ; }
|
<S2SV_ModStart> splitWait ) { bool bSegmentNumber = false ; const char * pPercent = <S2SV_ModEnd> strstr ( filename <S2SV_ModStart> ( filename , "%" ) ; if ( pPercent ) { pPercent ++ ; while ( * pPercent != '\\0' && isdigit ( * pPercent ) ) pPercent ++ ; if ( * pPercent == 'u' || * pPercent == 'd' ) bSegmentNumber = true ; } if ( bSegmentNumber <S2SV_ModEnd> ) { asprintf
|
6,619 |
CWE-000 int MPI_Allgatherv ( void * sendbuf , int sendcount , MPI_Datatype sendtype , void * recvbuf , int * recvcounts , int * displs , MPI_Datatype recvtype , MPI_Comm comm ) { <S2SV_StartBug> return MPI_SUCCESS ; <S2SV_EndBug> }
|
<S2SV_ModStart> comm ) { memcpy ( recvbuf , sendbuf , datasize ( sendtype ) * sendcount ) ;
|
6,620 |
CWE-000 EVENT_HANDLER ( frame_arrived ) { Segment buffer ; int link ; size_t length ; length = MAX_MESSAGE_SIZE ; CHECK ( CNET_read_physical ( & link , & buffer , & length ) ) ; uint32_t crc , post_crc ; crc = buffer . header . crc ; buffer . header . crc = 0 ; post_crc = CNET_crc32 ( ( unsigned char * ) & buffer , length ) ; if ( post_crc != crc ) { printf ( "Checksums<S2SV_blank>are<S2SV_blank>not<S2SV_blank>equal,<S2SV_blank>allowing<S2SV_blank>timeout.\\n" ) ; return ; } switch ( buffer . header . type ) { case DataSegment : printf ( "Received<S2SV_blank>data<S2SV_blank>segment<S2SV_blank>of<S2SV_blank>size:<S2SV_blank>%d.\\n" , length ) ; if ( buffer . header . sequence_number == expected ) { <S2SV_StartBug> CNET_stop_timer ( EV_TIMER1 ) ; <S2SV_EndBug> length = buffer . header . length ; <S2SV_StartBug> CHECK ( CNET_write_application ( ( unsigned char * ) & buffer . data , & length ) ) ; <S2SV_EndBug> expected ++ ; SegmentHeader header = { } ; header . type = AcknowledgementSegment ; header . sequence_number = expected ; header . length = 0 ; header . crc = 0 ; ack_buffer . header = header ; uint8_t nil [ MAX_MESSAGE_SIZE ] = { 0 } ; memcpy ( & ack_buffer . data , nil , header . length ) ; length = ack_buffer . header . length + sizeof ( SegmentHeader ) ; ack_buffer . header . crc = CNET_crc32 ( ( unsigned char * ) & ack_buffer , length ) ; printf ( "Sending<S2SV_blank>acknowledgment<S2SV_blank>of<S2SV_blank>size:<S2SV_blank>%d.<S2SV_blank>Exp<S2SV_blank>number:<S2SV_blank>%d.\\n" , length , expected ) ; <S2SV_StartBug> CHECK ( CNET_write_physical ( 1 , ( char * ) & ack_buffer , & length ) ) ; <S2SV_EndBug> CNET_start_timer ( EV_TIMER1 , 5000000 , 0 ) ; } break ; case AcknowledgementSegment : printf ( "Received<S2SV_blank>acknowledgment<S2SV_blank>segment<S2SV_blank>of<S2SV_blank>size:<S2SV_blank>%d.\\n" , length ) ; if ( buffer . header . sequence_number == transmitted ) { <S2SV_StartBug> printf ( "received<S2SV_blank>acknowledgment,<S2SV_blank>stopping<S2SV_blank>timer\\n" ) ; <S2SV_EndBug> CNET_stop_timer ( EV_TIMER0 ) ; <S2SV_StartBug> CNET_enable_application ( ALLNODES ) ; <S2SV_EndBug> } break ; default : printf ( "Received<S2SV_blank>an<S2SV_blank>unsupported<S2SV_blank>frame<S2SV_blank>type.\\n" ) ; } }
|
<S2SV_ModStart> expected ) { if ( NULLTIMER != reack_buffer_timer ) CHECK ( CNET_stop_timer ( reack_buffer_timer ) <S2SV_ModEnd> ) ; length <S2SV_ModStart> ( CNET_write_application ( <S2SV_ModEnd> & buffer . <S2SV_ModStart> ( 1 , & ack_buffer , & length ) ) ; reack_buffer_timer = <S2SV_ModEnd> CNET_start_timer ( EV_TIMER1 <S2SV_ModStart> transmitted ) { if ( NULLTIMER != retransmit_timer ) CHECK ( CNET_stop_timer ( retransmit_timer ) ) ; if ( nodeinfo . nodenumber == 0 ) CHECK ( <S2SV_ModEnd> CNET_enable_application ( ALLNODES <S2SV_ModStart> CNET_enable_application ( ALLNODES )
|
6,621 |
CWE-000 void ir_Remote_task ( void * param ) { ir_rx_init ( ) ; ir_tx_init ( 38000 ) ; while ( 1 ) { <S2SV_StartBug> printf ( "\\n%s" , __func__ ) ; <S2SV_EndBug> if ( receiveFlag ) { receiveFlag = 0 ; printf ( "\\nIr<S2SV_blank>Code<S2SV_blank>received" ) ; <S2SV_StartBug> for ( int i = 0 ; i < codeLen ; i ++ ) <S2SV_EndBug> { printf ( "\\n[%2d]-%d" , i , code [ i ] ) ; } ir_send_pronto ( code ) ; printf ( "\\nDone<S2SV_blank>Sending" ) ; } <S2SV_StartBug> vTaskDelay ( 1000 / portTICK_RATE_MS ) ; <S2SV_EndBug> } }
|
<S2SV_ModStart> 1 ) { <S2SV_ModEnd> if ( receiveFlag <S2SV_ModStart> "\\nIr<S2SV_blank>Code<S2SV_blank>received" ) ; <S2SV_ModEnd> ir_send_pronto ( code <S2SV_ModStart> } vTaskDelay ( 80 <S2SV_ModEnd> / portTICK_RATE_MS )
|
6,622 |
CWE-000 int gpg_install ( unsigned char app_state ) { gpg_pin_t pin ; unsigned int l ; unsigned char config [ 4 ] ; gpg_nvm_write ( N_gpg_pstate , NULL , sizeof ( gpg_nv_state_t ) ) ; os_memmove ( G_gpg_vstate . work . io_buffer , C_default_Histo , sizeof ( C_default_Histo ) ) ; G_gpg_vstate . work . io_buffer [ 7 ] = app_state ; gpg_nvm_write ( N_gpg_pstate -> histo , G_gpg_vstate . work . io_buffer , sizeof ( C_default_Histo ) ) ; os_memmove ( G_gpg_vstate . work . io_buffer , C_default_AID , sizeof ( C_default_AID ) ) ; cx_rng ( G_gpg_vstate . work . io_buffer + 10 , 4 ) ; <S2SV_StartBug> G_gpg_vstate . work . io_buffer [ 13 ] &= 0x07 ; <S2SV_EndBug> gpg_nvm_write ( N_gpg_pstate -> AID , & G_gpg_vstate . work . io_buffer , sizeof ( C_default_AID ) ) ; if ( app_state == STATE_ACTIVATE ) { G_gpg_vstate . work . io_buffer [ 0 ] = 0x39 ; gpg_nvm_write ( & N_gpg_pstate -> sex , G_gpg_vstate . work . io_buffer , 1 ) ; os_memmove ( pin . value , C_sha256_PW1 , sizeof ( C_sha256_PW1 ) ) ; pin . length = 6 ; pin . counter = 3 ; gpg_nvm_write ( & N_gpg_pstate -> PW1 , & pin , sizeof ( gpg_pin_t ) ) ; os_memmove ( pin . value , C_sha256_PW2 , sizeof ( C_sha256_PW2 ) ) ; pin . length = 8 ; pin . counter = 3 ; gpg_nvm_write ( & N_gpg_pstate -> PW3 , & pin , sizeof ( gpg_pin_t ) ) ; G_gpg_vstate . work . io_buffer [ 0 ] = 1 ; G_gpg_vstate . work . io_buffer [ 1 ] = GPG_MAX_PW_LENGTH ; G_gpg_vstate . work . io_buffer [ 2 ] = GPG_MAX_PW_LENGTH ; G_gpg_vstate . work . io_buffer [ 3 ] = GPG_MAX_PW_LENGTH ; gpg_nvm_write ( & N_gpg_pstate -> PW_status , G_gpg_vstate . work . io_buffer , 4 ) ; config [ 0 ] = GPG_KEYS_SLOTS ; config [ 1 ] = 0 ; config [ 2 ] = 3 ; for ( int s = 0 ; s < GPG_KEYS_SLOTS ; s ++ ) { # if 1 l = sizeof ( C_default_AlgoAttrRSA ) ; gpg_nvm_write ( & N_gpg_pstate -> keys [ s ] . sig . attributes . value , ( void * ) C_default_AlgoAttrRSA , l ) ; gpg_nvm_write ( & N_gpg_pstate -> keys [ s ] . sig . attributes . length , & l , sizeof ( unsigned int ) ) ; gpg_nvm_write ( & N_gpg_pstate -> keys [ s ] . aut . attributes . value , ( void * ) C_default_AlgoAttrRSA , l ) ; gpg_nvm_write ( & N_gpg_pstate -> keys [ s ] . aut . attributes . length , & l , sizeof ( unsigned int ) ) ; gpg_nvm_write ( & N_gpg_pstate -> keys [ s ] . dec . attributes . value , ( void * ) C_default_AlgoAttrRSA , l ) ; gpg_nvm_write ( & N_gpg_pstate -> keys [ s ] . dec . attributes . length , & l , sizeof ( unsigned int ) ) ; # else l = sizeof ( C_default_AlgoAttrECC_sig ) ; gpg_nvm_write ( & N_gpg_pstate -> keys [ s ] . sig . attributes . value , ( void * ) C_default_AlgoAttrECC_sig , l ) ; gpg_nvm_write ( & N_gpg_pstate -> keys [ s ] . sig . attributes . length , & l , sizeof ( unsigned int ) ) ; gpg_nvm_write ( & N_gpg_pstate -> keys [ s ] . aut . attributes . value , ( void * ) C_default_AlgoAttrECC_sig , l ) ; gpg_nvm_write ( & N_gpg_pstate -> keys [ s ] . aut . attributes . length , & l , sizeof ( unsigned int ) ) ; l = sizeof ( C_default_AlgoAttrECC_dec ) ; gpg_nvm_write ( & N_gpg_pstate -> keys [ s ] . dec . attributes . value , ( void * ) C_default_AlgoAttrECC_dec , l ) ; gpg_nvm_write ( & N_gpg_pstate -> keys [ s ] . dec . attributes . length , & l , sizeof ( unsigned int ) ) ; # endif } } return 0 ; }
|
<S2SV_ModStart> 13 ] &= ~
|
6,623 |
CWE-000 static int windows_compute_revents ( HANDLE h , int * p_sought ) { int i , ret , happened ; INPUT_RECORD * irbuffer ; DWORD avail , nbuffer ; BOOL bRet ; IO_STATUS_BLOCK iosb ; FILE_PIPE_LOCAL_INFORMATION fpli ; static PNtQueryInformationFile NtQueryInformationFile ; static BOOL once_only ; switch ( GetFileType ( h ) ) { case FILE_TYPE_PIPE : if ( ! once_only ) { NtQueryInformationFile = ( PNtQueryInformationFile ) <S2SV_StartBug> GetProcAddress ( GetModuleHandle ( "ntdll.dll" ) , <S2SV_EndBug> "NtQueryInformationFile" ) ; once_only = TRUE ; } happened = 0 ; if ( PeekNamedPipe ( h , NULL , 0 , NULL , & avail , NULL ) != 0 ) { if ( avail ) happened |= * p_sought & ( POLLIN | POLLRDNORM ) ; } else if ( GetLastError ( ) == ERROR_BROKEN_PIPE ) happened |= POLLHUP ; else { memset ( & iosb , 0 , sizeof ( iosb ) ) ; memset ( & fpli , 0 , sizeof ( fpli ) ) ; if ( ! NtQueryInformationFile || NtQueryInformationFile ( h , & iosb , & fpli , sizeof ( fpli ) , FilePipeLocalInformation ) || fpli . WriteQuotaAvailable >= PIPE_BUF || ( fpli . OutboundQuota < PIPE_BUF && fpli . WriteQuotaAvailable == fpli . OutboundQuota ) ) <S2SV_StartBug> happened |= * p_sought & ( POLLOUT | POLLWRNORM | POLLWRBAND ) ; <S2SV_EndBug> } return happened ; case FILE_TYPE_CHAR : ret = WaitForSingleObject ( h , 0 ) ; if ( ! IsConsoleHandle ( h ) ) return ret == WAIT_OBJECT_0 ? * p_sought & ~ ( POLLPRI | POLLRDBAND ) : 0 ; nbuffer = avail = 0 ; bRet = GetNumberOfConsoleInputEvents ( h , & nbuffer ) ; if ( bRet ) { * p_sought &= POLLIN | POLLRDNORM ; if ( nbuffer == 0 ) return POLLHUP ; if ( ! * p_sought ) return 0 ; <S2SV_StartBug> irbuffer = ( INPUT_RECORD * ) alloca ( nbuffer * sizeof ( INPUT_RECORD ) ) ; <S2SV_EndBug> bRet = PeekConsoleInput ( h , irbuffer , nbuffer , & avail ) ; if ( ! bRet || avail == 0 ) return POLLHUP ; for ( i = 0 ; i < avail ; i ++ ) if ( irbuffer [ i ] . EventType == KEY_EVENT ) return * p_sought ; return 0 ; } else { * p_sought &= POLLOUT | POLLWRNORM | POLLWRBAND ; return * p_sought ; } default : ret = WaitForSingleObject ( h , 0 ) ; if ( ret == WAIT_OBJECT_0 ) return * p_sought & ~ ( POLLPRI | POLLRDBAND ) ; return * p_sought & ( POLLOUT | POLLWRNORM | POLLWRBAND ) ; } }
|
<S2SV_ModStart> ( GetModuleHandle ( TEXT ( "ntdll.dll" ) ) , <S2SV_ModEnd> "NtQueryInformationFile" ) ; <S2SV_ModStart> OutboundQuota ) ) { <S2SV_ModStart> POLLWRBAND ) ; } <S2SV_ModStart> INPUT_RECORD * ) _alloca <S2SV_ModEnd> ( nbuffer *
|
6,624 |
CWE-000 int mlx5e_napi_poll ( struct napi_struct * napi , int budget ) { struct mlx5e_channel * c = container_of ( napi , struct mlx5e_channel , napi ) ; bool busy = false ; int work_done = 0 ; int i ; for ( i = 0 ; i < c -> num_tc ; i ++ ) busy |= mlx5e_poll_tx_cq ( & c -> sq [ i ] . cq , budget ) ; if ( c -> xdp ) busy |= mlx5e_poll_xdpsq_cq ( & c -> rq . xdpsq . cq ) ; if ( likely ( budget ) ) { work_done = mlx5e_poll_rx_cq ( & c -> rq . cq , budget ) ; busy |= work_done == budget ; } busy |= c -> rq . post_wqes ( & c -> rq ) ; if ( busy ) { if ( likely ( mlx5e_channel_no_affinity_change ( c ) ) ) return budget ; if ( budget && work_done == budget ) work_done -- ; } if ( unlikely ( ! napi_complete_done ( napi , work_done ) ) ) return work_done ; for ( i = 0 ; i < c -> num_tc ; i ++ ) <S2SV_StartBug> mlx5e_cq_arm ( & c -> sq [ i ] . cq ) ; <S2SV_EndBug> if ( MLX5E_TEST_BIT ( c -> rq . state , MLX5E_RQ_STATE_AM ) ) { struct net_dim_sample dim_sample ; net_dim_sample ( c -> rq . cq . event_ctr , c -> rq . stats . packets , c -> rq . stats . bytes , & dim_sample ) ; net_dim ( & c -> rq . dim , dim_sample ) ; } <S2SV_StartBug> mlx5e_cq_arm ( & c -> rq . cq ) ; <S2SV_EndBug> <S2SV_StartBug> mlx5e_cq_arm ( & c -> icosq . cq ) ; <S2SV_EndBug> return work_done ; }
|
<S2SV_ModStart> i ++ ) { mlx5e_handle_tx_dim <S2SV_ModEnd> ( & c <S2SV_ModStart> [ i ] ) ; <S2SV_ModEnd> mlx5e_cq_arm ( & <S2SV_ModStart> & c -> sq [ i ] . cq ) ; } mlx5e_handle_rx_dim ( & c -> rq <S2SV_ModEnd> ) ; mlx5e_cq_arm <S2SV_ModStart> & c -> rq . cq ) ; mlx5e_cq_arm ( & c ->
|
6,625 |
CWE-000 static int vega12_get_dpm_frequency_by_index ( struct pp_hwmgr * hwmgr , PPCLK_e clkID , uint32_t index , uint32_t * clock ) { <S2SV_StartBug> int result ; <S2SV_EndBug> PP_ASSERT_WITH_CODE ( smum_send_msg_to_smc_with_parameter ( hwmgr , PPSMC_MSG_GetDpmFreqByIndex , ( clkID << 16 | index ) ) == 0 , "[GetDpmFrequencyByIndex]<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>dpm<S2SV_blank>frequency<S2SV_blank>from<S2SV_blank>SMU!" , return - EINVAL ) ; * clock = smum_get_argument ( hwmgr ) ; return result ; }
|
<S2SV_ModStart> { int result = 0
|
6,626 |
CWE-000 static void connect_setup ( MVMThreadContext * tc , uv_loop_t * loop , MVMObject * async_task , void * data ) { int r ; ConnectInfo * ci = ( ConnectInfo * ) data ; ci -> tc = tc ; ci -> work_idx = MVM_repr_elems ( tc , tc -> instance -> event_loop_active ) ; MVM_repr_push_o ( tc , tc -> instance -> event_loop_active , async_task ) ; ci -> socket = MVM_malloc ( sizeof ( uv_tcp_t ) ) ; ci -> connect = MVM_malloc ( sizeof ( uv_connect_t ) ) ; ci -> connect -> data = data ; if ( ( r = uv_tcp_init ( loop , ci -> socket ) ) < 0 || ( r = uv_tcp_connect ( ci -> connect , ci -> socket , ci -> dest , on_connect ) ) < 0 ) { MVMROOT ( tc , async_task , { MVMObject * arr = MVM_repr_alloc_init ( tc , tc -> instance -> boot_types . BOOTArray ) ; MVMAsyncTask * t = ( MVMAsyncTask * ) async_task ; MVM_repr_push_o ( tc , arr , t -> body . schedulee ) ; MVM_repr_push_o ( tc , arr , tc -> instance -> boot_types . BOOTIO ) ; MVMROOT ( tc , arr , { MVMString * msg_str = MVM_string_ascii_decode_nt ( tc , tc -> instance -> VMString , uv_strerror ( r ) ) ; MVMObject * msg_box = MVM_repr_box_str ( tc , tc -> instance -> boot_types . BOOTStr , msg_str ) ; MVM_repr_push_o ( tc , arr , msg_box ) ; } ) ; MVM_repr_push_o ( tc , t -> body . queue , arr ) ; } ) ; <S2SV_StartBug> MVM_free ( ci -> socket ) ; <S2SV_EndBug> ci -> socket = NULL ; <S2SV_StartBug> MVM_free ( ci -> connect ) ; <S2SV_EndBug> ci -> connect = NULL ; } }
|
<S2SV_ModStart> ( ci -> connect ) ; ci -> connect <S2SV_ModEnd> = NULL ; <S2SV_ModStart> = NULL ; uv_close ( ( uv_handle_t * ) ci -> socket , free_on_close_cb ) ; ci -> socket <S2SV_ModEnd> = NULL ;
|
6,627 |
CWE-000 void display ( char * * str , coord_t size ) { for ( int i = 0 ; i < size . lines ; i ++ ) my_putstr ( str [ i ] ) ; <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> ] ) ; if ( str [ size . lines - 1 ] [ size . cols ] == '\\0' ) my_putchar ( '\\n' ) ;
|
6,628 |
CWE-000 void begin_value ( jit_gencode_t gen , _jit_regs_t * regs , jit_insn_t insn , short mask , int i , jit_value_t value , _jit_live_range_t range , int is_dest ) { <S2SV_StartBug> if ( ( insn -> flags & mask ) != 0 || value == 0 || regs -> descs [ i ] . value == 0 ) <S2SV_EndBug> { return ; } if ( value -> is_constant ) { if ( regs -> descs [ i ] . reg == - 1 ) { assert ( range != 0 ) ; regs -> descs [ i ] . reg = find_reg_in_colors ( range -> colors ) ; } _jit_gen_load_value ( gen , regs -> descs [ i ] . reg , regs -> descs [ i ] . other_reg , value ) ; } else if ( ! value -> in_register ) { assert ( range != 0 && range -> is_spill_range ) ; if ( regs -> descs [ i ] . reg == - 1 ) { regs -> descs [ i ] . reg = find_reg_in_colors ( range -> colors ) ; } if ( ! is_dest ) { _jit_gen_load_value ( gen , regs -> descs [ i ] . reg , regs -> descs [ i ] . other_reg , value ) ; } } else { if ( regs -> descs [ i ] . reg == - 1 ) { regs -> descs [ i ] . reg = value -> reg ; } else if ( regs -> descs [ i ] . reg != value -> reg ) { _jit_gen_load_value ( gen , regs -> descs [ i ] . reg , regs -> descs [ i ] . other_reg , value ) ; } } }
|
<S2SV_ModStart> value == 0 || get_type_index ( value ) == 0
|
6,629 |
CWE-000 int main ( ) { void * p = heap_init ( 4096 ) ; if ( p == NULL ) { fprintf ( stderr , "%s" , "Cannot<S2SV_blank>initialize<S2SV_blank>heap!" ) ; return 1 ; } int * pointers [ 80 ] ; for ( size_t i = 20 ; i < 100 ; ++ i ) { pointers [ i - 20 ] = _malloc ( i ) ; * pointers [ i - 20 ] = ( int ) i ; if ( ! pointers [ i - 20 ] ) break ; } FILE * f = fopen ( "heap.txt" , "w" ) ; malloc_debug_heap ( f , p ) ; <S2SV_StartBug> for ( int i = 20 ; i < 100 ; ++ i ) { <S2SV_EndBug> _free ( pointers [ i - 20 ] ) ; } f = fopen ( "heap_after_free.txt" , "w" ) ; malloc_debug_heap ( f , p ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> }
|
<S2SV_ModStart> p ) ; puts ( "Debug<S2SV_blank>file<S2SV_blank>\\"heap.txt\\"<S2SV_blank>created.<S2SV_blank>(After<S2SV_blank>allocating)" ) ; fclose ( f ) ; <S2SV_ModStart> p ) ; puts ( "Debug<S2SV_blank>file<S2SV_blank>\\"heap_after_free.txt\\"<S2SV_blank>created.<S2SV_blank>(After<S2SV_blank>free)" ) ; fclose ( f ) ;
|
6,630 |
CWE-000 void * sqlite3Realloc ( void * pOld , u64 nBytes ) { int nOld , nNew , nDiff ; void * pNew ; assert ( sqlite3MemdebugHasType ( pOld , MEMTYPE_HEAP ) ) ; <S2SV_StartBug> assert ( sqlite3MemdebugNoType ( pOld , ~ MEMTYPE_HEAP ) ) ; <S2SV_EndBug> if ( pOld == 0 ) { return sqlite3Malloc ( nBytes ) ; } if ( nBytes == 0 ) { sqlite3_free ( pOld ) ; return 0 ; } if ( nBytes >= 0x7fffff00 ) { return 0 ; } nOld = sqlite3MallocSize ( pOld ) ; nNew = sqlite3GlobalConfig . m . xRoundup ( ( int ) nBytes ) ; if ( nOld == nNew ) { pNew = pOld ; } else if ( sqlite3GlobalConfig . bMemstat ) { sqlite3_mutex_enter ( mem0 . mutex ) ; sqlite3StatusSet ( SQLITE_STATUS_MALLOC_SIZE , ( int ) nBytes ) ; nDiff = nNew - nOld ; if ( sqlite3StatusValue ( SQLITE_STATUS_MEMORY_USED ) >= mem0 . alarmThreshold - nDiff ) { sqlite3MallocAlarm ( nDiff ) ; } pNew = sqlite3GlobalConfig . m . xRealloc ( pOld , nNew ) ; if ( pNew == 0 && mem0 . alarmCallback ) { sqlite3MallocAlarm ( ( int ) nBytes ) ; pNew = sqlite3GlobalConfig . m . xRealloc ( pOld , nNew ) ; } if ( pNew ) { nNew = sqlite3MallocSize ( pNew ) ; sqlite3StatusAdd ( SQLITE_STATUS_MEMORY_USED , nNew - nOld ) ; } sqlite3_mutex_leave ( mem0 . mutex ) ; } else { pNew = sqlite3GlobalConfig . m . xRealloc ( pOld , nNew ) ; } assert ( EIGHT_BYTE_ALIGNMENT ( pNew ) ) ; return pNew ; }
|
<S2SV_ModStart> ( pOld , ( u8 )
|
6,631 |
CWE-000 void janus_videoroom_hangup_media ( janus_plugin_session * handle ) { JANUS_LOG ( LOG_INFO , "No<S2SV_blank>WebRTC<S2SV_blank>media<S2SV_blank>anymore\\n" ) ; if ( g_atomic_int_get ( & stopping ) || ! g_atomic_int_get ( & initialized ) ) return ; janus_videoroom_session * session = ( janus_videoroom_session * ) handle -> plugin_handle ; if ( ! session ) { JANUS_LOG ( LOG_ERR , "No<S2SV_blank>session<S2SV_blank>associated<S2SV_blank>with<S2SV_blank>this<S2SV_blank>handle...\\n" ) ; return ; } session -> started = FALSE ; if ( session -> destroyed ) return ; if ( g_atomic_int_add ( & session -> hangingup , 1 ) ) return ; if ( session -> participant_type == janus_videoroom_p_type_publisher ) { janus_videoroom_participant * participant = ( janus_videoroom_participant * ) session -> participant ; if ( participant -> sdp ) g_free ( participant -> sdp ) ; participant -> sdp = NULL ; participant -> firefox = FALSE ; participant -> audio_active = FALSE ; participant -> video_active = FALSE ; participant -> remb_startup = 4 ; participant -> remb_latest = 0 ; participant -> fir_latest = 0 ; participant -> fir_seq = 0 ; char request [ 100 ] ; <S2SV_StartBug> if ( participant -> listeners ) { <S2SV_EndBug> <S2SV_StartBug> guint64 room_id = * ( ( guint64 * ) participant -> room -> room_id ) ; <S2SV_EndBug> <S2SV_StartBug> g_snprintf ( request , sizeof ( request ) , "{\\"event\\":\\"unpublished\\",\\"transaction\\":\\"internal\\",\\"room\\":%" SCNu64 "}" , room_id ) ; <S2SV_EndBug> g_slist_foreach ( participant -> listeners , janus_videoroom_relay_data_packet , request ) ; } janus_mutex_lock ( & participant -> rec_mutex ) ; janus_videoroom_recorder_close ( participant ) ; janus_mutex_unlock ( & participant -> rec_mutex ) ; janus_mutex_lock ( & participant -> listeners_mutex ) ; while ( participant -> listeners ) { janus_videoroom_listener * l = ( janus_videoroom_listener * ) participant -> listeners -> data ; if ( l ) { participant -> listeners = g_slist_remove ( participant -> listeners , l ) ; l -> feed = NULL ; } } janus_mutex_unlock ( & participant -> listeners_mutex ) ; janus_videoroom_leave_or_unpublish ( participant , FALSE ) ; if ( participant -> room && gateway -> events_is_enabled ( ) ) { json_t * info = json_object ( ) ; json_object_set_new ( info , "event" , json_string ( "unpublished" ) ) ; json_object_set_new ( info , "room" , json_integer ( participant -> room -> room_id ) ) ; json_object_set_new ( info , "id" , json_integer ( participant -> user_id ) ) ; gateway -> notify_event ( & janus_videoroom_plugin , handle , info ) ; } } else if ( session -> participant_type == janus_videoroom_p_type_subscriber ) { janus_videoroom_listener * listener = ( janus_videoroom_listener * ) session -> participant ; if ( listener ) { listener -> paused = TRUE ; janus_videoroom_participant * publisher = listener -> feed ; if ( publisher != NULL ) { janus_mutex_lock ( & publisher -> listeners_mutex ) ; publisher -> listeners = g_slist_remove ( publisher -> listeners , listener ) ; janus_mutex_unlock ( & publisher -> listeners_mutex ) ; listener -> feed = NULL ; if ( notify_events && gateway -> events_is_enabled ( ) ) { json_t * info = json_object ( ) ; json_object_set_new ( info , "event" , json_string ( "unsubscribed" ) ) ; json_object_set_new ( info , "room" , json_integer ( publisher -> room -> room_id ) ) ; json_object_set_new ( info , "feed" , json_integer ( publisher -> user_id ) ) ; gateway -> notify_event ( & janus_videoroom_plugin , session -> handle , info ) ; } } } } else if ( session -> participant_type == janus_videoroom_p_type_subscriber_muxed ) { janus_videoroom_listener_muxed * listener = ( janus_videoroom_listener_muxed * ) session -> participant ; GSList * ps = listener -> listeners ; while ( ps ) { janus_videoroom_listener * l = ( janus_videoroom_listener * ) ps -> data ; if ( l ) { l -> paused = TRUE ; janus_videoroom_participant * publisher = l -> feed ; if ( publisher != NULL ) { janus_mutex_lock ( & publisher -> listeners_mutex ) ; publisher -> listeners = g_slist_remove ( publisher -> listeners , l ) ; janus_mutex_unlock ( & publisher -> listeners_mutex ) ; l -> feed = NULL ; } } ps = ps -> next ; } } }
|
<S2SV_ModStart> participant -> listeners && <S2SV_ModEnd> participant -> room <S2SV_ModStart> participant -> room ) { <S2SV_ModEnd> g_snprintf ( request <S2SV_ModStart> SCNu64 "}" , participant -> room ->
|
6,632 |
CWE-000 static gboolean hide_message ( OlOsdModule * osd ) { ol_log_func ( ) ; ol_assert_ret ( osd != NULL , FALSE ) ; <S2SV_StartBug> if ( osd -> lrc != NULL ) <S2SV_EndBug> return FALSE ; ol_osd_window_set_lyric ( osd -> window , 0 , NULL ) ; osd -> message_source = 0 ; return FALSE ; }
|
<S2SV_ModStart> FALSE ) ; ol_assert_ret <S2SV_ModEnd> ( osd -> <S2SV_ModStart> osd -> lrc == NULL , FALSE ) <S2SV_ModEnd> ; ol_osd_window_set_lyric (
|
6,633 |
CWE-000 int nd_btt_probe ( struct device * dev , struct nd_namespace_common * ndns ) { int rc ; struct device * btt_dev ; struct btt_sb * btt_sb ; struct nd_region * nd_region = to_nd_region ( ndns -> dev . parent ) ; if ( ndns -> force_raw ) return - ENODEV ; nvdimm_bus_lock ( & ndns -> dev ) ; btt_dev = __nd_btt_create ( nd_region , 0 , NULL , ndns ) ; nvdimm_bus_unlock ( & ndns -> dev ) ; if ( ! btt_dev ) return - ENOMEM ; btt_sb = devm_kzalloc ( dev , sizeof ( * btt_sb ) , GFP_KERNEL ) ; rc = __nd_btt_probe ( to_nd_btt ( btt_dev ) , ndns , btt_sb ) ; dev_dbg ( dev , "%s:<S2SV_blank>btt:<S2SV_blank>%s\\n" , __func__ , rc == 0 ? dev_name ( btt_dev ) : "<none>" ) ; if ( rc < 0 ) { struct nd_btt * nd_btt = to_nd_btt ( btt_dev ) ; <S2SV_StartBug> __nd_detach_ndns ( btt_dev , & nd_btt -> ndns ) ; <S2SV_EndBug> put_device ( btt_dev ) ; } return rc ; }
|
<S2SV_ModStart> btt_dev ) ; nd_detach_ndns <S2SV_ModEnd> ( btt_dev ,
|
6,634 |
CWE-000 void exit_cb ( uv_process_t * p , int64_t exit_status , int term_signal ) { <S2SV_StartBug> LogInfo ( "Out<S2SV_blank>process:<S2SV_blank>%d,<S2SV_blank>exited<S2SV_blank>with<S2SV_blank>status:<S2SV_blank>%" PRId64 ",<S2SV_blank>signal:<S2SV_blank>%d<S2SV_blank>!!\\n" , p -> pid , exit_status , term_signal ) ; <S2SV_EndBug> uv_close ( ( uv_handle_t * ) p , NULL ) ; }
|
<S2SV_ModStart> { LogInfo ( "Out<S2SV_blank>process:<S2SV_blank>%d,<S2SV_blank>exited<S2SV_blank>with<S2SV_blank>status:<S2SV_blank>" INT64_PRINTF <S2SV_ModEnd> ",<S2SV_blank>signal:<S2SV_blank>%d<S2SV_blank>!!\\n" , p
|
6,635 |
CWE-000 static int do_loopback ( struct path * path , const char * old_name , int recurse ) { struct path old_path ; <S2SV_StartBug> struct mount * mnt = NULL , * old , * parent ; <S2SV_EndBug> struct mountpoint * mp ; int err ; if ( ! old_name || ! * old_name ) return - EINVAL ; err = kern_path ( old_name , LOOKUP_FOLLOW | LOOKUP_AUTOMOUNT , & old_path ) ; if ( err ) return err ; err = - EINVAL ; if ( mnt_ns_loop ( old_path . dentry ) ) goto out ; mp = lock_mount ( path ) ; <S2SV_StartBug> err = PTR_ERR ( mp ) ; <S2SV_EndBug> <S2SV_StartBug> if ( IS_ERR ( mp ) ) <S2SV_EndBug> goto out ; <S2SV_StartBug> old = real_mount ( old_path . mnt ) ; <S2SV_EndBug> <S2SV_StartBug> parent = real_mount ( path -> mnt ) ; <S2SV_EndBug> err = - EINVAL ; if ( IS_MNT_UNBINDABLE ( old ) ) goto out2 ; if ( ! check_mnt ( parent ) ) goto out2 ; <S2SV_StartBug> if ( ! check_mnt ( old ) && old_path . dentry -> d_op != & ns_dentry_operations ) <S2SV_EndBug> goto out2 ; <S2SV_StartBug> if ( ! recurse && has_locked_children ( old , old_path . dentry ) ) <S2SV_EndBug> goto out2 ; if ( recurse ) mnt = copy_tree ( old , old_path . dentry , CL_COPY_MNT_NS_FILE ) ; else mnt = clone_mnt ( old , old_path . dentry , 0 ) ; if ( IS_ERR ( mnt ) ) { err = PTR_ERR ( mnt ) ; goto out2 ; } mnt -> mnt . mnt_flags &= ~ MNT_LOCKED ; err = graft_tree ( mnt , parent , mp ) ; if ( err ) { lock_mount_hash ( ) ; umount_tree ( mnt , UMOUNT_SYNC ) ; unlock_mount_hash ( ) ; } out2 : unlock_mount ( mp ) ; out : path_put ( & old_path ) ; return err ; }
|
<S2SV_ModStart> NULL , * <S2SV_ModEnd> parent ; struct <S2SV_ModStart> path ) ; if ( IS_ERR ( mp ) ) { <S2SV_ModStart> mp ) ; <S2SV_ModEnd> goto out ; <S2SV_ModStart> goto out ; } parent <S2SV_ModEnd> = real_mount ( <S2SV_ModStart> = real_mount ( <S2SV_ModEnd> path -> mnt <S2SV_ModStart> -> mnt ) <S2SV_ModEnd> ; if ( <S2SV_ModStart> goto out2 ; mnt = __do_loopback ( & old_path , recurse ) ; if ( IS_ERR ( mnt ) ) { err = PTR_ERR ( mnt ) ; <S2SV_ModEnd> goto out2 ; <S2SV_ModStart> goto out2 ; } <S2SV_ModEnd> err = graft_tree
|
6,636 |
CWE-000 int parse_port_cmd ( char * cmd , struct sockaddr_in * client_addr ) { char strIp [ 32 ] = { 0 } ; if ( ! IS_CMD ( cmd , "PORT" ) ) { return - 1 ; } cmd += strlen ( "PORT" ) ; while ( * cmd == '<S2SV_blank>' && * cmd != '\\0' ) { cmd ++ ; } if ( * cmd == '\\0' ) { return - 1 ; } int comma_cnt = 0 ; int cursor = 0 ; int seperator = 0 ; int port1_str_index = 0 ; int port2_str_index = 0 ; char str_port1 [ 16 ] = { 0 } ; char str_port2 [ 16 ] = { 0 } ; while ( cursor < strlen ( cmd ) ) { if ( cmd [ cursor ] == ',' ) { comma_cnt ++ ; if ( comma_cnt == 4 ) { seperator = cursor ; } if ( comma_cnt < 4 ) { cmd [ cursor ] = '.' ; } } else { if ( comma_cnt == 4 && cmd [ cursor ] >= '0' && cmd [ cursor ] <= '9' ) { str_port1 [ port1_str_index ++ ] = cmd [ cursor ] ; } if ( comma_cnt == 5 && cmd [ cursor ] >= '0' && cmd [ cursor ] <= '9' ) { str_port2 [ port2_str_index ++ ] = cmd [ cursor ] ; } } cursor ++ ; } if ( comma_cnt != 5 ) { return - 1 ; } int port1 = atoi ( str_port1 ) ; int port2 = atoi ( str_port2 ) ; int port = port1 * 256 + port2 ; strncpy ( strIp , cmd , seperator ) ; <S2SV_StartBug> printf ( "parsed<S2SV_blank>client<S2SV_blank>address<S2SV_blank>is<S2SV_blank>%s:%d" , strIp , port ) ; <S2SV_EndBug> memset ( client_addr , 0 , sizeof ( struct sockaddr_in ) ) ; client_addr -> sin_family = AF_INET ; client_addr -> sin_port = htons ( port ) ; client_addr -> sin_addr . s_addr = inet_addr ( strIp ) ; return 0 ; }
|
<S2SV_ModStart> ; printf ( "parsed<S2SV_blank>client<S2SV_blank>address<S2SV_blank>is<S2SV_blank>%s:%d\\r\\n" <S2SV_ModEnd> , strIp ,
|
6,637 |
CWE-000 bool place ( char * bp , size_t asize ) { char * headptr = HDRP ( bp ) ; size_t totalsize = GET_SIZE ( headptr ) ; size_t newsize = totalsize - ( DSIZE + asize ) ; PUT ( headptr , PACK ( DSIZE + asize , 1 ) ) ; char * footptr = FTRP ( bp ) ; PUT ( footptr , PACK ( DSIZE + asize , 1 ) ) ; <S2SV_StartBug> bp = footptr + WSIZE ; <S2SV_EndBug> char * newheadptr = HDRP ( bp ) ; PUT ( newheadptr , PACK ( newsize , 0 ) ) ; char * newfootptr = FTRP ( bp ) ; PUT ( newfootptr , PACK ( newsize , 0 ) ) ; return true ; }
|
<S2SV_ModStart> ; bp = NEXT_BLKP ( bp ) <S2SV_ModEnd> ; char *
|
6,638 |
CWE-000 static void fs__rename ( uv_fs_t * req ) { <S2SV_StartBug> int tries ; <S2SV_EndBug> int sys_errno ; int result ; int try_rmdir ; WCHAR * src , * dst ; DWORD src_attrib , dst_attrib ; <S2SV_StartBug> src = req -> file . pathw ; <S2SV_EndBug> <S2SV_StartBug> dst = req -> fs . info . new_pathw ; <S2SV_EndBug> try_rmdir = 0 ; src_attrib = GetFileAttributesW ( src ) ; if ( src_attrib == INVALID_FILE_ATTRIBUTES ) { SET_REQ_WIN32_ERROR ( req , GetLastError ( ) ) ; return ; } <S2SV_StartBug> dst_attrib = GetFileAttributesW ( dst ) ; <S2SV_EndBug> if ( dst_attrib != INVALID_FILE_ATTRIBUTES ) { if ( dst_attrib & FILE_ATTRIBUTE_READONLY ) { req -> result = UV_EPERM ; return ; } if ( src_attrib & FILE_ATTRIBUTE_DIRECTORY && dst_attrib & FILE_ATTRIBUTE_DIRECTORY ) try_rmdir = 1 ; } for ( tries = 0 ; tries < UV__RENAME_RETRIES ; ++ tries ) { if ( tries > 0 ) Sleep ( UV__RENAME_WAIT ) ; if ( try_rmdir ) { result = _wrmdir ( dst ) == 0 ? 0 : uv_translate_sys_error ( _doserrno ) ; switch ( result ) { case 0 : case UV_ENOENT : try_rmdir = 0 ; break ; case UV_ENOTEMPTY : SET_REQ_RESULT ( req , - 1 ) ; return ; default : break ; } } if ( MoveFileExW ( src , dst , MOVEFILE_REPLACE_EXISTING ) != 0 ) { SET_REQ_RESULT ( req , 0 ) ; <S2SV_StartBug> return ; <S2SV_EndBug> } sys_errno = GetLastError ( ) ; result = uv_translate_sys_error ( sys_errno ) ; if ( result != UV_EBUSY && result != UV_EPERM && result != UV_EACCES ) break ; } req -> sys_errno_ = sys_errno ; req -> result = result ; }
|
<S2SV_ModStart> req ) { if ( ! MoveFileExW ( <S2SV_ModEnd> req -> file <S2SV_ModStart> file . pathw , <S2SV_ModEnd> req -> fs <S2SV_ModStart> info . new_pathw , MOVEFILE_REPLACE_EXISTING ) <S2SV_ModEnd> ) { SET_REQ_WIN32_ERROR <S2SV_ModStart> return ; } <S2SV_ModEnd> SET_REQ_RESULT ( req <S2SV_ModStart> 0 ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null>
|
6,639 |
CWE-000 void AddWords ( void ) { <S2SV_StartBug> char * pch = pchDictionary ; <S2SV_EndBug> cpwCand = 0 ; while ( * pch ) { if ( ( pch [ 1 ] >= cchMinLength && pch [ 1 ] + cchMinLength <= cchPhraseLength ) || pch [ 1 ] == cchPhraseLength ) <S2SV_StartBug> BuildWord ( pch + 2 ) ; <S2SV_EndBug> pch += * pch ; } fprintf ( stderr , "%d<S2SV_blank>candidates\\n" , cpwCand ) ; }
|
<S2SV_ModStart> void ) { _Array_ptr < char > pchLowerBounds = pchDictionary ; _Array_ptr < char > pchUpperBounds = pchDictionary + pchDictionarySize ; _Array_ptr < char > pch : bounds ( pchLowerBounds , pchUpperBounds ) <S2SV_ModEnd> = pchDictionary ; <S2SV_ModStart> == cchPhraseLength ) { unsigned char wordLength = pch [ 0 ] ; _Array_ptr < char > wordStart = pch ; _Array_ptr < char > wordEnd = pch + wordLength ; _Dynamic_check ( wordEnd <= pchUpperBounds ) ; <S2SV_ModStart> pch + 2 , wordStart , wordEnd ) ; } <S2SV_ModEnd> pch += *
|
6,640 |
CWE-000 static int is_tube ( char * line , t_lemin * l ) { int i ; int j ; char * * tubes ; <S2SV_StartBug> if ( ( tubes = ft_strsplit ( line , '-' ) ) == NULL ) <S2SV_EndBug> return ( FAILURE ) ; i = - 1 ; if ( tubes [ 0 ] && tubes [ 1 ] && ! tubes [ 2 ] ) while ( ++ i < l -> nb_rooms ) if ( ft_strequ ( tubes [ 0 ] , ( l -> rooms ) [ i ] -> name ) && ( j = - 1 ) ) while ( ++ j < l -> nb_rooms ) if ( ft_strequ ( tubes [ 1 ] , ( l -> rooms ) [ j ] -> name ) ) { put_score ( l , i , j ) ; ft_free_tab ( ( void * * * ) & tubes ) ; return ( TRUE ) ; } ft_free_tab ( ( void * * * ) & tubes ) ; l -> step = 42 ; return ( FALSE ) ; }
|
<S2SV_ModStart> ; if ( countchar ( line , '-' ) != 1 ||
|
6,641 |
CWE-000 void setmap ( uint64_t * pgdir , uint64_t va , uint64_t pa , uint64_t flag ) { <S2SV_StartBug> uint64_t pt1 = ( va >> 39 ) & 0x1ff ; <S2SV_EndBug> uint64_t pt2 = ( va >> 30 ) & 0x1ff ; uint64_t pt3 = ( va >> 21 ) & 0x1ff ; uint64_t pt4 = ( va >> 12 ) & 0x1ff ; if ( ! ( pgdir [ pt1 ] & pte_p ) ) { uint64_t dir2 = alloc ( ) ; memset ( ( char * ) dir2 , 0 , 0x1000 ) ; pgdir [ pt1 ] = k2p ( dir2 ) | pte_p | pte_u | pte_w ; } uint64_t * pgdir2 = ( uint64_t * ) ( p2k ( pgdir [ pt1 ] & 0xfffffffffffff000 ) ) ; if ( ! ( pgdir2 [ pt2 ] & pte_p ) ) { uint64_t dir3 = alloc ( ) ; memset ( ( char * ) dir3 , 0 , 0x1000 ) ; pgdir2 [ pt2 ] = k2p ( dir3 ) | pte_p | pte_u | pte_w ; } uint64_t * pgdir3 = ( uint64_t * ) ( p2k ( pgdir2 [ pt2 ] & 0xfffffffffffff000 ) ) ; if ( ! ( pgdir3 [ pt3 ] & pte_p ) ) { uint64_t dir4 = alloc ( ) ; memset ( ( char * ) dir4 , 0 , 0x1000 ) ; pgdir3 [ pt3 ] = k2p ( dir4 ) | pte_p | pte_u | pte_w ; } uint64_t * pgdir4 = ( uint64_t * ) ( p2k ( pgdir3 [ pt3 ] & 0xfffffffffffff000 ) ) ; pgdir4 [ pt4 ] = pa | flag ; }
|
<S2SV_ModStart> ) { uint64_t * pte = getptepointer ( pgdir , va ) ; * pte <S2SV_ModEnd> = pa |
|
6,642 |
CWE-000 __declspec ( dllexport ) int mppPostMain ( int cmd , int arg0 , int arg1 , int arg2 , int arg3 , int arg4 , int arg5 , int arg6 , int arg7 , int arg8 , int arg9 , int arg10 , int arg11 ) { switch ( cmd ) { case CG_DRAW_ACTIVE_FRAME : { if ( cvar_ratioDraw . integer != 0 ) { int diff = sys -> snap -> ps . persistant [ PERS_SCORE ] - sys -> snap -> ps . persistant [ PERS_KILLED ] + nbSuicides ; float ratio = calculateRatio ( sys -> snap -> ps . persistant [ PERS_SCORE ] , sys -> snap -> ps . persistant [ PERS_KILLED ] - nbSuicides ) ; <S2SV_StartBug> sys -> mppRawTextCalculateDraw ( sys -> va ( "Ratio:<S2SV_blank>%.2f<S2SV_blank>(^%c%s%i^7)" , ratio , ( diff < 0 ? '1' : ( diff > 0 ) ? '2' : '3' ) , ( diff >= 0 ? "+" : "" ) , diff ) , cvar_ratioPosX . integer , cvar_ratioPosY . integer , cvar_ratioSize . value , 1 , 0 ) ; <S2SV_EndBug> } if ( currentTeam != TEAM_SPECTATOR && cvar_ratioStats . integer != 0 ) { int trickedIndex ; if ( sys -> cg -> clientNum > 47 ) trickedIndex = 3 ; if ( sys -> cg -> clientNum > 31 ) trickedIndex = 2 ; if ( sys -> cg -> clientNum > 15 ) trickedIndex = 1 ; else trickedIndex = 0 ; for ( int i = 0 ; i < sys -> cgs -> maxclients ; i ++ ) { <S2SV_StartBug> centity_t * cent = sys -> mppIsPlayerEntity ( i ) ; <S2SV_EndBug> <S2SV_StartBug> if ( cent ) { <S2SV_EndBug> int * trick = & cent -> currentState . trickedentindex ; trick += trickedIndex ; <S2SV_StartBug> if ( i != sys -> snap -> ps . clientNum && ! ( cent -> currentState . eFlags & EF_DEAD ) && ! ( * trick & ( 1 << ( sys -> cg -> clientNum % 16 ) ) ) && ! sys -> mppIsPlayerAlly ( i ) ) <S2SV_EndBug> { char stats [ 15 ] , statsSpaces [ MAX_NAME_LENGTH ] , nameSpaces [ MAX_NAME_LENGTH ] ; int spacesDiff = ( ( int ) ( sys -> Com_Sprintf ( stats , 15 , "^2%i^7/^1%i" , playerStats [ i ] . killedByMe , playerStats [ i ] . killedMe ) - 6 - strlen ( sys -> clientInfo [ i ] . name ) ) ) / 2 ; int j ; for ( j = 0 ; j < - spacesDiff && j < MAX_NAME_LENGTH ; j ++ ) { statsSpaces [ j ] = '<S2SV_blank>' ; } statsSpaces [ j ] = '\\0' ; for ( j = 0 ; j < spacesDiff && j < MAX_NAME_LENGTH ; j ++ ) { nameSpaces [ j ] = '<S2SV_blank>' ; } nameSpaces [ j ] = '\\0' ; <S2SV_StartBug> sys -> mppRenderTextAtEntity ( i , sys -> va ( "%s%s\\n%s%s" , nameSpaces , sys -> clientInfo [ i ] . name , statsSpaces , stats ) , qtrue , qfalse ) ; <S2SV_EndBug> } } } } break ; } default : break ; } return sys -> noBreakCode ; }
|
<S2SV_ModStart> 1 , 0 , TopRight <S2SV_ModStart> ++ ) { if ( i == sys -> cg -> clientNum || sys -> mppIsPlayerAlly ( i ) ) continue ; <S2SV_ModStart> if ( cent && ! ( cent -> currentState . eFlags & EF_DEAD ) <S2SV_ModStart> ; if ( <S2SV_ModEnd> ! ( * <S2SV_ModStart> 16 ) ) <S2SV_ModEnd> ) ) { <S2SV_ModStart> qtrue , qfalse , MiddleCenter
|
6,643 |
CWE-000 attribute_t schema_attribute_last ( schema_t s ) { <S2SV_StartBug> attribute_t attr ; <S2SV_EndBug> if ( s == NULL || s -> attrlist == NULL ) return NULL ; for ( attr = s -> attrlist ; attr -> next != NULL ; attr = attr -> next ) ; return attr ; }
|
<S2SV_ModStart> { attribute_t attr = NULL
|
6,644 |
CWE-000 void themis_secure_session_free_storage ( void * object TSRMLS_DC ) { <S2SV_StartBug> themis_secure_session_object * obj = ( themis_secure_session_object * ) object ; <S2SV_EndBug> <S2SV_StartBug> secure_session_destroy ( obj -> session ) ; <S2SV_EndBug> zend_hash_destroy ( obj -> std . properties ) ; FREE_HASHTABLE ( obj -> std . properties ) ; <S2SV_StartBug> efree ( obj ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> * obj = get_session_object ( object ) ; secure_session_t * session = obj -> session <S2SV_ModEnd> ; secure_session_destroy ( <S2SV_ModStart> ; secure_session_destroy ( <S2SV_ModEnd> session ) ; <S2SV_ModStart> ; efree ( object <S2SV_ModEnd> ) ; }
|
6,645 |
CWE-000 int removeEvent ( Eventlist * * eventlist , Eventlist * removable ) { Eventlist * prev , * cur , * next ; prev = NULL , cur = * eventlist , next = ( * eventlist ) -> next ; while ( cur != removable ) { prev = cur ; cur = next ; <S2SV_StartBug> next = prev -> next ; <S2SV_EndBug> } if ( prev != NULL ) { prev -> next = next ; } else { * eventlist = ( * eventlist ) -> next ; } return 0 ; }
|
<S2SV_ModStart> ; next = cur <S2SV_ModEnd> -> next ;
|
6,646 |
CWE-000 int bomb_move ( ) { if ( inair ( self ) && self -> toexplode == 1 ) { if ( self -> direction == DIRECTION_LEFT ) { self -> velocity . x = - self -> modeldata . speed ; } else if ( self -> direction == DIRECTION_RIGHT ) { self -> velocity . x = self -> modeldata . speed ; } } else if ( self -> takeaction != bomb_explode ) { self -> takeaction = bomb_explode ; <S2SV_StartBug> self -> velocity . y = 0 ; <S2SV_EndBug> <S2SV_StartBug> self -> modeldata . subject_to_basemap = 1 ; <S2SV_EndBug> self -> base = self -> position . y ; <S2SV_StartBug> self -> velocity . x = self -> velocity . z = 0 ; <S2SV_EndBug> if ( self -> modeldata . diesound >= 0 ) { sound_play_sample ( self -> modeldata . diesound , 0 , savedata . effectvol , savedata . effectvol , 100 ) ; } if ( self -> toexplode == 2 && validanim ( self , ANI_ATTACK2 ) ) { ent_set_anim ( self , ANI_ATTACK2 , 0 ) ; } else if ( validanim ( self , ANI_ATTACK1 ) ) { ent_set_anim ( self , ANI_ATTACK1 , 0 ) ; } <S2SV_StartBug> self -> modeldata . subject_to_wall = 0 ; <S2SV_EndBug> self -> modeldata . subject_to_platform = 1 ; self -> modeldata . subject_to_hole = 0 ; } return 1 ; }
|
<S2SV_ModStart> ; self -> modeldata . subject_to_wall = 1 ; self -> modeldata . subject_to_platform = 1 ; self -> modeldata . subject_to_hole = 1 ; self -> modeldata . subject_to_basemap = 1 ; if ( ! checkhole ( self -> position . x , self -> position . z ) ) { self -> <S2SV_ModStart> ; self -> <S2SV_ModEnd> base = self <S2SV_ModStart> = 0 ; } <S2SV_ModStart> ) ; } <S2SV_ModEnd> } return 1
|
6,647 |
CWE-000 static int cluster_configure ( struct lpm_cluster * cluster , int idx , bool from_idle ) { struct lpm_cluster_level * level = & cluster -> levels [ idx ] ; int ret , i ; if ( ! cpumask_equal ( & cluster -> num_children_in_sync , & cluster -> child_cpus ) || is_IPI_pending ( & cluster -> num_children_in_sync ) ) { return - EPERM ; } if ( idx != cluster -> default_level ) { update_debug_pc_event ( CLUSTER_ENTER , idx , cluster -> num_children_in_sync . bits [ 0 ] , cluster -> child_cpus . bits [ 0 ] , from_idle ) ; trace_cluster_enter ( cluster -> cluster_name , idx , cluster -> num_children_in_sync . bits [ 0 ] , cluster -> child_cpus . bits [ 0 ] , from_idle ) ; lpm_stats_cluster_enter ( cluster -> stats , idx ) ; } for ( i = 0 ; i < cluster -> ndevices ; i ++ ) { ret = set_device_mode ( cluster , i , level ) ; if ( ret ) goto failed_set_mode ; } if ( level -> notify_rpm ) { struct cpumask nextcpu , * cpumask ; uint64_t us ; us = get_cluster_sleep_time ( cluster , & nextcpu , from_idle ) ; cpumask = level -> disable_dynamic_routing ? NULL : & nextcpu ; ret = msm_rpm_enter_sleep ( 0 , cpumask ) ; if ( ret ) { pr_info ( "Failed<S2SV_blank>msm_rpm_enter_sleep()<S2SV_blank>rc<S2SV_blank>=<S2SV_blank>%d\\n" , ret ) ; goto failed_set_mode ; } <S2SV_StartBug> us = us + 1 ; <S2SV_EndBug> <S2SV_StartBug> do_div ( us , USEC_PER_SEC / SCLK_HZ ) ; <S2SV_EndBug> msm_mpm_enter_sleep ( us , from_idle , cpumask ) ; } cluster_notify ( cluster , level , true ) ; cluster -> last_level = idx ; return 0 ; failed_set_mode : for ( i = 0 ; i < cluster -> ndevices ; i ++ ) { int rc = 0 ; level = & cluster -> levels [ cluster -> default_level ] ; rc = set_device_mode ( cluster , i , level ) ; BUG_ON ( rc ) ; } return ret ; }
|
<S2SV_ModStart> } us = ( <S2SV_ModStart> us + 1 ) * 1000 <S2SV_ModStart> ( us , NSEC_PER_SEC <S2SV_ModEnd> / SCLK_HZ )
|
6,648 |
CWE-000 void WolfLocalTimer ( void ) { static unsigned int count = 0 ; <S2SV_StartBug> UINT status ; <S2SV_EndBug> <S2SV_StartBug> int ret ; <S2SV_EndBug> count ++ ; # ifdef WOLFLOCAL_TEST_KEY_SERVER if ( count > 15 ) { # if WOLFCAST_LOGGING_LEVEL >= 3 KS_PRINTF ( "timer:<S2SV_blank>%u\\n" , count ) ; # endif if ( ( count % 10 ) == 0 ) { # if WOLFCAST_LOGGING_LEVEL >= 3 KS_PRINTF ( "timer:<S2SV_blank>10<S2SV_blank>on<S2SV_blank>the<S2SV_blank>10\\n" ) ; # endif ret = KeyServer_GenNewKey ( gHeapHint ) ; if ( ret ) { # if WOLFCAST_LOGGING_LEVEL >= 1 KS_PRINTF ( "Failed<S2SV_blank>to<S2SV_blank>announce<S2SV_blank>new<S2SV_blank>key.\\n" ) ; # endif } else { status = tx_mutex_get ( & gKeyStateMutex , KS_TIMEOUT_KEY_STATE_WRITE ) ; if ( status == TX_SUCCESS ) { gGetNewKey = 1 ; tx_mutex_put ( & gKeyStateMutex ) ; } } } if ( ( count % 10 ) == 2 ) { # if WOLFCAST_LOGGING_LEVEL >= 3 KS_PRINTF ( "timer:<S2SV_blank>10<S2SV_blank>on<S2SV_blank>the<S2SV_blank>2\\n" ) ; # endif if ( KeyServer_IsRunning ( ) ) { ret = KeyServer_NewKeyUse ( gHeapHint ) ; if ( ret ) { # if WOLFCAST_LOGGING_LEVEL >= 1 KS_PRINTF ( "Failed<S2SV_blank>to<S2SV_blank>announce<S2SV_blank>key<S2SV_blank>switch.\\n" ) ; # endif } else { status = tx_mutex_get ( & gKeyStateMutex , KS_TIMEOUT_KEY_STATE_WRITE ) ; if ( status == TX_SUCCESS ) { gSwitchKeys = 1 ; tx_mutex_put ( & gKeyStateMutex ) ; } } } } } # endif # ifdef WOLFLOCAL_TEST_KEY_REQUEST if ( count > 15 ) { # if WOLFCAST_LOGGING_LEVEL >= 3 KS_PRINTF ( "timer:<S2SV_blank>%u\\n" , count ) ; # endif if ( ( count % 10 ) == 0 ) { EpochRespPacket_t epochResp ; # if WOLFCAST_LOGGING_LEVEL >= 3 KS_PRINTF ( "timer:<S2SV_blank>10<S2SV_blank>on<S2SV_blank>the<S2SV_blank>10\\n" ) ; # endif ret = KeyClient_NewKeyRequest ( & gKeySrvAddr , & epochResp , gHeapHint ) ; if ( ret ) { # if WOLFCAST_LOGGING_LEVEL >= 1 KS_PRINTF ( "Failed<S2SV_blank>to<S2SV_blank>request<S2SV_blank>new<S2SV_blank>key.\\n" ) ; # endif } else { # if WOLFCAST_LOGGING_LEVEL >= 1 KS_PRINTF ( "New<S2SV_blank>epoch<S2SV_blank>will<S2SV_blank>be<S2SV_blank>%u.\\n" , <S2SV_StartBug> ( ( epochResp . epoch [ 0 ] << 8 ) | epochResp . epoch [ 1 ] ) ; <S2SV_EndBug> # endif } } } # endif }
|
<S2SV_ModStart> = 0 ; int ret ; count ++ ; # ifdef WOLFLOCAL_TEST_KEY_SERVER if ( count > 15 ) { <S2SV_ModStart> UINT status ; <S2SV_ModEnd> # if WOLFCAST_LOGGING_LEVEL <S2SV_ModStart> 1 ] ) )
|
6,649 |
CWE-000 int corto_threadTlsKey ( corto_threadKey * key , void ( * destructor ) ( void * ) ) { if ( pthread_key_create ( key , destructor ) ) { corto_seterr ( "corto_threadTlsKey<S2SV_blank>failed." ) ; goto error ; } <S2SV_StartBug> return 0 ; <S2SV_EndBug> error : return - 1 ; }
|
<S2SV_ModStart> error ; } if ( destructor ) { corto_int32 slot = corto_ainc ( & corto_threadTlsCount ) ; corto_threadTlsAdmin [ slot ] . key = * key ; corto_threadTlsAdmin [ slot ] . destructor = destructor ; }
|
6,650 |
CWE-000 static void handle_missing_virtual_repo ( SeafRepoManager * mgr , SeafRepo * repo , SeafCommit * head , SeafVirtRepo * vinfo ) { SeafCommit * parent = NULL ; char * old_dir_id = NULL ; GList * diff_res = NULL , * ptr ; DiffEntry * de ; parent = seaf_commit_manager_get_commit ( seaf -> commit_mgr , head -> repo_id , head -> version , head -> parent_id ) ; if ( ! parent ) { seaf_warning ( "Failed<S2SV_blank>to<S2SV_blank>find<S2SV_blank>commit<S2SV_blank>%s:%s.\\n" , head -> repo_id , head -> parent_id ) ; return ; } int rc = diff_commits ( parent , head , & diff_res , TRUE ) ; if ( rc < 0 ) { seaf_warning ( "Failed<S2SV_blank>to<S2SV_blank>diff<S2SV_blank>commit<S2SV_blank>%s<S2SV_blank>to<S2SV_blank>%s.\\n" , parent -> commit_id , head -> commit_id ) ; seaf_commit_unref ( parent ) ; return ; } char * path = vinfo -> path , * sub_path , * p , * par_path ; gboolean is_renamed = FALSE ; p = & path [ strlen ( path ) ] ; par_path = g_strdup ( path ) ; sub_path = NULL ; while ( 1 ) { GError * error = NULL ; old_dir_id = seaf_fs_manager_get_seafdir_id_by_path ( seaf -> fs_mgr , repo -> store_id , repo -> version , parent -> root_id , par_path , & error ) ; if ( ! old_dir_id ) { if ( error && error -> code == SEAF_ERR_PATH_NO_EXIST ) { seaf_warning ( "Failed<S2SV_blank>to<S2SV_blank>find<S2SV_blank>%s<S2SV_blank>under<S2SV_blank>commit<S2SV_blank>%s<S2SV_blank>in<S2SV_blank>repo<S2SV_blank>%s.\\n" , par_path , parent -> commit_id , repo -> store_id ) ; seaf_debug ( "Delete<S2SV_blank>virtual<S2SV_blank>repo<S2SV_blank>%.10s.\\n" , vinfo -> repo_id ) ; seaf_repo_manager_del_virtual_repo ( mgr , vinfo -> repo_id ) ; g_clear_error ( & error ) ; } goto out ; } char de_id [ 41 ] ; char * new_path ; char * new_name ; char * * parts = NULL ; for ( ptr = diff_res ; ptr ; ptr = ptr -> next ) { de = ptr -> data ; if ( de -> status == DIFF_STATUS_DIR_RENAMED ) { rawdata_to_hex ( de -> sha1 , de_id , 20 ) ; if ( strcmp ( de_id , old_dir_id ) == 0 ) { if ( sub_path != NULL ) new_path = g_strconcat ( "/" , de -> new_name , "/" , sub_path , NULL ) ; else new_path = g_strconcat ( "/" , de -> new_name , NULL ) ; seaf_debug ( "Updating<S2SV_blank>path<S2SV_blank>of<S2SV_blank>virtual<S2SV_blank>repo<S2SV_blank>%s<S2SV_blank>to<S2SV_blank>%s.\\n" , vinfo -> repo_id , new_path ) ; set_virtual_repo_base_commit_path ( vinfo -> repo_id , head -> commit_id , new_path ) ; parts = g_strsplit ( new_path , "/" , 0 ) ; new_name = parts [ g_strv_length ( parts ) - 1 ] ; seaf_repo_manager_edit_repo ( vinfo -> repo_id , new_name , "Changed<S2SV_blank>library<S2SV_blank>name" , NULL , & error ) ; if ( error ) { seaf_warning ( "Failed<S2SV_blank>to<S2SV_blank>rename<S2SV_blank>repo<S2SV_blank>%s" , de -> new_name ) ; g_clear_error ( & error ) ; } is_renamed = TRUE ; <S2SV_StartBug> break ; <S2SV_EndBug> } } } g_free ( old_dir_id ) ; g_strfreev ( parts ) ; if ( is_renamed ) break ; while ( -- p != path && * p != '/' ) ; if ( p == path ) break ; g_free ( par_path ) ; g_free ( sub_path ) ; par_path = g_strndup ( path , p - path ) ; sub_path = g_strdup ( p + 1 ) ; } if ( ! is_renamed ) { seaf_debug ( "Delete<S2SV_blank>virtual<S2SV_blank>repo<S2SV_blank>%.10s.\\n" , vinfo -> repo_id ) ; seaf_repo_manager_del_virtual_repo ( mgr , vinfo -> repo_id ) ; } out : g_free ( par_path ) ; g_free ( sub_path ) ; for ( ptr = diff_res ; ptr ; ptr = ptr -> next ) diff_entry_free ( ( DiffEntry * ) ptr -> data ) ; g_list_free ( diff_res ) ; seaf_commit_unref ( parent ) ; }
|
<S2SV_ModStart> = TRUE ; g_free ( new_path ) ;
|
6,651 |
CWE-000 int main ( void ) { struct sockaddr_in si_me , si_other ; int s , slen = sizeof ( si_other ) ; char buf [ BUFLEN ] ; int i ; fclose ( stdin ) ; <S2SV_StartBug> signal ( SIGALRM , ( void * ) Check ) ; <S2SV_EndBug> alarm ( SECONDS ) ; if ( ( s = socket ( AF_INET , SOCK_DGRAM , IPPROTO_UDP ) ) == - 1 ) err ( "socket" ) ; memset ( ( char * ) & si_me , 0 , sizeof ( si_me ) ) ; si_me . sin_family = AF_INET ; si_me . sin_port = htons ( PORT ) ; si_me . sin_addr . s_addr = htonl ( INADDR_ANY ) ; if ( setsockopt ( s , SOL_SOCKET , SO_REUSEADDR , & ( int ) { 1 } , sizeof ( int ) ) < 0 ) err ( "setsockopt(SO_REUSEADDR)<S2SV_blank>failed" ) ; if ( bind ( s , ( void * ) & si_me , sizeof ( si_me ) ) == - 1 ) err ( "bind" ) ; for ( i ; i < MESSAGES ; i ++ ) { if ( recvfrom ( s , buf , BUFLEN , 0 , ( void * ) & si_other , & slen ) == - 1 ) err ( "recvfrom()" ) ; fprintf ( stderr , "%d<S2SV_blank>%d<S2SV_blank>Received<S2SV_blank>packet<S2SV_blank>from<S2SV_blank>%s:%d\\n" , getppid ( ) , getpid ( ) , inet_ntoa ( si_other . sin_addr ) , ntohs ( si_other . sin_port ) ) ; log ( buf ) ; } close ( s ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> }
|
<S2SV_ModStart> stdin ) ; mkdir ( LOGPATH ) ; <S2SV_ModStart> s ) ; Check ( 1 ) ;
|
6,652 |
CWE-000 gboolean gepub_widget_page_prev ( GepubWidget * widget ) { g_return_val_if_fail ( GEPUB_IS_DOC ( widget -> doc ) , FALSE ) ; widget -> chapter_pos = widget -> chapter_pos - widget -> length ; if ( widget -> chapter_pos < 0 ) { <S2SV_StartBug> widget -> init_chapter_pos = 100 ; <S2SV_EndBug> return gepub_doc_go_prev ( widget -> doc ) ; } scroll_to_chapter_pos ( widget ) ; g_object_notify_by_pspec ( G_OBJECT ( widget ) , properties [ PROP_CHAPTER_POS ] ) ; return TRUE ; }
|
<S2SV_ModStart> -> init_chapter_pos = HUNDRED_PERCENT <S2SV_ModEnd> ; return gepub_doc_go_prev
|
6,653 |
CWE-000 void init_panel ( ) { if ( panel_config . monitor > ( server . num_monitors - 1 ) ) { fprintf ( stderr , "warning<S2SV_blank>:<S2SV_blank>monitor<S2SV_blank>not<S2SV_blank>found.<S2SV_blank>tint2<S2SV_blank>default<S2SV_blank>to<S2SV_blank>all<S2SV_blank>monitors.\\n" ) ; panel_config . monitor = 0 ; } fprintf ( stderr , "panel<S2SV_blank>items:<S2SV_blank>%s\\n" , panel_items_order ) ; init_tooltip ( ) ; init_systray ( ) ; init_launcher ( ) ; init_clock ( ) ; # ifdef ENABLE_BATTERY init_battery ( ) ; # endif init_taskbar ( ) ; init_execp ( ) ; if ( panel_config . monitor >= 0 ) num_panels = 1 ; else num_panels = server . num_monitors ; panels = calloc ( num_panels , sizeof ( Panel ) ) ; for ( int i = 0 ; i < num_panels ; i ++ ) { memcpy ( & panels [ i ] , & panel_config , sizeof ( Panel ) ) ; } fprintf ( stderr , "tint2<S2SV_blank>:<S2SV_blank>nb<S2SV_blank>monitor<S2SV_blank>%d,<S2SV_blank>nb<S2SV_blank>monitor<S2SV_blank>used<S2SV_blank>%d,<S2SV_blank>nb<S2SV_blank>desktop<S2SV_blank>%d\\n" , server . num_monitors , num_panels , server . num_desktops ) ; for ( int i = 0 ; i < num_panels ; i ++ ) { Panel * p = & panels [ i ] ; if ( panel_config . monitor < 0 ) p -> monitor = i ; if ( ! p -> area . bg ) p -> area . bg = & g_array_index ( backgrounds , Background , 0 ) ; p -> area . parent = p ; p -> area . panel = p ; snprintf ( p -> area . name , sizeof ( p -> area . name ) , "Panel<S2SV_blank>%d" , i ) ; p -> area . on_screen = TRUE ; p -> area . resize_needed = 1 ; p -> area . size_mode = LAYOUT_DYNAMIC ; p -> area . _resize = resize_panel ; p -> area . _clear = panel_clear_background ; init_panel_size_and_position ( p ) ; for ( int k = 0 ; k < strlen ( panel_items_order ) ; k ++ ) { if ( panel_items_order [ k ] == 'L' ) init_launcher_panel ( p ) ; if ( panel_items_order [ k ] == 'T' ) init_taskbar_panel ( p ) ; # ifdef ENABLE_BATTERY if ( panel_items_order [ k ] == 'B' ) init_battery_panel ( p ) ; # endif if ( panel_items_order [ k ] == 'S' && systray_on_monitor ( i , num_panels ) ) { init_systray_panel ( p ) ; refresh_systray = 1 ; } if ( panel_items_order [ k ] == 'C' ) init_clock_panel ( p ) ; if ( panel_items_order [ k ] == 'F' && ! strstr ( panel_items_order , "T" ) ) init_freespace_panel ( p ) ; if ( panel_items_order [ k ] == 'E' ) init_execp_panel ( p ) ; } set_panel_items_order ( p ) ; XSetWindowAttributes att = { . colormap = server . colormap , . background_pixel = 0 , . border_pixel = 0 } ; unsigned long mask = CWEventMask | CWColormap | CWBackPixel | CWBorderPixel ; p -> main_win = XCreateWindow ( server . display , server . root_win , p -> posx , p -> posy , p -> area . width , p -> area . height , 0 , server . depth , InputOutput , server . visual , mask , & att ) ; long event_mask = ExposureMask | ButtonPressMask | ButtonReleaseMask | ButtonMotionMask | PropertyChangeMask ; if ( p -> mouse_effects || p -> g_task . tooltip_enabled || p -> clock . area . _get_tooltip_text || ( launcher_enabled && launcher_tooltip_enabled ) ) event_mask |= PointerMotionMask | LeaveWindowMask ; if ( panel_autohide ) event_mask |= LeaveWindowMask | EnterWindowMask ; XChangeWindowAttributes ( server . display , p -> main_win , CWEventMask , & ( XSetWindowAttributes ) { . event_mask = event_mask } ) ; if ( ! server . gc ) { XGCValues gcv ; server . gc = XCreateGC ( server . display , p -> main_win , 0 , & gcv ) ; } set_panel_properties ( p ) ; set_panel_background ( p ) ; if ( ! snapshot_path ) { XMapWindow ( server . display , p -> main_win ) ; } if ( panel_autohide ) autohide_trigger_hide ( p ) ; <S2SV_StartBug> update_taskbar_visibility ( p ) ; <S2SV_EndBug> } taskbar_refresh_tasklist ( ) ; reset_active_task ( ) ; <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> p ) ; <S2SV_ModEnd> } taskbar_refresh_tasklist ( <S2SV_ModStart> ( ) ; update_all_taskbars_visibility ( ) ;
|
6,654 |
CWE-000 struct chassis_frontend_t * chassis_frontend_new ( void ) { struct chassis_frontend_t * frontend ; frontend = g_slice_new0 ( struct chassis_frontend_t ) ; frontend -> max_files_number = 0 ; frontend -> disable_threads = 0 ; frontend -> is_back_compressed = 0 ; frontend -> is_client_compress_support = 0 ; frontend -> xa_log_detailed = 0 ; frontend -> default_pool_size = 10 ; frontend -> max_resp_len = 10 * 1024 * 1024 ; frontend -> max_alive_time = DEFAULT_LIVE_TIME ; frontend -> merged_output_size = 8192 ; frontend -> max_header_size = 65536 ; frontend -> config_port = 3306 ; frontend -> check_slave_delay = 1 ; frontend -> slave_delay_down_threshold_sec = 10.0 ; frontend -> default_query_cache_timeout = 100 ; frontend -> client_idle_timeout = 8 * HOURS ; frontend -> maintained_client_idle_timeout = 30 ; frontend -> long_query_time = MAX_QUERY_TIME ; frontend -> cetus_max_allowed_packet = MAX_ALLOWED_PACKET_DEFAULT ; frontend -> disable_dns_cache = 0 ; frontend -> group_replication_mode = 0 ; frontend -> sql_log_bufsize = 0 ; frontend -> sql_log_switch = NULL ; frontend -> sql_log_prefix = NULL ; frontend -> sql_log_path = NULL ; frontend -> sql_log_maxsize = - 1 ; frontend -> sql_log_mode = NULL ; frontend -> sql_log_idletime = 0 ; frontend -> sql_log_maxnum = - 1 ; frontend -> check_dns = 0 ; <S2SV_StartBug> return frontend ; <S2SV_EndBug> }
|
<S2SV_ModStart> = 0 ; frontend -> ssl = 0 ;
|
6,655 |
CWE-000 void CL_ClearMemory ( qboolean shutdownRef ) { CL_ShutdownAll ( shutdownRef ) ; if ( ! com_sv_running || ! com_sv_running -> integer ) { Hunk_Clear ( ) ; CM_ClearMap ( ) ; } else { Hunk_ClearToMark ( ) ; } <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> ) ; } if ( ( com_sv_running && com_sv_running -> integer ) && clc . demoReadFile ) { CM_ClearMap ( ) ; }
|
6,656 |
CWE-000 int main ( int argc , char * argv [ ] ) { if ( argc < 2 ) { printf ( "Please<S2SV_blank>provide<S2SV_blank>IP<S2SV_blank>addresses<S2SV_blank>of<S2SV_blank>slave<S2SV_blank>nodes.\\n" ) ; return 1 ; } int num_slaves = argc - 1 ; args = argv ; <S2SV_StartBug> results = ( int * ) malloc ( num_slaves * sizeof ( int ) ) ; <S2SV_EndBug> cl_arr = ( CLIENT * * ) malloc ( num_slaves * sizeof ( CLIENT * ) ) ; int i ; for ( i = 0 ; i < num_slaves ; i ++ ) { results [ i ] = 0 ; cl_arr [ i ] = NULL ; <S2SV_StartBug> pthread_t tid = ( pthread_t ) i ; <S2SV_EndBug> <S2SV_StartBug> pthread_create ( & tid , NULL , get_commit_resp , ( void * ) tid ) ; <S2SV_EndBug> } sleep ( 1 ) ; int successes = 0 ; for ( i = 0 ; i < num_slaves ; i ++ ) { successes += results [ i ] ; <S2SV_StartBug> pthread_cancel ( ( pthread_t ) i ) ; <S2SV_EndBug> } if ( successes == num_slaves ) { printf ( "Everyone<S2SV_blank>agreed<S2SV_blank>to<S2SV_blank>commit!<S2SV_blank>Woohoo!\\n" ) ; for ( i = 0 ; i < num_slaves ; i ++ ) { results [ i ] = 0 ; cl_arr [ i ] = NULL ; pthread_t tid = ( pthread_t ) i ; struct thread_arg * targ = ( struct thread_arg * ) malloc ( sizeof ( struct thread_arg ) ) ; commit_vec_args * cargs = ( commit_vec_args * ) malloc ( sizeof ( commit_vec_args ) ) ; unsigned int vec_id = ( unsigned int ) i ; unsigned long long vec = ( unsigned long long ) i ; cargs -> vec_id = vec_id ; cargs -> vec = vec ; targ -> tid = tid ; targ -> commit_args = cargs ; CLIENT * cl = clnt_create ( args [ i + 1 ] , TWO_PHASE_COMMIT_VEC , TPC_COMMIT_VEC_V1 , "tcp" ) ; if ( cl == NULL ) { printf ( "Error:<S2SV_blank>could<S2SV_blank>not<S2SV_blank>connect<S2SV_blank>to<S2SV_blank>slave<S2SV_blank>%s.\\n" , args [ i + 1 ] ) ; continue ; } int * result = commit_vec_1 ( cargs , cl ) ; printf ( "Result<S2SV_blank>=<S2SV_blank>%d\\n" , * result ) ; if ( result == NULL ) { printf ( "Commit<S2SV_blank>failed.\\n" ) ; } else { printf ( "Commit<S2SV_blank>succeeded.\\n" ) ; } } } else { printf ( "Failed<S2SV_blank>to<S2SV_blank>find<S2SV_blank>all<S2SV_blank>slaves\\n" ) ; return 1 ; } free ( results ) ; free ( cl_arr ) ; return 0 ; }
|
<S2SV_ModStart> = argv ; pthread_t tids [ num_slaves ] ; <S2SV_ModStart> = NULL ; <S2SV_ModEnd> pthread_create ( & <S2SV_ModStart> pthread_create ( & tids [ i ] <S2SV_ModEnd> , NULL , <S2SV_ModStart> void * ) i <S2SV_ModEnd> ) ; } <S2SV_ModStart> i ] ; pthread_join ( tids [ i ] , NULL ) ; } printf ( "exited<S2SV_blank>for\\n" ) ; <S2SV_ModEnd> if ( successes
|
6,657 |
CWE-000 <S2SV_StartBug> ST_double gf_array_dsd_range ( const ST_double v [ ] , const GT_size start , const GT_size end ) { <S2SV_EndBug> GT_size i ; ST_double vvar = 0 ; ST_double vmean = gf_array_dmean_range ( v , start , end ) ; for ( i = start ; i < end ; i ++ ) vvar += SQUARE ( v [ i ] - vmean ) ; return ( sqrt ( vvar / ( end - start - 1 ) ) ) ; }
|
<S2SV_ModStart> end ) { if ( gf_array_dsame ( v + start , end - start ) ) { return ( 0 ) ; }
|
6,658 |
CWE-000 static sense_reason_t compare_and_write_callback ( struct se_cmd * cmd , bool success , int * post_ret ) { struct se_device * dev = cmd -> se_dev ; struct scatterlist * write_sg = NULL , * sg ; unsigned char * buf = NULL , * addr ; struct sg_mapping_iter m ; unsigned int offset = 0 , len ; unsigned int nlbas = cmd -> t_task_nolb ; unsigned int block_size = dev -> dev_attrib . block_size ; unsigned int compare_len = ( nlbas * block_size ) ; sense_reason_t ret = TCM_NO_SENSE ; int rc , i ; if ( ! success && ( ! cmd -> t_data_sg || ! cmd -> t_bidi_data_sg ) ) return TCM_NO_SENSE ; if ( ! cmd -> data_length ) goto out ; if ( cmd -> scsi_status ) { <S2SV_StartBug> pr_err ( "compare_and_write_callback:<S2SV_blank>non<S2SV_blank>zero<S2SV_blank>scsi_status:" <S2SV_EndBug> <S2SV_StartBug> "<S2SV_blank>0x%02x\\n" , cmd -> scsi_status ) ; <S2SV_EndBug> goto out ; } buf = kzalloc ( cmd -> data_length , GFP_KERNEL ) ; if ( ! buf ) { pr_err ( "Unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>compare_and_write<S2SV_blank>buf\\n" ) ; ret = TCM_OUT_OF_RESOURCES ; goto out ; } write_sg = kmalloc ( sizeof ( struct scatterlist ) * cmd -> t_data_nents , GFP_KERNEL ) ; if ( ! write_sg ) { pr_err ( "Unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>compare_and_write<S2SV_blank>sg\\n" ) ; ret = TCM_OUT_OF_RESOURCES ; goto out ; } sg_init_table ( write_sg , cmd -> t_data_nents ) ; rc = sg_copy_to_buffer ( cmd -> t_data_sg , cmd -> t_data_nents , buf , cmd -> data_length ) ; if ( ! rc ) { pr_err ( "sg_copy_to_buffer()<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>compare_and_write\\n" ) ; ret = TCM_OUT_OF_RESOURCES ; goto out ; } for_each_sg ( cmd -> t_bidi_data_sg , sg , cmd -> t_bidi_data_nents , i ) { addr = ( unsigned char * ) kmap_atomic ( sg_page ( sg ) ) ; if ( ! addr ) { ret = TCM_OUT_OF_RESOURCES ; goto out ; } len = min ( sg -> length , compare_len ) ; if ( memcmp ( addr , buf + offset , len ) ) { pr_warn ( "Detected<S2SV_blank>MISCOMPARE<S2SV_blank>for<S2SV_blank>addr:<S2SV_blank>%p<S2SV_blank>buf:<S2SV_blank>%p\\n" , addr , buf + offset ) ; kunmap_atomic ( addr ) ; goto miscompare ; } kunmap_atomic ( addr ) ; offset += len ; compare_len -= len ; if ( ! compare_len ) break ; } i = 0 ; len = cmd -> t_task_nolb * block_size ; sg_miter_start ( & m , cmd -> t_data_sg , cmd -> t_data_nents , SG_MITER_TO_SG ) ; while ( len ) { sg_miter_next ( & m ) ; if ( block_size < PAGE_SIZE ) { sg_set_page ( & write_sg [ i ] , m . page , block_size , m . piter . sg -> offset + block_size ) ; } else { sg_miter_next ( & m ) ; sg_set_page ( & write_sg [ i ] , m . page , block_size , m . piter . sg -> offset ) ; } len -= block_size ; i ++ ; } sg_miter_stop ( & m ) ; cmd -> t_data_sg_orig = cmd -> t_data_sg ; cmd -> t_data_sg = write_sg ; cmd -> t_data_nents_orig = cmd -> t_data_nents ; cmd -> t_data_nents = 1 ; cmd -> sam_task_attr = TCM_HEAD_TAG ; cmd -> transport_complete_callback = compare_and_write_post ; cmd -> execute_cmd = sbc_execute_rw ; spin_lock_irq ( & cmd -> t_state_lock ) ; cmd -> t_state = TRANSPORT_PROCESSING ; cmd -> transport_state |= CMD_T_ACTIVE | CMD_T_SENT ; spin_unlock_irq ( & cmd -> t_state_lock ) ; __target_execute_cmd ( cmd , false ) ; kfree ( buf ) ; return ret ; miscompare : pr_warn ( "Target/%s:<S2SV_blank>Send<S2SV_blank>MISCOMPARE<S2SV_blank>check<S2SV_blank>condition<S2SV_blank>and<S2SV_blank>sense\\n" , dev -> transport -> name ) ; ret = TCM_MISCOMPARE_VERIFY ; out : up ( & dev -> caw_sem ) ; kfree ( write_sg ) ; kfree ( buf ) ; return ret ; }
|
<S2SV_ModStart> scsi_status ) { pr_debug <S2SV_ModEnd> ( "compare_and_write_callback:<S2SV_blank>non<S2SV_blank>zero<S2SV_blank>scsi_status:" "<S2SV_blank>0x%02x\\n" <S2SV_ModStart> -> scsi_status ) ; * post_ret = 1 ; if ( cmd -> scsi_status == SAM_STAT_CHECK_CONDITION ) ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE
|
6,659 |
CWE-000 static void __attribute__ ( ( nonnull ) ) cancel_accept ( struct ev_loop * const l __attribute__ ( ( unused ) ) , ev_timer * const w __attribute__ ( ( unused ) ) , int e __attribute__ ( ( unused ) ) ) { warn ( DBG , "canceling<S2SV_blank>q_accept()" ) ; ev_timer_stop ( loop , & accept_alarm ) ; accept_queue = 0 ; <S2SV_StartBug> maybe_api_return ( q_accept , accept_queue ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> q_accept , accept_queue , 0
|
6,660 |
CWE-000 static int markAsPrivate ( ID id ) { TYPE_DESC tp = ID_TYPE ( id ) ; <S2SV_StartBug> if ( TYPE_IS_PUBLIC ( id ) || ( tp != NULL && TYPE_IS_PUBLIC ( tp ) ) ) { <S2SV_EndBug> error ( "\'%s\'<S2SV_blank>is<S2SV_blank>already<S2SV_blank>specified<S2SV_blank>as<S2SV_blank>public." , ID_NAME ( id ) ) ; return FALSE ; } TYPE_UNSET_PUBLIC ( id ) ; TYPE_SET_PRIVATE ( id ) ; <S2SV_StartBug> return TRUE ; <S2SV_EndBug> }
|
<S2SV_ModStart> NULL && TYPE_IS_PUBLIC ( tp ) && ! TYPE_ACCESS_IS_INFERRED <S2SV_ModStart> id ) ; if ( tp != NULL ) { TYPE_ACCESS_IS_INFERRED ( tp ) = FALSE ; }
|
6,661 |
CWE-000 static void faulthandler_disable ( void ) { unsigned int i ; fault_handler_t * handler ; if ( fatal_error . enabled ) { fatal_error . enabled = 0 ; for ( i = 0 ; i < faulthandler_nsignals ; i ++ ) { handler = & faulthandler_handlers [ i ] ; faulthandler_disable_fatal_handler ( handler ) ; } } <S2SV_StartBug> Py_CLEAR ( fatal_error . file ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> ; } } # ifdef MS_WINDOWS if ( fatal_error . exc_handler != NULL ) { RemoveVectoredExceptionHandler ( fatal_error . exc_handler ) ; fatal_error . exc_handler = NULL ; } # endif
|
6,662 |
CWE-000 void rb_insert ( struct rb_node_t * * root , int key ) { struct rb_node_t * parent ; struct rb_node_t * node ; parent = NULL ; node = * root ; while ( node != NULL ) { if ( node -> key == key ) { return ; } parent = node ; if ( key < node -> key ) { node = node -> left ; } else { node = node -> right ; } } node = alloc_rb_node ( key ) ; if ( parent == NULL ) { * root = node ; } else if ( key < parent -> key ) { <S2SV_StartBug> node = parent -> left ; <S2SV_EndBug> } else { <S2SV_StartBug> node = parent -> right ; <S2SV_EndBug> } <S2SV_StartBug> node -> color = RED ; <S2SV_EndBug> rb_insert_fixup ( root , node ) ; }
|
<S2SV_ModStart> key ) { <S2SV_ModEnd> parent -> left <S2SV_ModStart> parent -> left = node <S2SV_ModStart> } else { <S2SV_ModEnd> parent -> right <S2SV_ModStart> parent -> right = node <S2SV_ModStart> color = RED ; node -> parent = parent
|
6,663 |
CWE-000 void knocked_out ( struct char_data * ch , int duration ) { struct affected_type af ; if ( GET_POS ( ch ) == POS_SLEEPING ) <S2SV_StartBug> return ; <S2SV_EndBug> send_to_char ( ch , "Your<S2SV_blank>vision<S2SV_blank>goes<S2SV_blank>black...\\r\\n" ) ; GET_POS ( ch ) = POS_SLEEPING ; GET_STUN ( ch ) = 0 ; af . duration = duration ; }
|
<S2SV_ModStart> POS_SLEEPING ) return ; act ( "$n<S2SV_blank>eyes<S2SV_blank>roll<S2SV_blank>back<S2SV_blank>in<S2SV_blank>their<S2SV_blank>head." , TRUE , ch , 0 , 0 , TO_ROOM )
|
6,664 |
CWE-000 static int gttwsi_initiate_xfer ( void * v , i2c_addr_t addr , int flags ) { struct gttwsi_softc * sc = v ; <S2SV_StartBug> uint32_t data , expect ; <S2SV_EndBug> int error , read ; KASSERT ( sc -> sc_inuse ) ; gttwsi_send_start ( v , flags ) ; read = ( flags & I2C_F_READ ) != 0 ; <S2SV_StartBug> if ( read ) <S2SV_EndBug> expect = STAT_ARBT_AR ; <S2SV_StartBug> else <S2SV_EndBug> <S2SV_StartBug> expect = STAT_AWBT_AR ; <S2SV_EndBug> data = read ; if ( addr > 0x7f ) { data |= 0xf0 | ( ( addr & 0x300 ) >> 7 ) ; gttwsi_write_4 ( sc , TWSI_DATA , data ) ; <S2SV_StartBug> error = gttwsi_wait ( sc , 0 , expect , flags ) ; <S2SV_EndBug> if ( error ) return error ; <S2SV_StartBug> if ( read ) <S2SV_EndBug> expect = STAT_SARBT_AR ; <S2SV_StartBug> else <S2SV_EndBug> <S2SV_StartBug> expect = STAT_SAWBT_AR ; <S2SV_EndBug> data = ( uint8_t ) addr ; } else data |= ( addr << 1 ) ; gttwsi_write_4 ( sc , TWSI_DATA , data ) ; <S2SV_StartBug> return gttwsi_wait ( sc , 0 , expect , flags ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> data , expect , alt <S2SV_ModStart> ( read ) { <S2SV_ModStart> = STAT_ARBT_AR ; alt = STAT_ARBT_ANR ; } else { <S2SV_ModEnd> expect = STAT_AWBT_AR <S2SV_ModStart> = STAT_AWBT_AR ; alt = STAT_AWBT_ANR ; } <S2SV_ModStart> , expect , alt , <S2SV_ModStart> ( read ) { <S2SV_ModStart> = STAT_SARBT_AR ; alt = STAT_SARBT_ANR ; } else { <S2SV_ModEnd> expect = STAT_SAWBT_AR <S2SV_ModStart> = STAT_SAWBT_AR ; alt = STAT_SAWBT_ANR ; } <S2SV_ModStart> , expect , alt ,
|
6,665 |
CWE-000 u32 mr_spanset_get_span_block ( struct megasas_instance * instance , u32 ld , u64 row , u64 * span_blk , struct MR_DRV_RAID_MAP_ALL * map ) { struct fusion_context * fusion = instance -> ctrl_context ; struct MR_LD_RAID * raid = MR_LdRaidGet ( ld , map ) ; LD_SPAN_SET * span_set ; struct MR_QUAD_ELEMENT * quad ; u32 span , info ; PLD_SPAN_INFO ldSpanInfo = fusion -> log_to_span ; for ( info = 0 ; info < MAX_QUAD_DEPTH ; info ++ ) { span_set = & ( ldSpanInfo [ ld ] . span_set [ info ] ) ; if ( span_set -> span_row_data_width == 0 ) break ; if ( row > span_set -> data_row_end ) continue ; for ( span = 0 ; span < raid -> spanDepth ; span ++ ) if ( le32_to_cpu ( map -> raidMap . ldSpanMap [ ld ] . spanBlock [ span ] . block_span_info . noElements ) >= info + 1 ) { quad = & map -> raidMap . ldSpanMap [ ld ] . spanBlock [ span ] . block_span_info . quad [ info ] ; <S2SV_StartBug> if ( le32_to_cpu ( quad -> diff == 0 ) ) <S2SV_EndBug> return SPAN_INVALID ; if ( le64_to_cpu ( quad -> logStart ) <= row && row <= le64_to_cpu ( quad -> logEnd ) && ( mega_mod64 ( row - le64_to_cpu ( quad -> logStart ) , le32_to_cpu ( quad -> diff ) ) ) == 0 ) { if ( span_blk != NULL ) { u64 blk ; blk = mega_div64_32 ( ( row - le64_to_cpu ( quad -> logStart ) ) , le32_to_cpu ( quad -> diff ) ) ; blk = ( blk + le64_to_cpu ( quad -> offsetInSpan ) ) << raid -> stripeShift ; * span_blk = blk ; } return span ; } } } return SPAN_INVALID ; }
|
<S2SV_ModStart> quad -> diff ) == 0 <S2SV_ModEnd> ) return SPAN_INVALID
|
6,666 |
CWE-000 static int recursiveRemove ( int fd ) { struct stat rb ; DIR * dir ; int rc = - 1 ; int dfd ; if ( ! ( dir = fdopendir ( fd ) ) ) { warn ( _ ( "failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>directory" ) ) ; goto done ; } dfd = dirfd ( dir ) ; if ( fstat ( dfd , & rb ) ) { warn ( _ ( "stat<S2SV_blank>failed" ) ) ; goto done ; } while ( 1 ) { struct dirent * d ; int isdir = 0 ; errno = 0 ; if ( ! ( d = readdir ( dir ) ) ) { if ( errno ) { warn ( _ ( "failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>directory" ) ) ; goto done ; } break ; } if ( ! strcmp ( d -> d_name , "." ) || ! strcmp ( d -> d_name , ".." ) ) continue ; # ifdef _DIRENT_HAVE_D_TYPE if ( d -> d_type == DT_DIR || d -> d_type == DT_UNKNOWN ) # endif { struct stat sb ; if ( fstatat ( dfd , d -> d_name , & sb , AT_SYMLINK_NOFOLLOW ) ) { warn ( _ ( "stat<S2SV_blank>of<S2SV_blank>%s<S2SV_blank>failed" ) , d -> d_name ) ; continue ; } <S2SV_StartBug> if ( S_ISDIR ( sb . st_mode ) && sb . st_dev == rb . st_dev ) { <S2SV_EndBug> int cfd ; cfd = openat ( dfd , d -> d_name , O_RDONLY ) ; if ( cfd >= 0 ) { recursiveRemove ( cfd ) ; close ( cfd ) ; } isdir = 1 ; <S2SV_StartBug> } else <S2SV_EndBug> continue ; } if ( unlinkat ( dfd , d -> d_name , isdir ? AT_REMOVEDIR : 0 ) ) warn ( _ ( "failed<S2SV_blank>to<S2SV_blank>unlink<S2SV_blank>%s" ) , d -> d_name ) ; } rc = 0 ; done : if ( dir ) closedir ( dir ) ; return rc ; }
|
<S2SV_ModStart> } if ( sb . st_dev != rb . st_dev ) continue ; if ( <S2SV_ModStart> . st_mode ) <S2SV_ModEnd> ) { int <S2SV_ModStart> 1 ; } <S2SV_ModEnd> } if (
|
6,667 |
CWE-000 <S2SV_StartBug> static int skb_set_peeked ( struct sk_buff * skb ) <S2SV_EndBug> { struct sk_buff * nskb ; if ( skb -> peeked ) <S2SV_StartBug> return 0 ; <S2SV_EndBug> if ( ! skb_shared ( skb ) ) goto done ; nskb = skb_clone ( skb , GFP_ATOMIC ) ; if ( ! nskb ) <S2SV_StartBug> return - ENOMEM ; <S2SV_EndBug> skb -> prev -> next = nskb ; skb -> next -> prev = nskb ; nskb -> prev = skb -> prev ; nskb -> next = skb -> next ; consume_skb ( skb ) ; skb = nskb ; done : skb -> peeked = 1 ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> }
|
<S2SV_ModStart> <S2SV_null> <S2SV_null> static struct sk_buff * <S2SV_ModEnd> skb_set_peeked ( struct <S2SV_ModStart> peeked ) return skb <S2SV_ModEnd> ; if ( <S2SV_ModStart> nskb ) return ERR_PTR ( - ENOMEM ) <S2SV_ModEnd> ; skb -> <S2SV_ModStart> 1 ; return skb <S2SV_ModEnd> ; } <S2SV_null>
|
6,668 |
CWE-000 static int msm_isp_prepare_isp_buf ( struct msm_isp_buf_mgr * buf_mgr , struct msm_isp_buffer * buf_info , struct msm_isp_qbuf_buffer * qbuf_buf ) { int i , rc = - 1 ; struct msm_isp_buffer_mapped_info * mapped_info ; struct buffer_cmd * buf_pending = NULL ; int domain_num ; uint32_t accu_length = 0 ; unsigned long flags ; if ( buf_mgr -> secure_enable == NON_SECURE_MODE ) domain_num = buf_mgr -> iommu_domain_num ; else domain_num = buf_mgr -> iommu_domain_num_secure ; for ( i = 0 ; i < qbuf_buf -> num_planes ; i ++ ) { mapped_info = & buf_info -> mapped_info [ i ] ; mapped_info -> handle = ion_import_dma_buf ( buf_mgr -> client , qbuf_buf -> planes [ i ] . addr ) ; if ( IS_ERR_OR_NULL ( mapped_info -> handle ) ) { <S2SV_StartBug> pr_err_ratelimited ( "%s:<S2SV_blank>null/error<S2SV_blank>ION<S2SV_blank>handle<S2SV_blank>%p\\n" , <S2SV_EndBug> __func__ , mapped_info -> handle ) ; goto ion_map_error ; } if ( ion_map_iommu ( buf_mgr -> client , mapped_info -> handle , domain_num , 0 , SZ_4K , 0 , & ( mapped_info -> paddr ) , & ( mapped_info -> len ) , 0 , 0 ) < 0 ) { rc = - EINVAL ; pr_err ( "%s:<S2SV_blank>cannot<S2SV_blank>map<S2SV_blank>address" , __func__ ) ; ion_free ( buf_mgr -> client , mapped_info -> handle ) ; goto ion_map_error ; } mapped_info -> paddr += accu_length ; mapped_info -> len -= accu_length ; accu_length += qbuf_buf -> planes [ i ] . length ; CDBG ( "%s:<S2SV_blank>plane:<S2SV_blank>%d<S2SV_blank>addr:%lu\\n" , __func__ , i , ( unsigned long ) mapped_info -> paddr ) ; buf_pending = kzalloc ( sizeof ( struct buffer_cmd ) , GFP_ATOMIC ) ; if ( ! buf_pending ) { pr_err ( "No<S2SV_blank>free<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>buf_pending\\n" ) ; return rc ; } buf_pending -> mapped_info = mapped_info ; spin_lock_irqsave ( & buf_mgr -> bufq_list_lock , flags ) ; list_add_tail ( & buf_pending -> list , & buf_mgr -> buffer_q ) ; spin_unlock_irqrestore ( & buf_mgr -> bufq_list_lock , flags ) ; } buf_info -> num_planes = qbuf_buf -> num_planes ; return 0 ; ion_map_error : for ( -- i ; i >= 0 ; i -- ) { mapped_info = & buf_info -> mapped_info [ i ] ; ion_unmap_iommu ( buf_mgr -> client , mapped_info -> handle , buf_mgr -> iommu_domain_num , 0 ) ; ion_free ( buf_mgr -> client , mapped_info -> handle ) ; } return rc ; }
|
<S2SV_ModStart> { pr_err_ratelimited ( "%s:<S2SV_blank>null/error<S2SV_blank>ION<S2SV_blank>handle<S2SV_blank>%pK\\n" <S2SV_ModEnd> , __func__ ,
|
6,669 |
CWE-000 float calcsd ( float data [ ] , float min , float max ) { float sum = 0.0 , mean = 0.0 , sd = 0.0 ; <S2SV_StartBug> int i = 0 ; <S2SV_EndBug> mean = calcmean ( data , min , max ) ; for ( i = 0 ; i < NUMMEASURES ; i ++ ) { if ( ( data [ i ] < max ) && ( data [ i ] > min ) ) { sd += pow ( data [ i ] - mean , 2 ) ; <S2SV_StartBug> } <S2SV_EndBug> } <S2SV_StartBug> return sqrt ( sd / NUMMEASURES ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> ; int i = 0 ; int c <S2SV_ModStart> 2 ) ; c ++ ; <S2SV_ModStart> ( sd / c <S2SV_ModEnd> ) ; }
|
6,670 |
CWE-000 int glusterfs_handle_terminate ( rpcsvc_request_t * req ) { gd1_mgmt_brick_op_req xlator_req = { 0 , } ; ssize_t ret ; glusterfs_ctx_t * ctx = NULL ; xlator_t * top = NULL ; xlator_t * victim = NULL ; xlator_list_t * * trav_p = NULL ; <S2SV_StartBug> gf_boolean_t lockflag = _gf_false ; <S2SV_EndBug> ret = xdr_to_generic ( req -> msg [ 0 ] , & xlator_req , ( xdrproc_t ) xdr_gd1_mgmt_brick_op_req ) ; if ( ret < 0 ) { req -> rpc_err = GARBAGE_ARGS ; return - 1 ; } ctx = glusterfsd_ctx ; LOCK ( & ctx -> volfile_lock ) ; { if ( glusterfsd_ctx -> active ) { top = glusterfsd_ctx -> active -> first ; for ( trav_p = & top -> children ; * trav_p ; trav_p = & ( * trav_p ) -> next ) { victim = ( * trav_p ) -> xlator ; if ( strcmp ( victim -> name , xlator_req . name ) == 0 ) { break ; } } } } if ( ! * trav_p ) { gf_log ( THIS -> name , GF_LOG_ERROR , "can\'t<S2SV_blank>terminate<S2SV_blank>%s<S2SV_blank>-<S2SV_blank>not<S2SV_blank>found" , xlator_req . name ) ; <S2SV_StartBug> glusterfs_terminate_response_send ( req , 0 ) ; <S2SV_EndBug> goto err ; } <S2SV_StartBug> glusterfs_terminate_response_send ( req , 0 ) ; <S2SV_EndBug> if ( ( trav_p == & top -> children ) && ! ( * trav_p ) -> next ) { <S2SV_StartBug> gf_log ( THIS -> name , GF_LOG_INFO , <S2SV_EndBug> <S2SV_StartBug> "terminating<S2SV_blank>after<S2SV_blank>loss<S2SV_blank>of<S2SV_blank>last<S2SV_blank>child<S2SV_blank>%s" , <S2SV_EndBug> xlator_req . name ) ; rpc_clnt_mgmt_pmap_signout ( glusterfsd_ctx , xlator_req . name ) ; kill ( getpid ( ) , SIGTERM ) ; <S2SV_StartBug> } else { <S2SV_EndBug> UNLOCK ( & ctx -> volfile_lock ) ; lockflag = _gf_true ; gf_log ( THIS -> name , GF_LOG_INFO , "detaching<S2SV_blank>not-only" "<S2SV_blank>child<S2SV_blank>%s" , xlator_req . name ) ; top -> notify ( top , GF_EVENT_CLEANUP , victim ) ; xlator_mem_cleanup ( victim ) ; } err : if ( ! lockflag ) UNLOCK ( & ctx -> volfile_lock ) ; free ( xlator_req . name ) ; xlator_req . name = NULL ; return 0 ; }
|
<S2SV_ModStart> ; gf_boolean_t lockflag = _gf_false ; gf_boolean_t last_brick <S2SV_ModStart> req , 0 , last_brick <S2SV_ModStart> err ; } <S2SV_ModEnd> if ( ( <S2SV_ModStart> next ) { last_brick = _gf_true ; glusterfs_terminate_response_send ( req , 0 , last_brick ) ; <S2SV_ModStart> , GF_LOG_INFO , "This<S2SV_blank>is<S2SV_blank>last<S2SV_blank>brick<S2SV_blank>of<S2SV_blank>process." "glusterD<S2SV_blank>will<S2SV_blank>kill<S2SV_blank>the<S2SV_blank>process<S2SV_blank>and<S2SV_blank>takes<S2SV_blank>care<S2SV_blank>of<S2SV_blank>" "removal<S2SV_blank>of<S2SV_blank>entries<S2SV_blank>from<S2SV_blank>port<S2SV_blank>map<S2SV_blank>register" <S2SV_ModEnd> ) ; } <S2SV_ModStart> } else { glusterfs_terminate_response_send ( req , 0 , last_brick ) ;
|
6,671 |
CWE-000 static __inline void usemap_free ( struct msdosfsmount * pmp , u_long cn ) { MSDOSFS_ASSERT_MP_LOCKED ( pmp ) ; KASSERT ( cn <= pmp -> pm_maxcluster , ( "cn<S2SV_blank>too<S2SV_blank>large<S2SV_blank>%lu<S2SV_blank>%lu" , cn , pmp -> pm_maxcluster ) ) ; KASSERT ( ( pmp -> pm_flags & MSDOSFSMNT_RONLY ) == 0 , ( "usemap_free<S2SV_blank>on<S2SV_blank>ro<S2SV_blank>msdosfs<S2SV_blank>mount" ) ) ; pmp -> pm_freeclustercount ++ ; pmp -> pm_flags |= MSDOSFS_FSIMOD ; KASSERT ( ( pmp -> pm_inusemap [ cn / N_INUSEBITS ] & ( 1 << ( cn % N_INUSEBITS ) ) ) != 0 , ( "Freeing<S2SV_blank>unused<S2SV_blank>sector<S2SV_blank>%ld<S2SV_blank>%ld<S2SV_blank>%x" , cn , cn % N_INUSEBITS , ( unsigned ) pmp -> pm_inusemap [ cn / N_INUSEBITS ] ) ) ; <S2SV_StartBug> pmp -> pm_inusemap [ cn / N_INUSEBITS ] &= ~ ( 1 << ( cn % N_INUSEBITS ) ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> &= ~ ( 1U <S2SV_ModEnd> << ( cn
|
6,672 |
CWE-000 extern int eav_setup ( eav_t * eav ) { if ( eav -> utf8 || eav -> rfc == EAV_RFC_6531 ) { <S2SV_StartBug> if ( eav -> tld_check ) <S2SV_EndBug> eav -> utf8_cb = is_6531_email_fqdn ; else <S2SV_StartBug> eav -> utf8_cb = is_6531_email ; <S2SV_EndBug> eav -> utf8 = true ; return init_idn ( eav ) ; } eav -> utf8 = false ; switch ( eav -> rfc ) { case EAV_RFC_822 : eav -> ascii_cb = is_822_email ; break ; case EAV_RFC_5321 : eav -> ascii_cb = is_5321_email ; break ; case EAV_RFC_5322 : eav -> ascii_cb = is_5322_email ; break ; default : return EEAV_INVALID_RFC ; } return EEAV_NO_ERROR ; }
|
<S2SV_ModStart> EAV_RFC_6531 ) { eav -> utf8 = true ; <S2SV_ModEnd> eav -> utf8_cb <S2SV_ModStart> utf8_cb = is_6531_email <S2SV_ModEnd> ; return init_idn
|
6,673 |
CWE-000 attribute_t schema_find_attr_by_name ( schema_t s , char * name ) { <S2SV_StartBug> attribute_t attr ; <S2SV_EndBug> assert ( s != NULL ) ; # if _DEBUG printf ( "find<S2SV_blank>attribute<S2SV_blank>[%s]\\n" , name ) ; # endif for ( attr = s -> attrlist ; attr != NULL ; attr = attr -> next ) if ( strcasecmp ( name , attr -> name ) == 0 ) return attr ; return NULL ; }
|
<S2SV_ModStart> { attribute_t attr = NULL
|
6,674 |
CWE-000 static int check_object ( struct object * obj , int type , void * data , struct fsck_options * options ) { struct obj_buffer * obj_buf ; if ( ! obj ) return 1 ; if ( obj -> flags & FLAG_WRITTEN ) return 0 ; if ( type != OBJ_ANY && obj -> type != type ) die ( "object<S2SV_blank>type<S2SV_blank>mismatch" ) ; if ( ! ( obj -> flags & FLAG_OPEN ) ) { unsigned long size ; int type = oid_object_info ( the_repository , & obj -> oid , & size ) ; if ( type != obj -> type || type <= 0 ) die ( "object<S2SV_blank>of<S2SV_blank>unexpected<S2SV_blank>type" ) ; obj -> flags |= FLAG_WRITTEN ; return 0 ; } obj_buf = lookup_object_buffer ( obj ) ; if ( ! obj_buf ) die ( "Whoops!<S2SV_blank>Cannot<S2SV_blank>find<S2SV_blank>object<S2SV_blank>\'%s\'" , oid_to_hex ( & obj -> oid ) ) ; if ( fsck_object ( obj , obj_buf -> buffer , obj_buf -> size , & fsck_options ) ) <S2SV_StartBug> die ( "Error<S2SV_blank>in<S2SV_blank>object" ) ; <S2SV_EndBug> fsck_options . walk = check_object ; if ( fsck_walk ( obj , NULL , & fsck_options ) ) die ( "Error<S2SV_blank>on<S2SV_blank>reachable<S2SV_blank>objects<S2SV_blank>of<S2SV_blank>%s" , oid_to_hex ( & obj -> oid ) ) ; write_cached_object ( obj , obj_buf ) ; return 0 ; }
|
<S2SV_ModStart> ) die ( "fsck<S2SV_blank>error<S2SV_blank>in<S2SV_blank>packed<S2SV_blank>object" <S2SV_ModEnd> ) ; fsck_options
|
6,675 |
CWE-000 int wma_dfs_indicate_radar ( struct ieee80211com * ic , struct ieee80211_channel * ichan ) { tp_wma_handle wma ; void * hdd_ctx ; struct wma_dfs_radar_indication * radar_event ; struct hdd_dfs_radar_ind hdd_radar_event ; void * vos_context = vos_get_global_context ( VOS_MODULE_ID_WDA , NULL ) ; tpAniSirGlobal pmac = NULL ; wma = ( tp_wma_handle ) vos_get_context ( VOS_MODULE_ID_WDA , vos_context ) ; if ( wma == NULL ) { WMA_LOGE ( "%s:<S2SV_blank>DFS-<S2SV_blank>Invalid<S2SV_blank>wma" , __func__ ) ; return - ENOENT ; } hdd_ctx = vos_get_context ( VOS_MODULE_ID_HDD , wma -> vos_context ) ; pmac = ( tpAniSirGlobal ) vos_get_context ( VOS_MODULE_ID_PE , wma -> vos_context ) ; if ( wma -> dfs_ic != ic ) { WMA_LOGE ( "%s:DFS-<S2SV_blank>Invalid<S2SV_blank>WMA<S2SV_blank>handle" , __func__ ) ; return - ENOENT ; } <S2SV_StartBug> radar_event = ( struct wma_dfs_radar_indication * ) <S2SV_EndBug> vos_mem_malloc ( sizeof ( struct wma_dfs_radar_indication ) ) ; if ( radar_event == NULL ) { WMA_LOGE ( "%s:DFS-<S2SV_blank>Invalid<S2SV_blank>radar_event" , __func__ ) ; return - ENOENT ; } adf_os_spin_lock_bh ( & ic -> chan_lock ) ; if ( ! pmac -> sap . SapDfsInfo . disable_dfs_ch_switch ) wma -> dfs_ic -> disable_phy_err_processing = true ; if ( ( ichan -> ic_ieee != ( wma -> dfs_ic -> last_radar_found_chan ) ) || ( pmac -> sap . SapDfsInfo . disable_dfs_ch_switch == VOS_TRUE ) ) { <S2SV_StartBug> wma -> dfs_ic -> last_radar_found_chan = ichan -> ic_ieee ; <S2SV_EndBug> hdd_radar_event . ieee_chan_number = ichan -> ic_ieee ; hdd_radar_event . chan_freq = ichan -> ic_freq ; hdd_radar_event . dfs_radar_status = WMA_DFS_RADAR_FOUND ; wma -> dfs_radar_indication_cb ( hdd_ctx , & hdd_radar_event ) ; WMA_LOGE ( "%s:DFS-<S2SV_blank>RADAR<S2SV_blank>INDICATED<S2SV_blank>TO<S2SV_blank>HDD" , __func__ ) ; radar_event -> vdev_id = ic -> vdev_id ; wma_get_channels ( ichan , & radar_event -> chan_list ) ; radar_event -> dfs_radar_status = WMA_DFS_RADAR_FOUND ; radar_event -> use_nol = ic -> ic_dfs_usenol ( ic ) ; wma_send_msg ( wma , WDA_DFS_RADAR_IND , ( void * ) radar_event , 0 ) ; WMA_LOGE ( "%s:DFS-<S2SV_blank>WDA_DFS_RADAR_IND<S2SV_blank>Message<S2SV_blank>Posted" , __func__ ) ; } adf_os_spin_unlock_bh ( & ic -> chan_lock ) ; return 0 ; }
|
<S2SV_ModStart> ENOENT ; } <S2SV_ModEnd> adf_os_spin_lock_bh ( & <S2SV_ModStart> ) ) { radar_event = ( struct wma_dfs_radar_indication * ) vos_mem_malloc ( sizeof ( * radar_event ) ) ; if ( radar_event == NULL ) { WMA_LOGE ( FL ( "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>radar_event" ) ) ; return - ENOMEM ; }
|
6,676 |
CWE-000 int main ( int argc __unused , char * * argv __unused ) { struct sched_param param = { . sched_priority = 1 , } ; level_oomadj [ VMPRESS_LEVEL_LOW ] = property_get_int32 ( "ro.lmk.low" , OOM_SCORE_ADJ_MAX + 1 ) ; level_oomadj [ VMPRESS_LEVEL_MEDIUM ] = property_get_int32 ( "ro.lmk.medium" , 800 ) ; level_oomadj [ VMPRESS_LEVEL_CRITICAL ] = property_get_int32 ( "ro.lmk.critical" , 0 ) ; debug_process_killing = property_get_bool ( "ro.lmk.debug" , false ) ; enable_pressure_upgrade = property_get_bool ( "ro.lmk.critical_upgrade" , false ) ; upgrade_pressure = ( int64_t ) property_get_int32 ( "ro.lmk.upgrade_pressure" , 100 ) ; downgrade_pressure = ( int64_t ) property_get_int32 ( "ro.lmk.downgrade_pressure" , 100 ) ; kill_heaviest_task = <S2SV_StartBug> property_get_bool ( "ro.lmk.kill_heaviest_task" , true ) ; <S2SV_EndBug> low_ram_device = property_get_bool ( "ro.config.low_ram" , false ) ; kill_timeout_ms = ( unsigned long ) property_get_int32 ( "ro.lmk.kill_timeout_ms" , 0 ) ; if ( ! init ( ) ) { if ( ! use_inkernel_interface ) { if ( mlockall ( MCL_CURRENT | MCL_FUTURE | MCL_ONFAULT ) && ( errno != EINVAL ) ) { ALOGW ( "mlockall<S2SV_blank>failed<S2SV_blank>%s" , strerror ( errno ) ) ; } sched_setscheduler ( 0 , SCHED_FIFO , & param ) ; } mainloop ( ) ; } ALOGI ( "exiting" ) ; return 0 ; }
|
<S2SV_ModStart> ( "ro.lmk.kill_heaviest_task" , false <S2SV_ModEnd> ) ; low_ram_device
|
6,677 |
CWE-000 static int32_t msm_cci_transfer_end ( struct cci_device * cci_dev , enum cci_i2c_master_t master , enum cci_i2c_queue_t queue ) { int32_t rc = 0 ; <S2SV_StartBug> if ( 0 == atomic_read ( & cci_dev -> cci_master_info [ master ] . q_free [ queue ] ) ) { <S2SV_EndBug> <S2SV_StartBug> rc = msm_cci_lock_queue ( cci_dev , master , queue , 0 ) ; <S2SV_EndBug> if ( rc < 0 ) { pr_err ( "%s<S2SV_blank>failed<S2SV_blank>line<S2SV_blank>%d\\n" , __func__ , __LINE__ ) ; return rc ; } rc = msm_cci_wait_report_cmd ( cci_dev , master , queue ) ; if ( rc < 0 ) { pr_err ( "%s:<S2SV_blank>%d<S2SV_blank>failed<S2SV_blank>rc<S2SV_blank>%d\\n" , __func__ , __LINE__ , rc ) ; return rc ; } } else { atomic_set ( & cci_dev -> cci_master_info [ master ] . done_pending [ queue ] , 1 ) ; <S2SV_StartBug> rc = msm_cci_wait ( cci_dev , master , queue ) ; <S2SV_EndBug> if ( rc < 0 ) { pr_err ( "%s:<S2SV_blank>%d<S2SV_blank>failed<S2SV_blank>rc<S2SV_blank>%d\\n" , __func__ , __LINE__ , rc ) ; return rc ; } rc = msm_cci_lock_queue ( cci_dev , master , queue , 0 ) ; if ( rc < 0 ) { pr_err ( "%s<S2SV_blank>failed<S2SV_blank>line<S2SV_blank>%d\\n" , __func__ , __LINE__ ) ; return rc ; } rc = msm_cci_wait_report_cmd ( cci_dev , master , queue ) ; if ( rc < 0 ) { pr_err ( "%s:<S2SV_blank>%d<S2SV_blank>failed<S2SV_blank>rc<S2SV_blank>%d\\n" , __func__ , __LINE__ , rc ) ; return rc ; } } return rc ; }
|
<S2SV_ModStart> = 0 ; unsigned long flags ; spin_lock_irqsave ( & cci_dev -> cci_master_info [ master ] . lock_q [ queue ] , flags ) ; <S2SV_ModStart> ) ) { spin_unlock_irqrestore ( & cci_dev -> cci_master_info [ master ] . lock_q [ queue ] , flags ) ; <S2SV_ModStart> 1 ) ; spin_unlock_irqrestore ( & cci_dev -> cci_master_info [ master ] . lock_q [ queue ] , flags ) ;
|
6,678 |
CWE-000 UINT8 * get_base ( UINT8 buffer [ ] ) { UINT8 * base ; <S2SV_StartBug> int difference ; <S2SV_EndBug> base = buffer ; <S2SV_StartBug> return base ; <S2SV_EndBug> }
|
<S2SV_ModStart> * base ; unsigned <S2SV_ModStart> = buffer ; difference = ( int ) base ; difference %= 0x100 ; difference = 0x100 - difference ; return base + difference <S2SV_ModEnd> ; } <S2SV_null>
|
6,679 |
CWE-000 static PyObject * tblot ( PyObject * obj , PyObject * args , PyObject * keywords ) { const char * kwlist [ ] = { "source" , "pixmap" , "output" , "xmin" , "xmax" , "ymin" , "ymax" , "scale" , "kscale" , "interp" , "exptime" , "misval" , "sinscl" , NULL } ; PyObject * oimg , * pixmap , * oout ; long xmin = 0 ; long xmax = 0 ; long ymin = 0 ; long ymax = 0 ; double scale = 1.0 ; float kscale = 1.0 ; char * interp_str = "poly5" ; float ef = 1.0 ; float misval = 0.0 ; float sinscl = 1.0 ; PyArrayObject * img = NULL , * out = NULL , * map = NULL ; enum e_interp_t interp ; int istat = 0 ; struct driz_error_t error ; struct driz_param_t p ; integer_t osize [ 2 ] ; <S2SV_StartBug> driz_error_init ( & error ) ; <S2SV_EndBug> if ( ! PyArg_ParseTupleAndKeywords ( args , keywords , "OOO|lllldfsfff:tblot" , ( char * * ) kwlist , & oimg , & pixmap , & oout , & xmin , & xmax , & ymin , & ymax , & scale , & kscale , & interp_str , & ef , & misval , & sinscl ) ) { return NULL ; } img = ( PyArrayObject * ) PyArray_ContiguousFromAny ( oimg , NPY_FLOAT , 2 , 2 ) ; if ( ! img ) { driz_error_set_message ( & error , "Invalid<S2SV_blank>input<S2SV_blank>array" ) ; goto _exit ; } map = ( PyArrayObject * ) PyArray_ContiguousFromAny ( pixmap , NPY_DOUBLE , 3 , 3 ) ; if ( ! map ) { driz_error_set_message ( & error , "Invalid<S2SV_blank>pixmap<S2SV_blank>array" ) ; goto _exit ; } out = ( PyArrayObject * ) PyArray_ContiguousFromAny ( oout , NPY_FLOAT , 2 , 2 ) ; if ( ! out ) { driz_error_set_message ( & error , "Invalid<S2SV_blank>output<S2SV_blank>array" ) ; goto _exit ; } if ( interp_str2enum ( interp_str , & interp , & error ) ) { goto _exit ; } get_dimensions ( out , osize ) ; if ( xmax == 0 ) xmax = osize [ 0 ] ; if ( ymax == 0 ) ymax = osize [ 1 ] ; driz_param_init ( & p ) ; p . data = img ; p . output_data = out ; p . xmin = xmin ; p . xmax = xmax ; p . ymin = ymin ; p . ymax = ymax ; p . scale = scale ; p . kscale = kscale ; p . in_units = unit_cps ; p . interpolation = interp ; p . ef = ef ; p . misval = misval ; p . sinscl = sinscl ; p . pixmap = map ; p . error = & error ; if ( driz_error_check ( & error , "xmin<S2SV_blank>must<S2SV_blank>be<S2SV_blank>>=<S2SV_blank>0" , p . xmin >= 0 ) ) goto _exit ; if ( driz_error_check ( & error , "ymin<S2SV_blank>must<S2SV_blank>be<S2SV_blank>>=<S2SV_blank>0" , p . ymin >= 0 ) ) goto _exit ; if ( driz_error_check ( & error , "xmax<S2SV_blank>must<S2SV_blank>be<S2SV_blank>><S2SV_blank>xmin" , p . xmax > p . xmin ) ) goto _exit ; if ( driz_error_check ( & error , "ymax<S2SV_blank>must<S2SV_blank>be<S2SV_blank>><S2SV_blank>ymin" , p . ymax > p . ymin ) ) goto _exit ; if ( driz_error_check ( & error , "scale<S2SV_blank>must<S2SV_blank>be<S2SV_blank>><S2SV_blank>0" , p . scale > 0.0 ) ) goto _exit ; if ( driz_error_check ( & error , "kscale<S2SV_blank>must<S2SV_blank>be<S2SV_blank>><S2SV_blank>0" , p . kscale > 0.0 ) ) goto _exit ; if ( driz_error_check ( & error , "exposure<S2SV_blank>time<S2SV_blank>must<S2SV_blank>be<S2SV_blank>><S2SV_blank>0" , p . ef > 0.0 ) ) goto _exit ; if ( doblot ( & p ) ) goto _exit ; _exit : <S2SV_StartBug> Py_DECREF ( img ) ; <S2SV_EndBug> Py_DECREF ( out ) ; Py_DECREF ( map ) ; if ( driz_error_is_set ( & error ) ) { if ( strcmp ( driz_error_get_message ( & error ) , "<PYTHON>" ) != 0 ) PyErr_SetString ( PyExc_Exception , driz_error_get_message ( & error ) ) ; return NULL ; } else { return Py_BuildValue ( "i" , istat ) ; } }
|
<S2SV_ModStart> 2 ] ; driz_log_handle = driz_log_init ( driz_log_handle ) ; driz_log_message ( "starting<S2SV_blank>tnlot" ) ; <S2SV_ModStart> ; _exit : driz_log_message ( "ending<S2SV_blank>tblot" ) ; driz_log_close ( driz_log_handle ) ;
|
6,680 |
CWE-000 void addCard ( cardHandler_t * cardHandler , cardvalue_t card ) { cardHandler_t * index = cardHandler ; cardHandler_t * addCardStruct = NULL ; bool added = 0 ; while ( ! added ) { <S2SV_StartBug> if ( index -> card [ 0 ] == - 1 ) <S2SV_EndBug> { added = 1 ; <S2SV_StartBug> index -> card [ 0 ] = card ; <S2SV_EndBug> } <S2SV_StartBug> else if ( index -> card [ 1 ] == - 1 ) <S2SV_EndBug> { added = 1 ; <S2SV_StartBug> index -> card [ 1 ] = card ; <S2SV_EndBug> } else if ( index -> next == NULL ) { addCardStruct = malloc ( sizeof ( cardHandler_t ) ) ; addCardStruct -> next = NULL ; <S2SV_StartBug> addCardStruct -> card [ 0 ] = card ; <S2SV_EndBug> <S2SV_StartBug> addCardStruct -> card [ 1 ] = - 1 ; <S2SV_EndBug> index -> next = addCardStruct ; added = 1 ; } else index = index -> next ; } }
|
<S2SV_ModStart> ( index -> cards <S2SV_ModEnd> [ 0 ] <S2SV_ModStart> ; index -> cards <S2SV_ModEnd> [ 0 ] <S2SV_ModStart> ( index -> cards <S2SV_ModEnd> [ 1 ] <S2SV_ModStart> ; index -> cards <S2SV_ModEnd> [ 1 ] <S2SV_ModStart> ; addCardStruct -> cards <S2SV_ModEnd> [ 0 ] <S2SV_ModStart> ; addCardStruct -> cards <S2SV_ModEnd> [ 1 ]
|
6,681 |
CWE-000 void dacp_monitor_port_update_callback ( char * dacp_id , uint16_t port ) { <S2SV_StartBug> debug ( 3 , "dacp_monitor_port_update_callback<S2SV_blank>with<S2SV_blank>Remote<S2SV_blank>ID<S2SV_blank>\\"%s\\"<S2SV_blank>and<S2SV_blank>port<S2SV_blank>number<S2SV_blank>%d." , dacp_id , <S2SV_EndBug> port ) ; sps_pthread_mutex_timedlock ( & dacp_server_information_lock , 500000 , "dacp_monitor_port_update_callback<S2SV_blank>couldn\'t<S2SV_blank>get<S2SV_blank>DACP<S2SV_blank>server<S2SV_blank>information<S2SV_blank>lock<S2SV_blank>in<S2SV_blank>0.5<S2SV_blank>second!." , 2 ) ; if ( strcmp ( dacp_id , dacp_server . dacp_id ) == 0 ) { dacp_server . port = port ; if ( port == 0 ) dacp_server . scan_enable = 0 ; else dacp_server . scan_enable = 1 ; metadata_hub_modify_prolog ( ) ; int ch = metadata_store . dacp_server_active != dacp_server . scan_enable ; metadata_store . dacp_server_active = dacp_server . scan_enable ; metadata_hub_modify_epilog ( ch ) ; pthread_cond_signal ( & dacp_server_information_cv ) ; } else { debug ( 1 , "dacp<S2SV_blank>port<S2SV_blank>monitor<S2SV_blank>reporting<S2SV_blank>on<S2SV_blank>an<S2SV_blank>out-of-use<S2SV_blank>remote." ) ; } pthread_mutex_unlock ( & dacp_server_information_lock ) ; }
|
<S2SV_ModStart> port ) { <S2SV_ModEnd> sps_pthread_mutex_timedlock ( &
|
6,682 |
CWE-000 static void invoke_swaybar ( struct bar_config * bar ) { int filedes [ 2 ] ; if ( pipe ( filedes ) == - 1 ) { sway_log ( L_ERROR , "Pipe<S2SV_blank>setup<S2SV_blank>failed!<S2SV_blank>Cannot<S2SV_blank>fork<S2SV_blank>into<S2SV_blank>bar" ) ; return ; } bar -> pid = fork ( ) ; if ( bar -> pid == 0 ) { close ( filedes [ 0 ] ) ; if ( ! bar -> swaybar_command ) { char * const cmd [ ] = { "swaybar" , "-b" , bar -> id , NULL , } ; close ( filedes [ 1 ] ) ; execvp ( cmd [ 0 ] , cmd ) ; _exit ( EXIT_SUCCESS ) ; } else { int len = strlen ( bar -> swaybar_command ) + strlen ( bar -> id ) + 5 ; char * command = malloc ( len * sizeof ( char ) ) ; if ( ! command ) { const char msg [ ] = "Unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>swaybar<S2SV_blank>command<S2SV_blank>string" ; int len = sizeof ( msg ) ; <S2SV_StartBug> write ( filedes [ 1 ] , & len , sizeof ( int ) ) ; <S2SV_EndBug> <S2SV_StartBug> write ( filedes [ 1 ] , msg , len ) ; <S2SV_EndBug> close ( filedes [ 1 ] ) ; _exit ( EXIT_FAILURE ) ; } snprintf ( command , len , "%s<S2SV_blank>-b<S2SV_blank>%s" , bar -> swaybar_command , bar -> id ) ; char * const cmd [ ] = { "sh" , "-c" , command , NULL , } ; close ( filedes [ 1 ] ) ; execvp ( cmd [ 0 ] , cmd ) ; free ( command ) ; _exit ( EXIT_SUCCESS ) ; } } close ( filedes [ 0 ] ) ; int len ; if ( read ( filedes [ 1 ] , & len , sizeof ( int ) ) == sizeof ( int ) ) { char * buf = malloc ( len ) ; if ( ! buf ) { sway_log ( L_ERROR , "Cannot<S2SV_blank>allocate<S2SV_blank>error<S2SV_blank>string" ) ; return ; } if ( read ( filedes [ 1 ] , buf , len ) ) { sway_log ( L_ERROR , "%s" , buf ) ; } free ( buf ) ; } close ( filedes [ 1 ] ) ; }
|
<S2SV_ModStart> msg ) ; if ( <S2SV_ModStart> int ) ) ) { } ; if ( <S2SV_ModEnd> write ( filedes <S2SV_ModStart> , len ) ) { }
|
6,683 |
CWE-000 static int string_search_replace ( int argc , RESULT_NODE * * argv , void * item , RESULT_NODE * result , THREAD * gsl_thread ) { RESULT_NODE * strbuf = argc > 0 ? argv [ 0 ] : NULL ; RESULT_NODE * search = argc > 1 ? argv [ 1 ] : NULL ; RESULT_NODE * replace = argc > 2 ? argv [ 2 ] : NULL ; if ( ! strbuf ) { strcpy ( object_error , "Missing<S2SV_blank>argument:<S2SV_blank>strbuf" ) ; return - 1 ; } if ( strbuf -> value . type == TYPE_UNDEFINED ) { result -> culprit = strbuf -> culprit ; strbuf -> culprit = NULL ; return 0 ; } if ( ! search ) { strcpy ( object_error , "Missing<S2SV_blank>argument:<S2SV_blank>search" ) ; return - 1 ; } if ( search -> value . type == TYPE_UNDEFINED ) { result -> culprit = search -> culprit ; search -> culprit = NULL ; return 0 ; } if ( ! replace ) { strcpy ( object_error , "Missing<S2SV_blank>argument:<S2SV_blank>replace" ) ; return - 1 ; } if ( replace -> value . type == TYPE_UNDEFINED ) { result -> culprit = replace -> culprit ; replace -> culprit = NULL ; return 0 ; } { char * strbuf_ , * search_ , * replace_ , * replace_location , * output ; size_t search_length , replace_length , result_length ; strbuf_ = string_value ( & strbuf -> value ) ; search_ = string_value ( & search -> value ) ; search_length = strlen ( search_ ) ; replace_ = string_value ( & replace -> value ) ; replace_length = strlen ( replace_ ) ; replace_location = strstr ( strbuf_ , search_ ) ; if ( replace_location == NULL ) { <S2SV_StartBug> result -> value . s = strdup ( strbuf_ ) ; <S2SV_EndBug> result -> value . type = TYPE_STRING ; } else { result_length = strlen ( strbuf_ ) - search_length + replace_length ; output = mem_alloc ( result_length + 1 ) ; result -> value . s = output ; result -> value . type = TYPE_STRING ; strncpy ( output , strbuf_ , replace_location - strbuf_ ) ; output += replace_location - strbuf_ ; strcpy ( output , replace_ ) ; output += replace_length ; strcpy ( output , replace_location + search_length ) ; } } return 0 ; }
|
<S2SV_ModStart> . s = mem_strdup <S2SV_ModEnd> ( strbuf_ )
|
6,684 |
CWE-000 const char * gu_str2bool ( const char * str , bool * b ) { size_t const len = strlen ( str ) ; int res = - 1 ; switch ( len ) { case 1 : switch ( str [ 0 ] ) { case '0' : case 'N' : case 'n' : res = 0 ; break ; case '1' : case 'Y' : case 'y' : res = 1 ; break ; } break ; case 2 : if ( ! strcasecmp ( str , "on" ) ) res = 1 ; else if ( ! strcasecmp ( str , "no" ) ) res = 0 ; break ; case 3 : if ( ! strcasecmp ( str , "off" ) ) res = 0 ; else if ( ! strcasecmp ( str , "yes" ) ) res = 1 ; <S2SV_StartBug> break ; <S2SV_EndBug> case 4 : if ( ! strcasecmp ( str , "true" ) ) res = 1 ; else if ( ! strcasecmp ( str , "sure" ) ) res = 1 ; else if ( ! strcasecmp ( str , "none" ) ) res = 0 ; else if ( ! strcasecmp ( str , "nope" ) ) res = 0 ; else if ( ! strcasecmp ( str , "yeah" ) ) res = 1 ; break ; case 5 : if ( ! strcasecmp ( str , "false" ) ) res = 0 ; break ; } * b = ( res > 0 ) ; return ( res >= 0 ) ? ( str + len ) : str ; }
|
<S2SV_ModStart> = 1 ; else if ( ! strcasecmp ( str , "yep" ) ) res = 1 ;
|
6,685 |
CWE-000 static texid_t Font_LoadReplacementConchars ( void ) { texid_t tex ; <S2SV_StartBug> tex = R_LoadHiResTexture ( "gfx/conchars.lmp" , NULL , IF_NEAREST | IF_PREMULTIPLYALPHA | IF_LOADNOW | IF_UIPIC | IF_NOMIPMAP | IF_NOGAMMA ) ; <S2SV_EndBug> TEXDOWAIT ( tex ) ; if ( TEXLOADED ( tex ) ) return tex ; tex = R_LoadHiResTexture ( "pics/conchars.pcx" , NULL , ( r_font_linear . ival ? IF_LINEAR : IF_NEAREST ) | IF_PREMULTIPLYALPHA | IF_LOADNOW | IF_UIPIC | IF_NOMIPMAP | IF_NOGAMMA ) ; TEXDOWAIT ( tex ) ; if ( TEXLOADED ( tex ) ) return tex ; tex = R_LoadHiResTexture ( "gfx/2d/bigchars.tga" , NULL , ( r_font_linear . ival ? IF_LINEAR : IF_NEAREST ) | IF_PREMULTIPLYALPHA | IF_LOADNOW | IF_UIPIC | IF_NOMIPMAP | IF_NOGAMMA ) ; TEXDOWAIT ( tex ) ; if ( TEXLOADED ( tex ) ) return tex ; return r_nulltex ; }
|
<S2SV_ModStart> , NULL , ( r_font_linear . ival ? IF_LINEAR : IF_NEAREST ) <S2SV_ModEnd> | IF_PREMULTIPLYALPHA |
|
6,686 |
CWE-000 int qcow2_grow_l1_table ( BlockDriverState * bs , uint64_t min_size , bool exact_size ) { BDRVQcow2State * s = bs -> opaque ; int new_l1_size2 , ret , i ; uint64_t * new_l1_table ; int64_t old_l1_table_offset , old_l1_size ; int64_t new_l1_table_offset , new_l1_size ; uint8_t data [ 12 ] ; if ( min_size <= s -> l1_size ) return 0 ; if ( min_size > INT_MAX / sizeof ( uint64_t ) ) { return - EFBIG ; } if ( exact_size ) { new_l1_size = min_size ; } else { new_l1_size = s -> l1_size ; if ( new_l1_size == 0 ) { new_l1_size = 1 ; } while ( min_size > new_l1_size ) { new_l1_size = ( new_l1_size * 3 + 1 ) / 2 ; } } QEMU_BUILD_BUG_ON ( QCOW_MAX_L1_SIZE > INT_MAX ) ; if ( new_l1_size > QCOW_MAX_L1_SIZE / sizeof ( uint64_t ) ) { return - EFBIG ; } # ifdef DEBUG_ALLOC2 fprintf ( stderr , "grow<S2SV_blank>l1_table<S2SV_blank>from<S2SV_blank>%d<S2SV_blank>to<S2SV_blank>%" PRId64 "\\n" , s -> l1_size , new_l1_size ) ; # endif new_l1_size2 = sizeof ( uint64_t ) * new_l1_size ; new_l1_table = qemu_try_blockalign ( bs -> file -> bs , align_offset ( new_l1_size2 , 512 ) ) ; if ( new_l1_table == NULL ) { return - ENOMEM ; } memset ( new_l1_table , 0 , align_offset ( new_l1_size2 , 512 ) ) ; <S2SV_StartBug> memcpy ( new_l1_table , s -> l1_table , s -> l1_size * sizeof ( uint64_t ) ) ; <S2SV_EndBug> BLKDBG_EVENT ( bs -> file , BLKDBG_L1_GROW_ALLOC_TABLE ) ; new_l1_table_offset = qcow2_alloc_clusters ( bs , new_l1_size2 ) ; if ( new_l1_table_offset < 0 ) { qemu_vfree ( new_l1_table ) ; return new_l1_table_offset ; } ret = qcow2_cache_flush ( bs , s -> refcount_block_cache ) ; if ( ret < 0 ) { goto fail ; } ret = qcow2_pre_write_overlap_check ( bs , 0 , new_l1_table_offset , new_l1_size2 ) ; if ( ret < 0 ) { goto fail ; } BLKDBG_EVENT ( bs -> file , BLKDBG_L1_GROW_WRITE_TABLE ) ; for ( i = 0 ; i < s -> l1_size ; i ++ ) new_l1_table [ i ] = cpu_to_be64 ( new_l1_table [ i ] ) ; ret = bdrv_pwrite_sync ( bs -> file , new_l1_table_offset , new_l1_table , new_l1_size2 ) ; if ( ret < 0 ) goto fail ; for ( i = 0 ; i < s -> l1_size ; i ++ ) new_l1_table [ i ] = be64_to_cpu ( new_l1_table [ i ] ) ; BLKDBG_EVENT ( bs -> file , BLKDBG_L1_GROW_ACTIVATE_TABLE ) ; stl_be_p ( data , new_l1_size ) ; stq_be_p ( data + 4 , new_l1_table_offset ) ; ret = bdrv_pwrite_sync ( bs -> file , offsetof ( QCowHeader , l1_size ) , data , sizeof ( data ) ) ; if ( ret < 0 ) { goto fail ; } qemu_vfree ( s -> l1_table ) ; old_l1_table_offset = s -> l1_table_offset ; s -> l1_table_offset = new_l1_table_offset ; s -> l1_table = new_l1_table ; old_l1_size = s -> l1_size ; s -> l1_size = new_l1_size ; qcow2_free_clusters ( bs , old_l1_table_offset , old_l1_size * sizeof ( uint64_t ) , QCOW2_DISCARD_OTHER ) ; return 0 ; fail : qemu_vfree ( new_l1_table ) ; qcow2_free_clusters ( bs , new_l1_table_offset , new_l1_size2 , QCOW2_DISCARD_OTHER ) ; return ret ; }
|
<S2SV_ModStart> ) ) ; if ( s -> l1_size ) { <S2SV_ModStart> ) ) ; }
|
6,687 |
CWE-000 static GstBuffer * gst_kms_sink_get_input_buffer ( GstKMSSink * self , GstBuffer * inbuf ) { GstMemory * mem ; GstBuffer * buf = NULL ; mem = gst_buffer_peek_memory ( inbuf , 0 ) ; if ( ! mem ) return NULL ; if ( gst_is_kms_memory ( mem ) ) return gst_buffer_ref ( inbuf ) ; if ( gst_kms_sink_import_dmabuf ( self , inbuf , & buf ) ) <S2SV_StartBug> return buf ; <S2SV_EndBug> GST_CAT_INFO_OBJECT ( CAT_PERFORMANCE , self , "frame<S2SV_blank>copy" ) ; <S2SV_StartBug> return gst_kms_sink_copy_to_dumb_buffer ( self , inbuf ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> buf ) ) goto done <S2SV_ModEnd> ; GST_CAT_INFO_OBJECT ( <S2SV_ModStart> "frame<S2SV_blank>copy" ) ; buf = <S2SV_ModEnd> gst_kms_sink_copy_to_dumb_buffer ( self <S2SV_ModStart> inbuf ) ; done : if ( buf ) gst_buffer_copy_into ( buf , inbuf , GST_BUFFER_COPY_METADATA , 0 , - 1 ) ; return buf ;
|
6,688 |
CWE-000 static int alarm_timer_set ( struct k_itimer * timr , int flags , struct itimerspec * new_setting , struct itimerspec * old_setting ) { ktime_t exp ; if ( ! rtcdev ) return - ENOTSUPP ; if ( flags & ~ TIMER_ABSTIME ) return - EINVAL ; if ( old_setting ) alarm_timer_get ( timr , old_setting ) ; if ( alarm_try_to_cancel ( & timr -> it . alarm . alarmtimer ) < 0 ) return TIMER_RETRY ; timr -> it . alarm . interval = timespec_to_ktime ( new_setting -> it_interval ) ; <S2SV_StartBug> exp = timespec_to_ktime ( new_setting -> it_value ) ; <S2SV_EndBug> if ( flags != TIMER_ABSTIME ) { ktime_t now ; now = alarm_bases [ timr -> it . alarm . alarmtimer . type ] . gettime ( ) ; exp = ktime_add_safe ( now , exp ) ; } alarm_start ( & timr -> it . alarm . alarmtimer , exp ) ; return 0 ; }
|
<S2SV_ModStart> it_interval ) ; if ( ktime_to_ns ( timr -> it . alarm . interval ) < TICK_NSEC ) timr -> it . alarm . interval = ktime_set ( 1 , 0 ) ;
|
6,689 |
CWE-000 void set_current_value_on_normal ( uint8_t value , uint8_t knob_idx ) { uint8_t tmp_value ; switch ( knob_idx ) { case 0 : switch ( func_mode ) { case NONE : current_values . v . step_fill = value >> 4 ; changed_value_flags |= 1 << CHG_VAL_FLAG_STEP_FILL ; break ; case FUNC : current_values . v . step_length = ( value >> 4 ) + 1 ; changed_value_flags |= 1 << CHG_VAL_FLAG_STEP_LENGTH ; break ; case HID : current_values . v . slide = value >> 4 ; changed_value_flags |= 1 << CHG_VAL_FLAG_SLIDE ; set_led_count ( current_values . v . slide + 1 ) ; break ; case WAVE_SHAPE : current_values . v . wave_select = value >> 3 ; changed_value_flags |= 1 << CHG_VAL_FLAG_WAVE_SELECT ; set_display_mode ( WAVE_SHAPE_SELECT ) ; break ; case STABILITY : no_rec_values . v . int_clock_instability = value >> 2 ; set_disp_left_8_dot_right_8_val ( no_rec_values . v . int_clock_instability ) ; break ; } break ; case 1 : switch ( func_mode ) { case NONE : current_values . v . step_rot = value >> 3 ; changed_value_flags |= 1 << CHG_VAL_FLAG_STEP_ROT ; break ; case FUNC : current_values . v . step_rand = value >> 3 ; changed_value_flags |= 1 << CHG_VAL_FLAG_STEP_RAND ; set_led_count ( ( value >> 4 ) + 1 ) ; break ; case HID : current_values . v . swing = value >> 1 ; changed_value_flags |= 1 << CHG_VAL_FLAG_SWING ; set_led_count ( ( value >> 4 ) + 1 ) ; break ; case WAVE_SHAPE : current_values . v . wave_phase = value >> 3 ; changed_value_flags |= 1 << CHG_VAL_FLAG_WAVE_PHASE ; set_led_count ( ( value >> 3 ) + 1 ) ; break ; case STABILITY : <S2SV_StartBug> no_rec_values . v . int_clock_sync_to_ext = value >> 7 ; <S2SV_EndBug> set_led_count ( no_rec_values . v . int_clock_sync_to_ext + 1 ) ; break ; } break ; case 2 : switch ( func_mode ) { case NONE : current_values . v . scale_select = value >> 4 ; changed_value_flags |= 1 << CHG_VAL_FLAG_SCALE_SELECT ; set_led_count ( ( value >> 4 ) + 1 ) ; break ; case FUNC : current_values . v . scale_transpose = ( uint16_t ) value * 76 / 256 ; changed_value_flags |= 1 << CHG_VAL_FLAG_SCALE_TRANSPOSE ; set_display_mode ( TRANSPOSE ) ; break ; case HID : current_values . v . scale_shift = ( value >> 2 ) + 16 ; changed_value_flags |= 1 << CHG_VAL_FLAG_SCALE_SHIFT ; set_led_count ( ( value >> 4 ) + 1 ) ; break ; case WAVE_SHAPE : tmp_value = value >> 4 ; if ( tmp_value < 4 ) { tmp_value = 4 ; } else if ( tmp_value > 12 ) { tmp_value = 12 ; } tmp_value -= 4 ; current_values . v . wave_balance = tmp_value ; changed_value_flags |= 1 << CHG_VAL_FLAG_WAVE_BALANCE ; set_display_mode ( WAVE_SHAPE_BALANCE ) ; break ; case STABILITY : no_rec_values . v . pitch_vibrato = value >> 3 ; set_led_count ( no_rec_values . v . pitch_vibrato + 1 ) ; break ; } break ; case 3 : switch ( func_mode ) { case NONE : current_values . v . scale_pattern = value >> 4 ; changed_value_flags |= 1 << CHG_VAL_FLAG_SCALE_PATTERN ; set_led_count ( ( value >> 4 ) + 1 ) ; break ; case FUNC : current_values . v . scale_range = ( value >> 4 ) + 1 ; changed_value_flags |= 1 << CHG_VAL_FLAG_SCALE_RANGE ; set_led_count ( ( value >> 4 ) + 1 ) ; break ; case HID : current_values . v . scale_pattern_random = value >> 4 ; changed_value_flags |= 1 << CHG_VAL_FLAG_SCALE_PAT_RAND ; set_led_count ( ( value >> 4 ) + 1 ) ; break ; case WAVE_SHAPE : current_values . v . wave_pitch_duration = value >> 3 ; changed_value_flags |= 1 << CHG_VAL_FLAG_WAVE_PITCH_DURATION ; set_led_count ( ( value >> 3 ) + 1 ) ; break ; case STABILITY : no_rec_values . v . pitch_overshoot = value >> 3 ; set_led_count ( no_rec_values . v . pitch_overshoot + 1 ) ; break ; } break ; default : break ; } if ( changed_value_flags & ( _BV ( CHG_VAL_FLAG_STEP_FILL ) | _BV ( CHG_VAL_FLAG_STEP_LENGTH ) | _BV ( CHG_VAL_FLAG_STEP_ROT ) ) ) { update_seq_pattern ( ) ; } }
|
<S2SV_ModStart> >> 7 ; if ( no_rec_values . v . int_clock_sync_to_ext ) { in_start_seq = current_state . start ; }
|
6,690 |
CWE-000 static void pdf_doc_close_page_tree ( pdf_doc * p ) { pdf_obj * page_tree_root ; pdf_obj * mediabox ; int page_no ; for ( page_no = PAGECOUNT ( p ) + 1 ; page_no <= MAXPAGES ( p ) ; page_no ++ ) { pdf_page * page ; page = doc_get_page_entry ( p , page_no ) ; if ( page -> page_obj ) { <S2SV_StartBug> dpx_warning ( "Nonexistent<S2SV_blank>page<S2SV_blank>#%ld<S2SV_blank>refered." , page_no ) ; <S2SV_EndBug> pdf_release_obj ( page -> page_ref ) ; page -> page_ref = NULL ; } if ( page -> page_obj ) { <S2SV_StartBug> dpx_warning ( "Entry<S2SV_blank>for<S2SV_blank>a<S2SV_blank>nonexistent<S2SV_blank>page<S2SV_blank>#%ld<S2SV_blank>created." , page_no ) ; <S2SV_EndBug> pdf_release_obj ( page -> page_obj ) ; page -> page_obj = NULL ; } if ( page -> annots ) { <S2SV_StartBug> dpx_warning ( "Annotation<S2SV_blank>attached<S2SV_blank>to<S2SV_blank>a<S2SV_blank>nonexistent<S2SV_blank>page<S2SV_blank>#%ld." , page_no ) ; <S2SV_EndBug> pdf_release_obj ( page -> annots ) ; page -> annots = NULL ; } if ( page -> beads ) { <S2SV_StartBug> dpx_warning ( "Article<S2SV_blank>beads<S2SV_blank>attached<S2SV_blank>to<S2SV_blank>a<S2SV_blank>nonexistent<S2SV_blank>page<S2SV_blank>#%ld." , page_no ) ; <S2SV_EndBug> pdf_release_obj ( page -> beads ) ; page -> beads = NULL ; } if ( page -> resources ) { pdf_release_obj ( page -> resources ) ; page -> resources = NULL ; } } page_tree_root = build_page_tree ( p , FIRSTPAGE ( p ) , PAGECOUNT ( p ) , NULL ) ; pdf_merge_dict ( p -> root . pages , page_tree_root ) ; pdf_release_obj ( page_tree_root ) ; if ( p -> pages . bop ) { pdf_add_stream ( p -> pages . bop , "\\n" , 1 ) ; pdf_release_obj ( p -> pages . bop ) ; p -> pages . bop = NULL ; } if ( p -> pages . eop ) { pdf_add_stream ( p -> pages . eop , "\\n" , 1 ) ; pdf_release_obj ( p -> pages . eop ) ; p -> pages . eop = NULL ; } mediabox = pdf_new_array ( ) ; pdf_add_array ( mediabox , pdf_new_number ( ROUND ( p -> pages . mediabox . llx , 0.01 ) ) ) ; pdf_add_array ( mediabox , pdf_new_number ( ROUND ( p -> pages . mediabox . lly , 0.01 ) ) ) ; pdf_add_array ( mediabox , pdf_new_number ( ROUND ( p -> pages . mediabox . urx , 0.01 ) ) ) ; pdf_add_array ( mediabox , pdf_new_number ( ROUND ( p -> pages . mediabox . ury , 0.01 ) ) ) ; pdf_add_dict ( p -> root . pages , pdf_new_name ( "MediaBox" ) , mediabox ) ; pdf_add_dict ( p -> root . dict , pdf_new_name ( "Pages" ) , pdf_ref_obj ( p -> root . pages ) ) ; pdf_release_obj ( p -> root . pages ) ; p -> root . pages = NULL ; free ( p -> pages . entries ) ; p -> pages . entries = NULL ; p -> pages . num_entries = 0 ; p -> pages . max_entries = 0 ; return ; }
|
<S2SV_ModStart> { dpx_warning ( "Nonexistent<S2SV_blank>page<S2SV_blank>#%d<S2SV_blank>refered." <S2SV_ModEnd> , page_no ) <S2SV_ModStart> { dpx_warning ( "Entry<S2SV_blank>for<S2SV_blank>a<S2SV_blank>nonexistent<S2SV_blank>page<S2SV_blank>#%d<S2SV_blank>created." <S2SV_ModEnd> , page_no ) <S2SV_ModStart> { dpx_warning ( "Annotation<S2SV_blank>attached<S2SV_blank>to<S2SV_blank>a<S2SV_blank>nonexistent<S2SV_blank>page<S2SV_blank>#%d." <S2SV_ModEnd> , page_no ) <S2SV_ModStart> { dpx_warning ( "Article<S2SV_blank>beads<S2SV_blank>attached<S2SV_blank>to<S2SV_blank>a<S2SV_blank>nonexistent<S2SV_blank>page<S2SV_blank>#%d." <S2SV_ModEnd> , page_no )
|
6,691 |
CWE-000 static int appletb_set_tb_disp ( struct appletb_device * tb_dev , unsigned char disp ) { unsigned char report [ ] = { 0 , 1 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 } ; int rc ; if ( ! tb_dev -> disp_info . usb_iface ) return - 1 ; if ( disp != APPLETB_CMD_DISP_OFF && <S2SV_StartBug> tb_dev -> cur_tb_disp == APPLETB_CMD_DISP_OFF ) { <S2SV_EndBug> rc = usb_autopm_get_interface ( tb_dev -> disp_info . usb_iface ) ; <S2SV_StartBug> if ( rc == 0 ) <S2SV_EndBug> tb_dev -> tb_autopm_off = true ; else pr_err ( "Failed<S2SV_blank>to<S2SV_blank>disable<S2SV_blank>auto-pm<S2SV_blank>on<S2SV_blank>touchbar<S2SV_blank>device<S2SV_blank>(%d)\\n" , rc ) ; } report [ 0 ] = tb_dev -> disp_info . report_id ; report [ 2 ] = disp ; rc = appletb_send_hid_report ( & tb_dev -> disp_info , USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE , report , sizeof ( report ) ) ; if ( rc < 0 ) pr_err ( "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>touchbar<S2SV_blank>display<S2SV_blank>to<S2SV_blank>%u<S2SV_blank>(%d)\\n" , disp , rc ) ; if ( disp == APPLETB_CMD_DISP_OFF && tb_dev -> cur_tb_disp != APPLETB_CMD_DISP_OFF ) { if ( tb_dev -> tb_autopm_off ) { usb_autopm_put_interface ( tb_dev -> disp_info . usb_iface ) ; tb_dev -> tb_autopm_off = false ; } } return rc ; }
|
<S2SV_ModStart> == APPLETB_CMD_DISP_OFF ) tb_dev -> tb_autopm_off = appletb_disable_autopm <S2SV_ModEnd> ( tb_dev -> <S2SV_ModStart> usb_iface ) ; <S2SV_ModEnd> report [ 0
|
6,692 |
CWE-000 ecma_value_t ecma_process_all_enqueued_jobs ( void ) { <S2SV_StartBug> ecma_value_t ret = ecma_make_simple_value ( ECMA_SIMPLE_VALUE_UNDEFINED ) ; <S2SV_EndBug> while ( JERRY_CONTEXT ( job_queue_head_p ) != NULL && ! ECMA_IS_VALUE_ERROR ( ret ) ) { ecma_job_queueitem_t * item_p = JERRY_CONTEXT ( job_queue_head_p ) ; JERRY_CONTEXT ( job_queue_head_p ) = JERRY_CONTEXT ( job_queue_head_p ) -> next_p ; void * job_p = item_p -> job_p ; ecma_job_handler_t handler = item_p -> handler ; jmem_heap_free_block ( item_p , sizeof ( ecma_job_queueitem_t ) ) ; ecma_free_value ( ret ) ; ret = handler ( job_p ) ; } <S2SV_StartBug> return ret ; <S2SV_EndBug> }
|
<S2SV_ModStart> ecma_make_simple_value ( ECMA_SIMPLE_VALUE_UNDEFINED ) ; jerry_value_t current_error = JERRY_CONTEXT ( error_value <S2SV_ModStart> ) ; } if ( current_error != JERRY_CONTEXT ( error_value ) ) { ecma_free_value ( ret ) ; return ecma_create_error_reference ( JERRY_CONTEXT ( error_value ) ) ; }
|
6,693 |
CWE-000 <S2SV_StartBug> static int ssl_print_server_keyex ( BIO * bio , int indent , SSL * ssl , <S2SV_EndBug> const unsigned char * msg , size_t msglen ) { const char * algname ; int id = ssl_get_keyex ( & algname , ssl ) ; BIO_indent ( bio , indent , 80 ) ; BIO_printf ( bio , "KeyExchangeAlgorithm=%s\\n" , algname ) ; if ( id & SSL_PSK ) { if ( ! ssl_print_hexbuf ( bio , indent + 2 , "psk_identity_hint" , 2 , & msg , & msglen ) ) return 0 ; } switch ( id ) { case SSL_kRSA : if ( ! ssl_print_hexbuf ( bio , indent + 2 , "rsa_modulus" , 2 , & msg , & msglen ) ) return 0 ; if ( ! ssl_print_hexbuf ( bio , indent + 2 , "rsa_exponent" , 2 , & msg , & msglen ) ) return 0 ; break ; case SSL_kDHE : case SSL_kDHEPSK : if ( ! ssl_print_hexbuf ( bio , indent + 2 , "dh_p" , 2 , & msg , & msglen ) ) return 0 ; if ( ! ssl_print_hexbuf ( bio , indent + 2 , "dh_g" , 2 , & msg , & msglen ) ) return 0 ; if ( ! ssl_print_hexbuf ( bio , indent + 2 , "dh_Ys" , 2 , & msg , & msglen ) ) return 0 ; break ; # ifndef OPENSSL_NO_EC case SSL_kECDHE : case SSL_kECDHEPSK : if ( msglen < 1 ) return 0 ; BIO_indent ( bio , indent + 2 , 80 ) ; if ( msg [ 0 ] == EXPLICIT_PRIME_CURVE_TYPE ) BIO_puts ( bio , "explicit_prime\\n" ) ; else if ( msg [ 0 ] == EXPLICIT_CHAR2_CURVE_TYPE ) BIO_puts ( bio , "explicit_char2\\n" ) ; else if ( msg [ 0 ] == NAMED_CURVE_TYPE ) { int curve ; if ( msglen < 3 ) return 0 ; curve = ( msg [ 1 ] << 8 ) | msg [ 2 ] ; BIO_printf ( bio , "named_curve:<S2SV_blank>%s<S2SV_blank>(%d)\\n" , ssl_trace_str ( curve , ssl_groups_tbl ) , curve ) ; msg += 3 ; msglen -= 3 ; if ( ! ssl_print_hexbuf ( bio , indent + 2 , "point" , 1 , & msg , & msglen ) ) return 0 ; } else { BIO_printf ( bio , "UNKNOWN<S2SV_blank>CURVE<S2SV_blank>PARAMETER<S2SV_blank>TYPE<S2SV_blank>%d\\n" , msg [ 0 ] ) ; return 0 ; } break ; # endif case SSL_kPSK : case SSL_kRSAPSK : break ; } if ( ! ( id & SSL_PSK ) ) ssl_print_signature ( bio , indent , ssl , & msg , & msglen ) ; return ! msglen ; }
|
<S2SV_ModStart> int indent , const
|
6,694 |
CWE-000 static ssize_t in_read ( struct audio_stream_in * stream , void * buffer , size_t bytes ) { struct a2dp_stream_in * in = ( struct a2dp_stream_in * ) stream ; int read ; DEBUG ( "read<S2SV_blank>%zu<S2SV_blank>bytes,<S2SV_blank>state:<S2SV_blank>%d" , bytes , in -> common . state ) ; if ( in -> common . state == AUDIO_A2DP_STATE_SUSPENDED ) { DEBUG ( "stream<S2SV_blank>suspended" ) ; return - 1 ; } if ( ( in -> common . state == AUDIO_A2DP_STATE_STOPPED ) || ( in -> common . state == AUDIO_A2DP_STATE_STANDBY ) ) { pthread_mutex_lock ( & in -> common . lock ) ; if ( start_audio_datapath ( & in -> common ) < 0 ) { int us_delay = calc_audiotime ( in -> common . cfg , bytes ) ; DEBUG ( "emulate<S2SV_blank>a2dp<S2SV_blank>read<S2SV_blank>delay<S2SV_blank>(%d<S2SV_blank>us)" , us_delay ) ; <S2SV_StartBug> usleep ( us_delay ) ; <S2SV_EndBug> pthread_mutex_unlock ( & in -> common . lock ) ; return - 1 ; } pthread_mutex_unlock ( & in -> common . lock ) ; } else if ( in -> common . state != AUDIO_A2DP_STATE_STARTED ) { ERROR ( "stream<S2SV_blank>not<S2SV_blank>in<S2SV_blank>stopped<S2SV_blank>or<S2SV_blank>standby" ) ; return - 1 ; } read = skt_read ( in -> common . audio_fd , buffer , bytes ) ; if ( read == - 1 ) { skt_disconnect ( in -> common . audio_fd ) ; in -> common . audio_fd = AUDIO_SKT_DISCONNECTED ; in -> common . state = AUDIO_A2DP_STATE_STOPPED ; } else if ( read == 0 ) { DEBUG ( "read<S2SV_blank>time<S2SV_blank>out<S2SV_blank>-<S2SV_blank>return<S2SV_blank>zeros" ) ; memset ( buffer , 0 , bytes ) ; read = bytes ; } DEBUG ( "read<S2SV_blank>%d<S2SV_blank>bytes<S2SV_blank>out<S2SV_blank>of<S2SV_blank>%zu<S2SV_blank>bytes" , read , bytes ) ; return read ; }
|
<S2SV_ModStart> us_delay ) ; TEMP_FAILURE_RETRY ( <S2SV_ModStart> usleep ( us_delay )
|
6,695 |
CWE-000 long str_to_mbytes ( const char * arg ) { <S2SV_StartBug> long result ; <S2SV_EndBug> char * endptr ; errno = 0 ; <S2SV_StartBug> result = strtol ( arg , & endptr , 10 ) ; <S2SV_EndBug> if ( ( errno != 0 ) && ( ( result == LONG_MIN ) || ( result == LONG_MAX ) ) ) result = - 1 ; else if ( endptr [ 0 ] == '\\0' ) ; else if ( ( endptr [ 0 ] == 'k' ) || ( endptr [ 0 ] == 'K' ) ) result = ( result + 1023 ) / 1024 ; else if ( ( endptr [ 0 ] == 'm' ) || ( endptr [ 0 ] == 'M' ) ) ; else if ( ( endptr [ 0 ] == 'g' ) || ( endptr [ 0 ] == 'G' ) ) result *= 1024 ; else if ( ( endptr [ 0 ] == 't' ) || ( endptr [ 0 ] == 'T' ) ) result *= ( 1024 * 1024 ) ; else result = - 1 ; return result ; }
|
<S2SV_ModStart> arg ) { return _str_to_mbtyes <S2SV_ModEnd> ( arg , <S2SV_ModStart> ( arg , 0 ) <S2SV_ModEnd> ; } <S2SV_null>
|
6,696 |
CWE-000 errcode_t ext2fs_sync_device ( int fd , int flushb ) { if ( fsync ( fd ) == - 1 ) return errno ; if ( flushb ) { <S2SV_StartBug> # ifdef BLKFLSBUF <S2SV_EndBug> if ( ioctl ( fd , BLKFLSBUF , 0 ) == 0 ) return 0 ; <S2SV_StartBug> # elif defined ( __linux__ ) <S2SV_EndBug> # warning BLKFLSBUF not defined # endif # ifdef FDFLUSH <S2SV_StartBug> return ioctl ( fd , FDFLUSH , 0 ) ; <S2SV_EndBug> # elif defined ( __linux__ ) # warning FDFLUSH not defined # endif <S2SV_StartBug> } <S2SV_EndBug> return 0 ; }
|
<S2SV_ModStart> flushb ) { errcode_t retval = 0 ; <S2SV_ModStart> return 0 ; retval = errno ; <S2SV_ModStart> # ifdef FDFLUSH if ( <S2SV_ModEnd> ioctl ( fd <S2SV_ModStart> , 0 ) == 0 ) return 0 ; if ( retval == 0 ) retval = errno <S2SV_ModStart> defined # endif return retval ;
|
6,697 |
CWE-000 function_space_specifier void Gfs_add_file ( char * name , char * file , size_t length , int * result ) { if ( _bcl_ -> init == 0 ) CommonInitFileSystem ( ) ; char * * ptr_name = _bcl_ -> names ; char * * ptr_file = _bcl_ -> files ; size_t * ptr_length = _bcl_ -> lengths ; for ( int i = 0 ; i < _bcl_ -> initial_size ; ++ i ) { if ( * ptr_name == NULL ) { * ptr_name = Gstrdup ( name ) ; * ptr_file = ( char * ) Gmalloc ( length ) ; memcpy ( * ptr_file , file , length ) ; * ptr_length = length ; return ; } else { ptr_name ++ ; ptr_file ++ ; ptr_length ++ ; } } <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> ; } } Crash ( "File<S2SV_blank>system<S2SV_blank>overflow.<S2SV_blank>Cannot<S2SV_blank>handle<S2SV_blank>more<S2SV_blank>than<S2SV_blank>%d<S2SV_blank>files.\\n" , _bcl_ -> initial_size ) ;
|
6,698 |
CWE-000 void single_shot_mode ( ) { log_printf ( "SINGLE_SHOT_MODE\\n" ) ; uint32_t number_of_transition = SINGLE_SHOT_TRANSITIONS ; <S2SV_StartBug> time_remain = intr_trig_time_in - ( SINGLE_SHOT_DURATION ) ; <S2SV_EndBug> out_gen_config_t out_gen_config = { . num_transitions = number_of_transition , <S2SV_StartBug> . out_gen_done_handler = pattern_out_done_handler , <S2SV_EndBug> <S2SV_StartBug> . out_gen_state = IDLE , <S2SV_EndBug> . transitions_durations = { SINGLE_SHOT_DURATION , time_remain } , . next_out = { { 0 , 1 , 1 } , { 0 , 1 , 1 } } , } ; debug_print_bool_array ( out_gen_config . next_out , "single<S2SV_blank>shot" ) ; out_gen_start ( & out_gen_config ) ; }
|
<S2SV_ModStart> = SINGLE_SHOT_TRANSITIONS ; uint32_t local_out_gen_state ; if ( pir_oper_flag == true ) { <S2SV_ModStart> SINGLE_SHOT_DURATION ) ; local_out_gen_state = IDLE ; } else { local_out_gen_state = TIMER_IDLE ; time_remain = LFCLK_TICKS_MS ( 1 ) ; } <S2SV_ModStart> . out_gen_done_handler = out_gen_done_ptr <S2SV_ModEnd> , . out_gen_state <S2SV_ModStart> . out_gen_state = local_out_gen_state <S2SV_ModEnd> , . transitions_durations
|
6,699 |
CWE-000 Decoder * dec_new ( ErlNifEnv * env ) { jiffy_st * st = ( jiffy_st * ) enif_priv_data ( env ) ; Decoder * d = enif_alloc_resource ( st -> res_dec , sizeof ( Decoder ) ) ; int i ; if ( d == NULL ) { return NULL ; } d -> atoms = st ; d -> bytes_per_red = DEFAULT_BYTES_PER_REDUCTION ; d -> is_partial = 0 ; d -> return_maps = 0 ; d -> return_trailer = 0 ; d -> dedupe_keys = 0 ; <S2SV_StartBug> d -> null_term = d -> atoms -> atom_null ; <S2SV_EndBug> d -> p = NULL ; d -> u = NULL ; d -> len = - 1 ; d -> i = - 1 ; d -> st_data = ( char * ) enif_alloc ( STACK_SIZE_INC * sizeof ( char ) ) ; d -> st_size = STACK_SIZE_INC ; d -> st_top = 0 ; for ( i = 0 ; i < d -> st_size ; i ++ ) { d -> st_data [ i ] = st_invalid ; } d -> st_data [ 0 ] = st_value ; d -> st_top ++ ; return d ; }
|
<S2SV_ModStart> ; d -> copy_strings = 0 ; d ->
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.