Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
2,500 | CWE-000 <S2SV_StartBug> uint8_t vGetPinStatus ( uint8_t Port , int Pin ) { <S2SV_EndBug> return PinLibrary [ Port ] [ Pin ] ; } | <S2SV_ModStart> Pin ) { nInitializePinLibrary ( ) ; |
2,501 | CWE-000 int main ( int argc , char * argv [ ] ) { print_program_name ( ) ; print_license_header ( ) ; struct Args args = args_parser ( argc , argv ) ; print_problem_description ( args ) ; FILE * file ; char file_fitness [ ] = "DataVisualization/Fitness.csv" ; if ( args . write_fitness ) { file = fopen ( file_fitness , "w" ) ; if ( file == NULL ) { printf ( "Error<S2SV_blank>opening<S2SV_blank>file!\\n" ) ; exit ( 1 ) ; } } int id = 1 ; Individual * best , * population , * nextpopulation ; <S2SV_StartBug> Individual parent1 , parent2 , child , survivor ; <S2SV_EndBug> GAResults results ; Individual * P = ( Individual * ) malloc ( sizeof ( Individual ) * args . n_population ) ; Individual * Q = ( Individual * ) malloc ( sizeof ( Individual ) * args . n_population ) ; RouletteCompartments * genetic_roulette = malloc_roulette ( args . n_population ) ; population = P ; nextpopulation = Q ; best = & population [ 0 ] ; initiate ( population , id , args . n_population , args . n_queens ) ; id = args . n_population ; evaluate ( population , args . n_population , args . n_queens ) ; if ( args . write_fitness ) write_fitness ( & file , file_fitness , population , args . n_population , 1 ) ; int n_deaths = ( int ) ( args . n_population * args . death_ratio ) ; print_GA_input ( ) ; print_GA_constants ( args ) ; print_configuration ( args ) ; results = genetic_algorithm ( args . strategy , population , nextpopulation , best , genetic_roulette , parent1 , parent2 , child , survivor , id , n_deaths , args , file , file_fitness ) ; print_GA_completed ( ) ; print_results ( results , args . n_queens ) ; <S2SV_StartBug> int i ; <S2SV_EndBug> for ( i = 0 ; i < args . n_population ; i ++ ) free ( P [ i ] . genes . rows ) ; free ( P ) ; free ( Q ) ; free ( genetic_roulette ) ; } | <S2SV_ModStart> nextpopulation ; Individual * parent1 , * parent2 , * survivor , child <S2SV_ModEnd> ; GAResults results <S2SV_ModStart> n_queens ) ; <S2SV_ModEnd> free ( P |
2,502 | CWE-000 mat4 rotation_matrix ( float x , float y , float z ) { mat4 x_mat = new_mat4 ( ( float [ ] ) { 1.0f , 0.0f , 0.0f , 0.0f , 0.0f , cos ( x ) , - sin ( x ) , 0.0f , 0.0f , sin ( x ) , cos ( x ) , 0.0f , 0.0f , 0.0f , 0.0f , 1.0f } ) ; mat4 y_mat = new_mat4 ( ( float [ ] ) { cos ( y ) , 0.0f , sin ( y ) , 0.0f , 0.0f , 1.0f , 0.0f , 0.0f , <S2SV_StartBug> - sin ( y ) , 0.0f , cos ( x ) , 0.0f , <S2SV_EndBug> 0.0f , 0.0f , 0.0f , 1.0f } ) ; mat4 z_mat = new_mat4 ( ( float [ ] ) { cos ( z ) , - sin ( z ) , 0.0f , 0.0f , sin ( z ) , cos ( z ) , 0.0f , 0.0f , 0.0f , 0.0f , 1.0f , 0.0f , 0.0f , 0.0f , 0.0f , 1.0f } ) ; return mat4_mult ( x_mat , mat4_mult ( y_mat , z_mat ) ) ; } | <S2SV_ModStart> , cos ( y <S2SV_ModEnd> ) , 0.0f |
2,503 | CWE-000 DynaStatus dmap_remove ( DynaMap map , void * key ) { dmap * m = ( dmap * ) map ; DynaStatus status ; size_t idx = dmap_index ( m , key ) ; if ( idx != DMAP_INVALID_IDX ) { size_t ksize = m -> ksize ; size_t esize = m -> esize ; uint8_t * kptr = m -> keys + idx * ksize ; uint8_t * vptr = m -> map + idx * esize ; if ( m -> key_dtor ) { m -> key_dtor ( kptr ) ; } if ( m -> val_dtor ) { m -> val_dtor ( vptr ) ; } size_t start = idx + 1 ; while ( m -> info [ start ] > DMAP_TAKEN_BIT ) { ++ start ; } <S2SV_StartBug> size_t len = start - idx ; <S2SV_EndBug> <S2SV_StartBug> uint8_t * infoptr = m -> info + idx ; <S2SV_EndBug> size_t klen = len * ksize ; size_t vlen = len * esize ; memmove ( kptr , kptr + ksize , klen ) ; memmove ( vptr , vptr + esize , vlen ) ; <S2SV_StartBug> memmove ( infoptr , infoptr + 1 , len ) ; <S2SV_EndBug> memset ( kptr + klen , 0 , ksize ) ; <S2SV_StartBug> memset ( vptr + vlen , 0 , esize ) ; <S2SV_EndBug> m -> info [ start ] = 0 ; -- ( m -> size ) ; status = DYNA_SUCCESS ; } else { status = DYNA_INVALID_KEY ; } return status ; } | <S2SV_ModStart> start ; } -- start ; <S2SV_ModStart> - idx ; if ( len > 0 ) { <S2SV_ModStart> vlen ) ; for ( size_t i = 0 ; i < len ; ++ i ) { infoptr [ i ] = infoptr [ i + 1 ] - 1 ; } <S2SV_ModEnd> memset ( kptr <S2SV_ModStart> esize ) ; } |
2,504 | CWE-000 void myroutine ( struct _myroutine_returns * _returns ) { struct _other_routine_returns _other_routine_get_returns ; _mi32 x = 0 ; _mi32 y = 0 ; _mi32 z = 0 ; <S2SV_StartBug> _mi32 V0 ; <S2SV_EndBug> _mi32 V1 ; _mi32 V2 ; other_routine ( & _other_routine_get_returns , 1 , 2 , x , y ) ; z = _other_routine_get_returns . _returns_0 ; <S2SV_StartBug> V0 = 1 + x ; <S2SV_EndBug> <S2SV_StartBug> V1 = y + V0 ; <S2SV_EndBug> <S2SV_StartBug> x = V1 ; <S2SV_EndBug> V2 = x > y ; <S2SV_StartBug> if ( V2 ) { ; <S2SV_EndBug> } else { ; } ; _returns -> _returns_0 = 1 ; _returns -> _returns_1 = 2 ; return ; } | <S2SV_ModStart> 0 ; _mi32 z2 = 0 ; _mi32 z3 = 0 ; _mi32 z4 = 0 ; _mi32 _V0 ; _mi32 _V1 ; _mi32 _V2 <S2SV_ModEnd> ; other_routine ( <S2SV_ModStart> . _returns_0 ; z2 = _other_routine_get_returns . _returns_1 ; z3 = _other_routine_get_returns . _returns_2 ; z4 = _other_routine_get_returns . _returns_3 ; _V0 <S2SV_ModEnd> = 1 + <S2SV_ModStart> + x ; _V1 <S2SV_ModEnd> = y + <S2SV_ModStart> = y + _V0 <S2SV_ModEnd> ; x = <S2SV_ModStart> ; x = _V1 ; _V2 <S2SV_ModEnd> = x > <S2SV_ModStart> ; if ( _V2 <S2SV_ModEnd> ) { ; |
2,505 | CWE-000 static int ncm_bind ( struct usb_configuration * c , struct usb_function * f ) { struct usb_composite_dev * cdev = c -> cdev ; struct f_ncm * ncm = func_to_ncm ( f ) ; <S2SV_StartBug> struct usb_string * us ; <S2SV_EndBug> int status ; struct usb_ep * ep ; struct f_ncm_opts * ncm_opts ; if ( ! can_support_ecm ( cdev -> gadget ) ) return - EINVAL ; ncm_opts = container_of ( f -> fi , struct f_ncm_opts , func_inst ) ; if ( ! ncm_opts -> bound ) { mutex_lock ( & ncm_opts -> lock ) ; ncm_opts -> net = gether_setup_name_default ( "ncm" ) ; if ( IS_ERR ( ncm_opts -> net ) ) { status = PTR_ERR ( ncm_opts -> net ) ; mutex_unlock ( & ncm_opts -> lock ) ; ERROR ( cdev , "%s:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>setup<S2SV_blank>ethernet\\n" , f -> name ) ; return status ; } ncm -> port . ioport = netdev_priv ( ncm_opts -> net ) ; gether_set_gadget ( ncm_opts -> net , cdev -> gadget ) ; status = gether_register_netdev ( ncm_opts -> net ) ; mutex_unlock ( & ncm_opts -> lock ) ; if ( status ) { free_netdev ( ncm_opts -> net ) ; return status ; } ncm_opts -> bound = true ; } status = gether_get_host_addr_cdc ( ncm_opts -> net , ncm -> ethaddr , sizeof ( ncm -> ethaddr ) ) ; if ( status < 12 ) { status = PTR_ERR ( us ) ; goto netdev_cleanup ; } us = usb_gstrings_attach ( cdev , ncm_strings , ARRAY_SIZE ( ncm_string_defs ) ) ; if ( IS_ERR ( us ) ) return PTR_ERR ( us ) ; ncm_control_intf . iInterface = us [ STRING_CTRL_IDX ] . id ; ncm_data_nop_intf . iInterface = us [ STRING_DATA_IDX ] . id ; ncm_data_intf . iInterface = us [ STRING_DATA_IDX ] . id ; ecm_desc . iMACAddress = us [ STRING_MAC_IDX ] . id ; ncm_iad_desc . iFunction = us [ STRING_IAD_IDX ] . id ; status = usb_interface_id ( c , f ) ; if ( status < 0 ) goto fail ; ncm -> ctrl_id = status ; ncm_iad_desc . bFirstInterface = status ; ncm_control_intf . bInterfaceNumber = status ; ncm_union_desc . bMasterInterface0 = status ; status = usb_interface_id ( c , f ) ; if ( status < 0 ) goto fail ; ncm -> data_id = status ; ncm_data_nop_intf . bInterfaceNumber = status ; ncm_data_intf . bInterfaceNumber = status ; ncm_union_desc . bSlaveInterface0 = status ; status = - ENODEV ; ep = usb_ep_autoconfig ( cdev -> gadget , & fs_ncm_in_desc ) ; if ( ! ep ) goto fail ; ncm -> port . in_ep = ep ; ep -> driver_data = cdev ; ep = usb_ep_autoconfig ( cdev -> gadget , & fs_ncm_out_desc ) ; if ( ! ep ) goto fail ; ncm -> port . out_ep = ep ; ep -> driver_data = cdev ; status = gether_alloc_request ( & ncm -> port ) ; printk ( "usb:<S2SV_blank>%s<S2SV_blank>:<S2SV_blank>ncm<S2SV_blank>queue<S2SV_blank>reqsest<S2SV_blank>ret<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>\\n" , __func__ , status ) ; if ( status < 0 ) goto fail ; ep = usb_ep_autoconfig ( cdev -> gadget , & fs_ncm_notify_desc ) ; if ( ! ep ) goto fail ; ncm -> notify = ep ; ep -> driver_data = cdev ; status = - ENOMEM ; ncm -> notify_req = usb_ep_alloc_request ( ep , GFP_KERNEL ) ; if ( ! ncm -> notify_req ) goto fail ; ncm -> notify_req -> buf = kmalloc ( NCM_STATUS_BYTECOUNT , GFP_KERNEL ) ; if ( ! ncm -> notify_req -> buf ) goto fail ; ncm -> notify_req -> context = ncm ; ncm -> notify_req -> complete = ncm_notify_complete ; hs_ncm_in_desc . bEndpointAddress = fs_ncm_in_desc . bEndpointAddress ; hs_ncm_out_desc . bEndpointAddress = fs_ncm_out_desc . bEndpointAddress ; hs_ncm_notify_desc . bEndpointAddress = fs_ncm_notify_desc . bEndpointAddress ; status = usb_assign_descriptors ( f , ncm_fs_function , ncm_hs_function , NULL , NULL ) ; ncm -> port . open = ncm_open ; ncm -> port . close = ncm_close ; DBG ( cdev , "CDC<S2SV_blank>Network:<S2SV_blank>%s<S2SV_blank>speed<S2SV_blank>IN/%s<S2SV_blank>OUT/%s<S2SV_blank>NOTIFY/%s\\n" , gadget_is_dualspeed ( c -> cdev -> gadget ) ? "dual" : "full" , ncm -> port . in_ep -> name , ncm -> port . out_ep -> name , ncm -> notify -> name ) ; return 0 ; fail : usb_free_all_descriptors ( f ) ; if ( ncm -> notify_req ) { kfree ( ncm -> notify_req -> buf ) ; usb_ep_free_request ( ncm -> notify , ncm -> notify_req ) ; } if ( ncm -> notify ) ncm -> notify -> driver_data = NULL ; if ( ncm -> port . out_ep ) ncm -> port . out_ep -> driver_data = NULL ; if ( ncm -> port . in_ep ) ncm -> port . in_ep -> driver_data = NULL ; netdev_cleanup : ncm_opts -> bound = false ; gether_cleanup ( netdev_priv ( ncm_opts -> net ) ) ; ERROR ( cdev , "%s:<S2SV_blank>can\'t<S2SV_blank>bind,<S2SV_blank>err<S2SV_blank>%d\\n" , f -> name , status ) ; return status ; } | <S2SV_ModStart> usb_string * us = NULL |
2,506 | CWE-000 char * parse_path ( char * path , char * cwdPath ) { char * absPathname , * parsedPathname ; absPathname = __get_abspath ( path , cwdPath ) ; if ( absPathname != NULL ) { if ( ( strlen ( absPathname ) == 1 ) && ( absPathname [ 0 ] == '/' ) ) { <S2SV_StartBug> return absPathname ; <S2SV_EndBug> } parsedPathname = __get_simplified_path ( absPathname ) ; free ( absPathname ) ; return parsedPathname ; } return NULL ; } | <S2SV_ModStart> ) ) { free ( absPathname ) ; return "/" <S2SV_ModEnd> ; } parsedPathname |
2,507 | CWE-000 ws2811_return_t ws2811_init ( ws2811_t * ws2811 ) { ws2811_device_t * device ; const rpi_hw_t * rpi_hw ; int chan ; ws2811 -> rpi_hw = rpi_hw_detect ( ) ; if ( ! ws2811 -> rpi_hw ) { return WS2811_ERROR_HW_NOT_SUPPORTED ; } rpi_hw = ws2811 -> rpi_hw ; ws2811 -> device = malloc ( sizeof ( * ws2811 -> device ) ) ; if ( ! ws2811 -> device ) { return WS2811_ERROR_OUT_OF_MEMORY ; } device = ws2811 -> device ; if ( check_hwver_and_gpionum ( ws2811 ) < 0 ) { return WS2811_ERROR_ILLEGAL_GPIO ; } device -> max_count = max_channel_led_count ( ws2811 ) ; if ( device -> driver_mode == SPI ) { return spi_init ( ws2811 ) ; } switch ( device -> driver_mode ) { case PWM : device -> mbox . size = PWM_BYTE_COUNT ( device -> max_count , ws2811 -> freq ) + sizeof ( dma_cb_t ) ; break ; case PCM : device -> mbox . size = PCM_BYTE_COUNT ( device -> max_count , ws2811 -> freq ) + sizeof ( dma_cb_t ) ; break ; } device -> mbox . size = ( device -> mbox . size + ( PAGE_SIZE - 1 ) ) & ~ ( PAGE_SIZE - 1 ) ; device -> mbox . handle = mbox_open ( ) ; if ( device -> mbox . handle == - 1 ) { return WS2811_ERROR_MAILBOX_DEVICE ; } device -> mbox . mem_ref = mem_alloc ( device -> mbox . handle , device -> mbox . size , PAGE_SIZE , rpi_hw -> videocore_base == 0x40000000 ? 0xC : 0x4 ) ; if ( device -> mbox . mem_ref == 0 ) { return WS2811_ERROR_OUT_OF_MEMORY ; } device -> mbox . bus_addr = mem_lock ( device -> mbox . handle , device -> mbox . mem_ref ) ; if ( device -> mbox . bus_addr == ( uint32_t ) ~ 0UL ) { mem_free ( device -> mbox . handle , device -> mbox . size ) ; return WS2811_ERROR_MEM_LOCK ; } device -> mbox . virt_addr = mapmem ( BUS_TO_PHYS ( device -> mbox . bus_addr ) , device -> mbox . size ) ; if ( ! device -> mbox . virt_addr ) { mem_unlock ( device -> mbox . handle , device -> mbox . mem_ref ) ; mem_free ( device -> mbox . handle , device -> mbox . size ) ; ws2811_cleanup ( ws2811 ) ; return WS2811_ERROR_MMAP ; } device -> pxl_raw = NULL ; device -> dma_cb = NULL ; for ( chan = 0 ; chan < RPI_PWM_CHANNELS ; chan ++ ) { ws2811 -> channel [ chan ] . leds = NULL ; } for ( chan = 0 ; chan < RPI_PWM_CHANNELS ; chan ++ ) { ws2811_channel_t * channel = & ws2811 -> channel [ chan ] ; channel -> leds = malloc ( sizeof ( ws2811_led_t ) * channel -> count ) ; if ( ! channel -> leds ) { ws2811_cleanup ( ws2811 ) ; return WS2811_ERROR_OUT_OF_MEMORY ; } memset ( channel -> leds , 0 , sizeof ( ws2811_led_t ) * channel -> count ) ; if ( ! channel -> strip_type ) { channel -> strip_type = WS2811_STRIP_RGB ; } <S2SV_StartBug> channel -> wshift = ( channel -> strip_type >> 24 ) & 0xff ; <S2SV_EndBug> channel -> rshift = ( channel -> strip_type >> 16 ) & 0xff ; channel -> gshift = ( channel -> strip_type >> 8 ) & 0xff ; channel -> bshift = ( channel -> strip_type >> 0 ) & 0xff ; } device -> dma_cb = ( dma_cb_t * ) device -> mbox . virt_addr ; device -> pxl_raw = ( uint8_t * ) device -> mbox . virt_addr + sizeof ( dma_cb_t ) ; switch ( device -> driver_mode ) { case PWM : pwm_raw_init ( ws2811 ) ; break ; case PCM : pcm_raw_init ( ws2811 ) ; break ; } memset ( ( dma_cb_t * ) device -> dma_cb , 0 , sizeof ( dma_cb_t ) ) ; device -> dma_cb_addr = addr_to_bus ( device , device -> dma_cb ) ; if ( map_registers ( ws2811 ) ) { ws2811_cleanup ( ws2811 ) ; return WS2811_ERROR_MAP_REGISTERS ; } if ( gpio_init ( ws2811 ) ) { unmap_registers ( ws2811 ) ; ws2811_cleanup ( ws2811 ) ; return WS2811_ERROR_GPIO_INIT ; } switch ( device -> driver_mode ) { case PWM : if ( setup_pwm ( ws2811 ) ) { unmap_registers ( ws2811 ) ; ws2811_cleanup ( ws2811 ) ; return WS2811_ERROR_PWM_SETUP ; } break ; case PCM : if ( setup_pcm ( ws2811 ) ) { unmap_registers ( ws2811 ) ; ws2811_cleanup ( ws2811 ) ; return WS2811_ERROR_PCM_SETUP ; } break ; } return WS2811_SUCCESS ; } | <S2SV_ModStart> } channel -> gamma = malloc ( sizeof ( uint8_t ) * 256 ) ; int x ; for ( x = 0 ; x < 256 ; x ++ ) { channel -> gamma [ x ] = x ; } channel -> |
2,508 | CWE-000 int vmbus_device_register ( struct hv_device * child_device_obj ) { int ret = 0 ; dev_set_name ( & child_device_obj -> device , "%pUl" , child_device_obj -> channel -> offermsg . offer . if_instance . b ) ; child_device_obj -> device . bus = & hv_bus ; child_device_obj -> device . parent = & hv_acpi_dev -> dev ; child_device_obj -> device . release = vmbus_device_release ; <S2SV_StartBug> ret = device_register ( & child_device_obj -> device ) ; <S2SV_EndBug> if ( ret ) pr_err ( "Unable<S2SV_blank>to<S2SV_blank>register<S2SV_blank>child<S2SV_blank>device\\n" ) ; else pr_debug ( "child<S2SV_blank>device<S2SV_blank>%s<S2SV_blank>registered\\n" , dev_name ( & child_device_obj -> device ) ) ; return ret ; } | <S2SV_ModStart> = vmbus_device_release ; if ( is_hvsock_channel ( child_device_obj -> channel ) ) dev_set_uevent_suppress ( & child_device_obj -> device , 1 ) ; |
2,509 | CWE-000 static void prvSOCKETS_NonBlocking_Test ( Server_t xConn ) { BaseType_t xResult ; int32_t lNumBytes ; TickType_t xStartTime ; TickType_t xEndTime ; TickType_t xTimeout = 0 ; TickType_t xWaitTime = 1000 ; uint8_t * pucTxBuffer = ( uint8_t * ) cTxBuffer ; uint8_t * pucRxBuffer = ( uint8_t * ) cRxBuffer ; <S2SV_StartBug> size_t xMessageLength = 1200 ; <S2SV_EndBug> size_t xNumBytesReceived = 0 ; xResult = pdPASS ; tcptestPRINTF ( ( "Starting<S2SV_blank>%s<S2SV_blank>\\r\\n" , __FUNCTION__ ) ) ; tcptestPRINTF ( ( "This<S2SV_blank>tests<S2SV_blank>timeouts,<S2SV_blank>so<S2SV_blank>it<S2SV_blank>takes<S2SV_blank>a<S2SV_blank>while!<S2SV_blank>\\r\\n" ) ) ; if ( TEST_PROTECT ( ) ) { xResult = prvConnectHelperWithRetry ( & xSocket , xConn , xReceiveTimeOut , xSendTimeOut , & xSocketOpen ) ; TEST_ASSERT_EQUAL_INT32_MESSAGE ( SOCKETS_ERROR_NONE , xResult , "Failed<S2SV_blank>to<S2SV_blank>connect" ) ; xResult = SOCKETS_SetSockOpt ( xSocket , 0 , SOCKETS_SO_NONBLOCK , & xTimeout , sizeof ( TickType_t ) ) ; TEST_ASSERT_EQUAL_INT32_MESSAGE ( SOCKETS_ERROR_NONE , xResult , "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>receive<S2SV_blank>timeout" ) ; xStartTime = xTaskGetTickCount ( ) ; xResult = SOCKETS_Recv ( xSocket , & pucRxBuffer , 1 , 0 ) ; xEndTime = xTaskGetTickCount ( ) ; TEST_ASSERT_LESS_THAN_MESSAGE ( 1 , xResult , "Receive<S2SV_blank>call<S2SV_blank>failed<S2SV_blank>in<S2SV_blank>receive<S2SV_blank>timeout<S2SV_blank>test" ) ; xResult = prvCheckTimeout ( xStartTime , xEndTime , xTimeout ) ; TEST_ASSERT_EQUAL_INT32_MESSAGE ( pdPASS , xResult , "Receive<S2SV_blank>timeout<S2SV_blank>was<S2SV_blank>outside<S2SV_blank>of<S2SV_blank>acceptable<S2SV_blank>range" ) ; memset ( pucTxBuffer , tcptestTX_BUFFER_FILLER , tcptestBUFFER_SIZE ) ; prvCreateTxData ( ( char * ) pucTxBuffer , xMessageLength , 0 ) ; xResult = prvSendHelper ( xSocket , pucTxBuffer , xMessageLength ) ; TEST_ASSERT_EQUAL_INT32_MESSAGE ( pdPASS , xResult , "Data<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>send\\r\\n" ) ; memset ( pucRxBuffer , tcptestRX_BUFFER_FILLER , tcptestBUFFER_SIZE ) ; xStartTime = xTaskGetTickCount ( ) ; xEndTime = xTaskGetTickCount ( ) ; do { lNumBytes = SOCKETS_Recv ( xSocket , & pucRxBuffer [ xNumBytesReceived ] , xMessageLength - xNumBytesReceived , 0 ) ; if ( lNumBytes > 0 ) { xNumBytesReceived += lNumBytes ; } xEndTime = xTaskGetTickCount ( ) ; } while ( ( ( xEndTime - xStartTime ) < xWaitTime ) && ( xMessageLength > xNumBytesReceived ) ) ; TEST_ASSERT_EQUAL_INT32_MESSAGE ( xMessageLength , xNumBytesReceived , "Data<S2SV_blank>was<S2SV_blank>not<S2SV_blank>received<S2SV_blank>\\r\\n" ) ; xResult = prvCheckRxTxBuffers ( pucTxBuffer , pucRxBuffer , xMessageLength ) ; xResult = prvShutdownHelper ( xSocket ) ; TEST_ASSERT_EQUAL_INT32_MESSAGE ( SOCKETS_ERROR_NONE , xResult , "Socket<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>shutdown" ) ; } xResult = prvCloseHelper ( xSocket , & xSocketOpen ) ; TEST_ASSERT_EQUAL_INT32_MESSAGE ( SOCKETS_ERROR_NONE , xResult , "Socket<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>close" ) ; tcptestPRINTF ( ( "%s<S2SV_blank>passed\\r\\n" , __FUNCTION__ ) ) ; } | <S2SV_ModStart> size_t xMessageLength = 500 <S2SV_ModEnd> ; size_t xNumBytesReceived |
2,510 | CWE-000 static int nat_callforwarding ( struct sk_buff * skb , struct nf_conn * ct , enum ip_conntrack_info ctinfo , unsigned int protoff , unsigned char * * data , int dataoff , TransportAddress * taddr , __be16 port , struct nf_conntrack_expect * exp ) { int dir = CTINFO2DIR ( ctinfo ) ; u_int16_t nated_port ; exp -> saved_addr = exp -> tuple . dst . u3 ; exp -> tuple . dst . u3 . ip = ct -> tuplehash [ ! dir ] . tuple . dst . u3 . ip ; exp -> saved_proto . tcp . port = exp -> tuple . dst . u . tcp . port ; exp -> expectfn = ip_nat_callforwarding_expect ; exp -> dir = ! dir ; for ( nated_port = ntohs ( port ) ; nated_port != 0 ; nated_port ++ ) { int ret ; exp -> tuple . dst . u . tcp . port = htons ( nated_port ) ; ret = nf_ct_expect_related ( exp ) ; if ( ret == 0 ) break ; else if ( ret != - EBUSY ) { nated_port = 0 ; break ; } } if ( nated_port == 0 ) { net_notice_ratelimited ( "nf_nat_q931:<S2SV_blank>out<S2SV_blank>of<S2SV_blank>TCP<S2SV_blank>ports\\n" ) ; return 0 ; } if ( set_h225_addr ( skb , protoff , data , dataoff , taddr , & ct -> tuplehash [ ! dir ] . tuple . dst . u3 , <S2SV_StartBug> htons ( nated_port ) ) != 0 ) { <S2SV_EndBug> nf_ct_unexpect_related ( exp ) ; return - 1 ; } pr_debug ( "nf_nat_q931:<S2SV_blank>expect<S2SV_blank>Call<S2SV_blank>Forwarding<S2SV_blank>%pI4:%hu->%pI4:%hu\\n" , & exp -> tuple . src . u3 . ip , ntohs ( exp -> tuple . src . u . tcp . port ) , & exp -> tuple . dst . u3 . ip , ntohs ( exp -> tuple . dst . u . tcp . port ) ) ; return 0 ; } | <S2SV_ModStart> nated_port ) ) <S2SV_ModEnd> ) { nf_ct_unexpect_related |
2,511 | CWE-000 bool get_sa_info ( struct state * st , bool inbound , deltatime_t * ago ) { char text_said [ SATOT_BUF ] ; u_int proto ; uint64_t bytes ; uint64_t add_time ; ipsec_spi_t spi ; const ip_address * src , * dst ; struct kernel_sa sa ; struct ipsec_proto_info * p2 ; const struct connection * c = st -> st_connection ; if ( kernel_ops -> get_sa == NULL || ( ! st -> st_esp . present && ! st -> st_ah . present ) ) { return FALSE ; } if ( st -> st_esp . present ) { proto = SA_ESP ; p2 = & st -> st_esp ; } else if ( st -> st_ah . present ) { proto = SA_AH ; p2 = & st -> st_ah ; } else { return FALSE ; } if ( inbound ) { src = & c -> spd . that . host_addr ; dst = & c -> spd . this . host_addr ; spi = p2 -> our_spi ; } else { src = & c -> spd . this . host_addr ; dst = & c -> spd . that . host_addr ; spi = p2 -> attrs . spi ; } set_text_said ( text_said , dst , spi , proto ) ; zero ( & sa ) ; sa . spi = spi ; sa . proto = proto ; sa . src = src ; sa . dst = dst ; sa . text_said = text_said ; DBG ( DBG_KERNEL , <S2SV_StartBug> DBG_log ( "get<S2SV_blank>%s" , text_said ) ) ; <S2SV_EndBug> if ( ! kernel_ops -> get_sa ( & sa , & bytes , & add_time ) ) return FALSE ; p2 -> add_time = add_time ; passert ( p2 -> our_lastused . mono_secs != 0 ) ; passert ( p2 -> peer_lastused . mono_secs != 0 ) ; if ( inbound ) { if ( bytes > p2 -> our_bytes ) { p2 -> our_bytes = bytes ; p2 -> our_lastused = mononow ( ) ; } if ( ago != NULL ) * ago = monotimediff ( mononow ( ) , p2 -> our_lastused ) ; } else { if ( bytes > p2 -> peer_bytes ) { p2 -> peer_bytes = bytes ; p2 -> peer_lastused = mononow ( ) ; } if ( ago != NULL ) * ago = monotimediff ( mononow ( ) , p2 -> peer_lastused ) ; } return TRUE ; } | <S2SV_ModStart> , DBG_log ( "get_sa_info<S2SV_blank>%s" <S2SV_ModEnd> , text_said ) |
2,512 | CWE-000 static void keyboardDongleProfileChangeCB ( uint8 paramID ) { uint8 newValue ; switch ( paramID ) { case KEYBOARD_PRESS_CHAR : KeyboardDongleProfile_GetParameter ( KEYBOARD_PRESS_CHAR , & newValue ) ; if ( newValue < 128 ) { uint8 hidCode = HIDTable [ newValue ] ; uint8 modifierCode = modifierTable [ newValue ] ; if ( ( hidCode != 0 ) || ( modifierCode != 0 ) ) { if ( hidReportBufLength < ( HID_REPORT_BUFFER_LEN ) ) { hidReportBufferAppend ( USB_HID_KBD_EP , modifierCode , 0 , hidCode , 0 , 0 , 0 , 0 , 0 ) ; hidReportBufferAppend ( USB_HID_KBD_EP , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ) ; reportRetries = 0 ; osal_stop_timerEx ( hidappTaskId , HIDAPP_EVT_REPORT_RETRY ) ; osal_start_timerEx ( hidappTaskId , HIDAPP_EVT_REPORT_RETRY , 0 ) ; } } } break ; case KEYBOARD_TYPE_CHAR : { uint8 typeData [ 9 ] ; <S2SV_StartBug> KeyboardDongleProfile_GetParameter ( KEYBOARD_TYPE_CHAR , typeData ) ; <S2SV_EndBug> int stringLen = strlen ( ( const char * ) typeData ) ; if ( stringLen > 8 ) stringLen = 8 ; for ( uint8 i = 0 ; i < stringLen ; i ++ ) { newValue = typeData [ i ] ; if ( newValue < 128 ) { uint8 hidCode = HIDTable [ newValue ] ; uint8 modifierCode = modifierTable [ newValue ] ; if ( ( hidCode != 0 ) || ( modifierCode != 0 ) ) { <S2SV_StartBug> if ( hidReportBufLength < ( HID_REPORT_BUFFER_LEN - 1 ) ) { <S2SV_EndBug> <S2SV_StartBug> hidReportBufferAppend ( USB_HID_KBD_EP , modifierCode , 0 , hidCode , 0 , 0 , 0 , 0 , 0 ) ; <S2SV_EndBug> } } <S2SV_StartBug> } <S2SV_EndBug> } if ( hidReportBufLength < ( HID_REPORT_BUFFER_LEN ) ) hidReportBufferAppend ( USB_HID_KBD_EP , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ) ; reportRetries = 0 ; osal_stop_timerEx ( hidappTaskId , HIDAPP_EVT_REPORT_RETRY ) ; osal_start_timerEx ( hidappTaskId , HIDAPP_EVT_REPORT_RETRY , 0 ) ; } break ; case KEYBOARD_REPORT_CHAR : { uint8 reportData [ 8 ] ; KeyboardDongleProfile_GetParameter ( KEYBOARD_REPORT_CHAR , reportData ) ; if ( hidReportBufLength < ( HID_REPORT_BUFFER_LEN ) ) { hidReportBufferAppend ( USB_HID_KBD_EP , reportData [ 0 ] , reportData [ 1 ] , reportData [ 2 ] , reportData [ 3 ] , reportData [ 4 ] , reportData [ 5 ] , reportData [ 6 ] , reportData [ 7 ] ) ; reportRetries = 0 ; osal_stop_timerEx ( hidappTaskId , HIDAPP_EVT_REPORT_RETRY ) ; osal_start_timerEx ( hidappTaskId , HIDAPP_EVT_REPORT_RETRY , 0 ) ; } } break ; case MOUSE_MOVE_CHAR : { uint8 reportData [ MOUSE_MOVE_CHAR_LEN ] ; KeyboardDongleProfile_GetParameter ( MOUSE_MOVE_CHAR , reportData ) ; if ( hidReportBufLength < ( HID_REPORT_BUFFER_LEN ) ) { hidReportBufferAppend ( USB_HID_MOUSE_EP , reportData [ 0 ] , reportData [ 1 ] , reportData [ 2 ] , reportData [ 3 ] , 0 , 0 , 0 , 0 ) ; reportRetries = 0 ; osal_stop_timerEx ( hidappTaskId , HIDAPP_EVT_REPORT_RETRY ) ; osal_start_timerEx ( hidappTaskId , HIDAPP_EVT_REPORT_RETRY , 0 ) ; } } break ; case CONSUMER_REPORT_CHAR : { uint8 reportData [ 2 ] ; KeyboardDongleProfile_GetParameter ( CONSUMER_REPORT_CHAR , reportData ) ; if ( hidReportBufLength < ( HID_REPORT_BUFFER_LEN ) ) { hidReportBufferAppend ( USB_HID_CC_EP , reportData [ 0 ] , reportData [ 1 ] , 0 , 0 , 0 , 0 , 0 , 0 ) ; reportRetries = 0 ; osal_stop_timerEx ( hidappTaskId , HIDAPP_EVT_REPORT_RETRY ) ; osal_start_timerEx ( hidappTaskId , HIDAPP_EVT_REPORT_RETRY , 0 ) ; } } break ; default : break ; } } | <S2SV_ModStart> 9 ] ; uint8 previousTypeData = 0 ; <S2SV_ModStart> { if ( previousTypeData == newValue ) if ( <S2SV_ModStart> ( USB_HID_KBD_EP , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ) ; } if ( hidReportBufLength < ( HID_REPORT_BUFFER_LEN - 1 ) ) { hidReportBufferAppend ( USB_HID_KBD_EP , <S2SV_ModStart> } } } previousTypeData = newValue ; |
2,513 | CWE-000 static int out_create_mmap_buffer ( const struct audio_stream_out * stream , int32_t min_size_frames , struct audio_mmap_buffer_info * info ) { struct stream_out * out = ( struct stream_out * ) stream ; struct audio_device * adev = out -> dev ; int ret = 0 ; <S2SV_StartBug> unsigned int offset1 ; <S2SV_EndBug> <S2SV_StartBug> unsigned int frames1 ; <S2SV_EndBug> const char * step = "" ; uint32_t mmap_size ; ALOGV ( "%s" , __func__ ) ; pthread_mutex_lock ( & adev -> lock ) ; if ( info == NULL || min_size_frames == 0 ) { ALOGE ( "%s:<S2SV_blank>info<S2SV_blank>=<S2SV_blank>%p,<S2SV_blank>min_size_frames<S2SV_blank>=<S2SV_blank>%d" , __func__ , info , min_size_frames ) ; ret = - EINVAL ; goto exit ; } if ( out -> usecase != USECASE_AUDIO_PLAYBACK_MMAP || ! out -> standby ) { ALOGE ( "%s:<S2SV_blank>usecase<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>standby<S2SV_blank>=<S2SV_blank>%d" , __func__ , out -> usecase , out -> standby ) ; ret = - ENOSYS ; goto exit ; } out -> pcm_device_id = platform_get_pcm_device_id ( out -> usecase , PCM_PLAYBACK ) ; if ( out -> pcm_device_id < 0 ) { ALOGE ( "%s:<S2SV_blank>Invalid<S2SV_blank>PCM<S2SV_blank>device<S2SV_blank>id(%d)<S2SV_blank>for<S2SV_blank>the<S2SV_blank>usecase(%d)" , __func__ , out -> pcm_device_id , out -> usecase ) ; ret = - EINVAL ; goto exit ; } adjust_mmap_period_count ( & out -> config , min_size_frames ) ; ALOGV ( "%s:<S2SV_blank>Opening<S2SV_blank>PCM<S2SV_blank>device<S2SV_blank>card_id(%d)<S2SV_blank>device_id(%d),<S2SV_blank>channels<S2SV_blank>%d" , __func__ , adev -> snd_card , out -> pcm_device_id , out -> config . channels ) ; out -> pcm = pcm_open ( adev -> snd_card , out -> pcm_device_id , ( PCM_OUT | PCM_MMAP | PCM_NOIRQ | PCM_MONOTONIC ) , & out -> config ) ; if ( out -> pcm == NULL || ! pcm_is_ready ( out -> pcm ) ) { step = "open" ; ret = - ENODEV ; goto exit ; } ret = pcm_mmap_begin ( out -> pcm , & info -> shared_memory_address , & offset1 , & frames1 ) ; if ( ret < 0 ) { step = "begin" ; goto exit ; } info -> buffer_size_frames = pcm_get_buffer_size ( out -> pcm ) ; info -> burst_size_frames = out -> config . period_size ; ret = platform_get_mmap_data_fd ( adev -> platform , out -> pcm_device_id , 0 , & info -> shared_memory_fd , & mmap_size ) ; if ( ret < 0 ) { step = "get_mmap_fd" ; goto exit ; } memset ( info -> shared_memory_address , 0 , pcm_frames_to_bytes ( out -> pcm , info -> buffer_size_frames ) ) ; ret = pcm_mmap_commit ( out -> pcm , 0 , MMAP_PERIOD_SIZE ) ; if ( ret < 0 ) { step = "commit" ; goto exit ; } out -> standby = false ; ret = 0 ; ALOGV ( "%s:<S2SV_blank>got<S2SV_blank>mmap<S2SV_blank>buffer<S2SV_blank>address<S2SV_blank>%p<S2SV_blank>info->buffer_size_frames<S2SV_blank>%d" , __func__ , info -> shared_memory_address , info -> buffer_size_frames ) ; exit : if ( ret != 0 ) { if ( out -> pcm == NULL ) { ALOGE ( "%s:<S2SV_blank>%s<S2SV_blank>-<S2SV_blank>%d" , __func__ , step , ret ) ; } else { ALOGE ( "%s:<S2SV_blank>%s<S2SV_blank>%s" , __func__ , step , pcm_get_error ( out -> pcm ) ) ; pcm_close ( out -> pcm ) ; out -> pcm = NULL ; } } pthread_mutex_unlock ( & adev -> lock ) ; return ret ; } | <S2SV_ModStart> unsigned int offset1 = 0 <S2SV_ModStart> unsigned int frames1 = 0 |
2,514 | CWE-000 static int tw686x_start_streaming ( struct vb2_queue * vq , unsigned int count ) { struct tw686x_video_channel * vc = vb2_get_drv_priv ( vq ) ; struct tw686x_dev * dev = vc -> dev ; struct pci_dev * pci_dev ; unsigned long flags ; int pb ; spin_lock_irqsave ( & dev -> lock , flags ) ; pci_dev = dev -> pci_dev ; spin_unlock_irqrestore ( & dev -> lock , flags ) ; if ( ! pci_dev ) return - ENODEV ; <S2SV_StartBug> if ( count < 2 ) { <S2SV_EndBug> v4l2_err ( & dev -> v4l2_dev , "no<S2SV_blank>enough<S2SV_blank>buffers<S2SV_blank>queued\\n" ) ; return - ENOBUFS ; } spin_lock_irqsave ( & vc -> qlock , flags ) ; if ( ! vc -> dma_descs [ 0 ] . virt || ! vc -> dma_descs [ 1 ] . virt ) { spin_unlock_irqrestore ( & vc -> qlock , flags ) ; v4l2_err ( & dev -> v4l2_dev , "video%d:<S2SV_blank>refusing<S2SV_blank>to<S2SV_blank>start<S2SV_blank>without<S2SV_blank>DMA<S2SV_blank>buffers\\n" , vc -> num ) ; return - ENOMEM ; } for ( pb = 0 ; pb < 2 ; pb ++ ) tw686x_buffer_refill ( vc , pb ) ; spin_unlock_irqrestore ( & vc -> qlock , flags ) ; vc -> sequence = 0 ; vc -> pb = 0 ; spin_lock_irqsave ( & dev -> lock , flags ) ; tw686x_enable_channel ( dev , vc -> ch ) ; spin_unlock_irqrestore ( & dev -> lock , flags ) ; mod_timer ( & dev -> dma_delay_timer , jiffies + msecs_to_jiffies ( 100 ) ) ; return 0 ; } | <S2SV_ModStart> - ENODEV ; <S2SV_ModEnd> spin_lock_irqsave ( & |
2,515 | CWE-000 char checkVector3 ( const PVM vm , const PARRAY array ) { if ( array -> top != 3 ) { vm -> error ( vm , ERR_LEFT ERR_ARRAY ERR_ARRAY_SIZE_EXACT ( 3 ) , vm -> stack ) ; return 0 ; } for ( int i = 0 ; i < array -> top ; i ++ ) { if ( array -> data [ i ] -> type != SCALAR_TYPE ( ) ) { <S2SV_StartBug> vm -> error ( vm , ERR_CAN_ONLY_PROCESS ERR_SCALAR "<S2SV_blank>" ERR_ARRAYS , vm -> stack ) ; <S2SV_EndBug> return 0 ; } } return 1 ; } | <S2SV_ModStart> , ERR_CAN_ONLY_PROCESS ERR_SCALAR L"<S2SV_blank>" <S2SV_ModEnd> ERR_ARRAYS , vm |
2,516 | CWE-000 void pir_handler ( int32_t adc_val ) { log_printf ( "PIR<S2SV_blank>Handler\\n" ) ; <S2SV_StartBug> out_gen_stop ( ( bool * ) out_gen_end_all_on ) ; <S2SV_EndBug> <S2SV_StartBug> log_printf ( "Sensed<S2SV_blank>%d\\n" , adc_val ) ; <S2SV_EndBug> pir_disable ( ) ; <S2SV_StartBug> pir_oper_flag = true ; <S2SV_EndBug> if ( video_on_flag == true && time_remain > 0 ) { time_remain -= out_gen_get_ticks ( ) ; out_gen_config_t video_end_out_gen_config = { . num_transitions = 1 , . out_gen_done_handler = pattern_out_done_handler , . out_gen_state = VIDEO_PIR_ON , . transitions_durations = { video_ext_time } , . next_out = { { 1 , 1 } , { 1 , 1 } } , } ; out_gen_start ( & video_end_out_gen_config ) ; debug_print_bool_array ( video_end_out_gen_config . next_out , "Pir<S2SV_blank>handler" ) ; } else { data_process_pattern_gen ( PIR_DATA_PROCESS_MODE ) ; } } | <S2SV_ModStart> "PIR<S2SV_blank>Handler\\n" ) ; <S2SV_ModEnd> log_printf ( "Sensed<S2SV_blank>%d\\n" <S2SV_ModStart> adc_val ) ; { } <S2SV_ModStart> pir_oper_flag = true ; out_gen_stop ( ( bool * ) out_gen_end_all_on ) |
2,517 | CWE-000 static void bta_dm_process_remove_device ( BD_ADDR bd_addr , tBT_TRANSPORT transport ) { # if ( BLE_INCLUDED == TRUE && GATTC_INCLUDED == TRUE ) BTA_GATTC_CancelOpen ( 0 , bd_addr , FALSE ) ; # endif <S2SV_StartBug> BTM_SecDeleteDevice ( bd_addr ) ; <S2SV_EndBug> # if ( BLE_INCLUDED == TRUE && GATTC_INCLUDED == TRUE ) BTA_GATTC_Refresh ( bd_addr , false ) ; # endif if ( bta_dm_cb . p_sec_cback ) { tBTA_DM_SEC sec_event ; bdcpy ( sec_event . link_down . bd_addr , bd_addr ) ; sec_event . link_down . status = HCI_SUCCESS ; if ( transport == BT_TRANSPORT_LE ) { bta_dm_cb . p_sec_cback ( BTA_DM_BLE_DEV_UNPAIRED_EVT , & sec_event ) ; } else { bta_dm_cb . p_sec_cback ( BTA_DM_DEV_UNPAIRED_EVT , & sec_event ) ; } } } | <S2SV_ModStart> BTM_SecDeleteDevice ( bd_addr , transport |
2,518 | CWE-000 <S2SV_StartBug> int aac_send_hosttime ( struct aac_dev * dev , struct timeval * now ) <S2SV_EndBug> { int ret = - ENOMEM ; struct fib * fibptr ; __le32 * info ; fibptr = aac_fib_alloc ( dev ) ; if ( ! fibptr ) goto out ; aac_fib_init ( fibptr ) ; info = ( __le32 * ) fib_data ( fibptr ) ; * info = cpu_to_le32 ( now -> tv_sec ) ; ret = aac_fib_send ( SendHostTime , fibptr , sizeof ( * info ) , FsaNormal , 1 , 1 , NULL , NULL ) ; if ( ret >= 0 ) aac_fib_complete ( fibptr ) ; if ( ret != - ERESTARTSYS ) aac_fib_free ( fibptr ) ; out : return ret ; } | <S2SV_ModStart> dev , struct timespec64 <S2SV_ModEnd> * now ) |
2,519 | CWE-000 static int chcr_cra_init ( struct crypto_tfm * tfm ) { struct crypto_alg * alg = tfm -> __crt_alg ; struct chcr_context * ctx = crypto_tfm_ctx ( tfm ) ; struct ablk_ctx * ablkctx = ABLK_CTX ( ctx ) ; ablkctx -> sw_cipher = crypto_alloc_skcipher ( alg -> cra_name , 0 , CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK ) ; if ( IS_ERR ( ablkctx -> sw_cipher ) ) { pr_err ( "failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>fallback<S2SV_blank>for<S2SV_blank>%s\\n" , alg -> cra_name ) ; return PTR_ERR ( ablkctx -> sw_cipher ) ; } <S2SV_StartBug> tfm -> crt_ablkcipher . reqsize = sizeof ( struct chcr_blkcipher_req_ctx ) ; <S2SV_EndBug> return chcr_device_init ( crypto_tfm_ctx ( tfm ) ) ; } | <S2SV_ModStart> ) ; } if ( get_cryptoalg_subtype ( tfm ) == CRYPTO_ALG_SUB_TYPE_XTS ) { ablkctx -> aes_generic = crypto_alloc_cipher ( "aes-generic" , 0 , 0 ) ; if ( IS_ERR ( ablkctx -> aes_generic ) ) { pr_err ( "failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>aes<S2SV_blank>cipher<S2SV_blank>for<S2SV_blank>tweak\\n" ) ; return PTR_ERR ( ablkctx -> aes_generic ) ; } } else ablkctx -> aes_generic = NULL ; |
2,520 | CWE-000 struct seccomp_config * scconfig_init ( ) { struct seccomp_config * cfg = malloc ( sizeof ( struct seccomp_config ) ) ; <S2SV_StartBug> if ( cfg != NULL ) { <S2SV_EndBug> PFTL ( "malloc<S2SV_blank>memory" ) ; return NULL ; } cfg -> type = CFG_WHITELIST ; cfg -> deny_action = DENY_KILL ; cfg -> rules_count = 0 ; cfg -> rules_alloc = SC_ALLOC_BASE ; cfg -> rules = malloc ( SC_ALLOC_BASE * sizeof ( struct seccomp_rule ) ) ; if ( cfg -> rules == NULL ) { PFTL ( "malloc<S2SV_blank>memory" ) ; free ( cfg ) ; cfg = NULL ; } return cfg ; } | <S2SV_ModStart> if ( cfg == <S2SV_ModEnd> NULL ) { |
2,521 | CWE-000 genome_t * genome_load_chromosome ( genome_t * genome , char * chromosome_name ) { if ( ! genome -> chromosome ) { if ( ! ( genome -> chromosome = ( chromosome_t * ) malloc ( sizeof ( chromosome_t ) ) ) ) { fprintf ( stdout , "[ERROR]<S2SV_blank>can\'t<S2SV_blank>allocate\\n" ) ; return NULL ; } genome -> chromosome -> seq = NULL ; } if ( genome -> chromosome -> seq ) { free ( genome -> chromosome -> seq ) ; } <S2SV_StartBug> printf ( "LOADING<S2SV_blank>%s\\n" , chromosome_name ) ; <S2SV_EndBug> int index ; index = get_chrom_index ( genome -> info , chromosome_name ) ; genome -> chromosome -> index = index ; int size ; size = genome -> info -> sizes [ index ] ; genome -> chromosome -> size = size ; strcpy ( genome -> chromosome -> name , chromosome_name ) ; if ( ! ( genome -> chromosome -> seq = ( char * ) malloc ( sizeof ( char ) * ( size + 1 + 1 ) ) ) ) { fprintf ( stdout , "[ERROR]<S2SV_blank>can\'t<S2SV_blank>allocate\\n" ) ; return NULL ; } char buf [ 512 ] ; strcpy ( buf , genome -> path ) ; strcat ( buf , chromosome_name ) ; strcat ( buf , ".fa" ) ; FILE * fp ; if ( ! ( fp = fopen ( buf , "r" ) ) ) { fprintf ( stdout , "[ERROR]<S2SV_blank>can\'t<S2SV_blank>open<S2SV_blank>%s\\n" , buf ) ; return NULL ; } char c ; genome -> chromosome -> seq [ 0 ] = '>' ; int i = 1 ; fgets ( buf , 512 , fp ) ; while ( ! feof ( fp ) || i < size ) { c = fgetc ( fp ) ; if ( c != '\\n' ) { if ( islower ( c ) ) c = toupper ( c ) ; genome -> chromosome -> seq [ i ] = c ; i ++ ; } } genome -> chromosome -> seq [ i ] = '\\0' ; fclose ( fp ) ; <S2SV_StartBug> printf ( "LOADED\\n" ) ; <S2SV_EndBug> return genome ; } | <S2SV_ModStart> ) ; } <S2SV_ModEnd> int index ; <S2SV_ModStart> fp ) ; <S2SV_ModEnd> return genome ; |
2,522 | CWE-000 int main ( ) { int r ; char * t1 = "abcabc" ; size_t tl1 = strlen ( t1 ) ; char * t2 = "a" ; size_t tl2 = strlen ( t2 ) ; char * t3 = "ab" ; size_t tl3 = strlen ( t3 ) ; char * s0 = "" ; char * a = "a" ; char * b = "b" ; char * c = "c" ; char * ab = "ab" ; char * abc = "abc" ; char * aaa = "aaa" ; char * ac = "ac" ; size_t l0 = strlen ( s0 ) ; size_t l1 = strlen ( a ) ; size_t l2 = strlen ( ab ) ; size_t l3 = strlen ( aaa ) ; SolPatternStateGen * g = solPatternStateGen_new ( ) ; SolPattern * p1 = solPattern_empty_new ( g ) ; SolPattern * p2 = solPattern_literal_new ( g , a ) ; SolPattern * p3 = solPattern_literal_new ( g , b ) ; r = solPattern_match ( p1 , s0 , l0 ) ; printf ( "//\\t\'\'\\t%d\\n" , r ) ; r = solPattern_match ( p1 , t1 , tl1 ) ; printf ( "//\\t%s?\\t%d\\n" , t1 , r ) ; r = solPattern_match ( p2 , t1 , tl1 ) ; printf ( "/%s/\\t[%s]?\\t%d\\n" , a , t1 , r ) ; r = solPattern_match ( p2 , t2 , tl2 ) ; printf ( "/%s/\\t[%s]?\\t%d\\n" , a , t2 , r ) ; solPattern_concatenate ( p2 , p3 ) ; r = solPattern_match ( p2 , t1 , tl1 ) ; printf ( "/ab/\\t[%s]?\\t%d\\n" , t1 , r ) ; r = solPattern_match ( p2 , t2 , tl2 ) ; printf ( "/ab/\\t[%s]?\\t%d\\n" , t2 , r ) ; r = solPattern_match ( p2 , t3 , tl3 ) ; printf ( "/ab/\\t[%s]?\\t%d\\n" , t3 , r ) ; solPattern_free ( p2 ) ; SolPattern * p4 = solPattern_literal_new ( g , a ) ; solPattern_choose ( p4 , solPattern_literal_new ( g , b ) ) ; printf ( "/a|b/\\t[%s]?\\t%d\\n" , a , solPattern_match ( p4 , t2 , tl2 ) ) ; printf ( "/a|b/\\t[%s]?\\t%d\\n" , b , solPattern_match ( p4 , b , tl2 ) ) ; printf ( "/a|b/\\t[%s]?\\t%d\\n" , t1 , solPattern_match ( p4 , t1 , tl1 ) ) ; solPattern_free ( p4 ) ; SolPattern * p5 = solPattern_literal_new ( g , a ) ; solPattern_repeat ( p5 ) ; printf ( "/a+/\\t[%s]?\\t%d\\n" , a , solPattern_match ( p5 , t2 , tl2 ) ) ; printf ( "/a+/\\t[%s]?\\t%d\\n" , b , solPattern_match ( p5 , b , tl2 ) ) ; printf ( "/a+/\\t[%s]?\\t%d\\n" , aaa , solPattern_match ( p5 , aaa , l3 ) ) ; solPattern_choose ( p1 , p5 ) ; printf ( "/a*/\\t[%s]?\\t%d\\n" , aaa , solPattern_match ( p1 , aaa , l3 ) ) ; printf ( "/a*/\\t[%s]?\\t%d\\n" , s0 , solPattern_match ( p1 , s0 , l0 ) ) ; solPattern_free ( p1 ) ; SolPattern * p6 ; p6 = solPattern_choose ( solPattern_concatenate ( solPattern_concatenate ( solPattern_literal_new ( g , a ) , solPattern_literal_new ( g , b ) ) , solPattern_literal_new ( g , c ) ) , solPattern_concatenate ( solPattern_literal_new ( g , a ) , solPattern_literal_new ( g , c ) ) ) ; <S2SV_StartBug> _solPattern_debug_relations ( p6 ) ; <S2SV_EndBug> printf ( "/(abc)|(ac)/\\t[%s]?\\t%d\\n" , a , solPattern_match ( p6 , a , l1 ) ) ; printf ( "/(abc)|(ac)/\\t[%s]?\\t%d\\n" , ab , solPattern_match ( p6 , ab , l2 ) ) ; printf ( "/(abc)|(ac)/\\t[%s]?\\t%d\\n" , ac , solPattern_match ( p6 , ac , l2 ) ) ; printf ( "/(abc)|(ac)/\\t[%s]?\\t%d\\n" , abc , solPattern_match ( p6 , abc , l3 ) ) ; solPattern_repeat ( p6 ) ; printf ( "/((abc)|(ac))+/\\t[%s]?\\t%d\\n" , ac , solPattern_match ( p6 , ac , l2 ) ) ; printf ( "/((abc)|(ac))+/\\t[%s]?\\t%d\\n" , abc , solPattern_match ( p6 , abc , l3 ) ) ; char * abc_x3 = "abcabcabc" ; char * abc_ac = "abcac" ; char * abc_ac_r2 = "abcacacabc" ; size_t l9 = strlen ( abc_x3 ) ; size_t l5 = strlen ( abc_ac ) ; size_t l10 = strlen ( abc_ac_r2 ) ; printf ( "/((abc)|(ac))+/\\t[%s]?\\t%d\\n" , abc , solPattern_match ( p6 , abc , l3 ) ) ; printf ( "/((abc)|(ac))+/\\t[%s]?\\t%d\\n" , abc_x3 , solPattern_match ( p6 , abc_x3 , l9 ) ) ; printf ( "/((abc)|(ac))+/\\t[%s]?\\t%d\\n" , abc_ac , solPattern_match ( p6 , abc_ac , l5 ) ) ; printf ( "/((abc)|(ac))+/\\t[%s]?\\t%d\\n" , abc_ac_r2 , solPattern_match ( p6 , abc_ac_r2 , l10 ) ) ; solPattern_free ( p6 ) ; solPatternStateGen_free ( g ) ; return 0 ; } | <S2SV_ModStart> ) ) ; <S2SV_ModEnd> printf ( "/(abc)|(ac)/\\t[%s]?\\t%d\\n" |
2,523 | CWE-000 static void process_event ( struct a12_state * S , void * tag , void ( * on_event ) ( struct arcan_shmif_cont * wnd , int chid , struct arcan_event * , void * ) ) { if ( ! process_mac ( S ) ) <S2SV_StartBug> return ; <S2SV_EndBug> struct arcan_event aev ; unpack_u64 ( & S -> last_seen_seqnr , S -> decode ) ; if ( - 1 == arcan_shmif_eventunpack ( & S -> decode [ SEQUENCE_NUMBER_SIZE ] , S -> decode_pos - SEQUENCE_NUMBER_SIZE , & aev ) ) { debug_print ( 1 , "broken<S2SV_blank>event<S2SV_blank>packet<S2SV_blank>received" ) ; } <S2SV_StartBug> else if ( on_event ) <S2SV_EndBug> on_event ( NULL , 0 , & aev , tag ) ; <S2SV_StartBug> reset_state ( S ) ; <S2SV_EndBug> } | <S2SV_ModStart> ) ) return ; uint8_t channel = S -> decode [ 16 ] <S2SV_ModStart> ( on_event ) { debug_print ( 2 , "unpack<S2SV_blank>event<S2SV_blank>to<S2SV_blank>%d" , channel ) ; on_event ( S -> channels [ channel ] . cont <S2SV_ModEnd> , 0 , <S2SV_ModStart> tag ) ; } |
2,524 | CWE-000 int deleteTest ( ) { FILE * fp , * ftemp ; student s1 ; fp = fopen ( "students.dat" , "rb" ) ; ftemp = fopen ( "temp.dat" , "wb" ) ; int chosenTest = testsMenu ( ) - 1 ; if ( chosenTest == - 1 ) { return 0 ; } ; printf ( "\\nVoce<S2SV_blank>tem<S2SV_blank>certeza<S2SV_blank>que<S2SV_blank>gostaria<S2SV_blank>de<S2SV_blank>excluir<S2SV_blank>a<S2SV_blank>Prova<S2SV_blank>%d?<S2SV_blank>(S/N)\\n" , chosenTest + 1 ) ; char prompt ; while ( 1 ) { fflush ( stdin ) ; prompt = getchar ( ) ; getchar ( ) ; if ( prompt == 'S' || prompt == 's' || prompt == 'n' || prompt == 'N' ) { break ; } printf ( "\\nPor<S2SV_blank>favor<S2SV_blank>digite<S2SV_blank>\\"S\\"<S2SV_blank>ou<S2SV_blank>\\"N\\"\\n" ) ; } if ( prompt == 'N' || prompt == 'n' ) { <S2SV_StartBug> return 0 ; <S2SV_EndBug> } while ( 1 ) { fread ( & s1 , sizeof ( s1 ) , 1 , fp ) ; if ( feof ( fp ) ) { break ; } s1 . test [ chosenTest ] = - 1 ; fwrite ( & s1 , sizeof ( s1 ) , 1 , ftemp ) ; } fclose ( ftemp ) ; fclose ( fp ) ; fp = fopen ( "students.dat" , "wb" ) ; ftemp = fopen ( "temp.dat" , "rb" ) ; while ( 1 ) { fread ( & s1 , sizeof ( s1 ) , 1 , ftemp ) ; if ( feof ( ftemp ) ) { break ; } fwrite ( & s1 , sizeof ( s1 ) , 1 , fp ) ; } fclose ( ftemp ) ; fclose ( fp ) ; <S2SV_StartBug> added [ chosenTest ] = 0 ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> { return 0 ; } else { printf ( "\\nProva<S2SV_blank>excluida." ) <S2SV_ModStart> fp ) ; printf ( "\\n\\nPressione<S2SV_blank>ENTER<S2SV_blank>para<S2SV_blank>continuar<S2SV_blank>" ) ; getchar ( ) ; |
2,525 | CWE-000 int in_bounds ( pos position ) { <S2SV_StartBug> int x , y ; <S2SV_EndBug> x = position . x ; y = position . y ; <S2SV_StartBug> if ( x < 8 && x >= 0 && y < 8 && y >= 0 ) <S2SV_EndBug> return TRUE ; return FALSE ; } | <S2SV_ModStart> position ) { if ( position . <S2SV_ModEnd> x < 8 <S2SV_ModStart> < 8 && position . <S2SV_ModStart> >= 0 && position . <S2SV_ModStart> < 8 && position . |
2,526 | CWE-000 static gint save_setting ( chassis * srv , gint * effected_rows ) { gint ret = ASSIGN_OK ; GKeyFile * keyfile = g_key_file_new ( ) ; g_key_file_set_list_separator ( keyfile , ',' ) ; GString * free_path = g_string_new ( NULL ) ; if ( srv -> default_file == NULL ) { gchar * current_dir = g_get_current_dir ( ) ; free_path = g_string_append ( free_path , current_dir ) ; free_path = g_string_append ( free_path , "/default.conf" ) ; srv -> default_file = g_strdup ( free_path -> str ) ; g_free ( current_dir ) ; } if ( ! g_path_is_absolute ( srv -> default_file ) ) { gchar * current_dir = g_get_current_dir ( ) ; free_path = g_string_append ( free_path , current_dir ) ; free_path = g_string_append ( free_path , "/" ) ; free_path = g_string_append ( free_path , srv -> default_file ) ; g_free ( srv -> default_file ) ; srv -> default_file = g_strdup ( free_path -> str ) ; g_free ( current_dir ) ; } if ( free_path ) { g_string_free ( free_path , TRUE ) ; } if ( srv -> default_file ) { GString * new_file = g_string_new ( NULL ) ; new_file = g_string_append ( new_file , srv -> default_file ) ; new_file = g_string_append ( new_file , ".old" ) ; if ( remove ( new_file -> str ) ) { g_message ( "remove<S2SV_blank>operate,<S2SV_blank>filename:%s,<S2SV_blank>errno:%d" , new_file -> str == NULL ? "" : new_file -> str , errno ) ; } if ( rename ( srv -> default_file , new_file -> str ) ) { g_message ( "rename<S2SV_blank>operate<S2SV_blank>failed,<S2SV_blank>filename:%s,<S2SV_blank>filename:%s,<S2SV_blank>errno:%d" , ( srv -> default_file == NULL ? "" : srv -> default_file ) , ( new_file -> str == NULL ? "" : new_file -> str ) , errno ) ; } g_string_free ( new_file , TRUE ) ; } if ( ret == ASSIGN_OK ) { * effected_rows = chassis_options_save ( keyfile , srv -> options , srv ) ; gsize file_size = 0 ; gchar * file_buf = g_key_file_to_data ( keyfile , & file_size , NULL ) ; GError * gerr = NULL ; if ( FALSE == g_file_set_contents ( srv -> default_file , file_buf , file_size , & gerr ) ) { ret = SAVE_ERROR ; g_clear_error ( & gerr ) ; <S2SV_StartBug> } <S2SV_EndBug> } return ret ; } | <S2SV_ModStart> ) ; } else { if ( ( ret = chmod ( srv -> default_file , S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP ) ) ) { g_debug ( "remove<S2SV_blank>operate<S2SV_blank>failed,<S2SV_blank>filename:%s,<S2SV_blank>errno:%d" , ( srv -> default_file == NULL ? "" : srv -> default_file ) , errno ) ; ret = CHMOD_ERROR ; } } |
2,527 | CWE-000 void CreeperModel_DrawModel ( Entity * entity ) { Gfx_BindTexture ( IModel_GetTexture ( & CreeperModel , entity -> MobTextureId ) ) ; IModel_DrawRotate ( - entity -> HeadX * MATH_DEG2RAD , 0.0f , 0.0f , Head , true ) ; IModel_DrawPart ( Torso ) ; <S2SV_StartBug> IModel_DrawRotate ( entity -> anim . leftLegX , 0.0f , 0.0f , LeftLegFront , false ) ; <S2SV_EndBug> <S2SV_StartBug> IModel_DrawRotate ( entity -> anim . rightLegX , 0.0f , 0.0f , RightLegFront , false ) ; <S2SV_EndBug> <S2SV_StartBug> IModel_DrawRotate ( entity -> anim . rightLegX , 0.0f , 0.0f , LeftLegBack , false ) ; <S2SV_EndBug> <S2SV_StartBug> IModel_DrawRotate ( entity -> anim . leftLegX , 0.0f , 0.0f , RightLegBack , false ) ; <S2SV_EndBug> IModel_UpdateVB ( ) ; } | <S2SV_ModStart> ( entity -> Anim . LeftLegX <S2SV_ModEnd> , 0.0f , <S2SV_ModStart> ( entity -> Anim . RightLegX <S2SV_ModEnd> , 0.0f , <S2SV_ModStart> ( entity -> Anim . RightLegX <S2SV_ModEnd> , 0.0f , <S2SV_ModStart> ( entity -> Anim . LeftLegX <S2SV_ModEnd> , 0.0f , |
2,528 | CWE-000 static int get_format ( int fd , enum v4l2_buf_type buf_type ) { struct v4l2_format fmt ; int port ; int rc ; <S2SV_StartBug> int extra_idx = 0 ; <S2SV_EndBug> int extra_data_size = 0 ; memset ( & fmt , 0 , sizeof ( fmt ) ) ; fmt . type = buf_type ; rc = ioctl ( fd , VIDIOC_G_FMT , & fmt ) ; if ( rc ) { E ( "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>format\\n" ) ; return - 1 ; } port = buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE ? CAPTURE_PORT : OUTPUT_PORT ; V ( "VIDIOC_G_FMT<S2SV_blank>port<S2SV_blank>=<S2SV_blank>%d:<S2SV_blank>height<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>width<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>format<S2SV_blank>=<S2SV_blank>%x,<S2SV_blank>size<S2SV_blank>=<S2SV_blank>%d\\n" , port , fmt . fmt . pix_mp . height , fmt . fmt . pix_mp . width , fmt . fmt . pix_mp . pixelformat , fmt . fmt . pix_mp . plane_fmt [ 0 ] . sizeimage ) ; V ( "stride<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>scanlines<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>num_planes<S2SV_blank>=<S2SV_blank>%d\\n" , fmt . fmt . pix_mp . plane_fmt [ 0 ] . bytesperline , fmt . fmt . pix_mp . plane_fmt [ 0 ] . reserved [ 0 ] , fmt . fmt . pix_mp . num_planes ) ; switch ( port ) { case CAPTURE_PORT : video_inst . fmt [ CAPTURE_PORT ] . fmt . pix_mp . height = fmt . fmt . pix_mp . height ; video_inst . fmt [ CAPTURE_PORT ] . fmt . pix_mp . width = fmt . fmt . pix_mp . width ; video_inst . fmt [ CAPTURE_PORT ] . fmt . pix_mp . pixelformat = fmt . fmt . pix_mp . pixelformat ; video_inst . fmt [ CAPTURE_PORT ] . fmt . pix_mp . plane_fmt [ 0 ] . sizeimage = fmt . fmt . pix_mp . plane_fmt [ 0 ] . sizeimage ; video_inst . fmt [ CAPTURE_PORT ] . fmt . pix_mp . num_planes = fmt . fmt . pix_mp . num_planes ; video_inst . fmt [ CAPTURE_PORT ] . fmt . pix_mp . plane_fmt [ 0 ] . bytesperline = fmt . fmt . pix_mp . plane_fmt [ 0 ] . bytesperline ; video_inst . fmt [ CAPTURE_PORT ] . fmt . pix_mp . plane_fmt [ 0 ] . reserved [ 0 ] = fmt . fmt . pix_mp . plane_fmt [ 0 ] . reserved [ 0 ] ; extra_idx = EXTRADATA_IDX ( fmt . fmt . pix_mp . num_planes ) ; if ( extra_idx && ( extra_idx < VIDEO_MAX_PLANES ) ) { extra_data_size = fmt . fmt . pix_mp . plane_fmt [ extra_idx ] . sizeimage ; D ( "Required<S2SV_blank>extra<S2SV_blank>data<S2SV_blank>size<S2SV_blank>per<S2SV_blank>buffer<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>idx<S2SV_blank>=<S2SV_blank>%d\\n" , extra_data_size , extra_idx ) ; } else if ( extra_idx >= VIDEO_MAX_PLANES ) { E ( "Extradata<S2SV_blank>index<S2SV_blank>is<S2SV_blank>more<S2SV_blank>than<S2SV_blank>allowed:<S2SV_blank>%d\\n" , extra_idx ) ; return - 1 ; } video_inst . extradata_info . size = video_inst . bufreq [ CAPTURE_PORT ] . count * extra_data_size ; video_inst . extradata_info . count = video_inst . bufreq [ CAPTURE_PORT ] . count ; video_inst . extradata_info . buffer_size = extra_data_size ; D ( "Update:<S2SV_blank>VIDIOC_G_FMT:<S2SV_blank>extra<S2SV_blank>data<S2SV_blank>all<S2SV_blank>buffers<S2SV_blank>size<S2SV_blank>=<S2SV_blank>%d\\n" , video_inst . extradata_info . size ) ; break ; case OUTPUT_PORT : video_inst . fmt [ OUTPUT_PORT ] . fmt . pix_mp . height = fmt . fmt . pix_mp . height ; video_inst . fmt [ OUTPUT_PORT ] . fmt . pix_mp . width = fmt . fmt . pix_mp . width ; video_inst . fmt [ OUTPUT_PORT ] . fmt . pix_mp . pixelformat = fmt . fmt . pix_mp . pixelformat ; video_inst . fmt [ OUTPUT_PORT ] . fmt . pix_mp . plane_fmt [ 0 ] . sizeimage = fmt . fmt . pix_mp . plane_fmt [ 0 ] . sizeimage ; video_inst . fmt [ OUTPUT_PORT ] . fmt . pix_mp . num_planes = fmt . fmt . pix_mp . num_planes ; break ; default : break ; } return 0 ; } | <S2SV_ModStart> int rc ; unsigned |
2,529 | CWE-000 static void stream_fd_closed ( int fd , void * p , uintptr_t u ) { struct stream_fd * sfd = p ; struct call * c ; int i ; socklen_t j ; assert ( sfd -> socket . fd == fd ) ; c = sfd -> call ; if ( ! c ) return ; j = sizeof ( i ) ; <S2SV_StartBug> getsockopt ( fd , SOL_SOCKET , SO_ERROR , & i , & j ) ; <S2SV_EndBug> ilog ( LOG_WARNING , "Read<S2SV_blank>error<S2SV_blank>on<S2SV_blank>media<S2SV_blank>socket:<S2SV_blank>%i<S2SV_blank>(%s)<S2SV_blank>--<S2SV_blank>closing<S2SV_blank>call" , i , strerror ( i ) ) ; call_destroy ( c ) ; } | <S2SV_ModStart> i ) ; i = 0 ; |
2,530 | CWE-000 SP_API enum sp_return sp_blocking_write ( struct sp_port * port , const void * buf , size_t count , unsigned int timeout_ms ) { TRACE ( "%p,<S2SV_blank>%p,<S2SV_blank>%d,<S2SV_blank>%d" , port , buf , count , timeout_ms ) ; CHECK_OPEN_PORT ( ) ; if ( ! buf ) RETURN_ERROR ( SP_ERR_ARG , "Null<S2SV_blank>buffer" ) ; <S2SV_StartBug> if ( timeout_ms ) <S2SV_EndBug> <S2SV_StartBug> DEBUG_FMT ( "Writing<S2SV_blank>%d<S2SV_blank>bytes<S2SV_blank>to<S2SV_blank>port<S2SV_blank>%s,<S2SV_blank>timeout<S2SV_blank>%d<S2SV_blank>ms" , <S2SV_EndBug> count , port -> name , timeout_ms ) ; else <S2SV_StartBug> DEBUG_FMT ( "Writing<S2SV_blank>%d<S2SV_blank>bytes<S2SV_blank>to<S2SV_blank>port<S2SV_blank>%s,<S2SV_blank>no<S2SV_blank>timeout" , <S2SV_EndBug> <S2SV_StartBug> count , port -> name ) ; <S2SV_EndBug> if ( count == 0 ) RETURN_INT ( 0 ) ; # ifdef _WIN32 DWORD bytes_written = 0 ; if ( GetOverlappedResult ( port -> hdl , & port -> write_ovl , & bytes_written , FALSE ) == 0 ) { if ( GetLastError ( ) != ERROR_IO_INCOMPLETE ) RETURN_FAIL ( "GetOverlappedResult()<S2SV_blank>failed" ) ; else { DEBUG ( "Previous<S2SV_blank>write<S2SV_blank>incomplete" ) ; RETURN_INT ( 0 ) ; } } else DEBUG ( "Previous<S2SV_blank>write<S2SV_blank>completed" ) ; if ( port -> timeouts . WriteTotalTimeoutMultiplier != 0 || port -> timeouts . WriteTotalTimeoutConstant != timeout_ms ) { port -> timeouts . WriteTotalTimeoutMultiplier = 0 ; port -> timeouts . WriteTotalTimeoutConstant = timeout_ms ; if ( SetCommTimeouts ( port -> hdl , & port -> timeouts ) == 0 ) RETURN_FAIL ( "SetCommTimeouts()<S2SV_blank>failed" ) ; } if ( WriteFile ( port -> hdl , buf , count , NULL , & port -> write_ovl ) == 0 ) if ( GetLastError ( ) != ERROR_IO_PENDING ) RETURN_FAIL ( "WriteFile()<S2SV_blank>failed" ) ; DEBUG ( "Waiting<S2SV_blank>for<S2SV_blank>write<S2SV_blank>to<S2SV_blank>complete" ) ; if ( GetOverlappedResult ( port -> hdl , & port -> write_ovl , & bytes_written , TRUE ) == 0 ) RETURN_FAIL ( "GetOverlappedResult()<S2SV_blank>failed" ) ; if ( port -> write_ovl . Internal == WAIT_TIMEOUT ) DEBUG ( "Write<S2SV_blank>timed<S2SV_blank>out" ) ; DEBUG_FMT ( "Write<S2SV_blank>completed,<S2SV_blank>%d/%d<S2SV_blank>bytes<S2SV_blank>written" , bytes_written , count ) ; RETURN_INT ( bytes_written ) ; # else size_t bytes_written = 0 ; unsigned char * ptr = ( unsigned char * ) buf ; struct timeval start , delta , now , end = { 0 , 0 } ; int started = 0 ; fd_set fds ; int result ; if ( timeout_ms ) { gettimeofday ( & start , NULL ) ; delta . tv_sec = timeout_ms / 1000 ; delta . tv_usec = ( timeout_ms % 1000 ) * 1000 ; timeradd ( & start , & delta , & end ) ; } FD_ZERO ( & fds ) ; FD_SET ( port -> fd , & fds ) ; while ( bytes_written < count ) { if ( timeout_ms && started ) { gettimeofday ( & now , NULL ) ; if ( timercmp ( & now , & end , > ) ) break ; timersub ( & end , & now , & delta ) ; } result = select ( port -> fd + 1 , NULL , & fds , NULL , timeout_ms ? & delta : NULL ) ; started = 1 ; if ( result < 0 ) { if ( errno == EINTR ) { DEBUG ( "select()<S2SV_blank>call<S2SV_blank>was<S2SV_blank>interrupted,<S2SV_blank>repeating" ) ; continue ; } else { RETURN_FAIL ( "select()<S2SV_blank>failed" ) ; } } else if ( result == 0 ) { break ; } result = write ( port -> fd , ptr , count - bytes_written ) ; if ( result < 0 ) { if ( errno == EAGAIN ) continue ; else RETURN_FAIL ( "write()<S2SV_blank>failed" ) ; } bytes_written += result ; ptr += result ; } if ( bytes_written < count ) DEBUG ( "Write<S2SV_blank>timed<S2SV_blank>out" ) ; RETURN_INT ( bytes_written ) ; # endif } | <S2SV_ModStart> ; if ( count == 0 ) RETURN_ERROR ( SP_ERR_ARG , "Zero<S2SV_blank>count" ) ; if ( <S2SV_ModStart> ) DEBUG_FMT ( "Writing<S2SV_blank>up<S2SV_blank>to<S2SV_blank>%d<S2SV_blank>bytes<S2SV_blank>to<S2SV_blank>port<S2SV_blank>%s,<S2SV_blank>timeout<S2SV_blank>%d<S2SV_blank>ms" <S2SV_ModEnd> , count , <S2SV_ModStart> else DEBUG_FMT ( "Writing<S2SV_blank>up<S2SV_blank>to<S2SV_blank>%d<S2SV_blank>bytes<S2SV_blank>to<S2SV_blank>port<S2SV_blank>%s,<S2SV_blank>no<S2SV_blank>timeout" <S2SV_ModEnd> , count , <S2SV_ModStart> port -> name <S2SV_ModEnd> ) ; # |
2,531 | CWE-000 void demo ( char * text , unsigned len ) { kdgu * q = kdgu_new ( KDGU_FMT_UTF32 , text , len ) ; <S2SV_StartBug> kdgu_chomp ( q ) ; <S2SV_EndBug> kdgu_uc ( q ) ; kdgu_reverse ( q ) ; kdgu_convert ( q , KDGU_FMT_UTF8 ) ; kdgu * r = kdgu_copy ( q ) ; kdgu_convert ( r , KDGU_FMT_UTF16 ) ; <S2SV_StartBug> kdgu_convert ( r , KDGU_FMT_UTF8 ) ; <S2SV_EndBug> assert ( kdgu_cmp ( q , r ) ) ; # if 0 for ( unsigned i = 0 ; i < q -> len ; i ++ ) { if ( q -> s [ i ] != r -> s [ i ] ) { printf ( "0x%X<S2SV_blank>and<S2SV_blank>0x%X<S2SV_blank>at<S2SV_blank>%u\\n" , ( unsigned char ) q -> s [ i ] , ( unsigned char ) r -> s [ i ] , i ) ; } } # endif kdgu_print ( r ) ; putchar ( '\\n' ) ; printf ( "length:<S2SV_blank>%zu\\n" , kdgu_len ( r ) ) ; printf ( "first<S2SV_blank>character:<S2SV_blank>\'" ) ; kdgu_nth ( r , 0 ) ; kdgu_pchr ( r , stdout ) ; puts ( "\'" ) ; printf ( "last<S2SV_blank>character:<S2SV_blank>\'" ) ; kdgu_nth ( r , kdgu_len ( r ) - 1 ) ; kdgu_pchr ( r , stdout ) ; puts ( "\'" ) ; print_errors ( q -> errlist , filename ) ; print_errors ( r -> errlist , filename ) ; kdgu_free ( q ) ; kdgu_free ( r ) ; kdgu * a = kdgu_news ( "foo<S2SV_blank>" ) ; kdgu * b = kdgu_news ( "bar" ) ; kdgu_convert ( a , KDGU_FMT_UTF8 ) ; kdgu_convert ( b , KDGU_FMT_UTF8 ) ; kdgu_uc ( b ) ; kdgu_cat ( a , b ) ; kdgu_print ( a ) ; putchar ( '\\n' ) ; kdgu_free ( a ) ; kdgu_free ( b ) ; } | <S2SV_ModStart> len ) ; kdgu_convert ( q , KDGU_FMT_UTF16 ) ; <S2SV_ModStart> r , KDGU_FMT_UTF8 <S2SV_ModEnd> ) ; # |
2,532 | CWE-000 static bool rx_complete_cb ( struct _dw1000_dev_instance_t * inst , dw1000_mac_interface_t * cbs ) { tdma_instance_t * tdma = inst -> tdma ; <S2SV_StartBug> if ( inst -> fctrl_array [ 0 ] == FCNTL_IEEE_BLINK_CCP_64 ) { <S2SV_EndBug> <S2SV_StartBug> DIAGMSG ( "{\\"utime\\":<S2SV_blank>%lu,\\"msg\\":<S2SV_blank>\\"rx_complete_cb\\"}\\n" , os_cputime_ticks_to_usecs ( os_cputime_get32 ( ) ) ) ; <S2SV_EndBug> if ( inst -> tdma != NULL && inst -> tdma -> status . initialized ) { tdma -> os_epoch = inst -> ccp -> os_epoch ; # ifdef TDMA_TASKS_ENABLE os_eventq_put ( & inst -> tdma -> eventq , & inst -> tdma -> event_cb . c_ev ) ; # else os_eventq_put ( & inst -> eventq , & inst -> tdma -> event_cb . c_ev ) ; # endif } return false ; } return false ; } | <S2SV_ModStart> ( inst -> ccp -> status . valid && inst -> <S2SV_ModStart> { DIAGMSG ( "{\\"utime\\":<S2SV_blank>%lu,\\"msg\\":<S2SV_blank>\\"tdma:rx_complete_cb\\"}\\n" <S2SV_ModEnd> , os_cputime_ticks_to_usecs ( |
2,533 | CWE-000 __attribute__ ( ( nonnull ( 1 ) , nothrow , warn_unused_result ) ) static int test1 ( darr_t * restrict darr , size_t nnum ) { size_t k ; size_t snum = ( size_t ) rand ( ) % nnum ; size_t sz = darr -> n ; int * restrict nums ; fprintf ( stderr , "test1<S2SV_blank>()<S2SV_blank>snum:<S2SV_blank>%d,<S2SV_blank>sz:<S2SV_blank>%d\\n" , ( int ) snum , ( int ) sz ) ; fflush ( stderr ) ; nums = malloc ( sizeof ( int ) * snum ) ; get_nums ( nums , snum ) ; error_check ( inserts_rear_darr ( darr , nums , snum ) != 0 ) { <S2SV_StartBug> fputs ( stderr , "error<S2SV_blank>-11" ) ; fflush ( stderr ) ; <S2SV_EndBug> free ( nums ) ; return - 11 ; } free ( nums ) ; error_check ( sz + snum != darr -> n ) return - 1 ; darr_print ( darr ) ; return 0 ; } | <S2SV_ModStart> { fputs ( "error<S2SV_blank>-11" , stderr <S2SV_ModEnd> ) ; fflush |
2,534 | CWE-000 static void test_keyrelease ( void * * state ) { <S2SV_StartBug> ( void ) state ; <S2SV_EndBug> input . lastState = KEY_UP ; input . currentState = 0 ; assert_true ( key_is_released ( & input , KEY_UP ) ) ; } | <S2SV_ModStart> void ) state ; KeyboardInput input = { 0 , 0 } |
2,535 | CWE-000 static void do_alloc ( int argc , char * argv [ ] ) { if ( argc != 3 ) { printf ( "usage:<S2SV_blank>./array<S2SV_blank><file-name><S2SV_blank>alloc<S2SV_blank><array-name>" "<size><S2SV_blank><type>\\n" ) ; return ; } enum array_types type = get_type ( argv [ 2 ] ) ; if ( type == UNKNOWN_ARRAY_TYPE ) return ; size_t size = atoi ( argv [ 1 ] ) ; TOID ( struct array_info ) array_info = find_array ( argv [ 0 ] ) ; if ( ! TOID_IS_NULL ( array_info ) ) POBJ_FREE ( & array_info ) ; POBJ_ZNEW ( pop , & array_info , struct array_info ) ; struct array_info * info = D_RW ( array_info ) ; <S2SV_StartBug> memcpy ( info -> name , argv [ 0 ] , strlen ( argv [ 0 ] ) ) ; <S2SV_EndBug> info -> size = size ; info -> type = type ; info -> array = alloc_array [ type ] ( size ) ; if ( OID_IS_NULL ( info -> array ) ) assert ( 0 ) ; pmemobj_persist ( pop , info , sizeof ( * info ) ) ; } | <S2SV_ModStart> array_info ) ; strncpy <S2SV_ModEnd> ( info -> <S2SV_ModStart> 0 ] , MAX_BUFFLEN ) ; info -> name [ MAX_BUFFLEN - 1 ] = '\\0' <S2SV_ModEnd> ; info -> |
2,536 | CWE-000 int start_listener ( ) { int sock ; <S2SV_StartBug> if ( strcasecmp ( "true" , getenv ( "USE_NETWORK" ) ) == 0 || <S2SV_EndBug> <S2SV_StartBug> strcasecmp ( "yes" , getenv ( "USE_NETWORK" ) ) == 0 ) { <S2SV_EndBug> sock = start_listener_inet ( ) ; } else { sock = start_listener_ipc ( & uds_client_fn ) ; atexit ( atexit_cleanup_udsfile ) ; } return sock ; } | <S2SV_ModStart> int sock ; char * network ; if ( getenv ( "USE_NETWORK" ) == NULL ) { network = "no" ; lprintf ( WARNING , "USE_NETWORK<S2SV_blank>is<S2SV_blank>not<S2SV_blank>set,<S2SV_blank>use<S2SV_blank>default<S2SV_blank>value<S2SV_blank>\\"no\\"." ) ; } else { network = getenv ( "USE_NETWORK" ) ; } <S2SV_ModStart> ( "true" , network <S2SV_ModEnd> ) == 0 <S2SV_ModStart> ( "yes" , network <S2SV_ModEnd> ) == 0 |
2,537 | CWE-000 static GstRTSPResult rtsp_ext_real_stream_select ( GstRTSPExtension * ext , GstRTSPUrl * url ) { GstRTSPReal * ctx = ( GstRTSPReal * ) ext ; GstRTSPResult res ; GstRTSPMessage request = { 0 } ; GstRTSPMessage response = { 0 } ; gchar * req_url ; if ( ! ctx -> isreal ) return GST_RTSP_OK ; if ( ! ctx -> rules ) return GST_RTSP_OK ; req_url = gst_rtsp_url_get_request_uri ( url ) ; if ( ( res = gst_rtsp_message_init_request ( & request , GST_RTSP_SET_PARAMETER , req_url ) ) < 0 ) goto create_request_failed ; g_free ( req_url ) ; gst_rtsp_message_add_header ( & request , GST_RTSP_HDR_SUBSCRIBE , ctx -> rules ) ; if ( ( res = gst_rtsp_extension_send ( ext , & request , & response ) ) < 0 ) goto send_error ; gst_rtsp_message_unset ( & request ) ; gst_rtsp_message_unset ( & response ) ; return GST_RTSP_OK ; create_request_failed : { GST_ELEMENT_ERROR ( ctx , LIBRARY , INIT , ( "Could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>request." ) , ( NULL ) ) ; <S2SV_StartBug> goto reset ; <S2SV_EndBug> } send_error : { GST_ELEMENT_ERROR ( ctx , RESOURCE , WRITE , ( "Could<S2SV_blank>not<S2SV_blank>send<S2SV_blank>message." ) , ( NULL ) ) ; goto reset ; } reset : { gst_rtsp_message_unset ( & request ) ; gst_rtsp_message_unset ( & response ) ; return res ; } } | <S2SV_ModStart> ) ) ; g_free ( req_url ) ; |
2,538 | CWE-000 jactivity_t * activity_new ( activity_table_t * at , char * actid , bool remote ) { jactivity_t * jact = ( jactivity_t * ) calloc ( 1 , sizeof ( jactivity_t ) ) ; if ( jact != NULL ) { <S2SV_StartBug> jact -> remote = remote ; <S2SV_EndBug> jact -> resultq = pqueue_new ( false ) ; while ( ( jact -> thread = activity_getthread ( at , actid ) ) == NULL ) { printf ( "Waiting<S2SV_blank>for<S2SV_blank>...\\n" ) ; taskdelay ( 10 ) ; } activity_setthread ( jact -> thread , jact , actid ) ; jact -> state = NEW ; jact -> actid = strdup ( actid ) ; } return jact ; } | <S2SV_ModStart> remote = remote <S2SV_ModEnd> ; while ( |
2,539 | CWE-000 <S2SV_StartBug> int imap_access ( const char * path , int flags ) <S2SV_EndBug> { struct ImapData * idata = NULL ; struct ImapMbox mx ; char buf [ LONG_STRING ] ; char mailbox [ LONG_STRING ] ; char mbox [ LONG_STRING ] ; int rc ; if ( imap_parse_path ( path , & mx ) ) return - 1 ; if ( ! ( idata = imap_conn_find ( & mx . account , option ( OPTIMAPPASSIVE ) ? MUTT_IMAP_CONN_NONEW : 0 ) ) ) { FREE ( & mx . mbox ) ; return - 1 ; } imap_fix_path ( idata , mx . mbox , mailbox , sizeof ( mailbox ) ) ; if ( ! * mailbox ) strfcpy ( mailbox , "INBOX" , sizeof ( mailbox ) ) ; if ( ascii_strcmp ( idata -> mailbox , mx . mbox ) == 0 ) { FREE ( & mx . mbox ) ; return 0 ; } FREE ( & mx . mbox ) ; if ( imap_mboxcache_get ( idata , mailbox , 0 ) ) { mutt_debug ( 3 , "imap_access:<S2SV_blank>found<S2SV_blank>%s<S2SV_blank>in<S2SV_blank>cache\\n" , mailbox ) ; return 0 ; } imap_munge_mbox_name ( idata , mbox , sizeof ( mbox ) , mailbox ) ; if ( mutt_bit_isset ( idata -> capabilities , IMAP4REV1 ) ) snprintf ( buf , sizeof ( buf ) , "STATUS<S2SV_blank>%s<S2SV_blank>(UIDVALIDITY)" , mbox ) ; else if ( mutt_bit_isset ( idata -> capabilities , STATUS ) ) snprintf ( buf , sizeof ( buf ) , "STATUS<S2SV_blank>%s<S2SV_blank>(UID-VALIDITY)" , mbox ) ; else { mutt_debug ( 2 , "imap_access:<S2SV_blank>STATUS<S2SV_blank>not<S2SV_blank>supported?\\n" ) ; return - 1 ; } if ( ( rc = imap_exec ( idata , buf , IMAP_CMD_FAIL_OK ) ) < 0 ) { mutt_debug ( 1 , "imap_access:<S2SV_blank>Can\'t<S2SV_blank>check<S2SV_blank>STATUS<S2SV_blank>of<S2SV_blank>%s\\n" , mbox ) ; return rc ; } return 0 ; } | <S2SV_ModStart> char * path <S2SV_ModEnd> ) { struct |
2,540 | CWE-000 static int __wlan_hdd_cfg80211_firmware_roaming ( struct wiphy * wiphy , struct wireless_dev * wdev , const void * data , int data_len ) { u8 bssid [ 6 ] = { 0 } ; hdd_context_t * pHddCtx = wiphy_priv ( wiphy ) ; struct nlattr * tb [ QCA_WLAN_VENDOR_ATTR_MAX + 1 ] ; eHalStatus status = eHAL_STATUS_SUCCESS ; v_U32_t isFwrRoamEnabled = FALSE ; int ret ; ENTER ( ) ; ret = wlan_hdd_validate_context ( pHddCtx ) ; if ( 0 != ret ) { return ret ; } ret = nla_parse ( tb , QCA_WLAN_VENDOR_ATTR_MAX , data , data_len , qca_wlan_vendor_attr ) ; if ( ret ) { hddLog ( VOS_TRACE_LEVEL_ERROR , FL ( "Invalid<S2SV_blank>ATTR" ) ) ; return - EINVAL ; } if ( ! tb [ QCA_WLAN_VENDOR_ATTR_ROAMING_POLICY ] ) { hddLog ( VOS_TRACE_LEVEL_ERROR , FL ( "attr<S2SV_blank>enable<S2SV_blank>failed" ) ) ; return - EINVAL ; } isFwrRoamEnabled = nla_get_u32 ( tb [ QCA_WLAN_VENDOR_ATTR_ROAMING_POLICY ] ) ; hddLog ( VOS_TRACE_LEVEL_INFO , FL ( "isFwrRoamEnabled<S2SV_blank>(%d)" ) , isFwrRoamEnabled ) ; if ( ! tb [ QCA_WLAN_VENDOR_ATTR_MAC_ADDR ] ) { hddLog ( VOS_TRACE_LEVEL_ERROR , FL ( "attr<S2SV_blank>bss<S2SV_blank>id<S2SV_blank>failed" ) ) ; return - EINVAL ; } <S2SV_StartBug> memcpy ( bssid , nla_data ( <S2SV_EndBug> tb [ QCA_WLAN_VENDOR_ATTR_MAC_ADDR ] ) , sizeof ( bssid ) ) ; hddLog ( VOS_TRACE_LEVEL_INFO , FL ( MAC_ADDRESS_STR ) , MAC_ADDR_ARRAY ( bssid ) ) ; status = sme_ConfigFwrRoaming ( ( tHalHandle ) ( pHddCtx -> hHal ) , isFwrRoamEnabled ) ; EXIT ( ) ; return status ; } | <S2SV_ModStart> EINVAL ; } if ( nla_len ( tb [ QCA_WLAN_VENDOR_ATTR_MAC_ADDR ] ) < sizeof ( bssid ) ) { hddLog ( VOS_TRACE_LEVEL_ERROR , FL ( "Attribute<S2SV_blank>peerMac<S2SV_blank>is<S2SV_blank>invalid=%d" ) , adapter -> device_mode ) ; return - EINVAL ; } |
2,541 | CWE-000 static int add_parents_to_list ( struct rev_info * revs , struct commit * commit , struct commit_list * * list , struct commit_list * * cache_ptr ) { struct commit_list * parent = commit -> parents ; unsigned left_flag ; struct commit_list * cached_base = cache_ptr ? * cache_ptr : NULL ; if ( commit -> object . flags & ADDED ) return 0 ; commit -> object . flags |= ADDED ; if ( revs -> include_check && ! revs -> include_check ( commit , revs -> include_check_data ) ) return 0 ; if ( commit -> object . flags & UNINTERESTING ) { while ( parent ) { struct commit * p = parent -> item ; parent = parent -> next ; if ( p ) p -> object . flags |= UNINTERESTING ; if ( parse_commit_gently ( p , 1 ) < 0 ) continue ; if ( p -> parents ) mark_parents_uninteresting ( p ) ; if ( p -> object . flags & SEEN ) continue ; p -> object . flags |= SEEN ; commit_list_insert_by_date_cached ( p , list , cached_base , cache_ptr ) ; } return 0 ; } try_to_simplify_commit ( revs , commit ) ; if ( revs -> no_walk ) return 0 ; left_flag = ( commit -> object . flags & SYMMETRIC_LEFT ) ; for ( parent = commit -> parents ; parent ; parent = parent -> next ) { struct commit * p = parent -> item ; <S2SV_StartBug> if ( parse_commit_gently ( p , revs -> ignore_missing_links ) < 0 ) <S2SV_EndBug> <S2SV_StartBug> return - 1 ; <S2SV_EndBug> if ( revs -> show_source && ! p -> util ) p -> util = commit -> util ; p -> object . flags |= left_flag ; if ( ! ( p -> object . flags & SEEN ) ) { p -> object . flags |= SEEN ; commit_list_insert_by_date_cached ( p , list , cached_base , cache_ptr ) ; } if ( revs -> first_parent_only ) break ; } return 0 ; } | <S2SV_ModStart> -> item ; int gently = revs -> ignore_missing_links || revs -> exclude_promisor_objects ; <S2SV_ModStart> ( p , gently <S2SV_ModEnd> ) < 0 <S2SV_ModStart> < 0 ) { if ( revs -> exclude_promisor_objects && is_promisor_object ( & p -> object . oid ) ) { if ( revs -> first_parent_only ) break ; continue ; } <S2SV_ModStart> - 1 ; } |
2,542 | CWE-000 int nat_rebinding_test ( ) { uint64_t simulated_time = 0 ; uint64_t loss_mask = 0 ; uint64_t initial_challenge = 0 ; picoquic_test_tls_api_ctx_t * test_ctx = NULL ; int ret = tls_api_init_ctx ( & test_ctx , PICOQUIC_INTERNAL_TEST_VERSION_1 , <S2SV_StartBug> PICOQUIC_TEST_SNI , PICOQUIC_TEST_ALPN , & simulated_time , NULL , 0 , 0 ) ; <S2SV_EndBug> if ( ret == 0 ) { initial_challenge = test_ctx -> cnx_server -> path [ 0 ] -> challenge ; } test_ctx -> client_addr . sin_port += 17 ; if ( ret == 0 ) { ret = test_api_init_send_recv_scenario ( test_ctx , test_scenario_q_and_r , sizeof ( test_scenario_mtu_discovery ) ) ; } if ( ret == 0 ) { ret = tls_api_data_sending_loop ( test_ctx , & loss_mask , & simulated_time , 0 ) ; } if ( ret == 0 ) { if ( initial_challenge == test_ctx -> cnx_server -> path [ 0 ] -> challenge ) { DBG_PRINTF ( "%s" , "Challenge<S2SV_blank>was<S2SV_blank>not<S2SV_blank>renewed<S2SV_blank>after<S2SV_blank>NAT<S2SV_blank>rebinding" ) ; ret = - 1 ; } else if ( test_ctx -> cnx_server -> path [ 0 ] -> challenge_verified != 1 ) { DBG_PRINTF ( "%s" , "Challenge<S2SV_blank>was<S2SV_blank>not<S2SV_blank>verified<S2SV_blank>after<S2SV_blank>NAT<S2SV_blank>rebinding" ) ; ret = - 1 ; } } if ( test_ctx != NULL ) { tls_api_delete_ctx ( test_ctx ) ; test_ctx = NULL ; } return ret ; } | <S2SV_ModStart> 0 ) ; if ( ret == 0 ) { ret = tls_api_connection_loop ( test_ctx , & loss_mask , 0 , & simulated_time ) ; } |
2,543 | CWE-000 int main ( void ) { <S2SV_StartBug> init ( ) ; <S2SV_EndBug> Driver * driver [ NUMBER_PORTS ] = { NULL , NULL } ; ContollerData cd [ NUMBER_PORTS ] ; Joystick joystick [ NUMBER_PORTS ] = { 0 , 0 } ; # if SINGLE_CONTROLLER == CONTROLLER_A for ( uint8_t p = PORT_A ; p <= PORT_A ; p ++ ) { # elif SINGLE_CONTROLLER == CONTROLLER_B for ( uint8_t p = PORT_B ; p <= PORT_B ; p ++ ) { # else for ( uint8_t p = PORT_A ; p <= PORT_B ; p ++ ) { # endif switch_selector ( p ) ; _delay_ms ( 1 ) ; driver [ p ] = GetDriver ( get_id ( ) ) ; } <S2SV_StartBug> # ifdef DEBUG <S2SV_EndBug> uint8_t toggle = 0 ; # endif while ( 1 ) { button_debounce ( ) ; if ( button_get ( ) ) { led_setnextstate ( ) ; } # if SINGLE_CONTROLLER == CONTROLLER_A for ( uint8_t p = PORT_A ; p <= PORT_A ; p ++ ) { # elif SINGLE_CONTROLLER == CONTROLLER_B for ( uint8_t p = PORT_B ; p <= PORT_B ; p ++ ) { # else for ( uint8_t p = PORT_A ; p <= PORT_B ; p ++ ) { # endif switch_selector ( p ) ; controller_read ( & cd [ p ] ) ; driver [ p ] -> get_joystick_state ( & cd [ p ] , & joystick [ p ] ) ; } joystick_update ( joystick [ PORT_A ] , joystick [ PORT_B ] ) ; paddle_update ( joystick [ PORT_A ] , joystick [ PORT_B ] ) ; # ifdef DEBUG _delay_ms ( 100 ) ; if ( toggle == 1 ) { led_switch ( 0 ) ; toggle = 0 ; } else { led_switch ( 1 ) ; toggle = 1 ; } # endif } return 0 ; } | <S2SV_ModStart> { init ( ) ; led_switch ( LED_BLINK1 <S2SV_ModStart> ) ; } led_switch ( LED_OFF ) ; |
2,544 | CWE-000 static MonoImage * do_mono_image_load ( MonoImage * image , MonoImageOpenStatus * status , gboolean care_about_cli , gboolean care_about_pecoff ) { ERROR_DECL ( error ) ; MonoCLIImageInfo * iinfo ; MonoDotNetHeader * header ; GSList * l ; MONO_PROFILER_RAISE ( image_loading , ( image ) ) ; mono_image_init ( image ) ; iinfo = ( MonoCLIImageInfo * ) image -> image_info ; header = & iinfo -> cli_header ; if ( ! image -> metadata_only ) { for ( l = image_loaders ; l ; l = l -> next ) { MonoImageLoader * loader = ( MonoImageLoader * ) l -> data ; if ( loader -> match ( image ) ) { image -> loader = loader ; break ; } } if ( ! image -> loader ) { if ( status ) * status = MONO_IMAGE_IMAGE_INVALID ; goto invalid_image ; } if ( status ) * status = MONO_IMAGE_IMAGE_INVALID ; if ( care_about_pecoff == FALSE ) goto done ; if ( image -> loader == & pe_loader && ! mono_verifier_verify_pe_data ( image , error ) ) goto invalid_image ; if ( ! mono_image_load_pe_data ( image ) ) goto invalid_image ; } else { image -> loader = ( MonoImageLoader * ) & pe_loader ; } if ( care_about_cli == FALSE ) { goto done ; } if ( image -> loader == & pe_loader && ! image -> metadata_only && ! mono_verifier_verify_cli_data ( image , error ) ) goto invalid_image ; if ( ! mono_image_load_cli_data ( image ) ) goto invalid_image ; <S2SV_StartBug> if ( ! image -> ref_only && is_problematic_image ( image ) ) { <S2SV_EndBug> if ( image -> load_from_context ) { mono_trace ( G_LOG_LEVEL_INFO , MONO_TRACE_ASSEMBLY , "Loading<S2SV_blank>problematic<S2SV_blank>image<S2SV_blank>%s" , image -> name ) ; } else { mono_trace ( G_LOG_LEVEL_INFO , MONO_TRACE_ASSEMBLY , "Denying<S2SV_blank>load<S2SV_blank>of<S2SV_blank>problematic<S2SV_blank>image<S2SV_blank>%s" , image -> name ) ; * status = MONO_IMAGE_IMAGE_INVALID ; goto invalid_image ; } } if ( image -> loader == & pe_loader && ! image -> metadata_only && ! mono_verifier_verify_table_data ( image , error ) ) goto invalid_image ; mono_image_load_names ( image ) ; load_modules ( image ) ; done : MONO_PROFILER_RAISE ( image_loaded , ( image ) ) ; if ( status ) * status = MONO_IMAGE_OK ; return image ; invalid_image : if ( ! is_ok ( error ) ) { mono_trace ( G_LOG_LEVEL_INFO , MONO_TRACE_ASSEMBLY , "Could<S2SV_blank>not<S2SV_blank>load<S2SV_blank>image<S2SV_blank>%s<S2SV_blank>due<S2SV_blank>to<S2SV_blank>%s" , image -> name , mono_error_get_message ( error ) ) ; mono_error_cleanup ( error ) ; } MONO_PROFILER_RAISE ( image_failed , ( image ) ) ; mono_image_close ( image ) ; return NULL ; } | <S2SV_ModStart> -> ref_only && mono_is_problematic_image <S2SV_ModEnd> ( image ) |
2,545 | CWE-000 <S2SV_StartBug> static inline bool AlarmShallStrike ( uint32_t aNow , AlarmIndex aIndex ) <S2SV_EndBug> { <S2SV_StartBug> uint32_t diff = aNow - sTimerData [ aIndex ] . mTargetTime ; <S2SV_EndBug> <S2SV_StartBug> return ! ( ( diff & ( 1UL << 31 ) ) != 0 ) ; <S2SV_EndBug> } | <S2SV_ModStart> bool AlarmShallStrike ( uint64_t <S2SV_ModEnd> aNow , AlarmIndex <S2SV_ModStart> aIndex ) { return aNow >= <S2SV_ModEnd> sTimerData [ aIndex <S2SV_ModStart> . mTargetTime ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
2,546 | CWE-000 s64 garbage_collect ( ) { HashsetIterator hti ; s64 mem1 = heap_size ; s64 del = 0 ; s64 time_startAt ; time_startAt = currentTimeMillis ( ) ; garbage_thread_lock ( ) ; if ( garbage_pause_the_world ( ) != 0 ) { garbage_resume_the_world ( ) ; return - 1 ; } garbage_move_cache ( ) ; garbage_copy_refer ( ) ; garbage_resume_the_world ( ) ; <S2SV_StartBug> garbage_thread_unlock ( ) ; <S2SV_EndBug> collector -> flag_refer ++ ; s64 time_stopWorld = currentTimeMillis ( ) - time_startAt ; s64 obj_count = ( collector -> objs -> entries ) ; <S2SV_StartBug> time_startAt = currentTimeMillis ( ) ; <S2SV_EndBug> garbage_big_search ( ) ; hashset_iterate ( collector -> objs , & hti ) ; for ( ; hashset_iter_has_more ( & hti ) ; ) { HashsetKey k = hashset_iter_next_key ( & hti ) ; MemoryBlock * mb = ( MemoryBlock * ) k ; if ( mb -> garbage_mark != collector -> flag_refer ) { <S2SV_StartBug> hashset_remove ( collector -> objs , mb , 0 ) ; <S2SV_EndBug> garbage_destory_memobj ( mb ) ; del ++ ; } } if ( collector -> _garbage_count ++ % 5 == 0 ) { hashset_remove ( collector -> objs , NULL , 1 ) ; } <S2SV_StartBug> s64 time_gc = currentTimeMillis ( ) - time_startAt ; <S2SV_EndBug> jvm_printf ( "gc<S2SV_blank>obj:<S2SV_blank>%lld<S2SV_blank>-><S2SV_blank>%lld<S2SV_blank><S2SV_blank>heap<S2SV_blank>:<S2SV_blank>%lld<S2SV_blank>-><S2SV_blank>%lld<S2SV_blank><S2SV_blank>stop_world:<S2SV_blank>%lld<S2SV_blank><S2SV_blank>gc:%lld\\n" , obj_count , hashset_num_entries ( collector -> objs ) , mem1 , heap_size , time_stopWorld , time_gc ) ; return del ; } | <S2SV_ModStart> ( ) ; <S2SV_ModEnd> s64 time_stopWorld = <S2SV_ModStart> time_startAt = currentTimeMillis ( ) ; _garbage_change_flag <S2SV_ModStart> flag_refer ) { garbage_destory_memobj ( mb ) ; hashset_iter_remove ( & hti <S2SV_ModEnd> ) ; del <S2SV_ModStart> ) ; } garbage_thread_unlock ( ) ; |
2,547 | CWE-000 static void gsi_handle_ev_ctrl ( int ee ) { uint32_t ch ; int i ; uint32_t val ; struct gsi_evt_ctx * ctx ; ch = gsi_readl ( gsi_ctx -> base + GSI_EE_n_CNTXT_SRC_EV_CH_IRQ_OFFS ( ee ) ) ; GSIDBG ( "ev<S2SV_blank>%x\\n" , ch ) ; for ( i = 0 ; i < 32 ; i ++ ) { <S2SV_StartBug> if ( ( 1 << i ) & ch ) { <S2SV_EndBug> ctx = & gsi_ctx -> evtr [ i ] ; val = gsi_readl ( gsi_ctx -> base + GSI_EE_n_EV_CH_k_CNTXT_0_OFFS ( i , ee ) ) ; ctx -> state = ( val & GSI_EE_n_EV_CH_k_CNTXT_0_CHSTATE_BMSK ) >> GSI_EE_n_EV_CH_k_CNTXT_0_CHSTATE_SHFT ; GSIDBG ( "evt<S2SV_blank>%u<S2SV_blank>state<S2SV_blank>updated<S2SV_blank>to<S2SV_blank>%u\\n" , i , ctx -> state ) ; complete ( & ctx -> compl ) ; } } gsi_writel ( ch , gsi_ctx -> base + GSI_EE_n_CNTXT_SRC_EV_CH_IRQ_CLR_OFFS ( ee ) ) ; } | <S2SV_ModStart> ch ) { if ( i >= gsi_ctx -> max_ev || i >= GSI_EVT_RING_MAX ) { GSIERR ( "invalid<S2SV_blank>event<S2SV_blank>%d\\n" , i ) ; break ; } |
2,548 | CWE-000 static void cpuset_css_free ( struct cgroup * cont ) { struct cpuset * cs = cgroup_cs ( cont ) ; free_cpumask_var ( cs -> cpus_allowed ) ; <S2SV_StartBug> kfree ( cs ) ; <S2SV_EndBug> } | <S2SV_ModStart> cpus_allowed ) ; free_cpumask_var ( cs -> cpus_requested ) ; |
2,549 | CWE-000 <S2SV_StartBug> static void list_lttng_channels ( enum lttng_domain_type domain , <S2SV_EndBug> struct ltt_session * session , struct lttng_channel * channels , struct lttcomm_channel_extended * chan_exts ) { <S2SV_StartBug> int i = 0 , ret ; <S2SV_EndBug> struct ltt_kernel_channel * kchan ; DBG ( "Listing<S2SV_blank>channels<S2SV_blank>for<S2SV_blank>session<S2SV_blank>%s" , session -> name ) ; switch ( domain ) { case LTTNG_DOMAIN_KERNEL : if ( session -> kernel_session != NULL ) { cds_list_for_each_entry ( kchan , & session -> kernel_session -> channel_list . head , list ) { uint64_t discarded_events , lost_packets ; ret = get_kernel_runtime_stats ( session , kchan , & discarded_events , & lost_packets ) ; if ( ret < 0 ) { goto end ; } memcpy ( & channels [ i ] , kchan -> channel , sizeof ( struct lttng_channel ) ) ; channels [ i ] . enabled = kchan -> enabled ; chan_exts [ i ] . discarded_events = discarded_events ; chan_exts [ i ] . lost_packets = lost_packets ; i ++ ; } } break ; case LTTNG_DOMAIN_UST : { struct lttng_ht_iter iter ; struct ltt_ust_channel * uchan ; rcu_read_lock ( ) ; cds_lfht_for_each_entry ( session -> ust_session -> domain_global . channels -> ht , & iter . iter , uchan , node . node ) { uint64_t discarded_events = 0 , lost_packets = 0 ; if ( lttng_strncpy ( channels [ i ] . name , uchan -> name , LTTNG_SYMBOL_NAME_LEN ) ) { break ; } channels [ i ] . attr . overwrite = uchan -> attr . overwrite ; channels [ i ] . attr . subbuf_size = uchan -> attr . subbuf_size ; channels [ i ] . attr . num_subbuf = uchan -> attr . num_subbuf ; channels [ i ] . attr . switch_timer_interval = uchan -> attr . switch_timer_interval ; channels [ i ] . attr . read_timer_interval = uchan -> attr . read_timer_interval ; channels [ i ] . enabled = uchan -> enabled ; channels [ i ] . attr . tracefile_size = uchan -> tracefile_size ; channels [ i ] . attr . tracefile_count = uchan -> tracefile_count ; switch ( uchan -> attr . output ) { case LTTNG_UST_MMAP : channels [ i ] . attr . output = LTTNG_EVENT_MMAP ; break ; default : assert ( 0 ) ; break ; } <S2SV_StartBug> ret = get_ust_runtime_stats ( session , uchan , <S2SV_EndBug> & discarded_events , & lost_packets ) ; if ( ret < 0 ) { break ; } chan_exts [ i ] . discarded_events = discarded_events ; chan_exts [ i ] . lost_packets = lost_packets ; i ++ ; } rcu_read_unlock ( ) ; break ; } default : break ; } end : <S2SV_StartBug> return ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> static ssize_t <S2SV_ModEnd> list_lttng_channels ( enum <S2SV_ModStart> 0 , ret = 0 <S2SV_ModStart> break ; } chan_exts [ i ] . monitor_timer_interval = uchan -> monitor_timer_interval ; <S2SV_ModStart> } end : if ( ret < 0 ) { return - LTTNG_ERR_FATAL ; } else { return LTTNG_OK ; } <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
2,550 | CWE-000 void time_of_add_dynamic ( int amount ) { struct timeval real_start , real_end ; struct rusage susage , eusage ; <S2SV_StartBug> int block_size = arc4random ( ) % ( MAX_BLOCK_SIZE - 1 ) + 1 ; <S2SV_EndBug> dynamic_array * array = create_random_dynamic_array ( amount , block_size ) ; char * block = create_block ( array -> block_size ) ; gettimeofday ( & real_start , NULL ) ; getrusage ( RUSAGE_SELF , & susage ) ; for ( int i = 0 ; i < amount ; i ++ ) add_dynamic ( array , i , block ) ; gettimeofday ( & real_end , NULL ) ; getrusage ( RUSAGE_SELF , & eusage ) ; delete_dynamic_array ( array ) ; printf ( "%dx<S2SV_blank>" , amount ) ; print_result ( "add<S2SV_blank>to<S2SV_blank>dynamic<S2SV_blank>array" , susage , eusage , real_start , real_end ) ; } | <S2SV_ModStart> ; int block_size ; do { block_size <S2SV_ModStart> ) + 1 ; } while ( ( block_size ) % 16 == 0 ) |
2,551 | CWE-000 static void btm_ble_process_adv_pkt_cont ( BD_ADDR bda , UINT8 addr_type , UINT8 evt_type , UINT8 * p ) { tINQ_DB_ENT * p_i ; tBTM_INQUIRY_VAR_ST * p_inq = & btm_cb . btm_inq_vars ; tBTM_INQ_RESULTS_CB * p_inq_results_cb = p_inq -> p_inq_results_cb ; tBTM_INQ_RESULTS_CB * p_obs_results_cb = btm_cb . ble_ctr_cb . p_obs_results_cb ; tBTM_INQ_RESULTS_CB * p_scan_results_cb = btm_cb . ble_ctr_cb . p_scan_results_cb ; tBTM_BLE_INQ_CB * p_le_inq_cb = & btm_cb . ble_ctr_cb . inq_var ; BOOLEAN update = TRUE ; UINT8 result = 0 ; if ( p_le_inq_cb -> scan_duplicate_filter == BTM_BLE_SCAN_DUPLICATE_ENABLE ) { <S2SV_StartBug> if ( memcmp ( bda , p_le_inq_cb -> adv_addr , BD_ADDR_LEN ) != 0 ) { <S2SV_EndBug> btm_ble_process_last_adv_pkt ( ) ; } } p_i = btm_inq_db_find ( bda ) ; if ( btm_inq_find_bdaddr ( bda ) ) { if ( p_i && ( ! ( p_i -> inq_info . results . device_type & BT_DEVICE_TYPE_BLE ) || ( ! p_i -> scan_rsp ) ) ) { update = TRUE ; } else if ( BTM_BLE_IS_DISCO_ACTIVE ( btm_cb . ble_ctr_cb . scan_activity ) ) { update = FALSE ; } else { return ; } } if ( p_i == NULL ) { if ( ( p_i = btm_inq_db_new ( bda ) ) != NULL ) { p_inq -> inq_cmpl_info . num_resp ++ ; } else { return ; } } else if ( p_i -> inq_count != p_inq -> inq_counter ) { p_inq -> inq_cmpl_info . num_resp ++ ; } if ( ! btm_ble_update_inq_result ( bda , p_i , addr_type , evt_type , p ) ) { return ; } if ( ( result = btm_ble_is_discoverable ( bda , evt_type , p ) ) == 0 ) { BTM_TRACE_WARNING ( "%s<S2SV_blank>device<S2SV_blank>is<S2SV_blank>no<S2SV_blank>longer<S2SV_blank>discoverable<S2SV_blank>so<S2SV_blank>discarding<S2SV_blank>advertising<S2SV_blank>packet<S2SV_blank>pkt" , __func__ ) ; return ; } if ( ! update ) { result &= ~ BTM_BLE_INQ_RESULT ; } if ( p_inq -> inqparms . max_resps && p_inq -> inq_cmpl_info . num_resp == p_inq -> inqparms . max_resps ) { if ( p_i == NULL || ( p_i && ( p_i -> inq_info . results . device_type & BT_DEVICE_TYPE_BLE ) == BT_DEVICE_TYPE_BLE && p_i -> scan_rsp ) ) { BTM_TRACE_WARNING ( "INQ<S2SV_blank>RES:<S2SV_blank>Extra<S2SV_blank>Response<S2SV_blank>Received...cancelling<S2SV_blank>inquiry.." ) ; if ( ( p_inq -> inq_active & BTM_BR_INQ_ACTIVE_MASK ) != 0 && ( p_inq -> inq_active & BTM_PERIODIC_INQUIRY_ACTIVE ) == 0 ) { btsnd_hcic_inq_cancel ( ) ; } btm_ble_stop_inquiry ( ) ; btm_acl_update_busy_level ( BTM_BLI_INQ_DONE_EVT ) ; } } if ( btm_cb . ble_ctr_cb . bg_conn_type == BTM_BLE_CONN_SELECTIVE ) { if ( result & BTM_BLE_SEL_CONN_RESULT ) { btm_send_sel_conn_callback ( bda , evt_type , p , addr_type ) ; } else { BTM_TRACE_DEBUG ( "None<S2SV_blank>LE<S2SV_blank>device,<S2SV_blank>can<S2SV_blank>not<S2SV_blank>initiate<S2SV_blank>selective<S2SV_blank>connection\\n" ) ; } } else { if ( p_inq_results_cb && ( result & BTM_BLE_INQ_RESULT ) ) { ( p_inq_results_cb ) ( ( tBTM_INQ_RESULTS * ) & p_i -> inq_info . results , p_le_inq_cb -> adv_data_cache ) ; p_le_inq_cb -> adv_len = 0 ; memset ( p_le_inq_cb -> adv_addr , 0 , BD_ADDR_LEN ) ; p_i -> inq_info . results . adv_data_len = 0 ; p_i -> inq_info . results . scan_rsp_len = 0 ; } if ( p_obs_results_cb && ( result & BTM_BLE_OBS_RESULT ) ) { ( p_obs_results_cb ) ( ( tBTM_INQ_RESULTS * ) & p_i -> inq_info . results , p_le_inq_cb -> adv_data_cache ) ; p_le_inq_cb -> adv_len = 0 ; memset ( p_le_inq_cb -> adv_addr , 0 , BD_ADDR_LEN ) ; p_i -> inq_info . results . adv_data_len = 0 ; p_i -> inq_info . results . scan_rsp_len = 0 ; } if ( p_scan_results_cb && ( result & BTM_BLE_DISCO_RESULT ) ) { ( p_scan_results_cb ) ( ( tBTM_INQ_RESULTS * ) & p_i -> inq_info . results , p_le_inq_cb -> adv_data_cache ) ; p_le_inq_cb -> adv_len = 0 ; memset ( p_le_inq_cb -> adv_addr , 0 , BD_ADDR_LEN ) ; p_i -> inq_info . results . adv_data_len = 0 ; p_i -> inq_info . results . scan_rsp_len = 0 ; } } } | <S2SV_ModStart> BTM_BLE_SCAN_DUPLICATE_ENABLE ) { int same_addr = <S2SV_ModEnd> memcmp ( bda <S2SV_ModStart> , BD_ADDR_LEN ) ; if ( same_addr != 0 || ( same_addr == 0 && evt_type != BTM_BLE_SCAN_RSP_EVT ) <S2SV_ModEnd> ) { btm_ble_process_last_adv_pkt |
2,552 | CWE-000 int iupdrvFontGetStringWidth ( Ihandle * ih , const char * str ) { <S2SV_StartBug> return emjsFont_GetStringWidth ( ih -> handle -> handleID , str ) ; <S2SV_EndBug> } | <S2SV_ModStart> str ) { iupEmscripten_Log ( "iupdrvFontGetStringWidth<S2SV_blank>being<S2SV_blank>called" ) ; <S2SV_ModStart> return emjsFont_GetStringWidth ( ih , |
2,553 | CWE-000 static bool too_many_workers ( struct worker_pool * pool ) { bool managing = mutex_is_locked ( & pool -> manager_arb ) ; int nr_idle = pool -> nr_idle + managing ; int nr_busy = pool -> nr_workers - nr_idle ; <S2SV_StartBug> if ( list_empty ( & pool -> idle_list ) ) <S2SV_EndBug> return false ; return nr_idle > 2 && ( nr_idle - 2 ) * MAX_IDLE_WORKERS_RATIO >= nr_busy ; } | <S2SV_ModStart> - nr_idle ; <S2SV_ModEnd> return nr_idle > |
2,554 | CWE-000 void hangouts_get_conversation_events ( HangoutsAccount * ha , const gchar * conv_id , gint64 since_timestamp ) { GetConversationRequest request ; ConversationId conversation_id ; <S2SV_StartBug> ConversationSpec conversation_spec ; <S2SV_EndBug> get_conversation_request__init ( & request ) ; request . request_header = hangouts_get_request_header ( ha ) ; conversation_spec__init ( & conversation_spec ) ; request . conversation_spec = & conversation_spec ; conversation_id__init ( & conversation_id ) ; conversation_id . id = ( gchar * ) conv_id ; conversation_spec . conversation_id = & conversation_id ; if ( since_timestamp > 0 ) { <S2SV_StartBug> EventContinuationToken event_continuation_token ; <S2SV_EndBug> request . has_include_event = TRUE ; request . include_event = TRUE ; request . has_max_events_per_conversation = TRUE ; request . max_events_per_conversation = 50 ; event_continuation_token__init ( & event_continuation_token ) ; event_continuation_token . event_timestamp = since_timestamp ; request . event_continuation_token = & event_continuation_token ; } hangouts_pblite_get_conversation ( ha , & request , hangouts_got_conversation_events , NULL ) ; hangouts_request_header_free ( request . request_header ) ; } | <S2SV_ModStart> ; ConversationSpec conversation_spec ; EventContinuationToken event_continuation_token <S2SV_ModStart> 0 ) { <S2SV_ModEnd> request . has_include_event |
2,555 | CWE-000 int main ( int argc , char * * argv ) { int i ; time_t seconds ; unsigned int reverse_seconds ; int result ; struct tm * breakdown ; char out_string [ 13 ] ; int last_minute = - 1 ; unsigned char big_display [ 16 ] ; int digit ; # if 0 struct tm { int tm_sec ; int tm_min ; int tm_hour ; int tm_mday ; int tm_mon ; int tm_year ; int tm_wday ; int tm_yday ; int tm_isdst ; } ; # endif signal ( SIGINT , quiet_and_exit ) ; result = display_init ( DISPLAY_I2C ) ; if ( result < 0 ) { display_type = DISPLAY_TEXT ; } while ( 1 ) { seconds = time ( NULL ) ; <S2SV_StartBug> reverse_seconds = reverse_bits32 ( seconds ) ; <S2SV_EndBug> bargraph_raw ( display_type , ( seconds >> 24 ) & 0xff , ( seconds >> 8 ) & 0xff , <S2SV_StartBug> 0 , <S2SV_EndBug> ( reverse_seconds >> 8 ) & 0xff , ( reverse_seconds >> 24 ) & 0xff , <S2SV_StartBug> 0 ) ; <S2SV_EndBug> breakdown = localtime ( & seconds ) ; if ( ( alarm_hour == breakdown -> tm_hour ) && ( alarm_minute == breakdown -> tm_min ) ) { if ( seconds & 1 ) sprintf ( out_string , "*<S2SV_blank>WAKE<S2SV_blank>UP!<S2SV_blank>*" ) ; else sprintf ( out_string , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" ) ; } else { if ( seconds & 1 ) { sprintf ( out_string , "<S2SV_blank><S2SV_blank>%2d:%02d<S2SV_blank>%s<S2SV_blank><S2SV_blank>" , breakdown -> tm_hour % 12 , breakdown -> tm_min , breakdown -> tm_hour > 11 ? "PM" : "AM" ) ; } else { sprintf ( out_string , "<S2SV_blank><S2SV_blank>%2d<S2SV_blank>%02d<S2SV_blank>%s<S2SV_blank><S2SV_blank>\\n" , breakdown -> tm_hour % 12 , breakdown -> tm_min , breakdown -> tm_hour > 11 ? "PM" : "AM" ) ; } } display_14seg_string ( display_type , out_string ) ; if ( breakdown -> tm_min != last_minute ) { last_minute = breakdown -> tm_min ; for ( i = 0 ; i < 16 ; i ++ ) big_display [ i ] = 0 ; digit = day_abbreviations [ breakdown -> tm_wday ] [ 0 ] ; big_display [ 0 ] = three_by_five [ digit ] [ 0 ] ; big_display [ 1 ] = three_by_five [ digit ] [ 1 ] ; big_display [ 2 ] = three_by_five [ digit ] [ 2 ] ; digit = day_abbreviations [ breakdown -> tm_wday ] [ 1 ] ; big_display [ 4 ] = three_by_five [ digit ] [ 0 ] ; big_display [ 5 ] = three_by_five [ digit ] [ 1 ] ; big_display [ 6 ] = three_by_five [ digit ] [ 2 ] ; digit = ( breakdown -> tm_mday / 10 ) + '0' ; if ( digit != '0' ) { big_display [ 9 ] = three_by_five [ digit ] [ 0 ] ; big_display [ 10 ] = three_by_five [ digit ] [ 1 ] ; big_display [ 11 ] = three_by_five [ digit ] [ 2 ] ; } digit = ( breakdown -> tm_mday % 10 ) + '0' ; big_display [ 13 ] = three_by_five [ digit ] [ 0 ] ; big_display [ 14 ] = three_by_five [ digit ] [ 1 ] ; big_display [ 15 ] = three_by_five [ digit ] [ 2 ] ; display_8x16_vertical ( display_type , big_display ) ; } usleep ( 200000 ) ; } display_shutdown ( display_type ) ; return 0 ; } | <S2SV_ModStart> NULL ) ; breakdown = localtime ( & seconds ) ; <S2SV_ModStart> & 0xff , ( 1 << ( ( breakdown -> tm_sec / 6 ) + 1 ) ) - 1 <S2SV_ModEnd> , ( reverse_seconds <S2SV_ModStart> & 0xff , ( 1 << ( ( breakdown -> tm_sec / 6 ) + 1 ) ) - 1 <S2SV_ModEnd> ) ; if |
2,556 | CWE-000 VOID OvsConntrackEntryCleaner ( PVOID data ) { POVS_CT_THREAD_CTX context = ( POVS_CT_THREAD_CTX ) data ; PLIST_ENTRY link , next ; POVS_CT_ENTRY entry ; <S2SV_StartBug> BOOLEAN success = TRUE ; <S2SV_EndBug> while ( success ) { <S2SV_StartBug> LOCK_STATE_EX lockState ; <S2SV_EndBug> NdisAcquireRWLockWrite ( ovsConntrackLockObj , & lockState , 0 ) ; if ( context -> exit ) { NdisReleaseRWLock ( ovsConntrackLockObj , & lockState ) ; break ; } INT64 threadSleepTimeout = - CT_CLEANUP_INTERVAL ; if ( ctTotalEntries ) { for ( int i = 0 ; i < CT_HASH_TABLE_SIZE ; i ++ ) { LIST_FORALL_SAFE ( & ovsConntrackTable [ i ] , link , next ) { entry = CONTAINING_RECORD ( link , OVS_CT_ENTRY , link ) ; if ( entry && OvsCtEntryExpired ( entry ) ) { OvsCtEntryDelete ( entry ) ; } } } } NdisReleaseRWLock ( ovsConntrackLockObj , & lockState ) ; KeWaitForSingleObject ( & context -> event , Executive , KernelMode , FALSE , ( LARGE_INTEGER * ) & threadSleepTimeout ) ; } PsTerminateSystemThread ( STATUS_SUCCESS ) ; } | <S2SV_ModStart> POVS_CT_ENTRY entry ; LOCK_STATE_EX lockState ; <S2SV_ModStart> success ) { if ( ovsConntrackLockObj == NULL ) { break ; } <S2SV_ModEnd> NdisAcquireRWLockWrite ( ovsConntrackLockObj |
2,557 | CWE-000 static void write_u16 ( int fd , uint16_t len , char * status ) { <S2SV_StartBug> char buf [ ARGSIZE ] = { ( len & ( 255 << 8 ) ) >> 8 , len & 255 } ; <S2SV_EndBug> if ( write ( fd , buf , ARGSIZE ) != ARGSIZE ) { * status = ERR_WRITE ; } } | <S2SV_ModStart> ] = { HBYTE ( len ) , LBYTE ( len ) <S2SV_ModEnd> } ; if |
2,558 | CWE-000 <S2SV_StartBug> void fCeedQFunctionSetContext ( int * qf , void * ctx , size_t * ctxsize , <S2SV_EndBug> int * err ) { CeedQFunction qf_ = CeedQFunction_dict [ * qf ] ; <S2SV_StartBug> struct fContext * newFContext ; CeedMalloc ( 1 , & newFContext ) ; <S2SV_EndBug> newFContext -> f = ( ( struct fContext * ) ( qf_ -> ctx ) ) -> f ; newFContext -> innerctx = ctx ; <S2SV_StartBug> * err = CeedQFunctionSetContext ( qf_ , newFContext , sizeof ( struct fContext ) ) ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> void fCeedQFunctionAddInput <S2SV_ModEnd> ( int * <S2SV_ModStart> * qf , const char * fieldname , CeedInt * ncomp , CeedEvalMode * emode , <S2SV_ModEnd> int * err <S2SV_ModStart> qf ] ; <S2SV_ModEnd> * err = <S2SV_ModStart> * err = CeedQFunctionAddInput <S2SV_ModEnd> ( qf_ , <S2SV_ModStart> ( qf_ , fieldname , * ncomp , * emode <S2SV_ModEnd> ) ; } |
2,559 | CWE-000 void my_connect_callback ( struct mosquitto * mosq , void * obj , int result ) { int i ; struct mosq_config * cfg ; assert ( obj ) ; cfg = ( struct mosq_config * ) obj ; if ( ! result ) { <S2SV_StartBug> mosquitto_subscribe ( mosq , NULL , "a/b" , 0 ) ; <S2SV_EndBug> } else { zsys_error ( "%s\\n" , mosquitto_connack_string ( result ) ) ; } } | <S2SV_ModStart> , "a/b" , 2 <S2SV_ModEnd> ) ; } |
2,560 | CWE-000 superframe_t * channels_generate_superframe ( const channel_t * const m_channel_list ) { superframe_entry_t * sf = calloc ( channels_count + 1 , sizeof ( superframe_entry_t ) ) ; unsigned int sf_size = 0 ; int rate = 0 ; for ( rate = 0 ; rate < RATE_END ; rate ++ ) { superframe_offset [ rate ] = sf_size ; sf_size += frame_size [ rate ] * get_spf ( rate ) ; } int i = 0 ; const channel_t * channel ; for ( channel = m_channel_list ; channel -> field [ 0 ] ; channel ++ ) { strcpy ( sf [ i ] . field , channel -> field ) ; sf [ i ] . type = superframe_type_array [ channel -> type ] ; sf [ i ] . spf = get_spf ( channel -> rate ) ; sf [ i ] . start = ( int64_t ) ( channel -> var - channel_data [ channel -> rate ] ) + superframe_offset [ channel -> rate ] ; sf [ i ] . skip = frame_size [ channel -> rate ] ; strcpy ( sf [ i ] . quantity , channel -> quantity ) ; strcpy ( sf [ i ] . units , channel -> units ) ; sf [ i ] . var = channel -> var ; i ++ ; } sf [ i ] . field [ 0 ] = '\\0' ; <S2SV_StartBug> return linklist_build_superframe ( sf , & channel_data_to_double , & channel_double_to_data ) ; <S2SV_EndBug> } | <S2SV_ModStart> = '\\0' ; printf ( "Finished<S2SV_blank>generating<S2SV_blank>superframe<S2SV_blank>entries\\n" ) ; |
2,561 | CWE-000 void rump_booter_init ( void * d ) { printc ( "~~~~~<S2SV_blank>vmid:<S2SV_blank>%d<S2SV_blank>~~~~~\\n" , vmid ) ; assert ( vmid == 0 ) ; printc ( "\\nRumpKernel<S2SV_blank>Boot<S2SV_blank>Start.\\n" ) ; cos2rump_setup ( ) ; rk_sched_init ( RK_SCHED_PERIOD_US ) ; printc ( "\\nSetting<S2SV_blank>up<S2SV_blank>arcv<S2SV_blank>for<S2SV_blank>hw<S2SV_blank>irq\\n" ) ; rk_hw_irq_alloc ( ) ; <S2SV_StartBug> rk_alloc_run ( RK_JSON_DEFAULT_HW ) ; <S2SV_EndBug> printc ( "\\nRumpKernel<S2SV_blank>Boot<S2SV_blank>done.\\n" ) ; cos_vm_exit ( ) ; return ; } | <S2SV_ModStart> ; rk_alloc_run ( RK_JSON_DEFAULT_QEMU <S2SV_ModEnd> ) ; printc |
2,562 | CWE-000 Tree * createTree ( Tree * tree , int * number ) { Tree * temp = newEmptyTree ( ) ; if ( temp == NULL ) { printf ( "createTree<S2SV_blank>ERROR:<S2SV_blank>not<S2SV_blank>possible<S2SV_blank>to<S2SV_blank>create<S2SV_blank>new<S2SV_blank>temp<S2SV_blank>empty<S2SV_blank>tree\\n\\n" ) ; return NULL ; } temp = tree ; Node * node ; if ( tree -> empty == 0 ) { <S2SV_StartBug> tree -> root -> value = * number ; <S2SV_EndBug> tree -> root -> right = NULL ; tree -> root -> left = NULL ; } else { if ( * number > tree -> root -> value ) { if ( tree -> root -> right == NULL ) { node = newEmptyNode ( ) ; if ( node == NULL ) { printf ( "createTree<S2SV_blank>ERROR:<S2SV_blank>not<S2SV_blank>possible<S2SV_blank>to<S2SV_blank>create<S2SV_blank>empty<S2SV_blank>node\\n\\n" ) ; return NULL ; } node -> value = * number ; tree -> root -> right = node ; } else { temp -> root = tree -> root -> right ; temp = createTree ( temp , number ) ; tree -> root -> right = temp -> root ; } } else { if ( tree -> root -> left == NULL ) { node = newEmptyNode ( ) ; if ( node == NULL ) { printf ( "createTree<S2SV_blank>ERROR:<S2SV_blank>not<S2SV_blank>possible<S2SV_blank>to<S2SV_blank>create<S2SV_blank>empty<S2SV_blank>node\\n\\n" ) ; return NULL ; } node -> value = * number ; tree -> root -> left = node ; } else { temp -> root = tree -> root -> left ; temp = createTree ( temp , number ) ; tree -> root -> left = temp -> root ; } } } return tree ; } | <S2SV_ModStart> tree -> root = newEmptyNode ( ) ; tree -> root |
2,563 | CWE-000 int BsdTcpServer ( unsigned short usPort ) { SlSockAddrIn_t sAddr ; SlSockAddrIn_t sLocalAddr ; int iCounter ; int iAddrSize ; int iSockID ; int iStatus ; int iNewSockID ; long lNonBlocking = 1 ; int iTestBufLen ; for ( iCounter = 0 ; iCounter < BUF_SIZE ; iCounter ++ ) { g_cBsdBuf [ iCounter ] = ( char ) ( iCounter % 10 ) ; } iTestBufLen = BUF_SIZE ; sLocalAddr . sin_family = SL_AF_INET ; sLocalAddr . sin_port = sl_Htons ( ( unsigned short ) usPort ) ; sLocalAddr . sin_addr . s_addr = 0 ; <S2SV_StartBug> LcdPrintf ( "Creating<S2SV_blank>socket" ) ; <S2SV_EndBug> iSockID = sl_Socket ( SL_AF_INET , SL_SOCK_STREAM , 0 ) ; if ( iSockID < 0 ) { sl_Close ( iSockID ) ; ASSERT_ON_ERROR ( SOCKET_CREATE_ERROR ) ; } iAddrSize = sizeof ( SlSockAddrIn_t ) ; iStatus = sl_Bind ( iSockID , ( SlSockAddr_t * ) & sLocalAddr , iAddrSize ) ; if ( iStatus < 0 ) { sl_Close ( iSockID ) ; ASSERT_ON_ERROR ( BIND_ERROR ) ; } <S2SV_StartBug> clearScreen ( ) ; <S2SV_EndBug> LcdPrintf ( "Listening" ) ; <S2SV_StartBug> iStatus = sl_Listen ( iSockID , 0 ) ; <S2SV_EndBug> if ( iStatus < 0 ) { sl_Close ( iSockID ) ; ASSERT_ON_ERROR ( LISTEN_ERROR ) ; } <S2SV_StartBug> LcdPrintf ( "Nonblocking" ) ; <S2SV_EndBug> iStatus = sl_SetSockOpt ( iSockID , SL_SOL_SOCKET , SL_SO_NONBLOCKING , & lNonBlocking , sizeof ( lNonBlocking ) ) ; if ( iStatus < 0 ) { sl_Close ( iSockID ) ; ASSERT_ON_ERROR ( SOCKET_OPT_ERROR ) ; } iNewSockID = SL_EAGAIN ; while ( iNewSockID < 0 ) { <S2SV_StartBug> clearScreen ( ) ; <S2SV_EndBug> <S2SV_StartBug> LcdPrintf ( "Waiting<S2SV_blank>to<S2SV_blank>connect" ) ; <S2SV_EndBug> iNewSockID = sl_Accept ( iSockID , ( struct SlSockAddr_t * ) & sAddr , ( SlSocklen_t * ) & iAddrSize ) ; if ( iNewSockID == SL_EAGAIN ) { <S2SV_StartBug> MAP_UtilsDelay ( 10000 ) ; <S2SV_EndBug> } else if ( iNewSockID < 0 ) { sl_Close ( iNewSockID ) ; sl_Close ( iSockID ) ; ASSERT_ON_ERROR ( ACCEPT_ERROR ) ; } } while ( 1 ) { iStatus = sl_Recv ( iNewSockID , g_cBsdBuf , iTestBufLen , 0 ) ; <S2SV_StartBug> clearScreen ( ) ; <S2SV_EndBug> LcdPrintf ( g_cBsdBuf ) ; <S2SV_StartBug> APIparse ( g_cBsdBuf ) ; <S2SV_EndBug> if ( iStatus <= 0 ) { sl_Close ( iNewSockID ) ; sl_Close ( iSockID ) ; break ; } } return SUCCESS ; } | <S2SV_ModStart> = 0 ; # ifdef DEBUG <S2SV_ModStart> "Creating<S2SV_blank>socket" ) ; # endif <S2SV_ModStart> ) ; } # ifdef DEBUG <S2SV_ModStart> "Listening" ) ; # endif <S2SV_ModStart> ) ; } # ifdef DEBUG <S2SV_ModStart> "Nonblocking" ) ; # endif <S2SV_ModStart> 0 ) { # ifdef DEBUG <S2SV_ModStart> "Waiting<S2SV_blank>to<S2SV_blank>connect" ) ; # endif <S2SV_ModStart> SL_EAGAIN ) { osi_Sleep ( 1000 <S2SV_ModEnd> ) ; } <S2SV_ModStart> 0 ) ; # ifdef DEBUG <S2SV_ModStart> g_cBsdBuf ) ; # endif <S2SV_ModStart> APIparse ( g_cBsdBuf ) ; osi_Sleep ( 1000 |
2,564 | CWE-000 void renameFile ( ) { if ( strlen ( fileName ) == 0 ) return ; if ( strcmp ( copyFrom , "" ) == 0 ) { if ( strcmp ( fileName , "." ) == 0 ) return ; if ( strcmp ( fileName , ".." ) == 0 ) <S2SV_StartBug> return ; <S2SV_EndBug> DRAGON_chdir ( curDir ) ; if ( dir_create ) DRAGON_mkdir ( fileName ) ; else { if ( debug_FileExists ( ( const char * ) fileName , 7 ) == FT_FILE ) { DRAGON_FILE * df = DRAGON_fopen ( fileName , "w" ) ; DRAGON_fclose ( df ) ; } } } else { char oldFile [ 256 ] ; char newFile [ 256 ] ; strcpy ( oldFile , copyFrom ) ; strcpy ( newFile , fileName ) ; strlwr ( oldFile ) ; strlwr ( newFile ) ; if ( strcmp ( oldFile , newFile ) == 0 ) { renameEntry ( copyFrom , "_TMP_REN.DSO" ) ; renameEntry ( "_TMP_REN.DSO" , fileName ) ; } else { renameEntry ( copyFrom , fileName ) ; } } } | <S2SV_ModStart> 0 ) return <S2SV_ModEnd> ; if ( |
2,565 | CWE-000 <S2SV_StartBug> struct net_buf * bt_mesh_adv_create_from_pool ( struct net_buf_pool * pool , <S2SV_EndBug> enum bt_mesh_adv_type type , u8_t xmit_count , u8_t xmit_int , s32_t timeout ) { struct bt_mesh_adv * adv ; struct net_buf * buf ; buf = net_buf_alloc ( pool , timeout ) ; if ( ! buf ) { return NULL ; } <S2SV_StartBug> adv = net_buf_user_data ( buf ) ; <S2SV_EndBug> memset ( adv , 0 , sizeof ( * adv ) ) ; adv -> type = type ; adv -> count = xmit_count ; adv -> adv_int = xmit_int ; return buf ; } | <S2SV_ModStart> net_buf_pool * pool , bt_mesh_adv_alloc_t get_id <S2SV_ModStart> } adv = get_id ( net_buf_id <S2SV_ModEnd> ( buf ) <S2SV_ModStart> ( buf ) ) ; BT_MESH_ADV ( buf ) = adv |
2,566 | CWE-000 struct CoreError itp_compileProgram ( struct Core * core , const char * sourceCode ) { struct Interpreter * interpreter = core -> interpreter ; itp_freeProgram ( core ) ; interpreter -> sourceCode = uppercaseString ( sourceCode ) ; if ( ! interpreter -> sourceCode ) return err_makeCoreError ( ErrorOutOfMemory , - 1 ) ; struct CoreError error = tok_tokenizeUppercaseProgram ( & interpreter -> tokenizer , interpreter -> sourceCode ) ; if ( error . code != ErrorNone ) { return error ; } struct DataManager * romDataManager = & interpreter -> romDataManager ; error = data_uppercaseImport ( romDataManager , interpreter -> sourceCode , false ) ; if ( error . code != ErrorNone ) return error ; struct DataEntry * entry0 = & romDataManager -> entries [ 0 ] ; if ( entry0 -> length == 0 && ( DATA_SIZE - data_currentSize ( romDataManager ) ) >= 1024 ) { data_setEntry ( romDataManager , 0 , "FONT" , ( uint8_t * ) DefaultCharacters , 1024 ) ; } interpreter -> pc = interpreter -> tokenizer . tokens ; interpreter -> pass = PassPrepare ; interpreter -> exitEvaluation = false ; interpreter -> subLevel = 0 ; interpreter -> numLabelStackItems = 0 ; interpreter -> isSingleLineIf = false ; enum ErrorCode errorCode ; do { errorCode = itp_evaluateCommand ( core ) ; } while ( errorCode == ErrorNone && interpreter -> pc -> type != TokenUndefined ) ; if ( errorCode != ErrorNone ) return err_makeCoreError ( errorCode , interpreter -> pc -> sourcePosition ) ; if ( interpreter -> numLabelStackItems > 0 ) { <S2SV_StartBug> struct LabelStackItem * item = & interpreter -> labelStackItems [ 0 ] ; <S2SV_EndBug> switch ( item -> type ) { case LabelTypeIF : case LabelTypeELSEIF : errorCode = ErrorIfWithoutEndIf ; break ; case LabelTypeFOR : errorCode = ErrorForWithoutNext ; break ; case LabelTypeDO : errorCode = ErrorDoWithoutLoop ; break ; case LabelTypeREPEAT : errorCode = ErrorRepeatWithoutUntil ; break ; case LabelTypeWHILE : errorCode = ErrorWhileWithoutWend ; break ; case LabelTypeSUB : errorCode = ErrorSubWithoutEndSub ; break ; case LabelTypeFORVar : case LabelTypeFORLimit : case LabelTypeELSE : case LabelTypeGOSUB : case LabelTypeCALL : case LabelTypeONCALL : break ; } if ( errorCode != ErrorNone ) { return err_makeCoreError ( errorCode , item -> token -> sourcePosition ) ; } } interpreter -> pc = interpreter -> tokenizer . tokens ; interpreter -> pass = PassRun ; interpreter -> state = StateEvaluate ; interpreter -> mode = ModeNone ; interpreter -> handlesPause = true ; interpreter -> currentDataToken = interpreter -> firstData ; interpreter -> currentDataValueToken = interpreter -> firstData + 1 ; interpreter -> isSingleLineIf = false ; interpreter -> lastFrameIOStatus . value = 0 ; interpreter -> seed = 0 ; memset ( & interpreter -> textLib , 0 , sizeof ( struct TextLib ) ) ; memset ( & interpreter -> spritesLib , 0 , sizeof ( struct SpritesLib ) ) ; interpreter -> textLib . core = core ; interpreter -> spritesLib . core = core ; return err_noCoreError ( ) ; } | <S2SV_ModStart> -> labelStackItems [ interpreter -> numLabelStackItems - 1 <S2SV_ModEnd> ] ; switch |
2,567 | CWE-000 static void check_actions_for ( xmlNode * rsc_entry , resource_t * rsc , node_t * node , pe_working_set_t * data_set ) { GListPtr gIter = NULL ; int offset = - 1 ; int interval = 0 ; int stop_index = 0 ; int start_index = 0 ; const char * task = NULL ; const char * interval_s = NULL ; xmlNode * rsc_op = NULL ; GListPtr op_list = NULL ; GListPtr sorted_op_list = NULL ; gboolean is_probe = FALSE ; gboolean did_change = FALSE ; CRM_CHECK ( node != NULL , return ) ; if ( is_set ( rsc -> flags , pe_rsc_orphan ) ) { resource_t * parent = uber_parent ( rsc ) ; if ( parent == NULL || parent -> variant < pe_clone || is_set ( parent -> flags , pe_rsc_unique ) ) { pe_rsc_trace ( rsc , "Skipping<S2SV_blank>param<S2SV_blank>check<S2SV_blank>for<S2SV_blank>%s<S2SV_blank>and<S2SV_blank>deleting:<S2SV_blank>orphan" , rsc -> id ) ; DeleteRsc ( rsc , node , FALSE , data_set ) ; } else { pe_rsc_trace ( rsc , "Skipping<S2SV_blank>param<S2SV_blank>check<S2SV_blank>for<S2SV_blank>%s<S2SV_blank>(orphan<S2SV_blank>clone)" , rsc -> id ) ; } return ; } else if ( pe_find_node_id ( rsc -> running_on , node -> details -> id ) == NULL ) { if ( check_rsc_parameters ( rsc , node , rsc_entry , FALSE , data_set ) ) { DeleteRsc ( rsc , node , FALSE , data_set ) ; } pe_rsc_trace ( rsc , "Skipping<S2SV_blank>param<S2SV_blank>check<S2SV_blank>for<S2SV_blank>%s:<S2SV_blank>no<S2SV_blank>longer<S2SV_blank>active<S2SV_blank>on<S2SV_blank>%s" , rsc -> id , node -> details -> uname ) ; return ; } pe_rsc_trace ( rsc , "Processing<S2SV_blank>%s<S2SV_blank>on<S2SV_blank>%s" , rsc -> id , node -> details -> uname ) ; if ( check_rsc_parameters ( rsc , node , rsc_entry , TRUE , data_set ) ) { DeleteRsc ( rsc , node , FALSE , data_set ) ; } for ( rsc_op = __xml_first_child ( rsc_entry ) ; rsc_op != NULL ; rsc_op = __xml_next_element ( rsc_op ) ) { if ( crm_str_eq ( ( const char * ) rsc_op -> name , XML_LRM_TAG_RSC_OP , TRUE ) ) { op_list = g_list_prepend ( op_list , rsc_op ) ; } } sorted_op_list = g_list_sort ( op_list , sort_op_by_callid ) ; calculate_active_ops ( sorted_op_list , & start_index , & stop_index ) ; for ( gIter = sorted_op_list ; gIter != NULL ; gIter = gIter -> next ) { xmlNode * rsc_op = ( xmlNode * ) gIter -> data ; offset ++ ; if ( start_index < stop_index ) { continue ; } else if ( offset < start_index ) { continue ; } is_probe = FALSE ; did_change = FALSE ; task = crm_element_value ( rsc_op , XML_LRM_ATTR_TASK ) ; interval_s = crm_element_value ( rsc_op , XML_LRM_ATTR_INTERVAL ) ; interval = crm_parse_int ( interval_s , "0" ) ; if ( interval == 0 && safe_str_eq ( task , RSC_STATUS ) ) { is_probe = TRUE ; } if ( interval > 0 && ( is_set ( rsc -> flags , pe_rsc_maintenance ) || node -> details -> maintenance ) ) { CancelXmlOp ( rsc , rsc_op , node , "maintenance<S2SV_blank>mode" , data_set ) ; } else if ( is_probe || safe_str_eq ( task , RSC_START ) || safe_str_eq ( task , RSC_PROMOTE ) || interval > 0 || safe_str_eq ( task , RSC_MIGRATED ) ) { did_change = check_action_definition ( rsc , node , rsc_op , data_set ) ; } if ( did_change && get_failcount ( node , rsc , NULL , data_set ) ) { char * key = NULL ; action_t * action_clear = NULL ; key = generate_op_key ( rsc -> id , CRM_OP_CLEAR_FAILCOUNT , 0 ) ; action_clear = custom_action ( rsc , key , CRM_OP_CLEAR_FAILCOUNT , node , FALSE , TRUE , data_set ) ; set_bit ( action_clear -> flags , pe_action_runnable ) ; <S2SV_StartBug> } <S2SV_EndBug> } g_list_free ( sorted_op_list ) ; } | <S2SV_ModStart> pe_action_runnable ) ; crm_notice ( "Clearing<S2SV_blank>failure<S2SV_blank>of<S2SV_blank>%s<S2SV_blank>on<S2SV_blank>%s<S2SV_blank>" "because<S2SV_blank>action<S2SV_blank>definition<S2SV_blank>changed<S2SV_blank>" CRM_XS "<S2SV_blank>%s" , rsc -> id , node -> details -> uname , action_clear -> uuid ) ; |
2,568 | CWE-000 static ssize_t wcnss_ctrl_read ( struct file * fp , char __user * user_buffer , size_t count , loff_t * position ) { int rc = 0 ; <S2SV_StartBug> if ( ! penv || ! penv -> device_opened ) <S2SV_EndBug> return - EFAULT ; rc = wait_event_interruptible ( penv -> wlan_config . wcnss_ctrl_wait , ( penv -> wlan_config . irisStatus == IRIS_DETECTION_SUCCESS || penv -> wlan_config . irisStatus == IRIS_DETECTION_FAIL ) ) ; if ( rc < 0 ) return rc ; mutex_lock ( & penv -> ctrl_lock ) ; count = sizeof ( penv -> wlan_config . irisStatus ) ; rc = copy_to_user ( user_buffer , ( void * ) & ( penv -> wlan_config . irisStatus ) , count ) ; mutex_unlock ( & penv -> ctrl_lock ) ; pr_info ( "%s:<S2SV_blank>iris<S2SV_blank>detection<S2SV_blank>status:<S2SV_blank>%d\\n" , __func__ , penv -> wlan_config . irisStatus ) ; return rc ; } | <S2SV_ModStart> ( ! penv <S2SV_ModEnd> ) return - |
2,569 | CWE-000 <S2SV_StartBug> void addBlock ( VA * address , int size , int offset ) <S2SV_EndBug> { struct block * newBlock ; newBlock = createBlock ( address , size , offset ) ; if ( Manager -> blocks == NULL ) { Manager -> blocks = newBlock ; return ; } struct block * curBlock = Manager -> blocks ; while ( curBlock != NULL ) { if ( newBlock -> offset == 0 ) { Manager -> blocks = newBlock ; newBlock -> next = curBlock ; return ; } if ( curBlock -> next == NULL ) { curBlock -> next = newBlock ; return ; } if ( curBlock -> offset < newBlock -> offset && curBlock -> next -> offset > newBlock -> offset ) { newBlock -> next = curBlock -> next ; curBlock -> next = newBlock ; return ; } curBlock = curBlock -> next ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> addBlock ( VA <S2SV_ModEnd> address , int <S2SV_ModStart> next ; } return ; |
2,570 | CWE-000 CURLcode Curl_http_auth_act ( struct connectdata * conn ) { struct Curl_easy * data = conn -> data ; bool pickhost = FALSE ; bool pickproxy = FALSE ; CURLcode result = CURLE_OK ; unsigned long authmask = ~ 0ul ; if ( ! conn -> oauth_bearer ) authmask &= ( unsigned long ) ~ CURLAUTH_BEARER ; if ( 100 <= data -> req . httpcode && 199 >= data -> req . httpcode ) return CURLE_OK ; if ( data -> state . authproblem ) return data -> set . http_fail_on_error ? CURLE_HTTP_RETURNED_ERROR : CURLE_OK ; if ( ( conn -> bits . user_passwd || conn -> oauth_bearer ) && ( ( data -> req . httpcode == 401 ) || ( conn -> bits . authneg && data -> req . httpcode < 300 ) ) ) { pickhost = pickoneauth ( & data -> state . authhost , authmask ) ; if ( ! pickhost ) data -> state . authproblem = TRUE ; } if ( conn -> bits . proxy_user_passwd && ( ( data -> req . httpcode == 407 ) || ( conn -> bits . authneg && data -> req . httpcode < 300 ) ) ) { pickproxy = pickoneauth ( & data -> state . authproxy , authmask & ~ CURLAUTH_BEARER ) ; if ( ! pickproxy ) data -> state . authproblem = TRUE ; } if ( pickhost || pickproxy ) { <S2SV_StartBug> Curl_safefree ( data -> req . newurl ) ; <S2SV_EndBug> data -> req . newurl = strdup ( data -> change . url ) ; if ( ! data -> req . newurl ) return CURLE_OUT_OF_MEMORY ; if ( ( data -> set . httpreq != HTTPREQ_GET ) && ( data -> set . httpreq != HTTPREQ_HEAD ) && ! conn -> bits . rewindaftersend ) { result = http_perhapsrewind ( conn ) ; if ( result ) return result ; } <S2SV_StartBug> } <S2SV_EndBug> else if ( ( data -> req . httpcode < 300 ) && ( ! data -> state . authhost . done ) && conn -> bits . authneg ) { if ( ( data -> set . httpreq != HTTPREQ_GET ) && ( data -> set . httpreq != HTTPREQ_HEAD ) ) { data -> req . newurl = strdup ( data -> change . url ) ; if ( ! data -> req . newurl ) return CURLE_OUT_OF_MEMORY ; data -> state . authhost . done = TRUE ; } } if ( http_should_fail ( conn ) ) { failf ( data , "The<S2SV_blank>requested<S2SV_blank>URL<S2SV_blank>returned<S2SV_blank>error:<S2SV_blank>%d" , data -> req . httpcode ) ; result = CURLE_HTTP_RETURNED_ERROR ; } return result ; } | <S2SV_ModStart> pickproxy ) { <S2SV_ModEnd> if ( ( <S2SV_ModStart> result ; } Curl_safefree ( data -> req . newurl ) ; data -> req . newurl = strdup ( data -> change . url ) ; if ( ! data -> req . newurl ) return CURLE_OUT_OF_MEMORY ; |
2,571 | CWE-000 <S2SV_StartBug> int _impl_k_queue_alloc_prepend ( struct k_queue * queue , void * data ) <S2SV_EndBug> { return queue_insert ( queue , NULL , data , true ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> s32_t <S2SV_ModEnd> _impl_k_queue_alloc_prepend ( struct |
2,572 | CWE-000 static void gschem_page_view_init ( GschemPageView * view ) { g_return_if_fail ( view != NULL ) ; view -> hadjustment = NULL ; view -> vadjustment = NULL ; geometry_cache_create ( view ) ; <S2SV_StartBug> view -> page = NULL ; <S2SV_EndBug> view -> configured = FALSE ; view -> doing_pan = FALSE ; view -> pan_x = 0 ; view -> pan_y = 0 ; view -> throttle = 0 ; g_signal_connect ( view , "set-scroll-adjustments" , G_CALLBACK ( set_scroll_adjustments ) , NULL ) ; g_signal_connect ( view , "realize" , G_CALLBACK ( event_realize ) , NULL ) ; g_signal_connect ( view , "unrealize" , G_CALLBACK ( event_unrealize ) , NULL ) ; } | <S2SV_ModStart> ; view -> _page <S2SV_ModEnd> = NULL ; |
2,573 | CWE-000 Obj DiffMat8BitMat8Bit ( Obj ml , Obj mr ) { Obj diff ; UInt q ; UInt i ; Obj row ; Obj type ; Obj info ; FF f ; FFV minusOne ; Obj mone ; UInt ll , lr , wl , wr , ld ; ll = LEN_MAT8BIT ( ml ) ; lr = LEN_MAT8BIT ( mr ) ; <S2SV_StartBug> wl = LEN_MAT8BIT ( ELM_MAT8BIT ( ml , 1 ) ) ; <S2SV_EndBug> wr = LEN_MAT8BIT ( ELM_MAT8BIT ( mr , 1 ) ) ; if ( ( ( ll > lr ) && ( wr > wl ) ) || ( ( lr > ll ) && ( wl > wr ) ) ) return TRY_NEXT_METHOD ; if ( ll > lr ) { ld = ll ; assert ( wl > wr ) ; } else { ld = lr ; assert ( wr >= wl ) ; } q = FIELD_VEC8BIT ( ELM_MAT8BIT ( ml , 1 ) ) ; if ( q % 2 == 0 ) return SumMat8BitMat8Bit ( ml , mr ) ; diff = NewBag ( T_POSOBJ , sizeof ( Obj ) * ( ld + 2 ) ) ; type = TypeMat8Bit ( q , IS_MUTABLE_OBJ ( ml ) || IS_MUTABLE_OBJ ( mr ) ) ; TYPE_POSOBJ ( diff ) = type ; SET_LEN_MAT8BIT ( diff , ld ) ; type = TypeVec8BitLocked ( q , IS_MUTABLE_OBJ ( ELM_MAT8BIT ( ml , 1 ) ) || IS_MUTABLE_OBJ ( ELM_MAT8BIT ( mr , 1 ) ) ) ; info = GetFieldInfo8Bit ( q ) ; f = FiniteField ( P_FIELDINFO_8BIT ( info ) , D_FIELDINFO_8BIT ( info ) ) ; minusOne = NEG_FFV ( 1 , SUCC_FF ( f ) ) ; mone = NEW_FFE ( f , minusOne ) ; for ( i = 1 ; i <= ld ; i ++ ) { if ( i > ll ) row = MultVec8BitFFE ( ELM_MAT8BIT ( mr , i ) , mone ) ; else if ( i > lr ) row = CopyVec8Bit ( ELM_MAT8BIT ( ml , i ) , 1 ) ; else row = SumVec8BitVec8BitMult ( ELM_MAT8BIT ( ml , i ) , ELM_MAT8BIT ( mr , i ) , mone ) ; SetTypeDatObj ( row , type ) ; SET_ELM_MAT8BIT ( diff , i , row ) ; CHANGED_BAG ( diff ) ; } return diff ; } | <S2SV_ModStart> ; wl = LEN_VEC8BIT ( ELM_MAT8BIT ( ml , 1 ) ) ; wr = LEN_VEC8BIT <S2SV_ModEnd> ( ELM_MAT8BIT ( |
2,574 | CWE-000 void log_config_init ( char * config_file ) { if ( NULL == g_log_config_handler ) { g_log_config_handler = ( stLogConfig * ) malloc ( sizeof ( stLogConfig ) ) ; if ( NULL == g_log_config_handler ) { fprintf ( stderr , "log<S2SV_blank>handler<S2SV_blank>malloc<S2SV_blank>error!\\n" ) ; return ; } <S2SV_StartBug> } <S2SV_EndBug> if ( NULL == config_file ) snprintf ( g_log_config_handler -> fileName , CONFIG_FILE_LENGTH_MAX - 1 , "log.ini" ) ; else snprintf ( g_log_config_handler -> fileName , CONFIG_FILE_LENGTH_MAX - 1 , config_file ) ; log_config_read ( ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> return ; } <S2SV_ModEnd> if ( NULL <S2SV_ModStart> ) ; } } |
2,575 | CWE-000 void vim_beep ( unsigned val ) { # ifdef FEAT_EVAL called_vim_beep = TRUE ; # endif if ( emsg_silent == 0 ) { if ( ! ( ( bo_flags & val ) || ( bo_flags & BO_ALL ) ) ) { # ifdef ELAPSED_FUNC static int did_init = FALSE ; static ELAPSED_TYPE start_tv ; if ( ! did_init || ELAPSED_FUNC ( start_tv ) > 500 ) { did_init = TRUE ; ELAPSED_INIT ( start_tv ) ; # endif if ( p_vb # ifdef FEAT_GUI && ! ( gui . in_use && gui . starting ) # endif ) <S2SV_StartBug> out_str_cf ( T_VB ) ; <S2SV_EndBug> else out_char ( BELL ) ; # ifdef ELAPSED_FUNC } # endif } if ( vim_strchr ( p_debug , 'e' ) != NULL ) { msg_source ( HL_ATTR ( HLF_W ) ) ; msg_attr ( ( char_u * ) _ ( "Beep!" ) , HL_ATTR ( HLF_W ) ) ; } } } | <S2SV_ModStart> # endif ) { <S2SV_ModStart> T_VB ) ; # ifdef FEAT_VTP if ( has_vtp_working ( ) != 0 # ifdef FEAT_TERMGUICOLORS && p_tgc # endif ) { redraw_later ( CLEAR ) ; update_screen ( 0 ) ; redrawcmd ( ) ; } # endif } |
2,576 | CWE-000 static void dnsout_send_notify ( zone_type * z , names_view_type view ) { <S2SV_StartBug> rrset_type * rrset = NULL ; <S2SV_EndBug> ldns_rr * soa = NULL ; if ( ! z -> notify ) { ods_log_error ( "[%s]<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>send<S2SV_blank>notify<S2SV_blank>for<S2SV_blank>zone<S2SV_blank>%s:<S2SV_blank>no<S2SV_blank>notify<S2SV_blank>" "handler" , adapter_str , z -> name ) ; return ; } ods_log_assert ( z -> adoutbound ) ; ods_log_assert ( z -> adoutbound -> config ) ; ods_log_assert ( z -> adoutbound -> type == ADAPTER_DNS ) ; ods_log_assert ( z -> name ) ; <S2SV_StartBug> rrset = zone_lookup_apex_rrset ( view , LDNS_RR_TYPE_SOA , NULL ) ; <S2SV_EndBug> <S2SV_StartBug> ods_log_assert ( rrset ) ; <S2SV_EndBug> <S2SV_StartBug> soa = ldns_rr_clone ( getsoa ( rrset ) ) ; <S2SV_EndBug> notify_enable ( z -> notify , soa ) ; } | <S2SV_ModStart> view ) { <S2SV_ModEnd> ldns_rr * soa <S2SV_ModStart> name ) ; names_viewlookupone ( view , NULL <S2SV_ModEnd> , LDNS_RR_TYPE_SOA , <S2SV_ModStart> LDNS_RR_TYPE_SOA , NULL , & soa <S2SV_ModStart> ; ods_log_assert ( soa <S2SV_ModEnd> ) ; soa <S2SV_ModStart> = ldns_rr_clone ( soa <S2SV_ModEnd> ) ; notify_enable |
2,577 | CWE-000 int main ( int argc , char * argv [ ] ) { int status = 0 ; BOOL abort = FALSE ; uint8_t index = 0 ; printf ( "\\n%s\\n" , MAIN_PROG_NAME ) ; <S2SV_StartBug> printf ( "Version:<S2SV_blank>%s\\n" , VERSION ) ; <S2SV_EndBug> printf ( "%s\\n\\n" , MAIN_COPYRIGHT ) ; if ( MAIN_RET_OK != main_init ( ) ) { abort = TRUE ; } else if ( CMDLINEPARSER_RET_OK != cmdLineParser_parse ( main_clpConfig , MAIN_ARRAY_NUM ( main_clpConfig ) , argc , argv ) ) { abort = TRUE ; } else if ( TRUE == main_cmdLineArgs . showHelp ) { printf ( "Usage:<S2SV_blank>%s<S2SV_blank><options>\\n\\n" , main_cmdLineArgs . progName ) ; printf ( "Options:\\n" ) ; cmdLineParser_show ( main_clpConfig , MAIN_ARRAY_NUM ( main_clpConfig ) ) ; } else { if ( TRUE == main_cmdLineArgs . verbose ) { log_setLevel ( LOG_LEVEL_INFO | LOG_LEVEL_DEBUG | LOG_LEVEL_WARNING | LOG_LEVEL_ERROR | LOG_LEVEL_FATAL ) ; } eeprom_load ( MAIN_EEPROM_FILENAME ) ; if ( VSCP_CORE_RET_OK != vscp_core_init ( ) ) { abort = TRUE ; } else { main_showKeyTable ( ) ; printf ( "\\n" ) ; if ( NULL != main_cmdLineArgs . daemonAddr ) { VSCP_TP_ADAPTER_RET ret = VSCP_TP_ADAPTER_RET_OK ; log_printf ( "Connecting<S2SV_blank>...\\n" ) ; ret = vscp_tp_adapter_connect ( main_cmdLineArgs . daemonAddr , main_cmdLineArgs . daemonUser , main_cmdLineArgs . daemonPassword , main_cmdLineArgs . lvl ) ; if ( VSCP_TP_ADAPTER_RET_OK != ret ) { printf ( "Connection<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>%s.\\n" , main_cmdLineArgs . daemonAddr ) ; if ( VSCP_TP_ADAPTER_RET_INVALID_USER == ret ) { log_printf ( "Invalid<S2SV_blank>user.\\n" ) ; } else if ( VSCP_TP_ADAPTER_RET_INVALID_PASSWORD == ret ) { log_printf ( "Invalid<S2SV_blank>password.\\n" ) ; } else if ( VSCP_TP_ADAPTER_RET_TIMEOUT == ret ) { log_printf ( "Connection<S2SV_blank>timeout.\\n" ) ; } abort = TRUE ; } else { log_printf ( "Connection<S2SV_blank>successful.\\n" ) ; } } } if ( FALSE == abort ) { if ( NULL != main_cmdLineArgs . nodeGuid ) { uint8_t nodeGuid [ 16 ] = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 } ; if ( VSCP_ERROR_SUCCESS != vscphlp_getGuidFromStringToArray ( nodeGuid , main_cmdLineArgs . nodeGuid ) ) { log_printf ( "Invalid<S2SV_blank>node<S2SV_blank>GUID.\\n" ) ; } else { for ( index = 0 ; index < MAIN_ARRAY_NUM ( nodeGuid ) ; ++ index ) { vscp_ps_writeGUID ( MAIN_ARRAY_NUM ( nodeGuid ) - index - 1 , nodeGuid [ index ] ) ; } } } if ( TRUE == main_cmdLineArgs . disableHeartbeat ) { vscp_core_enableHeartbeat ( FALSE ) ; } if ( VSCP_THREAD_RET_OK != vscp_thread_start ( ) ) { abort = TRUE ; } else if ( FALSE == main_cmdLineArgs . disableTemperature ) { if ( TEMPERATURE_SIM_RET_OK != temperature_sim_start ( ) ) { LOG_ERROR ( "Temperature<S2SV_blank>simulation<S2SV_blank>failed." ) ; } } } if ( FALSE == abort ) { main_loop ( & main_cmdLineArgs ) ; } printf ( "Please<S2SV_blank>wait<S2SV_blank>...\\n" ) ; temperature_sim_stop ( ) ; vscp_thread_stop ( ) ; if ( NULL != main_cmdLineArgs . daemonAddr ) { vscp_tp_adapter_disconnect ( ) ; } } if ( TRUE == abort ) { printf ( "\\nAborted.\\n" ) ; if ( 0 == status ) { status = 1 ; } } main_deInit ( ) ; return status ; } | <S2SV_ModStart> ; printf ( "Version:<S2SV_blank>%s<S2SV_blank>(%s)\\n" , VERSION , BUILDTYPE <S2SV_ModEnd> ) ; printf |
2,578 | CWE-000 void param_expension ( char * * value , t_params * params ) { char * ptr ; int state ; if ( ! value || ! * value ) return ; ptr = * value ; state = 0 ; while ( * ptr ) { printf ( "in<S2SV_blank>while<S2SV_blank>char:%c\\t%d\\t%p\\t%d\\n" , * ptr , * ptr , ptr , state ) ; if ( * ptr == '\\\\' ) { <S2SV_StartBug> ptr ++ ; <S2SV_EndBug> } else if ( state != - 2 && * ptr == 34 ) { state = ( state == - 1 ) ? 1 : - 1 ; ptr ++ ; printf ( "changement<S2SV_blank>state:%d\\n" , state ) ; } else if ( state != - 1 && * ptr == 39 ) { state = ( state == - 2 ) ? 1 : - 2 ; ptr ++ ; printf ( "changement<S2SV_blank>state:%d\\n" , state ) ; } else if ( * ptr == '$' && state != - 2 ) { printf ( "DEBUG<S2SV_blank>|<S2SV_blank>ptr:%p\\n" , ptr ) ; if ( * ( ptr + 1 ) > 47 && * ( ptr + 1 ) < 127 ) { printf ( "GO<S2SV_blank>EXPENSION\\n" ) ; do_param_expension ( value , & ptr , params ) ; state = 1 ; } } else ++ ptr ; } } | <S2SV_ModStart> ) { ptr += 2 <S2SV_ModEnd> ; } else |
2,579 | CWE-000 <S2SV_StartBug> struct dentry * ovl_lookup_temp ( struct dentry * workdir , struct dentry * dentry ) <S2SV_EndBug> { struct dentry * temp ; char name [ 20 ] ; static atomic_t temp_id = ATOMIC_INIT ( 0 ) ; snprintf ( name , sizeof ( name ) , "#%x" , atomic_inc_return ( & temp_id ) ) ; temp = lookup_one_len ( name , workdir , strlen ( name ) ) ; if ( ! IS_ERR ( temp ) && temp -> d_inode ) { pr_err ( "overlayfs:<S2SV_blank>workdir/%s<S2SV_blank>already<S2SV_blank>exists\\n" , name ) ; dput ( temp ) ; temp = ERR_PTR ( - EIO ) ; } return temp ; } | <S2SV_ModStart> dentry * workdir <S2SV_ModEnd> ) { struct |
2,580 | CWE-000 <S2SV_StartBug> void particles_indices ( int grid [ 3 ] ) { <S2SV_EndBug> if ( particles_gentype == PARTICLES_GT_QUEUE ) { grid [ 0 ] = particles_g_r - 1 ; grid [ 1 ] = particles_g_param1 - 1 ; grid [ 2 ] = particles_g_param2 - 1 ; } else { grid [ 0 ] = particles_r - 1 ; grid [ 1 ] = particles_param1 - 1 ; grid [ 2 ] = particles_param2 - 1 ; <S2SV_StartBug> } <S2SV_EndBug> if ( grid [ 0 ] < 0 ) grid [ 0 ] = particles_rn - 1 ; if ( grid [ 1 ] < 0 ) grid [ 1 ] = particles_param1n - 1 ; if ( grid [ 2 ] < 0 ) grid [ 2 ] = particles_param2n - 1 ; } | <S2SV_ModStart> 3 ] ) <S2SV_ModEnd> { grid [ <S2SV_ModStart> - 1 ; <S2SV_ModEnd> if ( grid |
2,581 | CWE-000 char * getLineSeparator ( gameParams * game ) { char * separator ; int N , m , i ; m = game -> m ; N = game -> N ; separator = malloc ( sizeof ( char ) * ( 4 * N + m + 1 ) + 1 ) ; if ( separator == NULL ) { freeSudokuGame ( game ) ; printMallocFailed ( ) ; <S2SV_StartBug> exit ( EXIT_FAILURE ) ; <S2SV_EndBug> } for ( i = 0 ; i < 4 * N + m + 1 ; i ++ ) { separator [ i ] = '-' ; } separator [ i ] = '\\0' ; return separator ; } | <S2SV_ModStart> ; exit ( 0 <S2SV_ModEnd> ) ; } |
2,582 | CWE-000 __attribute__ ( ( nonnull ( 1 , 2 ) , nothrow , warn_unused_result ) ) static int removes_front_test ( darr_t * restrict darr , int nums [ ] , size_t nnum ) { int * restrict tmps ; <S2SV_StartBug> printf ( "removes<S2SV_blank>front<S2SV_blank>test<S2SV_blank>(nnum=%d)\\n" , ( int ) nnum ) ; <S2SV_EndBug> tmps = malloc ( sizeof ( int ) * nnum ) ; error_check ( tmps == NULL ) { return - 1 ; } removes_front_darr ( darr , ( size_t ) 0 , tmps , nnum ) ; error_check ( trim_cap_darr ( darr , ( size_t ) 0 ) != 0 ) { puts ( "error<S2SV_blank>-7" ) ; fflush ( stdout ) ; free ( tmps ) ; return - 7 ; } error_check ( memcmp ( nums , tmps , nnum ) != 0 ) { puts ( "error<S2SV_blank>-8" ) ; fflush ( stdout ) ; free ( tmps ) ; return - 8 ; } free ( tmps ) ; return 0 ; } | <S2SV_ModStart> int ) nnum ) ; fflush ( stdout |
2,583 | CWE-000 void * shoes_native_menu_new ( shoes_menu * mn ) { GtkWidget * menu ; GtkWidget * mi ; menu = gtk_menu_new ( ) ; mi = gtk_menu_item_new_with_label ( mn -> title ) ; gtk_menu_item_set_submenu ( GTK_MENU_ITEM ( mi ) , menu ) ; mn -> native = ( void * ) mi ; mn -> extra = ( void * ) menu ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ) menu ; return mn -> native ; |
2,584 | CWE-000 void sqlite3GenerateRowDelete ( <S2SV_StartBug> Parse * pParse , <S2SV_EndBug> Table * pTab , Trigger * pTrigger , int iDataCur , int iIdxCur , int iPk , i16 nPk , u8 count , u8 onconf , u8 eMode , int iIdxNoSeek ) { Vdbe * v = pParse -> pVdbe ; int iOld = 0 ; int iLabel ; u8 opSeek ; assert ( v ) ; VdbeModuleComment ( ( v , "BEGIN:<S2SV_blank>GenRowDel(%d,%d,%d,%d)" , iDataCur , iIdxCur , iPk , ( int ) nPk ) ) ; iLabel = sqlite3VdbeMakeLabel ( v ) ; opSeek = HasRowid ( pTab ) ? OP_NotExists : OP_NotFound ; if ( eMode == ONEPASS_OFF ) { sqlite3VdbeAddOp4Int ( v , opSeek , iDataCur , iLabel , iPk , nPk ) ; VdbeCoverageIf ( v , opSeek == OP_NotExists ) ; VdbeCoverageIf ( v , opSeek == OP_NotFound ) ; } if ( sqlite3FkRequired ( pParse , pTab , 0 , 0 ) || pTrigger ) { u32 mask ; int iCol ; int addrStart ; mask = sqlite3TriggerColmask ( <S2SV_StartBug> pParse , pTrigger , 0 , 0 , TRIGGER_BEFORE | TRIGGER_AFTER , pTab , onconf <S2SV_EndBug> ) ; mask |= sqlite3FkOldmask ( pParse , pTab ) ; iOld = pParse -> nMem + 1 ; pParse -> nMem += ( 1 + pTab -> nCol ) ; sqlite3VdbeAddOp2 ( v , OP_Copy , iPk , iOld ) ; for ( iCol = 0 ; iCol < pTab -> nCol ; iCol ++ ) { testcase ( mask != 0xffffffff && iCol == 31 ) ; testcase ( mask != 0xffffffff && iCol == 32 ) ; if ( mask == 0xffffffff || ( iCol <= 31 && ( mask & MASKBIT32 ( iCol ) ) != 0 ) ) { sqlite3ExprCodeGetColumnOfTable ( v , pTab , iDataCur , iCol , iOld + iCol + 1 ) ; } } addrStart = sqlite3VdbeCurrentAddr ( v ) ; <S2SV_StartBug> sqlite3CodeRowTrigger ( pParse , pTrigger , <S2SV_EndBug> TK_DELETE , 0 , TRIGGER_BEFORE , pTab , iOld , onconf , iLabel ) ; if ( addrStart < sqlite3VdbeCurrentAddr ( v ) ) { sqlite3VdbeAddOp4Int ( v , opSeek , iDataCur , iLabel , iPk , nPk ) ; VdbeCoverageIf ( v , opSeek == OP_NotExists ) ; VdbeCoverageIf ( v , opSeek == OP_NotFound ) ; testcase ( iIdxNoSeek >= 0 ) ; iIdxNoSeek = - 1 ; } sqlite3FkCheck ( pParse , pTab , iOld , 0 , 0 , 0 ) ; } if ( pTab -> pSelect == 0 ) { u8 p5 = 0 ; sqlite3GenerateRowIndexDelete ( pParse , pTab , iDataCur , iIdxCur , 0 , iIdxNoSeek ) ; sqlite3VdbeAddOp2 ( v , OP_Delete , iDataCur , ( count ? OPFLAG_NCHANGE : 0 ) ) ; if ( pParse -> nested == 0 || 0 == sqlite3_stricmp ( pTab -> zName , "sqlite_stat1" ) ) { sqlite3VdbeAppendP4 ( v , ( char * ) pTab , P4_TABLE ) ; } if ( eMode != ONEPASS_OFF ) { sqlite3VdbeChangeP5 ( v , OPFLAG_AUXDELETE ) ; } if ( iIdxNoSeek >= 0 && iIdxNoSeek != iDataCur ) { sqlite3VdbeAddOp1 ( v , OP_Delete , iIdxNoSeek ) ; } if ( eMode == ONEPASS_MULTI ) p5 |= OPFLAG_SAVEPOSITION ; sqlite3VdbeChangeP5 ( v , p5 ) ; } <S2SV_StartBug> sqlite3FkActions ( pParse , pTab , 0 , iOld , 0 , 0 ) ; <S2SV_EndBug> <S2SV_StartBug> sqlite3CodeRowTrigger ( pParse , pTrigger , <S2SV_EndBug> TK_DELETE , 0 , TRIGGER_AFTER , pTab , iOld , onconf , iLabel ) ; sqlite3VdbeResolveLabel ( v , iLabel ) ; VdbeModuleComment ( ( v , "END:<S2SV_blank>GenRowDel()" ) ) ; } | <S2SV_ModStart> Parse * pParse , int iDb <S2SV_ModStart> ( pParse , iDb , <S2SV_ModStart> ( pParse , iDb , <S2SV_ModStart> ( pParse , iDb , <S2SV_ModStart> ( pParse , iDb , |
2,585 | CWE-000 void scale_bilinear_prepare ( unsigned char * ( * index ) ( const struct imagebuffer * image , size_t x , size_t y ) , unsigned char * restrict out_x0y0 , unsigned char * restrict out_x0y1 , unsigned char * restrict out_x1y0 , unsigned char * restrict out_x1y1 , size_t * restrict out_xf , size_t * restrict out_yf , const struct imagebuffer * src , size_t width , size_t height ) { size_t stepy = src -> height - 2 ; size_t stepx = src -> width - 2 ; size_t yerror = 0 ; size_t yi = 0 ; for ( size_t k = 0 , j = 0 ; j < height ; ++ j , yerror += stepy ) { while ( yerror >= height - 1 ) { yerror -= height - 1 ; ++ yi ; } size_t xerror = 0 ; size_t xi = 0 ; for ( size_t i = 0 ; i < width ; ++ i , ++ k , xerror += stepx ) { while ( xerror >= width - 1 ) { xerror -= width - 1 ; ++ xi ; } const size_t xi_ = xi + 1 ; const size_t yi_ = yi + 1 ; out_xf [ k ] = xerror ; out_yf [ k ] = yerror ; <S2SV_StartBug> out_x0y0 [ k ] = ( * index_gray ( src , xi , yi ) ) ; <S2SV_EndBug> <S2SV_StartBug> out_x1y0 [ k ] = ( * index_gray ( src , xi_ , yi ) ) ; <S2SV_EndBug> <S2SV_StartBug> out_x0y1 [ k ] = ( * index_gray ( src , xi , yi_ ) ) ; <S2SV_EndBug> <S2SV_StartBug> out_x1y1 [ k ] = ( * index_gray ( src , xi_ , yi_ ) ) ; <S2SV_EndBug> } } } | <S2SV_ModStart> = ( * index <S2SV_ModEnd> ( src , <S2SV_ModStart> = ( * index <S2SV_ModEnd> ( src , <S2SV_ModStart> = ( * index <S2SV_ModEnd> ( src , <S2SV_ModStart> = ( * index <S2SV_ModEnd> ( src , |
2,586 | CWE-000 int fill_square ( t_square * solution_square , t_tetralist * complete_list ) { int i ; int j ; if ( complete_list == NULL ) return ( 1 ) ; i = 0 ; while ( i < solution_square -> size ) { j = 0 ; while ( j < solution_square -> size ) { if ( place_tetra ( solution_square , complete_list , i , j ) ) { <S2SV_StartBug> if ( solver ( solution_square , complete_list -> next ) ) <S2SV_EndBug> return ( 1 ) ; remove_tetra ( solution_square , complete_list ) ; } j ++ ; } i ++ ; } return ( 0 ) ; } | <S2SV_ModStart> { if ( fill_square <S2SV_ModEnd> ( solution_square , |
2,587 | CWE-000 int local_edit_distance ( const Py_UNICODE * s , size_t ss , const Py_UNICODE * t , size_t st , <S2SV_StartBug> int match , int mismatch , int gap <S2SV_EndBug> ) { size_t rows = st + 1 ; size_t cols = ss + 1 ; int d1 , d2 , d3 ; unsigned short is_distance = match < mismatch ? 1 : 0 ; int * dp = malloc ( rows * cols * sizeof ( int ) ) ; for ( size_t i = 0 ; i < rows ; i ++ ) { <S2SV_StartBug> dp [ i * cols ] = i * gap ; <S2SV_EndBug> } for ( size_t i = 0 ; i < cols ; i ++ ) { <S2SV_StartBug> dp [ i ] = i * gap ; <S2SV_EndBug> } for ( size_t j = 1 ; j < rows ; j ++ ) { for ( size_t k = 1 ; k < cols ; k ++ ) { d3 = s [ k - 1 ] == t [ j - 1 ] ? dp [ ( j - 1 ) * cols + k - 1 ] + match : dp [ ( j - 1 ) * cols + k - 1 ] + mismatch ; <S2SV_StartBug> d1 = dp [ j * cols + k - 1 ] + gap ; <S2SV_EndBug> <S2SV_StartBug> d2 = dp [ ( j - 1 ) * cols + k ] + gap ; <S2SV_EndBug> if ( is_distance ) { dp [ j * cols + k ] = MIN ( 0 , MIN ( d3 , MIN ( d1 , d2 ) ) ) ; } else { dp [ j * cols + k ] = MAX ( 0 , MAX ( d3 , MAX ( d1 , d2 ) ) ) ; } } } int result = 0 ; for ( size_t i = 0 ; i < rows * cols ; i ++ ) { if ( ( dp [ i ] < result && is_distance ) || ( dp [ i ] > result && ! is_distance ) ) { result = dp [ i ] ; } } free ( dp ) ; return result ; } | <S2SV_ModStart> mismatch , int insert , int delete <S2SV_ModEnd> ) { size_t <S2SV_ModStart> cols ] = 0 <S2SV_ModEnd> ; } for <S2SV_ModStart> = i * 0 <S2SV_ModEnd> ; } for <S2SV_ModStart> 1 ] + delete <S2SV_ModEnd> ; d2 = <S2SV_ModStart> k ] + insert <S2SV_ModEnd> ; if ( |
2,588 | CWE-000 struct request * nvme_alloc_request ( struct request_queue * q , struct nvme_command * cmd , blk_mq_req_flags_t flags , int qid ) { unsigned op = nvme_is_write ( cmd ) ? REQ_OP_DRV_OUT : REQ_OP_DRV_IN ; struct request * req ; if ( qid == NVME_QID_ANY ) { req = blk_mq_alloc_request ( q , op , flags ) ; } else { req = blk_mq_alloc_request_hctx ( q , op , flags , qid ? qid - 1 : 0 ) ; } if ( IS_ERR ( req ) ) return req ; req -> cmd_flags |= REQ_FAILFAST_DRIVER ; <S2SV_StartBug> nvme_req ( req ) -> cmd = cmd ; <S2SV_EndBug> return req ; } | <S2SV_ModStart> |= REQ_FAILFAST_DRIVER ; nvme_clear_nvme_request ( req ) ; |
2,589 | CWE-000 ngx_int_t ngx_http_php_content_post_handler ( ngx_http_request_t * r ) { TSRMLS_FETCH ( ) ; ngx_http_php_main_conf_t * pmcf = ngx_http_get_module_main_conf ( r , ngx_http_php_module ) ; ngx_http_php_loc_conf_t * plcf = ngx_http_get_module_loc_conf ( r , ngx_http_php_module ) ; ngx_int_t rc ; ngx_http_php_ctx_t * ctx ; ctx = ngx_http_get_module_ctx ( r , ngx_http_php_module ) ; if ( ctx == NULL ) { ngx_log_error ( NGX_LOG_ERR , r -> connection -> log , 0 , "Get<S2SV_blank>ngx_http_php_ctx_t<S2SV_blank>fail" ) ; return NGX_HTTP_INTERNAL_SERVER_ERROR ; } if ( ctx -> request_body_more ) { rc = ngx_http_php_request_read_body ( r ) ; return rc ; <S2SV_StartBug> } <S2SV_EndBug> zend_first_try { ngx_php_ngx_run ( r , pmcf -> state , plcf -> content_inline_code ) ; } zend_end_try ( ) ; ngx_http_php_request_cleanup_handler ( r ) ; ngx_http_php_rputs_chain_list_t * chain ; ctx = ngx_http_get_module_ctx ( r , ngx_http_php_module ) ; chain = ctx -> rputs_chain ; if ( ctx -> rputs_chain == NULL ) { ngx_buf_t * b ; ngx_str_t ns ; u_char * u_str ; ns . data = ( u_char * ) "<S2SV_blank>" ; ns . len = 1 ; chain = ngx_pcalloc ( r -> pool , sizeof ( ngx_http_php_rputs_chain_list_t ) ) ; chain -> out = ngx_alloc_chain_link ( r -> pool ) ; chain -> last = & chain -> out ; b = ngx_calloc_buf ( r -> pool ) ; ( * chain -> last ) -> buf = b ; ( * chain -> last ) -> next = NULL ; u_str = ngx_pstrdup ( r -> pool , & ns ) ; ( * chain -> last ) -> buf -> pos = u_str ; ( * chain -> last ) -> buf -> last = u_str + ns . len ; ( * chain -> last ) -> buf -> memory = 1 ; ctx -> rputs_chain = chain ; if ( r -> headers_out . content_length_n == - 1 ) { r -> headers_out . content_length_n += ns . len + 1 ; } else { r -> headers_out . content_length_n += ns . len ; } } if ( ! r -> headers_out . status ) { r -> headers_out . status = NGX_HTTP_OK ; } if ( r -> method == NGX_HTTP_HEAD ) { rc = ngx_http_send_header ( r ) ; if ( rc != NGX_OK ) { return rc ; } } if ( chain != NULL ) { ( * chain -> last ) -> buf -> last_buf = 1 ; } rc = ngx_http_send_header ( r ) ; if ( rc != NGX_OK ) { return rc ; } ngx_http_output_filter ( r , chain -> out ) ; ngx_http_set_ctx ( r , NULL , ngx_http_php_module ) ; return NGX_OK ; } | <S2SV_ModStart> rc ; } NGX_HTTP_PHP_R_INIT ( r ) ; |
2,590 | CWE-000 static char * prepare ( char * fields [ 10 ] , struct fmt_main * self ) { static char Buf [ 256 ] ; char tmp [ 512 ] , tmp2 [ 512 ] , tmp4 [ 256 ] , tmp5 [ 6 ] , tmp6 [ 6 ] , * cp , * cp2 ; int N , r , p ; if ( ! strncmp ( fields [ 1 ] , FMT_CISCO9 , FMT_CISCO9_LEN ) ) { if ( strlen ( fields [ 1 ] ) != 4 + 14 + 43 ) return fields [ 1 ] ; N = 1 << 14 ; r = 1 ; p = 1 ; encode64_uint32 ( ( uint8_t * ) tmp5 , sizeof ( tmp5 ) , r , 30 ) ; tmp5 [ 5 ] = 0 ; encode64_uint32 ( ( uint8_t * ) tmp6 , sizeof ( tmp6 ) , p , 30 ) ; tmp6 [ 5 ] = 0 ; <S2SV_StartBug> sprintf ( Buf , "%s%c%s%s%14.14s$%s" , FMT_TAG7 , N_to_c ( N ) , tmp5 , tmp6 , & ( fields [ 1 ] [ 3 ] ) , <S2SV_EndBug> base64_convert_cp ( & ( fields [ 1 ] [ 3 + 14 + 1 ] ) , e_b64_crypt , 43 , tmp , e_b64_cryptBS , sizeof ( tmp ) , flg_Base64_NO_FLAGS , 0 ) ) ; } else if ( ! strncmp ( fields [ 1 ] , FMT_SCRYPTKDF , FMT_SCRYPTKDF_LEN ) ) { int N , r , p ; if ( strlen ( fields [ 1 ] ) > sizeof ( tmp ) + FMT_SCRYPTKDF_LEN ) return fields [ 1 ] ; strcpy ( tmp , & fields [ 1 ] [ FMT_SCRYPTKDF_LEN ] ) ; cp = strtokm ( tmp , "*" ) ; if ( ! cp || ! isdec ( cp ) ) return fields [ 1 ] ; N = atoi ( cp ) ; cp = strtokm ( NULL , "*" ) ; if ( ! cp || ! isdec ( cp ) ) return fields [ 1 ] ; r = atoi ( cp ) ; cp = strtokm ( NULL , "*" ) ; if ( ! cp || ! isdec ( cp ) ) return fields [ 1 ] ; p = atoi ( cp ) ; cp = strtokm ( NULL , "*" ) ; if ( ! cp ) return fields [ 1 ] ; cp2 = strtokm ( NULL , "*" ) ; if ( ! cp2 ) return fields [ 1 ] ; if ( base64_valid_length ( cp , e_b64_mime , flg_Base64_MIME_TRAIL_EQ_CNT , 0 ) != strlen ( cp ) ) return fields [ 1 ] ; if ( base64_valid_length ( cp2 , e_b64_mime , flg_Base64_MIME_TRAIL_EQ_CNT , 0 ) != strlen ( cp2 ) ) return fields [ 1 ] ; encode64_uint32 ( ( uint8_t * ) tmp5 , sizeof ( tmp5 ) , r , 30 ) ; tmp5 [ 5 ] = 0 ; encode64_uint32 ( ( uint8_t * ) tmp6 , sizeof ( tmp6 ) , p , 30 ) ; tmp6 [ 5 ] = 0 ; memset ( tmp4 , 0 , sizeof ( tmp4 ) ) ; base64_convert_cp ( cp , e_b64_mime , strlen ( cp ) , tmp4 , e_b64_raw , sizeof ( tmp4 ) , flg_Base64_NO_FLAGS , 0 ) ; memset ( tmp2 , 0 , sizeof ( tmp2 ) ) ; base64_convert_cp ( cp2 , e_b64_mime , strlen ( cp2 ) , tmp2 , e_b64_cryptBS , sizeof ( tmp2 ) , flg_Base64_NO_FLAGS , 0 ) ; cp = & tmp2 [ strlen ( tmp2 ) - 1 ] ; while ( cp > tmp2 && * cp == '.' ) * cp -- = 0 ; <S2SV_StartBug> cp = & tmp4 [ strlen ( tmp ) - 1 ] ; <S2SV_EndBug> while ( cp > tmp4 && * cp == '.' ) * cp -- = 0 ; <S2SV_StartBug> sprintf ( Buf , "%s%c%s%s%s$%s" , FMT_TAG7 , N_to_c ( N ) , tmp5 , tmp6 , tmp4 , tmp2 ) ; <S2SV_EndBug> } else return fields [ 1 ] ; return Buf ; } | <S2SV_ModStart> = 0 ; snprintf ( Buf , sizeof ( Buf ) <S2SV_ModEnd> , "%s%c%s%s%14.14s$%s" , <S2SV_ModStart> [ strlen ( tmp4 <S2SV_ModEnd> ) - 1 <S2SV_ModStart> = 0 ; snprintf ( Buf , sizeof ( Buf ) <S2SV_ModEnd> , "%s%c%s%s%s$%s" , |
2,591 | CWE-000 static ssize_t kcal_min_store ( struct device * dev , struct device_attribute * attr , const char * buf , size_t count ) { int kcal_min , r ; struct kcal_lut_data * lut_data = dev_get_drvdata ( dev ) ; r = kstrtoint ( buf , 10 , & kcal_min ) ; <S2SV_StartBug> if ( ( r ) || ( kcal_min < 1 || kcal_min > 256 ) ) <S2SV_EndBug> return - EINVAL ; lut_data -> minimum = kcal_min ; mdss_mdp_kcal_update_pcc ( lut_data ) ; mdss_mdp_kcal_display_commit ( ) ; return count ; } | <S2SV_ModStart> ( kcal_min < 0 <S2SV_ModEnd> || kcal_min > |
2,592 | CWE-000 static void power_down_all_systems ( void ) { nrf_gpio_cfg_output ( 15 ) ; <S2SV_StartBug> nrf_gpio_cfg_output ( 16 ) ; <S2SV_EndBug> nrf_gpio_cfg_output ( IC_LTC_POWER_PIN ) ; <S2SV_StartBug> nrf_gpio_pin_clear ( 15 ) ; <S2SV_EndBug> nrf_gpio_pin_clear ( 16 ) ; nrf_gpio_pin_clear ( IC_LTC_POWER_PIN ) ; nrf_gpio_cfg_default ( IC_SPI_FLASH_SS_PIN ) ; nrf_gpio_cfg_default ( IC_SPI_MISO_PIN ) ; nrf_gpio_cfg_default ( IC_SPI_MOSI_PIN ) ; nrf_gpio_cfg_default ( IC_SPI_SCK_PIN ) ; nrf_gpio_cfg_default ( IC_UART_RX_PIN ) ; nrf_gpio_cfg_default ( IC_UART_TX_PIN ) ; nrf_gpio_cfg_default ( IC_SPI_AFE_SS_PIN ) ; nrf_gpio_cfg_default ( IC_SPI_AFE_RESET_PIN ) ; nrf_gpio_cfg_default ( IC_SPI_AFE_PDN_PIN ) ; } | <S2SV_ModStart> 15 ) ; nrf_gpio_pin_clear ( 15 ) ; nrf_gpio_cfg_output ( 16 ) ; nrf_gpio_pin_clear <S2SV_ModEnd> ( 16 ) <S2SV_ModStart> ; nrf_gpio_pin_clear ( IC_LTC_POWER_PIN <S2SV_ModEnd> ) ; } |
2,593 | CWE-000 void moveTo ( int distance , int direction ) { float totalPulses = ( distance / 1.38 ) ; uint16_t speed = 1700 ; int partitialError = 0 ; int derivativeError = 0 ; int integralError = 0 ; int referenceValue = 0 ; int measurementValue ; int controlValue ; int iPart = 0 ; int dPart = 0 ; int kp = 20 ; int kd = 2 ; int ki = 2 ; float totMovement = 0 ; <S2SV_StartBug> == == == = <S2SV_EndBug> void moveTo ( int distance , int direktion ) { uint16_t totalPulses = distance / 1.35 ; uint16_t speed = 1650 ; int error = 0 ; int referenceValue = 0 ; int measurementValue ; int controlValue ; int kp = 5 ; int checkValue = - 4 ; >> >> >> > master reset_Counter ( ) ; if ( direction != 1 || direction != - 1 ) { direction = 1 ; } <S2SV_StartBug> << << << < HEAD <S2SV_EndBug> while ( totMovement <= totalPulses ) { delay_ms ( 1 ) ; if ( c1Loop == true && c2Loop == true ) { totMovement = totMovement + ( ( counter_1 + counter_2 ) / 2 ) ; delay_ms ( 1 ) ; measurementValue = ( counter_2 - counter_1 ) ; delay_us ( 500 ) ; reset_Counter ( ) ; delay_us ( 500 ) ; dPart = ( kd * ( partitialError - derivativeError ) ) ; delay_us ( 500 ) ; iPart = ( ki * integralError ) ; delay_us ( 500 ) ; partitialError = ( referenceValue - measurementValue ) ; delay_us ( 500 ) ; controlValue = ( ( kp * partitialError ) + iPart + dPart ) ; delay_us ( 500 ) ; rightWheel ( ( speed + controlValue ) ) ; leftWheel ( ( speed - controlValue ) ) ; delay_us ( 500 ) ; derivativeError = partitialError ; delay_us ( 500 ) ; integralError = ( integralError + partitialError ) ; delay_us ( 500 ) ; c1Loop = false ; c2Loop = false ; delay_us ( 500 ) ; } <S2SV_StartBug> == == == = <S2SV_EndBug> while ( counter_1 <= totalPulses ) { if ( ( ( counter_1 + counter_2 ) - checkValue ) >= 4 ) { measurementValue = ( counter_2 - counter_1 ) ; error = ( referenceValue - measurementValue ) ; controlValue = ( kp * error ) ; rightWheel ( ( speed + controlValue ) ) ; leftWheel ( ( speed - controlValue ) ) ; referenceValue = ( error * - 1 ) / 2 ; checkValue = counter_1 + counter_2 ; } >> >> >> > master } rightWheel ( 1500 ) ; leftWheel ( 1500 ) ; delay_s ( 2 ) ; } | <S2SV_ModStart> = 0 ; <S2SV_ModEnd> reset_Counter ( ) <S2SV_ModStart> 1 ; } <S2SV_ModEnd> while ( totMovement <S2SV_ModStart> ) ; } <S2SV_ModEnd> } rightWheel ( |
2,594 | CWE-000 static int aiv_gb_opcode_b6 ( aiv_gameboy * gb ) { <S2SV_StartBug> gb -> a | gb -> hl ; <S2SV_EndBug> if ( gb -> a == 0 ) { SET_Z ( gb ) ; <S2SV_StartBug> UNSET_N ( gb ) ; <S2SV_EndBug> UNSET_H ( gb ) ; UNSET_C ( gb ) ; } else { <S2SV_StartBug> UNSET_Z ( gb ) ; <S2SV_EndBug> UNSET_N ( gb ) ; UNSET_H ( gb ) ; UNSET_C ( gb ) ; <S2SV_StartBug> } <S2SV_EndBug> return 8 ; } | <S2SV_ModStart> gb -> a |= <S2SV_ModEnd> gb -> hl <S2SV_ModStart> gb ) ; <S2SV_ModEnd> } else { <S2SV_ModStart> gb ) ; } <S2SV_ModStart> gb ) ; <S2SV_ModEnd> return 8 ; |
2,595 | CWE-000 static void scheduler_timer ( void * data , const struct isr_regs * regs ) { assert ( current_task ) ; save_task_state ( current_task , regs ) ; <S2SV_StartBug> if ( current_task != idle_task ) { <S2SV_EndBug> checked_lock ( & ready_queue_lock ) ; list_append ( & ready_queue , current_task , node ) ; checked_unlock ( & ready_queue_lock ) ; } checked_lock ( & exited_queue_lock ) ; list_foreach ( task , task , & exited_queue , node ) { trace ( "Collecting<S2SV_blank>task<S2SV_blank>%s<S2SV_blank>(%d)" , task -> name , task -> pid ) ; list_remove ( & exited_queue , task , node ) ; vmm_destroy_pagedir ( task -> pagedir ) ; kfree ( task ) ; } checked_unlock ( & exited_queue_lock ) ; bool moretasks = true ; checked_lock ( & ready_queue_lock ) ; checked_lock ( & sleeping_queue_lock ) ; checked_lock ( & msgwait_queue_lock ) ; if ( list_empty ( & ready_queue ) && list_empty ( & sleeping_queue ) && list_empty ( & msgwait_queue ) ) { moretasks = false ; } else if ( list_empty ( & ready_queue ) && list_empty ( & sleeping_queue ) && ! list_empty ( & msgwait_queue ) ) { if ( list_head ( & msgwait_queue ) == list_tail ( & msgwait_queue ) ) { moretasks = false ; } } checked_unlock ( & msgwait_queue_lock ) ; checked_unlock ( & sleeping_queue_lock ) ; checked_unlock ( & ready_queue_lock ) ; if ( ! moretasks ) { trace ( "No<S2SV_blank>more<S2SV_blank>tasks<S2SV_blank>to<S2SV_blank>run.<S2SV_blank>Rebooting" ) ; reboot ( ) ; } task_switch_next ( ) ; invalid_code_path ( ) ; } | <S2SV_ModStart> regs ) ; scheduler_perform_checks ( ) ; |
2,596 | CWE-000 <S2SV_StartBug> void printLab ( LabCell lab ) { <S2SV_EndBug> int i = 0 ; int j = 0 ; <S2SV_StartBug> while ( i < lab . maxrow + 1 ) { <S2SV_EndBug> <S2SV_StartBug> printf ( "%s" , lab . lab [ i ] ) ; <S2SV_EndBug> i ++ ; } } | <S2SV_ModStart> void printLab ( char lab [ ] [ MAXROWS ] , int maxRow <S2SV_ModEnd> ) { int <S2SV_ModStart> ( i < maxRow <S2SV_ModEnd> + 1 ) <S2SV_ModStart> { printf ( "%s\\n" , <S2SV_ModEnd> lab [ i |
2,597 | CWE-000 static int init ( ) { int sockfd ; struct sockaddr_in my_name ; int status ; sockfd = socket ( AF_INET , SOCK_DGRAM , 0 ) ; if ( sockfd == - 1 ) { perror ( "Socket<S2SV_blank>creation<S2SV_blank>error" ) ; goto error ; } my_name . sin_family = AF_INET ; <S2SV_StartBug> my_name . sin_addr . s_addr = INADDR_ANY ; <S2SV_EndBug> my_name . sin_port = htons ( UDP_SERVER_PORT ) ; status = bind ( sockfd , ( struct sockaddr * ) & my_name , sizeof ( my_name ) ) ; if ( status == - 1 ) { perror ( "bind" ) ; goto error ; } return sockfd ; error : return - 1 ; } | <S2SV_ModStart> = AF_INET ; inet_aton ( UDP_SERVER_ADDR , <S2SV_ModStart> sin_addr . s_addr ) <S2SV_ModEnd> ; my_name . |
2,598 | CWE-000 static gboolean commit_changes ( NMSettingsConnection * connection , <S2SV_StartBug> NMSettingsConnectionCommitReason commit_reason , <S2SV_EndBug> GError * * error ) { NMIfnetConnectionPrivate * priv = NM_IFNET_CONNECTION_GET_PRIVATE ( ( NMIfnetConnection * ) connection ) ; char * new_name = NULL ; gboolean success = FALSE ; g_signal_emit ( connection , signals [ IFNET_CANCEL_MONITORS ] , 0 ) ; if ( priv -> conn_name ) { success = ifnet_update_parsers_by_connection ( NM_CONNECTION ( connection ) , priv -> conn_name , CONF_NET_FILE , WPA_SUPPLICANT_CONF , & new_name , NULL , error ) ; } else { success = ifnet_add_new_connection ( NM_CONNECTION ( connection ) , CONF_NET_FILE , WPA_SUPPLICANT_CONF , & new_name , NULL , error ) ; } g_assert ( ! ! success == ( new_name != NULL ) ) ; if ( success ) { g_free ( priv -> conn_name ) ; priv -> conn_name = new_name ; } reload_parsers ( ) ; g_signal_emit ( connection , signals [ IFNET_SETUP_MONITORS ] , 0 ) ; return success ; } | <S2SV_ModStart> * connection , NMConnection * new_connection , NMSettingsConnectionCommitReason commit_reason , NMConnection * * out_reread_connection , char * * out_logmsg_change <S2SV_ModEnd> , GError * |
2,599 | CWE-000 void sort_arr ( List * processes ) { int size = processes -> size ; if ( size <= 1 ) return ; elem * e ; char sorted = 0 ; while ( ! sorted ) { sorted = 1 ; e = processes -> first ; <S2SV_StartBug> for ( int i = 0 ; i < -- size ; i ++ ) { <S2SV_EndBug> if ( e -> proc . t_arr > e -> next -> proc . t_arr ) { switch_proc ( & e -> proc , & e -> next -> proc ) ; sorted = 0 ; } e = e -> next ; } } } | <S2SV_ModStart> -> first ; size -- ; <S2SV_ModStart> ; i < <S2SV_ModEnd> size ; i |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.