Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
100 | CWE-000 int pci_write_config_dword ( const struct pci_dev * dev , int where , u32 val ) { if ( pci_dev_is_disconnected ( dev ) ) <S2SV_StartBug> return - ENODEV ; <S2SV_EndBug> return pci_bus_write_config_dword ( dev -> bus , dev -> devfn , where , val ) ; } | <S2SV_ModStart> ) ) return PCIBIOS_DEVICE_NOT_FOUND <S2SV_ModEnd> ; return pci_bus_write_config_dword |
101 | CWE-000 <S2SV_StartBug> u8 * peer_accept_channel ( struct lightningd * ld UNNEEDED , <S2SV_EndBug> const struct pubkey * peer_id UNNEEDED , const struct wireaddr * addr UNNEEDED , const struct crypto_state * cs UNNEEDED , u64 gossip_index UNNEEDED , const u8 * gfeatures UNNEEDED , const u8 * lfeatures UNNEEDED , int peer_fd UNNEEDED , int gossip_fd UNNEEDED , const struct channel_id * channel_id UNNEEDED , const u8 * open_msg UNNEEDED ) { fprintf ( stderr , "peer_accept_channel<S2SV_blank>called!\\n" ) ; abort ( ) ; } | <S2SV_ModStart> * peer_accept_channel ( const tal_t * ctx UNNEEDED , |
102 | CWE-000 u16_t pbuf_copy_partial ( struct pbuf * buf , void * dataptr , u16_t len , u16_t offset ) { struct pbuf * p ; u16_t left ; u16_t buf_copy_len ; u16_t copied_total = 0 ; LWIP_ERROR ( "pbuf_copy_partial:<S2SV_blank>invalid<S2SV_blank>buf" , ( buf != NULL ) , return 0 ; ) ; LWIP_ERROR ( "pbuf_copy_partial:<S2SV_blank>invalid<S2SV_blank>dataptr" , ( dataptr != NULL ) , return 0 ; ) ; left = 0 ; <S2SV_StartBug> if ( ( buf == NULL ) || ( dataptr == NULL ) ) { <S2SV_EndBug> return 0 ; } for ( p = buf ; len != 0 && p != NULL ; p = p -> next ) { if ( ( offset != 0 ) && ( offset >= p -> len ) ) { offset -= p -> len ; } else { buf_copy_len = p -> len - offset ; if ( buf_copy_len > len ) buf_copy_len = len ; MEMCPY ( & ( ( char * ) dataptr ) [ left ] , & ( ( char * ) p -> payload ) [ offset ] , buf_copy_len ) ; copied_total += buf_copy_len ; left += buf_copy_len ; len -= buf_copy_len ; offset = 0 ; } } return copied_total ; } | <S2SV_ModStart> = 0 ; <S2SV_ModEnd> for ( p |
103 | CWE-000 static enum hrtimer_restart smsc95xx_recv ( struct hrtimer * timer ) { static unsigned char recv_buf [ AX_RX_URB_SIZE ] ; unsigned char * buf_ptr ; int err ; int actual_len ; u32 packet_len ; int cur_buf_align ; struct tasklet_hrtimer * thr = container_of ( timer , struct tasklet_hrtimer , timer ) ; tEdrvInstance * dev = container_of ( thr , tEdrvInstance , poll_timer ) ; printk ( "**<S2SV_blank>%s()\\n" , __func__ ) ; err = usb_bulk_msg ( dev -> pUsbDev , dev -> ep_in , ( void * ) recv_buf , AX_RX_URB_SIZE , & actual_len , <S2SV_StartBug> USB_BULK_RECV_TIMEOUT ) ; <S2SV_EndBug> printk ( "Rx:<S2SV_blank>len<S2SV_blank>=<S2SV_blank>%u,<S2SV_blank>actual<S2SV_blank>=<S2SV_blank>%u,<S2SV_blank>err<S2SV_blank>=<S2SV_blank>%d\\n" , AX_RX_URB_SIZE , actual_len , err ) ; if ( err != 0 ) { printk ( "Rx:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>receive\\n" ) ; goto Exit ; } if ( actual_len > AX_RX_URB_SIZE ) { printk ( "Rx:<S2SV_blank>received<S2SV_blank>too<S2SV_blank>many<S2SV_blank>bytes<S2SV_blank>%d\\n" , actual_len ) ; err = - EIO ; goto Exit ; } buf_ptr = recv_buf ; while ( actual_len > 0 ) { if ( actual_len < sizeof ( packet_len ) ) { printk ( "Rx:<S2SV_blank>incomplete<S2SV_blank>packet<S2SV_blank>length\\n" ) ; err = - EIO ; goto Exit ; } memcpy ( & packet_len , buf_ptr , sizeof ( packet_len ) ) ; le32_to_cpus ( & packet_len ) ; if ( packet_len & RX_STS_ES ) { printk ( "Rx:<S2SV_blank>Error<S2SV_blank>header=%#x" , packet_len ) ; err = - EIO ; goto Exit ; } packet_len = ( ( packet_len & RX_STS_FL ) >> 16 ) ; if ( packet_len > actual_len - sizeof ( packet_len ) ) { printk ( "Rx:<S2SV_blank>too<S2SV_blank>large<S2SV_blank>packet:<S2SV_blank>%d\\n" , packet_len ) ; err = - EIO ; goto Exit ; } if ( edrvInstance_l . initParam . pfnRxHandler != NULL ) { tEdrvRxBuffer rxBuffer ; rxBuffer . bufferInFrame = kEdrvBufferLastInFrame ; rxBuffer . rxFrameSize = packet_len - 4 ; rxBuffer . pBuffer = buf_ptr + sizeof packet_len ; edrvInstance_l . initParam . pfnRxHandler ( & rxBuffer ) ; } actual_len -= sizeof ( packet_len ) + packet_len ; buf_ptr += sizeof ( packet_len ) + packet_len ; cur_buf_align = ( int ) buf_ptr - ( int ) recv_buf ; if ( cur_buf_align & 0x03 ) { int align = 4 - ( cur_buf_align & 0x03 ) ; actual_len -= align ; buf_ptr += align ; } } Exit : return HRTIMER_RESTART ; } | <S2SV_ModStart> & actual_len , 500 ) ; if ( err == - ETIMEDOUT ) goto Exit <S2SV_ModEnd> ; printk ( |
104 | CWE-000 int mlx4_ib_multiplex_cm_handler ( struct ib_device * ibdev , int port , int slave_id , struct ib_mad * mad ) { struct id_map_entry * id ; u32 sl_cm_id ; int pv_cm_id = - 1 ; if ( mad -> mad_hdr . attr_id == CM_REQ_ATTR_ID || mad -> mad_hdr . attr_id == CM_REP_ATTR_ID || mad -> mad_hdr . attr_id == CM_SIDR_REQ_ATTR_ID ) { sl_cm_id = get_local_comm_id ( mad ) ; <S2SV_StartBug> id = id_map_alloc ( ibdev , slave_id , sl_cm_id ) ; <S2SV_EndBug> if ( IS_ERR ( id ) ) { mlx4_ib_warn ( ibdev , "%s:<S2SV_blank>id{slave:<S2SV_blank>%d,<S2SV_blank>sl_cm_id:<S2SV_blank>0x%x}<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>id_map_alloc\\n" , __func__ , slave_id , sl_cm_id ) ; return PTR_ERR ( id ) ; } } else if ( mad -> mad_hdr . attr_id == CM_REJ_ATTR_ID || mad -> mad_hdr . attr_id == CM_SIDR_REP_ATTR_ID ) { return 0 ; } else { sl_cm_id = get_local_comm_id ( mad ) ; id = id_map_get ( ibdev , & pv_cm_id , slave_id , sl_cm_id ) ; } if ( ! id ) { pr_debug ( "id{slave:<S2SV_blank>%d,<S2SV_blank>sl_cm_id:<S2SV_blank>0x%x}<S2SV_blank>is<S2SV_blank>NULL!\\n" , slave_id , sl_cm_id ) ; return - EINVAL ; } <S2SV_StartBug> set_local_comm_id ( mad , id -> pv_cm_id ) ; <S2SV_EndBug> if ( mad -> mad_hdr . attr_id == CM_DREQ_ATTR_ID ) schedule_delayed ( ibdev , id ) ; else if ( mad -> mad_hdr . attr_id == CM_DREP_ATTR_ID ) id_map_find_del ( ibdev , pv_cm_id ) ; return 0 ; } | <S2SV_ModStart> ; id = id_map_get ( ibdev , & pv_cm_id , slave_id , sl_cm_id ) ; if ( id ) goto cont ; id = <S2SV_ModStart> EINVAL ; } cont : |
105 | CWE-000 QDF_STATUS csr_roam_process_command ( tpAniSirGlobal pMac , tSmeCmd * pCommand ) { QDF_STATUS lock_status , status = QDF_STATUS_SUCCESS ; tCsrRoamInfo roamInfo ; uint32_t sessionId = pCommand -> sessionId ; tCsrRoamSession * pSession = CSR_GET_SESSION ( pMac , sessionId ) ; if ( ! pSession ) { sme_err ( "session<S2SV_blank>%d<S2SV_blank>not<S2SV_blank>found" , sessionId ) ; return QDF_STATUS_E_FAILURE ; } sme_debug ( "Roam<S2SV_blank>Reason:<S2SV_blank>%d<S2SV_blank>sessionId:<S2SV_blank>%d" , pCommand -> u . roamCmd . roamReason , sessionId ) ; pSession -> disconnect_reason = pCommand -> u . roamCmd . disconnect_reason ; switch ( pCommand -> u . roamCmd . roamReason ) { case eCsrForcedDisassoc : <S2SV_StartBug> status = csr_roam_process_disassoc_deauth ( pMac , pCommand , <S2SV_EndBug> true , false ) ; lock_status = sme_acquire_global_lock ( & pMac -> sme ) ; if ( ! QDF_IS_STATUS_SUCCESS ( lock_status ) ) { csr_roam_complete ( pMac , eCsrNothingToJoin , NULL ) ; return QDF_STATUS_SUCCESS ; } csr_free_roam_profile ( pMac , sessionId ) ; sme_release_global_lock ( & pMac -> sme ) ; break ; case eCsrSmeIssuedDisassocForHandoff : status = csr_roam_process_disassoc_deauth ( pMac , pCommand , true , false ) ; break ; case eCsrForcedDisassocMICFailure : status = csr_roam_process_disassoc_deauth ( pMac , pCommand , true , true ) ; lock_status = sme_acquire_global_lock ( & pMac -> sme ) ; if ( ! QDF_IS_STATUS_SUCCESS ( lock_status ) ) { csr_roam_complete ( pMac , eCsrNothingToJoin , NULL ) ; return QDF_STATUS_SUCCESS ; } csr_free_roam_profile ( pMac , sessionId ) ; sme_release_global_lock ( & pMac -> sme ) ; break ; case eCsrForcedDeauth : status = csr_roam_process_disassoc_deauth ( pMac , pCommand , false , false ) ; lock_status = sme_acquire_global_lock ( & pMac -> sme ) ; if ( ! QDF_IS_STATUS_SUCCESS ( lock_status ) ) { csr_roam_complete ( pMac , eCsrNothingToJoin , NULL ) ; return QDF_STATUS_SUCCESS ; } csr_free_roam_profile ( pMac , sessionId ) ; sme_release_global_lock ( & pMac -> sme ) ; break ; case eCsrHddIssuedReassocToSameAP : case eCsrSmeIssuedReassocToSameAP : status = csr_roam_trigger_reassociate ( pMac , pCommand , & roamInfo , pSession , sessionId ) ; break ; case eCsrCapsChange : sme_err ( "received<S2SV_blank>eCsrCapsChange<S2SV_blank>" ) ; csr_roam_state_change ( pMac , eCSR_ROAMING_STATE_JOINING , sessionId ) ; status = csr_roam_issue_disassociate ( pMac , sessionId , eCSR_ROAM_SUBSTATE_DISCONNECT_CONTINUE_ROAMING , false ) ; break ; case eCsrSmeIssuedFTReassoc : sme_debug ( "received<S2SV_blank>FT<S2SV_blank>Reassoc<S2SV_blank>Req" ) ; status = csr_process_ft_reassoc_roam_command ( pMac , pCommand ) ; break ; case eCsrStopBss : csr_roam_state_change ( pMac , eCSR_ROAMING_STATE_JOINING , sessionId ) ; status = csr_roam_issue_stop_bss ( pMac , sessionId , eCSR_ROAM_SUBSTATE_STOP_BSS_REQ ) ; break ; case eCsrForcedDisassocSta : csr_roam_state_change ( pMac , eCSR_ROAMING_STATE_JOINING , sessionId ) ; csr_roam_substate_change ( pMac , eCSR_ROAM_SUBSTATE_DISASSOC_REQ , sessionId ) ; sme_debug ( "Disassociate<S2SV_blank>issued<S2SV_blank>with<S2SV_blank>reason:<S2SV_blank>%d" , pCommand -> u . roamCmd . reason ) ; status = csr_send_mb_disassoc_req_msg ( pMac , sessionId , pCommand -> u . roamCmd . peerMac , pCommand -> u . roamCmd . reason ) ; break ; case eCsrForcedDeauthSta : csr_roam_state_change ( pMac , eCSR_ROAMING_STATE_JOINING , sessionId ) ; csr_roam_substate_change ( pMac , eCSR_ROAM_SUBSTATE_DEAUTH_REQ , sessionId ) ; status = csr_send_mb_deauth_req_msg ( pMac , sessionId , pCommand -> u . roamCmd . peerMac , pCommand -> u . roamCmd . reason ) ; break ; case eCsrPerformPreauth : sme_debug ( "Attempting<S2SV_blank>FT<S2SV_blank>PreAuth<S2SV_blank>Req" ) ; status = csr_roam_issue_ft_preauth_req ( pMac , sessionId , pCommand -> u . roamCmd . pLastRoamBss ) ; break ; default : csr_roam_state_change ( pMac , eCSR_ROAMING_STATE_JOINING , sessionId ) ; if ( pCommand -> u . roamCmd . fUpdateCurRoamProfile ) { lock_status = sme_acquire_global_lock ( & pMac -> sme ) ; if ( ! QDF_IS_STATUS_SUCCESS ( lock_status ) ) { csr_roam_complete ( pMac , eCsrNothingToJoin , NULL ) ; return QDF_STATUS_SUCCESS ; } csr_free_roam_profile ( pMac , sessionId ) ; pSession -> pCurRoamProfile = qdf_mem_malloc ( sizeof ( tCsrRoamProfile ) ) ; if ( NULL != pSession -> pCurRoamProfile ) { csr_roam_copy_profile ( pMac , pSession -> pCurRoamProfile , & pCommand -> u . roamCmd . roamProfile ) ; } sme_release_global_lock ( & pMac -> sme ) ; } status = csr_roam ( pMac , pCommand ) ; if ( ! QDF_IS_STATUS_SUCCESS ( status ) ) sme_warn ( "csr_roam()<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>status<S2SV_blank>=<S2SV_blank>0x%08X" , status ) ; break ; } return status ; } | <S2SV_ModStart> case eCsrForcedDisassoc : if ( eCSR_ROAMING_STATE_IDLE == sme_get_current_roam_state ( pMac , sessionId ) ) { sme_err ( "Ignore<S2SV_blank>eCsrForcedDisassoc<S2SV_blank>cmd<S2SV_blank>on<S2SV_blank>roam<S2SV_blank>state<S2SV_blank>%d" , eCSR_ROAMING_STATE_IDLE ) ; return QDF_STATUS_E_FAILURE ; } |
106 | CWE-000 static int32_t rtcwrite ( Chan * c , void * buf , int32_t n , int64_t off ) { <S2SV_StartBug> Mach * m = machp ( ) ; <S2SV_EndBug> int t ; char * a , * start ; Rtc rtc ; uint32_t secs ; uint8_t bcdclock [ Nbcd ] ; char * cp , * ep ; uint32_t offset = off ; if ( offset != 0 ) error ( Ebadarg ) ; switch ( ( uint32_t ) c -> qid . path ) { case Qrtc : cp = ep = buf ; ep += n ; while ( cp < ep ) { if ( * cp >= '0' && * cp <= '9' ) break ; cp ++ ; } secs = strtoul ( cp , 0 , 0 ) ; sec2rtc ( secs , & rtc ) ; PUTBCD ( rtc . sec , 0 ) ; PUTBCD ( rtc . min , 1 ) ; PUTBCD ( rtc . hour , 2 ) ; PUTBCD ( rtc . mday , 3 ) ; PUTBCD ( rtc . mon , 4 ) ; PUTBCD ( rtc . year , 5 ) ; ilock ( & nvrtlock ) ; outb ( Paddr , Seconds ) ; outb ( Pdata , bcdclock [ 0 ] ) ; outb ( Paddr , Minutes ) ; outb ( Pdata , bcdclock [ 1 ] ) ; outb ( Paddr , Hours ) ; outb ( Pdata , bcdclock [ 2 ] ) ; outb ( Paddr , Mday ) ; outb ( Pdata , bcdclock [ 3 ] ) ; outb ( Paddr , Month ) ; outb ( Pdata , bcdclock [ 4 ] ) ; outb ( Paddr , Year ) ; outb ( Pdata , bcdclock [ 5 ] ) ; iunlock ( & nvrtlock ) ; return n ; case Qnvram : if ( n == 0 ) return 0 ; if ( n > Nvsize ) n = Nvsize ; start = a = smalloc ( n ) ; if ( waserror ( ) ) { free ( start ) ; nexterror ( ) ; } memmove ( a , buf , n ) ; poperror ( ) ; ilock ( & nvrtlock ) ; for ( t = offset ; t < offset + n ; t ++ ) { if ( t >= Nvsize ) break ; outb ( Paddr , Nvoff + t ) ; outb ( Pdata , * a ++ ) ; } iunlock ( & nvrtlock ) ; free ( start ) ; return t - offset ; } error ( Ebadarg ) ; return 0 ; } | <S2SV_ModStart> off ) { Proc * up <S2SV_ModEnd> = machp ( <S2SV_ModStart> machp ( ) -> externup |
107 | CWE-000 static int luci_unlink ( struct inode * dir , struct dentry * dentry ) { <S2SV_StartBug> # if LINUX_VERSION_CODE < KERNEL_VERSION ( 4 , 0 , 0 ) <S2SV_EndBug> struct inode * inode = dentry -> d_inode ; # else struct inode * inode = d_inode ( dentry ) ; # endif struct luci_dir_entry_2 * de ; struct page * page ; int err ; luci_dbg ( "name<S2SV_blank>:%s" , dentry -> d_name . name ) ; de = luci_find_entry ( dir , & dentry -> d_name , & page ) ; if ( ! de ) { err = - ENOENT ; luci_err ( "name<S2SV_blank>:%s<S2SV_blank>not<S2SV_blank>found" , dentry -> d_name . name ) ; goto out ; } err = luci_truncate ( inode , 0 ) ; if ( err ) { err = - EIO ; luci_err ( "name<S2SV_blank>:%s<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>free<S2SV_blank>blocks" , dentry -> d_name . name ) ; goto out ; } err = luci_delete_entry ( de , page ) ; if ( err ) { err = - EIO ; luci_err ( "name<S2SV_blank>:%s<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>delete" , dentry -> d_name . name ) ; goto out ; } inode -> i_ctime = dir -> i_ctime ; inode_dec_link_count ( inode ) ; out : return err ; } | <S2SV_ModStart> dentry ) { struct inode * inode = DENTRY_INODE ( dentry ) ; <S2SV_ModEnd> struct luci_dir_entry_2 * |
108 | CWE-000 int main ( void ) { <S2SV_StartBug> write ( 2 , <S2SV_EndBug> "and<S2SV_blank>that<S2SV_blank>piece<S2SV_blank>of<S2SV_blank>art<S2SV_blank>is<S2SV_blank>useful\\"<S2SV_blank>-<S2SV_blank>Dora<S2SV_blank>Korpar,<S2SV_blank>2015-10-19\\n" , 59 ) ; return ( 1 ) ; } | <S2SV_ModStart> ( 2 , "and<S2SV_blank>that<S2SV_blank>piece<S2SV_blank>of<S2SV_blank>art<S2SV_blank>is<S2SV_blank>useful\\"<S2SV_blank>-<S2SV_blank>Dora<S2SV_blank>Korpar,<S2SV_blank>2015-10-19\\n" <S2SV_ModEnd> , 59 ) |
109 | CWE-000 static void test_QueueSubsOnReconnect ( void ) { natsStatus s ; natsConnection * nc = NULL ; natsSubscription * sub1 = NULL ; natsSubscription * sub2 = NULL ; natsOptions * opts = NULL ; natsPid serverPid = NATS_INVALID_PID ; struct threadArg arg ; s = _createDefaultThreadArgsForCbTests ( & arg ) ; if ( s == NATS_OK ) { arg . string = "bar" ; arg . status = NATS_OK ; arg . control = 6 ; } if ( s == NATS_OK ) opts = _createReconnectOptions ( ) ; if ( ( opts == NULL ) || ( natsOptions_SetReconnectedCB ( opts , _reconnectedCb , & arg ) != NATS_OK ) ) { FAIL ( "Unable<S2SV_blank>to<S2SV_blank>create<S2SV_blank>reconnect<S2SV_blank>options!" ) ; } serverPid = _startServer ( "nats://localhost:22222" , "-p<S2SV_blank>22222" , true ) ; CHECK_SERVER_STARTED ( serverPid ) ; s = natsConnection_Connect ( & nc , opts ) ; if ( s == NATS_OK ) s = natsConnection_QueueSubscribe ( & sub1 , nc , "foo.bar" , "workers" , _recvTestString , & arg ) ; if ( s == NATS_OK ) s = natsConnection_QueueSubscribe ( & sub2 , nc , "foo.bar" , "workers" , _recvTestString , & arg ) ; if ( s == NATS_OK ) s = natsConnection_Flush ( nc ) ; for ( int i = 0 ; ( s == NATS_OK ) && ( i < 10 ) ; i ++ ) { <S2SV_StartBug> char seq [ 10 ] ; <S2SV_EndBug> snprintf ( seq , sizeof ( seq ) , "%d" , i ) ; s = natsConnection_PublishString ( nc , "foo.bar" , seq ) ; } if ( s == NATS_OK ) s = natsConnection_Flush ( nc ) ; nats_Sleep ( 50 ) ; natsMutex_Lock ( arg . m ) ; for ( int i = 0 ; ( s == NATS_OK ) && ( i < 10 ) ; i ++ ) { if ( arg . results [ i ] != 1 ) s = NATS_ERR ; } if ( s == NATS_OK ) s = arg . status ; memset ( & arg . results , 0 , sizeof ( arg . results ) ) ; natsMutex_Unlock ( arg . m ) ; test ( "Base<S2SV_blank>results:<S2SV_blank>" ) ; testCond ( s == NATS_OK ) ; _stopServer ( serverPid ) ; serverPid = NATS_INVALID_PID ; serverPid = _startServer ( "nats://localhost:22222" , "-p<S2SV_blank>22222" , true ) ; CHECK_SERVER_STARTED ( serverPid ) ; test ( "Reconnects:<S2SV_blank>" ) natsMutex_Lock ( arg . m ) ; while ( ( s == NATS_OK ) && ! arg . reconnected ) s = natsCondition_TimedWait ( arg . c , arg . m , 2000 ) ; natsMutex_Unlock ( arg . m ) ; testCond ( ( s == NATS_OK ) && arg . reconnected ) ; for ( int i = 0 ; ( s == NATS_OK ) && ( i < 10 ) ; i ++ ) { <S2SV_StartBug> char seq [ 10 ] ; <S2SV_EndBug> snprintf ( seq , sizeof ( seq ) , "%d" , i ) ; s = natsConnection_PublishString ( nc , "foo.bar" , seq ) ; } if ( s == NATS_OK ) s = natsConnection_Flush ( nc ) ; nats_Sleep ( 50 ) ; natsMutex_Lock ( arg . m ) ; for ( int i = 0 ; ( s == NATS_OK ) && ( i < 10 ) ; i ++ ) { if ( arg . results [ i ] != 1 ) s = NATS_ERR ; } if ( s == NATS_OK ) s = arg . status ; memset ( & arg . results , 0 , sizeof ( arg . results ) ) ; natsMutex_Unlock ( arg . m ) ; test ( "Reconnect<S2SV_blank>results:<S2SV_blank>" ) ; testCond ( s == NATS_OK ) ; natsSubscription_Destroy ( sub1 ) ; natsSubscription_Destroy ( sub2 ) ; natsConnection_Destroy ( nc ) ; natsOptions_Destroy ( opts ) ; _destroyDefaultThreadArgs ( & arg ) ; _stopServer ( serverPid ) ; } | <S2SV_ModStart> char seq [ 20 <S2SV_ModEnd> ] ; snprintf <S2SV_ModStart> char seq [ 20 <S2SV_ModEnd> ] ; snprintf |
110 | CWE-000 int tls_sw_sendpage ( struct sock * sk , struct page * page , int offset , size_t size , int flags ) { long timeo = sock_sndtimeo ( sk , flags & MSG_DONTWAIT ) ; struct tls_context * tls_ctx = tls_get_ctx ( sk ) ; struct tls_sw_context_tx * ctx = tls_sw_ctx_tx ( tls_ctx ) ; unsigned char record_type = TLS_RECORD_TYPE_DATA ; size_t orig_size = size ; struct scatterlist * sg ; struct tls_rec * rec ; int num_async = 0 ; bool full_record ; int record_room ; <S2SV_StartBug> bool eor ; <S2SV_EndBug> int ret ; if ( flags & ~ ( MSG_MORE | MSG_DONTWAIT | MSG_NOSIGNAL | MSG_SENDPAGE_NOTLAST ) ) return - ENOTSUPP ; eor = ! ( flags & ( MSG_MORE | MSG_SENDPAGE_NOTLAST ) ) ; lock_sock ( sk ) ; sk_clear_bit ( SOCKWQ_ASYNC_NOSPACE , sk ) ; if ( unlikely ( sk -> sk_write_pending ) ) { ret = wait_on_pending_writer ( sk , & timeo ) ; if ( unlikely ( ret ) ) goto sendpage_end ; } while ( size > 0 ) { size_t copy , required_size ; if ( sk -> sk_err ) { ret = - sk -> sk_err ; goto sendpage_end ; } rec = get_rec ( sk ) ; if ( ! rec ) { ret = - ENOMEM ; goto sendpage_end ; } full_record = false ; record_room = TLS_MAX_PAYLOAD_SIZE - rec -> sg_plaintext_size ; copy = size ; if ( copy >= record_room ) { copy = record_room ; full_record = true ; } required_size = rec -> sg_plaintext_size + copy + tls_ctx -> tx . overhead_size ; if ( ! sk_stream_memory_free ( sk ) ) goto wait_for_sndbuf ; alloc_payload : ret = alloc_encrypted_sg ( sk , required_size ) ; if ( ret ) { if ( ret != - ENOSPC ) goto wait_for_memory ; copy -= required_size - rec -> sg_plaintext_size ; full_record = true ; } get_page ( page ) ; sg = rec -> sg_plaintext_data + rec -> sg_plaintext_num_elem ; sg_set_page ( sg , page , copy , offset ) ; sg_unmark_end ( sg ) ; rec -> sg_plaintext_num_elem ++ ; sk_mem_charge ( sk , copy ) ; offset += copy ; size -= copy ; rec -> sg_plaintext_size += copy ; tls_ctx -> pending_open_record_frags = rec -> sg_plaintext_num_elem ; if ( full_record || eor || rec -> sg_plaintext_num_elem == ARRAY_SIZE ( rec -> sg_plaintext_data ) ) { ret = tls_push_record ( sk , flags , record_type ) ; if ( ret ) { if ( ret == - EINPROGRESS ) num_async ++ ; else if ( ret != - EAGAIN ) goto sendpage_end ; } } continue ; wait_for_sndbuf : set_bit ( SOCK_NOSPACE , & sk -> sk_socket -> flags ) ; wait_for_memory : ret = sk_stream_wait_memory ( sk , & timeo ) ; if ( ret ) { trim_both_sgl ( sk , rec -> sg_plaintext_size ) ; goto sendpage_end ; } goto alloc_payload ; } if ( num_async ) { if ( test_and_clear_bit ( BIT_TX_SCHEDULED , & ctx -> tx_bitmask ) ) { cancel_delayed_work ( & ctx -> tx_work . work ) ; tls_tx_records ( sk , flags ) ; } } sendpage_end : if ( orig_size > size ) ret = orig_size - size ; else ret = sk_stream_error ( sk , flags , ret ) ; release_sock ( sk ) ; return ret ; } | <S2SV_ModStart> int record_room ; int ret = 0 ; bool eor <S2SV_ModEnd> ; if ( |
111 | CWE-000 <S2SV_StartBug> void parse_packet ( const char * pbuffer , const int buff_size ) { <S2SV_EndBug> char c_op [ 2 ] ; memcpy ( c_op , pbuffer , sizeof ( twobyte ) ) ; p . op = atoi ( c_op ) ; if ( IS_RRQ ( p . op ) || IS_WRQ ( p . op ) ) { int filenamel = 0 ; int model = 0 ; memset ( p . filename , 0 , sizeof ( p . filename ) ) ; memset ( p . mode , 0 , sizeof ( p . mode ) ) ; while ( * ( pbuffer + sizeof ( twobyte ) + filenamel ) != '0' ) { ( p . filename ) [ filenamel ] = pbuffer [ sizeof ( twobyte ) + filenamel ] ; filenamel ++ ; } ( p . filename ) [ filenamel ] = '<S2SV_blank>' ; while ( * ( pbuffer + sizeof ( twobyte ) + filenamel + model + 1 ) != '0' ) { ( p . mode ) [ model ] = pbuffer [ sizeof ( twobyte ) + filenamel + model + 1 ] ; model ++ ; } } else if ( IS_DAT ( p . op ) ) { char c_blnum [ 2 ] ; memcpy ( c_blnum , pbuffer + sizeof ( twobyte ) , sizeof ( twobyte ) ) ; p . blnum = atoi ( c_blnum ) ; p . data_l = 0 ; memset ( p . data , 0 , sizeof ( p . data ) ) ; while ( p . data_l < buff_size - ( 2 * sizeof ( twobyte ) ) ) { ( p . data ) [ p . data_l ] = pbuffer [ ( 2 * sizeof ( twobyte ) ) + p . data_l ] ; p . data_l ++ ; } } else if ( IS_ACK ( p . op ) ) { char c_blnum [ 2 ] ; memcpy ( c_blnum , pbuffer + sizeof ( twobyte ) , sizeof ( twobyte ) ) ; p . blnum = atoi ( c_blnum ) ; } else if ( IS_ERR ( p . op ) ) { char c_ecode [ 2 ] ; memcpy ( c_ecode , pbuffer + sizeof ( twobyte ) , sizeof ( twobyte ) ) ; p . errcode = atoi ( c_ecode ) ; memset ( p . errmes , 0 , sizeof ( p . errmes ) ) ; int errmes_l = 0 ; while ( * ( pbuffer + ( 2 * sizeof ( twobyte ) ) + errmes_l ) != '0' ) { ( p . errmes ) [ errmes_l ] = pbuffer [ ( 2 * sizeof ( twobyte ) ) + errmes_l ] ; errmes_l ++ ; } ( p . errmes ) [ errmes_l ] = '<S2SV_blank>' ; } else { <S2SV_StartBug> perror ( "Improper<S2SV_blank>packet<S2SV_blank>received.\\n" ) ; <S2SV_EndBug> } } | <S2SV_ModStart> buff_size ) { for ( int i = 0 ; i < buff_size ; ++ i ) { printf ( "%c\\n" , pbuffer [ i ] ) ; } <S2SV_ModStart> } else { printf ( "OP:<S2SV_blank>%d\\n" , p . op ) ; |
112 | CWE-000 static int do_sysctl ( mib_t * mp , size_t xpect ) <S2SV_StartBug> { <S2SV_EndBug> for ( ; mp -> m_fetched == 0 ; ) { int sts ; sts = sysctl ( mp -> m_mib , ( u_int ) mp -> m_miblen , mp -> m_data , & mp -> m_datalen , NULL , 0 ) ; if ( pmDebugOptions . appl0 ) { fprintf ( stderr , "sysctl(%s%s)<S2SV_blank>-><S2SV_blank>%d<S2SV_blank>(datalen=%d)\\n" , mp -> m_name , mp -> m_data == NULL ? "<S2SV_blank>firstcall" : "" , sts , ( int ) mp -> m_datalen ) ; } if ( sts == 0 && mp -> m_data != NULL ) { mp -> m_fetched = 1 ; break ; } if ( ( sts == - 1 && errno == ENOMEM ) || ( sts == 0 && mp -> m_data == NULL ) ) { mp -> m_data = realloc ( mp -> m_data , mp -> m_datalen ) ; if ( mp -> m_data == NULL ) { fprintf ( stderr , "Error:<S2SV_blank>%s:<S2SV_blank>buffer<S2SV_blank>alloc<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>sysctl<S2SV_blank>metric<S2SV_blank>\\"%s\\"\\n" , mp -> m_pcpname , mp -> m_name ) ; pmNoMem ( "do_sysctl" , mp -> m_datalen , PM_FATAL_ERR ) ; } } else return - errno ; } if ( xpect > 0 && mp -> m_datalen != xpect ) { fprintf ( stderr , "Error:<S2SV_blank>%s:<S2SV_blank>sysctl(%s)<S2SV_blank>datalen=%d<S2SV_blank>not<S2SV_blank>%d!\\n" , mp -> m_pcpname , mp -> m_name , ( int ) mp -> m_datalen , ( int ) xpect ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } return mp -> m_datalen ; } | <S2SV_ModStart> xpect ) { if ( pmDebugOptions . appl0 && pmDebugOptions . desperate ) { fprintf ( stderr , "do_sysctl(%s,<S2SV_blank>%d)<S2SV_blank>m_data=%p<S2SV_blank>m_datalen=%d<S2SV_blank>m_fetched=%d\\n" , mp -> m_name , ( int ) xpect , mp -> m_data , mp -> m_datalen , mp -> m_fetched ) ; } <S2SV_ModStart> ) ; return - 1 <S2SV_ModEnd> ; } return |
113 | CWE-000 static int mod_thread_instantiate ( UNUSED CONF_SECTION const * conf , void * instance , fr_event_list_t * el , void * thread ) { logtee_instance_t * inst = instance ; logtee_thread_instance_t * t = thread ; MEM ( t -> fring = fr_fring_alloc ( t , inst -> buffer_depth , false ) ) ; t -> inst = inst ; t -> el = el ; MEM ( t -> msg_pool = talloc_pool ( t , 1024 ) ) ; MEM ( t -> msg = fr_pair_afrom_da ( t -> msg_pool , inst -> msg_da ) ) ; MEM ( t -> type = fr_pair_afrom_da ( t , inst -> type_da ) ) ; MEM ( t -> lvl = fr_pair_afrom_da ( t , inst -> lvl_da ) ) ; if ( fr_conn_alloc ( t , el , & inst -> connection_timeout , & inst -> reconnection_delay , _logtee_conn_init , _logtee_conn_open , _logtee_conn_close , <S2SV_StartBug> inst -> name , t ) < 0 ) return - 1 ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> , t ) == NULL <S2SV_ModEnd> ) return - |
114 | CWE-000 static uint32_t rpmb_data_req ( int fd , struct rpmb_data_frame * req_frm , size_t req_nfrm , struct rpmb_data_frame * rsp_frm , size_t rsp_nfrm ) { int st ; size_t i ; uint16_t msg_type = ntohs ( req_frm -> msg_type ) ; struct mmc_ioc_cmd cmd ; memset ( & cmd , 0 , sizeof ( cmd ) ) ; cmd . blksz = 512 ; cmd . blocks = req_nfrm ; cmd . data_ptr = ( uintptr_t ) req_frm ; cmd . flags = MMC_RSP_R1 | MMC_CMD_ADTC ; cmd . opcode = MMC_WRITE_MULTIPLE_BLOCK ; cmd . write_flag = 1 ; for ( i = 1 ; i < req_nfrm ; i ++ ) { if ( req_frm [ i ] . msg_type != msg_type ) { EMSG ( "All<S2SV_blank>request<S2SV_blank>frames<S2SV_blank>shall<S2SV_blank>be<S2SV_blank>of<S2SV_blank>the<S2SV_blank>same<S2SV_blank>type" ) ; return TEEC_ERROR_BAD_PARAMETERS ; } } DMSG ( "Req:<S2SV_blank>%zu<S2SV_blank>frame(s)<S2SV_blank>of<S2SV_blank>type<S2SV_blank>0x%04x" , req_nfrm , msg_type ) ; DMSG ( "Rsp:<S2SV_blank>%zu<S2SV_blank>frame(s)" , rsp_nfrm ) ; switch ( msg_type ) { case RPMB_MSG_TYPE_REQ_AUTH_KEY_PROGRAM : case RPMB_MSG_TYPE_REQ_AUTH_DATA_WRITE : if ( rsp_nfrm != 1 ) { EMSG ( "Expected<S2SV_blank>only<S2SV_blank>one<S2SV_blank>response<S2SV_blank>frame" ) ; return TEEC_ERROR_BAD_PARAMETERS ; } cmd . write_flag |= MMC_CMD23_ARG_REL_WR ; cmd . postsleep_min_us = 20000 ; cmd . postsleep_max_us = 50000 ; st = IOCTL ( fd , MMC_IOC_CMD , & cmd ) ; if ( st < 0 ) return TEEC_ERROR_GENERIC ; cmd . postsleep_min_us = 0 ; cmd . postsleep_max_us = 0 ; memset ( rsp_frm , 0 , 1 ) ; rsp_frm -> msg_type = htons ( RPMB_MSG_TYPE_REQ_RESULT_READ ) ; cmd . data_ptr = ( uintptr_t ) rsp_frm ; cmd . write_flag &= ~ MMC_CMD23_ARG_REL_WR ; st = IOCTL ( fd , MMC_IOC_CMD , & cmd ) ; if ( st < 0 ) return TEEC_ERROR_GENERIC ; cmd . opcode = MMC_READ_MULTIPLE_BLOCK ; cmd . write_flag = 0 ; cmd . blocks = rsp_nfrm ; st = IOCTL ( fd , MMC_IOC_CMD , & cmd ) ; if ( st < 0 ) return TEEC_ERROR_GENERIC ; break ; case RPMB_MSG_TYPE_REQ_WRITE_COUNTER_VAL_READ : if ( rsp_nfrm != 1 ) { EMSG ( "Expected<S2SV_blank>only<S2SV_blank>one<S2SV_blank>response<S2SV_blank>frame" ) ; return TEEC_ERROR_BAD_PARAMETERS ; } <S2SV_StartBug> case RPMB_MSG_TYPE_REQ_AUTH_DATA_READ : <S2SV_EndBug> if ( req_nfrm != 1 ) { EMSG ( "Expected<S2SV_blank>only<S2SV_blank>one<S2SV_blank>request<S2SV_blank>frame" ) ; return TEEC_ERROR_BAD_PARAMETERS ; } st = IOCTL ( fd , MMC_IOC_CMD , & cmd ) ; if ( st < 0 ) return TEEC_ERROR_GENERIC ; cmd . data_ptr = ( uintptr_t ) rsp_frm ; cmd . opcode = MMC_READ_MULTIPLE_BLOCK ; cmd . write_flag = 0 ; cmd . blocks = rsp_nfrm ; st = IOCTL ( fd , MMC_IOC_CMD , & cmd ) ; if ( st < 0 ) return TEEC_ERROR_GENERIC ; break ; default : EMSG ( "Unsupported<S2SV_blank>message<S2SV_blank>type:<S2SV_blank>%d" , msg_type ) ; return TEEC_ERROR_GENERIC ; } return TEEC_SUCCESS ; } | <S2SV_ModStart> TEEC_ERROR_BAD_PARAMETERS ; } # if __GNUC__ > 6 __attribute__ ( ( fallthrough ) ) ; # endif |
115 | CWE-000 void timer ( ) { <S2SV_StartBug> BOOL isempty ; <S2SV_EndBug> pthread_mutex_lock ( & lock ) ; <S2SV_StartBug> count += 1 ; <S2SV_EndBug> pthread_cond_broadcast ( & cv ) ; pthread_mutex_unlock ( & lock ) ; if ( inqueue . length > max_num_in_line ) { max_num_in_line = inqueue . length ; } } | <S2SV_ModStart> ( ) { static unsigned int val = 0 <S2SV_ModEnd> ; pthread_mutex_lock ( <S2SV_ModStart> count += 1 ; val ^= 1 ; out8 ( port_a , val ) |
116 | CWE-000 static int ntfs_readpage ( struct file * file , struct page * page ) { loff_t i_size ; struct inode * vi ; ntfs_inode * ni , * base_ni ; u8 * addr ; ntfs_attr_search_ctx * ctx ; MFT_RECORD * mrec ; unsigned long flags ; u32 attr_len ; <S2SV_StartBug> int err = 0 ; <S2SV_EndBug> retry_readpage : BUG_ON ( ! PageLocked ( page ) ) ; vi = page -> mapping -> host ; i_size = i_size_read ( vi ) ; if ( unlikely ( page -> index >= ( i_size + PAGE_SIZE - 1 ) >> PAGE_SHIFT ) ) { zero_user ( page , 0 , PAGE_SIZE ) ; ntfs_debug ( "Read<S2SV_blank>outside<S2SV_blank>i_size<S2SV_blank>-<S2SV_blank>truncated?" ) ; goto done ; } if ( PageUptodate ( page ) ) { unlock_page ( page ) ; return 0 ; } ni = NTFS_I ( vi ) ; if ( ni -> type != AT_INDEX_ALLOCATION ) { if ( NInoEncrypted ( ni ) ) { BUG_ON ( ni -> type != AT_DATA ) ; err = - EACCES ; goto err_out ; } if ( NInoNonResident ( ni ) && NInoCompressed ( ni ) ) { BUG_ON ( ni -> type != AT_DATA ) ; BUG_ON ( ni -> name_len ) ; return ntfs_read_compressed_block ( page ) ; } } if ( NInoNonResident ( ni ) ) { return ntfs_read_block ( page ) ; } if ( unlikely ( page -> index > 0 ) ) { zero_user ( page , 0 , PAGE_SIZE ) ; goto done ; } if ( ! NInoAttr ( ni ) ) base_ni = ni ; else base_ni = ni -> ext . base_ntfs_ino ; <S2SV_StartBug> mrec = map_mft_record ( base_ni ) ; <S2SV_EndBug> if ( IS_ERR ( mrec ) ) { err = PTR_ERR ( mrec ) ; goto err_out ; } if ( unlikely ( NInoNonResident ( ni ) ) ) { unmap_mft_record ( base_ni ) ; goto retry_readpage ; } ctx = ntfs_attr_get_search_ctx ( base_ni , mrec ) ; if ( unlikely ( ! ctx ) ) { err = - ENOMEM ; goto unm_err_out ; } err = ntfs_attr_lookup ( ni -> type , ni -> name , ni -> name_len , CASE_SENSITIVE , 0 , NULL , 0 , ctx ) ; if ( unlikely ( err ) ) goto put_unm_err_out ; attr_len = le32_to_cpu ( ctx -> attr -> data . resident . value_length ) ; read_lock_irqsave ( & ni -> size_lock , flags ) ; if ( unlikely ( attr_len > ni -> initialized_size ) ) attr_len = ni -> initialized_size ; i_size = i_size_read ( vi ) ; read_unlock_irqrestore ( & ni -> size_lock , flags ) ; if ( unlikely ( attr_len > i_size ) ) { attr_len = i_size ; } addr = kmap_atomic ( page ) ; memcpy ( addr , ( u8 * ) ctx -> attr + le16_to_cpu ( ctx -> attr -> data . resident . value_offset ) , attr_len ) ; memset ( addr + attr_len , 0 , PAGE_SIZE - attr_len ) ; flush_dcache_page ( page ) ; kunmap_atomic ( addr ) ; put_unm_err_out : ntfs_attr_put_search_ctx ( ctx ) ; unm_err_out : unmap_mft_record ( base_ni ) ; done : SetPageUptodate ( page ) ; err_out : unlock_page ( page ) ; return err ; } | <S2SV_ModStart> err = 0 ; ntfs_debug ( "[%s]<S2SV_blank>Enter<S2SV_blank>ntfs_readpage<S2SV_blank>" , current -> comm ) <S2SV_ModStart> . base_ntfs_ino ; ntfs_debug ( "[%s]<S2SV_blank>Before<S2SV_blank>map_mft_record<S2SV_blank>base_ni<S2SV_blank>" , current -> comm ) ; |
117 | CWE-000 gboolean ifnet_update_parsers_by_connection ( NMConnection * connection , const char * conn_name , const char * config_file , const char * wpa_file , gchar * * out_new_name , gchar * * out_backup , GError * * error ) { NMSettingConnection * s_con ; NMSettingIPConfig * s_ip6 ; gboolean success = FALSE ; const char * type ; gboolean no_8021x = FALSE ; <S2SV_StartBug> gboolean wired = FALSE , pppoe = TRUE ; <S2SV_EndBug> const char * new_name = NULL ; if ( ! ifnet_can_write_connection ( connection , error ) ) return FALSE ; s_con = nm_connection_get_setting_connection ( connection ) ; g_assert ( s_con ) ; type = nm_setting_connection_get_connection_type ( s_con ) ; if ( ! type ) { g_set_error ( error , NM_SETTINGS_ERROR , NM_SETTINGS_ERROR_INVALID_CONNECTION , "Missing<S2SV_blank>connection<S2SV_blank>type!" ) ; goto out ; } if ( ! strcmp ( type , NM_SETTING_WIRED_SETTING_NAME ) ) { if ( ! write_wired_setting ( connection , conn_name , error ) ) goto out ; wired = TRUE ; no_8021x = TRUE ; } else if ( ! strcmp ( type , NM_SETTING_WIRELESS_SETTING_NAME ) ) { if ( ! write_wireless_setting ( connection , conn_name , & no_8021x , & new_name , error ) ) goto out ; } else if ( ! strcmp ( type , NM_SETTING_PPPOE_SETTING_NAME ) ) { NMSettingPppoe * s_pppoe ; s_pppoe = nm_connection_get_setting_pppoe ( connection ) ; if ( ! write_pppoe_setting ( conn_name , s_pppoe ) ) <S2SV_StartBug> goto out ; <S2SV_EndBug> pppoe = TRUE ; wired = TRUE ; no_8021x = TRUE ; } else { g_set_error ( error , NM_SETTINGS_ERROR , NM_SETTINGS_ERROR_NOT_SUPPORTED , "Can\'t<S2SV_blank>write<S2SV_blank>connection<S2SV_blank>type<S2SV_blank>\'%s\'" , type ) ; goto out ; } if ( new_name ) conn_name = new_name ; if ( ! no_8021x ) { if ( ! write_8021x_setting ( connection , conn_name , wired , error ) ) goto out ; } if ( ! write_ip4_setting ( connection , conn_name , error ) ) goto out ; s_ip6 = nm_connection_get_setting_ip6_config ( connection ) ; if ( s_ip6 ) { if ( ! write_ip6_setting ( connection , conn_name , error ) ) goto out ; } ifnet_set_data ( conn_name , "auto" , nm_setting_connection_get_autoconnect ( s_con ) ? "true" : "false" ) ; ifnet_set_data ( conn_name , "uuid" , nm_connection_get_uuid ( connection ) ) ; success = ifnet_flush_to_file ( config_file , out_backup ) ; if ( success ) wpa_flush_to_file ( wpa_file ) ; if ( out_new_name ) * out_new_name = g_strdup ( conn_name ) ; out : return success ; } | <S2SV_ModStart> wired = FALSE <S2SV_ModEnd> ; const char <S2SV_ModStart> ) goto out <S2SV_ModEnd> ; wired = |
118 | CWE-000 int seek_linklist_rawfile ( linklist_rawfile_t * ll_rawfile , unsigned int framenum ) { if ( ! ll_rawfile ) { linklist_err ( "Null<S2SV_blank>linklist_rawfile\\n" ) ; return - 1 ; } <S2SV_StartBug> unsigned int fileindex = framenum / ll_rawfile -> fpf ; <S2SV_EndBug> if ( fileindex != ll_rawfile -> fileindex || ! ll_rawfile -> fp ) { ll_rawfile -> fileindex = fileindex ; if ( ll_rawfile -> fp ) { fclose ( ll_rawfile -> fp ) ; ll_rawfile -> fp = NULL ; } char filename [ 128 ] ; sprintf ( filename , "%s" LINKLIST_EXT ".%.2u" , ll_rawfile -> basename , fileindex ) ; ll_rawfile -> fp = fpreopenb ( filename ) ; if ( ! ll_rawfile -> fp ) { linklist_err ( "Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>raw<S2SV_blank>linklist<S2SV_blank>binary<S2SV_blank>file<S2SV_blank>%s\\n" , filename ) ; return - 2 ; } } ll_rawfile -> framenum = framenum % ll_rawfile -> fpf ; return fseek ( ll_rawfile -> fp , ll_rawfile -> framenum * ll_rawfile -> framesize , SEEK_SET ) ; } | <S2SV_ModStart> ll_rawfile -> fpf ; printf ( "Framenum<S2SV_blank>%d,<S2SV_blank>fileindex<S2SV_blank>%d,<S2SV_blank>other<S2SV_blank>fileindex<S2SV_blank>%d\\n" , framenum , fileindex , ll_rawfile -> fileindex ) |
119 | CWE-000 static void ibus_levena_engine_update ( IBusLevenaEngine * klass ) { <S2SV_StartBug> g_printf ( "levena-engine<S2SV_blank>init!<S2SV_blank>in<S2SV_blank>classzzzz" ) ; <S2SV_EndBug> } | <S2SV_ModStart> klass ) { g_print ( "signal_update" <S2SV_ModEnd> ) ; } |
120 | CWE-000 SPVM_OP * SPVM_OP_build_enumeration_value ( SPVM_COMPILER * compiler , SPVM_OP * op_name , SPVM_OP * op_constant ) { if ( op_constant ) { SPVM_CONSTANT * constant = op_constant -> uv . constant ; if ( constant -> type -> dimension == 0 && constant -> type -> basic_type -> id == SPVM_BASIC_TYPE_C_ID_INT ) { compiler -> current_enum_value = constant -> value . ival ; } else { SPVM_COMPILER_error ( compiler , "enum<S2SV_blank>value<S2SV_blank>must<S2SV_blank>be<S2SV_blank>int<S2SV_blank>type<S2SV_blank>at<S2SV_blank>%s<S2SV_blank>line<S2SV_blank>%d\\n" , op_constant -> file , op_constant -> line ) ; } compiler -> current_enum_value ++ ; } else { op_constant = SPVM_OP_new_op_constant_int ( compiler , ( int32_t ) compiler -> current_enum_value , op_name -> file , op_name -> line ) ; compiler -> current_enum_value ++ ; } SPVM_OP * op_return = SPVM_OP_new_op ( compiler , SPVM_OP_C_ID_RETURN , op_name -> file , op_name -> line ) ; SPVM_OP_insert_child ( compiler , op_return , op_return -> last , op_constant ) ; SPVM_OP * op_list_statements = SPVM_OP_new_op_list ( compiler , op_name -> file , op_name -> line ) ; SPVM_OP_insert_child ( compiler , op_list_statements , op_list_statements -> last , op_return ) ; SPVM_OP * op_block = SPVM_OP_new_op_block ( compiler , op_name -> file , op_name -> line ) ; SPVM_OP_insert_child ( compiler , op_block , op_block -> last , op_list_statements ) ; SPVM_OP * op_sub = SPVM_OP_new_op ( compiler , SPVM_OP_C_ID_SUB , op_name -> file , op_name -> line ) ; op_sub -> file = op_name -> file ; op_sub -> line = op_name -> line ; SPVM_OP * op_return_type = SPVM_OP_new_op_type ( compiler , op_constant -> uv . constant -> type , op_name -> file , op_name -> line ) ; op_sub = SPVM_OP_build_sub ( compiler , op_sub , op_name , op_return_type , NULL , NULL , op_block , NULL , NULL ) ; op_sub -> uv . sub -> op_constant = op_constant ; op_sub -> uv . sub -> flag |= SPVM_SUB_C_FLAG_IS_ENUM ; op_sub -> uv . sub -> call_type_id = SPVM_SUB_C_CALL_TYPE_ID_CLASS_METHOD ; <S2SV_StartBug> return op_sub ; <S2SV_EndBug> } | <S2SV_ModStart> = SPVM_SUB_C_CALL_TYPE_ID_CLASS_METHOD ; SPVM_LIST_push ( compiler -> current_sub_names , ( void * ) op_name -> uv . name ) ; |
121 | CWE-000 static int com20020pci_probe ( struct pci_dev * pdev , const struct pci_device_id * id ) { struct com20020_pci_card_info * ci ; struct com20020_pci_channel_map * mm ; struct net_device * dev ; struct arcnet_local * lp ; struct com20020_priv * priv ; int i , ioaddr , ret ; struct resource * r ; if ( pci_enable_device ( pdev ) ) return - EIO ; priv = devm_kzalloc ( & pdev -> dev , sizeof ( struct com20020_priv ) , GFP_KERNEL ) ; if ( ! priv ) return - ENOMEM ; ci = ( struct com20020_pci_card_info * ) id -> driver_data ; priv -> ci = ci ; mm = & ci -> misc_map ; INIT_LIST_HEAD ( & priv -> list_dev ) ; if ( mm -> size ) { ioaddr = pci_resource_start ( pdev , mm -> bar ) + mm -> offset ; r = devm_request_region ( & pdev -> dev , ioaddr , mm -> size , "com20020-pci" ) ; if ( ! r ) { pr_err ( "IO<S2SV_blank>region<S2SV_blank>%xh-%xh<S2SV_blank>already<S2SV_blank>allocated.\\n" , ioaddr , ioaddr + mm -> size - 1 ) ; return - EBUSY ; } priv -> misc = ioaddr ; } for ( i = 0 ; i < ci -> devcount ; i ++ ) { struct com20020_pci_channel_map * cm = & ci -> chan_map_tbl [ i ] ; struct com20020_dev * card ; int dev_id_mask = 0xf ; dev = alloc_arcdev ( device ) ; if ( ! dev ) { ret = - ENOMEM ; goto out_port ; } dev -> dev_port = i ; dev -> netdev_ops = & com20020_netdev_ops ; lp = netdev_priv ( dev ) ; arc_printk ( D_NORMAL , dev , "%s<S2SV_blank>Controls\\n" , ci -> name ) ; ioaddr = pci_resource_start ( pdev , cm -> bar ) + cm -> offset ; r = devm_request_region ( & pdev -> dev , ioaddr , cm -> size , "com20020-pci" ) ; if ( ! r ) { pr_err ( "IO<S2SV_blank>region<S2SV_blank>%xh-%xh<S2SV_blank>already<S2SV_blank>allocated\\n" , ioaddr , ioaddr + cm -> size - 1 ) ; ret = - EBUSY ; goto out_port ; } arcnet_outb ( 0x00 , ioaddr , COM20020_REG_W_COMMAND ) ; arcnet_inb ( ioaddr , COM20020_REG_R_DIAGSTAT ) ; SET_NETDEV_DEV ( dev , & pdev -> dev ) ; dev -> base_addr = ioaddr ; dev -> dev_addr [ 0 ] = node ; dev -> sysfs_groups [ 0 ] = & com20020_state_group ; dev -> irq = pdev -> irq ; lp -> card_name = "PCI<S2SV_blank>COM20020" ; lp -> card_flags = ci -> flags ; lp -> backplane = backplane ; lp -> clockp = clockp & 7 ; lp -> clockm = clockm & 3 ; lp -> timeout = timeout ; lp -> hw . owner = THIS_MODULE ; lp -> backplane = ( inb ( priv -> misc ) >> ( 2 + i ) ) & 0x1 ; if ( ! strncmp ( ci -> name , "EAE<S2SV_blank>PLX-PCI<S2SV_blank>FB2" , 15 ) ) lp -> backplane = 1 ; if ( ! strncmp ( ci -> name , "EAE<S2SV_blank>PLX-PCI<S2SV_blank>MA1" , 15 ) ) dev_id_mask = 0x3 ; dev -> dev_id = ( inb ( priv -> misc + ci -> rotary ) >> 4 ) & dev_id_mask ; snprintf ( dev -> name , sizeof ( dev -> name ) , "arc%d-%d" , dev -> dev_id , i ) ; if ( arcnet_inb ( ioaddr , COM20020_REG_R_STATUS ) == 0xFF ) { pr_err ( "IO<S2SV_blank>address<S2SV_blank>%Xh<S2SV_blank>is<S2SV_blank>empty!\\n" , ioaddr ) ; ret = - EIO ; goto out_port ; } if ( com20020_check ( dev ) ) { ret = - EIO ; goto out_port ; } card = devm_kzalloc ( & pdev -> dev , sizeof ( struct com20020_dev ) , GFP_KERNEL ) ; if ( ! card ) <S2SV_StartBug> return - ENOMEM ; <S2SV_EndBug> card -> index = i ; card -> pci_priv = priv ; card -> tx_led . brightness_set = led_tx_set ; card -> tx_led . default_trigger = devm_kasprintf ( & pdev -> dev , GFP_KERNEL , "arc%d-%d-tx" , dev -> dev_id , i ) ; card -> tx_led . name = devm_kasprintf ( & pdev -> dev , GFP_KERNEL , "pci:green:tx:%d-%d" , dev -> dev_id , i ) ; card -> tx_led . dev = & dev -> dev ; card -> recon_led . brightness_set = led_recon_set ; card -> recon_led . default_trigger = devm_kasprintf ( & pdev -> dev , GFP_KERNEL , "arc%d-%d-recon" , dev -> dev_id , i ) ; card -> recon_led . name = devm_kasprintf ( & pdev -> dev , GFP_KERNEL , "pci:red:recon:%d-%d" , dev -> dev_id , i ) ; card -> recon_led . dev = & dev -> dev ; card -> dev = dev ; ret = devm_led_classdev_register ( & pdev -> dev , & card -> tx_led ) ; if ( ret ) goto out_port ; ret = devm_led_classdev_register ( & pdev -> dev , & card -> recon_led ) ; if ( ret ) goto out_port ; dev_set_drvdata ( & dev -> dev , card ) ; ret = com20020_found ( dev , IRQF_SHARED ) ; if ( ret ) goto out_port ; devm_arcnet_led_init ( dev , dev -> dev_id , i ) ; list_add ( & card -> list , & priv -> list_dev ) ; } pci_set_drvdata ( pdev , priv ) ; return 0 ; out_port : com20020pci_remove ( pdev ) ; return ret ; } | <S2SV_ModStart> ! card ) { ret = <S2SV_ModEnd> - ENOMEM ; <S2SV_ModStart> - ENOMEM ; goto out_port ; } |
122 | CWE-000 int pj_apply_vgridshift ( PJ * defn , const char * listname , PJ_GRIDINFO * * * gridlist_p , int * gridlist_count_p , int inverse , long point_count , int point_offset , double * x , double * y , double * z ) { int i ; static int debug_count = 0 ; PJ_GRIDINFO * * tables ; if ( * gridlist_p == NULL ) { * gridlist_p = pj_gridlist_from_nadgrids ( pj_get_ctx ( defn ) , pj_param ( defn -> ctx , defn -> params , listname ) . s , gridlist_count_p ) ; if ( * gridlist_p == NULL || * gridlist_count_p == 0 ) return defn -> ctx -> last_errno ; } if ( * gridlist_count_p == 0 ) { pj_ctx_set_errno ( defn -> ctx , - 38 ) ; return - 38 ; } tables = * gridlist_p ; defn -> ctx -> last_errno = 0 ; for ( i = 0 ; i < point_count ; i ++ ) { long io = i * point_offset ; LP input ; <S2SV_StartBug> int itable ; <S2SV_EndBug> double value = HUGE_VAL ; input . phi = y [ io ] ; input . lam = x [ io ] ; <S2SV_StartBug> for ( itable = 0 ; itable < * gridlist_count_p ; itable ++ ) <S2SV_EndBug> { PJ_GRIDINFO * gi = tables [ itable ] ; struct CTABLE * ct = gi -> ct ; double grid_x , grid_y ; int grid_ix , grid_iy ; int grid_ix2 , grid_iy2 ; float * cvs ; if ( ct -> ll . phi > input . phi || ct -> ll . lam > input . lam || ct -> ll . phi + ( ct -> lim . phi - 1 ) * ct -> del . phi < input . phi || ct -> ll . lam + ( ct -> lim . lam - 1 ) * ct -> del . lam < input . lam ) continue ; while ( gi -> child != NULL ) { PJ_GRIDINFO * child ; for ( child = gi -> child ; child != NULL ; child = child -> next ) { struct CTABLE * ct1 = child -> ct ; if ( ct1 -> ll . phi > input . phi || ct1 -> ll . lam > input . lam || ct1 -> ll . phi + ( ct1 -> lim . phi - 1 ) * ct1 -> del . phi < input . phi || ct1 -> ll . lam + ( ct1 -> lim . lam - 1 ) * ct1 -> del . lam < input . lam ) continue ; break ; } if ( child == NULL ) { break ; } gi = child ; ct = child -> ct ; } if ( ct -> cvs == NULL && ! pj_gridinfo_load ( pj_get_ctx ( defn ) , gi ) ) { pj_ctx_set_errno ( defn -> ctx , - 38 ) ; return - 38 ; } grid_x = ( input . lam - ct -> ll . lam ) / ct -> del . lam ; grid_y = ( input . phi - ct -> ll . phi ) / ct -> del . phi ; grid_ix = ( int ) floor ( grid_x ) ; grid_iy = ( int ) floor ( grid_y ) ; grid_x -= grid_ix ; grid_y -= grid_iy ; grid_ix2 = grid_ix + 1 ; if ( grid_ix2 >= ct -> lim . lam ) grid_ix2 = ct -> lim . lam - 1 ; grid_iy2 = grid_iy + 1 ; if ( grid_iy2 >= ct -> lim . phi ) grid_iy2 = ct -> lim . phi - 1 ; cvs = ( float * ) ct -> cvs ; value = cvs [ grid_ix + grid_iy * ct -> lim . lam ] * ( 1.0 - grid_x ) * ( 1.0 - grid_y ) + cvs [ grid_ix2 + grid_iy * ct -> lim . lam ] * ( grid_x ) * ( 1.0 - grid_y ) + cvs [ grid_ix + grid_iy2 * ct -> lim . lam ] * ( 1.0 - grid_x ) * ( grid_y ) + cvs [ grid_ix2 + grid_iy2 * ct -> lim . lam ] * ( grid_x ) * ( grid_y ) ; if ( value > 1000 || value < - 1000 || value == - 88.88880f ) value = HUGE_VAL ; else { if ( inverse ) z [ io ] -= value ; else z [ io ] += value ; } if ( value != HUGE_VAL ) { if ( debug_count ++ < 20 ) pj_log ( defn -> ctx , PJ_LOG_DEBUG_MINOR , "pj_apply_gridshift():<S2SV_blank>used<S2SV_blank>%s" , ct -> id ) ; break ; } } if ( value == HUGE_VAL ) { char gridlist [ 3000 ] ; pj_log ( defn -> ctx , PJ_LOG_DEBUG_MAJOR , "pj_apply_vgridshift():<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>find<S2SV_blank>a<S2SV_blank>grid<S2SV_blank>shift<S2SV_blank>table<S2SV_blank>for\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>location<S2SV_blank>(%.7fdW,%.7fdN)" , x [ io ] * RAD_TO_DEG , y [ io ] * RAD_TO_DEG ) ; gridlist [ 0 ] = '\\0' ; for ( itable = 0 ; itable < * gridlist_count_p ; itable ++ ) { PJ_GRIDINFO * gi = tables [ itable ] ; if ( strlen ( gridlist ) + strlen ( gi -> gridname ) > sizeof ( gridlist ) - 100 ) { strcat ( gridlist , "..." ) ; break ; } if ( itable == 0 ) sprintf ( gridlist , "<S2SV_blank><S2SV_blank><S2SV_blank>tried:<S2SV_blank>%s" , gi -> gridname ) ; else sprintf ( gridlist + strlen ( gridlist ) , ",%s" , gi -> gridname ) ; } pj_log ( defn -> ctx , PJ_LOG_DEBUG_MAJOR , "%s" , gridlist ) ; pj_ctx_set_errno ( defn -> ctx , PJD_ERR_GRID_AREA ) ; return PJD_ERR_GRID_AREA ; } } return 0 ; } | <S2SV_ModStart> ; int itable = 0 <S2SV_ModStart> io ] ; if ( input . phi != input . phi || input . lam != input . lam ) itable = * gridlist_count_p ; for ( <S2SV_ModEnd> ; itable < |
123 | CWE-000 int main ( void ) { printf ( "hello<S2SV_blank>world!\\n" ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> "hello<S2SV_blank>world!\\n" ) ; return 0 ; |
124 | CWE-000 static int set_search ( ares_channel channel , const char * str ) { <S2SV_StartBug> int n ; <S2SV_EndBug> const char * p , * q ; if ( channel -> ndomains != - 1 ) { for ( n = 0 ; n < channel -> ndomains ; n ++ ) ares_free ( channel -> domains [ n ] ) ; ares_free ( channel -> domains ) ; channel -> domains = NULL ; channel -> ndomains = - 1 ; } <S2SV_StartBug> n = 0 ; <S2SV_EndBug> p = str ; while ( * p ) { while ( * p && ! ISSPACE ( * p ) ) p ++ ; while ( ISSPACE ( * p ) ) p ++ ; n ++ ; } if ( ! n ) { <S2SV_StartBug> channel -> ndomains = 0 ; <S2SV_EndBug> return ARES_SUCCESS ; } channel -> domains = ares_malloc ( n * sizeof ( char * ) ) ; <S2SV_StartBug> if ( ! channel -> domains ) <S2SV_EndBug> return ARES_ENOMEM ; n = 0 ; p = str ; while ( * p ) { <S2SV_StartBug> channel -> ndomains = n ; <S2SV_EndBug> q = p ; while ( * q && ! ISSPACE ( * q ) ) q ++ ; channel -> domains [ n ] = ares_malloc ( q - p + 1 ) ; if ( ! channel -> domains [ n ] ) return ARES_ENOMEM ; memcpy ( channel -> domains [ n ] , p , q - p ) ; channel -> domains [ n ] [ q - p ] = 0 ; p = q ; while ( ISSPACE ( * p ) ) p ++ ; n ++ ; } channel -> ndomains = n ; return ARES_SUCCESS ; } | <S2SV_ModStart> { int n ; size_t cnt <S2SV_ModStart> 1 ; } channel -> domains = ares_strsplit ( str , ",<S2SV_blank>" , 1 , & cnt ) ; <S2SV_ModEnd> channel -> ndomains <S2SV_ModStart> -> ndomains = ( size_t ) cnt <S2SV_ModEnd> ; if ( <S2SV_ModStart> ; if ( <S2SV_ModEnd> channel -> domains <S2SV_ModStart> channel -> domains == NULL ) <S2SV_ModEnd> channel -> ndomains <S2SV_ModStart> -> ndomains = - 1 <S2SV_ModEnd> ; return ARES_SUCCESS |
125 | CWE-000 int swTable_create ( swTable * table ) { uint32_t row_num = table -> size * ( 1 + SW_TABLE_CONFLICT_PROPORTION ) ; uint32_t row_memory_size = sizeof ( swTableRow ) + table -> item_size ; size_t memory_size = row_num * row_memory_size ; memory_size += sizeof ( swMemoryPool ) + sizeof ( swFixedPool ) + ( ( row_num - table -> size ) * sizeof ( swFixedPool_slice ) ) ; memory_size += table -> size * sizeof ( swTableRow * ) ; void * memory = sw_shm_malloc ( memory_size ) ; if ( memory == NULL ) { return SW_ERR ; } memset ( memory , 0 , memory_size ) ; table -> memory = memory ; table -> compress_threshold = table -> size * SW_TABLE_COMPRESS_PROPORTION ; table -> rows = memory ; memory += table -> size * sizeof ( swTableRow * ) ; memory_size -= table -> size * sizeof ( swTableRow * ) ; # if SW_TABLE_USE_SPINLOCK == 0 pthread_mutexattr_t attr ; pthread_mutexattr_init ( & attr ) ; pthread_mutexattr_setpshared ( & attr , PTHREAD_PROCESS_SHARED ) ; <S2SV_StartBug> pthread_mutexattr_setrobust_np ( & attr , PTHREAD_MUTEX_ROBUST_NP ) ; <S2SV_EndBug> # endif int i ; for ( i = 0 ; i < table -> size ; i ++ ) { table -> rows [ i ] = memory + ( row_memory_size * i ) ; # if SW_TABLE_USE_SPINLOCK == 0 pthread_mutex_init ( & table -> rows [ i ] -> lock , & attr ) ; # endif } memory += row_memory_size * table -> size ; memory_size -= row_memory_size * table -> size ; table -> pool = swFixedPool_new2 ( row_memory_size , memory , memory_size ) ; return SW_OK ; } | <S2SV_ModStart> PTHREAD_PROCESS_SHARED ) ; pthread_mutexattr_setprotocol ( & attr , PTHREAD_PRIO_INHERIT ) ; |
126 | CWE-000 char * command_output ( const char * command ) { int idxc = 0 , bufsize_step = 256 , bufsize = bufsize_step ; char * buffer = ( char * ) malloc ( bufsize ) ; FILE * found = popen ( command , "r" ) ; if ( ! found ) { <S2SV_StartBug> fprintf ( stderr , "Cannot<S2SV_blank>into<S2SV_blank>popen.\\n" ) ; <S2SV_EndBug> return NULL ; } while ( ( buffer [ idxc ] = getc ( found ) ) != EOF ) { if ( strlen ( buffer ) > bufsize - 8 ) { buffer = ( char * ) realloc ( buffer , bufsize += bufsize_step ) ; } idxc ++ ; } if ( pclose ( found ) != 0 ) { <S2SV_StartBug> fprintf ( stderr , "Cannot<S2SV_blank>into<S2SV_blank>pclose.\\n" ) ; <S2SV_EndBug> return NULL ; } buffer [ idxc ] = '\\0' ; return buffer ; } | <S2SV_ModStart> ( stderr , "command_output():<S2SV_blank>Cannot<S2SV_blank>into<S2SV_blank>popen.\\n" <S2SV_ModEnd> ) ; return <S2SV_ModStart> ( stderr , "command_output():<S2SV_blank>Cannot<S2SV_blank>into<S2SV_blank>pclose.\\n" <S2SV_ModEnd> ) ; return |
127 | CWE-000 int _gnix_vc_nic_progress ( struct gnix_nic * nic ) { struct gnix_vc * vc ; <S2SV_StartBug> int ret ; <S2SV_EndBug> while ( ( vc = __gnix_nic_next_pending_vc ( nic ) ) ) { COND_ACQUIRE ( vc -> ep -> requires_lock , & vc -> ep -> vc_lock ) ; if ( vc -> conn_state != GNIX_VC_CONNECTED ) { COND_RELEASE ( vc -> ep -> requires_lock , & vc -> ep -> vc_lock ) ; continue ; } ret = __gnix_vc_rx_progress ( vc ) ; if ( ret != FI_SUCCESS ) GNIX_DEBUG ( FI_LOG_EP_CTRL , "__gnix_vc_rx_progress<S2SV_blank>failed:<S2SV_blank>%d\\n" , ret ) ; ret = __gnix_vc_push_work_reqs ( vc ) ; if ( ret != FI_SUCCESS ) GNIX_DEBUG ( FI_LOG_EP_CTRL , "__gnix_vc_push_work_reqs<S2SV_blank>failed:<S2SV_blank>%d\\n" , ret ) ; <S2SV_StartBug> ret = __gnix_vc_push_tx_reqs ( vc ) ; <S2SV_EndBug> if ( ret != FI_SUCCESS ) GNIX_DEBUG ( FI_LOG_EP_CTRL , "__gnix_vc_push_tx_reqs<S2SV_blank>failed:<S2SV_blank>%d\\n" , ret ) ; COND_RELEASE ( vc -> ep -> requires_lock , & vc -> ep -> vc_lock ) ; <S2SV_StartBug> } <S2SV_EndBug> return FI_SUCCESS ; } | <S2SV_ModStart> ; int ret , ret_tx <S2SV_ModStart> ret ) ; ret_tx <S2SV_ModEnd> = __gnix_vc_push_tx_reqs ( <S2SV_ModStart> __gnix_vc_push_tx_reqs ( vc <S2SV_ModEnd> ) ; COND_RELEASE <S2SV_ModStart> vc_lock ) ; if ( ret_tx != FI_SUCCESS ) { GNIX_DEBUG ( FI_LOG_EP_CTRL , "__gnix_vc_push_tx_reqs<S2SV_blank>failed:<S2SV_blank>%d\\n" , ret_tx ) ; break ; } |
128 | CWE-000 void op_swap ( stack_t * * stack , unsigned int line_number ) { stack_t * head , * tmp_node ; head = * stack ; if ( ! head || head -> next == NULL ) { printf ( "L%d:<S2SV_blank>can\'t<S2SV_blank>swap,<S2SV_blank>stack<S2SV_blank>too<S2SV_blank>short\\n" , line_number ) ; exit ( EXIT_FAILURE ) ; } tmp_node = head -> next ; <S2SV_StartBug> head -> next = tmp_node -> next ; <S2SV_EndBug> <S2SV_StartBug> head -> prev = tmp_node ; <S2SV_EndBug> tmp_node -> next = head ; tmp_node -> prev = NULL ; * stack = tmp_node ; } | <S2SV_ModStart> -> next ; free ( head ) ; head <S2SV_ModEnd> = tmp_node -> <S2SV_ModStart> prev = tmp_node ; head -> next = tmp_node -> next -> next |
129 | CWE-000 static void usage ( const char * cmd ) { printf ( "Usage:<S2SV_blank>%s<S2SV_blank>[options]<S2SV_blank>host<S2SV_blank>port\\n" "\\n" "Options:\\n" "<S2SV_blank><S2SV_blank>-a<S2SV_blank><alpn<S2SV_blank>list><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>a<S2SV_blank>coma<S2SV_blank>separated<S2SV_blank>list<S2SV_blank>of<S2SV_blank>ALPN<S2SV_blank>identifiers\\n" "<S2SV_blank><S2SV_blank>-c<S2SV_blank>certificate-file\\n" "<S2SV_blank><S2SV_blank>-k<S2SV_blank>key-file<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>specifies<S2SV_blank>the<S2SV_blank>credentials<S2SV_blank>to<S2SV_blank>be<S2SV_blank>used<S2SV_blank>for<S2SV_blank>running<S2SV_blank>the\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>server.<S2SV_blank>If<S2SV_blank>omitted,<S2SV_blank>the<S2SV_blank>command<S2SV_blank>runs<S2SV_blank>as<S2SV_blank>a<S2SV_blank>client.\\n" "<S2SV_blank><S2SV_blank>-l<S2SV_blank>log-file<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>file<S2SV_blank>to<S2SV_blank>log<S2SV_blank>traffic<S2SV_blank>secrets\\n" "<S2SV_blank><S2SV_blank>-p<S2SV_blank>path<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>path<S2SV_blank>to<S2SV_blank>request<S2SV_blank>(can<S2SV_blank>be<S2SV_blank>set<S2SV_blank>multiple<S2SV_blank>times)\\n" "<S2SV_blank><S2SV_blank>-r<S2SV_blank>[initial-rto]<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>initial<S2SV_blank>RTO<S2SV_blank>(in<S2SV_blank>milliseconds)\\n" <S2SV_StartBug> "<S2SV_blank><S2SV_blank>-s<S2SV_blank>[secret]<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>use<S2SV_blank>stateless<S2SV_blank>reset\\n" <S2SV_EndBug> "<S2SV_blank><S2SV_blank>-V<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>verify<S2SV_blank>peer<S2SV_blank>using<S2SV_blank>the<S2SV_blank>default<S2SV_blank>certificates\\n" "<S2SV_blank><S2SV_blank>-v<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>verbose<S2SV_blank>mode<S2SV_blank>(-vv<S2SV_blank>emits<S2SV_blank>packet<S2SV_blank>dumps<S2SV_blank>as<S2SV_blank>well)\\n" "<S2SV_blank><S2SV_blank>-h<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>print<S2SV_blank>this<S2SV_blank>help\\n" "\\n" , cmd ) ; } | <S2SV_ModStart> "<S2SV_blank><S2SV_blank>-l<S2SV_blank>log-file<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>file<S2SV_blank>to<S2SV_blank>log<S2SV_blank>traffic<S2SV_blank>secrets\\n" "<S2SV_blank><S2SV_blank>-p<S2SV_blank>path<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>path<S2SV_blank>to<S2SV_blank>request<S2SV_blank>(can<S2SV_blank>be<S2SV_blank>set<S2SV_blank>multiple<S2SV_blank>times)\\n" "<S2SV_blank><S2SV_blank>-r<S2SV_blank>[initial-rto]<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>initial<S2SV_blank>RTO<S2SV_blank>(in<S2SV_blank>milliseconds)\\n" "<S2SV_blank><S2SV_blank>-s<S2SV_blank>[secret]<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>use<S2SV_blank>stateless<S2SV_blank>retry<S2SV_blank>protected<S2SV_blank>by<S2SV_blank>the<S2SV_blank>secret\\n" <S2SV_ModEnd> "<S2SV_blank><S2SV_blank>-V<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>verify<S2SV_blank>peer<S2SV_blank>using<S2SV_blank>the<S2SV_blank>default<S2SV_blank>certificates\\n" "<S2SV_blank><S2SV_blank>-v<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>verbose<S2SV_blank>mode<S2SV_blank>(-vv<S2SV_blank>emits<S2SV_blank>packet<S2SV_blank>dumps<S2SV_blank>as<S2SV_blank>well)\\n" "<S2SV_blank><S2SV_blank>-h<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>print<S2SV_blank>this<S2SV_blank>help\\n" |
130 | CWE-000 <S2SV_StartBug> void grpc_jwt_verifier_destroy ( grpc_jwt_verifier * v ) { <S2SV_EndBug> size_t i ; if ( v == NULL ) return ; <S2SV_StartBug> grpc_httpcli_context_destroy ( & v -> http_ctx ) ; <S2SV_EndBug> if ( v -> mappings != NULL ) { for ( i = 0 ; i < v -> num_mappings ; i ++ ) { gpr_free ( v -> mappings [ i ] . email_domain ) ; gpr_free ( v -> mappings [ i ] . key_url_prefix ) ; } gpr_free ( v -> mappings ) ; } gpr_free ( v ) ; } | <S2SV_ModStart> void grpc_jwt_verifier_destroy ( grpc_exec_ctx * exec_ctx , <S2SV_ModStart> ; grpc_httpcli_context_destroy ( exec_ctx , |
131 | CWE-000 static void warn_if_shadowing ( tree new_decl ) { struct c_binding * b ; if ( ! ( warn_shadow || warn_shadow_local || warn_shadow_compatible_local ) || DECL_IS_BUILTIN ( new_decl ) || DECL_FROM_INLINE ( new_decl ) ) return ; for ( b = I_SYMBOL_BINDING ( DECL_NAME ( new_decl ) ) ; b ; b = b -> shadowed ) if ( b -> decl && b -> decl != new_decl && ! b -> invisible && ( b -> decl == error_mark_node || diagnostic_report_warnings_p ( global_dc , DECL_SOURCE_LOCATION ( b -> decl ) ) ) ) { tree old_decl = b -> decl ; if ( old_decl == error_mark_node ) { warning ( OPT_Wshadow , "declaration<S2SV_blank>of<S2SV_blank>%q+D<S2SV_blank>shadows<S2SV_blank>previous<S2SV_blank>" "non-variable" , new_decl ) ; break ; } bool warned = false ; auto_diagnostic_group d ; if ( TREE_CODE ( old_decl ) == PARM_DECL ) { enum opt_code warning_code ; if ( warn_shadow ) warning_code = OPT_Wshadow ; else if ( comptypes ( TREE_TYPE ( old_decl ) , TREE_TYPE ( new_decl ) ) ) warning_code = OPT_Wshadow_compatible_local ; else warning_code = OPT_Wshadow_local ; warned = warning_at ( DECL_SOURCE_LOCATION ( new_decl ) , warning_code , "declaration<S2SV_blank>of<S2SV_blank>%qD<S2SV_blank>shadows<S2SV_blank>a<S2SV_blank>parameter" , new_decl ) ; } else if ( DECL_FILE_SCOPE_P ( old_decl ) ) { if ( TREE_CODE ( old_decl ) == FUNCTION_DECL && TREE_CODE ( new_decl ) != FUNCTION_DECL && ! FUNCTION_POINTER_TYPE_P ( TREE_TYPE ( new_decl ) ) ) continue ; warned = warning_at ( DECL_SOURCE_LOCATION ( new_decl ) , OPT_Wshadow , "declaration<S2SV_blank>of<S2SV_blank>%qD<S2SV_blank>shadows<S2SV_blank>a<S2SV_blank>global<S2SV_blank>" "declaration" , new_decl ) ; } <S2SV_StartBug> else if ( TREE_CODE ( old_decl ) == FUNCTION_DECL <S2SV_EndBug> && DECL_BUILT_IN ( old_decl ) ) { warning ( OPT_Wshadow , "declaration<S2SV_blank>of<S2SV_blank>%q+D<S2SV_blank>shadows<S2SV_blank>" "a<S2SV_blank>built-in<S2SV_blank>function" , new_decl ) ; break ; } else { enum opt_code warning_code ; if ( warn_shadow ) warning_code = OPT_Wshadow ; else if ( comptypes ( TREE_TYPE ( old_decl ) , TREE_TYPE ( new_decl ) ) ) warning_code = OPT_Wshadow_compatible_local ; else warning_code = OPT_Wshadow_local ; warned = warning_at ( DECL_SOURCE_LOCATION ( new_decl ) , warning_code , "declaration<S2SV_blank>of<S2SV_blank>%qD<S2SV_blank>shadows<S2SV_blank>a<S2SV_blank>previous<S2SV_blank>local" , new_decl ) ; } if ( warned ) inform ( DECL_SOURCE_LOCATION ( old_decl ) , "shadowed<S2SV_blank>declaration<S2SV_blank>is<S2SV_blank>here" ) ; break ; } } | <S2SV_ModStart> else if ( decl_built_in_p <S2SV_ModEnd> ( old_decl ) |
132 | CWE-000 static int16_t menu_get_cell_height_callback ( MenuLayer * menu_layer , MenuIndex * cell_index , void * callback_context ) { if ( debug_timeline ) { APP_LOG ( APP_LOG_LEVEL_DEBUG , "--><S2SV_blank>cell<S2SV_blank>height<S2SV_blank>section:<S2SV_blank>%d<S2SV_blank>row:<S2SV_blank>%d" , cell_index -> section , cell_index -> row ) ; } switch ( cell_index -> section ) { case 0 : if ( debug_timeline ) { APP_LOG ( APP_LOG_LEVEL_DEBUG , "--><S2SV_blank>text<S2SV_blank>id<S2SV_blank>%d" , text [ cell_index -> row ] . id ) ; } if ( settings . font == 0 ) { return text [ cell_index -> row ] . hight + 26 ; } else { return text [ cell_index -> row ] . hight + 38 ; } break ; case 1 : <S2SV_StartBug> if ( debug_timeline ) { APP_LOG ( APP_LOG_LEVEL_DEBUG , "--><S2SV_blank>antw<S2SV_blank>id<S2SV_blank>%d" , antw [ cell_index -> row ] . id ) ; } <S2SV_EndBug> if ( settings . font == 0 ) { <S2SV_StartBug> return text [ cell_index -> row ] . hight + 26 ; <S2SV_EndBug> } else { <S2SV_StartBug> return text [ cell_index -> row ] . hight + 45 ; <S2SV_EndBug> } break ; default : return 0 ; } } | <S2SV_ModStart> : if ( debug <S2SV_ModEnd> ) { APP_LOG <S2SV_ModStart> ( APP_LOG_LEVEL_DEBUG , "--><S2SV_blank>antw<S2SV_blank>id<S2SV_blank>%d;<S2SV_blank>height<S2SV_blank>%d" <S2SV_ModEnd> , antw [ <S2SV_ModStart> ] . id , antw [ cell_index -> row ] . hight <S2SV_ModStart> ) { return antw <S2SV_ModEnd> [ cell_index -> <S2SV_ModStart> else { return antw <S2SV_ModEnd> [ cell_index -> |
133 | CWE-000 <S2SV_StartBug> char * * setup_n_receive ( ) { <S2SV_EndBug> char cwd [ 256 ] ; char inlin [ 256 ] ; getcwd ( cwd , 256 ) ; printf ( "\\n%s>><S2SV_blank>" , cwd ) ; fgets ( inlin , 256 , stdin ) ; inlin [ strlen ( inlin ) - 1 ] = 0 ; <S2SV_StartBug> return parse_args ( inlin ) ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> void setup_n_receive ( <S2SV_ModStart> char * * buff , char * cwd , char * inlin ) { <S2SV_ModEnd> getcwd ( cwd <S2SV_ModStart> = 0 ; <S2SV_ModEnd> parse_args ( inlin <S2SV_ModStart> parse_args ( inlin , buff |
134 | CWE-000 static void harp_idl_fill_error_struct ( harp_IDLError * fill , const short err ) { const char * message ; message = harp_errno_to_string ( err ) ; if ( message [ 0 ] == '\\0' ) { switch ( err ) { case HARP_IDL_ERR_EXPECTED_STRUCT : message = "structure<S2SV_blank>argument<S2SV_blank>expected" ; break ; case HARP_IDL_ERR_EXPECTED_STRING : message = "string<S2SV_blank>argument<S2SV_blank>expected" ; break ; case HARP_IDL_ERR_EXPECTED_SINGLE_ELM : message = "argument<S2SV_blank>should<S2SV_blank>be<S2SV_blank>a<S2SV_blank>single<S2SV_blank>element" ; break ; case HARP_IDL_ERR_EMPTY_ARRAY : message = "argument<S2SV_blank>contains<S2SV_blank>empty<S2SV_blank>array" ; break ; case HARP_IDL_ERR_EXPECTED_NUMERICAL_ARRAY : message = "argument<S2SV_blank>should<S2SV_blank>be<S2SV_blank>numerical<S2SV_blank>array" ; break ; case HARP_IDL_ERR_INVALID_PRODUCT : message = "invalid<S2SV_blank>product<S2SV_blank>record" ; break ; case HARP_IDL_ERR_INVALID_VARIABLE : message = "invalid<S2SV_blank>variable<S2SV_blank>record" ; break ; case HARP_IDL_ERR_UNKNOWN_OPTION : message = "unknown<S2SV_blank>option" ; break ; default : <S2SV_StartBug> message = "unkown<S2SV_blank>error" ; <S2SV_EndBug> break ; } } fill -> number = err ; IDL_StrStore ( & fill -> message , ( char * ) message ) ; } | <S2SV_ModStart> : message = "unknown<S2SV_blank>error" <S2SV_ModEnd> ; break ; |
135 | CWE-000 void machFunctionEpilogue ( Machine * m ) { instructionPrintf ( ".func_end:" ) ; while ( bufCount ( m -> stack ) > 0 ) { <S2SV_StartBug> stackPop ( m , Reg_RBX ) ; <S2SV_EndBug> } instructionPrintf ( "pop<S2SV_blank>rbp" ) ; instructionPrintf ( "ret" ) ; } | <S2SV_ModStart> 0 ) { machStackPop <S2SV_ModEnd> ( m , <S2SV_ModStart> ( m , machHelperInt64 ( ) <S2SV_ModEnd> ) ; } |
136 | CWE-000 int main ( ) { int qtdProgramas ; scanf ( "%d" , & qtdProgramas ) ; FilaProgramas * filaPreOrdem = criaFila ( qtdProgramas ) ; FilaProgramas * filaInOrdem = criaFila ( qtdProgramas ) ; for ( int i = 0 ; i < qtdProgramas ; i ++ ) { char * nomePrograma = malloc ( TAM_NOME * sizeof ( char ) ) ; scanf ( "%s" , nomePrograma ) ; enfileirar ( filaInOrdem , nomePrograma ) ; } for ( int i = 0 ; i < qtdProgramas ; i ++ ) { char * nomePrograma = malloc ( TAM_NOME * sizeof ( char ) ) ; scanf ( "%s" , nomePrograma ) ; enfileirar ( filaPreOrdem , nomePrograma ) ; } Pasta * raiz = recriaArvore ( * filaPreOrdem , * filaInOrdem , NULL ) ; printPreOrdem ( raiz ) ; printf ( "\\n" ) ; printInOrdem ( raiz ) ; printf ( "\\n" ) ; int op ; while ( scanf ( "%d" , & op ) != EOF ) { switch ( op ) { case INSTALAR : { Pasta * * pastaInstalada = malloc ( sizeof ( Pasta * ) ) ; char * nomeNovoPrograma = ( char * ) malloc ( TAM_NOME * sizeof ( char ) ) ; scanf ( "%s" , nomeNovoPrograma ) ; raiz = instalarPrograma ( raiz , nomeNovoPrograma , NULL , RAIZ , pastaInstalada ) ; printf ( "[INSTALL]<S2SV_blank>Programa<S2SV_blank>%s.exe<S2SV_blank>instalado<S2SV_blank>com<S2SV_blank>sucesso<S2SV_blank>na<S2SV_blank>pasta<S2SV_blank>%s\\n" , nomeNovoPrograma , ( * pastaInstalada ) -> nome ) ; printf ( "IN:<S2SV_blank>" ) ; printInOrdem ( raiz ) ; printf ( "\\nPRE:<S2SV_blank>" ) ; printPreOrdem ( raiz ) ; printf ( "\\n" ) ; break ; } case DESINSTALAR : { char * nomeProgramaRemover = malloc ( TAM_NOME * sizeof ( char ) ) ; scanf ( "%s" , nomeProgramaRemover ) ; bool * removeuPrograma = malloc ( sizeof ( bool ) ) ; * removeuPrograma = false ; raiz = desinstalarPrograma ( raiz , NULL , nomeProgramaRemover , removeuPrograma ) ; if ( * removeuPrograma == true ) printf ( "[UNINSTALL]<S2SV_blank>Programa<S2SV_blank>%s.exe<S2SV_blank>desinstalado<S2SV_blank>com<S2SV_blank>sucesso\\n" , nomeProgramaRemover ) ; else printf ( "[UNINSTALL]<S2SV_blank>Nao<S2SV_blank>foi<S2SV_blank>encontrado<S2SV_blank>no<S2SV_blank>sistema<S2SV_blank>nenhum<S2SV_blank>programa<S2SV_blank>com<S2SV_blank>nome<S2SV_blank>%s\\n" , nomeProgramaRemover ) ; break ; } case OTIMIZAR_RESPOSTA : { int numPastas = contaPastas ( raiz ) ; int * index = malloc ( sizeof ( int ) ) ; * index = 0 ; char * * programasInOrdem = malloc ( numPastas * sizeof ( char * ) ) ; criaVetorBalanceamento ( raiz , programasInOrdem , index ) ; printf ( "Programas:<S2SV_blank>" ) ; for ( int i = 0 ; i < numPastas ; i ++ ) { printf ( "%s\\n" , programasInOrdem [ i ] ) ; } desalocarArvore ( raiz ) ; raiz = balanceiaArvore ( programasInOrdem , numPastas , NULL ) ; printf ( "[OPTIMIZE]<S2SV_blank>O<S2SV_blank>sistema<S2SV_blank>de<S2SV_blank>acesso<S2SV_blank>a<S2SV_blank>programas<S2SV_blank>foi<S2SV_blank>otimizado\\n" ) ; break ; } case VELOCIDADE_RESPOSTA : { char * nomeProgramaPesquisa = malloc ( TAM_NOME * sizeof ( char ) ) ; int tempo ; <S2SV_StartBug> scanf ( "%s<S2SV_blank>%d" , nomeProgramaPesquisa , tempo ) ; <S2SV_EndBug> int tempoResposta = tempoDeExecucao ( raiz , nomeProgramaPesquisa ) ; int tempoRespostaSemRaiz = tempoResposta - 1 ; if ( tempo > tempoRespostaSemRaiz ) printf ( "[DELAY][OK]<S2SV_blank>O<S2SV_blank>acesso<S2SV_blank>ao<S2SV_blank>programa<S2SV_blank>%s.exe<S2SV_blank>foi<S2SV_blank>concluido<S2SV_blank>em<S2SV_blank>%d<S2SV_blank>segundos" , nomeProgramaPesquisa , tempoRespostaSemRaiz ) ; else printf ( "[DELAY][FAIL]<S2SV_blank>O<S2SV_blank>acesso<S2SV_blank>ao<S2SV_blank>programa<S2SV_blank>%s.exe<S2SV_blank>ultrapassou<S2SV_blank>o<S2SV_blank>limite<S2SV_blank>de<S2SV_blank>%d<S2SV_blank>segundo" , nomeProgramaPesquisa , tempo ) ; printf ( "%d\\n" , tempoResposta ) ; break ; } case BACKUP : { free ( filaPreOrdem ) ; free ( filaInOrdem ) ; int quantidadeDePastas = contaPastas ( raiz ) ; FilaProgramas * in = criaFila ( quantidadeDePastas ) ; FilaProgramas * pre = criaFila ( quantidadeDePastas ) ; backupInOrdem ( raiz , in ) ; backupInOrdem ( raiz , pre ) ; filaPreOrdem = pre ; filaInOrdem = in ; printf ( "[BACKUP]<S2SV_blank>Configuracao<S2SV_blank>atual<S2SV_blank>do<S2SV_blank>sistema<S2SV_blank>salva<S2SV_blank>com<S2SV_blank>sucesso\\n" ) ; break ; } case PRINT_PROGRAMAS : { char * caminho = malloc ( 2 * sizeof ( char ) ) ; strcpy ( caminho , "C:" ) ; printProgramas ( raiz , caminho , 4 ) ; break ; } case RESTAURAR : { desalocarArvore ( raiz ) ; raiz = recriaArvore ( * filaPreOrdem , * filaInOrdem , NULL ) ; printf ( "[RESTORE]<S2SV_blank>Sistema<S2SV_blank>restaurado<S2SV_blank>para<S2SV_blank>a<S2SV_blank>versao<S2SV_blank>do<S2SV_blank>backup\\n" ) ; break ; } default : printf ( "Operação<S2SV_blank>não<S2SV_blank>cadastrada!\\n" ) ; break ; } } } | <S2SV_ModStart> , nomeProgramaPesquisa , & |
137 | CWE-000 static struct radv_shader_variant * shader_variant_create ( struct radv_device * device , struct radv_shader_module * module , struct nir_shader * const * shaders , int shader_count , gl_shader_stage stage , struct radv_nir_compiler_options * options , bool gs_copy_shader , void * * code_out , unsigned * code_size_out ) { enum radeon_family chip_family = device -> physical_device -> rad_info . family ; enum ac_target_machine_options tm_options = 0 ; struct radv_shader_variant * variant ; struct ac_shader_binary binary ; struct ac_llvm_compiler ac_llvm ; bool thread_compiler ; variant = calloc ( 1 , sizeof ( struct radv_shader_variant ) ) ; if ( ! variant ) return NULL ; options -> family = chip_family ; options -> chip_class = device -> physical_device -> rad_info . chip_class ; options -> dump_shader = radv_can_dump_shader ( device , module , gs_copy_shader ) ; options -> dump_preoptir = options -> dump_shader && device -> instance -> debug_flags & RADV_DEBUG_PREOPTIR ; options -> record_llvm_ir = device -> keep_shader_info ; options -> check_ir = device -> instance -> debug_flags & RADV_DEBUG_CHECKIR ; options -> tess_offchip_block_dw_size = device -> tess_offchip_block_dw_size ; options -> address32_hi = device -> physical_device -> rad_info . address32_hi ; if ( options -> supports_spill ) tm_options |= AC_TM_SUPPORTS_SPILL ; if ( device -> instance -> perftest_flags & RADV_PERFTEST_SISCHED ) tm_options |= AC_TM_SISCHED ; if ( options -> check_ir ) tm_options |= AC_TM_CHECK_IR ; thread_compiler = ! ( device -> instance -> debug_flags & RADV_DEBUG_NOTHREADLLVM ) ; radv_init_llvm_once ( ) ; radv_init_llvm_compiler ( & ac_llvm , false , thread_compiler , chip_family , tm_options ) ; if ( gs_copy_shader ) { assert ( shader_count == 1 ) ; radv_compile_gs_copy_shader ( & ac_llvm , * shaders , & binary , & variant -> config , & variant -> info , options ) ; } else { radv_compile_nir_shader ( & ac_llvm , & binary , & variant -> config , & variant -> info , shaders , shader_count , options ) ; } radv_destroy_llvm_compiler ( & ac_llvm , thread_compiler ) ; radv_fill_shader_variant ( device , variant , & binary , stage ) ; if ( code_out ) { * code_out = binary . code ; <S2SV_StartBug> * code_size_out = variant -> code_size ; <S2SV_EndBug> } else free ( binary . code ) ; free ( binary . config ) ; free ( binary . rodata ) ; free ( binary . global_symbol_offsets ) ; free ( binary . relocs ) ; variant -> ref_count = 1 ; if ( device -> keep_shader_info ) { variant -> disasm_string = binary . disasm_string ; variant -> llvm_ir_string = binary . llvm_ir_string ; if ( ! gs_copy_shader && ! module -> nir ) { variant -> nir = * shaders ; variant -> spirv = ( uint32_t * ) module -> data ; variant -> spirv_size = module -> size ; } } else { free ( binary . disasm_string ) ; } return variant ; } | <S2SV_ModStart> * code_size_out = binary . <S2SV_ModEnd> code_size ; } |
138 | CWE-000 static void mlxsw_sp_neigh_rif_gone_sync ( struct mlxsw_sp * mlxsw_sp , struct mlxsw_sp_rif * rif ) { struct mlxsw_sp_neigh_entry * neigh_entry , * tmp ; <S2SV_StartBug> mlxsw_sp_neigh_rif_flush ( mlxsw_sp , rif ) ; <S2SV_EndBug> list_for_each_entry_safe ( neigh_entry , tmp , & rif -> neigh_list , <S2SV_StartBug> rif_list_node ) <S2SV_EndBug> mlxsw_sp_neigh_entry_destroy ( mlxsw_sp , neigh_entry ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> * tmp ; <S2SV_ModEnd> list_for_each_entry_safe ( neigh_entry <S2SV_ModStart> , rif_list_node ) { mlxsw_sp_neigh_entry_update ( mlxsw_sp , neigh_entry , false ) ; <S2SV_ModStart> ) ; } } |
139 | CWE-000 Context_t * _ThreadingSwitch ( _In_ Context_t * Context , _In_ int PreEmptive , _Out_ size_t * TimeSlice , _Out_ int * TaskQueue ) { MCoreThread_t * Thread = NULL ; UUId_t Cpu = CpuGetCurrentId ( ) ; if ( ThreadingGetCurrentThread ( Cpu ) == NULL ) { * TimeSlice = 20 ; * TaskQueue = 0 ; return Context ; } Thread = ThreadingGetCurrentThread ( Cpu ) ; assert ( Thread != NULL ) ; <S2SV_StartBug> if ( Thread -> Flags & THREADING_IMPERSONATION ) { <S2SV_EndBug> * TimeSlice = Thread -> TimeSlice ; * TaskQueue = Thread -> Queue ; return Context ; } if ( Thread -> Data [ THREAD_DATA_FLAGS ] & X86_THREAD_USEDFPU ) { if ( CpuHasFeatures ( CPUID_FEAT_ECX_XSAVE | CPUID_FEAT_ECX_OSXSAVE , 0 ) == OsSuccess ) { save_fpu_extended ( ( uintptr_t * ) Thread -> Data [ THREAD_DATA_MATHBUFFER ] ) ; } else { save_fpu ( ( uintptr_t * ) Thread -> Data [ THREAD_DATA_MATHBUFFER ] ) ; } } Thread = ThreadingSwitch ( Thread , PreEmptive , & Context ) ; * TimeSlice = Thread -> TimeSlice ; * TaskQueue = Thread -> Queue ; SwitchSystemMemorySpace ( Thread -> MemorySpace ) ; TssUpdateThreadStack ( Cpu , ( uintptr_t ) Thread -> Contexts [ THREADING_CONTEXT_LEVEL0 ] ) ; TssUpdateIo ( Cpu , ( uint8_t * ) Thread -> Data [ THREAD_DATA_IOMAP ] ) ; Thread -> Data [ THREAD_DATA_FLAGS ] &= ~ X86_THREAD_USEDFPU ; set_ts ( ) ; SignalHandle ( Thread -> Id ) ; return Context ; } | <S2SV_ModStart> NULL ) ; assert ( ! <S2SV_ModEnd> ( Thread -> <S2SV_ModStart> & THREADING_IMPERSONATION ) ) ; <S2SV_ModEnd> if ( Thread |
140 | CWE-000 static void xhci_pci_quirks ( struct device * dev , struct xhci_hcd * xhci ) { struct pci_dev * pdev = to_pci_dev ( dev ) ; if ( pdev -> vendor == PCI_VENDOR_ID_FRESCO_LOGIC && ( pdev -> device == PCI_DEVICE_ID_FRESCO_LOGIC_PDK || pdev -> device == PCI_DEVICE_ID_FRESCO_LOGIC_FL1400 ) ) { if ( pdev -> device == PCI_DEVICE_ID_FRESCO_LOGIC_PDK && pdev -> revision == 0x0 ) { xhci -> quirks |= XHCI_RESET_EP_QUIRK ; xhci_dbg ( xhci , "QUIRK:<S2SV_blank>Fresco<S2SV_blank>Logic<S2SV_blank>xHC<S2SV_blank>needs<S2SV_blank>configure" "<S2SV_blank>endpoint<S2SV_blank>cmd<S2SV_blank>after<S2SV_blank>reset<S2SV_blank>endpoint\\n" ) ; } xhci -> quirks |= XHCI_BROKEN_MSI ; xhci_dbg ( xhci , "QUIRK:<S2SV_blank>Fresco<S2SV_blank>Logic<S2SV_blank>revision<S2SV_blank>%u<S2SV_blank>" "has<S2SV_blank>broken<S2SV_blank>MSI<S2SV_blank>implementation\\n" , pdev -> revision ) ; xhci -> quirks |= XHCI_TRUST_TX_LENGTH ; } if ( pdev -> vendor == PCI_VENDOR_ID_NEC ) xhci -> quirks |= XHCI_NEC_HOST ; if ( pdev -> vendor == PCI_VENDOR_ID_AMD && xhci -> hci_version == 0x96 ) xhci -> quirks |= XHCI_AMD_0x96_HOST ; if ( pdev -> vendor == PCI_VENDOR_ID_AMD && usb_amd_find_chipset_info ( ) ) xhci -> quirks |= XHCI_AMD_PLL_FIX ; if ( pdev -> vendor == PCI_VENDOR_ID_INTEL && pdev -> device == PCI_DEVICE_ID_INTEL_PANTHERPOINT_XHCI ) { xhci -> quirks |= XHCI_EP_LIMIT_QUIRK ; xhci -> limit_active_eps = 64 ; xhci -> quirks |= XHCI_SW_BW_CHECKING ; xhci -> quirks |= XHCI_SPURIOUS_REBOOT ; xhci -> quirks |= XHCI_AVOID_BEI ; } if ( pdev -> vendor == PCI_VENDOR_ID_ETRON && pdev -> device == PCI_DEVICE_ID_ASROCK_P67 ) { xhci -> quirks |= XHCI_RESET_ON_RESUME ; xhci_dbg ( xhci , "QUIRK:<S2SV_blank>Resetting<S2SV_blank>on<S2SV_blank>resume\\n" ) ; xhci -> quirks |= XHCI_TRUST_TX_LENGTH ; } <S2SV_StartBug> if ( pdev -> vendor == PCI_VENDOR_ID_VIA ) <S2SV_EndBug> xhci -> quirks |= XHCI_RESET_ON_RESUME ; } | <S2SV_ModStart> -> vendor == PCI_VENDOR_ID_RENESAS && pdev -> device == 0x0015 && pdev -> subsystem_vendor == PCI_VENDOR_ID_SAMSUNG && pdev -> subsystem_device == 0xc0cd ) xhci -> quirks |= XHCI_RESET_ON_RESUME ; if ( pdev -> vendor == |
141 | CWE-000 static int set_format ( struct snd_usb_substream * subs , struct audioformat * fmt ) { struct usb_device * dev = subs -> dev ; struct usb_host_interface * alts ; struct usb_interface_descriptor * altsd ; struct usb_interface * iface ; int err ; iface = usb_ifnum_to_if ( dev , fmt -> iface ) ; if ( WARN_ON ( ! iface ) ) return - EINVAL ; alts = & iface -> altsetting [ fmt -> altset_idx ] ; altsd = get_iface_desc ( alts ) ; if ( WARN_ON ( altsd -> bAlternateSetting != fmt -> altsetting ) ) return - EINVAL ; if ( fmt == subs -> cur_audiofmt ) return 0 ; if ( subs -> interface >= 0 && subs -> interface != fmt -> iface ) { err = usb_set_interface ( subs -> dev , subs -> interface , 0 ) ; if ( err < 0 ) { dev_err ( & dev -> dev , "%d:%d:<S2SV_blank>return<S2SV_blank>to<S2SV_blank>setting<S2SV_blank>0<S2SV_blank>failed<S2SV_blank>(%d)\\n" , fmt -> iface , fmt -> altsetting , err ) ; return - EIO ; } subs -> interface = - 1 ; subs -> altset_idx = 0 ; } if ( subs -> interface != fmt -> iface || subs -> altset_idx != fmt -> altset_idx ) { err = snd_usb_select_mode_quirk ( subs , fmt ) ; if ( err < 0 ) return - EIO ; err = usb_set_interface ( dev , fmt -> iface , fmt -> altsetting ) ; if ( err < 0 ) { dev_err ( & dev -> dev , "%d:%d:<S2SV_blank>usb_set_interface<S2SV_blank>failed<S2SV_blank>(%d)\\n" , fmt -> iface , fmt -> altsetting , err ) ; <S2SV_StartBug> return - EIO ; <S2SV_EndBug> } dev_dbg ( & dev -> dev , "setting<S2SV_blank>usb<S2SV_blank>interface<S2SV_blank>%d:%d\\n" , fmt -> iface , fmt -> altsetting ) ; subs -> interface = fmt -> iface ; subs -> altset_idx = fmt -> altset_idx ; snd_usb_set_interface_quirk ( dev ) ; } subs -> data_endpoint = snd_usb_add_endpoint ( subs -> stream -> chip , alts , fmt -> endpoint , subs -> direction , SND_USB_ENDPOINT_TYPE_DATA ) ; if ( ! subs -> data_endpoint ) return - EINVAL ; err = set_sync_endpoint ( subs , fmt , dev , alts , altsd ) ; if ( err < 0 ) return err ; err = snd_usb_init_pitch ( subs -> stream -> chip , fmt -> iface , alts , fmt ) ; if ( err < 0 ) return err ; subs -> cur_audiofmt = fmt ; snd_usb_set_format_quirk ( subs , fmt ) ; return 0 ; } | <S2SV_ModStart> err ) ; # ifdef VENDOR_EDIT if ( ( 0x2717 == USB_ID_VENDOR ( subs -> stream -> chip -> usb_id ) ) && ( 0x3801 == USB_ID_PRODUCT ( subs -> stream -> chip -> usb_id ) ) ) kick_usbpd_vbus_sm ( ) ; # endif |
142 | CWE-000 int CirqBuffDynDestroy ( CirqBufferType * cPtr ) { <S2SV_StartBug> free ( cPtr -> bufStart ) ; <S2SV_EndBug> <S2SV_StartBug> free ( cPtr ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> cPtr ) { asfree <S2SV_ModEnd> ( cPtr -> <S2SV_ModStart> bufStart ) ; asfree <S2SV_ModEnd> ( cPtr ) |
143 | CWE-000 static void callee_filter_on_inactive ( zRPC_filter * filter , zRPC_channel * channel , void * tag ) { <S2SV_StartBug> zRPC_channel_set_custom_data ( channel , NULL ) ; <S2SV_EndBug> } | <S2SV_ModStart> tag ) { <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
144 | CWE-000 static gboolean _flatpak_dir_ensure_repo ( FlatpakDir * self , gboolean allow_empty , GCancellable * cancellable , GError * * error ) { g_autoptr ( GFile ) repodir = NULL ; g_autoptr ( OstreeRepo ) repo = NULL ; g_autoptr ( GError ) my_error = NULL ; gboolean use_helper = FALSE ; if ( self -> repo == NULL ) { if ( ! flatpak_dir_ensure_path ( self , cancellable , & my_error ) ) { if ( allow_empty ) return TRUE ; g_propagate_error ( error , g_steal_pointer ( & my_error ) ) ; return FALSE ; } repodir = g_file_get_child ( self -> basedir , "repo" ) ; if ( self -> no_system_helper || self -> user || getuid ( ) == 0 ) { repo = system_ostree_repo_new ( repodir ) ; } else { g_autoptr ( GFile ) cache_dir = NULL ; g_autofree char * cache_path = NULL ; repo = system_ostree_repo_new ( repodir ) ; use_helper = TRUE ; cache_dir = flatpak_ensure_user_cache_dir_location ( error ) ; if ( cache_dir == NULL ) return FALSE ; cache_path = g_file_get_path ( cache_dir ) ; if ( ! ostree_repo_set_cache_dir ( repo , AT_FDCWD , cache_path , cancellable , error ) ) return FALSE ; } if ( ! g_file_query_exists ( repodir , cancellable ) ) { OstreeRepoMode mode = OSTREE_REPO_MODE_BARE_USER_ONLY ; <S2SV_StartBug> const char * mode_env = g_getenv ( "FLATPAK_OSTREE_REPO_MODE" ) ; <S2SV_EndBug> if ( g_strcmp0 ( mode_env , "user-only" ) == 0 ) mode = OSTREE_REPO_MODE_BARE_USER_ONLY ; if ( g_strcmp0 ( mode_env , "user" ) == 0 ) mode = OSTREE_REPO_MODE_BARE_USER ; if ( ! ostree_repo_create ( repo , mode , cancellable , & my_error ) ) { flatpak_rm_rf ( repodir , cancellable , NULL ) ; if ( allow_empty ) return TRUE ; g_propagate_error ( error , g_steal_pointer ( & my_error ) ) ; return FALSE ; } if ( ! flatpak_dir_mark_changed ( self , & my_error ) ) { g_warning ( "Error<S2SV_blank>marking<S2SV_blank>directory<S2SV_blank>as<S2SV_blank>changed:<S2SV_blank>%s" , my_error -> message ) ; g_clear_error ( & my_error ) ; } } else { if ( ! ostree_repo_open ( repo , cancellable , error ) ) { g_autofree char * repopath = NULL ; repopath = g_file_get_path ( repodir ) ; g_prefix_error ( error , _ ( "While<S2SV_blank>opening<S2SV_blank>repository<S2SV_blank>%s:<S2SV_blank>" ) , repopath ) ; return FALSE ; } } if ( ! use_helper ) { GKeyFile * orig_config = NULL ; g_autofree char * orig_min_free_space_percent = NULL ; orig_config = ostree_repo_get_config ( repo ) ; orig_min_free_space_percent = g_key_file_get_value ( orig_config , "core" , "min-free-space-percent" , NULL ) ; if ( orig_min_free_space_percent == NULL ) { GKeyFile * config = ostree_repo_copy_config ( repo ) ; g_key_file_set_string ( config , "core" , "min-free-space-percent" , "0" ) ; if ( ! ostree_repo_write_config ( repo , config , error ) ) return FALSE ; if ( ! ostree_repo_reload_config ( repo , cancellable , error ) ) return FALSE ; } } g_assert ( self -> repo == NULL ) ; self -> repo = g_object_ref ( repo ) ; } return TRUE ; } | <S2SV_ModStart> = OSTREE_REPO_MODE_BARE_USER_ONLY ; <S2SV_ModEnd> if ( ! |
145 | CWE-000 static int completion_status ( struct cblk_dev * c , int timeout __attribute__ ( ( unused ) ) ) { int rc = ETIME ; uint32_t status = 0x0 ; uint32_t errbits = 0x0 ; int slot = - 1 ; struct cblk_req * req ; time_t usecs ; static int count = 0 ; # ifdef CONFIG_WAIT_FOR_IRQ rc = snap_action_completed ( c -> act , NULL , timeout ) ; if ( rc == 0 ) { fprintf ( stderr , "err:<S2SV_blank>Timeout<S2SV_blank>while<S2SV_blank>Waiting<S2SV_blank>for<S2SV_blank>Idle<S2SV_blank>%d\\n" , rc ) ; return - 1 ; } # endif rc = __cblk_read ( c , ACTION_STATUS , & status ) ; if ( rc != 0 ) { fprintf ( stderr , "err:<S2SV_blank>MMIO32<S2SV_blank>read<S2SV_blank>ACTION_STATUS<S2SV_blank>%d\\n" , rc ) ; dev_set_status ( c , CBLK_ERROR ) ; return - 2 ; } if ( ( ( status & ACTION_STATUS_ERROR_MASK ) != 0x0 ) && ( count ++ < 2 ) ) { __cblk_read ( c , ACTION_ERROR_BITS , & errbits ) ; <S2SV_StartBug> fprintf ( stderr , "[%s]<S2SV_blank>warn:<S2SV_blank>ACTION_STATUS=%08x<S2SV_blank>ERROR_MASK<S2SV_blank>not<S2SV_blank>0<S2SV_blank>" <S2SV_EndBug> "ACTION_ERROR_BITS=%08x\\n" , __func__ , status , errbits ) ; } if ( ( status & ACTION_STATUS_COMPLETED ) != ACTION_STATUS_COMPLETED ) { return - 3 ; } slot = status & ACTION_STATUS_COMPLETION_MASK ; req = & c -> req [ slot ] ; if ( status == ACTION_STATUS_WRITE_COMPLETED ) { block_trace ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[%s]<S2SV_blank>HW<S2SV_blank>WRITE_COMPLETED<S2SV_blank>%08x<S2SV_blank>slot:<S2SV_blank>%d<S2SV_blank>LBA=%ld\\n" , __func__ , status , slot , req -> lba ) ; } else { block_trace ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[%s]<S2SV_blank>HW<S2SV_blank>READ_COMPLETED<S2SV_blank>%08x<S2SV_blank>slot:<S2SV_blank>%d<S2SV_blank>LBA=%ld\\n" , __func__ , status , slot , req -> lba ) ; } gettimeofday ( & req -> h_etime , NULL ) ; usecs = timediff_usec ( & req -> h_etime , & req -> h_stime ) ; if ( cblk_is_write ( req ) ) c -> avg_hw_write_usecs += usecs ; else c -> avg_hw_read_usecs += usecs ; return slot ; } | <S2SV_ModStart> errbits ) ; block_trace ( <S2SV_ModEnd> "[%s]<S2SV_blank>warn:<S2SV_blank>ACTION_STATUS=%08x<S2SV_blank>ERROR_MASK<S2SV_blank>not<S2SV_blank>0<S2SV_blank>" "ACTION_ERROR_BITS=%08x\\n" , |
146 | CWE-000 void * ft_memchr ( const void * src , int src_c , size_t len ) { <S2SV_StartBug> const char * csrc ; <S2SV_EndBug> <S2SV_StartBug> csrc = ( const char * ) src ; <S2SV_EndBug> while ( len -- > 0 ) { <S2SV_StartBug> if ( * csrc ++ == ( unsigned char ) src_c ) <S2SV_EndBug> return ( ( void * ) csrc - 1 ) ; } return ( NULL ) ; } | <S2SV_ModStart> ) { const unsigned <S2SV_ModStart> char * csrc ; unsigned char to_find ; to_find = ( unsigned char ) src_c <S2SV_ModStart> = ( const unsigned <S2SV_ModStart> csrc ++ == to_find <S2SV_ModEnd> ) return ( |
147 | CWE-000 int main ( int argc , char * * argv ) { int time , oldtime , newtime ; int verLen , i ; const char * versionString ; # ifndef BUSY_WAIT struct timespec t ; # endif registerHandler ( ) ; <S2SV_StartBug> if ( getuid ( ) == 0 ) <S2SV_EndBug> { printf ( "Quake<S2SV_blank>II<S2SV_blank>shouldn\'t<S2SV_blank>be<S2SV_blank>run<S2SV_blank>as<S2SV_blank>root!<S2SV_blank>Backing<S2SV_blank>out<S2SV_blank>to<S2SV_blank>save<S2SV_blank>your<S2SV_blank>ass.<S2SV_blank>If\\n" ) ; printf ( "you<S2SV_blank>really<S2SV_blank>know<S2SV_blank>what<S2SV_blank>you\'re<S2SV_blank>doing,<S2SV_blank>edit<S2SV_blank>src/unix/main.c<S2SV_blank>and<S2SV_blank>remove\\n" ) ; printf ( "this<S2SV_blank>check.<S2SV_blank>But<S2SV_blank>don\'t<S2SV_blank>complain<S2SV_blank>if<S2SV_blank>Quake<S2SV_blank>II<S2SV_blank>eats<S2SV_blank>your<S2SV_blank>dog<S2SV_blank>afterwards!\\n" ) ; return 1 ; } if ( getuid ( ) != geteuid ( ) ) { printf ( "The<S2SV_blank>effective<S2SV_blank>UID<S2SV_blank>is<S2SV_blank>not<S2SV_blank>the<S2SV_blank>real<S2SV_blank>UID!<S2SV_blank>Your<S2SV_blank>binary<S2SV_blank>is<S2SV_blank>probably<S2SV_blank>marked\\n" ) ; printf ( "\'setuid\'.<S2SV_blank>That<S2SV_blank>is<S2SV_blank>not<S2SV_blank>good<S2SV_blank>idea,<S2SV_blank>please<S2SV_blank>fix<S2SV_blank>it<S2SV_blank>:)<S2SV_blank>If<S2SV_blank>you<S2SV_blank>really<S2SV_blank>know\\n" ) ; printf ( "what<S2SV_blank>you\'re<S2SV_blank>doing<S2SV_blank>edit<S2SV_blank>src/unix/main.c<S2SV_blank>and<S2SV_blank>remove<S2SV_blank>this<S2SV_blank>check.<S2SV_blank>Don\'t\\n" ) ; printf ( "complain<S2SV_blank>if<S2SV_blank>Quake<S2SV_blank>II<S2SV_blank>eats<S2SV_blank>your<S2SV_blank>dog<S2SV_blank>afterwards!\\n" ) ; return 1 ; } setenv ( "LC_ALL" , "C" , 1 ) ; versionString = va ( "Yamagi<S2SV_blank>Quake<S2SV_blank>II<S2SV_blank>v%s" , YQ2VERSION ) ; verLen = strlen ( versionString ) ; printf ( "\\n%s\\n" , versionString ) ; for ( i = 0 ; i < verLen ; ++ i ) { putc ( '=' , stdout ) ; } puts ( "\\n" ) ; # ifndef DEDICATED_ONLY printf ( "Client<S2SV_blank>build<S2SV_blank>options:\\n" ) ; # ifdef SDL2 printf ( "<S2SV_blank>+<S2SV_blank>SDL2\\n" ) ; # else printf ( "<S2SV_blank>-<S2SV_blank>SDL2<S2SV_blank>(using<S2SV_blank>1.2)\\n" ) ; # endif # ifdef CDA printf ( "<S2SV_blank>+<S2SV_blank>CD<S2SV_blank>audio\\n" ) ; # else printf ( "<S2SV_blank>-<S2SV_blank>CD<S2SV_blank>audio\\n" ) ; # endif # ifdef OGG printf ( "<S2SV_blank>+<S2SV_blank>OGG/Vorbis\\n" ) ; # else printf ( "<S2SV_blank>-<S2SV_blank>OGG/Vorbis\\n" ) ; # endif # ifdef USE_OPENAL printf ( "<S2SV_blank>+<S2SV_blank>OpenAL<S2SV_blank>audio\\n" ) ; # else printf ( "<S2SV_blank>-<S2SV_blank>OpenAL<S2SV_blank>audio\\n" ) ; # endif # ifdef ZIP printf ( "<S2SV_blank>+<S2SV_blank>Zip<S2SV_blank>file<S2SV_blank>support\\n" ) ; # else printf ( "<S2SV_blank>-<S2SV_blank>Zip<S2SV_blank>file<S2SV_blank>support\\n" ) ; # endif # endif printf ( "Platform:<S2SV_blank>%s\\n" , YQ2OSTYPE ) ; printf ( "Architecture:<S2SV_blank>%s\\n" , YQ2ARCH ) ; randk_seed ( ) ; Qcommon_Init ( argc , argv ) ; fcntl ( fileno ( stdin ) , F_SETFL , fcntl ( fileno ( stdin ) , F_GETFL , NULL ) | FNDELAY ) ; oldtime = Sys_Milliseconds ( ) ; t . tv_sec = 0 ; while ( 1 ) { do { # ifndef BUSY_WAIT t . tv_nsec = 10000 ; nanosleep ( & t , NULL ) ; # endif newtime = Sys_Milliseconds ( ) ; time = newtime - oldtime ; } while ( time < 1 ) ; Qcommon_Frame ( time ) ; oldtime = newtime ; } return 0 ; } | <S2SV_ModStart> ( ) ; for ( i = 0 ; i < argc ; i ++ ) { if ( strcmp ( argv [ i ] , "-portable" ) == 0 ) { is_portable = true ; } } |
148 | CWE-000 void <S2SV_StartBug> press_closer_floor ( struct pos * p ) <S2SV_EndBug> { struct closer_floor * c = closer_floor_at_pos ( p ) ; if ( ! c ) return ; if ( c -> broken ) return ; c -> pressed = true ; if ( ! c -> prev_pressed ) { <S2SV_StartBug> register_changed_pos ( & c -> p ) ; <S2SV_EndBug> c -> prev_pressed = true ; c -> priority = anim_cycle ; } } | <S2SV_ModStart> pos * p , struct anim * a <S2SV_ModStart> prev_pressed ) { kid_haptic ( a , KID_HAPTIC_COLLISION ) ; |
149 | CWE-000 static struct key * construct_key_and_link ( struct key_type * type , const char * description , const char * callout_info , size_t callout_len , void * aux , struct key * dest_keyring , unsigned long flags ) { struct key_user * user ; struct key * key ; int ret ; kenter ( "" ) ; <S2SV_StartBug> user = key_user_lookup ( current_fsuid ( ) ) ; <S2SV_EndBug> if ( ! user ) <S2SV_StartBug> return ERR_PTR ( - ENOMEM ) ; <S2SV_EndBug> construct_get_dest_keyring ( & dest_keyring ) ; ret = construct_alloc_key ( type , description , dest_keyring , flags , user , & key ) ; key_user_put ( user ) ; if ( ret == 0 ) { ret = construct_key ( key , callout_info , callout_len , aux , dest_keyring ) ; if ( ret < 0 ) { kdebug ( "cons<S2SV_blank>failed" ) ; goto construction_failed ; } } else if ( ret == - EINPROGRESS ) { ret = 0 ; } else { <S2SV_StartBug> goto couldnt_alloc_key ; <S2SV_EndBug> } key_put ( dest_keyring ) ; kleave ( "<S2SV_blank>=<S2SV_blank>key<S2SV_blank>%d" , key_serial ( key ) ) ; return key ; construction_failed : key_negate_and_link ( key , key_negative_timeout , NULL , NULL ) ; key_put ( key ) ; <S2SV_StartBug> couldnt_alloc_key : <S2SV_EndBug> <S2SV_StartBug> key_put ( dest_keyring ) ; <S2SV_EndBug> kleave ( "<S2SV_blank>=<S2SV_blank>%d" , ret ) ; return ERR_PTR ( ret ) ; } | <S2SV_ModStart> "" ) ; if ( type == & key_type_keyring <S2SV_ModEnd> ) return ERR_PTR <S2SV_ModStart> ERR_PTR ( - EPERM ) ; ret = construct_get_dest_keyring ( & dest_keyring ) ; if ( ret ) goto error ; user = key_user_lookup ( current_fsuid ( ) ) ; if ( ! user ) { ret = - ENOMEM ; goto error_put_dest_keyring ; } <S2SV_ModEnd> ret = construct_alloc_key <S2SV_ModStart> else { goto error_put_dest_keyring <S2SV_ModEnd> ; } key_put <S2SV_ModStart> key ) ; error_put_dest_keyring <S2SV_ModEnd> : key_put ( <S2SV_ModStart> dest_keyring ) ; error : |
150 | CWE-000 struct cnxctx * fd_cnx_cli_connect_tcp ( sSA * sa , socklen_t addrlen ) { int sock = 0 ; struct cnxctx * cnx = NULL ; char sa_buf [ sSA_DUMP_STRLEN ] ; TRACE_ENTRY ( "%p<S2SV_blank>%d" , sa , addrlen ) ; CHECK_PARAMS_DO ( sa && addrlen , return NULL ) ; fd_sa_sdump_numeric ( sa_buf , sa ) ; LOG_D ( "Connecting<S2SV_blank>to<S2SV_blank>TCP<S2SV_blank>%s..." , sa_buf ) ; { int ret = fd_tcp_client ( & sock , sa , addrlen ) ; if ( ret != 0 ) { LOG_E ( "TCP<S2SV_blank>connection<S2SV_blank>to<S2SV_blank>%s<S2SV_blank>failed:<S2SV_blank>%s" , sa_buf , strerror ( ret ) ) ; return NULL ; } } CHECK_MALLOC_DO ( cnx = fd_cnx_init ( 1 ) , { shutdown ( sock , SHUT_RDWR ) ; close ( sock ) ; return NULL ; } ) ; cnx -> cc_socket = sock ; cnx -> cc_family = sa -> sa_family ; cnx -> cc_proto = IPPROTO_TCP ; fd_cnx_s_setto ( cnx -> cc_socket ) ; { int rc ; snprintf ( cnx -> cc_id , sizeof ( cnx -> cc_id ) , CC_ID_HDR "TCP,#%d->%s" , cnx -> cc_socket , sa_buf ) ; <S2SV_StartBug> rc = getnameinfo ( sa , addrlen , cnx -> cc_remid , sizeof ( cnx -> cc_remid ) , NULL , 0 , 0 ) ; <S2SV_EndBug> if ( rc ) snprintf ( cnx -> cc_remid , sizeof ( cnx -> cc_remid ) , "[err:%s]" , gai_strerror ( rc ) ) ; } LOG_A ( "TCP<S2SV_blank>connection<S2SV_blank>to<S2SV_blank>%s<S2SV_blank>succeed<S2SV_blank>(socket:%d)." , sa_buf , sock ) ; return cnx ; } | <S2SV_ModStart> ; rc = fd_addr_to_string ( sa <S2SV_ModEnd> , cnx -> <S2SV_ModStart> cnx -> cc_remid ) ; if ( rc ) snprintf ( cnx -> cc_remid <S2SV_ModStart> cc_remid ) , <S2SV_ModEnd> "[err:%s]" , gai_strerror |
151 | CWE-000 static int get_device_address ( struct smem_client * smem_client , struct ion_handle * hndl , unsigned long align , ion_phys_addr_t * iova , unsigned long * buffer_size , unsigned long flags , enum hal_buffer buffer_type ) { int rc = 0 ; int domain , partition ; struct ion_client * clnt = NULL ; if ( ! iova || ! buffer_size || ! hndl || ! smem_client ) { <S2SV_StartBug> dprintk ( VIDC_ERR , "Invalid<S2SV_blank>params:<S2SV_blank>%p,<S2SV_blank>%p,<S2SV_blank>%p,<S2SV_blank>%p\\n" , <S2SV_EndBug> smem_client , hndl , iova , buffer_size ) ; return - EINVAL ; } clnt = smem_client -> clnt ; if ( ! clnt ) { dprintk ( VIDC_ERR , "Invalid<S2SV_blank>client\\n" ) ; return - EINVAL ; } if ( is_iommu_present ( smem_client -> res ) ) { rc = msm_smem_get_domain_partition ( smem_client , flags , buffer_type , & domain , & partition ) ; if ( rc ) { dprintk ( VIDC_ERR , "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>domain<S2SV_blank>and<S2SV_blank>partition:<S2SV_blank>%d\\n" , rc ) ; goto mem_domain_get_failed ; } } if ( flags & SMEM_SECURE ) { rc = msm_ion_secure_buffer ( clnt , hndl , get_tz_usage ( smem_client , buffer_type ) , 0 ) ; if ( rc ) { dprintk ( VIDC_ERR , "Failed<S2SV_blank>to<S2SV_blank>secure<S2SV_blank>memory\\n" ) ; goto mem_domain_get_failed ; } } if ( is_iommu_present ( smem_client -> res ) ) { dprintk ( VIDC_DBG , "Calling<S2SV_blank>ion_map_iommu<S2SV_blank>-<S2SV_blank>domain:<S2SV_blank>%d,<S2SV_blank>partition:<S2SV_blank>%d\\n" , domain , partition ) ; trace_msm_smem_buffer_iommu_op_start ( "MAP" , domain , partition , align , * iova , * buffer_size ) ; rc = ion_map_iommu ( clnt , hndl , domain , partition , align , 0 , iova , buffer_size , 0 , 0 ) ; trace_msm_smem_buffer_iommu_op_end ( "MAP" , domain , partition , align , * iova , * buffer_size ) ; } else { dprintk ( VIDC_DBG , "Using<S2SV_blank>physical<S2SV_blank>memory<S2SV_blank>address\\n" ) ; rc = ion_phys ( clnt , hndl , iova , ( size_t * ) buffer_size ) ; } if ( rc ) { dprintk ( VIDC_ERR , "ion<S2SV_blank>memory<S2SV_blank>map<S2SV_blank>failed<S2SV_blank>-<S2SV_blank>%d\\n" , rc ) ; goto mem_map_failed ; } <S2SV_StartBug> return 0 ; <S2SV_EndBug> mem_map_failed : if ( flags & SMEM_SECURE ) msm_ion_unsecure_buffer ( clnt , hndl ) ; mem_domain_get_failed : return rc ; } | <S2SV_ModStart> ( VIDC_ERR , "Invalid<S2SV_blank>params:<S2SV_blank>%pK,<S2SV_blank>%pK,<S2SV_blank>%pK,<S2SV_blank>%pK\\n" <S2SV_ModEnd> , smem_client , <S2SV_ModStart> mem_map_failed ; } dprintk ( VIDC_DBG , "mapped<S2SV_blank>ion<S2SV_blank>handle<S2SV_blank>%pK<S2SV_blank>to<S2SV_blank>%pa\\n" , hndl , iova ) ; |
152 | CWE-000 static inline char * copy_strptr ( char * dptr , int dsize ) { char * pretval = NULL ; TSRMLS_FETCH ( ) ; <S2SV_StartBug> pretval = ( char * ) ecalloc ( sizeof ( char ) , dsize + 2 ) ; <S2SV_EndBug> if ( pretval == NULL ) { php_error_docref ( NULL TSRMLS_CC , E_ERROR , "Out<S2SV_blank>of<S2SV_blank>memory<S2SV_blank>while<S2SV_blank>allocating<S2SV_blank>memory" ) ; return NULL ; } memset ( pretval , 0x00 , dsize + 1 ) ; strncpy ( pretval , dptr , dsize ) ; if ( pretval == NULL ) { php_error_docref ( NULL TSRMLS_CC , E_ERROR , "failed<S2SV_blank>to<S2SV_blank>strncpy" ) ; return NULL ; } return pretval ; } | <S2SV_ModStart> ) ecalloc ( dsize + 1 , <S2SV_ModStart> ( char ) <S2SV_ModEnd> ) ; if |
153 | CWE-000 static void ucp_wireup_process_request ( ucp_worker_h worker , const ucp_wireup_msg_t * msg , uint64_t uuid , const char * peer_name , unsigned address_count , const ucp_address_entry_t * address_list ) { ucp_rsc_index_t rsc_tli [ UCP_MAX_LANES ] ; uint8_t addr_indices [ UCP_MAX_LANES ] ; ucp_lane_index_t lane , remote_lane ; ucp_rsc_index_t rsc_index ; ucp_ep_params_t params ; ucs_status_t status ; uint64_t tl_bitmap = 0 ; ucp_ep_h ep ; <S2SV_StartBug> ucs_trace ( "got<S2SV_blank>wireup<S2SV_blank>request<S2SV_blank>from<S2SV_blank>0x%" PRIx64 , uuid ) ; <S2SV_EndBug> if ( msg -> ep_uuid == worker -> uuid ) { ep = ucp_worker_ep_find ( worker , uuid ) ; if ( ep == NULL ) { status = ucp_ep_new ( worker , uuid , peer_name , "remote-request" , & ep ) ; if ( status != UCS_OK ) { return ; } ep -> flags |= UCP_EP_FLAG_DEST_UUID_PEER ; } else { ucs_assert ( ep -> flags & UCP_EP_FLAG_DEST_UUID_PEER ) ; } } else { ep = ucp_worker_ep_find ( worker , msg -> ep_uuid ) ; if ( ep == NULL ) { ucs_trace ( "got<S2SV_blank>connection<S2SV_blank>request<S2SV_blank>with<S2SV_blank>invalid<S2SV_blank>ep_uuid<S2SV_blank>0x%" PRIx64 , msg -> ep_uuid ) ; return ; } ucs_assert ( ! ( ep -> flags & UCP_EP_FLAG_DEST_UUID_PEER ) ) ; ucp_ep_delete_from_hash ( ep ) ; ep -> dest_uuid = uuid ; ep -> flags |= UCP_EP_FLAG_DEST_UUID_PEER ; ucp_ep_add_to_hash ( ep ) ; <S2SV_StartBug> } <S2SV_EndBug> params . field_mask = UCP_EP_PARAM_FIELD_ERR_HANDLING_MODE ; params . err_mode = msg -> err_mode ; <S2SV_StartBug> status = ucp_wireup_init_lanes ( ep , & params , 0 , address_count , address_list , <S2SV_EndBug> addr_indices ) ; if ( status != UCS_OK ) { return ; } if ( ! ( ep -> flags & UCP_EP_FLAG_LOCAL_CONNECTED ) ) { status = ucp_wireup_connect_local ( ep , addr_indices , address_count , address_list ) ; if ( status != UCS_OK ) { return ; } ep -> flags |= UCP_EP_FLAG_LOCAL_CONNECTED ; memset ( rsc_tli , - 1 , sizeof ( rsc_tli ) ) ; for ( lane = 0 ; lane < ucp_ep_num_lanes ( ep ) ; ++ lane ) { rsc_index = ucp_ep_get_rsc_index ( ep , lane ) ; for ( remote_lane = 0 ; remote_lane < UCP_MAX_LANES ; ++ remote_lane ) { if ( addr_indices [ lane ] == msg -> tli [ remote_lane ] ) { ucs_assert ( ucp_worker_is_tl_p2p ( worker , rsc_index ) ) ; rsc_tli [ remote_lane ] = rsc_index ; tl_bitmap |= UCS_BIT ( rsc_index ) ; } } } ucs_trace ( "ep<S2SV_blank>%p:<S2SV_blank>sending<S2SV_blank>wireup<S2SV_blank>reply" , ep ) ; status = ucp_wireup_msg_send ( ep , UCP_WIREUP_MSG_REPLY , ep -> dest_uuid , tl_bitmap , rsc_tli ) ; if ( status != UCS_OK ) { return ; } } } | <S2SV_ModStart> ucp_ep_h ep ; unsigned ep_init_flags = 0 ; <S2SV_ModStart> ep ) ; ep_init_flags = UCP_EP_CREATE_AM_LANE ; <S2SV_ModStart> & params , ep_init_flags <S2SV_ModEnd> , address_count , |
154 | CWE-000 void printstuff ( char * * str , t_flags flags , char * * complex ) { int i ; <S2SV_StartBug> i = 0 ; <S2SV_EndBug> if ( flags . l ) complexprint ( complex , str ) ; else { while ( str [ i ] ) { ft_printf ( "%s\\n" , str [ i ] ) ; i ++ ; } } } | <S2SV_ModStart> i = 0 ; printf ( "" ) |
155 | CWE-000 static void ApplyLogicalMappingFile ( HTAB * tuplecid_data , Oid relid , const char * fname ) { char path [ MAXPGPATH ] ; int fd ; int readBytes ; LogicalRewriteMappingData map ; sprintf ( path , "pg_llog/mappings/%s" , fname ) ; fd = OpenTransientFile ( path , O_RDONLY | PG_BINARY , 0 ) ; if ( fd < 0 ) ereport ( ERROR , ( errmsg ( "could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>file<S2SV_blank>\\"%s\\":<S2SV_blank>%m" , path ) ) ) ; while ( true ) { ReorderBufferTupleCidKey key ; ReorderBufferTupleCidEnt * ent ; ReorderBufferTupleCidEnt * new_ent ; bool found ; memset ( & key , 0 , sizeof ( ReorderBufferTupleCidKey ) ) ; readBytes = read ( fd , & map , sizeof ( LogicalRewriteMappingData ) ) ; if ( readBytes < 0 ) ereport ( ERROR , ( errcode_for_file_access ( ) , errmsg ( "could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>file<S2SV_blank>\\"%s\\":<S2SV_blank>%m" , path ) ) ) ; else if ( readBytes == 0 ) break ; else if ( readBytes != sizeof ( LogicalRewriteMappingData ) ) ereport ( ERROR , ( errcode_for_file_access ( ) , <S2SV_StartBug> errmsg ( "could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>file<S2SV_blank>\\"%s\\",<S2SV_blank>read<S2SV_blank>%d<S2SV_blank>instead<S2SV_blank>of<S2SV_blank>%d" , <S2SV_EndBug> path , readBytes , ( int32 ) sizeof ( LogicalRewriteMappingData ) ) ) ) ; key . relnode = map . old_node ; ItemPointerCopy ( & map . old_tid , & key . tid ) ; ent = ( ReorderBufferTupleCidEnt * ) hash_search ( tuplecid_data , ( void * ) & key , HASH_FIND , NULL ) ; if ( ! ent ) continue ; key . relnode = map . new_node ; ItemPointerCopy ( & map . new_tid , & key . tid ) ; new_ent = ( ReorderBufferTupleCidEnt * ) hash_search ( tuplecid_data , ( void * ) & key , HASH_ENTER , & found ) ; if ( found ) { Assert ( ent -> cmin == InvalidCommandId || ent -> cmin == new_ent -> cmin ) ; Assert ( ent -> cmax == InvalidCommandId || ent -> cmax == new_ent -> cmax ) ; } else { new_ent -> cmin = ent -> cmin ; new_ent -> cmax = ent -> cmax ; new_ent -> combocid = ent -> combocid ; } } } | <S2SV_ModStart> , errmsg ( "could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>from<S2SV_blank>file<S2SV_blank>\\"%s\\":<S2SV_blank>read<S2SV_blank>%d<S2SV_blank>instead<S2SV_blank>of<S2SV_blank>%d<S2SV_blank>bytes" <S2SV_ModEnd> , path , |
156 | CWE-000 ERR_error FIL_get_all_files ( UTI_str p , MEM_heap * heap_of_paths ) { # ifdef UNIX ERR_ASSERT ( FIL_file_is_dir ( p ) , "file<S2SV_blank>%s<S2SV_blank>is<S2SV_blank>not<S2SV_blank>a<S2SV_blank>directory" , p ) ; DIR * directory ; struct dirent * entry ; if ( ( directory = opendir ( p ) ) != NULL ) { while ( ( entry = readdir ( directory ) ) != NULL ) { if ( ! FIL_file_is_dir ( entry -> d_name ) ) { size_t index ; MEM_add_top ( heap_of_paths , & index ) ; <S2SV_StartBug> ERR_error result ; <S2SV_EndBug> UTI_concat ( MEM_get_item_m ( UTI_buff_stor , heap_of_paths , index ) . buff , 1 , entry -> d_name ) ; } } closedir ( directory ) ; return ERR_GOOD ; } return ERR_MISSING_FILE ; # endif # ifdef WIN ERR_ASSERT ( false , "UNIMPLMENTED<S2SV_blank>CODE!" ) # endif } | <S2SV_ModStart> index ) ; <S2SV_ModEnd> UTI_concat ( MEM_get_item_m |
157 | CWE-000 PetscErrorCode Update_Solution ( Vec current_state , PetscReal t , struct AppCtx * user ) { PetscErrorCode ierr = 0 ; PetscInt x , y , ion , comp ; PetscInt Nx = user -> Nx ; PetscInt Ny = user -> Ny ; PetscInt nx = 2 * width_size + 1 ; PetscInt ny = 2 * width_size + 1 ; PetscReal vm_new ; PetscReal threshhold = 0.1 ; for ( x = 0 ; x < Nx ; x ++ ) { for ( y = 0 ; y < Ny ; y ++ ) { vm_new = ( user -> state_vars -> phi [ phi_index ( x , y , 0 , Nx ) ] - user -> state_vars -> phi [ phi_index ( x , y , Nc - 1 , Nx ) ] ) * RTFC ; <S2SV_StartBug> if ( fabs ( vm_new - user -> vm_past [ xy_index ( x , y , Nx ) ] ) > threshhold ) { <S2SV_EndBug> Load_Grid ( user , x , y ) ; Update_Grid ( x , y , t , user ) ; Unload_Grid ( user , x , y ) ; } } } return ierr ; } | <S2SV_ModStart> ) > threshhold || user -> dt_space [ xy_index ( x , y , Nx ) ] < user -> dt |
158 | CWE-000 static void execute_until ( const gchar * file , int line ) { gchar command [ 1000 ] ; <S2SV_StartBug> sprintf ( command , "-exec-until<S2SV_blank>%s:%i" , file , line ) ; <S2SV_EndBug> exec_async_command ( command ) ; } | <S2SV_ModStart> 1000 ] ; g_snprintf ( command , sizeof <S2SV_ModEnd> command , "-exec-until<S2SV_blank>%s:%i" |
159 | CWE-000 static void avbox_player_doplay ( struct avbox_player * const inst , const char * const path ) { ASSERT ( inst != NULL ) ; if ( inst -> play_state != AVBOX_PLAYER_PLAYSTATE_READY && inst -> play_state != AVBOX_PLAYER_PLAYSTATE_PLAYING ) { avbox_player_throwexception ( inst , "Ignoring<S2SV_blank>play<S2SV_blank>command.<S2SV_blank>Current<S2SV_blank>state<S2SV_blank>not<S2SV_blank>valid<S2SV_blank>(%i)" , inst -> play_state ) ; return ; } if ( path == NULL ) { if ( inst -> status == MB_PLAYER_STATUS_PAUSED ) { avbox_player_doresume ( inst ) ; return ; } avbox_player_throwexception ( inst , "Playback<S2SV_blank>failed:<S2SV_blank>NULL<S2SV_blank>path!" ) ; return ; } if ( inst -> status != MB_PLAYER_STATUS_READY ) { inst -> next_file = strdup ( path ) ; if ( inst -> next_file == NULL ) { LOG_PRINT_ERROR ( "Could<S2SV_blank>not<S2SV_blank>copy<S2SV_blank>path:<S2SV_blank>Out<S2SV_blank>of<S2SV_blank>memory" ) ; } avbox_player_dostop ( inst ) ; return ; } inst -> stream_percent = 0 ; inst -> play_state = AVBOX_PLAYER_PLAYSTATE_STREAM ; avbox_player_updatestatus ( inst , MB_PLAYER_STATUS_BUFFERING ) ; <S2SV_StartBug> # ifdef ENABLE_DVD <S2SV_EndBug> if ( ! strncmp ( "dvd:" , path , 4 ) ) { if ( avbox_dvdio_open ( path + 4 , inst , & inst -> stream ) == NULL ) { LOG_VPRINT_ERROR ( "Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>DVD:<S2SV_blank>%s" , strerror ( errno ) ) ; ASSERT ( inst -> stream . self == NULL ) ; avbox_player_updatestatus ( inst , MB_PLAYER_STATUS_READY ) ; return ; } } <S2SV_StartBug> # endif <S2SV_EndBug> const char * old_media_file = inst -> media_file ; inst -> media_file = strdup ( path ) ; if ( old_media_file != NULL ) { free ( ( void * ) old_media_file ) ; } inst -> stream_quit = 0 ; ASSERT ( inst -> stream_input_worker == NULL ) ; ASSERT ( inst -> stream_input_thread != NULL ) ; if ( ( inst -> stream_input_worker = avbox_thread_delegate ( inst -> stream_input_thread , avbox_player_stream_parse , inst ) ) == NULL ) { LOG_VPRINT_ERROR ( "Could<S2SV_blank>not<S2SV_blank>start<S2SV_blank>input<S2SV_blank>thread:<S2SV_blank>%s" , strerror ( errno ) ) ; inst -> play_state = AVBOX_PLAYER_PLAYSTATE_READY ; avbox_player_updatestatus ( inst , MB_PLAYER_STATUS_READY ) ; } } | <S2SV_ModStart> MB_PLAYER_STATUS_BUFFERING ) ; struct avbox_player_openstream_args open_stream ; struct avbox_delegate * del ; open_stream . inst = inst ; open_stream . path = path ; if ( ( del = avbox_application_delegate ( avbox_player_openstream , & open_stream ) ) == NULL ) { avbox_player_throwexception ( inst , "Could<S2SV_blank>not<S2SV_blank>delegate<S2SV_blank>streamopen" ) ; return ; } else { void * ret ; avbox_delegate_wait ( del , & ret ) ; if ( ret == ( void * ) - 1 ) { <S2SV_ModEnd> avbox_player_updatestatus ( inst <S2SV_ModStart> ; } } <S2SV_ModEnd> const char * |
160 | CWE-000 bool KeyMan_VerifyKey ( const Key_t * key ) { <S2SV_StartBug> if ( key -> key_index >= KEY_TABLE_SIZE / sizeof ( KeyEntry ) ) <S2SV_EndBug> return false ; for ( int i = 0 ; i < KEY_LENGTH ; i ++ ) { <S2SV_StartBug> if ( key -> key [ i ] != keyTable [ key -> key_index ] . key . key [ i ] ) <S2SV_EndBug> return false ; } return true ; } | <S2SV_ModStart> key -> key_index == 0 ) return false ; if ( key -> key_index - 1 <S2SV_ModStart> key -> key_index - 1 |
161 | CWE-000 GdkPixbuf * gdk_pixbuf_new_from_stream_finish ( GAsyncResult * async_result , GError * * error ) { GTask * task ; <S2SV_StartBug> GdkPixbuf * result ; <S2SV_EndBug> g_return_val_if_fail ( g_task_is_valid ( async_result , NULL ) , NULL ) ; g_return_val_if_fail ( ! error || ( error && ! * error ) , NULL ) ; task = G_TASK ( async_result ) ; g_warn_if_fail ( g_task_get_source_tag ( task ) == gdk_pixbuf_new_from_stream_async || g_task_get_source_tag ( task ) == gdk_pixbuf_new_from_stream_at_scale_async ) ; <S2SV_StartBug> result = g_task_propagate_pointer ( task , error ) ; <S2SV_EndBug> <S2SV_StartBug> if ( result ) <S2SV_EndBug> g_object_ref ( result ) ; return result ; } | <S2SV_ModStart> * task ; g_return_val_if_fail ( G_IS_TASK ( async_result <S2SV_ModEnd> ) , NULL <S2SV_ModStart> gdk_pixbuf_new_from_stream_at_scale_async ) ; return <S2SV_ModEnd> g_task_propagate_pointer ( task <S2SV_ModStart> error ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
162 | CWE-000 void print_optim ( t_filler * moves ) { int rating ; int w ; int h ; rating = 10000000 ; h = moves -> h ; w = moves -> w ; while ( moves ) { <S2SV_StartBug> dprintf ( 2 , ">>>>>>>>>>>>>>>>>>>:rating:%d<S2SV_blank><S2SV_blank>coords(%d,<S2SV_blank>%d)\\n" , moves -> rating , moves -> w , moves -> h ) ; <S2SV_EndBug> if ( rating > moves -> rating ) { rating = moves -> rating ; w = moves -> w ; h = moves -> h ; } moves = moves -> next ; } ft_putnbr ( w ) ; ft_putchar ( '<S2SV_blank>' ) ; ft_putnbr ( h ) ; ft_putchar ( '\\n' ) ; } | <S2SV_ModStart> moves ) { <S2SV_ModEnd> if ( rating |
163 | CWE-000 static void gen_onoff_set_unack ( struct bt_mesh_model * model , struct bt_mesh_msg_ctx * ctx , struct net_buf_simple * buf ) { <S2SV_StartBug> onoff_set_unack ( model , ctx , buf ) ; <S2SV_EndBug> } | <S2SV_ModStart> buf ) { gen_onoff_setunack <S2SV_ModEnd> ( model , |
164 | CWE-000 int nfc_llcp_register_device ( struct nfc_dev * ndev ) { struct nfc_llcp_local * local ; local = kzalloc ( sizeof ( struct nfc_llcp_local ) , GFP_KERNEL ) ; if ( local == NULL ) return - ENOMEM ; local -> dev = ndev ; INIT_LIST_HEAD ( & local -> list ) ; kref_init ( & local -> ref ) ; mutex_init ( & local -> sdp_lock ) ; <S2SV_StartBug> setup_timer ( & local -> link_timer , nfc_llcp_symm_timer , <S2SV_EndBug> <S2SV_StartBug> ( unsigned long ) local ) ; <S2SV_EndBug> skb_queue_head_init ( & local -> tx_queue ) ; INIT_WORK ( & local -> tx_work , nfc_llcp_tx_work ) ; local -> rx_pending = NULL ; INIT_WORK ( & local -> rx_work , nfc_llcp_rx_work ) ; INIT_WORK ( & local -> timeout_work , nfc_llcp_timeout_work ) ; rwlock_init ( & local -> sockets . lock ) ; rwlock_init ( & local -> connecting_sockets . lock ) ; rwlock_init ( & local -> raw_sockets . lock ) ; local -> lto = 150 ; local -> rw = LLCP_MAX_RW ; local -> miux = cpu_to_be16 ( LLCP_MAX_MIUX ) ; local -> local_wks = 0x1 ; nfc_llcp_build_gb ( local ) ; local -> remote_miu = LLCP_DEFAULT_MIU ; local -> remote_lto = LLCP_DEFAULT_LTO ; mutex_init ( & local -> sdreq_lock ) ; INIT_HLIST_HEAD ( & local -> pending_sdreqs ) ; <S2SV_StartBug> setup_timer ( & local -> sdreq_timer , nfc_llcp_sdreq_timer , <S2SV_EndBug> <S2SV_StartBug> ( unsigned long ) local ) ; <S2SV_EndBug> INIT_WORK ( & local -> sdreq_timeout_work , nfc_llcp_sdreq_timeout_work ) ; list_add ( & local -> list , & llcp_devices ) ; return 0 ; } | <S2SV_ModStart> sdp_lock ) ; timer_setup <S2SV_ModEnd> ( & local <S2SV_ModStart> , nfc_llcp_symm_timer , 0 <S2SV_ModEnd> ) ; skb_queue_head_init <S2SV_ModStart> pending_sdreqs ) ; timer_setup <S2SV_ModEnd> ( & local <S2SV_ModStart> , nfc_llcp_sdreq_timer , 0 <S2SV_ModEnd> ) ; INIT_WORK |
165 | CWE-000 static void mlp_mask_privacy ( struct context * cnt ) { if ( cnt -> imgs . mask_privacy == NULL ) return ; int pixels = cnt -> imgs . height * cnt -> imgs . width ; unsigned char * image = cnt -> current_image -> image ; const unsigned char * mask = cnt -> imgs . mask_privacy ; int index = pixels ; <S2SV_StartBug> while ( index >= sizeof ( unsigned long ) ) { <S2SV_EndBug> * ( ( unsigned long * ) image ) &= * ( ( unsigned long * ) mask ) ; <S2SV_StartBug> image += sizeof ( unsigned long ) ; <S2SV_EndBug> mask += sizeof ( unsigned long ) ; <S2SV_StartBug> index -= sizeof ( unsigned long ) ; <S2SV_EndBug> } while ( -- index >= 0 ) { * ( image ++ ) &= * ( mask ++ ) ; } index = cnt -> imgs . size - pixels ; const unsigned char * maskuv = cnt -> imgs . mask_privacy_uv ; <S2SV_StartBug> while ( index >= sizeof ( unsigned long ) ) { <S2SV_EndBug> <S2SV_StartBug> index -= sizeof ( unsigned long ) ; <S2SV_EndBug> * ( ( unsigned long * ) image ) &= * ( ( unsigned long * ) mask ) ; <S2SV_StartBug> mask += sizeof ( unsigned long ) ; <S2SV_EndBug> * ( ( unsigned long * ) image ) |= * ( ( unsigned long * ) maskuv ) ; <S2SV_StartBug> maskuv += sizeof ( unsigned long ) ; <S2SV_EndBug> image += sizeof ( unsigned long ) ; } while ( -- index >= 0 ) { if ( * ( mask ++ ) == 0x00 ) * image = 0x80 ; image += 1 ; } } | <S2SV_ModStart> = pixels ; int increment = <S2SV_ModEnd> sizeof ( unsigned <S2SV_ModStart> unsigned long ) ; while ( index >= increment <S2SV_ModStart> ; image += increment ; mask += increment <S2SV_ModEnd> ; index -= <S2SV_ModStart> ; index -= increment <S2SV_ModEnd> ; } while <S2SV_ModStart> ( index >= increment <S2SV_ModEnd> ) { index <S2SV_ModStart> { index -= increment <S2SV_ModEnd> ; * ( <S2SV_ModStart> ; mask += increment <S2SV_ModEnd> ; * ( <S2SV_ModStart> ; maskuv += increment ; image += increment <S2SV_ModEnd> ; } while |
166 | CWE-000 void main_while ( t_all * all ) { int x ; int y ; t_vertex vec1 ; int inter ; t_rgb color ; y = all -> dsp . rend_hs ; while ( y < all -> dsp . rend_he ) { x = all -> dsp . rend_ws ; while ( x < all -> dsp . rend_we ) { all -> rt . rgb = ( t_rgb ) { 0 , 0 , 0 , 0 } ; inter = ft_primary_ray ( all , x , y ) ; color = all -> rt . rgb ; if ( inter == TRUE ) { vec1 = ft_sub_vector ( all -> light , all -> rt . inter ) ; vec1 = ft_normalized_vector ( vec1 ) ; <S2SV_StartBug> if ( x == 0 && y == - 15 ) <S2SV_EndBug> printf ( "x:<S2SV_blank>%f\\ny:<S2SV_blank>%f\\nz:<S2SV_blank>%f\\n" , all -> rt . norm . x , all -> rt . norm . y , all -> rt . norm . z ) ; <S2SV_StartBug> if ( x == - 300 && y == - 15 ) <S2SV_EndBug> printf ( "+x:<S2SV_blank>%f\\n+y:<S2SV_blank>%f\\n+z:<S2SV_blank>%f\\n" , all -> rt . norm . x , all -> rt . norm . y , all -> rt . norm . z ) ; <S2SV_StartBug> if ( x == 300 && y == - 15 ) <S2SV_EndBug> printf ( "-x:<S2SV_blank>%f\\n-y:<S2SV_blank>%f\\n-z:<S2SV_blank>%f\\n" , all -> rt . norm . x , all -> rt . norm . y , all -> rt . norm . z ) ; all -> rt . brightness = ft_dot_product ( vec1 , all -> rt . norm ) ; if ( all -> rt . brightness < 0 ) all -> rt . brightness = 0 ; if ( x == - 1 && y == 84 ) printf ( "br1:<S2SV_blank>%f\\n" , all -> rt . brightness ) ; if ( x == - 283 && y == 85 ) printf ( "br2:<S2SV_blank>%f\\n" , all -> rt . brightness ) ; color = ( t_rgb ) { ( unsigned char ) ( color . r * all -> rt . brightness ) , ( unsigned char ) ( color . g * all -> rt . brightness ) , ( unsigned char ) ( color . b * all -> rt . brightness ) , 0 } ; } if ( inter == TRUE ) if ( ft_shadow_ray ( all ) ) color = ( t_rgb ) { ( unsigned char ) ( color . r * 0.30 ) , ( unsigned char ) ( color . g * 0.30 ) , ( unsigned char ) ( color . b * 0.30 ) , 0 } ; ft_put_color ( all , x + all -> dsp . half_w , y + all -> dsp . half_h , color ) ; x ++ ; } y ++ ; } } | <S2SV_ModStart> ( x == 360 <S2SV_ModEnd> && y == <S2SV_ModStart> && y == 190 <S2SV_ModEnd> ) printf ( <S2SV_ModStart> ( x == <S2SV_ModEnd> 300 && y <S2SV_ModStart> && y == 190 <S2SV_ModEnd> ) printf ( <S2SV_ModStart> ( x == 240 <S2SV_ModEnd> && y == <S2SV_ModStart> && y == 190 <S2SV_ModEnd> ) printf ( |
167 | CWE-000 static int lz4_uncompress ( const char * source , char * dest , int osize ) { const BYTE * ip = ( const BYTE * ) source ; const BYTE * ref ; BYTE * op = ( BYTE * ) dest ; BYTE * const oend = op + osize ; BYTE * cpy ; unsigned token ; size_t length ; size_t dec32table [ ] = { 0 , 3 , 2 , 3 , 0 , 0 , 0 , 0 } ; # if LZ4_ARCH64 size_t dec64table [ ] = { 0 , 0 , 0 , - 1 , 0 , 1 , 2 , 3 } ; # endif while ( 1 ) { token = * ip ++ ; length = ( token >> ML_BITS ) ; if ( length == RUN_MASK ) { size_t len ; len = * ip ++ ; for ( ; len == 255 ; length += 255 ) len = * ip ++ ; if ( unlikely ( length > ( size_t ) ( length + len ) ) ) goto _output_error ; length += len ; } cpy = op + length ; if ( unlikely ( cpy > oend - COPYLENGTH ) ) { if ( cpy != oend ) goto _output_error ; memcpy ( op , ip , length ) ; ip += length ; break ; } LZ4_WILDCOPY ( ip , op , cpy ) ; ip -= ( op - cpy ) ; op = cpy ; LZ4_READ_LITTLEENDIAN_16 ( ref , cpy , ip ) ; ip += 2 ; if ( unlikely ( ref < ( BYTE * const ) dest ) ) goto _output_error ; length = token & ML_MASK ; if ( length == ML_MASK ) { for ( ; * ip == 255 ; length += 255 ) ip ++ ; if ( unlikely ( length > ( size_t ) ( length + * ip ) ) ) goto _output_error ; length += * ip ++ ; } if ( unlikely ( ( op - ref ) < STEPSIZE ) ) { # if LZ4_ARCH64 size_t dec64 = dec64table [ op - ref ] ; # else const int dec64 = 0 ; # endif op [ 0 ] = ref [ 0 ] ; op [ 1 ] = ref [ 1 ] ; op [ 2 ] = ref [ 2 ] ; op [ 3 ] = ref [ 3 ] ; op += 4 ; ref += 4 ; ref -= dec32table [ op - ref ] ; PUT4 ( ref , op ) ; op += STEPSIZE - 4 ; ref -= dec64 ; } else { LZ4_COPYSTEP ( ref , op ) ; } cpy = op + length - ( STEPSIZE - 4 ) ; if ( cpy > ( oend - COPYLENGTH ) ) { if ( cpy > oend ) goto _output_error ; <S2SV_StartBug> LZ4_SECURECOPY ( ref , op , ( oend - COPYLENGTH ) ) ; <S2SV_EndBug> while ( op < cpy ) * op ++ = * ref ++ ; op = cpy ; if ( op == oend ) goto _output_error ; <S2SV_StartBug> continue ; <S2SV_EndBug> } LZ4_SECURECOPY ( ref , op , cpy ) ; op = cpy ; } return ( int ) ( ( ( char * ) ip ) - source ) ; _output_error : return - 1 ; } | <S2SV_ModStart> goto _output_error ; # if LZ4_ARCH64 if ( ( ref + COPYLENGTH ) > oend ) # else if ( ( ref + COPYLENGTH ) > oend || ( op + COPYLENGTH ) > oend ) # endif <S2SV_ModEnd> goto _output_error ; <S2SV_ModStart> goto _output_error ; LZ4_SECURECOPY ( ref , op , ( oend - COPYLENGTH ) ) ; while ( op < cpy ) * op ++ = * ref ++ ; op = cpy ; if ( op == oend ) goto _output_error ; |
168 | CWE-000 static svn_error_t * configure_option_incoming_dir_merge ( svn_client_conflict_t * conflict , svn_client_ctx_t * ctx , apr_array_header_t * options , apr_pool_t * scratch_pool ) { svn_node_kind_t victim_node_kind ; svn_wc_conflict_action_t incoming_change ; const char * incoming_old_repos_relpath ; svn_revnum_t incoming_old_pegrev ; svn_node_kind_t incoming_old_kind ; const char * incoming_new_repos_relpath ; svn_revnum_t incoming_new_pegrev ; svn_node_kind_t incoming_new_kind ; struct conflict_tree_incoming_delete_details * details ; svn_wc_operation_t operation ; details = conflict -> tree_conflict_incoming_details ; if ( details == NULL || details -> moves == NULL ) return SVN_NO_ERROR ; operation = svn_client_conflict_get_operation ( conflict ) ; incoming_change = svn_client_conflict_get_incoming_change ( conflict ) ; victim_node_kind = svn_client_conflict_tree_get_victim_node_kind ( conflict ) ; SVN_ERR ( svn_client_conflict_get_incoming_old_repos_location ( & incoming_old_repos_relpath , & incoming_old_pegrev , & incoming_old_kind , conflict , scratch_pool , scratch_pool ) ) ; SVN_ERR ( svn_client_conflict_get_incoming_new_repos_location ( & incoming_new_repos_relpath , & incoming_new_pegrev , & incoming_new_kind , conflict , scratch_pool , scratch_pool ) ) ; if ( victim_node_kind == svn_node_dir && incoming_old_kind == svn_node_dir && incoming_new_kind == svn_node_none && incoming_change == svn_wc_conflict_action_delete ) { const char * description ; const char * wcroot_abspath ; const char * victim_abspath ; <S2SV_StartBug> apr_array_header_t * move_target_repos_relpaths ; <S2SV_EndBug> victim_abspath = svn_client_conflict_get_local_abspath ( conflict ) ; SVN_ERR ( svn_wc__get_wcroot ( & wcroot_abspath , ctx -> wc_ctx , victim_abspath , scratch_pool , scratch_pool ) ) ; if ( details -> wc_move_targets == NULL ) { int i ; details -> wc_move_targets = apr_hash_make ( conflict -> pool ) ; for ( i = 0 ; i < details -> moves -> nelts ; i ++ ) { struct repos_move_info * move ; move = APR_ARRAY_IDX ( details -> moves , i , struct repos_move_info * ) ; SVN_ERR ( follow_move_chains ( details -> wc_move_targets , move , ctx , victim_abspath , victim_node_kind , incoming_new_pegrev , conflict -> pool , scratch_pool ) ) ; } <S2SV_StartBug> if ( apr_hash_count ( details -> wc_move_targets ) > 0 ) <S2SV_EndBug> { svn_sort__item_t item ; move_target_repos_relpaths = svn_sort__hash ( details -> wc_move_targets , svn_sort_compare_items_as_paths , scratch_pool ) ; item = APR_ARRAY_IDX ( move_target_repos_relpaths , 0 , svn_sort__item_t ) ; details -> move_target_repos_relpath = item . key ; details -> wc_move_target_idx = 0 ; } else { details -> move_target_repos_relpath = NULL ; details -> wc_move_target_idx = 0 ; return SVN_NO_ERROR ; <S2SV_StartBug> } <S2SV_EndBug> } if ( apr_hash_count ( details -> wc_move_targets ) == 0 ) return SVN_NO_ERROR ; <S2SV_StartBug> SVN_ERR ( describe_incoming_move_merge_conflict_option ( & description , <S2SV_EndBug> conflict , ctx , details , scratch_pool , scratch_pool ) ) ; add_resolution_option ( options , conflict , svn_client_conflict_option_incoming_move_dir_merge , _ ( "Move<S2SV_blank>and<S2SV_blank>merge" ) , description , resolve_incoming_move_dir_merge ) ; } return SVN_NO_ERROR ; } | <S2SV_ModStart> * victim_abspath ; <S2SV_ModEnd> victim_abspath = svn_client_conflict_get_local_abspath <S2SV_ModStart> ) ; } details -> move_target_repos_relpath = select_default_move_target_abspath ( details , scratch_pool ) ; details -> wc_move_target_idx = 0 ; } <S2SV_ModStart> -> wc_move_targets ) == 0 ) <S2SV_ModEnd> return SVN_NO_ERROR ; <S2SV_ModStart> return SVN_NO_ERROR ; SVN_ERR ( describe_incoming_move_merge_conflict_option ( & description , conflict , ctx , details , scratch_pool , scratch_pool ) ) ; add_resolution_option ( options , conflict , svn_client_conflict_option_incoming_move_dir_merge , _ ( "Move<S2SV_blank>and<S2SV_blank>merge" ) , description , resolve_incoming_move_dir_merge ) ; } <S2SV_ModEnd> return SVN_NO_ERROR ; <S2SV_ModStart> return SVN_NO_ERROR ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
169 | CWE-000 int get_node_info ( ) { nodecount = 0 ; <S2SV_StartBug> command_status ++ ; <S2SV_EndBug> <S2SV_StartBug> outbuf [ 0 ] = COMMAND_GETNODEINFO ; <S2SV_EndBug> outbuf [ 1 ] = COMMAND_ACTION_EXESTART ; * ( short * ) ( outbuf + 2 ) = 4 ; send ( ser , outbuf , 4 , 0 ) ; sprintf ( outbuf + 4 , "ID" ) ; outbuf [ 0 ] = COMMAND_GETNODEINFO ; outbuf [ 1 ] = COMMAND_ACTION_EXEINPUT ; * ( short * ) ( outbuf + 2 ) = strlen ( outbuf + 4 ) + 4 + 1 ; send ( ser , outbuf , * ( short * ) ( outbuf + 2 ) , 0 ) ; outbuf [ 0 ] = COMMAND_GETNODEINFO ; outbuf [ 1 ] = COMMAND_ACTION_EXESTOP ; * ( short * ) ( outbuf + 2 ) = 4 ; send ( ser , outbuf , 4 , 0 ) ; while ( command_status > 0 ) { usleep ( 1000 ) ; } return 1 ; } | <S2SV_ModStart> = 0 ; pthread_mutex_lock ( & mutex ) ; <S2SV_ModStart> command_status ++ ; pthread_mutex_unlock ( & mutex ) ; |
170 | CWE-000 void GPIO_Configuration ( void ) { <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> void ) { GPIO_PinRemapConfig ( GPIO_Remap_SWJ_Disable , ENABLE ) ; |
171 | CWE-000 int posix_create_link_if_gfid_exists ( xlator_t * this , uuid_t gfid , char * real_path , inode_table_t * itable ) { int ret = - 1 ; char * newpath = NULL ; char * unlink_path = NULL ; uint64_t ctx_int = 0 ; inode_t * inode = NULL ; struct stat stbuf = { 0 , } ; struct posix_private * priv = NULL ; priv = this -> private ; MAKE_HANDLE_PATH ( newpath , this , gfid , NULL ) ; if ( ! newpath ) { gf_msg ( this -> name , GF_LOG_WARNING , 0 , P_MSG_HANDLE_CREATE , "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>handle<S2SV_blank>path<S2SV_blank>(%s)" , uuid_utoa ( gfid ) ) ; return ret ; } ret = lstat ( newpath , & stbuf ) ; if ( ! ret ) { ret = sys_link ( newpath , real_path ) ; } else { inode = inode_find ( itable , gfid ) ; if ( ! inode ) return - 1 ; LOCK ( & inode -> lock ) ; { ret = __inode_ctx_get0 ( inode , this , & ctx_int ) ; if ( ret ) goto unlock ; if ( ctx_int != GF_UNLINK_TRUE ) goto unlock ; POSIX_GET_FILE_UNLINK_PATH ( priv -> base_path , gfid , unlink_path ) ; ret = sys_link ( unlink_path , real_path ) ; if ( ret ) { gf_msg ( this -> name , GF_LOG_WARNING , errno , P_MSG_HANDLE_CREATE , "Failed<S2SV_blank>to<S2SV_blank>link<S2SV_blank>" "%s<S2SV_blank>with<S2SV_blank>%s" , real_path , unlink_path ) ; goto unlock ; } ret = sys_rename ( unlink_path , newpath ) ; if ( ret ) { gf_msg ( this -> name , GF_LOG_WARNING , errno , P_MSG_HANDLE_CREATE , "Failed<S2SV_blank>to<S2SV_blank>link<S2SV_blank>" "%s<S2SV_blank>with<S2SV_blank>%s" , real_path , unlink_path ) ; goto unlock ; } ctx_int = GF_UNLINK_FALSE ; ret = __inode_ctx_set0 ( inode , this , & ctx_int ) ; } unlock : UNLOCK ( & inode -> lock ) ; <S2SV_StartBug> } <S2SV_EndBug> return ret ; } | <S2SV_ModStart> lock ) ; inode_unref ( inode ) ; |
172 | CWE-000 static sample_t * rs_loop ( MidiSong * song , Voice * vp , Sint32 count ) { sample_t v1 , v2 ; Sint32 ofs = vp -> sample_offset , incr = vp -> sample_increment , le = vp -> sample -> loop_end , ll = le - vp -> sample -> loop_start ; sample_t * dest = song -> resample_buffer , * src = vp -> sample -> data ; Sint32 i ; while ( count ) { <S2SV_StartBug> if ( ofs >= le ) <S2SV_EndBug> ofs -= ll ; i = ( le - ofs ) / incr + 1 ; if ( i > count ) { i = count ; count = 0 ; } else count -= i ; while ( i -- ) { v1 = src [ ofs >> FRACTION_BITS ] ; v2 = src [ ( ofs >> FRACTION_BITS ) + 1 ] ; * dest ++ = v1 + ( ( ( v2 - v1 ) * ( ofs & FRACTION_MASK ) ) >> FRACTION_BITS ) ; ofs += incr ; } } vp -> sample_offset = ofs ; return song -> resample_buffer ; } | <S2SV_ModStart> count ) { while <S2SV_ModEnd> ( ofs >= |
173 | CWE-000 int main ( ) { int s = socket ( AF_INET , SOCK_DGRAM , 0 ) ; if ( s < 0 ) { return 0 ; } struct sockaddr_in myaddr ; myaddr . sin_family = AF_INET ; myaddr . sin_addr . s_addr = htonl ( INADDR_ANY ) ; myaddr . sin_port = htons ( PORT ) ; int bindStatus = bind ( s , ( struct sockaddr * ) & myaddr , sizeof ( myaddr ) ) ; if ( bindStatus < 0 ) { return 0 ; } struct sockaddr_in remaddr ; unsigned char buf [ REC_SIZE ] ; socklen_t addrlen = sizeof ( remaddr ) ; ws2811_t ledString = setupLEDStrip ( ) ; unsigned char currentBuf [ REC_SIZE ] ; for ( int i = 0 ; i < REC_SIZE ; ++ i ) { currentBuf [ i ] = 0x0 ; } unsigned char targetBuf [ REC_SIZE ] ; for ( int i = 0 ; i < REC_SIZE ; ++ i ) { targetBuf [ i ] = 0x0 ; } clock_t lastTime = clock ( ) ; const float P_CONST = 0.25f ; for ( ; ; ) { int recvlen = recvfrom ( s , buf , REC_SIZE , MSG_DONTWAIT , ( struct sockaddr * ) & remaddr , & addrlen ) ; if ( recvlen > 0 ) { for ( int i = 0 ; i < recvlen ; ++ i ) { targetBuf [ i ] = buf [ i ] ; } } clock_t currentTime = clock ( ) ; float diff = ( ( float ) ( currentTime - lastTime ) / ( float ) CLOCKS_PER_SEC ) * 1000.0 ; if ( diff < ( 1.0f / 60.0f ) * 1000.0f ) { continue ; } lastTime = currentTime ; for ( int i = 0 ; i < REC_SIZE ; i += COLOR_COUNT ) { float red_t = ( float ) targetBuf [ i ] ; float green_t = ( float ) targetBuf [ i + 1 ] ; float blue_t = ( float ) targetBuf [ i + 2 ] ; float red_c = ( float ) currentBuf [ i ] ; float green_c = ( float ) currentBuf [ i + 1 ] ; float blue_c = ( float ) currentBuf [ i + 2 ] ; float red_pid = ( red_t - red_c ) * P_CONST ; float green_pid = ( green_t - green_c ) * P_CONST ; float blue_pid = ( blue_t - blue_c ) * P_CONST ; uint8_t red = ( uint8_t ) ( red_c + red_pid ) ; uint8_t green = ( uint8_t ) ( green_c + green_pid ) ; uint8_t blue = ( uint8_t ) ( blue_c + blue_pid ) ; uint32_t color = ( 0 << 24 ) | ( red << 16 ) | ( green << 8 ) | blue ; size_t index = i / 3 ; ledString . channel [ 0 ] . leds [ index ] = color ; ledString . channel [ 0 ] . leds [ LED_COUNT - 1 - index ] = color ; currentBuf [ i ] = red ; currentBuf [ i + 1 ] = green ; currentBuf [ i + 2 ] = blue ; } <S2SV_StartBug> ret = ws2811_render ( & ledString ) ; <S2SV_EndBug> if ( ret != WS2811_SUCCESS ) { } } return 0 ; } | <S2SV_ModStart> blue ; } ws2811_return_t |
174 | CWE-000 List * transformCreateStmt ( CreateStmt * stmt , const char * queryString ) { ParseState * pstate ; CreateStmtContext cxt ; List * result ; List * save_alist ; ListCell * elements ; Oid namespaceid ; Oid existing_relid ; ParseCallbackState pcbstate ; bool like_found = false ; stmt = ( CreateStmt * ) copyObject ( stmt ) ; pstate = make_parsestate ( NULL ) ; pstate -> p_sourcetext = queryString ; setup_parser_errposition_callback ( & pcbstate , pstate , stmt -> relation -> location ) ; namespaceid = RangeVarGetAndCheckCreationNamespace ( stmt -> relation , NoLock , & existing_relid ) ; cancel_parser_errposition_callback ( & pcbstate ) ; if ( stmt -> if_not_exists && OidIsValid ( existing_relid ) ) { ereport ( NOTICE , ( errcode ( ERRCODE_DUPLICATE_TABLE ) , errmsg ( "relation<S2SV_blank>\\"%s\\"<S2SV_blank>already<S2SV_blank>exists,<S2SV_blank>skipping" , stmt -> relation -> relname ) ) ) ; return NIL ; } if ( stmt -> relation -> schemaname == NULL && stmt -> relation -> relpersistence != RELPERSISTENCE_TEMP ) stmt -> relation -> schemaname = get_namespace_name ( namespaceid ) ; cxt . pstate = pstate ; if ( IsA ( stmt , CreateForeignTableStmt ) ) { cxt . stmtType = "CREATE<S2SV_blank>FOREIGN<S2SV_blank>TABLE" ; cxt . isforeign = true ; } else { cxt . stmtType = "CREATE<S2SV_blank>TABLE" ; cxt . isforeign = false ; } cxt . relation = stmt -> relation ; cxt . rel = NULL ; cxt . inhRelations = stmt -> inhRelations ; cxt . isalter = false ; cxt . columns = NIL ; cxt . ckconstraints = NIL ; cxt . fkconstraints = NIL ; cxt . ixconstraints = NIL ; cxt . inh_indexes = NIL ; cxt . blist = NIL ; cxt . alist = NIL ; cxt . pkey = NULL ; cxt . ispartitioned = stmt -> partspec != NULL ; cxt . hasoids = interpretOidsOption ( stmt -> options , ! cxt . isforeign ) ; Assert ( ! stmt -> ofTypename || ! stmt -> inhRelations ) ; if ( stmt -> ofTypename ) transformOfType ( & cxt , stmt -> ofTypename ) ; if ( stmt -> partspec ) { int partnatts = list_length ( stmt -> partspec -> partParams ) ; if ( stmt -> inhRelations && ! stmt -> partbound ) ereport ( ERROR , ( errcode ( ERRCODE_INVALID_OBJECT_DEFINITION ) , errmsg ( "cannot<S2SV_blank>create<S2SV_blank>partitioned<S2SV_blank>table<S2SV_blank>as<S2SV_blank>inheritance<S2SV_blank>child" ) ) ) ; if ( partnatts > PARTITION_MAX_KEYS ) ereport ( ERROR , ( errcode ( ERRCODE_TOO_MANY_COLUMNS ) , errmsg ( "cannot<S2SV_blank>partition<S2SV_blank>using<S2SV_blank>more<S2SV_blank>than<S2SV_blank>%d<S2SV_blank>columns" , PARTITION_MAX_KEYS ) ) ) ; if ( ! pg_strcasecmp ( stmt -> partspec -> strategy , "list" ) && partnatts > 1 ) ereport ( ERROR , ( errcode ( ERRCODE_INVALID_OBJECT_DEFINITION ) , errmsg ( "cannot<S2SV_blank>list<S2SV_blank>partition<S2SV_blank>using<S2SV_blank>more<S2SV_blank>than<S2SV_blank>one<S2SV_blank>column" ) ) ) ; } foreach ( elements , stmt -> tableElts ) { Node * element = lfirst ( elements ) ; switch ( nodeTag ( element ) ) { case T_ColumnDef : transformColumnDefinition ( & cxt , ( ColumnDef * ) element ) ; break ; <S2SV_StartBug> case T_TableLikeClause : <S2SV_EndBug> if ( ! like_found ) { cxt . hasoids = false ; like_found = true ; <S2SV_StartBug> } <S2SV_EndBug> transformTableLikeClause ( & cxt , ( TableLikeClause * ) element ) ; <S2SV_StartBug> break ; <S2SV_EndBug> case T_Constraint : break ; default : elog ( ERROR , "unrecognized<S2SV_blank>node<S2SV_blank>type:<S2SV_blank>%d" , ( int ) nodeTag ( element ) ) ; break ; } } <S2SV_StartBug> if ( like_found ) <S2SV_EndBug> { stmt -> options = lcons ( makeDefElem ( "oids" , <S2SV_StartBug> ( Node * ) makeInteger ( cxt . hasoids ) , - 1 ) , <S2SV_EndBug> stmt -> options ) ; <S2SV_StartBug> } <S2SV_EndBug> foreach ( elements , stmt -> tableElts ) { Node * element = lfirst ( elements ) ; if ( nodeTag ( element ) == T_Constraint ) transformTableConstraint ( & cxt , ( Constraint * ) element ) ; } save_alist = cxt . alist ; cxt . alist = NIL ; Assert ( stmt -> constraints == NIL ) ; transformIndexConstraints ( & cxt ) ; transformFKConstraints ( & cxt , true , false ) ; transformCheckConstraints ( & cxt , true ) ; stmt -> tableElts = cxt . columns ; stmt -> constraints = cxt . ckconstraints ; result = lappend ( cxt . blist , stmt ) ; result = list_concat ( result , cxt . alist ) ; result = list_concat ( result , save_alist ) ; return result ; } | <S2SV_ModStart> break ; case T_Constraint : transformTableConstraint ( & cxt , ( Constraint * ) element ) ; break ; case T_TableLikeClause : like_found <S2SV_ModEnd> = true ; <S2SV_ModStart> = true ; <S2SV_ModEnd> transformTableLikeClause ( & <S2SV_ModStart> element ) ; <S2SV_ModEnd> break ; default <S2SV_ModStart> if ( like_found && cxt . hasoids ) <S2SV_ModEnd> stmt -> options <S2SV_ModStart> ) makeInteger ( true <S2SV_ModEnd> ) , - <S2SV_ModStart> options ) ; <S2SV_ModEnd> save_alist = cxt |
175 | CWE-000 void printk ( char * text ) { <S2SV_StartBug> int i ; <S2SV_EndBug> for ( i = 0 ; i < strlen ( text ) ; i ++ ) { putch ( text [ i ] ) ; } } | <S2SV_ModStart> text ) { unsigned |
176 | CWE-000 int main ( ) { srand ( 0 ) ; spec = true ; beginspec ( ) ; for ( int i = 0 ; i < NUM_CHILDREN ; i ++ ) { pid_t pid = fork ( ) ; if ( pid == 0 ) { child ( i ) ; } else if ( pid == - 1 ) { perror ( "Unable<S2SV_blank>to<S2SV_blank>fork<S2SV_blank>process" ) ; exit ( - 1 ) ; } } int status ; while ( wait ( & status ) == 0 ) { if ( errno != ECHILD ) { <S2SV_StartBug> exit ( - 1 ) ; <S2SV_EndBug> } assert ( WIFEXITED ( status ) ) ; assert ( WEXITSTATUS ( status ) == 0 ) ; } endspec ( ) ; spec = false ; printf ( "Large<S2SV_blank>spec<S2SV_blank>allocation<S2SV_blank>test<S2SV_blank>passed!\\n" ) ; print_noomr_stats ( ) ; } | <S2SV_ModStart> ECHILD ) { noomr_perror ( "Unexpected<S2SV_blank>error" ) ; |
177 | CWE-000 static int hi8435_probe ( struct spi_device * spi ) { struct iio_dev * idev ; struct hi8435_priv * priv ; struct gpio_desc * reset_gpio ; int ret ; idev = devm_iio_device_alloc ( & spi -> dev , sizeof ( * priv ) ) ; if ( ! idev ) return - ENOMEM ; priv = iio_priv ( idev ) ; priv -> spi = spi ; reset_gpio = devm_gpiod_get ( & spi -> dev , NULL , GPIOD_OUT_LOW ) ; <S2SV_StartBug> if ( IS_ERR ( reset_gpio ) ) { <S2SV_EndBug> <S2SV_StartBug> hi8435_writeb ( priv , HI8435_CTRL_REG , HI8435_CTRL_SRST ) ; <S2SV_EndBug> hi8435_writeb ( priv , HI8435_CTRL_REG , 0 ) ; } else { <S2SV_StartBug> udelay ( 5 ) ; <S2SV_EndBug> gpiod_set_value ( reset_gpio , 1 ) ; } spi_set_drvdata ( spi , idev ) ; mutex_init ( & priv -> lock ) ; idev -> dev . parent = & spi -> dev ; idev -> dev . of_node = spi -> dev . of_node ; idev -> name = spi_get_device_id ( spi ) -> name ; idev -> modes = INDIO_DIRECT_MODE ; idev -> info = & hi8435_info ; idev -> channels = hi8435_channels ; idev -> num_channels = ARRAY_SIZE ( hi8435_channels ) ; priv -> event_scan_mask = ~ ( 0 ) ; priv -> threshold_lo [ 0 ] = priv -> threshold_lo [ 1 ] = 2 ; priv -> threshold_hi [ 0 ] = priv -> threshold_hi [ 1 ] = 4 ; hi8435_writew ( priv , HI8435_GOCENHYS_REG , 0x206 ) ; hi8435_writew ( priv , HI8435_SOCENHYS_REG , 0x206 ) ; ret = iio_triggered_event_setup ( idev , NULL , hi8435_trigger_handler ) ; if ( ret ) return ret ; ret = iio_device_register ( idev ) ; if ( ret < 0 ) { dev_err ( & spi -> dev , "unable<S2SV_blank>to<S2SV_blank>register<S2SV_blank>device\\n" ) ; goto unregister_triggered_event ; } return 0 ; unregister_triggered_event : iio_triggered_event_cleanup ( idev ) ; return ret ; } | <S2SV_ModStart> ; if ( ! <S2SV_ModStart> ) ) { gpiod_set_raw_value_cansleep ( reset_gpio , 0 ) ; udelay ( 1 ) ; gpiod_set_raw_value_cansleep ( reset_gpio , 1 <S2SV_ModEnd> ) ; } <S2SV_ModStart> } else { hi8435_writeb ( priv , HI8435_CTRL_REG , HI8435_CTRL_SRST ) ; hi8435_writeb ( priv , HI8435_CTRL_REG , 0 <S2SV_ModEnd> ) ; } |
178 | CWE-000 rstatus_t dnode_peer_req_forward ( struct context * ctx , struct conn * c_conn , struct conn * p_conn , struct msg * req , struct rack * rack , uint8_t * key , uint32_t keylen , dyn_error_t * dyn_error_code ) { struct node * server = p_conn -> owner ; log_info ( "%M<S2SV_blank>FORWARD<S2SV_blank>%M<S2SV_blank>to<S2SV_blank>peer<S2SV_blank>%M<S2SV_blank>on<S2SV_blank>rack<S2SV_blank>\'%.*s\'<S2SV_blank>dc<S2SV_blank>\'%.*s\'<S2SV_blank>" , c_conn , req , p_conn , rack -> name -> len , rack -> name -> data , server -> dc . len , server -> dc . data ) ; struct string * dc = rack -> dc ; rstatus_t status ; ASSERT ( p_conn -> type == CONN_DNODE_PEER_SERVER ) ; ASSERT ( ( c_conn -> type == CONN_CLIENT ) || ( c_conn -> type == CONN_DNODE_PEER_CLIENT ) ) ; status = conn_event_add_out ( p_conn ) ; if ( status != DN_OK ) { * dyn_error_code = DYNOMITE_UNKNOWN_ERROR ; p_conn -> err = errno ; return DN_ERROR ; } struct mbuf * header_buf = mbuf_get ( ) ; if ( header_buf == NULL ) { loga ( "Unable<S2SV_blank>to<S2SV_blank>obtain<S2SV_blank>an<S2SV_blank>mbuf<S2SV_blank>for<S2SV_blank>dnode<S2SV_blank>msg\'s<S2SV_blank>header!" ) ; * dyn_error_code = DYNOMITE_OK ; return DN_ENOMEM ; } struct server_pool * pool = c_conn -> owner ; dmsg_type_t msg_type = ( string_compare ( & pool -> dc , dc ) != 0 ) ? DMSG_REQ_FORWARD : DMSG_REQ ; if ( p_conn -> dnode_secured ) { if ( log_loggable ( LOG_VVERB ) ) { SCOPED_CHARPTR ( encoded_aes_key ) = base64_encode ( p_conn -> aes_key , AES_KEYLEN ) ; if ( encoded_aes_key ) log_debug ( LOG_VVERB , "AES<S2SV_blank>encryption<S2SV_blank>key:<S2SV_blank>%s\\n" , encoded_aes_key ) ; } if ( ENCRYPTION ) { status = dyn_aes_encrypt_msg ( req , p_conn -> aes_key ) ; if ( status == DN_ERROR ) { loga ( "OOM<S2SV_blank>to<S2SV_blank>obtain<S2SV_blank>an<S2SV_blank>mbuf<S2SV_blank>for<S2SV_blank>encryption!" ) ; mbuf_put ( header_buf ) ; * dyn_error_code = DN_ENOMEM ; return status ; } log_debug ( LOG_VVERB , "#encrypted<S2SV_blank>bytes<S2SV_blank>:<S2SV_blank>%d" , status ) ; dmsg_write ( header_buf , req -> id , msg_type , p_conn , msg_length ( req ) ) ; } else { log_debug ( LOG_VVERB , "no<S2SV_blank>encryption<S2SV_blank>on<S2SV_blank>the<S2SV_blank>msg<S2SV_blank>payload" ) ; dmsg_write ( header_buf , req -> id , msg_type , p_conn , msg_length ( req ) ) ; } } else { dmsg_write ( header_buf , req -> id , msg_type , p_conn , msg_length ( req ) ) ; } mbuf_insert_head ( & req -> mhdr , header_buf ) ; if ( log_loggable ( LOG_VVERB ) ) { log_hexdump ( LOG_VVERB , header_buf -> pos , mbuf_length ( header_buf ) , "dyn<S2SV_blank>message<S2SV_blank>header:<S2SV_blank>" ) ; <S2SV_StartBug> msg_dump ( req ) ; <S2SV_EndBug> } conn_enqueue_inq ( ctx , p_conn , req ) ; dnode_peer_req_forward_stats ( ctx , p_conn -> owner , req ) ; log_debug ( LOG_VVERB , "remote<S2SV_blank>forward<S2SV_blank>from<S2SV_blank>c<S2SV_blank>%d<S2SV_blank>to<S2SV_blank>s<S2SV_blank>%d<S2SV_blank>req<S2SV_blank>%" PRIu64 "<S2SV_blank>len<S2SV_blank>%" PRIu32 "<S2SV_blank>type<S2SV_blank>%d<S2SV_blank>with<S2SV_blank>key<S2SV_blank>\'%.*s\'" , c_conn -> sd , p_conn -> sd , req -> id , req -> mlen , req -> type , keylen , key ) ; return DN_OK ; } | <S2SV_ModStart> ; msg_dump ( LOG_VVERB , |
179 | CWE-000 static char * sprintf_speed ( char * buf , ulong sz , uint ms ) { <S2SV_StartBug> uint64_t kbytes_per_sec = ( ( sz >> 10 ) * 1000 ) / ms ; <S2SV_EndBug> <S2SV_StartBug> uint64_t mb_per_sec = kbytes_per_sec >> 10 ; <S2SV_EndBug> <S2SV_StartBug> uint32_t remain = ( ( kbytes_per_sec - ( mb_per_sec << 10 ) ) * 100 ) >> 10 ; <S2SV_EndBug> <S2SV_StartBug> if ( ms && mb_per_sec ) <S2SV_EndBug> sprintf ( buf , "%llu.%02u<S2SV_blank>MB/s" , mb_per_sec , remain ) ; <S2SV_StartBug> else if ( ms && kbytes_per_sec ) <S2SV_EndBug> sprintf ( buf , "%llu<S2SV_blank>KB/s" , kbytes_per_sec ) ; else <S2SV_StartBug> strcpy ( buf , "###<S2SV_blank>MB/s" ) ; <S2SV_EndBug> return buf ; } | <S2SV_ModStart> { uint64_t kbytes_per_sec ; uint64_t mb_per_sec ; uint32_t remain ; if ( ! ms ) goto out ; kbytes_per_sec <S2SV_ModStart> / ms ; <S2SV_ModEnd> mb_per_sec = kbytes_per_sec <S2SV_ModStart> >> 10 ; <S2SV_ModEnd> remain = ( <S2SV_ModStart> ; if ( <S2SV_ModEnd> mb_per_sec ) sprintf <S2SV_ModStart> else if ( <S2SV_ModEnd> kbytes_per_sec ) sprintf <S2SV_ModStart> ) ; else goto out ; return buf ; out : |
180 | CWE-000 <S2SV_StartBug> int fflush_j ( FILE_J * fp ) { return _flushbuff ( fp ) && _fillbuff ( fp ) ; } <S2SV_EndBug> | <S2SV_ModStart> fp ) { int flush , fill ; flush = <S2SV_ModEnd> _flushbuff ( fp <S2SV_ModStart> ( fp ) ; fill = <S2SV_ModEnd> _fillbuff ( fp <S2SV_ModStart> fp ) ; return flush && fill ; |
181 | CWE-000 int pool_write ( struct pool_data * pool , const void * buff , size_t nbytes , uint64_t off ) { if ( off + nbytes > pool -> set_file -> size ) return - 1 ; <S2SV_StartBug> if ( pool -> params . type != POOL_TYPE_BTT ) <S2SV_EndBug> <S2SV_StartBug> memcpy ( ( char * ) pool -> set_file -> addr + off , buff , nbytes ) ; <S2SV_EndBug> else { if ( pool_btt_lseek ( pool , ( off_t ) off , SEEK_SET ) == - 1 ) return - 1 ; if ( ( size_t ) pool_btt_write ( pool , buff , nbytes ) != nbytes ) return - 1 ; } return 0 ; } | <S2SV_ModStart> != POOL_TYPE_BTT ) { <S2SV_ModStart> nbytes ) ; pmem_persist_generic_auto ( ( char * ) pool -> set_file -> addr + off , nbytes ) ; } |
182 | CWE-000 client_disconnect_data * client_disconnect_data_new ( api_data * data , dbus_client * client ) <S2SV_StartBug> { <S2SV_EndBug> client_disconnect_data * disconnect_data = g_new0 ( client_disconnect_data , 1 ) ; disconnect_data -> main_data = data ; <S2SV_StartBug> disconnect_data -> client_name = g_strdup ( client -> peer -> name ) ; <S2SV_EndBug> <S2SV_StartBug> return disconnect_data ; <S2SV_EndBug> } | <S2SV_ModStart> client ) { if ( ! data || ! client || ! client -> peer || ! client -> peer -> name ) return NULL ; <S2SV_ModStart> = data ; if ( client -> peer ) <S2SV_ModStart> name ) ; else disconnect_data -> client_name = NULL ; |
183 | CWE-000 <S2SV_StartBug> void EnqueuePCB ( PCBQueueNode * queueHead , PCB * pcb , ConfigFile * config ) <S2SV_EndBug> { if ( strcmp ( config -> schedulingCode , "SJF-N" ) == 0 || strcmp ( config -> schedulingCode , "SRTF-P" ) == 0 ) { <S2SV_StartBug> Enqueue ( & queueHead , pcb , pcb -> remainingTime ) ; <S2SV_EndBug> } else if ( strcmp ( config -> schedulingCode , "RR-P" ) == 0 ) { <S2SV_StartBug> Enqueue ( & queueHead , pcb , DEFAULT_ENQUEUE ) ; <S2SV_EndBug> } else { <S2SV_StartBug> Enqueue ( & queueHead , pcb , pcb -> processID ) ; <S2SV_EndBug> } } | <S2SV_ModStart> EnqueuePCB ( PCBQueueNode * <S2SV_ModStart> { Enqueue ( <S2SV_ModEnd> queueHead , pcb <S2SV_ModStart> { Enqueue ( <S2SV_ModEnd> queueHead , pcb <S2SV_ModStart> { Enqueue ( <S2SV_ModEnd> queueHead , pcb |
184 | CWE-000 void md_super_write ( mddev_t * mddev , mdk_rdev_t * rdev , sector_t sector , int size , struct page * page ) { struct bio * bio = bio_alloc_mddev ( GFP_NOIO , 1 , mddev ) ; bio -> bi_bdev = rdev -> meta_bdev ? rdev -> meta_bdev : rdev -> bdev ; bio -> bi_sector = sector ; bio_add_page ( bio , page , size , 0 ) ; bio -> bi_private = rdev ; bio -> bi_end_io = super_written ; atomic_inc ( & mddev -> pending_writes ) ; <S2SV_StartBug> submit_bio ( REQ_WRITE | REQ_SYNC | REQ_FLUSH | REQ_FUA , bio ) ; <S2SV_EndBug> } | <S2SV_ModStart> ; submit_bio ( WRITE_FLUSH_FUA <S2SV_ModEnd> , bio ) |
185 | CWE-000 static int scan ( struct wiphy * wiphy , struct cfg80211_scan_request * request ) { struct wilc_priv * priv ; u32 i ; s32 ret = 0 ; <S2SV_StartBug> u8 au8ScanChanList [ MAX_NUM_SCANNED_NETWORKS ] ; <S2SV_EndBug> struct hidden_network hidden_ntwk ; struct wilc_vif * vif ; priv = wiphy_priv ( wiphy ) ; vif = netdev_priv ( priv -> dev ) ; priv -> scan_req = request ; priv -> rcvd_ch_cnt = 0 ; reset_shadow_found ( ) ; priv -> cfg_scanning = true ; if ( request -> n_channels <= MAX_NUM_SCANNED_NETWORKS ) { for ( i = 0 ; i < request -> n_channels ; i ++ ) <S2SV_StartBug> au8ScanChanList [ i ] = ( u8 ) ieee80211_frequency_to_channel ( request -> channels [ i ] -> center_freq ) ; <S2SV_EndBug> if ( request -> n_ssids >= 1 ) { hidden_ntwk . net_info = kmalloc_array ( request -> n_ssids , sizeof ( struct hidden_network ) , GFP_KERNEL ) ; if ( ! hidden_ntwk . net_info ) return - ENOMEM ; hidden_ntwk . n_ssids = request -> n_ssids ; for ( i = 0 ; i < request -> n_ssids ; i ++ ) { if ( request -> ssids [ i ] . ssid_len != 0 ) { hidden_ntwk . net_info [ i ] . ssid = kmalloc ( request -> ssids [ i ] . ssid_len , GFP_KERNEL ) ; memcpy ( hidden_ntwk . net_info [ i ] . ssid , request -> ssids [ i ] . ssid , request -> ssids [ i ] . ssid_len ) ; hidden_ntwk . net_info [ i ] . ssid_len = request -> ssids [ i ] . ssid_len ; } else { hidden_ntwk . n_ssids -= 1 ; } } ret = wilc_scan ( vif , USER_SCAN , ACTIVE_SCAN , <S2SV_StartBug> au8ScanChanList , <S2SV_EndBug> request -> n_channels , ( const u8 * ) request -> ie , request -> ie_len , cfg_scan_result , ( void * ) priv , & hidden_ntwk ) ; } else { ret = wilc_scan ( vif , USER_SCAN , ACTIVE_SCAN , <S2SV_StartBug> au8ScanChanList , <S2SV_EndBug> request -> n_channels , ( const u8 * ) request -> ie , request -> ie_len , cfg_scan_result , ( void * ) priv , NULL ) ; } } else { netdev_err ( priv -> dev , "Requested<S2SV_blank>scanned<S2SV_blank>channels<S2SV_blank>over\\n" ) ; } if ( ret != 0 ) ret = - EBUSY ; return ret ; } | <S2SV_ModStart> 0 ; u8 scan_ch_list <S2SV_ModEnd> [ MAX_NUM_SCANNED_NETWORKS ] <S2SV_ModStart> i ++ ) scan_ch_list <S2SV_ModEnd> [ i ] <S2SV_ModStart> , ACTIVE_SCAN , scan_ch_list <S2SV_ModEnd> , request -> <S2SV_ModStart> , ACTIVE_SCAN , scan_ch_list <S2SV_ModEnd> , request -> |
186 | CWE-000 int plugin_dispatch_notification ( const notification_t * notif ) { <S2SV_StartBug> long long unsigned int before = ( long long unsigned int ) CDTIME_T_TO_US ( cdtime ( ) ) / 1000 ; <S2SV_EndBug> llentry_t * le ; DEBUG ( "plugin_dispatch_notification:<S2SV_blank>severity<S2SV_blank>=<S2SV_blank>%i;<S2SV_blank>message<S2SV_blank>=<S2SV_blank>%s;<S2SV_blank>" "time<S2SV_blank>=<S2SV_blank>%.3f;<S2SV_blank>host<S2SV_blank>=<S2SV_blank>%s;" , notif -> severity , notif -> message , CDTIME_T_TO_DOUBLE ( notif -> time ) , notif -> host ) ; if ( list_notification == NULL ) return - 1 ; le = llist_head ( list_notification ) ; while ( le != NULL ) { callback_func_t * cf ; plugin_notification_cb callback ; int status ; cf = le -> value ; callback = cf -> cf_callback ; status = ( * callback ) ( notif , & cf -> cf_udata ) ; if ( status != 0 ) { WARNING ( "plugin_dispatch_notification:<S2SV_blank>Notification<S2SV_blank>" "callback<S2SV_blank>%s<S2SV_blank>returned<S2SV_blank>%i." , le -> key , status ) ; } le = le -> next ; } pid_t tid = syscall ( __NR_gettid ) ; <S2SV_StartBug> long long unsigned int after = ( long long unsigned int ) CDTIME_T_TO_US ( cdtime ( ) ) / 1000 ; <S2SV_EndBug> WARNING ( "AJB<S2SV_blank>(%d)<S2SV_blank>plugin_dispatch_DIFF:<S2SV_blank>%llu<S2SV_blank>us" , tid , after - before ) ; return 0 ; } | <S2SV_ModStart> ( ) ) <S2SV_ModEnd> ; llentry_t * <S2SV_ModStart> ( ) ) <S2SV_ModEnd> ; WARNING ( |
187 | CWE-000 static void activity_window_load ( Window * window ) { <S2SV_StartBug> APP_LOG ( APP_LOG_LEVEL_DEBUG , "Loading<S2SV_blank>activity<S2SV_blank>window" ) ; <S2SV_EndBug> currentStepIndex = 0 ; timeSpentInCurrentStep = 0 ; isPaused = false ; activity_load_bitmaps ( ) ; activity_load_status_bar ( window ) ; activity_load_action_bar ( window ) ; activity_load_main_layers ( window ) ; check_state_of_timer ( ) ; } | <S2SV_ModStart> window ) { <S2SV_ModEnd> currentStepIndex = 0 |
188 | CWE-000 void jabber_chat_free_settings ( account_t * acc , set_t * * head ) { <S2SV_StartBug> set_del ( head , "password" ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( head , "always_use_nicks" ) ; set_del ( head , |
189 | CWE-000 int ft_error ( char * util , char * msg , char * what ) { if ( what ) <S2SV_StartBug> ft_printfd ( 2 , "%s:<S2SV_blank>%s<S2SV_blank>%s\\n" , util , msg , what ) ; <S2SV_EndBug> else if ( util ) <S2SV_StartBug> ft_printfd ( 2 , "%s:<S2SV_blank>%s\\n" , util , msg ) ; <S2SV_EndBug> else <S2SV_StartBug> ft_printfd ( 2 , "%s\\n" , msg ) ; <S2SV_EndBug> return ( - 1 ) ; } | <S2SV_ModStart> ( 2 , "%s:<S2SV_blank>%s<S2SV_blank>%s" <S2SV_ModEnd> , util , <S2SV_ModStart> ( 2 , "%s:<S2SV_blank>%s" <S2SV_ModEnd> , util , <S2SV_ModStart> ( 2 , "%s" <S2SV_ModEnd> , msg ) |
190 | CWE-000 void NDRX_INTEGRA ( tpsvrdone ) ( void ) { int i ; NDRX_LOG ( log_debug , "tpsvrdone<S2SV_blank>called" ) ; <S2SV_StartBug> if ( NULL != G_bridge_cfg . con ) <S2SV_EndBug> { exnet_close_shut ( G_bridge_cfg . con ) ; } if ( G_bridge_cfg . net . is_server ) { exnet_close_shut ( & G_bridge_cfg . net ) ; } if ( M_init_ok ) { for ( i = 0 ; i < G_bridge_cfg . threadpoolsize ; i ++ ) { NDRX_LOG ( log_info , "Terminating<S2SV_blank>threadpool,<S2SV_blank>thread<S2SV_blank>#%d" , i ) ; thpool_add_work ( G_bridge_cfg . thpool , ( void * ) tp_thread_shutdown , NULL ) ; } thpool_wait ( G_bridge_cfg . thpool ) ; thpool_destroy ( G_bridge_cfg . thpool ) ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> "tpsvrdone<S2SV_blank>called" ) ; <S2SV_ModEnd> if ( M_init_ok <S2SV_ModStart> ) ; } if ( NULL != G_bridge_cfg . con ) { exnet_close_shut ( G_bridge_cfg . con ) ; } if ( G_bridge_cfg . net . is_server ) { exnet_close_shut ( & G_bridge_cfg . net ) ; } |
191 | CWE-000 void set_working_cpu ( int thread ) { int i ; if ( ! cpuset_size ) return ; for ( i = 0 ; ; ) { <S2SV_StartBug> if ( CPU_ISSET_S ( i , cpuset_size + 1 , cpuset ) && ! thread -- ) { <S2SV_EndBug> <S2SV_StartBug> CPU_ZERO_S ( cpuset_size + 1 , cpuset ) ; <S2SV_EndBug> <S2SV_StartBug> CPU_SET_S ( i , cpuset_size + 1 , cpuset ) ; <S2SV_EndBug> <S2SV_StartBug> sched_setaffinity ( 0 , cpuset_size + 1 , cpuset ) ; <S2SV_EndBug> return ; } <S2SV_StartBug> if ( ++ i >= cpuset_size ) <S2SV_EndBug> i = 0 ; } } | <S2SV_ModStart> i , cpuset_size <S2SV_ModEnd> , cpuset ) <S2SV_ModStart> CPU_ZERO_S ( cpuset_size <S2SV_ModEnd> , cpuset ) <S2SV_ModStart> i , cpuset_size <S2SV_ModEnd> , cpuset ) <S2SV_ModStart> 0 , cpuset_size <S2SV_ModEnd> , cpuset ) <S2SV_ModStart> ++ i >= cpuset_ncpu <S2SV_ModEnd> ) i = |
192 | CWE-000 static int sanity_check_raw_super ( struct super_block * sb , <S2SV_StartBug> struct f2fs_super_block * raw_super ) <S2SV_EndBug> { unsigned int blocksize ; if ( F2FS_SUPER_MAGIC != le32_to_cpu ( raw_super -> magic ) ) { f2fs_msg ( sb , KERN_INFO , "Magic<S2SV_blank>Mismatch,<S2SV_blank>valid(0x%x)<S2SV_blank>-<S2SV_blank>read(0x%x)" , F2FS_SUPER_MAGIC , le32_to_cpu ( raw_super -> magic ) ) ; return 1 ; } if ( F2FS_BLKSIZE != PAGE_CACHE_SIZE ) { f2fs_msg ( sb , KERN_INFO , "Invalid<S2SV_blank>page_cache_size<S2SV_blank>(%lu),<S2SV_blank>supports<S2SV_blank>only<S2SV_blank>4KB\\n" , PAGE_CACHE_SIZE ) ; return 1 ; } blocksize = 1 << le32_to_cpu ( raw_super -> log_blocksize ) ; if ( blocksize != F2FS_BLKSIZE ) { f2fs_msg ( sb , KERN_INFO , "Invalid<S2SV_blank>blocksize<S2SV_blank>(%u),<S2SV_blank>supports<S2SV_blank>only<S2SV_blank>4KB\\n" , blocksize ) ; return 1 ; } if ( le32_to_cpu ( raw_super -> log_blocks_per_seg ) != 9 ) { f2fs_msg ( sb , KERN_INFO , "Invalid<S2SV_blank>log<S2SV_blank>blocks<S2SV_blank>per<S2SV_blank>segment<S2SV_blank>(%u)\\n" , le32_to_cpu ( raw_super -> log_blocks_per_seg ) ) ; return 1 ; } if ( le32_to_cpu ( raw_super -> log_sectorsize ) > F2FS_MAX_LOG_SECTOR_SIZE || le32_to_cpu ( raw_super -> log_sectorsize ) < F2FS_MIN_LOG_SECTOR_SIZE ) { f2fs_msg ( sb , KERN_INFO , "Invalid<S2SV_blank>log<S2SV_blank>sectorsize<S2SV_blank>(%u)" , le32_to_cpu ( raw_super -> log_sectorsize ) ) ; return 1 ; } if ( le32_to_cpu ( raw_super -> log_sectors_per_block ) + le32_to_cpu ( raw_super -> log_sectorsize ) != F2FS_MAX_LOG_SECTOR_SIZE ) { f2fs_msg ( sb , KERN_INFO , "Invalid<S2SV_blank>log<S2SV_blank>sectors<S2SV_blank>per<S2SV_blank>block(%u)<S2SV_blank>log<S2SV_blank>sectorsize(%u)" , le32_to_cpu ( raw_super -> log_sectors_per_block ) , le32_to_cpu ( raw_super -> log_sectorsize ) ) ; return 1 ; } if ( le32_to_cpu ( raw_super -> segment_count ) > F2FS_MAX_SEGMENT ) { f2fs_msg ( sb , KERN_INFO , "Invalid<S2SV_blank>segment<S2SV_blank>count<S2SV_blank>(%u)" , le32_to_cpu ( raw_super -> segment_count ) ) ; return 1 ; } if ( le32_to_cpu ( raw_super -> node_ino ) != 1 || le32_to_cpu ( raw_super -> meta_ino ) != 2 || le32_to_cpu ( raw_super -> root_ino ) != 3 ) { f2fs_msg ( sb , KERN_INFO , "Invalid<S2SV_blank>Fs<S2SV_blank>Meta<S2SV_blank>Ino:<S2SV_blank>node(%u)<S2SV_blank>meta(%u)<S2SV_blank>root(%u)" , le32_to_cpu ( raw_super -> node_ino ) , le32_to_cpu ( raw_super -> meta_ino ) , le32_to_cpu ( raw_super -> root_ino ) ) ; return 1 ; } <S2SV_StartBug> if ( sanity_check_area_boundary ( sb , raw_super ) ) <S2SV_EndBug> return 1 ; return 0 ; } | <S2SV_ModStart> sb , struct buffer_head * bh ) { struct <S2SV_ModStart> f2fs_super_block * raw_super = ( struct f2fs_super_block * ) ( bh -> b_data + F2FS_SUPER_OFFSET ) ; <S2SV_ModEnd> unsigned int blocksize <S2SV_ModStart> ( sb , bh <S2SV_ModEnd> ) ) return |
193 | CWE-000 static int ehci_usb_probe ( struct udevice * dev ) { struct usb_platdata * plat = dev_get_platdata ( dev ) ; struct ehci_sunxi_priv * priv = dev_get_priv ( dev ) ; struct ehci_hccr * hccr = ( struct ehci_hccr * ) devfdt_get_addr ( dev ) ; struct ehci_hcor * hcor ; int extra_ahb_gate_mask = 0 ; int phys , ret ; priv -> cfg = ( const struct ehci_sunxi_cfg * ) dev_get_driver_data ( dev ) ; priv -> ccm = ( struct sunxi_ccm_reg * ) SUNXI_CCM_BASE ; if ( IS_ERR ( priv -> ccm ) ) return PTR_ERR ( priv -> ccm ) ; <S2SV_StartBug> phys = dev_count_phandle_with_args ( dev , "phys" , "#phy-cells" ) ; <S2SV_EndBug> if ( phys < 0 ) { phys = 0 ; goto no_phy ; } ret = generic_phy_get_by_name ( dev , "usb" , & priv -> phy ) ; if ( ret ) { pr_err ( "failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>%s<S2SV_blank>usb<S2SV_blank>PHY\\n" , dev -> name ) ; return ret ; } ret = generic_phy_init ( & priv -> phy ) ; if ( ret ) { pr_err ( "failed<S2SV_blank>to<S2SV_blank>init<S2SV_blank>%s<S2SV_blank>USB<S2SV_blank>PHY\\n" , dev -> name ) ; return ret ; } ret = generic_phy_power_on ( & priv -> phy ) ; if ( ret ) { pr_err ( "failed<S2SV_blank>to<S2SV_blank>power<S2SV_blank>on<S2SV_blank>%s<S2SV_blank>USB<S2SV_blank>PHY\\n" , dev -> name ) ; return ret ; } no_phy : priv -> ahb_gate_mask = 1 << AHB_GATE_OFFSET_USB_EHCI0 ; extra_ahb_gate_mask = priv -> cfg -> extra_ahb_gate_mask ; priv -> ahb_gate_mask <<= phys * AHB_CLK_DIST ; extra_ahb_gate_mask <<= phys * AHB_CLK_DIST ; setbits_le32 ( & priv -> ccm -> ahb_gate0 , priv -> ahb_gate_mask | extra_ahb_gate_mask ) ; if ( priv -> cfg -> has_reset ) <S2SV_StartBug> setbits_le32 ( & priv -> ccm -> ahb_reset0_cfg , <S2SV_EndBug> priv -> ahb_gate_mask | extra_ahb_gate_mask ) ; hcor = ( struct ehci_hcor * ) ( ( uintptr_t ) hccr + HC_LENGTH ( ehci_readl ( & hccr -> cr_capbase ) ) ) ; return ehci_register ( dev , hccr , hcor , NULL , 0 , plat -> init_type ) ; } | <S2SV_ModStart> ccm ) ; priv -> reset0_cfg = ( void * ) priv -> ccm + priv -> cfg -> reset0_cfg_offset ; <S2SV_ModStart> ) setbits_le32 ( priv -> reset0_cfg <S2SV_ModEnd> , priv -> |
194 | CWE-000 int main ( int argc , char * * argv ) { int ncid , dimid , varid , temp_typeid , sounding_typeid ; struct sea_sounding { int sounding_no ; nc_vlen_t temp_vl ; } data [ DIM_LEN ] ; int i , j ; for ( i = 0 ; i < DIM_LEN ; i ++ ) { if ( ! ( data [ i ] . temp_vl . p = malloc ( sizeof ( float ) * ( i + 1 ) ) ) ) return NC_ENOMEM ; for ( j = 0 ; j < i + 1 ; j ++ ) ( ( float * ) ( data [ i ] . temp_vl . p ) ) [ j ] = 23.5 - j ; data [ i ] . temp_vl . len = i + 1 ; } printf ( "\\n***<S2SV_blank>Testing<S2SV_blank>netcdf-4<S2SV_blank>CDM<S2SV_blank>compliance:<S2SV_blank>sea<S2SV_blank>soundings.\\n" ) ; printf ( "***<S2SV_blank>creating<S2SV_blank>simple<S2SV_blank>sea<S2SV_blank>sounding<S2SV_blank>file..." ) ; if ( nc_create ( FILE_NAME , NC_NETCDF4 , & ncid ) ) ERR ; if ( nc_def_vlen ( ncid , "temp_vlen" , NC_FLOAT , & temp_typeid ) ) ERR ; if ( nc_def_compound ( ncid , sizeof ( struct sea_sounding ) , "sea_sounding" , & sounding_typeid ) ) ERR ; if ( nc_insert_compound ( ncid , sounding_typeid , "sounding_no" , NC_COMPOUND_OFFSET ( struct sea_sounding , sounding_no ) , NC_INT ) ) ERR ; if ( nc_insert_compound ( ncid , sounding_typeid , "temp_vl" , NC_COMPOUND_OFFSET ( struct sea_sounding , temp_vl ) , temp_typeid ) ) ERR ; if ( nc_def_dim ( ncid , DIM_NAME , DIM_LEN , & dimid ) ) ERR ; if ( nc_def_var ( ncid , "fun_soundings" , sounding_typeid , 1 , & dimid , & varid ) ) ERR ; if ( nc_put_var ( ncid , varid , data ) ) ERR ; if ( nc_close ( ncid ) ) ERR ; SUMMARIZE_ERR ; for ( i = 0 ; i < DIM_LEN ; i ++ ) free ( data [ i ] . temp_vl . p ) ; <S2SV_StartBug> if ( total_err ) <S2SV_EndBug> { printf ( "%d<S2SV_blank>errors<S2SV_blank>detected!<S2SV_blank>Sorry!\\n" , total_err ) ; return 2 ; } printf ( "***<S2SV_blank>Tests<S2SV_blank>successful!\\n" ) ; return 0 ; } | <S2SV_ModStart> p ) ; FINAL_RESULTS <S2SV_ModEnd> ; } <S2SV_null> |
195 | CWE-000 MonoObject * mono_object_new_checked ( MonoDomain * domain , MonoClass * klass , MonoError * error ) { MONO_REQ_GC_UNSAFE_MODE ; MonoVTable * vtable ; <S2SV_StartBug> vtable = mono_class_vtable ( domain , klass ) ; <S2SV_EndBug> g_assert ( vtable ) ; MonoObject * o = mono_object_new_specific_checked ( vtable , error ) ; return o ; } | <S2SV_ModStart> ; vtable = mono_class_vtable_full <S2SV_ModEnd> ( domain , <S2SV_ModStart> domain , klass , error ) ; if ( ! vtable ) return NULL <S2SV_ModEnd> ; MonoObject * |
196 | CWE-000 int VCP_write ( const void * pBuffer , int size ) { if ( size > kMaxOutPacketSize ) { int offset ; <S2SV_StartBug> for ( offset = 0 ; offset < size ; offset ++ ) <S2SV_EndBug> { int todo = MIN ( kMaxOutPacketSize , size - offset ) ; <S2SV_StartBug> int done = VCP_write ( ( ( char * ) pBuffer ) + offset , todo ) ; <S2SV_EndBug> if ( done != todo ) return offset + done ; } return size ; } USBD_CDC_HandleTypeDef * pCDC = ( USBD_CDC_HandleTypeDef * ) USBD_Device . pClassData ; while ( pCDC -> TxState ) { } USBD_CDC_SetTxBuffer ( & USBD_Device , ( uint8_t * ) pBuffer , size ) ; if ( USBD_CDC_TransmitPacket ( & USBD_Device ) != USBD_OK ) return 0 ; while ( pCDC -> TxState ) { } return size ; } | <S2SV_ModStart> int offset ; int done = 0 ; <S2SV_ModStart> size ; offset += done <S2SV_ModEnd> ) { int <S2SV_ModStart> offset ) ; <S2SV_ModEnd> done = VCP_write |
197 | CWE-000 unsigned char CircularBufferGetByte ( CircularBuffer * circBuffer ) { assert ( circBuffer != NULL ) ; assert ( ! CircularBufferIsEmpty ( circBuffer ) ) ; unsigned char byte = circBuffer -> buffer [ circBuffer -> tail ] ; circBuffer -> tail = ( circBuffer -> tail + 1 ) % CIRCULAR_BUFFER_CAPACITY_BYTES ; <S2SV_StartBug> circBuffer -> isFull = false ; <S2SV_EndBug> return byte ; } | <S2SV_ModStart> % CIRCULAR_BUFFER_CAPACITY_BYTES ; if ( circBuffer -> tail == circBuffer -> head && ! circBuffer -> isEmpty ) { circBuffer -> isEmpty = true ; } <S2SV_ModEnd> return byte ; |
198 | CWE-000 void servo_control_thread ( void const * argument ) { while ( 1 ) { <S2SV_StartBug> set_servo ( ) ; <S2SV_EndBug> osDelay ( 10 ) ; } <S2SV_StartBug> terminate_thread ( ) ; <S2SV_EndBug> } | <S2SV_ModStart> 1 ) { osDelay ( 10 ) ; if ( BSP_PB_GetState ( BUTTON_USER ) == 0 ) { calibrate ( ) ; osDelay ( 100 ) ; } else { <S2SV_ModStart> ) ; } } |
199 | CWE-000 static void aac_process_events ( struct aac_dev * dev ) { struct hw_fib * hw_fib ; struct fib * fib ; unsigned long flags ; <S2SV_StartBug> spinlock_t * t_lock ; <S2SV_EndBug> unsigned int rcode ; t_lock = dev -> queues -> queue [ HostNormCmdQueue ] . lock ; spin_lock_irqsave ( t_lock , flags ) ; while ( ! list_empty ( & ( dev -> queues -> queue [ HostNormCmdQueue ] . cmdq ) ) ) { struct list_head * entry ; struct aac_aifcmd * aifcmd ; unsigned int num ; struct hw_fib * * hw_fib_pool , * * hw_fib_p ; struct fib * * fib_pool , * * fib_p ; set_current_state ( TASK_RUNNING ) ; entry = dev -> queues -> queue [ HostNormCmdQueue ] . cmdq . next ; list_del ( entry ) ; t_lock = dev -> queues -> queue [ HostNormCmdQueue ] . lock ; spin_unlock_irqrestore ( t_lock , flags ) ; fib = list_entry ( entry , struct fib , fiblink ) ; hw_fib = fib -> hw_fib_va ; if ( dev -> sa_firmware ) { aac_handle_sa_aif ( dev , fib ) ; aac_fib_adapter_complete ( fib , ( u16 ) sizeof ( u32 ) ) ; goto free_fib ; } memset ( fib , 0 , sizeof ( struct fib ) ) ; fib -> type = FSAFS_NTC_FIB_CONTEXT ; fib -> size = sizeof ( struct fib ) ; fib -> hw_fib_va = hw_fib ; fib -> data = hw_fib -> data ; fib -> dev = dev ; aifcmd = ( struct aac_aifcmd * ) hw_fib -> data ; if ( aifcmd -> command == cpu_to_le32 ( AifCmdDriverNotify ) ) { aac_handle_aif ( dev , fib ) ; * ( __le32 * ) hw_fib -> data = cpu_to_le32 ( ST_OK ) ; aac_fib_adapter_complete ( fib , ( u16 ) sizeof ( u32 ) ) ; goto free_fib ; } if ( aifcmd -> command == cpu_to_le32 ( AifCmdEventNotify ) || aifcmd -> command == cpu_to_le32 ( AifCmdJobProgress ) ) { aac_handle_aif ( dev , fib ) ; } num = get_fib_count ( dev ) ; if ( ! num ) goto free_fib ; hw_fib_pool = kmalloc_array ( num , sizeof ( struct hw_fib * ) , GFP_KERNEL ) ; if ( ! hw_fib_pool ) goto free_fib ; fib_pool = kmalloc_array ( num , sizeof ( struct fib * ) , GFP_KERNEL ) ; if ( ! fib_pool ) goto free_hw_fib_pool ; <S2SV_StartBug> rcode = fillup_pools ( dev , hw_fib_pool , fib_pool , num ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ! rcode ) <S2SV_EndBug> goto free_mem ; wakeup_fibctx_threads ( dev , hw_fib_pool , fib_pool , fib , hw_fib , num ) ; free_mem : hw_fib_p = hw_fib_pool ; fib_p = fib_pool ; while ( hw_fib_p < & hw_fib_pool [ num ] ) { kfree ( * hw_fib_p ) ; kfree ( * fib_p ) ; ++ fib_p ; ++ hw_fib_p ; } kfree ( fib_pool ) ; free_hw_fib_pool : kfree ( hw_fib_pool ) ; free_fib : kfree ( fib ) ; t_lock = dev -> queues -> queue [ HostNormCmdQueue ] . lock ; spin_lock_irqsave ( t_lock , flags ) ; } t_lock = dev -> queues -> queue [ HostNormCmdQueue ] . lock ; spin_unlock_irqrestore ( t_lock , flags ) ; } | <S2SV_ModStart> spinlock_t * t_lock <S2SV_ModEnd> ; t_lock = <S2SV_ModStart> goto free_hw_fib_pool ; num <S2SV_ModEnd> = fillup_pools ( <S2SV_ModStart> if ( ! num <S2SV_ModEnd> ) goto free_mem |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.