Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
2,800 | CWE-000 static int cleanup ( void ) { ofp_inetsw [ 0 ] . pr_ctlinput = ctlinput_bkp ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> = ctlinput_bkp ; restore_logging ( log_level ) ; |
2,801 | CWE-000 static void btrfs_split_extent_hook ( void * private_data , struct extent_state * orig , u64 split ) { struct inode * inode = private_data ; u64 size ; enum btrfs_metadata_reserve_type reserve_type = BTRFS_RESERVE_NORMAL ; u64 max_extent_size ; if ( ! ( orig -> state & EXTENT_DELALLOC ) ) <S2SV_StartBug> return ; <S2SV_EndBug> max_extent_size = btrfs_max_extent_size ( reserve_type ) ; size = orig -> end - orig -> start + 1 ; if ( size > max_extent_size ) { u32 num_extents ; u64 new_size ; new_size = orig -> end - split + 1 ; num_extents = count_max_extents ( new_size , max_extent_size ) ; new_size = split - orig -> start ; num_extents += count_max_extents ( new_size , max_extent_size ) ; if ( count_max_extents ( size , max_extent_size ) >= num_extents ) return ; } spin_lock ( & BTRFS_I ( inode ) -> lock ) ; btrfs_mod_outstanding_extents ( BTRFS_I ( inode ) , 1 ) ; spin_unlock ( & BTRFS_I ( inode ) -> lock ) ; } | <S2SV_ModStart> ) ) return ; if ( orig -> state & EXTENT_COMPRESS ) reserve_type = BTRFS_RESERVE_COMPRESS |
2,802 | CWE-000 int _common_update_attr_all ( struct transvr_obj_s * self , int show_err ) { char * err_str = "err" ; if ( _common_update_attr_id ( self , show_err ) < 0 ) { err_str = "_common_update_attr_id" ; goto err_common_update_attr_all ; } if ( _common_update_attr_eeprom ( self , show_err ) < 0 ) { err_str = "_common_update_attr_eeprom" ; goto err_common_update_attr_all ; } <S2SV_StartBug> if ( _common_update_attr_uppage ( self , show_err ) < 0 ) { <S2SV_EndBug> err_str = "_common_update_attr_uppage" ; goto err_common_update_attr_all ; } if ( _common_update_attr_extended_id ( self , show_err ) < 0 ) { err_str = "_common_update_attr_extended_id" ; goto err_common_update_attr_all ; } if ( _common_update_attr_connector ( self , show_err ) < 0 ) { err_str = "_common_update_attr_connector" ; goto err_common_update_attr_all ; } if ( _common_update_attr_transvr_comp ( self , show_err ) < 0 ) { err_str = "_common_update_attr_transvr_comp" ; goto err_common_update_attr_all ; } if ( _common_update_attr_transvr_comp_ext ( self , show_err ) < 0 ) { err_str = "_common_update_attr_transvr_comp_ext" ; goto err_common_update_attr_all ; } if ( _common_update_attr_vendor_name ( self , show_err ) < 0 ) { err_str = "_common_update_attr_vendor_name" ; goto err_common_update_attr_all ; } if ( _common_update_attr_vendor_pn ( self , show_err ) < 0 ) { err_str = "_common_update_attr_vendor_pn" ; goto err_common_update_attr_all ; } if ( _common_update_attr_vendor_rev ( self , show_err ) < 0 ) { err_str = "_common_update_attr_vendor_rev" ; goto err_common_update_attr_all ; } if ( _common_update_attr_vendor_sn ( self , show_err ) < 0 ) { err_str = "_common_update_attr_vendor_sn" ; goto err_common_update_attr_all ; } if ( _common_update_attr_br ( self , show_err ) < 0 ) { err_str = "_common_update_attr_br" ; goto err_common_update_attr_all ; } if ( _common_update_attr_len_smf ( self , show_err ) < 0 ) { err_str = "_common_update_attr_len_smf" ; goto err_common_update_attr_all ; } if ( _common_update_attr_len_om1 ( self , show_err ) < 0 ) { err_str = "_common_update_attr_len_om1" ; goto err_common_update_attr_all ; } if ( _common_update_attr_len_om2 ( self , show_err ) < 0 ) { err_str = "_common_update_attr_len_om2" ; goto err_common_update_attr_all ; } if ( _common_update_attr_len_om3 ( self , show_err ) < 0 ) { err_str = "_common_update_attr_len_om3" ; goto err_common_update_attr_all ; } if ( _common_update_attr_len_om4 ( self , show_err ) < 0 ) { err_str = "_common_update_attr_len_om4" ; goto err_common_update_attr_all ; } if ( _common_update_attr_option ( self , show_err ) < 0 ) { err_str = "_common_update_attr_option" ; goto err_common_update_attr_all ; } if ( _common_update_attr_comp_rev ( self , show_err ) < 0 ) { err_str = "_common_update_attr_comp_rev" ; goto err_common_update_attr_all ; } if ( _common_update_attr_diag_type ( self , show_err ) < 0 ) { err_str = "_common_update_attr_diag_type" ; goto err_common_update_attr_all ; } if ( _common_update_attr_wavelength ( self , show_err ) < 0 ) { err_str = "_common_update_attr_wavelength" ; goto err_common_update_attr_all ; } return 0 ; err_common_update_attr_all : if ( show_err ) { SWPS_INFO ( "%s:<S2SV_blank>fail<S2SV_blank>at:%s<S2SV_blank><swp>:%s\\n" , __func__ , err_str , self -> swp_name ) ; } return - 1 ; } | <S2SV_ModStart> } if ( <S2SV_ModEnd> _common_update_attr_extended_id ( self |
2,803 | CWE-000 static int aac_read ( struct scsi_cmnd * scsicmd ) { u64 lba ; u32 count ; int status ; struct aac_dev * dev ; struct fib * cmd_fibcontext ; int cid ; dev = ( struct aac_dev * ) scsicmd -> device -> host -> hostdata ; switch ( scsicmd -> cmnd [ 0 ] ) { case READ_6 : dprintk ( ( KERN_DEBUG "aachba:<S2SV_blank>received<S2SV_blank>a<S2SV_blank>read(6)<S2SV_blank>command<S2SV_blank>on<S2SV_blank>id<S2SV_blank>%d.\\n" , scmd_id ( scsicmd ) ) ) ; lba = ( ( scsicmd -> cmnd [ 1 ] & 0x1F ) << 16 ) | ( scsicmd -> cmnd [ 2 ] << 8 ) | scsicmd -> cmnd [ 3 ] ; count = scsicmd -> cmnd [ 4 ] ; if ( count == 0 ) count = 256 ; break ; case READ_16 : dprintk ( ( KERN_DEBUG "aachba:<S2SV_blank>received<S2SV_blank>a<S2SV_blank>read(16)<S2SV_blank>command<S2SV_blank>on<S2SV_blank>id<S2SV_blank>%d.\\n" , scmd_id ( scsicmd ) ) ) ; lba = ( ( u64 ) scsicmd -> cmnd [ 2 ] << 56 ) | ( ( u64 ) scsicmd -> cmnd [ 3 ] << 48 ) | ( ( u64 ) scsicmd -> cmnd [ 4 ] << 40 ) | ( ( u64 ) scsicmd -> cmnd [ 5 ] << 32 ) | ( ( u64 ) scsicmd -> cmnd [ 6 ] << 24 ) | ( scsicmd -> cmnd [ 7 ] << 16 ) | ( scsicmd -> cmnd [ 8 ] << 8 ) | scsicmd -> cmnd [ 9 ] ; count = ( scsicmd -> cmnd [ 10 ] << 24 ) | ( scsicmd -> cmnd [ 11 ] << 16 ) | ( scsicmd -> cmnd [ 12 ] << 8 ) | scsicmd -> cmnd [ 13 ] ; break ; case READ_12 : dprintk ( ( KERN_DEBUG "aachba:<S2SV_blank>received<S2SV_blank>a<S2SV_blank>read(12)<S2SV_blank>command<S2SV_blank>on<S2SV_blank>id<S2SV_blank>%d.\\n" , scmd_id ( scsicmd ) ) ) ; lba = ( ( u64 ) scsicmd -> cmnd [ 2 ] << 24 ) | ( scsicmd -> cmnd [ 3 ] << 16 ) | ( scsicmd -> cmnd [ 4 ] << 8 ) | scsicmd -> cmnd [ 5 ] ; count = ( scsicmd -> cmnd [ 6 ] << 24 ) | ( scsicmd -> cmnd [ 7 ] << 16 ) | ( scsicmd -> cmnd [ 8 ] << 8 ) | scsicmd -> cmnd [ 9 ] ; break ; default : dprintk ( ( KERN_DEBUG "aachba:<S2SV_blank>received<S2SV_blank>a<S2SV_blank>read(10)<S2SV_blank>command<S2SV_blank>on<S2SV_blank>id<S2SV_blank>%d.\\n" , scmd_id ( scsicmd ) ) ) ; lba = ( ( u64 ) scsicmd -> cmnd [ 2 ] << 24 ) | ( scsicmd -> cmnd [ 3 ] << 16 ) | ( scsicmd -> cmnd [ 4 ] << 8 ) | scsicmd -> cmnd [ 5 ] ; count = ( scsicmd -> cmnd [ 7 ] << 8 ) | scsicmd -> cmnd [ 8 ] ; break ; } if ( ( lba + count ) > ( dev -> fsa_dev [ scmd_id ( scsicmd ) ] . size ) ) { cid = scmd_id ( scsicmd ) ; dprintk ( ( KERN_DEBUG "aacraid:<S2SV_blank>Illegal<S2SV_blank>lba\\n" ) ) ; scsicmd -> result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION ; set_sense ( & dev -> fsa_dev [ cid ] . sense_data , HARDWARE_ERROR , SENCODE_INTERNAL_TARGET_FAILURE , ASENCODE_INTERNAL_TARGET_FAILURE , 0 , 0 ) ; memcpy ( scsicmd -> sense_buffer , & dev -> fsa_dev [ cid ] . sense_data , min_t ( size_t , sizeof ( dev -> fsa_dev [ cid ] . sense_data ) , SCSI_SENSE_BUFFERSIZE ) ) ; scsicmd -> scsi_done ( scsicmd ) ; return 1 ; } dprintk ( ( KERN_DEBUG "aac_read[cpu<S2SV_blank>%d]:<S2SV_blank>lba<S2SV_blank>=<S2SV_blank>%llu,<S2SV_blank>t<S2SV_blank>=<S2SV_blank>%ld.\\n" , smp_processor_id ( ) , ( unsigned long long ) lba , jiffies ) ) ; if ( aac_adapter_bounds ( dev , scsicmd , lba ) ) return 0 ; cmd_fibcontext = aac_fib_alloc_tag ( dev , scsicmd ) ; <S2SV_StartBug> status = aac_adapter_read ( cmd_fibcontext , scsicmd , lba , count ) ; <S2SV_EndBug> <S2SV_StartBug> if ( status == - EINPROGRESS ) { <S2SV_EndBug> scsicmd -> SCp . phase = AAC_OWNER_FIRMWARE ; return 0 ; <S2SV_StartBug> } <S2SV_EndBug> printk ( KERN_WARNING "aac_read:<S2SV_blank>aac_fib_send<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>status:<S2SV_blank>%d.\\n" , status ) ; scsicmd -> result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_TASK_SET_FULL ; scsicmd -> scsi_done ( scsicmd ) ; aac_fib_complete ( cmd_fibcontext ) ; aac_fib_free ( cmd_fibcontext ) ; return 0 ; } | <S2SV_ModStart> scsicmd ) ; scsicmd -> SCp . phase = AAC_OWNER_FIRMWARE ; <S2SV_ModStart> - EINPROGRESS ) <S2SV_ModEnd> return 0 ; <S2SV_ModStart> return 0 ; <S2SV_ModEnd> printk ( KERN_WARNING |
2,804 | CWE-000 void bfree ( void * memory ) { if ( memory != NULL ) { struct BlockHead * block = unhideHead ( memory ) ; <S2SV_StartBug> insert ( block ) ; <S2SV_EndBug> } } | <S2SV_ModStart> memory ) ; assert ( block -> status = Taken ) ; |
2,805 | CWE-000 void <S2SV_StartBug> print_selected_inferior ( struct ui_out * uiout ) <S2SV_EndBug> { <S2SV_StartBug> struct inferior * inf = current_inferior ( ) ; <S2SV_EndBug> const char * filename = inf -> pspace -> pspace_exec_filename ; if ( filename == NULL ) filename = _ ( "<noexec>" ) ; uiout -> message ( _ ( "[Switching<S2SV_blank>to<S2SV_blank>inferior<S2SV_blank>%d<S2SV_blank>[%s]<S2SV_blank>(%s)]\\n" ) , inf -> num , inferior_pid_to_str ( inf -> pid ) , filename ) ; } | <S2SV_ModStart> ui_out * uiout , <S2SV_ModEnd> struct inferior * <S2SV_ModStart> inferior * inf ) { <S2SV_ModEnd> const char * |
2,806 | CWE-000 static void wakeup_source_deactivate ( struct wakeup_source * ws ) <S2SV_StartBug> { <S2SV_EndBug> ktime_t duration ; ktime_t now ; ws -> relax_count ++ ; if ( ws -> relax_count != ws -> active_count ) { ws -> relax_count -- ; return ; } ws -> active = false ; now = ktime_get ( ) ; duration = ktime_sub ( now , ws -> last_time ) ; ws -> total_time = ktime_add ( ws -> total_time , duration ) ; if ( ktime_to_ns ( duration ) > ktime_to_ns ( ws -> max_time ) ) ws -> max_time = duration ; ws -> last_time = now ; del_timer ( & ws -> timer ) ; ws -> timer_expires = 0 ; cec = atomic_add_return ( MAX_IN_PROGRESS , & combined_event_count ) ; trace_wakeup_source_deactivate ( ws -> name , cec ) ; } | <S2SV_ModStart> ws ) { unsigned int cec ; |
2,807 | CWE-000 struct socket * usrsctp_socket ( int domain , int type , int protocol , int ( * receive_cb ) ( struct socket * sock , union sctp_sockstore addr , void * data , size_t datalen , struct sctp_rcvinfo , int flags , void * ulp_info ) , int ( * send_cb ) ( struct socket * sock , uint32_t sb_free ) , uint32_t sb_threshold , void * ulp_info ) { struct socket * so ; <S2SV_StartBug> if ( ( protocol = IPPROTO_SCTP ) && ( SCTP_BASE_VAR ( sctp_pcb_initialized ) == 0 ) ) { <S2SV_EndBug> errno = EPROTONOSUPPORT ; return ( NULL ) ; } if ( ( receive_cb == NULL ) && ( ( send_cb != NULL ) || ( sb_threshold != 0 ) || ( ulp_info != NULL ) ) ) { errno = EINVAL ; return ( NULL ) ; } if ( ( domain == AF_CONN ) && ( SCTP_BASE_VAR ( conn_output ) == NULL ) ) { errno = EAFNOSUPPORT ; return ( NULL ) ; } errno = socreate ( domain , & so , type , protocol ) ; if ( errno ) { return ( NULL ) ; } register_recv_cb ( so , receive_cb ) ; register_send_cb ( so , sb_threshold , send_cb ) ; register_ulp_info ( so , ulp_info ) ; return ( so ) ; } | <S2SV_ModStart> ( ( protocol == <S2SV_ModEnd> IPPROTO_SCTP ) && |
2,808 | CWE-000 <S2SV_StartBug> int __exit ( char * * tokens ) <S2SV_EndBug> { int i ; if ( _strcmp ( tokens [ 0 ] , "exit" ) == 0 ) { i = _atoi ( tokens [ 1 ] ) ; if ( i > 0 ) { free ( tokens ) ; <S2SV_StartBug> exit ( i ) ; <S2SV_EndBug> } else <S2SV_StartBug> exit ( 0 ) ; <S2SV_EndBug> } return ( - 1 ) ; } | <S2SV_ModStart> * * tokens , char * line <S2SV_ModStart> tokens ) ; free ( line ) ; <S2SV_ModStart> ; } else { free ( line ) ; free ( tokens ) ; <S2SV_ModStart> 0 ) ; } |
2,809 | CWE-000 static void tick_handler ( struct tm * tick_time , TimeUnits units_changed ) { <S2SV_StartBug> update_time ( false ) ; <S2SV_EndBug> } | <S2SV_ModStart> { update_time ( units_changed & DAY_UNIT <S2SV_ModEnd> ) ; } |
2,810 | CWE-000 static int exec_cc_cb ( struct wtc_tmux_cc * cc , size_t start , size_t len , bool err ) { struct shl_ring * ring = & ( cc -> buf ) ; struct cb_dat * dat = cc -> userdata ; <S2SV_StartBug> char * * out = err ? dat -> err : dat -> out ; <S2SV_EndBug> if ( ! out ) { dat -> handled = true ; return 0 ; } size_t i = 0 ; if ( * out ) { i = strlen ( * out ) ; len += i ; } struct iovec vecs [ 2 ] ; size_t size , pos ; char val ; char * buf = calloc ( len + 1 , sizeof ( char ) ) ; if ( ! buf ) { crit ( "exec_cc_cb:<S2SV_blank>Couldn\'t<S2SV_blank>allocate<S2SV_blank>buffer!" ) ; return - ENOMEM ; } if ( * out ) memcpy ( buf , * out , i ) ; SHL_RING_ITERATE ( ring , val , vecs , size , pos ) { if ( pos < start ) { pos = start - 1 ; continue ; } if ( pos == start + len ) break ; if ( val == '\\0' ) continue ; buf [ i ++ ] = val ; } buf [ i ] = '\\0' ; if ( * out ) free ( * out ) ; * out = buf ; dat -> handled = true ; return 0 ; } | <S2SV_ModStart> -> out ; if ( cc -> compensate ) { cc -> compensate = false ; return 0 ; } |
2,811 | CWE-000 static int pico_ppp_poll ( struct pico_device * dev , int loop_score ) { struct pico_device_ppp * ppp = ( struct pico_device_ppp * ) dev ; static uint32_t len = 0 ; int r ; if ( ppp -> serial_recv ) { do { r = ppp -> serial_recv ( & ppp -> dev , & ppp_recv_buf [ len ] , 1 ) ; if ( r <= 0 ) break ; <S2SV_StartBug> if ( ppp -> modem_state == PPP_MODEM_STATE_CONNECTED ) { <S2SV_EndBug> static int control_escape = 0 ; if ( ppp_recv_buf [ len ] == PPPF_FLAG_SEQ ) { if ( control_escape ) { ppp_dbg ( "Illegal<S2SV_blank>sequence,<S2SV_blank>ppp_recv_buf[%d]<S2SV_blank>=<S2SV_blank>%d\\n" , len , ppp_recv_buf [ len ] ) ; control_escape = 0 ; len = 0 ; } if ( len > 1 ) { ppp_recv_data ( ppp , ppp_recv_buf , len ) ; loop_score -- ; len = 0 ; } } else if ( control_escape ) { ppp_recv_buf [ len ] ^= 0x20 ; control_escape = 0 ; len ++ ; } else if ( ppp_recv_buf [ len ] == PPPF_CTRL_ESC ) { control_escape = 1 ; } else { len ++ ; } } else { static int s3 = 0 ; if ( ppp_recv_buf [ len ] == AT_S3 ) { s3 = 1 ; if ( len > 0 ) { ppp_recv_buf [ len ] = '\\0' ; ppp_modem_recv ( ppp , ppp_recv_buf , len ) ; len = 0 ; } } else if ( ppp_recv_buf [ len ] == AT_S4 ) { if ( ! s3 ) { len ++ ; } s3 = 0 ; } else { s3 = 0 ; len ++ ; } } } while ( ( r > 0 ) && ( len < ARRAY_SIZE ( ppp_recv_buf ) ) && ( loop_score > 0 ) ) ; } return loop_score ; } | <S2SV_ModStart> ) break ; pppdump ( & ppp_recv_buf [ len ] , 1 , 0 ) ; |
2,812 | CWE-000 int SysLogger_Start ( void ) { pid_t sysloggerPid ; char * filename ; if ( ! Logging_collector ) return 0 ; # ifndef WIN32 if ( syslogPipe [ 0 ] < 0 ) { if ( pipe ( syslogPipe ) < 0 ) ereport ( FATAL , ( errcode_for_socket_access ( ) , ( errmsg ( "could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>pipe<S2SV_blank>for<S2SV_blank>syslog:<S2SV_blank>%m" ) ) ) ) ; } # else if ( ! syslogPipe [ 0 ] ) { SECURITY_ATTRIBUTES sa ; memset ( & sa , 0 , sizeof ( SECURITY_ATTRIBUTES ) ) ; sa . nLength = sizeof ( SECURITY_ATTRIBUTES ) ; sa . bInheritHandle = TRUE ; if ( ! CreatePipe ( & syslogPipe [ 0 ] , & syslogPipe [ 1 ] , & sa , 32768 ) ) ereport ( FATAL , ( errcode_for_file_access ( ) , ( errmsg ( "could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>pipe<S2SV_blank>for<S2SV_blank>syslog:<S2SV_blank>%m" ) ) ) ) ; } # endif mkdir ( Log_directory , S_IRWXU ) ; first_syslogger_file_time = time ( NULL ) ; filename = logfile_getname ( first_syslogger_file_time , NULL ) ; syslogFile = logfile_open ( filename , "a" , false ) ; pfree ( filename ) ; <S2SV_StartBug> # ifdef EXEC_BACKEND <S2SV_EndBug> switch ( ( sysloggerPid = syslogger_forkexec ( ) ) ) # else switch ( ( sysloggerPid = fork_process ( ) ) ) # endif { case - 1 : ereport ( LOG , ( errmsg ( "could<S2SV_blank>not<S2SV_blank>fork<S2SV_blank>system<S2SV_blank>logger:<S2SV_blank>%m" ) ) ) ; return 0 ; # ifndef EXEC_BACKEND case 0 : InitPostmasterChild ( ) ; ClosePostmasterPorts ( true ) ; dsm_detach_all ( ) ; PGSharedMemoryDetach ( ) ; SysLoggerMain ( 0 , NULL ) ; break ; # endif default : if ( ! redirection_done ) { # ifdef WIN32 int fd ; # endif ereport ( LOG , ( errmsg ( "redirecting<S2SV_blank>log<S2SV_blank>output<S2SV_blank>to<S2SV_blank>logging<S2SV_blank>collector<S2SV_blank>process" ) , errhint ( "Future<S2SV_blank>log<S2SV_blank>output<S2SV_blank>will<S2SV_blank>appear<S2SV_blank>in<S2SV_blank>directory<S2SV_blank>\\"%s\\"." , Log_directory ) ) ) ; # ifndef WIN32 fflush ( stdout ) ; if ( dup2 ( syslogPipe [ 1 ] , fileno ( stdout ) ) < 0 ) ereport ( FATAL , ( errcode_for_file_access ( ) , errmsg ( "could<S2SV_blank>not<S2SV_blank>redirect<S2SV_blank>stdout:<S2SV_blank>%m" ) ) ) ; fflush ( stderr ) ; if ( dup2 ( syslogPipe [ 1 ] , fileno ( stderr ) ) < 0 ) ereport ( FATAL , ( errcode_for_file_access ( ) , errmsg ( "could<S2SV_blank>not<S2SV_blank>redirect<S2SV_blank>stderr:<S2SV_blank>%m" ) ) ) ; close ( syslogPipe [ 1 ] ) ; syslogPipe [ 1 ] = - 1 ; # else fflush ( stderr ) ; fd = _open_osfhandle ( ( intptr_t ) syslogPipe [ 1 ] , _O_APPEND | _O_BINARY ) ; if ( dup2 ( fd , _fileno ( stderr ) ) < 0 ) ereport ( FATAL , ( errcode_for_file_access ( ) , errmsg ( "could<S2SV_blank>not<S2SV_blank>redirect<S2SV_blank>stderr:<S2SV_blank>%m" ) ) ) ; close ( fd ) ; _setmode ( _fileno ( stderr ) , _O_BINARY ) ; syslogPipe [ 1 ] = 0 ; # endif redirection_done = true ; } fclose ( syslogFile ) ; syslogFile = NULL ; <S2SV_StartBug> return ( int ) sysloggerPid ; <S2SV_EndBug> } return 0 ; } | <S2SV_ModStart> filename ) ; if ( Log_destination & LOG_DESTINATION_CSVLOG ) { filename = logfile_getname ( first_syslogger_file_time , ".csv" ) ; csvlogFile = logfile_open ( filename , "a" , false ) ; pfree ( filename ) ; } <S2SV_ModStart> = NULL ; if ( csvlogFile != NULL ) { fclose ( csvlogFile ) ; csvlogFile = NULL ; } |
2,813 | CWE-000 static void Init ( void * obj ) { AG_Console * cons = obj ; WIDGET ( cons ) -> flags |= AG_WIDGET_FOCUSABLE | AG_WIDGET_USE_TEXT ; cons -> flags = 0 ; cons -> padding = 4 ; cons -> lines = NULL ; cons -> lineskip = 0 ; cons -> nLines = 0 ; cons -> rOffs = 0 ; cons -> rVisible = 0 ; cons -> pm = NULL ; cons -> pos = - 1 ; cons -> sel = 0 ; cons -> r = AG_RECT ( 0 , 0 , 0 , 0 ) ; cons -> scrollTo = NULL ; cons -> vBar = AG_ScrollbarNew ( cons , AG_SCROLLBAR_VERT , AG_SCROLLBAR_NOAUTOHIDE | AG_SCROLLBAR_EXCL ) ; AG_WidgetSetFocusable ( cons -> vBar , 0 ) ; AG_SetUint ( cons -> vBar , "min" , 0 ) ; AG_BindUint ( cons -> vBar , "max" , & cons -> nLines ) ; AG_BindUint ( cons -> vBar , "visible" , & cons -> rVisible ) ; AG_BindUint ( cons -> vBar , "value" , & cons -> rOffs ) ; AG_ActionFn ( cons , "BeginSelect" , BeginSelect , NULL ) ; AG_ActionFn ( cons , "CloseSelect" , CloseSelect , NULL ) ; AG_ActionFn ( cons , "PopupMenu" , PopupMenu , NULL ) ; AG_ActionFn ( cons , "ScrollUp" , ScrollUp , NULL ) ; AG_ActionFn ( cons , "ScrollDown" , ScrollDown , NULL ) ; AG_ActionFn ( cons , "PageUp" , PageUp , NULL ) ; AG_ActionFn ( cons , "PageDown" , PageDown , NULL ) ; AG_ActionOnButtonDown ( cons , AG_MOUSE_LEFT , "BeginSelect" ) ; AG_ActionOnButtonUp ( cons , AG_MOUSE_LEFT , "CloseSelect" ) ; AG_ActionOnButtonDown ( cons , AG_MOUSE_RIGHT , "PopupMenu" ) ; AG_ActionOnButtonDown ( cons , AG_MOUSE_WHEELUP , "ScrollUp" ) ; AG_ActionOnButtonDown ( cons , AG_MOUSE_WHEELDOWN , "ScrollDown" ) ; AG_ActionOnKey ( cons , AG_KEY_UP , AG_KEYMOD_ANY , "ScrollUp" ) ; AG_ActionOnKey ( cons , AG_KEY_DOWN , AG_KEYMOD_ANY , "ScrollDown" ) ; AG_ActionOnKey ( cons , AG_KEY_PAGEUP , AG_KEYMOD_ANY , "PageUp" ) ; AG_ActionOnKey ( cons , AG_KEY_PAGEDOWN , AG_KEYMOD_ANY , "PageDown" ) ; AG_SetEvent ( cons , "mouse-motion" , MouseMotion , NULL ) ; AG_AddEvent ( cons , "font-changed" , OnFontChange , NULL ) ; AG_AddEvent ( cons , "widget-shown" , OnFontChange , NULL ) ; <S2SV_StartBug> # ifdef AG_DEBUG <S2SV_EndBug> AG_BindUint ( cons , "nLines" , & cons -> nLines ) ; AG_BindUint ( cons , "rOffs" , & cons -> rOffs ) ; AG_BindUint ( cons , "rVisible" , & cons -> rVisible ) ; AG_BindInt ( cons , "pos" , & cons -> pos ) ; AG_BindInt ( cons , "sel" , & cons -> sel ) ; # endif } | <S2SV_ModStart> ) ; # if 0 <S2SV_ModEnd> AG_BindUint ( cons |
2,814 | CWE-000 float sum_float ( float * a , float * b , int len ) { float result = 0 ; for ( int i = 0 ; i < len ; i ++ ) { <S2SV_StartBug> result += a [ i ] = b [ i ] ; <S2SV_EndBug> } return result ; } | <S2SV_ModStart> [ i ] + <S2SV_ModEnd> b [ i |
2,815 | CWE-000 void * psd_refresh ( void * data ) { pubsub_discovery_t * disc = data ; celixThreadMutex_lock ( & disc -> runningMutex ) ; bool running = disc -> running ; celixThreadMutex_unlock ( & disc -> runningMutex ) ; while ( running ) { struct timespec start ; clock_gettime ( CLOCK_MONOTONIC , & start ) ; celixThreadMutex_lock ( & disc -> announcedEndpointsMutex ) ; hash_map_iterator_t iter = hashMapIterator_construct ( disc -> announcedEndpoints ) ; while ( hashMapIterator_hasNext ( & iter ) ) { pubsub_announce_entry_t * entry = hashMapIterator_nextValue ( & iter ) ; if ( entry -> isSet ) { int rc = etcd_refresh ( entry -> key , disc -> ttlForEntries ) ; if ( rc != ETCDLIB_RC_OK ) { L_ERROR ( "[PSD]<S2SV_blank>Warning:<S2SV_blank>error<S2SV_blank>refreshing<S2SV_blank>etcd<S2SV_blank>key<S2SV_blank>%s\\n" , entry -> key ) ; entry -> isSet = false ; entry -> errorCount += 1 ; } else { entry -> refreshCount += 1 ; } } else { char * str = pubsub_discovery_createJsonEndpoint ( entry -> properties ) ; int rc = etcd_set ( entry -> key , str , disc -> ttlForEntries , false ) ; if ( rc == ETCDLIB_RC_OK ) { entry -> isSet = true ; entry -> setCount += 1 ; } else { L_ERROR ( "[PSD]<S2SV_blank>Warning:<S2SV_blank>error<S2SV_blank>setting<S2SV_blank>endpoint<S2SV_blank>in<S2SV_blank>etcd<S2SV_blank>for<S2SV_blank>key<S2SV_blank>%s\\n" , entry -> key ) ; entry -> errorCount += 1 ; } <S2SV_StartBug> } <S2SV_EndBug> } celixThreadMutex_unlock ( & disc -> announcedEndpointsMutex ) ; struct timespec waitTill = start ; waitTill . tv_sec += disc -> sleepInsecBetweenTTLRefresh ; pthread_mutex_lock ( & disc -> waitMutex ) ; pthread_cond_timedwait ( & disc -> waitCond , & disc -> waitMutex , & waitTill ) ; pthread_mutex_unlock ( & disc -> waitMutex ) ; celixThreadMutex_lock ( & disc -> runningMutex ) ; running = disc -> running ; celixThreadMutex_unlock ( & disc -> runningMutex ) ; } return NULL ; } | <S2SV_ModStart> 1 ; } free ( str ) ; |
2,816 | CWE-000 int mt76x0_init_hardware ( struct mt76x02_dev * dev ) { int ret , i , k ; if ( ! mt76x02_wait_for_wpdma ( & dev -> mt76 , 1000 ) ) return - EIO ; if ( ! mt76x02_wait_for_mac ( & dev -> mt76 ) ) return - ETIMEDOUT ; mt76x0_reset_csr_bbp ( dev ) ; ret = mt76x02_mcu_function_select ( dev , Q_SELECT , 1 , false ) ; if ( ret ) return ret ; mt76x0_init_mac_registers ( dev ) ; if ( ! mt76x02_wait_for_txrx_idle ( & dev -> mt76 ) ) return - EIO ; ret = mt76x0_init_bbp ( dev ) ; if ( ret ) return ret ; dev -> mt76 . rxfilter = mt76_rr ( dev , MT_RX_FILTR_CFG ) ; <S2SV_StartBug> ret = mt76x0_init_wcid_mem ( dev ) ; <S2SV_EndBug> if ( ret ) return ret ; for ( i = 0 ; i < 16 ; i ++ ) for ( k = 0 ; k < 4 ; k ++ ) mt76x02_mac_shared_key_setup ( dev , i , k , NULL ) ; <S2SV_StartBug> ret = mt76x0_init_wcid_attr_mem ( dev ) ; <S2SV_EndBug> if ( ret ) return ret ; mt76x0_reset_counters ( dev ) ; ret = mt76x0_eeprom_init ( dev ) ; if ( ret ) return ret ; mt76x0_phy_init ( dev ) ; mt76x02_init_beacon_config ( dev ) ; return 0 ; } | <S2SV_ModStart> MT_RX_FILTR_CFG ) ; <S2SV_ModEnd> for ( i <S2SV_ModStart> NULL ) ; for ( i = 0 ; i < 256 ; i ++ ) mt76x02_mac_wcid_setup ( dev , i , 0 , NULL ) <S2SV_ModEnd> ; mt76x0_reset_counters ( |
2,817 | CWE-000 int AINode_Seek_ActivateEntity ( bot_state_t * bs ) { bot_goal_t * goal ; vec3_t target , dir , ideal_viewangles ; bot_moveresult_t moveresult ; int targetvisible ; bsp_trace_t bsptrace ; aas_entityinfo_t entinfo ; if ( BotIsObserver ( bs ) ) { BotClearActivateGoalStack ( bs ) ; AIEnter_Observer ( bs , "active<S2SV_blank>entity:<S2SV_blank>observer" ) ; return qfalse ; } if ( BotIntermission ( bs ) ) { BotClearActivateGoalStack ( bs ) ; AIEnter_Intermission ( bs , "activate<S2SV_blank>entity:<S2SV_blank>intermission" ) ; return qfalse ; } if ( BotIsDead ( bs ) ) { BotClearActivateGoalStack ( bs ) ; AIEnter_Respawn ( bs , "activate<S2SV_blank>entity:<S2SV_blank>bot<S2SV_blank>dead" ) ; return qfalse ; } bs -> tfl = TFL_DEFAULT ; if ( BotInLavaOrSlime ( bs ) ) { bs -> tfl |= TFL_LAVA | TFL_SLIME ; } BotMapScripts ( bs ) ; bs -> enemy = - 1 ; if ( ! bs -> activatestack ) { BotClearActivateGoalStack ( bs ) ; AIEnter_Seek_NBG ( bs , "activate<S2SV_blank>entity:<S2SV_blank>no<S2SV_blank>goal" ) ; return qfalse ; } goal = & bs -> activatestack -> goal ; targetvisible = qfalse ; if ( bs -> activatestack -> shoot ) { BotAI_Trace ( & bsptrace , bs -> eye , NULL , NULL , bs -> activatestack -> target , bs -> entitynum , MASK_SHOT ) ; if ( bsptrace . fraction >= 1.0 || bsptrace . entityNum == goal -> entitynum ) { targetvisible = qtrue ; if ( bs -> cur_ps . weapon == bs -> activatestack -> weapon ) { VectorSubtract ( bs -> activatestack -> target , bs -> eye , dir ) ; vectoangles ( dir , ideal_viewangles ) ; if ( InFieldOfVision ( bs -> viewangles , 20 , ideal_viewangles ) ) { trap_EA_Attack ( bs -> client ) ; } } } } if ( targetvisible ) { BotEntityInfo ( goal -> entitynum , & entinfo ) ; if ( ! VectorCompare ( bs -> activatestack -> origin , entinfo . origin ) ) { # ifdef DEBUG BotAI_Print ( PRT_MESSAGE , "hit<S2SV_blank>shootable<S2SV_blank>button<S2SV_blank>or<S2SV_blank>trigger\\n" ) ; # endif bs -> activatestack -> time = 0 ; } if ( bs -> activatestack -> time < FloatTime ( ) ) { BotPopFromActivateGoalStack ( bs ) ; if ( bs -> activatestack ) { bs -> activatestack -> time = FloatTime ( ) + 10 ; return qfalse ; } AIEnter_Seek_NBG ( bs , "activate<S2SV_blank>entity:<S2SV_blank>time<S2SV_blank>out" ) ; return qfalse ; } memset ( & moveresult , 0 , sizeof ( bot_moveresult_t ) ) ; } else { if ( ! goal ) { bs -> activatestack -> time = 0 ; } else if ( ! bs -> activatestack -> shoot ) { if ( trap_BotTouchingGoal ( bs -> origin , goal ) ) { # ifdef DEBUG BotAI_Print ( PRT_MESSAGE , "touched<S2SV_blank>button<S2SV_blank>or<S2SV_blank>trigger\\n" ) ; # endif bs -> activatestack -> time = 0 ; } } if ( bs -> activatestack -> time < FloatTime ( ) ) { BotPopFromActivateGoalStack ( bs ) ; if ( bs -> activatestack ) { bs -> activatestack -> time = FloatTime ( ) + 10 ; return qfalse ; } AIEnter_Seek_NBG ( bs , "activate<S2SV_blank>entity:<S2SV_blank>activated" ) ; return qfalse ; } if ( BotAIPredictObstacles ( bs , goal ) ) { return qfalse ; } <S2SV_StartBug> BotSetupForMovement ( bs ) ; <S2SV_EndBug> trap_BotMoveToGoal ( & moveresult , bs -> ms , goal , bs -> tfl ) ; if ( moveresult . failure ) { trap_BotResetAvoidReach ( bs -> ms ) ; bs -> activatestack -> time = 0 ; } BotAIBlocked ( bs , & moveresult , qtrue ) ; } BotClearPath ( bs , & moveresult ) ; if ( bs -> activatestack -> shoot ) { if ( ! ( moveresult . flags & MOVERESULT_MOVEMENTVIEW ) ) { VectorSubtract ( bs -> activatestack -> target , bs -> eye , dir ) ; vectoangles ( dir , moveresult . ideal_viewangles ) ; moveresult . flags |= MOVERESULT_MOVEMENTVIEW ; } if ( ! ( moveresult . flags & MOVERESULT_MOVEMENTWEAPON ) ) { moveresult . flags |= MOVERESULT_MOVEMENTWEAPON ; bs -> activatestack -> weapon = BotSelectActivateWeapon ( bs ) ; if ( bs -> activatestack -> weapon == - 1 ) { bs -> activatestack -> weapon = 0 ; } moveresult . weapon = bs -> activatestack -> weapon ; } } if ( moveresult . flags & ( MOVERESULT_MOVEMENTVIEWSET | MOVERESULT_MOVEMENTVIEW | MOVERESULT_SWIMVIEW ) ) { VectorCopy ( moveresult . ideal_viewangles , bs -> ideal_viewangles ) ; } else if ( moveresult . flags & MOVERESULT_WAITING ) { if ( random ( ) < bs -> thinktime * 0.8 ) { BotRoamGoal ( bs , target ) ; VectorSubtract ( target , bs -> origin , dir ) ; vectoangles ( dir , bs -> ideal_viewangles ) ; bs -> ideal_viewangles [ 2 ] *= 0.5 ; } } else if ( ! ( bs -> flags & BFL_IDEALVIEWSET ) ) { if ( trap_BotMovementViewTarget ( bs -> ms , goal , bs -> tfl , 300 , target ) ) { VectorSubtract ( target , bs -> origin , dir ) ; vectoangles ( dir , bs -> ideal_viewangles ) ; } else { vectoangles ( moveresult . movedir , bs -> ideal_viewangles ) ; } bs -> ideal_viewangles [ 2 ] *= 0.5 ; } if ( moveresult . flags & MOVERESULT_MOVEMENTWEAPON ) { bs -> weaponnum = moveresult . weapon ; } if ( BotFindEnemy ( bs , - 1 ) ) { if ( BotWantsToRetreat ( bs ) ) { AIEnter_Battle_NBG ( bs , "activate<S2SV_blank>entity:<S2SV_blank>found<S2SV_blank>enemy" ) ; } else { trap_BotResetLastAvoidReach ( bs -> ms ) ; trap_BotEmptyGoalStack ( bs -> gs ) ; AIEnter_Battle_Fight ( bs , "activate<S2SV_blank>entity:<S2SV_blank>found<S2SV_blank>enemy" ) ; } BotClearActivateGoalStack ( bs ) ; } return qtrue ; } | <S2SV_ModStart> qfalse ; } <S2SV_ModEnd> trap_BotMoveToGoal ( & |
2,818 | CWE-000 static int getNextToken ( ParseContext * pParse , int iCol , const char * z , int n , Fts3Expr * * ppExpr , int * pnConsumed ) { sqlite3_tokenizer * pTokenizer = pParse -> pTokenizer ; sqlite3_tokenizer_module const * pModule = pTokenizer -> pModule ; int rc ; sqlite3_tokenizer_cursor * pCursor ; Fts3Expr * pRet = 0 ; int i = 0 ; for ( i = 0 ; i < n ; i ++ ) { if ( sqlite3_fts3_enable_parentheses && ( z [ i ] == '(' || z [ i ] == ')' ) ) break ; <S2SV_StartBug> if ( z [ i ] == '*' || z [ i ] == \'"\' ) break ; <S2SV_EndBug> } * pnConsumed = i ; rc = sqlite3Fts3OpenTokenizer ( pTokenizer , pParse -> iLangid , z , i , & pCursor ) ; if ( rc == SQLITE_OK ) { const char * zToken ; int nToken = 0 , iStart = 0 , iEnd = 0 , iPosition = 0 ; int nByte ; rc = pModule -> xNext ( pCursor , & zToken , & nToken , & iStart , & iEnd , & iPosition ) ; if ( rc == SQLITE_OK ) { nByte = sizeof ( Fts3Expr ) + sizeof ( Fts3Phrase ) + nToken ; pRet = ( Fts3Expr * ) fts3MallocZero ( nByte ) ; if ( ! pRet ) { rc = SQLITE_NOMEM ; } else { pRet -> eType = FTSQUERY_PHRASE ; pRet -> pPhrase = ( Fts3Phrase * ) & pRet [ 1 ] ; pRet -> pPhrase -> nToken = 1 ; pRet -> pPhrase -> iColumn = iCol ; pRet -> pPhrase -> aToken [ 0 ] . n = nToken ; pRet -> pPhrase -> aToken [ 0 ] . z = ( char * ) & pRet -> pPhrase [ 1 ] ; memcpy ( pRet -> pPhrase -> aToken [ 0 ] . z , zToken , nToken ) ; if ( iEnd < n && z [ iEnd ] == '*' ) { pRet -> pPhrase -> aToken [ 0 ] . isPrefix = 1 ; iEnd ++ ; } while ( 1 ) { if ( ! sqlite3_fts3_enable_parentheses && iStart > 0 && z [ iStart - 1 ] == '-' ) { pParse -> isNot = 1 ; iStart -- ; } else if ( pParse -> bFts4 && iStart > 0 && z [ iStart - 1 ] == '^' ) { pRet -> pPhrase -> aToken [ 0 ] . bFirst = 1 ; iStart -- ; } else { break ; } } } * pnConsumed = iEnd ; } else if ( i && rc == SQLITE_DONE ) { rc = SQLITE_OK ; } pModule -> xClose ( pCursor ) ; } * ppExpr = pRet ; return rc ; } | <S2SV_ModStart> ; if ( <S2SV_ModEnd> z [ i |
2,819 | CWE-000 <S2SV_StartBug> static int stmmac_hw_setup ( struct net_device * dev ) <S2SV_EndBug> { struct stmmac_priv * priv = netdev_priv ( dev ) ; int ret ; ret = init_dma_desc_rings ( dev ) ; if ( ret < 0 ) { pr_err ( "%s:<S2SV_blank>DMA<S2SV_blank>descriptors<S2SV_blank>initialization<S2SV_blank>failed\\n" , __func__ ) ; return ret ; } ret = stmmac_init_dma_engine ( priv ) ; if ( ret < 0 ) { pr_err ( "%s:<S2SV_blank>DMA<S2SV_blank>engine<S2SV_blank>initialization<S2SV_blank>failed\\n" , __func__ ) ; return ret ; } priv -> hw -> mac -> set_umac_addr ( priv -> ioaddr , dev -> dev_addr , 0 ) ; if ( priv -> plat -> bus_setup ) priv -> plat -> bus_setup ( priv -> ioaddr ) ; priv -> hw -> mac -> core_init ( priv -> ioaddr ) ; stmmac_set_mac ( priv -> ioaddr , true ) ; stmmac_dma_operation_mode ( priv ) ; stmmac_mmc_setup ( priv ) ; <S2SV_StartBug> ret = stmmac_init_ptp ( priv ) ; <S2SV_EndBug> if ( ret ) <S2SV_StartBug> pr_warn ( "%s:<S2SV_blank>failed<S2SV_blank>PTP<S2SV_blank>initialisation\\n" , __func__ ) ; <S2SV_EndBug> # ifdef CONFIG_STMMAC_DEBUG_FS ret = stmmac_init_fs ( dev ) ; if ( ret < 0 ) pr_warn ( "%s:<S2SV_blank>failed<S2SV_blank>debugFS<S2SV_blank>registration\\n" , __func__ ) ; # endif pr_debug ( "%s:<S2SV_blank>DMA<S2SV_blank>RX/TX<S2SV_blank>processes<S2SV_blank>started...\\n" , dev -> name ) ; priv -> hw -> dma -> start_tx ( priv -> ioaddr ) ; priv -> hw -> dma -> start_rx ( priv -> ioaddr ) ; if ( netif_msg_hw ( priv ) ) { priv -> hw -> mac -> dump_regs ( priv -> ioaddr ) ; priv -> hw -> dma -> dump_regs ( priv -> ioaddr ) ; } priv -> tx_lpi_timer = STMMAC_DEFAULT_TWT_LS ; priv -> eee_enabled = stmmac_eee_init ( priv ) ; stmmac_init_tx_coalesce ( priv ) ; if ( ( priv -> use_riwt ) && ( priv -> hw -> dma -> rx_watchdog ) ) { priv -> rx_riwt = MAX_DMA_RIWT ; priv -> hw -> dma -> rx_watchdog ( priv -> ioaddr , MAX_DMA_RIWT ) ; } if ( priv -> pcs && priv -> hw -> mac -> ctrl_ane ) priv -> hw -> mac -> ctrl_ane ( priv -> ioaddr , 0 ) ; return 0 ; } | <S2SV_ModStart> net_device * dev , bool init_ptp <S2SV_ModStart> priv ) ; if ( init_ptp ) { <S2SV_ModStart> __func__ ) ; } |
2,820 | CWE-000 <S2SV_StartBug> static void <S2SV_EndBug> gtk_range_scroll_controller_scroll ( GtkEventControllerScroll * scroll , gdouble dx , gdouble dy , GtkRange * range ) { GtkRangePrivate * priv = gtk_range_get_instance_private ( range ) ; gdouble scroll_unit , delta ; gboolean handled ; GtkOrientation move_orientation ; # ifdef GDK_WINDOWING_QUARTZ scroll_unit = 1 ; # else scroll_unit = gtk_adjustment_get_page_increment ( priv -> adjustment ) ; # endif if ( priv -> orientation == GTK_ORIENTATION_HORIZONTAL && dx != 0 ) { move_orientation = GTK_ORIENTATION_HORIZONTAL ; delta = dx * scroll_unit ; } else { move_orientation = GTK_ORIENTATION_VERTICAL ; delta = dy * scroll_unit ; } if ( delta != 0 && should_invert_move ( range , move_orientation ) ) delta = - delta ; g_signal_emit ( range , signals [ CHANGE_VALUE ] , 0 , GTK_SCROLL_JUMP , gtk_adjustment_get_value ( priv -> adjustment ) + delta , & handled ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> <S2SV_null> <S2SV_null> static gboolean <S2SV_ModEnd> gtk_range_scroll_controller_scroll ( GtkEventControllerScroll <S2SV_ModStart> handled ) ; return GDK_EVENT_STOP ; |
2,821 | CWE-000 static void on_style_changed ( CMKWidget * self_ , CMKStyle * style ) { clutter_content_invalidate ( clutter_actor_get_content ( CLUTTER_ACTOR ( self_ ) ) ) ; float padding = cmk_style_get_padding ( style ) ; ClutterMargin margin = { padding , padding , padding , padding } ; clutter_actor_set_margin ( CLUTTER_ACTOR ( CMK_BUTTON ( self_ ) -> text ) , & margin ) ; CMKColor color ; cmk_style_get_font_color_for_background ( style , "background" , & color ) ; ClutterColor cc = cmk_to_clutter_color ( & color ) ; clutter_text_set_color ( CMK_BUTTON ( self_ ) -> text , & cc ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> cc ) ; CMK_WIDGET_CLASS ( cmk_button_parent_class ) -> style_changed ( self_ , style ) ; |
2,822 | CWE-000 void arc2_gen_execute_delayslot ( DisasCtxt * ctx ) { static int in_delay_slot = false ; if ( ctx -> insn . limm_p == 0 && ! in_delay_slot ) { in_delay_slot = true ; uint32_t cpc = ctx -> cpc ; <S2SV_StartBug> uint32_t npc = ctx -> npc ; <S2SV_EndBug> uint32_t dpc = ctx -> dpc ; uint32_t pcl = ctx -> pcl ; insn_t insn = ctx -> insn ; int bstate = ctx -> bstate ; ctx -> cpc = ctx -> npc ; ctx -> pcl = ctx -> cpc & 0xfffffffc ; ++ ctx -> ds ; arc_decode ( ctx ) ; -- ctx -> ds ; <S2SV_StartBug> ctx -> cpc = cpc ; <S2SV_EndBug> <S2SV_StartBug> ctx -> npc = npc ; <S2SV_EndBug> ctx -> dpc = dpc ; ctx -> pcl = pcl ; ctx -> insn = insn ; ctx -> bstate = bstate ; in_delay_slot = false ; } return ; } | <S2SV_ModStart> ctx -> npc <S2SV_ModEnd> ; uint32_t pcl <S2SV_ModStart> ; ctx -> dpc = ctx -> npc ; ctx -> <S2SV_ModStart> npc = npc <S2SV_ModEnd> ; ctx -> |
2,823 | CWE-000 int <S2SV_StartBug> mono_mmap_map ( void * handle , gint64 offset , gint64 * size , int access , void * * mmap_handle , void * * base_address ) <S2SV_EndBug> { gint64 mmap_offset = 0 ; MmapHandle * fh = ( MmapHandle * ) handle ; MmapInstance res = { 0 } ; size_t eff_size = * size ; struct stat buf = { 0 } ; fstat ( fh -> fd , & buf ) ; * mmap_handle = NULL ; * base_address = NULL ; if ( offset > buf . st_size || ( ( eff_size + offset ) > buf . st_size && ! is_special_zero_size_file ( & buf ) ) ) return ACCESS_DENIED ; if ( eff_size == 0 ) eff_size = align_up_to_page_size ( buf . st_size ) - offset ; * size = eff_size ; mmap_offset = align_down_to_page_size ( offset ) ; eff_size += ( offset - mmap_offset ) ; res . address = mono_file_map ( ( size_t ) eff_size , acess_to_mmap_flags ( access ) , fh -> fd , mmap_offset , & res . free_handle ) ; res . length = eff_size ; if ( res . address ) { * mmap_handle = g_memdup ( & res , sizeof ( MmapInstance ) ) ; * base_address = ( char * ) res . address + ( offset - mmap_offset ) ; return 0 ; } return COULD_NOT_MAP_MEMORY ; } | <S2SV_ModStart> * * base_address , MonoError * error |
2,824 | CWE-000 static void test_basic_parse ( ) { single_basic_parse ( "\\"\\003\\"" , 0 ) ; single_basic_parse ( "/*<S2SV_blank>hello<S2SV_blank>*/\\"foo\\"" , 0 ) ; single_basic_parse ( "//<S2SV_blank>hello\\n\\"foo\\"" , 0 ) ; single_basic_parse ( "\\"foo\\"blue" , 0 ) ; single_basic_parse ( "\\"\\\\u0041\\\\u0042\\\\u0043\\"" , 0 ) ; single_basic_parse ( "[9,\'\\\\uDAD" , 0 ) ; single_basic_parse ( "null" , 0 ) ; single_basic_parse ( "NaN" , 0 ) ; single_basic_parse ( "-NaN" , 0 ) ; single_basic_parse ( "Inf" , 0 ) ; single_basic_parse ( "inf" , 0 ) ; single_basic_parse ( "Infinity" , 0 ) ; single_basic_parse ( "infinity" , 0 ) ; single_basic_parse ( "-Infinity" , 0 ) ; single_basic_parse ( "-infinity" , 0 ) ; <S2SV_StartBug> single_basic_parse ( "Infinity!" , 0 ) ; <S2SV_EndBug> single_basic_parse ( "Infinitynull" , 0 ) ; single_basic_parse ( "InfinityXXXX" , 0 ) ; single_basic_parse ( "-Infinitynull" , 0 ) ; single_basic_parse ( "-InfinityXXXX" , 0 ) ; single_basic_parse ( "Infinoodle" , 0 ) ; single_basic_parse ( "InfinAAA" , 0 ) ; single_basic_parse ( "-Infinoodle" , 0 ) ; single_basic_parse ( "-InfinAAA" , 0 ) ; single_basic_parse ( "True" , 0 ) ; single_basic_parse ( "False" , 0 ) ; single_basic_parse ( "12" , 0 ) ; single_basic_parse ( "12.3" , 0 ) ; single_basic_parse ( "12.3.4" , 0 ) ; single_basic_parse ( "2015-01-15" , 0 ) ; single_basic_parse ( "12.3xxx" , 0 ) ; single_basic_parse ( "{\\"FoO\\"<S2SV_blank><S2SV_blank>:<S2SV_blank><S2SV_blank><S2SV_blank>-12.3E512}" , 0 ) ; single_basic_parse ( "{\\"FoO\\"<S2SV_blank><S2SV_blank>:<S2SV_blank><S2SV_blank><S2SV_blank>-12.3E51.2}" , 0 ) ; single_basic_parse ( "[\\"\\\\n\\"]" , 0 ) ; single_basic_parse ( "[\\"\\\\nabc\\\\n\\"]" , 0 ) ; single_basic_parse ( "[null]" , 0 ) ; single_basic_parse ( "[]" , 0 ) ; single_basic_parse ( "[false]" , 0 ) ; single_basic_parse ( "[\\"abc\\",null,\\"def\\",12]" , 0 ) ; single_basic_parse ( "{}" , 0 ) ; single_basic_parse ( "{<S2SV_blank>\\"foo\\":<S2SV_blank>\\"bar\\"<S2SV_blank>}" , 0 ) ; single_basic_parse ( "{<S2SV_blank>\\"foo\\":<S2SV_blank>\\"bar\\",<S2SV_blank>\\"baz\\":<S2SV_blank>null,<S2SV_blank>\\"bool0\\":<S2SV_blank>true<S2SV_blank>}" , 0 ) ; single_basic_parse ( "{<S2SV_blank>\\"foo\\":<S2SV_blank>[null,<S2SV_blank>\\"foo\\"]<S2SV_blank>}" , 0 ) ; single_basic_parse ( "{<S2SV_blank>\\"abc\\":<S2SV_blank>12,<S2SV_blank>\\"foo\\":<S2SV_blank>\\"bar\\",<S2SV_blank>\\"bool0\\":<S2SV_blank>false,<S2SV_blank>\\"bool1\\":<S2SV_blank>true,<S2SV_blank>\\"arr\\":<S2SV_blank>[<S2SV_blank>1,<S2SV_blank>2,<S2SV_blank>3,<S2SV_blank>null,<S2SV_blank>5<S2SV_blank>]<S2SV_blank>}" , 0 ) ; single_basic_parse ( "{<S2SV_blank>\\"abc\\":<S2SV_blank>\\"blue\\nred\\\\ngreen\\"<S2SV_blank>}" , 0 ) ; single_basic_parse ( "[0e]" , 1 ) ; single_basic_parse ( "[0e+]" , 1 ) ; single_basic_parse ( "[0e+-1]" , 1 ) ; single_basic_parse ( "[18446744073709551616]" , 1 ) ; } | <S2SV_ModStart> ; single_basic_parse ( "{<S2SV_blank>\\"min\\":<S2SV_blank>Infinity,<S2SV_blank>\\"max\\":<S2SV_blank>-Infinity}" , 0 ) ; single_basic_parse ( |
2,825 | CWE-000 static int _core_do ( mb_interpreter_t * s , void * * l ) { int result = MB_FUNC_OK ; _ls_node_t * ast = 0 ; _ls_node_t * loop_begin_node = 0 ; _object_t * obj = 0 ; _object_t loop_cond ; _object_t * loop_cond_ptr = 0 ; mb_assert ( s && l ) ; ast = ( _ls_node_t * ) * l ; ast = ast -> next ; obj = ( _object_t * ) ast -> data ; if ( ! _IS_EOS ( obj ) ) { _handle_error_on_obj ( s , SE_RN_SYNTAX_ERROR , s -> source_file , DON ( ast ) , MB_FUNC_ERR , _exit , result ) ; } ast = ast -> next ; loop_cond_ptr = & loop_cond ; _MAKE_NIL ( loop_cond_ptr ) ; loop_begin_node = ast ; _loop_begin : ast = loop_begin_node ; obj = ( _object_t * ) ast -> data ; while ( ! _IS_FUNC ( obj , _core_until ) ) { result = _execute_statement ( s , & ast , true ) ; if ( result == MB_LOOP_BREAK ) { <S2SV_StartBug> if ( _skip_struct ( s , & ast , _core_do , _core_until ) != MB_FUNC_OK ) <S2SV_EndBug> goto _exit ; _skip_to ( s , & ast , 0 , _DT_EOS ) ; result = MB_FUNC_OK ; goto _exit ; } else if ( result == MB_SUB_RETURN && s -> last_routine ) { if ( ast ) ast = ast -> prev ; if ( ast ) ast = ast -> prev ; goto _exit ; } else if ( result != MB_FUNC_OK && result != MB_SUB_RETURN ) { goto _exit ; } obj = ( _object_t * ) ast -> data ; } obj = ( _object_t * ) ast -> data ; if ( ! _IS_FUNC ( obj , _core_until ) ) { _handle_error_on_obj ( s , SE_RN_UNTIL_EXPECTED , s -> source_file , DON ( ast ) , MB_FUNC_ERR , _exit , result ) ; } ast = ast -> next ; result = _calc_expression ( s , & ast , & loop_cond_ptr ) ; if ( result != MB_FUNC_OK ) goto _exit ; if ( loop_cond_ptr -> data . integer ) { if ( ast ) _skip_to ( s , & ast , 0 , _DT_EOS ) ; goto _exit ; } else { goto _loop_begin ; } _exit : * l = ast ; return result ; } | <S2SV_ModStart> , _core_do , 0 , |
2,826 | CWE-000 int piControlGetDeviceInfoList ( SDeviceInfo * pDev ) { piControlOpen ( ) ; if ( PiControlHandle_g < 0 ) <S2SV_StartBug> return - 1 ; <S2SV_EndBug> return ioctl ( PiControlHandle_g , KB_GET_DEVICE_INFO_LIST , pDev ) ; } | <S2SV_ModStart> 0 ) return PiControlHandle_g <S2SV_ModEnd> ; return ioctl |
2,827 | CWE-000 lval * builtin_eq ( lenv * e , lval * a ) { LASSERT_ARGC ( "=" , a , 2 ) ; lval * x = lval_pop ( a , 0 ) ; lval * y = lval_take ( a , 0 ) ; <S2SV_StartBug> x = lval_arith ( x , y , LT ) ; <S2SV_EndBug> if ( x -> type == LVAL_ERR ) { return x ; } ; x -> type = LVAL_BOOL ; x -> val . bool = lval_is_true ( x ) ; return x ; } | <S2SV_ModStart> , y , EQ <S2SV_ModEnd> ) ; if |
2,828 | CWE-000 void CheckHealth ( void ) { static bool memory_low_flag = false ; static bool high_mcu_temp_flag = false ; uint16_t unused_memory = StackCount ( ) ; if ( ! memory_low_flag && unused_memory < LOW_STACK_LIMIT ) { ErrorHandler_LogError ( LOW_STACK , unused_memory ) ; memory_low_flag = true ; WARNING ( "Low<S2SV_blank>memory:<S2SV_blank>%u" , unused_memory ) ; } int16_t temperature ; struct sensor_t * temperature_sensor = driverMCUTemperature_GetSensor ( ) ; if ( Sensor_GetValue ( temperature_sensor , & temperature ) ) { if ( ! high_mcu_temp_flag && temperature > HICH_MCU_TEMP_LIMIT ) { <S2SV_StartBug> ErrorHandler_LogError ( HICH_MCU_TEMP_LIMIT , ( int8_t ) temperature ) ; <S2SV_EndBug> high_mcu_temp_flag = true ; WARNING ( "High<S2SV_blank>MCU<S2SV_blank>temperature:<S2SV_blank>%d" , temperature ) ; } } sc_assert ( unused_memory > 0 ) ; } | <S2SV_ModStart> { ErrorHandler_LogError ( HIGH_MCU_TEMPERATURE <S2SV_ModEnd> , ( int8_t |
2,829 | CWE-000 <S2SV_StartBug> static int __scpi_dvfs_round_rate ( struct scpi_clk * clk , unsigned long rate ) <S2SV_EndBug> { int idx ; <S2SV_StartBug> u32 fmin = 0 , fmax = ~ 0 , ftmp ; <S2SV_EndBug> const struct scpi_opp * opp = clk -> info -> opps ; for ( idx = 0 ; idx < clk -> info -> count ; idx ++ , opp ++ ) { ftmp = opp -> freq ; <S2SV_StartBug> if ( ftmp >= ( u32 ) rate ) { <S2SV_EndBug> if ( ftmp <= fmax ) fmax = ftmp ; break ; } else if ( ftmp >= fmin ) { fmin = ftmp ; } } return fmax != ~ 0 ? fmax : fmin ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> static long <S2SV_ModEnd> __scpi_dvfs_round_rate ( struct <S2SV_ModStart> int idx ; unsigned long <S2SV_ModEnd> fmin = 0 <S2SV_ModStart> ( ftmp >= <S2SV_ModEnd> rate ) { |
2,830 | CWE-000 static void restore_location ( struct memfile * mf , struct rm * loc ) { unsigned int lflags1 ; unsigned short lflags2 ; int l = 0 , t = 0 ; lflags1 = mread32 ( mf ) ; loc -> typ = mread8 ( mf ) ; loc -> seenv = mread8 ( mf ) ; lflags2 = mread16 ( mf ) ; loc -> mem_bg = ( lflags1 >> 26 ) & 63 ; if ( flags . save_revision < 9 ) { <S2SV_StartBug> if ( loc -> mem_bg >= 36 && loc -> mem_bg <= 56 ) <S2SV_EndBug> loc -> mem_bg += 5 ; } loc -> mem_trap = ( lflags1 >> 21 ) & 31 ; loc -> mem_obj = ( lflags1 >> 11 ) & 1023 ; loc -> mem_obj_mn = ( lflags1 >> 2 ) & 511 ; loc -> mem_invis = ( lflags1 >> 1 ) & 1 ; loc -> mem_stepped = ( lflags1 >> 0 ) & 1 ; loc -> flags = ( lflags2 >> 11 ) & 31 ; loc -> horizontal = ( lflags2 >> 10 ) & 1 ; loc -> lit = ( lflags2 >> 9 ) & 1 ; loc -> waslit = ( lflags2 >> 8 ) & 1 ; loc -> roomno = ( lflags2 >> 2 ) & 63 ; loc -> edge = ( lflags2 >> 1 ) & 1 ; loc -> pile = ( lflags2 >> 0 ) & 1 ; switch ( loc -> mem_bg ) { case S_vodoor_memlt : loc -> mem_bg = S_vodoor ; l = t = 1 ; break ; case S_vodoor_meml : loc -> mem_bg = S_vodoor ; l = 1 ; break ; case S_vodoor_memt : loc -> mem_bg = S_vodoor ; t = 1 ; break ; case S_hodoor_memlt : loc -> mem_bg = S_hodoor ; l = t = 1 ; break ; case S_hodoor_meml : loc -> mem_bg = S_hodoor ; l = 1 ; break ; case S_hodoor_memt : loc -> mem_bg = S_hodoor ; t = 1 ; break ; case S_vcdoor_memlt : loc -> mem_bg = S_vcdoor ; l = t = 1 ; break ; case S_vcdoor_meml : loc -> mem_bg = S_vcdoor ; l = 1 ; break ; case S_vcdoor_memt : loc -> mem_bg = S_vcdoor ; t = 1 ; break ; case S_hcdoor_memlt : loc -> mem_bg = S_hcdoor ; l = t = 1 ; break ; case S_hcdoor_meml : loc -> mem_bg = S_hcdoor ; l = 1 ; break ; case S_hcdoor_memt : loc -> mem_bg = S_hcdoor ; t = 1 ; break ; } loc -> mem_door_l = l ; loc -> mem_door_t = t ; } | <S2SV_ModStart> mem_bg <= 56 && loc -> mem_bg != 44 |
2,831 | CWE-000 gpointer mono_create_jump_trampoline ( MonoDomain * domain , MonoMethod * method , gboolean add_sync_wrapper , MonoError * error ) { MonoJitInfo * ji ; gpointer code ; guint32 code_size = 0 ; error_init ( error ) ; <S2SV_StartBug> if ( mono_use_interpreter ) { <S2SV_EndBug> gpointer ret = mini_get_interp_callbacks ( ) -> create_method_pointer ( method , FALSE , error ) ; if ( ! mono_error_ok ( error ) ) return NULL ; return ret ; } code = mono_jit_find_compiled_method_with_jit_info ( domain , method , & ji ) ; if ( code && ! ji -> has_generic_jit_info && ! ( method -> iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED ) ) return code ; if ( mono_llvm_only ) { code = mono_jit_compile_method ( method , error ) ; if ( ! mono_error_ok ( error ) ) return NULL ; return code ; } mono_domain_lock ( domain ) ; code = g_hash_table_lookup ( domain_jit_info ( domain ) -> jump_trampoline_hash , method ) ; mono_domain_unlock ( domain ) ; if ( code ) return code ; code = mono_create_specific_trampoline ( method , MONO_TRAMPOLINE_JUMP , mono_domain_get ( ) , & code_size ) ; g_assert ( code_size ) ; ji = ( MonoJitInfo * ) mono_domain_alloc0 ( domain , MONO_SIZEOF_JIT_INFO ) ; ji -> code_start = code ; ji -> code_size = code_size ; ji -> d . method = method ; mono_jit_info_table_add ( domain , ji ) ; mono_domain_lock ( domain ) ; g_hash_table_insert ( domain_jit_info ( domain ) -> jump_trampoline_hash , method , ji -> code_start ) ; mono_domain_unlock ( domain ) ; return ji -> code_start ; } | <S2SV_ModStart> if ( mono_use_interpreter && ! mono_aot_only |
2,832 | CWE-000 void * readBuffer ( struct resolverStruct * resolverData ) { char name [ 100 ] ; char ip [ 100 ] ; <S2SV_StartBug> while ( * resolverData -> flag ) <S2SV_EndBug> { pthread_mutex_lock ( resolverData -> sharedArrayLock ) ; if ( * resolverData -> sharedArrayCounter >= 0 ) { printf ( "name:<S2SV_blank>%s\\n" , resolverData -> sharedBufferPtr [ * resolverData -> sharedArrayCounter ] ) ; if ( dnslookup ( resolverData -> sharedBufferPtr [ * resolverData -> sharedArrayCounter ] , ip , 100 ) == 0 ) fprintf ( resolverData -> outputFile , "%s,%s\\n" , resolverData -> sharedBufferPtr [ * resolverData -> sharedArrayCounter ] , ip ) ; else fprintf ( resolverData -> outputFile , "%s,\\n" , resolverData -> sharedBufferPtr [ * resolverData -> sharedArrayCounter ] ) ; printf ( "ip<S2SV_blank>address:<S2SV_blank>%s\\n" , ip ) ; free ( resolverData -> sharedBufferPtr [ * resolverData -> sharedArrayCounter ] ) ; * resolverData -> sharedArrayCounter -= 1 ; pthread_mutex_unlock ( resolverData -> sharedArrayLock ) ; } else { pthread_mutex_unlock ( resolverData -> sharedArrayLock ) ; usleep ( 100000 ) ; } } pthread_exit ( 0 ) ; } | <S2SV_ModStart> resolverData -> flag && resolverData -> sharedArrayCounter >= 0 |
2,833 | CWE-000 void parseSWF_GRADIENT ( FILE * f , struct SWF_GRADIENT * gradient , int level ) { int i ; gradient -> SpreadMode = readBits ( f , 2 ) ; gradient -> InterpolationMode = readBits ( f , 2 ) ; gradient -> NumGradients = readBits ( f , 4 ) ; if ( ( gradient -> NumGradients > 8 && level < 4 ) || ( gradient -> NumGradients > 15 && level == 4 ) ) { fprintf ( stderr , "%d<S2SV_blank>gradients<S2SV_blank>in<S2SV_blank>SWF_GRADiENT,<S2SV_blank>expected<S2SV_blank>a<S2SV_blank>max<S2SV_blank>of<S2SV_blank>%d\\n" , gradient -> NumGradients , level < 4 ? 8 : 15 ) ; <S2SV_StartBug> } <S2SV_EndBug> for ( i = 0 ; i < gradient -> NumGradients ; i ++ ) parseSWF_GRADIENTRECORD ( f , & ( gradient -> GradientRecords [ i ] ) , level ) ; } | <S2SV_ModStart> 15 ) ; gradient -> NumGradients = 8 ; |
2,834 | CWE-000 void char_set_defaults ( ) { # if PACKETVER_SUPPORTS_PINCODE charserv_config . pincode_config . pincode_enabled = true ; charserv_config . pincode_config . pincode_changetime = 0 ; charserv_config . pincode_config . pincode_maxtry = 3 ; charserv_config . pincode_config . pincode_force = true ; charserv_config . pincode_config . pincode_allow_repeated = false ; charserv_config . pincode_config . pincode_allow_sequential = false ; # endif charserv_config . charmove_config . char_move_enabled = true ; charserv_config . charmove_config . char_movetoused = true ; charserv_config . charmove_config . char_moves_unlimited = false ; charserv_config . char_config . char_per_account = 0 ; charserv_config . char_config . char_del_level = 0 ; charserv_config . char_config . char_del_delay = 86400 ; # if PACKETVER >= 20100803 charserv_config . char_config . char_del_option = 2 ; # else charserv_config . char_config . char_del_option = 1 ; # endif safestrncpy ( charserv_config . wisp_server_name , "Server" , sizeof ( charserv_config . wisp_server_name ) ) ; charserv_config . login_ip = 0 ; charserv_config . login_port = 6900 ; charserv_config . char_ip = 0 ; charserv_config . bind_ip = INADDR_ANY ; charserv_config . char_port = 6121 ; charserv_config . char_maintenance = 0 ; charserv_config . char_new = true ; charserv_config . char_new_display = 0 ; charserv_config . char_config . name_ignoring_case = false ; charserv_config . char_config . char_name_option = 0 ; safestrncpy ( charserv_config . char_config . unknown_char_name , "Unknown" , sizeof ( charserv_config . char_config . unknown_char_name ) ) ; safestrncpy ( charserv_config . char_config . char_name_letters , "" , sizeof ( charserv_config . char_config . char_name_letters ) ) ; charserv_config . save_log = 1 ; charserv_config . log_char = 1 ; charserv_config . log_inter = 1 ; charserv_config . char_check_db = 1 ; charserv_config . start_point [ 0 ] . map = mapindex_name2id ( MAP_DEFAULT_NAME ) ; charserv_config . start_point [ 0 ] . x = MAP_DEFAULT_X ; charserv_config . start_point [ 0 ] . y = MAP_DEFAULT_Y ; <S2SV_StartBug> charserv_config . start_point_count = 0 ; <S2SV_EndBug> charserv_config . start_items [ 0 ] . nameid = 1201 ; charserv_config . start_items [ 0 ] . amount = 1 ; charserv_config . start_items [ 0 ] . pos = 2 ; charserv_config . start_items [ 1 ] . nameid = 2301 ; charserv_config . start_items [ 1 ] . amount = 1 ; charserv_config . start_items [ 1 ] . pos = 16 ; charserv_config . console = 0 ; charserv_config . max_connect_user = - 1 ; charserv_config . gm_allow_group = - 1 ; charserv_config . autosave_interval = DEFAULT_AUTOSAVE_INTERVAL ; charserv_config . start_zeny = 0 ; charserv_config . guild_exp_rate = 100 ; safestrncpy ( charserv_config . default_map , "prontera" , MAP_NAME_LENGTH ) ; charserv_config . default_map_x = 156 ; charserv_config . default_map_y = 191 ; } | <S2SV_ModStart> . start_point_count = 1 <S2SV_ModEnd> ; charserv_config . |
2,835 | CWE-000 PHP_FUNCTION ( openssl_seal ) { zval * pubkeys , * * pubkey , * sealdata , * ekeys ; HashTable * pubkeysht ; HashPosition pos ; EVP_PKEY * * pkeys ; long * key_resources ; int i , len1 , len2 , * eksl , nkeys ; unsigned char * buf = NULL , * * eks ; char * data ; int data_len ; char * method = NULL ; int method_len = 0 ; const EVP_CIPHER * cipher ; EVP_CIPHER_CTX ctx ; if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , "szza/|s" , & data , & data_len , & sealdata , & ekeys , & pubkeys , & method , & method_len ) == FAILURE ) { return ; } pubkeysht = HASH_OF ( pubkeys ) ; nkeys = pubkeysht ? zend_hash_num_elements ( pubkeysht ) : 0 ; if ( ! nkeys ) { php_error_docref ( NULL TSRMLS_CC , E_WARNING , "Fourth<S2SV_blank>argument<S2SV_blank>to<S2SV_blank>openssl_seal()<S2SV_blank>must<S2SV_blank>be<S2SV_blank>a<S2SV_blank>non-empty<S2SV_blank>array" ) ; RETURN_FALSE ; } if ( method ) { cipher = EVP_get_cipherbyname ( method ) ; if ( ! cipher ) { php_error_docref ( NULL TSRMLS_CC , E_WARNING , "Unknown<S2SV_blank>signature<S2SV_blank>algorithm." ) ; RETURN_FALSE ; } } else { cipher = EVP_rc4 ( ) ; } pkeys = safe_emalloc ( nkeys , sizeof ( * pkeys ) , 0 ) ; eksl = safe_emalloc ( nkeys , sizeof ( * eksl ) , 0 ) ; eks = safe_emalloc ( nkeys , sizeof ( * eks ) , 0 ) ; memset ( eks , 0 , sizeof ( * eks ) * nkeys ) ; key_resources = safe_emalloc ( nkeys , sizeof ( long ) , 0 ) ; memset ( key_resources , 0 , sizeof ( * key_resources ) * nkeys ) ; zend_hash_internal_pointer_reset_ex ( pubkeysht , & pos ) ; i = 0 ; while ( zend_hash_get_current_data_ex ( pubkeysht , ( void * * ) & pubkey , & pos ) == SUCCESS ) { pkeys [ i ] = php_openssl_evp_from_zval ( pubkey , 1 , NULL , 0 , & key_resources [ i ] TSRMLS_CC ) ; if ( pkeys [ i ] == NULL ) { php_error_docref ( NULL TSRMLS_CC , E_WARNING , "not<S2SV_blank>a<S2SV_blank>public<S2SV_blank>key<S2SV_blank>(%dth<S2SV_blank>member<S2SV_blank>of<S2SV_blank>pubkeys)" , i + 1 ) ; RETVAL_FALSE ; goto clean_exit ; } eks [ i ] = emalloc ( EVP_PKEY_size ( pkeys [ i ] ) + 1 ) ; zend_hash_move_forward_ex ( pubkeysht , & pos ) ; i ++ ; } if ( ! EVP_EncryptInit ( & ctx , cipher , NULL , NULL ) ) { RETVAL_FALSE ; EVP_CIPHER_CTX_cleanup ( & ctx ) ; goto clean_exit ; } # if 0 ivlen = EVP_CIPHER_CTX_iv_length ( & ctx ) ; iv = ivlen ? emalloc ( ivlen + 1 ) : NULL ; # endif buf = emalloc ( data_len + EVP_CIPHER_CTX_block_size ( & ctx ) ) ; EVP_CIPHER_CTX_cleanup ( & ctx ) ; <S2SV_StartBug> if ( ! EVP_SealInit ( & ctx , cipher , eks , eksl , NULL , pkeys , nkeys ) || ! EVP_SealUpdate ( & ctx , buf , & len1 , ( unsigned char * ) data , data_len ) ) { <S2SV_EndBug> RETVAL_FALSE ; efree ( buf ) ; EVP_CIPHER_CTX_cleanup ( & ctx ) ; goto clean_exit ; } <S2SV_StartBug> EVP_SealFinal ( & ctx , buf + len1 , & len2 ) ; <S2SV_EndBug> if ( len1 + len2 > 0 ) { zval_dtor ( sealdata ) ; buf [ len1 + len2 ] = '\\0' ; buf = erealloc ( buf , len1 + len2 + 1 ) ; ZVAL_STRINGL ( sealdata , ( char * ) buf , len1 + len2 , 0 ) ; zval_dtor ( ekeys ) ; array_init ( ekeys ) ; for ( i = 0 ; i < nkeys ; i ++ ) { eks [ i ] [ eksl [ i ] ] = '\\0' ; add_next_index_stringl ( ekeys , erealloc ( eks [ i ] , eksl [ i ] + 1 ) , eksl [ i ] , 0 ) ; eks [ i ] = NULL ; } # if 0 zval_dtor ( * ivec ) ; if ( ivlen ) { iv [ ivlen ] = '\\0' ; ZVAL_STRINGL ( * ivec , erealloc ( iv , ivlen + 1 ) , ivlen , 0 ) ; } else { ZVAL_EMPTY_STRING ( * ivec ) ; } # endif } else { efree ( buf ) ; } RETVAL_LONG ( len1 + len2 ) ; EVP_CIPHER_CTX_cleanup ( & ctx ) ; clean_exit : for ( i = 0 ; i < nkeys ; i ++ ) { if ( key_resources [ i ] == - 1 ) { EVP_PKEY_free ( pkeys [ i ] ) ; } if ( eks [ i ] ) { efree ( eks [ i ] ) ; } } efree ( eks ) ; efree ( eksl ) ; efree ( pkeys ) ; efree ( key_resources ) ; } | <S2SV_ModStart> ; if ( <S2SV_ModEnd> EVP_SealInit ( & <S2SV_ModStart> , nkeys ) <= 0 <S2SV_ModStart> , data_len ) || ! EVP_SealFinal ( & ctx , buf + len1 , & len2 ) <S2SV_ModStart> clean_exit ; } <S2SV_ModEnd> if ( len1 |
2,836 | CWE-000 <S2SV_StartBug> int prettify_path_i ( const char path [ PATH_MAX ] , const char home [ PATH_MAX ] ) { <S2SV_EndBug> const int hlen = strlen ( home ) ; if ( ! memcmp ( path , home , hlen ) ) { return hlen ; } return 0 ; } | <S2SV_ModStart> ( const char * path <S2SV_ModEnd> , const char <S2SV_ModStart> , const char * home <S2SV_ModEnd> ) { const |
2,837 | CWE-000 lua_State * mtev_lua_open ( const char * module_name , void * lmc , const char * script_dir , const char * cpath ) { int rv ; const char * existing_ppath , * existing_cpath ; char * npath ; lua_State * L = luaL_newstate ( ) , * * Lptr ; lua_atpanic ( L , & mtev_lua_panic ) ; lua_gc ( L , LUA_GCSTOP , 0 ) ; luaL_openlibs ( L ) ; if ( MTEV_JIT_OFF ( ) ) { lua_getglobal ( L , "jit" ) ; lua_getfield ( L , - 1 , "off" ) ; lua_call ( L , 0 , 0 ) ; lua_pop ( L , 1 ) ; } if ( MTEV_JIT_OPT ( ) >= 0 ) { lua_getglobal ( L , "jit" ) ; lua_getfield ( L , - 1 , "opt" ) ; lua_getfield ( L , - 1 , "start" ) ; lua_pushinteger ( L , MTEV_JIT_OPT ( ) ) ; lua_call ( L , 1 , 0 ) ; lua_pop ( L , 2 ) ; } lua_newtable ( L ) ; lua_setglobal ( L , "mtev_coros" ) ; if ( lmc ) { lua_pushlightuserdata ( L , lmc ) ; lua_setglobal ( L , "mtev_internal_lmc" ) ; } lua_getglobal ( L , "package" ) ; lua_getfield ( L , - 1 , "path" ) ; existing_ppath = lua_tostring ( L , - 1 ) ; lua_pop ( L , 1 ) ; lua_getfield ( L , - 1 , "cpath" ) ; existing_cpath = lua_tostring ( L , - 1 ) ; lua_pop ( L , 1 ) ; if ( ! script_dir ) script_dir = "{mtev.lua_path};{package.path}" ; npath = strdup ( script_dir ) ; npath = package_manip_path ( npath , "{package.path}" , existing_ppath ) ; npath = package_manip_path ( npath , "{mtev.lua_path}" , MTEV_MODULES_DIR "/lua/?.lua" ) ; lua_pushfstring ( L , "%s" , npath ) ; free ( npath ) ; lua_setfield ( L , - 2 , "path" ) ; if ( ! cpath ) cpath = "{mtev.lua_cpath};{package.cpath}" ; npath = strdup ( cpath ) ; npath = package_manip_path ( npath , "{package.cpath}" , existing_cpath ) ; npath = package_manip_path ( npath , "{mtev.lua_cpath}" , MTEV_LIB_DIR "/mtev_lua/?.so" ) ; lua_pushfstring ( L , "%s" , npath ) ; free ( npath ) ; lua_setfield ( L , - 2 , "cpath" ) ; lua_pop ( L , 1 ) ; require ( L , rv , ffi ) ; require ( L , rv , mtev ) ; require ( L , rv , mtev . timeval ) ; require ( L , rv , mtev . extras ) ; lua_gc ( L , LUA_GCRESTART , 0 ) ; <S2SV_StartBug> Lptr = malloc ( sizeof ( * Lptr ) ) ; <S2SV_EndBug> * Lptr = L ; <S2SV_StartBug> if ( lmc ) { <S2SV_EndBug> pthread_mutex_lock ( & mtev_lua_states_lock ) ; mtev_hash_store ( & mtev_lua_states , ( const char * ) Lptr , sizeof ( * Lptr ) , lmc ) ; pthread_mutex_unlock ( & mtev_lua_states_lock ) ; } return L ; } | <S2SV_ModStart> 0 ) ; if ( lmc ) { <S2SV_ModStart> = L ; <S2SV_ModEnd> pthread_mutex_lock ( & |
2,838 | CWE-000 int ffapi_write_frame ( FFContext * out , AVFrame * frame ) { AVFrame * writeframe = out -> swsframe ; <S2SV_StartBug> if ( out -> sws ) sws_scale ( out -> sws , ( const uint8_t * const * ) frame -> data , frame -> linesize , 0 , out -> st -> codec -> height , out -> swsframe -> data , out -> swsframe -> linesize ) ; <S2SV_EndBug> else writeframe = frame ; <S2SV_StartBug> AVCodecContext * codec = out -> st -> codec ; <S2SV_EndBug> <S2SV_StartBug> writeframe -> pts = frame -> pts ? frame -> pts : codec -> frame_number ; <S2SV_EndBug> <S2SV_StartBug> AVPacket packet = { 0 } ; <S2SV_EndBug> av_init_packet ( & packet ) ; int got_packet ; <S2SV_StartBug> int result = avcodec_encode_video2 ( codec , & packet , writeframe , & got_packet ) ; <S2SV_EndBug> if ( got_packet ) { if ( packet . pts != AV_NOPTS_VALUE ) packet . pts = av_rescale_q ( packet . pts , codec -> time_base , out -> st -> time_base ) ; else packet . pts = av_frame_get_best_effort_timestamp ( writeframe ) ; <S2SV_StartBug> if ( packet . dts != AV_NOPTS_VALUE ) <S2SV_EndBug> packet . dts = av_rescale_q ( packet . dts , codec -> time_base , out -> st -> time_base ) ; packet . stream_index = out -> st -> index ; result = av_write_frame ( out -> fmt , & packet ) ; av_packet_unref ( & packet ) ; } <S2SV_StartBug> return result ; <S2SV_EndBug> } | <S2SV_ModStart> -> st -> codecpar <S2SV_ModEnd> -> height , <S2SV_ModStart> = out -> <S2SV_ModEnd> codec ; writeframe <S2SV_ModStart> -> pts = <S2SV_ModEnd> codec -> frame_number <S2SV_ModStart> -> frame_number ; avcodec_send_frame <S2SV_ModEnd> ( codec , <S2SV_ModStart> ( codec , <S2SV_ModEnd> writeframe ) ; <S2SV_ModStart> writeframe ) ; return flush_frame ( out , writeframe <S2SV_ModEnd> ) ; } <S2SV_ModStart> ) ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
2,839 | CWE-000 ret_t check_icc ( ctiff_t * ctif ) { ret_t ret ; ret . value_found = malloc ( VALUESTRLEN ) ; if ( NULL == ret . value_found ) { ret . returncode = could_not_allocate_memory ; return ret ; } tifp_check ( ctif ) ; ifd_entry_t ifd_entry = TIFFGetRawIFDEntry ( ctif , TIFFTAG_ICCPROFILE ) ; uint32 icc_profile_size ; uint32 count ; char * icc_profile = NULL ; switch ( ifd_entry . datatype ) { case TIFF_UNDEFINED : { icc_profile_size = ifd_entry . count ; count = ifd_entry . count ; if ( ifd_entry . value_or_offset == is_offset ) { offset_t offset = read_offsetdata ( ctif , ifd_entry . data32offset , count , ifd_entry . datatype ) ; icc_profile = ( char * ) offset . data32p ; } else { ret . returncode = tagerror_encoded_as_value_excited_space ; return ret ; } break ; } default : { ret . value_found = strncpy ( ret . value_found , TIFFTypeName ( ifd_entry . datatype ) , VALUESTRLEN ) ; ret . returncode = tagerror_unexpected_type_found ; return ret ; break ; } ; } char * errmessage = malloc ( sizeof ( char ) * VALUESTRLEN ) ; unsigned long errsize = VALUESTRLEN ; icc_returncode_t icc_ret = parse_icc ( icc_profile_size , icc_profile , errsize , errmessage ) ; switch ( icc_ret ) { case icc_is_valid : ret . returncode = is_valid ; break ; case icc_error_profileclass : ret . returncode = iccerror_profileclass ; break ; case icc_error_colorspacedata : ret . returncode = iccerror_colorspacedata ; break ; case icc_error_connectionspacedata : ret . returncode = iccerror_connectionspacedata ; break ; case icc_error_primaryplatformsignature : ret . returncode = iccerror_primaryplatformsignature ; break ; case icc_error_header_1v43_2010 : ret . returncode = iccerror_header_1v43_2010 ; break ; case icc_error_header_v240_v430 : ret . returncode = iccerror_header_v240_v430 ; break ; case icc_error_header_generic : ret . returncode = iccerror_header_generic ; break ; case icc_error_preferredcmmtype : ret . returncode = iccerror_preferredcmmtype ; break ; <S2SV_StartBug> } <S2SV_EndBug> ret . value_found = strncpy ( ret . value_found , errmessage , VALUESTRLEN ) ; free ( errmessage ) ; return ret ; } | <S2SV_ModStart> ; break ; case icc_error_committed_size_differs : ret . returncode = iccerror_committed_size_differs ; break ; case icc_should_not_occure : ret . returncode = should_not_occure ; break ; |
2,840 | CWE-000 static int iso_stream_schedule ( struct ehci_hcd * ehci , struct urb * urb , struct ehci_iso_stream * stream ) { u32 now , base , next , start , period , span ; int status ; unsigned mod = ehci -> periodic_size << 3 ; struct ehci_iso_sched * sched = urb -> hcpriv ; period = urb -> interval ; span = sched -> span ; if ( ! stream -> highspeed ) { period <<= 3 ; span <<= 3 ; } now = ehci_read_frame_index ( ehci ) & ( mod - 1 ) ; if ( likely ( ! list_empty ( & stream -> td_list ) ) ) { if ( ehci -> i_thresh ) next = now + ehci -> i_thresh ; else next = ( now + 2 + 7 ) & ~ 0x07 ; base = ehci -> last_iso_frame << 3 ; next = ( next - base ) & ( mod - 1 ) ; start = ( stream -> next_uframe - base ) & ( mod - 1 ) ; if ( unlikely ( start < period ) ) { ehci_dbg ( ehci , "iso<S2SV_blank>sched<S2SV_blank>full<S2SV_blank>%p<S2SV_blank>(%u-%u<S2SV_blank><<S2SV_blank>%u<S2SV_blank>mod<S2SV_blank>%u)\\n" , urb , stream -> next_uframe , base , period , mod ) ; status = - ENOSPC ; goto fail ; } if ( unlikely ( start < next ) ) { <S2SV_StartBug> if ( urb -> transfer_flags & URB_ISO_ASAP ) <S2SV_EndBug> start += ( next - start + period - 1 ) & - period ; <S2SV_StartBug> else if ( start + span - period < next ) { <S2SV_EndBug> <S2SV_StartBug> ehci_dbg ( ehci , "iso<S2SV_blank>urb<S2SV_blank>late<S2SV_blank>%p<S2SV_blank>(%u+%u<S2SV_blank><<S2SV_blank>%u)\\n" , <S2SV_EndBug> urb , start + base , span - period , next + base ) ; status = - EXDEV ; goto fail ; } } start += base ; } else { int done = 0 ; base = now & ~ 0x07 ; start = base + SCHEDULING_DELAY ; next = start ; start += period ; do { start -- ; if ( stream -> highspeed ) { if ( itd_slot_ok ( ehci , mod , start , stream -> usecs , period ) ) done = 1 ; } else { if ( ( start % 8 ) >= 6 ) continue ; if ( sitd_slot_ok ( ehci , mod , stream , start , sched , period ) ) done = 1 ; } } while ( start > next && ! done ) ; if ( ! done ) { ehci_dbg ( ehci , "iso<S2SV_blank>sched<S2SV_blank>full<S2SV_blank>%p" , urb ) ; status = - ENOSPC ; goto fail ; } } if ( unlikely ( start - base + span - period >= mod ) ) { ehci_dbg ( ehci , "request<S2SV_blank>%p<S2SV_blank>would<S2SV_blank>overflow<S2SV_blank>(%u+%u<S2SV_blank>>=<S2SV_blank>%u)\\n" , urb , start - base , span - period , mod ) ; status = - EFBIG ; goto fail ; } stream -> next_uframe = start & ( mod - 1 ) ; urb -> start_frame = stream -> next_uframe ; if ( ! stream -> highspeed ) urb -> start_frame >>= 3 ; if ( ehci -> isoc_count == 0 ) ehci -> last_iso_frame = now >> 3 ; return 0 ; fail : iso_sched_free ( stream , sched ) ; urb -> hcpriv = NULL ; return status ; } | <S2SV_ModStart> ) ) { unsigned now2 = ( now - base ) & ( mod - 1 ) ; <S2SV_ModStart> - period < now2 <S2SV_ModEnd> ) { ehci_dbg <S2SV_ModStart> ( ehci , "iso<S2SV_blank>underrun<S2SV_blank>%p<S2SV_blank>(%u+%u<S2SV_blank><<S2SV_blank>%u)\\n" , urb , start + base , span - period , now2 + base ) <S2SV_ModEnd> ; } } |
2,841 | CWE-000 int z_clock_driver_init ( struct device * device ) { NVIC_SetPriority ( SysTick_IRQn , _IRQ_PRIO_OFFSET ) ; SysTick -> CTRL |= ( SysTick_CTRL_ENABLE_Msk | SysTick_CTRL_TICKINT_Msk | SysTick_CTRL_CLKSOURCE_Msk ) ; <S2SV_StartBug> last_load = IS_ENABLED ( CONFIG_TICKLESS_KERNEL ) ? <S2SV_EndBug> MAX_CYCLES : CYC_PER_TICK ; SysTick -> LOAD = last_load ; SysTick -> VAL = 0 ; return 0 ; } | <S2SV_ModStart> ; last_load = <S2SV_ModEnd> CYC_PER_TICK ; SysTick |
2,842 | CWE-000 static void row_add_request ( struct request_queue * q , struct request * rq ) { struct row_data * rd = ( struct row_data * ) q -> elevator -> elevator_data ; struct row_queue * rqueue = RQ_ROWQ ( rq ) ; list_add_tail ( & rq -> queuelist , & rqueue -> fifo ) ; rd -> nr_reqs [ rq_data_dir ( rq ) ] ++ ; rq_set_fifo_time ( rq , jiffies ) ; if ( queue_idling_enabled [ rqueue -> prio ] ) { if ( delayed_work_pending ( & rd -> read_idle . idle_work ) ) ( void ) cancel_delayed_work ( & rd -> read_idle . idle_work ) ; <S2SV_StartBug> if ( time_before ( jiffies , rqueue -> idle_data . idle_trigger_time ) ) { <S2SV_EndBug> rqueue -> idle_data . begin_idling = true ; row_log_rowq ( rd , rqueue -> prio , "Enable<S2SV_blank>idling" ) ; <S2SV_StartBug> } else <S2SV_EndBug> rqueue -> idle_data . begin_idling = false ; <S2SV_StartBug> rqueue -> idle_data . idle_trigger_time = <S2SV_EndBug> jiffies + msecs_to_jiffies ( rd -> read_idle . freq ) ; } <S2SV_StartBug> row_log_rowq ( rd , rqueue -> prio , "added<S2SV_blank>request" ) ; <S2SV_EndBug> } | <S2SV_ModStart> ; if ( ktime_to_ms ( ktime_sub ( ktime_get ( ) , rqueue -> idle_data . last_insert_time ) ) < rd -> read_idle . freq <S2SV_ModEnd> ) { rqueue <S2SV_ModStart> ; } else { <S2SV_ModStart> = false ; <S2SV_ModEnd> row_log_rowq ( rd <S2SV_ModStart> -> prio , "Disable<S2SV_blank>idling" ) ; } rqueue -> idle_data . last_insert_time = ktime_get ( ) ; } row_log_rowq ( rd , rqueue -> prio , |
2,843 | CWE-000 dbitem * item2db ( item * it ) { printf ( "item2db<S2SV_blank>begin\\n" ) ; <S2SV_StartBug> dbitem * dbit = ( dbitem * ) malloc ( sizeof ( dbitem ) ) ; <S2SV_EndBug> <S2SV_StartBug> memset ( dbit , 0 , sizeof ( dbitem ) ) ; <S2SV_EndBug> dbit -> exptime = it -> exptime ; dbit -> nbytes = it -> nbytes ; dbit -> nsuffix = it -> nsuffix ; dbit -> it_flags = it -> it_flags ; dbit -> nkey = it -> nkey ; memcpy ( DBITEM_key ( dbit ) , ITEM_key ( it ) , dbit -> nkey ) ; <S2SV_StartBug> memcpy ( DBITEM_data ( dbit ) , ITEM_suffix ( it ) , dbit -> nsuffix ) ; <S2SV_EndBug> memcpy ( DBITEM_data ( dbit ) , ITEM_data ( it ) , dbit -> nbytes ) ; printf ( "item2db<S2SV_blank>end\\n" ) ; return dbit ; } | <S2SV_ModStart> ) malloc ( ITEM_ntotal ( it <S2SV_ModEnd> ) ) ; <S2SV_ModStart> , sizeof ( ITEM_ntotal ( it ) <S2SV_ModEnd> ) ) ; <S2SV_ModStart> ; memcpy ( DBITEM_suffix <S2SV_ModEnd> ( dbit ) <S2SV_ModStart> dbit -> nsuffix ) ; printf ( "copy<S2SV_blank>nbytes<S2SV_blank>is<S2SV_blank>%d\\n" , dbit -> nbytes |
2,844 | CWE-000 uint16_t read_short ( char * * pptr ) { char * ptr = * pptr ; <S2SV_StartBug> int i = ( uint16_t ) ( * ptr ) << 8 ; <S2SV_EndBug> <S2SV_StartBug> i += ( uint16_t ) ( * ( ptr + 1 ) ) ; <S2SV_EndBug> * pptr += 2 ; return i ; } | <S2SV_ModStart> * pptr ; uint16_t <S2SV_ModEnd> i = ( <S2SV_ModStart> i = ( ( uint8_t <S2SV_ModEnd> ) ( * <S2SV_ModStart> ( * ptr ) <S2SV_ModStart> i += ( uint8_t <S2SV_ModEnd> ) ( * |
2,845 | CWE-000 TFTPD_TC_DEFINE ( wrq_medium , ) { int fd ; size_t i ; ssize_t r ; uint32_t contents [ 192 ] ; char buffer [ 1024 ] ; for ( i = 0 ; i < nitems ( contents ) ; i ++ ) contents [ i ] = i ; fd = open ( "medium.txt" , O_RDWR | O_CREAT , 0666 ) ; ATF_REQUIRE ( fd >= 0 ) ; close ( fd ) ; SEND_WRQ ( "medium.txt" , "octet" ) ; recv_ack ( 0 ) ; send_data ( 1 , ( const char * ) & contents [ 0 ] , 512 ) ; recv_ack ( 1 ) ; send_data ( 2 , ( const char * ) & contents [ 128 ] , 256 ) ; recv_ack ( 2 ) ; <S2SV_StartBug> atf_tc_expect_fail ( "PR<S2SV_blank>157700<S2SV_blank>tftpd<S2SV_blank>expects<S2SV_blank>more<S2SV_blank>data<S2SV_blank>after<S2SV_blank>EOF" ) ; <S2SV_EndBug> fd = open ( "medium.txt" , O_RDONLY ) ; r = read ( fd , buffer , sizeof ( buffer ) ) ; close ( fd ) ; require_bufeq ( ( const char * ) contents , 768 , buffer , r ) ; } | <S2SV_ModStart> 2 ) ; <S2SV_ModEnd> fd = open |
2,846 | CWE-000 static void cma_add_one ( struct ib_device * device ) { struct cma_device * cma_dev ; struct rdma_id_private * id_priv ; unsigned int i ; unsigned long supported_gids = 0 ; cma_dev = kmalloc ( sizeof * cma_dev , GFP_KERNEL ) ; if ( ! cma_dev ) return ; cma_dev -> device = device ; cma_dev -> default_gid_type = kcalloc ( device -> phys_port_cnt , sizeof ( * cma_dev -> default_gid_type ) , GFP_KERNEL ) ; if ( ! cma_dev -> default_gid_type ) goto free_cma_dev ; cma_dev -> default_roce_tos = kcalloc ( device -> phys_port_cnt , sizeof ( * cma_dev -> default_roce_tos ) , GFP_KERNEL ) ; if ( ! cma_dev -> default_roce_tos ) goto free_gid_type ; for ( i = rdma_start_port ( device ) ; i <= rdma_end_port ( device ) ; i ++ ) { supported_gids = roce_gid_type_mask_support ( device , i ) ; WARN_ON ( ! supported_gids ) ; <S2SV_StartBug> if ( supported_gids & CMA_PREFERRED_ROCE_GID_TYPE ) <S2SV_EndBug> cma_dev -> default_gid_type [ i - rdma_start_port ( device ) ] = CMA_PREFERRED_ROCE_GID_TYPE ; else cma_dev -> default_gid_type [ i - rdma_start_port ( device ) ] = find_first_bit ( & supported_gids , BITS_PER_LONG ) ; cma_dev -> default_roce_tos [ i - rdma_start_port ( device ) ] = 0 ; } init_completion ( & cma_dev -> comp ) ; atomic_set ( & cma_dev -> refcount , 1 ) ; INIT_LIST_HEAD ( & cma_dev -> id_list ) ; ib_set_client_data ( device , & cma_client , cma_dev ) ; mutex_lock ( & lock ) ; list_add_tail ( & cma_dev -> list , & dev_list ) ; list_for_each_entry ( id_priv , & listen_any_list , list ) cma_listen_on_dev ( id_priv , cma_dev ) ; mutex_unlock ( & lock ) ; return ; free_gid_type : kfree ( cma_dev -> default_gid_type ) ; free_cma_dev : kfree ( cma_dev ) ; return ; } | <S2SV_ModStart> ( supported_gids & ( 1 << CMA_PREFERRED_ROCE_GID_TYPE ) <S2SV_ModEnd> ) cma_dev -> |
2,847 | CWE-000 int mutt_change_flag ( struct Header * h , int bf ) { int i , flag ; struct Event event ; mutt_window_mvprintw ( MuttMessageWindow , 0 , 0 , "%s?<S2SV_blank>(D/N/O/r/*/!):<S2SV_blank>" , bf ? _ ( "Set<S2SV_blank>flag" ) : _ ( "Clear<S2SV_blank>flag" ) ) ; mutt_window_clrtoeol ( MuttMessageWindow ) ; <S2SV_StartBug> event = mutt_getch ( ) ; <S2SV_EndBug> <S2SV_StartBug> i = event . ch ; <S2SV_EndBug> if ( i < 0 ) { mutt_window_clearline ( MuttMessageWindow , 0 ) ; return - 1 ; } mutt_window_clearline ( MuttMessageWindow , 0 ) ; switch ( i ) { case 'd' : case 'D' : if ( ! bf ) { if ( h ) mutt_set_flag ( Context , h , MUTT_PURGE , bf ) ; else mutt_tag_set_flag ( MUTT_PURGE , bf ) ; } flag = MUTT_DELETE ; break ; case 'N' : case 'n' : flag = MUTT_NEW ; break ; case 'o' : case 'O' : if ( h ) mutt_set_flag ( Context , h , MUTT_READ , ! bf ) ; else mutt_tag_set_flag ( MUTT_READ , ! bf ) ; flag = MUTT_OLD ; break ; case 'r' : case 'R' : flag = MUTT_REPLIED ; break ; case '*' : flag = MUTT_TAG ; break ; case '!' : flag = MUTT_FLAG ; break ; default : BEEP ( ) ; return - 1 ; } if ( h ) mutt_set_flag ( Context , h , flag , bf ) ; else mutt_tag_set_flag ( flag , bf ) ; return 0 ; } | <S2SV_ModStart> MuttMessageWindow ) ; mutt_refresh ( ) ; do { <S2SV_ModStart> ( ) ; } while ( <S2SV_ModEnd> event . ch <S2SV_ModStart> event . ch == - 2 ) ; i = event . ch |
2,848 | CWE-000 Datum pgstrom_float24_div ( PG_FUNCTION_ARGS ) { float arg1 = fp16_to_fp32 ( PG_GETARG_FLOAT2 ( 0 ) ) ; <S2SV_StartBug> float arg2 = PG_GETARG_FLOAT2 ( 1 ) ; <S2SV_EndBug> float result ; if ( arg2 == 0.0 ) ereport ( ERROR , ( errcode ( ERRCODE_DIVISION_BY_ZERO ) , errmsg ( "division<S2SV_blank>by<S2SV_blank>zero" ) ) ) ; result = arg1 / arg2 ; CHECKFLOATVAL ( result , isinf ( arg1 ) || isinf ( arg2 ) , arg1 == 0.0 ) ; PG_RETURN_FLOAT4 ( result ) ; } | <S2SV_ModStart> float arg2 = PG_GETARG_FLOAT4 <S2SV_ModEnd> ( 1 ) |
2,849 | CWE-000 <S2SV_StartBug> void a_gpspoint_write_file ( VikTrwLayer * trw , FILE * f ) <S2SV_EndBug> { GHashTable * tracks = vik_trw_layer_get_tracks ( trw ) ; GHashTable * routes = vik_trw_layer_get_routes ( trw ) ; GHashTable * waypoints = vik_trw_layer_get_waypoints ( trw ) ; <S2SV_StartBug> fprintf ( f , "type=\\"waypointlist\\"\\n" ) ; <S2SV_EndBug> <S2SV_StartBug> g_hash_table_foreach ( waypoints , ( GHFunc ) a_gpspoint_write_waypoint , f ) ; <S2SV_EndBug> fprintf ( f , "type=\\"waypointlistend\\"\\n" ) ; g_hash_table_foreach ( tracks , ( GHFunc ) a_gpspoint_write_track , f ) ; g_hash_table_foreach ( routes , ( GHFunc ) a_gpspoint_write_track , f ) ; } | <S2SV_ModStart> FILE * f , const gchar * dirpath <S2SV_ModStart> trw ) ; WritingContext wc = { f , dirpath } ; <S2SV_ModStart> ) a_gpspoint_write_waypoint , & wc <S2SV_ModEnd> ) ; fprintf |
2,850 | CWE-000 void timer_sleep ( int64_t ticks ) { if ( ticks > 0 ) { int64_t start ; <S2SV_StartBug> enum intr_level old_level ; <S2SV_EndBug> struct thread * t ; old_level = intr_disable ( ) ; start = timer_ticks ( ) ; t = thread_current ( ) ; t -> alarm = start + ticks ; t -> alarm_set = true ; thread_block ( ) ; intr_set_level ( old_level ) ; } } | <S2SV_ModStart> int64_t start ; ASSERT ( intr_get_level ( ) == INTR_ON ) ; while ( timer_elapsed ( start ) < ticks ) thread_yield ( <S2SV_ModEnd> ) ; } |
2,851 | CWE-000 static void xen_set_fixmap ( unsigned idx , phys_addr_t phys , pgprot_t prot ) { pte_t pte ; phys >>= PAGE_SHIFT ; switch ( idx ) { case FIX_BTMAP_END ... FIX_BTMAP_BEGIN : case FIX_RO_IDT : # ifdef CONFIG_X86_32 case FIX_WP_TEST : # ifdef CONFIG_HIGHMEM case FIX_KMAP_BEGIN ... FIX_KMAP_END : # endif # elif defined ( CONFIG_X86_VSYSCALL_EMULATION ) case VSYSCALL_PAGE : # endif case FIX_TEXT_POKE0 : case FIX_TEXT_POKE1 : <S2SV_StartBug> pte = pfn_pte ( phys , prot ) ; <S2SV_EndBug> break ; # ifdef CONFIG_X86_LOCAL_APIC case FIX_APIC_BASE : pte = pfn_pte ( PFN_DOWN ( __pa ( dummy_mapping ) ) , PAGE_KERNEL ) ; break ; # endif # ifdef CONFIG_X86_IO_APIC case FIX_IO_APIC_BASE_0 ... FIX_IO_APIC_BASE_END : pte = pfn_pte ( PFN_DOWN ( __pa ( dummy_mapping ) ) , PAGE_KERNEL ) ; break ; # endif case FIX_PARAVIRT_BOOTMAP : pte = mfn_pte ( phys , prot ) ; break ; default : pte = mfn_pte ( phys , prot ) ; break ; } __native_set_fixmap ( idx , pte ) ; # ifdef CONFIG_X86_VSYSCALL_EMULATION if ( idx == VSYSCALL_PAGE ) { unsigned long vaddr = __fix_to_virt ( idx ) ; set_pte_vaddr_pud ( level3_user_vsyscall , vaddr , pte ) ; } # endif } | <S2SV_ModStart> case FIX_TEXT_POKE1 : case FIX_GDT_REMAP_BEGIN ... FIX_GDT_REMAP_END : |
2,852 | CWE-000 void smp_pairing_cmpl ( tSMP_CB * p_cb , tSMP_INT_DATA * p_data ) { if ( p_cb -> total_tx_unacked == 0 ) { <S2SV_StartBug> L2CA_EnableUpdateBleConnParams ( p_cb -> pairing_bda , TRUE ) ; <S2SV_EndBug> smp_proc_pairing_cmpl ( p_cb ) ; } } | <S2SV_ModStart> 0 ) { <S2SV_ModEnd> smp_proc_pairing_cmpl ( p_cb |
2,853 | CWE-000 static void haswell_crtc_enable ( struct intel_crtc_state * pipe_config , struct drm_atomic_state * old_state ) { struct drm_crtc * crtc = pipe_config -> base . crtc ; struct drm_device * dev = crtc -> dev ; struct drm_i915_private * dev_priv = to_i915 ( dev ) ; struct intel_crtc * intel_crtc = to_intel_crtc ( crtc ) ; int pipe = intel_crtc -> pipe , hsw_workaround_pipe ; <S2SV_StartBug> enum transcoder cpu_transcoder = intel_crtc -> config -> cpu_transcoder ; <S2SV_EndBug> if ( WARN_ON ( intel_crtc -> active ) ) return ; if ( intel_crtc -> config -> has_pch_encoder ) intel_set_pch_fifo_underrun_reporting ( dev_priv , TRANSCODER_A , false ) ; intel_encoders_pre_pll_enable ( crtc , pipe_config , old_state ) ; if ( intel_crtc -> config -> shared_dpll ) intel_enable_shared_dpll ( intel_crtc ) ; if ( intel_crtc_has_dp_encoder ( intel_crtc -> config ) ) intel_dp_set_m_n ( intel_crtc , M1_N1 ) ; if ( ! transcoder_is_dsi ( cpu_transcoder ) ) intel_set_pipe_timings ( intel_crtc ) ; intel_set_pipe_src_size ( intel_crtc ) ; if ( cpu_transcoder != TRANSCODER_EDP && ! transcoder_is_dsi ( cpu_transcoder ) ) { I915_WRITE ( PIPE_MULT ( cpu_transcoder ) , intel_crtc -> config -> pixel_multiplier - 1 ) ; } if ( intel_crtc -> config -> has_pch_encoder ) { intel_cpu_transcoder_set_m_n ( intel_crtc , & intel_crtc -> config -> fdi_m_n , NULL ) ; } if ( ! transcoder_is_dsi ( cpu_transcoder ) ) haswell_set_pipeconf ( crtc ) ; haswell_set_pipemisc ( crtc ) ; intel_color_set_csc ( & pipe_config -> base ) ; intel_crtc -> active = true ; if ( intel_crtc -> config -> has_pch_encoder ) intel_set_cpu_fifo_underrun_reporting ( dev_priv , pipe , false ) ; else intel_set_cpu_fifo_underrun_reporting ( dev_priv , pipe , true ) ; intel_encoders_pre_enable ( crtc , pipe_config , old_state ) ; if ( intel_crtc -> config -> has_pch_encoder ) dev_priv -> display . fdi_link_train ( crtc ) ; if ( ! transcoder_is_dsi ( cpu_transcoder ) ) intel_ddi_enable_pipe_clock ( intel_crtc ) ; if ( INTEL_INFO ( dev ) -> gen >= 9 ) skylake_pfit_enable ( intel_crtc ) ; else ironlake_pfit_enable ( intel_crtc ) ; intel_color_load_luts ( & pipe_config -> base ) ; intel_ddi_set_pipe_settings ( crtc ) ; if ( ! transcoder_is_dsi ( cpu_transcoder ) ) intel_ddi_enable_transcoder_func ( crtc ) ; if ( dev_priv -> display . initial_watermarks != NULL ) <S2SV_StartBug> dev_priv -> display . initial_watermarks ( pipe_config ) ; <S2SV_EndBug> else intel_update_watermarks ( intel_crtc ) ; if ( ! transcoder_is_dsi ( cpu_transcoder ) ) intel_enable_pipe ( intel_crtc ) ; if ( intel_crtc -> config -> has_pch_encoder ) lpt_pch_enable ( crtc ) ; if ( intel_crtc_has_type ( intel_crtc -> config , INTEL_OUTPUT_DP_MST ) ) intel_ddi_set_vc_payload_alloc ( crtc , true ) ; assert_vblank_disabled ( crtc ) ; drm_crtc_vblank_on ( crtc ) ; intel_encoders_enable ( crtc , pipe_config , old_state ) ; if ( intel_crtc -> config -> has_pch_encoder ) { intel_wait_for_vblank ( dev_priv , pipe ) ; intel_wait_for_vblank ( dev_priv , pipe ) ; intel_set_cpu_fifo_underrun_reporting ( dev_priv , pipe , true ) ; intel_set_pch_fifo_underrun_reporting ( dev_priv , TRANSCODER_A , true ) ; } hsw_workaround_pipe = pipe_config -> hsw_workaround_pipe ; if ( IS_HASWELL ( dev_priv ) && hsw_workaround_pipe != INVALID_PIPE ) { intel_wait_for_vblank ( dev_priv , hsw_workaround_pipe ) ; intel_wait_for_vblank ( dev_priv , hsw_workaround_pipe ) ; } } | <S2SV_ModStart> config -> cpu_transcoder ; struct intel_atomic_state * old_intel_state = to_intel_atomic_state ( old_state ) <S2SV_ModStart> . initial_watermarks ( old_intel_state , |
2,854 | CWE-000 <S2SV_StartBug> void * getf ( int fd ) <S2SV_EndBug> { struct spl_fileproc * sfp = NULL ; HANDLE h ; # if 1 struct fileproc * fp = NULL ; struct vnode * vp ; uint32_t vid ; sfp = kmem_alloc ( sizeof ( * sfp ) , KM_SLEEP ) ; if ( ! sfp ) return NULL ; <S2SV_StartBug> ObReferenceObjectByHandle ( fd , 0 , 0 , KernelMode , & fp , 0 ) ; <S2SV_EndBug> sfp -> f_vnode = sfp ; sfp -> f_fd = fd ; sfp -> f_offset = 0 ; sfp -> f_proc = current_proc ( ) ; sfp -> f_fp = fp ; mutex_enter ( & spl_getf_lock ) ; list_insert_tail ( & spl_getf_list , sfp ) ; mutex_exit ( & spl_getf_lock ) ; # endif return sfp ; } | <S2SV_ModStart> * getf ( uint64_t <S2SV_ModEnd> fd ) { <S2SV_ModStart> return NULL ; if ( <S2SV_ModStart> , 0 ) != STATUS_SUCCESS ) { dprintf ( "%s:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>fd<S2SV_blank>%d<S2SV_blank>fp<S2SV_blank>0x\\n" , __func__ , fd ) ; } <S2SV_ModEnd> sfp -> f_vnode |
2,855 | CWE-000 static int ti_cpufreq_init ( void ) { <S2SV_StartBug> platform_device_register_simple ( "ti-cpufreq" , - 1 , NULL , 0 ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> void ) { const struct of_device_id * match ; match = ti_cpufreq_match_node ( ) ; if ( match ) platform_device_register_data ( NULL , <S2SV_ModEnd> "ti-cpufreq" , - <S2SV_ModStart> - 1 , match , sizeof ( * match ) <S2SV_ModEnd> ) ; return |
2,856 | CWE-000 int is_exist ( int * * board , int index , int max ) { int i ; int j ; <S2SV_StartBug> i = 0 ; <S2SV_EndBug> j = 0 ; while ( i < max ) { j = 0 ; while ( j < max ) { if ( board [ i ] [ j ] == index ) return ( 1 ) ; j ++ ; } i ++ ; } return ( 0 ) ; } | <S2SV_ModStart> j ; i <S2SV_ModEnd> = 0 ; |
2,857 | CWE-000 function ( void , rawdataToTexbuffer , GLenum textype ) { as ( MCTexture ) ; <S2SV_StartBug> if ( obj -> data -> raw ) { <S2SV_EndBug> if ( obj -> data -> channels == 4 ) { glTexImage2D ( textype , 0 , GL_RGBA , obj -> width , obj -> height , 0 , GL_RGBA , GL_UNSIGNED_BYTE , obj -> data -> raw ) ; glGenerateMipmap ( textype ) ; } else if ( obj -> data -> channels == 3 ) { glTexImage2D ( textype , 0 , GL_RGB , obj -> width , obj -> height , 0 , GL_RGB , GL_UNSIGNED_BYTE , obj -> data -> raw ) ; glGenerateMipmap ( textype ) ; } } } | <S2SV_ModStart> ; if ( obj -> data && |
2,858 | CWE-000 static int CeedElemRestrictionDestroy_Occa ( CeedElemRestriction r ) { int ierr ; const Ceed ceed = r -> ceed ; CeedElemRestriction_Occa * data = r -> data ; dbg ( "[CeedElemRestriction][Destroy]" ) ; <S2SV_StartBug> ierr = CeedFree ( & data ) ; CeedChk ( ierr ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> "[CeedElemRestriction][Destroy]" ) ; for ( int i = 0 ; i < 9 ; i ++ ) { occaFree ( data -> kRestrict [ i ] ) ; } |
2,859 | CWE-000 static irqreturn_t hdmitx_hdcp_irq_handler ( int irq , void * dev_id ) { struct xilinx_drm_hdmi * xhdmi ; XV_HdmiTxSs * HdmiTxSsPtr ; unsigned long flags ; BUG_ON ( ! dev_id ) ; xhdmi = ( struct xilinx_drm_hdmi * ) dev_id ; HdmiTxSsPtr = ( XV_HdmiTxSs * ) & xhdmi -> xv_hdmitxss ; BUG_ON ( ! HdmiTxSsPtr -> HdmiTxPtr ) ; # ifndef RUN_HDCP_IN_INTERRUPT_CONTEXT <S2SV_StartBug> # ifdef MASK_IRQ_ON_HOST <S2SV_EndBug> disable_irq ( irq ) ; <S2SV_StartBug> # else <S2SV_EndBug> spin_lock_irqsave ( & xhdmi -> irq_lock , flags ) ; <S2SV_StartBug> XTmrCtr_DisableIntr ( HdmiTxSsPtr -> HdcpTimerPtr -> BaseAddress , 0 ) ; <S2SV_EndBug> XTmrCtr_DisableIntr ( HdmiTxSsPtr -> Hdcp22Ptr -> Timer . TmrCtr . BaseAddress , 0 ) ; <S2SV_StartBug> XHdcp1x_WriteReg ( HdmiTxSsPtr -> Hdcp14Ptr -> Config . BaseAddress , <S2SV_EndBug> XHDCP1X_CIPHER_REG_INTERRUPT_MASK , ( u32 ) 0xFFFFFFFFu ) ; spin_unlock_irqrestore ( & xhdmi -> irq_lock , flags ) ; <S2SV_StartBug> # endif <S2SV_EndBug> return IRQ_WAKE_THREAD ; # else XV_HdmiTxSS_HdcpIntrHandler ( HdmiTxSsPtr ) ; XV_HdmiTxSS_HdcpTimerIntrHandler ( HdmiTxSsPtr ) ; XV_HdmiTxSS_Hdcp22TimerIntrHandler ( HdmiTxSsPtr ) ; return IRQ_HANDLED ; # endif } | <S2SV_ModStart> # ifndef RUN_HDCP_IN_INTERRUPT_CONTEXT if ( irq == xhdmi -> hdcp1x_irq ) { disable_irq_nosync <S2SV_ModEnd> ( irq ) <S2SV_ModStart> irq ) ; } <S2SV_ModEnd> spin_lock_irqsave ( & <S2SV_ModStart> flags ) ; if ( irq == xhdmi -> hdcp1x_timer_irq ) { <S2SV_ModStart> 0 ) ; } else if ( irq == xhdmi -> hdcp22_timer_irq ) { <S2SV_ModStart> 0 ) ; } <S2SV_ModEnd> spin_unlock_irqrestore ( & <S2SV_ModStart> flags ) ; <S2SV_ModEnd> return IRQ_WAKE_THREAD ; |
2,860 | CWE-000 <S2SV_StartBug> bool kvm_vcpu_yield_to ( struct kvm_vcpu * target ) <S2SV_EndBug> { struct pid * pid ; struct task_struct * task = NULL ; <S2SV_StartBug> bool ret = false ; <S2SV_EndBug> rcu_read_lock ( ) ; pid = rcu_dereference ( target -> pid ) ; if ( pid ) task = get_pid_task ( target -> pid , PIDTYPE_PID ) ; rcu_read_unlock ( ) ; if ( ! task ) return ret ; if ( task -> flags & PF_VCPU ) { put_task_struct ( task ) ; return ret ; } ret = yield_to ( task , 1 ) ; put_task_struct ( task ) ; return ret ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> int <S2SV_ModEnd> kvm_vcpu_yield_to ( struct <S2SV_ModStart> = NULL ; int ret = 0 <S2SV_ModEnd> ; rcu_read_lock ( |
2,861 | CWE-000 void gsKit_remove_hsync_handler ( int callback_id ) { <S2SV_StartBug> DIntr ( ) ; <S2SV_EndBug> DisableIntc ( INTC_GS ) ; RemoveIntcHandler ( INTC_GS , callback_id ) ; EIntr ( ) ; } | <S2SV_ModStart> { DIntr ( ) ; GsPutIMR ( GsGetIMR ( ) | 0x0400 |
2,862 | CWE-000 ZEND_API void zend_register_interfaces ( void ) { REGISTER_MAGIC_INTERFACE ( traversable , Traversable ) ; REGISTER_MAGIC_INTERFACE ( aggregate , IteratorAggregate ) ; REGISTER_MAGIC_IMPLEMENT ( aggregate , traversable ) ; REGISTER_MAGIC_INTERFACE ( iterator , Iterator ) ; REGISTER_MAGIC_IMPLEMENT ( iterator , traversable ) ; REGISTER_MAGIC_INTERFACE ( arrayaccess , ArrayAccess ) ; REGISTER_MAGIC_INTERFACE ( serializable , Serializable ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> Serializable ) ; REGISTER_MAGIC_INTERFACE ( countable , Countable ) ; |
2,863 | CWE-000 <S2SV_StartBug> DEFUN ( debug_isis_err , <S2SV_EndBug> debug_isis_err_cmd , <S2SV_StartBug> "debug<S2SV_blank>" PROTO_NAME "<S2SV_blank>protocol-errors" , <S2SV_EndBug> DEBUG_STR PROTO_HELP <S2SV_StartBug> "IS-IS<S2SV_blank>LSP<S2SV_blank>protocol<S2SV_blank>errors\\n" ) <S2SV_EndBug> { <S2SV_StartBug> isis -> debugs |= DEBUG_PROTOCOL_ERRORS ; <S2SV_EndBug> <S2SV_StartBug> print_debug ( vty , DEBUG_PROTOCOL_ERRORS , 1 ) ; <S2SV_EndBug> return CMD_SUCCESS ; } | <S2SV_ModStart> <S2SV_null> DEFUN ( debug_isis_spfevents , debug_isis_spfevents_cmd <S2SV_ModEnd> , "debug<S2SV_blank>" PROTO_NAME <S2SV_ModStart> , "debug<S2SV_blank>" PROTO_NAME "<S2SV_blank>spf-events" <S2SV_ModEnd> , DEBUG_STR PROTO_HELP <S2SV_ModStart> , DEBUG_STR PROTO_HELP "IS-IS<S2SV_blank>Shortest<S2SV_blank>Path<S2SV_blank>First<S2SV_blank>Events\\n" <S2SV_ModEnd> ) { isis <S2SV_ModStart> -> debugs |= DEBUG_SPF_EVENTS <S2SV_ModEnd> ; print_debug ( <S2SV_ModStart> ( vty , DEBUG_SPF_EVENTS <S2SV_ModEnd> , 1 ) |
2,864 | CWE-000 BOSNode * file_type_archive_alloc ( load_images_state_t state , file_t * file ) { GError * error_pointer = NULL ; GBytes * data = buffered_file_as_bytes ( file , NULL , & error_pointer ) ; if ( ! data ) { g_printerr ( "Failed<S2SV_blank>to<S2SV_blank>load<S2SV_blank>archive<S2SV_blank>%s:<S2SV_blank>%s\\n" , file -> display_name , error_pointer ? error_pointer -> message : "Unknown<S2SV_blank>error" ) ; g_clear_error ( & error_pointer ) ; file_free ( file ) ; <S2SV_StartBug> return NULL ; <S2SV_EndBug> } struct archive * archive = file_type_archive_gen_archive ( data ) ; if ( ! archive ) { buffered_file_unref ( file ) ; file_free ( file ) ; <S2SV_StartBug> return NULL ; <S2SV_EndBug> } GtkFileFilterInfo file_filter_info ; file_filter_info . contains = GTK_FILE_FILTER_FILENAME | GTK_FILE_FILTER_DISPLAY_NAME ; BOSNode * first_node = FALSE_POINTER ; struct archive_entry * entry ; while ( archive_read_next_header ( archive , & entry ) == ARCHIVE_OK ) { const gchar * entry_name = archive_entry_pathname ( entry ) ; gchar * sub_name = g_strdup_printf ( "%s#%s" , file -> display_name , entry_name ) ; file_t * new_file = image_loader_duplicate_file ( file , g_strdup ( sub_name ) , g_strdup ( sub_name ) , sub_name ) ; if ( new_file -> file_data ) { g_bytes_unref ( new_file -> file_data ) ; new_file -> file_data = NULL ; } size_t delegate_struct_alloc_size = sizeof ( file_loader_delegate_archive_t ) + strlen ( entry_name ) + 2 ; file_loader_delegate_archive_t * new_file_data = g_malloc ( delegate_struct_alloc_size ) ; new_file_data -> source_archive = image_loader_duplicate_file ( file , NULL , NULL , NULL ) ; new_file_data -> entry_name = ( char * ) ( new_file_data ) + sizeof ( file_loader_delegate_archive_t ) + 1 ; memcpy ( new_file_data -> entry_name , entry_name , strlen ( entry_name ) + 1 ) ; new_file -> file_data = g_bytes_new_with_free_func ( new_file_data , delegate_struct_alloc_size , ( GDestroyNotify ) file_type_archive_data_free , new_file_data ) ; new_file -> file_flags |= FILE_FLAGS_MEMORY_IMAGE ; new_file -> file_data_loader = file_type_archive_data_loader ; gchar * name_lowerc = g_utf8_strdown ( entry_name , - 1 ) ; file_filter_info . filename = file_filter_info . display_name = name_lowerc ; BOSNode * node = load_images_handle_parameter_find_handler ( entry_name , state , new_file , & file_filter_info ) ; if ( node == NULL ) { file_free ( new_file ) ; } else if ( node == FALSE_POINTER ) { node = NULL ; } else if ( first_node == FALSE_POINTER ) { first_node = node ; } g_free ( name_lowerc ) ; archive_read_data_skip ( archive ) ; } archive_read_free ( archive ) ; buffered_file_unref ( file ) ; return first_node ; } | <S2SV_ModStart> ) ; return FALSE_POINTER <S2SV_ModEnd> ; } struct <S2SV_ModStart> ) ; return FALSE_POINTER <S2SV_ModEnd> ; } GtkFileFilterInfo |
2,865 | CWE-000 static int _dl_do_lazy_reloc ( struct elf_resolve * tpnt , struct r_scope_elem * scope , ELF_RELOC * rpnt ) { int reloc_type ; unsigned long * reloc_addr ; # if defined __SUPPORT_LD_DEBUG__ unsigned long old_val ; # endif reloc_addr = ( unsigned long * ) ( tpnt -> loadaddr + rpnt -> r_offset ) ; reloc_type = ELF_R_TYPE ( rpnt -> r_info ) ; # if defined __SUPPORT_LD_DEBUG__ old_val = * reloc_addr ; # endif switch ( reloc_type ) { case R_ARC_NONE : break ; case R_ARC_JMP_SLOT : * reloc_addr += tpnt -> loadaddr ; break ; default : return - 1 ; } # if defined __SUPPORT_LD_DEBUG__ if ( _dl_debug_reloc && _dl_debug_detail ) <S2SV_StartBug> _dl_dprintf ( _dl_debug_file , "\\tpatched:<S2SV_blank>%lx<S2SV_blank>==><S2SV_blank>%lx<S2SV_blank>@<S2SV_blank>%pl\\n" , <S2SV_EndBug> old_val , * reloc_addr , reloc_addr ) ; # endif return 0 ; } | <S2SV_ModStart> ( _dl_debug_file , "\\tpatched:<S2SV_blank>%x<S2SV_blank>==><S2SV_blank>%x<S2SV_blank>@<S2SV_blank>%x\\n" <S2SV_ModEnd> , old_val , |
2,866 | CWE-000 <S2SV_StartBug> int main ( ) { <S2SV_EndBug> float f1 ; float f2 = 0.0f ; float f3 = 1.0f ; ff1 ( f1 ) ; ff1 ( f2 ) ; ff2 ( & f2 , & f3 ) ; assert ( f2 == f3 ) ; return 0 ; } | <S2SV_ModStart> int main ( void |
2,867 | CWE-000 int setautorun ( const char * selector , const char * value , int flags ) { int ws_id ; <S2SV_StartBug> char s [ 1024 ] ; <S2SV_EndBug> char * ap , * sp , * str ; union arg a ; <S2SV_StartBug> int argc = 0 ; <S2SV_EndBug> pid_t pid ; struct pid_e * p ; ( void ) selector ; ( void ) flags ; if ( getenv ( "SWM_STARTED" ) ) return ( 0 ) ; <S2SV_StartBug> bzero ( s , sizeof s ) ; <S2SV_EndBug> <S2SV_StartBug> if ( sscanf ( value , "ws[%d]:%1023c" , & ws_id , s ) != 2 ) <S2SV_EndBug> <S2SV_StartBug> errx ( 1 , "invalid<S2SV_blank>autorun<S2SV_blank>entry,<S2SV_blank>should<S2SV_blank>be<S2SV_blank>\'ws[<idx>]:command\'" ) ; <S2SV_EndBug> ws_id -- ; if ( ws_id < 0 || ws_id >= workspace_limit ) errx ( 1 , "autorun:<S2SV_blank>invalid<S2SV_blank>workspace<S2SV_blank>%d" , ws_id + 1 ) ; <S2SV_StartBug> sp = str = expand_tilde ( ( char * ) & s ) ; <S2SV_EndBug> a . argv = NULL ; while ( ( ap = strsep ( & sp , "<S2SV_blank>\\t" ) ) != NULL ) { if ( * ap == '\\0' ) continue ; DNPRINTF ( SWM_D_SPAWN , "arg<S2SV_blank>[%s]\\n" , ap ) ; argc ++ ; if ( ( a . argv = realloc ( a . argv , argc * sizeof ( char * ) ) ) == NULL ) err ( 1 , "setautorun:<S2SV_blank>realloc" ) ; a . argv [ argc - 1 ] = ap ; } if ( ( a . argv = realloc ( a . argv , ( argc + 1 ) * sizeof ( char * ) ) ) == NULL ) err ( 1 , "setautorun:<S2SV_blank>realloc" ) ; a . argv [ argc ] = NULL ; if ( ( pid = fork ( ) ) == 0 ) { spawn ( ws_id , & a , true ) ; _exit ( 1 ) ; } free ( a . argv ) ; free ( str ) ; p = find_pid ( pid ) ; if ( p == NULL ) { p = calloc ( 1 , sizeof * p ) ; if ( p == NULL ) return ( 1 ) ; TAILQ_INSERT_TAIL ( & pidlist , p , entry ) ; } p -> pid = pid ; p -> ws = ws_id ; return ( 0 ) ; } | <S2SV_ModStart> ws_id ; char <S2SV_ModEnd> * ap , <S2SV_ModStart> argc = 0 , n <S2SV_ModStart> 0 ) ; <S2SV_ModEnd> if ( sscanf <S2SV_ModStart> ( value , "ws[%d]:%n" <S2SV_ModEnd> , & ws_id <S2SV_ModStart> & ws_id , & n ) != 1 || ! value [ n ] <S2SV_ModEnd> ) errx ( <S2SV_ModStart> , "invalid<S2SV_blank>autorun<S2SV_blank>entry,<S2SV_blank>should<S2SV_blank>be<S2SV_blank>\'ws[<idx>]:command\'" ) ; value += n <S2SV_ModStart> = expand_tilde ( value <S2SV_ModEnd> ) ; a |
2,868 | CWE-000 static int igbuio_pci_enable_interrupts ( struct rte_uio_pci_dev * udev ) { int err = 0 ; # ifndef HAVE_ALLOC_IRQ_VECTORS struct msix_entry msix_entry ; # endif switch ( igbuio_intr_mode_preferred ) { case RTE_INTR_MODE_MSIX : # ifndef HAVE_ALLOC_IRQ_VECTORS msix_entry . entry = 0 ; if ( pci_enable_msix ( udev -> pdev , & msix_entry , 1 ) == 0 ) { dev_dbg ( & udev -> pdev -> dev , "using<S2SV_blank>MSI-X" ) ; udev -> info . irq_flags = IRQF_NO_THREAD ; udev -> info . irq = msix_entry . vector ; udev -> mode = RTE_INTR_MODE_MSIX ; break ; } # else if ( pci_alloc_irq_vectors ( udev -> pdev , 1 , 1 , PCI_IRQ_MSIX ) == 1 ) { dev_dbg ( & udev -> pdev -> dev , "using<S2SV_blank>MSI-X" ) ; udev -> info . irq_flags = IRQF_NO_THREAD ; udev -> info . irq = pci_irq_vector ( udev -> pdev , 0 ) ; udev -> mode = RTE_INTR_MODE_MSIX ; break ; } # endif case RTE_INTR_MODE_MSI : # ifndef HAVE_ALLOC_IRQ_VECTORS if ( pci_enable_msi ( udev -> pdev ) == 0 ) { dev_dbg ( & udev -> pdev -> dev , "using<S2SV_blank>MSI" ) ; udev -> info . irq_flags = IRQF_NO_THREAD ; udev -> info . irq = udev -> pdev -> irq ; udev -> mode = RTE_INTR_MODE_MSI ; break ; } # else if ( pci_alloc_irq_vectors ( udev -> pdev , 1 , 1 , PCI_IRQ_MSI ) == 1 ) { dev_dbg ( & udev -> pdev -> dev , "using<S2SV_blank>MSI" ) ; udev -> info . irq_flags = IRQF_NO_THREAD ; udev -> info . irq = pci_irq_vector ( udev -> pdev , 0 ) ; udev -> mode = RTE_INTR_MODE_MSI ; break ; } # endif case RTE_INTR_MODE_LEGACY : if ( pci_intx_mask_supported ( udev -> pdev ) ) { dev_dbg ( & udev -> pdev -> dev , "using<S2SV_blank>INTX" ) ; udev -> info . irq_flags = IRQF_SHARED | IRQF_NO_THREAD ; udev -> info . irq = udev -> pdev -> irq ; udev -> mode = RTE_INTR_MODE_LEGACY ; break ; } dev_notice ( & udev -> pdev -> dev , "PCI<S2SV_blank>INTX<S2SV_blank>mask<S2SV_blank>not<S2SV_blank>supported\\n" ) ; case RTE_INTR_MODE_NONE : udev -> mode = RTE_INTR_MODE_NONE ; <S2SV_StartBug> udev -> info . irq = 0 ; <S2SV_EndBug> break ; default : dev_err ( & udev -> pdev -> dev , "invalid<S2SV_blank>IRQ<S2SV_blank>mode<S2SV_blank>%u" , igbuio_intr_mode_preferred ) ; err = - EINVAL ; } return err ; } | <S2SV_ModStart> . irq = UIO_IRQ_NONE <S2SV_ModEnd> ; break ; |
2,869 | CWE-000 static void free_children ( dmu_buf_impl_t * db , uint64_t blkid , uint64_t nblks , <S2SV_StartBug> dmu_tx_t * tx ) <S2SV_EndBug> { dnode_t * dn ; blkptr_t * bp ; dmu_buf_impl_t * subdb ; uint64_t start , end , dbstart , dbend ; unsigned int epbs , shift , i ; if ( db -> db_state != DB_CACHED ) ( void ) dbuf_read ( db , NULL , DB_RF_MUST_SUCCEED ) ; dbuf_release_bp ( db ) ; bp = db -> db . db_data ; DB_DNODE_ENTER ( db ) ; dn = DB_DNODE ( db ) ; epbs = dn -> dn_phys -> dn_indblkshift - SPA_BLKPTRSHIFT ; ASSERT3U ( epbs , < , 31 ) ; shift = ( db -> db_level - 1 ) * epbs ; dbstart = db -> db_blkid << epbs ; start = blkid >> shift ; if ( dbstart < start ) { bp += start - dbstart ; } else { start = dbstart ; } dbend = ( ( db -> db_blkid + 1 ) << epbs ) - 1 ; end = ( blkid + nblks - 1 ) >> shift ; if ( dbend <= end ) end = dbend ; ASSERT3U ( start , <= , end ) ; if ( db -> db_level == 1 ) { FREE_VERIFY ( db , start , end , tx ) ; free_blocks ( dn , bp , end - start + 1 , tx ) ; } else { for ( uint64_t id = start ; id <= end ; id ++ , bp ++ ) { if ( BP_IS_HOLE ( bp ) ) continue ; rw_enter ( & dn -> dn_struct_rwlock , RW_READER ) ; VERIFY0 ( dbuf_hold_impl ( dn , db -> db_level - 1 , id , TRUE , FALSE , FTAG , & subdb ) ) ; rw_exit ( & dn -> dn_struct_rwlock ) ; ASSERT3P ( bp , == , subdb -> db_blkptr ) ; <S2SV_StartBug> free_children ( subdb , blkid , nblks , tx ) ; <S2SV_EndBug> dbuf_rele ( subdb , FTAG ) ; } <S2SV_StartBug> } <S2SV_EndBug> <S2SV_StartBug> for ( i = 0 , bp = db -> db . db_data ; i < 1 << epbs ; i ++ , bp ++ ) { <S2SV_EndBug> <S2SV_StartBug> if ( ! BP_IS_HOLE ( bp ) ) <S2SV_EndBug> break ; } if ( i == 1 << epbs ) { rw_enter ( & dn -> dn_struct_rwlock , RW_WRITER ) ; bzero ( db -> db . db_data , db -> db . db_size ) ; <S2SV_StartBug> rw_exit ( & dn -> dn_struct_rwlock ) ; <S2SV_EndBug> free_blocks ( dn , db -> db_blkptr , 1 , tx ) ; <S2SV_StartBug> } else { <S2SV_EndBug> ASSERT ( db -> db_dirtycnt > 0 ) ; } DB_DNODE_EXIT ( db ) ; arc_buf_freeze ( db -> db_buf ) ; } | <S2SV_ModStart> uint64_t nblks , boolean_t free_indirects , <S2SV_ModStart> , nblks , free_indirects , <S2SV_ModStart> ; } } if ( free_indirects ) { <S2SV_ModStart> bp ++ ) ASSERT ( <S2SV_ModEnd> BP_IS_HOLE ( bp <S2SV_ModStart> ( bp ) <S2SV_ModEnd> ) ; bzero <S2SV_ModStart> db_size ) ; <S2SV_ModEnd> free_blocks ( dn <S2SV_ModStart> ) ; } <S2SV_ModEnd> DB_DNODE_EXIT ( db |
2,870 | CWE-000 void fpt_add_child_to_list ( FptEdge * * list , FptNode * node , char * pat , size_t n ) { if ( ! list ) { return ; } FptEdge * first = ( FptEdge * ) malloc ( sizeof ( FptEdge ) ) ; if ( first == NULL ) { perror ( "failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory" ) ; FatalExit ( ) ; } first -> node = node ; first -> len = n ; first -> text = ( char * ) malloc ( n ) ; if ( first -> text == NULL ) { perror ( "failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory" ) ; FatalExit ( ) ; } <S2SV_StartBug> strncpy ( fisrt -> text , pat , n ) ; <S2SV_EndBug> first -> prev = NULL ; first -> next = * list ; if ( * list ) ( * list ) -> prev = first ; * list = first ; } | <S2SV_ModStart> ) ; } memcpy ( first <S2SV_ModEnd> -> text , |
2,871 | CWE-000 static int get_options ( int * argc , char * * * argv ) { int ho_error ; if ( ( ho_error = handle_options ( argc , argv , my_long_options , get_one_option ) ) ) <S2SV_StartBug> exit ( ho_error ) ; <S2SV_EndBug> if ( ! * argc && ! print_all_codes ) { usage ( ) ; return 1 ; } return 0 ; } | <S2SV_ModStart> ) ) ) { my_end ( 0 ) ; <S2SV_ModStart> ho_error ) ; } |
2,872 | CWE-000 <S2SV_StartBug> ATF_TC_HEAD ( setlogin_failure , tc ) <S2SV_EndBug> { <S2SV_StartBug> atf_tc_set_md_var ( tc , "descr" , "Tests<S2SV_blank>the<S2SV_blank>audit<S2SV_blank>of<S2SV_blank>an<S2SV_blank>unsuccessful<S2SV_blank>" <S2SV_EndBug> "setlogin(2)<S2SV_blank>call" ) ; } | <S2SV_ModStart> <S2SV_null> ATF_TC_HEAD ( setlogin_success <S2SV_ModEnd> , tc ) <S2SV_ModStart> , "descr" , "Tests<S2SV_blank>the<S2SV_blank>audit<S2SV_blank>of<S2SV_blank>a<S2SV_blank>successful<S2SV_blank>" <S2SV_ModEnd> "setlogin(2)<S2SV_blank>call" ) ; |
2,873 | CWE-000 static void mkWinChildcareWorkerCaughtMoreOutput ( PWINCHILD pChild , PWINCCWPIPE pPipe , DWORD cbNewData ) { DWORD offStart = pPipe -> cbWritten ; <S2SV_StartBug> assert ( offStart <= pPipe -> offPendingRead ) ; <S2SV_EndBug> if ( cbNewData > 0 ) { DWORD offRest ; pPipe -> offPendingRead += cbNewData ; assert ( pPipe -> offPendingRead <= pPipe -> cbBuffer ) ; if ( pPipe -> offPendingRead > pPipe -> cbBuffer ) pPipe -> offPendingRead = pPipe -> cbBuffer ; offRest = pPipe -> offPendingRead ; while ( offRest > offStart && pPipe -> pbBuffer [ offRest - 1 ] != '\\n' ) offRest -- ; <S2SV_StartBug> if ( offRest > offStart <S2SV_EndBug> <S2SV_StartBug> || pPipe -> cbBuffer - pPipe -> offPendingRead + offStart > 16 ) <S2SV_EndBug> { } else { offRest = pPipe -> offPendingRead ; while ( offRest > offStart && isalnum ( pPipe -> pbBuffer [ offRest - 1 ] ) ) offRest -- ; if ( offRest == offStart ) offRest = pPipe -> offPendingRead ; <S2SV_StartBug> } <S2SV_EndBug> if ( offRest > offStart ) { DWORD cbToWrite = offRest - offStart ; # ifdef CONFIG_WITH_OUTPUT_IN_MEMORY if ( pChild -> pMkChild ) { output_write_bin ( & pChild -> pMkChild -> output , pPipe -> iWhich == 2 , & pPipe -> pbBuffer [ offStart ] , cbToWrite ) ; offStart += cbToWrite ; pPipe -> cbWritten = offStart ; } else # endif { DWORD cbWritten = 0 ; if ( WriteFile ( GetStdHandle ( pPipe -> iWhich == 1 ? STD_OUTPUT_HANDLE : STD_ERROR_HANDLE ) , & pPipe -> pbBuffer [ offStart ] , cbToWrite , & cbWritten , NULL ) ) { offStart += cbWritten <= cbToWrite ? cbWritten : cbToWrite ; pPipe -> cbWritten = offStart ; } } <S2SV_StartBug> } <S2SV_EndBug> } if ( offStart > 0 ) { DWORD cbUnwritten = pPipe -> offPendingRead - offStart ; if ( cbUnwritten > 0 ) memmove ( pPipe -> pbBuffer , & pPipe -> pbBuffer [ offStart ] , cbUnwritten ) ; pPipe -> offPendingRead -= pPipe -> cbWritten ; pPipe -> cbWritten = 0 ; } } | <S2SV_ModStart> pPipe -> offPendingRead ) ; assert ( offStart <= pPipe -> cbBuffer - 16 ) ; assert ( pPipe -> offPendingRead <= pPipe -> cbBuffer - 16 <S2SV_ModStart> if ( offRest <= offStart && <S2SV_ModEnd> pPipe -> cbBuffer <S2SV_ModStart> offPendingRead + offStart < 16 ) <S2SV_ModEnd> { offRest = <S2SV_ModStart> offPendingRead ; } else if ( pChild -> fProbableClExe && pPipe -> iWhich == 1 && offRest == pPipe -> offPendingRead && mkWinChildcareWorkerIsClExeSourceLine ( pPipe , offStart , offRest ) ) offRest = offStart ; <S2SV_ModStart> ; } } pPipe -> fHaveWrittenOut = TRUE ; |
2,874 | CWE-000 double travelThroughAltitude ( double * * travelAltitude , int i , int j , int n ) { if ( i == n - 1 && j == n - 1 ) { return travelAltitude [ i ] [ j ] ; } int newI = i , newJ = j , min = NORTH ; <S2SV_StartBug> double minAlt = 0 ; <S2SV_EndBug> int k ; for ( k = 0 ; k < DIRECTIONS ; k ++ ) { double alt = checkAltitudeInDirection ( travelAltitude , i , j , k , n ) ; if ( alt < minAlt ) { minAlt = alt ; min = k ; } } advanceInDirection ( & newI , & newJ , min ) ; <S2SV_StartBug> if ( i < n - 1 ) { <S2SV_EndBug> <S2SV_StartBug> return travelAltitude [ i ] [ j ] + travelThroughAltitude ( travelAltitude , i + 1 , j , n ) ; <S2SV_EndBug> } <S2SV_StartBug> else { <S2SV_EndBug> return travelAltitude [ i ] [ j ] + travelThroughAltitude ( travelAltitude , 0 , j + 1 , n ) ; } } | <S2SV_ModStart> double minAlt = checkAltitudeInDirection ( travelAltitude , i , j , 0 , n ) <S2SV_ModEnd> ; int k <S2SV_ModStart> min ) ; <S2SV_ModEnd> return travelAltitude [ <S2SV_ModStart> ( travelAltitude , newI , newJ <S2SV_ModEnd> , n ) <S2SV_ModStart> ) ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
2,875 | CWE-000 static int rxm_ep_msg_res_open ( struct fi_info * rxm_fi_info , struct util_domain * util_domain , struct rxm_ep * rxm_ep ) { struct rxm_domain * rxm_domain ; struct fi_cq_attr cq_attr ; int ret ; <S2SV_StartBug> ret = ofi_get_core_info ( util_domain -> fabric -> fabric_fid . api_version , <S2SV_EndBug> <S2SV_StartBug> NULL , NULL , 0 , & rxm_util_prov , rxm_fi_info , <S2SV_EndBug> rxm_info_to_core , & rxm_ep -> msg_info ) ; if ( ret ) return ret ; rxm_ep -> comp_per_progress = MIN ( rxm_ep -> msg_info -> tx_attr -> size , rxm_ep -> msg_info -> rx_attr -> size ) / 2 ; rxm_domain = container_of ( util_domain , struct rxm_domain , util_domain ) ; memset ( & cq_attr , 0 , sizeof ( cq_attr ) ) ; cq_attr . size = rxm_fi_info -> tx_attr -> size + rxm_fi_info -> rx_attr -> size ; cq_attr . format = FI_CQ_FORMAT_DATA ; ret = fi_cq_open ( rxm_domain -> msg_domain , & cq_attr , & rxm_ep -> msg_cq , NULL ) ; if ( ret ) { FI_WARN ( & rxm_prov , FI_LOG_CQ , "Unable<S2SV_blank>to<S2SV_blank>open<S2SV_blank>MSG<S2SV_blank>CQ\\n" ) ; goto err1 ; } <S2SV_StartBug> ret = fi_srx_context ( rxm_domain -> msg_domain , rxm_ep -> msg_info -> rx_attr , <S2SV_EndBug> & rxm_ep -> srx_ctx , NULL ) ; if ( ret ) { <S2SV_StartBug> FI_WARN ( & rxm_prov , FI_LOG_FABRIC , "Unable<S2SV_blank>to<S2SV_blank>open<S2SV_blank>shared<S2SV_blank>receive<S2SV_blank>context\\n" ) ; <S2SV_EndBug> <S2SV_StartBug> goto err2 ; <S2SV_EndBug> } ret = rxm_listener_open ( rxm_ep ) ; if ( ret ) goto err3 ; if ( rxm_ep -> msg_info -> src_addr ) { if ( ( ( struct sockaddr * ) rxm_ep -> msg_info -> src_addr ) -> sa_family == AF_INET ) ( ( struct sockaddr_in * ) ( rxm_ep -> msg_info -> src_addr ) ) -> sin_port = 0 ; else ( ( struct sockaddr_in6 * ) ( rxm_ep -> msg_info -> src_addr ) ) -> sin6_port = 0 ; } return 0 ; err3 : fi_close ( & rxm_ep -> srx_ctx -> fid ) ; err2 : fi_close ( & rxm_ep -> msg_cq -> fid ) ; err1 : fi_freeinfo ( rxm_ep -> msg_info ) ; return ret ; } | <S2SV_ModStart> ; ret = rxm_ep_get_core_info <S2SV_ModEnd> ( util_domain -> <S2SV_ModStart> . api_version , rxm_fi_info <S2SV_ModEnd> , & rxm_ep <S2SV_ModStart> err1 ; } if ( rxm_ep -> msg_info -> ep_attr -> rx_ctx_cnt == FI_SHARED_CONTEXT ) { <S2SV_ModStart> & rxm_prov , FI_LOG_EP_CTRL , <S2SV_ModEnd> "Unable<S2SV_blank>to<S2SV_blank>open<S2SV_blank>shared<S2SV_blank>receive<S2SV_blank>context\\n" ) ; <S2SV_ModStart> goto err2 ; } |
2,876 | CWE-000 bool should_run_posix_check ( struct sdap_id_ctx * ctx , struct sdap_id_conn_ctx * conn , bool use_id_mapping , bool posix_request ) { if ( use_id_mapping == false && posix_request == true && ctx -> opts -> schema_type == SDAP_SCHEMA_AD && <S2SV_StartBug> conn -> ignore_mark_offline == true && <S2SV_EndBug> ctx -> srv_opts && ctx -> srv_opts -> posix_checked == false ) { return true ; } return false ; } | <S2SV_ModStart> && conn -> check_posix_attrs <S2SV_ModEnd> == true && |
2,877 | CWE-000 <S2SV_StartBug> char * printable ( char * source ) <S2SV_EndBug> { size_t len ; if ( ! source ) return NULL ; <S2SV_StartBug> len = strlen ( source ) ; <S2SV_EndBug> if ( contains_unprintable ( source , len ) ) return hex_printable ( source , len ) ; else return quoted_printable ( source , len ) ; } | <S2SV_ModStart> char * source , size_t max_len <S2SV_ModStart> ; len = strnlen ( source , max_len <S2SV_ModEnd> ) ; if |
2,878 | CWE-000 void pdf_enc_compute_id_string ( const char * producer , const char * dviname , const char * pdfname ) { struct pdf_sec * p = & sec_data ; char datestr [ 32 ] ; MD5_CONTEXT md5 ; MD5_init ( & md5 ) ; dpx_util_format_asn_date ( datestr , 0 ) ; <S2SV_StartBug> MD5_write ( & md5 , ( unsigned char * ) datestr , strlen ( datestr ) ) ; <S2SV_EndBug> if ( producer ) <S2SV_StartBug> MD5_write ( & md5 , ( unsigned char * ) producer , strlen ( producer ) ) ; <S2SV_EndBug> if ( dviname ) <S2SV_StartBug> MD5_write ( & md5 , ( unsigned char * ) dviname , strlen ( dviname ) ) ; <S2SV_EndBug> if ( pdfname ) <S2SV_StartBug> MD5_write ( & md5 , ( unsigned char * ) pdfname , strlen ( pdfname ) ) ; <S2SV_EndBug> MD5_final ( p -> ID , & md5 ) ; } | <S2SV_ModStart> md5 , ( const <S2SV_ModStart> md5 , ( const <S2SV_ModStart> md5 , ( const <S2SV_ModStart> md5 , ( const |
2,879 | CWE-000 static void ipmi_bmc_unregister ( ipmi_smi_t intf ) { struct bmc_device * bmc = intf -> bmc ; if ( ! intf -> bmc_registered ) <S2SV_StartBug> return ; <S2SV_EndBug> sysfs_remove_link ( & intf -> si_dev -> kobj , "bmc" ) ; sysfs_remove_link ( & bmc -> pdev . dev . kobj , intf -> my_dev_name ) ; kfree ( intf -> my_dev_name ) ; intf -> my_dev_name = NULL ; <S2SV_StartBug> mutex_lock ( & ipmidriver_mutex ) ; <S2SV_EndBug> list_del ( & intf -> bmc_link ) ; <S2SV_StartBug> intf -> bmc = NULL ; <S2SV_EndBug> kref_put ( & bmc -> usecount , cleanup_bmc_device ) ; mutex_unlock ( & ipmidriver_mutex ) ; intf -> bmc_registered = false ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> bmc_registered ) return ; mutex_lock ( & intf -> bmc_reg_mutex ) <S2SV_ModStart> mutex_lock ( & bmc -> dyn_mutex <S2SV_ModEnd> ) ; list_del <S2SV_ModStart> bmc_link ) ; mutex_unlock ( & bmc -> dyn_mutex ) ; <S2SV_ModStart> bmc = NULL ; mutex_lock ( & ipmidriver_mutex ) <S2SV_ModStart> = false ; mutex_unlock ( & intf -> bmc_reg_mutex ) ; |
2,880 | CWE-000 EGLBoolean dri2_initialize_tizen ( _EGLDriver * drv , _EGLDisplay * dpy ) { struct dri2_egl_display * dri2_dpy ; tpl_display_t * tpl_display = NULL ; const char * err ; int tbm_bufmgr_fd = - 1 ; bool hw_accel = ! env_var_as_boolean ( "LIBGL_ALWAYS_SOFTWARE" , false ) ; loader_set_logger ( _eglLog ) ; dri2_dpy = calloc ( 1 , sizeof * dri2_dpy ) ; if ( ! dri2_dpy ) return _eglError ( EGL_BAD_ALLOC , "eglInitialize" ) ; dri2_dpy -> fd = - 1 ; dpy -> DriverData = ( void * ) dri2_dpy ; tpl_display = tpl_display_create ( TPL_BACKEND_UNKNOWN , dpy -> PlatformDisplay ) ; if ( ! tpl_display ) { err = "DRI2:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>tpl_display" ; goto cleanup ; } dri2_dpy -> tpl_display = tpl_display ; tbm_bufmgr_fd = tbm_drm_helper_get_fd ( ) ; if ( tbm_bufmgr_fd == - 1 ) { err = "DRI2:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>tbm_bufmgr<S2SV_blank>fd" ; goto cleanup ; } if ( hw_accel ) { int fd = - 1 ; if ( drmGetNodeTypeFromFd ( tbm_bufmgr_fd ) == DRM_NODE_RENDER ) fd = dup ( tbm_bufmgr_fd ) ; else { if ( ! tbm_drm_helper_get_auth_info ( & fd , NULL , NULL ) ) { # if 1 fd = dup ( tbm_bufmgr_fd ) ; # else err = "DRI2:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>fd<S2SV_blank>from<S2SV_blank>tbm_drm_helper_get_auth_info()" ; goto cleanup ; # endif } } if ( fd < 0 ) { err = "DRI2:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>fd" ; goto cleanup ; } dri2_dpy -> fd = fd ; dri2_dpy -> driver_name = loader_get_driver_for_fd ( dri2_dpy -> fd ) ; if ( dri2_dpy -> driver_name == NULL ) { err = "DRI2:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>driver<S2SV_blank>name" ; goto cleanup ; } dri2_dpy -> is_render_node = drmGetNodeTypeFromFd ( dri2_dpy -> fd ) == DRM_NODE_RENDER ; if ( ! dri2_dpy -> is_render_node ) { dri2_dpy -> loader_extensions = tizen_dri2_loader_extensions ; if ( ! dri2_load_driver ( dpy ) ) { err = "DRI2:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>load<S2SV_blank>driver" ; goto cleanup ; } } else { <S2SV_StartBug> err = "DRI2:<S2SV_blank>render<S2SV_blank>node<S2SV_blank>is<S2SV_blank>not<S2SV_blank>suppported" ; <S2SV_EndBug> goto cleanup ; } } else { dri2_dpy -> fd = dup ( tbm_bufmgr_fd ) ; if ( dri2_dpy -> fd < 0 ) { err = "DRI2:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>dup<S2SV_blank>fd" ; goto cleanup ; } dri2_dpy -> driver_name = strdup ( "swrast" ) ; if ( ! dri2_load_driver_swrast ( dpy ) ) { err = "DRI2:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>load<S2SV_blank>swrast<S2SV_blank>driver" ; goto cleanup ; } dri2_dpy -> loader_extensions = tizen_swrast_loader_extensions ; } if ( ! dri2_create_screen ( dpy ) ) { err = "DRI2:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>screen" ; goto cleanup ; } if ( ! dri2_setup_extensions ( dpy ) ) { err = "DRI2:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>setup<S2SV_blank>extensions" ; goto cleanup ; } dri2_setup_screen ( dpy ) ; if ( ! tizen_add_configs ( drv , dpy ) ) { err = "DRI2:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>add<S2SV_blank>configs" ; goto cleanup ; } dri2_dpy -> vtbl = & tizen_display_vtbl ; dpy -> Extensions . EXT_buffer_age = EGL_TRUE ; dpy -> Extensions . EXT_swap_buffers_with_damage = EGL_TRUE ; dpy -> Extensions . TIZEN_image_native_surface = EGL_TRUE ; dpy -> Extensions . WL_bind_wayland_display = EGL_TRUE ; drv -> API . BindWaylandDisplayWL = tizen_bind_wayland_display_wl ; drv -> API . UnbindWaylandDisplayWL = tizen_unbind_wayland_display_wl ; drv -> API . QueryWaylandBufferWL = tizen_query_wayland_buffer_wl ; return EGL_TRUE ; cleanup : dri2_display_destroy ( dpy ) ; return _eglError ( EGL_NOT_INITIALIZED , err ) ; } | <S2SV_ModStart> } else { dri2_dpy -> loader_extensions = tizen_image_loader_extensions ; if ( ! dri2_load_driver_dri3 ( dpy ) ) { err = "DRI3:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>load<S2SV_blank>driver" ; goto cleanup ; } <S2SV_ModEnd> } } else |
2,881 | CWE-000 <S2SV_StartBug> void merge ( unsigned int * const pOut , const unsigned int * const pIn ) { <S2SV_EndBug> const int elementsToCopy = pIn [ 0 ] ; int i , j ; for ( i = pOut [ 0 ] + 1 , j = 1 ; j <= elementsToCopy ; i ++ , j ++ ) { pOut [ i ] = pIn [ j ] ; } pOut [ 0 ] += elementsToCopy ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static inline |
2,882 | CWE-000 void showInfoText ( void ) { char ptemp [ 50 ] ; uint8_t i ; uint16_t aux ; usart_write_line ( USER_RS232 , "\\r\\n<S2SV_blank>\\r\\nLuxmeter<S2SV_blank>LMX-16<S2SV_blank>configuration<S2SV_blank>and<S2SV_blank>hardware<S2SV_blank>status:\\r\\n" ) ; usart_write_line ( USER_RS232 , "<S2SV_blank><S2SV_blank>Hardware<S2SV_blank>version:<S2SV_blank>" ) ; sprintf ( ptemp , "%c%c.%c%c\\r\\n" , hiddenConfig . hwMajor [ 0 ] , hiddenConfig . hwMajor [ 1 ] , hiddenConfig . hwMinor [ 0 ] , hiddenConfig . hwMinor [ 1 ] ) ; usart_write_line ( USER_RS232 , ptemp ) ; usart_write_line ( USER_RS232 , "<S2SV_blank><S2SV_blank>Firmware<S2SV_blank>version:<S2SV_blank>" ) ; sprintf ( ptemp , "%c%c.%c%c\\r\\n" , hiddenConfig . swMajor [ 0 ] , hiddenConfig . swMajor [ 1 ] , hiddenConfig . swMinor [ 0 ] , hiddenConfig . swMinor [ 1 ] ) ; usart_write_line ( USER_RS232 , ptemp ) ; usart_write_line ( USER_RS232 , "\\r\\nRS-232<S2SV_blank>port<S2SV_blank>settings:<S2SV_blank>" ) ; sprintf ( ptemp , "%2ld" , publicConfig2Save . comPortBaudrate ) ; usart_write_line ( USER_RS232 , ptemp ) ; usart_write_line ( USER_RS232 , "<S2SV_blank>baud,<S2SV_blank>RTS/CTS<S2SV_blank>handshaking<S2SV_blank>" ) ; DISP_ON_OFF ( publicConfig2Save . comPortHandshake ) ; usart_write_line ( USER_RS232 , ".\\r\\n" ) ; usart_write_line ( USER_RS232 , "\\r\\nMeasurement<S2SV_blank>settings:<S2SV_blank>speed<S2SV_blank>" ) ; sprintf ( ptemp , "%d" , publicConfig2Save . measNPLC ) ; usart_write_line ( USER_RS232 , ptemp ) ; usart_write_line ( USER_RS232 , "<S2SV_blank>NPLC,<S2SV_blank>line<S2SV_blank>frequency<S2SV_blank>" ) ; sprintf ( ptemp , "%d" , publicConfig2Save . measPowerLineFreq ) ; usart_write_line ( USER_RS232 , ptemp ) ; usart_write_line ( USER_RS232 , "<S2SV_blank>Hz,<S2SV_blank>rounding<S2SV_blank>" ) ; DISP_ON_OFF ( publicConfig2Save . measRounding ) ; usart_write_line ( USER_RS232 , ",\\r\\n<S2SV_blank><S2SV_blank>scientific<S2SV_blank>notation<S2SV_blank>" ) ; DISP_ON_OFF ( publicConfig2Save . measScientific ) ; usart_write_line ( USER_RS232 , ".\\r\\n" ) ; usart_write_line ( USER_RS232 , "\\r\\nChannel<S2SV_blank>status<S2SV_blank>(" ) ; sprintf ( ptemp , "%d" , channelCount ( publicConfig2Save . channelsToogleMask ) ) ; usart_write_line ( USER_RS232 , ptemp ) ; usart_write_line ( USER_RS232 , "<S2SV_blank>channels<S2SV_blank>are<S2SV_blank>ON):\\r\\n" ) ; aux = publicConfig2Save . channelsToogleMask ; usart_write_line ( USER_RS232 , "<S2SV_blank><S2SV_blank>+------+------+------+------+------+------+------+------+\\r\\n<S2SV_blank><S2SV_blank>" ) ; for ( i = 0 ; i < 8 ; i ++ ) { sprintf ( ptemp , "|<S2SV_blank>Ch%02d<S2SV_blank>" , i + 1 ) ; usart_write_line ( USER_RS232 , ptemp ) ; } usart_write_line ( USER_RS232 , "|\\r\\n<S2SV_blank><S2SV_blank>" ) ; for ( i = 0 ; i < 8 ; i ++ ) { usart_write_line ( USER_RS232 , "|<S2SV_blank>" ) ; DISP_ON_OFF_SPACE ( ( aux & 0x8000 ) ) ; usart_write_line ( USER_RS232 , "<S2SV_blank><S2SV_blank>" ) ; aux = aux << 1 ; } usart_write_line ( USER_RS232 , "|\\r\\n" ) ; usart_write_line ( USER_RS232 , "<S2SV_blank><S2SV_blank>+------+------+------+------+------+------+------+------+\\r\\n<S2SV_blank><S2SV_blank>" ) ; for ( i = 8 ; i < 16 ; i ++ ) { sprintf ( ptemp , "|<S2SV_blank>Ch%02d<S2SV_blank>" , i + 1 ) ; usart_write_line ( USER_RS232 , ptemp ) ; } usart_write_line ( USER_RS232 , "|\\r\\n<S2SV_blank><S2SV_blank>" ) ; for ( i = 8 ; i < 16 ; i ++ ) { usart_write_line ( USER_RS232 , "|<S2SV_blank>" ) ; DISP_ON_OFF_SPACE ( ( aux & 0x8000 ) ) ; usart_write_line ( USER_RS232 , "<S2SV_blank><S2SV_blank>" ) ; aux = aux << 1 ; } usart_write_line ( USER_RS232 , "|\\r\\n" ) ; usart_write_line ( USER_RS232 , "<S2SV_blank><S2SV_blank>+------+------+------+------+------+------+------+------+\\r\\n\\r\\n" ) ; <S2SV_StartBug> usart_write_line ( USER_RS232 , "Output<S2SV_blank>string<S2SV_blank>settings:<S2SV_blank>Prefix=\\"" ) ; <S2SV_EndBug> hexToStringRepresentation ( publicConfig2Save . outputPrefix ) ; <S2SV_StartBug> usart_write_line ( USER_RS232 , "\\",<S2SV_blank>separator<S2SV_blank>is<S2SV_blank>\\"" ) ; <S2SV_EndBug> hexToStringRepresentation ( publicConfig2Save . outputSeparator ) ; <S2SV_StartBug> usart_write_line ( USER_RS232 , "\\",\\r\\n" ) ; <S2SV_EndBug> usart_write_line ( USER_RS232 , "<S2SV_blank><S2SV_blank>suffix<S2SV_blank>is<S2SV_blank>\\"" ) ; hexToStringRepresentation ( publicConfig2Save . outputSuffix ) ; <S2SV_StartBug> usart_write_line ( USER_RS232 , "\\"<S2SV_blank>and<S2SV_blank>line<S2SV_blank>ending<S2SV_blank>is<S2SV_blank>\\"" ) ; <S2SV_EndBug> hexToStringRepresentation ( publicConfig2Save . outputLineEnding ) ; <S2SV_StartBug> usart_write_line ( USER_RS232 , "\\".\\r\\n\\r\\n" ) ; <S2SV_EndBug> usart_write_line ( USER_RS232 , "Example:\\r\\n<S2SV_blank><S2SV_blank>" ) ; outputStringExample ( publicConfig2Save . outputPrefix , publicConfig2Save . outputSeparator , publicConfig2Save . outputSuffix , publicConfig2Save . outputLineEnding , publicConfig2Save . measRounding , publicConfig2Save . measScientific ) ; usart_write_line ( USER_RS232 , "\\r\\n\\r\\n" ) ; measTimeInfo ( FALSE ) ; } | <S2SV_ModStart> ( USER_RS232 , "Output<S2SV_blank>string<S2SV_blank>settings:<S2SV_blank>Prefix<S2SV_blank>is<S2SV_blank>" <S2SV_ModEnd> ) ; hexToStringRepresentation <S2SV_ModStart> ( USER_RS232 , "<S2SV_blank>separator<S2SV_blank>is<S2SV_blank>" <S2SV_ModEnd> ) ; hexToStringRepresentation <S2SV_ModStart> ( USER_RS232 , "\\r\\n" ) ; usart_write_line ( USER_RS232 , "<S2SV_blank><S2SV_blank>suffix<S2SV_blank>is<S2SV_blank>" <S2SV_ModEnd> ) ; hexToStringRepresentation <S2SV_ModStart> ( USER_RS232 , "<S2SV_blank>and<S2SV_blank>line<S2SV_blank>ending<S2SV_blank>is<S2SV_blank>" <S2SV_ModEnd> ) ; hexToStringRepresentation <S2SV_ModStart> ( USER_RS232 , ".\\r\\n\\r\\n" <S2SV_ModEnd> ) ; usart_write_line |
2,883 | CWE-000 void WM_init ( bContext * C , int argc , const char * * argv ) { if ( ! G . background ) { wm_ghost_init ( C ) ; wm_init_cursor_data ( ) ; } GHOST_CreateSystemPaths ( ) ; BKE_addon_pref_type_init ( ) ; wm_operatortype_init ( ) ; wm_operatortypes_register ( ) ; WM_menutype_init ( ) ; WM_uilisttype_init ( ) ; ED_undosys_type_init ( ) ; BKE_library_callback_free_window_manager_set ( wm_close_and_free ) ; BKE_library_callback_free_notifier_reference_set ( WM_main_remove_notifier_reference ) ; BKE_library_callback_remap_editor_id_reference_set ( WM_main_remap_editor_id_reference ) ; BKE_blender_callback_test_break_set ( wm_window_testbreak ) ; BKE_spacedata_callback_id_remap_set ( ED_spacedata_id_remap ) ; DAG_editors_update_cb ( ED_render_id_flush_update , ED_render_scene_update , ED_render_scene_update_pre ) ; ED_spacetypes_init ( ) ; ED_file_init ( ) ; ED_node_init_butfuncs ( ) ; BLF_init ( ) ; BLT_lang_init ( ) ; <S2SV_StartBug> wm_init_reports ( C ) ; <S2SV_EndBug> wm_homefile_read ( C , NULL , G . factory_startup , false , true , NULL , WM_init_state_app_template_get ( ) ) ; BLT_lang_set ( NULL ) ; if ( ! G . background ) { # ifdef WITH_INPUT_NDOF WM_ndof_deadzone_set ( U . ndof_deadzone ) ; # endif GPU_init ( ) ; GPU_set_mipmap ( G_MAIN , ! ( U . gameflags & USER_DISABLE_MIPMAP ) ) ; GPU_set_linear_mipmap ( true ) ; GPU_set_anisotropic ( G_MAIN , U . anisotropic_filter ) ; GPU_set_gpu_mipmapping ( G_MAIN , U . use_gpu_mipmap ) ; # ifdef WITH_OPENSUBDIV BKE_subsurf_osd_init ( ) ; # endif UI_init ( ) ; } else { BKE_icons_init ( 1 ) ; } ED_spacemacros_init ( ) ; # ifdef WITH_PYTHON BPY_context_set ( C ) ; BPY_python_start ( argc , argv ) ; BPY_python_reset ( C ) ; # else ( void ) argc ; ( void ) argv ; # endif if ( ! G . background && ! wm_start_with_console ) GHOST_toggleConsole ( 3 ) ; clear_matcopybuf ( ) ; ED_render_clear_mtex_copybuf ( ) ; wm_history_file_read ( ) ; # if 0 if ( BKE_main_blendfile_path_from_global ( ) [ 0 ] == '\\0' ) BLI_make_file_string ( "/" , G_MAIN -> name , BKE_appdir_folder_default ( ) , "untitled.blend" ) ; # endif BLI_strncpy ( G . lib , BKE_main_blendfile_path_from_global ( ) , sizeof ( G . lib ) ) ; # ifdef WITH_COMPOSITOR if ( 1 ) { extern void * COM_linker_hack ; COM_linker_hack = COM_execute ; } # endif if ( U . uiflag2 & USER_KEEP_SESSION ) { } else { Main * bmain = CTX_data_main ( C ) ; CTX_wm_window_set ( C , CTX_wm_manager ( C ) -> windows . first ) ; BLI_callback_exec ( bmain , NULL , BLI_CB_EVT_VERSION_UPDATE ) ; BLI_callback_exec ( bmain , NULL , BLI_CB_EVT_LOAD_POST ) ; wm_file_read_report ( C , bmain ) ; if ( ! G . background ) { CTX_wm_window_set ( C , NULL ) ; } } } | <S2SV_ModStart> ( ) ; BLT_lang_set ( NULL ) ; |
2,884 | CWE-000 int linux_schedule_timeout ( int timeout ) { struct task_struct * task ; int ret ; int state ; int remainder ; task = current ; if ( timeout < 1 ) timeout = 1 ; else if ( timeout == MAX_SCHEDULE_TIMEOUT ) timeout = 0 ; remainder = ticks + timeout ; <S2SV_StartBug> DROP_GIANT ( ) ; <S2SV_EndBug> sleepq_lock ( task ) ; state = atomic_read ( & task -> state ) ; if ( state != TASK_WAKING ) { ret = linux_add_to_sleepqueue ( task , task , "sched" , timeout , state ) ; } else { sleepq_release ( task ) ; ret = 0 ; } <S2SV_StartBug> set_task_state ( task , TASK_RUNNING ) ; <S2SV_EndBug> PICKUP_GIANT ( ) ; if ( timeout == 0 ) return ( MAX_SCHEDULE_TIMEOUT ) ; remainder -= ticks ; if ( ret == - ERESTARTSYS && remainder < 1 ) remainder = 1 ; else if ( remainder < 0 ) remainder = 0 ; else if ( remainder > timeout ) remainder = timeout ; return ( remainder ) ; } | <S2SV_ModStart> + timeout ; <S2SV_ModEnd> sleepq_lock ( task <S2SV_ModStart> task , TASK_RUNNING <S2SV_ModEnd> ) ; if |
2,885 | CWE-000 void printStates ( int k ) { if ( k < N + 1 ) { for ( int i = getHead ( k , 1 ) ; i < getHead ( k + 1 , k == N ? 0 : 1 ) ; i ++ ) { printf ( "%d\\n" , i ) ; printf ( "F<S2SV_blank>=<S2SV_blank>%lf,<S2SV_blank>T<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>Pi<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>G<S2SV_blank>=<S2SV_blank>%lf,<S2SV_blank>Gamma<S2SV_blank>=<S2SV_blank>%d\\n" , realF [ i ] , stateTime [ i ] , Pi [ i ] , G [ i ] , Gamma [ i ] ) ; printPath ( i , 0 ) ; printf ( "\\n" ) ; } } else { for ( int i = getHead ( k , 0 ) ; i < getHead ( k , 1 ) ; i ++ ) { printf ( "%d\\n" , i ) ; <S2SV_StartBug> printf ( "F<S2SV_blank>=<S2SV_blank>%lf,<S2SV_blank>T<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>Pi<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>G<S2SV_blank>=<S2SV_blank>%lf,<S2SV_blank>Gamma<S2SV_blank>=<S2SV_blank>%d\\n" , realF [ i ] , stateTime [ i ] , Pi [ i ] , G [ i ] , Gamma [ i ] ) ; <S2SV_EndBug> printPath ( i , 0 ) ; printf ( "\\n" ) ; } } } | <S2SV_ModStart> ; printf ( "F<S2SV_blank>=<S2SV_blank>%lf,<S2SV_blank>T<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>realF<S2SV_blank>=<S2SV_blank>%lf,<S2SV_blank>Pi<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>G<S2SV_blank>=<S2SV_blank>%lf,<S2SV_blank>Gamma<S2SV_blank>=<S2SV_blank>%d\\n" , F [ i ] , stateTime [ i ] <S2SV_ModEnd> , realF [ <S2SV_ModStart> i ] , <S2SV_ModEnd> Pi [ i |
2,886 | CWE-000 <S2SV_StartBug> int aggregate_2d_init ( struct aggregate_2d * agg , double stickiness ) { <S2SV_EndBug> agg -> _aggregate = ( struct vector * ) NULL ; agg -> _attractor = ( struct vector * ) NULL ; agg -> _rsteps = ( struct vector * ) NULL ; agg -> _bcolls = ( struct vector * ) NULL ; agg -> _aggregate = vector_alloc ( sizeof ( struct pair ) ) ; if ( ! ( agg -> _aggregate ) ) goto errorcleanup ; agg -> _attractor = vector_alloc ( sizeof ( struct pair ) ) ; if ( ! ( agg -> _attractor ) ) goto errorcleanup ; agg -> _rsteps = vector_alloc ( sizeof ( size_t ) ) ; if ( ! ( agg -> _rsteps ) ) goto errorcleanup ; agg -> _bcolls = vector_alloc ( sizeof ( size_t ) ) ; if ( ! ( agg -> _bcolls ) ) goto errorcleanup ; agg -> stickiness = stickiness ; agg -> max_x = 0U ; agg -> max_y = 0U ; agg -> max_r_sqd = agg -> max_x * agg -> max_x + agg -> max_y * agg -> max_y ; agg -> b_offset = 6U ; agg -> spawn_diam = agg -> b_offset ; agg -> att_size = 1U ; <S2SV_StartBug> agg -> lt = SQUARE ; <S2SV_EndBug> <S2SV_StartBug> agg -> at = POINT ; <S2SV_EndBug> srand ( time ( NULL ) ) ; return 0 ; errorcleanup : aggregate_2d_free_fields ( agg ) ; return - 1 ; } | <S2SV_ModStart> , double stickiness , enum lattice_type lt , enum attractor_type at <S2SV_ModStart> -> lt = lt <S2SV_ModEnd> ; agg -> <S2SV_ModStart> -> at = at <S2SV_ModEnd> ; srand ( |
2,887 | CWE-000 void common_hal_audioio_audioout_stop ( audioio_audioout_obj_t * self ) { Tc * timer = tc_insts [ self -> tc_index ] ; timer -> COUNT16 . CTRLBSET . reg = TC_CTRLBSET_CMD_STOP ; audio_dma_stop ( & self -> left_dma ) ; # ifdef SAMD51 audio_dma_stop ( & self -> right_dma ) ; # endif <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ; # endif ramp_value ( self -> default_value , self -> default_value ) ; |
2,888 | CWE-000 void af_prim_colon ( af_global_t * global , af_task_t * task ) { af_byte_t * name ; af_cell_t name_length ; size_t name_size ; void * word_space ; af_word_t * word ; if ( ! af_parse_name_available ( global , task ) ) { af_handle_word_expected ( global , task ) ; return ; } name = af_parse_name ( global , task , & name_length ) ; name_length = name_length < 256 ? name_length : 255 ; name_size = ( name_length + 1 ) * sizeof ( af_byte_t ) ; if ( ! ( word_space = af_allocate ( global , task , sizeof ( af_word_t ) + name_size ) ) ) { return ; } word = word_space + name_size ; AF_WORD_NAME_LEN ( word ) = ( af_byte_t ) name_length ; memmove ( AF_WORD_NAME_DATA ( word ) , name , name_length ) ; word -> next_word = task -> current_wordlist -> first_word ; <S2SV_StartBug> word -> is_immediate = FALSE ; <S2SV_EndBug> word -> code = af_prim_docol ; word -> secondary = ( af_compiled_t * ) ( word + 1 ) ; word -> next_of_all_words = global -> first_of_all_words ; global -> first_of_all_words = word ; task -> most_recent_word = word ; task -> current_wordlist -> first_word = word ; task -> is_compiling = TRUE ; AF_ADVANCE_IP ( task , 1 ) ; } | <S2SV_ModStart> ; word -> flags = AF_WORD_HIDDEN <S2SV_ModEnd> ; word -> |
2,889 | CWE-000 static void _evas_svg_loader_xml_open_parser ( Evas_SVG_Loader * loader , const char * content , unsigned int length ) { const char * attrs = NULL ; int attrs_length = 0 ; int sz = length ; char tag_name [ 20 ] = "" ; Factory_Method method ; Gradient_Factory_Method gradient_method ; Svg_Node * node = NULL , * parent ; loader -> level ++ ; attrs = eina_simple_xml_tag_attributes_find ( content , length ) ; if ( ! attrs ) { attrs = content ; while ( ( attrs != NULL ) && * attrs != '>' ) attrs ++ ; } if ( attrs ) { sz = attrs - content ; attrs_length = length - sz ; while ( ( sz > 0 ) && ( isspace ( content [ sz - 1 ] ) ) ) sz -- ; strncpy ( tag_name , content , sz ) ; tag_name [ sz ] = '\\0' ; } if ( ( method = _find_group_factory ( tag_name ) ) ) { if ( ! loader -> doc ) { if ( strcmp ( tag_name , "svg" ) ) return ; node = method ( NULL , attrs , attrs_length ) ; loader -> doc = node ; } else { parent = eina_array_data_get ( loader -> stack , eina_array_count ( loader -> stack ) - 1 ) ; node = method ( parent , attrs , attrs_length ) ; } eina_array_push ( loader -> stack , node ) ; if ( node -> type == SVG_NODE_DEFS ) { loader -> doc -> node . doc . defs = node ; loader -> def = node ; } } else if ( ( method = _find_graphics_factory ( tag_name ) ) ) { parent = eina_array_data_get ( loader -> stack , eina_array_count ( loader -> stack ) - 1 ) ; node = method ( parent , attrs , attrs_length ) ; } else if ( ( gradient_method = _find_gradient_factory ( tag_name ) ) ) { Svg_Style_Gradient * gradient ; gradient = gradient_method ( attrs , attrs_length ) ; if ( loader -> doc -> node . doc . defs ) { loader -> def -> node . defs . gradients = eina_list_append ( loader -> def -> node . defs . gradients , gradient ) ; } loader -> gradient = gradient ; } else if ( ! strcmp ( tag_name , "stop" ) ) { Efl_Gfx_Gradient_Stop * stop = calloc ( 1 , sizeof ( Efl_Gfx_Gradient_Stop ) ) ; <S2SV_StartBug> eina_simple_xml_attributes_parse ( attrs , attrs_length , <S2SV_EndBug> _attr_parse_stops , stop ) ; if ( loader -> gradient ) loader -> gradient -> stops = eina_list_append ( loader -> gradient -> stops , stop ) ; } } | <S2SV_ModStart> ) ) ; stop -> a = 255 ; |
2,890 | CWE-000 double wallsPressure ( const double * r , const double * W , double L ) { double P = 0.0 ; double dx , dy , dz , dr2 , dr6 ; double dw = L / M ; <S2SV_StartBug> for ( int m = 0 ; m < M ; m ++ ) <S2SV_EndBug> { dx = r [ 3 * i ] - m * dw + dw / 2 ; dx = dx - L * rint ( dx / L ) ; dz = r [ 3 * i + 2 ] + L / 2 ; dz = dz - L * rint ( dz / L ) ; dr2 = dx * dx + dz * dz ; if ( dr2 < L * L / 4 ) { dr6 = dr2 * dr2 * dr2 ; P += 24.0 * W [ 2 * m + 1 ] / dr6 - 48.0 * W [ 2 * m ] / ( dr6 * dr6 ) ; } } <S2SV_StartBug> return - P / ( 3 * L * L * L ) ; <S2SV_EndBug> } | <S2SV_ModStart> M ; m ++ ) { for ( int i = 0 ; i < N ; i <S2SV_ModStart> ; } } } |
2,891 | CWE-000 static int webu_mhd_send ( struct webui_ctx * webui , int ctrl ) { int retcd ; struct MHD_Response * response ; response = MHD_create_response_from_buffer ( strlen ( webui -> resp_page ) , ( void * ) webui -> resp_page , MHD_RESPMEM_PERSISTENT ) ; if ( ! response ) { MOTION_LOG ( ERR , TYPE_STREAM , NO_ERRNO , _ ( "Invalid<S2SV_blank>response" ) ) ; return MHD_NO ; } <S2SV_StartBug> if ( ctrl ) { <S2SV_EndBug> if ( webui -> cnt -> conf . webcontrol_cors_header != NULL ) { MHD_add_response_header ( response , MHD_HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN , webui -> cnt -> conf . webcontrol_cors_header ) ; } if ( webui -> cnt -> conf . webcontrol_interface == 1 ) { MHD_add_response_header ( response , MHD_HTTP_HEADER_CONTENT_TYPE , "text/plain;" ) ; } else { MHD_add_response_header ( response , MHD_HTTP_HEADER_CONTENT_TYPE , "text/html" ) ; } } else { if ( webui -> cnt -> conf . stream_cors_header != NULL ) { MHD_add_response_header ( response , MHD_HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN , webui -> cnt -> conf . stream_cors_header ) ; } MHD_add_response_header ( response , MHD_HTTP_HEADER_CONTENT_TYPE , "text/html" ) ; } <S2SV_StartBug> retcd = MHD_queue_response ( webui -> connection , MHD_HTTP_OK , response ) ; <S2SV_EndBug> MHD_destroy_response ( response ) ; return retcd ; } | <S2SV_ModStart> } if ( webui -> cnt != NULL ) { if ( <S2SV_ModStart> ) ; } } |
2,892 | CWE-000 static int intel_gen7_queue_flip ( struct drm_device * dev , struct drm_crtc * crtc , struct drm_framebuffer * fb , struct drm_i915_gem_object * obj ) { struct drm_i915_private * dev_priv = dev -> dev_private ; struct intel_crtc * intel_crtc = to_intel_crtc ( crtc ) ; struct intel_ring_buffer * ring = & dev_priv -> ring [ BCS ] ; <S2SV_StartBug> int ret ; <S2SV_EndBug> ret = intel_pin_and_fence_fb_obj ( dev , obj , ring ) ; if ( ret ) goto err ; <S2SV_StartBug> ret = intel_ring_begin ( ring , 4 ) ; <S2SV_EndBug> if ( ret ) goto err_unpin ; <S2SV_StartBug> intel_ring_emit ( ring , MI_DISPLAY_FLIP_I915 | ( intel_crtc -> plane << 19 ) ) ; <S2SV_EndBug> intel_ring_emit ( ring , ( fb -> pitches [ 0 ] | obj -> tiling_mode ) ) ; intel_ring_emit ( ring , ( obj -> gtt_offset ) ) ; intel_ring_emit ( ring , ( MI_NOOP ) ) ; intel_ring_advance ( ring ) ; return 0 ; err_unpin : intel_unpin_fb_obj ( obj ) ; err : return ret ; } | <S2SV_ModStart> BCS ] ; uint32_t plane_bit = 0 ; <S2SV_ModStart> goto err ; switch ( intel_crtc -> plane ) { case PLANE_A : plane_bit = MI_DISPLAY_FLIP_IVB_PLANE_A ; break ; case PLANE_B : plane_bit = MI_DISPLAY_FLIP_IVB_PLANE_B ; break ; case PLANE_C : plane_bit = MI_DISPLAY_FLIP_IVB_PLANE_C ; break ; default : WARN_ONCE ( 1 , "unknown<S2SV_blank>plane<S2SV_blank>in<S2SV_blank>flip<S2SV_blank>command\\n" ) ; ret = - ENODEV ; goto err ; } <S2SV_ModStart> , MI_DISPLAY_FLIP_I915 | plane_bit <S2SV_ModEnd> ) ; intel_ring_emit |
2,893 | CWE-000 static ssize_t pipe_read ( struct kiocb * iocb , const struct iovec * _iov , unsigned long nr_segs , loff_t pos ) { struct file * filp = iocb -> ki_filp ; struct inode * inode = filp -> f_path . dentry -> d_inode ; struct pipe_inode_info * pipe ; int do_wakeup ; ssize_t ret ; struct iovec * iov = ( struct iovec * ) _iov ; size_t total_len ; total_len = iov_length ( iov , nr_segs ) ; if ( unlikely ( total_len == 0 ) ) return 0 ; do_wakeup = 0 ; ret = 0 ; mutex_lock ( & inode -> i_mutex ) ; pipe = inode -> i_pipe ; for ( ; ; ) { int bufs = pipe -> nrbufs ; if ( bufs ) { int curbuf = pipe -> curbuf ; struct pipe_buffer * buf = pipe -> bufs + curbuf ; const struct pipe_buf_operations * ops = buf -> ops ; void * addr ; size_t chars = buf -> len , remaining ; int error , atomic ; int offset ; if ( chars > total_len ) chars = total_len ; error = ops -> confirm ( pipe , buf ) ; if ( error ) { if ( ! ret ) ret = error ; break ; } atomic = ! iov_fault_in_pages_write ( iov , chars ) ; remaining = chars ; offset = buf -> offset ; redo : addr = ops -> map ( pipe , buf , atomic ) ; error = pipe_iov_copy_to_user ( iov , addr , & offset , & remaining , atomic ) ; ops -> unmap ( pipe , buf , addr ) ; if ( unlikely ( error ) ) { if ( atomic ) { atomic = 0 ; goto redo ; } if ( ! ret ) ret = error ; break ; } ret += chars ; <S2SV_StartBug> buf -> offset += chars ; <S2SV_EndBug> buf -> len -= chars ; if ( buf -> flags & PIPE_BUF_FLAG_PACKET ) { total_len = chars ; buf -> len = 0 ; } if ( ! buf -> len ) { buf -> ops = NULL ; ops -> release ( pipe , buf ) ; curbuf = ( curbuf + 1 ) & ( pipe -> buffers - 1 ) ; pipe -> curbuf = curbuf ; pipe -> nrbufs = -- bufs ; do_wakeup = 1 ; } total_len -= chars ; if ( ! total_len ) break ; } if ( bufs ) continue ; if ( ! pipe -> writers ) break ; if ( ! pipe -> waiting_writers ) { if ( ret ) break ; if ( filp -> f_flags & O_NONBLOCK ) { ret = - EAGAIN ; break ; } } if ( signal_pending ( current ) ) { if ( ! ret ) ret = - ERESTARTSYS ; break ; } if ( do_wakeup ) { wake_up_interruptible_sync_poll ( & pipe -> wait , POLLOUT | POLLWRNORM ) ; kill_fasync ( & pipe -> fasync_writers , SIGIO , POLL_OUT ) ; } pipe_wait ( pipe ) ; } mutex_unlock ( & inode -> i_mutex ) ; if ( do_wakeup ) { wake_up_interruptible_sync_poll ( & pipe -> wait , POLLOUT | POLLWRNORM ) ; kill_fasync ( & pipe -> fasync_writers , SIGIO , POLL_OUT ) ; } if ( ret > 0 ) file_accessed ( filp ) ; return ret ; } | <S2SV_ModStart> ; buf -> <S2SV_ModEnd> len -= chars |
2,894 | CWE-000 static void ds_obj_rw_complete ( crt_rpc_t * rpc , daos_handle_t ioh , int status , <S2SV_StartBug> uint32_t map_version , struct ds_cont_hdl * cont_hdl ) <S2SV_EndBug> { int rc ; if ( ! daos_handle_is_inval ( ioh ) ) { struct obj_rw_in * orwi ; orwi = crt_req_get ( rpc ) ; D_ASSERT ( orwi != NULL ) ; if ( opc_get ( rpc -> cr_opc ) == DAOS_OBJ_RPC_UPDATE ) { <S2SV_StartBug> rc = vos_obj_zc_update_end ( ioh , cont_hdl -> sch_uuid , <S2SV_EndBug> & orwi -> orw_dkey , orwi -> orw_nr , orwi -> orw_iods . da_arrays , status ) ; } else { D_ASSERT ( opc_get ( rpc -> cr_opc ) == DAOS_OBJ_RPC_FETCH ) ; rc = vos_obj_zc_fetch_end ( ioh , & orwi -> orw_dkey , orwi -> orw_nr , orwi -> orw_iods . da_arrays , status ) ; } if ( rc != 0 ) { D_ERROR ( DF_UOID "%x<S2SV_blank>ZC<S2SV_blank>end<S2SV_blank>failed:<S2SV_blank>%d\\n" , DP_UOID ( orwi -> orw_oid ) , opc_get ( rpc -> cr_opc ) , rc ) ; if ( status == 0 ) status = rc ; } } obj_reply_set_status ( rpc , status ) ; obj_reply_map_version_set ( rpc , map_version ) ; rc = crt_reply_send ( rpc ) ; if ( rc != 0 ) D_ERROR ( "send<S2SV_blank>reply<S2SV_blank>failed:<S2SV_blank>%d\\n" , rc ) ; if ( opc_get ( rpc -> cr_opc ) == DAOS_OBJ_RPC_FETCH ) { struct obj_rw_out * orwo ; orwo = crt_reply_get ( rpc ) ; D_ASSERT ( orwo != NULL ) ; if ( orwo -> orw_sizes . da_arrays != NULL ) { D_FREE ( orwo -> orw_sizes . da_arrays , orwo -> orw_sizes . da_count * sizeof ( uint64_t ) ) ; orwo -> orw_sizes . da_count = 0 ; } if ( orwo -> orw_nrs . da_arrays != NULL ) { D_FREE ( orwo -> orw_nrs . da_arrays , orwo -> orw_nrs . da_count * sizeof ( uint32_t ) ) ; orwo -> orw_nrs . da_count = 0 ; } } } | <S2SV_ModStart> uint32_t map_version , uuid_t cookie <S2SV_ModEnd> ) { int <S2SV_ModStart> ( ioh , cookie <S2SV_ModEnd> , & orwi |
2,895 | CWE-000 int main ( ) <S2SV_StartBug> { <S2SV_EndBug> while ( 1 ) { <S2SV_StartBug> printf ( "Hello<S2SV_blank>from<S2SV_blank>user<S2SV_blank>space<S2SV_blank>task<S2SV_blank>1\\r\\n" ) ; <S2SV_EndBug> } # if 0 here : __asm ( ".intel_syntax<S2SV_blank>noprefix" ) ; __asm volatile ( "mov<S2SV_blank>eax,<S2SV_blank>0xdeadbeef" ) ; goto here ; # endif return 0 ; } | <S2SV_ModStart> ( ) { unsigned int i = 0 ; <S2SV_ModStart> { printf ( "1<S2SV_blank>-<S2SV_blank>%d\\r\\n" , i ++ <S2SV_ModEnd> ) ; } |
2,896 | CWE-000 static void remote_store_registers ( struct target_ops * ops , struct regcache * regcache , int regnum ) { <S2SV_StartBug> struct remote_arch_state * rsa = get_remote_arch_state ( ) ; <S2SV_EndBug> int i ; set_remote_traceframe ( ) ; set_general_thread ( regcache_get_ptid ( regcache ) ) ; if ( regnum >= 0 ) { <S2SV_StartBug> struct packet_reg * reg = packet_reg_from_regnum ( rsa , regnum ) ; <S2SV_EndBug> gdb_assert ( reg != NULL ) ; if ( store_register_using_P ( regcache , reg ) ) return ; if ( ! reg -> in_g_packet ) return ; store_registers_using_G ( regcache ) ; return ; } store_registers_using_G ( regcache ) ; <S2SV_StartBug> for ( i = 0 ; i < gdbarch_num_regs ( get_regcache_arch ( regcache ) ) ; i ++ ) <S2SV_EndBug> if ( ! rsa -> regs [ i ] . in_g_packet ) if ( ! store_register_using_P ( regcache , & rsa -> regs [ i ] ) ) continue ; } | <S2SV_ModStart> ) { struct gdbarch * gdbarch = regcache -> arch ( ) ; <S2SV_ModStart> = get_remote_arch_state ( gdbarch <S2SV_ModStart> 0 ) { <S2SV_ModEnd> packet_reg * reg <S2SV_ModStart> = packet_reg_from_regnum ( gdbarch , <S2SV_ModStart> < gdbarch_num_regs ( gdbarch <S2SV_ModEnd> ) ; i |
2,897 | CWE-000 void easelcomm_handle_cmd_dma_xfer ( struct easelcomm_service * service , char * command_args , <S2SV_StartBug> int command_arg_len ) <S2SV_EndBug> { struct easelcomm_dma_xfer_arg * dma_xfer ; struct easelcomm_message_metadata * msg_metadata ; if ( WARN_ON ( command_arg_len < sizeof ( struct easelcomm_dma_xfer_arg ) ) ) return ; dma_xfer = ( struct easelcomm_dma_xfer_arg * ) command_args ; dev_dbg ( easelcomm_miscdev . this_device , "recv<S2SV_blank>cmd<S2SV_blank>DMA_XFER<S2SV_blank>msg<S2SV_blank>%u:%s%llu<S2SV_blank>type=%u<S2SV_blank>saddr=%llx\\n" , service -> service_id , dma_xfer -> dma_dir == EASELCOMM_DMA_DIR_TO_SERVER ? "l" : "r" , dma_xfer -> message_id , dma_xfer -> xfer_type , dma_xfer -> server_addr ) ; if ( dma_xfer -> dma_dir == EASELCOMM_DMA_DIR_TO_SERVER ) { msg_metadata = easelcomm_find_local_message ( service , dma_xfer -> message_id ) ; } else { msg_metadata = easelcomm_find_remote_message ( service , dma_xfer -> message_id ) ; } if ( ! msg_metadata ) { dev_err ( easelcomm_miscdev . this_device , "DMA_XFER<S2SV_blank>msg<S2SV_blank>%u:%s%llu<S2SV_blank>not<S2SV_blank>found\\n" , service -> service_id , dma_xfer -> dma_dir == EASELCOMM_DMA_DIR_TO_SERVER ? "l" : "r" , dma_xfer -> message_id ) ; return ; } msg_metadata -> dma_xfer . xfer_type = dma_xfer -> xfer_type ; msg_metadata -> dma_xfer . server_addr = dma_xfer -> server_addr ; complete ( & msg_metadata -> dma_xfer . xfer_ready ) ; easelcomm_drop_reference ( service , msg_metadata , false ) ; } | <S2SV_ModStart> * command_args , size_t <S2SV_ModEnd> command_arg_len ) { |
2,898 | CWE-000 static void parse_long_opts ( int opt_flow_index , char * optarg ) { errno = 0 ; switch ( opt_flow_index ) { case NO_DAEMON_OPT_INDEX : case NO_HUGE_OPT_INDEX : case NO_GRO_OPT_INDEX : case NO_GSO_OPT_INDEX : case NO_RX_MRG_BUF_INDEX : break ; case VERSION_OPT_INDEX : version_print ( ) ; exit ( 0 ) ; break ; case MEMPOOL_SIZE_OPT_INDEX : vr_mempool_sz = ( unsigned int ) strtoul ( optarg , NULL , 0 ) ; if ( errno != 0 ) { <S2SV_StartBug> vr_mempool_sz = VR_DEF_MEMPOOL_SZ ; <S2SV_EndBug> } break ; case PACKET_SIZE_OPT_INDEX : vr_packet_sz = ( unsigned int ) strtoul ( optarg , NULL , 0 ) ; if ( errno != 0 ) { vr_packet_sz = VR_DEF_MAX_PACKET_SZ ; } break ; case VLAN_TCI_OPT_INDEX : vr_dpdk . vlan_tag = ( uint16_t ) strtoul ( optarg , NULL , 0 ) ; if ( errno != 0 ) { vr_dpdk . vlan_tag = VLAN_ID_INVALID ; } if ( vr_dpdk . vlan_tag > 4095 ) Usage ( ) ; break ; case VTEST_VLAN_OPT_INDEX : vr_dpdk . vtest_vlan = 1 ; break ; case VLAN_NAME_OPT_INDEX : strncpy ( vr_dpdk . vlan_name , optarg , sizeof ( vr_dpdk . vlan_name ) - 1 ) ; break ; case VDEV_OPT_INDEX : dpdk_argv_append ( "--" VDEV_OPT , optarg ) ; break ; case BRIDGE_ENTRIES_OPT_INDEX : vr_bridge_entries = ( unsigned int ) strtoul ( optarg , NULL , 0 ) ; if ( errno != 0 ) { vr_bridge_entries = VR_DEF_BRIDGE_ENTRIES ; } break ; case BRIDGE_OENTRIES_OPT_INDEX : vr_bridge_oentries = ( unsigned int ) strtoul ( optarg , NULL , 0 ) ; if ( errno != 0 ) { vr_bridge_oentries = ( ( vr_bridge_entries / 5 ) + 1023 ) & ~ 1023 ; } break ; case FLOW_ENTRIES_OPT_INDEX : vr_flow_entries = ( unsigned int ) strtoul ( optarg , NULL , 0 ) ; if ( errno != 0 ) { vr_flow_entries = VR_DEF_FLOW_ENTRIES ; } break ; case OFLOW_ENTRIES_OPT_INDEX : vr_oflow_entries = ( unsigned int ) strtoul ( optarg , NULL , 0 ) ; if ( errno != 0 ) { vr_oflow_entries = ( ( vr_flow_entries / 5 ) + 1023 ) & ~ 1023 ; } break ; case MEMORY_ALLOC_CHECKS_OPT_INDEX : vr_memory_alloc_checks = 1 ; break ; case MPLS_LABELS_OPT_INDEX : vr_mpls_labels = ( unsigned int ) strtoul ( optarg , NULL , 0 ) ; if ( errno != 0 ) { vr_mpls_labels = VR_DEF_LABELS ; } break ; case NEXTHOPS_OPT_INDEX : vr_nexthops = ( unsigned int ) strtoul ( optarg , NULL , 0 ) ; if ( errno != 0 ) { vr_nexthops = VR_DEF_NEXTHOPS ; } break ; case VRFS_OPT_INDEX : vr_vrfs = ( unsigned int ) strtoul ( optarg , NULL , 0 ) ; if ( errno != 0 ) { vr_vrfs = VR_DEF_VRFS ; } break ; case SOCKET_DIR_OPT_INDEX : vr_socket_dir = optarg ; break ; case NETLINK_PORT_OPT_INDEX : vr_netlink_port = ( unsigned int ) strtoul ( optarg , NULL , 0 ) ; if ( errno != 0 ) { vr_netlink_port = VR_DEF_NETLINK_PORT ; } break ; case SOCKET_MEM_OPT_INDEX : dpdk_argv_remove ( "-m" ) ; dpdk_argv_append ( "--" SOCKET_MEM_OPT , optarg ) ; break ; case LOG_FILE_OPT_INDEX : strncpy ( dpdk_log_file , optarg , sizeof ( dpdk_log_file ) - 1 ) ; dpdk_log_file [ sizeof ( dpdk_log_file ) - 1 ] = '\\0' ; break ; case HELP_OPT_INDEX : default : Usage ( ) ; } } | <S2SV_ModStart> vr_mempool_sz = VR_DEF_MEMPOOL_SZ ; } break ; case DPDK_RXD_SIZE_OPT_INDEX : vr_rxd_sz = ( unsigned int ) strtoul ( optarg , NULL , 0 ) ; if ( errno != 0 ) { vr_rxd_sz = VR_DPDK_NB_RXD ; } break ; case DPDK_TXD_SIZE_OPT_INDEX : vr_txd_sz = ( unsigned int ) strtoul ( optarg , NULL , 0 ) ; if ( errno != 0 ) { vr_txd_sz = VR_DPDK_NB_TXD |
2,899 | CWE-000 DEFUN_HIDDEN ( cfg_ts_pchan_compat , cfg_ts_pchan_compat_cmd , "phys_chan_config<S2SV_blank>PCHAN" , "Physical<S2SV_blank>Channel<S2SV_blank>configuration<S2SV_blank>(TCH/SDCCH/...)\\n" "Physical<S2SV_blank>Channel\\n" ) { struct gsm_bts_trx_ts * ts = vty -> index ; int pchanc ; pchanc = gsm_pchan_parse ( argv [ 0 ] ) ; <S2SV_StartBug> if ( pchanc < 0 ) <S2SV_EndBug> return CMD_WARNING ; ts -> pchan = pchanc ; return CMD_SUCCESS ; } | <S2SV_ModStart> < 0 ) { vty_out ( vty , "Unknown<S2SV_blank>physical<S2SV_blank>channel<S2SV_blank>name<S2SV_blank>\'%s\'%s" , argv [ 0 ] , VTY_NEWLINE ) ; return CMD_ERR_NO_MATCH ; } <S2SV_ModEnd> ts -> pchan |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.