Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
2,300 | CWE-000 static inline int sql_writer_recover_deadlock ( struct sqlclntstate * clnt ) { struct sql_thread * thd = pthread_getspecific ( query_info_key ) ; <S2SV_StartBug> int count = 0 ; <S2SV_EndBug> if ( ! clnt || clnt -> skip_recover_deadlock ) { assert ( bdb_lockref ( ) == 0 ) ; return 1 ; } if ( thd ) { if ( release_locks ( "slow<S2SV_blank>reader" ) != 0 ) { <S2SV_StartBug> assert ( bdb_lockref ( ) == 0 ) ; <S2SV_EndBug> logmsg ( LOGMSG_ERROR , "%s<S2SV_blank>release_locks<S2SV_blank>failed\\n" , __func__ ) ; return 1 ; } <S2SV_StartBug> assert ( bdb_lockref ( ) > 0 ) ; <S2SV_EndBug> return 0 ; } if ( clnt && clnt -> emitting_flag ) { assert ( clnt -> heartbeat_lock == 0 ) ; assert ( clnt -> need_recover_deadlock == 0 ) ; clnt -> heartbeat_lock = 1 ; clnt -> need_recover_deadlock = 1 ; do { struct timespec ts ; count ++ ; clock_gettime ( CLOCK_REALTIME , & ts ) ; ts . tv_sec ++ ; if ( count > 5 ) { logmsg ( LOGMSG_ERROR , "%s<S2SV_blank>wait<S2SV_blank>for<S2SV_blank>sql<S2SV_blank>to<S2SV_blank>release<S2SV_blank>locks,<S2SV_blank>count=%d\\n" , __func__ , count ) ; } pthread_cond_timedwait ( & clnt -> write_cond , & clnt -> write_lock , & ts ) ; assert ( clnt -> emitting_flag ) ; assert ( ! clnt -> done ) ; } while ( clnt -> need_recover_deadlock == 1 ) ; assert ( clnt -> need_recover_deadlock == 0 ) ; clnt -> heartbeat_lock = 0 ; return 0 ; } return 1 ; } | <S2SV_ModStart> count = 0 , ref <S2SV_ModStart> { assert ( ( ref = <S2SV_ModStart> bdb_lockref ( ) ) <S2SV_ModStart> } assert ( ( ref = bdb_lockref ( ) <S2SV_ModEnd> ) > 0 |
2,301 | CWE-000 int db_write_bytes ( vm_offset_t addr , size_t size , char * data ) { jmp_buf jb ; void * prev_jb ; char * dst ; int ret ; prev_jb = kdb_jmpbuf ( jb ) ; ret = setjmp ( jb ) ; if ( ret == 0 ) { dst = ( char * ) addr ; while ( size -- > 0 ) * dst ++ = * data ++ ; <S2SV_StartBug> fence ( ) ; <S2SV_EndBug> cpu_dcache_wb_range ( addr , ( vm_size_t ) size ) ; cpu_icache_sync_range ( addr , ( vm_size_t ) size ) ; } ( void ) kdb_jmpbuf ( prev_jb ) ; return ( ret ) ; } | <S2SV_ModStart> data ++ ; fence_i ( <S2SV_ModEnd> ) ; } |
2,302 | CWE-000 static int pt_insn_at_disabled_event ( const struct pt_event * ev , const struct pt_insn * insn , const struct pt_insn_ext * iext ) { if ( ! ev || ! insn || ! iext ) return - pte_internal ; if ( ev -> ip_suppressed ) { if ( pt_insn_is_far_branch ( insn , iext ) || pt_insn_changes_cpl ( insn , iext ) || pt_insn_changes_cr3 ( insn , iext ) ) return 1 ; } else { switch ( insn -> iclass ) { case ptic_ptwrite : case ptic_other : break ; case ptic_call : case ptic_jump : if ( iext -> variant . branch . is_direct ) { uint64_t ip ; ip = insn -> ip ; ip += insn -> size ; ip += iext -> variant . branch . displacement ; if ( ip != ev -> variant . disabled . ip ) break ; } <S2SV_StartBug> case ptic_return : <S2SV_EndBug> case ptic_far_call : case ptic_far_return : case ptic_far_jump : case ptic_cond_jump : return 1 ; case ptic_error : return - pte_bad_insn ; } } return 0 ; } | <S2SV_ModStart> break ; } fallthrough ; |
2,303 | CWE-000 int bnxt_hwrm_cfa_l2_set_rx_mask ( struct bnxt * bp , struct bnxt_vnic_info * vnic , uint16_t vlan_count , struct bnxt_vlan_table_entry * vlan_table ) { int rc = 0 ; struct hwrm_cfa_l2_set_rx_mask_input req = { . req_type = 0 } ; struct hwrm_cfa_l2_set_rx_mask_output * resp = bp -> hwrm_cmd_resp_addr ; uint32_t mask = 0 ; HWRM_PREP ( req , CFA_L2_SET_RX_MASK ) ; req . vnic_id = rte_cpu_to_le_16 ( vnic -> fw_vnic_id ) ; if ( vnic -> flags & BNXT_VNIC_INFO_BCAST ) mask = HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_BCAST ; if ( vnic -> flags & BNXT_VNIC_INFO_UNTAGGED ) mask |= HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_VLAN_NONVLAN ; if ( vnic -> flags & BNXT_VNIC_INFO_PROMISC ) mask |= HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_PROMISCUOUS ; if ( vnic -> flags & BNXT_VNIC_INFO_ALLMULTI ) mask |= HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_ALL_MCAST ; if ( vnic -> flags & BNXT_VNIC_INFO_MCAST ) mask |= HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_MCAST ; if ( vnic -> mc_addr_cnt ) { mask |= HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_MCAST ; req . num_mc_entries = rte_cpu_to_le_32 ( vnic -> mc_addr_cnt ) ; req . mc_tbl_addr = rte_cpu_to_le_64 ( vnic -> mc_list_dma_addr ) ; } if ( vlan_table ) { if ( ! ( mask & HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_VLAN_NONVLAN ) ) mask |= HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_VLANONLY ; req . vlan_tag_tbl_addr = rte_cpu_to_le_64 ( rte_mem_virt2phy ( vlan_table ) ) ; req . num_vlan_tags = rte_cpu_to_le_32 ( ( uint32_t ) vlan_count ) ; } <S2SV_StartBug> req . mask = rte_cpu_to_le_32 ( HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_BCAST | <S2SV_EndBug> mask ) ; rc = bnxt_hwrm_send_message ( bp , & req , sizeof ( req ) ) ; HWRM_CHECK_RESULT ( ) ; HWRM_UNLOCK ( ) ; return rc ; } | <S2SV_ModStart> = rte_cpu_to_le_32 ( <S2SV_ModEnd> mask ) ; |
2,304 | CWE-000 static PyObject * get_fpu_mode ( PyObject * self , PyObject * args ) { if ( ! PyArg_ParseTuple ( args , "" ) ) { return NULL ; } # if defined ( _MSC_VER ) { unsigned int result = 0 ; result = _controlfp ( 0 , 0 ) ; return PyLong_FromLongLong ( result ) ; } # elif defined ( __GNUC__ ) && ( defined ( __x86_64__ ) || defined ( __i386__ ) ) { unsigned short cw = 0 ; __asm__ ( "fstcw<S2SV_blank>%w0" : "=m" ( cw ) ) ; return PyLong_FromLongLong ( cw ) ; } # else <S2SV_StartBug> return Py_RETURN_NONE ; <S2SV_EndBug> # endif } | <S2SV_ModStart> } # else <S2SV_ModEnd> Py_RETURN_NONE ; # |
2,305 | CWE-000 char * DS_StrToChar ( const DS_String * string ) { assert ( string ) ; assert ( string -> buf ) ; <S2SV_StartBug> char * cstr = ( char * ) calloc ( string -> len , sizeof ( char ) ) ; <S2SV_EndBug> int i ; for ( i = 0 ; i < ( int ) string -> len ; ++ i ) cstr [ i ] = string -> buf [ i ] ; <S2SV_StartBug> return cstr ; <S2SV_EndBug> } | <S2SV_ModStart> string -> len + 1 <S2SV_ModStart> i ] ; cstr [ string -> len ] = '\\0' ; |
2,306 | CWE-000 static int __chroot_open ( struct shim_dentry * dent , const char * uri , int len , int flags , mode_t mode , struct shim_handle * hdl , struct shim_file_data * data ) { int ret = 0 ; if ( ! uri ) { uri = qstrgetstr ( & data -> host_uri ) ; len = data -> host_uri . len ; } int version = atomic_read ( & data -> version ) ; int oldmode = flags & O_ACCMODE ; int accmode = oldmode ; int creat = flags & PAL_CREAT_MASK ; int option = flags & PAL_OPTION_MASK ; if ( ( data -> type == FILE_REGULAR || data -> type == FILE_UNKNOWN ) && accmode == O_WRONLY ) accmode = O_RDWR ; PAL_HANDLE palhdl ; if ( hdl && hdl -> pal_handle ) { palhdl = hdl -> pal_handle ; } else { <S2SV_StartBug> palhdl = DkStreamOpen ( uri , accmode , mode , creat , option ) ; <S2SV_EndBug> if ( ! palhdl ) { if ( PAL_NATIVE_ERRNO == PAL_ERROR_DENIED && accmode != oldmode ) palhdl = DkStreamOpen ( uri , oldmode , mode , creat , option ) ; if ( ! palhdl ) return - PAL_ERRNO ; } } if ( ! data -> queried ) { lock ( data -> lock ) ; ret = __query_attr ( dent , data , palhdl ) ; unlock ( data -> lock ) ; } if ( ! hdl ) { DkObjectClose ( palhdl ) ; return 0 ; } hdl -> pal_handle = palhdl ; hdl -> info . file . type = data -> type ; hdl -> info . file . version = version ; hdl -> info . file . size = atomic_read ( & data -> size ) ; hdl -> info . file . data = data ; return ret ; } | <S2SV_ModStart> } else { debug ( "open<S2SV_blank>file:<S2SV_blank>%s\\n" , uri ) ; |
2,307 | CWE-000 char * ce_rune_string_to_char_string ( const CeRune_t * int_str ) { size_t len = 1 ; const int * int_itr = int_str ; while ( * int_itr ) { if ( isprint ( * int_itr ) ) { len ++ ; } else { switch ( * int_itr ) { default : if ( * int_itr >= 1 && * int_itr <= 31 ) { len += 3 ; } else { len ++ ; } break ; case KEY_BACKSPACE : case KEY_ESCAPE : case KEY_ENTER : case CE_TAB : case KEY_UP : case KEY_DOWN : case KEY_LEFT : case KEY_RIGHT : case '\\\\' : len += 2 ; break ; <S2SV_StartBug> } <S2SV_EndBug> } int_itr ++ ; } char * char_str = malloc ( len ) ; if ( ! char_str ) return NULL ; char * char_itr = char_str ; int_itr = int_str ; while ( * int_itr ) { if ( isprint ( * int_itr ) ) { * char_itr = * int_itr ; char_itr ++ ; } else { switch ( * int_itr ) { default : if ( * int_itr >= 1 && * int_itr <= 26 ) { * char_itr = '\\\\' ; char_itr ++ ; * char_itr = '^' ; char_itr ++ ; * char_itr = 'a' + ( * int_itr - 1 ) ; char_itr ++ ; } else if ( * int_itr == 27 ) { * char_itr = '\\\\' ; char_itr ++ ; * char_itr = '^' ; char_itr ++ ; * char_itr = '[' ; char_itr ++ ; } else if ( * int_itr == 28 ) { * char_itr = '\\\\' ; char_itr ++ ; * char_itr = '^' ; char_itr ++ ; * char_itr = '\\\\' ; char_itr ++ ; } else if ( * int_itr == 29 ) { * char_itr = '\\\\' ; char_itr ++ ; * char_itr = '^' ; char_itr ++ ; * char_itr = ']' ; char_itr ++ ; } else if ( * int_itr == 30 ) { * char_itr = '\\\\' ; char_itr ++ ; * char_itr = '^' ; char_itr ++ ; * char_itr = '^' ; char_itr ++ ; } else if ( * int_itr == 31 ) { * char_itr = '\\\\' ; char_itr ++ ; * char_itr = '^' ; char_itr ++ ; * char_itr = '_' ; char_itr ++ ; } else { * char_itr = '~' ; char_itr ++ ; } break ; case KEY_BACKSPACE : * char_itr = '\\\\' ; char_itr ++ ; * char_itr = 'b' ; char_itr ++ ; break ; case KEY_ESCAPE : * char_itr = '\\\\' ; char_itr ++ ; * char_itr = 'e' ; char_itr ++ ; break ; case KEY_ENTER : * char_itr = '\\\\' ; char_itr ++ ; * char_itr = 'r' ; char_itr ++ ; break ; case CE_TAB : * char_itr = '\\\\' ; char_itr ++ ; * char_itr = 't' ; char_itr ++ ; break ; case KEY_UP : * char_itr = '\\\\' ; char_itr ++ ; * char_itr = 'u' ; char_itr ++ ; break ; case KEY_DOWN : * char_itr = '\\\\' ; char_itr ++ ; * char_itr = 'd' ; char_itr ++ ; break ; case KEY_LEFT : * char_itr = '\\\\' ; char_itr ++ ; * char_itr = 'l' ; char_itr ++ ; break ; case KEY_RIGHT : * char_itr = '\\\\' ; char_itr ++ ; <S2SV_StartBug> * char_itr = 'i' ; char_itr ++ ; <S2SV_EndBug> break ; case '\\\\' : * char_itr = '\\\\' ; char_itr ++ ; * char_itr = '\\\\' ; char_itr ++ ; break ; } } int_itr ++ ; } char_str [ len - 1 ] = 0 ; return char_str ; } | <S2SV_ModStart> ; break ; case KEY_REDO : len += 3 ; break ; <S2SV_ModStart> char_itr = 'i' ; char_itr ++ ; break ; case KEY_REDO : * char_itr = '\\\\' ; char_itr ++ ; * char_itr = '^' ; char_itr ++ ; * char_itr = 'r' |
2,308 | CWE-000 int main ( int ac , char * * av ) { if ( ac != 2 ) { fprintf ( stderr , "usage:<S2SV_blank>%s<S2SV_blank><filename>\\n" , av [ 0 ] ) ; exit ( 1 ) ; } unsigned long binary , dyld ; if ( is_sierra ( ) ) { <S2SV_StartBug> if ( find_macho ( EXECUTABLE_BASE_ADDR , & binary ) ) return 1 ; <S2SV_EndBug> <S2SV_StartBug> if ( find_macho ( binary + 0x1000 , & dyld ) ) return 1 ; <S2SV_EndBug> } else { <S2SV_StartBug> if ( find_macho ( DYLD_BASE , & dyld ) ) return 1 ; <S2SV_EndBug> } return load_and_exec ( av [ 1 ] , dyld ) ; } | <S2SV_ModStart> , & binary , 0x1000 , 0 <S2SV_ModStart> , & dyld , 0x1000 , 0 <S2SV_ModStart> , & dyld , 0x1000 , 0 |
2,309 | CWE-000 static void msm_actuator_parse_i2c_params ( struct msm_actuator_ctrl_t * a_ctrl , int16_t next_lens_position , uint32_t hw_params , uint16_t delay ) { struct msm_actuator_reg_params_t * write_arr = NULL ; uint32_t hw_dword = hw_params ; uint16_t i2c_byte1 = 0 , i2c_byte2 = 0 ; uint16_t value = 0 ; uint32_t size = 0 , i = 0 ; struct msm_camera_i2c_reg_array * i2c_tbl = NULL ; CDBG ( "Enter\\n" ) ; if ( a_ctrl == NULL ) { pr_err ( "failed.<S2SV_blank>actuator<S2SV_blank>ctrl<S2SV_blank>is<S2SV_blank>NULL" ) ; return ; } size = a_ctrl -> reg_tbl_size ; write_arr = a_ctrl -> reg_tbl ; i2c_tbl = a_ctrl -> i2c_reg_tbl ; for ( i = 0 ; i < size ; i ++ ) { <S2SV_StartBug> if ( ( a_ctrl -> total_steps + 1 ) < ( a_ctrl -> i2c_tbl_index ) ) <S2SV_EndBug> break ; if ( write_arr [ i ] . reg_write_type == MSM_ACTUATOR_WRITE_DAC ) { value = ( next_lens_position << write_arr [ i ] . data_shift ) | ( ( hw_dword & write_arr [ i ] . hw_mask ) >> write_arr [ i ] . hw_shift ) ; if ( write_arr [ i ] . reg_addr != 0xFFFF ) { if ( ! strcmp ( a_ctrl -> pdev -> name , "a0c000.qcom,cci:qcom,actuator@0" ) ) { i2c_tbl [ a_ctrl -> i2c_tbl_index ] . reg_addr = write_arr [ i ] . reg_addr ; i2c_tbl [ a_ctrl -> i2c_tbl_index ] . reg_data = 0x90 ; i2c_tbl [ a_ctrl -> i2c_tbl_index ] . delay = 0 ; a_ctrl -> i2c_tbl_index ++ ; i ++ ; i2c_tbl [ a_ctrl -> i2c_tbl_index ] . reg_addr = write_arr [ i ] . reg_addr ; i2c_tbl [ a_ctrl -> i2c_tbl_index ] . reg_data = 0x00 ; i2c_tbl [ a_ctrl -> i2c_tbl_index ] . delay = 0 ; a_ctrl -> i2c_tbl_index ++ ; i ++ ; i2c_tbl [ a_ctrl -> i2c_tbl_index ] . reg_addr = write_arr [ i ] . reg_addr ; i2c_tbl [ a_ctrl -> i2c_tbl_index ] . reg_data = ( value & 0xFF00 ) >> 8 ; i2c_tbl [ a_ctrl -> i2c_tbl_index ] . delay = 0 ; a_ctrl -> i2c_tbl_index ++ ; i ++ ; i2c_byte1 = write_arr [ i ] . reg_addr ; i2c_byte2 = ( value & 0xFF ) ; } else { i2c_byte1 = write_arr [ i ] . reg_addr ; i2c_byte2 = value ; if ( size != ( i + 1 ) ) { i2c_byte2 = value & 0xFF ; CDBG ( "byte1:0x%x,<S2SV_blank>byte2:0x%x\\n" , i2c_byte1 , i2c_byte2 ) ; <S2SV_StartBug> i2c_tbl [ a_ctrl -> i2c_tbl_index ] . <S2SV_EndBug> reg_addr = i2c_byte1 ; i2c_tbl [ a_ctrl -> i2c_tbl_index ] . reg_data = i2c_byte2 ; i2c_tbl [ a_ctrl -> i2c_tbl_index ] . delay = 0 ; a_ctrl -> i2c_tbl_index ++ ; i ++ ; i2c_byte1 = write_arr [ i ] . reg_addr ; i2c_byte2 = ( value & 0xFF00 ) >> 8 ; } } } else { i2c_byte1 = ( value & 0xFF00 ) >> 8 ; i2c_byte2 = value & 0xFF ; } } else { i2c_byte1 = write_arr [ i ] . reg_addr ; i2c_byte2 = ( hw_dword & write_arr [ i ] . hw_mask ) >> write_arr [ i ] . hw_shift ; } <S2SV_StartBug> CDBG ( "i2c_byte1:0x%x,<S2SV_blank>i2c_byte2:0x%x\\n" , i2c_byte1 , i2c_byte2 ) ; <S2SV_EndBug> i2c_tbl [ a_ctrl -> i2c_tbl_index ] . reg_addr = i2c_byte1 ; i2c_tbl [ a_ctrl -> i2c_tbl_index ] . reg_data = i2c_byte2 ; i2c_tbl [ a_ctrl -> i2c_tbl_index ] . delay = delay ; a_ctrl -> i2c_tbl_index ++ ; } CDBG ( "Exit\\n" ) ; } | <S2SV_ModStart> { if ( <S2SV_ModEnd> write_arr [ i <S2SV_ModStart> i2c_byte2 ) ; if ( a_ctrl -> i2c_tbl_index > a_ctrl -> total_steps ) { pr_err ( "failed:i2c<S2SV_blank>table<S2SV_blank>index<S2SV_blank>out<S2SV_blank>of<S2SV_blank>bound\\n" ) ; break ; } <S2SV_ModStart> hw_shift ; } if ( a_ctrl -> i2c_tbl_index > a_ctrl -> total_steps ) { pr_err ( "failed:<S2SV_blank>i2c<S2SV_blank>table<S2SV_blank>index<S2SV_blank>out<S2SV_blank>of<S2SV_blank>bound\\n" ) ; break ; } |
2,310 | CWE-000 static Res cbsInsert ( Range rangeReturn , Land land , Range range ) { CBS cbs ; Bool b ; Res res ; Addr base , limit , newBase , newLimit ; Tree leftSplay , rightSplay ; Node leftBlock , rightBlock ; Bool leftMerge , rightMerge ; Size oldSize ; AVER ( rangeReturn != NULL ) ; AVERT ( Land , land ) ; AVERT ( Range , range ) ; AVER ( RangeIsAligned ( range , LandAlignment ( land ) ) ) ; cbs = cbsOfLand ( land ) ; base = RangeBase ( range ) ; limit = RangeLimit ( range ) ; METER_ACC ( cbs -> treeSearch , cbs -> treeSize ) ; b = SplayTreeNeighbours ( & leftSplay , & rightSplay , cbsSplay ( cbs ) , NodeKeyOfBaseVar ( base ) ) ; if ( ! b ) { res = ResFAIL ; goto fail ; } if ( leftSplay == TreeEMPTY ) { leftBlock = NULL ; leftMerge = FALSE ; } else { leftBlock = NodeOfTree ( leftSplay ) ; AVER ( NodeLimit ( leftBlock ) <= base ) ; leftMerge = NodeLimit ( leftBlock ) == base ; } if ( rightSplay == TreeEMPTY ) { rightBlock = NULL ; rightMerge = FALSE ; } else { rightBlock = NodeOfTree ( rightSplay ) ; <S2SV_StartBug> if ( rightBlock != NULL && limit > NodeLimit ( rightBlock ) ) { <S2SV_EndBug> res = ResFAIL ; goto fail ; } rightMerge = NodeBase ( rightBlock ) == limit ; } newBase = leftMerge ? NodeBase ( leftBlock ) : base ; newLimit = rightMerge ? NodeLimit ( rightBlock ) : limit ; if ( leftMerge && rightMerge ) { Size oldLeftSize = NodeSize ( leftBlock ) ; Addr rightLimit = NodeLimit ( rightBlock ) ; cbsBlockDelete ( cbs , rightBlock ) ; NodeSetLimit ( leftBlock , rightLimit ) ; cbsBlockGrew ( cbs , leftBlock , oldLeftSize ) ; } else if ( leftMerge ) { oldSize = NodeSize ( leftBlock ) ; NodeSetLimit ( leftBlock , limit ) ; cbsBlockGrew ( cbs , leftBlock , oldSize ) ; } else if ( rightMerge ) { oldSize = NodeSize ( rightBlock ) ; NodeSetBase ( rightBlock , base ) ; cbsBlockGrew ( cbs , rightBlock , oldSize ) ; } else { Node block ; res = cbsBlockAlloc ( & block , cbs , range ) ; if ( res != ResOK ) goto fail ; cbsBlockInsert ( cbs , block ) ; } AVER ( newBase <= base ) ; AVER ( newLimit >= limit ) ; RangeInit ( rangeReturn , newBase , newLimit ) ; return ResOK ; fail : AVER ( res != ResOK ) ; return res ; } | <S2SV_ModStart> && limit > NodeBase <S2SV_ModEnd> ( rightBlock ) |
2,311 | CWE-000 static void read_remotes_file ( struct remote * remote ) { struct strbuf buf = STRBUF_INIT ; <S2SV_StartBug> FILE * f = fopen ( git_path ( "remotes/%s" , remote -> name ) , "r" ) ; <S2SV_EndBug> if ( ! f ) return ; remote -> configured_in_repo = 1 ; remote -> origin = REMOTE_REMOTES ; while ( strbuf_getline ( & buf , f ) != EOF ) { const char * v ; strbuf_rtrim ( & buf ) ; if ( skip_prefix ( buf . buf , "URL:" , & v ) ) add_url_alias ( remote , xstrdup ( skip_spaces ( v ) ) ) ; else if ( skip_prefix ( buf . buf , "Push:" , & v ) ) add_push_refspec ( remote , xstrdup ( skip_spaces ( v ) ) ) ; else if ( skip_prefix ( buf . buf , "Pull:" , & v ) ) add_fetch_refspec ( remote , xstrdup ( skip_spaces ( v ) ) ) ; } strbuf_release ( & buf ) ; fclose ( f ) ; } | <S2SV_ModStart> * f = fopen_or_warn <S2SV_ModEnd> ( git_path ( |
2,312 | CWE-000 void icsp_begin_programming ( ) { <S2SV_StartBug> icsp_write ( 0x08 , 6 ) ; <S2SV_EndBug> _delay_ms ( T_PINT ) ; } | <S2SV_ModStart> { icsp_write ( 0x08u <S2SV_ModEnd> , 6 ) |
2,313 | CWE-000 cpl_table * cr2res_demod ( const cpl_frameset * fs1 , const cpl_frameset * fs2 , cpl_table * trace_wave ) { cpl_image * sum1 ; cpl_image * sum2 ; cpl_vector * trace_b_angle_1 ; cpl_vector * trace_a_angle_1 ; cpl_vector * trace_b_angle_2 ; cpl_vector * trace_a_angle_2 ; cpl_size order ; int nb_orders ; int * orders = cr2res_trace_get_order_numbers ( trace_wave , & nb_orders ) ; cpl_vector * sx ; cpl_vector * si ; cpl_vector * sn ; int res = 0 ; cpl_table * stokes = cpl_table_new ( CR2RES_DETECTOR_SIZE ) ; char column_name [ 10 ] ; int chip = 1 ; cr2res_pol_load_images ( fs1 , fs2 , chip , & sum1 , & sum2 ) ; for ( int i = 0 ; i < nb_orders ; i ++ ) { order = orders [ i ] ; res = cr2res_pol_demod_extract ( sum1 , sum2 , trace_wave , order , & trace_a_angle_1 , & trace_b_angle_1 , & trace_a_angle_2 , & trace_b_angle_2 ) ; if ( res == - 1 ) { sx = cpl_vector_new ( CR2RES_DETECTOR_SIZE ) ; <S2SV_StartBug> si = cpl_vector_new ( CR2RES_DETECTOR_SIZE ) ; <S2SV_EndBug> <S2SV_StartBug> sn = cpl_vector_new ( CR2RES_DETECTOR_SIZE ) ; <S2SV_EndBug> } else { cr2res_pol_demod_order ( trace_a_angle_1 , trace_b_angle_1 , trace_a_angle_2 , trace_b_angle_2 , & sx , & si , & sn ) ; cpl_vector_delete ( trace_a_angle_1 ) ; cpl_vector_delete ( trace_b_angle_1 ) ; cpl_vector_delete ( trace_a_angle_2 ) ; cpl_vector_delete ( trace_b_angle_2 ) ; } sprintf ( column_name , "POL_X_%i" , order ) ; cpl_table_wrap_double ( stokes , cpl_vector_get_data ( sx ) , column_name ) ; cpl_vector_delete ( sx ) ; sprintf ( column_name , "POL_I_%d" , order ) ; cpl_table_wrap_double ( stokes , cpl_vector_get_data ( si ) , column_name ) ; cpl_vector_delete ( si ) ; sprintf ( column_name , "POL_N_%d" , order ) ; cpl_table_wrap_double ( stokes , cpl_vector_get_data ( sn ) , column_name ) ; cpl_vector_delete ( sn ) ; } cpl_image_delete ( sum1 ) ; cpl_image_delete ( sum2 ) ; return stokes ; } | <S2SV_ModStart> CR2RES_DETECTOR_SIZE ) ; cpl_vector_fill ( sx , 0. ) ; <S2SV_ModStart> CR2RES_DETECTOR_SIZE ) ; cpl_vector_fill ( si , 0. ) ; <S2SV_ModStart> cpl_vector_new ( CR2RES_DETECTOR_SIZE ) ; cpl_vector_fill ( sn , 0. |
2,314 | CWE-000 void executeStep ( CPU_p cpu , DEBUG_WIN_p win ) { cpu -> ebuff . op = cpu -> dbuff . op ; cpu -> ebuff . dr = cpu -> dbuff . dr ; cpu -> ebuff . pc = cpu -> dbuff . pc ; cpu -> alu_a = cpu -> dbuff . opn1 ; cpu -> alu_b = cpu -> dbuff . opn2 ; switch ( cpu -> ebuff . op ) { case ADD : cpu -> alu_r = cpu -> alu_a + cpu -> alu_b ; cpu -> ebuff . result = cpu -> alu_r ; break ; case AND : cpu -> alu_r = cpu -> alu_a & cpu -> alu_b ; cpu -> ebuff . result = cpu -> alu_r ; break ; case NOT : <S2SV_StartBug> cpu -> alu_r = ~ cpu -> alu_a ; <S2SV_EndBug> case BR : if ( cpu -> mbuff . pc == NOP ) { cpu -> stalls [ P_EX ] ++ ; cpu -> ebuff . op = NOP ; cpu -> ebuff . dr = NOP ; cpu -> ebuff . result = NOP ; cpu -> ebuff . pc = NOP ; break ; } if ( checkBEN ( cpu ) ) { cpu -> ebuff . result = cpu -> dbuff . pc + cpu -> dbuff . opn2 ; cpu -> pc = cpu -> ebuff . result ; flushPipeline ( cpu ) ; } break ; case JSR : case JMP : cpu -> ebuff . result = cpu -> dbuff . pc + cpu -> dbuff . opn2 ; cpu -> pc = cpu -> ebuff . result ; flushPipeline ( cpu ) ; <S2SV_StartBug> case ST : <S2SV_EndBug> case LD : case LEA : cpu -> ebuff . result = cpu -> dbuff . pc + cpu -> dbuff . opn1 ; break ; case LDR : case STR : cpu -> ebuff . result = cpu -> dbuff . opn1 + cpu -> dbuff . opn2 ; <S2SV_StartBug> case TRAP : <S2SV_EndBug> if ( trap ( cpu , win ) ) { return ; } <S2SV_StartBug> case RSV : <S2SV_EndBug> cpu -> ebuff . result = cpu -> dbuff . opn1 ; cpu -> ebuff . imb = cpu -> dbuff . imb ; break ; } } | <S2SV_ModStart> cpu -> alu_a ; break <S2SV_ModStart> cpu ) ; break ; <S2SV_ModStart> . opn2 ; break ; <S2SV_ModStart> return ; } break ; |
2,315 | CWE-000 static int make_ydt15_entry ( int p1 , int p2 , int16_t * ydt ) # endif { int lo , hi ; lo = ydt [ p1 ] ; lo += ( lo * 32 ) + ( lo * 1024 ) ; hi = ydt [ p2 ] ; hi += ( hi * 32 ) + ( hi * 1024 ) ; <S2SV_StartBug> return ( lo + ( hi * ( 1 << 16 ) ) ) * 2 ; <S2SV_EndBug> } | <S2SV_ModStart> hi * ( 1U <S2SV_ModEnd> << 16 ) |
2,316 | CWE-000 void eof_log ( const char * text , int level ) { <S2SV_StartBug> if ( text && eof_log_fp && ( eof_log_level & 1 ) && ( eof_log_level >= level ) ) <S2SV_EndBug> { if ( fprintf ( eof_log_fp , "%03u:<S2SV_blank>%s\\n" , eof_log_id , text ) > 0 ) { ( void ) fflush ( eof_log_fp ) ; } } } | <S2SV_ModStart> text && eof_log_fp <S2SV_ModEnd> && ( eof_log_level |
2,317 | CWE-000 static inline struct page * __rmqueue_fallback ( struct zone * zone , int order , int start_migratetype ) { struct free_area * area ; int current_order ; struct page * page ; int migratetype , new_type , i ; for ( current_order = MAX_ORDER - 1 ; current_order >= order ; -- current_order ) { for ( i = 0 ; ; i ++ ) { migratetype = fallbacks [ start_migratetype ] [ i ] ; if ( migratetype == MIGRATE_RESERVE ) break ; area = & ( zone -> free_area [ current_order ] ) ; if ( list_empty ( & area -> free_list [ migratetype ] ) ) continue ; page = list_entry ( area -> free_list [ migratetype ] . next , struct page , lru ) ; area -> nr_free -- ; new_type = try_to_steal_freepages ( zone , page , start_migratetype , migratetype ) ; list_del ( & page -> lru ) ; rmv_page_order ( page ) ; expand ( zone , page , order , current_order , area , new_type ) ; set_freepage_migratetype ( page , new_type ) ; trace_mm_page_alloc_extfrag ( page , order , current_order , <S2SV_StartBug> start_migratetype , migratetype , new_type ) ; <S2SV_EndBug> return page ; } } return NULL ; } | <S2SV_ModStart> start_migratetype , migratetype <S2SV_ModEnd> ) ; return |
2,318 | CWE-000 int handle_random_icmp ( FPING_ICMPHDR * p , struct sockaddr * addr , socklen_t addr_len ) { FPING_ICMPHDR * sent_icmp ; unsigned char * c ; HOST_ENTRY * h ; SEQMAP_VALUE * seqmap_value ; char addr_ascii [ INET6_ADDRSTRLEN ] ; unsigned short icmp_type ; unsigned short icmp_code ; unsigned short sent_icmp_type ; unsigned short sent_icmp_seq ; unsigned short sent_icmp_id ; getnameinfo ( ( struct sockaddr * ) addr , addr_len , addr_ascii , INET6_ADDRSTRLEN , NULL , 0 , NI_NUMERICHOST ) ; c = ( unsigned char * ) p ; sent_icmp = ( FPING_ICMPHDR * ) ( c + 28 ) ; # ifndef IPV6 icmp_type = p -> icmp_type ; icmp_code = p -> icmp_code ; sent_icmp_type = sent_icmp -> icmp_type ; sent_icmp_seq = sent_icmp -> icmp_seq ; sent_icmp_id = sent_icmp -> icmp_id ; # else icmp_type = p -> icmp6_type ; icmp_code = p -> icmp6_code ; sent_icmp_type = sent_icmp -> icmp6_type ; sent_icmp_seq = sent_icmp -> icmp6_seq ; sent_icmp_id = sent_icmp -> icmp6_id ; # endif switch ( icmp_type ) { case ICMP_UNREACH : seqmap_value = seqmap_fetch ( ntohs ( sent_icmp_seq ) , & current_time ) ; if ( ( sent_icmp_type == ICMP_ECHO ) && ( ntohs ( sent_icmp_id ) == ident ) && ( seqmap_value != NULL ) ) { h = table [ ntohs ( sent_icmp_seq ) % num_hosts ] ; if ( icmp_code > ICMP_UNREACH_MAXTYPE ) { print_warning ( "ICMP<S2SV_blank>Unreachable<S2SV_blank>(Invalid<S2SV_blank>Code)<S2SV_blank>from<S2SV_blank>%s<S2SV_blank>for<S2SV_blank>ICMP<S2SV_blank>Echo<S2SV_blank>sent<S2SV_blank>to<S2SV_blank>%s" , addr_ascii , h -> host ) ; } else { print_warning ( "%s<S2SV_blank>from<S2SV_blank>%s<S2SV_blank>for<S2SV_blank>ICMP<S2SV_blank>Echo<S2SV_blank>sent<S2SV_blank>to<S2SV_blank>%s" , icmp_unreach_str [ icmp_code ] , addr_ascii , h -> host ) ; } if ( inet_addr ( h -> host ) == INADDR_NONE ) print_warning ( "<S2SV_blank>(%s)" , addr_ascii ) ; print_warning ( "\\n" ) ; } return 1 ; case ICMP_SOURCEQUENCH : case ICMP_REDIRECT : case ICMP_TIMXCEED : case ICMP_PARAMPROB : seqmap_value = seqmap_fetch ( ntohs ( sent_icmp_seq ) , & current_time ) ; if ( ( sent_icmp_type == ICMP_ECHO ) && ( ntohs ( sent_icmp_id ) == ident ) && ( seqmap_value != NULL ) ) { h = table [ ntohs ( sent_icmp_seq ) % num_hosts ] ; if ( icmp_type <= ICMP_TYPE_STR_MAX ) { <S2SV_StartBug> fprintf ( stderr , "%s<S2SV_blank>from<S2SV_blank>%s<S2SV_blank>for<S2SV_blank>ICMP<S2SV_blank>Echo<S2SV_blank>sent<S2SV_blank>to<S2SV_blank>%s" , <S2SV_EndBug> icmp_type_str [ icmp_type ] , addr_ascii , h -> host ) ; } else { <S2SV_StartBug> fprintf ( stderr , "ICMP<S2SV_blank>%d<S2SV_blank>from<S2SV_blank>%s<S2SV_blank>for<S2SV_blank>ICMP<S2SV_blank>Echo<S2SV_blank>sent<S2SV_blank>to<S2SV_blank>%s" , <S2SV_EndBug> icmp_type , addr_ascii , h -> host ) ; } if ( inet_addr ( h -> host ) == INADDR_NONE ) <S2SV_StartBug> fprintf ( stderr , "<S2SV_blank>(%s)" , addr_ascii ) ; <S2SV_EndBug> <S2SV_StartBug> fprintf ( stderr , "\\n" ) ; <S2SV_EndBug> } return 2 ; case ICMP_TSTAMP : case ICMP_TSTAMPREPLY : case ICMP_IREQ : case ICMP_IREQREPLY : case ICMP_MASKREQ : case ICMP_MASKREPLY : default : return 0 ; } } | <S2SV_ModStart> ICMP_TYPE_STR_MAX ) { print_warning ( <S2SV_ModEnd> "%s<S2SV_blank>from<S2SV_blank>%s<S2SV_blank>for<S2SV_blank>ICMP<S2SV_blank>Echo<S2SV_blank>sent<S2SV_blank>to<S2SV_blank>%s" , icmp_type_str <S2SV_ModStart> } else { print_warning ( <S2SV_ModEnd> "ICMP<S2SV_blank>%d<S2SV_blank>from<S2SV_blank>%s<S2SV_blank>for<S2SV_blank>ICMP<S2SV_blank>Echo<S2SV_blank>sent<S2SV_blank>to<S2SV_blank>%s" , icmp_type <S2SV_ModStart> == INADDR_NONE ) print_warning ( <S2SV_ModEnd> "<S2SV_blank>(%s)" , addr_ascii <S2SV_ModStart> addr_ascii ) ; print_warning ( <S2SV_ModEnd> "\\n" ) ; |
2,319 | CWE-000 void player_laser_stop ( unsigned char player ) { <S2SV_StartBug> lasers [ LASER_X ( player ) ] = 0 ; <S2SV_EndBug> <S2SV_StartBug> lasers [ LASER_Y ( player ) ] = 0 ; <S2SV_EndBug> lasers [ LASER_TYPE ( player ) ] = 0 ; lasers [ LASER_SHOOTING ( player ) ] = 0 ; lasers [ LASER_DIRECTION ( player ) ] = 0 ; lasers [ LASER_OFFSET_X ( player ) ] = 0 ; lasers [ LASER_OFFSET_Y ( player ) ] = 0 ; } | <S2SV_ModStart> ) ] = 0xff <S2SV_ModEnd> ; lasers [ <S2SV_ModStart> ) ] = 0xff <S2SV_ModEnd> ; lasers [ |
2,320 | CWE-000 void gl4es_glColor4f ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) { if ( glstate -> list . active ) { if ( glstate -> list . active -> stage != STAGE_DRAW ) { if ( glstate -> list . compiling || glstate -> gl_batch || glstate -> list . active -> stage < STAGE_DRAW ) { glstate -> list . active -> lastColors [ 0 ] = red ; glstate -> list . active -> lastColors [ 1 ] = green ; glstate -> list . active -> lastColors [ 2 ] = blue ; glstate -> list . active -> lastColors [ 3 ] = alpha ; glstate -> list . active -> lastColorsSet = 1 ; <S2SV_StartBug> PUSH_IF_COMPILING ( glColor4f ) ; <S2SV_EndBug> } else if ( glstate -> list . pending && glstate -> list . active -> stage == STAGE_POSTDRAW ) { glstate -> list . active -> post_colors [ 0 ] = red ; glstate -> list . active -> post_colors [ 1 ] = green ; glstate -> list . active -> post_colors [ 2 ] = blue ; glstate -> list . active -> post_colors [ 3 ] = alpha ; glstate -> list . active -> post_color = 1 ; return ; } PUSH_IF_COMPILING ( glColor4f ) ; } else { rlColor4f ( glstate -> list . active , red , green , blue , alpha ) ; noerrorShim ( ) ; } } else { LOAD_GLES_FPE ( glColor4f ) ; errorGL ( ) ; gles_glColor4f ( red , green , blue , alpha ) ; } glstate -> color [ 0 ] = red ; glstate -> color [ 1 ] = green ; glstate -> color [ 2 ] = blue ; glstate -> color [ 3 ] = alpha ; } | <S2SV_ModStart> = 1 ; <S2SV_ModEnd> } else if |
2,321 | CWE-000 static int kvm_s390_vm_get_migration ( struct kvm * kvm , struct kvm_device_attr * attr ) { <S2SV_StartBug> u64 mig = ( kvm -> arch . migration_state != NULL ) ; <S2SV_EndBug> if ( attr -> attr != KVM_S390_VM_MIGRATION_STATUS ) return - ENXIO ; if ( copy_to_user ( ( void __user * ) attr -> addr , & mig , sizeof ( mig ) ) ) return - EFAULT ; return 0 ; } | <S2SV_ModStart> u64 mig = <S2SV_ModEnd> kvm -> arch <S2SV_ModStart> -> arch . migration_mode <S2SV_ModEnd> ; if ( |
2,322 | CWE-000 tid_t process_execute ( const char * file_name ) { char * fn_copy ; tid_t tid ; fn_copy = palloc_get_page ( 0 ) ; if ( fn_copy == NULL ) return TID_ERROR ; <S2SV_StartBug> strlcpy ( fn_copy , file_name , PGSIZE ) ; <S2SV_EndBug> fn_tmp = malloc ( sizeof ( char ) * strlen ( file_name ) + 1 ) ; strlcpy ( fn_tmp , file_name , strlen ( file_name ) + 1 ) ; file_name = strtok_r ( fn_tmp , "<S2SV_blank>" , & ptr ) ; tid = thread_create ( file_name , PRI_DEFAULT , start_process , fn_copy ) ; if ( tid == TID_ERROR ) palloc_free_page ( fn_copy ) ; return tid ; } | <S2SV_ModStart> , PGSIZE ) ; char * fn_tmp , * ptr |
2,323 | CWE-000 static void nlmon_setup ( struct net_device * dev ) { dev -> type = ARPHRD_NETLINK ; dev -> tx_queue_len = 0 ; dev -> netdev_ops = & nlmon_ops ; dev -> ethtool_ops = & nlmon_ethtool_ops ; <S2SV_StartBug> dev -> destructor = free_netdev ; <S2SV_EndBug> dev -> features = NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HIGHDMA | NETIF_F_LLTX ; dev -> flags = IFF_NOARP ; dev -> mtu = NLMSG_GOODSIZE ; } | <S2SV_ModStart> ; dev -> needs_free_netdev = true <S2SV_ModEnd> ; dev -> |
2,324 | CWE-000 static void recv ( struct broadcast_conn * broadcast , const linkaddr_t * sender ) { struct iburst_conn * c = ( struct iburst_conn * ) broadcast ; uint16_t seqno = packetbuf_attr ( PACKETBUF_ATTR_EPACKET_ID ) ; c -> originator = packetbuf_addr ( PACKETBUF_ADDR_ESENDER ) ; c -> hops = packetbuf_attr ( PACKETBUF_ATTR_HOPS ) + 1 ; c -> sender = packetbuf_addr ( PACKETBUF_ADDR_SENDER ) ; if ( seqno == c -> seqno ) { if ( c -> cb -> dropped ) { c -> cb -> dropped ( c ) ; } } <S2SV_StartBug> else if ( ( int16_t ) ( ( seqno ) - ( c -> seqno ) ) < 0 ) { <S2SV_EndBug> c -> seqno = seqno ; if ( c -> cb -> recv ) { c -> cb -> recv ( c , c -> sender , c -> originator , c -> hops ) ; } fwd ( ( struct broadcast_conn * ) c ) ; } else { c -> seqno = seqno ; if ( c -> cb -> recv ) { c -> cb -> recv ( c , c -> originator , c -> sender , c -> hops ) ; } fwd ( ( struct broadcast_conn * ) c ) ; } } | <S2SV_ModStart> } } else <S2SV_ModEnd> { c -> |
2,325 | CWE-000 <S2SV_StartBug> static long <S2SV_EndBug> pyg_param_spec_hash ( PyGParamSpec * self ) { <S2SV_StartBug> return ( long ) pyg_param_spec_get ( self ) ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> static PYGLIB_Py_hash_t <S2SV_ModEnd> pyg_param_spec_hash ( PyGParamSpec <S2SV_ModStart> ) { return PYGLIB_Py_hash_t_FromVoidPtr ( <S2SV_ModEnd> pyg_param_spec_get ( self <S2SV_ModStart> pyg_param_spec_get ( self ) |
2,326 | CWE-000 int MPI_Allreduce ( const void * sendbuf , void * recvbuf , int count , MPI_Datatype datatype , MPI_Op op , MPI_Comm comm ) { if ( kahanmpi_type_op_supported ( datatype , op ) ) { <S2SV_StartBug> return KahanMPI_Allreduce ( sendbuf , recvbuf , count , datatype , op , comm ) ; <S2SV_EndBug> } return PMPI_Allreduce ( sendbuf , recvbuf , count , datatype , op , comm ) ; } | <S2SV_ModStart> ) { return KahanMPI_Reduce <S2SV_ModEnd> ( sendbuf , <S2SV_ModStart> datatype , op , - 1 |
2,327 | CWE-000 <S2SV_StartBug> void checkCardPilesDontChange ( gameState * state , int checkKingdomCards , int checkVictoryCards , int checkTreasureCards ) { <S2SV_EndBug> <S2SV_StartBug> struct gameState * initialState = malloc ( sizeof ( struct gameState ) ) ; <S2SV_EndBug> int playerIndex = 0 ; int randomSeed = 2 ; int numPlayers = 2 ; int i ; <S2SV_StartBug> initializeGame ( numPlayers , kingdomCards , randomSeed , initialState ) ; <S2SV_EndBug> if ( checkKingdomCards ) { for ( i = 0 ; i < 10 ; i ++ ) { <S2SV_StartBug> int card = kingdomCards [ i ] ; <S2SV_EndBug> printf ( "Checking<S2SV_blank>kingdom<S2SV_blank>card<S2SV_blank>%d\\n" , card ) ; checkIntEquals ( initialState -> supplyCount [ card ] , state -> supplyCount [ card ] , "Supply<S2SV_blank>-<S2SV_blank>kindgom<S2SV_blank>card" ) ; } } if ( checkVictoryCards ) { for ( i = 0 ; i < 4 ; i ++ ) { int card = victoryCards [ i ] ; printf ( "Checking<S2SV_blank>victory<S2SV_blank>card<S2SV_blank>%d\\n" , card ) ; checkIntEquals ( initialState -> supplyCount [ card ] , state -> supplyCount [ card ] , "Supply<S2SV_blank>-<S2SV_blank>victory<S2SV_blank>card" ) ; } } if ( checkTreasureCards ) { for ( i = 0 ; i < 3 ; i ++ ) { int card = treasureCards [ i ] ; printf ( "Checking<S2SV_blank>treasure<S2SV_blank>card<S2SV_blank>%d\\n" , card ) ; checkIntEquals ( initialState -> supplyCount [ card ] , state -> supplyCount [ card ] , "Supply<S2SV_blank>-<S2SV_blank>treasure<S2SV_blank>card" ) ; } } } | <S2SV_ModStart> void checkCardPilesDontChange ( <S2SV_ModEnd> struct gameState * <S2SV_ModStart> struct gameState * state , int checkKingdomCards , int checkVictoryCards , int checkTreasureCards ) { struct gameState * initialState = malloc ( sizeof ( struct gameState ) ) <S2SV_ModEnd> ; int randomSeed <S2SV_ModStart> ( numPlayers , gameKingdomCards <S2SV_ModEnd> , randomSeed , <S2SV_ModStart> int card = gameKingdomCards <S2SV_ModEnd> [ i ] |
2,328 | CWE-000 static int mlxcpld_mux_reg_write ( struct i2c_adapter * adap , struct i2c_client * client , u8 val ) { <S2SV_StartBug> struct mlxcpld_mux_plat_data * pdata = dev_get_platdata ( & client -> dev ) ; <S2SV_EndBug> if ( adap -> algo -> master_xfer ) { struct i2c_msg msg ; u8 msgbuf [ ] = { pdata -> sel_reg_addr , val } ; msg . addr = client -> addr ; msg . flags = 0 ; msg . len = 2 ; msg . buf = msgbuf ; <S2SV_StartBug> return __i2c_transfer ( adap , & msg , 1 ) ; <S2SV_EndBug> } else if ( adap -> algo -> smbus_xfer ) { union i2c_smbus_data data ; data . byte = val ; <S2SV_StartBug> return adap -> algo -> smbus_xfer ( adap , client -> addr , <S2SV_EndBug> client -> flags , I2C_SMBUS_WRITE , pdata -> sel_reg_addr , I2C_SMBUS_BYTE_DATA , & data ) ; <S2SV_StartBug> } else <S2SV_EndBug> return - ENODEV ; } | <S2SV_ModStart> -> dev ) ; int ret = - ENODEV <S2SV_ModStart> = msgbuf ; ret = <S2SV_ModEnd> __i2c_transfer ( adap <S2SV_ModStart> , 1 ) ; if ( ret >= 0 && ret != 1 ) ret = - EREMOTEIO <S2SV_ModStart> = val ; ret = <S2SV_ModEnd> adap -> algo <S2SV_ModStart> ) ; } return ret <S2SV_ModEnd> ; } <S2SV_null> |
2,329 | CWE-000 int main ( int argc , char * * argv , char * * env ) { char * * path = ( string_token ( env [ 9 ] , ":=" ) + 1 ) ; ssize_t run_shell = 0 ; size_t count = 0 ; char * line = NULL , * * array = NULL , * ptr = NULL ; int i = 0 , exit_code = 0 , call_count = 0 ; while ( 42 ) { run_shell = 0 ; count = 0 ; line = NULL ; array = NULL ; ptr = NULL ; i = 0 ; exit_code = 0 ; call_count = 0 ; call_count ++ ; write ( STDIN_FILENO , "\\033[1;35m$\\033[0m<S2SV_blank>" , 13 ) ; run_shell = getline ( & line , & count , stdin ) ; if ( run_shell == - 1 ) { write ( STDIN_FILENO , "\\n" , 1 ) ; return ( 0 ) ; } array = string_token ( line , "\\n<S2SV_blank>" ) ; if ( array == NULL ) free ( line ) ; if ( array != NULL && ! ( strcmp ( array [ 0 ] , "exit" ) ) ) { <S2SV_StartBug> break ; <S2SV_EndBug> } if ( array != NULL && ! ( strcmp ( array [ 0 ] , "env" ) ) ) { print_env ( env ) ; } if ( array != NULL && access ( array [ 0 ] , F_OK ) == - 1 ) array [ 0 ] = path_helper ( path , array [ 0 ] ) ; if ( forking_helper ( array ) ) { } if ( array != NULL ) { free ( array [ 0 ] ) ; free ( array ) ; } } free ( array [ 0 ] ) ; free ( array ) ; return ( exit_code ) ; } | <S2SV_ModStart> ) ) { write ( STDIN_FILENO , argv [ 0 ] , _strlen ( argv [ 0 ] ) ) ; write ( STDIN_FILENO , ":<S2SV_blank>" , 2 ) ; write ( STDIN_FILENO , call_count , _strlen ( ? : ) ) ; write ( STDIN_FILENO , ":<S2SV_blank>exit" , 6 ) ; fix call_count number to print istead of buffer of 100 exit_code = array [ 1 ] ; if not string |
2,330 | CWE-000 unsigned bch2_dirent_name_bytes ( struct bkey_s_c_dirent d ) { <S2SV_StartBug> unsigned len = bkey_val_bytes ( d . k ) - sizeof ( struct bch_dirent ) ; <S2SV_EndBug> while ( len && ! d . v -> d_name [ len - 1 ] ) -- len ; return len ; } | <S2SV_ModStart> k ) - offsetof <S2SV_ModEnd> ( struct bch_dirent <S2SV_ModStart> ( struct bch_dirent , d_name |
2,331 | CWE-000 <S2SV_StartBug> int maximum ( unsigned * plengths , int s ) { <S2SV_EndBug> int i ; <S2SV_StartBug> int max = - 1 ; <S2SV_EndBug> for ( i = 0 ; i < s ; i ++ ) { if ( plengths [ i ] > max ) { max = plengths [ i ] ; } } return max ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> unsigned <S2SV_ModEnd> maximum ( unsigned <S2SV_ModStart> int i ; unsigned max = 0 <S2SV_ModEnd> ; for ( |
2,332 | CWE-000 static char * encode ( char * result , char * s_ ) { char s [ 256 ] ; long i , lim ; strcpy ( s , s_ ) ; if ( * lock_code == '\\0' ) return strcpy ( result , s ) ; lim = strlen ( s ) ; for ( i = 0 ; i < lim ; i ++ ) { lock_pos ++ ; if ( lock_pos > strlen ( lock_code ) ) lock_pos = 1 ; <S2SV_StartBug> if ( ( uchar ) s [ i ] <= 31 || ( s [ i ] & ( ~ 127 ) ) != 0 && ( s [ i ] & 255 ) <= 255 ) <S2SV_EndBug> s [ i ] = '<S2SV_blank>' ; this_dat = s [ i ] & 15 ; s [ i ] = ( char ) ( ( s [ i ] ^ lock_code [ lock_pos - 1 ] ^ lock_dat ) + 1 ) ; lock_dat = this_dat ; } return strcpy ( result , s ) ; } | <S2SV_ModStart> if ( ( char <S2SV_ModEnd> ) s [ |
2,333 | CWE-000 static int i915_gem_execbuffer_relocate_vma ( struct i915_vma * vma , struct eb_vmas * eb ) { # define N_RELOC ( x ) ( ( x ) / sizeof ( struct drm_i915_gem_relocation_entry ) ) struct drm_i915_gem_relocation_entry stack_reloc [ N_RELOC ( 512 ) ] ; struct drm_i915_gem_relocation_entry __user * user_relocs ; struct drm_i915_gem_exec_object2 * entry = vma -> exec_entry ; struct reloc_cache cache ; int remain , ret = 0 ; user_relocs = u64_to_user_ptr ( entry -> relocs_ptr ) ; reloc_cache_init ( & cache , eb -> i915 ) ; remain = entry -> relocation_count ; while ( remain ) { struct drm_i915_gem_relocation_entry * r = stack_reloc ; unsigned long unwritten ; unsigned int count ; count = min_t ( unsigned int , remain , ARRAY_SIZE ( stack_reloc ) ) ; remain -= count ; pagefault_disable ( ) ; unwritten = __copy_from_user_inatomic ( r , user_relocs , count * sizeof ( r [ 0 ] ) ) ; pagefault_enable ( ) ; if ( unlikely ( unwritten ) ) { ret = - EFAULT ; goto out ; } do { u64 offset = r -> presumed_offset ; <S2SV_StartBug> ret = i915_gem_execbuffer_relocate_entry ( vma -> obj , eb , r , & cache ) ; <S2SV_EndBug> if ( ret ) goto out ; if ( r -> presumed_offset != offset ) { pagefault_disable ( ) ; unwritten = __put_user ( r -> presumed_offset , & user_relocs -> presumed_offset ) ; pagefault_enable ( ) ; if ( unlikely ( unwritten ) ) { ret = - EFAULT ; goto out ; } } user_relocs ++ ; r ++ ; } while ( -- count ) ; } out : reloc_cache_fini ( & cache ) ; return ret ; # undef N_RELOC } | <S2SV_ModStart> i915_gem_execbuffer_relocate_entry ( vma <S2SV_ModEnd> , eb , |
2,334 | CWE-000 int fsck_chk_didnode_blk ( struct f2fs_sb_info * sbi , <S2SV_StartBug> struct f2fs_inode * inode , <S2SV_EndBug> u32 nid , enum FILE_TYPE ftype , struct f2fs_node * node_blk , u32 * blk_cnt ) { int i = 0 ; for ( i = 0 ; i < NIDS_PER_BLOCK ; i ++ ) { if ( le32_to_cpu ( node_blk -> in . nid [ i ] ) == 0x0 ) continue ; * blk_cnt = * blk_cnt + 1 ; fsck_chk_node_blk ( sbi , inode , le32_to_cpu ( node_blk -> in . nid [ i ] ) , ftype , TYPE_INDIRECT_NODE , blk_cnt ) ; } return 0 ; } | <S2SV_ModStart> f2fs_inode * inode <S2SV_ModEnd> , enum FILE_TYPE |
2,335 | CWE-000 bool resend_ike_v1_msg ( struct state * st , const char * where ) { bool ret = send_or_resend_ike_msg ( st , where , TRUE ) ; if ( st -> st_state == STATE_XAUTH_R0 && ! LIN ( POLICY_AGGRESSIVE , st -> st_connection -> policy ) ) { <S2SV_StartBug> event_schedule_ms ( EVENT_v1_SEND_XAUTH , EVENT_v1_SEND_XAUTH_DELAY , st ) ; <S2SV_EndBug> } return ret ; } | <S2SV_ModStart> ) ) { event_schedule <S2SV_ModEnd> ( EVENT_v1_SEND_XAUTH , <S2SV_ModStart> ( EVENT_v1_SEND_XAUTH , deltatime_ms ( EVENT_v1_SEND_XAUTH_DELAY_MS ) <S2SV_ModEnd> , st ) |
2,336 | CWE-000 <S2SV_StartBug> pnm interpolation ( char * filter_name , int factor , int imd_rows , int imd_cols , int cols , pnm ims ) <S2SV_EndBug> { pnm imd = pnm_new ( imd_cols , imd_rows , PnmRawPpm ) ; for ( int j_prime = 0 ; j_prime < imd_cols ; ++ j_prime ) { for ( int i = 0 ; i < imd_rows ; ++ i ) { double j = j_prime / ( double ) factor ; double wf = WF ( filter_name ) ; double left = j - wf ; double right = j + wf ; double S = 0 ; for ( int k = left ; k < right ; ++ k ) { if ( k < 0 || k >= cols ) { continue ; } S += pnm_get_component ( ims , i , k , 0 ) * h ( filter_name , k - j ) ; } for ( int k = 0 ; k < 3 ; ++ k ) { pnm_set_component ( imd , i , j_prime , k , S ) ; } } } <S2SV_StartBug> return imd ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> void <S2SV_ModEnd> interpolation ( char <S2SV_ModStart> , pnm ims , pnm imd ) { <S2SV_ModEnd> for ( int <S2SV_ModStart> } } } <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
2,337 | CWE-000 static int init_overlay_changeset ( struct overlay_changeset * ovcs , <S2SV_StartBug> struct device_node * tree ) <S2SV_EndBug> { struct device_node * node , * overlay_node ; struct fragment * fragment ; struct fragment * fragments ; int cnt , id , ret ; if ( ! of_node_check_flag ( tree , OF_DYNAMIC ) ) pr_debug ( "%s()<S2SV_blank>tree<S2SV_blank>is<S2SV_blank>not<S2SV_blank>dynamic\\n" , __func__ ) ; if ( ! of_node_check_flag ( tree , OF_DETACHED ) ) pr_debug ( "%s()<S2SV_blank>tree<S2SV_blank>is<S2SV_blank>not<S2SV_blank>detached\\n" , __func__ ) ; if ( ! of_node_is_root ( tree ) ) pr_debug ( "%s()<S2SV_blank>tree<S2SV_blank>is<S2SV_blank>not<S2SV_blank>root\\n" , __func__ ) ; ovcs -> overlay_tree = tree ; <S2SV_StartBug> INIT_LIST_HEAD ( & ovcs -> ovcs_list ) ; <S2SV_EndBug> of_changeset_init ( & ovcs -> cset ) ; id = idr_alloc ( & ovcs_idr , ovcs , 1 , 0 , GFP_KERNEL ) ; if ( id <= 0 ) return id ; cnt = 0 ; for_each_child_of_node ( tree , node ) { overlay_node = of_get_child_by_name ( node , "__overlay__" ) ; if ( overlay_node ) { cnt ++ ; of_node_put ( overlay_node ) ; } } node = of_get_child_by_name ( tree , "__symbols__" ) ; if ( node ) { cnt ++ ; of_node_put ( node ) ; } fragments = kcalloc ( cnt , sizeof ( * fragments ) , GFP_KERNEL ) ; if ( ! fragments ) { ret = - ENOMEM ; goto err_free_idr ; } cnt = 0 ; for_each_child_of_node ( tree , node ) { overlay_node = of_get_child_by_name ( node , "__overlay__" ) ; if ( ! overlay_node ) continue ; fragment = & fragments [ cnt ] ; fragment -> overlay = overlay_node ; fragment -> target = find_target_node ( node ) ; if ( ! fragment -> target ) { of_node_put ( fragment -> overlay ) ; ret = - EINVAL ; goto err_free_fragments ; } cnt ++ ; } node = of_get_child_by_name ( tree , "__symbols__" ) ; if ( node ) { ovcs -> symbols_fragment = 1 ; fragment = & fragments [ cnt ] ; fragment -> overlay = node ; fragment -> target = of_find_node_by_path ( "/__symbols__" ) ; if ( ! fragment -> target ) { pr_err ( "symbols<S2SV_blank>in<S2SV_blank>overlay,<S2SV_blank>but<S2SV_blank>not<S2SV_blank>in<S2SV_blank>live<S2SV_blank>tree\\n" ) ; ret = - EINVAL ; goto err_free_fragments ; } cnt ++ ; } if ( ! cnt ) { <S2SV_StartBug> ret = - EINVAL ; <S2SV_EndBug> goto err_free_fragments ; } ovcs -> id = id ; ovcs -> count = cnt ; ovcs -> fragments = fragments ; return 0 ; err_free_fragments : kfree ( fragments ) ; err_free_idr : idr_remove ( & ovcs_idr , id ) ; pr_err ( "%s()<S2SV_blank>failed,<S2SV_blank>ret<S2SV_blank>=<S2SV_blank>%d\\n" , __func__ , ret ) ; return ret ; } | <S2SV_ModStart> * ovcs , const void * fdt , <S2SV_ModStart> = tree ; ovcs -> fdt = fdt ; <S2SV_ModStart> cnt ) { pr_err ( "no<S2SV_blank>fragments<S2SV_blank>or<S2SV_blank>symbols<S2SV_blank>in<S2SV_blank>overlay\\n" ) ; |
2,338 | CWE-000 void xavs2_dct_init ( uint32_t cpuid , dct_funcs_t * dctf ) { dctf -> dct [ LUMA_4x4 ] = dct_4x4_c ; dctf -> dct [ LUMA_8x8 ] = dct_8x8_c ; dctf -> dct [ LUMA_16x16 ] = dct_16x16_c ; dctf -> dct [ LUMA_32x32 ] = dct_32x32_c ; dctf -> dct [ LUMA_64x64 ] = dct_64x64_c ; dctf -> dct [ LUMA_16x4 ] = dct_16x4_c ; dctf -> dct [ LUMA_4x16 ] = dct_4x16_c ; dctf -> dct [ LUMA_32x8 ] = dct_32x8_c ; dctf -> dct [ LUMA_8x32 ] = dct_8x32_c ; dctf -> dct [ LUMA_64x16 ] = dct_64x16_c ; dctf -> dct [ LUMA_16x64 ] = dct_16x64_c ; dctf -> idct [ LUMA_4x4 ] = idct_4x4_c ; dctf -> idct [ LUMA_8x8 ] = idct_8x8_c ; dctf -> idct [ LUMA_16x16 ] = idct_16x16_c ; dctf -> idct [ LUMA_32x32 ] = idct_32x32_c ; dctf -> idct [ LUMA_64x64 ] = idct_64x64_c ; dctf -> idct [ LUMA_16x4 ] = idct_16x4_c ; dctf -> idct [ LUMA_4x16 ] = idct_4x16_c ; dctf -> idct [ LUMA_32x8 ] = idct_32x8_c ; dctf -> idct [ LUMA_8x32 ] = idct_8x32_c ; dctf -> idct [ LUMA_64x16 ] = idct_64x16_c ; dctf -> idct [ LUMA_16x64 ] = idct_16x64_c ; <S2SV_StartBug> memcpy ( dctf -> dct_half , dctf -> dct , sizeof ( dctf -> dct_half ) ) ; <S2SV_EndBug> dctf -> transform_4x4_2nd = transform_4x4_2nd_c ; dctf -> inv_transform_4x4_2nd = inv_transform_4x4_2nd_c ; dctf -> transform_2nd = transform_2nd_c ; dctf -> inv_transform_2nd = inv_transform_2nd_c ; # if HAVE_MMX <S2SV_StartBug> memcpy ( dctf -> dct_half , dctf -> dct , sizeof ( dctf -> dct_half ) ) ; <S2SV_EndBug> if ( cpuid & XAVS2_CPU_SSE42 ) { dctf -> dct [ LUMA_4x4 ] = dct_4x4_sse128 ; dctf -> dct [ LUMA_8x8 ] = dct_8x8_sse128 ; dctf -> dct [ LUMA_16x16 ] = dct_16x16_sse128 ; dctf -> dct [ LUMA_32x32 ] = dct_32x32_sse128 ; dctf -> dct [ LUMA_64x64 ] = dct_64x64_sse128 ; dctf -> dct [ LUMA_16x4 ] = dct_16x4_sse128 ; dctf -> dct [ LUMA_4x16 ] = dct_4x16_sse128 ; dctf -> dct [ LUMA_32x8 ] = dct_32x8_sse128 ; dctf -> dct [ LUMA_8x32 ] = dct_8x32_sse128 ; dctf -> dct [ LUMA_64x16 ] = dct_64x16_sse128 ; dctf -> dct [ LUMA_16x64 ] = dct_16x64_sse128 ; dctf -> idct [ LUMA_4x4 ] = idct_4x4_sse128 ; dctf -> idct [ LUMA_8x8 ] = idct_8x8_sse128 ; dctf -> idct [ LUMA_16x16 ] = idct_16x16_sse128 ; dctf -> idct [ LUMA_32x32 ] = idct_32x32_sse128 ; dctf -> idct [ LUMA_64x64 ] = idct_64x64_sse128 ; dctf -> idct [ LUMA_16x4 ] = idct_16x4_sse128 ; dctf -> idct [ LUMA_4x16 ] = idct_4x16_sse128 ; dctf -> idct [ LUMA_32x8 ] = idct_32x8_sse128 ; dctf -> idct [ LUMA_8x32 ] = idct_8x32_sse128 ; dctf -> idct [ LUMA_64x16 ] = idct_64x16_sse128 ; dctf -> idct [ LUMA_16x64 ] = idct_16x64_sse128 ; dctf -> transform_4x4_2nd = transform_4x4_2nd_sse128 ; dctf -> inv_transform_4x4_2nd = inv_transform_4x4_2nd_sse128 ; dctf -> transform_2nd = transform_2nd_sse128 ; dctf -> inv_transform_2nd = inv_transform_2nd_sse128 ; dctf -> dct_half [ LUMA_32x32 ] = dct_32x32_half_sse128 ; dctf -> dct_half [ LUMA_64x64 ] = dct_64x64_half_sse128 ; } if ( cpuid & XAVS2_CPU_SSE2 ) { dctf -> dct [ LUMA_4x4 ] = xavs2_dct_4x4_sse2 ; dctf -> dct [ LUMA_8x8 ] = xavs2_dct_8x8_sse2 ; dctf -> idct [ LUMA_4x4 ] = xavs2_idct_4x4_sse2 ; dctf -> idct [ LUMA_8x8 ] = xavs2_idct_8x8_sse2 ; } if ( cpuid & XAVS2_CPU_SSSE3 ) { dctf -> idct [ LUMA_8x8 ] = xavs2_idct_8x8_ssse3 ; } if ( cpuid & XAVS2_CPU_SSE4 ) { dctf -> dct [ LUMA_8x8 ] = xavs2_dct_8x8_sse4 ; } if ( cpuid & XAVS2_CPU_AVX2 ) { dctf -> dct [ LUMA_4x4 ] = xavs2_dct_4x4_avx2 ; dctf -> dct [ LUMA_8x8 ] = xavs2_dct_8x8_avx2 ; dctf -> dct [ LUMA_16x16 ] = xavs2_dct_16x16_avx2 ; dctf -> dct [ LUMA_32x32 ] = xavs2_dct_32x32_avx2 ; dctf -> idct [ LUMA_4x4 ] = xavs2_idct_4x4_avx2 ; dctf -> idct [ LUMA_8x8 ] = xavs2_idct_8x8_avx2 ; dctf -> idct [ LUMA_16x16 ] = xavs2_idct_16x16_avx2 ; dctf -> idct [ LUMA_32x32 ] = xavs2_idct_32x32_avx2 ; } # if ARCH_X86_64 if ( cpuid & XAVS2_CPU_AVX2 ) { dctf -> dct [ LUMA_16x4 ] = dct_16x4_avx2 ; dctf -> dct [ LUMA_8x32 ] = dct_8x32_avx2 ; dctf -> dct [ LUMA_32x8 ] = dct_32x8_avx2 ; dctf -> dct [ LUMA_16x16 ] = dct_16x16_avx2 ; dctf -> dct [ LUMA_64x64 ] = dct_64x64_avx2 ; dctf -> dct [ LUMA_64x16 ] = dct_64x16_avx2 ; dctf -> dct [ LUMA_16x64 ] = dct_16x64_avx2 ; dctf -> idct [ LUMA_8x8 ] = idct_8x8_avx2 ; dctf -> idct [ LUMA_16x16 ] = idct_16x16_avx2 ; dctf -> idct [ LUMA_32x32 ] = idct_32x32_avx2 ; dctf -> idct [ LUMA_64x64 ] = idct_64x64_avx2 ; dctf -> idct [ LUMA_64x16 ] = idct_64x16_avx2 ; dctf -> idct [ LUMA_16x64 ] = idct_16x64_avx2 ; dctf -> dct_half [ LUMA_32x32 ] = dct_32x32_half_avx2 ; dctf -> dct_half [ LUMA_64x64 ] = dct_64x64_half_avx2 ; } # endif # else UNUSED_PARAMETER ( cpuid ) ; # endif } | <S2SV_ModStart> = idct_16x64_c ; dctf -> transform_4x4_2nd = transform_4x4_2nd_c ; dctf -> inv_transform_4x4_2nd = inv_transform_4x4_2nd_c ; dctf -> transform_2nd = transform_2nd_c ; dctf -> inv_transform_2nd = inv_transform_2nd_c ; <S2SV_ModEnd> dctf -> dct_half <S2SV_ModStart> dctf -> dct_half [ LUMA_32x32 ] = dct_32x32_half_c ; <S2SV_ModEnd> dctf -> dct_half <S2SV_ModStart> dctf -> dct_half [ LUMA_64x64 ] = dct_64x64_half_c <S2SV_ModEnd> ; # if <S2SV_ModStart> # if HAVE_MMX <S2SV_ModEnd> if ( cpuid |
2,339 | CWE-000 int sendTcpPacket ( char * sendBuf , int size ) { int bytesSent ; if ( currentConnectionFD == - 1 ) { return - 1 ; } bytesSent = send ( currentConnectionFD , sendBuf , size , 0 ) ; if ( bytesSent < 0 ) { <S2SV_StartBug> debugger_printf ( "Error:<S2SV_blank>send<S2SV_blank>failed.\\n" ) ; <S2SV_EndBug> VCP_txflush ( ) ; } return bytesSent ; } | <S2SV_ModStart> 0 ) { tfp_printf ( "Error:<S2SV_blank>send<S2SV_blank>failed.\\n" <S2SV_ModEnd> ) ; } |
2,340 | CWE-000 const char * gui_chat_string_add_offset_screen ( const char * string , int offset_screen ) { int size_on_screen ; <S2SV_StartBug> while ( string && string [ 0 ] && ( offset_screen > 0 ) ) <S2SV_EndBug> { string = gui_chat_string_next_char ( NULL , NULL , ( unsigned char * ) string , 0 , 0 , 0 ) ; if ( string ) { size_on_screen = gui_chat_char_size_screen ( string ) ; offset_screen -= size_on_screen ; <S2SV_StartBug> string = utf8_next_char ( string ) ; <S2SV_EndBug> } } return string ; } | <S2SV_ModStart> && ( offset_screen >= <S2SV_ModEnd> 0 ) ) <S2SV_ModStart> -= size_on_screen ; if ( offset_screen < 0 ) return string ; |
2,341 | CWE-000 bool ce_vim_verb_open_above ( CeVim_t * vim , const CeVimAction_t * action , CeVimMotionRange_t motion_range , CeView_t * view , const CeConfigOptions_t * config_options ) { char * insert_string = strdup ( "\\n" ) ; motion_range . start . x = 0 ; if ( ! ce_buffer_insert_string ( view -> buffer , insert_string , motion_range . start ) ) return false ; CeBufferChange_t change = { } ; change . chain = action -> chain_undo ; change . insertion = true ; <S2SV_StartBug> change . remove_line_if_empty = true ; <S2SV_EndBug> change . string = insert_string ; change . location = motion_range . start ; change . cursor_before = view -> cursor ; change . cursor_after = view -> cursor ; ce_buffer_change ( view -> buffer , & change ) ; CePoint_t indentation_point = { 0 , motion_range . start . y } ; CePoint_t cursor_end = { 0 , indentation_point . y } ; int64_t indentation = ce_vim_get_indentation ( view -> buffer , indentation_point , config_options -> tab_width ) ; if ( indentation > 0 ) { cursor_end . x = indentation ; insert_string = malloc ( indentation + 1 ) ; memset ( insert_string , '<S2SV_blank>' , indentation ) ; insert_string [ indentation ] = 0 ; if ( ! ce_buffer_insert_string ( view -> buffer , insert_string , indentation_point ) ) return false ; change . chain = true ; change . insertion = true ; <S2SV_StartBug> change . remove_line_if_empty = false ; <S2SV_EndBug> change . string = insert_string ; change . location = indentation_point ; change . cursor_before = view -> cursor ; change . cursor_after = cursor_end ; ce_buffer_change ( view -> buffer , & change ) ; } view -> cursor = cursor_end ; vim -> chain_undo = true ; insert_mode ( vim ) ; return true ; } | <S2SV_ModStart> ; change . <S2SV_ModEnd> string = insert_string <S2SV_ModStart> ; change . <S2SV_ModEnd> string = insert_string |
2,342 | CWE-000 void init_editor ( ) { <S2SV_StartBug> char font [ ] = "c:/windows/fonts/times.ttf" ; <S2SV_EndBug> s32 font_size = 20 ; init_font ( font , font_size , win_state . win_width , win_state . win_height ) ; init_text_api ( ) ; editor_state . cursor = 0 ; <S2SV_StartBug> editor_state . buffer_size = _tm_text_size ; <S2SV_EndBug> <S2SV_StartBug> editor_state . buffer = get_text_buffer ( _tm_text_size , 0 ) ; <S2SV_EndBug> Text_Container * container = & editor_state . container ; container -> left_padding = 2.0f ; container -> right_padding = 2.0f ; container -> bottom_padding = 2.0f ; container -> top_padding = 20.0f ; update_container ( container ) ; } | <S2SV_ModStart> [ ] = "c:/windows/fonts/consola.ttf" <S2SV_ModEnd> ; s32 font_size <S2SV_ModStart> ; editor_state . cursor_column = 0 ; editor_state . cursor_prev_line_char_count = 0 ; editor_state . <S2SV_ModStart> , 0 ) ; editor_state . render = true |
2,343 | CWE-000 static l_uint8 * makeValTabSG4 ( void ) { l_int32 i ; l_uint8 * tab ; <S2SV_StartBug> tab = ( l_uint8 * ) LEPT_CALLOC ( 17 , sizeof ( l_uint8 ) ) ; <S2SV_EndBug> for ( i = 0 ; i < 17 ; i ++ ) tab [ i ] = 0xff - ( i * 255 ) / 16 ; return tab ; } | <S2SV_ModStart> * tab ; PROCNAME ( "makeValTabSG4" ) ; if ( ( <S2SV_ModStart> ( l_uint8 ) ) ) == NULL ) return ( l_uint8 * ) ERROR_PTR ( "tab<S2SV_blank>not<S2SV_blank>made" , procName , NULL |
2,344 | CWE-000 static void qemu_input_event_trace ( QemuConsole * src , InputEvent * evt ) { const char * name ; int qcode , idx = - 1 ; InputKeyEvent * key ; InputBtnEvent * btn ; InputMoveEvent * move ; if ( src ) { idx = qemu_console_get_index ( src ) ; } switch ( evt -> type ) { case INPUT_EVENT_KIND_KEY : key = evt -> u . key . data ; switch ( key -> key -> type ) { case KEY_VALUE_KIND_NUMBER : qcode = qemu_input_key_number_to_qcode ( key -> key -> u . number . data ) ; name = QKeyCode_str ( qcode ) ; trace_input_event_key_number ( idx , key -> key -> u . number . data , name , key -> down ) ; break ; case KEY_VALUE_KIND_QCODE : <S2SV_StartBug> name = QKeyCode_str ( key -> key -> u . qcode . data ) ; <S2SV_EndBug> trace_input_event_key_qcode ( idx , name , key -> down ) ; break ; case KEY_VALUE_KIND__MAX : break ; } break ; case INPUT_EVENT_KIND_BTN : btn = evt -> u . btn . data ; name = InputButton_str ( btn -> button ) ; trace_input_event_btn ( idx , name , btn -> down ) ; break ; case INPUT_EVENT_KIND_REL : move = evt -> u . rel . data ; name = InputAxis_str ( move -> axis ) ; trace_input_event_rel ( idx , name , move -> value ) ; break ; case INPUT_EVENT_KIND_ABS : move = evt -> u . abs . data ; name = InputAxis_str ( move -> axis ) ; trace_input_event_abs ( idx , name , move -> value ) ; break ; case INPUT_EVENT_KIND__MAX : break ; } } | <S2SV_ModStart> case KEY_VALUE_KIND_QCODE : trace_input_event_key_number ( idx , <S2SV_ModEnd> key -> key <S2SV_ModStart> qcode . data , "" , <S2SV_ModEnd> key -> down |
2,345 | CWE-000 bool fixup_umip_exception ( struct pt_regs * regs ) { int not_copied , nr_copied , reg_offset , dummy_data_size , umip_inst ; unsigned long seg_base = 0 , * reg_addr ; unsigned char dummy_data [ 10 ] = { 0 } ; unsigned char buf [ MAX_INSN_SIZE ] ; void __user * uaddr ; struct insn insn ; char seg_defs ; if ( user_64bit_mode ( regs ) ) return false ; if ( ! user_64bit_mode ( regs ) ) seg_base = insn_get_seg_base ( regs , INAT_SEG_REG_CS ) ; if ( seg_base == - 1L ) return false ; not_copied = copy_from_user ( buf , ( void __user * ) ( seg_base + regs -> ip ) , sizeof ( buf ) ) ; nr_copied = sizeof ( buf ) - not_copied ; if ( ! nr_copied ) return false ; insn_init ( & insn , buf , nr_copied , user_64bit_mode ( regs ) ) ; seg_defs = insn_get_code_seg_defaults ( regs ) ; if ( seg_defs == - EINVAL ) return false ; insn . addr_bytes = ( unsigned char ) INSN_CODE_SEG_ADDR_SZ ( seg_defs ) ; insn . opnd_bytes = ( unsigned char ) INSN_CODE_SEG_OPND_SZ ( seg_defs ) ; insn_get_length ( & insn ) ; if ( nr_copied < insn . length ) return false ; umip_inst = identify_insn ( & insn ) ; if ( umip_inst < 0 ) return false ; if ( emulate_umip_insn ( & insn , umip_inst , dummy_data , & dummy_data_size ) ) return false ; if ( X86_MODRM_MOD ( insn . modrm . value ) == 3 ) { reg_offset = insn_get_modrm_rm_off ( & insn , regs ) ; if ( reg_offset < 0 ) return false ; reg_addr = ( unsigned long * ) ( ( unsigned long ) regs + reg_offset ) ; memcpy ( reg_addr , dummy_data , dummy_data_size ) ; } else { uaddr = insn_get_addr_ref ( & insn , regs ) ; if ( ( unsigned long ) uaddr == - 1L ) return false ; nr_copied = copy_to_user ( uaddr , dummy_data , dummy_data_size ) ; if ( nr_copied > 0 ) <S2SV_StartBug> return false ; <S2SV_EndBug> } regs -> ip += insn . length ; return true ; } | <S2SV_ModStart> > 0 ) { force_sig_info_umip_fault ( uaddr , regs ) ; return true ; } <S2SV_ModEnd> } regs -> |
2,346 | CWE-000 NodeConstDecl * ConstDeclPrime ( ) { NodeConstDecl * node = NULL ; switch ( lex -> type ) { case IDENTIFIER : node = new_node ( NodeConstDecl ) ; <S2SV_StartBug> match ( IDENTIFIER ) ; <S2SV_EndBug> match ( OP_EQUALS ) ; <S2SV_StartBug> Expression ( ) ; <S2SV_EndBug> match ( STM_END ) ; <S2SV_StartBug> ConstDeclPrime ( ) ; <S2SV_EndBug> break ; default : break ; } return node ; } | <S2SV_ModStart> NodeConstDecl ) ; store_identifier ( & node -> name ) ; <S2SV_ModStart> OP_EQUALS ) ; node -> expression = <S2SV_ModStart> STM_END ) ; node -> next_constdecl = |
2,347 | CWE-000 void loadFirmTest ( boottype boot_type , firmtype firm_type ) { u32 firmVersion = firmRead ( ( u8 * ) firm , firm_type ) ; <S2SV_StartBug> u8 * sect_arm9 = ( u8 * ) firm + firm -> section [ 2 ] . offset ; <S2SV_EndBug> int ret = 0 ; if ( firmVersion == 0xDEADBEEF ) { debugWrite ( "/rei/debug.log" , "Failed<S2SV_blank>to<S2SV_blank>mount<S2SV_blank>CTRNAND.<S2SV_blank>" , 25 ) ; shutdown ( ) ; } firmSize = decryptExeFs ( ( Cxi * ) ( ( u8 * ) firm ) ) ; <S2SV_StartBug> if ( firmSize ) <S2SV_EndBug> debugWrite ( "/rei/debug.log" , "Successfully<S2SV_blank>Decrypted<S2SV_blank>CTRNAND<S2SV_blank>FIRM.<S2SV_blank>" , 37 ) ; if ( ! firmSize ) { debugWrite ( "/rei/debug.log" , "Failed<S2SV_blank>to<S2SV_blank>decrypt<S2SV_blank>the<S2SV_blank>CTRNAND<S2SV_blank>FIRM.<S2SV_blank>" , 38 ) ; shutdown ( ) ; } <S2SV_StartBug> if ( ( firm -> section [ 3 ] . offset != 0 ? firm -> section [ 3 ] . address : firm -> section [ 2 ] . address ) != ( ISN3DS ? ( u8 * ) 0x8006000 : ( u8 * ) 0x8006800 ) ) <S2SV_EndBug> <S2SV_StartBug> shutdown ( ) ; <S2SV_EndBug> if ( ISN3DS ) { k9loader ( ( Arm9Bin * ) sect_arm9 ) ; firm -> arm9Entry = ( u8 * ) 0x801B01C ; } getMPU ( firmLocation , firmSize , & mpuOffset ) ; * ( u32 * ) mpuOffset = PERMS ( RW_RW , N_N , SIZE_256MB ) ; * ( u32 * ) ( mpuOffset + 0x18 ) = PERMS ( RW_RW , R_R , SIZE_128KB ) ; * ( u32 * ) ( mpuOffset + 0x24 ) = PERMS ( RW_RW , R_R , SIZE_32KB ) ; if ( fopen ( "/rei/loader.cxi" , "rb" ) ) { u8 * arm11SysMods = ( u8 * ) firm + firm -> section [ 0 ] . offset ; Size ldrInFirmSize ; Size ldrFileSize = fsize ( ) ; getLoader ( arm11SysMods , & ldrInFirmSize , & ldrOffset ) ; memcpy ( firm -> section [ 0 ] . address , arm11SysMods , ldrOffset ) ; fread ( firm -> section [ 0 ] . address + ldrOffset , 1 , ldrFileSize ) ; memcpy ( firm -> section [ 0 ] . address + ldrOffset + ldrFileSize , arm11SysMods + ldrOffset + ldrInFirmSize , firm -> section [ 0 ] . size - ( ldrOffset + ldrInFirmSize ) ) ; fclose ( ) ; } else { memcpy ( firm -> section [ 0 ] . address , firmLocation + firm -> section [ 0 ] . offset , firm -> section [ 0 ] . size ) ; } getEmunandSect ( & emuOffset , & emuHeader ) ; loadNandType ( boot_type ) ; } | <S2SV_ModStart> ] . offset <S2SV_ModEnd> ; if ( <S2SV_ModStart> ; if ( <S2SV_ModEnd> ! firmSize ) <S2SV_ModStart> 0x8006800 ) ) { debugWrite ( "/rei/debug.log" , "This<S2SV_blank>firm<S2SV_blank>isn\'t<S2SV_blank>for<S2SV_blank>this<S2SV_blank>console.<S2SV_blank>" , 34 ) ; <S2SV_ModStart> ( ) ; } |
2,348 | CWE-000 int main ( int argc , char * * argv ) { int v , failures ; v = ( argc > 1 ) ? atoi ( argv [ 1 ] ) : 0 ; failures = 0 ; failures += test_div ( v , "20000" , "100" , "200" , "0" ) ; failures += test_div ( v , "20001" , "100" , "200" , "1" ) ; failures += test_div ( v , "20013" , "200" , "100" , "13" ) ; failures += test_div ( v , "287713" , "571" , "503" , "500" ) ; failures += test_div ( v , "-13" , "6" , "-2" , "1" ) ; failures += test_div ( v , "20" , "-7" , "-2" , "6" ) ; failures += test_div ( v , "-100" , "-9" , "11" , "1" ) ; failures += test_div ( v , "5088824049625" , "33554393" , "151658" , "31916031" ) ; failures += test_div_by_zero ( v ) ; <S2SV_StartBug> if ( failures ) { <S2SV_EndBug> Test_log_error2 ( "%d<S2SV_blank>failures<S2SV_blank>in<S2SV_blank>%s\\n" , failures , __FILE__ ) ; } return check_status ( failures ) ; } | <S2SV_ModStart> v ) ; failures += test_div_l ( v , "-13" , 6 , "-2" , "1" ) ; failures += test_div_l ( v , "600851475143" , 65521 , "9170364" , "55499" ) ; |
2,349 | CWE-000 static int ipv4_set_default_routes ( struct tunnel * tunnel ) { int ret ; struct rtentry * def_rt = & tunnel -> ipv4 . def_rt ; struct rtentry * gtw_rt = & tunnel -> ipv4 . gtw_rt ; struct rtentry * ppp_rt = & tunnel -> ipv4 . ppp_rt ; route_init ( def_rt ) ; route_init ( ppp_rt ) ; route_dest ( def_rt ) . s_addr = inet_addr ( "0.0.0.0" ) ; route_mask ( def_rt ) . s_addr = inet_addr ( "0.0.0.0" ) ; tunnel -> ipv4 . route_to_vpn_is_added = 1 ; ret = ipv4_get_route ( def_rt ) ; if ( ret != 0 ) { log_warn ( "Could<S2SV_blank>not<S2SV_blank>get<S2SV_blank>current<S2SV_blank>default<S2SV_blank>route<S2SV_blank>(%s).\\n" , err_ipv4_str ( ret ) ) ; goto err_destroy ; } memcpy ( gtw_rt , def_rt , sizeof ( * gtw_rt ) ) ; route_dest ( gtw_rt ) . s_addr = tunnel -> config -> gateway_ip . s_addr ; route_mask ( gtw_rt ) . s_addr = inet_addr ( "255.255.255.255" ) ; gtw_rt -> rt_flags |= RTF_HOST ; gtw_rt -> rt_metric = 0 ; log_debug ( "Setting<S2SV_blank>route<S2SV_blank>to<S2SV_blank>tunnel<S2SV_blank>gateway...\\n" ) ; ret = ipv4_set_route ( gtw_rt ) ; if ( ret == ERR_IPV4_SEE_ERRNO && errno == EEXIST ) log_warn ( "Route<S2SV_blank>to<S2SV_blank>gateway<S2SV_blank>exists<S2SV_blank>already.\\n" ) ; else if ( ret != 0 ) log_warn ( "Could<S2SV_blank>not<S2SV_blank>set<S2SV_blank>route<S2SV_blank>to<S2SV_blank>tunnel<S2SV_blank>gateway<S2SV_blank>(%s).\\n" , err_ipv4_str ( ret ) ) ; log_debug ( "Deleting<S2SV_blank>the<S2SV_blank>current<S2SV_blank>default<S2SV_blank>route...\\n" ) ; ret = ipv4_del_route ( def_rt ) ; if ( ret != 0 ) log_warn ( "Could<S2SV_blank>not<S2SV_blank>delete<S2SV_blank>the<S2SV_blank>current<S2SV_blank>default<S2SV_blank>route<S2SV_blank>(%s).\\n" , err_ipv4_str ( ret ) ) ; route_dest ( ppp_rt ) . s_addr = inet_addr ( "0.0.0.0" ) ; route_mask ( ppp_rt ) . s_addr = inet_addr ( "0.0.0.0" ) ; route_gtw ( ppp_rt ) . s_addr = inet_addr ( "0.0.0.0" ) ; strncpy ( route_iface ( ppp_rt ) , tunnel -> ppp_iface , ROUTE_IFACE_LEN - 1 ) ; log_debug ( "Setting<S2SV_blank>new<S2SV_blank>default<S2SV_blank>route...\\n" ) ; ret = ipv4_set_route ( ppp_rt ) ; if ( ret == ERR_IPV4_SEE_ERRNO && errno == EEXIST ) log_warn ( "Default<S2SV_blank>route<S2SV_blank>exists<S2SV_blank>already.\\n" ) ; else if ( ret != 0 ) log_warn ( "Could<S2SV_blank>not<S2SV_blank>set<S2SV_blank>the<S2SV_blank>new<S2SV_blank>default<S2SV_blank>route<S2SV_blank>(%s).\\n" , err_ipv4_str ( ret ) ) ; <S2SV_StartBug> return ret ; <S2SV_EndBug> err_destroy : route_destroy ( ppp_rt ) ; tunnel -> ipv4 . route_to_vpn_is_added = 0 ; return ret ; } | <S2SV_ModStart> ) ; return 0 <S2SV_ModEnd> ; err_destroy : |
2,350 | CWE-000 void lily_builtin_String_format ( lily_state * s ) { const char * fmt = lily_arg_string_raw ( s , 0 ) ; lily_container_val * lv = lily_arg_container ( s , 1 ) ; int lsize = lily_container_num_values ( lv ) ; <S2SV_StartBug> lily_msgbuf * msgbuf = lily_get_msgbuf ( s ) ; <S2SV_EndBug> int idx , last_idx = 0 ; while ( 1 ) { idx = char_index ( fmt , last_idx , '{' ) ; if ( idx > - 1 ) { if ( idx > last_idx ) lily_mb_add_slice ( msgbuf , fmt , last_idx , idx ) ; char ch ; int i , total = 0 ; int start = idx + 1 ; do { idx ++ ; ch = fmt [ idx ] ; } while ( ch == '0' ) ; for ( i = 0 ; i < 2 ; i ++ ) { if ( isdigit ( ch ) == 0 ) break ; total = ( total * 10 ) + ( ch - '0' ) ; idx ++ ; ch = fmt [ idx ] ; } if ( isdigit ( ch ) ) lily_ValueError ( s , "Format<S2SV_blank>must<S2SV_blank>be<S2SV_blank>between<S2SV_blank>0...99." ) ; else if ( start == idx ) lily_ValueError ( s , "Format<S2SV_blank>specifier<S2SV_blank>is<S2SV_blank>empty." ) ; else if ( ch != '}' ) lily_ValueError ( s , "Format<S2SV_blank>specifier<S2SV_blank>is<S2SV_blank>not<S2SV_blank>numeric." ) ; else if ( total >= lsize ) lily_IndexError ( s , "Format<S2SV_blank>specifier<S2SV_blank>is<S2SV_blank>too<S2SV_blank>large." ) ; idx ++ ; last_idx = idx ; lily_value * v = lily_nth_get ( lv , total ) ; lily_mb_add_value ( msgbuf , s , v ) ; } else { lily_mb_add_slice ( msgbuf , fmt , last_idx , strlen ( fmt ) ) ; break ; } } lily_return_string ( s , lily_new_string ( lily_mb_get ( msgbuf ) ) ) ; } | <S2SV_ModStart> * msgbuf = lily_get_clean_msgbuf <S2SV_ModEnd> ( s ) |
2,351 | CWE-000 static int update_cell ( t_map * map , int i , int j , int new_id ) { <S2SV_StartBug> if ( i < 0 || i >= map -> length || j < 0 || j >= map -> width ) <S2SV_EndBug> return ( 0 ) ; if ( map -> field [ i ] [ j ] != - 2 ) return ( 0 ) ; map -> field [ i ] [ j ] = new_id ; return ( 1 ) ; } | <S2SV_ModStart> map -> length ) return ( 0 ) ; if ( <S2SV_ModEnd> j < 0 |
2,352 | CWE-000 int sport_init_client ( struct service_port * sport , struct lsquic_engine * engine , struct event_base * eb ) { const struct sockaddr * sa_peer = ( struct sockaddr * ) & sport -> sas ; int saved_errno , s ; # ifndef WIN32 int flags ; # endif SOCKET_TYPE sockfd ; socklen_t socklen ; union { struct sockaddr_in sin ; struct sockaddr_in6 sin6 ; } u ; struct sockaddr * sa_local = ( struct sockaddr * ) & u ; char addr_str [ 0x20 ] ; switch ( sa_peer -> sa_family ) { case AF_INET : socklen = sizeof ( struct sockaddr_in ) ; u . sin . sin_family = AF_INET ; u . sin . sin_addr . s_addr = INADDR_ANY ; <S2SV_StartBug> u . sin . sin_port = local_port ; <S2SV_EndBug> break ; case AF_INET6 : socklen = sizeof ( struct sockaddr_in6 ) ; memset ( & u . sin6 , 0 , sizeof ( u . sin6 ) ) ; u . sin6 . sin6_family = AF_INET6 ; <S2SV_StartBug> u . sin6 . sin6_port = local_port ; <S2SV_EndBug> break ; default : errno = EINVAL ; return - 1 ; } # if WIN32 getExtensionPtrs ( ) ; # endif sockfd = socket ( sa_peer -> sa_family , SOCK_DGRAM , 0 ) ; if ( - 1 == sockfd ) return - 1 ; if ( 0 != bind ( sockfd , sa_local , socklen ) ) { saved_errno = errno ; CLOSE_SOCKET ( sockfd ) ; errno = saved_errno ; return - 1 ; } # ifndef WIN32 flags = fcntl ( sockfd , F_GETFL ) ; if ( - 1 == flags ) { saved_errno = errno ; CLOSE_SOCKET ( sockfd ) ; errno = saved_errno ; return - 1 ; } flags |= O_NONBLOCK ; if ( 0 != fcntl ( sockfd , F_SETFL , flags ) ) { saved_errno = errno ; CLOSE_SOCKET ( sockfd ) ; errno = saved_errno ; return - 1 ; } # else { u_long on = 1 ; ioctlsocket ( sockfd , FIONBIO , & on ) ; } # endif # if LSQUIC_DONTFRAG_SUPPORTED if ( sport -> sp_flags & SPORT_DONT_FRAGMENT ) { if ( AF_INET == sa_local -> sa_family ) { int on ; # if __linux__ on = IP_PMTUDISC_DO ; s = setsockopt ( sockfd , IPPROTO_IP , IP_MTU_DISCOVER , & on , sizeof ( on ) ) ; # elif WIN32 on = 1 ; s = setsockopt ( sockfd , IPPROTO_IP , IP_DONTFRAGMENT , ( char * ) & on , sizeof ( on ) ) ; # else on = 1 ; s = setsockopt ( sockfd , IPPROTO_IP , IP_DONTFRAG , & on , sizeof ( on ) ) ; # endif if ( 0 != s ) { saved_errno = errno ; CLOSE_SOCKET ( sockfd ) ; errno = saved_errno ; return - 1 ; } } } # endif if ( sport -> sp_flags & SPORT_SET_SNDBUF ) { s = setsockopt ( sockfd , SOL_SOCKET , SO_SNDBUF , CHAR_CAST & sport -> sp_sndbuf , sizeof ( sport -> sp_sndbuf ) ) ; if ( 0 != s ) { saved_errno = errno ; CLOSE_SOCKET ( sockfd ) ; errno = saved_errno ; return - 1 ; } } if ( sport -> sp_flags & SPORT_SET_RCVBUF ) { s = setsockopt ( sockfd , SOL_SOCKET , SO_RCVBUF , CHAR_CAST & sport -> sp_rcvbuf , sizeof ( sport -> sp_rcvbuf ) ) ; if ( 0 != s ) { saved_errno = errno ; CLOSE_SOCKET ( sockfd ) ; errno = saved_errno ; return - 1 ; } } if ( 0 != getsockname ( sockfd , sa_local , & socklen ) ) { saved_errno = errno ; CLOSE_SOCKET ( sockfd ) ; errno = saved_errno ; return - 1 ; } sport -> packs_in = allocate_packets_in ( sockfd ) ; if ( ! sport -> packs_in ) { saved_errno = errno ; CLOSE_SOCKET ( sockfd ) ; errno = saved_errno ; return - 1 ; } switch ( sa_local -> sa_family ) { case AF_INET : LSQ_DEBUG ( "local<S2SV_blank>address:<S2SV_blank>%s:%d" , inet_ntop ( AF_INET , & u . sin . sin_addr , addr_str , sizeof ( addr_str ) ) , ntohs ( u . sin . sin_port ) ) ; break ; } sport -> engine = engine ; sport -> fd = sockfd ; return add_to_event_loop ( sport , eb ) ; } | <S2SV_ModStart> . sin_port = htons ( local_port ) <S2SV_ModEnd> ; break ; <S2SV_ModStart> . sin6_port = htons ( local_port ) <S2SV_ModEnd> ; break ; |
2,353 | CWE-000 static void window_unload_handler ( Window * window ) { <S2SV_StartBug> s_edit_timer_field_num = 0 ; <S2SV_EndBug> s_timer_text_buffer [ 0 ] = '\\0' ; struct App_data * app_data = window_get_user_data ( window ) ; app_data_set_current_timer_index ( app_data , INVALID_INDEX ) ; text_layer_destroy ( s_timer_text_layer ) ; s_timer_text_layer = NULL ; window_destroy ( s_timer_edit_window ) ; s_timer_edit_window = NULL ; } | <S2SV_ModStart> window ) { <S2SV_ModEnd> text_layer_destroy ( s_timer_text_layer |
2,354 | CWE-000 static void dsa_dst_unapply ( struct dsa_switch_tree * dst ) { struct dsa_switch * ds ; u32 index ; if ( ! dst -> applied ) return ; dst -> master_netdev -> dsa_ptr = NULL ; wmb ( ) ; for ( index = 0 ; index < DSA_MAX_SWITCHES ; index ++ ) { ds = dst -> ds [ index ] ; if ( ! ds ) continue ; dsa_ds_unapply ( dst , ds ) ; } <S2SV_StartBug> if ( dst -> cpu_switch ) <S2SV_EndBug> <S2SV_StartBug> dsa_cpu_port_ethtool_restore ( dst -> cpu_switch ) ; <S2SV_EndBug> pr_info ( "DSA:<S2SV_blank>tree<S2SV_blank>%d<S2SV_blank>unapplied\\n" , dst -> tree ) ; dst -> applied = false ; } | <S2SV_ModStart> -> cpu_switch ) { <S2SV_ModStart> cpu_switch ) ; dst -> cpu_switch = NULL ; } |
2,355 | CWE-000 static void test_sema ( void ) { pthread_t newthread ; <S2SV_StartBug> pthread_attr_t attr ; <S2SV_EndBug> struct sched_param schedparam ; int schedpolicy = SCHED_FIFO ; int val , ret ; schedparam . priority = 1 ; ret = pthread_attr_init ( & attr ) ; if ( ret != 0 ) { zassert_false ( pthread_attr_destroy ( & attr ) , "Unable<S2SV_blank>to<S2SV_blank>destroy<S2SV_blank>pthread<S2SV_blank>object<S2SV_blank>attrib\\n" ) ; zassert_false ( pthread_attr_init ( & attr ) , "Unable<S2SV_blank>to<S2SV_blank>create<S2SV_blank>pthread<S2SV_blank>object<S2SV_blank>attrib\\n" ) ; } pthread_attr_setstack ( & attr , & stack , STACK_SIZE ) ; pthread_attr_setschedpolicy ( & attr , schedpolicy ) ; pthread_attr_setschedparam ( & attr , & schedparam ) ; zassert_equal ( sem_init ( & sema , 0 , ( CONFIG_SEM_VALUE_MAX + 1 ) ) , - 1 , "value<S2SV_blank>larger<S2SV_blank>than<S2SV_blank>%d\\n" , CONFIG_SEM_VALUE_MAX ) ; zassert_equal ( errno , EINVAL , NULL ) ; zassert_false ( sem_init ( & sema , 0 , 0 ) , "sem_init<S2SV_blank>failed\\n" ) ; zassert_equal ( sem_getvalue ( & sema , & val ) , 0 , NULL ) ; zassert_equal ( val , 0 , NULL ) ; pthread_create ( & newthread , & attr , foo_func , NULL ) ; zassert_false ( sem_wait ( & sema ) , "sem_wait<S2SV_blank>failed\\n" ) ; printk ( "Parent<S2SV_blank>thread<S2SV_blank>unlocked\\n" ) ; zassert_false ( sem_destroy ( & sema ) , "sema<S2SV_blank>is<S2SV_blank>not<S2SV_blank>destroyed\\n" ) ; } | <S2SV_ModStart> ; pthread_attr_t attr = { 0 } |
2,356 | CWE-000 int main ( int argc , char * argv [ ] ) { <S2SV_StartBug> init_all ( ) ; <S2SV_EndBug> for ( int i = 0 ; i < 100 ; ++ i ) { printf ( "\\n" ) ; } <S2SV_StartBug> practice_game * pg = calloc ( 1 , sizeof ( practice_game ) ) ; <S2SV_EndBug> int num_deals = 3 ; for ( int i = 0 ; i < num_deals ; ++ i ) { append_practice_deal ( pg , rand_piece ( ) ) ; } pg -> incoming = WIDTH * 5 ; pg -> delay = 20 ; for ( int i = 0 ; i < 1000 ; ++ i ) { <S2SV_StartBug> content_t choice = gcn_practice_policy ( pg , pg -> deals , num_deals ) ; <S2SV_EndBug> step_practice ( pg , pg -> deals [ 0 ] , choice ) ; print_practice ( pg ) ; if ( i % 30 == 29 ) { pg -> incoming = WIDTH * 5 ; pg -> delay = 28 ; } } return 0 ; } | <S2SV_ModStart> ) { init_all ( ) ; test_all <S2SV_ModStart> ) ; } game * g = new_game ( 2 , 3 ) <S2SV_ModEnd> ; for ( <S2SV_ModStart> ) { content_t choices [ 2 ] = { gcn_game_policy ( g , 0 ) , mc_game_policy ( g , 1 ) } ; step_game ( g , choices ) ; print_player ( g -> players ) ; print_player ( g -> players + 1 ) ; usleep ( 50000 ) ; <S2SV_ModEnd> } return 0 |
2,357 | CWE-000 bool huge_ralloc_no_move ( void * ptr , size_t oldsize , size_t size , size_t extra , bool zero ) { size_t usize ; if ( oldsize < chunksize ) return ( true ) ; assert ( s2u ( oldsize ) == oldsize ) ; usize = s2u ( size ) ; if ( usize == 0 ) { return ( true ) ; } if ( CHUNK_CEILING ( oldsize ) >= CHUNK_CEILING ( usize ) <S2SV_StartBug> && CHUNK_CEILING ( oldsize ) <= CHUNK_CEILING ( size + extra ) ) { <S2SV_EndBug> huge_ralloc_no_move_similar ( ptr , oldsize , usize , size , extra , zero ) ; return ( false ) ; } if ( CHUNK_CEILING ( oldsize ) >= CHUNK_CEILING ( usize ) ) { huge_ralloc_no_move_shrink ( ptr , oldsize , usize ) ; return ( false ) ; } if ( huge_ralloc_no_move_expand ( ptr , oldsize , size + extra , zero ) ) { if ( extra == 0 ) return ( true ) ; return ( huge_ralloc_no_move_expand ( ptr , oldsize , size , zero ) ) ; } return ( false ) ; } | <S2SV_ModStart> <= CHUNK_CEILING ( s2u ( <S2SV_ModStart> size + extra ) |
2,358 | CWE-000 size_t ue_communication_receive_sync ( ue_communication_context * context , void * connection , void * received_message ) { <S2SV_StartBug> size_t result ; <S2SV_EndBug> if ( ! context ) { ue_stacktrace_push_code ( UNKNOWNECHO_INVALID_PARAMETER ) ; return 0 ; } <S2SV_StartBug> if ( ( result = context -> communication_receive_sync_impl ( connection , received_message ) ) == 0 ) { <S2SV_EndBug> ue_stacktrace_push_msg ( "communication_receive_sync_impl()<S2SV_blank>returned<S2SV_blank>0.<S2SV_blank>The<S2SV_blank>communication<S2SV_blank>was<S2SV_blank>interrupted" ) ; } return result ; } | <S2SV_ModStart> received_message ) { <S2SV_ModEnd> if ( ! <S2SV_ModStart> 0 ; } return <S2SV_ModEnd> context -> communication_receive_sync_impl <S2SV_ModStart> , received_message ) <S2SV_ModEnd> ; } <S2SV_null> |
2,359 | CWE-000 s32 ixgbe_blink_led_start_generic ( struct ixgbe_hw * hw , u32 index ) { ixgbe_link_speed speed = 0 ; bool link_up = false ; u32 autoc_reg = IXGBE_READ_REG ( hw , IXGBE_AUTOC ) ; u32 led_reg = IXGBE_READ_REG ( hw , IXGBE_LEDCTL ) ; bool locked = false ; s32 ret_val ; <S2SV_StartBug> hw -> mac . ops . check_link ( hw , & speed , & link_up , false ) ; <S2SV_EndBug> if ( ! link_up ) { ret_val = hw -> mac . ops . prot_autoc_read ( hw , & locked , & autoc_reg ) ; if ( ret_val ) return ret_val ; autoc_reg |= IXGBE_AUTOC_AN_RESTART ; autoc_reg |= IXGBE_AUTOC_FLU ; ret_val = hw -> mac . ops . prot_autoc_write ( hw , autoc_reg , locked ) ; if ( ret_val ) return ret_val ; IXGBE_WRITE_FLUSH ( hw ) ; usleep_range ( 10000 , 20000 ) ; } led_reg &= ~ IXGBE_LED_MODE_MASK ( index ) ; led_reg |= IXGBE_LED_BLINK ( index ) ; IXGBE_WRITE_REG ( hw , IXGBE_LEDCTL , led_reg ) ; IXGBE_WRITE_FLUSH ( hw ) ; return 0 ; } | <S2SV_ModStart> s32 ret_val ; if ( index > 3 ) return IXGBE_ERR_PARAM ; |
2,360 | CWE-000 <S2SV_StartBug> const ep_t * ep_curve_get_tab ( ) { <S2SV_EndBug> # if defined ( EP_PRECO ) # if ALLOC == AUTO return ( const ep_t * ) * core_get ( ) -> ep_ptr ; # else return ( const ep_t * ) core_get ( ) -> ep_ptr ; # endif # else return NULL ; # endif } | <S2SV_ModStart> * ep_curve_get_tab ( void |
2,361 | CWE-000 static bool chunk_constraint_tuple_found ( TupleInfo * ti , void * data ) { ChunkConstraints * ccs = data ; <S2SV_StartBug> chunk_constraints_add_from_tuple ( ccs , ti -> tuple ) ; <S2SV_EndBug> return true ; } | <S2SV_ModStart> ccs , ti <S2SV_ModEnd> ) ; return |
2,362 | CWE-000 int udp_addpkt ( pkt_ptr pkt_queue , char * raw_addr , char * content , int size ) { <S2SV_StartBug> printf ( "udp_addpkt\\n" ) ; <S2SV_EndBug> int UDP = 3 ; char identification [ identification_length ] ; memset ( & identification , 0 , sizeof ( char ) * identification_length ) ; generate_identification ( identification , identification_length ) ; unsigned int offset = 0 ; unsigned int Data_fragmentation = 0 ; char tmp_content [ MAX_DATA_LENGTH ] ; char address [ Address_length ] ; <S2SV_StartBug> memset ( address , 0 , Address_length ) ; <S2SV_EndBug> int address_loc = 0 ; for ( int n = 0 ; n < 4 ; n ++ ) { int count = 0 ; unsigned char tmp [ 3 ] ; memset ( & tmp , 0 , sizeof ( char ) * 3 ) ; while ( count != 3 ) { if ( raw_addr [ address_loc ] == '.' ) { address_loc ++ ; break ; } else { tmp [ count ] = raw_addr [ address_loc ] ; count ++ ; address_loc ++ ; if ( address_loc >= strlen ( raw_addr ) ) break ; } } for ( int lo = 0 ; lo < 3 ; lo ++ ) { if ( ( 3 - count ) > lo ) address [ n * 3 + lo ] = '0' ; else { address [ n * 3 + lo ] = tmp [ lo - ( 3 - count ) ] ; } } if ( count == 3 ) address_loc ++ ; } memset ( & tmp_content , 0 , sizeof ( char ) * MAX_DATA_LENGTH ) ; for ( int loc = 0 ; loc < MAX_DATA_LENGTH ; loc ++ ) { tmp_content [ loc ] = content [ loc ] ; if ( ( loc + 1 ) == size ) break ; } addpkt ( pkt_queue , UDP , identification , Data_fragmentation , offset , address , tmp_content , MAX_DATA_LENGTH ) ; return 0 ; } | <S2SV_ModStart> size ) { const <S2SV_ModEnd> int UDP = <S2SV_ModStart> ; memset ( & |
2,363 | CWE-000 void ktf_debugfs_cleanup ( void ) { tlog ( T_DEBUG , "Removing<S2SV_blank>ktf<S2SV_blank>debugfs<S2SV_blank>dirs..." ) ; <S2SV_StartBug> if ( ktf_debugfs_cov_file ) <S2SV_EndBug> debugfs_remove ( ktf_debugfs_cov_file ) ; <S2SV_StartBug> if ( ktf_debugfs_rundir ) <S2SV_EndBug> debugfs_remove ( ktf_debugfs_rundir ) ; <S2SV_StartBug> if ( ktf_debugfs_resultsdir ) <S2SV_EndBug> debugfs_remove ( ktf_debugfs_resultsdir ) ; <S2SV_StartBug> if ( ktf_debugfs_rootdir ) <S2SV_EndBug> debugfs_remove ( ktf_debugfs_rootdir ) ; } | <S2SV_ModStart> "Removing<S2SV_blank>ktf<S2SV_blank>debugfs<S2SV_blank>dirs..." ) ; <S2SV_ModEnd> debugfs_remove ( ktf_debugfs_cov_file <S2SV_ModStart> ktf_debugfs_cov_file ) ; <S2SV_ModEnd> debugfs_remove ( ktf_debugfs_rundir <S2SV_ModStart> ktf_debugfs_rundir ) ; <S2SV_ModEnd> debugfs_remove ( ktf_debugfs_resultsdir <S2SV_ModStart> ktf_debugfs_resultsdir ) ; <S2SV_ModEnd> debugfs_remove ( ktf_debugfs_rootdir |
2,364 | CWE-000 void UpdatePosition ( void ) { update_shooter_flags ( ) ; if ( encoder1_2 . Alive == 0 ) { encoder1_2 . delta_count [ 0 ] = 0 ; encoder1_2 . delta_count [ 1 ] = 0 ; } <S2SV_StartBug> LencoderSum += ( int16_t ) encoder1_2 . delta_count [ 0 ] ; <S2SV_EndBug> RencoderSum += ( int16_t ) encoder1_2 . delta_count [ 1 ] ; <S2SV_StartBug> long long encoderSum = 0 ; <S2SV_EndBug> <S2SV_StartBug> if ( LencoderSum > RencoderSum + 3500 ) { <S2SV_EndBug> encoderSum = 2 * LencoderSum ; } <S2SV_StartBug> else if ( RencoderSum > LencoderSum + 3500 ) { <S2SV_EndBug> encoderSum = 2 * RencoderSum ; } else { encoderSum = LencoderSum + RencoderSum ; } <S2SV_StartBug> distanceSum = ( ( float ) encoderSum * 12000 / 682160 ) + xDistanceOffset ; <S2SV_EndBug> yDistance = ( long long ) ( M [ 6 ] . Board . EncoderCount - yEncoderOffset ) * 500 / 395473 ; <S2SV_StartBug> int LSpos = 1911 - LineSensor2016 [ 0 ] . position ; <S2SV_EndBug> Linesensor ( ) ; switch ( LSState ) { case 2 : break ; case - 2 : break ; case 1 : if ( LSpos > 0 ) { polezone ++ ; } else { polezone -- ; } break ; case - 1 : break ; default : break ; } } | <S2SV_ModStart> 0 ; } else { <S2SV_ModStart> 1 ] ; } <S2SV_ModEnd> if ( LencoderSum <S2SV_ModStart> > RencoderSum + 350 <S2SV_ModEnd> ) { encoderSum <S2SV_ModStart> > LencoderSum + 350 <S2SV_ModEnd> ) { encoderSum <S2SV_ModStart> ) encoderSum * 13000.0 / 667170 <S2SV_ModEnd> ) + xDistanceOffset <S2SV_ModStart> / 395473 ; debug_display [ 7 ] = encoderSum / 10000 ; debug_display [ 8 ] = encoderSum % 10000 ; |
2,365 | CWE-000 static void subtract ( matrix_type_t at , byte_t * ap , size_t as , matrix_type_t bt , byte_t * bp , size_t bs , matrix_type_t ct , byte_t * cp , size_t cs , size_t n , size_t m ) { if ( ( at == bt ) && ( bt == ct ) ) { # ifdef USE_GCC_VECTOR if ( is_aligned ( ap ) && is_aligned ( bp ) && is_aligned ( cp ) ) <S2SV_StartBug> mtv_subtract_ ( at , ap , as , bp , bs , cp , cs , n , m ) ; <S2SV_EndBug> else # endif <S2SV_StartBug> mt_subtract_ ( at , ap , as , bp , bs , cp , cs , n , m ) ; <S2SV_EndBug> } <S2SV_StartBug> else if ( element_is_float ( at ) || element_is_float ( bt ) || <S2SV_EndBug> element_is_float ( ct ) ) { size_t elem_size_a = element_size ( at ) ; size_t elem_size_b = element_size ( bt ) ; size_t elem_size_c = element_size ( ct ) ; while ( n -- ) { byte_t * ap1 = ap ; byte_t * bp1 = bp ; byte_t * cp1 = cp ; size_t m1 = m ; while ( m1 -- ) { float64_t a = read_float ( at , ap1 ) ; float64_t b = read_float ( bt , bp1 ) ; ap1 += elem_size_a ; bp1 += elem_size_b ; write_float ( ct , cp1 , a - b ) ; cp1 += elem_size_c ; } ap += as * elem_size_a ; bp += bs * elem_size_b ; cp += cs * elem_size_c ; } } <S2SV_StartBug> else { <S2SV_EndBug> size_t elem_size_a = element_size ( at ) ; size_t elem_size_b = element_size ( bt ) ; size_t elem_size_c = element_size ( ct ) ; while ( n -- ) { byte_t * ap1 = ap ; byte_t * bp1 = bp ; byte_t * cp1 = cp ; size_t m1 = m ; while ( m1 -- ) { int64_t a = read_int ( at , ap1 ) ; int64_t b = read_int ( bt , bp1 ) ; ap1 += elem_size_a ; bp1 += elem_size_b ; write_int ( ct , cp1 , a - b ) ; cp1 += elem_size_c ; } ap += as * elem_size_a ; bp += bs * elem_size_b ; cp += cs * elem_size_c ; } } } | <S2SV_ModStart> cp ) ) mtv_subtract <S2SV_ModEnd> ( at , <S2SV_ModStart> else # endif mt_subtract <S2SV_ModEnd> ( at , <S2SV_ModStart> ; } else { apply2 ( MINUS , at , ap , as , bt , bp , bs , ct , cp , cs , n , m ) <S2SV_ModEnd> ; } } <S2SV_ModStart> ; } } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
2,366 | CWE-000 static void virtio_gpu_resource_attach_backing ( VirtIOGPU * g , struct virtio_gpu_ctrl_command * cmd ) { struct virtio_gpu_simple_resource * res ; struct virtio_gpu_resource_attach_backing ab ; int ret ; VIRTIO_GPU_FILL_CMD ( ab ) ; trace_virtio_gpu_cmd_res_back_attach ( ab . resource_id ) ; res = virtio_gpu_find_resource ( g , ab . resource_id ) ; if ( ! res ) { qemu_log_mask ( LOG_GUEST_ERROR , "%s:<S2SV_blank>illegal<S2SV_blank>resource<S2SV_blank>specified<S2SV_blank>%d\\n" , __func__ , ab . resource_id ) ; cmd -> error = VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID ; return ; } <S2SV_StartBug> ret = virtio_gpu_create_mapping_iov ( & ab , cmd , & res -> addrs , & res -> iov ) ; <S2SV_EndBug> if ( ret != 0 ) { cmd -> error = VIRTIO_GPU_RESP_ERR_UNSPEC ; return ; } res -> iov_cnt = ab . nr_entries ; } | <S2SV_ModStart> return ; } if ( res -> iov ) { cmd -> error = VIRTIO_GPU_RESP_ERR_UNSPEC ; return ; } |
2,367 | CWE-000 <S2SV_StartBug> static inline unsigned int kgsl_iommu_sync_lock ( struct kgsl_mmu * mmu , <S2SV_EndBug> unsigned int * cmds ) { struct kgsl_device * device = mmu -> device ; struct adreno_device * adreno_dev = ADRENO_DEVICE ( device ) ; struct kgsl_iommu * iommu = mmu -> device -> mmu . priv ; struct remote_iommu_petersons_spinlock * lock_vars = iommu -> sync_lock_vars ; unsigned int * start = cmds ; if ( ! iommu -> sync_lock_initialized ) return 0 ; * cmds ++ = cp_type3_packet ( CP_MEM_WRITE , 2 ) ; * cmds ++ = lock_vars -> flag [ PROC_GPU ] ; * cmds ++ = 1 ; cmds += adreno_add_idle_cmds ( adreno_dev , cmds ) ; * cmds ++ = cp_type3_packet ( CP_WAIT_REG_MEM , 5 ) ; * cmds ++ = 0x13 ; * cmds ++ = lock_vars -> flag [ PROC_GPU ] ; * cmds ++ = 0x1 ; * cmds ++ = 0x1 ; * cmds ++ = 0x1 ; * cmds ++ = cp_type3_packet ( CP_SET_PROTECTED_MODE , 1 ) ; * cmds ++ = 0 ; * cmds ++ = cp_type3_packet ( CP_MEM_WRITE , 2 ) ; * cmds ++ = lock_vars -> turn ; * cmds ++ = 0 ; cmds += adreno_add_idle_cmds ( adreno_dev , cmds ) ; * cmds ++ = cp_type3_packet ( CP_WAIT_REG_MEM , 5 ) ; * cmds ++ = 0x13 ; * cmds ++ = lock_vars -> flag [ PROC_GPU ] ; * cmds ++ = 0x1 ; * cmds ++ = 0x1 ; * cmds ++ = 0x1 ; * cmds ++ = cp_type3_packet ( CP_SET_PROTECTED_MODE , 1 ) ; * cmds ++ = 0 ; * cmds ++ = cp_type3_packet ( CP_TEST_TWO_MEMS , 3 ) ; * cmds ++ = lock_vars -> flag [ PROC_APPS ] ; * cmds ++ = lock_vars -> turn ; * cmds ++ = 0 ; * cmds ++ = cp_type3_packet ( CP_SET_PROTECTED_MODE , 1 ) ; * cmds ++ = 0 ; cmds += adreno_add_idle_cmds ( adreno_dev , cmds ) ; return cmds - start ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> <S2SV_ModEnd> inline unsigned int |
2,368 | CWE-000 static void iousers_draw_machine_readable ( void * arg ) { conv_hash_t * hash = ( conv_hash_t * ) arg ; io_users_t * iu = ( io_users_t * ) hash -> user_data ; conv_item_t * iui ; guint64 last_frames , max_frames ; struct tm * tm_time ; guint i ; gboolean display_ports = ( ! strncmp ( iu -> type , "TCP" , 3 ) || ! strncmp ( iu -> type , "UDP" , 3 ) || ! strncmp ( iu -> type , "SCTP" , 4 ) ) ? TRUE : FALSE ; ; char null_string [ ] = "\\0" ; max_frames = UINT_MAX ; do { last_frames = 0 ; for ( i = 0 ; ( iu -> hash . conv_array && i < iu -> hash . conv_array -> len ) ; i ++ ) { guint64 tot_frames ; iui = & g_array_index ( iu -> hash . conv_array , conv_item_t , i ) ; tot_frames = iui -> rx_frames + iui -> tx_frames ; if ( ( tot_frames > last_frames ) && ( tot_frames < max_frames ) ) { last_frames = tot_frames ; } } for ( i = 0 ; ( iu -> hash . conv_array && i < iu -> hash . conv_array -> len ) ; i ++ ) { guint64 tot_frames ; char * src_addr , * dst_addr , * src_port , * dst_port , * src_name , * dst_name ; src_port = null_string ; dst_port = null_string ; iui = & g_array_index ( iu -> hash . conv_array , conv_item_t , i ) ; tot_frames = iui -> rx_frames + iui -> tx_frames ; if ( tot_frames == last_frames ) { src_name = get_conversation_address ( NULL , & iui -> src_address , TRUE ) ; dst_name = get_conversation_address ( NULL , & iui -> dst_address , TRUE ) ; src_addr = get_conversation_address ( NULL , & iui -> src_address , FALSE ) ; dst_addr = get_conversation_address ( NULL , & iui -> dst_address , FALSE ) ; if ( display_ports ) { src_port = get_conversation_port ( NULL , iui -> src_port , iui -> ptype , FALSE ) ; dst_port = get_conversation_port ( NULL , iui -> dst_port , iui -> ptype , FALSE ) ; } if ( strcmp ( src_name , src_addr ) == 0 ) { src_name = null_string ; } if ( strcmp ( dst_name , dst_addr ) == 0 ) { dst_name = null_string ; } printf ( "%s,%s,%s,%s,%s,%s,%s,%" G_GINT64_MODIFIER "u,%" G_GINT64_MODIFIER "u,%" G_GINT64_MODIFIER "u,%" G_GINT64_MODIFIER "u,%" G_GINT64_MODIFIER "u,%" G_GINT64_MODIFIER "u," , iu -> type , src_addr , src_name , src_port , dst_addr , dst_name , dst_port , iui -> rx_frames , iui -> rx_bytes , iui -> tx_frames , iui -> tx_bytes , iui -> tx_frames + iui -> rx_frames , iui -> tx_bytes + iui -> rx_bytes ) ; if ( display_ports ) { wmem_free ( NULL , src_port ) ; wmem_free ( NULL , dst_port ) ; } wmem_free ( NULL , src_addr ) ; wmem_free ( NULL , dst_addr ) ; tm_time = gmtime ( & iui -> start_abs_time . secs ) ; if ( tm_time != NULL ) { printf ( "%04d-%02d-%02d<S2SV_blank>%02d:%02d:%02d," , tm_time -> tm_year + 1900 , tm_time -> tm_mon + 1 , tm_time -> tm_mday , tm_time -> tm_hour , tm_time -> tm_min , tm_time -> tm_sec ) ; } else { printf ( "XXXX-XX-XX<S2SV_blank>XX:XX:XX," ) ; } printf ( "%f\\n" , nstime_to_sec ( & iui -> stop_time ) - nstime_to_sec ( & iui -> start_time ) ) ; } } max_frames = last_frames ; } while ( last_frames ) ; <S2SV_StartBug> printf ( "\\n" ) ; <S2SV_EndBug> } | <S2SV_ModStart> last_frames ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
2,369 | CWE-000 void resolve_offers ( Market * m ) { int i , j ; int g ; float quantity ; float price ; double total_price , total_quantity ; Bid * top_bid ; Ask * top_ask ; for ( g = 0 ; g < NUM_GOODS ; g ++ ) { qsort ( m -> bids [ g ] , m -> num_bids [ g ] , sizeof ( Bid * ) , cmp_bid ) ; qsort ( m -> asks [ g ] , m -> num_asks [ g ] , sizeof ( Ask * ) , cmp_ask ) ; total_price = 0.0 ; total_quantity = 0.0 ; for ( i = j = 0 ; i < m -> num_bids [ g ] && j < m -> num_asks [ g ] ; ) { top_bid = m -> bids [ g ] [ i ] ; <S2SV_StartBug> top_bid -> status = UNSUCCESSFUL ; <S2SV_EndBug> top_ask = m -> asks [ g ] [ j ] ; <S2SV_StartBug> top_ask -> status = UNSUCCESSFUL ; <S2SV_EndBug> price = ( top_bid -> price + top_ask -> price ) / 2.0 ; quantity = MIN2 ( MIN2 ( top_bid -> quantity , top_ask -> quantity ) , top_bid -> agent -> currency / price ) ; total_price += price * quantity ; total_quantity += quantity ; if ( top_bid -> quantity < top_ask -> quantity ) { top_ask -> quantity -= top_bid -> quantity ; top_bid -> quantity = 0.0 ; } else if ( top_bid -> quantity > top_ask -> quantity ) { top_bid -> quantity -= top_ask -> quantity ; top_ask -> quantity = 0.0 ; } else { top_bid -> quantity = 0.0 ; top_ask -> quantity = 0.0 ; } top_bid -> agent -> good_quantity [ g ] += quantity ; top_ask -> agent -> good_quantity [ g ] -= quantity ; top_bid -> agent -> currency -= price * quantity ; top_ask -> agent -> currency += price * quantity ; update_price_model ( top_bid -> agent , g , price , TRADE_SUCCESS ) ; update_price_model ( top_ask -> agent , g , price , TRADE_SUCCESS ) ; if ( top_bid -> quantity == 0.0 ) { i ++ ; } if ( top_ask -> quantity == 0.0 ) { j ++ ; } } if ( total_quantity != 0 ) { m -> mean [ g ] = ( m -> mean [ g ] * ( MEAN_ROLLING_AVG - 1 ) + total_price / total_quantity ) / MEAN_ROLLING_AVG ; } while ( i < m -> num_bids [ g ] ) { top_bid = m -> bids [ g ] [ i ] ; if ( top_bid -> status != SUCCESSFUL ) { top_bid -> status = UNSUCCESSFUL ; } update_price_model ( top_bid -> agent , g , m -> mean [ g ] , TRADE_FAILURE ) ; i ++ ; } while ( j < m -> num_asks [ g ] ) { top_ask = m -> asks [ g ] [ j ] ; if ( top_ask -> status != SUCCESSFUL ) { top_ask -> status = UNSUCCESSFUL ; } update_price_model ( top_ask -> agent , g , m -> mean [ g ] , TRADE_FAILURE ) ; j ++ ; } } } | <S2SV_ModStart> -> status = SUCCESSFUL <S2SV_ModEnd> ; top_ask = <S2SV_ModStart> -> status = SUCCESSFUL <S2SV_ModEnd> ; price = |
2,370 | CWE-000 static int block_free_internal ( int block_index , int close_fd , int deregister ) { int proc_index ; ishm_block_t * block ; int last ; int ret = 0 ; if ( ( block_index < 0 ) || ( block_index >= ISHM_MAX_NB_BLOCKS ) || ( ishm_tbl -> block [ block_index ] . len == 0 ) ) { ODP_ERR ( "Request<S2SV_blank>to<S2SV_blank>free<S2SV_blank>an<S2SV_blank>invalid<S2SV_blank>block\\n" ) ; return - 1 ; } block = & ishm_tbl -> block [ block_index ] ; proc_index = procfind_block ( block_index ) ; if ( proc_index >= 0 ) { do_unmap ( ishm_proctable -> entry [ proc_index ] . start , block -> len , ishm_proctable -> entry [ proc_index ] . flags , block_index ) ; <S2SV_StartBug> if ( close_fd ) <S2SV_EndBug> close ( ishm_proctable -> entry [ proc_index ] . fd ) ; last = ishm_proctable -> nb_entries - 1 ; ishm_proctable -> entry [ proc_index ] = ishm_proctable -> entry [ last ] ; ishm_proctable -> nb_entries = last ; } else { do_unmap ( NULL , 0 , block -> flags , block_index ) ; } if ( close_fd ) delete_file ( block ) ; if ( deregister ) ret = _odp_fdserver_deregister_fd ( FD_SRV_CTX_ISHM , block_index ) ; block -> len = 0 ; block -> seq ++ ; return ret ; } | <S2SV_ModStart> ( close_fd ) { int fd = ishm_proctable -> entry [ proc_index ] . fd ; if ( block -> huge == CACHED ) hp_put_cached ( fd ) ; else close ( fd ) ; } <S2SV_ModEnd> last = ishm_proctable |
2,371 | CWE-000 static int ast_i2c_xfer ( struct i2c_adapter * adap , struct i2c_msg * msgs , int num ) { struct ast_i2c_dev * i2c_dev = adap -> algo_data ; int ret , i ; int sts ; sts = ast_i2c_read ( i2c_dev , I2C_CMD_REG ) ; dev_dbg ( i2c_dev -> dev , "state[%x],SCL[%d],SDA[%d],BUS[%d]\\n" , ( sts >> 19 ) & 0xf , ( sts >> 18 ) & 0x1 , ( sts >> 17 ) & 0x1 , ( sts >> 16 ) & 1 ) ; ret = ast_i2c_wait_bus_not_busy ( i2c_dev ) ; if ( ret ) { dev_err ( & i2c_dev -> adap . dev , "i2c_ast:<S2SV_blank>timeout<S2SV_blank>waiting<S2SV_blank>for<S2SV_blank>bus<S2SV_blank>free\\n" ) ; goto out ; } for ( i = adap -> retries ; i >= 0 ; i -- ) { ret = ast_i2c_do_msgs_xfer ( i2c_dev , msgs , num ) ; <S2SV_StartBug> if ( ret != - EAGAIN ) <S2SV_EndBug> goto out ; dev_dbg ( & i2c_dev -> adap . dev , "Retrying<S2SV_blank>transmission<S2SV_blank>[%d]\\n" , i ) ; udelay ( 100 ) ; } ret = - EREMOTEIO ; out : return ret ; } | <S2SV_ModStart> ; if ( ( i <= 0 ) || ( <S2SV_ModStart> - EAGAIN ) ) |
2,372 | CWE-000 int main ( int argc , char * argv [ ] ) { if ( argc < 2 ) { fprintf ( stderr , "Use:<S2SV_blank>vcc<S2SV_blank>[flags]<S2SV_blank>[arquivo1.tpp<S2SV_blank>arquivo2.tpp<S2SV_blank>...]\\n" ) ; return 1 ; } separaArquivosFlags ( argc , argv ) ; char i = 0 ; while ( arquivos [ i ] ) { if ( openFile ( arquivos [ i ] ) == '1' ) { return 1 ; } TR * primeiro = getToken ( ) ; TR * token = primeiro ; while ( token -> tokenval != EOFU ) { token -> proximo = ( struct TokenRecord * ) getToken ( ) ; token = ( TR * ) token -> proximo ; } <S2SV_StartBug> if ( flags [ 0 ] ) { <S2SV_EndBug> <S2SV_StartBug> token = primeiro ; <S2SV_EndBug> printf ( "Arquivo:<S2SV_blank>%s.\\n" , arquivos [ i ] ) ; do { printToken ( token , 1 , 1 ) ; token = ( TR * ) token -> proximo ; } while ( token -> tokenval != EOFU ) ; printf ( "\\n" ) ; } TreeNode * ast = parse ( arquivos [ i ] , primeiro ) ; if ( flags [ 1 ] ) printArvoreX ( ast , arquivos [ i ] , 0 ) ; if ( flags [ 2 ] ) <S2SV_StartBug> printArvoreT ( ast , arquivos [ i ] ) ; <S2SV_EndBug> TreeNode * st = podar ( ast ) ; if ( flags [ 3 ] ) printArvoreX ( st , arquivos [ i ] , 1 ) ; if ( flags [ 4 ] ) printArvoreT ( st , arquivos [ i ] ) ; i ++ ; } if ( flags [ 5 ] ) { printHelp ( ) ; } return 0 ; } | <S2SV_ModStart> proximo ; } printf ( "ARQUIVO:<S2SV_blank>%s.\\n" , arquivos [ i ] ) ; <S2SV_ModStart> token = primeiro <S2SV_ModEnd> ; do { <S2SV_ModStart> printArvoreT ( ast <S2SV_ModEnd> ) ; TreeNode |
2,373 | CWE-000 mpplaylist * appendToPL ( mptitle * title , mpplaylist * pl ) { <S2SV_StartBug> if ( pl != NULL ) { <S2SV_EndBug> <S2SV_StartBug> while ( pl -> next != NULL ) { <S2SV_EndBug> <S2SV_StartBug> pl = pl -> next ; <S2SV_EndBug> } <S2SV_StartBug> addToPL ( title , pl ) ; <S2SV_EndBug> } else { pl = addToPL ( title , NULL ) ; } return pl ; } | <S2SV_ModStart> pl ) { mpplaylist * runner = pl ; if ( runner <S2SV_ModEnd> != NULL ) <S2SV_ModStart> { while ( runner <S2SV_ModEnd> -> next != <S2SV_ModStart> NULL ) { runner = runner <S2SV_ModEnd> -> next ; <S2SV_ModStart> ( title , runner <S2SV_ModEnd> ) ; } |
2,374 | CWE-000 int32_t mcp23017_set_pin_direction ( const uint8_t pin_num , const uint8_t direction ) { int32_t r ; <S2SV_StartBug> uint8_t reg , value , pos , old , new , enable_pullup ; <S2SV_EndBug> enable_pullup = 0 ; switch ( direction ) { case INPUT_PULLUP : enable_pullup = 1 ; case INPUT : value = 1 ; break ; case OUTPUT : value = 0 ; break ; default : r = EINVAL ; goto fail ; } reg = pin_num < 8 ? MCP23x17_IODIR : MCP23x17_IODIR + 1 ; pos = pin_num < 8 ? pin_num : pin_num - 8 ; if ( ( r = mcp23017_read8 ( reg , & old ) ) != 0 ) { goto fail ; } <S2SV_StartBug> new = bit_write8 ( old , pos , value ) ; <S2SV_EndBug> <S2SV_StartBug> if ( new != old ) { <S2SV_EndBug> <S2SV_StartBug> if ( ( r = mcp23017_write8 ( reg , new ) ) != 0 ) { <S2SV_EndBug> goto fail ; } } if ( enable_pullup == 1 ) { if ( ( r = mcp23017_enable_pullup ( pin_num ) ) != 0 ) { goto fail ; } } fail : return r ; } | <S2SV_ModStart> , old , new_value <S2SV_ModEnd> , enable_pullup ; <S2SV_ModStart> fail ; } new_value <S2SV_ModEnd> = bit_write8 ( <S2SV_ModStart> ; if ( new_value <S2SV_ModEnd> != old ) <S2SV_ModStart> ( reg , new_value <S2SV_ModEnd> ) ) != |
2,375 | CWE-000 static int handle_response_icmp ( int af , struct sk_buff * skb , union nf_inet_addr * snet , __u8 protocol , struct ip_vs_conn * cp , struct ip_vs_protocol * pp , <S2SV_StartBug> unsigned int offset , unsigned int ihl ) <S2SV_EndBug> { unsigned int verdict = NF_DROP ; if ( IP_VS_FWD_METHOD ( cp ) != 0 ) { pr_err ( "shouldn\'t<S2SV_blank>reach<S2SV_blank>here,<S2SV_blank>because<S2SV_blank>the<S2SV_blank>box<S2SV_blank>is<S2SV_blank>on<S2SV_blank>the<S2SV_blank>" "half<S2SV_blank>connection<S2SV_blank>in<S2SV_blank>the<S2SV_blank>tun/dr<S2SV_blank>module.\\n" ) ; } if ( ! skb_csum_unnecessary ( skb ) && ip_vs_checksum_complete ( skb , ihl ) ) { IP_VS_DBG_BUF ( 1 , "Forward<S2SV_blank>ICMP:<S2SV_blank>failed<S2SV_blank>checksum<S2SV_blank>from<S2SV_blank>%s!\\n" , IP_VS_DBG_ADDR ( af , snet ) ) ; goto out ; } if ( IPPROTO_TCP == protocol || IPPROTO_UDP == protocol || IPPROTO_SCTP == protocol ) offset += 2 * sizeof ( __u16 ) ; if ( ! skb_make_writable ( skb , offset ) ) goto out ; # ifdef CONFIG_IP_VS_IPV6 if ( af == AF_INET6 ) ip_vs_nat_icmp_v6 ( skb , pp , cp , 1 ) ; else # endif ip_vs_nat_icmp ( skb , pp , cp , 1 ) ; <S2SV_StartBug> if ( ip_vs_route_me_harder ( af , skb ) ) <S2SV_EndBug> goto out ; ip_vs_out_stats ( cp , skb ) ; skb -> ipvs_property = 1 ; if ( ! ( cp -> flags & IP_VS_CONN_F_NFCT ) ) ip_vs_notrack ( skb ) ; else ip_vs_update_conntrack ( skb , cp , 0 ) ; verdict = NF_ACCEPT ; out : __ip_vs_conn_put ( cp ) ; return verdict ; } | <S2SV_ModStart> unsigned int ihl , unsigned int hooknum <S2SV_ModStart> af , skb , hooknum |
2,376 | CWE-000 static void __attribute__ ( ( __noreturn__ ) ) usage ( FILE * out ) { fputs ( USAGE_HEADER , out ) ; fprintf ( out , _ ( "<S2SV_blank>%1$s<S2SV_blank>[options]<S2SV_blank><dev><S2SV_blank>[[-N]<S2SV_blank><part>]\\n" "<S2SV_blank>%1$s<S2SV_blank>[options]<S2SV_blank><command>\\n" ) , program_invocation_short_name ) ; fputs ( USAGE_SEPARATOR , out ) ; fputs ( _ ( "Display<S2SV_blank>or<S2SV_blank>manipulate<S2SV_blank>a<S2SV_blank>disk<S2SV_blank>partition<S2SV_blank>table.\\n" ) , out ) ; fputs ( _ ( "\\nCommands:\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank>-A,<S2SV_blank>--activate<S2SV_blank><dev><S2SV_blank>[<part><S2SV_blank>...]<S2SV_blank>list<S2SV_blank>or<S2SV_blank>set<S2SV_blank>bootable<S2SV_blank>MBR<S2SV_blank>partitions\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank>-d,<S2SV_blank>--dump<S2SV_blank><dev><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>dump<S2SV_blank>partition<S2SV_blank>table<S2SV_blank>(usable<S2SV_blank>for<S2SV_blank>later<S2SV_blank>input)\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank>-J,<S2SV_blank>--json<S2SV_blank><dev><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>dump<S2SV_blank>partition<S2SV_blank>table<S2SV_blank>in<S2SV_blank>JSON<S2SV_blank>format\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank>-g,<S2SV_blank>--show-geometry<S2SV_blank>[<dev><S2SV_blank>...]<S2SV_blank><S2SV_blank><S2SV_blank>list<S2SV_blank>geometry<S2SV_blank>of<S2SV_blank>all<S2SV_blank>or<S2SV_blank>specified<S2SV_blank>devices\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank>-l,<S2SV_blank>--list<S2SV_blank>[<dev><S2SV_blank>...]<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>list<S2SV_blank>partitions<S2SV_blank>of<S2SV_blank>each<S2SV_blank>device\\n" ) , out ) ; <S2SV_StartBug> fputs ( _ ( "<S2SV_blank>-F,<S2SV_blank>--list-free<S2SV_blank>[<dev><S2SV_blank>...]<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>list<S2SV_blank>unpartitions<S2SV_blank>free<S2SV_blank>areas<S2SV_blank>of<S2SV_blank>each<S2SV_blank>device\\n" ) , out ) ; <S2SV_EndBug> fputs ( _ ( "<S2SV_blank>-r,<S2SV_blank>--reorder<S2SV_blank><dev><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>fix<S2SV_blank>partitions<S2SV_blank>order<S2SV_blank>(by<S2SV_blank>start<S2SV_blank>offset)\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank>-s,<S2SV_blank>--show-size<S2SV_blank>[<dev><S2SV_blank>...]<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>list<S2SV_blank>sizes<S2SV_blank>of<S2SV_blank>all<S2SV_blank>or<S2SV_blank>specified<S2SV_blank>devices\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank>-T,<S2SV_blank>--list-types<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>print<S2SV_blank>the<S2SV_blank>recognized<S2SV_blank>types<S2SV_blank>(see<S2SV_blank>-X)\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank>-V,<S2SV_blank>--verify<S2SV_blank>[<dev><S2SV_blank>...]<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>test<S2SV_blank>whether<S2SV_blank>partitions<S2SV_blank>seem<S2SV_blank>correct\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--delete<S2SV_blank><dev><S2SV_blank>[<part><S2SV_blank>...]<S2SV_blank><S2SV_blank><S2SV_blank>delete<S2SV_blank>all<S2SV_blank>or<S2SV_blank>specified<S2SV_blank>partitions\\n" ) , out ) ; fputs ( USAGE_SEPARATOR , out ) ; fputs ( _ ( "<S2SV_blank>--part-label<S2SV_blank><dev><S2SV_blank><part><S2SV_blank>[<str>]<S2SV_blank>print<S2SV_blank>or<S2SV_blank>change<S2SV_blank>partition<S2SV_blank>label\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank>--part-type<S2SV_blank><dev><S2SV_blank><part><S2SV_blank>[<type>]<S2SV_blank>print<S2SV_blank>or<S2SV_blank>change<S2SV_blank>partition<S2SV_blank>type\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank>--part-uuid<S2SV_blank><dev><S2SV_blank><part><S2SV_blank>[<uuid>]<S2SV_blank>print<S2SV_blank>or<S2SV_blank>change<S2SV_blank>partition<S2SV_blank>uuid\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank>--part-attrs<S2SV_blank><dev><S2SV_blank><part><S2SV_blank>[<str>]<S2SV_blank>print<S2SV_blank>or<S2SV_blank>change<S2SV_blank>partition<S2SV_blank>attributes\\n" ) , out ) ; fputs ( USAGE_SEPARATOR , out ) ; fputs ( _ ( "<S2SV_blank><dev><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>device<S2SV_blank>(usually<S2SV_blank>disk)<S2SV_blank>path\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank><part><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>partition<S2SV_blank>number\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank><type><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>partition<S2SV_blank>type,<S2SV_blank>GUID<S2SV_blank>for<S2SV_blank>GPT,<S2SV_blank>hex<S2SV_blank>for<S2SV_blank>MBR\\n" ) , out ) ; fputs ( USAGE_OPTIONS , out ) ; fputs ( _ ( "<S2SV_blank>-a,<S2SV_blank>--append<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>append<S2SV_blank>partitions<S2SV_blank>to<S2SV_blank>existing<S2SV_blank>partition<S2SV_blank>table\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank>-b,<S2SV_blank>--backup<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>backup<S2SV_blank>partition<S2SV_blank>table<S2SV_blank>sectors<S2SV_blank>(see<S2SV_blank>-O)\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--bytes<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>print<S2SV_blank>SIZE<S2SV_blank>in<S2SV_blank>bytes<S2SV_blank>rather<S2SV_blank>than<S2SV_blank>in<S2SV_blank>human<S2SV_blank>readable<S2SV_blank>format\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--move-data[=<typescript>]<S2SV_blank>move<S2SV_blank>partition<S2SV_blank>data<S2SV_blank>after<S2SV_blank>relocation<S2SV_blank>(requires<S2SV_blank>-N)\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank>-f,<S2SV_blank>--force<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>disable<S2SV_blank>all<S2SV_blank>consistency<S2SV_blank>checking\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--color[=<when>]<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>colorize<S2SV_blank>output<S2SV_blank>(auto,<S2SV_blank>always<S2SV_blank>or<S2SV_blank>never)\\n" ) , out ) ; fprintf ( out , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%s\\n" , USAGE_COLORS_DEFAULT ) ; fputs ( _ ( "<S2SV_blank>-N,<S2SV_blank>--partno<S2SV_blank><num><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>specify<S2SV_blank>partition<S2SV_blank>number\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank>-n,<S2SV_blank>--no-act<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>do<S2SV_blank>everything<S2SV_blank>except<S2SV_blank>write<S2SV_blank>to<S2SV_blank>device\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--no-reread<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>do<S2SV_blank>not<S2SV_blank>check<S2SV_blank>whether<S2SV_blank>the<S2SV_blank>device<S2SV_blank>is<S2SV_blank>in<S2SV_blank>use\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank>-O,<S2SV_blank>--backup-file<S2SV_blank><path><S2SV_blank><S2SV_blank>override<S2SV_blank>default<S2SV_blank>backup<S2SV_blank>file<S2SV_blank>name\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank>-o,<S2SV_blank>--output<S2SV_blank><list><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>output<S2SV_blank>columns\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank>-q,<S2SV_blank>--quiet<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>suppress<S2SV_blank>extra<S2SV_blank>info<S2SV_blank>messages\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank>-w,<S2SV_blank>--wipe<S2SV_blank><mode><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>wipe<S2SV_blank>signatures<S2SV_blank>(auto,<S2SV_blank>always<S2SV_blank>or<S2SV_blank>never)\\n" ) , out ) ; <S2SV_StartBug> fputs ( _ ( "<S2SV_blank>-W,<S2SV_blank>--wipe-partitons<S2SV_blank><mode><S2SV_blank><S2SV_blank>wipe<S2SV_blank>signatures<S2SV_blank>from<S2SV_blank>new<S2SV_blank>partitions<S2SV_blank>(auto,<S2SV_blank>always<S2SV_blank>or<S2SV_blank>never)\\n" ) , out ) ; <S2SV_EndBug> fputs ( _ ( "<S2SV_blank>-X,<S2SV_blank>--label<S2SV_blank><name><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>specify<S2SV_blank>label<S2SV_blank>type<S2SV_blank>(dos,<S2SV_blank>gpt,<S2SV_blank>...)\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank>-Y,<S2SV_blank>--label-nested<S2SV_blank><name><S2SV_blank>specify<S2SV_blank>nested<S2SV_blank>label<S2SV_blank>type<S2SV_blank>(dos,<S2SV_blank>bsd)\\n" ) , out ) ; fputs ( USAGE_SEPARATOR , out ) ; fputs ( _ ( "<S2SV_blank>-L,<S2SV_blank>--Linux<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>deprecated,<S2SV_blank>only<S2SV_blank>for<S2SV_blank>backward<S2SV_blank>compatibility\\n" ) , out ) ; fputs ( _ ( "<S2SV_blank>-u,<S2SV_blank>--unit<S2SV_blank>S<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>deprecated,<S2SV_blank>only<S2SV_blank>sector<S2SV_blank>unit<S2SV_blank>is<S2SV_blank>supported\\n" ) , out ) ; fputs ( USAGE_SEPARATOR , out ) ; fputs ( USAGE_HELP , out ) ; fputs ( _ ( "<S2SV_blank>-v,<S2SV_blank>--version<S2SV_blank><S2SV_blank>output<S2SV_blank>version<S2SV_blank>information<S2SV_blank>and<S2SV_blank>exit\\n" ) , out ) ; list_available_columns ( out ) ; fprintf ( out , USAGE_MAN_TAIL ( "sfdisk(8)" ) ) ; exit ( out == stderr ? EXIT_FAILURE : EXIT_SUCCESS ) ; } | <S2SV_ModStart> ( _ ( "<S2SV_blank>-F,<S2SV_blank>--list-free<S2SV_blank>[<dev><S2SV_blank>...]<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>list<S2SV_blank>unpartitioned<S2SV_blank>free<S2SV_blank>areas<S2SV_blank>of<S2SV_blank>each<S2SV_blank>device\\n" <S2SV_ModEnd> ) , out <S2SV_ModStart> ( _ ( "<S2SV_blank>-W,<S2SV_blank>--wipe-partitions<S2SV_blank><mode><S2SV_blank><S2SV_blank>wipe<S2SV_blank>signatures<S2SV_blank>from<S2SV_blank>new<S2SV_blank>partitions<S2SV_blank>(auto,<S2SV_blank>always<S2SV_blank>or<S2SV_blank>never)\\n" <S2SV_ModEnd> ) , out |
2,377 | CWE-000 static int tfw_cfgop_in_sched ( TfwCfgSpec * cs , TfwCfgEntry * ce ) <S2SV_StartBug> { <S2SV_EndBug> tfw_cfg_schref = & tfw_cfg_schref_predict ; return tfw_cfgop_sched ( cs , ce , & tfw_cfg_sched , tfw_cfg_schref , & tfw_cfg_sg_flags ) ; } | <S2SV_ModStart> ce ) { if ( TFW_CFGOP_HAS_DFLT ( ce , sched ) ) { tfw_cfg_sched = tfw_cfg_out_sched ; tfw_cfg_schref = tfw_cfg_out_schref ; tfw_cfg_sg_flags = tfw_cfg_out_sg_flags ; return 0 ; } |
2,378 | CWE-000 static struct _sii_stdconfig * parse_config ( xmlNode * root ) { xmlNode * n , * tmp ; <S2SV_StartBug> struct _sii_stdconfig * sc = malloc ( sizeof ( struct _sii_stdconfig ) ) ; <S2SV_EndBug> <S2SV_StartBug> memset ( sc , 0 , sizeof ( struct _sii_stdconfig ) ) ; <S2SV_EndBug> n = search_node ( root , "Vendor" ) ; if ( n == NULL ) { free ( sc ) ; return NULL ; } tmp = search_node ( n , "Id" ) ; sscanf ( ( const char * ) tmp -> children -> content , "#x%x" , & ( sc -> vendor_id ) ) ; n = search_node ( search_node ( root , "Devices" ) , "Device" ) ; tmp = search_node ( n , "Type" ) ; xmlAttr * prop = tmp -> properties ; while ( prop != NULL ) { if ( xmlStrncmp ( prop -> name , Char2xmlChar ( "ProductCode" ) , xmlStrlen ( prop -> name ) ) == 0 ) { sscanf ( ( const char * ) prop -> children -> content , "#x%x" , & ( sc -> product_id ) ) ; } if ( xmlStrncmp ( prop -> name , Char2xmlChar ( "RevisionNo" ) , xmlStrlen ( prop -> name ) ) == 0 ) { sscanf ( ( const char * ) prop -> children -> content , "#x%x" , & ( sc -> revision_id ) ) ; } prop = prop -> next ; } sc -> serial = 0 ; sc -> bs_rec_mbox_offset = 0 ; sc -> bs_rec_mbox_size = 0 ; sc -> bs_snd_mbox_offset = 0 ; sc -> bs_snd_mbox_size = 0 ; sc -> std_rec_mbox_offset = 0x1000 ; sc -> std_rec_mbox_size = 128 ; sc -> std_snd_mbox_offset = 0x1080 ; sc -> std_snd_mbox_size = 128 ; tmp = n -> children ; while ( tmp != NULL ) { if ( xmlStrncmp ( tmp -> name , Char2xmlChar ( "Sm" ) , xmlStrlen ( tmp -> name ) ) == 0 ) { xmlNode * smchild = tmp -> children ; while ( smchild != NULL ) { if ( xmlStrncmp ( smchild -> content , Char2xmlChar ( "MBoxOut" ) , xmlStrlen ( smchild -> content ) ) == 0 ) { xmlAttr * p = tmp -> properties ; while ( p != NULL ) { if ( xmlStrncmp ( p -> name , Char2xmlChar ( "DefaultSize" ) , xmlStrlen ( p -> name ) ) == 0 ) { sc -> std_rec_mbox_size = ( uint16_t ) atoi ( ( const char * ) p -> children -> content ) ; } if ( xmlStrncmp ( p -> name , Char2xmlChar ( "StartAddress" ) , xmlStrlen ( p -> name ) ) == 0 ) { unsigned int atmp = 0 ; sscanf ( ( const char * ) p -> children -> content , "#x%x" , & atmp ) ; sc -> std_rec_mbox_offset = atmp ; } p = p -> next ; } } if ( xmlStrncmp ( smchild -> content , Char2xmlChar ( "MBoxIn" ) , xmlStrlen ( smchild -> content ) ) == 0 ) { xmlAttr * p = tmp -> properties ; while ( p != NULL ) { if ( xmlStrncmp ( p -> name , Char2xmlChar ( "DefaultSize" ) , xmlStrlen ( p -> name ) ) == 0 ) { sc -> std_snd_mbox_size = ( uint16_t ) atoi ( ( const char * ) p -> children -> content ) ; } if ( xmlStrncmp ( p -> name , Char2xmlChar ( "StartAddress" ) , xmlStrlen ( p -> name ) ) == 0 ) { unsigned int atmp = 0 ; sscanf ( ( const char * ) p -> children -> content , "#x%x" , & atmp ) ; sc -> std_snd_mbox_offset = atmp ; } p = p -> next ; } } smchild = smchild -> next ; } } tmp = tmp -> next ; } tmp = search_node ( n , "Mailbox" ) ; xmlNode * mbox ; mbox = search_node ( tmp , "CoE" ) ; if ( mbox != NULL ) sc -> mailbox_protocol . bit . coe = 1 ; mbox = search_node ( tmp , "EoE" ) ; if ( mbox != NULL ) sc -> mailbox_protocol . bit . eoe = 1 ; mbox = search_node ( tmp , "FoE" ) ; if ( mbox != NULL ) sc -> mailbox_protocol . bit . foe = 1 ; mbox = search_node ( tmp , "VoE" ) ; if ( mbox != NULL ) sc -> mailbox_protocol . bit . voe = 1 ; tmp = search_node ( n , "ByteSize" ) ; sc -> eeprom_size = atoi ( ( char * ) tmp -> children -> content ) / 1024 ; sc -> version = 1 ; return sc ; } | <S2SV_ModStart> * tmp ; n = search_node ( root , "Vendor" ) ; if ( n == NULL ) { return NULL ; } <S2SV_ModStart> * sc = calloc ( 1 , <S2SV_ModEnd> sizeof ( struct <S2SV_ModStart> ) ) ; <S2SV_ModEnd> tmp = search_node |
2,379 | CWE-000 inline static void mat_add_var ( matlist_t * ml , InstrPtr q , InstrPtr p , int var , mat_type_t type , int inputmat , int parentmat , int pushed ) { mat_t * dst = & ml -> v [ ml -> top ] ; if ( ml -> top == ml -> size ) { int s = ml -> size * 2 ; mat_t * v = ( mat_t * ) GDKzalloc ( s * sizeof ( mat_t ) ) ; if ( ! v ) return ; memcpy ( v , ml -> v , ml -> top * sizeof ( mat_t ) ) ; GDKfree ( ml -> v ) ; ml -> size = s ; ml -> v = v ; dst = & ml -> v [ ml -> top ] ; } dst -> mi = q ; dst -> org = p ; dst -> mv = var ; dst -> type = type ; dst -> im = inputmat ; dst -> pm = parentmat ; dst -> packed = 0 ; dst -> pushed = pushed ; <S2SV_StartBug> ml -> vars [ var ] = ml -> top ; <S2SV_EndBug> ++ ml -> top ; } | <S2SV_ModStart> = pushed ; if ( ml -> vars [ var ] < 0 ) |
2,380 | CWE-000 int __dbuf_stats_hash_table_data ( char * buf , size_t size , dmu_buf_impl_t * db ) { arc_buf_info_t abi = { 0 } ; dmu_object_info_t doi = { 0 } ; dnode_t * dn = DB_DNODE ( db ) ; <S2SV_StartBug> if ( db -> db_buf ) <S2SV_EndBug> arc_buf_info ( db -> db_buf , & abi , zfs_dbuf_state_index ) ; if ( dn ) __dmu_object_info_from_dnode ( dn , & doi ) ; <S2SV_StartBug> ( void ) snprintf ( buf , size , <S2SV_EndBug> "%-16s<S2SV_blank>%-8llu<S2SV_blank>%-8lld<S2SV_blank>%-8lld<S2SV_blank>%-8lld<S2SV_blank>%-8llu<S2SV_blank>%-8llu<S2SV_blank>%-5d<S2SV_blank>%-5d<S2SV_blank>%-5lu<S2SV_blank>|<S2SV_blank>" "%-5d<S2SV_blank>%-5d<S2SV_blank>%-6lld<S2SV_blank>0x%-6x<S2SV_blank>%-6lu<S2SV_blank>%-8llu<S2SV_blank>%-12llu<S2SV_blank>" "%-6lu<S2SV_blank>%-6lu<S2SV_blank>%-6lu<S2SV_blank>%-6lu<S2SV_blank>%-6lu<S2SV_blank>%-8llu<S2SV_blank>%-8llu<S2SV_blank>%-8d<S2SV_blank>%-5lu<S2SV_blank>|<S2SV_blank>" "%-6d<S2SV_blank>%-6d<S2SV_blank>%-8lu<S2SV_blank>%-8lu<S2SV_blank>%-6llu<S2SV_blank>%-6lu<S2SV_blank>%-5lu<S2SV_blank>%-8llu<S2SV_blank>%-8llu\\n" , spa_name ( dn -> dn_objset -> os_spa ) , ( u_longlong_t ) dmu_objset_id ( db -> db_objset ) , ( longlong_t ) db -> db . db_object , ( longlong_t ) db -> db_level , ( longlong_t ) db -> db_blkid , ( u_longlong_t ) db -> db . db_offset , ( u_longlong_t ) db -> db . db_size , ! ! dbuf_is_metadata ( db ) , db -> db_state , ( ulong_t ) refcount_count ( & db -> db_holds ) , abi . abi_state_type , abi . abi_state_contents , ( longlong_t ) abi . abi_state_index , abi . abi_flags , ( ulong_t ) abi . abi_datacnt , ( u_longlong_t ) abi . abi_size , ( u_longlong_t ) abi . abi_access , ( ulong_t ) abi . abi_mru_hits , ( ulong_t ) abi . abi_mru_ghost_hits , ( ulong_t ) abi . abi_mfu_hits , ( ulong_t ) abi . abi_mfu_ghost_hits , ( ulong_t ) abi . abi_l2arc_hits , ( u_longlong_t ) abi . abi_l2arc_dattr , ( u_longlong_t ) abi . abi_l2arc_asize , abi . abi_l2arc_compress , ( ulong_t ) abi . abi_holds , doi . doi_type , doi . doi_bonus_type , ( ulong_t ) doi . doi_data_block_size , ( ulong_t ) doi . doi_metadata_block_size , ( u_longlong_t ) doi . doi_bonus_size , ( ulong_t ) doi . doi_indirection , ( ulong_t ) refcount_count ( & dn -> dn_holds ) , ( u_longlong_t ) doi . doi_fill_count , ( u_longlong_t ) doi . doi_max_offset ) ; <S2SV_StartBug> return ( size ) ; <S2SV_EndBug> } | <S2SV_ModStart> db ) ; size_t nwritten ; <S2SV_ModStart> doi ) ; nwritten = <S2SV_ModEnd> snprintf ( buf <S2SV_ModStart> doi_max_offset ) ; if ( nwritten >= size ) <S2SV_ModStart> return ( size ) ; return ( nwritten + 1 |
2,381 | CWE-000 imc_vector_t * imc_vector_update ( imc_vector_t * vec , int index , imc_data_t * data ) { assert ( index < vec -> size ) ; split s = ft_split ( vec , index ) ; list * l = create_lempty ( ) ; l = add ( create_data_node ( data ) , l ) ; <S2SV_StartBug> node_unref ( s . node ) ; <S2SV_EndBug> return concat_w_middle ( s . ft1 , l , s . ft2 ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> l ) ; ft * tmp = <S2SV_ModEnd> concat_w_middle ( s <S2SV_ModStart> ft2 ) ; ft_display ( tmp ) ; node_unref ( s . node ) ; return tmp ; |
2,382 | CWE-000 void main ( void ) { uint8_t pac [ 8 ] ; uint32_t id ; uint8_t rcz , retr_err ; uint32_t cust_counter = 0 ; float customer_temp [ 12 ] = { 0 } ; uint8_t customer_data [ 12 ] = { 0 } ; uint8_t customer_resp [ 8 ] ; HAL_Init ( ) ; ST_LOWLEVEL_SetSysClock ( ) ; SdkEvalIdentification ( ) ; SdkEvalM2SGpioInit ( M2S_GPIO_SDN , M2S_MODE_GPIO_OUT ) ; SdkEvalSpiInit ( ) ; EepromSpiInitialization ( ) ; USARTConfig ( ) ; initializeAllSensors ( ) ; enableAllSensors ( ) ; S2LPManagementIdentificationRFBoard ( ) ; SdkEvalEnterShutdown ( ) ; ST_MANUF_API_set_freq_offset ( S2LPManagementGetOffset ( ) ) ; ST_LOWLEVEL_TimerCalibration ( 500 ) ; SdkEvalPushButtonInit ( BUTTON_KEY , BUTTON_MODE_EXTI ) ; retr_err = enc_utils_retrieve_data ( & id , pac , & rcz ) ; if ( retr_err != RETR_OK ) { PRINTF ( "Board<S2SV_blank>not<S2SV_blank>ready<S2SV_blank>for<S2SV_blank>SigFox.<S2SV_blank>Missing<S2SV_blank>board<S2SV_blank>ID/PAC.\\n\\r" ) ; PRINTF ( "Please<S2SV_blank>register<S2SV_blank>the<S2SV_blank>board<S2SV_blank>with<S2SV_blank>ST<S2SV_blank>to<S2SV_blank>obtain<S2SV_blank>the<S2SV_blank>ID/PAC.\\n\\r" ) ; Fatal_Error ( ) ; } # ifdef FOR_ETSI if ( rcz != 1 ) Fatal_Error ( ) ; if ( ST_SIGFOX_API_open ( ST_RCZ1 , ( uint8_t * ) & id ) != 0 ) { Fatal_Error ( ) ; } # elif FOR_FCC uint8_t send_call_num = 0 ; if ( rcz == 2 ) { if ( ST_SIGFOX_API_open ( ST_RCZ2 , ( uint8_t * ) & id ) != 0 ) { Fatal_Error ( ) ; } uint32_t config_words [ 3 ] = { 0x1FF , 0 , 0 } ; if ( ST_SIGFOX_API_set_std_config ( config_words , 1 ) != 0 ) { Fatal_Error ( ) ; } ST_SIGFOX_API_reset ( ) ; } else if ( rcz == 4 ) { if ( ST_SIGFOX_API_open ( ST_RCZ4 , ( uint8_t * ) & id ) != 0 ) { Fatal_Error ( ) ; } uint32_t config_words [ 3 ] = { 0 , 0xF0000000 , 0x1F } ; if ( ST_SIGFOX_API_set_std_config ( config_words , 63 ) != 0 ) { Fatal_Error ( ) ; } ST_SIGFOX_API_reset ( ) ; } else { Fatal_Error ( ) ; } # endif <S2SV_StartBug> disableAllSensors ( ) ; <S2SV_EndBug> <S2SV_StartBug> HAL_PWR_EnterSTOPMode ( PWR_LOWPOWERREGULATOR_ON , PWR_STOPENTRY_WFI ) ; <S2SV_EndBug> ST_LOWLEVEL_SetSysClock ( ) ; exitGpioLowPower ( ) ; <S2SV_StartBug> enableAllSensors ( ) ; <S2SV_EndBug> while ( 1 ) { SdkDelayMs ( 10000 ) ; PRINTF ( "-----------------------\\r\\n" ) ; # ifdef USE_ACC_GYRO Accelero_Sensor_Handler ( LSM6DSL_X_0_handle ) ; Gyro_Sensor_Handler ( LSM6DSL_G_0_handle ) ; # endif # ifdef USE_MAG_ACC Accelero_Sensor_Handler ( LSM303AGR_X_0_handle ) ; Magneto_Sensor_Handler ( LSM303AGR_M_0_handle ) ; # endif # ifdef USE_ENVI_SENSORS customer_temp [ 0 ] = Humidity_Sensor_Handler ( HTS221_H_0_handle ) ; PRINTF ( "Humidity<S2SV_blank>=<S2SV_blank>%f\\r\\n" , customer_temp [ 0 ] ) ; customer_data [ 0 ] = roundf ( customer_temp [ 0 ] ) ; customer_temp [ 1 ] = Temperature_Sensor_Handler ( HTS221_T_0_handle ) ; PRINTF ( "Temp<S2SV_blank>=<S2SV_blank>%f\\r\\n" , customer_temp [ 1 ] ) ; customer_data [ 1 ] = roundf ( customer_temp [ 1 ] ) + 128 ; ST_SIGFOX_API_send_frame ( customer_data , 2 , customer_resp , 0 , 0 ) ; # endif # ifdef FOR_FCC if ( send_call_num == 1 ) { ST_SIGFOX_API_reset ( ) ; send_call_num = 0 ; } else { send_call_num ++ ; } # endif } } | <S2SV_ModStart> } # endif HAL_PWR_EnterSTOPMode ( PWR_LOWPOWERREGULATOR_ON , PWR_STOPENTRY_WFI ) ; ST_LOWLEVEL_SetSysClock ( ) ; exitGpioLowPower ( ) ; while ( 1 ) { <S2SV_ModStart> ( ) ; SdkDelayMs ( 10000 ) ; PRINTF ( "-----------------------\\r\\n" <S2SV_ModEnd> ) ; enableAllSensors <S2SV_ModStart> ; enableAllSensors ( <S2SV_ModEnd> ) ; # |
2,383 | CWE-000 static int p8_chiplet_probe ( struct target * target ) { uint64_t value ; <S2SV_StartBug> struct chiplet * chiplet = target_to_chiplet ( target ) ; <S2SV_EndBug> int i , count = 0 , rc = 0 ; if ( pib_read ( target , SCOM_EX_GP3 , & value ) ) { PR_DEBUG ( "Error<S2SV_blank>reading<S2SV_blank>chip<S2SV_blank>GP3<S2SV_blank>register\\n" ) ; return - 1 ; } if ( ! GETFIELD ( PPC_BIT ( 0 ) , value ) ) return - 1 ; assert_special_wakeup ( chiplet ) ; return 0 ; } | <S2SV_ModStart> ( target ) <S2SV_ModEnd> ; if ( |
2,384 | CWE-000 static int handle_page_fault ( struct lazy_pages_info * lpi , struct uffd_msg * msg ) { struct lp_req * req ; struct lazy_iov * iov ; __u64 address ; int ret ; address = msg -> arg . pagefault . address & ~ ( page_size ( ) - 1 ) ; <S2SV_StartBug> pr_debug ( "%d:<S2SV_blank>#PF<S2SV_blank>at<S2SV_blank>0x%llx\\n" , lpi -> pid , address ) ; <S2SV_EndBug> list_for_each_entry ( req , & lpi -> reqs , l ) if ( req -> addr == address ) return 0 ; iov = find_lazy_iov ( lpi , address ) ; if ( ! iov ) return uffd_zero ( lpi , address , 1 ) ; req = xzalloc ( sizeof ( * req ) ) ; if ( ! req ) return - 1 ; req -> addr = address ; list_add ( & req -> l , & lpi -> reqs ) ; ret = uffd_handle_pages ( lpi , address , 1 , PR_ASYNC | PR_ASAP ) ; if ( ret < 0 ) { <S2SV_StartBug> pr_err ( "Error<S2SV_blank>during<S2SV_blank>regular<S2SV_blank>page<S2SV_blank>copy\\n" ) ; <S2SV_EndBug> return - 1 ; } return 0 ; } | <S2SV_ModStart> 1 ) ; lp_debug ( lpi , "#PF<S2SV_blank>at<S2SV_blank>0x%llx\\n" <S2SV_ModEnd> , address ) <S2SV_ModStart> 0 ) { lp_err ( lpi , <S2SV_ModEnd> "Error<S2SV_blank>during<S2SV_blank>regular<S2SV_blank>page<S2SV_blank>copy\\n" ) ; |
2,385 | CWE-000 static int bma2x2_eeprom_prog ( struct i2c_client * client ) { int res = 0 , timeout = 0 ; unsigned char databuf ; res = bma2x2_smbus_read_byte ( client , BMA2X2_EEPROM_CTRL_REG , & databuf ) ; if ( res < 0 ) { dev_err ( & client -> dev , "read<S2SV_blank>eeprom<S2SV_blank>control<S2SV_blank>reg<S2SV_blank>error1\\n" ) ; return res ; } databuf |= 0x01 ; res = bma2x2_smbus_write_byte ( client , BMA2X2_EEPROM_CTRL_REG , & databuf ) ; if ( res < 0 ) { dev_err ( & client -> dev , "write<S2SV_blank>eeprom<S2SV_blank>control<S2SV_blank>reg<S2SV_blank>error1\\n" ) ; return res ; } res = bma2x2_smbus_read_byte ( client , BMA2X2_EEPROM_CTRL_REG , & databuf ) ; if ( res < 0 ) { dev_err ( & client -> dev , "read<S2SV_blank>eeprom<S2SV_blank>control<S2SV_blank>reg<S2SV_blank>error2\\n" ) ; return res ; } databuf |= 0x02 ; res = bma2x2_smbus_write_byte ( client , BMA2X2_EEPROM_CTRL_REG , & databuf ) ; if ( res < 0 ) { dev_err ( & client -> dev , "write<S2SV_blank>eeprom<S2SV_blank>control<S2SV_blank>reg<S2SV_blank>error2\\n" ) ; return res ; } do { WAIT_CAL_READY ( ) ; res = bma2x2_smbus_read_byte ( client , BMA2X2_EEPROM_CTRL_REG , & databuf ) ; if ( res < 0 ) { dev_err ( & client -> dev , "read<S2SV_blank>nvm_rdy<S2SV_blank>error\\n" ) ; return res ; } databuf = ( databuf >> 2 ) & 0x01 ; if ( ++ timeout == 50 ) { dev_err ( & client -> dev , "check<S2SV_blank>nvm_rdy<S2SV_blank>time<S2SV_blank>out\\n" ) ; break ; } } while ( databuf == 0 ) ; res = bma2x2_smbus_read_byte ( client , BMA2X2_EEPROM_CTRL_REG , & databuf ) ; if ( res < 0 ) { dev_err ( & client -> dev , "read<S2SV_blank>eeprom<S2SV_blank>control<S2SV_blank>reg<S2SV_blank>error3\\n" ) ; return res ; } <S2SV_StartBug> databuf |= 0xFE ; <S2SV_EndBug> res = bma2x2_smbus_write_byte ( client , BMA2X2_EEPROM_CTRL_REG , & databuf ) ; if ( res < 0 ) { dev_err ( & client -> dev , "write<S2SV_blank>eeprom<S2SV_blank>control<S2SV_blank>reg<S2SV_blank>error3\\n" ) ; return res ; } return res ; } | <S2SV_ModStart> ; } databuf &= <S2SV_ModEnd> 0xFE ; res |
2,386 | CWE-000 static void <S2SV_StartBug> yang_print_signed ( struct lyout * out , int level , LYEXT_SUBSTMT substmt , const struct lys_module * module , <S2SV_EndBug> struct lys_ext_instance * * ext , unsigned int ext_size , signed int attr_value ) { char * str ; asprintf ( & str , "%d" , attr_value ) ; <S2SV_StartBug> yang_print_substmt ( out , level , substmt , 0 , str , module , ext , ext_size ) ; <S2SV_EndBug> free ( str ) ; } | <S2SV_ModStart> LYEXT_SUBSTMT substmt , uint8_t substmt_index , <S2SV_ModStart> , substmt , substmt_index <S2SV_ModEnd> , str , |
2,387 | CWE-000 static void bgp_config_write_network_evpn ( struct vty * vty , struct bgp * bgp , afi_t afi , safi_t safi ) { struct bgp_node * prn ; struct bgp_node * rn ; struct bgp_table * table ; struct prefix * p ; struct prefix_rd * prd ; struct bgp_static * bgp_static ; <S2SV_StartBug> char buf [ PREFIX_STRLEN ] ; <S2SV_EndBug> char buf2 [ SU_ADDRSTRLEN ] ; char rdbuf [ RD_ADDRSTRLEN ] ; for ( prn = bgp_table_top ( bgp -> route [ afi ] [ safi ] ) ; prn ; prn = bgp_route_next ( prn ) ) { if ( ( table = prn -> info ) == NULL ) continue ; for ( rn = bgp_table_top ( table ) ; rn ; rn = bgp_route_next ( rn ) ) { if ( ( bgp_static = rn -> info ) == NULL ) continue ; char * macrouter = NULL ; char * esi = NULL ; if ( bgp_static -> router_mac ) macrouter = prefix_mac2str ( bgp_static -> router_mac , NULL , 0 ) ; if ( bgp_static -> eth_s_id ) esi = esi2str ( bgp_static -> eth_s_id ) ; p = & rn -> p ; prd = ( struct prefix_rd * ) & prn -> p ; prefix_rd2str ( prd , rdbuf , sizeof ( rdbuf ) ) ; if ( p -> u . prefix_evpn . route_type == 5 ) { char local_buf [ PREFIX_STRLEN ] ; uint8_t family = is_evpn_prefix_ipaddr_v4 ( ( struct prefix_evpn * ) p ) ? AF_INET : AF_INET6 ; inet_ntop ( family , & p -> u . prefix_evpn . prefix_addr . ip . ip . addr , local_buf , PREFIX_STRLEN ) ; sprintf ( buf , "%s/%u" , local_buf , p -> u . prefix_evpn . prefix_addr . ip_prefix_length ) ; } else { prefix2str ( p , buf , sizeof ( buf ) ) ; } if ( bgp_static -> gatewayIp . family == AF_INET || bgp_static -> gatewayIp . family == AF_INET6 ) inet_ntop ( bgp_static -> gatewayIp . family , & bgp_static -> gatewayIp . u . prefix , buf2 , sizeof ( buf2 ) ) ; vty_out ( vty , "<S2SV_blank><S2SV_blank>network<S2SV_blank>%s<S2SV_blank>rd<S2SV_blank>%s<S2SV_blank>ethtag<S2SV_blank>%u<S2SV_blank>label<S2SV_blank>%u<S2SV_blank>esi<S2SV_blank>%s<S2SV_blank>gwip<S2SV_blank>%s<S2SV_blank>routermac<S2SV_blank>%s\\n" , buf , rdbuf , p -> u . prefix_evpn . prefix_addr . eth_tag , decode_label ( & bgp_static -> label ) , esi , buf2 , macrouter ) ; if ( macrouter ) XFREE ( MTYPE_TMP , macrouter ) ; if ( esi ) XFREE ( MTYPE_TMP , esi ) ; } } } | <S2SV_ModStart> buf [ PREFIX_STRLEN * 2 |
2,388 | CWE-000 int drm_crtc_add_crc_entry ( struct drm_crtc * crtc , bool has_frame , uint32_t frame , uint32_t * crcs ) { struct drm_crtc_crc * crc = & crtc -> crc ; struct drm_crtc_crc_entry * entry ; int head , tail ; spin_lock ( & crc -> lock ) ; <S2SV_StartBug> if ( ! crc -> opened ) { <S2SV_EndBug> spin_unlock ( & crc -> lock ) ; return - EINVAL ; } head = crc -> head ; tail = crc -> tail ; if ( CIRC_SPACE ( head , tail , DRM_CRC_ENTRIES_NR ) < 1 ) { spin_unlock ( & crc -> lock ) ; DRM_ERROR ( "Overflow<S2SV_blank>of<S2SV_blank>CRC<S2SV_blank>buffer,<S2SV_blank>userspace<S2SV_blank>reads<S2SV_blank>too<S2SV_blank>slow.\\n" ) ; return - ENOBUFS ; } entry = & crc -> entries [ head ] ; entry -> frame = frame ; entry -> has_frame_counter = has_frame ; memcpy ( & entry -> crcs , crcs , sizeof ( * crcs ) * crc -> values_cnt ) ; head = ( head + 1 ) & ( DRM_CRC_ENTRIES_NR - 1 ) ; crc -> head = head ; spin_unlock ( & crc -> lock ) ; wake_up_interruptible ( & crc -> wq ) ; return 0 ; } | <S2SV_ModStart> ! crc -> entries <S2SV_ModEnd> ) { spin_unlock |
2,389 | CWE-000 static PetscErrorCode newton_petsc_monitor ( SNES snes , PetscInt it , PetscReal norm , void * ctx ) { krylov_ctx_t * petsc_ctx = ( krylov_ctx_t * ) ctx ; zlog_category_t * c_default = zlog_get_category ( "d4est_solver_newton_petsc" ) ; int lit ; SNESGetLinearSolveIterations ( snes , & lit ) ; if ( petsc_ctx -> p4est -> mpirank == 0 ) { zlog_info ( c_default , "AMR_IT<S2SV_blank>SNES_IT<S2SV_blank>KSP_IT<S2SV_blank>SNES_NORM:<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%.25f" , petsc_ctx -> amr_level , it , lit , norm ) ; } if ( petsc_ctx -> checkpoint_every_n_newton_its > 0 ) { if ( ( it - petsc_ctx -> last_newton_checkpoint_it ) >= petsc_ctx -> checkpoint_every_n_newton_its ) { if ( petsc_ctx -> p4est -> mpirank == 0 ) { <S2SV_StartBug> zlog_info ( c_default , "Saving<S2SV_blank>checkpoint<S2SV_blank>at<S2SV_blank>newton<S2SV_blank>iteration<S2SV_blank>%d" , it ) ; <S2SV_EndBug> } char * output = NULL ; asprintf ( & output , "checkpoint_newton_%d" , it ) ; d4est_elliptic_data_t * vecs = petsc_ctx -> vecs ; d4est_checkpoint_save ( petsc_ctx -> amr_level , output , petsc_ctx -> p4est , NULL , NULL , ( const char * [ ] ) { "u" , NULL } , ( hid_t [ ] ) { H5T_NATIVE_DOUBLE } , ( int [ ] ) { vecs -> local_nodes } , ( void * [ ] ) { vecs -> u0 } ) ; petsc_ctx -> last_newton_checkpoint_it = it ; free ( output ) ; } <S2SV_StartBug> } <S2SV_EndBug> } | <S2SV_ModStart> 0 ) { printf ( <S2SV_ModEnd> "Saving<S2SV_blank>checkpoint<S2SV_blank>at<S2SV_blank>newton<S2SV_blank>iteration<S2SV_blank>%d" , it <S2SV_ModStart> ) ; } else { if ( petsc_ctx -> p4est -> mpirank == 0 ) { zlog_info ( c_default , "No<S2SV_blank>checkpoint<S2SV_blank>at<S2SV_blank>newton<S2SV_blank>iteration<S2SV_blank>%d" , it ) ; zlog_info ( c_default , "petsc_ctx->last_newton_checkpoint_it<S2SV_blank>=<S2SV_blank>%d" , petsc_ctx -> last_newton_checkpoint_it ) ; zlog_info ( c_default , "petsc_ctx->checkpoint_every_n_newton_its<S2SV_blank>=<S2SV_blank>%d" , petsc_ctx -> checkpoint_every_n_newton_its ) ; } } } return 0 ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
2,390 | CWE-000 static void format_odp_userspace_action ( struct ds * ds , const struct nlattr * attr ) { static const struct nl_policy ovs_userspace_policy [ ] = { [ OVS_USERSPACE_ATTR_PID ] = { . type = NL_A_U32 } , [ OVS_USERSPACE_ATTR_USERDATA ] = { . type = NL_A_UNSPEC , . optional = true } , [ OVS_USERSPACE_ATTR_EGRESS_TUN_PORT ] = { . type = NL_A_U32 , . optional = true } , [ OVS_USERSPACE_ATTR_ACTIONS ] = { . type = NL_A_UNSPEC , . optional = true } , } ; struct nlattr * a [ ARRAY_SIZE ( ovs_userspace_policy ) ] ; const struct nlattr * userdata_attr ; const struct nlattr * tunnel_out_port_attr ; if ( ! nl_parse_nested ( attr , ovs_userspace_policy , a , ARRAY_SIZE ( a ) ) ) { ds_put_cstr ( ds , "userspace(error)" ) ; return ; } ds_put_format ( ds , "userspace(pid=%" PRIu32 , nl_attr_get_u32 ( a [ OVS_USERSPACE_ATTR_PID ] ) ) ; userdata_attr = a [ OVS_USERSPACE_ATTR_USERDATA ] ; if ( userdata_attr ) { const uint8_t * userdata = nl_attr_get ( userdata_attr ) ; size_t userdata_len = nl_attr_get_size ( userdata_attr ) ; bool userdata_unspec = true ; union user_action_cookie cookie ; if ( userdata_len >= sizeof cookie . type && userdata_len <= sizeof cookie ) { memset ( & cookie , 0 , sizeof cookie ) ; memcpy ( & cookie , userdata , userdata_len ) ; userdata_unspec = false ; if ( userdata_len == sizeof cookie . sflow && cookie . type == USER_ACTION_COOKIE_SFLOW ) { ds_put_format ( ds , ",sFlow(" <S2SV_StartBug> "vid=%" PRIu16 ",pcp=%" PRIu8 ",output=%" PRIu32 ")" , <S2SV_EndBug> vlan_tci_to_vid ( cookie . sflow . vlan_tci ) , vlan_tci_to_pcp ( cookie . sflow . vlan_tci ) , cookie . sflow . output ) ; } else if ( userdata_len == sizeof cookie . slow_path && cookie . type == USER_ACTION_COOKIE_SLOW_PATH ) { ds_put_cstr ( ds , ",slow_path(" ) ; format_flags ( ds , slow_path_reason_to_string , cookie . slow_path . reason , ',' ) ; ds_put_format ( ds , ")" ) ; } else if ( userdata_len == sizeof cookie . flow_sample && cookie . type == USER_ACTION_COOKIE_FLOW_SAMPLE ) { ds_put_format ( ds , ",flow_sample(probability=%" PRIu16 ",collector_set_id=%" PRIu32 ",obs_domain_id=%" PRIu32 ",obs_point_id=%" PRIu32 ",output_port=%" PRIu32 , cookie . flow_sample . probability , cookie . flow_sample . collector_set_id , cookie . flow_sample . obs_domain_id , cookie . flow_sample . obs_point_id , cookie . flow_sample . output_odp_port ) ; if ( cookie . flow_sample . direction == NX_ACTION_SAMPLE_INGRESS ) { ds_put_cstr ( ds , ",ingress" ) ; } else if ( cookie . flow_sample . direction == NX_ACTION_SAMPLE_EGRESS ) { ds_put_cstr ( ds , ",egress" ) ; } ds_put_char ( ds , ')' ) ; } else if ( userdata_len >= sizeof cookie . ipfix && cookie . type == USER_ACTION_COOKIE_IPFIX ) { ds_put_format ( ds , ",ipfix(output_port=%" PRIu32 ")" , cookie . ipfix . output_odp_port ) ; } else { userdata_unspec = true ; } } if ( userdata_unspec ) { size_t i ; ds_put_format ( ds , ",userdata(" ) ; for ( i = 0 ; i < userdata_len ; i ++ ) { ds_put_format ( ds , "%02x" , userdata [ i ] ) ; } ds_put_char ( ds , ')' ) ; } } if ( a [ OVS_USERSPACE_ATTR_ACTIONS ] ) { ds_put_cstr ( ds , ",actions" ) ; } tunnel_out_port_attr = a [ OVS_USERSPACE_ATTR_EGRESS_TUN_PORT ] ; if ( tunnel_out_port_attr ) { ds_put_format ( ds , ",tunnel_out_port=%" PRIu32 , nl_attr_get_u32 ( tunnel_out_port_attr ) ) ; } ds_put_char ( ds , ')' ) ; } | <S2SV_ModStart> ",sFlow(" "vid=%" PRIu16 ",pcp=%d,output=%" <S2SV_ModEnd> PRIu32 ")" , |
2,391 | CWE-000 int GetRxCharSet ( char * pszOld , char cSet [ 256 ] , int * piSetSize , char * pcRepeat ) { char c ; int n = 0 ; char * psz0 = pszOld ; char negative ; int i ; int hasNul ; if ( * pcRepeat != '\\xFF' ) { switch ( c = * pszOld ) { case '[' : pszOld += 1 ; memset ( cSet , 0 , 256 ) ; negative = 0 ; if ( * pszOld == '^' ) { negative = 1 ; pszOld += 1 ; } if ( * pszOld == ']' ) { cSet [ ( unsigned char ) ']' ] = 1 ; pszOld += 1 ; } while ( ( c = * pszOld ) ) { pszOld += GetEscChar ( pszOld , & c ) ; if ( c == ']' ) break ; cSet [ ( unsigned char ) c ] = 1 ; if ( * pszOld == '-' ) { char cLast = c ; pszOld += 1 ; pszOld += GetEscChar ( pszOld , & cLast ) ; if ( cLast < c ) cLast = c ; for ( c ++ ; c <= cLast ; c ++ ) { cSet [ ( unsigned char ) c ] = 1 ; } } } if ( negative ) for ( i = 0 ; i < 256 ; i ++ ) cSet [ i ] = ( char ) ! cSet [ i ] ; hasNul = cSet [ 0 ] ; for ( i = 1 , n = 0 ; i < 256 ; i ++ ) if ( cSet [ i ] ) cSet [ n ++ ] = ( char ) i ; if ( hasNul ) cSet [ n ++ ] = '\\0' ; break ; case '.' : pszOld += 1 ; for ( n = 0 ; n < 256 ; n ++ ) { cSet [ n ] = ( char ) ( n + 1 ) ; } break ; default : pszOld += GetEscChar ( pszOld , cSet ) ; n = 1 ; break ; } * piSetSize = n ; if ( n < 256 ) cSet [ n ] = '\\0' ; c = * pszOld ; switch ( c ) { case '?' : case '+' : case '*' : * pcRepeat = c ; pszOld += 1 ; break ; case '\\0' : default : * pcRepeat = '\\0' ; break ; } } else { c = * ( pszOld ++ ) ; cSet [ 0 ] = c ; * piSetSize = 1 ; } # if 0 DEBUG_CODE_IF_ON ( <S2SV_StartBug> fprintf ( mf , "Extracted<S2SV_blank>set<S2SV_blank>\\"" ) ; <S2SV_EndBug> PrintEscapeString ( mf , cSet ) ; fprintf ( mf , "\\"<S2SV_blank>%c,<S2SV_blank>return<S2SV_blank>%d\\n" , * pcRepeat , pszOld - psz0 ) ; ) ; # endif return ( int ) ( pszOld - psz0 ) ; } | <S2SV_ModStart> ( mf , "//<S2SV_blank>Extracted<S2SV_blank>set<S2SV_blank>\\"" <S2SV_ModEnd> ) ; PrintEscapeString |
2,392 | CWE-000 bool rtc_method_get_uses_reg ( uint8_t method , uint8_t reg ) { <S2SV_StartBug> # ifdef AOT_STRATEGY_MARKLOOP <S2SV_EndBug> return ( rtc_ts -> call_saved_registers_used_per_method [ method ] & 1 << ( ( reg - 2 ) / 2 ) ) != 0 ; <S2SV_StartBug> # else <S2SV_EndBug> return true ; # endif } | <S2SV_ModStart> reg ) { <S2SV_ModEnd> return ( rtc_ts <S2SV_ModStart> != 0 ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
2,393 | CWE-000 static int cmd_handle_untagged ( struct ImapData * idata ) { char * s = NULL ; char * pn = NULL ; unsigned int count ; s = imap_next_word ( idata -> buf ) ; pn = imap_next_word ( s ) ; if ( ( idata -> state >= IMAP_SELECTED ) && isdigit ( ( unsigned char ) * s ) ) { pn = s ; s = imap_next_word ( s ) ; if ( mutt_str_strncasecmp ( "EXISTS" , s , 6 ) == 0 ) { mutt_debug ( 2 , "Handling<S2SV_blank>EXISTS\\n" ) ; <S2SV_StartBug> count = atoi ( pn ) ; <S2SV_EndBug> if ( ! ( idata -> reopen & IMAP_EXPUNGE_PENDING ) && count < idata -> max_msn ) { mutt_debug ( 1 , "Message<S2SV_blank>count<S2SV_blank>is<S2SV_blank>out<S2SV_blank>of<S2SV_blank>sync\\n" ) ; return 0 ; } else if ( count == idata -> max_msn ) mutt_debug ( 3 , "superfluous<S2SV_blank>EXISTS<S2SV_blank>message.\\n" ) ; else { if ( ! ( idata -> reopen & IMAP_EXPUNGE_PENDING ) ) { mutt_debug ( 2 , "New<S2SV_blank>mail<S2SV_blank>in<S2SV_blank>%s<S2SV_blank>-<S2SV_blank>%d<S2SV_blank>messages<S2SV_blank>total.\\n" , idata -> mailbox , count ) ; idata -> reopen |= IMAP_NEWMAIL_PENDING ; } idata -> new_mail_count = count ; } } else if ( mutt_str_strncasecmp ( "EXPUNGE" , s , 7 ) == 0 ) cmd_parse_expunge ( idata , pn ) ; else if ( mutt_str_strncasecmp ( "FETCH" , s , 5 ) == 0 ) cmd_parse_fetch ( idata , pn ) ; } else if ( mutt_str_strncasecmp ( "CAPABILITY" , s , 10 ) == 0 ) cmd_parse_capability ( idata , s ) ; else if ( mutt_str_strncasecmp ( "OK<S2SV_blank>[CAPABILITY" , s , 14 ) == 0 ) cmd_parse_capability ( idata , pn ) ; else if ( mutt_str_strncasecmp ( "OK<S2SV_blank>[CAPABILITY" , pn , 14 ) == 0 ) cmd_parse_capability ( idata , imap_next_word ( pn ) ) ; else if ( mutt_str_strncasecmp ( "LIST" , s , 4 ) == 0 ) cmd_parse_list ( idata , s ) ; else if ( mutt_str_strncasecmp ( "LSUB" , s , 4 ) == 0 ) cmd_parse_lsub ( idata , s ) ; else if ( mutt_str_strncasecmp ( "MYRIGHTS" , s , 8 ) == 0 ) cmd_parse_myrights ( idata , s ) ; else if ( mutt_str_strncasecmp ( "SEARCH" , s , 6 ) == 0 ) cmd_parse_search ( idata , s ) ; else if ( mutt_str_strncasecmp ( "STATUS" , s , 6 ) == 0 ) cmd_parse_status ( idata , s ) ; else if ( mutt_str_strncasecmp ( "ENABLED" , s , 7 ) == 0 ) cmd_parse_enabled ( idata , s ) ; else if ( mutt_str_strncasecmp ( "BYE" , s , 3 ) == 0 ) { mutt_debug ( 2 , "Handling<S2SV_blank>BYE\\n" ) ; if ( idata -> status == IMAP_BYE ) return 0 ; s += 3 ; SKIPWS ( s ) ; mutt_error ( "%s" , s ) ; mutt_sleep ( 2 ) ; cmd_handle_fatal ( idata ) ; return - 1 ; } else if ( ImapServernoise && ( mutt_str_strncasecmp ( "NO" , s , 2 ) == 0 ) ) { mutt_debug ( 2 , "Handling<S2SV_blank>untagged<S2SV_blank>NO\\n" ) ; mutt_error ( "%s" , s + 3 ) ; mutt_sleep ( 2 ) ; } return 0 ; } | <S2SV_ModStart> "Handling<S2SV_blank>EXISTS\\n" ) ; mutt_atoui ( pn , & count <S2SV_ModEnd> ) ; if |
2,394 | CWE-000 char _dev_read_rotary ( void ) { DWORD cbBytesRead ; DWORD dwMode ; BOOL fSuccess ; HANDLE hPipe ; int cb ; unsigned char keybframebuffer [ 10 ] = { 0 } ; char c = 0 ; hPipe = CreateFile ( lpszRotaryPipename , GENERIC_READ | GENERIC_WRITE , 0 , NULL , OPEN_EXISTING , 0 , NULL ) ; if ( hPipe == INVALID_HANDLE_VALUE ) { <S2SV_StartBug> return 0 ; <S2SV_EndBug> if ( GetLastError ( ) != ERROR_PIPE_BUSY ) { perror ( "Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>pipe\\n" ) ; return 0 ; } if ( ! WaitNamedPipe ( lpszRotaryPipename , 20000 ) ) { perror ( "Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>pipe\\n" ) ; return 0 ; } } dwMode = PIPE_READMODE_MESSAGE ; fSuccess = SetNamedPipeHandleState ( hPipe , & dwMode , NULL , NULL ) ; if ( ! fSuccess ) { perror ( "SetNamedPipeHandleState\\n" ) ; return 0 ; } fSuccess = ReadFile ( hPipe , & keybframebuffer , sizeof ( keybframebuffer ) , & cbBytesRead , NULL ) ; if ( ! fSuccess ) return 0 ; for ( cb = 0 ; cb < ( int ) cbBytesRead ; cb ++ ) { c = keybframebuffer [ cb ] ; } CloseHandle ( hPipe ) ; return c ; } | <S2SV_ModStart> INVALID_HANDLE_VALUE ) { <S2SV_ModEnd> if ( GetLastError |
2,395 | CWE-000 static void nm_setting_connection_init ( NMSettingConnection * setting ) { <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> setting ) { NMSettingConnectionPrivate * priv = NM_SETTING_CONNECTION_GET_PRIVATE ( setting ) ; priv -> mdns = NM_SETTING_CONNECTION_MDNS_DEFAULT ; |
2,396 | CWE-000 static int mcp_update_shared_key ( struct mailbox_transaction_context * t , struct mail_user * user , const char * target_uid , struct dcrypt_private_key * key , const char * * error_r ) { const char * error ; struct mail_user * dest_user ; struct mail_storage_service_user * dest_service_user ; struct ioloop_context * cur_ioloop_ctx ; struct dcrypt_public_key * pkey ; const char * dest_username ; int ret = 0 ; bool disallow_insecure = mail_crypt_acl_secure_sharing_enabled ( user ) ; ret = mcp_user_create ( user , target_uid , & dest_user , & dest_service_user , & error ) ; <S2SV_StartBug> mail_storage_service_io_deactivate_user ( dest_service_user ) ; <S2SV_EndBug> mail_storage_service_io_activate_user ( user -> _service_user ) ; if ( ret <= 0 ) { i_error ( "Cannot<S2SV_blank>initialize<S2SV_blank>destination<S2SV_blank>user<S2SV_blank>%s:<S2SV_blank>%s" , <S2SV_StartBug> target_uid , error ) ; <S2SV_EndBug> } else { i_assert ( dest_user != NULL ) ; dest_username = dest_user -> username ; if ( ( ret = mail_crypt_user_get_public_key ( dest_user , & pkey , error_r ) ) <= 0 ) { if ( ret == 0 && disallow_insecure ) { * error_r = t_strdup_printf ( "User<S2SV_blank>%s<S2SV_blank>has<S2SV_blank>no<S2SV_blank>active<S2SV_blank>public<S2SV_blank>key" , dest_user -> username ) ; ret = - 1 ; } else if ( ret == 0 ) { dest_username = NULL ; pkey = NULL ; ret = 1 ; } } if ( ret == 1 ) { ARRAY_TYPE ( dcrypt_private_key ) keys ; t_array_init ( & keys , 1 ) ; array_append ( & keys , & key , 1 ) ; ret = mail_crypt_box_share_private_keys ( t , pkey , dest_username , & keys , error_r ) ; } } mail_storage_service_io_deactivate_user ( user -> _service_user ) ; mail_storage_service_io_activate_user ( dest_service_user ) ; mail_user_unref ( & dest_user ) ; <S2SV_StartBug> if ( dest_service_user != NULL ) <S2SV_EndBug> <S2SV_StartBug> mail_storage_service_user_free ( & dest_service_user ) ; <S2SV_EndBug> if ( ( cur_ioloop_ctx = io_loop_get_current_context ( current_ioloop ) ) != NULL ) io_loop_context_deactivate ( cur_ioloop_ctx ) ; mail_storage_service_io_activate_user ( user -> _service_user ) ; return ret ; } | <S2SV_ModStart> error ) ; if ( ret > 0 ) <S2SV_ModStart> , error ) ; return ret <S2SV_ModStart> dest_user ) ; mail_storage_service_user_free ( & dest_service_user ) ; if ( ( cur_ioloop_ctx = io_loop_get_current_context ( current_ioloop ) ) <S2SV_ModEnd> != NULL ) <S2SV_ModStart> != NULL ) io_loop_context_deactivate ( cur_ioloop_ctx <S2SV_ModEnd> ) ; mail_storage_service_io_activate_user |
2,397 | CWE-000 static pss_value_t _pscript_builtin_len ( pss_vm_t * vm , uint32_t argc , pss_value_t * argv ) { ( void ) vm ; pss_value_t ret = { . kind = PSS_VALUE_KIND_ERROR , . num = PSS_VM_ERROR_TYPE } ; <S2SV_StartBug> if ( argc < 1 ) return ret ; <S2SV_EndBug> if ( argv [ 0 ] . kind != PSS_VALUE_KIND_REF ) return ret ; switch ( pss_value_ref_type ( argv [ 0 ] ) ) { case PSS_VALUE_REF_TYPE_DICT : { pss_dict_t * dict = ( pss_dict_t * ) pss_value_get_data ( argv [ 0 ] ) ; if ( NULL == dict ) break ; uint32_t result = pss_dict_size ( dict ) ; if ( ERROR_CODE ( uint32_t ) == result ) break ; ret . kind = PSS_VALUE_KIND_NUM ; ret . num = result ; break ; } case PSS_VALUE_REF_TYPE_STRING : { const char * str = ( const char * ) pss_value_get_data ( argv [ 0 ] ) ; if ( NULL == str ) break ; ret . kind = PSS_VALUE_KIND_NUM ; ret . num = ( int64_t ) strlen ( str ) ; break ; } default : <S2SV_StartBug> break ; <S2SV_EndBug> } return ret ; } | <S2SV_ModStart> < 1 ) { ret . num = PSS_VM_ERROR_ARGUMENT ; LOG_ERROR ( "Argument<S2SV_blank>error:<S2SV_blank>len<S2SV_blank>function<S2SV_blank>requires<S2SV_blank>at<S2SV_blank>least<S2SV_blank>one<S2SV_blank>argument" ) ; <S2SV_ModStart> return ret ; } <S2SV_ModStart> } default : LOG_ERROR ( "Type<S2SV_blank>error:<S2SV_blank>len<S2SV_blank>fucntion<S2SV_blank>doesn\'t<S2SV_blank>support<S2SV_blank>the<S2SV_blank>input<S2SV_blank>type" ) ; |
2,398 | CWE-000 boolean_t objcache_reclaimlist ( struct objcache * oclist [ ] , int nlist , int ocflags ) { struct objcache * oc ; struct percpu_objcache * cpucache ; struct magazinedepot * depot ; struct magazinelist tmplist ; int i , count ; <S2SV_StartBug> kprintf ( "objcache_reclaimlist\\n" ) ; <S2SV_EndBug> SLIST_INIT ( & tmplist ) ; for ( i = 0 ; i < nlist ; i ++ ) { oc = oclist [ i ] ; cpucache = & oc -> cache_percpu [ mycpuid ] ; depot = & oc -> depot [ myclusterid ] ; crit_enter ( ) ; count = mag_purge ( oc , & cpucache -> loaded_magazine , FALSE ) ; if ( count == 0 ) count += mag_purge ( oc , & cpucache -> previous_magazine , FALSE ) ; crit_exit ( ) ; if ( count > 0 ) { spin_lock ( & depot -> spin ) ; depot -> unallocated_objects += count ; spin_unlock ( & depot -> spin ) ; if ( depot -> waiting ) wakeup ( depot ) ; return ( TRUE ) ; } spin_lock ( & depot -> spin ) ; maglist_disassociate ( depot , & depot -> fullmagazines , & tmplist , FALSE ) ; spin_unlock ( & depot -> spin ) ; count = maglist_purge ( oc , & tmplist ) ; if ( count > 0 ) { if ( depot -> waiting ) wakeup ( depot ) ; return ( TRUE ) ; } } return ( FALSE ) ; } | <S2SV_ModStart> , count ; <S2SV_ModEnd> SLIST_INIT ( & |
2,399 | CWE-000 static ssize_t fi_ibv_rdm_process_event ( struct rdma_cm_event * event , struct fi_ibv_rdm_ep * ep ) { ssize_t ret = FI_SUCCESS ; switch ( event -> event ) { case RDMA_CM_EVENT_ADDR_RESOLVED : ret = fi_ibv_rdm_process_addr_resolved ( event -> id , ep ) ; break ; case RDMA_CM_EVENT_ROUTE_RESOLVED : ret = fi_ibv_rdm_process_route_resolved ( event , ep ) ; break ; case RDMA_CM_EVENT_ESTABLISHED : ret = fi_ibv_rdm_process_event_established ( event , ep ) ; break ; case RDMA_CM_EVENT_DISCONNECTED : ret = fi_ibv_rdm_process_event_disconnected ( ep , event ) ; break ; case RDMA_CM_EVENT_CONNECT_REQUEST : ret = fi_ibv_rdm_process_connect_request ( event , ep ) ; break ; case RDMA_CM_EVENT_REJECTED : ret = fi_ibv_rdm_process_event_rejected ( ep , event ) ; break ; case RDMA_CM_EVENT_TIMEWAIT_EXIT : <S2SV_StartBug> ret = FI_SUCCESS ; <S2SV_EndBug> break ; case RDMA_CM_EVENT_ADDR_ERROR : ret = - FI_EADDRNOTAVAIL ; goto print_err ; case RDMA_CM_EVENT_ROUTE_ERROR : ret = - FI_EHOSTUNREACH ; goto print_err ; case RDMA_CM_EVENT_CONNECT_ERROR : ret = - FI_ECONNREFUSED ; goto print_err ; case RDMA_CM_EVENT_UNREACHABLE : ret = - FI_EADDRNOTAVAIL ; goto print_err ; default : print_err : VERBS_INFO ( FI_LOG_AV , "got<S2SV_blank>unexpected<S2SV_blank>rdmacm<S2SV_blank>event,<S2SV_blank>%s\\n" , rdma_event_str ( event -> event ) ) ; ret = - FI_ECONNABORTED ; break ; } return ret ; } | <S2SV_ModStart> case RDMA_CM_EVENT_TIMEWAIT_EXIT : fi_ibv_rdm_process_timewait_exit_event ( event , ep ) ; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.