Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
6,300 | CWE-000 static inline void write_pixels ( unsigned int start , unsigned int end , FILE * file_attr , FILE * file_conv , char * * attr_colors , char * * conv_colors , int attr_pixel_size , int conv_pixel_size ) { for ( unsigned int i = start ; i < end ; i ++ ) { if ( i % LINE_COUNT == 0 ) { char nl = '\\n' ; fwrite ( & nl , sizeof ( char ) , 1 , file_attr ) ; fwrite ( & nl , sizeof ( char ) , 1 , file_conv ) ; } fwrite ( attr_colors [ RESULT_ATTR [ i ] + 1 ] , attr_pixel_size , 1 , file_attr ) ; unsigned int tmp = MIN ( MAX_CONV_NBR , RESULT_CONV [ i ] ) ; <S2SV_StartBug> fwrite ( conv_colors [ tmp ] , MAX_CONV_CHAR_SIZE + 1 , 1 , file_conv ) ; <S2SV_EndBug> } return ; } | <S2SV_ModStart> tmp ] , ( <S2SV_ModStart> MAX_CONV_CHAR_SIZE + 1 ) * 3 |
6,301 | CWE-000 RETRACE_REPLACE ( putenv ) char * RETRACE_IMPLEMENTATION ( getenv ) ( const char * envname ) { <S2SV_StartBug> char * env ; <S2SV_EndBug> rtr_getenv_t real_getenv ; real_getenv = RETRACE_GET_REAL ( getenv ) ; <S2SV_StartBug> env = real_getenv ( envname ) ; <S2SV_EndBug> <S2SV_StartBug> trace_printf ( 1 , "getenv(\\"%s\\");<S2SV_blank>[%s]\\n" , envname , env ) ; <S2SV_EndBug> <S2SV_StartBug> return real_getenv ( envname ) ; <S2SV_EndBug> } | <S2SV_ModStart> envname ) { rtr_getenv_t <S2SV_ModEnd> real_getenv = RETRACE_GET_REAL <S2SV_ModStart> getenv ) ; char * <S2SV_ModStart> envname ) ; if ( env != NULL ) <S2SV_ModStart> ( 1 , "getenv(\\"%s\\");<S2SV_blank>[\\"%s\\"]\\n" , envname , env ) ; else trace_printf ( 1 , "getenv(\\"%s\\");<S2SV_blank>[NULL]\\n" <S2SV_ModEnd> , envname , <S2SV_ModStart> ) ; return ( env <S2SV_ModEnd> ) ; } |
6,302 | CWE-000 void call_all_postdissectors ( tvbuff_t * tvb , packet_info * pinfo , proto_tree * tree ) { <S2SV_StartBug> guint i ; <S2SV_EndBug> for ( i = 0 ; i < postdissectors -> len ; i ++ ) { call_dissector_only ( POSTDISSECTORS ( i ) . handle , tvb , pinfo , tree , NULL ) ; } } | <S2SV_ModStart> { guint i ; if ( ! postdissectors ) return |
6,303 | CWE-000 int hyper_getgrouplist ( const char * user , gid_t group , gid_t * groups , int * ngroups ) { int nr = 0 , ret ; FILE * file = fopen ( "/etc/group" , "r" ) ; if ( ! file ) { perror ( "faile<S2SV_blank>to<S2SV_blank>open<S2SV_blank>/etc/group" ) ; return - 1 ; } for ( ; ; ) { struct group * gr = fgetgrent ( file ) ; if ( ! gr ) break ; int j ; for ( j = 0 ; gr -> gr_mem && gr -> gr_mem [ j ] ; j ++ ) { if ( ! strcmp ( gr -> gr_mem [ j ] , user ) ) { <S2SV_StartBug> if ( nr + 1 < * ngroups ) <S2SV_EndBug> groups [ nr ] = gr -> gr_gid ; nr ++ ; } } } fclose ( file ) ; if ( nr == 0 ) { <S2SV_StartBug> if ( nr + 1 < * ngroups ) <S2SV_EndBug> groups [ nr ] = group ; nr ++ ; } ret = nr <= * ngroups ? nr : - 1 ; * ngroups = nr ; return ret ; } | <S2SV_ModStart> ) ) { fprintf ( stdout , "hyper_getgrouplist()<S2SV_blank>found<S2SV_blank>matched<S2SV_blank>group<S2SV_blank>for<S2SV_blank>user<S2SV_blank>%s,<S2SV_blank>grname:<S2SV_blank>%s,<S2SV_blank>gid:<S2SV_blank>%d\\n" , user , gr -> gr_name , gr -> gr_gid ) ; if ( nr <S2SV_ModEnd> < * ngroups <S2SV_ModStart> 0 ) { fprintf ( stdout , "hyper_getgrouplist()<S2SV_blank>adds<S2SV_blank>the<S2SV_blank>default<S2SV_blank>group<S2SV_blank>to<S2SV_blank>list,<S2SV_blank>gid:%d\\n" , group ) ; if ( nr <S2SV_ModEnd> < * ngroups |
6,304 | CWE-000 static int create_fixed_stream_quirk ( struct snd_usb_audio * chip , struct usb_interface * iface , struct usb_driver * driver , const struct snd_usb_audio_quirk * quirk ) { struct audioformat * fp ; struct usb_host_interface * alts ; int stream , err ; unsigned * rate_table = NULL ; fp = kmemdup ( quirk -> data , sizeof ( * fp ) , GFP_KERNEL ) ; if ( ! fp ) { snd_printk ( KERN_ERR "cannot<S2SV_blank>memdup\\n" ) ; return - ENOMEM ; } INIT_LIST_HEAD ( & fp -> list ) ; if ( fp -> nr_rates > MAX_NR_RATES ) { kfree ( fp ) ; return - EINVAL ; } if ( fp -> nr_rates > 0 ) { rate_table = kmemdup ( fp -> rate_table , sizeof ( int ) * fp -> nr_rates , GFP_KERNEL ) ; if ( ! rate_table ) { kfree ( fp ) ; return - ENOMEM ; } fp -> rate_table = rate_table ; } stream = ( fp -> endpoint & USB_DIR_IN ) ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK ; err = snd_usb_add_audio_stream ( chip , stream , fp ) ; if ( err < 0 ) goto error ; if ( fp -> iface != get_iface_desc ( & iface -> altsetting [ 0 ] ) -> bInterfaceNumber || fp -> altset_idx >= iface -> num_altsetting ) { err = - EINVAL ; goto error ; } alts = & iface -> altsetting [ fp -> altset_idx ] ; fp -> datainterval = snd_usb_parse_datainterval ( chip , alts ) ; fp -> maxpacksize = le16_to_cpu ( get_endpoint ( alts , 0 ) -> wMaxPacketSize ) ; usb_set_interface ( chip -> dev , fp -> iface , 0 ) ; snd_usb_init_pitch ( chip , fp -> iface , alts , fp ) ; snd_usb_init_sample_rate ( chip , fp -> iface , alts , fp , fp -> rate_max ) ; return 0 ; error : <S2SV_StartBug> kfree ( fp ) ; <S2SV_EndBug> kfree ( rate_table ) ; return err ; } | <S2SV_ModStart> ; error : list_del ( & fp -> list ) ; |
6,305 | CWE-000 FLOAT CNAME ( BLASLONG n , FLOAT * x , BLASLONG inc_x ) { # if defined ( SMP ) int nthreads ; FLOAT dummy_alpha ; # endif FLOAT nrm2 = 0.0 ; double nrm2_double = 0.0 ; if ( n <= 0 || inc_x <= 0 ) return 0.0 ; if ( n == 1 ) return fabs ( x [ 0 ] ) ; # if defined ( SMP ) nthreads = num_cpu_avail ( 1 ) ; if ( n <= 10000 ) nthreads = 1 ; if ( nthreads == 1 ) { nrm2_double = nrm2_compute ( n , x , inc_x ) ; } else { int mode , i ; char result [ MAX_CPU_NUMBER * sizeof ( double ) * 2 ] ; double * ptr ; mode = BLAS_SINGLE | BLAS_REAL ; blas_level1_thread_with_return_value ( mode , n , 0 , 0 , & dummy_alpha , x , inc_x , NULL , 0 , result , 0 , ( void * ) nrm2_thread_function , nthreads ) ; ptr = ( double * ) result ; for ( i = 0 ; i < nthreads ; i ++ ) { <S2SV_StartBug> nrm2_double = nrm2_double + ( * ptr ) * ( * ptr ) ; <S2SV_EndBug> ptr = ( double * ) ( ( ( char * ) ptr ) + sizeof ( double ) * 2 ) ; } } # else nrm2_double = nrm2_compute ( n , x , inc_x ) ; # endif nrm2 = sqrt ( nrm2_double ) ; return nrm2 ; } | <S2SV_ModStart> * ptr ) <S2SV_ModEnd> ; ptr = |
6,306 | CWE-000 static void cdcreatecanvas ( cdCanvas * canvas , void * data ) { cdCtxCanvas * ctxcanvas ; HWND hWnd = NULL ; HDC hDC = NULL , ScreenDC ; int release_dc = 0 ; if ( ! data ) { hDC = GetDC ( NULL ) ; release_dc = 1 ; canvas -> w = GetDeviceCaps ( hDC , HORZRES ) ; canvas -> h = GetDeviceCaps ( hDC , VERTRES ) ; } else if ( IsWindow ( ( HWND ) data ) ) { RECT rect ; hWnd = ( HWND ) data ; GetClientRect ( hWnd , & rect ) ; canvas -> w = rect . right - rect . left ; canvas -> h = rect . bottom - rect . top ; } else { DWORD objtype = GetObjectType ( ( HGDIOBJ ) data ) ; if ( objtype == OBJ_DC || objtype == OBJ_MEMDC || objtype == OBJ_ENHMETADC || objtype == OBJ_METADC ) { hDC = ( HDC ) data ; canvas -> w = GetDeviceCaps ( hDC , HORZRES ) ; canvas -> h = GetDeviceCaps ( hDC , VERTRES ) ; } else return ; } ScreenDC = GetDC ( NULL ) ; canvas -> bpp = GetDeviceCaps ( ScreenDC , BITSPIXEL ) ; canvas -> xres = ( ( double ) GetDeviceCaps ( ScreenDC , LOGPIXELSX ) ) / 25.4 ; canvas -> yres = ( ( double ) GetDeviceCaps ( ScreenDC , LOGPIXELSY ) ) / 25.4 ; ReleaseDC ( NULL , ScreenDC ) ; canvas -> w_mm = ( ( double ) canvas -> w ) / canvas -> xres ; canvas -> h_mm = ( ( double ) canvas -> h ) / canvas -> yres ; ctxcanvas = cdwd2dCreateCanvas ( canvas , hWnd , hDC ) ; ctxcanvas -> release_dc = release_dc ; ctxcanvas -> canvas -> invert_yaxis = 1 ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> = 1 ; cdactivate ( ctxcanvas ) ; |
6,307 | CWE-000 static int parse_report ( transport_smart * transport , git_push * push ) { git_pkt * pkt = NULL ; const char * line_end = NULL ; gitno_buffer * buf = & transport -> buffer ; int error , recvd ; git_buf data_pkt_buf = GIT_BUF_INIT ; for ( ; ; ) { if ( buf -> offset > 0 ) error = git_pkt_parse_line ( & pkt , buf -> data , & line_end , buf -> offset ) ; else error = GIT_EBUFS ; if ( error < 0 && error != GIT_EBUFS ) { error = - 1 ; goto done ; } if ( error == GIT_EBUFS ) { if ( ( recvd = gitno_recv ( buf ) ) < 0 ) { error = recvd ; goto done ; } if ( recvd == 0 ) { giterr_set ( GITERR_NET , "early<S2SV_blank>EOF" ) ; error = GIT_EEOF ; goto done ; } continue ; } gitno_consume ( buf , line_end ) ; <S2SV_StartBug> error = 0 ; <S2SV_EndBug> switch ( pkt -> type ) { case GIT_PKT_DATA : error = add_push_report_sideband_pkt ( push , ( git_pkt_data * ) pkt , & data_pkt_buf ) ; break ; case GIT_PKT_ERR : giterr_set ( GITERR_NET , "report-status:<S2SV_blank>Error<S2SV_blank>reported:<S2SV_blank>%s" , ( ( git_pkt_err * ) pkt ) -> error ) ; error = - 1 ; break ; case GIT_PKT_PROGRESS : if ( transport -> progress_cb ) { git_pkt_progress * p = ( git_pkt_progress * ) pkt ; error = transport -> progress_cb ( p -> data , p -> len , transport -> message_cb_payload ) ; } break ; default : error = add_push_report_pkt ( push , pkt ) ; break ; } git_pkt_free ( pkt ) ; if ( error == GIT_ITEROVER ) { error = 0 ; if ( data_pkt_buf . size > 0 ) { giterr_set ( GITERR_NET , "Incomplete<S2SV_blank>pack<S2SV_blank>data<S2SV_blank>pkt-line" ) ; error = GIT_ERROR ; } goto done ; } if ( error < 0 ) { goto done ; } } done : git_buf_free ( & data_pkt_buf ) ; return error ; } | <S2SV_ModStart> error = 0 ; if ( pkt == NULL ) continue |
6,308 | CWE-000 static enum clnt_stat clnt_raw_call ( struct clnt_req * cc ) { CLIENT * clnt = cc -> cc_clnt ; struct cx_data * cx = CX_DATA ( clnt ) ; struct cm_data * cm = CM_DATA ( cx ) ; XDR * xdrs = & cm -> xdr_stream ; <S2SV_StartBug> struct rpc_msg msg ; <S2SV_EndBug> struct rpc_err error ; cc -> cc_error . re_status = RPC_SUCCESS ; mutex_lock ( & clnt -> cl_lock ) ; <S2SV_StartBug> cx -> cx_u . cx_mcalli = ntohl ( cc -> cc_xid ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ( ! XDR_PUTBYTES ( xdrs , cx -> cx_u . cx_mcallc , cx -> cx_mpos ) ) <S2SV_EndBug> || ( ! XDR_PUTUINT32 ( xdrs , cc -> cc_proc ) ) || ( ! AUTH_MARSHALL ( cc -> cc_auth , xdrs ) ) || ( ! ( * cc -> cc_call . proc ) ( xdrs , cc -> cc_call . where ) ) ) { mutex_unlock ( & clnt -> cl_lock ) ; __warnx ( TIRPC_DEBUG_FLAG_CLNT_RAW , "%s:<S2SV_blank>failed" , __func__ ) ; XDR_DESTROY ( xdrs ) ; return ( RPC_CANTENCODEARGS ) ; } ( void ) XDR_GETPOS ( xdrs ) ; mutex_unlock ( & clnt -> cl_lock ) ; # if 0 svc_getreq_common ( FD_SETSIZE ) ; xdrs -> x_op = XDR_DECODE ; XDR_SETPOS ( xdrs , 0 ) ; msg . RPCM_ack . ar_verf = _null_auth ; msg . RPCM_ack . ar_results . proc = cc -> cc_msg . rm_xdr . proc ; msg . RPCM_ack . ar_results . where = cc -> cc_msg . rm_xdr . where ; if ( ! xdr_replymsg ( xdrs , & msg ) ) { int op = xdrs -> x_op ; xdrs -> x_op = XDR_FREE ; ( void ) xdr_replymsg ( xdrs , & msg ) ; xdrs -> x_op = op ; return ( RPC_CANTDECODERES ) ; } # endif _seterr_reply ( & msg , & error ) ; return ( error . re_status ) ; } | <S2SV_ModStart> -> xdr_stream ; u_int32_t * uint32p ; <S2SV_ModStart> cl_lock ) ; uint32p = ( u_int32_t * ) & cx -> cx_mcallc [ 0 ] ; * uint32p = htonl <S2SV_ModEnd> ( cc -> <S2SV_ModStart> , cx -> <S2SV_ModEnd> cx_mcallc , cx |
6,309 | CWE-000 void ipfw_delete ( char * av [ ] ) { <S2SV_StartBug> int i , j ; <S2SV_EndBug> int exitval = EX_OK ; int do_set = 0 ; <S2SV_StartBug> char * sep ; <S2SV_EndBug> ipfw_range_tlv rt ; av ++ ; <S2SV_StartBug> NEED1 ( "missing<S2SV_blank>rule<S2SV_blank>specification" ) ; <S2SV_EndBug> memset ( & rt , 0 , sizeof ( rt ) ) ; if ( * av && _substrcmp ( * av , "set" ) == 0 ) { if ( co . use_set ) errx ( EX_DATAERR , "invalid<S2SV_blank>syntax" ) ; do_set = 1 ; av ++ ; } while ( * av && isdigit ( * * av ) ) { i = strtol ( * av , & sep , 10 ) ; j = i ; if ( * sep == '-' ) j = strtol ( sep + 1 , NULL , 10 ) ; av ++ ; if ( co . do_nat ) { exitval = do_cmd ( IP_FW_NAT_DEL , & i , sizeof i ) ; if ( exitval ) { exitval = EX_UNAVAILABLE ; warn ( "rule<S2SV_blank>%u<S2SV_blank>not<S2SV_blank>available" , i ) ; } } else if ( co . do_pipe ) { exitval = ipfw_delete_pipe ( co . do_pipe , i ) ; } else { <S2SV_StartBug> if ( do_set != 0 ) { <S2SV_EndBug> rt . set = i & 31 ; rt . flags = IPFW_RCFLAG_SET ; } else { rt . start_rule = i & 0xffff ; rt . end_rule = j & 0xffff ; if ( rt . start_rule == 0 && rt . end_rule == 0 ) rt . flags |= IPFW_RCFLAG_ALL ; else rt . flags |= IPFW_RCFLAG_RANGE ; if ( co . use_set != 0 ) { rt . set = co . use_set - 1 ; rt . flags |= IPFW_RCFLAG_SET ; } } i = do_range_cmd ( IP_FW_XDEL , & rt ) ; if ( i != 0 ) { exitval = EX_UNAVAILABLE ; warn ( "rule<S2SV_blank>%u:<S2SV_blank>setsockopt(IP_FW_XDEL)" , rt . start_rule ) ; } else if ( rt . new_set == 0 && do_set == 0 ) { exitval = EX_UNAVAILABLE ; if ( rt . start_rule != rt . end_rule ) warnx ( "no<S2SV_blank>rules<S2SV_blank>rules<S2SV_blank>in<S2SV_blank>%u-%u<S2SV_blank>range" , rt . start_rule , rt . end_rule ) ; else warnx ( "rule<S2SV_blank>%u<S2SV_blank>not<S2SV_blank>found" , rt . start_rule ) ; } } } if ( exitval != EX_OK ) exit ( exitval ) ; } | <S2SV_ModStart> ] ) { ipfw_range_tlv rt ; char * sep ; <S2SV_ModStart> = 0 ; <S2SV_ModEnd> av ++ ; <S2SV_ModStart> NEED1 ( "missing<S2SV_blank>rule<S2SV_blank>specification" <S2SV_ModEnd> ) ; if <S2SV_ModStart> } else { memset ( & rt , 0 , sizeof ( rt ) ) ; |
6,310 | CWE-000 static bcore_string_s * translate_selftest ( ) { bcore_life_s * l = bcore_life_s_create ( ) ; bcore_string_s * out = bcore_string_s_create ( ) ; <S2SV_StartBug> bcore_flect_parse_sc ( "specs<S2SV_blank>=<S2SV_blank>{<S2SV_blank>aware_t<S2SV_blank>_;<S2SV_blank>bcore_string_s*<S2SV_blank>name;<S2SV_blank>sz_t<S2SV_blank>size;<S2SV_blank>u2_t<S2SV_blank>param1;<S2SV_blank>s2_t<S2SV_blank>param2;<S2SV_blank>private<S2SV_blank>s3_t<S2SV_blank>param3;<S2SV_blank>sz_t<S2SV_blank>[]<S2SV_blank>numarr;<S2SV_blank><S2SV_blank>bcore_string_s<S2SV_blank>[]<S2SV_blank>strarr;<S2SV_blank>bool<S2SV_blank>flag;}" ) ; <S2SV_EndBug> bcore_flect_parse_sc ( "specs_arr<S2SV_blank>=<S2SV_blank>{<S2SV_blank>aware_t<S2SV_blank>_;<S2SV_blank>aware<S2SV_blank>*<S2SV_blank>[]<S2SV_blank>arr;<S2SV_blank>}" ) ; vd_t specs = bcore_life_s_push_aware ( l , bcore_instance_typed_create ( typeof ( "specs" ) ) ) ; { const bcore_via_s * specs_v = bcore_via_s_get_aware ( specs ) ; u2_t u2_v = 10 ; specs_v -> nset_c ( specs_v , specs , typeof ( "param1" ) , & u2_v ) ; s3_t s3_v = - 3240 ; specs_v -> nset_c ( specs_v , specs , typeof ( "param2" ) , & s3_v ) ; bcore_string_s * s = specs_v -> ncreate ( specs_v , specs , typeof ( "name" ) ) ; bcore_string_s_pushf ( s , "\\"my<S2SV_blank>string\\n\\"" ) ; { const bcore_array_s * numarr_p = bcore_array_s_get_typed ( specs_v -> nget_type ( specs_v , specs , typeof ( "numarr" ) ) ) ; vd_t numarr = specs_v -> nget_d ( specs_v , specs , typeof ( "numarr" ) ) ; for ( sz_t i = 0 ; i < 10 ; i ++ ) numarr_p -> push_c ( numarr_p , numarr , & i ) ; } { const bcore_array_s * strarr_p = bcore_array_s_get_typed ( specs_v -> nget_type ( specs_v , specs , typeof ( "strarr" ) ) ) ; vd_t strarr = specs_v -> nget_d ( specs_v , specs , typeof ( "strarr" ) ) ; for ( sz_t i = 0 ; i < 10 ; i ++ ) strarr_p -> push_d ( strarr_p , strarr , bcore_string_s_createf ( "<%zu>" , i ) ) ; } <S2SV_StartBug> } <S2SV_EndBug> vd_t specs_arr = bcore_life_s_push_aware ( l , bcore_instance_typed_create ( typeof ( "specs_arr" ) ) ) ; { const bcore_array_s * arr_p = bcore_array_s_get_aware ( specs_arr ) ; for ( sz_t i = 0 ; i < 2 ; i ++ ) { arr_p -> push_c ( arr_p , specs_arr , specs ) ; } } bcore_bml_translator_s * trans = bcore_life_s_push_aware ( l , bcore_bml_translator_s_create ( ) ) ; bcore_bml_translator_s_translate_body ( trans , typeof ( "specs_arr" ) , specs_arr , out ) ; bcore_bml_translator_s_translate_body ( trans , typeof ( "bcore_bml_translator_s" ) , trans , out ) ; { bcore_string_s * buf = bcore_life_s_push_aware ( l , bcore_string_s_create ( ) ) ; bcore_bml_translator_s_translate_object ( trans , typeof ( "specs_arr" ) , specs_arr , buf ) ; bcore_bml_interpreter_s * intrp = bcore_life_s_push_aware ( l , bcore_bml_interpreter_s_create ( ) ) ; bcore_string_source_s * str_src = bcore_life_s_push_aware ( l , bcore_string_source_s_create_string ( buf ) ) ; vd_t specs_arr_2 = bcore_life_s_push_aware ( l , bcore_bml_interpreter_s_interpret_object ( intrp , str_src ) . o ) ; bcore_string_s_pushf ( out , "\\n<S2SV_blank>=================specs_arr_2:<S2SV_blank>==================\\n" ) ; bcore_bml_translator_s_translate_body ( trans , typeof ( "specs_arr" ) , specs_arr_2 , out ) ; } bcore_life_s_discard ( l ) ; return out ; } | <S2SV_ModStart> ) ; bcore_flect_parse_sc ( "specs<S2SV_blank>=<S2SV_blank>" "{" "<S2SV_blank><S2SV_blank><S2SV_blank>aware_t<S2SV_blank>_;" "<S2SV_blank><S2SV_blank><S2SV_blank>bcore_string_s*<S2SV_blank>name;" "<S2SV_blank><S2SV_blank><S2SV_blank>sz_t<S2SV_blank>size;" "<S2SV_blank><S2SV_blank><S2SV_blank>u2_t<S2SV_blank>param1;" "<S2SV_blank><S2SV_blank><S2SV_blank>s2_t<S2SV_blank>param2;" "<S2SV_blank><S2SV_blank><S2SV_blank>specs<S2SV_blank>*<S2SV_blank>child;" "<S2SV_blank><S2SV_blank><S2SV_blank>sz_t<S2SV_blank>[]<S2SV_blank>numarr;" "<S2SV_blank><S2SV_blank><S2SV_blank>bcore_string_s<S2SV_blank>[]<S2SV_blank>strarr;<S2SV_blank>bool<S2SV_blank>flag;" "}" <S2SV_ModEnd> ) ; bcore_flect_parse_sc <S2SV_ModStart> ) ; } specs_v -> nset_d ( specs_v , specs , typeof ( "child" ) , bcore_instance_aware_clone ( specs ) ) ; |
6,311 | CWE-000 int aws_iot_mqtt_tests_multi_threading_validation ( ) { pthread_t publish_thread [ MAX_PUB_THREAD_COUNT ] , yield_thread , sub_unsub_thread ; char certDirectory [ 15 ] = "../../certs" ; char clientCRT [ PATH_MAX + 1 ] ; char clientKey [ PATH_MAX + 1 ] ; char CurrentWD [ PATH_MAX + 1 ] ; char root_CA [ PATH_MAX + 1 ] ; char clientId [ 50 ] ; <S2SV_StartBug> IoT_Client_Init_Params initParams ; <S2SV_EndBug> IoT_Client_Connect_Params connectParams ; int threadId [ MAX_PUB_THREAD_COUNT ] ; int pubThreadReturn [ MAX_PUB_THREAD_COUNT ] ; int yieldThreadReturn = 0 , subUnsubThreadReturn = 0 ; float percentOfRxMsg = 0.0 ; int finishedThreadCount = 0 ; IoT_Error_t rc = SUCCESS ; int i , rxMsgCount = 0 , j = 0 ; <S2SV_StartBug> struct timeval connectTime , subscribeTopic ; <S2SV_EndBug> unsigned int connectCounter = 0 ; int test_result = 0 ; ThreadData threadData [ MAX_PUB_THREAD_COUNT ] ; AWS_IoT_Client client ; terminate_yield_thread = false ; rxMsgBufferTooBigCounter = 0 ; rxUnexpectedNumberCounter = 0 ; rePublishCount = 0 ; wrongYieldCount = 0 ; for ( j = 0 ; j < MAX_PUB_THREAD_COUNT ; j ++ ) { threadId [ j ] = j + 1 ; threadStatus [ j ] = 0 ; for ( i = 0 ; i < PUBLISH_COUNT ; i ++ ) { countArray [ j ] [ i ] = 0 ; } } printf ( "\\nConnecting<S2SV_blank>Client<S2SV_blank>" ) ; do { getcwd ( CurrentWD , sizeof ( CurrentWD ) ) ; snprintf ( root_CA , PATH_MAX + 1 , "%s/%s/%s" , CurrentWD , certDirectory , AWS_IOT_ROOT_CA_FILENAME ) ; snprintf ( clientCRT , PATH_MAX + 1 , "%s/%s/%s" , CurrentWD , certDirectory , AWS_IOT_CERTIFICATE_FILENAME ) ; snprintf ( clientKey , PATH_MAX + 1 , "%s/%s/%s" , CurrentWD , certDirectory , AWS_IOT_PRIVATE_KEY_FILENAME ) ; srand ( ( unsigned int ) time ( NULL ) ) ; snprintf ( clientId , 50 , "%s_%d" , INTEGRATION_TEST_CLIENT_ID , rand ( ) % 10000 ) ; IOT_DEBUG ( "<S2SV_blank>Root<S2SV_blank>CA<S2SV_blank>Path<S2SV_blank>:<S2SV_blank>%s\\n<S2SV_blank>clientCRT<S2SV_blank>:<S2SV_blank>%s\\n<S2SV_blank>clientKey<S2SV_blank>:<S2SV_blank>%s\\n" , root_CA , clientCRT , clientKey ) ; initParams . pHostURL = AWS_IOT_MQTT_HOST ; initParams . port = AWS_IOT_MQTT_PORT ; initParams . pRootCALocation = root_CA ; initParams . pDeviceCertLocation = clientCRT ; initParams . pDevicePrivateKeyLocation = clientKey ; initParams . mqttCommandTimeout_ms = 10000 ; initParams . tlsHandshakeTimeout_ms = 10000 ; initParams . disconnectHandler = aws_iot_mqtt_tests_disconnect_callback_handler ; initParams . enableAutoReconnect = false ; initParams . isBlockOnThreadLockEnabled = true ; aws_iot_mqtt_init ( & client , & initParams ) ; connectParams . keepAliveIntervalInSec = 10 ; connectParams . isCleanSession = true ; connectParams . MQTTVersion = MQTT_3_1_1 ; connectParams . pClientID = ( char * ) & clientId ; connectParams . clientIDLen = strlen ( clientId ) ; connectParams . isWillMsgPresent = false ; connectParams . pUsername = NULL ; connectParams . usernameLen = 0 ; connectParams . pPassword = NULL ; connectParams . passwordLen = 0 ; rc = aws_iot_mqtt_connect ( & client , & connectParams ) ; if ( SUCCESS != rc ) { IOT_ERROR ( "ERROR<S2SV_blank>Connecting<S2SV_blank>%d\\n" , rc ) ; return - 1 ; } connectCounter ++ ; } while ( SUCCESS != rc && connectCounter < CONNECT_MAX_ATTEMPT_COUNT ) ; if ( SUCCESS == rc ) { <S2SV_StartBug> printf ( "\\n##<S2SV_blank>Connect<S2SV_blank>Success.<S2SV_blank>Time<S2SV_blank>sec:<S2SV_blank>%d,<S2SV_blank>usec:<S2SV_blank>%d\\n" , connectTime . tv_sec , connectTime . tv_usec ) ; <S2SV_EndBug> } else { IOT_ERROR ( "##<S2SV_blank>Connect<S2SV_blank>Failed.<S2SV_blank>error<S2SV_blank>code<S2SV_blank>%d\\n" , rc ) ; return - 1 ; } aws_iot_mqtt_tests_subscribe_to_test_topic ( & client , QOS1 , & subscribeTopic ) ; printf ( "\\nRunning<S2SV_blank>Test!<S2SV_blank>" ) ; yieldThreadReturn = pthread_create ( & yield_thread , NULL , aws_iot_mqtt_tests_yield_thread_runner , & client ) ; subUnsubThreadReturn = pthread_create ( & sub_unsub_thread , NULL , aws_iot_mqtt_tests_sub_unsub_thread_runner , & client ) ; for ( i = 0 ; i < MAX_PUB_THREAD_COUNT ; i ++ ) { threadData [ i ] . client = & client ; threadData [ i ] . threadId = threadId [ i ] ; pubThreadReturn [ i ] = pthread_create ( & publish_thread [ i ] , NULL , aws_iot_mqtt_tests_publish_thread_runner , & threadData [ i ] ) ; } do { finishedThreadCount = 0 ; for ( i = 0 ; i < MAX_PUB_THREAD_COUNT ; i ++ ) { finishedThreadCount += threadStatus [ i ] ; } printf ( "\\nFinished<S2SV_blank>thread<S2SV_blank>count<S2SV_blank>:<S2SV_blank>%d<S2SV_blank>\\n" , finishedThreadCount ) ; sleep ( 1 ) ; } while ( finishedThreadCount < MAX_PUB_THREAD_COUNT ) ; printf ( "\\nFinished<S2SV_blank>publishing!!" ) ; terminate_yield_thread = true ; terminate_subUnsub_thread = true ; pthread_join ( yield_thread , NULL ) ; pthread_join ( sub_unsub_thread , NULL ) ; for ( i = 0 ; i < MAX_PUB_THREAD_COUNT ; i ++ ) { pthread_join ( publish_thread [ i ] , NULL ) ; } printf ( "\\n\\nCalculating<S2SV_blank>Results!!<S2SV_blank>\\n\\n" ) ; for ( i = 0 ; i < PUBLISH_COUNT ; i ++ ) { for ( j = 0 ; j < MAX_PUB_THREAD_COUNT ; j ++ ) { if ( countArray [ j ] [ i ] > 0 ) { rxMsgCount ++ ; } } } printf ( "\\n\\nResult<S2SV_blank>:<S2SV_blank>\\n" ) ; percentOfRxMsg = ( float ) rxMsgCount * 100 / ( PUBLISH_COUNT * MAX_PUB_THREAD_COUNT ) ; if ( RX_RECEIVE_PERCENTAGE <= percentOfRxMsg && 0 == rxMsgBufferTooBigCounter && 0 == rxUnexpectedNumberCounter && 0 == wrongYieldCount ) { printf ( "\\nSuccess:<S2SV_blank>%f<S2SV_blank>\\%\\n" , percentOfRxMsg ) ; printf ( "Published<S2SV_blank>Messages:<S2SV_blank>%d<S2SV_blank>,<S2SV_blank>Received<S2SV_blank>Messages:<S2SV_blank>%d<S2SV_blank>\\n" , PUBLISH_COUNT * MAX_PUB_THREAD_COUNT , rxMsgCount ) ; printf ( "QoS<S2SV_blank>1<S2SV_blank>re<S2SV_blank>publish<S2SV_blank>count<S2SV_blank>%d\\n" , rePublishCount ) ; printf ( "Connection<S2SV_blank>Attempts<S2SV_blank>%d\\n" , connectCounter ) ; printf ( "Yield<S2SV_blank>count<S2SV_blank>without<S2SV_blank>error<S2SV_blank>during<S2SV_blank>callback<S2SV_blank>%d\\n" , wrongYieldCount ) ; test_result = 0 ; } else { printf ( "\\nFailure:<S2SV_blank>%f\\n" , percentOfRxMsg ) ; printf ( "\\"Received<S2SV_blank>message<S2SV_blank>was<S2SV_blank>too<S2SV_blank>big<S2SV_blank>than<S2SV_blank>anything<S2SV_blank>sent\\"<S2SV_blank>count:<S2SV_blank>%d\\n" , rxMsgBufferTooBigCounter ) ; printf ( "\\"The<S2SV_blank>number<S2SV_blank>received<S2SV_blank>is<S2SV_blank>out<S2SV_blank>of<S2SV_blank>the<S2SV_blank>range\\"<S2SV_blank>count:<S2SV_blank>%d\\n" , rxUnexpectedNumberCounter ) ; printf ( "Yield<S2SV_blank>count<S2SV_blank>without<S2SV_blank>error<S2SV_blank>during<S2SV_blank>callback<S2SV_blank>%d\\n" , wrongYieldCount ) ; test_result = - 2 ; } aws_iot_mqtt_disconnect ( & client ) ; return test_result ; } | <S2SV_ModStart> ; IoT_Client_Init_Params initParams = IoT_Client_Init_Params_initializer <S2SV_ModStart> ; struct timeval <S2SV_ModEnd> subscribeTopic ; unsigned <S2SV_ModStart> { printf ( "\\n##<S2SV_blank>Connect<S2SV_blank>Success.\\n" <S2SV_ModEnd> ) ; } |
6,312 | CWE-000 static void groupSetMemorySpillRatio ( const ResGroupCaps * caps ) { char value [ 64 ] ; snprintf ( value , sizeof ( value ) , "%d" , caps -> memSpillRatio ) ; set_config_option ( "memory_spill_ratio" , value , PGC_USERSET , PGC_S_RESGROUP , <S2SV_StartBug> GUC_ACTION_SET , true ) ; <S2SV_EndBug> } | <S2SV_ModStart> GUC_ACTION_SET , true , 0 |
6,313 | CWE-000 void cmd_scratchpad_show ( I3_CMD ) { DLOG ( "should<S2SV_blank>show<S2SV_blank>scratchpad<S2SV_blank>window\\n" ) ; owindow * current ; <S2SV_StartBug> if ( match_is_empty ( current_match ) ) { <S2SV_EndBug> <S2SV_StartBug> scratchpad_show ( NULL ) ; <S2SV_EndBug> } else { TAILQ_FOREACH ( current , & owindows , owindows ) { DLOG ( "matching:<S2SV_blank>%p<S2SV_blank>/<S2SV_blank>%s\\n" , current -> con , current -> con -> name ) ; <S2SV_StartBug> scratchpad_show ( current -> con ) ; <S2SV_EndBug> } } cmd_output -> needs_tree_render = true ; <S2SV_StartBug> ysuccess ( true ) ; <S2SV_EndBug> } | <S2SV_ModStart> * current ; bool result = false ; <S2SV_ModStart> ) ) { result = <S2SV_ModStart> name ) ; result &= <S2SV_ModStart> ; ysuccess ( result <S2SV_ModEnd> ) ; } |
6,314 | CWE-000 static size_t ble_println_long ( long data , UCHAR fmt ) { <S2SV_StartBug> char tmp_c [ 33 ] ; <S2SV_EndBug> printNumber ( tmp_c , data , fmt ) ; ble_println ( tmp_c ) ; return strlen ( tmp_c ) ; } | <S2SV_ModStart> [ 33 ] ; if ( mode != 3 ) return ( mode * - 1 ) |
6,315 | CWE-000 int connection_init_or_handshake_state ( or_connection_t * conn , int started_here ) { or_handshake_state_t * s ; if ( conn -> handshake_state ) { log_warn ( LD_BUG , "Duplicate<S2SV_blank>call<S2SV_blank>to<S2SV_blank>connection_init_or_handshake_state!" ) ; return 0 ; } s = conn -> handshake_state = tor_malloc_zero ( sizeof ( or_handshake_state_t ) ) ; s -> started_here = started_here ? 1 : 0 ; s -> digest_sent_data = 1 ; s -> digest_received_data = 1 ; <S2SV_StartBug> s -> certs = or_handshake_certs_new ( ) ; <S2SV_EndBug> s -> certs -> started_here = s -> started_here ; return 0 ; } | <S2SV_ModStart> = 1 ; if ( ! started_here && get_current_link_cert_cert ( ) ) { s -> own_link_cert = tor_cert_dup ( get_current_link_cert_cert ( ) ) ; } |
6,316 | CWE-000 void * get_ssh_string ( int * datalen , const void * * data , int * stringlen ) { void * ret ; unsigned int len ; if ( * datalen < 4 ) return NULL ; len = GET_32BIT_MSB_FIRST ( ( const unsigned char * ) * data ) ; <S2SV_StartBug> if ( * datalen < len + 4 ) <S2SV_EndBug> return NULL ; ret = ( void * ) ( ( const char * ) * data + 4 ) ; * datalen -= len + 4 ; * data = ( const char * ) * data + len + 4 ; * stringlen = len ; return ret ; } | <S2SV_ModStart> ( * datalen - 4 < len <S2SV_ModEnd> ) return NULL |
6,317 | CWE-000 static rb_iseq_t * new_child_iseq_ifunc ( rb_iseq_t * iseq , const struct vm_ifunc * ifunc , VALUE name , const rb_iseq_t * parent , enum iseq_type type , int line_no ) { rb_iseq_t * ret_iseq ; debugs ( "[new_child_iseq_ifunc]><S2SV_blank>---------------------------------------\\n" ) ; ret_iseq = rb_iseq_new_ifunc ( ifunc , name , rb_iseq_path ( iseq ) , rb_iseq_realpath ( iseq ) , INT2FIX ( line_no ) , parent , type , ISEQ_COMPILE_DATA ( iseq ) -> option ) ; debugs ( "[new_child_iseq_ifunc]<<S2SV_blank>---------------------------------------\\n" ) ; <S2SV_StartBug> iseq_add_mark_object ( iseq , ( VALUE ) ret_iseq ) ; <S2SV_EndBug> return ret_iseq ; } | <S2SV_ModStart> "[new_child_iseq_ifunc]<<S2SV_blank>---------------------------------------\\n" ) ; iseq_add_mark_object_compile_time <S2SV_ModEnd> ( iseq , |
6,318 | CWE-000 int i2c_acquire ( i2c_t bus ) { <S2SV_StartBug> assert ( bus <= I2C_NUMOF ) ; <S2SV_EndBug> mutex_lock ( & locks [ bus ] ) ; return 0 ; } | <S2SV_ModStart> bus ) { if ( ! ( bus < I2C_NUMOF ) ) { return - 1 ; } <S2SV_ModEnd> mutex_lock ( & |
6,319 | CWE-000 void mptcp_send_active_reset ( struct sock * meta_sk , gfp_t priority ) { struct tcp_sock * meta_tp = tcp_sk ( meta_sk ) ; struct mptcp_cb * mpcb = meta_tp -> mpcb ; struct sock * sk ; if ( ! mpcb -> cnt_subflows ) return ; WARN_ON ( meta_tp -> send_mp_fclose ) ; sk = mptcp_select_ack_sock ( meta_sk ) ; if ( ! sk || mpcb -> infinite_mapping_snd || mpcb -> send_infinite_mapping || mpcb -> infinite_mapping_rcv ) { if ( ! in_serving_softirq ( ) ) local_bh_disable ( ) ; mptcp_sub_force_close_all ( mpcb , NULL ) ; if ( ! in_serving_softirq ( ) ) local_bh_enable ( ) ; return ; } tcp_sk ( sk ) -> send_mp_fclose = 1 ; if ( ! in_serving_softirq ( ) ) local_bh_disable ( ) ; mptcp_sub_force_close_all ( mpcb , sk ) ; tcp_set_state ( sk , TCP_RST_WAIT ) ; if ( ! in_serving_softirq ( ) ) local_bh_enable ( ) ; tcp_send_ack ( sk ) ; tcp_clear_xmit_timers ( sk ) ; inet_csk_reset_keepalive_timer ( sk , inet_csk ( sk ) -> icsk_rto ) ; meta_tp -> send_mp_fclose = 1 ; <S2SV_StartBug> MPTCP_INC_STATS ( sock_net ( meta_sk ) , MPTCP_MIB_FASTCLOSETX ) ; <S2SV_EndBug> } | <S2SV_ModStart> = 1 ; inet_csk ( sk ) -> icsk_retransmits = 0 ; inet_csk ( sk ) -> icsk_backoff = 0 ; |
6,320 | CWE-000 void parseConfigFile ( char * path ) { FILE * fp ; fp = fopen ( path , "r" ) ; if ( fp == NULL ) { <S2SV_StartBug> printf ( "Error<S2SV_blank>while<S2SV_blank>opening<S2SV_blank>file:<S2SV_blank>%s\\n" , path ) ; <S2SV_EndBug> <S2SV_StartBug> exit ( 1 ) ; <S2SV_EndBug> } else { char charBuffer ; int line = 1 ; while ( ( charBuffer = getc ( fp ) ) != EOF ) { if ( charBuffer == '#' ) { while ( getc ( fp ) != '\\n' ) ; line ++ ; } else { int charCounter = 0 ; while ( charBuffer != EOF && charBuffer != ':' ) { if ( charCounter != MAX_NAME_LENGTH - 1 ) { bookmarkNames [ storedLinks ] [ charCounter ++ ] = charBuffer ; } else { <S2SV_StartBug> printf ( "ERROR:<S2SV_blank>Link<S2SV_blank>name<S2SV_blank>on<S2SV_blank>line:<S2SV_blank>%d,<S2SV_blank>in<S2SV_blank>file:<S2SV_blank>%s<S2SV_blank>is<S2SV_blank>to<S2SV_blank>long.\\n" , line , path ) ; <S2SV_EndBug> <S2SV_StartBug> exit ( 1 ) ; <S2SV_EndBug> } charBuffer = getc ( fp ) ; } bookmarkNames [ storedLinks ] [ charCounter ] = '\\0' ; charBuffer = getc ( fp ) ; while ( charBuffer == '<S2SV_blank>' || charBuffer == '\\t' ) { charBuffer = getc ( fp ) ; } charCounter = 0 ; while ( charBuffer != EOF && charBuffer != '\\n' ) { if ( charCounter != MAX_LINK_LENGTH - 1 ) { bookmarkLinks [ storedLinks ] [ charCounter ++ ] = charBuffer ; } else { <S2SV_StartBug> printf ( "ERROR:<S2SV_blank>Link<S2SV_blank>on<S2SV_blank>line<S2SV_blank>%d,<S2SV_blank>in<S2SV_blank>config<S2SV_blank>file<S2SV_blank>%s<S2SV_blank>is<S2SV_blank>to<S2SV_blank>long.\\n" , line , path ) ; <S2SV_EndBug> } charBuffer = getc ( fp ) ; } bookmarkLinks [ storedLinks ] [ charCounter ] = '\\0' ; if ( ++ storedLinks == MAX_ENTRIES ) { <S2SV_StartBug> printf ( "ERROR:<S2SV_blank>On<S2SV_blank>line:<S2SV_blank>%d,<S2SV_blank>in<S2SV_blank>file<S2SV_blank>%s.\\nTo<S2SV_blank>many<S2SV_blank>entries.\\n" , line , path ) ; <S2SV_EndBug> } line ++ ; } } } } | <S2SV_ModStart> NULL ) { fprintf ( stderr , "Error:<S2SV_blank>Openening<S2SV_blank>file<S2SV_blank>%s:<S2SV_blank>" , path ) ; perror ( "" <S2SV_ModEnd> ) ; exit <S2SV_ModStart> ; exit ( EXIT_FAILURE <S2SV_ModEnd> ) ; } <S2SV_ModStart> } else { fprintf ( stderr , "Error:<S2SV_blank>Link<S2SV_blank>name<S2SV_blank>on<S2SV_blank>line:<S2SV_blank>%d,<S2SV_blank>in<S2SV_blank>file:<S2SV_blank>%s<S2SV_blank>is<S2SV_blank>to<S2SV_blank>long.\\n" <S2SV_ModEnd> , line , <S2SV_ModStart> ; exit ( EXIT_FAILURE <S2SV_ModEnd> ) ; } <S2SV_ModStart> } else { fprintf ( stderr , "Error:<S2SV_blank>Link<S2SV_blank>on<S2SV_blank>line<S2SV_blank>%d,<S2SV_blank>in<S2SV_blank>config<S2SV_blank>file<S2SV_blank>%s<S2SV_blank>is<S2SV_blank>to<S2SV_blank>long.\\n" <S2SV_ModEnd> , line , <S2SV_ModStart> MAX_ENTRIES ) { fprintf ( stderr , "Error:<S2SV_blank>On<S2SV_blank>line:<S2SV_blank>%d,<S2SV_blank>in<S2SV_blank>file<S2SV_blank>%s.\\nTo<S2SV_blank>many<S2SV_blank>entries.\\n" <S2SV_ModEnd> , line , |
6,321 | CWE-000 static void ngx_http_upstream_process_request ( ngx_http_request_t * r , ngx_http_upstream_t * u ) { ngx_temp_file_t * tf ; ngx_event_pipe_t * p ; p = u -> pipe ; # if ( NGX_THREADS ) <S2SV_StartBug> if ( p -> writing ) { <S2SV_EndBug> return ; } # endif if ( u -> peer . connection ) { if ( u -> store ) { if ( p -> upstream_eof || p -> upstream_done ) { tf = p -> temp_file ; if ( u -> headers_in . status_n == NGX_HTTP_OK && ( p -> upstream_done || p -> length == - 1 ) && ( u -> headers_in . content_length_n == - 1 || u -> headers_in . content_length_n == tf -> offset ) ) { ngx_http_upstream_store ( r , u ) ; } } } # if ( NGX_HTTP_CACHE ) if ( u -> cacheable ) { if ( p -> upstream_done ) { ngx_http_file_cache_update ( r , p -> temp_file ) ; } else if ( p -> upstream_eof ) { tf = p -> temp_file ; if ( p -> length == - 1 && ( u -> headers_in . content_length_n == - 1 || u -> headers_in . content_length_n == tf -> offset - ( off_t ) r -> cache -> body_start ) ) { ngx_http_file_cache_update ( r , tf ) ; } else { ngx_http_file_cache_free ( r -> cache , tf ) ; } } else if ( p -> upstream_error ) { ngx_http_file_cache_free ( r -> cache , p -> temp_file ) ; } } # endif if ( p -> upstream_done || p -> upstream_eof || p -> upstream_error ) { ngx_log_debug1 ( NGX_LOG_DEBUG_HTTP , r -> connection -> log , 0 , "http<S2SV_blank>upstream<S2SV_blank>exit:<S2SV_blank>%p" , p -> out ) ; if ( p -> upstream_done || ( p -> upstream_eof && p -> length == - 1 ) ) { ngx_http_upstream_finalize_request ( r , u , 0 ) ; return ; } if ( p -> upstream_eof ) { ngx_log_error ( NGX_LOG_ERR , r -> connection -> log , 0 , "upstream<S2SV_blank>prematurely<S2SV_blank>closed<S2SV_blank>connection" ) ; } ngx_http_upstream_finalize_request ( r , u , NGX_HTTP_BAD_GATEWAY ) ; return ; } } if ( p -> downstream_error ) { ngx_log_debug0 ( NGX_LOG_DEBUG_HTTP , r -> connection -> log , 0 , "http<S2SV_blank>upstream<S2SV_blank>downstream<S2SV_blank>error" ) ; if ( ! u -> cacheable && ! u -> store && u -> peer . connection ) { ngx_http_upstream_finalize_request ( r , u , NGX_ERROR ) ; } } } | <S2SV_ModStart> p -> writing && ! p -> aio ) { if ( ngx_event_pipe ( p , 1 ) == NGX_ABORT ) { ngx_http_upstream_finalize_request ( r , u , NGX_ERROR ) ; return ; } } if ( p -> writing |
6,322 | CWE-000 static void handler_sigwinch ( int which ) { struct winsize ws ; if ( ioctl ( STDOUT_FILENO , TIOCGWINSZ , & ws ) == - 1 ) error_exit ( "Cannot<S2SV_blank>get<S2SV_blank>new<S2SV_blank>window<S2SV_blank>size." ) ; window_height = ws . ws_row ; window_width = ws . ws_col ; <S2SV_StartBug> draw ( ) ; <S2SV_EndBug> } | <S2SV_ModStart> . ws_col ; resizeterm ( window_height , window_width ) ; |
6,323 | CWE-000 <S2SV_StartBug> DEFUN ( show_evpn_vni_vni , <S2SV_EndBug> show_evpn_vni_vni_cmd , "show<S2SV_blank>evpn<S2SV_blank>vni<S2SV_blank>" CMD_VNI_RANGE "[json]" , SHOW_STR "EVPN\\n" <S2SV_StartBug> "VxLAN<S2SV_blank>Network<S2SV_blank>Identifier\\n" <S2SV_EndBug> "VNI<S2SV_blank>number\\n" JSON_STR ) { <S2SV_StartBug> struct zebra_vrf * zvrf ; <S2SV_EndBug> vni_t vni ; uint8_t uj = use_json ( argc , argv ) ; <S2SV_StartBug> vni = strtoul ( argv [ 3 ] -> arg , NULL , 10 ) ; <S2SV_EndBug> <S2SV_StartBug> zvrf = vrf_info_lookup ( VRF_DEFAULT ) ; <S2SV_EndBug> <S2SV_StartBug> zebra_vxlan_print_vni ( vty , zvrf , vni , uj ) ; <S2SV_EndBug> return CMD_SUCCESS ; } | <S2SV_ModStart> <S2SV_null> DEFUN ( show_evpn_rmac_vni , show_evpn_rmac_vni_cmd , "show<S2SV_blank>evpn<S2SV_blank>rmac<S2SV_blank>vni<S2SV_blank>" <S2SV_ModEnd> CMD_VNI_RANGE "[json]" , <S2SV_ModStart> , SHOW_STR "EVPN\\n" "RMAC\\n" "L3<S2SV_blank>VNI\\n" <S2SV_ModEnd> "VNI<S2SV_blank>number\\n" JSON_STR ) <S2SV_ModStart> JSON_STR ) { vni_t l3vni = 0 <S2SV_ModEnd> ; uint8_t uj <S2SV_ModStart> argv ) ; l3vni <S2SV_ModEnd> = strtoul ( <S2SV_ModStart> ( argv [ 4 <S2SV_ModEnd> ] -> arg <S2SV_ModStart> 10 ) ; zebra_vxlan_print_rmacs_l3vni <S2SV_ModEnd> ( vty , <S2SV_ModStart> ( vty , l3vni <S2SV_ModEnd> , uj ) |
6,324 | CWE-000 static void ev_view_size_request_continuous_dual_page ( EvView * view , GtkRequisition * requisition ) { gint n_pages ; n_pages = ev_document_get_n_pages ( view -> document ) + 1 ; get_page_y_offset ( view , n_pages , & requisition -> height ) ; switch ( view -> sizing_mode ) { case EV_SIZING_FIT_WIDTH : case EV_SIZING_BEST_FIT : requisition -> width = 1 ; break ; case EV_SIZING_FREE : { gint max_width ; GtkBorder border ; ev_view_get_max_page_size ( view , & max_width , NULL ) ; <S2SV_StartBug> compute_border ( view , max_width , max_width , & border ) ; <S2SV_EndBug> requisition -> width = ( max_width + border . left + border . right ) * 2 + ( view -> spacing * 3 ) ; } break ; default : g_assert_not_reached ( ) ; } } | <S2SV_ModStart> ( view , <S2SV_ModEnd> & border ) |
6,325 | CWE-000 <S2SV_StartBug> static void decrypt_buffer ( uint8_t * buf , size_t len ) { <S2SV_EndBug> * buf ++ = 0xff ; uint8_t * const end = buf + len ; uint8_t idx11 = 0 , idx13 = 0 ; while ( buf != end ) { * buf = ( ( * buf - ( 11 - idx11 ) ) ^ ( KEY11 [ idx11 ] ) ^ ( KEY13 [ idx13 ] ) ) + ( 13 - idx13 ) ; ++ buf ; <S2SV_StartBug> if ( ++ idx11 == 11 ) idx11 == 0 ; <S2SV_EndBug> <S2SV_StartBug> if ( ++ idx13 == 13 ) idx13 == 0 ; <S2SV_EndBug> } } | <S2SV_ModStart> len ) { static const uint8_t KEY11 [ ] = { 0x1E , 0x1D , 0xC4 , 0x77 , 0x26 , 0x97 , 0xE0 , 0x74 , 0x59 , 0x88 , 0x7C } ; static const uint8_t KEY13 [ ] = { 0xA9 , 0x84 , 0x8D , 0xCD , 0x75 , 0x83 , 0x43 , 0x63 , 0x24 , 0x83 , 0x19 , 0xF7 , 0x9A } ; <S2SV_ModStart> 11 ) idx11 = <S2SV_ModEnd> 0 ; if <S2SV_ModStart> 13 ) idx13 = <S2SV_ModEnd> 0 ; } |
6,326 | CWE-000 int mpi_dec_test_decode ( MpiDecTestCmd * cmd ) { MPP_RET ret = MPP_OK ; size_t file_size = 0 ; MppCtx ctx = NULL ; MppApi * mpi = NULL ; MppPacket packet = NULL ; MppFrame frame = NULL ; MpiCmd mpi_cmd = MPP_CMD_BASE ; MppParam param = NULL ; RK_U32 need_split = 1 ; RK_U32 width = cmd -> width ; RK_U32 height = cmd -> height ; MppCodingType type = cmd -> type ; char * buf = NULL ; size_t packet_size = MPI_DEC_STREAM_SIZE ; MppBuffer pkt_buf = NULL ; MppBuffer frm_buf = NULL ; MpiDecLoopData data ; mpp_log ( "mpi_dec_test<S2SV_blank>start\\n" ) ; memset ( & data , 0 , sizeof ( data ) ) ; if ( cmd -> have_input ) { data . fp_input = fopen ( cmd -> file_input , "rb" ) ; if ( NULL == data . fp_input ) { mpp_err ( "failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>input<S2SV_blank>file<S2SV_blank>%s\\n" , cmd -> file_input ) ; goto MPP_TEST_OUT ; } fseek ( data . fp_input , 0L , SEEK_END ) ; file_size = ftell ( data . fp_input ) ; rewind ( data . fp_input ) ; mpp_log ( "input<S2SV_blank>file<S2SV_blank>size<S2SV_blank>%ld\\n" , file_size ) ; } if ( cmd -> have_output ) { data . fp_output = fopen ( cmd -> file_output , "w+b" ) ; if ( NULL == data . fp_output ) { mpp_err ( "failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>output<S2SV_blank>file<S2SV_blank>%s\\n" , cmd -> file_output ) ; goto MPP_TEST_OUT ; } } if ( cmd -> simple ) { buf = mpp_malloc ( char , packet_size ) ; if ( NULL == buf ) { mpp_err ( "mpi_dec_test<S2SV_blank>malloc<S2SV_blank>input<S2SV_blank>stream<S2SV_blank>buffer<S2SV_blank>failed\\n" ) ; goto MPP_TEST_OUT ; } ret = mpp_packet_init ( & packet , buf , packet_size ) ; if ( ret ) { mpp_err ( "mpp_packet_init<S2SV_blank>failed\\n" ) ; goto MPP_TEST_OUT ; } } else { <S2SV_StartBug> ret = mpp_buffer_group_get_internal ( & data . frm_grp , MPP_BUFFER_TYPE_ION ) ; <S2SV_EndBug> if ( ret ) { mpp_err ( "failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>buffer<S2SV_blank>group<S2SV_blank>for<S2SV_blank>input<S2SV_blank>frame<S2SV_blank>ret<S2SV_blank>%d\\n" , ret ) ; goto MPP_TEST_OUT ; } ret = mpp_buffer_group_get_internal ( & data . pkt_grp , MPP_BUFFER_TYPE_ION ) ; if ( ret ) { mpp_err ( "failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>buffer<S2SV_blank>group<S2SV_blank>for<S2SV_blank>output<S2SV_blank>packet<S2SV_blank>ret<S2SV_blank>%d\\n" , ret ) ; goto MPP_TEST_OUT ; } ret = mpp_frame_init ( & frame ) ; if ( MPP_OK != ret ) { mpp_err ( "mpp_frame_init<S2SV_blank>failed\\n" ) ; goto MPP_TEST_OUT ; } <S2SV_StartBug> ret = mpp_buffer_get ( data . frm_grp , & frm_buf , width * height * 2 ) ; <S2SV_EndBug> if ( ret ) { mpp_err ( "failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>buffer<S2SV_blank>for<S2SV_blank>input<S2SV_blank>frame<S2SV_blank>ret<S2SV_blank>%d\\n" , ret ) ; goto MPP_TEST_OUT ; } if ( type == MPP_VIDEO_CodingMJPEG ) { packet_size = file_size ; } ret = mpp_buffer_get ( data . pkt_grp , & pkt_buf , packet_size ) ; if ( ret ) { mpp_err ( "failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>buffer<S2SV_blank>for<S2SV_blank>input<S2SV_blank>frame<S2SV_blank>ret<S2SV_blank>%d\\n" , ret ) ; goto MPP_TEST_OUT ; } mpp_packet_init_with_buffer ( & packet , pkt_buf ) ; buf = mpp_buffer_get_ptr ( pkt_buf ) ; mpp_frame_set_buffer ( frame , frm_buf ) ; <S2SV_StartBug> mpp_log ( "mpi_dec_test<S2SV_blank>decoder<S2SV_blank>test<S2SV_blank>start<S2SV_blank>w<S2SV_blank>%d<S2SV_blank>h<S2SV_blank>%d<S2SV_blank>type<S2SV_blank>%d\\n" , width , height , type ) ; <S2SV_EndBug> } mpp_log ( "mpi_dec_test<S2SV_blank>decoder<S2SV_blank>test<S2SV_blank>start<S2SV_blank>w<S2SV_blank>%d<S2SV_blank>h<S2SV_blank>%d<S2SV_blank>type<S2SV_blank>%d\\n" , width , height , type ) ; ret = mpp_create ( & ctx , & mpi ) ; if ( MPP_OK != ret ) { mpp_err ( "mpp_create<S2SV_blank>failed\\n" ) ; goto MPP_TEST_OUT ; } mpi_cmd = MPP_DEC_SET_PARSER_SPLIT_MODE ; param = & need_split ; ret = mpi -> control ( ctx , mpi_cmd , param ) ; if ( MPP_OK != ret ) { mpp_err ( "mpi->control<S2SV_blank>failed\\n" ) ; goto MPP_TEST_OUT ; } ret = mpp_init ( ctx , MPP_CTX_DEC , type ) ; if ( MPP_OK != ret ) { mpp_err ( "mpp_init<S2SV_blank>failed\\n" ) ; goto MPP_TEST_OUT ; } data . ctx = ctx ; data . mpi = mpi ; data . eos = 0 ; data . buf = buf ; data . packet = packet ; data . packet_size = packet_size ; data . frame = frame ; data . frame_count = 0 ; if ( cmd -> simple ) { while ( ! data . eos ) { decode_simple ( & data ) ; } } else { while ( ! data . eos ) { decode_advanced ( & data ) ; } } ret = mpi -> reset ( ctx ) ; if ( MPP_OK != ret ) { mpp_err ( "mpi->reset<S2SV_blank>failed\\n" ) ; goto MPP_TEST_OUT ; } MPP_TEST_OUT : if ( packet ) { mpp_packet_deinit ( & packet ) ; packet = NULL ; } if ( frame ) { mpp_frame_deinit ( & frame ) ; frame = NULL ; } if ( ctx ) { mpp_destroy ( ctx ) ; ctx = NULL ; } if ( cmd -> simple ) { if ( buf ) { mpp_free ( buf ) ; buf = NULL ; } } else { if ( pkt_buf ) { mpp_buffer_put ( pkt_buf ) ; pkt_buf = NULL ; } if ( frm_buf ) { mpp_buffer_put ( frm_buf ) ; frm_buf = NULL ; } } if ( data . pkt_grp ) { mpp_buffer_group_put ( data . pkt_grp ) ; data . pkt_grp = NULL ; } if ( data . frm_grp ) { mpp_buffer_group_put ( data . frm_grp ) ; data . frm_grp = NULL ; } if ( data . fp_output ) { fclose ( data . fp_output ) ; data . fp_output = NULL ; } if ( data . fp_input ) { fclose ( data . fp_input ) ; data . fp_input = NULL ; } return ret ; } | <S2SV_ModStart> } else { RK_U32 hor_stride = MPP_ALIGN ( width , 16 ) ; RK_U32 ver_stride = MPP_ALIGN ( height , 16 ) ; <S2SV_ModStart> & frm_buf , hor_stride * ver_stride <S2SV_ModEnd> * 2 ) <S2SV_ModStart> frm_buf ) ; <S2SV_ModEnd> } mpp_log ( |
6,327 | CWE-000 unsigned long dma_alloc_from_contiguous ( struct device * dev , int count , unsigned int align ) { unsigned long mask , pfn = 0 , pageno , start = 0 ; struct cma * cma = dev_get_cma_area ( dev ) ; int ret = 0 ; int tries = 0 ; int retry_after_sleep = 0 ; if ( ! cma || ! cma -> count ) return 0 ; if ( align > CONFIG_CMA_ALIGNMENT ) align = CONFIG_CMA_ALIGNMENT ; pr_debug ( "%s(cma<S2SV_blank>%p,<S2SV_blank>count<S2SV_blank>%d,<S2SV_blank>align<S2SV_blank>%d)\\n" , __func__ , ( void * ) cma , count , align ) ; if ( ! count ) return 0 ; mask = ( 1 << align ) - 1 ; for ( ; ; ) { mutex_lock ( & cma -> lock ) ; pageno = bitmap_find_next_zero_area ( cma -> bitmap , cma -> count , start , count , mask ) ; if ( pageno >= cma -> count ) { if ( retry_after_sleep < 2 ) { pfn = 0 ; start = 0 ; pr_debug ( "%s:<S2SV_blank>Memory<S2SV_blank>range<S2SV_blank>busy," "retry<S2SV_blank>after<S2SV_blank>sleep\\n" , __func__ ) ; msleep ( 100 ) ; retry_after_sleep ++ ; mutex_unlock ( & cma -> lock ) ; continue ; } else { pfn = 0 ; mutex_unlock ( & cma -> lock ) ; break ; } } bitmap_set ( cma -> bitmap , pageno , count ) ; mutex_unlock ( & cma -> lock ) ; pfn = cma -> base_pfn + pageno ; mutex_lock ( & cma_mutex ) ; if ( cma -> in_system ) ret = alloc_contig_range ( pfn , pfn + count , MIGRATE_CMA ) ; mutex_unlock ( & cma_mutex ) ; if ( ret == 0 ) { break ; } else if ( ret != - EBUSY ) { <S2SV_StartBug> clear_cma_bitmap ( cma , pfn , count ) ; <S2SV_EndBug> pfn = 0 ; break ; } clear_cma_bitmap ( cma , pfn , count ) ; tries ++ ; trace_dma_alloc_contiguous_retry ( tries ) ; pr_debug ( "%s():<S2SV_blank>memory<S2SV_blank>range<S2SV_blank>at<S2SV_blank>%p<S2SV_blank>is<S2SV_blank>busy,<S2SV_blank>retrying\\n" , __func__ , pfn_to_page ( pfn ) ) ; start = pageno + mask + 1 ; } mutex_unlock ( & cma_mutex ) ; pr_debug ( "%s():<S2SV_blank>returned<S2SV_blank>%lx\\n" , __func__ , pfn ) ; return pfn ; } | <S2SV_ModStart> EBUSY ) { pfn = 0 ; |
6,328 | CWE-000 static int fake_tx ( struct device * dev , struct net_buf * buf ) { <S2SV_StartBug> TC_PRINT ( "Sending<S2SV_blank>buffer<S2SV_blank>%p<S2SV_blank>-<S2SV_blank>length<S2SV_blank>%u\\n" , <S2SV_EndBug> buf , net_buf_frags_len ( buf ) ) ; net_nbuf_set_ll_reserve ( current_buf , net_nbuf_ll_reserve ( buf ) ) ; insert_frag_dummy_way ( buf ) ; k_sem_give ( & driver_lock ) ; return 0 ; } | <S2SV_ModStart> { TC_PRINT ( "Sending<S2SV_blank>buffer<S2SV_blank>%p<S2SV_blank>-<S2SV_blank>length<S2SV_blank>%zu\\n" <S2SV_ModEnd> , buf , |
6,329 | CWE-000 void Deflate_MakeStream ( Stream * stream , DeflateState * state , Stream * underlying ) { state -> InputPosition = 0 ; state -> Source = underlying ; Stream_SetName ( stream , & underlying -> Name ) ; stream -> Meta_Inflate = state ; <S2SV_StartBug> stream -> Read = Inflate_StreamWrite ; <S2SV_EndBug> stream -> Write = Deflate_StreamWrite ; <S2SV_StartBug> stream -> Seek = Inflate_StreamSeek ; <S2SV_EndBug> stream -> Close = Deflate_StreamClose ; } | <S2SV_ModStart> -> Read = Stream_UnsupportedIO <S2SV_ModEnd> ; stream -> <S2SV_ModStart> -> Seek = Stream_UnsupportedSeek <S2SV_ModEnd> ; stream -> |
6,330 | CWE-000 static struct page * __get_node_page ( struct f2fs_sb_info * sbi , pgoff_t nid , struct page * parent , int start ) { struct page * page ; int err ; if ( ! nid ) return ERR_PTR ( - ENOENT ) ; f2fs_bug_on ( sbi , check_nid_range ( sbi , nid ) ) ; repeat : page = f2fs_grab_cache_page ( NODE_MAPPING ( sbi ) , nid , false ) ; if ( ! page ) return ERR_PTR ( - ENOMEM ) ; err = read_node_page ( page , READ_SYNC ) ; if ( err < 0 ) { f2fs_put_page ( page , 1 ) ; return ERR_PTR ( err ) ; <S2SV_StartBug> } else if ( err == LOCKED_PAGE ) { <S2SV_EndBug> goto page_hit ; } if ( parent ) ra_node_pages ( parent , start + 1 , MAX_RA_NODE ) ; lock_page ( page ) ; if ( unlikely ( page -> mapping != NODE_MAPPING ( sbi ) ) ) { f2fs_put_page ( page , 1 ) ; goto repeat ; } <S2SV_StartBug> if ( unlikely ( ! PageUptodate ( page ) ) ) <S2SV_EndBug> goto out_err ; <S2SV_StartBug> page_hit : <S2SV_EndBug> mark_page_accessed ( page ) ; if ( unlikely ( nid != nid_of_node ( page ) ) ) { <S2SV_StartBug> f2fs_bug_on ( sbi , 1 ) ; <S2SV_EndBug> <S2SV_StartBug> ClearPageUptodate ( page ) ; <S2SV_EndBug> out_err : f2fs_put_page ( page , 1 ) ; <S2SV_StartBug> return ERR_PTR ( - EIO ) ; <S2SV_EndBug> } return page ; } | <S2SV_ModStart> LOCKED_PAGE ) { err = 0 ; <S2SV_ModStart> ) ) ) { err = - EIO ; <S2SV_ModStart> goto out_err ; } <S2SV_ModStart> ) ) { f2fs_msg ( sbi -> sb , KERN_WARNING , "inconsistent<S2SV_blank>node<S2SV_blank>block,<S2SV_blank>" "nid:%lu,<S2SV_blank>node_footer[nid:%u,ino:%u,ofs:%u,cpver:%llu,blkaddr:%u]" , nid , nid_of_node ( page ) , ino_of_node ( page ) , ofs_of_node ( page ) , cpver_of_node ( page ) , next_blkaddr_of_node ( page ) <S2SV_ModEnd> ) ; ClearPageUptodate <S2SV_ModStart> ( page ) ; err = - EINVAL <S2SV_ModStart> return ERR_PTR ( err <S2SV_ModEnd> ) ; } |
6,331 | CWE-000 void mmc_gpiod_request_cd_irq ( struct mmc_host * host ) { struct mmc_gpio * ctx = host -> slot . handler_priv ; int irq = - EINVAL ; int ret ; if ( host -> slot . cd_irq >= 0 || ! ctx || ! ctx -> cd_gpio ) return ; if ( ! ( host -> caps & MMC_CAP_NEEDS_POLL ) ) irq = gpiod_to_irq ( ctx -> cd_gpio ) ; if ( irq >= 0 ) { if ( ! ctx -> cd_gpio_isr ) ctx -> cd_gpio_isr = mmc_gpio_cd_irqt ; ret = devm_request_threaded_irq ( host -> parent , irq , NULL , ctx -> cd_gpio_isr , IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT , ctx -> cd_label , host ) ; if ( ret < 0 ) irq = ret ; } host -> slot . cd_irq = irq ; if ( irq < 0 ) host -> caps |= MMC_CAP_NEEDS_POLL ; <S2SV_StartBug> else if ( ( host -> caps & MMC_CAP_CD_WAKE ) && ! enable_irq_wake ( irq ) ) <S2SV_EndBug> host -> slot . cd_wake_enabled = true ; } | <S2SV_ModStart> |= MMC_CAP_NEEDS_POLL ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
6,332 | CWE-000 struct sock * tcp_check_req ( struct sock * sk , struct sk_buff * skb , struct request_sock * req , bool fastopen , bool * req_stolen ) { struct tcp_options_received tmp_opt ; struct sock * child ; const struct tcphdr * th = tcp_hdr ( skb ) ; __be32 flg = tcp_flag_word ( th ) & ( TCP_FLAG_RST | TCP_FLAG_SYN | TCP_FLAG_ACK ) ; bool paws_reject = false ; bool own_req ; tmp_opt . saw_tstamp = 0 ; if ( th -> doff > ( sizeof ( struct tcphdr ) >> 2 ) ) { tcp_parse_options ( sock_net ( sk ) , skb , & tmp_opt , 0 , NULL ) ; if ( tmp_opt . saw_tstamp ) { tmp_opt . ts_recent = req -> ts_recent ; if ( tmp_opt . rcv_tsecr ) tmp_opt . rcv_tsecr -= tcp_rsk ( req ) -> ts_off ; <S2SV_StartBug> tmp_opt . ts_recent_stamp = get_seconds ( ) - ( ( TCP_TIMEOUT_INIT / HZ ) << req -> num_timeout ) ; <S2SV_EndBug> paws_reject = tcp_paws_reject ( & tmp_opt , th -> rst ) ; } } if ( TCP_SKB_CB ( skb ) -> seq == tcp_rsk ( req ) -> rcv_isn && flg == TCP_FLAG_SYN && ! paws_reject ) { if ( ! tcp_oow_rate_limited ( sock_net ( sk ) , skb , LINUX_MIB_TCPACKSKIPPEDSYNRECV , & tcp_rsk ( req ) -> last_oow_ack_time ) && ! inet_rtx_syn_ack ( sk , req ) ) { unsigned long expires = jiffies ; expires += min ( TCP_TIMEOUT_INIT << req -> num_timeout , TCP_RTO_MAX ) ; if ( ! fastopen ) mod_timer_pending ( & req -> rsk_timer , expires ) ; else req -> rsk_timer . expires = expires ; } return NULL ; } if ( ( flg & TCP_FLAG_ACK ) && ! fastopen && ( TCP_SKB_CB ( skb ) -> ack_seq != tcp_rsk ( req ) -> snt_isn + 1 ) ) return sk ; if ( paws_reject || ! tcp_in_window ( TCP_SKB_CB ( skb ) -> seq , TCP_SKB_CB ( skb ) -> end_seq , tcp_rsk ( req ) -> rcv_nxt , tcp_rsk ( req ) -> rcv_nxt + req -> rsk_rcv_wnd ) ) { if ( ! ( flg & TCP_FLAG_RST ) && ! tcp_oow_rate_limited ( sock_net ( sk ) , skb , LINUX_MIB_TCPACKSKIPPEDSYNRECV , & tcp_rsk ( req ) -> last_oow_ack_time ) ) req -> rsk_ops -> send_ack ( sk , skb , req ) ; if ( paws_reject ) __NET_INC_STATS ( sock_net ( sk ) , LINUX_MIB_PAWSESTABREJECTED ) ; return NULL ; } if ( tmp_opt . saw_tstamp && ! after ( TCP_SKB_CB ( skb ) -> seq , tcp_rsk ( req ) -> rcv_nxt ) ) req -> ts_recent = tmp_opt . rcv_tsval ; if ( TCP_SKB_CB ( skb ) -> seq == tcp_rsk ( req ) -> rcv_isn ) { flg &= ~ TCP_FLAG_SYN ; } if ( flg & ( TCP_FLAG_RST | TCP_FLAG_SYN ) ) { __TCP_INC_STATS ( sock_net ( sk ) , TCP_MIB_ATTEMPTFAILS ) ; goto embryonic_reset ; } if ( ! ( flg & TCP_FLAG_ACK ) ) return NULL ; if ( fastopen ) return sk ; if ( req -> num_timeout < inet_csk ( sk ) -> icsk_accept_queue . rskq_defer_accept && TCP_SKB_CB ( skb ) -> end_seq == tcp_rsk ( req ) -> rcv_isn + 1 ) { inet_rsk ( req ) -> acked = 1 ; __NET_INC_STATS ( sock_net ( sk ) , LINUX_MIB_TCPDEFERACCEPTDROP ) ; return NULL ; } child = inet_csk ( sk ) -> icsk_af_ops -> syn_recv_sock ( sk , skb , req , NULL , req , & own_req ) ; if ( ! child ) goto listen_overflow ; sock_rps_save_rxhash ( child , skb ) ; tcp_synack_rtt_meas ( child , req ) ; * req_stolen = ! own_req ; return inet_csk_complete_hashdance ( sk , child , req , own_req ) ; listen_overflow : if ( ! sock_net ( sk ) -> ipv4 . sysctl_tcp_abort_on_overflow ) { inet_rsk ( req ) -> acked = 1 ; return NULL ; } embryonic_reset : if ( ! ( flg & TCP_FLAG_RST ) ) { req -> rsk_ops -> send_reset ( sk , skb ) ; } else if ( fastopen ) { reqsk_fastopen_remove ( sk , req , true ) ; tcp_reset ( sk ) ; } if ( ! fastopen ) { inet_csk_reqsk_queue_drop ( sk , req ) ; __NET_INC_STATS ( sock_net ( sk ) , LINUX_MIB_EMBRYONICRSTS ) ; } return NULL ; } | <S2SV_ModStart> . ts_recent_stamp = ktime_get_seconds <S2SV_ModEnd> ( ) - |
6,333 | CWE-000 static int resize_stripes ( struct r5conf * conf , int newsize ) { struct stripe_head * osh , * nsh ; LIST_HEAD ( newstripes ) ; struct disk_info * ndisks ; int err ; struct kmem_cache * sc ; int i ; int hash , cnt ; if ( newsize <= conf -> pool_size ) return 0 ; err = md_allow_write ( conf -> mddev ) ; if ( err ) return err ; sc = kmem_cache_create ( conf -> cache_name [ 1 - conf -> active_name ] , sizeof ( struct stripe_head ) + ( newsize - 1 ) * sizeof ( struct r5dev ) , 0 , 0 , NULL ) ; if ( ! sc ) return - ENOMEM ; <S2SV_StartBug> for ( i = conf -> max_nr_stripes ; i ; i -- ) { <S2SV_EndBug> nsh = alloc_stripe ( sc , GFP_KERNEL ) ; if ( ! nsh ) break ; nsh -> raid_conf = conf ; list_add ( & nsh -> lru , & newstripes ) ; } if ( i ) { while ( ! list_empty ( & newstripes ) ) { nsh = list_entry ( newstripes . next , struct stripe_head , lru ) ; list_del ( & nsh -> lru ) ; kmem_cache_free ( sc , nsh ) ; } <S2SV_StartBug> kmem_cache_destroy ( sc ) ; <S2SV_EndBug> return - ENOMEM ; } hash = 0 ; cnt = 0 ; list_for_each_entry ( nsh , & newstripes , lru ) { lock_device_hash_lock ( conf , hash ) ; wait_event_exclusive_cmd ( conf -> wait_for_stripe [ hash ] , ! list_empty ( conf -> inactive_list + hash ) , unlock_device_hash_lock ( conf , hash ) , lock_device_hash_lock ( conf , hash ) ) ; osh = get_free_stripe ( conf , hash ) ; unlock_device_hash_lock ( conf , hash ) ; for ( i = 0 ; i < conf -> pool_size ; i ++ ) { nsh -> dev [ i ] . page = osh -> dev [ i ] . page ; nsh -> dev [ i ] . orig_page = osh -> dev [ i ] . page ; } nsh -> hash_lock_index = hash ; kmem_cache_free ( conf -> slab_cache , osh ) ; cnt ++ ; if ( cnt >= conf -> max_nr_stripes / NR_STRIPE_HASH_LOCKS + ! ! ( ( conf -> max_nr_stripes % NR_STRIPE_HASH_LOCKS ) > hash ) ) { hash ++ ; cnt = 0 ; } } kmem_cache_destroy ( conf -> slab_cache ) ; ndisks = kzalloc ( newsize * sizeof ( struct disk_info ) , GFP_NOIO ) ; if ( ndisks ) { for ( i = 0 ; i < conf -> raid_disks ; i ++ ) ndisks [ i ] = conf -> disks [ i ] ; kfree ( conf -> disks ) ; conf -> disks = ndisks ; } else err = - ENOMEM ; <S2SV_StartBug> while ( ! list_empty ( & newstripes ) ) { <S2SV_EndBug> nsh = list_entry ( newstripes . next , struct stripe_head , lru ) ; list_del_init ( & nsh -> lru ) ; for ( i = conf -> raid_disks ; i < newsize ; i ++ ) if ( nsh -> dev [ i ] . page == NULL ) { struct page * p = alloc_page ( GFP_NOIO ) ; nsh -> dev [ i ] . page = p ; nsh -> dev [ i ] . orig_page = p ; if ( ! p ) err = - ENOMEM ; } release_stripe ( nsh ) ; } conf -> slab_cache = sc ; conf -> active_name = 1 - conf -> active_name ; if ( ! err ) conf -> pool_size = newsize ; return err ; } | <S2SV_ModStart> - ENOMEM ; mutex_lock ( & conf -> cache_size_mutex ) ; <S2SV_ModStart> kmem_cache_destroy ( sc ) ; mutex_unlock ( & conf -> cache_size_mutex <S2SV_ModStart> - ENOMEM ; mutex_unlock ( & conf -> cache_size_mutex ) ; |
6,334 | CWE-000 void setSignals ( ) { <S2SV_StartBug> for ( int i = 0 ; i < 9 ; i ++ ) { <S2SV_EndBug> memset ( & ( act [ i ] ) , 0 , sizeof ( act [ i ] ) ) ; memset ( & ( old [ i ] ) , 0 , sizeof ( old [ i ] ) ) ; } sigemptyset ( & set ) ; sigaddset ( & set , SIGUSR1 ) ; sigaddset ( & set , SIGALRM ) ; act [ 0 ] . sa_handler = timerHand ; act [ 0 ] . sa_mask = set ; sigemptyset ( & set ) ; sigaddset ( & set , SIGUSR1 ) ; sigaddset ( & set , SIGVTALRM ) ; act [ 1 ] . sa_handler = timerHand ; act [ 1 ] . sa_mask = set ; sigemptyset ( & set ) ; sigaddset ( & set , SIGUSR1 ) ; act [ 2 ] . sa_handler = ursignalHand ; act [ 2 ] . sa_mask = set ; sigemptyset ( & set ) ; sigaddset ( & set , SIGUSR1 ) ; sigaddset ( & set , SIGUSR2 ) ; act [ 3 ] . sa_handler = ursignalHand2 ; act [ 3 ] . sa_mask = set ; sigemptyset ( & set ) ; sigaddset ( & set , SIGUSR1 ) ; sigaddset ( & set , SIGWINCH ) ; act [ 4 ] . sa_handler = windHand ; act [ 4 ] . sa_mask = set ; sigemptyset ( & set ) ; sigaddset ( & set , SIGUSR1 ) ; sigaddset ( & set , SIGTERM ) ; act [ 5 ] . sa_handler = killHand ; act [ 5 ] . sa_mask = set ; sigemptyset ( & set ) ; sigaddset ( & set , SIGUSR1 ) ; sigaddset ( & set , SIGINT ) ; act [ 6 ] . sa_handler = killHand ; act [ 6 ] . sa_mask = set ; sigemptyset ( & set ) ; sigaddset ( & set , SIGUSR1 ) ; sigaddset ( & set , SIGTSTP ) ; act [ 7 ] . sa_handler = ursignalHand2 ; act [ 7 ] . sa_mask = set ; sigemptyset ( & set ) ; sigaddset ( & set , SIGUSR1 ) ; sigaddset ( & set , SIGQUIT ) ; act [ 8 ] . sa_handler = killHand ; act [ 8 ] . sa_mask = set ; sigemptyset ( & set ) ; sigaddset ( & set , SIGUSR1 ) ; sigaddset ( & set , SIGSEGV ) ; act [ 9 ] . sa_handler = SIG_IGN ; act [ 9 ] . sa_mask = set ; sigaction ( SIGALRM , & ( act [ 0 ] ) , & ( old [ 0 ] ) ) ; sigaction ( SIGVTALRM , & ( act [ 1 ] ) , & ( old [ 1 ] ) ) ; sigaction ( SIGUSR1 , & ( act [ 2 ] ) , & ( old [ 2 ] ) ) ; sigaction ( SIGUSR2 , & ( act [ 3 ] ) , & ( old [ 3 ] ) ) ; sigaction ( SIGWINCH , & ( act [ 4 ] ) , & ( old [ 4 ] ) ) ; sigaction ( SIGTERM , & ( act [ 5 ] ) , & ( old [ 5 ] ) ) ; sigaction ( SIGINT , & ( act [ 6 ] ) , & ( old [ 6 ] ) ) ; sigaction ( SIGTSTP , & ( act [ 7 ] ) , & ( old [ 7 ] ) ) ; sigaction ( SIGQUIT , & ( act [ 8 ] ) , & ( old [ 8 ] ) ) ; sigaction ( SIGSEGV , & ( act [ 9 ] ) , & ( old [ 9 ] ) ) ; } | <S2SV_ModStart> ( ) { int i ; for ( <S2SV_ModEnd> i = 0 |
6,335 | CWE-000 static jit_value_t compile_callN ( jit_function_t func , const char * name , Lisp_Object ( * callee ) ( ptrdiff_t , Lisp_Object * ) , int howmany , jit_value_t scratch , jit_value_t * stack ) { jit_value_t args [ 2 ] ; args [ 0 ] = jit_value_create_nint_constant ( func , ptrdiff_t_type , howmany ) ; args [ 1 ] = scratch ; int i ; for ( i = 0 ; i < howmany ; ++ i ) jit_insn_store_relative ( func , scratch , i * sizeof ( Lisp_Object ) , <S2SV_StartBug> stack [ i ] ) ; <S2SV_EndBug> return jit_insn_call_native ( func , name , ( void * ) callee , callN_signature , args , 2 , JIT_CALL_NOTHROW ) ; } | <S2SV_ModStart> , stack [ 1 + |
6,336 | CWE-000 <S2SV_StartBug> static int <S2SV_EndBug> probe_table ( uint64_t address , const char * sig ) { void * va = hpa2hva ( address ) ; struct acpi_table_header * table = ( struct acpi_table_header * ) va ; <S2SV_StartBug> if ( strncmp ( table -> signature , sig , ACPI_NAME_SIZE ) != 0 ) { <S2SV_EndBug> <S2SV_StartBug> return 0 ; <S2SV_EndBug> } <S2SV_StartBug> return 1 ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> static bool <S2SV_ModEnd> probe_table ( uint64_t <S2SV_ModStart> ) va ; bool ret ; <S2SV_ModStart> 0 ) { ret = false ; } else { ret = true <S2SV_ModEnd> ; } return <S2SV_ModStart> ; } return ret <S2SV_ModEnd> ; } <S2SV_null> |
6,337 | CWE-000 int Perl_mg_set ( pTHX_ SV * sv ) { dVAR ; const I32 mgs_ix = SSNEW ( sizeof ( MGS ) ) ; MAGIC * mg ; MAGIC * nextmg ; PERL_ARGS_ASSERT_MG_SET ; if ( PL_localizing == 2 && sv == DEFSV ) return 0 ; if ( sv == UNDEF || sv == PLACEHOLDER || sv == SV_YES || sv == SV_NO ) return 0 ; <S2SV_StartBug> save_magic_flags ( mgs_ix , sv , SVs_GMG | SVs_SMG ) ; <S2SV_EndBug> for ( mg = SvMAGIC ( sv ) ; mg ; mg = nextmg ) { const MGVTBL * vtbl = mg -> mg_virtual ; nextmg = mg -> mg_moremagic ; if ( mg -> mg_flags & MGf_GSKIP ) { mg -> mg_flags &= ~ MGf_GSKIP ; ( SSPTR ( mgs_ix , MGS * ) ) -> mgs_flags &= ~ ( SVs_GMG | SVs_SMG | SVs_RMG ) ; } if ( PL_localizing == 2 && PERL_MAGIC_TYPE_IS_VALUE_MAGIC ( mg -> mg_type ) ) continue ; if ( vtbl && vtbl -> svt_set ) vtbl -> svt_set ( aTHX_ sv , mg ) ; } restore_magic ( INT2PTR ( void * , ( IV ) mgs_ix ) ) ; return 0 ; } | <S2SV_ModStart> SVs_GMG | SVs_SMG ) ; assert ( sv |
6,338 | CWE-000 void setup_offset ( ) { int i , k ; for ( i = 0 ; i < NUMLINK - 1 ; i ++ ) { for ( k = 0 ; k < NDIMS ; k ++ ) offset [ i ] [ k ] = 0 ; offset [ i ] [ i ] = 1 ; } for ( k = 0 ; k < NDIMS ; k ++ ) offset [ DIR_5 ] [ k ] = - 1 ; # ifdef DEBUG_CHECK node0_printf ( "There<S2SV_blank>are<S2SV_blank>%d<S2SV_blank>distinct<S2SV_blank>paths:\\n" , NUMLINK ) ; # endif for ( i = 0 ; i < NUMLINK ; i ++ ) { goffset [ i ] = make_gather ( cubic_neighbor , offset [ i ] , WANT_INVERSE , NO_EVEN_ODD , SCRAMBLE_PARITY ) ; # ifdef DEBUG_CHECK int dir ; node0_printf ( "<S2SV_blank><S2SV_blank>%d<S2SV_blank>ahead:" , i ) ; <S2SV_StartBug> for ( dir = XUP ; dir <= TUP ; dir ++ ) <S2SV_EndBug> node0_printf ( "<S2SV_blank>%d" , offset [ i ] [ dir ] ) ; node0_printf ( "<S2SV_blank>(offset<S2SV_blank>%d)\\n" , goffset [ i ] ) ; # endif } if ( PBC >= 0 ) node0_printf ( "Periodic<S2SV_blank>temporal<S2SV_blank>boundary<S2SV_blank>conditions\\n" ) ; if ( PBC < 0 ) node0_printf ( "Antiperiodic<S2SV_blank>temporal<S2SV_blank>boundary<S2SV_blank>conditions\\n" ) ; setup_bc ( ) ; } | <S2SV_ModStart> i ) ; FORALLUPDIR ( dir <S2SV_ModEnd> ) node0_printf ( |
6,339 | CWE-000 pid_t # if defined __arm__ && defined __thumb__ && __GNUC_PREREQ ( 4 , 6 ) attribute_optimize ( "O2" ) # endif fork ( void ) { pid_t pid ; struct used_handler { struct fork_handler * handler ; struct used_handler * next ; } * allp = NULL ; struct fork_handler * runp ; while ( ( runp = __fork_handlers ) != NULL ) { atomic_full_barrier ( ) ; unsigned int oldval = runp -> refcntr ; if ( oldval == 0 ) continue ; if ( atomic_compare_and_exchange_bool_acq ( & __fork_handlers -> refcntr , oldval + 1 , oldval ) ) continue ; while ( 1 ) { if ( runp -> prepare_handler != NULL ) runp -> prepare_handler ( ) ; struct used_handler * newp = ( struct used_handler * ) alloca ( sizeof ( * newp ) ) ; newp -> handler = runp ; newp -> next = allp ; allp = newp ; runp = runp -> next ; if ( runp == NULL ) break ; atomic_increment ( & runp -> refcntr ) ; } break ; } __UCLIBC_IO_MUTEX_LOCK_CANCEL_UNSAFE ( _stdio_openlist_add_lock ) ; # ifndef NDEBUG pid_t ppid = THREAD_GETMEM ( THREAD_SELF , tid ) ; # endif # ifdef ARCH_FORK pid = ARCH_FORK ( ) ; # else # error "ARCH_FORK<S2SV_blank>must<S2SV_blank>be<S2SV_blank>defined<S2SV_blank>so<S2SV_blank>that<S2SV_blank>the<S2SV_blank>CLONE_SETTID<S2SV_blank>flag<S2SV_blank>is<S2SV_blank>used" pid = INLINE_SYSCALL ( fork , 0 ) ; # endif if ( pid == 0 ) { <S2SV_StartBug> struct pthread * self = THREAD_SELF ; <S2SV_EndBug> assert ( THREAD_GETMEM ( self , tid ) != ppid ) ; if ( __fork_generation_pointer != NULL ) * __fork_generation_pointer += 4 ; fresetlockfiles ( ) ; STDIO_INIT_MUTEX ( _stdio_openlist_add_lock ) ; while ( allp != NULL ) { if ( allp -> handler -> child_handler != NULL ) allp -> handler -> child_handler ( ) ; allp -> handler -> refcntr = 1 ; allp = allp -> next ; } __fork_lock = LLL_LOCK_INITIALIZER ; } else { assert ( THREAD_GETMEM ( THREAD_SELF , tid ) == ppid ) ; __UCLIBC_IO_MUTEX_UNLOCK_CANCEL_UNSAFE ( _stdio_openlist_add_lock ) ; while ( allp != NULL ) { if ( allp -> handler -> parent_handler != NULL ) allp -> handler -> parent_handler ( ) ; if ( atomic_decrement_and_test ( & allp -> handler -> refcntr ) && allp -> handler -> need_signal ) lll_futex_wake ( allp -> handler -> refcntr , 1 , LLL_PRIVATE ) ; allp = allp -> next ; } } return pid ; } | <S2SV_ModStart> 0 ) { assert ( THREAD_GETMEM ( THREAD_SELF <S2SV_ModEnd> , tid ) |
6,340 | CWE-000 static inline int _parse_primitive_field ( _context_t * ctx , proto_type_t * type ) { const lexer_token_t * tok = _peek ( ctx , 1 ) ; if ( NULL == tok ) _RAISE ( ctx , return ERROR_CODE ( int ) , "Internal<S2SV_blank>error:<S2SV_blank>cannot<S2SV_blank>peek<S2SV_blank>token" ) ; uint32_t elem_size = tok -> data -> size ; proto_type_atomic_metadata_t metadata = tok -> metadata ; _TRY_CONSUME ( ctx , return ERROR_CODE ( int ) , 1 ) ; if ( NULL == ( tok = _peek ( ctx , 1 ) ) || tok -> type != LEXER_TOKEN_ID ) _RAISE ( ctx , return ERROR_CODE ( int ) , "snytax<S2SV_blank>error:<S2SV_blank>identifer<S2SV_blank>expected" ) ; static char namebuf [ 128 ] ; snprintf ( namebuf , sizeof ( namebuf ) , "%s" , tok -> data -> id ) ; _TRY_CONSUME ( ctx , return ERROR_CODE ( int ) , 1 ) ; if ( NULL == ( tok = _peek ( ctx , 1 ) ) ) _RAISE ( ctx , return ERROR_CODE ( int ) , "internal<S2SV_blank>error:<S2SV_blank>cannot<S2SV_blank>peek<S2SV_blank>token" ) ; static uint32_t dimensions [ 128 ] ; char typename_buf [ 4096 ] ; int rc = 0 ; int64_t ival = 0 ; double dval = 0 ; float fval = 0 ; if ( tok -> type == LEXER_TOKEN_EQUAL ) { if ( metadata . flags . numeric . invalid ) _RAISE ( ctx , return ERROR_CODE ( int ) , "syntax<S2SV_blank>error:<S2SV_blank>interger<S2SV_blank>expected" ) ; _TRY_CONSUME ( ctx , return ERROR_CODE ( int ) , 1 ) ; if ( NULL == ( tok = _peek ( ctx , 1 ) ) ) _RAISE ( ctx , return ERROR_CODE ( int ) , "internal<S2SV_blank>error:<S2SV_blank>cannot<S2SV_blank>peek<S2SV_blank>token" ) ; if ( tok -> type == LEXER_TOKEN_NUMBER ) ival = tok -> data -> number ; else if ( tok -> type == LEXER_TOKEN_FLOAT_POINT ) dval = tok -> data -> floatpoint ; else _RAISE ( ctx , return ERROR_CODE ( int ) , "syntax<S2SV_blank>error:<S2SV_blank>number<S2SV_blank>expected" ) ; if ( metadata . flags . numeric . is_real ) { if ( tok -> type == LEXER_TOKEN_NUMBER ) dval = ( double ) ival ; if ( elem_size == 4 ) { fval = ( float ) dval ; metadata . numeric_default = & fval ; metadata . flags . numeric . default_size = 4 ; } else { metadata . numeric_default = & dval ; metadata . flags . numeric . default_size = 8 ; } elem_size = 0 ; } else if ( tok -> type == LEXER_TOKEN_NUMBER ) { <S2SV_StartBug> ival &= ( ( 1ll << ( 8 * elem_size ) ) - 1 ) ; <S2SV_EndBug> metadata . numeric_default = & ival ; metadata . flags . numeric . default_size = elem_size & 0x1fffffffu ; elem_size = 0 ; } else _RAISE ( ctx , return ERROR_CODE ( int ) , "syntax<S2SV_blank>error:<S2SV_blank>integer<S2SV_blank>expected" ) ; _TRY_CONSUME ( ctx , return ERROR_CODE ( int ) , 1 ) ; } else if ( tok -> type == LEXER_TOKEN_AT ) { if ( ! metadata . flags . scope . valid ) _RAISE ( ctx , return ERROR_CODE ( int ) , "syntax<S2SV_blank>error:<S2SV_blank>scope<S2SV_blank>object<S2SV_blank>type<S2SV_blank>expected" ) ; _TRY_CONSUME ( ctx , return ERROR_CODE ( int ) , 1 ) ; if ( NULL != ( tok = _peek ( ctx , 1 ) ) && tok -> type == LEXER_TOKEN_ID ) { metadata . flags . scope . typename_size = strlen ( tok -> data -> id ) & 0x3fffffff ; metadata . scope_typename = typename_buf ; snprintf ( typename_buf , sizeof ( typename_buf ) , "%s" , tok -> data -> id ) ; _TRY_CONSUME ( ctx , return ERROR_CODE ( int ) , 1 ) ; } else _RAISE ( ctx , return ERROR_CODE ( int ) , "syntax<S2SV_blank>error:<S2SV_blank>identifer<S2SV_blank>exepcted" ) ; } else rc = _parse_subscript ( ctx , dimensions , sizeof ( dimensions ) / sizeof ( uint32_t ) ) ; if ( rc == ERROR_CODE ( int ) ) return ERROR_CODE ( int ) ; if ( ERROR_CODE ( int ) == proto_type_append_atomic ( type , namebuf , elem_size , ( ( rc == 0 ) ? NULL : dimensions ) , & metadata ) ) _LIB_PROTO_ERROR ( ctx , return ERROR_CODE ( int ) ) ; return 0 ; } | <S2SV_ModStart> ival &= ( elem_size < 8 ? ( <S2SV_ModStart> ) - 1 ) : - 1ll |
6,341 | CWE-000 value_t fcnCursorReset ( value_t * args , value_t * thisVal , environment_t * env ) { object_t * oval = js_addr ( * thisVal ) ; DbCursor * dbCursor ; Handle * idxHndl ; DbHandle * hndl ; JsMvcc * jsMvcc ; uint64_t bits ; DbAddr next ; value_t s ; s . bits = vt_status ; hndl = ( DbHandle * ) oval -> base -> hndl ; if ( ! ( idxHndl = bindHandle ( hndl ) ) ) return s . status = DB_ERROR_handleclosed , s ; dbCursor = ( DbCursor * ) ( idxHndl + 1 ) ; jsMvcc = ( JsMvcc * ) ( dbCursor + 1 ) ; bits = jsMvcc -> deDup -> bits ; while ( ( next . bits = bits ) ) { DbMmbr * mmbr = getObj ( idxHndl -> map -> parent , next ) ; bits = mmbr -> next . bits ; freeBlk ( idxHndl -> map -> parent , next ) ; } jsMvcc -> deDup -> bits = 0 ; jsMvcc -> txnId . bits = * env -> txnBits ; <S2SV_StartBug> if ( cc -> isolation == SnapShot ) <S2SV_EndBug> <S2SV_StartBug> jsMvcc -> ts = getSnapshotTimestamp ( jsMvcc -> txnId , false ) ; <S2SV_EndBug> s . status = dbLeftKey ( dbCursor , idxHndl -> map ) ; return s ; } | <S2SV_ModStart> -> txnBits ; <S2SV_ModEnd> getSnapshotTimestamp ( jsMvcc <S2SV_ModStart> getSnapshotTimestamp ( jsMvcc <S2SV_ModEnd> , false ) |
6,342 | CWE-000 static void aq_nic_cfg_init_defaults ( struct aq_nic_s * self ) { struct aq_nic_cfg_s * cfg = & self -> aq_nic_cfg ; cfg -> aq_hw_caps = & self -> aq_hw_caps ; cfg -> vecs = AQ_CFG_VECS_DEF ; cfg -> tcs = AQ_CFG_TCS_DEF ; cfg -> rxds = AQ_CFG_RXDS_DEF ; cfg -> txds = AQ_CFG_TXDS_DEF ; cfg -> is_polling = AQ_CFG_IS_POLLING_DEF ; <S2SV_StartBug> cfg -> is_interrupt_moderation = AQ_CFG_IS_INTERRUPT_MODERATION_DEF ; <S2SV_EndBug> <S2SV_StartBug> cfg -> itr = cfg -> is_interrupt_moderation ? <S2SV_EndBug> AQ_CFG_INTERRUPT_MODERATION_RATE_DEF : 0U ; cfg -> is_rss = AQ_CFG_IS_RSS_DEF ; cfg -> num_rss_queues = AQ_CFG_NUM_RSS_QUEUES_DEF ; cfg -> aq_rss . base_cpu_number = AQ_CFG_RSS_BASE_CPU_NUM_DEF ; cfg -> flow_control = AQ_CFG_FC_MODE ; cfg -> mtu = AQ_CFG_MTU_DEF ; cfg -> link_speed_msk = AQ_CFG_SPEED_MSK ; cfg -> is_autoneg = AQ_CFG_IS_AUTONEG_DEF ; cfg -> is_lro = AQ_CFG_IS_LRO_DEF ; cfg -> vlan_id = 0U ; aq_nic_rss_init ( self , cfg -> num_rss_queues ) ; } | <S2SV_ModStart> ; cfg -> itr = aq_itr <S2SV_ModEnd> ; cfg -> <S2SV_ModStart> ; cfg -> tx_itr = aq_itr_tx ; cfg -> rx_itr = aq_itr_rx <S2SV_ModEnd> ; cfg -> |
6,343 | CWE-000 void GPU_texture_free ( const GLuint texID ) { GPUTexture * tex = & textures [ texID ] ; tex -> refcount -- ; if ( tex -> refcount < 0 ) printf ( "GPUTexture:<S2SV_blank>negative<S2SV_blank>refcount\\n" ) ; if ( tex -> refcount == 0 ) { GPU_framebuffer_texture_detach_all ( texID ) ; <S2SV_StartBug> glDeleteTextures ( 1 , & tex -> bindcode ) ; <S2SV_EndBug> gpu_texture_memory_footprint_remove ( texID ) ; } } | <S2SV_ModStart> texID ) ; <S2SV_ModEnd> gpu_texture_memory_footprint_remove ( texID |
6,344 | CWE-000 int Itclng_CreateClassDestructorCmd ( ClientData clientData , Tcl_Interp * interp , int objc , Tcl_Obj * const * objv ) { Tcl_HashEntry * hPtr ; ItclngObjectInfo * infoPtr ; ItclngClass * iclsPtr ; ItclngMemberFunc * imPtr ; <S2SV_StartBug> ItclngShowArgs ( 0 , "Itclng_CreateClassDestructorCmd" , objc , objv ) ; <S2SV_EndBug> if ( ItclngCheckNumCmdParams ( interp , infoPtr , "createClassDestructor" , objc , 2 , 2 ) != TCL_OK ) { return TCL_ERROR ; } infoPtr = ( ItclngObjectInfo * ) clientData ; hPtr = Tcl_FindHashEntry ( & infoPtr -> classes , ( char * ) objv [ 1 ] ) ; if ( hPtr == NULL ) { Tcl_AppendResult ( interp , "no<S2SV_blank>such<S2SV_blank>class<S2SV_blank>\\"" , Tcl_GetString ( objv [ 1 ] ) , "\\"" , NULL ) ; return TCL_ERROR ; } iclsPtr = Tcl_GetHashValue ( hPtr ) ; if ( ItclngCreateMethodOrProc ( interp , iclsPtr , objv [ 2 ] , 0 , & imPtr ) != TCL_OK ) { return TCL_ERROR ; } imPtr -> flags &= ITCLNG_DESTRUCTOR ; return TCL_OK ; } | <S2SV_ModStart> ; ItclngShowArgs ( 1 <S2SV_ModEnd> , "Itclng_CreateClassDestructorCmd" , |
6,345 | CWE-000 void test_cleanup_register ( test_cleanup_func func ) { <S2SV_StartBug> struct cleanup_func * cleanup , * * last ; <S2SV_EndBug> cleanup = bmalloc ( sizeof ( struct cleanup_func ) ) ; cleanup -> func = func ; cleanup -> next = NULL ; last = & cleanup_funcs ; while ( * last != NULL ) last = & ( * last ) -> next ; * last = cleanup ; } | <S2SV_ModStart> func ) { register_cleanup ( func , NULL , NULL ) <S2SV_ModEnd> ; } <S2SV_null> |
6,346 | CWE-000 static void intel_tv_pre_enable ( struct intel_encoder * encoder , struct intel_crtc_state * pipe_config , struct drm_connector_state * conn_state ) { struct drm_i915_private * dev_priv = to_i915 ( encoder -> base . dev ) ; struct intel_crtc * intel_crtc = to_intel_crtc ( encoder -> base . crtc ) ; struct intel_tv * intel_tv = enc_to_tv ( encoder ) ; <S2SV_StartBug> const struct tv_mode * tv_mode = intel_tv_mode_find ( intel_tv ) ; <S2SV_EndBug> u32 tv_ctl ; u32 scctl1 , scctl2 , scctl3 ; int i , j ; const struct video_levels * video_levels ; const struct color_conversion * color_conversion ; bool burst_ena ; int xpos = 0x0 , ypos = 0x0 ; unsigned int xsize , ysize ; if ( ! tv_mode ) return ; tv_ctl = I915_READ ( TV_CTL ) ; tv_ctl &= TV_CTL_SAVE ; switch ( intel_tv -> type ) { default : case DRM_MODE_CONNECTOR_Unknown : case DRM_MODE_CONNECTOR_Composite : tv_ctl |= TV_ENC_OUTPUT_COMPOSITE ; video_levels = tv_mode -> composite_levels ; color_conversion = tv_mode -> composite_color ; burst_ena = tv_mode -> burst_ena ; break ; case DRM_MODE_CONNECTOR_Component : tv_ctl |= TV_ENC_OUTPUT_COMPONENT ; video_levels = & component_levels ; if ( tv_mode -> burst_ena ) color_conversion = & sdtv_csc_yprpb ; else color_conversion = & hdtv_csc_yprpb ; burst_ena = false ; break ; case DRM_MODE_CONNECTOR_SVIDEO : tv_ctl |= TV_ENC_OUTPUT_SVIDEO ; video_levels = tv_mode -> svideo_levels ; color_conversion = tv_mode -> svideo_color ; burst_ena = tv_mode -> burst_ena ; break ; } if ( intel_crtc -> pipe == 1 ) tv_ctl |= TV_ENC_PIPEB_SELECT ; tv_ctl |= tv_mode -> oversample ; if ( tv_mode -> progressive ) tv_ctl |= TV_PROGRESSIVE ; if ( tv_mode -> trilevel_sync ) tv_ctl |= TV_TRILEVEL_SYNC ; if ( tv_mode -> pal_burst ) tv_ctl |= TV_PAL_BURST ; scctl1 = 0 ; if ( tv_mode -> dda1_inc ) scctl1 |= TV_SC_DDA1_EN ; if ( tv_mode -> dda2_inc ) scctl1 |= TV_SC_DDA2_EN ; if ( tv_mode -> dda3_inc ) scctl1 |= TV_SC_DDA3_EN ; scctl1 |= tv_mode -> sc_reset ; if ( video_levels ) scctl1 |= video_levels -> burst << TV_BURST_LEVEL_SHIFT ; scctl1 |= tv_mode -> dda1_inc << TV_SCDDA1_INC_SHIFT ; scctl2 = tv_mode -> dda2_size << TV_SCDDA2_SIZE_SHIFT | tv_mode -> dda2_inc << TV_SCDDA2_INC_SHIFT ; scctl3 = tv_mode -> dda3_size << TV_SCDDA3_SIZE_SHIFT | tv_mode -> dda3_inc << TV_SCDDA3_INC_SHIFT ; if ( IS_I915GM ( dev_priv ) ) tv_ctl |= TV_ENC_C0_FIX | TV_ENC_SDP_FIX ; set_tv_mode_timings ( dev_priv , tv_mode , burst_ena ) ; I915_WRITE ( TV_SC_CTL_1 , scctl1 ) ; I915_WRITE ( TV_SC_CTL_2 , scctl2 ) ; I915_WRITE ( TV_SC_CTL_3 , scctl3 ) ; set_color_conversion ( dev_priv , color_conversion ) ; if ( INTEL_GEN ( dev_priv ) >= 4 ) I915_WRITE ( TV_CLR_KNOBS , 0x00404000 ) ; else I915_WRITE ( TV_CLR_KNOBS , 0x00606000 ) ; if ( video_levels ) I915_WRITE ( TV_CLR_LEVEL , ( ( video_levels -> black << TV_BLACK_LEVEL_SHIFT ) | ( video_levels -> blank << TV_BLANK_LEVEL_SHIFT ) ) ) ; assert_pipe_disabled ( dev_priv , intel_crtc -> pipe ) ; I915_WRITE ( TV_FILTER_CTL_1 , TV_AUTO_SCALE ) ; xsize = tv_mode -> hblank_start - tv_mode -> hblank_end ; if ( tv_mode -> progressive ) ysize = tv_mode -> nbr_end + 1 ; else ysize = 2 * tv_mode -> nbr_end + 1 ; <S2SV_StartBug> xpos += intel_tv -> margin [ TV_MARGIN_LEFT ] ; <S2SV_EndBug> <S2SV_StartBug> ypos += intel_tv -> margin [ TV_MARGIN_TOP ] ; <S2SV_EndBug> <S2SV_StartBug> xsize -= ( intel_tv -> margin [ TV_MARGIN_LEFT ] + <S2SV_EndBug> intel_tv -> margin [ TV_MARGIN_RIGHT ] ) ; <S2SV_StartBug> ysize -= ( intel_tv -> margin [ TV_MARGIN_TOP ] + <S2SV_EndBug> intel_tv -> margin [ TV_MARGIN_BOTTOM ] ) ; I915_WRITE ( TV_WIN_POS , ( xpos << 16 ) | ypos ) ; I915_WRITE ( TV_WIN_SIZE , ( xsize << 16 ) | ysize ) ; j = 0 ; for ( i = 0 ; i < 60 ; i ++ ) I915_WRITE ( TV_H_LUMA ( i ) , tv_mode -> filter_table [ j ++ ] ) ; for ( i = 0 ; i < 60 ; i ++ ) I915_WRITE ( TV_H_CHROMA ( i ) , tv_mode -> filter_table [ j ++ ] ) ; for ( i = 0 ; i < 43 ; i ++ ) I915_WRITE ( TV_V_LUMA ( i ) , tv_mode -> filter_table [ j ++ ] ) ; for ( i = 0 ; i < 43 ; i ++ ) I915_WRITE ( TV_V_CHROMA ( i ) , tv_mode -> filter_table [ j ++ ] ) ; I915_WRITE ( TV_DAC , I915_READ ( TV_DAC ) & TV_DAC_SAVE ) ; I915_WRITE ( TV_CTL , tv_ctl ) ; } | <S2SV_ModStart> = intel_tv_mode_find ( conn_state <S2SV_ModEnd> ) ; u32 <S2SV_ModStart> ; xpos += conn_state -> tv . margins . left <S2SV_ModEnd> ; ypos += <S2SV_ModStart> ; ypos += conn_state -> tv . margins . top <S2SV_ModEnd> ; xsize -= <S2SV_ModStart> xsize -= ( conn_state -> tv . margins . left + conn_state -> tv . margins . right <S2SV_ModEnd> ) ; ysize <S2SV_ModStart> ysize -= ( conn_state -> tv . margins . top + conn_state -> tv . margins . bottom <S2SV_ModEnd> ) ; I915_WRITE |
6,347 | CWE-000 static int marvell_nfc_init ( struct marvell_nfc * nfc ) { struct device_node * np = nfc -> dev -> of_node ; if ( nfc -> caps -> need_system_controller ) { struct regmap * sysctrl_base = syscon_regmap_lookup_by_phandle ( np , "marvell,system-controller" ) ; u32 reg ; if ( IS_ERR ( sysctrl_base ) ) return PTR_ERR ( sysctrl_base ) ; reg = GENCONF_SOC_DEVICE_MUX_NFC_EN | GENCONF_SOC_DEVICE_MUX_ECC_CLK_RST | GENCONF_SOC_DEVICE_MUX_ECC_CORE_RST | GENCONF_SOC_DEVICE_MUX_NFC_INT_EN ; regmap_write ( sysctrl_base , GENCONF_SOC_DEVICE_MUX , reg ) ; regmap_read ( sysctrl_base , GENCONF_CLK_GATING_CTRL , & reg ) ; reg |= GENCONF_CLK_GATING_CTRL_ND_GATE ; regmap_write ( sysctrl_base , GENCONF_CLK_GATING_CTRL , reg ) ; regmap_read ( sysctrl_base , GENCONF_ND_CLK_CTRL , & reg ) ; reg |= GENCONF_ND_CLK_CTRL_EN ; regmap_write ( sysctrl_base , GENCONF_ND_CLK_CTRL , reg ) ; } if ( ! nfc -> caps -> is_nfcv2 ) marvell_nfc_init_dma ( nfc ) ; <S2SV_StartBug> writel_relaxed ( NDCR_ALL_INT | NDCR_ND_ARB_EN | NDCR_SPARE_EN | <S2SV_EndBug> NDCR_RD_ID_CNT ( NFCV1_READID_LEN ) , nfc -> regs + NDCR ) ; writel_relaxed ( 0xFFFFFFFF , nfc -> regs + NDSR ) ; writel_relaxed ( 0 , nfc -> regs + NDECCCTRL ) ; return 0 ; } | <S2SV_ModStart> nfc ) ; marvell_nfc_reset ( nfc <S2SV_ModEnd> ) ; return |
6,348 | CWE-000 static char * sh_tilde ( Shell_t * shp , const char * string ) { char * cp ; int c ; struct passwd * pw ; Namval_t * np = 0 ; static Dt_t * logins_tree ; if ( * string ++ != '~' ) return NULL ; if ( ( c = * string ) == 0 ) { if ( ! ( cp = nv_getval ( sh_scoped ( shp , HOME ) ) ) ) cp = getlogin ( ) ; return cp ; } if ( ( c == '-' || c == '+' ) && string [ 1 ] == 0 ) { if ( c == '+' ) { cp = nv_getval ( sh_scoped ( shp , PWDNOD ) ) ; } else { cp = nv_getval ( sh_scoped ( shp , OLDPWDNOD ) ) ; } return cp ; } if ( c == '{' ) { char * s2 ; size_t len ; int fd , offset = stktell ( shp -> stk ) ; Spawnvex_t * vc = ( Spawnvex_t * ) shp -> vex ; if ( ! vc && ( vc = spawnvex_open ( 0 ) ) ) shp -> vex = ( void * ) vc ; if ( ! ( s2 = strchr ( string ++ , '}' ) ) ) return NULL ; len = s2 - string ; sfwrite ( shp -> stk , string , len + 1 ) ; s2 = stkptr ( shp -> stk , offset ) ; s2 [ len ] = 0 ; stkseek ( shp -> stk , offset ) ; if ( isdigit ( * s2 ) ) { fd = strtol ( s2 , & s2 , 10 ) ; if ( * s2 ) return NULL ; } else { Namval_t * np = nv_open ( s2 , shp -> var_tree , NV_VARNAME | NV_NOFAIL | NV_NOADD ) ; if ( ! np ) return NULL ; fd = ( int ) nv_getnum ( np ) ; nv_close ( np ) ; } if ( fd < 0 ) return NULL ; # ifdef _fd_pid_dir_fmt sfprintf ( shp -> stk , _fd_pid_dir_fmt , ( long ) getpid ( ) , fd , "" , "" ) ; # else # ifdef _fd_self_dir_fmt sfprintf ( shp -> stk , _fd_self_dir_fmt , fd , "" , "" ) ; # else sfprintf ( shp -> stk , "/dev/fd/%d" , fd ) ; # endif # endif if ( vc ) spawnvex_add ( vc , fd , fd , 0 , 0 ) ; return stkfreeze ( shp -> stk , 1 ) ; } # if _WINIX if ( fcgetc ( c ) == '/' ) { char * str ; int n = 0 , offset = stktell ( shp -> stk ) ; sfputr ( shp -> stk , string , - 1 ) ; do { sfputc ( shp -> stk , c ) ; n ++ ; } while ( fcgetc ( c ) && c != '/' ) ; sfputc ( shp -> stk , 0 ) ; if ( c ) fcseek ( - 1 ) ; str = stkseek ( shp -> stk , offset ) ; Skip = n ; if ( logins_tree && ( np = nv_search ( str , logins_tree , 0 ) ) ) return nv_getval ( np ) ; if ( pw = getpwnam ( str ) ) { string = str ; goto skip ; } Skip = 0 ; } # endif if ( logins_tree && ( np = nv_search ( string , logins_tree , 0 ) ) ) return nv_getval ( np ) ; if ( ! ( pw = getpwnam ( string ) ) ) return NULL ; # if _WINIX skip : # endif if ( ! logins_tree ) { logins_tree = dtopen ( & _Nvdisc , Dtbag ) ; dtuserdata ( logins_tree , shp , 1 ) ; } <S2SV_StartBug> if ( np = nv_search ( string , logins_tree , NV_ADD ) ) { <S2SV_EndBug> c = shp -> subshell ; shp -> subshell = 0 ; nv_putval ( np , pw -> pw_dir , 0 ) ; shp -> subshell = c ; } return pw -> pw_dir ; } | <S2SV_ModStart> ) ; } <S2SV_ModEnd> np = nv_search <S2SV_ModStart> , NV_ADD ) ; if ( np |
6,349 | CWE-000 static int component_register ( void ) { ompi_osc_pt2pt_no_locks = false ; ( void ) mca_base_component_var_register ( & mca_osc_pt2pt_component . super . osc_version , "no_locks" , "Enable<S2SV_blank>optimizations<S2SV_blank>available<S2SV_blank>only<S2SV_blank>if<S2SV_blank>MPI_LOCK<S2SV_blank>is<S2SV_blank>" "not<S2SV_blank>used.<S2SV_blank><S2SV_blank>" "Info<S2SV_blank>key<S2SV_blank>of<S2SV_blank>same<S2SV_blank>name<S2SV_blank>overrides<S2SV_blank>this<S2SV_blank>value." , MCA_BASE_VAR_TYPE_BOOL , NULL , 0 , 0 , OPAL_INFO_LVL_9 , MCA_BASE_VAR_SCOPE_READONLY , & ompi_osc_pt2pt_no_locks ) ; mca_osc_pt2pt_component . buffer_size = 8192 ; ( void ) mca_base_component_var_register ( & mca_osc_pt2pt_component . super . osc_version , "buffer_size" , "Data<S2SV_blank>transfers<S2SV_blank>smaller<S2SV_blank>than<S2SV_blank>this<S2SV_blank>limit<S2SV_blank>may<S2SV_blank>be<S2SV_blank>coalesced<S2SV_blank>before<S2SV_blank>" "being<S2SV_blank>transferred<S2SV_blank>(default:<S2SV_blank>8k)" , MCA_BASE_VAR_TYPE_UNSIGNED_INT , NULL , 0 , 0 , OPAL_INFO_LVL_9 , MCA_BASE_VAR_SCOPE_READONLY , & mca_osc_pt2pt_component . buffer_size ) ; <S2SV_StartBug> return OMPI_SUCCESS ; <S2SV_EndBug> } | <S2SV_ModStart> buffer_size ) ; mca_osc_pt2pt_component . receive_count = 4 ; ( void ) mca_base_component_var_register ( & mca_osc_pt2pt_component . super . osc_version , "receive_count" , "Number<S2SV_blank>of<S2SV_blank>receives<S2SV_blank>to<S2SV_blank>post<S2SV_blank>for<S2SV_blank>each<S2SV_blank>window<S2SV_blank>for<S2SV_blank>incoming<S2SV_blank>fragments<S2SV_blank>" "(default:<S2SV_blank>4)" , MCA_BASE_VAR_TYPE_INT , NULL , 0 , 0 , OPAL_INFO_LVL_4 , MCA_BASE_VAR_SCOPE_READONLY , & mca_osc_pt2pt_component . receive_count ) ; |
6,350 | CWE-000 void parse_wps_settings ( const u_char * packet , struct pcap_pkthdr * header , char * target , int passive , int mode , int source ) { struct radio_tap_header * rt_header = NULL ; struct dot11_frame_header * frame_header = NULL ; struct libwps_data * wps = NULL ; enum encryption_type encryption = NONE ; char * bssid = NULL , * ssid = NULL , * lock_display = NULL ; int wps_parsed = 0 , probe_sent = 0 , channel = 0 , rssi = 0 ; static int channel_changed = 0 ; wps = malloc ( sizeof ( struct libwps_data ) ) ; memset ( wps , 0 , sizeof ( struct libwps_data ) ) ; if ( packet == NULL || header == NULL || header -> len < MIN_BEACON_SIZE ) { goto end ; } rt_header = ( struct radio_tap_header * ) radio_header ( packet , header -> len ) ; frame_header = ( struct dot11_frame_header * ) ( packet + rt_header -> len ) ; if ( ! is_target ( frame_header ) ) { goto end ; } set_ssid ( NULL ) ; bssid = ( char * ) mac2str ( frame_header -> addr3 , ':' ) ; <S2SV_StartBug> if ( bssid ) <S2SV_EndBug> { if ( ( target == NULL ) || ( target != NULL && strcmp ( bssid , target ) == 0 ) ) { channel = parse_beacon_tags ( packet , header -> len ) ; rssi = signal_strength ( packet , header -> len ) ; ssid = ( char * ) get_ssid ( ) ; if ( target != NULL && channel_changed == 0 ) { ualarm ( 0 , 0 ) ; change_channel ( channel ) ; channel_changed = 1 ; } if ( frame_header -> fc . sub_type == PROBE_RESPONSE || frame_header -> fc . sub_type == SUBTYPE_BEACON ) { wps_parsed = parse_wps_parameters ( packet , header -> len , wps ) ; } if ( ! is_done ( bssid ) && ( get_channel ( ) == channel || source == PCAP_FILE ) ) { if ( frame_header -> fc . sub_type == SUBTYPE_BEACON && mode == SCAN && ! passive && should_probe ( bssid ) ) { send_probe_request ( get_bssid ( ) , get_ssid ( ) ) ; probe_sent = 1 ; } if ( ! insert ( bssid , ssid , wps , encryption , rssi ) ) { update ( bssid , ssid , wps , encryption ) ; } else if ( wps -> version > 0 ) { switch ( wps -> locked ) { case WPSLOCKED : lock_display = YES ; break ; case UNLOCKED : case UNSPECIFIED : lock_display = NO ; break ; } cprintf ( INFO , "%17s<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%2d<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%.2d<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%d.%d<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%s<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%s\\n" , bssid , channel , rssi , ( wps -> version >> 4 ) , ( wps -> version & 0x0F ) , lock_display , ssid ) ; } if ( probe_sent ) { update_probe_count ( bssid ) ; } if ( ! wps_parsed || frame_header -> fc . sub_type == PROBE_RESPONSE ) { mark_ap_complete ( bssid ) ; } } } if ( channel == get_channel ( ) ) { update_ap_power ( bssid , rssi ) ; } free ( bssid ) ; bssid = NULL ; } end : if ( wps ) free ( wps ) ; <S2SV_StartBug> return ; <S2SV_EndBug> } | <S2SV_ModStart> ':' ) ; set_bssid ( ( unsigned char * ) frame_header -> addr3 ) ; <S2SV_ModStart> wps ) ; set_bssid ( ( unsigned char * ) NULL_MAC ) ; |
6,351 | CWE-000 int main ( int argc , char * argv [ ] ) { wiringPiSetup ( ) ; Setup ( ) ; mosquitto_lib_init ( ) ; mosquitto_connect ( mosq , host , port , 60 ) ; printf ( "connessione<S2SV_blank>avvenuta" ) ; mosq = mosquitto_new ( NULL , true , NULL ) ; mosquitto_connect_callback_set ( mosq , connect_callback ) ; mosquitto_message_callback_set ( mosq , message_callback ) ; <S2SV_StartBug> mosquitto_subscribe ( mosq , NULL , GEAR , 0 ) ; <S2SV_EndBug> mosquitto_subscribe ( mosq , NULL , rpm , 0 ) ; mosquitto_subscribe ( mosq , NULL , VhSpeed , 0 ) ; while ( 1 ) { if ( acceleration == 1 ) { aggiorna0_100time = true ; if ( Rpm >= sogliaRpmDW && ( bool ) digitalRead ( SH_LT ) == 1 ) { uint16_t sh_time = ( uint32_t ) millis ( ) - accStartTime ; frame751 . data [ 0 ] = sogliaRpmUP >> 8 ; frame751 . data [ 1 ] = sogliaRpmUP ; frame751 . id = 751 ; frame751 . time = ( uint32_t ) millis ( ) ; send_Frame ( frame751 ) ; if ( Speed == 0 ) { accStartTime = ( uint32_t ) millis ( ) ; } if ( Speed > 100 && aggiorna0_100time ) { accTime = ( uint32_t ) millis ( ) - accStartTime ; frame751 . data [ 4 ] = accTime >> 8 ; frame751 . data [ 5 ] = accTime ; frame751 . id = 751 ; frame751 . time = ( uint32_t ) millis ( ) ; send_Frame ( frame751 ) ; aggiorna0_100time = false ; } <S2SV_StartBug> if ( ( bool ) digitalRead ( SH_LT ) == 1 && gear != 0 && gear != 6 ) { <S2SV_EndBug> gearUP ( sh_time ) ; } } } } <S2SV_StartBug> mosquitto_lib_cleanup ( ) ; <S2SV_EndBug> } | <S2SV_ModStart> message_callback ) ; <S2SV_ModEnd> while ( 1 <S2SV_ModStart> != 6 ) <S2SV_ModEnd> gearUP ( sh_time <S2SV_ModStart> } } } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
6,352 | CWE-000 static int lfs_init ( lfs_t * lfs , const struct lfs_config * cfg ) { lfs -> cfg = cfg ; if ( lfs -> cfg -> read_buffer ) { lfs -> rcache . buffer = lfs -> cfg -> read_buffer ; } else { lfs -> rcache . buffer = lfs_malloc ( lfs -> cfg -> read_size ) ; if ( ! lfs -> rcache . buffer ) { <S2SV_StartBug> return LFS_ERR_NOMEM ; <S2SV_EndBug> } } if ( lfs -> cfg -> prog_buffer ) { lfs -> pcache . buffer = lfs -> cfg -> prog_buffer ; } else { lfs -> pcache . buffer = lfs_malloc ( lfs -> cfg -> prog_size ) ; if ( ! lfs -> pcache . buffer ) { <S2SV_StartBug> return LFS_ERR_NOMEM ; <S2SV_EndBug> } } lfs_cache_zero ( lfs , & lfs -> rcache ) ; lfs_cache_zero ( lfs , & lfs -> pcache ) ; LFS_ASSERT ( lfs -> cfg -> lookahead % 32 == 0 ) ; LFS_ASSERT ( lfs -> cfg -> lookahead > 0 ) ; if ( lfs -> cfg -> lookahead_buffer ) { lfs -> free . buffer = lfs -> cfg -> lookahead_buffer ; } else { lfs -> free . buffer = lfs_malloc ( lfs -> cfg -> lookahead / 8 ) ; if ( ! lfs -> free . buffer ) { <S2SV_StartBug> return LFS_ERR_NOMEM ; <S2SV_EndBug> } } LFS_ASSERT ( lfs -> cfg -> prog_size % lfs -> cfg -> read_size == 0 ) ; LFS_ASSERT ( lfs -> cfg -> block_size % lfs -> cfg -> prog_size == 0 ) ; LFS_ASSERT ( 4 * lfs_npw2 ( 0xffffffff / ( lfs -> cfg -> block_size - 2 * 4 ) ) <= lfs -> cfg -> block_size ) ; lfs -> root [ 0 ] = 0xffffffff ; lfs -> root [ 1 ] = 0xffffffff ; lfs -> files = NULL ; lfs -> dirs = NULL ; lfs -> deorphaned = false ; return 0 ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> buffer ) { goto cleanup <S2SV_ModEnd> ; } } <S2SV_ModStart> buffer ) { goto cleanup <S2SV_ModEnd> ; } } <S2SV_ModStart> buffer ) { goto cleanup <S2SV_ModEnd> ; } } <S2SV_ModStart> return 0 ; cleanup : lfs_deinit ( lfs ) ; return LFS_ERR_NOMEM ; |
6,353 | CWE-000 void renderPoly ( polygon_t * poly , colour_t * colour , frame_t * frame ) { co_ord_t coords [ poly -> no_verts ] ; <S2SV_StartBug> for ( int i = 0 ; i < poly -> no_verts ; i ++ ) { <S2SV_EndBug> <S2SV_StartBug> coords [ i ] . x = F * poly -> verts [ 0 ] [ i ] / poly -> verts [ 2 ] [ i ] ; <S2SV_EndBug> <S2SV_StartBug> coords [ i ] . y = F * poly -> verts [ 1 ] [ i ] / poly -> verts [ 2 ] [ i ] ; <S2SV_EndBug> } for ( int i = 0 ; i < poly -> no_verts ; i ++ ) { for ( int j = ( i + 1 ) ; j < poly -> no_verts ; j ++ ) { if ( poly -> adj [ i ] [ j ] ) { drawLine ( & coords [ i ] , & coords [ j ] , colour , frame ) ; } } } } | <S2SV_ModStart> no_verts ] ; int midx = frame -> width / 2 ; int midy = frame -> height / 2 ; <S2SV_ModStart> . x = midx + ( <S2SV_ModStart> [ i ] ) <S2SV_ModStart> . y = midy + ( <S2SV_ModStart> [ i ] ) |
6,354 | CWE-000 static void saveopDirect ( cstrCtx h , int op ) { if ( h -> numBlends > 0 ) flushBlends ( h ) ; else if ( h -> stack . cnt != 0 ) { int i ; for ( i = 0 ; i < h -> stack . cnt ; i ++ ) { cstr_savenum ( h , h -> stack . array [ i ] ) ; } h -> stack . cnt = 0 ; } <S2SV_StartBug> cstr_saveop ( h , op ) ; <S2SV_EndBug> h -> pendop = tx_noop ; } | <S2SV_ModStart> 0 ; } h -> flushed_cnt = 0 ; |
6,355 | CWE-000 int f ( unsigned short usVlanID ) { <S2SV_StartBug> unsigned int uiVlanID = 0xffffffff ; <S2SV_EndBug> int i ; if ( ( unsigned short ) 0xffff != usVlanID ) uiVlanID = ( unsigned int ) usVlanID ; return uiVlanID ; } | <S2SV_ModStart> uiVlanID = 0xffffffff <S2SV_ModEnd> ; if ( |
6,356 | CWE-000 static M_CODE lm_worker_perform ( worker_t * w ) { M_CODE r ; int x ; filetype_t * ft = w -> m -> filetypes [ w -> ue_h -> current -> bind - 1 ] ; if ( lm_crawler_flag_isset ( w -> crawler , LM_CRFLAG_JAIL ) ) { url_t * url = w -> ue_h -> current ; url_t * jail_url = & w -> crawler -> jail_url ; if ( url -> file_o - url -> host_o - url -> host_l < jail_url -> file_o - jail_url -> host_o - jail_url -> host_l || strncasecmp ( jail_url -> str + jail_url -> host_o + jail_url -> host_l , url -> str + url -> host_o + url -> host_l , jail_url -> file_o - jail_url -> host_o - jail_url -> host_l ) != 0 ) { return M_OK ; } } if ( lm_filter_eval_url ( & w -> ue_h -> host_ent -> filter , w -> ue_h -> current ) != LM_FILTER_ALLOW ) return M_OK ; # ifdef DEBUG fprintf ( stderr , "*<S2SV_blank>worker:(%p)<S2SV_blank>URL:<S2SV_blank>%s\\n" , w , w -> ue_h -> current -> str ) ; # endif if ( ft -> switch_to . ptr ) lm_worker_set_crawler ( w , ft -> switch_to . ptr ) ; w -> io_h -> timer_wait = ( clock_t ) ( w -> crawler -> wait * ( float ) CLOCKS_PER_SEC ) ; w -> io_h -> timer_wait_mp = 0 ; lm_attrlist_prepare ( & w -> attributes , ( const char * * ) ft -> attributes , ft -> attr_count ) ; wfunction_t * wf = ( ft -> handler . wf ? ft -> handler . wf : ( w -> crawler -> default_handler . wf ? w -> crawler -> default_handler . wf : 0 ) ) ; if ( wf ) { # ifdef DEBUG fprintf ( stderr , "*<S2SV_blank>worker:(%p)<S2SV_blank>calling<S2SV_blank>handler<S2SV_blank>\'%s\'\\n" , w , wf -> name ) ; # endif switch ( wf -> type ) { case LM_WFUNCTION_TYPE_NATIVE : r = wf -> fn . native_handler ( w , w -> io_h , w -> ue_h -> current ) ; break ; default : return M_ERROR ; } } else r = lm_io_get ( w -> io_h , w -> ue_h -> current ) ; if ( r != M_OK ) { # ifdef DEBUG fprintf ( stderr , "*<S2SV_blank>worker:(%p)<S2SV_blank>handler<S2SV_blank>or<S2SV_blank>lm_io_get<S2SV_blank>failed:<S2SV_blank>%s<S2SV_blank>(%d)\\n" , w , lm_strerror ( r ) , r ) ; # endif return r ; } w -> m -> status_cb ( w -> m , w , w -> ue_h -> current , & w -> io_h -> transfer ) ; if ( w -> io_h -> transfer . status_code >= 300 && w -> io_h -> transfer . status_code < 400 ) { if ( w -> io_h -> transfer . headers . location ) { # ifdef DEBUG fprintf ( stderr , "*<S2SV_blank>worker:(%p)<S2SV_blank>%d<S2SV_blank>redirect<S2SV_blank>to<S2SV_blank>\'%s\'\\n" , w , w -> io_h -> transfer . status_code , w -> io_h -> transfer . headers . location ) ; # endif w -> redirects ++ ; if ( w -> redirects >= 20 ) { LM_WARNING ( w -> m , "breaking<S2SV_blank>out<S2SV_blank>of<S2SV_blank>possible<S2SV_blank>redirect<S2SV_blank>loop" ) ; w -> redirects = 0 ; return M_OK ; } url_t tmp ; lm_url_init ( & tmp ) ; if ( lm_url_set ( & tmp , w -> io_h -> transfer . headers . location , strlen ( w -> io_h -> transfer . headers . location ) ) == M_OK ) { <S2SV_StartBug> if ( lm_url_hostcmp ( & tmp , w -> ue_h -> current ) == 0 ) <S2SV_EndBug> ue_revert ( w -> ue_h , tmp . str , tmp . sz ) ; <S2SV_StartBug> else <S2SV_EndBug> <S2SV_StartBug> ue_move_to_secondary ( w -> ue_h , & tmp ) ; <S2SV_EndBug> } lm_url_uninit ( & tmp ) ; return M_OK ; } } w -> redirects = 0 ; int last = LM_WFUNCTION_TYPE_NATIVE ; for ( x = 0 ; x < ft -> parser_chain . num_parsers ; x ++ ) { wfunction_t * p = ft -> parser_chain . parsers [ x ] ; # ifdef DEBUG fprintf ( stderr , "*<S2SV_blank>worker:(%p)<S2SV_blank>parser<S2SV_blank>%d<S2SV_blank>of<S2SV_blank>%d:<S2SV_blank>\'%s\'\\n" , w , x + 1 , ft -> parser_chain . num_parsers , p -> name ) ; # endif switch ( p -> type ) { case LM_WFUNCTION_TYPE_NATIVE : p -> fn . native_parser ( w , & w -> io_h -> buf , w -> ue_h , w -> ue_h -> current , & w -> attributes ) ; break ; default : return M_FAILED ; } last = p -> type ; } if ( w -> attributes . changed ) w -> m -> target_cb ( w -> m , w , w -> ue_h -> current , & w -> attributes , ft ) ; return M_OK ; } | <S2SV_ModStart> == 0 ) { <S2SV_ModStart> sz ) ; } else { <S2SV_ModEnd> ue_move_to_secondary ( w <S2SV_ModStart> tmp ) ; } |
6,357 | CWE-000 bool process_record_keymap ( uint16_t keycode , keyrecord_t * record ) { switch ( keycode ) { case MO ( _LOWER ) : if ( game ) { if ( record -> event . pressed ) { register_code ( KC_SPC ) ; } else { unregister_code ( KC_SPC ) ; } return false ; } else { return true ; } <S2SV_StartBug> default : <S2SV_EndBug> return true ; } } | <S2SV_ModStart> true ; } case KC_LALT : if ( game ) { if ( record -> event . pressed ) { layer_on ( _RAISE ) ; } else { layer_off ( _RAISE ) ; } return false ; } else { return true ; } |
6,358 | CWE-000 static IUDEVICE * udev_init ( UDEVICE * pdev , UINT16 bus_number , UINT16 dev_number ) { int status , num ; LIBUSB_DEVICE_DESCRIPTOR * devDescriptor ; LIBUSB_CONFIG_DESCRIPTOR * config_temp ; LIBUSB_INTERFACE_DESCRIPTOR interface_temp ; status = udev_get_hub_handle ( pdev , bus_number , dev_number ) ; if ( status < 0 ) { WLog_ERR ( TAG , "USB<S2SV_blank>init:<S2SV_blank>Error<S2SV_blank>to<S2SV_blank>get<S2SV_blank>HUB<S2SV_blank>handle!!" ) ; pdev -> hub_handle = NULL ; } pdev -> devDescriptor = udev_new_descript ( pdev -> libusb_dev ) ; if ( ! pdev -> devDescriptor ) { WLog_ERR ( TAG , "USB<S2SV_blank>init:<S2SV_blank>Error<S2SV_blank>to<S2SV_blank>get<S2SV_blank>device<S2SV_blank>descriptor!!" ) ; zfree ( pdev ) ; return NULL ; } num = pdev -> devDescriptor -> bNumConfigurations ; status = libusb_get_active_config_descriptor ( pdev -> libusb_dev , & pdev -> LibusbConfig ) ; if ( status < 0 ) { WLog_ERR ( TAG , "libusb_get_descriptor:<S2SV_blank>ERROR!!ret:%d" , status ) ; zfree ( pdev ) ; return NULL ; } config_temp = pdev -> LibusbConfig ; interface_temp = config_temp -> interface [ 0 ] . altsetting [ 0 ] ; <S2SV_StartBug> WLog_DBG ( TAG , "Regist<S2SV_blank>Device:<S2SV_blank>Vid:<S2SV_blank>0x%04" PRIX16 "<S2SV_blank>Pid:<S2SV_blank>0x%04" PRIX16 "" <S2SV_EndBug> "<S2SV_blank>InterfaceClass<S2SV_blank>=<S2SV_blank>0x%02" PRIX8 "" , pdev -> devDescriptor -> idVendor , pdev -> devDescriptor -> idProduct , interface_temp . bInterfaceClass ) ; switch ( interface_temp . bInterfaceClass ) { case CLASS_RESERVE : case CLASS_MASS_STORAGE : case CLASS_HUB : case CLASS_SMART_CARD : case CLASS_CONTENT_SECURITY : WLog_ERR ( TAG , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Device<S2SV_blank>is<S2SV_blank>not<S2SV_blank>supported!!" ) ; zfree ( pdev ) ; return NULL ; default : break ; } devDescriptor = pdev -> devDescriptor ; if ( ( devDescriptor -> bNumConfigurations == 1 ) && ( config_temp -> bNumInterfaces > 1 ) && ( devDescriptor -> bDeviceClass == 0x0 ) ) { pdev -> isCompositeDevice = 1 ; } else if ( ( devDescriptor -> bDeviceClass == 0xef ) && ( devDescriptor -> bDeviceSubClass == 0x02 ) && ( devDescriptor -> bDeviceProtocol == 0x01 ) ) { pdev -> isCompositeDevice = 1 ; } else { pdev -> isCompositeDevice = 0 ; } devDescriptor -> bDeviceClass = interface_temp . bInterfaceClass ; devDescriptor -> bDeviceSubClass = interface_temp . bInterfaceSubClass ; devDescriptor -> bDeviceProtocol = interface_temp . bInterfaceProtocol ; pdev -> prev = NULL ; pdev -> next = NULL ; pdev -> bus_number = bus_number ; pdev -> dev_number = dev_number ; pdev -> status = 0 ; pdev -> ReqCompletion = 0 ; pdev -> channel_id = 0xffff ; pdev -> request_queue = request_queue_new ( ) ; pdev -> isoch_queue = NULL ; sem_init ( & pdev -> sem_id , 0 , 0 ) ; pdev -> MsConfig = msusb_msconfig_new ( ) ; pthread_mutex_init ( & pdev -> mutex_isoch , NULL ) ; udev_load_interface ( pdev ) ; return ( IUDEVICE * ) pdev ; } | <S2SV_ModStart> ( TAG , "Registered<S2SV_blank>Device:<S2SV_blank>Vid:<S2SV_blank>0x%04" <S2SV_ModEnd> PRIX16 "<S2SV_blank>Pid:<S2SV_blank>0x%04" PRIX16 |
6,359 | CWE-000 static LLVMValueRef cgen_resolution_wrapper ( ident_t name , vcode_type_t type ) { char * buf LOCAL = xasprintf ( "%s_resolution" , istr ( name ) ) ; LLVMValueRef fn = LLVMGetNamedFunction ( module , safe_symbol ( buf ) ) ; if ( fn != NULL ) return llvm_void_cast ( fn ) ; <S2SV_StartBug> LLVMTypeRef elem_type = cgen_type ( type ) ; <S2SV_EndBug> <S2SV_StartBug> LLVMTypeRef uarray_type = llvm_uarray_type ( elem_type , 1 ) ; <S2SV_EndBug> LLVMTypeRef args [ ] = { <S2SV_StartBug> LLVMPointerType ( elem_type , 0 ) , <S2SV_EndBug> LLVMInt32Type ( ) } ; fn = LLVMAddFunction ( module , buf , <S2SV_StartBug> LLVMFunctionType ( LLVMInt64Type ( ) , args , <S2SV_EndBug> ARRAY_LEN ( args ) , false ) ) ; LLVMBasicBlockRef saved_bb = LLVMGetInsertBlock ( builder ) ; LLVMBasicBlockRef entry_bb = LLVMAppendBasicBlock ( fn , "entry" ) ; LLVMPositionBuilderAtEnd ( builder , entry_bb ) ; const char * safe_name = safe_symbol ( istr ( name ) ) ; LLVMValueRef rfn = LLVMGetNamedFunction ( module , safe_name ) ; if ( rfn == NULL ) { <S2SV_StartBug> LLVMTypeRef args [ ] = { uarray_type } ; <S2SV_EndBug> rfn = LLVMAddFunction ( module , safe_name , <S2SV_StartBug> LLVMFunctionType ( elem_type , args , <S2SV_EndBug> ARRAY_LEN ( args ) , false ) ) ; } LLVMTypeRef field_types [ LLVMCountStructElementTypes ( uarray_type ) ] ; LLVMGetStructElementTypes ( uarray_type , field_types ) ; LLVMTypeRef dim_struct = LLVMGetElementType ( field_types [ 1 ] ) ; LLVMValueRef dim_array = LLVMGetUndef ( field_types [ 1 ] ) ; LLVMValueRef left = llvm_int32 ( 0 ) ; LLVMValueRef right = LLVMBuildSub ( builder , LLVMGetParam ( fn , 1 ) , llvm_int32 ( 1 ) , "right" ) ; LLVMValueRef dir = llvm_int1 ( RANGE_TO ) ; LLVMValueRef vals = LLVMGetParam ( fn , 0 ) ; LLVMValueRef d = LLVMGetUndef ( dim_struct ) ; d = LLVMBuildInsertValue ( builder , d , left , 0 , "" ) ; d = LLVMBuildInsertValue ( builder , d , right , 1 , "" ) ; d = LLVMBuildInsertValue ( builder , d , dir , 2 , "" ) ; dim_array = LLVMBuildInsertValue ( builder , dim_array , d , 0 , "" ) ; LLVMValueRef wrapped = LLVMGetUndef ( uarray_type ) ; wrapped = LLVMBuildInsertValue ( builder , wrapped , vals , 0 , "" ) ; wrapped = LLVMBuildInsertValue ( builder , wrapped , dim_array , 1 , "" ) ; LLVMValueRef r = LLVMBuildCall ( builder , rfn , & wrapped , 1 , "" ) ; <S2SV_StartBug> LLVMBuildRet ( builder , <S2SV_EndBug> LLVMBuildZExt ( builder , r , LLVMInt64Type ( ) , "" ) ) ; LLVMPositionBuilderAtEnd ( builder , saved_bb ) ; return llvm_void_cast ( fn ) ; } | <S2SV_ModStart> fn ) ; const bool is_record = vtype_kind ( type ) == VCODE_TYPE_RECORD ; <S2SV_ModStart> ) ; LLVMTypeRef pointer_type = LLVMPointerType ( elem_type , 0 ) ; LLVMTypeRef <S2SV_ModStart> elem_type , 1 ) ; LLVMTypeRef result_type = is_record ? pointer_type : LLVMInt64Type ( <S2SV_ModStart> ] = { pointer_type <S2SV_ModEnd> , LLVMInt32Type ( <S2SV_ModStart> , LLVMFunctionType ( result_type <S2SV_ModEnd> , args , <S2SV_ModStart> ) { LLVMTypeRef wrapped_result_type = is_record ? pointer_type : elem_type ; LLVMTypeRef <S2SV_ModStart> , LLVMFunctionType ( wrapped_result_type <S2SV_ModEnd> , args , <S2SV_ModStart> "" ) ; if ( is_record ) LLVMBuildRet ( builder , r ) ; else |
6,360 | CWE-000 void wish_clear ( wish_term * term ) { wish_frame * frame ; <S2SV_StartBug> frame = & term -> frame ; <S2SV_EndBug> <S2SV_StartBug> memset ( frame -> ch , '<S2SV_blank>' , term -> size . x * term -> size . y * sizeof ( * frame -> ch ) ) ; <S2SV_EndBug> <S2SV_StartBug> memset ( frame -> attr , 0 , term -> size . x * term -> size . y * sizeof ( * frame -> attr ) ) ; <S2SV_EndBug> } | <S2SV_ModStart> * frame ; wish_attr attr ; wish_attr_init ( & attr ) ; <S2SV_ModStart> -> frame ; for ( size_t i = 0 ; i < <S2SV_ModEnd> term -> size <S2SV_ModStart> size . y ; ++ i ) { <S2SV_ModEnd> frame -> ch <S2SV_ModStart> frame -> ch [ i ] = '<S2SV_blank>' ; <S2SV_ModEnd> frame -> attr <S2SV_ModStart> frame -> attr [ i ] = attr ; } } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
6,361 | CWE-000 void Acknowledge ( struct proto_tcp_conn_context * context , uint32_t number ) { struct TCPPacket * packet ; for ( packet = context -> fFirstSentPacket ; packet != NULL ; packet = context -> fFirstSentPacket ) { if ( packet -> fSequenceNumber >= number ) <S2SV_StartBug> return ; <S2SV_EndBug> context -> fFirstSentPacket = packet -> fNext ; DEL ( packet ) ; } context -> fLastSentPacket = NULL ; } | <S2SV_ModStart> >= number ) { TRACE ( "packet->fSequenceNumber<S2SV_blank>%d<S2SV_blank>>=<S2SV_blank>number<S2SV_blank>%d" , packet -> fSequenceNumber , number ) ; return ; } <S2SV_ModEnd> context -> fFirstSentPacket |
6,362 | CWE-000 char * ft_itoa ( int n ) { unsigned int len ; int tmp ; int neg ; char * res ; tmp = n ; len = 1 ; neg = 0 ; n >= 0 ? 0 : ( neg = 1 ) ; if ( n == - 2147483648 ) return ( "-2147483648" ) ; while ( tmp /= 10 ) len ++ ; <S2SV_StartBug> res = ft_strnew ( len + 1 + neg ) ; <S2SV_EndBug> if ( neg ) res [ 0 ] = '-' ; while ( len -- ) { res [ len + neg ] = ABS ( n % 10 ) + '0' ; n /= 10 ; } return ( res ) ; } | <S2SV_ModStart> len ++ ; if ( ! ( <S2SV_ModStart> 1 + neg ) ) ) return ( NULL |
6,363 | CWE-000 rc_t cmn_read_uint8_array ( struct cmn_iter * self , uint32_t col_id , uint8_t * * values , uint32_t * values_read ) { uint32_t elem_bits , boff , row_len ; rc_t rc = VCursorCellDataDirect ( self -> cursor , self -> row_id , col_id , & elem_bits , ( const void * * ) values , & boff , & row_len ) ; if ( rc != 0 ) <S2SV_StartBug> ErrMsg ( "VCursorCellDataDirect(<S2SV_blank>#%ld<S2SV_blank>)<S2SV_blank>-><S2SV_blank>%R\\n" , self -> row_id , rc ) ; <S2SV_EndBug> <S2SV_StartBug> else if ( elem_bits != 8 || boff != 0 || row_len < 1 ) <S2SV_EndBug> { <S2SV_StartBug> ErrMsg ( "row#%ld<S2SV_blank>:<S2SV_blank>bits=%d,<S2SV_blank>boff=%d,<S2SV_blank>len=%d\\n" , self -> row_id , elem_bits , boff , row_len ) ; <S2SV_EndBug> rc = RC ( rcApp , rcNoTarg , rcAccessing , rcRow , rcInvalid ) ; } else { if ( values_read != NULL ) * values_read = row_len ; } return rc ; } | <S2SV_ModStart> ) ErrMsg ( "cmn_iter.c<S2SV_blank>cmn_read_uint8_array(<S2SV_blank>#%ld<S2SV_blank>).VCursorCellDataDirect()<S2SV_blank>-><S2SV_blank>%R\\n" <S2SV_ModEnd> , self -> <S2SV_ModStart> boff != 0 <S2SV_ModEnd> ) { ErrMsg <S2SV_ModStart> { ErrMsg ( "cmn_iter.c<S2SV_blank>cmn_read_uint8_array(<S2SV_blank>#%ld<S2SV_blank>)<S2SV_blank>:<S2SV_blank>bits=%d,<S2SV_blank>boff=%d\\n" <S2SV_ModEnd> , self -> <S2SV_ModStart> elem_bits , boff <S2SV_ModEnd> ) ; rc |
6,364 | CWE-000 static void complete_one ( gpointer key , gpointer value , gpointer user_data ) { <S2SV_StartBug> const char * prefix = user_data ; <S2SV_EndBug> const char * name = key ; const char * last ; last = strrchr ( prefix , ',' ) ; if ( last ) last ++ ; else last = prefix ; if ( ( ! * last && ! strchr ( name , '.' ) ) || matches ( last , name ) ) { <S2SV_StartBug> g_print ( "%.*s%s%s\\n" , ( int ) ( last - prefix ) , prefix , name , <S2SV_EndBug> strcmp ( last , name ) == 0 ? "," : "" ) ; } } | <S2SV_ModStart> const char * * option_with_value = user_data ; const char * option = option_with_value [ 0 ] ; const char * prefix = option_with_value [ 1 ] <S2SV_ModEnd> ; const char <S2SV_ModStart> ) ) { if ( option != prefix ) { g_print ( "%s=" , option ) ; } |
6,365 | CWE-000 static enum req_fsm_nxt cnt_fetch ( struct worker * wrk , struct req * req ) { CHECK_OBJ_NOTNULL ( wrk , WORKER_MAGIC ) ; CHECK_OBJ_NOTNULL ( req , REQ_MAGIC ) ; <S2SV_StartBug> CHECK_OBJ_NOTNULL ( req -> objcore , OBJCORE_MAGIC ) ; <S2SV_EndBug> wrk -> stats -> s_fetch ++ ; ( void ) VRB_Ignore ( req ) ; if ( req -> objcore -> flags & OC_F_FAILED ) { req -> err_code = 503 ; req -> req_step = R_STP_SYNTH ; ( void ) HSH_DerefObjCore ( wrk , & req -> objcore ) ; AZ ( req -> objcore ) ; return ( REQ_FSM_MORE ) ; } req -> req_step = R_STP_DELIVER ; return ( REQ_FSM_MORE ) ; } | <S2SV_ModStart> objcore , OBJCORE_MAGIC ) ; AZ ( req -> stale_oc |
6,366 | CWE-000 int scenario_is_tutorial_3 ( ) { <S2SV_StartBug> return Data_Settings . isCustomScenario && Data_Settings . currentMissionId == 2 ; <S2SV_EndBug> } | <S2SV_ModStart> ) { return ! |
6,367 | CWE-000 void display_wrong_move ( ) { if ( wrong_move ) { printf ( "You<S2SV_blank>entered<S2SV_blank>an<S2SV_blank>invalid<S2SV_blank>move!\\n" ) ; <S2SV_StartBug> wrong_move = 0 ; <S2SV_EndBug> } } | <S2SV_ModStart> ; wrong_move = FALSE <S2SV_ModEnd> ; } } |
6,368 | CWE-000 struct lsdn_vr * lsdn_vr_new ( struct lsdn_virt * virt , uint16_t prio_num , enum lsdn_direction dir , struct lsdn_vr_action * a ) { assert ( ( prio_num >= LSDN_VR_PRIO_MIN && prio_num < LSDN_VR_PRIO_MAX ) || prio_num == LSDN_PRIO_FORWARD_DST_MAC ) ; struct vr_prio * * ht = ( dir == LSDN_IN ) ? & virt -> ht_in_rules : & virt -> ht_out_rules ; struct lsdn_vr * vr = malloc ( sizeof ( * vr ) ) ; if ( ! vr ) <S2SV_StartBug> ret_ptr ( virt -> network -> ctx , vr ) ; <S2SV_EndBug> struct vr_prio * prio ; HASH_FIND ( hh , * ht , & prio_num , sizeof ( prio_num ) , prio ) ; if ( ! prio ) { prio = malloc ( sizeof ( * prio ) ) ; if ( ! prio ) { free ( vr ) ; <S2SV_StartBug> ret_ptr ( virt -> network -> ctx , vr ) ; <S2SV_EndBug> } prio -> commited_prio = NULL ; prio -> commited_count = 0 ; prio -> prio_num = prio_num ; lsdn_list_init ( & prio -> rules_list ) ; HASH_ADD ( hh , * ht , prio_num , sizeof ( prio -> prio_num ) , prio ) ; } vr -> pos = 0 ; vr -> state = LSDN_STATE_NEW ; vr -> rule . action = a -> desc ; for ( size_t i = 0 ; i < LSDN_MAX_MATCHES ; i ++ ) { vr -> targets [ i ] = LSDN_MATCH_NONE ; bzero ( vr -> masks [ i ] . bytes , sizeof ( vr -> masks [ i ] . bytes ) ) ; } lsdn_list_init_add ( & prio -> rules_list , & vr -> rules_entry ) ; return vr ; } | <S2SV_ModStart> -> ctx , NULL <S2SV_ModEnd> ) ; struct <S2SV_ModStart> -> ctx , NULL <S2SV_ModEnd> ) ; } |
6,369 | CWE-000 int main ( int argc , char * argv [ ] ) { CLIENT * remote_client ; char * line = NULL ; char * transactionType ; char * accountNum1 ; char * accountNum2 ; int amount = 0 ; size_t len = 0 ; FILE * file ; if ( argc < 1 ) { printf ( "Missing<S2SV_blank>filename" ) ; } else { if ( ! doesFileExist ( argv [ 1 ] ) ) { printf ( "Unable<S2SV_blank>to<S2SV_blank>find<S2SV_blank>file" ) ; return 0 ; } else { file = fopen ( argv [ 1 ] , "r" ) ; if ( file ) { while ( getline ( & line , & len , file ) != - 1 ) { if ( line [ 0 ] != '\\n' ) { transactionType = strtok ( line , "<S2SV_blank>" ) ; if ( strcasecmp ( transactionType , "credit" ) != 0 && strcasecmp ( transactionType , "debit" ) != 0 && strcasecmp ( transactionType , "transfer" ) != 0 ) { printf ( "Invalid<S2SV_blank>Transaction\\n" ) ; } else { if ( strcasecmp ( transactionType , "credit" ) == 0 ) { accountNum1 = strtok ( NULL , "<S2SV_blank>" ) ; <S2SV_StartBug> printf ( "Ready><S2SV_blank>credit<S2SV_blank>%s<S2SV_blank>%i\\n" , accountNum1 , amount ) ; <S2SV_EndBug> } else if ( strcasecmp ( transactionType , "debit" ) == 0 ) { accountNum1 = strtok ( NULL , "<S2SV_blank>" ) ; <S2SV_StartBug> printf ( "Ready><S2SV_blank>debit<S2SV_blank>%s<S2SV_blank>%i\\n" , accountNum1 , amount ) ; <S2SV_EndBug> } else { accountNum1 = strtok ( NULL , "<S2SV_blank>" ) ; accountNum2 = strtok ( NULL , "<S2SV_blank>" ) ; <S2SV_StartBug> printf ( "Ready><S2SV_blank>transfer<S2SV_blank>%s<S2SV_blank>%i\\n" , accountNum1 , accountNum2 , amount ) ; <S2SV_EndBug> } } } } } fclose ( file ) ; } } } | <S2SV_ModStart> "<S2SV_blank>" ) ; amount = atoi ( strtok ( NULL , "<S2SV_blank>" ) ) ; <S2SV_ModStart> "<S2SV_blank>" ) ; amount = atoi ( strtok ( NULL , "<S2SV_blank>" ) ) ; <S2SV_ModStart> "<S2SV_blank>" ) ; amount = atoi ( strtok ( NULL , "<S2SV_blank>" ) ) ; |
6,370 | CWE-000 static int bpf_mkmap ( struct dentry * dentry , umode_t mode , void * arg ) { struct bpf_map * map = arg ; return bpf_mkobj_ops ( dentry , mode , arg , & bpf_map_iops , <S2SV_StartBug> map -> btf ? & bpffs_map_fops : NULL ) ; <S2SV_EndBug> } | <S2SV_ModStart> & bpffs_map_fops : & bpffs_obj_fops <S2SV_ModEnd> ) ; } |
6,371 | CWE-000 static void scavenge_interrupt_context ( os_context_t * context ) { unsigned int i ; INTERIOR_POINTER_VARS ( pc ) ; # ifdef reg_LIP INTERIOR_POINTER_VARS ( lip ) ; # endif # ifdef ARCH_HAS_LINK_REGISTER INTERIOR_POINTER_VARS ( lr ) ; # endif # ifdef ARCH_HAS_NPC_REGISTER INTERIOR_POINTER_VARS ( npc ) ; # endif # ifdef LISP_FEATURE_PPC INTERIOR_POINTER_VARS ( ctr ) ; # endif PAIR_INTERIOR_POINTER ( pc ) ; # ifdef reg_LIP PAIR_INTERIOR_POINTER ( lip ) ; # endif # ifdef ARCH_HAS_LINK_REGISTER PAIR_INTERIOR_POINTER ( lr ) ; # endif # ifdef ARCH_HAS_NPC_REGISTER PAIR_INTERIOR_POINTER ( npc ) ; # endif # ifdef LISP_FEATURE_PPC PAIR_INTERIOR_POINTER ( ctr ) ; # endif for ( i = 0 ; i < ( sizeof ( boxed_registers ) / sizeof ( int ) ) ; i ++ ) { <S2SV_StartBug> int index ; <S2SV_EndBug> lispobj foo ; <S2SV_StartBug> index = boxed_registers [ i ] ; <S2SV_EndBug> foo = * os_context_register_addr ( context , index ) ; <S2SV_StartBug> scavenge ( & foo , 1 ) ; <S2SV_EndBug> <S2SV_StartBug> * os_context_register_addr ( context , index ) = foo ; <S2SV_EndBug> scavenge ( ( lispobj * ) os_context_register_addr ( context , index ) , 1 ) ; } FIXUP_INTERIOR_POINTER ( pc ) ; # ifdef reg_LIP FIXUP_INTERIOR_POINTER ( lip ) ; # endif # ifdef ARCH_HAS_LINK_REGISTER FIXUP_INTERIOR_POINTER ( lr ) ; # endif # ifdef ARCH_HAS_NPC_REGISTER FIXUP_INTERIOR_POINTER ( npc ) ; # endif # ifdef LISP_FEATURE_PPC FIXUP_INTERIOR_POINTER ( ctr ) ; # endif } | <S2SV_ModStart> ++ ) { os_context_register_t * boxed_reg ; lispobj datum ; boxed_reg = os_context_register_addr ( context , <S2SV_ModEnd> boxed_registers [ i <S2SV_ModStart> [ i ] ) ; datum = * boxed_reg <S2SV_ModEnd> ; scavenge ( <S2SV_ModStart> scavenge ( & datum <S2SV_ModEnd> , 1 ) <S2SV_ModStart> ) ; * boxed_reg = datum <S2SV_ModEnd> ; } FIXUP_INTERIOR_POINTER |
6,372 | CWE-000 static void update_per_cpu_stat ( void ) { unsigned int cpu ; struct ip_cpu_info * l_ip_info ; for_each_online_cpu ( cpu ) { l_ip_info = & per_cpu ( ip_info , cpu ) ; l_ip_info -> cpu_nr_running = avg_cpu_nr_running ( cpu ) ; <S2SV_StartBug> } <S2SV_EndBug> } | <S2SV_ModStart> cpu ) ; # ifdef DEBUG_INTELLI_PLUG pr_info ( "cpu<S2SV_blank>%u<S2SV_blank>nr_running<S2SV_blank>=><S2SV_blank>%lu\\n" , cpu , l_ip_info -> cpu_nr_running ) ; # endif |
6,373 | CWE-000 <S2SV_StartBug> void getSnapshotData_float_1D ( float * * data , int dataSeriesLength , TightDataPointStorageF * tdps ) <S2SV_EndBug> { SZ_Reset ( ) ; int i ; if ( tdps -> allSameData ) { float value = bytesToFloat ( tdps -> exactMidBytes ) ; * data = ( float * ) malloc ( sizeof ( float ) * dataSeriesLength ) ; for ( i = 0 ; i < dataSeriesLength ; i ++ ) ( * data ) [ i ] = value ; } else { if ( tdps -> rtypeArray == NULL ) { <S2SV_StartBug> if ( errorBoundMode != PW_REL ) <S2SV_EndBug> decompressDataSeries_float_1D ( data , dataSeriesLength , tdps ) ; else decompressDataSeries_float_1D_pwr ( data , dataSeriesLength , tdps ) ; return ; } else { * data = ( float * ) malloc ( sizeof ( float ) * dataSeriesLength ) ; int * rtypes ; int validLength = computeBitNumRequired ( dataSeriesLength ) ; decompressBitArraybySimpleLZ77 ( & rtypes , tdps -> rtypeArray , tdps -> rtypeArray_size , dataSeriesLength , validLength ) ; int count = 0 ; for ( i = 0 ; i < dataSeriesLength ; i ++ ) { if ( rtypes [ i ] == 1 ) ( * data ) [ i ] = tdps -> reservedValue ; else count ++ ; } float * decmpData ; <S2SV_StartBug> if ( errorBoundMode != PW_REL ) <S2SV_EndBug> decompressDataSeries_float_1D ( & decmpData , dataSeriesLength , tdps ) ; else decompressDataSeries_float_1D_pwr ( & decmpData , dataSeriesLength , tdps ) ; int k = 0 ; for ( i = 0 ; i < dataSeriesLength ; i ++ ) { if ( rtypes [ i ] == 0 ) { ( * data ) [ i ] = decmpData [ k ++ ] ; } } free ( decmpData ) ; free ( rtypes ) ; } } } | <S2SV_ModStart> TightDataPointStorageF * tdps , int errBoundMode <S2SV_ModStart> { if ( errBoundMode <S2SV_ModEnd> != PW_REL ) <S2SV_ModStart> ; if ( errBoundMode <S2SV_ModEnd> != PW_REL ) |
6,374 | CWE-000 uint8_t MCP2515_read_status ( ) { <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ( ) { uint8_t read_data [ 2 ] ; uint8_t cmd [ ] = { MCP_READ_STATUS , 0xFF } ; spi_transmit_recieve ( cmd , read_data , 2 ) ; return read_data [ 1 ] ; |
6,375 | CWE-000 void hammer2_chain_modify ( hammer2_chain_t * chain , hammer2_tid_t mtid , hammer2_off_t dedup_off , int flags ) { hammer2_blockref_t obref ; hammer2_dev_t * hmp ; hammer2_io_t * dio ; int error ; int wasinitial ; int newmod ; char * bdata ; hmp = chain -> hmp ; obref = chain -> bref ; KKASSERT ( ( chain -> flags & HAMMER2_CHAIN_FICTITIOUS ) == 0 ) ; if ( chain -> bref . type == HAMMER2_BREF_TYPE_FREEMAP_NODE || chain -> bref . type == HAMMER2_BREF_TYPE_FREEMAP_LEAF ) { KKASSERT ( ( chain -> flags & HAMMER2_CHAIN_INITIAL ) || ( flags & HAMMER2_MODIFY_OPTDATA ) == 0 ) ; } if ( chain -> data == NULL && chain -> bytes != 0 && ( flags & HAMMER2_MODIFY_OPTDATA ) == 0 && ( chain -> bref . data_off & ~ HAMMER2_OFF_MASK_RADIX ) ) { hammer2_chain_load_data ( chain ) ; } if ( ( chain -> flags & HAMMER2_CHAIN_MODIFIED ) && modified_needs_new_allocation ( chain ) ) { newmod = 1 ; } else if ( ( chain -> flags & HAMMER2_CHAIN_MODIFIED ) == 0 ) { atomic_add_long ( & hammer2_count_modified_chains , 1 ) ; atomic_set_int ( & chain -> flags , HAMMER2_CHAIN_MODIFIED ) ; hammer2_pfs_memory_inc ( chain -> pmp ) ; if ( ( chain -> bref . type == HAMMER2_BREF_TYPE_DATA || chain -> bref . type == HAMMER2_BREF_TYPE_DIRENT ) && ( chain -> flags & HAMMER2_CHAIN_INITIAL ) == 0 && HAMMER2_DEC_CHECK ( chain -> bref . methods ) == HAMMER2_CHECK_NONE && chain -> pmp && chain -> bref . modify_tid > chain -> pmp -> iroot -> meta . pfs_lsnap_tid && modified_needs_new_allocation ( chain ) == 0 ) { newmod = 0 ; } else { newmod = 1 ; } } else { newmod = 0 ; } if ( ( chain -> flags & HAMMER2_CHAIN_UPDATE ) == 0 ) atomic_set_int ( & chain -> flags , HAMMER2_CHAIN_UPDATE ) ; if ( chain != & hmp -> vchain && chain != & hmp -> fchain && chain -> bytes ) { if ( ( chain -> bref . data_off & ~ HAMMER2_OFF_MASK_RADIX ) == 0 || newmod ) { if ( dedup_off ) { chain -> bref . data_off = dedup_off ; chain -> bytes = 1 << ( dedup_off & HAMMER2_OFF_MASK_RADIX ) ; <S2SV_StartBug> atomic_set_int ( & chain -> flags , <S2SV_EndBug> HAMMER2_CHAIN_DEDUP ) ; hammer2_freemap_adjust ( hmp , & chain -> bref , HAMMER2_FREEMAP_DORECOVER ) ; } else { <S2SV_StartBug> hammer2_freemap_alloc ( chain , chain -> bytes ) ; <S2SV_EndBug> atomic_clear_int ( & chain -> flags , HAMMER2_CHAIN_DEDUP ) ; } } } chain -> bref . mirror_tid = hmp -> voldata . mirror_tid + 1 ; if ( mtid ) chain -> bref . modify_tid = mtid ; if ( chain -> flags & HAMMER2_CHAIN_BMAPPED ) atomic_set_int ( & chain -> flags , HAMMER2_CHAIN_BMAPUPD ) ; if ( chain -> bref . type == HAMMER2_BREF_TYPE_DATA && ( flags & HAMMER2_MODIFY_OPTDATA ) && chain -> data == NULL ) { KKASSERT ( chain -> dio == NULL ) ; goto skip2 ; } if ( chain -> flags & HAMMER2_CHAIN_INITIAL ) { atomic_clear_int ( & chain -> flags , HAMMER2_CHAIN_INITIAL ) ; wasinitial = 1 ; } else { wasinitial = 0 ; } switch ( chain -> bref . type ) { case HAMMER2_BREF_TYPE_VOLUME : case HAMMER2_BREF_TYPE_FREEMAP : KKASSERT ( chain -> dio == NULL ) ; break ; case HAMMER2_BREF_TYPE_DIRENT : if ( chain -> bytes == 0 ) { KKASSERT ( chain -> dio == NULL ) ; break ; } case HAMMER2_BREF_TYPE_INODE : case HAMMER2_BREF_TYPE_FREEMAP_LEAF : case HAMMER2_BREF_TYPE_DATA : case HAMMER2_BREF_TYPE_INDIRECT : case HAMMER2_BREF_TYPE_FREEMAP_NODE : KKASSERT ( chain != & hmp -> vchain && chain != & hmp -> fchain ) ; if ( wasinitial && dedup_off == 0 ) { error = hammer2_io_new ( hmp , chain -> bref . type , chain -> bref . data_off , chain -> bytes , & dio ) ; } else { error = hammer2_io_bread ( hmp , chain -> bref . type , chain -> bref . data_off , chain -> bytes , & dio ) ; } hammer2_adjreadcounter ( & chain -> bref , chain -> bytes ) ; if ( error ) { kprintf ( "hammer2_chain_modify:<S2SV_blank>hmp=%p<S2SV_blank>I/O<S2SV_blank>error\\n" , hmp ) ; chain -> error = HAMMER2_ERROR_IO ; hammer2_io_brelse ( & dio ) ; hammer2_io_brelse ( & chain -> dio ) ; chain -> data = NULL ; break ; } chain -> error = 0 ; bdata = hammer2_io_data ( dio , chain -> bref . data_off ) ; if ( chain -> data ) { KKASSERT ( chain -> dio != NULL ) ; if ( chain -> data != ( void * ) bdata && dedup_off == 0 ) { bcopy ( chain -> data , bdata , chain -> bytes ) ; } } else if ( wasinitial == 0 ) { panic ( "hammer2_chain_modify:<S2SV_blank>having<S2SV_blank>a<S2SV_blank>COW<S2SV_blank>%p\\n" , chain ) ; } if ( chain -> dio ) hammer2_io_bqrelse ( & chain -> dio ) ; chain -> data = ( void * ) bdata ; chain -> dio = dio ; if ( dedup_off == 0 ) hammer2_io_setdirty ( dio ) ; break ; default : panic ( "hammer2_chain_modify:<S2SV_blank>illegal<S2SV_blank>non-embedded<S2SV_blank>type<S2SV_blank>%d" , chain -> bref . type ) ; break ; } skip2 : if ( chain -> parent ) hammer2_chain_setflush ( chain -> parent ) ; } | <S2SV_ModStart> HAMMER2_OFF_MASK_RADIX ) ; atomic_clear_int ( & chain -> flags , HAMMER2_CHAIN_MODIFIED ) ; atomic_add_long ( & hammer2_count_modified_chains , - 1 ) ; if ( chain -> pmp ) hammer2_pfs_memory_wakeup ( chain -> pmp <S2SV_ModEnd> ) ; hammer2_freemap_adjust <S2SV_ModStart> chain -> bytes <S2SV_ModEnd> ) ; } |
6,376 | CWE-000 <S2SV_StartBug> int initializeObjects ( void ) <S2SV_EndBug> { for ( int i = 0 ; i < MAX_OBJECT ; i ++ ) gameObject [ i ] . type = NOTHING ; return ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> void <S2SV_ModEnd> initializeObjects ( void |
6,377 | CWE-000 int elan_read_fw_from_sdcard ( char * file_path ) { mm_segment_t oldfs ; struct file * firmware_fp ; int ret = 0 ; int retry = 0 ; int file_len ; if ( file_fw_data_out != NULL ) kfree ( file_fw_data_out ) ; oldfs = get_fs ( ) ; set_fs ( KERNEL_DS ) ; for ( retry = 0 ; retry < 5 ; retry ++ ) { firmware_fp = filp_open ( file_path , O_RDONLY , 0 ) ; if ( IS_ERR ( firmware_fp ) ) { dev_err ( & private_ts -> client -> dev , "[elan]<S2SV_blank>retry<S2SV_blank>to<S2SV_blank>open<S2SV_blank>user<S2SV_blank>bin<S2SV_blank>filen\\n" ) ; mdelay ( 1000 ) ; } else break ; } if ( retry >= 5 ) { dev_err ( & private_ts -> client -> dev , "[elan<S2SV_blank>error]<S2SV_blank>open<S2SV_blank>%s<S2SV_blank>file<S2SV_blank>error!\\n" , file_path ) ; ret = - 1 ; goto out_read_fw_from_user2 ; } else dev_dbg ( & private_ts -> client -> dev , "[elan]<S2SV_blank>open<S2SV_blank>%s<S2SV_blank>file<S2SV_blank>sucess!\\n" , file_path ) ; file_len = firmware_fp -> f_path . dentry -> d_inode -> i_size ; if ( file_len == 0 ) { dev_dbg ( & private_ts -> client -> dev , "elan<S2SV_blank>file<S2SV_blank>len<S2SV_blank>error<S2SV_blank>!!!!!!\\n" ) ; ret = - 2 ; goto out_read_fw_from_user1 ; } else PageNum = file_len / 132 ; dev_dbg ( & private_ts -> client -> dev , "[elan]<S2SV_blank>user<S2SV_blank>bin<S2SV_blank>data<S2SV_blank>len=%d\\n" , file_len ) ; file_fw_data_out = kzalloc ( file_len , GFP_KERNEL ) ; <S2SV_StartBug> if ( file_fw_data == NULL ) { <S2SV_EndBug> dev_err ( & private_ts -> client -> dev , <S2SV_StartBug> "[elan<S2SV_blank>error]<S2SV_blank>mallco<S2SV_blank>file_fw_data<S2SV_blank>error\\n" ) ; <S2SV_EndBug> ret = - 3 ; goto out_read_fw_from_user1 ; } ret = firmware_fp -> f_op -> read ( firmware_fp , file_fw_data_out , file_len , & firmware_fp -> f_pos ) ; if ( ret != file_len ) { dev_err ( & private_ts -> client -> dev , "[elan<S2SV_blank>error]<S2SV_blank>read<S2SV_blank>BIN<S2SV_blank>file<S2SV_blank>size<S2SV_blank>error,ret<S2SV_blank>=<S2SV_blank>%d!\\n" , ret ) ; ret = - 4 ; } ret = 0 ; out_read_fw_from_user1 : filp_close ( firmware_fp , NULL ) ; out_read_fw_from_user2 : set_fs ( oldfs ) ; return ret ; } | <S2SV_ModStart> ; if ( file_fw_data_out <S2SV_ModEnd> == NULL ) <S2SV_ModStart> -> dev , "[elan<S2SV_blank>error]<S2SV_blank>mallco<S2SV_blank>file_fw_data_out<S2SV_blank>error\\n" <S2SV_ModEnd> ) ; ret |
6,378 | CWE-000 int ncdwio_bufferedfile_write ( NC_dw_bufferedfile * f , void * buf , size_t count ) { int i , err ; size_t midstart , midend ; size_t sblock , soff , eblock , eoff ; size_t off , len ; <S2SV_StartBug> size_t ioret ; <S2SV_EndBug> if ( f -> buffer != NULL ) { <S2SV_StartBug> midstart = ( f -> bsize - f -> pos % f -> bsize ) % f -> bsize ; <S2SV_EndBug> midend = f -> pos + count - ( f -> pos + count ) % f -> bsize ; if ( midstart > midend ) { midstart = 0 ; <S2SV_StartBug> midend = 0 ; <S2SV_EndBug> } if ( midstart > 0 ) { if ( f -> bused - f -> bunused > 0 ) { memcpy ( f -> buffer + f -> bused , buf , midstart ) ; err = ncdwio_sharedfile_write ( f -> fd , f -> buffer + f -> bunused , f -> bsize - f -> bunused ) ; if ( err != NC_NOERR ) { return err ; } f -> bused = 0 ; f -> bunused = 0 ; } else { midstart = 0 ; } } if ( midend > midstart ) { err = ncdwio_sharedfile_write ( f -> fd , buf + midstart , midend - midstart ) ; if ( err != NC_NOERR ) { return err ; } } if ( count > midend ) { memcpy ( f -> buffer + f -> bused , buf + midend , count - midend ) ; f -> bused += count - midend ; } } else { err = ncdwio_sharedfile_write ( f -> fd , buf , count ) ; if ( err != NC_NOERR ) { return err ; } } f -> pos += count ; if ( f -> fsize < f -> pos ) { f -> fsize = f -> pos ; } return NC_NOERR ; } | <S2SV_ModStart> , len ; ssize_t <S2SV_ModEnd> ioret ; if <S2SV_ModStart> { midstart = f -> pos + <S2SV_ModStart> midend = 0 ; } else { midstart -= f -> pos ; midend -= f -> pos |
6,379 | CWE-000 static int rtnl_fdb_dump ( struct sk_buff * skb , struct netlink_callback * cb ) { struct net_device * dev ; struct nlattr * tb [ IFLA_MAX + 1 ] ; struct net_device * br_dev = NULL ; const struct net_device_ops * ops = NULL ; const struct net_device_ops * cops = NULL ; struct ifinfomsg * ifm = nlmsg_data ( cb -> nlh ) ; struct net * net = sock_net ( skb -> sk ) ; struct hlist_head * head ; int brport_idx = 0 ; int br_idx = 0 ; int h , s_h ; int idx = 0 , s_idx ; int err = 0 ; int fidx = 0 ; <S2SV_StartBug> err = nlmsg_parse ( cb -> nlh , sizeof ( struct ifinfomsg ) , tb , <S2SV_EndBug> IFLA_MAX , ifla_policy ) ; if ( err < 0 ) { return - EINVAL ; } else if ( err == 0 ) { if ( tb [ IFLA_MASTER ] ) br_idx = nla_get_u32 ( tb [ IFLA_MASTER ] ) ; } brport_idx = ifm -> ifi_index ; <S2SV_StartBug> if ( br_idx ) { <S2SV_EndBug> br_dev = __dev_get_by_index ( net , br_idx ) ; if ( ! br_dev ) return - ENODEV ; ops = br_dev -> netdev_ops ; } s_h = cb -> args [ 0 ] ; s_idx = cb -> args [ 1 ] ; for ( h = s_h ; h < NETDEV_HASHENTRIES ; h ++ , s_idx = 0 ) { idx = 0 ; head = & net -> dev_index_head [ h ] ; hlist_for_each_entry ( dev , head , index_hlist ) { if ( brport_idx && ( dev -> ifindex != brport_idx ) ) continue ; if ( ! br_idx ) { if ( dev -> priv_flags & IFF_BRIDGE_PORT ) { br_dev = netdev_master_upper_dev_get ( dev ) ; cops = br_dev -> netdev_ops ; } } else { if ( dev != br_dev && ! ( dev -> priv_flags & IFF_BRIDGE_PORT ) ) continue ; if ( br_dev != netdev_master_upper_dev_get ( dev ) && ! ( dev -> priv_flags & IFF_EBRIDGE ) ) continue ; cops = ops ; } if ( idx < s_idx ) goto cont ; if ( dev -> priv_flags & IFF_BRIDGE_PORT ) { if ( cops && cops -> ndo_fdb_dump ) { err = cops -> ndo_fdb_dump ( skb , cb , br_dev , dev , & fidx ) ; if ( err == - EMSGSIZE ) goto out ; } } if ( dev -> netdev_ops -> ndo_fdb_dump ) err = dev -> netdev_ops -> ndo_fdb_dump ( skb , cb , dev , NULL , & fidx ) ; else err = ndo_dflt_fdb_dump ( skb , cb , dev , NULL , & fidx ) ; if ( err == - EMSGSIZE ) goto out ; cops = NULL ; cb -> args [ 2 ] = 0 ; fidx = 0 ; cont : idx ++ ; } } out : cb -> args [ 0 ] = h ; cb -> args [ 1 ] = idx ; cb -> args [ 2 ] = fidx ; return skb -> len ; } | <S2SV_ModStart> = 0 ; if ( nlmsg_len ( cb -> nlh ) != sizeof ( struct ndmsg ) && ( nlmsg_len ( cb -> nlh ) != sizeof ( struct ndmsg ) + nla_attr_size ( sizeof ( u32 ) ) ) ) { <S2SV_ModStart> -> ifi_index ; } |
6,380 | CWE-000 static int llc_ui_recvmsg ( struct kiocb * iocb , struct socket * sock , struct msghdr * msg , size_t len , int flags ) { struct sockaddr_llc * uaddr = ( struct sockaddr_llc * ) msg -> msg_name ; const int nonblock = flags & MSG_DONTWAIT ; struct sk_buff * skb = NULL ; struct sock * sk = sock -> sk ; struct llc_sock * llc = llc_sk ( sk ) ; unsigned long cpu_flags ; size_t copied = 0 ; u32 peek_seq = 0 ; u32 * seq , skb_len ; unsigned long used ; int target ; long timeo ; lock_sock ( sk ) ; copied = - ENOTCONN ; if ( unlikely ( sk -> sk_type == SOCK_STREAM && sk -> sk_state == TCP_LISTEN ) ) goto out ; timeo = sock_rcvtimeo ( sk , nonblock ) ; seq = & llc -> copied_seq ; if ( flags & MSG_PEEK ) { peek_seq = llc -> copied_seq ; seq = & peek_seq ; } target = sock_rcvlowat ( sk , flags & MSG_WAITALL , len ) ; copied = 0 ; do { u32 offset ; if ( signal_pending ( current ) ) { if ( copied ) break ; copied = timeo ? sock_intr_errno ( timeo ) : - EAGAIN ; break ; } skb = skb_peek ( & sk -> sk_receive_queue ) ; if ( skb ) { offset = * seq ; goto found_ok_skb ; } if ( copied >= target && ! sk -> sk_backlog . tail ) break ; if ( copied ) { if ( sk -> sk_err || sk -> sk_state == TCP_CLOSE || ( sk -> sk_shutdown & RCV_SHUTDOWN ) || ! timeo || ( flags & MSG_PEEK ) ) break ; } else { if ( sock_flag ( sk , SOCK_DONE ) ) break ; if ( sk -> sk_err ) { copied = sock_error ( sk ) ; break ; } if ( sk -> sk_shutdown & RCV_SHUTDOWN ) break ; if ( sk -> sk_type == SOCK_STREAM && sk -> sk_state == TCP_CLOSE ) { if ( ! sock_flag ( sk , SOCK_DONE ) ) { copied = - ENOTCONN ; break ; } break ; } if ( ! timeo ) { copied = - EAGAIN ; break ; } } if ( copied >= target ) { release_sock ( sk ) ; lock_sock ( sk ) ; } else <S2SV_StartBug> sk_wait_data ( sk , & timeo ) ; <S2SV_EndBug> if ( ( flags & MSG_PEEK ) && peek_seq != llc -> copied_seq ) { if ( net_ratelimit ( ) ) printk ( KERN_DEBUG "LLC(%s:%d):<S2SV_blank>Application<S2SV_blank>" "bug,<S2SV_blank>race<S2SV_blank>in<S2SV_blank>MSG_PEEK.\\n" , current -> comm , task_pid_nr ( current ) ) ; peek_seq = llc -> copied_seq ; } continue ; found_ok_skb : skb_len = skb -> len ; used = skb -> len - offset ; if ( len < used ) used = len ; if ( ! ( flags & MSG_TRUNC ) ) { int rc = skb_copy_datagram_iovec ( skb , offset , msg -> msg_iov , used ) ; if ( rc ) { if ( ! copied ) copied = - EFAULT ; break ; } } * seq += used ; copied += used ; len -= used ; if ( sk -> sk_type != SOCK_STREAM ) goto copy_uaddr ; if ( ! ( flags & MSG_PEEK ) ) { spin_lock_irqsave ( & sk -> sk_receive_queue . lock , cpu_flags ) ; sk_eat_skb ( sk , skb , false ) ; spin_unlock_irqrestore ( & sk -> sk_receive_queue . lock , cpu_flags ) ; * seq = 0 ; } if ( used + offset < skb_len ) continue ; } while ( len > 0 ) ; out : release_sock ( sk ) ; return copied ; copy_uaddr : if ( uaddr != NULL && skb != NULL ) { memcpy ( uaddr , llc_ui_skb_cb ( skb ) , sizeof ( * uaddr ) ) ; msg -> msg_namelen = sizeof ( * uaddr ) ; } if ( llc_sk ( sk ) -> cmsg_flags ) llc_cmsg_rcv ( msg , skb ) ; if ( ! ( flags & MSG_PEEK ) ) { spin_lock_irqsave ( & sk -> sk_receive_queue . lock , cpu_flags ) ; sk_eat_skb ( sk , skb , false ) ; spin_unlock_irqrestore ( & sk -> sk_receive_queue . lock , cpu_flags ) ; * seq = 0 ; } goto out ; } | <S2SV_ModStart> , & timeo , NULL |
6,381 | CWE-000 void getSample ( uint32_t phase ) { uint32_t LnSample ; uint32_t LnFamily ; uint32_t phaseFrac ; uint32_t morphFrac ; uint32_t Lnvalue1 ; uint32_t Rnvalue1 ; uint32_t Lnvalue2 ; uint32_t Rnvalue2 ; uint32_t interp1 ; uint32_t interp2 ; if ( phase == 0 ) { LnSample = ( position >> 16 ) ; LnFamily = fixMorph >> morphBitShiftRight ; phaseFrac = 0x0000FFFF & position ; morphFrac = ( fixMorph - ( LnFamily << morphBitShiftRight ) ) << morphBitShiftLeft ; Lnvalue1 = attackHoldArray [ LnFamily ] [ LnSample ] ; Rnvalue1 = attackHoldArray [ LnFamily ] [ LnSample + 1 ] ; Lnvalue2 = attackHoldArray [ LnFamily + 1 ] [ LnSample ] ; Rnvalue2 = attackHoldArray [ LnFamily + 1 ] [ LnSample + 1 ] ; interp1 = myfix16_lerp ( Lnvalue1 , Lnvalue2 , morphFrac ) ; interp2 = myfix16_lerp ( Rnvalue1 , Rnvalue2 , morphFrac ) ; out = myfix16_lerp ( interp1 , interp2 , phaseFrac ) >> 3 ; if ( interp1 < interp2 ) { EXPAND_GATE_HIGH REV2_GATE_HIGH if ( DELTAB ) { BLOGIC_HIGH if ( RGB_ON ) { <S2SV_StartBug> LEDC_ON <S2SV_EndBug> } } if ( DELTAA ) { ALOGIC_LOW if ( RGB_ON ) { LEDD_OFF } } } else if ( interp2 < interp1 ) { EXPAND_GATE_LOW REV2_GATE_LOW if ( DELTAB ) { BLOGIC_LOW if ( RGB_ON ) { LEDC_OFF } } if ( DELTAA ) { ALOGIC_HIGH if ( RGB_ON ) { LEDD_ON } } } if ( RGB_ON ) { __HAL_TIM_SET_COMPARE ( & htim1 , TIM_CHANNEL_3 , out ) ; __HAL_TIM_SET_COMPARE ( & htim1 , TIM_CHANNEL_2 , fixMorph >> 2 ) ; } } else { LnSample = ( ( spanx2 - position ) >> 16 ) ; LnFamily = fixMorph >> morphBitShiftRight ; phaseFrac = 0x0000FFFF & ( spanx2 - position ) ; morphFrac = ( uint16_t ) ( ( fixMorph - ( LnFamily << morphBitShiftRight ) ) << morphBitShiftLeft ) ; Lnvalue1 = releaseHoldArray [ LnFamily ] [ LnSample ] ; Rnvalue1 = releaseHoldArray [ LnFamily ] [ LnSample + 1 ] ; Lnvalue2 = releaseHoldArray [ LnFamily + 1 ] [ LnSample ] ; Rnvalue2 = releaseHoldArray [ LnFamily + 1 ] [ LnSample + 1 ] ; interp1 = myfix16_lerp ( Lnvalue1 , Lnvalue2 , morphFrac ) ; interp2 = myfix16_lerp ( Rnvalue1 , Rnvalue2 , morphFrac ) ; out = myfix16_lerp ( interp1 , interp2 , phaseFrac ) >> 3 ; if ( interp2 < interp1 ) { EXPAND_GATE_HIGH REV2_GATE_HIGH if ( DELTAB ) { BLOGIC_HIGH if ( RGB_ON ) { LEDD_ON } } if ( DELTAA ) { ALOGIC_LOW if ( RGB_ON ) { LEDC_OFF } } } else if ( interp1 < interp2 ) { EXPAND_GATE_LOW REV2_GATE_LOW if ( DELTAB ) { BLOGIC_LOW if ( RGB_ON ) { LEDD_OFF } } if ( DELTAA ) { ALOGIC_HIGH if ( RGB_ON ) { LEDC_ON } } } if ( RGB_ON ) { __HAL_TIM_SET_COMPARE ( & htim1 , TIM_CHANNEL_1 , out ) ; __HAL_TIM_SET_COMPARE ( & htim1 , TIM_CHANNEL_2 , fixMorph >> 2 ) ; } } } | <S2SV_ModStart> RGB_ON ) { LEDD_ON } } if ( DELTAA ) { ALOGIC_LOW if ( RGB_ON ) { LEDC_OFF } } } else if ( interp2 < interp1 ) { EXPAND_GATE_LOW REV2_GATE_LOW if ( DELTAB ) { BLOGIC_LOW if ( RGB_ON ) { LEDD_OFF } } if ( DELTAA ) { ALOGIC_HIGH if ( RGB_ON ) { LEDC_ON <S2SV_ModEnd> } } } |
6,382 | CWE-000 static void virQEMUCapsSetHostModel ( virQEMUCapsPtr qemuCaps , virDomainVirtType type , virCPUDefPtr reported , <S2SV_StartBug> virCPUDefPtr migratable ) <S2SV_EndBug> { virQEMUCapsHostCPUDataPtr cpuData = virQEMUCapsGetHostCPUData ( qemuCaps , type ) ; cpuData -> reported = reported ; cpuData -> migratable = migratable ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> , virCPUDefPtr migratable , virCPUDefPtr full <S2SV_ModStart> = migratable ; cpuData -> full = full ; |
6,383 | CWE-000 static void mlx4_rxmode_toggle ( struct rte_eth_dev * dev , enum rxmode_toggle toggle ) { struct priv * priv = dev -> data -> dev_private ; const char * mode ; struct rte_flow_error error ; switch ( toggle ) { case RXMODE_TOGGLE_PROMISC_OFF : case RXMODE_TOGGLE_PROMISC_ON : mode = "promiscuous" ; dev -> data -> promiscuous = toggle & 1 ; break ; case RXMODE_TOGGLE_ALLMULTI_OFF : case RXMODE_TOGGLE_ALLMULTI_ON : mode = "all<S2SV_blank>multicast" ; dev -> data -> all_multicast = toggle & 1 ; break ; <S2SV_StartBug> } <S2SV_EndBug> if ( ! mlx4_flow_sync ( priv , & error ) ) return ; ERROR ( "cannot<S2SV_blank>toggle<S2SV_blank>%s<S2SV_blank>mode<S2SV_blank>(code<S2SV_blank>%d,<S2SV_blank>\\"%s\\")," "<S2SV_blank>flow<S2SV_blank>error<S2SV_blank>type<S2SV_blank>%d,<S2SV_blank>cause<S2SV_blank>%p,<S2SV_blank>message:<S2SV_blank>%s" , mode , rte_errno , strerror ( rte_errno ) , error . type , error . cause , error . message ? error . message : "(unspecified)" ) ; } | <S2SV_ModStart> ; break ; default : mode = "undefined" ; |
6,384 | CWE-000 static int vdbePmaReadBlob ( PmaReader * p , int nByte , u8 * * ppOut ) { int iBuf ; int nAvail ; if ( p -> aMap ) { * ppOut = & p -> aMap [ p -> iReadOff ] ; p -> iReadOff += nByte ; return SQLITE_OK ; } assert ( p -> aBuffer ) ; iBuf = p -> iReadOff % p -> nBuffer ; if ( iBuf == 0 ) { int nRead ; int rc ; if ( ( p -> iEof - p -> iReadOff ) > ( i64 ) p -> nBuffer ) { nRead = p -> nBuffer ; } else { nRead = ( int ) ( p -> iEof - p -> iReadOff ) ; } assert ( nRead > 0 ) ; rc = sqlite3OsRead ( p -> pFd , p -> aBuffer , nRead , p -> iReadOff ) ; assert ( rc != SQLITE_IOERR_SHORT_READ ) ; if ( rc != SQLITE_OK ) return rc ; } nAvail = p -> nBuffer - iBuf ; if ( nByte <= nAvail ) { * ppOut = & p -> aBuffer [ iBuf ] ; p -> iReadOff += nByte ; } else { int nRem ; if ( p -> nAlloc < nByte ) { u8 * aNew ; int nNew = MAX ( 128 , p -> nAlloc * 2 ) ; while ( nByte > nNew ) nNew = nNew * 2 ; aNew = sqlite3Realloc ( p -> aAlloc , nNew ) ; <S2SV_StartBug> if ( ! aNew ) return SQLITE_NOMEM ; <S2SV_EndBug> p -> nAlloc = nNew ; p -> aAlloc = aNew ; } memcpy ( p -> aAlloc , & p -> aBuffer [ iBuf ] , nAvail ) ; p -> iReadOff += nAvail ; nRem = nByte - nAvail ; while ( nRem > 0 ) { int rc ; int nCopy ; u8 * aNext ; nCopy = nRem ; if ( nRem > p -> nBuffer ) nCopy = p -> nBuffer ; rc = vdbePmaReadBlob ( p , nCopy , & aNext ) ; if ( rc != SQLITE_OK ) return rc ; assert ( aNext != p -> aAlloc ) ; memcpy ( & p -> aAlloc [ nByte - nRem ] , aNext , nCopy ) ; nRem -= nCopy ; } * ppOut = p -> aAlloc ; } return SQLITE_OK ; } | <S2SV_ModStart> aNew ) return SQLITE_NOMEM_BKPT <S2SV_ModEnd> ; p -> |
6,385 | CWE-000 void dmac_init ( void ) { uint64_t tmp ; dmac_commonreg_intclear_u_t intclear ; dmac_cfg_u_t dmac_cfg ; dmac_reset_u_t dmac_reset ; sysctl_clock_enable ( SYSCTL_CLOCK_DMA ) ; dmac_reset . data = readq ( & dmac -> reset ) ; dmac_reset . reset . rst = 1 ; writeq ( dmac_reset . data , & dmac -> reset ) ; while ( dmac_reset . reset . rst ) dmac_reset . data = readq ( & dmac -> reset ) ; intclear . data = readq ( & dmac -> com_intclear ) ; intclear . com_intclear . cear_slvif_dec_err_intstat = 1 ; intclear . com_intclear . clear_slvif_wr2ro_err_intstat = 1 ; intclear . com_intclear . clear_slvif_rd2wo_err_intstat = 1 ; intclear . com_intclear . clear_slvif_wronhold_err_intstat = 1 ; intclear . com_intclear . clear_slvif_undefinedreg_dec_err_intstat = 1 ; writeq ( intclear . data , & dmac -> com_intclear ) ; dmac_cfg . data = readq ( & dmac -> cfg ) ; dmac_cfg . cfg . dmac_en = 0 ; dmac_cfg . cfg . int_en = 0 ; writeq ( dmac_cfg . data , & dmac -> cfg ) ; while ( readq ( & dmac -> cfg ) ) ; tmp = readq ( & dmac -> chen ) ; tmp &= ~ 0xf ; writeq ( tmp , & dmac -> chen ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> chen ) ; dmac_enable ( ) ; |
6,386 | CWE-000 tSirRetStatus convert_wsc_opaque ( tpAniSirGlobal pMac , tSirAddie * pOld , tDot11fIEWscIEOpaque * pNew ) { <S2SV_StartBug> uint8_t curAddIELen = pOld -> length ; <S2SV_EndBug> pOld -> length = curAddIELen + pNew -> num_data + 6 ; pOld -> addIEdata [ curAddIELen ++ ] = 0xdd ; pOld -> addIEdata [ curAddIELen ++ ] = pNew -> num_data + 4 ; pOld -> addIEdata [ curAddIELen ++ ] = 0x00 ; pOld -> addIEdata [ curAddIELen ++ ] = 0x50 ; pOld -> addIEdata [ curAddIELen ++ ] = 0xf2 ; pOld -> addIEdata [ curAddIELen ++ ] = 0x04 ; qdf_mem_copy ( pOld -> addIEdata + curAddIELen , pNew -> data , pNew -> num_data ) ; return eSIR_SUCCESS ; } | <S2SV_ModStart> pNew ) { uint16_t <S2SV_ModEnd> curAddIELen = pOld |
6,387 | CWE-000 static void gthread_segv_trap ( int signum , siginfo_t * info , void * uctx ) { # ifdef __APPLE__ assert ( signum == SIGSEGV || signum == SIGBUS ) ; # else assert ( signum == SIGSEGV ) ; # endif gthread_task_t * current = gthread_task_current ( ) ; Node * page = whichPage ( info -> si_addr ) ; if ( branch_unexpected ( page == NULL ) ) { fprintf ( stderr , "segmentation<S2SV_blank>fault<S2SV_blank>by<S2SV_blank>task<S2SV_blank>%p<S2SV_blank>at<S2SV_blank>address<S2SV_blank>%p\\n" , current , info -> si_addr ) ; fflush ( stderr ) ; if ( restore_signal ( signum ) ) { abort ( ) ; } else { return ; } } if ( branch_unexpected ( page -> thread != current ) ) { fprintf ( stderr , "segmentation<S2SV_blank>fault<S2SV_blank>by<S2SV_blank>task<S2SV_blank>%p<S2SV_blank>accessing<S2SV_blank>memory<S2SV_blank>owned<S2SV_blank>by<S2SV_blank>task<S2SV_blank>%p<S2SV_blank>" "at<S2SV_blank>address<S2SV_blank>%p\\n" , current , page -> thread , info -> si_addr ) ; fflush ( stderr ) ; if ( restore_signal ( signum ) ) { abort ( ) ; } else { return ; } } assert ( ( ( uintptr_t ) page -> page_end_addr - ( uintptr_t ) page -> page_start_addr ) % page_size == 0 ) ; assert ( ( uintptr_t ) page -> page_start_addr % page_size == 0 ) ; <S2SV_StartBug> gthread_malloc_unprotect_region ( <S2SV_EndBug> page -> page_start_addr , ( uintptr_t ) page -> page_end_addr - ( uintptr_t ) page -> page_start_addr ) ; } | <S2SV_ModStart> 0 ) ; page -> protected = FALSE ; |
6,388 | CWE-000 static lily_container_val * build_traceback_raw ( lily_vm_state * vm ) { lily_call_frame * frame_iter = vm -> call_chain ; int depth = vm -> call_depth ; int i ; if ( vm -> include_last_frame_in_trace == 0 ) { depth -- ; frame_iter = frame_iter -> prev ; vm -> include_last_frame_in_trace = 1 ; } <S2SV_StartBug> lily_msgbuf * msgbuf = lily_get_msgbuf ( vm ) ; <S2SV_EndBug> lily_container_val * lv = lily_new_list ( depth ) ; for ( i = depth ; i >= 1 ; i -- , frame_iter = frame_iter -> prev ) { lily_function_val * func_val = frame_iter -> function ; char * path ; char line [ 16 ] = "" ; const char * class_name ; char * separator ; const char * name = func_val -> trace_name ; if ( func_val -> code ) { path = func_val -> module -> path ; sprintf ( line , "%d:" , frame_iter -> line_num ) ; } else path = "[C]" ; if ( func_val -> class_name == NULL ) { class_name = "" ; separator = "" ; } else { separator = "." ; class_name = func_val -> class_name ; } const char * str = lily_mb_sprintf ( msgbuf , "%s:%s<S2SV_blank>from<S2SV_blank>%s%s%s" , path , line , class_name , separator , name ) ; lily_move_string ( lv -> values [ i - 1 ] , lily_new_string ( str ) ) ; } return lv ; } | <S2SV_ModStart> * msgbuf = lily_get_clean_msgbuf <S2SV_ModEnd> ( vm ) |
6,389 | CWE-000 static void _check_node_status ( void ) { json_object * j_obj ; json_object_iter iter ; json_object * j_array = NULL ; json_object * j_value ; char * resp_msg , * * script_argv ; int i , nid , num_ent , retry , status = 0 ; struct node_record * node_ptr ; DEF_TIMERS ; script_argv = xmalloc ( sizeof ( char * ) * 4 ) ; script_argv [ 0 ] = xstrdup ( "capmc" ) ; script_argv [ 1 ] = xstrdup ( "node_status" ) ; for ( retry = 0 ; ; retry ++ ) { START_TIMER ; resp_msg = _run_script ( capmc_path , script_argv , & status ) ; END_TIMER ; if ( debug_flag ) info ( "%s:<S2SV_blank>node_status<S2SV_blank>ran<S2SV_blank>for<S2SV_blank>%s" , __func__ , TIME_STR ) ; _log_script_argv ( script_argv , resp_msg ) ; if ( WIFEXITED ( status ) && ( WEXITSTATUS ( status ) == 0 ) ) break ; error ( "%s:<S2SV_blank>node_status<S2SV_blank>status:%u<S2SV_blank>response:%s" , __func__ , status , resp_msg ) ; if ( resp_msg == NULL ) { info ( "%s:<S2SV_blank>node_status<S2SV_blank>returned<S2SV_blank>no<S2SV_blank>information" , __func__ ) ; _free_script_argv ( script_argv ) ; return ; } if ( strstr ( resp_msg , "Could<S2SV_blank>not<S2SV_blank>lookup" ) && ( retry <= capmc_retries ) ) { sleep ( 1 ) ; xfree ( resp_msg ) ; } else { xfree ( resp_msg ) ; _free_script_argv ( script_argv ) ; return ; } } _free_script_argv ( script_argv ) ; j_obj = json_tokener_parse ( resp_msg ) ; if ( j_obj == NULL ) { error ( "%s:<S2SV_blank>json<S2SV_blank>parser<S2SV_blank>failed<S2SV_blank>on<S2SV_blank>%s" , __func__ , resp_msg ) ; xfree ( resp_msg ) ; return ; <S2SV_StartBug> } <S2SV_EndBug> FREE_NULL_BITMAP ( capmc_node_bitmap ) ; capmc_node_bitmap = bit_alloc ( 100000 ) ; json_object_object_foreachC ( j_obj , iter ) { if ( ! xstrcmp ( iter . key , "e" ) || ! xstrcmp ( iter . key , "err_msg" ) ) continue ; if ( json_object_get_type ( iter . val ) != json_type_array ) continue ; json_object_object_get_ex ( j_obj , iter . key , & j_array ) ; if ( ! j_array ) { error ( "%s:<S2SV_blank>Unable<S2SV_blank>to<S2SV_blank>parse<S2SV_blank>nid<S2SV_blank>specification" , __func__ ) ; FREE_NULL_BITMAP ( capmc_node_bitmap ) ; return ; } num_ent = json_object_array_length ( j_array ) ; for ( i = 0 ; i < num_ent ; i ++ ) { j_value = json_object_array_get_idx ( j_array , i ) ; if ( json_object_get_type ( j_value ) != json_type_int ) { error ( "%s:<S2SV_blank>Unable<S2SV_blank>to<S2SV_blank>parse<S2SV_blank>nid<S2SV_blank>specification" , __func__ ) ; } else { nid = json_object_get_int64 ( j_value ) ; if ( ( nid >= 0 ) && ( nid < 100000 ) ) bit_set ( capmc_node_bitmap , nid ) ; } } } json_object_put ( j_obj ) ; for ( i = 0 , node_ptr = node_record_table_ptr ; i < node_record_count ; i ++ , node_ptr ++ ) { nid = atoi ( node_ptr -> name + 3 ) ; if ( ( nid < 0 ) || ( nid >= 100000 ) || bit_test ( capmc_node_bitmap , nid ) ) continue ; info ( "Node<S2SV_blank>%s<S2SV_blank>not<S2SV_blank>found<S2SV_blank>by<S2SV_blank>\\\'capmc<S2SV_blank>node_status\\\',<S2SV_blank>draining<S2SV_blank>it" , node_ptr -> name ) ; if ( IS_NODE_DOWN ( node_ptr ) || IS_NODE_DRAIN ( node_ptr ) ) continue ; node_ptr -> node_state |= NODE_STATE_DRAIN ; xfree ( node_ptr -> reason ) ; node_ptr -> reason = xstrdup ( "Node<S2SV_blank>not<S2SV_blank>found<S2SV_blank>by<S2SV_blank>capmc" ) ; node_ptr -> reason_time = time ( NULL ) ; node_ptr -> reason_uid = slurm_get_slurm_user_id ( ) ; if ( avail_node_bitmap ) bit_clear ( avail_node_bitmap , i ) ; } } | <S2SV_ModStart> return ; } xfree ( resp_msg ) ; |
6,390 | CWE-000 int afs_fetch_data ( struct afs_vnode * vnode , struct key * key , struct afs_read * desc ) { struct afs_fs_cursor fc ; int ret ; _enter ( "%s{%x:%u.%u},%x,,," , vnode -> volume -> name , vnode -> fid . vid , vnode -> fid . vnode , vnode -> fid . unique , key_serial ( key ) ) ; ret = - ERESTARTSYS ; if ( afs_begin_vnode_operation ( & fc , vnode , key ) ) { while ( afs_select_fileserver ( & fc ) ) { <S2SV_StartBug> fc . cb_break = vnode -> cb_break + vnode -> cb_s_break ; <S2SV_EndBug> afs_fs_fetch_data ( & fc , desc ) ; } afs_check_for_remote_deletion ( & fc , fc . vnode ) ; afs_vnode_commit_status ( & fc , vnode , fc . cb_break ) ; ret = afs_end_vnode_operation ( & fc ) ; } if ( ret == 0 ) { afs_stat_v ( vnode , n_fetches ) ; atomic_long_add ( desc -> actual_len , & afs_v2net ( vnode ) -> n_fetch_bytes ) ; } _leave ( "<S2SV_blank>=<S2SV_blank>%d" , ret ) ; return ret ; } | <S2SV_ModStart> . cb_break = afs_calc_vnode_cb_break ( vnode ) <S2SV_ModEnd> ; afs_fs_fetch_data ( |
6,391 | CWE-000 static void kvm_setup_pvclock_page ( struct kvm_vcpu * v ) { struct kvm_vcpu_arch * vcpu = & v -> arch ; struct pvclock_vcpu_time_info guest_hv_clock ; if ( unlikely ( kvm_read_guest_cached ( v -> kvm , & vcpu -> pv_time , & guest_hv_clock , sizeof ( guest_hv_clock ) ) ) ) return ; BUILD_BUG_ON ( offsetof ( struct pvclock_vcpu_time_info , version ) != 0 ) ; <S2SV_StartBug> vcpu -> hv_clock . version = guest_hv_clock . version + 1 ; <S2SV_EndBug> kvm_write_guest_cached ( v -> kvm , & vcpu -> pv_time , & vcpu -> hv_clock , sizeof ( vcpu -> hv_clock . version ) ) ; smp_wmb ( ) ; vcpu -> hv_clock . flags |= ( guest_hv_clock . flags & PVCLOCK_GUEST_STOPPED ) ; if ( vcpu -> pvclock_set_guest_stopped_request ) { vcpu -> hv_clock . flags |= PVCLOCK_GUEST_STOPPED ; vcpu -> pvclock_set_guest_stopped_request = false ; } trace_kvm_pvclock_update ( v -> vcpu_id , & vcpu -> hv_clock ) ; kvm_write_guest_cached ( v -> kvm , & vcpu -> pv_time , & vcpu -> hv_clock , sizeof ( vcpu -> hv_clock ) ) ; smp_wmb ( ) ; vcpu -> hv_clock . version ++ ; kvm_write_guest_cached ( v -> kvm , & vcpu -> pv_time , & vcpu -> hv_clock , sizeof ( vcpu -> hv_clock . version ) ) ; } | <S2SV_ModStart> 0 ) ; if ( guest_hv_clock . version & 1 ) ++ guest_hv_clock . version ; |
6,392 | CWE-000 static int ext4_valid_extent ( struct inode * inode , struct ext4_extent * ext ) { ext4_fsblk_t block = ext4_ext_pblock ( ext ) ; int len = ext4_ext_get_actual_len ( ext ) ; ext4_lblk_t lblock = le32_to_cpu ( ext -> ee_block ) ; <S2SV_StartBug> ext4_lblk_t last = lblock + len - 1 ; <S2SV_EndBug> if ( lblock > last ) return 0 ; return ext4_data_block_valid ( EXT4_SB ( inode -> i_sb ) , block , len ) ; } | <S2SV_ModStart> ee_block ) ; if ( <S2SV_ModEnd> lblock + len <S2SV_ModStart> lblock + len <= lblock <S2SV_ModEnd> ) return 0 |
6,393 | CWE-000 static inline int vnc_wait_connect ( int display ) { int errcode ; <S2SV_StartBug> int result ; <S2SV_EndBug> while ( g_vnc_sessions [ display ] == NULL || g_vnc_sessions [ display ] -> state != VNCSERVER_RUNNING ) { do { ret = nxsem_wait ( & g_fbstartup [ display ] . fbconnect ) ; if ( ret < 0 && ret != - EINTR ) { return ret ; } } while ( ret == - EINTR ) ; <S2SV_StartBug> result = g_fbstartup [ display ] . result ; <S2SV_EndBug> <S2SV_StartBug> if ( result != - EBUSY ) <S2SV_EndBug> { # ifdef CONFIG_DEBUG_FEATURES <S2SV_StartBug> if ( result < 0 ) <S2SV_EndBug> { DEBUGASSERT ( g_vnc_sessions [ display ] == NULL ) ; <S2SV_StartBug> gerr ( "ERROR:<S2SV_blank>VNC<S2SV_blank>server<S2SV_blank>startup<S2SV_blank>failed:<S2SV_blank>%d\\n" , result ) ; <S2SV_EndBug> } else { DEBUGASSERT ( g_vnc_sessions [ display ] != NULL && g_vnc_sessions [ display ] -> state == VNCSERVER_RUNNING ) ; } # endif <S2SV_StartBug> return result ; <S2SV_EndBug> } } return OK ; } | <S2SV_ModStart> errcode ; int ret <S2SV_ModEnd> ; while ( <S2SV_ModStart> EINTR ) ; ret <S2SV_ModEnd> = g_fbstartup [ <S2SV_ModStart> ; if ( ret <S2SV_ModEnd> != - EBUSY <S2SV_ModStart> CONFIG_DEBUG_FEATURES if ( ret <S2SV_ModEnd> < 0 ) <S2SV_ModStart> ( "ERROR:<S2SV_blank>VNC<S2SV_blank>server<S2SV_blank>startup<S2SV_blank>failed:<S2SV_blank>%d\\n" , ret <S2SV_ModEnd> ) ; } <S2SV_ModStart> # endif return ret <S2SV_ModEnd> ; } } |
6,394 | CWE-000 void WebBrowserTest ( void ) { Ihandle * txt , * dlg , * web ; Ihandle * btLoad , * btReload , * btBack , * btForward , * btStop ; # ifndef WIN32 Ihandle * history ; # endif IupWebBrowserOpen ( ) ; web = IupWebBrowser ( ) ; dlg = IupDialog ( IupVbox ( IupHbox ( btBack = IupButton ( "Back" , NULL ) , btForward = IupButton ( "Forward" , NULL ) , txt = IupText ( "" ) , btLoad = IupButton ( "Load" , NULL ) , btReload = IupButton ( "Reload" , NULL ) , btStop = IupButton ( "Stop" , NULL ) , # ifndef WIN32 history = IupButton ( "History" , NULL ) , # endif NULL ) , web , NULL ) ) ; IupSetAttribute ( dlg , "TITLE" , "IupWebBrowser" ) ; IupSetAttribute ( dlg , "MY_TEXT" , ( char * ) txt ) ; IupSetAttribute ( dlg , "MY_WEB" , ( char * ) web ) ; IupSetAttribute ( dlg , "RASTERSIZE" , "800x600" ) ; IupSetAttribute ( dlg , "MARGIN" , "10x10" ) ; IupSetAttribute ( dlg , "GAP" , "10" ) ; <S2SV_StartBug> IupSetAttribute ( txt , "VALUE" , "http://www.tecgraf.puc-rio.br/iup" ) ; <S2SV_EndBug> IupSetAttribute ( web , "VALUE" , IupGetAttribute ( txt , "VALUE" ) ) ; IupSetAttributeHandle ( dlg , "DEFAULTENTER" , btLoad ) ; IupSetAttribute ( txt , "EXPAND" , "HORIZONTAL" ) ; IupSetCallback ( btLoad , "ACTION" , ( Icallback ) load_cb ) ; IupSetCallback ( btReload , "ACTION" , ( Icallback ) reload_cb ) ; IupSetCallback ( btBack , "ACTION" , ( Icallback ) back_cb ) ; IupSetCallback ( btForward , "ACTION" , ( Icallback ) forward_cb ) ; IupSetCallback ( btStop , "ACTION" , ( Icallback ) stop_cb ) ; # ifndef WIN32 IupSetCallback ( history , "ACTION" , ( Icallback ) history_cb ) ; <S2SV_StartBug> # endif <S2SV_EndBug> IupSetCallback ( web , "NEWWINDOW_CB" , ( Icallback ) newwindow_cb ) ; IupSetCallback ( web , "NAVIGATE_CB" , ( Icallback ) navigate_cb ) ; IupSetCallback ( web , "ERROR_CB" , ( Icallback ) error_cb ) ; IupSetCallback ( web , "COMPLETED_CB" , ( Icallback ) completed_cb ) ; IupShow ( dlg ) ; } | <S2SV_ModStart> , "VALUE" , "https://www.google.com" <S2SV_ModEnd> ) ; IupSetAttribute <S2SV_ModStart> history_cb ) ; IupSetAttribute ( history , "MY_WEB" , ( char * ) web ) ; |
6,395 | CWE-000 static sqInt NoDbgRegParms blockDispatchTargetsForperformarg ( CogMethod * cogMethod , usqInt ( * binaryFunction ) ( sqInt mcpc , sqInt arg ) , sqInt arg ) { sqInt blockEntry ; <S2SV_StartBug> sqInt end ; <S2SV_EndBug> sqInt pc ; sqInt result ; usqInt targetpc ; if ( ( ( cogMethod -> blockEntryOffset ) ) == 0 ) { return null ; } blockEntry = ( ( cogMethod -> blockEntryOffset ) ) + ( ( ( sqInt ) cogMethod ) ) ; pc = blockEntry ; end = ( mapEndFor ( cogMethod ) ) - 1 ; while ( pc < end ) { if ( isJumpAt ( backEnd , pc ) ) { targetpc = jumpTargetPCAt ( backEnd , pc ) ; if ( targetpc < blockEntry ) { result = binaryFunction ( targetpc , arg ) ; if ( result != 0 ) { return result ; } } } pc += 4 ; } return 0 ; } | <S2SV_ModStart> sqInt blockEntry ; usqInt <S2SV_ModEnd> end ; sqInt |
6,396 | CWE-000 EFI_STATUS PxeBcCacheDhcp4Offer ( IN PXEBC_PRIVATE_DATA * Private , IN EFI_DHCP4_PACKET * RcvdOffer ) { PXEBC_DHCP4_PACKET_CACHE * Cache4 ; EFI_DHCP4_PACKET * Offer ; PXEBC_OFFER_TYPE OfferType ; EFI_STATUS Status ; ASSERT ( Private -> OfferNum < PXEBC_OFFER_MAX_NUM ) ; Cache4 = & Private -> OfferBuffer [ Private -> OfferNum ] . Dhcp4 ; Offer = & Cache4 -> Packet . Offer ; Status = PxeBcCacheDhcp4Packet ( Offer , RcvdOffer ) ; if ( EFI_ERROR ( Status ) ) { return Status ; } if ( EFI_ERROR ( PxeBcParseDhcp4Packet ( Cache4 ) ) ) { return EFI_ABORTED ; } OfferType = Cache4 -> OfferType ; ASSERT ( OfferType < PxeOfferTypeMax ) ; if ( OfferType == PxeOfferTypeBootp ) { if ( Private -> OfferCount [ OfferType ] == 0 ) { Private -> OfferIndex [ OfferType ] [ 0 ] = Private -> OfferNum ; Private -> OfferCount [ OfferType ] = 1 ; } else { return EFI_ABORTED ; } } else { ASSERT ( Private -> OfferCount [ OfferType ] < PXEBC_OFFER_MAX_NUM ) ; if ( IS_PROXY_DHCP_OFFER ( Offer ) ) { Private -> IsProxyRecved = TRUE ; if ( OfferType == PxeOfferTypeProxyBinl ) { Private -> OfferIndex [ OfferType ] [ Private -> OfferCount [ OfferType ] ] = Private -> OfferNum ; Private -> OfferCount [ OfferType ] ++ ; <S2SV_StartBug> } else if ( Private -> OfferCount [ OfferType ] > 0 ) { <S2SV_EndBug> <S2SV_StartBug> Private -> OfferIndex [ OfferType ] [ 0 ] = Private -> OfferNum ; <S2SV_EndBug> Private -> OfferCount [ OfferType ] = 1 ; } else { return EFI_ABORTED ; } } else { Private -> OfferIndex [ OfferType ] [ Private -> OfferCount [ OfferType ] ] = Private -> OfferNum ; Private -> OfferCount [ OfferType ] ++ ; } } Private -> OfferNum ++ ; return EFI_SUCCESS ; } | <S2SV_ModStart> else if ( ( OfferType == PxeOfferTypeProxyPxe10 || OfferType == PxeOfferTypeProxyWfm11a ) && Private -> OfferCount [ OfferType ] < 1 ) { Private -> OfferIndex [ OfferType ] [ 0 ] = Private -> OfferNum ; Private -> OfferCount [ OfferType ] = 1 ; } else { return EFI_ABORTED ; } } else <S2SV_ModEnd> { Private -> <S2SV_ModStart> OfferType ] [ <S2SV_ModEnd> Private -> OfferCount |
6,397 | CWE-000 <S2SV_StartBug> static int __cpufreq_remove_dev_prepare ( struct device * dev , <S2SV_EndBug> struct subsys_interface * sif ) { unsigned int cpu = dev -> id ; int ret = 0 ; struct cpufreq_policy * policy ; pr_debug ( "%s:<S2SV_blank>unregistering<S2SV_blank>CPU<S2SV_blank>%u\\n" , __func__ , cpu ) ; policy = cpufreq_cpu_get_raw ( cpu ) ; if ( ! policy ) { pr_debug ( "%s:<S2SV_blank>No<S2SV_blank>cpu_data<S2SV_blank>found\\n" , __func__ ) ; return - EINVAL ; } if ( has_target ( ) ) { ret = __cpufreq_governor ( policy , CPUFREQ_GOV_STOP ) ; <S2SV_StartBug> if ( ret ) { <S2SV_EndBug> pr_err ( "%s:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>stop<S2SV_blank>governor\\n" , __func__ ) ; <S2SV_StartBug> return ret ; <S2SV_EndBug> } } down_write ( & policy -> rwsem ) ; cpumask_clear_cpu ( cpu , policy -> cpus ) ; if ( policy_is_inactive ( policy ) ) { if ( has_target ( ) ) strncpy ( policy -> last_governor , policy -> governor -> name , CPUFREQ_NAME_LEN ) ; } else if ( cpu == policy -> cpu ) { policy -> cpu = cpumask_any ( policy -> cpus ) ; } up_write ( & policy -> rwsem ) ; if ( ! policy_is_inactive ( policy ) ) { if ( has_target ( ) ) { ret = __cpufreq_governor ( policy , CPUFREQ_GOV_START ) ; if ( ! ret ) ret = __cpufreq_governor ( policy , CPUFREQ_GOV_LIMITS ) ; if ( ret ) pr_err ( "%s:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>start<S2SV_blank>governor\\n" , __func__ ) ; } } else if ( cpufreq_driver -> stop_cpu ) { cpufreq_driver -> stop_cpu ( policy ) ; } return ret ; } | <S2SV_ModStart> device * dev <S2SV_ModEnd> ) { unsigned <S2SV_ModStart> ( ret ) <S2SV_ModEnd> pr_err ( "%s:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>stop<S2SV_blank>governor\\n" <S2SV_ModStart> __func__ ) ; <S2SV_ModEnd> } down_write ( |
6,398 | CWE-000 static int refresh_one ( const char * controller , const char * path , Hashmap * a , Hashmap * b , unsigned iteration , unsigned depth , Group * * ret ) { _cleanup_closedir_ DIR * d = NULL ; Group * ours = NULL ; int r ; assert ( controller ) ; assert ( path ) ; assert ( a ) ; if ( depth > arg_depth ) return 0 ; r = process ( controller , path , a , b , iteration , & ours ) ; if ( r < 0 ) return r ; r = cg_enumerate_subgroups ( controller , path , & d ) ; if ( r == - ENOENT ) return 0 ; if ( r < 0 ) return r ; for ( ; ; ) { _cleanup_free_ char * fn = NULL , * p = NULL ; Group * child = NULL ; r = cg_read_subgroup ( d , & fn ) ; if ( r < 0 ) return r ; if ( r == 0 ) break ; <S2SV_StartBug> p = strjoin ( path , "/" , fn , NULL ) ; <S2SV_EndBug> if ( ! p ) return - ENOMEM ; path_kill_slashes ( p ) ; r = refresh_one ( controller , p , a , b , iteration , depth + 1 , & child ) ; if ( r < 0 ) return r ; if ( arg_recursive && IN_SET ( arg_count , COUNT_ALL_PROCESSES , COUNT_USERSPACE_PROCESSES ) && child && child -> n_tasks_valid && streq ( controller , SYSTEMD_CGROUP_CONTROLLER ) ) { if ( ours -> n_tasks_valid ) ours -> n_tasks += child -> n_tasks ; else { ours -> n_tasks = child -> n_tasks ; ours -> n_tasks_valid = true ; } } } if ( ret ) * ret = ours ; return 1 ; } | <S2SV_ModStart> "/" , fn <S2SV_ModEnd> ) ; if |
6,399 | CWE-000 static void hub_activate ( struct usb_hub * hub , enum hub_activation_type type ) { struct usb_device * hdev = hub -> hdev ; struct usb_hcd * hcd ; int ret ; int port1 ; int status ; bool need_debounce_delay = false ; unsigned delay ; if ( type == HUB_INIT2 ) goto init2 ; if ( type == HUB_INIT3 ) goto init3 ; if ( type != HUB_RESUME ) { if ( type == HUB_INIT ) { delay = hub_power_on ( hub , false ) ; PREPARE_DELAYED_WORK ( & hub -> init_work , hub_init_func2 ) ; schedule_delayed_work ( & hub -> init_work , msecs_to_jiffies ( delay ) ) ; usb_autopm_get_interface_no_resume ( to_usb_interface ( hub -> intfdev ) ) ; return ; } else if ( type == HUB_RESET_RESUME ) { hcd = bus_to_hcd ( hdev -> bus ) ; if ( hcd -> driver -> update_hub_device ) { ret = hcd -> driver -> update_hub_device ( hcd , hdev , & hub -> tt , GFP_NOIO ) ; if ( ret < 0 ) { dev_err ( hub -> intfdev , "Host<S2SV_blank>not<S2SV_blank>" "accepting<S2SV_blank>hub<S2SV_blank>info<S2SV_blank>" "update.\\n" ) ; dev_err ( hub -> intfdev , "LS/FS<S2SV_blank>devices<S2SV_blank>" "and<S2SV_blank>hubs<S2SV_blank>may<S2SV_blank>not<S2SV_blank>work<S2SV_blank>" "under<S2SV_blank>this<S2SV_blank>hub\\n." ) ; } } hub_power_on ( hub , true ) ; } else { hub_power_on ( hub , true ) ; } } init2 : for ( port1 = 1 ; port1 <= hdev -> maxchild ; ++ port1 ) { struct usb_device * udev = hdev -> children [ port1 - 1 ] ; u16 portstatus , portchange ; portstatus = portchange = 0 ; status = hub_port_status ( hub , port1 , & portstatus , & portchange ) ; if ( udev || ( portstatus & USB_PORT_STAT_CONNECTION ) ) dev_dbg ( hub -> intfdev , "port<S2SV_blank>%d:<S2SV_blank>status<S2SV_blank>%04x<S2SV_blank>change<S2SV_blank>%04x\\n" , port1 , portstatus , portchange ) ; if ( ( portstatus & USB_PORT_STAT_ENABLE ) && ( type != HUB_RESUME || ! ( portstatus & USB_PORT_STAT_CONNECTION ) || ! udev || udev -> state == USB_STATE_NOTATTACHED ) ) { if ( ! hub_is_superspeed ( hdev ) ) { clear_port_feature ( hdev , port1 , USB_PORT_FEAT_ENABLE ) ; portstatus &= ~ USB_PORT_STAT_ENABLE ; } else { portstatus &= ~ USB_PORT_STAT_ENABLE ; } } if ( portchange & USB_PORT_STAT_C_CONNECTION ) { need_debounce_delay = true ; clear_port_feature ( hub -> hdev , port1 , USB_PORT_FEAT_C_CONNECTION ) ; } if ( portchange & USB_PORT_STAT_C_ENABLE ) { need_debounce_delay = true ; clear_port_feature ( hub -> hdev , port1 , USB_PORT_FEAT_C_ENABLE ) ; } if ( portchange & USB_PORT_STAT_C_LINK_STATE ) { need_debounce_delay = true ; clear_port_feature ( hub -> hdev , port1 , USB_PORT_FEAT_C_PORT_LINK_STATE ) ; } <S2SV_StartBug> if ( ! ( portstatus & USB_PORT_STAT_CONNECTION ) || <S2SV_EndBug> ( portchange & USB_PORT_STAT_C_CONNECTION ) ) clear_bit ( port1 , hub -> removed_bits ) ; if ( ! udev || udev -> state == USB_STATE_NOTATTACHED ) { if ( udev || ( portstatus & USB_PORT_STAT_CONNECTION ) ) set_bit ( port1 , hub -> change_bits ) ; } else if ( portstatus & USB_PORT_STAT_ENABLE ) { if ( portchange ) set_bit ( port1 , hub -> change_bits ) ; } else if ( udev -> persist_enabled ) { # ifdef CONFIG_PM udev -> reset_resume = 1 ; # endif set_bit ( port1 , hub -> change_bits ) ; } else { usb_set_device_state ( udev , USB_STATE_NOTATTACHED ) ; set_bit ( port1 , hub -> change_bits ) ; } } if ( need_debounce_delay ) { delay = HUB_DEBOUNCE_STABLE ; if ( type == HUB_INIT2 ) { PREPARE_DELAYED_WORK ( & hub -> init_work , hub_init_func3 ) ; schedule_delayed_work ( & hub -> init_work , msecs_to_jiffies ( delay ) ) ; return ; } else { msleep ( delay ) ; } } init3 : hub -> quiescing = 0 ; status = usb_submit_urb ( hub -> urb , GFP_NOIO ) ; if ( status < 0 ) dev_err ( hub -> intfdev , "activate<S2SV_blank>--><S2SV_blank>%d\\n" , status ) ; if ( hub -> has_indicators && blinkenlights ) schedule_delayed_work ( & hub -> leds , LED_CYCLE_PERIOD ) ; kick_khubd ( hub ) ; if ( type <= HUB_INIT3 ) usb_autopm_put_interface_async ( to_usb_interface ( hub -> intfdev ) ) ; } | <S2SV_ModStart> } if ( ( portchange & USB_PORT_STAT_C_BH_RESET ) && hub_is_superspeed ( hub -> hdev ) ) { need_debounce_delay = true ; clear_port_feature ( hub -> hdev , port1 , USB_PORT_FEAT_C_BH_PORT_RESET ) ; } if ( |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.