Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
5,200 | CWE-000 <S2SV_StartBug> I main ( ) { init ( ) ; <S2SV_EndBug> <S2SV_StartBug> K s1 = r1 ( r1 ( ks ( "ciao" ) ) ) ; <S2SV_EndBug> K s2 = r1 ( ks ( "ciao" ) ) ; K x = r1 ( ktn ( 0 , 0 ) ) ; jk ( & x , s1 ) ; r0 ( s1 ) ; <S2SV_StartBug> r0 ( x ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( ) ; repl ( ) ; <S2SV_ModStart> K s1 = kp ( "2+2\\n" ) ; s1 -> n -- ; js ( & s1 , ";" <S2SV_ModEnd> ) ; r0 <S2SV_ModStart> s1 ) ; K s2 = kp ( "2+2" ) ; r0 ( s2 <S2SV_ModEnd> ) ; } |
5,201 | CWE-000 XS ( set_error ) { dXSARGS ; <S2SV_StartBug> if ( items >= 1 ) <S2SV_EndBug> last_error = SvIV ( ST ( 0 ) ) ; nbdkit_set_error ( last_error ) ; <S2SV_StartBug> XSRETURN_EMPTY ; <S2SV_EndBug> } | <S2SV_ModStart> >= 1 ) { <S2SV_ModStart> last_error ) ; } |
5,202 | CWE-000 static Selectivity mcelem_array_contained_selec ( Datum * mcelem , int nmcelem , float4 * numbers , int nnumbers , Datum * array_data , int nitems , float4 * hist , int nhist , Oid operator , FmgrInfo * cmpfunc ) { int mcelem_index , i , unique_nitems = 0 ; float selec , minfreq , nullelem_freq ; float * dist , * mcelem_dist , * hist_part ; float avg_count , mult , rest ; float * elem_selec ; if ( numbers == NULL || nnumbers != nmcelem + 3 ) return DEFAULT_CONTAIN_SEL ; if ( hist == NULL || nhist < 3 ) return DEFAULT_CONTAIN_SEL ; minfreq = numbers [ nmcelem ] ; nullelem_freq = numbers [ nmcelem + 2 ] ; avg_count = hist [ nhist - 1 ] ; rest = avg_count ; mult = 1.0f ; elem_selec = ( float * ) palloc ( sizeof ( float ) * nitems ) ; mcelem_index = 0 ; for ( i = 0 ; i < nitems ; i ++ ) { bool match = false ; if ( i > 0 && <S2SV_StartBug> element_compare ( & array_data [ i - 1 ] , & array_data [ i ] , cmpfunc ) == 0 ) <S2SV_EndBug> continue ; while ( mcelem_index < nmcelem ) { <S2SV_StartBug> int cmp = element_compare ( & mcelem [ mcelem_index ] , <S2SV_EndBug> & array_data [ i ] , cmpfunc ) ; if ( cmp < 0 ) { mult *= ( 1.0f - numbers [ mcelem_index ] ) ; rest -= numbers [ mcelem_index ] ; mcelem_index ++ ; } else { if ( cmp == 0 ) match = true ; break ; } } if ( match ) { elem_selec [ unique_nitems ] = numbers [ mcelem_index ] ; rest -= numbers [ mcelem_index ] ; mcelem_index ++ ; } else { elem_selec [ unique_nitems ] = Min ( DEFAULT_CONTAIN_SEL , minfreq / 2 ) ; } unique_nitems ++ ; } while ( mcelem_index < nmcelem ) { mult *= ( 1.0f - numbers [ mcelem_index ] ) ; rest -= numbers [ mcelem_index ] ; mcelem_index ++ ; } mult *= exp ( - rest ) ; # define EFFORT 100 if ( ( nmcelem + unique_nitems ) > 0 && unique_nitems > EFFORT * nmcelem / ( nmcelem + unique_nitems ) ) { double b = ( double ) nmcelem ; int n ; n = ( int ) ( ( sqrt ( b * b + 4 * EFFORT * b ) - b ) / 2 ) ; qsort ( elem_selec , unique_nitems , sizeof ( float ) , float_compare_desc ) ; unique_nitems = n ; } dist = calc_distr ( elem_selec , unique_nitems , unique_nitems , 0.0f ) ; mcelem_dist = calc_distr ( numbers , nmcelem , unique_nitems , rest ) ; hist_part = calc_hist ( hist , nhist - 1 , unique_nitems ) ; selec = 0.0f ; for ( i = 0 ; i <= unique_nitems ; i ++ ) { if ( mcelem_dist [ i ] > 0 ) selec += hist_part [ i ] * mult * dist [ i ] / mcelem_dist [ i ] ; } pfree ( dist ) ; pfree ( mcelem_dist ) ; pfree ( hist_part ) ; pfree ( elem_selec ) ; selec *= ( 1.0f - nullelem_freq ) ; CLAMP_PROBABILITY ( selec ) ; return selec ; } | <S2SV_ModStart> > 0 && CALL_QSORT_ARG_COMPARATOR ( element_compare , <S2SV_ModEnd> & array_data [ <S2SV_ModStart> int cmp = CALL_QSORT_ARG_COMPARATOR ( element_compare , <S2SV_ModEnd> & mcelem [ |
5,203 | CWE-000 <S2SV_StartBug> node_ptr mark ( node_ptr node ) { <S2SV_EndBug> return ( node_ptr ) ( ( size_t ) node | 0x1 ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static |
5,204 | CWE-000 static int whereLoopCheaperProperSubset ( const WhereLoop * pX , const WhereLoop * pY ) { int i , j ; if ( pX -> nLTerm - pX -> nSkip >= pY -> nLTerm - pY -> nSkip ) { return 0 ; } if ( pY -> nSkip > pX -> nSkip ) return 0 ; if ( pX -> rRun >= pY -> rRun ) { if ( pX -> rRun > pY -> rRun ) return 0 ; if ( pX -> nOut > pY -> nOut ) return 0 ; } for ( i = pX -> nLTerm - 1 ; i >= 0 ; i -- ) { if ( pX -> aLTerm [ i ] == 0 ) continue ; for ( j = pY -> nLTerm - 1 ; j >= 0 ; j -- ) { if ( pY -> aLTerm [ j ] == pX -> aLTerm [ i ] ) break ; } if ( j < 0 ) return 0 ; } <S2SV_StartBug> return 1 ; <S2SV_EndBug> } | <S2SV_ModStart> 0 ; } if ( ( pX -> wsFlags & WHERE_IDX_ONLY ) != 0 && ( pY -> wsFlags & WHERE_IDX_ONLY ) == 0 ) { return 0 ; } |
5,205 | CWE-000 SECStatus PublicKey_encrypt ( PublicKey pubkey , unsigned char * output , unsigned int * outputLen , unsigned int maxOutputLen , const unsigned char * input , unsigned int inputLen ) { if ( pubkey == NULL ) return SECFailure ; if ( inputLen >= MAX_ENCRYPT_LEN ) return SECFailure ; unsigned int needLen ; if ( PublicKey_encryptSize ( inputLen , & needLen ) != SECSuccess ) return SECFailure ; if ( maxOutputLen < needLen ) return SECFailure ; SECStatus rv = SECSuccess ; PublicKey eph_pub = NULL ; PrivateKey eph_priv = NULL ; <S2SV_StartBug> PK11SymKey * aes_key = NULL ; <S2SV_EndBug> unsigned char nonce [ GCM_IV_LEN_BYTES ] ; <S2SV_StartBug> unsigned char aadBuf [ AAD_LEN ] ; <S2SV_EndBug> P_CHECKC ( rand_bytes ( nonce , GCM_IV_LEN_BYTES ) ) ; P_CHECKC ( Keypair_new ( & eph_priv , & eph_pub ) ) ; P_CHECKC ( derive_dh_secret ( & aes_key , eph_priv , pubkey ) ) ; CK_GCM_PARAMS param ; SECItem paramItem ; set_gcm_params ( & paramItem , & param , nonce , eph_pub , aadBuf ) ; const SECItem * pk = PublicKey_toBytes ( eph_pub ) ; P_CHECKCB ( pk -> len == CURVE25519_KEY_LEN ) ; memcpy ( output , pk -> data , pk -> len ) ; memcpy ( output + CURVE25519_KEY_LEN , param . pIv , param . ulIvLen ) ; const int offset = CURVE25519_KEY_LEN + param . ulIvLen ; P_CHECKC ( PK11_Encrypt ( aes_key , CKM_AES_GCM , & paramItem , output + offset , outputLen , maxOutputLen - offset , input , inputLen ) ) ; * outputLen = * outputLen + CURVE25519_KEY_LEN + GCM_IV_LEN_BYTES ; cleanup : <S2SV_StartBug> PublicKey_clear ( eph_pub ) ; <S2SV_EndBug> PrivateKey_clear ( eph_priv ) ; if ( aes_key ) PK11_FreeSymKey ( aes_key ) ; return rv ; } | <S2SV_ModStart> PK11SymKey * aes_key = NULL ; unsigned char * aadBuf <S2SV_ModStart> GCM_IV_LEN_BYTES ] ; P_CHECKA ( aadBuf = safe_calloc ( AAD_LEN , sizeof ( unsigned char ) ) ) <S2SV_ModEnd> ; P_CHECKC ( <S2SV_ModStart> ; cleanup : if ( aadBuf ) free ( aadBuf ) ; |
5,206 | CWE-000 int gwbuf_compare ( const GWBUF * lhs , const GWBUF * rhs ) { int rv ; if ( ( lhs == NULL ) && ( rhs == NULL ) ) { rv = 0 ; } else if ( lhs == NULL ) { ss_dassert ( rhs ) ; rv = - 1 ; } else if ( rhs == NULL ) { ss_dassert ( lhs ) ; rv = 1 ; } else { ss_dassert ( lhs && rhs ) ; size_t llen = gwbuf_length ( lhs ) ; size_t rlen = gwbuf_length ( rhs ) ; if ( llen < rlen ) { rv = - 1 ; } else if ( rlen < llen ) { rv = 1 ; } else { ss_dassert ( llen == rlen ) ; rv = 0 ; size_t i = 0 ; size_t loffset = 0 ; size_t roffset = 0 ; while ( ( rv == 0 ) && ( i < llen ) ) { <S2SV_StartBug> uint8_t lc ; <S2SV_EndBug> <S2SV_StartBug> uint8_t rc ; <S2SV_EndBug> ss_debug ( bool rv1 = ) gwbuf_get_byte ( & lhs , & loffset , & lc ) ; ss_debug ( bool rv2 = ) gwbuf_get_byte ( & rhs , & roffset , & rc ) ; ss_dassert ( rv1 && rv2 ) ; rv = ( int ) lc - ( int ) rc ; ++ i ; } if ( rv < 0 ) { rv = - 1 ; } else if ( rv > 0 ) { rv = 1 ; } } } return rv ; } | <S2SV_ModStart> { uint8_t lc = 0 <S2SV_ModStart> ; uint8_t rc = 0 |
5,207 | CWE-000 int tmtag_file_has_tags ( const TMFile * file , const TagVector * tags ) { file_filter filter = NULL ; int passes_filter = 0 ; for ( int i = 0 ; i < tags -> size ; i ++ ) { filter = find_filter ( tags -> tags [ i ] [ 0 ] ) ; <S2SV_StartBug> if ( filter ) <S2SV_EndBug> passes_filter = filter ( file , tags -> tags [ i ] + 1 ) ; <S2SV_StartBug> else <S2SV_EndBug> passes_filter = check_tmdb ( tmdb_has_tag ( file -> id , tags -> tags [ i ] ) ) ; <S2SV_StartBug> if ( passes_filter <= 0 ) <S2SV_EndBug> return passes_filter ; } return 1 ; } | <S2SV_ModStart> ( filter ) { <S2SV_ModStart> 1 ) ; } else { <S2SV_ModEnd> passes_filter = check_tmdb <S2SV_ModStart> ) ) ; } |
5,208 | CWE-000 void draw_rect ( GUI gui , Camera camera , const int64_t x , const int64_t y , const int64_t wd , const int64_t ht ) { <S2SV_StartBug> Point_Int32 pt = offset_point ( gui , camera , x , y ) ; <S2SV_EndBug> <S2SV_StartBug> SDL_Rect rect = { pt . x , pt . y , wd , ht } ; <S2SV_EndBug> SDL_RenderDrawRect ( get_renderer ( gui ) , & rect ) ; } | <S2SV_ModStart> ht ) { struct pt_float <S2SV_ModEnd> pt = offset_point <S2SV_ModStart> rect = { ( int ) <S2SV_ModStart> . x , ( int ) |
5,209 | CWE-000 int plugin_gather ( plugin_t * p ) { DEBUG ( zlog_debug ( p -> tag , "..<S2SV_blank>Gather" ) ) ; if ( ! p -> working ) p -> working = get_packet ( METRIC ) ; packet_t * pkt = p -> working ; if ( pkt -> state == EMPTY ) { packet_append ( pkt , "{\\"license\\":\\"%s\\",\\"tid\\":%llu,\\"metrics\\":[" , license , p -> tid ) ; pkt -> state = BEGIN ; } epoch_t begin = epoch_time ( ) ; if ( pkt -> state == BEGIN ) pkt -> started = begin ; packet_transaction ( pkt ) ; if ( pkt -> state == WROTE ) packet_append ( pkt , "," ) ; packet_append ( pkt , "{\\"timestamp\\":%llu," , begin ) ; switch ( packet_gather ( pkt , "values" , p -> gather , p -> module ) ) { case ENONE : packet_append ( pkt , "}" ) ; if ( pkt -> state == BEGIN ) pkt -> state = WROTE ; packet_commit ( pkt ) ; break ; case ENODATA : packet_rollback ( pkt ) ; break ; case EPLUGUP : packet_rollback ( pkt ) ; routine_change_task ( & p -> r , plugin_alert_up ) ; break ; case EPLUGDOWN : packet_rollback ( pkt ) ; routine_change_task ( & p -> r , plugin_alert_down ) ; break ; } if ( packet_expired ( pkt ) ) { if ( pkt -> state == WROTE ) { packet_append ( pkt , "]}" ) ; pkt -> state = READY ; p -> working = 0 ; } else { pkt -> state = DONE ; p -> working = 0 ; } } <S2SV_StartBug> DEBUG ( zlog_debug ( p -> tag , "..<S2SV_blank>%d<S2SV_blank>bytes,<S2SV_blank>in<S2SV_blank>%llums" , pkt -> size , epoch_time ( ) - begin ) ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> ; } } printf ( "%s\\n" , pkt -> payload ) ; |
5,210 | CWE-000 int hist_browser__run ( struct hist_browser * browser , const char * help , bool warn_lost_event ) { int key ; char title [ 160 ] ; struct hist_browser_timer * hbt = browser -> hbt ; int delay_secs = hbt ? hbt -> refresh : 0 ; browser -> b . entries = & browser -> hists -> entries ; browser -> b . nr_entries = hist_browser__nr_entries ( browser ) ; hist_browser__title ( browser , title , sizeof ( title ) ) ; if ( ui_browser__show ( & browser -> b , title , "%s" , help ) < 0 ) return - 1 ; while ( 1 ) { key = ui_browser__run ( & browser -> b , delay_secs ) ; switch ( key ) { case K_TIMER : { u64 nr_entries ; hbt -> timer ( hbt -> arg ) ; if ( hist_browser__has_filter ( browser ) || symbol_conf . report_hierarchy ) hist_browser__update_nr_entries ( browser ) ; nr_entries = hist_browser__nr_entries ( browser ) ; ui_browser__update_nr_entries ( & browser -> b , nr_entries ) ; if ( warn_lost_event && ( browser -> hists -> stats . nr_lost_warned != browser -> hists -> stats . nr_events [ PERF_RECORD_LOST ] ) ) { browser -> hists -> stats . nr_lost_warned = browser -> hists -> stats . nr_events [ PERF_RECORD_LOST ] ; ui_browser__warn_lost_events ( & browser -> b ) ; } hist_browser__title ( browser , title , sizeof ( title ) ) ; ui_browser__show_title ( & browser -> b , title ) ; continue ; } case 'D' : { static int seq ; struct hist_entry * h = rb_entry ( browser -> b . top , struct hist_entry , rb_node ) ; ui_helpline__pop ( ) ; <S2SV_StartBug> ui_helpline__fpush ( "%d:<S2SV_blank>nr_ent=(%d,%d),<S2SV_blank>rows=%d,<S2SV_blank>idx=%d,<S2SV_blank>fve:<S2SV_blank>idx=%d,<S2SV_blank>row_off=%d,<S2SV_blank>nrows=%d" , <S2SV_EndBug> seq ++ , browser -> b . nr_entries , browser -> hists -> nr_entries , <S2SV_StartBug> browser -> b . rows , <S2SV_EndBug> browser -> b . index , browser -> b . top_idx , h -> row_offset , h -> nr_rows ) ; } break ; case 'C' : hist_browser__set_folding ( browser , false ) ; break ; case 'c' : hist_browser__set_folding_selected ( browser , false ) ; break ; case 'E' : hist_browser__set_folding ( browser , true ) ; break ; case 'e' : hist_browser__set_folding_selected ( browser , true ) ; break ; case 'H' : browser -> show_headers = ! browser -> show_headers ; hist_browser__update_rows ( browser ) ; break ; case K_ENTER : if ( hist_browser__toggle_fold ( browser ) ) break ; default : goto out ; } } out : ui_browser__hide ( & browser -> b ) ; return key ; } | <S2SV_ModStart> ; ui_helpline__fpush ( "%d:<S2SV_blank>nr_ent=(%d,%d),<S2SV_blank>etl:<S2SV_blank>%d,<S2SV_blank>rows=%d,<S2SV_blank>idx=%d,<S2SV_blank>fve:<S2SV_blank>idx=%d,<S2SV_blank>row_off=%d,<S2SV_blank>nrows=%d" <S2SV_ModEnd> , seq ++ <S2SV_ModStart> -> b . extra_title_lines , browser -> b . |
5,211 | CWE-000 int compareByKey ( void * a , void * b ) { <S2SV_StartBug> long a1 = ( ( struct integer_pair * ) a ) -> key ; <S2SV_EndBug> <S2SV_StartBug> long b1 = ( ( struct integer_pair * ) b ) -> key ; <S2SV_EndBug> int res ; if ( a1 > b1 ) { res = 1 ; } else if ( b1 > a1 ) { res = - 1 ; } else { res = 0 ; } return res ; } | <S2SV_ModStart> b ) { int <S2SV_ModEnd> a1 = ( <S2SV_ModStart> -> key ; int <S2SV_ModEnd> b1 = ( |
5,212 | CWE-000 static int common_path_parser ( search_items * s , char * path ) { char * term ; if ( ! s -> filename ) { s -> filename = malloc ( sizeof ( slist ) ) ; if ( s -> filename == NULL ) return 1 ; slist_create ( s -> filename ) ; } if ( * path == \'"\' ) { path ++ ; term = strchr ( path , \'"\' ) ; if ( term == NULL ) return 2 ; * term = 0 ; if ( s -> filename ) { snode sn ; sn . str = strdup ( path ) ; sn . key = NULL ; sn . hits = 1 ; if ( ( sn . str [ 0 ] == '.' ) && ( ( sn . str [ 1 ] == '.' ) || ( sn . str [ 1 ] == '/' ) ) && s -> cwd ) { char * tmp = malloc ( PATH_MAX ) ; if ( tmp == NULL ) { free ( sn . str ) ; return 3 ; } snprintf ( tmp , PATH_MAX , "%s/%s" , s -> cwd , sn . str ) ; free ( sn . str ) ; sn . str = tmp ; } slist_append ( s -> filename , & sn ) ; } * term = \'"\' ; } else { if ( s -> filename ) { snode sn ; sn . key = NULL ; sn . hits = 1 ; if ( strncmp ( path , "(null)" , 6 ) == 0 ) { sn . str = strdup ( "(null)" ) ; goto append ; } if ( ! isxdigit ( path [ 0 ] ) ) return 4 ; if ( path [ 0 ] == '0' && path [ 1 ] == '0' ) sn . str = unescape ( & path [ 2 ] ) ; else { term = strchr ( path , '<S2SV_blank>' ) ; if ( term == NULL ) return 5 ; * term = 0 ; sn . str = unescape ( path ) ; * term = '<S2SV_blank>' ; } <S2SV_StartBug> if ( ( sn . str [ 0 ] == '.' ) && ( ( sn . str [ 1 ] == '.' ) || <S2SV_EndBug> ( sn . str [ 1 ] == '/' ) ) && s -> cwd ) { char * tmp = malloc ( PATH_MAX ) ; if ( tmp == NULL ) return 6 ; snprintf ( tmp , PATH_MAX , "%s/%s" , s -> cwd , sn . str ) ; free ( sn . str ) ; sn . str = tmp ; } append : slist_append ( s -> filename , & sn ) ; } } return 0 ; } | <S2SV_ModStart> } if ( sn . str == NULL ) return 7 ; if ( |
5,213 | CWE-000 int ui_loadfilelistpage ( ui_context * ctx ) <S2SV_StartBug> { <S2SV_EndBug> # ifdef DEBUG dbg_printf ( "enter<S2SV_blank>ui_loadfilelistpage\\n" ) ; # endif <S2SV_StartBug> int i , j , y_pos ; <S2SV_EndBug> unsigned char displayentry ; unsigned char entrytype_icon ; i = 0 ; do { memset ( & DirectoryEntry_tab [ i ] , 0 , sizeof ( disk_in_drive_v2_long ) ) ; i ++ ; } while ( ( i < ctx -> NUMBER_OF_FILE_ON_DISPLAY ) ) ; memcpy ( & file_list_status , & file_list_status_tab [ ctx -> page_number ] , sizeof ( FL_DIR ) ) ; last_file = 0x00 ; clear_list ( ctx ) ; y_pos = FILELIST_Y_POS ; hxc_printf ( ctx , CENTER_ALIGNED , 0 , y_pos , "---<S2SV_blank>SD/USB<S2SV_blank>Media<S2SV_blank>files<S2SV_blank>---" ) ; y_pos ++ ; i = 0 ; do { displayentry = 0xFF ; if ( ! fl_readdir ( & file_list_status , & dir_entry ) ) { if ( ctx -> filtermode ) { if ( ! stristr ( dir_entry . filename , ctx -> filter ) ) { displayentry = 0x00 ; } } if ( displayentry ) { getext ( dir_entry . filename , ( char * ) & DirectoryEntry_tab [ i ] . type ) ; j = 0 ; while ( j < MAX_LONG_NAME_LENGHT && dir_entry . filename [ j ] ) { DirectoryEntry_tab [ i ] . name [ j ] = dir_entry . filename [ j ] ; j ++ ; } DirectoryEntry_tab [ i ] . name [ j ] = 0x00 ; DirectoryEntry_tab [ i ] . attributes = 0x00 ; if ( dir_entry . is_dir ) { DirectoryEntry_tab [ i ] . attributes = FILE_ATTR_DIRECTORY ; } if ( dir_entry . is_readonly ) DirectoryEntry_tab [ i ] . attributes |= FILE_ATTR_READ_ONLY ; if ( dir_entry . is_system ) DirectoryEntry_tab [ i ] . attributes |= FILE_ATTR_SYSTEM ; if ( dir_entry . is_hidden ) DirectoryEntry_tab [ i ] . attributes |= FILE_ATTR_HIDDEN ; DirectoryEntry_tab [ i ] . firstCluster = ENDIAN_32BIT ( dir_entry . cluster ) ; DirectoryEntry_tab [ i ] . size = ENDIAN_32BIT ( dir_entry . size ) ; entrytype_icon = FONT_FILE_ICON ; if ( DirectoryEntry_tab [ i ] . attributes & FILE_ATTR_DIRECTORY ) entrytype_icon = FONT_FOLDER_ICON ; hxc_printf ( ctx , LEFT_ALIGNED | DONTPARSE , 0 , y_pos , "<S2SV_blank>%c%s" , entrytype_icon , DirectoryEntry_tab [ i ] . name ) ; y_pos ++ ; # ifdef DEBUG dbg_printf ( "Entry<S2SV_blank>:<S2SV_blank>%s<S2SV_blank>Size:%d<S2SV_blank>Cluster<S2SV_blank>0x%.8X<S2SV_blank>Flags<S2SV_blank>0x%.2X\\n" , DirectoryEntry_tab [ i ] . name , DirectoryEntry_tab [ i ] . size , DirectoryEntry_tab [ i ] . firstCluster , DirectoryEntry_tab [ i ] . attributes ) ; # endif i ++ ; } } else { last_file = 0xFF ; i = ctx -> NUMBER_OF_FILE_ON_DISPLAY ; } } while ( i < ctx -> NUMBER_OF_FILE_ON_DISPLAY ) ; if ( ctx -> page_number < MAX_PAGES_PER_DIRECTORY - 1 ) memcpy ( & file_list_status_tab [ ctx -> page_number + 1 ] , & file_list_status , sizeof ( FL_DIR ) ) ; return last_file ; } | <S2SV_ModStart> ctx ) { int i , j , y_pos ; unsigned char displayentry ; unsigned char entrytype_icon ; <S2SV_ModStart> ; # endif <S2SV_ModEnd> i = 0 |
5,214 | CWE-000 <S2SV_StartBug> char * getAccountRequest ( ) { <S2SV_EndBug> char * fmt = "{\\"request\\":\\"%s\\"}" ; <S2SV_StartBug> return oidc_sprintf ( fmt , REQUEST_VALUE_ACCOUNTLIST ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ( ) { START_APILOGLEVEL <S2SV_ModStart> = "{\\"request\\":\\"%s\\"}" ; char * ret = <S2SV_ModEnd> oidc_sprintf ( fmt <S2SV_ModStart> REQUEST_VALUE_ACCOUNTLIST ) ; END_APILOGLEVEL return ret ; |
5,215 | CWE-000 void BootStrapXLOG ( void ) { CheckPoint checkPoint ; char * buffer ; XLogPageHeader page ; XLogLongPageHeader longpage ; XLogRecord * record ; bool use_existent ; uint64 sysidentifier ; struct timeval tv ; pg_crc32 crc ; gettimeofday ( & tv , NULL ) ; sysidentifier = ( ( uint64 ) tv . tv_sec ) << 32 ; sysidentifier |= ( uint32 ) ( tv . tv_sec | tv . tv_usec ) ; ThisTimeLineID = 1 ; buffer = ( char * ) palloc ( XLOG_BLCKSZ + ALIGNOF_XLOG_BUFFER ) ; page = ( XLogPageHeader ) TYPEALIGN ( ALIGNOF_XLOG_BUFFER , buffer ) ; memset ( page , 0 , XLOG_BLCKSZ ) ; checkPoint . redo . xlogid = 0 ; checkPoint . redo . xrecoff = XLogSegSize + SizeOfXLogLongPHD ; checkPoint . ThisTimeLineID = ThisTimeLineID ; checkPoint . nextXidEpoch = 0 ; checkPoint . nextXid = FirstNormalTransactionId ; checkPoint . nextOid = FirstBootstrapObjectId ; <S2SV_StartBug> checkPoint . nextRelfilenode = FirstNormalObjectId ; <S2SV_EndBug> checkPoint . nextMulti = FirstMultiXactId ; checkPoint . nextMultiOffset = 0 ; checkPoint . oldestXid = FirstNormalTransactionId ; checkPoint . oldestXidDB = TemplateDbOid ; checkPoint . time = ( pg_time_t ) time ( NULL ) ; checkPoint . oldestActiveXid = InvalidTransactionId ; ShmemVariableCache -> nextXid = checkPoint . nextXid ; ShmemVariableCache -> nextOid = checkPoint . nextOid ; ShmemVariableCache -> oidCount = 0 ; ShmemVariableCache -> nextRelfilenode = checkPoint . nextRelfilenode ; ShmemVariableCache -> relfilenodeCount = 0 ; MultiXactSetNextMXact ( checkPoint . nextMulti , checkPoint . nextMultiOffset ) ; SetTransactionIdLimit ( checkPoint . oldestXid , checkPoint . oldestXidDB ) ; page -> xlp_magic = XLOG_PAGE_MAGIC ; page -> xlp_info = XLP_LONG_HEADER ; page -> xlp_tli = ThisTimeLineID ; page -> xlp_pageaddr . xlogid = 0 ; page -> xlp_pageaddr . xrecoff = XLogSegSize ; longpage = ( XLogLongPageHeader ) page ; longpage -> xlp_sysid = sysidentifier ; longpage -> xlp_seg_size = XLogSegSize ; longpage -> xlp_xlog_blcksz = XLOG_BLCKSZ ; record = ( XLogRecord * ) ( ( char * ) page + SizeOfXLogLongPHD ) ; record -> xl_prev . xlogid = 0 ; record -> xl_prev . xrecoff = XLogSegSize ; record -> xl_xid = InvalidTransactionId ; record -> xl_tot_len = SizeOfXLogRecord + sizeof ( checkPoint ) ; record -> xl_len = sizeof ( checkPoint ) ; record -> xl_info = XLOG_CHECKPOINT_SHUTDOWN ; record -> xl_rmid = RM_XLOG_ID ; memcpy ( XLogRecGetData ( record ) , & checkPoint , sizeof ( checkPoint ) ) ; INIT_CRC32C ( crc ) ; COMP_CRC32C ( crc , & checkPoint , sizeof ( checkPoint ) ) ; COMP_CRC32C ( crc , ( char * ) record + sizeof ( pg_crc32 ) , SizeOfXLogRecord - sizeof ( pg_crc32 ) ) ; FIN_CRC32C ( crc ) ; record -> xl_crc = crc ; use_existent = false ; openLogFile = XLogFileInit ( 0 , 1 , & use_existent , false ) ; errno = 0 ; if ( write ( openLogFile , page , XLOG_BLCKSZ ) != XLOG_BLCKSZ ) { if ( errno == 0 ) errno = ENOSPC ; ereport ( PANIC , ( errcode_for_file_access ( ) , errmsg ( "could<S2SV_blank>not<S2SV_blank>write<S2SV_blank>bootstrap<S2SV_blank>transaction<S2SV_blank>log<S2SV_blank>file:<S2SV_blank>%m" ) ) ) ; } if ( pg_fsync ( openLogFile ) != 0 ) ereport ( PANIC , ( errcode_for_file_access ( ) , errmsg ( "could<S2SV_blank>not<S2SV_blank>fsync<S2SV_blank>bootstrap<S2SV_blank>transaction<S2SV_blank>log<S2SV_blank>file:<S2SV_blank>%m" ) ) ) ; if ( close ( openLogFile ) ) ereport ( PANIC , ( errcode_for_file_access ( ) , errmsg ( "could<S2SV_blank>not<S2SV_blank>close<S2SV_blank>bootstrap<S2SV_blank>transaction<S2SV_blank>log<S2SV_blank>file:<S2SV_blank>%m" ) ) ) ; openLogFile = - 1 ; memset ( ControlFile , 0 , sizeof ( ControlFileData ) ) ; ControlFile -> system_identifier = sysidentifier ; ControlFile -> state = DB_SHUTDOWNED ; ControlFile -> time = checkPoint . time ; ControlFile -> checkPoint = checkPoint . redo ; ControlFile -> checkPointCopy = checkPoint ; ControlFile -> MaxConnections = MaxConnections ; ControlFile -> max_prepared_xacts = max_prepared_xacts ; ControlFile -> max_locks_per_xact = max_locks_per_xact ; ControlFile -> wal_level = wal_level ; ControlFile -> data_checksum_version = bootstrap_data_checksum_version ; WriteControlFile ( ) ; BootStrapCLOG ( ) ; BootStrapSUBTRANS ( ) ; BootStrapMultiXact ( ) ; DistributedLog_BootStrap ( ) ; pfree ( buffer ) ; } | <S2SV_ModStart> . nextRelfilenode = FirstBootstrapObjectId <S2SV_ModEnd> ; checkPoint . |
5,216 | CWE-000 void editorFreeRow ( erow * row ) { <S2SV_StartBug> free ( row -> render ) ; <S2SV_EndBug> <S2SV_StartBug> free ( row -> chars ) ; <S2SV_EndBug> <S2SV_StartBug> free ( row -> hl ) ; <S2SV_EndBug> } | <S2SV_ModStart> row ) { if ( row -> render != NULL ) <S2SV_ModStart> render ) ; if ( row -> chars != NULL ) <S2SV_ModStart> chars ) ; if ( row -> hl != NULL ) |
5,217 | CWE-000 static int cross_time_closest_sample ( struct sample * current_spl , struct sample * test_spl , double radius , PixelStore * store , struct field_id * current_field ) { <S2SV_StartBug> if ( current_field -> epoch != test_spl -> epoch || <S2SV_EndBug> current_field -> fieldindex != test_spl -> set -> field -> fieldindex ) { if ( current_field -> havematch ) { return 0 ; } else { <S2SV_StartBug> current_field -> epoch = test_spl -> epoch ; <S2SV_EndBug> current_field -> fieldindex = test_spl -> set -> field -> fieldindex ; } } current_field -> havematch = crossmatch ( current_spl , test_spl , radius , store ) ; return 1 ; } | <S2SV_ModStart> ( current_field -> <S2SV_ModEnd> fieldindex != test_spl <S2SV_ModStart> } else { <S2SV_ModEnd> current_field -> fieldindex |
5,218 | CWE-000 uint8_t * mbc_encode ( const uint8_t * data , size_t data_size ) { uint8_t * edata ; register size_t i , j ; edata = malloc ( data_size ) ; if ( edata == NULL ) return NULL ; <S2SV_StartBug> for ( i = 0 ; i < data_size ; i ++ ) <S2SV_EndBug> <S2SV_StartBug> edata [ i ] = data [ i ] ^ user_key [ i % user_key_size ] ; <S2SV_EndBug> for ( ; i < user_key_size ; i ++ ) edata [ i % data_size ] ^= user_key [ i ] ; for ( i = 0 ; i < data_size ; i ++ ) for ( j = 0 ; j < oct_key_size ; j ++ ) if ( edata [ i ] >> oct_key [ j ] [ 0 ] != edata [ i ] >> oct_key [ j ] [ 1 ] ) edata [ i ] ^= ( 0x01 << oct_key [ j ] [ 0 ] ) ^ ( 0x01 << oct_key [ j ] [ 1 ] ) ; return edata ; } | <S2SV_ModStart> return NULL ; memcpy ( edata , data , data_size ) ; <S2SV_ModStart> [ i ] ^= <S2SV_ModEnd> user_key [ i |
5,219 | CWE-000 unsigned long arch_get_unmapped_area ( struct file * filp , unsigned long addr , unsigned long len , unsigned long pgoff , unsigned long flags ) { struct mm_struct * mm = current -> mm ; struct vm_area_struct * vma ; struct vm_unmapped_area_info info ; <S2SV_StartBug> if ( len > TASK_SIZE ) <S2SV_EndBug> return - ENOMEM ; if ( flags & MAP_FIXED ) return addr ; if ( addr ) { addr = PAGE_ALIGN ( addr ) ; vma = find_vma ( mm , addr ) ; <S2SV_StartBug> if ( TASK_SIZE - len >= addr && <S2SV_EndBug> ( ! vma || addr + len <= vma -> vm_start ) ) return addr ; } info . flags = 0 ; info . length = len ; info . low_limit = TASK_UNMAPPED_BASE ; info . high_limit = TASK_SIZE ; info . align_mask = 0 ; return vm_unmapped_area ( & info ) ; } | <S2SV_ModStart> len > TASK_SIZE - mmap_min_addr <S2SV_ModStart> len >= addr && addr >= mmap_min_addr |
5,220 | CWE-000 static int show_image_info ( sd_bus * bus , const char * path , bool * new_line ) { static const struct bus_properties_map map [ ] = { { "Name" , "s" , NULL , offsetof ( ImageStatusInfo , name ) } , { "Path" , "s" , NULL , offsetof ( ImageStatusInfo , path ) } , { "Type" , "s" , NULL , offsetof ( ImageStatusInfo , type ) } , { "ReadOnly" , "b" , NULL , offsetof ( ImageStatusInfo , read_only ) } , { "CreationTimestamp" , "t" , NULL , offsetof ( ImageStatusInfo , crtime ) } , { "ModificationTimestamp" , "t" , NULL , offsetof ( ImageStatusInfo , mtime ) } , { "Usage" , "t" , NULL , offsetof ( ImageStatusInfo , usage ) } , { "Limit" , "t" , NULL , offsetof ( ImageStatusInfo , limit ) } , { "UsageExclusive" , "t" , NULL , offsetof ( ImageStatusInfo , usage_exclusive ) } , { "LimitExclusive" , "t" , NULL , offsetof ( ImageStatusInfo , limit_exclusive ) } , { } } ; <S2SV_StartBug> _cleanup_ ( image_status_info_clear ) ImageStatusInfo info = { } ; <S2SV_EndBug> int r ; assert ( bus ) ; assert ( path ) ; assert ( new_line ) ; r = bus_map_all_properties ( bus , "org.freedesktop.machine1" , path , <S2SV_StartBug> map , <S2SV_EndBug> & info ) ; if ( r < 0 ) <S2SV_StartBug> return log_error_errno ( r , "Could<S2SV_blank>not<S2SV_blank>get<S2SV_blank>properties:<S2SV_blank>%m" ) ; <S2SV_EndBug> if ( * new_line ) printf ( "\\n" ) ; * new_line = true ; print_image_status_info ( bus , & info ) ; return r ; } | <S2SV_ModStart> ; _cleanup_ ( sd_bus_error_free ) sd_bus_error error = SD_BUS_ERROR_NULL ; _cleanup_ ( <S2SV_ModStart> path , map , & error <S2SV_ModStart> ( r , "Could<S2SV_blank>not<S2SV_blank>get<S2SV_blank>properties:<S2SV_blank>%s" , bus_error_message ( & error , r ) <S2SV_ModEnd> ) ; if |
5,221 | CWE-000 static bool getregs_supplies ( struct gdbarch * gdbarch , int regnum ) { return ( regnum >= MIPS_ZERO_REGNUM <S2SV_StartBug> && regnum <= gdbarch_pc_regnum ( gdbarch ) ) ; <S2SV_EndBug> } | <S2SV_ModStart> && regnum <= mips_regnum <S2SV_ModEnd> ( gdbarch ) <S2SV_ModStart> ( gdbarch ) -> pc |
5,222 | CWE-000 static int get_error ( struct connection * conn ) { <S2SV_StartBug> int ret = 0 ; <S2SV_EndBug> <S2SV_StartBug> if ( conn -> errno_is_reliable ) <S2SV_EndBug> ret = errno ; return ret ? ret : EIO ; } | <S2SV_ModStart> int ret = tls_get_error ( ) <S2SV_ModEnd> ; if ( <S2SV_ModStart> ; if ( ! ret && |
5,223 | CWE-000 struct sock * __vsock_create ( struct net * net , struct socket * sock , struct sock * parent , gfp_t priority , unsigned short type ) { struct sock * sk ; struct vsock_sock * psk ; struct vsock_sock * vsk ; sk = sk_alloc ( net , AF_VSOCK , priority , & vsock_proto ) ; if ( ! sk ) return NULL ; sock_init_data ( sock , sk ) ; if ( ! sock ) sk -> sk_type = type ; vsk = vsock_sk ( sk ) ; vsock_addr_init ( & vsk -> local_addr , VMADDR_CID_ANY , VMADDR_PORT_ANY ) ; vsock_addr_init ( & vsk -> remote_addr , VMADDR_CID_ANY , VMADDR_PORT_ANY ) ; sk -> sk_destruct = vsock_sk_destruct ; sk -> sk_backlog_rcv = vsock_queue_rcv_skb ; sk -> sk_state = 0 ; sock_reset_flag ( sk , SOCK_DONE ) ; INIT_LIST_HEAD ( & vsk -> bound_table ) ; INIT_LIST_HEAD ( & vsk -> connected_table ) ; vsk -> listener = NULL ; INIT_LIST_HEAD ( & vsk -> pending_links ) ; INIT_LIST_HEAD ( & vsk -> accept_queue ) ; vsk -> rejected = false ; vsk -> sent_request = false ; vsk -> ignore_connecting_rst = false ; vsk -> peer_shutdown = 0 ; <S2SV_StartBug> psk = parent ? vsock_sk ( parent ) : NULL ; <S2SV_EndBug> if ( parent ) { vsk -> trusted = psk -> trusted ; vsk -> owner = get_cred ( psk -> owner ) ; vsk -> connect_timeout = psk -> connect_timeout ; } else { vsk -> trusted = capable ( CAP_NET_ADMIN ) ; vsk -> owner = get_current_cred ( ) ; vsk -> connect_timeout = VSOCK_DEFAULT_CONNECT_TIMEOUT ; } if ( transport -> init ( vsk , psk ) < 0 ) { sk_free ( sk ) ; return NULL ; } if ( sock ) vsock_insert_unbound ( vsk ) ; return sk ; } | <S2SV_ModStart> = 0 ; INIT_DELAYED_WORK ( & vsk -> connect_work , vsock_connect_timeout ) ; INIT_DELAYED_WORK ( & vsk -> pending_work , vsock_pending_work ) ; |
5,224 | CWE-000 int ti_parse_region2d ( const ti_index_t * idx , const char * str , int * tid , int * begin , int * end , int * begin2 , int * end2 ) { char * s , * p , * sname ; int i , l , k , h ; int coord1s , coord1e , coord2s , coord2e , pos1s , pos2s ; char region_split_character = ti_get_region_split_character ( idx ) ; l = strlen ( str ) ; p = s = ( char * ) malloc ( l + 1 ) ; for ( i = k = 0 ; i != l ; ++ i ) if ( str [ i ] != ',' && ! isspace ( str [ i ] ) ) s [ k ++ ] = str [ i ] ; s [ k ] = 0 ; for ( i = 0 ; i != k ; i ++ ) if ( s [ i ] == region_split_character ) break ; s [ i ] = 0 ; int dim = ti_get_sc2 ( idx ) + 1 == 0 ? 1 : 2 ; if ( i == k && dim == 1 ) { * begin2 = - 1 ; * end2 = - 1 ; int res = ti_parse_region ( idx , str , tid , begin , end ) ; free ( s ) ; return ( res ) ; } if ( i == k && dim == 2 ) { s = ( char * ) realloc ( s , l * 2 + 2 ) ; strcpy ( s + i + 1 , s ) ; s [ i ] = region_split_character ; <S2SV_StartBug> } <S2SV_EndBug> coord1s = 0 ; coord1e = i ; coord2s = i + 1 ; coord2e = k ; for ( i = coord1s ; i != coord1e ; ++ i ) if ( s [ i ] == ':' ) break ; s [ i ] = 0 ; pos1s = i + 1 ; for ( i = coord2s ; i != coord2e ; ++ i ) if ( s [ i ] == ':' ) break ; s [ i ] = 0 ; pos2s = i + 1 ; sname = ( char * ) malloc ( l + 1 ) ; strcpy ( sname , s + coord1s ) ; h = strlen ( sname ) ; sname [ h ] = region_split_character ; strcpy ( sname + h + 1 , s + coord2s ) ; if ( ( * tid = ti_get_tid ( idx , sname ) ) < 0 ) { free ( s ) ; free ( sname ) ; return - 1 ; } if ( pos1s - 1 == coord1e ) { * begin = 0 ; * end = 1 << 29 ; } else { p = s + pos1s ; for ( i = pos1s ; i != coord1e ; ++ i ) if ( s [ i ] == '-' ) break ; * begin = atoi ( p ) ; if ( i < coord1e ) { p = s + i + 1 ; * end = atoi ( p ) ; } else * end = 1 << 29 ; if ( * begin > 0 ) -- * begin ; } if ( pos2s - 1 == coord2e ) { * begin2 = 0 ; * end2 = 1 << 29 ; } else { p = s + pos2s ; for ( i = pos2s ; i != coord2e ; ++ i ) if ( s [ i ] == '-' ) break ; * begin2 = atoi ( p ) ; if ( i < coord2e ) { p = s + i + 1 ; * end2 = atoi ( p ) ; } else * end2 = 1 << 29 ; if ( * begin2 > 0 ) -- * begin2 ; } free ( s ) ; free ( sname ) ; if ( * begin > * end ) return - 1 ; if ( * begin2 != - 1 && * begin2 > * end2 ) return - 1 ; return 0 ; } | <S2SV_ModStart> = region_split_character ; l = l * 2 + 1 ; |
5,225 | CWE-000 Motion * make_broadcast_motion ( Plan * lefttree , bool useExecutorVarFormat ) { Motion * motion ; <S2SV_StartBug> motion = make_motion ( NULL , lefttree , NIL , useExecutorVarFormat ) ; <S2SV_EndBug> add_slice_to_motion ( motion , MOTIONTYPE_FIXED , NULL , 0 , NULL ) ; return motion ; } | <S2SV_ModStart> , lefttree , 0 , NULL , NULL , NULL , NULL , <S2SV_ModEnd> useExecutorVarFormat ) ; |
5,226 | CWE-000 static void help ( const char * progPath ) { PRINT ( "Usage:\\n" ) ; PRINT ( "<S2SV_blank><S2SV_blank>%s<S2SV_blank>[options]<S2SV_blank>[file(s)]\\n" , progPath ) ; PRINT ( "\\n" ) ; PRINT ( "Options:\\n" ) ; PRINT ( "<S2SV_blank><S2SV_blank>-oFILE<S2SV_blank>:<S2SV_blank>specify<S2SV_blank>the<S2SV_blank>output<S2SV_blank>file<S2SV_blank>name\\n" ) ; <S2SV_StartBug> PRINT ( "<S2SV_blank><S2SV_blank>-i#<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>provide<S2SV_blank>initial<S2SV_blank>compression<S2SV_blank>level<S2SV_blank>--<S2SV_blank>default<S2SV_blank>%d,<S2SV_blank>must<S2SV_blank>be<S2SV_blank>in<S2SV_blank>the<S2SV_blank>range<S2SV_blank>[L,<S2SV_blank>U]<S2SV_blank>where<S2SV_blank>L<S2SV_blank>and<S2SV_blank>U<S2SV_blank>are<S2SV_blank>bound<S2SV_blank>values<S2SV_blank>(see<S2SV_blank>below<S2SV_blank>for<S2SV_blank>defaults)\\n" , DEFAULT_COMPRESSION_LEVEL ) ; <S2SV_EndBug> PRINT ( "<S2SV_blank><S2SV_blank>-h<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>display<S2SV_blank>help/information\\n" ) ; PRINT ( "<S2SV_blank><S2SV_blank>-f<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>force<S2SV_blank>the<S2SV_blank>compression<S2SV_blank>level<S2SV_blank>to<S2SV_blank>stay<S2SV_blank>constant\\n" ) ; PRINT ( "<S2SV_blank><S2SV_blank>-c<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>force<S2SV_blank>write<S2SV_blank>to<S2SV_blank>stdout\\n" ) ; PRINT ( "<S2SV_blank><S2SV_blank>-p<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>hide<S2SV_blank>progress<S2SV_blank>bar\\n" ) ; <S2SV_StartBug> PRINT ( "<S2SV_blank><S2SV_blank>-q<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>quiet<S2SV_blank>mode<S2SV_blank>--<S2SV_blank>do<S2SV_blank>not<S2SV_blank>show<S2SV_blank>progress<S2SV_blank>bar<S2SV_blank>or<S2SV_blank>other<S2SV_blank>information\\n" ) ; <S2SV_EndBug> PRINT ( "<S2SV_blank><S2SV_blank>-l#<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>provide<S2SV_blank>lower<S2SV_blank>bound<S2SV_blank>for<S2SV_blank>compression<S2SV_blank>level<S2SV_blank>--<S2SV_blank>default<S2SV_blank>1\\n" ) ; PRINT ( "<S2SV_blank><S2SV_blank>-u#<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>provide<S2SV_blank>upper<S2SV_blank>bound<S2SV_blank>for<S2SV_blank>compression<S2SV_blank>level<S2SV_blank>--<S2SV_blank>default<S2SV_blank>%u\\n" , ZSTD_maxCLevel ( ) ) ; } | <S2SV_ModStart> ; PRINT ( "<S2SV_blank><S2SV_blank>-i#<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>provide<S2SV_blank>initial<S2SV_blank>compression<S2SV_blank>level<S2SV_blank>--<S2SV_blank>default<S2SV_blank>%d,<S2SV_blank>must<S2SV_blank>be<S2SV_blank>" "in<S2SV_blank>the<S2SV_blank>range<S2SV_blank>[L,<S2SV_blank>U]<S2SV_blank>where<S2SV_blank>L<S2SV_blank>and<S2SV_blank>U<S2SV_blank>are<S2SV_blank>bound<S2SV_blank>values<S2SV_blank>(see<S2SV_blank>below<S2SV_blank>for<S2SV_blank>" "defaults)\\n" <S2SV_ModEnd> , DEFAULT_COMPRESSION_LEVEL ) <S2SV_ModStart> ; PRINT ( "<S2SV_blank><S2SV_blank>-q<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>quiet<S2SV_blank>mode<S2SV_blank>--<S2SV_blank>do<S2SV_blank>not<S2SV_blank>show<S2SV_blank>progress<S2SV_blank>bar<S2SV_blank>or<S2SV_blank>other<S2SV_blank>" "information\\n" <S2SV_ModEnd> ) ; PRINT |
5,227 | CWE-000 int generate_file_key ( const char * mnemonic , const char * bucket_id , const char * index , char * * file_key ) { <S2SV_StartBug> char * bucket_key = calloc ( DETERMINISTIC_KEY_SIZE + 1 , sizeof ( char ) ) ; <S2SV_EndBug> if ( ! bucket_key ) { <S2SV_StartBug> return 1 ; <S2SV_EndBug> } <S2SV_StartBug> if ( generate_bucket_key ( mnemonic , bucket_id , & bucket_key ) ) { <S2SV_EndBug> return 1 ; } bucket_key [ DETERMINISTIC_KEY_SIZE ] = '\\0' ; get_deterministic_key ( bucket_key , 64 , index , file_key ) ; <S2SV_StartBug> memset_zero ( bucket_key , DETERMINISTIC_KEY_SIZE + 1 ) ; <S2SV_EndBug> free ( bucket_key ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> file_key ) { int status = 0 ; <S2SV_ModStart> bucket_key ) { status = 1 ; goto cleanup ; } status = <S2SV_ModEnd> generate_bucket_key ( mnemonic <S2SV_ModStart> & bucket_key ) ; if ( status ) { goto cleanup <S2SV_ModEnd> ; } bucket_key <S2SV_ModStart> file_key ) ; cleanup : if ( bucket_key ) { <S2SV_ModStart> bucket_key ) ; } return status <S2SV_ModEnd> ; } <S2SV_null> |
5,228 | CWE-000 static void clnt_dg_geterr ( CLIENT * clnt , struct rpc_err * errp ) { <S2SV_StartBug> struct cu_data * cu = CU_DATA ( ( struct cx_data * ) clnt -> cl_p1 ) ; <S2SV_EndBug> * errp = cu -> cu_error ; } | <S2SV_ModStart> ) { struct cx_data * cx = CX_DATA ( clnt ) ; struct <S2SV_ModStart> = CU_DATA ( cx <S2SV_ModEnd> ) ; * |
5,229 | CWE-000 int main ( int argc , const char * * argv ) { int data_id , i , n ; pixel * im_data ; matrix train_input , train_label , test_input , test_label ; if ( argc < 2 ) { help_msg ( ) ; } else { if ( argv [ 1 ] [ 1 ] ) { fprintf ( stderr , "input<S2SV_blank>invalid!\\n" ) ; help_msg ( ) ; } data_id = atoi ( argv [ 1 ] ) ; if ( data_id < 1 || data_id > 5 ) { fprintf ( stderr , "input<S2SV_blank>dataset<S2SV_blank>is<S2SV_blank>invalid!\\n" ) ; help_msg ( ) ; } } if ( data_id == 1 ) { read_mnist ( & train_input , & train_label , & test_input , & test_label , "./MNIST" ) ; } <S2SV_StartBug> free_matrix ( & train_input ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> ) ; } matrix_free <S2SV_ModEnd> ( & train_input |
5,230 | CWE-000 STATIC void free_rl ( struct redirtab * rt , int reset ) { struct renamelist * rl , * rn = rt -> renamed ; while ( ( rl = rn ) != NULL ) { rn = rl -> next ; if ( rl -> orig == 0 ) fd0_redirected -- ; <S2SV_StartBug> if ( reset ) { <S2SV_EndBug> <S2SV_StartBug> if ( rl -> into < 0 ) <S2SV_EndBug> close ( rl -> orig ) ; <S2SV_StartBug> else <S2SV_EndBug> <S2SV_StartBug> movefd ( rl -> into , rl -> orig ) ; <S2SV_EndBug> } ckfree ( rl ) ; } rt -> renamed = NULL ; } | <S2SV_ModStart> fd0_redirected -- ; VTRACE ( DBG_REDIR , ( "popredir<S2SV_blank>%d%s:<S2SV_blank>%s" , rl -> orig , rl -> orig == 0 ? "<S2SV_blank>(STDIN)" : "" , reset ? "" : "no<S2SV_blank>reset\\n" ) ) ; <S2SV_ModStart> < 0 ) { VTRACE ( DBG_REDIR , ( "closed\\n" ) ) ; <S2SV_ModStart> orig ) ; } else { VTRACE ( DBG_REDIR , ( "from<S2SV_blank>%d\\n" , rl -> into ) ) ; <S2SV_ModEnd> movefd ( rl <S2SV_ModStart> orig ) ; } |
5,231 | CWE-000 long cr__choose_stream_dirs ( river_args * a , coords * this , long dir , long that_dir [ ] , boolean that_ok [ ] , coords that [ ] , boolean that_chosen [ ] ) { long i1 ; boolean done ; long return_value = 0 ; ENTER ( ( "cr__choose_stream_dirs" , "r" ) ) ; * this = S_list [ S_l_top ] . loc ; dir = Gup [ this -> y ] [ this -> x ] . out ; for ( i1 = 1 ; i1 <= 3 ; i1 ++ ) { that_dir [ i1 ] = rotate_dir ( dir , 2 - i1 ) ; <S2SV_StartBug> that_ok [ i1 ] = r__move_this ( a , that_dir [ i1 ] , this , & ( that [ i1 ] ) ) ; <S2SV_EndBug> if ( that_ok [ i1 ] ) { that_ok [ i1 ] = Gup [ that [ i1 ] . y ] [ that [ i1 ] . x ] . pos <= Num_left ; } that_chosen [ i1 ] = false ; } done = false ; if ( ( randint ( 3 * Gup [ this -> y ] [ this -> x ] . flow ) == 1 ) || ! ( that_ok [ 1 ] || that_ok [ 2 ] || that_ok [ 3 ] ) ) { done = true ; return_value = 0 ; } else if ( ( ( randint ( 5 ) == 1 ) || ! ( that_ok [ 1 ] || that_ok [ 3 ] ) ) && that_ok [ 2 ] ) { done = true ; that_chosen [ 2 ] = true ; return_value = 1 ; } else if ( ( randint ( 5 ) == 1 ) && ( that_ok [ 1 ] && that_ok [ 3 ] ) ) { done = true ; that_chosen [ 1 ] = true ; that_chosen [ 3 ] = true ; return_value = 2 ; } if ( ! done ) { i1 = 2 * randint ( 2 ) - 1 ; that_chosen [ i1 ] = that_ok [ i1 ] ; that_chosen [ 4 - i1 ] = ! that_chosen [ i1 ] ; return_value = 1 ; } RETURN ( "cr__choose_stream_dirs" , "r" , 'd' , "branches" , & return_value ) ; return return_value ; } | <S2SV_ModStart> = r__move_this ( <S2SV_ModEnd> that_dir [ i1 |
5,232 | CWE-000 acpi_status acpi_tb_install_standard_table ( acpi_physical_address address , u8 flags , u8 reload , u8 override , u32 * table_index ) { u32 i ; acpi_status status = AE_OK ; struct acpi_table_desc new_table_desc ; ACPI_FUNCTION_TRACE ( tb_install_standard_table ) ; status = acpi_tb_acquire_temp_table ( & new_table_desc , address , flags ) ; if ( ACPI_FAILURE ( status ) ) { ACPI_ERROR ( ( AE_INFO , "Could<S2SV_blank>not<S2SV_blank>acquire<S2SV_blank>table<S2SV_blank>length<S2SV_blank>at<S2SV_blank>%8.8X%8.8X" , ACPI_FORMAT_UINT64 ( address ) ) ) ; return_ACPI_STATUS ( status ) ; } if ( ! reload && acpi_gbl_disable_ssdt_table_install && ACPI_COMPARE_NAME ( & new_table_desc . signature , ACPI_SIG_SSDT ) ) { ACPI_INFO ( ( "Ignoring<S2SV_blank>installation<S2SV_blank>of<S2SV_blank>%4.4s<S2SV_blank>at<S2SV_blank>%8.8X%8.8X" , new_table_desc . signature . ascii , ACPI_FORMAT_UINT64 ( address ) ) ) ; goto release_and_exit ; } status = acpi_tb_verify_temp_table ( & new_table_desc , NULL ) ; if ( ACPI_FAILURE ( status ) ) { goto release_and_exit ; <S2SV_StartBug> } <S2SV_EndBug> if ( reload ) { if ( ( new_table_desc . signature . ascii [ 0 ] != 0x00 ) && ( ! ACPI_COMPARE_NAME ( & new_table_desc . signature , ACPI_SIG_SSDT ) ) && ( strncmp ( new_table_desc . signature . ascii , "OEM" , 3 ) ) ) { ACPI_BIOS_ERROR ( ( AE_INFO , "Table<S2SV_blank>has<S2SV_blank>invalid<S2SV_blank>signature<S2SV_blank>[%4.4s]<S2SV_blank>(0x%8.8X),<S2SV_blank>" "must<S2SV_blank>be<S2SV_blank>SSDT<S2SV_blank>or<S2SV_blank>OEMx" , acpi_ut_valid_nameseg ( new_table_desc . signature . ascii ) ? new_table_desc . signature . ascii : "????" , new_table_desc . signature . integer ) ) ; status = AE_BAD_SIGNATURE ; <S2SV_StartBug> goto release_and_exit ; <S2SV_EndBug> } for ( i = 0 ; i < acpi_gbl_root_table_list . current_table_count ; ++ i ) { if ( ! acpi_tb_compare_tables ( & new_table_desc , i ) ) { continue ; } if ( acpi_gbl_root_table_list . tables [ i ] . flags & ACPI_TABLE_IS_LOADED ) { status = AE_ALREADY_EXISTS ; <S2SV_StartBug> goto release_and_exit ; <S2SV_EndBug> } else { <S2SV_StartBug> acpi_tb_uninstall_table ( & new_table_desc ) ; <S2SV_EndBug> * table_index = i ; return_ACPI_STATUS ( AE_OK ) ; } } } acpi_tb_install_table_with_override ( & new_table_desc , override , table_index ) ; <S2SV_StartBug> if ( acpi_gbl_table_handler ) { <S2SV_EndBug> ( void ) acpi_gbl_table_handler ( ACPI_TABLE_EVENT_INSTALL , new_table_desc . pointer , acpi_gbl_table_handler_context ) ; <S2SV_StartBug> } <S2SV_EndBug> release_and_exit : acpi_tb_release_temp_table ( & new_table_desc ) ; return_ACPI_STATUS ( status ) ; } | <S2SV_ModStart> release_and_exit ; } ( void ) acpi_ut_acquire_mutex ( ACPI_MTX_TABLES ) ; <S2SV_ModStart> AE_BAD_SIGNATURE ; goto unlock_and_exit <S2SV_ModEnd> ; } for <S2SV_ModStart> AE_ALREADY_EXISTS ; goto unlock_and_exit <S2SV_ModEnd> ; } else <S2SV_ModStart> ( & new_table_desc ) ; ( void ) acpi_ut_release_mutex ( ACPI_MTX_TABLES <S2SV_ModStart> table_index ) ; ( void ) acpi_ut_release_mutex ( ACPI_MTX_TABLES ) ; <S2SV_ModStart> ) ; } ( void ) acpi_ut_acquire_mutex ( ACPI_MTX_TABLES ) ; unlock_and_exit : ( void ) acpi_ut_release_mutex ( ACPI_MTX_TABLES ) ; |
5,233 | CWE-000 <S2SV_StartBug> void set_colors ( ) <S2SV_EndBug> { start_color ( ) ; use_default_colors ( ) ; set_normal_colors ( ) ; if ( has_colors ( ) ) { normal_color_theme ( ) ; } else { no_colors_theme ( ) ; } } | <S2SV_ModStart> void set_colors ( void |
5,234 | CWE-000 void update_frame_execute ( u32 skip ) { <S2SV_StartBug> s32 hds_cycles ; <S2SV_EndBug> static u32 check_idle_loop_line = 0 ; u32 check_idle_loops = 3 ; do <S2SV_StartBug> { <S2SV_EndBug> if ( check_idle_loops && ( vce . frame_counter == check_idle_loop_line ) ) { patch_idle_loop ( ) ; check_idle_loops -- ; } if ( vce . frame_counter == 0 ) vdc_frame_start ( & vdc_a ) ; vdc_a . vblank_active = 0 ; vdc_burst_mode_dma ( & vdc_a ) ; if ( vdc_check_vblank ( & vdc_a ) ) { if ( check_idle_loops ) { patch_idle_loop ( ) ; check_idle_loops -- ; } } if ( vdc_check_raster_line ( & vdc_a ) ) { if ( check_idle_loops != 0 ) { patch_idle_loop ( ) ; check_idle_loops -- ; } } hds_cycles = vdc_a . hds_cycles ; execute_instructions_timer ( hds_cycles , false ) ; vdc_set_effective_byr ( & vdc_a ) ; if ( ! skip ) { render_line_hw ( ) ; } if ( vdc_a . vblank_active && ( vdc_a . cr & 0x08 ) ) { vdc_a . status |= VDC_STATUS_VBLANK_IRQ ; execute_instructions_timer ( 6 , false ) ; hds_cycles += 6 ; if ( vdc_a . status & VDC_STATUS_VBLANK_IRQ ) raise_interrupt ( IRQ_VDC ) ; } execute_instructions_timer ( vce . scanline_cycles - hds_cycles , true ) ; vdc_line_increment ( & vdc_a ) ; vce . frame_counter ++ ; if ( vce . frame_counter == vce . num_lines ) vce . frame_counter = 0 ; } while ( vce . frame_counter != vdc_a . vblank_line ) ; check_idle_loop_line += 16 ; if ( check_idle_loop_line >= vce . num_lines ) check_idle_loop_line -= vce . num_lines ; } | <S2SV_ModStart> skip ) { vdc_hw_a . skip = skip ; <S2SV_ModStart> ; do { vdc_hw_a . force_flush = false ; |
5,235 | CWE-000 void cpu_init ( struct cpu * cpu ) { <S2SV_StartBug> cpu -> PC = 0 ; <S2SV_EndBug> memset ( cpu -> reg , 0 , sizeof ( cpu -> reg ) ) ; memset ( cpu -> ram , 0 , sizeof ( cpu -> ram ) ) ; } | <S2SV_ModStart> cpu -> PC = 0 ; cpu -> IR = 0 ; cpu -> MAR = 0 ; cpu -> MDR = 0 ; cpu -> FL |
5,236 | CWE-000 static GstFlowReturn gst_omx_buffer_pool_alloc_buffer ( GstBufferPool * bpool , GstBuffer * * buffer , GstBufferPoolAcquireParams * params ) { GstOMXBufferPool * pool = GST_OMX_BUFFER_POOL ( bpool ) ; GstBuffer * buf ; <S2SV_StartBug> GstOMXBuffer * omx_buf ; <S2SV_EndBug> g_return_val_if_fail ( pool -> allocating , GST_FLOW_ERROR ) ; omx_buf = g_ptr_array_index ( pool -> port -> buffers , pool -> current_buffer_index ) ; g_return_val_if_fail ( omx_buf != NULL , GST_FLOW_ERROR ) ; if ( pool -> other_pool ) { guint i , n ; buf = g_ptr_array_index ( pool -> buffers , pool -> current_buffer_index ) ; g_assert ( pool -> other_pool == buf -> pool ) ; gst_object_replace ( ( GstObject * * ) & buf -> pool , NULL ) ; n = gst_buffer_n_memory ( buf ) ; for ( i = 0 ; i < n ; i ++ ) { GstMemory * mem = gst_buffer_peek_memory ( buf , i ) ; GST_MINI_OBJECT_FLAG_SET ( mem , GST_MEMORY_FLAG_NO_SHARE ) ; } if ( pool -> add_videometa ) { GstVideoMeta * meta ; meta = gst_buffer_get_video_meta ( buf ) ; if ( ! meta ) { gst_buffer_add_video_meta ( buf , GST_VIDEO_FRAME_FLAG_NONE , GST_VIDEO_INFO_FORMAT ( & pool -> video_info ) , GST_VIDEO_INFO_WIDTH ( & pool -> video_info ) , GST_VIDEO_INFO_HEIGHT ( & pool -> video_info ) ) ; } } pool -> need_copy = FALSE ; } else { GstMemory * mem ; const guint nstride = pool -> port -> port_def . format . video . nStride ; const guint nslice = pool -> port -> port_def . format . video . nSliceHeight ; gsize offset [ GST_VIDEO_MAX_PLANES ] = { 0 , } ; gint stride [ GST_VIDEO_MAX_PLANES ] = { nstride , 0 , } ; if ( pool -> output_mode == GST_OMX_BUFFER_MODE_DMABUF ) { gint fd ; GstMapInfo map ; fd = GPOINTER_TO_INT ( omx_buf -> omx_buf -> pBuffer ) ; mem = gst_dmabuf_allocator_alloc ( pool -> allocator , fd , omx_buf -> omx_buf -> nAllocLen ) ; if ( ! gst_caps_features_contains ( gst_caps_get_features ( pool -> caps , 0 ) , GST_CAPS_FEATURE_MEMORY_DMABUF ) ) { if ( ! gst_memory_map ( mem , & map , GST_MAP_READWRITE ) ) { GST_ERROR_OBJECT ( pool , "dmabuf<S2SV_blank>memory<S2SV_blank>is<S2SV_blank>not<S2SV_blank>mappable<S2SV_blank>but<S2SV_blank>caps<S2SV_blank>does<S2SV_blank>not<S2SV_blank>have<S2SV_blank>the<S2SV_blank>\'memory:DMABuf\'<S2SV_blank>feature" ) ; gst_memory_unref ( mem ) ; return GST_FLOW_ERROR ; } gst_memory_unmap ( mem , & map ) ; } } else { mem = gst_omx_memory_allocator_alloc ( pool -> allocator , 0 , omx_buf ) ; } buf = gst_buffer_new ( ) ; gst_buffer_append_memory ( buf , mem ) ; g_ptr_array_add ( pool -> buffers , buf ) ; switch ( GST_VIDEO_INFO_FORMAT ( & pool -> video_info ) ) { case GST_VIDEO_FORMAT_ABGR : case GST_VIDEO_FORMAT_ARGB : case GST_VIDEO_FORMAT_RGB16 : case GST_VIDEO_FORMAT_BGR16 : case GST_VIDEO_FORMAT_YUY2 : case GST_VIDEO_FORMAT_UYVY : case GST_VIDEO_FORMAT_YVYU : case GST_VIDEO_FORMAT_GRAY8 : break ; case GST_VIDEO_FORMAT_I420 : stride [ 1 ] = nstride / 2 ; offset [ 1 ] = offset [ 0 ] + stride [ 0 ] * nslice ; stride [ 2 ] = nstride / 2 ; offset [ 2 ] = offset [ 1 ] + ( stride [ 1 ] * nslice / 2 ) ; break ; case GST_VIDEO_FORMAT_NV12 : case GST_VIDEO_FORMAT_NV12_10LE32 : case GST_VIDEO_FORMAT_NV16 : case GST_VIDEO_FORMAT_NV16_10LE32 : stride [ 1 ] = nstride ; offset [ 1 ] = offset [ 0 ] + stride [ 0 ] * nslice ; break ; default : g_assert_not_reached ( ) ; break ; } if ( pool -> add_videometa ) { pool -> need_copy = FALSE ; } else { GstVideoInfo info ; gboolean need_copy = FALSE ; gint i ; gst_video_info_init ( & info ) ; gst_video_info_set_format ( & info , GST_VIDEO_INFO_FORMAT ( & pool -> video_info ) , GST_VIDEO_INFO_WIDTH ( & pool -> video_info ) , GST_VIDEO_INFO_HEIGHT ( & pool -> video_info ) ) ; for ( i = 0 ; i < GST_VIDEO_INFO_N_PLANES ( & pool -> video_info ) ; i ++ ) { if ( info . stride [ i ] != stride [ i ] || info . offset [ i ] != offset [ i ] ) { GST_CAT_DEBUG_OBJECT ( CAT_PERFORMANCE , pool , "Need<S2SV_blank>to<S2SV_blank>copy<S2SV_blank>output<S2SV_blank>frames<S2SV_blank>because<S2SV_blank>of<S2SV_blank>stride/offset<S2SV_blank>mismatch:<S2SV_blank>plane<S2SV_blank>%d<S2SV_blank>stride<S2SV_blank>%d<S2SV_blank>(expected:<S2SV_blank>%d)<S2SV_blank>offset<S2SV_blank>%" G_GSIZE_FORMAT "<S2SV_blank>(expected:<S2SV_blank>%" G_GSIZE_FORMAT ")<S2SV_blank>nStride:<S2SV_blank>%d<S2SV_blank>nSliceHeight:<S2SV_blank>%d<S2SV_blank>" , i , stride [ i ] , info . stride [ i ] , offset [ i ] , info . offset [ i ] , nstride , nslice ) ; need_copy = TRUE ; break ; } } pool -> need_copy = need_copy ; } if ( pool -> need_copy || pool -> add_videometa ) { gst_buffer_add_video_meta_full ( buf , GST_VIDEO_FRAME_FLAG_NONE , GST_VIDEO_INFO_FORMAT ( & pool -> video_info ) , GST_VIDEO_INFO_WIDTH ( & pool -> video_info ) , GST_VIDEO_INFO_HEIGHT ( & pool -> video_info ) , GST_VIDEO_INFO_N_PLANES ( & pool -> video_info ) , offset , stride ) ; } } gst_omx_buffer_set_omx_buf ( buf , omx_buf ) ; * buffer = buf ; pool -> current_buffer_index ++ ; return GST_FLOW_OK ; } | <S2SV_ModStart> GstOMXBuffer * omx_buf <S2SV_ModEnd> ; omx_buf = |
5,237 | CWE-000 int main ( int argc , char * * argv ) { int r ; int server_socket ; int client_socket ; int client_address_size ; struct sockaddr_in client_address ; char buffer [ BUF_SIZE ] ; char filePath [ FILE_NAME_SIZE ] ; <S2SV_StartBug> if ( argc != 4 ) { <S2SV_EndBug> fprintf ( stderr , "Usage:<S2SV_blank>%s<S2SV_blank><launcher_ip><S2SV_blank><start_ip><S2SV_blank><end_ip>\\n" , argv [ 0 ] ) ; exit ( 1 ) ; } if ( check_ip_arg ( argv [ 2 ] , argv [ 3 ] ) == - 1 ) { fprintf ( stderr , "IP<S2SV_blank>Argument<S2SV_blank>Error\\n" ) ; exit ( 1 ) ; } <S2SV_StartBug> server_socket = port_bind ( argv [ 1 ] ) ; <S2SV_EndBug> if ( server_socket == - 1 ) { exit ( 1 ) ; } while ( 1 ) { client_address_size = sizeof ( client_address ) ; client_socket = accept ( server_socket , ( struct sockaddr * ) & client_address , & client_address_size ) ; if ( client_socket == - 1 ) { fprintf ( stderr , "accept()<S2SV_blank>error\\n" ) ; continue ; } if ( check_range ( argv [ 2 ] , argv [ 3 ] , inet_ntoa ( client_address . sin_addr ) ) == - 1 ) { fprintf ( stderr , "range<S2SV_blank>error\\n" ) ; close ( client_socket ) ; continue ; } printf ( "DEBUG]<S2SV_blank>Hello<S2SV_blank>%s\\n" , inet_ntoa ( client_address . sin_addr ) ) ; memset ( buffer , 0 , BUF_SIZE ) ; memset ( filePath , 0 , FILE_NAME_SIZE ) ; <S2SV_StartBug> r = read ( client_socket , buffer , BUF_SIZE ) ; <S2SV_EndBug> if ( r <= 0 ) { break ; } if ( jsonParse ( filePath , buffer ) == 0 ) { printf ( "DEBUG]<S2SV_blank>Client:<S2SV_blank>%s\\n" , filePath ) ; } close ( client_socket ) ; } close ( server_socket ) ; return 0 ; } | <S2SV_ModStart> FILE_NAME_SIZE ] ; char defaultPath [ FILE_NAME_SIZE ] ; <S2SV_ModStart> ) ; } getDefaultPath ( defaultPath , argv [ 0 ] ) ; <S2SV_ModStart> FILE_NAME_SIZE ) ; strcpy ( filePath , defaultPath ) ; |
5,238 | CWE-000 static int TIFFWriteDirectoryTagCheckedLong8Array ( TIFF * tif , uint32 * ndir , TIFFDirEntry * dir , uint16 tag , uint32 count , uint64 * value ) { assert ( count < 0x20000000 ) ; assert ( sizeof ( uint64 ) == 8 ) ; if ( ! ( tif -> tif_flags & TIFF_BIGTIFF ) ) { <S2SV_StartBug> TIFFErrorExt ( tif -> tif_clientdata , "TIFFWriteDirectoryTagCheckedLong8" , "LONG8<S2SV_blank>not<S2SV_blank>allowed<S2SV_blank>for<S2SV_blank>ClassicTIFF" ) ; <S2SV_EndBug> return ( 0 ) ; } if ( tif -> tif_flags & TIFF_SWAB ) TIFFSwabArrayOfLong8 ( value , count ) ; return ( TIFFWriteDirectoryTagData ( tif , ndir , dir , tag , TIFF_LONG8 , count , count * 8 , value ) ) ; } | <S2SV_ModStart> -> tif_clientdata , "TIFFWriteDirectoryTagCheckedLong8Array" <S2SV_ModEnd> , "LONG8<S2SV_blank>not<S2SV_blank>allowed<S2SV_blank>for<S2SV_blank>ClassicTIFF" ) |
5,239 | CWE-000 static void bq27z561_itf_unlock ( struct bq27z561_itf * bi ) { <S2SV_StartBug> if ( ! bi -> bi_lock ) { <S2SV_EndBug> return ; } os_mutex_release ( bi -> itf_lock ) ; } | <S2SV_ModStart> ! bi -> itf_lock <S2SV_ModEnd> ) { return |
5,240 | CWE-000 <S2SV_StartBug> void classloader_destory ( ClassLoader * class_loader ) { <S2SV_EndBug> utf8_destory ( class_loader -> g_classpath ) ; class_loader -> g_classpath = NULL ; hashtable_destory ( class_loader -> classes ) ; class_loader -> classes = NULL ; jvm_free ( class_loader ) ; } | <S2SV_ModStart> class_loader ) { HashtableIterator hti ; hashtable_iterate ( class_loader -> classes , & hti ) ; for ( ; hashtable_iter_has_more ( & hti ) ; ) { HashtableValue v = hashtable_iter_next_value ( & hti ) ; Class * clazz = ( Class * ) ( v ) ; garbage_refer_count_dec ( v ) ; } hashtable_clear ( array_classloader -> classes ) ; |
5,241 | CWE-000 void lpfc_drop_node ( struct lpfc_vport * vport , struct lpfc_nodelist * ndlp ) { if ( ndlp -> nlp_state == NLP_STE_UNUSED_NODE ) return ; lpfc_nlp_set_state ( vport , ndlp , NLP_STE_UNUSED_NODE ) ; <S2SV_StartBug> if ( vport -> phba -> sli_rev == LPFC_SLI_REV4 ) <S2SV_EndBug> lpfc_cleanup_vports_rrqs ( vport , ndlp ) ; <S2SV_StartBug> lpfc_nlp_put ( ndlp ) ; <S2SV_EndBug> <S2SV_StartBug> return ; <S2SV_EndBug> } | <S2SV_ModStart> == LPFC_SLI_REV4 ) { <S2SV_ModStart> ndlp ) ; lpfc_unreg_rpi ( vport , ndlp ) ; } else { <S2SV_ModStart> ndlp ) ; } |
5,242 | CWE-000 int drm_mode_destroy_dumb_ioctl ( struct drm_device * dev , void * data , struct drm_file * file_priv ) { struct drm_mode_destroy_dumb * args = data ; <S2SV_StartBug> if ( ! dev -> driver -> dumb_create ) <S2SV_EndBug> return - ENOSYS ; if ( dev -> driver -> dumb_destroy ) <S2SV_StartBug> return dev -> driver -> dumb_destroy ( file_priv , dev , args -> handle ) ; <S2SV_EndBug> else return drm_gem_dumb_destroy ( file_priv , dev , args -> handle ) ; } | <S2SV_ModStart> = data ; return drm_mode_destroy_dumb ( <S2SV_ModEnd> dev , args <S2SV_ModStart> args -> handle , file_priv <S2SV_ModEnd> ) ; } |
5,243 | CWE-000 int init ( int state ) { if ( query == NULL ) query = kore_buf_alloc ( 512 ) ; <S2SV_StartBug> kore_pgsql_register ( "db" , "host=kore-postgres<S2SV_blank>user=postgres<S2SV_blank>password=postgres_pwd" ) ; <S2SV_EndBug> return KORE_RESULT_OK ; } | <S2SV_ModStart> ( "db" , "host=postgres<S2SV_blank>user=postgres<S2SV_blank>password=postgres_pwd" <S2SV_ModEnd> ) ; return |
5,244 | CWE-000 int TM_getCurrentTime ( char * result ) { time_t rawtime = time ( NULL ) ; struct tm * timeinfo ; <S2SV_StartBug> int hour , minute ; <S2SV_EndBug> int isPM = 0 ; timeinfo = localtime ( & rawtime ) ; hour = ( * timeinfo ) . tm_hour ; minute = ( * timeinfo ) . tm_min ; if ( hour >= 12 ) { isPM = 1 ; } if ( hour > 12 ) { hour -= 12 ; } if ( hour < 10 ) { if ( minute < 10 ) { sprintf ( result , "0%d0%d" , hour , minute ) ; } else { sprintf ( result , "0%d%d" , hour , minute ) ; } } else { if ( minute < 10 ) { sprintf ( result , "%d0%d" , hour , minute ) ; } else { sprintf ( result , "%d%d" , hour , minute ) ; } } if ( isPM ) { return 1 ; } else { return 0 ; } } | <S2SV_ModStart> ; int hour = 0 ; int minute = 0 <S2SV_ModEnd> ; int isPM |
5,245 | CWE-000 <S2SV_StartBug> int blast ( blast_in infun , void * inhow , blast_out outfun , void * outhow ) <S2SV_EndBug> { struct state s ; int err ; s . infun = infun ; s . inhow = inhow ; <S2SV_StartBug> s . left = 0 ; <S2SV_EndBug> s . bitbuf = 0 ; s . bitcnt = 0 ; s . outfun = outfun ; s . outhow = outhow ; s . next = 0 ; s . first = 1 ; if ( setjmp ( s . env ) != 0 ) err = 2 ; else <S2SV_StartBug> err = decomp ( & s ) ; <S2SV_EndBug> if ( err != 1 && s . next && s . outfun ( s . outhow , s . out , s . next ) && err == 0 ) err = 1 ; return err ; } | <S2SV_ModStart> void * outhow , unsigned * left , unsigned char * * in <S2SV_ModStart> = inhow ; if ( left != NULL && * left ) { s . left = * left ; s . in = * in ; } else <S2SV_ModStart> & s ) ; if ( left != NULL ) * left = s . left ; if ( in != NULL ) * in = s . left ? s . in : NULL |
5,246 | CWE-000 static void gui_cleanup ( PLimUI * ui ) { for ( int i = 0 ; i < 3 ; ++ i ) { robtk_dial_destroy ( ui -> spn_ctrl [ i ] ) ; robtk_lbl_destroy ( ui -> lbl_ctrl [ i ] ) ; cairo_surface_destroy ( ui -> dial_bg [ i ] ) ; } pango_font_description_free ( ui -> font [ 0 ] ) ; pango_font_description_free ( ui -> font [ 1 ] ) ; <S2SV_StartBug> if ( ui -> m_fg ) { <S2SV_EndBug> cairo_pattern_destroy ( ui -> m_fg ) ; } if ( ui -> m_bg ) { cairo_pattern_destroy ( ui -> m_bg ) ; } robwidget_destroy ( ui -> m0 ) ; rob_table_destroy ( ui -> ctbl ) ; rob_box_destroy ( ui -> rw ) ; } | <S2SV_ModStart> ] ) ; pango_font_description_free ( ui -> font [ 2 ] ) ; |
5,247 | CWE-000 G_MODULE_EXPORT void on_extract_activate ( GtkWidget * button , gpointer user_data ) { char * reason = NULL ; stop_playback ( ) ; if ( extracting ) { on_progress_cancel_clicked ( NULL , NULL ) ; return ; } current . stamp = 0 ; total_extracting = 0 ; current_duration = total_duration = 0 ; before . seconds = - 1 ; <S2SV_StartBug> overwrite_mode = NORMAL ; <S2SV_EndBug> gtk_tree_model_foreach ( GTK_TREE_MODEL ( track_store ) , extract_track_foreach_cb , NULL ) ; if ( total_extracting == 0 ) { g_warning ( "No<S2SV_blank>tracks<S2SV_blank>selected<S2SV_blank>for<S2SV_blank>extracting" ) ; return ; } if ( ! initialised ) { <S2SV_StartBug> g_signal_connect ( extractor , "progress" , G_CALLBACK ( on_progress_cb ) , NULL ) ; <S2SV_EndBug> <S2SV_StartBug> g_signal_connect ( extractor , "completion" , G_CALLBACK ( on_completion_cb ) , ( gpointer ) & overwrite_mode ) ; <S2SV_EndBug> <S2SV_StartBug> g_signal_connect ( extractor , "error" , G_CALLBACK ( on_error_cb ) , NULL ) ; <S2SV_EndBug> extract_button = GET_WIDGET ( "extract_button" ) ; play_button = GET_WIDGET ( "play_button" ) ; title_entry = GET_WIDGET ( "title_entry" ) ; artist_entry = GET_WIDGET ( "artist_entry" ) ; composer_entry = GET_WIDGET ( "composer_entry" ) ; genre_entry = GET_WIDGET ( "genre_entry" ) ; year_entry = GET_WIDGET ( "year_entry" ) ; disc_number_entry = GET_WIDGET ( "disc_number_entry" ) ; track_listview = GET_WIDGET ( "track_listview" ) ; progress_bar = GET_WIDGET ( "progress_bar" ) ; status_bar = GET_WIDGET ( "status_bar" ) ; initialised = TRUE ; } gtk_button_set_label ( GTK_BUTTON ( extract_button ) , _ ( "_Stop" ) ) ; gtk_widget_show ( progress_bar ) ; gtk_progress_bar_set_fraction ( GTK_PROGRESS_BAR ( progress_bar ) , 0 ) ; update_speed_progress ( NULL , 0.0 , - 1 ) ; gtk_widget_set_sensitive ( play_button , FALSE ) ; gtk_widget_set_sensitive ( title_entry , FALSE ) ; gtk_widget_set_sensitive ( artist_entry , FALSE ) ; gtk_widget_set_sensitive ( composer_entry , FALSE ) ; gtk_widget_set_sensitive ( genre_entry , FALSE ) ; gtk_widget_set_sensitive ( year_entry , FALSE ) ; gtk_widget_set_sensitive ( disc_number_entry , FALSE ) ; set_action_enabled ( "play" , FALSE ) ; set_action_enabled ( "select-all" , FALSE ) ; set_action_enabled ( "deselect-all" , FALSE ) ; set_action_enabled ( "re-read" , FALSE ) ; g_object_set ( G_OBJECT ( toggle_renderer ) , "mode" , GTK_CELL_RENDERER_MODE_INERT , NULL ) ; g_object_set ( G_OBJECT ( title_renderer ) , "editable" , FALSE , NULL ) ; g_object_set ( G_OBJECT ( artist_renderer ) , "editable" , FALSE , NULL ) ; g_signal_handlers_block_by_func ( track_listview , on_tracklist_row_activate , NULL ) ; <S2SV_StartBug> if ( ! brasero_drive_lock ( drive , _ ( "Extracting<S2SV_blank>audio<S2SV_blank>from<S2SV_blank>CD" ) , & reason ) ) { <S2SV_EndBug> g_warning ( "Could<S2SV_blank>not<S2SV_blank>lock<S2SV_blank>drive:<S2SV_blank>%s" , reason ) ; g_free ( reason ) ; } cookie = gtk_application_inhibit ( GTK_APPLICATION ( g_application_get_default ( ) ) , GTK_WINDOW ( main_window ) , GTK_APPLICATION_INHIBIT_SUSPEND | GTK_APPLICATION_INHIBIT_SWITCH , _ ( "Extracting<S2SV_blank>audio<S2SV_blank>from<S2SV_blank>CD" ) ) ; save_genre ( genre_entry ) ; extracting = TRUE ; gtk_tree_model_get_iter_first ( GTK_TREE_MODEL ( track_store ) , & current ) ; find_next ( ) ; <S2SV_StartBug> pop_and_extract ( & overwrite_mode ) ; <S2SV_EndBug> } | <S2SV_ModStart> - 1 ; sj_overwrite_mode <S2SV_ModEnd> = NORMAL ; <S2SV_ModStart> { g_signal_connect ( sj_extractor <S2SV_ModEnd> , "progress" , <S2SV_ModStart> ; g_signal_connect ( sj_extractor <S2SV_ModEnd> , "completion" , <S2SV_ModStart> gpointer ) & sj_overwrite_mode <S2SV_ModEnd> ) ; g_signal_connect <S2SV_ModStart> ; g_signal_connect ( sj_extractor <S2SV_ModEnd> , "error" , <S2SV_ModStart> ! brasero_drive_lock ( sj_drive <S2SV_ModEnd> , _ ( <S2SV_ModStart> pop_and_extract ( & sj_overwrite_mode <S2SV_ModEnd> ) ; } |
5,248 | CWE-000 char * __strcpy_chk ( char * dest , const char * src , size_t destlen ) { <S2SV_StartBug> assert ( dest != NULL ) ; <S2SV_EndBug> assert ( src != NULL ) ; <S2SV_StartBug> assert ( strlen ( src ) < destlen ) ; <S2SV_EndBug> return strcpy ( dest , src ) ; } | <S2SV_ModStart> destlen ) { size_t n = strlen ( src ) + 1 ; <S2SV_ModStart> ; assert ( destlen >= n ) ; if ( dest < src ) { assert ( dest + n <= src ) ; } else { assert ( src + n <= dest ) ; } <S2SV_ModEnd> return strcpy ( |
5,249 | CWE-000 struct msm_isp_bufq * msm_isp_get_bufq ( struct msm_isp_buf_mgr * buf_mgr , uint32_t bufq_handle ) { struct msm_isp_bufq * bufq = NULL ; uint32_t bufq_index = bufq_handle & 0xFF ; <S2SV_StartBug> if ( bufq_index > buf_mgr -> num_buf_q ) <S2SV_EndBug> return bufq ; bufq = & buf_mgr -> bufq [ bufq_index ] ; if ( bufq -> bufq_handle == bufq_handle ) return bufq ; return NULL ; } | <S2SV_ModStart> ; if ( ( bufq_handle == 0 ) || ( <S2SV_ModStart> -> num_buf_q ) || ( bufq_index >= BUF_MGR_NUM_BUF_Q ) ) return NULL <S2SV_ModEnd> ; bufq = |
5,250 | CWE-000 void _copyNode ( struct node * nodeDest , struct node * nodeSrc ) { int i ; <S2SV_StartBug> nodeDest -> function = nodeSrc -> function ; <S2SV_EndBug> nodeDest -> active = nodeSrc -> active ; nodeDest -> maxArity = nodeSrc -> maxArity ; nodeDest -> actArity = nodeSrc -> actArity ; for ( i = 0 ; i < nodeSrc -> maxArity ; i ++ ) { nodeDest -> inputs [ i ] = nodeSrc -> inputs [ i ] ; nodeDest -> weights [ i ] = nodeSrc -> weights [ i ] ; } } | <S2SV_ModStart> nodeSrc -> function ; nodeDest -> amplitude = nodeSrc -> amplitude |
5,251 | CWE-000 static int is_exec_sh_success ( uint8_t * data , int data_len ) { char * data_ptr = ( char * ) data ; int handle_len = - 1 ; int i ; <S2SV_StartBug> int ret ; <S2SV_EndBug> <S2SV_StartBug> for ( i = data_len ; i > 0 ; i -- ) <S2SV_EndBug> { if ( data_ptr [ i ] == '$' || data_ptr [ i ] == '#' || data_ptr [ i ] == '~' ) { <S2SV_StartBug> handle_len = i ; <S2SV_EndBug> break ; } } return handle_len ; } | <S2SV_ModStart> int i ; <S2SV_ModEnd> for ( i <S2SV_ModStart> data_len ; i >= <S2SV_ModEnd> 0 ; i <S2SV_ModStart> handle_len = i + 1 |
5,252 | CWE-000 static void init ( void ) { int sz ; if ( ! global_mem . init ) { sz = getpagesize ( ) * 13 ; <S2SV_StartBug> global_mem . min = new_mem_group ( NULL , sz ) ; <S2SV_EndBug> sz = 128 * sz ; global_mem . med = new_mem_group ( NULL , sz ) ; global_mem . init = 1 ; } } | <S2SV_ModStart> ; global_mem . sml <S2SV_ModEnd> = new_mem_group ( |
5,253 | CWE-000 void * connect_handler ( void * args ) { struct sockaddr_in sin_rem ; struct connect_args * p_cn ; pthread_detach ( pthread_self ( ) ) ; p_cn = ( struct connect_args * ) args ; sin_rem . sin_addr . s_addr = p_cn -> ip_dst_n ; sin_rem . sin_family = AF_INET ; sin_rem . sin_port = p_cn -> port_dst_n ; if ( connect ( p_cn -> sockfd , ( struct sockaddr * ) & sin_rem , sizeof ( sin_rem ) ) < 0 ) { printf ( "connect<S2SV_blank>failed.<S2SV_blank>Error" ) ; pthread_exit ( NULL ) ; } <S2SV_StartBug> pthread_exit ( NULL ) ; <S2SV_EndBug> } | <S2SV_ModStart> ) ; } snprintf ( msg_buf , MAX_MSG_LENGTH , "connect_handler:connect<S2SV_blank>success<S2SV_blank>return" ) ; add_msg ( msg_buf ) ; |
5,254 | CWE-000 void gql_string_set ( gqlValue value , const char * str , int len ) { value -> type = & gql_string_type ; if ( NULL == str ) { value -> str = NULL ; } else { if ( 0 >= len ) { <S2SV_StartBug> len = strlen ( str ) ; <S2SV_EndBug> } if ( len < ( int ) sizeof ( value -> str16 ) ) { value -> type = & gql_str16_type ; strncpy ( value -> str16 , str , len ) ; } else { value -> str = strndup ( str , len ) ; } } } | <S2SV_ModStart> { len = ( int ) |
5,255 | CWE-000 ISR ( SERIAL_RX ) { uint8_t data = UDR0 ; uint8_t next_head ; switch ( data ) { case CMD_RESET : mc_reset ( ) ; break ; case CMD_STATUS_REPORT : system_set_exec_state_flag ( EXEC_STATUS_REPORT ) ; break ; case CMD_CYCLE_START : system_set_exec_state_flag ( EXEC_CYCLE_START ) ; break ; <S2SV_StartBug> case CMD_FEED_HOLD : system_set_exec_state_flag ( EXEC_FEED_HOLD ) ; break ; <S2SV_EndBug> default : if ( data > 0x7F ) { switch ( data ) { case CMD_SAFETY_DOOR : system_set_exec_state_flag ( EXEC_SAFETY_DOOR ) ; break ; case CMD_JOG_CANCEL : if ( sys . state & STATE_JOG ) { system_set_exec_state_flag ( EXEC_MOTION_CANCEL ) ; } break ; # ifdef DEBUG case CMD_DEBUG_REPORT : { uint8_t sreg = SREG ; cli ( ) ; bit_true ( sys_rt_exec_debug , EXEC_DEBUG_REPORT ) ; SREG = sreg ; } break ; # endif case CMD_FEED_OVR_RESET : system_set_exec_motion_override_flag ( EXEC_FEED_OVR_RESET ) ; break ; case CMD_FEED_OVR_COARSE_PLUS : system_set_exec_motion_override_flag ( EXEC_FEED_OVR_COARSE_PLUS ) ; break ; case CMD_FEED_OVR_COARSE_MINUS : system_set_exec_motion_override_flag ( EXEC_FEED_OVR_COARSE_MINUS ) ; break ; case CMD_FEED_OVR_FINE_PLUS : system_set_exec_motion_override_flag ( EXEC_FEED_OVR_FINE_PLUS ) ; break ; case CMD_FEED_OVR_FINE_MINUS : system_set_exec_motion_override_flag ( EXEC_FEED_OVR_FINE_MINUS ) ; break ; case CMD_RAPID_OVR_RESET : system_set_exec_motion_override_flag ( EXEC_RAPID_OVR_RESET ) ; break ; case CMD_RAPID_OVR_MEDIUM : system_set_exec_motion_override_flag ( EXEC_RAPID_OVR_MEDIUM ) ; break ; case CMD_RAPID_OVR_LOW : system_set_exec_motion_override_flag ( EXEC_RAPID_OVR_LOW ) ; break ; case CMD_SPINDLE_OVR_RESET : system_set_exec_accessory_override_flag ( EXEC_SPINDLE_OVR_RESET ) ; break ; case CMD_SPINDLE_OVR_COARSE_PLUS : system_set_exec_accessory_override_flag ( EXEC_SPINDLE_OVR_COARSE_PLUS ) ; break ; case CMD_SPINDLE_OVR_COARSE_MINUS : system_set_exec_accessory_override_flag ( EXEC_SPINDLE_OVR_COARSE_MINUS ) ; break ; case CMD_SPINDLE_OVR_FINE_PLUS : system_set_exec_accessory_override_flag ( EXEC_SPINDLE_OVR_FINE_PLUS ) ; break ; case CMD_SPINDLE_OVR_FINE_MINUS : system_set_exec_accessory_override_flag ( EXEC_SPINDLE_OVR_FINE_MINUS ) ; break ; case CMD_SPINDLE_OVR_STOP : system_set_exec_accessory_override_flag ( EXEC_SPINDLE_OVR_STOP ) ; break ; case CMD_COOLANT_FLOOD_OVR_TOGGLE : system_set_exec_accessory_override_flag ( EXEC_COOLANT_FLOOD_OVR_TOGGLE ) ; break ; # ifdef ENABLE_M7 case CMD_COOLANT_MIST_OVR_TOGGLE : system_set_exec_accessory_override_flag ( EXEC_COOLANT_MIST_OVR_TOGGLE ) ; break ; # endif } } else { next_head = serial_rx_buffer_head + 1 ; if ( next_head == RX_RING_BUFFER ) { next_head = 0 ; } if ( next_head != serial_rx_buffer_tail ) { serial_rx_buffer [ serial_rx_buffer_head ] = data ; serial_rx_buffer_head = next_head ; } } } } | <S2SV_ModStart> system_set_exec_state_flag ( EXEC_FEED_HOLD ) ; system_set_exec_state_flag ( EXEC_SAFETY_DOOR |
5,256 | CWE-000 static int __cpufreq_add_dev ( struct device * dev , struct subsys_interface * sif , bool frozen ) { unsigned int j , cpu = dev -> id ; int ret = - ENOMEM ; struct cpufreq_policy * policy ; unsigned long flags ; # ifdef CONFIG_HOTPLUG_CPU struct cpufreq_policy * tpolicy ; struct cpufreq_governor * gov ; # endif if ( cpu_is_offline ( cpu ) ) return 0 ; pr_debug ( "adding<S2SV_blank>CPU<S2SV_blank>%u\\n" , cpu ) ; # ifdef CONFIG_SMP policy = cpufreq_cpu_get ( cpu ) ; if ( unlikely ( policy ) ) { cpufreq_cpu_put ( policy ) ; return 0 ; } # endif if ( ! down_read_trylock ( & cpufreq_rwsem ) ) return 0 ; # ifdef CONFIG_HOTPLUG_CPU read_lock_irqsave ( & cpufreq_driver_lock , flags ) ; list_for_each_entry ( tpolicy , & cpufreq_policy_list , policy_list ) { if ( cpumask_test_cpu ( cpu , tpolicy -> related_cpus ) ) { read_unlock_irqrestore ( & cpufreq_driver_lock , flags ) ; ret = cpufreq_add_policy_cpu ( tpolicy , cpu , dev ) ; up_read ( & cpufreq_rwsem ) ; return ret ; } } read_unlock_irqrestore ( & cpufreq_driver_lock , flags ) ; # endif if ( frozen ) policy = cpufreq_policy_restore ( cpu ) ; else policy = cpufreq_policy_alloc ( ) ; if ( ! policy ) goto nomem_out ; if ( frozen && cpu != policy -> cpu ) { update_policy_cpu ( policy , cpu ) ; WARN_ON ( kobject_move ( & policy -> kobj , & dev -> kobj ) ) ; } else { policy -> cpu = cpu ; } policy -> governor = CPUFREQ_DEFAULT_GOVERNOR ; cpumask_copy ( policy -> cpus , cpumask_of ( cpu ) ) ; init_completion ( & policy -> kobj_unregister ) ; INIT_WORK ( & policy -> update , handle_update ) ; ret = cpufreq_driver -> init ( policy ) ; if ( ret ) { pr_debug ( "initialization<S2SV_blank>failed\\n" ) ; goto err_set_policy_cpu ; } if ( cpufreq_driver -> get ) { policy -> cur = cpufreq_driver -> get ( policy -> cpu ) ; if ( ! policy -> cur ) { pr_err ( "%s:<S2SV_blank>->get()<S2SV_blank>failed\\n" , __func__ ) ; goto err_get_freq ; } } cpumask_or ( policy -> related_cpus , policy -> related_cpus , policy -> cpus ) ; cpumask_and ( policy -> cpus , policy -> cpus , cpu_online_mask ) ; <S2SV_StartBug> policy -> user_policy . min = policy -> min ; <S2SV_EndBug> <S2SV_StartBug> policy -> user_policy . max = policy -> max ; <S2SV_EndBug> blocking_notifier_call_chain ( & cpufreq_policy_notifier_list , CPUFREQ_START , policy ) ; # ifdef CONFIG_HOTPLUG_CPU gov = __find_governor ( per_cpu ( cpufreq_policy_save , cpu ) . gov ) ; if ( gov ) { policy -> governor = gov ; pr_debug ( "Restoring<S2SV_blank>governor<S2SV_blank>%s<S2SV_blank>for<S2SV_blank>cpu<S2SV_blank>%d\\n" , policy -> governor -> name , cpu ) ; } if ( per_cpu ( cpufreq_policy_save , cpu ) . min ) { policy -> min = per_cpu ( cpufreq_policy_save , cpu ) . min ; policy -> user_policy . min = policy -> min ; } if ( per_cpu ( cpufreq_policy_save , cpu ) . max ) { policy -> max = per_cpu ( cpufreq_policy_save , cpu ) . max ; policy -> user_policy . max = policy -> max ; } pr_debug ( "Restoring<S2SV_blank>CPU%d<S2SV_blank>user<S2SV_blank>policy<S2SV_blank>min<S2SV_blank>%d<S2SV_blank>and<S2SV_blank>max<S2SV_blank>%d\\n" , cpu , policy -> min , policy -> max ) ; # endif if ( ! frozen ) { ret = cpufreq_add_dev_interface ( policy , dev ) ; if ( ret ) goto err_out_unregister ; blocking_notifier_call_chain ( & cpufreq_policy_notifier_list , CPUFREQ_CREATE_POLICY , policy ) ; } write_lock_irqsave ( & cpufreq_driver_lock , flags ) ; list_add ( & policy -> policy_list , & cpufreq_policy_list ) ; write_unlock_irqrestore ( & cpufreq_driver_lock , flags ) ; cpufreq_init_policy ( policy ) ; <S2SV_StartBug> write_lock_irqsave ( & cpufreq_driver_lock , flags ) ; <S2SV_EndBug> for_each_cpu ( j , policy -> cpus ) per_cpu ( cpufreq_cpu_data , j ) = policy ; write_unlock_irqrestore ( & cpufreq_driver_lock , flags ) ; kobject_uevent ( & policy -> kobj , KOBJ_ADD ) ; up_read ( & cpufreq_rwsem ) ; pr_debug ( "initialization<S2SV_blank>complete\\n" ) ; return 0 ; err_out_unregister : write_lock_irqsave ( & cpufreq_driver_lock , flags ) ; for_each_cpu ( j , policy -> cpus ) per_cpu ( cpufreq_cpu_data , j ) = NULL ; write_unlock_irqrestore ( & cpufreq_driver_lock , flags ) ; err_get_freq : if ( cpufreq_driver -> exit ) cpufreq_driver -> exit ( policy ) ; err_set_policy_cpu : if ( frozen ) cpufreq_policy_put_kobj ( policy ) ; cpufreq_policy_free ( policy ) ; nomem_out : up_read ( & cpufreq_rwsem ) ; return ret ; } | <S2SV_ModStart> cpu_online_mask ) ; if ( ! frozen ) { <S2SV_ModStart> -> max ; } <S2SV_ModStart> policy ) ; if ( ! frozen ) { policy -> user_policy . policy = policy -> policy ; policy -> user_policy . governor = policy -> governor ; } |
5,257 | CWE-000 int deallocate_block ( file_ext2_t * file_del , uint32_t del_blk_num ) { <S2SV_StartBug> int retval = - 1 ; <S2SV_EndBug> if ( ! del_blk_num ) { return 0 ; } superblock_ext2_t * sb = file_del -> sb ; uint32_t ext2_blocksize = GET_BLOCKSIZE_EXT2 ( sb ) ; uint32_t del_blk_bgd_index = blk_num_to_blk_group ( sb , del_blk_num ) ; uint32_t del_blk_bgd_akt = del_blk_bgd_index ; char * blk_bitmap = 0 ; alloc_if_empty ( & blk_bitmap , ext2_blocksize ) ; bg_desc_ext2_t bgd_akt ; read_bgdesc_ext2 ( file_del -> dev_file , & bgd_akt , del_blk_bgd_akt ) ; uint32_t blk_num_bitmap = bgd_akt . bg_block_bitmap ; read_from_dev ( file_del -> dev_file , blk_bitmap , ext2_blocksize , BLKNUM_TO_OFFSET ( blk_num_bitmap , ext2_blocksize ) ) ; # if 1 uint32_t first_bit_akt = get_first_data_block_pos_in_block_group_bitmap ( del_blk_bgd_akt , sb , & bgd_akt ) ; uint32_t last_bit_akt = get_last_data_block_pos_in_block_group_bitmap ( del_blk_bgd_akt , sb , & bgd_akt ) ; # endif uint32_t bit_akt = del_blk_num - blk_group_to_blk_num ( sb , del_blk_bgd_akt ) ; ASSERT ( first_bit_akt <= bit_akt ) ; ASSERT ( bit_akt <= last_bit_akt ) ; <S2SV_StartBug> ASSERT ( test_bit ( bit_akt , blk_bitmap ) ) ; <S2SV_EndBug> <S2SV_StartBug> reset_bit ( bit_akt , blk_bitmap ) ; <S2SV_EndBug> write_to_dev ( file_del -> dev_file , blk_bitmap , ext2_blocksize , BLKNUM_TO_OFFSET ( blk_num_bitmap , ext2_blocksize ) ) ; ++ bgd_akt . bg_free_blocks_count ; write_bgdesc_ext2 ( file_del -> dev_file , & bgd_akt , del_blk_bgd_akt ) ; ++ sb -> s_free_blocks_count ; sb -> s_wtime = get_timestamp ( ) ; write_superblock_ext2 ( file_del -> dev_file , sb ) ; free ( blk_bitmap ) ; return 0 ; } | <S2SV_ModStart> del_blk_num ) { <S2SV_ModEnd> if ( ! <S2SV_ModStart> ( bit_akt , ( uint8_t * ) <S2SV_ModStart> ( bit_akt , ( uint8_t * ) |
5,258 | CWE-000 void lsquic_packet_out_destroy ( lsquic_packet_out_t * packet_out , <S2SV_StartBug> struct lsquic_engine_public * enpub ) <S2SV_EndBug> { if ( packet_out -> po_flags & PO_SREC_ARR ) { struct stream_rec_arr * srec_arr , * next ; for ( srec_arr = TAILQ_FIRST ( & packet_out -> po_srecs . arr ) ; srec_arr ; srec_arr = next ) { next = TAILQ_NEXT ( srec_arr , next_stream_rec_arr ) ; lsquic_malo_put ( srec_arr ) ; } } if ( packet_out -> po_flags & PO_ENCRYPTED ) <S2SV_StartBug> enpub -> enp_pmi -> pmi_release ( enpub -> enp_pmi_ctx , <S2SV_EndBug> <S2SV_StartBug> packet_out -> po_enc_data ) ; <S2SV_EndBug> if ( packet_out -> po_nonce ) free ( packet_out -> po_nonce ) ; lsquic_mm_put_packet_out ( & enpub -> enp_mm , packet_out ) ; } | <S2SV_ModStart> lsquic_engine_public * enpub , void * peer_ctx <S2SV_ModStart> -> enp_pmi_ctx , peer_ctx , <S2SV_ModStart> packet_out -> po_enc_data , lsquic_packet_out_ipv6 ( packet_out ) |
5,259 | CWE-000 RCMS * r_pkcs7_parse_cms ( const ut8 * buffer , ut32 length ) { RASN1Object * object ; RCMS * container ; if ( ! buffer || ! length ) { return NULL ; } container = R_NEW0 ( RCMS ) ; if ( ! container ) { return NULL ; } object = r_asn1_create_object ( buffer , length ) ; if ( ! object || object -> list . length != 2 || ! object -> list . objects || ! object -> list . objects [ 0 ] || ! object -> list . objects [ 1 ] || object -> list . objects [ 1 ] -> list . length != 1 ) { r_asn1_free_object ( object ) ; free ( container ) ; return NULL ; <S2SV_StartBug> } <S2SV_EndBug> container -> contentType = r_asn1_stringify_oid ( object -> list . objects [ 0 ] -> sector , object -> list . objects [ 0 ] -> length ) ; <S2SV_StartBug> r_pkcs7_parse_signeddata ( & container -> signedData , object -> list . objects [ 1 ] -> list . objects [ 0 ] ) ; <S2SV_EndBug> <S2SV_StartBug> r_asn1_free_object ( object ) ; <S2SV_EndBug> return container ; } | <S2SV_ModStart> NULL ; } if ( object -> list . objects [ 0 ] ) { <S2SV_ModStart> length ) ; } if ( object -> list . objects [ 1 ] ) { <S2SV_ModStart> ] ) ; } |
5,260 | CWE-000 void chpl_task_addToTaskList ( chpl_fn_int_t fid , chpl_task_bundle_t * arg , size_t arg_size , c_sublocid_t full_subloc , void * * task_list , int32_t task_list_locale , <S2SV_StartBug> chpl_bool is_begin_stmt , <S2SV_EndBug> int lineno , int32_t filename ) { chpl_bool serial_state = chpl_task_getSerial ( ) ; chpl_fn_p requested_fn = chpl_ftable [ fid ] ; assert ( isActualSublocID ( full_subloc ) || full_subloc == c_sublocid_any ) ; PROFILE_INCR ( profile_task_addToTaskList , 1 ) ; if ( serial_state ) { requested_fn ( arg ) ; } else { c_sublocid_t execution_subloc = chpl_localeModel_sublocToExecutionSubloc ( full_subloc ) ; arg -> serial_state = false ; arg -> countRunning = false ; arg -> is_executeOn = false ; arg -> requestedSubloc = full_subloc ; arg -> requested_fid = fid ; arg -> requested_fn = requested_fn ; arg -> lineno = lineno ; arg -> filename = filename ; arg -> id = chpl_nullTaskID ; wrap_callbacks ( chpl_task_cb_event_kind_create , arg ) ; if ( execution_subloc == c_sublocid_any ) { qthread_fork_copyargs ( chapel_wrapper , arg , arg_size , NULL ) ; } else { qthread_fork_copyargs_to ( chapel_wrapper , arg , arg_size , NULL , ( qthread_shepherd_id_t ) execution_subloc ) ; } } } | <S2SV_ModStart> , chpl_bool is_begin_stmt , void * dummy_task_group |
5,261 | CWE-000 int main ( int argc , char * argv [ ] ) { char buf [ 256 ] ; aismsg_pos _pos , * pos ; pos = & _pos ; int err = 0 ; char config_smi = 1 , config_cog = 1 , config_sog = 1 ; while ( ! feof ( stdin ) ) { if ( fgets ( buf , 255 , stdin ) == NULL ) break ; memset ( pos , 0 , sizeof ( aismsg_pos ) ) ; static char * ais ; static char * prefix ; if ( ( ais = strchr ( buf , ';' ) ) != NULL ) { ais [ 0 ] = '\\0' ; ais ++ ; pos -> ts = buf ; } else { ais = buf ; prefix = "" ; } if ( ( err = buf2pos ( ais , pos ) ) == 0 ) { printf ( "{\\"type\\":\\"Feature\\"," ) ; printf ( "" "\\"geometry\\":{" "" "\\"type\\":\\"Point\\"," "" "\\"coordinates\\":[%0.7f,%0.7f]" "" "}," , pos -> long_ddd , pos -> lat_dd ) ; printf ( "" "\\"properties\\":{" "" "\\"mmsi\\":\\"%ld\\"," , pos -> userid ) ; <S2SV_StartBug> printf ( "" "\\"aistype\\":%ld," , pos -> msgid ) ; <S2SV_EndBug> if ( config_cog && pos -> cog >= 0 ) printf ( "\\"cog\\":%0.1f," , pos -> cog ) ; if ( config_sog && pos -> sog >= 0 ) printf ( "\\"sog\\":%0.1f," , pos -> sog ) ; if ( config_smi && pos -> smi >= 0 ) printf ( "\\"smi\\":%d," , pos -> smi ) ; if ( pos -> ts == 0 ) printf ( "\\"ts\\":false" ) ; else { static char * endptr ; errno = 0 ; long int ts = strtol ( pos -> ts , & endptr , 10 ) ; if ( errno == 0 && ( endptr + 1 == ais ) ) { <S2SV_StartBug> printf ( "\\"ts\\":%d" , ts ) ; <S2SV_EndBug> } else { printf ( "\\"ts\\":\\"%s\\"" , pos -> ts ) ; } } printf ( "}}\\n" ) ; } } return 0 ; } | <S2SV_ModStart> printf ( "" "\\"aistype\\":%d," <S2SV_ModEnd> , pos -> <S2SV_ModStart> { printf ( "\\"ts\\":%ld" <S2SV_ModEnd> , ts ) |
5,262 | CWE-000 void setup ( void ) { REG_WDT_MR = WDT_MR_WDDIS ; masterClockInit ( ) ; pioInit ( ) ; adcSingleConvInit ( ) ; ledInit ( ) ; motor_init ( ) ; SPI_Init ( ) ; twi0Init ( ) ; twi2Init ( ) ; lightSensInit ( MUX_LIGHTSENS_R ) ; lightSensInit ( MUX_LIGHTSENS_L ) ; proxSensInit ( MUX_PROXSENS_A ) ; proxSensInit ( MUX_PROXSENS_B ) ; proxSensInit ( MUX_PROXSENS_C ) ; proxSensInit ( MUX_PROXSENS_D ) ; proxSensInit ( MUX_PROXSENS_E ) ; proxSensInit ( MUX_PROXSENS_F ) ; CommunicationSetup ( ) ; <S2SV_StartBug> uint16_t result = proxSensRead ( MUX_PROXSENS_A ) ; <S2SV_EndBug> return ; } | <S2SV_ModStart> ( ) ; imuInit ( <S2SV_ModEnd> ) ; return |
5,263 | CWE-000 PHP_PROTO_INIT_SUBMSGCLASS_END PHP_METHOD ( FieldMask , __construct ) { init_file_field_mask ( TSRMLS_C ) ; MessageHeader * intern = UNBOX ( MessageHeader , getThis ( ) ) ; <S2SV_StartBug> custom_data_init ( field_mask_type , intern PHP_PROTO_TSRMLS_CC ) ; <S2SV_EndBug> } | <S2SV_ModStart> ) ) ; INIT_MESSAGE_WITH_ARRAY <S2SV_ModEnd> ; } <S2SV_null> |
5,264 | CWE-000 const char * do_alt_speller ( char * tempfile_name ) { int alt_spell_status ; size_t current_x_save = openfile -> current_x ; size_t pww_save = openfile -> placewewant ; ssize_t lineno_save = openfile -> current -> lineno ; struct stat spellfileinfo ; time_t timestamp ; pid_t pid_spell ; char * ptr ; static int arglen = 3 ; static char * * spellargs = NULL ; # ifndef NANO_TINY bool old_mark_set = openfile -> mark_set ; bool added_magicline = FALSE ; filestruct * top , * bot ; <S2SV_StartBug> size_t top_x , bot_x ; <S2SV_EndBug> bool right_side_up = FALSE ; ssize_t mb_lineno_save = 0 ; size_t size_of_surrounding = 0 ; # endif stat ( tempfile_name , & spellfileinfo ) ; timestamp = spellfileinfo . st_mtime ; if ( spellfileinfo . st_size == 0 ) return NULL ; # ifndef NANO_TINY if ( old_mark_set ) { mb_lineno_save = openfile -> mark_begin -> lineno ; openfile -> mark_set = FALSE ; } # endif endwin ( ) ; if ( spellargs == NULL ) { spellargs = ( char * * ) nmalloc ( arglen * sizeof ( char * ) ) ; spellargs [ 0 ] = strtok ( alt_speller , "<S2SV_blank>" ) ; while ( ( ptr = strtok ( NULL , "<S2SV_blank>" ) ) != NULL ) { arglen ++ ; spellargs = ( char * * ) nrealloc ( spellargs , arglen * sizeof ( char * ) ) ; spellargs [ arglen - 3 ] = ptr ; } spellargs [ arglen - 1 ] = NULL ; } spellargs [ arglen - 2 ] = tempfile_name ; if ( ( pid_spell = fork ( ) ) == 0 ) { execvp ( spellargs [ 0 ] , spellargs ) ; exit ( 1 ) ; } if ( pid_spell < 0 ) return _ ( "Could<S2SV_blank>not<S2SV_blank>fork" ) ; # ifndef NANO_TINY allow_sigwinch ( FALSE ) ; # endif wait ( & alt_spell_status ) ; doupdate ( ) ; terminal_init ( ) ; if ( ! WIFEXITED ( alt_spell_status ) || WEXITSTATUS ( alt_spell_status ) != 0 ) { # ifndef NANO_TINY openfile -> mark_set = old_mark_set ; # endif return invocation_error ( alt_speller ) ; } # ifndef NANO_TINY if ( old_mark_set ) { mark_order ( ( const filestruct * * ) & top , & top_x , ( const filestruct * * ) & bot , & bot_x , & right_side_up ) ; filepart = partition_filestruct ( top , top_x , bot , bot_x ) ; if ( ! ISSET ( NO_NEWLINES ) ) added_magicline = ( openfile -> filebot -> data [ 0 ] != '\\0' ) ; size_of_surrounding = openfile -> totsize - get_totsize ( top , bot ) ; } # endif replace_buffer ( tempfile_name ) ; # ifndef NANO_TINY if ( old_mark_set ) { filestruct * top_save = openfile -> fileage ; if ( added_magicline ) remove_magicline ( ) ; if ( right_side_up ) <S2SV_StartBug> current_x_save = strlen ( openfile -> filebot -> data ) ; <S2SV_EndBug> else <S2SV_StartBug> openfile -> mark_begin_x = strlen ( openfile -> filebot -> data ) ; <S2SV_EndBug> unpartition_filestruct ( & filepart ) ; renumber ( top_save ) ; openfile -> totsize += size_of_surrounding ; openfile -> mark_begin = fsfromline ( mb_lineno_save ) ; openfile -> mark_set = TRUE ; } # endif goto_line_posx ( lineno_save , current_x_save ) ; if ( openfile -> current_x > strlen ( openfile -> current -> data ) ) openfile -> current_x = strlen ( openfile -> current -> data ) ; openfile -> placewewant = pww_save ; adjust_viewport ( STATIONARY ) ; stat ( tempfile_name , & spellfileinfo ) ; if ( spellfileinfo . st_mtime != timestamp ) { set_modified ( ) ; # ifndef NANO_TINY discard_until ( NULL , openfile ) ; # endif } # ifndef NANO_TINY allow_sigwinch ( TRUE ) ; # endif return NULL ; } | <S2SV_ModStart> top_x , bot_x , was_x , new_x <S2SV_ModStart> ( right_side_up ) was_x = current_x_save ; else was_x = openfile -> mark_begin_x ; if ( top == bot ) new_x = was_x - bot_x + top_x + <S2SV_ModEnd> strlen ( openfile <S2SV_ModStart> ) ; else new_x = strlen ( openfile -> filebot -> data ) ; if ( right_side_up ) current_x_save = new_x ; else <S2SV_ModStart> -> mark_begin_x = new_x <S2SV_ModEnd> ; unpartition_filestruct ( |
5,265 | CWE-000 void vfs_init ( void ) { struct fnode * dev = NULL ; FNO_ROOT . owner = NULL ; FNO_ROOT . fname = "/" ; FNO_ROOT . parent = & FNO_ROOT ; FNO_ROOT . children = NULL ; FNO_ROOT . next = NULL ; FNO_ROOT . flags = FL_DIR | FL_RDWR ; <S2SV_StartBug> dev = fno_mkdir ( NULL , "dev" , NULL ) ; <S2SV_EndBug> <S2SV_StartBug> dev = fno_mkdir ( NULL , "sys" , NULL ) ; <S2SV_EndBug> <S2SV_StartBug> dev = fno_mkdir ( NULL , "tmp" , NULL ) ; <S2SV_EndBug> <S2SV_StartBug> dev = fno_mkdir ( NULL , "bin" , NULL ) ; <S2SV_EndBug> <S2SV_StartBug> dev = fno_mkdir ( NULL , "mnt" , NULL ) ; <S2SV_EndBug> } | <S2SV_ModStart> | FL_RDWR ; <S2SV_ModEnd> fno_mkdir ( NULL <S2SV_ModStart> NULL ) ; <S2SV_ModEnd> fno_mkdir ( NULL <S2SV_ModStart> NULL ) ; <S2SV_ModEnd> fno_mkdir ( NULL <S2SV_ModStart> NULL ) ; <S2SV_ModEnd> fno_mkdir ( NULL <S2SV_ModStart> NULL ) ; <S2SV_ModEnd> fno_mkdir ( NULL |
5,266 | CWE-000 static ngx_int_t ngx_resolver_send_udp_query ( ngx_resolver_t * r , ngx_resolver_connection_t * rec , u_char * query , u_short qlen ) { ssize_t n ; if ( rec -> udp == NULL ) { if ( ngx_udp_connect ( rec ) != NGX_OK ) { return NGX_ERROR ; } rec -> udp -> data = rec ; rec -> udp -> read -> handler = ngx_resolver_udp_read ; rec -> udp -> read -> resolver = 1 ; } n = ngx_send ( rec -> udp , query , qlen ) ; if ( n == NGX_ERROR ) { <S2SV_StartBug> return NGX_ERROR ; <S2SV_EndBug> } if ( ( size_t ) n != ( size_t ) qlen ) { ngx_log_error ( NGX_LOG_CRIT , & rec -> log , 0 , "send()<S2SV_blank>incomplete" ) ; <S2SV_StartBug> return NGX_ERROR ; <S2SV_EndBug> } return NGX_OK ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> NGX_ERROR ) { goto failed <S2SV_ModEnd> ; } if <S2SV_ModStart> "send()<S2SV_blank>incomplete" ) ; goto failed <S2SV_ModEnd> ; } return <S2SV_ModStart> return NGX_OK ; failed : ngx_close_connection ( rec -> udp ) ; rec -> udp = NULL ; return NGX_ERROR ; |
5,267 | CWE-000 static int virStorageBackendSheepdogCreateVol ( virConnectPtr conn ATTRIBUTE_UNUSED , virStoragePoolObjPtr pool , virStorageVolDefPtr vol ) { if ( vol -> target . encryption != NULL ) { virReportError ( VIR_ERR_CONFIG_UNSUPPORTED , "%s" , _ ( "storage<S2SV_blank>pool<S2SV_blank>does<S2SV_blank>not<S2SV_blank>support<S2SV_blank>encrypted<S2SV_blank>" "volumes" ) ) ; return - 1 ; } vol -> type = VIR_STORAGE_VOL_NETWORK ; VIR_FREE ( vol -> key ) ; if ( virAsprintf ( & vol -> key , "%s/%s" , <S2SV_StartBug> pool -> def -> source . name , vol -> name ) == - 1 ) <S2SV_EndBug> return - 1 ; VIR_FREE ( vol -> target . path ) ; if ( VIR_STRDUP ( vol -> target . path , vol -> name ) < 0 ) return - 1 ; return 0 ; } | <S2SV_ModStart> -> name ) < 0 <S2SV_ModEnd> ) return - |
5,268 | CWE-000 bwt_t * bwt_file_read ( char * filename , txt_t * txt ) { int fd = - 1 ; <S2SV_StartBug> uint64_t * data = NULL ; <S2SV_EndBug> error_test_msg ( filename == NULL , "argument<S2SV_blank>\'filename\'<S2SV_blank>is<S2SV_blank>NULL." ) ; error_test_msg ( txt == NULL , "argument<S2SV_blank>\'txt\'<S2SV_blank>is<S2SV_blank>NULL." ) ; int32_t sym_cnt = sym_count ( txt_get_symbols ( txt ) ) ; fd = open ( filename , O_RDONLY ) ; error_test_def ( fd == - 1 ) ; <S2SV_StartBug> bwt_t * bwt = malloc ( sizeof ( bwt_t ) ) ; <S2SV_EndBug> error_test_mem ( bwt ) ; bwt -> occ = NULL ; bwt -> c = NULL ; struct stat sb ; fstat ( fd , & sb ) ; error_test_msg ( sb . st_size < 48 , "\'bwt\'<S2SV_blank>file<S2SV_blank>is<S2SV_blank>too<S2SV_blank>small<S2SV_blank>(sb.st_size<S2SV_blank><<S2SV_blank>48)." ) ; data = mmap ( NULL , sb . st_size , PROT_READ , MAP_SHARED , fd , 0 ) ; error_test_def ( data == NULL ) ; bwt -> mmap_len = sb . st_size ; bwt -> mmap_ptr = ( void * ) data ; uint64_t magic = data [ 0 ] ; error_test_msg ( magic != BWT_FILE_MAGICNO , "unrecognized<S2SV_blank>\'bwt\'<S2SV_blank>file<S2SV_blank>format<S2SV_blank>(magicno)." ) ; bwt -> occ_length = data [ 1 ] ; bwt -> occ_mark_intv = data [ 2 ] ; bwt -> occ_word_size = data [ 3 ] ; bwt -> occ_mark_bits = data [ 4 ] ; bwt -> c = data + 5 ; bwt -> occ = bwt -> c + sym_cnt + 1 ; bwt -> txt = txt ; close ( fd ) ; return bwt ; failure_return : if ( fd != - 1 ) close ( fd ) ; if ( data != NULL ) munmap ( data , sb . st_size ) ; bwt_free ( bwt ) ; return NULL ; } | <S2SV_ModStart> uint64_t * data = NULL ; bwt_t * bwt <S2SV_ModStart> 1 ) ; <S2SV_ModEnd> bwt = malloc |
5,269 | CWE-000 int rump_init ( void ) { if ( rumpuser_init ( RUMPUSER_VERSION , & hyp ) != 0 ) { rumpuser_dprintf ( "rumpuser<S2SV_blank>init<S2SV_blank>failed\\n" ) ; return - EINVAL ; } rumpuser_mutex_init ( & thrmtx , RUMPUSER_MTX_SPIN ) ; rumpuser_cv_init ( & thrcv ) ; threads_are_go = false ; if ( rumpuser_getparam ( "LKL_BOOT_CMDLINE" , buf , sizeof ( buf ) ) == 0 ) boot_cmdline = buf ; else boot_cmdline = "mem=100M<S2SV_blank>virtio-pci.force_legacy=1" ; <S2SV_StartBug> if ( ! stack ) { <S2SV_EndBug> stack = rump_mem_alloc ( STACKSIZE ) ; if ( ! stack ) { rumpuser_dprintf ( "rump_mem_alloc<S2SV_blank>failiure\\n" ) ; return - EINVAL ; } } lkl_start_kernel ( & lkl_host_ops , boot_cmdline ) ; # ifdef ENABLE_SYSPROXY rump_sysproxy_init ( ) ; # endif if ( rumpuser_getparam ( "RUMP_VERBOSE" , buf , sizeof ( buf ) ) == 0 ) { if ( * buf != 0 ) verbose = 1 ; } if ( verbose ) rumpuser_dprintf ( "rumpuser<S2SV_blank>started.\\n" ) ; return 0 ; } | <S2SV_ModStart> = "mem=100M<S2SV_blank>virtio-pci.force_legacy=1" ; <S2SV_ModEnd> lkl_start_kernel ( & |
5,270 | CWE-000 static int compare_node_priority ( const void * a , const void * b ) { const MXS_MONITORED_SERVER * s_a = * ( MXS_MONITORED_SERVER * const * ) a ; const MXS_MONITORED_SERVER * s_b = * ( MXS_MONITORED_SERVER * const * ) b ; char pri_a [ 50 ] ; char pri_b [ 50 ] ; <S2SV_StartBug> bool have_a = server_get_parameter ( s_a -> server , "priority" , pri_a , sizeof ( pri_a ) ) ; <S2SV_EndBug> <S2SV_StartBug> bool have_b = server_get_parameter ( s_b -> server , "priority" , pri_b , sizeof ( pri_b ) ) ; <S2SV_EndBug> if ( ! have_a && have_b ) { MXS_DEBUG ( "Server<S2SV_blank>%s<S2SV_blank>has<S2SV_blank>no<S2SV_blank>given<S2SV_blank>priority.<S2SV_blank>It<S2SV_blank>will<S2SV_blank>be<S2SV_blank>at<S2SV_blank>the<S2SV_blank>beginning<S2SV_blank>of<S2SV_blank>the<S2SV_blank>list" , s_a -> server -> unique_name ) ; return - ( INT_MAX - 1 ) ; } else if ( have_a && ! have_b ) { MXS_DEBUG ( "Server<S2SV_blank>%s<S2SV_blank>has<S2SV_blank>no<S2SV_blank>given<S2SV_blank>priority.<S2SV_blank>It<S2SV_blank>will<S2SV_blank>be<S2SV_blank>at<S2SV_blank>the<S2SV_blank>beginning<S2SV_blank>of<S2SV_blank>the<S2SV_blank>list" , s_b -> server -> unique_name ) ; return INT_MAX - 1 ; } else if ( ! have_a && ! have_b ) { MXS_DEBUG ( "Servers<S2SV_blank>%s<S2SV_blank>and<S2SV_blank>%s<S2SV_blank>have<S2SV_blank>no<S2SV_blank>given<S2SV_blank>priority.<S2SV_blank>They<S2SV_blank>be<S2SV_blank>at<S2SV_blank>the<S2SV_blank>beginning<S2SV_blank>of<S2SV_blank>the<S2SV_blank>list" , s_a -> server -> unique_name , s_b -> server -> unique_name ) ; return 0 ; } int pri_val_a = atoi ( pri_a ) ; int pri_val_b = atoi ( pri_b ) ; if ( ( pri_val_a < INT_MAX && pri_val_a > 0 ) && ! ( pri_val_b < INT_MAX && pri_val_b > 0 ) ) { return pri_val_a ; } else if ( ! ( pri_val_a < INT_MAX && pri_val_a > 0 ) && ( pri_val_b < INT_MAX && pri_val_b > 0 ) ) { return - pri_val_b ; } else if ( ! ( pri_val_a < INT_MAX && pri_val_a > 0 ) && ! ( pri_val_b < INT_MAX && pri_val_b > 0 ) ) { return 0 ; } return pri_val_b - pri_val_a ; } | <S2SV_ModStart> bool have_a = server_get_parameter_nolock <S2SV_ModEnd> ( s_a -> <S2SV_ModStart> bool have_b = server_get_parameter_nolock <S2SV_ModEnd> ( s_b -> |
5,271 | CWE-000 static int grow_lower_delta ( const char * device , int top , int start_level , int end_level ) { off_t src_size = 0 ; off_t dst_size = 0 ; char * src_image = NULL ; char * dst_image = NULL ; int i , devfd ; struct ploop_pvd_header * vh ; struct grow_maps grow_maps ; char * fmt ; int dst_is_raw = 0 ; void * buf = NULL ; <S2SV_StartBug> struct delta odelta = { } ; <S2SV_EndBug> int ret ; __u64 cluster ; if ( top ) { if ( ( ret = ploop_get_size ( device , & src_size ) ) ) return ret ; } else { if ( find_delta_names ( device , end_level , end_level , & src_image , & fmt ) ) { ploop_err ( errno , "find_delta_names" ) ; ret = SYSEXIT_SYSFS ; goto done ; } if ( ( ret = read_size_from_image ( src_image , 0 , & src_size ) ) ) goto done ; } if ( find_delta_names ( device , start_level , start_level , & dst_image , & fmt ) ) { ploop_err ( errno , "find_delta_names" ) ; ret = SYSEXIT_SYSFS ; goto done ; } if ( strcmp ( fmt , "raw" ) == 0 ) dst_is_raw = 1 ; if ( ( ret = read_size_from_image ( dst_image , dst_is_raw , & dst_size ) ) ) goto done ; if ( src_size <= dst_size ) { ret = 0 ; goto done ; } if ( dst_is_raw ) { ret = grow_raw_delta ( dst_image , S2B ( src_size - dst_size ) ) ; goto done ; } if ( open_delta ( & odelta , dst_image , O_RDWR , OD_NOFLAGS ) ) { ploop_err ( errno , "open_delta" ) ; ret = SYSEXIT_OPEN ; goto done ; } if ( dirty_delta ( & odelta ) ) { ploop_err ( errno , "dirty_delta" ) ; ret = SYSEXIT_WRITE ; goto done ; } cluster = S2B ( odelta . blocksize ) ; if ( p_memalign ( & buf , 4096 , cluster ) ) { ret = SYSEXIT_MALLOC ; goto done ; } if ( ( ret = grow_delta ( & odelta , src_size , buf , & grow_maps ) ) ) goto done ; if ( clear_delta ( & odelta ) ) { ploop_err ( errno , "clear_delta" ) ; ret = SYSEXIT_WRITE ; goto done ; } devfd = open ( device , O_RDONLY ) ; if ( devfd < 0 ) { ploop_err ( errno , "open<S2SV_blank>dev" ) ; ret = SYSEXIT_DEVICE ; goto done ; } grow_maps . ctl -> level = start_level ; ret = ioctl_device ( devfd , PLOOP_IOC_UPDATE_INDEX , grow_maps . ctl ) ; close ( devfd ) ; if ( ret ) goto done ; memset ( buf , 0 , cluster ) ; for ( i = 0 ; i < grow_maps . ctl -> n_maps ; i ++ ) if ( PWRITE ( & odelta , buf , cluster , ( off_t ) ( grow_maps . zblks [ i ] ) * cluster ) ) { ret = SYSEXIT_WRITE ; goto done ; } vh = ( struct ploop_pvd_header * ) buf ; generate_pvd_header ( vh , src_size , odelta . blocksize , odelta . version ) ; if ( PREAD ( & odelta , & vh -> m_Flags , sizeof ( vh -> m_Flags ) , offsetof ( struct ploop_pvd_header , m_Flags ) ) ) { ret = SYSEXIT_READ ; goto done ; } if ( PWRITE ( & odelta , vh , sizeof ( * vh ) , 0 ) ) { ret = SYSEXIT_WRITE ; goto done ; } if ( fsync ( odelta . fd ) ) { ploop_err ( errno , "fsync" ) ; ret = SYSEXIT_FSYNC ; } done : free ( buf ) ; free ( src_image ) ; free ( dst_image ) ; close_delta ( & odelta ) ; return ret ; } | <S2SV_ModStart> odelta = { . fd = - 1 |
5,272 | CWE-000 IsValidCases isValidMove ( ChessBoard * board , DetailedMove * move ) { GamePiece * piece = board -> boardData [ move -> fromCell . row ] [ move -> fromCell . column ] ; if ( piece == NULL ) { return IlegalMove ; } else { bool isWhite = piece -> isWhite ; if ( is_check ( board , isWhite ) ) { ChessBoard * newBoard = copy_board ( board ) ; make_move_on_board ( newBoard , piece , & move -> fromCell ) ; if ( is_check ( newBoard , true ) ) { return CheckAndCheckAfterwards ; } free_chess_board ( newBoard ) ; } else { ChessBoard * newBoard = copy_board ( board ) ; make_move_on_board ( newBoard , piece , & move -> fromCell ) ; if ( is_check ( newBoard , true ) ) { return NewCheck ; } free_chess_board ( newBoard ) ; } <S2SV_StartBug> } <S2SV_EndBug> return ValidMove ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ) ; } List * possibleMoves = _get_posibble_moves ( & move -> fromCell , board ) ; for ( int i = 0 ; i < get_items_count ( possibleMoves ) ; i ++ ) { Move * pMove = get_element ( possibleMoves , i ) ; if ( are_cells_equal ( & pMove -> cell , & move -> fromCell ) ) { free_list ( possibleMoves ) ; <S2SV_ModEnd> return ValidMove ; <S2SV_ModStart> ValidMove ; } } return IlegalMove ; } return ValidMove ; } |
5,273 | CWE-000 int main ( int argc , char * * argv ) { t_graph * graph ; t_all * all ; char * line ; char * * save ; int * * matrix ; int fd ; int i ; i = 0 ; <S2SV_StartBug> fd = open ( "ant_farms_samples/test5" , O_RDONLY ) ; <S2SV_EndBug> save = ( char * * ) malloc ( sizeof ( char * ) * 1000 ) ; while ( get_next_line ( fd , & line ) && * line != 0 ) { save [ i ++ ] = line ; } all = creat_struct ( count_vert ( save ) , count_links ( save ) ) ; fill_all ( all , save ) ; check ( all ) ; graph = creat_graph ( count_vert ( save ) ) ; fill_graph ( graph , all , count_links ( save ) ) ; int * arr = malloc ( sizeof ( int ) * graph -> count_vert ) ; t_node * node_start = find_node ( graph , all -> dest , all -> start ) ; all -> res [ 0 ] = node_start -> begin ; rec_f ( all , graph , node_start ) ; all -> res [ all -> i + 1 ] = NULL ; ft_arr_putstr ( all -> res ) ; close ( fd ) ; } | <S2SV_ModStart> = open ( "ant_farms_samples/test" <S2SV_ModEnd> , O_RDONLY ) |
5,274 | CWE-000 char * dc_semantic_version_string ( char * buffer , int32_t buffer_size , struct semantic_version * semver ) { int res ; if ( buffer == NULL || semver == NULL ) { log_warn ( "%s<S2SV_blank>invoked<S2SV_blank>with<S2SV_blank>NULL<S2SV_blank>pointer(s)<S2SV_blank>(buffer<S2SV_blank>%p,<S2SV_blank>semver:<S2SV_blank>%p)" , __func__ , buffer , semver ) ; return NULL ; } res = snprintf ( buffer , buffer_size , <S2SV_StartBug> "%d.%d.%d" , semver -> sv_major , semver -> sv_minor , semver -> sv_patch ) ; <S2SV_EndBug> if ( res < 0 || res >= buffer_size ) { <S2SV_StartBug> log_warn ( "Insufficient<S2SV_blank>buffer(<S2SV_blank>%p<S2SV_blank>)<S2SV_blank>size(<S2SV_blank>%d<S2SV_blank>)<S2SV_blank>to<S2SV_blank>copy<S2SV_blank>semver<S2SV_blank>(%d.%d.%d)<S2SV_blank>-<S2SV_blank>Res:<S2SV_blank>%d" , <S2SV_EndBug> buffer , buffer_size , semver -> sv_major , semver -> sv_minor , semver -> sv_patch , res ) ; return NULL ; } return buffer ; } | <S2SV_ModStart> , buffer_size , "%u.%u.%u" <S2SV_ModEnd> , semver -> <S2SV_ModStart> { log_warn ( "Insufficient<S2SV_blank>buffer(<S2SV_blank>%p<S2SV_blank>)<S2SV_blank>size(<S2SV_blank>%d<S2SV_blank>)<S2SV_blank>to<S2SV_blank>copy<S2SV_blank>semver<S2SV_blank>(%u.%u.%u)<S2SV_blank>-<S2SV_blank>Res:<S2SV_blank>%d" <S2SV_ModEnd> , buffer , |
5,275 | CWE-000 char * pathfinder ( sev_t * sev ) { char * fpath = NULL , * ev_path = _getenv ( "PATH" , sev ) ; char * * pathlist = NULL ; <S2SV_StartBug> DIR * dp = NULL ; <S2SV_EndBug> dp = opendir ( sev -> p_input [ 0 ] ) ; if ( dp ) { closedir ( dp ) ; sev -> error = 126 ; permdenied ( sev ) ; return ( NULL ) ; } if ( sev -> p_input ) { if ( ! ev_path ) { if ( ! access ( sev -> p_input [ 0 ] , X_OK ) ) return ( sev -> p_input [ 0 ] ) ; if ( ! access ( sev -> p_input [ 0 ] , F_OK ) ) { sev -> error = 126 ; permdenied ( sev ) ; } else { sev -> error = 127 ; filenotfound ( sev ) ; } return ( NULL ) ; } if ( sev -> p_input [ 0 ] [ 0 ] == '/' || sev -> p_input [ 0 ] [ 0 ] == '.' ) { if ( ! access ( sev -> p_input [ 0 ] , X_OK ) ) return ( sev -> p_input [ 0 ] ) ; if ( ! access ( sev -> p_input [ 0 ] , F_OK ) ) { sev -> error = 126 ; permdenied ( sev ) ; } else { sev -> error = 127 ; filenotfound ( sev ) ; } return ( NULL ) ; } pathlist = make_arr_str ( ev_path , COLON , sev ) ; if ( ! pathlist ) return ( NULL ) ; for ( ; * pathlist ; pathlist ++ ) { fpath = _strcat ( * pathlist , FSLASH , & ( sev -> mem ) ) ; fpath = _strcat ( fpath , sev -> p_input [ 0 ] , & ( sev -> mem ) ) ; if ( ! access ( fpath , X_OK ) ) { sev -> error = 0 ; return ( fpath ) ; } if ( ! access ( fpath , F_OK ) ) { sev -> error = 126 ; permdenied ( sev ) ; } else { if ( sev -> error != - 2 ) { sev -> error = 127 ; filenotfound ( sev ) ; } } } } return ( NULL ) ; } | <S2SV_ModStart> dp = NULL ; if ( ! _strcmp ( sev -> p_input [ 0 ] , "." ) ) return ( NULL ) |
5,276 | CWE-000 void spGamePrintBoard ( spGame * game ) { int i , j , x ; int counterI = 0 , counterJ = 0 ; <S2SV_StartBug> for ( i = 0 ; i < 13 ; i ++ ) <S2SV_EndBug> { <S2SV_StartBug> if ( i % 4 == 0 ) { <S2SV_EndBug> printf ( "----------------------------------\\n" ) ; counterI ++ ; continue ; } counterJ = 0 ; for ( j = 0 ; j < 13 ; j ++ ) { <S2SV_StartBug> if ( j % 4 == 0 ) { <S2SV_EndBug> printf ( "|<S2SV_blank>" ) ; <S2SV_StartBug> if ( j == 12 ) { <S2SV_EndBug> printf ( "\\n" ) ; } counterJ ++ ; continue ; } <S2SV_StartBug> x = game -> values [ i - counterI ] [ j - counterJ ] . val ; <S2SV_EndBug> if ( x == 0 ) { printf ( "<S2SV_blank><S2SV_blank><S2SV_blank>" ) ; } else if ( game -> values [ i - counterI ] [ j - counterJ ] . fixed ) { printf ( ".%d<S2SV_blank>" , x ) ; } else { printf ( "<S2SV_blank>%d<S2SV_blank>" , x ) ; } } } } | <S2SV_ModStart> ; i < BOARD_SIZE + 4 <S2SV_ModEnd> ; i ++ <S2SV_ModStart> ( i % ( BLOCK_SIZE + 1 ) == 0 ) { printf ( "----------------------------------\\n" ) ; counterI ++ ; continue ; } counterJ = 0 ; for ( j = 0 ; j < BOARD_SIZE + 4 <S2SV_ModEnd> ; j ++ <S2SV_ModStart> ( j % ( BLOCK_SIZE + 1 ) <S2SV_ModEnd> == 0 ) <S2SV_ModStart> ( j == BOARD_SIZE + 3 <S2SV_ModEnd> ) { printf <S2SV_ModStart> counterJ ] . solvedVal <S2SV_ModEnd> ; if ( |
5,277 | CWE-000 <S2SV_StartBug> void set_motor_right_direction_forward ( ) { <S2SV_EndBug> set_pin_x_clear_pin_y ( MOTOR_RIGHT_F_GPIO , MOTOR_RIGHT_R_GPIO ) ; } | <S2SV_ModStart> ( ) { ESP_LOGD ( TAG , ">><S2SV_blank>setting<S2SV_blank>motor<S2SV_blank>right<S2SV_blank>forward" ) ; |
5,278 | CWE-000 static int lyd_merge_siblings ( struct lyd_node * target , struct lyd_node * source , int options ) { struct lyd_node * trg , * src , * src_backup , * ins ; struct ly_ctx * ctx = target -> schema -> module -> ctx ; while ( target -> prev -> next ) { target = target -> prev ; } LY_TREE_FOR_SAFE ( source , src_backup , src ) { LY_TREE_FOR ( target , trg ) { if ( lyd_merge_node_equal ( trg , src ) ) { switch ( trg -> schema -> nodetype ) { case LYS_LEAF : case LYS_ANYXML : case LYS_ANYDATA : lyd_merge_node_update ( trg , src ) ; break ; case LYS_LEAFLIST : break ; case LYS_LIST : case LYS_CONTAINER : case LYS_NOTIF : case LYS_RPC : case LYS_INPUT : case LYS_OUTPUT : if ( lyd_merge_parent_children ( trg , src -> child , options ) ) { lyd_free_withsiblings ( source ) ; return EXIT_FAILURE ; } break ; default : LOGINT ; lyd_free_withsiblings ( source ) ; return EXIT_FAILURE ; } break ; } else if ( ly_errno ) { <S2SV_StartBug> return EXIT_FAILURE ; <S2SV_EndBug> } } if ( ! trg ) { if ( ctx != src -> schema -> module -> ctx ) { ins = lyd_dup_to_ctx ( src , 1 , ctx ) ; } else { lyd_unlink ( src ) ; if ( src == source ) { source = src_backup ; } ins = src ; } lyd_insert_after ( target -> prev , ins ) ; } } lyd_free_withsiblings ( source ) ; return EXIT_SUCCESS ; } | <S2SV_ModStart> ly_errno ) { lyd_free_withsiblings ( source ) ; |
5,279 | CWE-000 int adam_Insert_SIgnal2Candidate_Time ( call_t * c , sic_signal_t * sic_signal ) { struct nodedata * nodedata = get_node_private_data ( c ) ; adam_error_code_t error_id = ADAM_ERROR_NO_ERROR ; sic_signal_t * p_sic_current = NULL ; if ( NULL == sic_signal ) { error_id = ADAM_ERROR_UNEXPECTED_INPUT ; goto END ; } PRINT_RADIO ( "get_time=%" PRId64 "\\n" , get_time ( ) ) ; PRINT_RADIO ( "c->node=%d,<S2SV_blank>sic_signal->id=%d\\n" , c -> node , sic_signal -> id ) ; PRINT_RADIO ( "sic_signal->clock1=%" PRId64 "\\n" , sic_signal -> clock1 ) ; if ( NULL == nodedata -> sic_signal_time_first ) { nodedata -> sic_signal_time_first = sic_signal ; goto END ; } PRINT_RADIO ( "nodedata->sic_signal_time_first->clock1=%" PRId64 ",<S2SV_blank>nodedata->sic_signal_time_first->id=%d\\n" , nodedata -> sic_signal_time_first -> clock1 , nodedata -> sic_signal_time_first -> id ) ; for ( p_sic_current = nodedata -> sic_signal_time_first ; NULL != p_sic_current ; p_sic_current = p_sic_current -> signal_next_endtime ) { PRINT_RADIO ( "p_sic_current->clock1=%" PRId64 ",<S2SV_blank>p_sic_current->id=%d\\n" , p_sic_current -> clock1 , p_sic_current -> id ) ; if ( p_sic_current -> clock1 > sic_signal -> clock1 ) { sic_signal -> signal_next_endtime = p_sic_current ; sic_signal -> signal_pre_endtime = p_sic_current -> signal_pre_endtime ; <S2SV_StartBug> p_sic_current -> signal_pre_endtime -> signal_next_endtime = sic_signal ; <S2SV_EndBug> p_sic_current -> signal_pre_endtime = sic_signal ; break ; } if ( NULL == p_sic_current -> signal_next_endtime ) { sic_signal -> signal_pre_endtime = p_sic_current ; p_sic_current -> signal_next_endtime = sic_signal ; break ; } } END : if ( NULL != nodedata -> sic_signal_time_first ) { PRINT_RADIO ( "nodedata->sic_signal_time_first->id=%d\\n" , nodedata -> sic_signal_time_first -> id ) ; if ( NULL != nodedata -> sic_signal_time_first -> signal_next_endtime ) { PRINT_RADIO ( "nodedata->sic_signal_time_first->signal_next_endtime->id=%d\\n" , nodedata -> sic_signal_time_first -> signal_next_endtime -> id ) ; } } if ( ADAM_ERROR_NO_ERROR != error_id ) { PRINT_RADIO ( "E:<S2SV_blank>error_id=%d\\n" , error_id ) ; } return error_id ; } | <S2SV_ModStart> -> signal_pre_endtime ; if ( NULL != p_sic_current -> signal_pre_endtime ) { p_sic_current -> signal_pre_endtime -> signal_next_endtime = sic_signal ; } <S2SV_ModEnd> p_sic_current -> signal_pre_endtime |
5,280 | CWE-000 static void * buttonReader ( void * arg ) { uint16_t inputBuffer [ 16 ] ; int fd = open ( "/dev/input/event0" , O_NONBLOCK ) ; int epollFD = epoll_create ( 1 ) ; struct epoll_event readEvent ; readEvent . events = EPOLLIN ; readEvent . data . fd = fd ; epoll_ctl ( epollFD , EPOLL_CTL_ADD , fd , & readEvent ) ; int timeOut = - 1 ; while ( 1 ) { int err = epoll_wait ( epollFD , & readEvent , 1 , timeOut ) ; if ( err == 0 ) { timeOut = - 1 ; DEBUGPRINT ( "ScreenInverter:<S2SV_blank>Light<S2SV_blank>Button<S2SV_blank>action<S2SV_blank>triggered" ) ; if ( lightButtonToggleNightMode ) { setNewState ( ! inversionActive ) ; } if ( lightButtonLaunchCommand ) { <S2SV_StartBug> DEBUGPRINT ( "ScreenInverter:<S2SV_blank>launching<S2SV_blank>script<S2SV_blank>\'%s\'" , lightButtonScript ) ; <S2SV_EndBug> FILE * commandFile = fopen ( lightButtonCommand , "r" ) ; if ( commandFile != NULL ) { fclose ( commandFile ) ; system ( lightButtonCommand ) ; <S2SV_StartBug> } <S2SV_EndBug> } continue ; } if ( err > 0 ) { int bytesRead = read ( fd , & inputBuffer , sizeof ( inputBuffer ) ) ; if ( bytesRead != 16 ) continue ; if ( inputBuffer [ 6 ] == 1 && ( inputBuffer [ 5 ] == 0x5a || inputBuffer [ 5 ] == 0x66 ) ) timeOut = longPressTimeout ; else timeOut = - 1 ; } } return NULL ; } | <S2SV_ModStart> ( "ScreenInverter:<S2SV_blank>launching<S2SV_blank>script<S2SV_blank>\'%s\'" , lightButtonCommand <S2SV_ModEnd> ) ; system <S2SV_ModStart> lightButtonCommand ) ; <S2SV_ModEnd> } continue ; |
5,281 | CWE-000 static void update_dialog ( T3GUI_PLAYER * player ) { ALLEGRO_EVENT my_event ; int n ; <S2SV_StartBug> my_event . user . data4 = ( unsigned long ) player ; <S2SV_EndBug> for ( n = 0 ; player -> dialog [ n ] . proc ; n ++ ) { if ( player -> dialog [ n ] . flags & D_DIRTY ) { player -> dialog [ n ] . flags &= ~ D_DIRTY ; player -> res |= D_REDRAW_ALL ; } } if ( player -> res & D_REDRAW_ANY ) { player -> redraw = true ; } if ( player -> res & D_CLOSE ) { my_event . user . type = T3GUI_EVENT_CLOSE ; if ( player -> obj == - 1 ) { my_event . user . type = T3GUI_EVENT_CANCEL ; } my_event . user . data1 = player -> obj ; my_event . user . data2 = 0 ; if ( player -> obj >= 0 ) { my_event . user . data2 = ( intptr_t ) & player -> dialog [ player -> obj ] ; } al_emit_user_event ( & player -> event_src , & my_event , t3gui_event_destructor ) ; if ( player -> user_queue ) { al_emit_user_event ( t3gui_get_event_source ( ) , & my_event , t3gui_event_destructor ) ; } t3gui_close_dialog_by_element ( player -> dialog ) ; } player -> res &= ~ D_USED_CHAR ; } | <S2SV_ModStart> data4 = ( intptr_t <S2SV_ModEnd> ) player ; |
5,282 | CWE-000 static void gst_mfx_encoder_set_frame_info ( GstMfxEncoder * encoder ) { GstMfxEncoderPrivate * const priv = GST_MFX_ENCODER_GET_PRIVATE ( encoder ) ; if ( ! priv -> shared ) { priv -> params . mfx . FrameInfo . ChromaFormat = MFX_CHROMAFORMAT_YUV420 ; priv -> params . mfx . FrameInfo . CropX = 0 ; priv -> params . mfx . FrameInfo . CropY = 0 ; priv -> params . mfx . FrameInfo . CropW = priv -> info . width ; priv -> params . mfx . FrameInfo . CropH = priv -> info . height ; priv -> params . mfx . FrameInfo . FrameRateExtN = priv -> info . fps_n ; priv -> params . mfx . FrameInfo . FrameRateExtD = priv -> info . fps_d ; priv -> params . mfx . FrameInfo . AspectRatioW = priv -> info . par_n ; priv -> params . mfx . FrameInfo . AspectRatioH = priv -> info . par_d ; <S2SV_StartBug> if ( priv -> plugin_uid && memcmp ( priv -> plugin_uid , & MFX_PLUGINID_HEVCE_HW , <S2SV_EndBug> sizeof ( mfxPluginUID ) ) == 0 ) { priv -> params . mfx . FrameInfo . Width = GST_ROUND_UP_32 ( priv -> info . width ) ; priv -> params . mfx . FrameInfo . Height = GST_ROUND_UP_32 ( priv -> info . height ) ; <S2SV_StartBug> } else { <S2SV_EndBug> priv -> params . mfx . FrameInfo . Width = GST_ROUND_UP_16 ( priv -> info . width ) ; priv -> params . mfx . FrameInfo . Height = ! GST_VIDEO_INFO_IS_INTERLACED ( & priv -> info ) ? GST_ROUND_UP_16 ( priv -> info . height ) : GST_ROUND_UP_32 ( priv -> info . height ) ; } priv -> frame_info = priv -> params . mfx . FrameInfo ; priv -> frame_info . PicStruct = GST_VIDEO_INFO_IS_INTERLACED ( & priv -> info ) ? ( GST_VIDEO_INFO_FLAG_IS_SET ( & priv -> info , GST_VIDEO_FRAME_FLAG_TFF ) ? MFX_PICSTRUCT_FIELD_TFF : MFX_PICSTRUCT_FIELD_BFF ) : MFX_PICSTRUCT_PROGRESSIVE ; priv -> frame_info . FourCC = gst_video_format_to_mfx_fourcc ( GST_VIDEO_INFO_FORMAT ( & priv -> info ) ) ; if ( MFX_FOURCC_P010 == priv -> frame_info . FourCC ) { priv -> frame_info . BitDepthLuma = 10 ; priv -> frame_info . BitDepthChroma = 10 ; } else { priv -> frame_info . BitDepthLuma = 8 ; priv -> frame_info . BitDepthChroma = 8 ; } } else { priv -> params . mfx . FrameInfo = priv -> frame_info ; } priv -> params . mfx . FrameInfo . PicStruct = MFX_PICSTRUCT_PROGRESSIVE ; } | <S2SV_ModStart> . par_d ; <S2SV_ModEnd> priv -> params <S2SV_ModStart> height ) ; <S2SV_ModEnd> priv -> frame_info |
5,283 | CWE-000 static void iov_int_string ( int value , struct iovec * iov , char * buf , size_t bufsz ) { <S2SV_StartBug> static const char * const digit_lookup = "9876543210123456789" + 9 ; <S2SV_EndBug> char * p = & buf [ bufsz ] ; int negative = value < 0 ; do { -- p ; * p = lookup [ value % 10 ] ; value /= 10 ; } while ( value != 0 ) ; if ( negative ) * -- p = '-' ; iov -> iov_base = p ; iov -> iov_len = & buf [ bufsz ] - p ; } | <S2SV_ModStart> char * const lookup <S2SV_ModEnd> = "9876543210123456789" + |
5,284 | CWE-000 int writeMP4 ( const unsigned char * pData , int size , int type ) { MP4FileHandle hMp4File ; if ( mp4File == NULL ) { return - 1 ; } if ( pData == NULL ) { return - 1 ; } hMp4File = mp4File ; <S2SV_StartBug> if ( type == 0x07 ) { <S2SV_EndBug> m_videoId = MP4AddH264VideoTrack ( hMp4File , 90000 , 90000 / 25 , <S2SV_StartBug> 1280 , 720 , pData [ 5 ] , pData [ 6 ] , pData [ 7 ] , 3 ) ; <S2SV_EndBug> if ( m_videoId == MP4_INVALID_TRACK_ID ) { printf ( "add<S2SV_blank>video<S2SV_blank>track<S2SV_blank>failed.\\n" ) ; return - 1 ; } MP4SetVideoProfileLevel ( hMp4File , 1 ) ; <S2SV_StartBug> MP4AddH264SequenceParameterSet ( hMp4File , m_videoId , pData + 4 , size - 4 ) ; <S2SV_EndBug> } else if ( type == 0x08 ) { <S2SV_StartBug> MP4AddH264PictureParameterSet ( hMp4File , m_videoId , pData + 4 , size - 4 ) ; <S2SV_EndBug> } else if ( type == 0x06 || type == 0x05 || type == 0x01 ) { <S2SV_StartBug> * ( ( unsigned int * ) pData ) = htonl ( size - 4 ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ! MP4WriteSample ( hMp4File , m_videoId , pData , size , MP4_INVALID_DURATION , 0 , 1 ) ) { <S2SV_EndBug> return - 1 ; } } else { printf ( "unknown<S2SV_blank>type<S2SV_blank>=<S2SV_blank>%d\\n" , type ) ; } return 0 ; } | <S2SV_ModStart> = mp4File ; memcpy ( mp4Buf , pData , size ) ; <S2SV_ModStart> , 720 , mp4Buf <S2SV_ModEnd> [ 5 ] <S2SV_ModStart> 5 ] , mp4Buf <S2SV_ModEnd> [ 6 ] <S2SV_ModStart> 6 ] , mp4Buf <S2SV_ModEnd> [ 7 ] <S2SV_ModStart> , m_videoId , mp4Buf <S2SV_ModEnd> + 4 , <S2SV_ModStart> , m_videoId , mp4Buf <S2SV_ModEnd> + 4 , <S2SV_ModStart> int * ) mp4Buf <S2SV_ModEnd> ) = htonl <S2SV_ModStart> , m_videoId , mp4Buf <S2SV_ModEnd> , size , |
5,285 | CWE-000 uint8_t calibrateDistanceOffset ( VL53L0X_Dev_t * device , VL53L0X_Error * status , uint16_t referenceDistanceMM , int32_t * pOffsetMicroMeter ) { <S2SV_StartBug> if ( VL53L0X_PerformOffsetCalibration ( device , referenceDistanceMM , pOffsetMicroMeter ) != VL53L0X_ERROR_NONE ) return 1 ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> ( device , ( uint32_t ) referenceDistanceMM << 16 <S2SV_ModEnd> , pOffsetMicroMeter ) |
5,286 | CWE-000 void oz_timer_add ( struct oz_pd * pd , int type , unsigned long due_time ) { spin_lock_bh ( & g_polling_lock ) ; switch ( type ) { case OZ_TIMER_TOUT : case OZ_TIMER_STOP : <S2SV_StartBug> if ( hrtimer_active ( & pd -> timeout ) ) { <S2SV_EndBug> hrtimer_set_expires ( & pd -> timeout , ktime_set ( due_time / MSEC_PER_SEC , ( due_time % MSEC_PER_SEC ) * NSEC_PER_MSEC ) ) ; hrtimer_start_expires ( & pd -> timeout , HRTIMER_MODE_REL ) ; } else { hrtimer_start ( & pd -> timeout , ktime_set ( due_time / MSEC_PER_SEC , ( due_time % MSEC_PER_SEC ) * NSEC_PER_MSEC ) , HRTIMER_MODE_REL ) ; } pd -> timeout_type = type ; break ; case OZ_TIMER_HEARTBEAT : if ( ! hrtimer_active ( & pd -> heartbeat ) ) hrtimer_start ( & pd -> heartbeat , ktime_set ( due_time / MSEC_PER_SEC , ( due_time % MSEC_PER_SEC ) * NSEC_PER_MSEC ) , HRTIMER_MODE_REL ) ; break ; } spin_unlock_bh ( & g_polling_lock ) ; } | <S2SV_ModStart> ) ) { hrtimer_cancel ( & pd -> timeout ) ; |
5,287 | CWE-000 void drm_helper_mode_fill_fb_struct ( struct drm_device * dev , struct drm_framebuffer * fb , const struct drm_mode_fb_cmd2 * mode_cmd ) { const struct drm_format_info * info ; int i ; info = drm_format_info ( mode_cmd -> pixel_format ) ; if ( ! info || ! info -> depth ) { struct drm_format_name_buf format_name ; DRM_DEBUG_KMS ( "non-RGB<S2SV_blank>pixel<S2SV_blank>format<S2SV_blank>%s\\n" , drm_get_format_name ( mode_cmd -> pixel_format , & format_name ) ) ; } else { } fb -> dev = dev ; fb -> format = info ; fb -> width = mode_cmd -> width ; fb -> height = mode_cmd -> height ; for ( i = 0 ; i < 4 ; i ++ ) { fb -> pitches [ i ] = mode_cmd -> pitches [ i ] ; fb -> offsets [ i ] = mode_cmd -> offsets [ i ] ; } fb -> modifier = mode_cmd -> modifier [ 0 ] ; <S2SV_StartBug> fb -> pixel_format = mode_cmd -> pixel_format ; <S2SV_EndBug> fb -> flags = mode_cmd -> flags ; } | <S2SV_ModStart> ; fb -> <S2SV_ModEnd> flags = mode_cmd |
5,288 | CWE-000 static celix_status_t pubsub_topicPublicationGetService ( void * handle , bundle_pt bundle , service_registration_pt registration , void * * service ) { celix_status_t status = CELIX_SUCCESS ; topic_publication_pt publish = ( topic_publication_pt ) handle ; celixThreadMutex_lock ( & ( publish -> tp_lock ) ) ; publish_bundle_bound_service_pt bound = ( publish_bundle_bound_service_pt ) hashMap_get ( publish -> boundServices , bundle ) ; if ( bound == NULL ) { bound = pubsub_createPublishBundleBoundService ( publish , bundle ) ; if ( bound != NULL ) { hashMap_put ( publish -> boundServices , bundle , bound ) ; } } else { bound -> getCount ++ ; } <S2SV_StartBug> * service = bound -> service ; <S2SV_EndBug> celixThreadMutex_unlock ( & ( publish -> tp_lock ) ) ; return status ; } | <S2SV_ModStart> ++ ; } if ( bound != NULL ) { <S2SV_ModStart> -> service ; } |
5,289 | CWE-000 <S2SV_StartBug> gboolean oregano_schedule_error ( gchar * msg ) { oregano_error_with_title ( msg , NULL ) ; return FALSE ; } <S2SV_EndBug> | <S2SV_ModStart> ) ; return G_SOURCE_REMOVE <S2SV_ModEnd> ; } <S2SV_null> |
5,290 | CWE-000 static ssize_t _debug_stats_read ( struct file * file , char __user * buf , size_t count , loff_t * ppos ) { int rc = - EINVAL ; int len ; len = _disp_stats ( ) ; <S2SV_StartBug> rc = simple_read_from_buffer ( ( void __user * ) buf , len , <S2SV_EndBug> ppos , ( void * ) _debug_read_buf , len ) ; return rc ; } | <S2SV_ModStart> ( ) ; if ( len <= count ) |
5,291 | CWE-000 void insertion_sort ( int * arr , int arr_size ) { <S2SV_StartBug> int i , key , j ; <S2SV_EndBug> for ( i = 1 ; i < arr_size ; i ++ ) { <S2SV_StartBug> key = arr [ i ] ; <S2SV_EndBug> j = i - 1 ; while ( j >= 0 && arr [ j ] > key ) { arr [ j + 1 ] = arr [ j ] ; j -- ; } arr [ j + 1 ] = key ; } } | <S2SV_ModStart> { int i <S2SV_ModEnd> , j ; <S2SV_ModStart> ++ ) { int |
5,292 | CWE-000 PRIVATE void Accept ( int ExpectedToken ) { if ( CurrentToken . code != ExpectedToken ) { <S2SV_StartBug> SyntaxError ( ExpectedToken , CurrentToken ) ; <S2SV_EndBug> ReadToEndOfFile ( ) ; fclose ( InputFile ) ; <S2SV_StartBug> fclose ( ListFile ) ; <S2SV_EndBug> exit ( EXIT_FAILURE ) ; } else CurrentToken = GetToken ( ) ; } | <S2SV_ModStart> ExpectedToken ) { <S2SV_ModEnd> ReadToEndOfFile ( ) <S2SV_ModStart> fclose ( ListFile ) ; printf ( "<S2SV_blank>syntax<S2SV_blank>error\\n" |
5,293 | CWE-000 BootloaderHandleMessageResponse get_frame_duration ( const GetFrameDuration * data , GetFrameDuration_Response * response ) { response -> header . length = sizeof ( GetFrameDuration_Response ) ; <S2SV_StartBug> return HANDLE_MESSAGE_RESPONSE_NEW_MESSAGE ; <S2SV_EndBug> } | <S2SV_ModStart> GetFrameDuration_Response ) ; response -> frame_duration = dmx . frame_duration ; |
5,294 | CWE-000 int main ( int argc , const char * * argv ) { char * target_ip = NULL ; <S2SV_StartBug> uint16_t target_port = 0 ; <S2SV_EndBug> uint16_t listen_port = 0 ; uint32_t timeout = 0 ; struct argparse_option options [ ] = { OPT_HELP ( ) , OPT_GROUP ( "Bridge<S2SV_blank>Target<S2SV_blank>Options" ) , OPT_STRING ( 'i' , "ip" , & target_ip , "Bridge<S2SV_blank>target<S2SV_blank>ip" , NULL , 0 , 0 ) , OPT_INTEGER ( 'p' , "port" , & target_port , "Bridge<S2SV_blank>target<S2SV_blank>port" , NULL , 0 , 0 ) , OPT_GROUP ( "Server<S2SV_blank>Options" ) , OPT_INTEGER ( 'l' , "listen" , & listen_port , "Listen<S2SV_blank>port" , NULL , 0 , 0 ) , OPT_GROUP ( "General<S2SV_blank>Options" ) , OPT_INTEGER ( 't' , "tcp-user-timeout" , & timeout , "Linux<S2SV_blank>only<S2SV_blank>feature.<S2SV_blank>tcp<S2SV_blank>user<S2SV_blank>timeout" , NULL , 0 , 0 ) , OPT_END ( ) , } ; struct argparse argparse ; argparse_init ( & argparse , options , usage , 0 ) ; argparse_describe ( & argparse , "\\nTODO:<S2SV_blank>write<S2SV_blank>description" , "\\nTODO:<S2SV_blank>Write<S2SV_blank>additional<S2SV_blank>info<S2SV_blank>here" ) ; argc = argparse_parse ( & argparse , argc , argv ) ; <S2SV_StartBug> chif_net_startup ( ) ; <S2SV_EndBug> const uint16_t dlisten_port = 1337 ; const char * dtarget_ip = "192.168.208.128" ; const uint16_t dtarget_port = 1337 ; printf ( "~<S2SV_blank>bridge<S2SV_blank>~\\n\\n~<S2SV_blank>options<S2SV_blank>~\\n" ) ; printf ( "bridging<S2SV_blank>to<S2SV_blank>%s:%d\\n" , target_ip != NULL ? target_ip : dtarget_ip , target_port != 0 ? target_port : dtarget_port ) ; printf ( "listening<S2SV_blank>on<S2SV_blank>port<S2SV_blank>%d\\n" , listen_port != 0 ? listen_port : dlisten_port ) ; if ( timeout != 0 ) printf ( "tcp_user_timeout:<S2SV_blank>%d\\n" , timeout ) ; struct bridge_options bridge_opt = { . target_ip = target_ip != NULL ? target_ip : dtarget_ip , . target_port = target_port != 0 ? target_port : dtarget_port , . listen_port = listen_port != 0 ? listen_port : dlisten_port , . tcp_user_timeout = timeout } ; connection_server ( & bridge_opt ) ; printf ( "~<S2SV_blank>shutting<S2SV_blank>down<S2SV_blank>~\\n" ) ; chif_net_shutdown ( ) ; return 0 ; } | <S2SV_ModStart> = NULL ; uint32_t target_port = 0 ; uint32_t <S2SV_ModEnd> listen_port = 0 <S2SV_ModStart> argv ) ; if ( target_port > USHRT_MAX ) { fprintf ( stderr , "attempted<S2SV_blank>to<S2SV_blank>set<S2SV_blank>--port=%d,<S2SV_blank>but<S2SV_blank>maximum<S2SV_blank>port<S2SV_blank>value<S2SV_blank>is<S2SV_blank>%d\\n" , target_port , USHRT_MAX ) ; exit ( 1 ) ; } if ( listen_port > USHRT_MAX ) { fprintf ( stderr , "attempted<S2SV_blank>to<S2SV_blank>set<S2SV_blank>--listen=%d,<S2SV_blank>but<S2SV_blank>maximum<S2SV_blank>port<S2SV_blank>value<S2SV_blank>is<S2SV_blank>%d\\n" , listen_port , USHRT_MAX ) ; exit ( 1 ) ; } |
5,295 | CWE-000 static netdev_tx_t loopback_xmit ( struct sk_buff * skb , struct net_device * dev ) { struct pcpu_lstats * lb_stats ; int len ; <S2SV_StartBug> skb_orphan ( skb ) ; <S2SV_EndBug> skb -> protocol = eth_type_trans ( skb , dev ) ; lb_stats = this_cpu_ptr ( dev -> lstats ) ; len = skb -> len ; if ( likely ( netif_rx ( skb ) == NET_RX_SUCCESS ) ) { u64_stats_update_begin ( & lb_stats -> syncp ) ; lb_stats -> bytes += len ; lb_stats -> packets ++ ; u64_stats_update_end ( & lb_stats -> syncp ) ; } return NETDEV_TX_OK ; } | <S2SV_ModStart> len ; skb_orphan ( skb ) ; skb_dst_force |
5,296 | CWE-000 static int ocsp_status_request_callback ( SSL * ssl , void * arg ) { struct tls_endpoint_config_t * config = ( struct tls_endpoint_config_t * ) arg ; <S2SV_StartBug> if ( config -> ocsp_responder . cert && config -> ocsp_responder . key ) { <S2SV_EndBug> OCSP_RESPONSE * response = create_ocsp_response ( config -> cert , config -> ocsp_responder . cert , config -> ocsp_responder . key ) ; if ( response ) { uint8_t * serialized_ticket ; int serialized_ticket_length ; if ( serialize_ocsp_response ( response , & serialized_ticket , & serialized_ticket_length ) ) { SSL_set_tlsext_status_ocsp_resp ( ssl , serialized_ticket , serialized_ticket_length ) ; } else { logmsg ( LLVL_ERROR , "Failed<S2SV_blank>to<S2SV_blank>serialize<S2SV_blank>OCSP<S2SV_blank>ticket,<S2SV_blank>not<S2SV_blank>adding<S2SV_blank>to<S2SV_blank>SSL<S2SV_blank>connection." ) ; } OCSP_RESPONSE_free ( response ) ; } else { logmsg ( LLVL_DEBUG , "Received<S2SV_blank>status<S2SV_blank>request<S2SV_blank>by<S2SV_blank>client,<S2SV_blank>but<S2SV_blank>could<S2SV_blank>not<S2SV_blank>fake<S2SV_blank>OCSP<S2SV_blank>response." ) ; } <S2SV_StartBug> } else { <S2SV_EndBug> logmsg ( LLVL_DEBUG , "Received<S2SV_blank>status<S2SV_blank>request<S2SV_blank>by<S2SV_blank>client,<S2SV_blank>but<S2SV_blank>no<S2SV_blank>OCSP<S2SV_blank>CA<S2SV_blank>registered<S2SV_blank>in<S2SV_blank>connection." ) ; } return 0 ; } | <S2SV_ModStart> ; if ( ! config -> ocsp_status ) { logmsg ( LLVL_DEBUG , "Received<S2SV_blank>status<S2SV_blank>request<S2SV_blank>by<S2SV_blank>client,<S2SV_blank>but<S2SV_blank>OCSP<S2SV_blank>responses<S2SV_blank>are<S2SV_blank>disabled." ) ; return 0 ; } if ( ! <S2SV_ModStart> ocsp_responder . cert ) { logmsg ( LLVL_DEBUG , "Received<S2SV_blank>status<S2SV_blank>request<S2SV_blank>by<S2SV_blank>client,<S2SV_blank>but<S2SV_blank>OCSP<S2SV_blank>responder<S2SV_blank>certificate<S2SV_blank>in<S2SV_blank>configuration." ) ; return 0 ; } if ( ! <S2SV_ModEnd> config -> ocsp_responder <S2SV_ModStart> key ) { logmsg ( LLVL_DEBUG , "Received<S2SV_blank>status<S2SV_blank>request<S2SV_blank>by<S2SV_blank>client,<S2SV_blank>but<S2SV_blank>OCSP<S2SV_blank>responder<S2SV_blank>key<S2SV_blank>in<S2SV_blank>configuration." ) ; return 0 ; } <S2SV_ModStart> ) ; } <S2SV_ModEnd> return 0 ; |
5,297 | CWE-000 void jw_object_uint64 ( struct json_writer * jw , const char * key , uint64_t value ) { assert_in_object ( jw , key ) ; maybe_add_comma ( jw ) ; append_quoted_string ( & jw -> json , key ) ; <S2SV_StartBug> strbuf_addf ( & jw -> json , ":%" PRIuMAX , value ) ; <S2SV_EndBug> } | <S2SV_ModStart> ":%" PRIuMAX , ( uintmax_t ) |
5,298 | CWE-000 void sprintf_word ( char * pch_word , t_int64 d , int NegZero , int bSetHiPuch ) { int i , n , neg , hi ; if ( d < 0 ) { neg = 1 ; d = - d ; } else if ( ( d == 0 ) && ( NegZero ) ) { neg = 1 ; } else { neg = 0 ; } for ( i = 9 ; i >= 0 ; i -- ) { hi = 0 ; if ( ( i == 1 ) && ( bSetHiPuch == 2 ) ) hi = 1 ; <S2SV_StartBug> if ( ( i == 9 ) && ( bSetHiPuch > 0 ) ) hi = 1 ; <S2SV_EndBug> n = ( int ) ( d % 10 ) ; d = d / 10 ; n = n + hi * 10 ; if ( ( neg == 1 ) && ( i == 9 ) ) n = n + 20 ; pch_word [ i ] = digits_ascii [ n ] ; } pch_word [ 10 ] = 0 ; } | <S2SV_ModStart> > 0 ) && ( neg == 0 ) |
5,299 | CWE-000 Action_info * toggle_flag ( unsigned char x , unsigned char y ) { Action_info * action_info = ( Action_info * ) malloc ( sizeof ( Action_info ) ) ; if ( game_status == GAME_STATUS_NOT_IN_PROGRESS ) { action_info -> error_type = TOGGLE_FLAG_GAME_NOT_IN_PROGRESS ; return action_info ; } if ( game_status > GAME_STATUS_IN_PROGRESS ) { action_info -> error_type = TOGGLE_FLAG_GAME_ALREADY_FINISHED ; return action_info ; } if ( x >= current_width ) { action_info -> error_type = TOGGLE_FLAG_X_COORDINATE_TOO_HIGH ; return action_info ; } if ( y >= current_height ) { action_info -> error_type = TOGGLE_FLAG_Y_COORDINATE_TOO_HIGH ; return action_info ; } unsigned char * position = field_begin + current_width * y + x ; if ( is_revealed ( position ) ) { action_info -> error_type = TOGGLE_FLAG_MUST_BE_UNREVEALED ; return action_info ; } if ( is_flagged ( position ) ) { set_flagged ( position , false ) ; mines_not_flagged ++ ; } else { set_flagged ( position , true ) ; mines_not_flagged -- ; } Copy_node * mbla_head = ( Copy_node * ) malloc ( sizeof ( Copy_node ) ) ; <S2SV_StartBug> * mbla_head = ( Copy_node ) { * position & ~ BITS_SENSITIVE , x , y , NULL } ; <S2SV_EndBug> action_info -> error_type = TOGGLE_FLAG_NO_ERROR ; action_info -> game_status = game_status ; action_info -> mines_not_flagged = mines_not_flagged ; action_info -> mbla_head = mbla_head ; return action_info ; } | <S2SV_ModStart> Copy_node ) { x , y , <S2SV_ModStart> ~ BITS_SENSITIVE , <S2SV_ModEnd> NULL } ; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.