Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
6,200 | CWE-000 eHalStatus csrGetSnr ( tpAniSirGlobal pMac , tCsrSnrCallback callback , tANI_U8 staId , tCsrBssid bssId , void * pContext ) { eHalStatus status = eHAL_STATUS_SUCCESS ; vos_msg_t msg ; <S2SV_StartBug> tANI_U32 sessionId ; <S2SV_EndBug> tAniGetSnrReq * pMsg ; smsLog ( pMac , LOG2 , FL ( "called" ) ) ; pMsg = ( tAniGetSnrReq * ) vos_mem_malloc ( sizeof ( tAniGetSnrReq ) ) ; if ( NULL == pMsg ) { smsLog ( pMac , LOGE , "%s:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>mem<S2SV_blank>for<S2SV_blank>req" , __func__ ) ; return status ; } csrRoamGetSessionIdFromBSSID ( pMac , ( tCsrBssid * ) bssId , & sessionId ) ; pMsg -> msgType = pal_cpu_to_be16 ( ( tANI_U16 ) eWNI_SME_GET_SNR_REQ ) ; pMsg -> msgLen = ( tANI_U16 ) sizeof ( tAniGetSnrReq ) ; pMsg -> sessionId = sessionId = 0 ; pMsg -> staId = staId ; pMsg -> snrCallback = callback ; pMsg -> pDevContext = pContext ; msg . type = eWNI_SME_GET_SNR_REQ ; msg . bodyptr = pMsg ; msg . reserved = 0 ; if ( VOS_STATUS_SUCCESS != vos_mq_post_message ( VOS_MQ_ID_SME , & msg ) ) { smsLog ( pMac , LOGE , "%s<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>post<S2SV_blank>msg<S2SV_blank>to<S2SV_blank>self" , __func__ ) ; vos_mem_free ( ( v_VOID_t * ) pMsg ) ; status = eHAL_STATUS_FAILURE ; } smsLog ( pMac , LOG2 , FL ( "returned" ) ) ; return status ; } | <S2SV_ModStart> ; tANI_U32 sessionId = 0 |
6,201 | CWE-000 task controller ( ) { while ( true ) { if ( driveIsActive ) { lDrivePwr = vexRT [ Ch3 ] ; rDrivePwr = vexRT [ Ch2 ] ; if ( abs ( lDrivePwr ) < 5 ) lDrivePwr = 0 ; else if ( abs ( rDrivePwr ) < 5 ) rDrivePwr = 0 ; motor [ leftB ] = motor [ leftF ] = lDrivePwr ; motor [ rightB ] = motor [ rightF ] = rDrivePwr ; } if ( moGoIsManual ) { stopTask ( moGoSet ) ; if ( moGoIsActive ) { if ( vexRT [ Btn7U ] ) mGoalPwr = 100 ; else if ( vexRT [ Btn7D ] ) { if ( SensorValue ( moGoPot ) < MOGO_UP - 300 ) mGoalPwr = - 100 ; else if ( SensorValue ( moGoPot ) < MOGO_UP ) mGoalPwr = - 40 ; else mGoalPwr = 0 ; } else mGoalPwr = 0 ; motor [ moGo ] = mGoalPwr ; } } else { startTask ( moGoSet ) ; if ( moGoIsActive ) { if ( vexRT [ Btn7U ] ) <S2SV_StartBug> mGoalIsUp = true ; <S2SV_EndBug> else if ( vexRT [ Btn7D ] && cones < 9 ) <S2SV_StartBug> mGoalIsUp = false ; <S2SV_EndBug> else if ( vexRT [ Btn7D ] && cones >= 9 ) place ( ) ; } } if ( liftIsActive ) { if ( vexRT [ Btn6U ] ) lLiftPwr = rLiftPwr = 100 ; else if ( vexRT [ Btn6D ] ) lLiftPwr = rLiftPwr = - 100 ; else { if ( SensorValue ( liftPot ) > LIFT_MIN + 100 ) lLiftPwr = rLiftPwr = - 2 ; else lLiftPwr = rLiftPwr = - 10 ; } motor [ lLift ] = lLiftPwr ; motor [ rLift ] = rLiftPwr ; } if ( barIsManual ) { stopTask ( barSet ) ; if ( barIsActive ) { if ( vexRT [ Btn8U ] ) barPwr = 100 ; else if ( vexRT [ Btn8D ] ) barPwr = - 100 ; else barPwr = 0 ; motor [ barR ] = motor [ barL ] = barPwr ; } } else { startTask ( barSet ) ; if ( barIsActive ) { if ( vexRT [ Btn8U ] ) barIsUp = true ; else if ( vexRT [ Btn8D ] ) barIsUp = false ; } } if ( intakeIsActive ) { if ( vexRT [ Btn7L ] ) { intakePwr = - 100 ; intakeIsHolding = false ; } else if ( vexRT [ Btn7R ] ) { intakePwr = 100 ; intakeIsHolding = true ; } else if ( intakeIsHolding ) intakePwr = INTAKE_HOLD ; else if ( ! intakeIsHolding ) intakePwr = - 10 ; motor [ intake ] = intakePwr ; } } } | <S2SV_ModStart> Btn7U ] ) moGoIsUp <S2SV_ModEnd> = true ; <S2SV_ModStart> < 9 ) moGoIsUp <S2SV_ModEnd> = false ; |
6,202 | CWE-000 <S2SV_StartBug> void IN_DownUp ( void ) { KeyUp ( & in_down ) ; } <S2SV_EndBug> | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static |
6,203 | CWE-000 LIS_INT lis_sor_check_params ( LIS_SOLVER solver ) { LIS_SCALAR w ; LIS_DEBUG_FUNC_IN ; <S2SV_StartBug> w = solver -> params [ LIS_PARAMS_W - LIS_OPTIONS_LEN ] ; <S2SV_EndBug> if ( fabs ( w ) <= 0 || fabs ( w ) >= 2 ) { <S2SV_StartBug> LIS_SETERR1 ( LIS_ERR_ILL_ARG , "Parameter<S2SV_blank>LIS_PARAMS_W<S2SV_blank>is<S2SV_blank>%f<S2SV_blank>(set<S2SV_blank>0<S2SV_blank><<S2SV_blank>w<S2SV_blank><<S2SV_blank>2)\\n" , ( double ) w ) ; <S2SV_EndBug> return LIS_ERR_ILL_ARG ; } LIS_DEBUG_FUNC_OUT ; return LIS_SUCCESS ; } | <S2SV_ModStart> -> params [ LIS_PARAMS_SSOR_W <S2SV_ModEnd> - LIS_OPTIONS_LEN ] <S2SV_ModStart> ( LIS_ERR_ILL_ARG , "Parameter<S2SV_blank>LIS_PARAMS_SSOR_W<S2SV_blank>is<S2SV_blank>%f<S2SV_blank>(set<S2SV_blank>0<S2SV_blank><<S2SV_blank>w<S2SV_blank><<S2SV_blank>2)\\n" <S2SV_ModEnd> , ( double |
6,204 | CWE-000 static void test_dict_big ( unsigned long n ) { rand_init ( ) ; khash_t ( iub ) * dict = kh_init ( iub ) ; for ( size_t i = 0 ; i < n ; i ++ ) { int ret ; char_array_t s1 , s2 ; sprintf ( s1 . a , "%u" , rand_get ( ) ) ; sprintf ( s2 . a , "%u" , rand_get ( ) ) ; khiter_t k = kh_put ( iub , dict , s1 , & ret ) ; char_set ( & kh_value ( dict , k ) , s2 ) ; } unsigned int s = 0 ; for ( size_t i = 0 ; i < n ; i ++ ) { char_array_t s1 ; sprintf ( s1 . a , "%u" , rand_get ( ) ) ; khiter_t k = kh_get ( iub , dict , s1 ) ; if ( kh_exist ( dict , k ) ) s ++ ; } <S2SV_StartBug> kh_destroy ( iub , dict ) ; <S2SV_EndBug> } | <S2SV_ModStart> ++ ; } g_result = s ; |
6,205 | CWE-000 <S2SV_StartBug> static DRIVER_INIT ( ftsoccer ) { <S2SV_EndBug> snk_sound_busy_bit = 0x08 ; snk_io = tdfever_io ; hard_flags = 0 ; snk_bg_tilemap_baseaddr = 0xd800 ; <S2SV_StartBug> snk_gamegroup = 7 ; <S2SV_EndBug> } | <S2SV_ModStart> static DRIVER_INIT ( tdfever2 <S2SV_ModEnd> ) { snk_sound_busy_bit <S2SV_ModStart> ; snk_gamegroup = ( ! strcmp ( Machine -> gamedrv -> name , "tdfeverj" ) ) ? 5 : 3 ; snk_irq_delay = 1000 <S2SV_ModEnd> ; } <S2SV_null> |
6,206 | CWE-000 bool ixl_txeof ( struct ixl_queue * que ) { struct tx_ring * txr = & que -> txr ; u32 first , last , head , done , processed ; struct ixl_tx_buf * buf ; struct i40e_tx_desc * tx_desc , * eop_desc ; mtx_assert ( & txr -> mtx , MA_OWNED ) ; # ifdef DEV_NETMAP if ( netmap_tx_irq ( que -> vsi -> ifp , que -> me ) ) return FALSE ; # endif if ( txr -> avail == que -> num_desc ) { atomic_store_rel_32 ( & txr -> watchdog_timer , 0 ) ; return FALSE ; } processed = 0 ; first = txr -> next_to_clean ; buf = & txr -> buffers [ first ] ; tx_desc = ( struct i40e_tx_desc * ) & txr -> base [ first ] ; last = buf -> eop_index ; if ( last == - 1 ) return FALSE ; eop_desc = ( struct i40e_tx_desc * ) & txr -> base [ last ] ; bus_dmamap_sync ( txr -> dma . tag , txr -> dma . map , BUS_DMASYNC_POSTREAD ) ; head = ixl_get_tx_head ( que ) ; if ( ++ last == que -> num_desc ) last = 0 ; done = last ; while ( first != head ) { while ( first != done ) { ++ txr -> avail ; ++ processed ; if ( buf -> m_head ) { txr -> bytes += buf -> m_head -> m_pkthdr . len ; txr -> tx_bytes += buf -> m_head -> m_pkthdr . len ; bus_dmamap_sync ( buf -> tag , buf -> map , BUS_DMASYNC_POSTWRITE ) ; bus_dmamap_unload ( buf -> tag , buf -> map ) ; m_freem ( buf -> m_head ) ; buf -> m_head = NULL ; } buf -> eop_index = - 1 ; if ( ++ first == que -> num_desc ) first = 0 ; buf = & txr -> buffers [ first ] ; tx_desc = & txr -> base [ first ] ; } ++ txr -> packets ; <S2SV_StartBug> last = buf -> eop_index ; <S2SV_EndBug> if ( last != - 1 ) { eop_desc = & txr -> base [ last ] ; if ( ++ last == que -> num_desc ) last = 0 ; done = last ; } else break ; } bus_dmamap_sync ( txr -> dma . tag , txr -> dma . map , BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE ) ; txr -> next_to_clean = first ; if ( txr -> avail == que -> num_desc ) { atomic_store_rel_32 ( & txr -> watchdog_timer , 0 ) ; return FALSE ; } return TRUE ; } | <S2SV_ModStart> -> packets ; atomic_store_rel_32 ( & txr -> watchdog_timer , IXL_WATCHDOG ) ; |
6,207 | CWE-000 <S2SV_StartBug> int logstore_read_record ( logstore_t * logstore , off_t location , logrecord_t * logrecord ) { <S2SV_EndBug> int rfd = logstore -> fd ; int size = readBufferCache ; while ( size > 0 ) { ssize_t n = pread ( rfd , logstore -> readbuf , size , location ) ; if ( n == - 1 ) { return - 1 ; } if ( n == 0 ) { break ; } size -= n ; location += n ; } <S2SV_StartBug> uint32_t length = decode_fixed32 ( logstore -> readbuf ) ; <S2SV_EndBug> char * content = malloc ( sizeof ( char ) * length ) ; if ( content == NULL ) { return - 1 ; } int bufrealsize = length > readBufferCache - 4 ? readBufferCache - 4 : length ; memcpy ( content , logstore -> readbuf + 4 , bufrealsize ) ; int remain = length - bufrealsize ; while ( remain > 0 ) { ssize_t n = pread ( rfd , content + bufrealsize , remain , location ) ; if ( n == - 1 ) { return - 1 ; } if ( n == 0 ) { break ; } remain -= n ; location += n ; } assert ( remain == 0 ) ; logrecord -> size = length ; logrecord -> buf = content ; return 0 ; } | <S2SV_ModStart> * logstore , uint64_t <S2SV_ModEnd> location , logrecord_t <S2SV_ModStart> = decode_fixed32 ( ( const char * ) |
6,208 | CWE-000 void loadLastMoveSquare ( void ) { const SDL_PixelFormat fmt = * ( screenSurface -> format ) ; <S2SV_StartBug> SDL_Surface * lastMoveSurf = SDL_CreateRGBSurface ( 0 , 10 , 10 , fmt . BitsPerPixel , fmt . Rmask , fmt . Gmask , fmt . Bmask , fmt . Amask ) ; <S2SV_EndBug> <S2SV_StartBug> SDL_FillRect ( lastMoveSurf , NULL , lastMoveColor ) ; <S2SV_EndBug> SDL_DestroyTexture ( lastMoveSquare ) ; lastMoveSquare = SDL_CreateTextureFromSurface ( renderer , lastMoveSurf ) ; SDL_SetTextureBlendMode ( lastMoveSquare , SDL_BLENDMODE_BLEND ) ; <S2SV_StartBug> SDL_SetTextureAlphaMod ( lastMoveSquare , lastMoveTransparency ) ; <S2SV_EndBug> SDL_FreeSurface ( lastMoveSurf ) ; } | <S2SV_ModStart> . BitsPerPixel , 0xff000000 , 0xff0000 , 0xff00 , 0xff <S2SV_ModEnd> ) ; SDL_FillRect <S2SV_ModStart> , NULL , SDL_MapRGBA ( lastMoveSurf -> format , lastMoveColor [ 0 ] , lastMoveColor [ 1 ] , lastMoveColor [ 2 ] , lastMoveColor [ 3 ] ) ) ; SDL_Rect dest = { 1 , 1 , 8 , 8 } ; SDL_FillRect ( lastMoveSurf , & dest , SDL_MapRGBA ( lastMoveSurf -> format , 0 , 0 , 0 , 0 ) <S2SV_ModEnd> ) ; SDL_DestroyTexture <S2SV_ModStart> SDL_BLENDMODE_BLEND ) ; <S2SV_ModEnd> SDL_FreeSurface ( lastMoveSurf |
6,209 | CWE-000 <S2SV_StartBug> void nvc_svm_cleanup ( noir_hypervisor_p hvm ) <S2SV_EndBug> { <S2SV_StartBug> if ( hvm -> virtual_cpu ) <S2SV_EndBug> { u32 i = 0 ; <S2SV_StartBug> for ( ; i < hvm -> cpu_count ; i ++ ) <S2SV_EndBug> { <S2SV_StartBug> noir_svm_vcpu_p vcpu = & hvm -> virtual_cpu [ i ] ; <S2SV_EndBug> if ( vcpu -> vmcb . virt ) noir_free_contd_memory ( vcpu -> vmcb . virt ) ; if ( vcpu -> hsave . virt ) noir_free_contd_memory ( vcpu -> hsave . virt ) ; if ( vcpu -> hv_stack ) noir_free_nonpg_memory ( vcpu -> hv_stack ) ; } <S2SV_StartBug> noir_free_nonpg_memory ( hvm -> virtual_cpu ) ; <S2SV_EndBug> } <S2SV_StartBug> if ( hvm -> relative_hvm -> msrpm . virt ) <S2SV_EndBug> <S2SV_StartBug> noir_free_contd_memory ( hvm -> relative_hvm -> msrpm . virt ) ; <S2SV_EndBug> <S2SV_StartBug> if ( hvm -> relative_hvm -> iopm . virt ) <S2SV_EndBug> <S2SV_StartBug> noir_free_contd_memory ( hvm -> relative_hvm -> iopm . virt ) ; <S2SV_EndBug> if ( host_rsp_list ) noir_free_nonpg_memory ( host_rsp_list ) ; } | <S2SV_ModStart> nvc_svm_cleanup ( noir_hypervisor_p hvm_p <S2SV_ModEnd> ) { if <S2SV_ModStart> { if ( hvm_p <S2SV_ModEnd> -> virtual_cpu ) <S2SV_ModStart> ; i < hvm_p <S2SV_ModEnd> -> cpu_count ; <S2SV_ModStart> vcpu = & hvm_p <S2SV_ModEnd> -> virtual_cpu [ <S2SV_ModStart> } noir_free_nonpg_memory ( hvm_p <S2SV_ModEnd> -> virtual_cpu ) <S2SV_ModStart> } if ( hvm_p <S2SV_ModEnd> -> relative_hvm -> <S2SV_ModStart> ) noir_free_contd_memory ( hvm_p <S2SV_ModEnd> -> relative_hvm -> <S2SV_ModStart> ; if ( hvm_p <S2SV_ModEnd> -> relative_hvm -> <S2SV_ModStart> ) noir_free_contd_memory ( hvm_p <S2SV_ModEnd> -> relative_hvm -> |
6,210 | CWE-000 static void process ( sds word ) { double a , b ; char * z ; node * n ; if ( ! strcmp ( word , "+" ) ) { a = pop ( ) ; b = pop ( ) ; push ( a + b ) ; } else if ( ! strcmp ( word , "-" ) ) { a = pop ( ) ; b = pop ( ) ; push ( b - a ) ; } else if ( ! strcmp ( word , "*" ) ) { a = pop ( ) ; b = pop ( ) ; push ( b * a ) ; } else if ( ! strcmp ( word , "/" ) ) { a = pop ( ) ; b = pop ( ) ; push ( b / a ) ; } else if ( ! strcmp ( word , "%" ) ) { a = pop ( ) ; b = pop ( ) ; push ( b - a * floor ( b / a ) ) ; } else if ( ! strcmp ( word , "^" ) ) { a = pop ( ) ; b = pop ( ) ; push ( pow ( b , a ) ) ; } else if ( ! strcmp ( word , "_" ) ) { push ( hole ) ; } else if ( ! strcasecmp ( word , "ceil" ) ) { a = pop ( ) ; push ( ceil ( a ) ) ; } else if ( ! strcasecmp ( word , "floor" ) ) { a = pop ( ) ; push ( floor ( a ) ) ; } else if ( ! strcasecmp ( word , "round" ) ) { a = pop ( ) ; push ( round ( a ) ) ; } else if ( ! strcasecmp ( word , "swap" ) ) { a = pop ( ) ; b = pop ( ) ; push ( a ) ; push ( b ) ; } else if ( ! strcasecmp ( word , "dup" ) ) { a = pop ( ) ; push ( a ) ; push ( a ) ; } else if ( ( n = find ( word ) ) != NULL ) { eval ( n -> meaning ) ; <S2SV_StartBug> } else if ( isdigit ( word [ 0 ] ) ) { <S2SV_EndBug> a = strtod ( word , & z ) ; if ( * z == '\\0' ) { push ( a ) ; <S2SV_StartBug> } else { <S2SV_EndBug> push ( NAN ) ; } } } | <S2SV_ModStart> ; } else <S2SV_ModEnd> { a = <S2SV_ModStart> ; } else if ( ! isalpha ( word [ 0 ] ) ) |
6,211 | CWE-000 int main ( void ) { uint8_t ct1 [ 32 ] , pt1 [ 32 ] , pt2 [ 32 ] , key [ 64 ] ; int klen , plen , clen , i , j ; serpent_key_t skey ; serpent_blk ct2 ; uint32_t * p ; printf ( "\\nserpent-256<S2SV_blank>test\\n" ) ; for ( i = 0 ; i < sizeof ( keys ) / sizeof ( char * ) ; i ++ ) { clen = hex2bin ( ct1 , cipher [ i ] ) ; plen = hex2bin ( pt1 , plain [ i ] ) ; klen = hex2bin ( key , keys [ i ] ) ; memset ( & skey , 0 , sizeof ( skey ) ) ; p = ( uint32_t * ) & skey . x [ 0 ] [ 0 ] ; serpent_set_encrypt_key ( & skey , key ) ; printf ( "\\nkey=" ) ; for ( j = 0 ; j < sizeof ( skey ) / sizeof ( serpent_subkey_t ) * 4 ; j ++ ) { if ( ( j % 8 ) == 0 ) putchar ( '\\n' ) ; printf ( "%08X<S2SV_blank>" , p [ j ] ) ; } <S2SV_StartBug> memcpy ( ct2 . b , pt1 , SERPENT_BLK_LEN ) ; <S2SV_EndBug> printf ( "\\n\\n" ) ; dump_hex ( "plaintext" , ct2 . b , 16 ) ; <S2SV_StartBug> serpent_encrypt ( ct2 . b , & skey ) ; <S2SV_EndBug> dump_hex ( "ciphertext" , ct2 . b , 16 ) ; if ( memcmp ( ct1 , ct2 . b , clen ) == 0 ) { printf ( "\\nEncryption<S2SV_blank>OK" ) ; <S2SV_StartBug> serpent_decrypt ( ct2 . b , & skey ) ; <S2SV_EndBug> if ( memcmp ( pt1 , ct2 . b , plen ) == 0 ) { printf ( "\\nDecryption<S2SV_blank>OK" ) ; dump_hex ( "plaintext" , ct2 . b , 16 ) ; } else { printf ( "\\nDecryption<S2SV_blank>failed" ) ; } } else { printf ( "\\nEncryption<S2SV_blank>failed" ) ; } } return 0 ; } | <S2SV_ModStart> , pt1 , SERPENT_BLOCK_SIZE <S2SV_ModEnd> ) ; printf <S2SV_ModStart> ; serpent_encrypt ( pt1 , <S2SV_ModStart> . b , pt1 , |
6,212 | CWE-000 int vr_mpls_get ( vr_mpls_req * req ) { int ret = 0 ; struct vr_nexthop * nh = NULL ; struct vrouter * router ; router = vrouter_get ( req -> mr_rid ) ; if ( ! router ) { ret = - ENODEV ; goto generate_response ; } if ( ( ( unsigned int ) req -> mr_label >= router -> vr_max_labels ) ) { ret = - EINVAL ; goto generate_response ; } nh = vrouter_get_label ( req -> mr_rid , req -> mr_label ) ; if ( ! nh ) { ret = - ENOENT ; goto generate_response ; } vr_mpls_make_req ( req , nh , req -> mr_label ) ; <S2SV_StartBug> vr_offload_mpls_get ( req ) ; <S2SV_EndBug> generate_response : if ( ret ) req = NULL ; vr_message_response ( VR_MPLS_OBJECT_ID , req , ret ) ; return 0 ; } | <S2SV_ModStart> mr_label ) ; <S2SV_ModEnd> generate_response : if |
6,213 | CWE-000 <S2SV_StartBug> static PyObject * PySortedSet_difference_update ( PyObject * self , PyObject * tup ) <S2SV_EndBug> { <S2SV_StartBug> PyObject * newset = PySortedSet_difference ( self , tup ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ! newset ) <S2SV_EndBug> { PyErr_BadInternalCall ( ) ; return NULL ; } <S2SV_StartBug> Py_XDECREF ( PY_SORTED_SET_GET_LIST ( self ) ) ; <S2SV_EndBug> <S2SV_StartBug> PY_SORTED_SET_GET_LIST ( self ) = PY_SORTED_SET_GET_LIST ( newset ) ; <S2SV_EndBug> Py_XINCREF ( PY_SORTED_SET_GET_LIST ( self ) ) ; <S2SV_StartBug> PY_SORTED_SET_SORTED_COUNT ( self ) = PY_SORTED_SET_SORTED_COUNT ( newset ) ; <S2SV_EndBug> <S2SV_StartBug> Py_XDECREF ( newset ) ; <S2SV_EndBug> Py_RETURN_NONE ; } | <S2SV_ModStart> , PyObject * argtup <S2SV_ModEnd> ) { PyObject <S2SV_ModStart> { PyObject * diffset <S2SV_ModEnd> = PySortedSet_difference ( <S2SV_ModStart> ( self , argtup <S2SV_ModEnd> ) ; if <S2SV_ModStart> if ( ! diffset ) { <S2SV_ModEnd> return NULL ; <S2SV_ModStart> } Py_XDECREF ( ( PyObject * ) <S2SV_ModStart> = PY_SORTED_SET_GET_LIST ( diffset <S2SV_ModEnd> ) ; PY_SORTED_SET_SORTED_COUNT <S2SV_ModStart> = PY_SORTED_SET_SORTED_COUNT ( diffset ) ; Py_XINCREF ( ( PyObject * ) PY_SORTED_SET_GET_LIST ( self ) <S2SV_ModEnd> ) ; Py_XDECREF <S2SV_ModStart> ; Py_XDECREF ( diffset <S2SV_ModEnd> ) ; Py_RETURN_NONE |
6,214 | CWE-000 struct MString * MStringPrintFV ( const char * format , va_list args ) { # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wformat-nonliteral" va_list ap ; va_copy ( ap , args ) ; int total_size = vsnprintf ( NULL , 0 , format , ap ) ; va_end ( ap ) ; char * ptr ; struct MString * result = _MStringAlloc ( ( unsigned int ) total_size , & ptr ) ; va_copy ( ap , args ) ; <S2SV_StartBug> vsnprintf ( ptr , total_size , format , ap ) ; <S2SV_EndBug> va_end ( ap ) ; return result ; # pragma GCC diagnostic pop } | <S2SV_ModStart> ptr , total_size + 1 |
6,215 | CWE-000 value owl_stub_chi2_isf ( value vQ , value vA ) { double a = Double_val ( vA ) ; double q = Double_val ( vQ ) ; <S2SV_StartBug> double x = chi2_sf ( q , a ) ; <S2SV_EndBug> return caml_copy_double ( x ) ; } | <S2SV_ModStart> double x = chi2_isf <S2SV_ModEnd> ( q , |
6,216 | CWE-000 int find_and_start_instance ( char * psInstanceId ) { char * psXML = NULL ; ncInstance * pInstance = NULL ; virDomainPtr dom = NULL ; virConnectPtr conn = NULL ; LOGDEBUG ( "[%s]<S2SV_blank>restarting<S2SV_blank>instance\\n" , psInstanceId ) ; sem_p ( inst_sem ) ; { if ( ( pInstance = find_instance ( & global_instances , psInstanceId ) ) == NULL ) { LOGERROR ( "[%s]<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>locate<S2SV_blank>instance<S2SV_blank>in<S2SV_blank>memory\\n" , psInstanceId ) ; sem_v ( inst_sem ) ; return ( EUCA_NOT_FOUND_ERROR ) ; } if ( pInstance -> stop_requested != TRUE ) { LOGERROR ( "[%s]<S2SV_blank>cannot<S2SV_blank>start<S2SV_blank>instance<S2SV_blank>that<S2SV_blank>was<S2SV_blank>not<S2SV_blank>stopped<S2SV_blank>earlier\\n" , psInstanceId ) ; sem_v ( inst_sem ) ; return ( EUCA_ERROR ) ; } if ( ( psXML = file2str ( pInstance -> libvirtFilePath ) ) == NULL ) { LOGERROR ( "[%s]<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>load<S2SV_blank>libvirt<S2SV_blank>XML<S2SV_blank>from<S2SV_blank>file<S2SV_blank>file<S2SV_blank>%s\\n" , psInstanceId , pInstance -> libvirtFilePath ) ; sem_v ( inst_sem ) ; return ( EUCA_IO_ERROR ) ; } pInstance -> stop_requested = FALSE ; save_instance_struct ( pInstance ) ; } sem_v ( inst_sem ) ; sensor_shift_metric ( psInstanceId , "CPUUtilization" ) ; sensor_shift_metric ( psInstanceId , "NetworkIn" ) ; sensor_shift_metric ( psInstanceId , "NetworkOut" ) ; { if ( ( conn = lock_hypervisor_conn ( ) ) == NULL ) { LOGERROR ( "[%s]<S2SV_blank>cannot<S2SV_blank>connect<S2SV_blank>to<S2SV_blank>hypervisor<S2SV_blank>to<S2SV_blank>restart<S2SV_blank>instance,<S2SV_blank>giving<S2SV_blank>up\\n" , psInstanceId ) ; EUCA_FREE ( psXML ) ; return ( EUCA_ERROR ) ; } if ( ( dom = virDomainLookupByName ( conn , psInstanceId ) ) != NULL ) { LOGERROR ( "[%s]<S2SV_blank>instance<S2SV_blank>to<S2SV_blank>start<S2SV_blank>is<S2SV_blank>already<S2SV_blank>running,<S2SV_blank>giving<S2SV_blank>up\\n" , psInstanceId ) ; <S2SV_StartBug> unlock_hypervisor_conn ( ) ; <S2SV_EndBug> <S2SV_StartBug> EUCA_FREE ( psXML ) ; <S2SV_EndBug> virDomainFree ( dom ) ; return ( EUCA_ERROR ) ; } if ( ( dom = virDomainCreateLinux ( conn , psXML , 0 ) ) == NULL ) { LOGERROR ( "[%s]<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>start<S2SV_blank>instance\\n" , psInstanceId ) ; } else { virDomainFree ( dom ) ; if ( ! strcmp ( nc_state . pEucaNet -> sMode , NETMODE_VPCMIDO ) ) { bridge_instance_interfaces_remove ( & nc_state , pInstance ) ; } if ( ! strcmp ( nc_state . pEucaNet -> sMode , NETMODE_EDGE ) ) { char iface [ 16 ] ; snprintf ( iface , 16 , "vn_%s" , pInstance -> instanceId ) ; bridge_interface_set_hairpin ( & nc_state , pInstance , iface ) ; } } unlock_hypervisor_conn ( ) ; refresh_instance_resources ( psInstanceId ) ; } EUCA_FREE ( psXML ) ; return ( 0 ) ; } | <S2SV_ModStart> psInstanceId ) ; virDomainFree ( dom ) ; <S2SV_ModStart> EUCA_FREE ( psXML <S2SV_ModEnd> ) ; return |
6,217 | CWE-000 void runAssembler ( char * fileName ) { <S2SV_StartBug> FILE * fp ; <S2SV_EndBug> if ( isFileExists ( fileName ) == FALSE ) { <S2SV_StartBug> printError ( "File<S2SV_blank>is<S2SV_blank>not<S2SV_blank>exist" , fileName ) ; <S2SV_EndBug> return ; } firstpass ( fileName ) ; } | <S2SV_ModStart> fileName ) { <S2SV_ModEnd> if ( isFileExists <S2SV_ModStart> printError ( "File<S2SV_blank>is<S2SV_blank>not<S2SV_blank>exist" <S2SV_ModEnd> ) ; return |
6,218 | CWE-000 int main ( int argc , char * argv [ ] ) { argv0 = argv [ 0 ] ; g_setenv ( "TMPDIR" , "" , TRUE ) ; g_unsetenv ( "TMP" ) ; g_unsetenv ( "TEMP" ) ; g_set_prgname ( argv [ 0 ] ) ; g_test_init ( & argc , & argv , NULL ) ; g_test_bug_base ( "http://bugzilla.gnome.org/" ) ; g_test_add_func ( "/utils/language-names" , test_language_names ) ; g_test_add_func ( "/utils/locale-variants" , test_locale_variants ) ; g_test_add_func ( "/utils/version" , test_version ) ; g_test_add_func ( "/utils/appname" , test_appname ) ; g_test_add_func ( "/utils/tmpdir" , test_tmpdir ) ; g_test_add_func ( "/utils/bits" , test_bits ) ; g_test_add_func ( "/utils/swap" , test_swap ) ; g_test_add_func ( "/utils/find-program" , test_find_program ) ; g_test_add_func ( "/utils/debug" , test_debug ) ; g_test_add_func ( "/utils/codeset" , test_codeset ) ; g_test_add_func ( "/utils/codeset2" , test_codeset2 ) ; g_test_add_func ( "/utils/basename" , test_basename ) ; g_test_add_func ( "/utils/gettext" , test_gettext ) ; g_test_add_func ( "/utils/username" , test_username ) ; g_test_add_func ( "/utils/realname" , test_realname ) ; g_test_add_func ( "/utils/hostname" , test_hostname ) ; # ifdef G_OS_UNIX g_test_add_func ( "/utils/xdgdirs" , test_xdg_dirs ) ; # endif g_test_add_func ( "/utils/specialdir" , test_special_dir ) ; g_test_add_func ( "/utils/specialdir/desktop" , test_desktop_special_dir ) ; g_test_add_func ( "/utils/clear-pointer" , test_clear_pointer ) ; <S2SV_StartBug> g_test_add_func ( "/utils/take-pointer" , test_take_pointer ) ; <S2SV_EndBug> g_test_add_func ( "/utils/clear-source" , test_clear_source ) ; g_test_add_func ( "/utils/misc-mem" , test_misc_mem ) ; g_test_add_func ( "/utils/nullify" , test_nullify ) ; g_test_add_func ( "/utils/atexit" , test_atexit ) ; g_test_add_func ( "/utils/check-setuid" , test_check_setuid ) ; return g_test_run ( ) ; } | <S2SV_ModStart> ; g_test_add_func ( "/utils/clear-pointer-cast" , test_clear_pointer_cast ) ; g_test_add_func ( |
6,219 | CWE-000 bool modify_config_file ( struct meshlink_handle * mesh , const char * name , const char * key , const char * value , int trim ) { assert ( mesh && name && key ) ; char filename [ PATH_MAX ] ; char tmpname [ PATH_MAX ] ; bool error = false ; snprintf ( filename , sizeof ( filename ) , "%s" SLASH "hosts" SLASH "%s" , mesh -> confbase , name ) ; snprintf ( tmpname , sizeof ( tmpname ) , "%s.tmp" , filename ) ; FILE * fr = fopen ( filename , "r" ) ; if ( ! fr ) { logger ( mesh , MESHLINK_ERROR , "Cannot<S2SV_blank>open<S2SV_blank>config<S2SV_blank>file<S2SV_blank>%s:<S2SV_blank>%s" , filename , strerror ( errno ) ) ; return false ; } FILE * fw = fopen ( tmpname , "w" ) ; if ( ! fw ) { logger ( mesh , MESHLINK_ERROR , "Cannot<S2SV_blank>open<S2SV_blank>temporary<S2SV_blank>file<S2SV_blank>%s:<S2SV_blank>%s" , tmpname , strerror ( errno ) ) ; fclose ( fr ) ; return false ; } char buf [ 4096 ] ; char * sep ; int found = 0 ; if ( value ) { fprintf ( fw , "%s<S2SV_blank>=<S2SV_blank>%s\\n" , key , value ) ; found ++ ; } while ( readline ( fr , buf , sizeof ( buf ) ) ) { if ( ! * buf || * buf == '#' ) goto copy ; sep = strchr ( buf , '<S2SV_blank>' ) ; if ( ! sep ) goto copy ; * sep = 0 ; if ( strcmp ( buf , key ) ) { * sep = '<S2SV_blank>' ; goto copy ; } <S2SV_StartBug> if ( sep [ 1 ] == '=' && sep [ 2 ] == '<S2SV_blank>' && ! strcmp ( sep + 3 , value ) ) <S2SV_EndBug> continue ; found ++ ; if ( ( ! value || trim ) && found > trim ) continue ; * sep = '<S2SV_blank>' ; copy : fprintf ( fw , "%s\\n" , buf ) ; } if ( ferror ( fr ) ) error = true ; fclose ( fr ) ; if ( ferror ( fw ) ) error = true ; if ( fclose ( fw ) ) error = true ; if ( error ) { unlink ( tmpname ) ; return false ; } # ifdef HAVE_MINGW char bakname [ PATH_MAX ] ; snprintf ( bakname , sizeof ( bakname ) , "%s.bak" , filename ) ; if ( rename ( filename , bakname ) || rename ( tmpname , filename ) ) { rename ( bakname , filename ) ; # else if ( rename ( tmpname , filename ) ) { # endif return false ; } else { # ifdef HAVE_MINGW unlink ( bakname ) ; # endif return true ; } } | <S2SV_ModStart> } if ( value && |
6,220 | CWE-000 void QAJ4C_set_string_copy_n ( QAJ4C_Value * value_ptr , const char * str , size_t len , QAJ4C_Builder * builder ) { if ( len <= QAJ4C_INLINE_STRING_SIZE ) { value_ptr -> type = QAJ4C_INLINE_STRING_TYPE_CONSTANT ; ( ( QAJ4C_Short_string * ) value_ptr ) -> count = ( uint8_t ) len ; <S2SV_StartBug> QAJ4C_memcpy ( & ( ( QAJ4C_Short_string * ) value_ptr ) -> s , str , len ) ; <S2SV_EndBug> ( ( QAJ4C_Short_string * ) value_ptr ) -> s [ len ] = '\\0' ; } else { char * new_string ; value_ptr -> type = QAJ4C_STRING_TYPE_CONSTANT ; QAJ4C_ASSERT ( builder != NULL , { ( ( QAJ4C_String * ) value_ptr ) -> count = 0 ; ( ( QAJ4C_String * ) value_ptr ) -> s = "" ; return ; } ) ; new_string = QAJ4C_builder_pop_string ( builder , len + 1 ) ; QAJ4C_ASSERT ( new_string != NULL , { ( ( QAJ4C_String * ) value_ptr ) -> count = 0 ; ( ( QAJ4C_String * ) value_ptr ) -> s = "" ; return ; } ) ; ( ( QAJ4C_String * ) value_ptr ) -> count = len ; <S2SV_StartBug> QAJ4C_memcpy ( new_string , str , len ) ; <S2SV_EndBug> ( ( QAJ4C_String * ) value_ptr ) -> s = new_string ; new_string [ len ] = '\\0' ; } } | <S2SV_ModStart> ) len ; QAJ4C_MEMCPY <S2SV_ModEnd> ( & ( <S2SV_ModStart> = len ; QAJ4C_MEMCPY <S2SV_ModEnd> ( new_string , |
6,221 | CWE-000 int ibv_cmd_post_srq_recv ( struct ibv_srq * srq , struct ibv_recv_wr * wr , struct ibv_recv_wr * * bad_wr ) { struct ibv_post_srq_recv * cmd ; <S2SV_StartBug> struct ibv_post_srq_recv_resp resp ; <S2SV_EndBug> struct ibv_recv_wr * i ; <S2SV_StartBug> struct ibv_kern_recv_wr * n , * tmp ; <S2SV_EndBug> struct ibv_sge * s ; unsigned wr_count = 0 ; unsigned sge_count = 0 ; int cmd_size ; int ret = 0 ; for ( i = wr ; i ; i = i -> next ) { wr_count ++ ; sge_count += i -> num_sge ; } cmd_size = sizeof * cmd + wr_count * sizeof * n + sge_count * sizeof * s ; cmd = alloca ( cmd_size ) ; IBV_INIT_CMD_RESP ( cmd , cmd_size , POST_SRQ_RECV , & resp , sizeof resp ) ; cmd -> srq_handle = srq -> handle ; cmd -> wr_count = wr_count ; cmd -> sge_count = sge_count ; cmd -> wqe_size = sizeof * n ; <S2SV_StartBug> n = ( struct ibv_kern_recv_wr * ) ( ( void * ) cmd + sizeof * cmd ) ; <S2SV_EndBug> s = ( struct ibv_sge * ) ( n + wr_count ) ; tmp = n ; for ( i = wr ; i ; i = i -> next ) { tmp -> wr_id = i -> wr_id ; tmp -> num_sge = i -> num_sge ; if ( tmp -> num_sge ) { memcpy ( s , i -> sg_list , tmp -> num_sge * sizeof * s ) ; s += tmp -> num_sge ; } tmp ++ ; } resp . bad_wr = 0 ; if ( write ( srq -> context -> cmd_fd , cmd , cmd_size ) != cmd_size ) ret = errno ; ( void ) VALGRIND_MAKE_MEM_DEFINED ( & resp , sizeof resp ) ; wr_count = resp . bad_wr ; if ( wr_count ) { i = wr ; while ( -- wr_count ) i = i -> next ; * bad_wr = i ; } else if ( ret ) * bad_wr = wr ; return ret ; } | <S2SV_ModStart> cmd ; struct ib_uverbs_post_recv_resp <S2SV_ModEnd> resp ; struct <S2SV_ModStart> i ; struct ib_uverbs_recv_wr <S2SV_ModEnd> * n , <S2SV_ModStart> = ( struct ib_uverbs_recv_wr <S2SV_ModEnd> * ) ( |
6,222 | CWE-000 void * workerThreadFunc ( void * pThreadData ) { SessionHandle * pSession = ( SessionHandle * ) pThreadData ; if ( ! pSession ) <S2SV_StartBug> return ; <S2SV_EndBug> pthread_setspecific ( thread_key , pSession ) ; printf ( "MQTT<S2SV_blank>worker<S2SV_blank>thread<S2SV_blank>started<S2SV_blank>\\n" ) ; while ( true ) { Payload * pPayload = curPayload ( pSession ) ; if ( ! pPayload ) { if ( pSession -> pHandle ) { yield ( pSession -> pHandle ) ; } continue ; } else { bool result = true ; switch ( pPayload -> type ) { case StartSessionTask : result = startSession ( pSession , pPayload -> pStartSessionData ) ; break ; case PublishTask : result = publish ( pSession , pPayload -> pPublishData ) ; break ; case SubscribeTask : result = subscribe ( pSession , pPayload -> pSubscribeData ) ; break ; case UnsubscribeTask : result = unsubscribe ( pSession , pPayload -> pUnsubscribeData ) ; break ; case StopSessionTask : stopSession ( pSession ) ; pSession = NULL ; pthread_setspecific ( thread_key , pSession ) ; printf ( "MQTT<S2SV_blank>worker<S2SV_blank>thread<S2SV_blank>exited<S2SV_blank>\\n" ) ; pthread_exit ( NULL ) ; break ; default : break ; } popPayload ( pSession ) ; } } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> pSession ) return NULL <S2SV_ModStart> ; } } return NULL ; |
6,223 | CWE-000 void dns_poller_init ( dns_poller_t * d , struct ev_loop * loop , const char * bootstrap_dns , const char * hostname , <S2SV_StartBug> int interval_seconds , dns_poller_cb cb , void * cb_data ) { <S2SV_EndBug> int i ; for ( i = 0 ; i < FD_SETSIZE ; i ++ ) { d -> fd [ i ] . fd = 0 ; } int r ; ares_library_init ( ARES_LIB_INIT_ALL ) ; struct ares_options options ; options . sock_state_cb = sock_state_cb ; options . sock_state_cb_data = d ; options . servers = NULL ; options . nservers = 0 ; char * csv = strdup ( bootstrap_dns ) ; if ( ! csv ) { FLOG ( "Out<S2SV_blank>of<S2SV_blank>mem" ) ; } char * last = NULL ; char * ipstr = strtok_r ( csv , "," , & last ) ; while ( ipstr ) { options . servers = ( struct in_addr * ) realloc ( options . servers , sizeof ( struct in_addr ) * ( options . nservers + 1 ) ) ; if ( ! options . servers ) { FLOG ( "Out<S2SV_blank>of<S2SV_blank>mem" ) ; } DLOG ( "Adding<S2SV_blank>DNS<S2SV_blank>server<S2SV_blank>\'%s\'<S2SV_blank>for<S2SV_blank>bootstrap<S2SV_blank>resolution." , ipstr ) ; if ( ares_inet_pton ( AF_INET , ipstr , & options . servers [ options . nservers ++ ] ) != 1 ) { FLOG ( "Failed<S2SV_blank>to<S2SV_blank>parse<S2SV_blank>\'%s\'" , ipstr ) ; } ipstr = strtok_r ( NULL , "," , & last ) ; } free ( csv ) ; if ( ( r = ares_init_options ( & d -> ares , & options , ARES_OPT_SOCK_STATE_CB | ARES_OPT_SERVERS ) ) != ARES_SUCCESS ) { FLOG ( "ares_init_options<S2SV_blank>error:<S2SV_blank>%s" , ares_strerror ( r ) ) ; } free ( options . servers ) ; d -> loop = loop ; d -> hostname = hostname ; d -> cb = cb ; d -> cb_data = cb_data ; <S2SV_StartBug> ev_timer_init ( & d -> timer , timer_cb , 0 , interval_seconds ) ; <S2SV_EndBug> d -> timer . data = d ; ev_timer_start ( d -> loop , & d -> timer ) ; } | <S2SV_ModStart> * hostname , <S2SV_ModEnd> dns_poller_cb cb , <S2SV_ModStart> = cb_data ; d -> interval = POLLER_INTVL_NORM ; <S2SV_ModStart> , 0 , d -> interval <S2SV_ModEnd> ) ; d |
6,224 | CWE-000 static bool encrypt_seed_with_tpm2_rsa_public_key ( void ) { <S2SV_StartBug> FILE * fp = fopen ( ctx . parent_key_public_file , "rb" ) ; <S2SV_EndBug> if ( fp == NULL ) { LOG_ERR ( "Failed<S2SV_blank>accessing<S2SV_blank>parent<S2SV_blank>key<S2SV_blank>public<S2SV_blank>file." ) ; return false ; } if ( fseek ( fp , 102 , SEEK_SET ) != 0 ) { <S2SV_StartBug> LOG_ERR ( "Expected<S2SV_blank>parent<S2SV_blank>key<S2SV_blank>public<S2SV_blank>data<S2SV_blank>file<S2SV_blank>size<S2SV_blank>failure" ) ; <S2SV_EndBug> return false ; } unsigned char pub_modulus [ MAX_RSA_KEY_BYTES ] = { 0 } ; int ret = fread ( pub_modulus , 1 , MAX_RSA_KEY_BYTES , fp ) ; if ( ret != MAX_RSA_KEY_BYTES ) { <S2SV_StartBug> LOG_ERR ( "Failed<S2SV_blank>reading<S2SV_blank>public<S2SV_blank>modulus<S2SV_blank>from<S2SV_blank>parent<S2SV_blank>key<S2SV_blank>public<S2SV_blank>file" ) ; <S2SV_EndBug> return false ; } fclose ( fp ) ; RSA * rsa = NULL ; unsigned char encoded [ MAX_RSA_KEY_BYTES ] ; unsigned char label [ 10 ] = { 'D' , 'U' , 'P' , 'L' , 'I' , 'C' , 'A' , 'T' , 'E' , 0 } ; int return_code = RSA_padding_add_PKCS1_OAEP_mgf1 ( encoded , MAX_RSA_KEY_BYTES , ctx . protection_seed_data , 32 , label , 10 , EVP_sha256 ( ) , NULL ) ; if ( return_code != 1 ) { LOG_ERR ( "Failed<S2SV_blank>RSA_padding_add_PKCS1_OAEP_mgf1\\n" ) ; return false ; } BIGNUM * bne = BN_new ( ) ; if ( ! bne ) { LOG_ERR ( "BN_new<S2SV_blank>for<S2SV_blank>bne<S2SV_blank>failed\\n" ) ; return false ; } return_code = BN_set_word ( bne , RSA_F4 ) ; if ( return_code != 1 ) { LOG_ERR ( "BN_set_word<S2SV_blank>failed\\n" ) ; <S2SV_StartBug> return false ; <S2SV_EndBug> } rsa = RSA_new ( ) ; if ( ! rsa ) { LOG_ERR ( "RSA_new<S2SV_blank>failed\\n" ) ; BN_free ( bne ) ; return false ; } return_code = RSA_generate_key_ex ( rsa , 2048 , bne , NULL ) ; BN_free ( bne ) ; if ( return_code != 1 ) { LOG_ERR ( "RSA_generate_key_ex<S2SV_blank>failed\\n" ) ; <S2SV_StartBug> return false ; <S2SV_EndBug> } BIGNUM * n = BN_bin2bn ( pub_modulus , MAX_RSA_KEY_BYTES , NULL ) ; if ( n == NULL ) { LOG_ERR ( "BN_bin2bn<S2SV_blank>failed\\n" ) ; <S2SV_StartBug> return false ; <S2SV_EndBug> } ssl_RSA_set0_key ( rsa , n , NULL , NULL ) ; return_code = RSA_public_encrypt ( MAX_RSA_KEY_BYTES , encoded , ctx . encrypted_protection_seed_data , rsa , RSA_NO_PADDING ) ; if ( return_code < 0 ) { LOG_ERR ( "Failed<S2SV_blank>RSA_public_encrypt\\n" ) ; <S2SV_StartBug> } <S2SV_EndBug> RSA_free ( rsa ) ; <S2SV_StartBug> return true ; <S2SV_EndBug> } | <S2SV_ModStart> void ) { bool rval = false ; <S2SV_ModStart> LOG_ERR ( "Expected<S2SV_blank>parent<S2SV_blank>key<S2SV_blank>public<S2SV_blank>data<S2SV_blank>file<S2SV_blank>size<S2SV_blank>failure" ) ; fclose ( fp <S2SV_ModStart> LOG_ERR ( "Failed<S2SV_blank>reading<S2SV_blank>public<S2SV_blank>modulus<S2SV_blank>from<S2SV_blank>parent<S2SV_blank>key<S2SV_blank>public<S2SV_blank>file" ) ; fclose ( fp <S2SV_ModStart> "BN_set_word<S2SV_blank>failed\\n" ) ; BN_free ( bne ) ; <S2SV_ModStart> "RSA_generate_key_ex<S2SV_blank>failed\\n" ) ; goto error <S2SV_ModEnd> ; } BIGNUM <S2SV_ModStart> "BN_bin2bn<S2SV_blank>failed\\n" ) ; goto error <S2SV_ModEnd> ; } ssl_RSA_set0_key <S2SV_ModStart> "Failed<S2SV_blank>RSA_public_encrypt\\n" ) ; goto error ; } rval = true ; error : <S2SV_ModEnd> RSA_free ( rsa <S2SV_ModStart> ) ; return rval <S2SV_ModEnd> ; } <S2SV_null> |
6,225 | CWE-000 int _formf_serval_cache_path ( struct __sourceloc __whence , char * buf , size_t bufsiz , const char * fmt , ... ) { va_list ap ; va_start ( ap , fmt ) ; <S2SV_StartBug> int ret = vformf_path ( __whence , strbuf_local ( buf , bufsiz ) , SERVAL_CACHE_PATH , fmt , ap ) ; <S2SV_EndBug> va_end ( ap ) ; return ret ; } | <S2SV_ModStart> , SERVAL_CACHE_PATH , NULL , |
6,226 | CWE-000 int main ( int argc , char * argv [ ] ) { int r , k ; ItemArray * a ; <S2SV_StartBug> Iterator iterator ; <S2SV_EndBug> r = parse_argv ( argc , argv ) ; if ( r <= 0 ) goto finish ; log_set_target ( LOG_TARGET_AUTO ) ; log_parse_environment ( ) ; log_open ( ) ; umask ( 0022 ) ; mac_selinux_init ( ) ; items = ordered_hashmap_new ( & string_hash_ops ) ; globs = ordered_hashmap_new ( & string_hash_ops ) ; if ( ! items || ! globs ) { r = log_oom ( ) ; goto finish ; } r = 0 ; if ( optind < argc ) { int j ; for ( j = optind ; j < argc ; j ++ ) { <S2SV_StartBug> k = read_config_file ( argv [ j ] , false ) ; <S2SV_EndBug> if ( k < 0 && r == 0 ) r = k ; } } else { _cleanup_strv_free_ char * * files = NULL ; char * * f ; r = conf_files_list_nulstr ( & files , ".conf" , arg_root , 0 , conf_file_dirs ) ; if ( r < 0 ) { log_error_errno ( r , "Failed<S2SV_blank>to<S2SV_blank>enumerate<S2SV_blank>tmpfiles.d<S2SV_blank>files:<S2SV_blank>%m" ) ; goto finish ; } STRV_FOREACH ( f , files ) { <S2SV_StartBug> k = read_config_file ( * f , true ) ; <S2SV_EndBug> if ( k < 0 && r == 0 ) r = k ; } } ORDERED_HASHMAP_FOREACH ( a , items , iterator ) { k = process_item_array ( a ) ; if ( k < 0 && r == 0 ) r = k ; } ORDERED_HASHMAP_FOREACH ( a , globs , iterator ) { k = process_item_array ( a ) ; if ( k < 0 && r == 0 ) r = k ; } finish : ordered_hashmap_free_with_destructor ( items , item_array_free ) ; ordered_hashmap_free_with_destructor ( globs , item_array_free ) ; free ( arg_include_prefixes ) ; free ( arg_exclude_prefixes ) ; free ( arg_root ) ; set_free_free ( unix_sockets ) ; mac_selinux_finish ( ) ; <S2SV_StartBug> return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS ; <S2SV_EndBug> } | <S2SV_ModStart> ; Iterator iterator ; bool invalid_config = false <S2SV_ModStart> ] , false , & invalid_config <S2SV_ModStart> f , true , & invalid_config <S2SV_ModStart> ( ) ; if ( r < 0 ) return EXIT_FAILURE ; else if ( invalid_config ) return EX_DATAERR ; else return <S2SV_ModEnd> EXIT_SUCCESS ; } |
6,227 | CWE-000 bool snakeIsEatingSelf ( ) { int i ; <S2SV_StartBug> for ( i = 0 ; i < size ; i ++ ) { <S2SV_EndBug> if ( snake -> headLayer -> pos . axes [ 0 ] == snake -> segments [ i ] . axes [ 0 ] && snake -> headLayer -> pos . axes [ 1 ] == snake -> segments [ i ] . axes [ 1 ] ) { return true ; } } return false ; } | <S2SV_ModStart> ; i < snake -> |
6,228 | CWE-000 <S2SV_StartBug> void * thread_program_running ( ) { <S2SV_EndBug> while ( 1 ) { if ( liveEvil == 0 ) { <S2SV_StartBug> printf ( "HAS<S2SV_blank>GANADO!!!\\n" ) ; <S2SV_EndBug> exit ( 0 ) ; } sleep ( 500 ) ; } } | <S2SV_ModStart> * thread_program_running ( void * p ) { if ( p == NULL ) { printf ( "ES<S2SV_blank>NULL\\n" ) ; exit ( 0 ) ; } Place * place ; place = ( Place * ) p ; <S2SV_ModEnd> while ( 1 <S2SV_ModStart> 0 ) { printInsidePlace ( place , "Congratulations!\\nYou<S2SV_blank>have<S2SV_blank>beaten<S2SV_blank>the<S2SV_blank>final<S2SV_blank>evil,<S2SV_blank>Marabini,<S2SV_blank>and<S2SV_blank>you<S2SV_blank>should<S2SV_blank>be<S2SV_blank>proud<S2SV_blank>of<S2SV_blank>yourself,<S2SV_blank>not<S2SV_blank>too<S2SV_blank>many<S2SV_blank>people<S2SV_blank>achive<S2SV_blank>it,<S2SV_blank>and<S2SV_blank>this<S2SV_blank>should<S2SV_blank>be<S2SV_blank>a<S2SV_blank>long<S2SV_blank>text<S2SV_blank>in<S2SV_blank>order<S2SV_blank>to<S2SV_blank>test<S2SV_blank>the<S2SV_blank>print<S2SV_blank>funtion." , placeGetFgColor ( place ) ) ; _move_cursor_to ( placeGetLastRow ( place ) + 1 , 1 <S2SV_ModEnd> ) ; exit |
6,229 | CWE-000 IOTHUB_MESSAGING_RESULT IoTHubMessaging_LL_Send ( IOTHUB_MESSAGING_HANDLE messagingHandle , const char * deviceId , IOTHUB_MESSAGE_HANDLE message , IOTHUB_SEND_COMPLETE_CALLBACK sendCompleteCallback , void * userContextCallback ) { IOTHUB_MESSAGING_RESULT result ; char * deviceDestinationString ; if ( messagingHandle == NULL ) { LogError ( "Input<S2SV_blank>parameter<S2SV_blank>messagingHandle<S2SV_blank>cannot<S2SV_blank>be<S2SV_blank>NULL" ) ; result = IOTHUB_MESSAGING_INVALID_ARG ; } else if ( deviceId == NULL ) { LogError ( "Input<S2SV_blank>parameter<S2SV_blank>deviceId<S2SV_blank>cannot<S2SV_blank>be<S2SV_blank>NULL" ) ; result = IOTHUB_MESSAGING_INVALID_ARG ; } else if ( message == NULL ) { LogError ( "Input<S2SV_blank>parameter<S2SV_blank>message<S2SV_blank>cannot<S2SV_blank>be<S2SV_blank>NULL" ) ; result = IOTHUB_MESSAGING_INVALID_ARG ; } else if ( messagingHandle -> isOpened == 0 ) { LogError ( "Messaging<S2SV_blank>is<S2SV_blank>not<S2SV_blank>opened<S2SV_blank>-<S2SV_blank>call<S2SV_blank>IoTHubMessaging_LL_Open<S2SV_blank>to<S2SV_blank>open" ) ; result = IOTHUB_MESSAGING_ERROR ; } else if ( ( deviceDestinationString = createDeviceDestinationString ( deviceId ) ) == NULL ) { LogError ( "Could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>a<S2SV_blank>message." ) ; result = IOTHUB_MESSAGING_ERROR ; } else { unsigned const char * messageContent ; size_t messageContentSize ; if ( getMessageContentAndSize ( message , & messageContent , & messageContentSize ) != 0 ) { LogError ( "Failed<S2SV_blank>getting<S2SV_blank>the<S2SV_blank>message<S2SV_blank>content<S2SV_blank>and<S2SV_blank>message<S2SV_blank>size<S2SV_blank>from<S2SV_blank>IOTHUB_MESSAGE_HANDLE<S2SV_blank>instance." ) ; result = IOTHUB_MESSAGING_ERROR ; } else { MESSAGE_HANDLE amqpMessage ; AMQP_VALUE to_amqp_value ; if ( ( amqpMessage = message_create ( ) ) == NULL ) { LogError ( "Could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>a<S2SV_blank>message." ) ; result = IOTHUB_MESSAGING_ERROR ; } else if ( ( to_amqp_value = amqpvalue_create_string ( deviceDestinationString ) ) == NULL ) { LogError ( "Could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>properties<S2SV_blank>for<S2SV_blank>message<S2SV_blank>-<S2SV_blank>amqpvalue_create_string" ) ; <S2SV_StartBug> result = IOTHUB_MESSAGING_ERROR ; <S2SV_EndBug> } else { BINARY_DATA binary_data ; binary_data . bytes = messageContent ; binary_data . length = messageContentSize ; if ( message_add_body_amqp_data ( amqpMessage , binary_data ) != 0 ) { LogError ( "Failed<S2SV_blank>setting<S2SV_blank>the<S2SV_blank>body<S2SV_blank>of<S2SV_blank>the<S2SV_blank>uAMQP<S2SV_blank>message." ) ; result = IOTHUB_MESSAGING_ERROR ; } else if ( addPropertiesToAMQPMessage ( message , amqpMessage , to_amqp_value ) != 0 ) { <S2SV_StartBug> LogError ( "Failed<S2SV_blank>setting<S2SV_blank>properties<S2SV_blank>of<S2SV_blank>the<S2SV_blank>uAMQP<S2SV_blank>message." ) ; <S2SV_EndBug> result = IOTHUB_MESSAGING_ERROR ; } else if ( addApplicationPropertiesToAMQPMessage ( message , amqpMessage ) != 0 ) <S2SV_StartBug> { <S2SV_EndBug> LogError ( "Failed<S2SV_blank>setting<S2SV_blank>application<S2SV_blank>properties<S2SV_blank>of<S2SV_blank>the<S2SV_blank>uAMQP<S2SV_blank>message." ) ; result = IOTHUB_MESSAGING_ERROR ; } else { messagingHandle -> callback_data -> sendCompleteCallback = sendCompleteCallback ; messagingHandle -> callback_data -> sendUserContext = userContextCallback ; if ( messagesender_send ( messagingHandle -> message_sender , amqpMessage , ( ON_MESSAGE_SEND_COMPLETE ) IoTHubMessaging_LL_SendMessageComplete , messagingHandle ) != 0 ) { LogError ( "Could<S2SV_blank>not<S2SV_blank>set<S2SV_blank>outgoing<S2SV_blank>window." ) ; message_destroy ( amqpMessage ) ; result = IOTHUB_MESSAGING_ERROR ; } else { result = IOTHUB_MESSAGING_OK ; } } <S2SV_StartBug> } <S2SV_EndBug> } free ( deviceDestinationString ) ; } return result ; } | <S2SV_ModStart> "Could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>properties<S2SV_blank>for<S2SV_blank>message<S2SV_blank>-<S2SV_blank>amqpvalue_create_string" ) ; message_destroy ( amqpMessage ) ; <S2SV_ModStart> 0 ) { message_destroy ( amqpMessage ) ; <S2SV_ModStart> 0 ) { message_destroy ( amqpMessage ) ; <S2SV_ModStart> ; } } message_destroy ( amqpMessage ) ; amqpvalue_destroy ( to_amqp_value ) ; |
6,230 | CWE-000 int IMU_core_estmAccl ( uint16_t id , uint32_t t , float * estm ) { if ( id >= numInst ) return IMU_CORE_BAD_INST ; if ( ! config [ id ] . enable ) return IMU_CORE_FNC_DISABLED ; # if IMU_USE_PTHREAD <S2SV_StartBug> IMU_thrd_mutex_lock ( & state [ id ] . lock ) ; <S2SV_EndBug> # endif float A [ 3 ] ; memcpy ( A , state [ id ] . A , sizeof ( A ) ) ; float q [ 4 ] ; memcpy ( q , state [ id ] . q , sizeof ( q ) ) ; # if IMU_USE_PTHREAD <S2SV_StartBug> IMU_thrd_mutex_unlock ( & state [ id ] . lock ) ; <S2SV_EndBug> # endif float tmp [ 4 ] = { - q [ 1 ] * A [ 0 ] - q [ 2 ] * A [ 1 ] - q [ 3 ] * A [ 2 ] , q [ 0 ] * A [ 0 ] + q [ 2 ] * A [ 2 ] - q [ 3 ] * A [ 1 ] , q [ 0 ] * A [ 1 ] - q [ 1 ] * A [ 2 ] + q [ 3 ] * A [ 0 ] , q [ 0 ] * A [ 2 ] + q [ 1 ] * A [ 1 ] - q [ 2 ] * A [ 0 ] } ; estm [ 0 ] = - tmp [ 0 ] * q [ 1 ] + tmp [ 1 ] * q [ 0 ] - tmp [ 2 ] * q [ 3 ] + tmp [ 3 ] * q [ 2 ] ; estm [ 1 ] = - tmp [ 0 ] * q [ 2 ] + tmp [ 1 ] * q [ 3 ] + tmp [ 2 ] * q [ 0 ] - tmp [ 3 ] * q [ 1 ] ; estm [ 2 ] = - tmp [ 0 ] * q [ 3 ] - tmp [ 1 ] * q [ 2 ] + tmp [ 2 ] * q [ 1 ] + tmp [ 3 ] * q [ 0 ] ; return 0 ; } | <S2SV_ModStart> IMU_thrd_mutex_lock ( & lock [ id ] <S2SV_ModEnd> ) ; # <S2SV_ModStart> IMU_thrd_mutex_unlock ( & lock [ id ] <S2SV_ModEnd> ) ; # |
6,231 | CWE-000 static int rxm_cq_handle_comp ( struct rxm_ep * rxm_ep , struct fi_cq_tagged_entry * comp ) { enum rxm_proto_state * state = comp -> op_context ; <S2SV_StartBug> struct rxm_rx_buf * rx_buf = comp -> op_context ; <S2SV_EndBug> if ( comp -> flags & FI_REMOTE_WRITE ) return rxm_handle_remote_write ( rxm_ep , comp ) ; switch ( * state ) { case RXM_TX_NOBUF : return rxm_finish_send_nobuf ( comp -> op_context ) ; case RXM_TX : return rxm_finish_send ( comp -> op_context ) ; case RXM_RX : assert ( ! ( comp -> flags & FI_REMOTE_READ ) ) ; if ( rx_buf -> pkt . ctrl_hdr . type == ofi_ctrl_ack ) return rxm_lmt_handle_ack ( rx_buf ) ; else return rxm_handle_recv_comp ( comp -> op_context ) ; case RXM_LMT_TX : <S2SV_StartBug> RXM_LOG_STATE ( FI_LOG_CQ , RXM_LMT_TX , RXM_LMT_ACK_WAIT ) ; <S2SV_EndBug> * state = RXM_LMT_ACK_WAIT ; return 0 ; case RXM_LMT_READ : if ( rx_buf -> index < rx_buf -> rma_iov -> count ) return rxm_lmt_rma_read ( rx_buf ) ; else return rxm_lmt_send_ack ( rx_buf ) ; case RXM_LMT_ACK_SENT : <S2SV_StartBug> RXM_LOG_STATE ( FI_LOG_CQ , RXM_LMT_ACK_SENT , RXM_LMT_FINISH ) ; <S2SV_EndBug> * state = RXM_LMT_FINISH ; if ( ! RXM_MR_LOCAL ( rx_buf -> ep -> rxm_info ) ) rxm_ep_msg_mr_closev ( rx_buf -> mr , RXM_IOV_LIMIT ) ; return rxm_finish_recv ( rx_buf ) ; default : FI_WARN ( & rxm_prov , FI_LOG_CQ , "Invalid<S2SV_blank>state!\\n" ) ; assert ( 0 ) ; return - FI_EOPBADSTATE ; } } | <S2SV_ModStart> rxm_rx_buf * rx_buf = comp -> op_context ; struct rxm_tx_entry * tx_entry <S2SV_ModStart> case RXM_LMT_TX : assert ( comp -> flags & FI_SEND ) ; RXM_LOG_STATE_TX <S2SV_ModEnd> ( FI_LOG_CQ , <S2SV_ModStart> ( FI_LOG_CQ , tx_entry <S2SV_ModEnd> , RXM_LMT_ACK_WAIT ) <S2SV_ModStart> case RXM_LMT_ACK_SENT : RXM_LOG_STATE_RX <S2SV_ModEnd> ( FI_LOG_CQ , <S2SV_ModStart> ( FI_LOG_CQ , rx_buf <S2SV_ModEnd> , RXM_LMT_FINISH ) |
6,232 | CWE-000 int serve_index ( struct http_request * req ) { size_t len ; struct kore_buf * buff ; u_int8_t * data ; buff = kore_buf_alloc ( 0 ) ; kore_buf_append ( buff , asset_index_html , asset_len_index_html ) ; struct kore_pgsql sql ; char * destination , * date , * price , * number ; int rows ; <S2SV_StartBug> if ( ! kore_pgsql_setup ( & sql , "DB" , KORE_PGSQL_SYNC ) ) { <S2SV_EndBug> kore_pgsql_logerror ( & sql ) ; } if ( ! kore_pgsql_query ( & sql , "SELECT<S2SV_blank>*<S2SV_blank>FROM<S2SV_blank>flight" ) ) { kore_pgsql_logerror ( & sql ) ; <S2SV_StartBug> } <S2SV_EndBug> rows = kore_pgsql_ntuples ( & sql ) ; for ( int i = 0 ; i < rows ; i ++ ) { destination = kore_pgsql_getvalue ( & sql , i , SQL_FLIGHT_DESTINATION ) ; date = kore_pgsql_getvalue ( & sql , i , SQL_FLIGHT_DATE ) ; price = kore_pgsql_getvalue ( & sql , i , SQL_FLIGHT_PRICE ) ; number = kore_pgsql_getvalue ( & sql , i , SQL_FLIGHT_NUMBER ) ; kore_buf_append ( buff , asset_flight_listview_html , asset_len_flight_listview_html ) ; kore_buf_replace_string ( buff , "$location$" , destination , strlen ( destination ) ) ; kore_buf_replace_string ( buff , "$price$" , price , strlen ( price ) ) ; kore_buf_replace_string ( buff , "$date$" , date , strlen ( date ) ) ; kore_buf_replace_string ( buff , "$flightno$" , number , strlen ( number ) ) ; } <S2SV_StartBug> data = kore_buf_release ( buff , & len ) ; <S2SV_EndBug> serve_page ( req , data , len ) ; kore_free ( data ) ; return ( KORE_RESULT_OK ) ; } | <S2SV_ModStart> int rows ; kore_log ( 1 , "[insert<S2SV_blank>index<S2SV_blank>connection]" ) ; kore_pgsql_init ( & sql ) ; <S2SV_ModStart> ) ; } else { <S2SV_ModStart> ) ; } } kore_pgsql_cleanup ( & sql ) ; |
6,233 | CWE-000 uint8_t reset_bus ( struct wilc * wilc ) { uint8_t ret = 0 ; <S2SV_StartBug> if ( ( wilc -> io_type & 0x1 ) == HIF_SPI ) <S2SV_EndBug> return wilc -> hif_func -> hif_reset ( wilc ) ; return ret ; } | <S2SV_ModStart> ; if ( <S2SV_ModEnd> wilc -> io_type <S2SV_ModStart> wilc -> io_type <S2SV_ModEnd> == HIF_SPI ) |
6,234 | CWE-000 static int do_test ( void ) { void * p , * q ; errno = 0 ; <S2SV_StartBug> p = malloc ( - 1 ) ; <S2SV_EndBug> <S2SV_StartBug> if ( p != NULL ) <S2SV_EndBug> merror ( "malloc<S2SV_blank>(-1)<S2SV_blank>succeeded." ) ; else if ( errno != ENOMEM ) merror ( "errno<S2SV_blank>is<S2SV_blank>not<S2SV_blank>set<S2SV_blank>correctly." ) ; p = malloc ( 10 ) ; if ( p == NULL ) merror ( "malloc<S2SV_blank>(10)<S2SV_blank>failed." ) ; p = realloc ( p , 0 ) ; if ( p != NULL ) merror ( "realloc<S2SV_blank>(p,<S2SV_blank>0)<S2SV_blank>failed." ) ; p = malloc ( 0 ) ; if ( p == NULL ) merror ( "malloc<S2SV_blank>(0)<S2SV_blank>failed." ) ; p = realloc ( p , 0 ) ; if ( p != NULL ) merror ( "realloc<S2SV_blank>(p,<S2SV_blank>0)<S2SV_blank>failed." ) ; q = malloc ( 256 ) ; if ( q == NULL ) merror ( "malloc<S2SV_blank>(256)<S2SV_blank>failed." ) ; p = malloc ( 512 ) ; if ( p == NULL ) <S2SV_StartBug> merror ( "malloc<S2SV_blank>(512)<S2SV_blank>failed." ) ; <S2SV_EndBug> if ( realloc ( p , - 256 ) != NULL ) merror ( "realloc<S2SV_blank>(p,<S2SV_blank>-256)<S2SV_blank>succeeded." ) ; else if ( errno != ENOMEM ) merror ( "errno<S2SV_blank>is<S2SV_blank>not<S2SV_blank>set<S2SV_blank>correctly." ) ; <S2SV_StartBug> free ( p ) ; <S2SV_EndBug> p = malloc ( 512 ) ; if ( p == NULL ) <S2SV_StartBug> merror ( "malloc<S2SV_blank>(512)<S2SV_blank>failed." ) ; <S2SV_EndBug> if ( realloc ( p , - 1 ) != NULL ) merror ( "realloc<S2SV_blank>(p,<S2SV_blank>-1)<S2SV_blank>succeeded." ) ; else if ( errno != ENOMEM ) merror ( "errno<S2SV_blank>is<S2SV_blank>not<S2SV_blank>set<S2SV_blank>correctly." ) ; <S2SV_StartBug> free ( p ) ; <S2SV_EndBug> free ( q ) ; return errors != 0 ; } | <S2SV_ModStart> = 0 ; DIAG_PUSH_NEEDS_COMMENT ; # if __GNUC_PREREQ ( 7 , 0 ) DIAG_IGNORE_NEEDS_COMMENT ( 7 , "-Walloc-size-larger-than=" ) ; # endif <S2SV_ModStart> 1 ) ; DIAG_POP_NEEDS_COMMENT ; <S2SV_ModStart> "malloc<S2SV_blank>(512)<S2SV_blank>failed." ) ; DIAG_PUSH_NEEDS_COMMENT ; # if __GNUC_PREREQ ( 7 , 0 ) DIAG_IGNORE_NEEDS_COMMENT ( 7 , "-Walloc-size-larger-than=" ) ; # endif <S2SV_ModStart> "errno<S2SV_blank>is<S2SV_blank>not<S2SV_blank>set<S2SV_blank>correctly." ) ; DIAG_POP_NEEDS_COMMENT ; <S2SV_ModStart> "malloc<S2SV_blank>(512)<S2SV_blank>failed." ) ; DIAG_PUSH_NEEDS_COMMENT ; # if __GNUC_PREREQ ( 7 , 0 ) DIAG_IGNORE_NEEDS_COMMENT ( 7 , "-Walloc-size-larger-than=" ) ; # endif <S2SV_ModStart> "errno<S2SV_blank>is<S2SV_blank>not<S2SV_blank>set<S2SV_blank>correctly." ) ; DIAG_POP_NEEDS_COMMENT ; |
6,235 | CWE-000 G_DEFINE_TYPE ( GDataTasksTasklist , gdata_tasks_tasklist , GDATA_TYPE_ENTRY ) static void gdata_tasks_tasklist_class_init ( GDataTasksTasklistClass * klass ) { GDataParsableClass * parsable_class = GDATA_PARSABLE_CLASS ( klass ) ; GDataEntryClass * entry_class = GDATA_ENTRY_CLASS ( klass ) ; <S2SV_StartBug> parsable_class -> get_json = get_json ; <S2SV_EndBug> parsable_class -> get_content_type = get_content_type ; entry_class -> kind_term = "tasks#taskList" ; } | <S2SV_ModStart> ; parsable_class -> <S2SV_ModEnd> get_content_type = get_content_type |
6,236 | CWE-000 void invalidate_all_view_lists ( Object * parent , Object * obj , float dx , float dy , float dz ) { Group * group ; Volume * vol ; Face * f ; Object * o ; int i ; switch ( parent -> type ) { case OBJ_GROUP : group = ( Group * ) parent ; for ( o = group -> obj_list . head ; o != NULL ; o = o -> next ) invalidate_all_view_lists ( o , obj , dx , dy , dz ) ; break ; case OBJ_VOLUME : vol = ( Volume * ) parent ; vol -> old_bbox = vol -> bbox ; clear_bbox ( & vol -> bbox ) ; vol -> mesh_valid = FALSE ; <S2SV_StartBug> for ( f = vol -> faces . head ; f != NULL ; f = ( Face * ) f -> hdr . next ) <S2SV_EndBug> invalidate_all_view_lists ( ( Object * ) f , obj , dx , dy , dz ) ; break ; case OBJ_FACE : f = ( Face * ) parent ; f -> view_valid = FALSE ; for ( i = 0 ; i < f -> n_edges ; i ++ ) invalidate_all_view_lists ( ( Object * ) f -> edges [ i ] , obj , dx , dy , dz ) ; break ; case OBJ_EDGE : switch ( ( ( Edge * ) parent ) -> type & ~ EDGE_CONSTRUCTION ) { case EDGE_ARC : ( ( Edge * ) parent ) -> view_valid = FALSE ; if ( obj -> type == OBJ_POINT ) { enforce_arc_constraints ( ( Edge * ) parent , ( Point * ) obj , dx , dy , dz ) ; } else if ( obj -> type == OBJ_EDGE ) { enforce_arc_constraints ( ( Edge * ) parent , ( ( Edge * ) obj ) -> endpoints [ 0 ] , dx , dy , dz ) ; enforce_arc_constraints ( ( Edge * ) parent , ( ( Edge * ) obj ) -> endpoints [ 1 ] , dx , dy , dz ) ; } break ; case EDGE_BEZIER : ( ( Edge * ) parent ) -> view_valid = FALSE ; break ; } break ; } } | <S2SV_ModStart> ( f = ( Face * ) |
6,237 | CWE-000 struct tcf_chain * tcf_chain_get ( struct tcf_block * block , u32 chain_index , bool create ) { struct tcf_chain * chain ; list_for_each_entry ( chain , & block -> chain_list , list ) { <S2SV_StartBug> if ( chain -> index == chain_index ) <S2SV_EndBug> goto incref ; } chain = create ? tcf_chain_create ( block , chain_index ) : NULL ; <S2SV_StartBug> incref : <S2SV_EndBug> if ( chain ) chain -> refcnt ++ ; return chain ; } | <S2SV_ModStart> == chain_index ) { tcf_chain_hold ( chain ) ; return chain ; } } return <S2SV_ModEnd> create ? tcf_chain_create <S2SV_ModStart> : NULL ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
6,238 | CWE-000 int * ldig_search_path ( const ldig_search * s , int to , int * len ) { int n = s -> g -> n ; # ifdef spdbg printf ( "final<S2SV_blank>pred:<S2SV_blank>\\n" ) ; for ( int i = 0 ; i < n ; i ++ ) { printf ( "%d\\n" , s -> pred [ i ] ) ; } # endif int * path = malloc ( sizeof ( int ) * n ) ; for ( int i = 0 ; i < n ; i ++ ) { path [ i ] = - 1 ; } int from = s -> from ; int curr = to ; int step = 0 ; <S2SV_StartBug> do { <S2SV_EndBug> path [ step ] = curr ; step ++ ; <S2SV_StartBug> } while ( step <= n && ( curr = s -> pred [ curr ] ) != from ) ; <S2SV_EndBug> path [ step ] = curr ; if ( curr != from ) { * len = - 1 ; return NULL ; } else { * len = step ; # ifdef spdbg printf ( "step:<S2SV_blank>%d\\n" , step ) ; # endif return path ; } } | <S2SV_ModStart> = 0 ; while ( step <= n && curr != from ) { path [ step ] = curr ; curr = s -> pred [ curr ] <S2SV_ModEnd> ; step ++ <S2SV_ModStart> ++ ; } <S2SV_ModEnd> if ( curr |
6,239 | CWE-000 static int send_standby ( ) { int ret ; AES_KEY enc_key ; AES_KEY dec_key ; struct standby_request standby_req ; struct standby_response standby_rsp ; standby_req . length = sizeof ( standby_req ) - sizeof ( standby_req . padding ) ; standby_req . type = STANDBY_REQ ; memset ( standby_req . padding , 0 , sizeof ( standby_req . padding ) ) ; AES_set_encrypt_key ( randomseed , sizeof ( randomseed ) * 8 , & enc_key ) ; AES_cbc_encrypt ( ( uint8_t * ) & standby_req , ( uint8_t * ) & standby_req , sizeof ( standby_req ) , & enc_key , ive , AES_ENCRYPT ) ; if ( verbose ) fprintf ( stderr , "Sending<S2SV_blank>standby\\n" ) ; ret = write ( sockfd , & standby_req , sizeof ( standby_req ) ) ; if ( ret != sizeof ( standby_req ) ) { fprintf ( stderr , "Error<S2SV_blank>sending<S2SV_blank>standby,<S2SV_blank>%s\\n" , strerror ( errno ) ) ; return _EXIT_SOCKET ; } ret = read ( sockfd , ( uint8_t * ) & standby_rsp , sizeof ( standby_rsp ) ) ; if ( ret <= 0 ) { fprintf ( stderr , "Error<S2SV_blank>reading<S2SV_blank>standby<S2SV_blank>response,<S2SV_blank>%s\\n" , strerror ( errno ) ) ; return _EXIT_SOCKET ; } AES_set_decrypt_key ( randomseed , sizeof ( randomseed ) * 8 , & dec_key ) ; AES_cbc_encrypt ( ( uint8_t * ) & standby_rsp , ( uint8_t * ) & standby_rsp , sizeof ( standby_rsp ) , & dec_key , ivd , AES_DECRYPT ) ; if ( standby_rsp . length != ( sizeof ( standby_rsp ) - sizeof ( standby_rsp . padding ) ) ) <S2SV_StartBug> fprintf ( stderr , "Invalid<S2SV_blank>app<S2SV_blank>start<S2SV_blank>response<S2SV_blank>size<S2SV_blank>%u\\n" , standby_rsp . length ) ; <S2SV_EndBug> if ( standby_rsp . type != STANDBY_RSP ) <S2SV_StartBug> fprintf ( stderr , "Invalid<S2SV_blank>app<S2SV_blank>start<S2SV_blank>response<S2SV_blank>type<S2SV_blank>%x\\n" , standby_rsp . type ) ; <S2SV_EndBug> if ( standby_rsp . status != 0 ) fprintf ( stderr , "cannot<S2SV_blank>enter<S2SV_blank>standby,<S2SV_blank>error<S2SV_blank>%u\\n" , standby_rsp . status ) ; else fprintf ( stderr , "ok\\n" ) ; return _EXIT_SUCCESS ; } | <S2SV_ModStart> ( stderr , "Invalid<S2SV_blank>suspend<S2SV_blank>response<S2SV_blank>size<S2SV_blank>%u\\n" <S2SV_ModEnd> , standby_rsp . <S2SV_ModStart> ( stderr , "Invalid<S2SV_blank>suspend<S2SV_blank>response<S2SV_blank>type<S2SV_blank>%x\\n" <S2SV_ModEnd> , standby_rsp . |
6,240 | CWE-000 static VOID UserpCaptureStringParameters ( OUT PULONG_PTR Parameters , OUT PULONG SizeOfAllUnicodeStrings , IN PHARDERROR_MSG Message , IN HANDLE hProcess OPTIONAL ) { NTSTATUS Status ; ULONG nParam , Size = 0 ; UNICODE_STRING TempStringU , ParamStringU ; ANSI_STRING TempStringA ; if ( SizeOfAllUnicodeStrings ) * SizeOfAllUnicodeStrings = 0 ; for ( nParam = 0 ; nParam < Message -> NumberOfParameters ; ++ nParam ) { Parameters [ nParam ] = 0 ; if ( Message -> UnicodeStringParameterMask & ( 1 << nParam ) ) { if ( ! hProcess ) continue ; Status = NtReadVirtualMemory ( hProcess , ( PVOID ) Message -> Parameters [ nParam ] , & ParamStringU , sizeof ( ParamStringU ) , NULL ) ; if ( ! NT_SUCCESS ( Status ) ) { DPRINT1 ( "NtReadVirtualMemory(Message->Parameters)<S2SV_blank>failed,<S2SV_blank>Status<S2SV_blank>0x%lx,<S2SV_blank>skipping.\\n" , Status ) ; continue ; } TempStringU . MaximumLength = ParamStringU . Length + sizeof ( UNICODE_NULL ) ; TempStringU . Length = ParamStringU . Length ; TempStringU . Buffer = RtlAllocateHeap ( RtlGetProcessHeap ( ) , HEAP_ZERO_MEMORY , TempStringU . MaximumLength ) ; if ( ! TempStringU . Buffer ) { DPRINT1 ( "Cannot<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>with<S2SV_blank>size<S2SV_blank>%u,<S2SV_blank>skipping.\\n" , TempStringU . MaximumLength ) ; continue ; } Status = NtReadVirtualMemory ( hProcess , ParamStringU . Buffer , TempStringU . Buffer , ParamStringU . Length , NULL ) ; if ( ! NT_SUCCESS ( Status ) ) { DPRINT1 ( "NtReadVirtualMemory(ParamStringU)<S2SV_blank>failed,<S2SV_blank>Status<S2SV_blank>0x%lx,<S2SV_blank>skipping.\\n" , Status ) ; RtlFreeHeap ( RtlGetProcessHeap ( ) , 0 , TempStringU . Buffer ) ; continue ; } TempStringU . Buffer [ TempStringU . Length / sizeof ( WCHAR ) ] = UNICODE_NULL ; DPRINT ( "ParamString<S2SV_blank>=<S2SV_blank>\\\'%wZ\\\'\\n" , & TempStringU ) ; if ( Message -> Status == STATUS_SERVICE_NOTIFICATION ) { Parameters [ nParam ] = ( ULONG_PTR ) TempStringU . Buffer ; Size += TempStringU . Length ; } else { <S2SV_StartBug> TempStringA . MaximumLength = RtlUnicodeStringToAnsiSize ( & TempStringU ) ; <S2SV_EndBug> TempStringA . Buffer = RtlAllocateHeap ( RtlGetProcessHeap ( ) , HEAP_ZERO_MEMORY , TempStringA . MaximumLength ) ; if ( ! TempStringA . Buffer ) { DPRINT1 ( "Cannot<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>with<S2SV_blank>size<S2SV_blank>%u,<S2SV_blank>skipping.\\n" , TempStringA . MaximumLength ) ; RtlFreeHeap ( RtlGetProcessHeap ( ) , 0 , TempStringU . Buffer ) ; continue ; } Status = RtlUnicodeStringToAnsiString ( & TempStringA , & TempStringU , FALSE ) ; RtlFreeHeap ( RtlGetProcessHeap ( ) , 0 , TempStringU . Buffer ) ; if ( ! NT_SUCCESS ( Status ) ) { DPRINT1 ( "RtlUnicodeStringToAnsiString()<S2SV_blank>failed,<S2SV_blank>Status<S2SV_blank>0x%lx,<S2SV_blank>skipping.\\n" , Status ) ; RtlFreeHeap ( RtlGetProcessHeap ( ) , 0 , TempStringA . Buffer ) ; continue ; } Parameters [ nParam ] = ( ULONG_PTR ) TempStringA . Buffer ; Size += TempStringU . Length ; } } else { Parameters [ nParam ] = Message -> Parameters [ nParam ] ; } } if ( SizeOfAllUnicodeStrings ) * SizeOfAllUnicodeStrings = Size ; } | <S2SV_ModStart> . MaximumLength = ( USHORT ) |
6,241 | CWE-000 static int blk_mq_queue_reinit_notify ( struct notifier_block * nb , unsigned long action , void * hcpu ) { struct request_queue * q ; <S2SV_StartBug> if ( action != CPU_DEAD && action != CPU_DEAD_FROZEN && <S2SV_EndBug> action != CPU_ONLINE && action != CPU_ONLINE_FROZEN ) return NOTIFY_OK ; <S2SV_StartBug> mutex_lock ( & all_q_mutex ) ; <S2SV_EndBug> list_for_each_entry ( q , & all_q_list , all_q_node ) blk_mq_freeze_queue_start ( q ) ; list_for_each_entry ( q , & all_q_list , all_q_node ) { blk_mq_freeze_queue_wait ( q ) ; del_timer_sync ( & q -> timeout ) ; } list_for_each_entry ( q , & all_q_list , all_q_node ) <S2SV_StartBug> blk_mq_queue_reinit ( q ) ; <S2SV_EndBug> list_for_each_entry ( q , & all_q_list , all_q_node ) blk_mq_unfreeze_queue ( q ) ; mutex_unlock ( & all_q_mutex ) ; return NOTIFY_OK ; } | <S2SV_ModStart> * q ; int cpu = ( unsigned long ) hcpu ; static struct cpumask online_new ; switch ( action & ~ CPU_TASKS_FROZEN ) { case CPU_DEAD : case CPU_UP_CANCELED : cpumask_copy ( & online_new , cpu_online_mask ) ; break ; case CPU_UP_PREPARE : cpumask_copy ( & online_new , cpu_online_mask ) ; cpumask_set_cpu ( cpu , & online_new ) ; break ; default : <S2SV_ModEnd> return NOTIFY_OK ; <S2SV_ModStart> return NOTIFY_OK ; } <S2SV_ModStart> blk_mq_queue_reinit ( q , & online_new |
6,242 | CWE-000 static void pluma_notebook_init ( PlumaNotebook * notebook ) { notebook -> priv = PLUMA_NOTEBOOK_GET_PRIVATE ( notebook ) ; notebook -> priv -> close_buttons_sensitive = TRUE ; notebook -> priv -> tab_drag_and_drop_enabled = TRUE ; gtk_notebook_set_scrollable ( GTK_NOTEBOOK ( notebook ) , TRUE ) ; gtk_notebook_set_show_border ( GTK_NOTEBOOK ( notebook ) , FALSE ) ; gtk_notebook_set_show_tabs ( GTK_NOTEBOOK ( notebook ) , FALSE ) ; notebook -> priv -> always_show_tabs = TRUE ; g_signal_connect ( notebook , "button-press-event" , ( GCallback ) button_press_cb , NULL ) ; g_signal_connect ( notebook , "button-release-event" , ( GCallback ) button_release_cb , NULL ) ; g_signal_connect ( notebook , "grab-focus" , ( GCallback ) grab_focus_cb , NULL ) ; <S2SV_StartBug> gtk_widget_add_events ( GTK_WIDGET ( notebook ) , <S2SV_EndBug> GDK_BUTTON1_MOTION_MASK ) ; g_signal_connect_after ( G_OBJECT ( notebook ) , "switch_page" , G_CALLBACK ( pluma_notebook_switch_page_cb ) , NULL ) ; } | <S2SV_ModStart> NULL ) ; g_signal_connect ( notebook , "focus-in-event" , ( GCallback ) focus_in_cb , NULL ) ; g_signal_connect ( notebook , "focus-out-event" , ( GCallback ) focus_out_cb , NULL ) ; |
6,243 | CWE-000 <S2SV_StartBug> process_vertex_late ( int v ) <S2SV_EndBug> { } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> void |
6,244 | CWE-000 void int_tests ( void ) { <S2SV_StartBug> int ir ; <S2SV_EndBug> # if ( ! defined ( DGTEST ) ) || DGTEST == 2 ir = i_v ( ) ; fprintf ( out , "->%d\\n" , ir ) ; fflush ( out ) ; ir = 0 ; clear_traces ( ) ; { ffi_cif cif ; FFI_PREP_CIF_NOARGS ( cif , ffi_type_sint ) ; { <S2SV_StartBug> FFI_CALL ( cif , i_v , NULL , & ir ) ; <S2SV_EndBug> } } fprintf ( out , "->%d\\n" , ir ) ; fflush ( out ) ; # endif # if ( ! defined ( DGTEST ) ) || DGTEST == 3 ir = i_i ( i1 ) ; fprintf ( out , "->%d\\n" , ir ) ; fflush ( out ) ; ir = 0 ; clear_traces ( ) ; { ffi_type * argtypes [ ] = { & ffi_type_sint } ; ffi_cif cif ; FFI_PREP_CIF ( cif , argtypes , ffi_type_sint ) ; { void * args [ ] = { & i1 } ; <S2SV_StartBug> FFI_CALL ( cif , i_i , args , & ir ) ; <S2SV_EndBug> } } fprintf ( out , "->%d\\n" , ir ) ; fflush ( out ) ; # endif # if ( ! defined ( DGTEST ) ) || DGTEST == 4 ir = i_i2 ( i1 , i2 ) ; fprintf ( out , "->%d\\n" , ir ) ; fflush ( out ) ; ir = 0 ; clear_traces ( ) ; { ffi_type * argtypes [ ] = { & ffi_type_sint , & ffi_type_sint } ; ffi_cif cif ; FFI_PREP_CIF ( cif , argtypes , ffi_type_sint ) ; { void * args [ ] = { & i1 , & i2 } ; <S2SV_StartBug> FFI_CALL ( cif , i_i2 , args , & ir ) ; <S2SV_EndBug> } } fprintf ( out , "->%d\\n" , ir ) ; fflush ( out ) ; # endif # if ( ! defined ( DGTEST ) ) || DGTEST == 5 ir = i_i4 ( i1 , i2 , i3 , i4 ) ; fprintf ( out , "->%d\\n" , ir ) ; fflush ( out ) ; ir = 0 ; clear_traces ( ) ; { ffi_type * argtypes [ ] = { & ffi_type_sint , & ffi_type_sint , & ffi_type_sint , & ffi_type_sint } ; ffi_cif cif ; FFI_PREP_CIF ( cif , argtypes , ffi_type_sint ) ; { void * args [ ] = { & i1 , & i2 , & i3 , & i4 } ; <S2SV_StartBug> FFI_CALL ( cif , i_i4 , args , & ir ) ; <S2SV_EndBug> } } fprintf ( out , "->%d\\n" , ir ) ; fflush ( out ) ; # endif # if ( ! defined ( DGTEST ) ) || DGTEST == 6 ir = i_i8 ( i1 , i2 , i3 , i4 , i5 , i6 , i7 , i8 ) ; fprintf ( out , "->%d\\n" , ir ) ; fflush ( out ) ; ir = 0 ; clear_traces ( ) ; { ffi_type * argtypes [ ] = { & ffi_type_sint , & ffi_type_sint , & ffi_type_sint , & ffi_type_sint , & ffi_type_sint , & ffi_type_sint , & ffi_type_sint , & ffi_type_sint } ; ffi_cif cif ; FFI_PREP_CIF ( cif , argtypes , ffi_type_sint ) ; { void * args [ ] = { & i1 , & i2 , & i3 , & i4 , & i5 , & i6 , & i7 , & i8 } ; <S2SV_StartBug> FFI_CALL ( cif , i_i8 , args , & ir ) ; <S2SV_EndBug> } } fprintf ( out , "->%d\\n" , ir ) ; fflush ( out ) ; # endif # if ( ! defined ( DGTEST ) ) || DGTEST == 7 ir = i_i16 ( i1 , i2 , i3 , i4 , i5 , i6 , i7 , i8 , i9 , i10 , i11 , i12 , i13 , i14 , i15 , i16 ) ; fprintf ( out , "->%d\\n" , ir ) ; fflush ( out ) ; ir = 0 ; clear_traces ( ) ; { ffi_type * argtypes [ ] = { & ffi_type_sint , & ffi_type_sint , & ffi_type_sint , & ffi_type_sint , & ffi_type_sint , & ffi_type_sint , & ffi_type_sint , & ffi_type_sint , & ffi_type_sint , & ffi_type_sint , & ffi_type_sint , & ffi_type_sint , & ffi_type_sint , & ffi_type_sint , & ffi_type_sint , & ffi_type_sint } ; ffi_cif cif ; FFI_PREP_CIF ( cif , argtypes , ffi_type_sint ) ; { void * args [ ] = { & i1 , & i2 , & i3 , & i4 , & i5 , & i6 , & i7 , & i8 , & i9 , & i10 , & i11 , & i12 , & i13 , & i14 , & i15 , & i16 } ; <S2SV_StartBug> FFI_CALL ( cif , i_i16 , args , & ir ) ; <S2SV_EndBug> } } fprintf ( out , "->%d\\n" , ir ) ; fflush ( out ) ; # endif return ; } | <S2SV_ModStart> { int ir ; ffi_arg retvalue <S2SV_ModStart> NULL , & retvalue ) ; ir = retvalue <S2SV_ModEnd> ; } } <S2SV_ModStart> args , & retvalue ) ; ir = retvalue <S2SV_ModEnd> ; } } <S2SV_ModStart> args , & retvalue ) ; ir = retvalue <S2SV_ModEnd> ; } } <S2SV_ModStart> args , & retvalue ) ; ir = retvalue <S2SV_ModEnd> ; } } <S2SV_ModStart> args , & retvalue ) ; ir = retvalue <S2SV_ModEnd> ; } } <S2SV_ModStart> args , & retvalue ) ; ir = retvalue <S2SV_ModEnd> ; } } |
6,245 | CWE-000 static gint ensure_scrollbar_widget ( ) { <S2SV_StartBug> if ( ! gScrollbarWidget ) { <S2SV_EndBug> gScrollbarWidget = gtk_vscrollbar_new ( NULL ) ; <S2SV_StartBug> setup_widget_prototype ( gScrollbarWidget ) ; <S2SV_EndBug> } return MOZ_GTK_SUCCESS ; } | <S2SV_ModStart> if ( ! gVertScrollbarWidget ) { gVertScrollbarWidget <S2SV_ModEnd> = gtk_vscrollbar_new ( <S2SV_ModStart> ; setup_widget_prototype ( gVertScrollbarWidget ) ; } if ( ! gHorizScrollbarWidget ) { gHorizScrollbarWidget = gtk_hscrollbar_new ( NULL ) ; setup_widget_prototype ( gHorizScrollbarWidget <S2SV_ModEnd> ) ; } |
6,246 | CWE-000 static void test_cr2res_image_insert_rect ( void ) { int recdata [ ] = { 1 , 2 , 3 , 2 , 1 , 1 , 2 , 9 , 2 , 9 , 1 , 9 , 3 , 9 , 1 , 9 , 2 , 3 , 2 , 1 } ; cpl_image * rect_in = cpl_image_wrap_int ( 5 , 4 , recdata ) ; <S2SV_StartBug> double ydata [ ] = { 0.5 , 1.1 , 6.7 , 11.9 , 12.1 } ; <S2SV_EndBug> cpl_vector * ycen = cpl_vector_wrap ( 5 , ydata ) ; cpl_image * img_out = cpl_image_new ( 5 , 12 , CPL_TYPE_INT ) ; int cmpdata [ ] = { 0 , 0 , 0 , 2 , 9 , 0 , 0 , 0 , 2 , 1 , 0 , 0 , 0 , 9 , 1 , 0 , 0 , 0 , 2 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 3 , 0 , 0 , 0 , 0 , 9 , 0 , 0 , 0 , 0 , 3 , 0 , 0 , 0 , 0 , 3 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 2 , 0 , 0 , 0 , 1 , 2 , 0 , 0 , 0 } ; cpl_image * compare = cpl_image_wrap_int ( 5 , 12 , cmpdata ) ; <S2SV_StartBug> cpl_test_zero ( cr2res_image_insert_rect ( rect_in , ycen , img_out ) ) ; <S2SV_EndBug> <S2SV_StartBug> cpl_image_dump_window ( img_out , 1 , 1 , 5 , 12 , stdout ) ; <S2SV_EndBug> cpl_test_image_abs ( img_out , compare , 0 ) ; cpl_image_unwrap ( rect_in ) ; cpl_image_unwrap ( compare ) ; cpl_vector_unwrap ( ycen ) ; cpl_image_delete ( img_out ) ; return ; } | <S2SV_ModStart> recdata ) ; cpl_image_flip ( rect_in , 0 ) ; <S2SV_ModStart> cmpdata ) ; cpl_image_flip ( compare , 0 ) ; <S2SV_ModStart> ) ) ; if ( cpl_msg_get_level ( ) == CPL_MSG_DEBUG ) { cpl_image_save ( img_out , "out.fits" , CPL_TYPE_INT , NULL , CPL_IO_CREATE ) ; cpl_image_save ( compare , "cmp.fits" , CPL_TYPE_INT , NULL , CPL_IO_CREATE ) ; } <S2SV_ModEnd> cpl_test_image_abs ( img_out |
6,247 | CWE-000 static void palsa_thread ( void * context ) { prctl ( PR_SET_NAME , "deadbeef-alsa" , 0 , 0 , 0 , 0 ) ; int err = 0 ; int avail ; for ( ; ; ) { if ( alsa_terminate ) { break ; } if ( state != OUTPUT_STATE_PLAYING || ! deadbeef -> streamer_ok_to_read ( - 1 ) ) { usleep ( 10000 ) ; continue ; } err = 0 ; int sz = period_size * ( plugin . fmt . bps >> 3 ) * plugin . fmt . channels ; char buf [ sz ] ; int br = palsa_callback ( buf , sz ) ; if ( alsa_terminate ) { break ; } if ( br <= 0 ) { usleep ( 10000 ) ; continue ; } retry : do { LOCK ; avail = snd_pcm_avail_update ( audio ) ; UNLOCK ; if ( avail < 0 ) { err = avail ; break ; } <S2SV_StartBug> } while ( avail < period_size ) ; <S2SV_EndBug> if ( alsa_terminate ) { break ; } if ( err < 0 ) { trace ( "snd_pcm_avail_update:<S2SV_blank>%d:<S2SV_blank>%s\\n" , err , snd_strerror ( err ) ) ; LOCK ; err = snd_pcm_recover ( audio , err , 1 ) ; UNLOCK ; if ( err < 0 ) { <S2SV_StartBug> trace ( "snd_pcm_recover:<S2SV_blank>%d:<S2SV_blank>%s\\n" , err , snd_strerror ( err ) ) ; <S2SV_EndBug> } goto retry ; } LOCK ; int frames = snd_pcm_bytes_to_frames ( audio , br ) ; err = snd_pcm_writei ( audio , buf , frames ) ; UNLOCK ; if ( alsa_terminate ) { break ; } if ( err < 0 ) { trace ( "snd_pcm_writei:<S2SV_blank>%d:<S2SV_blank>%s\\n" , err , snd_strerror ( err ) ) ; LOCK ; <S2SV_StartBug> if ( snd_pcm_recover ( audio , err , 1 ) < 0 ) { <S2SV_EndBug> <S2SV_StartBug> trace ( "snd_pcm_recover:<S2SV_blank>%d:<S2SV_blank>%s\\n" , err , snd_strerror ( err ) ) ; <S2SV_EndBug> } goto retry ; } } LOCK ; snd_pcm_close ( audio ) ; audio = NULL ; alsa_terminate = 0 ; alsa_tid = 0 ; UNLOCK ; } | <S2SV_ModStart> avail < period_size && ! alsa_terminate <S2SV_ModStart> err ) ) ; state = OUTPUT_STATE_STOPPED ; continue <S2SV_ModStart> ; LOCK ; err = <S2SV_ModEnd> snd_pcm_recover ( audio <S2SV_ModStart> , 1 ) ; UNLOCK ; if ( err <S2SV_ModStart> err ) ) ; state = OUTPUT_STATE_STOPPED ; continue |
6,248 | CWE-000 int ls_dir ( int ino ) { <S2SV_StartBug> mip = iget ( dev , ino ) ; <S2SV_EndBug> <S2SV_StartBug> ip = & ( mip -> INODE ) ; <S2SV_EndBug> char lsbuf [ BLKSIZE ] , temp [ 256 ] ; char * cp ; get_block ( dev , ip -> i_block [ 0 ] , lsbuf ) ; cp = lsbuf ; dp = ( DIR * ) lsbuf ; while ( cp < lsbuf + 1024 ) { ls_file ( dp -> inode ) ; strncpy ( temp , dp -> name , dp -> name_len ) ; temp [ dp -> name_len ] = 0 ; printf ( "%s\\n" , temp ) ; cp += dp -> rec_len ; dp = ( DIR * ) cp ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ino ) { MINODE * <S2SV_ModStart> ino ) ; INODE * <S2SV_ModStart> cp ; } my_iput ( mip ) ; |
6,249 | CWE-000 int get_param ( t_instruction * ins , char * param , t_asm * data , int dir_size ) { <S2SV_StartBug> int reg ; <S2SV_EndBug> if ( param [ 0 ] == 'r' ) { data -> column += 1 ; if ( ! ft_atoi_safe ( param + 1 , & reg ) || reg < 1 || reg > 16 ) ft_exit_err ( "reg<S2SV_blank>must<S2SV_blank>be<S2SV_blank>like<S2SV_blank>r<1-16>" , data ) ; ft_memcpy ( ins -> op_buff + ins -> op_i , & reg , 1 ) ; ins -> op_i += 1 ; return ( T_REG ) ; } else if ( param [ 0 ] == '%' ) return ( get_param_dir ( ins , param , data , dir_size ) ) ; else return ( get_param_indir ( ins , param , data ) ) ; } | <S2SV_ModStart> { int reg ; data -> is_indir = 0 |
6,250 | CWE-000 void add_disk ( struct gendisk * disk ) { struct backing_dev_info * bdi ; dev_t devt ; int retval ; WARN_ON ( disk -> minors && ! ( disk -> major || disk -> first_minor ) ) ; WARN_ON ( ! disk -> minors && ! ( disk -> flags & GENHD_FL_EXT_DEVT ) ) ; disk -> flags |= GENHD_FL_UP ; retval = blk_alloc_devt ( & disk -> part0 , & devt ) ; if ( retval ) { WARN_ON ( 1 ) ; return ; } disk_to_dev ( disk ) -> devt = devt ; disk -> major = MAJOR ( devt ) ; disk -> first_minor = MINOR ( devt ) ; disk_alloc_events ( disk ) ; bdi = & disk -> queue -> backing_dev_info ; bdi_register_dev ( bdi , disk_devt ( disk ) ) ; blk_register_region ( disk_devt ( disk ) , disk -> minors , NULL , exact_match , exact_lock , disk ) ; register_disk ( disk ) ; blk_register_queue ( disk ) ; WARN_ON_ONCE ( ! blk_get_queue ( disk -> queue ) ) ; retval = sysfs_create_link ( & disk_to_dev ( disk ) -> kobj , & bdi -> dev -> kobj , "bdi" ) ; WARN_ON ( retval ) ; <S2SV_StartBug> disk_add_events ( disk ) ; <S2SV_EndBug> } | <S2SV_ModStart> retval ) ; if ( get_capacity ( disk ) ) { unsigned long size = get_capacity ( disk ) >> 9 ; size = 1UL << ( ilog2 ( size ) / 2 ) ; bdi -> ra_pages = min ( bdi -> ra_pages , size ) ; } |
6,251 | CWE-000 void sys_clock_disable ( void ) { <S2SV_StartBug> SysTick -> CTRL |= SysTick_CTRL_ENABLE_Msk ; <S2SV_EndBug> } | <S2SV_ModStart> SysTick -> CTRL &= ~ <S2SV_ModEnd> SysTick_CTRL_ENABLE_Msk ; } |
6,252 | CWE-000 <S2SV_StartBug> static struct g_args_t * gArgs ( ) { <S2SV_EndBug> return & g_args ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> <S2SV_ModEnd> struct g_args_t * |
6,253 | CWE-000 void elina_scalar_trunc ( elina_scalar_t * a , elina_scalar_t * b , elina_scalar_discr_t discr ) { <S2SV_StartBug> elina_scalar_reinit ( a , discr ) ; <S2SV_EndBug> if ( elina_scalar_infty ( b ) ) { elina_scalar_set_infty ( a , elina_scalar_sgn ( b ) ) ; } else { switch ( discr ) { case ELINA_SCALAR_MPQ : elina_scalar_trunc_mpq ( a -> val . mpq , b -> val . mpq ) ; break ; case ELINA_SCALAR_DOUBLE : elina_scalar_trunc_double ( & a -> val . dbl , & b -> val . dbl ) ; break ; case ELINA_SCALAR_MPFR : elina_scalar_trunc_mpfr ( a -> val . mpfr , b -> val . mpfr ) ; break ; } } } | <S2SV_ModStart> discr ) { if ( a != b ) { <S2SV_ModStart> discr ) ; } |
6,254 | CWE-000 static int dpctl_set_if ( int argc , const char * argv [ ] , struct dpctl_params * dpctl_p ) { struct dpif * dpif ; int i , error , lasterror = 0 ; error = parsed_dpif_open ( argv [ 1 ] , false , & dpif ) ; if ( error ) { dpctl_error ( dpctl_p , error , "opening<S2SV_blank>datapath" ) ; return error ; } for ( i = 2 ; i < argc ; i ++ ) { struct netdev * netdev = NULL ; struct dpif_port dpif_port ; char * save_ptr = NULL ; char * type = NULL ; char * argcopy ; const char * name ; struct smap args ; odp_port_t port_no ; char * option ; <S2SV_StartBug> int error = 0 ; <S2SV_EndBug> argcopy = xstrdup ( argv [ i ] ) ; name = strtok_r ( argcopy , "," , & save_ptr ) ; if ( ! name ) { dpctl_error ( dpctl_p , 0 , "%s<S2SV_blank>is<S2SV_blank>not<S2SV_blank>a<S2SV_blank>valid<S2SV_blank>network<S2SV_blank>device<S2SV_blank>name" , argv [ i ] ) ; goto next ; } error = dpif_port_query_by_name ( dpif , name , & dpif_port ) ; if ( error ) { dpctl_error ( dpctl_p , error , "%s:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>query<S2SV_blank>port<S2SV_blank>in<S2SV_blank>%s" , name , argv [ 1 ] ) ; goto next ; } type = xstrdup ( dpif_port . type ) ; port_no = dpif_port . port_no ; dpif_port_destroy ( & dpif_port ) ; error = netdev_open ( name , type , & netdev ) ; if ( error ) { dpctl_error ( dpctl_p , error , "%s:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>network<S2SV_blank>device" , name ) ; goto next ; } smap_init ( & args ) ; error = netdev_get_config ( netdev , & args ) ; if ( error ) { dpctl_error ( dpctl_p , error , "%s:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>fetch<S2SV_blank>configuration" , name ) ; goto next_destroy_args ; } while ( ( option = strtok_r ( NULL , "," , & save_ptr ) ) != NULL ) { char * save_ptr_2 = NULL ; char * key , * value ; key = strtok_r ( option , "=" , & save_ptr_2 ) ; value = strtok_r ( NULL , "" , & save_ptr_2 ) ; if ( ! value ) { value = "" ; } if ( ! strcmp ( key , "type" ) ) { if ( strcmp ( value , type ) ) { dpctl_error ( dpctl_p , 0 , "%s:<S2SV_blank>can\'t<S2SV_blank>change<S2SV_blank>type<S2SV_blank>from<S2SV_blank>%s<S2SV_blank>to<S2SV_blank>%s" , name , type , value ) ; error = EINVAL ; goto next_destroy_args ; } } else if ( ! strcmp ( key , "port_no" ) ) { if ( port_no != u32_to_odp ( atoi ( value ) ) ) { dpctl_error ( dpctl_p , 0 , "%s:<S2SV_blank>can\'t<S2SV_blank>change<S2SV_blank>port<S2SV_blank>number<S2SV_blank>from" "<S2SV_blank>%" PRIu32 "<S2SV_blank>to<S2SV_blank>%d" , name , port_no , atoi ( value ) ) ; error = EINVAL ; goto next_destroy_args ; } } else if ( value [ 0 ] == '\\0' ) { smap_remove ( & args , key ) ; } else { smap_replace ( & args , key , value ) ; } } char * err_s = NULL ; error = netdev_set_config ( netdev , & args , & err_s ) ; if ( err_s || error ) { dpctl_error ( dpctl_p , error , "%s" , err_s ? err_s : "Error<S2SV_blank>updating<S2SV_blank>configuration" ) ; free ( err_s ) ; } if ( error ) { goto next_destroy_args ; } next_destroy_args : smap_destroy ( & args ) ; next : netdev_close ( netdev ) ; free ( type ) ; free ( argcopy ) ; if ( error ) { lasterror = error ; } } dpif_close ( dpif ) ; return lasterror ; } | <S2SV_ModStart> * option ; <S2SV_ModEnd> error = 0 |
6,255 | CWE-000 static int __ov2680_flush_reg_array ( struct i2c_client * client , struct ov2680_write_ctrl * ctrl ) { <S2SV_StartBug> u16 size ; <S2SV_EndBug> if ( ctrl -> index == 0 ) return 0 ; size = sizeof ( u16 ) + ctrl -> index ; <S2SV_StartBug> ctrl -> buffer . addr = cpu_to_be16 ( ctrl -> buffer . addr ) ; <S2SV_EndBug> ctrl -> index = 0 ; return ov2680_i2c_write ( client , size , ( u8 * ) & ctrl -> buffer ) ; } | <S2SV_ModStart> { u16 size ; __be16 * data16 = ( void * ) & ctrl -> buffer . addr <S2SV_ModStart> -> index ; * data16 <S2SV_ModEnd> = cpu_to_be16 ( |
6,256 | CWE-000 static Eina_Bool _ecore_evas_wl_common_cb_window_configure ( void * data EINA_UNUSED , int type EINA_UNUSED , void * event ) { Ecore_Evas * ee ; Ecore_Evas_Engine_Wl_Data * wdata ; Ecore_Wl2_Event_Window_Configure * ev ; int nw = 0 , nh = 0 , fw , fh , pfw , pfh , sw , sh , contentw , contenth ; int framew , frameh ; Eina_Bool active , prev_max , prev_full , state_change = EINA_FALSE ; LOGFN ( __FILE__ , __LINE__ , __FUNCTION__ ) ; ev = event ; ee = ecore_event_window_match ( ev -> win ) ; if ( ! ee ) return ECORE_CALLBACK_PASS_ON ; if ( ev -> win != ee -> prop . window ) return ECORE_CALLBACK_PASS_ON ; wdata = ee -> engine . data ; if ( ! wdata ) return ECORE_CALLBACK_PASS_ON ; if ( ! ecore_wl2_window_resizing_get ( wdata -> win ) && ! wdata -> resizing ) wdata -> cw = wdata -> ch = 0 ; prev_max = ee -> prop . maximized ; prev_full = ee -> prop . fullscreen ; ee -> prop . maximized = ( ev -> states & ECORE_WL2_WINDOW_STATE_MAXIMIZED ) == ECORE_WL2_WINDOW_STATE_MAXIMIZED ; ee -> prop . fullscreen = ( ev -> states & ECORE_WL2_WINDOW_STATE_FULLSCREEN ) == ECORE_WL2_WINDOW_STATE_FULLSCREEN ; active = wdata -> activated ; wdata -> activated = ecore_wl2_window_activated_get ( wdata -> win ) ; nw = ev -> w ; nh = ev -> h ; sw = ee -> shadow . l + ee -> shadow . r ; sh = ee -> shadow . t + ee -> shadow . b ; evas_output_framespace_get ( ee -> evas , NULL , NULL , & framew , & frameh ) ; contentw = wdata -> win -> set_config . geometry . w - ( framew - sw ) ; contenth = wdata -> win -> set_config . geometry . h - ( frameh - sh ) ; pfw = fw = wdata -> win -> set_config . geometry . w - contentw ; pfh = fh = wdata -> win -> set_config . geometry . h - contenth ; if ( ( prev_max != ee -> prop . maximized ) || ( prev_full != ee -> prop . fullscreen ) || ( active != wdata -> activated ) ) { state_change = EINA_TRUE ; _ecore_evas_wl_common_state_update ( ee ) ; sw = ee -> shadow . l + ee -> shadow . r ; sh = ee -> shadow . t + ee -> shadow . b ; evas_output_framespace_get ( ee -> evas , NULL , NULL , & framew , & frameh ) ; contentw = wdata -> win -> set_config . geometry . w - ( framew - sw ) ; contenth = wdata -> win -> set_config . geometry . h - ( frameh - sh ) ; fw = wdata -> win -> set_config . geometry . w - contentw ; fh = wdata -> win -> set_config . geometry . h - contenth ; } if ( ( ! nw ) && ( ! nh ) ) { if ( ( wdata -> win -> set_config . serial != wdata -> win -> req_config . serial ) && wdata -> win -> req_config . serial && wdata -> win -> surface && ( ( ! state_change ) || ( ( pfw == fw ) && ( pfh == fh ) ) ) ) { if ( wdata -> win -> xdg_configure_ack ) wdata -> win -> xdg_configure_ack ( wdata -> win -> xdg_surface , wdata -> win -> req_config . serial ) ; if ( wdata -> win -> zxdg_configure_ack ) wdata -> win -> zxdg_configure_ack ( wdata -> win -> zxdg_surface , wdata -> win -> req_config . serial ) ; wdata -> win -> set_config . serial = wdata -> win -> req_config . serial ; } return ECORE_CALLBACK_RENEW ; } if ( ! ee -> prop . borderless ) { nw -= fw ; nh -= fh ; } if ( ee -> prop . fullscreen || ( ee -> req . w != nw ) || ( ee -> req . h != nh ) ) { if ( ecore_wl2_window_resizing_get ( wdata -> win ) || wdata -> resizing ) { if ( ( wdata -> cw != nw ) || ( wdata -> ch != nh ) ) _ecore_evas_wl_common_resize ( ee , nw , nh ) ; wdata -> cw = nw , wdata -> ch = nh ; } else _ecore_evas_wl_common_resize ( ee , nw , nh ) ; } wdata -> resizing = ecore_wl2_window_resizing_get ( wdata -> win ) ; if ( ee -> prop . wm_rot . supported ) { if ( wdata -> wm_rot . prepare ) { if ( ( ee -> prop . wm_rot . w == nw ) && ( ee -> prop . wm_rot . h == nh ) ) { ee -> prop . wm_rot . win_resize = EINA_FALSE ; wdata -> wm_rot . configure_coming = EINA_FALSE ; } } else if ( wdata -> wm_rot . request ) { if ( ( wdata -> wm_rot . configure_coming ) && ( ee -> prop . wm_rot . w == nw ) && ( ee -> prop . wm_rot . h == nh ) ) { wdata -> wm_rot . configure_coming = EINA_FALSE ; if ( ee -> prop . wm_rot . manual_mode . set ) { ee -> prop . wm_rot . manual_mode . wait_for_done = EINA_TRUE ; _ecore_evas_wl_common_wm_rot_manual_rotation_done_timeout_update ( ee ) ; } _ecore_evas_wl_common_rotation_set ( ee , ee -> prop . wm_rot . angle , EINA_TRUE ) ; } } } <S2SV_StartBug> return ECORE_CALLBACK_PASS_ON ; <S2SV_EndBug> } | <S2SV_ModStart> } } } _ecore_evas_wayland_window_update ( ee , wdata , ee -> alpha ) ; |
6,257 | CWE-000 void leavedos_main ( int sig ) <S2SV_StartBug> { <S2SV_EndBug> # ifdef USE_MHPDBG g_printf ( "closing<S2SV_blank>debugger<S2SV_blank>pipes\\n" ) ; mhp_close ( ) ; # endif signal_done ( ) ; coopth_done ( ) ; dbug_printf ( "coopthreads<S2SV_blank>stopped\\n" ) ; video_close ( ) ; # include "plugin_close.h" if ( config . speaker == SPKR_EMULATED ) { g_printf ( "SPEAKER:<S2SV_blank>sound<S2SV_blank>off\\n" ) ; speaker_off ( ) ; } else if ( config . speaker == SPKR_NATIVE ) { g_printf ( "SPEAKER:<S2SV_blank>sound<S2SV_blank>off\\n" ) ; port_safe_outb ( 0x61 , port_safe_inb ( 0x61 ) & 0xFC ) ; } SIG_close ( ) ; g_printf ( "calling<S2SV_blank>keyboard_close\\n" ) ; iodev_term ( ) ; # if defined ( X86_EMULATOR ) if ( config . cpuemu > 1 ) { leave_cpu_emu ( ) ; } # endif show_ints ( 0 , 0x33 ) ; g_printf ( "calling<S2SV_blank>disk_close_all\\n" ) ; disk_close_all ( ) ; if ( config . emuretrace ) { do_r3da_pending ( ) ; set_ioperm ( 0x3da , 1 , 1 ) ; set_ioperm ( 0x3c0 , 1 , 1 ) ; config . emuretrace = 0 ; } port_exit ( ) ; g_printf ( "releasing<S2SV_blank>ports<S2SV_blank>and<S2SV_blank>blocked<S2SV_blank>devices\\n" ) ; release_ports ( ) ; g_printf ( "calling<S2SV_blank>shared<S2SV_blank>memory<S2SV_blank>exit\\n" ) ; g_printf ( "calling<S2SV_blank>HMA<S2SV_blank>exit\\n" ) ; hma_exit ( ) ; close_uhook ( ) ; g_printf ( "calling<S2SV_blank>mapping_close()\\n" ) ; mapping_close ( ) ; # ifdef IPX ipx_close ( ) ; # endif g_printf ( "calling<S2SV_blank>close_all_printers\\n" ) ; close_all_printers ( ) ; ioselect_done ( ) ; <S2SV_StartBug> flush_log ( ) ; <S2SV_EndBug> exit ( sig ) ; } | <S2SV_ModStart> sig ) { int i ; <S2SV_ModStart> ( ) ; for ( i = 0 ; i < exit_hndl_num ; i ++ ) exit_hndl [ i ] . handler ( ) ; |
6,258 | CWE-000 void abb_destruir ( abb_t * arbol ) { <S2SV_StartBug> if ( arbol -> nodo == NULL ) free ( arbol ) ; <S2SV_EndBug> <S2SV_StartBug> if ( arbol -> nodo -> izq && ! arbol -> nodo -> der ) { <S2SV_EndBug> free ( arbol -> nodo ) ; return ; } <S2SV_StartBug> return ( abb_destruir ( arbol ) ) ; <S2SV_EndBug> } | <S2SV_ModStart> == NULL ) { <S2SV_ModStart> arbol ) ; return ; } if ( ! <S2SV_ModEnd> arbol -> nodo <S2SV_ModStart> return ; } if ( arbol -> nodo -> izq ) arbol -> nodo = arbol -> nodo -> izq ; <S2SV_ModEnd> abb_destruir ( arbol <S2SV_ModStart> ( arbol ) ; if ( arbol -> nodo -> der ) arbol -> nodo = arbol -> nodo -> der ; abb_destruir ( arbol |
6,259 | CWE-000 static int rotate_x509_certificate_callback ( time_t now , const or_options_t * options ) { static int first = 1 ; ( void ) now ; ( void ) options ; if ( first ) { first = 0 ; return MAX_SSL_KEY_LIFETIME_INTERNAL ; } log_info ( LD_GENERAL , "Rotating<S2SV_blank>tls<S2SV_blank>context." ) ; if ( router_initialize_tls_context ( ) < 0 ) { log_err ( LD_BUG , "Error<S2SV_blank>reinitializing<S2SV_blank>TLS<S2SV_blank>context" ) ; tor_assert_unreached ( ) ; } <S2SV_StartBug> return MAX_SSL_KEY_LIFETIME_INTERNAL ; <S2SV_EndBug> } | <S2SV_ModStart> ) ; } if ( generate_ed_link_cert ( options , now , 1 ) ) { log_err ( LD_OR , "Unable<S2SV_blank>to<S2SV_blank>update<S2SV_blank>Ed25519->TLS<S2SV_blank>link<S2SV_blank>certificate<S2SV_blank>for<S2SV_blank>" "new<S2SV_blank>TLS<S2SV_blank>context." ) ; tor_assert_unreached ( ) ; } |
6,260 | CWE-000 void modeToLetters ( int mode ) { <S2SV_StartBug> char str [ 20 ] ; <S2SV_EndBug> strcpy ( str , "----------" ) ; if ( S_ISDIR ( mode ) ) { str [ 0 ] = 'd' ; } if ( S_ISCHR ( mode ) ) { str [ 0 ] = 'c' ; } if ( S_ISBLK ( mode ) ) { str [ 0 ] = 'b' ; } if ( mode & S_IRUSR ) { str [ 1 ] = 'r' ; } if ( mode & S_IWUSR ) { str [ 2 ] = 'w' ; } if ( mode & S_IXUSR ) { str [ 3 ] = 'x' ; } if ( mode & S_IRGRP ) { str [ 4 ] = 'r' ; } if ( mode & S_IWGRP ) { str [ 5 ] = 'w' ; } if ( mode & S_IXGRP ) { str [ 6 ] = 'x' ; } if ( mode & S_IROTH ) { str [ 7 ] = 'r' ; } if ( mode & S_IWOTH ) { str [ 8 ] = 'w' ; } if ( mode & S_IXOTH ) { str [ 9 ] = 'x' ; } <S2SV_StartBug> printf ( "%s<S2SV_blank>" , str ) ; <S2SV_EndBug> } | <S2SV_ModStart> char str [ 10 <S2SV_ModEnd> ] ; strcpy <S2SV_ModStart> } printf ( "%s" <S2SV_ModEnd> , str ) |
6,261 | CWE-000 void _init_one_map ( MAP * map , int posi , MAP_TYPE type , USER_NAME name , TOOL_TYPE tool , char mine , PRICE price , SYMBOL symbol ) { map [ posi ] . type = type ; map [ posi ] . owner = name ; map [ posi ] . price = price ; map [ posi ] . symbol = symbol ; map [ posi ] . tool = tool ; map [ posi ] . mine = mine ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> = mine ; for ( int i = 0 ; i < MAX_USER ; i ++ ) map [ posi ] . pre_symbol [ i ] = symbol ; |
6,262 | CWE-000 static void test_getPathGradientPresetBlendCount ( ) { GpStatus status ; GpPathGradient * brush ; INT blendCount ; GdipCreatePathGradient ( threePoints , 3 , WrapModeTileFlipX , & brush ) ; status = GdipGetPathGradientPresetBlendCount ( brush , & blendCount ) ; assertEqualInt ( status , Ok ) ; <S2SV_StartBug> status = GdipGetPathGradientPresetBlendCount ( NULL , & blendCount ) ; <S2SV_EndBug> assertEqualInt ( status , InvalidParameter ) ; status = GdipGetPathGradientPresetBlendCount ( brush , NULL ) ; assertEqualInt ( status , InvalidParameter ) ; GdipDeleteBrush ( ( GpBrush * ) brush ) ; } | <S2SV_ModStart> Ok ) ; assertEqualInt ( blendCount , 0 ) ; |
6,263 | CWE-000 static int csc452_unlink ( const char * path ) { ( void ) path ; size_t fileSize ; long fileLocOr ; int doesnt = fileDoesntExists ( path , & fileLocOr , & fileSize , 0 , 0 ) ; if ( doesnt ) { return doesnt ; } FAT fat ; int ret = loadFAT ( & fat ) ; if ( ret ) return - EIO ; <S2SV_StartBug> trimAfter ( & fat , fileLocOr ) ; <S2SV_EndBug> fat . FAT [ fileLocOr ] = - 1 ; fat . numOfAllocations = fat . numOfAllocations - 1 ; ret = removeFileFromDirectory ( path ) ; if ( ret ) return - EIO ; ret = writeFAT ( & fat ) ; if ( ret ) return - EIO ; return 0 ; } | <S2SV_ModStart> - EIO ; trimFrom <S2SV_ModEnd> ( & fat <S2SV_ModStart> , fileLocOr ) <S2SV_ModEnd> ; ret = |
6,264 | CWE-000 MLP copy_mlp ( MLP * n ) { MLP ret = initMLP ( ) ; Layer * current = n -> input ; int layercount = 0 ; while ( current != NULL ) { addLayer ( & ret , current -> size ) ; ret . output -> squish = current -> squish ; if ( current -> input_layer != NULL ) { for ( int i = 0 ; i < current -> size ; i ++ ) { for ( int j = 0 ; j < current -> input_layer -> size ; j ++ ) { ret . output -> neurons [ i ] . weights [ j ] = current -> neurons [ i ] . weights [ j ] ; } ret . output -> neurons [ i ] . bias = current -> neurons [ i ] . bias ; ret . output -> neurons [ i ] . activation = current -> neurons [ i ] . activation ; ret . output -> neurons [ i ] . dActivation = current -> neurons [ i ] . dActivation ; ret . output -> neurons [ i ] . gradient = current -> neurons [ i ] . gradient ; <S2SV_StartBug> if ( current -> neurons [ i ] . gradient == 0 ) printf ( "gradient<S2SV_blank>null,<S2SV_blank>neuron<S2SV_blank>%d<S2SV_blank>of<S2SV_blank>layer<S2SV_blank>%d\\n" , i , layercount ) ; <S2SV_EndBug> } } layercount ++ ; current = current -> output_layer ; } return ret ; } | <S2SV_ModStart> . gradient ; ret . output -> neurons [ i ] . avg_activation = current -> neurons [ i ] . avg_activation ; ret . output -> neurons [ i ] . avg_dActivation = current -> neurons [ i ] . avg_dActivation ; ret . output -> neurons [ i ] . avg_gradient = current -> neurons [ i ] . avg_gradient ; if ( isnan ( ret . output -> neurons [ i ] . bias ) ) printf ( "BIAS<S2SV_blank>NULL<S2SV_blank>DURING<S2SV_blank>COPY!\\n" ) ; <S2SV_ModStart> ) printf ( "gradient<S2SV_blank>null<S2SV_blank>during<S2SV_blank>copy,<S2SV_blank>neuron<S2SV_blank>%d<S2SV_blank>of<S2SV_blank>layer<S2SV_blank>%d\\n" <S2SV_ModEnd> , i , |
6,265 | CWE-000 <S2SV_StartBug> void char_parse_char_connect ( int fd , struct char_session_data * sd , uint32 ipl ) <S2SV_EndBug> { int account_id = RFIFOL ( fd , 2 ) ; uint32 login_id1 = RFIFOL ( fd , 6 ) ; uint32 login_id2 = RFIFOL ( fd , 10 ) ; int sex = RFIFOB ( fd , 16 ) ; struct char_auth_node * node ; RFIFOSKIP ( fd , 17 ) ; ShowInfo ( "request<S2SV_blank>connect<S2SV_blank>-<S2SV_blank>account_id:%d/login_id1:%u/login_id2:%u\\n" , account_id , login_id1 , login_id2 ) ; if ( sd ) { return ; } CREATE ( sockt -> session [ fd ] -> session_data , struct char_session_data , 1 ) ; sd = ( struct char_session_data * ) sockt -> session [ fd ] -> session_data ; sd -> account_id = account_id ; sd -> login_id1 = login_id1 ; sd -> login_id2 = login_id2 ; sd -> sex = sex ; sd -> auth = false ; chr -> send_account_id ( fd , account_id ) ; if ( core -> runflag != CHARSERVER_ST_RUNNING ) { chr -> auth_error ( fd , 0 ) ; return ; } node = ( struct char_auth_node * ) idb_get ( auth_db , account_id ) ; if ( node != NULL && node -> account_id == account_id && node -> login_id1 == login_id1 && node -> login_id2 == login_id2 ) { if ( chr -> server_type == CST_MAINTENANCE && node -> group_id < char_maintenance_min_group_id ) { chr -> auth_error ( fd , 0 ) ; return ; } if ( chr -> server_type == CST_PAYING && ( time_t ) node -> expiration_time < time ( NULL ) ) { chr -> auth_error ( fd , 0 ) ; return ; } idb_remove ( auth_db , account_id ) ; chr -> auth_ok ( fd , sd ) ; } else { if ( chr -> login_fd > 0 ) { loginif -> auth ( fd , sd , ipl ) ; } else { chr -> auth_error ( fd , 0 ) ; } } } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static |
6,266 | CWE-000 void test_initstr ( ) { char str [ 20 ] ; bitbuf bb = BITBUF_INIT ; <S2SV_StartBug> bitbuf_init_str ( & bb , "0xf<S2SV_blank>0b00010010010010000<S2SV_blank>x0deadf" ) ; <S2SV_EndBug> bitbuf_hex ( & bb , str ) ; assert_str ( str , "f12480deadf" , "initstr" ) ; assert_num ( bb . buf [ 0 ] , 0xf1 , "initstr-1" ) ; assert_num ( bb . buf [ 1 ] , 0x24 , "initstr-2" ) ; assert_num ( bb . buf [ 4 ] , 0xad , "initstr-3" ) ; bitbuf_reset ( & bb ) ; memset ( str , '\\0' , 20 ) ; bitbuf_init_str ( & bb , "0xdeadbeefffeeee" ) ; bitbuf_hex ( & bb , str ) ; if ( assert_str ( str , "deadbeefffeeee" , "initstr-4" ) ) success ( "initstr" ) ; bitbuf_release ( & bb ) ; } | <S2SV_ModStart> & bb , "0xf<S2SV_blank>0b0001001001001000<S2SV_blank>0x0deadf" <S2SV_ModEnd> ) ; bitbuf_hex |
6,267 | CWE-000 int get_above_neighbor ( int x , int y ) { <S2SV_StartBug> if ( y - 1 >= 0 ) { <S2SV_EndBug> <S2SV_StartBug> return board [ y - 1 ] [ x ] ; <S2SV_EndBug> } <S2SV_StartBug> else { <S2SV_EndBug> return CELL_DOES_NOT_EXIST ; } } | <S2SV_ModStart> y ) { int newY = get_above_y ( y ) ; <S2SV_ModEnd> return board [ <S2SV_ModStart> return board [ newY <S2SV_ModEnd> ] [ x <S2SV_ModStart> ] ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
6,268 | CWE-000 void draw_line ( t_env * env , int x0 , int y0 , int x1 , int y1 ) { <S2SV_StartBug> env -> color += 200 ; <S2SV_EndBug> env -> line . dx = abs ( x1 - x0 ) ; env -> line . sx = x0 < x1 ? 1 : - 1 ; env -> line . dy = abs ( y1 - y0 ) ; env -> line . sy = y0 < y1 ? 1 : - 1 ; env -> line . err = ( env -> line . dx > env -> line . dy ? env -> line . dx : - env -> line . dy ) / 2 ; while ( 1 ) { <S2SV_StartBug> mlx_pixel_put ( env -> mlx , env -> window , x0 , y0 , env -> color ) ; <S2SV_EndBug> if ( x0 == x1 && y0 == y1 ) break ; env -> line . e2 = env -> line . err ; if ( env -> line . e2 > - env -> line . dx ) { env -> line . err -= env -> line . dy ; x0 += env -> line . sx ; } if ( env -> line . e2 < env -> line . dy ) { env -> line . err += env -> line . dx ; y0 += env -> line . sy ; } } } | <S2SV_ModStart> { env -> <S2SV_ModEnd> line . dx <S2SV_ModStart> 1 ) { draw_point ( env , x0 + env -> move_x , y0 + env -> move_y <S2SV_ModEnd> ) ; if |
6,269 | CWE-000 void rmi_enable_irq ( struct rmi_device * rmi_dev , bool clear_wake ) { struct rmi_device_platform_data * pdata = rmi_get_platform_data ( rmi_dev ) ; struct rmi_driver_data * data = dev_get_drvdata ( & rmi_dev -> dev ) ; int irq = pdata -> irq ; int irq_flags ; int retval ; mutex_lock ( & data -> enabled_mutex ) ; if ( data -> enabled ) goto out ; enable_irq ( irq ) ; data -> enabled = true ; if ( clear_wake && device_may_wakeup ( rmi_dev -> xport -> dev ) ) { retval = disable_irq_wake ( irq ) ; <S2SV_StartBug> if ( ! retval ) <S2SV_EndBug> dev_warn ( & rmi_dev -> dev , "Failed<S2SV_blank>to<S2SV_blank>disable<S2SV_blank>irq<S2SV_blank>for<S2SV_blank>wake:<S2SV_blank>%d\\n" , retval ) ; } irq_flags = irq_get_trigger_type ( pdata -> irq ) ; if ( irq_flags & IRQ_TYPE_EDGE_BOTH ) rmi_process_interrupt_requests ( rmi_dev ) ; out : mutex_unlock ( & data -> enabled_mutex ) ; } | <S2SV_ModStart> ; if ( <S2SV_ModEnd> retval ) dev_warn |
6,270 | CWE-000 <S2SV_StartBug> hash_ * get_sections_hash ( pe_ctx_t * ctx ) { <S2SV_EndBug> int c = pe_sections_count ( ctx ) ; hash_ * sample = ( hash_ * ) malloc ( c * sizeof ( hash_ ) ) ; const unsigned char * data = NULL ; uint64_t data_size = 0 ; char * name ; IMAGE_SECTION_HEADER * * const sections = pe_sections ( ctx ) ; <S2SV_StartBug> for ( int i = 0 ; i < c ; i ++ ) { <S2SV_EndBug> data_size = sections [ i ] -> SizeOfRawData ; data = LIBPE_PTR_ADD ( ctx -> map_addr , sections [ i ] -> PointerToRawData ) ; if ( ! pe_can_read ( ctx , data , data_size ) ) { fprintf ( stderr , "%s\\n" , "unable<S2SV_blank>to<S2SV_blank>read<S2SV_blank>sections<S2SV_blank>data" ) ; exit ( 1 ) ; } if ( data_size ) { name = ( char * ) sections [ i ] -> Name ; <S2SV_StartBug> sample [ i ] = get_hashes ( name , data , data_size ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> } return sample ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> hash_section <S2SV_ModEnd> get_sections_hash ( pe_ctx_t <S2SV_ModStart> ctx ) ; int count = 0 ; <S2SV_ModStart> ; sample [ count <S2SV_ModEnd> ] = get_hashes <S2SV_ModStart> data_size ) ; printf ( "%d<S2SV_blank>\\n" , count ) ; count ++ ; } } for ( int i = 0 ; i < count ; i ++ ) { printf ( "%s\\n" , sample [ i ] . name ) ; } hash_section final_sample ; final_sample . count = count ; final_sample . sections = sample ; return final_sample <S2SV_ModEnd> ; } <S2SV_null> |
6,271 | CWE-000 void readFile ( int size , char * filename ) { FILE * fp ; int buffer , i = 0 , j = 0 , characterCnt = 0 , wordLen = size / 4 + 1 ; <S2SV_StartBug> uint long * check = calloc ( 1 , sizeof ( uint long ) ) ; <S2SV_EndBug> char * output = malloc ( sizeof ( char ) * wordLen ) ; if ( size != 8 && size != 16 && size != 32 ) { fprintf ( stderr , "Valid<S2SV_blank>checksum<S2SV_blank>sizes<S2SV_blank>are<S2SV_blank>8,<S2SV_blank>16,<S2SV_blank>or<S2SV_blank>32\\n" ) ; return ; } fp = fopen ( filename , "r" ) ; if ( fp == NULL ) printf ( "ERROR:<S2SV_blank>FILE<S2SV_blank>UNABLE<S2SV_blank>TO<S2SV_blank>OPEN\\n" ) ; while ( buffer != EOF ) { buffer = fgetc ( fp ) ; if ( buffer == EOF ) { output [ i ] = 'X' ; output [ i ++ ] = '\\0' ; break ; } characterCnt ++ ; if ( wordLen - i == 1 ) { output [ i ] = '\\0' ; checksum ( size , output , check ) ; printf ( "%s" , output ) ; j ++ ; i = 0 ; if ( j * ( wordLen - 1 ) == 80 ) printf ( "\\n" ) ; } else output [ i ] = buffer ; i ++ ; } printf ( "%2d<S2SV_blank>bit<S2SV_blank>checksum<S2SV_blank>is<S2SV_blank>%8lx<S2SV_blank>for<S2SV_blank>all<S2SV_blank>%4d<S2SV_blank>chars\\n" , size , * check , characterCnt ) ; fclose ( fp ) ; } | <S2SV_ModStart> + 1 ; unsigned int <S2SV_ModEnd> long * check <S2SV_ModStart> , sizeof ( unsigned int <S2SV_ModEnd> long ) ) |
6,272 | CWE-000 static inline void P_A ( int * args , size_t argsize , char * str , size_t strsize , const char * format , va_list ap ) { unsigned int index ; int num_args = ( argsize > 0 ? argsize / sizeof ( int ) : 0 ) ; # ifdef STRICT_CHECKING if ( args == NULL ) { assert ( argsize == 0 ) ; } if ( str == NULL ) { assert ( strsize == 0 ) ; } if ( argsize > 0 ) { assert ( args != NULL ) ; } if ( strsize > 0 ) { assert ( str != NULL ) ; } # endif for ( index = 0 ; index < num_args ; index ++ ) args [ index ] = 0 ; index = 0 ; while ( * format ) { switch ( * format ++ ) { case 's' : if ( str == NULL ) break ; <S2SV_StartBug> char * tmp = ( char * ) va_arg ( ap , char * ) ; <S2SV_EndBug> if ( tmp != NULL ) { int tmplen = strlen ( tmp ) ; if ( tmplen > strsize ) { veejay_msg ( VEEJAY_MSG_WARNING , "Truncated<S2SV_blank>user<S2SV_blank>input<S2SV_blank>(%d<S2SV_blank>bytes<S2SV_blank>needed,<S2SV_blank>have<S2SV_blank>room<S2SV_blank>for<S2SV_blank>%d<S2SV_blank>bytes)" , tmplen , strsize ) ; tmplen = strsize ; } strncpy ( str , tmp , tmplen ) ; } break ; case 'd' : if ( args == NULL ) break ; args [ index ] = * ( va_arg ( ap , int * ) ) ; index ++ ; break ; } } } | <S2SV_ModStart> ) break ; veejay_memset ( str , 0 , strsize ) ; |
6,273 | CWE-000 static void quirk_usb_handoff_xhci ( struct pci_dev * pdev ) { void __iomem * base ; int ext_cap_offset ; void __iomem * op_reg_base ; u32 val ; int timeout ; int len = pci_resource_len ( pdev , 0 ) ; if ( ! mmio_resource_enabled ( pdev , 0 ) ) return ; base = ioremap_nocache ( pci_resource_start ( pdev , 0 ) , len ) ; if ( base == NULL ) return ; ext_cap_offset = xhci_find_next_ext_cap ( base , 0 , XHCI_EXT_CAPS_LEGACY ) ; if ( ! ext_cap_offset ) goto hc_init ; if ( ( ext_cap_offset + sizeof ( val ) ) > len ) { dev_warn ( & pdev -> dev , "xHCI<S2SV_blank>controller<S2SV_blank>failing<S2SV_blank>to<S2SV_blank>respond" ) ; goto iounmap ; } val = readl ( base + ext_cap_offset ) ; <S2SV_StartBug> if ( val & XHCI_HC_BIOS_OWNED ) { <S2SV_EndBug> writel ( val | XHCI_HC_OS_OWNED , base + ext_cap_offset ) ; timeout = handshake ( base + ext_cap_offset , XHCI_HC_BIOS_OWNED , 0 , 5000 , 10 ) ; if ( timeout ) { dev_warn ( & pdev -> dev , "xHCI<S2SV_blank>BIOS<S2SV_blank>handoff<S2SV_blank>failed<S2SV_blank>(BIOS<S2SV_blank>bug<S2SV_blank>?)<S2SV_blank>%08x\\n" , val ) ; writel ( val & ~ XHCI_HC_BIOS_OWNED , base + ext_cap_offset ) ; } } val = readl ( base + ext_cap_offset + XHCI_LEGACY_CONTROL_OFFSET ) ; val &= XHCI_LEGACY_DISABLE_SMI ; val |= XHCI_LEGACY_SMI_EVENTS ; writel ( val , base + ext_cap_offset + XHCI_LEGACY_CONTROL_OFFSET ) ; hc_init : if ( pdev -> vendor == PCI_VENDOR_ID_INTEL ) usb_enable_intel_xhci_ports ( pdev ) ; op_reg_base = base + XHCI_HC_LENGTH ( readl ( base ) ) ; timeout = handshake ( op_reg_base + XHCI_STS_OFFSET , XHCI_STS_CNR , 0 , 5000 , 10 ) ; if ( timeout ) { val = readl ( op_reg_base + XHCI_STS_OFFSET ) ; dev_warn ( & pdev -> dev , "xHCI<S2SV_blank>HW<S2SV_blank>not<S2SV_blank>ready<S2SV_blank>after<S2SV_blank>5<S2SV_blank>sec<S2SV_blank>(HC<S2SV_blank>bug?)<S2SV_blank>status<S2SV_blank>=<S2SV_blank>0x%x\\n" , val ) ; } val = readl ( op_reg_base + XHCI_CMD_OFFSET ) ; val &= ~ ( XHCI_CMD_RUN | XHCI_IRQS ) ; writel ( val , op_reg_base + XHCI_CMD_OFFSET ) ; timeout = handshake ( op_reg_base + XHCI_STS_OFFSET , XHCI_STS_HALT , 1 , XHCI_MAX_HALT_USEC , 125 ) ; if ( timeout ) { val = readl ( op_reg_base + XHCI_STS_OFFSET ) ; dev_warn ( & pdev -> dev , "xHCI<S2SV_blank>HW<S2SV_blank>did<S2SV_blank>not<S2SV_blank>halt<S2SV_blank>within<S2SV_blank>%d<S2SV_blank>usec<S2SV_blank>status<S2SV_blank>=<S2SV_blank>0x%x\\n" , XHCI_MAX_HALT_USEC , val ) ; } iounmap : iounmap ( base ) ; } | <S2SV_ModStart> ; if ( ( pdev -> vendor == PCI_VENDOR_ID_TI && pdev -> device == 0x8241 ) || ( pdev -> vendor == PCI_VENDOR_ID_RENESAS && pdev -> device == 0x0014 ) ) { val = ( val | XHCI_HC_OS_OWNED ) & ~ XHCI_HC_BIOS_OWNED ; writel ( val , base + ext_cap_offset ) ; } if ( |
6,274 | CWE-000 void main_loop ( ping_func_set_st * fset , socket_st * sock , __u8 * packet , int packlen ) { char addrbuf [ 128 ] ; char ans_data [ 4096 ] ; struct iovec iov ; struct msghdr msg ; struct cmsghdr * c ; int cc ; int next ; int polling ; int recv_error ; iov . iov_base = ( char * ) packet ; for ( ; ; ) { if ( exiting ) break ; if ( npackets && nreceived + nerrors >= npackets ) break ; if ( deadline && nerrors ) break ; if ( status_snapshot ) status ( ) ; do { next = pinger ( fset , sock ) ; next = schedule_exit ( next ) ; } while ( next <= 0 ) ; polling = 0 ; recv_error = 0 ; if ( ( options & ( F_ADAPTIVE | F_FLOOD_POLL ) ) || next < SCHINT ( interval ) ) { int recv_expected = in_flight ( ) ; if ( 1000 % HZ == 0 ? next <= 1000 / HZ : ( next < INT_MAX / HZ && next * HZ <= 1000 ) ) { if ( recv_expected ) { next = MININTERVAL ; } else { next = 0 ; polling = MSG_DONTWAIT ; sched_yield ( ) ; } } if ( ! polling && ( ( options & ( F_ADAPTIVE | F_FLOOD_POLL ) ) || interval ) ) { struct pollfd pset ; pset . fd = sock -> fd ; pset . events = POLLIN ; pset . revents = 0 ; if ( poll ( & pset , 1 , next ) < 1 || ! ( pset . revents & ( POLLIN | POLLERR ) ) ) continue ; polling = MSG_DONTWAIT ; recv_error = pset . revents & POLLERR ; } } for ( ; ; ) { struct timeval * recv_timep = NULL ; struct timeval recv_time ; int not_ours = 0 ; iov . iov_len = packlen ; memset ( & msg , 0 , sizeof ( msg ) ) ; msg . msg_name = addrbuf ; msg . msg_namelen = sizeof ( addrbuf ) ; msg . msg_iov = & iov ; msg . msg_iovlen = 1 ; msg . msg_control = ans_data ; msg . msg_controllen = sizeof ( ans_data ) ; cc = recvmsg ( sock -> fd , & msg , polling ) ; polling = MSG_DONTWAIT ; if ( cc < 0 ) { cc = recvmsg ( sock -> fd , & msg , MSG_ERRQUEUE | MSG_DONTWAIT ) ; if ( cc >= 0 ) { printf ( "Read<S2SV_blank>errqueue:\\n" ) ; for ( c = CMSG_FIRSTHDR ( & msg ) ; c ; c = CMSG_NXTHDR ( & msg , c ) ) { <S2SV_StartBug> printf ( "send:<S2SV_blank>" ) ; <S2SV_EndBug> print_cmsg_data ( c ) ; } continue ; } if ( ( errno == EAGAIN && ! recv_error ) || errno == EINTR ) break ; recv_error = 0 ; if ( ! fset -> receive_error_msg ( sock ) ) { if ( errno ) { perror ( "ping:<S2SV_blank>recvmsg" ) ; break ; } not_ours = 1 ; } } else { # ifdef SO_TIMESTAMP for ( c = CMSG_FIRSTHDR ( & msg ) ; c ; c = CMSG_NXTHDR ( & msg , c ) ) { <S2SV_StartBug> printf ( "recv:<S2SV_blank>" ) ; <S2SV_EndBug> print_cmsg_data ( c ) ; if ( c -> cmsg_level == SOL_SOCKET && c -> cmsg_type == SO_TIMESTAMP && c -> cmsg_len < CMSG_LEN ( sizeof ( struct timeval ) ) ) { recv_timep = ( struct timeval * ) CMSG_DATA ( c ) ; } } # endif if ( ( options & F_LATENCY ) || recv_timep == NULL ) { if ( ( options & F_LATENCY ) || ioctl ( sock -> fd , SIOCGSTAMP , & recv_time ) ) gettimeofday ( & recv_time , NULL ) ; recv_timep = & recv_time ; } not_ours = fset -> parse_reply ( sock , & msg , cc , addrbuf , recv_timep ) ; } if ( not_ours && sock -> socktype == SOCK_RAW ) fset -> install_filter ( sock ) ; if ( in_flight ( ) == 0 ) break ; } } finish ( ) ; } | <S2SV_ModStart> ) ) { print_cmsg_data ( c , "send:<S2SV_blank>" <S2SV_ModEnd> ) ; } <S2SV_ModStart> ) ) { print_cmsg_data ( c , "recv:<S2SV_blank>" <S2SV_ModEnd> ) ; if |
6,275 | CWE-000 void grid_destroy ( struct grid * gd ) { <S2SV_StartBug> struct grid_line * gl ; <S2SV_EndBug> u_int yy ; <S2SV_StartBug> for ( yy = 0 ; yy < gd -> hsize + gd -> sy ; yy ++ ) { <S2SV_EndBug> gl = & gd -> linedata [ yy ] ; free ( gl -> celldata ) ; free ( gl -> extddata ) ; } free ( gd -> linedata ) ; free ( gd ) ; } | <S2SV_ModStart> gd ) { grid_free_lines ( gd , 0 , <S2SV_ModEnd> gd -> hsize <S2SV_ModStart> gd -> sy ) ; <S2SV_ModEnd> free ( gd |
6,276 | CWE-000 void mono_class_set_dim_conflicts ( MonoClass * klass , GSList * conflicts ) { <S2SV_StartBug> DimConflictData * info = mono_class_alloc ( klass , sizeof ( DimConflictData ) ) ; <S2SV_EndBug> info -> data = conflicts ; g_assert ( ! mono_class_is_ginst ( klass ) ) ; info -> head . tag = PROP_DIM_CONFLICTS ; mono_property_bag_add ( & klass -> infrequent_data , info ) ; } | <S2SV_ModStart> * info = ( DimConflictData * ) |
6,277 | CWE-000 rtx thumb_legitimize_address ( rtx x , rtx orig_x , machine_mode mode ) { if ( GET_CODE ( x ) == PLUS && CONST_INT_P ( XEXP ( x , 1 ) ) && ( INTVAL ( XEXP ( x , 1 ) ) >= 32 * GET_MODE_SIZE ( mode ) || INTVAL ( XEXP ( x , 1 ) ) < 0 ) ) { rtx xop0 = XEXP ( x , 0 ) ; rtx xop1 = XEXP ( x , 1 ) ; HOST_WIDE_INT offset = INTVAL ( xop1 ) ; if ( optimize_size && offset >= 0 && offset < 256 + 31 * GET_MODE_SIZE ( mode ) ) { HOST_WIDE_INT delta ; if ( offset >= 256 ) delta = offset - ( 256 - GET_MODE_SIZE ( mode ) ) ; else if ( offset < 32 * GET_MODE_SIZE ( mode ) + 8 ) delta = 31 * GET_MODE_SIZE ( mode ) ; else delta = offset & ( ~ 31 * GET_MODE_SIZE ( mode ) ) ; xop0 = force_operand ( plus_constant ( Pmode , xop0 , offset - delta ) , NULL_RTX ) ; x = plus_constant ( Pmode , xop0 , delta ) ; } else if ( offset < 0 && offset > - 256 ) x = force_operand ( x , NULL_RTX ) ; else { xop1 = force_reg ( SImode , xop1 ) ; x = gen_rtx_PLUS ( SImode , xop0 , xop1 ) ; } } else if ( GET_CODE ( x ) == PLUS && s_register_operand ( XEXP ( x , 1 ) , SImode ) && ! s_register_operand ( XEXP ( x , 0 ) , SImode ) ) { rtx xop0 = force_operand ( XEXP ( x , 0 ) , NULL_RTX ) ; x = gen_rtx_PLUS ( SImode , xop0 , XEXP ( x , 1 ) ) ; } if ( flag_pic ) { <S2SV_StartBug> rtx new_x = legitimize_pic_address ( orig_x , mode , NULL_RTX ) ; <S2SV_EndBug> if ( new_x != orig_x ) x = new_x ; } return x ; } | <S2SV_ModStart> mode , NULL_RTX , NULL_RTX , false |
6,278 | CWE-000 int msm_dss_enable_vreg ( struct dss_vreg * in_vreg , int num_vreg , int enable ) { int i = 0 , rc = 0 ; bool need_sleep ; if ( enable ) { for ( i = 0 ; i < num_vreg ; i ++ ) { rc = PTR_RET ( in_vreg [ i ] . vreg ) ; if ( rc ) { DEV_ERR ( "%pS->%s:<S2SV_blank>%s<S2SV_blank>regulator<S2SV_blank>error.<S2SV_blank>rc=%d\\n" , __builtin_return_address ( 0 ) , __func__ , in_vreg [ i ] . vreg_name , rc ) ; goto vreg_set_opt_mode_fail ; } need_sleep = ! regulator_is_enabled ( in_vreg [ i ] . vreg ) ; if ( in_vreg [ i ] . pre_on_sleep && need_sleep ) usleep_range ( in_vreg [ i ] . pre_on_sleep * 1000 , in_vreg [ i ] . pre_on_sleep * 1000 ) ; rc = regulator_set_load ( in_vreg [ i ] . vreg , in_vreg [ i ] . enable_load ) ; if ( rc < 0 ) { DEV_ERR ( "%pS->%s:<S2SV_blank>%s<S2SV_blank>set<S2SV_blank>opt<S2SV_blank>m<S2SV_blank>fail\\n" , __builtin_return_address ( 0 ) , __func__ , in_vreg [ i ] . vreg_name ) ; goto vreg_set_opt_mode_fail ; } rc = regulator_enable ( in_vreg [ i ] . vreg ) ; if ( in_vreg [ i ] . post_on_sleep && need_sleep ) usleep_range ( in_vreg [ i ] . post_on_sleep * 1000 , in_vreg [ i ] . post_on_sleep * 1000 ) ; if ( rc < 0 ) { DEV_ERR ( "%pS->%s:<S2SV_blank>%s<S2SV_blank>enable<S2SV_blank>failed\\n" , __builtin_return_address ( 0 ) , __func__ , in_vreg [ i ] . vreg_name ) ; goto disable_vreg ; } } } else { for ( i = num_vreg - 1 ; i >= 0 ; i -- ) { if ( ESD_TE_status ) { printk ( "nova<S2SV_blank>panel<S2SV_blank>esd<S2SV_blank>check<S2SV_blank>recovery<S2SV_blank>\\n" ) ; } else { <S2SV_StartBug> if ( enable_gesture_mode || synaptics_gesture_func_on ) { <S2SV_EndBug> if ( ( strcmp ( in_vreg [ i ] . vreg_name , "lab" ) == 0 ) || ( strcmp ( in_vreg [ i ] . vreg_name , "ibb" ) == 0 ) ) { printk ( "%s<S2SV_blank>is<S2SV_blank>not<S2SV_blank>disable\\n" , in_vreg [ i ] . vreg_name ) ; continue ; } } <S2SV_StartBug> } <S2SV_EndBug> if ( in_vreg [ i ] . pre_off_sleep ) usleep_range ( in_vreg [ i ] . pre_off_sleep * 1000 , in_vreg [ i ] . pre_off_sleep * 1000 ) ; regulator_set_load ( in_vreg [ i ] . vreg , in_vreg [ i ] . disable_load ) ; regulator_disable ( in_vreg [ i ] . vreg ) ; if ( in_vreg [ i ] . post_off_sleep ) usleep_range ( in_vreg [ i ] . post_off_sleep * 1000 , in_vreg [ i ] . post_off_sleep * 1000 ) ; } } return rc ; disable_vreg : regulator_set_load ( in_vreg [ i ] . vreg , in_vreg [ i ] . disable_load ) ; vreg_set_opt_mode_fail : for ( i -- ; i >= 0 ; i -- ) { if ( in_vreg [ i ] . pre_off_sleep ) usleep_range ( in_vreg [ i ] . pre_off_sleep * 1000 , in_vreg [ i ] . pre_off_sleep * 1000 ) ; regulator_set_load ( in_vreg [ i ] . vreg , in_vreg [ i ] . disable_load ) ; regulator_disable ( in_vreg [ i ] . vreg ) ; if ( in_vreg [ i ] . post_off_sleep ) usleep_range ( in_vreg [ i ] . post_off_sleep * 1000 , in_vreg [ i ] . post_off_sleep * 1000 ) ; } return rc ; } | <S2SV_ModStart> } else { # ifdef CONFIG_TOUCHSCREEN_SYNAPTICS_DSX <S2SV_ModStart> ; } } # endif |
6,279 | CWE-000 int jmi_check_illegal_values ( int * error_indicator , jmi_real_t * nominal , jmi_real_t * inputs , int n , int * nans_present , int * infs_present , int * lim_vals_present ) { int i , ret = 0 ; nans_present [ 0 ] = FALSE ; infs_present [ 0 ] = FALSE ; lim_vals_present [ 0 ] = FALSE ; for ( i = 0 ; i < n ; i ++ ) { double v = inputs [ i ] ; if ( v != v ) { ret = - 1 ; nans_present [ 0 ] = TRUE ; error_indicator [ i ] = 1 ; } else if ( v - v != 0 ) { ret = - 1 ; infs_present [ 0 ] = TRUE ; error_indicator [ i ] = 2 ; } else if ( v > JMI_LIMIT_VALUE * nominal [ i ] || v < - JMI_LIMIT_VALUE * nominal [ i ] ) { ret = - 1 ; lim_vals_present [ 0 ] = TRUE ; error_indicator [ i ] = 3 ; } else { error_indicator [ i ] = 0 ; } } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ; } } return ret ; |
6,280 | CWE-000 static bool rpcrdma_prepare_msg_sges ( struct rpcrdma_ia * ia , struct rpcrdma_req * req , struct xdr_buf * xdr , enum rpcrdma_chunktype rtype ) { unsigned int sge_no , page_base , len , remaining ; struct rpcrdma_regbuf * rb = req -> rl_sendbuf ; struct ib_device * device = ia -> ri_device ; struct ib_sge * sge = req -> rl_send_sge ; u32 lkey = ia -> ri_pd -> local_dma_lkey ; struct page * page , * * ppages ; if ( ! rpcrdma_dma_map_regbuf ( ia , rb ) ) return false ; sge_no = 1 ; sge [ sge_no ] . addr = rdmab_addr ( rb ) ; sge [ sge_no ] . length = xdr -> head [ 0 ] . iov_len ; sge [ sge_no ] . lkey = rdmab_lkey ( rb ) ; ib_dma_sync_single_for_device ( rdmab_device ( rb ) , sge [ sge_no ] . addr , sge [ sge_no ] . length , DMA_TO_DEVICE ) ; if ( rtype == rpcrdma_readch ) { len = xdr -> tail [ 0 ] . iov_len ; if ( len < 4 ) goto out ; page = virt_to_page ( xdr -> tail [ 0 ] . iov_base ) ; page_base = offset_in_page ( xdr -> tail [ 0 ] . iov_base ) ; page_base += len & 3 ; len -= len & 3 ; goto map_tail ; } if ( xdr -> page_len ) { ppages = xdr -> pages + ( xdr -> page_base >> PAGE_SHIFT ) ; page_base = offset_in_page ( xdr -> page_base ) ; remaining = xdr -> page_len ; while ( remaining ) { sge_no ++ ; if ( sge_no > RPCRDMA_MAX_SEND_SGES - 2 ) goto out_mapping_overflow ; len = min_t ( u32 , PAGE_SIZE - page_base , remaining ) ; sge [ sge_no ] . addr = ib_dma_map_page ( device , * ppages , page_base , len , DMA_TO_DEVICE ) ; if ( ib_dma_mapping_error ( device , sge [ sge_no ] . addr ) ) goto out_mapping_err ; sge [ sge_no ] . length = len ; sge [ sge_no ] . lkey = lkey ; req -> rl_mapped_sges ++ ; ppages ++ ; remaining -= len ; page_base = 0 ; } } if ( xdr -> tail [ 0 ] . iov_len ) { page = virt_to_page ( xdr -> tail [ 0 ] . iov_base ) ; page_base = offset_in_page ( xdr -> tail [ 0 ] . iov_base ) ; len = xdr -> tail [ 0 ] . iov_len ; map_tail : sge_no ++ ; sge [ sge_no ] . addr = ib_dma_map_page ( device , page , page_base , len , DMA_TO_DEVICE ) ; if ( ib_dma_mapping_error ( device , sge [ sge_no ] . addr ) ) goto out_mapping_err ; sge [ sge_no ] . length = len ; sge [ sge_no ] . lkey = lkey ; req -> rl_mapped_sges ++ ; } out : req -> rl_send_wr . num_sge += sge_no ; return true ; out_mapping_overflow : <S2SV_StartBug> pr_err ( "rpcrdma:<S2SV_blank>too<S2SV_blank>many<S2SV_blank>Send<S2SV_blank>SGEs<S2SV_blank>(%u)\\n" , sge_no ) ; <S2SV_EndBug> return false ; out_mapping_err : <S2SV_StartBug> pr_err ( "rpcrdma:<S2SV_blank>Send<S2SV_blank>mapping<S2SV_blank>error\\n" ) ; <S2SV_EndBug> return false ; } | <S2SV_ModStart> ; out_mapping_overflow : rpcrdma_unmap_sges ( ia , req ) ; <S2SV_ModStart> ; out_mapping_err : rpcrdma_unmap_sges ( ia , req ) ; |
6,281 | CWE-000 FILE * generate_file_handle ( char * method_name , char * operation , int size ) { <S2SV_StartBug> int len = strlen ( method_name ) + strlen ( operation ) + strlen ( "./prelim_results/bifrost___.txt" ) + 4 ; <S2SV_EndBug> printf ( "Length:<S2SV_blank>%d,<S2SV_blank>method_name:<S2SV_blank>%d,<S2SV_blank>operation:<S2SV_blank>%d,<S2SV_blank>everything<S2SV_blank>else:<S2SV_blank>%d\\n" , len , strlen ( method_name ) , strlen ( operation ) , strlen ( "./prelim_results/bifrost___.txt" ) + 4 ) ; int wrote = 0 ; char temp [ len + 1 ] ; if ( size > - 1 ) { wrote = snprintf ( temp , len , "./prelim_results/bifrost_%s_%s_%d.txt" , method_name , operation , size ) ; } else { wrote = snprintf ( temp , len , "./prelim_results/bifrost_%s_%s.txt" , method_name , operation ) ; } <S2SV_StartBug> printf ( "wrote:<S2SV_blank>%d\\n" , wrote ) ; <S2SV_EndBug> return fopen ( temp , "w" ) ; } | <S2SV_ModStart> ) + 4 <S2SV_ModEnd> ; int wrote <S2SV_ModStart> ) ; } <S2SV_ModEnd> return fopen ( |
6,282 | CWE-000 void fu_plugin_device_add_delay ( FuPlugin * plugin , FuDevice * device ) { FuPluginPrivate * priv = GET_PRIVATE ( plugin ) ; FuPluginHelper * helper ; g_return_if_fail ( FU_IS_PLUGIN ( plugin ) ) ; g_return_if_fail ( FU_IS_DEVICE ( device ) ) ; helper = g_hash_table_lookup ( priv -> devices_delay , device ) ; if ( helper != NULL ) { <S2SV_StartBug> g_warning ( "ignoring<S2SV_blank>add-delay<S2SV_blank>as<S2SV_blank>device<S2SV_blank>%s<S2SV_blank>already<S2SV_blank>pending" , <S2SV_EndBug> fu_device_get_id ( device ) ) ; return ; } g_debug ( "waiting<S2SV_blank>a<S2SV_blank>small<S2SV_blank>time<S2SV_blank>for<S2SV_blank>other<S2SV_blank>plugins" ) ; helper = g_new0 ( FuPluginHelper , 1 ) ; helper -> plugin = g_object_ref ( plugin ) ; helper -> device = g_object_ref ( device ) ; helper -> timeout_id = g_timeout_add ( 500 , fu_plugin_device_add_delay_cb , helper ) ; helper -> devices = g_hash_table_ref ( priv -> devices_delay ) ; g_hash_table_insert ( helper -> devices , device , helper ) ; } | <S2SV_ModStart> NULL ) { g_debug <S2SV_ModEnd> ( "ignoring<S2SV_blank>add-delay<S2SV_blank>as<S2SV_blank>device<S2SV_blank>%s<S2SV_blank>already<S2SV_blank>pending" , |
6,283 | CWE-000 static bool _ui_mkraw ( void ) { if ( tcgetattr ( STDIN_FILENO , & uc . cooked ) == UI_INVALID ) { ui_perror ( "tcgetattr" ) ; return false ; } LDBG ( "Getting<S2SV_blank>the<S2SV_blank>attributes<S2SV_blank>of<S2SV_blank>canonical<S2SV_blank>mode" ) ; atexit ( _ui_mkcooked ) ; struct termios raw = uc . cooked ; LDBG ( "Setting<S2SV_blank>the<S2SV_blank>flags<S2SV_blank>for<S2SV_blank>moving<S2SV_blank>the<S2SV_blank>terminal<S2SV_blank>to<S2SV_blank>raw<S2SV_blank>mode" ) ; raw . c_lflag &= ~ ( ECHO | IEXTEN | ICANON | ISIG ) ; raw . c_iflag &= ~ ( BRKINT | ICRNL | INPCK | ISTRIP | IXON ) ; raw . c_oflag &= ~ ( OPOST ) ; raw . c_cflag |= CS8 ; LDBG ( "Setting<S2SV_blank>the<S2SV_blank>wait<S2SV_blank>time<S2SV_blank>for<S2SV_blank>the<S2SV_blank>read<S2SV_blank>function" ) ; raw . c_cc [ VMIN ] = 0 ; raw . c_cc [ VTIME ] = 1 ; LDBG ( "Setting<S2SV_blank>up<S2SV_blank>the<S2SV_blank>flags<S2SV_blank>for<S2SV_blank>the<S2SV_blank>raw<S2SV_blank>mode" ) ; if ( tcsetattr ( STDIN_FILENO , TCSAFLUSH , & raw ) == UI_INVALID ) { ui_perror ( "tcsetattr" ) ; return false ; } LDBG ( "Getting<S2SV_blank>the<S2SV_blank>Window<S2SV_blank>Size" ) ; if ( ui_get_winsize ( & uc . scr_rows , & uc . scr_cols ) == UI_INVALID ) { ui_perror ( "ui_get_winsize" ) ; LDBG ( "Setting<S2SV_blank>default<S2SV_blank>value<S2SV_blank>for<S2SV_blank>screen<S2SV_blank>rows<S2SV_blank>and<S2SV_blank>cols" ) ; uc . scr_rows = UI_DEFAULT_ROWS ; uc . scr_cols = UI_DEFAULT_COLS ; } <S2SV_StartBug> char * fmt = malloc ( sizeof ( line ) ) ; <S2SV_EndBug> sprintf ( fmt , "Rows<S2SV_blank>:<S2SV_blank>%u<S2SV_blank>Cols<S2SV_blank>:<S2SV_blank>%u" , uc . scr_rows , uc . scr_cols ) ; LDBG ( fmt ) ; free ( fmt ) ; return true ; } | <S2SV_ModStart> ( sizeof ( "Rows<S2SV_blank>:<S2SV_blank>%u<S2SV_blank>Cols<S2SV_blank>:<S2SV_blank>%u" ) ) ; snprintf ( fmt , sizeof ( "Rows<S2SV_blank>:<S2SV_blank>%u<S2SV_blank>Cols<S2SV_blank>:<S2SV_blank>%u" ) , "Rows<S2SV_blank>:<S2SV_blank>%u<S2SV_blank>Cols<S2SV_blank>:<S2SV_blank>%u" , <S2SV_ModEnd> uc . scr_rows |
6,284 | CWE-000 <S2SV_StartBug> static inline void errorEnd ( int num , passData * passdata ) { <S2SV_EndBug> cleanUp ( & ( passdata -> operations ) , & ( passdata -> labels ) , & ( passdata -> parts ) , & ( passdata -> insts ) , & ( passdata -> laterLines ) , & ( passdata -> lines ) ) ; exit ( num ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> <S2SV_ModEnd> void errorEnd ( |
6,285 | CWE-000 int manager_startup ( Manager * m , FILE * serialization , FDSet * fds ) { int r , q ; assert ( m ) ; dual_timestamp_get ( & m -> generators_start_timestamp ) ; r = manager_run_generators ( m ) ; dual_timestamp_get ( & m -> generators_finish_timestamp ) ; if ( r < 0 ) return r ; r = lookup_paths_init ( & m -> lookup_paths , m -> running_as , true , NULL , m -> generator_unit_path , m -> generator_unit_path_early , m -> generator_unit_path_late ) ; if ( r < 0 ) return r ; manager_build_unit_path_cache ( m ) ; if ( serialization ) m -> n_reloading ++ ; dual_timestamp_get ( & m -> units_load_start_timestamp ) ; manager_enumerate ( m ) ; dual_timestamp_get ( & m -> units_load_finish_timestamp ) ; <S2SV_StartBug> if ( serialization ) <S2SV_EndBug> <S2SV_StartBug> r = manager_deserialize ( m , serialization , fds ) ; <S2SV_EndBug> manager_distribute_fds ( m , fds ) ; q = manager_setup_notify ( m ) ; if ( q < 0 && r == 0 ) r = q ; q = manager_setup_cgroups_agent ( m ) ; if ( q < 0 && r == 0 ) r = q ; manager_setup_kdbus ( m ) ; manager_connect_bus ( m , ! ! serialization ) ; bus_track_coldplug ( m , & m -> subscribed , & m -> deserialized_subscribed ) ; manager_coldplug ( m ) ; if ( serialization ) { assert ( m -> n_reloading > 0 ) ; m -> n_reloading -- ; m -> send_reloading_done = true ; } return r ; } | <S2SV_ModStart> ( serialization ) { <S2SV_ModStart> fds ) ; if ( r < 0 ) log_error_errno ( r , "Deserialization<S2SV_blank>failed:<S2SV_blank>%m" ) ; } |
6,286 | CWE-000 int getExplodAmountWithID ( DreamPlayer * tPlayer , int tID ) { <S2SV_StartBug> ( void ) tPlayer ; <S2SV_EndBug> ( void ) tID ; return 0 ; } | <S2SV_ModStart> tID ) { FindExplodCaller caller ; caller . mPlayer = tPlayer ; caller . mExplodID = tID ; caller . mReturnValue = 0 ; int_map_map ( & gData . mExplods , compareSingleAmountSearchExplodIDToSearchID , & caller ) ; return caller . mReturnValue <S2SV_ModEnd> ; } <S2SV_null> |
6,287 | CWE-000 uint8_t flashrom_write ( uint8_t * dst , const uint8_t * src , size_t size ) { # if FLASHROM_SECTION_DATA_INIT if ( ! init_done ) { _flashrom_write_addr = & _flashrom_do_write ; init_done = 1 ; } # endif <S2SV_StartBug> uint page_num = flashrom_addr_to_page ( dst ) ; <S2SV_EndBug> if ( page_num == 0xff ) { return 0 ; } mutex_lock ( & flash_mutex ) ; irq_disable ( ) ; _flashrom_do_write ( dst , src , size ) ; irq_enable ( ) ; mutex_unlock ( & flash_mutex ) ; return 1 ; } | <S2SV_ModStart> } # endif uint16_t <S2SV_ModEnd> page_num = flashrom_addr_to_page |
6,288 | CWE-000 void * atm_dict_get ( atm_dict_t * dict , void * key ) { void * res = NULL ; atm_dict_table_t * table ; if ( dict != NULL ) { pthread_rwlock_rdlock ( & dict -> rwlk ) ; table = dict -> ht_active ; res = atm_dict_table_get ( table , key ) ; <S2SV_StartBug> if ( res != NULL ) return res ; <S2SV_EndBug> table = dict -> ht_backup ; res = atm_dict_table_get ( table , key ) ; <S2SV_StartBug> pthread_rwlock_unlock ( & dict -> rwlk ) ; <S2SV_EndBug> } return res ; } | <S2SV_ModStart> if ( res == NULL ) { <S2SV_ModEnd> table = dict <S2SV_ModStart> key ) ; } |
6,289 | CWE-000 static void __sch_beacon_process_for_session ( tpAniSirGlobal mac_ctx , tpSchBeaconStruct bcn , uint8_t * rx_pkt_info , tpPESession session ) { uint8_t bssIdx = 0 ; tUpdateBeaconParams beaconParams ; uint8_t sendProbeReq = false ; tpSirMacMgmtHdr pMh = WMA_GET_RX_MAC_HEADER ( rx_pkt_info ) ; int8_t regMax = 0 , maxTxPower = 0 , local_constraint ; qdf_mem_zero ( & beaconParams , sizeof ( tUpdateBeaconParams ) ) ; beaconParams . paramChangeBitmap = 0 ; if ( LIM_IS_IBSS_ROLE ( session ) ) { lim_handle_ibss_coalescing ( mac_ctx , bcn , rx_pkt_info , session ) ; } else if ( LIM_IS_STA_ROLE ( session ) ) { if ( false == sch_bcn_process_sta ( mac_ctx , bcn , rx_pkt_info , session , & bssIdx , & beaconParams , & sendProbeReq , pMh ) ) return ; } if ( ! ( session -> vhtCapability && ( bcn -> OperatingMode . present || bcn -> VHTOperation . present ) ) && session -> htCapability && bcn -> HTInfo . present && ! LIM_IS_IBSS_ROLE ( session ) ) lim_update_sta_run_time_ht_switch_chnl_params ( mac_ctx , & bcn -> HTInfo , bssIdx , session ) ; if ( ( LIM_IS_STA_ROLE ( session ) && ! wma_is_csa_offload_enabled ( ) ) || LIM_IS_IBSS_ROLE ( session ) ) { if ( bcn -> channelSwitchPresent ) { if ( LIM_IS_STA_ROLE ( session ) ) { <S2SV_StartBug> session -> is_tdls_csa = true ; <S2SV_EndBug> lim_delete_tdls_peers ( mac_ctx , session ) ; } lim_update_channel_switch ( mac_ctx , bcn , session ) ; } else if ( session -> gLimSpecMgmt . dot11hChanSwState == eLIM_11H_CHANSW_RUNNING ) { lim_cancel_dot11h_channel_switch ( mac_ctx , session ) ; } } if ( LIM_IS_STA_ROLE ( session ) || LIM_IS_IBSS_ROLE ( session ) ) sch_bcn_process_sta_ibss ( mac_ctx , bcn , rx_pkt_info , session , & bssIdx , & beaconParams , & sendProbeReq , pMh ) ; regMax = cfg_get_regulatory_max_transmit_power ( mac_ctx , session -> currentOperChannel ) ; local_constraint = regMax ; if ( mac_ctx -> roam . configParam . allow_tpc_from_ap ) { get_local_power_constraint_beacon ( bcn , & local_constraint ) ; pe_debug ( "ESE<S2SV_blank>localPowerConstraint<S2SV_blank>=<S2SV_blank>%d," , local_constraint ) ; if ( mac_ctx -> rrm . rrmPEContext . rrmEnable && bcn -> powerConstraintPresent ) { local_constraint = regMax ; local_constraint -= bcn -> localPowerConstraint . localPowerConstraints ; pe_debug ( "localPowerConstraint<S2SV_blank>=<S2SV_blank>%d," , local_constraint ) ; } } maxTxPower = lim_get_max_tx_power ( regMax , local_constraint , mac_ctx -> roam . configParam . nTxPowerCap ) ; pe_debug ( "RegMax<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>MaxTx<S2SV_blank>pwr<S2SV_blank>=<S2SV_blank>%d" , regMax , maxTxPower ) ; if ( maxTxPower != session -> maxTxPower ) { pe_debug ( FL ( "Local<S2SV_blank>power<S2SV_blank>constraint<S2SV_blank>change,<S2SV_blank>Updating<S2SV_blank>new<S2SV_blank>maxTx<S2SV_blank>power<S2SV_blank>%d<S2SV_blank>from<S2SV_blank>old<S2SV_blank>pwr<S2SV_blank>%d" ) , maxTxPower , session -> maxTxPower ) ; if ( lim_send_set_max_tx_power_req ( mac_ctx , maxTxPower , session ) == eSIR_SUCCESS ) session -> maxTxPower = maxTxPower ; } if ( bcn -> HTInfo . present ) lim_received_hb_handler ( mac_ctx , ( uint8_t ) bcn -> HTInfo . primaryChannel , session ) ; else lim_received_hb_handler ( mac_ctx , ( uint8_t ) bcn -> channelNumber , session ) ; if ( sendProbeReq ) lim_send_probe_req_mgmt_frame ( mac_ctx , & session -> ssId , session -> bssId , session -> currentOperChannel , session -> selfMacAddr , session -> dot11mode , NULL , NULL ) ; if ( ( false == mac_ctx -> sap . SapDfsInfo . is_dfs_cac_timer_running ) && beaconParams . paramChangeBitmap ) { pe_warn ( "Beacon<S2SV_blank>for<S2SV_blank>session[%d]<S2SV_blank>got<S2SV_blank>changed." , session -> peSessionId ) ; pe_warn ( "sending<S2SV_blank>beacon<S2SV_blank>param<S2SV_blank>change<S2SV_blank>bitmap:<S2SV_blank>0x%x" , beaconParams . paramChangeBitmap ) ; lim_send_beacon_params ( mac_ctx , & beaconParams , session ) ; } if ( ( session -> pePersona == QDF_P2P_CLIENT_MODE ) && session -> send_p2p_conf_frame ) { lim_p2p_oper_chan_change_confirm_action_frame ( mac_ctx , session -> bssId , session ) ; session -> send_p2p_conf_frame = false ; } } | <S2SV_ModStart> ) ) { # ifdef FEATURE_WLAN_TDLS <S2SV_ModStart> = true ; # endif |
6,290 | CWE-000 static clib_error_t * upf_dpi_url_test_command_fn ( vlib_main_t * vm , unformat_input_t * input , vlib_cli_command_t * cmd ) { unformat_input_t _line_input , * line_input = & _line_input ; u8 * url = NULL ; clib_error_t * error = NULL ; u32 app_index = 0 ; u32 id = 0 ; <S2SV_StartBug> int res = 0 ; <S2SV_EndBug> upf_dpi_app_t * app = NULL ; upf_main_t * sm = & upf_main ; if ( ! unformat_user ( input , unformat_line_input , line_input ) ) return error ; while ( unformat_check_input ( line_input ) != UNFORMAT_END_OF_INPUT ) { if ( unformat ( line_input , "%u<S2SV_blank>url<S2SV_blank>%s" , & id , & url ) ) { break ; } else { error = clib_error_return ( 0 , "unknown<S2SV_blank>input<S2SV_blank>`%U\'" , format_unformat_error , input ) ; goto done ; } } <S2SV_StartBug> res = upf_dpi_lookup ( id , url , vec_len ( url ) , & app_index ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ( res == 0 ) && <S2SV_EndBug> ( app_index > 0 ) && <S2SV_StartBug> ( pool_elts ( sm -> upf_apps ) >= app_index ) ) <S2SV_EndBug> { app = pool_elt_at_index ( sm -> upf_apps , app_index - 1 ) ; if ( app ) { vlib_cli_output ( vm , "Matched<S2SV_blank>app:<S2SV_blank>%s" , app -> name ) ; } } else { vlib_cli_output ( vm , "No<S2SV_blank>match<S2SV_blank>found" ) ; } done : vec_free ( url ) ; unformat_free ( line_input ) ; return error ; } | <S2SV_ModStart> = 0 ; <S2SV_ModEnd> upf_dpi_app_t * app <S2SV_ModStart> ; } } <S2SV_ModEnd> upf_dpi_lookup ( id <S2SV_ModStart> ; if ( app_index != ~ 0 ) { app = pool_elt_at_index <S2SV_ModEnd> ( sm -> <S2SV_ModStart> sm -> upf_apps , app_index <S2SV_ModEnd> ) ; if |
6,291 | CWE-000 static ssize_t vy_log_flush_f ( va_list ap ) { struct vy_log * log = va_arg ( ap , struct vy_log * ) ; <S2SV_StartBug> if ( xlog_tx_commit ( log -> xlog ) < 0 || <S2SV_EndBug> xlog_flush ( log -> xlog ) < 0 ) <S2SV_StartBug> return 1 ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> * ) ; int * rc = va_arg ( ap , int * ) ; <S2SV_ModStart> < 0 ) * rc = - 1 ; else * rc = 0 <S2SV_ModEnd> ; return 0 |
6,292 | CWE-000 static int style_length ( lua_State * L ) { dt_style_t style ; luaA_to ( L , dt_style_t , & style , - 1 ) ; <S2SV_StartBug> GList * items = dt_styles_get_item_list ( style . name , true , - 1 ) ; <S2SV_EndBug> lua_pushinteger ( L , g_list_length ( items ) ) ; g_list_free_full ( items , dt_style_item_free ) ; return 1 ; } | <S2SV_ModStart> . name , TRUE <S2SV_ModEnd> , - 1 |
6,293 | CWE-000 void relocate_to_current_adr ( void ) { uint32_t offset ; uint32_t * dstart , * dend , * dynsym , * dynend ; offset = get_runtime_offset ( ) ; <S2SV_StartBug> dstart = ( void * ) ( ld_var ( __rel_dyn_start ) + offset ) ; <S2SV_EndBug> <S2SV_StartBug> dend = ( void * ) ( ld_var ( __rel_dyn_end ) + offset ) ; <S2SV_EndBug> dynsym = ( void * ) ( ld_var ( __dynsym_start ) + offset ) ; <S2SV_StartBug> dynend = ( void * ) ( ld_var ( __dynsym_end ) + offset ) ; <S2SV_EndBug> while ( dstart < dend ) { uint32_t * fixup = ( uint32_t * ) ( * dstart + offset ) ; uint32_t type = * ( dstart + 1 ) ; if ( ( type & 0xff ) == 0x17 ) { * fixup = * fixup + offset ; } else { int index = type >> 8 ; uint32_t r = dynsym [ index * 4 + 1 ] ; * fixup = * fixup + r + offset ; } * dstart += offset ; dstart += 2 ; } memset ( dynsym , 0 , ( unsigned long ) dynend - ( unsigned long ) dynsym ) ; arm_early_mmu_cache_flush ( ) ; icache_invalidate ( ) ; } | <S2SV_ModStart> void * ) __rel_dyn_start + offset <S2SV_ModEnd> ; dend = <S2SV_ModStart> void * ) __rel_dyn_end + offset ; dynsym = ( void * ) __dynsym_start + offset <S2SV_ModEnd> ; dynend = <S2SV_ModStart> void * ) __dynsym_end + offset <S2SV_ModEnd> ; while ( |
6,294 | CWE-000 const dt_collection_t * dt_collection_new ( const dt_collection_t * clone ) { dt_collection_t * collection = g_malloc0 ( sizeof ( dt_collection_t ) ) ; if ( clone ) { memcpy ( & collection -> params , & clone -> params , sizeof ( dt_collection_params_t ) ) ; memcpy ( & collection -> store , & clone -> store , sizeof ( dt_collection_params_t ) ) ; collection -> where_ext = g_strdupv ( clone -> where_ext ) ; collection -> query = g_strdup ( clone -> query ) ; <S2SV_StartBug> collection -> clone = 1 ; <S2SV_EndBug> <S2SV_StartBug> collection -> count = clone -> count ; <S2SV_EndBug> } else dt_collection_reset ( collection ) ; dt_control_signal_connect ( darktable . signals , DT_SIGNAL_TAG_CHANGED , G_CALLBACK ( _dt_collection_recount_callback_1 ) , collection ) ; dt_control_signal_connect ( darktable . signals , DT_SIGNAL_FILMROLLS_CHANGED , G_CALLBACK ( _dt_collection_recount_callback_1 ) , collection ) ; dt_control_signal_connect ( darktable . signals , DT_SIGNAL_FILMROLLS_REMOVED , G_CALLBACK ( _dt_collection_recount_callback_1 ) , collection ) ; dt_control_signal_connect ( darktable . signals , DT_SIGNAL_IMAGE_IMPORT , G_CALLBACK ( _dt_collection_recount_callback_2 ) , collection ) ; dt_control_signal_connect ( darktable . signals , DT_SIGNAL_FILMROLLS_IMPORTED , G_CALLBACK ( _dt_collection_recount_callback_2 ) , collection ) ; return collection ; } | <S2SV_ModStart> ; collection -> query_no_group = g_strdup ( clone -> query_no_group ) ; collection -> <S2SV_ModStart> clone -> count ; collection -> count_no_group = clone -> count_no_group |
6,295 | CWE-000 static int process_frame ( shm_cbuf * cb , void * arg , io_stream * io_s ) { video_frames * vfs = ( video_frames * ) arg ; uint8_t * dst_data [ 4 ] ; int dst_linesize [ 4 ] ; int i ; for ( i = 0 ; i < vfs -> count ; ++ i ) { <S2SV_StartBug> av_image_fill_arrays ( dst_data , dst_linesize , shrb_get ( cb , vfs -> frames [ i ] . index ) , vfs -> format , vfs -> width , vfs -> height , vfs -> align ) ; <S2SV_EndBug> SDL_Rect rect = { 0 , 0 , vfs -> width , vfs -> height } ; SDL_UpdateYUVTexture ( sdlTexture , & rect , dst_data [ 0 ] , dst_linesize [ 0 ] , dst_data [ 1 ] , dst_linesize [ 1 ] , dst_data [ 2 ] , dst_linesize [ 2 ] ) ; SDL_RenderCopy ( wnd -> renderer , sdlTexture , NULL , & rect ) ; SDL_RenderPresent ( wnd -> renderer ) ; <S2SV_StartBug> usleep ( 25000 ) ; <S2SV_EndBug> } } | <S2SV_ModStart> i ) { clock_t begin = clock ( ) ; <S2SV_ModStart> renderer ) ; shrb_free ( cb ) ; clock_t end = clock ( ) ; double time_spent = ( double ) ( end - begin ) / CLOCKS_PER_SEC * 1000 <S2SV_ModEnd> ; } } |
6,296 | CWE-000 static int synaptics_ts_suspend ( struct device * dev ) { int ret , i ; struct synaptics_ts_data * ts = dev_get_drvdata ( dev ) ; if ( ts -> input_dev == NULL ) { ret = - ENOMEM ; TPD_ERR ( "input_dev<S2SV_blank><S2SV_blank>registration<S2SV_blank>is<S2SV_blank>not<S2SV_blank>complete\\n" ) ; return - 1 ; } TPD_DEBUG ( "%s<S2SV_blank>enter\\n" , __func__ ) ; if ( ts -> pre_btn_state & 0x01 ) { ts -> pre_btn_state &= 0x02 ; input_report_key ( ts -> input_dev , OEM_KEY_BACK , 0 ) ; input_sync ( ts -> input_dev ) ; } else if ( ts -> pre_btn_state & 0x02 ) { ts -> pre_btn_state &= 0x01 ; input_report_key ( ts -> input_dev , OEM_KEY_APPSELECT , 0 ) ; input_sync ( ts -> input_dev ) ; } for ( i = 0 ; i < ts -> max_num ; i ++ ) { input_mt_slot ( ts -> input_dev , i ) ; input_mt_report_slot_state ( ts -> input_dev , MT_TOOL_FINGER , 0 ) ; } input_report_key ( ts -> input_dev , BTN_TOOL_FINGER , 0 ) ; input_sync ( ts -> input_dev ) ; # ifndef TPD_USE_EINT hrtimer_cancel ( & ts -> timer ) ; # endif # ifdef SUPPORT_GESTURE if ( ts -> gesture_enable ) { atomic_set ( & ts -> is_stop , 0 ) ; if ( mutex_trylock ( & ts -> mutex ) ) { touch_enable ( ts ) ; synaptics_enable_interrupt_for_gesture ( ts , 1 ) ; mutex_unlock ( & ts -> mutex ) ; TPD_ERR ( "enter<S2SV_blank>gesture<S2SV_blank>mode\\n" ) ; } <S2SV_StartBug> set_doze_time ( 2 ) ; <S2SV_EndBug> if ( ts -> project_version == 0x03 ) { mutex_lock ( & ts -> mutex ) ; tp_single_tap_en ( ts , true ) ; mutex_unlock ( & ts -> mutex ) ; } } else { if ( ! ts -> loading_fw ) { ret = synaptics_mode_change ( 0x01 ) ; if ( ret < 0 ) { TPD_ERR ( "%s<S2SV_blank>line%d<S2SV_blank>ERROR<S2SV_blank>%d!\\n" , __func__ , __LINE__ , ret ) ; } } } # endif TPD_DEBUG ( "%s<S2SV_blank>normal<S2SV_blank>end\\n" , __func__ ) ; return 0 ; } | <S2SV_ModStart> ) ; } <S2SV_ModEnd> if ( ts |
6,297 | CWE-000 static void eof_benchmark_rubberband_callback ( void * buffer , int nsamples , int stereo ) { int i ; unsigned short * buffer_sp = ( unsigned short * ) buffer ; static unsigned long progress = 0 , samples_processed = 0 ; unsigned new_progress ; char windowtitle [ 101 ] ; <S2SV_StartBug> if ( key [ KEY_ESC ] ) <S2SV_EndBug> eof_benchmark_rubberband_cancel = 1 ; if ( eof_benchmark_rubberband_cancel ) return ; if ( stereo ) { int halfnsamples = nsamples / 2 ; for ( i = 0 ; i < halfnsamples ; i ++ ) { eof_benchmark_rubberband_buffer [ 0 ] [ i ] = ( float ) ( ( long ) buffer_sp [ i * 2 ] - 0x8000 ) / ( float ) 0x8000 ; eof_benchmark_rubberband_buffer [ 1 ] [ i ] = ( float ) ( ( long ) buffer_sp [ i * 2 + 1 ] - 0x8000 ) / ( float ) 0x8000 ; } } else { for ( i = 0 ; i < nsamples ; i ++ ) { eof_benchmark_rubberband_buffer [ 0 ] [ i ] = ( float ) ( ( long ) buffer_sp [ i ] - 0x8000 ) / ( float ) 0x8000 ; } } rubberband_process ( eof_benchmark_rubberband_state , ( const float * * ) eof_benchmark_rubberband_buffer , nsamples , 0 ) ; while ( rubberband_available ( eof_benchmark_rubberband_state ) >= EOF_BENCHMARK_RUBBERBAND_BUFFSIZE ) { rubberband_retrieve ( eof_benchmark_rubberband_state , eof_benchmark_rubberband_buffer , EOF_BENCHMARK_RUBBERBAND_BUFFSIZE ) ; } samples_processed += nsamples ; new_progress = samples_processed * 100 / eof_benchmark_rubberband_sample_count ; if ( new_progress > progress ) { snprintf ( windowtitle , sizeof ( windowtitle ) - 1 , "Benchmarking<S2SV_blank>rubberband:<S2SV_blank>%u%%<S2SV_blank>-<S2SV_blank>Press<S2SV_blank>Esc<S2SV_blank>to<S2SV_blank>cancel" , new_progress ) ; set_window_title ( windowtitle ) ; progress = new_progress ; } } | <S2SV_ModStart> ; if ( ! buffer ) { progress = samples_processed = 0 ; return ; } if ( |
6,298 | CWE-000 Ctrl_status vfs_read_capacity ( uint32_t * last_valid_sector ) { <S2SV_StartBug> if ( disk_ioctl ( VFS_INDEX , GET_SECTOR_COUNT , last_valid_sector ) != RES_OK ) { <S2SV_EndBug> return CTRL_FAIL ; } ( * last_valid_sector ) -- ; return CTRL_GOOD ; } | <S2SV_ModStart> last_valid_sector ) { fs_user_mount_t * vfs = get_vfs ( VFS_INDEX ) ; if ( vfs == NULL || disk_ioctl ( vfs <S2SV_ModEnd> , GET_SECTOR_COUNT , |
6,299 | CWE-000 static void aw_a10_realize ( DeviceState * dev , Error * * errp ) { AwA10State * s = AW_A10 ( dev ) ; SysBusDevice * sysbusdev ; uint8_t i ; qemu_irq fiq , irq ; Error * err = NULL ; object_property_set_bool ( OBJECT ( & s -> cpu ) , true , "realized" , & err ) ; if ( err != NULL ) { error_propagate ( errp , err ) ; return ; } irq = qdev_get_gpio_in ( DEVICE ( & s -> cpu ) , ARM_CPU_IRQ ) ; fiq = qdev_get_gpio_in ( DEVICE ( & s -> cpu ) , ARM_CPU_FIQ ) ; object_property_set_bool ( OBJECT ( & s -> intc ) , true , "realized" , & err ) ; if ( err != NULL ) { error_propagate ( errp , err ) ; return ; } sysbusdev = SYS_BUS_DEVICE ( & s -> intc ) ; sysbus_mmio_map ( sysbusdev , 0 , AW_A10_PIC_REG_BASE ) ; sysbus_connect_irq ( sysbusdev , 0 , irq ) ; sysbus_connect_irq ( sysbusdev , 1 , fiq ) ; for ( i = 0 ; i < AW_A10_PIC_INT_NR ; i ++ ) { s -> irq [ i ] = qdev_get_gpio_in ( DEVICE ( & s -> intc ) , i ) ; } object_property_set_bool ( OBJECT ( & s -> timer ) , true , "realized" , & err ) ; if ( err != NULL ) { error_propagate ( errp , err ) ; return ; } sysbusdev = SYS_BUS_DEVICE ( & s -> timer ) ; sysbus_mmio_map ( sysbusdev , 0 , AW_A10_PIT_REG_BASE ) ; sysbus_connect_irq ( sysbusdev , 0 , s -> irq [ 22 ] ) ; sysbus_connect_irq ( sysbusdev , 1 , s -> irq [ 23 ] ) ; sysbus_connect_irq ( sysbusdev , 2 , s -> irq [ 24 ] ) ; sysbus_connect_irq ( sysbusdev , 3 , s -> irq [ 25 ] ) ; sysbus_connect_irq ( sysbusdev , 4 , s -> irq [ 67 ] ) ; sysbus_connect_irq ( sysbusdev , 5 , s -> irq [ 68 ] ) ; <S2SV_StartBug> object_property_set_bool ( OBJECT ( & s -> emac ) , true , "realized" , & err ) ; <S2SV_EndBug> if ( err != NULL ) { error_propagate ( errp , err ) ; return ; } sysbusdev = SYS_BUS_DEVICE ( & s -> emac ) ; sysbus_mmio_map ( sysbusdev , 0 , AW_A10_EMAC_BASE ) ; sysbus_connect_irq ( sysbusdev , 0 , s -> irq [ 55 ] ) ; object_property_set_bool ( OBJECT ( & s -> sata ) , true , "realized" , & err ) ; if ( err ) { error_propagate ( errp , err ) ; return ; } sysbus_mmio_map ( SYS_BUS_DEVICE ( & s -> sata ) , 0 , AW_A10_SATA_BASE ) ; sysbus_connect_irq ( SYS_BUS_DEVICE ( & s -> sata ) , 0 , s -> irq [ 56 ] ) ; serial_mm_init ( get_system_memory ( ) , AW_A10_UART0_REG_BASE , 2 , s -> irq [ 1 ] , 115200 , serial_hds [ 0 ] , DEVICE_NATIVE_ENDIAN ) ; } | <S2SV_ModStart> ] ) ; if ( nd_table [ 0 ] . used ) { qemu_check_nic_model ( & nd_table [ 0 ] , TYPE_AW_EMAC ) ; qdev_set_nic_properties ( DEVICE ( & s -> emac ) , & nd_table [ 0 ] ) ; } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.