Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
7,800 |
CWE-000 int main ( void ) { terminal_special ( "kernel:<S2SV_blank>GDT<S2SV_blank>loaded<S2SV_blank>!\\n" , TERMINAL_INFO ) ; init_idt ( ) ; terminal_special ( "kernel:<S2SV_blank>IDT<S2SV_blank>initialized\\n" , TERMINAL_INFO ) ; terminal_special ( "kernel:<S2SV_blank>PIC<S2SV_blank>initialized\\n" , TERMINAL_INFO ) ; init_pic ( ) ; <S2SV_StartBug> asm ( "movw<S2SV_blank>$0x38,<S2SV_blank>%ax<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n<S2SV_blank>\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>ltr<S2SV_blank>%ax" ) ; <S2SV_EndBug> terminal_special ( "kernel:<S2SV_blank>TR<S2SV_blank>loaded\\n" , TERMINAL_INFO ) ; init_mm ( ) ; terminal_special ( "kernel:<S2SV_blank>Paging<S2SV_blank>enabled\\n" , TERMINAL_WARNING ) ; terminal_special ( "kernel:<S2SV_blank>Installing<S2SV_blank>devices...\\n" , TERMINAL_INFO ) ; syscalls_install ( ) ; kbd_install ( ) ; clock_install ( ) ; terminal_special ( "kernel:<S2SV_blank>Devices<S2SV_blank>installed\\n" , TERMINAL_INFO ) ; terminal_special ( "kernel:<S2SV_blank>Creating<S2SV_blank>tasks..." , TERMINAL_WARNING ) ; <S2SV_StartBug> load_task ( ( uint32_t * ) 0x200000 , ( uint32_t * ) & task1 , 0x2000 ) ; <S2SV_EndBug> load_task ( ( uint32_t * ) 0x300000 , ( uint32_t * ) & task2 , 0x2000 ) ; terminal_special ( "DONE\\n" , TERMINAL_WARNING ) ; terminal_special ( "kernel:<S2SV_blank>Setting<S2SV_blank>interrupts<S2SV_blank>!\\n" , TERMINAL_WARNING ) ; sti ; while ( 1 ) ; return 1 ; }
|
<S2SV_ModStart> ; asm ( "movw<S2SV_blank>$0x38,<S2SV_blank>%ax<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n<S2SV_blank>\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>ltr<S2SV_blank>%ax" <S2SV_ModEnd> ) ; terminal_special <S2SV_ModStart> TERMINAL_WARNING ) ; <S2SV_ModEnd> terminal_special ( "DONE\\n"
|
7,801 |
CWE-000 void thread_delete_new_lock ( struct thread * t , struct lock * lock ) { enum intr_level old_level = intr_disable ( ) ; list_remove ( & lock -> elem ) ; <S2SV_StartBug> lock -> holder = NULL ; <S2SV_EndBug> thread_update_priority_from_locks ( t ) ; intr_set_level ( old_level ) ; }
|
<S2SV_ModStart> elem ) ; <S2SV_ModEnd> thread_update_priority_from_locks ( t
|
7,802 |
CWE-000 DynaStatus dmap_insertStringKey ( DynaMap map , const char * key , const void * val ) { dassert ( map != NULL , DYNA_ASSERT_MAP_NULL ) ; dassert ( key != NULL , DYNA_ASSERT_KEY_NULL ) ; dassert ( val != NULL , DYNA_ASSERT_VAL_NULL ) ; dmap * m = ( dmap * ) map ; dassert ( m -> key_dtor == dstr_destruct && m -> val_dtor != dstr_destruct , DYNA_ASSERT_MAP_STRING_KEY ) ; dstr s ; DynaStatus status = dstr_init ( & s , key ) ; <S2SV_StartBug> if ( yunlikely ( status ) ) { <S2SV_EndBug> return status ; } size_t esize = m -> esize ; size_t ksize = m -> ksize ; uint8_t * vptr = m -> swap + ksize + ksize + esize ; memcpy ( vptr , val , esize ) ; return dmap_insertHelper ( m , & s , vptr ) ; }
|
<S2SV_ModStart> ; if ( yerror <S2SV_ModEnd> ( status )
|
7,803 |
CWE-000 static void biji_manager_finalize ( GObject * object ) { BijiManager * manager = BIJI_MANAGER ( object ) ; g_clear_object ( & manager -> priv -> location ) ; g_hash_table_destroy ( manager -> priv -> items ) ; g_hash_table_destroy ( manager -> priv -> archives ) ; <S2SV_StartBug> G_OBJECT_CLASS ( biji_manager_parent_class ) -> finalize ( object ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> archives ) ; g_hash_table_unref ( manager -> priv -> providers ) ; g_clear_object ( & manager -> priv -> local_provider ) ;
|
7,804 |
CWE-000 INLINE int _ReduceAttrValueMatch ( XML_Char c ) { <S2SV_StartBug> # if defined ( CONFIG_ENABLE_WCHAR ) <S2SV_EndBug> if ( ( unsigned char ) c < 256 ) <S2SV_StartBug> return _ReduceAttrValueMatchChars [ ( unsigned char ) c ] ; <S2SV_EndBug> return 0 ; <S2SV_StartBug> # else <S2SV_EndBug> return _ReduceAttrValueMatchChars [ ( unsigned char ) c ] ; # endif }
|
<S2SV_ModStart> c ) { int i = ( int ) c ; if ( i >= 0 && i <S2SV_ModEnd> < 256 ) <S2SV_ModStart> return _ReduceAttrValueMatchChars [ i <S2SV_ModEnd> ] ; return <S2SV_ModStart> return 0 ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null>
|
7,805 |
CWE-000 int main ( int argc , char * * argv ) { DIR * dir ; struct dirent * ent ; int fd ; int ret ; uint64_t total_read ; struct mtcp_conf mcfg ; int cores [ MAX_CPUS ] ; int process_cpu ; int i , o ; num_cores = GetNumCPUs ( ) ; core_limit = num_cores ; process_cpu = - 1 ; dir = NULL ; if ( argc < 2 ) { TRACE_CONFIG ( "$%s<S2SV_blank>directory_to_service\\n" , argv [ 0 ] ) ; return FALSE ; } <S2SV_StartBug> while ( - 1 != ( o = getopt ( argc , argv , "N:f:p:c:h" ) ) ) { <S2SV_EndBug> switch ( o ) { case 'p' : www_main = optarg ; dir = opendir ( www_main ) ; if ( ! dir ) { TRACE_CONFIG ( "Failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>%s.\\n" , www_main ) ; perror ( "opendir" ) ; return FALSE ; } break ; case 'N' : core_limit = mystrtol ( optarg , 10 ) ; if ( core_limit > num_cores ) { TRACE_CONFIG ( "CPU<S2SV_blank>limit<S2SV_blank>should<S2SV_blank>be<S2SV_blank>smaller<S2SV_blank>than<S2SV_blank>the<S2SV_blank>" "number<S2SV_blank>of<S2SV_blank>CPUs:<S2SV_blank>%d\\n" , num_cores ) ; return FALSE ; } mtcp_getconf ( & mcfg ) ; mcfg . num_cores = core_limit ; mtcp_setconf ( & mcfg ) ; break ; case 'f' : conf_file = optarg ; break ; case 'c' : process_cpu = mystrtol ( optarg , 10 ) ; if ( process_cpu > core_limit ) { TRACE_CONFIG ( "Starting<S2SV_blank>CPU<S2SV_blank>is<S2SV_blank>way<S2SV_blank>off<S2SV_blank>limits!\\n" ) ; return FALSE ; } break ; <S2SV_StartBug> case 'h' : <S2SV_EndBug> printHelp ( argv [ 0 ] ) ; break ; } } if ( dir == NULL ) { TRACE_CONFIG ( "You<S2SV_blank>did<S2SV_blank>not<S2SV_blank>pass<S2SV_blank>a<S2SV_blank>valid<S2SV_blank>www_path!\\n" ) ; exit ( EXIT_FAILURE ) ; } nfiles = 0 ; while ( ( ent = readdir ( dir ) ) != NULL ) { if ( strcmp ( ent -> d_name , "." ) == 0 ) continue ; else if ( strcmp ( ent -> d_name , ".." ) == 0 ) continue ; snprintf ( fcache [ nfiles ] . name , NAME_LIMIT , "%s" , ent -> d_name ) ; snprintf ( fcache [ nfiles ] . fullname , FULLNAME_LIMIT , "%s/%s" , www_main , ent -> d_name ) ; fd = open ( fcache [ nfiles ] . fullname , O_RDONLY ) ; if ( fd < 0 ) { perror ( "open" ) ; continue ; } else { fcache [ nfiles ] . size = lseek64 ( fd , 0 , SEEK_END ) ; lseek64 ( fd , 0 , SEEK_SET ) ; } fcache [ nfiles ] . file = ( char * ) malloc ( fcache [ nfiles ] . size ) ; if ( ! fcache [ nfiles ] . file ) { TRACE_CONFIG ( "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>file<S2SV_blank>%s\\n" , fcache [ nfiles ] . name ) ; perror ( "malloc" ) ; continue ; } TRACE_INFO ( "Reading<S2SV_blank>%s<S2SV_blank>(%lu<S2SV_blank>bytes)\\n" , fcache [ nfiles ] . name , fcache [ nfiles ] . size ) ; total_read = 0 ; while ( 1 ) { ret = read ( fd , fcache [ nfiles ] . file + total_read , fcache [ nfiles ] . size - total_read ) ; if ( ret < 0 ) { break ; } else if ( ret == 0 ) { break ; } total_read += ret ; } if ( total_read < fcache [ nfiles ] . size ) { free ( fcache [ nfiles ] . file ) ; continue ; } close ( fd ) ; nfiles ++ ; if ( nfiles >= MAX_FILES ) break ; } finished = 0 ; if ( conf_file == NULL ) { TRACE_CONFIG ( "You<S2SV_blank>forgot<S2SV_blank>to<S2SV_blank>pass<S2SV_blank>the<S2SV_blank>mTCP<S2SV_blank>startup<S2SV_blank>config<S2SV_blank>file!\\n" ) ; exit ( EXIT_FAILURE ) ; } ret = mtcp_init ( conf_file ) ; if ( ret ) { TRACE_CONFIG ( "Failed<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>mtcp\\n" ) ; <S2SV_StartBug> exit ( EXIT_FAILURE ) ; <S2SV_EndBug> } mtcp_register_signal ( SIGINT , SignalHandler ) ; TRACE_INFO ( "Application<S2SV_blank>initialization<S2SV_blank>finished.\\n" ) ; for ( i = ( ( process_cpu == - 1 ) ? 0 : process_cpu ) ; i < core_limit ; i ++ ) { cores [ i ] = i ; done [ i ] = FALSE ; if ( pthread_create ( & app_thread [ i ] , NULL , RunServerThread , ( void * ) & cores [ i ] ) ) { perror ( "pthread_create" ) ; TRACE_CONFIG ( "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>server<S2SV_blank>thread.\\n" ) ; exit ( EXIT_FAILURE ) ; } if ( process_cpu != - 1 ) break ; } for ( i = ( ( process_cpu == - 1 ) ? 0 : process_cpu ) ; i < core_limit ; i ++ ) { pthread_join ( app_thread [ i ] , NULL ) ; if ( process_cpu != - 1 ) break ; } mtcp_destroy ( ) ; closedir ( dir ) ; return 0 ; }
|
<S2SV_ModStart> , argv , "N:f:p:c:b:h" <S2SV_ModEnd> ) ) ) <S2SV_ModStart> break ; case 'b' : backlog = mystrtol ( optarg , 10 ) ; break ; case <S2SV_ModStart> ( EXIT_FAILURE ) ; } mtcp_getconf ( & mcfg ) ; if ( backlog > mcfg . max_concurrency ) { TRACE_CONFIG ( "backlog<S2SV_blank>can<S2SV_blank>not<S2SV_blank>be<S2SV_blank>set<S2SV_blank>larger<S2SV_blank>than<S2SV_blank>CONFIG.max_concurrency\\n" ) ; return FALSE ; } if ( backlog == - 1 ) { backlog = mcfg . max_concurrency
|
7,806 |
CWE-000 static int pn533_usb_probe ( struct usb_interface * interface , const struct usb_device_id * id ) { struct pn533 * priv ; struct pn533_usb_phy * phy ; struct usb_host_interface * iface_desc ; struct usb_endpoint_descriptor * endpoint ; int in_endpoint = 0 ; int out_endpoint = 0 ; int rc = - ENOMEM ; int i ; u32 protocols ; enum pn533_protocol_type protocol_type = PN533_PROTO_REQ_ACK_RESP ; struct pn533_frame_ops * fops = NULL ; unsigned char * in_buf ; int in_buf_len = PN533_EXT_FRAME_HEADER_LEN + PN533_STD_FRAME_MAX_PAYLOAD_LEN + PN533_STD_FRAME_TAIL_LEN ; phy = devm_kzalloc ( & interface -> dev , sizeof ( * phy ) , GFP_KERNEL ) ; if ( ! phy ) return - ENOMEM ; <S2SV_StartBug> in_buf = kzalloc ( in_buf_len , GFP_KERNEL ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ! in_buf ) <S2SV_EndBug> return - ENOMEM ; phy -> udev = usb_get_dev ( interface_to_usbdev ( interface ) ) ; phy -> interface = interface ; iface_desc = interface -> cur_altsetting ; for ( i = 0 ; i < iface_desc -> desc . bNumEndpoints ; ++ i ) { endpoint = & iface_desc -> endpoint [ i ] . desc ; if ( ! in_endpoint && usb_endpoint_is_bulk_in ( endpoint ) ) in_endpoint = endpoint -> bEndpointAddress ; if ( ! out_endpoint && usb_endpoint_is_bulk_out ( endpoint ) ) out_endpoint = endpoint -> bEndpointAddress ; } if ( ! in_endpoint || ! out_endpoint ) { nfc_err ( & interface -> dev , "Could<S2SV_blank>not<S2SV_blank>find<S2SV_blank>bulk-in<S2SV_blank>or<S2SV_blank>bulk-out<S2SV_blank>endpoint\\n" ) ; rc = - ENODEV ; goto error ; } phy -> in_urb = usb_alloc_urb ( 0 , GFP_KERNEL ) ; phy -> out_urb = usb_alloc_urb ( 0 , GFP_KERNEL ) ; if ( ! phy -> in_urb || ! phy -> out_urb ) goto error ; usb_fill_bulk_urb ( phy -> in_urb , phy -> udev , usb_rcvbulkpipe ( phy -> udev , in_endpoint ) , in_buf , in_buf_len , NULL , phy ) ; usb_fill_bulk_urb ( phy -> out_urb , phy -> udev , usb_sndbulkpipe ( phy -> udev , out_endpoint ) , <S2SV_StartBug> NULL , 0 , pn533_send_complete , phy ) ; <S2SV_EndBug> switch ( id -> driver_info ) { case PN533_DEVICE_STD : protocols = PN533_ALL_PROTOCOLS ; break ; case PN533_DEVICE_PASORI : protocols = PN533_NO_TYPE_B_PROTOCOLS ; break ; case PN533_DEVICE_ACR122U : protocols = PN533_NO_TYPE_B_PROTOCOLS ; fops = & pn533_acr122_frame_ops ; protocol_type = PN533_PROTO_REQ_RESP , rc = pn533_acr122_poweron_rdr ( phy ) ; if ( rc < 0 ) { nfc_err ( & interface -> dev , "Couldn\'t<S2SV_blank>poweron<S2SV_blank>the<S2SV_blank>reader<S2SV_blank>(error<S2SV_blank>%d)\\n" , rc ) ; goto error ; } break ; default : nfc_err ( & interface -> dev , "Unknown<S2SV_blank>device<S2SV_blank>type<S2SV_blank>%lu\\n" , id -> driver_info ) ; rc = - EINVAL ; goto error ; } priv = pn533_register_device ( id -> driver_info , protocols , protocol_type , phy , & usb_phy_ops , fops , & phy -> udev -> dev , & interface -> dev ) ; if ( IS_ERR ( priv ) ) { rc = PTR_ERR ( priv ) ; goto error ; } phy -> priv = priv ; rc = pn533_finalize_setup ( priv ) ; if ( rc ) goto error ; usb_set_intfdata ( interface , phy ) ; return 0 ; error : usb_free_urb ( phy -> in_urb ) ; usb_free_urb ( phy -> out_urb ) ; usb_put_dev ( phy -> udev ) ; <S2SV_StartBug> kfree ( in_buf ) ; <S2SV_EndBug> return rc ; }
|
<S2SV_ModStart> ; in_buf = devm_kzalloc ( & interface -> dev , <S2SV_ModEnd> in_buf_len , GFP_KERNEL <S2SV_ModStart> ( ! in_buf ) return - ENOMEM ; phy -> out_buf = devm_kzalloc ( & interface -> dev , OUT_BUF_LEN , GFP_KERNEL ) ; if ( ! phy -> out_buf <S2SV_ModStart> out_endpoint ) , phy -> out_buf , OUT_BUF_LEN <S2SV_ModEnd> , pn533_send_complete , <S2SV_ModStart> udev ) ; <S2SV_ModEnd> return rc ;
|
7,807 |
CWE-000 int vec_realloc ( t_vec * vec , size_t new_size ) { <S2SV_StartBug> uint8_t * new_data ; <S2SV_EndBug> if ( vec -> elmnt_count > new_size ) return ( - 1 ) ; if ( NULL == ( new_data = malloc ( vec -> elmnt_size * new_size ) ) ) return ( - 1 ) ; memcpy ( new_data , vec -> data , vec -> elmnt_size * vec -> elmnt_count ) ; free ( vec -> data ) ; vec -> elmnt_max = new_size ; vec -> data = new_data ; vec -> data_end = new_data + ( vec -> elmnt_size * vec -> elmnt_count ) ; return ( 0 ) ; }
|
<S2SV_ModStart> uint8_t * new_data <S2SV_ModEnd> ; if (
|
7,808 |
CWE-000 <S2SV_StartBug> Test ( dictionary , in_dict_s1 ) { <S2SV_EndBug> check_in_dict ( "dict_test0.txt" , <S2SV_StartBug> "dictionaryverysuperduperlongwordyayitssolongwowcrazy" , 1 ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> ( dictionary , add_to_dict_f0 ) { check_add_to_dict <S2SV_ModEnd> ( "dict_test0.txt" , <S2SV_ModStart> , "dictionaryverysuperduperlongwordyayitssolongwowcrazy" , 0 <S2SV_ModEnd> ) ; }
|
7,809 |
CWE-000 static void bta_dm_service_search_remname_cback ( BD_ADDR bd_addr , DEV_CLASS dc , BD_NAME bd_name ) { tBTM_REMOTE_DEV_NAME rem_name ; tBTM_STATUS btm_status ; UNUSED ( dc ) ; APPL_TRACE_DEBUG ( "bta_dm_service_search_remname_cback<S2SV_blank>name=<%s>" , bd_name ) ; if ( ! bdcmp ( bta_dm_search_cb . peer_bdaddr , bd_addr ) ) { rem_name . length = strlen ( ( char * ) bd_name ) ; if ( rem_name . length > ( BD_NAME_LEN - 1 ) ) { rem_name . length = ( BD_NAME_LEN - 1 ) ; rem_name . remote_bd_name [ ( BD_NAME_LEN - 1 ) ] = 0 ; } <S2SV_StartBug> BCM_STRNCPY_S ( ( char * ) rem_name . remote_bd_name , sizeof ( BD_NAME ) , ( char * ) bd_name , ( BD_NAME_LEN - 1 ) ) ; <S2SV_EndBug> rem_name . status = BTM_SUCCESS ; bta_dm_remname_cback ( & rem_name ) ; } else { btm_status = BTM_ReadRemoteDeviceName ( bta_dm_search_cb . peer_bdaddr , ( tBTM_CMPL_CB * ) bta_dm_remname_cback , BT_TRANSPORT_BR_EDR ) ; if ( btm_status == BTM_BUSY ) { APPL_TRACE_DEBUG ( "bta_dm_service_search_remname_cback:<S2SV_blank>BTM_ReadRemoteDeviceName<S2SV_blank>is<S2SV_blank>busy" ) ; } else if ( btm_status != BTM_CMD_STARTED ) { APPL_TRACE_WARNING ( "bta_dm_service_search_remname_cback:<S2SV_blank>BTM_ReadRemoteDeviceName<S2SV_blank>returns<S2SV_blank>0x%02X" , btm_status ) ; rem_name . length = 0 ; rem_name . remote_bd_name [ 0 ] = 0 ; rem_name . status = btm_status ; bta_dm_remname_cback ( & rem_name ) ; } } }
|
<S2SV_ModStart> 0 ; } strlcpy <S2SV_ModEnd> ( ( char <S2SV_ModStart> . remote_bd_name , <S2SV_ModEnd> ( char * <S2SV_ModStart> ) bd_name , BD_NAME_LEN <S2SV_ModEnd> ) ; rem_name
|
7,810 |
CWE-000 void SetAxis ( axis_t * axis , char axisName , uint8_t stepPin , uint8_t directionPin , uint16_t stepPulseDuration , uint8_t maxLimitPin , uint8_t minLimitPin , float maxSpeed , float maxAcceleration , char * transmitMessage ) { if ( ( IsPinValid ( stepPin ) == TRUE ) && ( IsPinValid ( directionPin ) == TRUE ) && ( stepPulseDuration > 0 ) && ( maxSpeed > 0 ) && ( maxAcceleration > 0 ) ) { axis -> AxisName = axisName ; axis -> StepPin = stepPin ; axis -> DirectionPin = directionPin ; axis -> StepPulseDuration = stepPulseDuration ; axis -> MaxLimitPin = maxLimitPin ; axis -> MinLimitPin = minLimitPin ; axis -> MaxSpeed = maxSpeed ; axis -> MaxAcceleration = maxAcceleration ; <S2SV_StartBug> PinList [ stepPin ] . DirectionAddress = PinList [ stepPin ] . DirectionMask ; <S2SV_EndBug> PinList [ directionPin ] . DirectionAddress = PinList [ directionPin ] . DirectionMask ; PinList [ maxLimitPin ] . DirectionAddress &= ~ PinList [ maxLimitPin ] . DirectionMask ; <S2SV_StartBug> PinList [ minLimitPin ] . DirectionAddress &= ~ PinList [ minLimitPin ] . DirectionMask ; <S2SV_EndBug> ReportAxisSettings ( axis , transmitMessage ) ; } else { HandleError ( ERROR_PARAMETER_INVALID , transmitMessage ) ; return ; } }
|
<S2SV_ModStart> = maxAcceleration ; * PinList [ stepPin ] . DirectionAddress |= PinList [ stepPin ] . DirectionMask ; * PinList [ directionPin ] . DirectionAddress |= PinList [ directionPin ] . DirectionMask ; * <S2SV_ModEnd> PinList [ maxLimitPin <S2SV_ModStart> . DirectionMask ; *
|
7,811 |
CWE-000 int order_getDirection ( int floor , int localDir ) { int new_dir = 0 ; <S2SV_StartBug> if ( ( floor == - 1 && prevState == ELEV_EMERGENCY_STOP ) ) <S2SV_EndBug> { new_dir = order_checkOrders_idle ( floor ) ; } else if ( ( floor < 0 ) && ( currentFloor != previousFloor ) ) { printf ( "ERROR:<S2SV_blank>negative<S2SV_blank>floor!<S2SV_blank>\\n" ) ; return 0 ; } else { switch ( localDir ) { case ( - 1 ) : new_dir = order_checkOrders_down ( floor ) ; if ( ! new_dir ) { new_dir = order_checkOrders_idle ( floor ) ; } break ; case ( 1 ) : new_dir = order_checkOrders_up ( floor ) ; if ( ! new_dir ) { new_dir = order_checkOrders_idle ( floor ) ; } break ; default : new_dir = order_checkOrders_idle ( floor ) ; break ; } } if ( currentFloor != previousFloor ) { printf ( "New<S2SV_blank>direction:<S2SV_blank>%i\\n" , new_dir ) ; } printf ( "order_getDirection<S2SV_blank>called<S2SV_blank>with<S2SV_blank>values:\\nFloor:<S2SV_blank>%i<S2SV_blank>&<S2SV_blank>dir:<S2SV_blank>%i\\n" , floor , localDir ) ; return new_dir ; }
|
<S2SV_ModStart> - 1 && state <S2SV_ModEnd> == ELEV_EMERGENCY_STOP )
|
7,812 |
CWE-000 static int mtk_iommu_remove ( struct platform_device * pdev ) { struct mtk_iommu_data * data = platform_get_drvdata ( pdev ) ; iommu_device_sysfs_remove ( & data -> iommu ) ; iommu_device_unregister ( & data -> iommu ) ; if ( iommu_present ( & platform_bus_type ) ) bus_set_iommu ( & platform_bus_type , NULL ) ; <S2SV_StartBug> free_io_pgtable_ops ( data -> m4u_dom -> iop ) ; <S2SV_EndBug> clk_disable_unprepare ( data -> bclk ) ; devm_free_irq ( & pdev -> dev , data -> irq , data ) ; component_master_del ( & pdev -> dev , & mtk_iommu_com_ops ) ; return 0 ; }
|
<S2SV_ModStart> NULL ) ; <S2SV_ModEnd> clk_disable_unprepare ( data
|
7,813 |
CWE-000 static void sa_aes_cra_exit ( struct crypto_tfm * tfm ) { struct crypto_alg * alg = tfm -> __crt_alg ; struct sa_tfm_ctx * ctx = crypto_tfm_ctx ( tfm ) ; struct sa_crypto_data * data = dev_get_drvdata ( sa_k3_dev ) ; <S2SV_StartBug> dev_info ( sa_k3_dev , "%s(0x%p)<S2SV_blank>sc-ids(0x%x(0x%llx),<S2SV_blank>0x%x(0x%llx))\\n" , <S2SV_EndBug> <S2SV_StartBug> __func__ , tfm , ctx -> enc . sc_id , ctx -> enc . sc_phys , <S2SV_EndBug> <S2SV_StartBug> ctx -> dec . sc_id , ctx -> dec . sc_phys ) ; <S2SV_EndBug> if ( ( alg -> cra_flags & CRYPTO_ALG_TYPE_ABLKCIPHER ) == CRYPTO_ALG_TYPE_ABLKCIPHER ) { sa_free_ctx_info ( & ctx -> enc , data ) ; sa_free_ctx_info ( & ctx -> dec , data ) ; } }
|
<S2SV_ModStart> sa_k3_dev ) ; dev_dbg <S2SV_ModEnd> ( sa_k3_dev , <S2SV_ModStart> ( sa_k3_dev , "%s(0x%p)<S2SV_blank>sc-ids(0x%x(0x%pad),<S2SV_blank>0x%x(0x%pad))\\n" <S2SV_ModEnd> , __func__ , <S2SV_ModStart> . sc_id , & <S2SV_ModStart> . sc_id , &
|
7,814 |
CWE-000 static int s_none ( t_lexer * lexer , int * i ) { int index ; int parenthesis_count ; int has_tt_name ; if ( TOKEN_CODE ( * i ) != TC_LPAREN && TOKEN_CODE ( * i ) != TC_RPAREN ) return ( ST_OK ) ; index = * i + ( TOKEN_CODE ( * i ) == TC_LPAREN ? 1 : - 1 ) ; parenthesis_count = 1 ; has_tt_name = 0 ; <S2SV_StartBug> while ( ( TOKEN_CODE ( * i ) == TC_LPAREN ? index < lexer -> size : index >= 0 ) <S2SV_EndBug> && parenthesis_count > 0 ) { if ( TOKEN_TYPE ( index ) == TT_NAME ) has_tt_name = 1 ; <S2SV_StartBug> else if ( TOKEN_CODE ( index ) == TC_LPAREN <S2SV_EndBug> || TOKEN_CODE ( index ) == TC_RPAREN ) parenthesis_count += ( TOKEN_CODE ( index ) == TOKEN_CODE ( * i ) ? 1 : - 1 ) ; index += ( TOKEN_CODE ( * i ) == TC_LPAREN ? 1 : - 1 ) ; } if ( has_tt_name > 0 && parenthesis_count == 0 ) return ( ST_OK ) ; if ( lexer -> notify == 1 ) display_status ( ST_PARSER_TOKEN , NULL , lexer -> tokens [ * i ] -> content ) ; return ( ST_PARSER ) ; }
|
<S2SV_ModStart> = 0 ; if ( s_none_part1 ( lexer , i ) != ST_OK ) return ( ST_PARSER ) ; <S2SV_ModStart> else if ( TOKEN_TYPE ( index ) == TT_SUBSHELL <S2SV_ModEnd> ) parenthesis_count +=
|
7,815 |
CWE-000 static void XndObject_dfree ( void * self ) { XndObject * xnd = ( XndObject * ) self ; <S2SV_StartBug> gc_guard_unregister ( xnd ) ; <S2SV_EndBug> xfree ( xnd ) ; }
|
<S2SV_ModStart> ) self ; rb_xnd_gc_guard_unregister <S2SV_ModEnd> ( xnd )
|
7,816 |
CWE-000 int netvsc_poll ( struct napi_struct * napi , int budget ) { struct netvsc_channel * nvchan = container_of ( napi , struct netvsc_channel , napi ) ; struct netvsc_device * net_device = nvchan -> net_device ; struct vmbus_channel * channel = nvchan -> channel ; struct hv_device * device = netvsc_channel_to_device ( channel ) ; struct net_device * ndev = hv_get_drvdata ( device ) ; int work_done = 0 ; if ( ! nvchan -> desc ) nvchan -> desc = hv_pkt_iter_first ( channel ) ; while ( nvchan -> desc && work_done < budget ) { work_done += netvsc_process_raw_pkt ( device , channel , net_device , ndev , nvchan -> desc , budget ) ; nvchan -> desc = hv_pkt_iter_next ( channel , nvchan -> desc ) ; } <S2SV_StartBug> if ( ! nvchan -> desc ) <S2SV_EndBug> hv_pkt_iter_close ( channel ) ; if ( send_recv_completions ( nvchan ) == 0 && work_done < budget && napi_complete_done ( napi , work_done ) && hv_end_read ( & channel -> inbound ) ) { hv_begin_read ( & channel -> inbound ) ; napi_reschedule ( napi ) ; } return min ( work_done , budget ) ; }
|
<S2SV_ModStart> } if ( send_recv_completions ( ndev , net_device , <S2SV_ModEnd> nvchan ) ==
|
7,817 |
CWE-000 int create_orc_sections ( struct objtool_file * file ) { struct instruction * insn , * prev_insn ; struct section * sec , * u_sec , * ip_relasec ; unsigned int idx ; struct orc_entry empty = { . sp_reg = ORC_REG_UNDEFINED , . bp_reg = ORC_REG_UNDEFINED , . type = ORC_TYPE_CALL , } ; sec = find_section_by_name ( file -> elf , ".orc_unwind" ) ; if ( sec ) { WARN ( "file<S2SV_blank>already<S2SV_blank>has<S2SV_blank>.orc_unwind<S2SV_blank>section,<S2SV_blank>skipping" ) ; return - 1 ; } idx = 0 ; for_each_sec ( file , sec ) { if ( ! sec -> text ) continue ; prev_insn = NULL ; sec_for_each_insn ( file , sec , insn ) { if ( ! prev_insn || memcmp ( & insn -> orc , & prev_insn -> orc , sizeof ( struct orc_entry ) ) ) { idx ++ ; } prev_insn = insn ; } if ( prev_insn ) idx ++ ; } if ( ! idx ) return - 1 ; sec = elf_create_section ( file -> elf , ".orc_unwind_ip" , sizeof ( int ) , idx ) ; <S2SV_StartBug> ip_relasec = elf_create_rela_section ( file -> elf , sec ) ; <S2SV_EndBug> if ( ! ip_relasec ) return - 1 ; u_sec = elf_create_section ( file -> elf , ".orc_unwind" , sizeof ( struct orc_entry ) , idx ) ; idx = 0 ; for_each_sec ( file , sec ) { if ( ! sec -> text ) continue ; prev_insn = NULL ; sec_for_each_insn ( file , sec , insn ) { if ( ! prev_insn || memcmp ( & insn -> orc , & prev_insn -> orc , sizeof ( struct orc_entry ) ) ) { if ( create_orc_entry ( u_sec , ip_relasec , idx , insn -> sec , insn -> offset , & insn -> orc ) ) return - 1 ; idx ++ ; } prev_insn = insn ; } if ( prev_insn ) { if ( create_orc_entry ( u_sec , ip_relasec , idx , prev_insn -> sec , prev_insn -> offset + prev_insn -> len , & empty ) ) return - 1 ; idx ++ ; } } if ( elf_rebuild_rela_section ( ip_relasec ) ) return - 1 ; return 0 ; }
|
<S2SV_ModStart> idx ) ; if ( ! sec ) return - 1 ;
|
7,818 |
CWE-000 static sqInt NoDbgRegParms compileAbstractInstructionsFromthrough ( sqInt start , sqInt end ) { BytecodeDescriptor * descriptor ; BytecodeFixup * fixup ; sqInt generateBranchAround ; sqInt nExts ; sqInt nextOpcodeIndex ; sqInt result ; traceSimStack ( ) ; bytecodePC = start ; nExts = ( result = 0 ) ; descriptor = null ; deadCode = 0 ; while ( 1 ) { maybeHaltIfDebugPC ( ) ; fixup = fixupAtIndex ( bytecodePC - initialPC ) ; mergeWithFixupIfRequired ( fixup ) ; descriptor = loadBytesAndGetDescriptor ( ) ; nextOpcodeIndex = opcodeIndex ; result = ( deadCode ? mapDeadDescriptorIfNeeded ( descriptor ) : ( ( descriptor -> generator ) ) ( ) ) ; <S2SV_StartBug> if ( ! ( ( descriptor -> isExtension ) ) ) { <S2SV_EndBug> assert ( ( extA == 0 ) && ( ( extB == 0 ) <S2SV_StartBug> && ( numExtB == 0 ) ) ) ; <S2SV_EndBug> } traceDescriptor ( descriptor ) ; traceSimStack ( ) ; if ( ( ( ( ( ( usqInt ) ( ( fixup -> targetInstruction ) ) ) ) >= NeedsNonMergeFixupFlag ) && ( ( ( ( usqInt ) ( ( fixup -> targetInstruction ) ) ) ) <= NeedsMergeFixupFlag ) ) ) { if ( opcodeIndex == nextOpcodeIndex ) { genoperandoperand ( Label , ( labelCounter += 1 ) , bytecodePC ) ; } ( fixup -> targetInstruction = abstractInstructionAt ( nextOpcodeIndex ) ) ; } if ( ( isUnconditionalBranch ( descriptor ) ) || ( ( descriptor -> isReturn ) ) ) { generateBranchAround = ! ( ( isUnconditionalBranch ( descriptor ) ) || ( ( descriptor -> isReturn ) ) ) ; } bytecodePC = ( bytecodePC + ( ( descriptor -> numBytes ) ) ) + ( ( ( descriptor -> isBlockCreation ) ? ( ( descriptor -> spanFunction ) ) ( descriptor , bytecodePC , nExts , methodObj ) : 0 ) ) ; if ( ! ( ( result == 0 ) && ( bytecodePC <= end ) ) ) break ; nExts = ( ( descriptor -> isExtension ) ? nExts + 1 : 0 ) ; } if ( opcodeIndex > numAbstractOpcodes ) { error ( "Cog<S2SV_blank>JIT<S2SV_blank>internal<S2SV_blank>error.<S2SV_blank>Too<S2SV_blank>many<S2SV_blank>abstract<S2SV_blank>opcodes.<S2SV_blank><S2SV_blank>Num<S2SV_blank>opcodes<S2SV_blank>heuristic<S2SV_blank>is<S2SV_blank>too<S2SV_blank>optimistic." ) ; } return result ; }
|
<S2SV_ModStart> ; if ( result == 0 ) { if ( <S2SV_ModStart> ) ) ; }
|
7,819 |
CWE-000 static void destroyRealmTreeNode ( RealmTreeNode * n ) { <S2SV_StartBug> int i = 0 ; <S2SV_EndBug> if ( ! n -> vnos ) { int c ; for ( c = 0 ; c < childrenSize ; c ++ ) { RealmTreeNode * child = n -> children [ c ] ; n -> children [ c ] = NULL ; if ( ! child ) continue ; destroyRealmTreeNode ( child ) ; free ( child ) ; } } else { if ( n -> vnos != n -> vnosBuff ) free ( n -> vnos ) ; } }
|
<S2SV_ModStart> n ) { <S2SV_ModEnd> if ( !
|
7,820 |
CWE-000 int32_t mm_camera_poll_thread_release ( mm_camera_poll_thread_t * poll_cb ) { int32_t rc = 0 ; if ( MM_CAMERA_POLL_TASK_STATE_STOPPED == poll_cb -> state ) { LOGE ( "err,<S2SV_blank>poll<S2SV_blank>thread<S2SV_blank>is<S2SV_blank>not<S2SV_blank>running.\\n" ) ; return rc ; } mm_camera_poll_sig ( poll_cb , MM_CAMERA_PIPE_CMD_EXIT ) ; if ( pthread_join ( poll_cb -> pid , NULL ) != 0 ) { <S2SV_StartBug> LOGE ( "pthread<S2SV_blank>dead<S2SV_blank>already\\n" ) ; <S2SV_EndBug> } if ( poll_cb -> pfds [ 0 ] >= 0 ) { close ( poll_cb -> pfds [ 0 ] ) ; } if ( poll_cb -> pfds [ 1 ] >= 0 ) { close ( poll_cb -> pfds [ 1 ] ) ; } pthread_mutex_destroy ( & poll_cb -> mutex ) ; pthread_cond_destroy ( & poll_cb -> cond_v ) ; memset ( poll_cb , 0 , sizeof ( mm_camera_poll_thread_t ) ) ; poll_cb -> pfds [ 0 ] = - 1 ; poll_cb -> pfds [ 1 ] = - 1 ; return rc ; }
|
<S2SV_ModStart> 0 ) { LOGD <S2SV_ModEnd> ( "pthread<S2SV_blank>dead<S2SV_blank>already\\n" )
|
7,821 |
CWE-000 ldap_rcode_t fr_ldap_result ( LDAPMessage * * result , LDAPControl * * * ctrls , ldap_handle_t const * conn , int msgid , int all , char const * dn , struct timeval const * timeout ) { ldap_rcode_t status = LDAP_PROC_SUCCESS ; int lib_errno ; struct timeval tv ; LDAPMessage * tmp_msg = NULL , * msg ; LDAPMessage * * result_p = result ; if ( result ) * result = NULL ; if ( ctrls ) * ctrls = NULL ; if ( ! result ) result_p = & tmp_msg ; ldap_get_option ( conn -> handle , LDAP_OPT_ERROR_NUMBER , & lib_errno ) ; if ( lib_errno != LDAP_SUCCESS ) return fr_ldap_error_check ( NULL , conn , NULL , dn ) ; if ( ! timeout ) { tv = conn -> config -> res_timeout ; } else { tv = * timeout ; } lib_errno = ldap_result ( conn -> handle , msgid , all , & tv , result_p ) ; switch ( lib_errno ) { case 0 : lib_errno = LDAP_TIMEOUT ; fr_strerror_printf ( "timeout<S2SV_blank>waiting<S2SV_blank>for<S2SV_blank>result" ) ; return LDAP_PROC_TIMEOUT ; case - 1 : return fr_ldap_error_check ( NULL , conn , NULL , dn ) ; default : break ; } for ( msg = ldap_first_message ( conn -> handle , * result_p ) ; msg ; msg = ldap_next_message ( conn -> handle , msg ) ) { status = fr_ldap_error_check ( ctrls , conn , msg , dn ) ; if ( status != LDAP_PROC_SUCCESS ) break ; } if ( * result_p && ( ( status < 0 ) || ! result ) ) { ldap_msgfree ( * result_p ) ; <S2SV_StartBug> * result = NULL ; <S2SV_EndBug> } return status ; }
|
<S2SV_ModStart> ) ; * result_p <S2SV_ModEnd> = NULL ;
|
7,822 |
CWE-000 void PBCnr3c_drv ( int ( * intor ) ( ) , void ( * fill ) ( ) , double complex * eri , int nkpts_ij , int nkpts , int comp , int nimgs , double * Ls , double complex * expkL , int * kptij_idx , int * shls_slice , int * ao_loc , CINTOpt * cintopt , int * atm , int natm , int * bas , int nbas , double * env ) { const int ish0 = shls_slice [ 0 ] ; const int ish1 = shls_slice [ 1 ] ; const int jsh0 = shls_slice [ 2 ] ; const int jsh1 = shls_slice [ 3 ] ; const int ksh0 = shls_slice [ 4 ] ; const int ksh1 = shls_slice [ 5 ] ; const int nish = ish1 - ish0 ; const int njsh = jsh1 - jsh0 ; const int nksh = ksh1 - ksh0 ; double * expkL_r = malloc ( sizeof ( double ) * nimgs * nkpts * OF_CMPLX ) ; double * expkL_i = expkL_r + nimgs * nkpts ; int i ; for ( i = 0 ; i < nimgs * nkpts ; i ++ ) { expkL_r [ i ] = creal ( expkL [ i ] ) ; expkL_i [ i ] = cimag ( expkL [ i ] ) ; } size_t count ; if ( fill == & PBCnr3c_fill_kks1 || fill == & PBCnr3c_fill_kks2 ) { <S2SV_StartBug> count = nkpts * nkpts * OF_CMPLX + <S2SV_EndBug> <S2SV_StartBug> nkpts * MIN ( nimgs , IMGBLK ) * OF_CMPLX + nimgs ; <S2SV_EndBug> } else { <S2SV_StartBug> count = ( nkpts * OF_CMPLX + nimgs ) * 4 ; <S2SV_EndBug> } # pragma omp parallel default ( none ) shared ( intor , fill , eri , nkpts_ij , nkpts , comp , nimgs , Ls , expkL_r , expkL_i , kptij_idx , shls_slice , ao_loc , cintopt , atm , natm , bas , nbas , env , count ) { int ish , jsh , ij ; int nenv = PBCsizeof_env ( shls_slice , atm , natm , bas , nbas , env ) ; nenv = MAX ( nenv , PBCsizeof_env ( shls_slice + 2 , atm , natm , bas , nbas , env ) ) ; nenv = MAX ( nenv , PBCsizeof_env ( shls_slice + 4 , atm , natm , bas , nbas , env ) ) ; double * env_loc = malloc ( sizeof ( double ) * nenv ) ; memcpy ( env_loc , env , sizeof ( double ) * nenv ) ; <S2SV_StartBug> double * buf = malloc ( sizeof ( double ) * count * INTBUFMAX * comp ) ; <S2SV_EndBug> # pragma omp for schedule ( dynamic ) for ( ij = 0 ; ij < nish * njsh ; ij ++ ) { ish = ij / njsh ; jsh = ij % njsh ; ( * fill ) ( intor , eri , nkpts_ij , nkpts , comp , nimgs , ish , jsh , buf , env_loc , Ls , expkL_r , expkL_i , kptij_idx , shls_slice , ao_loc , cintopt , atm , natm , bas , nbas , env ) ; } free ( buf ) ; free ( env_loc ) ; } free ( expkL_r ) ; }
|
<S2SV_ModStart> PBCnr3c_fill_kks2 ) { int dijk = ( max_cgto ( shls_slice [ 0 ] , shls_slice [ 1 ] , ao_loc ) * max_cgto ( shls_slice [ 2 ] , shls_slice [ 3 ] , ao_loc ) * max_cgto ( shls_slice [ 4 ] , shls_slice [ 5 ] , ao_loc ) ) ; <S2SV_ModStart> OF_CMPLX + nimgs ; count *= MAX ( INTBUFMAX , dijk ) * comp <S2SV_ModStart> nimgs ) * INTBUFMAX10 * comp <S2SV_ModEnd> ; } # <S2SV_ModStart> ) * count <S2SV_ModEnd> ) ; #
|
7,823 |
CWE-000 <S2SV_StartBug> u32 fat_alloc_chain ( struct fat * fat , u32 length ) <S2SV_EndBug> { const u32 start_cluster = fat_alloc_cluster ( fat ) ; u32 cluster = start_cluster ; u32 new_cluster ; <S2SV_StartBug> u32 i ; <S2SV_EndBug> for ( i = 1 ; i < length ; ++ i ) { <S2SV_StartBug> new_cluster = fat_alloc_cluster ( fat ) ; <S2SV_EndBug> fat -> entries [ cluster ] = new_cluster ; cluster = new_cluster ; } <S2SV_StartBug> return start_cluster ; <S2SV_EndBug> }
|
<S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> bool <S2SV_ModEnd> fat_alloc_chain ( struct <S2SV_ModStart> , u32 length , u32 * start_cluster ) { u32 cluster , <S2SV_ModEnd> new_cluster ; u32 <S2SV_ModStart> ; u32 i ; if ( ! fat_alloc_cluster ( fat , start_cluster ) ) { return false ; } cluster = * start_cluster <S2SV_ModStart> i ) { if ( ! <S2SV_ModEnd> fat_alloc_cluster ( fat <S2SV_ModStart> fat_alloc_cluster ( fat , & new_cluster ) ) { return false ; } <S2SV_ModEnd> fat -> entries <S2SV_ModStart> ; } return true <S2SV_ModEnd> ; } <S2SV_null>
|
7,824 |
CWE-000 void doEat ( ) { unsigned int c = 1 ; unsigned int i = 0 ; bool checked [ 52 ] ; unsigned int j = 0 ; item * inventory [ 52 ] ; item * chosenItem ; itemClassId itemClass ; for ( j = 0 ; j < 52 ; j ++ ) { checked [ j ] = false ; } getCreatureInventory ( & player , inventory ) ; addToMsgQueue ( "Eat<S2SV_blank>which<S2SV_blank>item?<S2SV_blank>(space<S2SV_blank>to<S2SV_blank>cancel)" , false ) ; procMsgQueue ( ) ; while ( c ) { displayInventoryWindow ( i , checked ) ; c = getch ( ) ; switch ( c ) { case KEY_UP : i == 0 ? : i -- ; break ; case KEY_DOWN : i == 39 ? : i ++ ; break ; case '<S2SV_blank>' : <S2SV_StartBug> return ; <S2SV_EndBug> default : if ( isupper ( c ) || islower ( c ) ) { if ( isInventoryLetter ( c ) ) { chosenItem = inventory [ inventoryLetterToIndex ( c ) ] ; itemClass = getItemClass ( chosenItem ) ; if ( ( itemClass != ITEM_TYPE_CORPSE ) && ( itemClass != ITEM_TYPE_FRUIT ) ) { addToMsgQueue ( NOT_FOOD_MSG , false ) ; return ; } eatItem ( & player , chosenItem ) ; return ; } else { break ; } } else { break ; } } delwin ( invWin ) ; } return ; }
|
<S2SV_ModStart> case '<S2SV_blank>' : freeAction = true ;
|
7,825 |
CWE-000 static int ext4_commit_super ( struct super_block * sb , int sync ) { struct ext4_super_block * es = EXT4_SB ( sb ) -> s_es ; struct buffer_head * sbh = EXT4_SB ( sb ) -> s_sbh ; int error = 0 ; if ( ! sbh || block_device_ejected ( sb ) ) return error ; if ( buffer_write_io_error ( sbh ) ) { ext4_msg ( sb , KERN_ERR , "previous<S2SV_blank>I/O<S2SV_blank>error<S2SV_blank>to<S2SV_blank>" "superblock<S2SV_blank>detected" ) ; clear_buffer_write_io_error ( sbh ) ; set_buffer_uptodate ( sbh ) ; } if ( ! ( sb -> s_flags & MS_RDONLY ) ) es -> s_wtime = cpu_to_le32 ( get_seconds ( ) ) ; if ( sb -> s_bdev -> bd_part ) es -> s_kbytes_written = cpu_to_le64 ( EXT4_SB ( sb ) -> s_kbytes_written + ( ( part_stat_read ( sb -> s_bdev -> bd_part , sectors [ 1 ] ) - EXT4_SB ( sb ) -> s_sectors_written_start ) >> 1 ) ) ; else es -> s_kbytes_written = cpu_to_le64 ( EXT4_SB ( sb ) -> s_kbytes_written ) ; if ( percpu_counter_initialized ( & EXT4_SB ( sb ) -> s_freeclusters_counter ) ) ext4_free_blocks_count_set ( es , EXT4_C2B ( EXT4_SB ( sb ) , percpu_counter_sum_positive ( & EXT4_SB ( sb ) -> s_freeclusters_counter ) ) ) ; if ( percpu_counter_initialized ( & EXT4_SB ( sb ) -> s_freeinodes_counter ) ) es -> s_free_inodes_count = cpu_to_le32 ( percpu_counter_sum_positive ( & EXT4_SB ( sb ) -> s_freeinodes_counter ) ) ; BUFFER_TRACE ( sbh , "marking<S2SV_blank>dirty" ) ; ext4_superblock_csum_set ( sb ) ; mark_buffer_dirty ( sbh ) ; if ( sync ) { error = __sync_dirty_buffer ( sbh , test_opt ( sb , BARRIER ) ? WRITE_FUA : WRITE_SYNC ) ; <S2SV_StartBug> if ( error && ! buffer_write_io_error ( sbh ) ) <S2SV_EndBug> return error ; <S2SV_StartBug> if ( buffer_write_io_error ( sbh ) ) { <S2SV_EndBug> ext4_msg ( sb , KERN_ERR , "I/O<S2SV_blank>error<S2SV_blank>while<S2SV_blank>writing<S2SV_blank>" "superblock" ) ; clear_buffer_write_io_error ( sbh ) ; set_buffer_uptodate ( sbh ) ; } } return error ; }
|
<S2SV_ModStart> ; if ( <S2SV_ModEnd> buffer_write_io_error ( sbh <S2SV_ModStart> sbh ) ) { ext4_msg ( sb , KERN_ERR , "I/O<S2SV_blank>error<S2SV_blank>while<S2SV_blank>writing<S2SV_blank>" "superblock" ) ; clear_buffer_write_io_error ( sbh ) ; set_buffer_uptodate ( sbh ) ; } } <S2SV_ModStart> return error ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null>
|
7,826 |
CWE-000 void parse_ch ( struct parser_state * state , uint32_t ch ) { <S2SV_StartBug> parser_push_ch ( state , ch ) ; <S2SV_EndBug> while ( state -> pending_tail != state -> pending_head ) { struct subparser_state * subp ; subp = list_peek ( state -> parsers ) ; ch = parser_pop_ch ( state ) ; int r = state -> iter ( state , ch ) ; if ( r == PARSER_CONTINUE ) { subp -> parser ( state , ch ) ; } else if ( r == PARSER_DEFER ) { break ; } if ( ch == '\\n' ) { ++ state -> lineno ; state -> colno = 1 ; } else { ++ state -> colno ; } } }
|
<S2SV_ModStart> state , ch , true
|
7,827 |
CWE-000 inline void planner_line ( double x , double y , double z , double feed_rate , uint8_t nominal_laser_intensity , double pixel_width ) { int32_t target [ 3 ] ; target [ X_AXIS ] = lround ( x * CONFIG_X_STEPS_PER_MM ) ; target [ Y_AXIS ] = lround ( y * CONFIG_Y_STEPS_PER_MM ) ; target [ Z_AXIS ] = lround ( z * CONFIG_Z_STEPS_PER_MM ) ; int next_buffer_head = next_block_index ( block_buffer_head ) ; while ( block_buffer_tail == next_buffer_head ) { protocol_idle ( ) ; } block_t * block = & block_buffer [ block_buffer_head ] ; if ( pixel_width != 0.0 ) { block -> type = TYPE_RASTER_LINE ; <S2SV_StartBug> block -> pixel_steps = lround ( pixel_width * CONFIG_X_STEPS_PER_MM ) ; <S2SV_EndBug> } else { block -> type = TYPE_LINE ; } block -> nominal_laser_intensity = nominal_laser_intensity ; block -> direction_bits = 0 ; if ( target [ X_AXIS ] < position [ X_AXIS ] ) { block -> direction_bits |= ( 1 << X_DIRECTION_BIT ) ; } if ( target [ Y_AXIS ] < position [ Y_AXIS ] ) { block -> direction_bits |= ( 1 << Y_DIRECTION_BIT ) ; } if ( target [ Z_AXIS ] < position [ Z_AXIS ] ) { block -> direction_bits |= ( 1 << Z_DIRECTION_BIT ) ; } block -> steps_x = labs ( target [ X_AXIS ] - position [ X_AXIS ] ) ; block -> steps_y = labs ( target [ Y_AXIS ] - position [ Y_AXIS ] ) ; block -> steps_z = labs ( target [ Z_AXIS ] - position [ Z_AXIS ] ) ; block -> step_event_count = max ( block -> steps_x , max ( block -> steps_y , block -> steps_z ) ) ; if ( block -> step_event_count == 0 ) { return ; } ; double delta_mm [ 3 ] ; delta_mm [ X_AXIS ] = ( target [ X_AXIS ] - position [ X_AXIS ] ) / CONFIG_X_STEPS_PER_MM ; delta_mm [ Y_AXIS ] = ( target [ Y_AXIS ] - position [ Y_AXIS ] ) / CONFIG_Y_STEPS_PER_MM ; delta_mm [ Z_AXIS ] = ( target [ Z_AXIS ] - position [ Z_AXIS ] ) / CONFIG_Z_STEPS_PER_MM ; block -> millimeters = sqrt ( ( delta_mm [ X_AXIS ] * delta_mm [ X_AXIS ] ) + ( delta_mm [ Y_AXIS ] * delta_mm [ Y_AXIS ] ) + ( delta_mm [ Z_AXIS ] * delta_mm [ Z_AXIS ] ) ) ; double inverse_millimeters = 1.0 / block -> millimeters ; double inverse_minute = feed_rate * inverse_millimeters ; block -> nominal_speed = feed_rate ; block -> nominal_rate = ceil ( block -> step_event_count * inverse_minute ) ; block -> rate_delta = ceil ( block -> step_event_count * inverse_millimeters * CONFIG_ACCELERATION / ( 60 * ACCELERATION_TICKS_PER_SECOND ) ) ; double unit_vec [ 3 ] ; unit_vec [ X_AXIS ] = delta_mm [ X_AXIS ] * inverse_millimeters ; unit_vec [ Y_AXIS ] = delta_mm [ Y_AXIS ] * inverse_millimeters ; unit_vec [ Z_AXIS ] = delta_mm [ Z_AXIS ] * inverse_millimeters ; double vmax_junction = ZERO_SPEED ; if ( ( block_buffer_head != block_buffer_tail ) && ( previous_nominal_speed > 0.0 ) ) { double cos_theta = - previous_unit_vec [ X_AXIS ] * unit_vec [ X_AXIS ] - previous_unit_vec [ Y_AXIS ] * unit_vec [ Y_AXIS ] - previous_unit_vec [ Z_AXIS ] * unit_vec [ Z_AXIS ] ; if ( cos_theta < 0.95 ) { vmax_junction = min ( previous_nominal_speed , block -> nominal_speed ) ; if ( cos_theta > - 0.95 ) { double sin_theta_d2 = sqrt ( 0.5 * ( 1.0 - cos_theta ) ) ; vmax_junction = min ( vmax_junction , sqrt ( CONFIG_ACCELERATION * CONFIG_JUNCTION_DEVIATION * sin_theta_d2 / ( 1.0 - sin_theta_d2 ) ) ) ; } } } block -> vmax_junction = vmax_junction ; double v_allowable = max_allowable_speed ( - CONFIG_ACCELERATION , ZERO_SPEED , block -> millimeters ) ; block -> entry_speed = min ( vmax_junction , v_allowable ) ; if ( block -> nominal_speed <= v_allowable ) { block -> nominal_length_flag = true ; } else { block -> nominal_length_flag = false ; } block -> recalculate_flag = true ; memcpy ( previous_unit_vec , unit_vec , sizeof ( unit_vec ) ) ; previous_nominal_speed = block -> nominal_speed ; block_buffer_head = next_buffer_head ; memcpy ( position , target , sizeof ( target ) ) ; planner_recalculate ( ) ; stepper_start_processing ( ) ; }
|
<S2SV_ModStart> -> pixel_steps = <S2SV_ModEnd> pixel_width * CONFIG_X_STEPS_PER_MM <S2SV_ModStart> pixel_width * CONFIG_X_STEPS_PER_MM <S2SV_ModEnd> ; } else
|
7,828 |
CWE-000 HashTable * gbutton_get_properties ( zval * object ) { <S2SV_StartBug> HashTable * props ; <S2SV_EndBug> zval zv ; ze_gwidget_object * intern = Z_GWIDGET_P ( object ) ; gwidget_ptr w = intern -> widget_ptr ; <S2SV_StartBug> if ( ! w ) { <S2SV_EndBug> return NULL ; } <S2SV_StartBug> GtkButton * but = GTK_BUTTON ( w -> intern ) ; <S2SV_EndBug> props = gcontainer_get_properties ( object ) ; G_H_UPDATE_STRING ( GBUTTON_LABEL , gtk_button_get_label ( but ) ) ; G_H_UPDATE_BOOL ( GBUTTON_ALWAYS_SHOW_IMAGE , gtk_button_get_always_show_image ( but ) ) ; G_H_UPDATE_BOOL ( GBUTTON_USE_UNDERLINE , gtk_button_get_use_underline ( but ) ) ; G_H_UPDATE_LONG ( GBUTTON_IMAGE_POSITION , gtk_button_get_image_position ( but ) ) ; G_H_UPDATE_LONG ( GBUTTON_RELIEF , gtk_button_get_relief ( but ) ) ; <S2SV_StartBug> return props ; <S2SV_EndBug> }
|
<S2SV_ModStart> object ) { G_H_UPDATE_INIT ( gcontainer_get_properties ( object ) ) <S2SV_ModEnd> ; ze_gwidget_object * <S2SV_ModStart> -> widget_ptr ; <S2SV_ModEnd> GtkButton * but <S2SV_ModStart> w -> intern <S2SV_ModEnd> ) ; G_H_UPDATE_STRING <S2SV_ModStart> ) ; return G_H_UPDATE_RETURN <S2SV_ModEnd> ; } <S2SV_null>
|
7,829 |
CWE-000 static int msm_pcm_prepare ( struct snd_pcm_substream * substream ) { int ret = 0 ; struct snd_pcm_runtime * runtime = substream -> runtime ; struct voip_drv_info * prtd = runtime -> private_data ; uint32_t media_type = 0 ; uint32_t rate_type = 0 ; mutex_lock ( & prtd -> lock ) ; if ( substream -> stream == SNDRV_PCM_STREAM_PLAYBACK ) ret = msm_pcm_playback_prepare ( substream ) ; else if ( substream -> stream == SNDRV_PCM_STREAM_CAPTURE ) ret = msm_pcm_capture_prepare ( substream ) ; if ( ( runtime -> format != FORMAT_SPECIAL ) && ( ( prtd -> mode == MODE_AMR ) || ( prtd -> mode == MODE_AMR_WB ) || ( prtd -> mode == MODE_IS127 ) || ( prtd -> mode == MODE_4GV_NB ) || ( prtd -> mode == MODE_4GV_WB ) ) ) { pr_err ( "mode:%d<S2SV_blank>and<S2SV_blank>format:%u<S2SV_blank>are<S2SV_blank>not<S2SV_blank>mached\\n" , prtd -> mode , ( uint32_t ) runtime -> format ) ; ret = - EINVAL ; goto done ; } if ( ( runtime -> format != FORMAT_S16_LE ) && ( prtd -> mode == MODE_PCM ) ) { pr_err ( "mode:%d<S2SV_blank>and<S2SV_blank>format:%u<S2SV_blank>are<S2SV_blank>not<S2SV_blank>mached\\n" , prtd -> mode , ( uint32_t ) runtime -> format ) ; ret = - EINVAL ; goto done ; } if ( prtd -> playback_instance && prtd -> capture_instance && ( prtd -> state != VOIP_STARTED ) ) { ret = voip_get_rate_type ( prtd -> mode , prtd -> rate , & rate_type ) ; if ( ret < 0 ) { pr_err ( "fail<S2SV_blank>at<S2SV_blank>getting<S2SV_blank>rate_type\\n" ) ; ret = - EINVAL ; goto done ; } prtd -> rate_type = rate_type ; <S2SV_StartBug> media_type = voip_get_media_type ( prtd -> mode , <S2SV_EndBug> prtd -> play_samp_rate ) ; if ( media_type < 0 ) { <S2SV_StartBug> pr_err ( "fail<S2SV_blank>at<S2SV_blank>getting<S2SV_blank>media_type\\n" ) ; <S2SV_EndBug> ret = - EINVAL ; goto done ; } pr_debug ( "<S2SV_blank>media_type=%d,<S2SV_blank>rate_type=%d\\n" , media_type , rate_type ) ; if ( ( prtd -> play_samp_rate == 8000 ) && ( prtd -> cap_samp_rate == 8000 ) ) voc_config_vocoder ( media_type , rate_type , VSS_NETWORK_ID_VOIP_NB , voip_info . dtx_mode ) ; else if ( ( prtd -> play_samp_rate == 16000 ) && ( prtd -> cap_samp_rate == 16000 ) ) voc_config_vocoder ( media_type , rate_type , VSS_NETWORK_ID_VOIP_WB , voip_info . dtx_mode ) ; else { pr_debug ( "%s:<S2SV_blank>Invalid<S2SV_blank>rate<S2SV_blank>playback<S2SV_blank>%d,<S2SV_blank>capture<S2SV_blank>%d\\n" , __func__ , prtd -> play_samp_rate , prtd -> cap_samp_rate ) ; goto done ; } voc_register_mvs_cb ( voip_process_ul_pkt , voip_process_dl_pkt , prtd ) ; voc_start_voice_call ( voc_get_session_id ( VOIP_SESSION_NAME ) ) ; prtd -> state = VOIP_STARTED ; } done : mutex_unlock ( & prtd -> lock ) ; return ret ; }
|
<S2SV_ModStart> = rate_type ; ret = voip_get_media_type ( prtd -> mode , prtd -> play_samp_rate , & media_type ) ; if ( ret <S2SV_ModEnd> < 0 ) <S2SV_ModStart> ( "fail<S2SV_blank>at<S2SV_blank>getting<S2SV_blank>media_type\\n" ) <S2SV_ModEnd> ; goto done
|
7,830 |
CWE-000 int PF_sprint ( lua_State * L ) { edict_t * * e ; char * s ; client_t * client ; int entnum ; int level ; e = luaL_checkudata ( L , 1 , "edict_t" ) ; entnum = NUM_FOR_EDICT ( * e ) ; level = luaL_checknumber ( L , 2 ) ; <S2SV_StartBug> s = PF_VarString ( 2 ) ; <S2SV_EndBug> if ( entnum < 1 || entnum > MAX_CLIENTS ) { Con_Printf ( "tried<S2SV_blank>to<S2SV_blank>sprint<S2SV_blank>to<S2SV_blank>a<S2SV_blank>non-client\\n" ) ; return 0 ; } client = & svs . clients [ entnum - 1 ] ; SV_ClientPrintf ( client , level , "%s" , s ) ; return 0 ; }
|
<S2SV_ModStart> ; s = ( char * ) luaL_checkstring ( L , 3 <S2SV_ModEnd> ) ; if
|
7,831 |
CWE-000 INT size_ast_of ( int ast , DTYPE dtype ) { INT d , len , clen , mlpyr = 1 , sptr = 0 , concat ; ISZ_T val ; TY_KIND ty = get_ty_kind ( dtype ) ; switch ( ty ) { case TY_WORD : case TY_DWORD : case TY_LOG : case TY_INT : case TY_FLOAT : case TY_PTR : case TY_SLOG : case TY_SINT : case TY_BINT : case TY_BLOG : case TY_DBLE : case TY_QUAD : case TY_CMPLX : case TY_DCMPLX : case TY_QCMPLX : case TY_INT8 : case TY_LOG8 : return mk_isz_cval ( dtypeinfo [ ty ] . size , astb . bnd . dtype ) ; case TY_HOLL : return mk_isz_cval ( dtypeinfo [ DTY ( DT_INT ) ] . size , astb . bnd . dtype ) ; case TY_NCHAR : mlpyr = 2 ; case TY_CHAR : concat = 0 ; if ( ast ) { if ( A_TYPEG ( ast ) == A_SUBSTR ) ast = A_LOPG ( ast ) ; <S2SV_StartBug> if ( A_TYPEG ( ast ) == A_SUBSCR ) <S2SV_EndBug> ast = A_LOPG ( ast ) ; if ( A_TYPEG ( ast ) == A_CNST ) { sptr = A_SPTRG ( ast ) ; } else if ( A_TYPEG ( ast ) == A_ID ) { sptr = A_SPTRG ( ast ) ; } else if ( A_TYPEG ( ast ) == A_MEM ) { sptr = A_SPTRG ( A_MEMG ( ast ) ) ; } else if ( A_TYPEG ( ast ) == A_BINOP && A_OPTYPEG ( ast ) == OP_CAT ) { sptr = 0 ; concat = 1 ; } else { interr ( "size_ast_of:<S2SV_blank>unexpected<S2SV_blank>ast<S2SV_blank>type" , A_TYPEG ( ast ) , 3 ) ; sptr = 0 ; } } else { sptr = 0 ; } if ( sptr && ( dtype == DT_ASSCHAR || dtype == DT_DEFERCHAR || dtype == DT_ASSNCHAR || dtype == DT_DEFERNCHAR ) ) { clen = ast_intr ( I_LEN , astb . bnd . dtype , 1 , ast ) ; } else if ( sptr && ADJLENG ( sptr ) && ! F90POINTERG ( sptr ) ) { clen = CVLENG ( sptr ) ; if ( clen == 0 ) { clen = sym_get_scalar ( SYMNAME ( sptr ) , "len" , astb . bnd . dtype ) ; CVLENP ( sptr , clen ) ; } clen = mk_id ( clen ) ; } else { clen = DTY ( dtype + 1 ) ; if ( clen == 0 && concat ) { int lsize , rsize ; lsize = size_ast_of ( A_LOPG ( ast ) , A_DTYPEG ( A_LOPG ( ast ) ) ) ; rsize = size_ast_of ( A_ROPG ( ast ) , A_DTYPEG ( A_ROPG ( ast ) ) ) ; return mk_binop ( OP_ADD , lsize , rsize , astb . bnd . dtype ) ; } if ( A_ALIASG ( clen ) ) { clen = A_ALIASG ( clen ) ; clen = A_SPTRG ( clen ) ; clen = CONVAL2G ( clen ) ; return mk_isz_cval ( mlpyr * clen , astb . bnd . dtype ) ; } clen = mk_convert ( clen , astb . bnd . dtype ) ; clen = ast_intr ( I_MAX , astb . bnd . dtype , 2 , clen , mk_cval ( 0 , astb . bnd . dtype ) ) ; } if ( mlpyr != 1 ) { len = mk_cval ( mlpyr , astb . bnd . dtype ) ; clen = mk_binop ( OP_MUL , len , clen , astb . bnd . dtype ) ; } return clen ; case TY_ARRAY : len = size_ast_of ( ast , DTY ( dtype + 1 ) ) ; if ( DTY ( dtype + 2 ) <= 0 ) { interr ( "size_ast_of:<S2SV_blank>no<S2SV_blank>array<S2SV_blank>descriptor" , dtype , 3 ) ; return len ; } if ( ADD_DEFER ( dtype ) ) { return mk_cval ( dtypeinfo [ DTY ( DT_PTR ) ] . size , DT_INT ) ; } if ( ADD_NUMELM ( dtype ) == 0 ) { ADD_NUMELM ( dtype ) = astb . bnd . one ; d = stb . i1 ; } else { d = sym_of_ast ( ADD_NUMELM ( dtype ) ) ; if ( d == stb . i0 || STYPEG ( d ) != ST_CONST ) { ADD_NUMELM ( dtype ) = astb . bnd . one ; d = stb . i1 ; } } val = ad_val_of ( d ) ; if ( A_TYPEG ( len ) == A_CNST ) { int dd ; ISZ_T val2 ; dd = sym_of_ast ( len ) ; if ( STYPEG ( dd ) != ST_CONST ) { dd = stb . i1 ; } val2 = ad_val_of ( dd ) ; return mk_isz_cval ( val * val2 , astb . bnd . dtype ) ; } d = mk_isz_cval ( d , astb . bnd . dtype ) ; return mk_binop ( OP_MUL , d , len , astb . bnd . dtype ) ; case TY_STRUCT : case TY_UNION : case TY_DERIVED : if ( ! sptr ) sptr = DTY ( dtype + 1 ) ; if ( DTY ( dtype + 2 ) <= 0 && ! UNLPOLYG ( DTY ( dtype + 3 ) ) && ( ! CLASSG ( sptr ) || ! DTY ( dtype + 1 ) ) ) { errsev ( 151 ) ; return mk_isz_cval ( 4 , astb . bnd . dtype ) ; } else { return mk_isz_cval ( DTY ( dtype + 2 ) , astb . bnd . dtype ) ; } default : interr ( "size_ast_of:<S2SV_blank>bad<S2SV_blank>dtype" , ty , 3 ) ; return mk_isz_cval ( 1 , astb . bnd . dtype ) ; } }
|
<S2SV_ModStart> ) == A_SUBSCR ) ast = A_LOPG ( ast ) ; if ( A_TYPEG ( ast ) == A_FUNC
|
7,832 |
CWE-000 rc_t make_index_writer ( KDirectory * dir , struct index_writer * * writer , size_t buf_size , uint64_t frequency , const char * fmt , ... ) { rc_t rc ; struct KFile * f ; va_list args ; va_start ( args , fmt ) ; rc = KDirectoryVCreateFile ( dir , & f , false , 0664 , kcmInit , fmt , args ) ; if ( rc != 0 ) <S2SV_StartBug> ErrMsg ( "%s<S2SV_blank>%s().KDirectoryVCreateFile()<S2SV_blank>-><S2SV_blank>%R" , __FILE__ , __func__ , rc ) ; <S2SV_EndBug> else { if ( buf_size > 0 ) { struct KFile * temp_file ; rc = KBufFileMakeWrite ( & temp_file , f , false , buf_size ) ; if ( rc != 0 ) <S2SV_StartBug> ErrMsg ( "%s<S2SV_blank>%s().KBufFileMakeWrite()<S2SV_blank>-><S2SV_blank>%R" , __FILE__ , __func__ , rc ) ; <S2SV_EndBug> else { KFileRelease ( f ) ; f = temp_file ; } } if ( rc == 0 ) { rc = make_index_writer_obj ( writer , frequency , f ) ; if ( rc != 0 ) KFileRelease ( f ) ; } } va_end ( args ) ; return rc ; }
|
<S2SV_ModStart> ) ErrMsg ( "index.c<S2SV_blank>make_index_writer().KDirectoryVCreateFile()<S2SV_blank>-><S2SV_blank>%R" <S2SV_ModEnd> , rc ) <S2SV_ModStart> ) ErrMsg ( "index.c<S2SV_blank>make_index_writer().KBufFileMakeWrite()<S2SV_blank>-><S2SV_blank>%R" <S2SV_ModEnd> , rc )
|
7,833 |
CWE-000 static int mdp3_ctrl_off ( struct msm_fb_data_type * mfd ) { int rc = 0 ; bool intf_stopped = true ; struct mdp3_session_data * mdp3_session ; struct mdss_panel_data * panel ; pr_debug ( "mdp3_ctrl_off\\n" ) ; mdp3_session = ( struct mdp3_session_data * ) mfd -> mdp . private1 ; if ( ! mdp3_session || ! mdp3_session -> panel || ! mdp3_session -> dma || ! mdp3_session -> intf ) { pr_err ( "mdp3_ctrl_on<S2SV_blank>no<S2SV_blank>device" ) ; return - ENODEV ; } pm_runtime_get_sync ( & mdp3_res -> pdev -> dev ) ; MDSS_XLOG ( XLOG_FUNC_ENTRY , __LINE__ , mdss_fb_is_power_on_ulp ( mfd ) , mfd -> panel_power_state ) ; panel = mdp3_session -> panel ; mutex_lock ( & mdp3_session -> lock ) ; pr_debug ( "Requested<S2SV_blank>power<S2SV_blank>state<S2SV_blank>=<S2SV_blank>%d\\n" , mfd -> panel_power_state ) ; if ( mdss_fb_is_power_on_lp ( mfd ) ) { intf_stopped = false ; } else { if ( ! mdp3_session -> status ) { pr_debug ( "fb%d<S2SV_blank>is<S2SV_blank>off<S2SV_blank>already" , mfd -> index ) ; goto off_error ; } if ( panel && panel -> set_backlight ) panel -> set_backlight ( panel , 0 ) ; } if ( panel -> event_handler ) rc = panel -> event_handler ( panel , MDSS_EVENT_BLANK , ( void * ) ( long int ) mfd -> panel_power_state ) ; if ( rc ) pr_err ( "EVENT_BLANK<S2SV_blank>error<S2SV_blank>(%d)\\n" , rc ) ; if ( intf_stopped ) { if ( ! mdp3_session -> clk_on ) mdp3_ctrl_clk_enable ( mfd , 1 ) ; mdp3_histogram_stop ( mdp3_session , MDP_BLOCK_DMA_P ) ; mutex_lock ( & mdp3_session -> dma -> pp_lock ) ; mdp3_session -> dma -> ccs_config . ccs_dirty = false ; mdp3_session -> dma -> lut_config . lut_dirty = false ; mutex_unlock ( & mdp3_session -> dma -> pp_lock ) ; rc = mdp3_session -> dma -> stop ( mdp3_session -> dma , mdp3_session -> intf ) ; if ( rc ) pr_debug ( "fail<S2SV_blank>to<S2SV_blank>stop<S2SV_blank>the<S2SV_blank>MDP3<S2SV_blank>dma\\n" ) ; msleep ( 20 ) ; mfd -> panel_info -> cont_splash_enabled = 0 ; mdp3_autorefresh_disable ( mfd -> panel_info ) ; mdp3_splash_done ( mfd -> panel_info ) ; mdp3_irq_deregister ( ) ; } if ( panel -> event_handler ) rc = panel -> event_handler ( panel , MDSS_EVENT_PANEL_OFF , ( void * ) ( long int ) mfd -> panel_power_state ) ; if ( rc ) pr_err ( "EVENT_PANEL_OFF<S2SV_blank>error<S2SV_blank>(%d)\\n" , rc ) ; if ( intf_stopped ) { if ( mdp3_session -> clk_on ) { pr_debug ( "mdp3_ctrl_off<S2SV_blank>stop<S2SV_blank>clock\\n" ) ; if ( panel -> event_handler && ( panel -> panel_info . type == MIPI_CMD_PANEL ) ) { struct dsi_panel_clk_ctrl clk_ctrl ; clk_ctrl . state = MDSS_DSI_CLK_OFF ; clk_ctrl . client = DSI_CLK_REQ_MDP_CLIENT ; rc |= panel -> event_handler ( panel , MDSS_EVENT_PANEL_CLK_CTRL , ( void * ) & clk_ctrl ) ; } rc = mdp3_dynamic_clock_gating_ctrl ( 1 ) ; rc = mdp3_res_update ( 0 , 1 , MDP3_CLIENT_DMA_P ) ; if ( rc ) pr_err ( "mdp<S2SV_blank>clock<S2SV_blank>resource<S2SV_blank>release<S2SV_blank>failed\\n" ) ; } mdp3_ctrl_notifier_unregister ( mdp3_session , & mdp3_session -> mfd -> mdp_sync_pt_data . notifier ) ; mdp3_session -> vsync_enabled = 0 ; atomic_set ( & mdp3_session -> vsync_countdown , 0 ) ; atomic_set ( & mdp3_session -> dma_done_cnt , 0 ) ; mdp3_session -> clk_on = 0 ; mdp3_session -> in_splash_screen = 0 ; mdp3_res -> solid_fill_vote_en = false ; mdp3_session -> status = 0 ; if ( atomic_dec_return ( & mdp3_res -> active_intf_cnt ) != 0 ) { pr_warn ( "active_intf_cnt<S2SV_blank>unbalanced\\n" ) ; atomic_set ( & mdp3_res -> active_intf_cnt , 0 ) ; } if ( ! mdp3_res -> idle_pc_enabled || ( mfd -> panel_info -> type != MIPI_CMD_PANEL ) ) { rc = pm_runtime_put ( & mdp3_res -> pdev -> dev ) ; if ( rc ) pr_err ( "%s:<S2SV_blank>pm_runtime_put<S2SV_blank>failed<S2SV_blank>(rc<S2SV_blank>%d)\\n" , __func__ , rc ) ; } mdp3_bufq_deinit ( & mdp3_session -> bufq_out ) ; if ( mdp3_session -> overlay . id != MSMFB_NEW_REQUEST ) { mdp3_session -> overlay . id = MSMFB_NEW_REQUEST ; mdp3_bufq_deinit ( & mdp3_session -> bufq_in ) ; } } if ( mdss_fb_is_power_on_ulp ( mfd ) && ( mfd -> panel . type == MIPI_CMD_PANEL ) ) { <S2SV_StartBug> pr_debug ( "Disable<S2SV_blank>MDP3<S2SV_blank>clocks<S2SV_blank>in<S2SV_blank>ULP\\n" ) ; <S2SV_EndBug> if ( atomic_read ( & mfd -> kickoff_pending ) || atomic_read ( & mfd -> commits_pending ) ) { rc = wait_event_timeout ( mfd -> kickoff_wait_q , ( ! atomic_read ( & mfd -> kickoff_pending ) ) , msecs_to_jiffies ( WAIT_DISP_OP_TIMEOUT ) ) ; if ( ! rc ) { pr_info ( "Wait<S2SV_blank>for<S2SV_blank>kickoff<S2SV_blank>time<S2SV_blank>out<S2SV_blank>in<S2SV_blank>ULP\\n" ) ; MDSS_XLOG ( atomic_read ( & mfd -> kickoff_pending ) , atomic_read ( & mdp3_session -> vsync_countdown ) , rc ) ; } } if ( ! mdp3_session -> clk_on ) mdp3_ctrl_clk_enable ( mfd , 1 ) ; rc = mdp3_session -> dma -> stop ( mdp3_session -> dma , mdp3_session -> intf ) ; if ( rc ) pr_warn ( "fail<S2SV_blank>to<S2SV_blank>stop<S2SV_blank>the<S2SV_blank>MDP3<S2SV_blank>dma<S2SV_blank>in<S2SV_blank>ULP\\n" ) ; msleep ( 20 ) ; atomic_set ( & mdp3_session -> vsync_countdown , 0 ) ; mdp3_session -> vsync_enabled = 0 ; mdp3_ctrl_vsync_enable ( mdp3_session -> mfd , 0 ) ; mdp3_ctrl_clk_enable ( mdp3_session -> mfd , 0 ) ; } off_error : MDSS_XLOG ( XLOG_FUNC_EXIT , __LINE__ ) ; mutex_unlock ( & mdp3_session -> lock ) ; pm_runtime_put ( & mdp3_res -> pdev -> dev ) ; return 0 ; }
|
<S2SV_ModStart> { pr_debug ( "%s:<S2SV_blank>Disable<S2SV_blank>MDP3<S2SV_blank>clocks<S2SV_blank>in<S2SV_blank>ULP\\n" , __func__ <S2SV_ModEnd> ) ; if
|
7,834 |
CWE-000 static void gst_msdkenc_reset_task ( MsdkEncTask * task ) { <S2SV_StartBug> task -> input_frame = NULL ; <S2SV_EndBug> task -> output_bitstream . DataLength = 0 ; task -> sync_point = NULL ; <S2SV_StartBug> task -> more_data = FALSE ; <S2SV_EndBug> }
|
<S2SV_ModStart> task ) { <S2SV_ModEnd> task -> output_bitstream <S2SV_ModStart> = NULL ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null>
|
7,835 |
CWE-000 <S2SV_StartBug> static void string_map_remove_element ( StringMapBucketListEntry * e ) { <S2SV_EndBug> if ( e -> mIsOwned ) { freeMemory ( e -> mData ) ; } <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> void string_map_remove_element ( StringMap * tMap , <S2SV_ModStart> ) ; } tMap -> mSize -- ;
|
7,836 |
CWE-000 <S2SV_StartBug> void readTable ( cciHashTable_t * tb ) { <S2SV_EndBug> size_t size = HashTableSize ( tb ) ; size_t base = strlen ( _SUT ) ; <S2SV_StartBug> struct token * tokens = malloc ( sizeof ( struct token ) * size ) ; <S2SV_EndBug> for ( size_t i = 0 ; i < size ; ++ i ) { <S2SV_StartBug> randomSliceSUT ( tokens [ i ] . s , TOKEN_SIZE , base ) ; <S2SV_EndBug> SGet ( tb , tokens [ i ] . s ) ; } <S2SV_StartBug> free ( tokens ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> cciHashTable_t * tb , <S2SV_ModEnd> struct token * <S2SV_ModStart> token * tokens , size_t size ) { <S2SV_ModEnd> for ( size_t <S2SV_ModStart> i ) { <S2SV_ModEnd> SGet ( tb <S2SV_ModStart> ) ; } <S2SV_ModEnd> } <S2SV_null> <S2SV_null>
|
7,837 |
CWE-000 static qboolean NET_Resolve ( const char * s , struct sockaddr * sadr , int sadr_len , sa_family_t family , char * errormsg1k ) { struct addrinfo hints ; struct addrinfo * res = NULL ; struct addrinfo * search = NULL ; struct addrinfo * hintsp ; int retval ; memset ( sadr , '\\0' , sizeof ( * sadr ) ) ; memset ( & hints , '\\0' , sizeof ( hints ) ) ; hintsp = & hints ; hintsp -> ai_family = family ; hintsp -> ai_socktype = SOCK_DGRAM ; retval = getaddrinfo ( s , NULL , hintsp , & res ) ; if ( ! retval ) { if ( family == AF_UNSPEC ) { if ( net_enabled -> integer & NET_PRIOV6 ) { if ( net_enabled -> integer & NET_ENABLEV6 ) search = SearchAddrInfo ( res , AF_INET6 ) ; if ( ! search && ( net_enabled -> integer & NET_ENABLEV4 ) ) search = SearchAddrInfo ( res , AF_INET ) ; } else { if ( net_enabled -> integer & NET_ENABLEV4 ) search = SearchAddrInfo ( res , AF_INET ) ; if ( ! search && ( net_enabled -> integer & NET_ENABLEV6 ) ) search = SearchAddrInfo ( res , AF_INET6 ) ; } } else search = SearchAddrInfo ( res , family ) ; if ( search ) { if ( search -> ai_addrlen > sadr_len ) search -> ai_addrlen = sadr_len ; memcpy ( sadr , search -> ai_addr , search -> ai_addrlen ) ; freeaddrinfo ( search ) ; return qtrue ; } else { Com_sprintf ( errormsg1k , 1024 , "Sys_StringToSockaddr:<S2SV_blank>Error<S2SV_blank>resolving<S2SV_blank>%s:<S2SV_blank>No<S2SV_blank>address<S2SV_blank>of<S2SV_blank>required<S2SV_blank>type<S2SV_blank>found.\\n" , s ) ; } } else { <S2SV_StartBug> Com_PrintError ( CON_CHANNEL_NETWORK , errormsg1k , 1024 , "Sys_StringToSockaddr:<S2SV_blank>Error<S2SV_blank>resolving<S2SV_blank>%s:<S2SV_blank>%s\\n" , s , gai_strerror ( retval ) ) ; <S2SV_EndBug> } if ( res ) { freeaddrinfo ( res ) ; } return qfalse ; }
|
<S2SV_ModStart> } else { Com_sprintf ( <S2SV_ModEnd> errormsg1k , 1024
|
7,838 |
CWE-000 static int CommandType ( char * command ) { if ( command == NULL ) { ERROR ( "%s;<S2SV_blank>command:<S2SV_blank>NULL" , strerror ( EINVAL ) ) ; return - EINVAL ; } <S2SV_StartBug> cmd_t * cmd = ( cmd_t * ) command ; <S2SV_EndBug> return cmd -> type ; }
|
<S2SV_ModStart> EINVAL ; } return ( <S2SV_ModEnd> ( cmd_t * <S2SV_ModStart> * ) command ) <S2SV_ModEnd> -> type ;
|
7,839 |
CWE-000 static int deobfs_random_header ( buffer_t * buf , size_t cap , obfs_t * obfs ) { if ( obfs == NULL || obfs -> deobfs_stage != 0 ) return 0 ; char * data = buf -> data ; int len = buf -> len ; <S2SV_StartBug> uint8_t padding_len = ( uint8_t * ) data ; <S2SV_EndBug> len -= ( 1 + padding_len ) ; data += ( 1 + padding_len ) ; memmove ( buf -> data , data , len ) ; buf -> len = len ; return 0 ; }
|
<S2SV_ModStart> uint8_t padding_len = *
|
7,840 |
CWE-000 <S2SV_StartBug> static int mdss_dsi_parse_dcs_cmds ( struct device_node * np , <S2SV_EndBug> struct dsi_panel_cmds * pcmds , char * cmd_key , char * link_key ) { const char * data ; int blen = 0 , len ; char * buf , * bp ; struct dsi_ctrl_hdr * dchdr ; int i , cnt ; data = of_get_property ( np , cmd_key , & blen ) ; if ( ! data ) { pr_err ( "%s:<S2SV_blank>failed,<S2SV_blank>key=%s\\n" , __func__ , cmd_key ) ; return - ENOMEM ; } buf = kzalloc ( sizeof ( char ) * blen , GFP_KERNEL ) ; if ( ! buf ) return - ENOMEM ; memcpy ( buf , data , blen ) ; bp = buf ; len = blen ; cnt = 0 ; while ( len >= sizeof ( * dchdr ) ) { dchdr = ( struct dsi_ctrl_hdr * ) bp ; dchdr -> dlen = ntohs ( dchdr -> dlen ) ; if ( dchdr -> dlen > len ) { pr_err ( "%s:<S2SV_blank>dtsi<S2SV_blank>cmd=%x<S2SV_blank>error,<S2SV_blank>len=%d" , __func__ , dchdr -> dtype , dchdr -> dlen ) ; goto exit_free ; } bp += sizeof ( * dchdr ) ; len -= sizeof ( * dchdr ) ; bp += dchdr -> dlen ; len -= dchdr -> dlen ; cnt ++ ; } if ( len != 0 ) { pr_err ( "%s:<S2SV_blank>dcs_cmd=%x<S2SV_blank>len=%d<S2SV_blank>error!" , __func__ , buf [ 0 ] , blen ) ; goto exit_free ; } pcmds -> cmds = kzalloc ( cnt * sizeof ( struct dsi_cmd_desc ) , GFP_KERNEL ) ; if ( ! pcmds -> cmds ) goto exit_free ; pcmds -> cmd_cnt = cnt ; pcmds -> buf = buf ; pcmds -> blen = blen ; bp = buf ; len = blen ; for ( i = 0 ; i < cnt ; i ++ ) { dchdr = ( struct dsi_ctrl_hdr * ) bp ; len -= sizeof ( * dchdr ) ; bp += sizeof ( * dchdr ) ; if ( ( dchdr -> wait != 0 || i == ( cnt - 1 ) ) && dchdr -> last == 0 ) { pr_warn ( "%s:<S2SV_blank>correct<S2SV_blank>\\"last\\"<S2SV_blank>flag<S2SV_blank>of<S2SV_blank>DSI<S2SV_blank>cmd<S2SV_blank>0x%02X<S2SV_blank>of<S2SV_blank>%s\\n" , __func__ , * bp , cmd_key ) ; dchdr -> last = 1 ; } pcmds -> cmds [ i ] . dchdr = * dchdr ; pcmds -> cmds [ i ] . payload = bp ; bp += dchdr -> dlen ; len -= dchdr -> dlen ; } pcmds -> link_state = DSI_LP_MODE ; if ( link_key ) { data = of_get_property ( np , link_key , NULL ) ; if ( data && ! strcmp ( data , "dsi_hs_mode" ) ) pcmds -> link_state = DSI_HS_MODE ; else pcmds -> link_state = DSI_LP_MODE ; } pr_debug ( "%s:<S2SV_blank>dcs_cmd=%x<S2SV_blank>len=%d,<S2SV_blank>cmd_cnt=%d<S2SV_blank>link_state=%d\\n" , __func__ , pcmds -> buf [ 0 ] , pcmds -> blen , pcmds -> cmd_cnt , pcmds -> link_state ) ; return 0 ; exit_free : kfree ( buf ) ; return - ENOMEM ; }
|
<S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> <S2SV_ModEnd> int mdss_dsi_parse_dcs_cmds (
|
7,841 |
CWE-000 int bnxt_hwrm_func_vf_vnic_query_and_config ( struct bnxt * bp , uint16_t vf , void ( * vnic_cb ) ( struct bnxt_vnic_info * , void * ) , void * cbdata , int ( * hwrm_cb ) ( struct bnxt * bp , struct bnxt_vnic_info * vnic ) ) { struct bnxt_vnic_info vnic ; int rc = 0 ; int i , num_vnic_ids ; uint16_t * vnic_ids ; size_t vnic_id_sz ; size_t sz ; vnic_id_sz = bp -> pf . total_vnics * sizeof ( * vnic_ids ) ; vnic_ids = rte_malloc ( "bnxt_hwrm_vf_vnic_ids_query" , vnic_id_sz , RTE_CACHE_LINE_SIZE ) ; if ( vnic_ids == NULL ) { rc = - ENOMEM ; return rc ; } for ( sz = 0 ; sz < vnic_id_sz ; sz += getpagesize ( ) ) rte_mem_lock_page ( ( ( char * ) vnic_ids ) + sz ) ; num_vnic_ids = bnxt_hwrm_func_vf_vnic_query ( bp , vf , vnic_ids ) ; if ( num_vnic_ids < 0 ) return num_vnic_ids ; for ( i = 0 ; i < num_vnic_ids ; i ++ ) { memset ( & vnic , 0 , sizeof ( struct bnxt_vnic_info ) ) ; vnic . fw_vnic_id = rte_le_to_cpu_16 ( vnic_ids [ i ] ) ; rc = bnxt_hwrm_vnic_qcfg ( bp , & vnic , bp -> pf . first_vf_id + vf ) ; if ( rc ) break ; <S2SV_StartBug> if ( vnic . mru == 4 ) <S2SV_EndBug> continue ; vnic_cb ( & vnic , cbdata ) ; rc = hwrm_cb ( bp , & vnic ) ; if ( rc ) break ; } rte_free ( vnic_ids ) ; return rc ; }
|
<S2SV_ModStart> vnic . mru <= <S2SV_ModEnd> 4 ) continue
|
7,842 |
CWE-000 static struct kgsl_pagetable * kgsl_mmu_createpagetableobject ( struct kgsl_mmu * mmu , unsigned int name ) { int status = 0 ; struct kgsl_pagetable * pagetable = NULL ; unsigned long flags ; unsigned int ptsize ; pagetable = kzalloc ( sizeof ( struct kgsl_pagetable ) , GFP_KERNEL ) ; <S2SV_StartBug> if ( pagetable == NULL ) { <S2SV_EndBug> KGSL_CORE_ERR ( "kzalloc(%d)<S2SV_blank>failed\\n" , sizeof ( struct kgsl_pagetable ) ) ; return NULL ; <S2SV_StartBug> } <S2SV_EndBug> kref_init ( & pagetable -> refcount ) ; spin_lock_init ( & pagetable -> lock ) ; ptsize = kgsl_mmu_get_ptsize ( mmu ) ; pagetable -> mmu = mmu ; pagetable -> name = name ; pagetable -> max_entries = KGSL_PAGETABLE_ENTRIES ( ptsize ) ; pagetable -> fault_addr = 0xFFFFFFFF ; atomic_set ( & pagetable -> stats . entries , 0 ) ; atomic_set ( & pagetable -> stats . mapped , 0 ) ; atomic_set ( & pagetable -> stats . max_mapped , 0 ) ; atomic_set ( & pagetable -> stats . max_entries , 0 ) ; if ( ( KGSL_MMU_TYPE_IOMMU == kgsl_mmu_get_mmutype ( ) ) && ( ( KGSL_MMU_GLOBAL_PT == name ) || ( KGSL_MMU_PRIV_BANK_TABLE_NAME == name ) ) ) { pagetable -> kgsl_pool = gen_pool_create ( ilog2 ( SZ_8K ) , - 1 ) ; if ( pagetable -> kgsl_pool == NULL ) { KGSL_CORE_ERR ( "gen_pool_create(%d)<S2SV_blank>failed\\n" , ilog2 ( SZ_8K ) ) ; goto err_alloc ; } if ( gen_pool_add ( pagetable -> kgsl_pool , KGSL_IOMMU_GLOBAL_MEM_BASE , KGSL_IOMMU_GLOBAL_MEM_SIZE , - 1 ) ) { KGSL_CORE_ERR ( "gen_pool_add<S2SV_blank>failed\\n" ) ; goto err_kgsl_pool ; } } pagetable -> pool = gen_pool_create ( PAGE_SHIFT , - 1 ) ; if ( pagetable -> pool == NULL ) { KGSL_CORE_ERR ( "gen_pool_create(%d)<S2SV_blank>failed\\n" , PAGE_SHIFT ) ; goto err_kgsl_pool ; } if ( gen_pool_add ( pagetable -> pool , kgsl_mmu_get_base_addr ( mmu ) , ptsize , - 1 ) ) { KGSL_CORE_ERR ( "gen_pool_add<S2SV_blank>failed\\n" ) ; goto err_pool ; } if ( KGSL_MMU_TYPE_GPU == kgsl_mmu_type ) pagetable -> pt_ops = & gpummu_pt_ops ; else if ( KGSL_MMU_TYPE_IOMMU == kgsl_mmu_type ) pagetable -> pt_ops = & iommu_pt_ops ; pagetable -> priv = pagetable -> pt_ops -> mmu_create_pagetable ( ) ; if ( ! pagetable -> priv ) goto err_pool ; status = kgsl_setup_pt ( pagetable ) ; if ( status ) goto err_mmu_create ; spin_lock_irqsave ( & kgsl_driver . ptlock , flags ) ; list_add ( & pagetable -> list , & kgsl_driver . pagetable_list ) ; spin_unlock_irqrestore ( & kgsl_driver . ptlock , flags ) ; pagetable_add_sysfs_objects ( pagetable ) ; return pagetable ; err_mmu_create : pagetable -> pt_ops -> mmu_destroy_pagetable ( pagetable ) ; err_pool : gen_pool_destroy ( pagetable -> pool ) ; err_kgsl_pool : if ( pagetable -> kgsl_pool ) gen_pool_destroy ( pagetable -> kgsl_pool ) ; err_alloc : kfree ( pagetable ) ; return NULL ; }
|
<S2SV_ModStart> == NULL ) <S2SV_ModEnd> return NULL ; <S2SV_ModStart> return NULL ; <S2SV_ModEnd> kref_init ( &
|
7,843 |
CWE-000 void * recvfrom_udpclient ( void * args ) { int mysocket ; mysocket = socket ( PF_INET , SOCK_DGRAM , IPPROTO_UDP ) ; char * buffer = "hello" ; int len = strlen ( buffer ) + 1 ; struct sockaddr_in dest ; socklen_t fromlen ; memset ( & dest , 0 , sizeof ( dest ) ) ; dest . sin_family = PF_INET ; dest . sin_addr . s_addr = inet_addr ( "127.0.0.1" ) ; dest . sin_port = htons ( PORTNUM ) ; fromlen = sizeof ( dest ) ; sendto ( mysocket , buffer , len , 0 , ( struct sockaddr * ) & dest , fromlen ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> }
|
<S2SV_ModStart> fromlen ) ; close ( mysocket ) ;
|
7,844 |
CWE-000 int kvm_arch_get_registers ( CPUState * cs ) { ARMCPU * cpu = ARM_CPU ( cs ) ; CPUARMState * env = & cpu -> env ; struct kvm_one_reg r ; int mode , bn ; int ret , i ; uint32_t cpsr , fpscr ; for ( i = 0 ; i < ARRAY_SIZE ( regs ) ; i ++ ) { r . id = regs [ i ] . id ; r . addr = ( uintptr_t ) ( env ) + regs [ i ] . offset ; ret = kvm_vcpu_ioctl ( cs , KVM_GET_ONE_REG , & r ) ; if ( ret ) { return ret ; } } r . id = KVM_REG_ARM | KVM_REG_SIZE_U32 | KVM_REG_ARM_CORE | KVM_REG_ARM_CORE_REG ( usr_regs . ARM_cpsr ) ; r . addr = ( uintptr_t ) ( & cpsr ) ; ret = kvm_vcpu_ioctl ( cs , KVM_GET_ONE_REG , & r ) ; if ( ret ) { return ret ; } cpsr_write ( env , cpsr , 0xffffffff , CPSRWriteRaw ) ; mode = env -> uncached_cpsr & CPSR_M ; bn = bank_number ( mode ) ; if ( mode == ARM_CPU_MODE_FIQ ) { memcpy ( env -> regs + 8 , env -> fiq_regs , 5 * sizeof ( uint32_t ) ) ; } else { memcpy ( env -> regs + 8 , env -> usr_regs , 5 * sizeof ( uint32_t ) ) ; } env -> regs [ 13 ] = env -> banked_r13 [ bn ] ; <S2SV_StartBug> env -> regs [ 14 ] = env -> banked_r14 [ bn ] ; <S2SV_EndBug> env -> spsr = env -> banked_spsr [ bn ] ; r . id = KVM_REG_ARM | KVM_REG_SIZE_U64 | KVM_REG_ARM_VFP ; for ( i = 0 ; i < 32 ; i ++ ) { r . addr = ( uintptr_t ) aa32_vfp_dreg ( env , i ) ; ret = kvm_vcpu_ioctl ( cs , KVM_GET_ONE_REG , & r ) ; if ( ret ) { return ret ; } r . id ++ ; } r . id = KVM_REG_ARM | KVM_REG_SIZE_U32 | KVM_REG_ARM_VFP | KVM_REG_ARM_VFP_FPSCR ; r . addr = ( uintptr_t ) & fpscr ; ret = kvm_vcpu_ioctl ( cs , KVM_GET_ONE_REG , & r ) ; if ( ret ) { return ret ; } vfp_set_fpscr ( env , fpscr ) ; ret = kvm_get_vcpu_events ( cpu ) ; if ( ret ) { return ret ; } if ( ! write_kvmstate_to_list ( cpu ) ) { return EINVAL ; } write_list_to_cpustate ( cpu ) ; kvm_arm_sync_mpstate_to_qemu ( cpu ) ; return 0 ; }
|
<S2SV_ModStart> ; env -> spsr = env -> banked_spsr [ bn ] ; env -> <S2SV_ModStart> -> banked_r14 [ r14_bank_number ( mode ) <S2SV_ModEnd> ] ; r
|
7,845 |
CWE-000 static void module_free_global_ref ( emacs_env * env , emacs_value ref ) { MODULE_FUNCTION_BEGIN ( ) ; struct Lisp_Hash_Table * h = XHASH_TABLE ( Vmodule_refs_hash ) ; Lisp_Object obj = value_to_lisp ( ref ) ; ptrdiff_t i = hash_lookup ( h , obj , NULL ) ; if ( i >= 0 ) { EMACS_INT refcount = XFASTINT ( HASH_VALUE ( h , i ) ) - 1 ; if ( refcount > 0 ) set_hash_value_slot ( h , i , make_natnum ( refcount ) ) ; else { eassert ( refcount == 0 ) ; hash_remove_from_table ( h , obj ) ; } } if ( module_assertions ) { Lisp_Object globals = global_env_private . values ; Lisp_Object prev = Qnil ; ptrdiff_t count = 0 ; <S2SV_StartBug> for ( Lisp_Object tail = global_env_private . values ; CONSP ( tail ) ; <S2SV_EndBug> <S2SV_StartBug> tail = XCDR ( tail ) ) <S2SV_EndBug> { emacs_value global = XSAVE_POINTER ( XCAR ( globals ) , 0 ) ; if ( global == ref ) { if ( NILP ( prev ) ) global_env_private . values = XCDR ( globals ) ; else XSETCDR ( prev , XCDR ( globals ) ) ; return ; } ++ count ; <S2SV_StartBug> prev = globals ; <S2SV_EndBug> } module_abort ( "Global<S2SV_blank>value<S2SV_blank>was<S2SV_blank>not<S2SV_blank>found<S2SV_blank>in<S2SV_blank>list<S2SV_blank>of<S2SV_blank>%" pD "d<S2SV_blank>globals" , count ) ; } }
|
<S2SV_ModStart> Lisp_Object tail = globals ; CONSP ( tail ) ; tail = XCDR ( tail ) ) { emacs_value global = XSAVE_POINTER ( XCAR ( tail ) , 0 ) ; if ( global == ref ) { if ( NILP ( prev ) ) <S2SV_ModStart> global_env_private . values <S2SV_ModEnd> = XCDR ( <S2SV_ModStart> = XCDR ( globals ) ; else XSETCDR ( prev , XCDR ( tail <S2SV_ModEnd> ) ) ; <S2SV_ModStart> ; prev = tail <S2SV_ModEnd> ; } module_abort
|
7,846 |
CWE-000 static time_t rvth_parse_timestamp ( const NHCD_BankEntry * nhcd_entry ) { unsigned int ymd = 0 ; unsigned int hms = 0 ; unsigned int i ; <S2SV_StartBug> for ( i = 0 ; i < 8 ; i ++ ) { <S2SV_EndBug> if ( unlikely ( ! isdigit ( nhcd_entry -> mdate [ i ] ) ) ) { return - 1 ; } ymd *= 10 ; ymd += ( nhcd_entry -> mdate [ i ] & 0xF ) ; } if ( unlikely ( ymd < 19000101 || ymd > 99991231 ) ) { return - 1 ; } for ( i = 0 ; i < 6 ; i ++ ) { if ( unlikely ( ! isdigit ( nhcd_entry -> mtime [ i ] ) ) ) { return - 1 ; } hms *= 10 ; hms += ( nhcd_entry -> mtime [ i ] & 0xF ) ; } if ( unlikely ( hms > 235959 ) ) { return - 1 ; } <S2SV_StartBug> struct tm ymdtime ; <S2SV_EndBug> ymdtime . tm_year = ( ymd / 10000 ) - 1900 ; ymdtime . tm_mon = ( ( ymd / 100 ) % 100 ) - 1 ; ymdtime . tm_mday = ymd % 100 ; ymdtime . tm_hour = ( hms / 10000 ) ; ymdtime . tm_min = ( hms / 100 ) % 100 ; ymdtime . tm_sec = hms % 100 ; ymdtime . tm_wday = 0 ; ymdtime . tm_yday = 0 ; ymdtime . tm_isdst = 0 ; return timegm ( & ymdtime ) ; }
|
<S2SV_ModStart> int i ; struct tm ymdtime ; <S2SV_ModStart> 1 ; } <S2SV_ModEnd> ymdtime . tm_year
|
7,847 |
CWE-000 static gboolean gst_mfx_encoder_init_properties ( GstMfxEncoder * encoder , GstMfxTaskAggregator * aggregator , const GstVideoInfo * info , gboolean memtype_is_system ) { encoder -> aggregator = gst_mfx_task_aggregator_ref ( aggregator ) ; if ( ( GST_VIDEO_INFO_FORMAT ( info ) == GST_VIDEO_FORMAT_NV12 ) && ! memtype_is_system ) { GstMfxTask * task = gst_mfx_task_aggregator_get_current_task ( encoder -> aggregator ) ; <S2SV_StartBug> if ( gst_mfx_task_has_type ( task , GST_MFX_TASK_DECODER ) ) { <S2SV_EndBug> mfxVideoParam * params = gst_mfx_task_get_video_params ( task ) ; encoder -> frame_info = params -> mfx . FrameInfo ; } else { <S2SV_StartBug> encoder -> frame_info = gst_mfx_task_get_request ( task ) -> Info ; <S2SV_EndBug> } if ( gst_mfx_task_has_video_memory ( task ) && encoder -> frame_info . FourCC == MFX_FOURCC_NV12 ) { encoder -> shared = TRUE ; encoder -> encode = task ; encoder -> session = gst_mfx_task_get_session ( encoder -> encode ) ; } else { if ( ! gst_mfx_task_has_video_memory ( task ) ) memtype_is_system = TRUE ; gst_mfx_task_set_task_type ( task , gst_mfx_task_get_task_type ( task ) | GST_MFX_TASK_VPP_IN ) ; init_encoder_task ( encoder ) ; gst_mfx_task_unref ( task ) ; } } else { init_encoder_task ( encoder ) ; } if ( ! encoder -> encode ) return FALSE ; encoder -> bs . MaxLength = info -> width * info -> height * 4 ; encoder -> bitstream = g_byte_array_sized_new ( encoder -> bs . MaxLength ) ; if ( ! encoder -> bitstream ) return FALSE ; encoder -> bs . Data = encoder -> bitstream -> data ; encoder -> async_depth = DEFAULT_ASYNC_DEPTH ; encoder -> info = * info ; if ( ! encoder -> info . fps_n ) encoder -> info . fps_n = 30 ; encoder -> duration = ( encoder -> info . fps_d / ( gdouble ) encoder -> info . fps_n ) * 1000000000 ; encoder -> current_pts = GST_CLOCK_TIME_NONE ; encoder -> memtype_is_system = memtype_is_system ; return TRUE ; }
|
<S2SV_ModStart> ; if ( ! task ) { GST_ERROR ( "Unable<S2SV_blank>to<S2SV_blank>retrieve<S2SV_blank>upstream<S2SV_blank>MFX<S2SV_blank>task<S2SV_blank>from<S2SV_blank>task<S2SV_blank>aggregator." ) ; return FALSE ; } if ( <S2SV_ModStart> } else { mfxFrameAllocRequest * req = gst_mfx_task_get_request ( task ) ; if ( ! req ) { GST_ERROR ( "Unable<S2SV_blank>to<S2SV_blank>retrieve<S2SV_blank>allocation<S2SV_blank>request<S2SV_blank>for<S2SV_blank>encoder<S2SV_blank>task." ) ; return FALSE ; } <S2SV_ModStart> -> frame_info = req <S2SV_ModEnd> -> Info ;
|
7,848 |
CWE-000 unsigned char CircularBufferGetByte ( CircularBuffer * circBuffer ) { <S2SV_StartBug> assert ( circBuffer != NULL ) ; <S2SV_EndBug> <S2SV_StartBug> assert ( ! CircularBufferIsEmpty ( circBuffer ) ) ; <S2SV_EndBug> unsigned char byte = circBuffer -> buffer [ circBuffer -> tail ] ; circBuffer -> tail = ( circBuffer -> tail + 1 ) % CIRCULAR_BUFFER_CAPACITY_BYTES ; if ( circBuffer -> tail == circBuffer -> head && ! circBuffer -> isEmpty ) { circBuffer -> isEmpty = true ; } return byte ; }
|
<S2SV_ModStart> circBuffer ) { BUG_ON <S2SV_ModEnd> ( circBuffer != <S2SV_ModStart> NULL ) ; BUG_ON <S2SV_ModEnd> ( ! CircularBufferIsEmpty
|
7,849 |
CWE-000 int main ( int argc , char * * argv , char * * envp ) { <S2SV_StartBug> char * katanaHome = getenv ( "KATANA_HOME" ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ! katanaHome ) <S2SV_EndBug> { fprintf ( stderr , "RenderPreBoot:<S2SV_blank>Error<S2SV_blank>-<S2SV_blank>KATANA_HOME<S2SV_blank>env<S2SV_blank>variable<S2SV_blank>is<S2SV_blank>not<S2SV_blank>set,<S2SV_blank>so<S2SV_blank>cannot<S2SV_blank>find<S2SV_blank>where<S2SV_blank>the<S2SV_blank>real<S2SV_blank>renderboot<S2SV_blank>is.\\n\\n" ) ; return - 1 ; } fprintf ( stderr , "Invoking<S2SV_blank>RenderPreBoot...\\n" ) ; char * extraCommands = getenv ( "RPB_EXTRA_COMMANDS" ) ; int numArgs = argc ; int numExtraCommands = 0 ; char realRenderbootPath [ 2048 ] ; memset ( realRenderbootPath , 0 , 2048 ) ; <S2SV_StartBug> strcpy ( realRenderbootPath , katanaHome ) ; <S2SV_EndBug> strcat ( realRenderbootPath , "/bin/renderboot" ) ; int nextArg = 0 ; int argOffset = 0 ; if ( extraCommands && extraCommands [ 0 ] != '\\0' ) { const char * extraTmp = extraCommands ; while ( * extraTmp ) { if ( * extraTmp ++ == '|' ) { numExtraCommands ++ ; } } numExtraCommands += 1 ; numArgs += numExtraCommands ; nextArg += numExtraCommands ; argOffset = numExtraCommands ; } char * * newTargetArgs = ( char * * ) malloc ( ( numArgs + 1 ) * sizeof ( char * ) ) ; if ( ! newTargetArgs ) { fprintf ( stderr , "RenderPreBoot:<S2SV_blank>Can\'t<S2SV_blank>allocate<S2SV_blank>memory.\\n\\n" ) ; return - 1 ; } if ( numExtraCommands == 0 ) { newTargetArgs [ 0 ] = realRenderbootPath ; } else { fprintf ( stderr , "RenderPreBoot:<S2SV_blank>invoking<S2SV_blank>pre<S2SV_blank>command:<S2SV_blank>%s\\n\\n" , extraCommands ) ; if ( numExtraCommands == 1 ) { newTargetArgs [ 0 ] = extraCommands ; } else { int commandCount = 0 ; char * commandToken = strtok ( extraCommands , "|" ) ; for ( ; commandToken ; commandToken = strtok ( NULL , "|" ) ) { int length = strlen ( commandToken ) ; char * newCommand = ( char * ) malloc ( length + 1 ) ; strcpy ( newCommand , commandToken ) ; newTargetArgs [ 0 + commandCount ++ ] = newCommand ; } } newTargetArgs [ nextArg ] = realRenderbootPath ; } nextArg ++ ; for ( int i = nextArg ; i < numArgs ; i ++ ) { newTargetArgs [ i ] = argv [ i - argOffset ] ; } newTargetArgs [ numArgs ] = NULL ; # if 0 for ( int i = 0 ; i < numArgs ; i ++ ) { fprintf ( stderr , "%s\\n" , newTargetArgs [ i ] ) ; } return 0 ; # endif return execve ( newTargetArgs [ 0 ] , newTargetArgs , envp ) ; }
|
<S2SV_ModStart> { char * katanaRoot <S2SV_ModEnd> = getenv ( <S2SV_ModStart> = getenv ( "KATANA_ROOT" <S2SV_ModEnd> ) ; if <S2SV_ModStart> if ( ! katanaRoot <S2SV_ModEnd> ) { fprintf <S2SV_ModStart> ( realRenderbootPath , katanaRoot <S2SV_ModEnd> ) ; strcat
|
7,850 |
CWE-000 <S2SV_StartBug> void run_with_pipe ( t_sh * shell , int * fd ) <S2SV_EndBug> { if ( shell -> fd_pipe != 0 ) { dup2 ( shell -> fd_pipe , 0 ) ; close ( shell -> fd_pipe ) ; } if ( fd [ 1 ] != 1 && ! shell -> right_side ) { dup2 ( fd [ 1 ] , 1 ) ; close ( fd [ 1 ] ) ; } }
|
<S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static
|
7,851 |
CWE-000 static inline int fi_ibv_rdm_process_recv_wc ( struct fi_ibv_rdm_ep * ep , struct ibv_wc * wc ) { struct fi_ibv_rdm_conn * conn = ( void * ) wc -> wr_id ; struct fi_ibv_rdm_buf * rbuf = fi_ibv_rdm_get_rbuf ( conn , ep , conn -> recv_processed ) ; FI_IBV_PREFETCH_ADDR ( rbuf ) ; FI_IBV_DBG_OPCODE ( wc -> opcode , "RECV" ) ; if ( ! FI_IBV_RDM_CHECK_RECV_WC ( wc ) ) { VERBS_INFO ( FI_LOG_EP_DATA , "conn<S2SV_blank>%p<S2SV_blank>state<S2SV_blank>%d,<S2SV_blank>wc<S2SV_blank>status<S2SV_blank>%d\\n" , conn , conn -> state , wc -> status ) ; if ( ! conn -> recv_preposted ) { VERBS_DBG ( FI_LOG_EP_DATA , "no<S2SV_blank>more<S2SV_blank>preposted<S2SV_blank>entries:<S2SV_blank>" "conn<S2SV_blank>%p<S2SV_blank>state<S2SV_blank>%d\\n" , conn , conn -> state ) ; return 0 ; } conn -> recv_preposted -- ; if ( wc -> status == IBV_WC_WR_FLUSH_ERR && conn -> state == FI_VERBS_CONN_ESTABLISHED ) { fi_ibv_rdm_start_disconnection ( conn ) ; } else { assert ( "Error<S2SV_blank>recv<S2SV_blank>wc\\n" && ( ! ep -> is_closing || conn -> state != FI_VERBS_CONN_ESTABLISHED ) ) ; } conn -> state = FI_VERBS_CONN_CLOSED ; } else { check_and_repost_receives ( ep , conn ) ; } conn -> recv_completions ++ ; if ( conn -> recv_completions & ep -> n_buffs ) { conn -> recv_completions = 0 ; } VERBS_DBG ( FI_LOG_EP_DATA , "conn<S2SV_blank>%p<S2SV_blank>recv_completions<S2SV_blank>%d\\n" , conn , conn -> recv_completions ) ; <S2SV_StartBug> if ( ( rbuf -> service_data . status == BUF_STATUS_RECVED ) && <S2SV_EndBug> ( wc -> opcode == IBV_WC_RECV_RDMA_WITH_IMM ? fi_ibv_rdm_buffer_check_seq_num ( rbuf , conn -> recv_processed ) : 1 ) ) { do { assert ( rbuf -> service_data . pkt_len > 0 ) ; fi_ibv_rdm_process_recv ( ep , conn , rbuf -> service_data . pkt_len , rbuf ) ; VERBS_DBG ( FI_LOG_EP_DATA , "processed:<S2SV_blank>conn<S2SV_blank>%p,<S2SV_blank>pkt<S2SV_blank>#<S2SV_blank>%d\\n" , conn , rbuf -> service_data . seq_num ) ; fi_ibv_rdm_set_buffer_status ( rbuf , BUF_STATUS_FREE ) ; rbuf -> service_data . seq_num = ( uint16_t ) ( - 1 ) ; conn -> recv_processed ++ ; if ( conn -> recv_processed & ep -> n_buffs ) { conn -> recv_processed = 0 ; fi_ibv_rdm_tagged_release_remote_sbuff ( conn , ep ) ; } VERBS_DBG ( FI_LOG_EP_DATA , "conn<S2SV_blank>%p<S2SV_blank>recv_processed<S2SV_blank>%d\\n" , conn , conn -> recv_processed ) ; rbuf = fi_ibv_rdm_get_rbuf ( conn , ep , conn -> recv_processed ) ; } while ( conn -> recv_processed != conn -> recv_completions && <S2SV_StartBug> rbuf -> service_data . status == BUF_STATUS_RECVED ) ; <S2SV_EndBug> } else { VERBS_DBG ( FI_LOG_EP_DATA , "not<S2SV_blank>processed:<S2SV_blank>conn<S2SV_blank>%p,<S2SV_blank>status:<S2SV_blank>%d\\n" , conn , rbuf -> service_data . status ) ; } return 0 ; }
|
<S2SV_ModStart> . status == BUF_STATUS_RECEIVED <S2SV_ModEnd> ) && ( <S2SV_ModStart> . status == BUF_STATUS_RECEIVED <S2SV_ModEnd> ) ; }
|
7,852 |
CWE-000 struct Graph * addEdge ( struct Graph * graph , int origin , int destiny ) { if ( graph -> arrayAdjList [ origin ] . head == NULL ) { graph = addVertex ( graph , origin ) ; } if ( graph -> arrayAdjList [ destiny ] . head == NULL ) { graph = addVertex ( graph , destiny ) ; } <S2SV_StartBug> struct Vertex * headORIGIN = graph -> arrayAdjList [ origin ] . head ; <S2SV_EndBug> struct SubList * current = graph -> arrayAdjList [ origin ] . head -> listVert ; while ( current -> next != NULL ) { current = current -> next ; } current -> next = newSubList_malloc ; current -> sVertex = graph -> arrayAdjList [ destiny ] . head ; current -> next -> next = NULL ; return graph ; }
|
<S2SV_ModStart> ; } struct <S2SV_ModEnd> SubList * current
|
7,853 |
CWE-000 long kvm_vm_ioctl_create_spapr_tce ( struct kvm * kvm , struct kvm_create_spapr_tce_64 * args ) { struct kvmppc_spapr_tce_table * stt = NULL ; unsigned long npages , size ; int ret = - ENOMEM ; int i ; if ( ! args -> size ) return - EINVAL ; list_for_each_entry ( stt , & kvm -> arch . spapr_tce_tables , list ) { if ( stt -> liobn == args -> liobn ) return - EBUSY ; } size = args -> size ; npages = kvmppc_tce_pages ( size ) ; ret = kvmppc_account_memlimit ( kvmppc_stt_pages ( npages ) , true ) ; if ( ret ) { stt = NULL ; goto fail ; } <S2SV_StartBug> stt = kzalloc ( sizeof ( * stt ) + npages * sizeof ( struct page * ) , <S2SV_EndBug> GFP_KERNEL ) ; if ( ! stt ) goto fail ; stt -> liobn = args -> liobn ; stt -> page_shift = args -> page_shift ; stt -> offset = args -> offset ; stt -> size = size ; stt -> kvm = kvm ; for ( i = 0 ; i < npages ; i ++ ) { stt -> pages [ i ] = alloc_page ( GFP_KERNEL | __GFP_ZERO ) ; if ( ! stt -> pages [ i ] ) goto fail ; } kvm_get_kvm ( kvm ) ; mutex_lock ( & kvm -> lock ) ; list_add_rcu ( & stt -> list , & kvm -> arch . spapr_tce_tables ) ; mutex_unlock ( & kvm -> lock ) ; return anon_inode_getfd ( "kvm-spapr-tce" , & kvm_spapr_tce_fops , stt , O_RDWR | O_CLOEXEC ) ; fail : if ( stt ) { for ( i = 0 ; i < npages ; i ++ ) if ( stt -> pages [ i ] ) __free_page ( stt -> pages [ i ] ) ; kfree ( stt ) ; } return ret ; }
|
<S2SV_ModStart> fail ; } ret = - ENOMEM ;
|
7,854 |
CWE-000 struct work_queue * work_queue_create ( int port ) { struct work_queue * q = malloc ( sizeof ( * q ) ) ; if ( ! q ) { fprintf ( stderr , "Error:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>queue.\\n" ) ; return 0 ; } char * envstring ; random_init ( ) ; memset ( q , 0 , sizeof ( * q ) ) ; if ( port == 0 ) { envstring = getenv ( "WORK_QUEUE_PORT" ) ; if ( envstring ) { port = atoi ( envstring ) ; } } if ( getenv ( "WORK_QUEUE_LOW_PORT" ) ) setenv ( "TCP_LOW_PORT" , getenv ( "WORK_QUEUE_LOW_PORT" ) , 0 ) ; if ( getenv ( "WORK_QUEUE_HIGH_PORT" ) ) setenv ( "TCP_HIGH_PORT" , getenv ( "WORK_QUEUE_HIGH_PORT" ) , 0 ) ; q -> master_link = link_serve ( port ) ; if ( ! q -> master_link ) { debug ( D_NOTICE , "Could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>work_queue<S2SV_blank>on<S2SV_blank>port<S2SV_blank>%i." , port ) ; free ( q ) ; return 0 ; } else { char address [ LINK_ADDRESS_MAX ] ; link_address_local ( q -> master_link , address , & q -> port ) ; } getcwd ( q -> workingdir , PATH_MAX ) ; q -> next_taskid = 1 ; q -> ready_list = list_create ( ) ; q -> tasks = itable_create ( 0 ) ; q -> task_state_map = itable_create ( 0 ) ; q -> worker_table = hash_table_create ( 0 , 0 ) ; q -> worker_blacklist = hash_table_create ( 0 , 0 ) ; q -> worker_task_map = itable_create ( 0 ) ; q -> measured_local_resources = rmsummary_create ( - 1 ) ; q -> current_max_worker = rmsummary_create ( - 1 ) ; q -> stats = calloc ( 1 , sizeof ( struct work_queue_stats ) ) ; q -> stats_disconnected_workers = calloc ( 1 , sizeof ( struct work_queue_stats ) ) ; q -> stats_measure = calloc ( 1 , sizeof ( struct work_queue_stats ) ) ; q -> workers_with_available_results = hash_table_create ( 0 , 0 ) ; q -> poll_table_size = 8 ; q -> worker_selection_algorithm = wq_option_scheduler ; q -> process_pending_check = 0 ; q -> short_timeout = 5 ; q -> long_timeout = 3600 ; q -> stats -> time_when_started = timestamp_get ( ) ; q -> task_reports = list_create ( ) ; q -> time_last_wait = 0 ; q -> catalog_hosts = 0 ; q -> keepalive_interval = WORK_QUEUE_DEFAULT_KEEPALIVE_INTERVAL ; q -> keepalive_timeout = WORK_QUEUE_DEFAULT_KEEPALIVE_TIMEOUT ; q -> monitor_mode = MON_DISABLED ; q -> allocation_default_mode = WORK_QUEUE_ALLOCATION_MODE_FIXED ; q -> categories = hash_table_create ( 0 , 0 ) ; work_queue_activate_fast_abort ( q , - 1 ) ; q -> password = 0 ; q -> asynchrony_multiplier = 1.0 ; q -> asynchrony_modifier = 0 ; q -> minimum_transfer_timeout = 10 ; q -> foreman_transfer_timeout = 3600 ; q -> transfer_outlier_factor = 10 ; q -> default_transfer_rate = 1 * MEGABYTE ; q -> master_preferred_connection = xxstrdup ( "by_ip" ) ; if ( ( envstring = getenv ( "WORK_QUEUE_BANDWIDTH" ) ) ) { q -> bandwidth = string_metric_parse ( envstring ) ; if ( q -> bandwidth < 0 ) { q -> bandwidth = 0 ; } } q -> task_ordering = WORK_QUEUE_TASK_ORDER_FIFO ; log_queue_stats ( q ) ; q -> time_last_wait = timestamp_get ( ) ; debug ( D_WQ , "Work<S2SV_blank>Queue<S2SV_blank>is<S2SV_blank>listening<S2SV_blank>on<S2SV_blank>port<S2SV_blank>%d." , q -> port ) ; time_t ts ; time ( & ts ) ; <S2SV_StartBug> debug ( D_BJ , "\\nENGAGE:<S2SV_blank>%lld\\n" , ( long long ) ts ) ; <S2SV_EndBug> return q ; }
|
<S2SV_ModStart> ts ) ; <S2SV_ModEnd> return q ;
|
7,855 |
CWE-000 int fb_hGL_Init ( FB_DYLIB lib , char * os_extensions ) { const char * gl_funcs [ ] = { "glEnable" , "glDisable" , "glEnableClientState" , "glDisableClientState" , "glGetString" , "glViewport" , "glMatrixMode" , "glLoadIdentity" , "glOrtho" , "glShadeModel" , "glDepthMask" , "glClearColor" , "glClear" , "glGenTextures" , "glDeleteTextures" , "glBindTexture" , "glTexParameteri" , "glTexImage2D" , "glTexSubImage2D" , "glVertexPointer" , "glTexCoordPointer" , "glDrawArrays" , "glPushMatrix" , "glPopMatrix" , "glPushAttrib" , "glPopAttrib" , <S2SV_StartBug> "glPushClientAttrib" , "glPopClientAttrib" , "glPixelTransferi" , "glPixelMapfv" } ; <S2SV_EndBug> FB_GL * funcs = & __fb_gl ; void * * funcs_ptr = ( void * * ) funcs ; int res = 0 , size = FBGL_EXTENSIONS_STRING_SIZE - 1 ; fb_hMemSet ( & __fb_gl , 0 , sizeof ( FB_GL ) ) ; if ( fb_hDynLoadAlso ( lib , gl_funcs , funcs_ptr , sizeof ( gl_funcs ) / sizeof ( const char * ) ) ) return - 1 ; strncpy ( __fb_gl . extensions , ( char * ) __fb_gl . GetString ( GL_EXTENSIONS ) , size ) ; size -= strlen ( __fb_gl . extensions ) ; if ( os_extensions ) strncat ( __fb_gl . extensions , os_extensions , size ) ; __fb_gl . extensions [ FBGL_EXTENSIONS_STRING_SIZE - 1 ] = '\\0' ; res |= ! fb_hGL_ExtensionSupported ( "GL_EXT_bgra" ) ; return res ; }
|
<S2SV_ModStart> , "glPopClientAttrib" , "glPixelStorei" ,
|
7,856 |
CWE-000 void kmain ( ) { clear_screen ( ) ; <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> ( ) ; print_banner ( ) ;
|
7,857 |
CWE-000 static void pch_lpc_add_mmio_resources ( device_t dev ) { u32 reg ; struct resource * res ; const u32 default_decode_base = IO_APIC_ADDR ; res = new_resource ( dev , OIC ) ; res -> base = default_decode_base ; res -> size = 0 - default_decode_base ; res -> flags = IORESOURCE_MEM | IORESOURCE_ASSIGNED | IORESOURCE_FIXED ; <S2SV_StartBug> if ( RCBA_BASE_ADDRESS < default_decode_base ) { <S2SV_EndBug> res = new_resource ( dev , RCBA ) ; res -> base = RCBA_BASE_ADDRESS ; res -> size = 16 * 1024 ; res -> flags = IORESOURCE_MEM | IORESOURCE_ASSIGNED | IORESOURCE_FIXED | IORESOURCE_RESERVE ; } reg = pci_read_config32 ( dev , LGMR ) ; if ( reg & 1 ) { reg &= ~ 0xffff ; if ( reg < default_decode_base ) { res = new_resource ( dev , LGMR ) ; res -> base = reg ; res -> size = 16 * 1024 ; res -> flags = IORESOURCE_MEM | IORESOURCE_ASSIGNED | IORESOURCE_FIXED | IORESOURCE_RESERVE ; } } }
|
<S2SV_ModStart> ; if ( default_decode_base > RCBA_BASE_ADDRESS <S2SV_ModEnd> ) { res
|
7,858 |
CWE-000 <S2SV_StartBug> static int nr_ice_crypto_dummy_hmac_sha1 ( UCHAR * key , int key_l , UCHAR * buf , int buf_l , UCHAR digest [ 20 ] ) <S2SV_EndBug> { fprintf ( stderr , "Need<S2SV_blank>to<S2SV_blank>define<S2SV_blank>crypto<S2SV_blank>API<S2SV_blank>implementation\\n" ) ; exit ( 1 ) ; }
|
<S2SV_ModStart> * key , size_t <S2SV_ModEnd> key_l , UCHAR <S2SV_ModStart> * buf , size_t <S2SV_ModEnd> buf_l , UCHAR
|
7,859 |
CWE-000 static int mdss_fb_remove ( struct platform_device * pdev ) { struct msm_fb_data_type * mfd ; mfd = ( struct msm_fb_data_type * ) platform_get_drvdata ( pdev ) ; if ( ! mfd ) return - ENODEV ; mdss_fb_remove_sysfs ( mfd ) ; pm_runtime_disable ( mfd -> fbi -> dev ) ; if ( mfd -> key != MFD_KEY ) return - EINVAL ; mdss_fb_unregister_input_handler ( mfd ) ; <S2SV_StartBug> if ( mdss_fb_suspend_sub ( mfd ) ) <S2SV_EndBug> pr_err ( "msm_fb_remove:<S2SV_blank>can\'t<S2SV_blank>stop<S2SV_blank>the<S2SV_blank>device<S2SV_blank>%d\\n" , mfd -> index ) ; unregister_framebuffer ( mfd -> fbi ) ; if ( lcd_backlight_registered ) { lcd_backlight_registered = 0 ; led_classdev_unregister ( & backlight_led ) ; } return 0 ; }
|
<S2SV_ModStart> mfd ) ; mdss_panel_debugfs_cleanup ( mfd -> panel_info ) ;
|
7,860 |
CWE-000 pid_t sys_exec ( const char * cmd_line ) { if ( cmd_line < PHYS_BASE ) { int ret = get_user ( cmd_line ) ; if ( ret < 0 ) { sys_exit ( - 1 ) ; } } else { sys_exit ( - 1 ) ; } <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> ) ; } printf ( "NOT<S2SV_blank>IMPLEMENTED!!!" ) ;
|
7,861 |
CWE-000 int trig_set_timepix_delay ( unsigned char delay ) { int rc ; unsigned char fullmask [ 4 ] ; rc = trig_get_register ( 0x05 , fullmask ) ; if ( rc != TRIG_OK ) return rc ; fullmask [ 3 ] = delay ; <S2SV_StartBug> return trig_set_register ( 0x02 , fullmask ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> return trig_set_register ( 0x05 <S2SV_ModEnd> , fullmask )
|
7,862 |
CWE-000 struct lxc_container * lxc_container_new ( const char * name , const char * configpath ) { struct lxc_container * c ; <S2SV_StartBug> if ( ! name ) <S2SV_EndBug> return NULL ; c = malloc ( sizeof ( * c ) ) ; if ( ! c ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>%s\\n" , name ) ; return NULL ; } memset ( c , 0 , sizeof ( * c ) ) ; if ( configpath ) c -> config_path = strdup ( configpath ) ; else c -> config_path = strdup ( lxc_global_config_value ( "lxc.lxcpath" ) ) ; if ( ! c -> config_path ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>%s\\n" , name ) ; goto err ; } remove_trailing_slashes ( c -> config_path ) ; <S2SV_StartBug> c -> name = malloc ( strlen ( name ) + 1 ) ; <S2SV_EndBug> if ( ! c -> name ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>%s\\n" , name ) ; goto err ; } <S2SV_StartBug> strcpy ( c -> name , name ) ; <S2SV_EndBug> c -> numthreads = 1 ; c -> slock = lxc_newlock ( c -> config_path , name ) ; if ( ! c -> slock ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>lock<S2SV_blank>for<S2SV_blank>%s\\n" , name ) ; goto err ; } c -> privlock = lxc_newlock ( NULL , NULL ) ; if ( ! c -> privlock ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>private<S2SV_blank>lock<S2SV_blank>for<S2SV_blank>%s\\n" , name ) ; goto err ; } if ( ! set_config_filename ( c ) ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>config<S2SV_blank>file<S2SV_blank>name<S2SV_blank>for<S2SV_blank>%s\\n" , name ) ; goto err ; } if ( file_exists ( c -> configfile ) && ! lxcapi_load_config ( c , NULL ) ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>load<S2SV_blank>config<S2SV_blank>for<S2SV_blank>%s\\n" , name ) ; goto err ; } if ( ongoing_create ( c ) == 2 ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>complete<S2SV_blank>container<S2SV_blank>creation<S2SV_blank>for<S2SV_blank>%s" , c -> name ) ; container_destroy ( c , NULL ) ; lxcapi_clear_config ( c ) ; } c -> daemonize = true ; c -> pidfile = NULL ; c -> is_defined = lxcapi_is_defined ; c -> state = lxcapi_state ; c -> is_running = lxcapi_is_running ; c -> freeze = lxcapi_freeze ; c -> unfreeze = lxcapi_unfreeze ; c -> console = lxcapi_console ; c -> console_getfd = lxcapi_console_getfd ; c -> init_pid = lxcapi_init_pid ; c -> load_config = lxcapi_load_config ; c -> want_daemonize = lxcapi_want_daemonize ; c -> want_close_all_fds = lxcapi_want_close_all_fds ; c -> start = lxcapi_start ; c -> startl = lxcapi_startl ; c -> stop = lxcapi_stop ; c -> config_file_name = lxcapi_config_file_name ; c -> wait = lxcapi_wait ; c -> set_config_item = lxcapi_set_config_item ; c -> destroy = lxcapi_destroy ; c -> destroy_with_snapshots = lxcapi_destroy_with_snapshots ; c -> rename = lxcapi_rename ; c -> save_config = lxcapi_save_config ; c -> get_keys = lxcapi_get_keys ; c -> create = lxcapi_create ; c -> createl = lxcapi_createl ; c -> shutdown = lxcapi_shutdown ; c -> reboot = lxcapi_reboot ; c -> reboot2 = lxcapi_reboot2 ; c -> clear_config = lxcapi_clear_config ; c -> clear_config_item = lxcapi_clear_config_item ; c -> get_config_item = lxcapi_get_config_item ; c -> get_running_config_item = lxcapi_get_running_config_item ; c -> get_cgroup_item = lxcapi_get_cgroup_item ; c -> set_cgroup_item = lxcapi_set_cgroup_item ; c -> get_config_path = lxcapi_get_config_path ; c -> set_config_path = lxcapi_set_config_path ; c -> clone = lxcapi_clone ; c -> get_interfaces = lxcapi_get_interfaces ; c -> get_ips = lxcapi_get_ips ; c -> attach = lxcapi_attach ; c -> attach_run_wait = lxcapi_attach_run_wait ; c -> attach_run_waitl = lxcapi_attach_run_waitl ; c -> snapshot = lxcapi_snapshot ; c -> snapshot_list = lxcapi_snapshot_list ; c -> snapshot_restore = lxcapi_snapshot_restore ; c -> snapshot_destroy = lxcapi_snapshot_destroy ; c -> snapshot_destroy_all = lxcapi_snapshot_destroy_all ; c -> may_control = lxcapi_may_control ; c -> add_device_node = lxcapi_add_device_node ; c -> remove_device_node = lxcapi_remove_device_node ; c -> attach_interface = lxcapi_attach_interface ; c -> detach_interface = lxcapi_detach_interface ; c -> checkpoint = lxcapi_checkpoint ; c -> restore = lxcapi_restore ; c -> migrate = lxcapi_migrate ; c -> console_log = lxcapi_console_log ; return c ; err : lxc_container_free ( c ) ; return NULL ; }
|
<S2SV_ModStart> * c ; size_t len ; <S2SV_ModStart> config_path ) ; len = strlen ( name ) ; <S2SV_ModStart> = malloc ( len <S2SV_ModEnd> + 1 ) <S2SV_ModStart> err ; } ( void ) strlcpy ( c -> name , name , len + 1 <S2SV_ModEnd> ) ; c
|
7,863 |
CWE-000 void * initialize_flame_sensors ( void * arg ) { struct thread_info * info = ( struct thread_info * ) arg ; i2c_semaphore = info -> semaphore ; message_queue_id = info -> message_queue_id ; current_direction . value = not_specified ; sem_wait ( i2c_semaphore ) ; int handle = open_i2c_bus ( ) ; if ( handle < 0 ) { exit ( 1 ) ; } sem_post ( i2c_semaphore ) ; int converted_value ; int next_direction = 0 ; while ( 1 ) { converted_value = read_sensor ( handle , next_direction , i2c_semaphore ) ; receive_control_data ( & current_direction ) ; send_flame_data ( ( int ) converted_value , next_direction ) ; <S2SV_StartBug> if ( ( next_direction == front ) && ( converted_value < 1500 ) ) { <S2SV_EndBug> motors_off ( ) ; } if ( current_direction . value == not_specified ) { next_direction = ( ( int ) next_direction + 1 ) % 4 ; } else { next_direction = current_direction . value ; } } exit ( 0 ) ; }
|
<S2SV_ModStart> ; if ( <S2SV_ModEnd> current_direction . value
|
7,864 |
CWE-000 static int sprd_cpufreq_init ( struct cpufreq_policy * policy ) { int ret ; cpufreq_frequency_table_cpuinfo ( policy , sprd_cpufreq_conf -> freq_tbl ) ; policy -> cur = sprd_raw_get_cpufreq ( ) ; policy -> cpuinfo . transition_latency = TRANSITION_LATENCY ; policy -> shared_type = CPUFREQ_SHARED_TYPE_ALL ; cpufreq_frequency_table_get_attr ( sprd_cpufreq_conf -> freq_tbl , policy -> cpu ) ; percpu_target [ policy -> cpu ] = policy -> cur ; ret = cpufreq_frequency_table_cpuinfo ( policy , sprd_cpufreq_conf -> freq_tbl ) ; if ( ret != 0 ) pr_err ( "%s<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>config<S2SV_blank>freq<S2SV_blank>table:<S2SV_blank>%d\\n" , __func__ , ret ) ; pr_info ( "%s<S2SV_blank>policy->cpu=%d,<S2SV_blank>policy->cur=%u,<S2SV_blank>ret=%d\\n" , __func__ , policy -> cpu , policy -> cur , ret ) ; <S2SV_StartBug> cpumask_setall ( policy -> cpus ) ; <S2SV_EndBug> return ret ; }
|
<S2SV_ModStart> ret ) ; <S2SV_ModEnd> return ret ;
|
7,865 |
CWE-000 void config_one_led ( enum ec_led_id id , enum led_charge_state charge ) { const led_patterns * pattern ; struct led_pattern p ; pattern = patterns [ id ] ; if ( ! pattern ) return ; if ( id == EC_LED_ID_BATTERY_LED && charge == LED_STATE_DISCHARGE && charge_get_percent ( ) < low_battery_soc ) p = low_battery ; else p = ( * pattern ) [ charge ] [ power_state ] ; <S2SV_StartBug> if ( ! p . pulse ) { <S2SV_EndBug> cancel_tick ( id ) ; set_color ( id , p . color , 100 ) ; return ; } config_tick ( id , & p ) ; <S2SV_StartBug> start_tick ( id ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> power_state ] ; start_tick <S2SV_ModEnd> ( id , <S2SV_ModStart> p ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null>
|
7,866 |
CWE-000 void msm_gem_shrinker_cleanup ( struct drm_device * dev ) { <S2SV_StartBug> struct msm_drm_private * priv = dev -> dev_private ; <S2SV_EndBug> WARN_ON ( unregister_vmap_purge_notifier ( & priv -> vmap_notifier ) ) ; unregister_shrinker ( & priv -> shrinker ) ; <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> -> dev_private ; if ( priv -> shrinker . nr_deferred ) { <S2SV_ModStart> ) ; } }
|
7,867 |
CWE-000 static int wt_save_sq ( real_t * a , size_t sz , FILE * fp ) { size_t i ; int16_t si ; for ( i = 0 ; i < sz ; i ++ ) { si = quantify_int16 ( a [ i ] , SQ_MULTIPLE ) ; if ( fwrite ( & si , sizeof ( int16_t ) , 1 , fp ) != 1 ) { ST_WARNING ( "Failed<S2SV_blank>to<S2SV_blank>write<S2SV_blank>short." ) ; return - 1 ; } } <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> ; } } return 0 ;
|
7,868 |
CWE-000 <S2SV_StartBug> void lmcp_pack_float ( uint8_t * buf , float in ) { <S2SV_EndBug> uint32_t l = pack754_32 ( in ) ; lmcp_pack_uint32_t ( buf , l ) ; <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> size_t <S2SV_ModEnd> lmcp_pack_float ( uint8_t <S2SV_ModStart> l ) ; return 4 ;
|
7,869 |
CWE-000 void mgr_sched_unset ( struct batch_request * preq ) { int bad_attr = 0 ; svrattrl * plist , * tmp_plist ; int rc ; pbs_sched * psched = find_scheduler ( preq -> rq_ind . rq_manager . rq_objname ) ; if ( ! psched ) { req_reject ( PBSE_UNKSCHED , 0 , preq ) ; return ; } for ( tmp_plist = ( svrattrl * ) GET_NEXT ( preq -> rq_ind . rq_manager . rq_attr ) ; tmp_plist ; tmp_plist = ( struct svrattrl * ) GET_NEXT ( tmp_plist -> al_link ) ) { if ( strcasecmp ( tmp_plist -> al_name , ATTR_sched_log ) == 0 || strcasecmp ( tmp_plist -> al_name , ATTR_sched_priv ) == 0 ) { set_scheduler_flag ( SCH_ATTRS_CONFIGURE , psched ) ; } else if ( strcasecmp ( tmp_plist -> al_name , ATTR_schediteration ) == 0 ) { if ( dflt_scheduler ) { svrattrl * t_list ; t_list = attrlist_create ( tmp_plist -> al_name , NULL , 0 ) ; if ( t_list == NULL ) { reply_badattr ( - 1 , bad_attr , tmp_plist , preq ) ; } t_list -> al_link . ll_next -> ll_struct = NULL ; rc = mgr_unset_attr ( server . sv_attr , svr_attr_def , SRV_ATR_LAST , t_list , - 1 , & bad_attr , ( void * ) & server , PARENT_TYPE_SERVER , INDIRECT_RES_CHECK ) ; if ( rc != 0 ) { free_svrattrl ( t_list ) ; reply_badattr ( rc , bad_attr , tmp_plist , preq ) ; return ; } <S2SV_StartBug> svr_save_db ( & server , SVR_SAVE_FULL ) ; <S2SV_EndBug> <S2SV_StartBug> free_svrattrl ( t_list ) ; <S2SV_EndBug> } } } plist = ( svrattrl * ) GET_NEXT ( preq -> rq_ind . rq_manager . rq_attr ) ; rc = mgr_unset_attr ( psched -> sch_attr , sched_attr_def , SCHED_ATR_LAST , plist , preq -> rq_perm , & bad_attr , ( void * ) psched , PARENT_TYPE_SCHED , INDIRECT_RES_CHECK ) ; if ( rc != 0 ) reply_badattr ( rc , bad_attr , plist , preq ) ; else { ( void ) sched_save_db ( psched , SVR_SAVE_FULL ) ; set_sched_default ( psched , 1 ) ; ( void ) sprintf ( log_buffer , msg_manager , msg_man_uns , preq -> rq_user , preq -> rq_host ) ; log_event ( PBSEVENT_ADMIN , PBS_EVENTCLASS_SCHED , LOG_INFO , msg_daemonname , log_buffer ) ; mgr_log_attr ( msg_man_uns , plist , PBS_EVENTCLASS_SCHED , msg_daemonname , NULL ) ; reply_ack ( preq ) ; } }
|
<S2SV_ModStart> return ; } backup_svr_sv_jobidnumber = server . sv_qs . sv_jobidnumber ; server . sv_qs . sv_jobidnumber = update_svr_sv_jobidnumber ; <S2SV_ModStart> SVR_SAVE_FULL ) ; server . sv_qs . sv_jobidnumber = backup_svr_sv_jobidnumber ;
|
7,870 |
CWE-000 void bitmap_print_sb ( struct bitmap * bitmap ) { bitmap_super_t * sb ; if ( ! bitmap || ! bitmap -> storage . sb_page ) return ; sb = kmap_atomic ( bitmap -> storage . sb_page ) ; pr_debug ( "%s:<S2SV_blank>bitmap<S2SV_blank>file<S2SV_blank>superblock:\\n" , bmname ( bitmap ) ) ; pr_debug ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>magic:<S2SV_blank>%08x\\n" , le32_to_cpu ( sb -> magic ) ) ; pr_debug ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>version:<S2SV_blank>%d\\n" , le32_to_cpu ( sb -> version ) ) ; pr_debug ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>uuid:<S2SV_blank>%08x.%08x.%08x.%08x\\n" , <S2SV_StartBug> * ( __u32 * ) ( sb -> uuid + 0 ) , <S2SV_EndBug> <S2SV_StartBug> * ( __u32 * ) ( sb -> uuid + 4 ) , <S2SV_EndBug> <S2SV_StartBug> * ( __u32 * ) ( sb -> uuid + 8 ) , <S2SV_EndBug> <S2SV_StartBug> * ( __u32 * ) ( sb -> uuid + 12 ) ) ; <S2SV_EndBug> pr_debug ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>events:<S2SV_blank>%llu\\n" , ( unsigned long long ) le64_to_cpu ( sb -> events ) ) ; pr_debug ( "events<S2SV_blank>cleared:<S2SV_blank>%llu\\n" , ( unsigned long long ) le64_to_cpu ( sb -> events_cleared ) ) ; pr_debug ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>state:<S2SV_blank>%08x\\n" , le32_to_cpu ( sb -> state ) ) ; pr_debug ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>chunksize:<S2SV_blank>%d<S2SV_blank>B\\n" , le32_to_cpu ( sb -> chunksize ) ) ; pr_debug ( "<S2SV_blank><S2SV_blank>daemon<S2SV_blank>sleep:<S2SV_blank>%ds\\n" , le32_to_cpu ( sb -> daemon_sleep ) ) ; pr_debug ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>sync<S2SV_blank>size:<S2SV_blank>%llu<S2SV_blank>KB\\n" , ( unsigned long long ) le64_to_cpu ( sb -> sync_size ) / 2 ) ; pr_debug ( "max<S2SV_blank>write<S2SV_blank>behind:<S2SV_blank>%d\\n" , le32_to_cpu ( sb -> write_behind ) ) ; kunmap_atomic ( sb ) ; }
|
<S2SV_ModStart> ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>uuid:<S2SV_blank>%08x.%08x.%08x.%08x\\n" , le32_to_cpu ( <S2SV_ModStart> + 0 ) ) , le32_to_cpu ( <S2SV_ModEnd> * ( __u32 <S2SV_ModStart> + 4 ) ) , le32_to_cpu ( <S2SV_ModEnd> * ( __u32 <S2SV_ModStart> + 8 ) ) , le32_to_cpu ( <S2SV_ModEnd> * ( __u32 <S2SV_ModStart> uuid + 12 )
|
7,871 |
CWE-000 int tool_cmd_get ( nyoci_t nyoci , int argc , char * argv [ ] ) { gRet = ERRORCODE_INPROGRESS ; int i ; char url [ 1000 ] = "" ; previous_sigint_handler = signal ( SIGINT , & signal_interrupt ) ; get_show_headers = false ; next_len = ( ( coap_size_t ) ( - 1 ) ) ; get_show_headers = false ; redirect_count = 0 ; size_request = 0 ; get_observe = false ; get_keep_alive = false ; get_timeout = 30 * 1000 ; last_observe_value = - 1 ; request_accept_type = COAP_CONTENT_TYPE_UNKNOWN ; observe_once = false ; observe_ignore_first = false ; get_tt = COAP_TRANS_TYPE_CONFIRMABLE ; if ( strcmp ( argv [ 0 ] , "observe" ) == 0 || strcmp ( argv [ 0 ] , "obs" ) == 0 ) { get_observe = true ; get_timeout = CMS_DISTANT_FUTURE ; } BEGIN_LONG_ARGUMENTS ( gRet ) HANDLE_LONG_ARGUMENT ( "include" ) get_show_headers = true ; HANDLE_LONG_ARGUMENT ( "follow" ) redirect_count = 10 ; HANDLE_LONG_ARGUMENT ( "no-follow" ) redirect_count = 0 ; HANDLE_LONG_ARGUMENT ( "slice-size" ) size_request = htons ( strtol ( argv [ ++ i ] , NULL , 0 ) ) ; HANDLE_LONG_ARGUMENT ( "timeout" ) get_timeout = ( nyoci_cms_t ) ( 1000 * strtof ( argv [ ++ i ] , NULL ) ) ; HANDLE_LONG_ARGUMENT ( "observe" ) get_observe = true ; HANDLE_LONG_ARGUMENT ( "no-observe" ) get_observe = false ; HANDLE_LONG_ARGUMENT ( "non" ) get_tt = COAP_TRANS_TYPE_NONCONFIRMABLE ; HANDLE_LONG_ARGUMENT ( "keep-alive" ) get_keep_alive = true ; HANDLE_LONG_ARGUMENT ( "no-keep-alive" ) get_keep_alive = false ; HANDLE_LONG_ARGUMENT ( "once" ) observe_once = true ; HANDLE_LONG_ARGUMENT ( "ignore-first" ) observe_ignore_first = true ; HANDLE_LONG_ARGUMENT ( "timestamp" ) print_timestamp = true ; HANDLE_LONG_ARGUMENT ( "accept" ) { i ++ ; if ( ! argv [ i ] ) { fprintf ( stderr , "Missing<S2SV_blank>argument<S2SV_blank>for<S2SV_blank>\\"%s\\"\\n" , argv [ i - 1 ] ) ; gRet = ERRORCODE_BADARG ; goto bail ; } request_accept_type = coap_content_type_from_cstr ( argv [ i ] ) ; } HANDLE_LONG_ARGUMENT ( "help" ) { print_arg_list_help ( option_list , argv [ 0 ] , "[args]<S2SV_blank><uri>" ) ; gRet = ERRORCODE_HELP ; goto bail ; } BEGIN_SHORT_ARGUMENTS ( gRet ) HANDLE_SHORT_ARGUMENT ( 'i' ) get_show_headers = true ; HANDLE_SHORT_ARGUMENT ( 'f' ) redirect_count = 10 ; HANDLE_SHORT_ARGUMENT ( 'O' ) get_observe = true ; HANDLE_SHORT_ARGUMENT ( 'a' ) { i ++ ; if ( ! argv [ i ] ) { fprintf ( stderr , "Missing<S2SV_blank>argument<S2SV_blank>for<S2SV_blank>\\"%s\\"\\n" , argv [ i - 1 ] ) ; gRet = ERRORCODE_BADARG ; goto bail ; } request_accept_type = coap_content_type_from_cstr ( argv [ i ] ) ; } HANDLE_SHORT_ARGUMENT2 ( 'h' , '?' ) { print_arg_list_help ( option_list , argv [ 0 ] , "[args]<S2SV_blank><uri>" ) ; gRet = ERRORCODE_HELP ; goto bail ; } HANDLE_OTHER_ARGUMENT ( ) { if ( url [ 0 ] == 0 ) { if ( getenv ( "NYOCI_CURRENT_PATH" ) ) { strncpy ( url , getenv ( "NYOCI_CURRENT_PATH" ) , sizeof ( url ) ) ; url_change ( url , argv [ i ] ) ; } else { strncpy ( url , argv [ i ] , sizeof ( url ) ) ; } } else { fprintf ( stderr , "Unexpected<S2SV_blank>extra<S2SV_blank>argument:<S2SV_blank>\\"%s\\"\\n" , argv [ i ] ) ; gRet = ERRORCODE_BADARG ; goto bail ; } } END_ARGUMENTS if ( ( url [ 0 ] == 0 ) && getenv ( "NYOCI_CURRENT_PATH" ) ) strncpy ( url , getenv ( "NYOCI_CURRENT_PATH" ) , sizeof ( url ) ) ; if ( url [ 0 ] == 0 ) { fprintf ( stderr , "Missing<S2SV_blank>path<S2SV_blank>argument.\\n" ) ; gRet = ERRORCODE_BADARG ; goto bail ; } if ( size_request ) { char block [ ] = { 1 } ; require ( send_get_request ( nyoci , url , block , 1 ) , bail ) ; } else { require ( send_get_request ( nyoci , url , NULL , 0 ) , bail ) ; } while ( ERRORCODE_INPROGRESS == gRet ) { nyoci_plat_wait ( nyoci , 1000 ) ; nyoci_plat_process ( nyoci ) ; } bail : <S2SV_StartBug> nyoci_transaction_end ( nyoci , & transaction ) ; <S2SV_EndBug> <S2SV_StartBug> signal ( SIGINT , previous_sigint_handler ) ; <S2SV_EndBug> url_data = NULL ; return gRet ; }
|
<S2SV_ModStart> } bail : if ( transaction . active ) { <S2SV_ModStart> transaction ) ; }
|
7,872 |
CWE-000 static int ip6_setup_cork ( struct sock * sk , struct inet_cork_full * cork , struct inet6_cork * v6_cork , int hlimit , int tclass , struct ipv6_txoptions * opt , struct rt6_info * rt , struct flowi6 * fl6 ) { struct ipv6_pinfo * np = inet6_sk ( sk ) ; unsigned int mtu ; if ( opt ) { if ( WARN_ON ( v6_cork -> opt ) ) return - EINVAL ; <S2SV_StartBug> v6_cork -> opt = kzalloc ( opt -> tot_len , sk -> sk_allocation ) ; <S2SV_EndBug> if ( unlikely ( ! v6_cork -> opt ) ) return - ENOBUFS ; v6_cork -> opt -> tot_len = opt -> tot_len ; v6_cork -> opt -> opt_flen = opt -> opt_flen ; v6_cork -> opt -> opt_nflen = opt -> opt_nflen ; v6_cork -> opt -> dst0opt = ip6_opt_dup ( opt -> dst0opt , sk -> sk_allocation ) ; if ( opt -> dst0opt && ! v6_cork -> opt -> dst0opt ) return - ENOBUFS ; v6_cork -> opt -> dst1opt = ip6_opt_dup ( opt -> dst1opt , sk -> sk_allocation ) ; if ( opt -> dst1opt && ! v6_cork -> opt -> dst1opt ) return - ENOBUFS ; v6_cork -> opt -> hopopt = ip6_opt_dup ( opt -> hopopt , sk -> sk_allocation ) ; if ( opt -> hopopt && ! v6_cork -> opt -> hopopt ) return - ENOBUFS ; v6_cork -> opt -> srcrt = ip6_rthdr_dup ( opt -> srcrt , sk -> sk_allocation ) ; if ( opt -> srcrt && ! v6_cork -> opt -> srcrt ) return - ENOBUFS ; } dst_hold ( & rt -> dst ) ; cork -> base . dst = & rt -> dst ; cork -> fl . u . ip6 = * fl6 ; v6_cork -> hop_limit = hlimit ; v6_cork -> tclass = tclass ; if ( rt -> dst . flags & DST_XFRM_TUNNEL ) mtu = np -> pmtudisc >= IPV6_PMTUDISC_PROBE ? rt -> dst . dev -> mtu : dst_mtu ( & rt -> dst ) ; else mtu = np -> pmtudisc >= IPV6_PMTUDISC_PROBE ? rt -> dst . dev -> mtu : dst_mtu ( rt -> dst . path ) ; if ( np -> frag_size < mtu ) { if ( np -> frag_size ) mtu = np -> frag_size ; } cork -> base . fragsize = mtu ; if ( dst_allfrag ( rt -> dst . path ) ) cork -> base . flags |= IPCORK_ALLFRAG ; cork -> base . length = 0 ; return 0 ; }
|
<S2SV_ModStart> = kzalloc ( sizeof ( * opt ) , sk -> sk_allocation ) ; if ( unlikely ( ! v6_cork -> opt ) ) return - ENOBUFS ; v6_cork -> <S2SV_ModStart> opt -> tot_len = sizeof ( * opt ) <S2SV_ModEnd> ; v6_cork ->
|
7,873 |
CWE-000 void * key_process ( void * emm ) { volatile char temp ; for ( ; ; ) { temp = getch ( ) ; if ( communication_input == 0xFF ) break ; communication_input = temp ; } <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> temp ; } pthread_exit ( 0 ) ;
|
7,874 |
CWE-000 <S2SV_StartBug> void oc_send_buffer ( oc_message_t * message ) { <S2SV_EndBug> ( void ) message ; oc_abort ( __func__ ) ; <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> int <S2SV_ModEnd> oc_send_buffer ( oc_message_t <S2SV_ModStart> __func__ ) ; return - 1 ;
|
7,875 |
CWE-000 static int fec_drv_remove ( struct platform_device * pdev ) { struct net_device * ndev = platform_get_drvdata ( pdev ) ; struct fec_enet_private * fep = netdev_priv ( ndev ) ; cancel_work_sync ( & fep -> tx_timeout_work ) ; fec_ptp_stop ( pdev ) ; unregister_netdev ( ndev ) ; fec_enet_mii_remove ( fep ) ; if ( fep -> reg_phy ) regulator_disable ( fep -> reg_phy ) ; <S2SV_StartBug> of_node_put ( fep -> phy_node ) ; <S2SV_EndBug> free_netdev ( ndev ) ; return 0 ; }
|
<S2SV_ModStart> reg_phy ) ; pm_runtime_put ( & pdev -> dev ) ; pm_runtime_disable ( & pdev -> dev ) ;
|
7,876 |
CWE-000 int add_new_ip ( struct ip_list * head , uint32_t ip , uint32_t mask ) { struct ip_list * p ; p = head ; while ( p -> fp != head ) { p = p -> fp ; } <S2SV_StartBug> struct ip_list * newip = ( struct ip_list * ) malloc ( sizeof ( struct ip_list * ) ) ; <S2SV_EndBug> init_ip_struct ( newip , ip , mask ) ; insert_iplist ( p , newip ) ; }
|
<S2SV_ModStart> ( struct ip_list <S2SV_ModEnd> ) ) ;
|
7,877 |
CWE-000 void syncThreadTo60Hz ( void ) { uint64_t timeNow_64bit ; <S2SV_StartBug> double delayMs_f , perfFreq_f ; <S2SV_EndBug> perfFreq_f = ( double ) ( SDL_GetPerformanceFrequency ( ) ) ; if ( perfFreq_f == 0.0 ) return ; timeNow_64bit = SDL_GetPerformanceCounter ( ) ; if ( next60HzTime_64bit > timeNow_64bit ) { delayMs_f = ( double ) ( next60HzTime_64bit - timeNow_64bit ) * ( 1000.0 / perfFreq_f ) ; SDL_Delay ( ( uint32_t ) ( delayMs_f + 0.5 ) ) ; } <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> delayMs_f , perfFreq_f , frameLength_f <S2SV_ModStart> ) ; } frameLength_f = perfFreq_f / VBLANK_HZ ; next60HzTime_64bit += ( uint64_t ) ( frameLength_f + 0.5 ) ;
|
7,878 |
CWE-000 <S2SV_StartBug> uint8_t execl_P ( const PROGMEM char * argv , ... ) <S2SV_EndBug> { char * arglist [ NCARGS ] , * p , * str ; uint8_t len , ret = 0 ; int8_t i = 0 ; va_list va ; if ( argv == NULL ) return 0 ; p = ( char * ) argv ; va_start ( va , argv ) ; do { len = strlen_P ( p ) ; if ( ( str = malloc ( len + 1 ) ) == NULL ) { ret = 6 ; goto finish ; } strncpy_P ( str , p , len ) ; str [ len ] = 0 ; arglist [ i ++ ] = str ; } while ( i < NCARGS && ( p = va_arg ( va , char * ) ) != NULL ) ; va_end ( va ) ; arglist [ i ] = NULL ; ret = execve ( ( const char * * ) arglist , NULL ) ; finish : for ( i -- ; i >= 0 ; i -- ) free ( arglist [ i ] ) ; return ret ; }
|
<S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> int8_t <S2SV_ModEnd> execl_P ( const
|
7,879 |
CWE-000 static void resolveAlias ( Parse * pParse , ExprList * pEList , int iCol , Expr * pExpr , const char * zType , int nSubquery ) { Expr * pOrig ; Expr * pDup ; sqlite3 * db ; assert ( iCol >= 0 && iCol < pEList -> nExpr ) ; pOrig = pEList -> a [ iCol ] . pExpr ; assert ( pOrig != 0 ) ; db = pParse -> db ; pDup = sqlite3ExprDup ( db , pOrig , 0 ) ; if ( pDup == 0 ) return ; <S2SV_StartBug> if ( pOrig -> op != TK_COLUMN && zType [ 0 ] != 'G' ) { <S2SV_EndBug> incrAggFunctionDepth ( pDup , nSubquery ) ; <S2SV_StartBug> pDup = sqlite3PExpr ( pParse , TK_AS , pDup , 0 , 0 ) ; <S2SV_EndBug> if ( pDup == 0 ) return ; ExprSetProperty ( pDup , EP_Skip ) ; if ( pEList -> a [ iCol ] . u . x . iAlias == 0 ) { pEList -> a [ iCol ] . u . x . iAlias = ( u16 ) ( ++ pParse -> nAlias ) ; } pDup -> iTable = pEList -> a [ iCol ] . u . x . iAlias ; } if ( pExpr -> op == TK_COLLATE ) { pDup = sqlite3ExprAddCollateString ( pParse , pDup , pExpr -> u . zToken ) ; } <S2SV_StartBug> ExprSetProperty ( pExpr , EP_Static ) ; <S2SV_EndBug> sqlite3ExprDelete ( db , pExpr ) ; memcpy ( pExpr , pDup , sizeof ( * pExpr ) ) ; if ( ! ExprHasProperty ( pExpr , EP_IntValue ) && pExpr -> u . zToken != 0 ) { assert ( ( pExpr -> flags & ( EP_Reduced | EP_TokenOnly ) ) == 0 ) ; pExpr -> u . zToken = sqlite3DbStrDup ( db , pExpr -> u . zToken ) ; pExpr -> flags |= EP_MemToken ; } sqlite3DbFree ( db , pDup ) ; }
|
<S2SV_ModStart> ; if ( <S2SV_ModEnd> zType [ 0 <S2SV_ModStart> != 'G' ) <S2SV_ModEnd> incrAggFunctionDepth ( pDup <S2SV_ModStart> nSubquery ) ; <S2SV_ModEnd> if ( pExpr <S2SV_ModStart> } ExprSetProperty ( pDup , EP_Alias ) ; ExprSetProperty (
|
7,880 |
CWE-000 void ft_load_db ( t_table * t ) { int fd ; char * line ; if ( ( fd = open ( FILENAME , O_RDONLY ) ) == - 1 ) { printf ( "file<S2SV_blank>no<S2SV_blank>exist\\n" ) ; return ; } if ( ! ( get_next_line ( fd , & line ) ) ) { printf ( "no<S2SV_blank>header\\n" ) ; return ; } ft_get_columns ( line , t ) ; ft_strdel ( & line ) ; while ( get_next_line ( fd , & line ) ) { <S2SV_StartBug> ft_load_row ( line , t ) ; <S2SV_EndBug> ft_strdel ( & line ) ; } close ( fd ) ; }
|
<S2SV_ModStart> ) ) { printf ( "about<S2SV_blank>to<S2SV_blank>load<S2SV_blank>%s\\n" , line ) ;
|
7,881 |
CWE-000 void swap_ab ( t_stack * l1 ) { <S2SV_StartBug> if ( ft_lstlen ( l1 ) == 1 ) <S2SV_EndBug> <S2SV_StartBug> return ; <S2SV_EndBug> <S2SV_StartBug> ft_swap ( & l1 -> data , & l1 -> next -> data ) ; <S2SV_EndBug> ft_swap ( & l1 -> norm , & l1 -> next -> norm ) ; }
|
<S2SV_ModStart> l1 ) { ft_putendl_fd ( CYN "A" RESET , 2 ) ; if ( l1 == NULL || l1 -> next == NULL ) return ; ft_putendl_fd ( CYN "B" RESET , 2 ) ; <S2SV_ModStart> ( l1 ) <= <S2SV_ModEnd> 1 ) return <S2SV_ModStart> 1 ) return ; ft_putendl_fd ( CYN "C" RESET , 2 ) <S2SV_ModStart> next -> data ) ; ft_putendl_fd ( CYN "D" RESET , 2
|
7,882 |
CWE-000 void calcAbsLoc ( struct sprite * spriteIn , struct absLoc * loc ) { int init = - 1 ; memcpy ( loc , & init , sizeof ( struct absLoc ) ) ; loc -> numChars = 0 ; int dispCount ; char tdisp [ MAX_DISP_SUBSIZE ] ; char temp [ MAX_DISP_SUBSIZE ] ; for ( dispCount = 0 ; dispCount < spriteIn -> numDisps ; dispCount ++ ) { int i = 0 , j = 0 , n = 0 ; strcpy ( tdisp , spriteIn -> dispArr [ dispCount ] -> disp ) ; for ( i = 0 ; i <= strlen ( tdisp ) ; i ++ ) { if ( tdisp [ i ] == '\\n' || tdisp [ i ] == '\\0' ) { memcpy ( temp , & ( tdisp [ n ] ) , ( i - n ) * sizeof ( char ) ) ; temp [ i - n ] = '\\0' ; int dx = 0 ; <S2SV_StartBug> while ( dx <= strlen ( temp ) ) { <S2SV_EndBug> if ( temp [ dx ] != '<S2SV_blank>' ) { loc -> x [ loc -> numChars ] = ( int ) spriteIn -> xLoc + dx ; loc -> y [ loc -> numChars ] = ( int ) spriteIn -> yLoc + j ; loc -> numChars ++ ; } dx ++ ; } n = i + 1 ; j ++ ; } } } }
|
<S2SV_ModStart> while ( dx < <S2SV_ModEnd> strlen ( temp
|
7,883 |
CWE-000 void UiSpectrum_Redraw ( ) { if ( <S2SV_StartBug> ( ts . scope_scheduler == 0 || ts . waterfall . scheduler == 0 ) <S2SV_EndBug> && ( ts . txrx_mode == TRX_MODE_RX ) && ( ts . menu_mode == false ) && ( ts . powering_down == false ) && ( ts . mem_disp == false ) && ( sd . enabled == true ) && ( ts . lcd_blanking_flag == false ) ) { if ( ts . waterfall . scheduler == 0 && is_waterfallmode ( ) ) { if ( ts . waterfall . speed > 0 ) { ts . waterfall . scheduler = ( ts . waterfall . speed - 1 ) * ( sd . doubleWaterfallLine ? 100 : 50 ) ; sd . RedrawType |= Redraw_WATERFALL ; } } if ( ts . scope_scheduler == 0 && is_scopemode ( ) ) { if ( ts . scope_speed > 0 ) { ts . scope_scheduler = ( ts . scope_speed - 1 ) * 50 ; sd . RedrawType |= Redraw_SCOPE ; } } UiSpectrum_RedrawSpectrum ( ) ; } }
|
<S2SV_ModStart> { if ( <S2SV_ModEnd> ( ts .
|
7,884 |
CWE-000 int can_main ( int argc , char * argv [ ] ) { # ifndef CONFIG_EXAMPLES_CAN_READONLY struct can_msg_s txmsg ; # ifdef CONFIG_CAN_EXTID uint32_t msgid ; # else uint16_t msgid ; # endif int msgdlc ; uint8_t msgdata ; # endif # ifndef CONFIG_EXAMPLES_CAN_WRITEONLY struct can_msg_s rxmsg ; # endif size_t msgsize ; ssize_t nbytes ; # if defined ( CONFIG_NSH_BUILTIN_APPS ) || defined ( CONFIG_EXAMPLES_CAN_NMSGS ) long nmsgs ; # endif int fd ; int errval = 0 ; int ret ; int i ; # if defined ( CONFIG_NSH_BUILTIN_APPS ) nmsgs = CONFIG_EXAMPLES_CAN_NMSGS ; if ( argc > 1 ) { nmsgs = strtol ( argv [ 1 ] , NULL , 10 ) ; } message ( "can_main:<S2SV_blank>nmsgs:<S2SV_blank>%d\\n" , nmsgs ) ; # elif defined ( CONFIG_EXAMPLES_CAN_NMSGS ) message ( "can_main:<S2SV_blank>nmsgs:<S2SV_blank>%d\\n" , CONFIG_EXAMPLES_CAN_NMSGS ) ; # endif message ( "can_main:<S2SV_blank>Initializing<S2SV_blank>external<S2SV_blank>CAN<S2SV_blank>device\\n" ) ; ret = can_devinit ( ) ; if ( ret != OK ) { message ( "can_main:<S2SV_blank>can_devinit<S2SV_blank>failed:<S2SV_blank>%d\\n" , ret ) ; errval = 1 ; goto errout ; } message ( "can_main:<S2SV_blank>Hardware<S2SV_blank>initialized.<S2SV_blank>Opening<S2SV_blank>the<S2SV_blank>CAN<S2SV_blank>device\\n" ) ; fd = open ( CONFIG_EXAMPLES_CAN_DEVPATH , CAN_OFLAGS ) ; if ( fd < 0 ) { message ( "can_main:<S2SV_blank>open<S2SV_blank>%s<S2SV_blank>failed:<S2SV_blank>%d\\n" , CONFIG_EXAMPLES_CAN_DEVPATH , errno ) ; errval = 2 ; goto errout_with_dev ; } # ifndef CONFIG_EXAMPLES_CAN_READONLY msgdlc = 1 ; msgid = 1 ; msgdata = 0 ; # endif # if defined ( CONFIG_NSH_BUILTIN_APPS ) for ( ; nmsgs > 0 ; nmsgs -- ) # elif defined ( CONFIG_EXAMPLES_CAN_NMSGS ) for ( nmsgs = 0 ; nmsgs < CONFIG_EXAMPLES_CAN_NMSGS ; nmsgs ++ ) # else for ( ; ; ) # endif { msgflush ( ) ; # ifndef CONFIG_EXAMPLES_CAN_READONLY txmsg . cm_hdr . ch_id = msgid ; txmsg . cm_hdr . ch_rtr = false ; txmsg . cm_hdr . ch_dlc = msgdlc ; # ifdef CONFIG_CAN_EXTID txmsg . cm_hdr . ch_extid = true ; # endif for ( i = 0 ; i < msgdlc ; i ++ ) { txmsg . cm_data [ i ] = msgdata + i ; } msgsize = CAN_MSGLEN ( msgdlc ) ; nbytes = write ( fd , & txmsg , msgsize ) ; if ( nbytes != msgsize ) { message ( "ERROR:<S2SV_blank>write(%d)<S2SV_blank>returned<S2SV_blank>%d\\n" , msgsize , nbytes ) ; errval = 3 ; goto errout_with_dev ; } # endif # ifdef CONFIG_EXAMPLES_CAN_WRITEONLY message ( "<S2SV_blank><S2SV_blank>ID:<S2SV_blank>%4d<S2SV_blank>DLC:<S2SV_blank>%d\\n" , msgid , msgdlc ) ; # endif # ifndef CONFIG_EXAMPLES_CAN_WRITEONLY msgsize = sizeof ( struct can_msg_s ) ; nbytes = read ( fd , & rxmsg , msgsize ) ; if ( nbytes < CAN_MSGLEN ( 0 ) || nbytes > msgsize ) { message ( "ERROR:<S2SV_blank>read(%d)<S2SV_blank>returned<S2SV_blank>%d\\n" , msgsize , nbytes ) ; errval = 4 ; goto errout_with_dev ; } # endif # ifndef CONFIG_EXAMPLES_CAN_READONLY <S2SV_StartBug> message ( "<S2SV_blank><S2SV_blank>ID:<S2SV_blank>%4d<S2SV_blank>DLC:<S2SV_blank>%d\\n" , rxmsg . cm_hdr . id , rxmsg . cm_hdr . dlc ) ; <S2SV_EndBug> # endif # ifdef CONFIG_EXAMPLES_CAN_READWRITE if ( memcmp ( & txmsg . cm_hdr , & rxmsg . cm_hdr , sizeof ( struct can_hdr_s ) ) != 0 ) { message ( "ERROR:<S2SV_blank>Sent<S2SV_blank>header<S2SV_blank>does<S2SV_blank>not<S2SV_blank>match<S2SV_blank>received<S2SV_blank>header:\\n" ) ; lib_dumpbuffer ( "Sent<S2SV_blank>header" , ( FAR const uint8_t * ) & txmsg . cm_hdr , sizeof ( struct can_hdr_s ) ) ; lib_dumpbuffer ( "Received<S2SV_blank>header" , ( FAR const uint8_t * ) & rxmsg . cm_hdr , sizeof ( struct can_hdr_s ) ) ; errval = 4 ; goto errout_with_dev ; } if ( memcmp ( txmsg . cm_data , rxmsg . cm_data , msgdlc ) != 0 ) { message ( "ERROR:<S2SV_blank>Data<S2SV_blank>does<S2SV_blank>not<S2SV_blank>match.<S2SV_blank>DLC=%d\\n" , msgdlc ) ; for ( i = 0 ; i < msgdlc ; i ++ ) { message ( "<S2SV_blank><S2SV_blank>%d:<S2SV_blank>TX<S2SV_blank>%02x<S2SV_blank>RX<S2SV_blank>%02x\\n" , i , txmsg . cm_data [ i ] , rxmsg . cm_data [ i ] ) ; errval = 5 ; goto errout_with_dev ; } } message ( "<S2SV_blank><S2SV_blank>ID:<S2SV_blank>%4d<S2SV_blank>DLC:<S2SV_blank>%d<S2SV_blank>--<S2SV_blank>OK\\n" , msgid , msgdlc ) ; # endif # ifndef CONFIG_EXAMPLES_CAN_READONLY msgdata += msgdlc ; if ( ++ msgid >= MAX_ID ) { msgid = 1 ; } if ( ++ msgdlc > CAN_MAXDATALEN ) { msgdlc = 1 ; } # endif } errout_with_dev : close ( fd ) ; errout : message ( "Terminating!\\n" ) ; msgflush ( ) ; return errval ; }
|
<S2SV_ModStart> . cm_hdr . ch_id <S2SV_ModEnd> , rxmsg . <S2SV_ModStart> . cm_hdr . ch_dlc <S2SV_ModEnd> ) ; #
|
7,885 |
CWE-000 void smp_proc_enc_info ( tSMP_CB * p_cb , tSMP_INT_DATA * p_data ) { UINT8 * p = ( UINT8 * ) p_data ; SMP_TRACE_DEBUG ( "%s" , __func__ ) ; <S2SV_StartBug> STREAM_TO_ARRAY ( p_cb -> ltk , p , BT_OCTET16_LEN ) ; <S2SV_EndBug> smp_key_distribution ( p_cb , NULL ) ; }
|
<S2SV_ModStart> __func__ ) ; if ( smp_command_has_invalid_parameters ( p_cb ) ) { tSMP_INT_DATA smp_int_data ; smp_int_data . status = SMP_INVALID_PARAMETERS ; android_errorWriteLog ( 0x534e4554 , "111937065" ) ; smp_sm_event ( p_cb , SMP_AUTH_CMPL_EVT , & smp_int_data ) ; return ; }
|
7,886 |
CWE-000 int run_lisp ( const char * bootstrap_path , const char * program_file , bool run_repl ) { if ( bootstrap_path && check_read_permissions ( bootstrap_path ) != 0 ) return errno ; if ( program_file && check_read_permissions ( program_file ) ) return errno ; int err = read_history ( LISP_HISTORY ) ; <S2SV_StartBug> if ( err ) perror ( LISP_HISTORY ) ; <S2SV_EndBug> repl_init ( ) ; signal ( SIGINT , int_handler ) ; if ( bootstrap_path ) repl_run_program ( bootstrap_path ) ; if ( program_file ) repl_run_program ( program_file ) ; if ( run_repl ) repl_run ( ) ; repl_dispose ( ) ; err = write_history ( LISP_HISTORY ) ; if ( err ) perror ( LISP_HISTORY ) ; return 0 ; }
|
<S2SV_ModStart> if ( err && err != ENOENT
|
7,887 |
CWE-000 int main ( int ac , char * * av ) { t_entries ent ; char flagcheck ; flagcheck = 0 ; ent = entries_init ( ) ; if ( ac == 1 ) { ent . dirs -> dir_name = ft_strdup ( "." ) ; opendir_getnames ( & ent . dirs -> files , ent . dirs -> dir_name , ent . flags ) ; mergesort_files ( & ent . dirs -> files ) ; printfileslist ( ent . dirs -> files , ent . flags ) ; return ( 0 ) ; } else av ++ ; if ( * * av == '-' ) { flagcheck = checkflags ( * av ) ; if ( flagcheck == 1 ) ent . flags = setfield ( * av ) ; else { if ( flagcheck != '1' ) { ft_printf ( "ft_ls:<S2SV_blank>illegal<S2SV_blank>option<S2SV_blank>--<S2SV_blank>%c\\n" , flagcheck ) ; ft_putendl ( "usage:<S2SV_blank>ft_ls<S2SV_blank>[-lRart]<S2SV_blank>[file<S2SV_blank>...]" ) ; exit ( 1 ) ; } } if ( ac == 2 ) { ent . dirs -> dir_name = ft_strdup ( "." ) ; opendir_getnames ( & ent . dirs -> files , ent . dirs -> dir_name , ent . flags ) ; mergesort_files ( & ent . dirs -> files ) ; if ( ent . flags & LONG_FORMAT ) ft_printf ( "total<S2SV_blank>%i\\n" , gettotalblocks ( ent . dirs -> files ) ) ; printfileslist ( ent . dirs -> files , ent . flags ) ; } else if ( ac > 2 ) { av ++ ; addto_list ( av , & ent ) ; mergesort_files ( & ent . file_list ) ; mergesort_files ( & ent . none_ex ) ; mergesort_dirs ( & ent . dirs ) ; print_error_none_ex ( ent . none_ex ) ; printfileslist ( ent . file_list , ent . flags ) ; if ( ent . dirs != NULL ) { if ( ent . file_list != NULL ) ft_putchar ( '\\n' ) ; if ( ent . dirs -> next == NULL ) { <S2SV_StartBug> opendir_getnames ( & ent . dirs -> files , * av , ent . flags ) ; <S2SV_EndBug> mergesort_files ( & ent . dirs -> files ) ; printfileslist ( ent . dirs -> files , ent . flags ) ; } else print_all_dirs ( ent . dirs , ent . flags ) ; } } } else { addto_list ( av , & ent ) ; mergesort_dirs ( & ent . dirs ) ; mergesort_files ( & ent . file_list ) ; mergesort_files ( & ent . none_ex ) ; print_error_none_ex ( ent . none_ex ) ; printfileslist ( ent . file_list , ent . flags ) ; if ( ent . dirs != NULL ) { if ( ent . file_list != NULL ) ft_putchar ( '\\n' ) ; if ( ac == 2 ) { opendir_getnames ( & ent . dirs -> files , * av , ent . flags ) ; mergesort_files ( & ent . dirs -> files ) ; printfileslist ( ent . dirs -> files , ent . flags ) ; } else print_all_dirs ( ent . dirs , ent . flags ) ; } } return ( 0 ) ; }
|
<S2SV_ModStart> NULL ) { if ( ent . flags & LONG_FORMAT ) ft_printf ( "total<S2SV_blank>%i\\n" , gettotalblocks ( ent . dirs -> files ) ) ;
|
7,888 |
CWE-000 static void eglib_log_adapter ( const gchar * log_domain , GLogLevelFlags log_level , const gchar * message , gpointer user_data ) { <S2SV_StartBug> UserSuppliedLoggerUserData * ll = logCallback . user_data ; <S2SV_EndBug> ll -> legacy_callback ( log_domain , log_level_get_name ( log_level ) , message , log_level & G_LOG_LEVEL_ERROR , ll -> user_data ) ; }
|
<S2SV_ModStart> * ll = ( UserSuppliedLoggerUserData * )
|
7,889 |
CWE-000 static int tcmu_check_expired_cmd ( int id , void * p , void * data ) { struct tcmu_cmd * cmd = p ; if ( test_bit ( TCMU_CMD_BIT_EXPIRED , & cmd -> flags ) ) return 0 ; if ( ! time_after ( cmd -> deadline , jiffies ) ) return 0 ; set_bit ( TCMU_CMD_BIT_EXPIRED , & cmd -> flags ) ; target_complete_cmd ( cmd -> se_cmd , SAM_STAT_CHECK_CONDITION ) ; cmd -> se_cmd = NULL ; <S2SV_StartBug> kmem_cache_free ( tcmu_cmd_cache , cmd ) ; <S2SV_EndBug> return 0 ; }
|
<S2SV_ModStart> = NULL ; <S2SV_ModEnd> return 0 ;
|
7,890 |
CWE-000 static tFirmwareRet parseLine ( tFirmwareStoreHandle pFwStore_p , char * pLine_p , tFirmwareInfo * pInfo_p ) { tFirmwareRet ret = kFwReturnOk ; tFirmwareInfo info ; int result ; tFirmwareStoreConfig storeConfig ; char imagePath [ FIRMWAREINFO_FW_IMAGE_PATH_LENGTH ] ; char completePath [ FIRMWAREINFO_FW_IMAGE_PATH_LENGTH ] ; void * baseInfo ; memset ( imagePath , 0 , FIRMWAREINFO_FW_IMAGE_PATH_LENGTH ) ; result = sscanf ( pLine_p , FIRMWAREINFO_LINE_FORMAT , ( unsigned int * ) & info . moduleInfo . nodeId , & info . moduleInfo . vendorId , & info . moduleInfo . productId , & info . moduleInfo . hwVariant , & info . appSwDate , & info . appSwTime , ( unsigned int * ) & info . fFirmwareLocked , imagePath ) ; if ( result != FIRMWAREINFO_NUMBER_OF_VALUES_PER_LINE ) { <S2SV_StartBug> goto EXIT ; <S2SV_EndBug> } memset ( & storeConfig , 0 , sizeof ( tFirmwareStoreConfig ) ) ; ret = firmwarestore_getBase ( pFwStore_p , & baseInfo ) ; if ( ret != kFwReturnOk ) { goto EXIT ; } sprintf ( completePath , "%s%c%s" , ( char * ) baseInfo , FIRMWARESTORE_PATH_DIR_SEP , imagePath ) ; storeConfig . pFilename = completePath ; ret = firmwarestore_create ( & storeConfig , & info . pFwImage ) ; if ( ret != kFwReturnOk ) { goto EXIT ; } memcpy ( pInfo_p , & info , sizeof ( tFirmwareInfo ) ) ; EXIT : return ret ; }
|
<S2SV_ModStart> FIRMWAREINFO_NUMBER_OF_VALUES_PER_LINE ) { ret = kFwReturnIgnoreInfoFileLine ;
|
7,891 |
CWE-000 int libswd_bus_write_data_p ( libswd_ctx_t * libswdctx , libswd_operation_t operation , int * data , char * parity ) { if ( libswdctx == NULL ) return LIBSWD_ERROR_NULLCONTEXT ; if ( data == NULL || parity == NULL ) return LIBSWD_ERROR_NULLPOINTER ; if ( operation != LIBSWD_OPERATION_ENQUEUE && operation != LIBSWD_OPERATION_EXECUTE ) return LIBSWD_ERROR_BADOPCODE ; int res , qcmdcnt = 0 , tcmdcnt = 0 ; res = libswd_bus_setdir_mosi ( libswdctx ) ; if ( res < 0 ) return res ; <S2SV_StartBug> qcmdcnt = + res ; <S2SV_EndBug> res = libswd_cmd_enqueue_mosi_data_p ( libswdctx , data , parity ) ; if ( res < 0 ) return res ; <S2SV_StartBug> qcmdcnt = + res ; <S2SV_EndBug> if ( operation == LIBSWD_OPERATION_ENQUEUE ) { return qcmdcnt ; } else if ( operation == LIBSWD_OPERATION_EXECUTE ) { res = libswd_cmdq_flush ( libswdctx , & libswdctx -> cmdq , operation ) ; if ( res < 0 ) return res ; <S2SV_StartBug> tcmdcnt = + res ; <S2SV_EndBug> return qcmdcnt + tcmdcnt ; } else return LIBSWD_ERROR_BADOPCODE ; }
|
<S2SV_ModStart> res ; qcmdcnt += <S2SV_ModEnd> res ; res <S2SV_ModStart> res ; qcmdcnt += <S2SV_ModEnd> res ; if <S2SV_ModStart> res ; tcmdcnt += <S2SV_ModEnd> res ; return
|
7,892 |
CWE-000 State * sm_add_terminal_state ( StateMachine * sm , char * state_name ) { State * state = sm_add_state ( sm , state_name ) ; if ( state != NULL ) { <S2SV_StartBug> sm -> is_terminal = 1 ; <S2SV_EndBug> } return state ; }
|
<S2SV_ModStart> NULL ) { state <S2SV_ModEnd> -> is_terminal =
|
7,893 |
CWE-000 void print_ops ( t_op * op ) { t_op * curr ; curr = op ; while ( curr ) { <S2SV_StartBug> ft_printf ( "Size:<S2SV_blank>%u\\nInfo:<S2SV_blank>%s<S2SV_blank>(%#x)\\nParams:\\n\\n\\tLabel[1]:<S2SV_blank>%s\\n\\tType[1]:<S2SV_blank>%u\\n\\tSize[1]:<S2SV_blank>%u\\n\\tValue[1]:<S2SV_blank>%u\\n\\n\\tLabel[2]:<S2SV_blank>%s\\n\\tType[2]:<S2SV_blank>%u\\n\\tSize[2]:<S2SV_blank>%u\\n\\tValue[2]:<S2SV_blank>%u\\n\\n\\tLabel[3]:<S2SV_blank>%s\\n\\tType[3]:<S2SV_blank>%u\\n\\tSize[3]:<S2SV_blank>%u\\n\\tValue[3]:<S2SV_blank>%u\\n\\n" , curr -> size , curr -> info . name , curr -> info . opcode , curr -> params [ 0 ] . label , curr -> params [ 0 ] . type , curr -> params [ 0 ] . size , curr -> params [ 0 ] . value , curr -> params [ 1 ] . label , curr -> params [ 1 ] . type , curr -> params [ 1 ] . size , curr -> params [ 1 ] . value , curr -> params [ 2 ] . label , curr -> params [ 2 ] . type , curr -> params [ 2 ] . size , curr -> params [ 2 ] . value ) ; <S2SV_EndBug> curr = curr -> next ; } }
|
<S2SV_ModStart> { ft_printf ( "Size:<S2SV_blank>%u\\nLine:<S2SV_blank>%u\\nInfo:<S2SV_blank>%s<S2SV_blank>(%#x)\\nParams:\\n\\n\\tLabel[1]:<S2SV_blank>%s\\n\\tType[1]:<S2SV_blank>%u\\n\\tSize[1]:<S2SV_blank>%u\\n\\tValue[1]:<S2SV_blank>%u\\n\\n\\tLabel[2]:<S2SV_blank>%s\\n\\tType[2]:<S2SV_blank>%u\\n\\tSize[2]:<S2SV_blank>%u\\n\\tValue[2]:<S2SV_blank>%u\\n\\n\\tLabel[3]:<S2SV_blank>%s\\n\\tType[3]:<S2SV_blank>%u\\n\\tSize[3]:<S2SV_blank>%u\\n\\tValue[3]:<S2SV_blank>%u\\n\\n" <S2SV_ModEnd> , curr -> <S2SV_ModStart> curr -> size , curr -> line
|
7,894 |
CWE-000 int M ( int a , int i ) { <S2SV_StartBug> int off ; <S2SV_EndBug> <S2SV_StartBug> off = i == 0 ? 0 : mval ( ri [ i ] , 3 , MASK2 ) ; <S2SV_EndBug> return a + off ; }
|
<S2SV_ModStart> { int off , r ; r = ri [ i ] & ~ ( MASK3 << 2 * BITS ) <S2SV_ModStart> : mval ( r , 0 <S2SV_ModEnd> , MASK2 )
|
7,895 |
CWE-000 static size_t mdb_xfer_bound_data ( MdbHandle * mdb , int start , MdbColumn * col , int len ) { int ret ; if ( len ) { col -> cur_value_start = start ; col -> cur_value_len = len ; } else { col -> cur_value_start = 0 ; col -> cur_value_len = 0 ; } if ( col -> bind_ptr ) { if ( ! len ) { strcpy ( col -> bind_ptr , "" ) ; } else { char * str ; if ( col -> col_type == MDB_NUMERIC ) { str = mdb_numeric_to_string ( mdb , start , col -> col_prec , col -> col_scale ) ; } else { <S2SV_StartBug> str = mdb_col_to_string ( mdb , mdb -> pg_buf , start , col -> col_type , len ) ; <S2SV_EndBug> } strcpy ( col -> bind_ptr , str ) ; g_free ( str ) ; } ret = strlen ( col -> bind_ptr ) ; if ( col -> len_ptr ) { * col -> len_ptr = ret ; } return ret ; } return 0 ; }
|
<S2SV_ModStart> ( mdb , ( char * )
|
7,896 |
CWE-000 void nextPivot ( int * master , int * row , int * col , int myrank , int order , int np , MPI_Comm * comm ) { <S2SV_StartBug> int i ; <S2SV_EndBug> }
|
<S2SV_ModStart> comm ) { MPI_Comm newCom ; if ( order / np == 1 || ( * row ) != 0 && ( * row ) % order / np == 0 ) { int color = 0 ; if ( myrank == * master ) { color = MPI_UNDEFINED ; } * master = * master + 1 ; * row = * col = 0 ; int nRank ; } else { ( * row ) ++ ; ( * col ) ++ ; } } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null>
|
7,897 |
CWE-000 static bool trans_SRLI ( DisasContext * ctx , arg_SRLI * a , uint32_t insn ) { LOAD_ARGSI if ( a -> shamt > TARGET_LONG_BITS ) { <S2SV_StartBug> gen_exception_illegal ( ctx ) ; <S2SV_EndBug> return false ; } tcg_gen_shri_tl ( source1 , source1 , a -> shamt ) ; RESULT_AND_FREEI return true ; }
|
<S2SV_ModStart> TARGET_LONG_BITS ) { <S2SV_ModEnd> return false ;
|
7,898 |
CWE-000 void cmd_focus_window_mode ( I3_CMD , const char * window_mode ) { DLOG ( "window_mode<S2SV_blank>=<S2SV_blank>%s\\n" , window_mode ) ; bool to_floating ; if ( strcmp ( window_mode , "mode_toggle" ) == 0 ) { to_floating = ! con_inside_floating ( focused ) ; } else if ( strcmp ( window_mode , "floating" ) == 0 ) { to_floating = true ; } else if ( strcmp ( window_mode , "tiling" ) == 0 ) { to_floating = false ; } Con * ws = con_get_workspace ( focused ) ; Con * current ; bool success = false ; TAILQ_FOREACH ( current , & ( ws -> focus_head ) , focused ) { if ( ( to_floating && current -> type != CT_FLOATING_CON ) || ( ! to_floating && current -> type == CT_FLOATING_CON ) ) continue ; <S2SV_StartBug> con_focus ( con_descend_focused ( current ) ) ; <S2SV_EndBug> success = true ; break ; } if ( success ) { cmd_output -> needs_tree_render = true ; ysuccess ( true ) ; } else { yerror ( "Failed<S2SV_blank>to<S2SV_blank>find<S2SV_blank>a<S2SV_blank>%s<S2SV_blank>container<S2SV_blank>in<S2SV_blank>workspace." , to_floating ? "floating" : "tiling" ) ; } }
|
<S2SV_ModStart> ) continue ; cmd_focus_force_focus <S2SV_ModEnd> ( con_descend_focused (
|
7,899 |
CWE-000 int cetus_write_channel ( int s , cetus_channel_t * ch , size_t size ) { int err ; ssize_t n ; struct iovec iov [ 1 ] ; struct msghdr msg ; g_debug ( "%s:call<S2SV_blank>cetus_write_channel,<S2SV_blank>fd:%d" , G_STRLOC , s ) ; union { struct cmsghdr cm ; char space [ CMSG_SPACE ( sizeof ( int ) ) ] ; } cmsg ; if ( ch -> basics . fd == - 1 ) { msg . msg_control = NULL ; msg . msg_controllen = 0 ; } else { msg . msg_control = ( caddr_t ) & cmsg ; msg . msg_controllen = sizeof ( cmsg ) ; memset ( & cmsg , 0 , sizeof ( cmsg ) ) ; cmsg . cm . cmsg_len = CMSG_LEN ( sizeof ( int ) ) ; cmsg . cm . cmsg_level = SOL_SOCKET ; cmsg . cm . cmsg_type = SCM_RIGHTS ; <S2SV_StartBug> memcpy ( CMSG_DATA ( & cmsg . cm ) , & ch -> basics . fd , sizeof ( int ) ) ; <S2SV_EndBug> } msg . msg_flags = 0 ; iov [ 0 ] . iov_base = ( char * ) ch ; iov [ 0 ] . iov_len = size ; msg . msg_name = NULL ; msg . msg_namelen = 0 ; msg . msg_iov = iov ; msg . msg_iovlen = 1 ; iov [ 0 ] . iov_base = ( char * ) ch ; iov [ 0 ] . iov_len = size ; msg . msg_name = NULL ; msg . msg_namelen = 0 ; msg . msg_iov = iov ; msg . msg_iovlen = 1 ; n = sendmsg ( s , & msg , 0 ) ; g_debug ( "%s:<S2SV_blank>sendmsg<S2SV_blank>fd:%d,<S2SV_blank>n:%d,<S2SV_blank>size:%d" , G_STRLOC , s , ( int ) n , ( int ) size ) ; if ( n == - 1 ) { err = errno ; if ( err == EAGAIN ) { return NETWORK_SOCKET_WAIT_FOR_EVENT ; } g_critical ( "%s:sendmsg()<S2SV_blank>failed,<S2SV_blank>err:%s" , G_STRLOC , strerror ( errno ) ) ; return NETWORK_SOCKET_ERROR ; } return NETWORK_SOCKET_SUCCESS ; }
|
<S2SV_ModStart> = SCM_RIGHTS ; <S2SV_ModEnd> } msg .
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.