Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
3,700 | CWE-000 void log_debug ( const char * format , ... ) { va_list ap ; char time_format [ LOG_STR_BUFFER_SIZE ] ; time_t now = time ( NULL ) ; if ( opts . debug ) { strftime ( time_format , sizeof ( time_format ) , timefmt , localtime ( & now ) ) ; <S2SV_StartBug> strncat ( time_format , "(debug)<S2SV_blank>" , sizeof ( time_format ) ) ; <S2SV_EndBug> <S2SV_StartBug> strncat ( time_format , format , sizeof ( time_format ) ) ; <S2SV_EndBug> va_start ( ap , format ) ; vfprintf ( stderr , time_format , ap ) ; fprintf ( stderr , "\\n" ) ; va_end ( ap ) ; } } | <S2SV_ModStart> ( time_format ) - strlen ( time_format ) - 1 <S2SV_ModStart> ( time_format ) - strlen ( time_format ) - 1 |
3,701 | CWE-000 static int rfbi_get_clocks ( void ) { <S2SV_StartBug> rfbi . dss_ick = clk_get ( rfbi . fbdev -> dev , "ick" ) ; <S2SV_EndBug> if ( IS_ERR ( rfbi . dss_ick ) ) { dev_err ( rfbi . fbdev -> dev , "can\'t<S2SV_blank>get<S2SV_blank>ick\\n" ) ; return PTR_ERR ( rfbi . dss_ick ) ; } <S2SV_StartBug> rfbi . dss1_fck = clk_get ( rfbi . fbdev -> dev , "dss1_fck" ) ; <S2SV_EndBug> if ( IS_ERR ( rfbi . dss1_fck ) ) { dev_err ( rfbi . fbdev -> dev , "can\'t<S2SV_blank>get<S2SV_blank>dss1_fck\\n" ) ; clk_put ( rfbi . dss_ick ) ; return PTR_ERR ( rfbi . dss1_fck ) ; } return 0 ; } | <S2SV_ModStart> = clk_get ( & dispc . fbdev -> dssdev <S2SV_ModEnd> -> dev , <S2SV_ModStart> = clk_get ( & dispc . fbdev -> dssdev <S2SV_ModEnd> -> dev , |
3,702 | CWE-000 char * encode_html ( const char * src ) { size_t length = strlen ( src ) + 1 ; char * dest = malloc ( length ) ; if ( dest == NULL ) return NULL ; memset ( dest , 0 , length ) ; size_t i = 0 , j = 0 ; int last_char_is_space = 0 ; while ( src [ i ] ) { int chars = numberOfBytesInChar ( ( unsigned char ) src [ i ] ) ; if ( chars > 1 ) { unsigned long bits = 0 ; unsigned char first = ( unsigned char ) src [ i ++ ] ; for ( int k = 0 ; k <= chars + 1 ; k ++ ) first &= ~ ( 0x80 >> k ) ; bits = ( bits << ( 8 - ( chars + 1 ) ) ) | first ; for ( int k = 0 ; k < chars - 1 ; k ++ ) { unsigned char hexchar = ( unsigned char ) src [ i ] ; if ( ( char ) hexchar == 0 ) { bits = 0 ; break ; } i ++ ; hexchar &= ~ 0x80 ; hexchar &= ~ 0x40 ; bits = ( bits << 6 ) | hexchar ; } if ( bits ) { char entity [ 16 ] ; snprintf ( entity , 16 , "&#x%lx;" , bits ) ; length += strlen ( entity ) - chars ; dest = realloc ( dest , length ) ; for ( size_t x = 0 ; x < strlen ( entity ) ; x ++ ) dest [ j + x ] = entity [ x ] ; j += strlen ( entity ) ; } else i ++ ; } <S2SV_StartBug> else if ( src [ i ] == 32 ) { <S2SV_EndBug> if ( last_char_is_space ) { <S2SV_StartBug> length += strlen ( " " ) - 1 ; <S2SV_EndBug> dest = realloc ( dest , length ) ; <S2SV_StartBug> dest [ j ++ ] = '&' ; <S2SV_EndBug> dest [ j ++ ] = 'n' ; dest [ j ++ ] = 'b' ; dest [ j ++ ] = 's' ; dest [ j ++ ] = 'p' ; dest [ j ++ ] = ';' ; i ++ ; } else { <S2SV_StartBug> dest [ j ++ ] = '<S2SV_blank>' ; <S2SV_EndBug> } last_char_is_space = 1 ; continue ; } else if ( isalnum ( src [ i ] ) || ( 33 <= src [ i ] && src [ i ] <= 47 && src [ i ] != 44 ) || ( src [ i ] == 61 || src [ i ] == 63 || src [ i ] == 64 ) || ( 123 <= src [ i ] && src [ i ] <= 126 ) ) { dest [ j ++ ] = src [ i ++ ] ; } else if ( src [ i ] == '\\n' ) { <S2SV_StartBug> length += strlen ( "<br>" ) - 1 ; <S2SV_EndBug> dest = realloc ( dest , length ) ; <S2SV_StartBug> dest [ j ++ ] = '<' ; <S2SV_EndBug> dest [ j ++ ] = 'b' ; dest [ j ++ ] = 'r' ; dest [ j ++ ] = '>' ; i ++ ; } else { char num [ HTML_ESCAPE_LENGTH ] ; snprintf ( num , HTML_ESCAPE_LENGTH , "&#%i;" , src [ i ++ ] ) ; <S2SV_StartBug> length += strlen ( num ) - 1 ; <S2SV_EndBug> dest = realloc ( dest , length ) ; for ( size_t x = 0 ; x < strlen ( num ) ; x ++ ) dest [ j + x ] = num [ x ] ; j += strlen ( num ) ; } last_char_is_space = 0 ; } dest [ j ] = 0 ; return dest ; } | <S2SV_ModStart> i ] == '<S2SV_blank>' <S2SV_ModEnd> ) { if <S2SV_ModStart> ( " " ) <S2SV_ModEnd> ; dest = <S2SV_ModStart> length ) ; memcpy ( dest + j , " " , strlen ( " " ) + 1 ) ; j += strlen ( " " ) <S2SV_ModEnd> ; i ++ <S2SV_ModStart> ] = '<S2SV_blank>' ; i ++ <S2SV_ModStart> ( "<br>" ) <S2SV_ModEnd> ; dest = <S2SV_ModStart> length ) ; memcpy ( dest + j , "<br>" , strlen ( "<br>" ) + 1 ) ; j += strlen ( "<br>" ) <S2SV_ModEnd> ; i ++ <S2SV_ModStart> ( num ) <S2SV_ModEnd> ; dest = |
3,703 | CWE-000 void target_before_init_debug ( void ) { <S2SV_StartBug> swd_set_target_reset ( 1 ) ; <S2SV_EndBug> } | <S2SV_ModStart> void ) { return <S2SV_ModEnd> ; } <S2SV_null> |
3,704 | CWE-000 static bool dsi_display_validate_reg_read ( struct dsi_panel * panel ) { int i , j = 0 ; int len = 0 , * lenp ; int group = 0 , count = 0 ; <S2SV_StartBug> struct dsi_display_mode * mode ; <S2SV_EndBug> struct drm_panel_esd_config * config ; if ( ! panel ) return false ; config = & ( panel -> esd_config ) ; lenp = config -> status_valid_params ? : config -> status_cmds_rlen ; <S2SV_StartBug> mode = panel -> cur_mode ; <S2SV_EndBug> count = mode -> priv_info -> cmd_sets [ DSI_CMD_SET_PANEL_STATUS ] . count ; for ( i = 0 ; i < count ; i ++ ) len += lenp [ i ] ; for ( i = 0 ; i < len ; i ++ ) j += len ; for ( j = 0 ; j < config -> groups ; ++ j ) { for ( i = 0 ; i < len ; ++ i ) { if ( config -> return_buf [ i ] != config -> status_value [ group + i ] ) break ; } if ( i == len ) return true ; group += len ; } return false ; } | <S2SV_ModStart> 0 ; struct <S2SV_ModEnd> drm_panel_esd_config * config <S2SV_ModStart> -> status_cmds_rlen ; count = config -> status_cmd <S2SV_ModEnd> . count ; |
3,705 | CWE-000 void datasetup ( t_format * flags , char * format , va_list * args ) { int len ; char * tmp ; tmp = format ; tmp ++ ; flags -> precision = - 1 ; len = ft_strchr ( tmp , TYPE ) - tmp ; findflags ( flags , tmp , len ) ; findw ( flags , tmp , len ) ; findp ( flags , tmp , len ) ; findast ( flags , tmp , len , args ) ; if ( flags -> width < 0 ) { flags -> width *= - 1 ; flags -> flagminus = 1 ; } <S2SV_StartBug> if ( flags -> flagminus || flags -> flagspace || ( ! P && ft_strchr ( g_numconv , TYPE ) ) ) <S2SV_EndBug> flags -> flagzero = 0 ; if ( flags -> flagplus ) flags -> flagspace = 0 ; findlength ( flags , tmp , len ) ; } | <S2SV_ModStart> -> flagminus || <S2SV_ModEnd> ( ! P |
3,706 | CWE-000 rt_err_t rt_data_queue_push ( struct rt_data_queue * queue , const void * data_ptr , rt_size_t data_size , rt_int32_t timeout ) { rt_ubase_t level ; rt_thread_t thread ; rt_err_t result ; RT_ASSERT ( queue != RT_NULL ) ; result = RT_EOK ; thread = rt_thread_self ( ) ; level = rt_hw_interrupt_disable ( ) ; while ( queue -> put_index - queue -> get_index == queue -> size ) { queue -> waiting_lwm = RT_TRUE ; if ( timeout == 0 ) { result = - RT_ETIMEOUT ; goto __exit ; } RT_DEBUG_NOT_IN_INTERRUPT ; thread -> error = RT_EOK ; rt_thread_suspend ( thread ) ; rt_list_insert_before ( & ( queue -> suspended_push_list ) , & ( thread -> tlist ) ) ; if ( timeout > 0 ) { rt_timer_control ( & ( thread -> thread_timer ) , RT_TIMER_CTRL_SET_TIME , & timeout ) ; rt_timer_start ( & ( thread -> thread_timer ) ) ; } rt_hw_interrupt_enable ( level ) ; rt_schedule ( ) ; result = thread -> error ; level = rt_hw_interrupt_disable ( ) ; if ( result != RT_EOK ) <S2SV_StartBug> { <S2SV_EndBug> queue -> waiting_lwm = RT_FALSE ; goto __exit ; <S2SV_StartBug> } <S2SV_EndBug> } queue -> queue [ queue -> put_index % queue -> size ] . data_ptr = data_ptr ; queue -> queue [ queue -> put_index % queue -> size ] . data_size = data_size ; queue -> put_index += 1 ; if ( ! rt_list_isempty ( & ( queue -> suspended_pop_list ) ) ) { thread = rt_list_entry ( queue -> suspended_pop_list . next , struct rt_thread , tlist ) ; rt_thread_resume ( thread ) ; rt_hw_interrupt_enable ( level ) ; rt_schedule ( ) ; return result ; } __exit : rt_hw_interrupt_enable ( level ) ; if ( ( result == RT_EOK ) && queue -> evt_notify != RT_NULL ) { queue -> evt_notify ( queue , RT_DATAQUEUE_EVENT_PUSH ) ; } return result ; } | <S2SV_ModStart> != RT_EOK ) <S2SV_ModEnd> goto __exit ; <S2SV_ModStart> goto __exit ; <S2SV_ModEnd> } queue -> |
3,707 | CWE-000 void check_solution ( double * * A , int nx , int ny , double dx , double dy , double elapsed , double D , double bc [ 2 ] [ 2 ] , double * rss ) { double sum = 0. ; # pragma acc data copyin ( A [ 0 : ny ] [ 0 : nx ] , bc [ 0 : 2 ] [ 0 : 2 ] ) copy ( sum ) { # pragma acc parallel reduction ( + : sum ) { int i , j ; double ca , cal , car , cn , poly_erf , r , trss , z , z2 ; # pragma acc loop for ( j = 1 ; j < ny - 1 ; j ++ ) { # pragma acc loop for ( i = 1 ; i < nx - 1 ; i ++ ) { cn = A [ j ] [ i ] ; r = ( j < ny / 2 ) ? dx * ( i - 1 ) : sqrt ( dx * dx * ( i - 1 ) * ( i - 1 ) + dy * dy * ( j - ny / 2 ) * ( j - ny / 2 ) ) ; z = r / sqrt ( 4. * D * elapsed ) ; z2 = z * z ; <S2SV_StartBug> poly_erf = ( z < 1. ) ? 2. * z * ( 1. + z2 * ( - 1. / 3 + z2 * ( 1. / 10 + z2 * ( - 1. / 42 + z2 / 216 ) ) ) ) / M_PI : 1. ; <S2SV_EndBug> cal = bc [ 1 ] [ 0 ] * ( 1. - poly_erf ) ; r = ( j >= ny / 2 ) ? dx * ( nx - 2 - i ) : sqrt ( dx * dx * ( nx - 2 - i ) * ( nx - 2 - i ) + dy * dy * ( ny / 2 - j ) * ( ny / 2 - j ) ) ; z = r / sqrt ( 4. * D * elapsed ) ; z2 = z * z ; <S2SV_StartBug> poly_erf = ( z < 1. ) ? 2. * z * ( 1. + z2 * ( - 1. / 3 + z2 * ( 1. / 10 + z2 * ( - 1. / 42 + z2 / 216 ) ) ) ) / M_PI : 1. ; <S2SV_EndBug> car = bc [ 1 ] [ 0 ] * ( 1. - poly_erf ) ; ca = cal + car ; trss = ( ca - cn ) * ( ca - cn ) / ( double ) ( ( nx - 2 ) * ( ny - 2 ) ) ; sum += trss ; } } } } * rss = sum ; } | <S2SV_ModStart> ( z < 1.5 <S2SV_ModEnd> ) ? 2. <S2SV_ModStart> ) ) / sqrt ( M_PI ) <S2SV_ModEnd> : 1. ; <S2SV_ModStart> ( z < 1.5 <S2SV_ModEnd> ) ? 2. <S2SV_ModStart> ) ) / sqrt ( M_PI ) <S2SV_ModEnd> : 1. ; |
3,708 | CWE-000 static int compat_get_qcedev_vbuf_info ( struct compat_qcedev_vbuf_info __user * vbuf32 , struct qcedev_vbuf_info __user * vbuf ) { compat_uptr_t vaddr ; int err = 0 , i = 0 ; uint32_t len ; for ( i = 0 ; i < QCEDEV_MAX_BUFFERS ; i ++ ) { err |= get_user ( vaddr , & vbuf32 -> src [ i ] . vaddr ) ; <S2SV_StartBug> vbuf -> src [ i ] . vaddr = NULL ; <S2SV_EndBug> err |= put_user ( vaddr , ( compat_uptr_t * ) & vbuf -> src [ i ] . vaddr ) ; err |= get_user ( len , & vbuf32 -> src [ i ] . len ) ; err |= put_user ( len , & vbuf -> src [ i ] . len ) ; } for ( i = 0 ; i < QCEDEV_MAX_BUFFERS ; i ++ ) { err |= get_user ( vaddr , & vbuf32 -> dst [ i ] . vaddr ) ; <S2SV_StartBug> vbuf -> dst [ i ] . vaddr = NULL ; <S2SV_EndBug> err |= put_user ( vaddr , ( compat_uptr_t * ) & vbuf -> dst [ i ] . vaddr ) ; err |= get_user ( len , & vbuf32 -> dst [ i ] . len ) ; err |= put_user ( len , & vbuf -> dst [ i ] . len ) ; } return err ; } | <S2SV_ModStart> vaddr ) ; <S2SV_ModEnd> err |= put_user <S2SV_ModStart> vaddr ) ; <S2SV_ModEnd> err |= put_user |
3,709 | CWE-000 static gboolean proxy_add_server_connection_array ( network_mysqld_con * con , int * server_unavailable ) { sharding_plan_t * plan = con -> sharding_plan ; size_t i ; gint8 server_map [ MAX_SERVER_NUM ] = { 0 } ; if ( con -> dist_tran == 0 && con -> servers != NULL && con -> servers -> len > 0 ) { int hit = 0 ; for ( i = 0 ; i < con -> servers -> len ; i ++ ) { server_session_t * ss = g_ptr_array_index ( con -> servers , i ) ; const GString * group = ss -> server -> group ; if ( sharding_plan_has_group ( plan , group ) ) { if ( con -> is_read_ro_server_allowed && ! ss -> server -> is_read_only ) { g_debug ( "%s:<S2SV_blank>use<S2SV_blank>read<S2SV_blank>server" , G_STRLOC ) ; } else if ( ! con -> is_read_ro_server_allowed && ss -> server -> is_read_only ) { g_debug ( "%s:<S2SV_blank>should<S2SV_blank>release<S2SV_blank>ro<S2SV_blank>server<S2SV_blank>to<S2SV_blank>pool" , G_STRLOC ) ; } else { hit ++ ; server_map [ i ] = 1 ; ss -> sql = sharding_plan_get_sql ( con -> sharding_plan , group ) ; g_debug ( "%s:<S2SV_blank>hit<S2SV_blank>server" , G_STRLOC ) ; } } } if ( hit == plan -> groups -> len && con -> servers -> len == hit ) { return TRUE ; } else { if ( con -> is_in_transaction ) { g_warning ( "%s:in<S2SV_blank>single<S2SV_blank>tran,<S2SV_blank>but<S2SV_blank>visit<S2SV_blank>multi<S2SV_blank>servers<S2SV_blank>for<S2SV_blank>con:%p,<S2SV_blank>sql:%s" , G_STRLOC , con , con -> orig_sql -> str ) ; <S2SV_StartBug> return FALSE ; <S2SV_EndBug> } GPtrArray * new_servers = g_ptr_array_new ( ) ; for ( i = 0 ; i < con -> servers -> len ; i ++ ) { server_session_t * ss = g_ptr_array_index ( con -> servers , i ) ; if ( server_map [ i ] == 0 ) { network_connection_pool * pool = ss -> backend -> pool ; network_socket * server = ss -> server ; CHECK_PENDING_EVENT ( & ( server -> event ) ) ; network_pool_add_idle_conn ( pool , con -> srv , server ) ; ss -> backend -> connected_clients -- ; g_debug ( "%s:<S2SV_blank>conn<S2SV_blank>clients<S2SV_blank>sub,<S2SV_blank>total<S2SV_blank>len:%d,<S2SV_blank>back:%p,<S2SV_blank>value:%d<S2SV_blank>con:%p,<S2SV_blank>s:%p" , G_STRLOC , con -> servers -> len , ss -> backend , ss -> backend -> connected_clients , con , server ) ; ss -> sql = NULL ; g_free ( ss ) ; } else { ss -> server -> parse . qs_state = PARSE_COM_QUERY_INIT ; g_ptr_array_add ( new_servers , ss ) ; } } gpointer * pdata = g_ptr_array_free ( con -> servers , FALSE ) ; g_free ( pdata ) ; con -> servers = new_servers ; } } else { if ( con -> dist_tran && con -> servers ) { for ( i = 0 ; i < con -> servers -> len ; i ++ ) { server_session_t * ss = g_ptr_array_index ( con -> servers , i ) ; if ( ss -> server -> is_read_only ) { g_critical ( "%s:<S2SV_blank>crazy,<S2SV_blank>dist<S2SV_blank>tran<S2SV_blank>use<S2SV_blank>readonly<S2SV_blank>server:%p" , G_STRLOC , con ) ; } ss -> participated = 0 ; } } } for ( i = 0 ; i < plan -> groups -> len ; i ++ ) { GString * group = g_ptr_array_index ( plan -> groups , i ) ; if ( ! proxy_add_server_connection ( con , group , server_unavailable ) ) { return FALSE ; } } if ( con -> is_new_server_added && con -> dist_tran && con -> servers -> len > 1 ) { g_ptr_array_sort ( con -> servers , ss_comp ) ; } return TRUE ; } | <S2SV_ModStart> str ) ; con -> xa_tran_conflict = 1 ; |
3,710 | CWE-000 int main ( int argc , char * argv [ ] ) { int N ; int i , j ; int weight ; char word ; int MODE ; char tmp [ 100 ] ; char tmp2 [ 100 ] ; <S2SV_StartBug> userEnterStringInfo * userEnter , userEnterInfo = { 0 , { 0 } , "How<S2SV_blank>are<S2SV_blank>you<S2SV_blank>!" } ; ; <S2SV_EndBug> node * pnode , * rootPnode ; HFTree * rootHuffmanTree ; printf ( "Please<S2SV_blank>select<S2SV_blank>the<S2SV_blank>MODE<S2SV_blank>!\\n" ) ; <S2SV_StartBug> printf ( "1.自定义<S2SV_blank><S2SV_blank><S2SV_blank>2.根据配置文件生成\\n" ) ; <S2SV_EndBug> scanf ( "%d" , & MODE ) ; switch ( MODE ) { case 1 : { printf ( "Please<S2SV_blank>input<S2SV_blank>the<S2SV_blank>NODE<S2SV_blank>number!\\n" ) ; scanf ( "%d" , & N ) ; rootPnode = pnode = ( node * ) malloc ( N * sizeof ( node ) ) ; for ( i = 0 ; i < N ; i ++ ) { scanf ( "%d<S2SV_blank>%c" , & pnode -> info_weight , & pnode -> info_word ) ; memset ( pnode -> info_huffmanCode , 0 , sizeof ( pnode -> info_huffmanCode ) ) ; pnode ++ ; } printf ( "*****now*****\\n" ) ; } break ; case 2 : { rootPnode = pnode = ( node * ) malloc ( 52 * sizeof ( node ) ) ; readHuffmanConfig ( rootPnode ) ; N = 52 ; } break ; case 3 : { N = 0 ; <S2SV_StartBug> characterFrequency ( & userEnterInfo ) ; <S2SV_EndBug> rootPnode = pnode = ( node * ) malloc ( ( userEnterInfo . N ) * sizeof ( node ) ) ; for ( i = 0 ; i < 122 ; i ++ ) { if ( userEnterInfo . freq [ i ] != 0 ) { printf ( "\'%c\':%d<S2SV_blank><S2SV_blank><S2SV_blank>" , i , userEnterInfo . freq [ i ] ) ; pnode -> info_word = i ; pnode -> info_weight = userEnterInfo . freq [ i ] ; <S2SV_StartBug> } <S2SV_EndBug> } N = userEnterInfo . N ; } break ; } getchar ( ) ; <S2SV_StartBug> rootHuffmanTree = createHuffmanTree ( rootPnode , N ) ; <S2SV_EndBug> huffmanCodeing ( rootPnode , N , rootHuffmanTree ) ; for ( i = 0 ; i < N ; i ++ ) printf ( "权值:%d<S2SV_blank><S2SV_blank>字符:%c<S2SV_blank><S2SV_blank>编码:%s\\n" , rootPnode [ i ] . info_weight , rootPnode [ i ] . info_word , rootPnode [ i ] . info_huffmanCode ) ; dataFlowCoding ( rootPnode , tmp ) ; printf ( "用户输入字符串编码:%s\\n" , tmp ) ; dataFlowDecoding ( rootPnode , tmp2 ) ; printf ( "解码:%s\\n" , tmp2 ) ; } | <S2SV_ModStart> "How<S2SV_blank>are<S2SV_blank>you<S2SV_blank>!" } ; <S2SV_ModEnd> node * pnode <S2SV_ModStart> ; printf ( "1.自定义<S2SV_blank><S2SV_blank><S2SV_blank>2.根据配置文件生成<S2SV_blank><S2SV_blank><S2SV_blank>3.动态生成编码\\n" <S2SV_ModEnd> ) ; scanf <S2SV_ModStart> = 0 ; acceptUserInput ( & userEnterInfo ) ; <S2SV_ModStart> i ] ; pnode += 1 ; <S2SV_ModStart> ( ) ; # ifdef nodePrint_Debug nodeCheckPrint ( rootPnode , N ) ; # endif |
3,711 | CWE-000 <S2SV_StartBug> static int _calc_subtract_minutes ( jy * dt , int minutes ) <S2SV_EndBug> { <S2SV_StartBug> int overflow ; <S2SV_EndBug> if ( dt -> jy_min >= minutes ) { dt -> jy_min -= minutes ; return 0 ; } overflow = minutes / 60 ; minutes = minutes % 60 ; if ( dt -> jy_min >= minutes ) { dt -> jy_min -= minutes ; return overflow ; } minutes -= dt -> jy_min ; dt -> jy_min = 60 - minutes ; return ++ overflow ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> static uint_fast64_t <S2SV_ModEnd> _calc_subtract_minutes ( jy <S2SV_ModStart> * dt , uint_fast64_t <S2SV_ModEnd> minutes ) { <S2SV_ModStart> minutes ) { uint_fast64_t <S2SV_ModEnd> overflow ; if |
3,712 | CWE-000 <S2SV_StartBug> errno_t memset_secure ( void * dest , rsize_t destsz , int ch , rsize_t count ) { <S2SV_EndBug> # if __STDC_VERSION__ >= 201112L || __cplusplus >= 201103L return memset_s ( dest , destsz , ch , count ) ; # elif defined ( _WIN32 ) SecureZeroMemory ( dest , destsz ) ; return 0 ; # else if ( dest == NULL ) return EINVAL ; <S2SV_StartBug> if ( destsz > RSIZE_MAX ) return EINVAL ; <S2SV_EndBug> if ( count > destsz ) return EINVAL ; volatile unsigned char * p = dest ; while ( destsz -- && count -- ) { * p ++ = ch ; } return 0 ; # endif } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> int <S2SV_ModEnd> memset_secure ( void <S2SV_ModStart> * dest , size_t <S2SV_ModEnd> destsz , int <S2SV_ModStart> int ch , size_t <S2SV_ModEnd> count ) { <S2SV_ModStart> ( destsz > SIZE_MAX <S2SV_ModEnd> ) return EINVAL |
3,713 | CWE-000 void FillParametersFakeData ( ) { parameters . sensors . kp = 1.00 ; parameters . sensors . kd = 2.00 ; parameters . sensors . derivativeType = feedbackDerivative ; parameters . misc . uartUpdateRate = 75 ; parameters . left . kp = 0 ; parameters . left . ki = 0 ; parameters . left . kd = 3.30 ; parameters . left . derivativeType = feedbackDerivative ; parameters . left . I_limit = 4.00 ; parameters . left . MaxSpeed = 5.00 ; parameters . left . MinSpeed = 6.00 ; parameters . left . SpeedOffset = 7.00 ; parameters . right . kp = 3.14 ; parameters . right . ki = 3.24 ; parameters . right . kd = 3.34 ; parameters . right . derivativeType = feedbackDerivative ; parameters . right . I_limit = 4.14 ; parameters . right . MaxSpeed = 5.14 ; parameters . right . MinSpeed = 6.14 ; parameters . right . SpeedOffset = 7.14 ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> = 7.14 ; parameters . misc . backToTrackForce = 1.0 ; |
3,714 | CWE-000 t_color rec_raytrace ( t_rendering * r , t_line l , int m ) { t_cam_render * d ; t_vec v [ 4 ] ; <S2SV_StartBug> d = & r -> c -> data ; <S2SV_EndBug> if ( m < d -> antialia ) { v [ 0 ] = apply ( vecpro ( apply ( d -> x , d -> y ) , 1 / ( m * 4.0 ) ) , l . v ) ; v [ 1 ] = apply ( vecpro ( apply ( d -> x , vec_rev ( d -> y ) ) , 1 / ( m * 4.0 ) ) , l . v ) ; v [ 2 ] = apply ( vecpro ( apply ( vec_rev ( d -> x ) , d -> y ) , 1 / ( m * 4.0 ) ) , l . v ) ; v [ 3 ] = apply ( vec_rev ( vecpro ( apply ( d -> x , d -> y ) , 1 / ( m * 4.0 ) ) ) , l . v ) ; return ( rgbmoy4 ( ( t_color [ ] ) { rec_raytrace ( r , ( t_line ) { l . m , v [ 0 ] } , m * 2 ) , rec_raytrace ( r , ( t_line ) { l . m , v [ 1 ] } , m * 2 ) , rec_raytrace ( r , ( t_line ) { l . m , v [ 2 ] } , m * 2 ) , rec_raytrace ( r , ( t_line ) { l . m , v [ 3 ] } , m * 2 ) , } ) ) ; } else return ( raytrace ( r , l , 0 ) ) ; } | <S2SV_ModStart> 4 ] ; if ( m == 1 ) pthread_mutex_unlock ( <S2SV_ModEnd> & r -> <S2SV_ModStart> & r -> lock ) ; d = & r -> |
3,715 | CWE-000 void graphic_hw_update_done ( QemuConsole * con ) { <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> con ) { struct qmp_screendump * dump , * next ; QLIST_FOREACH_SAFE ( dump , & con -> qmp_screendumps , link , next ) { qmp_screendump_finish ( con , dump -> filename , dump -> ret ) ; g_free ( dump -> filename ) ; QLIST_REMOVE ( dump , link ) ; g_free ( dump ) ; } |
3,716 | CWE-000 int page_directory_insert ( page_directory * dir , seL4_Word page_id , seL4_CPtr cap , seL4_CPtr kernel_cap ) { seL4_Word frame_id ; assert ( IS_ALIGNED_4K ( page_id ) ) ; seL4_Word directory_index = DIRECTORY_INDEX ( page_id ) ; seL4_Word table_index = TABLE_INDEX ( page_id ) ; if ( ! dir || ! ( dir -> directory ) ) { LOG_ERROR ( "Directory<S2SV_blank>doesnt<S2SV_blank>exist" ) ; return 1 ; } seL4_Word * directory = dir -> directory ; if ( ! directory [ directory_index ] ) { LOG_INFO ( "Creating<S2SV_blank>second<S2SV_blank>level<S2SV_blank>page<S2SV_blank>table<S2SV_blank>at<S2SV_blank>index<S2SV_blank>%d" , directory_index ) ; seL4_Word page_table_vaddr ; if ( ( frame_id = frame_alloc ( & page_table_vaddr ) ) == - 1 ) { LOG_ERROR ( "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>second<S2SV_blank>level" ) ; return 1 ; } assert ( frame_table_set_chance ( frame_id , PINNED ) == 0 ) ; directory [ directory_index ] = page_table_vaddr ; } page_table_entry * second_level = ( page_table_entry * ) directory [ directory_index ] ; <S2SV_StartBug> assert ( cap < MAX_CAP_ID ) ; <S2SV_EndBug> assert ( ( cap >> 31 ) == 0 ) ; second_level [ table_index ] . page = cap ; if ( kernel_cap ) { seL4_Word index = CAP_INDEX ( page_id ) ; seL4_CPtr * cap_table = dir -> kernel_page_table_caps ; assert ( ! cap_table [ index ] ) ; cap_table [ index ] = kernel_cap ; LOG_INFO ( "kernel<S2SV_blank>cap<S2SV_blank>inserted<S2SV_blank>into<S2SV_blank>%u" , index ) ; } return 0 ; } | <S2SV_ModStart> directory_index ] ; if ( IS_EVICTED ( cap ) ) { LOG_ERROR ( "MSB<S2SV_blank>is<S2SV_blank>required<S2SV_blank>to<S2SV_blank>be<S2SV_blank>0" ) ; return 1 ; } <S2SV_ModEnd> second_level [ table_index |
3,717 | CWE-000 static int rack_do_syn_recv ( struct mbuf * m , struct tcphdr * th , struct socket * so , struct tcpcb * tp , struct tcpopt * to , int32_t drop_hdrlen , int32_t tlen , uint32_t tiwin , int32_t thflags , int32_t nxt_pkt ) { int32_t ret_val = 0 ; int32_t ourfinisacked = 0 ; rack_calc_rwin ( so , tp ) ; if ( ( thflags & TH_ACK ) && ( SEQ_LEQ ( th -> th_ack , tp -> snd_una ) || SEQ_GT ( th -> th_ack , tp -> snd_max ) ) ) { rack_do_dropwithreset ( m , tp , th , BANDLIM_RST_OPENPORT , tlen ) ; return ( 1 ) ; } if ( IS_FASTOPEN ( tp -> t_flags ) ) { if ( ( thflags & ( TH_SYN | TH_ACK ) ) == ( TH_SYN | TH_ACK ) ) { rack_do_dropwithreset ( m , tp , th , BANDLIM_RST_OPENPORT , tlen ) ; return ( 1 ) ; } else if ( thflags & TH_SYN ) { struct tcp_rack * rack ; rack = ( struct tcp_rack * ) tp -> t_fb_ptr ; if ( ( rack -> r_ctl . rc_hpts_flags & PACE_TMR_RXT ) || ( rack -> r_ctl . rc_hpts_flags & PACE_TMR_TLP ) || ( rack -> r_ctl . rc_hpts_flags & PACE_TMR_RACK ) ) { rack_do_drop ( m , NULL ) ; return ( 0 ) ; } } else if ( ! ( thflags & ( TH_ACK | TH_FIN | TH_RST ) ) ) { rack_do_drop ( m , NULL ) ; return ( 0 ) ; } } if ( thflags & TH_RST ) return ( rack_process_rst ( m , th , so , tp ) ) ; <S2SV_StartBug> if ( thflags & TH_SYN ) { <S2SV_EndBug> rack_challenge_ack ( m , th , tp , & ret_val ) ; return ( ret_val ) ; } if ( ( to -> to_flags & TOF_TS ) != 0 && tp -> ts_recent && TSTMP_LT ( to -> to_tsval , tp -> ts_recent ) ) { if ( rack_ts_check ( m , th , tp , tlen , thflags , & ret_val ) ) return ( ret_val ) ; } if ( SEQ_LT ( th -> th_seq , tp -> irs ) ) { rack_do_dropwithreset ( m , tp , th , BANDLIM_RST_OPENPORT , tlen ) ; return ( 1 ) ; } if ( rack_drop_checks ( to , m , th , tp , & tlen , & thflags , & drop_hdrlen , & ret_val ) ) { return ( ret_val ) ; } if ( ( to -> to_flags & TOF_TS ) != 0 && SEQ_LEQ ( th -> th_seq , tp -> last_ack_sent ) && SEQ_LEQ ( tp -> last_ack_sent , th -> th_seq + tlen + ( ( thflags & ( TH_SYN | TH_FIN ) ) != 0 ) ) ) { tp -> ts_recent_age = tcp_ts_getticks ( ) ; tp -> ts_recent = to -> to_tsval ; } if ( ( thflags & TH_ACK ) == 0 ) { if ( IS_FASTOPEN ( tp -> t_flags ) ) { tp -> snd_wnd = tiwin ; cc_conn_init ( tp ) ; } return ( rack_process_data ( m , th , so , tp , drop_hdrlen , tlen , tiwin , thflags , nxt_pkt ) ) ; } TCPSTAT_INC ( tcps_connects ) ; soisconnected ( so ) ; if ( ( tp -> t_flags & ( TF_RCVD_SCALE | TF_REQ_SCALE ) ) == ( TF_RCVD_SCALE | TF_REQ_SCALE ) ) { tp -> rcv_scale = tp -> request_r_scale ; tp -> snd_wnd = tiwin ; } <S2SV_StartBug> tp -> t_starttime = ticks ; <S2SV_EndBug> if ( tp -> t_flags & TF_NEEDFIN ) { tcp_state_change ( tp , TCPS_FIN_WAIT_1 ) ; tp -> t_flags &= ~ TF_NEEDFIN ; } else { tcp_state_change ( tp , TCPS_ESTABLISHED ) ; TCP_PROBE5 ( accept__established , NULL , tp , mtod ( m , const char * ) , tp , th ) ; <S2SV_StartBug> if ( IS_FASTOPEN ( tp -> t_flags ) && tp -> t_tfo_pending ) { <S2SV_EndBug> tcp_fastopen_decrement_counter ( tp -> t_tfo_pending ) ; tp -> t_tfo_pending = NULL ; tp -> snd_una ++ ; } if ( ! IS_FASTOPEN ( tp -> t_flags ) ) cc_conn_init ( tp ) ; } if ( tlen == 0 && ( thflags & TH_FIN ) == 0 ) ( void ) tcp_reass ( tp , ( struct tcphdr * ) 0 , NULL , 0 , ( struct mbuf * ) 0 ) ; tp -> snd_wl1 = th -> th_seq - 1 ; if ( rack_process_ack ( m , th , so , tp , to , tiwin , tlen , & ourfinisacked , thflags , & ret_val ) ) { return ( ret_val ) ; } if ( tp -> t_state == TCPS_FIN_WAIT_1 ) { if ( ourfinisacked ) { if ( so -> so_rcv . sb_state & SBS_CANTRCVMORE ) { soisdisconnected ( so ) ; tcp_timer_activate ( tp , TT_2MSL , ( tcp_fast_finwait2_recycle ? tcp_finwait2_timeout : TP_MAXIDLE ( tp ) ) ) ; } tcp_state_change ( tp , TCPS_FIN_WAIT_2 ) ; } } return ( rack_process_data ( m , th , so , tp , drop_hdrlen , tlen , tiwin , thflags , nxt_pkt ) ) ; } | <S2SV_ModStart> ; if ( <S2SV_ModEnd> ( to -> <S2SV_ModStart> = ticks ; if ( IS_FASTOPEN ( tp -> t_flags ) && tp -> t_tfo_pending ) { tcp_fastopen_decrement_counter ( tp -> t_tfo_pending ) ; tp -> t_tfo_pending = NULL ; tp -> snd_una ++ ; } <S2SV_ModStart> ; if ( <S2SV_ModEnd> ! IS_FASTOPEN ( |
3,718 | CWE-000 <S2SV_StartBug> void Perpendicular_ElectricField ( float StepSize , unsigned long int Time_Seconds ) <S2SV_EndBug> { <S2SV_StartBug> unsigned int count = 0 ; <S2SV_EndBug> while ( count <= Time_Seconds ) { ElectronMovement_Perpendicular ( Velocity_Electron , count ) ; Sleep ( StepSize * 1000 ) ; count ++ ; } } | <S2SV_ModStart> float StepSize , float <S2SV_ModEnd> Time_Seconds ) { <S2SV_ModStart> Time_Seconds ) { float <S2SV_ModEnd> count = 0 |
3,719 | CWE-000 static void connect_conn_callback ( uv_poll_t * handle , int status , int events ) { ( void ) status ; ( void ) events ; UpstreamPoll * upstreamPoll = handle -> data ; if ( ! upstreamPoll ) { return ; } uv_poll_stop ( handle ) ; uv_close ( ( uv_handle_t * ) handle , broker_free_handle ) ; upstreamPoll -> connPoll = NULL ; char * resp = NULL ; int respLen = 0 ; while ( 1 ) { char buf [ 1024 ] ; int read = dslink_socket_read ( upstreamPoll -> sock , buf , sizeof ( buf ) - 1 ) ; if ( read == DSLINK_SOCK_WOULD_BLOCK ) { continue ; } if ( read == 0 ) { break ; } if ( read != DSLINK_SOCK_WOULD_BLOCK && read <= 0 ) { if ( errno != EAGAIN ) { log_err ( "Error<S2SV_blank>while<S2SV_blank>reading<S2SV_blank>from<S2SV_blank>socket<S2SV_blank>%d\\n" , errno ) ; return ; } break ; } if ( resp == NULL ) { resp = dslink_malloc ( ( size_t ) read + 1 ) ; respLen = read ; memcpy ( resp , buf , ( size_t ) read ) ; * ( resp + respLen ) = '\\0' ; } else { char * tmp = realloc ( resp , ( size_t ) respLen + read + 1 ) ; resp = tmp ; memcpy ( resp + respLen , buf , ( size_t ) read ) ; respLen += read ; * ( resp + respLen ) = '\\0' ; } } json_t * handshake = NULL ; dslink_parse_handshake_response ( resp , & handshake ) ; dslink_free ( resp ) ; dslink_socket_close_nofree ( upstreamPoll -> sock ) ; dslink_socket_free ( upstreamPoll -> sock ) ; upstreamPoll -> sock = NULL ; if ( handshake ) { const char * uri = json_string_value ( json_object_get ( handshake , "wsUri" ) ) ; const char * tKey = json_string_value ( json_object_get ( handshake , "tempKey" ) ) ; const char * salt = json_string_value ( json_object_get ( handshake , "salt" ) ) ; if ( ! ( uri && tKey && salt ) ) { log_warn ( "Handshake<S2SV_blank>didn\'t<S2SV_blank>return<S2SV_blank>the<S2SV_blank>necessary<S2SV_blank>parameters<S2SV_blank>to<S2SV_blank>complete\\n" ) ; goto exit ; } if ( ( dslink_handshake_connect_ws ( upstreamPoll -> clientDslink -> config . broker_url , & upstreamPoll -> clientDslink -> key , uri , tKey , salt , upstreamPoll -> dsId , NULL , & upstreamPoll -> sock ) ) != 0 ) { upstream_reconnect ( upstreamPoll ) ; goto exit ; } else { <S2SV_StartBug> log_info ( "Successfully<S2SV_blank>connected<S2SV_blank>to<S2SV_blank>the<S2SV_blank>broker\\n" ) ; <S2SV_EndBug> } upstreamPoll -> clientDslink -> _socket = upstreamPoll -> sock ; upstream_handshake_handle_ws ( upstreamPoll ) ; upstreamPoll -> status = UPSTREAM_WS ; upstreamPoll -> reconnectInterval = 0 ; } else { upstreamPoll -> status = UPSTREAM_NONE ; upstream_reconnect ( upstreamPoll ) ; } exit : json_decref ( handshake ) ; } | <S2SV_ModStart> { log_info ( "Successfully<S2SV_blank>connected<S2SV_blank>to<S2SV_blank>the<S2SV_blank>upstream<S2SV_blank>broker<S2SV_blank>\'%s\'\\n" , upstreamPoll -> name ) ; log_info ( |
3,720 | CWE-000 static int set_sample_req ( unsigned char * str ) { <S2SV_StartBug> size_t len = len = strlen ( str ) ; <S2SV_EndBug> int r ; if ( sample_req ) test_req_free ( sample_req ) ; sample_req = test_req_alloc ( len ) ; r = tfw_http_parse_req ( sample_req , str , len ) ; return r ; } | <S2SV_ModStart> ) { size_t <S2SV_ModEnd> len = strlen |
3,721 | CWE-000 static int read_symbols ( struct elf * elf ) { struct section * symtab , * sec ; struct symbol * sym , * pfunc ; struct list_head * entry , * tmp ; int symbols_nr , i ; char * coldstr ; symtab = find_section_by_name ( elf , ".symtab" ) ; if ( ! symtab ) { WARN ( "missing<S2SV_blank>symbol<S2SV_blank>table" ) ; return - 1 ; } symbols_nr = symtab -> sh . sh_size / symtab -> sh . sh_entsize ; for ( i = 0 ; i < symbols_nr ; i ++ ) { sym = malloc ( sizeof ( * sym ) ) ; if ( ! sym ) { perror ( "malloc" ) ; return - 1 ; } memset ( sym , 0 , sizeof ( * sym ) ) ; sym -> idx = i ; if ( ! gelf_getsym ( symtab -> data , i , & sym -> sym ) ) { WARN_ELF ( "gelf_getsym" ) ; goto err ; } sym -> name = elf_strptr ( elf -> elf , symtab -> sh . sh_link , sym -> sym . st_name ) ; if ( ! sym -> name ) { WARN_ELF ( "elf_strptr" ) ; goto err ; } sym -> type = GELF_ST_TYPE ( sym -> sym . st_info ) ; sym -> bind = GELF_ST_BIND ( sym -> sym . st_info ) ; if ( sym -> sym . st_shndx > SHN_UNDEF && sym -> sym . st_shndx < SHN_LORESERVE ) { sym -> sec = find_section_by_index ( elf , sym -> sym . st_shndx ) ; if ( ! sym -> sec ) { WARN ( "couldn\'t<S2SV_blank>find<S2SV_blank>section<S2SV_blank>for<S2SV_blank>symbol<S2SV_blank>%s" , sym -> name ) ; goto err ; } if ( sym -> type == STT_SECTION ) { sym -> name = sym -> sec -> name ; sym -> sec -> sym = sym ; } } else sym -> sec = find_section_by_index ( elf , 0 ) ; sym -> offset = sym -> sym . st_value ; sym -> len = sym -> sym . st_size ; entry = & sym -> sec -> symbol_list ; list_for_each_prev ( tmp , & sym -> sec -> symbol_list ) { struct symbol * s ; s = list_entry ( tmp , struct symbol , list ) ; if ( sym -> offset > s -> offset ) { entry = tmp ; break ; } if ( sym -> offset == s -> offset && sym -> len >= s -> len ) { entry = tmp ; break ; } } list_add ( & sym -> list , entry ) ; hash_add ( sym -> sec -> symbol_hash , & sym -> hash , sym -> idx ) ; } list_for_each_entry ( sec , & elf -> sections , list ) { list_for_each_entry ( sym , & sec -> symbol_list , list ) { if ( sym -> type != STT_FUNC ) continue ; sym -> pfunc = sym -> cfunc = sym ; coldstr = strstr ( sym -> name , ".cold" ) ; if ( ! coldstr ) continue ; coldstr [ 0 ] = '\\0' ; pfunc = find_symbol_by_name ( elf , sym -> name ) ; coldstr [ 0 ] = '.' ; if ( ! pfunc ) { WARN ( "%s():<S2SV_blank>can\'t<S2SV_blank>find<S2SV_blank>parent<S2SV_blank>function" , sym -> name ) ; <S2SV_StartBug> goto err ; <S2SV_EndBug> } sym -> pfunc = pfunc ; pfunc -> cfunc = sym ; if ( sym -> sec == pfunc -> sec && sym -> offset >= pfunc -> offset && sym -> offset + sym -> len == pfunc -> offset + pfunc -> len ) { pfunc -> len -= sym -> len ; } } } return 0 ; err : free ( sym ) ; return - 1 ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> name ) ; <S2SV_ModEnd> return - 1 <S2SV_ModStart> 1 ; } sym -> pfunc = pfunc ; pfunc -> cfunc = sym ; if ( sym -> sec == pfunc -> sec && sym -> offset >= pfunc -> offset && sym -> offset + sym -> len == pfunc -> offset + pfunc -> len ) { pfunc -> len -= sym -> len ; } } } return 0 ; err : free ( sym ) ; return - 1 ; } |
3,722 | CWE-000 static void _eglDefaultLogger ( EGLint level , const char * msg ) { # ifdef HAVE_ANDROID_PLATFORM static const int egl2alog [ ] = { <S2SV_StartBug> [ _EGL_FATAL ] = LOG_ERROR , <S2SV_EndBug> <S2SV_StartBug> [ _EGL_WARNING ] = LOG_WARN , <S2SV_EndBug> <S2SV_StartBug> [ _EGL_INFO ] = LOG_INFO , <S2SV_EndBug> <S2SV_StartBug> [ _EGL_DEBUG ] = LOG_DEBUG , <S2SV_EndBug> } ; <S2SV_StartBug> ALOG ( egl2alog [ level ] , LOG_TAG , "%s" , msg ) ; <S2SV_EndBug> # else fprintf ( stderr , "libEGL<S2SV_blank>%s:<S2SV_blank>%s\\n" , level_strings [ level ] , msg ) ; # endif } | <S2SV_ModStart> _EGL_FATAL ] = ANDROID_LOG_ERROR <S2SV_ModEnd> , [ _EGL_WARNING <S2SV_ModStart> _EGL_WARNING ] = ANDROID_LOG_WARN <S2SV_ModEnd> , [ _EGL_INFO <S2SV_ModStart> _EGL_INFO ] = ANDROID_LOG_INFO <S2SV_ModEnd> , [ _EGL_DEBUG <S2SV_ModStart> _EGL_DEBUG ] = ANDROID_LOG_DEBUG <S2SV_ModEnd> , } ; <S2SV_ModStart> , } ; LOG_PRI <S2SV_ModEnd> ( egl2alog [ |
3,723 | CWE-000 static int check_fd ( int fd ) { # if defined ( HAVE_FSTAT ) struct stat buf ; <S2SV_StartBug> if ( ! _PyVerify_fd ( fd ) || ( fstat ( fd , & buf ) < 0 && errno == EBADF ) ) { <S2SV_EndBug> PyObject * exc ; <S2SV_StartBug> char * msg = strerror ( EBADF ) ; <S2SV_EndBug> exc = PyObject_CallFunction ( PyExc_OSError , "(is)" , EBADF , msg ) ; PyErr_SetObject ( PyExc_OSError , exc ) ; Py_XDECREF ( exc ) ; return - 1 ; <S2SV_StartBug> } <S2SV_EndBug> # endif return 0 ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> stat buf ; int res ; <S2SV_ModEnd> PyObject * exc <S2SV_ModStart> ; char * msg ; if ( ! _PyVerify_fd ( fd ) ) { goto badfd ; } Py_BEGIN_ALLOW_THREADS res = fstat ( fd , & buf ) ; Py_END_ALLOW_THREADS if ( res < 0 && errno == EBADF ) { goto badfd ; } return 0 ; badfd : <S2SV_ModStart> - 1 ; # else <S2SV_ModEnd> return 0 ; <S2SV_ModStart> return 0 ; # endif |
3,724 | CWE-000 xns_object * xns_prim_atom ( struct xns_vm * vm , xns_obj env , xns_obj args ) { <S2SV_StartBug> if ( ! xns_nil ( args -> cdr ) ) { <S2SV_EndBug> <S2SV_StartBug> vm -> error ( vm , "atom<S2SV_blank>called<S2SV_blank>with<S2SV_blank>too<S2SV_blank>many<S2SV_blank>arguments" , args ) ; <S2SV_EndBug> return vm -> NIL ; } xns_obj o = eval ( args -> car , env ) ; while ( o -> type == XNS_HANDLE ) { o = o -> ptr ; } if ( o -> type != XNS_CONS ) { return o ; } return vm -> NIL ; } | <S2SV_ModStart> { if ( xns_len ( args ) != 1 <S2SV_ModEnd> ) { vm <S2SV_ModStart> ( vm , "atom<S2SV_blank>called<S2SV_blank>with<S2SV_blank>an<S2SV_blank>incorrect<S2SV_blank>number<S2SV_blank>of<S2SV_blank>arguments" <S2SV_ModEnd> , args ) |
3,725 | CWE-000 <S2SV_StartBug> static int mem_stat ( struct chan * c , uint8_t * db , int n ) <S2SV_EndBug> { return devstat ( c , db , n , mem_dir , ARRAY_SIZE ( mem_dir ) , devgen ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> static size_t <S2SV_ModEnd> mem_stat ( struct <S2SV_ModStart> * db , size_t <S2SV_ModEnd> n ) { |
3,726 | CWE-000 int II_Read ( void * ctx , IndexResult * hit ) { IntersectContext * ic = ( IntersectContext * ) ctx ; if ( ic -> num == 0 ) return INDEXREAD_EOF ; int nh = 0 ; int i = 0 ; do { nh = 0 ; for ( i = 0 ; i < ic -> num ; i ++ ) { IndexIterator * it = ic -> its [ i ] ; if ( ! it ) goto eof ; IndexResult * h = & ic -> currentHits [ i ] ; int rc = INDEXREAD_OK ; if ( h -> docId != ic -> lastDocId || ic -> lastDocId == 0 ) { h -> numRecords = 0 ; <S2SV_StartBug> if ( i == 0 ) { <S2SV_EndBug> rc = it -> Read ( it -> ctx , h ) ; } else { rc = it -> SkipTo ( it -> ctx , ic -> lastDocId , h ) ; } if ( rc == INDEXREAD_EOF ) goto eof ; } if ( h -> docId > ic -> lastDocId ) { ic -> lastDocId = h -> docId ; break ; } if ( rc == INDEXREAD_OK ) { ++ nh ; } else { ic -> lastDocId ++ ; } } if ( nh == ic -> num ) { if ( hit != NULL ) { hit -> numRecords = 0 ; for ( int i = 0 ; i < nh ; i ++ ) { IndexResult_Add ( hit , & ic -> currentHits [ i ] ) ; } } ic -> lastDocId ++ ; if ( ic -> exact && hit != NULL ) { int md = IndexResult_MinOffsetDelta ( hit ) ; if ( md > ic -> num - 1 ) { continue ; } } ic -> len ++ ; return INDEXREAD_OK ; } } while ( 1 ) ; eof : ic -> atEnd = 1 ; return INDEXREAD_EOF ; } | <S2SV_ModStart> i == 0 && h -> docId >= ic -> lastDocId |
3,727 | CWE-000 void CLAnnSetupTrainingFor ( CLAnn * nn , CLPlatform platform , CLDevice device ) { nn -> platform = platform ; nn -> device = device ; nn -> context = CLCreateContext ( platform , device ) ; nn -> queue = CLCreateQueue ( nn -> context , nn -> device ) ; nn -> program = CLCreateProgram ( nn -> context , nn -> device , "Kernels.ocl" ) ; nn -> kernelClean = CLCreateKernel ( nn -> program , kClean ) ; nn -> kernelActivation = malloc ( sizeof ( CLKernel ) * 3 ) ; nn -> kernelActivation [ CLActivationSigmoid ] = CLCreateKernel ( nn -> program , kActivationSigmoid ) ; nn -> kernelActivation [ CLActivationTansig ] = CLCreateKernel ( nn -> program , kActivationTansig ) ; nn -> kernelActivation [ CLActivationRadbas ] = CLCreateKernel ( nn -> program , kActivationRadbas ) ; nn -> kernelChiSquared = CLCreateKernel ( nn -> program , kChiSquared ) ; nn -> kernelChiSquaredReduce = CLCreateKernel ( nn -> program , kChiSquaredReduce ) ; nn -> kernelJacobian = CLCreateKernel ( nn -> program , kJacobian ) ; nn -> kernelDelta = CLCreateKernel ( nn -> program , kDelta ) ; nn -> kernelCholeskyDecomposition = CLCreateKernel ( nn -> program , kCholeskyDecomposition ) ; clblasSetup ( ) ; CLMatrixCreateMemHostVar ( nn -> inputs , nn -> context , CL_MEM_READ_ONLY ) ; CLMatrixCreateMemHostVar ( nn -> targets , nn -> context , CL_MEM_READ_ONLY ) ; CLMatrixCreateMemHostVar ( nn -> weights , nn -> context , CL_MEM_READ_WRITE ) ; CLMatrixUpdateValues ( nn -> weightsTemp , nn -> weights -> values ) ; CLMatrixCreateMemHostVar ( nn -> weightsTemp , nn -> context , CL_MEM_READ_WRITE ) ; CLSize offset = 0 ; for ( CLUInt i = 0 ; i < nn -> nHiddenLayers + 1 ; ++ i ) { nn -> weightsForLayer [ i ] -> offsetMem = offset ; offset += nn -> weightsForLayer [ i ] -> elements ; nn -> weightsForLayer [ i ] -> mem = nn -> weights -> mem ; clRetainMemObject ( nn -> weights -> mem ) ; } <S2SV_StartBug> CLMatrixCreateMem ( nn -> outputs , nn -> context , CL_MEM_READ_ONLY ) ; <S2SV_EndBug> for ( CLUInt i = 0 ; i < nn -> nHiddenLayers ; ++ i ) { CLMatrixCreateMem ( nn -> hActivations [ i ] , nn -> context , CL_MEM_READ_WRITE ) ; } CLSize lws [ ] = { BLOCK_SIZE } ; CLSize gws [ ] = { CLGetOptimalGlobalWorkItemsSize ( nn -> targets -> elements , lws [ 0 ] ) } ; CLSize nwg = divUpSize ( gws [ 0 ] , lws [ 0 ] ) ; nn -> chiSquaredError = CLCreateBuffer ( nn -> context , CL_MEM_READ_WRITE , sizeof ( CLFloat ) * nwg , "chiSquaredError" ) ; CLMatrixCreateMem ( nn -> jacobian , nn -> context , CL_MEM_READ_WRITE ) ; CLMatrixCreateMem ( nn -> hessian , nn -> context , CL_MEM_READ_WRITE ) ; CLMatrixCreateMem ( nn -> d , nn -> context , CL_MEM_READ_WRITE ) ; CLMatrixCreateMem ( nn -> delta , nn -> context , CL_MEM_READ_WRITE ) ; CLMatrixCreateMem ( nn -> cholesky , nn -> context , CL_MEM_READ_WRITE ) ; nn -> illMem = CLCreateBuffer ( nn -> context , CL_MEM_READ_WRITE , sizeof ( CLUInt ) , "ill" ) ; CLDeviceType deviceType = CLGetDeviceType ( nn -> device ) ; switch ( deviceType ) { case CL_DEVICE_TYPE_CPU : BLOCK_SIZE = 1 ; break ; case CL_DEVICE_TYPE_GPU : BLOCK_SIZE = 32 ; break ; default : break ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> -> context , CL_MEM_READ_WRITE <S2SV_ModEnd> ) ; for <S2SV_ModStart> break ; } printf ( "CLMem<S2SV_blank>weights<S2SV_blank>reference<S2SV_blank>count:<S2SV_blank>%d\\n" , getReferenceCountOfMem ( nn -> weights -> mem ) ) ; |
3,728 | CWE-000 bool eval_regex ( const struct expr * expr , struct eval_state * state ) { const char * path = state -> ftwbuf -> path ; size_t len = strlen ( path ) ; regmatch_t match = { . rm_so = 0 , . rm_eo = len , } ; int flags = 0 ; # ifdef REG_STARTEND flags |= REG_STARTEND ; # endif int err = regexec ( expr -> regex , path , 1 , & match , flags ) ; if ( err == 0 ) { return match . rm_so == 0 && match . rm_eo == len ; } else if ( err != REG_NOMATCH ) { char * str = xregerror ( err , expr -> regex ) ; if ( str ) { <S2SV_StartBug> cfprintf ( state -> cmdline -> cerr , "%{er}\'%s\':<S2SV_blank>%s%{rs}\\n" , path , str ) ; <S2SV_EndBug> free ( str ) ; } else { perror ( "xregerror()" ) ; } * state -> ret = EXIT_FAILURE ; } return false ; } | <S2SV_ModStart> -> cerr , "%{er}error:<S2SV_blank>\'%s\':<S2SV_blank>%s%{rs}\\n" <S2SV_ModEnd> , path , |
3,729 | CWE-000 static lrc_obj_t * network_constructor ( void ) { struct lrc_network * network ; network = malloc ( sizeof ( * network ) ) ; if ( ! network ) { return ( lrc_obj_t * ) 0 ; } <S2SV_StartBug> memset ( network , 0 , sizeof ( network -> protocol ) ) ; <S2SV_EndBug> network -> port = INVAILD_PORT ; return ( lrc_obj_t * ) network ; } | <S2SV_ModStart> , sizeof ( * network <S2SV_ModEnd> ) ) ; |
3,730 | CWE-000 static Lisp_Object read_char_x_menu_prompt ( Lisp_Object map , Lisp_Object prev_event , bool * used_mouse_menu ) { if ( used_mouse_menu ) * used_mouse_menu = false ; if ( ! menu_prompting ) return Qnil ; if ( EVENT_HAS_PARAMETERS ( prev_event ) && ! EQ ( XCAR ( prev_event ) , Qmenu_bar ) && ! EQ ( XCAR ( prev_event ) , Qtool_bar ) ) { Lisp_Object value ; <S2SV_StartBug> value = Fx_popup_menu ( prev_event , get_keymap ( map , 0 , 1 ) ) ; <S2SV_EndBug> if ( CONSP ( value ) ) { Lisp_Object tem ; record_menu_key ( XCAR ( value ) ) ; for ( tem = XCDR ( value ) ; CONSP ( tem ) ; tem = XCDR ( tem ) ) { record_menu_key ( XCAR ( tem ) ) ; if ( SYMBOLP ( XCAR ( tem ) ) || INTEGERP ( XCAR ( tem ) ) ) XSETCAR ( tem , Fcons ( XCAR ( tem ) , Qdisabled ) ) ; } Vunread_command_events = nconc2 ( XCDR ( value ) , Vunread_command_events ) ; value = XCAR ( value ) ; } else if ( NILP ( value ) ) value = Qt ; if ( used_mouse_menu ) * used_mouse_menu = true ; return value ; } return Qnil ; } | <S2SV_ModStart> ; value = x_popup_menu_1 <S2SV_ModEnd> ( prev_event , |
3,731 | CWE-000 void llist_unlink ( llist_head_st * head , llist_elem_st * elem ) { llist_elem_st * prev_elem , * next_elem ; prev_elem = elem -> prev ; next_elem = elem -> next ; if ( prev_elem ) { prev_elem -> next = next_elem ; } else { <S2SV_StartBug> head -> list_head = NULL ; <S2SV_EndBug> } if ( next_elem ) { next_elem -> prev = prev_elem ; } elem -> next = NULL ; elem -> prev = NULL ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> -> list_head = next_elem <S2SV_ModEnd> ; } if <S2SV_ModStart> = NULL ; head -> list_count -- ; |
3,732 | CWE-000 int CSC322_fread ( void * buffer , size_t nBytes , CSC322FILE * stream ) { if ( stream == NULL ) { return ERR_NULL ; } if ( ! fs_init ( ) ) { return ERR_FILESYSTEM ; } if ( nBytes == 0 ) { return 0 ; } if ( nBytes < 0 ) { return - 1 ; } if ( strcmp ( stream -> mode , "ab" ) == 0 ) { return - 1 ; } else if ( strcmp ( stream -> mode , "wb" ) == 0 ) { return - 1 ; } uint64_t futurePos = nBytes + stream -> fpos ; <S2SV_StartBug> if ( futurePos >= stream -> fsize ) { <S2SV_EndBug> futurePos = stream -> fsize - 1 ; } uint64_t willRead = futurePos - stream -> fpos ; if ( willRead == 0 ) { return EOF ; } memcpy ( buffer , stream -> buffer , ( size_t ) willRead ) ; stream -> fpos = futurePos ; return ( int ) willRead ; } | <S2SV_ModStart> if ( futurePos > <S2SV_ModEnd> stream -> fsize |
3,733 | CWE-000 static ssize_t lnet_debugfs_write ( struct file * filp , const char __user * buf , size_t count , loff_t * ppos ) { struct ctl_table * table = filp -> private_data ; int error ; <S2SV_StartBug> error = table -> proc_handler ( table , 1 , ( void __user * ) buf , & count , ppos ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ! error ) <S2SV_EndBug> <S2SV_StartBug> error = count ; <S2SV_EndBug> return error ; } | <S2SV_ModStart> int error ; loff_t old_pos = * ppos ; <S2SV_ModStart> ! error ) { <S2SV_ModStart> = count ; if ( * ppos == old_pos ) * ppos += count ; } |
3,734 | CWE-000 int tokenizer_has_next ( tokenizer * tok ) { <S2SV_StartBug> for ( int i = tok -> prev_token_index ; i < string_length ( tok -> str ) ; i ++ ) <S2SV_EndBug> if ( string_char_at ( tok -> str , i ) != '<S2SV_blank>' && string_char_at ( tok -> str , i ) != ')' ) return true ; return false ; } | <S2SV_ModStart> tok ) { return tok -> tokens_left > 0 <S2SV_ModEnd> ; } <S2SV_null> |
3,735 | CWE-000 static int parse_uci_config ( ctx_t * ctx , char * key ) { char xpath [ XPATH_MAX_LEN ] ; char ucipath [ XPATH_MAX_LEN ] ; char * uci_val = calloc ( 1 , 100 ) ; int rc = SR_ERR_OK ; rc = sr_set_item_str ( ctx -> startup_sess , "/sip:sip-config/enabled" , "true" , SR_EDIT_DEFAULT ) ; CHECK_RET ( rc , cleanup , "failed<S2SV_blank>sr_set_item_str:<S2SV_blank>%s" , sr_strerror ( rc ) ) ; const int n_mappings_bool = ARR_SIZE ( table_sr_uci_bool ) ; for ( int i = 0 ; i < n_mappings_bool ; i ++ ) { snprintf ( xpath , XPATH_MAX_LEN , table_sr_uci_bool [ i ] . xpath , key ) ; snprintf ( ucipath , XPATH_MAX_LEN , table_sr_uci_bool [ i ] . ucipath , key ) ; rc = get_uci_item ( ctx -> uctx , ucipath , & uci_val ) ; UCI_CHECK_RET ( rc , cleanup , "get_uci_item<S2SV_blank>%s" , sr_strerror ( rc ) ) ; INF ( "%s<S2SV_blank>:<S2SV_blank>%s" , xpath , uci_val ) ; if ( 0 == strncmp ( uci_val , "1" , 1 ) || ( 0 == strncmp ( uci_val , "true" , 1 ) ) || ( 0 == strncmp ( uci_val , "on" , 1 ) ) ) { rc = sr_set_item_str ( ctx -> startup_sess , xpath , "true" , SR_EDIT_DEFAULT ) ; } else { rc = sr_set_item_str ( ctx -> startup_sess , xpath , "false" , SR_EDIT_DEFAULT ) ; } CHECK_RET ( rc , cleanup , "failed<S2SV_blank>sr_set_item_str:<S2SV_blank>%s" , sr_strerror ( rc ) ) ; } const int n_mappings = ARR_SIZE ( table_sr_uci ) ; for ( int i = 0 ; i < n_mappings ; i ++ ) { snprintf ( xpath , XPATH_MAX_LEN , table_sr_uci [ i ] . xpath , key ) ; snprintf ( ucipath , XPATH_MAX_LEN , table_sr_uci [ i ] . ucipath , key ) ; rc = get_uci_item ( ctx -> uctx , ucipath , & uci_val ) ; if ( UCI_ERR_NOTFOUND != rc ) { UCI_CHECK_RET ( rc , cleanup , "get_uci_item<S2SV_blank>%s" , sr_strerror ( rc ) ) ; INF ( "%s<S2SV_blank>:<S2SV_blank>%s" , xpath , uci_val ) ; rc = sr_set_item_str ( ctx -> startup_sess , xpath , uci_val , SR_EDIT_DEFAULT ) ; CHECK_RET ( rc , cleanup , "failed<S2SV_blank>sr_set_item_str:<S2SV_blank>%s" , sr_strerror ( rc ) ) ; } } char * secret = NULL ; rc = get_secret ( key , & secret ) ; <S2SV_StartBug> CHECK_RET ( rc , cleanup , "failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>asterisk<S2SV_blank>secret:<S2SV_blank>%s" , sr_strerror ( rc ) ) ; <S2SV_EndBug> snprintf ( xpath , XPATH_MAX_LEN , "/sip:sip-config/sip-account[account=\'%s\']/password" , key ) ; rc = sr_set_item_str ( ctx -> startup_sess , xpath , secret , SR_EDIT_DEFAULT ) ; <S2SV_StartBug> free ( secret ) ; <S2SV_EndBug> cleanup : if ( SR_ERR_NOT_FOUND == rc ) { rc = SR_ERR_OK ; } if ( NULL != uci_val ) { free ( uci_val ) ; } return rc ; } | <S2SV_ModStart> secret ) ; if ( SR_ERR_OK == rc && NULL != secret ) { <S2SV_ModStart> SR_EDIT_DEFAULT ) ; CHECK_RET ( rc , cleanup , "failed<S2SV_blank>sr_set_item_str:<S2SV_blank>%s" , sr_strerror ( rc ) ) ; <S2SV_ModStart> secret ) ; } else { rc = SR_ERR_OK ; } |
3,736 | CWE-000 VOID VmDirdStateSet ( VDIR_SERVER_STATE state ) { <S2SV_StartBug> BOOLEAN bInLock = FALSE ; <S2SV_EndBug> VDIR_BACKEND_CTX beCtx = { 0 } ; VMDIR_LOCK_MUTEX ( bInLock , gVmdirGlobals . mutex ) ; gVmdirGlobals . vmdirdState = state ; VMDIR_UNLOCK_MUTEX ( bInLock , gVmdirGlobals . mutex ) ; <S2SV_StartBug> if ( state == VMDIRD_STATE_READ_ONLY ) <S2SV_EndBug> { beCtx . pBE = VmDirBackendSelect ( NULL ) ; assert ( beCtx . pBE ) ; while ( beCtx . pBE -> pfnBEGetLeastOutstandingUSN ( & beCtx , TRUE ) != 0 ) { VMDIR_LOG_VERBOSE ( VMDIR_LOG_MASK_ALL , "VmDirdStateSet:<S2SV_blank>Waiting<S2SV_blank>for<S2SV_blank>the<S2SV_blank>pending<S2SV_blank>write<S2SV_blank>transactions<S2SV_blank>to<S2SV_blank>be<S2SV_blank>over" ) ; VmDirSleep ( 2 * 1000 ) ; } } VmDirBackendCtxContentFree ( & beCtx ) ; VMDIR_LOG_INFO ( VMDIR_LOG_MASK_ALL , "VmDir<S2SV_blank>State<S2SV_blank>(%u)" , state ) ; return ; } | <S2SV_ModStart> bInLock = FALSE <S2SV_ModEnd> ; VMDIR_LOCK_MUTEX ( <S2SV_ModStart> mutex ) ; VmDirIterateInstances ( _VmDirdStateSetCB , ( PVOID ) state <S2SV_ModEnd> ) ; VMDIR_LOG_INFO |
3,737 | CWE-000 static gboolean handle_monitor ( gint * argc , gchar * * argv [ ] , gboolean request_completion , const gchar * completion_cur , const gchar * completion_prev ) { gint ret ; GOptionContext * o ; gchar * s ; GError * error ; GDBusConnection * c ; gboolean complete_names ; gboolean complete_paths ; GMainLoop * loop ; ret = FALSE ; c = NULL ; modify_argv0_for_command ( argc , argv , "monitor" ) ; o = g_option_context_new ( NULL ) ; if ( request_completion ) g_option_context_set_ignore_unknown_options ( o , TRUE ) ; g_option_context_set_help_enabled ( o , FALSE ) ; g_option_context_set_summary ( o , _ ( "Monitor<S2SV_blank>a<S2SV_blank>remote<S2SV_blank>object." ) ) ; g_option_context_add_main_entries ( o , monitor_entries , GETTEXT_PACKAGE ) ; g_option_context_add_group ( o , connection_get_group ( ) ) ; complete_names = FALSE ; if ( request_completion && * argc > 1 && g_strcmp0 ( ( * argv ) [ ( * argc ) - 1 ] , "--dest" ) == 0 ) { complete_names = TRUE ; remove_arg ( ( * argc ) - 1 , argc , argv ) ; } complete_paths = FALSE ; if ( request_completion && * argc > 1 && g_strcmp0 ( ( * argv ) [ ( * argc ) - 1 ] , "--object-path" ) == 0 ) { complete_paths = TRUE ; remove_arg ( ( * argc ) - 1 , argc , argv ) ; } if ( ! g_option_context_parse ( o , argc , argv , NULL ) ) { if ( ! request_completion ) { s = g_option_context_get_help ( o , FALSE , NULL ) ; g_printerr ( "%s" , s ) ; g_free ( s ) ; goto out ; } } error = NULL ; c = connection_get_dbus_connection ( & error ) ; if ( c == NULL ) { if ( request_completion ) { if ( g_strcmp0 ( completion_prev , "--address" ) == 0 ) { g_print ( "unix:\\n" "tcp:\\n" "nonce-tcp:\\n" ) ; } else { g_print ( "--system<S2SV_blank>\\n--session<S2SV_blank>\\n--address<S2SV_blank>\\n" ) ; } } else { g_printerr ( _ ( "Error<S2SV_blank>connecting:<S2SV_blank>%s\\n" ) , error -> message ) ; g_error_free ( error ) ; } goto out ; } <S2SV_StartBug> if ( g_dbus_connection_get_unique_name ( c ) != NULL ) <S2SV_EndBug> { if ( complete_names ) { print_names ( c , FALSE ) ; goto out ; } if ( opt_monitor_dest == NULL ) { if ( request_completion ) g_print ( "--dest<S2SV_blank>\\n" ) ; else g_printerr ( _ ( "Error:<S2SV_blank>Destination<S2SV_blank>is<S2SV_blank>not<S2SV_blank>specified\\n" ) ) ; goto out ; } if ( request_completion && g_strcmp0 ( "--dest" , completion_prev ) == 0 ) { print_names ( c , g_str_has_prefix ( opt_monitor_dest , ":" ) ) ; goto out ; <S2SV_StartBug> } <S2SV_EndBug> } if ( ! request_completion && ! g_dbus_is_name ( opt_monitor_dest ) ) { g_printerr ( _ ( "Error:<S2SV_blank>%s<S2SV_blank>is<S2SV_blank>not<S2SV_blank>a<S2SV_blank>valid<S2SV_blank>bus<S2SV_blank>name\\n" ) , opt_monitor_dest ) ; goto out ; } if ( complete_paths ) { print_paths ( c , opt_monitor_dest , "/" ) ; goto out ; } if ( opt_monitor_object_path == NULL ) { if ( request_completion ) { g_print ( "--object-path<S2SV_blank>\\n" ) ; goto out ; } } if ( request_completion && g_strcmp0 ( "--object-path" , completion_prev ) == 0 ) { gchar * p ; s = g_strdup ( opt_monitor_object_path ) ; p = strrchr ( s , '/' ) ; if ( p != NULL ) { if ( p == s ) p ++ ; * p = '\\0' ; } print_paths ( c , opt_monitor_dest , s ) ; g_free ( s ) ; goto out ; } if ( ! request_completion && ( opt_monitor_object_path != NULL && ! g_variant_is_object_path ( opt_monitor_object_path ) ) ) { g_printerr ( _ ( "Error:<S2SV_blank>%s<S2SV_blank>is<S2SV_blank>not<S2SV_blank>a<S2SV_blank>valid<S2SV_blank>object<S2SV_blank>path\\n" ) , opt_monitor_object_path ) ; goto out ; } if ( request_completion ) goto out ; if ( opt_monitor_object_path != NULL ) g_print ( "Monitoring<S2SV_blank>signals<S2SV_blank>on<S2SV_blank>object<S2SV_blank>%s<S2SV_blank>owned<S2SV_blank>by<S2SV_blank>%s\\n" , opt_monitor_object_path , opt_monitor_dest ) ; else g_print ( "Monitoring<S2SV_blank>signals<S2SV_blank>from<S2SV_blank>all<S2SV_blank>objects<S2SV_blank>owned<S2SV_blank>by<S2SV_blank>%s\\n" , opt_monitor_dest ) ; loop = g_main_loop_new ( NULL , FALSE ) ; g_bus_watch_name_on_connection ( c , opt_monitor_dest , G_BUS_NAME_WATCHER_FLAGS_AUTO_START , monitor_on_name_appeared , monitor_on_name_vanished , NULL , NULL ) ; g_main_loop_run ( loop ) ; g_main_loop_unref ( loop ) ; ret = TRUE ; out : if ( c != NULL ) g_object_unref ( c ) ; g_option_context_free ( o ) ; return ret ; } | <S2SV_ModStart> ( c ) == NULL ) { if ( ! request_completion ) g_printerr ( _ ( "Error:<S2SV_blank>can’t<S2SV_blank>monitor<S2SV_blank>a<S2SV_blank>non-message-bus<S2SV_blank>connection\\n" ) ) ; goto out ; } <S2SV_ModEnd> if ( complete_names <S2SV_ModStart> goto out ; <S2SV_ModEnd> } if ( |
3,738 | CWE-000 static int msm_eeprom_platform_probe ( struct platform_device * pdev ) { int rc = 0 ; int j = 0 ; uint32_t temp ; struct msm_camera_cci_client * cci_client = NULL ; struct msm_eeprom_ctrl_t * e_ctrl = NULL ; struct msm_eeprom_board_info * eb_info = NULL ; struct device_node * of_node = pdev -> dev . of_node ; struct msm_camera_power_ctrl_t * power_info = NULL ; CDBG ( "%s<S2SV_blank>E\\n" , __func__ ) ; e_ctrl = kzalloc ( sizeof ( * e_ctrl ) , GFP_KERNEL ) ; if ( ! e_ctrl ) { pr_err ( "%s:%d<S2SV_blank>kzalloc<S2SV_blank>failed\\n" , __func__ , __LINE__ ) ; return - ENOMEM ; } e_ctrl -> eeprom_v4l2_subdev_ops = & msm_eeprom_subdev_ops ; e_ctrl -> eeprom_mutex = & msm_eeprom_mutex ; e_ctrl -> is_supported = 0 ; if ( ! of_node ) { pr_err ( "%s<S2SV_blank>dev.of_node<S2SV_blank>NULL\\n" , __func__ ) ; <S2SV_StartBug> return - EINVAL ; <S2SV_EndBug> } rc = of_property_read_u32 ( of_node , "cell-index" , & pdev -> id ) ; CDBG ( "cell-index<S2SV_blank>%d,<S2SV_blank>rc<S2SV_blank>%d\\n" , pdev -> id , rc ) ; if ( rc < 0 ) { pr_err ( "failed<S2SV_blank>rc<S2SV_blank>%d\\n" , rc ) ; <S2SV_StartBug> return rc ; <S2SV_EndBug> } e_ctrl -> subdev_id = pdev -> id ; rc = of_property_read_u32 ( of_node , "qcom,cci-master" , & e_ctrl -> cci_master ) ; CDBG ( "qcom,cci-master<S2SV_blank>%d,<S2SV_blank>rc<S2SV_blank>%d\\n" , e_ctrl -> cci_master , rc ) ; if ( rc < 0 ) { pr_err ( "%s<S2SV_blank>failed<S2SV_blank>rc<S2SV_blank>%d\\n" , __func__ , rc ) ; <S2SV_StartBug> return rc ; <S2SV_EndBug> } rc = of_property_read_u32 ( of_node , "qcom,slave-addr" , & temp ) ; if ( rc < 0 ) { <S2SV_StartBug> pr_err ( "%s<S2SV_blank>failed<S2SV_blank>rc<S2SV_blank>%d\\n" , __func__ , rc ) ; <S2SV_EndBug> return rc ; } e_ctrl -> pdev = pdev ; e_ctrl -> eeprom_device_type = MSM_CAMERA_PLATFORM_DEVICE ; e_ctrl -> i2c_client . i2c_func_tbl = & msm_eeprom_cci_func_tbl ; e_ctrl -> i2c_client . cci_client = kzalloc ( sizeof ( struct msm_camera_cci_client ) , GFP_KERNEL ) ; if ( ! e_ctrl -> i2c_client . cci_client ) { <S2SV_StartBug> pr_err ( "%s<S2SV_blank>failed<S2SV_blank>no<S2SV_blank>memory\\n" , __func__ ) ; <S2SV_EndBug> return - ENOMEM ; } e_ctrl -> eboard_info = kzalloc ( sizeof ( struct msm_eeprom_board_info ) , GFP_KERNEL ) ; if ( ! e_ctrl -> eboard_info ) { pr_err ( "%s<S2SV_blank>failed<S2SV_blank>line<S2SV_blank>%d\\n" , __func__ , __LINE__ ) ; rc = - ENOMEM ; goto cciclient_free ; } eb_info = e_ctrl -> eboard_info ; power_info = & eb_info -> power_info ; eb_info -> i2c_slaveaddr = temp ; power_info -> clk_info = cam_8974_clk_info ; power_info -> clk_info_size = ARRAY_SIZE ( cam_8974_clk_info ) ; power_info -> dev = & pdev -> dev ; CDBG ( "qcom,slave-addr<S2SV_blank>=<S2SV_blank>0x%X\\n" , eb_info -> i2c_slaveaddr ) ; cci_client = e_ctrl -> i2c_client . cci_client ; cci_client -> cci_subdev = msm_cci_get_subdev ( ) ; cci_client -> cci_i2c_master = e_ctrl -> cci_master ; cci_client -> sid = eb_info -> i2c_slaveaddr >> 1 ; cci_client -> retries = 3 ; cci_client -> id_map = 0 ; rc = of_property_read_string ( of_node , "qcom,eeprom-name" , & eb_info -> eeprom_name ) ; CDBG ( "%s<S2SV_blank>qcom,eeprom-name<S2SV_blank>%s,<S2SV_blank>rc<S2SV_blank>%d\\n" , __func__ , eb_info -> eeprom_name , rc ) ; if ( rc < 0 ) { pr_err ( "%s<S2SV_blank>failed<S2SV_blank>%d\\n" , __func__ , __LINE__ ) ; goto board_free ; } rc = msm_eeprom_get_dt_data ( e_ctrl ) ; if ( rc ) goto board_free ; rc = msm_eeprom_parse_memory_map ( of_node , "cal" , & e_ctrl -> cal_data ) ; if ( rc < 0 ) goto board_free ; rc = msm_camera_power_up ( power_info , e_ctrl -> eeprom_device_type , & e_ctrl -> i2c_client ) ; if ( rc ) { pr_err ( "failed<S2SV_blank>rc<S2SV_blank>%d\\n" , rc ) ; goto memdata_free ; } rc = read_eeprom_memory ( e_ctrl , & e_ctrl -> cal_data ) ; if ( rc < 0 ) { pr_err ( "%s<S2SV_blank>read_eeprom_memory<S2SV_blank>failed\\n" , __func__ ) ; goto power_down ; } for ( j = 0 ; j < e_ctrl -> cal_data . num_data ; j ++ ) CDBG ( "memory_data[%d]<S2SV_blank>=<S2SV_blank>0x%X\\n" , j , e_ctrl -> cal_data . mapdata [ j ] ) ; e_ctrl -> is_supported |= msm_eeprom_match_crc ( & e_ctrl -> cal_data ) ; rc = msm_camera_power_down ( power_info , e_ctrl -> eeprom_device_type , & e_ctrl -> i2c_client ) ; if ( rc ) { pr_err ( "failed<S2SV_blank>rc<S2SV_blank>%d\\n" , rc ) ; goto memdata_free ; } v4l2_subdev_init ( & e_ctrl -> msm_sd . sd , e_ctrl -> eeprom_v4l2_subdev_ops ) ; v4l2_set_subdevdata ( & e_ctrl -> msm_sd . sd , e_ctrl ) ; platform_set_drvdata ( pdev , & e_ctrl -> msm_sd . sd ) ; e_ctrl -> msm_sd . sd . internal_ops = & msm_eeprom_internal_ops ; e_ctrl -> msm_sd . sd . flags |= V4L2_SUBDEV_FL_HAS_DEVNODE ; snprintf ( e_ctrl -> msm_sd . sd . name , ARRAY_SIZE ( e_ctrl -> msm_sd . sd . name ) , "msm_eeprom" ) ; media_entity_init ( & e_ctrl -> msm_sd . sd . entity , 0 , NULL , 0 ) ; e_ctrl -> msm_sd . sd . entity . type = MEDIA_ENT_T_V4L2_SUBDEV ; e_ctrl -> msm_sd . sd . entity . group_id = MSM_CAMERA_SUBDEV_EEPROM ; msm_sd_register ( & e_ctrl -> msm_sd ) ; e_ctrl -> is_supported = ( e_ctrl -> is_supported << 1 ) | 1 ; CDBG ( "%s<S2SV_blank>X\\n" , __func__ ) ; return rc ; power_down : msm_camera_power_down ( power_info , e_ctrl -> eeprom_device_type , & e_ctrl -> i2c_client ) ; memdata_free : kfree ( e_ctrl -> cal_data . mapdata ) ; kfree ( e_ctrl -> cal_data . map ) ; board_free : kfree ( e_ctrl -> eboard_info ) ; cciclient_free : kfree ( e_ctrl -> i2c_client . cci_client ) ; kfree ( e_ctrl ) ; return rc ; } | <S2SV_ModStart> __func__ ) ; kfree ( e_ctrl ) ; <S2SV_ModStart> rc ) ; kfree ( e_ctrl ) ; <S2SV_ModStart> rc ) ; kfree ( e_ctrl ) ; <S2SV_ModStart> __func__ , rc ) ; kfree ( e_ctrl <S2SV_ModStart> "%s<S2SV_blank>failed<S2SV_blank>no<S2SV_blank>memory\\n" , __func__ ) ; kfree ( e_ctrl |
3,739 | CWE-000 static int rewrite_flush ( const char * path , struct fuse_file_info * fi ) { int res ; ( void ) path ; <S2SV_StartBug> res = close ( dup ( fi -> fh ) ) ; <S2SV_EndBug> if ( res == - 1 ) return - errno ; return 0 ; } | <S2SV_ModStart> ) path ; RLOCK ( <S2SV_ModStart> fi -> fh ) |
3,740 | CWE-000 int timer_set_absolute ( tim_t dev , int channel , unsigned int value ) { DEBUG ( "Setting<S2SV_blank>timer<S2SV_blank>%i<S2SV_blank>channel<S2SV_blank>%i<S2SV_blank>to<S2SV_blank>%i\\n" , dev , channel , value ) ; switch ( dev ) { # if TIMER_0_EN case TIMER_0 : switch ( channel ) { case 0 : TIMER_0_DEV . INTFLAG . reg |= TC_INTFLAG_MC0 ; TIMER_0_DEV . CC [ 0 ] . reg = value ; TIMER_0_DEV . INTENSET . bit . MC0 = 1 ; break ; case 1 : TIMER_0_DEV . INTFLAG . reg |= TC_INTFLAG_MC1 ; TIMER_0_DEV . CC [ 1 ] . reg = value ; TIMER_0_DEV . INTENSET . bit . MC1 = 1 ; break ; <S2SV_StartBug> } <S2SV_EndBug> # endif # if TIMER_1_EN case TIMER_1 : switch ( channel ) { case 0 : TIMER_1_DEV . INTFLAG . reg |= TC_INTFLAG_MC0 ; TIMER_1_DEV . CC [ 0 ] . reg = value ; TIMER_1_DEV . INTENSET . bit . MC0 = 1 ; break ; case 1 : TIMER_1_DEV . INTFLAG . reg |= TC_INTFLAG_MC1 ; TIMER_1_DEV . CC [ 1 ] . reg = value ; TIMER_1_DEV . INTENSET . bit . MC1 = 1 ; break ; <S2SV_StartBug> } <S2SV_EndBug> # endif case TIMER_UNDEFINED : default : return - 1 ; } return 1 ; } | <S2SV_ModStart> ; break ; default : return - 1 ; } break ; <S2SV_ModEnd> # endif # <S2SV_ModStart> ; break ; default : return - 1 ; } break ; <S2SV_ModEnd> # endif case |
3,741 | CWE-000 static void show_pinnedobj_count ( ) { page_index_t page ; int nbytes = 0 ; int n_pinned_largeobj = 0 ; for ( page = 0 ; page < last_free_page ; ++ page ) { <S2SV_StartBug> if ( page_table [ page ] . gen == from_space && page_table [ page ] . dont_move ) { <S2SV_EndBug> nbytes += page_bytes_used ( page ) ; if ( page_starts_contiguous_block_p ( page ) ) ++ n_pinned_largeobj ; } } fprintf ( stderr , "/pinned<S2SV_blank>objects(g%d):<S2SV_blank>large=%d<S2SV_blank>(%d<S2SV_blank>bytes),<S2SV_blank>small=%d\\n" , from_space , n_pinned_largeobj , nbytes , pinned_objects . count ) ; } | <S2SV_ModStart> ] . dont_move && page_table [ page ] . large_object |
3,742 | CWE-000 struct nvm_bbt * nvm_bbt_alloc_cp ( const struct nvm_bbt * bbt ) { struct nvm_bbt * new ; <S2SV_StartBug> if ( ( ! bbt ) || ( ! bbt -> blks ) ) { <S2SV_EndBug> NVM_DEBUG ( "FAILED:<S2SV_blank>given<S2SV_blank>bbt<S2SV_blank>is<S2SV_blank>invalid" ) ; errno = EINVAL ; return NULL ; } new = malloc ( sizeof ( * new ) + sizeof ( * ( new -> blks ) ) * bbt -> nblks ) ; if ( ! new ) { <S2SV_StartBug> NVM_DEBUG ( "FAILED:<S2SV_blank>malloc<S2SV_blank>\'new\'" ) ; <S2SV_EndBug> errno = ENOMEM ; return NULL ; } memcpy ( new , bbt , sizeof ( * new ) + sizeof ( * ( new -> blks ) ) * bbt -> nblks ) ; return new ; } | <S2SV_ModStart> ; if ( <S2SV_ModEnd> ! bbt ) <S2SV_ModStart> ! bbt ) { NVM_ERR <S2SV_ModEnd> ( "FAILED:<S2SV_blank>given<S2SV_blank>bbt<S2SV_blank>is<S2SV_blank>invalid" ) <S2SV_ModStart> new ) { NVM_ERR <S2SV_ModEnd> ( "FAILED:<S2SV_blank>malloc<S2SV_blank>\'new\'" ) |
3,743 | CWE-000 void collect_flight_data ( ) { float engtb [ 4 ] ; int iw = g_end ; lastVS = XPLMGetDataf ( vertSpeedRef ) ; lastG = XPLMGetDataf ( gForceRef ) ; lastPitch = XPLMGetDataf ( pitchRef ) ; lastAir = check_ground ( XPLMGetDataf ( gearFRef ) ) ; lastElev = XPLMGetDataf ( elevatorRef ) ; lastAgl = XPLMGetDataf ( aglRef ) ; lastTm = XPLMGetDataf ( tmRef ) ; <S2SV_StartBug> XPLMGetDatavf ( engRef , engtb , 0 , 4 ) ; <S2SV_EndBug> lastEng = engtb [ 0 ] ; touchdown_vs_table [ iw ] = lastVS ; touchdown_g_table [ iw ] = lastG ; touchdown_pch_table [ iw ] = lastPitch ; touchdown_air_table [ iw ] = lastAir ; touchdown_elev_table [ iw ] = lastElev ; touchdown_eng_table [ iw ] = lastEng ; touchdown_agl_table [ iw ] = lastAgl ; touchdown_tm_table [ iw ] = lastTm ; BUFFER_INSERT_BACK ( ) ; } | <S2SV_ModStart> , 0 , 3 <S2SV_ModEnd> ) ; lastEng |
3,744 | CWE-000 static void cmd_scan_filter_rssi ( int argc , char * argv [ ] ) { if ( argc < 2 || ! strlen ( argv [ 1 ] ) ) { if ( filter . rssi != DISTANCE_VAL_INVALID ) bt_shell_printf ( "RSSI:<S2SV_blank>%d\\n" , filter . rssi ) ; <S2SV_StartBug> return ; <S2SV_EndBug> } filter . pathloss = DISTANCE_VAL_INVALID ; filter . rssi = atoi ( argv [ 1 ] ) ; filter . set = false ; } | <S2SV_ModStart> ) ; return bt_shell_noninteractive_quit ( EXIT_SUCCESS ) |
3,745 | CWE-000 int main ( int argc , const char * argv [ ] ) { int ret ; int kerr ; int opt ; int debug_fd = - 1 ; poptContext pc ; TALLOC_CTX * main_ctx = NULL ; uint8_t * buf = NULL ; ssize_t len = 0 ; const char * ccname = NULL ; <S2SV_StartBug> time_t expire_time = 0 ; <S2SV_EndBug> struct input_buffer * ibuf = NULL ; struct response * resp = NULL ; ssize_t written ; struct poptOption long_options [ ] = { POPT_AUTOHELP { "debug-level" , 'd' , POPT_ARG_INT , & debug_level , 0 , _ ( "Debug<S2SV_blank>level" ) , NULL } , { "debug-timestamps" , 0 , POPT_ARG_INT , & debug_timestamps , 0 , _ ( "Add<S2SV_blank>debug<S2SV_blank>timestamps" ) , NULL } , { "debug-microseconds" , 0 , POPT_ARG_INT , & debug_microseconds , 0 , _ ( "Show<S2SV_blank>timestamps<S2SV_blank>with<S2SV_blank>microseconds" ) , NULL } , { "debug-fd" , 0 , POPT_ARG_INT , & debug_fd , 0 , _ ( "An<S2SV_blank>open<S2SV_blank>file<S2SV_blank>descriptor<S2SV_blank>for<S2SV_blank>the<S2SV_blank>debug<S2SV_blank>logs" ) , NULL } , { "debug-to-stderr" , 0 , POPT_ARG_NONE | POPT_ARGFLAG_DOC_HIDDEN , & debug_to_stderr , 0 , _ ( "Send<S2SV_blank>the<S2SV_blank>debug<S2SV_blank>output<S2SV_blank>to<S2SV_blank>stderr<S2SV_blank>directly." ) , NULL } , POPT_TABLEEND } ; debug_level = SSSDBG_INVALID ; pc = poptGetContext ( argv [ 0 ] , argc , argv , long_options , 0 ) ; while ( ( opt = poptGetNextOpt ( pc ) ) != - 1 ) { switch ( opt ) { default : fprintf ( stderr , "\\nInvalid<S2SV_blank>option<S2SV_blank>%s:<S2SV_blank>%s\\n\\n" , poptBadOption ( pc , 0 ) , poptStrerror ( opt ) ) ; poptPrintUsage ( pc , stderr , 0 ) ; _exit ( - 1 ) ; } } poptFreeContext ( pc ) ; DEBUG_INIT ( debug_level ) ; debug_prg_name = talloc_asprintf ( NULL , "[sssd[ldap_child[%d]]]" , getpid ( ) ) ; if ( ! debug_prg_name ) { debug_prg_name = "[sssd[ldap_child]]" ; DEBUG ( SSSDBG_CRIT_FAILURE , "talloc_asprintf<S2SV_blank>failed.\\n" ) ; goto fail ; } if ( debug_fd != - 1 ) { ret = set_debug_file_from_fd ( debug_fd ) ; if ( ret != EOK ) { DEBUG ( SSSDBG_CRIT_FAILURE , "set_debug_file_from_fd<S2SV_blank>failed.\\n" ) ; } } BlockSignals ( false , SIGTERM ) ; CatchSignal ( SIGTERM , sig_term_handler ) ; DEBUG ( SSSDBG_TRACE_FUNC , "ldap_child<S2SV_blank>started.\\n" ) ; main_ctx = talloc_new ( NULL ) ; if ( main_ctx == NULL ) { DEBUG ( SSSDBG_CRIT_FAILURE , "talloc_new<S2SV_blank>failed.\\n" ) ; talloc_free ( discard_const ( debug_prg_name ) ) ; goto fail ; } talloc_steal ( main_ctx , debug_prg_name ) ; buf = talloc_size ( main_ctx , sizeof ( uint8_t ) * IN_BUF_SIZE ) ; if ( buf == NULL ) { DEBUG ( SSSDBG_CRIT_FAILURE , "talloc_size<S2SV_blank>failed.\\n" ) ; goto fail ; } ibuf = talloc_zero ( main_ctx , struct input_buffer ) ; if ( ibuf == NULL ) { DEBUG ( SSSDBG_CRIT_FAILURE , "talloc_size<S2SV_blank>failed.\\n" ) ; goto fail ; } DEBUG ( SSSDBG_TRACE_INTERNAL , "context<S2SV_blank>initialized\\n" ) ; errno = 0 ; len = sss_atomic_read_s ( STDIN_FILENO , buf , IN_BUF_SIZE ) ; if ( len == - 1 ) { ret = errno ; DEBUG ( SSSDBG_CRIT_FAILURE , "read<S2SV_blank>failed<S2SV_blank>[%d][%s].\\n" , ret , strerror ( ret ) ) ; goto fail ; } close ( STDIN_FILENO ) ; ret = unpack_buffer ( buf , len , ibuf ) ; if ( ret != EOK ) { DEBUG ( SSSDBG_CRIT_FAILURE , "unpack_buffer<S2SV_blank>failed.[%d][%s].\\n" , ret , strerror ( ret ) ) ; goto fail ; } kerr = privileged_krb5_setup ( ibuf ) ; if ( kerr != EOK ) { DEBUG ( SSSDBG_CRIT_FAILURE , "Privileged<S2SV_blank>Krb5<S2SV_blank>setup<S2SV_blank>failed.\\n" ) ; goto fail ; } DEBUG ( SSSDBG_TRACE_INTERNAL , "Kerberos<S2SV_blank>context<S2SV_blank>initialized\\n" ) ; kerr = become_user ( ibuf -> uid , ibuf -> gid ) ; if ( kerr != 0 ) { DEBUG ( SSSDBG_CRIT_FAILURE , "become_user<S2SV_blank>failed.\\n" ) ; goto fail ; } DEBUG ( SSSDBG_TRACE_INTERNAL , "Running<S2SV_blank>as<S2SV_blank>[%" SPRIuid "][%" SPRIgid "].\\n" , geteuid ( ) , getegid ( ) ) ; DEBUG ( SSSDBG_TRACE_INTERNAL , "getting<S2SV_blank>TGT<S2SV_blank>sync\\n" ) ; kerr = ldap_child_get_tgt_sync ( main_ctx , ibuf -> context , ibuf -> realm_str , ibuf -> princ_str , ibuf -> keytab_name , ibuf -> lifetime , <S2SV_StartBug> & ccname , & expire_time ) ; <S2SV_EndBug> if ( kerr != EOK ) { DEBUG ( SSSDBG_CRIT_FAILURE , "ldap_child_get_tgt_sync<S2SV_blank>failed.\\n" ) ; } <S2SV_StartBug> ret = prepare_response ( main_ctx , ccname , expire_time , kerr , & resp ) ; <S2SV_EndBug> if ( ret != EOK ) { DEBUG ( SSSDBG_CRIT_FAILURE , "prepare_response<S2SV_blank>failed.<S2SV_blank>[%d][%s].\\n" , ret , strerror ( ret ) ) ; goto fail ; } errno = 0 ; written = sss_atomic_write_s ( STDOUT_FILENO , resp -> buf , resp -> size ) ; if ( written == - 1 ) { ret = errno ; DEBUG ( SSSDBG_CRIT_FAILURE , "write<S2SV_blank>failed<S2SV_blank>[%d][%s].\\n" , ret , strerror ( ret ) ) ; goto fail ; } if ( written != resp -> size ) { DEBUG ( SSSDBG_CRIT_FAILURE , "Expected<S2SV_blank>to<S2SV_blank>write<S2SV_blank>%zu<S2SV_blank>bytes,<S2SV_blank>wrote<S2SV_blank>%zu\\n" , resp -> size , written ) ; goto fail ; } DEBUG ( SSSDBG_TRACE_FUNC , "ldap_child<S2SV_blank>completed<S2SV_blank>successfully\\n" ) ; close ( STDOUT_FILENO ) ; talloc_free ( main_ctx ) ; _exit ( 0 ) ; fail : DEBUG ( SSSDBG_CRIT_FAILURE , "ldap_child<S2SV_blank>failed!\\n" ) ; close ( STDOUT_FILENO ) ; talloc_free ( main_ctx ) ; _exit ( - 1 ) ; } | <S2SV_ModStart> = NULL ; char * krb5_msg = NULL ; <S2SV_ModStart> , & expire_time , & krb5_msg <S2SV_ModStart> , kerr , krb5_msg , |
3,746 | CWE-000 int rmdir ( ) { MINODE * mip , * pip ; INODE * ip ; char buf [ BLKSIZE ] ; int empty = 1 ; int ino = getino ( dev , pathname ) ; if ( ino == 0 ) { printf ( "Path<S2SV_blank>not<S2SV_blank>found<S2SV_blank>can\'t<S2SV_blank>remove\\n" ) ; return - 1 ; } mip = iget ( dev , ino ) ; char myname [ 256 ] ; ip = & ( mip -> INODE ) ; printf ( "%d<S2SV_blank>%d\\n" , ip -> i_uid , running -> uid ) ; if ( ip -> i_uid == running -> uid || running -> uid == 0 ) { printf ( "User<S2SV_blank>can<S2SV_blank>rmdir\\n" ) ; <S2SV_StartBug> if ( ip -> i_mode != 0x41ED || mip -> refCount > 0 || ip -> i_links_count >= 2 ) { <S2SV_EndBug> printf ( "Might<S2SV_blank>be<S2SV_blank>empty<S2SV_blank>%d<S2SV_blank>%d\\n" , ip -> i_links_count , mip -> dirty ) ; if ( ip -> i_links_count == 2 && ip -> i_mode == 0x41ED ) { printf ( "Checking<S2SV_blank>if<S2SV_blank>truly<S2SV_blank>empty\\n" ) ; char * cp ; get_block ( mip -> dev , ip -> i_block [ 0 ] , buf ) ; cp = buf ; cp += 12 ; dp = ( DIR * ) cp ; if ( dp -> rec_len > 12 ) { empty = 1 ; } else { empty = 0 ; } } if ( ! empty ) { return - 1 ; <S2SV_StartBug> } <S2SV_EndBug> } pip = iget ( mip -> dev , dp -> inode ) ; getmyname ( pip , mip -> ino , myname ) ; int i = 0 ; for ( i = 0 ; i < 12 ; i ++ ) { if ( ip -> i_block [ i ] != 0 ) { printf ( "Deallocating<S2SV_blank>block<S2SV_blank>%d\\n" , i ) ; bdealloc ( mip -> dev , ip -> i_block [ i ] ) ; } } printf ( "Deallocate<S2SV_blank>inode\\n" ) ; idealloc ( mip -> dev , mip -> ino ) ; mip -> dirty = 1 ; iput ( mip ) ; printf ( "Removing<S2SV_blank>%s<S2SV_blank>from<S2SV_blank>parent\'s<S2SV_blank>list\\n" , myname ) ; rm_child ( pip , myname ) ; pip -> dirty = 1 ; pip -> INODE . i_links_count -- ; pip -> INODE . i_atime = pip -> INODE . i_mtime = time ( 0L ) ; iput ( pip ) ; } } | <S2SV_ModStart> ip -> i_mode == 0x41ED ) { if ( <S2SV_ModEnd> mip -> refCount <S2SV_ModStart> 1 ; } } } else { printf ( "Path<S2SV_blank>not<S2SV_blank>a<S2SV_blank>DIR<S2SV_blank>type\\n" ) ; return - 1 ; |
3,747 | CWE-000 static int ceu_try_fmt ( struct ceu_device * ceudev , struct v4l2_format * v4l2_fmt ) { struct ceu_subdev * ceu_sd = ceudev -> sd ; struct v4l2_pix_format_mplane * pix = & v4l2_fmt -> fmt . pix_mp ; struct v4l2_subdev * v4l2_sd = ceu_sd -> v4l2_sd ; struct v4l2_subdev_pad_config pad_cfg ; const struct ceu_fmt * ceu_fmt ; int ret ; struct v4l2_subdev_format sd_format = { . which = V4L2_SUBDEV_FORMAT_TRY , <S2SV_StartBug> } ; <S2SV_EndBug> switch ( pix -> pixelformat ) { case V4L2_PIX_FMT_YUYV : case V4L2_PIX_FMT_NV16 : case V4L2_PIX_FMT_NV61 : case V4L2_PIX_FMT_NV12 : case V4L2_PIX_FMT_NV21 : break ; default : pix -> pixelformat = V4L2_PIX_FMT_NV16 ; break ; } ceu_fmt = get_ceu_fmt_from_fourcc ( pix -> pixelformat ) ; v4l_bound_align_image ( & pix -> width , 2 , CEU_MAX_WIDTH , 4 , & pix -> height , 4 , CEU_MAX_HEIGHT , 4 , 0 ) ; v4l2_fill_mbus_format_mplane ( & sd_format . format , pix ) ; ret = v4l2_subdev_call ( v4l2_sd , pad , set_fmt , & pad_cfg , & sd_format ) ; if ( ret ) return ret ; v4l2_fill_pix_format_mplane ( pix , & sd_format . format ) ; ceu_calc_plane_sizes ( ceudev , ceu_fmt , pix ) ; return 0 ; } | <S2SV_ModStart> = V4L2_SUBDEV_FORMAT_TRY , . format = { . code = ceu_sd -> mbus_fmt . mbus_code , } , |
3,748 | CWE-000 double main ( ) { char initChar ; char * init ; init = & initChar ; FILE * file ; file = fopen ( "/home/foesa/C-Programs/input.txt" , "r" ) ; initChar = fgetc ( file ) ; struct nodePointer * list = newnodePointer ( ) ; struct nodePointer * opList = newnodePointer ( ) ; struct nodePointer * rpnList = newnodePointer ( ) ; struct nodePointer * rpnOpList = newnodePointer ( ) ; bool isPostfix = false ; bool isbigNum = false ; int numOfRun = - 1 ; if ( * init == 'p' ) { while ( * init != '<S2SV_blank>' ) { * init = fgetc ( file ) ; } isPostfix = false ; } else if ( * init == 'i' ) { while ( * init != '<S2SV_blank>' ) { * init = fgetc ( file ) ; } isPostfix = true ; } * init = fgetc ( file ) ; while ( * init != '\\n' && * init != EOF ) { if ( isdigit ( * init ) == 0 ) { isbigNum = true ; numOfRun = - 1 ; } else { isbigNum = false ; numOfRun ++ ; } if ( * init != '<S2SV_blank>' ) { if ( ! isPostfix ) { postfix ( list , opList , init , isbigNum , numOfRun , isPostfix ) ; } else { double passer = * init ; infix ( rpnList , passer , rpnOpList , isbigNum , numOfRun ) ; } } * init = fgetc ( file ) ; <S2SV_StartBug> if ( isPostfix && ( * init == '\\n' || * init == EOF ) ) { <S2SV_EndBug> while ( rpnList -> head != NULL ) { char charpass = pop ( rpnList ) ; char * pass = & charpass ; postfix ( list , opList , pass , false , 0 , isPostfix ) ; } } } printf ( "The<S2SV_blank>answer<S2SV_blank>is:<S2SV_blank>%f" , ( list -> head ) -> data ) ; } | <S2SV_ModStart> ) ) { clearOplist ( rpnOpList , rpnList ) ; |
3,749 | CWE-000 int xfs_set_acl ( struct inode * inode , struct posix_acl * acl , int type ) { int error = 0 ; if ( ! acl ) goto set_acl ; error = - E2BIG ; if ( acl -> a_count > XFS_ACL_MAX_ENTRIES ( XFS_M ( inode -> i_sb ) ) ) return error ; if ( type == ACL_TYPE_ACCESS ) { <S2SV_StartBug> umode_t mode = inode -> i_mode ; <S2SV_EndBug> <S2SV_StartBug> error = posix_acl_equiv_mode ( acl , & mode ) ; <S2SV_EndBug> <S2SV_StartBug> if ( error <= 0 ) { <S2SV_EndBug> acl = NULL ; if ( error < 0 ) return error ; <S2SV_StartBug> } <S2SV_EndBug> error = xfs_set_mode ( inode , mode ) ; if ( error ) return error ; } set_acl : return __xfs_set_acl ( inode , type , acl ) ; } | <S2SV_ModStart> { umode_t mode ; struct posix_acl * old_acl = acl <S2SV_ModEnd> ; error = <S2SV_ModStart> ; error = posix_acl_update_mode ( inode <S2SV_ModEnd> , & mode <S2SV_ModStart> , & mode , & acl ) ; if ( ! acl ) posix_acl_release ( old_acl <S2SV_ModStart> if ( error <S2SV_ModEnd> ) return error <S2SV_ModStart> return error ; <S2SV_ModEnd> error = xfs_set_mode |
3,750 | CWE-000 KA_CTX * KA_CTX_new ( void ) { <S2SV_StartBug> KA_CTX * out = OPENSSL_malloc ( sizeof ( KA_CTX ) ) ; <S2SV_EndBug> if ( ! out ) goto err ; out -> key = EVP_PKEY_new ( ) ; if ( ! out -> key ) <S2SV_StartBug> goto err ; <S2SV_EndBug> out -> md = NULL ; out -> md_engine = NULL ; out -> cmac_ctx = NULL ; out -> cipher = NULL ; out -> cipher_engine = NULL ; out -> iv = NULL ; out -> generate_key = NULL ; out -> compute_key = NULL ; out -> mac_keylen = 0 ; out -> enc_keylen = 0 ; out -> shared_secret = NULL ; out -> k_enc = NULL ; out -> k_mac = NULL ; return out ; err : if ( out ) { if ( out -> key ) EVP_PKEY_free ( out -> key ) ; OPENSSL_free ( out ) ; } return NULL ; } | <S2SV_ModStart> * out = OPENSSL_zalloc <S2SV_ModEnd> ( sizeof ( <S2SV_ModStart> ) goto err <S2SV_ModEnd> ; return out |
3,751 | CWE-000 int s5p_mfc_release_firmware ( struct s5p_mfc_dev * dev ) { s5p_mfc_release_priv_buf ( dev , & dev -> fw_buf ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> fw_buf ) ; dev -> fw_get_done = false ; |
3,752 | CWE-000 static int dummy_hcd_probe ( struct platform_device * pdev ) { struct dummy * dum ; struct usb_hcd * hs_hcd ; struct usb_hcd * ss_hcd ; int retval ; dev_info ( & pdev -> dev , "%s,<S2SV_blank>driver<S2SV_blank>" DRIVER_VERSION "\\n" , driver_desc ) ; dum = * ( ( void * * ) dev_get_platdata ( & pdev -> dev ) ) ; <S2SV_StartBug> if ( ! mod_data . is_super_speed ) <S2SV_EndBug> <S2SV_StartBug> dummy_hcd . flags = HCD_USB2 ; <S2SV_EndBug> hs_hcd = usb_create_hcd ( & dummy_hcd , & pdev -> dev , dev_name ( & pdev -> dev ) ) ; if ( ! hs_hcd ) return - ENOMEM ; hs_hcd -> has_tt = 1 ; retval = usb_add_hcd ( hs_hcd , 0 , 0 ) ; if ( retval ) goto put_usb2_hcd ; if ( mod_data . is_super_speed ) { ss_hcd = usb_create_shared_hcd ( & dummy_hcd , & pdev -> dev , dev_name ( & pdev -> dev ) , hs_hcd ) ; if ( ! ss_hcd ) { retval = - ENOMEM ; goto dealloc_usb2_hcd ; } retval = usb_add_hcd ( ss_hcd , 0 , 0 ) ; if ( retval ) goto put_usb3_hcd ; } return 0 ; put_usb3_hcd : usb_put_hcd ( ss_hcd ) ; dealloc_usb2_hcd : usb_remove_hcd ( hs_hcd ) ; put_usb2_hcd : usb_put_hcd ( hs_hcd ) ; dum -> hs_hcd = dum -> ss_hcd = NULL ; return retval ; } | <S2SV_ModStart> ; if ( <S2SV_ModEnd> mod_data . is_super_speed <S2SV_ModStart> . flags = HCD_USB3 | HCD_SHARED ; else if ( mod_data . is_high_speed ) dummy_hcd . flags = HCD_USB2 ; else dummy_hcd . flags = HCD_USB11 <S2SV_ModEnd> ; hs_hcd = |
3,753 | CWE-000 static ngx_int_t ngx_epoll_process_events ( ngx_cycle_t * cycle , ngx_msec_t timer , ngx_uint_t flags ) { int events ; uint32_t revents ; ngx_int_t instance , i ; ngx_uint_t level ; ngx_err_t err ; ngx_event_t * rev , * wev ; ngx_queue_t * queue ; ngx_connection_t * c ; ngx_log_debug1 ( NGX_LOG_DEBUG_EVENT , cycle -> log , 0 , "epoll<S2SV_blank>timer:<S2SV_blank>%M" , timer ) ; events = epoll_wait ( ep , event_list , ( int ) nevents , timer ) ; err = ( events == - 1 ) ? ngx_errno : 0 ; if ( flags & NGX_UPDATE_TIME || ngx_event_timer_alarm ) { ngx_time_update ( ) ; } if ( err ) { if ( err == NGX_EINTR ) { if ( ngx_event_timer_alarm ) { ngx_event_timer_alarm = 0 ; return NGX_OK ; } level = NGX_LOG_INFO ; } else { level = NGX_LOG_ALERT ; } ngx_log_error ( level , cycle -> log , err , "epoll_wait()<S2SV_blank>failed" ) ; return NGX_ERROR ; } if ( events == 0 ) { if ( timer != NGX_TIMER_INFINITE ) { return NGX_OK ; } ngx_log_error ( NGX_LOG_ALERT , cycle -> log , 0 , "epoll_wait()<S2SV_blank>returned<S2SV_blank>no<S2SV_blank>events<S2SV_blank>without<S2SV_blank>timeout" ) ; return NGX_ERROR ; } for ( i = 0 ; i < events ; i ++ ) { c = event_list [ i ] . data . ptr ; instance = ( uintptr_t ) c & 1 ; c = ( ngx_connection_t * ) ( ( uintptr_t ) c & ( uintptr_t ) ~ 1 ) ; rev = c -> read ; if ( c -> fd == - 1 || rev -> instance != instance ) { ngx_log_debug1 ( NGX_LOG_DEBUG_EVENT , cycle -> log , 0 , "epoll:<S2SV_blank>stale<S2SV_blank>event<S2SV_blank>%p" , c ) ; continue ; } revents = event_list [ i ] . events ; ngx_log_debug3 ( NGX_LOG_DEBUG_EVENT , cycle -> log , 0 , "epoll:<S2SV_blank>fd:%d<S2SV_blank>ev:%04XD<S2SV_blank>d:%p" , c -> fd , revents , event_list [ i ] . data . ptr ) ; if ( revents & ( EPOLLERR | EPOLLHUP ) ) { ngx_log_debug2 ( NGX_LOG_DEBUG_EVENT , cycle -> log , 0 , "epoll_wait()<S2SV_blank>error<S2SV_blank>on<S2SV_blank>fd:%d<S2SV_blank>ev:%04XD" , c -> fd , revents ) ; <S2SV_StartBug> } <S2SV_EndBug> # if 0 if ( revents & ~ ( EPOLLIN | EPOLLOUT | EPOLLERR | EPOLLHUP ) ) { ngx_log_error ( NGX_LOG_ALERT , cycle -> log , 0 , "strange<S2SV_blank>epoll_wait()<S2SV_blank>events<S2SV_blank>fd:%d<S2SV_blank>ev:%04XD" , c -> fd , revents ) ; } # endif <S2SV_StartBug> if ( ( revents & ( EPOLLERR | EPOLLHUP ) ) <S2SV_EndBug> && ( revents & ( EPOLLIN | EPOLLOUT ) ) == 0 ) { revents |= EPOLLIN | EPOLLOUT ; } if ( ( revents & EPOLLIN ) && rev -> active ) { # if ( NGX_HAVE_EPOLLRDHUP ) if ( revents & EPOLLRDHUP ) { rev -> pending_eof = 1 ; } rev -> available = 1 ; # endif rev -> ready = 1 ; if ( flags & NGX_POST_EVENTS ) { queue = rev -> accept ? & ngx_posted_accept_events : & ngx_posted_events ; ngx_post_event ( rev , queue ) ; } else { rev -> handler ( rev ) ; } } wev = c -> write ; if ( ( revents & EPOLLOUT ) && wev -> active ) { if ( c -> fd == - 1 || wev -> instance != instance ) { ngx_log_debug1 ( NGX_LOG_DEBUG_EVENT , cycle -> log , 0 , "epoll:<S2SV_blank>stale<S2SV_blank>event<S2SV_blank>%p" , c ) ; continue ; } wev -> ready = 1 ; # if ( NGX_THREADS ) wev -> complete = 1 ; # endif if ( flags & NGX_POST_EVENTS ) { ngx_post_event ( wev , & ngx_posted_events ) ; } else { wev -> handler ( wev ) ; } } } return NGX_OK ; } | <S2SV_ModStart> revents ) ; revents |= EPOLLIN | EPOLLOUT ; <S2SV_ModStart> ( revents & <S2SV_ModEnd> EPOLLIN ) && |
3,754 | CWE-000 static void getDirContent ( void ) { <S2SV_StartBug> DIR * dirp = opendir ( path ) ; <S2SV_EndBug> char * filePath ; struct dirent * entry ; size_t i , imax = 0 , size = 0 ; unsigned int tmpmax = 0 ; struct stat fileStat ; for ( i = 0 ; ( entry = readdir ( dirp ) ) ; i ++ ) { if ( isVisible ( entry -> d_name ) ) { if ( i + 1 >= size / sizeof * items ) if ( ! ( items = realloc ( items , ( size += BUFSIZ ) ) ) ) die ( "cannot<S2SV_blank>realloc<S2SV_blank>%u<S2SV_blank>bytes:" , size ) ; if ( ! ( items [ i ] . text = strdup ( entry -> d_name ) ) ) die ( "cannot<S2SV_blank>strdup<S2SV_blank>%u<S2SV_blank>bytes:" , strlen ( entry -> d_name ) + 1 ) ; filePath = malloc ( strlen ( path ) + strlen ( entry -> d_name ) + 2 ) ; strcpy ( filePath , path ) ; strcat ( filePath , "/" ) ; strcat ( filePath , entry -> d_name ) ; stat ( filePath , & fileStat ) ; items [ i ] . dir = S_ISDIR ( fileStat . st_mode ) ; free ( filePath ) ; items [ i ] . out = 0 ; drw_font_getexts ( drw -> fonts , entry -> d_name , strlen ( entry -> d_name ) , & tmpmax , NULL ) ; if ( tmpmax > inputw ) { inputw = tmpmax ; imax = i ; } } else { i -- ; } } if ( items ) items [ i ] . text = NULL ; inputw = items ? TEXTW ( items [ imax ] . text ) : 0 ; lines = MIN ( lines , i ) ; closedir ( dirp ) ; } | <S2SV_ModStart> = opendir ( path ) ; if ( ! dirp ) die ( "Error<S2SV_blank>reading<S2SV_blank>directory<S2SV_blank>content:<S2SV_blank>%s" , |
3,755 | CWE-000 static void msm_isp_process_overflow_irq ( struct vfe_device * vfe_dev , uint32_t * irq_status0 , uint32_t * irq_status1 ) { uint32_t overflow_mask ; if ( ! vfe_dev -> axi_data . num_active_stream ) return ; if ( atomic_read ( & vfe_dev -> error_info . overflow_state ) != NO_OVERFLOW ) { uint32_t halt_restart_mask0 , halt_restart_mask1 ; vfe_dev -> hw_info -> vfe_ops . core_ops . get_halt_restart_mask ( & halt_restart_mask0 , & halt_restart_mask1 ) ; * irq_status0 &= halt_restart_mask0 ; * irq_status1 &= halt_restart_mask1 ; return ; } vfe_dev -> hw_info -> vfe_ops . core_ops . get_overflow_mask ( & overflow_mask ) ; overflow_mask &= * irq_status1 ; if ( overflow_mask ) { struct msm_isp_event_data error_event ; struct msm_vfe_axi_halt_cmd halt_cmd ; if ( vfe_dev -> reset_pending == 1 ) { pr_err ( "%s:%d<S2SV_blank>failed:<S2SV_blank>overflow<S2SV_blank>%x<S2SV_blank>during<S2SV_blank>reset\\n" , __func__ , __LINE__ , overflow_mask ) ; * irq_status1 &= ~ overflow_mask ; return ; } halt_cmd . overflow_detected = 1 ; halt_cmd . stop_camif = 1 ; halt_cmd . blocking_halt = 0 ; msm_isp_axi_halt ( vfe_dev , & halt_cmd ) ; * irq_status0 = 0 ; * irq_status1 = 0 ; if ( atomic_read ( & vfe_dev -> error_info . overflow_state ) <S2SV_StartBug> != HALT_ENFORCED ) { <S2SV_EndBug> error_event . frame_id = vfe_dev -> axi_data . src_info [ VFE_PIX_0 ] . frame_id ; error_event . u . error_info . err_type = ISP_ERROR_BUS_OVERFLOW ; msm_isp_send_event ( vfe_dev , ISP_EVENT_ERROR , & error_event ) ; } } } | <S2SV_ModStart> HALT_ENFORCED ) { memset ( & error_event , 0 , sizeof ( error_event ) ) ; |
3,756 | CWE-000 static void * lgdst_rx ( void * arg ) { while ( 1 != do_exit_m ) { char cmdline [ 160 ] , * pl = cmdline ; size_t len = sizeof ( cmdline ) ; if ( - 1 != getline ( & pl , & len , stdin ) ) { char * argv [ 20 + 1 ] ; int argc = 0 ; do { <S2SV_StartBug> argv [ argc ++ ] = strtok ( pl , "<S2SV_blank>" ) ; <S2SV_EndBug> pl = NULL ; } while ( 20 >= argc && argv [ argc - 1 ] ) ; if ( 1 == argc ) { puts ( "empty<S2SV_blank>command<S2SV_blank>line<S2SV_blank>received..." ) ; continue ; } if ( 20 < argc ) { puts ( "too<S2SV_blank>many<S2SV_blank>fields<S2SV_blank>in<S2SV_blank>command<S2SV_blank>line..." ) ; continue ; } if ( ! strcmp ( argv [ 0 ] , "lgdstv" ) ) { strcpy ( argv [ 0 ] , "lgdst" ) ; lgdst_access_rx_vid ( argc - 1 , argv , NULL ) ; } else if ( ! strcmp ( argv [ 0 ] , "lgdstc" ) ) { strcpy ( argv [ 0 ] , "lgdst" ) ; lgdst_access_rx_ctl ( argc - 1 , argv , NULL ) ; } else puts ( "invalid<S2SV_blank>lgdst<S2SV_blank>command,<S2SV_blank>only<S2SV_blank>lgdstv<S2SV_blank>or<S2SV_blank>lgdstc" ) ; } } return ; } | <S2SV_ModStart> ( pl , "<S2SV_blank>\\n" <S2SV_ModEnd> ) ; pl |
3,757 | CWE-000 static int luci_rename ( struct inode * old_dir , struct dentry * old_dentry , <S2SV_StartBug> # if LINUX_VERSION_CODE >= KERNEL_VERSION ( 4 , 11 , 8 ) <S2SV_EndBug> struct inode * new_dir , struct dentry * new_dentry , unsigned int flags ) # else struct inode * new_dir , struct dentry * new_dentry ) <S2SV_StartBug> # endif <S2SV_EndBug> { luci_dbg_inode ( old_dir , "renaming" ) ; return 0 ; } | <S2SV_ModStart> * old_dentry , <S2SV_ModEnd> struct inode * <S2SV_ModStart> * new_dentry ) <S2SV_ModEnd> { luci_dbg_inode ( |
3,758 | CWE-000 void log_gps ( file * f , gps_data * gps ) { uint8_t data [ PACKET_LENGTH_GPS + 1 ] ; data [ 0 ] = PACKET_TYPE_GPS ; uint32_t time = ( int32_t ) ( gps -> time * 1000 ) ; uint32_t lat = ( int32_t ) ( gps -> latitude * 1000 ) ; uint32_t lon = ( int32_t ) ( gps -> longitude * 1000 ) ; uint32_t fix = ( int32_t ) ( gps -> fix_quality * 1000 ) ; uint32_t hdop = ( int32_t ) ( gps -> hdop * 1000 ) ; uint32_t alt = ( int32_t ) ( gps -> altitude * 1000 ) ; uint8_t numsats = ( uint8_t ) ( gps -> sats_tracked ) ; data [ 1 ] = time >> 24 ; data [ 2 ] = time >> 16 ; data [ 3 ] = time >> 8 ; data [ 4 ] = time ; data [ 5 ] = lat >> 24 ; data [ 6 ] = lat >> 16 ; data [ 7 ] = lat >> 8 ; data [ 8 ] = lat ; data [ 9 ] = lon >> 24 ; data [ 10 ] = lon >> 16 ; data [ 11 ] = lon >> 8 ; data [ 12 ] = lon ; data [ 13 ] = fix >> 24 ; data [ 14 ] = fix >> 16 ; data [ 15 ] = fix >> 8 ; data [ 16 ] = fix ; data [ 17 ] = hdop >> 24 ; data [ 18 ] = hdop >> 16 ; data [ 19 ] = hdop >> 8 ; data [ 20 ] = hdop ; data [ 21 ] = alt >> 24 ; data [ 22 ] = alt >> 16 ; data [ 23 ] = alt >> 8 ; data [ 24 ] = alt ; data [ 25 ] = numsats ; log_to_flash ( f , data , sizeof ( data ) ) ; <S2SV_StartBug> == == == = <S2SV_EndBug> log_data ( f , data , sizeof ( data ) ) ; >> >> >> > master } | <S2SV_ModStart> ) ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
3,759 | CWE-000 static ssize_t mwl_debugfs_info_read ( struct file * file , char __user * ubuf , size_t count , loff_t * ppos ) { struct mwl_priv * priv = ( struct mwl_priv * ) file -> private_data ; unsigned long page = get_zeroed_page ( GFP_KERNEL ) ; char * p = ( char * ) page ; int len = 0 , size = PAGE_SIZE , i ; ssize_t ret ; if ( ! p ) return - ENOMEM ; len += scnprintf ( p + len , size - len , "\\n" ) ; len += scnprintf ( p + len , size - len , "driver<S2SV_blank>name:<S2SV_blank>%s\\n" , MWL_DRV_NAME ) ; len += scnprintf ( p + len , size - len , "chip<S2SV_blank>type:<S2SV_blank>%s\\n" , chipname [ priv -> chip_type ] ) ; len += scnprintf ( p + len , size - len , "hw<S2SV_blank>version:<S2SV_blank>%X\\n" , priv -> hw_data . hw_version ) ; len += scnprintf ( p + len , size - len , "driver<S2SV_blank>version:<S2SV_blank>%s\\n" , MWL_DRV_VERSION ) ; len += scnprintf ( p + len , size - len , "firmware<S2SV_blank>version:<S2SV_blank>0x%08x\\n" , priv -> hw_data . fw_release_num ) ; len += scnprintf ( p + len , size - len , "power<S2SV_blank>table<S2SV_blank>loaded<S2SV_blank>from<S2SV_blank>dts:<S2SV_blank>%s\\n" , priv -> forbidden_setting ? "no" : "yes" ) ; len += scnprintf ( p + len , size - len , "firmware<S2SV_blank>region<S2SV_blank>code:<S2SV_blank>0x%x\\n" , priv -> fw_region_code ) ; len += scnprintf ( p + len , size - len , "mac<S2SV_blank>address:<S2SV_blank>%pM\\n" , priv -> hw_data . mac_addr ) ; len += scnprintf ( p + len , size - len , "2g:<S2SV_blank>%s\\n" , priv -> disable_2g ? "disable" : "enable" ) ; len += scnprintf ( p + len , size - len , "5g:<S2SV_blank>%s\\n" , priv -> disable_5g ? "disable" : "enable" ) ; len += scnprintf ( p + len , size - len , "antenna:<S2SV_blank>%d<S2SV_blank>%d\\n" , priv -> ant_tx_num , priv -> ant_rx_num ) ; len += scnprintf ( p + len , size - len , "irq<S2SV_blank>number:<S2SV_blank>%d\\n" , priv -> irq ) ; if ( priv -> if_ops . dbg_info != NULL ) len += priv -> if_ops . dbg_info ( priv , p , size , len ) ; len += scnprintf ( p + len , size - len , "tx<S2SV_blank>limit:<S2SV_blank>%d\\n" , priv -> txq_limit ) ; len += scnprintf ( p + len , size - len , "rx<S2SV_blank>limit:<S2SV_blank>%d\\n" , priv -> recv_limit ) ; len += scnprintf ( p + len , size - len , "ap<S2SV_blank>macid<S2SV_blank>support:<S2SV_blank>%08x\\n" , priv -> ap_macids_supported ) ; len += scnprintf ( p + len , size - len , "sta<S2SV_blank>macid<S2SV_blank>support:<S2SV_blank>%08x\\n" , priv -> sta_macids_supported ) ; len += scnprintf ( p + len , size - len , "macid<S2SV_blank>used:<S2SV_blank>%08x\\n" , priv -> macids_used ) ; len += scnprintf ( p + len , size - len , "qe<S2SV_blank>trigger<S2SV_blank>number:<S2SV_blank>%d\\n" , priv -> qe_trigger_num ) ; len += scnprintf ( p + len , size - len , "radio:<S2SV_blank>%s\\n" , priv -> radio_on ? "enable" : "disable" ) ; len += scnprintf ( p + len , size - len , "OS<S2SV_blank>TxQ<S2SV_blank>status<S2SV_blank>=<S2SV_blank>[<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>]\\n" , ieee80211_queue_stopped ( priv -> hw , 0 ) , ieee80211_queue_stopped ( priv -> hw , 1 ) , ieee80211_queue_stopped ( priv -> hw , 2 ) , ieee80211_queue_stopped ( priv -> hw , 3 ) ) ; len += scnprintf ( p + len , size - len , "tx_mgmt_cnt=%lu,<S2SV_blank>tx_data_cnt=%lu\\n" , priv -> tx_mgmt_cnt , priv -> tx_data_cnt ) ; len += scnprintf ( p + len , size - len , "num_valid_interrupts<S2SV_blank>=<S2SV_blank>%lu\\n" , priv -> valid_interrupt_cnt ) ; if ( ( ( priv -> host_if == MWL_IF_PCIE ) && IS_PFU_ENABLED ( priv -> chip_type ) ) ) { struct mwl_pcie_card * card = priv -> intf ; len += scnprintf ( p + len , size - len , "PCIe<S2SV_blank>Tx<S2SV_blank>Rd/Wr<S2SV_blank>Ptr<S2SV_blank>(Sw)<S2SV_blank>=<S2SV_blank>(0x%x<S2SV_blank>/<S2SV_blank>0x%x)\\n" , priv -> txbd_rdptr , priv -> txbd_wrptr ) ; len += scnprintf ( p + len , size - len , "PCIe<S2SV_blank>Tx<S2SV_blank>Rd/Wr<S2SV_blank>Ptr<S2SV_blank>(Hw)<S2SV_blank>=<S2SV_blank>(0x%x<S2SV_blank>/<S2SV_blank>0x%x)\\n" , readl ( card -> iobase1 + REG_TXBD_RDPTR ) , readl ( card -> iobase1 + REG_TXBD_WRPTR ) ) ; len += scnprintf ( p + len , size - len , "PCIe<S2SV_blank>IntMask<S2SV_blank>=<S2SV_blank>0x%x\\n" , readl ( card -> iobase1 + MACREG_REG_A2H_INTERRUPT_STATUS_MASK ) ) ; } for ( i = 0 ; i < 7 ; i ++ ) { u32 cwmin , cwmax , txop , aifsn ; if ( mwl_fwcmd_reg_mac ( priv -> hw , WL_GET , MAC_REG_CW0_MIN + ( i * 8 ) , & cwmin ) ) cwmin = 0xdead ; if ( mwl_fwcmd_reg_mac ( priv -> hw , WL_GET , MAC_REG_CW0_MAX + ( i * 8 ) , & cwmax ) ) cwmax = 0xdead ; if ( mwl_fwcmd_reg_mac ( priv -> hw , WL_GET , MAC_REG_TXOP0 + ( i * 4 ) , & txop ) ) cwmax = 0xdead ; if ( mwl_fwcmd_reg_mac ( priv -> hw , WL_GET , MAC_REG_AIFSN0 + ( i * 4 ) , & aifsn ) ) cwmax = 0xdead ; len += scnprintf ( p + len , size - len , "TCQ%d<S2SV_blank>:<S2SV_blank>cwmin=%d<S2SV_blank>cwmax=%d<S2SV_blank>txop=%d<S2SV_blank>aifsn=%d\\n" , i , cwmin , cwmax , txop , aifsn ) ; } if ( priv -> host_if == MWL_IF_SDIO ) { struct mwl_sdio_card * card = priv -> intf ; len += scnprintf ( p + len , size - len , <S2SV_StartBug> "tx_pkt_unaligned_cnt:<S2SV_blank>%d\\n" , card -> tx_pkt_unaligned_cnt ) ; <S2SV_EndBug> } len += scnprintf ( p + len , size - len , "\\n" ) ; ret = simple_read_from_buffer ( ubuf , count , ppos , p , len ) ; free_page ( page ) ; return ret ; } | <S2SV_ModStart> - len , "tx_align_war_count:<S2SV_blank>%d\\n" <S2SV_ModEnd> , card -> <S2SV_ModStart> , card -> tx_align_war_count <S2SV_ModEnd> ) ; } |
3,760 | CWE-000 Object * eval_while ( Interpreter * self , ASTWhile * node ) { assert ( node -> node . type == AST_WHILE ) ; Object * condition = NULL ; Object * rv = LoxNIL ; for ( ; ; ) { condition = eval_node ( self , node -> condition ) ; if ( ! Bool_isBool ( condition ) ) { Object * T = Bool_fromObject ( condition ) ; <S2SV_StartBug> DECREF ( condition ) ; <S2SV_EndBug> condition = T ; } if ( condition == ( Object * ) LoxFALSE ) break ; <S2SV_StartBug> if ( rv ) DECREF ( rv ) ; <S2SV_EndBug> rv = eval_node ( self , node -> block ) ; <S2SV_StartBug> DECREF ( condition ) ; <S2SV_EndBug> } DECREF ( condition ) ; return rv ; } | <S2SV_ModStart> condition ) ; <S2SV_ModEnd> condition = T <S2SV_ModStart> ) break ; <S2SV_ModEnd> rv = eval_node <S2SV_ModStart> block ) ; } <S2SV_ModEnd> return rv ; |
3,761 | CWE-000 static void astg_stop ( struct thermal_zone_device * tz ) { <S2SV_StartBug> struct astg_ctx * gov = tz_to_gov ( tz ) ; <S2SV_EndBug> if ( ! gov ) return ; kobject_put ( & gov -> kobj ) ; kfree ( gov ) ; } | <S2SV_ModStart> tz_to_gov ( tz ) ; pr_debug ( "ASTG:<S2SV_blank>Stopping<S2SV_blank>ASTG\\n" |
3,762 | CWE-000 void app_RAND_load_conf ( CONF * c , const char * section ) { const char * randfile = NCONF_get_string ( c , section , "RANDFILE" ) ; if ( randfile == NULL ) { ERR_clear_error ( ) ; return ; } if ( RAND_load_file ( randfile , - 1 ) < 0 ) { BIO_printf ( bio_err , "Can\'t<S2SV_blank>load<S2SV_blank>%s<S2SV_blank>into<S2SV_blank>RNG\\n" , randfile ) ; ERR_print_errors ( bio_err ) ; <S2SV_StartBug> return ; <S2SV_EndBug> } if ( save_rand_file == NULL ) save_rand_file = OPENSSL_strdup ( randfile ) ; } | <S2SV_ModStart> bio_err ) ; <S2SV_ModEnd> } if ( |
3,763 | CWE-000 static int enduser_setup_check_host_header ( char * data , unsigned short data_len ) { ENDUSER_SETUP_DEBUG ( "enduser_setup_check_host_header" ) ; char * host_str = ( char * ) ( ( uint32_t ) strstr ( & ( data [ 6 ] ) , "Host:" ) ) ; if ( host_str == NULL ) { ENDUSER_SETUP_DEBUG ( "Host<S2SV_blank>Header<S2SV_blank>Not<S2SV_blank>Found" ) ; return 1 ; } host_str += 5 ; while ( host_str [ 0 ] == '<S2SV_blank>' ) { host_str ++ ; } if ( c_strncmp ( host_str , state -> softAPipaddr , c_strlen ( state -> softAPipaddr ) ) != 0 ) <S2SV_StartBug> ENDUSER_SETUP_DEBUG ( "Different<S2SV_blank>Host<S2SV_blank>Found" ) ; <S2SV_EndBug> return 2 ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> != 0 ) { <S2SV_ModStart> 2 ; } return 0 ; } |
3,764 | CWE-000 static MRIS_HASH_TABLE * newMHT ( MRI_SURFACE const * mris ) { MRIS_HASH_TABLE * mht = ( MRIS_HASH_TABLE * ) calloc ( 1 , sizeof ( MRIS_HASH_TABLE ) ) ; if ( ! mht ) { ErrorExit ( ERROR_NO_MEMORY , "%s:<S2SV_blank>could<S2SV_blank>not<S2SV_blank>allocate<S2SV_blank>hash<S2SV_blank>table.\\n" , __MYFUNCTION__ ) ; } mht -> mris = mris ; <S2SV_StartBug> # ifdef HAVE_OPENMP <S2SV_EndBug> omp_init_lock ( & mht -> buckets_lock ) ; # endif return mht ; } | <S2SV_ModStart> = mris ; mht -> interestingFno = - 1 ; |
3,765 | CWE-000 static void usage ( void ) { <S2SV_StartBug> ( void ) fprintf ( stderr , "Usage:<S2SV_blank>audit<S2SV_blank>-i<S2SV_blank>|<S2SV_blank>-n<S2SV_blank>|<S2SV_blank>-s<S2SV_blank>|<S2SV_blank>-t<S2SV_blank>\\n" ) ; <S2SV_EndBug> exit ( - 1 ) ; } | <S2SV_ModStart> ( stderr , "Usage:<S2SV_blank>audit<S2SV_blank>-e<S2SV_blank>|<S2SV_blank>-i<S2SV_blank>|<S2SV_blank>-n<S2SV_blank>|<S2SV_blank>-s<S2SV_blank>|<S2SV_blank>-t<S2SV_blank>\\n" <S2SV_ModEnd> ) ; exit |
3,766 | CWE-000 static void fini_mmc_for_env ( struct mmc * mmc ) { # ifdef CONFIG_SYS_MMC_ENV_PART <S2SV_StartBug> int dev = mmc_get_env_dev ( ) ; <S2SV_EndBug> blk_select_hwpart_devnum ( IF_TYPE_MMC , dev , env_mmc_orig_hwpart ) ; # endif } | <S2SV_ModStart> int dev = get_device_num <S2SV_ModEnd> ( ) ; |
3,767 | CWE-000 void gregorio_rebuild_characters ( gregorio_character * * const param_character , gregorio_center_determination center_is_determined , bool skip_initial ) { gregorio_character * current_character = * param_character ; gregorio_character * sentinel ; det_style * first_style = NULL ; grestyle_style center_type = ST_NO_STYLE ; int start = - 1 , end = - 1 , index = - 1 ; bool in_elision = false ; det_style * current_style ; <S2SV_StartBug> if ( go_to_end_initial ( & current_character ) ) { <S2SV_EndBug> if ( ! current_character -> next_character ) { insert_style_after ( ST_T_END , ST_CENTER , & current_character ) ; gregorio_go_to_first_character_c ( & current_character ) ; insert_style_before ( ST_T_BEGIN , ST_CENTER , current_character ) ; gregorio_go_to_first_character_c ( & current_character ) ; ( * param_character ) = current_character ; return ; } <S2SV_StartBug> if ( skip_initial ) { <S2SV_EndBug> current_character = current_character -> next_character ; <S2SV_StartBug> } else { <S2SV_EndBug> gregorio_go_to_first_character_c ( & current_character ) ; } } if ( center_is_determined == 0 ) { center_type = ST_CENTER ; determine_center ( current_character , & start , & end ) ; } else { center_type = ST_FORCED_CENTER ; } if ( ! current_character ) { return ; } for ( sentinel = current_character ; sentinel -> next_character ; sentinel = sentinel -> next_character ) { } insert_style_after ( ST_T_NOTHING , ST_SENTINEL , & sentinel ) ; <S2SV_StartBug> while ( current_character != sentinel ) { <S2SV_EndBug> if ( current_character -> is_character ) { if ( ! in_elision ) { ++ index ; if ( ! center_is_determined && index == start ) { begin_center ( center_type , current_character , & first_style ) ; center_is_determined = CENTER_DETERMINING_MIDDLE ; } else if ( center_is_determined == CENTER_DETERMINING_MIDDLE && index == end ) { end_center ( center_type , current_character , & first_style ) ; center_is_determined = CENTER_FULLY_DETERMINED ; } } } else { const grestyle_style style = current_character -> cos . s . style ; switch ( current_character -> cos . s . type ) { case ST_T_BEGIN : switch ( style ) { case ST_VERBATIM : case ST_SPECIAL_CHAR : if ( center_is_determined == CENTER_DETERMINING_MIDDLE ) { end_center ( center_type , current_character , & first_style ) ; center_is_determined = CENTER_FULLY_DETERMINED ; } if ( current_character -> next_character ) { current_character = current_character -> next_character ; } <S2SV_StartBug> while ( current_character && current_character -> is_character ) { <S2SV_EndBug> current_character = current_character -> next_character ; } <S2SV_StartBug> if ( current_character ) { <S2SV_EndBug> gregorio_assert2 ( ! current_character -> is_character && current_character -> cos . s . type == ST_T_END && current_character -> cos . s . style == style , gregorio_rebuild_characters , "mismatched<S2SV_blank>%s" , grestyle_style_to_string ( style ) , break ) ; } break ; case ST_CENTER : gregorio_fail ( gregorio_rebuild_characters , "encountered<S2SV_blank>unexpected<S2SV_blank>begin<S2SV_blank>ST_CENTER" ) ; break ; case ST_FORCED_CENTER : begin_center ( center_type , current_character , & first_style ) ; current_character = suppress_character ( current_character ) ; continue ; default : handle_elision ( current_character , & in_elision ) ; for ( current_style = first_style ; current_style && current_style -> style != current_character -> cos . s . style ; current_style = current_style -> next_style ) { } if ( current_style ) { current_character = suppress_character ( current_character ) ; continue ; } style_push ( & first_style , current_character -> cos . s . style ) ; break ; } break ; case ST_T_END : switch ( current_character -> cos . s . style ) { case ST_VERBATIM : case ST_SPECIAL_CHAR : case ST_CENTER : gregorio_fail2 ( gregorio_rebuild_characters , "encountered<S2SV_blank>unexpected<S2SV_blank>end<S2SV_blank>%s" , grestyle_style_to_string ( current_character -> cos . s . style ) ) ; break ; case ST_FORCED_CENTER : end_center ( center_type , current_character , & first_style ) ; current_character = suppress_character ( current_character ) ; continue ; default : handle_elision ( current_character , & in_elision ) ; if ( ! first_style ) { current_character = suppress_character ( current_character ) ; continue ; } for ( current_style = first_style ; current_style && current_style -> style != current_character -> cos . s . style ; current_style = current_style -> next_style ) { } if ( current_style ) { det_style * this_style ; for ( this_style = first_style ; this_style != current_style ; this_style = this_style -> next_style ) { insert_style_before ( ST_T_END , this_style -> style , current_character ) ; } for ( this_style = this_style -> previous_style ; this_style ; this_style = this_style -> previous_style ) { insert_style_after ( ST_T_BEGIN , this_style -> style , & current_character ) ; } style_pop ( & first_style , current_style ) ; } else { current_character = suppress_character ( current_character ) ; continue ; } } break ; default : gregorio_fail ( gregorio_rebuild_characters , "unexpected<S2SV_blank>style<S2SV_blank>type" ) ; } } current_character = current_character -> next_character ; } current_character = sentinel -> previous_character ; <S2SV_StartBug> suppress_character ( sentinel ) ; <S2SV_EndBug> for ( current_style = first_style ; current_style ; current_style = current_style -> next_style ) { insert_style_after ( ST_T_END , current_style -> style , & current_character ) ; } if ( center_is_determined != CENTER_FULLY_DETERMINED ) { insert_style_after ( ST_T_END , center_type , & current_character ) ; } if ( ! center_is_determined ) { if ( skip_initial && go_to_end_initial ( & current_character ) ) { current_character = current_character -> next_character ; } else { gregorio_go_to_first_character_c ( & current_character ) ; } insert_style_before ( ST_T_BEGIN , ST_CENTER , current_character ) ; } gregorio_go_to_first_character_c ( & current_character ) ; ( * param_character ) = current_character ; free_styles ( & first_style ) ; } | <S2SV_ModStart> ; if ( skip_initial && <S2SV_ModStart> return ; } <S2SV_ModEnd> current_character = current_character <S2SV_ModStart> ; } else { if ( current_character ) <S2SV_ModStart> ; while ( current_character && <S2SV_ModStart> current_character && current_character != sentinel && current_character <S2SV_ModStart> next_character ; } assert ( current_character ) ; if ( current_character != sentinel <S2SV_ModEnd> ) { gregorio_assert2 <S2SV_ModStart> -> previous_character ; current_character -> next_character = NULL ; free <S2SV_ModEnd> ( sentinel ) |
3,768 | CWE-000 void INIWriteInt ( HANDLE file , const char * name , DWORD value , DWORD mask , int section ) { char buffer [ 256 ] ; char number [ 32 ] ; int buffersize ; int outsize ; if ( mask ) { SetINISection ( file , section ) ; strcpy ( buffer , name ) ; strcat ( buffer , "=" ) ; <S2SV_StartBug> itoa ( value , number , 10 ) ; <S2SV_EndBug> strcat ( buffer , number ) ; strcat ( buffer , "\\r\\n" ) ; buffersize = strlen ( buffer ) ; WriteFile ( file , buffer , buffersize , & outsize , NULL ) ; } } | <S2SV_ModStart> "=" ) ; _itoa <S2SV_ModEnd> ( value , |
3,769 | CWE-000 int main ( ) { key_t sem_key = ftok ( "." , 'S' ) ; key_t mem_key = ftok ( "." , 'R' ) ; int semID = semget ( sem_key , 1 , 0 ) ; struct sembuf opp ; opp . sem_op = - 1 ; opp . sem_flg = SEM_UNDO ; <S2SV_StartBug> semop ( semID , & opp , 1 ) ; <S2SV_EndBug> int memID = shmget ( mem_key , 127 , 0 ) ; char * data = shmat ( memID , 0 , 0 ) ; <S2SV_StartBug> char bytes = data [ 0 ] ; <S2SV_EndBug> if ( ! bytes ) { printf ( "Please<S2SV_blank>input<S2SV_blank>a<S2SV_blank>phrase\\n" ) ; } else { char * last_line = & data [ 1 ] ; printf ( "Please<S2SV_blank>input<S2SV_blank>a<S2SV_blank>phrase\\n" ) ; printf ( "Previous<S2SV_blank>Line:<S2SV_blank>%s\\n" , last_line ) ; } char answer [ 127 ] ; fgets ( answer , 127 , stdin ) ; <S2SV_StartBug> bytes = sizeof ( answer ) ; <S2SV_EndBug> data [ 0 ] = bytes ; strcpy ( & data [ 1 ] , answer ) ; shmdt ( data ) ; int fd = open ( "story" , O_WRONLY | O_APPEND ) ; write ( fd , answer , bytes ) ; close ( fd ) ; opp . sem_op = 1 ; semop ( semID , & opp , 1 ) ; return 0 ; } | <S2SV_ModStart> = SEM_UNDO ; opp . sem_num = 0 ; <S2SV_ModStart> opp , 1 ) ; printf ( "%d\\n" , semctl ( semID , 0 , GETVAL ) <S2SV_ModStart> 0 ) ; int <S2SV_ModEnd> bytes = data <S2SV_ModStart> stdin ) ; int i = 0 ; while ( answer [ i ] ) { i ++ ; } bytes = i <S2SV_ModEnd> ; data [ |
3,770 | CWE-000 static void finish_writers ( struct writer_data * wd , struct opts * opts ) { int i ; char * elapsed_time = get_child_time ( & wd -> ts1 , & wd -> ts2 ) ; if ( opts -> time ) { print_child_time ( elapsed_time ) ; print_child_usage ( & wd -> usage ) ; } <S2SV_StartBug> free ( elapsed_time ) ; <S2SV_EndBug> <S2SV_StartBug> if ( opts -> nop ) <S2SV_EndBug> return ; if ( fill_file_header ( opts , wd -> status , & wd -> usage , elapsed_time ) < 0 ) <S2SV_StartBug> pr_err ( "cannot<S2SV_blank>generate<S2SV_blank>data<S2SV_blank>file" ) ; <S2SV_EndBug> if ( shmem_lost_count ) pr_warn ( "LOST<S2SV_blank>%d<S2SV_blank>records\\n" , shmem_lost_count ) ; for ( i = 0 ; i < opts -> nr_thread ; i ++ ) pthread_join ( wd -> writers [ i ] , NULL ) ; free ( wd -> writers ) ; close ( thread_ctl [ 0 ] ) ; flush_shmem_list ( opts -> dirname , opts -> bufsize ) ; record_remaining_buffer ( opts , wd -> sock ) ; unlink_shmem_list ( ) ; free_tid_list ( ) ; if ( opts -> kernel ) finish_kernel_tracing ( & wd -> kernel ) ; if ( has_perf_event ) finish_perf_record ( & wd -> perf ) ; } | <S2SV_ModStart> ) ; } if ( opts -> nop ) { <S2SV_ModStart> elapsed_time ) ; return ; } <S2SV_ModEnd> if ( fill_file_header <S2SV_ModStart> pr_err ( "cannot<S2SV_blank>generate<S2SV_blank>data<S2SV_blank>file" ) ; free ( elapsed_time |
3,771 | CWE-000 NFA * remove_epsilons ( NFA * n ) { Transition temp ; char c , c2 ; int sub ; for ( int s = 0 ; s < n -> num_states ; s ++ ) { for ( int t = 0 ; t < n -> states [ s ] . num_transitions ; t ++ ) { if ( n -> states [ s ] . transitions [ t ] . symbol != EPSILON ) continue ; temp = n -> states [ s ] . transitions [ t ] ; for ( int t2 = 0 ; t2 < n -> states [ temp . destination ] . num_transitions ; t2 ++ ) { c = n -> states [ temp . destination ] . transitions [ t2 ] . symbol ; if ( c == EPSILON ) continue ; c2 = 1 ; for ( int i = 0 ; i < n -> states [ s ] . num_transitions ; i ++ ) { if ( n -> states [ s ] . transitions [ i ] . symbol == c && n -> states [ s ] . transitions [ i ] . destination == n -> states [ temp . destination ] . transitions [ t2 ] . destination ) { c2 = 0 ; break ; } } if ( c2 ) { NFA_addTransition ( n , s , c , n -> states [ temp . destination ] . transitions [ t2 ] . destination ) ; } sub = n -> states [ temp . destination ] . transitions [ t2 ] . destination ; for ( int i = 0 ; i < n -> states [ sub ] . num_transitions ; i ++ ) { if ( n -> states [ sub ] . transitions [ i ] . symbol != EPSILON ) continue ; c2 = 1 ; for ( int j = 0 ; j < n -> states [ s ] . num_transitions ; j ++ ) { if ( n -> states [ s ] . transitions [ j ] . symbol == c && n -> states [ s ] . transitions [ j ] . destination == n -> states [ sub ] . transitions [ i ] . destination ) { c2 = 0 ; break ; } } if ( c2 ) { NFA_addTransition ( n , s , c , n -> states [ sub ] . transitions [ i ] . destination ) ; } } } } } NFA * r = malloc ( sizeof ( NFA ) ) ; r -> start = n -> start ; r -> num_states = n -> num_states ; r -> buf_size = n -> buf_size ; r -> states = malloc ( r -> buf_size * sizeof ( State ) ) ; for ( int s = 0 ; s < r -> num_states ; s ++ ) { <S2SV_StartBug> r -> states [ s ] . active = 0 ; <S2SV_EndBug> r -> states [ s ] . num_transitions = 0 ; <S2SV_StartBug> r -> states [ s ] . accepting = n -> states [ s ] . accepting ; <S2SV_EndBug> r -> states [ s ] . buf_size = n -> states [ s ] . buf_size ; <S2SV_StartBug> r -> states [ s ] . transitions = malloc ( r -> buf_size * sizeof ( Transition ) ) ; <S2SV_EndBug> for ( int t = 0 ; t < n -> states [ s ] . num_transitions ; t ++ ) { if ( n -> states [ s ] . transitions [ t ] . symbol != EPSILON ) NFA_addTransition ( r , s , n -> states [ s ] . transitions [ t ] . symbol , n -> states [ s ] . transitions [ t ] . destination ) ; } } return r ; } | <S2SV_ModStart> s ] . accepting = n -> states [ s ] . accepting ; r -> states [ s ] . <S2SV_ModStart> s ] . <S2SV_ModEnd> buf_size = n <S2SV_ModStart> ( r -> states [ s ] . |
3,772 | CWE-000 struct page * pktlog_vmmap ( struct vm_area_struct * vma , unsigned long addr , int write_access ) # endif { unsigned long offset , vaddr ; struct proc_dir_entry * proc_entry ; struct ath_pktlog_info * pl_info = proc_entry = PDE ( vma -> vm_file -> f_dentry -> d_inode ) ; pl_info = ( struct ath_pktlog_info * ) proc_entry -> data ; offset = addr - vma -> vm_start + ( vma -> vm_pgoff << PAGE_SHIFT ) ; vaddr = ( unsigned long ) pktlog_virt_to_logical ( ( void * ) ( pl_info -> buf ) + offset ) ; if ( vaddr == 0UL ) { printk ( PKTLOG_TAG "%s:<S2SV_blank>page<S2SV_blank>fault<S2SV_blank>out<S2SV_blank>of<S2SV_blank>range\\n" , __func__ ) ; return ( ( struct page * ) 0UL ) ; } get_page ( virt_to_page ( ( void * ) vaddr ) ) ; # if LINUX_VERSION_CODE >= KERNEL_VERSION ( 2 , 6 , 0 ) if ( type ) <S2SV_StartBug> * type = VM_FAULT_MINOR ; <S2SV_EndBug> # endif return virt_to_page ( ( void * ) vaddr ) ; } | <S2SV_ModStart> ( type ) # if LINUX_VERSION_CODE >= KERNEL_VERSION ( 4 , 6 , 0 ) <S2SV_ModStart> * type = 0 ; # else * type = VM_FAULT_MINOR ; # endif <S2SV_ModEnd> # endif return |
3,773 | CWE-000 void Draw_InitLocal ( void ) { <S2SV_StartBug> gl_nolerp_list = ri . Cvar_Get ( "gl_nolerp_list" , "pics/conchars.pcx<S2SV_blank>pics/ch1.pcx<S2SV_blank>pics/ch2.pcx<S2SV_blank>pics/ch3.pcx" , 0 ) ; <S2SV_EndBug> draw_chars = R_FindImage ( "pics/conchars.pcx" , it_pic ) ; } | <S2SV_ModStart> void ) { <S2SV_ModEnd> draw_chars = R_FindImage |
3,774 | CWE-000 int main ( int argc , char const * argv [ ] ) { char buff [ 2000 ] ; struct sockaddr_in source , dest ; struct sockaddr saddr ; struct ifreq ethreq ; int sock = socket ( PF_PACKET , SOCK_RAW , ETH_P_ALL ) ; <S2SV_StartBug> strncpy ( ethreq . ifr_name , "eno1" , IFNAMSIZ ) ; <S2SV_EndBug> <S2SV_StartBug> ioctl ( sock , SIOCGIFFLAGS , & ethreq ) ; <S2SV_EndBug> ethreq . ifr_flags |= IFF_PROMISC ; <S2SV_StartBug> ioctl ( sock , SIOCSIFFLAGS , & ethreq ) ; <S2SV_EndBug> <S2SV_StartBug> int addr_size = sizeof ( saddr ) ; <S2SV_EndBug> <S2SV_StartBug> recvfrom ( sock , buff , sizeof ( buff ) , 0 , & saddr , & addr_size ) ; <S2SV_EndBug> printf ( "%s\\n" , buff ) ; return 0 ; } | <S2SV_ModStart> ETH_P_ALL ) ; if ( sock ) printf ( "socket<S2SV_blank>bien<S2SV_blank>sock:<S2SV_blank>%d\\n" , sock ) ; <S2SV_ModStart> IFNAMSIZ ) ; printf ( "ethreq.ifr_name:<S2SV_blank>%s\\n" , ethreq . ifr_name ) ; int io = <S2SV_ModStart> , & ethreq ) ; printf ( "iocl:<S2SV_blank>%d\\n" , io <S2SV_ModStart> |= IFF_PROMISC ; io = <S2SV_ModStart> ethreq ) ; printf ( "ioScl:<S2SV_blank>%d\\n" , io ) ; <S2SV_ModStart> saddr ) ; printf ( "addrsize<S2SV_blank>%d<S2SV_blank><S2SV_blank>buffersize:<S2SV_blank>%d\\n" , addr_size , sizeof ( buff ) ) ; int len = <S2SV_ModStart> ( sock , & <S2SV_ModStart> , & addr_size ) ; printf ( "%d\\n" , len |
3,775 | CWE-000 static void compile_block ( jit_gencode_t gen , jit_function_t func , jit_block_t block ) { jit_insn_iter_t iter ; jit_insn_t insn ; # ifdef _JIT_COMPILE_DEBUG printf ( "Block<S2SV_blank>#%d:<S2SV_blank>%d\\n\\n" , func -> builder -> block_count ++ , block -> label ) ; # endif jit_insn_iter_init ( & iter , block ) ; while ( ( insn = jit_insn_iter_next ( & iter ) ) != 0 ) { # ifdef _JIT_COMPILE_DEBUG unsigned char * p1 , * p2 ; p1 = gen -> ptr ; printf ( "Insn<S2SV_blank>#%d:<S2SV_blank>" , func -> builder -> insn_count ++ ) ; jit_dump_insn ( stdout , func , insn ) ; printf ( "\\nStart<S2SV_blank>of<S2SV_blank>binary<S2SV_blank>code:<S2SV_blank>0x%08x\\n" , p1 ) ; # endif switch ( insn -> opcode ) { case JIT_OP_NOP : break ; case JIT_OP_CHECK_NULL : if ( ! _jit_insn_check_is_redundant ( & iter ) ) { _jit_gen_insn ( gen , func , block , insn ) ; } break ; # ifndef JIT_BACKEND_INTERP case JIT_OP_CALL : case JIT_OP_CALL_TAIL : case JIT_OP_CALL_INDIRECT : case JIT_OP_CALL_INDIRECT_TAIL : case JIT_OP_CALL_VTABLE_PTR : case JIT_OP_CALL_VTABLE_PTR_TAIL : case JIT_OP_CALL_EXTERNAL : case JIT_OP_CALL_EXTERNAL_TAIL : _jit_regs_spill_all ( gen ) ; _jit_gen_insn ( gen , func , block , insn ) ; _jit_regs_clear_all_outgoing ( gen ) ; break ; # endif <S2SV_StartBug> case JIT_OP_IMPORT : <S2SV_EndBug> _jit_gen_fix_value ( insn -> value2 ) ; insn -> opcode = JIT_OP_ADD_RELATIVE ; insn -> value2 = jit_value_create_nint_constant ( func , jit_type_nint , insn -> value2 -> frame_offset ) ; _jit_gen_insn ( gen , func , block , insn ) ; break ; # ifndef JIT_BACKEND_INTERP case JIT_OP_INCOMING_REG : _jit_regs_set_incoming ( gen , ( int ) jit_value_get_nint_constant ( insn -> value2 ) , insn -> value1 ) ; _jit_gen_insn ( gen , func , block , insn ) ; break ; # endif case JIT_OP_INCOMING_FRAME_POSN : insn -> value1 -> frame_offset = jit_value_get_nint_constant ( insn -> value2 ) ; insn -> value1 -> in_register = 0 ; insn -> value1 -> has_frame_offset = 1 ; if ( insn -> value1 -> has_global_register ) { insn -> value1 -> in_global_register = 1 ; _jit_gen_load_global ( gen , insn -> value1 -> global_reg , insn -> value1 ) ; } else { insn -> value1 -> in_frame = 1 ; } break ; # ifndef JIT_BACKEND_INTERP case JIT_OP_OUTGOING_REG : _jit_regs_set_outgoing ( gen , ( int ) jit_value_get_nint_constant ( insn -> value2 ) , insn -> value1 ) ; break ; # endif case JIT_OP_OUTGOING_FRAME_POSN : insn -> value1 -> frame_offset = jit_value_get_nint_constant ( insn -> value2 ) ; insn -> value1 -> in_register = 0 ; insn -> value1 -> in_global_register = 0 ; insn -> value1 -> in_frame = 0 ; insn -> value1 -> has_frame_offset = 1 ; insn -> value1 -> has_global_register = 0 ; break ; # ifndef JIT_BACKEND_INTERP case JIT_OP_RETURN_REG : _jit_regs_set_incoming ( gen , ( int ) jit_value_get_nint_constant ( insn -> value2 ) , insn -> value1 ) ; _jit_gen_insn ( gen , func , block , insn ) ; break ; # endif case JIT_OP_MARK_OFFSET : mark_offset ( gen , func , ( unsigned long ) ( long ) jit_value_get_nint_constant ( insn -> value1 ) ) ; break ; default : _jit_gen_insn ( gen , func , block , insn ) ; break ; } # ifdef _JIT_COMPILE_DEBUG p2 = gen -> ptr ; printf ( "Length<S2SV_blank>of<S2SV_blank>binary<S2SV_blank>code:<S2SV_blank>%d\\n\\n" , p2 - p1 ) ; fflush ( stdout ) ; # endif } } | <S2SV_ModStart> ; # endif <S2SV_ModEnd> # ifndef JIT_BACKEND_INTERP |
3,776 | CWE-000 static void tcmulib_reg_name_acquired ( GDBusConnection * connection , const gchar * name , gpointer user_data ) { struct tcmulib_handler * handler = user_data ; struct tcmulib_context * ctx = handler -> ctx ; <S2SV_StartBug> if ( ! ctx -> reg_count_down || -- ctx -> reg_count_down ) <S2SV_EndBug> return ; darray_foreach ( handler , ctx -> handlers ) { <S2SV_StartBug> if ( ! tcmulib_register_handler ( ctx , handler ) ) { <S2SV_EndBug> tcmulib_reg_fail ( ctx ) ; break ; } } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> -> ctx ; handler -> connection = connection ; if ( ctx -> connection ) { <S2SV_ModEnd> tcmulib_register_handler ( ctx <S2SV_ModStart> , handler ) <S2SV_ModEnd> ; } } <S2SV_ModStart> ; } } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
3,777 | CWE-000 static uint8_t find_highest_priority ( void ) { struct My_data_pointers * slaves ; uint8_t slave_highest_priority = 0xFF ; <S2SV_StartBug> uint8_t highest_priority ; <S2SV_EndBug> if ( 0 != data_struct ) { if ( xQueuePeek ( data_struct , & ( slaves ) , ( TickType_t ) 0 ) ) { if ( xSemaphoreTake ( data_struct_mutex , ( ( TickType_t ) 10 ) == pdTRUE ) ) { <S2SV_StartBug> NRF_LOG_INFO ( "\\t<S2SV_blank>Take<S2SV_blank>data_struct_mutex<S2SV_blank>h_p<S2SV_blank>\\n\\r" ) ; <S2SV_EndBug> <S2SV_StartBug> for ( int i ; i <= CENTRAL_LINK_COUNT ; i ++ ) <S2SV_EndBug> { <S2SV_StartBug> if ( 100 > slaves -> pMy_datas [ i ] -> state && slaves -> pMy_datas [ i ] -> priority < highest_priority ) <S2SV_EndBug> { slave_highest_priority = i ; highest_priority = slaves -> pMy_datas [ i ] -> priority ; } } if ( xSemaphoreGive ( data_struct_mutex ) != pdTRUE ) { } <S2SV_StartBug> NRF_LOG_INFO ( "\\t<S2SV_blank>Give<S2SV_blank>data_struct_mutex<S2SV_blank>h_p<S2SV_blank>\\n\\r" ) ; <S2SV_EndBug> } } } if ( 0xFF == slave_highest_priority ) { } return slave_highest_priority ; } | <S2SV_ModStart> ; uint8_t highest_priority = 0xFF <S2SV_ModStart> ) ) { <S2SV_ModEnd> for ( int <S2SV_ModStart> ( int i = 0 <S2SV_ModStart> i <= CENTRAL_LINK_COUNT - 1 <S2SV_ModStart> ) { if ( <S2SV_ModStart> priority < highest_priority ) && slaves -> pMy_datas [ i ] -> type != '0' <S2SV_ModStart> ) { } } } <S2SV_ModEnd> } return slave_highest_priority |
3,778 | CWE-000 void concreate ( void ) { char file [ 3 ] ; int i , pid , n , fd ; char fa [ 40 ] ; struct { ushort inum ; char name [ 14 ] ; } de ; printf ( 1 , "concreate<S2SV_blank>test\\n" ) ; file [ 0 ] = 'C' ; file [ 2 ] = '\\0' ; for ( i = 0 ; i < 40 ; i ++ ) { file [ 1 ] = '0' + i ; unlink ( file ) ; pid = fork ( ) ; if ( pid && ( i % 3 ) == 1 ) { link ( "C0" , file ) ; } else if ( pid == 0 && ( i % 5 ) == 1 ) { link ( "C0" , file ) ; } else { fd = open ( file , O_CREATE | O_RDWR ) ; if ( fd < 0 ) { printf ( 1 , "concreate<S2SV_blank>create<S2SV_blank>%s<S2SV_blank>failed\\n" , file ) ; exit ( 0 ) ; } close ( fd ) ; } if ( pid == 0 ) exit ( 0 ) ; else <S2SV_StartBug> wait ( ) ; <S2SV_EndBug> } memset ( fa , 0 , sizeof ( fa ) ) ; fd = open ( "." , 0 ) ; n = 0 ; while ( read ( fd , & de , sizeof ( de ) ) > 0 ) { if ( de . inum == 0 ) continue ; if ( de . name [ 0 ] == 'C' && de . name [ 2 ] == '\\0' ) { i = de . name [ 1 ] - '0' ; if ( i < 0 || i >= sizeof ( fa ) ) { printf ( 1 , "concreate<S2SV_blank>weird<S2SV_blank>file<S2SV_blank>%s\\n" , de . name ) ; exit ( 0 ) ; } if ( fa [ i ] ) { printf ( 1 , "concreate<S2SV_blank>duplicate<S2SV_blank>file<S2SV_blank>%s\\n" , de . name ) ; exit ( 0 ) ; } fa [ i ] = 1 ; n ++ ; } } close ( fd ) ; if ( n != 40 ) { printf ( 1 , "concreate<S2SV_blank>not<S2SV_blank>enough<S2SV_blank>files<S2SV_blank>in<S2SV_blank>directory<S2SV_blank>listing\\n" ) ; exit ( 0 ) ; } for ( i = 0 ; i < 40 ; i ++ ) { file [ 1 ] = '0' + i ; pid = fork ( ) ; if ( pid < 0 ) { printf ( 1 , "fork<S2SV_blank>failed\\n" ) ; exit ( 0 ) ; } if ( ( ( i % 3 ) == 0 && pid == 0 ) || ( ( i % 3 ) == 1 && pid != 0 ) ) { close ( open ( file , 0 ) ) ; close ( open ( file , 0 ) ) ; close ( open ( file , 0 ) ) ; close ( open ( file , 0 ) ) ; } else { unlink ( file ) ; unlink ( file ) ; unlink ( file ) ; unlink ( file ) ; } if ( pid == 0 ) exit ( 0 ) ; else <S2SV_StartBug> wait ( ) ; <S2SV_EndBug> } printf ( 1 , "concreate<S2SV_blank>ok\\n" ) ; } | <S2SV_ModStart> else wait ( 0 <S2SV_ModStart> else wait ( 0 |
3,779 | CWE-000 int init_first_block ( size_t size , t_heap * * heap ) { t_block * first_used ; t_block * first_free ; <S2SV_StartBug> first_used = ( t_block * ) ( ( * heap ) + 1 ) ; <S2SV_EndBug> first_free = ( t_block * ) ( ( char * ) ( * heap ) + sizeof ( t_heap ) + sizeof ( t_block ) + size ) ; first_used -> size = ( int ) size ; first_used -> heap = * heap ; first_used -> next = NULL ; first_used -> prev = NULL ; <S2SV_StartBug> ( * heap ) -> head = first_used ; <S2SV_EndBug> first_free -> size = ( ( * heap ) -> size - size - ( sizeof ( t_block ) * 2 ) ) * - 1 ; first_free -> heap = * heap ; ( * heap ) -> free_head = first_free ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> ) + 1 <S2SV_ModEnd> ) ; first_used <S2SV_ModStart> head = first_used ; if ( ( * heap ) -> size > first_used -> size + sizeof ( t_block ) * 2 ) { first_free = ( t_block * ) ( ( char * ) ( * heap ) + sizeof ( t_heap ) + sizeof ( t_block ) + size ) <S2SV_ModStart> = first_free ; } |
3,780 | CWE-000 struct msgb * gsm0808_create_paging ( const char * imsi , const uint32_t * tmsi , const struct gsm0808_cell_id_list * cil , const uint8_t * chan_needed ) { <S2SV_StartBug> struct msgb * msg ; <S2SV_EndBug> uint8_t mid_buf [ GSM48_MI_SIZE + 2 ] ; int mid_len ; uint32_t tmsi_sw ; OSMO_ASSERT ( imsi ) ; OSMO_ASSERT ( cil ) ; <S2SV_StartBug> OSMO_ASSERT ( strlen ( imsi ) <= GSM48_MI_SIZE ) ; <S2SV_EndBug> msg = msgb_alloc_headroom ( BSSMAP_MSG_SIZE , BSSMAP_MSG_HEADROOM , "paging" ) ; if ( ! msg ) return NULL ; <S2SV_StartBug> msgb_v_put ( msg , BSS_MAP_MSG_PAGING ) ; <S2SV_EndBug> mid_len = gsm48_generate_mid_from_imsi ( mid_buf , imsi ) ; msgb_tlv_put ( msg , GSM0808_IE_IMSI , mid_len - 2 , mid_buf + 2 ) ; if ( tmsi ) { tmsi_sw = osmo_htonl ( * tmsi ) ; msgb_tlv_put ( msg , GSM0808_IE_TMSI , sizeof ( * tmsi ) , ( uint8_t * ) & tmsi_sw ) ; } <S2SV_StartBug> if ( cil ) <S2SV_EndBug> gsm0808_enc_cell_id_list ( msg , cil ) ; if ( chan_needed ) { msgb_tv_put ( msg , GSM0808_IE_CHANNEL_NEEDED , ( * chan_needed ) & 0x03 ) ; } msg -> l3h = msgb_tv_push ( msg , BSSAP_MSG_BSS_MANAGEMENT , msgb_length ( msg ) ) ; return msg ; } | <S2SV_ModStart> ) { struct gsm0808_cell_id_list2 cil2 = { } <S2SV_ModEnd> ; OSMO_ASSERT ( <S2SV_ModStart> cil ) ; if ( cil -> id_list_len > GSM0808_CELL_ID_LIST2_MAXLEN <S2SV_ModEnd> ) return NULL <S2SV_ModStart> return NULL ; cil2 . id_discr = cil -> id_discr ; memcpy ( cil2 . id_list , cil -> id_list_lac , cil -> id_list_len * sizeof ( cil2 . id_list [ 0 ] . lac ) ) ; cil2 . id_list_len = cil -> id_list_len ; return gsm0808_create_paging2 ( imsi , tmsi , & cil2 , chan_needed <S2SV_ModEnd> ) ; } <S2SV_ModStart> ) ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
3,781 | CWE-000 static int get_crash_memory_ranges ( struct memory_range * * range , int * ranges , int kexec_flags , unsigned long lowmem_limit ) { const char * iomem = proc_iomem ( ) ; int memory_ranges = 0 , gart = 0 , i ; char line [ MAX_LINE ] ; FILE * fp ; unsigned long long start , end ; uint64_t gart_start = 0 , gart_end = 0 ; fp = fopen ( iomem , "r" ) ; if ( ! fp ) { fprintf ( stderr , "Cannot<S2SV_blank>open<S2SV_blank>%s:<S2SV_blank>%s\\n" , iomem , strerror ( errno ) ) ; return - 1 ; } while ( fgets ( line , sizeof ( line ) , fp ) != 0 ) { char * str ; int type , consumed , count ; if ( memory_ranges >= CRASH_MAX_MEMORY_RANGES ) break ; count = sscanf ( line , "%llx-%llx<S2SV_blank>:<S2SV_blank>%n" , & start , & end , & consumed ) ; if ( count != 2 ) continue ; str = line + consumed ; dbgprintf ( "%016llx-%016llx<S2SV_blank>:<S2SV_blank>%s" , start , end , str ) ; if ( memcmp ( str , "System<S2SV_blank>RAM\\n" , 11 ) == 0 ) { type = RANGE_RAM ; } else if ( memcmp ( str , "ACPI<S2SV_blank>Tables\\n" , 12 ) == 0 ) { type = RANGE_ACPI ; } else if ( memcmp ( str , "ACPI<S2SV_blank>Non-volatile<S2SV_blank>Storage\\n" , 26 ) == 0 ) { type = RANGE_ACPI_NVS ; } else if ( memcmp ( str , "Persistent<S2SV_blank>Memory<S2SV_blank>(legacy)\\n" , 27 ) == 0 ) { type = RANGE_PRAM ; } else if ( memcmp ( str , "Persistent<S2SV_blank>Memory\\n" , 18 ) == 0 ) { type = RANGE_PMEM ; } else if ( memcmp ( str , "reserved\\n" , 9 ) == 0 ) { type = RANGE_RESERVED ; <S2SV_StartBug> } else if ( memcmp ( str , "GART\\n" , 5 ) == 0 ) { <S2SV_EndBug> gart_start = start ; gart_end = end ; gart = 1 ; continue ; } else { continue ; } crash_memory_range [ memory_ranges ] . start = start ; crash_memory_range [ memory_ranges ] . end = end ; crash_memory_range [ memory_ranges ] . type = type ; segregate_lowmem_region ( & memory_ranges , lowmem_limit ) ; memory_ranges ++ ; } fclose ( fp ) ; if ( kexec_flags & KEXEC_PRESERVE_CONTEXT ) { for ( i = 0 ; i < memory_ranges ; i ++ ) { if ( crash_memory_range [ i ] . end > 0x0009ffff ) { crash_reserved_mem [ 0 ] . start = crash_memory_range [ i ] . start ; break ; } } if ( crash_reserved_mem [ 0 ] . start >= mem_max ) { fprintf ( stderr , "Too<S2SV_blank>small<S2SV_blank>mem_max:<S2SV_blank>0x%llx.\\n" , mem_max ) ; return - 1 ; } crash_reserved_mem [ 0 ] . end = mem_max ; crash_reserved_mem [ 0 ] . type = RANGE_RAM ; crash_reserved_mem_nr = 1 ; } for ( i = 0 ; i < crash_reserved_mem_nr ; i ++ ) if ( exclude_region ( & memory_ranges , crash_reserved_mem [ i ] . start , crash_reserved_mem [ i ] . end ) < 0 ) return - 1 ; if ( gart ) { if ( exclude_region ( & memory_ranges , gart_start , gart_end ) < 0 ) return - 1 ; } * range = crash_memory_range ; * ranges = memory_ranges ; return 0 ; } | <S2SV_ModStart> ( str , "Reserved\\n" , 9 ) == 0 ) { type = RANGE_RESERVED ; } else if ( memcmp ( str , |
3,782 | CWE-000 void execute_isto ( ) { <S2SV_StartBug> print_ostack ( ) ; <S2SV_EndBug> print_istack ( ) ; Orecord * obj = malloc ( sizeof ( Orecord ) ) ; * obj = * top_ostack ( ) ; pop_ostack ( ) ; Orecord * addr_descr = top_ostack ( ) ; unsigned char * bytes = malloc ( sizeof ( unsigned char ) * ( obj -> size ) ) ; if ( addr_descr -> type == ATOM ) { Orecord * dest = addr_descr -> instance . sval ; memcpy ( & ( dest -> instance ) , & ( obj -> instance ) , obj -> size ) ; } else { if ( obj -> type == ATOM ) { memcpy ( bytes , & ( obj -> instance ) , obj -> size ) ; write_n_istack ( bytes , obj -> size , addr_descr -> instance . ival ) ; } else { bytes = pop_n_istack ( obj -> size ) ; write_n_istack ( bytes , obj -> size , addr_descr -> instance . ival ) ; } } pop_ostack ( ) ; free ( obj ) ; free ( bytes ) ; } | <S2SV_ModStart> ( ) { <S2SV_ModEnd> Orecord * obj |
3,783 | CWE-000 Client * client_unregisterFromServer ( Server * server , Client * client ) { if ( server && client ) { Client * c = avl_removeNode ( server -> clients , client ) ; <S2SV_StartBug> if ( c ) { <S2SV_EndBug> for ( u8 i = 0 ; i < client -> n_active_cons ; i ++ ) { for ( u8 j = 0 ; j < poll_n_fds ; j ++ ) { if ( server -> fds [ j ] . fd == client -> active_connections [ i ] ) { server -> fds [ j ] . fd = - 1 ; server -> fds [ j ] . events = - 1 ; } } } <S2SV_StartBug> # ifdef CERVER_DEBUG <S2SV_EndBug> logMsg ( stdout , DEBUG_MSG , SERVER , "Unregistered<S2SV_blank>a<S2SV_blank>client<S2SV_blank>from<S2SV_blank>the<S2SV_blank>sever" ) ; # endif server -> connectedClients -- ; return c ; } else logMsg ( stdout , WARNING , CLIENT , "The<S2SV_blank>client<S2SV_blank>wasn\'t<S2SV_blank>registered<S2SV_blank>in<S2SV_blank>the<S2SV_blank>server." ) ; } return NULL ; } | <S2SV_ModStart> if ( c ) { if ( client -> active_connections <S2SV_ModStart> } } } } |
3,784 | CWE-000 <S2SV_StartBug> void nformat_rate ( FILE * fp , double x ) <S2SV_EndBug> { char temp [ 64 ] ; uint64_t i = x ; if ( conf . noformat ) { fprintf ( fp , "%llu<S2SV_blank>pps<S2SV_blank>" , i ) ; return ; } if ( i > 1500 * 1000 ) sprintf ( temp , "%5.3f<S2SV_blank>M" , ( ( double ) ( i / 1000 ) ) / 1000 ) ; else if ( i > 5 * 1000 ) sprintf ( temp , "%7llu<S2SV_blank>k" , i / ( 1000 ) ) ; else sprintf ( temp , "%7llu<S2SV_blank><S2SV_blank>" , i ) ; fprintf ( fp , "%10s<S2SV_blank>%s" , temp , "pps<S2SV_blank>" ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static |
3,785 | CWE-000 static int ocfs2_defrag_extent ( struct ocfs2_move_extents_context * context , u32 cpos , u32 phys_cpos , u32 * len , int ext_flags ) { int ret , credits = 0 , extra_blocks = 0 , partial = context -> partial ; handle_t * handle ; struct inode * inode = context -> inode ; struct ocfs2_super * osb = OCFS2_SB ( inode -> i_sb ) ; struct inode * tl_inode = osb -> osb_tl_inode ; struct ocfs2_refcount_tree * ref_tree = NULL ; u32 new_phys_cpos , new_len ; u64 phys_blkno = ocfs2_clusters_to_blocks ( inode -> i_sb , phys_cpos ) ; int need_free = 0 ; if ( ( ext_flags & OCFS2_EXT_REFCOUNTED ) && * len ) { BUG_ON ( ! ocfs2_is_refcount_inode ( inode ) ) ; BUG_ON ( ! context -> refcount_loc ) ; ret = ocfs2_lock_refcount_tree ( osb , context -> refcount_loc , 1 , & ref_tree , NULL ) ; if ( ret ) { mlog_errno ( ret ) ; return ret ; } ret = ocfs2_prepare_refcount_change_for_del ( inode , context -> refcount_loc , phys_blkno , * len , & credits , & extra_blocks ) ; if ( ret ) { mlog_errno ( ret ) ; goto out ; } } <S2SV_StartBug> ret = ocfs2_lock_allocators_move_extents ( inode , & context -> et , * len , 1 , <S2SV_EndBug> <S2SV_StartBug> & context -> meta_ac , <S2SV_EndBug> & context -> data_ac , extra_blocks , & credits ) ; if ( ret ) { mlog_errno ( ret ) ; goto out ; } inode_lock ( tl_inode ) ; if ( ocfs2_truncate_log_needs_flush ( osb ) ) { ret = __ocfs2_flush_truncate_log ( osb ) ; if ( ret < 0 ) { mlog_errno ( ret ) ; goto out_unlock_mutex ; <S2SV_StartBug> } <S2SV_EndBug> } handle = ocfs2_start_trans ( osb , credits ) ; if ( IS_ERR ( handle ) ) { ret = PTR_ERR ( handle ) ; mlog_errno ( ret ) ; goto out_unlock_mutex ; } ret = __ocfs2_claim_clusters ( handle , context -> data_ac , 1 , * len , & new_phys_cpos , & new_len ) ; if ( ret ) { mlog_errno ( ret ) ; goto out_commit ; } if ( new_len != * len ) { mlog ( 0 , "len_claimed:<S2SV_blank>%u,<S2SV_blank>len:<S2SV_blank>%u\\n" , new_len , * len ) ; if ( ! partial ) { context -> range -> me_flags &= ~ OCFS2_MOVE_EXT_FL_COMPLETE ; ret = - ENOSPC ; need_free = 1 ; goto out_commit ; } } mlog ( 0 , "cpos:<S2SV_blank>%u,<S2SV_blank>phys_cpos:<S2SV_blank>%u,<S2SV_blank>new_phys_cpos:<S2SV_blank>%u\\n" , cpos , phys_cpos , new_phys_cpos ) ; ret = __ocfs2_move_extent ( handle , context , cpos , new_len , phys_cpos , new_phys_cpos , ext_flags ) ; if ( ret ) mlog_errno ( ret ) ; if ( partial && ( new_len != * len ) ) * len = new_len ; ret = ocfs2_cow_sync_writeback ( inode -> i_sb , context -> inode , cpos , * len ) ; if ( ret ) mlog_errno ( ret ) ; out_commit : if ( need_free && context -> data_ac ) { struct ocfs2_alloc_context * data_ac = context -> data_ac ; if ( context -> data_ac -> ac_which == OCFS2_AC_USE_LOCAL ) ocfs2_free_local_alloc_bits ( osb , handle , data_ac , new_phys_cpos , new_len ) ; else ocfs2_free_clusters ( handle , data_ac -> ac_inode , data_ac -> ac_bh , ocfs2_clusters_to_blocks ( osb -> sb , new_phys_cpos ) , new_len ) ; } ocfs2_commit_trans ( osb , handle ) ; out_unlock_mutex : inode_unlock ( tl_inode ) ; if ( context -> data_ac ) { ocfs2_free_alloc_context ( context -> data_ac ) ; context -> data_ac = NULL ; } if ( context -> meta_ac ) { ocfs2_free_alloc_context ( context -> meta_ac ) ; context -> meta_ac = NULL ; } out : if ( ref_tree ) ocfs2_unlock_refcount_tree ( osb , ref_tree , 1 ) ; return ret ; } | <S2SV_ModStart> } ret = ocfs2_lock_meta_allocator_move_extents <S2SV_ModEnd> ( inode , <S2SV_ModStart> context -> meta_ac <S2SV_ModEnd> , extra_blocks , <S2SV_ModStart> out_unlock_mutex ; } } ret = ocfs2_reserve_clusters ( osb , * len , & context -> data_ac ) ; if ( ret ) { mlog_errno ( ret ) ; goto out_unlock_mutex ; |
3,786 | CWE-000 static ArvEvaluatorStatus parse_to_stacks ( ArvEvaluator * evaluator , char * expression , ArvEvaluatorParserState * state ) { ArvEvaluatorToken * token ; ArvEvaluatorStatus status ; gboolean token_found ; if ( expression == NULL ) return ARV_EVALUATOR_STATUS_EMPTY_EXPRESSION ; do { token = arv_get_next_token ( & expression , state -> previous_token_was_operand , state -> previous_token_was_right_parenthesis ) ; if ( token != NULL ) { token_found = TRUE ; state -> previous_token_was_operand = arv_evaluator_token_is_operand ( token ) ; state -> previous_token_was_right_parenthesis = arv_evaluator_token_is_right_parenthesis ( token ) ; if ( arv_evaluator_token_is_variable ( token ) ) { if ( g_hash_table_lookup_extended ( evaluator -> priv -> constants , token -> data . name , NULL , NULL ) ) { const char * constant ; constant = g_hash_table_lookup ( evaluator -> priv -> constants , token -> data . name ) ; if ( constant != NULL ) { arv_evaluator_token_free ( token ) ; token = arv_get_next_token ( ( char * * ) & constant , FALSE , FALSE ) ; if ( token != NULL ) state -> token_stack = g_slist_prepend ( state -> token_stack , token ) ; } else { status = ARV_EVALUATOR_STATUS_UNKNOWN_CONSTANT ; goto CLEANUP ; } } else if ( g_hash_table_lookup_extended ( evaluator -> priv -> sub_expressions , token -> data . name , NULL , NULL ) ) { const char * sub_expression ; sub_expression = g_hash_table_lookup ( evaluator -> priv -> sub_expressions , token -> data . name ) ; if ( sub_expression != NULL ) { char * string ; if ( state -> in_sub_expression ) { status = ARV_EVALUATOR_STATUS_FORBIDDEN_RECUSRION ; goto CLEANUP ; } string = g_strdup_printf ( "(%s)" , sub_expression ) ; state -> in_sub_expression = TRUE ; status = parse_to_stacks ( evaluator , string , state ) ; state -> in_sub_expression = FALSE ; g_free ( string ) ; if ( status != ARV_EVALUATOR_STATUS_SUCCESS ) { goto CLEANUP ; } arv_evaluator_token_free ( token ) ; token = NULL ; } else { status = ARV_EVALUATOR_STATUS_UNKNOWN_SUB_EXPRESSION ; goto CLEANUP ; } } else { state -> token_stack = g_slist_prepend ( state -> token_stack , token ) ; } } else if ( arv_evaluator_token_is_operand ( token ) ) { state -> token_stack = g_slist_prepend ( state -> token_stack , token ) ; } else if ( arv_evaluator_token_is_comma ( token ) ) { while ( state -> operator_stack != NULL && ! arv_evaluator_token_is_left_parenthesis ( state -> operator_stack -> data ) ) { state -> token_stack = g_slist_prepend ( state -> token_stack , state -> operator_stack -> data ) ; state -> operator_stack = g_slist_delete_link ( state -> operator_stack , state -> operator_stack ) ; } if ( state -> operator_stack == NULL || ! arv_evaluator_token_is_left_parenthesis ( state -> operator_stack -> data ) ) { status = ARV_EVALUATOR_STATUS_PARENTHESES_MISMATCH ; goto CLEANUP ; } state -> garbage_stack = g_slist_prepend ( state -> garbage_stack , token ) ; } else if ( arv_evaluator_token_is_operator ( token ) ) { while ( state -> operator_stack != NULL && arv_evaluator_token_compare_precedence ( token , state -> operator_stack -> data ) ) { state -> token_stack = g_slist_prepend ( state -> token_stack , state -> operator_stack -> data ) ; state -> operator_stack = g_slist_delete_link ( state -> operator_stack , state -> operator_stack ) ; } state -> operator_stack = g_slist_prepend ( state -> operator_stack , token ) ; } else if ( arv_evaluator_token_is_left_parenthesis ( token ) ) { <S2SV_StartBug> state -> operator_stack = g_slist_prepend ( state -> operator_stack , token ) ; <S2SV_EndBug> state -> token_stack = g_slist_prepend ( state -> token_stack , state -> operator_stack -> data ) ; } else if ( arv_evaluator_token_is_right_parenthesis ( token ) ) { while ( state -> operator_stack != NULL && ! arv_evaluator_token_is_left_parenthesis ( state -> operator_stack -> data ) ) { state -> token_stack = g_slist_prepend ( state -> token_stack , state -> operator_stack -> data ) ; state -> operator_stack = g_slist_delete_link ( state -> operator_stack , state -> operator_stack ) ; } if ( state -> operator_stack == NULL ) { status = ARV_EVALUATOR_STATUS_PARENTHESES_MISMATCH ; goto CLEANUP ; } <S2SV_StartBug> state -> token_stack = g_slist_prepend ( state -> token_stack , token ) ; <S2SV_EndBug> state -> operator_stack = g_slist_delete_link ( state -> operator_stack , state -> operator_stack ) ; } else { status = ARV_EVALUATOR_STATUS_SYNTAX_ERROR ; goto CLEANUP ; } ( state -> count ) ++ ; } else if ( * expression != '\\0' ) { status = ARV_EVALUATOR_STATUS_SYNTAX_ERROR ; goto CLEANUP ; } else { token_found = FALSE ; } } while ( token_found ) ; return ARV_EVALUATOR_STATUS_SUCCESS ; CLEANUP : if ( token != NULL ) arv_evaluator_token_free ( token ) ; return status ; } | <S2SV_ModStart> ) ) { ArvEvaluatorToken * clone = arv_evaluator_token_new ( token -> token_id ) ; clone -> data = token -> data ; state -> operator_stack = g_slist_prepend ( state -> operator_stack , clone ) ; state -> token_stack = g_slist_prepend ( state -> token_stack , token <S2SV_ModEnd> ) ; } <S2SV_ModStart> token_stack , token ) ; state -> garbage_stack = g_slist_prepend ( state -> garbage_stack , state -> operator_stack -> data |
3,787 | CWE-000 float getConfidenceHyp ( int expect , int size , float p , int stat_size ) { if ( expect > size ) { return 0 ; } float mu = size * p ; float sig = sqrt ( size * p * ( 1.0 - p ) ) * ( ( ( float ) stat_size - size ) / ( ( float ) stat_size - 1.0 ) ) ; <S2SV_StartBug> return 1.0 - 0.5 * ( 1.0 + erf ( ( expect - 0.5 - mu ) / sig ) ) ; <S2SV_EndBug> } | <S2SV_ModStart> erf ( ( ( ( float ) expect ) <S2SV_ModEnd> - 0.5 - <S2SV_ModStart> mu ) / ( sig * sqrt ( 2 ) ) <S2SV_ModEnd> ) ) ; |
3,788 | CWE-000 void insertrowbelowcell ( GtkWidget * widget , gpointer data ) { int i ; Spreadsheet * tmp = ( Spreadsheet * ) data ; GtkWidget * buf ; if ( tmp -> active . row < 0 ) { gtk_label_set_text ( GTK_LABEL ( tmp -> message ) , "Please<S2SV_blank>select<S2SV_blank>a<S2SV_blank>cell<S2SV_blank>first<S2SV_blank>!" ) ; return ; } gtk_grid_insert_row ( GTK_GRID ( tmp -> grid ) , tmp -> active . row + 1 ) ; <S2SV_StartBug> for ( i = 0 ; i <= tmp -> max . col ; i ++ ) { <S2SV_EndBug> buf = gtk_button_new_with_label ( "<S2SV_blank>" ) ; tmp -> context = gtk_widget_get_style_context ( buf ) ; gtk_style_context_add_class ( tmp -> context , "cell" ) ; gtk_grid_attach ( GTK_GRID ( tmp -> grid ) , buf , i , tmp -> active . row + 1 , 1 , 1 ) ; g_signal_connect ( buf , "clicked" , G_CALLBACK ( cellClicked ) , tmp ) ; g_signal_connect ( buf , "focus" , G_CALLBACK ( cellFocussed ) , tmp ) ; <S2SV_StartBug> } <S2SV_EndBug> gtk_widget_show_all ( window ) ; return ; } | <S2SV_ModStart> 0 ; i < <S2SV_ModEnd> tmp -> max <S2SV_ModStart> ) ; } tmp -> max . row ++ ; |
3,789 | CWE-000 static int driveGrabbing ( void ) { u32 control ; u32 prevLastWrite ; u32 nextWrite ; u32 last_write_chk_buf ; if ( qcdma . bufs_cnt == 0 ) return - 1 ; while ( ! qcdma . stop_grabbing ) { if ( sensor_dma_getreg ( Status ) & ImageDone ) { prevLastWrite = qcdma . last_write ; last_write_chk_buf = qcdma . last_write + 2 ; if ( last_write_chk_buf >= qcdma . bufs_cnt ) last_write_chk_buf -= ( qcdma . bufs_cnt - 1 ) ; if ( last_write_chk_buf == qcdma . last_read ) { qcdma . frame_skipped = true ; if ( qcdma . last_read == qcdma . bufs_cnt - 1 ) qcdma . last_read = 0 ; else ++ qcdma . last_read ; } if ( qcdma . last_write == qcdma . bufs_cnt - 1 ) qcdma . last_write = 0 ; else ++ qcdma . last_write ; if ( prevLastWrite == qcdma . last_read ) qcdma . frame_ready = true ; if ( qcdma . last_write == qcdma . bufs_cnt - 1 ) nextWrite = 0 ; else nextWrite = qcdma . last_write + 1 ; sensor_dma_setreg ( Pointer0 , qcdma . bufs_raw [ nextWrite ] ) ; control = sensor_dma_getreg ( Control ) ; sensor_dma_setreg ( Control , control | IrqAck ) ; sensor_dma_setreg ( Control , control | Start ) ; if ( sensor_dma_getreg ( Status ) & ImageDone ) { msleep ( 100 ) ; } if ( sensor_dma_getreg ( Status ) & ImageDone ) { msleep ( 1000 ) ; } wake_up_interruptible ( & frame_wait ) ; } else { usleep_range ( 100 , 200 ) ; } } wake_up_interruptible ( & frame_wait ) ; msleep ( 10 ) ; qcdma . stop_grabbing = false ; qcdma . grabbing = false ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> = false ; qcdma . frame_ready = false ; |
3,790 | CWE-000 static void _add_message_to_batch ( HTTPDestinationDriver * self , LogMessage * msg ) <S2SV_StartBug> { <S2SV_EndBug> if ( self -> body_template ) { log_template_append_format ( self -> body_template , msg , & self -> template_options , LTZ_SEND , self -> super . seq_num , NULL , self -> request_body ) ; } else { <S2SV_StartBug> if ( self -> request_body -> len ) <S2SV_EndBug> g_string_append_c ( self -> request_body , '\\n' ) ; g_string_append ( self -> request_body , log_msg_get_value ( msg , LM_V_MESSAGE , NULL ) ) ; } } | <S2SV_ModStart> msg ) { if ( self -> super . batch_size > 1 ) { g_string_append_len ( self -> request_body , self -> delimiter -> str , self -> delimiter -> len ) ; } <S2SV_ModStart> } else { <S2SV_ModEnd> g_string_append ( self |
3,791 | CWE-000 void NDSTouchscreenMode ( ) { u8 volLevel ; if ( fifoCheckValue32 ( FIFO_USER_01 ) ) { volLevel = 0xAC ; } else { volLevel = 0xA7 ; } <S2SV_StartBug> readTSCReg ( 0 ) ; <S2SV_EndBug> writeTSCReg ( 0 , 0 ) ; writeTSCReg ( 0x3a , 0 ) ; readTSCReg ( 0x51 ) ; writeTSCReg ( 3 , 0 ) ; readTSCReg ( 2 ) ; writeTSCReg ( 0 , 0 ) ; readTSCReg ( 0x3f ) ; writeTSCReg ( 0 , 1 ) ; readTSCReg ( 0x38 ) ; readTSCReg ( 0x2a ) ; readTSCReg ( 0x2E ) ; writeTSCReg ( 0 , 0 ) ; writeTSCReg ( 0x52 , 0x80 ) ; writeTSCReg ( 0x40 , 0xC ) ; writeTSCReg ( 0 , 1 ) ; writeTSCReg ( 0x24 , 0xff ) ; writeTSCReg ( 0x25 , 0xff ) ; writeTSCReg ( 0x26 , 0x7f ) ; writeTSCReg ( 0x27 , 0x7f ) ; writeTSCReg ( 0x28 , 0x4a ) ; writeTSCReg ( 0x29 , 0x4a ) ; writeTSCReg ( 0x2a , 0x10 ) ; writeTSCReg ( 0x2b , 0x10 ) ; writeTSCReg ( 0 , 0 ) ; writeTSCReg ( 0x51 , 0 ) ; writeTSCReg ( 0 , 3 ) ; readTSCReg ( 2 ) ; writeTSCReg ( 2 , 0x98 ) ; writeTSCReg ( 0 , 1 ) ; writeTSCReg ( 0x23 , 0 ) ; writeTSCReg ( 0x1f , 0x14 ) ; writeTSCReg ( 0x20 , 0x14 ) ; writeTSCReg ( 0 , 0 ) ; writeTSCReg ( 0x3f , 0 ) ; readTSCReg ( 0x0b ) ; writeTSCReg ( 0x5 , 0 ) ; writeTSCReg ( 0xb , 0x1 ) ; writeTSCReg ( 0xc , 0x2 ) ; writeTSCReg ( 0x12 , 0x1 ) ; writeTSCReg ( 0x13 , 0x2 ) ; writeTSCReg ( 0 , 1 ) ; writeTSCReg ( 0x2E , 0x00 ) ; writeTSCReg ( 0 , 0 ) ; writeTSCReg ( 0x3A , 0x60 ) ; writeTSCReg ( 0x01 , 01 ) ; writeTSCReg ( 0x9 , 0x66 ) ; writeTSCReg ( 0 , 1 ) ; readTSCReg ( 0x20 ) ; writeTSCReg ( 0x20 , 0x10 ) ; writeTSCReg ( 0 , 0 ) ; writeTSCReg ( 04 , 00 ) ; writeTSCReg ( 0x12 , 0x81 ) ; writeTSCReg ( 0x13 , 0x82 ) ; writeTSCReg ( 0x51 , 0x82 ) ; writeTSCReg ( 0x51 , 0x00 ) ; writeTSCReg ( 0x04 , 0x03 ) ; writeTSCReg ( 0x05 , 0xA1 ) ; writeTSCReg ( 0x06 , 0x15 ) ; writeTSCReg ( 0x0B , 0x87 ) ; writeTSCReg ( 0x0C , 0x83 ) ; writeTSCReg ( 0x12 , 0x87 ) ; writeTSCReg ( 0x13 , 0x83 ) ; writeTSCReg ( 0 , 3 ) ; readTSCReg ( 0x10 ) ; writeTSCReg ( 0x10 , 0x08 ) ; writeTSCReg ( 0 , 4 ) ; writeTSCReg ( 0x08 , 0x7F ) ; writeTSCReg ( 0x09 , 0xE1 ) ; writeTSCReg ( 0xa , 0x80 ) ; writeTSCReg ( 0xb , 0x1F ) ; writeTSCReg ( 0xc , 0x7F ) ; writeTSCReg ( 0xd , 0xC1 ) ; writeTSCReg ( 0 , 0 ) ; writeTSCReg ( 0x41 , 0x08 ) ; writeTSCReg ( 0x42 , 0x08 ) ; writeTSCReg ( 0x3A , 0x00 ) ; writeTSCReg ( 0 , 4 ) ; writeTSCReg ( 0x08 , 0x7F ) ; writeTSCReg ( 0x09 , 0xE1 ) ; writeTSCReg ( 0xa , 0x80 ) ; writeTSCReg ( 0xb , 0x1F ) ; writeTSCReg ( 0xc , 0x7F ) ; writeTSCReg ( 0xd , 0xC1 ) ; writeTSCReg ( 0 , 1 ) ; writeTSCReg ( 0x2F , 0x2B ) ; writeTSCReg ( 0x30 , 0x40 ) ; writeTSCReg ( 0x31 , 0x40 ) ; writeTSCReg ( 0x32 , 0x60 ) ; writeTSCReg ( 0 , 0 ) ; readTSCReg ( 0x74 ) ; writeTSCReg ( 0x74 , 0x02 ) ; readTSCReg ( 0x74 ) ; writeTSCReg ( 0x74 , 0x10 ) ; readTSCReg ( 0x74 ) ; writeTSCReg ( 0x74 , 0x40 ) ; writeTSCReg ( 0 , 1 ) ; writeTSCReg ( 0x21 , 0x20 ) ; writeTSCReg ( 0x22 , 0xF0 ) ; writeTSCReg ( 0 , 0 ) ; readTSCReg ( 0x51 ) ; readTSCReg ( 0x3f ) ; writeTSCReg ( 0x3f , 0xd4 ) ; writeTSCReg ( 0 , 1 ) ; writeTSCReg ( 0x23 , 0x44 ) ; writeTSCReg ( 0x1F , 0xD4 ) ; writeTSCReg ( 0x28 , 0x4e ) ; writeTSCReg ( 0x29 , 0x4e ) ; writeTSCReg ( 0x24 , 0x9e ) ; writeTSCReg ( 0x24 , 0x9e ) ; writeTSCReg ( 0x20 , 0xD4 ) ; writeTSCReg ( 0x2a , 0x14 ) ; writeTSCReg ( 0x2b , 0x14 ) ; <S2SV_StartBug> writeTSCReg ( 0x26 , volLevel + 0x10 ) ; <S2SV_EndBug> <S2SV_StartBug> writeTSCReg ( 0x27 , volLevel + 0x10 ) ; <S2SV_EndBug> writeTSCReg ( 0 , 0 ) ; writeTSCReg ( 0x40 , 0 ) ; writeTSCReg ( 0x3a , 0x60 ) ; writeTSCReg ( 0 , 1 ) ; <S2SV_StartBug> writeTSCReg ( 0x26 , volLevel + 0x10 ) ; <S2SV_EndBug> <S2SV_StartBug> writeTSCReg ( 0x27 , volLevel + 0x10 ) ; <S2SV_EndBug> writeTSCReg ( 0x2e , 0x03 ) ; writeTSCReg ( 0 , 3 ) ; writeTSCReg ( 3 , 0 ) ; writeTSCReg ( 0 , 1 ) ; writeTSCReg ( 0x21 , 0x20 ) ; writeTSCReg ( 0x22 , 0xF0 ) ; readTSCReg ( 0x22 ) ; writeTSCReg ( 0x22 , 0xF0 ) ; writeTSCReg ( 0 , 0 ) ; writeTSCReg ( 0x52 , 0x80 ) ; writeTSCReg ( 0x51 , 0x00 ) ; writeTSCReg ( 0 , 3 ) ; readTSCReg ( 0x02 ) ; writeTSCReg ( 2 , 0x98 ) ; writeTSCReg ( 0 , 0xff ) ; writeTSCReg ( 5 , 0 ) ; writePowerManagement ( 0x00 , 0x0D ) ; } | <S2SV_ModStart> 0xA7 ; } volLevel += 0x13 ; <S2SV_ModStart> 0x26 , volLevel <S2SV_ModEnd> ) ; writeTSCReg <S2SV_ModStart> 0x27 , volLevel <S2SV_ModEnd> ) ; writeTSCReg <S2SV_ModStart> 0x26 , volLevel <S2SV_ModEnd> ) ; writeTSCReg <S2SV_ModStart> 0x27 , volLevel <S2SV_ModEnd> ) ; writeTSCReg |
3,792 | CWE-000 static int nft_run_cmd_from_buffer ( struct nft_ctx * nft , char * buf , size_t buflen ) { int rc = NFT_EXIT_SUCCESS ; struct parser_state state ; LIST_HEAD ( msgs ) ; <S2SV_StartBug> void * scanner ; <S2SV_EndBug> parser_init ( nft -> nf_sock , & nft -> cache , & state , & msgs , nft -> debug_mask , & nft -> output ) ; scanner = scanner_init ( & state ) ; scanner_push_buffer ( scanner , & indesc_cmdline , buf ) ; if ( nft_run ( nft , nft -> nf_sock , scanner , & state , & msgs ) != 0 ) rc = NFT_EXIT_FAILURE ; <S2SV_StartBug> erec_print_list ( stderr , & msgs , nft -> debug_mask ) ; <S2SV_EndBug> scanner_destroy ( scanner ) ; return rc ; } | <S2SV_ModStart> void * scanner ; FILE * fp <S2SV_ModStart> = NFT_EXIT_FAILURE ; fp = nft_ctx_set_output ( nft , stderr ) ; erec_print_list ( & nft -> output <S2SV_ModEnd> , & msgs <S2SV_ModStart> nft -> debug_mask ) ; nft_ctx_set_output ( nft , fp |
3,793 | CWE-000 FuncP getCurrentCallback ( LinkedList * list ) { <S2SV_StartBug> Item * itemHead = list -> head ; <S2SV_EndBug> TxRxCallbackList * callBackList5 = ( TxRxCallbackList * ) ( itemHead -> data ) ; return callBackList5 -> txRxCallbackFuncP ; } | <S2SV_ModStart> -> head ; if ( itemHead == NULL ) { return NULL ; } |
3,794 | CWE-000 void battering_ram_hit ( edict_t * ent , vec3_t g_offset , int damage ) { vec3_t forward , right , start , offset ; AngleVectors ( ent -> client -> v_angle , forward , right , NULL ) ; VectorSet ( offset , 24 , 8 , ent -> viewheight - 8 ) ; VectorAdd ( offset , g_offset , offset ) ; P_ProjectSource ( ent -> client , ent -> s . origin , offset , forward , right , start ) ; VectorScale ( forward , 5 , ent -> client -> kick_origin ) ; ent -> client -> kick_angles [ 0 ] = - 1 ; <S2SV_StartBug> melee ( ent , start , forward , 250 , damage , 500 , 0 ) ; <S2SV_EndBug> } | <S2SV_ModStart> , damage , 50 <S2SV_ModEnd> , 0 ) |
3,795 | CWE-000 static LY_ERR parse_identity ( struct ly_parser_ctx * ctx , const char * * data , struct lysp_ident * * identities ) { LY_ERR ret = 0 ; char * buf , * word ; size_t word_len ; enum yang_keyword kw ; struct lysp_ident * ident ; LYSP_ARRAY_NEW_RET ( ctx , identities , ident , LY_EMEM ) ; ret = get_argument ( ctx , data , Y_IDENTIF_ARG , & word , & buf , & word_len ) ; LY_CHECK_RET ( ret ) ; INSERT_WORD ( ctx , buf , ident -> name , word , word_len ) ; YANG_READ_SUBSTMT_FOR ( ctx , data , kw , word , word_len , ret ) { LY_CHECK_RET ( ret ) ; switch ( kw ) { case YANG_DESCRIPTION : ret = parse_text_field ( ctx , data , LYEXT_SUBSTMT_DESCRIPTION , 0 , & ident -> dsc , Y_STR_ARG , & ident -> exts ) ; break ; case YANG_IF_FEATURE : ret = parse_text_fields ( ctx , data , LYEXT_SUBSTMT_IFFEATURE , & ident -> iffeatures , Y_STR_ARG , & ident -> exts ) ; break ; case YANG_REFERENCE : ret = parse_text_field ( ctx , data , LYEXT_SUBSTMT_REFERENCE , 0 , & ident -> ref , Y_STR_ARG , & ident -> exts ) ; break ; case YANG_STATUS : ret = parse_status ( ctx , data , & ident -> flags , & ident -> exts ) ; break ; case YANG_BASE : ret = parse_text_fields ( ctx , data , LYEXT_SUBSTMT_BASE , & ident -> bases , Y_PREF_IDENTIF_ARG , & ident -> exts ) ; break ; case YANG_CUSTOM : ret = parse_ext ( ctx , data , word , word_len , LYEXT_SUBSTMT_SELF , 0 , & ident -> exts ) ; break ; default : LOGVAL_YANG ( ctx , LY_VCODE_INCHILDSTMT , ly_stmt2str ( kw ) , "identity" ) ; return LY_EVALID ; } LY_CHECK_RET ( ret ) ; } <S2SV_StartBug> LY_CHECK_RET ( ret ) ; <S2SV_EndBug> return ret ; } | <S2SV_ModStart> ) ; } <S2SV_ModEnd> return ret ; |
3,796 | CWE-000 PetscErrorCode DataBucketView_SEQ ( DataBucket db , const char filename [ ] , DataBucketViewType type ) { PetscErrorCode ierr ; PetscFunctionBegin ; switch ( type ) { case DATABUCKET_VIEW_STDOUT : { PetscInt f ; double memory_usage_total = 0.0 ; ierr = PetscPrintf ( PETSC_COMM_SELF , "DataBucketView(SEQ):<S2SV_blank>(\\"%s\\")\\n" , filename ) ; CHKERRQ ( ierr ) ; ierr = PetscPrintf ( PETSC_COMM_SELF , "<S2SV_blank><S2SV_blank>L<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>=<S2SV_blank>%D<S2SV_blank>\\n" , db -> L ) ; CHKERRQ ( ierr ) ; ierr = PetscPrintf ( PETSC_COMM_SELF , "<S2SV_blank><S2SV_blank>buffer<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>=<S2SV_blank>%D<S2SV_blank>\\n" , db -> buffer ) ; CHKERRQ ( ierr ) ; ierr = PetscPrintf ( PETSC_COMM_SELF , "<S2SV_blank><S2SV_blank>allocated<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>=<S2SV_blank>%D<S2SV_blank>\\n" , db -> allocated ) ; CHKERRQ ( ierr ) ; ierr = PetscPrintf ( PETSC_COMM_SELF , "<S2SV_blank><S2SV_blank>nfields<S2SV_blank>registered<S2SV_blank>=<S2SV_blank>%D<S2SV_blank>\\n" , db -> nfields ) ; CHKERRQ ( ierr ) ; for ( f = 0 ; f < db -> nfields ; ++ f ) { double memory_usage_f = ( double ) ( db -> field [ f ] -> atomic_size * db -> allocated ) * 1.0e-6 ; ierr = PetscPrintf ( PETSC_COMM_SELF , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[%3D]:<S2SV_blank>field<S2SV_blank>name<S2SV_blank><S2SV_blank>==>><S2SV_blank>%30s<S2SV_blank>:<S2SV_blank>Mem.<S2SV_blank>usage<S2SV_blank>=<S2SV_blank>%1.2e<S2SV_blank>(MB)<S2SV_blank>\\n" , f , db -> field [ f ] -> name , memory_usage_f ) ; CHKERRQ ( ierr ) ; ierr = PetscPrintf ( PETSC_COMM_SELF , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>blocksize<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>=<S2SV_blank>%D<S2SV_blank>\\n" , db -> field [ f ] -> bs ) ; CHKERRQ ( ierr ) ; if ( db -> field [ f ] -> bs != 1 ) { ierr = PetscPrintf ( PETSC_COMM_SELF , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>atomic<S2SV_blank>size<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>=<S2SV_blank>%zu<S2SV_blank>[full<S2SV_blank>block,<S2SV_blank>bs=%D]\\n" , db -> field [ f ] -> atomic_size , db -> field [ f ] -> bs ) ; CHKERRQ ( ierr ) ; ierr = PetscPrintf ( PETSC_COMM_SELF , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>atomic<S2SV_blank>size/item<S2SV_blank><S2SV_blank><S2SV_blank>=<S2SV_blank>%zu<S2SV_blank>\\n" , db -> field [ f ] -> atomic_size / db -> field [ f ] -> bs ) ; CHKERRQ ( ierr ) ; } else { ierr = PetscPrintf ( PETSC_COMM_SELF , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>atomic<S2SV_blank>size<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>=<S2SV_blank>%zu<S2SV_blank>\\n" , db -> field [ f ] -> atomic_size ) ; CHKERRQ ( ierr ) ; } memory_usage_total += memory_usage_f ; } ierr = PetscPrintf ( PETSC_COMM_SELF , "<S2SV_blank><S2SV_blank>Total<S2SV_blank>mem.<S2SV_blank>usage<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>=<S2SV_blank>%1.2e<S2SV_blank>(MB)<S2SV_blank>\\n" , memory_usage_total ) ; CHKERRQ ( ierr ) ; } break ; case DATABUCKET_VIEW_ASCII : <S2SV_StartBug> { <S2SV_EndBug> <S2SV_StartBug> SETERRQ ( PETSC_COMM_SELF , PETSC_ERR_SUP , "Cannot<S2SV_blank>be<S2SV_blank>implemented<S2SV_blank>as<S2SV_blank>we<S2SV_blank>don\'t<S2SV_blank>know<S2SV_blank>the<S2SV_blank>underlying<S2SV_blank>particle<S2SV_blank>data<S2SV_blank>structure" ) ; <S2SV_EndBug> } break ; case DATABUCKET_VIEW_BINARY : <S2SV_StartBug> { <S2SV_EndBug> ierr = _DataBucketViewBinary ( db , filename ) ; CHKERRQ ( ierr ) ; } break ; case DATABUCKET_VIEW_HDF5 : <S2SV_StartBug> { <S2SV_EndBug> <S2SV_StartBug> SETERRQ ( PETSC_COMM_SELF , PETSC_ERR_SUP , "No<S2SV_blank>HDF5<S2SV_blank>support" ) ; <S2SV_EndBug> } break ; default : SETERRQ ( PETSC_COMM_SELF , PETSC_ERR_SUP , "Unknown<S2SV_blank>viewer<S2SV_blank>method<S2SV_blank>requested" ) ; } PetscFunctionReturn ( 0 ) ; } | <S2SV_ModStart> case DATABUCKET_VIEW_ASCII : <S2SV_ModEnd> SETERRQ ( PETSC_COMM_SELF <S2SV_ModStart> , PETSC_ERR_SUP , "No<S2SV_blank>support<S2SV_blank>for<S2SV_blank>ascii<S2SV_blank>output" ) ; <S2SV_ModEnd> break ; case <S2SV_ModStart> case DATABUCKET_VIEW_BINARY : SETERRQ ( PETSC_COMM_SELF , PETSC_ERR_SUP , "No<S2SV_blank>support<S2SV_blank>for<S2SV_blank>binary<S2SV_blank>output" ) ; <S2SV_ModEnd> break ; case <S2SV_ModStart> case DATABUCKET_VIEW_HDF5 : <S2SV_ModEnd> SETERRQ ( PETSC_COMM_SELF <S2SV_ModStart> , PETSC_ERR_SUP , "No<S2SV_blank>support<S2SV_blank>for<S2SV_blank>HDF5<S2SV_blank>output" ) ; <S2SV_ModEnd> break ; default |
3,797 | CWE-000 int br_is_device_wired ( const char * mac ) { <S2SV_StartBug> if ( ! is_valid_mac ( mac ) ) <S2SV_EndBug> return is_device_wired_intern ( mac , config_get_config ( ) -> gw_interface ) ; return 0 ; } | <S2SV_ModStart> { if ( <S2SV_ModEnd> is_valid_mac ( mac |
3,798 | CWE-000 int mpv_opengl_cb_uninit_gl ( struct mpv_opengl_cb_context * ctx ) { if ( ! ctx ) return 0 ; pthread_mutex_lock ( & ctx -> lock ) ; forget_frames ( ctx , true ) ; ctx -> initialized = false ; pthread_mutex_unlock ( & ctx -> lock ) ; kill_video ( ctx -> client_api ) ; pthread_mutex_lock ( & ctx -> lock ) ; assert ( ! ctx -> active ) ; pthread_mutex_unlock ( & ctx -> lock ) ; gl_video_uninit ( ctx -> renderer ) ; ctx -> renderer = NULL ; ra_hwdec_uninit ( ctx -> hwdec ) ; ctx -> hwdec = NULL ; hwdec_devices_destroy ( ctx -> hwdec_devs ) ; ctx -> hwdec_devs = NULL ; <S2SV_StartBug> ra_ctx_destroy ( & ctx -> ra_ctx ) ; <S2SV_EndBug> talloc_free ( ctx -> gl ) ; <S2SV_StartBug> ctx -> gl = NULL ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> = NULL ; ra_gl_ctx_uninit ( ctx -> ra_ctx ) ; talloc_free ( <S2SV_ModEnd> ctx -> ra_ctx <S2SV_ModStart> ; ctx -> ra_ctx = NULL ; ctx -> |
3,799 | CWE-000 char gr_getch ( ) { gr_refresh ( ) ; uint32_t ticks = gr_getms ( ) ; if ( tout_num && end <= ticks ) end = tout_num + ticks ; if ( tout_num == 0 ) end = 0 ; SDL_Event sdlEvent ; while ( 1 ) { if ( end && gr_getms ( ) >= end ) { end = 0 ; break ; } if ( ! SDL_PollEvent ( & sdlEvent ) ) { if ( gr_onidle ) gr_onidle ( ) ; if ( cur_key_down && gr_getms ( ) >= key_fire_ms ) { key_fire_ms = gr_getms ( ) + gr_kdelay ; return cur_key_down ; } gr_wait ( 10 ) ; continue ; } char input_key = 0 ; switch ( sdlEvent . type ) { case SDL_TEXTINPUT : input_key = sdlEvent . text . text [ 0 ] ; break ; case SDL_KEYDOWN : { <S2SV_StartBug> uint32_t mod = sdlEvent . key . keysym . mod << 16 ; <S2SV_EndBug> SDL_Keycode code = sdlEvent . key . keysym . sym ; if ( code == SDLK_UP ) input_key = mod | GRK_UP ; else if ( code == SDLK_DOWN ) input_key = mod | GRK_DN ; else if ( code == SDLK_LEFT ) input_key = mod | GRK_LF ; else if ( code == SDLK_RIGHT ) input_key = mod | GRK_RT ; else if ( code == SDLK_RETURN ) input_key = mod | CH_LF ; else if ( code == SDLK_BACKSPACE ) input_key = mod | CH_BS ; else if ( code == SDLK_ESCAPE ) input_key = mod | CH_ESC ; break ; } case SDL_KEYUP : <S2SV_StartBug> cur_key_down = 0 ; <S2SV_EndBug> break ; case SDL_QUIT : exit ( 0 ) ; default : break ; } if ( input_key && input_key == cur_key_down ) continue ; else if ( input_key ) { cur_key_down = input_key ; key_fire_ms = gr_getms ( ) + gr_kinitdelay ; return input_key ; } } return EOF ; } | <S2SV_ModStart> SDL_KEYDOWN : { if ( sdlEvent . key . repeat ) break ; ++ num_keys_down ; <S2SV_ModStart> case SDL_KEYUP : -- num_keys_down ; if ( ! num_keys_down ) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.