Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
4,800 | CWE-000 static gboolean cb_print_position ( GstElement * pipeline ) { gint64 pos , len ; if ( gst_element_query_position ( pipeline , GST_FORMAT_TIME , & pos ) && gst_element_query_duration ( pipeline , GST_FORMAT_TIME , & len ) ) { gint64 rem = ( len - pos ) / 1000000000 ; <S2SV_StartBug> gint64 seconds = rem % 60 ; <S2SV_EndBug> <S2SV_StartBug> gint64 minutes = ( rem - seconds ) / 60 ; <S2SV_EndBug> <S2SV_StartBug> g_print ( "Time<S2SV_blank>remaining<S2SV_blank>:<S2SV_blank>%02ld:%02ld\\n" , minutes , seconds ) ; <S2SV_EndBug> } return TRUE ; } | <S2SV_ModStart> / 1000000000 ; gint <S2SV_ModEnd> seconds = rem <S2SV_ModStart> % 60 ; gint <S2SV_ModEnd> minutes = ( <S2SV_ModStart> ; g_print ( "Time<S2SV_blank>remaining<S2SV_blank>:<S2SV_blank>%02d:%02d\\n" <S2SV_ModEnd> , minutes , |
4,801 | CWE-000 USB_STREAM_CONFIG_FULL ( usb_upgrade , USB_IFACE_UPGRADE , USB_CLASS_VENDOR_SPEC , USB_SUBCLASS_GOOGLE_CR50 , USB_PROTOCOL_GOOGLE_CR50_NON_HC_FW_UPDATE , USB_STR_UPGRADE_NAME , USB_EP_UPGRADE , USB_MAX_PACKET_SIZE , USB_MAX_PACKET_SIZE , usb_to_upgrade , upgrade_to_usb ) enum rx_state { rx_idle , rx_inside_block , rx_outside_block , <S2SV_StartBug> rx_awaiting_reset <S2SV_EndBug> } ; enum rx_state rx_state_ = rx_idle ; static uint8_t * block_buffer ; static uint32_t block_size ; static uint32_t block_index ; static int valid_transfer_start ( struct consumer const * consumer , size_t count , struct update_frame_header * pupfr ) { int i ; i = count ; while ( i > 0 ) { QUEUE_REMOVE_UNITS ( consumer -> queue , pupfr , MIN ( i , sizeof ( * pupfr ) ) ) ; i -= sizeof ( * pupfr ) ; } if ( count != sizeof ( struct update_frame_header ) ) { CPRINTS ( "FW<S2SV_blank>update:<S2SV_blank>wrong<S2SV_blank>first<S2SV_blank>block,<S2SV_blank>size<S2SV_blank>%d" , count ) ; return 0 ; } for ( i = 0 ; i < sizeof ( pupfr -> cmd ) ; i ++ ) if ( ( ( uint8_t * ) & pupfr -> cmd ) [ i ] ) return 0 ; return 1 ; } | <S2SV_ModStart> , rx_outside_block , <S2SV_ModEnd> } ; enum |
4,802 | CWE-000 static bool clients_username_exists ( Client * * clients , const char * username ) { Client * c = clients [ 0 ] ; while ( c ) { <S2SV_StartBug> if ( ! strcasecmp ( username , c -> username ) ) <S2SV_EndBug> { return true ; } c = c -> next ; } return false ; } | <S2SV_ModStart> { if ( c -> state == CLIENT_STATE_AUTHENTICATED && |
4,803 | CWE-000 static void cmd_since ( struct watchman_client * client , json_t * args ) { <S2SV_StartBug> const char * clockspec ; <S2SV_EndBug> w_root_t * root ; w_query * query ; char * errmsg = NULL ; struct w_query_field_list field_list ; w_query_res res ; json_t * response , * clock_ele ; json_t * file_list ; char clockbuf [ 128 ] ; <S2SV_StartBug> if ( json_array_size ( args ) < 3 ) { <S2SV_EndBug> send_error_response ( client , "not<S2SV_blank>enough<S2SV_blank>arguments<S2SV_blank>for<S2SV_blank>\'since\'" ) ; return ; } <S2SV_StartBug> root = resolve_root_or_err ( client , args , 1 , false ) ; <S2SV_EndBug> if ( ! root ) { return ; } clock_ele = json_array_get ( args , 2 ) ; clockspec = json_string_value ( clock_ele ) ; if ( ! clockspec ) { send_error_response ( client , "expected<S2SV_blank>argument<S2SV_blank>2<S2SV_blank>to<S2SV_blank>be<S2SV_blank>a<S2SV_blank>valid<S2SV_blank>clockspec" ) ; <S2SV_StartBug> w_root_delref ( root ) ; <S2SV_EndBug> return ; } <S2SV_StartBug> query = w_query_parse_legacy ( root , args , & errmsg , 3 , NULL , clockspec , NULL ) ; <S2SV_EndBug> if ( errmsg ) { send_error_response ( client , "%s" , errmsg ) ; free ( errmsg ) ; <S2SV_StartBug> w_root_delref ( root ) ; <S2SV_EndBug> return ; } w_query_legacy_field_list ( & field_list ) ; <S2SV_StartBug> if ( ! w_query_execute ( query , root , & res , NULL , NULL ) ) { <S2SV_EndBug> send_error_response ( client , "query<S2SV_blank>failed:<S2SV_blank>%s" , res . errmsg ) ; w_query_result_free ( & res ) ; <S2SV_StartBug> w_root_delref ( root ) ; <S2SV_EndBug> w_query_delref ( query ) ; return ; } w_query_delref ( query ) ; file_list = w_query_results_to_json ( & field_list , res . num_results , res . results ) ; w_query_result_free ( & res ) ; response = make_response ( ) ; if ( clock_id_string ( res . root_number , res . ticks , clockbuf , sizeof ( clockbuf ) ) ) { set_unicode_prop ( response , "clock" , clockbuf ) ; } set_prop ( response , "is_fresh_instance" , json_pack ( "b" , res . is_fresh_instance ) ) ; set_prop ( response , "files" , file_list ) ; <S2SV_StartBug> add_root_warnings_to_response ( response , root ) ; <S2SV_EndBug> send_and_dispose_response ( client , response ) ; <S2SV_StartBug> w_root_delref ( root ) ; <S2SV_EndBug> } | <S2SV_ModStart> char * clockspec <S2SV_ModEnd> ; w_query * <S2SV_ModStart> 128 ] ; struct unlocked_watchman_root unlocked ; <S2SV_ModStart> return ; } if ( ! <S2SV_ModEnd> resolve_root_or_err ( client <S2SV_ModStart> 1 , false , & unlocked ) <S2SV_ModEnd> ) { return <S2SV_ModStart> ; w_root_delref ( unlocked . <S2SV_ModStart> = w_query_parse_legacy ( unlocked . <S2SV_ModStart> ; w_root_delref ( unlocked . <S2SV_ModStart> ( query , & unlocked <S2SV_ModEnd> , & res <S2SV_ModStart> ; w_root_delref ( unlocked . <S2SV_ModStart> ( response , unlocked . <S2SV_ModStart> ; w_root_delref ( unlocked . |
4,804 | CWE-000 static void save_allocated ( pubnub_t * pb ) { # if defined PUBNUB_ASSERT_LEVEL_EX pubnub_mutex_init_static ( m_lock ) ; pubnub_mutex_lock ( m_lock ) ; if ( m_n == m_cap ) { pubnub_t * * npalloc = ( pubnub_t * * ) realloc ( m_allocated , sizeof m_allocated [ 0 ] * ( m_n + 1 ) ) ; if ( NULL == npalloc ) { <S2SV_StartBug> pubnub_mutex_unlock ( m_lock ) ; <S2SV_EndBug> return ; } m_allocated = npalloc ; m_allocated [ m_n ++ ] = pb ; m_cap = m_n ; } else { m_allocated [ m_n ++ ] = pb ; } pubnub_mutex_unlock ( m_lock ) ; # endif } | <S2SV_ModStart> npalloc ) { PUBNUB_LOG_WARNING ( "Couldn\'t<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>pubnub_alloc_std<S2SV_blank>bookkeeping" ) ; |
4,805 | CWE-000 <S2SV_StartBug> static int tegra_pcie_get_xbar_config ( const void * fdt , int node , u32 lanes , <S2SV_EndBug> enum tegra_pci_id id , unsigned long * xbar ) { switch ( id ) { case TEGRA20_PCIE : switch ( lanes ) { case 0x00000004 : debug ( "single-mode<S2SV_blank>configuration\\n" ) ; * xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_SINGLE ; return 0 ; case 0x00000202 : debug ( "dual-mode<S2SV_blank>configuration\\n" ) ; * xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_DUAL ; return 0 ; } break ; case TEGRA30_PCIE : switch ( lanes ) { case 0x00000204 : debug ( "4x1,<S2SV_blank>2x1<S2SV_blank>configuration\\n" ) ; * xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_420 ; return 0 ; case 0x00020202 : debug ( "2x3<S2SV_blank>configuration\\n" ) ; * xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_222 ; return 0 ; case 0x00010104 : debug ( "4x1,<S2SV_blank>1x2<S2SV_blank>configuration\\n" ) ; * xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_411 ; return 0 ; } break ; case TEGRA124_PCIE : case TEGRA210_PCIE : switch ( lanes ) { case 0x0000104 : debug ( "4x1,<S2SV_blank>1x1<S2SV_blank>configuration\\n" ) ; * xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_X4_X1 ; return 0 ; case 0x0000102 : debug ( "2x1,<S2SV_blank>1x1<S2SV_blank>configuration\\n" ) ; * xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_X2_X1 ; return 0 ; } break ; case TEGRA186_PCIE : switch ( lanes ) { case 0x0010004 : debug ( "x4<S2SV_blank>x1<S2SV_blank>configuration\\n" ) ; * xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_T186_401 ; return 0 ; case 0x0010102 : debug ( "x2<S2SV_blank>x1<S2SV_blank>x1<S2SV_blank>configuration\\n" ) ; * xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_T186_211 ; return 0 ; case 0x0010101 : debug ( "x1<S2SV_blank>x1<S2SV_blank>x1<S2SV_blank>configuration\\n" ) ; * xbar = AFI_PCIE_CONFIG_SM2TMS0_XBAR_CONFIG_T186_111 ; return 0 ; } break ; default : break ; } return - FDT_ERR_NOTFOUND ; } | <S2SV_ModStart> int tegra_pcie_get_xbar_config ( ofnode <S2SV_ModEnd> node , u32 |
4,806 | CWE-000 static int builtin_posix_dataset_path ( struct hio_module_t * module , builtin_posix_dataset_dmode_t dmode , char * * path , const char * name , uint64_t set_id ) { <S2SV_StartBug> hio_context_t context = module -> context ; <S2SV_EndBug> int rc ; if ( HIO_DIR_MODE_HIERARCHICAL == dmode ) { <S2SV_StartBug> rc = asprintf ( path , "%s/%s.hio/%s/%" PRId64 , module -> data_root , hioi_object_identifier ( context ) , name , <S2SV_EndBug> set_id ) ; <S2SV_StartBug> } else if ( HIO_DIR_MODE_SINGLE == dmode ) { <S2SV_EndBug> rc = asprintf ( path , "%s/%s.%s.%" PRId64 ".hiod" , module -> data_root , hioi_object_identifier ( context ) , name , set_id ) ; } else { return HIO_ERROR ; } return ( 0 > rc ) ? hioi_err_errno ( errno ) : HIO_SUCCESS ; } | <S2SV_ModStart> set_id ) { return builtin_posix_dataset_path_data_root ( module , dmode , path <S2SV_ModEnd> , module -> <S2SV_ModStart> -> data_root , <S2SV_ModEnd> name , set_id <S2SV_ModStart> ) ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
4,807 | CWE-000 static ngx_int_t ngx_http_set_host_header ( ngx_http_request_t * r , ngx_http_lua_header_val_t * hv , ngx_str_t * value ) { ngx_str_t host ; <S2SV_StartBug> dd ( "server<S2SV_blank>new<S2SV_blank>value<S2SV_blank>len:<S2SV_blank>%d" , ( int ) value -> len ) ; <S2SV_EndBug> if ( value -> len ) { host = * value ; if ( ngx_http_lua_validate_host ( & host , r -> pool , 0 ) != NGX_OK ) { return NGX_ERROR ; } r -> headers_in . server = host ; } else { r -> headers_in . server = * value ; } <S2SV_StartBug> return ngx_http_set_builtin_header ( r , hv , value ) ; <S2SV_EndBug> } | <S2SV_ModStart> ngx_str_t host ; ngx_http_lua_main_conf_t * lmcf ; ngx_http_variable_value_t * var ; <S2SV_ModStart> value -> len ) ; lmcf = ngx_http_get_module_main_conf ( r , ngx_http_lua_module <S2SV_ModStart> value ; } var = & r -> variables [ lmcf -> host_var_index ] ; var -> valid = 0 ; var -> not_found = 0 ; |
4,808 | CWE-000 static bool tpm_tis_update_timeouts ( struct tpm_chip * chip , unsigned long * timeout_cap ) { struct tpm_tis_data * priv = dev_get_drvdata ( & chip -> dev ) ; int i , rc ; u32 did_vid ; <S2SV_StartBug> rc = tpm_tis_read32 ( priv , TPM_DID_VID ( 0 ) , & did_vid ) ; <S2SV_EndBug> if ( rc < 0 ) <S2SV_StartBug> return rc ; <S2SV_EndBug> for ( i = 0 ; i != ARRAY_SIZE ( vendor_timeout_overrides ) ; i ++ ) { if ( vendor_timeout_overrides [ i ] . did_vid != did_vid ) continue ; memcpy ( timeout_cap , vendor_timeout_overrides [ i ] . timeout_us , sizeof ( vendor_timeout_overrides [ i ] . timeout_us ) ) ; <S2SV_StartBug> return true ; <S2SV_EndBug> } <S2SV_StartBug> return false ; <S2SV_EndBug> } | <S2SV_ModStart> u32 did_vid ; if ( chip -> ops -> clk_enable != NULL ) chip -> ops -> clk_enable ( chip , true ) ; <S2SV_ModStart> < 0 ) goto out <S2SV_ModEnd> ; for ( <S2SV_ModStart> ) ) ; rc = <S2SV_ModEnd> true ; } <S2SV_ModStart> true ; } rc = false ; out : if ( chip -> ops -> clk_enable != NULL ) chip -> ops -> clk_enable ( chip , false ) ; return rc <S2SV_ModEnd> ; } <S2SV_null> |
4,809 | CWE-000 static void expect_terminator ( struct parser * ps ) { if ( strcmp ( ps -> tok -> value , ";" ) && ! ps -> tok -> prev -> is_line_end ) { if ( ps -> tok -> type == TOK_END ) { struct token * tok = ps -> tok -> prev ; error_push ( ps -> r , tok -> loc , ERR_FATAL , "unexpected<S2SV_blank>end-of-file;<S2SV_blank>expected<S2SV_blank>a<S2SV_blank>statement<S2SV_blank>terminator" ) ; } else { error_push ( ps -> r , ps -> tok -> loc , ERR_FATAL , "unexpected<S2SV_blank>token<S2SV_blank>\'" ERROR_LOCATION_COLOR "%s" RESET_COLOR "\';<S2SV_blank>expected<S2SV_blank>a<S2SV_blank>statement<S2SV_blank>terminator" , ps -> tok -> value ) ; } } <S2SV_StartBug> if ( ! strcmp ( ps -> tok -> value , ";" ) ) NEXT ; <S2SV_EndBug> } | <S2SV_ModStart> } if ( <S2SV_ModEnd> ps -> tok <S2SV_ModStart> -> tok -> type != TOK_END <S2SV_ModEnd> ) NEXT ; |
4,810 | CWE-000 static void qlcnic_83xx_flush_mbx_queue ( struct qlcnic_adapter * adapter ) { struct qlcnic_mailbox * mbx = adapter -> ahw -> mailbox ; struct list_head * head = & mbx -> cmd_q ; struct qlcnic_cmd_args * cmd = NULL ; <S2SV_StartBug> spin_lock ( & mbx -> queue_lock ) ; <S2SV_EndBug> while ( ! list_empty ( head ) ) { cmd = list_entry ( head -> next , struct qlcnic_cmd_args , list ) ; dev_info ( & adapter -> pdev -> dev , "%s:<S2SV_blank>Mailbox<S2SV_blank>command<S2SV_blank>0x%x\\n" , __func__ , cmd -> cmd_op ) ; list_del ( & cmd -> list ) ; mbx -> num_cmds -- ; qlcnic_83xx_notify_cmd_completion ( adapter , cmd ) ; } <S2SV_StartBug> spin_unlock ( & mbx -> queue_lock ) ; <S2SV_EndBug> } | <S2SV_ModStart> = NULL ; spin_lock_bh <S2SV_ModEnd> ( & mbx <S2SV_ModStart> ) ; } spin_unlock_bh <S2SV_ModEnd> ( & mbx |
4,811 | CWE-000 static void make_point ( GdaGeometricPoint * point , const gchar * value ) { value ++ ; <S2SV_StartBug> point -> x = g_ascii_strtod ( value , NULL ) ; <S2SV_EndBug> value = strchr ( value , ',' ) ; value ++ ; <S2SV_StartBug> point -> y = g_ascii_strtod ( value , NULL ) ; <S2SV_EndBug> } | <S2SV_ModStart> value ++ ; gda_geometricpoint_set_x ( point , <S2SV_ModEnd> g_ascii_strtod ( value <S2SV_ModStart> value , NULL ) <S2SV_ModStart> value ++ ; gda_geometricpoint_set_y ( point , <S2SV_ModEnd> g_ascii_strtod ( value <S2SV_ModStart> , NULL ) ) |
4,812 | CWE-000 static int read_compacted_summaries ( struct f2fs_sb_info * sbi ) { struct f2fs_checkpoint * ckpt = F2FS_CKPT ( sbi ) ; struct curseg_info * seg_i ; unsigned char * kaddr ; struct page * page ; block_t start ; int i , j , offset ; start = start_sum_block ( sbi ) ; page = get_meta_page ( sbi , start ++ ) ; kaddr = ( unsigned char * ) page_address ( page ) ; seg_i = CURSEG_I ( sbi , CURSEG_HOT_DATA ) ; <S2SV_StartBug> memcpy ( & seg_i -> sum_blk -> journal . n_nats , kaddr , SUM_JOURNAL_SIZE ) ; <S2SV_EndBug> seg_i = CURSEG_I ( sbi , CURSEG_COLD_DATA ) ; <S2SV_StartBug> memcpy ( & seg_i -> sum_blk -> journal . n_sits , kaddr + SUM_JOURNAL_SIZE , <S2SV_EndBug> SUM_JOURNAL_SIZE ) ; offset = 2 * SUM_JOURNAL_SIZE ; for ( i = CURSEG_HOT_DATA ; i <= CURSEG_COLD_DATA ; i ++ ) { unsigned short blk_off ; unsigned int segno ; seg_i = CURSEG_I ( sbi , i ) ; segno = le32_to_cpu ( ckpt -> cur_data_segno [ i ] ) ; blk_off = le16_to_cpu ( ckpt -> cur_data_blkoff [ i ] ) ; seg_i -> next_segno = segno ; reset_curseg ( sbi , i , 0 ) ; seg_i -> alloc_type = ckpt -> alloc_type [ i ] ; seg_i -> next_blkoff = blk_off ; if ( seg_i -> alloc_type == SSR ) blk_off = sbi -> blocks_per_seg ; for ( j = 0 ; j < blk_off ; j ++ ) { struct f2fs_summary * s ; s = ( struct f2fs_summary * ) ( kaddr + offset ) ; seg_i -> sum_blk -> entries [ j ] = * s ; offset += SUMMARY_SIZE ; if ( offset + SUMMARY_SIZE <= PAGE_CACHE_SIZE - SUM_FOOTER_SIZE ) continue ; f2fs_put_page ( page , 1 ) ; page = NULL ; page = get_meta_page ( sbi , start ++ ) ; kaddr = ( unsigned char * ) page_address ( page ) ; offset = 0 ; } } f2fs_put_page ( page , 1 ) ; return 0 ; } | <S2SV_ModStart> ; memcpy ( seg_i -> journal <S2SV_ModEnd> , kaddr , <S2SV_ModStart> ; memcpy ( seg_i -> journal <S2SV_ModEnd> , kaddr + |
4,813 | CWE-000 static int a2a_alg_simple ( struct oshmem_group_t * group , void * target , const void * source , size_t nelems , size_t element_size ) { <S2SV_StartBug> int rc ; <S2SV_EndBug> int dst_pe ; int src_blk_idx ; int dst_blk_idx ; void * dst_blk ; SCOLL_VERBOSE ( 14 , "[#%d]<S2SV_blank>send<S2SV_blank>data<S2SV_blank>to<S2SV_blank>all<S2SV_blank>PE<S2SV_blank>in<S2SV_blank>the<S2SV_blank>group" , group -> my_pe ) ; dst_blk_idx = oshmem_proc_group_find_id ( group , group -> my_pe ) ; dst_blk = get_stride_elem ( target , 1 , nelems , element_size , dst_blk_idx , 0 ) ; <S2SV_StartBug> for ( src_blk_idx = 0 ; src_blk_idx < group -> proc_count ; src_blk_idx ++ ) { <S2SV_EndBug> <S2SV_StartBug> dst_pe = get_dst_pe ( group , src_blk_idx , dst_blk_idx ) ; <S2SV_EndBug> rc = MCA_SPML_CALL ( put ( dst_blk , nelems * element_size , get_stride_elem ( source , 1 , nelems , element_size , src_blk_idx , 0 ) , dst_pe ) ) ; if ( OSHMEM_SUCCESS != rc ) { return rc ; } } return OSHMEM_SUCCESS ; } | <S2SV_ModStart> { int rc , i <S2SV_ModStart> ; for ( i <S2SV_ModEnd> = 0 ; <S2SV_ModStart> = 0 ; i <S2SV_ModEnd> < group -> <S2SV_ModStart> -> proc_count ; i <S2SV_ModEnd> ++ ) { <S2SV_ModStart> ( group , i <S2SV_ModEnd> , dst_blk_idx ) <S2SV_ModStart> , dst_blk_idx ) ; src_blk_idx = dst_pe |
4,814 | CWE-000 static json_pair * ParsePair ( tokenizer * Tokenizer , bool First ) { <S2SV_StartBug> json_pair * Result = PushStruct ( & Tokenizer -> TreeArena , json_pair ) ; <S2SV_EndBug> if ( ! First ) { if ( ! RequireToken ( Tokenizer , Token_Comma ) ) { ReportError ( Tokenizer , "Expected<S2SV_blank>comma<S2SV_blank>before<S2SV_blank>next<S2SV_blank>pair" , 0 ) ; DIE_IF_ERROR ( Tokenizer , Result ) ; } } token KeyToken = GetToken ( Tokenizer ) ; if ( KeyToken . Type != Token_String ) { ReportError ( Tokenizer , "Object<S2SV_blank>keys<S2SV_blank>must<S2SV_blank>be<S2SV_blank>strings" , 0 ) ; DIE_IF_ERROR ( Tokenizer , Result ) ; } if ( Result != NULL ) Result -> Key = KeyToken . Text ; if ( ! RequireToken ( Tokenizer , Token_Colon ) ) { ReportError ( Tokenizer , "Expected<S2SV_blank>colon<S2SV_blank>after<S2SV_blank>object<S2SV_blank>key" , 0 ) ; DIE_IF_ERROR ( Tokenizer , Result ) ; } json_value * Value = ParseValue ( Tokenizer ) ; if ( Result != NULL ) Result -> Value = Value ; DIE_IF_ERROR ( Tokenizer , Result ) ; return Result ; } | <S2SV_ModStart> json_pair ) ; if ( Result != NULL ) { memset ( Result , 0 , sizeof ( json_pair ) ) ; Result -> Type = JSON_PAIR ; } |
4,815 | CWE-000 int X509V3_EXT_add_nconf_sk ( CONF * conf , X509V3_CTX * ctx , char * section , STACK_OF ( X509_EXTENSION ) * * sk ) { X509_EXTENSION * ext ; STACK_OF ( CONF_VALUE ) * nval ; CONF_VALUE * val ; int i ; if ( ! ( nval = NCONF_get_section ( conf , section ) ) ) return 0 ; for ( i = 0 ; i < sk_CONF_VALUE_num ( nval ) ; i ++ ) { val = sk_CONF_VALUE_value ( nval , i ) ; if ( ! ( ext = X509V3_EXT_nconf ( conf , ctx , val -> name , val -> value ) ) ) return 0 ; <S2SV_StartBug> if ( sk ) <S2SV_EndBug> <S2SV_StartBug> X509v3_add_ext ( sk , ext , - 1 ) ; <S2SV_EndBug> X509_EXTENSION_free ( ext ) ; } return 1 ; } | <S2SV_ModStart> if ( sk != NULL ) { if ( <S2SV_ModEnd> X509v3_add_ext ( sk <S2SV_ModStart> - 1 ) == NULL ) { X509_EXTENSION_free ( ext ) ; return 0 ; } } <S2SV_ModEnd> X509_EXTENSION_free ( ext |
4,816 | CWE-000 static int open_zvol ( int fd , zvol_info_t * * zinfopp ) { int rc ; zvol_io_hdr_t hdr ; zvol_op_open_data_t open_data ; zvol_info_t * zinfo = NULL ; zvol_state_t * zv = NULL ; kthread_t * thrd_info ; thread_args_t * thrd_arg ; int rele_dataset_on_error = 0 ; if ( uzfs_zvol_read_header ( fd , & hdr ) != 0 ) { LOG_ERR ( "error<S2SV_blank>reading<S2SV_blank>open<S2SV_blank>header" ) ; return ( - 1 ) ; } if ( hdr . opcode != ZVOL_OPCODE_OPEN ) { LOG_ERR ( "zvol<S2SV_blank>must<S2SV_blank>be<S2SV_blank>opened<S2SV_blank>first" ) ; return ( - 1 ) ; } if ( hdr . len != sizeof ( open_data ) ) { LOG_ERR ( "Invalid<S2SV_blank>payload<S2SV_blank>length<S2SV_blank>for<S2SV_blank>open" ) ; return ( - 1 ) ; } rc = uzfs_zvol_socket_read ( fd , ( char * ) & open_data , sizeof ( open_data ) ) ; if ( rc != 0 ) { LOG_ERR ( "Payload<S2SV_blank>read<S2SV_blank>failed" ) ; return ( - 1 ) ; } open_data . volname [ MAX_NAME_LEN - 1 ] = '\\0' ; zinfo = uzfs_zinfo_lookup ( open_data . volname ) ; if ( zinfo == NULL ) { LOG_ERR ( "zvol<S2SV_blank>%s<S2SV_blank>not<S2SV_blank>found" , open_data . volname ) ; hdr . status = ZVOL_OP_STATUS_FAILED ; goto open_reply ; } ( void ) pthread_mutex_lock ( & zinfo -> zinfo_mutex ) ; if ( zinfo -> state != ZVOL_INFO_STATE_ONLINE ) { LOG_ERR ( "zvol<S2SV_blank>%s<S2SV_blank>is<S2SV_blank>not<S2SV_blank>online" , open_data . volname ) ; hdr . status = ZVOL_OP_STATUS_FAILED ; ( void ) pthread_mutex_unlock ( & zinfo -> zinfo_mutex ) ; goto open_reply ; } if ( zinfo -> is_io_ack_sender_created != B_FALSE ) { LOG_ERR ( "zvol<S2SV_blank>%s<S2SV_blank>ack<S2SV_blank>sender<S2SV_blank>already<S2SV_blank>present" , open_data . volname ) ; hdr . status = ZVOL_OP_STATUS_FAILED ; ( void ) pthread_mutex_unlock ( & zinfo -> zinfo_mutex ) ; goto open_reply ; } if ( zinfo -> is_io_receiver_created != B_FALSE ) { LOG_ERR ( "zvol<S2SV_blank>%s<S2SV_blank>io<S2SV_blank>receiver<S2SV_blank>already<S2SV_blank>present" , open_data . volname ) ; hdr . status = ZVOL_OP_STATUS_FAILED ; ( void ) pthread_mutex_unlock ( & zinfo -> zinfo_mutex ) ; goto open_reply ; } zv = zinfo -> main_zv ; ASSERT3P ( zv , != , NULL ) ; ASSERT3P ( zv -> zv_status , == , ZVOL_STATUS_DEGRADED ) ; ASSERT3P ( zv -> rebuild_info . zv_rebuild_status , == , ZVOL_REBUILDING_INIT ) ; if ( ( zv -> zv_status != ZVOL_STATUS_DEGRADED ) || ( ( zv -> rebuild_info . zv_rebuild_status != ZVOL_REBUILDING_INIT ) && ( zv -> rebuild_info . zv_rebuild_status != ZVOL_REBUILDING_FAILED ) ) ) { LOG_ERR ( "as<S2SV_blank>status<S2SV_blank>for<S2SV_blank>%s<S2SV_blank>is<S2SV_blank>%d<S2SV_blank>or<S2SV_blank>rebuild<S2SV_blank>status<S2SV_blank>is<S2SV_blank>%d" , open_data . volname , zv -> zv_status , zv -> rebuild_info . zv_rebuild_status ) ; hdr . status = ZVOL_OP_STATUS_FAILED ; ( void ) pthread_mutex_unlock ( & zinfo -> zinfo_mutex ) ; goto open_reply ; } if ( open_data . tgt_block_size == 0 || ( open_data . tgt_block_size & ( open_data . tgt_block_size - 1 ) ) != 0 ) { LOG_ERR ( "Invalid<S2SV_blank>block<S2SV_blank>size" ) ; hdr . status = ZVOL_OP_STATUS_FAILED ; ( void ) pthread_mutex_unlock ( & zinfo -> zinfo_mutex ) ; goto open_reply ; } rele_dataset_on_error = 0 ; if ( zv -> zv_objset == NULL ) { if ( uzfs_hold_dataset ( zv ) != 0 ) { ( void ) pthread_mutex_unlock ( & zinfo -> zinfo_mutex ) ; LOG_ERR ( "Failed<S2SV_blank>to<S2SV_blank>hold<S2SV_blank>zvol<S2SV_blank>during<S2SV_blank>open" ) ; hdr . status = ZVOL_OP_STATUS_FAILED ; goto open_reply ; } rele_dataset_on_error = 1 ; } if ( uzfs_update_metadata_granularity ( zv , open_data . tgt_block_size ) != 0 ) { if ( rele_dataset_on_error == 1 ) uzfs_rele_dataset ( zv ) ; LOG_ERR ( "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>granularity<S2SV_blank>of<S2SV_blank>metadata" ) ; hdr . status = ZVOL_OP_STATUS_FAILED ; ( void ) pthread_mutex_unlock ( & zinfo -> zinfo_mutex ) ; goto open_reply ; } if ( zinfo -> snap_zv == NULL ) { ASSERT3P ( zinfo -> clone_zv , == , NULL ) ; if ( uzfs_zvol_get_or_create_internal_clone ( zinfo -> main_zv , <S2SV_StartBug> & zinfo -> snap_zv , & zinfo -> clone_zv ) != 0 ) { <S2SV_EndBug> if ( rele_dataset_on_error == 1 ) uzfs_rele_dataset ( zv ) ; LOG_ERR ( "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>clone<S2SV_blank>for<S2SV_blank>rebuild" ) ; hdr . status = ZVOL_OP_STATUS_FAILED ; ( void ) pthread_mutex_unlock ( & zinfo -> zinfo_mutex ) ; goto open_reply ; } } ASSERT3P ( zinfo -> clone_zv , != , NULL ) ; uzfs_update_ionum_interval ( zinfo , open_data . timeout ) ; zinfo -> timeout = open_data . timeout ; * zinfopp = zinfo ; zinfo -> conn_closed = B_FALSE ; zinfo -> is_io_ack_sender_created = B_TRUE ; zinfo -> is_io_receiver_created = B_TRUE ; ( void ) pthread_mutex_unlock ( & zinfo -> zinfo_mutex ) ; thrd_arg = kmem_alloc ( sizeof ( thread_args_t ) , KM_SLEEP ) ; thrd_arg -> fd = fd ; thrd_arg -> zinfo = zinfo ; uzfs_zinfo_take_refcnt ( zinfo ) ; thrd_info = zk_thread_create ( NULL , 0 , ( thread_func_t ) uzfs_zvol_io_ack_sender , ( void * ) thrd_arg , 0 , NULL , TS_RUN , 0 , PTHREAD_CREATE_DETACHED ) ; VERIFY3P ( thrd_info , != , NULL ) ; hdr . status = ZVOL_OP_STATUS_OK ; open_reply : hdr . len = 0 ; rc = uzfs_zvol_socket_write ( fd , ( char * ) & hdr , sizeof ( hdr ) ) ; if ( rc == - 1 ) LOG_ERR ( "Failed<S2SV_blank>to<S2SV_blank>send<S2SV_blank>reply<S2SV_blank>for<S2SV_blank>open<S2SV_blank>request" ) ; if ( hdr . status != ZVOL_OP_STATUS_OK ) { ASSERT3P ( * zinfopp , == , NULL ) ; if ( zinfo != NULL ) uzfs_zinfo_drop_refcnt ( zinfo ) ; return ( - 1 ) ; } return ( rc ) ; } | <S2SV_ModStart> zinfo -> clone_zv , NULL |
4,817 | CWE-000 <S2SV_StartBug> static int commit_contains ( struct ref_filter * filter , struct commit * commit ) <S2SV_EndBug> { if ( filter -> with_commit_tag_algo ) <S2SV_StartBug> return contains_tag_algo ( commit , filter -> with_commit ) == CONTAINS_YES ; <S2SV_EndBug> return is_descendant_of ( commit , filter -> with_commit ) ; } | <S2SV_ModStart> commit * commit , struct contains_cache * cache <S2SV_ModStart> filter -> with_commit , cache |
4,818 | CWE-000 static int read_u64 ( struct archive_read * a , uint64_t * pvalue ) { const uint8_t * p ; if ( ! read_ahead ( a , 8 , & p ) ) return 0 ; <S2SV_StartBug> * pvalue = * ( const uint64_t * ) p ; <S2SV_EndBug> return ARCHIVE_OK == consume ( a , 8 ) ? 1 : 0 ; } | <S2SV_ModStart> * pvalue = archive_le64dec ( p ) <S2SV_ModEnd> ; return ARCHIVE_OK |
4,819 | CWE-000 static void vol_release ( struct device * dev ) { struct ubi_volume * vol = container_of ( dev , struct ubi_volume , dev ) ; <S2SV_StartBug> ubi_assert ( vol -> removed ) ; <S2SV_EndBug> kfree ( vol ) ; } | <S2SV_ModStart> dev ) ; <S2SV_ModEnd> kfree ( vol |
4,820 | CWE-000 void __assert ( bool_t ok , string_t expr , string_t file , uint_t line , string_t func ) { if ( ! ok ) { printf ( "Assert<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>expression<S2SV_blank>\\"%s\\"<S2SV_blank>in<S2SV_blank>%s:%u,<S2SV_blank>%s\\r\\n" , expr , file , line , func ) ; <S2SV_StartBug> } <S2SV_EndBug> while ( TRUE ) { } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> func ) ; <S2SV_ModEnd> while ( TRUE <S2SV_ModStart> { } } } |
4,821 | CWE-000 <S2SV_StartBug> int func1 ( ) <S2SV_EndBug> { return 1 ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static |
4,822 | CWE-000 int rsi_send_bt_pkt ( struct rsi_common * common , struct sk_buff * skb ) { struct rsi_hw * adapter = common -> priv ; int status = - EINVAL ; u8 header_size = 0 ; __le16 * frame_desc ; <S2SV_StartBug> header_size = FRAME_DESC_SZ ; <S2SV_EndBug> if ( header_size > skb_headroom ( skb ) ) { ven_rsi_dbg ( ERR_ZONE , "%s:<S2SV_blank>Not<S2SV_blank>enough<S2SV_blank>headroom\\n" , __func__ ) ; status = - ENOSPC ; <S2SV_StartBug> goto err ; <S2SV_EndBug> } skb_push ( skb , header_size ) ; frame_desc = ( __le16 * ) & skb -> data [ 0 ] ; memset ( ( u8 * ) frame_desc , 0 , header_size ) ; frame_desc [ 0 ] = cpu_to_le16 ( skb -> len - FRAME_DESC_SZ ) ; frame_desc [ 0 ] |= ( cpu_to_le16 ( RSI_BT_DATA_Q ) & 0x7 ) << 12 ; frame_desc [ 7 ] = cpu_to_le16 ( bt_cb ( skb ) -> pkt_type ) ; rsi_hex_dump ( DATA_TX_ZONE , "TX<S2SV_blank>BT<S2SV_blank>pkt" , skb -> data , skb -> len ) ; status = adapter -> host_intf_ops -> write_pkt ( common -> priv , skb -> data , skb -> len ) ; if ( status ) ven_rsi_dbg ( ERR_ZONE , "%s:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>write<S2SV_blank>bt<S2SV_blank>pkt\\n" , __func__ ) ; <S2SV_StartBug> err : <S2SV_EndBug> dev_kfree_skb ( skb ) ; return status ; } | <S2SV_ModStart> * frame_desc ; u8 queueno = ( ( skb -> data [ 1 ] >> 4 ) & 0xf ) ; if ( queueno == RSI_BT_MGMT_Q ) { rsi_hex_dump ( MGMT_TX_ZONE , "TX<S2SV_blank>BT<S2SV_blank>Mgmt<S2SV_blank>Pkt" , skb -> data , skb -> len ) ; status = adapter -> host_intf_ops -> write_pkt ( common -> priv , skb -> data , skb -> len ) ; if ( status ) ven_rsi_dbg ( ERR_ZONE , "%s:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>write<S2SV_blank>bt<S2SV_blank>mgmt<S2SV_blank>pkt\\n" , __func__ ) ; goto out ; } <S2SV_ModStart> ENOSPC ; goto out <S2SV_ModEnd> ; } skb_push <S2SV_ModStart> __func__ ) ; out <S2SV_ModEnd> : dev_kfree_skb ( |
4,823 | CWE-000 XLogRecPtr XLogInsertRecord ( XLogRecData * rdata , XLogRecPtr fpw_lsn ) { XLogCtlInsert * Insert = & XLogCtl -> Insert ; pg_crc32c rdata_crc ; bool inserted ; XLogRecord * rechdr = ( XLogRecord * ) rdata -> data ; bool isLogSwitch = ( rechdr -> xl_rmid == RM_XLOG_ID && rechdr -> xl_info == XLOG_SWITCH ) ; XLogRecPtr StartPos ; XLogRecPtr EndPos ; <S2SV_StartBug> Assert ( rdata -> len >= SizeOfXLogRecord ) ; <S2SV_EndBug> if ( ! XLogInsertAllowed ( ) ) elog ( ERROR , "cannot<S2SV_blank>make<S2SV_blank>new<S2SV_blank>WAL<S2SV_blank>entries<S2SV_blank>during<S2SV_blank>recovery" ) ; START_CRIT_SECTION ( ) ; if ( isLogSwitch ) WALInsertLockAcquireExclusive ( ) ; else WALInsertLockAcquire ( ) ; if ( RedoRecPtr != Insert -> RedoRecPtr ) { Assert ( RedoRecPtr < Insert -> RedoRecPtr ) ; RedoRecPtr = Insert -> RedoRecPtr ; } doPageWrites = ( Insert -> fullPageWrites || Insert -> forcePageWrites ) ; <S2SV_StartBug> if ( fpw_lsn != InvalidXLogRecPtr && fpw_lsn <= RedoRecPtr && doPageWrites ) <S2SV_EndBug> { WALInsertLockRelease ( ) ; END_CRIT_SECTION ( ) ; return InvalidXLogRecPtr ; } if ( isLogSwitch ) inserted = ReserveXLogSwitch ( & StartPos , & EndPos , & rechdr -> xl_prev ) ; else { ReserveXLogInsertLocation ( rechdr -> xl_tot_len , & StartPos , & EndPos , & rechdr -> xl_prev ) ; inserted = true ; } if ( inserted ) { rdata_crc = rechdr -> xl_crc ; COMP_CRC32C ( rdata_crc , rechdr , offsetof ( XLogRecord , xl_crc ) ) ; FIN_CRC32C ( rdata_crc ) ; rechdr -> xl_crc = rdata_crc ; CopyXLogRecordToWAL ( rechdr -> xl_tot_len , isLogSwitch , rdata , StartPos , EndPos ) ; } else { } WALInsertLockRelease ( ) ; MarkCurrentTransactionIdLoggedIfAny ( ) ; END_CRIT_SECTION ( ) ; if ( StartPos / XLOG_BLCKSZ != EndPos / XLOG_BLCKSZ ) { SpinLockAcquire ( & XLogCtl -> info_lck ) ; if ( XLogCtl -> LogwrtRqst . Write < EndPos ) XLogCtl -> LogwrtRqst . Write = EndPos ; LogwrtResult = XLogCtl -> LogwrtResult ; SpinLockRelease ( & XLogCtl -> info_lck ) ; } if ( isLogSwitch ) { TRACE_POSTGRESQL_XLOG_SWITCH ( ) ; XLogFlush ( EndPos ) ; if ( inserted ) { EndPos = StartPos + SizeOfXLogRecord ; if ( StartPos / XLOG_BLCKSZ != EndPos / XLOG_BLCKSZ ) { if ( EndPos % XLOG_SEG_SIZE == EndPos % XLOG_BLCKSZ ) EndPos += SizeOfXLogLongPHD ; else EndPos += SizeOfXLogShortPHD ; } } } # ifdef WAL_DEBUG if ( XLOG_DEBUG ) { static XLogReaderState * debug_reader = NULL ; StringInfoData buf ; StringInfoData recordBuf ; char * errormsg = NULL ; MemoryContext oldCxt ; oldCxt = MemoryContextSwitchTo ( walDebugCxt ) ; initStringInfo ( & buf ) ; appendStringInfo ( & buf , "INSERT<S2SV_blank>@<S2SV_blank>%X/%X:<S2SV_blank>" , ( uint32 ) ( EndPos >> 32 ) , ( uint32 ) EndPos ) ; initStringInfo ( & recordBuf ) ; for ( ; rdata != NULL ; rdata = rdata -> next ) appendBinaryStringInfo ( & recordBuf , rdata -> data , rdata -> len ) ; if ( ! debug_reader ) debug_reader = XLogReaderAllocate ( NULL , NULL ) ; if ( ! debug_reader ) { appendStringInfoString ( & buf , "error<S2SV_blank>decoding<S2SV_blank>record:<S2SV_blank>out<S2SV_blank>of<S2SV_blank>memory" ) ; } else if ( ! DecodeXLogRecord ( debug_reader , ( XLogRecord * ) recordBuf . data , & errormsg ) ) { appendStringInfo ( & buf , "error<S2SV_blank>decoding<S2SV_blank>record:<S2SV_blank>%s" , errormsg ? errormsg : "no<S2SV_blank>error<S2SV_blank>message" ) ; } else { appendStringInfoString ( & buf , "<S2SV_blank>-<S2SV_blank>" ) ; xlog_outdesc ( & buf , debug_reader ) ; } elog ( LOG , "%s" , buf . data ) ; pfree ( buf . data ) ; pfree ( recordBuf . data ) ; MemoryContextSwitchTo ( oldCxt ) ; } # endif ProcLastRecPtr = StartPos ; XactLastRecEnd = EndPos ; return EndPos ; } | <S2SV_ModStart> XLogRecPtr EndPos ; bool prevDoPageWrites = doPageWrites ; <S2SV_ModStart> ) ; if ( doPageWrites && ( ! prevDoPageWrites || <S2SV_ModStart> fpw_lsn <= RedoRecPtr ) ) <S2SV_ModEnd> ) { WALInsertLockRelease |
4,824 | CWE-000 void model_plot ( model_t * model ) { START_FUNCTION_TIMER ( ) ; <S2SV_StartBug> int nprocs ; <S2SV_EndBug> MPI_Comm_size ( model -> global_comm , & nprocs ) ; <S2SV_StartBug> if ( model -> sim_name == NULL ) <S2SV_EndBug> <S2SV_StartBug> polymec_error ( "No<S2SV_blank>simulation<S2SV_blank>name<S2SV_blank>was<S2SV_blank>set<S2SV_blank>with<S2SV_blank>model_set_sim_name." ) ; <S2SV_EndBug> char prefix [ FILENAME_MAX ] , dir [ FILENAME_MAX ] ; snprintf ( prefix , FILENAME_MAX , "%s_plot" , model -> sim_name ) ; if ( model -> sim_path != NULL ) snprintf ( dir , FILENAME_MAX , "%s/%s-%d" , model -> sim_path , model -> sim_name , nprocs ) ; else snprintf ( dir , FILENAME_MAX , "%s-%d" , model -> sim_name , nprocs ) ; <S2SV_StartBug> log_detail ( "%s:<S2SV_blank>Writing<S2SV_blank>plot<S2SV_blank>to<S2SV_blank>directory<S2SV_blank>%s..." , model -> name , dir ) ; <S2SV_EndBug> <S2SV_StartBug> model -> vtable . plot ( model -> context , prefix , dir , model -> time , model -> step ) ; <S2SV_EndBug> STOP_FUNCTION_TIMER ( ) ; } | <S2SV_ModStart> ( ) ; <S2SV_ModEnd> if ( model <S2SV_ModStart> ( model -> vtable . plot <S2SV_ModEnd> == NULL ) <S2SV_ModStart> ) polymec_error ( "Plotting<S2SV_blank>is<S2SV_blank>not<S2SV_blank>supported<S2SV_blank>by<S2SV_blank>this<S2SV_blank>model." <S2SV_ModEnd> ) ; log_detail <S2SV_ModStart> -> name , model -> sim_dir <S2SV_ModEnd> ) ; model <S2SV_ModStart> -> context , model -> sim_prefix , model -> sim_dir <S2SV_ModEnd> , model -> |
4,825 | CWE-000 void GB_apu_init ( GB_gameboy_t * gb ) { memset ( & gb -> apu , 0 , sizeof ( gb -> apu ) ) ; gb -> io_registers [ GB_IO_NR50 ] = 0x77 ; for ( int i = 0 ; i < 4 ; i ++ ) { gb -> apu . left_enabled [ i ] = gb -> apu . right_enabled [ i ] = true ; } gb -> apu . wave_channel . sample_length = 0x7FF ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> = 0x7FF ; gb -> apu . square_carry = 1 ; |
4,826 | CWE-000 int main ( int argc , char * argv [ ] ) { if ( ( argc > 1 ) && ( * ( argv [ 1 ] ) == 'h' ) ) { print_help ( ) ; return 0 ; } char * input_pt ; double subtotal = 0.0 ; <S2SV_StartBug> double radicand = 0.0 ; <S2SV_EndBug> struct Input input ; input . is_done = 0 ; input . is_initialized = 0 ; input . opr = '\\0' ; input . new_num = 0.0 ; input . tmp = 0.0 ; <S2SV_StartBug> input . type = '\\0' ; <S2SV_EndBug> struct Input last_input ; last_input . was_num = 0 ; last_input . was_operator = 0 ; last_input . was_root = 0 ; <S2SV_StartBug> printf ( "Please<S2SV_blank>enter<S2SV_blank>what<S2SV_blank>you<S2SV_blank>want<S2SV_blank>to<S2SV_blank>calculate.<S2SV_blank>Enter<S2SV_blank>\\"=\\"<S2SV_blank>to<S2SV_blank>get<S2SV_blank>subtotal<S2SV_blank>and<S2SV_blank>quit.<S2SV_blank>If<S2SV_blank>you<S2SV_blank>wish<S2SV_blank>to<S2SV_blank>see\\\n<S2SV_blank><S2SV_blank>brief<S2SV_blank>help<S2SV_blank>section,<S2SV_blank>you<S2SV_blank>may<S2SV_blank>launch<S2SV_blank>program<S2SV_blank>with<S2SV_blank>\\"h\\"<S2SV_blank>argument,<S2SV_blank>like<S2SV_blank>so:<S2SV_blank>\\"./calc<S2SV_blank>h\\".\\n" ) ; <S2SV_EndBug> while ( 1 ) { input_pt = query_input ( ) ; input . type = identify_input ( & input_pt , subtotal , input ) ; if ( type_is_operator ( input . type ) && ( get_operator ( & input_pt ) == '=' ) ) input . is_done = 1 ; if ( ! input . type || ( type_is_operator ( input . type ) && ( isnan ( input . tmp ) || isinf ( input . tmp ) ) ) || <S2SV_StartBug> ( type_is_num ( input . type ) && last_input . was_root ) || <S2SV_EndBug> ( ! type_is_num ( input . type ) && ! ( last_input . was_num || last_input . was_root ) && ! ( type_is_operator ( input . type ) && last_input . was_operator ) ) ) { if ( input . is_done ) break ; print_error ( & input_pt , input ) ; continue ; } if ( input . type && type_is_num ( input . type ) ) { input . new_num = get_num ( & input_pt , subtotal ) ; } else input . opr = get_operator ( & input_pt ) ; if ( input . type && ( type_is_num ( input . type ) || type_is_root ( input . type ) ) ) { if ( ! input . opr ) { input . tmp = input . new_num ; } else { <S2SV_StartBug> radicand = input . tmp ; <S2SV_EndBug> if ( input . opr ) input . tmp = do_math ( subtotal , input ) ; if ( isnan ( input . tmp ) || isinf ( input . tmp ) ) { print_subtotal ( subtotal , input ) ; print_error ( & input_pt , input ) ; input . tmp = subtotal ; continue ; } } if ( type_is_num ( input . type ) ) print_subtotal ( subtotal , input ) ; else if ( type_is_root ( input . type ) ) <S2SV_StartBug> print_subtotal ( radicand , input ) ; <S2SV_EndBug> } else if ( input . type && type_is_operator ( input . type ) ) subtotal = input . tmp ; last_input . was_operator = type_is_operator ( input . type ) ; last_input . was_num = type_is_num ( input . type ) ; last_input . was_root = type_is_root ( input . type ) ; if ( input . is_done ) break ; } printf ( "Result<S2SV_blank>is:<S2SV_blank>%f\\n" , subtotal ) ; return 0 ; } | <S2SV_ModStart> = 0.0 ; int error_code = 0 <S2SV_ModEnd> ; struct Input <S2SV_ModStart> ; input . radicand = 0.0 ; input . <S2SV_ModStart> ; printf ( "Please<S2SV_blank>enter<S2SV_blank>what<S2SV_blank>you<S2SV_blank>want<S2SV_blank>to<S2SV_blank>calculate.<S2SV_blank>Enter<S2SV_blank>\\"=\\"<S2SV_blank>to<S2SV_blank>get<S2SV_blank>subtotal<S2SV_blank>and<S2SV_blank>quit.<S2SV_blank>If<S2SV_blank>you<S2SV_blank>wish<S2SV_blank>to<S2SV_blank>see\\\n<S2SV_blank>brief<S2SV_blank>help<S2SV_blank>section,<S2SV_blank>you<S2SV_blank>may<S2SV_blank>launch<S2SV_blank>program<S2SV_blank>with<S2SV_blank>\\"h\\"<S2SV_blank>argument,<S2SV_blank>like<S2SV_blank>so:<S2SV_blank>\\"./calc<S2SV_blank>h\\".\\n" <S2SV_ModEnd> ) ; while <S2SV_ModStart> type ) && ( ( <S2SV_ModStart> last_input . was_root ) || input . opr == 'r' ) <S2SV_ModStart> } else { input . <S2SV_ModStart> ) print_subtotal ( input . |
4,827 | CWE-000 void main ( ) { int i = 0 ; while ( i ++ < 1000 ) { PrintChar ( 'A' ) ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ) ; } Print ( "End<S2SV_blank>A\\n" ) ; |
4,828 | CWE-000 void S_SetMusicVolume ( int volume ) { if ( volume < 0 || volume > 127 ) { I_Error ( "Attempt<S2SV_blank>to<S2SV_blank>set<S2SV_blank>music<S2SV_blank>volume<S2SV_blank>at<S2SV_blank>%d" , volume ) ; } <S2SV_StartBug> I_SetMusicVolume ( volume ) ; <S2SV_EndBug> } | <S2SV_ModStart> ) ; } if ( musicVolume == 0 ) { I_PauseSong ( ) ; mus_paused = true ; } else { I_ResumeSong ( ) ; mus_paused = false ; } |
4,829 | CWE-000 struct cooling_tables get_redshift_invariant_table ( struct cooling_function_data * restrict cooling ) { # ifdef HAVE_HDF5 struct cooling_tables cooling_table ; hid_t file_id , dataset ; herr_t status ; char fname [ 500 ] , set_name [ 500 ] ; int specs , i , j , k , table_index , cooling_index ; float * net_cooling_rate ; float * electron_abundance ; float * temperature ; float * he_net_cooling_rate ; float * he_electron_abundance ; net_cooling_rate = ( float * ) malloc ( cooling -> N_Temp * cooling -> N_nH * sizeof ( float ) ) ; electron_abundance = ( float * ) malloc ( cooling -> N_Temp * cooling -> N_nH * sizeof ( float ) ) ; temperature = ( float * ) malloc ( cooling -> N_He * cooling -> N_Temp * cooling -> N_nH * sizeof ( float ) ) ; he_net_cooling_rate = ( float * ) malloc ( cooling -> N_He * cooling -> N_Temp * cooling -> N_nH * sizeof ( float ) ) ; he_electron_abundance = ( float * ) malloc ( cooling -> N_He * cooling -> N_Temp * cooling -> N_nH * sizeof ( float ) ) ; cooling_table . metal_heating = ( float * ) malloc ( cooling -> N_Elements * cooling -> N_Temp * cooling -> N_nH * sizeof ( float ) ) ; cooling_table . electron_abundance = ( float * ) malloc ( cooling -> N_Temp * cooling -> N_nH * sizeof ( float ) ) ; cooling_table . temperature = ( float * ) malloc ( cooling -> N_He * cooling -> N_Temp * cooling -> N_nH * sizeof ( float ) ) ; cooling_table . H_plus_He_heating = ( float * ) malloc ( cooling -> N_He * cooling -> N_Temp * cooling -> N_nH * sizeof ( float ) ) ; cooling_table . H_plus_He_electron_abundance = ( float * ) malloc ( cooling -> N_He * cooling -> N_Temp * cooling -> N_nH * sizeof ( float ) ) ; if ( cooling -> low_z_index == - 1 ) { sprintf ( fname , "%sz_8.989nocompton.hdf5" , cooling -> cooling_table_path ) ; } else if ( cooling -> low_z_index == - 2 ) { sprintf ( fname , "%sz_photodis.hdf5" , cooling -> cooling_table_path ) ; } file_id = H5Fopen ( fname , H5F_ACC_RDONLY , H5P_DEFAULT ) ; for ( specs = 0 ; specs < cooling -> N_Elements ; specs ++ ) { sprintf ( set_name , "/%s/Net_Cooling" , eagle_tables_element_names [ specs ] ) ; dataset = H5Dopen ( file_id , set_name , H5P_DEFAULT ) ; status = H5Dread ( dataset , H5T_NATIVE_FLOAT , H5S_ALL , H5S_ALL , H5P_DEFAULT , net_cooling_rate ) ; <S2SV_StartBug> status = H5Dclose ( dataset ) ; <S2SV_EndBug> for ( j = 0 ; j < cooling -> N_Temp ; j ++ ) { for ( k = 0 ; k < cooling -> N_nH ; k ++ ) { table_index = row_major_index_2d ( j , k , cooling -> N_Temp , cooling -> N_nH ) ; cooling_index = row_major_index_3d ( k , j , specs , cooling -> N_nH , cooling -> N_Temp , cooling -> N_Elements ) ; cooling_table . metal_heating [ cooling_index ] = - net_cooling_rate [ table_index ] ; } } } strcpy ( set_name , "/Metal_free/Net_Cooling" ) ; dataset = H5Dopen ( file_id , set_name , H5P_DEFAULT ) ; status = H5Dread ( dataset , H5T_NATIVE_FLOAT , H5S_ALL , H5S_ALL , H5P_DEFAULT , he_net_cooling_rate ) ; status = H5Dclose ( dataset ) ; strcpy ( set_name , "/Metal_free/Temperature/Temperature" ) ; dataset = H5Dopen ( file_id , set_name , H5P_DEFAULT ) ; status = H5Dread ( dataset , H5T_NATIVE_FLOAT , H5S_ALL , H5S_ALL , H5P_DEFAULT , temperature ) ; status = H5Dclose ( dataset ) ; strcpy ( set_name , "/Metal_free/Electron_density_over_n_h" ) ; dataset = H5Dopen ( file_id , set_name , H5P_DEFAULT ) ; status = H5Dread ( dataset , H5T_NATIVE_FLOAT , H5S_ALL , H5S_ALL , H5P_DEFAULT , he_electron_abundance ) ; status = H5Dclose ( dataset ) ; for ( i = 0 ; i < cooling -> N_He ; i ++ ) { for ( j = 0 ; j < cooling -> N_Temp ; j ++ ) { for ( k = 0 ; k < cooling -> N_nH ; k ++ ) { table_index = row_major_index_3d ( i , j , k , cooling -> N_He , cooling -> N_Temp , cooling -> N_nH ) ; cooling_index = row_major_index_3d ( k , i , j , cooling -> N_nH , cooling -> N_He , cooling -> N_Temp ) ; cooling_table . H_plus_He_heating [ cooling_index ] = - he_net_cooling_rate [ table_index ] ; cooling_table . H_plus_He_electron_abundance [ cooling_index ] = he_electron_abundance [ table_index ] ; cooling_table . temperature [ cooling_index ] = log10 ( temperature [ table_index ] ) ; } } } strcpy ( set_name , "/Solar/Electron_density_over_n_h" ) ; dataset = H5Dopen ( file_id , set_name , H5P_DEFAULT ) ; status = H5Dread ( dataset , H5T_NATIVE_FLOAT , H5S_ALL , H5S_ALL , H5P_DEFAULT , electron_abundance ) ; status = H5Dclose ( dataset ) ; for ( i = 0 ; i < cooling -> N_Temp ; i ++ ) { for ( j = 0 ; j < cooling -> N_nH ; j ++ ) { table_index = row_major_index_2d ( i , j , cooling -> N_Temp , cooling -> N_nH ) ; cooling_index = row_major_index_2d ( j , i , cooling -> N_nH , cooling -> N_Temp ) ; cooling_table . electron_abundance [ cooling_index ] = electron_abundance [ table_index ] ; } } status = H5Fclose ( file_id ) ; free ( net_cooling_rate ) ; free ( electron_abundance ) ; free ( temperature ) ; free ( he_net_cooling_rate ) ; free ( he_electron_abundance ) ; # ifdef SWIFT_DEBUG_CHECKS message ( "done<S2SV_blank>reading<S2SV_blank>in<S2SV_blank>redshift<S2SV_blank>invariant<S2SV_blank>table" ) ; # endif return cooling_table ; # else error ( "Need<S2SV_blank>HDF5<S2SV_blank>to<S2SV_blank>read<S2SV_blank>cooling<S2SV_blank>tables" ) ; # endif } | <S2SV_ModStart> net_cooling_rate ) ; if ( status < 0 ) error ( "error<S2SV_blank>reading<S2SV_blank>cooling<S2SV_blank>rate<S2SV_blank>table" ) ; |
4,830 | CWE-000 int io_cleanup ( void ) { int slave , i ; for ( slave = 1 ; slave <= slave_num ; slave ++ ) { for ( i = 1 ; i <= slave_list [ slave ] . input_list_num ; i ++ ) free ( slave_list [ slave ] . input_pdo_set_list [ i ] . pdo_mapping_list ) ; for ( i = 1 ; i <= slave_list [ slave ] . output_list_num ; i ++ ) free ( slave_list [ slave ] . output_pdo_set_list [ i ] . pdo_mapping_list ) ; free ( slave_list [ slave ] . input_pdo_set_list ) ; free ( slave_list [ slave ] . output_pdo_set_list ) ; } free ( slave_list ) ; if ( input_list != NULL ) { free ( input_list ) ; input_list = NULL ; input_count = 0 ; } if ( output_list != NULL ) { free ( output_list ) ; output_list = NULL ; output_count = 0 ; } if ( is_connected ) { ec_slave [ 0 ] . state = EC_STATE_INIT ; ec_writestate ( 0 ) ; ec_close ( ) ; <S2SV_StartBug> } <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> ( ) ; is_connected = 0 ; |
4,831 | CWE-000 static ngx_int_t ngx_http_upstream_dynamic_servers_init_process ( ngx_cycle_t * cycle ) { <S2SV_StartBug> ngx_http_upstream_dynamic_server_main_conf_t * udsmcf = ngx_http_cycle_get_module_main_conf ( cycle , ngx_http_upstream_dynamic_servers_module ) ; <S2SV_EndBug> ngx_http_upstream_dynamic_server_conf_t * dynamic_server = udsmcf -> dynamic_servers . elts ; ngx_uint_t i ; ngx_event_t * timer ; ngx_uint_t refresh_in ; for ( i = 0 ; i < udsmcf -> dynamic_servers . nelts ; i ++ ) { timer = & dynamic_server [ i ] . timer ; timer -> handler = ngx_http_upstream_dynamic_server_resolve ; timer -> log = cycle -> log ; timer -> data = & dynamic_server [ i ] ; refresh_in = ngx_random ( ) % 1000 ; ngx_log_debug ( NGX_LOG_DEBUG_CORE , cycle -> log , 0 , "upstream-dynamic-servers:<S2SV_blank>Initial<S2SV_blank>DNS<S2SV_blank>refresh<S2SV_blank>of<S2SV_blank>\'%V\'<S2SV_blank>in<S2SV_blank>%ims" , & dynamic_server [ i ] . host , refresh_in ) ; ngx_add_timer ( timer , refresh_in ) ; } return NGX_OK ; } | <S2SV_ModStart> ngx_http_upstream_dynamic_servers_module ) ; if ( udsmcf == NULL ) { return NGX_OK ; } |
4,832 | CWE-000 static int execute_test_large_message ( const SSL_METHOD * smeth , const SSL_METHOD * cmeth ) { SSL_CTX * cctx = NULL , * sctx = NULL ; SSL * clientssl = NULL , * serverssl = NULL ; int testresult = 0 ; int i ; BIO * certbio = BIO_new_file ( cert , "r" ) ; X509 * chaincert = NULL ; int certlen ; if ( certbio == NULL ) { printf ( "Can\'t<S2SV_blank>load<S2SV_blank>the<S2SV_blank>certficate<S2SV_blank>file\\n" ) ; goto end ; } chaincert = PEM_read_bio_X509 ( certbio , NULL , NULL , NULL ) ; <S2SV_StartBug> if ( ! create_ssl_ctx_pair ( smeth , cmeth , & sctx , <S2SV_EndBug> & cctx , cert , privkey ) ) { printf ( "Unable<S2SV_blank>to<S2SV_blank>create<S2SV_blank>SSL_CTX<S2SV_blank>pair\\n" ) ; goto end ; } <S2SV_StartBug> BIO_free ( certbio ) ; <S2SV_EndBug> certbio = NULL ; certlen = i2d_X509 ( chaincert , NULL ) ; OPENSSL_assert ( ( certlen * NUM_EXTRA_CERTS ) > ( ( SSL3_RT_MAX_PLAIN_LENGTH * 4 ) / 3 ) ) ; for ( i = 0 ; i < NUM_EXTRA_CERTS ; i ++ ) { if ( ! X509_up_ref ( chaincert ) ) { printf ( "Unable<S2SV_blank>to<S2SV_blank>up<S2SV_blank>ref<S2SV_blank>cert\\n" ) ; goto end ; } if ( ! SSL_CTX_add_extra_chain_cert ( sctx , chaincert ) ) { printf ( "Unable<S2SV_blank>to<S2SV_blank>add<S2SV_blank>extra<S2SV_blank>chain<S2SV_blank>cert<S2SV_blank>%d\\n" , i ) ; X509_free ( chaincert ) ; goto end ; } } if ( ! create_ssl_objects ( sctx , cctx , & serverssl , & clientssl , NULL , NULL ) ) { printf ( "Unable<S2SV_blank>to<S2SV_blank>create<S2SV_blank>SSL<S2SV_blank>objects\\n" ) ; goto end ; } if ( ! create_ssl_connection ( serverssl , clientssl ) ) { printf ( "Unable<S2SV_blank>to<S2SV_blank>create<S2SV_blank>SSL<S2SV_blank>connection\\n" ) ; goto end ; } testresult = 1 ; end : X509_free ( chaincert ) ; SSL_free ( serverssl ) ; SSL_free ( clientssl ) ; SSL_CTX_free ( sctx ) ; SSL_CTX_free ( cctx ) ; return testresult ; } | <S2SV_ModStart> NULL ) ; BIO_free ( certbio ) ; certbio = NULL ; if ( chaincert == NULL ) { printf ( "Unable<S2SV_blank>to<S2SV_blank>load<S2SV_blank>certificate<S2SV_blank>for<S2SV_blank>chain\\n" ) ; goto end ; } <S2SV_ModStart> end ; } <S2SV_ModEnd> certlen = i2d_X509 |
4,833 | CWE-000 static void book_enabled_cb ( DhBook * book , DhBookManager * book_manager ) { DhBookManagerPrivate * priv = dh_book_manager_get_instance_private ( book_manager ) ; GList * node ; gchar * book_id ; node = find_book_in_disabled_list ( priv -> books_disabled , book ) ; g_return_if_fail ( node != NULL ) ; book_id = node -> data ; g_free ( book_id ) ; priv -> books_disabled = g_list_delete_link ( priv -> books_disabled , node ) ; store_books_disabled ( book_manager ) ; <S2SV_StartBug> inc_language ( book_manager , dh_book_get_language ( book ) ) ; <S2SV_EndBug> g_signal_emit ( book_manager , signals [ BOOK_ENABLED ] , 0 , book ) ; } | <S2SV_ModStart> book_manager ) ; <S2SV_ModEnd> g_signal_emit ( book_manager |
4,834 | CWE-000 int main ( int argc , char * argv [ ] ) { int err ; signal ( SIGINT , sighandler ) ; <S2SV_StartBug> printf ( "%d" , getHeight ( ) ) ; <S2SV_EndBug> char host [ 100 ] ; char rawuser [ 100 ] ; printf ( "\\e[1;1H\\e[2J" ) ; printf ( HEADER ) ; printf ( "%s\\n\\n" , promptLine ( getWidth ( ) ) ) ; printf ( "Enter<S2SV_blank>a<S2SV_blank>unique<S2SV_blank>username:\\n\\nUsername:<S2SV_blank>" ) ; fgets ( rawuser , sizeof ( rawuser ) , stdin ) ; char user [ 100 ] ; * strchr ( rawuser , '\\n' ) = 0 ; strcpy ( user , multiParse ( rawuser ) ) ; printf ( "Enter<S2SV_blank>a<S2SV_blank>chatroom<S2SV_blank>address<S2SV_blank>to<S2SV_blank>connect!\\n(xxx.xxx.xxx.xxx)\\n\\nAddress:<S2SV_blank>" ) ; fgets ( host , sizeof ( host ) , stdin ) ; * strchr ( host , '\\n' ) = 0 ; int sd ; sd = client_connect ( host ) ; char buffer [ MESSAGE_BUFFER_SIZE ] ; char newbuff [ MESSAGE_BUFFER_SIZE ] ; <S2SV_StartBug> int f = fork ( ) ; <S2SV_EndBug> printf ( HEADER ) ; printf ( "%s\\n" , promptLine ( getWidth ( ) ) ) ; printClear ( getHeight ( ) ) ; if ( f == 0 ) { while ( run ) { printf ( "%s\\n" , promptLine ( getWidth ( ) ) ) ; fgets ( buffer , sizeof ( buffer ) , stdin ) ; strcpy ( newbuff , multiParse ( buffer ) ) ; char message [ MESSAGE_BUFFER_SIZE ] ; message [ 0 ] = 0 ; strcat ( message , user ) ; strcat ( message , ":<S2SV_blank>" ) ; strcat ( message , newbuff ) ; int dLines = findDLines ( getWidth ( ) , newbuff ) ; char * dString = dLineString ( dLines ) ; printf ( "%s%s:<S2SV_blank>%s" , dString , user , newbuff ) ; if ( run ) { err = write ( sd , message , sizeof ( message ) ) ; error_check ( err , "writing<S2SV_blank>to<S2SV_blank>server" ) ; } } <S2SV_StartBug> printf ( "[client]<S2SV_blank>received<S2SV_blank>exit<S2SV_blank>signal,<S2SV_blank>sending<S2SV_blank>exit<S2SV_blank>message<S2SV_blank>to<S2SV_blank>server\\n" ) ; <S2SV_EndBug> char * exiter = "EXIT" ; write ( sd , exiter , 5 ) ; <S2SV_StartBug> printf ( "writer<S2SV_blank>exiting...\\n" ) ; <S2SV_EndBug> exit ( 1 ) ; } else { while ( run ) { char buffer2 [ MESSAGE_BUFFER_SIZE ] ; err = read ( sd , buffer2 , sizeof ( buffer2 ) ) ; error_check ( err , "reading<S2SV_blank>from<S2SV_blank>server" ) ; if ( ! strcmp ( "EXIT" , buffer2 ) ) break ; printf ( "\\033[1A\\x1b[K%s%s\\n" , buffer2 , promptLine ( getWidth ( ) ) ) ; } <S2SV_StartBug> printf ( "reader<S2SV_blank>exiting...<S2SV_blank>\\n" ) ; <S2SV_EndBug> exit ( 1 ) ; } } | <S2SV_ModStart> sighandler ) ; <S2SV_ModEnd> char host [ <S2SV_ModStart> = fork ( ) ; printf ( WELCOME ) ; printf ( WELCOME2 <S2SV_ModStart> } printf ( "\\nYou<S2SV_blank>have<S2SV_blank>been<S2SV_blank>disconnected!\\n" <S2SV_ModEnd> ) ; char <S2SV_ModStart> 5 ) ; <S2SV_ModEnd> exit ( 1 <S2SV_ModStart> ) ; } <S2SV_ModEnd> exit ( 1 |
4,835 | CWE-000 void apply_ld ( t_process * process , t_env * env ) { t_args args [ 3 ] ; <S2SV_StartBug> uint32_t val ; <S2SV_EndBug> uint32_t reg ; uint32_t addr ; decode ( args , env -> memory [ process -> pc ] , env -> memory [ process -> pc + 1 ] ) ; addr = process -> pc + BYPASS_ARG_ENCODE ; <S2SV_StartBug> val = get_args ( env -> memory , addr , args [ 0 ] . length ) ; <S2SV_EndBug> val = return_value ( process , env -> memory , args [ 0 ] , val ) ; addr += args [ 0 ] . length ; reg = get_args ( env -> memory , addr , T_REG ) ; process -> reg [ reg - 1 ] = val ; process -> nb_cycle -= 5 ; <S2SV_StartBug> process -> pc += BYPASS ( args , BYPASS_ARG_ENCODE ) ; <S2SV_EndBug> process -> carry = ( val == 0 ) ; } | <S2SV_ModStart> 3 ] ; int16_t <S2SV_ModEnd> val ; uint32_t <S2SV_ModStart> ; val = ( int16_t ) <S2SV_ModStart> -> pc += BYPASS_ARG_ENCODE + args [ 0 ] . length + args [ 1 ] . length <S2SV_ModEnd> ; process -> |
4,836 | CWE-000 long kvmppc_read_intr ( void ) { long ret = 0 ; long rc ; <S2SV_StartBug> bool again ; <S2SV_EndBug> do { again = false ; rc = kvmppc_read_one_intr ( & again ) ; if ( rc && ( ret == 0 || rc > ret ) ) ret = rc ; } while ( again ) ; return ret ; } | <S2SV_ModStart> ; bool again ; if ( xive_enabled ( ) ) return 1 |
4,837 | CWE-000 static PyObject * new_tcp ( PyObject * self , PyObject * args ) { char * ip ; int port = 502 ; if ( ! PyArg_ParseTuple ( args , "s|i" , & ip , & port ) ) { PyErr_SetString ( PyModbusError , "Invalid<S2SV_blank>input<S2SV_blank>parameter." ) ; return NULL ; } mb = modbus_new_tcp ( ip , port ) ; if ( mb == NULL ) { PyErr_SetString ( PyModbusError , modbus_strerror ( errno ) ) ; return NULL ; } if ( - 1 == modbus_connect ( mb ) ) { <S2SV_StartBug> PyErr_SetString ( PyModbusError , modbus_strerror ( errno ) ) ; <S2SV_EndBug> return NULL ; } modbus_set_slave ( mb , slave_addr ) ; return Py_BuildValue ( "O" , Py_True ) ; } | <S2SV_ModStart> ) ) { modbus_free ( mb ) ; |
4,838 | CWE-000 int gpiod_line_set_value_bulk ( struct gpiod_line_bulk * bulk , int * values ) { struct gpiohandle_data data ; struct gpiod_line * line ; unsigned int i ; int status ; <S2SV_StartBug> if ( ! line_bulk_is_requested ( bulk ) ) { <S2SV_EndBug> errno = EPERM ; return - 1 ; <S2SV_StartBug> } <S2SV_EndBug> memset ( & data , 0 , sizeof ( data ) ) ; for ( i = 0 ; i < gpiod_line_bulk_num_lines ( bulk ) ; i ++ ) data . values [ i ] = ( uint8_t ) ! ! values [ i ] ; line = gpiod_line_bulk_get_line ( bulk , 0 ) ; status = ioctl ( line -> fd , GPIOHANDLE_SET_LINE_VALUES_IOCTL , & data ) ; if ( status < 0 ) return - 1 ; return 0 ; } | <S2SV_ModStart> if ( ! line_bulk_same_chip ( bulk ) || ! line_bulk_all_requested <S2SV_ModEnd> ( bulk ) <S2SV_ModStart> bulk ) ) <S2SV_ModEnd> return - 1 <S2SV_ModStart> - 1 ; <S2SV_ModEnd> memset ( & |
4,839 | CWE-000 void driver_test ( DiskDriver * disk ) { printf ( "\\t\\t\\t<S2SV_blank>Testing<S2SV_blank>disk<S2SV_blank>driver<S2SV_blank>module:\\n" ) ; printf ( "\\t\\t<S2SV_blank>Testing<S2SV_blank>disk_init:\\n" ) ; unlink ( "disk" ) ; DiskDriver_init ( disk , "disk" , 10 ) ; printf ( "associated<S2SV_blank>file<S2SV_blank>descriptor:<S2SV_blank>%d\\n" , disk -> fd ) ; printf ( "\\t<S2SV_blank>DiskHeader<S2SV_blank>info:\\n" ) ; printf ( "num<S2SV_blank>blocks:<S2SV_blank>%d\\n" , disk -> header -> num_blocks ) ; printf ( "num<S2SV_blank>bitmap<S2SV_blank>blocks:<S2SV_blank>%d\\n" , disk -> header -> bitmap_blocks ) ; printf ( "bitmap<S2SV_blank>entries:<S2SV_blank>%d\\n" , disk -> header -> bitmap_entries ) ; printf ( "num<S2SV_blank>free<S2SV_blank>blocks:<S2SV_blank>%d\\n" , disk -> header -> free_blocks ) ; printf ( "first<S2SV_blank>free<S2SV_blank>block:<S2SV_blank>%d\\n" , disk -> header -> first_free_block ) ; bitmap_info ( disk ) ; printf ( "\\t<S2SV_blank>testing<S2SV_blank>disk_write\\n" ) ; char * v = "Test<S2SV_blank>di<S2SV_blank>scrittura<S2SV_blank>su<S2SV_blank>settore<S2SV_blank>del<S2SV_blank>nostro<S2SV_blank>bellissimo<S2SV_blank>disk_driver,<S2SV_blank>devo<S2SV_blank>scrivere<S2SV_blank>tanto<S2SV_blank>per<S2SV_blank>provare<S2SV_blank>il<S2SV_blank>corretto<S2SV_blank>funzionamento.<S2SV_blank>hjefgkjhgfwsgfkgfwsejkfgshfglsujgfjkhgfjushegjkhdsgfjlhsgfvjlhdfjgyflyfgaelfialrgigsdiufgdriyihulkfuilfuhwlidiujelkifudlgdfjlvshgdshfgsdahjsfgsuyhgkjuddsdydsgflysdfydsgflydgljsgjhshgvfdljhgslhkgdkfvglhgsdlhfghdslgsajhbsdjvfgshfsdhvgsdfklgsjdgfsdhubggfjsdfgsdhjfvgsjgfgsdjhfgjsahfdfgsdilvcfsdgfvckhdsvgcbsdghfgslhcvlhgfdsjhbfhfgdsxlflvkhfgdfhsdbglgdflhegfjlhsagflhjegbfls<dgderlhfgbvsl<S2SV_blank>Test" ; <S2SV_StartBug> int result = DiskDriver_writeBlock ( & disk , v , 0 ) ; <S2SV_EndBug> printf ( "disk_write<S2SV_blank>result:<S2SV_blank>%d\\n" , result ) ; printf ( "\\t<S2SV_blank>testing<S2SV_blank>disk_read\\n" ) ; char data [ 512 ] ; <S2SV_StartBug> result = DiskDriver_readBlock ( & disk , data , 0 ) ; <S2SV_EndBug> printf ( "disk_read<S2SV_blank>result:<S2SV_blank>%d\\n" , result ) ; printf ( "Data<S2SV_blank>readed->%s<-\\nend\\n\\n" , data ) ; printf ( "\\t<S2SV_blank>testing<S2SV_blank>disk_flush\\n" ) ; <S2SV_StartBug> result = DiskDriver_flush ( & disk ) ; <S2SV_EndBug> printf ( "flush<S2SV_blank>result:<S2SV_blank>%d\\n" , result ) ; } | <S2SV_ModStart> = DiskDriver_writeBlock ( <S2SV_ModEnd> disk , v <S2SV_ModStart> = DiskDriver_readBlock ( <S2SV_ModEnd> disk , data <S2SV_ModStart> = DiskDriver_flush ( <S2SV_ModEnd> disk ) ; |
4,840 | CWE-000 void render_nametable ( PPU * ppu , WORD nametable_data , int startX , int startY ) { WORD pattern_table ; if ( ppu -> reg_ppuctrl & 0b10000 ) pattern_table = 0x1000 ; else pattern_table = 0x0000 ; BYTE backdrop_color = ppu -> VRAM [ 0x3F00 ] ; BYTE pallete [ 4 ] ; int tileX , tileY ; for ( tileY = 0 ; tileY < 30 ; tileY ++ ) { for ( tileX = 0 ; tileX < 32 ; tileX ++ ) { int blockX = tileX / 2 ; int blockY = tileY / 2 ; int superblockX = blockX / 2 ; int superblockY = blockY / 2 ; <S2SV_StartBug> int attribute_byte = ppu -> VRAM [ nametable_data + 0xC30 + superblockY * 8 + superblockX ] ; <S2SV_EndBug> <S2SV_StartBug> int pallete_index = 0xff & ( attribute_byte >> ( 6 - ( 2 * ( 2 * ( blockY % 2 ) + ( blockX % 2 ) ) ) ) ) ; <S2SV_EndBug> pallete [ 0 ] = backdrop_color ; pallete [ 1 ] = ppu -> VRAM [ 0x3F00 + pallete_index * 4 + 1 ] ; pallete [ 2 ] = ppu -> VRAM [ 0x3F00 + pallete_index * 4 + 2 ] ; pallete [ 3 ] = ppu -> VRAM [ 0x3F00 + pallete_index * 4 + 3 ] ; int tile_index = ppu -> VRAM [ nametable_data + tileY * 32 + tileX ] ; int tile_data_plane1 = pattern_table + tile_index * 16 ; int tile_data_plane2 = pattern_table + tile_index * 16 + 8 ; int x , y ; for ( y = 0 ; y < 8 ; y ++ ) { BYTE plane1 = ppu -> VRAM [ tile_data_plane1 + y ] ; BYTE plane2 = ppu -> VRAM [ tile_data_plane2 + y ] ; for ( x = 0 ; x < 8 ; x ++ ) { if ( x == 0 && y == 0 ) { setPixel ( ppu , startX + tileX * 8 + x , startY + tileY * 8 + y , 0xf ) ; continue ; } int c_id = ( plane1 >> ( 7 - x ) & 0b1 ) | ( ( plane2 >> ( 7 - x ) & 0b1 ) << 1 ) ; setPixel ( ppu , startX + tileX * 8 + x , startY + tileY * 8 + y , pallete [ c_id ] ) ; } } } } } | <S2SV_ModStart> [ nametable_data + 0x3C0 <S2SV_ModEnd> + superblockY * <S2SV_ModStart> int pallete_index = 0b11 <S2SV_ModEnd> & ( attribute_byte |
4,841 | CWE-000 static int flushbufqueues ( struct buf * marker , bufq_type_t q ) { struct bufpcpu * pcpu ; struct buf * bp ; int r = 0 ; u_int loops = flushperqueue ; int lcpu = marker -> b_qcpu ; KKASSERT ( marker -> b_qindex == BQUEUE_NONE ) ; KKASSERT ( marker -> b_flags & B_MARKER ) ; again : pcpu = & bufpcpu [ marker -> b_qcpu ] ; spin_lock ( & pcpu -> spin ) ; marker -> b_qindex = q ; TAILQ_INSERT_HEAD ( & pcpu -> bufqueues [ q ] , marker , b_freelist ) ; bp = marker ; while ( ( bp = TAILQ_NEXT ( bp , b_freelist ) ) != NULL ) { if ( bp -> b_flags & B_MARKER ) continue ; if ( ( bp -> b_flags & B_DELWRI ) == 0 ) { kprintf ( "Unexpected<S2SV_blank>clean<S2SV_blank>buffer<S2SV_blank>%p\\n" , bp ) ; continue ; } if ( BUF_LOCK ( bp , LK_EXCLUSIVE | LK_NOWAIT ) ) continue ; KKASSERT ( bp -> b_qcpu == marker -> b_qcpu && bp -> b_qindex == q ) ; TAILQ_REMOVE ( & pcpu -> bufqueues [ q ] , marker , b_freelist ) ; TAILQ_INSERT_AFTER ( & pcpu -> bufqueues [ q ] , bp , marker , b_freelist ) ; if ( ( bp -> b_flags & B_DELWRI ) == 0 ) { spin_unlock ( & pcpu -> spin ) ; BUF_UNLOCK ( bp ) ; spin_lock ( & pcpu -> spin ) ; bp = marker ; continue ; } _bremfree ( bp ) ; if ( bp -> b_flags & B_INVAL ) { spin_unlock ( & pcpu -> spin ) ; brelse ( bp ) ; goto doloop ; } spin_unlock ( & pcpu -> spin ) ; lwkt_yield ( ) ; if ( LIST_FIRST ( & bp -> b_dep ) != NULL && ( bp -> b_flags & B_DEFERRED ) == 0 && buf_countdeps ( bp , 0 ) ) { spin_lock ( & pcpu -> spin ) ; TAILQ_INSERT_TAIL ( & pcpu -> bufqueues [ q ] , bp , b_freelist ) ; bp -> b_qindex = q ; bp -> b_flags |= B_DEFERRED ; spin_unlock ( & pcpu -> spin ) ; BUF_UNLOCK ( bp ) ; spin_lock ( & pcpu -> spin ) ; bp = marker ; continue ; } if ( LIST_FIRST ( & bp -> b_dep ) != NULL && buf_checkwrite ( bp ) ) { brelse ( bp ) ; } else if ( bp -> b_flags & B_ERROR ) { tsleep ( bp , 0 , "bioer" , 1 ) ; bp -> b_flags &= ~ B_AGE ; cluster_awrite ( bp ) ; } else { <S2SV_StartBug> bp -> b_flags |= B_AGE ; <S2SV_EndBug> cluster_awrite ( bp ) ; } doloop : spin_lock ( & pcpu -> spin ) ; ++ r ; if ( -- loops == 0 ) break ; bp = marker ; } TAILQ_REMOVE ( & pcpu -> bufqueues [ q ] , marker , b_freelist ) ; marker -> b_qindex = BQUEUE_NONE ; spin_unlock ( & pcpu -> spin ) ; marker -> b_qcpu = ( marker -> b_qcpu + 1 ) % ncpus ; if ( bp == NULL ) { if ( marker -> b_qcpu != lcpu ) goto again ; } return ( r ) ; } | <S2SV_ModStart> b_flags |= B_AGE | B_KVABIO |
4,842 | CWE-000 void debug_draw ( G g ) { char buf [ 1024 ] ; char log_text [ 1024 ] ; log_text [ 0 ] = '\\0' ; g_debug ( "hi" ) ; g_log ( NULL , G_LOG_LEVEL_DEBUG , "MSG" ) ; for ( int i = 0 ; i < ( g -> log_len > 10 ? 10 : g -> log_len ) ; i ++ ) { strcat ( log_text , g_list_nth_data ( g -> log , i ) ) ; strcat ( log_text , "\\n" ) ; } snprintf ( buf , 1024 , "Debug:<S2SV_blank>\\n" "Key:<S2SV_blank>%d\\n" "Log:\\n%s\\n" "Viewport<S2SV_blank>Left:<S2SV_blank>%d\\n" "Viewport<S2SV_blank>cx:cy<S2SV_blank>=<S2SV_blank>%d:%d\\n" "Viewport<S2SV_blank>left:top<S2SV_blank>=<S2SV_blank>%d:%d\\n" <S2SV_StartBug> "Player<S2SV_blank>x:y<S2SV_blank>=<S2SV_blank>%d:%d\\n" <S2SV_EndBug> , g -> key , log_text , g -> view -> display_left , g -> view -> cx , g -> view -> cy , viewport_left ( g -> view ) , viewport_top ( g -> view ) , <S2SV_StartBug> g -> player -> x , g -> player -> y <S2SV_EndBug> ) ; cc_printxy ( buf , cn_white , 0 , 20 ) ; } | <S2SV_ModStart> "Viewport<S2SV_blank>Left:<S2SV_blank>%d\\n" "Viewport<S2SV_blank>cx:cy<S2SV_blank>=<S2SV_blank>%d:%d\\n" "Viewport<S2SV_blank>left:top<S2SV_blank>=<S2SV_blank>%d:%d\\n" "Player<S2SV_blank>x:y<S2SV_blank>=<S2SV_blank>%d:%d<S2SV_blank>[HP:<S2SV_blank>%d<S2SV_blank><S2SV_blank>]\\n" <S2SV_ModEnd> , g -> <S2SV_ModStart> player -> y , g -> player -> stat_hp |
4,843 | CWE-000 int ls_print ( t_ls * ls , t_lsarg * d , t_list * lst , int depth ) { if ( d -> is_dir && ! ( ! ls -> index && ! depth ) && ( ls -> index || depth ) ) write ( 1 , "\\n" , 1 ) ; if ( d -> is_dir && ( ls -> index || depth || ls -> count > 1 ) ) ft_printf ( "%s:\\n" , d -> fullpath ) ; if ( lst && ( d -> err = ( ( t_lsarg * ) ( lst -> content ) ) -> err ) ) <S2SV_StartBug> ft_printf ( "ft_ls:<S2SV_blank>%s:<S2SV_blank>%s" , d -> filename , strerror ( d -> err ) ) ; <S2SV_EndBug> else if ( ls -> opts & LS_L ) ls_print_l ( ls , d , lst ) ; else if ( ls -> opts & LS_CC ) ls_print_c ( ls , lst ) ; else ls_print_classic ( ls , lst ) ; return ( 1 ) ; } | <S2SV_ModStart> ) ft_printf ( "ft_ls:<S2SV_blank>%s:<S2SV_blank>%s\\n" <S2SV_ModEnd> , d -> |
4,844 | CWE-000 static void <S2SV_StartBug> upf_add_rules ( u32 app_index , upf_dpi_app_t * app , upf_dpi_args_t * args ) <S2SV_EndBug> { u32 index = 0 ; u32 rule_index = 0 ; <S2SV_StartBug> upf_dpi_rule_t * rule = NULL ; <S2SV_EndBug> hash_foreach ( rule_index , index , app -> rules_by_id , ( { rule = pool_elt_at_index ( app -> rules , index ) ; if ( rule -> path ) { <S2SV_StartBug> vec_add1 ( args -> indecies , app_index ) ; <S2SV_EndBug> <S2SV_StartBug> vec_add1 ( args -> rules , ( const char * ) rule -> path ) ; <S2SV_EndBug> vec_add1 ( args -> flags , 0 ) ; } } ) ) ; } | <S2SV_ModStart> app , upf_dpi_args_t * <S2SV_ModStart> rule = NULL ; upf_dpi_args_t arg <S2SV_ModStart> path ) { arg . index = app_index ; arg . rule = rule -> path <S2SV_ModEnd> ; vec_add1 ( <S2SV_ModStart> ; vec_add1 ( * args , arg <S2SV_ModEnd> ) ; } |
4,845 | CWE-000 PyMODINIT_FUNC init_zstd ( void ) { <S2SV_StartBug> PyObject * module = Py_InitModule ( "_zstd" , ZstdMethods ) ; <S2SV_EndBug> <S2SV_StartBug> if ( module == NULL ) { <S2SV_EndBug> return ; } ZstdError = PyErr_NewException ( "_zstd.Error" , NULL , NULL ) ; if ( ZstdError == NULL ) { Py_DECREF ( module ) ; return ; } Py_INCREF ( ZstdError ) ; PyModule_AddObject ( module , "Error" , ZstdError ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> * module = Py_InitModule3 <S2SV_ModEnd> ( "_zstd" , <S2SV_ModStart> "_zstd" , ZstdMethods , zstd_module_doc <S2SV_ModStart> == NULL ) return ; <S2SV_ModEnd> ZstdError = PyErr_NewException <S2SV_ModStart> ZstdError ) ; zstd_add_constants ( module ) ; |
4,846 | CWE-000 static TupleTableSlot * ValuesNext ( ValuesScanState * node ) { TupleTableSlot * slot ; EState * estate ; ExprContext * econtext ; ScanDirection direction ; List * exprlist ; estate = node -> ss . ps . state ; direction = estate -> es_direction ; slot = node -> ss . ss_ScanTupleSlot ; econtext = node -> rowcontext ; if ( ScanDirectionIsForward ( direction ) ) { if ( node -> curr_idx < node -> array_len ) node -> curr_idx ++ ; if ( node -> curr_idx < node -> array_len ) exprlist = node -> exprlists [ node -> curr_idx ] ; else exprlist = NIL ; } else { if ( node -> curr_idx >= 0 ) node -> curr_idx -- ; if ( node -> curr_idx >= 0 ) exprlist = node -> exprlists [ node -> curr_idx ] ; else exprlist = NIL ; } ExecClearTuple ( slot ) ; if ( exprlist ) { MemoryContext oldContext ; <S2SV_StartBug> List * exprstatelist ; <S2SV_EndBug> Datum * values ; bool * isnull ; Form_pg_attribute * att ; ListCell * lc ; int resind ; ReScanExprContext ( econtext ) ; oldContext = MemoryContextSwitchTo ( econtext -> ecxt_per_tuple_memory ) ; <S2SV_StartBug> exprstatelist = ( List * ) ExecInitExpr ( ( Expr * ) exprlist , NULL ) ; <S2SV_EndBug> Assert ( list_length ( exprstatelist ) == slot -> tts_tupleDescriptor -> natts ) ; values = slot -> tts_values ; isnull = slot -> tts_isnull ; att = slot -> tts_tupleDescriptor -> attrs ; resind = 0 ; foreach ( lc , exprstatelist ) { ExprState * estate = ( ExprState * ) lfirst ( lc ) ; values [ resind ] = ExecEvalExpr ( estate , econtext , & isnull [ resind ] , NULL ) ; values [ resind ] = MakeExpandedObjectReadOnly ( values [ resind ] , isnull [ resind ] , att [ resind ] -> attlen ) ; resind ++ ; } MemoryContextSwitchTo ( oldContext ) ; ExecStoreVirtualTuple ( slot ) ; } return slot ; } | <S2SV_ModStart> ; List * oldsubplans ; List * <S2SV_ModStart> ecxt_per_tuple_memory ) ; oldsubplans = node -> ss . ps . subPlan ; node -> ss . ps . subPlan = NIL ; <S2SV_ModStart> ) exprlist , & node -> ss . ps ) ; node -> ss . ps . subPlan = oldsubplans <S2SV_ModEnd> ; Assert ( |
4,847 | CWE-000 void confine_ecall ( ) { if ( getLower ( btc - 1 ) == SYSCALL_READ ) { <S2SV_StartBug> printTrace ( ) ; <S2SV_EndBug> checkSatisfiability ( lastConstraint ) ; print ( selfieName ) ; print ( ( uint64_t * ) ":<S2SV_blank>symbolic<S2SV_blank>value<S2SV_blank>reached<S2SV_blank>read<S2SV_blank>ecall<S2SV_blank>and<S2SV_blank>is<S2SV_blank>satisfiable<S2SV_blank>with<S2SV_blank>witnesses:<S2SV_blank>" ) ; printInteger ( getLower ( lastConstraint ) ) ; print ( ( uint64_t * ) ",..," ) ; printInteger ( getUpper ( lastConstraint ) ) ; <S2SV_StartBug> println ( ) ; println ( ) ; <S2SV_EndBug> numberOfSymbolics = numberOfSymbolics - 1 ; } * ( registers + REG_A0 ) = * ( tcs + btc ) ; } | <S2SV_ModStart> SYSCALL_READ ) { <S2SV_ModEnd> checkSatisfiability ( lastConstraint <S2SV_ModStart> ) ) ; if ( sourceLineNumber != ( uint64_t * ) 0 ) { print ( ( uint64_t * ) "<S2SV_blank>read<S2SV_blank>in<S2SV_blank>line<S2SV_blank>" ) ; printSourceLineNumberOfInstruction ( findPrevFuncCall ( btc ) ) ; } |
4,848 | CWE-000 static void dumpUserMappings ( Archive * fout , const char * servername , const char * namespace , const char * owner , CatalogId catalogId , DumpId dumpId ) { PQExpBuffer q ; PQExpBuffer delq ; PQExpBuffer query ; PQExpBuffer tag ; PGresult * res ; int ntups ; int i_usename ; int i_umoptions ; int i ; q = createPQExpBuffer ( ) ; tag = createPQExpBuffer ( ) ; delq = createPQExpBuffer ( ) ; query = createPQExpBuffer ( ) ; selectSourceSchema ( fout , "pg_catalog" ) ; appendPQExpBuffer ( query , "SELECT<S2SV_blank>usename,<S2SV_blank>" "array_to_string(ARRAY(" "SELECT<S2SV_blank>quote_ident(option_name)<S2SV_blank>||<S2SV_blank>\'<S2SV_blank>\'<S2SV_blank>||<S2SV_blank>" "quote_literal(option_value)<S2SV_blank>" "FROM<S2SV_blank>pg_options_to_table(umoptions)<S2SV_blank>" "ORDER<S2SV_blank>BY<S2SV_blank>option_name" "),<S2SV_blank>E\',\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\')<S2SV_blank>AS<S2SV_blank>umoptions<S2SV_blank>" "FROM<S2SV_blank>pg_user_mappings<S2SV_blank>" "WHERE<S2SV_blank>srvid<S2SV_blank>=<S2SV_blank>\'%u\'<S2SV_blank>" "ORDER<S2SV_blank>BY<S2SV_blank>usename" , catalogId . oid ) ; res = ExecuteSqlQuery ( fout , query -> data , PGRES_TUPLES_OK ) ; ntups = PQntuples ( res ) ; i_usename = PQfnumber ( res , "usename" ) ; i_umoptions = PQfnumber ( res , "umoptions" ) ; for ( i = 0 ; i < ntups ; i ++ ) { char * usename ; char * umoptions ; usename = PQgetvalue ( res , i , i_usename ) ; umoptions = PQgetvalue ( res , i , i_umoptions ) ; resetPQExpBuffer ( q ) ; appendPQExpBuffer ( q , "CREATE<S2SV_blank>USER<S2SV_blank>MAPPING<S2SV_blank>FOR<S2SV_blank>%s" , fmtId ( usename ) ) ; appendPQExpBuffer ( q , "<S2SV_blank>SERVER<S2SV_blank>%s" , fmtId ( servername ) ) ; if ( umoptions && strlen ( umoptions ) > 0 ) appendPQExpBuffer ( q , "<S2SV_blank>OPTIONS<S2SV_blank>(\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%s\\n)" , umoptions ) ; appendPQExpBufferStr ( q , ";\\n" ) ; resetPQExpBuffer ( delq ) ; appendPQExpBuffer ( delq , "DROP<S2SV_blank>USER<S2SV_blank>MAPPING<S2SV_blank>FOR<S2SV_blank>%s" , fmtId ( usename ) ) ; appendPQExpBuffer ( delq , "<S2SV_blank>SERVER<S2SV_blank>%s;\\n" , fmtId ( servername ) ) ; resetPQExpBuffer ( tag ) ; appendPQExpBuffer ( tag , "USER<S2SV_blank>MAPPING<S2SV_blank>%s<S2SV_blank>SERVER<S2SV_blank>%s" , usename , servername ) ; ArchiveEntry ( fout , nilCatalogId , createDumpId ( ) , tag -> data , namespace , NULL , owner , false , "USER<S2SV_blank>MAPPING" , SECTION_PRE_DATA , q -> data , delq -> data , NULL , & dumpId , 1 , NULL , NULL ) ; } PQclear ( res ) ; destroyPQExpBuffer ( query ) ; destroyPQExpBuffer ( delq ) ; <S2SV_StartBug> destroyPQExpBuffer ( q ) ; <S2SV_EndBug> } | <S2SV_ModStart> ; destroyPQExpBuffer ( tag ) ; destroyPQExpBuffer ( |
4,849 | CWE-000 dtk_result dtk_tabgroup_hide_tabbar ( dtk_tabgroup * pTabGroup ) { if ( pTabGroup == NULL ) { return DTK_INVALID_ARGS ; } if ( ! dtk_tabgroup_is_showing_tabbar ( pTabGroup ) ) { return DTK_SUCCESS ; } <S2SV_StartBug> dtk_result result = dtk_control_hide ( DTK_CONTROL ( pTabGroup ) ) ; <S2SV_EndBug> if ( result != DTK_SUCCESS ) { return result ; } <S2SV_StartBug> dtk_control_refresh_layout ( DTK_CONTROL ( pTabGroup ) ) ; <S2SV_EndBug> return result ; } | <S2SV_ModStart> ( DTK_CONTROL ( & pTabGroup -> tabbar <S2SV_ModEnd> ) ) ; <S2SV_ModStart> result ; } dtk_tabgroup__refresh_layout ( pTabGroup <S2SV_ModEnd> ) ; return |
4,850 | CWE-000 static int get_page_list ( uint32_t kernel , uint32_t sc , remote_arg_t * pra , struct fastrpc_buf * ibuf , struct fastrpc_buf * obuf ) { struct smq_phy_page * pgstart , * pages ; struct smq_invoke_buf * list ; int i , rlen , err = 0 ; int inbufs = REMOTE_SCALARS_INBUFS ( sc ) ; int outbufs = REMOTE_SCALARS_OUTBUFS ( sc ) ; LOCK_MMAP ( kernel ) ; * obuf = * ibuf ; retry : list = smq_invoke_buf_start ( ( remote_arg_t * ) obuf -> virt , sc ) ; pgstart = smq_phy_page_start ( sc , list ) ; pages = pgstart + 1 ; rlen = obuf -> size - ( ( uint32_t ) pages - ( uint32_t ) obuf -> virt ) ; if ( rlen < 0 ) { rlen = ( ( uint32_t ) pages - ( uint32_t ) obuf -> virt ) - obuf -> size ; obuf -> size += buf_page_size ( rlen ) ; VERIFY ( err , 0 == alloc_mem ( obuf ) ) ; if ( err ) goto bail ; goto retry ; } pgstart -> addr = obuf -> phys ; pgstart -> size = obuf -> size ; for ( i = 0 ; i < inbufs + outbufs ; ++ i ) { void * buf ; <S2SV_StartBug> int len , num ; <S2SV_EndBug> list [ i ] . num = 0 ; list [ i ] . pgidx = 0 ; len = pra [ i ] . buf . len ; VERIFY ( err , len >= 0 ) ; if ( err ) goto bail ; if ( ! len ) continue ; buf = pra [ i ] . buf . pv ; num = buf_num_pages ( buf , len ) ; if ( ! kernel ) list [ i ] . num = buf_get_pages ( buf , len , num , i >= inbufs , pages , rlen / sizeof ( * pages ) ) ; else list [ i ] . num = 0 ; VERIFY ( err , list [ i ] . num >= 0 ) ; if ( err ) goto bail ; if ( list [ i ] . num ) { list [ i ] . pgidx = pages - pgstart ; pages = pages + list [ i ] . num ; } else if ( rlen > sizeof ( * pages ) ) { list [ i ] . pgidx = pages - pgstart ; pages = pages + 1 ; } else { if ( obuf -> handle != ibuf -> handle ) free_mem ( obuf ) ; obuf -> size += buf_page_size ( sizeof ( * pages ) ) ; VERIFY ( err , 0 == alloc_mem ( obuf ) ) ; if ( err ) goto bail ; goto retry ; } rlen = obuf -> size - ( ( uint32_t ) pages - ( uint32_t ) obuf -> virt ) ; } obuf -> used = obuf -> size - rlen ; bail : if ( err && ( obuf -> handle != ibuf -> handle ) ) free_mem ( obuf ) ; UNLOCK_MMAP ( kernel ) ; return err ; } | <S2SV_ModStart> buf ; int num ; ssize_t len <S2SV_ModEnd> ; list [ |
4,851 | CWE-000 static bool CreateDistributedSnapshot ( DistributedSnapshotWithLocalMapping * distribSnapshotWithLocalMapping ) { int i ; int count ; DistributedTransactionId xmin ; DistributedTransactionId xmax ; DistributedSnapshotId distribSnapshotId ; DistributedTransactionId globalXminDistributedSnapshots ; DistributedSnapshot * ds ; ProcArrayStruct * arrayP = procArray ; Assert ( LWLockHeldByMe ( ProcArrayLock ) ) ; if ( * shmNumCommittedGxacts != 0 ) elog ( ERROR , "Create<S2SV_blank>distributed<S2SV_blank>snapshot<S2SV_blank>before<S2SV_blank>DTM<S2SV_blank>recovery<S2SV_blank>finish" ) ; xmin = LastDistributedTransactionId ; xmax = getMaxDistributedXid ( ) ; globalXminDistributedSnapshots = xmax ; count = 0 ; ds = & distribSnapshotWithLocalMapping -> ds ; for ( i = 0 ; i < arrayP -> numProcs ; i ++ ) { PGPROC * proc = arrayP -> procs [ i ] ; TMGXACT * gxact_candidate = & proc -> gxact ; volatile DistributedTransactionId gxid ; DistributedTransactionId dxid ; gxid = gxact_candidate -> gxid ; if ( gxid == InvalidDistributedTransactionId ) continue ; <S2SV_StartBug> if ( gxact_candidate -> state == DTX_STATE_ACTIVE_NOT_DISTRIBUTED ) <S2SV_EndBug> continue ; Assert ( gxact_candidate -> state != DTX_STATE_ACTIVE_NOT_DISTRIBUTED && gxact_candidate -> state != DTX_STATE_NONE ) ; dxid = gxact_candidate -> xminDistributedSnapshot ; if ( ( dxid != InvalidDistributedTransactionId ) && dxid < globalXminDistributedSnapshots ) { globalXminDistributedSnapshots = dxid ; } if ( gxid < xmin ) { xmin = gxid ; } if ( gxid > xmax ) { xmax = gxid ; } if ( proc == MyProc ) continue ; if ( count >= ds -> maxCount ) elog ( ERROR , "Too<S2SV_blank>many<S2SV_blank>distributed<S2SV_blank>transactions<S2SV_blank>for<S2SV_blank>snapshot" ) ; ds -> inProgressXidArray [ count ++ ] = gxid ; elog ( ( Debug_print_full_dtm ? LOG : DEBUG5 ) , "CreateDistributedSnapshot<S2SV_blank>added<S2SV_blank>inProgressDistributedXid<S2SV_blank>=<S2SV_blank>%u<S2SV_blank>to<S2SV_blank>snapshot" , gxid ) ; } distribSnapshotId = pg_atomic_add_fetch_u32 ( ( pg_atomic_uint32 * ) shmNextSnapshotId , 1 ) ; if ( xmin < globalXminDistributedSnapshots ) globalXminDistributedSnapshots = xmin ; qsort ( ds -> inProgressXidArray , count , sizeof ( DistributedTransactionId ) , DistributedSnapshotMappedEntry_Compare ) ; ds -> distribTransactionTimeStamp = * shmDistribTimeStamp ; ds -> xminAllDistributedSnapshots = globalXminDistributedSnapshots ; ds -> distribSnapshotId = distribSnapshotId ; ds -> xmin = xmin ; ds -> xmax = xmax ; ds -> count = count ; if ( xmin < MyProc -> gxact . xminDistributedSnapshot ) MyProc -> gxact . xminDistributedSnapshot = xmin ; elog ( ( Debug_print_full_dtm ? LOG : DEBUG5 ) , "CreateDistributedSnapshot<S2SV_blank>distributed<S2SV_blank>snapshot<S2SV_blank>has<S2SV_blank>xmin<S2SV_blank>=<S2SV_blank>%u,<S2SV_blank>count<S2SV_blank>=<S2SV_blank>%u,<S2SV_blank>xmax<S2SV_blank>=<S2SV_blank>%u." , xmin , count , xmax ) ; elog ( ( Debug_print_snapshot_dtm ? LOG : DEBUG5 ) , "[Distributed<S2SV_blank>Snapshot<S2SV_blank>#%u]<S2SV_blank>*Create*<S2SV_blank>(gxid<S2SV_blank>=<S2SV_blank>%u,<S2SV_blank>\'%s\')" , distribSnapshotId , MyProc -> gxact . gxid , DtxContextToString ( DistributedTransactionContext ) ) ; distribSnapshotWithLocalMapping -> currentLocalXidsCount = 0 ; distribSnapshotWithLocalMapping -> minCachedLocalXid = InvalidTransactionId ; distribSnapshotWithLocalMapping -> maxCachedLocalXid = InvalidTransactionId ; Assert ( distribSnapshotWithLocalMapping -> maxLocalXidsCount != 0 ) ; Assert ( distribSnapshotWithLocalMapping -> inProgressMappedLocalXids != NULL ) ; memset ( distribSnapshotWithLocalMapping -> inProgressMappedLocalXids , InvalidTransactionId , sizeof ( TransactionId ) * distribSnapshotWithLocalMapping -> maxLocalXidsCount ) ; return true ; } | <S2SV_ModStart> ) continue ; Assert ( <S2SV_ModEnd> gxact_candidate -> state |
4,852 | CWE-000 void key_manager_init ( key_manager_t manager ) { manager -> i = 0 ; manager -> j = 0 ; manager -> current = NULL ; manager -> previous = NULL ; <S2SV_StartBug> manager -> our_dh -> pub = dh_mpi_new ( ) ; <S2SV_EndBug> <S2SV_StartBug> manager -> our_dh -> priv = dh_mpi_new ( ) ; <S2SV_EndBug> <S2SV_StartBug> manager -> their_dh = dh_mpi_new ( ) ; <S2SV_EndBug> } | <S2SV_ModStart> -> pub = NULL <S2SV_ModEnd> ; manager -> <S2SV_ModStart> -> priv = NULL <S2SV_ModEnd> ; manager -> <S2SV_ModStart> -> their_dh = NULL <S2SV_ModEnd> ; } <S2SV_null> |
4,853 | CWE-000 static void terminal_put ( CeTerminal_t * terminal , CeRune_t rune ) { char characters [ CE_UTF8_SIZE ] ; int width = 1 ; int64_t len = 0 ; if ( terminal -> mode & CE_TERMINAL_MODE_UTF8 ) { ce_utf8_encode ( rune , characters , CE_UTF8_SIZE , & len ) ; } else { characters [ 0 ] = rune ; width = 1 ; } if ( terminal -> escape_state & CE_TERMINAL_ESCAPE_STATE_STR ) { if ( rune == '\\a' || rune == 030 || rune == 032 || rune == 033 || is_controller_c1 ( rune ) ) { terminal -> escape_state &= ~ ( CE_TERMINAL_ESCAPE_STATE_START | CE_TERMINAL_ESCAPE_STATE_STR | CE_TERMINAL_ESCAPE_STATE_DCS ) ; if ( terminal -> mode & CE_TERMINAL_MODE_SIXEL ) { CHANGE_BIT ( terminal -> mode , 0 , CE_TERMINAL_MODE_SIXEL ) ; return ; } terminal -> escape_state |= CE_TERMINAL_ESCAPE_STATE_STR_END ; } else { if ( terminal -> mode & CE_TERMINAL_MODE_SIXEL ) { return ; } if ( terminal -> escape_state & CE_TERMINAL_ESCAPE_STATE_DCS && terminal -> str_escape . buffer_length == 0 && rune == 'q' ) { terminal -> mode |= CE_TERMINAL_MODE_SIXEL ; } if ( terminal -> str_escape . buffer_length + 1 >= ( CE_TERMINAL_ESCAPE_BUFFER_SIZE - 1 ) ) { return ; } terminal -> str_escape . buffer [ terminal -> str_escape . buffer_length ] = rune ; terminal -> str_escape . buffer_length ++ ; return ; } } if ( is_controller ( rune ) ) { terminal_control_code ( terminal , rune ) ; return ; } if ( terminal -> escape_state & CE_TERMINAL_ESCAPE_STATE_START ) { if ( terminal -> escape_state & CE_TERMINAL_ESCAPE_STATE_CSI ) { CeTerminalCSIEscape_t * csi = & terminal -> csi_escape ; csi -> buffer [ csi -> buffer_length ] = rune ; csi -> buffer_length ++ ; if ( BETWEEN ( rune , 0x40 , 0x7E ) || csi -> buffer_length >= ( CE_TERMINAL_ESCAPE_BUFFER_SIZE - 1 ) ) { terminal -> escape_state = 0 ; csi_parse ( csi ) ; csi_handle ( terminal ) ; } return ; } else if ( terminal -> escape_state & CE_TERMINAL_ESCAPE_STATE_UTF8 ) { if ( rune == 'G' ) { terminal -> mode |= CE_TERMINAL_MODE_UTF8 ; } else if ( rune == '@' ) { terminal -> mode &= ~ CE_TERMINAL_MODE_UTF8 ; } } else if ( terminal -> escape_state & CE_TERMINAL_ESCAPE_STATE_ALTCHARSET ) { } else if ( terminal -> escape_state & CE_TERMINAL_ESCAPE_STATE_TEST ) { } else { if ( ! esc_handle ( terminal , rune ) ) return ; } terminal -> escape_state = 0 ; return ; } CeTerminalGlyph_t * current_glyph = terminal -> lines [ terminal -> cursor . y ] + terminal -> cursor . x ; if ( terminal -> mode & CE_TERMINAL_MODE_WRAP && terminal -> cursor . state & CE_TERMINAL_CURSOR_STATE_WRAPNEXT ) { current_glyph -> attributes |= CE_TERMINAL_GLYPH_ATTRIBUTE_WRAP ; terminal_put_newline ( terminal , true ) ; current_glyph = terminal -> lines [ terminal -> cursor . y ] + terminal -> cursor . x ; } if ( terminal -> mode & CE_TERMINAL_MODE_INSERT && ( terminal -> cursor . x + width ) < terminal -> columns ) { int size = ( terminal -> columns - terminal -> cursor . x - width ) ; memmove ( current_glyph + width , current_glyph , size * sizeof ( * current_glyph ) ) ; char * line_src = ce_utf8_find_index ( terminal -> buffer -> lines [ terminal -> cursor . y ] , terminal -> cursor . x ) ; char * line_dst = line_src + width ; CeRune_t runes [ size ] ; for ( int i = 0 ; i < size ; i ++ ) { int64_t rune_len = 0 ; runes [ i ] = ce_utf8_decode ( line_src , & rune_len ) ; } <S2SV_StartBug> for ( int i = 0 ; i < size ; i ++ ) { <S2SV_EndBug> int64_t rune_len = 0 ; <S2SV_StartBug> ce_utf8_encode ( runes [ i ] , line_dst , strlen ( line_dst ) , & rune_len ) ; <S2SV_EndBug> } } if ( terminal -> cursor . x + width > terminal -> columns ) { terminal_put_newline ( terminal , true ) ; } terminal_set_glyph ( terminal , rune , & terminal -> cursor . attributes , terminal -> cursor . x , terminal -> cursor . y ) ; if ( terminal -> cursor . x + width < terminal -> columns ) { terminal_move_cursor_to ( terminal , terminal -> cursor . x + width , terminal -> cursor . y ) ; } else { terminal -> cursor . state |= CE_TERMINAL_CURSOR_STATE_WRAPNEXT ; } } | <S2SV_ModStart> ) ; } char * itr_dst = line_dst ; <S2SV_ModStart> i ] , itr_dst <S2SV_ModEnd> , strlen ( <S2SV_ModStart> , strlen ( itr_dst <S2SV_ModEnd> ) , & <S2SV_ModStart> & rune_len ) ; itr_dst += rune_len |
4,854 | CWE-000 static GError * _resolve_m1_through_many_m0 ( struct hc_resolver_s * r , const char * const * urlv , const guint8 * prefix , gchar * * * result ) { GRID_TRACE2 ( "%s(%02X%02X)" , __FUNCTION__ , prefix [ 0 ] , prefix [ 1 ] ) ; if ( urlv && * urlv ) { gsize len = oio_strv_length ( urlv ) ; if ( r -> service_qualifier ) { gboolean _wrap ( gconstpointer p ) { return r -> service_qualifier ( ( const char * ) p ) ; } len = oio_ext_array_partition ( ( void * * ) urlv , len , _wrap ) ; } if ( len > 1 && oio_resolver_dir_shuffle ) oio_ext_array_shuffle ( ( void * * ) urlv , len ) ; } for ( const char * const * purl = urlv ; * purl ; ++ purl ) { GError * err = _resolve_m1_through_one_m0 ( * purl , prefix , result ) ; EXTRA_ASSERT ( ( err != NULL ) ^ ( * result != NULL ) ) ; if ( ! err ) return NULL ; if ( ! CODE_IS_NETWORK_ERROR ( err -> code ) ) return err ; if ( r -> service_notifier ) r -> service_notifier ( * purl ) ; g_error_free ( err ) ; } <S2SV_StartBug> return NEWERROR ( CODE_INTERNAL_ERROR , "No<S2SV_blank>META0<S2SV_blank>answered" ) ; <S2SV_EndBug> } | <S2SV_ModStart> ; } return BUSY ( "No<S2SV_blank>meta0<S2SV_blank>answered" <S2SV_ModEnd> ) ; } |
4,855 | CWE-000 static int update_cut ( knot_pkt_t * pkt , const knot_rrset_t * rr , struct kr_request * req ) { struct kr_query * qry = req -> current_query ; struct kr_zonecut * cut = & qry -> zone_cut ; int state = KR_STATE_CONSUME ; if ( ! knot_dname_in ( cut -> name , rr -> owner ) ) { <S2SV_StartBug> DEBUG_MSG ( "<=<S2SV_blank>authority:<S2SV_blank>ns<S2SV_blank>outside<S2SV_blank>bailiwick\\n" ) ; <S2SV_EndBug> # ifdef STRICT_MODE return KR_STATE_FAIL ; # else if ( knot_pkt_section ( pkt , KNOT_ANSWER ) -> count == 0 ) { state = KR_STATE_FAIL ; } return state ; # endif } const knot_dname_t * current_cut = cut -> name ; if ( ! knot_dname_is_equal ( rr -> owner , cut -> name ) ) { struct kr_zonecut * parent = mm_alloc ( & req -> pool , sizeof ( * parent ) ) ; if ( parent ) { memcpy ( parent , cut , sizeof ( * parent ) ) ; kr_zonecut_init ( cut , rr -> owner , & req -> pool ) ; cut -> key = parent -> key ; cut -> trust_anchor = parent -> trust_anchor ; cut -> parent = parent ; } else { kr_zonecut_set ( cut , rr -> owner ) ; } state = KR_STATE_DONE ; } for ( unsigned i = 0 ; i < rr -> rrs . rr_count ; ++ i ) { const knot_dname_t * ns_name = knot_ns_name ( & rr -> rrs , i ) ; int glue_records = has_glue ( pkt , ns_name ) ; if ( ! glue_records && knot_dname_in ( rr -> owner , ns_name ) ) { <S2SV_StartBug> DEBUG_MSG ( "<=<S2SV_blank>authority:<S2SV_blank>missing<S2SV_blank>mandatory<S2SV_blank>glue,<S2SV_blank>rejecting\\n" ) ; <S2SV_EndBug> continue ; } kr_zonecut_add ( cut , ns_name , NULL ) ; if ( qry -> flags & QUERY_PERMISSIVE ) { fetch_glue ( pkt , ns_name , req ) ; } else if ( qry -> flags & QUERY_STRICT ) { if ( knot_dname_in ( cut -> name , ns_name ) ) fetch_glue ( pkt , ns_name , req ) ; } else { if ( knot_dname_in ( current_cut , ns_name ) ) fetch_glue ( pkt , ns_name , req ) ; } } return state ; } | <S2SV_ModStart> ) ) { VERBOSE_MSG <S2SV_ModEnd> ( "<=<S2SV_blank>authority:<S2SV_blank>ns<S2SV_blank>outside<S2SV_blank>bailiwick\\n" ) <S2SV_ModStart> ) ) { VERBOSE_MSG <S2SV_ModEnd> ( "<=<S2SV_blank>authority:<S2SV_blank>missing<S2SV_blank>mandatory<S2SV_blank>glue,<S2SV_blank>rejecting\\n" ) |
4,856 | CWE-000 void * gf_tier_do_fix_layout ( void * args ) { gf_tier_fix_layout_arg_t * tier_fix_layout_arg = args ; int ret = - 1 ; xlator_t * this = NULL ; dht_conf_t * conf = NULL ; gf_defrag_info_t * defrag = NULL ; dict_t * dict = NULL ; loc_t loc = { 0 , } ; struct iatt iatt = { 0 , } ; struct iatt parent = { 0 , } ; GF_VALIDATE_OR_GOTO ( "tier" , tier_fix_layout_arg , out ) ; GF_VALIDATE_OR_GOTO ( "tier" , tier_fix_layout_arg -> this , out ) ; this = tier_fix_layout_arg -> this ; conf = this -> private ; GF_VALIDATE_OR_GOTO ( this -> name , conf , out ) ; defrag = conf -> defrag ; GF_VALIDATE_OR_GOTO ( this -> name , defrag , out ) ; GF_VALIDATE_OR_GOTO ( this -> name , defrag -> root_inode , out ) ; GF_VALIDATE_OR_GOTO ( this -> name , tier_fix_layout_arg -> fix_layout , out ) ; dht_build_root_loc ( defrag -> root_inode , & loc ) ; ret = syncop_lookup ( this , & loc , & iatt , & parent , NULL , NULL ) ; if ( ret ) { gf_msg ( this -> name , GF_LOG_ERROR , - ret , DHT_MSG_REBALANCE_START_FAILED , "Lookup<S2SV_blank>on<S2SV_blank>root<S2SV_blank>failed." ) ; ret = - 1 ; goto out ; } gf_msg ( this -> name , GF_LOG_INFO , 0 , DHT_MSG_LOG_TIER_STATUS , "Tiering<S2SV_blank>Fixlayout<S2SV_blank>started" ) ; ret = gf_defrag_fix_layout ( this , defrag , & loc , tier_fix_layout_arg -> fix_layout , NULL ) ; if ( ret && ret != 2 ) { gf_msg ( this -> name , GF_LOG_ERROR , 0 , DHT_MSG_REBALANCE_FAILED , "Tiering<S2SV_blank>fixlayout<S2SV_blank>failed." ) ; ret = - 1 ; goto out ; } if ( ret != 2 && gf_defrag_settle_hash ( this , defrag , & loc , tier_fix_layout_arg -> fix_layout ) != 0 ) { defrag -> total_failures ++ ; ret = - 1 ; goto out ; } dict = dict_new ( ) ; if ( ! dict ) { ret = - 1 ; goto out ; } ret = dict_set_str ( dict , GF_XATTR_TIER_LAYOUT_FIXED_KEY , "yes" ) ; if ( ret ) { gf_msg ( this -> name , GF_LOG_ERROR , 0 , DHT_MSG_REBALANCE_FAILED , "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>dictionary<S2SV_blank>value:<S2SV_blank>key<S2SV_blank>=<S2SV_blank>%s" , GF_XATTR_TIER_LAYOUT_FIXED_KEY ) ; ret = - 1 ; goto out ; } ret = syncop_setxattr ( this , & loc , dict , 0 , NULL , NULL ) ; if ( ret ) { gf_log ( this -> name , GF_LOG_ERROR , "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>tiering<S2SV_blank>fix<S2SV_blank>" "layout<S2SV_blank>completed<S2SV_blank>xattr<S2SV_blank>on<S2SV_blank>%s" , loc . path ) ; ret = - 1 ; goto out ; } ret = 0 ; out : <S2SV_StartBug> if ( ret ) <S2SV_EndBug> defrag -> total_failures ++ ; if ( dict ) dict_unref ( dict ) ; return NULL ; } | <S2SV_ModStart> if ( ret && defrag |
4,857 | CWE-000 unsigned long process_app1 ( FILE * inptr , unsigned long app1_offset , unsigned short tag , struct image_summary * summary_entry , char * parent_name , int indent ) { unsigned long max_offset = 0UL ; unsigned long ifd_offset , fileoffset_base ; unsigned long dumplength = 0UL ; unsigned short app_length = 0 ; int chpr = 0 ; struct fileheader * header ; char * app_string , * name ; char * fulldirname = CNULL ; if ( inptr ) { if ( summary_entry ) { summary_entry -> filesubformat |= FILESUBFMT_APPN ; summary_entry -> filesubformatAPPN [ 1 ] = 1 ; } name = tagname ( tag ) ; if ( PRINT_SECTION ) { print_tag_address ( SECTION , app1_offset , indent , "@" ) ; chpr += printf ( "<%s><S2SV_blank>%#x<S2SV_blank>" , name , tag ) ; } app_length = read_ushort ( inptr , TIFF_MOTOROLA , HERE ) ; if ( ferror ( inptr ) || feof ( inptr ) ) { clearerr ( inptr ) ; goto appdump ; } if ( PRINT_SECTION ) chpr += printf ( "length<S2SV_blank>%u,<S2SV_blank>" , app_length ) ; else if ( ( PRINT_ENTRY ) ) { print_tag_address ( ENTRY , HERE , indent , "*" ) ; if ( ( PRINT_TAGINFO ) ) { if ( ( PRINT_LONGNAMES ) ) chpr += printf ( "%s." , parent_name ) ; chpr += printf ( "%-14.14s" , "APP1" ) ; } if ( ( PRINT_VALUE ) ) chpr += printf ( "<S2SV_blank>=<S2SV_blank>@%lu:%-9u" , app1_offset , app_length ) ; chpr = newline ( chpr ) ; } app_string = read_appstring ( inptr , JPEG_APP1 , HERE ) ; if ( ferror ( inptr ) || feof ( inptr ) ) { clearerr ( inptr ) ; goto appdump ; } if ( app_string ) { if ( PRINT_SECTION ) chpr += printf ( "\\\'%s\\\'" , app_string ) ; fileoffset_base = ftell ( inptr ) ; if ( strncmp ( app_string , "Exif" , 4 ) == 0 ) { fulldirname = splice ( parent_name , "." , "APP1" ) ; ++ fileoffset_base ; if ( PRINT_SECTION ) { chpr = newline ( chpr ) ; print_tag_address ( SECTION , fileoffset_base , indent + SMALLINDENT , "@" ) ; } header = read_imageheader ( inptr , fileoffset_base ) ; if ( header && ( print_header ( header , SECTION ) == 0 ) && ( header -> probe_magic == TIFF_MAGIC ) ) { ifd_offset = read_ulong ( inptr , header -> file_marker , HERE ) ; if ( PRINT_SECTION ) { chpr += printf ( "<S2SV_blank>ifd<S2SV_blank>offset<S2SV_blank>=<S2SV_blank>%lu<S2SV_blank>(+<S2SV_blank>%lu<S2SV_blank>=<S2SV_blank>%#lx/%lu)" , ifd_offset , fileoffset_base , fileoffset_base + ifd_offset , fileoffset_base + ifd_offset ) ; chpr = newline ( chpr ) ; } max_offset = process_tiff_ifd ( inptr , header -> file_marker , ifd_offset , fileoffset_base , 0L , summary_entry , fulldirname , TIFF_IFD , 0 , - 1 , indent + SMALLINDENT ) ; if ( max_offset < app1_offset + app_length + 2 ) max_offset = app1_offset + app_length + 2 ; } else { max_offset = app1_offset + app_length + 2 ; if ( PRINT_SECTION ) { extraindent ( indent + ADDRWIDTH ) ; <S2SV_StartBug> chpr += printf ( "<S2SV_blank>INVALID<S2SV_blank>MAGIC<S2SV_blank>%lu<S2SV_blank>(%s)<S2SV_blank>where<S2SV_blank>TIFF<S2SV_blank>header<S2SV_blank>should<S2SV_blank>be" , <S2SV_EndBug> <S2SV_StartBug> header -> probe_magic , tagname ( header -> probe_magic ) ) ; <S2SV_EndBug> # define PRINT_A_BIT 48 if ( app_length > PRINT_A_BIT ) dumplength = PRINT_A_BIT ; else dumplength = app_length ; goto appdump ; } } if ( fulldirname ) free ( fulldirname ) ; } else { max_offset = app1_offset + app_length + 2 ; if ( PRINT_SECTION ) { chpr += printf ( "<S2SV_blank>-<S2SV_blank>unknown<S2SV_blank>format" ) ; goto appdump ; } } } else if ( PRINT_SECTION ) { chpr += printf ( "<S2SV_blank><S2SV_blank>No<S2SV_blank>APP1<S2SV_blank>header<S2SV_blank>name<S2SV_blank>string<S2SV_blank>found" ) ; chpr = newline ( chpr ) ; } if ( PRINT_SECTION ) { print_tag_address ( SECTION , max_offset - 1 , indent , "-" ) ; chpr += printf ( "</%s>" , name ) ; chpr = newline ( chpr ) ; } } return ( max_offset ) ; appdump : if ( app_length > 0L ) { if ( ( PRINT_APPNDUMP ) || ( dumplength > 0 ) ) { if ( ( Max_appdump == DUMPALL ) || ( Max_appdump > ( app_length + 2 ) ) ) dumplength = app_length + 2 ; else if ( Max_appdump > 0L ) dumplength = Max_appdump ; else if ( dumplength == 0 ) dumplength = Max_undefined ; if ( dumplength ) { chpr = newline ( 1 ) ; hexdump ( inptr , app1_offset , app_length + 2 , dumplength , 16 , indent + SMALLINDENT , SMALLINDENT ) ; chpr = newline ( 1 ) ; } } else { if ( PRINT_SEGMENT ) { chpr += printf ( "<S2SV_blank>-<S2SV_blank>(not<S2SV_blank>dumped:<S2SV_blank>use<S2SV_blank>-A)" ) ; chpr = newline ( chpr ) ; } } max_offset = app1_offset + app_length + 2 ; print_tag_address ( SECTION , app1_offset + app_length + 1 , indent , "-" ) ; if ( PRINT_SECTION ) { chpr += printf ( "</%s>" , name ) ; chpr = newline ( chpr ) ; } } setcharsprinted ( chpr ) ; return ( max_offset ) ; } | <S2SV_ModStart> ADDRWIDTH ) ; if ( header ) { <S2SV_ModStart> ) ) ; } else { chpr += printf ( "<S2SV_blank>INVALID<S2SV_blank>HEADER<S2SV_blank>for<S2SV_blank>TIFF" ) ; } |
4,858 | CWE-000 static void gpio_intel_apl_irq_config ( struct device * dev ) { <S2SV_StartBug> IRQ_CONNECT ( INTEL_APL_GPIO_0_IRQ_0 , INTEL_APL_GPIO_0_IRQ_0_PRIORITY , <S2SV_EndBug> gpio_intel_apl_isr , DEVICE_GET ( gpio_intel_apl ) , <S2SV_StartBug> INTEL_APL_GPIO_0_IRQ_0_SENSE ) ; <S2SV_EndBug> <S2SV_StartBug> irq_enable ( INTEL_APL_GPIO_0_IRQ_0 ) ; <S2SV_EndBug> } | <S2SV_ModStart> { IRQ_CONNECT ( APL_GPIO_IRQ , APL_GPIO_IRQ_PRIORITY <S2SV_ModEnd> , gpio_intel_apl_isr , <S2SV_ModStart> gpio_intel_apl ) , APL_GPIO_IRQ_SENSE <S2SV_ModEnd> ) ; irq_enable <S2SV_ModStart> ; irq_enable ( APL_GPIO_IRQ <S2SV_ModEnd> ) ; } |
4,859 | CWE-000 static ngx_int_t ngx_http_upload_md5_variable ( ngx_http_request_t * r , ngx_http_variable_value_t * v , uintptr_t data ) { ngx_http_upload_ctx_t * u ; u = ngx_http_get_module_ctx ( r , ngx_http_upload_module ) ; <S2SV_StartBug> if ( u -> sha1_ctx == NULL || u -> partial_content ) { <S2SV_EndBug> v -> not_found = 1 ; return NGX_OK ; } return ngx_http_upload_hash_variable ( r , v , data , u -> md5_ctx -> md5_digest , MD5_DIGEST_LENGTH ) ; } | <S2SV_ModStart> ( u -> md5_ctx <S2SV_ModEnd> == NULL || |
4,860 | CWE-000 static int BN_from_montgomery_word ( BIGNUM * ret , BIGNUM * r , BN_MONT_CTX * mont ) { BIGNUM * n ; BN_ULONG * ap , * np , * rp , n0 , v , carry ; int nl , max , i ; n = & ( mont -> N ) ; nl = n -> top ; if ( nl == 0 ) { ret -> top = 0 ; return 1 ; } max = ( 2 * nl ) ; if ( bn_wexpand ( r , max ) == NULL ) return 0 ; r -> neg ^= n -> neg ; np = n -> d ; rp = r -> d ; i = max - r -> top ; <S2SV_StartBug> if ( i ) <S2SV_EndBug> <S2SV_StartBug> memset ( & rp [ r -> top ] , 0 , sizeof ( * rp ) * i ) ; <S2SV_EndBug> r -> top = max ; n0 = mont -> n0 [ 0 ] ; for ( carry = 0 , i = 0 ; i < nl ; i ++ , rp ++ ) { v = bn_mul_add_words ( rp , np , nl , ( rp [ 0 ] * n0 ) & BN_MASK2 ) ; v = ( v + carry + rp [ nl ] ) & BN_MASK2 ; carry |= ( v != rp [ nl ] ) ; carry &= ( v <= rp [ nl ] ) ; rp [ nl ] = v ; } if ( bn_wexpand ( ret , nl ) == NULL ) return 0 ; ret -> top = nl ; ret -> neg = r -> neg ; rp = ret -> d ; ap = & ( r -> d [ nl ] ) ; v = bn_sub_words ( rp , ap , np , nl ) - carry ; v = 0 - v ; for ( i = 0 ; i < nl ; i ++ ) { rp [ i ] = ( v & ap [ i ] ) | ( ~ v & rp [ i ] ) ; ap [ i ] = 0 ; } bn_correct_top ( r ) ; bn_correct_top ( ret ) ; bn_check_top ( ret ) ; return 1 ; } | <S2SV_ModStart> if ( i > 0 <S2SV_ModStart> * i ) ; else if ( i < 0 ) return 0 |
4,861 | CWE-000 static void send_perf_data_by_time ( void ) { char * tx_buf [ PCKT_FRAG_MAX ] ; struct knet_mmsghdr msg [ PCKT_FRAG_MAX ] ; struct iovec iov_out [ PCKT_FRAG_MAX ] ; char ctrl_message [ 16 ] ; int sent_msgs ; int i ; uint32_t packetsize = 64 ; struct timespec clock_start , clock_end ; unsigned long long time_diff = 0 ; setup_send_buffers_common ( msg , iov_out , tx_buf ) ; memset ( & clock_start , 0 , sizeof ( clock_start ) ) ; memset ( & clock_end , 0 , sizeof ( clock_start ) ) ; while ( packetsize <= KNET_MAX_PACKET_SIZE ) { for ( i = 0 ; i < PCKT_FRAG_MAX ; i ++ ) { iov_out [ i ] . iov_len = packetsize ; } <S2SV_StartBug> printf ( "Testing<S2SV_blank>with<S2SV_blank>%u<S2SV_blank>bytes<S2SV_blank>packet<S2SV_blank>size<S2SV_blank>for<S2SV_blank>%zu<S2SV_blank>seconds.\\n" , packetsize , perf_by_time_secs ) ; <S2SV_EndBug> memset ( ctrl_message , 0 , sizeof ( ctrl_message ) ) ; knet_send ( knet_h , ctrl_message , TEST_START , channel ) ; if ( clock_gettime ( CLOCK_MONOTONIC , & clock_start ) != 0 ) { printf ( "Unable<S2SV_blank>to<S2SV_blank>get<S2SV_blank>start<S2SV_blank>time!\\n" ) ; } time_diff = 0 ; while ( time_diff < ( perf_by_time_secs * 1000000000llu ) ) { sent_msgs = send_messages ( & msg [ 0 ] , PCKT_FRAG_MAX ) ; if ( sent_msgs < 0 ) { printf ( "Something<S2SV_blank>went<S2SV_blank>wrong,<S2SV_blank>aborting\\n" ) ; exit ( FAIL ) ; } if ( clock_gettime ( CLOCK_MONOTONIC , & clock_end ) != 0 ) { printf ( "Unable<S2SV_blank>to<S2SV_blank>get<S2SV_blank>end<S2SV_blank>time!\\n" ) ; } timespec_diff ( clock_start , clock_end , & time_diff ) ; } sleep ( 2 ) ; knet_send ( knet_h , ctrl_message , TEST_STOP , channel ) ; if ( packetsize == KNET_MAX_PACKET_SIZE ) { break ; } packetsize *= 4 ; if ( packetsize > KNET_MAX_PACKET_SIZE ) { packetsize = KNET_MAX_PACKET_SIZE ; } } knet_send ( knet_h , ctrl_message , TEST_COMPLETE , channel ) ; for ( i = 0 ; i < PCKT_FRAG_MAX ; i ++ ) { free ( tx_buf [ i ] ) ; } } | <S2SV_ModStart> packetsize ; } # if ! ( defined ( __i386__ ) ) <S2SV_ModStart> perf_by_time_secs ) ; # else printf ( "Testing<S2SV_blank>with<S2SV_blank>%u<S2SV_blank>bytes<S2SV_blank>packet<S2SV_blank>size<S2SV_blank>for<S2SV_blank>%llu<S2SV_blank>seconds.\\n" , packetsize , perf_by_time_secs ) ; # endif |
4,862 | CWE-000 unsigned int windowStateFromString ( const char * str ) { if ( strcasecmp ( str , "modal" ) == 0 ) return CompWindowStateModalMask ; <S2SV_StartBug> else if ( strcasecmp ( str , "sticky" ) == 0 ) <S2SV_EndBug> return CompWindowStateStickyMask ; else if ( strcasecmp ( str , "maxvert" ) == 0 ) return CompWindowStateMaximizedVertMask ; else if ( strcasecmp ( str , "maxhorz" ) == 0 ) return CompWindowStateMaximizedHorzMask ; else if ( strcasecmp ( str , "shaded" ) == 0 ) return CompWindowStateShadedMask ; else if ( strcasecmp ( str , "skiptaskbar" ) == 0 ) return CompWindowStateSkipTaskbarMask ; else if ( strcasecmp ( str , "skippager" ) == 0 ) return CompWindowStateSkipPagerMask ; else if ( strcasecmp ( str , "hidden" ) == 0 ) return CompWindowStateHiddenMask ; else if ( strcasecmp ( str , "fullscreen" ) == 0 ) return CompWindowStateFullscreenMask ; else if ( strcasecmp ( str , "above" ) == 0 ) return CompWindowStateAboveMask ; else if ( strcasecmp ( str , "below" ) == 0 ) return CompWindowStateBelowMask ; else if ( strcasecmp ( str , "demandsattention" ) == 0 ) return CompWindowStateDemandsAttentionMask ; return 0 ; } | <S2SV_ModStart> ( str , "focused" ) == 0 ) return CompWindowStateFocusedMask ; else if ( strcasecmp ( str , |
4,863 | CWE-000 void hash_table_remove ( HashTable * hashtable , const char * skey ) { size_t pos ; HashNode * pHead , * pLast , * pRemove ; pHead = pLast = pRemove = NULL ; pos = hash_pos ( hash ( skey ) , hashtable ) ; if ( ( pHead = hashtable -> hashnode [ pos ] ) ) { hashNode_for_each ( pHead ) { if ( strcmp ( skey , pHead -> sKey ) == 0 ) { pRemove = pHead ; break ; } pLast = pHead ; } <S2SV_StartBug> if ( pRemove ) { <S2SV_EndBug> if ( pLast ) { pLast -> pNext = pRemove -> pNext ; } else { <S2SV_StartBug> ( hashtable -> hashnode ) [ pos ] = pRemove -> pNext ; <S2SV_EndBug> } __free_hashnode__ ( pRemove ) ; } else { <S2SV_StartBug> die ( "key<S2SV_blank>is<S2SV_blank>not<S2SV_blank>exist." ) ; <S2SV_EndBug> } } else { die ( "key<S2SV_blank>is<S2SV_blank>not<S2SV_blank>exist." ) ; } } | <S2SV_ModStart> } if ( <S2SV_ModEnd> pLast ) { <S2SV_ModStart> } else { <S2SV_ModEnd> hashtable -> hashnode <S2SV_ModStart> hashtable -> hashnode <S2SV_ModEnd> [ pos ] <S2SV_ModStart> } else { printf <S2SV_ModEnd> ( "key<S2SV_blank>is<S2SV_blank>not<S2SV_blank>exist." ) |
4,864 | CWE-000 void * pgdir_get_phys_page ( u32 * pgdir , void * virtaddr ) { void * off = ( void * ) ( ( u32 ) virtaddr & 0x00000FFF ) ; virtaddr = ( void * ) ( ( u32 ) virtaddr & 0xFFFFF000 ) ; u32 pdindex = ( u32 ) virtaddr >> 22 ; u32 ptindex = ( u32 ) virtaddr >> 12 & 0x03FF ; if ( pgdir [ pdindex ] & 0x01 ) { <S2SV_StartBug> if ( ( ( u32 * ) pgdir [ pdindex ] ) [ ptindex ] & 0x01 ) <S2SV_EndBug> <S2SV_StartBug> return ( void * ) ( ( ( ( u32 * ) pgdir [ pdindex ] ) [ ptindex ] & 0xFFFFF000 ) | ( u32 ) off ) ; <S2SV_EndBug> else return NULL ; } else return NULL ; } | <S2SV_ModStart> u32 * ) ( <S2SV_ModStart> [ pdindex ] & 0xFFFFF000 ) <S2SV_ModStart> u32 * ) ( <S2SV_ModStart> [ pdindex ] & 0xFFFFF000 ) |
4,865 | CWE-000 double update_bosonic_step ( Real eps ) { int n = nsteps [ 1 ] , i ; double norm ; # ifdef UPDATE_DEBUG node0_printf ( "gauge<S2SV_blank>%d<S2SV_blank>steps<S2SV_blank>%.4g<S2SV_blank>dt\\n" , n , eps ) ; # endif norm = bosonic_force ( eps * LAMBDA ) ; for ( i = 1 ; i <= n ; i ++ ) { <S2SV_StartBug> update_uu ( 0.5 * eps ) ; <S2SV_EndBug> norm += bosonic_force ( eps * LAMBDA_MID ) ; <S2SV_StartBug> update_uu ( 0.5 * eps ) ; <S2SV_EndBug> if ( i < n ) norm += bosonic_force ( eps * TWO_LAMBDA ) ; else norm += bosonic_force ( eps * LAMBDA ) ; } reunitarize ( ) ; reantihermize ( ) ; return ( norm / n ) ; } | <S2SV_ModStart> ++ ) { update_u <S2SV_ModEnd> ( 0.5 * <S2SV_ModStart> LAMBDA_MID ) ; update_u <S2SV_ModEnd> ( 0.5 * |
4,866 | CWE-000 int main ( int argc , char * * argv ) { <S2SV_StartBug> int how_many_threads_ya_want = ( int ) argv [ 1 ] ; <S2SV_EndBug> _debugging_pthread_mutex ( how_many_threads_ya_want ) ; } | <S2SV_ModStart> argv ) { if ( argc != 2 ) { printf ( ANSI_COLOR_RED "Usage:<S2SV_blank>./my_pthread_t<S2SV_blank>[NUM_THREADS]\\n" ANSI_COLOR_RESET ) ; exit ( - 1 ) ; } <S2SV_ModStart> int how_many_threads_ya_want = atoi ( <S2SV_ModEnd> argv [ 1 <S2SV_ModStart> [ 1 ] ) ; printf ( "%i\\n" , how_many_threads_ya_want ) |
4,867 | CWE-000 static int bcm_get_resources ( struct bcm_device * dev ) <S2SV_StartBug> { <S2SV_EndBug> dev -> name = dev_name ( dev -> dev ) ; if ( x86_apple_machine && ! bcm_apple_get_resources ( dev ) ) return 0 ; dev -> clk = devm_clk_get ( dev -> dev , NULL ) ; dev -> device_wakeup = devm_gpiod_get_optional ( dev -> dev , "device-wakeup" , GPIOD_OUT_LOW ) ; if ( IS_ERR ( dev -> device_wakeup ) ) return PTR_ERR ( dev -> device_wakeup ) ; dev -> shutdown = devm_gpiod_get_optional ( dev -> dev , "shutdown" , GPIOD_OUT_LOW ) ; if ( IS_ERR ( dev -> shutdown ) ) return PTR_ERR ( dev -> shutdown ) ; dev -> set_device_wakeup = bcm_gpio_set_device_wakeup ; dev -> set_shutdown = bcm_gpio_set_shutdown ; if ( dev -> irq <= 0 ) { struct gpio_desc * gpio ; gpio = devm_gpiod_get_optional ( dev -> dev , "host-wakeup" , GPIOD_IN ) ; if ( IS_ERR ( gpio ) ) return PTR_ERR ( gpio ) ; dev -> irq = gpiod_to_irq ( gpio ) ; } <S2SV_StartBug> dev_dbg ( dev -> dev , "BCM<S2SV_blank>irq:<S2SV_blank>%d\\n" , dev -> irq ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> dev ) { const struct dmi_system_id * dmi_id ; <S2SV_ModStart> ) ; } dmi_id = dmi_first_match ( bcm_broken_irq_dmi_table ) ; if ( dmi_id ) { dev_info ( dev -> dev , "%s:<S2SV_blank>Has<S2SV_blank>a<S2SV_blank>broken<S2SV_blank>IRQ<S2SV_blank>config,<S2SV_blank>disabling<S2SV_blank>IRQ<S2SV_blank>support<S2SV_blank>/<S2SV_blank>runtime-pm\\n" , dmi_id -> ident ) ; dev -> irq = 0 ; } |
4,868 | CWE-000 PyObject * tcc_compil ( PyObject * self , PyObject * args ) { char * func_name ; char * func_code ; int ( * entry ) ( void ) ; TCCState * tcc_state = NULL ; PyObject * ret ; tcc_state = tcc_init_state ( ) ; if ( ! PyArg_ParseTuple ( args , "ss" , & func_name , & func_code ) ) return NULL ; if ( tcc_compile_string ( tcc_state , func_code ) != 0 ) { <S2SV_StartBug> fprintf ( stderr , "Erreur<S2SV_blank>de<S2SV_blank>compilation<S2SV_blank>!\\n" ) ; <S2SV_EndBug> fprintf ( stderr , "%s\\n" , func_code ) ; exit ( 1 ) ; } if ( tcc_relocate ( tcc_state , TCC_RELOCATE_AUTO ) < 0 ) { <S2SV_StartBug> fprintf ( stderr , "tcc<S2SV_blank>relocate<S2SV_blank>error\\n" ) ; <S2SV_EndBug> exit ( 1 ) ; } entry = tcc_get_symbol ( tcc_state , func_name ) ; if ( ! entry ) { <S2SV_StartBug> fprintf ( stderr , "Erreur<S2SV_blank>de<S2SV_blank>symbole<S2SV_blank>%s!\\n" , func_name ) ; <S2SV_EndBug> fprintf ( stderr , "%s\\n" , func_name ) ; exit ( 1 ) ; } ret = PyTuple_New ( 2 ) ; if ( ret == NULL ) { <S2SV_StartBug> fprintf ( stderr , "Erreur<S2SV_blank>alloc<S2SV_blank>%s!\\n" , func_name ) ; <S2SV_EndBug> fprintf ( stderr , "%s\\n" , func_name ) ; exit ( 1 ) ; } PyTuple_SetItem ( ret , 0 , PyLong_FromUnsignedLongLong ( ( intptr_t ) tcc_state ) ) ; PyTuple_SetItem ( ret , 1 , PyLong_FromUnsignedLongLong ( ( intptr_t ) entry ) ) ; return ret ; } | <S2SV_ModStart> ( stderr , "Error<S2SV_blank>compiling<S2SV_blank>!\\n" <S2SV_ModEnd> ) ; fprintf <S2SV_ModStart> ( stderr , "TCC<S2SV_blank>relocate<S2SV_blank>error\\n" <S2SV_ModEnd> ) ; exit <S2SV_ModStart> ( stderr , "Error<S2SV_blank>getting<S2SV_blank>symbol<S2SV_blank>%s!\\n" <S2SV_ModEnd> , func_name ) <S2SV_ModStart> ( stderr , "Error<S2SV_blank>alloc<S2SV_blank>%s!\\n" <S2SV_ModEnd> , func_name ) |
4,869 | CWE-000 struct mCc_ast_literal * mCc_test_build_test_lit_string ( const char * value ) { <S2SV_StartBug> return mCc_ast_new_literal_string ( strdup ( value ) ) ; <S2SV_EndBug> } | <S2SV_ModStart> strdup ( value , strlen ( value ) + 1 |
4,870 | CWE-000 static ssize_t mem_used_max_store ( struct device * dev , struct device_attribute * attr , const char * buf , size_t len ) { int err ; unsigned long val ; struct zram * zram = dev_to_zram ( dev ) ; <S2SV_StartBug> struct zram_meta * meta = zram -> meta ; <S2SV_EndBug> err = kstrtoul ( buf , 10 , & val ) ; if ( err || val != 0 ) return - EINVAL ; down_read ( & zram -> init_lock ) ; <S2SV_StartBug> if ( init_done ( zram ) ) <S2SV_EndBug> atomic_long_set ( & zram -> stats . max_used_pages , zs_get_total_pages ( meta -> mem_pool ) ) ; <S2SV_StartBug> up_read ( & zram -> init_lock ) ; <S2SV_EndBug> return len ; } | <S2SV_ModStart> dev ) ; <S2SV_ModEnd> err = kstrtoul <S2SV_ModStart> zram ) ) { struct zram_meta * meta = zram -> meta ; <S2SV_ModStart> ) ) ; } |
4,871 | CWE-000 dupreq_status_t nfs_dupreq_finish ( struct svc_req * req , nfs_res_t * res_nfs ) { dupreq_entry_t * ov = NULL , * dv = ( dupreq_entry_t * ) req -> rq_u1 ; dupreq_status_t status = DUPREQ_SUCCESS ; struct rbtree_x_part * t ; drc_t * drc = NULL ; int16_t cnt = 0 ; if ( dv == ( void * ) DUPREQ_NOCACHE ) goto out ; if ( dv == ( void * ) DUPREQ_BAD_ADDR1 ) goto out ; PTHREAD_MUTEX_lock ( & dv -> mtx ) ; dv -> res = res_nfs ; dv -> timestamp = time ( NULL ) ; dv -> state = DUPREQ_COMPLETE ; drc = dv -> hin . drc ; PTHREAD_MUTEX_unlock ( & dv -> mtx ) ; PTHREAD_MUTEX_lock ( & drc -> mtx ) ; LogFullDebug ( COMPONENT_DUPREQ , "completing<S2SV_blank>dv=%p<S2SV_blank>xid=%u<S2SV_blank>on<S2SV_blank>DRC=%p<S2SV_blank>state=%s,<S2SV_blank>status=%s,<S2SV_blank>refcnt=%d,<S2SV_blank>drc->size=%d" , dv , dv -> hin . tcp . rq_xid , drc , dupreq_state_table [ dv -> state ] , dupreq_status_table [ status ] , dv -> refcnt , drc -> size ) ; drc_dec_retwnd ( drc ) ; dq_again : if ( drc_should_retire ( drc ) ) { ov = TAILQ_FIRST ( & drc -> dupreq_q ) ; if ( likely ( ov ) ) { if ( unlikely ( ov -> refcnt > 0 ) ) goto unlock ; t = rbtx_partition_of_scalar ( & drc -> xt , ov -> hk ) ; uint64_t ov_hk = ov -> hk ; PTHREAD_MUTEX_unlock ( & drc -> mtx ) ; PTHREAD_MUTEX_lock ( & t -> mtx ) ; PTHREAD_MUTEX_lock ( & drc -> mtx ) ; ov = TAILQ_FIRST ( & drc -> dupreq_q ) ; if ( ov == NULL || ov -> hk != ov_hk ) { PTHREAD_MUTEX_unlock ( & t -> mtx ) ; goto unlock ; } if ( ov -> refcnt > 0 ) { PTHREAD_MUTEX_unlock ( & t -> mtx ) ; goto unlock ; } TAILQ_REMOVE ( & drc -> dupreq_q , ov , fifo_q ) ; -- ( drc -> size ) ; <S2SV_StartBug> PTHREAD_MUTEX_unlock ( & drc -> mtx ) ; <S2SV_EndBug> rbtree_x_cached_remove ( & drc -> xt , t , & ov -> rbt_k , ov -> hk ) ; PTHREAD_MUTEX_unlock ( & t -> mtx ) ; LogDebug ( COMPONENT_DUPREQ , "retiring<S2SV_blank>ov=%p<S2SV_blank>xid=%u<S2SV_blank>on<S2SV_blank>DRC=%p<S2SV_blank>state=%s,<S2SV_blank>status=%s,<S2SV_blank>refcnt=%d" , ov , ov -> hin . tcp . rq_xid , ov -> hin . drc , dupreq_state_table [ dv -> state ] , dupreq_status_table [ status ] , ov -> refcnt ) ; nfs_dupreq_free_dupreq ( ov ) ; if ( cnt ++ < DUPREQ_MAX_RETRIES ) { PTHREAD_MUTEX_lock ( & drc -> mtx ) ; goto dq_again ; } goto out ; } } unlock : PTHREAD_MUTEX_unlock ( & drc -> mtx ) ; out : return status ; } | <S2SV_ModStart> size ) ; nfs_dupreq_put_drc ( NULL , drc , DRC_FLAG_LOCKED ) ; |
4,872 | CWE-000 void pwake ( ptptr p ) { if ( p -> p_status > P_RUNNING && p -> p_status < P_STOPPED ) { <S2SV_StartBug> p -> p_status = P_READY ; <S2SV_EndBug> p -> p_wait = NULL ; <S2SV_StartBug> nready ++ ; <S2SV_EndBug> } } | <S2SV_ModStart> P_STOPPED ) { if ( p -> p_status != P_READY ) { nready ++ ; <S2SV_ModStart> = P_READY ; } <S2SV_ModStart> = NULL ; <S2SV_ModEnd> } } <S2SV_null> |
4,873 | CWE-000 void k_thread_abort ( k_tid_t thread ) { unsigned int key ; key = irq_lock ( ) ; _k_thread_single_abort ( thread ) ; _thread_monitor_exit ( thread ) ; if ( _current == thread ) { <S2SV_StartBug> if ( _ScbIsInThreadMode ( ) ) { <S2SV_EndBug> _Swap ( key ) ; CODE_UNREACHABLE ; } else { <S2SV_StartBug> _ScbPendsvSet ( ) ; <S2SV_EndBug> } } _reschedule_threads ( key ) ; } | <S2SV_ModStart> { if ( ( SCB -> ICSR & SCB_ICSR_VECTACTIVE_Msk ) == 0 <S2SV_ModEnd> ) { _Swap <S2SV_ModStart> } else { SCB -> ICSR |= SCB_ICSR_PENDSVSET_Msk <S2SV_ModEnd> ; } } |
4,874 | CWE-000 lex_ctxt * init_empty_lex_ctxt ( ) { lex_ctxt * c = g_malloc0 ( sizeof ( lex_ctxt ) ) ; <S2SV_StartBug> c -> ctx_vars . hash_elt = g_malloc0 ( sizeof ( named_nasl_var ) * VAR_NAME_HASH ) ; <S2SV_EndBug> c -> ctx_vars . num_elt = NULL ; c -> ctx_vars . max_idx = 0 ; c -> functions = g_hash_table_new_full ( g_str_hash , g_str_equal , NULL , ( GDestroyNotify ) free_func ) ; c -> oid = NULL ; c -> ret_val = NULL ; c -> fct_ctxt = 0 ; init_nasl_library ( c ) ; return c ; } | <S2SV_ModStart> sizeof ( named_nasl_var * |
4,875 | CWE-000 mfmError mfmCreateStackAllocator ( mfmStackAllocator * * stackAllocator , mfmU64 size ) { if ( stackAllocator == NULL || size == 0 ) return MFM_ERROR_INVALID_ARGUMENTS ; <S2SV_StartBug> return <S2SV_EndBug> mfmU8 * memory = ( mfmU8 * ) malloc ( sizeof ( mfmStackAllocator ) + size ) ; if ( memory == NULL ) return MFM_ERROR_ALLOCATION_FAILED ; * stackAllocator = ( mfmStackAllocator * ) ( memory + 0 ) ; ( * stackAllocator ) -> stackSize = size ; ( * stackAllocator ) -> stackBegin = memory + sizeof ( mfmStackAllocator ) ; ( * stackAllocator ) -> stackHead = memory + sizeof ( mfmStackAllocator ) ; <S2SV_StartBug> ( * mfmStackAllocator ) -> object . destructorFunc = & mfmDestroyStackAllocator ; <S2SV_EndBug> return MFM_ERROR_OKAY ; } | <S2SV_ModStart> return MFM_ERROR_INVALID_ARGUMENTS ; <S2SV_ModEnd> mfmU8 * memory <S2SV_ModStart> ; ( * stackAllocator <S2SV_ModEnd> ) -> object |
4,876 | CWE-000 static int am65_cpsw_nuss_init_tx_chns ( struct am65_cpsw_common * common ) { struct device * dev = common -> dev ; u32 max_desc_num = ALIGN ( AM65_CPSW_MAX_TX_DESC , MAX_SKB_FRAGS ) ; struct k3_nav_udmax_tx_channel_cfg tx_cfg = { 0 } ; struct k3_nav_ring_cfg ring_cfg = { . elm_size = K3_NAV_RINGACC_RING_ELSIZE_8 , . mode = K3_NAV_RINGACC_RING_MODE_RING , . flags = 0 } ; u32 hdesc_size ; int i , ret ; init_completion ( & common -> tdown_complete ) ; hdesc_size = knav_udmap_hdesc_calc_size ( true , AM65_CPSW_NAV_PS_DATA_SIZE , AM65_CPSW_NAV_SW_DATA_SIZE ) ; tx_cfg . swdata_size = AM65_CPSW_NAV_SW_DATA_SIZE ; tx_cfg . tx_cfg = ring_cfg ; tx_cfg . txcq_cfg = ring_cfg ; tx_cfg . tx_cfg . size = max_desc_num ; tx_cfg . txcq_cfg . size = max_desc_num ; for ( i = 0 ; i < AM65_CPSW_MAX_TX_QUEUES ; i ++ ) { struct am65_cpsw_tx_chn * tx_chn = & common -> tx_chns [ i ] ; char tx_chn_name [ IFNAMSIZ ] ; snprintf ( tx_chn_name , sizeof ( tx_chn_name ) , "tx%d" , i ) ; tx_chn -> dev = dev ; tx_chn -> id = i ; tx_chn -> descs_num = max_desc_num ; tx_chn -> desc_pool = k3_knav_pool_create_name ( dev , tx_chn -> descs_num , hdesc_size , tx_chn_name ) ; if ( IS_ERR ( tx_chn -> desc_pool ) ) { ret = PTR_ERR ( tx_chn -> desc_pool ) ; <S2SV_StartBug> tx_chn -> desc_pool = NULL ; <S2SV_EndBug> dev_err ( dev , "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>poll<S2SV_blank>%d\\n" , ret ) ; goto err ; } tx_chn -> tx_chn = k3_nav_udmax_request_tx_chn ( dev , tx_chn_name , & tx_cfg ) ; if ( IS_ERR ( tx_chn -> tx_chn ) ) { <S2SV_StartBug> ret = PTR_ERR ( tx_chn -> tx_chn ) ; <S2SV_EndBug> tx_chn -> tx_chn = NULL ; dev_err ( dev , "Failed<S2SV_blank>to<S2SV_blank>request<S2SV_blank>tx<S2SV_blank>dma<S2SV_blank>channel<S2SV_blank>%d\\n" , ret ) ; goto err ; } ret = k3_nav_udmax_tx_get_irq ( tx_chn -> tx_chn , & tx_chn -> irq , IRQF_TRIGGER_HIGH , true , i ? common -> tx_chns [ 0 ] . tx_chn : NULL ) ; <S2SV_StartBug> if ( ret ) <S2SV_EndBug> goto err ; } <S2SV_StartBug> return 0 ; <S2SV_EndBug> err : for ( i = 0 ; i < AM65_CPSW_MAX_TX_QUEUES ; i ++ ) { struct am65_cpsw_tx_chn * tx_chn = & common -> tx_chns [ i ] ; <S2SV_StartBug> if ( tx_chn -> irq > 0 ) <S2SV_EndBug> k3_nav_udmax_tx_put_irq ( tx_chn -> tx_chn ) ; if ( tx_chn -> tx_chn ) k3_nav_udmax_release_tx_chn ( tx_chn -> tx_chn ) ; if ( tx_chn -> desc_pool ) k3_knav_pool_destroy ( tx_chn -> desc_pool ) ; memset ( tx_chn , 0 , sizeof ( * tx_chn ) ) ; } return ret ; } | <S2SV_ModStart> desc_pool ) ; <S2SV_ModEnd> dev_err ( dev <S2SV_ModStart> -> tx_chn ) <S2SV_ModEnd> ; dev_err ( <S2SV_ModStart> ( ret ) { dev_err ( dev , "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>tx<S2SV_blank>dma<S2SV_blank>irq<S2SV_blank>%d\\n" , ret ) ; <S2SV_ModStart> err ; } } err : i = devm_add_action ( dev , am65_cpsw_nuss_free_tx_chns , common ) <S2SV_ModEnd> ; if ( <S2SV_ModStart> ; if ( i ) { dev_err ( dev , "failed<S2SV_blank>to<S2SV_blank>add<S2SV_blank>free_tx_chns<S2SV_blank>action<S2SV_blank>%d" , i ) ; return i ; } return <S2SV_ModEnd> ret ; } |
4,877 | CWE-000 void conn_put ( struct conn * conn ) { ASSERT ( conn -> sd < 0 ) ; ASSERT ( conn -> owner == NULL ) ; log_debug ( LOG_VVERB , "put<S2SV_blank>conn<S2SV_blank>%p" , conn ) ; nfree_connq ++ ; TAILQ_INSERT_HEAD ( & free_connq , conn , conn_tqe ) ; <S2SV_StartBug> curr_connections -- ; <S2SV_EndBug> } | <S2SV_ModStart> conn_tqe ) ; if ( conn -> client ) { curr_client_connections -- ; } |
4,878 | CWE-000 void val_DestroyInstance ( VkInstance _instance , const VkAllocationCallbacks * pAllocator ) { VAL_FROM_HANDLE ( val_instance , instance , _instance ) ; <S2SV_StartBug> val_finish_wsi ( & instance -> physicalDevice ) ; <S2SV_EndBug> vk_free ( & instance -> alloc , instance ) ; } | <S2SV_ModStart> _instance ) ; if ( instance -> physicalDeviceCount != - 1 ) { <S2SV_ModStart> physicalDevice ) ; } |
4,879 | CWE-000 int ssfs_fwrite ( int fileID , char * buf , int length ) { if ( fileID < 0 || fileID >= max_file_num ) return - 1 ; int k = 0 , block_to_write , i_node_index [ max_file_num ] = { - 1 } , i_node_number = fd_table [ fileID ] . i_node_number ; if ( length == 0 ) return 0 ; if ( i_node_number != - 1 ) { int block = fd_table [ fileID ] . write_ptr . block ; int entry = fd_table [ fileID ] . write_ptr . entry ; int offset = entry + 1 ; if ( offset + length <= block_size ) { int acc = writes_block_by_char ( block , offset , buf , length ) ; if ( acc != - 1 ) { fd_table [ fileID ] . write_ptr . entry += acc ; int inc = fd_table [ fileID ] . write_ptr . entry - i_node_array [ i_node_number ] . size % block_size + 1 ; if ( find_block_to_read ( i_node_number , block ) == - 1 && inc > 0 ) inc_size ( fileID , inc ) ; commit_i_node_file ( ) ; load_i_node_file ( ) ; <S2SV_StartBug> return length ; <S2SV_EndBug> } else return - 1 ; } else if ( entry == block_size - 1 && length <= block_size ) { <S2SV_StartBug> int temp = find_block_to_write ( fileID , block ) ; <S2SV_EndBug> <S2SV_StartBug> if ( temp < 0 ) return - 1 ; <S2SV_EndBug> fd_table [ fileID ] . write_ptr . block = temp ; fd_table [ fileID ] . write_ptr . entry = - 1 ; return ssfs_fwrite ( fileID , buf , length ) ; } else { int avail = block_size - offset ; int rest = length - avail ; int piece = rest / block_size ; int last = rest % block_size ; int acc = 0 ; int temp ; acc += ssfs_fwrite ( fileID , buf , avail ) ; for ( k = 0 ; k < piece ; k ++ ) { <S2SV_StartBug> if ( ( temp = ssfs_fwrite ( fileID , buf + avail + block_size * k , block_size ) ) < 0 ) return acc ; <S2SV_EndBug> <S2SV_StartBug> else acc += temp ; <S2SV_EndBug> } <S2SV_StartBug> if ( ( temp = ssfs_fwrite ( fileID , buf + avail + block_size * k , last ) ) < 0 ) return acc ; <S2SV_EndBug> else acc += temp ; <S2SV_StartBug> return acc ; <S2SV_EndBug> } } printf ( "fwrite:<S2SV_blank>requested<S2SV_blank>file<S2SV_blank>is<S2SV_blank>not<S2SV_blank>opened\\n" ) ; return - 1 ; } | <S2SV_ModStart> ( ) ; printf ( "write<S2SV_blank>pointer<S2SV_blank>at<S2SV_blank>%d<S2SV_blank>%d\\n" , fd_table [ fileID ] . write_ptr . block , fd_table [ fileID ] . write_ptr . entry ) ; <S2SV_ModStart> = find_block_to_write ( i_node_number <S2SV_ModEnd> , block ) <S2SV_ModStart> < 0 ) { return - 1 ; } <S2SV_ModEnd> fd_table [ fileID <S2SV_ModStart> < 0 ) { return acc ; } <S2SV_ModEnd> else acc += <S2SV_ModStart> acc += temp ; printf ( "acc3:<S2SV_blank>%d\\n" , acc ) <S2SV_ModStart> < 0 ) { return acc ; } <S2SV_ModEnd> else acc += <S2SV_ModStart> += temp ; buf [ length ] = '\\0' ; |
4,880 | CWE-000 static int do_reset ( struct ibmvnic_adapter * adapter , struct ibmvnic_rwi * rwi , u32 reset_state ) { <S2SV_StartBug> struct net_device * netdev = adapter -> netdev ; <S2SV_EndBug> int i , rc ; netdev_dbg ( adapter -> netdev , "Re-setting<S2SV_blank>driver<S2SV_blank>(%d)\\n" , rwi -> reset_reason ) ; netif_carrier_off ( netdev ) ; adapter -> reset_reason = rwi -> reset_reason ; <S2SV_StartBug> if ( rwi -> reset_reason == VNIC_RESET_MOBILITY ) { <S2SV_EndBug> rc = ibmvnic_reenable_crq_queue ( adapter ) ; if ( rc ) return 0 ; } rc = __ibmvnic_close ( netdev ) ; if ( rc ) return rc ; if ( adapter -> reset_reason == VNIC_RESET_CHANGE_PARAM || adapter -> wait_for_reset ) { release_resources ( adapter ) ; release_sub_crqs ( adapter ) ; release_crq_queue ( adapter ) ; } if ( adapter -> reset_reason != VNIC_RESET_NON_FATAL ) { adapter -> state = VNIC_PROBED ; rc = ibmvnic_init ( adapter ) ; if ( rc ) return IBMVNIC_INIT_FAILED ; if ( reset_state == VNIC_PROBED ) return 0 ; rc = ibmvnic_login ( netdev ) ; if ( rc ) { adapter -> state = VNIC_PROBED ; return 0 ; } if ( adapter -> reset_reason == VNIC_RESET_CHANGE_PARAM || adapter -> wait_for_reset ) { rc = init_resources ( adapter ) ; if ( rc ) <S2SV_StartBug> return rc ; <S2SV_EndBug> } else { rc = reset_tx_pools ( adapter ) ; if ( rc ) return rc ; rc = reset_rx_pools ( adapter ) ; if ( rc ) return rc ; if ( reset_state == VNIC_CLOSED ) return 0 ; } } rc = __ibmvnic_open ( netdev ) ; if ( rc ) { if ( list_empty ( & adapter -> rwi_list ) ) adapter -> state = VNIC_CLOSED ; else adapter -> state = reset_state ; return 0 ; } netif_carrier_on ( netdev ) ; for ( i = 0 ; i < adapter -> req_rx_queues ; i ++ ) napi_schedule ( & adapter -> napi [ i ] ) ; if ( adapter -> reset_reason != VNIC_RESET_FAILOVER ) netdev_notify_peers ( netdev ) ; return 0 ; } | <S2SV_ModStart> reset_state ) { u64 old_num_rx_queues , old_num_tx_queues ; <S2SV_ModStart> -> reset_reason ; old_num_rx_queues = adapter -> req_rx_queues ; old_num_tx_queues = adapter -> req_tx_queues ; <S2SV_ModStart> ) return rc ; } else if ( adapter -> req_rx_queues != old_num_rx_queues || adapter -> req_tx_queues != old_num_tx_queues ) { release_rx_pools ( adapter ) ; release_tx_pools ( adapter ) ; init_rx_pools ( netdev ) ; init_tx_pools ( netdev ) |
4,881 | CWE-000 static void conn_default ( struct starter_conn * conn , struct starter_conn * def ) { int i ; * conn = * def ; conn -> link . tqe_next = NULL ; conn -> link . tqe_prev = NULL ; conn -> left . iface = clone_str ( def -> left . iface , "conn<S2SV_blank>default<S2SV_blank>left<S2SV_blank>iface" ) ; conn -> left . id = clone_str ( def -> left . id , "conn<S2SV_blank>default<S2SV_blank>leftid" ) ; conn -> left . rsakey1 = clone_str ( def -> left . rsakey1 , "conn<S2SV_blank>default<S2SV_blank>left<S2SV_blank>rsakey1" ) ; conn -> left . rsakey2 = clone_str ( def -> left . rsakey2 , "conn<S2SV_blank>default<S2SV_blank>left<S2SV_blank>rsakey2" ) ; conn -> right . iface = clone_str ( def -> right . iface , "conn<S2SV_blank>default<S2SV_blank>right<S2SV_blank>iface" ) ; conn -> right . id = clone_str ( def -> right . id , "conn<S2SV_blank>default<S2SV_blank>rightid" ) ; conn -> right . rsakey1 = clone_str ( def -> right . rsakey1 , "conn<S2SV_blank>default<S2SV_blank>right<S2SV_blank>rsakey1" ) ; conn -> right . rsakey2 = clone_str ( def -> right . rsakey2 , "conn<S2SV_blank>default<S2SV_blank>right<S2SV_blank>rsakey2" ) ; <S2SV_StartBug> # define C ( LR , F ) conn -> LR . F = clone_str ( def -> LR . F , "conn<S2SV_blank>default<S2SV_blank>" # LR "<S2SV_blank>" # F ) <S2SV_EndBug> # define CLR ( F ) C ( left , F ) ; C ( right , F ) CLR ( updown ) ; # undef CLR # undef C for ( i = 0 ; i < KSCF_MAX ; i ++ ) { conn -> left . strings [ i ] = clone_str ( def -> left . strings [ i ] , "conn<S2SV_blank>default<S2SV_blank>left<S2SV_blank>item" ) ; conn -> right . strings [ i ] = clone_str ( def -> right . strings [ i ] , "conn<S2SV_blank>default<S2SV_blank>right<S2SV_blank>item" ) ; } for ( i = 0 ; i < KNCF_MAX ; i ++ ) { conn -> left . options [ i ] = def -> left . options [ i ] ; conn -> right . options [ i ] = def -> right . options [ i ] ; } for ( i = 0 ; i < KSF_MAX ; i ++ ) conn -> strings [ i ] = clone_str ( def -> strings [ i ] , "conn<S2SV_blank>default<S2SV_blank>string<S2SV_blank>item" ) ; for ( i = 0 ; i < KBF_MAX ; i ++ ) conn -> options [ i ] = def -> options [ i ] ; conn -> esp = clone_str ( def -> esp , "conn<S2SV_blank>default<S2SV_blank>esp" ) ; conn -> ike = clone_str ( def -> ike , "conn<S2SV_blank>default<S2SV_blank>ike" ) ; conn -> modecfg_dns = clone_str ( def -> modecfg_dns , "conn<S2SV_blank>default<S2SV_blank>dns" ) ; conn -> modecfg_domains = clone_str ( def -> modecfg_domains , "conn<S2SV_blank>default<S2SV_blank>domains" ) ; conn -> modecfg_banner = clone_str ( def -> modecfg_banner , "conn<S2SV_blank>default<S2SV_blank>banner" ) ; conn -> conn_mark_both = clone_str ( def -> conn_mark_both , "conn<S2SV_blank>default<S2SV_blank>conn_mark_both" ) ; conn -> conn_mark_in = clone_str ( def -> conn_mark_in , "conn<S2SV_blank>default<S2SV_blank>conn_mark_in" ) ; conn -> conn_mark_out = clone_str ( def -> conn_mark_out , "conn<S2SV_blank>default<S2SV_blank>conn_mark_out" ) ; # ifdef HAVE_LABELED_IPSEC conn -> policy_label = clone_str ( def -> policy_label , "conn<S2SV_blank>default<S2SV_blank>policy_label" ) ; # endif conn -> policy = def -> policy ; } | <S2SV_ModStart> = clone_str ( DEFAULT_UPDOWN <S2SV_ModEnd> , "conn<S2SV_blank>default<S2SV_blank>" # |
4,882 | CWE-000 arcvcap_t emu_create_aep_thread ( spdid_t client , thdclosure_index_t idx , cos_channelkey_t key ) { struct sl_thd * thd ; sched_param_t aep_priority ; struct cos_defcompinfo child_dci ; arcvcap_t extrcv ; cos_defcompinfo_childid_init ( & child_dci , client ) ; thd = sl_thd_aep_alloc_ext ( & child_dci , NULL , idx , 1 , 0 , key , 0 , 0 , & extrcv ) ; assert ( thd ) ; <S2SV_StartBug> aep_priority = sched_param_pack ( SCHEDP_PRIO , CFE_TIME_1HZ_TASK_PRIORITY ) ; <S2SV_EndBug> sl_thd_param_set ( thd , aep_priority ) ; return extrcv ; } | <S2SV_ModStart> ( SCHEDP_PRIO , CFE_INVERT_PRIO - |
4,883 | CWE-000 <S2SV_StartBug> void testtriangle ( m , b , testtri ) <S2SV_EndBug> struct mesh * m ; struct behavior * b ; struct otri * testtri ; # endif { struct otri tri1 , tri2 ; struct osub testsub ; vertex torg , tdest , tapex ; vertex base1 , base2 ; vertex org1 , dest1 , org2 , dest2 ; vertex joinvertex ; REAL dxod , dyod , dxda , dyda , dxao , dyao ; REAL dxod2 , dyod2 , dxda2 , dyda2 , dxao2 , dyao2 ; REAL apexlen , orglen , destlen , minedge ; REAL angle ; REAL area ; REAL dist1 , dist2 ; subseg sptr ; triangle ptr ; org ( * testtri , torg ) ; dest ( * testtri , tdest ) ; apex ( * testtri , tapex ) ; dxod = torg [ 0 ] - tdest [ 0 ] ; dyod = torg [ 1 ] - tdest [ 1 ] ; dxda = tdest [ 0 ] - tapex [ 0 ] ; dyda = tdest [ 1 ] - tapex [ 1 ] ; dxao = tapex [ 0 ] - torg [ 0 ] ; dyao = tapex [ 1 ] - torg [ 1 ] ; dxod2 = dxod * dxod ; dyod2 = dyod * dyod ; dxda2 = dxda * dxda ; dyda2 = dyda * dyda ; dxao2 = dxao * dxao ; dyao2 = dyao * dyao ; apexlen = dxod2 + dyod2 ; orglen = dxda2 + dyda2 ; destlen = dxao2 + dyao2 ; if ( ( apexlen < orglen ) && ( apexlen < destlen ) ) { minedge = apexlen ; angle = dxda * dxao + dyda * dyao ; angle = angle * angle / ( orglen * destlen ) ; base1 = torg ; base2 = tdest ; otricopy ( * testtri , tri1 ) ; } else if ( orglen < destlen ) { minedge = orglen ; angle = dxod * dxao + dyod * dyao ; angle = angle * angle / ( apexlen * destlen ) ; base1 = tdest ; base2 = tapex ; lnext ( * testtri , tri1 ) ; } else { minedge = destlen ; angle = dxod * dxda + dyod * dyda ; angle = angle * angle / ( apexlen * orglen ) ; base1 = tapex ; base2 = torg ; lprev ( * testtri , tri1 ) ; } if ( b -> vararea || b -> fixedarea || b -> usertest ) { area = 0.5 * ( dxod * dyda - dyod * dxda ) ; if ( b -> fixedarea && ( area > b -> maxarea ) ) { enqueuebadtri ( m , b , testtri , minedge , tapex , torg , tdest ) ; return ; } if ( ( b -> vararea ) && ( area > areabound ( * testtri ) ) && ( areabound ( * testtri ) > 0.0 ) ) { enqueuebadtri ( m , b , testtri , minedge , tapex , torg , tdest ) ; return ; } if ( b -> usertest ) { if ( triunsuitable ( torg , tdest , tapex , area ) ) { enqueuebadtri ( m , b , testtri , minedge , tapex , torg , tdest ) ; return ; } } } if ( angle > b -> goodangle ) { if ( ( vertextype ( base1 ) == SEGMENTVERTEX ) && ( vertextype ( base2 ) == SEGMENTVERTEX ) ) { tspivot ( tri1 , testsub ) ; if ( testsub . ss == m -> dummysub ) { otricopy ( tri1 , tri2 ) ; do { oprevself ( tri1 ) ; tspivot ( tri1 , testsub ) ; } while ( testsub . ss == m -> dummysub ) ; segorg ( testsub , org1 ) ; segdest ( testsub , dest1 ) ; do { dnextself ( tri2 ) ; tspivot ( tri2 , testsub ) ; } while ( testsub . ss == m -> dummysub ) ; segorg ( testsub , org2 ) ; segdest ( testsub , dest2 ) ; joinvertex = ( vertex ) NULL ; if ( ( dest1 [ 0 ] == org2 [ 0 ] ) && ( dest1 [ 1 ] == org2 [ 1 ] ) ) { joinvertex = dest1 ; } else if ( ( org1 [ 0 ] == dest2 [ 0 ] ) && ( org1 [ 1 ] == dest2 [ 1 ] ) ) { joinvertex = org1 ; } if ( joinvertex != ( vertex ) NULL ) { dist1 = ( ( base1 [ 0 ] - joinvertex [ 0 ] ) * ( base1 [ 0 ] - joinvertex [ 0 ] ) + ( base1 [ 1 ] - joinvertex [ 1 ] ) * ( base1 [ 1 ] - joinvertex [ 1 ] ) ) ; dist2 = ( ( base2 [ 0 ] - joinvertex [ 0 ] ) * ( base2 [ 0 ] - joinvertex [ 0 ] ) + ( base2 [ 1 ] - joinvertex [ 1 ] ) * ( base2 [ 1 ] - joinvertex [ 1 ] ) ) ; if ( ( dist1 < 1.001 * dist2 ) && ( dist1 > 0.999 * dist2 ) ) { return ; } } } } enqueuebadtri ( m , b , testtri , minedge , tapex , torg , tdest ) ; } } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> void testtriangle ( struct mesh * m , struct behavior * b , struct otri * testtri ) # else |
4,884 | CWE-000 static void pcacheUnpin ( PgHdr * p ) { <S2SV_StartBug> PCache * pCache = p -> pCache ; <S2SV_EndBug> if ( pCache -> bPurgeable ) { if ( p -> pgno == 1 ) { <S2SV_StartBug> pCache -> pPage1 = 0 ; <S2SV_EndBug> } <S2SV_StartBug> sqlite3GlobalConfig . pcache2 . xUnpin ( pCache -> pCache , p -> pPage , 0 ) ; <S2SV_EndBug> } } | <S2SV_ModStart> p ) { if ( p -> <S2SV_ModEnd> pCache -> bPurgeable <S2SV_ModStart> 1 ) { p -> <S2SV_ModStart> . xUnpin ( p -> |
4,885 | CWE-000 static void pinctrl_handle_put_dhcpv6_opts ( struct dp_packet * pkt_in , struct ofputil_packet_in * pin , struct ofpbuf * userdata , struct ofpbuf * continuation OVS_UNUSED ) { static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT ( 1 , 5 ) ; enum ofp_version version = rconn_get_version ( swconn ) ; enum ofputil_protocol proto = ofputil_protocol_from_ofp_version ( version ) ; struct dp_packet * pkt_out_ptr = NULL ; uint32_t success = 0 ; const struct mf_field * f ; enum ofperr ofperr = nx_pull_header ( userdata , NULL , & f , NULL ) ; if ( ofperr ) { VLOG_WARN_RL ( & rl , "bad<S2SV_blank>result<S2SV_blank>OXM<S2SV_blank>(%s)" , ofperr_to_string ( ofperr ) ) ; goto exit ; } ovs_be32 * ofsp = ofpbuf_try_pull ( userdata , sizeof * ofsp ) ; if ( ! ofsp ) { VLOG_WARN_RL ( & rl , "offset<S2SV_blank>not<S2SV_blank>present<S2SV_blank>in<S2SV_blank>the<S2SV_blank>userdata" ) ; goto exit ; } struct mf_subfield dst = { . field = f , . ofs = ntohl ( * ofsp ) , . n_bits = 1 } ; ofperr = mf_check_dst ( & dst , NULL ) ; if ( ofperr ) { VLOG_WARN_RL ( & rl , "bad<S2SV_blank>result<S2SV_blank>bit<S2SV_blank>(%s)" , ofperr_to_string ( ofperr ) ) ; goto exit ; } if ( ! userdata -> size ) { VLOG_WARN_RL ( & rl , "DHCPv6<S2SV_blank>options<S2SV_blank>not<S2SV_blank>present<S2SV_blank>in<S2SV_blank>the<S2SV_blank>userdata" ) ; goto exit ; } struct udp_header * in_udp = dp_packet_l4 ( pkt_in ) ; <S2SV_StartBug> const uint8_t * in_dhcpv6_data = dp_packet_get_udp_payload ( pkt_in ) ; <S2SV_EndBug> uint8_t out_dhcpv6_msg_type ; switch ( * in_dhcpv6_data ) { case DHCPV6_MSG_TYPE_SOLICIT : out_dhcpv6_msg_type = DHCPV6_MSG_TYPE_ADVT ; break ; case DHCPV6_MSG_TYPE_REQUEST : case DHCPV6_MSG_TYPE_CONFIRM : case DHCPV6_MSG_TYPE_DECLINE : out_dhcpv6_msg_type = DHCPV6_MSG_TYPE_REPLY ; break ; default : goto exit ; } in_dhcpv6_data += 4 ; ovs_be32 iaid = 0 ; struct dhcpv6_opt_header const * in_opt_client_id = NULL ; size_t udp_len = ntohs ( in_udp -> udp_len ) ; size_t l4_len = dp_packet_l4_size ( pkt_in ) ; uint8_t * end = ( uint8_t * ) in_udp + MIN ( udp_len , l4_len ) ; while ( in_dhcpv6_data < end ) { struct dhcpv6_opt_header const * in_opt = ( struct dhcpv6_opt_header * ) in_dhcpv6_data ; switch ( ntohs ( in_opt -> code ) ) { case DHCPV6_OPT_IA_NA_CODE : { struct dhcpv6_opt_ia_na * opt_ia_na = ( struct dhcpv6_opt_ia_na * ) in_opt ; iaid = opt_ia_na -> iaid ; break ; } case DHCPV6_OPT_CLIENT_ID_CODE : in_opt_client_id = in_opt ; break ; default : break ; } in_dhcpv6_data += sizeof * in_opt + ntohs ( in_opt -> len ) ; } if ( ! in_opt_client_id ) { VLOG_WARN_RL ( & rl , "DHCPv6<S2SV_blank>option<S2SV_blank>-<S2SV_blank>Client<S2SV_blank>id<S2SV_blank>not<S2SV_blank>present<S2SV_blank>in<S2SV_blank>the<S2SV_blank>" "<S2SV_blank>DHCPv6<S2SV_blank>packet" ) ; goto exit ; } if ( ! iaid ) { VLOG_WARN_RL ( & rl , "DHCPv6<S2SV_blank>option<S2SV_blank>-<S2SV_blank>IA<S2SV_blank>NA<S2SV_blank>not<S2SV_blank>present<S2SV_blank>in<S2SV_blank>the<S2SV_blank>" "<S2SV_blank>DHCPv6<S2SV_blank>packet" ) ; goto exit ; } uint64_t out_ofpacts_dhcpv6_opts_stub [ 256 / 8 ] ; struct ofpbuf out_dhcpv6_opts = OFPBUF_STUB_INITIALIZER ( out_ofpacts_dhcpv6_opts_stub ) ; if ( ! compose_out_dhcpv6_opts ( userdata , & out_dhcpv6_opts , iaid ) ) { VLOG_WARN_RL ( & rl , "Invalid<S2SV_blank>userdata" ) ; goto exit ; } uint16_t new_l4_size = ( UDP_HEADER_LEN + 4 + sizeof * in_opt_client_id + ntohs ( in_opt_client_id -> len ) + out_dhcpv6_opts . size ) ; size_t new_packet_size = pkt_in -> l4_ofs + new_l4_size ; struct dp_packet pkt_out ; dp_packet_init ( & pkt_out , new_packet_size ) ; dp_packet_clear ( & pkt_out ) ; dp_packet_prealloc_tailroom ( & pkt_out , new_packet_size ) ; pkt_out_ptr = & pkt_out ; dp_packet_put ( & pkt_out , dp_packet_pull ( pkt_in , pkt_in -> l4_ofs ) , pkt_in -> l4_ofs ) ; pkt_out . l2_5_ofs = pkt_in -> l2_5_ofs ; pkt_out . l2_pad_size = pkt_in -> l2_pad_size ; pkt_out . l3_ofs = pkt_in -> l3_ofs ; pkt_out . l4_ofs = pkt_in -> l4_ofs ; struct udp_header * out_udp = dp_packet_put ( & pkt_out , dp_packet_pull ( pkt_in , UDP_HEADER_LEN ) , UDP_HEADER_LEN ) ; uint8_t * out_dhcpv6 = dp_packet_put ( & pkt_out , dp_packet_pull ( pkt_in , 4 ) , 4 ) ; * out_dhcpv6 = out_dhcpv6_msg_type ; dp_packet_put ( & pkt_out , in_opt_client_id , sizeof * in_opt_client_id + ntohs ( in_opt_client_id -> len ) ) ; dp_packet_put ( & pkt_out , out_dhcpv6_opts . data , out_dhcpv6_opts . size ) ; out_udp -> udp_len = htons ( new_l4_size ) ; out_udp -> udp_csum = 0 ; struct ovs_16aligned_ip6_hdr * out_ip6 = dp_packet_l3 ( & pkt_out ) ; out_ip6 -> ip6_ctlun . ip6_un1 . ip6_un1_plen = out_udp -> udp_len ; uint32_t csum ; csum = packet_csum_pseudoheader6 ( dp_packet_l3 ( & pkt_out ) ) ; csum = csum_continue ( csum , out_udp , dp_packet_size ( & pkt_out ) - ( ( const unsigned char * ) out_udp - ( const unsigned char * ) dp_packet_eth ( & pkt_out ) ) ) ; out_udp -> udp_csum = csum_finish ( csum ) ; if ( ! out_udp -> udp_csum ) { out_udp -> udp_csum = htons ( 0xffff ) ; } pin -> packet = dp_packet_data ( & pkt_out ) ; pin -> packet_len = dp_packet_size ( & pkt_out ) ; ofpbuf_uninit ( & out_dhcpv6_opts ) ; success = 1 ; exit : if ( ! ofperr ) { union mf_subvalue sv ; sv . u8_val = success ; mf_write_subfield ( & dst , & sv , & pin -> flow_metadata ) ; } queue_msg ( ofputil_encode_resume ( pin , continuation , proto ) ) ; dp_packet_uninit ( pkt_out_ptr ) ; } | <S2SV_ModStart> pkt_in ) ; if ( ! in_udp || ! in_dhcpv6_data ) { VLOG_WARN_RL ( & rl , "truncated<S2SV_blank>dhcpv6<S2SV_blank>packet" ) ; goto exit ; } |
4,886 | CWE-000 static uint16_t * get_pointer_to_address ( uint8_t line , uint8_t column ) { if ( ! VALID_LINE_NUMBER ( line ) || ! VALID_COLUMN_NUMBER ( column ) ) return NULL ; <S2SV_StartBug> return ( uint16_t * ) VIDEO_MEMORY_ADDRESS + 2 * ( column + line * COLS ) ; <S2SV_EndBug> } | <S2SV_ModStart> uint16_t * ) ( <S2SV_ModStart> * COLS ) ) |
4,887 | CWE-000 int lys_check_id ( struct lys_node * node , struct lys_node * parent , struct lys_module * module ) { struct lys_node * start , * stop , * iter ; struct lys_node_grp * grp ; int down , up ; assert ( node ) ; if ( ! parent ) { assert ( module ) ; } else { module = parent -> module ; <S2SV_StartBug> } <S2SV_EndBug> switch ( node -> nodetype ) { case LYS_GROUPING : if ( parent ) { start = * lys_child ( parent , LYS_GROUPING ) ; if ( ! start ) { down = 0 ; start = parent ; } else { down = 1 ; } if ( parent -> nodetype == LYS_EXT ) { up = 0 ; } else { up = 1 ; } } else { down = up = 1 ; start = module -> data ; } if ( up && lys_find_grouping_up ( node -> name , start ) ) { LOGVAL ( LYE_DUPID , LY_VLOG_LYS , node , "grouping" , node -> name ) ; return EXIT_FAILURE ; } if ( down ) { for ( iter = start , stop = NULL ; iter ; iter = iter -> prev ) { if ( ! stop ) { stop = start ; } else if ( iter == stop ) { break ; } if ( ! ( iter -> nodetype & ( LYS_CONTAINER | LYS_CHOICE | LYS_LIST | LYS_GROUPING | LYS_INPUT | LYS_OUTPUT ) ) ) { continue ; } grp = NULL ; while ( ( grp = lys_get_next_grouping ( grp , iter ) ) ) { if ( ly_strequal ( node -> name , grp -> name , 1 ) ) { LOGVAL ( LYE_DUPID , LY_VLOG_LYS , node , "grouping" , node -> name ) ; return EXIT_FAILURE ; } } } } break ; case LYS_LEAF : case LYS_LEAFLIST : case LYS_LIST : case LYS_CONTAINER : case LYS_CHOICE : case LYS_ANYDATA : if ( parent ) { iter = parent ; while ( iter && ( iter -> nodetype & ( LYS_USES | LYS_CASE | LYS_CHOICE | LYS_AUGMENT ) ) ) { if ( iter -> nodetype == LYS_AUGMENT ) { if ( ( ( struct lys_node_augment * ) iter ) -> target ) { iter = ( ( struct lys_node_augment * ) iter ) -> target ; continue ; } break ; } iter = iter -> parent ; } if ( ! iter ) { stop = NULL ; iter = module -> data ; } else if ( iter -> nodetype == LYS_EXT ) { stop = iter ; iter = * lys_child ( iter , node -> nodetype ) ; } else { stop = iter ; iter = iter -> child ; } } else { stop = NULL ; iter = module -> data ; } while ( iter ) { if ( iter -> nodetype & ( LYS_USES | LYS_CASE ) ) { iter = iter -> child ; continue ; } if ( iter -> nodetype & ( LYS_LEAF | LYS_LEAFLIST | LYS_LIST | LYS_CONTAINER | LYS_CHOICE | LYS_ANYDATA ) ) { if ( iter -> module == node -> module && ly_strequal ( iter -> name , node -> name , 1 ) ) { LOGVAL ( LYE_DUPID , LY_VLOG_LYS , node , strnodetype ( node -> nodetype ) , node -> name ) ; return EXIT_FAILURE ; } } if ( iter -> nodetype == LYS_CHOICE ) { iter = iter -> child ; continue ; } if ( ! iter -> next ) { do { if ( iter -> parent == stop ) { iter = stop ; break ; } iter = lys_parent ( iter ) ; if ( iter && iter -> next ) { break ; } } while ( iter != stop ) ; if ( iter == stop ) { break ; } } iter = iter -> next ; } break ; case LYS_CASE : if ( parent ) { start = * lys_child ( parent , LYS_CASE ) ; } else { start = module -> data ; } LY_TREE_FOR ( start , iter ) { if ( ! ( iter -> nodetype & ( LYS_ANYDATA | LYS_CASE | LYS_CONTAINER | LYS_LEAF | LYS_LEAFLIST | LYS_LIST ) ) ) { continue ; } if ( iter -> module == node -> module && ly_strequal ( iter -> name , node -> name , 1 ) ) { LOGVAL ( LYE_DUPID , LY_VLOG_LYS , node , "case" , node -> name ) ; return EXIT_FAILURE ; } } break ; default : break ; } return EXIT_SUCCESS ; } | <S2SV_ModStart> module ; } module = lys_main_module ( module ) ; |
4,888 | CWE-000 static PyObject * <S2SV_StartBug> oled_end_method ( PyObject * self , PyObject * args ) <S2SV_EndBug> { <S2SV_StartBug> if ( ! PyArg_ParseTuple ( args , "" ) ) <S2SV_EndBug> <S2SV_StartBug> return NULL ; <S2SV_EndBug> thread_quit = 1 ; <S2SV_StartBug> pthread_cond_broadcast ( & cond_modified ) ; <S2SV_EndBug> pthread_join ( thread_id , NULL ) ; if ( ! oled_i2c_close ( ) ) return NULL ; Py_RETURN_NONE ; } | <S2SV_ModStart> PyObject * args , PyObject * keywds ) { float timeout = DEFAULT_TIMEOUT ; static char * kwlist [ ] = { "timeout" , NULL } ; <S2SV_ModEnd> if ( ! <S2SV_ModStart> if ( ! PyArg_ParseTupleAndKeywords <S2SV_ModEnd> ( args , <S2SV_ModStart> ( args , keywds , "|f" , kwlist , & timeout <S2SV_ModEnd> ) ) return <S2SV_ModStart> ) return NULL ; if ( ! wait_update ( timeout ) ) return NULL ; pthread_mutex_lock ( & mutex_updating ) <S2SV_ModStart> ( & cond_modified ) ; pthread_mutex_unlock ( & mutex_updating |
4,889 | CWE-000 static int snd_rpi_hifiberry_dacplus_clk_for_rate ( int sample_rate ) { int type ; switch ( sample_rate ) { case 11025 : case 22050 : case 44100 : case 88200 : case 176400 : <S2SV_StartBug> type = HIFIBERRY_DACPRO_CLK44EN ; <S2SV_EndBug> break ; default : type = HIFIBERRY_DACPRO_CLK48EN ; break ; } return type ; } | <S2SV_ModStart> case 176400 : case 352800 : |
4,890 | CWE-000 int vc4_get_tiling_ioctl ( struct drm_device * dev , void * data , struct drm_file * file_priv ) { struct drm_vc4_get_tiling * args = data ; struct drm_gem_object * gem_obj ; struct vc4_bo * bo ; if ( args -> flags != 0 || args -> modifier != 0 ) return - EINVAL ; gem_obj = drm_gem_object_lookup ( file_priv , args -> handle ) ; if ( ! gem_obj ) { <S2SV_StartBug> DRM_ERROR ( "Failed<S2SV_blank>to<S2SV_blank>look<S2SV_blank>up<S2SV_blank>GEM<S2SV_blank>BO<S2SV_blank>%d\\n" , args -> handle ) ; <S2SV_EndBug> return - ENOENT ; } bo = to_vc4_bo ( gem_obj ) ; if ( bo -> t_format ) args -> modifier = DRM_FORMAT_MOD_BROADCOM_VC4_T_TILED ; else args -> modifier = DRM_FORMAT_MOD_NONE ; drm_gem_object_put_unlocked ( gem_obj ) ; return 0 ; } | <S2SV_ModStart> gem_obj ) { DRM_DEBUG <S2SV_ModEnd> ( "Failed<S2SV_blank>to<S2SV_blank>look<S2SV_blank>up<S2SV_blank>GEM<S2SV_blank>BO<S2SV_blank>%d\\n" , |
4,891 | CWE-000 struct tcb_t * thread_dequeue ( struct list_head * queue ) { <S2SV_StartBug> if ( list_empty ( & queue ) ) return NULL ; <S2SV_EndBug> <S2SV_StartBug> list_del ( & queue ) ; <S2SV_EndBug> <S2SV_StartBug> return container_of ( & queue , struct tcb_t , t_sched ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( list_empty ( <S2SV_ModEnd> queue ) ) <S2SV_ModStart> ; list_del ( <S2SV_ModEnd> queue ) ; <S2SV_ModStart> return container_of ( <S2SV_ModEnd> queue , struct |
4,892 | CWE-000 static I_32 checkMethods ( J9CfrClassFile * classfile , U_8 * segment , U_32 vmVersionShifted , U_32 flags ) { J9CfrMethod * method ; U_32 value = 0 ; U_32 maskedValue = 0 ; U_32 errorCode = 0 ; U_32 offset = 0 ; U_32 i ; BOOLEAN nameIndexOK ; U_32 classfileVersion = flags & BCT_MajorClassFileVersionMask ; for ( i = 0 ; i < classfile -> methodsCount ; i ++ ) { method = & ( classfile -> methods [ i ] ) ; nameIndexOK = TRUE ; value = method -> nameIndex ; if ( ( ! value ) || ( value > classfile -> constantPoolCount ) ) { nameIndexOK = FALSE ; } else if ( classfile -> constantPool [ value ] . tag != CFR_CONSTANT_Utf8 ) { nameIndexOK = FALSE ; } value = method -> accessFlags & CFR_METHOD_ACCESS_MASK ; if ( classfileVersion < BCT_Java5MajorVersionShifted ) { value &= ~ CFR_METHOD_ACCESS_NEWJDK5_MASK ; } if ( ( classfileVersion < BCT_Java2MajorVersionShifted ) && ( ( flags & CFR_Xfuture ) == 0 ) ) { value &= ~ CFR_ACC_STRICT ; } if ( nameIndexOK && utf8Equal ( & classfile -> constantPool [ method -> nameIndex ] , "<clinit>" , 8 ) ) { if ( classfileVersion < BCT_Java7MajorVersionShifted ) { method -> accessFlags |= CFR_ACC_STATIC ; } else if ( vmVersionShifted >= BCT_Java9MajorVersionShifted ) { if ( J9_ARE_NO_BITS_SET ( method -> accessFlags , CFR_ACC_STATIC ) ) { errorCode = J9NLS_CFR_ERR_CLINIT_NOT_STATIC__ID ; goto _errorFound ; } } method -> accessFlags &= CFR_CLINIT_METHOD_ACCESS_MASK ; goto _nameCheck ; } if ( nameIndexOK && utf8Equal ( & classfile -> constantPool [ method -> nameIndex ] , "<init>" , 6 ) ) { if ( value & ~ CFR_INIT_METHOD_ACCESS_MASK ) { errorCode = J9NLS_CFR_ERR_INIT_METHOD__ID ; goto _errorFound ; } if ( vmVersionShifted >= BCT_Java9MajorVersionShifted ) { if ( classfile -> accessFlags & CFR_ACC_INTERFACE ) { errorCode = J9NLS_CFR_ERR_INIT_ILLEGAL_IN_INTERFACE__ID ; goto _errorFound ; } } } if ( classfile -> accessFlags & CFR_ACC_INTERFACE ) { if ( classfileVersion < BCT_Java8MajorVersionShifted ) { U_32 mask = CFR_INTERFACE_METHOD_ACCESS_MASK ; if ( ( flags & CFR_Xfuture ) == 0 ) { mask |= ( CFR_ACC_STRICT | CFR_ACC_SYNCHRONIZED ) ; } if ( ( value & ~ mask ) || ( ( value & CFR_INTERFACE_METHOD_ACCESS_REQUIRED ) != CFR_INTERFACE_METHOD_ACCESS_REQUIRED ) ) { errorCode = J9NLS_CFR_ERR_INTERFACE_METHOD__ID ; goto _errorFound ; } } else { const U_32 illegalMask = CFR_ACC_PROTECTED | CFR_ACC_FINAL | CFR_ACC_NATIVE | CFR_ACC_SYNCHRONIZED ; const U_32 publicPrivateMask = CFR_ACC_PUBLIC | CFR_ACC_PRIVATE ; const U_32 maskedValue = value & publicPrivateMask ; BOOLEAN oneOfPublicOrPrivate = ( maskedValue != 0 ) && ( ( ( maskedValue ) & ( ( maskedValue ) - 1 ) ) == 0 ) ; if ( ( 0 != ( value & illegalMask ) ) || ! oneOfPublicOrPrivate ) { errorCode = J9NLS_CFR_ERR_INTERFACE_METHOD_JAVA_8__ID ; goto _errorFound ; } if ( ( CFR_ACC_ABSTRACT == ( value & CFR_ACC_ABSTRACT ) ) && ( 0 != ( value & ~ CFR_ABSTRACT_METHOD_ACCESS_MASK ) ) ) { errorCode = J9NLS_CFR_ERR_INTERFACE_METHOD_JAVA_8__ID ; goto _errorFound ; } } goto _nameCheck ; } if ( value & CFR_ACC_ABSTRACT ) { if ( value & ~ CFR_ABSTRACT_METHOD_ACCESS_MASK ) { errorCode = J9NLS_CFR_ERR_ABSTRACT_METHOD__ID ; goto _errorFound ; } } maskedValue = value & CFR_PUBLIC_PRIVATE_PROTECTED_MASK ; if ( maskedValue & ( maskedValue - 1 ) ) { errorCode = J9NLS_CFR_ERR_ACCESS_CONFLICT_METHOD__ID ; goto _errorFound ; } _nameCheck : offset = 2 ; value = method -> nameIndex ; if ( ! nameIndexOK ) { if ( ( ! value ) || ( value > classfile -> constantPoolCount ) ) { errorCode = J9NLS_CFR_ERR_BAD_INDEX__ID ; goto _errorFound ; } if ( classfile -> constantPool [ value ] . tag != CFR_CONSTANT_Utf8 ) { errorCode = J9NLS_CFR_ERR_BAD_NAME_INDEX__ID ; goto _errorFound ; } } offset = 4 ; value = method -> descriptorIndex ; if ( ( ! value ) || ( value > classfile -> constantPoolCount ) ) { errorCode = J9NLS_CFR_ERR_BAD_INDEX__ID ; goto _errorFound ; } if ( classfile -> constantPool [ value ] . tag != CFR_CONSTANT_Utf8 ) { errorCode = J9NLS_CFR_ERR_BAD_DESCRIPTOR_INDEX__ID ; goto _errorFound ; } if ( checkAttributes ( classfile , method -> attributes , method -> attributesCount , segment , - 1 , OUTSIDE_CODE , flags ) ) { return - 1 ; } if ( method -> codeAttribute ) { if ( method -> codeAttribute -> codeLength > 65535 ) { errorCode = J9NLS_CFR_ERR_CODE_ARRAY_TOO_LARGE__ID ; goto _errorFound ; } if ( J9_ARE_ANY_BITS_SET ( method -> accessFlags , CFR_ACC_NATIVE | CFR_ACC_ABSTRACT ) ) { errorCode = J9NLS_CFR_ERR_CODE_FOR_ABSTRACT_OR_NATIVE__ID ; goto _errorFound ; } } } return 0 ; _errorFound : <S2SV_StartBug> buildError ( ( J9CfrError * ) segment , errorCode , CFR_ThrowClassFormatError , method -> romAddress + offset ) ; <S2SV_EndBug> return - 1 ; } | <S2SV_ModStart> ; _errorFound : printf ( "cfreader<S2SV_blank>classformaterror<S2SV_blank>7" ) ; |
4,893 | CWE-000 void rule_addtag_config ( ) { if ( parser_state . val_stackp > 0 ) { # ifdef RULE_DEBUG printf ( "rule_addtag_config\\n" ) ; # endif internal_entry_t e ; e . i_stackp = 0 ; e . regex_stackp = 0 ; e . lineno = getlineno ( ) ; e . is_precondition = 1 ; e . tag = parser_state . tag ; <S2SV_StartBug> if ( parser_state . mode & mode_enable_type_checks ) { <S2SV_EndBug> internal_entry_t p ; p . i_stackp = 0 ; p . regex_stackp = 0 ; p . lineno = getlineno ( ) ; p . is_precondition = 0 ; p . tag = parser_state . tag ; p . function = fc_tag_quiet ; e . function = fc_tag_has_valid_type ; exe_push ( e ) ; exe_push ( p ) ; } # ifdef RULE_DEBUG printf ( "try<S2SV_blank>to<S2SV_blank>match<S2SV_blank>tagline<S2SV_blank>at<S2SV_blank>line<S2SV_blank>%i\\n" , e . lineno ) ; # endif # ifdef RULE_DEBUG v_printstack ( ) ; i_printstack ( ) ; r_printstack ( ) ; # endif do { values_t val = v_pop ( ) ; # ifdef RULE_DEBUG printf ( "was<S2SV_blank>ist<S2SV_blank>noch<S2SV_blank>auf<S2SV_blank>stacks?\\n" ) ; v_printstack ( ) ; i_printstack ( ) ; r_printstack ( ) ; printf ( "auf<S2SV_blank>exe<S2SV_blank>stack<S2SV_blank>ist<S2SV_blank>nun:\\n" ) ; exe_printstack ( ) ; printf ( "-----\\n" ) ; # endif e . function = fc_dummy ; build_functional_structure ( & e , val ) ; evaluate_req_and_push_exe ( parser_state . req , e ) ; } while ( parser_state . val_stackp > 0 ) ; reset_valuelist ( ) ; parser_state . any_reference = 0 ; # ifdef RULE_DEBUG exe_printstack ( ) ; # endif } } | <S2SV_ModStart> . tag ; <S2SV_ModEnd> # ifdef RULE_DEBUG |
4,894 | CWE-000 <S2SV_StartBug> static void modify_decoding ( const struct pci_dev * pdev , bool map , bool rom_only ) <S2SV_EndBug> { struct vpci_header * header = & pdev -> vpci -> header ; uint8_t slot = PCI_SLOT ( pdev -> devfn ) , func = PCI_FUNC ( pdev -> devfn ) ; <S2SV_StartBug> uint16_t cmd ; <S2SV_EndBug> unsigned int i ; for ( i = 0 ; i < ARRAY_SIZE ( header -> bars ) ; i ++ ) { if ( ! MAPPABLE_BAR ( & header -> bars [ i ] ) ) continue ; if ( rom_only && header -> bars [ i ] . type == VPCI_BAR_ROM ) { unsigned int rom_pos = ( i == PCI_HEADER_NORMAL_NR_BARS ) ? PCI_ROM_ADDRESS : PCI_ROM_ADDRESS1 ; uint32_t val = header -> bars [ i ] . addr | ( map ? PCI_ROM_ADDRESS_ENABLE : 0 ) ; header -> bars [ i ] . enabled = header -> rom_enabled = map ; pci_conf_write32 ( pdev -> seg , pdev -> bus , slot , func , rom_pos , val ) ; return ; } if ( ! rom_only && ( header -> bars [ i ] . type != VPCI_BAR_ROM || header -> rom_enabled ) ) header -> bars [ i ] . enabled = map ; } <S2SV_StartBug> ASSERT ( ! rom_only ) ; <S2SV_EndBug> cmd = pci_conf_read16 ( pdev -> seg , pdev -> bus , slot , func , PCI_COMMAND ) ; cmd &= ~ PCI_COMMAND_MEMORY ; cmd |= map ? PCI_COMMAND_MEMORY : 0 ; pci_conf_write16 ( pdev -> seg , pdev -> bus , slot , func , PCI_COMMAND , cmd ) ; } | <S2SV_ModStart> * pdev , uint16_t cmd , <S2SV_ModEnd> bool rom_only ) <S2SV_ModStart> devfn ) ; bool map = cmd & PCI_COMMAND_MEMORY <S2SV_ModEnd> ; unsigned int <S2SV_ModStart> map ; } if <S2SV_ModEnd> ( ! rom_only <S2SV_ModStart> ! rom_only ) pci_conf_write16 ( pdev -> seg , pdev -> bus , slot , func , PCI_COMMAND , cmd ) ; else ASSERT_UNREACHABLE ( <S2SV_ModEnd> ) ; } |
4,895 | CWE-000 static void multi_2x_serial_pci_class_initfn ( ObjectClass * klass , void * data ) { DeviceClass * dc = DEVICE_CLASS ( klass ) ; PCIDeviceClass * pc = PCI_DEVICE_CLASS ( klass ) ; pc -> realize = multi_serial_pci_realize ; pc -> exit = multi_serial_pci_exit ; pc -> vendor_id = PCI_VENDOR_ID_REDHAT ; pc -> device_id = PCI_DEVICE_ID_REDHAT_SERIAL2 ; pc -> revision = 1 ; pc -> class_id = PCI_CLASS_COMMUNICATION_SERIAL ; dc -> vmsd = & vmstate_pci_multi_serial ; dc -> props = multi_2x_serial_pci_properties ; set_bit ( DEVICE_CATEGORY_INPUT , dc -> categories ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> categories ) ; dc -> user_creatable = false ; |
4,896 | CWE-000 void free_page ( t_page * p ) <S2SV_StartBug> { <S2SV_EndBug> LOCK ; g_current_page = p ; foreach_pages ( delete_page_from_heap ) ; <S2SV_StartBug> UNLOCK ; <S2SV_EndBug> } | <S2SV_ModStart> p ) { DEBUG ( "free<S2SV_blank>page<S2SV_blank>start\\n" ) ; <S2SV_ModStart> delete_page_from_heap ) ; DEBUG ( "free<S2SV_blank>page<S2SV_blank>end\\n" ) ; |
4,897 | CWE-000 void print_all ( frame_frac * ptr ) { if ( get_size ( ptr ) == 0 ) { <S2SV_StartBug> printf ( "Empty<S2SV_blank>queue!" ) ; <S2SV_EndBug> return ; } frame_frac * traversal ; traversal = ptr -> child ; while ( traversal != NULL ) { print_node ( traversal ) ; traversal = traversal -> child ; } printf ( "Printing<S2SV_blank>process<S2SV_blank>end.\\n\\n" ) ; } | <S2SV_ModStart> { printf ( "Empty<S2SV_blank>queue!\\n" <S2SV_ModEnd> ) ; return |
4,898 | CWE-000 char * string_replace_all ( const char * needle , const char * replacement , char * haystack ) { char * start ; <S2SV_StartBug> start = strstr ( haystack , needle ) ; <S2SV_EndBug> while ( start != NULL ) { <S2SV_StartBug> haystack = string_replace ( needle , replacement , haystack ) ; <S2SV_EndBug> <S2SV_StartBug> start = strstr ( haystack , needle ) ; <S2SV_EndBug> } return haystack ; } | <S2SV_ModStart> * start ; int needle_pos ; int needle_len , repl_len ; needle_len = strlen ( needle ) ; if ( needle_len == 0 ) { return haystack ; } <S2SV_ModStart> haystack , needle ) ; repl_len = strlen ( replacement <S2SV_ModStart> NULL ) { needle_pos = start - haystack ; haystack = string_replace_at ( haystack , needle_pos , needle_len , replacement <S2SV_ModEnd> ) ; start <S2SV_ModStart> strstr ( haystack + needle_pos + repl_len |
4,899 | CWE-000 int main ( int argc , char * * argv ) { if ( argc != 4 ) { printf ( "Error:<S2SV_blank>Input<S2SV_blank>an<S2SV_blank>IP,<S2SV_blank>Port,<S2SV_blank>and<S2SV_blank>Filename<S2SV_blank>as<S2SV_blank>arguments\\n" ) ; exit ( EXIT_FAILURE ) ; } char * ip = argv [ 1 ] ; char * filename = argv [ 3 ] ; int port ; sscanf ( argv [ 2 ] , "%d" , & port ) ; int sockfd , n ; char sendline [ 1024 ] ; char recvline [ 1024 ] ; struct sockaddr_in servaddr ; sockfd = socket ( AF_INET , SOCK_STREAM , 0 ) ; if ( sockfd < 0 ) { printf ( "Error<S2SV_blank>opening<S2SV_blank>socket\\n" ) ; exit ( EXIT_FAILURE ) ; } bzero ( & servaddr , sizeof servaddr ) ; servaddr . sin_family = AF_INET ; servaddr . sin_port = htons ( port ) ; inet_pton ( AF_INET , ip , & ( servaddr . sin_addr ) ) ; FILE * zip_file = fopen ( filename , "r" ) ; if ( zip_file == NULL ) { printf ( "Error:<S2SV_blank>File<S2SV_blank>%s<S2SV_blank>not<S2SV_blank>found.\\n" , filename ) ; exit ( 1 ) ; } connect ( sockfd , ( struct sockaddr * ) & servaddr , sizeof ( servaddr ) ) ; printf ( "Starting<S2SV_blank>timer\\n" ) ; clock_t start = clock ( ) , diff ; <S2SV_StartBug> printf ( "Sending<S2SV_blank>file:<S2SV_blank>%s\\n" , filename ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ( write ( sockfd , filename , sizeof ( argv [ 3 ] ) ) ) < 0 ) { <S2SV_EndBug> printf ( "Error:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>send<S2SV_blank>file<S2SV_blank>%s.\\n" , filename ) ; exit ( EXIT_FAILURE ) ; } bzero ( sendline , 1024 ) ; int file_block_size = fread ( sendline , sizeof ( char ) , 1024 , zip_file ) ; int write_sz ; while ( file_block_size > 0 ) { if ( write ( sockfd , sendline , file_block_size ) < 0 ) { printf ( "Error:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>send<S2SV_blank>file<S2SV_blank>%s.\\n" , filename ) ; exit ( EXIT_FAILURE ) ; } printf ( "Sent<S2SV_blank>bytes:<S2SV_blank>%d\\n" , file_block_size ) ; bzero ( sendline , 1024 ) ; if ( file_block_size < 1024 ) { printf ( "File<S2SV_blank>successfully<S2SV_blank>sent:<S2SV_blank>%s<S2SV_blank>\\n" , filename ) ; break ; } file_block_size = fread ( sendline , sizeof ( char ) , 1024 , zip_file ) ; } fclose ( zip_file ) ; file_block_size = read ( sockfd , recvline , 1024 ) ; filename = malloc ( file_block_size ) ; filename = recvline ; <S2SV_StartBug> printf ( "Receiving<S2SV_blank>file:<S2SV_blank>%s\\n" , filename ) ; <S2SV_EndBug> bzero ( filename , 50 ) ; strcpy ( filename , "file.txt" ) ; FILE * file = fopen ( filename , "w" ) ; bzero ( recvline , 1024 ) ; file_block_size = read ( sockfd , recvline , 1024 ) ; write_sz = 0 ; while ( file_block_size > 0 ) { printf ( "Received<S2SV_blank>bytes:<S2SV_blank>%d\\n" , file_block_size ) ; write_sz = fwrite ( recvline , sizeof ( char ) , file_block_size , file ) ; if ( write_sz < file_block_size ) { fprintf ( stderr , "File<S2SV_blank>write<S2SV_blank>failed<S2SV_blank>on<S2SV_blank>server.\\n" ) ; exit ( EXIT_FAILURE ) ; } bzero ( recvline , 1024 ) ; if ( file_block_size < 1024 ) { printf ( "File<S2SV_blank>has<S2SV_blank>been<S2SV_blank>received.\\n" ) ; break ; } file_block_size = read ( sockfd , recvline , 1024 ) ; } fclose ( file ) ; close ( sockfd ) ; diff = clock ( ) ; printf ( "**Time<S2SV_blank>taken:<S2SV_blank>%d<S2SV_blank>milliseconds**\\n" , ( int ) diff ) ; } | <S2SV_ModStart> ; printf ( "Sending<S2SV_blank>file:<S2SV_blank>%d<S2SV_blank>//<S2SV_blank>%s\\n" , ( int ) strlen <S2SV_ModEnd> ( argv [ <S2SV_ModStart> 3 ] ) , filename ) ; if ( ( write ( sockfd , filename , strlen ( argv [ 3 ] ) <S2SV_ModStart> "Receiving<S2SV_blank>file:<S2SV_blank>%s\\n" , filename <S2SV_ModEnd> ) ; FILE |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.