Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
6,800 |
CWE-000 static match match_binding_attributes ( gfc_typebound_proc * ba , bool generic , bool ppc ) { bool found_passing = false ; bool seen_ptr = false ; match m = MATCH_YES ; ba -> access = ACCESS_UNKNOWN ; ba -> pass_arg = NULL ; ba -> pass_arg_num = 0 ; ba -> nopass = 0 ; ba -> non_overridable = 0 ; ba -> deferred = 0 ; ba -> ppc = ppc ; m = gfc_match_char ( ',' ) ; if ( m == MATCH_NO ) goto done ; do { m = gfc_match ( "<S2SV_blank>public" ) ; if ( m == MATCH_ERROR ) goto error ; if ( m == MATCH_YES ) { if ( ba -> access != ACCESS_UNKNOWN ) { gfc_error ( "Duplicate<S2SV_blank>access-specifier<S2SV_blank>at<S2SV_blank>%C" ) ; goto error ; } ba -> access = ACCESS_PUBLIC ; continue ; } m = gfc_match ( "<S2SV_blank>private" ) ; if ( m == MATCH_ERROR ) goto error ; if ( m == MATCH_YES ) { if ( ba -> access != ACCESS_UNKNOWN ) { gfc_error ( "Duplicate<S2SV_blank>access-specifier<S2SV_blank>at<S2SV_blank>%C" ) ; goto error ; } ba -> access = ACCESS_PRIVATE ; continue ; } if ( ! generic ) { m = gfc_match ( "<S2SV_blank>nopass" ) ; if ( m == MATCH_ERROR ) goto error ; if ( m == MATCH_YES ) { if ( found_passing ) { gfc_error ( "Binding<S2SV_blank>attributes<S2SV_blank>already<S2SV_blank>specify<S2SV_blank>passing," "<S2SV_blank>illegal<S2SV_blank>NOPASS<S2SV_blank>at<S2SV_blank>%C" ) ; goto error ; } found_passing = true ; ba -> nopass = 1 ; continue ; } m = gfc_match ( "<S2SV_blank>pass" ) ; if ( m == MATCH_ERROR ) goto error ; if ( m == MATCH_YES ) { char arg [ GFC_MAX_SYMBOL_LEN + 1 ] ; if ( found_passing ) { gfc_error ( "Binding<S2SV_blank>attributes<S2SV_blank>already<S2SV_blank>specify<S2SV_blank>passing," "<S2SV_blank>illegal<S2SV_blank>PASS<S2SV_blank>at<S2SV_blank>%C" ) ; goto error ; } m = gfc_match ( "<S2SV_blank>(<S2SV_blank>%n<S2SV_blank>)" , arg ) ; if ( m == MATCH_ERROR ) goto error ; if ( m == MATCH_YES ) <S2SV_StartBug> ba -> pass_arg = gfc_get_string ( arg ) ; <S2SV_EndBug> gcc_assert ( ( m == MATCH_YES ) == ( ba -> pass_arg != NULL ) ) ; found_passing = true ; ba -> nopass = 0 ; continue ; } if ( ppc ) { m = gfc_match ( "<S2SV_blank>pointer" ) ; if ( m == MATCH_ERROR ) goto error ; if ( m == MATCH_YES ) { if ( seen_ptr ) { gfc_error ( "Duplicate<S2SV_blank>POINTER<S2SV_blank>attribute<S2SV_blank>at<S2SV_blank>%C" ) ; goto error ; } seen_ptr = true ; continue ; } } else { m = gfc_match ( "<S2SV_blank>non_overridable" ) ; if ( m == MATCH_ERROR ) goto error ; if ( m == MATCH_YES ) { if ( ba -> non_overridable ) { gfc_error ( "Duplicate<S2SV_blank>NON_OVERRIDABLE<S2SV_blank>at<S2SV_blank>%C" ) ; goto error ; } ba -> non_overridable = 1 ; continue ; } m = gfc_match ( "<S2SV_blank>deferred" ) ; if ( m == MATCH_ERROR ) goto error ; if ( m == MATCH_YES ) { if ( ba -> deferred ) { gfc_error ( "Duplicate<S2SV_blank>DEFERRED<S2SV_blank>at<S2SV_blank>%C" ) ; goto error ; } ba -> deferred = 1 ; continue ; } } } if ( generic ) gfc_error ( "Expected<S2SV_blank>access-specifier<S2SV_blank>at<S2SV_blank>%C" ) ; else gfc_error ( "Expected<S2SV_blank>binding<S2SV_blank>attribute<S2SV_blank>at<S2SV_blank>%C" ) ; goto error ; } while ( gfc_match_char ( ',' ) == MATCH_YES ) ; if ( ba -> non_overridable && ba -> deferred ) { gfc_error ( "NON_OVERRIDABLE<S2SV_blank>and<S2SV_blank>DEFERRED<S2SV_blank>can\'t<S2SV_blank>both<S2SV_blank>appear<S2SV_blank>at<S2SV_blank>%C" ) ; goto error ; } m = MATCH_YES ; done : if ( ba -> access == ACCESS_UNKNOWN ) ba -> access = gfc_typebound_default_access ; if ( ppc && ! seen_ptr ) { gfc_error ( "POINTER<S2SV_blank>attribute<S2SV_blank>is<S2SV_blank>required<S2SV_blank>for<S2SV_blank>procedure<S2SV_blank>pointer<S2SV_blank>component" "<S2SV_blank>at<S2SV_blank>%C" ) ; goto error ; } return m ; error : return MATCH_ERROR ; }
|
<S2SV_ModStart> = gfc_get_string ( "%s" ,
|
6,801 |
CWE-000 <S2SV_StartBug> void _sbrk_r ( void * ptr , int incr ) <S2SV_EndBug> { <S2SV_StartBug> return ; <S2SV_EndBug> }
|
<S2SV_ModStart> <S2SV_null> <S2SV_null> void * _sbrk_r ( struct _reent * r , ptrdiff_t <S2SV_ModEnd> incr ) { <S2SV_ModStart> ) { return NULL
|
6,802 |
CWE-000 static void common_init ( Flash * fls ) { memset ( fls , 0 , sizeof ( * fls ) ) ; DB ( fls -> blk . priv . type = KBT_FLASH ) ; fls -> hw = & flash_stm32_hw ; <S2SV_StartBug> fls -> blk . blk_size = FLASH_PAGE_SIZE_BYTES ; <S2SV_EndBug> fls -> blk . blk_cnt = ( F_SIZE * 1024 ) / FLASH_PAGE_SIZE_BYTES ; <S2SV_StartBug> EMB_FLASH -> KEYR = FLASH_KEY1 ; <S2SV_EndBug> EMB_FLASH -> KEYR = FLASH_KEY2 ; # if CPU_CM3_STM32F2 EMB_FLASH -> CR &= ~ ( 0x3 << 8 ) ; EMB_FLASH -> CR |= ( 0x1 << 8 ) ; # endif }
|
<S2SV_ModStart> ; fls -> hw -> status = 0 ; fls -> <S2SV_ModStart> / FLASH_PAGE_SIZE_BYTES ; UNLOCK_FLASH ( ) ; LOG_INFO ( "flash<S2SV_blank>device<S2SV_blank>initialized<S2SV_blank>and<S2SV_blank>unlocked" ) <S2SV_ModEnd> ; # if
|
6,803 |
CWE-000 static inline int cmp_idx_rs_uint ( const void * a , const void * b ) { <S2SV_StartBug> return ( int ) ( ( * ( bin_u_int * ) a ) - ( * ( bin_u_int * ) b ) ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> ( * ( const <S2SV_ModStart> ( * ( const
|
6,804 |
CWE-000 static int qcom_pcie_get_resources_2_3_2 ( struct qcom_pcie * pcie ) { struct qcom_pcie_resources_2_3_2 * res = & pcie -> res . v2_3_2 ; struct dw_pcie * pci = pcie -> pci ; struct device * dev = pci -> dev ; <S2SV_StartBug> res -> aux_clk = devm_clk_get ( dev , "aux" ) ; <S2SV_EndBug> if ( IS_ERR ( res -> aux_clk ) ) return PTR_ERR ( res -> aux_clk ) ; res -> cfg_clk = devm_clk_get ( dev , "cfg" ) ; if ( IS_ERR ( res -> cfg_clk ) ) return PTR_ERR ( res -> cfg_clk ) ; res -> master_clk = devm_clk_get ( dev , "bus_master" ) ; if ( IS_ERR ( res -> master_clk ) ) return PTR_ERR ( res -> master_clk ) ; res -> slave_clk = devm_clk_get ( dev , "bus_slave" ) ; if ( IS_ERR ( res -> slave_clk ) ) return PTR_ERR ( res -> slave_clk ) ; res -> pipe_clk = devm_clk_get ( dev , "pipe" ) ; return PTR_ERR_OR_ZERO ( res -> pipe_clk ) ; }
|
<S2SV_ModStart> -> dev ; int ret ; res -> supplies [ 0 ] . supply = "vdda" ; res -> supplies [ 1 ] . supply = "vddpe-3v3" ; ret = devm_regulator_bulk_get ( dev , ARRAY_SIZE ( res -> supplies ) , res -> supplies ) ; if ( ret ) return ret ;
|
6,805 |
CWE-000 int i386_cmovb ( asm_instr * new , u_char * opcode , u_int len , asm_processor * proc ) { new -> len += 1 ; new -> instr = ASM_CMOVB ; # if LIBASM_USE_OPERAND_VECTOR <S2SV_StartBug> # if WIP <S2SV_EndBug> new -> len += asm_operand_fetch ( & new -> op [ 0 ] , opcode + 1 , ASM_CONTENT_GENERAL , new , 0 ) ; # else new -> len += asm_operand_fetch ( & new -> op [ 0 ] , opcode + 1 , ASM_CONTENT_GENERAL , new ) ; <S2SV_StartBug> # endif <S2SV_EndBug> # if WIP new -> len += asm_operand_fetch ( & new -> op [ 1 ] , opcode + 1 , ASM_CONTENT_ENCODED , new , 0 ) ; # else new -> len += asm_operand_fetch ( & new -> op [ 1 ] , opcode + 1 , ASM_CONTENT_ENCODED , new ) ; <S2SV_StartBug> # endif <S2SV_EndBug> # else new -> op [ 0 ] . content = ASM_CONTENT_GENERAL ; new -> op [ 1 ] . content = ASM_CONTENT_ENCODED ; operand_rv_rmv ( new , opcode + 1 , len - 1 , proc ) ; # endif return ( new -> len ) ; }
|
<S2SV_ModStart> # if LIBASM_USE_OPERAND_VECTOR <S2SV_ModEnd> new -> len <S2SV_ModStart> new ) ; <S2SV_ModEnd> new -> len <S2SV_ModStart> new ) ; <S2SV_ModEnd> # else new
|
6,806 |
CWE-000 <S2SV_StartBug> int stack_is_full ( stack * s ) <S2SV_EndBug> { return s -> top >= s -> size - 1 ; }
|
<S2SV_ModStart> int stack_is_full ( struct
|
6,807 |
CWE-000 void atm_arr_free ( void * arr ) { atm_arr_t * a = arr ; if ( a != NULL ) { atm_free ( a -> _vals ) ; <S2SV_StartBug> pthread_rwlock_destroy ( & a -> rwlk ) ; <S2SV_EndBug> atm_free ( a ) ; } }
|
<S2SV_ModStart> _vals ) ; <S2SV_ModEnd> atm_free ( a
|
6,808 |
CWE-000 static int php_sockop_set_option ( php_stream * stream , int option , int value , void * ptrparam ) { int oldmode , flags ; php_netstream_data_t * sock = ( php_netstream_data_t * ) stream -> abstract ; php_stream_xport_param * xparam ; if ( ! sock ) { return PHP_STREAM_OPTION_RETURN_NOTIMPL ; } switch ( option ) { case PHP_STREAM_OPTION_CHECK_LIVENESS : { struct timeval tv ; char buf ; int alive = 1 ; if ( value == - 1 ) { if ( sock -> timeout . tv_sec == - 1 ) { tv . tv_sec = FG ( default_socket_timeout ) ; tv . tv_usec = 0 ; } else { tv = sock -> timeout ; } } else { tv . tv_sec = value ; tv . tv_usec = 0 ; } if ( sock -> socket == - 1 ) { alive = 0 ; } else if ( php_pollfd_for ( sock -> socket , PHP_POLLREADABLE | POLLPRI , & tv ) > 0 ) { # ifdef PHP_WIN32 int ret ; # else ssize_t ret ; # endif int err ; ret = recv ( sock -> socket , & buf , sizeof ( buf ) , MSG_PEEK ) ; err = php_socket_errno ( ) ; if ( 0 == ret || <S2SV_StartBug> ( 0 > ret && err != EWOULDBLOCK && err != EAGAIN ) ) { <S2SV_EndBug> alive = 0 ; } } return alive ? PHP_STREAM_OPTION_RETURN_OK : PHP_STREAM_OPTION_RETURN_ERR ; } case PHP_STREAM_OPTION_BLOCKING : oldmode = sock -> is_blocked ; if ( SUCCESS == php_set_sock_blocking ( sock -> socket , value ) ) { sock -> is_blocked = value ; return oldmode ; } return PHP_STREAM_OPTION_RETURN_ERR ; case PHP_STREAM_OPTION_READ_TIMEOUT : sock -> timeout = * ( struct timeval * ) ptrparam ; sock -> timeout_event = 0 ; return PHP_STREAM_OPTION_RETURN_OK ; case PHP_STREAM_OPTION_META_DATA_API : add_assoc_bool ( ( zval * ) ptrparam , "timed_out" , sock -> timeout_event ) ; add_assoc_bool ( ( zval * ) ptrparam , "blocked" , sock -> is_blocked ) ; add_assoc_bool ( ( zval * ) ptrparam , "eof" , stream -> eof ) ; return PHP_STREAM_OPTION_RETURN_OK ; case PHP_STREAM_OPTION_XPORT_API : xparam = ( php_stream_xport_param * ) ptrparam ; switch ( xparam -> op ) { case STREAM_XPORT_OP_LISTEN : xparam -> outputs . returncode = ( listen ( sock -> socket , xparam -> inputs . backlog ) == 0 ) ? 0 : - 1 ; return PHP_STREAM_OPTION_RETURN_OK ; case STREAM_XPORT_OP_GET_NAME : xparam -> outputs . returncode = php_network_get_sock_name ( sock -> socket , xparam -> want_textaddr ? & xparam -> outputs . textaddr : NULL , xparam -> want_addr ? & xparam -> outputs . addr : NULL , xparam -> want_addr ? & xparam -> outputs . addrlen : NULL ) ; return PHP_STREAM_OPTION_RETURN_OK ; case STREAM_XPORT_OP_GET_PEER_NAME : xparam -> outputs . returncode = php_network_get_peer_name ( sock -> socket , xparam -> want_textaddr ? & xparam -> outputs . textaddr : NULL , xparam -> want_addr ? & xparam -> outputs . addr : NULL , xparam -> want_addr ? & xparam -> outputs . addrlen : NULL ) ; return PHP_STREAM_OPTION_RETURN_OK ; case STREAM_XPORT_OP_SEND : flags = 0 ; if ( ( xparam -> inputs . flags & STREAM_OOB ) == STREAM_OOB ) { flags |= MSG_OOB ; } xparam -> outputs . returncode = sock_sendto ( sock , xparam -> inputs . buf , xparam -> inputs . buflen , flags , xparam -> inputs . addr , xparam -> inputs . addrlen ) ; if ( xparam -> outputs . returncode == - 1 ) { char * err = php_socket_strerror ( php_socket_errno ( ) , NULL , 0 ) ; php_error_docref ( NULL , E_WARNING , "%s\\n" , err ) ; efree ( err ) ; } return PHP_STREAM_OPTION_RETURN_OK ; case STREAM_XPORT_OP_RECV : flags = 0 ; if ( ( xparam -> inputs . flags & STREAM_OOB ) == STREAM_OOB ) { flags |= MSG_OOB ; } if ( ( xparam -> inputs . flags & STREAM_PEEK ) == STREAM_PEEK ) { flags |= MSG_PEEK ; } xparam -> outputs . returncode = sock_recvfrom ( sock , xparam -> inputs . buf , xparam -> inputs . buflen , flags , xparam -> want_textaddr ? & xparam -> outputs . textaddr : NULL , xparam -> want_addr ? & xparam -> outputs . addr : NULL , xparam -> want_addr ? & xparam -> outputs . addrlen : NULL ) ; return PHP_STREAM_OPTION_RETURN_OK ; # ifdef HAVE_SHUTDOWN # ifndef SHUT_RD # define SHUT_RD 0 # endif # ifndef SHUT_WR # define SHUT_WR 1 # endif # ifndef SHUT_RDWR # define SHUT_RDWR 2 # endif case STREAM_XPORT_OP_SHUTDOWN : { static const int shutdown_how [ ] = { SHUT_RD , SHUT_WR , SHUT_RDWR } ; xparam -> outputs . returncode = shutdown ( sock -> socket , shutdown_how [ xparam -> how ] ) ; return PHP_STREAM_OPTION_RETURN_OK ; } # endif default : return PHP_STREAM_OPTION_RETURN_NOTIMPL ; } default : return PHP_STREAM_OPTION_RETURN_NOTIMPL ; } }
|
<S2SV_ModStart> err != EAGAIN && err != EMSGSIZE
|
6,809 |
CWE-000 struct int_array * parser ( char * fs ) { <S2SV_StartBug> struct int_array * result ; <S2SV_EndBug> int * A ; int block_size = 1024 ; int blocks = 1 ; A = calloc ( block_size * blocks , sizeof ( int ) ) ; if ( A == NULL ) { fprintf ( stderr , "Error<S2SV_blank>-<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>required<S2SV_blank>memory.\\n" ) ; exit ( 1 ) ; } int i = 0 ; char * pos = strtok ( fs , "\\n" ) ; while ( pos != NULL ) { if ( i == blocks * block_size ) { blocks ++ ; A = realloc ( A , block_size * blocks * sizeof ( int ) ) ; if ( A == NULL ) { fprintf ( stderr , "Error<S2SV_blank>-<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>required<S2SV_blank>\t\t\t\tmemory.\\n" ) ; exit ( 1 ) ; } } A [ i ] = atoi ( pos ) ; pos = strtok ( NULL , "\\n" ) ; i ++ ; } result -> len = i ; result -> A = A ; <S2SV_StartBug> free ( A ) ; <S2SV_EndBug> return result ; }
|
<S2SV_ModStart> int_array * result = malloc ( sizeof * result ) <S2SV_ModStart> = A ; <S2SV_ModEnd> return result ;
|
6,810 |
CWE-000 static void load_cmap4 ( struct cmap4 * map , <S2SV_StartBug> unsigned char * GIDToCIDMap , CMap * cmap ) <S2SV_EndBug> { USHORT c0 , c1 , gid , cid ; USHORT j , d , segCount ; USHORT ch ; int i ; segCount = map -> segCountX2 / 2 ; for ( i = segCount - 1 ; i >= 0 ; i -- ) { c0 = map -> startCount [ i ] ; c1 = map -> endCount [ i ] ; d = map -> idRangeOffset [ i ] / 2 - ( segCount - i ) ; for ( j = 0 ; j <= c1 - c0 ; j ++ ) { ch = c0 + j ; if ( map -> idRangeOffset [ i ] == 0 ) { gid = ( ch + map -> idDelta [ i ] ) & 0xffff ; } else if ( c0 == 0xffff && c1 == 0xffff && map -> idRangeOffset [ i ] == 0xffff ) { gid = 0 ; } else { gid = ( map -> glyphIndexArray [ j + d ] + map -> idDelta [ i ] ) & 0xffff ; } <S2SV_StartBug> if ( gid != 0 && gid != 0xffff ) { <S2SV_EndBug> if ( GIDToCIDMap ) { cid = ( ( GIDToCIDMap [ 2 * gid ] << 8 ) | GIDToCIDMap [ 2 * gid + 1 ] ) ; if ( cid == 0 ) WARN ( "GID<S2SV_blank>%u<S2SV_blank>does<S2SV_blank>not<S2SV_blank>have<S2SV_blank>corresponding<S2SV_blank>CID<S2SV_blank>%u." , gid , cid ) ; } else { cid = gid ; } wbuf [ 0 ] = 0 ; wbuf [ 1 ] = 0 ; wbuf [ 2 ] = ( ch >> 8 ) & 0xff ; wbuf [ 3 ] = ch & 0xff ; CMap_add_cidchar ( cmap , wbuf , 4 , cid ) ; } } } return ; }
|
<S2SV_ModStart> char * GIDToCIDMap , otl_gsub * gsub_list <S2SV_ModStart> 0xffff ) { if ( gsub_list ) otl_gsub_apply ( gsub_list , & gid ) ;
|
6,811 |
CWE-000 void BIDLIST_insert ( BIDLIST * l , int i ) { NODE * n ; n = ( NODE * ) malloc ( sizeof ( NODE ) ) ; n -> valor = i ; if ( l -> pri == l -> ult ) { ( * l -> pdi ) . valor = i ; } else { l -> pdi = l -> pri ; while ( ! BIDLIST_end ( * l ) && BIDLIST_read ( * l ) < i ) { <S2SV_StartBug> ( * l -> pdi ) -> seg = l -> pdi ; <S2SV_EndBug> } if ( BIDLIST_end ( * l ) && BIDLIST_read ( * l ) > i ) { n -> ant = l -> pdi ; n -> seg = NULL ; ( * n -> ant ) . seg = n ; } else { n -> seg = l -> pdi ; n -> ant = ( * l -> pdi ) . ant ; ( * n -> ant ) . seg = n ; ( * n -> seg ) . ant = n ; } } }
|
<S2SV_ModStart> -> pdi ) . <S2SV_ModEnd> seg = l
|
6,812 |
CWE-000 static int fanotify_release ( struct inode * ignored , struct file * file ) { struct fsnotify_group * group = file -> private_data ; struct fanotify_perm_event_info * event , * next ; struct fsnotify_event * fsn_event ; fsnotify_group_stop_queueing ( group ) ; spin_lock ( & group -> notification_lock ) ; list_for_each_entry_safe ( event , next , & group -> fanotify_data . access_list , fae . fse . list ) { pr_debug ( "%s:<S2SV_blank>found<S2SV_blank>group=%p<S2SV_blank>event=%p\\n" , __func__ , group , event ) ; list_del_init ( & event -> fae . fse . list ) ; event -> response = FAN_ALLOW ; } while ( ! fsnotify_notify_queue_is_empty ( group ) ) { fsn_event = fsnotify_remove_first_event ( group ) ; <S2SV_StartBug> if ( ! ( fsn_event -> mask & FAN_ALL_PERM_EVENTS ) ) { <S2SV_EndBug> spin_unlock ( & group -> notification_lock ) ; fsnotify_destroy_event ( group , fsn_event ) ; spin_lock ( & group -> notification_lock ) ; } else { FANOTIFY_PE ( fsn_event ) -> response = FAN_ALLOW ; } } spin_unlock ( & group -> notification_lock ) ; wake_up ( & group -> fanotify_data . access_waitq ) ; fsnotify_destroy_group ( group ) ; return 0 ; }
|
<S2SV_ModStart> -> mask & FANOTIFY_PERM_EVENTS <S2SV_ModEnd> ) ) {
|
6,813 |
CWE-000 int _sfputm ( Sfio_t * f , Sfulong_t v , Sfulong_t m ) { uchar * s , * ps ; ssize_t n , p ; uchar c [ N_ARRAY ] ; <S2SV_StartBug> SFMTXDECL ( f ) ; <S2SV_EndBug> <S2SV_StartBug> SFMTXENTER ( f , - 1 ) ; <S2SV_EndBug> <S2SV_StartBug> if ( v > m || ( f -> mode != SF_WRITE && _sfmode ( f , SF_WRITE , 0 ) < 0 ) ) SFMTXRETURN ( f , - 1 ) ; <S2SV_EndBug> <S2SV_StartBug> SFLOCK ( f , 0 ) ; <S2SV_EndBug> s = ps = & ( c [ N_ARRAY - 1 ] ) ; * s = ( uchar ) SFBVALUE ( v ) ; while ( ( m >>= SF_BBITS ) > 0 ) { v >>= SF_BBITS ; * -- s = ( uchar ) SFBVALUE ( v ) ; } n = ( ps - s ) + 1 ; if ( n > 8 || SFWPEEK ( f , ps , p ) < n ) n = SFWRITE ( f , ( void * ) s , n ) ; else { switch ( n ) { case 8 : * ps ++ = * s ++ ; case 7 : * ps ++ = * s ++ ; case 6 : * ps ++ = * s ++ ; case 5 : * ps ++ = * s ++ ; case 4 : * ps ++ = * s ++ ; case 3 : * ps ++ = * s ++ ; case 2 : * ps ++ = * s ++ ; case 1 : * ps ++ = * s ++ ; default : ; } f -> next = ps ; } <S2SV_StartBug> SFOPEN ( f ) ; <S2SV_EndBug> <S2SV_StartBug> SFMTXRETURN ( f , ( int ) n ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> ( f ) <S2SV_ModEnd> SFMTXENTER ( f <S2SV_ModStart> - 1 ) <S2SV_ModEnd> if ( v <S2SV_ModStart> - 1 ) <S2SV_ModEnd> SFLOCK ( f <S2SV_ModStart> , 0 ) <S2SV_ModEnd> s = ps <S2SV_ModStart> ( f ) <S2SV_ModEnd> SFMTXRETURN ( f <S2SV_ModStart> ) n ) <S2SV_ModEnd> } <S2SV_null> <S2SV_null>
|
6,814 |
CWE-000 static int relay_process_control_receive_header ( struct relay_connection * conn ) { int ret = 0 ; struct lttcomm_relayd_hdr header ; struct lttng_dynamic_buffer * reception_buffer = & conn -> protocol . ctrl . reception_buffer ; struct ctrl_connection_state_receive_header * state = & conn -> protocol . ctrl . state . receive_header ; assert ( state -> left_to_receive != 0 ) ; ret = conn -> sock -> ops -> recvmsg ( conn -> sock , reception_buffer -> data + state -> received , state -> left_to_receive , MSG_DONTWAIT ) ; if ( ret < 0 ) { ERR ( "Unable<S2SV_blank>to<S2SV_blank>receive<S2SV_blank>control<S2SV_blank>command<S2SV_blank>header<S2SV_blank>on<S2SV_blank>sock<S2SV_blank>%d" , conn -> sock -> fd ) ; goto end ; } else if ( ret == 0 ) { DBG ( "Socket<S2SV_blank>%d<S2SV_blank>performed<S2SV_blank>an<S2SV_blank>orderly<S2SV_blank>shutdown<S2SV_blank>(received<S2SV_blank>EOF)" , conn -> sock -> fd ) ; ret = - 1 ; goto end ; } assert ( ret > 0 ) ; assert ( ret <= state -> left_to_receive ) ; state -> left_to_receive -= ret ; state -> received += ret ; if ( state -> left_to_receive > 0 ) { DBG3 ( "Partial<S2SV_blank>reception<S2SV_blank>of<S2SV_blank>control<S2SV_blank>connection<S2SV_blank>protocol<S2SV_blank>header<S2SV_blank>(received<S2SV_blank>%" PRIu64 "<S2SV_blank>bytes,<S2SV_blank>%" PRIu64 "<S2SV_blank>bytes<S2SV_blank>left<S2SV_blank>to<S2SV_blank>receive,<S2SV_blank>fd<S2SV_blank>=<S2SV_blank>%i)" , state -> received , state -> left_to_receive , conn -> sock -> fd ) ; ret = 0 ; goto end ; } conn -> protocol . ctrl . state_id = CTRL_CONNECTION_STATE_RECEIVE_PAYLOAD ; memcpy ( & header , reception_buffer -> data , sizeof ( header ) ) ; header . circuit_id = be64toh ( header . circuit_id ) ; header . data_size = be64toh ( header . data_size ) ; header . cmd = be32toh ( header . cmd ) ; header . cmd_version = be32toh ( header . cmd_version ) ; memcpy ( & conn -> protocol . ctrl . state . receive_payload . header , & header , sizeof ( header ) ) ; DBG ( "Done<S2SV_blank>receiving<S2SV_blank>control<S2SV_blank>command<S2SV_blank>header:<S2SV_blank>fd<S2SV_blank>=<S2SV_blank>%i,<S2SV_blank>cmd<S2SV_blank>=<S2SV_blank>%" PRIu32 ",<S2SV_blank>cmd_version<S2SV_blank>=<S2SV_blank>%" PRIu32 ",<S2SV_blank>payload<S2SV_blank>size<S2SV_blank>=<S2SV_blank>%" PRIu64 "<S2SV_blank>bytes" , conn -> sock -> fd , header . cmd , header . cmd_version , header . data_size ) ; <S2SV_StartBug> if ( header . data_size > ( 128 * 1024 * 1024 ) ) { <S2SV_EndBug> ERR ( "Command<S2SV_blank>header<S2SV_blank>indicates<S2SV_blank>a<S2SV_blank>payload<S2SV_blank>(%" PRIu64 "<S2SV_blank>bytes)<S2SV_blank>that<S2SV_blank>exceeds<S2SV_blank>the<S2SV_blank>maximal<S2SV_blank>payload<S2SV_blank>size<S2SV_blank>allowed<S2SV_blank>on<S2SV_blank>a<S2SV_blank>control<S2SV_blank>connection." , header . data_size ) ; ret = - 1 ; goto end ; } conn -> protocol . ctrl . state . receive_payload . left_to_receive = header . data_size ; conn -> protocol . ctrl . state . receive_payload . received = 0 ; ret = lttng_dynamic_buffer_set_size ( reception_buffer , header . data_size ) ; if ( ret ) { goto end ; } if ( header . data_size == 0 ) { ret = relay_process_control_receive_payload ( conn ) ; } end : return ret ; }
|
<S2SV_ModStart> . data_size > DEFAULT_NETWORK_RELAYD_CTRL_MAX_PAYLOAD_SIZE <S2SV_ModEnd> ) { ERR
|
6,815 |
CWE-000 int ParseCmd ( unsigned char * buffer , uint8_t len ) { static uint32_t StartAddress , StartAddress_bak , TotalLen , TotalLen_bak , LastDataLen , g_packno = 1 ; uint8_t * response ; uint16_t lcksum ; uint32_t lcmd , srclen , i , regcnf0 , security ; unsigned char * pSrc ; static uint32_t gcmd ; response = response_buff ; pSrc = buffer ; srclen = len ; lcmd = inpw ( pSrc ) ; outpw ( response + 4 , 0 ) ; pSrc += 8 ; srclen -= 8 ; ReadData ( Config0 , Config0 + 8 , ( uint32_t * ) ( response + 8 ) ) ; regcnf0 = * ( uint32_t * ) ( response + 8 ) ; security = regcnf0 & 0x2 ; if ( lcmd == CMD_SYNC_PACKNO ) { g_packno = inpw ( pSrc ) ; } if ( ( lcmd ) && ( lcmd != CMD_RESEND_PACKET ) ) gcmd = lcmd ; if ( lcmd == CMD_GET_FWVER ) { response [ 8 ] = FW_VERSION ; } else if ( lcmd == CMD_GET_DEVICEID ) { outpw ( response + 8 , SYS -> PDID ) ; goto out ; } else if ( lcmd == CMD_RUN_APROM || lcmd == CMD_RUN_LDROM || lcmd == CMD_RESET ) { outpw ( & SYS -> RSTSRC , 3 ) ; if ( lcmd == CMD_RUN_APROM ) { i = ( FMC -> ISPCON & 0xFFFFFFFC ) ; } else if ( lcmd == CMD_RUN_LDROM ) { i = ( FMC -> ISPCON & 0xFFFFFFFC ) ; i |= 0x00000002 ; } else { i = ( FMC -> ISPCON & 0xFFFFFFFE ) ; } outpw ( & FMC -> ISPCON , i ) ; outpw ( & SCB -> AIRCR , ( V6M_AIRCR_VECTKEY_DATA | V6M_AIRCR_SYSRESETREQ ) ) ; while ( 1 ) ; } else if ( lcmd == CMD_CONNECT ) { g_packno = 1 ; goto out ; } else if ( lcmd == CMD_DISCONNECT ) { return 0 ; } else if ( ( lcmd == CMD_UPDATE_APROM ) || ( lcmd == CMD_ERASE_ALL ) ) { EraseAP ( FMC_APROM_BASE , ( g_apromSize < g_dataFlashAddr ) ? g_apromSize : g_dataFlashAddr ) ; if ( lcmd == CMD_ERASE_ALL ) { EraseAP ( g_dataFlashAddr , g_dataFlashAddr + g_dataFlashSize ) ; * ( uint32_t * ) ( response + 8 ) = regcnf0 | 0x02 ; UpdateConfig ( ( uint32_t * ) ( response + 8 ) , NULL ) ; } bUpdateApromCmd = TRUE ; } else if ( lcmd == CMD_GET_FLASHMODE ) { outpw ( response + 8 , ( FMC -> ISPCON & 0x2 ) ? 2 : 1 ) ; } if ( ( lcmd == CMD_UPDATE_APROM ) || ( lcmd == CMD_UPDATE_DATAFLASH ) ) { if ( lcmd == CMD_UPDATE_DATAFLASH ) { StartAddress = g_dataFlashAddr ; if ( g_dataFlashSize ) { EraseAP ( g_dataFlashAddr , g_dataFlashAddr + g_dataFlashSize ) ; } else goto out ; } else { StartAddress = 0 ; } TotalLen = inpw ( pSrc + 4 ) ; pSrc += 8 ; srclen -= 8 ; StartAddress_bak = StartAddress ; TotalLen_bak = TotalLen ; } else if ( lcmd == CMD_UPDATE_CONFIG ) { if ( ( security == 0 ) && ( ! bUpdateApromCmd ) ) goto out ; UpdateConfig ( ( uint32_t * ) ( pSrc ) , ( uint32_t * ) ( response + 8 ) ) ; GetDataFlashInfo ( & g_dataFlashAddr , & g_dataFlashSize ) ; goto out ; } else if ( lcmd == CMD_RESEND_PACKET ) { <S2SV_StartBug> StartAddress -= LastDataLen ; <S2SV_EndBug> TotalLen += LastDataLen ; <S2SV_StartBug> if ( ( StartAddress & 0xFFE00 ) >= Config0 ) <S2SV_EndBug> goto out ; <S2SV_StartBug> ReadData ( StartAddress & 0xFFE00 , StartAddress , ( uint32_t * ) aprom_buf ) ; <S2SV_EndBug> <S2SV_StartBug> FMC_Erase_User ( StartAddress & 0xFFE00 ) ; <S2SV_EndBug> <S2SV_StartBug> WriteData ( StartAddress & 0xFFE00 , StartAddress , ( uint32_t * ) aprom_buf ) ; <S2SV_EndBug> if ( ( StartAddress % FMC_FLASH_PAGE_SIZE ) >= ( FMC_FLASH_PAGE_SIZE - LastDataLen ) ) <S2SV_StartBug> FMC_Erase_User ( ( StartAddress & 0xFFE00 ) + FMC_FLASH_PAGE_SIZE ) ; <S2SV_EndBug> goto out ; } if ( ( gcmd == CMD_UPDATE_APROM ) || ( gcmd == CMD_UPDATE_DATAFLASH ) ) { if ( TotalLen < srclen ) { srclen = TotalLen ; } TotalLen -= srclen ; WriteData ( StartAddress , StartAddress + srclen , ( uint32_t * ) pSrc ) ; memset ( pSrc , 0 , srclen ) ; ReadData ( StartAddress , StartAddress + srclen , ( uint32_t * ) pSrc ) ; StartAddress += srclen ; LastDataLen = srclen ; if ( TotalLen == 0 ) { lcksum = CalCheckSum ( StartAddress_bak , TotalLen_bak ) ; outps ( response + 8 , lcksum ) ; } } out : lcksum = Checksum ( buffer , len ) ; outps ( response , lcksum ) ; ++ g_packno ; outpw ( response + 4 , g_packno ) ; g_packno ++ ; return 0 ; }
|
<S2SV_ModStart> CMD_RESEND_PACKET ) { uint32_t PageAddress ; <S2SV_ModStart> += LastDataLen ; PageAddress = StartAddress & ( 0x100000 - FMC_FLASH_PAGE_SIZE ) ; if ( PageAddress <S2SV_ModEnd> >= Config0 ) <S2SV_ModStart> ; ReadData ( PageAddress <S2SV_ModEnd> , StartAddress , <S2SV_ModStart> ; FMC_Erase_User ( PageAddress <S2SV_ModEnd> ) ; WriteData <S2SV_ModStart> ; WriteData ( PageAddress <S2SV_ModEnd> , StartAddress , <S2SV_ModStart> ) FMC_Erase_User ( PageAddress <S2SV_ModEnd> + FMC_FLASH_PAGE_SIZE )
|
6,816 |
CWE-000 int main ( void ) { DEBUG ( "main" , "Starting<S2SV_blank>bot..." ) ; struct sigaction act ; act . sa_handler = signal_catch ; sigaction ( SIGINT , & act , NULL ) ; Tox * tox = tox_init ( ) ; if ( ! tox ) { return 1 ; } if ( ! settings_load ( SETTINGS_FILE ) ) { DEBUG ( "WARNING" , "Settings<S2SV_blank>could<S2SV_blank>not<S2SV_blank>be<S2SV_blank>loaded,<S2SV_blank>default<S2SV_blank>settings<S2SV_blank>will<S2SV_blank>be<S2SV_blank>used." ) ; } IRC * irc = irc_connect ( settings . server , settings . port ) ; if ( ! irc ) { <S2SV_StartBug> return 2 ; <S2SV_EndBug> } <S2SV_StartBug> irc_join_channel ( irc , settings . default_channel ) ; <S2SV_EndBug> irc -> channels [ irc -> num_channels - 1 ] . group_num = tox_conference_new ( tox , NULL ) ; char nick [ 128 ] , msg [ 512 ] , channel [ 128 ] ; while ( ! exit_bot ) { int count = 0 ; ioctl ( irc -> sock , FIONREAD , & count ) ; if ( count > 0 ) { uint8_t data [ count + 1 ] ; data [ count ] = 0 ; recv ( irc -> sock , data , count , MSG_NOSIGNAL ) ; printf ( "%s" , data ) ; if ( strncmp ( ( char * ) data , "PING" , 4 ) == 0 ) { data [ 1 ] = 'O' ; int i ; for ( i = 0 ; i < count ; ++ i ) { if ( data [ i ] == '\\n' ) { ++ i ; break ; } } irc_send ( irc -> sock , ( char * ) data , i ) ; } else if ( data [ 0 ] == ':' ) { char * ptr = strtok ( ( char * ) data , "!" ) ; bool privmsg = false ; if ( ptr == NULL ) { continue ; } else { strncpy ( nick , & ptr [ 1 ] , 127 ) ; nick [ 127 ] = '\\0' ; } if ( strcmp ( nick , settings . name ) == 0 ) { continue ; } while ( ( ptr = strtok ( NULL , "<S2SV_blank>" ) ) != NULL ) { if ( strcmp ( ptr , "PRIVMSG" ) == 0 ) { privmsg = true ; break ; } } if ( ! privmsg ) { continue ; } if ( ( ptr = strtok ( NULL , ":" ) ) != NULL && ( ptr = strtok ( NULL , "" ) ) != NULL ) { strncpy ( msg , ptr , 511 ) ; msg [ 511 ] = '\\0' ; } uint32_t group = irc_get_channel_group ( irc , channel ) ; if ( group == UINT32_MAX ) { continue ; } tox_group_send_msg ( tox , group , nick , msg ) ; } } int error = 0 ; socklen_t len = sizeof ( error ) ; if ( irc -> sock < 0 || getsockopt ( irc -> sock , SOL_SOCKET , SO_ERROR , & error , & len ) != 0 ) { DEBUG ( "main" , "Socket<S2SV_blank>has<S2SV_blank>gone<S2SV_blank>bad.<S2SV_blank>Reconnecting..." ) ; irc_disconnect ( irc ) ; irc_free ( irc ) ; irc = irc_connect ( settings . server , settings . port ) ; } tox_iterate ( tox , irc ) ; usleep ( tox_iteration_interval ( tox ) ) ; } irc_disconnect ( irc ) ; irc_free ( irc ) ; write_config ( tox , SAVE_FILE ) ; tox_kill ( tox ) ; settings_save ( SETTINGS_FILE ) ; DEBUG ( "main" , "Shutting<S2SV_blank>down<S2SV_blank>bot..." ) ; return 0 ; }
|
<S2SV_ModStart> irc ) { tox_kill ( tox ) ; return 2 ; } TOX_ERR_CONFERENCE_NEW err ; uint32_t group_num = tox_conference_new ( tox , & err ) ; if ( group_num == UINT32_MAX ) { DEBUG ( "main" , "Could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>groupchat<S2SV_blank>for<S2SV_blank>default<S2SV_blank>group." ) ; tox_kill ( tox ) ; irc_disconnect ( irc ) ; irc_free ( irc ) ; return 3 <S2SV_ModEnd> ; } irc_join_channel <S2SV_ModStart> settings . default_channel , group_num <S2SV_ModEnd> ) ; char
|
6,817 |
CWE-000 int main ( ) { HMODULE lib1 ; HMODULE lib2 ; lib1 = myload ( "win32.multisec.dll.dll" ) ; <S2SV_StartBug> lib2 = myload ( "win32m~1.dll" ) ; <S2SV_EndBug> if ( lib1 == lib2 ) { print ( "there<S2SV_blank>is<S2SV_blank>a<S2SV_blank>problem<S2SV_blank>-<S2SV_blank>should<S2SV_blank>have<S2SV_blank>collided,<S2SV_blank>maybe<S2SV_blank>missing\\n" ) ; } f ( ) ; func3 ( ) ; func4 ( ) ; FreeLibrary ( lib1 ) ; FreeLibrary ( lib2 ) ; return 0 ; }
|
<S2SV_ModStart> = myload ( "win32.multisec2.dll.dll" <S2SV_ModEnd> ) ; if
|
6,818 |
CWE-000 Size SharedSnapshotShmemSize ( void ) { Size size ; <S2SV_StartBug> xipEntryCount = MaxBackends + max_prepared_xacts ; <S2SV_EndBug> slotSize = sizeof ( SharedSnapshotSlot ) ; <S2SV_StartBug> slotSize += mul_size ( sizeof ( TransactionId ) , ( xipEntryCount ) ) ; <S2SV_EndBug> slotSize = MAXALIGN ( slotSize ) ; slotCount = NUM_SHARED_SNAPSHOT_SLOTS ; size = offsetof ( SharedSnapshotStruct , xips ) ; size = add_size ( size , mul_size ( slotSize , slotCount ) ) ; return MAXALIGN ( size ) ; }
|
<S2SV_ModStart> MaxBackends + max_prepared_xacts ; subxipEntryCount = MaxBackends * PGPROC_MAX_CACHED_SUBXIDS <S2SV_ModStart> , ( xipEntryCount ) ) ; slotSize += mul_size ( sizeof ( TransactionId ) , ( subxipEntryCount
|
6,819 |
CWE-000 int idmap_get_gid ( const char * name ) { struct sockaddr_un address ; struct SNFS4Message data ; int addrlen ; <S2SV_StartBug> int clisckt = socket ( AF_UNIX , SOCK_SEQPACKET , 0 ) ; <S2SV_EndBug> if ( clisckt == - 1 ) return ( - 1 ) ; memset ( & address , 0 , sizeof ( struct sockaddr_un ) ) ; address . sun_family = AF_UNIX ; strncpy ( address . sun_path , SERVERNAME , UNIX_PATH_MAX ) ; addrlen = strlen ( address . sun_path ) + sizeof ( address . sun_family ) ; if ( connect ( clisckt , ( struct sockaddr * ) & address , addrlen ) == - 1 ) return ( - 1 ) ; memset ( & data , 0 , sizeof ( data ) ) ; data . Type = MSG_IDMAP_REG_GROUP ; strncpy ( data . Name , name , MAX_NAME ) ; if ( write ( clisckt , & data , sizeof ( data ) ) != sizeof ( data ) ) { close ( clisckt ) ; return ( - 1 ) ; } memset ( & data , 0 , sizeof ( data ) ) ; if ( read ( clisckt , & data , sizeof ( data ) ) != sizeof ( data ) ) { close ( clisckt ) ; return ( - 1 ) ; } if ( data . Type != MSG_IDMAP_REG_GROUP ) { close ( clisckt ) ; return ( - 1 ) ; } close ( clisckt ) ; if ( data . ID > 0 ) return ( data . ID ) ; data . Name [ MAX_NAME ] = '\\0' ; <S2SV_StartBug> struct group * p_grp = getgrnam ( data . Name ) ; <S2SV_EndBug> if ( p_grp != NULL ) { return ( p_grp -> gr_gid ) ; } return ( get_gid ( "NOGROUP" ) ) ; }
|
<S2SV_ModStart> int addrlen ; struct group * p_grp ; <S2SV_ModStart> = '\\0' ; <S2SV_ModEnd> p_grp = getgrnam
|
6,820 |
CWE-000 static void process_syscall_ptr_arg ( u64 syscall , REF u64 args [ ] , index_t ptr_arg_index ) { ASSERT ( ptr_arg_index < SYSCALL_MAX_ARGS , "System<S2SV_blank>call<S2SV_blank>argument<S2SV_blank>index<S2SV_blank>%lu<S2SV_blank>out<S2SV_blank>of<S2SV_blank>range!" , ptr_arg_index ) ; void * arg_ptr = ( void * ) args [ ptr_arg_index ] ; if ( ! arg_ptr ) return ; void * canonical_ptr ; int result = vremap_resolve ( arg_ptr , OUT & canonical_ptr ) ; if ( result == VREM_OK ) { REF args [ ptr_arg_index ] = ( u64 ) canonical_ptr ; } else if ( result != VREM_NOT_REMAPPED ) { # if DANGLESS_CONFIG_SYSCALLMETA_HAS_INFO LOG ( "syscall<S2SV_blank>%s<S2SV_blank>arg<S2SV_blank>%lu<S2SV_blank>(%s<S2SV_blank>%s):<S2SV_blank>" , syscall_get_name ( syscall ) , ptr_arg_index , syscall_get_info ( syscall ) -> params [ ptr_arg_index ] . name , syscall_get_info ( syscall ) -> params [ ptr_arg_index ] . type ) ; # else LOG ( "syscall<S2SV_blank>%lu<S2SV_blank>arg<S2SV_blank>%lu:<S2SV_blank>" , syscall , ptr_arg_index ) ; # endif <S2SV_StartBug> LOG ( "could<S2SV_blank>not<S2SV_blank>translate<S2SV_blank>%p:<S2SV_blank>%s<S2SV_blank>(code<S2SV_blank>%d)\\n" , arg_ptr , vremap_diag ( ) , result ) ; <S2SV_EndBug> } }
|
<S2SV_ModStart> , vremap_diag ( result
|
6,821 |
CWE-000 static int start_new_child ( int pipes [ ] ) { int errln = - 1 ; int size , res , i , pos = 0 ; char * buff , * o_buff ; char * cmd , * wd , * * new_environ , * * args = NULL ; <S2SV_StartBug> Sint cnt , flags ; <S2SV_EndBug> do { res = read ( pipes [ 0 ] , ( char * ) & size , sizeof ( size ) ) ; } while ( res < 0 && ( errno == EINTR || errno == ERRNO_BLOCK ) ) ; if ( res <= 0 ) { errln = __LINE__ ; goto child_error ; } buff = malloc ( size ) ; DEBUG_PRINT ( "size<S2SV_blank>=<S2SV_blank>%d" , size ) ; do { if ( ( res = read ( pipes [ 0 ] , buff + pos , size - pos ) ) < 0 ) { if ( errno == ERRNO_BLOCK || errno == EINTR ) continue ; errln = __LINE__ ; goto child_error ; } if ( res == 0 ) { errno = EPIPE ; errln = __LINE__ ; goto child_error ; } pos += res ; } while ( size - pos != 0 ) ; o_buff = buff ; flags = get_int32 ( buff ) ; <S2SV_StartBug> buff += sizeof ( Sint32 ) ; <S2SV_EndBug> DEBUG_PRINT ( "flags<S2SV_blank>=<S2SV_blank>%d" , flags ) ; cmd = buff ; buff += strlen ( buff ) + 1 ; if ( * buff == '\\0' ) { wd = NULL ; } else { wd = buff ; buff += strlen ( buff ) + 1 ; } buff ++ ; DEBUG_PRINT ( "wd<S2SV_blank>=<S2SV_blank>%s" , wd ) ; cnt = get_int32 ( buff ) ; <S2SV_StartBug> buff += sizeof ( Sint32 ) ; <S2SV_EndBug> new_environ = malloc ( sizeof ( char * ) * ( cnt + 1 ) ) ; <S2SV_StartBug> DEBUG_PRINT ( "env_len<S2SV_blank>=<S2SV_blank>%ld" , cnt ) ; <S2SV_EndBug> for ( i = 0 ; i < cnt ; i ++ , buff ++ ) { new_environ [ i ] = buff ; while ( * buff != '\\0' ) buff ++ ; } new_environ [ cnt ] = NULL ; if ( o_buff + size != buff ) { cnt = get_int32 ( buff ) ; <S2SV_StartBug> buff += sizeof ( Sint32 ) ; <S2SV_EndBug> args = malloc ( sizeof ( char * ) * ( cnt + 1 ) ) ; for ( i = 0 ; i < cnt ; i ++ , buff ++ ) { args [ i ] = buff ; while ( * buff != '\\0' ) buff ++ ; } args [ cnt ] = NULL ; } if ( o_buff + size != buff ) { errno = EINVAL ; errln = __LINE__ ; fprintf ( stderr , "erl_child_setup:<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>protocol<S2SV_blank>" "error<S2SV_blank>%d<S2SV_blank>on<S2SV_blank>line<S2SV_blank>%d" , errno , errln ) ; abort ( ) ; } DEBUG_PRINT ( "read<S2SV_blank>ack" ) ; do { ErtsSysForkerProto proto ; res = read ( pipes [ 0 ] , & proto , sizeof ( proto ) ) ; if ( res > 0 ) { ASSERT ( proto . action == ErtsSysForkerProtoAction_Ack ) ; ASSERT ( res == sizeof ( proto ) ) ; } } while ( res < 0 && ( errno == EINTR || errno == ERRNO_BLOCK ) ) ; if ( res < 1 ) { errno = EPIPE ; errln = __LINE__ ; goto child_error ; } <S2SV_StartBug> DEBUG_PRINT ( "Do<S2SV_blank>that<S2SV_blank>forking<S2SV_blank>business:<S2SV_blank>\'%s\'\\n" , cmd ) ; <S2SV_EndBug> if ( wd && chdir ( wd ) < 0 ) { errln = __LINE__ ; goto child_error ; <S2SV_StartBug> } <S2SV_EndBug> if ( flags & FORKER_FLAG_USE_STDIO ) { if ( flags & FORKER_FLAG_DO_WRITE && dup2 ( pipes [ 0 ] , 0 ) < 0 ) { errln = __LINE__ ; goto child_error ; } if ( flags & FORKER_FLAG_DO_READ && dup2 ( pipes [ 1 ] , 1 ) < 0 ) { errln = __LINE__ ; goto child_error ; } } else { if ( flags & FORKER_FLAG_DO_READ && dup2 ( pipes [ 1 ] , 4 ) < 0 ) { errln = __LINE__ ; goto child_error ; } if ( flags & FORKER_FLAG_DO_WRITE && dup2 ( pipes [ 0 ] , 3 ) < 0 ) { errln = __LINE__ ; goto child_error ; } } if ( dup2 ( pipes [ 2 ] , 2 ) < 0 ) { errln = __LINE__ ; goto child_error ; } # if defined ( USE_SETPGRP_NOARGS ) ( void ) setpgrp ( ) ; # elif defined ( USE_SETPGRP ) ( void ) setpgrp ( 0 , getpid ( ) ) ; # else ( void ) setsid ( ) ; # endif close ( pipes [ 0 ] ) ; close ( pipes [ 1 ] ) ; close ( pipes [ 2 ] ) ; sys_sigrelease ( SIGCHLD ) ; if ( args ) { execve ( cmd , args , new_environ ) ; } else { execle ( SHELL , "sh" , "-c" , cmd , ( char * ) NULL , new_environ ) ; } DEBUG_PRINT ( "exec<S2SV_blank>error:<S2SV_blank>%d" , errno ) ; _exit ( errno ) ; child_error : <S2SV_StartBug> fprintf ( stderr , "erl_child_setup:<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>error<S2SV_blank>%d<S2SV_blank>on<S2SV_blank>line<S2SV_blank>%d" , <S2SV_EndBug> errno , errln ) ; _exit ( errno ) ; }
|
<S2SV_ModStart> = NULL ; Sint32 <S2SV_ModEnd> cnt , flags <S2SV_ModStart> += sizeof ( flags <S2SV_ModEnd> ) ; DEBUG_PRINT <S2SV_ModStart> += sizeof ( cnt <S2SV_ModEnd> ) ; new_environ <S2SV_ModStart> ; DEBUG_PRINT ( "env_len<S2SV_blank>=<S2SV_blank>%d" <S2SV_ModEnd> , cnt ) <S2SV_ModStart> += sizeof ( cnt <S2SV_ModEnd> ) ; args <S2SV_ModStart> } DEBUG_PRINT ( "Set<S2SV_blank>wd<S2SV_blank>to:<S2SV_blank>\'%s\'" , wd <S2SV_ModEnd> ) ; if <S2SV_ModStart> child_error ; } DEBUG_PRINT ( "Do<S2SV_blank>that<S2SV_blank>forking<S2SV_blank>business:<S2SV_blank>\'%s\'" , cmd ) ; <S2SV_ModStart> ( stderr , "erl_child_setup:<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>error<S2SV_blank>%d<S2SV_blank>on<S2SV_blank>line<S2SV_blank>%d\\r\\n" <S2SV_ModEnd> , errno ,
|
6,822 |
CWE-000 static real_t * silo_file_read_mesh_field ( silo_file_t * file , mesh_centering_t centering , const char * * field_component_names , const char * mesh_name , int num_components , silo_field_metadata_t * * field_metadata ) <S2SV_StartBug> { <S2SV_EndBug> ASSERT ( file -> mode == DB_READ ) ; set_domain_dir ( file ) ; char num_elems_var [ FILENAME_MAX + 1 ] ; int cent = DB_ZONECENT ; switch ( centering ) { case MESH_CELL : cent = DB_ZONECENT ; snprintf ( num_elems_var , FILENAME_MAX , "%s_mesh_num_cells" , mesh_name ) ; break ; case MESH_FACE : cent = DB_FACECENT ; snprintf ( num_elems_var , FILENAME_MAX , "%s_mesh_num_faces" , mesh_name ) ; break ; case MESH_EDGE : cent = DB_EDGECENT ; snprintf ( num_elems_var , FILENAME_MAX , "%s_mesh_num_edges" , mesh_name ) ; break ; case MESH_NODE : cent = DB_NODECENT ; snprintf ( num_elems_var , FILENAME_MAX , "%s_mesh_num_nodes" , mesh_name ) ; } ASSERT ( DBInqVarExists ( file -> dbfile , num_elems_var ) ) ; int num_elems ; DBReadVar ( file -> dbfile , num_elems_var , & num_elems ) ; real_t * field = polymec_malloc ( sizeof ( real_t ) * num_components * num_elems ) ; if ( num_components == 1 ) { DBucdvar * var = DBGetUcdvar ( file -> dbfile , ( char * ) field_component_names [ 0 ] ) ; if ( var == NULL ) polymec_error ( "Field<S2SV_blank>\'%s\'<S2SV_blank>was<S2SV_blank>not<S2SV_blank>found<S2SV_blank>in<S2SV_blank>the<S2SV_blank>Silo<S2SV_blank>file." , field_component_names [ 0 ] ) ; if ( var -> centering != cent ) polymec_error ( "Field<S2SV_blank>\'%s\'<S2SV_blank>has<S2SV_blank>the<S2SV_blank>incorrect<S2SV_blank>centering." , field_component_names [ 0 ] ) ; memcpy ( field , var -> vals [ 0 ] , sizeof ( real_t ) * num_elems ) ; silo_field_metadata_t * metadata = ( field_metadata [ 0 ] != NULL ) ? field_metadata [ 0 ] : NULL ; read_mesh_metadata ( file -> dbfile , var , metadata ) ; DBFreeUcdvar ( var ) ; } else { for ( int c = 0 ; c < num_components ; ++ c ) { DBucdvar * var = DBGetUcdvar ( file -> dbfile , ( char * ) field_component_names [ c ] ) ; if ( var == NULL ) polymec_error ( "Field<S2SV_blank>\'%s\'<S2SV_blank>was<S2SV_blank>not<S2SV_blank>found<S2SV_blank>in<S2SV_blank>the<S2SV_blank>Silo<S2SV_blank>file." , field_component_names [ c ] ) ; if ( var -> centering != cent ) polymec_error ( "Field<S2SV_blank>\'%s\'<S2SV_blank>has<S2SV_blank>the<S2SV_blank>incorrect<S2SV_blank>centering." , field_component_names [ c ] ) ; real_t * data = var -> vals [ c ] ; for ( int i = 0 ; i < num_elems ; ++ i ) field [ num_components * i + c ] = data [ i ] ; read_mesh_metadata ( file -> dbfile , var , ( field_metadata != NULL ) ? field_metadata [ c ] : NULL ) ; DBFreeUcdvar ( var ) ; } } set_root_dir ( file ) ; <S2SV_StartBug> return field ; <S2SV_EndBug> }
|
<S2SV_ModStart> field_metadata ) { START_FUNCTION_TIMER ( ) ; <S2SV_ModStart> file ) ; STOP_FUNCTION_TIMER ( ) ;
|
6,823 |
CWE-000 void traverse ( t_format * format , va_list args ) { while ( FSP ) { if ( FSP == '%' ) { format -> pos ++ ; if ( FSP == '%' ) { write ( 1 , "%" , 1 ) ; format -> num_writt ++ ; format -> pos ++ ; } manage_format ( format , args ) ; } else { <S2SV_StartBug> ft_putchar ( FSP ) ; <S2SV_EndBug> format -> num_writt ++ ; format -> pos ++ ; } } }
|
<S2SV_ModStart> } else { write ( 1 , & FSP , 1 <S2SV_ModEnd> ) ; format
|
6,824 |
CWE-000 static void insert_address ( Memory memory , unsigned long int address , Operation op ) { Cache L1 = memory -> L1 ; Cache L2 = memory -> L2 ; unsigned long int lru_address ; bool isDirty = false ; WriteResult res ; if ( TryAccess ( L2 , address ) == MISS ) { res = writeAddress ( L2 , address , & lru_address , & isDirty ) ; if ( res == REPLACED ) { snoop_cache ( L1 , lru_address ) ; } if ( op == OP_WRITE && memory -> write_policy == NO_WRITE_ALLOC ) setDirty ( L2 , address ) ; } if ( op == OP_READ || ( op == OP_WRITE && memory -> write_policy == WRITE_ALLOC ) ) { assert ( TryAccess ( L1 , address ) == MISS ) ; res = writeAddress ( L1 , address , & lru_address , & isDirty ) ; if ( res == REPLACED ) { assert ( TryAccess ( L2 , lru_address ) == HIT ) ; writeAddress ( L2 , lru_address , NULL , NULL ) ; } if ( op == OP_WRITE ) setDirty ( L1 , address ) ; } <S2SV_StartBug> if ( op == WRITE_ALLOC ) <S2SV_EndBug> setDirty ( L2 , address ) ; }
|
<S2SV_ModStart> ) ; } <S2SV_ModEnd> } <S2SV_null> <S2SV_null>
|
6,825 |
CWE-000 static int Open ( vlc_object_t * p_this ) { stream_t * p_access = ( stream_t * ) p_this ; access_sys_t * p_sys ; if ( p_access -> b_preparsing ) return VLC_EGENERIC ; p_access -> p_sys = p_sys = calloc ( 1 , sizeof ( access_sys_t ) ) ; if ( ! p_sys ) return VLC_ENOMEM ; VarInit ( p_access ) ; if ( ParseMRL ( p_access ) ) { free ( p_sys ) ; return VLC_EGENERIC ; } bool b_scan_mode = var_GetInteger ( p_access , "dvb-frequency" ) == 0 ; if ( b_scan_mode ) { msg_Dbg ( p_access , "DVB<S2SV_blank>scan<S2SV_blank>mode<S2SV_blank>selected" ) ; p_access -> pf_block = BlockScan ; } else <S2SV_StartBug> return VLC_EGENERIC ; <S2SV_EndBug> if ( FrontendOpen ( p_this , & p_sys -> dvb , p_access -> psz_name ) ) { free ( p_sys ) ; return VLC_EGENERIC ; } if ( DVROpen ( p_this , & p_sys -> dvb ) < 0 ) { FrontendClose ( p_this , & p_sys -> dvb ) ; free ( p_sys ) ; return VLC_EGENERIC ; } scan_parameter_t parameter ; scan_t * p_scan ; scan_parameter_Init ( & parameter ) ; parameter . b_use_nit = var_InheritBool ( p_access , "dvb-scan-nit" ) ; if ( FrontendFillScanParameter ( p_this , & p_sys -> dvb , & parameter ) || ( p_scan = scan_New ( VLC_OBJECT ( p_access ) , & parameter , ScanFrontendTuningHandler , ScanStatsCallback , ScanFilterHandler , ScanReadCallback , p_access ) ) == NULL ) { scan_parameter_Clean ( & parameter ) ; Close ( VLC_OBJECT ( p_access ) ) ; return VLC_EGENERIC ; } scan_parameter_Clean ( & parameter ) ; p_sys -> scan = p_scan ; p_access -> pf_control = Control ; return VLC_SUCCESS ; }
|
<S2SV_ModStart> ; } else { free ( p_sys ) ; return VLC_EGENERIC ; } <S2SV_ModEnd> if ( FrontendOpen
|
6,826 |
CWE-000 void ofi_idx_replace ( struct indexer * idx , int index , void * item ) { <S2SV_StartBug> union ofi_idx_entry * entry ; <S2SV_EndBug> entry = idx -> array [ ofi_idx_array_index ( index ) ] ; entry [ ofi_idx_entry_index ( index ) ] . item = item ; }
|
<S2SV_ModStart> item ) { struct <S2SV_ModEnd> ofi_idx_entry * entry
|
6,827 |
CWE-000 static VALUE exc_setup_cause ( VALUE exc , VALUE cause ) { # if SUPPORT_JOKE if ( NIL_P ( cause ) ) { ID id_true_cause ; CONST_ID ( id_true_cause , "true_cause" ) ; cause = rb_attr_get ( rb_eFatal , id_true_cause ) ; if ( NIL_P ( cause ) ) { cause = rb_exc_new_cstr ( rb_eFatal , "because<S2SV_blank>using<S2SV_blank>such<S2SV_blank>Ruby" ) ; rb_ivar_set ( cause , id_cause , INT2FIX ( 42 ) ) ; OBJ_FREEZE ( cause ) ; rb_ivar_set ( rb_eFatal , id_true_cause , cause ) ; } } # endif <S2SV_StartBug> if ( ! NIL_P ( cause ) && cause != exc ) { <S2SV_EndBug> rb_ivar_set ( exc , id_cause , cause ) ; <S2SV_StartBug> } <S2SV_EndBug> return exc ; }
|
<S2SV_ModStart> cause != exc && BUILTIN_TYPE ( cause ) != T_NODE <S2SV_ModStart> cause ) ; if ( ! rb_ivar_defined ( cause , id_cause ) ) { rb_ivar_set ( cause , id_cause , Qnil ) ; }
|
6,828 |
CWE-000 struct filediff * <S2SV_StartBug> unpack ( struct filediff * f , int tree , char * * tmp , <S2SV_EndBug> int type ) { enum uz_id id ; struct filediff * z ; int i ; char * s ; if ( ( tree == 1 && ! S_ISREG ( f -> type [ 0 ] ) ) || ( tree == 2 && ! S_ISREG ( bmode ? f -> type [ 0 ] : f -> type [ 1 ] ) ) ) return NULL ; s = f -> name ? f -> name : bmode ? gl_mark : tree == 1 ? mark_lnam : mark_rnam ; if ( ( id = check_ext ( s , & i ) ) == UZ_NONE ) return NULL ; switch ( id ) { case UZ_TGZ : case UZ_TBZ : case UZ_TAR : case UZ_TXZ : case UZ_ZIP : case UZ_TAR_Z : if ( ! ( type & 1 ) ) { return NULL ; } default : ; } if ( mktmpdirs ( ) ) return NULL ; switch ( id ) { case UZ_GZ : z = zcat ( "zcat" , f , tree , i ) ; break ; case UZ_BZ2 : z = zcat ( "bzcat" , f , tree , i ) ; break ; case UZ_XZ : z = zcat ( "xzcat" , f , tree , i ) ; break ; case UZ_TGZ : z = tar ( "xzf" , f , tree , i , type & 4 ? 1 : 0 ) ; break ; case UZ_TBZ : z = tar ( "xjf" , f , tree , i , type & 4 ? 1 : 0 ) ; break ; case UZ_TAR : z = tar ( "xf" , f , tree , i , type & 4 ? 1 : 0 ) ; break ; case UZ_TXZ : z = tar ( "xJf" , f , tree , i , type & 4 ? 1 : 0 ) ; break ; case UZ_TAR_Z : z = tar ( "xZf" , f , tree , i , type & 4 ? 1 : 0 ) ; break ; case UZ_ZIP : z = unzip ( f , tree , i , type & 4 ? 1 : 0 ) ; break ; default : rmtmpdirs ( tmp_dir , TOOL_NOLIST | ( type & 2 ? TOOL_NOCURS : 0 ) ) ; return NULL ; } * tmp = tmp_dir ; return z ; }
|
<S2SV_ModStart> * unpack ( const
|
6,829 |
CWE-000 int main ( void ) { int fd ; uint8_t * address_from_mmap ; uint32_t len = 1920 * 1080 * 4 ; if ( ( fd = open ( "/dev/vpu-service" , O_RDWR | O_SYNC ) ) < 0 ) { perror ( "open" ) ; exit ( - 1 ) ; } fprintf ( stderr , "mmap_alloc:<S2SV_blank>open<S2SV_blank>OK\\n" ) ; address_from_mmap = mmap ( 0 , len , PROT_READ | PROT_WRITE , MAP_SHARED | MAP_LOCKED , fd , 0 ) ; if ( address_from_mmap == MAP_FAILED ) { perror ( "mmap" ) ; exit ( - 1 ) ; } int const out_fd = open ( "output_frame" , O_RDWR | O_CREAT , 00664 ) ; if ( out_fd < 0 ) perror ( "Could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>the<S2SV_blank>output<S2SV_blank>file\\n" ) ; else { write ( out_fd , address_from_mmap , len ) ; close ( out_fd ) ; } <S2SV_StartBug> ioctl ( fd , MYY_IOCTL_DUMP_OUTPUT_FIRST_BYTES , NULL ) ; <S2SV_EndBug> fprintf ( stderr , "mmap_alloc:<S2SV_blank>mmap<S2SV_blank>OK<S2SV_blank>-<S2SV_blank>Address<S2SV_blank>:<S2SV_blank>%p\\n" , address_from_mmap ) ; fprintf ( stderr , "closing...\\n" ) ; close ( fd ) ; }
|
<S2SV_ModStart> ) ; } uint32_t regs [ 41 ] ; <S2SV_ModStart> ( fd , MYY_IOCTL_VPU_COPY_REGISTERS , regs ) ; printf ( "uint32_t<S2SV_blank>regs[41]<S2SV_blank>=<S2SV_blank>{\\n\\t" ) ; for ( uint_fast8_t i = 0 ; i < 41 ; i ++ ) { printf ( "0x%08x,<S2SV_blank>" , regs [ i ] ) ; if ( i % 7 == 7 ) printf ( "\\n\\t" ) ; } printf ( "\\n};\\n" <S2SV_ModEnd> ) ; fprintf
|
6,830 |
CWE-000 Item list_pop_back ( List * plist ) { Item item_t ; memset ( & item_t , 0 , sizeof ( item_t ) ) ; if ( plist -> head == plist -> this ) { fprintf ( stderr , "Empty<S2SV_blank>list!<S2SV_blank>Meaningless<S2SV_blank>return<S2SV_blank>value!\\n" ) ; return item_t ; } <S2SV_StartBug> item_t = plist -> tail -> item ; <S2SV_EndBug> <S2SV_StartBug> Iterator pt = plist -> tail -> prev ; <S2SV_EndBug> <S2SV_StartBug> pt -> next = plist -> this ; <S2SV_EndBug> <S2SV_StartBug> if ( plist -> head == plist -> tail ) plist -> head = plist -> this ; <S2SV_EndBug> free ( plist -> tail ) ; <S2SV_StartBug> plist -> tail = pt ; <S2SV_EndBug> plist -> count -- ; return item_t ; <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> item_t ; } else { <S2SV_ModStart> item ; Iterator pprev <S2SV_ModEnd> = plist -> <S2SV_ModStart> -> prev ; if ( pprev == plist -> this ) { plist -> head = plist -> this ; } else { pprev <S2SV_ModEnd> -> next = <S2SV_ModStart> -> this ; } <S2SV_ModEnd> free ( plist <S2SV_ModStart> -> tail = pprev <S2SV_ModEnd> ; plist -> <S2SV_ModStart> item_t ; } }
|
6,831 |
CWE-000 float avgTurnaroundTime ( Proc * * procs , int numProcs ) { <S2SV_StartBug> int procNdx , numFinished = 0 ; ; <S2SV_EndBug> float sum = 0 ; for ( procNdx = 0 ; procNdx < numProcs ; procNdx ++ ) { <S2SV_StartBug> if ( ( * ( procs + procNdx ) ) -> start > 0 ) { <S2SV_EndBug> sum += ( ( * ( procs + procNdx ) ) -> end - ( * ( procs + procNdx ) ) -> arv ) ; numFinished ++ ; } } return sum / numFinished ; }
|
<S2SV_ModStart> numFinished = 0 <S2SV_ModEnd> ; float sum <S2SV_ModStart> ) ) -> end <S2SV_ModEnd> > 0 )
|
6,832 |
CWE-000 PetscErrorCode MatMult_Laplacian ( Mat A , Vec x , Vec y ) { AppCtx * appctx ; PetscErrorCode ierr ; PetscReal * * temp , vv ; PetscInt i , j , xs , xn ; Vec xlocal , ylocal ; const PetscScalar * xl ; PetscScalar * yl ; <S2SV_StartBug> PetscMPIInt _One = 1 , n ; <S2SV_EndBug> PetscScalar _DOne = 1 ; ierr = MatShellGetContext ( A , & appctx ) ; CHKERRQ ( ierr ) ; ierr = DMGetLocalVector ( appctx -> da , & xlocal ) ; CHKERRQ ( ierr ) ; ierr = DMGlobalToLocalBegin ( appctx -> da , x , INSERT_VALUES , xlocal ) ; CHKERRQ ( ierr ) ; ierr = DMGlobalToLocalEnd ( appctx -> da , x , INSERT_VALUES , xlocal ) ; CHKERRQ ( ierr ) ; ierr = DMGetLocalVector ( appctx -> da , & ylocal ) ; CHKERRQ ( ierr ) ; ierr = VecSet ( ylocal , 0.0 ) ; CHKERRQ ( ierr ) ; ierr = PetscGLLElementLaplacianCreate ( & appctx -> SEMop . gll , & temp ) ; CHKERRQ ( ierr ) ; for ( i = 0 ; i < appctx -> param . N ; i ++ ) { vv = - appctx -> param . mu * 2.0 / appctx -> param . Le ; for ( j = 0 ; j < appctx -> param . N ; j ++ ) temp [ i ] [ j ] = temp [ i ] [ j ] * vv ; } ierr = DMDAVecGetArrayRead ( appctx -> da , xlocal , & xl ) ; CHKERRQ ( ierr ) ; ierr = DMDAVecGetArray ( appctx -> da , ylocal , & yl ) ; CHKERRQ ( ierr ) ; ierr = DMDAGetCorners ( appctx -> da , & xs , NULL , NULL , & xn , NULL , NULL ) ; CHKERRQ ( ierr ) ; ierr = PetscBLASIntCast ( appctx -> param . N , & n ) ; CHKERRQ ( ierr ) ; for ( j = xs ; j < xs + xn ; j += appctx -> param . N - 1 ) { PetscStackCallBLAS ( "BLASgemv" , BLASgemv_ ( "N" , & n , & n , & _DOne , & temp [ 0 ] [ 0 ] , & n , & xl [ j ] , & _One , & _DOne , & yl [ j ] , & _One ) ) ; } ierr = DMDAVecRestoreArrayRead ( appctx -> da , xlocal , & xl ) ; CHKERRQ ( ierr ) ; ierr = DMDAVecRestoreArray ( appctx -> da , ylocal , & yl ) ; CHKERRQ ( ierr ) ; ierr = PetscGLLElementLaplacianDestroy ( & appctx -> SEMop . gll , & temp ) ; CHKERRQ ( ierr ) ; ierr = VecSet ( y , 0.0 ) ; CHKERRQ ( ierr ) ; ierr = DMLocalToGlobalBegin ( appctx -> da , ylocal , ADD_VALUES , y ) ; CHKERRQ ( ierr ) ; ierr = DMLocalToGlobalEnd ( appctx -> da , ylocal , ADD_VALUES , y ) ; CHKERRQ ( ierr ) ; ierr = DMRestoreLocalVector ( appctx -> da , & xlocal ) ; CHKERRQ ( ierr ) ; ierr = DMRestoreLocalVector ( appctx -> da , & ylocal ) ; CHKERRQ ( ierr ) ; ierr = VecPointwiseDivide ( y , y , appctx -> SEMop . mass ) ; CHKERRQ ( ierr ) ; return 0 ; }
|
<S2SV_ModStart> * yl ; PetscBLASInt <S2SV_ModEnd> _One = 1
|
6,833 |
CWE-000 void start_game ( t_vm * vm ) { int i ; int c ; int l ; t_player * tmp ; if ( vm -> player == NULL ) print_usage ( ) ; sort_players ( vm ) ; c = count_players ( vm ) ; l = MEM_SIZE / c ; tmp = vm -> player ; i = 0 ; while ( tmp != NULL ) { c = - 1 ; while ( tmp -> instructions [ ++ c ] ) { vm -> mem [ i + ( c / 2 ) + ( c % 2 ) ] -> value = hex_to_int ( tmp -> instructions [ c ] ) * 16 + hex_to_int ( tmp -> instructions [ c + 1 ] ) ; vm -> mem [ i + ( c / 2 ) + ( c % 2 ) ] -> player = tmp ; c ++ ; } add_process ( vm , i , tmp ) ; i += l ; tmp = tmp -> next ; } if ( vm -> visual_mode == 1 ) initiate_visualization ( vm ) ; <S2SV_StartBug> while ( 1 ) <S2SV_EndBug> game_move ( vm ) ; }
|
<S2SV_ModStart> ; while ( vm -> game_on ==
|
6,834 |
CWE-000 void dat_release ( dat_trie_ptr p ) { if ( p != NULL ) { <S2SV_StartBug> dict_release ( p -> _dict ) ; <S2SV_EndBug> <S2SV_StartBug> for ( int i = 0 ; i < POOL_REGION_SIZE ; ++ i ) { <S2SV_EndBug> if ( p -> _nodepool [ i ] != NULL ) free ( p -> _nodepool [ i ] ) ; } free ( p ) ; } }
|
<S2SV_ModStart> NULL ) { int i ; <S2SV_ModStart> ; for ( <S2SV_ModEnd> i = 0
|
6,835 |
CWE-000 int fuse_do_setattr ( struct dentry * dentry , struct iattr * attr , struct file * file ) { <S2SV_StartBug> struct inode * inode = d_inode ( dentry ) ; <S2SV_EndBug> struct fuse_conn * fc = get_fuse_conn ( inode ) ; struct fuse_inode * fi = get_fuse_inode ( inode ) ; struct fuse_req * req ; struct fuse_setattr_in inarg ; struct fuse_attr_out outarg ; bool is_truncate = false ; bool is_wb = fc -> writeback_cache ; loff_t oldsize ; int err ; bool trust_local_mtime = is_wb && S_ISREG ( inode -> i_mode ) ; if ( ! ( fc -> flags & FUSE_DEFAULT_PERMISSIONS ) ) attr -> ia_valid |= ATTR_FORCE ; err = inode_change_ok ( inode , attr ) ; if ( err ) return err ; if ( attr -> ia_valid & ATTR_OPEN ) { if ( fc -> atomic_o_trunc ) return 0 ; file = NULL ; } if ( attr -> ia_valid & ATTR_SIZE ) is_truncate = true ; req = fuse_get_req_nopages ( fc ) ; if ( IS_ERR ( req ) ) return PTR_ERR ( req ) ; if ( is_truncate ) { fuse_set_nowrite ( inode ) ; set_bit ( FUSE_I_SIZE_UNSTABLE , & fi -> state ) ; } memset ( & inarg , 0 , sizeof ( inarg ) ) ; memset ( & outarg , 0 , sizeof ( outarg ) ) ; iattr_to_fattr ( attr , & inarg , trust_local_mtime ) ; if ( file ) { struct fuse_file * ff = file -> private_data ; inarg . valid |= FATTR_FH ; inarg . fh = ff -> fh ; } if ( attr -> ia_valid & ATTR_SIZE ) { inarg . valid |= FATTR_LOCKOWNER ; inarg . lock_owner = fuse_lock_owner_id ( fc , current -> files ) ; } fuse_setattr_fill ( fc , req , inode , & inarg , & outarg ) ; fuse_request_send ( fc , req ) ; err = req -> out . h . error ; fuse_put_request ( fc , req ) ; if ( err ) { if ( err == - EINTR ) fuse_invalidate_attr ( inode ) ; goto error ; } if ( ( inode -> i_mode ^ outarg . attr . mode ) & S_IFMT ) { make_bad_inode ( inode ) ; err = - EIO ; goto error ; } spin_lock ( & fc -> lock ) ; if ( trust_local_mtime && ( attr -> ia_valid & ATTR_MTIME ) ) { inode -> i_mtime = attr -> ia_mtime ; clear_bit ( FUSE_I_MTIME_DIRTY , & fi -> state ) ; } fuse_change_attributes_common ( inode , & outarg . attr , attr_timeout ( & outarg ) ) ; oldsize = inode -> i_size ; if ( ! is_wb || is_truncate || ! S_ISREG ( inode -> i_mode ) ) i_size_write ( inode , outarg . attr . size ) ; if ( is_truncate ) { __fuse_release_nowrite ( inode ) ; } spin_unlock ( & fc -> lock ) ; if ( ( is_truncate || ! is_wb ) && S_ISREG ( inode -> i_mode ) && oldsize != outarg . attr . size ) { truncate_pagecache ( inode , oldsize , outarg . attr . size ) ; invalidate_inode_pages2 ( inode -> i_mapping ) ; } clear_bit ( FUSE_I_SIZE_UNSTABLE , & fi -> state ) ; return 0 ; error : if ( is_truncate ) fuse_release_nowrite ( inode ) ; clear_bit ( FUSE_I_SIZE_UNSTABLE , & fi -> state ) ; return err ; }
|
<S2SV_ModStart> * inode = dentry <S2SV_ModEnd> ; struct fuse_conn
|
6,836 |
CWE-000 static void PSys_InitParticles ( void ) { int i ; memset ( PSys_Particles , 0 , sizeof ( PSys_Particles ) ) ; PSys_Particles_inuse . next = & PSys_Particles_inuse ; PSys_Particles_inuse . prev = & PSys_Particles_inuse ; PSys_Particles_free = PSys_Particles ; <S2SV_StartBug> for ( i = 0 ; i < MAX_PARTICLES - 1 ; ++ i ) <S2SV_EndBug> PSys_Particles [ i ] . next = & PSys_Particles [ i + 1 ] ; }
|
<S2SV_ModStart> - 1 ; i ++ <S2SV_ModEnd> ) PSys_Particles [
|
6,837 |
CWE-000 static int llog ( lua_State * L ) { int i ; int paramn = lua_gettop ( L ) ; silly_log ( "" ) ; for ( i = 1 ; i <= paramn ; i ++ ) { int type = lua_type ( L , i ) ; switch ( type ) { case LUA_TSTRING : silly_log_raw ( "%s<S2SV_blank>" , lua_tostring ( L , i ) ) ; break ; case LUA_TNUMBER : <S2SV_StartBug> silly_log_raw ( "%d<S2SV_blank>" , ( int ) lua_tointeger ( L , i ) ) ; <S2SV_EndBug> break ; case LUA_TBOOLEAN : silly_log_raw ( "%s<S2SV_blank>" , lua_toboolean ( L , i ) ? "true" : "false" ) ; break ; case LUA_TTABLE : silly_log_raw ( "table:<S2SV_blank>%p<S2SV_blank>" , lua_topointer ( L , i ) ) ; break ; case LUA_TNIL : silly_log_raw ( "#%d.null<S2SV_blank>" , i ) ; break ; default : return luaL_error ( L , "log<S2SV_blank>unspport<S2SV_blank>param#%d<S2SV_blank>type:%s" , i , lua_typename ( L , type ) ) ; } } silly_log_raw ( "\\n" ) ; return 0 ; }
|
<S2SV_ModStart> : silly_log_raw ( LUA_INTEGER_FMT "<S2SV_blank>" , <S2SV_ModEnd> lua_tointeger ( L
|
6,838 |
CWE-000 void cmd_fwrite ( ) { par_getsharp ( ) ; if ( ! prog_error ) { int handle = par_getint ( ) ; if ( ! prog_error ) { if ( code_peek ( ) == kwTYPE_EOC || code_peek ( ) == kwTYPE_LINE ) { if ( ! dev_fstatus ( handle ) ) { } else { <S2SV_StartBug> rt_raise ( "FIO:<S2SV_blank>FILE<S2SV_blank>IS<S2SV_blank>NOT<S2SV_blank>OPENED" ) ; <S2SV_EndBug> } return ; } par_getsep ( ) ; if ( ! prog_error ) { if ( dev_fstatus ( handle ) ) { byte code , exitf = 0 ; var_t * var_p ; do { code = code_peek ( ) ; switch ( code ) { case kwTYPE_LINE : case kwTYPE_EOC : exitf = 1 ; break ; case kwTYPE_SEP : code_skipsep ( ) ; break ; case kwTYPE_VAR : var_p = par_getvar_ptr ( ) ; if ( ! prog_error ) write_encoded_var ( handle , var_p ) ; break ; default : rt_raise ( "WRITE:<S2SV_blank>ONLY<S2SV_blank>VARIABLES<S2SV_blank>ARE<S2SV_blank>ALLOWED" ) ; } ; if ( prog_error ) { return ; } } while ( ! exitf ) ; } else { <S2SV_StartBug> rt_raise ( "FIO:<S2SV_blank>FILE<S2SV_blank>IS<S2SV_blank>NOT<S2SV_blank>OPENED" ) ; <S2SV_EndBug> } } } } }
|
<S2SV_ModStart> { rt_raise ( ERR_FILE_NOT_OPEN <S2SV_ModEnd> ) ; } <S2SV_ModStart> { rt_raise ( ERR_FILE_NOT_OPEN <S2SV_ModEnd> ) ; }
|
6,839 |
CWE-000 matvar_t * Mat_VarGetStructsLinear ( matvar_t * matvar , int start , int stride , int edge , int copy_fields ) { <S2SV_StartBug> int i , I , field , nfields ; <S2SV_EndBug> matvar_t * struct_slab , * * fields ; if ( matvar == NULL || matvar -> rank > 10 ) { struct_slab = NULL ; } else { <S2SV_StartBug> struct_slab = Mat_VarDuplicate ( matvar , 0 ) ; <S2SV_EndBug> if ( ! copy_fields ) struct_slab -> mem_conserve = 1 ; nfields = matvar -> internal -> num_fields ; struct_slab -> nbytes = edge * nfields * sizeof ( matvar_t * ) ; struct_slab -> data = malloc ( struct_slab -> nbytes ) ; struct_slab -> dims [ 0 ] = edge ; struct_slab -> dims [ 1 ] = 1 ; fields = ( matvar_t * * ) struct_slab -> data ; I = start * nfields ; for ( i = 0 ; i < edge ; i ++ ) { if ( copy_fields ) { for ( field = 0 ; field < nfields ; field ++ ) { fields [ i * nfields + field ] = Mat_VarDuplicate ( * ( ( matvar_t * * ) matvar -> data + I ) , 1 ) ; I ++ ; } } else { for ( field = 0 ; field < nfields ; field ++ ) { fields [ i * nfields + field ] = * ( ( matvar_t * * ) matvar -> data + I ) ; I ++ ; } } I += ( stride - 1 ) * nfields ; } } return struct_slab ; }
|
<S2SV_ModStart> copy_fields ) { matvar_t * struct_slab <S2SV_ModEnd> ; if ( <S2SV_ModStart> } else { int i , I , field , nfields ; matvar_t * * fields ;
|
6,840 |
CWE-000 void buf_init_once ( void ) { for ( int i = 0 ; i < MAX_SPECIFIC_DATA ; ++ i ) pthread_key_create ( & buf_key [ i ] , free ) ; <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> free ) ; pthread_key_create ( & buf_id , free ) ;
|
6,841 |
CWE-000 int mlx5e_xdp_xmit ( struct net_device * dev , int n , struct xdp_frame * * frames , u32 flags ) { struct mlx5e_priv * priv = netdev_priv ( dev ) ; struct mlx5e_xdpsq * sq ; int drops = 0 ; int sq_num ; int i ; if ( unlikely ( ! test_bit ( MLX5E_STATE_OPENED , & priv -> state ) ) ) return - ENETDOWN ; if ( unlikely ( flags & ~ XDP_XMIT_FLAGS_MASK ) ) return - EINVAL ; sq_num = smp_processor_id ( ) ; if ( unlikely ( sq_num >= priv -> channels . num ) ) return - ENXIO ; sq = & priv -> channels . c [ sq_num ] -> xdpsq ; if ( unlikely ( ! test_bit ( MLX5E_SQ_STATE_ENABLED , & sq -> state ) ) ) return - ENETDOWN ; for ( i = 0 ; i < n ; i ++ ) { struct xdp_frame * xdpf = frames [ i ] ; struct mlx5e_xdp_info xdpi ; xdpi . dma_addr = dma_map_single ( sq -> pdev , xdpf -> data , xdpf -> len , DMA_TO_DEVICE ) ; if ( unlikely ( dma_mapping_error ( sq -> pdev , xdpi . dma_addr ) ) ) { <S2SV_StartBug> drops ++ ; <S2SV_EndBug> continue ; } xdpi . xdpf = xdpf ; if ( unlikely ( ! mlx5e_xmit_xdp_frame ( sq , & xdpi ) ) ) { <S2SV_StartBug> xdp_return_frame_rx_napi ( xdpf ) ; <S2SV_EndBug> drops ++ ; } } if ( flags & XDP_XMIT_FLUSH ) mlx5e_xmit_xdp_doorbell ( sq ) ; return n - drops ; }
|
<S2SV_ModStart> ) ) { xdp_return_frame_rx_napi ( xdpf ) ; <S2SV_ModStart> ) ) { dma_unmap_single ( sq -> pdev , xdpi . dma_addr , xdpf -> len , DMA_TO_DEVICE ) ;
|
6,842 |
CWE-000 int fasync_remove_entry ( struct file * filp , struct fasync_struct * * fapp ) { struct fasync_struct * fa , * * fp ; int result = 0 ; spin_lock ( & filp -> f_lock ) ; spin_lock ( & fasync_lock ) ; for ( fp = fapp ; ( fa = * fp ) != NULL ; fp = & fa -> fa_next ) { if ( fa -> fa_file != filp ) continue ; <S2SV_StartBug> spin_lock_irq ( & fa -> fa_lock ) ; <S2SV_EndBug> fa -> fa_file = NULL ; <S2SV_StartBug> spin_unlock_irq ( & fa -> fa_lock ) ; <S2SV_EndBug> * fp = fa -> fa_next ; call_rcu ( & fa -> fa_rcu , fasync_free_rcu ) ; filp -> f_flags &= ~ FASYNC ; result = 1 ; break ; } spin_unlock ( & fasync_lock ) ; spin_unlock ( & filp -> f_lock ) ; return result ; }
|
<S2SV_ModStart> ) continue ; write_lock_irq <S2SV_ModEnd> ( & fa <S2SV_ModStart> = NULL ; write_unlock_irq <S2SV_ModEnd> ( & fa
|
6,843 |
CWE-000 L_qnode * BuyNode ( int val ) { <S2SV_StartBug> L_qnode * pTmp = malloc ( sizeof ( L_qnode ) ) ; <S2SV_EndBug> assert ( pTmp != NULL ) ; pTmp -> data = val ; pTmp -> next = NULL ; return pTmp ; }
|
<S2SV_ModStart> * pTmp = ( L_qnode * )
|
6,844 |
CWE-000 int load_buffer ( char * buf , struct audit_log_entry_t * audit_log ) { char * mark = NULL ; int res = 0 ; int count = 0 ; int buf_len = strlen ( buf ) ; while ( buf_len > count && buf [ count ] != '\\n' ) { count ++ ; } if ( buf [ count ] != '\\n' ) { e ( "Not<S2SV_blank>an<S2SV_blank>valid<S2SV_blank>audit<S2SV_blank>log<S2SV_blank>entry" ) ; res = - 1 ; goto not_valid_audit_log ; } mark = malloc ( sizeof ( char ) * ( count - 3 + 1 ) ) ; memset ( mark , '\\0' , count - 3 + 1 ) ; mark = strncpy ( mark , buf , count - 3 ) ; char number [ 20 ] ; memset ( number , '\\0' , 20 ) ; <S2SV_StartBug> snprintf ( number , 20 , "%d" , strlen ( buf ) ) ; <S2SV_EndBug> audit_log -> mark = mark ; audit_log -> buf = buf ; audit_log -> buf_len = strlen ( buf ) ; audit_log -> audit_size = strdup ( number ) ; audit_log -> md5 = md5sum ( buf , audit_log -> buf_len ) ; audit_log -> uploaded = 0 ; audit_log -> section_a = load_section ( 'A' , audit_log ) ; audit_log -> section_b = load_section ( 'B' , audit_log ) ; audit_log -> section_f = load_section ( 'F' , audit_log ) ; audit_log -> section_e = load_section ( 'E' , audit_log ) ; audit_log -> section_h = load_section ( 'H' , audit_log ) ; res = parse_section_a ( audit_log ) ; res = parse_section_b ( audit_log ) ; res = parse_section_f ( audit_log ) ; size_t a = strlen ( audit_log -> hostname ) + 1 + strlen ( audit_log -> remote_addr ) + 1 + strlen ( audit_log -> remote_user ) + 1 + strlen ( audit_log -> local_user ) + 1 + strlen ( audit_log -> logtime ) + 1 + strlen ( audit_log -> request ) + 1 + 2 + strlen ( audit_log -> response_status ) + 1 + strlen ( audit_log -> bytes_sent ) + 1 + strlen ( audit_log -> refer ) + 1 + 2 + strlen ( audit_log -> user_agent ) + 1 + 2 + strlen ( audit_log -> uniqueid ) + 1 + strlen ( audit_log -> sessionid ) + 1 + 2 + strlen ( audit_log -> audit_file ) + 1 + strlen ( audit_log -> extra ) + 1 + strlen ( audit_log -> md5 ) + 1 + 4 + strlen ( audit_log -> audit_size ) + 1 ; audit_log -> summary_line = malloc ( a + 1 ) ; memset ( audit_log -> summary_line , '\\0' , a + 1 ) ; snprintf ( audit_log -> summary_line , a , "%s<S2SV_blank>%s<S2SV_blank>%s<S2SV_blank>%s<S2SV_blank>%s<S2SV_blank>\\"%s\\"<S2SV_blank>%s<S2SV_blank>%s<S2SV_blank>\\"%s\\"<S2SV_blank>\\"%s\\"<S2SV_blank>%s<S2SV_blank>\\"%s\\"<S2SV_blank>%s<S2SV_blank>%s<S2SV_blank>%s<S2SV_blank>md5:%s\\n" , audit_log -> hostname , audit_log -> remote_addr , audit_log -> remote_user , audit_log -> local_user , audit_log -> logtime , audit_log -> request , audit_log -> response_status , audit_log -> bytes_sent , audit_log -> refer , audit_log -> user_agent , audit_log -> uniqueid , audit_log -> sessionid , audit_log -> audit_file , audit_log -> extra , audit_log -> audit_size , audit_log -> md5 ) ; not_valid_audit_log : return res ; }
|
<S2SV_ModStart> , 20 , "%lu" <S2SV_ModEnd> , strlen (
|
6,845 |
CWE-000 static int ngx_http_lua_ngx_worker_id ( lua_State * L ) { <S2SV_StartBug> # if ( nginx_version >= 1009001 ) <S2SV_EndBug> lua_pushinteger ( L , ( lua_Integer ) ngx_worker ) ; # else lua_pushnil ( L ) ; # endif return 1 ; }
|
<S2SV_ModStart> >= 1009001 ) if ( ngx_process != NGX_PROCESS_WORKER ) { lua_pushnil ( L ) ; return 1 ; }
|
6,846 |
CWE-000 void nbd_r2h_request ( struct nbd_request_raw * from , struct nbd_request * to ) { <S2SV_StartBug> to -> magic = htobe32 ( from -> magic ) ; <S2SV_EndBug> <S2SV_StartBug> to -> flags = htobe16 ( from -> flags ) ; <S2SV_EndBug> <S2SV_StartBug> to -> type = htobe16 ( from -> type ) ; <S2SV_EndBug> to -> handle . w = from -> handle . w ; <S2SV_StartBug> to -> from = htobe64 ( from -> from ) ; <S2SV_EndBug> <S2SV_StartBug> to -> len = htobe32 ( from -> len ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> -> magic = be32toh <S2SV_ModEnd> ( from -> <S2SV_ModStart> -> flags = be16toh <S2SV_ModEnd> ( from -> <S2SV_ModStart> -> type = be16toh <S2SV_ModEnd> ( from -> <S2SV_ModStart> -> from = be64toh <S2SV_ModEnd> ( from -> <S2SV_ModStart> -> len = be32toh <S2SV_ModEnd> ( from ->
|
6,847 |
CWE-000 int rndis_qc_bind_config_vendor ( struct usb_configuration * c , u8 ethaddr [ ETH_ALEN ] , u32 vendorID , const char * manufacturer , u8 max_pkt_per_xfer , u8 pkt_alignment_factor , char * xport_name ) { struct f_rndis_qc * rndis ; int status ; if ( ! can_support_rndis_qc ( c ) || ! ethaddr ) { pr_debug ( "%s:<S2SV_blank>invalid<S2SV_blank>argument\\n" , __func__ ) ; return - EINVAL ; } status = rndis_init ( ) ; if ( status < 0 ) return status ; status = rndis_qc_bam_setup ( ) ; if ( status ) { pr_err ( "%s:<S2SV_blank>bam<S2SV_blank>setup<S2SV_blank>failed\\n" , __func__ ) ; return status ; } if ( rndis_qc_string_defs [ 0 ] . id == 0 ) { status = usb_string_id ( c -> cdev ) ; if ( status < 0 ) return status ; rndis_qc_string_defs [ 0 ] . id = status ; rndis_qc_control_intf . iInterface = status ; status = usb_string_id ( c -> cdev ) ; if ( status < 0 ) return status ; rndis_qc_string_defs [ 1 ] . id = status ; rndis_qc_data_intf . iInterface = status ; status = usb_string_id ( c -> cdev ) ; if ( status < 0 ) return status ; rndis_qc_string_defs [ 2 ] . id = status ; rndis_qc_iad_descriptor . iFunction = status ; } status = - ENOMEM ; rndis = kzalloc ( sizeof * rndis , GFP_KERNEL ) ; if ( ! rndis ) { pr_err ( "%s:<S2SV_blank>fail<S2SV_blank>allocate<S2SV_blank>and<S2SV_blank>initialize<S2SV_blank>new<S2SV_blank>instance\\n" , __func__ ) ; goto fail ; } rndis -> xport = str_to_xport ( xport_name ) ; if ( rndis -> xport == USB_GADGET_XPORT_BAM2BAM_IPA ) { gether_qc_get_macs ( rndis_ipa_params . device_ethaddr , rndis_ipa_params . host_ethaddr ) ; pr_debug ( "setting<S2SV_blank>host_ethaddr=%pM,<S2SV_blank>device_ethaddr=%pM" , rndis_ipa_params . host_ethaddr , rndis_ipa_params . device_ethaddr ) ; rndis_ipa_supported = true ; memcpy ( rndis -> ethaddr , & rndis_ipa_params . host_ethaddr , ETH_ALEN ) ; } else memcpy ( rndis -> ethaddr , ethaddr , ETH_ALEN ) ; rndis -> vendorID = vendorID ; rndis -> manufacturer = manufacturer ; rndis -> max_pkt_per_xfer = max_pkt_per_xfer ? max_pkt_per_xfer : DEFAULT_MAX_PKT_PER_XFER ; u_bam_data_set_max_pkt_num ( rndis -> max_pkt_per_xfer ) ; if ( ( rndis -> pkt_alignment_factor == 0 ) && ( rndis -> max_pkt_per_xfer == 1 ) ) rndis -> pkt_alignment_factor = 0 ; else rndis -> pkt_alignment_factor = pkt_alignment_factor ? pkt_alignment_factor : DEFAULT_PKT_ALIGNMENT_FACTOR ; rndis -> port . cdc_filter = 0 ; rndis -> port . header_len = sizeof ( struct rndis_packet_msg_type ) ; rndis -> port . wrap = rndis_qc_add_header ; rndis -> port . unwrap = rndis_qc_rm_hdr ; rndis -> port . func . name = "rndis" ; rndis -> port . func . strings = rndis_qc_strings ; rndis -> port . func . bind = rndis_qc_bind ; rndis -> port . func . unbind = rndis_qc_unbind ; rndis -> port . func . set_alt = rndis_qc_set_alt ; rndis -> port . func . setup = rndis_qc_setup ; rndis -> port . func . disable = rndis_qc_disable ; rndis -> port . func . suspend = rndis_qc_suspend ; rndis -> port . func . resume = rndis_qc_resume ; _rndis_qc = rndis ; <S2SV_StartBug> status = usb_add_function ( c , & rndis -> port . func ) ; <S2SV_EndBug> if ( status ) { <S2SV_StartBug> kfree ( rndis ) ; <S2SV_EndBug> goto fail ; } if ( rndis -> xport != USB_GADGET_XPORT_BAM2BAM_IPA ) return status ; <S2SV_StartBug> status = rndis_ipa_init ( & rndis_ipa_params ) ; <S2SV_EndBug> if ( status ) { pr_err ( "%s:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>rndis_ipa\\n" , __func__ ) ; kfree ( rndis ) ; goto fail ; } else { pr_debug ( "%s:<S2SV_blank>rndis_ipa<S2SV_blank>successful<S2SV_blank>created\\n" , __func__ ) ; return status ; } fail : rndis_exit ( ) ; return status ; }
|
<S2SV_ModStart> = rndis ; if ( rndis -> xport == USB_GADGET_XPORT_BAM2BAM_IPA ) { status = rndis_ipa_init ( & rndis_ipa_params ) ; if ( status ) { pr_err ( "%s:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>init<S2SV_blank>rndis_ipa\\n" , __func__ ) ; goto fail ; } } <S2SV_ModStart> status ) { if ( rndis -> xport == USB_GADGET_XPORT_BAM2BAM_IPA ) rndis_ipa_cleanup ( rndis_ipa_params . private <S2SV_ModEnd> ) ; goto <S2SV_ModStart> return status ; fail : kfree ( rndis ) ; _rndis_qc = NULL ; <S2SV_ModEnd> rndis_exit ( )
|
6,848 |
CWE-000 static bool opt_num ( char * * * arg , const char * pre , int * num ) { unsigned long val ; <S2SV_StartBug> char * param , * value , * endptr ; <S2SV_EndBug> if ( ! opt_long ( arg , pre , & param ) ) return false ; errno = 0 ; val = strtol ( param , & endptr , 0 ) ; if ( ( val == 0 ) && ( errno == 0 ) ) fprintf ( stderr , "Parameter<S2SV_blank>cannot<S2SV_blank>be<S2SV_blank>zero.\\n" ) , abort ( ) ; if ( ( * endptr == 'k' ) || ( * endptr == 'K' ) ) val *= 1000 , endptr ++ ; else if ( ( * endptr == 'm' ) || ( * endptr == 'M' ) ) val *= 1000000 , endptr ++ ; if ( ( ( val == 0 ) && ( errno != 0 ) ) || ( * endptr != '\\0' ) ) <S2SV_StartBug> fprintf ( stderr , "Invalid<S2SV_blank>%s<S2SV_blank>parameter<S2SV_blank>\'%s\'.\\n" , pre , value ) , abort ( ) ; <S2SV_EndBug> else if ( val > INT_MAX ) <S2SV_StartBug> fprintf ( stderr , "Number<S2SV_blank>too<S2SV_blank>large<S2SV_blank>\'%s\'.\\n" , value ) , abort ( ) ; <S2SV_EndBug> * num = val ; return true ; }
|
<S2SV_ModStart> param , * <S2SV_ModEnd> endptr ; if <S2SV_ModStart> , pre , param <S2SV_ModEnd> ) , abort <S2SV_ModStart> , "Number<S2SV_blank>too<S2SV_blank>large<S2SV_blank>\'%s\'.\\n" , param <S2SV_ModEnd> ) , abort
|
6,849 |
CWE-000 extern int gres_plugin_job_state_validate2 ( char * cpus_per_tres , char * tres_per_job , char * tres_per_node , char * tres_per_socket , char * tres_per_task , char * mem_per_tres , uint32_t num_tasks , uint32_t min_nodes , uint32_t max_nodes , List * gres_list ) { int rc = SLURM_SUCCESS ; gres_job_state_t * job_gres_data ; <S2SV_StartBug> uint64_t cnt = 0 ; <S2SV_EndBug> if ( ( rc = gres_plugin_init ( ) ) != SLURM_SUCCESS ) return rc ; if ( * gres_list && cpus_per_tres && ( cpus_per_tres [ 0 ] == '\\0' ) ) { ( void ) list_for_each ( * gres_list , _clear_cpus_per_gres , NULL ) ; cpus_per_tres = NULL ; } if ( * gres_list && tres_per_job && ( tres_per_job [ 0 ] == '\\0' ) ) { ( void ) list_for_each ( * gres_list , _clear_gres_per_job , NULL ) ; tres_per_job = NULL ; } if ( * gres_list && tres_per_node && ( tres_per_node [ 0 ] == '\\0' ) ) { ( void ) list_for_each ( * gres_list , _clear_gres_per_node , NULL ) ; tres_per_node = NULL ; } if ( * gres_list && tres_per_socket && ( tres_per_socket [ 0 ] == '\\0' ) ) { ( void ) list_for_each ( * gres_list , _clear_gres_per_socket , NULL ) ; tres_per_socket = NULL ; } if ( * gres_list && tres_per_task && ( tres_per_task [ 0 ] == '\\0' ) ) { ( void ) list_for_each ( * gres_list , _clear_gres_per_task , NULL ) ; tres_per_task = NULL ; } if ( * gres_list && mem_per_tres && ( mem_per_tres [ 0 ] == '\\0' ) ) { ( void ) list_for_each ( * gres_list , _clear_mem_per_gres , NULL ) ; mem_per_tres = NULL ; } if ( * gres_list == NULL ) * gres_list = list_create ( _gres_job_list_delete ) ; slurm_mutex_lock ( & gres_context_lock ) ; if ( cpus_per_tres ) { char * in_val = cpus_per_tres , * save_ptr = NULL ; while ( ( job_gres_data = _get_next_gres ( in_val , & cnt , * gres_list , & save_ptr , & rc ) ) ) { job_gres_data -> cpus_per_gres = cnt ; in_val = NULL ; } } if ( tres_per_job ) { char * in_val = tres_per_job , * save_ptr = NULL ; while ( ( job_gres_data = _get_next_gres ( in_val , & cnt , * gres_list , & save_ptr , & rc ) ) ) { job_gres_data -> gres_per_job = cnt ; in_val = NULL ; } } if ( tres_per_node ) { char * in_val = tres_per_node , * save_ptr = NULL ; while ( ( job_gres_data = _get_next_gres ( in_val , & cnt , * gres_list , & save_ptr , & rc ) ) ) { job_gres_data -> gres_per_node = cnt ; in_val = NULL ; } } if ( tres_per_socket ) { char * in_val = tres_per_socket , * save_ptr = NULL ; while ( ( job_gres_data = _get_next_gres ( in_val , & cnt , * gres_list , & save_ptr , & rc ) ) ) { job_gres_data -> gres_per_socket = cnt ; in_val = NULL ; } } if ( tres_per_task ) { char * in_val = tres_per_task , * save_ptr = NULL ; while ( ( job_gres_data = _get_next_gres ( in_val , & cnt , * gres_list , & save_ptr , & rc ) ) ) { job_gres_data -> gres_per_task = cnt ; in_val = NULL ; } } if ( mem_per_tres ) { char * in_val = mem_per_tres , * save_ptr = NULL ; while ( ( job_gres_data = _get_next_gres ( in_val , & cnt , * gres_list , & save_ptr , & rc ) ) ) { job_gres_data -> mem_per_gres = cnt ; in_val = NULL ; } } if ( tres_per_socket ) { char * in_val = tres_per_socket , * save_ptr = NULL ; while ( ( job_gres_data = _get_next_gres ( in_val , & cnt , * gres_list , & save_ptr , & rc ) ) ) { job_gres_data -> gres_per_socket = cnt ; in_val = NULL ; } } slurm_mutex_unlock ( & gres_context_lock ) ; if ( ( rc == SLURM_SUCCESS ) && ( list_for_each ( * gres_list , _test_gres_cnt , NULL ) < 0 ) ) { rc = ESLURM_INVALID_GRES ; } return rc ; }
|
<S2SV_ModStart> cnt = 0 ; if ( ! cpus_per_tres && ! tres_per_job && ! tres_per_node && ! tres_per_socket && ! tres_per_task && ! mem_per_tres ) return SLURM_SUCCESS
|
6,850 |
CWE-000 static inline void render_display_begin ( struct obs_display * display , uint32_t cx , uint32_t cy , bool size_changed ) { struct vec4 clear_color ; <S2SV_StartBug> gs_load_swapchain ( display ? display -> swap : NULL ) ; <S2SV_EndBug> if ( size_changed ) gs_resize ( cx , cy ) ; gs_begin_scene ( ) ; vec4_from_rgba ( & clear_color , display -> background_color ) ; clear_color . w = 1.0f ; gs_clear ( GS_CLEAR_COLOR | GS_CLEAR_DEPTH | GS_CLEAR_STENCIL , & clear_color , 1.0f , 0 ) ; gs_enable_depth_test ( false ) ; gs_set_cull_mode ( GS_NEITHER ) ; gs_ortho ( 0.0f , ( float ) cx , 0.0f , ( float ) cy , - 100.0f , 100.0f ) ; gs_set_viewport ( 0 , 0 , cx , cy ) ; }
|
<S2SV_ModStart> gs_load_swapchain ( display -> swap <S2SV_ModEnd> ) ; if
|
6,851 |
CWE-000 static int virResctrlGetMonitorInfo ( virResctrlInfoPtr resctrl ) { int ret = - 1 ; int rv = - 1 ; char * featurestr = NULL ; char * * features = NULL ; size_t nfeatures = 0 ; virResctrlInfoMongrpPtr info_monitor = NULL ; if ( VIR_ALLOC ( info_monitor ) < 0 ) return - 1 ; info_monitor -> cache_level = 3 ; rv = virFileReadValueUint ( & info_monitor -> max_monitor , SYSFS_RESCTRL_PATH "/info/L3_MON/num_rmids" ) ; if ( rv == - 2 ) { VIR_INFO ( "The<S2SV_blank>file<S2SV_blank>\'" SYSFS_RESCTRL_PATH "/info/L3_MON/num_rmids\'<S2SV_blank>" "does<S2SV_blank>not<S2SV_blank>exist" ) ; ret = 0 ; virResetLastError ( ) ; goto cleanup ; } else if ( rv < 0 ) { goto cleanup ; } rv = virFileReadValueUint ( & info_monitor -> cache_reuse_threshold , SYSFS_RESCTRL_PATH "/info/L3_MON/max_threshold_occupancy" ) ; if ( rv == - 2 ) { VIR_DEBUG ( "File<S2SV_blank>\'" SYSFS_RESCTRL_PATH "/info/L3_MON/max_threshold_occupancy\'<S2SV_blank>does<S2SV_blank>not<S2SV_blank>exist" ) ; virResetLastError ( ) ; } else if ( rv < 0 ) { goto cleanup ; } rv = virFileReadValueString ( & featurestr , SYSFS_RESCTRL_PATH "/info/L3_MON/mon_features" ) ; if ( rv == - 2 ) virReportError ( VIR_ERR_INTERNAL_ERROR , "%s" , _ ( "Cannot<S2SV_blank>get<S2SV_blank>mon_features<S2SV_blank>from<S2SV_blank>resctrl" ) ) ; if ( rv < 0 ) goto cleanup ; if ( ! * featurestr ) { virReportError ( VIR_ERR_INTERNAL_ERROR , "%s" , _ ( "Get<S2SV_blank>empty<S2SV_blank>feature<S2SV_blank>list<S2SV_blank>from<S2SV_blank>resctrl" ) ) ; goto cleanup ; } features = virStringSplitCount ( featurestr , "\\n" , 0 , & nfeatures ) ; <S2SV_StartBug> VIR_DEBUG ( "Resctrl<S2SV_blank>supported<S2SV_blank>%ld<S2SV_blank>monitoring<S2SV_blank>features" , nfeatures ) ; <S2SV_EndBug> info_monitor -> nfeatures = nfeatures ; VIR_STEAL_PTR ( info_monitor -> features , features ) ; VIR_STEAL_PTR ( resctrl -> monitor_info , info_monitor ) ; ret = 0 ; cleanup : VIR_FREE ( featurestr ) ; virStringListFree ( features ) ; VIR_FREE ( info_monitor ) ; return ret ; }
|
<S2SV_ModStart> ; VIR_DEBUG ( "Resctrl<S2SV_blank>supported<S2SV_blank>%zd<S2SV_blank>monitoring<S2SV_blank>features" <S2SV_ModEnd> , nfeatures )
|
6,852 |
CWE-000 static void internal_add_timer ( struct tvec_base * base , struct timer_list * timer ) { <S2SV_StartBug> unsigned long expires = timer -> expires ; <S2SV_EndBug> <S2SV_StartBug> unsigned long idx = expires - base -> timer_jiffies ; <S2SV_EndBug> struct list_head * vec ; if ( idx < TVR_SIZE ) { int i = expires & TVR_MASK ; vec = base -> tv1 . vec + i ; } else if ( idx < 1 << ( TVR_BITS + TVN_BITS ) ) { int i = ( expires >> TVR_BITS ) & TVN_MASK ; vec = base -> tv2 . vec + i ; } else if ( idx < 1 << ( TVR_BITS + 2 * TVN_BITS ) ) { int i = ( expires >> ( TVR_BITS + TVN_BITS ) ) & TVN_MASK ; vec = base -> tv3 . vec + i ; } else if ( idx < 1 << ( TVR_BITS + 3 * TVN_BITS ) ) { int i = ( expires >> ( TVR_BITS + 2 * TVN_BITS ) ) & TVN_MASK ; vec = base -> tv4 . vec + i ; } else if ( ( signed long ) idx < 0 ) { vec = base -> tv1 . vec + ( base -> timer_jiffies & TVR_MASK ) ; } else { int i ; if ( idx > 0xffffffffUL ) { idx = 0xffffffffUL ; expires = idx + base -> timer_jiffies ; } i = ( expires >> ( TVR_BITS + 3 * TVN_BITS ) ) & TVN_MASK ; vec = base -> tv5 . vec + i ; } list_add_tail ( & timer -> entry , vec ) ; }
|
<S2SV_ModStart> timer ) { __internal_add_timer ( base , timer ) ; if ( ! tbase_get_deferrable ( timer -> base ) ) { if ( time_before ( timer -> expires , base -> next_timer ) ) base -> next_timer <S2SV_ModEnd> = timer -> <S2SV_ModStart> -> expires ; base -> active_timers ++ ; } <S2SV_ModEnd> } <S2SV_null> <S2SV_null>
|
6,853 |
CWE-000 int main ( void ) { int i ; char counter = 0 ; for ( i = 0 ; i < BUF_SIZE ; i ++ ) { <S2SV_StartBug> packet_rx [ i ] = packet_tx [ i ] = i ; <S2SV_EndBug> } radio_set_addr ( 0x802 ) ; radio_set_pan ( 0xABCD ) ; <S2SV_StartBug> radio_commit ( ) ; <S2SV_EndBug> radio_receive_callback ( callback , packet_rx , BUF_SIZE ) ; while ( 1 ) { int err = radio_send ( 0x0802 , packet_tx , BUF_SIZE ) ; printf ( "Packet<S2SV_blank>sent,<S2SV_blank>return<S2SV_blank>code:<S2SV_blank>%i\\n" , err ) ; counter ++ ; packet_tx [ 0 ] = counter ; delay_ms ( 4000 ) ; } }
|
<S2SV_ModStart> ++ ) { <S2SV_ModEnd> packet_tx [ i <S2SV_ModStart> ] = i ; packet_rx [ i ] = 0 <S2SV_ModStart> ) ; radio_commit ( ) ; radio_init
|
6,854 |
CWE-000 int hioi_fs_query ( hio_context_t context , const char * path , hio_fs_attr_t * fs_attr ) { <S2SV_StartBug> struct statfs fsinfo ; <S2SV_EndBug> char tmp [ 4096 ] ; int rc ; if ( NULL == path ) { return HIO_ERR_BAD_PARAM ; } do { <S2SV_StartBug> if ( 0 != context -> c_rank ) { <S2SV_EndBug> <S2SV_StartBug> break ; <S2SV_EndBug> } if ( NULL == realpath ( path , tmp ) ) { fs_attr -> fs_type = hioi_err_errno ( errno ) ; break ; } rc = statfs ( tmp , & fsinfo ) ; if ( 0 > rc ) { <S2SV_StartBug> hioi_log ( context , HIO_VERBOSE_DEBUG_LOW , "statfs<S2SV_blank>path:%s<S2SV_blank>rc:%d<S2SV_blank>errno:%d(%s)" , tmp , rc , errno , strerror ( errno ) ) ; <S2SV_EndBug> fs_attr -> fs_type = hioi_err_errno ( errno ) ; break ; } memset ( fs_attr , 0 , sizeof ( * fs_attr ) ) ; fs_attr -> fs_bavail = fsinfo . f_bavail ; fs_attr -> fs_btotal = fsinfo . f_blocks ; fs_attr -> fs_bsize = fsinfo . f_bsize ; fs_attr -> fs_scount = 1 ; fs_attr -> fs_ssize = fs_attr -> fs_bsize ; switch ( fsinfo . f_type ) { # if defined ( LL_SUPER_MAGIC ) case LL_SUPER_MAGIC : hioi_fs_query_lustre ( tmp , fs_attr ) ; <S2SV_StartBug> break ; <S2SV_EndBug> # endif # if defined ( GPFS_SUPER_MAGIC ) case GPFS_SUPER_MAGIC : break ; # endif # if defined ( PAN_FS_CLIENT_MAGIC ) case PAN_FS_CLIENT_MAGIC : break ; # endif # if HIO_USE_DATAWARP case DW_SUPER_MAGIC : hioi_fs_query_datawarp ( tmp , fs_attr ) ; break ; # endif } hioi_log ( context , HIO_VERBOSE_DEBUG_LOW , "filesystem<S2SV_blank>query:<S2SV_blank>path:<S2SV_blank>%s,<S2SV_blank>type:<S2SV_blank>%d,<S2SV_blank>flags:<S2SV_blank>0x%x,<S2SV_blank>block<S2SV_blank>size:<S2SV_blank>%" PRIu64 "<S2SV_blank>block<S2SV_blank>count:<S2SV_blank>%" PRIu64 "<S2SV_blank>blocks<S2SV_blank>free:<S2SV_blank>%" PRIu64 "<S2SV_blank>stripe<S2SV_blank>count:<S2SV_blank>%" PRIu32 "<S2SV_blank>stripe<S2SV_blank>max<S2SV_blank>count:<S2SV_blank>%" PRIu32 "<S2SV_blank>stripe<S2SV_blank>unit:<S2SV_blank>%" PRIu64 "<S2SV_blank>stripe<S2SV_blank>size:<S2SV_blank>%" PRIu64 "<S2SV_blank>stripe<S2SV_blank>max<S2SV_blank>size:<S2SV_blank>%" PRIu64 , tmp , fs_attr -> fs_type , fs_attr -> fs_flags , fs_attr -> fs_bsize , fs_attr -> fs_btotal , fs_attr -> fs_bavail , fs_attr -> fs_scount , fs_attr -> fs_smax_count , fs_attr -> fs_sunit , fs_attr -> fs_ssize , fs_attr -> fs_smax_size ) ; } while ( 0 ) ; # if HIO_MPI_HAVE ( 1 ) if ( hioi_context_using_mpi ( context ) ) { MPI_Bcast ( fs_attr , sizeof ( * fs_attr ) , MPI_BYTE , 0 , context -> c_comm ) ; } # endif if ( 0 > fs_attr -> fs_type ) { return fs_attr -> fs_type ; } fs_attr -> fs_open = hio_fs_open_fns [ fs_attr -> fs_type ] ; assert ( NULL != fs_attr -> fs_open ) ; return HIO_SUCCESS ; }
|
<S2SV_ModStart> fs_attr ) { <S2SV_ModEnd> if ( 0 <S2SV_ModStart> if ( 0 == <S2SV_ModEnd> context -> c_rank <S2SV_ModStart> c_rank ) { hioi_fs_query_single <S2SV_ModEnd> ( context , <S2SV_ModStart> ( context , path <S2SV_ModEnd> , fs_attr ) <S2SV_ModStart> fs_attr ) ; } <S2SV_ModEnd> # if HIO_MPI_HAVE
|
6,855 |
CWE-000 struct song_node * add_song_sorted ( struct song_node * head , char * artist , char * name ) { if ( head == NULL ) { return add_song ( head , artist , name ) ; } struct song_node * cur = head ; struct song_node * prev = 0 ; struct song_node * new_node ; while ( cur != 0 && strcmp ( artist , cur -> artist ) > 0 ) { prev = cur ; cur = cur -> next ; } <S2SV_StartBug> while ( cur != 0 && strcmp ( name , cur -> name ) > 0 ) <S2SV_EndBug> { prev = cur ; cur = cur -> next ; } new_node = add_song ( cur , artist , name ) ; if ( prev == NULL ) { return new_node ; } prev -> next = new_node ; return head ; }
|
<S2SV_ModStart> && strcmp ( artist , cur -> artist ) == 0 && strcmp (
|
6,856 |
CWE-000 <S2SV_StartBug> event end ( t = 60 ) { <S2SV_EndBug> }
|
<S2SV_ModStart> ( t = 600 <S2SV_ModEnd> ) { }
|
6,857 |
CWE-000 static void vxp_dma_read ( struct vx_core * chip , struct snd_pcm_runtime * runtime , struct vx_pipe * pipe , int count ) { struct snd_vxpocket * pchip = ( struct snd_vxpocket * ) chip ; long port = vxp_reg_addr ( chip , VX_DMA ) ; int offset = pipe -> hw_ptr ; unsigned short * addr = ( unsigned short * ) ( runtime -> dma_area + offset ) ; if ( snd_BUG_ON ( count % 2 ) ) return ; vx_setup_pseudo_dma ( chip , 0 ) ; <S2SV_StartBug> if ( offset + count > pipe -> buffer_bytes ) { <S2SV_EndBug> int length = pipe -> buffer_bytes - offset ; count -= length ; length >>= 1 ; <S2SV_StartBug> while ( length -- > 0 ) <S2SV_EndBug> * addr ++ = le16_to_cpu ( inw ( port ) ) ; addr = ( unsigned short * ) runtime -> dma_area ; pipe -> hw_ptr = 0 ; } pipe -> hw_ptr += count ; count >>= 1 ; <S2SV_StartBug> while ( count -- > 1 ) <S2SV_EndBug> * addr ++ = le16_to_cpu ( inw ( port ) ) ; pchip -> regDIALOG &= ~ VXP_DLG_DMAREAD_SEL_MASK ; vx_outb ( chip , DIALOG , pchip -> regDIALOG ) ; * addr = le16_to_cpu ( inw ( port ) ) ; pchip -> regDIALOG &= ~ VXP_DLG_DMA16_SEL_MASK ; vx_outb ( chip , DIALOG , pchip -> regDIALOG ) ; vx_outb ( chip , ICR , 0 ) ; }
|
<S2SV_ModStart> offset + count >= <S2SV_ModEnd> pipe -> buffer_bytes <S2SV_ModStart> >>= 1 ; for ( ; length > 0 ; length -- <S2SV_ModEnd> ) * addr <S2SV_ModStart> >>= 1 ; for ( ; count > 1 ; count -- <S2SV_ModEnd> ) * addr
|
6,858 |
CWE-000 void main1 ( ) { Graph a = newGraph ( 4 ) ; printGraph ( stdout , a ) ; <S2SV_StartBug> addEdge ( a , 2 , 3 ) ; <S2SV_EndBug> printGraph ( stdout , a ) ; addEdge ( a , 2 , 3 ) ; printGraph ( stdout , a ) ; addArc ( a , 2 , 3 ) ; printGraph ( stdout , a ) ; addArc ( a , 2 , 4 ) ; printGraph ( stdout , a ) ; addEdge ( a , 2 , 4 ) ; printGraph ( stdout , a ) ; addEdge ( a , 2 , 1 ) ; printGraph ( stdout , a ) ; <S2SV_StartBug> addEdge ( a , 2 , 2 ) ; <S2SV_EndBug> printGraph ( stdout , a ) ; makeNull ( a ) ; printGraph ( stdout , a ) ; freeGraph ( & a ) ; }
|
<S2SV_ModStart> ) ; addEdge <S2SV_ModEnd> ( a , <S2SV_ModStart> a ) ; <S2SV_ModEnd> makeNull ( a
|
6,859 |
CWE-000 static void flush_old_commits ( struct work_struct * work ) { struct reiserfs_sb_info * sbi ; struct super_block * s ; sbi = container_of ( work , struct reiserfs_sb_info , old_work . work ) ; s = sbi -> s_journal -> j_work_sb ; spin_lock ( & sbi -> old_work_lock ) ; <S2SV_StartBug> sbi -> work_queued = 0 ; <S2SV_EndBug> spin_unlock ( & sbi -> old_work_lock ) ; reiserfs_sync_fs ( s , 1 ) ; }
|
<S2SV_ModStart> old_work_lock ) ; if ( sbi -> work_queued == 1 )
|
6,860 |
CWE-000 static int cmd_add_nio_ethernet ( hypervisor_conn_t * conn , int argc , char * argv [ ] ) { nio_t * nio ; <S2SV_StartBug> volatile bridge_t * bridge ; <S2SV_EndBug> bridge = find_bridge ( argv [ 0 ] ) ; if ( bridge == NULL ) { hypervisor_send_reply ( conn , HSC_ERR_NOT_FOUND , 1 , "bridge<S2SV_blank>\'%s\'<S2SV_blank>doesn\'t<S2SV_blank>exist" , argv [ 0 ] ) ; return ( - 1 ) ; } nio = create_nio_ethernet ( argv [ 1 ] ) ; if ( ! nio ) { hypervisor_send_reply ( conn , HSC_ERR_CREATE , 1 , "unable<S2SV_blank>to<S2SV_blank>create<S2SV_blank>NIO<S2SV_blank>Ethernet<S2SV_blank>for<S2SV_blank>bridge<S2SV_blank>\'%s\'" , argv [ 0 ] ) ; return ( - 1 ) ; } if ( add_nio_to_bridge ( conn , bridge , nio ) == - 1 ) { free_nio ( nio ) ; return ( - 1 ) ; } add_nio_desc ( nio , "%s" , argv [ 1 ] ) ; hypervisor_send_reply ( conn , HSC_INFO_OK , 1 , "NIO<S2SV_blank>Ethernet<S2SV_blank>added<S2SV_blank>to<S2SV_blank>bridge<S2SV_blank>\'%s\'" , argv [ 0 ] ) ; return ( 0 ) ; }
|
<S2SV_ModStart> * nio ; <S2SV_ModEnd> bridge_t * bridge
|
6,861 |
CWE-000 static int load_texture ( const char * f , struct shader_texture * tex ) { void * img = wx_image_load ( f ) ; if ( ! img ) return 0 ; int width , height ; wx_image_get_size ( img , & width , & height ) ; if ( width != next_pow2 ( width ) || height != next_pow2 ( height ) ) wx_image_rescale ( img , next_pow2 ( width ) , next_pow2 ( height ) ) ; wx_image_get_size ( img , & width , & height ) ; GLubyte * rgb = wx_image_get_data ( img ) ; GLubyte * alpha = wx_image_get_alpha ( img ) ; int bpp = alpha ? 4 : 3 ; GLubyte * data = malloc ( width * height * bpp ) ; <S2SV_StartBug> int Y ; <S2SV_EndBug> <S2SV_StartBug> for ( int y = 0 ; y < height ; ++ y ) <S2SV_EndBug> { Y = height - y - 1 ; <S2SV_StartBug> for ( int x = 0 ; x < width ; x ++ ) <S2SV_EndBug> { data [ ( y * width + x ) * bpp + 0 ] = rgb [ ( Y * width + x ) * 3 + 0 ] ; data [ ( y * width + x ) * bpp + 1 ] = rgb [ ( Y * width + x ) * 3 + 1 ] ; data [ ( y * width + x ) * bpp + 2 ] = rgb [ ( Y * width + x ) * 3 + 2 ] ; if ( alpha ) data [ ( y * width + x ) * bpp + 3 ] = alpha [ Y * width + x ] ; } } wx_image_free ( img ) ; tex -> width = width ; tex -> height = height ; tex -> internal_format = alpha ? GL_RGBA8 : GL_RGB8 ; tex -> format = alpha ? GL_RGBA : GL_RGB ; tex -> type = GL_UNSIGNED_BYTE ; tex -> data = data ; return 1 ; }
|
<S2SV_ModStart> ) ; int x , y , <S2SV_ModStart> ; for ( <S2SV_ModEnd> y = 0 <S2SV_ModStart> ; for ( <S2SV_ModEnd> x = 0
|
6,862 |
CWE-000 static int au1200fb_drv_probe ( struct platform_device * dev ) { struct au1200fb_device * fbdev ; struct au1200fb_platdata * pd ; struct fb_info * fbi = NULL ; unsigned long page ; int bpp , plane , ret , irq ; print_info ( "" DRIVER_DESC "" ) ; pd = dev -> dev . platform_data ; if ( ! pd ) return - ENODEV ; if ( au1200fb_setup ( pd ) ) return - ENODEV ; panel = & known_lcd_panels [ panel_index ] ; win = & windows [ window_index ] ; printk ( DRIVER_NAME ":<S2SV_blank>Panel<S2SV_blank>%d<S2SV_blank>%s\\n" , panel_index , panel -> name ) ; printk ( DRIVER_NAME ":<S2SV_blank>Win<S2SV_blank>%d<S2SV_blank>%s\\n" , window_index , win -> name ) ; ret = 0 ; fbdev = NULL ; for ( plane = 0 ; plane < device_count ; ++ plane ) { bpp = winbpp ( win -> w [ plane ] . mode_winctrl1 ) ; if ( win -> w [ plane ] . xres == 0 ) win -> w [ plane ] . xres = panel -> Xres ; if ( win -> w [ plane ] . yres == 0 ) win -> w [ plane ] . yres = panel -> Yres ; fbi = framebuffer_alloc ( sizeof ( struct au1200fb_device ) , & dev -> dev ) ; if ( ! fbi ) { ret = - ENOMEM ; goto failed ; } _au1200fb_infos [ plane ] = fbi ; fbdev = fbi -> par ; fbdev -> fb_info = fbi ; fbdev -> pd = pd ; fbdev -> plane = plane ; fbdev -> fb_len = ( win -> w [ plane ] . xres * win -> w [ plane ] . yres * bpp ) / 8 ; fbdev -> fb_mem = dmam_alloc_attrs ( & dev -> dev , PAGE_ALIGN ( fbdev -> fb_len ) , & fbdev -> fb_phys , GFP_KERNEL , DMA_ATTR_NON_CONSISTENT ) ; if ( ! fbdev -> fb_mem ) { print_err ( "fail<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>frambuffer<S2SV_blank>(size:<S2SV_blank>%dK))" , fbdev -> fb_len / 1024 ) ; ret = - ENOMEM ; goto failed ; } for ( page = ( unsigned long ) fbdev -> fb_phys ; page < PAGE_ALIGN ( ( unsigned long ) fbdev -> fb_phys + fbdev -> fb_len ) ; page += PAGE_SIZE ) { SetPageReserved ( pfn_to_page ( page >> PAGE_SHIFT ) ) ; } print_dbg ( "Framebuffer<S2SV_blank>memory<S2SV_blank>map<S2SV_blank>at<S2SV_blank>%p" , fbdev -> fb_mem ) ; print_dbg ( "phys=0x%08x,<S2SV_blank>size=%dK" , fbdev -> fb_phys , fbdev -> fb_len / 1024 ) ; if ( ( ret = au1200fb_init_fbinfo ( fbdev ) ) < 0 ) goto failed ; ret = register_framebuffer ( fbi ) ; if ( ret < 0 ) { print_err ( "cannot<S2SV_blank>register<S2SV_blank>new<S2SV_blank>framebuffer" ) ; goto failed ; } au1200fb_fb_set_par ( fbi ) ; # if ! defined ( CONFIG_FRAMEBUFFER_CONSOLE ) && defined ( CONFIG_LOGO ) if ( plane == 0 ) if ( fb_prepare_logo ( fbi , FB_ROTATE_UR ) ) { fb_set_cmap ( & fbi -> cmap , fbi ) ; fb_show_logo ( fbi , FB_ROTATE_UR ) ; } # endif } irq = platform_get_irq ( dev , 0 ) ; ret = request_irq ( irq , au1200fb_handle_irq , IRQF_SHARED , "lcd" , ( void * ) dev ) ; if ( ret ) { print_err ( "fail<S2SV_blank>to<S2SV_blank>request<S2SV_blank>interrupt<S2SV_blank>line<S2SV_blank>%d<S2SV_blank>(err:<S2SV_blank>%d)" , irq , ret ) ; goto failed ; } platform_set_drvdata ( dev , pd ) ; au1200_setpanel ( panel , pd ) ; return 0 ; failed : <S2SV_StartBug> if ( fbi ) { <S2SV_EndBug> if ( fbi -> cmap . len != 0 ) fb_dealloc_cmap ( & fbi -> cmap ) ; kfree ( fbi -> pseudo_palette ) ; <S2SV_StartBug> } <S2SV_EndBug> return ret ; }
|
<S2SV_ModStart> ; failed : for ( plane = 0 ; plane < device_count ; ++ plane ) { fbi = _au1200fb_infos [ plane ] ; if ( ! fbi ) break ; unregister_framebuffer ( fbi ) ; <S2SV_ModEnd> if ( fbi <S2SV_ModStart> pseudo_palette ) ; framebuffer_release ( fbi ) ; _au1200fb_infos [ plane ] = NULL ;
|
6,863 |
CWE-000 void fw_client_process_from_authserver_response ( t_authresponse * authresponse , t_client * p1 ) { int operation = 0 ; t_client * tmp_c ; s_config * config = config_get_config ( ) ; LOCK_CLIENT_LIST ( ) ; tmp_c = client_list_find_by_client ( p1 ) ; if ( NULL == tmp_c ) { UNLOCK_CLIENT_LIST ( ) ; debug ( LOG_NOTICE , "Client<S2SV_blank>was<S2SV_blank>already<S2SV_blank>removed.<S2SV_blank>Skipping<S2SV_blank>auth<S2SV_blank>processing" ) ; return ; } if ( config -> auth_servers != NULL && tmp_c -> is_online ) { switch ( authresponse -> authcode ) { case AUTH_DENIED : debug ( LOG_NOTICE , "%s<S2SV_blank>-<S2SV_blank>Denied.<S2SV_blank>Removing<S2SV_blank>client<S2SV_blank>and<S2SV_blank>firewall<S2SV_blank>rules" , tmp_c -> ip ) ; client_list_delete ( tmp_c ) ; operation = 1 ; break ; case AUTH_VALIDATION_FAILED : debug ( LOG_NOTICE , "%s<S2SV_blank>-<S2SV_blank>Validation<S2SV_blank>timeout,<S2SV_blank>now<S2SV_blank>denied.<S2SV_blank>Removing<S2SV_blank>client<S2SV_blank>and<S2SV_blank>firewall<S2SV_blank>rules" , tmp_c -> ip ) ; client_list_delete ( tmp_c ) ; operation = 1 ; break ; case AUTH_ALLOWED : if ( tmp_c -> fw_connection_state != FW_MARK_KNOWN ) { debug ( LOG_INFO , "%s<S2SV_blank>-<S2SV_blank>Access<S2SV_blank>has<S2SV_blank>changed<S2SV_blank>to<S2SV_blank>allowed,<S2SV_blank>refreshing<S2SV_blank>firewall<S2SV_blank>and<S2SV_blank>clearing<S2SV_blank>counters" , tmp_c -> ip ) ; if ( tmp_c -> fw_connection_state != FW_MARK_PROBATION ) { tmp_c -> counters . incoming_delta = tmp_c -> counters . outgoing_delta = tmp_c -> counters . incoming = tmp_c -> counters . outgoing = 0 ; } else { debug ( LOG_INFO , "%s<S2SV_blank>-<S2SV_blank>Skipped<S2SV_blank>clearing<S2SV_blank>counters<S2SV_blank>after<S2SV_blank>all,<S2SV_blank>the<S2SV_blank>user<S2SV_blank>was<S2SV_blank>previously<S2SV_blank>in<S2SV_blank>validation" , tmp_c -> ip ) ; } operation = 2 ; } break ; case AUTH_VALIDATION : debug ( LOG_INFO , "%s<S2SV_blank>-<S2SV_blank>User<S2SV_blank>in<S2SV_blank>validation<S2SV_blank>period" , tmp_c -> ip ) ; break ; case AUTH_ERROR : debug ( LOG_WARNING , "Error<S2SV_blank>communicating<S2SV_blank>with<S2SV_blank>auth<S2SV_blank>server<S2SV_blank>-<S2SV_blank>leaving<S2SV_blank>%s<S2SV_blank>as-is<S2SV_blank>for<S2SV_blank>now" , tmp_c -> ip ) ; break ; default : <S2SV_StartBug> debug ( LOG_ERR , "I<S2SV_blank>do<S2SV_blank>not<S2SV_blank>know<S2SV_blank>about<S2SV_blank>authentication<S2SV_blank>code<S2SV_blank>%d" , authresponse . authcode ) ; <S2SV_EndBug> break ; } } UNLOCK_CLIENT_LIST ( ) ; fw_client_operation ( operation , p1 ) ; }
|
<S2SV_ModStart> "I<S2SV_blank>do<S2SV_blank>not<S2SV_blank>know<S2SV_blank>about<S2SV_blank>authentication<S2SV_blank>code<S2SV_blank>%d" , authresponse -> <S2SV_ModEnd> authcode ) ;
|
6,864 |
CWE-000 static int connect_process ( TINO_SOCK sock , enum tino_sock_proctype type ) { struct ptybuffer_connect * c = tino_sock_userO ( sock ) ; char * pos ; int got , put ; xDP ( ( "(%p[%d],<S2SV_blank>%d)" , sock , tino_sock_fdO ( sock ) , type ) ) ; switch ( type ) { case TINO_SOCK_PROC_EOF : xDP ( ( "connect_process()<S2SV_blank>eof" ) ) ; return TINO_SOCK_FREE ; case TINO_SOCK_PROC_CLOSE : xDP ( ( "()<S2SV_blank>close" ) ) ; file_log ( "close<S2SV_blank>%d:<S2SV_blank>%d<S2SV_blank>sockets" , tino_sock_fdO ( sock ) , tino_sock_useO ( ) - 1 ) ; if ( c -> p -> sock == sock ) { c -> p -> sock = 0 ; c -> p -> forcepoll = 1 ; } if ( c -> infill && ! c -> p -> kill_incomplete ) send_to_pty ( c , c -> infill ) ; return TINO_SOCK_FREE ; case TINO_SOCK_PROC_POLL : xDP ( ( "()<S2SV_blank>poll" ) ) ; xDP ( ( "<S2SV_blank>%d,<S2SV_blank>%d,<S2SV_blank>%d,<S2SV_blank>%d<S2SV_blank>@<S2SV_blank>%p" , c -> outpos , c -> outfill , c -> screenpos , c -> p -> blockcount , c -> p -> pty ) ) ; if ( c -> p -> pty ) return c -> outpos < c -> outfill || c -> screenpos < c -> p -> blockcount ? TINO_SOCK_READWRITE : TINO_SOCK_READ ; if ( c -> outpos < c -> outfill || c -> screenpos < c -> p -> blockcount ) return TINO_SOCK_WRITE ; <S2SV_StartBug> file_log ( "closing<S2SV_blank>%d:<S2SV_blank>all<S2SV_blank>data<S2SV_blank>written" ) ; <S2SV_EndBug> return TINO_SOCK_EOF ; case TINO_SOCK_PROC_READ : xDP ( ( "()<S2SV_blank>read" ) ) ; if ( c -> infill >= sizeof c -> in ) { c -> discard = 1 ; c -> infill = 0 ; } got = read ( tino_sock_fdO ( sock ) , c -> in + c -> infill , sizeof c -> in - c -> infill ) ; xDP ( ( "()<S2SV_blank>read<S2SV_blank>%d" , got ) ) ; if ( got <= 0 ) return got ; c -> infill += got ; if ( c -> p -> immediate ) send_to_pty ( c , c -> infill ) ; else { while ( c -> infill && ( pos = memchr ( c -> in , '\\n' , ( size_t ) c -> infill ) ) != 0 ) { pos ++ ; send_to_pty ( c , pos - c -> in ) ; } } return got ; case TINO_SOCK_PROC_WRITE : xDP ( ( "()<S2SV_blank>write" ) ) ; if ( c -> outpos >= c -> outfill ) { TINO_GLIST_ENT list ; long long min ; c -> outpos = 0 ; c -> outfill = 0 ; min = c -> p -> blockcount - c -> p -> screen -> count ; if ( c -> minscreenpos && min < c -> minscreenpos ) { min = c -> minscreenpos ; c -> minscreenpos = 0 ; } if ( min > c -> screenpos ) { c -> outfill = snprintf ( c -> out , sizeof c -> out , "\\n[[%Ld<S2SV_blank>bytes<S2SV_blank>(%Ld<S2SV_blank>infoblocks)<S2SV_blank>skipped]]\\n" , c -> p -> skipbytes - c -> screenbytes , min - c -> screenpos ) ; c -> screenpos = min ; c -> screenbytes = c -> p -> skipbytes ; } list = c -> p -> screen -> list ; for ( ; min < c -> screenpos && list ; min ++ ) list = list -> next ; for ( ; list ; c -> screenpos ++ , list = list -> next ) { int max ; max = sizeof c -> out - c -> outfill ; if ( list -> len > max ) break ; memcpy ( c -> out + c -> outfill , list -> data , list -> len ) ; c -> outfill += list -> len ; } } if ( ! c -> outfill ) { xDP ( ( "()<S2SV_blank>write<S2SV_blank>cancel" ) ) ; return 1 ; } xDP ( ( "()<S2SV_blank>write(%d)" , ( int ) ( c -> outfill - c -> outpos ) ) ) ; put = write ( tino_sock_fdO ( sock ) , c -> out + c -> outpos , c -> outfill - c -> outpos ) ; xDP ( ( "()<S2SV_blank>write<S2SV_blank>%d" , put ) ) ; if ( put > 0 ) c -> outpos += put ; return put ; default : break ; } tino_fatal ( "connect_process" ) ; return 0 ; }
|
<S2SV_ModStart> file_log ( "closing<S2SV_blank>%d:<S2SV_blank>all<S2SV_blank>data<S2SV_blank>written" , tino_sock_fdO ( sock )
|
6,865 |
CWE-000 struct gbm_bo * swap_drm_surface_buffers ( struct wlr_drm_surface * surf , pixman_region32_t * damage ) { wlr_render_surface_swap_buffers ( surf -> render_surface , damage ) ; <S2SV_StartBug> return surf -> back ; <S2SV_EndBug> }
|
<S2SV_ModStart> return surf -> front <S2SV_ModEnd> ; } <S2SV_null>
|
6,866 |
CWE-000 void local_row_to_dimm_fw_image ( const PersistentStore * p_ps , sqlite3_stmt * p_stmt , struct db_dimm_fw_image * p_dimm_fw_image ) { INTEGER_COLUMN ( p_stmt , 0 , p_dimm_fw_image -> device_handle ) ; TEXT_COLUMN ( p_stmt , 1 , p_dimm_fw_image -> fw_rev , DIMM_FW_IMAGE_FW_REV_LEN ) ; INTEGER_COLUMN ( p_stmt , 2 , p_dimm_fw_image -> fw_type ) ; <S2SV_StartBug> INTEGER_COLUMN ( p_stmt , <S2SV_EndBug> <S2SV_StartBug> 3 , <S2SV_EndBug> p_dimm_fw_image -> staged_fw_status ) ; TEXT_COLUMN ( p_stmt , 4 , p_dimm_fw_image -> staged_fw_rev , DIMM_FW_IMAGE_STAGED_FW_REV_LEN ) ; INTEGER_COLUMN ( p_stmt , <S2SV_StartBug> 5 , <S2SV_EndBug> p_dimm_fw_image -> staged_fw_type ) ; TEXT_COLUMN ( p_stmt , <S2SV_StartBug> 6 , <S2SV_EndBug> p_dimm_fw_image -> commit_id , DIMM_FW_IMAGE_COMMIT_ID_LEN ) ; TEXT_COLUMN ( p_stmt , <S2SV_StartBug> 7 , <S2SV_EndBug> p_dimm_fw_image -> build_configuration , DIMM_FW_IMAGE_BUILD_CONFIGURATION_LEN ) ; }
|
<S2SV_ModStart> fw_type ) ; TEXT_COLUMN <S2SV_ModEnd> ( p_stmt , <S2SV_ModStart> p_stmt , 3 <S2SV_ModEnd> , p_dimm_fw_image -> <S2SV_ModStart> ( p_stmt , 4 <S2SV_ModEnd> , p_dimm_fw_image -> <S2SV_ModStart> ( p_stmt , 5 <S2SV_ModEnd> , p_dimm_fw_image -> <S2SV_ModStart> ( p_stmt , 6 <S2SV_ModEnd> , p_dimm_fw_image ->
|
6,867 |
CWE-000 void evgEllipse ( VGfloat x , VGfloat y , VGfloat w , VGfloat h ) { <S2SV_StartBug> VGPath path = evgMakeEllipse ( ) ; <S2SV_EndBug> evgDrawPath ( path , VG_FILL_PATH | VG_STROKE_PATH ) ; vgDestroyPath ( path ) ; }
|
<S2SV_ModStart> = evgMakeEllipse ( x , y , w , h
|
6,868 |
CWE-000 void execute_BRK ( void ) { PUSH ( ( uint8_t ) ( ( NES -> PC + 2 ) >> 8 ) ) ; PUSH ( ( uint8_t ) ( NES -> PC + 2 ) ) ; PUSH ( NES -> P | 0x30 ) ; NES -> P |= FLAG_I ; <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> |= FLAG_I ; NES -> PC = ( read_addr ( NES , 0xFFFF ) << 8 ) | read_addr ( NES , 0xFFFE ) ;
|
6,869 |
CWE-000 static void add_next_word ( uint32_t * buf , uint32_t len , uint32_t next_int ) { uint64_t product = 0 ; uint64_t carry = 0 ; uint32_t radix_val = 0x17179149 ; <S2SV_StartBug> uint32_t i ; <S2SV_EndBug> for ( i = len - 1 ; i >= 0 ; i -- ) { product = radix_val * buf [ i ] + carry ; buf [ i ] = ( uint32_t ) product ; carry = product >> 32 ; } uint64_t sum = buf [ len - 1 ] + next_int ; buf [ len - 1 ] = ( uint32_t ) sum ; carry = sum >> 32 ; for ( i = len - 2 ; i >= 0 ; i -- ) { sum = buf [ i ] + carry ; buf [ i ] = ( uint32_t ) sum ; carry = sum >> 32 ; } }
|
<S2SV_ModStart> = 0x17179149 ; int32_t <S2SV_ModEnd> i ; for
|
6,870 |
CWE-000 int vy_recovery_iterate ( struct vy_recovery * recovery , bool include_deleted , vy_recovery_cb cb , void * cb_arg ) { mh_int_t i ; mh_foreach ( recovery -> index_hash , i ) { struct vy_index_recovery_info * index ; index = mh_i64ptr_node ( recovery -> index_hash , i ) -> val ; if ( index -> is_dropped && rlist_empty ( & index -> runs ) ) continue ; <S2SV_StartBug> if ( vy_recovery_do_iterate_index ( index , include_deleted , <S2SV_EndBug> cb , cb_arg ) < 0 ) return - 1 ; } return 0 ; }
|
<S2SV_ModStart> ; if ( vy_recovery_iterate_index <S2SV_ModEnd> ( index ,
|
6,871 |
CWE-000 BOOL i_py2do_e ( void * env , PyObject * p , DATA_OBJECT * o ) { int type = 0 ; PyObject * value = NULL , * item = NULL ; void * do_value = NULL ; <S2SV_StartBug> long i = 0 , n = 0 ; <S2SV_EndBug> double d = 0 ; char * s = NULL ; if ( ! IS_PY_DATA_OBJECT ( p ) ) goto fail ; type = PY_DATA_OBJECT_TYPE ( p ) ; value = PY_DATA_OBJECT_VALUE ( p ) ; switch ( type ) { case INTEGER : <S2SV_StartBug> if ( ! PyInt_Check ( value ) ) <S2SV_EndBug> <S2SV_StartBug> goto fail ; <S2SV_EndBug> i = PyInt_AsLong ( value ) ; do_value = EnvAddLong ( env , i ) ; break ; case FLOAT : if ( ! PyFloat_Check ( value ) ) goto fail ; d = PyFloat_AsDouble ( value ) ; do_value = EnvAddDouble ( env , d ) ; break ; case STRING : case SYMBOL : case INSTANCE_NAME : if ( ! PyString_Check ( value ) ) goto fail ; s = PyString_AsString ( value ) ; do_value = EnvAddSymbol ( env , s ) ; break ; case MULTIFIELD : if ( ! PyList_Check ( value ) ) goto fail ; n = PyList_Size ( value ) ; if ( n == 0 ) goto fail ; if ( ! ( do_value = EnvCreateMultifield ( env , n ) ) ) goto fail ; for ( i = 0 ; i < n ; i ++ ) { item = PyList_GetItem ( value , i ) ; if ( ! item ) goto fail ; if ( ! i_py2do_mfhelp_e ( env , item , do_value , ( int ) ( i + 1 ) ) ) goto fail ; } break ; case INSTANCE_ADDRESS : if ( ! clips_instance_check ( value ) ) goto fail ; do_value = clips_instance_value ( value ) ; break ; case FACT_ADDRESS : if ( ! clips_fact_check ( value ) ) goto fail ; do_value = clips_fact_value ( value ) ; break ; case EXTERNAL_ADDRESS : if ( ! clips_address_check ( value ) ) goto fail ; do_value = clips_address_value ( value ) ; break ; default : goto fail ; } SetpType ( o , type ) ; SetpValue ( o , do_value ) ; if ( type == MULTIFIELD ) { SetpDOBegin ( o , 1 ) ; SetpDOEnd ( o , n ) ; } return TRUE ; fail : return FALSE ; }
|
<S2SV_ModStart> NULL ; long long <S2SV_ModStart> if ( ! ( <S2SV_ModStart> value ) ) || PyLong_Check ( value ) ) goto fail ; i = PyLong_AsLongLong <S2SV_ModEnd> ( value )
|
6,872 |
CWE-000 int deregister_entity ( struct http_request * req ) { const char * id ; const char * apikey ; const char * entity ; pthread_t thread ; bool thread_started = false ; req -> status = 403 ; BAD_REQUEST_if ( KORE_RESULT_OK != http_request_header ( req , "id" , & id ) || KORE_RESULT_OK != http_request_header ( req , "apikey" , & apikey ) || KORE_RESULT_OK != http_request_header ( req , "entity" , & entity ) , "inputs<S2SV_blank>missing<S2SV_blank>in<S2SV_blank>headers" ) ; if ( ! looks_like_a_valid_owner ( id ) ) FORBIDDEN ( "id<S2SV_blank>is<S2SV_blank>not<S2SV_blank>an<S2SV_blank>owner" ) ; if ( ! looks_like_a_valid_entity ( entity ) ) FORBIDDEN ( "entity<S2SV_blank>is<S2SV_blank>not<S2SV_blank>valid" ) ; if ( ! login_success ( id , apikey ) ) FORBIDDEN ( "invalid<S2SV_blank>id<S2SV_blank>or<S2SV_blank>apikey" ) ; sanitize ( id ) ; sanitize ( entity ) ; if ( ! is_owner ( id , entity ) ) FORBIDDEN ( "you<S2SV_blank>are<S2SV_blank>not<S2SV_blank>the<S2SV_blank>owner<S2SV_blank>of<S2SV_blank>the<S2SV_blank>entity" ) ; CREATE_STRING ( query , <S2SV_StartBug> "SELECT<S2SV_blank>1<S2SV_blank>FROM<S2SV_blank>users<S2SV_blank>WHERE<S2SV_blank>from_id<S2SV_blank>=<S2SV_blank>\'%s\'" , <S2SV_EndBug> entity ) ; RUN_QUERY ( query , "could<S2SV_blank>no<S2SV_blank>query<S2SV_blank>entity" ) ; if ( kore_pgsql_ntuples ( & sql ) != 1 ) BAD_REQUEST ( "invalid<S2SV_blank>entity" ) ; pthread_create ( & thread , NULL , delete_exchanges_and_queues , ( void * ) entity ) ; thread_started = true ; CREATE_STRING ( query , "DELETE<S2SV_blank>FROM<S2SV_blank>acl<S2SV_blank>WHERE<S2SV_blank>from_id<S2SV_blank>=<S2SV_blank>\'%s\'<S2SV_blank>or<S2SV_blank>exchange<S2SV_blank>LIKE<S2SV_blank>\'%s.%%\'" , entity , entity ) ; RUN_QUERY ( query , "could<S2SV_blank>not<S2SV_blank>delete<S2SV_blank>from<S2SV_blank>acl<S2SV_blank>table" ) ; CREATE_STRING ( query , "DELETE<S2SV_blank>FROM<S2SV_blank>follow<S2SV_blank>WHERE<S2SV_blank>requested_by<S2SV_blank>=<S2SV_blank>\'%s\'<S2SV_blank>or<S2SV_blank>exchange<S2SV_blank>LIKE<S2SV_blank>\'%s.%%\'" , entity , entity ) ; RUN_QUERY ( query , "could<S2SV_blank>not<S2SV_blank>delete<S2SV_blank>from<S2SV_blank>follow<S2SV_blank>table" ) ; CREATE_STRING ( query , "DELETE<S2SV_blank>FROM<S2SV_blank>users<S2SV_blank>WHERE<S2SV_blank>id<S2SV_blank>=<S2SV_blank>\'%s\'" , entity ) ; RUN_QUERY ( query , "could<S2SV_blank>not<S2SV_blank>delete<S2SV_blank>the<S2SV_blank>entity" ) ; OK ( ) ; done : if ( thread_started ) pthread_join ( thread , NULL ) ; END ( ) ; }
|
<S2SV_ModStart> ( query , "SELECT<S2SV_blank>1<S2SV_blank>FROM<S2SV_blank>users<S2SV_blank>WHERE<S2SV_blank>id<S2SV_blank>=<S2SV_blank>\'%s\'" <S2SV_ModEnd> , entity )
|
6,873 |
CWE-000 int main ( int argc , char * argv [ ] ) { char * port = "3000" ; if ( argc == 2 ) port = argv [ 1 ] ; struct addrinfo hint , * res ; int code ; memset ( & hint , 0 , sizeof ( struct addrinfo ) ) ; hint . ai_family = AF_UNSPEC ; hint . ai_socktype = SOCK_STREAM ; hint . ai_flags = AI_PASSIVE ; if ( ( code = getaddrinfo ( NULL , port , & hint , & res ) ) != 0 ) { printf ( "-<S2SV_blank>Error:<S2SV_blank>%s.\\n" , gai_strerror ( code ) ) ; return 1 ; } int sock_local ; if ( ( sock_local = socket ( res -> ai_family , res -> ai_socktype , res -> ai_protocol ) ) == - 1 ) { printf ( "-<S2SV_blank>Error:<S2SV_blank>socket<S2SV_blank>failed,<S2SV_blank>errno=%d\\n" , errno ) ; return 1 ; } if ( bind ( sock_local , res -> ai_addr , res -> ai_addrlen ) == - 1 ) { printf ( "-<S2SV_blank>Error:<S2SV_blank>bind<S2SV_blank>failed,<S2SV_blank>errno=%d\\n" , errno ) ; return 1 ; } printf ( "-<S2SV_blank>Info:<S2SV_blank>socket<S2SV_blank>bound<S2SV_blank>to<S2SV_blank>port:<S2SV_blank>%d\\n" , get_port ( res -> ai_addr ) ) ; if ( listen ( sock_local , 10 ) == - 1 ) { printf ( "-<S2SV_blank>Error:<S2SV_blank>listen<S2SV_blank>failed,<S2SV_blank>errno=%d\\n" , errno ) ; return 1 ; } int sock_new ; struct sockaddr_storage their_addr ; <S2SV_StartBug> while ( ( sock_new = accept ( sock_local , & their_addr , sizeof ( their_addr ) ) ) != - 1 ) <S2SV_EndBug> { printf ( "-<S2SV_blank>Info:<S2SV_blank>new<S2SV_blank>connection,<S2SV_blank>socket:<S2SV_blank>%d\\n" , sock_new ) ; int recvd = 0 ; int sent = 0 ; char buff [ 1024 ] ; int currec ; while ( ( currec = recv ( sock_new , buff , sizeof ( buff ) , 0 ) ) != 0 ) { recvd += currec ; int cursent ; <S2SV_StartBug> if ( ( cursent = send ( sock_new , buff , sizeof ( buff ) , 0 ) ) == - 1 ) <S2SV_EndBug> { printf ( "-<S2SV_blank>Error:<S2SV_blank>send<S2SV_blank>failed,<S2SV_blank>errno=%d\\n" , errno ) ; return 1 ; } sent += cursent ; } printf ( "-<S2SV_blank>Info:<S2SV_blank>connection<S2SV_blank>closed,<S2SV_blank>receved:<S2SV_blank>%d<S2SV_blank>bytes,<S2SV_blank>sent:<S2SV_blank>%d<S2SV_blank>bytes\\n" , recvd , sent ) ; } freeaddrinfo ( res ) ; return 0 ; }
|
<S2SV_ModStart> sockaddr_storage their_addr ; socklen_t addr_size = sizeof ( their_addr ) ; <S2SV_ModStart> ( sock_local , ( struct sockaddr * ) <S2SV_ModStart> & their_addr , & addr_size <S2SV_ModEnd> ) ) != <S2SV_ModStart> , buff , currec <S2SV_ModEnd> , 0 )
|
6,874 |
CWE-000 CODmarker_param_t get_CODmkrdata_from_j2kstream ( Byte_t * CODstream ) { CODmarker_param_t COD ; int i ; if ( * CODstream ++ != 0xff || * CODstream ++ != 0x52 ) { fprintf ( FCGI_stderr , "Error,<S2SV_blank>COD<S2SV_blank>marker<S2SV_blank>not<S2SV_blank>found<S2SV_blank>in<S2SV_blank>the<S2SV_blank>reconstructed<S2SV_blank>j2kstream\\n" ) ; <S2SV_StartBug> return COD ; <S2SV_EndBug> } COD . Lcod = big2 ( CODstream ) ; COD . Scod = * ( CODstream + 2 ) ; COD . prog_order = * ( CODstream + 3 ) ; COD . numOflayers = big2 ( CODstream + 4 ) ; COD . numOfdecomp = * ( CODstream + 7 ) ; if ( COD . Scod & 0x01 ) { COD . XPsiz = ( Byte4_t * ) opj_malloc ( ( OPJ_SIZE_T ) ( COD . numOfdecomp + 1 ) * sizeof ( Byte4_t ) ) ; COD . YPsiz = ( Byte4_t * ) opj_malloc ( ( OPJ_SIZE_T ) ( COD . numOfdecomp + 1 ) * sizeof ( Byte4_t ) ) ; for ( i = 0 ; i <= COD . numOfdecomp ; i ++ ) { COD . XPsiz [ i ] = ( Byte4_t ) pow ( 2 , * ( CODstream + 12 + i ) & 0x0F ) ; COD . YPsiz [ i ] = ( Byte4_t ) pow ( 2 , ( * ( CODstream + 12 + i ) & 0xF0 ) >> 4 ) ; } } else { COD . XPsiz = ( Byte4_t * ) opj_malloc ( sizeof ( Byte4_t ) ) ; COD . YPsiz = ( Byte4_t * ) opj_malloc ( sizeof ( Byte4_t ) ) ; COD . XPsiz [ 0 ] = COD . YPsiz [ 0 ] = 1 << 15 ; } return COD ; }
|
<S2SV_ModStart> "Error,<S2SV_blank>COD<S2SV_blank>marker<S2SV_blank>not<S2SV_blank>found<S2SV_blank>in<S2SV_blank>the<S2SV_blank>reconstructed<S2SV_blank>j2kstream\\n" ) ; memset ( & COD , 0 , sizeof ( COD ) ) ;
|
6,875 |
CWE-000 static int nft_dynset_init ( const struct nft_ctx * ctx , const struct nft_expr * expr , const struct nlattr * const tb [ ] ) { struct nft_dynset * priv = nft_expr_priv ( expr ) ; u8 genmask = nft_genmask_next ( ctx -> net ) ; struct nft_set * set ; u64 timeout ; int err ; if ( tb [ NFTA_DYNSET_SET_NAME ] == NULL || tb [ NFTA_DYNSET_OP ] == NULL || tb [ NFTA_DYNSET_SREG_KEY ] == NULL ) return - EINVAL ; if ( tb [ NFTA_DYNSET_FLAGS ] ) { u32 flags = ntohl ( nla_get_be32 ( tb [ NFTA_DYNSET_FLAGS ] ) ) ; if ( flags & ~ NFT_DYNSET_F_INV ) return - EINVAL ; if ( flags & NFT_DYNSET_F_INV ) priv -> invert = true ; } set = nft_set_lookup_global ( ctx -> net , ctx -> table , tb [ NFTA_DYNSET_SET_NAME ] , tb [ NFTA_DYNSET_SET_ID ] , genmask ) ; if ( IS_ERR ( set ) ) return PTR_ERR ( set ) ; if ( set -> ops -> update == NULL ) return - EOPNOTSUPP ; if ( set -> flags & NFT_SET_CONSTANT ) return - EBUSY ; priv -> op = ntohl ( nla_get_be32 ( tb [ NFTA_DYNSET_OP ] ) ) ; switch ( priv -> op ) { case NFT_DYNSET_OP_ADD : break ; case NFT_DYNSET_OP_UPDATE : if ( ! ( set -> flags & NFT_SET_TIMEOUT ) ) return - EOPNOTSUPP ; break ; default : return - EOPNOTSUPP ; } timeout = 0 ; if ( tb [ NFTA_DYNSET_TIMEOUT ] != NULL ) { if ( ! ( set -> flags & NFT_SET_TIMEOUT ) ) return - EINVAL ; timeout = msecs_to_jiffies ( be64_to_cpu ( nla_get_be64 ( tb [ NFTA_DYNSET_TIMEOUT ] ) ) ) ; } priv -> sreg_key = nft_parse_register ( tb [ NFTA_DYNSET_SREG_KEY ] ) ; err = nft_validate_register_load ( priv -> sreg_key , set -> klen ) ; if ( err < 0 ) return err ; if ( tb [ NFTA_DYNSET_SREG_DATA ] != NULL ) { if ( ! ( set -> flags & NFT_SET_MAP ) ) return - EINVAL ; if ( set -> dtype == NFT_DATA_VERDICT ) return - EOPNOTSUPP ; priv -> sreg_data = nft_parse_register ( tb [ NFTA_DYNSET_SREG_DATA ] ) ; err = nft_validate_register_load ( priv -> sreg_data , set -> dlen ) ; if ( err < 0 ) return err ; } else if ( set -> flags & NFT_SET_MAP ) return - EINVAL ; if ( tb [ NFTA_DYNSET_EXPR ] != NULL ) { if ( ! ( set -> flags & NFT_SET_EVAL ) ) return - EINVAL ; if ( ! nft_set_is_anonymous ( set ) ) return - EOPNOTSUPP ; priv -> expr = nft_expr_init ( ctx , tb [ NFTA_DYNSET_EXPR ] ) ; if ( IS_ERR ( priv -> expr ) ) return PTR_ERR ( priv -> expr ) ; err = - EOPNOTSUPP ; if ( ! ( priv -> expr -> ops -> type -> flags & NFT_EXPR_STATEFUL ) ) goto err1 ; if ( priv -> expr -> ops -> type -> flags & NFT_EXPR_GC ) { if ( set -> flags & NFT_SET_TIMEOUT ) goto err1 ; if ( ! set -> ops -> gc_init ) goto err1 ; set -> ops -> gc_init ( set ) ; } <S2SV_StartBug> } else if ( set -> flags & NFT_SET_EVAL ) <S2SV_EndBug> return - EINVAL ; nft_set_ext_prepare ( & priv -> tmpl ) ; nft_set_ext_add_length ( & priv -> tmpl , NFT_SET_EXT_KEY , set -> klen ) ; if ( set -> flags & NFT_SET_MAP ) nft_set_ext_add_length ( & priv -> tmpl , NFT_SET_EXT_DATA , set -> dlen ) ; if ( priv -> expr != NULL ) nft_set_ext_add_length ( & priv -> tmpl , NFT_SET_EXT_EXPR , priv -> expr -> ops -> size ) ; if ( set -> flags & NFT_SET_TIMEOUT ) { if ( timeout || set -> timeout ) nft_set_ext_add ( & priv -> tmpl , NFT_SET_EXT_EXPIRATION ) ; } priv -> timeout = timeout ; err = nf_tables_bind_set ( ctx , set , & priv -> binding ) ; if ( err < 0 ) goto err1 ; if ( set -> size == 0 ) set -> size = 0xffff ; priv -> set = set ; return 0 ; err1 : if ( priv -> expr != NULL ) nft_expr_destroy ( ctx , priv -> expr ) ; return err ; }
|
<S2SV_ModStart> ; } } <S2SV_ModEnd> nft_set_ext_prepare ( &
|
6,876 |
CWE-000 static int zipfileRegister ( sqlite3 * db ) { static sqlite3_module zipfileModule = { 1 , zipfileConnect , zipfileConnect , zipfileBestIndex , zipfileDisconnect , zipfileDisconnect , zipfileOpen , zipfileClose , zipfileFilter , zipfileNext , zipfileEof , zipfileColumn , zipfileRowid , zipfileUpdate , zipfileBegin , 0 , zipfileCommit , zipfileRollback , <S2SV_StartBug> 0 , <S2SV_EndBug> 0 , } ; int rc = sqlite3_create_module ( db , "zipfile" , & zipfileModule , 0 ) ; <S2SV_StartBug> return rc ; <S2SV_EndBug> }
|
<S2SV_ModStart> , zipfileRollback , zipfileFindFunction <S2SV_ModEnd> , 0 , <S2SV_ModStart> 0 ) ; if ( rc == SQLITE_OK ) { rc = sqlite3_overload_function ( db , "zipfile_cds" , - 1 ) ; }
|
6,877 |
CWE-000 int mount ( const char * device , const char * fsname , const char * _path , const char * fsoptions ) { struct fs_device_d * fsdev ; int ret ; char * path = normalise_path ( _path ) ; if ( ! fsoptions ) fsoptions = "" ; debug ( "mount:<S2SV_blank>%s<S2SV_blank>on<S2SV_blank>%s<S2SV_blank>type<S2SV_blank>%s,<S2SV_blank>options=%s\\n" , device , path , fsname , fsoptions ) ; if ( fs_dev_root ) { struct stat s ; fsdev = get_fsdevice_by_path ( path ) ; if ( fsdev != fs_dev_root ) { printf ( "sorry,<S2SV_blank>no<S2SV_blank>nested<S2SV_blank>mounts\\n" ) ; ret = - EBUSY ; goto err_free_path ; } ret = lstat ( path , & s ) ; if ( ret ) goto err_free_path ; if ( ! S_ISDIR ( s . st_mode ) ) { ret = - ENOTDIR ; goto err_free_path ; } } else { if ( * path != '/' || * ( path + 1 ) ) { ret = - ENOTDIR ; goto err_free_path ; } } if ( ! fsname ) fsname = detect_fs ( device , fsoptions ) ; if ( ! fsname ) return - ENOENT ; fsdev = xzalloc ( sizeof ( struct fs_device_d ) ) ; fsdev -> backingstore = xstrdup ( device ) ; safe_strncpy ( fsdev -> dev . name , fsname , MAX_DRIVER_NAME ) ; fsdev -> dev . id = get_free_deviceid ( fsdev -> dev . name ) ; fsdev -> path = xstrdup ( path ) ; fsdev -> dev . bus = & fs_bus ; fsdev -> options = xstrdup ( fsoptions ) ; ret = register_device ( & fsdev -> dev ) ; if ( ret ) goto err_register ; if ( ! fsdev -> dev . driver ) { ret = - EINVAL ; goto err_no_driver ; } if ( ! fsdev -> linux_rootarg && fsdev -> cdev && fsdev -> cdev -> partuuid [ 0 ] != 0 ) { char * str = basprintf ( "root=PARTUUID=%s" , fsdev -> cdev -> partuuid ) ; fsdev_set_linux_rootarg ( fsdev , str ) ; } <S2SV_StartBug> return 0 ; <S2SV_EndBug> err_no_driver : unregister_device ( & fsdev -> dev ) ; err_register : fs_remove ( & fsdev -> dev ) ; err_free_path : free ( path ) ; errno = - ret ; return ret ; }
|
<S2SV_ModStart> ) ; } free ( path ) ;
|
6,878 |
CWE-000 static int vce_v3_0_set_clockgating_state ( void * handle , enum amd_clockgating_state state ) { struct amdgpu_device * adev = ( struct amdgpu_device * ) handle ; bool enable = ( state == AMD_CG_STATE_GATE ) ? true : false ; int i ; if ( ! ( adev -> cg_flags & AMD_CG_SUPPORT_VCE_MGCG ) ) return 0 ; mutex_lock ( & adev -> grbm_idx_mutex ) ; for ( i = 0 ; i < 2 ; i ++ ) { if ( adev -> vce . harvest_config & ( 1 << i ) ) continue ; WREG32 ( mmGRBM_GFX_INDEX , GET_VCE_INSTANCE ( i ) ) ; <S2SV_StartBug> if ( enable ) { <S2SV_EndBug> uint32_t data = RREG32 ( mmVCE_CLOCK_GATING_A ) ; data &= ~ ( 0xf | 0xff0 ) ; data |= ( ( 0x0 << 0 ) | ( 0x04 << 4 ) ) ; WREG32 ( mmVCE_CLOCK_GATING_A , data ) ; data = RREG32 ( mmVCE_UENC_CLOCK_GATING ) ; data &= ~ ( 0xf | 0xff0 ) ; data |= ( ( 0x0 << 0 ) | ( 0x04 << 4 ) ) ; WREG32 ( mmVCE_UENC_CLOCK_GATING , data ) ; } vce_v3_0_set_vce_sw_clock_gating ( adev , enable ) ; } WREG32 ( mmGRBM_GFX_INDEX , mmGRBM_GFX_INDEX_DEFAULT ) ; mutex_unlock ( & adev -> grbm_idx_mutex ) ; return 0 ; }
|
<S2SV_ModStart> ; if ( !
|
6,879 |
CWE-000 void push_dup ( int io_number , int target_fd , int natural_fd , t_list * * redir_stack ) { int * save ; save = palloc ( sizeof ( * save ) * 4 ) ; save [ 0 ] = io_number ; save [ 1 ] = dup ( io_number ) ; save [ 2 ] = target_fd ; save [ 3 ] = natural_fd ; <S2SV_StartBug> ft_simple_lst_pushback ( redir_stack , ft_simple_lst_create ( save ) ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> = natural_fd ; if ( target_fd == - 2 ) close ( io_number ) ;
|
6,880 |
CWE-000 static __constructor ( 101 ) void inet6_ctor ( void ) { <S2SV_StartBug> int i ; <S2SV_EndBug> for ( i = 0 ; i < nitems ( inet6_cmds ) ; i ++ ) cmd_register ( & inet6_cmds [ i ] ) ; af_register ( & af_inet6 ) ; opt_register ( & in6_Lopt ) ; }
|
<S2SV_ModStart> void ) { size_t <S2SV_ModEnd> i ; for
|
6,881 |
CWE-000 int pg_firewall_reload ( struct pg_brick * brick , struct pg_error * * errp ) { <S2SV_StartBug> npf_error_t errinfo ; <S2SV_EndBug> <S2SV_StartBug> struct pg_firewall_state * state ; <S2SV_EndBug> struct nl_config * config ; void * config_build ; int npf_ret ; GList * it ; state = pg_brick_get_state ( brick , struct pg_firewall_state ) ; <S2SV_StartBug> config = npf_config_create ( ) ; <S2SV_EndBug> it = state -> rules ; while ( it != NULL ) { npf_rule_insert ( config , NULL , it -> data ) ; it = g_list_next ( it ) ; } <S2SV_StartBug> config_build = npf_config_build ( config ) ; <S2SV_EndBug> npf_ret = npf_load ( state -> npf , config_build , & errinfo ) ; npf_config_destroy ( config ) ; <S2SV_StartBug> if ( npf_ret != 0 ) { <S2SV_EndBug> * errp = pg_error_new_errno ( npf_ret , "NPF<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>load<S2SV_blank>configuration" ) ; return - 1 ; } return 0 ; }
|
<S2SV_ModStart> errp ) { <S2SV_ModEnd> struct pg_firewall_state * <S2SV_ModStart> pg_firewall_state * state = <S2SV_ModEnd> pg_brick_get_state ( brick <S2SV_ModStart> pg_firewall_state ) ; struct nl_config * <S2SV_ModStart> npf_config_create ( ) ; int ret ; GList * it <S2SV_ModStart> ) ; } ret = firewall_reload_internal ( state , config , errp <S2SV_ModEnd> ) ; npf_config_destroy <S2SV_ModStart> config ) ; return ret <S2SV_ModEnd> ; } <S2SV_null>
|
6,882 |
CWE-000 void rt_purge ( rt_t * self ) { assert ( self ) ; uint64_t timestamp_s = ( uint64_t ) zclock_time ( ) / 1000 ; zhashx_t * device = ( zhashx_t * ) zhashx_first ( self -> devices ) ; while ( device ) { fty_proto_t * metric = ( fty_proto_t * ) zhashx_first ( device ) ; zlistx_t * to_delete = zlistx_new ( ) ; zlistx_set_destructor ( to_delete , ( czmq_destructor * ) zstr_free ) ; zlistx_set_duplicator ( to_delete , ( czmq_duplicator * ) strdup ) ; while ( metric ) { <S2SV_StartBug> uint64_t time_s = fty_proto_aux_number ( metric , "time" , 0 ) ; <S2SV_EndBug> if ( timestamp_s - time_s > fty_proto_ttl ( metric ) ) { zlistx_add_end ( to_delete , ( void * ) zhashx_cursor ( device ) ) ; } metric = ( fty_proto_t * ) zhashx_next ( device ) ; } char * cursor = ( char * ) zlistx_first ( to_delete ) ; while ( cursor ) { zhashx_delete ( device , ( char * ) cursor ) ; cursor = ( char * ) zlistx_next ( to_delete ) ; } zlistx_destroy ( & to_delete ) ; device = ( zhashx_t * ) zhashx_next ( self -> devices ) ; } }
|
<S2SV_ModStart> uint64_t time_s = fty_proto_time ( metric <S2SV_ModEnd> ) ; if
|
6,883 |
CWE-000 int main ( int argc , char * argv [ ] ) { <S2SV_StartBug> fprintf ( stdout , "\\n" EC_COLOR_BOLD "%s<S2SV_blank>%s" EC_COLOR_END "<S2SV_blank>copyright<S2SV_blank>%s<S2SV_blank>%s\\n\\n" , <S2SV_EndBug> GBL_PROGRAM , EC_VERSION , EC_COPYRIGHT , EC_AUTHORS ) ; <S2SV_StartBug> GBL . lineno = 1 ; <S2SV_EndBug> parse_options ( argc , argv ) ; <S2SV_StartBug> if ( GBL_OPTIONS . source_file ) { <S2SV_EndBug> <S2SV_StartBug> yyin = fopen ( GBL_OPTIONS . source_file , "r" ) ; <S2SV_EndBug> if ( yyin == NULL ) FATAL_ERROR ( "Input<S2SV_blank>file<S2SV_blank>not<S2SV_blank>found<S2SV_blank>!" ) ; } else { FATAL_ERROR ( "No<S2SV_blank>source<S2SV_blank>file." ) ; } setbuf ( yyin , NULL ) ; setbuf ( stdout , NULL ) ; setbuf ( stderr , NULL ) ; load_tables ( ) ; load_constants ( ) ; <S2SV_StartBug> fprintf ( stdout , "\\n<S2SV_blank>Parsing<S2SV_blank>source<S2SV_blank>file<S2SV_blank>\\\'%s\\\'<S2SV_blank>" , GBL_OPTIONS . source_file ) ; <S2SV_EndBug> fflush ( stdout ) ; ef_debug ( 1 , "\\n" ) ; if ( yyparse ( ) == 0 ) fprintf ( stdout , "<S2SV_blank>done.\\n\\n" ) ; else fprintf ( stdout , "\\n\\nThe<S2SV_blank>script<S2SV_blank>contains<S2SV_blank>errors...\\n\\n" ) ; if ( write_output ( ) != ESUCCESS ) <S2SV_StartBug> FATAL_ERROR ( "Cannot<S2SV_blank>write<S2SV_blank>output<S2SV_blank>file<S2SV_blank>(%s)" , GBL_OPTIONS . output_file ) ; <S2SV_EndBug> return 0 ; }
|
<S2SV_ModStart> ] ) { globals_alloc ( ) ; <S2SV_ModStart> ) ; GBL -> <S2SV_ModEnd> lineno = 1 <S2SV_ModStart> if ( GBL_OPTIONS -> <S2SV_ModEnd> source_file ) { <S2SV_ModStart> fopen ( GBL_OPTIONS -> <S2SV_ModEnd> source_file , "r" <S2SV_ModStart> "\\n<S2SV_blank>Parsing<S2SV_blank>source<S2SV_blank>file<S2SV_blank>\\\'%s\\\'<S2SV_blank>" , GBL_OPTIONS -> <S2SV_ModEnd> source_file ) ; <S2SV_ModStart> "Cannot<S2SV_blank>write<S2SV_blank>output<S2SV_blank>file<S2SV_blank>(%s)" , GBL_OPTIONS -> output_file ) ; globals_free ( <S2SV_ModEnd> ) ; return
|
6,884 |
CWE-000 static void dbuf_prefetch_indirect_done ( zio_t * zio , arc_buf_t * abuf , void * private ) { dbuf_prefetch_arg_t * dpa = private ; ASSERT3S ( dpa -> dpa_zb . zb_level , < , dpa -> dpa_curlevel ) ; ASSERT3S ( dpa -> dpa_curlevel , > , 0 ) ; if ( zio != NULL ) { ASSERT3S ( BP_GET_LEVEL ( zio -> io_bp ) , == , dpa -> dpa_curlevel ) ; if ( zio -> io_flags & ZIO_FLAG_RAW ) { ASSERT3U ( BP_GET_PSIZE ( zio -> io_bp ) , == , zio -> io_size ) ; } else { ASSERT3U ( BP_GET_LSIZE ( zio -> io_bp ) , == , zio -> io_size ) ; } ASSERT3P ( zio -> io_spa , == , dpa -> dpa_spa ) ; dpa -> dpa_dnode = NULL ; } else if ( dpa -> dpa_dnode != NULL ) { uint64_t curblkid = dpa -> dpa_zb . zb_blkid >> ( dpa -> dpa_epbs * ( dpa -> dpa_curlevel - dpa -> dpa_zb . zb_level ) ) ; dmu_buf_impl_t * db = dbuf_hold_level ( dpa -> dpa_dnode , dpa -> dpa_curlevel , curblkid , FTAG ) ; ( void ) dbuf_read ( db , NULL , DB_RF_MUST_SUCCEED | DB_RF_NOPREFETCH | DB_RF_HAVESTRUCT ) ; dbuf_rele ( db , FTAG ) ; } dpa -> dpa_curlevel -- ; uint64_t nextblkid = dpa -> dpa_zb . zb_blkid >> ( dpa -> dpa_epbs * ( dpa -> dpa_curlevel - dpa -> dpa_zb . zb_level ) ) ; blkptr_t * bp = ( ( blkptr_t * ) abuf -> b_data ) + P2PHASE ( nextblkid , 1ULL << dpa -> dpa_epbs ) ; if ( BP_IS_HOLE ( bp ) || ( zio != NULL && zio -> io_error != 0 ) ) { kmem_free ( dpa , sizeof ( * dpa ) ) ; } else if ( dpa -> dpa_curlevel == dpa -> dpa_zb . zb_level ) { ASSERT3U ( nextblkid , == , dpa -> dpa_zb . zb_blkid ) ; dbuf_issue_final_prefetch ( dpa , bp ) ; kmem_free ( dpa , sizeof ( * dpa ) ) ; } else { arc_flags_t iter_aflags = ARC_FLAG_NOWAIT ; zbookmark_phys_t zb ; <S2SV_StartBug> ASSERT3U ( dpa -> dpa_curlevel , == , BP_GET_LEVEL ( bp ) ) ; <S2SV_EndBug> SET_BOOKMARK ( & zb , dpa -> dpa_zb . zb_objset , dpa -> dpa_zb . zb_object , dpa -> dpa_curlevel , nextblkid ) ; ( void ) arc_read ( dpa -> dpa_zio , dpa -> dpa_spa , bp , dbuf_prefetch_indirect_done , dpa , dpa -> dpa_prio , ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE , & iter_aflags , & zb ) ; } arc_buf_destroy ( abuf , private ) ; }
|
<S2SV_ModStart> zbookmark_phys_t zb ; if ( dpa -> dpa_aflags & ARC_FLAG_L2CACHE ) iter_aflags |= ARC_FLAG_L2CACHE ;
|
6,885 |
CWE-000 void plotrequest ( ) { int dummy_token = 0 ; AXIS_INDEX axis ; if ( ! term ) int_error ( c_token , "use<S2SV_blank>\'set<S2SV_blank>term\'<S2SV_blank>to<S2SV_blank>set<S2SV_blank>terminal<S2SV_blank>type<S2SV_blank>first" ) ; is_3d_plot = FALSE ; splot_map_deactivate ( ) ; if ( parametric && strcmp ( set_dummy_var [ 0 ] , "u" ) == 0 ) strcpy ( set_dummy_var [ 0 ] , "t" ) ; axis_init ( & axis_array [ FIRST_X_AXIS ] , FALSE ) ; axis_init ( & axis_array [ FIRST_Y_AXIS ] , TRUE ) ; axis_init ( & axis_array [ SECOND_X_AXIS ] , FALSE ) ; axis_init ( & axis_array [ SECOND_Y_AXIS ] , TRUE ) ; axis_init ( & axis_array [ T_AXIS ] , FALSE ) ; axis_init ( & axis_array [ U_AXIS ] , FALSE ) ; axis_init ( & axis_array [ V_AXIS ] , FALSE ) ; axis_init ( & axis_array [ POLAR_AXIS ] , TRUE ) ; <S2SV_StartBug> axis_init ( & axis_array [ COLOR_AXIS ] , TRUE ) ; <S2SV_EndBug> for ( axis = 0 ; axis < NUMBER_OF_MAIN_VISIBLE_AXES ; axis ++ ) { AXIS * secondary = & axis_array [ axis ] ; if ( axis == SAMPLE_AXIS ) continue ; if ( secondary -> linked_to_primary && secondary -> linked_to_primary -> index == - secondary -> index ) { AXIS * primary = secondary -> linked_to_primary ; primary -> set_autoscale = secondary -> set_autoscale ; axis_init ( primary , 1 ) ; } } if ( inside_zoom ) { while ( equals ( c_token , "[" ) ) parse_skip_range ( ) ; } if ( parametric || polar ) { dummy_token = parse_range ( T_AXIS ) ; parse_range ( FIRST_X_AXIS ) ; } else { dummy_token = parse_range ( FIRST_X_AXIS ) ; } parse_range ( FIRST_Y_AXIS ) ; parse_range ( SECOND_X_AXIS ) ; parse_range ( SECOND_Y_AXIS ) ; if ( equals ( c_token , "sample" ) && equals ( c_token + 1 , "[" ) ) c_token ++ ; for ( axis = 0 ; axis < AXIS_ARRAY_SIZE ; axis ++ ) { struct ticdef * ticdef = & axis_array [ axis ] . ticdef ; if ( ticdef -> def . user ) ticdef -> def . user = prune_dataticks ( ticdef -> def . user ) ; if ( ! ticdef -> def . user && ticdef -> type == TIC_USER ) ticdef -> type = TIC_COMPUTED ; } if ( dummy_token > 0 ) copy_str ( c_dummy_var [ 0 ] , dummy_token , MAX_ID_LEN ) ; else strcpy ( c_dummy_var [ 0 ] , set_dummy_var [ 0 ] ) ; eval_plots ( ) ; }
|
<S2SV_ModStart> TRUE ) ; for ( axis = 0 ; axis < NUMBER_OF_MAIN_VISIBLE_AXES ; axis ++ ) { AXIS * this_axis = & axis_array [ axis ] ; if ( this_axis -> set_autoscale != AUTOSCALE_NONE ) this_axis -> range_flags |= RANGE_WRITEBACK ; }
|
6,886 |
CWE-000 int main ( int argc , char * * argv ) { t_map * map ; void * mlx ; void * win ; if ( argc > 2 ) ft_putendl ( "Error:<S2SV_blank>Too<S2SV_blank>many<S2SV_blank>arguments" ) ; else { map = get_matrix ( argc , argv ) ; if ( map ) { mlx = mlx_init ( ) ; win = mlx_new_window ( mlx , 800 , 800 , "FdF" ) ; find_vertices ( mlx , win , map ) ; mlx_key_hook ( win , escape_key , map ) ; <S2SV_StartBug> mlx_key_hook ( win , move_key , map ) ; <S2SV_EndBug> mlx_key_hook ( win , color_key , map ) ; mlx_loop ( mlx ) ; } } return ( 0 ) ; }
|
<S2SV_ModStart> map ) ; <S2SV_ModEnd> mlx_loop ( mlx
|
6,887 |
CWE-000 as_status aerospike_batch_read_async ( aerospike * as , as_error * err , const as_policy_batch * policy , as_batch_read_records * records , as_async_batch_listener listener , void * udata , as_event_loop * event_loop ) { as_error_reset ( err ) ; if ( records -> list . size == 0 ) { listener ( 0 , records , udata , event_loop ) ; return AEROSPIKE_OK ; } as_async_batch_executor * executor = cf_malloc ( sizeof ( as_async_batch_executor ) ) ; as_event_executor * exec = & executor -> executor ; pthread_mutex_init ( & exec -> lock , NULL ) ; exec -> commands = 0 ; exec -> event_loop = as_event_assign ( event_loop ) ; exec -> complete_fn = as_batch_complete_async ; exec -> udata = udata ; <S2SV_StartBug> exec -> max_concurrent = 0 ; <S2SV_EndBug> exec -> max = 0 ; <S2SV_StartBug> exec -> count = 0 ; <S2SV_EndBug> exec -> valid = true ; executor -> records = records ; executor -> listener = listener ; return as_batch_read_execute ( as , err , policy , records , executor ) ; }
|
<S2SV_ModStart> ; exec -> err = NULL ; exec -> <S2SV_ModStart> count = 0 ; exec -> notify = true
|
6,888 |
CWE-000 DECLARE_EMULATION_FUNC ( emulate_float_store ) { uintptr_t val_lo , val_hi , error ; uint64_t val ; <S2SV_StartBug> uintptr_t addr = GET_RS1 ( insn , regs ) + IMM_I ( insn ) ; <S2SV_EndBug> switch ( insn & MASK_FUNCT3 ) { case MATCH_FSW & MASK_FUNCT3 : if ( addr % 4 != 0 ) return misaligned_store_trap ( mcause , regs ) ; val_lo = GET_F32_RS2 ( insn , regs ) ; error = unpriv_mem_access ( mstatus , mepc , "sw<S2SV_blank>%[val_lo],<S2SV_blank>(%[addr])" , unused1 , unused2 , val_lo , addr ) ; break ; case MATCH_FSD & MASK_FUNCT3 : if ( addr % sizeof ( uintptr_t ) != 0 ) return misaligned_store_trap ( mcause , regs ) ; val = GET_F64_RS2 ( insn , regs ) ; # ifdef __riscv64 error = unpriv_mem_access ( mstatus , mepc , "sd<S2SV_blank>%[val],<S2SV_blank>(%[addr])" , unused1 , unused2 , val , addr ) ; # else val_lo = val ; val_hi = val >> 32 ; error = unpriv_mem_access ( mstatus , mepc , "sw<S2SV_blank>%[val_lo],<S2SV_blank>(%[addr]);" "sw<S2SV_blank>%[val_hi],<S2SV_blank>4(%[addr])" , unused1 , unused2 , val_lo , val_hi , addr ) ; # endif break ; default : error = 1 ; } if ( error ) { restore_mstatus ( mstatus , mepc ) ; return - 1 ; } write_csr ( mepc , mepc + 4 ) ; return 0 ; }
|
<S2SV_ModStart> regs ) + IMM_S <S2SV_ModEnd> ( insn )
|
6,889 |
CWE-000 void addOBJ ( struct scene * sceneData , char * inputFileName ) { printf ( "Loading<S2SV_blank>OBJ<S2SV_blank>%s\\n" , inputFileName ) ; obj_scene_data data ; if ( parse_obj_scene ( & data , inputFileName ) == 0 ) { printf ( "OBJ<S2SV_blank>%s<S2SV_blank>file<S2SV_blank>not<S2SV_blank>found!\\n" , getFileName ( inputFileName ) ) ; return ; } printf ( "OBJ<S2SV_blank>loaded,<S2SV_blank>converting\\n" ) ; sceneData -> objs = ( struct crayOBJ * ) realloc ( sceneData -> objs , ( sceneData -> objCount + 1 ) * sizeof ( struct crayOBJ ) ) ; sceneData -> objs [ sceneData -> objCount ] . firstVectorIndex = vertexCount ; sceneData -> objs [ sceneData -> objCount ] . vertexCount = data . vertex_count ; sceneData -> objs [ sceneData -> objCount ] . firstNormalIndex = normalCount ; sceneData -> objs [ sceneData -> objCount ] . normalCount = data . vertex_normal_count ; sceneData -> objs [ sceneData -> objCount ] . firstTextureIndex = textureCount ; sceneData -> objs [ sceneData -> objCount ] . textureCount = data . vertex_texture_count ; sceneData -> objs [ sceneData -> objCount ] . firstPolyIndex = polyCount ; <S2SV_StartBug> sceneData -> objs [ sceneData -> objCount ] . polyCount = data . face_count ; <S2SV_EndBug> sceneData -> objs [ sceneData -> objCount ] . boundingVolume . pos = vectorWithPos ( 0 , 0 , 0 ) ; sceneData -> objs [ sceneData -> objCount ] . boundingVolume . radius = 0 ; sceneData -> objs [ sceneData -> objCount ] . transformCount = 0 ; sceneData -> objs [ sceneData -> objCount ] . transforms = ( struct matrixTransform * ) malloc ( sizeof ( struct matrixTransform ) ) ; sceneData -> objs [ sceneData -> objCount ] . materialCount = 0 ; sceneData -> objs [ sceneData -> objCount ] . objName = getFileName ( inputFileName ) ; vertexCount += data . vertex_count ; normalCount += data . vertex_normal_count ; textureCount += data . vertex_texture_count ; polyCount += data . face_count ; printf ( "Converting<S2SV_blank>vectors\\n" ) ; vertexArray = ( struct vector * ) realloc ( vertexArray , vertexCount * sizeof ( struct vector ) ) ; for ( int i = 0 ; i < data . vertex_count ; i ++ ) { vertexArray [ sceneData -> objs [ sceneData -> objCount ] . firstVectorIndex + i ] = vectorFromObj ( data . vertex_list [ i ] ) ; } printf ( "Converting<S2SV_blank>normals\\n" ) ; normalArray = ( struct vector * ) realloc ( normalArray , normalCount * sizeof ( struct vector ) ) ; for ( int i = 0 ; i < data . vertex_normal_count ; i ++ ) { normalArray [ sceneData -> objs [ sceneData -> objCount ] . firstNormalIndex + i ] = vectorFromObj ( data . vertex_normal_list [ i ] ) ; } printf ( "Converting<S2SV_blank>texture<S2SV_blank>coordinates\\n" ) ; textureArray = ( struct vector * ) realloc ( textureArray , textureCount * sizeof ( struct vector ) ) ; for ( int i = 0 ; i < data . vertex_texture_count ; i ++ ) { textureArray [ sceneData -> objs [ sceneData -> objCount ] . firstTextureIndex + i ] = vectorFromObj ( data . vertex_texture_list [ i ] ) ; } printf ( "Converting<S2SV_blank>polygons\\n" ) ; polygonArray = ( struct poly * ) realloc ( polygonArray , polyCount * sizeof ( struct poly ) ) ; for ( int i = 0 ; i < data . face_count ; i ++ ) { polygonArray [ sceneData -> objs [ sceneData -> objCount ] . firstPolyIndex + i ] = polyFromObj ( data . face_list [ i ] , sceneData -> objs [ sceneData -> objCount ] . firstVectorIndex , sceneData -> objs [ sceneData -> objCount ] . firstNormalIndex , sceneData -> objs [ sceneData -> objCount ] . firstTextureIndex , sceneData -> objs [ sceneData -> objCount ] . firstPolyIndex + i ) ; } sceneData -> objs [ sceneData -> objCount ] . materials = ( struct material * ) calloc ( 1 , sizeof ( struct material ) ) ; if ( data . material_count == 0 ) { sceneData -> objs [ sceneData -> objCount ] . materials = ( struct material * ) calloc ( 1 , sizeof ( struct material ) ) ; * sceneData -> objs [ sceneData -> objCount ] . materials = newMaterial ( colorWithValues ( 255.0 / 255.0 , 20.0 / 255.0 , 147.0 / 255.0 , 0 ) , 0 ) ; } else { for ( int i = 0 ; i < data . material_count ; i ++ ) { addMaterialOBJ ( & sceneData -> objs [ sceneData -> objCount ] , materialFromObj ( data . material_list [ i ] ) ) ; } } delete_obj_data ( & data ) ; printf ( "Loaded<S2SV_blank>OBJ!<S2SV_blank>Translated<S2SV_blank>%i<S2SV_blank>faces<S2SV_blank>and<S2SV_blank>%i<S2SV_blank>vectors\\n\\n" , data . face_count , data . vertex_count ) ; sceneData -> objCount ++ ; }
|
<S2SV_ModStart> data . face_count <S2SV_ModEnd> ; sceneData ->
|
6,890 |
CWE-000 FTVOID vc2012emu_save_cdata ( FTC8 * dataPath , FTU8 * p ) { FILE * pF ; pF = fopen ( dataPath , "wb" ) ; if ( NULL == pF ) { FTPRINT ( "\\nvc2012emu_save_cdata:<S2SV_blank>fail<S2SV_blank>to<S2SV_blank>open<S2SV_blank>file" ) ; return ; } <S2SV_StartBug> fwrite ( p , 4 , FT800_CAL_PARA_NUM , pF ) ; <S2SV_EndBug> fclose ( pF ) ; }
|
<S2SV_ModStart> , 4 , EVE_CAL_PARA_NUM <S2SV_ModEnd> , pF )
|
6,891 |
CWE-000 void drive_value ( char * Val , char * Code ) { <S2SV_StartBug> int P = intcode ( Code ) ; <S2SV_EndBug> char Bus [ 1000 ] ; int Width = sigs [ P ] . wide ; if ( Width <= 8 ) { strcpy ( sigs [ P ] . value , Val ) ; } else { strcpy ( sigs [ P ] . allocated , Val ) ; } for ( int ii = 0 ; ii < psensitive ; ii ++ ) { <S2SV_StartBug> if ( ( sensitives [ ii ] == P ) && ( sensitive_value [ ii ] == Val [ 0 ] ) ) { <S2SV_EndBug> PyRun_SimpleString ( qqia ( sensitive_command [ ii ] ) ) ; return ; } } <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> Code ) { char Bus [ 1000 ] ; <S2SV_ModStart> ( Code ) <S2SV_ModEnd> ; int Width <S2SV_ModStart> ++ ) { int AA = <S2SV_ModEnd> ( sensitives [ <S2SV_ModStart> == P ) ; int BB = <S2SV_ModEnd> ( sensitive_value [ <S2SV_ModStart> 0 ] ) ; int Cond = AA && BB ; if ( Cond <S2SV_ModStart> ; } } return ;
|
6,892 |
CWE-000 static struct nvmf_host * nvmf_host_default ( void ) { struct nvmf_host * host ; <S2SV_StartBug> host = kzalloc ( sizeof ( * host ) , GFP_KERNEL ) ; <S2SV_EndBug> if ( ! host ) return NULL ; kref_init ( & host -> ref ) ; uuid_gen ( & host -> id ) ; snprintf ( host -> nqn , NVMF_NQN_SIZE , "nqn.2014-08.org.nvmexpress:uuid:%pUb" , & host -> id ) ; mutex_lock ( & nvmf_hosts_mutex ) ; list_add_tail ( & host -> list , & nvmf_hosts ) ; mutex_unlock ( & nvmf_hosts_mutex ) ; return host ; }
|
<S2SV_ModStart> ; host = kmalloc <S2SV_ModEnd> ( sizeof (
|
6,893 |
CWE-000 static void test_dns_name_apply_idna ( void ) { # if defined HAVE_LIBIDN2 || defined HAVE_LIBIDN const int ret = 1 ; # else const int ret = 0 ; # endif # if defined HAVE_LIBIDN const int ret2 = 1 ; # else const int ret2 = 0 ; # endif test_dns_name_apply_idna_one ( "" , ret , "" ) ; test_dns_name_apply_idna_one ( "foo" , ret , "foo" ) ; test_dns_name_apply_idna_one ( "foo." , ret , "foo" ) ; test_dns_name_apply_idna_one ( "foo.bar" , ret , "foo.bar" ) ; test_dns_name_apply_idna_one ( "foo.bar." , ret , "foo.bar" ) ; test_dns_name_apply_idna_one ( "föö" , ret , "xn--f-1gaa" ) ; test_dns_name_apply_idna_one ( "föö." , ret , "xn--f-1gaa" ) ; test_dns_name_apply_idna_one ( "föö.bär" , ret , "xn--f-1gaa.xn--br-via" ) ; test_dns_name_apply_idna_one ( "föö.bär." , ret , "xn--f-1gaa.xn--br-via" ) ; test_dns_name_apply_idna_one ( "xn--f-1gaa.xn--br-via" , ret , "xn--f-1gaa.xn--br-via" ) ; <S2SV_StartBug> test_dns_name_apply_idna_one ( "r3---sn-ab5l6ne7.googlevideo.com" , ret2 , <S2SV_EndBug> ret2 ? "r3---sn-ab5l6ne7.googlevideo.com" : "" ) ; }
|
<S2SV_ModStart> ; test_dns_name_apply_idna_one ( "_443._tcp.fedoraproject.org" , ret2 , "_443._tcp.fedoraproject.org" ) ; test_dns_name_apply_idna_one ( "_443" , ret2 , "_443" ) ; test_dns_name_apply_idna_one ( "gateway" , ret , "gateway" ) ; test_dns_name_apply_idna_one ( "_gateway" , ret2 , "_gateway" ) ; test_dns_name_apply_idna_one (
|
6,894 |
CWE-000 static gboolean get_manufacturer_data ( const GDBusPropertyTable * property , DBusMessageIter * iter , void * user_data ) { DBusMessageIter dict ; struct ad_data * data = & ad . manufacturer . data ; <S2SV_StartBug> dbus_message_iter_open_container ( iter , DBUS_TYPE_ARRAY , "{qv}" , & dict ) ; <S2SV_EndBug> dict_append_basic_array ( & dict , DBUS_TYPE_UINT16 , & ad . manufacturer . id , <S2SV_StartBug> DBUS_TYPE_BYTE , & data -> data , data -> len ) ; <S2SV_EndBug> dbus_message_iter_close_container ( iter , & dict ) ; return TRUE ; }
|
<S2SV_ModStart> . data ; uint8_t * val = data -> data ; <S2SV_ModStart> DBUS_TYPE_BYTE , & val <S2SV_ModEnd> , data ->
|
6,895 |
CWE-000 void display_list_content ( t_arg * list ) { int i ; i = 1 ; while ( list ) { <S2SV_StartBug> if ( list -> content [ 0 ] != '\\0' ) <S2SV_EndBug> <S2SV_StartBug> printf ( "content<S2SV_blank>:<S2SV_blank>%s\\n" , list -> content ) ; <S2SV_EndBug> printf ( "flag<S2SV_blank>:<S2SV_blank>\'%s\'\\n" , list -> flag ) ; printf ( "field<S2SV_blank>:<S2SV_blank>\'%s\'\\n" , list -> field ) ; <S2SV_StartBug> printf ( "precision<S2SV_blank>:<S2SV_blank>%d\\n" , list -> precision ) ; <S2SV_EndBug> if ( list -> length_modifier != WOAW ) printf ( "length<S2SV_blank>modifier<S2SV_blank>:<S2SV_blank>%d\\n" , list -> length_modifier ) ; if ( list -> conversion_indicator != woaw ) printf ( "conversion<S2SV_blank>indicator<S2SV_blank>:<S2SV_blank>%d\\n" , list -> conversion_indicator ) ; list = list -> next ; printf ( "maillon<S2SV_blank>%d\\n\\n" , i ) ; i ++ ; } }
|
<S2SV_ModStart> list ) { printf ( "content<S2SV_blank>:<S2SV_blank>\'%s\'\\n" <S2SV_ModEnd> , list -> <S2SV_ModStart> content ) ; if ( list -> conversion_indicator != woaw ) { <S2SV_ModStart> precision ) ; }
|
6,896 |
CWE-000 void decode_cycle_with_sync ( int bus_data , int pin_rnw , int pin_sync , int pin_rst ) { static int cyclenum = 0 ; static int last_cyclenum = 0 ; static int opcode = - 1 ; static int opcount = 0 ; static int op1 = 0 ; static int op2 = 0 ; static int bus_cycle = 0 ; static int rst_state = 0 ; static int intr_state = 0 ; static uint64_t accumulator = 0 ; static int last_pin_rst = 1 ; if ( pin_rst == 1 ) { if ( arguments . idx_rst >= 0 ) { if ( last_pin_rst == 0 ) { rst_state = 3 ; } } else { if ( ( bus_cycle == 5 ) && ( bus_data == ( arguments . vec_rst & 0xff ) ) ) { rst_state ++ ; } if ( ( bus_cycle == 6 ) && ( bus_data == ( ( arguments . vec_rst >> 8 ) & 0xff ) ) ) { rst_state ++ ; } if ( ( bus_cycle == 7 ) && ( ( bus_data == ( ( arguments . vec_rst >> 16 ) & 0xff ) ) || ( ( ( arguments . vec_rst >> 16 ) & 0xff ) == 0 ) ) ) { rst_state ++ ; } } if ( arguments . idx_rnw >= 0 ) { if ( pin_rnw == 0 ) { if ( bus_cycle == 2 || bus_cycle == 3 || bus_cycle == 4 ) { intr_state ++ ; } } } else { if ( ( bus_cycle == 2 ) && ( bus_data == ( ( pc >> 8 ) & 0xff ) ) ) { intr_state ++ ; } if ( ( bus_cycle == 3 ) && ( bus_data == ( pc & 0xff ) ) ) { intr_state ++ ; } if ( ( bus_cycle == 4 ) && ( ( bus_data & 0x30 ) == 0x20 ) ) { if ( ! compare_NVDIZC ( bus_data ) ) { intr_state ++ ; } } } if ( pin_sync == 1 ) { if ( opcode >= 0 ) { analyze_instruction ( opcode , op1 , op2 , accumulator , intr_state == 3 , cyclenum - last_cyclenum , rst_state == 3 ) ; rst_state = 0 ; } last_cyclenum = cyclenum ; bus_cycle = 0 ; opcode = bus_data ; opcount = instr_table [ opcode ] . len - 1 ; intr_state = 0 ; accumulator = 0 ; } else { if ( bus_cycle == 1 && opcount >= 1 ) { op1 = bus_data ; } if ( bus_cycle == ( ( opcode == 0x20 ) ? 5 : ( ( opcode & 0x0f ) == 0x0f ) ? 4 : 2 ) && opcount >= 2 && intr_state < 3 ) { op2 = bus_data ; } accumulator = ( accumulator << 8 ) | bus_data ; } <S2SV_StartBug> if ( arguments . debug >= 1 ) { <S2SV_EndBug> printf ( "%d<S2SV_blank>%02x<S2SV_blank>%d" , bus_cycle , bus_data , pin_sync ) ; if ( arguments . idx_rnw >= 0 ) { printf ( "<S2SV_blank>%d" , pin_rnw ) ; } if ( arguments . idx_rst >= 0 ) { printf ( "<S2SV_blank>%d" , pin_rst ) ; } printf ( "\\n" ) ; } bus_cycle ++ ; <S2SV_StartBug> } <S2SV_EndBug> cyclenum ++ ; last_pin_rst = pin_rst ; }
|
<S2SV_ModStart> bus_data ; } } else { opcode = - 1 ; } <S2SV_ModStart> bus_cycle ++ ; <S2SV_ModEnd> cyclenum ++ ;
|
6,897 |
CWE-000 static void terminateChild ( wrkrInstanceData_t * pWrkrData ) { assert ( pWrkrData -> bIsRunning == 1 ) ; if ( pWrkrData -> pData -> bSignalOnClose ) { kill ( pWrkrData -> pid , SIGTERM ) ; } <S2SV_StartBug> cleanupChild ( pWrkrData , DEFAULT_FORCED_TERMINATION_TIMEOUT_MS ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> cleanupChild ( pWrkrData <S2SV_ModEnd> ) ; }
|
6,898 |
CWE-000 <S2SV_StartBug> static int <S2SV_EndBug> encode_fraction_longitude ( void ) { <S2SV_StartBug> return ugeo -> frac_lon * 1000000000 ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> <S2SV_null> <S2SV_null> static inline <S2SV_ModStart> void ) { if ( ugeo -> frac_lon != 0 ) <S2SV_ModStart> * 1000000000 ; else return 0 ;
|
6,899 |
CWE-000 static void print_plot_str ( int32_t value , int32_t baseline ) { char str [ 110 ] ; int32_t idx , i ; if ( value > 9995 ) { printf ( "%5d:<S2SV_blank>value<S2SV_blank>is<S2SV_blank>out<S2SV_blank>of<S2SV_blank>range\\n" , value ) ; return ; } if ( baseline < 0 || baseline > 9995 ) { printf ( "%5d:<S2SV_blank>baseline<S2SV_blank>is<S2SV_blank>out<S2SV_blank>of<S2SV_blank>range\\n" , baseline ) ; return ; } if ( value < 0 ) { value = 0 ; } bzero ( str , sizeof ( str ) ) ; idx = value / 100 ; for ( i = 0 ; i <= idx ; i ++ ) { str [ i ] = '*' ; } idx = baseline / 100 ; if ( str [ idx ] == '*' ) { str [ idx ] = '+' ; } else { str [ idx ] = '|' ; for ( i = 0 ; i < idx ; i ++ ) { if ( str [ i ] == '\\0' ) { str [ i ] = '<S2SV_blank>' ; } } } <S2SV_StartBug> printf ( "%5d:<S2SV_blank>%s\\n" , value - 2048 , str ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> "%5d:<S2SV_blank>%s\\n" , value <S2SV_ModEnd> , str )
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.