Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
2,400 | CWE-000 struct xfs_btree_cur * xfs_allocbt_init_cursor ( struct xfs_mount * mp , struct xfs_trans * tp , struct xfs_buf * agbp , xfs_agnumber_t agno , xfs_btnum_t btnum ) { struct xfs_agf * agf = XFS_BUF_TO_AGF ( agbp ) ; struct xfs_btree_cur * cur ; ASSERT ( btnum == XFS_BTNUM_BNO || btnum == XFS_BTNUM_CNT ) ; cur = kmem_zone_zalloc ( xfs_btree_cur_zone , KM_NOFS ) ; cur -> bc_tp = tp ; cur -> bc_mp = mp ; cur -> bc_btnum = btnum ; cur -> bc_blocklog = mp -> m_sb . sb_blocklog ; <S2SV_StartBug> cur -> bc_ops = & xfs_allocbt_ops ; <S2SV_EndBug> if ( btnum == XFS_BTNUM_BNO ) cur -> bc_statoff = XFS_STATS_CALC_INDEX ( xs_abtb_2 ) ; else cur -> bc_statoff = XFS_STATS_CALC_INDEX ( xs_abtc_2 ) ; <S2SV_StartBug> if ( btnum == XFS_BTNUM_CNT ) { <S2SV_EndBug> cur -> bc_nlevels = be32_to_cpu ( agf -> agf_levels [ XFS_BTNUM_CNT ] ) ; cur -> bc_flags = XFS_BTREE_LASTREC_UPDATE ; } else { <S2SV_StartBug> cur -> bc_nlevels = be32_to_cpu ( agf -> agf_levels [ XFS_BTNUM_BNO ] ) ; <S2SV_EndBug> } cur -> bc_private . a . agbp = agbp ; cur -> bc_private . a . agno = agno ; if ( xfs_sb_version_hascrc ( & mp -> m_sb ) ) cur -> bc_flags |= XFS_BTREE_CRC_BLOCKS ; return cur ; } | <S2SV_ModStart> . sb_blocklog ; <S2SV_ModEnd> if ( btnum <S2SV_ModStart> XFS_BTNUM_CNT ) { cur -> bc_statoff = XFS_STATS_CALC_INDEX ( xs_abtc_2 ) ; cur -> bc_ops = & xfs_cntbt_ops ; <S2SV_ModStart> { cur -> bc_statoff = XFS_STATS_CALC_INDEX ( xs_abtb_2 ) ; cur -> bc_ops = & xfs_bnobt_ops ; cur -> |
2,401 | CWE-000 unsigned int updateADCDistance ( unsigned int index , unsigned int place , unsigned long ADCValue ) { Nokia5110_SetCursor ( 5 , place ) ; unsigned int distanceCalc ; distanceCalc = tableDistance [ index ] + ( ADCValue - tableADCValue [ index ] ) * ( tableDistance [ index ] - tableDistance [ index + 1 ] ) / ( tableADCValue [ index ] - tableADCValue [ index + 1 ] ) ; if ( distanceCalc < 10 ) <S2SV_StartBug> distance = 10 ; <S2SV_EndBug> if ( distanceCalc >= 51 ) Nokia5110_OutString ( "OOR<S2SV_blank><S2SV_blank><S2SV_blank>" ) ; else Nokia5110_OutUDec ( distanceCalc ) ; return distanceCalc ; } | <S2SV_ModStart> < 10 ) distanceCalc <S2SV_ModEnd> = 10 ; |
2,402 | CWE-000 int32_t CASendTCPUnicastData ( const CAEndpoint_t * endpoint , const void * data , uint32_t dataLength , CADataType_t dataType ) { OIC_LOG ( DEBUG , TAG , "IN" ) ; ( void ) dataType ; if ( ( 0 == dataLength ) || ( dataLength > INT32_MAX ) ) { OIC_LOG ( ERROR , TAG , "Invalid<S2SV_blank>Data<S2SV_blank>Length" ) ; return - 1 ; } # ifndef SINGLE_THREAD <S2SV_StartBug> return CAQueueTCPData ( false , endpoint , data , dataLength ) ; <S2SV_EndBug> # else return ( int32_t ) CATCPSendData ( endpoint , data , dataLength ) ; # endif } | <S2SV_ModStart> data , dataLength , false |
2,403 | CWE-000 int main ( int argc , char * * argv ) { int file ; piece p [ 27 ] ; boards * board ; file = open ( argv [ 1 ] , O_RDONLY ) ; board = ( boards * ) malloc ( sizeof ( boards ) * 2 ) ; zero_it ( board , p ) ; reader ( file , p ) ; board -> final = get_final ( p ) ; board -> size = 3 ; if ( solver ( p , board ) ) { printer ( p , board ) ; <S2SV_StartBug> temp ( board , p ) ; <S2SV_EndBug> } else write ( 1 , "sorry,<S2SV_blank>no<S2SV_blank>answer\\n" , 17 ) ; return ( 0 ) ; } | <S2SV_ModStart> board ) ; <S2SV_ModEnd> } else write |
2,404 | CWE-000 int sctp_tsnmap_mark ( struct sctp_tsnmap * map , __u32 tsn ) { u16 gap ; if ( TSN_lt ( tsn , map -> base_tsn ) ) return 0 ; gap = tsn - map -> base_tsn ; <S2SV_StartBug> if ( gap >= map -> len && ! sctp_tsnmap_grow ( map , gap ) ) <S2SV_EndBug> return - ENOMEM ; if ( ! sctp_tsnmap_has_gap ( map ) && gap == 0 ) { map -> max_tsn_seen ++ ; map -> cumulative_tsn_ack_point ++ ; map -> base_tsn ++ ; } else { if ( TSN_lt ( map -> max_tsn_seen , tsn ) ) map -> max_tsn_seen = tsn ; set_bit ( gap , map -> tsn_map ) ; sctp_tsnmap_update ( map ) ; } return 0 ; } | <S2SV_ModStart> map , gap + 1 |
2,405 | CWE-000 char * astringReadFileToMemory ( const char * filename , unsigned int * length ) { * length = 0 ; FILE * pFile = fopen ( filename , "rb" ) ; if ( pFile == 0 ) { fprintf ( stderr , RED "AmmServer_ReadFileToMemory<S2SV_blank>failed\\n" NORMAL ) ; fprintf ( stderr , RED "Could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>file<S2SV_blank>%s<S2SV_blank>\\n" NORMAL , filename ) ; return 0 ; } fseek ( pFile , 0 , SEEK_END ) ; unsigned long lSize = ftell ( pFile ) ; rewind ( pFile ) ; <S2SV_StartBug> unsigned long bufferSize = sizeof ( char ) * ( lSize + 2 ) ; <S2SV_EndBug> char * buffer = ( char * ) malloc ( bufferSize ) ; if ( buffer == 0 ) { fprintf ( stderr , RED "Could<S2SV_blank>not<S2SV_blank>allocate<S2SV_blank>enough<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>file<S2SV_blank>%s<S2SV_blank>\\n" NORMAL , filename ) ; fclose ( pFile ) ; return 0 ; } size_t result = fread ( buffer , 1 , lSize , pFile ) ; if ( result != lSize ) { safeFree ( buffer , bufferSize ) ; fprintf ( stderr , RED "Could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>the<S2SV_blank>whole<S2SV_blank>file<S2SV_blank>onto<S2SV_blank>memory<S2SV_blank>%s<S2SV_blank>\\n" NORMAL , filename ) ; fclose ( pFile ) ; return 0 ; } fclose ( pFile ) ; buffer [ lSize ] = 0 ; * length = ( unsigned int ) lSize ; return buffer ; } | <S2SV_ModStart> ( lSize + 1 <S2SV_ModEnd> ) ; char |
2,406 | CWE-000 int csync_check_mod ( const char * file , int recursive , int ignnoent , int init_run ) { int check_type = csync_match_file ( file ) ; int dirdump_this = 0 , dirdump_parent = 0 ; struct dirent * * namelist ; int n , this_is_dirty = 0 ; const char * checktxt ; struct stat st ; if ( * file != '%' ) { struct csync_prefix * p ; for ( p = csync_prefix ; p ; p = p -> next ) { if ( ! p -> path ) continue ; if ( ! strcmp ( file , p -> path ) ) { char new_file [ strlen ( p -> name ) + 3 ] ; sprintf ( new_file , "%%%s%%" , p -> name ) ; csync_debug ( 2 , "Prefix<S2SV_blank>matched:<S2SV_blank>%s<S2SV_blank><-<S2SV_blank>%s.\\n" , new_file , file ) ; csync_check_mod ( new_file , recursive , ignnoent , init_run ) ; continue ; } if ( check_type < 1 ) { int file_len = strlen ( file ) ; int path_len = strlen ( p -> path ) ; if ( file_len < path_len && p -> path [ file_len ] == '/' && ! strncmp ( file , p -> path , file_len ) ) check_type = 1 ; } } } if ( check_type > 0 && lstat_strict ( prefixsubst ( file ) , & st ) != 0 ) { if ( ignnoent ) return 0 ; csync_fatal ( "This<S2SV_blank>should<S2SV_blank>not<S2SV_blank>happen:<S2SV_blank>" <S2SV_StartBug> "Can\'t<S2SV_blank>stat<S2SV_blank>%s.\\n" , file ) ; <S2SV_EndBug> } switch ( check_type ) { case 2 : csync_debug ( 2 , "Checking<S2SV_blank>%s.\\n" , file ) ; checktxt = csync_genchecktxt ( & st , file , 0 ) ; if ( csync_compare_mode ) printf ( "%s\\n" , file ) ; SQL_BEGIN ( "Checking<S2SV_blank>File" , "SELECT<S2SV_blank>checktxt<S2SV_blank>FROM<S2SV_blank>file<S2SV_blank>WHERE<S2SV_blank>" "filename<S2SV_blank>=<S2SV_blank>\'%s\'" , url_encode ( file ) ) { if ( ! csync_cmpchecktxt ( checktxt , url_decode ( SQL_V ( 0 ) ) ) ) { csync_debug ( 2 , "File<S2SV_blank>has<S2SV_blank>changed:<S2SV_blank>%s\\n" , file ) ; this_is_dirty = 1 ; } } SQL_FIN { if ( SQL_COUNT == 0 ) { csync_debug ( 2 , "New<S2SV_blank>file:<S2SV_blank>%s\\n" , file ) ; this_is_dirty = 1 ; } } SQL_END ; if ( this_is_dirty && ! csync_compare_mode ) { SQL ( "Deleting<S2SV_blank>old<S2SV_blank>file<S2SV_blank>entry" , "DELETE<S2SV_blank>FROM<S2SV_blank>file<S2SV_blank>WHERE<S2SV_blank>filename<S2SV_blank>=<S2SV_blank>\'%s\'" , url_encode ( file ) ) ; SQL ( "Adding<S2SV_blank>or<S2SV_blank>updating<S2SV_blank>file<S2SV_blank>entry" , "INSERT<S2SV_blank>INTO<S2SV_blank>file<S2SV_blank>(filename,<S2SV_blank>checktxt)<S2SV_blank>" "VALUES<S2SV_blank>(\'%s\',<S2SV_blank>\'%s\')" , url_encode ( file ) , url_encode ( checktxt ) ) ; if ( ! init_run ) csync_mark ( file , 0 , 0 ) ; } dirdump_this = 1 ; dirdump_parent = 1 ; case 1 : if ( ! recursive ) break ; if ( ! S_ISDIR ( st . st_mode ) ) break ; csync_debug ( 2 , "Checking<S2SV_blank>%s%s*<S2SV_blank>..\\n" , file , ! strcmp ( file , "/" ) ? "" : "/" ) ; n = scandir ( prefixsubst ( file ) , & namelist , 0 , alphasort ) ; if ( n < 0 ) { csync_debug ( 0 , "%s<S2SV_blank>in<S2SV_blank>scandir:<S2SV_blank>%s<S2SV_blank>(%s)\\n" , strerror ( errno ) , prefixsubst ( file ) , file ) ; csync_error_count ++ ; } else { while ( n -- ) { on_cygwin_lowercase ( namelist [ n ] -> d_name ) ; if ( strcmp ( namelist [ n ] -> d_name , "." ) && strcmp ( namelist [ n ] -> d_name , ".." ) ) { char fn [ strlen ( file ) + strlen ( namelist [ n ] -> d_name ) + 2 ] ; sprintf ( fn , "%s/%s" , ! strcmp ( file , "/" ) ? "" : file , namelist [ n ] -> d_name ) ; if ( csync_check_mod ( fn , recursive , 0 , init_run ) ) dirdump_this = 1 ; } free ( namelist [ n ] ) ; } free ( namelist ) ; } if ( dirdump_this && csync_dump_dir_fd >= 0 ) { int written = 0 , len = strlen ( file ) + 1 ; while ( written < len ) { int rc = write ( csync_dump_dir_fd , file + written , len - written ) ; if ( rc <= 0 ) csync_fatal ( "Error<S2SV_blank>while<S2SV_blank>writing<S2SV_blank>to<S2SV_blank>dump_dir_fd<S2SV_blank>%d:<S2SV_blank>%s\\n" , csync_dump_dir_fd , strerror ( errno ) ) ; written += rc ; } } break ; default : csync_debug ( 2 , "Don\'t<S2SV_blank>check<S2SV_blank>at<S2SV_blank>all:<S2SV_blank>%s\\n" , file ) ; break ; } return dirdump_parent ; } | <S2SV_ModStart> "This<S2SV_blank>should<S2SV_blank>not<S2SV_blank>happen:<S2SV_blank>" "Can\'t<S2SV_blank>stat<S2SV_blank>%s.\\n" , prefixsubst ( file ) <S2SV_ModEnd> ) ; } |
2,407 | CWE-000 int get_pd ( int fd , uint8_t * * dev , struct udf_disc * disc , size_t sectorsize , size_t st_size , struct filesystemStats * stats , vds_sequence_t * seq ) { int vds = - 1 ; uint32_t offset = 0 , chunk = 0 ; uint32_t chunksize = CHUNK_SIZE ; uint64_t position = 0 ; if ( ( vds = get_correct ( seq , TAG_IDENT_PD ) ) < 0 ) { err ( "No<S2SV_blank>correct<S2SV_blank>PD<S2SV_blank>found.<S2SV_blank>Aborting.\\n" ) ; return 4 ; } struct partitionHeaderDesc * phd = ( struct partitionHeaderDesc * ) ( disc -> udf_pd [ vds ] -> partitionContentsUse ) ; dbg ( "[USD]<S2SV_blank>UST<S2SV_blank>pos:<S2SV_blank>%d,<S2SV_blank>len:<S2SV_blank>%d\\n" , phd -> unallocSpaceTable . extPosition , phd -> unallocSpaceTable . extLength ) ; dbg ( "[USD]<S2SV_blank>USB<S2SV_blank>pos:<S2SV_blank>%d,<S2SV_blank>len:<S2SV_blank>%d\\n" , phd -> unallocSpaceBitmap . extPosition , phd -> unallocSpaceBitmap . extLength ) ; dbg ( "[USD]<S2SV_blank>FST<S2SV_blank>pos:<S2SV_blank>%d,<S2SV_blank>len:<S2SV_blank>%d\\n" , phd -> freedSpaceTable . extPosition , phd -> freedSpaceTable . extLength ) ; dbg ( "[USD]<S2SV_blank>FSB<S2SV_blank>pos:<S2SV_blank>%d,<S2SV_blank>len:<S2SV_blank>%d\\n" , phd -> freedSpaceBitmap . extPosition , phd -> freedSpaceBitmap . extLength ) ; if ( phd -> unallocSpaceTable . extLength > 0 ) { err ( "[USD]<S2SV_blank>Unallocated<S2SV_blank>Space<S2SV_blank>Table<S2SV_blank>is<S2SV_blank>unhandled.<S2SV_blank>Skipping.\\n" ) ; return - 128 ; } if ( phd -> freedSpaceTable . extLength > 0 ) { err ( "[USD]<S2SV_blank>Free<S2SV_blank>Space<S2SV_blank>Table<S2SV_blank>is<S2SV_blank>unhandled.<S2SV_blank>Skipping.\\n" ) ; return - 128 ; } if ( phd -> freedSpaceBitmap . extLength > 0 ) { err ( "[USD]<S2SV_blank>Freed<S2SV_blank>Space<S2SV_blank>Bitmap<S2SV_blank>is<S2SV_blank>unhandled.<S2SV_blank>Skipping.\\n" ) ; return - 128 ; } if ( phd -> unallocSpaceBitmap . extLength > 3 ) { uint32_t lsnBase = disc -> udf_pd [ vds ] -> partitionStartingLocation ; dbg ( "LSNBase:<S2SV_blank>%d\\n" , lsnBase ) ; position = ( lsnBase + phd -> unallocSpaceBitmap . extPosition ) * sectorsize ; chunk = position / chunksize ; offset = position % chunksize ; map_chunk ( fd , dev , chunk , st_size , __FILE__ , __LINE__ ) ; struct spaceBitmapDesc * sbd = ( struct spaceBitmapDesc * ) ( dev [ chunk ] + offset ) ; if ( sbd -> descTag . tagIdent != TAG_IDENT_SBD ) { err ( "SBD<S2SV_blank>not<S2SV_blank>found\\n" ) ; return - 1 ; } if ( ! checksum ( sbd -> descTag ) ) { err ( "SBD<S2SV_blank>checksum<S2SV_blank>error.<S2SV_blank>Continue<S2SV_blank>with<S2SV_blank>caution.\\n" ) ; seq -> pd . error |= E_CHECKSUM ; } if ( crc ( sbd , sbd -> descTag . descCRCLength + sizeof ( tag ) ) ) { err ( "SBD<S2SV_blank>CRC<S2SV_blank>error.<S2SV_blank>Continue<S2SV_blank>with<S2SV_blank>caution.\\n" ) ; seq -> pd . error |= E_CRC ; } dbg ( "SBD<S2SV_blank>is<S2SV_blank>ok\\n" ) ; dbg ( "[SBD]<S2SV_blank>NumOfBits:<S2SV_blank>%d\\n" , sbd -> numOfBits ) ; dbg ( "[SBD]<S2SV_blank>NumOfBytes:<S2SV_blank>%d\\n" , sbd -> numOfBytes ) ; <S2SV_StartBug> dbg ( "Bitmap:<S2SV_blank>%d,<S2SV_blank>%p\\n" , ( lsnBase + phd -> unallocSpaceBitmap . extPosition ) , sbd -> bitmap ) ; <S2SV_EndBug> stats -> actPartitionBitmap = calloc ( sbd -> numOfBytes , 1 ) ; memset ( stats -> actPartitionBitmap , 0xff , sbd -> numOfBytes ) ; stats -> partitionNumOfBytes = sbd -> numOfBytes ; stats -> partitionNumOfBits = sbd -> numOfBits ; dbg ( "Crete<S2SV_blank>array<S2SV_blank>done\\n" ) ; uint8_t * ptr = NULL ; dbg ( "Chunk:<S2SV_blank>%d\\n" , chunk ) ; map_raw ( fd , & ptr , ( uint64_t ) ( chunk ) * CHUNK_SIZE , ( sbd -> numOfBytes + offset ) , st_size ) ; <S2SV_StartBug> dbg ( "Ptr:<S2SV_blank>%p\\n" , ptr ) ; <S2SV_EndBug> sbd = ( struct spaceBitmapDesc * ) ( ptr + offset ) ; dbg ( "Get<S2SV_blank>bitmap<S2SV_blank>statistics\\n" ) ; uint32_t usedBlocks = 0 ; uint32_t unusedBlocks = 0 ; uint8_t count = 0 ; uint8_t v = 0 ; for ( int i = 0 ; i < sbd -> numOfBytes - 1 ; i ++ ) { v = sbd -> bitmap [ i ] ; count = BitsSetTable256 [ v & 0xff ] + BitsSetTable256 [ ( v >> 8 ) & 0xff ] + BitsSetTable256 [ ( v >> 16 ) & 0xff ] + BitsSetTable256 [ v >> 24 ] ; usedBlocks += 8 - count ; unusedBlocks += count ; } dbg ( "Unused<S2SV_blank>blocks:<S2SV_blank>%d\\n" , unusedBlocks ) ; dbg ( "Used<S2SV_blank>Blocks:<S2SV_blank>%d\\n" , usedBlocks ) ; uint8_t bitCorrection = sbd -> numOfBytes * 8 - sbd -> numOfBits ; dbg ( "BitCorrection:<S2SV_blank>%d\\n" , bitCorrection ) ; v = sbd -> bitmap [ sbd -> numOfBytes - 1 ] ; dbg ( "Bitmap<S2SV_blank>last:<S2SV_blank>0x%02x\\n" , v ) ; for ( int i = 0 ; i < 8 - bitCorrection ; i ++ ) { dbg ( "Mask:<S2SV_blank>0x%02x,<S2SV_blank>Result:<S2SV_blank>0x%02x\\n" , ( 1 << i ) , v & ( 1 << i ) ) ; if ( v & ( 1 << i ) ) unusedBlocks ++ ; else usedBlocks ++ ; } stats -> expUsedBlocks = usedBlocks ; stats -> expUnusedBlocks = unusedBlocks ; stats -> expPartitionBitmap = sbd -> bitmap ; dbg ( "Unused<S2SV_blank>blocks:<S2SV_blank>%d\\n" , unusedBlocks ) ; dbg ( "Used<S2SV_blank>Blocks:<S2SV_blank>%d\\n" , usedBlocks ) ; sbd = ( struct spaceBitmapDesc * ) ( dev [ chunk ] + offset ) ; unmap_raw ( & ptr , ( uint64_t ) ( chunk ) * CHUNK_SIZE , sbd -> numOfBytes ) ; unmap_chunk ( dev , chunk , st_size ) ; } increment_used_space ( stats , phd -> unallocSpaceTable . extLength , phd -> unallocSpaceTable . extPosition ) ; increment_used_space ( stats , phd -> unallocSpaceBitmap . extLength , phd -> unallocSpaceBitmap . extPosition ) ; increment_used_space ( stats , phd -> freedSpaceTable . extLength , phd -> freedSpaceTable . extPosition ) ; increment_used_space ( stats , phd -> freedSpaceBitmap . extLength , phd -> freedSpaceBitmap . extPosition ) ; return 0 ; } | <S2SV_ModStart> numOfBytes ) ; # ifdef MEMTRACE <S2SV_ModStart> bitmap ) ; # else dbg ( "Bitmap:<S2SV_blank>%d\\n" , ( lsnBase + phd -> unallocSpaceBitmap . extPosition ) ) ; # endif <S2SV_ModStart> st_size ) ; # ifdef MEMTRACE <S2SV_ModStart> ptr ) ; # endif |
2,408 | CWE-000 void cpu_run ( struct cpu * cpu ) { int running = 1 ; while ( running ) { <S2SV_StartBug> unsigned char IR = cpu_ram_read ( cpu , cpu -> pc ) ; <S2SV_EndBug> <S2SV_StartBug> unsigned char operandA = cpu_ram_read ( cpu , cpu -> pc + 1 ) ; <S2SV_EndBug> <S2SV_StartBug> unsigned char operandB = cpu_ram_read ( cpu , cpu -> pc + 2 ) ; <S2SV_EndBug> int instruction_set_pc = ( IR >> 4 ) & 1 ; switch ( IR ) { case LDI : cpu -> reg [ operandA ] = operandB ; break ; case PRN : printf ( "%d\\n" , cpu -> reg [ operandA ] ) ; break ; case HLT : running = 0 ; break ; default : <S2SV_StartBug> fprintf ( strderr , "ERROR:<S2SV_blank>Unknown<S2SV_blank>Instruction\\n<S2SV_blank>from<S2SV_blank>cpu_run()<S2SV_blank>in<S2SV_blank>cpu.c\\n<S2SV_blank>PC:<S2SV_blank>%02x\\n<S2SV_blank>IR:<S2SV_blank>%02X\\n" , cpu -> PC , IR ) ; <S2SV_EndBug> exit ( 3 ) ; } if ( ! instruction_set_pc ) { cpu -> PC += ( ( IR >> 6 ) & 0x3 ) + 1 ; } } } | <S2SV_ModStart> , cpu -> PC <S2SV_ModEnd> ) ; unsigned <S2SV_ModStart> , cpu -> PC <S2SV_ModEnd> + 1 ) <S2SV_ModStart> , cpu -> PC <S2SV_ModEnd> + 2 ) <S2SV_ModStart> : fprintf ( stderr <S2SV_ModEnd> , "ERROR:<S2SV_blank>Unknown<S2SV_blank>Instruction\\n<S2SV_blank>from<S2SV_blank>cpu_run()<S2SV_blank>in<S2SV_blank>cpu.c\\n<S2SV_blank>PC:<S2SV_blank>%02x\\n<S2SV_blank>IR:<S2SV_blank>%02X\\n" , |
2,409 | CWE-000 unsigned char * siridb_points_raw_string ( siridb_points_t * points , uint_fast32_t start , uint_fast32_t end , uint16_t * cinfo , size_t * size ) { size_t ts_sz = * size ; * size = 0 ; uint_fast32_t n = end - start ; size_t * sizes = ( size_t * ) malloc ( sizeof ( size_t ) * n ) ; if ( sizes == NULL ) { return NULL ; } size_t * psz = sizes ; unsigned char * pdata ; for ( uint_fast32_t i = start ; i < end ; ++ i , ++ psz ) { * psz = strlen ( points -> data [ i ] . val . str ) + 1 ; * size += * psz ; } if ( POINTS_set_cinfo_size ( cinfo , size ) ) { free ( sizes ) ; return NULL ; } * size += n * ts_sz ; <S2SV_StartBug> unsigned char * cdata = ( unsigned char * ) malloc ( * size ) ; <S2SV_EndBug> if ( cdata == NULL ) { free ( sizes ) ; return NULL ; } pdata = cdata ; psz = sizes ; switch ( ts_sz ) { case sizeof ( uint32_t ) : for ( uint_fast32_t i = start ; i < end ; ++ i ) { uint32_t ts = points -> data [ i ] . ts ; memcpy ( pdata , & ts , sizeof ( uint32_t ) ) ; pdata += sizeof ( uint32_t ) ; } break ; case sizeof ( uint64_t ) : for ( uint_fast32_t i = start ; i < end ; ++ i ) { memcpy ( pdata , & points -> data [ i ] . ts , sizeof ( uint64_t ) ) ; pdata += sizeof ( uint64_t ) ; } break ; default : assert ( 0 ) ; } for ( uint_fast32_t i = start ; i < end ; ++ i , ++ psz ) { memcpy ( pdata , points -> data [ i ] . val . str , * psz ) ; pdata += * psz ; } free ( sizes ) ; return cdata ; } | <S2SV_ModStart> char * ) calloc ( * size , sizeof ( unsigned char ) <S2SV_ModEnd> ) ; if |
2,410 | CWE-000 static int try_to_wake_up ( struct task_struct * p , unsigned int state , int wake_flags ) { unsigned long flags ; int cpu , success = 0 ; unsigned long src_cpu ; int notify = 0 ; struct migration_notify_data mnd ; int heavy_task = 0 ; # ifdef CONFIG_SMP unsigned int old_load ; struct rq * rq ; u64 wallclock ; struct related_thread_group * grp = NULL ; # endif smp_mb__before_spinlock ( ) ; raw_spin_lock_irqsave ( & p -> pi_lock , flags ) ; src_cpu = cpu = task_cpu ( p ) ; if ( ! ( p -> state & state ) ) goto out ; success = 1 ; if ( p -> on_rq && ttwu_remote ( p , wake_flags ) ) goto stat ; # ifdef CONFIG_SMP smp_rmb ( ) ; <S2SV_StartBug> while ( p -> on_cpu ) <S2SV_EndBug> cpu_read_relax ( ) ; smp_rmb ( ) ; rq = cpu_rq ( task_cpu ( p ) ) ; raw_spin_lock ( & rq -> lock ) ; old_load = task_load ( p ) ; grp = task_related_thread_group ( p ) ; wallclock = sched_ktime_clock ( ) ; update_task_ravg ( rq -> curr , rq , TASK_UPDATE , wallclock , 0 ) ; heavy_task = heavy_task_wakeup ( p , rq , TASK_WAKE ) ; update_task_ravg ( p , rq , TASK_WAKE , wallclock , 0 ) ; raw_spin_unlock ( & rq -> lock ) ; if ( update_preferred_cluster ( grp , p , old_load ) ) set_preferred_cluster ( grp ) ; p -> sched_contributes_to_load = ! ! task_contributes_to_load ( p ) ; p -> state = TASK_WAKING ; if ( p -> sched_class -> task_waking ) p -> sched_class -> task_waking ( p ) ; cpu = select_task_rq ( p , SD_BALANCE_WAKE , wake_flags ) ; src_cpu = task_cpu ( p ) ; if ( src_cpu != cpu ) { wake_flags |= WF_MIGRATED ; set_task_cpu ( p , cpu ) ; } else { note_run_start ( p , wallclock ) ; } # endif ttwu_queue ( p , cpu ) ; stat : ttwu_stat ( p , cpu , wake_flags ) ; if ( task_notify_on_migrate ( p ) ) { mnd . src_cpu = src_cpu ; mnd . dest_cpu = cpu ; mnd . load = pct_task_load ( p ) ; if ( ( src_cpu != cpu ) || ( mnd . load > sysctl_sched_wakeup_load_threshold ) ) notify = 1 ; } out : raw_spin_unlock_irqrestore ( & p -> pi_lock , flags ) ; if ( notify ) atomic_notifier_call_chain ( & migration_notifier_head , 0 , ( void * ) & mnd ) ; if ( ! same_cluster ( src_cpu , cpu ) ) { check_for_freq_change ( cpu_rq ( cpu ) ) ; check_for_freq_change ( cpu_rq ( src_cpu ) ) ; } else if ( heavy_task ) check_for_freq_change ( cpu_rq ( cpu ) ) ; return success ; } | <S2SV_ModStart> ( ) ; smp_rmb ( ) ; |
2,411 | CWE-000 static BOOL compile_load_variable ( unsigned int node , sCompileInfo * info ) { sVar * var = get_variable_from_table ( info -> lv_table , gNodes [ node ] . uValue . mVarName ) ; if ( var == NULL ) { parser_err_msg ( info -> pinfo , "undeclared<S2SV_blank>variable<S2SV_blank>%s" , gNodes [ node ] . uValue . mVarName ) ; info -> err_num ++ ; info -> type = create_node_type_with_class_name ( "int" ) ; return TRUE ; } gNodes [ node ] . mType = var -> mType ; int var_index = get_variable_index ( info -> lv_table , gNodes [ node ] . uValue . mVarName ) ; MASSERT ( var_index != - 1 ) ; append_opecode_to_code ( info -> code , OP_LOAD , info -> no_output ) ; append_int_value_to_code ( info -> code , var_index , info -> no_output ) ; info -> stack_num ++ ; sNodeType * result_type = var -> mType ; <S2SV_StartBug> if ( result_type == NULL ) { <S2SV_EndBug> parser_err_msg ( info -> pinfo , "null<S2SV_blank>type<S2SV_blank>%s" , gNodes [ node ] . uValue . mVarName ) ; info -> err_num ++ ; info -> type = create_node_type_with_class_name ( "int" ) ; return TRUE ; } sNodeType * result_type2 ; solve_generics_for_variable ( result_type , & result_type2 , info -> pinfo -> klass ) ; info -> type = result_type2 ; return TRUE ; } | <S2SV_ModStart> result_type == NULL || result_type -> mClass == NULL |
2,412 | CWE-000 <S2SV_StartBug> static int sccp_wrapper_asterisk16_answer ( PBX_CHANNEL_TYPE * chan ) <S2SV_EndBug> { int res = - 1 ; <S2SV_StartBug> AUTO_RELEASE ( sccp_channel_t , channel , get_sccp_channel_from_pbx_channel ( chan ) ) ; <S2SV_EndBug> <S2SV_StartBug> if ( channel ) { <S2SV_EndBug> res = sccp_pbx_answered ( channel ) ; } return res ; } | <S2SV_ModStart> ( PBX_CHANNEL_TYPE * pbxchan <S2SV_ModEnd> ) { int <S2SV_ModStart> ( sccp_channel_t , c <S2SV_ModEnd> , get_sccp_channel_from_pbx_channel ( <S2SV_ModStart> , get_sccp_channel_from_pbx_channel ( pbxchan <S2SV_ModEnd> ) ) ; <S2SV_ModStart> ; if ( c ) { if ( pbx_channel_state ( pbxchan ) != AST_STATE_UP && c -> state < SCCP_GROUPED_CHANNELSTATE_CONNECTION ) { pbx_indicate ( pbxchan , AST_CONTROL_PROGRESS ) ; } res = sccp_pbx_answer ( c <S2SV_ModEnd> ) ; } |
2,413 | CWE-000 int main ( void ) { initIO ( ) ; CAN_init ( CAN_ENABLED ) ; CAN_wait_on_receive ( BRAKE_LIGHT_MBOX , CAN_ID_BRAKE_LIGHT , CAN_LEN_BRAKE_LIGHT , CAN_IDM_single ) ; CAN_wait_on_receive ( BMS_MBOX , CAN_ID_BMS_MASTER , CAN_LEN_BMS_MASTER , CAN_IDM_single ) ; CAN_wait_on_receive ( AIR_MBOX , CAN_ID_AIR_CONTROL , CAN_LEN_AIR_CONTROL , CAN_IDM_single ) ; CAN_wait_on_receive ( AIR_MBOX , CAN_ID_AIR_CONTROL , CAN_LEN_AIR_CONTROL , CAN_IDM_single ) ; CAN_wait_on_receive ( DLEFT_MBOX , CAN_ID_THROTTLE , CAN_LEN_THROTTLE , CAN_IDM_single ) ; initTimer ( ) ; gFlag |= _BV ( UPDATE_STATUS ) ; while ( 1 ) { if ( bit_is_set ( gFlag , UPDATE_STATUS ) ) { PORT_EXT_LED_ORANGE ^= _BV ( EXT_LED_ORANGE ) ; PORT_LED1 ^= _BV ( LED1_PIN ) ; updateStateFromFlags ( ) ; checkShutdownState ( ) ; <S2SV_StartBug> << << << < HEAD <S2SV_EndBug> OCR1B = charge ; <S2SV_StartBug> == == == = <S2SV_EndBug> >> >> >> > dfc8a7ce0d46ffcc49fc3997a15d70ebcc71d5ee if ( bit_is_set ( gFlag , BRAKE_PRESSED ) && bit_is_set ( gFlag , TSMS_CLOSED ) ) { CAN_transmit ( 0 , CAN_ID_DASHBOARD , CAN_LEN_DASHBOARD , gCAN_MSG ) ; } if ( bit_is_set ( gFlag , TSMS_CLOSED ) ) { PORT_EXT_LED_GREEN ^= _BV ( EXT_LED_GREEN ) ; } gFlag &= ~ _BV ( UPDATE_STATUS ) ; } } } | <S2SV_ModStart> ( ) ; <S2SV_ModEnd> OCR1B = charge <S2SV_ModStart> = charge ; <S2SV_ModEnd> if ( bit_is_set |
2,414 | CWE-000 rBuffer * r_newbuffer_wrap ( lua_State * L , char * data , size_t len ) { rBufferLite * buflite = ( rBufferLite * ) lua_newuserdata ( L , sizeof ( rBufferLite ) ) ; rBuffer * buf = ( rBuffer * ) buflite ; <S2SV_StartBug> buflite -> initb = data ; <S2SV_EndBug> buf -> data = data ; buf -> n = len ; buf -> capacity = len ; if ( luaL_newmetatable ( L , ROSIE_BUFFER ) ) rbuf_type_init ( L ) ; lua_setmetatable ( L , - 2 ) ; return buf ; } | <S2SV_ModStart> ) buflite ; buf <S2SV_ModEnd> -> initb = |
2,415 | CWE-000 static void __gvt_cache_remove_entry ( struct intel_vgpu * vgpu , struct gvt_dma * entry ) { rb_erase ( & entry -> gfn_node , & vgpu -> vdev . gfn_cache ) ; rb_erase ( & entry -> dma_addr_node , & vgpu -> vdev . dma_addr_cache ) ; kfree ( entry ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> entry ) ; vgpu -> vdev . nr_cache_entries -- ; |
2,416 | CWE-000 int main ( ) { char output [ 300 ] = { '\\0' } ; <S2SV_StartBug> convertExpression ( "result=(d1+d2)*d3>>4" , output , OP_TABLE , TABLE_LENGTH ) ; <S2SV_EndBug> printf ( "%s" , output ) ; return 0 ; } | <S2SV_ModStart> ; convertExpression ( "end=40/start=2*(3+4)" <S2SV_ModEnd> , output , |
2,417 | CWE-000 UsefulBufC UsefulBuf_CopyOffset ( UsefulBuf Dest , size_t uOffset , const UsefulBufC Src ) { <S2SV_StartBug> if ( Src . len > Dest . len - uOffset ) { <S2SV_EndBug> return NULLUsefulBufC ; } memcpy ( Dest . ptr + uOffset , Src . ptr , Src . len ) ; <S2SV_StartBug> return ( ( UsefulBufC ) { Dest . ptr , Src . len } ) ; <S2SV_EndBug> } | <S2SV_ModStart> { if ( uOffset > Dest . len || <S2SV_ModStart> Src . len + uOffset |
2,418 | CWE-000 static int error_directory ( char * path , t_opt * opt ) { DIR * dr ; errno = 0 ; dr = opendir ( path ) ; if ( errno != 0 && opt -> up_r == 1 ) { if ( path [ ft_strlen ( path ) - 1 ] == '/' ) path [ ft_strlen ( path ) - 1 ] = '\\0' ; if ( opt -> dpcount == 1 && opt -> tricks == 1 ) ft_printf ( "\\n" ) ; <S2SV_StartBug> ft_printf ( "%s:\\n" , path ) ; <S2SV_EndBug> perror ( ft_strjoin ( "ft_ls:<S2SV_blank>" , & ( ft_strrchr ( path , '/' ) ) [ 1 ] ) ) ; errno = 0 ; if ( dr ) closedir ( dr ) ; return ( - 1 ) ; } if ( dr ) closedir ( dr ) ; return ( 0 ) ; } | <S2SV_ModStart> ; ft_printf ( "%s:" <S2SV_ModEnd> , path ) |
2,419 | CWE-000 static unsigned oacc_loop_auto_partitions ( oacc_loop * loop , unsigned outer_mask , bool outer_assign ) { bool assign = ( loop -> flags & OLF_AUTO ) && ( loop -> flags & OLF_INDEPENDENT ) ; bool noisy = true ; bool tiling = loop -> flags & OLF_TILE ; # ifdef ACCEL_COMPILER noisy = false ; # endif if ( assign && ( ! outer_assign || loop -> inner ) ) { unsigned this_mask = GOMP_DIM_MASK ( GOMP_DIM_GANG ) ; if ( ( loop -> flags & OLF_REDUCTION ) && oacc_get_fn_attrib ( current_function_decl ) && ! lookup_attribute ( "omp<S2SV_blank>target<S2SV_blank>entrypoint" , DECL_ATTRIBUTES ( current_function_decl ) ) ) this_mask = GOMP_DIM_MASK ( GOMP_DIM_WORKER ) ; while ( this_mask <= outer_mask ) this_mask <<= 1 ; if ( tiling && ! ( loop -> mask | loop -> e_mask ) ) this_mask |= this_mask << 1 ; this_mask &= GOMP_DIM_MASK ( GOMP_DIM_MAX - 1 ) - 1 ; this_mask &= ~ loop -> inner ; if ( tiling && ! loop -> e_mask ) { loop -> e_mask = this_mask & ( this_mask << 1 ) ; this_mask ^= loop -> e_mask ; } <S2SV_StartBug> loop -> mask |= this_mask ; <S2SV_EndBug> } if ( loop -> child ) { unsigned tmp_mask = outer_mask | loop -> mask | loop -> e_mask ; loop -> inner = oacc_loop_auto_partitions ( loop -> child , tmp_mask , outer_assign | assign ) ; } if ( assign && ( ! loop -> mask || ( tiling && ! loop -> e_mask ) || ! outer_assign ) ) { unsigned this_mask = 0 ; this_mask = loop -> inner | GOMP_DIM_MASK ( GOMP_DIM_MAX ) ; this_mask = least_bit_hwi ( this_mask ) ; this_mask >>= 1 ; this_mask &= ~ outer_mask ; if ( tiling ) { this_mask &= ~ ( loop -> e_mask | loop -> mask ) ; unsigned tile_mask = ( ( this_mask >> 1 ) & ~ ( outer_mask | loop -> e_mask | loop -> mask ) ) ; if ( tile_mask || loop -> mask ) { loop -> e_mask |= this_mask ; this_mask = tile_mask ; } if ( ! loop -> e_mask && noisy ) warning_at ( loop -> loc , 0 , "insufficient<S2SV_blank>partitioning<S2SV_blank>available" "<S2SV_blank>to<S2SV_blank>parallelize<S2SV_blank>element<S2SV_blank>loop" ) ; <S2SV_StartBug> } <S2SV_EndBug> loop -> mask |= this_mask ; if ( ! loop -> mask && noisy ) warning_at ( loop -> loc , 0 , tiling ? G_ ( "insufficient<S2SV_blank>partitioning<S2SV_blank>available" "<S2SV_blank>to<S2SV_blank>parallelize<S2SV_blank>tile<S2SV_blank>loop" ) : G_ ( "insufficient<S2SV_blank>partitioning<S2SV_blank>available" "<S2SV_blank>to<S2SV_blank>parallelize<S2SV_blank>loop" ) ) ; } if ( assign && dump_file ) fprintf ( dump_file , "Auto<S2SV_blank>loop<S2SV_blank>%s:%d<S2SV_blank>assigned<S2SV_blank>%d<S2SV_blank>&<S2SV_blank>%d\\n" , LOCATION_FILE ( loop -> loc ) , LOCATION_LINE ( loop -> loc ) , loop -> mask , loop -> e_mask ) ; unsigned inner_mask = 0 ; if ( loop -> sibling ) inner_mask |= oacc_loop_auto_partitions ( loop -> sibling , outer_mask , outer_assign ) ; inner_mask |= loop -> inner | loop -> mask | loop -> e_mask ; return inner_mask ; } | <S2SV_ModStart> e_mask ; } this_mask = targetm . goacc . adjust_parallelism ( this_mask , outer_mask ) ; <S2SV_ModStart> ) ; } loop -> mask = targetm . goacc . adjust_parallelism ( loop -> mask , outer_mask ) ; |
2,420 | CWE-000 static int check_collision ( t_vector pt , t_wolf * w ) { t_coord map ; int i = - 1 ; while ( ++ i < 360 ) { map . x = ( int ) ( ( pt . x + w -> cos_table [ i ] * PLAYER_RADIUS ) / BLOC_SIZE ) ; map . y = ( int ) ( ( pt . y + w -> sin_table [ i ] * PLAYER_RADIUS ) / BLOC_SIZE ) ; <S2SV_StartBug> if ( map . x > w -> map_size . x || map . y > w -> map_size . y ) <S2SV_EndBug> return ( 1 ) ; if ( map . x < 0 || map . y < 0 ) return ( 1 ) ; if ( w -> map [ map . y ] [ map . x ] > '0' && w -> map [ map . y ] [ map . x ] < ( '0' + T_DOOR ) ) return ( 1 ) ; } return ( 0 ) ; } | <S2SV_ModStart> map . x >= <S2SV_ModEnd> w -> map_size <S2SV_ModStart> map . y >= <S2SV_ModEnd> w -> map_size |
2,421 | CWE-000 int main ( ) { <S2SV_StartBug> classifier_B classifier = classifier_new ( 10 , 10 ) ; <S2SV_EndBug> <S2SV_StartBug> classifier_print ( classifier ) ; <S2SV_EndBug> } | <S2SV_ModStart> = classifier_new ( 8 * 28 * 28 <S2SV_ModEnd> , 10 ) <S2SV_ModStart> 10 ) ; for ( int i = 0 ; i < 1000 ; i ++ ) { bitstring_B string = bitstring_random ( 8 * 28 * 28 ) ; classifier_input ( classifier , string ) ; printf ( "Loop[%d]\\n" , i ) ; } classifier_printoutput <S2SV_ModEnd> ( classifier ) |
2,422 | CWE-000 static int _parse_term ( char * s , term * a , var_list * vars ) { s = trim ( s ) ; int low_limit = index_of ( s , '(' ) ; if ( low_limit < 1 ) { if ( s [ 0 ] >= 'A' && s [ 0 ] <= 'Z' ) { a -> type = variable ; } else { <S2SV_StartBug> a -> type = ( s [ 0 ] >= '0' && s [ 0 ] <= '9' ) ? const_num : const_atom ; <S2SV_EndBug> } int len = strlen ( s ) ; a -> value = calloc ( 1 , len + 1 ) ; memcpy ( a -> value , s , len ) ; ( ( char * ) a -> value ) [ len ] = 0 ; if ( a -> type == variable ) var_list_init ( vars , a -> value ) ; return 1 ; } if ( s [ 0 ] >= 'A' && s [ 0 ] <= 'Z' ) return 0 ; a -> type = func_type ; a -> value = calloc ( 1 , sizeof ( functor ) ) ; return parse_functor ( s , ( functor * ) a -> value , vars ) ; } | <S2SV_ModStart> -> type = constant <S2SV_ModEnd> ; } int |
2,423 | CWE-000 static int uid_stat_show ( struct seq_file * m , void * v ) { struct uid_entry * uid_entry ; struct task_struct * task ; cputime_t utime ; cputime_t stime ; unsigned long bkt ; mutex_lock ( & uid_lock ) ; hash_for_each ( hash_table , bkt , uid_entry , hash ) { uid_entry -> active_stime = 0 ; uid_entry -> active_utime = 0 ; <S2SV_StartBug> } <S2SV_EndBug> read_lock ( & tasklist_lock ) ; for_each_process ( task ) { uid_entry = find_or_register_uid ( from_kuid_munged ( current_user_ns ( ) , task_uid ( task ) ) ) ; if ( ! uid_entry ) { read_unlock ( & tasklist_lock ) ; mutex_unlock ( & uid_lock ) ; pr_err ( "%s:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>find<S2SV_blank>the<S2SV_blank>uid_entry<S2SV_blank>for<S2SV_blank>uid<S2SV_blank>%d\\n" , __func__ , from_kuid_munged ( current_user_ns ( ) , task_uid ( task ) ) ) ; return - ENOMEM ; } task_cputime_adjusted ( task , & utime , & stime ) ; uid_entry -> active_utime += utime ; uid_entry -> active_stime += stime ; <S2SV_StartBug> } <S2SV_EndBug> read_unlock ( & tasklist_lock ) ; hash_for_each ( hash_table , bkt , uid_entry , hash ) { cputime_t total_utime = uid_entry -> utime + uid_entry -> active_utime ; cputime_t total_stime = uid_entry -> stime + uid_entry -> active_stime ; <S2SV_StartBug> seq_printf ( m , "%d:<S2SV_blank>%u<S2SV_blank>%u\\n" , uid_entry -> uid , <S2SV_EndBug> cputime_to_usecs ( total_utime ) , <S2SV_StartBug> cputime_to_usecs ( total_stime ) ) ; <S2SV_EndBug> } mutex_unlock ( & uid_lock ) ; return 0 ; } | <S2SV_ModStart> = 0 ; uid_entry -> active_power = 0 ; <S2SV_ModStart> += stime ; uid_entry -> active_power += task -> cpu_power ; <S2SV_ModStart> -> active_stime ; unsigned long long total_power = uid_entry -> power + uid_entry -> active_power ; <S2SV_ModStart> ( m , "%d:<S2SV_blank>%u<S2SV_blank>%u<S2SV_blank>%llu\\n" <S2SV_ModEnd> , uid_entry -> <S2SV_ModStart> ( total_stime ) , total_power |
2,424 | CWE-000 int drm_helper_probe_single_connector_modes ( struct drm_connector * connector , uint32_t maxX , uint32_t maxY ) { struct drm_device * dev = connector -> dev ; struct drm_display_mode * mode ; const struct drm_connector_helper_funcs * connector_funcs = connector -> helper_private ; int count = 0 , ret ; int mode_flags = 0 ; bool verbose_prune = true ; enum drm_connector_status old_status ; struct drm_modeset_acquire_ctx ctx ; WARN_ON ( ! mutex_is_locked ( & dev -> mode_config . mutex ) ) ; drm_modeset_acquire_init ( & ctx , 0 ) ; DRM_DEBUG_KMS ( "[CONNECTOR:%d:%s]\\n" , connector -> base . id , connector -> name ) ; retry : ret = drm_modeset_lock ( & dev -> mode_config . connection_mutex , & ctx ) ; if ( ret == - EDEADLK ) { drm_modeset_backoff ( & ctx ) ; goto retry ; } else WARN_ON ( ret < 0 ) ; list_for_each_entry ( mode , & connector -> modes , head ) mode -> status = MODE_STALE ; old_status = connector -> status ; if ( connector -> force ) { if ( connector -> force == DRM_FORCE_ON || connector -> force == DRM_FORCE_ON_DIGITAL ) connector -> status = connector_status_connected ; else connector -> status = connector_status_disconnected ; if ( connector -> funcs -> force ) connector -> funcs -> force ( connector ) ; } else { ret = drm_helper_probe_detect ( connector , & ctx , true ) ; if ( ret == - EDEADLK ) { drm_modeset_backoff ( & ctx ) ; goto retry ; } else if ( WARN ( ret < 0 , "Invalid<S2SV_blank>return<S2SV_blank>value<S2SV_blank>%i<S2SV_blank>for<S2SV_blank>connector<S2SV_blank>detection\\n" , ret ) ) ret = connector_status_unknown ; connector -> status = ret ; } if ( old_status != connector -> status ) { DRM_DEBUG_KMS ( "[CONNECTOR:%d:%s]<S2SV_blank>status<S2SV_blank>updated<S2SV_blank>from<S2SV_blank>%s<S2SV_blank>to<S2SV_blank>%s\\n" , connector -> base . id , connector -> name , drm_get_connector_status_name ( old_status ) , drm_get_connector_status_name ( connector -> status ) ) ; dev -> mode_config . delayed_event = true ; if ( dev -> mode_config . poll_enabled ) schedule_delayed_work ( & dev -> mode_config . output_poll_work , 0 ) ; } if ( drm_kms_helper_poll != dev -> mode_config . poll_running ) drm_kms_helper_poll_enable ( dev ) ; dev -> mode_config . poll_running = drm_kms_helper_poll ; if ( connector -> status == connector_status_disconnected ) { DRM_DEBUG_KMS ( "[CONNECTOR:%d:%s]<S2SV_blank>disconnected\\n" , connector -> base . id , connector -> name ) ; drm_connector_update_edid_property ( connector , NULL ) ; verbose_prune = false ; goto prune ; } count = ( * connector_funcs -> get_modes ) ( connector ) ; if ( count == 0 && connector -> status == connector_status_connected ) count = drm_add_modes_noedid ( connector , 1024 , 768 ) ; count += drm_helper_probe_add_cmdline_mode ( connector ) ; if ( count == 0 ) goto prune ; <S2SV_StartBug> drm_mode_connector_list_update ( connector ) ; <S2SV_EndBug> if ( connector -> interlace_allowed ) mode_flags |= DRM_MODE_FLAG_INTERLACE ; if ( connector -> doublescan_allowed ) mode_flags |= DRM_MODE_FLAG_DBLSCAN ; if ( connector -> stereo_allowed ) mode_flags |= DRM_MODE_FLAG_3D_MASK ; list_for_each_entry ( mode , & connector -> modes , head ) { if ( mode -> status == MODE_OK ) mode -> status = drm_mode_validate_driver ( dev , mode ) ; if ( mode -> status == MODE_OK ) mode -> status = drm_mode_validate_size ( mode , maxX , maxY ) ; if ( mode -> status == MODE_OK ) mode -> status = drm_mode_validate_flag ( mode , mode_flags ) ; if ( mode -> status == MODE_OK ) mode -> status = drm_mode_validate_pipeline ( mode , connector ) ; if ( mode -> status == MODE_OK ) mode -> status = drm_mode_validate_ycbcr420 ( mode , connector ) ; } prune : drm_mode_prune_invalid ( dev , & connector -> modes , verbose_prune ) ; drm_modeset_drop_locks ( & ctx ) ; drm_modeset_acquire_fini ( & ctx ) ; if ( list_empty ( & connector -> modes ) ) return 0 ; list_for_each_entry ( mode , & connector -> modes , head ) mode -> vrefresh = drm_mode_vrefresh ( mode ) ; drm_mode_sort ( & connector -> modes ) ; DRM_DEBUG_KMS ( "[CONNECTOR:%d:%s]<S2SV_blank>probed<S2SV_blank>modes<S2SV_blank>:\\n" , connector -> base . id , connector -> name ) ; list_for_each_entry ( mode , & connector -> modes , head ) { drm_mode_set_crtcinfo ( mode , CRTC_INTERLACE_HALVE_V ) ; drm_mode_debug_printmodeline ( mode ) ; } return count ; } | <S2SV_ModStart> goto prune ; drm_connector_list_update <S2SV_ModEnd> ( connector ) |
2,425 | CWE-000 int nereon_get_config_options_t ( nereon_ctx_t * ctx , nereon_config_option_t * cfg_opts , int opts_count ) { <S2SV_StartBug> struct nereon_nos_option * nos_opts = ( struct nereon_nos_option * ) ctx -> nos_opts ; <S2SV_EndBug> struct nereon_noc_option * noc_opts = ( struct nereon_noc_option * ) ctx -> noc_opts ; int i ; for ( i = 0 ; i < opts_count ; i ++ ) { nereon_config_option_t * cfg_opt = & cfg_opts [ i ] ; <S2SV_StartBug> struct nereon_nos_option * nos_opt = NULL ; <S2SV_EndBug> struct nereon_noc_option * noc_opt = NULL ; union nereon_config_data * cfg_data = NULL ; if ( nos_opts ) { nos_opt = nereon_get_nos_by_name ( nos_opts , ctx -> nos_opts_count , cfg_opt -> name ) ; if ( ! nos_opt ) { nereon_set_err ( "Could<S2SV_blank>not<S2SV_blank>get<S2SV_blank>NOS<S2SV_blank>option<S2SV_blank>for<S2SV_blank>config<S2SV_blank>\'%s\'" , cfg_opt -> name ) ; DEBUG_PRINT ( "Could<S2SV_blank>not<S2SV_blank>get<S2SV_blank>NOS<S2SV_blank>option<S2SV_blank>for<S2SV_blank>config<S2SV_blank>\'%s\'\\n" , cfg_opt -> name ) ; return - 1 ; } if ( nos_opt -> is_cli_set ) { DEBUG_PRINT ( "NOS<S2SV_blank>option<S2SV_blank>was<S2SV_blank>set<S2SV_blank>for<S2SV_blank>config<S2SV_blank>\'%s\'\\n" , cfg_opt -> name ) ; if ( cfg_opt -> is_cli_set ) * cfg_opt -> is_cli_set = true ; cfg_data = & nos_opt -> data ; } else { if ( strlen ( nos_opt -> noc_key ) > 0 && ( noc_opt = nereon_get_noc_option ( noc_opts , nos_opt -> noc_key ) ) ) { cfg_data = & noc_opt -> data ; } else if ( nos_opt -> exist_default ) { DEBUG_PRINT ( "Setting<S2SV_blank>NOS<S2SV_blank>default<S2SV_blank>data<S2SV_blank>for<S2SV_blank>config<S2SV_blank>\'%s\'\\n" , cfg_opt -> name ) ; cfg_data = & nos_opt -> default_data ; } } } else { noc_opt = nereon_get_noc_option ( noc_opts , cfg_opt -> name ) ; if ( noc_opt ) cfg_data = & noc_opt -> data ; } if ( ! cfg_data && cfg_opt -> type != NEREON_TYPE_ARRAY ) { if ( cfg_opt -> mandatory ) { nereon_set_err ( "Could<S2SV_blank>not<S2SV_blank>get<S2SV_blank>configuration<S2SV_blank>for<S2SV_blank>\'%s\'" , cfg_opt -> name ) ; return - 1 ; } continue ; } switch ( cfg_opt -> type ) { case NEREON_TYPE_INT : * ( int * ) ( cfg_opt -> data ) = cfg_data -> i ; break ; case NEREON_TYPE_BOOL : case NEREON_TYPE_HELPER : * ( bool * ) ( cfg_opt -> data ) = cfg_data -> b ; break ; case NEREON_TYPE_STRING : case NEREON_TYPE_IPPORT : case NEREON_TYPE_CONFIG : * ( char * * ) ( cfg_opt -> data ) = cfg_data -> str ; break ; case NEREON_TYPE_ARRAY : <S2SV_StartBug> * ( ( nereon_config_object_t * ) cfg_opt -> data ) = ( void * ) noc_opt -> parent ; <S2SV_EndBug> break ; default : break ; } } return 0 ; } | <S2SV_ModStart> opts_count ) { nereon_nos_option_t <S2SV_ModEnd> * nos_opts = <S2SV_ModStart> nos_opts = ( nereon_nos_option_t <S2SV_ModEnd> * ) ctx <S2SV_ModStart> i ] ; nereon_nos_option_t <S2SV_ModEnd> * nos_opt = <S2SV_ModStart> * ( ( nereon_noc_option_t * <S2SV_ModEnd> * ) cfg_opt |
2,426 | CWE-000 tBTA_GATTC_FIND_SERVICE_CB bta_gattc_register_service_change_notify ( UINT16 conn_id , BD_ADDR remote_bda ) { tBTA_GATTC_SERV * p_srcb = NULL ; list_t * p_cache = NULL ; tBTA_GATTC_SERVICE * p_service = NULL ; tBTA_GATTC_CHARACTERISTIC * p_char = NULL ; tBTA_GATTC_DESCRIPTOR * p_desc = NULL ; tBTA_GATTC_FIND_SERVICE_CB result ; BOOLEAN gatt_cache_found = FALSE ; BOOLEAN gatt_service_found = FALSE ; BOOLEAN gatt_service_change_found = FALSE ; BOOLEAN gatt_ccc_found = FALSE ; tBT_UUID gatt_service_uuid = { LEN_UUID_16 , { UUID_SERVCLASS_GATT_SERVER } } ; tBT_UUID gatt_service_change_uuid = { LEN_UUID_16 , { GATT_UUID_GATT_SRV_CHGD } } ; <S2SV_StartBug> tBT_UUID gatt_ccc_uuid = { LEN_UUID_16 , { GATT_UUID_CHAR_CLIENT_CONFIG } } ; <S2SV_EndBug> p_srcb = bta_gattc_find_srcb ( remote_bda ) ; if ( ( p_srcb != NULL ) && ( p_srcb -> p_srvc_cache != NULL ) ) { p_cache = p_srcb -> p_srvc_cache ; gatt_cache_found = TRUE ; } else { result = SERVICE_CHANGE_CACHE_NOT_FOUND ; } if ( gatt_cache_found == TRUE ) { for ( list_node_t * sn = list_begin ( p_cache ) ; sn != list_end ( p_cache ) ; sn = list_next ( sn ) ) { p_service = list_node ( sn ) ; if ( bta_gattc_uuid_compare ( & gatt_service_uuid , & p_service -> uuid , TRUE ) ) { gatt_service_found = TRUE ; break ; } } } else { result = SERVICE_CHANGE_CACHE_NOT_FOUND ; } if ( gatt_service_found == TRUE ) { if ( p_service -> characteristics ) { for ( list_node_t * cn = list_begin ( p_service -> characteristics ) ; cn != list_end ( p_service -> characteristics ) ; cn = list_next ( cn ) ) { p_char = list_node ( cn ) ; if ( bta_gattc_uuid_compare ( & gatt_service_change_uuid , & p_char -> uuid , TRUE ) ) { gatt_service_change_found = TRUE ; break ; } } } } else if ( gatt_cache_found == TRUE ) { result = SERVICE_CHANGE_SERVICE_NOT_FOUND ; } if ( gatt_service_change_found == TRUE ) { if ( p_char -> descriptors ) { for ( list_node_t * dn = list_begin ( p_char -> descriptors ) ; dn != list_end ( p_char -> descriptors ) ; dn = list_next ( dn ) ) { p_desc = list_node ( dn ) ; if ( bta_gattc_uuid_compare ( & gatt_ccc_uuid , & p_desc -> uuid , TRUE ) ) { gatt_ccc_found = TRUE ; break ; } } } } else if ( gatt_service_found == TRUE ) { result = SERVICE_CHANGE_CHAR_NOT_FOUND ; } if ( gatt_ccc_found == TRUE ) { <S2SV_StartBug> tBTA_GATTC_CONN * p_conn = bta_gattc_conn_find_alloc ( remote_bda ) ; <S2SV_EndBug> if ( p_conn ) { p_conn -> svc_change_descr_handle = p_desc -> handle ; } result = SERVICE_CHANGE_CCC_WRITTEN_SUCCESS ; uint16_t indicate_value = GATT_CLT_CONFIG_INDICATION ; tBTA_GATT_UNFMT indicate_v ; indicate_v . len = 2 ; indicate_v . p_value = ( uint8_t * ) & indicate_value ; BTA_GATTC_WriteCharDescr ( conn_id , p_desc -> handle , BTA_GATTC_TYPE_WRITE , & indicate_v , BTA_GATT_AUTH_REQ_NONE ) ; } else if ( gatt_service_change_found == TRUE ) { result = SERVICE_CHANGE_CCC_NOT_FOUND ; } return result ; } | <S2SV_ModStart> } } ; tBTA_GATTC_CONN * p_conn = bta_gattc_conn_find_alloc ( remote_bda ) ; if ( p_conn && p_conn -> write_remote_svc_change_ccc_done ) { return SERVICE_CHANGE_CCC_WRITTEN_SUCCESS ; } <S2SV_ModStart> TRUE ) { if ( p_conn ) { p_conn -> svc_change_descr_handle = p_desc -> handle ; p_conn -> write_remote_svc_change_ccc_done = TRUE <S2SV_ModEnd> ; } result |
2,427 | CWE-000 int main ( int argc , char * * argv ) { int ret , tests = sizeof ( my_tests ) / sizeof ( MA_ODBC_TESTS ) - 1 ; <S2SV_StartBug> if ( Travis ) <S2SV_EndBug> { diag ( "Skipping<S2SV_blank>this<S2SV_blank>testsuite<S2SV_blank>in<S2SV_blank>Travis" ) ; return 0 ; } get_options ( argc , argv ) ; plan ( tests ) ; Dsn = MADB_DSN_Init ( ) ; Dsn -> FreeMe = FALSE ; ret = run_tests ( my_tests ) ; Dsn -> FreeMe = TRUE ; MADB_DSN_Free ( Dsn ) ; if ( CleanUp ( ) == FAIL ) { ret = 1 ; diag ( "Clean-up<S2SV_blank>after<S2SV_blank>tests<S2SV_blank>failed<S2SV_blank>-<S2SV_blank>%d<S2SV_blank>test<S2SV_blank>DSN\'s<S2SV_blank>stay<S2SV_blank>in<S2SV_blank>the<S2SV_blank>system:" , CreatedDsnCount ) ; } return ret ; } | <S2SV_ModStart> - 1 ; <S2SV_ModEnd> get_options ( argc |
2,428 | CWE-000 <S2SV_StartBug> size_t strlen ( char * str ) { <S2SV_EndBug> size_t i = 0 ; while ( str [ i ] ) i ++ ; return i ; } | <S2SV_ModStart> size_t strlen ( const |
2,429 | CWE-000 bool ce_buffer_insert_string ( CeBuffer_t * buffer , const char * string , CePoint_t point ) { if ( buffer -> status == CE_BUFFER_STATUS_READONLY ) return false ; if ( ! ce_buffer_point_is_valid ( buffer , point ) ) { if ( buffer -> line_count == 0 && ce_points_equal ( point , ( CePoint_t ) { 0 , 0 } ) ) { <S2SV_StartBug> int64_t string_len = strlen ( string ) ; <S2SV_EndBug> buffer -> lines = malloc ( sizeof ( * buffer -> lines ) ) ; buffer -> lines [ 0 ] = malloc ( string_len + 1 ) ; strcpy ( buffer -> lines [ 0 ] , string ) ; buffer -> lines [ 0 ] [ string_len ] = 0 ; <S2SV_StartBug> buffer -> line_count = 1 ; <S2SV_EndBug> return true ; } else { return false ; } } int64_t string_lines = ce_util_count_string_lines ( string ) ; if ( string_lines == 0 ) { return true ; } else if ( string_lines == 1 ) { pthread_mutex_lock ( & buffer -> lock ) ; char * line = buffer -> lines [ point . y ] ; size_t insert_len = strlen ( string ) ; size_t existing_len = strlen ( line ) ; size_t total_len = insert_len + existing_len ; line = realloc ( line , total_len + 1 ) ; if ( ! line ) { pthread_mutex_unlock ( & buffer -> lock ) ; return false ; } char * src = ce_utf8_find_index ( line , point . x ) ; char * dst = src + insert_len ; size_t src_len = strlen ( src ) ; memmove ( dst , src , src_len ) ; memcpy ( src , string , insert_len ) ; line [ total_len ] = 0 ; buffer -> lines [ point . y ] = line ; pthread_mutex_unlock ( & buffer -> lock ) ; buffer -> status = CE_BUFFER_STATUS_MODIFIED ; return true ; } int64_t shift_lines = string_lines - 1 ; int64_t old_line_count = buffer -> line_count ; if ( ! buffer_realloc_lines ( buffer , buffer -> line_count + shift_lines ) ) { return false ; } int64_t first_new_line = point . y + 1 ; char * * src_line = buffer -> lines + first_new_line ; char * * dst_line = src_line + shift_lines ; size_t move_count = old_line_count - first_new_line ; memmove ( dst_line , src_line , move_count * sizeof ( src_line ) ) ; char * end_string = NULL ; int64_t end_string_len = strlen ( buffer -> lines [ point . y ] + point . x ) ; if ( end_string_len ) end_string = strdup ( buffer -> lines [ point . y ] + point . x ) ; const char * next_newline = strchr ( string , CE_NEWLINE ) ; assert ( next_newline ) ; size_t first_line_len = next_newline - string ; size_t new_line_len = point . x + first_line_len ; buffer -> lines [ point . y ] = realloc ( buffer -> lines [ point . y ] , new_line_len + 1 ) ; if ( * string != CE_NEWLINE ) { memcpy ( buffer -> lines [ point . y ] + point . x , string , first_line_len ) ; } buffer -> lines [ point . y ] [ new_line_len ] = 0 ; string = next_newline + 1 ; next_newline = strchr ( string , CE_NEWLINE ) ; int64_t next_line = point . y + 1 ; while ( next_newline ) { new_line_len = next_newline - string ; buffer -> lines [ next_line ] = calloc ( 1 , new_line_len + 1 ) ; memcpy ( buffer -> lines [ next_line ] , string , new_line_len ) ; buffer -> lines [ next_line ] [ new_line_len ] = 0 ; string = next_newline + 1 ; next_newline = strchr ( string , CE_NEWLINE ) ; next_line ++ ; } new_line_len = strlen ( string ) ; int64_t last_line_len = new_line_len + end_string_len ; buffer -> lines [ next_line ] = calloc ( 1 , last_line_len + 1 ) ; memcpy ( buffer -> lines [ next_line ] , string , new_line_len ) ; if ( end_string ) { memcpy ( buffer -> lines [ next_line ] + new_line_len , end_string , end_string_len ) ; free ( end_string ) ; } buffer -> lines [ next_line ] [ last_line_len ] = 0 ; buffer -> status = CE_BUFFER_STATUS_MODIFIED ; return true ; } | <S2SV_ModStart> ) { int64_t line_count = ce_util_count_string_lines ( string ) ; buffer_realloc_lines ( buffer , line_count ) ; } else if ( point . y == buffer -> line_count && point . x == 0 ) { if ( ! buffer_realloc_lines ( buffer , <S2SV_ModEnd> buffer -> line_count <S2SV_ModStart> buffer -> line_count + 1 ) ) return false ; buffer -> lines [ point . y ] = calloc ( 1 , 1 ) <S2SV_ModEnd> ; } else |
2,430 | CWE-000 <S2SV_StartBug> void runFemtOS ( void ) <S2SV_EndBug> { while ( 1 ) { # ifdef EVENT_LOOP_TASKS EventManager ( ) ; # endif TaskManager ( ) ; } } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> inline |
2,431 | CWE-000 static int verify_header ( struct android_metadata_header * header ) { <S2SV_StartBug> int retval = - EINVAL ; <S2SV_EndBug> if ( is_userdebug ( ) && le32_to_cpu ( header -> magic_number ) == VERITY_METADATA_MAGIC_DISABLE ) return VERITY_STATE_DISABLE ; if ( ! ( le32_to_cpu ( header -> magic_number ) == VERITY_METADATA_MAGIC_NUMBER ) || ( le32_to_cpu ( header -> magic_number ) == VERITY_METADATA_MAGIC_DISABLE ) ) { DMERR ( "Incorrect<S2SV_blank>magic<S2SV_blank>number" ) ; return retval ; } if ( le32_to_cpu ( header -> protocol_version ) != VERITY_METADATA_VERSION ) { DMERR ( "Unsupported<S2SV_blank>version<S2SV_blank>%u" , le32_to_cpu ( header -> protocol_version ) ) ; return retval ; } return 0 ; } | <S2SV_ModStart> = - EINVAL ; return VERITY_STATE_DISABLE |
2,432 | CWE-000 static int raid1_reshape ( struct mddev * mddev ) { mempool_t * newpool , * oldpool ; struct pool_info * newpoolinfo ; struct raid1_info * newmirrors ; struct r1conf * conf = mddev -> private ; int cnt , raid_disks ; unsigned long flags ; int d , d2 , err ; if ( mddev -> chunk_sectors != mddev -> new_chunk_sectors || mddev -> layout != mddev -> new_layout || mddev -> level != mddev -> new_level ) { mddev -> new_chunk_sectors = mddev -> chunk_sectors ; mddev -> new_layout = mddev -> layout ; mddev -> new_level = mddev -> level ; return - EINVAL ; } err = md_allow_write ( mddev ) ; if ( err ) return err ; raid_disks = mddev -> raid_disks + mddev -> delta_disks ; if ( raid_disks < conf -> raid_disks ) { cnt = 0 ; for ( d = 0 ; d < conf -> raid_disks ; d ++ ) if ( conf -> mirrors [ d ] . rdev ) cnt ++ ; if ( cnt > raid_disks ) return - EBUSY ; } newpoolinfo = kmalloc ( sizeof ( * newpoolinfo ) , GFP_KERNEL ) ; if ( ! newpoolinfo ) return - ENOMEM ; newpoolinfo -> mddev = mddev ; newpoolinfo -> raid_disks = raid_disks * 2 ; newpool = mempool_create ( NR_RAID1_BIOS , r1bio_pool_alloc , r1bio_pool_free , newpoolinfo ) ; if ( ! newpool ) { kfree ( newpoolinfo ) ; return - ENOMEM ; } newmirrors = kzalloc ( sizeof ( struct raid1_info ) * raid_disks * 2 , GFP_KERNEL ) ; if ( ! newmirrors ) { kfree ( newpoolinfo ) ; mempool_destroy ( newpool ) ; return - ENOMEM ; } <S2SV_StartBug> raise_barrier ( conf ) ; <S2SV_EndBug> oldpool = conf -> r1bio_pool ; conf -> r1bio_pool = newpool ; for ( d = d2 = 0 ; d < conf -> raid_disks ; d ++ ) { struct md_rdev * rdev = conf -> mirrors [ d ] . rdev ; if ( rdev && rdev -> raid_disk != d2 ) { sysfs_unlink_rdev ( mddev , rdev ) ; rdev -> raid_disk = d2 ; sysfs_unlink_rdev ( mddev , rdev ) ; if ( sysfs_link_rdev ( mddev , rdev ) ) printk ( KERN_WARNING "md/raid1:%s:<S2SV_blank>cannot<S2SV_blank>register<S2SV_blank>rd%d\\n" , mdname ( mddev ) , rdev -> raid_disk ) ; } if ( rdev ) newmirrors [ d2 ++ ] . rdev = rdev ; } kfree ( conf -> mirrors ) ; conf -> mirrors = newmirrors ; kfree ( conf -> poolinfo ) ; conf -> poolinfo = newpoolinfo ; spin_lock_irqsave ( & conf -> device_lock , flags ) ; mddev -> degraded += ( raid_disks - conf -> raid_disks ) ; spin_unlock_irqrestore ( & conf -> device_lock , flags ) ; conf -> raid_disks = mddev -> raid_disks = raid_disks ; mddev -> delta_disks = 0 ; <S2SV_StartBug> lower_barrier ( conf ) ; <S2SV_EndBug> set_bit ( MD_RECOVERY_NEEDED , & mddev -> recovery ) ; md_wakeup_thread ( mddev -> thread ) ; mempool_destroy ( oldpool ) ; return 0 ; } | <S2SV_ModStart> ENOMEM ; } freeze_array ( conf , 0 <S2SV_ModEnd> ) ; oldpool <S2SV_ModStart> = 0 ; unfreeze_array <S2SV_ModEnd> ( conf ) |
2,433 | CWE-000 static int fimc_lite_probe ( struct platform_device * pdev ) { struct flite_drvdata * drv_data = NULL ; struct device * dev = & pdev -> dev ; const struct of_device_id * of_id ; struct fimc_lite * fimc ; struct resource * res ; int ret ; if ( ! dev -> of_node ) return - ENODEV ; fimc = devm_kzalloc ( dev , sizeof ( * fimc ) , GFP_KERNEL ) ; if ( ! fimc ) return - ENOMEM ; of_id = of_match_node ( flite_of_match , dev -> of_node ) ; if ( of_id ) drv_data = ( struct flite_drvdata * ) of_id -> data ; fimc -> index = of_alias_get_id ( dev -> of_node , "fimc-lite" ) ; if ( ! drv_data || fimc -> index >= drv_data -> num_instances || fimc -> index < 0 ) { dev_err ( dev , "Wrong<S2SV_blank>%s<S2SV_blank>node<S2SV_blank>alias\\n" , dev -> of_node -> full_name ) ; return - EINVAL ; } fimc -> dd = drv_data ; fimc -> pdev = pdev ; init_waitqueue_head ( & fimc -> irq_queue ) ; spin_lock_init ( & fimc -> slock ) ; mutex_init ( & fimc -> lock ) ; res = platform_get_resource ( pdev , IORESOURCE_MEM , 0 ) ; fimc -> regs = devm_ioremap_resource ( dev , res ) ; if ( IS_ERR ( fimc -> regs ) ) return PTR_ERR ( fimc -> regs ) ; res = platform_get_resource ( pdev , IORESOURCE_IRQ , 0 ) ; if ( res == NULL ) { dev_err ( dev , "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>IRQ<S2SV_blank>resource\\n" ) ; return - ENXIO ; } ret = fimc_lite_clk_get ( fimc ) ; if ( ret ) return ret ; ret = devm_request_irq ( dev , res -> start , flite_irq_handler , 0 , dev_name ( dev ) , fimc ) ; if ( ret ) { dev_err ( dev , "Failed<S2SV_blank>to<S2SV_blank>install<S2SV_blank>irq<S2SV_blank>(%d)\\n" , ret ) ; goto err_clk_put ; } ret = fimc_lite_create_capture_subdev ( fimc ) ; if ( ret ) goto err_clk_put ; platform_set_drvdata ( pdev , fimc ) ; pm_runtime_enable ( dev ) ; if ( ! pm_runtime_enabled ( dev ) ) { ret = clk_enable ( fimc -> clock ) ; if ( ret < 0 ) <S2SV_StartBug> goto err_clk_put ; <S2SV_EndBug> } fimc -> alloc_ctx = vb2_dma_contig_init_ctx ( dev ) ; if ( IS_ERR ( fimc -> alloc_ctx ) ) { ret = PTR_ERR ( fimc -> alloc_ctx ) ; goto err_clk_dis ; } fimc_lite_set_default_config ( fimc ) ; dev_dbg ( dev , "FIMC-LITE.%d<S2SV_blank>registered<S2SV_blank>successfully\\n" , fimc -> index ) ; return 0 ; err_clk_dis : <S2SV_StartBug> clk_disable ( fimc -> clock ) ; <S2SV_EndBug> err_sd : fimc_lite_unregister_capture_subdev ( fimc ) ; err_clk_put : fimc_lite_clk_put ( fimc ) ; return ret ; } | <S2SV_ModStart> 0 ) goto err_sd <S2SV_ModEnd> ; } fimc <S2SV_ModStart> ; err_clk_dis : if ( ! pm_runtime_enabled ( dev ) ) |
2,434 | CWE-000 int magnet_off ( void ) { <S2SV_StartBug> LOG_TRACE ( "Turning<S2SV_blank>magnet<S2SV_blank>off" ) ; <S2SV_EndBug> int x = get_pos ( X ) ; int y = get_pos ( Y ) ; <S2SV_StartBug> LOG_TRACE ( "magnet<S2SV_blank>position:<S2SV_blank>(%d,%d)" , x , y ) ; <S2SV_EndBug> HAL_Delay ( 500 ) ; MAGNET_OFF ; return 0 ; } | <S2SV_ModStart> void ) { <S2SV_ModEnd> int x = <S2SV_ModStart> Y ) ; <S2SV_ModEnd> HAL_Delay ( 500 |
2,435 | CWE-000 void ADS1263_GetGpioDatState ( ads1263_t * ads1263 ) { uint8_t buffer = 0 ; <S2SV_StartBug> buffer = ADS1263_ReadReg ( ADS1263_GPIODAT ) ; <S2SV_EndBug> ADS1263_ParseGpioDatReg ( ads1263 , buffer ) ; } | <S2SV_ModStart> = ADS1263_ReadReg ( ads1263 , |
2,436 | CWE-000 int64_t os_time_get_nano ( void ) { # if defined ( PIPE_OS_LINUX ) struct timespec tv ; clock_gettime ( CLOCK_MONOTONIC , & tv ) ; return tv . tv_nsec + tv . tv_sec * INT64_C ( 1000000000 ) ; # elif defined ( PIPE_OS_UNIX ) struct timeval tv ; gettimeofday ( & tv , NULL ) ; return tv . tv_usec * INT64_C ( 1000 ) + tv . tv_sec * INT64_C ( 1000000000 ) ; # elif defined ( PIPE_SUBSYSTEM_WINDOWS_USER ) static LARGE_INTEGER frequency ; LARGE_INTEGER counter ; <S2SV_StartBug> if ( ! frequency . QuadPart ) <S2SV_EndBug> QueryPerformanceFrequency ( & frequency ) ; QueryPerformanceCounter ( & counter ) ; <S2SV_StartBug> return counter . QuadPart * INT64_C ( 1000000000 ) / frequency . QuadPart ; <S2SV_EndBug> # else # error Unsupported OS # endif } | <S2SV_ModStart> LARGE_INTEGER counter ; int64_t secs , nanosecs ; <S2SV_ModStart> counter ) ; secs = <S2SV_ModEnd> counter . QuadPart <S2SV_ModStart> counter . QuadPart / frequency . QuadPart ; nanosecs = ( counter . QuadPart % frequency . QuadPart ) <S2SV_ModStart> frequency . QuadPart ; return secs * INT64_C ( 1000000000 ) + nanosecs |
2,437 | CWE-000 void scan_char ( ) { assert ( * stream == '\\'' ) ; stream ++ ; char val = 0 ; if ( * stream == '\\'' ) { syntax_error ( "Char<S2SV_blank>literal<S2SV_blank>cannot<S2SV_blank>be<S2SV_blank>empty" ) ; stream ++ ; } else if ( * stream == '\\n' ) { syntax_error ( "Char<S2SV_blank>literal<S2SV_blank>cannot<S2SV_blank>contain<S2SV_blank>newline" ) ; } else if ( * stream == '\\\\' ) { stream ++ ; <S2SV_StartBug> val = escape_to_char [ * stream ] ; <S2SV_EndBug> if ( val == 0 && * stream != '0' ) { syntax_error ( "Invalid<S2SV_blank>char<S2SV_blank>literal<S2SV_blank>escape<S2SV_blank>\'\\\\%c\'" , * stream ) ; } stream ++ ; } else { val = * stream ; stream ++ ; } if ( * stream != '\\'' ) { syntax_error ( "Expected<S2SV_blank>closing<S2SV_blank>char<S2SV_blank>quote,<S2SV_blank>got<S2SV_blank>\'%c\'" , * stream ) ; } else { stream ++ ; } token . kind = TOKEN_INT ; token . int_val = val ; token . mod = TOKENMOD_CHAR ; } | <S2SV_ModStart> escape_to_char [ * ( unsigned char * ) |
2,438 | CWE-000 void svga_doblit ( int y1 , int y2 , int wx , int wy , svga_t * svga ) { int y_add = ( enable_overscan ) ? 32 : 0 ; int x_add = ( enable_overscan ) ? 16 : 0 ; uint32_t * p , * q , i , j ; svga -> frames ++ ; if ( y1 > y2 ) { video_blit_memtoscreen ( 32 , 0 , 0 , 0 , xsize + x_add , ysize + y_add ) ; return ; } if ( ( wx != xsize || wy != ysize ) && ! vid_resize ) { xsize = wx ; ysize = wy + 1 ; if ( xsize < 64 ) xsize = 640 ; if ( ysize < 32 ) ysize = 200 ; <S2SV_StartBug> updatewindowsize ( xsize + x_add , ysize + y_add ) ; <S2SV_EndBug> } if ( vid_resize ) { xsize = wx ; ysize = wy + 1 ; } <S2SV_StartBug> if ( enable_overscan ) <S2SV_EndBug> { if ( ( wx >= 160 ) && ( ( wy + 1 ) >= 120 ) ) { for ( i = 0 ; i < 16 ; i ++ ) { p = & ( ( uint32_t * ) buffer32 -> line [ i ] ) [ 32 ] ; q = & ( ( uint32_t * ) buffer32 -> line [ ysize + y_add - 1 - i ] ) [ 32 ] ; for ( j = 0 ; j < ( xsize + x_add ) ; j ++ ) { p [ j ] = svga -> pallook [ svga -> attrregs [ 0x11 ] ] ; q [ j ] = svga -> pallook [ svga -> attrregs [ 0x11 ] ] ; } } for ( i = 16 ; i < ( ysize + 16 ) ; i ++ ) { p = & ( ( uint32_t * ) buffer32 -> line [ i ] ) [ 32 ] ; for ( j = 0 ; j < 8 ; j ++ ) { p [ j ] = svga -> pallook [ svga -> attrregs [ 0x11 ] ] ; p [ xsize + x_add - 1 - j ] = svga -> pallook [ svga -> attrregs [ 0x11 ] ] ; } } } } video_blit_memtoscreen ( 32 , 0 , y1 , y2 + y_add , xsize + x_add , ysize + y_add ) ; } | <S2SV_ModStart> = 200 ; if ( xsize > 2032 ) { x_add = 0 ; y_add = 0 ; suppress_overscan = 0 ; } else { suppress_overscan = 1 ; } <S2SV_ModStart> if ( enable_overscan && ! suppress_overscan |
2,439 | CWE-000 static int hvc_write ( struct tty_struct * tty , const unsigned char * buf , int count ) { struct hvc_struct * hp = tty -> driver_data ; unsigned long flags ; int rsize , written = 0 ; if ( ! hp ) return - EPIPE ; if ( hp -> port . count <= 0 ) return - EIO ; while ( count > 0 ) { <S2SV_StartBug> spin_lock_irqsave ( & hp -> lock , flags ) ; <S2SV_EndBug> rsize = hp -> outbuf_size - hp -> n_outbuf ; if ( rsize ) { if ( rsize > count ) rsize = count ; memcpy ( hp -> outbuf + hp -> n_outbuf , buf , rsize ) ; count -= rsize ; buf += rsize ; hp -> n_outbuf += rsize ; written += rsize ; } if ( hp -> n_outbuf > 0 ) <S2SV_StartBug> hvc_push ( hp ) ; <S2SV_EndBug> <S2SV_StartBug> spin_unlock_irqrestore ( & hp -> lock , flags ) ; <S2SV_EndBug> if ( count ) { if ( hp -> n_outbuf > 0 ) hvc_flush ( hp ) ; cond_resched ( ) ; } } if ( hp -> n_outbuf ) hvc_kick ( ) ; return written ; } | <S2SV_ModStart> 0 ) { int ret = 0 ; <S2SV_ModStart> > 0 ) ret = <S2SV_ModStart> , flags ) ; if ( ! ret ) break |
2,440 | CWE-000 static struct pipeline * configTextOut ( struct jsonElement * queryObj , int * pSavedStdout ) { char * fileName = "" ; char * compressType = textOutCompressNone ; struct jsonElement * outFileOptions = jsonFindNamedField ( queryObj , QUERY_SPEC , "outFileOptions" ) ; if ( outFileOptions ) { boolean doFile = jsonOptionalBooleanField ( outFileOptions , "doFile" , FALSE ) ; if ( doFile ) { fileName = jsonOptionalStringField ( outFileOptions , "fileName" , "hgIntegratorResults" ) ; <S2SV_StartBug> boolean doGzip = jsonOptionalBooleanField ( outFileOptions , "doGzip" , FALSE ) ; <S2SV_EndBug> if ( doGzip ) compressType = textOutCompressGzip ; } } return textOutInit ( fileName , compressType , pSavedStdout ) ; } | <S2SV_ModStart> "hgIntegratorResults" ) ; fileName = textOutSanitizeHttpFileName ( fileName ) ; |
2,441 | CWE-000 static void db_cleanup ( const char * rel ) { memset ( g_query , 0 , QUERY_LENGTH ) ; snprintf ( g_query , QUERY_LENGTH , "REMOVE<S2SV_blank>RELATION<S2SV_blank>%s;" , rel ) ; <S2SV_StartBug> db_exec ( g_query ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> rel ) ; int ret = <S2SV_ModStart> g_query ) ; if ( ret != DB_OK ) { printf ( "\\ndb_create_attribute<S2SV_blank>:<S2SV_blank>db_exec<S2SV_blank>FAIL\\n" ) ; db_deinit ( ) ; return ; } |
2,442 | CWE-000 int hashtable_del ( hashtable * ht , char * key ) { int bucket , key_size = strlen ( key ) , current_key_size ; entry * current , * prev ; bucket = hash_function ( key , key_size ) % ht -> nbucket ; prev = current = ht -> buckets [ bucket ] ; while ( current ) { current_key_size = strlen ( current -> key ) ; if ( key_size == current_key_size && ! strncmp ( key , current -> key , key_size ) ) { prev -> next = current -> next ; if ( current == ht -> buckets [ bucket ] ) { <S2SV_StartBug> ht -> buckets [ bucket ] = NULL ; <S2SV_EndBug> } free ( current -> key ) ; ht -> free ? ht -> free ( current -> value ) : free ( current -> value ) ; free ( current ) ; return 1 ; } prev = current ; current = current -> next ; } return 0 ; } | <S2SV_ModStart> bucket ] = prev <S2SV_ModEnd> ; } free |
2,443 | CWE-000 static void dma_uart_rx_idle_isr ( struct rt_serial_device * serial ) { struct stm32_uart * uart = ( struct stm32_uart * ) serial -> parent . user_data ; rt_size_t recv_total_index , recv_len ; rt_base_t level ; level = rt_hw_interrupt_disable ( ) ; recv_total_index = uart -> dma . setting_recv_len - DMA_GetCurrDataCounter ( uart -> dma . rx_ch ) ; <S2SV_StartBug> if ( recv_total_index >= uart -> dma . last_recv_index ) <S2SV_EndBug> { recv_len = recv_total_index - uart -> dma . last_recv_index ; <S2SV_StartBug> } <S2SV_EndBug> else { recv_len = uart -> dma . setting_recv_len - uart -> dma . last_recv_index + recv_total_index ; } uart -> dma . last_recv_index = recv_total_index ; rt_hw_interrupt_enable ( level ) ; if ( recv_len ) rt_hw_serial_isr ( serial , RT_SERIAL_EVENT_RX_DMADONE | ( recv_len << 8 ) ) ; USART_ReceiveData ( uart -> uart_device ) ; DMA_ClearFlag ( uart -> dma . rx_gl_flag ) ; } | <S2SV_ModStart> rx_ch ) ; <S2SV_ModEnd> recv_len = recv_total_index <S2SV_ModStart> . last_recv_index ; <S2SV_ModEnd> uart -> dma |
2,444 | CWE-000 int ixl_ioctl ( struct ifnet * ifp , u_long command , caddr_t data ) { struct ixl_vsi * vsi = ifp -> if_softc ; struct ixl_pf * pf = vsi -> back ; struct ifreq * ifr = ( struct ifreq * ) data ; struct ifdrv * ifd = ( struct ifdrv * ) data ; # if defined ( INET ) || defined ( INET6 ) struct ifaddr * ifa = ( struct ifaddr * ) data ; bool avoid_reset = FALSE ; # endif int error = 0 ; switch ( command ) { case SIOCSIFADDR : IOCTL_DEBUGOUT ( "ioctl:<S2SV_blank>SIOCSIFADDR<S2SV_blank>(Set<S2SV_blank>Interface<S2SV_blank>Address)" ) ; # ifdef INET if ( ifa -> ifa_addr -> sa_family == AF_INET ) avoid_reset = TRUE ; # endif # ifdef INET6 if ( ifa -> ifa_addr -> sa_family == AF_INET6 ) avoid_reset = TRUE ; # endif # if defined ( INET ) || defined ( INET6 ) if ( avoid_reset ) { ifp -> if_flags |= IFF_UP ; if ( ! ( ifp -> if_drv_flags & IFF_DRV_RUNNING ) ) ixl_init ( pf ) ; # ifdef INET if ( ! ( ifp -> if_flags & IFF_NOARP ) ) arp_ifinit ( ifp , ifa ) ; # endif } else error = ether_ioctl ( ifp , command , data ) ; break ; # endif case SIOCSIFMTU : IOCTL_DEBUGOUT ( "ioctl:<S2SV_blank>SIOCSIFMTU<S2SV_blank>(Set<S2SV_blank>Interface<S2SV_blank>MTU)" ) ; if ( ifr -> ifr_mtu > IXL_MAX_FRAME - ETHER_HDR_LEN - ETHER_CRC_LEN - ETHER_VLAN_ENCAP_LEN ) { error = EINVAL ; } else { IXL_PF_LOCK ( pf ) ; ifp -> if_mtu = ifr -> ifr_mtu ; vsi -> max_frame_size = ifp -> if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN + ETHER_VLAN_ENCAP_LEN ; <S2SV_StartBug> ixl_init_locked ( pf ) ; <S2SV_EndBug> IXL_PF_UNLOCK ( pf ) ; } break ; case SIOCSIFFLAGS : IOCTL_DEBUGOUT ( "ioctl:<S2SV_blank>SIOCSIFFLAGS<S2SV_blank>(Set<S2SV_blank>Interface<S2SV_blank>Flags)" ) ; IXL_PF_LOCK ( pf ) ; if ( ifp -> if_flags & IFF_UP ) { if ( ( ifp -> if_drv_flags & IFF_DRV_RUNNING ) ) { if ( ( ifp -> if_flags ^ pf -> if_flags ) & ( IFF_PROMISC | IFF_ALLMULTI ) ) { ixl_set_promisc ( vsi ) ; } } else { IXL_PF_UNLOCK ( pf ) ; ixl_init ( pf ) ; IXL_PF_LOCK ( pf ) ; } } else { if ( ifp -> if_drv_flags & IFF_DRV_RUNNING ) { ixl_stop_locked ( pf ) ; } } pf -> if_flags = ifp -> if_flags ; IXL_PF_UNLOCK ( pf ) ; break ; case SIOCSDRVSPEC : case SIOCGDRVSPEC : IOCTL_DEBUGOUT ( "ioctl:<S2SV_blank>SIOCxDRVSPEC<S2SV_blank>(Get/Set<S2SV_blank>Driver-specific<S2SV_blank>" "Info)\\n" ) ; if ( ifd -> ifd_cmd == I40E_NVM_ACCESS ) error = ixl_handle_nvmupd_cmd ( pf , ifd ) ; else error = EINVAL ; break ; case SIOCADDMULTI : IOCTL_DEBUGOUT ( "ioctl:<S2SV_blank>SIOCADDMULTI" ) ; if ( ifp -> if_drv_flags & IFF_DRV_RUNNING ) { IXL_PF_LOCK ( pf ) ; ixl_disable_rings_intr ( vsi ) ; ixl_add_multi ( vsi ) ; ixl_enable_intr ( vsi ) ; IXL_PF_UNLOCK ( pf ) ; } break ; case SIOCDELMULTI : IOCTL_DEBUGOUT ( "ioctl:<S2SV_blank>SIOCDELMULTI" ) ; if ( ifp -> if_drv_flags & IFF_DRV_RUNNING ) { IXL_PF_LOCK ( pf ) ; ixl_disable_rings_intr ( vsi ) ; ixl_del_multi ( vsi ) ; ixl_enable_intr ( vsi ) ; IXL_PF_UNLOCK ( pf ) ; } break ; case SIOCSIFMEDIA : case SIOCGIFMEDIA : case SIOCGIFXMEDIA : IOCTL_DEBUGOUT ( "ioctl:<S2SV_blank>SIOCxIFMEDIA<S2SV_blank>(Get/Set<S2SV_blank>Interface<S2SV_blank>Media)" ) ; error = ifmedia_ioctl ( ifp , ifr , & vsi -> media , command ) ; break ; case SIOCSIFCAP : { int mask = ifr -> ifr_reqcap ^ ifp -> if_capenable ; IOCTL_DEBUGOUT ( "ioctl:<S2SV_blank>SIOCSIFCAP<S2SV_blank>(Set<S2SV_blank>Capabilities)" ) ; ixl_cap_txcsum_tso ( vsi , ifp , mask ) ; if ( mask & IFCAP_RXCSUM ) ifp -> if_capenable ^= IFCAP_RXCSUM ; if ( mask & IFCAP_RXCSUM_IPV6 ) ifp -> if_capenable ^= IFCAP_RXCSUM_IPV6 ; if ( mask & IFCAP_LRO ) ifp -> if_capenable ^= IFCAP_LRO ; if ( mask & IFCAP_VLAN_HWTAGGING ) ifp -> if_capenable ^= IFCAP_VLAN_HWTAGGING ; if ( mask & IFCAP_VLAN_HWFILTER ) ifp -> if_capenable ^= IFCAP_VLAN_HWFILTER ; if ( mask & IFCAP_VLAN_HWTSO ) ifp -> if_capenable ^= IFCAP_VLAN_HWTSO ; if ( ifp -> if_drv_flags & IFF_DRV_RUNNING ) { IXL_PF_LOCK ( pf ) ; ixl_init_locked ( pf ) ; IXL_PF_UNLOCK ( pf ) ; } VLAN_CAPABILITIES ( ifp ) ; break ; } # if __FreeBSD_version >= 1003000 case SIOCGI2C : { struct ifi2creq i2c ; int i ; IOCTL_DEBUGOUT ( "ioctl:<S2SV_blank>SIOCGI2C<S2SV_blank>(Get<S2SV_blank>I2C<S2SV_blank>Data)" ) ; if ( ! pf -> has_i2c ) return ( ENOTTY ) ; error = copyin ( ifr -> ifr_data , & i2c , sizeof ( i2c ) ) ; if ( error != 0 ) break ; if ( i2c . dev_addr != 0xA0 && i2c . dev_addr != 0xA2 ) { error = EINVAL ; break ; } if ( i2c . len > sizeof ( i2c . data ) ) { error = EINVAL ; break ; } for ( i = 0 ; i < i2c . len ; i ++ ) if ( ixl_read_i2c_byte ( pf , i2c . offset + i , i2c . dev_addr , & i2c . data [ i ] ) ) return ( EIO ) ; error = copyout ( & i2c , ifr -> ifr_data , sizeof ( i2c ) ) ; break ; } # endif default : IOCTL_DEBUGOUT ( "ioctl:<S2SV_blank>UNKNOWN<S2SV_blank>(0x%X)\\n" , ( int ) command ) ; error = ether_ioctl ( ifp , command , data ) ; break ; } return ( error ) ; } | <S2SV_ModStart> + ETHER_VLAN_ENCAP_LEN ; if ( ifp -> if_drv_flags & IFF_DRV_RUNNING ) |
2,445 | CWE-000 bool writeFile ( Filepath filepath , void * iterator , bool ( popCategory ) ( void * , char * * ) , bool ( popRecord ) ( void * , ProductRecord * * ) ) { FILE * file = fopen ( filepath , "w" ) ; if ( ! file ) { printf ( "Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>file<S2SV_blank>for<S2SV_blank>writing.\\n" ) ; return false ; } { char * name ; while ( popCategory ( iterator , & name ) ) { fprintf ( file , "CAT<S2SV_blank>%s\\n" , name ) ; } } { ProductRecord * record ; # define STRING "%s\\n" # define INT "%i\\n" while ( popRecord ( iterator , & record ) ) { fprintf ( file , STRING INT STRING INT INT , record -> id , record -> instances , record -> name , record -> price , record -> category ) ; } # undef STRING # undef INT } <S2SV_StartBug> return true ; <S2SV_EndBug> } | <S2SV_ModStart> undef INT } fclose ( file ) ; |
2,446 | CWE-000 static void add_3d ( boundary * bnd , grid * grd , problem * pb ) { char * classify = bnd -> classify ; char * norm_dirs = bnd -> norm_dir ; double * values = bnd -> values ; int i ; for ( i = 0 ; i < 6 ; i ++ ) { int ii , jj ; int stride [ 2 ] ; int len [ 2 ] ; int offset ; char norm_dir ; len [ 0 ] = 0 ; len [ 1 ] = 0 ; if ( i == NORTH && grd -> cart_coord [ 1 ] == grd -> num_procs [ 1 ] - 1 && ( ! grd -> periodic [ 1 ] ) ) { stride [ 0 ] = grd -> len [ 0 ] * grd -> len [ 1 ] ; stride [ 1 ] = 1 ; offset = ( grd -> ibeg [ 1 ] + ( grd -> ny - 1 ) ) * grd -> len [ 0 ] ; norm_dir = - 2 ; len [ 0 ] = grd -> len [ 2 ] ; len [ 1 ] = grd -> len [ 0 ] ; } else if ( i == SOUTH && grd -> cart_coord [ 1 ] == 0 && ( ! grd -> periodic [ 1 ] ) ) { stride [ 0 ] = grd -> len [ 0 ] * grd -> len [ 1 ] ; stride [ 1 ] = 1 ; offset = grd -> ibeg [ 1 ] * grd -> len [ 0 ] ; norm_dir = 2 ; len [ 0 ] = grd -> len [ 2 ] ; len [ 1 ] = grd -> len [ 0 ] ; } else if ( i == EAST && grd -> cart_coord [ 0 ] == grd -> num_procs [ 0 ] - 1 && ( ! grd -> periodic [ 0 ] ) ) { stride [ 0 ] = grd -> len [ 0 ] * grd -> len [ 1 ] ; stride [ 1 ] = grd -> len [ 0 ] ; offset = grd -> ibeg [ 0 ] + grd -> nx - 1 ; norm_dir = - 1 ; len [ 0 ] = grd -> len [ 2 ] ; len [ 1 ] = grd -> len [ 1 ] ; } else if ( i == WEST && grd -> cart_coord [ 0 ] == 0 && ( ! grd -> periodic [ 0 ] ) ) { stride [ 0 ] = grd -> len [ 0 ] * grd -> len [ 1 ] ; stride [ 1 ] = grd -> len [ 0 ] ; offset = grd -> ibeg [ 0 ] ; norm_dir = 1 ; len [ 0 ] = grd -> len [ 2 ] ; len [ 1 ] = grd -> len [ 1 ] ; } else if ( i == FRONT && grd -> cart_coord [ 2 ] == grd -> num_procs [ 2 ] - 1 && ( ! grd -> periodic [ 2 ] ) ) { stride [ 0 ] = grd -> len [ 0 ] ; stride [ 1 ] = 1 ; offset = ( grd -> ibeg [ 2 ] + ( grd -> nz - 1 ) ) * grd -> len [ 0 ] * grd -> len [ 1 ] ; norm_dir = - 3 ; len [ 0 ] = grd -> len [ 1 ] ; <S2SV_StartBug> len [ 1 ] = grd -> len [ 2 ] ; <S2SV_EndBug> } else if ( i == BACK && grd -> cart_coord [ 2 ] == 0 && ( ! grd -> periodic [ 2 ] ) ) { stride [ 0 ] = grd -> len [ 0 ] ; stride [ 1 ] = 1 ; offset = grd -> ibeg [ 2 ] * grd -> len [ 0 ] * grd -> len [ 1 ] ; norm_dir = 3 ; len [ 0 ] = grd -> len [ 1 ] ; len [ 1 ] = grd -> len [ 0 ] ; } for ( ii = 0 ; ii < len [ 0 ] ; ii ++ ) { for ( jj = 0 ; jj < len [ 1 ] ; jj ++ ) { int ind = ii * stride [ 0 ] + jj * stride [ 1 ] + offset ; if ( ! ( ( classify [ ind ] == DIRICHLET ) && ( pb -> boundary [ i ] != DIRICHLET ) ) ) { classify [ ind ] = pb -> boundary [ i ] ; if ( pb -> boundary [ i ] == DIRICHLET ) values [ ind ] = pb -> sol ( grd -> x [ ind ] , grd -> y [ ind ] , grd -> z [ ind ] ) ; else values [ ind ] = 0.0 ; norm_dirs [ ind ] = norm_dir ; } } } } } | <S2SV_ModStart> -> len [ 0 <S2SV_ModEnd> ] ; } |
2,447 | CWE-000 fmiStatus fmi1_cs_set_time ( fmiComponent c , fmiReal time ) { fmi1_cs_t * fmi1_cs = ( fmi1_cs_t * ) c ; int retval ; <S2SV_StartBug> retval = fmi1_me_set_time ( fmi1_cs -> ode_problem -> fmix_me , time ) ; <S2SV_EndBug> if ( retval != fmiOK ) { return fmiError ; } fmi1_cs -> ode_problem -> time = time ; return fmiOK ; } | <S2SV_ModStart> ( fmi1_cs -> cs_data <S2SV_ModEnd> -> fmix_me , |
2,448 | CWE-000 LIST * CreateList ( ) { LIST * list = FILTER_ALLOC_MEM ( FilterDriverObject , sizeof ( LIST ) ) ; NdisZeroMemory ( list , sizeof ( LIST ) ) ; list -> Lock = CreateSpinLock ( ) ; <S2SV_StartBug> return list ; <S2SV_EndBug> } | <S2SV_ModStart> ( ) ; list -> Releasing = FALSE ; |
2,449 | CWE-000 int qse_wcsntoctype ( const qse_wchar_t * name , qse_size_t len , qse_wctype_t * id ) { int left = 0 , right = QSE_COUNTOF ( wtab ) - 1 , mid ; while ( left <= right ) { int n ; struct wtab_t * kwp ; <S2SV_StartBug> mid = ( left + right ) / 2 ; <S2SV_EndBug> kwp = & wtab [ mid ] ; n = qse_wcsxcmp ( name , len , kwp -> name ) ; if ( n < 0 ) { right = mid - 1 ; } else if ( n > 0 ) left = mid + 1 ; else { * id = kwp -> class ; return 0 ; } } return - 1 ; } | <S2SV_ModStart> ; mid = left + ( right - left <S2SV_ModEnd> ) / 2 |
2,450 | CWE-000 static int prep_set_cmos_checksum ( DeviceState * dev , void * opaque ) { uint16_t checksum = * ( uint16_t * ) opaque ; ISADevice * rtc ; if ( object_dynamic_cast ( OBJECT ( dev ) , "mc146818rtc" ) ) { rtc = ISA_DEVICE ( dev ) ; rtc_set_memory ( rtc , 0x2e , checksum & 0xff ) ; rtc_set_memory ( rtc , 0x3e , checksum & 0xff ) ; rtc_set_memory ( rtc , 0x2f , checksum >> 8 ) ; rtc_set_memory ( rtc , 0x3f , checksum >> 8 ) ; <S2SV_StartBug> } <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> 8 ) ; object_property_add_alias ( qdev_get_machine ( ) , "rtc-time" , OBJECT ( rtc ) , "date" , NULL ) ; |
2,451 | CWE-000 int_t treeqp_dune_scenarios_calculate_size ( tree_ocp_qp_in * qp_in ) { struct node * tree = ( struct node * ) qp_in -> tree ; int_t nx = qp_in -> nx [ 1 ] ; int_t nu = qp_in -> nu [ 0 ] ; int_t Nn = qp_in -> N ; int_t Nh = tree [ Nn - 1 ] . stage ; int_t Np = get_number_of_parent_nodes ( Nn , tree ) ; int_t Ns = Nn - Np ; int_t Nr = get_robust_horizon ( Nn , tree ) ; int_t commonNodes , commonNodesNxt , maxTmpDim ; int_t commonNodesMax = 0 ; int_t bytes = 0 ; bytes += 2 * Ns * sizeof ( int_t * ) ; bytes += 2 * Ns * ( Nh + 1 ) * sizeof ( int_t ) ; # ifdef _CHECK_LAST_ACTIVE_SET_ bytes += 2 * Ns * sizeof ( int_t * ) ; bytes += 2 * Ns * ( Nh + 1 ) * sizeof ( int_t ) ; # endif bytes += ( Ns - 1 ) * sizeof ( int_t ) ; bytes += Ns * sizeof ( real_t ) ; bytes += 6 * Ns * sizeof ( struct d_strvec * ) ; bytes += 6 * Ns * Nh * sizeof ( struct d_strvec ) ; bytes += 2 * Ns * sizeof ( struct d_strvec * ) ; bytes += 2 * Ns * Nh * sizeof ( struct d_strvec ) ; bytes += 4 * Ns * sizeof ( struct d_strvec * ) ; bytes += 4 * Ns * Nh * sizeof ( struct d_strvec ) ; bytes += Ns * sizeof ( struct d_strmat * ) ; bytes += Ns * Nh * sizeof ( struct d_strmat ) ; bytes += 2 * Ns * sizeof ( struct d_strmat * ) ; bytes += 2 * Ns * Nh * sizeof ( struct d_strmat ) ; bytes += 2 * Ns * sizeof ( struct d_strmat * ) ; bytes += 2 * Ns * ( Nh - 1 ) * sizeof ( struct d_strmat ) ; # ifdef _CHECK_LAST_ACTIVE_SET_ bytes += Ns * sizeof ( struct d_strmat * ) ; bytes += Ns * Nh * sizeof ( struct d_strmat ) ; bytes += 2 * Ns * sizeof ( struct d_strvec * ) ; bytes += 2 * Ns * Nh * sizeof ( struct d_strvec ) ; # endif bytes += 3 * Ns * Nh * d_size_strvec ( nx ) ; bytes += 3 * Ns * Nh * d_size_strvec ( nu ) ; bytes += Ns * Nh * d_size_strvec ( nx ) ; bytes += Ns * Nh * d_size_strvec ( nu ) ; bytes += 4 * Ns * Nh * d_size_strvec ( nx ) ; bytes += Ns * Nh * d_size_strmat ( nx , nu ) ; bytes += 2 * Ns * Nh * d_size_strmat ( nx , nx ) ; bytes += 2 * Ns * ( Nh - 1 ) * d_size_strmat ( nx , nx ) ; # ifdef _CHECK_LAST_ACTIVE_SET_ bytes += Ns * Nh * d_size_strmat ( nx , nx ) ; bytes += Ns * Nh * d_size_strvec ( nx ) ; bytes += Ns * Nh * d_size_strvec ( nu ) ; # endif bytes += 6 * Nn * sizeof ( struct d_strmat ) ; bytes += 2 * ( Ns - 1 ) * sizeof ( struct d_strmat ) ; bytes += 2 * ( Ns - 2 ) * sizeof ( struct d_strmat ) ; bytes += 2 * Ns * sizeof ( struct d_strmat ) ; bytes += 2 * ( Ns - 1 ) * sizeof ( struct d_strvec ) ; bytes += 2 * ( Ns - 1 ) * sizeof ( struct d_strvec ) ; bytes += 1 * sizeof ( struct d_strvec ) ; bytes += Ns * sizeof ( struct d_strvec ) ; bytes += Ns * sizeof ( struct d_strmat ) ; for ( int_t jj = 0 ; jj < Nn ; jj ++ ) { bytes += 3 * d_size_strvec ( qp_in -> nx [ jj ] ) ; bytes += 3 * d_size_strvec ( qp_in -> nu [ jj ] ) ; } for ( int_t ii = 0 ; ii < Ns - 1 ; ii ++ ) { commonNodes = get_number_of_common_nodes ( Nn , Ns , Nh , ii , ii + 1 , tree ) ; commonNodesMax = MAX ( commonNodesMax , commonNodes ) ; bytes += 2 * d_size_strmat ( nu * commonNodes , nu * commonNodes ) ; bytes += 2 * d_size_strvec ( nu * commonNodes ) ; bytes += 2 * d_size_strvec ( nu * commonNodes ) ; if ( ii < Ns - 2 ) { commonNodesNxt = get_number_of_common_nodes ( Nn , Ns , Nh , ii + 1 , ii + 2 , tree ) ; bytes += 2 * d_size_strmat ( nu * commonNodesNxt , nu * commonNodes ) ; } } maxTmpDim = MAX ( nx , nu * commonNodesMax ) ; bytes += d_size_strvec ( maxTmpDim ) ; bytes += Ns * d_size_strvec ( maxTmpDim ) ; bytes += Ns * d_size_strmat ( nu , nx ) ; bytes += Ns * d_size_strmat ( nu * Nr , Nh * nx ) ; bytes += Ns * d_size_strmat ( nu * Nr , nu * Nr ) ; <S2SV_StartBug> bytes += ( bytes + 63 ) / 64 * 64 ; <S2SV_EndBug> bytes += 64 ; return bytes ; } | <S2SV_ModStart> ) ; bytes = <S2SV_ModEnd> ( bytes + |
2,452 | CWE-000 static int get_the_top_level_aux_file_name ( const char * aux_file_name ) { name_of_file = xmalloc_array ( ASCII_code , strlen ( aux_file_name ) + 1 ) ; strcpy ( ( char * ) name_of_file + 1 , aux_file_name ) ; aux_name_length = strlen ( ( char * ) name_of_file + 1 ) ; aux_name_length -= 4 ; <S2SV_StartBug> aux_ptr = 0 ; <S2SV_EndBug> if ( ( aux_file [ aux_ptr ] = peekable_open ( ( char * ) name_of_file + 1 , kpse_tex_format ) ) == NULL ) { sam_wrong_file_name_print ( ) ; return 1 ; } <S2SV_StartBug> name_length = aux_name_length ; <S2SV_EndBug> add_extension ( s_log_extension ) ; if ( ( log_file = ttstub_output_open ( ( char * ) name_of_file + 1 , 0 ) ) == NULL ) { sam_wrong_file_name_print ( ) ; return 1 ; } name_length = aux_name_length ; add_extension ( s_bbl_extension ) ; if ( ( bbl_file = ttstub_output_open ( ( char * ) name_of_file + 1 , 0 ) ) == NULL ) { sam_wrong_file_name_print ( ) ; return 1 ; } name_length = aux_name_length ; add_extension ( s_aux_extension ) ; name_ptr = 1 ; while ( name_ptr <= name_length ) { buffer [ name_ptr ] = name_of_file [ name_ptr ] ; name_ptr = name_ptr + 1 ; } top_lev_str = hash_text [ str_lookup ( buffer , 1 , aux_name_length , 0 , true ) ] ; aux_list [ aux_ptr ] = hash_text [ str_lookup ( buffer , 1 , name_length , 3 , true ) ] ; if ( hash_found ) { puts_log ( "Already<S2SV_blank>encountered<S2SV_blank>auxiliary<S2SV_blank>file" ) ; print_confusion ( ) ; longjmp ( error_jmpbuf , 1 ) ; } aux_ln_stack [ aux_ptr ] = 0 ; return 0 ; } | <S2SV_ModStart> -= 4 ; name_length = aux_name_length ; <S2SV_ModStart> 1 ; } <S2SV_ModEnd> add_extension ( s_log_extension |
2,453 | CWE-000 bool won ( void ) { int previous = 0 ; for ( int i = 0 ; i < d ; i ++ ) { for ( int j = 0 ; j < d ; j ++ ) { int current = board [ i ] [ j ] ; if ( current > previous ) { previous = current ; } <S2SV_StartBug> else if ( current == 0 && previous == d - 1 ) <S2SV_EndBug> { return true ; } else { return false ; } } printf ( "\\n" ) ; } return false ; } | <S2SV_ModStart> previous == d * d |
2,454 | CWE-000 ScmObj Scm_CharSetAdd ( ScmCharSet * dst , ScmCharSet * src ) { check_mutable ( dst ) ; if ( dst == src ) return SCM_OBJ ( dst ) ; <S2SV_StartBug> set_large ( dst , TRUE ) ; <S2SV_EndBug> ScmTreeIter iter ; ScmDictEntry * e ; Scm_BitsOperate ( dst -> small , SCM_BIT_IOR , dst -> small , src -> small , 0 , SCM_CHAR_SET_SMALL_CHARS ) ; Scm_TreeIterInit ( & iter , & src -> large . tree , NULL ) ; while ( ( e = Scm_TreeIterNext ( & iter ) ) != NULL ) { Scm_CharSetAddRange ( dst , SCM_CHAR ( e -> key ) , SCM_CHAR ( e -> value ) ) ; } return SCM_OBJ ( dst ) ; } | <S2SV_ModStart> ( dst , SCM_CHAR_SET_LARGEP ( src ) <S2SV_ModEnd> ) ; ScmTreeIter |
2,455 | CWE-000 <S2SV_StartBug> static PHP_METHOD ( Phalcon_Mvc_Router_Group , getPaths ) { <S2SV_EndBug> <S2SV_StartBug> zval * this_ptr = getThis ( ) ; <S2SV_EndBug> <S2SV_StartBug> RETURN_MEMBER ( getThis ( ) , "_paths" ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> static PHP_METHOD ( Phalcon_Validation_Message_Group , __construct <S2SV_ModEnd> ) { zval <S2SV_ModStart> { zval * messages = NULL ; zephir_fetch_params ( 0 , 0 , 1 , & messages ) ; if ( ! messages ) { messages = ZEPHIR_GLOBAL ( global_null ) ; } if ( Z_TYPE_P ( messages ) == IS_ARRAY ) { zephir_update_property_this <S2SV_ModEnd> ( getThis ( <S2SV_ModStart> ( ) , SL ( "_messages" ) , messages TSRMLS_CC <S2SV_ModEnd> ) ; } <S2SV_ModStart> ) ; } } |
2,456 | CWE-000 void mips_intr_disable ( void ) { <S2SV_StartBug> asm volatile ( "di" ) ; <S2SV_EndBug> } | <S2SV_ModStart> asm volatile ( "di;<S2SV_blank>ehb" <S2SV_ModEnd> ) ; } |
2,457 | CWE-000 void _CfrTil_FinishSourceCode ( CfrTil * cfrtil , Word * word ) { if ( ! word -> SourceCode ) word -> SourceCode = String_New ( cfrtil -> SourceCodeScratchPad , STRING_MEM ) ; Lexer_SourceCodeOff ( _Context_ -> Lexer0 ) ; <S2SV_StartBug> SetState ( cfrtil , SOURCE_CODE_INITIALIZED , false ) ; <S2SV_EndBug> } | <S2SV_ModStart> Lexer0 ) ; __CfrTil_SourceCode_Init ( cfrtil ) ; |
2,458 | CWE-000 static int wil_vring_alloc_skb ( struct wil6210_priv * wil , struct wil_ring * vring , u32 i , int headroom ) { struct device * dev = wil_to_dev ( wil ) ; unsigned int sz = wil -> rx_buf_len + ETH_HLEN + wil_rx_snaplen ( ) ; struct vring_rx_desc dd , * d = & dd ; volatile struct vring_rx_desc * _d = & vring -> va [ i ] . rx . legacy ; dma_addr_t pa ; struct sk_buff * skb = dev_alloc_skb ( sz + headroom ) ; if ( unlikely ( ! skb ) ) return - ENOMEM ; skb_reserve ( skb , headroom ) ; skb_put ( skb , sz ) ; <S2SV_StartBug> pa = dma_map_single ( dev , skb -> data , skb -> len , DMA_FROM_DEVICE ) ; <S2SV_EndBug> if ( unlikely ( dma_mapping_error ( dev , pa ) ) ) { kfree_skb ( skb ) ; return - ENOMEM ; } d -> dma . d0 = RX_DMA_D0_CMD_DMA_RT | RX_DMA_D0_CMD_DMA_IT ; wil_desc_addr_set ( & d -> dma . addr , pa ) ; d -> dma . status = 0 ; d -> dma . length = cpu_to_le16 ( sz ) ; * _d = * d ; vring -> ctx [ i ] . skb = skb ; return 0 ; } | <S2SV_ModStart> sz ) ; skb -> ip_summed = CHECKSUM_NONE ; |
2,459 | CWE-000 void IntrFuncCallEnd ( UInt funccall , UInt options , UInt nr ) { Obj func ; Obj a1 ; Obj a2 ; Obj a3 ; Obj a4 ; Obj a5 ; Obj a6 ; Obj args ; Obj argi ; Obj val ; Obj opts ; UInt i ; if ( TLS ( IntrReturning ) > 0 ) { return ; } if ( TLS ( IntrIgnoring ) > 0 ) { return ; } if ( TLS ( IntrCoding ) > 0 ) { CodeFuncCallEnd ( funccall , options , nr ) ; return ; } if ( options ) { opts = PopObj ( ) ; CALL_1ARGS ( PushOptions , opts ) ; } a1 = a2 = a3 = a4 = a5 = a6 = args = 0 ; if ( nr <= 6 ) { if ( 6 <= nr ) { a6 = PopObj ( ) ; } if ( 5 <= nr ) { a5 = PopObj ( ) ; } if ( 4 <= nr ) { a4 = PopObj ( ) ; } if ( 3 <= nr ) { a3 = PopObj ( ) ; } if ( 2 <= nr ) { a2 = PopObj ( ) ; } if ( 1 <= nr ) { a1 = PopObj ( ) ; } } else { args = NEW_PLIST ( T_PLIST , nr ) ; SET_LEN_PLIST ( args , nr ) ; for ( i = nr ; 1 <= i ; i -- ) { argi = PopObj ( ) ; SET_ELM_PLIST ( args , i , argi ) ; } } func = PopObj ( ) ; if ( TNUM_OBJ ( func ) != T_FUNCTION ) { args = NEW_PLIST ( T_PLIST_DENSE , nr ) ; SET_LEN_PLIST ( args , nr ) ; switch ( nr ) { case 6 : SET_ELM_PLIST ( args , 6 , a6 ) ; case 5 : SET_ELM_PLIST ( args , 5 , a5 ) ; case 4 : SET_ELM_PLIST ( args , 4 , a4 ) ; case 3 : SET_ELM_PLIST ( args , 3 , a3 ) ; case 2 : SET_ELM_PLIST ( args , 2 , a2 ) ; case 1 : SET_ELM_PLIST ( args , 1 , a1 ) ; } val = DoOperation2Args ( CallFuncListOper , func , args ) ; } else { if ( 0 == nr ) { val = CALL_0ARGS ( func ) ; } else if ( 1 == nr ) { val = CALL_1ARGS ( func , a1 ) ; } else if ( 2 == nr ) { val = CALL_2ARGS ( func , a1 , a2 ) ; } else if ( 3 == nr ) { val = CALL_3ARGS ( func , a1 , a2 , a3 ) ; } else if ( 4 == nr ) { val = CALL_4ARGS ( func , a1 , a2 , a3 , a4 ) ; } else if ( 5 == nr ) { val = CALL_5ARGS ( func , a1 , a2 , a3 , a4 , a5 ) ; } else if ( 6 == nr ) { val = CALL_6ARGS ( func , a1 , a2 , a3 , a4 , a5 , a6 ) ; } else { val = CALL_XARGS ( func , args ) ; } if ( TLS ( UserHasQuit ) || TLS ( UserHasQUIT ) ) { ReadEvalError ( ) ; } } <S2SV_StartBug> if ( funccall && val == 0 ) { <S2SV_EndBug> ErrorQuit ( "Function<S2SV_blank>call:<S2SV_blank><func><S2SV_blank>must<S2SV_blank>return<S2SV_blank>a<S2SV_blank>value" , 0L , 0L ) ; } if ( options ) CALL_0ARGS ( PopOptions ) ; if ( val == 0 ) PushVoidObj ( ) ; else PushObj ( val ) ; } | <S2SV_ModStart> } if ( options ) CALL_0ARGS ( PopOptions ) ; if ( <S2SV_ModEnd> val == 0 <S2SV_ModStart> == 0 ) PushFunctionVoidReturn <S2SV_ModEnd> ( ) ; |
2,460 | CWE-000 static int ssl_print_extensions ( BIO * bio , int indent , int server , unsigned char mt , const unsigned char * * msgin , size_t * msginlen ) { size_t extslen , msglen = * msginlen ; const unsigned char * msg = * msgin ; BIO_indent ( bio , indent , 80 ) ; if ( msglen == 0 ) { BIO_puts ( bio , "No<S2SV_blank>Extensions\\n" ) ; return 1 ; } extslen = ( msg [ 0 ] << 8 ) | msg [ 1 ] ; if ( extslen != msglen - 2 ) return 0 ; msg += 2 ; msglen = extslen ; BIO_printf ( bio , "extensions,<S2SV_blank>length<S2SV_blank>=<S2SV_blank>%d\\n" , ( int ) msglen ) ; while ( msglen > 0 ) { int extype ; size_t extlen ; if ( msglen < 4 ) return 0 ; extype = ( msg [ 0 ] << 8 ) | msg [ 1 ] ; extlen = ( msg [ 2 ] << 8 ) | msg [ 3 ] ; if ( msglen < extlen + 4 ) <S2SV_StartBug> return 0 ; <S2SV_EndBug> msg += 4 ; if ( ! ssl_print_extension ( bio , indent + 2 , server , mt , extype , msg , extlen ) ) return 0 ; msg += extlen ; msglen -= extlen + 4 ; } * msgin = msg ; * msginlen = msglen ; return 1 ; } | <S2SV_ModStart> + 4 ) { BIO_printf ( bio , "extensions,<S2SV_blank>extype<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>extlen<S2SV_blank>=<S2SV_blank>%d\\n" , extype , ( int ) extlen ) ; BIO_dump_indent ( bio , ( const char * ) msg , msglen , indent + 2 ) ; return 0 ; } <S2SV_ModEnd> msg += 4 |
2,461 | CWE-000 static LEXEME * expression_ampersand ( LEXEME * lex , SYMBOL * funcsp , TYPE * atp , TYPE * * tp , EXPRESSION * * exp , int flags ) { lex = getsym ( ) ; lex = expression_cast ( lex , funcsp , atp , tp , exp , NULL , ( flags ) | _F_AMPERSAND ) ; if ( * tp ) { TYPE * btp , * tp1 ; EXPRESSION * exp1 = * exp , * symRef ; while ( exp1 -> type == en_void && exp1 -> right ) exp1 = exp1 -> right ; if ( exp1 -> type == en_void ) exp1 = exp1 -> left ; symRef = chosenAssembler -> msil ? GetSymRef ( exp1 ) : NULL ; btp = basetype ( * tp ) ; if ( ( cparams . prm_cplusplus || chosenAssembler -> msil ) && insertOperatorFunc ( ovcl_unary_any , and_unary , funcsp , tp , exp , NULL , NULL , NULL , flags ) ) { return lex ; } else if ( isvoid ( * tp ) || ismsil ( * tp ) ) error ( ERR_NOT_AN_ALLOWED_TYPE ) ; else if ( btp -> hasbits ) error ( ERR_CANNOT_TAKE_ADDRESS_OF_BIT_FIELD ) ; else if ( btp -> msil ) error ( ERR_MANAGED_OBJECT_NO_ADDRESS ) ; else if ( symRef && symRef -> v . sp -> linkage2 == lk_property ) errorsym ( ERR_CANNOT_TAKE_ADDRESS_OF_PROPERTY , symRef -> v . sp ) ; else if ( inreg ( * exp , TRUE ) ) error ( ERR_CANNOT_TAKE_ADDRESS_OF_REGISTER ) ; else if ( ( ! ispointer ( btp ) || ! ( btp ) -> array ) && ! isstructured ( btp ) && ! isfunction ( btp ) && btp -> type != bt_aggregate && ( exp1 ) -> type != en_memberptr ) { if ( ( exp1 ) -> type != en_const && exp1 -> type != en_assign ) if ( ! lvalue ( exp1 ) ) if ( cparams . prm_ansi || ! castvalue ( exp1 ) ) error ( ERR_MUST_TAKE_ADDRESS_OF_MEMORY_LOCATION ) ; } else switch ( ( exp1 ) -> type ) { case en_pc : case en_auto : case en_label : case en_global : case en_absolute : case en_threadlocal : { <S2SV_StartBug> SYMBOL * sp = ( * exp ) -> v . sp ; <S2SV_EndBug> if ( sp -> isConstructor || sp -> isDestructor ) error ( ERR_CANNOT_TAKE_ADDRESS_OF_CONSTRUCTOR_OR_DESTRUCTOR ) ; break ; } default : break ; } if ( ( * exp ) -> type == en_const ) { SYMBOL * sp = ( * exp ) -> v . sp ; if ( ! sp -> indecltable ) { if ( ! sp -> label ) { TYPE * tp , * tpb , * tpn , * * tpnp = & tpn ; BOOLEAN done = FALSE ; SYMBOL * spold = sp ; sp -> label = nextLabel ++ ; IncGlobalFlag ( ) ; sp = clonesym ( sp ) ; spold -> indecltable = TRUE ; tp = sp -> tp ; tpb = basetype ( tp ) ; do { * tpnp = Alloc ( sizeof ( TYPE ) ) ; * * tpnp = * tp ; UpdateRootTypes ( * tpnp ) ; tpnp = & ( * tpnp ) -> btp ; if ( tp != tpb ) tp = tp -> btp ; else done = TRUE ; } while ( ! done ) ; sp -> tp = tpn ; insertInitSym ( sp ) ; DecGlobalFlag ( ) ; } else { IncGlobalFlag ( ) ; insertInitSym ( sp ) ; DecGlobalFlag ( ) ; } if ( ! sp -> parent ) sp -> parent = funcsp ; * exp = varNode ( en_label , sp ) ; } else { * exp = varNode ( en_label , sp ) ; } tp1 = Alloc ( sizeof ( TYPE ) ) ; tp1 -> type = bt_pointer ; tp1 -> size = getSize ( bt_pointer ) ; tp1 -> btp = * tp ; tp1 -> rootType = tp1 ; * tp = tp1 ; } else if ( ! isfunction ( * tp ) && ( * tp ) -> type != bt_aggregate ) { <S2SV_StartBug> EXPRESSION * expasn = NULL ; <S2SV_EndBug> while ( castvalue ( exp1 ) ) exp1 = ( exp1 ) -> left ; if ( exp1 -> type == en_assign ) { expasn = exp1 ; exp1 = exp1 -> left ; while ( castvalue ( exp1 ) ) exp1 = ( exp1 ) -> left ; } if ( ! lvalue ( exp1 ) ) { if ( ! btp -> array && ! btp -> vla && ! isstructured ( btp ) && basetype ( btp ) -> type != bt_memberptr && basetype ( btp ) -> type != bt_templateparam ) error ( ERR_LVALUE ) ; } else if ( ! isstructured ( btp ) && exp1 -> type != en_l_ref ) exp1 = ( exp1 ) -> left ; switch ( ( exp1 ) -> type ) { case en_pc : case en_auto : case en_label : case en_global : case en_absolute : case en_threadlocal : ( exp1 ) -> v . sp -> addressTaken = TRUE ; break ; default : break ; } <S2SV_StartBug> if ( basetype ( btp ) -> type != bt_memberptr ) <S2SV_EndBug> { tp1 = Alloc ( sizeof ( TYPE ) ) ; tp1 -> type = bt_pointer ; tp1 -> size = getSize ( bt_pointer ) ; tp1 -> btp = * tp ; tp1 -> rootType = tp1 ; * tp = tp1 ; if ( expasn ) <S2SV_StartBug> * exp = exprNode ( en_void , expasn , exp1 ) ; <S2SV_EndBug> else <S2SV_StartBug> * exp = exp1 ; <S2SV_EndBug> } } } return lex ; } | <S2SV_ModStart> * sp = exp1 <S2SV_ModEnd> -> v . <S2SV_ModStart> expasn = NULL , * * exp2 <S2SV_ModStart> break ; } exp2 = exp ; while ( ( * exp2 ) -> type == en_void && ( * exp2 ) -> right ) exp2 = & ( * exp2 ) -> right ; if ( ( * exp2 ) -> type == en_void ) exp2 = & ( * exp2 ) -> left ; <S2SV_ModStart> expasn ) * exp2 <S2SV_ModEnd> = exprNode ( <S2SV_ModStart> ; else * exp2 <S2SV_ModEnd> = exp1 ; |
2,462 | CWE-000 static void start_vrrp ( void ) { clear_summary_flags ( ) ; kernel_netlink_init ( ) ; if ( reload ) <S2SV_StartBug> global_data = alloc_global_data ( ) ; <S2SV_EndBug> vrrp_data = alloc_vrrp_data ( ) ; if ( ! vrrp_data ) { stop_vrrp ( KEEPALIVED_EXIT_FATAL ) ; return ; } init_data ( conf_file , vrrp_init_keywords ) ; if ( non_existent_interface_specified ) { log_message ( LOG_INFO , "Non-existent<S2SV_blank>interface<S2SV_blank>specified<S2SV_blank>in<S2SV_blank>configuration" ) ; stop_vrrp ( KEEPALIVED_EXIT_CONFIG ) ; return ; } if ( reload ) init_global_data ( global_data ) ; set_time_now ( ) ; if ( ! __test_bit ( CONFIG_TEST_BIT , & debug ) ) { set_process_priorities ( # ifdef _HAVE_SCHED_RT_ global_data -> vrrp_realtime_priority , # if HAVE_DECL_RLIMIT_RTTIME == 1 global_data -> vrrp_rlimit_rt , # endif # endif global_data -> vrrp_process_priority , global_data -> vrrp_no_swap ? 4096 : 0 ) ; # if defined _WITH_SNMP_RFC || defined _WITH_SNMP_VRRP_ if ( ! reload && ( # ifdef _WITH_SNMP_VRRP_ global_data -> enable_snmp_vrrp || # endif # ifdef _WITH_SNMP_RFCV2_ global_data -> enable_snmp_rfcv2 || # endif # ifdef _WITH_SNMP_RFCV3_ global_data -> enable_snmp_rfcv3 || # endif false ) ) { vrrp_snmp_agent_init ( global_data -> snmp_socket ) ; # ifdef _WITH_SNMP_RFC_ vrrp_start_time = time_now ; # endif } # endif # ifdef _WITH_LVS_ if ( vrrp_ipvs_needed ( ) ) { if ( ipvs_start ( ) != IPVS_SUCCESS ) { stop_vrrp ( KEEPALIVED_EXIT_FATAL ) ; return ; } if ( global_data -> lvs_tcp_timeout || global_data -> lvs_tcpfin_timeout || global_data -> lvs_udp_timeout ) ipvs_set_timeouts ( global_data -> lvs_tcp_timeout , global_data -> lvs_tcpfin_timeout , global_data -> lvs_udp_timeout ) ; ipvs_syncd_cmd ( IPVS_STOPDAEMON , NULL , IPVS_MASTER , true , true ) ; ipvs_syncd_cmd ( IPVS_STOPDAEMON , NULL , IPVS_BACKUP , true , true ) ; } # endif if ( reload ) { kernel_netlink_set_recv_bufs ( ) ; clear_diff_saddresses ( ) ; # ifdef _HAVE_FIB_ROUTING_ clear_diff_srules ( ) ; clear_diff_sroutes ( ) ; # endif clear_diff_script ( ) ; # ifdef _WITH_BFD_ clear_diff_bfd ( ) ; # endif } else { netlink_iplist ( vrrp_data -> static_addresses , IPADDRESS_DEL , false ) ; # ifdef _HAVE_FIB_ROUTING_ netlink_rtlist ( vrrp_data -> static_routes , IPROUTE_DEL ) ; netlink_error_ignore = ENOENT ; netlink_rulelist ( vrrp_data -> static_rules , IPRULE_DEL , true ) ; netlink_error_ignore = 0 ; # endif } # ifdef _WITH_DBUS_ if ( ! reload && global_data -> enable_dbus ) if ( ! dbus_start ( ) ) global_data -> enable_dbus = false ; # endif } if ( ! vrrp_complete_init ( ) ) { stop_vrrp ( KEEPALIVED_EXIT_CONFIG ) ; return ; } if ( __test_bit ( CONFIG_TEST_BIT , & debug ) ) { stop_vrrp ( KEEPALIVED_EXIT_OK ) ; return ; } if ( have_ipv4_instance ) gratuitous_arp_init ( ) ; else gratuitous_arp_close ( ) ; if ( have_ipv6_instance ) ndisc_init ( ) ; else ndisc_close ( ) ; iptables_init ( ) ; if ( vrrp_data -> vrrp_track_files ) init_track_files ( vrrp_data -> vrrp_track_files ) ; # ifdef _HAVE_LIBIPTC_ if ( ! reload ) iptables_cleanup ( ) ; iptables_startup ( reload ) ; # endif if ( ! reload ) vrrp_restore_interfaces_startup ( ) ; if ( reload ) clear_diff_vrrp ( ) ; # ifdef _WITH_DBUS_ if ( reload && global_data -> enable_dbus ) dbus_reload ( old_vrrp_data -> vrrp , vrrp_data -> vrrp ) ; # endif # ifdef _MEM_CHECK_ log_message ( LOG_INFO , "Configuration<S2SV_blank>is<S2SV_blank>using<S2SV_blank>:<S2SV_blank>%zu<S2SV_blank>Bytes" , mem_allocated ) ; # endif netlink_iplist ( vrrp_data -> static_addresses , IPADDRESS_ADD , false ) ; # ifdef _HAVE_FIB_ROUTING_ netlink_rtlist ( vrrp_data -> static_routes , IPROUTE_ADD ) ; netlink_rulelist ( vrrp_data -> static_rules , IPRULE_ADD , false ) ; # endif if ( __test_bit ( DUMP_CONF_BIT , & debug ) ) dump_data_vrrp ( NULL ) ; thread_add_event ( master , vrrp_dispatcher_init , NULL , VRRP_DISPATCHER ) ; } | <S2SV_ModStart> ( ) ; else if ( global_data -> default_ifname ) { global_data -> default_ifp = if_get_by_ifname ( global_data -> default_ifname , IF_CREATE_IF_DYNAMIC ) ; if ( ! global_data -> default_ifp ) log_message ( LOG_INFO , "WARNING<S2SV_blank>-<S2SV_blank>default<S2SV_blank>interface<S2SV_blank>%s<S2SV_blank>doesn\'t<S2SV_blank>exist" , global_data -> default_ifname ) ; } |
2,463 | CWE-000 int odp_pktio_start ( odp_pktio_t hdl ) { pktio_entry_t * entry ; odp_pktin_mode_t mode ; int res = 0 ; entry = get_pktio_entry ( hdl ) ; if ( ! entry ) return - 1 ; lock_entry ( entry ) ; if ( entry -> s . state == PKTIO_STATE_STARTED ) { unlock_entry ( entry ) ; return - 1 ; } if ( entry -> s . ops -> start ) res = entry -> s . ops -> start ( entry ) ; if ( ! res ) entry -> s . state = PKTIO_STATE_STARTED ; unlock_entry ( entry ) ; mode = entry -> s . param . in_mode ; if ( mode == ODP_PKTIN_MODE_SCHED ) { unsigned i ; unsigned num = entry -> s . num_in_queue ; int index [ num ] ; odp_queue_t odpq [ num ] ; for ( i = 0 ; i < num ; i ++ ) { index [ i ] = i ; odpq [ i ] = entry -> s . in_queue [ i ] . queue ; if ( entry -> s . in_queue [ i ] . queue == ODP_QUEUE_INVALID ) { ODP_ERR ( "No<S2SV_blank>input<S2SV_blank>queue\\n" ) ; return - 1 ; } } sched_fn -> pktio_start ( _odp_pktio_index ( hdl ) , num , index , odpq ) ; } <S2SV_StartBug> return res ; <S2SV_EndBug> } | <S2SV_ModStart> ) ; } if ( ODP_PCAPNG ) { if ( pcapng_prepare ( entry ) ) ODP_ERR ( "pcap<S2SV_blank>init<S2SV_blank>failed,<S2SV_blank>won\'t<S2SV_blank>capture\\n" ) ; } |
2,464 | CWE-000 hdd_adapter_t * hdd_wlan_create_ap_dev ( hdd_context_t * pHddCtx , tSirMacAddr macAddr , tANI_U8 * iface_name ) { struct net_device * pWlanHostapdDev = NULL ; hdd_adapter_t * pHostapdAdapter = NULL ; v_CONTEXT_t pVosContext = NULL ; hddLog ( VOS_TRACE_LEVEL_DEBUG , "%s:<S2SV_blank>iface_name<S2SV_blank>=<S2SV_blank>%s" , __func__ , iface_name ) ; pWlanHostapdDev = alloc_netdev_mq ( sizeof ( hdd_adapter_t ) , iface_name , ether_setup , NUM_TX_QUEUES ) ; if ( pWlanHostapdDev != NULL ) { pHostapdAdapter = netdev_priv ( pWlanHostapdDev ) ; ether_setup ( pWlanHostapdDev ) ; vos_mem_zero ( pHostapdAdapter , sizeof ( hdd_adapter_t ) ) ; pHostapdAdapter -> dev = pWlanHostapdDev ; pHostapdAdapter -> pHddCtx = pHddCtx ; pHostapdAdapter -> magic = WLAN_HDD_ADAPTER_MAGIC ; hddLog ( VOS_TRACE_LEVEL_DEBUG , "%s:<S2SV_blank>pWlanHostapdDev<S2SV_blank>=<S2SV_blank>%p,<S2SV_blank>" "pHostapdAdapter<S2SV_blank>=<S2SV_blank>%p,<S2SV_blank>" "concurrency_mode=0x%x" , __func__ , pWlanHostapdDev , pHostapdAdapter , ( int ) vos_get_concurrency_mode ( ) ) ; pVosContext = vos_get_global_context ( VOS_MODULE_ID_SYS , NULL ) ; ( ( VosContextType * ) ( pVosContext ) ) -> pHDDSoftAPContext = ( v_VOID_t * ) pHostapdAdapter ; strlcpy ( pWlanHostapdDev -> name , ( const char * ) iface_name , IFNAMSIZ ) ; hdd_set_ap_ops ( pHostapdAdapter -> dev ) ; pWlanHostapdDev -> watchdog_timeo = HDD_TX_TIMEOUT ; pWlanHostapdDev -> mtu = HDD_DEFAULT_MTU ; <S2SV_StartBug> vos_mem_copy ( pWlanHostapdDev -> dev_addr , ( void * ) macAddr , sizeof ( tSirMacAddr ) ) ; <S2SV_EndBug> vos_mem_copy ( pHostapdAdapter -> macAddressCurrent . bytes , ( void * ) macAddr , sizeof ( tSirMacAddr ) ) ; pHostapdAdapter -> offloads_configured = FALSE ; pWlanHostapdDev -> destructor = free_netdev ; pWlanHostapdDev -> ieee80211_ptr = & pHostapdAdapter -> wdev ; pHostapdAdapter -> wdev . wiphy = pHddCtx -> wiphy ; pHostapdAdapter -> wdev . netdev = pWlanHostapdDev ; init_completion ( & pHostapdAdapter -> tx_action_cnf_event ) ; init_completion ( & pHostapdAdapter -> cancel_rem_on_chan_var ) ; init_completion ( & pHostapdAdapter -> rem_on_chan_ready_event ) ; init_completion ( & pHostapdAdapter -> ula_complete ) ; init_completion ( & pHostapdAdapter -> offchannel_tx_event ) ; init_completion ( & pHostapdAdapter -> scan_info . scan_req_completion_event ) ; init_completion ( & pHostapdAdapter -> scan_info . abortscan_event_var ) ; vos_event_init ( & pHostapdAdapter -> scan_info . scan_finished_event ) ; pHostapdAdapter -> scan_info . scan_pending_option = WEXT_SCAN_PENDING_GIVEUP ; SET_NETDEV_DEV ( pWlanHostapdDev , pHddCtx -> parent_dev ) ; } return pHostapdAdapter ; } | <S2SV_ModStart> = HDD_DEFAULT_MTU ; pWlanHostapdDev -> tx_queue_len = HDD_NETDEV_TX_QUEUE_LEN ; |
2,465 | CWE-000 void analyse_exp_is_assignop ( node_t * root ) { node_t * exp1 = get_child_node_w ( root , Exp ) ; node_t * exp2 = get_child_node_with_skip_w ( root , Exp , 1 ) ; root -> dt = exp1 -> dt ; root -> eni . et . lrv = exp1 -> eni . et . lrv ; <S2SV_StartBug> check_type_assignable ( exp1 , exp2 ) ; <S2SV_EndBug> } | <S2SV_ModStart> . lrv ; if ( exp1 -> eni . et . lrv == ExpTypeRightValue ) error_at ( exp1 , "expression<S2SV_blank>is<S2SV_blank>not<S2SV_blank>assignable" ) ; |
2,466 | CWE-000 node * SAfor ( node * arg_node , info * arg_info ) { DBUG_ENTER ( "SAfor" ) ; DBUG_PRINT ( "SA" , ( "Processing<S2SV_blank>the<S2SV_blank>start,<S2SV_blank>stop<S2SV_blank>and<S2SV_blank>step<S2SV_blank>expressions." ) ) ; node * varDef = FOR_VARDEF ( arg_node ) ; TRAVdo ( VARDEF_EXPR ( varDef ) , arg_info ) ; TRAVdo ( FOR_FINISH ( arg_node ) , arg_info ) ; TRAVopt ( FOR_STEP ( arg_node ) , arg_info ) ; DBUG_PRINT ( "SA" , ( "Looking<S2SV_blank>for<S2SV_blank>existing<S2SV_blank>name." ) ) ; char * name = VARDEF_NAME ( varDef ) ; node * existingVarDef = findWithinScope ( INFO_CURSCOPE ( arg_info ) , name , STE_vardef ) ; char * originalName = NULL ; if ( existingVarDef ) { DBUG_PRINT ( "SA" , ( "Hiding<S2SV_blank>the<S2SV_blank>existing<S2SV_blank>name<S2SV_blank>in<S2SV_blank>the<S2SV_blank>symboltable<S2SV_blank>for<S2SV_blank>now." ) ) ; originalName = SYMBOLTABLEENTRY_NAME ( existingVarDef ) ; SYMBOLTABLEENTRY_NAME ( existingVarDef ) = "" ; } node * forVarEntry = registerWithinCurrentScope ( INFO_CURSCOPE ( arg_info ) , varDef , name , STE_vardef , TY_int ) ; VARDEF_STE ( varDef ) = forVarEntry ; SYMBOLTABLEENTRY_DEFNODE ( forVarEntry ) = varDef ; SYMBOLTABLEENTRY_OFFSET ( forVarEntry ) = SYMBOLTABLE_VARIABLES ( INFO_CURSCOPE ( arg_info ) ) ++ ; DBUG_PRINT ( "SA" , ( "Processing<S2SV_blank>the<S2SV_blank>block." ) ) ; FOR_BLOCK ( arg_node ) = TRAVopt ( FOR_BLOCK ( arg_node ) , arg_info ) ; if ( existingVarDef ) { DBUG_PRINT ( "SA" , ( "Restoring<S2SV_blank>the<S2SV_blank>original<S2SV_blank>name<S2SV_blank>and<S2SV_blank>generating<S2SV_blank>a<S2SV_blank>unique<S2SV_blank>name." ) ) ; SYMBOLTABLEENTRY_NAME ( existingVarDef ) = originalName ; <S2SV_StartBug> SYMBOLTABLEENTRY_NAME ( forVarEntry ) = createUniqueNameForSymbolTable ( INFO_CURSCOPE ( arg_info ) , name , STE_vardef ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> DBUG_RETURN ( arg_node ) ; } | <S2SV_ModStart> = originalName ; } <S2SV_ModStart> STE_vardef ) ; <S2SV_ModEnd> DBUG_RETURN ( arg_node |
2,467 | CWE-000 <S2SV_StartBug> void onDemand_notifyDebuggingStarted ( ) { <S2SV_EndBug> LOG_MISC ( ( "Notifying<S2SV_blank>debugging<S2SV_blank>session<S2SV_blank>started." ) ) ; debugMonitorEnter ( onDemandMonitor ) ; if ( onDemandCurrentState != ON_DEMAND_WAITING_FOR_CONNECTION ) { LOG_MISC ( ( "Unexpected<S2SV_blank>state<S2SV_blank>%d<S2SV_blank>when<S2SV_blank>starting<S2SV_blank>debugging" , onDemandCurrentState ) ) ; } else { onDemandCurrentState = ON_DEMAND_CONNECTED ; debugMonitorNotifyAll ( onDemandMonitor ) ; } debugMonitorExit ( onDemandMonitor ) ; } | <S2SV_ModStart> ( ) { if ( ! onDemand_isEnabled ( ) ) { return ; } |
2,468 | CWE-000 static u32 ena_com_reg_bar_read32 ( struct ena_com_dev * ena_dev , u16 offset ) { struct ena_com_mmio_read * mmio_read = & ena_dev -> mmio_read ; volatile struct ena_admin_ena_mmio_req_read_less_resp * read_resp = mmio_read -> read_resp ; <S2SV_StartBug> u32 mmio_read_reg , timeout , ret ; <S2SV_EndBug> unsigned long flags ; <S2SV_StartBug> int i ; <S2SV_EndBug> might_sleep ( ) ; <S2SV_StartBug> timeout = mmio_read -> reg_read_to ? : ENA_REG_READ_TIMEOUT ; <S2SV_EndBug> if ( ! mmio_read -> readless_supported ) return readl ( ena_dev -> reg_bar + offset ) ; spin_lock_irqsave ( & mmio_read -> lock , flags ) ; mmio_read -> seq_num ++ ; read_resp -> req_id = mmio_read -> seq_num + 0xDEAD ; mmio_read_reg = ( offset << ENA_REGS_MMIO_REG_READ_REG_OFF_SHIFT ) & ENA_REGS_MMIO_REG_READ_REG_OFF_MASK ; mmio_read_reg |= mmio_read -> seq_num & ENA_REGS_MMIO_REG_READ_REQ_ID_MASK ; wmb ( ) ; writel ( mmio_read_reg , ena_dev -> reg_bar + ENA_REGS_MMIO_REG_READ_OFF ) ; for ( i = 0 ; i < timeout ; i ++ ) { if ( read_resp -> req_id == mmio_read -> seq_num ) break ; udelay ( 1 ) ; } if ( unlikely ( i == timeout ) ) { pr_err ( "reading<S2SV_blank>reg<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>timeout.<S2SV_blank>expected:<S2SV_blank>req<S2SV_blank>id[%hu]<S2SV_blank>offset[%hu]<S2SV_blank>actual:<S2SV_blank>req<S2SV_blank>id[%hu]<S2SV_blank>offset[%hu]\\n" , mmio_read -> seq_num , offset , read_resp -> req_id , read_resp -> reg_off ) ; ret = ENA_MMIO_READ_TIMEOUT ; goto err ; } if ( read_resp -> reg_off != offset ) { pr_err ( "Read<S2SV_blank>failure:<S2SV_blank>wrong<S2SV_blank>offset<S2SV_blank>provided" ) ; ret = ENA_MMIO_READ_TIMEOUT ; } else { ret = read_resp -> reg_val ; } err : spin_unlock_irqrestore ( & mmio_read -> lock , flags ) ; return ret ; } | <S2SV_ModStart> u32 mmio_read_reg , ret , i <S2SV_ModEnd> ; unsigned long <S2SV_ModStart> long flags ; u32 timeout = mmio_read -> reg_read_to <S2SV_ModEnd> ; might_sleep ( <S2SV_ModStart> ( ) ; if ( timeout == 0 ) timeout = <S2SV_ModEnd> ENA_REG_READ_TIMEOUT ; if |
2,469 | CWE-000 void * msort ( void * th_ ) { Tmst * th = ( Tmst * ) th_ ; char * ch = "b" ; unsigned int lineno = 1 ; fseek ( th -> ln_0 -> fp , th -> lineno_ [ 0 ] + 1 , SEEK_SET ) ; switch ( th -> i ) { case 0 : strcpy ( th -> ln_0 -> ecp -> id , ID0 ) ; break ; case 1 : strcpy ( th -> ln_0 -> ecp -> id , ID1 ) ; break ; case 2 : strcpy ( th -> ln_0 -> ecp -> id , ID2 ) ; break ; case 3 : strcpy ( th -> ln_0 -> ecp -> id , ID3 ) ; break ; case 4 : strcpy ( th -> ln_0 -> ecp -> id , ID4 ) ; break ; case 5 : strcpy ( th -> ln_0 -> ecp -> id , ID5 ) ; break ; case 6 : strcpy ( th -> ln_0 -> ecp -> id , ID6 ) ; break ; case 7 : strcpy ( th -> ln_0 -> ecp -> id , ID7 ) ; break ; <S2SV_StartBug> default : fprintf ( stderr , "\\nError<S2SV_blank>switch(i)<S2SV_blank>line<S2SV_blank>62<S2SV_blank>in<S2SV_blank>idsort.c\\n" ) ; <S2SV_EndBug> exit ( - 45 ) ; } <S2SV_StartBug> unsigned int err_no_ids_found = 0 ; <S2SV_EndBug> unsigned int lim = ( INSTALLED_IDS * 3 ) + 1 ; bool called = true ; while ( ( ch != NULL ) ) { <S2SV_StartBug> if ( ( err_no_ids_found > lim ) && ( called ) ) { <S2SV_EndBug> fprintf ( stderr , "The<S2SV_blank>string<S2SV_blank><%s><S2SV_blank>wasn\'t<S2SV_blank>found<S2SV_blank>in<S2SV_blank>the<S2SV_blank>file<S2SV_blank>until<S2SV_blank>line(%ud)<S2SV_blank>are<S2SV_blank>you<S2SV_blank>" "sure<S2SV_blank>you<S2SV_blank>entered<S2SV_blank>the<S2SV_blank>correct<S2SV_blank>file<S2SV_blank>or<S2SV_blank>the<S2SV_blank>correct<S2SV_blank>ID<S2SV_blank>in<S2SV_blank>config.c?\\n" , th -> ln_0 -> ecp -> id , ( INSTALLED_IDS * 3 ) + 2 ) ; fprintf ( stderr , "The<S2SV_blank>program<S2SV_blank>will<S2SV_blank>continue<S2SV_blank>to<S2SV_blank>work<S2SV_blank>but<S2SV_blank>won\'t<S2SV_blank>show<S2SV_blank>this<S2SV_blank>error<S2SV_blank>for\\n" "this<S2SV_blank>tmpfile<S2SV_blank>again.\\n" ) ; called = false ; } ch = fgets ( th -> line , th -> lineno_ [ lineno ] + 2 , th -> ln_0 -> fp ) ; if ( strstr ( th -> line , th -> ln_0 -> ecp -> id ) != NULL ) { fprintf ( th -> ln_0 -> ecp -> tmp , "%s" , th -> line ) ; <S2SV_StartBug> err_no_ids_found = 0 ; <S2SV_EndBug> } else { err_no_ids_found ++ ; } fflush ( th -> ln_0 -> ecp -> tmp ) ; lineno ++ ; } pthread_exit ( 0 ) ; } | <S2SV_ModStart> ( stderr , "\\nError<S2SV_blank>switch(i)<S2SV_blank>in<S2SV_blank>idsort.c\\n" <S2SV_ModEnd> ) ; exit <S2SV_ModStart> ) ; } <S2SV_ModEnd> while ( ( <S2SV_ModStart> ) ) { <S2SV_ModEnd> ch = fgets <S2SV_ModStart> line ) ; <S2SV_ModEnd> } fflush ( |
2,470 | CWE-000 <S2SV_StartBug> static void wait_for_pager_atexit ( void ) <S2SV_EndBug> <S2SV_StartBug> { <S2SV_EndBug> wait_for_pager ( 0 ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> <S2SV_ModEnd> void wait_for_pager_atexit ( <S2SV_ModStart> void ) { if ( run_wait_for_pager_atexit ) |
2,471 | CWE-000 int main ( int argc , const char * * argv ) { printf ( "AppSync<S2SV_blank>Unified\\n" ) ; <S2SV_StartBug> printf ( "Copyright<S2SV_blank>(C)<S2SV_blank>2014-2017<S2SV_blank>Linus<S2SV_blank>Yang,<S2SV_blank>Karen／明美<S2SV_blank>(angelXwind)\\n" ) ; <S2SV_EndBug> printf ( "**<S2SV_blank>PLEASE<S2SV_blank>DO<S2SV_blank>NOT<S2SV_blank>USE<S2SV_blank>APPSYNC<S2SV_blank>UNIFIED<S2SV_blank>FOR<S2SV_blank>PIRACY<S2SV_blank>**\\n" ) ; if ( access ( DPKG_PATH , F_OK ) == - 1 ) { printf ( "You<S2SV_blank>seem<S2SV_blank>to<S2SV_blank>have<S2SV_blank>installed<S2SV_blank>AppSync<S2SV_blank>Unified<S2SV_blank>from<S2SV_blank>an<S2SV_blank>APT<S2SV_blank>repository<S2SV_blank>that<S2SV_blank>is<S2SV_blank>not<S2SV_blank>cydia.angelxwind.net<S2SV_blank>(package<S2SV_blank>ID<S2SV_blank>net.angelxwind.appsyncunified).\\n" ) ; printf ( "If<S2SV_blank>someone<S2SV_blank>other<S2SV_blank>than<S2SV_blank>Linus<S2SV_blank>Yang<S2SV_blank>(laokongzi)<S2SV_blank>or<S2SV_blank>Karen／明美<S2SV_blank>(angelXwind)<S2SV_blank>is<S2SV_blank>taking<S2SV_blank>credit<S2SV_blank>for<S2SV_blank>the<S2SV_blank>development<S2SV_blank>of<S2SV_blank>this<S2SV_blank>tool,<S2SV_blank>they<S2SV_blank>are<S2SV_blank>likely<S2SV_blank>lying.\\n" ) ; printf ( "Please<S2SV_blank>only<S2SV_blank>download<S2SV_blank>AppSync<S2SV_blank>Unified<S2SV_blank>from<S2SV_blank>the<S2SV_blank>official<S2SV_blank>repository<S2SV_blank>to<S2SV_blank>ensure<S2SV_blank>file<S2SV_blank>integrity<S2SV_blank>and<S2SV_blank>reliability.\\n" ) ; } if ( geteuid ( ) != 0 ) { printf ( "FATAL:<S2SV_blank>This<S2SV_blank>binary<S2SV_blank>must<S2SV_blank>be<S2SV_blank>run<S2SV_blank>as<S2SV_blank>root.\\n" ) ; return 1 ; } <S2SV_StartBug> if ( kCFCoreFoundationVersionNumber >= kCFCoreFoundationVersionNumber_iOS_8_0 && kCFCoreFoundationVersionNumber < kCFCoreFoundationVersionNumber_iOS_10_0 ) { <S2SV_EndBug> # ifdef POSTINST if ( access ( INSTALLD_PLIST_PATH_L , F_OK ) == - 1 ) { <S2SV_StartBug> printf ( "Current<S2SV_blank>iOS<S2SV_blank>version<S2SV_blank>is<S2SV_blank>iOS<S2SV_blank>8/9,<S2SV_blank>symlinking<S2SV_blank>installd<S2SV_blank>plist...\\n" ) ; <S2SV_EndBug> symlink ( INSTALLD_PLIST_PATH_SL , INSTALLD_PLIST_PATH_L ) ; } # endif run_launchctl ( INSTALLD_PLIST_PATH_L , "unload" ) ; run_launchctl ( INSTALLD_PLIST_PATH_L , "load" ) ; } else { run_launchctl ( INSTALLD_PLIST_PATH_SL , "unload" ) ; run_launchctl ( INSTALLD_PLIST_PATH_SL , "load" ) ; } # ifdef __LP64__ printf ( "Current<S2SV_blank>device<S2SV_blank>architecture<S2SV_blank>is<S2SV_blank>64-bit,<S2SV_blank>disabling<S2SV_blank>asu_inject...\\n" ) ; unlink ( ASU_INJECT_PLIST_PATH ) ; # else <S2SV_StartBug> if ( kCFCoreFoundationVersionNumber >= kCFCoreFoundationVersionNumber_iOS_9_3 ) { <S2SV_EndBug> printf ( "Current<S2SV_blank>device<S2SV_blank>architecture<S2SV_blank>is<S2SV_blank>32-bit<S2SV_blank>running<S2SV_blank>iOS<S2SV_blank>>=<S2SV_blank>9.3,<S2SV_blank>enabling<S2SV_blank>asu_inject...\\n" ) ; chown ( ASU_INJECT_PLIST_PATH , 0 , 0 ) ; chmod ( ASU_INJECT_PLIST_PATH , 0644 ) ; run_launchctl ( ASU_INJECT_PLIST_PATH , "unload" ) ; # ifdef POSTINST run_launchctl ( ASU_INJECT_PLIST_PATH , "load" ) ; # endif <S2SV_StartBug> } <S2SV_EndBug> # endif return 0 ; } | <S2SV_ModStart> ; printf ( "Copyright<S2SV_blank>(C)<S2SV_blank>2014-2018<S2SV_blank>Linus<S2SV_blank>Yang,<S2SV_blank>Karen／明美<S2SV_blank>(angelXwind)\\n" <S2SV_ModEnd> ) ; printf <S2SV_ModStart> } if ( ( <S2SV_ModStart> kCFCoreFoundationVersionNumber >= kCFCoreFoundationVersionNumber_iOS_8_0 ) && ( <S2SV_ModEnd> kCFCoreFoundationVersionNumber < kCFCoreFoundationVersionNumber_iOS_10_0 <S2SV_ModStart> kCFCoreFoundationVersionNumber < kCFCoreFoundationVersionNumber_iOS_10_0 ) <S2SV_ModStart> { printf ( "Current<S2SV_blank>iOS<S2SV_blank>version<S2SV_blank>is<S2SV_blank>iOS<S2SV_blank>8<S2SV_blank>or<S2SV_blank>9,<S2SV_blank>creating<S2SV_blank>symbolic<S2SV_blank>link<S2SV_blank>to<S2SV_blank>installd<S2SV_blank>plist...\\n" <S2SV_ModEnd> ) ; symlink <S2SV_ModStart> else if ( ( <S2SV_ModStart> >= kCFCoreFoundationVersionNumber_iOS_9_3 ) && ( kCFCoreFoundationVersionNumber < kCFCoreFoundationVersionNumber_iOS_10_0 ) ) { printf ( "Current<S2SV_blank>device<S2SV_blank>is<S2SV_blank>running<S2SV_blank>32-bit<S2SV_blank>iOS<S2SV_blank>9.3.x,<S2SV_blank>enabling<S2SV_blank>asu_inject<S2SV_blank>as<S2SV_blank>a<S2SV_blank>workaround<S2SV_blank>for<S2SV_blank>a<S2SV_blank>Phoenix<S2SV_blank>bug...\\n" <S2SV_ModEnd> ) ; chown <S2SV_ModStart> # endif } else { unlink ( ASU_INJECT_PLIST_PATH ) ; } |
2,472 | CWE-000 static void verify_space ( lispobj * start , size_t words ) { extern int valid_lisp_pointer_p ( lispobj ) ; int is_in_dynamic_space = ( find_page_index ( ( void * ) start ) != - 1 ) ; int is_in_readonly_space = ( READ_ONLY_SPACE_START <= ( uword_t ) start && ( uword_t ) start < SymbolValue ( READ_ONLY_SPACE_FREE_POINTER , 0 ) ) ; # ifdef LISP_FEATURE_IMMOBILE_SPACE int is_in_immobile_space = ( IMMOBILE_SPACE_START <= ( uword_t ) start && ( uword_t ) start < SymbolValue ( IMMOBILE_SPACE_FREE_POINTER , 0 ) ) ; # endif while ( words > 0 ) { size_t count = 1 ; lispobj thing = * start ; if ( is_lisp_pointer ( thing ) ) { page_index_t page_index = find_page_index ( ( void * ) thing ) ; sword_t to_readonly_space = ( READ_ONLY_SPACE_START <= thing && thing < SymbolValue ( READ_ONLY_SPACE_FREE_POINTER , 0 ) ) ; sword_t to_static_space = ( STATIC_SPACE_START <= thing && thing < SymbolValue ( STATIC_SPACE_FREE_POINTER , 0 ) ) ; # ifdef LISP_FEATURE_IMMOBILE_SPACE sword_t to_immobile_space = ( IMMOBILE_SPACE_START <= thing && thing < SymbolValue ( IMMOBILE_FIXEDOBJ_FREE_POINTER , 0 ) ) || ( IMMOBILE_VARYOBJ_SUBSPACE_START <= thing && thing < SymbolValue ( IMMOBILE_SPACE_FREE_POINTER , 0 ) ) ; # endif if ( page_index != - 1 ) { if ( ! page_allocated_p ( page_index ) ) lose ( "Ptr<S2SV_blank>%p<S2SV_blank>@<S2SV_blank>%p<S2SV_blank>sees<S2SV_blank>free<S2SV_blank>page.\\n" , thing , start ) ; if ( ( char * ) thing - ( char * ) page_address ( page_index ) >= page_table [ page_index ] . bytes_used ) lose ( "Ptr<S2SV_blank>%p<S2SV_blank>@<S2SV_blank>%p<S2SV_blank>sees<S2SV_blank>unallocated<S2SV_blank>space.\\n" , thing , start ) ; if ( * ( ( lispobj * ) native_pointer ( thing ) ) == 0x01 ) { lose ( "Ptr<S2SV_blank>%p<S2SV_blank>@<S2SV_blank>%p<S2SV_blank>sees<S2SV_blank>forwarding<S2SV_blank>ptr.\\n" , thing , start ) ; } if ( is_in_readonly_space ) { lose ( "ptr<S2SV_blank>to<S2SV_blank>dynamic<S2SV_blank>space<S2SV_blank>%p<S2SV_blank>from<S2SV_blank>RO<S2SV_blank>space<S2SV_blank>%x\\n" , thing , start ) ; } # ifdef LISP_FEATURE_IMMOBILE_SPACE if ( is_in_immobile_space && ! valid_lisp_pointer_p ( thing ) ) { lose ( "Ptr<S2SV_blank>%p<S2SV_blank>@<S2SV_blank>%p<S2SV_blank>sees<S2SV_blank>junk.\\n" , thing , start ) ; } # endif # ifdef LISP_FEATURE_IMMOBILE_SPACE } else if ( to_immobile_space ) { if ( ! other_immediate_lowtag_p ( * native_pointer ( thing ) ) || immobile_filler_p ( native_pointer ( thing ) ) ) lose ( "Ptr<S2SV_blank>%p<S2SV_blank>@<S2SV_blank>%p<S2SV_blank>sees<S2SV_blank>trashed<S2SV_blank>object.\\n" , ( void * ) thing , start ) ; if ( ! valid_lisp_pointer_p ( thing ) ) lose ( "Ptr<S2SV_blank>%p<S2SV_blank>@<S2SV_blank>%p<S2SV_blank>sees<S2SV_blank>junk.\\n" , thing , start ) ; # endif } else { extern char __attribute__ ( ( unused ) ) funcallable_instance_tramp ; if ( ! to_readonly_space && ! to_static_space && ! is_in_stack_space ( thing ) ) { lose ( "Ptr<S2SV_blank>%p<S2SV_blank>@<S2SV_blank>%p<S2SV_blank>sees<S2SV_blank>junk.\\n" , thing , start ) ; } } } else { if ( ! ( fixnump ( thing ) ) ) { switch ( widetag_of ( * start ) ) { case SIMPLE_VECTOR_WIDETAG : case RATIO_WIDETAG : case COMPLEX_WIDETAG : case SIMPLE_ARRAY_WIDETAG : case COMPLEX_BASE_STRING_WIDETAG : # ifdef COMPLEX_CHARACTER_STRING_WIDETAG case COMPLEX_CHARACTER_STRING_WIDETAG : # endif case COMPLEX_VECTOR_NIL_WIDETAG : case COMPLEX_BIT_VECTOR_WIDETAG : case COMPLEX_VECTOR_WIDETAG : case COMPLEX_ARRAY_WIDETAG : case CLOSURE_HEADER_WIDETAG : case FUNCALLABLE_INSTANCE_HEADER_WIDETAG : case VALUE_CELL_HEADER_WIDETAG : case SYMBOL_HEADER_WIDETAG : case CHARACTER_WIDETAG : # if N_WORD_BITS == 64 case SINGLE_FLOAT_WIDETAG : # endif case UNBOUND_MARKER_WIDETAG : case FDEFN_WIDETAG : count = 1 ; break ; case INSTANCE_HEADER_WIDETAG : <S2SV_StartBug> { <S2SV_EndBug> <S2SV_StartBug> lispobj layout = instance_layout ( start ) ; <S2SV_EndBug> if ( ! layout ) { count = 1 ; break ; } sword_t nslots = instance_length ( thing ) | 1 ; <S2SV_StartBug> instance_scan_interleaved ( verify_space , start + 1 , nslots , <S2SV_EndBug> <S2SV_StartBug> native_pointer ( layout ) ) ; <S2SV_EndBug> count = 1 + nslots ; <S2SV_StartBug> break ; <S2SV_EndBug> } case CODE_HEADER_WIDETAG : { if ( is_in_dynamic_space && verify_dynamic_code_check ) { FSHOW ( ( stderr , "/code<S2SV_blank>object<S2SV_blank>at<S2SV_blank>%p<S2SV_blank>in<S2SV_blank>the<S2SV_blank>dynamic<S2SV_blank>space\\n" , start ) ) ; } struct code * code = ( struct code * ) start ; sword_t nheader_words = code_header_words ( code -> header ) ; verify_space ( start + 1 , nheader_words - 1 ) ; for_each_simple_fun ( i , fheaderp , code , 1 , { verify_space ( SIMPLE_FUN_SCAV_START ( fheaderp ) , SIMPLE_FUN_SCAV_NWORDS ( fheaderp ) ) ; } ) ; count = nheader_words + code_instruction_words ( code -> code_size ) ; break ; } case BIGNUM_WIDETAG : # if N_WORD_BITS != 64 case SINGLE_FLOAT_WIDETAG : # endif case DOUBLE_FLOAT_WIDETAG : # ifdef COMPLEX_LONG_FLOAT_WIDETAG case LONG_FLOAT_WIDETAG : # endif # ifdef COMPLEX_SINGLE_FLOAT_WIDETAG case COMPLEX_SINGLE_FLOAT_WIDETAG : # endif # ifdef COMPLEX_DOUBLE_FLOAT_WIDETAG case COMPLEX_DOUBLE_FLOAT_WIDETAG : # endif # ifdef COMPLEX_LONG_FLOAT_WIDETAG case COMPLEX_LONG_FLOAT_WIDETAG : # endif # ifdef SIMD_PACK_WIDETAG case SIMD_PACK_WIDETAG : # endif case SIMPLE_BASE_STRING_WIDETAG : # ifdef SIMPLE_CHARACTER_STRING_WIDETAG case SIMPLE_CHARACTER_STRING_WIDETAG : # endif case SIMPLE_BIT_VECTOR_WIDETAG : case SIMPLE_ARRAY_NIL_WIDETAG : case SIMPLE_ARRAY_UNSIGNED_BYTE_2_WIDETAG : case SIMPLE_ARRAY_UNSIGNED_BYTE_4_WIDETAG : case SIMPLE_ARRAY_UNSIGNED_BYTE_7_WIDETAG : case SIMPLE_ARRAY_UNSIGNED_BYTE_8_WIDETAG : case SIMPLE_ARRAY_UNSIGNED_BYTE_15_WIDETAG : case SIMPLE_ARRAY_UNSIGNED_BYTE_16_WIDETAG : case SIMPLE_ARRAY_UNSIGNED_FIXNUM_WIDETAG : case SIMPLE_ARRAY_UNSIGNED_BYTE_31_WIDETAG : case SIMPLE_ARRAY_UNSIGNED_BYTE_32_WIDETAG : # ifdef SIMPLE_ARRAY_UNSIGNED_BYTE_63_WIDETAG case SIMPLE_ARRAY_UNSIGNED_BYTE_63_WIDETAG : # endif # ifdef SIMPLE_ARRAY_UNSIGNED_BYTE_64_WIDETAG case SIMPLE_ARRAY_UNSIGNED_BYTE_64_WIDETAG : # endif # ifdef SIMPLE_ARRAY_SIGNED_BYTE_8_WIDETAG case SIMPLE_ARRAY_SIGNED_BYTE_8_WIDETAG : # endif # ifdef SIMPLE_ARRAY_SIGNED_BYTE_16_WIDETAG case SIMPLE_ARRAY_SIGNED_BYTE_16_WIDETAG : # endif case SIMPLE_ARRAY_FIXNUM_WIDETAG : # ifdef SIMPLE_ARRAY_SIGNED_BYTE_32_WIDETAG case SIMPLE_ARRAY_SIGNED_BYTE_32_WIDETAG : # endif # ifdef SIMPLE_ARRAY_SIGNED_BYTE_64_WIDETAG case SIMPLE_ARRAY_SIGNED_BYTE_64_WIDETAG : # endif case SIMPLE_ARRAY_SINGLE_FLOAT_WIDETAG : case SIMPLE_ARRAY_DOUBLE_FLOAT_WIDETAG : # ifdef SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG case SIMPLE_ARRAY_LONG_FLOAT_WIDETAG : # endif # ifdef SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG case SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG : # endif # ifdef SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG case SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG : # endif # ifdef SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG case SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG : # endif case SAP_WIDETAG : case WEAK_POINTER_WIDETAG : # ifdef NO_TLS_VALUE_MARKER_WIDETAG case NO_TLS_VALUE_MARKER_WIDETAG : # endif count = ( sizetab [ widetag_of ( * start ) ] ) ( start ) ; break ; default : lose ( "Unhandled<S2SV_blank>widetag<S2SV_blank>%p<S2SV_blank>at<S2SV_blank>%p\\n" , widetag_of ( * start ) , start ) ; } } } start += count ; words -= count ; } } | <S2SV_ModStart> case INSTANCE_HEADER_WIDETAG : if ( instance_layout ( start ) ) { lispobj bitmap = ( ( struct layout * ) native_pointer ( <S2SV_ModEnd> instance_layout ( start <S2SV_ModStart> ( start ) ) ) -> bitmap ; <S2SV_ModEnd> sword_t nslots = <S2SV_ModStart> | 1 ; instance_scan <S2SV_ModEnd> ( verify_space , <S2SV_ModStart> , nslots , bitmap <S2SV_ModEnd> ) ; count <S2SV_ModStart> + nslots ; } else { count = 1 ; } break ; <S2SV_ModEnd> case CODE_HEADER_WIDETAG : |
2,473 | CWE-000 err_t eth_arch_enetif_init ( struct netif * netif ) { err_t error = ERR_OK ; struct ethernetif * ethernetif ; <S2SV_StartBug> ethernetif -> is_enabled = 0 ; <S2SV_EndBug> LWIP_ASSERT ( "netif<S2SV_blank>!=<S2SV_blank>NULL" , ( netif != NULL ) ) ; ethernetif = mem_malloc ( sizeof ( struct ethernetif ) ) ; if ( ethernetif == NULL ) { LWIP_DEBUGF ( NETIF_DEBUG , ( "ethernetif_init:<S2SV_blank>out<S2SV_blank>of<S2SV_blank>memory\\n" ) ) ; return ERR_MEM ; <S2SV_StartBug> } <S2SV_EndBug> # if LWIP_NETIF_HOSTNAME netif -> hostname = HOSTNAME_STRING ; # endif MIB2_INIT_NETIF ( netif , snmp_ifType_ethernet_csmacd , LINK_SPEED_OF_YOUR_NETIF_IN_BPS ) ; netif -> state = ethernetif ; netif -> name [ 0 ] = 'e' ; netif -> name [ 1 ] = 'n' ; netif -> output = etharp_output ; # if LWIP_IPV6 netif -> output_ip6 = ethip6_output ; # endif netif -> linkoutput = low_level_output ; ethernetif -> ethaddr = ( struct eth_addr * ) & ( netif -> hwaddr [ 0 ] ) ; error = low_level_init ( netif ) ; if ( error == ERR_OK ) { sys_thread_new ( "receive_thread" , packet_rx , netif , DEFAULT_THREAD_STACKSIZE , osPriorityNormal ) ; sys_sem_new ( & rx_ready_sem , 0 ) ; ethernetif -> is_enabled = 1 ; } return error ; } | <S2SV_ModStart> * ethernetif ; <S2SV_ModEnd> LWIP_ASSERT ( "netif<S2SV_blank>!=<S2SV_blank>NULL" <S2SV_ModStart> ERR_MEM ; } ethernetif -> is_enabled = 0 ; |
2,474 | CWE-000 int qla_nvme_register_remote ( scsi_qla_host_t * vha , fc_port_t * fcport ) { <S2SV_StartBug> # if ( IS_ENABLED ( CONFIG_NVME_FC ) ) <S2SV_EndBug> struct nvme_rport * rport ; int ret ; <S2SV_StartBug> if ( fcport -> nvme_flag & NVME_FLAG_REGISTERED ) <S2SV_EndBug> return 0 ; if ( ! vha -> flags . nvme_enabled ) { ql_log ( ql_log_info , vha , 0x2100 , "%s:<S2SV_blank>Not<S2SV_blank>registering<S2SV_blank>target<S2SV_blank>since<S2SV_blank>Host<S2SV_blank>NVME<S2SV_blank>is<S2SV_blank>not<S2SV_blank>enabled\\n" , __func__ ) ; return 0 ; } if ( ! ( fcport -> nvme_prli_service_param & ( NVME_PRLI_SP_TARGET | NVME_PRLI_SP_DISCOVERY ) ) ) return 0 ; INIT_WORK ( & fcport -> nvme_del_work , qla_nvme_unregister_remote_port ) ; rport = kzalloc ( sizeof ( * rport ) , GFP_KERNEL ) ; if ( ! rport ) { ql_log ( ql_log_warn , vha , 0x2101 , "%s:<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>alloc<S2SV_blank>memory\\n" , __func__ ) ; return - ENOMEM ; } rport -> req . port_name = wwn_to_u64 ( fcport -> port_name ) ; rport -> req . node_name = wwn_to_u64 ( fcport -> node_name ) ; rport -> req . port_role = 0 ; if ( fcport -> nvme_prli_service_param & NVME_PRLI_SP_INITIATOR ) rport -> req . port_role = FC_PORT_ROLE_NVME_INITIATOR ; if ( fcport -> nvme_prli_service_param & NVME_PRLI_SP_TARGET ) rport -> req . port_role |= FC_PORT_ROLE_NVME_TARGET ; if ( fcport -> nvme_prli_service_param & NVME_PRLI_SP_DISCOVERY ) rport -> req . port_role |= FC_PORT_ROLE_NVME_DISCOVERY ; rport -> req . port_id = fcport -> d_id . b24 ; ql_log ( ql_log_info , vha , 0x2102 , "%s:<S2SV_blank>traddr=pn-0x%016llx:nn-0x%016llx<S2SV_blank>PortID:%06x\\n" , __func__ , rport -> req . port_name , rport -> req . node_name , rport -> req . port_id ) ; ret = nvme_fc_register_remoteport ( vha -> nvme_local_port , & rport -> req , & fcport -> nvme_remote_port ) ; if ( ret ) { ql_log ( ql_log_warn , vha , 0x212e , "Failed<S2SV_blank>to<S2SV_blank>register<S2SV_blank>remote<S2SV_blank>port.<S2SV_blank>Transport<S2SV_blank>returned<S2SV_blank>%d\\n" , ret ) ; return ret ; } fcport -> nvme_remote_port -> private = fcport ; fcport -> nvme_flag |= NVME_FLAG_REGISTERED ; atomic_set ( & fcport -> nvme_ref_count , 1 ) ; init_waitqueue_head ( & fcport -> nvme_waitQ ) ; rport -> fcport = fcport ; list_add_tail ( & rport -> list , & vha -> nvme_rport_list ) ; <S2SV_StartBug> # endif <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> fcport ) { <S2SV_ModEnd> struct nvme_rport * <S2SV_ModStart> ; if ( ! IS_ENABLED ( CONFIG_NVME_FC ) ) return 0 ; if ( <S2SV_ModStart> nvme_rport_list ) ; <S2SV_ModEnd> return 0 ; |
2,475 | CWE-000 static void can_configure_gpio ( gpio_num_t tx , gpio_num_t rx , gpio_num_t clkout , gpio_num_t bus_status ) { gpio_set_pull_mode ( tx , GPIO_FLOATING ) ; gpio_matrix_out ( tx , CAN_TX_IDX , false , false ) ; gpio_pad_select_gpio ( tx ) ; gpio_set_pull_mode ( rx , GPIO_FLOATING ) ; gpio_matrix_in ( rx , CAN_RX_IDX , false ) ; <S2SV_StartBug> gpio_pad_select_gpio ( rx ) ; <S2SV_EndBug> if ( clkout >= 0 && clkout < GPIO_NUM_MAX ) { gpio_set_pull_mode ( clkout , GPIO_FLOATING ) ; gpio_matrix_out ( clkout , CAN_CLKOUT_IDX , false , false ) ; gpio_pad_select_gpio ( clkout ) ; } if ( bus_status >= 0 && bus_status < GPIO_NUM_MAX ) { gpio_set_pull_mode ( bus_status , GPIO_FLOATING ) ; gpio_matrix_out ( bus_status , CAN_BUS_OFF_ON_IDX , false , false ) ; gpio_pad_select_gpio ( bus_status ) ; } } | <S2SV_ModStart> gpio_pad_select_gpio ( rx ) ; gpio_set_direction ( rx , GPIO_MODE_INPUT |
2,476 | CWE-000 static ssize_t mm_stat_show ( struct device * dev , struct device_attribute * attr , char * buf ) { struct zram * zram = dev_to_zram ( dev ) ; struct zs_pool_stats pool_stats ; u64 orig_size , mem_used = 0 ; long max_used ; ssize_t ret ; memset ( & pool_stats , 0x00 , sizeof ( struct zs_pool_stats ) ) ; down_read ( & zram -> init_lock ) ; if ( init_done ( zram ) ) { mem_used = zs_get_total_pages ( zram -> meta -> mem_pool ) ; zs_pool_stats ( zram -> meta -> mem_pool , & pool_stats ) ; } orig_size = atomic64_read ( & zram -> stats . pages_stored ) ; max_used = atomic_long_read ( & zram -> stats . max_used_pages ) ; ret = scnprintf ( buf , PAGE_SIZE , "%8llu<S2SV_blank>%8llu<S2SV_blank>%8llu<S2SV_blank>%8lu<S2SV_blank>%8ld<S2SV_blank>%8llu<S2SV_blank>%8lu\\n" , orig_size << PAGE_SHIFT , ( u64 ) atomic64_read ( & zram -> stats . compr_data_size ) , mem_used << PAGE_SHIFT , zram -> limit_pages << PAGE_SHIFT , max_used << PAGE_SHIFT , <S2SV_StartBug> ( u64 ) atomic64_read ( & zram -> stats . zero_pages ) , <S2SV_EndBug> pool_stats . pages_compacted ) ; up_read ( & zram -> init_lock ) ; return ret ; } | <S2SV_ModStart> -> stats . same_pages <S2SV_ModEnd> ) , pool_stats |
2,477 | CWE-000 static int ffmpeg_open ( struct input_plugin_data * ip_data ) { struct ffmpeg_private * priv ; int err = 0 ; int i ; int stream_index = - 1 ; int64_t channel_layout = 0 ; AVCodec * codec ; AVCodecContext * cc = NULL ; AVFormatContext * ic = NULL ; SwrContext * swr = NULL ; ffmpeg_init ( ) ; # if ( LIBAVFORMAT_VERSION_INT <= ( ( 53 << 16 ) + ( 2 << 8 ) + 0 ) ) err = av_open_input_file ( & ic , ip_data -> filename , NULL , 0 , NULL ) ; # else err = avformat_open_input ( & ic , ip_data -> filename , NULL , NULL ) ; # endif if ( err < 0 ) { d_print ( "av_open<S2SV_blank>failed:<S2SV_blank>%d\\n" , err ) ; return - IP_ERROR_FILE_FORMAT ; } do { # if ( LIBAVFORMAT_VERSION_INT <= ( ( 53 << 16 ) + ( 5 << 8 ) + 0 ) ) err = av_find_stream_info ( ic ) ; # else err = avformat_find_stream_info ( ic , NULL ) ; # endif if ( err < 0 ) { d_print ( "unable<S2SV_blank>to<S2SV_blank>find<S2SV_blank>stream<S2SV_blank>info:<S2SV_blank>%d\\n" , err ) ; err = - IP_ERROR_FILE_FORMAT ; break ; } for ( i = 0 ; i < ic -> nb_streams ; i ++ ) { cc = ic -> streams [ i ] -> codec ; if ( cc -> codec_type == AVMEDIA_TYPE_AUDIO ) { stream_index = i ; break ; } } if ( stream_index == - 1 ) { d_print ( "could<S2SV_blank>not<S2SV_blank>find<S2SV_blank>audio<S2SV_blank>stream\\n" ) ; err = - IP_ERROR_FILE_FORMAT ; break ; } codec = avcodec_find_decoder ( cc -> codec_id ) ; if ( ! codec ) { # if LIBAVCODEC_VERSION_MAJOR >= 54 d_print ( "codec<S2SV_blank>not<S2SV_blank>found:<S2SV_blank>%d,<S2SV_blank>%s\\n" , cc -> codec_id , avcodec_get_name ( cc -> codec_id ) ) ; # else d_print ( "codec<S2SV_blank>not<S2SV_blank>found:<S2SV_blank>%d,<S2SV_blank>%s\\n" , cc -> codec_id , cc -> codec_name ) ; # endif err = - IP_ERROR_UNSUPPORTED_FILE_TYPE ; break ; } if ( codec -> capabilities & CODEC_CAP_TRUNCATED ) cc -> flags |= CODEC_FLAG_TRUNCATED ; # if ( LIBAVCODEC_VERSION_INT < ( ( 53 << 16 ) + ( 8 << 8 ) + 0 ) ) if ( avcodec_open ( cc , codec ) < 0 ) { # else if ( avcodec_open2 ( cc , codec , NULL ) < 0 ) { # endif # if LIBAVCODEC_VERSION_MAJOR >= 54 d_print ( "could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>codec:<S2SV_blank>%d,<S2SV_blank>%s\\n" , cc -> codec_id , avcodec_get_name ( cc -> codec_id ) ) ; # else d_print ( "could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>codec:<S2SV_blank>%d,<S2SV_blank>%s\\n" , cc -> codec_id , cc -> codec_name ) ; # endif err = - IP_ERROR_UNSUPPORTED_FILE_TYPE ; break ; } } while ( 0 ) ; if ( err < 0 ) { # if ( LIBAVCODEC_VERSION_INT < ( ( 53 << 16 ) + ( 25 << 8 ) + 0 ) ) av_close_input_file ( ic ) ; # else avformat_close_input ( & ic ) ; # endif return err ; } priv = xnew ( struct ffmpeg_private , 1 ) ; priv -> codec_context = cc ; priv -> input_context = ic ; priv -> codec = codec ; <S2SV_StartBug> priv -> stream_index = stream_index ; <S2SV_EndBug> priv -> input = ffmpeg_input_create ( ) ; if ( priv -> input == NULL ) { avcodec_close ( cc ) ; # if ( LIBAVCODEC_VERSION_INT < ( ( 53 << 16 ) + ( 25 << 8 ) + 0 ) ) av_close_input_file ( ic ) ; # else avformat_close_input ( & ic ) ; # endif free ( priv ) ; return - IP_ERROR_INTERNAL ; } <S2SV_StartBug> priv -> output = ffmpeg_output_create ( ) ; <S2SV_EndBug> swr = swr_alloc ( ) ; av_opt_set_int ( swr , "in_channel_layout" , av_get_default_channel_layout ( cc -> channels ) , 0 ) ; av_opt_set_int ( swr , "out_channel_layout" , av_get_default_channel_layout ( cc -> channels ) , 0 ) ; av_opt_set_int ( swr , "in_sample_rate" , cc -> sample_rate , 0 ) ; av_opt_set_int ( swr , "out_sample_rate" , cc -> sample_rate , 0 ) ; av_opt_set_sample_fmt ( swr , "in_sample_fmt" , cc -> sample_fmt , 0 ) ; priv -> swr = swr ; ip_data -> private = priv ; ip_data -> sf = sf_rate ( cc -> sample_rate ) | sf_channels ( cc -> channels ) ; switch ( cc -> sample_fmt ) { case AV_SAMPLE_FMT_U8 : ip_data -> sf |= sf_bits ( 8 ) | sf_signed ( 0 ) ; av_opt_set_sample_fmt ( swr , "out_sample_fmt" , AV_SAMPLE_FMT_U8 , 0 ) ; break ; case AV_SAMPLE_FMT_S32 : ip_data -> sf |= sf_bits ( 32 ) | sf_signed ( 1 ) ; av_opt_set_sample_fmt ( swr , "out_sample_fmt" , AV_SAMPLE_FMT_S32 , 0 ) ; break ; default : ip_data -> sf |= sf_bits ( 16 ) | sf_signed ( 1 ) ; av_opt_set_sample_fmt ( swr , "out_sample_fmt" , AV_SAMPLE_FMT_S16 , 0 ) ; break ; } swr_init ( swr ) ; # ifdef WORDS_BIGENDIAN ip_data -> sf |= sf_bigendian ( 1 ) ; # endif # if ( LIBAVCODEC_VERSION_INT > ( ( 52 << 16 ) + ( 1 << 8 ) + 0 ) ) channel_layout = cc -> channel_layout ; # endif channel_map_init_waveex ( cc -> channels , channel_layout , ip_data -> channel_map ) ; return 0 ; } | <S2SV_ModStart> ; priv -> <S2SV_ModEnd> input = ffmpeg_input_create <S2SV_ModStart> } priv -> input -> stream_index = stream_index ; priv -> |
2,478 | CWE-000 NTSTATUS FspFileDescSetDirectoryMarker ( FSP_FILE_DESC * FileDesc , PUNICODE_STRING FileName ) <S2SV_StartBug> { <S2SV_EndBug> if ( & FileDesc -> DirectoryMarker == FileName ) return STATUS_SUCCESS ; FSP_FSVOL_DEVICE_EXTENSION * FsvolDeviceExtension = FspFsvolDeviceExtension ( FileDesc -> FileNode -> FsvolDeviceObject ) ; UNICODE_STRING DirectoryMarker ; if ( FsvolDeviceExtension -> VolumeParams . MaxComponentLength < FileName -> Length ) return STATUS_OBJECT_NAME_INVALID ; DirectoryMarker . Length = DirectoryMarker . MaximumLength = FileName -> Length ; DirectoryMarker . Buffer = FspAlloc ( FileName -> Length ) ; if ( 0 == DirectoryMarker . Buffer ) return STATUS_INSUFFICIENT_RESOURCES ; RtlCopyMemory ( DirectoryMarker . Buffer , FileName -> Buffer , FileName -> Length ) ; if ( 0 != FileDesc -> DirectoryMarker . Buffer ) FspFree ( FileDesc -> DirectoryMarker . Buffer ) ; FileDesc -> DirectoryMarker = DirectoryMarker ; return STATUS_SUCCESS ; } | <S2SV_ModStart> FileName ) { PAGED_CODE ( ) ; |
2,479 | CWE-000 static int hclge_mdio_write ( struct mii_bus * bus , int phyid , int regnum , u16 data ) { struct hclge_mdio_cfg_cmd * mdio_cmd ; struct hclge_dev * hdev = bus -> priv ; struct hclge_desc desc ; int ret ; <S2SV_StartBug> if ( test_bit ( HCLGE_STATE_RST_HANDLING , & hdev -> state ) ) <S2SV_EndBug> return 0 ; hclge_cmd_setup_basic_desc ( & desc , HCLGE_OPC_MDIO_CONFIG , false ) ; mdio_cmd = ( struct hclge_mdio_cfg_cmd * ) desc . data ; hnae3_set_field ( mdio_cmd -> phyid , HCLGE_MDIO_PHYID_M , HCLGE_MDIO_PHYID_S , phyid ) ; hnae3_set_field ( mdio_cmd -> phyad , HCLGE_MDIO_PHYREG_M , HCLGE_MDIO_PHYREG_S , regnum ) ; hnae3_set_bit ( mdio_cmd -> ctrl_bit , HCLGE_MDIO_CTRL_START_B , 1 ) ; hnae3_set_field ( mdio_cmd -> ctrl_bit , HCLGE_MDIO_CTRL_ST_M , HCLGE_MDIO_CTRL_ST_S , 1 ) ; hnae3_set_field ( mdio_cmd -> ctrl_bit , HCLGE_MDIO_CTRL_OP_M , HCLGE_MDIO_CTRL_OP_S , HCLGE_MDIO_C22_WRITE ) ; mdio_cmd -> data_wr = cpu_to_le16 ( data ) ; ret = hclge_cmd_send ( & hdev -> hw , & desc , 1 ) ; if ( ret ) { dev_err ( & hdev -> pdev -> dev , "mdio<S2SV_blank>write<S2SV_blank>fail<S2SV_blank>when<S2SV_blank>sending<S2SV_blank>cmd,<S2SV_blank>status<S2SV_blank>is<S2SV_blank>%d.\\n" , ret ) ; return ret ; } return 0 ; } | <S2SV_ModStart> ( test_bit ( HCLGE_STATE_CMD_DISABLE <S2SV_ModEnd> , & hdev |
2,480 | CWE-000 int fdtbus_get_phandle ( int phandle , const char * prop ) { u_int phandle_ref ; <S2SV_StartBug> u_int * buf ; <S2SV_EndBug> int len ; <S2SV_StartBug> len = OF_getproplen ( phandle , prop ) ; <S2SV_EndBug> <S2SV_StartBug> if ( len < sizeof ( phandle_ref ) ) <S2SV_EndBug> return - 1 ; <S2SV_StartBug> buf = kmem_alloc ( len , KM_SLEEP ) ; <S2SV_EndBug> if ( OF_getprop ( phandle , prop , buf , len ) != len ) { kmem_free ( buf , len ) ; return - 1 ; } phandle_ref = fdt32_to_cpu ( buf [ 0 ] ) ; kmem_free ( buf , len ) ; return fdtbus_get_phandle_from_native ( phandle_ref ) ; } | <S2SV_ModStart> u_int phandle_ref ; const <S2SV_ModStart> int len ; buf = fdt_getprop ( fdtbus_get_data ( ) , fdtbus_phandle2offset ( phandle ) , prop , & len <S2SV_ModEnd> ) ; if <S2SV_ModStart> ; if ( buf == NULL || <S2SV_ModStart> - 1 ; phandle_ref = be32dec ( buf <S2SV_ModEnd> ) ; return |
2,481 | CWE-000 void __attribute__ ( ( constructor , no_instrument_function ) ) trace_begin ( void ) { struct profile * p = & _profparam ; if ( p -> state != PROF_BUSY ) return ; if ( ! p -> already_setup ) { Profiling_log = fopen ( path , "w+" ) ; if ( Profiling_log != NULL ) { fseek ( Profiling_log , 0 , SEEK_SET ) ; fputs ( "<?xml<S2SV_blank>version=\\"1.0\\"<S2SV_blank>encoding=\\"UTF-8\\"?>\\n" , Profiling_log ) ; <S2SV_StartBug> sprintf ( string_app , "<table<S2SV_blank>xmlns:xsi=\\"http://www.w3.org/2001/XMLSchema-instance\\"\\n<S2SV_blank>xsi:noNamespaceSchemaLocation=\\"schema_table.xsd\\">\\n<S2SV_blank><header><S2SV_blank><hdr_name_1>cycles</hdr_name_1><S2SV_blank><hdr_name_2>fun_addrs</hdr_name_2><S2SV_blank><hdr_name_3>fun_name</hdr_name_3><S2SV_blank></header>\\n" ) ; <S2SV_EndBug> fputs ( string_app , Profiling_log ) ; fclose ( Profiling_log ) ; p -> already_setup = 1 ; p -> state = PROF_ON ; } else { Error_profile ( ) ; } } } | <S2SV_ModStart> ( string_app , "<table<S2SV_blank>xmlns:xsi=\\"http://www.w3.org/2001/XMLSchema-instance\\"\\n<S2SV_blank>xsi:noNamespaceSchemaLocation=\\"schema_table.xsd\\">\\n<S2SV_blank><header><S2SV_blank><hdr_name_1>cycles</hdr_name_1><S2SV_blank><hdr_name_2>fun_addrs</hdr_name_2><S2SV_blank><hdr_name_3>fun_name</hdr_name_3><S2SV_blank></header>\\n<S2SV_blank><!--Tracer<S2SV_blank>Profile<S2SV_blank>for<S2SV_blank>%s<S2SV_blank>-->\\n" , file_name <S2SV_ModEnd> ) ; fputs |
2,482 | CWE-000 char * currentInterface ( int nbErrors ) { <S2SV_StartBug> char * hangman = ( char * ) malloc ( sizeof ( char ) * 256 ) ; <S2SV_EndBug> switch ( nbErrors ) { case 1 : <S2SV_StartBug> hangman = "0\\n============\\n" ; <S2SV_EndBug> break ; case 2 : hangman = "0\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n============" ; break ; case 3 : hangman = "0\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>==========Y===\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n============" ; break ; case 4 : hangman = "0\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>==========Y===\\n<S2SV_blank><S2SV_blank><S2SV_blank>||<S2SV_blank><S2SV_blank>/\\n<S2SV_blank><S2SV_blank><S2SV_blank>||<S2SV_blank>/\\n<S2SV_blank><S2SV_blank><S2SV_blank>||/\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank>/||\\n<S2SV_blank>//||\\n============" ; break ; case 5 : hangman = "0\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>==========Y===\\n<S2SV_blank><S2SV_blank><S2SV_blank>||<S2SV_blank><S2SV_blank>/<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>|\\n<S2SV_blank><S2SV_blank><S2SV_blank>||<S2SV_blank>/<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>|\\n<S2SV_blank><S2SV_blank><S2SV_blank>||/\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank>/||\\n<S2SV_blank>//||\\n============" ; break ; case 6 : hangman = "0\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>==========Y===\\n<S2SV_blank><S2SV_blank><S2SV_blank>||<S2SV_blank><S2SV_blank>/<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>|\\n<S2SV_blank><S2SV_blank><S2SV_blank>||<S2SV_blank>/<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>|\\n<S2SV_blank><S2SV_blank><S2SV_blank>||/<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>O\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank>/||\\n<S2SV_blank>//||\\n============" ; break ; case 7 : hangman = "0\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>==========Y===\\n<S2SV_blank><S2SV_blank><S2SV_blank>||<S2SV_blank><S2SV_blank>/<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>|\\n<S2SV_blank><S2SV_blank><S2SV_blank>||<S2SV_blank>/<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>|\\n<S2SV_blank><S2SV_blank><S2SV_blank>||/<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>O\\n<S2SV_blank><S2SV_blank><S2SV_blank>||<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>|\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank>/||\\n<S2SV_blank>//||\\n============" ; break ; case 8 : hangman = "0\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>==========Y===\\n<S2SV_blank><S2SV_blank><S2SV_blank>||<S2SV_blank><S2SV_blank>/<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>|\\n<S2SV_blank><S2SV_blank><S2SV_blank>||<S2SV_blank>/<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>|\\n<S2SV_blank><S2SV_blank><S2SV_blank>||/<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>O\\n<S2SV_blank><S2SV_blank><S2SV_blank>||<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>|\\\\\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank>/||\\n<S2SV_blank>//||\\n============" ; break ; case 9 : hangman = "0\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>==========Y===\\n<S2SV_blank><S2SV_blank><S2SV_blank>||<S2SV_blank><S2SV_blank>/<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>|\\n<S2SV_blank><S2SV_blank><S2SV_blank>||<S2SV_blank>/<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>|\\n<S2SV_blank><S2SV_blank><S2SV_blank>||/<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>O\\n<S2SV_blank><S2SV_blank><S2SV_blank>||<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>/|\\\\\\n<S2SV_blank><S2SV_blank><S2SV_blank>||<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>/\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank>/||\\n<S2SV_blank>//||\\n============" ; break ; case 10 : hangman = "0\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>==========Y===\\n<S2SV_blank><S2SV_blank><S2SV_blank>||<S2SV_blank><S2SV_blank>/<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>|\\n<S2SV_blank><S2SV_blank><S2SV_blank>||<S2SV_blank>/<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>|\\n<S2SV_blank><S2SV_blank><S2SV_blank>||/<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>O\\n<S2SV_blank><S2SV_blank><S2SV_blank>||<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>/|\\\\\\n<S2SV_blank><S2SV_blank><S2SV_blank>||<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>/|\\n<S2SV_blank><S2SV_blank><S2SV_blank>||\\n<S2SV_blank><S2SV_blank>/||\\n<S2SV_blank>//||\\n============" ; break ; } return hangman ; } | <S2SV_ModStart> char * ) calloc ( TAILLE_MAX_NOM , <S2SV_ModEnd> sizeof ( char <S2SV_ModStart> ( char ) <S2SV_ModEnd> ) ; switch <S2SV_ModStart> : hangman = "0\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n============\\n" <S2SV_ModEnd> ; break ; |
2,483 | CWE-000 static int _invocation ( struct _KOS_COMP_UNIT * program , const struct _KOS_AST_NODE * node , struct _KOS_REG * * reg , enum _KOS_BYTECODE_INSTR instr , unsigned tail_closure_size ) { int error ; struct _KOS_REG * obj = 0 ; struct _KOS_REG * fun = 0 ; struct _KOS_REG * args = _is_var_used ( program , node , * reg ) ? 0 : * reg ; int32_t rdest = ( int32_t ) tail_closure_size ; int num_contig_args ; assert ( tail_closure_size <= 255U ) ; node = node -> children ; assert ( node ) ; TRY ( _maybe_refinement ( program , node , & fun , & obj ) ) ; node = node -> next ; num_contig_args = _count_contig_arg_siblings ( node ) ; if ( num_contig_args <= MAX_CONTIG_REGS ) { struct _KOS_REG * argn [ MAX_CONTIG_REGS ] = { 0 , 0 , 0 , 0 } ; int i ; if ( num_contig_args > 1 ) TRY ( _gen_reg_range ( program , & argn [ 0 ] , num_contig_args ) ) ; for ( i = 0 ; node ; node = node -> next , i ++ ) { struct _KOS_REG * arg = argn [ i ] ; <S2SV_StartBug> assert ( i == 0 || arg -> reg == argn [ i - 1 ] -> reg + 1 ) ; <S2SV_EndBug> <S2SV_StartBug> TRY ( _visit_node ( program , node , & arg ) ) ; <S2SV_EndBug> if ( ! argn [ i ] ) { assert ( num_contig_args == 1 ) ; argn [ i ] = arg ; } else if ( arg != argn [ i ] ) { assert ( ! arg -> tmp ) ; TRY ( _gen_instr2 ( program , INSTR_MOVE , argn [ i ] -> reg , arg -> reg ) ) ; } } if ( instr == INSTR_CALL ) { if ( ! * reg ) { for ( i = 0 ; i < num_contig_args ; i ++ ) { if ( argn [ i ] -> tmp ) { * reg = argn [ i ] ; break ; } } } if ( ! * reg ) TRY ( _gen_reg ( program , reg ) ) ; rdest = ( * reg ) -> reg ; } if ( obj ) { instr = ( instr == INSTR_CALL ) ? INSTR_CALL_N : INSTR_TAIL_CALL_N ; TRY ( _gen_instr5 ( program , instr , rdest , fun -> reg , obj -> reg , num_contig_args ? argn [ 0 ] -> reg : 255 , num_contig_args ) ) ; } else { instr = ( instr == INSTR_CALL ) ? INSTR_CALL_FUN : INSTR_TAIL_CALL_FUN ; TRY ( _gen_instr4 ( program , instr , rdest , fun -> reg , num_contig_args ? argn [ 0 ] -> reg : 255 , num_contig_args ) ) ; } while ( num_contig_args ) { struct _KOS_REG * arg = argn [ -- num_contig_args ] ; if ( arg != * reg ) _free_reg ( program , arg ) ; } } else { TRY ( _gen_array ( program , node , & args ) ) ; if ( ! * reg && instr == INSTR_CALL ) * reg = args ; if ( ! obj ) { TRY ( _gen_reg ( program , & obj ) ) ; TRY ( _gen_instr1 ( program , INSTR_LOAD_VOID , obj -> reg ) ) ; } if ( instr == INSTR_CALL ) rdest = ( * reg ) -> reg ; TRY ( _gen_instr4 ( program , instr , rdest , fun -> reg , obj -> reg , args -> reg ) ) ; if ( args != * reg ) _free_reg ( program , args ) ; } _free_reg ( program , fun ) ; if ( obj ) _free_reg ( program , obj ) ; _error : return error ; } | <S2SV_ModStart> 0 || arg ) ; assert ( i == 0 || arg <S2SV_ModStart> & arg ) ) ; assert ( arg |
2,484 | CWE-000 static JSTrapStatus TrapHandler ( JSContext * cx , JSScript * script , jsbytecode * pc , jsval * rval , void * closure ) { JSString * str ; JSStackFrame * caller ; <S2SV_StartBug> str = closure ; <S2SV_EndBug> caller = cx -> fp -> down ; if ( ! JS_EvaluateScript ( cx , caller -> scopeChain , JS_GetStringBytes ( str ) , JS_GetStringLength ( str ) , caller -> script -> filename , caller -> script -> lineno , rval ) ) { return JSTRAP_ERROR ; } if ( * rval != JSVAL_VOID ) return JSTRAP_RETURN ; return JSTRAP_CONTINUE ; } | <S2SV_ModStart> ; str = ( JSString * ) |
2,485 | CWE-000 int main ( void ) { int ierr ; int size [ 3 ] = { 3 , 3 , 3 } ; int ngp = 100 ; int type = 2 ; double params [ 1 ] = { 0.2 } ; material_t materials [ NMATERIALS ] ; material_set ( & materials [ 0 ] , 1.0e8 , 0.25 , 1.0e8 , 1.0e4 , 0 ) ; material_set ( & materials [ 1 ] , 1.0e8 , 0.25 , 1.0e8 , 1.0e4 , 0 ) ; ierr = microc_init ( ngp , size , type , params , materials ) ; const double strain [ 6 ] = { 1. , 2. , 3. , 1. , 1. , 1. } ; ierr = VecZeroEntries ( u ) ; ierr = bc_apply_on_u ( u , strain ) ; <S2SV_StartBug> double norm = assembly_jac ( A , u , NULL ) ; <S2SV_EndBug> microc_finish ( ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> strain ) ; ierr <S2SV_ModEnd> = assembly_jac ( <S2SV_ModStart> ) ; return ierr <S2SV_ModEnd> ; } <S2SV_null> |
2,486 | CWE-000 u32 rio_mport_get_feature ( struct rio_mport * port , int local , u16 destid , u8 hopcount , int ftr ) { u32 asm_info , ext_ftr_ptr , ftr_header ; if ( local ) rio_local_read_config_32 ( port , RIO_ASM_INFO_CAR , & asm_info ) ; else rio_mport_read_config_32 ( port , destid , hopcount , RIO_ASM_INFO_CAR , & asm_info ) ; ext_ftr_ptr = asm_info & RIO_EXT_FTR_PTR_MASK ; while ( ext_ftr_ptr ) { if ( local ) rio_local_read_config_32 ( port , ext_ftr_ptr , & ftr_header ) ; else rio_mport_read_config_32 ( port , destid , hopcount , ext_ftr_ptr , & ftr_header ) ; if ( RIO_GET_BLOCK_ID ( ftr_header ) == ftr ) return ext_ftr_ptr ; <S2SV_StartBug> if ( ! ( ext_ftr_ptr = RIO_GET_BLOCK_PTR ( ftr_header ) ) ) <S2SV_EndBug> break ; } return 0 ; } | <S2SV_ModStart> return ext_ftr_ptr ; <S2SV_ModEnd> ext_ftr_ptr = RIO_GET_BLOCK_PTR <S2SV_ModStart> ( ftr_header ) ; if ( ! ext_ftr_ptr <S2SV_ModEnd> ) break ; |
2,487 | CWE-000 static int instance_delete ( const char * name ) { struct trace_array * tr ; int found = 0 ; int ret ; mutex_lock ( & trace_types_lock ) ; ret = - ENODEV ; list_for_each_entry ( tr , & ftrace_trace_arrays , list ) { if ( tr -> name && strcmp ( tr -> name , name ) == 0 ) { found = 1 ; break ; } } if ( ! found ) goto out_unlock ; ret = - EBUSY ; if ( tr -> ref ) goto out_unlock ; list_del ( & tr -> list ) ; tracing_set_nop ( tr ) ; event_trace_del_tracer ( tr ) ; <S2SV_StartBug> ftrace_destroy_function_files ( tr ) ; <S2SV_EndBug> debugfs_remove_recursive ( tr -> dir ) ; free_trace_buffers ( tr ) ; kfree ( tr -> name ) ; kfree ( tr ) ; ret = 0 ; out_unlock : mutex_unlock ( & trace_types_lock ) ; return ret ; } | <S2SV_ModStart> tr ) ; ftrace_clear_pids ( tr ) ; |
2,488 | CWE-000 static foreign_t rdf_keys_in_literal_map_proteced ( atom_map * map , term_t spec , term_t keys ) { term_t tail = PL_copy_term_ref ( keys ) ; term_t head = PL_new_term_ref ( ) ; atom_t name ; size_t arity ; if ( ! PL_get_name_arity ( spec , & name , & arity ) ) PL_type_error ( "key-specifier" , spec ) ; if ( name == ATOM_all ) { skiplist_enum state ; node_data * data ; for ( data = skiplist_find_first ( & map -> list , NULL , & state ) ; data ; data = skiplist_find_next ( & state ) ) { if ( ! PL_unify_list ( tail , head , tail ) || ! unify_datum ( head , data -> key ) ) { skiplist_find_destroy ( & state ) ; return FALSE ; } } skiplist_find_destroy ( & state ) ; } else if ( name == ATOM_key && arity == 1 ) { term_t a = PL_new_term_ref ( ) ; node_data * data ; node_data_ex search ; _PL_get_arg ( 1 , spec , a ) ; if ( ! get_search_datum ( a , & search ) ) return FALSE ; if ( ( data = skiplist_find ( & map -> list , & search ) ) ) { intptr_t size = ( intptr_t ) data -> values . size ; <S2SV_StartBug> assert ( size > 0 ) ; <S2SV_EndBug> <S2SV_StartBug> return PL_unify_integer ( keys , size ) ; <S2SV_EndBug> } return FALSE ; } else if ( ( name == ATOM_prefix || name == ATOM_case ) && arity == 1 ) { term_t a = PL_new_term_ref ( ) ; atom_t prefix , first_a ; skiplist_enum state ; node_data * data ; node_data_ex search ; int match = ( name == ATOM_prefix ? STR_MATCH_PREFIX : STR_MATCH_ICASE ) ; _PL_get_arg ( 1 , spec , a ) ; if ( ! PL_get_atom_ex ( a , & prefix ) ) return FALSE ; first_a = first_atom ( prefix , STR_MATCH_PREFIX ) ; search . data . key = atom_to_datum ( first_a ) ; search . atom . handle = first_a ; search . atom . resolved = FALSE ; SECURE ( search . magic = ND_MAGIC_EX ) ; for ( data = skiplist_find_first ( & map -> list , & search , & state ) ; data ; data = skiplist_find_next ( & state ) ) { assert ( isAtomDatum ( data -> key ) ) ; if ( ! match_atoms ( match , first_a , atom_from_datum ( data -> key ) ) ) break ; if ( ! PL_unify_list ( tail , head , tail ) || ! unify_datum ( head , data -> key ) ) { skiplist_find_destroy ( & state ) ; return FALSE ; } skiplist_find_destroy ( & state ) ; } } else if ( ( name == ATOM_ge || name == ATOM_le ) && arity == 1 ) { term_t a = PL_new_term_ref ( ) ; intptr_t val , min , max ; _PL_get_arg ( 1 , spec , a ) ; if ( ! PL_get_intptr_ex ( a , & val ) ) return FALSE ; if ( name == ATOM_ge ) min = val , max = MAP_MAX_INT ; else max = val , min = MAP_MIN_INT ; if ( ! between_keys ( map , min , max , head , tail ) ) return FALSE ; } else if ( name == ATOM_between && arity == 2 ) { term_t a = PL_new_term_ref ( ) ; intptr_t min , max ; _PL_get_arg ( 1 , spec , a ) ; if ( ! PL_get_intptr_ex ( a , & min ) ) return FALSE ; _PL_get_arg ( 2 , spec , a ) ; if ( ! PL_get_intptr_ex ( a , & max ) ) return FALSE ; if ( ! between_keys ( map , min , max , head , tail ) ) return FALSE ; } else { return PL_type_error ( "key-specifier" , spec ) ; } return PL_unify_nil ( tail ) ; } | <S2SV_ModStart> . size ; if <S2SV_ModEnd> ( size > <S2SV_ModStart> > 0 ) <S2SV_ModEnd> return PL_unify_integer ( <S2SV_ModStart> keys , size ) ; assert ( size == 0 |
2,489 | CWE-000 <S2SV_StartBug> void ft_del_test_lst ( test_lst * base ) <S2SV_EndBug> { <S2SV_StartBug> test_lst * tmp ; <S2SV_EndBug> tmp = base ; while ( base ) { while ( tmp -> next ) tmp = tmp -> next ; ft_strdel ( & tmp -> name ) ; free ( tmp ) ; tmp = NULL ; tmp = base ; } } | <S2SV_ModStart> void ft_del_test_lst ( t_test <S2SV_ModEnd> * base ) <S2SV_ModStart> base ) { t_test <S2SV_ModEnd> * tmp ; |
2,490 | CWE-000 int myAES_Encrypt ( char * filename , int changekey , char * outputstr ) { EVP_CIPHER_CTX en ; int final_len = 0 , output_len = 0 , password_len , inputfile , encryptedfile , file_count = 0 , blks , encrypt_result , total_len ; size_t file_len ; inputfile = open ( filename , O_RDONLY ) ; if ( inputfile == - 1 ) { printf ( "faild<S2SV_blank>to<S2SV_blank>open<S2SV_blank>source<S2SV_blank>file<S2SV_blank>%s.\\n" , filename ) ; return 0 ; } unsigned char * password = ( unsigned char * ) malloc ( sizeof ( unsigned char ) * 32 ) , * salt = ( unsigned char * ) malloc ( sizeof ( unsigned char ) * 8 ) , * key = ( unsigned char * ) malloc ( sizeof ( unsigned char ) * 32 ) , * iv = ( unsigned char * ) malloc ( sizeof ( unsigned char ) * 16 ) , * outputbuffer , * file ; char encryptedfilename [ 40 ] , decryptedfilename [ 30 ] , destr [ ] = "-de.txt" , enstr [ ] = "-en-00.txt" ; memset ( encryptedfilename , 0 , 40 ) ; memset ( decryptedfilename , 0 , 30 ) ; strncpy ( encryptedfilename , filename , strlen ( filename ) - 4 ) ; strcat ( encryptedfilename , enstr ) ; strncpy ( decryptedfilename , filename , strlen ( filename ) - 4 ) ; strcat ( decryptedfilename , destr ) ; file_len = myAES_get_file_length ( filename ) ; file = ( unsigned char * ) malloc ( sizeof ( unsigned char ) * file_len ) ; myAES_read_file ( filename , file , file_len ) ; if ( changekey ) { srand ( time ( NULL ) ) ; myAES_generate_new_password ( password ) ; myAES_generate_new_salt ( salt ) ; <S2SV_StartBug> password_len = strlen ( ( char * ) ( password ) ) ; <S2SV_EndBug> if ( ! myAES_generate_key_iv ( password , password_len , salt , key , iv ) ) { printf ( "Error,<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>key<S2SV_blank>and<S2SV_blank>IV.\\n" ) ; return 0 ; } myAESStorage_set_encryptblock ( key , iv , password , password_len ) ; } else { struct myAES_encryptblock * encryptblock = myAESStorage_get_encryptblock ( ) ; memcpy ( key , encryptblock -> key , KEY_SIZE ) ; memcpy ( iv , encryptblock -> iv , KEY_SIZE / 2 ) ; password_len = encryptblock -> password_len ; memcpy ( password , encryptblock -> password , password_len ) ; } myAES_Encrypt_init ( & en , key , iv ) ; blks = ( file_len / BLK_SIZE ) + 1 ; outputbuffer = ( unsigned char * ) malloc ( sizeof ( unsigned char ) * blks * BLK_SIZE ) ; encrypt_result = EVP_EncryptUpdate ( & en , ( unsigned char * ) outputbuffer , & output_len , ( unsigned char * ) file , file_len ) ; if ( encrypt_result == 0 ) { printf ( "failed<S2SV_blank>to<S2SV_blank>update.\\n" ) ; return 0 ; } encrypt_result = EVP_EncryptFinal_ex ( & en , ( unsigned char * ) outputbuffer + output_len , & final_len ) ; total_len = output_len + final_len ; if ( encrypt_result == 0 || total_len != ( blks * BLK_SIZE ) ) { printf ( "failed<S2SV_blank>to<S2SV_blank>final<S2SV_blank>update.\\n" ) ; return 0 ; } file_count = total_len / SIZE + 1 ; for ( int i = 1 ; i <= file_count ; i ++ ) { encryptedfilename [ strlen ( encryptedfilename ) - 6 ] = i / 10 + '0' ; encryptedfilename [ strlen ( encryptedfilename ) - 5 ] = i % 10 + '0' ; encryptedfile = open ( encryptedfilename , O_WRONLY | O_CREAT | O_TRUNC , 0400 | 0200 ) ; int write_len ; if ( i != file_count ) write_len = SIZE ; else write_len = total_len % SIZE ; if ( write ( encryptedfile , outputbuffer + SIZE * ( i - 1 ) , write_len ) != write_len ) { printf ( "Error,<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>write<S2SV_blank>encryption<S2SV_blank>to<S2SV_blank>file.\\n" ) ; return 0 ; } close ( encryptedfile ) ; } printf ( "Encryption<S2SV_blank>successed<S2SV_blank>with<S2SV_blank>key<S2SV_blank>" ) ; for ( int i = 0 ; i < 32 ; i ++ ) printf ( "%c" , password [ i ] ) ; printf ( "\\n" ) ; strcat ( outputstr , filename ) ; strcat ( outputstr , "," ) ; strcat ( outputstr , password ) ; strcat ( outputstr , "," ) ; strcat ( outputstr , salt ) ; strcat ( outputstr , "," ) ; char num [ 3 ] ; sprintf ( num , "%d" , file_count ) ; strcat ( outputstr , num ) ; close ( inputfile ) ; free ( key ) ; free ( password ) ; free ( iv ) ; free ( salt ) ; free ( outputbuffer ) ; EVP_CIPHER_CTX_cleanup ( & en ) ; return 1 ; } | <S2SV_ModStart> ; password_len = KEY_SIZE <S2SV_ModEnd> ; if ( |
2,491 | CWE-000 static void print_cdr ( object * o ) { <S2SV_StartBug> switch ( otype ( o ) ) { <S2SV_EndBug> case O_KEYWORD : case O_SYM : printf ( "<S2SV_blank>.<S2SV_blank>%s" , string_ptr ( o -> str ) ) ; break ; case O_STR : printf ( "<S2SV_blank>.<S2SV_blank>\\"%s\\"" , string_ptr ( o -> str ) ) ; break ; case O_NUM : printf ( "<S2SV_blank>.<S2SV_blank>%ld" , o -> num ) ; break ; case O_CONS : printf ( "<S2SV_blank>" ) ; print_cons ( o -> c ) ; break ; case O_FN_NATIVE : printf ( "<S2SV_blank>.<S2SV_blank>#<NATIVE<S2SV_blank>FUNCTION<S2SV_blank>(%s)>" , o -> name ) ; break ; case O_FN : printf ( "<S2SV_blank>.<S2SV_blank>#<FUNCTION<S2SV_blank>@<S2SV_blank>%p>" , o ) ; break ; case O_MACRO : printf ( "<S2SV_blank>.<S2SV_blank>#<MACRO<S2SV_blank>@<S2SV_blank>%p>" , o ) ; break ; case O_FN_COMPILED : printf ( "<S2SV_blank>.<S2SV_blank>#<COMPILED<S2SV_blank>FUNCTION<S2SV_blank>@<S2SV_blank>%p>" , o ) ; break ; case O_MACRO_COMPILED : printf ( "<S2SV_blank>.<S2SV_blank>#<COMPILED<S2SV_blank>MACRO<S2SV_blank>@<S2SV_blank>%p>" , o ) ; break ; case O_STACKOFFSET : printf ( "<S2SV_blank>.<S2SV_blank>#<STACK_OFFSET:<S2SV_blank>%ld>" , o -> num ) ; break ; case O_FSTREAM : printf ( "<S2SV_blank>.<S2SV_blank>#<FILE<S2SV_blank>STREAM>" ) ; break ; case O_CHAR : <S2SV_StartBug> printf ( "<S2SV_blank>.<S2SV_blank>#\\\\%c" , o -> character ) ; <S2SV_EndBug> <S2SV_StartBug> break ; <S2SV_EndBug> } } | <S2SV_ModStart> o ) { char * name ; <S2SV_ModStart> case O_CHAR : name = char_to_name ( o -> character ) ; if ( name ) { printf ( "<S2SV_blank>.<S2SV_blank>#\\\\%s" , name ) ; } else { <S2SV_ModStart> character ) ; } |
2,492 | CWE-000 static int hdmi_lpe_audio_probe ( struct platform_device * pdev ) { struct hdmi_lpe_audio_ctx * ctx ; struct intel_hdmi_lpe_audio_pdata * pdata ; int irq ; struct resource * res_mmio ; void __iomem * mmio_start ; int ret = 0 ; unsigned long flag_irq ; static const struct pci_device_id cherryview_ids [ ] = { { PCI_DEVICE ( 0x8086 , 0x22b0 ) } , { PCI_DEVICE ( 0x8086 , 0x22b1 ) } , { PCI_DEVICE ( 0x8086 , 0x22b2 ) } , { PCI_DEVICE ( 0x8086 , 0x22b3 ) } , { } } ; dev_dbg ( & hlpe_pdev -> dev , "Enter<S2SV_blank>%s\\n" , __func__ ) ; hlpe_pdev = pdev ; hlpe_state = hdmi_connector_status_disconnected ; irq = platform_get_irq ( pdev , 0 ) ; if ( irq < 0 ) { dev_err ( & hlpe_pdev -> dev , "Could<S2SV_blank>not<S2SV_blank>get<S2SV_blank>irq<S2SV_blank>resource\\n" ) ; return - ENODEV ; } res_mmio = platform_get_resource ( pdev , IORESOURCE_MEM , 0 ) ; if ( ! res_mmio ) { dev_err ( & hlpe_pdev -> dev , "Could<S2SV_blank>not<S2SV_blank>get<S2SV_blank>IO_MEM<S2SV_blank>resources\\n" ) ; return - ENXIO ; } dev_dbg ( & hlpe_pdev -> dev , "%s:<S2SV_blank>mmio_start<S2SV_blank>=<S2SV_blank>0x%x,<S2SV_blank>mmio_end<S2SV_blank>=<S2SV_blank>0x%x\\n" , __func__ , ( unsigned int ) res_mmio -> start , ( unsigned int ) res_mmio -> end ) ; mmio_start = ioremap_nocache ( res_mmio -> start , ( size_t ) ( resource_size ( res_mmio ) ) ) ; if ( ! mmio_start ) { dev_err ( & hlpe_pdev -> dev , "Could<S2SV_blank>not<S2SV_blank>get<S2SV_blank>ioremap\\n" ) ; return - EACCES ; } ret = request_irq ( irq , display_pipe_interrupt_handler , 0 , pdev -> name , NULL ) ; if ( ret < 0 ) { dev_err ( & hlpe_pdev -> dev , "request_irq<S2SV_blank>failed\\n" ) ; <S2SV_StartBug> iounmap ( mmio_start ) ; <S2SV_EndBug> return - ENODEV ; } ctx = kzalloc ( sizeof ( * ctx ) , GFP_KERNEL ) ; if ( ctx == NULL ) { <S2SV_StartBug> free_irq ( irq , NULL ) ; <S2SV_EndBug> iounmap ( mmio_start ) ; return - ENOMEM ; <S2SV_StartBug> } <S2SV_EndBug> ctx -> irq = irq ; dev_dbg ( & hlpe_pdev -> dev , "hdmi<S2SV_blank>lpe<S2SV_blank>audio:<S2SV_blank>irq<S2SV_blank>num<S2SV_blank>=<S2SV_blank>%d\\n" , irq ) ; ctx -> mmio_start = mmio_start ; ctx -> tmds_clock_speed = DIS_SAMPLE_RATE_148_5 ; INIT_WORK ( & ctx -> hdmi_audio_wq , _had_wq ) ; if ( pci_dev_present ( cherryview_ids ) ) dev_dbg ( & hlpe_pdev -> dev , "%s:<S2SV_blank>Cherrytrail<S2SV_blank>LPE<S2SV_blank>-<S2SV_blank>Detected\\n" , __func__ ) ; else dev_dbg ( & hlpe_pdev -> dev , "%s:<S2SV_blank>Baytrail<S2SV_blank>LPE<S2SV_blank>-<S2SV_blank>Assume\\n" , __func__ ) ; ctx -> had_config_offset = AUDIO_HDMI_CONFIG_A ; pdata = pdev -> dev . platform_data ; if ( pdata == NULL ) { dev_err ( & hlpe_pdev -> dev , "%s:<S2SV_blank>quit:<S2SV_blank>pdata<S2SV_blank>not<S2SV_blank>allocated<S2SV_blank>by<S2SV_blank>i915!!\\n" , __func__ ) ; <S2SV_StartBug> kfree ( ctx ) ; <S2SV_EndBug> free_irq ( irq , NULL ) ; iounmap ( mmio_start ) ; return - ENOMEM ; <S2SV_StartBug> } <S2SV_EndBug> platform_set_drvdata ( pdev , ctx ) ; ret = hdmi_audio_probe ( pdev , & ctx -> had ) ; <S2SV_StartBug> dev_dbg ( & hlpe_pdev -> dev , "hdmi<S2SV_blank>lpe<S2SV_blank>audio:<S2SV_blank>setting<S2SV_blank>pin<S2SV_blank>eld<S2SV_blank>notify<S2SV_blank>callback\\n" ) ; <S2SV_EndBug> dev_dbg ( & hlpe_pdev -> dev , "%s:<S2SV_blank>Scheduling<S2SV_blank>HDMI<S2SV_blank>audio<S2SV_blank>work<S2SV_blank>queue\\n" , __func__ ) ; schedule_work ( & ctx -> hdmi_audio_wq ) ; spin_lock_irqsave ( & pdata -> lpe_audio_slock , flag_irq ) ; pdata -> notify_audio_lpe = notify_audio_lpe ; if ( pdata -> notify_pending ) { dev_dbg ( & hlpe_pdev -> dev , "%s:<S2SV_blank>handle<S2SV_blank>pending<S2SV_blank>notification\\n" , __func__ ) ; notify_audio_lpe ( pdev ) ; pdata -> notify_pending = false ; } spin_unlock_irqrestore ( & pdata -> lpe_audio_slock , flag_irq ) ; return ret ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> "request_irq<S2SV_blank>failed\\n" ) ; goto error_irq <S2SV_ModEnd> ; } ctx <S2SV_ModStart> NULL ) { ret = <S2SV_ModEnd> - ENOMEM ; <S2SV_ModStart> - ENOMEM ; goto error_ctx ; <S2SV_ModStart> __func__ ) ; ret = <S2SV_ModEnd> - ENOMEM ; <S2SV_ModStart> - ENOMEM ; goto error_probe ; <S2SV_ModStart> had ) ; if ( ret < 0 ) goto error_probe ; <S2SV_ModStart> return ret ; error_probe : kfree ( ctx ) ; error_ctx : free_irq ( irq , NULL ) ; error_irq : iounmap ( mmio_start ) ; return ret ; |
2,493 | CWE-000 <S2SV_StartBug> void applySetting ( char * * content , void * data ) <S2SV_EndBug> { AppData * appData = data ; char key [ MAX_SETTING_SIZE ] ; char value [ MAX_SETTING_SIZE ] ; int ok ; <S2SV_StartBug> ok = parseSetting ( * content , key , value ) ; <S2SV_EndBug> if ( ok == 0 ) { if ( strcmp ( key , "version" ) == 0 ) { strcpy ( appData -> version , value ) ; } else if ( strcmp ( key , "something" ) == 0 ) { } } } | <S2SV_ModStart> applySetting ( char <S2SV_ModEnd> * content , <S2SV_ModStart> = parseSetting ( <S2SV_ModEnd> content , key |
2,494 | CWE-000 char * field_width ( char * str , int len ) { char * ret ; int i ; if ( ft_strlen ( str ) < len ) { if ( ! ( ret = ( char * ) malloc ( sizeof ( char ) * ( len + 1 ) ) ) ) return ( NULL ) ; ret [ len ] = 0 ; ft_memset ( ret , '<S2SV_blank>' , len ) ; i = ft_strlen ( str ) - 1 ; while ( i >= 0 ) { ret [ len - 1 ] = str [ i ] ; i -- ; len -- ; } free ( str ) ; <S2SV_StartBug> printf ( "passing<S2SV_blank>by<S2SV_blank>width:<S2SV_blank>%s\\n" , ret ) ; <S2SV_EndBug> return ( ret ) ; } return ( str ) ; } | <S2SV_ModStart> str ) ; <S2SV_ModEnd> return ( ret |
2,495 | CWE-000 int eigrp_hello_timer ( struct thread * thread ) { struct eigrp_interface * ei ; ei = THREAD_ARG ( thread ) ; ei -> t_hello = NULL ; if ( IS_DEBUG_EIGRP ( 0 , TIMERS ) ) <S2SV_StartBug> zlog ( NULL , LOG_DEBUG , "Start<S2SV_blank>Hello<S2SV_blank>Timer<S2SV_blank>(%s)<S2SV_blank>Expire<S2SV_blank>[%u]" , <S2SV_EndBug> IF_NAME ( ei ) , EIGRP_IF_PARAM ( ei , v_hello ) ) ; eigrp_hello_send ( ei , EIGRP_HELLO_NORMAL , NULL ) ; ei -> t_hello = thread_add_timer ( master , eigrp_hello_timer , ei , EIGRP_IF_PARAM ( ei , v_hello ) ) ; return 0 ; } | <S2SV_ModStart> TIMERS ) ) zlog_debug ( <S2SV_ModEnd> "Start<S2SV_blank>Hello<S2SV_blank>Timer<S2SV_blank>(%s)<S2SV_blank>Expire<S2SV_blank>[%u]" , IF_NAME |
2,496 | CWE-000 enum responseCodes canfr_canrecvStart ( busInterface itfName ) { int ret = CB_ERROR ; struct ifreq ifr ; itfName = itfName & 3 ; int err ; <S2SV_StartBug> err = rt_sem_create ( & sem_desc , "MySemaphore" , SEM_INIT , SEM_MODE ) ; <S2SV_EndBug> switch ( itfName ) { case ITF_RTCANALL : strncpy ( ifr . ifr_name , "rtcan0" , IFNAMSIZ ) ; ret = canRecvStartOnItf ( ifr , ITF_RTCAN0 ) ; if ( ret == CB_SUCCESS ) { rt_task_create ( & rtcan0MsgRecv_task , "rtcan0_Task" , 0 , 50 , 0 ) ; rt_task_start ( & rtcan0MsgRecv_task , rtcan0MsgRecv_func , NULL ) ; } else { if ( print_error ) rt_printf ( "Can<S2SV_blank>not<S2SV_blank>start<S2SV_blank>can<S2SV_blank>recv<S2SV_blank>at<S2SV_blank>rtcan0\\n" ) ; } strncpy ( ifr . ifr_name , "rtcan1" , IFNAMSIZ ) ; ret = canRecvStartOnItf ( ifr , ITF_RTCAN1 ) ; if ( ret == CB_SUCCESS ) { rt_task_create ( & rtcan1MsgRecv_task , "rtcan1_Task" , 0 , 50 , 0 ) ; rt_task_start ( & rtcan1MsgRecv_task , rtcan1MsgRecv_func , NULL ) ; } else { if ( print_error ) rt_printf ( "Can<S2SV_blank>not<S2SV_blank>start<S2SV_blank>can<S2SV_blank>recv<S2SV_blank>at<S2SV_blank>rtcan1\\n" ) ; } break ; case ITF_RTCAN0 : strncpy ( ifr . ifr_name , "rtcan0" , IFNAMSIZ ) ; ret = canRecvStartOnItf ( ifr , ITF_RTCAN0 ) ; if ( ret == CB_SUCCESS ) { rt_task_create ( & rtcan0MsgRecv_task , "rtcan0_Task" , 0 , 50 , 0 ) ; rt_task_start ( & rtcan0MsgRecv_task , rtcan0MsgRecv_func , NULL ) ; } else { if ( print_error ) rt_printf ( "Can<S2SV_blank>not<S2SV_blank>start<S2SV_blank>can<S2SV_blank>recv<S2SV_blank>at<S2SV_blank>rtcan0\\n" ) ; } break ; case ITF_RTCAN1 : strncpy ( ifr . ifr_name , "rtcan1" , IFNAMSIZ ) ; ret = canRecvStartOnItf ( ifr , ITF_RTCAN1 ) ; if ( ret == CB_SUCCESS ) { rt_task_create ( & rtcan0MsgRecv_task , "rtcan1_Task" , 0 , 50 , 0 ) ; rt_task_start ( & rtcan0MsgRecv_task , rtcan0MsgRecv_func , NULL ) ; } else { if ( print_error ) rt_printf ( "Can<S2SV_blank>not<S2SV_blank>start<S2SV_blank>can<S2SV_blank>recv<S2SV_blank>at<S2SV_blank>rtcan1\\n" ) ; } break ; default : if ( print_error ) rt_printf ( "Unknown<S2SV_blank>interface<S2SV_blank>value<S2SV_blank>" ) ; ret = CB_ERR_WRONG_BUS_TYPE ; break ; } return ret ; } | <S2SV_ModStart> rt_sem_create ( & sem_vel_desc , "semaphoreForVelocity" , SEM_INIT , SEM_MODE ) ; err = rt_sem_create ( & sem_vel_desc , "semaphoreForBattery" <S2SV_ModEnd> , SEM_INIT , |
2,497 | CWE-000 int ffs_release ( const char * path , struct fuse_file_info * fi ) { <S2SV_StartBug> int fd = ffs_fdmap_get ( path ) ; <S2SV_EndBug> close ( fd ) ; ffs_fdmap_remove ( path ) ; return 0 ; } | <S2SV_ModStart> fi ) { <S2SV_ModEnd> return 0 ; |
2,498 | CWE-000 <S2SV_StartBug> static int <S2SV_EndBug> uvn_put ( uobj , pps , npages , flags ) struct uvm_object * uobj ; struct vm_page * * pps ; int npages , flags ; { struct vnode * vp = ( struct vnode * ) uobj ; int error ; error = VOP_PUTPAGES ( vp , pps , npages , flags , NULL ) ; return error ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> <S2SV_ModEnd> int uvn_put ( |
2,499 | CWE-000 <S2SV_StartBug> static void ss_save_csc_matrix ( FILE * file , const SS_Matrix * A ) <S2SV_EndBug> { uint64_t i ; const uint64_t isize = sizeof ( i ) ; double x ; const uint64_t xsize = sizeof ( x ) ; size_t nwritten = fwrite ( SS_MATRIX_BINARY_HEADER , 1 , sizeof ( SS_MATRIX_BINARY_HEADER ) , file ) ; if ( nwritten != sizeof ( SS_MATRIX_BINARY_HEADER ) ) goto error_exit ; int32_t f = A -> format ; nwritten = fwrite ( & f , sizeof ( int32_t ) , 1 , file ) ; i = A -> rowdim ; nwritten += fwrite ( & i , isize , 1 , file ) ; i = A -> coldim ; nwritten += fwrite ( & i , isize , 1 , file ) ; if ( nwritten != 3 ) goto error_exit ; const SS_CSC_Matrix_Store * store = A -> store ; for ( SS_Int col = 0 ; col < A -> coldim ; ++ col ) { const uint64_t nelems = store -> colptr [ col + 1 ] - store -> colptr [ col ] ; nwritten = fwrite ( & nelems , isize , 1 , file ) ; for ( SS_Int elem = 0 ; elem < nelems ; ++ elem ) { i = store -> rowvals [ elem ] . indx ; x = store -> rowvals [ elem ] . val ; nwritten += fwrite ( & i , isize , 1 , file ) ; nwritten += fwrite ( & x , xsize , 1 , file ) ; } if ( nwritten != 2 * nelems + 1 ) goto error_exit ; } <S2SV_StartBug> return ; <S2SV_EndBug> error_exit : fprintf ( stderr , "ss_save_matrix:<S2SV_blank>Filesystem<S2SV_blank>write<S2SV_blank>error<S2SV_blank>-<S2SV_blank>saving<S2SV_blank>" "matrix<S2SV_blank>was<S2SV_blank>not<S2SV_blank>completed\\n" ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> <S2SV_null> <S2SV_null> static int <S2SV_ModEnd> ss_save_csc_matrix ( FILE <S2SV_ModStart> ; } return 0 <S2SV_ModStart> "matrix<S2SV_blank>was<S2SV_blank>not<S2SV_blank>completed\\n" ) ; return 1 ; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.