Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
6,100 | CWE-000 static int handle_lan_get_msg_cmd ( struct ipmi_smi * intf , struct ipmi_smi_msg * msg ) { struct cmd_rcvr * rcvr ; int rv = 0 ; unsigned char netfn ; unsigned char cmd ; unsigned char chan ; struct ipmi_user * user = NULL ; struct ipmi_lan_addr * lan_addr ; struct ipmi_recv_msg * recv_msg ; if ( msg -> rsp_size < 12 ) { ipmi_inc_stat ( intf , invalid_commands ) ; return 0 ; } if ( msg -> rsp [ 2 ] != 0 ) { return 0 ; } netfn = msg -> rsp [ 6 ] >> 2 ; cmd = msg -> rsp [ 10 ] ; chan = msg -> rsp [ 3 ] & 0xf ; rcu_read_lock ( ) ; rcvr = find_cmd_rcvr ( intf , netfn , cmd , chan ) ; if ( rcvr ) { user = rcvr -> user ; kref_get ( & user -> refcount ) ; } else user = NULL ; rcu_read_unlock ( ) ; if ( user == NULL ) { ipmi_inc_stat ( intf , unhandled_commands ) ; rv = 0 ; } else { <S2SV_StartBug> ipmi_inc_stat ( intf , handled_commands ) ; <S2SV_EndBug> recv_msg = ipmi_alloc_recv_msg ( ) ; if ( ! recv_msg ) { rv = 1 ; kref_put ( & user -> refcount , free_user ) ; } else { lan_addr = ( struct ipmi_lan_addr * ) & recv_msg -> addr ; lan_addr -> addr_type = IPMI_LAN_ADDR_TYPE ; lan_addr -> session_handle = msg -> rsp [ 4 ] ; lan_addr -> remote_SWID = msg -> rsp [ 8 ] ; lan_addr -> local_SWID = msg -> rsp [ 5 ] ; lan_addr -> lun = msg -> rsp [ 9 ] & 3 ; lan_addr -> channel = msg -> rsp [ 3 ] & 0xf ; lan_addr -> privilege = msg -> rsp [ 3 ] >> 4 ; recv_msg -> user = user ; recv_msg -> recv_type = IPMI_CMD_RECV_TYPE ; recv_msg -> msgid = msg -> rsp [ 9 ] >> 2 ; recv_msg -> msg . netfn = msg -> rsp [ 6 ] >> 2 ; recv_msg -> msg . cmd = msg -> rsp [ 10 ] ; recv_msg -> msg . data = recv_msg -> msg_data ; recv_msg -> msg . data_len = msg -> rsp_size - 12 ; memcpy ( recv_msg -> msg_data , & ( msg -> rsp [ 11 ] ) , msg -> rsp_size - 12 ) ; <S2SV_StartBug> deliver_response ( recv_msg ) ; <S2SV_EndBug> } } return rv ; } | <S2SV_ModStart> } else { <S2SV_ModEnd> recv_msg = ipmi_alloc_recv_msg <S2SV_ModStart> 12 ) ; if ( deliver_response ( intf , recv_msg ) ) ipmi_inc_stat ( intf , unhandled_commands ) ; else ipmi_inc_stat ( intf , handled_commands <S2SV_ModEnd> ) ; } |
6,101 | CWE-000 void lsdn_broadcast_remove ( struct lsdn_broadcast_action * action ) { <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> action ) { action -> filter -> free_actions += action -> action . actions_count ; action -> filter -> actions [ action -> filter_entry_index ] = NULL ; lsdn_flush_action_list ( action -> filter ) ; |
6,102 | CWE-000 static void check_action_changed ( int action_id , const char * update_action ) { if ( ! update_action ) return ; if ( update_action != server_hawkbit . update_action ) { char * notifybuf = NULL ; server_hawkbit . update_action = update_action ; INFO ( "Update<S2SV_blank>classified<S2SV_blank>as<S2SV_blank>\'%s\'<S2SV_blank>by<S2SV_blank>server." , server_hawkbit . update_action ) ; if ( ENOMEM_ASPRINTF == asprintf ( & notifybuf , "{<S2SV_blank>\\"id\\"<S2SV_blank>:<S2SV_blank>\\"%d\\",<S2SV_blank>\\"update\\"<S2SV_blank>:<S2SV_blank>\\"%s\\"}" , action_id , server_hawkbit . update_action ) ) { <S2SV_StartBug> notify ( SUBPROCESS , CHANGE , "Update<S2SV_blank>type<S2SV_blank>changed<S2SV_blank>by<S2SV_blank>server" ) ; <S2SV_EndBug> } else { <S2SV_StartBug> notify ( SUBPROCESS , CHANGE , notifybuf ) ; <S2SV_EndBug> free ( notifybuf ) ; } } } | <S2SV_ModStart> , CHANGE , DEBUGLEVEL , <S2SV_ModStart> SUBPROCESS , CHANGE , DEBUGLEVEL |
6,103 | CWE-000 static inline void msg_done ( struct device * dev , unsigned int flags ) { const struct i2c_stm32_config * cfg = DEV_CFG ( dev ) ; I2C_TypeDef * i2c = cfg -> i2c ; <S2SV_StartBug> if ( ( flags & I2C_MSG_RESTART ) == 0 ) { <S2SV_EndBug> while ( ! LL_I2C_IsActiveFlag_STOP ( i2c ) ) { ; } <S2SV_StartBug> LL_I2C_GenerateStopCondition ( i2c ) ; <S2SV_EndBug> } } | <S2SV_ModStart> ; if ( ! LL_I2C_IsEnabledAutoEndMode ( i2c ) ) { while ( ! LL_I2C_IsActiveFlag_TC ( i2c ) ) { ; } if ( ( flags & I2C_MSG_RESTART ) == 0 ) { LL_I2C_GenerateStopCondition ( i2c ) ; } } if ( <S2SV_ModStart> { ; } LL_I2C_ClearFlag_STOP <S2SV_ModEnd> ( i2c ) |
6,104 | CWE-000 <S2SV_StartBug> int LIBMTP_Get_File_To_File ( LIBMTP_mtpdevice_t * device , uint32_t const id , <S2SV_EndBug> char const * const path , LIBMTP_progressfunc_t const callback , void const * const data ) { int fd = - 1 ; int ret ; if ( path == NULL ) { add_error_to_errorstack ( device , LIBMTP_ERROR_GENERAL , "LIBMTP_Get_File_To_File():<S2SV_blank>Bad<S2SV_blank>arguments,<S2SV_blank>path<S2SV_blank>was<S2SV_blank>NULL." ) ; <S2SV_StartBug> return - 1 ; <S2SV_EndBug> } # ifdef __WIN32__ # ifdef USE_WINDOWS_IO_H if ( ( fd = _open ( path , O_RDWR | O_CREAT | O_TRUNC | O_BINARY , _S_IREAD ) ) == - 1 ) { # else if ( ( fd = open ( path , O_RDWR | O_CREAT | O_TRUNC | O_BINARY , S_IRWXU ) ) == - 1 ) { # endif # else if ( ( fd = open ( path , O_RDWR | O_CREAT | O_TRUNC , S_IRWXU | S_IRGRP ) ) == - 1 ) { # endif add_error_to_errorstack ( device , LIBMTP_ERROR_GENERAL , "LIBMTP_Get_File_To_File():<S2SV_blank>Could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>file." ) ; <S2SV_StartBug> return - 1 ; <S2SV_EndBug> } ret = LIBMTP_Get_File_To_File_Descriptor ( device , id , fd , callback , data ) ; close ( fd ) ; <S2SV_StartBug> if ( ret == - 1 ) { <S2SV_EndBug> unlink ( path ) ; } return ret ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> LIBMTP_err_t <S2SV_ModEnd> LIBMTP_Get_File_To_File ( LIBMTP_mtpdevice_t <S2SV_ModStart> ) ; return LIBMTP_ERR_BAD_PARAM <S2SV_ModEnd> ; } # <S2SV_ModStart> ) ; return LIBMTP_ERR_IO <S2SV_ModEnd> ; } ret <S2SV_ModStart> if ( ret != LIBMTP_OK <S2SV_ModEnd> ) { unlink |
6,105 | CWE-000 char * * separateString ( char input [ ] , char delimiter , int * start , int * error ) { char * tok ; int leftParenthesisCount = 0 , rightParenthesisCount = 0 , length = 0 , delimiterCount = 0 , i = 0 ; char strDelimiter [ 2 ] ; strDelimiter [ 0 ] = delimiter ; strDelimiter [ 1 ] = '\\0' ; input += ( * start + 1 ) ; for ( length = 0 ; input [ length ] ; length ++ ) { if ( input [ length ] == '(' ) { leftParenthesisCount ++ ; } else if ( input [ length ] == ')' ) { rightParenthesisCount ++ ; } if ( input [ length ] == delimiter ) { delimiterCount ++ ; } if ( leftParenthesisCount == rightParenthesisCount ) { break ; } } <S2SV_StartBug> char * input2 = malloc ( length * sizeof ( * input2 ) ) ; <S2SV_EndBug> __MALLOC_CHECK ( input2 , * error ) ; strcpy ( input2 , input ) ; char * * separatedString = malloc ( ( delimiterCount + 2 ) * sizeof ( * separatedString ) ) ; __MALLOC_CHECK ( separatedString , * error ) ; for ( int j = 0 ; j < ( delimiterCount + 2 ) ; j ++ ) { separatedString [ j ] = malloc ( length * sizeof ( * * separatedString ) ) ; __MALLOC_CHECK ( * separatedString , * error ) ; } * start += ( length + 1 ) ; input2 [ length + 1 ] = 0 ; tok = strtok ( input2 , strDelimiter ) ; ++ tok ; for ( i = 0 ; tok != NULL ; i ++ ) { strcpy ( separatedString [ i ] , tok ) ; tok = strtok ( NULL , strDelimiter ) ; } separatedString [ i - 1 ] [ strlen ( separatedString [ i - 1 ] ) - 1 ] = '\\0' ; strcpy ( separatedString [ i ] , "" ) ; free ( input2 ) ; return separatedString ; } | <S2SV_ModStart> = malloc ( ( length + 2 ) <S2SV_ModEnd> * sizeof ( |
6,106 | CWE-000 static void OnPubMatch ( DPS_Subscription * sub , const DPS_Publication * pub , uint8_t * data , size_t len ) { DPS_Status ret ; const DPS_UUID * pubId = DPS_PublicationGetUUID ( pub ) ; uint32_t sn = DPS_PublicationGetSequenceNum ( pub ) ; size_t i ; size_t numTopics ; if ( ! quiet ) { DPS_PRINT ( "Pub<S2SV_blank>%s(%d)<S2SV_blank>matches:\\n" , DPS_UUIDToString ( pubId ) , sn ) ; DPS_PRINT ( "<S2SV_blank><S2SV_blank>pub<S2SV_blank>" ) ; numTopics = DPS_PublicationGetNumTopics ( pub ) ; for ( i = 0 ; i < numTopics ; ++ i ) { if ( i ) { DPS_PRINT ( "<S2SV_blank>|<S2SV_blank>" ) ; } DPS_PRINT ( "%s" , DPS_PublicationGetTopic ( pub , i ) ) ; } DPS_PRINT ( "\\n" ) ; DPS_PRINT ( "<S2SV_blank><S2SV_blank>sub<S2SV_blank>" ) ; numTopics = DPS_SubscriptionGetNumTopics ( sub ) ; for ( i = 0 ; i < numTopics ; ++ i ) { if ( i ) { DPS_PRINT ( "<S2SV_blank>&<S2SV_blank>" ) ; } DPS_PRINT ( "%s" , DPS_SubscriptionGetTopic ( sub , i ) ) ; } DPS_PRINT ( "\\n" ) ; if ( data ) { DPS_PRINT ( "%.*s\\n" , ( int ) len , data ) ; } } if ( DPS_PublicationIsAckRequested ( pub ) ) { char ackMsg [ sizeof ( AckFmt ) + 8 ] ; sprintf ( ackMsg , AckFmt , DPS_GetPortNumber ( DPS_PublicationGetNode ( pub ) ) ) ; DPS_PRINT ( "Sending<S2SV_blank>ack<S2SV_blank>for<S2SV_blank>pub<S2SV_blank>UUID<S2SV_blank>%s(%d)\\n" , DPS_UUIDToString ( DPS_PublicationGetUUID ( pub ) ) , DPS_PublicationGetSequenceNum ( pub ) ) ; DPS_PRINT ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%s\\n" , ackMsg ) ; <S2SV_StartBug> ret = DPS_AckPublication ( pub , ackMsg , sizeof ( ackMsg ) ) ; <S2SV_EndBug> if ( ret != DPS_OK ) { DPS_PRINT ( "Failed<S2SV_blank>to<S2SV_blank>ack<S2SV_blank>pub<S2SV_blank>%s\\n" , DPS_ErrTxt ( ret ) ) ; } } } | <S2SV_ModStart> , ackMsg , strnlen ( ackMsg , <S2SV_ModStart> sizeof ( ackMsg ) |
6,107 | CWE-000 disk disk_open ( const char * path ) { <S2SV_StartBug> syslog ( LOG_INFO , "opening<S2SV_blank>disk<S2SV_blank>\'%s\'" , path ) ; <S2SV_EndBug> disk disk = malloc ( sizeof ( struct disk_info ) ) ; disk -> file = fopen ( path , "r+" ) ; if ( ! disk -> file ) { disk -> file = fopen ( path , "w+" ) ; } if ( ! disk -> file ) { free ( disk ) ; syslog ( LOG_ERR , "failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>disk<S2SV_blank>%s" , path ) ; return NULL ; } fread ( & disk -> superblock , sizeof ( struct superblock ) , 1 , disk -> file ) ; syslog ( LOG_INFO , "opened<S2SV_blank>disk<S2SV_blank>\'%s\'" , path ) ; return disk ; } | <S2SV_ModStart> { syslog ( LOG_DEBUG <S2SV_ModEnd> , "opening<S2SV_blank>disk<S2SV_blank>\'%s\'" , |
6,108 | CWE-000 <S2SV_StartBug> ACMD ( storeall ) <S2SV_EndBug> { <S2SV_StartBug> int i ; <S2SV_EndBug> <S2SV_StartBug> if ( sd -> state . storage_flag != STORAGE_FLAG_NORMAL ) { <S2SV_EndBug> if ( storage -> open ( sd ) == 1 ) { <S2SV_StartBug> clif -> message ( fd , msg_fd ( fd , 1161 ) ) ; <S2SV_EndBug> return false ; } <S2SV_StartBug> } <S2SV_EndBug> <S2SV_StartBug> for ( i = 0 ; i < MAX_INVENTORY ; i ++ ) { <S2SV_EndBug> if ( sd -> status . inventory [ i ] . amount ) { if ( sd -> status . inventory [ i ] . equip != 0 ) pc -> unequipitem ( sd , i , PCUNEQUIPITEM_RECALC | PCUNEQUIPITEM_FORCE ) ; <S2SV_StartBug> storage -> add ( sd , i , sd -> status . inventory [ i ] . amount ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> } storage -> close ( sd ) ; <S2SV_StartBug> clif -> message ( fd , msg_fd ( fd , 1162 ) ) ; <S2SV_EndBug> return true ; } | <S2SV_ModStart> <S2SV_null> ACMD ( clearstorage <S2SV_ModEnd> ) { int <S2SV_ModStart> { int i , j <S2SV_ModStart> state . storage_flag == STORAGE_FLAG_NORMAL <S2SV_ModEnd> ) { clif <S2SV_ModStart> ( fd , 250 <S2SV_ModEnd> ) ) ; <S2SV_ModStart> false ; } j = sd -> status . storage . storage_amount ; <S2SV_ModEnd> for ( i <S2SV_ModStart> ; i < j ; ++ i ) { storage -> delitem <S2SV_ModEnd> ( sd , <S2SV_ModStart> -> status . storage . items <S2SV_ModEnd> [ i ] <S2SV_ModStart> amount ) ; <S2SV_ModEnd> } storage -> <S2SV_ModStart> ( fd , 1394 <S2SV_ModEnd> ) ) ; |
6,109 | CWE-000 fort_table_options_t * create_table_options ( ) { fort_table_options_t * options = ( fort_table_options_t * ) F_CALLOC ( sizeof ( fort_table_options_t ) , 1 ) ; if ( options == NULL ) { return NULL ; } memcpy ( options , & g_table_options , sizeof ( fort_table_options_t ) ) ; options -> cell_options = create_cell_opt_container ( ) ; if ( options -> cell_options == NULL ) { destroy_table_options ( options ) ; <S2SV_StartBug> options = NULL ; <S2SV_EndBug> } memcpy ( & options -> entire_table_options , & g_entire_table_options , sizeof ( fort_entire_table_options_t ) ) ; return options ; } | <S2SV_ModStart> options ) ; return <S2SV_ModEnd> NULL ; } |
6,110 | CWE-000 Stmt * parse_case_body ( Context * context , Scope * scope , Token * t , u32 * length ) { Token * t_start = t ; Stmt * body = null ; if ( t [ 0 ] . kind == TOKEN_BRACKET_CURLY_OPEN ) { t += 1 ; u32 body_length ; body = parse_stmts ( context , scope , t , & body_length , false ) ; t += body_length ; if ( body == null ) { * length = t - t_start ; return null ; } if ( ! expect_single_token ( context , t , '}' , "after<S2SV_blank>case" ) ) { * length = t - t_start ; return null ; } <S2SV_StartBug> } else { <S2SV_EndBug> u32 body_length ; body = parse_stmts ( context , scope , t , & body_length , true ) ; t += body_length ; if ( body == null ) { * length = t - t_start ; return null ; } } * length = t - t_start ; return body ; } | <S2SV_ModStart> null ; } t += 1 ; |
6,111 | CWE-000 static void _doh_read_cb ( void * arg ) { _doh_upstream * self = ( _doh_upstream * ) arg ; int rv ; DEBUG_STUB ( "%s<S2SV_blank>%-35s:<S2SV_blank>FD:<S2SV_blank><S2SV_blank>%d\\n" , STUB_DEBUG_READ , __FUNC__ , self -> super . super . fd ) ; <S2SV_StartBug> if ( ( rv = nghttp2_session_recv ( self -> session ) ) ) { <S2SV_EndBug> UP_ERR ( & self -> super . super . super , "Could<S2SV_blank>not<S2SV_blank>recv:<S2SV_blank>\\"%s\\"" , nghttp2_strerror ( rv ) ) ; UPSTREAM_ERRED ( & self -> super . super . super ) ; return ; } <S2SV_StartBug> if ( ! self -> session ) <S2SV_EndBug> <S2SV_StartBug> return ; <S2SV_EndBug> if ( ( rv = nghttp2_session_send ( self -> session ) ) ) { UP_ERR ( & self -> super . super . super , "Could<S2SV_blank>not<S2SV_blank>send:<S2SV_blank>\\"%s\\"" , nghttp2_strerror ( rv ) ) ; UPSTREAM_ERRED ( & self -> super . super . super ) ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> fd ) ; self -> erred = 0 ; <S2SV_ModStart> } if ( self -> erred ) { UPSTREAM_ERRED ( & self -> super . super . super ) ; return ; } if ( ( rv = nghttp2_session_send ( <S2SV_ModEnd> self -> session <S2SV_ModStart> -> session ) <S2SV_ModEnd> ) ) { <S2SV_ModStart> ) ; } if ( self -> erred ) UPSTREAM_ERRED ( & self -> super . super . super ) ; |
6,112 | CWE-000 int ompi_coll_base_bcast_intra_generic ( void * buffer , int original_count , struct ompi_datatype_t * datatype , int root , struct ompi_communicator_t * comm , mca_coll_base_module_t * module , uint32_t count_by_segment , ompi_coll_tree_t * tree ) { int err = 0 , line , i , rank , segindex , req_index ; int num_segments ; int sendcount ; size_t realsegsize , type_size ; char * tmpbuf ; ptrdiff_t extent , lb ; ompi_request_t * recv_reqs [ 2 ] = { MPI_REQUEST_NULL , MPI_REQUEST_NULL } ; ompi_request_t * * send_reqs = NULL ; # if OPAL_ENABLE_DEBUG int size ; size = ompi_comm_size ( comm ) ; assert ( size > 1 ) ; # endif rank = ompi_comm_rank ( comm ) ; ompi_datatype_get_extent ( datatype , & lb , & extent ) ; ompi_datatype_type_size ( datatype , & type_size ) ; num_segments = ( original_count + count_by_segment - 1 ) / count_by_segment ; realsegsize = ( ptrdiff_t ) count_by_segment * extent ; tmpbuf = ( char * ) buffer ; if ( tree -> tree_nextsize != 0 ) { <S2SV_StartBug> send_reqs = coll_base_comm_get_reqs ( module -> base_data , tree -> tree_nextsize ) ; <S2SV_EndBug> if ( NULL == send_reqs ) { err = OMPI_ERR_OUT_OF_RESOURCE ; line = __LINE__ ; goto error_hndl ; } } if ( rank == root ) { sendcount = count_by_segment ; for ( segindex = 0 ; segindex < num_segments ; segindex ++ ) { if ( segindex == ( num_segments - 1 ) ) { sendcount = original_count - segindex * count_by_segment ; } for ( i = 0 ; i < tree -> tree_nextsize ; i ++ ) { err = MCA_PML_CALL ( isend ( tmpbuf , sendcount , datatype , tree -> tree_next [ i ] , MCA_COLL_BASE_TAG_BCAST , MCA_PML_BASE_SEND_STANDARD , comm , & send_reqs [ i ] ) ) ; if ( err != MPI_SUCCESS ) { line = __LINE__ ; goto error_hndl ; } } err = ompi_request_wait_all ( tree -> tree_nextsize , send_reqs , MPI_STATUSES_IGNORE ) ; if ( err != MPI_SUCCESS ) { line = __LINE__ ; goto error_hndl ; } tmpbuf += realsegsize ; } } else if ( tree -> tree_nextsize > 0 ) { req_index = 0 ; err = MCA_PML_CALL ( irecv ( tmpbuf , count_by_segment , datatype , tree -> tree_prev , MCA_COLL_BASE_TAG_BCAST , comm , & recv_reqs [ req_index ] ) ) ; if ( err != MPI_SUCCESS ) { line = __LINE__ ; goto error_hndl ; } for ( segindex = 1 ; segindex < num_segments ; segindex ++ ) { req_index = req_index ^ 0x1 ; err = MCA_PML_CALL ( irecv ( tmpbuf + realsegsize , count_by_segment , datatype , tree -> tree_prev , MCA_COLL_BASE_TAG_BCAST , comm , & recv_reqs [ req_index ] ) ) ; if ( err != MPI_SUCCESS ) { line = __LINE__ ; goto error_hndl ; } err = ompi_request_wait ( & recv_reqs [ req_index ^ 0x1 ] , MPI_STATUS_IGNORE ) ; if ( err != MPI_SUCCESS ) { line = __LINE__ ; goto error_hndl ; } for ( i = 0 ; i < tree -> tree_nextsize ; i ++ ) { err = MCA_PML_CALL ( isend ( tmpbuf , count_by_segment , datatype , tree -> tree_next [ i ] , MCA_COLL_BASE_TAG_BCAST , MCA_PML_BASE_SEND_STANDARD , comm , & send_reqs [ i ] ) ) ; if ( err != MPI_SUCCESS ) { line = __LINE__ ; goto error_hndl ; } } err = ompi_request_wait_all ( tree -> tree_nextsize , send_reqs , MPI_STATUSES_IGNORE ) ; if ( err != MPI_SUCCESS ) { line = __LINE__ ; goto error_hndl ; } tmpbuf += realsegsize ; } err = ompi_request_wait ( & recv_reqs [ req_index ] , MPI_STATUS_IGNORE ) ; if ( err != MPI_SUCCESS ) { line = __LINE__ ; goto error_hndl ; } sendcount = original_count - ( ptrdiff_t ) ( num_segments - 1 ) * count_by_segment ; for ( i = 0 ; i < tree -> tree_nextsize ; i ++ ) { err = MCA_PML_CALL ( isend ( tmpbuf , sendcount , datatype , tree -> tree_next [ i ] , MCA_COLL_BASE_TAG_BCAST , MCA_PML_BASE_SEND_STANDARD , comm , & send_reqs [ i ] ) ) ; if ( err != MPI_SUCCESS ) { line = __LINE__ ; goto error_hndl ; } } err = ompi_request_wait_all ( tree -> tree_nextsize , send_reqs , MPI_STATUSES_IGNORE ) ; if ( err != MPI_SUCCESS ) { line = __LINE__ ; goto error_hndl ; } } else { req_index = 0 ; err = MCA_PML_CALL ( irecv ( tmpbuf , count_by_segment , datatype , tree -> tree_prev , MCA_COLL_BASE_TAG_BCAST , comm , & recv_reqs [ req_index ] ) ) ; if ( err != MPI_SUCCESS ) { line = __LINE__ ; goto error_hndl ; } for ( segindex = 1 ; segindex < num_segments ; segindex ++ ) { req_index = req_index ^ 0x1 ; tmpbuf += realsegsize ; err = MCA_PML_CALL ( irecv ( tmpbuf , count_by_segment , datatype , tree -> tree_prev , MCA_COLL_BASE_TAG_BCAST , comm , & recv_reqs [ req_index ] ) ) ; if ( err != MPI_SUCCESS ) { line = __LINE__ ; goto error_hndl ; } err = ompi_request_wait ( & recv_reqs [ req_index ^ 0x1 ] , MPI_STATUS_IGNORE ) ; if ( err != MPI_SUCCESS ) { line = __LINE__ ; goto error_hndl ; } } err = ompi_request_wait ( & recv_reqs [ req_index ] , MPI_STATUS_IGNORE ) ; if ( err != MPI_SUCCESS ) { line = __LINE__ ; goto error_hndl ; } } return ( MPI_SUCCESS ) ; error_hndl : OPAL_OUTPUT ( ( ompi_coll_base_framework . framework_output , "%s:%4d\\tError<S2SV_blank>occurred<S2SV_blank>%d,<S2SV_blank>rank<S2SV_blank>%2d" , __FILE__ , line , err , rank ) ) ; ( void ) line ; ompi_coll_base_free_reqs ( recv_reqs , 2 ) ; if ( NULL != send_reqs ) { ompi_coll_base_free_reqs ( send_reqs , tree -> tree_nextsize ) ; } return err ; } | <S2SV_ModStart> { send_reqs = ompi_coll_base_comm_get_reqs <S2SV_ModEnd> ( module -> |
6,113 | CWE-000 int uart_communication_thread_main ( int argc , char * argv [ ] ) { thread_running = true ; <S2SV_StartBug> printf ( "Hello<S2SV_blank>uart_communication!\\n" ) ; <S2SV_EndBug> int sensor_sub_fd = orb_subscribe ( ORB_ID ( sensor_combined ) ) ; orb_set_interval ( sensor_sub_fd , 1000 ) ; struct pollfd fds [ ] = { { . fd = sensor_sub_fd , . events = POLLIN } , } ; char byte_data = '0' ; char in_buffer [ 64 ] = "" ; int index = 0 ; int uart_read = uart_init ( "/dev/ttyS6" ) ; if ( false == uart_read ) return - 1 ; if ( false == set_uart_baudrate ( uart_read , 115200 ) ) { printf ( "[YCM]set_uart_baudrate<S2SV_blank>is<S2SV_blank>failed\\n" ) ; return - 1 ; } struct parafoil_attitude_sensor_s parafoil_attitude_sensor ; memset ( & parafoil_attitude_sensor , 0 , sizeof ( parafoil_attitude_sensor ) ) ; orb_advert_t parafoil_attitude_sensor_pub_fd = orb_advertise ( ORB_ID ( parafoil_attitude_sensor ) , & parafoil_attitude_sensor ) ; <S2SV_StartBug> while ( ! thread_should_exit ) { <S2SV_EndBug> int poll_ret = poll ( fds , 1 , 1000 ) ; if ( poll_ret == 0 ) { printf ( "[px4_simple_app]<S2SV_blank>Got<S2SV_blank>no<S2SV_blank>data<S2SV_blank>within<S2SV_blank>a<S2SV_blank>second\\n" ) ; } else if ( poll_ret < 0 ) { } else { if ( fds [ 0 ] . revents & POLLIN ) { read ( uart_read , & byte_data , 1 ) ; in_buffer [ index ] = byte_data ; if ( ( index == 0 ) && ( in_buffer [ index ] == 0x55 ) ) index = 1 ; else if ( ( index == 1 ) && ( in_buffer [ index ] == 0x53 ) ) { index = 2 ; printf ( "Attitude<S2SV_blank>message<S2SV_blank>is<S2SV_blank>coming!\\n" ) ; } else if ( ( index >= 2 ) && ( index < 11 ) ) index ++ ; else if ( index == 11 ) { int title ; title = in_buffer [ 0 ] << 8 | in_buffer [ 1 ] ; printf ( "Title<S2SV_blank>confirmed(att_message<S2SV_blank>-><S2SV_blank>0x5553):<S2SV_blank>title_x<S2SV_blank>=<S2SV_blank>%x\\n" , title ) ; index = 0 ; printf ( "I<S2SV_blank>get<S2SV_blank>the<S2SV_blank>attitude<S2SV_blank>message!\\n" ) ; char RL = in_buffer [ 2 ] , RH = in_buffer [ 3 ] ; printf ( "RL<S2SV_blank>=<S2SV_blank>%x\\tRH<S2SV_blank>=<S2SV_blank>%x\\n" , RL , RH ) ; char PL = in_buffer [ 4 ] , PH = in_buffer [ 5 ] ; printf ( "PL<S2SV_blank>=<S2SV_blank>%x\\tPH<S2SV_blank>=<S2SV_blank>%x\\n" , PL , PH ) ; char YL = in_buffer [ 6 ] , YH = in_buffer [ 7 ] ; printf ( "YL<S2SV_blank>=<S2SV_blank>%x\\tYH<S2SV_blank>=<S2SV_blank>%x\\n" , YL , YH ) ; char TL = in_buffer [ 8 ] , TH = in_buffer [ 9 ] ; printf ( "TL<S2SV_blank>=<S2SV_blank>%x\\tTH<S2SV_blank>=<S2SV_blank>%x\\n" , TL , TH ) ; float roll_angle = ( float ) ( RH << 8 | RL ) / 32768.0f * 180.0f ; printf ( "roll<S2SV_blank>angle<S2SV_blank>=<S2SV_blank>%8.3f<S2SV_blank>degree\\n" , ( double ) roll_angle ) ; float pitch_angle = ( float ) ( PH << 8 | PL ) / 32768.0f * 180.0f ; printf ( "pitch<S2SV_blank>angle<S2SV_blank>=<S2SV_blank>%8.3f<S2SV_blank>degree\\n" , ( double ) pitch_angle ) ; float yaw_angle = ( float ) ( YH << 8 | YL ) / 32768.0f * 180.0f ; printf ( "yaw<S2SV_blank>angle<S2SV_blank>=<S2SV_blank>%8.3f<S2SV_blank>degree\\n" , ( double ) yaw_angle ) ; float T_sensor = ( float ) ( TH << 8 | TL ) / 340.0f + 36.53f ; printf ( "Temperature<S2SV_blank>=<S2SV_blank>%8.3f<S2SV_blank>degree\\n" , ( double ) T_sensor ) ; parafoil_attitude_sensor . parafoil_roll_angle = roll_angle ; parafoil_attitude_sensor . parafoil_pitch_angle = pitch_angle ; parafoil_attitude_sensor . parafoil_yaw_angle = yaw_angle ; orb_publish ( ORB_ID ( parafoil_attitude_sensor ) , parafoil_attitude_sensor_pub_fd , & parafoil_attitude_sensor ) ; } else index = 0 ; } <S2SV_StartBug> } <S2SV_EndBug> } thread_running = false ; return 0 ; } | <S2SV_ModStart> ( "Hello<S2SV_blank>uart_communication!\\n" ) <S2SV_ModEnd> ; char byte_data <S2SV_ModStart> ( ! thread_should_exit <S2SV_ModEnd> ) { read <S2SV_ModStart> 0 ; } <S2SV_ModEnd> thread_running = false |
6,114 | CWE-000 void getSuperBlock ( struct ext2_super_block * block ) { <S2SV_StartBug> memset ( super_block_buf , 0 , SUPER_BLOCK_BUFFER_SIZE ) ; <S2SV_EndBug> <S2SV_StartBug> ssize_t nread = pread ( image_fd , super_block_buf , SUPER_BLOCK_BUFFER_SIZE , SUPER_BLOCK_OFFSET ) ; <S2SV_EndBug> if ( nread < 0 ) { fprintf ( stderr , "Error<S2SV_blank>reading<S2SV_blank>super<S2SV_blank>block<S2SV_blank>info<S2SV_blank>from<S2SV_blank>image<S2SV_blank>file.\\n" ) ; exit ( EXIT_FAILURE ) ; } memcpy ( & block -> s_blocks_count , super_block_buf + 4 , 4 ) ; memcpy ( & block -> s_inodes_count , super_block_buf , 4 ) ; memcpy ( & block -> s_log_block_size , super_block_buf + 24 , 4 ) ; block -> s_log_block_size = 1024 << block -> s_log_block_size ; memcpy ( & block -> s_inode_size , super_block_buf + 88 , 2 ) ; memcpy ( & block -> s_blocks_per_group , super_block_buf + 32 , 4 ) ; memcpy ( & block -> s_inodes_per_group , super_block_buf + 40 , 4 ) ; memcpy ( & block -> s_first_ino , super_block_buf + 84 , 4 ) ; } | <S2SV_ModStart> , 0 , SUPER_BLOCK_SIZE <S2SV_ModEnd> ) ; ssize_t <S2SV_ModStart> , super_block_buf , SUPER_BLOCK_SIZE <S2SV_ModEnd> , SUPER_BLOCK_OFFSET ) |
6,115 | CWE-000 int stan_core_dump ( STAN_CORE * k ) { int i ; <S2SV_StartBug> printf ( "+<S2SV_blank>Dumming<S2SV_blank>Core\\n" ) ; <S2SV_EndBug> printf ( "<S2SV_blank><S2SV_blank>-<S2SV_blank>File<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>%s\\n" , k -> fname ) ; printf ( "<S2SV_blank><S2SV_blank>-<S2SV_blank>Size<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>%ld\\n" , k -> size ) ; printf ( "<S2SV_blank><S2SV_blank>-<S2SV_blank>Entry<S2SV_blank>Point<S2SV_blank><S2SV_blank>:<S2SV_blank>%lx\\n" , k -> ep ) ; printf ( "<S2SV_blank><S2SV_blank>-<S2SV_blank>Type<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>%s\\n" , stan_core_type_str [ k -> type ] ) ; printf ( "<S2SV_blank><S2SV_blank>-<S2SV_blank>Valid<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>%s\\n" , stan_core_valid_str [ k -> valid ] ) ; printf ( "<S2SV_blank><S2SV_blank>-<S2SV_blank>Architecture<S2SV_blank>:<S2SV_blank>%s\\n" , stan_core_arch_str [ k -> arch ] ) ; printf ( "<S2SV_blank><S2SV_blank>-<S2SV_blank>Mode<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>%s(%d)\\n" , stan_core_mode_str [ k -> mode ] , k -> mode ) ; printf ( "<S2SV_blank><S2SV_blank>-<S2SV_blank>Info<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>%s<S2SV_blank>%s\\n" , IS_DYNAMIC ( k ) ? "Dynamic" : "Static" , IS_STRIPPED ( k ) ? "Stripped" : "Not<S2SV_blank>Stripped" ) ; for ( i = 0 ; i < k -> seg -> n ; i ++ ) { STAN_SEGMENT * s = ( STAN_SEGMENT * ) k -> seg -> p [ i ] ; printf ( "[%02d]<S2SV_blank>%s<S2SV_blank>Addr:%p<S2SV_blank>Offset:0x%04lx<S2SV_blank>Size:0x%04lx<S2SV_blank>(%ld)\\n" , i , s -> id , ( void * ) s -> addr , s -> off , s -> size , s -> size ) ; } printf ( ".................................................\\n" ) ; for ( i = 0 ; i < k -> sec -> n ; i ++ ) { STAN_SEGMENT * s = ( STAN_SEGMENT * ) k -> sec -> p [ i ] ; STAN_SEGMENT * s1 = NULL ; int seg = stan_core_ptr_segment ( k , s -> addr ) ; if ( seg >= 0 ) s1 = ( STAN_SEGMENT * ) k -> seg -> p [ seg ] ; printf ( "[%02d]<S2SV_blank>%15s<S2SV_blank>0x%02x<S2SV_blank>Addr:%p<S2SV_blank>Offset:0x%04lx<S2SV_blank>Size:0x%04lx<S2SV_blank>(%7ld)<S2SV_blank>[%s+0x%04lx]\\n" , i , s -> id , s -> type , ( void * ) s -> addr , s -> off , s -> size , s -> size , ( s1 ) ? s1 -> id : "N/A" , ( s1 ) ? s -> addr - s1 -> addr : 0 ) ; } return 0 ; } | <S2SV_ModStart> ; printf ( "+<S2SV_blank>Core<S2SV_blank>Information\\n" <S2SV_ModEnd> ) ; printf |
6,116 | CWE-000 static int imxfb_check_var ( struct fb_var_screeninfo * var , struct fb_info * info ) { struct imxfb_info * fbi = info -> par ; struct imxfb_rgb * rgb ; const struct imx_fb_videomode * imxfb_mode ; unsigned long lcd_clk ; unsigned long long tmp ; u32 pcr = 0 ; if ( var -> xres < MIN_XRES ) var -> xres = MIN_XRES ; if ( var -> yres < MIN_YRES ) var -> yres = MIN_YRES ; imxfb_mode = imxfb_find_mode ( fbi ) ; if ( ! imxfb_mode ) return - EINVAL ; var -> xres = imxfb_mode -> mode . xres ; var -> yres = imxfb_mode -> mode . yres ; var -> bits_per_pixel = imxfb_mode -> bpp ; var -> pixclock = imxfb_mode -> mode . pixclock ; var -> hsync_len = imxfb_mode -> mode . hsync_len ; var -> left_margin = imxfb_mode -> mode . left_margin ; var -> right_margin = imxfb_mode -> mode . right_margin ; var -> vsync_len = imxfb_mode -> mode . vsync_len ; var -> upper_margin = imxfb_mode -> mode . upper_margin ; var -> lower_margin = imxfb_mode -> mode . lower_margin ; var -> sync = imxfb_mode -> mode . sync ; var -> xres_virtual = max ( var -> xres_virtual , var -> xres ) ; var -> yres_virtual = max ( var -> yres_virtual , var -> yres ) ; pr_debug ( "var->bits_per_pixel=%d\\n" , var -> bits_per_pixel ) ; lcd_clk = clk_get_rate ( fbi -> clk_per ) ; tmp = var -> pixclock * ( unsigned long long ) lcd_clk ; do_div ( tmp , 1000000 ) ; if ( do_div ( tmp , 1000000 ) > 500000 ) tmp ++ ; pcr = ( unsigned int ) tmp ; if ( -- pcr > 0x3F ) { pcr = 0x3F ; printk ( KERN_WARNING "Must<S2SV_blank>limit<S2SV_blank>pixel<S2SV_blank>clock<S2SV_blank>to<S2SV_blank>%luHz\\n" , lcd_clk / pcr ) ; } switch ( var -> bits_per_pixel ) { case 32 : pcr |= PCR_BPIX_18 ; rgb = & def_rgb_18 ; break ; case 16 : default : if ( is_imx1_fb ( fbi ) ) pcr |= PCR_BPIX_12 ; else pcr |= PCR_BPIX_16 ; if ( imxfb_mode -> pcr & PCR_TFT ) rgb = & def_rgb_16_tft ; else rgb = & def_rgb_16_stn ; break ; case 8 : pcr |= PCR_BPIX_8 ; rgb = & def_rgb_8 ; break ; } pcr |= imxfb_mode -> pcr & ~ ( 0x3f | ( 7 << 25 ) ) ; fbi -> pcr = pcr ; <S2SV_StartBug> var -> red = rgb -> red ; <S2SV_EndBug> var -> green = rgb -> green ; var -> blue = rgb -> blue ; var -> transp = rgb -> transp ; pr_debug ( "RGBT<S2SV_blank>length<S2SV_blank>=<S2SV_blank>%d:%d:%d:%d\\n" , var -> red . length , var -> green . length , var -> blue . length , var -> transp . length ) ; pr_debug ( "RGBT<S2SV_blank>offset<S2SV_blank>=<S2SV_blank>%d:%d:%d:%d\\n" , var -> red . offset , var -> green . offset , var -> blue . offset , var -> transp . offset ) ; return 0 ; } | <S2SV_ModStart> = pcr ; if ( ! is_imx1_fb ( fbi ) && imxfb_mode -> aus_mode ) fbi -> lauscr = LAUSCR_AUS_MODE ; |
6,117 | CWE-000 MOCK_IMPL ( const node_t * , node_get_by_nickname , ( const char * nickname , unsigned flags ) ) { const int warn_if_unnamed = ! ( flags & NNF_NO_WARN_UNNAMED ) ; if ( ! the_nodelist ) return NULL ; { const node_t * node ; if ( ( node = node_get_by_hex_id ( nickname , flags ) ) != NULL ) return node ; } if ( ! strcasecmp ( nickname , UNNAMED_ROUTER_NICKNAME ) ) return NULL ; { smartlist_t * matches = smartlist_new ( ) ; const node_t * choice = NULL ; SMARTLIST_FOREACH_BEGIN ( the_nodelist -> nodes , node_t * , node ) { if ( ! strcasecmp ( node_get_nickname ( node ) , nickname ) ) smartlist_add ( matches , node ) ; } SMARTLIST_FOREACH_END ( node ) ; if ( smartlist_len ( matches ) > 1 && warn_if_unnamed ) { int any_unwarned = 0 ; SMARTLIST_FOREACH_BEGIN ( matches , node_t * , node ) { if ( ! node -> name_lookup_warned ) { node -> name_lookup_warned = 1 ; any_unwarned = 1 ; } } SMARTLIST_FOREACH_END ( node ) ; if ( any_unwarned ) { <S2SV_StartBug> log_warn ( LD_CONFIG , "There<S2SV_blank>are<S2SV_blank>multiple<S2SV_blank>matches<S2SV_blank>for<S2SV_blank>the<S2SV_blank>name<S2SV_blank>%s,<S2SV_blank>" <S2SV_EndBug> "but<S2SV_blank>none<S2SV_blank>is<S2SV_blank>listed<S2SV_blank>as<S2SV_blank>Named<S2SV_blank>in<S2SV_blank>the<S2SV_blank>directory<S2SV_blank>consensus.<S2SV_blank>" "Choosing<S2SV_blank>one<S2SV_blank>arbitrarily." , nickname ) ; } } else if ( smartlist_len ( matches ) == 1 && warn_if_unnamed ) { char fp [ HEX_DIGEST_LEN + 1 ] ; node_t * node = smartlist_get ( matches , 0 ) ; if ( ! node -> name_lookup_warned ) { base16_encode ( fp , sizeof ( fp ) , node -> identity , DIGEST_LEN ) ; log_warn ( LD_CONFIG , "You<S2SV_blank>specified<S2SV_blank>a<S2SV_blank>relay<S2SV_blank>\\"%s\\"<S2SV_blank>by<S2SV_blank>name,<S2SV_blank>but<S2SV_blank>nicknames<S2SV_blank>can<S2SV_blank>be<S2SV_blank>" "used<S2SV_blank>by<S2SV_blank>any<S2SV_blank>relay,<S2SV_blank>not<S2SV_blank>just<S2SV_blank>the<S2SV_blank>one<S2SV_blank>you<S2SV_blank>meant.<S2SV_blank>" "To<S2SV_blank>make<S2SV_blank>sure<S2SV_blank>you<S2SV_blank>get<S2SV_blank>the<S2SV_blank>same<S2SV_blank>relay<S2SV_blank>in<S2SV_blank>the<S2SV_blank>future,<S2SV_blank>refer<S2SV_blank>" "to<S2SV_blank>it<S2SV_blank>by<S2SV_blank>key,<S2SV_blank>as<S2SV_blank>\\"$%s\\"." , nickname , fp ) ; node -> name_lookup_warned = 1 ; } } if ( smartlist_len ( matches ) ) choice = smartlist_get ( matches , 0 ) ; smartlist_free ( matches ) ; return choice ; } } | <S2SV_ModStart> ( LD_CONFIG , "There<S2SV_blank>are<S2SV_blank>multiple<S2SV_blank>matches<S2SV_blank>for<S2SV_blank>the<S2SV_blank>name<S2SV_blank>%s.<S2SV_blank>" <S2SV_ModEnd> "Choosing<S2SV_blank>one<S2SV_blank>arbitrarily." , nickname |
6,118 | CWE-000 static void create_breakpoints_sal_default ( struct gdbarch * gdbarch , struct linespec_result * canonical , <S2SV_StartBug> char * cond_string , <S2SV_EndBug> char * extra_string , enum bptype type_wanted , enum bpdisp disposition , int thread , int task , int ignore_count , const struct breakpoint_ops * ops , int from_tty , int enabled , int internal , unsigned flags ) { <S2SV_StartBug> create_breakpoints_sal ( gdbarch , canonical , cond_string , <S2SV_EndBug> extra_string , type_wanted , disposition , thread , task , ignore_count , ops , from_tty , enabled , internal , flags ) ; } | <S2SV_ModStart> * canonical , gdb : : unique_xmalloc_ptr < char > cond_string , gdb : : unique_xmalloc_ptr < char > <S2SV_ModEnd> extra_string , enum <S2SV_ModStart> , canonical , std : : move ( cond_string ) , std : : move ( extra_string ) <S2SV_ModEnd> , type_wanted , |
6,119 | CWE-000 void readCombustionTankPressureTask ( void const * arg ) { CombustionTankPressureData * data = ( CombustionTankPressureData * ) arg ; uint32_t prevWakeTime = osKernelSysTick ( ) ; uint16_t adcRead = 0 ; double vo = 0 ; double vi = 0 ; double tankPressure = 0 ; int counter = 0 ; <S2SV_StartBug> int R1 = 60 ; <S2SV_EndBug> <S2SV_StartBug> int R2 = 165 ; <S2SV_EndBug> HAL_ADC_Start ( & hadc1 ) ; for ( ; ; ) { osDelayUntil ( & prevWakeTime , READ_COMBUSTION_TANK_PRESSURE_PERIOD ) ; if ( HAL_ADC_PollForConversion ( & hadc1 , ADC_POLL_TIMEOUT ) == HAL_OK ) { adcRead += HAL_ADC_GetValue ( & hadc1 ) ; counter ++ ; } if ( counter >= 5 ) { adcRead /= counter ; vo = 3.3 / pow ( 2 , 12 ) * adcRead ; vi = ( R2 + R1 ) / R2 * vo ; tankPressure = ( vi - 0.5 ) * 300 / 4 ; tankPressure = tankPressure * 1000 ; adcRead = 0 ; counter = 0 ; } if ( osMutexWait ( data -> mutex_ , 0 ) != osOK ) { continue ; } data -> pressure_ = ( int32_t ) tankPressure ; osMutexRelease ( data -> mutex_ ) ; } } | <S2SV_ModStart> int R1 = 100 <S2SV_ModEnd> ; int R2 <S2SV_ModStart> int R2 = 133 <S2SV_ModEnd> ; HAL_ADC_Start ( |
6,120 | CWE-000 static void write_fits_header ( file_t * fp , const char * str , uint32_t magic , uint64_t ndim , mwSize * dims ) { int bitpix ; switch ( magic ) { case M_FLT : bitpix = - 32 ; break ; case M_DBL : bitpix = - 64 ; break ; case M_INT32 : bitpix = 32 ; break ; case M_INT16 : bitpix = 16 ; break ; case M_INT8 : bitpix = 8 ; break ; default : bitpix = 0 ; error ( "Data<S2SV_blank>type<S2SV_blank>is<S2SV_blank>not<S2SV_blank>yet<S2SV_blank>supported.\\n" ) ; } const int nh = 36 ; char header [ nh ] [ 80 ] ; memset ( header , '<S2SV_blank>' , sizeof ( char ) * 36 * 80 ) ; int hc = 0 ; if ( fp -> isfits == 1 ) { snprintf ( header [ hc ] , 80 , "%-8s=<S2SV_blank>%20s" , "SIMPLE" , "T" ) ; header [ hc ] [ 30 ] = '<S2SV_blank>' ; hc ++ ; fp -> isfits ++ ; } else { snprintf ( header [ hc ] , 80 , "%-8s=<S2SV_blank>%s" , "XTENSION" , "\'IMAGE<S2SV_blank><S2SV_blank><S2SV_blank>\'" ) ; header [ hc ] [ 20 ] = '<S2SV_blank>' ; hc ++ ; } snprintf ( header [ hc ] , 80 , "%-8s=<S2SV_blank>%20d" , "BITPIX" , bitpix ) ; header [ hc ] [ 30 ] = '<S2SV_blank>' ; hc ++ ; <S2SV_StartBug> snprintf ( header [ hc ] , 80 , "%-8s=<S2SV_blank>%20llu" , "NAXIS" , ndim ) ; header [ hc ] [ 30 ] = '<S2SV_blank>' ; hc ++ ; <S2SV_EndBug> # define FLUSH_OUT if ( hc == nh ) { zfwrite ( header , sizeof ( char ) , 36 * 80 , fp ) ; memset ( header , '<S2SV_blank>' , sizeof ( char ) * 36 * 80 ) ; hc = 0 ; } <S2SV_StartBug> for ( uint64_t i = 0 ; i < ndim ; i ++ ) { <S2SV_EndBug> FLUSH_OUT ; <S2SV_StartBug> snprintf ( header [ hc ] , 80 , "%-5s%-3llu=<S2SV_blank>%20lu" , "NAXIS" , i + 1 , ( unsigned long ) ( dims [ i ] ) ) ; header [ hc ] [ 30 ] = '<S2SV_blank>' ; hc ++ ; <S2SV_EndBug> } if ( str ) { const char * str2 = str + strlen ( str ) ; while ( str < str2 ) { const char * nl = strchr ( str , '\\n' ) ; int length ; if ( nl ) { length = nl - str + 1 ; } else { length = strlen ( str ) ; } if ( length > 70 ) length = 70 ; FLUSH_OUT ; strncpy ( header [ hc ] , "COMMENT<S2SV_blank><S2SV_blank><S2SV_blank>" , 10 ) ; strncpy ( header [ hc ] + 10 , str , length ) ; if ( nl ) { header [ hc ] [ 10 + length - 1 ] = ';' ; } hc ++ ; str += length ; } } FLUSH_OUT ; snprintf ( header [ hc ] , 80 , "%-8s" , "END" ) ; header [ hc ] [ 8 ] = '<S2SV_blank>' ; hc ++ ; zfwrite ( header , sizeof ( char ) , 36 * 80 , fp ) ; # undef FLUSH_OUT } | <S2SV_ModStart> , 80 , "%-8s=<S2SV_blank>%20ld" <S2SV_ModEnd> , "NAXIS" , <S2SV_ModStart> , "NAXIS" , ( long ) <S2SV_ModStart> } for ( unsigned long <S2SV_ModEnd> i = 0 <S2SV_ModStart> , 80 , "%-5s%-3lu=<S2SV_blank>%20ld" <S2SV_ModEnd> , "NAXIS" , <S2SV_ModStart> 1 , ( <S2SV_ModEnd> long ) ( |
6,121 | CWE-000 int capabilities ( ) { fprintf ( stderr , "=><S2SV_blank>dropping<S2SV_blank>capabilities..." ) ; int drop_caps [ ] = { CAP_AUDIT_CONTROL , CAP_AUDIT_READ , CAP_AUDIT_WRITE , CAP_BLOCK_SUSPEND , CAP_DAC_READ_SEARCH , CAP_FSETID , CAP_IPC_LOCK , CAP_MAC_ADMIN , CAP_MAC_OVERRIDE , CAP_MKNOD , CAP_SETFCAP , CAP_SYSLOG , CAP_SYS_ADMIN , CAP_SYS_BOOT , CAP_SYS_MODULE , CAP_SYS_NICE , CAP_SYS_RAWIO , CAP_SYS_RESOURCE , CAP_SYS_TIME , CAP_WAKE_ALARM } ; size_t num_caps = sizeof ( drop_caps ) / sizeof ( * drop_caps ) ; fprintf ( stderr , "bounding..." ) ; for ( size_t i = 0 ; i < num_caps ; i ++ ) { <S2SV_StartBug> if ( prctl ( PR_CAPBSET_DROP , dorp_caps [ i ] , 0 , 0 , 0 ) ) { <S2SV_EndBug> fprintf ( stderr , "prctl<S2SV_blank>failed:<S2SV_blank>%m\\n" ) ; return 1 ; } } fprintf ( stderr , "inheritable..." ) ; cap_t caps = NULL ; if ( ! ( caps = cap_get_proc ( ) ) <S2SV_StartBug> || cap_set_flag ( caps , CAP_INHERITABLE , num_caps , drop_caps , CAP_CLEANER ) <S2SV_EndBug> || cap_set_proc ( caps ) ) { fprintf ( stderr , "failed:<S2SV_blank>%m<S2SV_blank>\\n" ) ; if ( caps ) cap_free ( caps ) ; return 1 ; } cap_free ( caps ) ; fprintf ( stderr , "done.\\n" ) ; return 0 ; } | <S2SV_ModStart> ( PR_CAPBSET_DROP , drop_caps <S2SV_ModEnd> [ i ] <S2SV_ModStart> , drop_caps , CAP_CLEAR <S2SV_ModEnd> ) || cap_set_proc |
6,122 | CWE-000 bool policy_check_recv ( Policy * p , uid_t uid , gid_t gid , int message_type , const char * name , const char * path , const char * interface , const char * member ) { struct policy_check_filter filter = { . class = POLICY_ITEM_RECV , . uid = uid , . gid = gid , . message_type = message_type , . name = name , . interface = interface , . path = path , . member = member , } ; int verdict ; assert ( p ) ; verdict = policy_check ( p , & filter ) ; log_full ( LOG_AUTH | ( verdict != ALLOW ? LOG_WARNING : LOG_DEBUG ) , <S2SV_StartBug> "Receive<S2SV_blank>permission<S2SV_blank>check<S2SV_blank>for<S2SV_blank>uid=" UID_FMT "<S2SV_blank>gid=" GID_FMT "<S2SV_blank>message=%s<S2SV_blank>name=%s<S2SV_blank>interface=%s<S2SV_blank>path=%s<S2SV_blank>member=%s:<S2SV_blank>%s" , <S2SV_EndBug> uid , gid , bus_message_type_to_string ( message_type ) , strna ( name ) , strna ( path ) , strna ( interface ) , strna ( member ) , strna ( verdict_to_string ( verdict ) ) ) ; return verdict == ALLOW ; } | <S2SV_ModStart> UID_FMT "<S2SV_blank>gid=" GID_FMT "<S2SV_blank>message=%s<S2SV_blank>name=%s<S2SV_blank>path=%s<S2SV_blank>interface=%s<S2SV_blank>member=%s:<S2SV_blank>%s" <S2SV_ModEnd> , uid , |
6,123 | CWE-000 int control_dispatch_vmd ( int fd , struct privsep_proc * p , struct imsg * imsg ) { <S2SV_StartBug> struct ctl_conn * c ; <S2SV_EndBug> switch ( imsg -> hdr . type ) { case IMSG_VMDOP_START_VM_RESPONSE : case IMSG_VMDOP_TERMINATE_VM_RESPONSE : case IMSG_VMDOP_GET_INFO_VM_DATA : case IMSG_VMDOP_GET_INFO_VM_END_DATA : if ( ( c = control_connbyfd ( imsg -> hdr . peerid ) ) == NULL ) { log_warnx ( "%s:<S2SV_blank>lost<S2SV_blank>control<S2SV_blank>connection:<S2SV_blank>fd<S2SV_blank>%d" , __func__ , imsg -> hdr . peerid ) ; return ( 0 ) ; } imsg_compose_event ( & c -> iev , imsg -> hdr . type , 0 , 0 , - 1 , imsg -> data , IMSG_DATA_SIZE ( imsg ) ) ; break ; <S2SV_StartBug> default : <S2SV_EndBug> return ( - 1 ) ; } return ( 0 ) ; } | <S2SV_ModStart> ctl_conn * c ; struct privsep * ps = p -> p_ps <S2SV_ModStart> ; break ; case IMSG_VMDOP_CONFIG : config_getconfig ( ps -> ps_env , imsg ) ; break ; case IMSG_CTL_RESET : config_getreset ( ps -> ps_env , imsg ) ; break ; |
6,124 | CWE-000 static void plot_check ( args_t * args , char * target_sample , char * query_sample ) { char * fname ; FILE * fp = open_file ( & fname , "w" , "%s.py" , args -> plot ) ; fprintf ( fp , "import<S2SV_blank>matplotlib<S2SV_blank>as<S2SV_blank>mpl\\n" "mpl.use(\'Agg\')\\n" "import<S2SV_blank>matplotlib.pyplot<S2SV_blank>as<S2SV_blank>plt\\n" "import<S2SV_blank>matplotlib.gridspec<S2SV_blank>as<S2SV_blank>gridspec\\n" "import<S2SV_blank>csv\\n" "csv.register_dialect(\'tab\',<S2SV_blank>delimiter=\'\\\\t\',<S2SV_blank>quoting=csv.QUOTE_NONE)\\n" "\\n" "sample_ids<S2SV_blank>=<S2SV_blank>False\\n" "\\n" "dat<S2SV_blank>=<S2SV_blank>[]\\n" <S2SV_StartBug> "with<S2SV_blank>open(\'%s.tab\',<S2SV_blank>\'rb\')<S2SV_blank>as<S2SV_blank>f:\\n" <S2SV_EndBug> "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>reader<S2SV_blank>=<S2SV_blank>csv.reader(f,<S2SV_blank>\'tab\')\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>for<S2SV_blank>row<S2SV_blank>in<S2SV_blank>reader:\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>if<S2SV_blank>row[0][0]==\'#\':<S2SV_blank>continue\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>if<S2SV_blank>row[0]!=\'CN\':<S2SV_blank>continue\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>tgt<S2SV_blank>=<S2SV_blank>0\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>if<S2SV_blank>row[4]==\'%s\':<S2SV_blank>tgt<S2SV_blank>=<S2SV_blank>1\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>dat.append([float(row[1]),<S2SV_blank>float(row[2]),<S2SV_blank>float(row[3]),<S2SV_blank>tgt,<S2SV_blank>row[4]])\\n" "\\n" "dat<S2SV_blank>=<S2SV_blank>sorted(dat)\\n" "\\n" "iq<S2SV_blank>=<S2SV_blank>-1;<S2SV_blank>dp<S2SV_blank>=<S2SV_blank>0\\n" "for<S2SV_blank>i<S2SV_blank>in<S2SV_blank>range(len(dat)):\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>if<S2SV_blank>iq==-1<S2SV_blank>and<S2SV_blank>dat[i][3]==1:<S2SV_blank>iq<S2SV_blank>=<S2SV_blank>i\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>dp<S2SV_blank>+=<S2SV_blank>dat[i][2]\\n" "dp<S2SV_blank>/=<S2SV_blank>len(dat)\\n" "\\n" "fig,ax1<S2SV_blank>=<S2SV_blank>plt.subplots(figsize=(8,5))\\n" "ax2<S2SV_blank>=<S2SV_blank>ax1.twinx()\\n" "plots<S2SV_blank><S2SV_blank>=<S2SV_blank>ax1.plot([x[0]<S2SV_blank>for<S2SV_blank>x<S2SV_blank>in<S2SV_blank>dat],\'o-\',<S2SV_blank>ms=3,<S2SV_blank>color=\'g\',<S2SV_blank>mec=\'g\',<S2SV_blank>label=\'Discordance<S2SV_blank>(total)\')\\n" "plots<S2SV_blank>+=<S2SV_blank>ax1.plot([x[1]<S2SV_blank>for<S2SV_blank>x<S2SV_blank>in<S2SV_blank>dat],<S2SV_blank>\'^\',<S2SV_blank>ms=3,<S2SV_blank>color=\'r\',<S2SV_blank>mec=\'r\',<S2SV_blank>label=\'Discordance<S2SV_blank>(avg<S2SV_blank>per<S2SV_blank>site)\')\\n" "plots<S2SV_blank>+=<S2SV_blank>ax2.plot([x[2]<S2SV_blank>for<S2SV_blank>x<S2SV_blank>in<S2SV_blank>dat],\'v\',<S2SV_blank>ms=3,<S2SV_blank>color=\'k\',<S2SV_blank>label=\'Number<S2SV_blank>of<S2SV_blank>sites\')\\n" "if<S2SV_blank>iq!=-1:\\n" "<S2SV_blank><S2SV_blank><S2SV_blank>ax1.plot([iq],[dat[iq][0]],\'o\',color=\'orange\',<S2SV_blank>ms=9)\\n" "<S2SV_blank><S2SV_blank><S2SV_blank>ax1.annotate(\'%s\',xy=(iq,dat[iq][0]),<S2SV_blank>xytext=(5,5),<S2SV_blank>textcoords=\'offset<S2SV_blank>points\',fontsize=\'xx-small\',rotation=45,va=\'bottom\',ha=\'left\')\\n" "<S2SV_blank><S2SV_blank><S2SV_blank>ax1.plot([iq],[dat[iq][1]],\'^\',color=\'red\',<S2SV_blank>ms=5)\\n" "for<S2SV_blank>tl<S2SV_blank>in<S2SV_blank>ax1.get_yticklabels():<S2SV_blank>tl.set_color(\'g\')\\n" "for<S2SV_blank>tl<S2SV_blank>in<S2SV_blank>ax2.get_yticklabels():<S2SV_blank>tl.set_color(\'k\');<S2SV_blank>tl.set_fontsize(9)\\n" "min_dp<S2SV_blank>=<S2SV_blank>min([x[2]<S2SV_blank>for<S2SV_blank>x<S2SV_blank>in<S2SV_blank>dat])\\n" "max_dp<S2SV_blank>=<S2SV_blank>max([x[2]<S2SV_blank>for<S2SV_blank>x<S2SV_blank>in<S2SV_blank>dat])\\n" "ax2.set_ylim(min_dp-1,max_dp+1)\\n" "ax1.set_title(\'Discordance<S2SV_blank>with<S2SV_blank>%s\')\\n" "ax1.set_xlim(-0.05*len(dat),1.05*(len(dat)-1))\\n" "ax1.set_xlabel(\'Sample<S2SV_blank>ID\')\\n" "plt.subplots_adjust(left=0.1,right=0.9,bottom=0.1,top=0.9)\\n" "if<S2SV_blank>sample_ids:\\n" "<S2SV_blank><S2SV_blank><S2SV_blank>ax1.set_xticks(range(len(dat)))\\n" "<S2SV_blank><S2SV_blank><S2SV_blank>ax1.set_xticklabels([x[4]<S2SV_blank>for<S2SV_blank>x<S2SV_blank>in<S2SV_blank>dat],**{\'rotation\':45,<S2SV_blank>\'ha\':\'right\',<S2SV_blank>\'fontsize\':8})\\n" "<S2SV_blank><S2SV_blank><S2SV_blank>plt.subplots_adjust(bottom=0.2)\\n" "ax1.set_ylabel(\'Discordance\',color=\'g\')\\n" "ax2.set_ylabel(\'Number<S2SV_blank>of<S2SV_blank>sites\',color=\'k\')\\n" "ax2.ticklabel_format(style=\'sci\',<S2SV_blank>scilimits=(-3,2),<S2SV_blank>axis=\'y\')\\n" "ax1.ticklabel_format(style=\'sci\',<S2SV_blank>scilimits=(-3,2),<S2SV_blank>axis=\'y\')\\n" "labels<S2SV_blank>=<S2SV_blank>[l.get_label()<S2SV_blank>for<S2SV_blank>l<S2SV_blank>in<S2SV_blank>plots]\\n" "plt.legend(plots,labels,numpoints=1,markerscale=1,loc=\'best\',prop={\'size\':10},frameon=False)\\n" "plt.savefig(\'%s.png\')\\n" "plt.close()\\n" "\\n" , args -> plot , target_sample , target_sample , query_sample , args -> plot ) ; fclose ( fp ) ; py_plot ( fname ) ; free ( fname ) ; } | <S2SV_ModStart> "sample_ids<S2SV_blank>=<S2SV_blank>False\\n" "\\n" "dat<S2SV_blank>=<S2SV_blank>[]\\n" "with<S2SV_blank>open(\'%s.tab\',<S2SV_blank>\'r\')<S2SV_blank>as<S2SV_blank>f:\\n" <S2SV_ModEnd> "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>reader<S2SV_blank>=<S2SV_blank>csv.reader(f,<S2SV_blank>\'tab\')\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>for<S2SV_blank>row<S2SV_blank>in<S2SV_blank>reader:\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>if<S2SV_blank>row[0][0]==\'#\':<S2SV_blank>continue\\n" |
6,125 | CWE-000 static Eina_Bool _ecore_imf_xim_init ( void ) { const char * s ; if ( ! getenv ( "DISPLAY" ) ) return EINA_FALSE ; if ( ( s = getenv ( "ELM_DISPLAY" ) ) ) { if ( strcmp ( s , "x11" ) ) return EINA_FALSE ; } eina_init ( ) ; _ecore_imf_xim_log_dom = eina_log_domain_register ( "ecore_imf_xim" , NULL ) ; if ( _ecore_imf_xim_log_dom < 0 ) { EINA_LOG_ERR ( "Could<S2SV_blank>not<S2SV_blank>register<S2SV_blank>log<S2SV_blank>domain:<S2SV_blank>ecore_imf_xim" ) ; } DBG ( "<S2SV_blank>" ) ; <S2SV_StartBug> if ( ! ecore_x_init ( NULL ) ) <S2SV_EndBug> { eina_shutdown ( ) ; return EINA_FALSE ; } ecore_imf_module_register ( & xim_info , xim_imf_module_create , xim_imf_module_exit ) ; return EINA_TRUE ; } | <S2SV_ModStart> "<S2SV_blank>" ) ; <S2SV_ModEnd> ecore_imf_module_register ( & |
6,126 | CWE-000 struct contains_ptr callee ( int * x ) { static int is [ ] = { 69105 , 4432 } ; <S2SV_StartBug> return ( struct contains_ptr ) { . do_not_care = x , . not_a_ptr = 42l , . p = is } ; <S2SV_EndBug> } | <S2SV_ModStart> p = is , . otherptr = x |
6,127 | CWE-000 Image * bandsize ( Window * w ) { Image * i ; Rectangle r , or ; Point p , startp ; int which , but ; p = mouse -> xy ; but = mouse -> buttons ; which = whichcorner ( w , p ) ; p = cornerpt ( w -> r , p , which ) ; wmovemouse ( w , p ) ; readmouse ( mousectl ) ; r = whichrect ( w -> r , p , which ) ; drawborder ( r , 1 ) ; or = r ; startp = p ; while ( mouse -> buttons == but ) { p = onscreen ( mouse -> xy ) ; r = whichrect ( w -> r , p , which ) ; if ( ! eqrect ( r , or ) && goodrect ( r ) ) { drawborder ( r , 1 ) ; flushimage ( display , 1 ) ; or = r ; } readmouse ( mousectl ) ; } p = mouse -> xy ; drawborder ( or , 0 ) ; flushimage ( display , 1 ) ; wsetcursor ( w , 1 ) ; if ( mouse -> buttons != 0 || Dx ( or ) < 100 || Dy ( or ) < 3 * font -> height ) { while ( mouse -> buttons ) readmouse ( mousectl ) ; return nil ; } if ( abs ( p . x - startp . x ) + abs ( p . y - startp . y ) <= 1 ) return nil ; <S2SV_StartBug> i = allocwindow ( wscreen , or , Refbackup , DWhite ) ; <S2SV_EndBug> if ( i == nil ) return nil ; border ( i , r , Selborder , red , ZP ) ; return i ; } | <S2SV_ModStart> return nil ; or = windowMinusTitle ( or , w -> t ) ; |
6,128 | CWE-000 void pidController ( const pidProfile_t * pidProfile , const rollAndPitchTrims_t * angleTrim , timeUs_t currentTimeUs ) { static float previousGyroRateDterm [ 2 ] ; static float previousPidSetpoint [ 2 ] ; if ( ! pidStabilisationEnabled || gyroOverflowDetected ( ) ) { for ( int axis = FD_ROLL ; axis <= FD_YAW ; ++ axis ) { pidData [ axis ] . P = 0 ; pidData [ axis ] . I = 0 ; pidData [ axis ] . D = 0 ; pidData [ axis ] . Sum = 0 ; } return ; } const float tpaFactor = getThrottlePIDAttenuation ( ) ; const float motorMixRange = getMotorMixRange ( ) ; const float dynCi = MIN ( ( 1.0f - motorMixRange ) * ITermWindupPointInv , 1.0f ) * dT * itermAccelerator ; const float dynCd = flightModeFlags ? 0.0f : dtermSetpointWeight ; float gyroRateDterm [ 2 ] ; for ( int axis = FD_ROLL ; axis < FD_YAW ; ++ axis ) { gyroRateDterm [ axis ] = dtermNotchApplyFn ( ( filter_t * ) & dtermNotch [ axis ] , gyro . gyroADCf [ axis ] ) ; gyroRateDterm [ axis ] = dtermLowpassApplyFn ( ( filter_t * ) & dtermLowpass [ axis ] , gyroRateDterm [ axis ] ) ; gyroRateDterm [ axis ] = dtermLowpass2ApplyFn ( ( filter_t * ) & dtermLowpass2 [ axis ] , gyroRateDterm [ axis ] ) ; } if ( itermRotation ) { handleItermRotation ( ) ; } for ( int axis = FD_ROLL ; axis <= FD_YAW ; ++ axis ) { float currentPidSetpoint = getSetpointRate ( axis ) ; if ( maxVelocity [ axis ] ) { currentPidSetpoint = accelerationLimit ( axis , currentPidSetpoint ) ; } if ( ( FLIGHT_MODE ( ANGLE_MODE ) || FLIGHT_MODE ( HORIZON_MODE ) ) && axis != YAW ) { currentPidSetpoint = pidLevel ( axis , pidProfile , angleTrim , currentPidSetpoint ) ; } const float gyroRate = gyro . gyroADCf [ axis ] ; float errorRate = currentPidSetpoint - gyroRate ; handleCrashRecovery ( pidProfile -> crash_recovery , angleTrim , axis , currentTimeUs , gyroRate , & currentPidSetpoint , & errorRate ) ; pidData [ axis ] . P = pidCoefficient [ axis ] . Kp * errorRate * tpaFactor ; if ( axis == FD_YAW ) { pidData [ axis ] . P = ptermYawLowpassApplyFn ( ( filter_t * ) & ptermYawLowpass , pidData [ axis ] . P ) ; } const float ITerm = pidData [ axis ] . I ; const float ITermNew = constrainf ( ITerm + pidCoefficient [ axis ] . Ki * errorRate * dynCi , - itermLimit , itermLimit ) ; const bool outputSaturated = mixerIsOutputSaturated ( axis , errorRate ) ; if ( outputSaturated == false || ABS ( ITermNew ) < ABS ( ITerm ) ) { pidData [ axis ] . I = ITermNew ; } if ( axis != FD_YAW ) { float transition = relaxFactor > 0 ? MIN ( 1.f , getRcDeflectionAbs ( axis ) * relaxFactor ) : 1 ; const float delta = ( dynCd * transition * ( currentPidSetpoint - previousPidSetpoint [ axis ] ) - ( gyroRateDterm [ axis ] - previousGyroRateDterm [ axis ] ) ) / dT ; previousPidSetpoint [ axis ] = currentPidSetpoint ; previousGyroRateDterm [ axis ] = gyroRateDterm [ axis ] ; detectAndSetCrashRecovery ( pidProfile -> crash_recovery , axis , currentTimeUs , delta , errorRate ) ; pidData [ axis ] . D = pidCoefficient [ axis ] . Kd * delta * tpaFactor ; <S2SV_StartBug> if ( gyroYawSpinDetected ( ) ) { <S2SV_EndBug> pidData [ axis ] . P = 0 ; pidData [ axis ] . I = 0 ; pidData [ axis ] . D = 0 ; } } } pidData [ FD_ROLL ] . Sum = pidData [ FD_ROLL ] . P + pidData [ FD_ROLL ] . I + pidData [ FD_ROLL ] . D ; pidData [ FD_PITCH ] . Sum = pidData [ FD_PITCH ] . P + pidData [ FD_PITCH ] . I + pidData [ FD_PITCH ] . D ; <S2SV_StartBug> if ( gyroYawSpinDetected ( ) ) { <S2SV_EndBug> pidData [ FD_YAW ] . I = 0 ; } pidData [ FD_YAW ] . Sum = pidData [ FD_YAW ] . P + pidData [ FD_YAW ] . I ; } | <S2SV_ModStart> ; if ( yawSpinNow <S2SV_ModEnd> ( ) ) <S2SV_ModStart> ; if ( yawSpinNow <S2SV_ModEnd> ( ) ) |
6,129 | CWE-000 static void usage ( void ) { <S2SV_StartBug> fprintf ( stderr , "usage:<S2SV_blank>detype1<S2SV_blank>[font<S2SV_blank>[text]]\\n" ) ; <S2SV_EndBug> exit ( 1 ) ; } | <S2SV_ModStart> void ) { printf ( "usage:<S2SV_blank>detype1<S2SV_blank>[font<S2SV_blank>[text]]\\n" <S2SV_ModEnd> ) ; } |
6,130 | CWE-000 void set_ssid_in_wifi_resource ( const char * ssid ) { if ( ssid == NULL ) { memset ( g_wifi_resource . ssid , 0 , sizeof ( char ) * MAX_SSIDLEN ) ; memset ( g_wifi_resource . cred , 0 , sizeof ( char ) * MAX_CREDLEN ) ; g_wifi_resource . auth_type = NONE_AUTH ; g_wifi_resource . enc_type = NONE_ENC ; g_wifi_resource . discovery_channel = 0 ; <S2SV_StartBug> } else if ( strncmp ( ssid , g_wifi_data . ssid , strlen ( g_wifi_data . ssid ) ) == 0 ) { <S2SV_EndBug> things_strncpy ( g_wifi_resource . ssid , g_wifi_data . ssid , sizeof ( char ) * MAX_SSIDLEN ) ; things_strncpy ( g_wifi_resource . cred , g_wifi_data . pwd , sizeof ( char ) * MAX_CREDLEN ) ; g_wifi_resource . auth_type = g_wifi_data . authtype ; g_wifi_resource . enc_type = g_wifi_data . enctype ; g_wifi_resource . discovery_channel = g_wifi_data . discovery_channel ; } else { things_strncpy ( g_wifi_resource . ssid , ssid , sizeof ( char ) * MAX_SSIDLEN ) ; memset ( g_wifi_resource . cred , 0 , sizeof ( char ) * MAX_CREDLEN ) ; g_wifi_resource . auth_type = NONE_AUTH ; g_wifi_resource . enc_type = NONE_ENC ; g_wifi_resource . discovery_channel = 1 ; } THINGS_LOG_D ( THINGS_DEBUG , ES_RH_TAG , "Connected<S2SV_blank>SSID=%s" , ssid ) ; THINGS_LOG_D ( THINGS_DEBUG , ES_RH_TAG , "g_wifi_data.ssid=%s" , g_wifi_data . ssid ) ; THINGS_LOG_D ( THINGS_DEBUG , ES_RH_TAG , "g_wifi_resource.ssid=%s" , g_wifi_resource . ssid ) ; } | <S2SV_ModStart> , strlen ( <S2SV_ModEnd> ssid ) ) |
6,131 | CWE-000 <S2SV_StartBug> static void cmd_without_delimiter_rules ( t_sh * sh , t_tree * * new_node , t_list * * aggregation ) <S2SV_EndBug> { t_fd * fd ; t_list * cmd_tokens ; t_token * token ; <S2SV_StartBug> cmd_tokens = NULL ; <S2SV_EndBug> <S2SV_StartBug> fd = NULL ; <S2SV_EndBug> while ( ( token = text_rules ( sh ) ) || ( token != ( void * ) - 1 && ( fd = aggregation_rules ( sh ) ) ) ) <S2SV_StartBug> { <S2SV_EndBug> if ( token ) ft_node_push_back ( & cmd_tokens , ft_strdup ( token -> value ) ) ; } if ( token == ( void * ) - 1 ) * new_node = ( void * ) - 1 ; if ( cmd_tokens ) { <S2SV_StartBug> if ( fd ) <S2SV_EndBug> ft_node_push_back ( aggregation , fd ) ; * new_node = create_node ( NULL , NULL , cmd_tokens , NULL ) ; <S2SV_StartBug> } <S2SV_EndBug> } | <S2SV_ModStart> * * new_node <S2SV_ModEnd> ) { t_fd <S2SV_ModStart> * token ; t_list * aggregations ; <S2SV_ModStart> NULL ; fd = NULL ; aggregations <S2SV_ModStart> ) ) { if ( fd ) ft_node_push_back ( & aggregations , fd ) ; <S2SV_ModStart> cmd_tokens ) { <S2SV_ModEnd> * new_node = <S2SV_ModStart> NULL ) ; ( * new_node ) -> aggregations = aggregations ; |
6,132 | CWE-000 u32 Quadramp_GetOverRide ( Quadramp * InstancePtr ) { Xil_AssertNonvoid ( InstancePtr != NULL ) ; Xil_AssertNonvoid ( InstancePtr -> IsReady == XIL_COMPONENT_IS_READY ) ; <S2SV_StartBug> QUADRAMP_mReadReg ( InstancePtr -> BaseAddress , QUADRAMP_S00_AXI_SLV_REG0_OFFSET ) ; <S2SV_EndBug> } | <S2SV_ModStart> XIL_COMPONENT_IS_READY ) ; return |
6,133 | CWE-000 static TEE_Result verify_node ( struct traverse_arg * targ , struct htree_node * node ) { void * ctx = targ -> arg ; TEE_Result res ; uint8_t digest [ TEE_FS_HTREE_HASH_SIZE ] ; <S2SV_StartBug> res = calc_node_hash ( node , ctx , digest ) ; <S2SV_EndBug> if ( res == TEE_SUCCESS && buf_compare_ct ( digest , node -> node . hash , sizeof ( digest ) ) ) return TEE_ERROR_CORRUPT_OBJECT ; return res ; } | <S2SV_ModStart> TEE_FS_HTREE_HASH_SIZE ] ; if ( node -> parent ) <S2SV_ModStart> calc_node_hash ( node , NULL , ctx , digest ) ; else res = calc_node_hash ( node , & targ -> ht -> imeta . meta |
6,134 | CWE-000 static void new_pes_packet ( PESContext * pes , AVPacket * pkt ) { av_packet_from_data ( pkt , pes -> buffer , pes -> data_index ) ; if ( pes -> total_size != MAX_PES_PAYLOAD && pes -> pes_header_size + pes -> data_index != pes -> total_size + PES_START_SIZE ) { av_log ( pes -> stream , AV_LOG_WARNING , "PES<S2SV_blank>packet<S2SV_blank>size<S2SV_blank>mismatch\\n" ) ; pes -> flags |= AV_PKT_FLAG_CORRUPT ; } <S2SV_StartBug> memset ( pkt -> data + pkt -> size , 0 , FF_INPUT_BUFFER_PADDING_SIZE ) ; <S2SV_EndBug> if ( pes -> sub_st && pes -> stream_type == 0x83 && pes -> extended_stream_id == 0x76 ) pkt -> stream_index = pes -> sub_st -> index ; else pkt -> stream_index = pes -> st -> index ; pkt -> pts = pes -> pts ; pkt -> dts = pes -> dts ; pkt -> pos = pes -> ts_packet_pos ; pkt -> flags = pes -> flags ; pes -> pts = AV_NOPTS_VALUE ; pes -> dts = AV_NOPTS_VALUE ; pes -> buffer = NULL ; pes -> data_index = 0 ; pes -> flags = 0 ; } | <S2SV_ModStart> , 0 , AV_INPUT_BUFFER_PADDING_SIZE <S2SV_ModEnd> ) ; if |
6,135 | CWE-000 pregex * pregex_create ( char * pat , int flags ) { pregex * regex ; pregex_ptn * ptn ; PROC ( "pregex_create" ) ; PARMS ( "pat" , "%s" , pat ) ; PARMS ( "flags" , "%d" , flags ) ; if ( ! pregex_ptn_parse ( & ptn , pat , flags ) ) RETURN ( ( pregex * ) NULL ) ; ptn -> accept -> accept = 1 ; regex = ( pregex * ) pmalloc ( sizeof ( pregex ) ) ; regex -> ptn = ptn ; regex -> flags = flags ; if ( ( regex -> trans_cnt = pregex_ptn_to_dfatab ( & regex -> trans , ptn ) ) < 0 ) RETURN ( pregex_free ( regex ) ) ; <S2SV_StartBug> pregex_ptn_to_dfatab ( ( wchar_t * * * ) NULL , ptn ) ; <S2SV_EndBug> RETURN ( regex ) ; } | <S2SV_ModStart> ) ) ; <S2SV_ModEnd> RETURN ( regex |
6,136 | CWE-000 void ft_lstdel ( t_list * * alst , void ( * del ) ( void * , U_LONG ) ) { if ( * alst ) if ( ( * alst ) -> content ) ( * del ) ( ( * alst ) -> content , ( * alst ) -> content_size ) ; if ( ( * alst ) -> next ) ft_lstdel ( & ( * alst ) -> next , del ) ; if ( * alst ) <S2SV_StartBug> ft_memdel ( ( void * * ) ( * alst ) ) ; <S2SV_EndBug> } | <S2SV_ModStart> * * ) alst <S2SV_ModEnd> ) ; } |
6,137 | CWE-000 <S2SV_StartBug> static void mail_index_modseq_update_header ( struct mail_index_view * view , <S2SV_EndBug> uint64_t highest_modseq ) { struct mail_index_map * map = view -> map ; const struct mail_index_ext * ext ; const struct mail_index_modseq_header * old_modseq_hdr ; struct mail_index_modseq_header new_modseq_hdr ; uint32_t ext_map_idx , log_seq ; uoff_t log_offset ; <S2SV_StartBug> if ( ! mail_index_map_get_ext_idx ( map , view -> index -> modseq_ext_id , <S2SV_EndBug> & ext_map_idx ) ) return ; mail_transaction_log_view_get_prev_pos ( view -> log_view , & log_seq , & log_offset ) ; <S2SV_StartBug> ext = array_idx ( & map -> extensions , ext_map_idx ) ; <S2SV_EndBug> old_modseq_hdr = CONST_PTR_OFFSET ( map -> hdr_base , ext -> hdr_offset ) ; if ( old_modseq_hdr -> log_seq < log_seq || ( old_modseq_hdr -> log_seq == log_seq && old_modseq_hdr -> log_offset < log_offset ) ) { i_zero ( & new_modseq_hdr ) ; new_modseq_hdr . highest_modseq = highest_modseq ; new_modseq_hdr . log_seq = log_seq ; new_modseq_hdr . log_offset = log_offset ; buffer_write ( map -> hdr_copy_buf , ext -> hdr_offset , & new_modseq_hdr , sizeof ( new_modseq_hdr ) ) ; map -> hdr_base = map -> hdr_copy_buf -> data ; i_assert ( map -> hdr_copy_buf -> used == map -> hdr . header_size ) ; } } | <S2SV_ModStart> mail_index_modseq_update_header ( struct mail_index_modseq_sync * ctx ) { struct <S2SV_ModStart> mail_index_view * view = ctx -> view ; <S2SV_ModEnd> struct mail_index_map * <S2SV_ModStart> uoff_t log_offset ; uint64_t highest_modseq ; <S2SV_ModStart> log_offset ) ; highest_modseq = mail_transaction_log_view_get_prev_modseq ( view -> log_view ) ; |
6,138 | CWE-000 void likwid_markerInit ( void ) { int i ; int verbosity ; int setinit = 0 ; bstring bThreadStr ; bstring bEventStr ; struct bstrList * threadTokens ; struct bstrList * eventStrings ; char * modeStr = getenv ( "LIKWID_MODE" ) ; char * eventStr = getenv ( "LIKWID_EVENTS" ) ; char * cThreadStr = getenv ( "LIKWID_THREADS" ) ; char * filepath = getenv ( "LIKWID_FILEPATH" ) ; int ( * ownatoi ) ( const char * ) ; ownatoi = & atoi ; if ( ( modeStr != NULL ) && ( filepath != NULL ) && ( eventStr != NULL ) && ( cThreadStr != NULL ) && likwid_init == 0 ) { setinit = 1 ; } else if ( likwid_init == 0 ) { fprintf ( stderr , "Running<S2SV_blank>without<S2SV_blank>Marker<S2SV_blank>API.<S2SV_blank>Activate<S2SV_blank>Marker<S2SV_blank>API<S2SV_blank>with<S2SV_blank>-m<S2SV_blank>on<S2SV_blank>commandline.\\n" ) ; return ; } else { return ; } if ( ! lock_check ( ) ) { fprintf ( stderr , "Access<S2SV_blank>to<S2SV_blank>performance<S2SV_blank>counters<S2SV_blank>is<S2SV_blank>locked.\\n" ) ; exit ( EXIT_FAILURE ) ; } topology_init ( ) ; numa_init ( ) ; affinity_init ( ) ; hashTable_init ( ) ; for ( int i = 0 ; i < MAX_NUM_NODES ; i ++ ) socket_lock [ i ] = LOCK_INIT ; # ifndef LIKWID_USE_PERFEVENT HPMmode ( atoi ( modeStr ) ) ; # endif if ( getenv ( "LIKWID_DEBUG" ) != NULL ) { perfmon_verbosity = atoi ( getenv ( "LIKWID_DEBUG" ) ) ; verbosity = perfmon_verbosity ; } bThreadStr = bfromcstr ( cThreadStr ) ; threadTokens = bsplit ( bThreadStr , ',' ) ; num_cpus = threadTokens -> qty ; for ( i = 0 ; i < num_cpus ; i ++ ) { threads2Cpu [ i ] = ownatoi ( bdata ( threadTokens -> entry [ i ] ) ) ; } bdestroy ( bThreadStr ) ; bstrListDestroy ( threadTokens ) ; if ( getenv ( "LIKWID_PIN" ) != NULL ) { likwid_pinThread ( threads2Cpu [ 0 ] ) ; if ( getenv ( "OMP_NUM_THREADS" ) != NULL ) { if ( ownatoi ( getenv ( "OMP_NUM_THREADS" ) ) > num_cpus ) { use_locks = 1 ; } } if ( getenv ( "CILK_NWORKERS" ) != NULL ) { if ( ownatoi ( getenv ( "CILK_NWORKERS" ) ) > num_cpus ) { use_locks = 1 ; } } } i = perfmon_init ( num_cpus , threads2Cpu ) ; if ( i < 0 ) { return ; } bEventStr = bfromcstr ( eventStr ) ; eventStrings = bsplit ( bEventStr , '|' ) ; numberOfGroups = eventStrings -> qty ; groups = malloc ( numberOfGroups * sizeof ( int ) ) ; if ( ! groups ) { fprintf ( stderr , "Cannot<S2SV_blank>allocate<S2SV_blank>space<S2SV_blank>for<S2SV_blank>group<S2SV_blank>handling.\\n" ) ; bstrListDestroy ( eventStrings ) ; exit ( EXIT_FAILURE ) ; } for ( i = 0 ; i < eventStrings -> qty ; i ++ ) { groups [ i ] = perfmon_addEventSet ( bdata ( eventStrings -> entry [ i ] ) ) ; } bstrListDestroy ( eventStrings ) ; bdestroy ( bEventStr ) ; for ( i = 0 ; i < num_cpus ; i ++ ) { hashTable_initThread ( threads2Cpu [ i ] ) ; for ( int j = 0 ; j < groupSet -> groups [ groups [ 0 ] ] . numberOfEvents ; j ++ ) { groupSet -> groups [ groups [ 0 ] ] . events [ j ] . threadCounter [ i ] . init = TRUE ; groupSet -> groups [ groups [ 0 ] ] . state = STATE_START ; } } if ( setinit ) { likwid_init = 1 ; } groupSet -> activeGroup = 0 ; <S2SV_StartBug> # ifdef LIKWID_USE_PERFEVENT <S2SV_EndBug> perfmon_setupCounters ( groupSet -> activeGroup ) ; perfmon_startCounters ( ) ; # endif } | <S2SV_ModStart> = 0 ; threads2Pthread [ registered_cpus ] = pthread_self ( ) ; registered_cpus ++ ; |
6,139 | CWE-000 void amd64_displaced_step_fixup ( struct gdbarch * gdbarch , <S2SV_StartBug> struct displaced_step_closure * dsc , <S2SV_EndBug> CORE_ADDR from , CORE_ADDR to , struct regcache * regs ) <S2SV_StartBug> { <S2SV_EndBug> enum bfd_endian byte_order = gdbarch_byte_order ( gdbarch ) ; ULONGEST insn_offset = to - from ; <S2SV_StartBug> gdb_byte * insn = dsc -> insn_buf ; <S2SV_EndBug> const struct amd64_insn * insn_details = & dsc -> insn_details ; if ( debug_displaced ) fprintf_unfiltered ( gdb_stdlog , "displaced:<S2SV_blank>fixup<S2SV_blank>(%s,<S2SV_blank>%s),<S2SV_blank>" "insn<S2SV_blank>=<S2SV_blank>0x%02x<S2SV_blank>0x%02x<S2SV_blank>...\\n" , paddress ( gdbarch , from ) , paddress ( gdbarch , to ) , insn [ 0 ] , insn [ 1 ] ) ; if ( dsc -> tmp_used ) { if ( debug_displaced ) fprintf_unfiltered ( gdb_stdlog , "displaced:<S2SV_blank>restoring<S2SV_blank>reg<S2SV_blank>%d<S2SV_blank>to<S2SV_blank>%s\\n" , dsc -> tmp_regno , paddress ( gdbarch , dsc -> tmp_save ) ) ; regcache_cooked_write_unsigned ( regs , dsc -> tmp_regno , dsc -> tmp_save ) ; } if ( ! amd64_absolute_jmp_p ( insn_details ) && ! amd64_absolute_call_p ( insn_details ) && ! amd64_ret_p ( insn_details ) ) { ULONGEST orig_rip ; int insn_len ; regcache_cooked_read_unsigned ( regs , AMD64_RIP_REGNUM , & orig_rip ) ; if ( amd64_syscall_p ( insn_details , & insn_len ) && orig_rip != to + insn_len && orig_rip != to + insn_len + 1 ) { if ( debug_displaced ) fprintf_unfiltered ( gdb_stdlog , "displaced:<S2SV_blank>syscall<S2SV_blank>changed<S2SV_blank>%%rip;<S2SV_blank>" "not<S2SV_blank>relocating\\n" ) ; } else { ULONGEST rip = orig_rip - insn_offset ; regcache_cooked_write_unsigned ( regs , AMD64_RIP_REGNUM , rip ) ; if ( debug_displaced ) fprintf_unfiltered ( gdb_stdlog , "displaced:<S2SV_blank>" "relocated<S2SV_blank>%%rip<S2SV_blank>from<S2SV_blank>%s<S2SV_blank>to<S2SV_blank>%s\\n" , paddress ( gdbarch , orig_rip ) , paddress ( gdbarch , rip ) ) ; } } if ( amd64_call_p ( insn_details ) ) { ULONGEST rsp ; ULONGEST retaddr ; const ULONGEST retaddr_len = 8 ; regcache_cooked_read_unsigned ( regs , AMD64_RSP_REGNUM , & rsp ) ; retaddr = read_memory_unsigned_integer ( rsp , retaddr_len , byte_order ) ; retaddr = ( retaddr - insn_offset ) & 0xffffffffffffffffULL ; write_memory_unsigned_integer ( rsp , retaddr_len , byte_order , retaddr ) ; if ( debug_displaced ) fprintf_unfiltered ( gdb_stdlog , "displaced:<S2SV_blank>relocated<S2SV_blank>return<S2SV_blank>addr<S2SV_blank>at<S2SV_blank>%s<S2SV_blank>" "to<S2SV_blank>%s\\n" , paddress ( gdbarch , rsp ) , paddress ( gdbarch , retaddr ) ) ; } } | <S2SV_ModStart> struct displaced_step_closure * dsc_ <S2SV_ModEnd> , CORE_ADDR from <S2SV_ModStart> regs ) { amd64_displaced_step_closure * dsc = ( amd64_displaced_step_closure * ) dsc_ ; <S2SV_ModStart> dsc -> insn_buf . data ( ) |
6,140 | CWE-000 static LONG f_to_24 ( float value ) { if ( value <= - 1.f ) return 0x80000000 ; if ( value >= 1.f * 0x7FFFFF / 0x800000 ) return 0x7FFFFF00 ; <S2SV_StartBug> return lrintf ( value * 0x80000000U ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> return 0x7FFFFF00 ; # ifdef HAVE_LRINTF <S2SV_ModStart> 0x80000000U ) ; # else return value * 0x80000000U ; # endif |
6,141 | CWE-000 static void heci_pci_set16 ( uint32_t reg , uint32_t val ) { uint16_t v ; <S2SV_StartBug> v = * ( ( uint16_t * ) ( cse_mmio_base_va + reg ) ) ; <S2SV_EndBug> <S2SV_StartBug> * ( ( uint16_t * ) ( cse_mmio_base_va + reg ) ) = v | val ; <S2SV_EndBug> } | <S2SV_ModStart> * ( ( volatile <S2SV_ModStart> * ( ( volatile |
6,142 | CWE-000 PAM_EXTERN int pam_sm_open_session ( pam_handle_t * ph , int flags , int argc , const char * * argv ) { const char * user = NULL , * password = NULL ; struct passwd * pwd ; int ret ; uint args ; int need_daemon = 0 ; args = parse_args ( ph , argc , argv ) ; if ( args & ARG_IGNORE_SERVICE ) return PAM_SUCCESS ; ret = pam_get_user ( ph , & user , NULL ) ; if ( ret != PAM_SUCCESS ) { syslog ( GKR_LOG_ERR , "gkr-pam:<S2SV_blank>couldn\'t<S2SV_blank>get<S2SV_blank>the<S2SV_blank>user<S2SV_blank>name:<S2SV_blank>%s" , pam_strerror ( ph , ret ) ) ; return PAM_SERVICE_ERR ; } pwd = getpwnam ( user ) ; if ( ! pwd ) { syslog ( GKR_LOG_ERR , "gkr-pam:<S2SV_blank>error<S2SV_blank>looking<S2SV_blank>up<S2SV_blank>user<S2SV_blank>information<S2SV_blank>for:<S2SV_blank>%s" , user ) ; return PAM_SERVICE_ERR ; } if ( pam_get_data ( ph , "gkr_system_authtok" , ( const void * * ) & password ) != PAM_SUCCESS ) { password = NULL ; } if ( args & ARG_AUTO_START || password ) { ret = unlock_keyring ( ph , pwd , password , & need_daemon ) ; if ( ret != PAM_SUCCESS && need_daemon && ( args & ARG_AUTO_START ) ) ret = start_daemon ( ph , pwd , true , password ) ; } <S2SV_StartBug> return PAM_SUCCESS ; <S2SV_EndBug> } | <S2SV_ModStart> ) ; } if ( password && pam_set_data ( ph , "gkr_system_authtok" , NULL , NULL ) != PAM_SUCCESS ) { syslog ( GKR_LOG_ERR , "gkr-pam:<S2SV_blank>error<S2SV_blank>destroying<S2SV_blank>the<S2SV_blank>password" ) ; return PAM_SERVICE_ERR ; } |
6,143 | CWE-000 int arch_dup_task_struct ( struct task_struct * dst , struct task_struct * src ) { int ret ; * dst = * src ; if ( fpu_allocated ( & src -> thread . fpu ) ) { memset ( & dst -> thread . fpu , 0 , sizeof ( dst -> thread . fpu ) ) ; ret = fpu_alloc ( & dst -> thread . fpu ) ; if ( ret ) return ret ; <S2SV_StartBug> fpu_copy ( & dst -> thread . fpu , & src -> thread . fpu ) ; <S2SV_EndBug> } return 0 ; } | <S2SV_ModStart> ; fpu_copy ( dst , src <S2SV_ModEnd> ) ; } |
6,144 | CWE-000 struct snd_soc_card * populate_snd_card_dailinks ( struct device * dev ) { struct snd_soc_card * card = & snd_soc_card_msm_card ; struct snd_soc_dai_link * msm8952_dai_links = NULL ; int num_links , ret , len1 , len2 , len3 , len4 , len5 = 0 ; enum codec_variant codec_ver = 0 ; const char * tasha_lite [ NUM_OF_TASHA_LITE_DEVICE ] = { "msm8952-tashalite-snd-card" , "msm8953-tashalite-snd-card" } ; card -> dev = dev ; ret = snd_soc_of_parse_card_name ( card , "qcom,model" ) ; if ( ret ) { dev_err ( dev , "%s:<S2SV_blank>parse<S2SV_blank>card<S2SV_blank>name<S2SV_blank>failed,<S2SV_blank>err:%d\\n" , __func__ , ret ) ; return NULL ; } if ( ! strcmp ( card -> name , "msm8952-tomtom-snd-card" ) ) { len1 = ARRAY_SIZE ( msm8952_common_fe_dai ) ; len2 = len1 + ARRAY_SIZE ( msm8952_tomtom_fe_dai ) ; len3 = len2 + ARRAY_SIZE ( msm8952_tdm_fe_dai ) ; len4 = len3 + ARRAY_SIZE ( msm8952_common_be_dai ) ; len5 = len4 + ARRAY_SIZE ( msm8952_tomtom_be_dai ) ; snd_soc_card_msm [ TOMTOM_CODEC ] . name = card -> name ; card = & snd_soc_card_msm [ TOMTOM_CODEC ] ; num_links = ARRAY_SIZE ( msm8952_tomtom_dai_links ) ; memcpy ( msm8952_tomtom_dai_links , msm8952_common_fe_dai , sizeof ( msm8952_common_fe_dai ) ) ; memcpy ( msm8952_tomtom_dai_links + len1 , msm8952_tomtom_fe_dai , sizeof ( msm8952_tomtom_fe_dai ) ) ; memcpy ( msm8952_tomtom_dai_links + len2 , msm8952_tdm_fe_dai , sizeof ( msm8952_tdm_fe_dai ) ) ; memcpy ( msm8952_tomtom_dai_links + len3 , msm8952_common_be_dai , sizeof ( msm8952_common_be_dai ) ) ; memcpy ( msm8952_tomtom_dai_links + len4 , msm8952_tomtom_be_dai , sizeof ( msm8952_tomtom_be_dai ) ) ; msm8952_dai_links = msm8952_tomtom_dai_links ; } else if ( strnstr ( card -> name , "tasha" , strlen ( card -> name ) ) ) { codec_ver = tasha_codec_ver ( ) ; <S2SV_StartBug> if ( codec_ver == WCD9326 ) { <S2SV_EndBug> if ( ! strcmp ( card -> name , "msm8952-tasha-snd-card" ) ) card -> name = tasha_lite [ MSM8952_TASHA_LITE ] ; else if ( ! strcmp ( card -> name , "msm8953-tasha-snd-card" ) ) card -> name = tasha_lite [ MSM8953_TASHA_LITE ] ; } len1 = ARRAY_SIZE ( msm8952_common_fe_dai ) ; len2 = len1 + ARRAY_SIZE ( msm8952_tasha_fe_dai ) ; len3 = len2 + ARRAY_SIZE ( msm8952_tdm_fe_dai ) ; len4 = len3 + ARRAY_SIZE ( msm8952_common_be_dai ) ; len5 = len4 + ARRAY_SIZE ( msm8952_tasha_be_dai ) ; snd_soc_card_msm [ TASHA_CODEC ] . name = card -> name ; card = & snd_soc_card_msm [ TASHA_CODEC ] ; num_links = ARRAY_SIZE ( msm8952_tasha_dai_links ) ; memcpy ( msm8952_tasha_dai_links , msm8952_common_fe_dai , sizeof ( msm8952_common_fe_dai ) ) ; memcpy ( msm8952_tasha_dai_links + len1 , msm8952_tasha_fe_dai , sizeof ( msm8952_tasha_fe_dai ) ) ; memcpy ( msm8952_tasha_dai_links + len2 , msm8952_tdm_fe_dai , sizeof ( msm8952_tdm_fe_dai ) ) ; memcpy ( msm8952_tasha_dai_links + len3 , msm8952_common_be_dai , sizeof ( msm8952_common_be_dai ) ) ; memcpy ( msm8952_tasha_dai_links + len4 , msm8952_tasha_be_dai , sizeof ( msm8952_tasha_be_dai ) ) ; msm8952_dai_links = msm8952_tasha_dai_links ; } if ( of_property_read_bool ( dev -> of_node , "qcom,hdmi-dba-codec-rx" ) ) { dev_dbg ( dev , "%s():<S2SV_blank>hdmi<S2SV_blank>dba<S2SV_blank>audio<S2SV_blank>support<S2SV_blank>present\\n" , __func__ ) ; memcpy ( msm8952_dai_links + len5 , msm8952_hdmi_dba_dai_link , sizeof ( msm8952_hdmi_dba_dai_link ) ) ; len5 += ARRAY_SIZE ( msm8952_hdmi_dba_dai_link ) ; } else { dev_dbg ( dev , "%s():<S2SV_blank>No<S2SV_blank>hdmi<S2SV_blank>dba<S2SV_blank>present,<S2SV_blank>add<S2SV_blank>quin<S2SV_blank>dai\\n" , __func__ ) ; memcpy ( msm8952_dai_links + len5 , msm8952_quin_dai_link , sizeof ( msm8952_quin_dai_link ) ) ; len5 += ARRAY_SIZE ( msm8952_quin_dai_link ) ; } card -> dai_link = msm8952_dai_links ; card -> num_links = len5 ; card -> dev = dev ; return card ; } | <S2SV_ModStart> ( codec_ver == WCD9XXX ) return NULL ; if ( codec_ver == |
6,145 | CWE-000 int main ( int argc , char * * argv ) { if ( argc < 3 ) { printf ( "The<S2SV_blank>test<S2SV_blank>requires<S2SV_blank>two<S2SV_blank>positive<S2SV_blank>integers:<S2SV_blank>(a)<S2SV_blank>Number<S2SV_blank>of<S2SV_blank>variables<S2SV_blank>and<S2SV_blank>(b)<S2SV_blank>Number<S2SV_blank>of<S2SV_blank>constraints" ) ; return 0 ; } unsigned short int dim = atoi ( argv [ 1 ] ) ; size_t nbcons = atoi ( argv [ 2 ] ) ; if ( dim <= 0 || nbcons <= 0 ) { printf ( "The<S2SV_blank>Input<S2SV_blank>parameters<S2SV_blank>should<S2SV_blank>be<S2SV_blank>positive\\n" ) ; return 0 ; } printf ( "Testing<S2SV_blank>Meet\\n" ) ; test_meetjoin ( dim , nbcons , true ) ; printf ( "Testing<S2SV_blank>Join\\n" ) ; test_meetjoin ( dim , nbcons , false ) ; printf ( "Testing<S2SV_blank>Assign\\n" ) ; test_assign ( dim , nbcons ) ; <S2SV_StartBug> printf ( "Testing<S2SV_blank>Fold\\n" ) ; <S2SV_EndBug> test_fold ( 6 , 6 ) ; printf ( "Testing<S2SV_blank>Expand\\n" ) ; test_expand ( dim , nbcons ) ; } | <S2SV_ModStart> ; printf ( <S2SV_ModEnd> "Testing<S2SV_blank>Expand\\n" ) ; |
6,146 | CWE-000 static int xennet_get_responses ( struct netfront_queue * queue , struct netfront_rx_info * rinfo , RING_IDX rp , struct sk_buff_head * list ) { struct xen_netif_rx_response * rx = & rinfo -> rx ; struct xen_netif_extra_info * extras = rinfo -> extras ; struct device * dev = & queue -> info -> netdev -> dev ; RING_IDX cons = queue -> rx . rsp_cons ; struct sk_buff * skb = xennet_get_rx_skb ( queue , cons ) ; grant_ref_t ref = xennet_get_rx_ref ( queue , cons ) ; <S2SV_StartBug> int max = MAX_SKB_FRAGS + ( rx -> status <= RX_COPY_THRESHOLD ) ; <S2SV_EndBug> int slots = 1 ; int err = 0 ; unsigned long ret ; if ( rx -> flags & XEN_NETRXF_extra_info ) { err = xennet_get_extras ( queue , extras , rp ) ; cons = queue -> rx . rsp_cons ; } for ( ; ; ) { if ( unlikely ( rx -> status < 0 || rx -> offset + rx -> status > XEN_PAGE_SIZE ) ) { if ( net_ratelimit ( ) ) dev_warn ( dev , "rx->offset:<S2SV_blank>%u,<S2SV_blank>size:<S2SV_blank>%d\\n" , rx -> offset , rx -> status ) ; xennet_move_rx_slot ( queue , skb , ref ) ; err = - EINVAL ; goto next ; } if ( ref == GRANT_INVALID_REF ) { if ( net_ratelimit ( ) ) dev_warn ( dev , "Bad<S2SV_blank>rx<S2SV_blank>response<S2SV_blank>id<S2SV_blank>%d.\\n" , rx -> id ) ; err = - EINVAL ; goto next ; } ret = gnttab_end_foreign_access_ref ( ref , 0 ) ; BUG_ON ( ! ret ) ; gnttab_release_grant_reference ( & queue -> gref_rx_head , ref ) ; __skb_queue_tail ( list , skb ) ; next : if ( ! ( rx -> flags & XEN_NETRXF_more_data ) ) break ; if ( cons + slots == rp ) { if ( net_ratelimit ( ) ) dev_warn ( dev , "Need<S2SV_blank>more<S2SV_blank>slots\\n" ) ; err = - ENOENT ; break ; } rx = RING_GET_RESPONSE ( & queue -> rx , cons + slots ) ; skb = xennet_get_rx_skb ( queue , cons + slots ) ; ref = xennet_get_rx_ref ( queue , cons + slots ) ; slots ++ ; } if ( unlikely ( slots > max ) ) { if ( net_ratelimit ( ) ) dev_warn ( dev , "Too<S2SV_blank>many<S2SV_blank>slots\\n" ) ; err = - E2BIG ; } if ( unlikely ( err ) ) queue -> rx . rsp_cons = cons + slots ; return err ; } | <S2SV_ModStart> int max = XEN_NETIF_NR_SLOTS_MIN <S2SV_ModEnd> + ( rx |
6,147 | CWE-000 NV_ID NV_Op_assign ( const NV_ID * tList , int index , const NV_ID * ctx ) { const int operandCount = 2 ; NV_ID operand [ operandCount ] ; int operandIndex [ operandCount ] = { - 1 , 1 } ; const NV_ID scope = NV_Context_getCurrentScope ( ctx ) ; NV_ID v = operand [ 0 ] ; NV_getOperandByList ( tList , index , operandIndex , operand , operandCount ) ; <S2SV_StartBug> if ( NV_Term_isAssignable ( & operand [ 0 ] , & scope ) ) { <S2SV_EndBug> v = NV_Term_getAssignableNode ( & operand [ 0 ] , & scope ) ; } else { if ( ! NV_NodeID_isString ( & operand [ 0 ] ) ) { return NV_Node_createWithString ( "Error:<S2SV_blank>Invalid<S2SV_blank>Operand<S2SV_blank>Type." ) ; } v = NV_Variable_createWithName ( & scope , & operand [ 0 ] ) ; } NV_Variable_assign ( & v , & operand [ 1 ] ) ; NV_removeOperandByList ( tList , index , operandIndex , operandCount ) ; NV_Array_writeToIndex ( tList , index - 1 , & v ) ; return NODEID_NULL ; } | <S2SV_ModStart> operandCount ) ; operand [ 0 ] = NV_Term_tryReadAsVariable ( & operand [ 0 ] , & scope ) ; |
6,148 | CWE-000 <S2SV_StartBug> lval lval_err ( int x ) { <S2SV_EndBug> <S2SV_StartBug> lval v ; <S2SV_EndBug> v . type = LVAL_ERR ; <S2SV_StartBug> v . err = x ; <S2SV_EndBug> return v ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> lval * lval_err ( char * m <S2SV_ModEnd> ) { lval <S2SV_ModStart> ) { lval * v = malloc ( sizeof ( lval ) ) ; v -> <S2SV_ModEnd> type = LVAL_ERR <S2SV_ModStart> LVAL_ERR ; v -> err = malloc ( strlen ( m ) + 1 ) ; strcpy ( v -> err , m ) <S2SV_ModEnd> ; return v |
6,149 | CWE-000 int ufshcd_system_suspend ( struct ufs_hba * hba ) { int ret = 0 ; ktime_t start = ktime_get ( ) ; if ( ! hba || ! hba -> is_powered ) return 0 ; if ( ( ufs_get_pm_lvl_to_dev_pwr_mode ( hba -> spm_lvl ) == hba -> curr_dev_pwr_mode ) && ( ufs_get_pm_lvl_to_link_pwr_state ( hba -> spm_lvl ) == hba -> uic_link_state ) ) goto out ; if ( pm_runtime_suspended ( hba -> dev ) ) { ret = ufshcd_runtime_resume ( hba ) ; if ( ret ) goto out ; } ret = ufshcd_suspend ( hba , UFS_SYSTEM_PM ) ; out : trace_ufshcd_system_suspend ( dev_name ( hba -> dev ) , ret , ktime_to_us ( ktime_sub ( ktime_get ( ) , start ) ) , <S2SV_StartBug> hba -> uic_link_state , hba -> curr_dev_pwr_mode ) ; <S2SV_EndBug> if ( ! ret ) hba -> is_sys_suspended = true ; return ret ; } | <S2SV_ModStart> , hba -> curr_dev_pwr_mode <S2SV_ModEnd> , hba -> <S2SV_ModStart> , hba -> uic_link_state <S2SV_ModEnd> ) ; if |
6,150 | CWE-000 sql_subfunc * sql_find_func ( sql_allocator * sa , sql_schema * s , const char * sqlfname , int nrargs , int type , sql_subfunc * prev ) { sql_subfunc * fres ; int key = hash_key ( sqlfname ) ; sql_hash_e * he ; int found = 0 ; int filt = ( type == F_FUNC ) ? F_FILT : type ; assert ( nrargs ) ; MT_lock_set ( & funcs -> ht_lock ) ; he = funcs -> ht -> buckets [ key & ( funcs -> ht -> size - 1 ) ] ; if ( prev ) { for ( ; he && ! found ; he = he -> chain ) if ( he -> value == prev -> func ) found = 1 ; <S2SV_StartBug> if ( found ) <S2SV_EndBug> he = he -> chain ; } for ( ; he ; he = he -> chain ) { sql_func * f = he -> value ; if ( f -> type != type && f -> type != filt ) continue ; if ( ( fres = func_cmp ( sa , f , sqlfname , nrargs ) ) != NULL ) { MT_lock_unset ( & funcs -> ht_lock ) ; return fres ; } } MT_lock_unset ( & funcs -> ht_lock ) ; if ( s ) { node * n ; if ( s -> funcs . set ) { MT_lock_set ( & s -> funcs . set -> ht_lock ) ; if ( s -> funcs . set -> ht ) { he = s -> funcs . set -> ht -> buckets [ key & ( s -> funcs . set -> ht -> size - 1 ) ] ; if ( prev ) { for ( ; he && ! found ; he = he -> chain ) if ( he -> value == prev -> func ) found = 1 ; <S2SV_StartBug> if ( found ) <S2SV_EndBug> he = he -> chain ; } for ( ; he ; he = he -> chain ) { sql_func * f = he -> value ; if ( f -> type != type && f -> type != filt ) continue ; if ( ( fres = func_cmp ( sa , f , sqlfname , nrargs ) ) != NULL ) { MT_lock_unset ( & s -> funcs . set -> ht_lock ) ; return fres ; } } MT_lock_unset ( & s -> funcs . set -> ht_lock ) ; } else { MT_lock_unset ( & s -> funcs . set -> ht_lock ) ; n = s -> funcs . set -> h ; if ( prev ) { for ( ; n && ! found ; n = n -> next ) if ( n -> data == prev ) found = 1 ; <S2SV_StartBug> if ( found ) <S2SV_EndBug> n = n -> next ; } for ( ; n ; n = n -> next ) { sql_func * f = n -> data ; if ( f -> type != type && f -> type != filt ) continue ; if ( ( fres = func_cmp ( sa , f , sqlfname , nrargs ) ) != NULL ) return fres ; } } } } return NULL ; } | <S2SV_ModStart> = 1 ; <S2SV_ModEnd> } for ( <S2SV_ModStart> = 1 ; <S2SV_ModEnd> } for ( <S2SV_ModStart> = 1 ; <S2SV_ModEnd> } for ( |
6,151 | CWE-000 int nouveau_mem_host ( struct ttm_mem_reg * reg , struct ttm_dma_tt * tt ) { struct nouveau_mem * mem = nouveau_mem ( reg ) ; struct nouveau_cli * cli = mem -> cli ; struct nouveau_drm * drm = cli -> drm ; struct nvif_mmu * mmu = & cli -> mmu ; struct nvif_mem_ram_v0 args = { } ; bool super = cli -> base . super ; u8 type ; int ret ; <S2SV_StartBug> if ( mmu -> type [ drm -> ttm . type_host ] . type & NVIF_MEM_UNCACHED ) <S2SV_EndBug> type = drm -> ttm . type_ncoh ; else type = drm -> ttm . type_host ; if ( mem -> kind && ! ( mmu -> type [ type ] . type & NVIF_MEM_KIND ) ) mem -> comp = mem -> kind = 0 ; if ( mem -> comp && ! ( mmu -> type [ type ] . type & NVIF_MEM_COMP ) ) { if ( mmu -> object . oclass >= NVIF_CLASS_MMU_GF100 ) mem -> kind = mmu -> kind [ mem -> kind ] ; mem -> comp = 0 ; } if ( tt -> ttm . sg ) args . sgl = tt -> ttm . sg -> sgl ; else args . dma = tt -> dma_address ; mutex_lock ( & drm -> master . lock ) ; cli -> base . super = true ; ret = nvif_mem_init_type ( mmu , cli -> mem -> oclass , type , PAGE_SHIFT , reg -> num_pages << PAGE_SHIFT , & args , sizeof ( args ) , & mem -> mem ) ; cli -> base . super = super ; mutex_unlock ( & drm -> master . lock ) ; return ret ; } | <S2SV_ModStart> ; if ( ! nouveau_drm_use_coherent_gpu_mapping ( drm ) ) type = <S2SV_ModEnd> drm -> ttm <S2SV_ModStart> -> ttm . type_ncoh [ ! ! mem -> kind ] ; else type = drm -> ttm . type_host [ 0 ] <S2SV_ModEnd> ; if ( |
6,152 | CWE-000 void rx ( call_t * c , packet_t * packet ) { struct nodedata * nodedata = get_node_private_data ( c ) ; array_t * up = get_entity_bindings_up ( c ) ; int i = up -> size ; struct routing_header * header = ( struct routing_header * ) ( packet -> data + nodedata -> overhead ) ; call_t c0 = { get_entity_bindings_down ( c ) -> elts [ 0 ] , c -> node , c -> entity } ; call_t c1 = { get_entity_bindings_down ( & c0 ) -> elts [ 0 ] , c0 . node , c0 . entity } ; double sensibility_mw , rx_mw , noise_mw ; # ifdef ADAM_TEST uint64_t delay = 0 ; # endif PRINT_ROUTING ( "B:<S2SV_blank>packet->id=%d,<S2SV_blank>c->node=%d\\n" , packet -> id , c -> node ) ; switch ( header -> type ) { case HELLO_PACKET : sensibility_mw = dBm2mW ( radio_get_sensibility ( & c1 ) ) ; rx_mw = dBm2mW ( packet -> rxdBm ) ; noise_mw = MEDIA_GET_WHITE_NOISE ( & c0 , packet -> channel ) ; nodedata -> hello_rx ++ ; PRINT_ROUTING ( "HELLO_PACKET<S2SV_blank>rx_mw=%f,<S2SV_blank>tx_mw=%f,<S2SV_blank>sensibility_mw=%f,<S2SV_blank>noise_mw=%f\\n" , rx_mw , dBm2mW ( packet -> txdBm ) , sensibility_mw , noise_mw ) ; <S2SV_StartBug> add_neighbor_low ( c , header ) ; <S2SV_EndBug> if ( rx_mw > ( noise_mw + sensibility_mw + rx_mw / 3 ) * DEFAULT_SIC_THRESHOLD ) { add_neighbor_high ( c , header ) ; } packet_dealloc ( packet ) ; break ; case DATA_PACKET : nodedata -> data_rx ++ ; PRINT_ROUTING ( "DATA_PACKET<S2SV_blank>header->dst=%d\\n" , header -> dst ) ; if ( ( header -> dst != BROADCAST_ADDR ) && ( header -> dst != c -> node ) ) { forward ( c , packet ) ; goto END ; } # ifdef ADAM_TEST delay = get_time ( ) - header -> time_start ; g_delay += delay ; PRINT_RESULT ( "node<S2SV_blank>%d<S2SV_blank>received<S2SV_blank>packet,<S2SV_blank>delay=%" PRId64 "\\n" , c -> node , delay ) ; PRINT_RESULT ( "%d<S2SV_blank>packets<S2SV_blank>received\\n" , ++ g_num_r ) ; PRINT_RESULT ( "average<S2SV_blank>delay<S2SV_blank>is<S2SV_blank>%f\\n" , g_delay / g_num_r ) ; # endif while ( i -- ) { call_t c_up = { up -> elts [ i ] , c -> node , c -> entity } ; packet_t * packet_up ; if ( i > 0 ) { packet_up = packet_clone ( packet ) ; } else { packet_up = packet ; } RX ( & c_up , packet_up ) ; } break ; default : break ; } END : return ; } | <S2SV_ModStart> noise_mw ) ; if ( rx_mw > ADAM_HIGH_POWER_RATIO * ( noise_mw + sensibility_mw ) ) { <S2SV_ModStart> header ) ; } |
6,153 | CWE-000 static int fill_io_u ( struct thread_data * td , struct io_u * io_u ) { bool is_random ; if ( td_ioengine_flagged ( td , FIO_NOIO ) ) goto out ; set_rw_ddir ( td , io_u ) ; if ( ! ddir_rw ( io_u -> ddir ) ) goto out ; <S2SV_StartBug> if ( td -> o . zone_range ) { <S2SV_EndBug> __fill_io_u_zone ( td , io_u ) ; <S2SV_StartBug> } <S2SV_EndBug> if ( get_next_offset ( td , io_u , & is_random ) ) { dprint ( FD_IO , "io_u<S2SV_blank>%p,<S2SV_blank>failed<S2SV_blank>getting<S2SV_blank>offset\\n" , io_u ) ; return 1 ; } io_u -> buflen = get_next_buflen ( td , io_u , is_random ) ; if ( ! io_u -> buflen ) { dprint ( FD_IO , "io_u<S2SV_blank>%p,<S2SV_blank>failed<S2SV_blank>getting<S2SV_blank>buflen\\n" , io_u ) ; return 1 ; } if ( io_u -> offset + io_u -> buflen > io_u -> file -> real_file_size ) { dprint ( FD_IO , "io_u<S2SV_blank>%p,<S2SV_blank>off=0x%llx<S2SV_blank>+<S2SV_blank>len=0x%lx<S2SV_blank>exceeds<S2SV_blank>file<S2SV_blank>size=0x%llx\\n" , io_u , ( unsigned long long ) io_u -> offset , io_u -> buflen , ( unsigned long long ) io_u -> file -> real_file_size ) ; return 1 ; } if ( td_random ( td ) && file_randommap ( td , io_u -> file ) ) mark_random_map ( td , io_u ) ; out : dprint_io_u ( io_u , "fill" ) ; td -> zone_bytes += io_u -> buflen ; return 0 ; } | <S2SV_ModStart> . zone_range ) <S2SV_ModEnd> __fill_io_u_zone ( td <S2SV_ModStart> io_u ) ; <S2SV_ModEnd> if ( get_next_offset |
6,154 | CWE-000 int rec_memory ( char type , int * curs , t_a * a , int addr ) { int val ; val = 0 ; if ( ( type & 0x03 ) == 0x02 && ! addr ) { val = a -> mem [ * curs ] << 24 ; * curs = ( * curs + 1 ) % MEM_SIZE ; val += a -> mem [ * curs ] << 16 ; * curs = ( * curs + 1 ) % MEM_SIZE ; val += a -> mem [ * curs ] << 8 ; * curs = ( * curs + 1 ) % MEM_SIZE ; val += a -> mem [ * curs ] ; * curs = ( * curs + 1 ) % MEM_SIZE ; } else if ( ( type & 0x03 ) > 1 ) { val = a -> mem [ * curs ] << 8 ; * curs = ( * curs + 1 ) % MEM_SIZE ; val = ( char ) a -> mem [ * curs ] ; * curs = ( * curs + 1 ) % MEM_SIZE ; } else if ( type & 0x01 ) { val = a -> mem [ * curs ] ; <S2SV_StartBug> val = val % ( REG_NUMBER + 1 ) ; <S2SV_EndBug> * curs = ( * curs + 1 ) % MEM_SIZE ; } return ( val ) ; } | <S2SV_ModStart> % ( REG_NUMBER ) ; if ( val <= 0 ) val = REG_NUMBER - val ; val -- <S2SV_ModEnd> ; * curs |
6,155 | CWE-000 static int create_log_socket ( int type ) { <S2SV_StartBug> struct timeval tv ; <S2SV_EndBug> int fd ; fd = socket ( AF_UNIX , type | SOCK_CLOEXEC , 0 ) ; if ( fd < 0 ) return - errno ; fd = fd_move_above_stdio ( fd ) ; <S2SV_StartBug> ( void ) fd_inc_sndbuf ( fd , SNDBUF_SIZE ) ; <S2SV_EndBug> if ( getpid_cached ( ) == 1 ) timeval_store ( & tv , 10 * USEC_PER_MSEC ) ; else timeval_store ( & tv , 10 * USEC_PER_SEC ) ; ( void ) setsockopt ( fd , SOL_SOCKET , SO_SNDTIMEO , & tv , sizeof ( tv ) ) ; return fd ; } | <S2SV_ModStart> struct timeval tv ; int buf_size <S2SV_ModStart> fd ) ; buf_size = SNDBUF_SIZE ; <S2SV_ModStart> ( void ) setsockopt <S2SV_ModEnd> ( fd , <S2SV_ModStart> ( fd , SOL_SOCKET , SO_RCVBUF , & buf_size , sizeof ( buf_size ) <S2SV_ModEnd> ) ; if |
6,156 | CWE-000 static void clearpad_funcarea_initialize ( struct clearpad_t * this ) { struct clearpad_funcarea_t * funcarea ; struct clearpad_area_t pointer_area ; struct clearpad_button_data_t * button ; struct clearpad_pointer_data_t * pointer_data ; const char * func_name [ ] = { [ SYN_FUNCAREA_INSENSIBLE ] = "insensible" , [ SYN_FUNCAREA_POINTER ] = "pointer" , [ SYN_FUNCAREA_BUTTON ] = "button" , } ; this -> funcarea = clearpad_funcarea_get ( this , this -> device_info . customer_family , this -> device_info . firmware_revision_major ) ; funcarea = this -> funcarea ; if ( funcarea == NULL ) { dev_info ( & this -> pdev -> dev , "no<S2SV_blank>funcarea\\n" ) ; return ; } for ( ; funcarea -> func != SYN_FUNCAREA_END ; funcarea ++ ) { switch ( funcarea -> func ) { case SYN_FUNCAREA_POINTER : pointer_area = ( struct clearpad_area_t ) funcarea -> original ; pointer_data = ( struct clearpad_pointer_data_t * ) funcarea -> data ; if ( pointer_data ) { pointer_area . x1 -= pointer_data -> offset_x ; pointer_area . x2 -= pointer_data -> offset_x ; pointer_area . y1 -= pointer_data -> offset_y ; pointer_area . y2 -= pointer_data -> offset_y ; <S2SV_StartBug> } <S2SV_EndBug> input_set_abs_params ( this -> input , ABS_MT_TRACKING_ID , 0 , this -> extents . n_fingers , 0 , 0 ) ; input_set_abs_params ( this -> input , ABS_MT_POSITION_X , pointer_area . x1 , pointer_area . x2 , 0 , 0 ) ; input_set_abs_params ( this -> input , ABS_MT_POSITION_Y , pointer_area . y1 , pointer_area . y2 , 0 , 0 ) ; if ( this -> touch_pressure_enabled ) input_set_abs_params ( this -> input , ABS_MT_PRESSURE , 0 , SYN_MAX_Z_VALUE , 0 , 0 ) ; if ( this -> touch_size_enabled ) { input_set_abs_params ( this -> input , ABS_MT_TOUCH_MAJOR , 0 , SYN_MAX_W_VALUE + 1 , 0 , 0 ) ; input_set_abs_params ( this -> input , ABS_MT_TOUCH_MINOR , 0 , SYN_MAX_W_VALUE + 1 , 0 , 0 ) ; } if ( this -> touch_orientation_enabled ) input_set_abs_params ( this -> input , ABS_MT_ORIENTATION , - 1 , 1 , 0 , 0 ) ; input_set_abs_params ( this -> input , ABS_MT_TOOL_TYPE , 0 , this -> pen . enabled ? MT_TOOL_PEN : MT_TOOL_FINGER , 0 , 0 ) ; break ; case SYN_FUNCAREA_BUTTON : button = ( struct clearpad_button_data_t * ) funcarea -> data ; input_set_capability ( this -> input , EV_KEY , button -> code ) ; break ; default : continue ; } dev_info ( & this -> pdev -> dev , "funcarea<S2SV_blank>\'%s\'<S2SV_blank>[%d,<S2SV_blank>%d,<S2SV_blank>%d,<S2SV_blank>%d]<S2SV_blank>[%d,<S2SV_blank>%d,<S2SV_blank>%d,<S2SV_blank>%d]\\n" , func_name [ funcarea -> func ] , funcarea -> original . x1 , funcarea -> original . y1 , funcarea -> original . x2 , funcarea -> original . y2 , funcarea -> extension . x1 , funcarea -> extension . y1 , funcarea -> extension . x2 , funcarea -> extension . y2 ) ; } } | <S2SV_ModStart> offset_y ; } input_mt_init_slots ( this -> input , this -> extents . n_fingers , 0 ) ; |
6,157 | CWE-000 static int nv04_crtc_do_mode_set_base ( struct drm_crtc * crtc , struct drm_framebuffer * passed_fb , int x , int y , bool atomic ) { struct nouveau_crtc * nv_crtc = nouveau_crtc ( crtc ) ; struct drm_device * dev = crtc -> dev ; struct nouveau_drm * drm = nouveau_drm ( dev ) ; struct nv04_crtc_reg * regp = & nv04_display ( dev ) -> mode_reg . crtc_reg [ nv_crtc -> index ] ; struct drm_framebuffer * drm_fb ; struct nouveau_framebuffer * fb ; int arb_burst , arb_lwm ; NV_DEBUG ( drm , "index<S2SV_blank>%d\\n" , nv_crtc -> index ) ; if ( ! atomic && ! crtc -> primary -> fb ) { NV_DEBUG ( drm , "No<S2SV_blank>FB<S2SV_blank>bound\\n" ) ; return 0 ; } if ( atomic ) { drm_fb = passed_fb ; fb = nouveau_framebuffer ( passed_fb ) ; } else { drm_fb = crtc -> primary -> fb ; fb = nouveau_framebuffer ( crtc -> primary -> fb ) ; } nv_crtc -> fb . offset = fb -> nvbo -> bo . offset ; if ( nv_crtc -> lut . depth != drm_fb -> format -> depth ) { nv_crtc -> lut . depth = drm_fb -> format -> depth ; nv_crtc_gamma_load ( crtc ) ; } regp -> CRTC [ NV_CIO_CRE_PIXEL_INDEX ] &= ~ 3 ; regp -> CRTC [ NV_CIO_CRE_PIXEL_INDEX ] |= ( drm_fb -> format -> depth + 1 ) / 8 ; regp -> ramdac_gen_ctrl &= ~ NV_PRAMDAC_GENERAL_CONTROL_ALT_MODE_SEL ; if ( drm_fb -> format -> depth == 16 ) regp -> ramdac_gen_ctrl |= NV_PRAMDAC_GENERAL_CONTROL_ALT_MODE_SEL ; crtc_wr_cio_state ( crtc , regp , NV_CIO_CRE_PIXEL_INDEX ) ; NVWriteRAMDAC ( dev , nv_crtc -> index , NV_PRAMDAC_GENERAL_CONTROL , regp -> ramdac_gen_ctrl ) ; regp -> CRTC [ NV_CIO_CR_OFFSET_INDEX ] = drm_fb -> pitches [ 0 ] >> 3 ; regp -> CRTC [ NV_CIO_CRE_RPC0_INDEX ] = XLATE ( drm_fb -> pitches [ 0 ] >> 3 , 8 , NV_CIO_CRE_RPC0_OFFSET_10_8 ) ; regp -> CRTC [ NV_CIO_CRE_42 ] = XLATE ( drm_fb -> pitches [ 0 ] / 8 , 11 , NV_CIO_CRE_42_OFFSET_11 ) ; crtc_wr_cio_state ( crtc , regp , NV_CIO_CRE_RPC0_INDEX ) ; crtc_wr_cio_state ( crtc , regp , NV_CIO_CR_OFFSET_INDEX ) ; crtc_wr_cio_state ( crtc , regp , NV_CIO_CRE_42 ) ; regp -> fb_start = nv_crtc -> fb . offset & ~ 3 ; regp -> fb_start += ( y * drm_fb -> pitches [ 0 ] ) + ( x * drm_fb -> format -> cpp [ 0 ] ) ; nv_set_crtc_base ( dev , nv_crtc -> index , regp -> fb_start ) ; nouveau_calc_arb ( dev , crtc -> mode . clock , drm_fb -> format -> cpp [ 0 ] * 8 , & arb_burst , & arb_lwm ) ; regp -> CRTC [ NV_CIO_CRE_FF_INDEX ] = arb_burst ; regp -> CRTC [ NV_CIO_CRE_FFLWM__INDEX ] = arb_lwm & 0xff ; crtc_wr_cio_state ( crtc , regp , NV_CIO_CRE_FF_INDEX ) ; crtc_wr_cio_state ( crtc , regp , NV_CIO_CRE_FFLWM__INDEX ) ; <S2SV_StartBug> if ( drm -> device . info . family >= NV_DEVICE_INFO_V0_KELVIN ) { <S2SV_EndBug> regp -> CRTC [ NV_CIO_CRE_47 ] = arb_lwm >> 8 ; crtc_wr_cio_state ( crtc , regp , NV_CIO_CRE_47 ) ; } return 0 ; } | <S2SV_ModStart> ( drm -> client . |
6,158 | CWE-000 static void write_pixel ( double R , double G , double B , double A , int bytes , unsigned long long int max ) { unsigned long long int colours [ 4 ] ; unsigned char buf [ 4 * 8 ] ; int i , j , k , bm = bytes - 1 ; if ( R < 0 || G < 0 || B < 0 || R > 1 || G > 1 || B > 1 ) { if ( gamut_warning_triggered ) { gamut_warning_triggered = 1 ; weprintf ( "warning:<S2SV_blank>out-of-gamut<S2SV_blank>colour<S2SV_blank>detected\\n" ) ; } ; R = R < 0 ? 0 : R > 1 ? 1 : R ; G = G < 0 ? 0 : G > 1 ? 1 : G ; B = B < 0 ? 0 : B > 1 ? 1 : B ; } if ( A < 0 || A > 1 ) { if ( alpha_warning_triggered ) { alpha_warning_triggered = 1 ; weprintf ( "warning:<S2SV_blank>alpha<S2SV_blank>values<S2SV_blank>truncated\\n" ) ; } A = A < 0 ? 0 : 1 ; } colours [ 0 ] = srgb_encode ( R ) * max + 0.5 ; colours [ 1 ] = srgb_encode ( G ) * max + 0.5 ; colours [ 2 ] = srgb_encode ( B ) * max + 0.5 ; colours [ 3 ] = A * max + 0.5 ; <S2SV_StartBug> for ( i = k = 0 ; i < 4 ; i ++ ) { <S2SV_EndBug> <S2SV_StartBug> for ( j = 0 ; j < bytes ; j ++ , k ++ ) { <S2SV_EndBug> <S2SV_StartBug> buf [ k + bm - j ] = ( unsigned char ) ( colours [ j ] ) ; <S2SV_EndBug> colours [ j ] >>= 8 ; } } <S2SV_StartBug> ewriteall ( STDOUT_FILENO , buf , ( size_t ) bytes * 4 , "<stdout>" ) ; <S2SV_EndBug> } | <S2SV_ModStart> ; i ++ , k += bytes <S2SV_ModStart> bytes ; j <S2SV_ModEnd> ++ ) { <S2SV_ModStart> ( colours [ i ] ) ; colours [ i <S2SV_ModEnd> ] >>= 8 <S2SV_ModStart> , buf , k <S2SV_ModEnd> , "<stdout>" ) |
6,159 | CWE-000 static int print_user_status_info ( sd_bus * bus , const char * path , bool * new_line ) { static const struct bus_properties_map map [ ] = { { "Name" , "s" , NULL , offsetof ( UserStatusInfo , name ) } , { "Linger" , "b" , NULL , offsetof ( UserStatusInfo , linger ) } , { "Slice" , "s" , NULL , offsetof ( UserStatusInfo , slice ) } , { "State" , "s" , NULL , offsetof ( UserStatusInfo , state ) } , { "UID" , "u" , NULL , offsetof ( UserStatusInfo , uid ) } , { "Timestamp" , "t" , NULL , offsetof ( UserStatusInfo , timestamp . realtime ) } , { "TimestampMonotonic" , "t" , NULL , offsetof ( UserStatusInfo , timestamp . monotonic ) } , { "Display" , "(so)" , prop_map_first_of_struct , offsetof ( UserStatusInfo , display ) } , { "Sessions" , "a(so)" , prop_map_sessions_strv , offsetof ( UserStatusInfo , sessions ) } , { } } ; <S2SV_StartBug> char since1 [ FORMAT_TIMESTAMP_RELATIVE_MAX ] , * s1 ; <S2SV_EndBug> char since2 [ FORMAT_TIMESTAMP_MAX ] , * s2 ; _cleanup_ ( user_status_info_clear ) UserStatusInfo i = { } ; int r ; <S2SV_StartBug> r = bus_map_all_properties ( bus , "org.freedesktop.login1" , path , map , & i ) ; <S2SV_EndBug> if ( r < 0 ) <S2SV_StartBug> return log_error_errno ( r , "Could<S2SV_blank>not<S2SV_blank>get<S2SV_blank>properties:<S2SV_blank>%m" ) ; <S2SV_EndBug> if ( * new_line ) printf ( "\\n" ) ; * new_line = true ; if ( i . name ) printf ( "%s<S2SV_blank>(%" PRIu32 ")\\n" , i . name , i . uid ) ; else printf ( "%" PRIu32 "\\n" , i . uid ) ; s1 = format_timestamp_relative ( since1 , sizeof ( since1 ) , i . timestamp . realtime ) ; s2 = format_timestamp ( since2 , sizeof ( since2 ) , i . timestamp . realtime ) ; if ( s1 ) printf ( "\\t<S2SV_blank><S2SV_blank><S2SV_blank>Since:<S2SV_blank>%s;<S2SV_blank>%s\\n" , s2 , s1 ) ; else if ( s2 ) printf ( "\\t<S2SV_blank><S2SV_blank><S2SV_blank>Since:<S2SV_blank>%s\\n" , s2 ) ; if ( ! isempty ( i . state ) ) printf ( "\\t<S2SV_blank><S2SV_blank><S2SV_blank>State:<S2SV_blank>%s\\n" , i . state ) ; if ( ! strv_isempty ( i . sessions ) ) { char * * l ; printf ( "\\tSessions:" ) ; STRV_FOREACH ( l , i . sessions ) printf ( "<S2SV_blank>%s%s" , streq_ptr ( * l , i . display ) ? "*" : "" , * l ) ; printf ( "\\n" ) ; } printf ( "\\t<S2SV_blank><S2SV_blank>Linger:<S2SV_blank>%s\\n" , yes_no ( i . linger ) ) ; if ( i . slice ) { printf ( "\\t<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Unit:<S2SV_blank>%s\\n" , i . slice ) ; show_unit_cgroup ( bus , "org.freedesktop.systemd1.Slice" , i . slice , 0 ) ; show_journal_by_unit ( stdout , i . slice , arg_output , 0 , i . timestamp . monotonic , arg_lines , 0 , get_output_flags ( ) | OUTPUT_BEGIN_NEWLINE , SD_JOURNAL_LOCAL_ONLY , true , NULL ) ; } return 0 ; } | <S2SV_ModStart> } } ; _cleanup_ ( sd_bus_error_free ) sd_bus_error error = SD_BUS_ERROR_NULL ; <S2SV_ModStart> map , & error , & <S2SV_ModStart> ( r , "Could<S2SV_blank>not<S2SV_blank>get<S2SV_blank>properties:<S2SV_blank>%s" , bus_error_message ( & error , r ) <S2SV_ModEnd> ) ; if |
6,160 | CWE-000 int bench_test ( const tst_node * root , char * out_file , const int max ) { <S2SV_StartBug> char prefix [ 3 ] = "" ; <S2SV_EndBug> char word [ WORDMAX ] = "" ; char * * sgl ; FILE * fp = fopen ( out_file , "w" ) ; FILE * dict = fopen ( DICT_FILE , "r" ) ; int idx = 0 , sidx = 0 ; double t1 , t2 ; if ( ! fp || ! dict ) { if ( fp ) { fprintf ( stderr , "error:<S2SV_blank>file<S2SV_blank>open<S2SV_blank>failed<S2SV_blank>in<S2SV_blank>\'%s\'.\\n" , DICT_FILE ) ; fclose ( fp ) ; } if ( dict ) { fprintf ( stderr , "error:<S2SV_blank>file<S2SV_blank>open<S2SV_blank>failed<S2SV_blank>in<S2SV_blank>\'%s\'.\\n" , out_file ) ; fclose ( dict ) ; } return 1 ; } sgl = ( char * * ) malloc ( sizeof ( char * ) * max ) ; while ( fscanf ( dict , "%s" , word ) != EOF ) { if ( strlen ( word ) < 4 ) continue ; <S2SV_StartBug> strncpy ( prefix , word , 3 ) ; <S2SV_EndBug> t1 = tvgetf ( ) ; tst_search_prefix ( root , prefix , sgl , & sidx , max ) ; t2 = tvgetf ( ) ; fprintf ( fp , "%d<S2SV_blank>%f<S2SV_blank>sec\\n" , idx , ( t2 - t1 ) * 1000000 ) ; idx ++ ; } <S2SV_StartBug> fclose ( fp ) ; <S2SV_EndBug> fclose ( dict ) ; return 0 ; } | <S2SV_ModStart> char prefix [ 4 <S2SV_ModEnd> ] = "" <S2SV_ModStart> , 3 ) ; prefix [ 3 ] = '\\0' <S2SV_ModStart> ++ ; } puts ( "finish" ) ; |
6,161 | CWE-000 static void yy_syntax_error ( yyParser * yypParser , int yymajor , <S2SV_StartBug> YYMINORTYPE yyminor <S2SV_EndBug> ) { sqlite3ParserARG_FETCH ; <S2SV_StartBug> # define TOKEN ( yyminor . yy0 ) <S2SV_EndBug> UNUSED_PARAMETER ( yymajor ) ; assert ( TOKEN . z [ 0 ] ) ; sqlite3ErrorMsg ( pParse , "near<S2SV_blank>\\"%T\\":<S2SV_blank>syntax<S2SV_blank>error" , & TOKEN ) ; sqlite3ParserARG_STORE ; } | <S2SV_ModStart> int yymajor , sqlite3ParserTOKENTYPE <S2SV_ModEnd> yyminor ) { <S2SV_ModStart> # define TOKEN yyminor <S2SV_ModEnd> UNUSED_PARAMETER ( yymajor |
6,162 | CWE-000 char * * new_pdir ( char * path ) { char * * pdir ; DIR * dire ; struct dirent * new ; int i ; i = 0 ; pdir = NULL ; <S2SV_StartBug> dire = NULL ; <S2SV_EndBug> if ( ( dire = opendir ( path ) ) ) <S2SV_StartBug> { <S2SV_EndBug> if ( ! ( pdir = ( char * * ) malloc ( sizeof ( char * ) * ( pdir_len ( path ) + 1 ) ) ) ) exit ( EXIT_FAILURE ) ; new = readdir ( dire ) ; while ( new ) { pdir [ i ] = ft_strdup ( new -> d_name ) ; i ++ ; new = readdir ( dire ) ; } pdir [ i ] = 0 ; closedir ( dire ) ; } return ( pdir ) ; } | <S2SV_ModStart> = NULL ; <S2SV_ModEnd> if ( ( <S2SV_ModStart> ) ) { ft_putendl ( "tst" ) ; |
6,163 | CWE-000 void m_foutput ( FILE * fp , const MAT * a ) # endif { unsigned int i , j , tmp ; if ( a == ( MAT * ) NULL ) { fprintf ( fp , "Matrix:<S2SV_blank>NULL\\n" ) ; return ; } fprintf ( fp , "Matrix:<S2SV_blank>%d<S2SV_blank>by<S2SV_blank>%d\\n" , a -> m , a -> n ) ; <S2SV_StartBug> if ( a -> me == ( Real * * ) NULL ) <S2SV_EndBug> { fprintf ( fp , "NULL\\n" ) ; return ; } for ( i = 0 ; i < a -> m ; i ++ ) { fprintf ( fp , "row<S2SV_blank>%u:<S2SV_blank>" , i ) ; for ( j = 0 , tmp = 2 ; j < a -> n ; j ++ , tmp ++ ) { fprintf ( fp , format , a -> me [ i ] [ j ] ) ; if ( ! ( tmp % 5 ) ) putc ( '\\n' , fp ) ; } if ( tmp % 5 != 1 ) putc ( '\\n' , fp ) ; } } | <S2SV_ModStart> me == ( double <S2SV_ModEnd> * * ) |
6,164 | CWE-000 esp_http_client_handle_t esp_http_client_init ( esp_http_client_config_t * config ) { esp_http_client_handle_t client = calloc ( 1 , sizeof ( esp_http_client_t ) ) ; assert ( client ) ; client -> parser = calloc ( 1 , sizeof ( struct http_parser ) ) ; client -> parser_settings = calloc ( 1 , sizeof ( struct http_parser_settings ) ) ; client -> parser_settings -> on_message_begin = http_on_message_begin ; client -> parser_settings -> on_url = http_on_url ; client -> parser_settings -> on_status = http_on_status ; client -> parser_settings -> on_header_field = http_on_header_field ; client -> parser_settings -> on_header_value = http_on_header_value ; client -> parser_settings -> on_headers_complete = http_on_headers_complete ; client -> parser_settings -> on_body = http_on_body ; client -> parser_settings -> on_message_complete = http_on_message_complete ; client -> parser_settings -> on_chunk_complete = http_on_chunk_complete ; client -> parser -> data = client ; client -> auth_data = calloc ( 1 , sizeof ( esp_http_auth_data_t ) ) ; assert ( client -> auth_data ) ; client -> transport_list = transport_list_init ( ) ; transport_handle_t tcp = transport_tcp_init ( ) ; transport_set_default_port ( tcp , DEFAULT_HTTP_PORT ) ; transport_list_add ( client -> transport_list , tcp , "http" ) ; # ifdef CONFIG_ENABLE_HTTPS transport_handle_t ssl = transport_ssl_init ( ) ; transport_set_default_port ( ssl , DEFAULT_HTTPS_PORT ) ; if ( config -> cert_pem ) { transport_ssl_set_cert_data ( ssl , config -> cert_pem , strlen ( config -> cert_pem ) ) ; } transport_list_add ( client -> transport_list , ssl , "https" ) ; # endif _set_config ( client , config ) ; client -> request = calloc ( 1 , sizeof ( http_data_t ) ) ; assert ( client -> request ) ; client -> response = calloc ( 1 , sizeof ( http_data_t ) ) ; assert ( client -> response ) ; client -> request -> headers = http_header_init ( ) ; client -> response -> headers = http_header_init ( ) ; client -> request -> buffer = calloc ( 1 , sizeof ( http_buffer_t ) ) ; assert ( client -> request -> buffer ) ; client -> response -> buffer = calloc ( 1 , sizeof ( http_buffer_t ) ) ; assert ( client -> response -> buffer ) ; client -> request -> buffer -> data = malloc ( client -> buffer_size ) ; assert ( client -> request -> buffer -> data ) ; client -> response -> buffer -> data = malloc ( client -> buffer_size ) ; assert ( client -> response -> buffer -> data ) ; esp_http_client_set_uri ( client , config -> uri ) ; esp_http_client_set_header ( client , "User-Agent" , DEFAULT_HTTP_USER_AGENT ) ; esp_http_client_set_header ( client , "Host" , client -> connection_info . host ) ; <S2SV_StartBug> esp_http_client_set_header ( client , "Content-Length" , "0" ) ; <S2SV_EndBug> client -> event . client = client ; client -> state = HTTP_STATE_INIT ; return client ; } | <S2SV_ModStart> host ) ; <S2SV_ModEnd> client -> event |
6,165 | CWE-000 int jfs_set_acl ( struct inode * inode , struct posix_acl * acl , int type ) { int rc ; tid_t tid ; tid = txBegin ( inode -> i_sb , 0 ) ; mutex_lock ( & JFS_IP ( inode ) -> commit_mutex ) ; <S2SV_StartBug> rc = __jfs_set_acl ( tid , inode , type , acl ) ; <S2SV_EndBug> if ( ! rc ) rc = txCommit ( tid , 1 , & inode , 0 ) ; <S2SV_StartBug> txEnd ( tid ) ; <S2SV_EndBug> mutex_unlock ( & JFS_IP ( inode ) -> commit_mutex ) ; return rc ; } | <S2SV_ModStart> commit_mutex ) ; if ( type == ACL_TYPE_ACCESS && acl ) { rc = posix_acl_update_mode ( inode , & inode -> i_mode , & acl ) ; if ( rc ) goto end_tx ; inode -> i_ctime = current_time ( inode ) ; mark_inode_dirty ( inode ) ; } <S2SV_ModStart> 0 ) ; end_tx : |
6,166 | CWE-000 void hyperv_init ( void ) { u64 guest_id ; union hv_x64_msr_hypercall_contents hypercall_msr ; if ( x86_hyper != & x86_hyper_ms_hyperv ) return ; guest_id = generate_guest_id ( 0 , LINUX_VERSION_CODE , 0 ) ; wrmsrl ( HV_X64_MSR_GUEST_OS_ID , guest_id ) ; hypercall_pg = __vmalloc ( PAGE_SIZE , GFP_KERNEL , PAGE_KERNEL_RX ) ; if ( hypercall_pg == NULL ) { wrmsrl ( HV_X64_MSR_GUEST_OS_ID , 0 ) ; return ; } rdmsrl ( HV_X64_MSR_HYPERCALL , hypercall_msr . as_uint64 ) ; hypercall_msr . enable = 1 ; hypercall_msr . guest_physical_address = vmalloc_to_pfn ( hypercall_pg ) ; wrmsrl ( HV_X64_MSR_HYPERCALL , hypercall_msr . as_uint64 ) ; # ifdef CONFIG_X86_64 if ( ms_hyperv . features & HV_X64_MSR_REFERENCE_TSC_AVAILABLE ) { union hv_x64_msr_hypercall_contents tsc_msr ; tsc_pg = __vmalloc ( PAGE_SIZE , GFP_KERNEL , PAGE_KERNEL ) ; if ( ! tsc_pg ) goto register_msr_cs ; hyperv_cs = & hyperv_cs_tsc ; rdmsrl ( HV_X64_MSR_REFERENCE_TSC , tsc_msr . as_uint64 ) ; tsc_msr . enable = 1 ; tsc_msr . guest_physical_address = vmalloc_to_pfn ( tsc_pg ) ; wrmsrl ( HV_X64_MSR_REFERENCE_TSC , tsc_msr . as_uint64 ) ; clocksource_register_hz ( & hyperv_cs_tsc , NSEC_PER_SEC / 100 ) ; return ; } <S2SV_StartBug> # endif <S2SV_EndBug> register_msr_cs : hyperv_cs = & hyperv_cs_msr ; if ( ms_hyperv . features & HV_X64_MSR_TIME_REF_COUNT_AVAILABLE ) clocksource_register_hz ( & hyperv_cs_msr , NSEC_PER_SEC / 100 ) ; } | <S2SV_ModStart> return ; } register_msr_cs : # endif <S2SV_ModEnd> hyperv_cs = & |
6,167 | CWE-000 static int smb1351_parse_dt ( struct smb1351_charger * chip ) { int rc ; struct device_node * node = chip -> dev -> of_node ; if ( ! node ) { pr_err ( "device<S2SV_blank>tree<S2SV_blank>info.<S2SV_blank>missing\\n" ) ; return - EINVAL ; } chip -> usb_suspended_status = of_property_read_bool ( node , "qcom,charging-disabled" ) ; chip -> chg_autonomous_mode = of_property_read_bool ( node , "qcom,chg-autonomous-mode" ) ; chip -> disable_apsd = of_property_read_bool ( node , "qcom,disable-apsd" ) ; chip -> using_pmic_therm = of_property_read_bool ( node , "qcom,using-pmic-therm" ) ; chip -> bms_controlled_charging = of_property_read_bool ( node , "qcom,bms-controlled-charging" ) ; chip -> force_hvdcp_2p0 = of_property_read_bool ( node , "qcom,force-hvdcp-2p0" ) ; rc = of_property_read_string ( node , "qcom,bms-psy-name" , & chip -> bms_psy_name ) ; if ( rc ) chip -> bms_psy_name = NULL ; rc = of_property_read_u32 ( node , "qcom,fastchg-current-max-ma" , & chip -> target_fastchg_current_max_ma ) ; if ( rc ) chip -> target_fastchg_current_max_ma = SMB1351_CHG_FAST_MAX_MA ; chip -> iterm_disabled = of_property_read_bool ( node , "qcom,iterm-disabled" ) ; rc = of_property_read_u32 ( node , "qcom,iterm-ma" , & chip -> iterm_ma ) ; if ( rc ) chip -> iterm_ma = - EINVAL ; rc = of_property_read_u32 ( node , "qcom,float-voltage-mv" , & chip -> vfloat_mv ) ; if ( rc ) chip -> vfloat_mv = - EINVAL ; rc = of_property_read_u32 ( node , "qcom,recharge-mv" , & chip -> recharge_mv ) ; if ( rc ) chip -> recharge_mv = - EINVAL ; chip -> recharge_disabled = of_property_read_bool ( node , "qcom,recharge-disabled" ) ; <S2SV_StartBug> rc = of_property_read_u32 ( node , "qcom,batt-cold-decidegc" , <S2SV_EndBug> & chip -> batt_cold_decidegc ) ; if ( rc < 0 ) chip -> batt_cold_decidegc = - EINVAL ; rc = of_property_read_u32 ( node , "qcom,batt-hot-decidegc" , & chip -> batt_hot_decidegc ) ; if ( rc < 0 ) chip -> batt_hot_decidegc = - EINVAL ; rc = of_property_read_u32 ( node , "qcom,batt-warm-decidegc" , & chip -> batt_warm_decidegc ) ; rc |= of_property_read_u32 ( node , "qcom,batt-cool-decidegc" , & chip -> batt_cool_decidegc ) ; if ( ! rc ) { rc = of_property_read_u32 ( node , "qcom,batt-cool-mv" , & chip -> batt_cool_mv ) ; rc |= of_property_read_u32 ( node , "qcom,batt-warm-mv" , & chip -> batt_warm_mv ) ; rc |= of_property_read_u32 ( node , "qcom,batt-cool-ma" , & chip -> batt_cool_ma ) ; rc |= of_property_read_u32 ( node , "qcom,batt-warm-ma" , & chip -> batt_warm_ma ) ; if ( rc ) chip -> jeita_supported = false ; else chip -> jeita_supported = true ; } pr_debug ( "jeita_supported<S2SV_blank>=<S2SV_blank>%d\\n" , chip -> jeita_supported ) ; rc = of_property_read_u32 ( node , "qcom,batt-missing-decidegc" , & chip -> batt_missing_decidegc ) ; chip -> pinctrl_state_name = of_get_property ( node , "pinctrl-names" , NULL ) ; return 0 ; } | <S2SV_ModStart> ( node , "qcom,switch-freq" , & chip -> switch_freq ) ; rc = of_property_read_u32 ( node , |
6,168 | CWE-000 __kernel_size_t __clear_user_hexagon ( void __user * dest , unsigned long count ) { long uncleared ; while ( count > PAGE_SIZE ) { <S2SV_StartBug> uncleared = __copy_to_user_hexagon ( dest , & empty_zero_page , <S2SV_EndBug> PAGE_SIZE ) ; if ( uncleared ) return count - ( PAGE_SIZE - uncleared ) ; count -= PAGE_SIZE ; dest += PAGE_SIZE ; } if ( count ) <S2SV_StartBug> count = __copy_to_user_hexagon ( dest , & empty_zero_page , count ) ; <S2SV_EndBug> return count ; } | <S2SV_ModStart> { uncleared = raw_copy_to_user <S2SV_ModEnd> ( dest , <S2SV_ModStart> ) count = raw_copy_to_user <S2SV_ModEnd> ( dest , |
6,169 | CWE-000 struct coll * coll_new ( const struct coll_def * def ) { assert ( def -> type == COLL_TYPE_ICU ) ; size_t total_len = sizeof ( struct coll ) + def -> name_len + 1 ; struct coll * coll = ( struct coll * ) calloc ( 1 , total_len ) ; if ( coll == NULL ) { diag_set ( OutOfMemory , total_len , "malloc" , "struct<S2SV_blank>coll" ) ; return NULL ; <S2SV_StartBug> } <S2SV_EndBug> coll -> id = def -> id ; coll -> owner_id = def -> owner_id ; coll -> type = def -> type ; coll -> name_len = def -> name_len ; memcpy ( coll -> name , def -> name , def -> name_len ) ; coll -> name [ coll -> name_len ] = 0 ; if ( coll_icu_init_cmp ( coll , def ) != 0 ) { free ( coll ) ; return NULL ; } return coll ; } | <S2SV_ModStart> NULL ; } coll -> refs = 1 ; |
6,170 | CWE-000 static bool describeOneTSParser ( const char * oid , const char * nspname , const char * prsname ) { PQExpBufferData buf ; PGresult * res ; char title [ 1024 ] ; printQueryOpt myopt = pset . popt ; static const bool translate_columns [ ] = { true , false , false } ; initPQExpBuffer ( & buf ) ; printfPQExpBuffer ( & buf , "SELECT<S2SV_blank>\'%s\'<S2SV_blank>AS<S2SV_blank>\\"%s\\",<S2SV_blank>\\n" "<S2SV_blank><S2SV_blank><S2SV_blank>p.prsstart::pg_catalog.regproc<S2SV_blank>AS<S2SV_blank>\\"%s\\",<S2SV_blank>\\n" "<S2SV_blank><S2SV_blank><S2SV_blank>pg_catalog.obj_description(p.prsstart,<S2SV_blank>\'pg_proc\')<S2SV_blank>as<S2SV_blank>\\"%s\\"<S2SV_blank>\\n" "<S2SV_blank>FROM<S2SV_blank>pg_catalog.pg_ts_parser<S2SV_blank>p<S2SV_blank>\\n" "<S2SV_blank>WHERE<S2SV_blank>p.oid<S2SV_blank>=<S2SV_blank>\'%s\'<S2SV_blank>\\n" "UNION<S2SV_blank>ALL<S2SV_blank>\\n" "SELECT<S2SV_blank>\'%s\',<S2SV_blank>\\n" "<S2SV_blank><S2SV_blank><S2SV_blank>p.prstoken::pg_catalog.regproc,<S2SV_blank>\\n" "<S2SV_blank><S2SV_blank><S2SV_blank>pg_catalog.obj_description(p.prstoken,<S2SV_blank>\'pg_proc\')<S2SV_blank>\\n" "<S2SV_blank>FROM<S2SV_blank>pg_catalog.pg_ts_parser<S2SV_blank>p<S2SV_blank>\\n" "<S2SV_blank>WHERE<S2SV_blank>p.oid<S2SV_blank>=<S2SV_blank>\'%s\'<S2SV_blank>\\n" "UNION<S2SV_blank>ALL<S2SV_blank>\\n" "SELECT<S2SV_blank>\'%s\',<S2SV_blank>\\n" "<S2SV_blank><S2SV_blank><S2SV_blank>p.prsend::pg_catalog.regproc,<S2SV_blank>\\n" "<S2SV_blank><S2SV_blank><S2SV_blank>pg_catalog.obj_description(p.prsend,<S2SV_blank>\'pg_proc\')<S2SV_blank>\\n" "<S2SV_blank>FROM<S2SV_blank>pg_catalog.pg_ts_parser<S2SV_blank>p<S2SV_blank>\\n" "<S2SV_blank>WHERE<S2SV_blank>p.oid<S2SV_blank>=<S2SV_blank>\'%s\'<S2SV_blank>\\n" "UNION<S2SV_blank>ALL<S2SV_blank>\\n" "SELECT<S2SV_blank>\'%s\',<S2SV_blank>\\n" "<S2SV_blank><S2SV_blank><S2SV_blank>p.prsheadline::pg_catalog.regproc,<S2SV_blank>\\n" "<S2SV_blank><S2SV_blank><S2SV_blank>pg_catalog.obj_description(p.prsheadline,<S2SV_blank>\'pg_proc\')<S2SV_blank>\\n" "<S2SV_blank>FROM<S2SV_blank>pg_catalog.pg_ts_parser<S2SV_blank>p<S2SV_blank>\\n" "<S2SV_blank>WHERE<S2SV_blank>p.oid<S2SV_blank>=<S2SV_blank>\'%s\'<S2SV_blank>\\n" "UNION<S2SV_blank>ALL<S2SV_blank>\\n" "SELECT<S2SV_blank>\'%s\',<S2SV_blank>\\n" "<S2SV_blank><S2SV_blank><S2SV_blank>p.prslextype::pg_catalog.regproc,<S2SV_blank>\\n" "<S2SV_blank><S2SV_blank><S2SV_blank>pg_catalog.obj_description(p.prslextype,<S2SV_blank>\'pg_proc\')<S2SV_blank>\\n" "<S2SV_blank>FROM<S2SV_blank>pg_catalog.pg_ts_parser<S2SV_blank>p<S2SV_blank>\\n" "<S2SV_blank>WHERE<S2SV_blank>p.oid<S2SV_blank>=<S2SV_blank>\'%s\';" , gettext_noop ( "Start<S2SV_blank>parse" ) , gettext_noop ( "Method" ) , gettext_noop ( "Function" ) , gettext_noop ( "Description" ) , oid , gettext_noop ( "Get<S2SV_blank>next<S2SV_blank>token" ) , oid , gettext_noop ( "End<S2SV_blank>parse" ) , oid , gettext_noop ( "Get<S2SV_blank>headline" ) , oid , gettext_noop ( "Get<S2SV_blank>token<S2SV_blank>types" ) , oid ) ; res = PSQLexec ( buf . data , false ) ; termPQExpBuffer ( & buf ) ; if ( ! res ) return false ; myopt . nullPrint = NULL ; if ( nspname ) sprintf ( title , _ ( "Text<S2SV_blank>search<S2SV_blank>parser<S2SV_blank>\\"%s.%s\\"" ) , nspname , prsname ) ; else sprintf ( title , _ ( "Text<S2SV_blank>search<S2SV_blank>parser<S2SV_blank>\\"%s\\"" ) , prsname ) ; myopt . title = title ; myopt . footers = NULL ; myopt . topt . default_footer = false ; myopt . translate_header = true ; myopt . translate_columns = translate_columns ; <S2SV_StartBug> printQuery ( res , & myopt , pset . queryFout , pset . logfile ) ; <S2SV_EndBug> PQclear ( res ) ; initPQExpBuffer ( & buf ) ; printfPQExpBuffer ( & buf , "SELECT<S2SV_blank>t.alias<S2SV_blank>as<S2SV_blank>\\"%s\\",<S2SV_blank>\\n" "<S2SV_blank><S2SV_blank>t.description<S2SV_blank>as<S2SV_blank>\\"%s\\"<S2SV_blank>\\n" "FROM<S2SV_blank>pg_catalog.ts_token_type(<S2SV_blank>\'%s\'::pg_catalog.oid<S2SV_blank>)<S2SV_blank>as<S2SV_blank>t<S2SV_blank>\\n" "ORDER<S2SV_blank>BY<S2SV_blank>1;" , gettext_noop ( "Token<S2SV_blank>name" ) , gettext_noop ( "Description" ) , oid ) ; res = PSQLexec ( buf . data , false ) ; termPQExpBuffer ( & buf ) ; if ( ! res ) return false ; myopt . nullPrint = NULL ; if ( nspname ) sprintf ( title , _ ( "Token<S2SV_blank>types<S2SV_blank>for<S2SV_blank>parser<S2SV_blank>\\"%s.%s\\"" ) , nspname , prsname ) ; else sprintf ( title , _ ( "Token<S2SV_blank>types<S2SV_blank>for<S2SV_blank>parser<S2SV_blank>\\"%s\\"" ) , prsname ) ; myopt . title = title ; myopt . footers = NULL ; myopt . topt . default_footer = true ; myopt . translate_header = true ; <S2SV_StartBug> myopt . translate_columns = NULL ; <S2SV_EndBug> printQuery ( res , & myopt , pset . queryFout , pset . logfile ) ; PQclear ( res ) ; return true ; } | <S2SV_ModStart> = translate_columns ; myopt . n_translate_columns = lengthof ( translate_columns ) ; <S2SV_ModStart> translate_columns = NULL ; myopt . n_translate_columns = 0 |
6,171 | CWE-000 int setAudioStreamType ( VideoState * * ps , int type ) { VideoState * is = * ps ; if ( is ) { <S2SV_StartBug> return NO_ERROR ; <S2SV_EndBug> } return INVALID_OPERATION ; } | <S2SV_ModStart> is ) { is -> stream_type = type ; |
6,172 | CWE-000 <S2SV_StartBug> static void snd_timer_check_master ( struct snd_timer_instance * master ) <S2SV_EndBug> { struct snd_timer_instance * slave , * tmp ; list_for_each_entry_safe ( slave , tmp , & snd_timer_slave_list , open_list ) { if ( slave -> slave_class == master -> slave_class && slave -> slave_id == master -> slave_id ) { <S2SV_StartBug> list_move_tail ( & slave -> open_list , & master -> slave_list_head ) ; <S2SV_EndBug> spin_lock_irq ( & slave_active_lock ) ; spin_lock ( & master -> timer -> lock ) ; slave -> master = master ; slave -> timer = master -> timer ; if ( slave -> flags & SNDRV_TIMER_IFLG_RUNNING ) list_add_tail ( & slave -> active_list , & master -> slave_active_head ) ; spin_unlock ( & master -> timer -> lock ) ; spin_unlock_irq ( & slave_active_lock ) ; } } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> <S2SV_null> <S2SV_null> static int <S2SV_ModEnd> snd_timer_check_master ( struct <S2SV_ModStart> slave_id ) { if ( master -> timer -> num_instances >= master -> timer -> max_instances ) return - EBUSY ; <S2SV_ModStart> -> slave_list_head ) ; master -> timer -> num_instances ++ <S2SV_ModStart> ; } } return 0 ; |
6,173 | CWE-000 int comm_buf_to_queue ( struct comm_buffer_queue_s * q , struct comm_buffer_s * b ) { b -> next = NULL ; <S2SV_StartBug> if ( q -> last ) <S2SV_EndBug> <S2SV_StartBug> q -> last -> next = b ; <S2SV_EndBug> else q -> last = q -> first = b ; return ( 0 ) ; } | <S2SV_ModStart> -> last ) { <S2SV_ModStart> = b ; q -> last = b ; } |
6,174 | CWE-000 static struct type * decode_base_type ( struct coff_symbol * cs , unsigned int c_type , union internal_auxent * aux , struct objfile * objfile ) { struct gdbarch * gdbarch = get_objfile_arch ( objfile ) ; struct type * type ; switch ( c_type ) { case T_NULL : return objfile_type ( objfile ) -> builtin_void ; # ifdef T_VOID case T_VOID : return objfile_type ( objfile ) -> builtin_void ; # endif case T_CHAR : return objfile_type ( objfile ) -> builtin_char ; case T_SHORT : return objfile_type ( objfile ) -> builtin_short ; case T_INT : return objfile_type ( objfile ) -> builtin_int ; case T_LONG : if ( cs -> c_sclass == C_FIELD && aux -> x_sym . x_misc . x_lnsz . x_size > gdbarch_long_bit ( gdbarch ) ) return objfile_type ( objfile ) -> builtin_long_long ; else return objfile_type ( objfile ) -> builtin_long ; case T_FLOAT : return objfile_type ( objfile ) -> builtin_float ; case T_DOUBLE : return objfile_type ( objfile ) -> builtin_double ; case T_LNGDBL : return objfile_type ( objfile ) -> builtin_long_double ; case T_STRUCT : if ( cs -> c_naux != 1 ) { type = coff_alloc_type ( cs -> c_symnum ) ; TYPE_CODE ( type ) = TYPE_CODE_STRUCT ; TYPE_NAME ( type ) = NULL ; TYPE_TAG_NAME ( type ) = NULL ; INIT_CPLUS_SPECIFIC ( type ) ; TYPE_LENGTH ( type ) = 0 ; TYPE_FIELDS ( type ) = 0 ; TYPE_NFIELDS ( type ) = 0 ; } else { type = coff_read_struct_type ( cs -> c_symnum , aux -> x_sym . x_misc . x_lnsz . x_size , aux -> x_sym . x_fcnary . x_fcn . x_endndx . l , objfile ) ; } return type ; case T_UNION : if ( cs -> c_naux != 1 ) { type = coff_alloc_type ( cs -> c_symnum ) ; TYPE_NAME ( type ) = NULL ; TYPE_TAG_NAME ( type ) = NULL ; INIT_CPLUS_SPECIFIC ( type ) ; TYPE_LENGTH ( type ) = 0 ; TYPE_FIELDS ( type ) = 0 ; TYPE_NFIELDS ( type ) = 0 ; } else { type = coff_read_struct_type ( cs -> c_symnum , aux -> x_sym . x_misc . x_lnsz . x_size , aux -> x_sym . x_fcnary . x_fcn . x_endndx . l , objfile ) ; } TYPE_CODE ( type ) = TYPE_CODE_UNION ; return type ; case T_ENUM : if ( cs -> c_naux != 1 ) { type = coff_alloc_type ( cs -> c_symnum ) ; TYPE_CODE ( type ) = TYPE_CODE_ENUM ; TYPE_NAME ( type ) = NULL ; TYPE_TAG_NAME ( type ) = NULL ; TYPE_LENGTH ( type ) = 0 ; TYPE_FIELDS ( type ) = 0 ; TYPE_NFIELDS ( type ) = 0 ; } else { type = coff_read_enum_type ( cs -> c_symnum , aux -> x_sym . x_misc . x_lnsz . x_size , aux -> x_sym . x_fcnary . x_fcn . x_endndx . l , objfile ) ; } return type ; case T_MOE : break ; case T_UCHAR : return objfile_type ( objfile ) -> builtin_unsigned_char ; case T_USHORT : return objfile_type ( objfile ) -> builtin_unsigned_short ; case T_UINT : return objfile_type ( objfile ) -> builtin_unsigned_int ; case T_ULONG : if ( cs -> c_sclass == C_FIELD && aux -> x_sym . x_misc . x_lnsz . x_size > gdbarch_long_bit ( gdbarch ) ) return objfile_type ( objfile ) -> builtin_unsigned_long_long ; else return objfile_type ( objfile ) -> builtin_unsigned_long ; } <S2SV_StartBug> complaint ( & symfile_complaints , <S2SV_EndBug> _ ( "Unexpected<S2SV_blank>type<S2SV_blank>for<S2SV_blank>symbol<S2SV_blank>%s" ) , cs -> c_name ) ; return objfile_type ( objfile ) -> builtin_void ; } | <S2SV_ModStart> } complaint ( <S2SV_ModEnd> _ ( "Unexpected<S2SV_blank>type<S2SV_blank>for<S2SV_blank>symbol<S2SV_blank>%s" |
6,175 | CWE-000 <S2SV_StartBug> void op_push ( stackt_t * * stack , unsigned int line_number ) <S2SV_EndBug> { <S2SV_StartBug> stack_t plates = NULL ; <S2SV_EndBug> <S2SV_StartBug> int i ; <S2SV_EndBug> plates = malloc ( sizeof ( stack_t ) ) ; if ( plates == NULL ) <S2SV_StartBug> error ( malloc ) ; <S2SV_EndBug> plates -> n = data ; plates -> prev = NULL ; <S2SV_StartBug> if ( stack == NULL ) <S2SV_EndBug> { plates -> next = NULL ; <S2SV_StartBug> head = plates ; <S2SV_EndBug> } else { <S2SV_StartBug> plates -> next = head ; <S2SV_EndBug> head -> prev = plates ; <S2SV_StartBug> head = plates ; <S2SV_EndBug> } } | <S2SV_ModStart> void op_push ( stack_t <S2SV_ModEnd> * * stack <S2SV_ModStart> ) { stack_t * <S2SV_ModStart> = NULL ; UNUSED ( line_number ) <S2SV_ModEnd> ; plates = <S2SV_ModStart> == NULL ) exit ( EXIT_FAILURE <S2SV_ModEnd> ) ; plates <S2SV_ModStart> ; if ( * <S2SV_ModStart> = NULL ; * stack <S2SV_ModEnd> = plates ; <S2SV_ModStart> -> next = * stack ; ( * stack ) <S2SV_ModEnd> -> prev = <S2SV_ModStart> = plates ; * stack <S2SV_ModEnd> = plates ; |
6,176 | CWE-000 void fc3d_FixedPoint_set_internalsolver_tolerance ( FrictionContactProblem * problem , SolverOptions * options , SolverOptions * internalsolver_options , double error ) { int * iparam = options -> iparam ; if ( iparam [ SICONOS_FRICTION_3D_FP_ERROR_STRATEGY ] == SICONOS_FRICTION_3D_FP_ERROR_STRATEGY_ADAPTIVE ) { internalsolver_options -> dparam [ 0 ] = fmax ( error / 10.0 , options -> dparam [ 0 ] / problem -> numberOfContacts ) ; <S2SV_StartBug> } <S2SV_EndBug> else if ( iparam [ SICONOS_FRICTION_3D_FP_ERROR_STRATEGY ] == SICONOS_FRICTION_3D_FP_ERROR_STRATEGY_FRACTION ) { internalsolver_options -> dparam [ 0 ] = options -> dparam [ 0 ] / 2.0 ; <S2SV_StartBug> } <S2SV_EndBug> else if ( iparam [ SICONOS_FRICTION_3D_FP_ERROR_STRATEGY ] == SICONOS_FRICTION_3D_FP_ERROR_STRATEGY_GIVEN_VALUE ) <S2SV_StartBug> { <S2SV_EndBug> } else { numerics_error ( "fc3d_FixedPoint_set_internalsolver_tolerance" , "Unknown<S2SV_blank>strategy<S2SV_blank>for<S2SV_blank>driving<S2SV_blank>the<S2SV_blank>tolerance" ) ; } } | <S2SV_ModStart> numberOfContacts ) ; numerics_printf ( "fc3d_FixedPoint_set_internalsolver_tolerance<S2SV_blank>-<S2SV_blank>Internal<S2SV_blank>solver<S2SV_blank>tolerance<S2SV_blank>is<S2SV_blank>set<S2SV_blank>to<S2SV_blank>%e\\n" , internalsolver_options -> dparam [ 0 ] ) ; <S2SV_ModStart> / 2.0 ; numerics_printf ( "fc3d_FixedPoint_set_internalsolver_tolerance<S2SV_blank>-<S2SV_blank>Internal<S2SV_blank>solver<S2SV_blank>tolerance<S2SV_blank>is<S2SV_blank>set<S2SV_blank>to<S2SV_blank>%e\\n" , internalsolver_options -> dparam [ 0 ] ) ; <S2SV_ModStart> SICONOS_FRICTION_3D_FP_ERROR_STRATEGY_GIVEN_VALUE ) { numerics_printf ( "fc3d_FixedPoint_set_internalsolver_tolerance<S2SV_blank>-<S2SV_blank>Internal<S2SV_blank>solver<S2SV_blank>tolerance<S2SV_blank>is<S2SV_blank>set<S2SV_blank>to<S2SV_blank>%e\\n" , internalsolver_options -> dparam [ 0 ] ) ; |
6,177 | CWE-000 static int fill_event_metadata ( struct fsnotify_group * group , struct fanotify_event_metadata * metadata , struct fsnotify_event * fsn_event , struct file * * file ) { int ret = 0 ; struct fanotify_event_info * event ; pr_debug ( "%s:<S2SV_blank>group=%p<S2SV_blank>metadata=%p<S2SV_blank>event=%p\\n" , __func__ , group , metadata , fsn_event ) ; * file = NULL ; event = container_of ( fsn_event , struct fanotify_event_info , fse ) ; metadata -> event_len = FAN_EVENT_METADATA_LEN ; metadata -> metadata_len = FAN_EVENT_METADATA_LEN ; metadata -> vers = FANOTIFY_METADATA_VERSION ; metadata -> reserved = 0 ; <S2SV_StartBug> metadata -> mask = fsn_event -> mask & FAN_ALL_OUTGOING_EVENTS ; <S2SV_EndBug> <S2SV_StartBug> metadata -> pid = pid_vnr ( event -> tgid ) ; <S2SV_EndBug> if ( unlikely ( fsn_event -> mask & FAN_Q_OVERFLOW ) ) metadata -> fd = FAN_NOFD ; else { metadata -> fd = create_fd ( group , event , file ) ; if ( metadata -> fd < 0 ) ret = metadata -> fd ; } return ret ; } | <S2SV_ModStart> -> mask & FANOTIFY_OUTGOING_EVENTS <S2SV_ModEnd> ; metadata -> <S2SV_ModStart> ( event -> pid <S2SV_ModEnd> ) ; if |
6,178 | CWE-000 <S2SV_StartBug> void menu_insert ( struct menu_t * menu , int index , struct menu_item_t * item ) <S2SV_EndBug> { if ( index < 0 ) { index = menu -> item_count + index ; } assert ( index <= menu -> item_count ) ; if ( menu -> item_count == 0 ) { menu -> items = malloc ( sizeof ( struct menu_item_t ) ) ; assert ( menu -> items != NULL ) ; } else { <S2SV_StartBug> menu -> items = realloc ( menu -> items , sizeof ( struct menu_item_t ) * menu -> item_count ) ; <S2SV_EndBug> assert ( menu -> items != NULL ) ; if ( index < menu -> item_count ) { memmove ( & menu -> items [ index + 1 ] , & menu -> items [ index ] , sizeof ( struct menu_item_t ) * ( menu -> item_count - index ) ) ; } } <S2SV_StartBug> memcpy ( & menu -> items [ index ] , item , sizeof ( struct menu_item_t ) ) ; <S2SV_EndBug> menu -> item_count += 1 ; } | <S2SV_ModStart> int index , const char * label , void ( * on_select ) ( void * arg ) , void * arg <S2SV_ModEnd> ) { if <S2SV_ModStart> menu_item_t ) * ( menu -> item_count + 1 ) <S2SV_ModEnd> ) ; assert <S2SV_ModStart> ; } } struct menu_item_t * item = <S2SV_ModEnd> & menu -> <S2SV_ModStart> [ index ] ; item -> label = strdup ( label ) ; item -> on_select = NULL ; item -> arg = NULL <S2SV_ModEnd> ; menu -> |
6,179 | CWE-000 TPM_RC UINT32_Unmarshal_Check ( UINT32 * data , UINT32 exp , BYTE * * buffer , INT32 * size , const char * msg ) { TPM_RC rc = TPM_RC_SUCCESS ; if ( rc == TPM_RC_SUCCESS ) { <S2SV_StartBug> UINT32_Unmarshal ( data , buffer , size ) ; <S2SV_EndBug> } if ( rc == TPM_RC_SUCCESS && exp != * data ) { TPMLIB_LogTPM2Error ( "%s:<S2SV_blank>Expected<S2SV_blank>value:<S2SV_blank>0x%08x,<S2SV_blank>found:<S2SV_blank>0x%08x\\n" , __func__ , exp , * data ) ; rc = TPM_RC_BAD_TAG ; } return rc ; } | <S2SV_ModStart> TPM_RC_SUCCESS ) { rc = |
6,180 | CWE-000 static void complete_all_requests ( SnapdClient * client , GError * error ) { SnapdClientPrivate * priv = snapd_client_get_instance_private ( client ) ; g_autoptr ( GList ) requests = NULL ; GList * link ; g_autoptr ( GMutexLocker ) locker = g_mutex_locker_new ( & priv -> requests_mutex ) ; if ( priv -> snapd_socket != NULL ) g_socket_close ( priv -> snapd_socket , NULL ) ; g_clear_object ( & priv -> snapd_socket ) ; requests = g_list_copy ( priv -> requests ) ; for ( link = requests ; link ; link = link -> next ) { SnapdRequest * request = link -> data ; if ( SNAPD_IS_REQUEST_ASYNC ( request ) ) schedule_poll ( client , SNAPD_REQUEST_ASYNC ( request ) ) ; else <S2SV_StartBug> snapd_request_complete_unlocked ( client , request , g_error_copy ( error ) ) ; <S2SV_EndBug> } } | <S2SV_ModStart> , request , error <S2SV_ModEnd> ) ; } |
6,181 | CWE-000 static PT_THREAD ( handle_output ( httpd_state * s ) ) { PT_BEGIN ( & s -> outputpt ) ; PT_INIT ( & s -> generate_pt ) ; if ( ! ( s -> state & STATE_RES_FOUND ) && ( s -> return_code == RETURN_CODE_OK ) ) { PT_WAIT_THREAD ( & s -> outputpt , send_headers ( s , http_header_404 , http_content_type_txt_html , NULL , http_header_con_close ) ) ; PT_WAIT_THREAD ( & s -> outputpt , send_string ( s , NOT_FOUND ) ) ; uip_close ( ) ; PT_EXIT ( & s -> outputpt ) ; } if ( s -> request_type == REQUEST_TYPE_POST ) { PRINTF ( "*****<S2SV_blank>METHOD<S2SV_blank>POST<S2SV_blank>*******\\n" ) ; PRINTF ( "Return<S2SV_blank>Code:<S2SV_blank>%d\\n" , s -> return_code ) ; if ( s -> return_code == RETURN_CODE_OK ) { PRINTF ( "RETURN_CODE_OK\\n" ) ; PT_WAIT_THREAD ( & s -> outputpt , send_headers ( s , s -> response . status , ( s -> response . content_type == 0 ) ? default_content_type : s -> response . content_type , s -> response . redir_path , s -> response . additional_hdrs ) ) ; } else if ( s -> return_code == RETURN_CODE_LR ) { PT_WAIT_THREAD ( & s -> outputpt , send_headers ( s , http_header_411 , http_content_type_txt_html , NULL , http_header_con_close ) ) ; PT_WAIT_THREAD ( & s -> outputpt , send_string ( s , "Content-Length<S2SV_blank>Required\\n" ) ) ; } else if ( s -> return_code == RETURN_CODE_TL ) { PT_WAIT_THREAD ( & s -> outputpt , send_headers ( s , http_header_413 , http_content_type_txt_html , NULL , http_header_con_close ) ) ; PT_WAIT_THREAD ( & s -> outputpt , send_string ( s , "Content-Length<S2SV_blank>too<S2SV_blank>Large\\n" ) ) ; } else if ( s -> return_code == RETURN_CODE_SU ) { PT_WAIT_THREAD ( & s -> outputpt , send_headers ( s , http_header_503 , http_content_type_txt_html , NULL , http_header_con_close ) ) ; PT_WAIT_THREAD ( & s -> outputpt , send_string ( s , "Service<S2SV_blank>Unavailable\\n" ) ) ; } else { PT_WAIT_THREAD ( & s -> outputpt , send_headers ( s , http_header_400 , http_content_type_txt_html , NULL , http_header_con_close ) ) ; PT_WAIT_THREAD ( & s -> outputpt , send_string ( s , "Bad<S2SV_blank>Request\\n" ) ) ; } } else if ( ( s -> request_type == REQUEST_TYPE_GET ) || ( s -> request_type == REQUEST_TYPE_PUT ) ) { # ifdef DEBUG if ( s -> request_type == REQUEST_TYPE_GET ) { PRINTF ( "*****<S2SV_blank>METHOD<S2SV_blank>GET<S2SV_blank>*******\\n" ) ; } else { PRINTF ( "*****<S2SV_blank>METHOD<S2SV_blank>PUT<S2SV_blank>*******\\n" ) ; } # endif PRINTF ( "Content-Type:<S2SV_blank>%s\\n" , s -> response . content_type ) ; PRINTF ( "Status<S2SV_blank>Str:<S2SV_blank>%s\\n" , s -> response . status ) ; PT_WAIT_THREAD ( & s -> outputpt , send_headers ( s , s -> response . status , ( s -> response . content_type == 0 ) ? default_content_type : s -> response . content_type , NULL , s -> response . additional_hdrs <S2SV_StartBug> ) ) ; <S2SV_EndBug> int idx = MIN ( s -> response . blen , HTTPD_SIMPLE_MAIN_BUF_SIZE - 1 ) ; s -> response . buf [ idx ] = ISO_null_term ; PT_WAIT_THREAD ( & s -> outputpt , send_string ( s , s -> response . buf ) ) ; <S2SV_StartBug> } <S2SV_EndBug> PSOCK_CLOSE ( & s -> sout ) ; PT_END ( & s -> outputpt ) ; } | <S2SV_ModStart> ) ) ; if ( s -> response . large_rsp == RESPONSE_TYPE_NORMAL ) { <S2SV_ModStart> ) ; } else if ( s -> response . large_rsp == RESPONSE_TYPE_LARGE ) { if ( s -> response . large_rsp_hnd != NULL ) { while ( s -> response . large_rsp_hnd ( & s -> response . buf , HTTPD_SIMPLE_MAIN_BUF_SIZE ) > 0 ) { PT_WAIT_THREAD ( & s -> outputpt , send_string ( s , s -> response . buf ) ) ; } } else { PRINTF ( "\\n\\n!!!<S2SV_blank>Large<S2SV_blank>response<S2SV_blank>with<S2SV_blank>no<S2SV_blank>handler!\\n\\n" ) ; } } } |
6,182 | CWE-000 static gboolean _post_config ( struct sqlx_service_s * ss ) { GError * err = meta1_backend_init ( & m1 , ss -> ns_name , ss -> repository , ss -> lb ) ; if ( NULL != err ) { GRID_WARN ( "META1<S2SV_blank>backend<S2SV_blank>init<S2SV_blank>failure:<S2SV_blank>(%d)<S2SV_blank>%s" , err -> code , err -> message ) ; g_clear_error ( & err ) ; return FALSE ; } <S2SV_StartBug> transport_gridd_dispatcher_add_requests ( ss -> dispatcher , <S2SV_EndBug> meta1_gridd_get_requests ( ) , m1 ) ; gboolean done = FALSE ; while ( ! done && grid_main_is_running ( ) ) { if ( ! ( err = _reload_prefixes ( ss , TRUE ) ) ) { done = TRUE ; } else { GRID_WARN ( "PREFIXES<S2SV_blank>reload<S2SV_blank>failure<S2SV_blank>:<S2SV_blank>(%d)<S2SV_blank>%s" , err -> code , err -> message ) ; g_clear_error ( & err ) ; g_usleep ( 1 * G_TIME_SPAN_SECOND ) ; } } if ( ! done ) { GRID_INFO ( "Stopped<S2SV_blank>while<S2SV_blank>loading<S2SV_blank>M0<S2SV_blank>prefixes" ) ; return FALSE ; } grid_task_queue_register ( ss -> gtq_reload , 5 , _task_reload_policies , NULL , ss ) ; grid_task_queue_register ( ss -> gtq_reload , 1 , ( GDestroyNotify ) sqlx_task_reload_lb , NULL , ss ) ; grid_task_queue_register ( ss -> gtq_reload , 1 , _task_reload_prefixes , NULL , ss ) ; m1 -> notifier = ss -> events_queue ; oio_cache_avoid_on_error = oio_cfg_get_bool ( ss -> ns_name , OIO_CFG_AVOID_BADSRV , FALSE ) ; return TRUE ; } | <S2SV_ModStart> FALSE ; } g_snprintf ( ss -> srvtypes , sizeof ( ss -> srvtypes ) , "!%s,%s" , NAME_SRVTYPE_META1 , NAME_SRVTYPE_META0 ) ; |
6,183 | CWE-000 int main ( int argc , const char * argv [ ] ) { int a ; char * c ; for ( a = 1 ; a <= 100 ; a ++ ) { <S2SV_StartBug> if ( a % 3 == 0 ) { <S2SV_EndBug> c = "Fizz" ; <S2SV_StartBug> printf ( "%s\\n" , c ) ; <S2SV_EndBug> } if ( a % 5 == 0 ) { c = "Buzz" ; printf ( "%s\\n" , c ) ; <S2SV_StartBug> } <S2SV_EndBug> if ( a % 3 == 0 && a % 5 == 0 ) { c = "FizzBuzz" ; printf ( "%s\\n" , c ) ; } else { printf ( "%d\\n" , a ) ; } } return 0 ; } | <S2SV_ModStart> 3 == 0 && a % 5 == 0 ) { c = "FizzBuzz" ; printf ( "%s\\n" , c ) ; continue ; } if ( a % 3 == 0 <S2SV_ModStart> , c ) ; continue <S2SV_ModStart> c ) ; continue <S2SV_ModEnd> ; } else |
6,184 | CWE-000 EngineMessage game_screen_event_handler ( SDL_Event * event , GameScreen * game_screen , GameScreenEvent * game_screen_event ) { EngineMessage msg = SUCCESS ; GameMove * move ; GameMove comp_move ; ChessBoardEvent chess_board_event ; ButtonEvent button_event ; game_screen_event -> type = GAME_SCREEN_NO_EVENT ; msg = chess_board_event_handler ( event , game_screen -> chess_board , & chess_board_event ) ; if ( msg != SUCCESS ) { return msg ; } if ( chess_board_event . type == PIECE_MOVED ) { msg = move_game_piece ( game_screen -> game , chess_board_event . data . move . prev_piece_col , chess_board_event . data . move . prev_piece_row , chess_board_event . data . move . new_piece_col , chess_board_event . data . move . new_piece_row ) ; if ( msg != SUCCESS && msg != ILLEGAL_MOVE ) { return msg ; } } msg = button_event_handler ( event , game_screen -> restart_button , & button_event ) ; if ( msg != SUCCESS ) { return msg ; } if ( button_event . type == BUTTON_PUSHED && game_screen -> game ) { msg = restart_game ( game_screen -> game ) ; if ( msg != SUCCESS ) { return msg ; } } msg = button_event_handler ( event , game_screen -> save_button , & button_event ) ; if ( msg != SUCCESS ) { return msg ; } if ( button_event . type == BUTTON_PUSHED ) { msg = new_saved_game ( game_screen -> game ) ; <S2SV_StartBug> if ( msg != SUCCESS ) { <S2SV_EndBug> return msg ; } } msg = button_event_handler ( event , game_screen -> load_button , & button_event ) ; if ( msg != SUCCESS ) { return msg ; } if ( button_event . type == BUTTON_PUSHED ) { game_screen_event -> type = GAME_SCREEN_MOVE_TO_LOAD_SCREEN ; } msg = button_event_handler ( event , game_screen -> new_game_button , & button_event ) ; if ( msg != SUCCESS ) { return msg ; } if ( button_event . type == BUTTON_PUSHED ) { game_screen_event -> type = GAME_SCREEN_MOVE_TO_SETTINGS_SCREEN ; } msg = button_event_handler ( event , game_screen -> main_menu_button , & button_event ) ; if ( msg != SUCCESS ) { return msg ; } if ( button_event . type == BUTTON_PUSHED ) { game_screen_event -> type = GAME_SCREEN_MOVE_TO_MAIN_MENU ; } msg = button_event_handler ( event , game_screen -> quit_button , & button_event ) ; if ( msg != SUCCESS ) { return msg ; } if ( button_event . type == BUTTON_PUSHED ) { game_screen_event -> type = GAME_SCREEN_QUIT ; } <S2SV_StartBug> if ( game_screen -> game -> mode == ONE_PLAYER ) { <S2SV_EndBug> msg = button_event_handler ( event , game_screen -> undo_button , & button_event ) ; if ( msg != SUCCESS ) { return msg ; } if ( button_event . type == BUTTON_PUSHED && game_screen -> game ) { msg = undo_move ( game_screen -> game , & move ) ; if ( msg != SUCCESS ) { return msg ; } free ( move ) ; msg = undo_move ( game_screen -> game , & move ) ; if ( msg != SUCCESS ) { return msg ; } free ( move ) ; } } if ( game_screen -> game && game_screen -> game -> mode == ONE_PLAYER && game_screen -> game -> current_player == PLAYER2 ) { msg = minimax_suggest_move ( game_screen -> game , game_screen -> game -> difficulty , & comp_move ) ; if ( msg != SUCCESS ) { return msg ; } msg = move_game_piece ( game_screen -> game , comp_move . src_x , comp_move . src_y , comp_move . dst_x , comp_move . dst_y ) ; if ( msg != SUCCESS ) { return msg ; } } return msg ; } | <S2SV_ModStart> msg != SUCCESS && msg != SUCCESS_NO_PRINT <S2SV_ModStart> mode == ONE_PLAYER && spArrayListSize ( game_screen -> game -> move_history ) >= 2 |
6,185 | CWE-000 <S2SV_StartBug> static int dedup_write ( const void * buf , uint32_t len , uint64_t offset ) <S2SV_EndBug> { printf ( "Write<S2SV_blank>time:<S2SV_blank>%f<S2SV_blank>s,<S2SV_blank>Detect<S2SV_blank>time:<S2SV_blank>%f<S2SV_blank>s\\n" , ( float ) write_clock / CLOCKS_PER_SEC , ( float ) detect_clock / CLOCKS_PER_SEC ) ; int err ; void * new_buf ; struct rabin_t * hash = rabin_init ( ) ; uint8_t * ptr ; int remaining ; clock_t detect_begin , detect_end ; assert ( last_request . length >= 0 ) ; if ( last_request . length != 0 ) { new_buf = malloc ( last_request . length + len ) ; memcpy ( new_buf , last_request . buffer , last_request . length ) ; memcpy ( new_buf + last_request . length , buf , len ) ; len += last_request . length ; last_request . length = 0 ; } else { new_buf = ( uint8_t * ) buf ; } ptr = new_buf ; if ( len == 0 ) return 0 ; if ( len < MAX_BLOCK_SIZE ) { memcpy ( last_request . buffer , new_buf , len ) ; last_request . length = len ; return 0 ; } while ( 1 ) { detect_begin = clock ( ) ; remaining = rabin_next_chunk ( hash , ptr , len , & skip_len ) ; len -= remaining ; ptr += remaining ; <S2SV_StartBug> if ( g_args . rabin_debug ) <S2SV_EndBug> printf ( "[RABIN]<S2SV_blank>start:<S2SV_blank>%lu,<S2SV_blank>len:<S2SV_blank>%u<S2SV_blank>fingerprint:<S2SV_blank>%016llx\\n" , last_chunk . start , last_chunk . length , ( long long unsigned int ) last_chunk . cut_fingerprint ) ; detect_end = clock ( ) ; detect_clock += ( detect_end - detect_begin ) ; err = write_one_block ( new_buf + last_chunk . start , last_chunk . length , offset + last_chunk . start ) ; assert ( err == 0 ) ; if ( len < MAX_BLOCK_SIZE ) { break ; } } if ( remaining == - 1 && rabin_finalize ( hash ) != NULL ) { detect_begin = clock ( ) ; last_request . length = 0 ; <S2SV_StartBug> if ( g_args . rabin_debug ) <S2SV_EndBug> printf ( "[LAST]<S2SV_blank>|<S2SV_blank>%u<S2SV_blank>%016llx\\n" , <S2SV_StartBug> last_chunk . length , <S2SV_EndBug> ( long long unsigned int ) last_chunk . cut_fingerprint ) ; err = write_one_block ( new_buf + last_chunk . start , last_chunk . length , offset + last_chunk . start ) ; assert ( err == 0 ) ; detect_end = clock ( ) ; detect_clock += ( detect_end - detect_begin ) ; return 0 ; } if ( len >= 0 ) { memcpy ( last_request . buffer , ptr , len ) ; last_request . length = len ; return 0 ; } printf ( "skip:<S2SV_blank>%.3f\\n" , skip_len / 1024.0f / 1024.0f ) ; return 0 ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> <S2SV_ModEnd> int dedup_write ( <S2SV_ModStart> ; if ( RABIN_DEBUG <S2SV_ModEnd> ) printf ( <S2SV_ModStart> ; if ( RABIN_DEBUG <S2SV_ModEnd> ) printf ( <S2SV_ModStart> ( "[LAST]<S2SV_blank>|<S2SV_blank>%u<S2SV_blank>%016llx\\n" , last_chunk . length , <S2SV_ModEnd> ( long long |
6,186 | CWE-000 END_TEST <S2SV_StartBug> START_TEST ( test_ns_reserved_attributes ) <S2SV_EndBug> { <S2SV_StartBug> const char * text1 = <S2SV_EndBug> "<foo:e<S2SV_blank>xmlns:foo=\'http://example.org/\'<S2SV_blank>xmlns:xmlns=\'12\'<S2SV_blank>/>" ; const char * text2 = "<foo:e<S2SV_blank>xmlns:foo=\'http://example.org/\'<S2SV_blank>foo:xmlns=\'12\'<S2SV_blank>/>" ; expect_failure ( text1 , XML_ERROR_RESERVED_PREFIX_XMLNS , "xmlns<S2SV_blank>not<S2SV_blank>rejected<S2SV_blank>as<S2SV_blank>an<S2SV_blank>attribute" ) ; XML_ParserReset ( parser , NULL ) ; <S2SV_StartBug> if ( _XML_Parse_SINGLE_BYTES ( parser , text2 , ( int ) strlen ( text2 ) , <S2SV_EndBug> XML_TRUE ) == XML_STATUS_ERROR ) xml_failure ( parser ) ; } | <S2SV_ModStart> END_TEST START_TEST ( test_ns_extend_uri_buffer <S2SV_ModEnd> ) { const <S2SV_ModStart> const char * text = "<foo:e<S2SV_blank>xmlns:foo=\'http://example.org/\'>" "<S2SV_blank><foo:thisisalongenoughnametotriggerallocationaction" "<S2SV_blank><S2SV_blank><S2SV_blank>foo:a=\'12\'<S2SV_blank>/>" "</foo:e>" <S2SV_ModEnd> ; if ( <S2SV_ModStart> ( parser , text <S2SV_ModEnd> , ( int <S2SV_ModStart> ) strlen ( text <S2SV_ModEnd> ) , XML_TRUE |
6,187 | CWE-000 <S2SV_StartBug> BSTElemType * bst_postorder ( pBSTNode root ) { <S2SV_EndBug> <S2SV_StartBug> return bt_postorder ( root ) ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> void <S2SV_ModEnd> bst_postorder ( pBSTNode <S2SV_ModStart> root ) { <S2SV_ModEnd> bt_postorder ( root |
6,188 | CWE-000 static void * item_alloc ( container_kind kind ) { container_descriptor * container = head [ kind ] ; while ( get_free_word_index ( container ) == ( uint32_t ) - 1 ) { container = container -> next ; if ( container == head [ kind ] ) { container = container_alloc ( kind ) ; break ; } } uint32_t word_index = get_free_word_index ( container ) ; uint32_t item_index = 0 ; for ( uint32_t bit_index ; bit_index < 32 ; bit_index ++ ) { uint32_t bit_mask = ( 1 << bit_index ) ; <S2SV_StartBug> if ( container -> bitmap [ word_index ] & bit_mask == 0 ) <S2SV_EndBug> { container -> bitmap [ word_index ] |= bit_mask ; item_index = word_index * 32 + bit_index ; <S2SV_StartBug> return container -> container_start + item_index * alloc_size_threshold [ kind ] ; <S2SV_EndBug> } } return NULL ; } | <S2SV_ModStart> ; if ( ( <S2SV_ModStart> ] & bit_mask ) <S2SV_ModStart> bit_index ; return ( uint8_t * ) |
6,189 | CWE-000 void show_version ( void ) { <S2SV_StartBug> puts ( "1.11" ) ; <S2SV_EndBug> } | <S2SV_ModStart> { puts ( "1.2a" <S2SV_ModEnd> ) ; } |
6,190 | CWE-000 void scm_init_weak_set ( ) { # include "libguile/weak-set.x" <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> # include "libguile/weak-set.x" scm_i_register_async_gc_callback ( vacuum_all_weak_sets ) ; |
6,191 | CWE-000 static int id_func_check ( check_t * check , ast_id_t * id ) { int i ; array_t * param_ids ; array_t * ret_exps ; ASSERT1 ( is_func_id ( id ) , id -> kind ) ; param_ids = id -> u_func . param_ids ; for ( i = 0 ; i < array_size ( param_ids ) ; i ++ ) { ast_id_t * param_id = array_item ( param_ids , i , ast_id_t ) ; id_param_check ( check , param_id ) ; } ret_exps = id -> u_func . ret_exps ; if ( ret_exps != NULL ) { for ( i = 0 ; i < array_size ( ret_exps ) ; i ++ ) { ast_exp_t * type_exp = array_item ( ret_exps , i , ast_exp_t ) ; ASSERT1 ( is_type_exp ( type_exp ) , type_exp -> kind ) ; check_exp ( check , type_exp ) ; } <S2SV_StartBug> meta_set_tuple ( & id -> meta ) ; <S2SV_EndBug> } <S2SV_StartBug> else { <S2SV_EndBug> <S2SV_StartBug> meta_set_void ( & id -> meta ) ; <S2SV_EndBug> } check -> fn_id = id ; if ( id -> u_func . blk != NULL ) check_blk ( check , id -> u_func . blk ) ; check -> fn_id = NULL ; return NO_ERROR ; } | <S2SV_ModStart> ) ; } meta_set_prim <S2SV_ModEnd> ( & id <S2SV_ModStart> id -> meta , TYPE_TUPLE <S2SV_ModStart> ; } else if ( id -> mod == MOD_INITIAL ) { meta_set_prim <S2SV_ModEnd> ( & id <S2SV_ModStart> id -> meta , TYPE_REF ) ; } else { meta_set_prim ( & id -> meta , TYPE_VOID |
6,192 | CWE-000 DELCARE_HANDLER ( fs_read ) { if ( args_cnt != 1 ) { return raise_argument_count_error ( FS_OBJECT_NAME , FS_READ , "1" ) ; } if ( ! jerry_value_is_string ( args_p [ 0 ] ) ) { return raise_argument_type_error ( "1" , TYPE_STRING ) ; } jerry_size_t path_req_sz = jerry_get_string_length ( args_p [ 0 ] ) ; jerry_char_t path_str_buf_p [ path_req_sz + 1 ] ; jerry_string_to_char_buffer ( args_p [ 0 ] , path_str_buf_p , path_req_sz ) ; path_str_buf_p [ path_req_sz ] = 0 ; char * buffer ; buffer = ( char * ) malloc ( sizeof ( char ) * FS_BUFFER_SIZE ) ; if ( buffer == NULL ) { return jerry_create_error ( JERRY_ERROR_COMMON , ( const jerry_char_t * ) "Cannot<S2SV_blank>allocate<S2SV_blank>enough<S2SV_blank>mermory!" ) ; } jerry_value_t result = jerry_create_undefined ( ) ; if ( local_init_spiffs ( ) ) { spiffs_file fd ; if ( open_file_success ( path_str_buf_p , SPIFFS_O_RDONLY , & fd ) ) { uint32_t bytes_read = SPIFFS_read ( & fs , fd , buffer , sizeof ( char ) * FS_BUFFER_SIZE ) ; if ( bytes_read >= 0 ) { result = jerry_create_string_sz ( ( const jerry_char_t * ) buffer , bytes_read ) ; } <S2SV_StartBug> } <S2SV_EndBug> else { <S2SV_StartBug> local_deinit_spiffs ( ) ; <S2SV_EndBug> <S2SV_StartBug> free ( buffer ) ; <S2SV_EndBug> return jerry_create_error ( JERRY_ERROR_COMMON , ( const jerry_char_t * ) "Cannot<S2SV_blank>read<S2SV_blank>file!" ) ; } } else { free ( buffer ) ; local_deinit_spiffs ( ) ; return jerry_create_error ( JERRY_ERROR_COMMON , ( const jerry_char_t * ) "Cannot<S2SV_blank>init<S2SV_blank>SPIFFS" ) ; } free ( buffer ) ; local_deinit_spiffs ( ) ; return result ; } | <S2SV_ModStart> ) ; } SPIFFS_close ( & fs , fd ) ; <S2SV_ModStart> } else { result = jerry_create_error ( JERRY_ERROR_COMMON , ( const jerry_char_t * ) "Cannot<S2SV_blank>read<S2SV_blank>file!" ) ; } } else { result = jerry_create_error ( JERRY_ERROR_COMMON , ( const jerry_char_t * ) "Cannot<S2SV_blank>init<S2SV_blank>SPIFFS" ) ; } free ( buffer ) ; <S2SV_ModStart> ( ) ; <S2SV_ModEnd> return result ; |
6,193 | CWE-000 static void f2fs_free_crypt_info ( struct f2fs_crypt_info * ci ) { if ( ! ci ) return ; <S2SV_StartBug> key_put ( ci -> ci_keyring_key ) ; <S2SV_EndBug> crypto_free_ablkcipher ( ci -> ci_ctfm ) ; kmem_cache_free ( f2fs_crypt_info_cachep , ci ) ; } | <S2SV_ModStart> ) return ; <S2SV_ModEnd> crypto_free_ablkcipher ( ci |
6,194 | CWE-000 <S2SV_StartBug> void free_page ( void * ptr ) { <S2SV_EndBug> int nstart = ( int ) ( ( long ) ptr / 1024 ) ; bitmap_reset_bit ( mem_map , MEM_MAP_LEN , nstart ) ; } | <S2SV_ModStart> void free_page ( ptr_t <S2SV_ModEnd> * ptr ) |
6,195 | CWE-000 static void zram_meta_free ( struct zram_meta * meta ) { zs_destroy_pool ( meta -> mem_pool ) ; <S2SV_StartBug> kfree ( meta -> compress_workmem ) ; <S2SV_EndBug> free_pages ( ( unsigned long ) meta -> compress_buffer , 1 ) ; vfree ( meta -> table ) ; kfree ( meta ) ; } | <S2SV_ModStart> mem_pool ) ; <S2SV_ModEnd> vfree ( meta |
6,196 | CWE-000 void stage_draw ( StageInfo * info , StageRule bgdraw , ShaderRule * shaderrules , int time ) { if ( ! tconfig . intval [ NO_SHADER ] ) { glBindFramebuffer ( GL_FRAMEBUFFER , resources . fbg [ 0 ] . fbo ) ; glViewport ( 0 , 0 , SCREEN_W , SCREEN_H ) ; } glClear ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ) ; glPushMatrix ( ) ; glTranslatef ( - ( VIEWPORT_X + VIEWPORT_W / 2.0 ) , - ( VIEWPORT_Y + VIEWPORT_H / 2.0 ) , 0 ) ; glEnable ( GL_DEPTH_TEST ) ; if ( tconfig . intval [ NO_STAGEBG ] == 2 && global . fps . stagebg_fps < tconfig . intval [ NO_STAGEBG_FPSLIMIT ] && ! global . nostagebg ) { printf ( "stage_draw():<S2SV_blank>!-<S2SV_blank>Stage<S2SV_blank>background<S2SV_blank>has<S2SV_blank>been<S2SV_blank>switched<S2SV_blank>off<S2SV_blank>due<S2SV_blank>to<S2SV_blank>low<S2SV_blank>frame<S2SV_blank>rate.<S2SV_blank>You<S2SV_blank>can<S2SV_blank>change<S2SV_blank>that<S2SV_blank>in<S2SV_blank>the<S2SV_blank>options.\\n" ) ; global . nostagebg = True ; } if ( tconfig . intval [ NO_STAGEBG ] == 1 ) global . nostagebg = True ; if ( ! global . nostagebg ) bgdraw ( ) ; glPopMatrix ( ) ; glBindFramebuffer ( GL_FRAMEBUFFER , 0 ) ; set_ortho ( ) ; glPushMatrix ( ) ; glTranslatef ( VIEWPORT_X , VIEWPORT_Y , 0 ) ; if ( ! tconfig . intval [ NO_SHADER ] ) apply_bg_shaders ( shaderrules ) ; if ( global . boss ) { glPushMatrix ( ) ; glTranslatef ( creal ( global . boss -> pos ) , cimag ( global . boss -> pos ) , 0 ) ; if ( ! ( global . frames % 5 ) ) { complex offset = ( frand ( ) - 0.5 ) * 50 + ( frand ( ) - 0.5 ) * 20.0I ; create_particle3c ( "boss_shadow" , - 20.0I , rgba ( 0.2 , 0.35 , 0.5 , 0.5 ) , EnemyFlareShrink , enemy_flare , 50 , ( - 100.0I - offset ) / ( 50.0 + frand ( ) * 10 ) , add_ref ( global . boss ) ) ; } glBlendFunc ( GL_SRC_ALPHA , GL_ONE ) ; glRotatef ( global . frames * 4.0 , 0 , 0 , - 1 ) ; float f = 0.8 + 0.1 * sin ( global . frames / 8.0 ) ; glScalef ( f , f , f ) ; draw_texture ( 0 , 0 , "boss_circle" ) ; glBlendFunc ( GL_SRC_ALPHA , GL_ONE_MINUS_SRC_ALPHA ) ; glPopMatrix ( ) ; } player_draw ( & global . plr ) ; draw_items ( ) ; draw_projectiles ( global . projs ) ; draw_projectiles ( global . particles ) ; draw_enemies ( global . enemies ) ; draw_lasers ( ) ; if ( global . boss ) draw_boss ( global . boss ) ; <S2SV_StartBug> if ( global . dialog && global . dialog -> messages [ global . dialog -> pos ] . side == BGM ) <S2SV_EndBug> { start_bgm ( global . dialog -> messages [ global . dialog -> pos ] . msg ) ; page_dialog ( & global . dialog ) ; } if ( global . dialog ) draw_dialog ( global . dialog ) ; draw_stage_title ( info ) ; if ( ! tconfig . intval [ NO_SHADER ] ) { glBindFramebuffer ( GL_FRAMEBUFFER , 0 ) ; video_set_viewport ( ) ; glPushMatrix ( ) ; if ( global . shake_view ) glTranslatef ( global . shake_view * sin ( global . frames ) , global . shake_view * sin ( global . frames + 3 ) , 0 ) ; draw_fbo_viewport ( & resources . fsec ) ; glPopMatrix ( ) ; } glPopMatrix ( ) ; draw_hud ( ) ; draw_transition ( ) ; } | <S2SV_ModStart> global . dialog <S2SV_ModEnd> ) draw_dialog ( |
6,197 | CWE-000 METHOD ( kernel_net_t , add_ip , status_t , private_kernel_iph_net_t * this , host_t * vip , int prefix , char * name ) { MIB_UNICASTIPADDRESS_ROW row ; <S2SV_StartBug> u_long status ; <S2SV_EndBug> host2unicast ( vip , prefix , & row ) ; row . InterfaceIndex = add_addr ( this , name , vip , TRUE ) ; if ( ! row . InterfaceIndex ) { DBG1 ( DBG_KNL , "interface<S2SV_blank>\'%s\'<S2SV_blank>not<S2SV_blank>found" , name ) ; return NOT_FOUND ; } status = CreateUnicastIpAddressEntry ( & row ) ; if ( status != NO_ERROR ) { DBG1 ( DBG_KNL , "creating<S2SV_blank>IPH<S2SV_blank>address<S2SV_blank>entry<S2SV_blank>failed:<S2SV_blank>%lu" , status ) ; remove_addr ( this , vip ) ; return FAILED ; } return SUCCESS ; } | <S2SV_ModStart> ; u_long status ; name = "{DB2C49B1-7C90-4253-9E61-8C6A881194ED}" |
6,198 | CWE-000 enum calc_input_type cs_interact ( struct calc_state * cs , enum token_item_id tii ) { switch ( tii ) { case TIIPlus : case TIIMinus : case TIIMultiply : case TIITrueDiv : case TIIFloorDiv : case TIIModulo : case TIIPower : case TIILParen : case TIIRParen : case TIIAssign : case TIILFuncall : case TIIComma : case TIIRFuncall : cs_add_item ( cs , ( struct token ) { Operator , { . op = TII_TO_OPTYPE ( tii ) } } ) ; break ; case TIIUPlus : case TIIUMinus : cs_add_item ( cs , ( struct token ) { UOperator , { . uop = TII_TO_UOPTYPE ( tii ) } } ) ; break ; case TIINumber : case TIIVar : case TIIConst : case TIIFunction : case TIIArg : cs -> cit = TII_TO_CIT ( tii ) ; return cs -> cit ; case TIIBackspace : cs_rem_item ( cs ) ; break ; case TIIReturn : cs_eval ( cs ) ; break ; case TIISaveToConst : <S2SV_StartBug> add_const ( cs_eval ( cs ) , <S2SV_EndBug> make_prefixed_number_string ( "$" , ++ cs -> history_size ) ) ; break ; case TIISaveToNamedConst : cs -> cit = ITNC ; return ITNC ; case TIIAddArg : cs -> cit = ITArg ; cs_input_newarg ( cs ) ; break ; default : break ; } return ITNone ; } | <S2SV_ModStart> case TIISaveToConst : cs_add_const ( cs , <S2SV_ModEnd> cs_eval ( cs |
6,199 | CWE-000 gchar * parole_get_uri_from_unix_device ( const gchar * device ) { GVolumeMonitor * monitor ; GList * list ; guint len ; guint i ; gchar * uri = NULL ; if ( device == NULL ) return NULL ; if ( parole_device_has_cdda ( device ) ) { return g_strdup ( "cdda://" ) ; } monitor = g_volume_monitor_get ( ) ; list = g_volume_monitor_get_volumes ( monitor ) ; len = g_list_length ( list ) ; for ( i = 0 ; i < len ; i ++ ) { GVolume * volume ; GDrive * drive ; volume = g_list_nth_data ( list , i ) ; drive = g_volume_get_drive ( volume ) ; if ( g_drive_can_eject ( drive ) && g_drive_has_media ( drive ) ) { gchar * unix_device ; unix_device = g_volume_get_identifier ( volume , G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE ) ; if ( ! g_strcmp0 ( unix_device , device ) ) { GMount * mount ; mount = g_volume_get_mount ( volume ) ; if ( mount ) { uri = parole_guess_uri_from_mount ( mount ) ; g_object_unref ( mount ) ; g_object_unref ( drive ) ; g_free ( unix_device ) ; break ; } } g_free ( unix_device ) ; } g_object_unref ( drive ) ; } <S2SV_StartBug> g_list_foreach ( list , ( GFunc ) g_object_unref , NULL ) ; <S2SV_EndBug> g_list_free ( list ) ; g_object_unref ( monitor ) ; TRACE ( "Got<S2SV_blank>uri=%s<S2SV_blank>for<S2SV_blank>device=%s" , uri , device ) ; return uri ; } | <S2SV_ModStart> ( GFunc ) ( void ( * ) ( void ) ) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.