Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
4,900 | CWE-000 void USART2_IRQHandler ( void ) { if ( USART_GetITStatus ( USART2 , USART_IT_RXNE ) != RESET ) { if ( ( gpsReceiveString [ gpsReadIterator ++ ] = USART_ReceiveData ( USART2 ) ) == '\\n' ) { gpsDataUpdated = true ; gpsReadIterator = 0 ; <S2SV_StartBug> } <S2SV_EndBug> } } | <S2SV_ModStart> = 0 ; if ( strncmp ( gpsReceiveString , "$GPVTG" , 6 ) == 0 ) gps_parseGPVTG ( gpsReceiveString , velocityString ) ; |
4,901 | CWE-000 <S2SV_StartBug> int unlock ( int mutexMbox ) <S2SV_EndBug> { int result = MboxReceive ( mutexMbox , NULL , 0 ) ; if ( result == - 3 ) { } } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> void <S2SV_ModEnd> unlock ( int |
4,902 | CWE-000 void printCharArraylist ( Arraylist * arraylist ) { <S2SV_StartBug> for ( int i = 1 ; i <= arraylist -> size ; i ++ ) <S2SV_EndBug> printf ( "the<S2SV_blank>%dth<S2SV_blank>element<S2SV_blank>is<S2SV_blank>%c\\n" , i , * ( ( char * ) getIthElement ( arraylist , i ) ) ) ; } | <S2SV_ModStart> arraylist ) { int i ; for ( <S2SV_ModEnd> i = 1 |
4,903 | CWE-000 int delete_hash_entry ( struct task_struct * p ) { <S2SV_StartBug> if ( remove_fromHash_table ( p ) == - 1 ) return - 1 ; <S2SV_EndBug> kfree ( ( const void * ) p -> hash_entry ) ; p -> hash_entry = NULL ; return 0 ; } | <S2SV_ModStart> p ) { <S2SV_ModEnd> return 0 ; |
4,904 | CWE-000 static mrb_value mrb_zmq_msg_new ( mrb_state * mrb , mrb_value self ) { mrb_value data = mrb_nil_value ( ) ; mrb_get_args ( mrb , "|o" , & data ) ; <S2SV_StartBug> zmq_msg_t * msg = mrb_realloc ( mrb , DATA_PTR ( self ) , sizeof ( zmq_msg_t ) ) ; <S2SV_EndBug> memset ( msg , 0 , sizeof ( * msg ) ) ; mrb_data_init ( self , msg , & mrb_zmq_msg_type ) ; switch ( mrb_type ( data ) ) { case MRB_TT_STRING : { int rc = zmq_msg_init_size ( msg , RSTRING_LEN ( data ) ) ; if ( unlikely ( rc == - 1 ) ) { mrb_zmq_handle_error ( mrb , "zmq_msg_init_size" ) ; } memcpy ( zmq_msg_data ( msg ) , RSTRING_PTR ( data ) , RSTRING_LEN ( data ) ) ; } break ; case MRB_TT_FALSE : { zmq_msg_init ( msg ) ; } break ; default : { mrb_raise ( mrb , E_TYPE_ERROR , "(optionally)<S2SV_blank>expected<S2SV_blank>a<S2SV_blank>String" ) ; } } return self ; } | <S2SV_ModStart> , sizeof ( * msg <S2SV_ModEnd> ) ) ; |
4,905 | CWE-000 static void * hermes_worker_libevent ( void * arg ) { LIBEVENT_THREAD * me = arg ; me -> l = logger_create ( ) ; me -> lru_bump_buf = item_lru_bump_buf_create ( ) ; if ( me -> l == NULL || me -> lru_bump_buf == NULL ) { abort ( ) ; } if ( settings . drop_privileges ) { drop_worker_privileges ( ) ; } hermes_register_thread_initialized ( me ) ; hermes_debug ( "worker<S2SV_blank>thread<S2SV_blank>has<S2SV_blank>registered<S2SV_blank>itself!\\n" ) ; event_base_loop ( me -> base , 0 ) ; event_base_free ( me -> base ) ; hermes_debug ( "now<S2SV_blank>worker<S2SV_blank>thread<S2SV_blank>will<S2SV_blank>exit!\\n" ) ; <S2SV_StartBug> uthread_exit ( NULL ) ; <S2SV_EndBug> return NULL ; } | <S2SV_ModStart> "now<S2SV_blank>worker<S2SV_blank>thread<S2SV_blank>will<S2SV_blank>exit!\\n" ) ; free ( me ) ; |
4,906 | CWE-000 static void evdtest_event_trash_impl ( evdsptc_event_t * event ) { evdsptc_listelem_t * listelem = ( evdsptc_listelem_t * ) event ; event -> auto_destruct = false ; event -> destructor = evdtest_event_free ; evdsptc_listelem_setdestructor ( listelem , evdtest_event_listelem_free ) ; evdsptc_list_push ( & context . observers_bin , & event -> listelem ) ; <S2SV_StartBug> TRACE ( "evdtest_event<S2SV_blank>%p<S2SV_blank>trashed." , ( void * ) event ) ; <S2SV_EndBug> } | <S2SV_ModStart> listelem ) ; EVDTEST_TRACE <S2SV_ModEnd> ( "evdtest_event<S2SV_blank>%p<S2SV_blank>trashed." , |
4,907 | CWE-000 double SGKObjective ( int _maxNumCanon , int D [ 2 ] [ maxK ] [ _maxNumCanon ] ) { int i , j ; double sum = 0 ; totalCanons = 0 ; for ( i = 0 ; i < maxK ; i ++ ) { int k = _k [ i ] ; if ( k == - 1 ) break ; assert ( _numCanon [ k - 1 ] >= 0 ) ; totalCanons += _numCanon [ k - 1 ] ; for ( j = 0 ; j < _numCanon [ k - 1 ] ; j ++ ) { int m , M ; m = MIN ( D [ 0 ] [ k - 1 ] [ j ] , D [ 1 ] [ k - 1 ] [ j ] ) ; M = MAX ( D [ 0 ] [ k - 1 ] [ j ] , D [ 1 ] [ k - 1 ] [ j ] ) ; if ( M == 0 ) totalCanons -= 1 ; else sum += ( ( double ) m / M ) ; } } assert ( totalCanons > 0 ) ; double returnVal = sum / totalCanons ; <S2SV_StartBug> assert ( returnVal >= 0 ) ; <S2SV_EndBug> return returnVal ; } | <S2SV_ModStart> / totalCanons ; returnVal = 1 - returnVal ; assert ( ( <S2SV_ModEnd> returnVal >= 0 <S2SV_ModStart> returnVal >= 0 ) && ( returnVal <= 1 ) |
4,908 | CWE-000 int mse_start_transmission ( int index , void * buffer , size_t buffer_size , void * priv , int ( * mse_completion ) ( void * priv , int size ) ) { int err = - EINVAL ; struct mse_instance * instance ; struct mse_trans_buffer * buf ; int buf_cnt ; u64 now ; int idx ; <S2SV_StartBug> unsigned long flags ; <S2SV_EndBug> if ( ( index < 0 ) || ( index >= MSE_INSTANCE_MAX ) ) { mse_err ( "invalid<S2SV_blank>argument.<S2SV_blank>index=%d\\n" , index ) ; return err ; } if ( ! buffer ) { mse_err ( "invalid<S2SV_blank>argument.<S2SV_blank>buffer<S2SV_blank>is<S2SV_blank>NULL\\n" ) ; return err ; } if ( ! buffer_size ) { mse_err ( "invalid<S2SV_blank>argument.<S2SV_blank>buffer_size<S2SV_blank>is<S2SV_blank>zero\\n" ) ; return err ; } mse_debug ( "index=%d<S2SV_blank>buffer=%p<S2SV_blank>size=%zu\\n" , index , buffer , buffer_size ) ; spin_lock_irqsave ( & mse -> lock_instance_table , flags ) ; instance = mse -> instance_table [ index ] ; spin_unlock_irqrestore ( & mse -> lock_instance_table , flags ) ; if ( ! instance ) { mse_err ( "operation<S2SV_blank>is<S2SV_blank>not<S2SV_blank>permitted.<S2SV_blank>index=%d\\n" , index ) ; return - EPERM ; } <S2SV_StartBug> write_lock_irqsave ( & instance -> lock_state , flags ) ; <S2SV_EndBug> mse_debug_state ( instance ) ; if ( mse_state_test_nolock ( instance , MSE_STATE_STOPPING ) ) { <S2SV_StartBug> write_unlock_irqrestore ( & instance -> lock_state , flags ) ; <S2SV_EndBug> mse_err ( "instance<S2SV_blank>is<S2SV_blank>busy.<S2SV_blank>index=%d\\n" , index ) ; return - EBUSY ; } if ( ! mse_state_test_nolock ( instance , MSE_STATE_RUNNABLE ) ) { <S2SV_StartBug> write_unlock_irqrestore ( & instance -> lock_state , flags ) ; <S2SV_EndBug> mse_err ( "operation<S2SV_blank>is<S2SV_blank>not<S2SV_blank>permitted.<S2SV_blank>index=%d\\n" , index ) ; return - EPERM ; } <S2SV_StartBug> err = mse_state_change ( instance , MSE_STATE_EXECUTE ) ; <S2SV_EndBug> write_unlock_irqrestore ( & instance -> lock_state , flags ) ; if ( ! err ) { buf_cnt = atomic_read ( & instance -> trans_buf_cnt ) ; <S2SV_StartBug> if ( buf_cnt >= MSE_TRANS_BUF_ACCEPTABLE ) <S2SV_EndBug> <S2SV_StartBug> return - EAGAIN ; <S2SV_EndBug> spin_lock_irqsave ( & instance -> lock_buf_list , flags ) ; idx = instance -> trans_idx ; buf = & instance -> trans_buffer [ idx ] ; buf -> media_buffer = buffer ; buf -> buffer = buffer ; buf -> buffer_size = buffer_size ; buf -> work_length = 0 ; buf -> private_data = priv ; buf -> mse_completion = mse_completion ; if ( instance -> tx && IS_MSE_TYPE_MPEG2TS ( instance -> media -> type ) ) { mse_ptp_get_time ( instance -> ptp_index , & now ) ; buf -> launch_avtp_timestamp = ( u32 ) ( now + instance -> max_transit_time_ns ) ; } else { buf -> launch_avtp_timestamp = PTP_TIMESTAMP_INVALID ; } instance -> trans_idx = ( idx + 1 ) % MSE_TRANS_BUF_NUM ; list_add_tail ( & buf -> list , & instance -> trans_buf_list ) ; atomic_inc ( & instance -> trans_buf_cnt ) ; spin_unlock_irqrestore ( & instance -> lock_buf_list , flags ) ; queue_work ( instance -> wq_packet , & instance -> wk_start_trans ) ; } <S2SV_StartBug> return err ; <S2SV_EndBug> } | <S2SV_ModStart> unsigned long flags , flags2 <S2SV_ModStart> -> lock_state , flags2 <S2SV_ModEnd> ) ; mse_debug_state <S2SV_ModStart> -> lock_state , flags2 <S2SV_ModEnd> ) ; mse_err <S2SV_ModStart> -> lock_state , flags2 <S2SV_ModEnd> ) ; mse_err <S2SV_ModStart> instance , MSE_STATE_EXECUTE <S2SV_ModEnd> ) ; if <S2SV_ModStart> >= MSE_TRANS_BUF_ACCEPTABLE ) { write_unlock_irqrestore ( & instance -> lock_state , flags2 ) ; <S2SV_ModStart> - EAGAIN ; } <S2SV_ModStart> ) ; } write_unlock_irqrestore ( & instance -> lock_state , flags2 ) ; |
4,909 | CWE-000 static int link_path_walk ( const char * name , struct nameidata * nd ) { <S2SV_StartBug> int err ; <S2SV_EndBug> int deep = 1 ; while ( * name == '/' ) name ++ ; if ( ! * name ) return 0 ; for ( ; ; ) { u64 hash_len ; int type ; err = may_lookup ( nd ) ; if ( err ) return err ; hash_len = hash_name ( nd -> path . dentry , name ) ; type = LAST_NORM ; if ( name [ 0 ] == '.' ) switch ( hashlen_len ( hash_len ) ) { case 2 : if ( name [ 1 ] == '.' ) { type = LAST_DOTDOT ; nd -> flags |= LOOKUP_JUMPED ; } break ; case 1 : type = LAST_DOT ; } if ( likely ( type == LAST_NORM ) ) { struct dentry * parent = nd -> path . dentry ; nd -> flags &= ~ LOOKUP_JUMPED ; if ( unlikely ( parent -> d_flags & DCACHE_OP_HASH ) ) { struct qstr this = { { . hash_len = hash_len } , . name = name } ; err = parent -> d_op -> d_hash ( parent , & this ) ; if ( err < 0 ) return err ; hash_len = this . hash_len ; name = this . name ; } } nd -> last . hash_len = hash_len ; nd -> last . name = name ; nd -> last_type = type ; name += hashlen_len ( hash_len ) ; if ( ! * name ) goto OK ; do { name ++ ; } while ( unlikely ( * name == '/' ) ) ; if ( unlikely ( ! * name ) ) { OK : if ( ! nd -> depth ) return 0 ; name = nd -> stack [ nd -> depth - 1 ] . name ; if ( ! name ) return 0 ; err = walk_component ( nd , WALK_FOLLOW ) ; } else { err = walk_component ( nd , WALK_FOLLOW | WALK_MORE ) ; } if ( err < 0 ) return err ; if ( err ) { const char * s = get_link ( nd ) ; if ( IS_ERR ( s ) ) return PTR_ERR ( s ) ; err = 0 ; if ( unlikely ( ! s ) ) { put_link ( nd ) ; } else { nd -> stack [ nd -> depth - 1 ] . name = name ; name = s ; continue ; } } if ( unlikely ( ! d_can_lookup ( nd -> path . dentry ) ) ) { if ( nd -> flags & LOOKUP_RCU ) { if ( unlazy_walk ( nd ) ) return - ECHILD ; } return - ENOTDIR ; } } } | <S2SV_ModStart> { int err <S2SV_ModEnd> ; while ( |
4,910 | CWE-000 static int _load_segments_crashed ( struct crypt_device * cd , struct luks2_hdr * hdr , struct luks2_reenc_context * rh ) { int r ; uint64_t data_offset = crypt_get_data_offset ( cd ) << SECTOR_SHIFT ; if ( ! rh ) return - EINVAL ; rh -> jobj_segs_pre = json_object_new_object ( ) ; if ( ! rh -> jobj_segs_pre ) return - ENOMEM ; json_object_object_foreach ( LUKS2_get_segments_jobj ( hdr ) , key , val ) <S2SV_StartBug> json_object_object_add ( rh -> jobj_segs_pre , key , LUKS2_segment_copy ( val ) ) ; <S2SV_EndBug> r = LUKS2_reenc_create_segments_after ( cd , hdr , rh , data_offset ) ; if ( r ) { json_object_put ( rh -> jobj_segs_pre ) ; rh -> jobj_segs_pre = NULL ; } return r ; } | <S2SV_ModStart> , key , json_object_get <S2SV_ModEnd> ( val ) |
4,911 | CWE-000 static void _make_src_file_list ( ) { DIR * dirfile ; struct dirent * entry ; FILE * names ; char path [ PATHLEN + 1 ] ; char * file ; int i ; char * src_dir ; # if ( ANALYZE_HASH == 1 ) struct listitem * item_ptr ; int depth ; hash_collisions = 0 ; # endif if ( settings . autoGenEnable ) AUTOGEN_init ( DIR_get_path ( DIR_DATA ) ) ; if ( fileargc > 0 ) { for ( i = 0 ; i < fileargc ; ++ i ) { file = strdup ( fileargv [ i ] ) ; compress_path ( ( char * ) file ) ; if ( ! infilelist ( file ) ) { <S2SV_StartBug> if ( access ( file , R_OK ) == 0 ) <S2SV_EndBug> DIR_addsrcfile ( file ) ; else fprintf ( stderr , "Cannot<S2SV_blank>find<S2SV_blank>file<S2SV_blank>%s\\n" , file ) ; } free ( file ) ; } return ; } if ( ( settings . nameFile [ 0 ] != 0 ) && ( ! settings . recurseDir ) ) { if ( ( names = fopen ( settings . nameFile , "r" ) ) == NULL ) { my_cannotopen ( namefile ) ; exit ( EXIT_FAILURE ) ; } while ( fscanf ( names , "%s" , path ) == 1 ) { compress_path ( path ) ; if ( infilelist ( path ) == FALSE ) { <S2SV_StartBug> if ( access ( path , R_OK ) == 0 ) <S2SV_EndBug> DIR_addsrcfile ( path ) ; else fprintf ( stderr , "Cannot<S2SV_blank>find<S2SV_blank>file<S2SV_blank>%s\\n" , path ) ; } } ( void ) fclose ( names ) ; return ; } src_dir = DIR_get_path ( DIR_SOURCE ) ; if ( settings . recurseDir ) { if ( settings . searchLogging && ( strlen ( settings . searchLogFile ) > 0 ) ) if ( ( rlogfile = fopen ( settings . searchLogFile , "w" ) ) == NULL ) fprintf ( stderr , "Error:<S2SV_blank>Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>Recursive<S2SV_blank>Search<S2SV_blank>log<S2SV_blank>\'%s\'<S2SV_blank>for<S2SV_blank>writing\\n" , settings . searchLogFile ) ; find_srcfiles_in_tree ( src_dir ) ; if ( ( settings . searchLogging ) && ( rlogfile != NULL ) ) fclose ( rlogfile ) ; } else { if ( ( dirfile = opendir ( src_dir ) ) != NULL ) { while ( ( entry = readdir ( dirfile ) ) != NULL ) { file = entry -> d_name ; if ( entry -> d_ino != 0 && issrcfile ( file ) && infilelist ( file ) == FALSE ) { ( void ) sprintf ( path , "%s/%s" , src_dir , file ) ; compress_path ( path ) ; DIR_addsrcfile ( path ) ; } } closedir ( dirfile ) ; } } # if ( ANALYZE_HASH == 1 ) printf ( "\\n" ) ; for ( i = 0 ; i < HASH_SIZE ; i ++ ) { depth = 0 ; if ( src_names_hash_tbl [ i ] ) { depth ++ ; item_ptr = src_names_hash_tbl [ i ] ; while ( item_ptr ) { item_ptr = item_ptr -> next ; depth ++ ; } } printf ( "%d," , depth ) ; } printf ( "File<S2SV_blank>Count:<S2SV_blank>%d<S2SV_blank><S2SV_blank>Hash<S2SV_blank>Collisions:<S2SV_blank>%d\\n" , nsrcfiles , hash_collisions ) ; # endif } | <S2SV_ModStart> { if ( is_regular_file ( file ) <S2SV_ModEnd> ) DIR_addsrcfile ( <S2SV_ModStart> { if ( is_regular_file ( path ) <S2SV_ModEnd> ) DIR_addsrcfile ( |
4,912 | CWE-000 static auth_result htpasswd_auth ( auth_client * auth_user ) { auth_t * auth = auth_user -> client -> auth ; htpasswd_auth_state * htpasswd = auth -> state ; client_t * client = auth_user -> client ; htpasswd_user entry ; void * result ; if ( client -> username == NULL || client -> password == NULL ) return AUTH_FAILED ; if ( htpasswd -> filename == NULL ) { ICECAST_LOG_ERROR ( "No<S2SV_blank>filename<S2SV_blank>given<S2SV_blank>in<S2SV_blank>options<S2SV_blank>for<S2SV_blank>authenticator." ) ; return AUTH_FAILED ; } htpasswd_recheckfile ( htpasswd ) ; <S2SV_StartBug> thread_rwlock_rlock ( & htpasswd -> file_rwlock ) ; <S2SV_EndBug> entry . name = client -> username ; if ( avl_get_by_key ( htpasswd -> users , & entry , & result ) == 0 ) { htpasswd_user * found = result ; char * hashed_pw ; thread_rwlock_unlock ( & htpasswd -> file_rwlock ) ; hashed_pw = get_hash ( client -> password , strlen ( client -> password ) ) ; if ( strcmp ( found -> pass , hashed_pw ) == 0 ) { free ( hashed_pw ) ; return AUTH_OK ; } free ( hashed_pw ) ; ICECAST_LOG_DEBUG ( "incorrect<S2SV_blank>password<S2SV_blank>for<S2SV_blank>client" ) ; return AUTH_FAILED ; } ICECAST_LOG_DEBUG ( "no<S2SV_blank>such<S2SV_blank>username:<S2SV_blank>%s" , client -> username ) ; thread_rwlock_unlock ( & htpasswd -> file_rwlock ) ; return AUTH_FAILED ; } | <S2SV_ModStart> htpasswd ) ; if ( htpasswd -> users == NULL ) { ICECAST_LOG_ERROR ( "No<S2SV_blank>user<S2SV_blank>list." ) ; return AUTH_FAILED ; } |
4,913 | CWE-000 extern int netlink_send ( struct nl_handler * handler , struct nlmsg * nlmsg ) { struct sockaddr_nl nladdr ; struct iovec iov = { . iov_base = nlmsg -> nlmsghdr , . iov_len = nlmsg -> nlmsghdr -> nlmsg_len , } ; struct msghdr msg = { . msg_name = & nladdr , . msg_namelen = sizeof ( nladdr ) , . msg_iov = & iov , . msg_iovlen = 1 , } ; int ret ; memset ( & nladdr , 0 , sizeof ( nladdr ) ) ; nladdr . nl_family = AF_NETLINK ; nladdr . nl_pid = 0 ; nladdr . nl_groups = 0 ; <S2SV_StartBug> ret = sendmsg ( handler -> fd , & msg , 0 ) ; <S2SV_EndBug> if ( ret < 0 ) return - errno ; return ret ; } | <S2SV_ModStart> & msg , MSG_NOSIGNAL <S2SV_ModEnd> ) ; if |
4,914 | CWE-000 static int choose_service_fd_base ( struct pstree_item * me ) { int nr , real_nr , fdt_nr = 1 , id = rsti ( me ) -> service_fd_id ; if ( rsti ( me ) -> fdt ) { if ( id != 0 ) return service_fd_base ; fdt_nr = rsti ( me ) -> fdt -> nr ; } if ( ! list_empty ( & rsti ( me ) -> fds ) ) nr = list_entry ( rsti ( me ) -> fds . prev , struct fdinfo_list_entry , ps_list ) -> fe -> fd ; else nr = - 1 ; nr = max ( nr , inh_fd_max ) ; nr += ( SERVICE_FD_MAX - SERVICE_FD_MIN ) * fdt_nr ; nr += 16 ; real_nr = nr ; nr /= ( 1024 / sizeof ( void * ) ) ; <S2SV_StartBug> nr = 1 << ( 32 - __builtin_clz ( nr ) ) ; <S2SV_EndBug> nr *= ( 1024 / sizeof ( void * ) ) ; if ( nr > service_fd_rlim_cur ) { nr = round_down ( service_fd_rlim_cur , ( 1024 / sizeof ( void * ) ) ) ; if ( nr < real_nr ) { pr_err ( "Can\'t<S2SV_blank>chose<S2SV_blank>service_fd_base:<S2SV_blank>%d<S2SV_blank>%d\\n" , nr , real_nr ) ; return - 1 ; } } return nr ; } | <S2SV_ModStart> ) ) ; if ( nr ) <S2SV_ModStart> nr ) ) ; else nr = 1 |
4,915 | CWE-000 <S2SV_StartBug> INLINE int get_sprite_xy ( UINT8 num , UINT8 * sx , UINT8 * sy ) <S2SV_EndBug> { int offs = num * 4 ; * sx = spriteram [ offs ] - 1 ; * sy = 240 - spriteram [ offs + 1 ] ; return ( * sy < 240 ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static |
4,916 | CWE-000 void kernel_main ( struct multiboot_info * mi ) { terminal_initialize ( COLOR_WHITE ) ; uint32_t low_pages = 256 ; uint32_t high_pages = ( mi -> mem_upper * 1024 ) / 4096 ; uint32_t total_frames = high_pages + low_pages ; set_vmode ( ) ; set_vesa_color ( make_vesa_color ( 0x8F , 0x8F , 0x8F ) ) ; init_gdt ( ) ; remap_pic ( ) ; init_idt ( ) ; init_timer ( 100 ) ; initialize_keyboard ( ) ; initialize_paging ( total_frames , get_framebuffer_addr ( ) , get_framebuffer_length ( ) ) ; malloc_stats ( ) ; printf ( "Done<S2SV_blank>setting<S2SV_blank>up<S2SV_blank>paging.\\n" ) ; setup_stdin ( ) ; set_vesa_color ( make_vesa_color ( 0xFF , 0xFF , 0xFF ) ) ; printf ( "Kernel<S2SV_blank>is<S2SV_blank>ready<S2SV_blank>to<S2SV_blank>go!!!\\n\\n" ) ; printf ( "Creating<S2SV_blank>fat32<S2SV_blank>filesystem.\\n" ) ; master_fs = makeFilesystem ( "" ) ; if ( master_fs == NULL ) { printf ( "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>fat32<S2SV_blank>filesystem.<S2SV_blank>Disk<S2SV_blank>may<S2SV_blank>be<S2SV_blank>corrupt.\\n" ) ; return ; } printf ( "Finding<S2SV_blank>/foo/bar/baz/boo/dep/doo/poo/goo/tood.txt.\\n" ) ; FILE * f = fopen ( "/foo/bar/baz/boo/dep/doo/poo/goo/tood.txt" , NULL ) ; if ( f ) { # define BCOUNT 1000 uint8_t c [ BCOUNT ] ; printf ( "READING:.................................\\n" ) ; int count , total ; while ( ( count = fread ( & c , BCOUNT , 1 , f ) ) , count > 0 ) { for ( int i = 0 ; i < count ; i ++ ) { printf ( "%c" , c [ i ] ) ; } total += count ; } fclose ( f ) ; printf ( "Read<S2SV_blank>%d<S2SV_blank>bytes.\\n" , total ) ; } else { printf ( "File<S2SV_blank>not<S2SV_blank>found.<S2SV_blank>Continuing.\\n" ) ; } <S2SV_StartBug> printf ( "Starting<S2SV_blank>fat32<S2SV_blank>console.\\n" ) ; <S2SV_EndBug> fat32_console ( master_fs ) ; printf ( "FAT32<S2SV_blank>shell<S2SV_blank>exited.\\n" ) ; printf ( "LISP<S2SV_blank>VM<S2SV_blank>exited.<S2SV_blank>It<S2SV_blank>is<S2SV_blank>safe<S2SV_blank>to<S2SV_blank>power<S2SV_blank>off.\\nSystem<S2SV_blank>is<S2SV_blank>in<S2SV_blank>free-typing<S2SV_blank>mode.\\n" ) ; while ( 1 ) { char c = get_ascii_char ( ) ; printf ( "%c" , c ) ; } ; printf ( "Halting.\\n" ) ; } | <S2SV_ModStart> ) ; } main ( <S2SV_ModEnd> ) ; printf |
4,917 | CWE-000 void qcc_arena_init ( struct qcc_arena * arena , void * buffer , size_t size ) { <S2SV_StartBug> arena -> buffer_start = buffer ; <S2SV_EndBug> arena -> buffer_end = arena -> buffer_start + size ; arena -> free_memory = arena -> buffer_start ; arena -> objects = ( struct qcc_arena_object * ) arena -> buffer_end ; arena -> array_start = 0 ; arena -> array_end = 0 ; } | <S2SV_ModStart> -> buffer_start = ( uint8_t * ) |
4,918 | CWE-000 bool do_deferred_options ( struct context * c , const unsigned int found ) { if ( found & OPT_P_MESSAGES ) { init_verb_mute ( c , IVM_LEVEL_1 | IVM_LEVEL_2 ) ; msg ( D_PUSH , "OPTIONS<S2SV_blank>IMPORT:<S2SV_blank>--verb<S2SV_blank>and/or<S2SV_blank>--mute<S2SV_blank>level<S2SV_blank>changed" ) ; } if ( found & OPT_P_TIMER ) { do_init_timers ( c , true ) ; msg ( D_PUSH , "OPTIONS<S2SV_blank>IMPORT:<S2SV_blank>timers<S2SV_blank>and/or<S2SV_blank>timeouts<S2SV_blank>modified" ) ; } # ifdef ENABLE_OCC if ( found & OPT_P_EXPLICIT_NOTIFY ) { if ( ! proto_is_udp ( c -> options . ce . proto ) && c -> options . ce . explicit_exit_notification ) { msg ( D_PUSH , "OPTIONS<S2SV_blank>IMPORT:<S2SV_blank>--explicit-exit-notify<S2SV_blank>can<S2SV_blank>only<S2SV_blank>be<S2SV_blank>used<S2SV_blank>with<S2SV_blank>--proto<S2SV_blank>udp" ) ; c -> options . ce . explicit_exit_notification = 0 ; } else { msg ( D_PUSH , "OPTIONS<S2SV_blank>IMPORT:<S2SV_blank>explicit<S2SV_blank>notify<S2SV_blank>parm(s)<S2SV_blank>modified" ) ; } } # endif # ifdef USE_COMP if ( found & OPT_P_COMP ) { msg ( D_PUSH , "OPTIONS<S2SV_blank>IMPORT:<S2SV_blank>compression<S2SV_blank>parms<S2SV_blank>modified" ) ; comp_uninit ( c -> c2 . comp_context ) ; c -> c2 . comp_context = comp_init ( & c -> options . comp ) ; } # endif if ( found & OPT_P_SHAPER ) { msg ( D_PUSH , "OPTIONS<S2SV_blank>IMPORT:<S2SV_blank>traffic<S2SV_blank>shaper<S2SV_blank>enabled" ) ; do_init_traffic_shaper ( c ) ; } if ( found & OPT_P_SOCKBUF ) { msg ( D_PUSH , "OPTIONS<S2SV_blank>IMPORT:<S2SV_blank>--sndbuf/--rcvbuf<S2SV_blank>options<S2SV_blank>modified" ) ; link_socket_update_buffer_sizes ( c -> c2 . link_socket , c -> options . rcvbuf , c -> options . sndbuf ) ; } if ( found & OPT_P_SOCKFLAGS ) { msg ( D_PUSH , "OPTIONS<S2SV_blank>IMPORT:<S2SV_blank>--socket-flags<S2SV_blank>option<S2SV_blank>modified" ) ; link_socket_update_flags ( c -> c2 . link_socket , c -> options . sockflags ) ; } if ( found & OPT_P_PERSIST ) { msg ( D_PUSH , "OPTIONS<S2SV_blank>IMPORT:<S2SV_blank>--persist<S2SV_blank>options<S2SV_blank>modified" ) ; } if ( found & OPT_P_UP ) { msg ( D_PUSH , "OPTIONS<S2SV_blank>IMPORT:<S2SV_blank>--ifconfig/up<S2SV_blank>options<S2SV_blank>modified" ) ; } if ( found & OPT_P_ROUTE ) { msg ( D_PUSH , "OPTIONS<S2SV_blank>IMPORT:<S2SV_blank>route<S2SV_blank>options<S2SV_blank>modified" ) ; } if ( found & OPT_P_ROUTE_EXTRAS ) { msg ( D_PUSH , "OPTIONS<S2SV_blank>IMPORT:<S2SV_blank>route-related<S2SV_blank>options<S2SV_blank>modified" ) ; } if ( found & OPT_P_IPWIN32 ) { msg ( D_PUSH , "OPTIONS<S2SV_blank>IMPORT:<S2SV_blank>--ip-win32<S2SV_blank>and/or<S2SV_blank>--dhcp-option<S2SV_blank>options<S2SV_blank>modified" ) ; } if ( found & OPT_P_SETENV ) { msg ( D_PUSH , "OPTIONS<S2SV_blank>IMPORT:<S2SV_blank>environment<S2SV_blank>modified" ) ; } if ( found & OPT_P_PEER_ID ) { msg ( D_PUSH , "OPTIONS<S2SV_blank>IMPORT:<S2SV_blank>peer-id<S2SV_blank>set" ) ; c -> c2 . tls_multi -> use_peer_id = true ; c -> c2 . tls_multi -> peer_id = c -> options . peer_id ; frame_add_to_extra_frame ( & c -> c2 . frame , + 3 ) ; if ( ! c -> options . ce . link_mtu_defined ) { frame_add_to_link_mtu ( & c -> c2 . frame , + 3 ) ; msg ( D_PUSH , "OPTIONS<S2SV_blank>IMPORT:<S2SV_blank>adjusting<S2SV_blank>link_mtu<S2SV_blank>to<S2SV_blank>%d" , EXPANDED_SIZE ( & c -> c2 . frame ) ) ; } else { msg ( M_WARN , "OPTIONS<S2SV_blank>IMPORT:<S2SV_blank>WARNING:<S2SV_blank>peer-id<S2SV_blank>set,<S2SV_blank>but<S2SV_blank>link-mtu" "<S2SV_blank>fixed<S2SV_blank>by<S2SV_blank>config<S2SV_blank>-<S2SV_blank>reducing<S2SV_blank>tun-mtu<S2SV_blank>to<S2SV_blank>%d,<S2SV_blank>expect" "<S2SV_blank>MTU<S2SV_blank>problems" , TUN_MTU_SIZE ( & c -> c2 . frame ) ) ; } } if ( c -> options . pull ) { struct tls_session * session = & c -> c2 . tls_multi -> session [ TM_ACTIVE ] ; if ( found & OPT_P_NCP ) { msg ( D_PUSH , "OPTIONS<S2SV_blank>IMPORT:<S2SV_blank>data<S2SV_blank>channel<S2SV_blank>crypto<S2SV_blank>options<S2SV_blank>modified" ) ; } else if ( c -> options . ncp_enabled ) { tls_poor_mans_ncp ( & c -> options , c -> c2 . tls_multi -> remote_ciphername ) ; } if ( ! session -> key [ KS_PRIMARY ] . crypto_options . key_ctx_bi . initialized <S2SV_StartBug> && ! tls_session_update_crypto_params ( session , & c -> options , & c -> c2 . frame ) ) <S2SV_EndBug> { msg ( D_TLS_ERRORS , "OPTIONS<S2SV_blank>ERROR:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>import<S2SV_blank>crypto<S2SV_blank>options" ) ; return false ; } <S2SV_StartBug> } <S2SV_EndBug> return true ; } | <S2SV_ModStart> c -> options <S2SV_ModEnd> ) ) { <S2SV_ModStart> false ; } adjust_frame_overhead ( & c -> options , & c -> c2 . frame , "Updated<S2SV_blank>Data<S2SV_blank>Channel<S2SV_blank>MTU<S2SV_blank>parms" ) ; # ifdef ENABLE_FRAGMENT if ( c -> options . ce . fragment ) { adjust_frame_overhead ( & c -> options , & c -> c2 . frame_fragment , "Updated<S2SV_blank>Fragmentation<S2SV_blank>MTU<S2SV_blank>parms" ) ; } # endif |
4,919 | CWE-000 static void copy_reverse ( char * buffer , const char * original ) { int i ; for ( i = strlen ( original ) - 1 ; i >= 0 ; i -- ) * ( buffer ++ ) = original [ i ] ; <S2SV_StartBug> buffer = 0 ; <S2SV_EndBug> } | <S2SV_ModStart> i ] ; * |
4,920 | CWE-000 void ktime_get_snapshot ( struct system_time_snapshot * systime_snapshot ) { struct timekeeper * tk = & tk_core . timekeeper ; unsigned long seq ; ktime_t base_raw ; ktime_t base_real ; s64 nsec_raw ; s64 nsec_real ; cycle_t now ; WARN_ON_ONCE ( timekeeping_suspended ) ; do { seq = read_seqcount_begin ( & tk_core . seq ) ; <S2SV_StartBug> now = tk -> tkr_mono . read ( tk -> tkr_mono . clock ) ; <S2SV_EndBug> systime_snapshot -> cs_was_changed_seq = tk -> cs_was_changed_seq ; systime_snapshot -> clock_was_set_seq = tk -> clock_was_set_seq ; base_real = ktime_add ( tk -> tkr_mono . base , tk_core . timekeeper . offs_real ) ; base_raw = tk -> tkr_raw . base ; nsec_real = timekeeping_cycles_to_ns ( & tk -> tkr_mono , now ) ; nsec_raw = timekeeping_cycles_to_ns ( & tk -> tkr_raw , now ) ; } while ( read_seqcount_retry ( & tk_core . seq , seq ) ) ; systime_snapshot -> cycles = now ; systime_snapshot -> real = ktime_add_ns ( base_real , nsec_real ) ; systime_snapshot -> raw = ktime_add_ns ( base_raw , nsec_raw ) ; } | <S2SV_ModStart> ; now = tk_clock_read ( & <S2SV_ModStart> tk -> tkr_mono <S2SV_ModEnd> ) ; systime_snapshot |
4,921 | CWE-000 int send_err ( connection_t * connection_prop , int err , char * descr ) { int sock = connection_prop -> sock ; connection_prop -> status_code = err ; char * head = malloc ( MAXSCRIPTOUT + HEADBUF ) ; if ( head == NULL ) { # ifdef SERVERDBG syslog ( LOG_CRIT , "Not<S2SV_blank>enough<S2SV_blank>memory<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>buffers" ) ; # endif return ERR_NOMEM ; } char * page = head + HEADBUF ; <S2SV_StartBug> int page_len = snprintf ( page , MAXSCRIPTOUT , "%s%s</title>%s\\n<style<S2SV_blank>type=\\"text/css\\">%s</style></head>\\n<body><h4>%s</h4><div<S2SV_blank>class=\\"list\\"><h1>Error<S2SV_blank>%d</h1>%s<S2SV_blank>%s" , HTMLHEAD , weborf_conf . name , weborf_conf . favlink , weborf_conf . css , weborf_conf . name , err , descr , HTMLFOOT ) ; <S2SV_EndBug> <S2SV_StartBug> int head_len = snprintf ( head , HEADBUF , "HTTP/1.1<S2SV_blank>%d<S2SV_blank>%s\\r\\nServer:<S2SV_blank>" SIGNATURE "\\r\\nContent-Length:<S2SV_blank>%d\\r\\nContent-Type:<S2SV_blank>text/html\\r\\n\\r\\n" , err , descr , ( int ) page_len ) ; <S2SV_EndBug> if ( write ( sock , head , head_len ) != head_len ) { free ( head ) ; return ERR_SOCKWRITE ; } if ( write ( sock , page , page_len ) != page_len ) { free ( head ) ; return ERR_SOCKWRITE ; } free ( head ) ; return 0 ; } | <S2SV_ModStart> , MAXSCRIPTOUT , "%s%s</title>%s\\n<style<S2SV_blank>type=\\"text/css\\">%s</style></head>\\n<body><a<S2SV_blank>href=\\"/\\"<S2SV_blank>title=\\"%s\\"><h4>%s</h4></a><div<S2SV_blank>class=\\"list\\"><h1>Error<S2SV_blank>%d</h1>%s<S2SV_blank>%s" <S2SV_ModEnd> , HTMLHEAD , <S2SV_ModStart> , weborf_conf . basedir , weborf_conf . <S2SV_ModStart> HEADBUF , "HTTP/1.1<S2SV_blank>%d<S2SV_blank>%s\\r\\nServer:<S2SV_blank>" PACKAGE_STRING <S2SV_ModEnd> "\\r\\nContent-Length:<S2SV_blank>%d\\r\\nContent-Type:<S2SV_blank>text/html\\r\\n\\r\\n" , err |
4,922 | CWE-000 int intel_uc_fw_upload ( struct intel_uc_fw * uc_fw , int ( * xfer ) ( struct intel_uc_fw * uc_fw , struct i915_vma * vma ) ) { struct i915_vma * vma ; u32 ggtt_pin_bias ; int err ; DRM_DEBUG_DRIVER ( "%s<S2SV_blank>fw<S2SV_blank>load<S2SV_blank>%s\\n" , intel_uc_fw_type_repr ( uc_fw -> type ) , uc_fw -> path ) ; if ( uc_fw -> fetch_status != INTEL_UC_FIRMWARE_SUCCESS ) return - ENOEXEC ; uc_fw -> load_status = INTEL_UC_FIRMWARE_PENDING ; DRM_DEBUG_DRIVER ( "%s<S2SV_blank>fw<S2SV_blank>load<S2SV_blank>%s\\n" , intel_uc_fw_type_repr ( uc_fw -> type ) , intel_uc_fw_status_repr ( uc_fw -> load_status ) ) ; err = i915_gem_object_set_to_gtt_domain ( uc_fw -> obj , false ) ; if ( err ) { DRM_DEBUG_DRIVER ( "%s<S2SV_blank>fw<S2SV_blank>set-domain<S2SV_blank>err=%d\\n" , intel_uc_fw_type_repr ( uc_fw -> type ) , err ) ; goto fail ; } <S2SV_StartBug> ggtt_pin_bias = to_i915 ( uc_fw -> obj -> base . dev ) -> guc . ggtt_pin_bias ; <S2SV_EndBug> vma = i915_gem_object_ggtt_pin ( uc_fw -> obj , NULL , 0 , 0 , PIN_OFFSET_BIAS | ggtt_pin_bias ) ; if ( IS_ERR ( vma ) ) { err = PTR_ERR ( vma ) ; DRM_DEBUG_DRIVER ( "%s<S2SV_blank>fw<S2SV_blank>ggtt-pin<S2SV_blank>err=%d\\n" , intel_uc_fw_type_repr ( uc_fw -> type ) , err ) ; goto fail ; } err = xfer ( uc_fw , vma ) ; i915_vma_unpin ( vma ) ; if ( err ) goto fail ; uc_fw -> load_status = INTEL_UC_FIRMWARE_SUCCESS ; DRM_DEBUG_DRIVER ( "%s<S2SV_blank>fw<S2SV_blank>load<S2SV_blank>%s\\n" , intel_uc_fw_type_repr ( uc_fw -> type ) , intel_uc_fw_status_repr ( uc_fw -> load_status ) ) ; DRM_INFO ( "%s:<S2SV_blank>Loaded<S2SV_blank>firmware<S2SV_blank>%s<S2SV_blank>(version<S2SV_blank>%u.%u)\\n" , intel_uc_fw_type_repr ( uc_fw -> type ) , uc_fw -> path , uc_fw -> major_ver_found , uc_fw -> minor_ver_found ) ; return 0 ; fail : uc_fw -> load_status = INTEL_UC_FIRMWARE_FAIL ; DRM_DEBUG_DRIVER ( "%s<S2SV_blank>fw<S2SV_blank>load<S2SV_blank>%s\\n" , intel_uc_fw_type_repr ( uc_fw -> type ) , intel_uc_fw_status_repr ( uc_fw -> load_status ) ) ; DRM_WARN ( "%s:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>load<S2SV_blank>firmware<S2SV_blank>%s<S2SV_blank>(error<S2SV_blank>%d)\\n" , intel_uc_fw_type_repr ( uc_fw -> type ) , uc_fw -> path , err ) ; return err ; } | <S2SV_ModStart> dev ) -> ggtt . pin_bias <S2SV_ModEnd> ; vma = |
4,923 | CWE-000 void clearpid ( pid_t pid ) { if ( pid != 0 ) { delete ( pid ) ; } else { disable = 1 ; for ( int i = 0 ; i < HASHTABLE_FIRST_NODE_SIZE ; i ++ ) { if ( first_nodes [ i ] != NULL ) { struct respawn_node * node = first_nodes [ i ] ; while ( node -> next != NULL ) { struct respawn_node * tmp = node ; node = node -> next ; nodeunref ( tmp ) ; } nodeunref ( node ) ; first_nodes [ i ] = NULL ; } } <S2SV_StartBug> } <S2SV_EndBug> } | <S2SV_ModStart> ; } } munmap ( respawn , length ) ; |
4,924 | CWE-000 static ssize_t fi_ibv_rdm_eager_recv_got_pkt ( struct fi_ibv_rdm_request * request , void * data ) { FI_IBV_RDM_HNDL_REQ_LOG_IN ( ) ; struct fi_ibv_recv_got_pkt_preprocess_data * p = data ; struct fi_ibv_rdm_buf * rbuf = p -> rbuf ; ssize_t ret ; assert ( request -> state . eager == FI_IBV_STATE_EAGER_RECV_WAIT4PKT ) ; assert ( request -> state . rndv == FI_IBV_STATE_RNDV_NOT_USED ) ; switch ( p -> pkt_type ) { case FI_IBV_RDM_EAGER_PKT : case FI_IBV_RDM_MSG_PKT : { const size_t data_len = p -> arrived_len - sizeof ( rbuf -> header ) ; assert ( data_len <= p -> ep -> rndv_threshold ) ; if ( request -> parent ) { <S2SV_StartBug> fi_ibv_rdm_repost_multi_recv ( request , data_len , p -> ep ) ; <S2SV_EndBug> } if ( request -> len >= data_len ) { request -> minfo . conn = p -> conn ; request -> minfo . tag = rbuf -> header . tag ; request -> minfo . is_tagged = FI_IBV_RDM_EAGER_PKT ? 1 : 0 ; request -> len = data_len ; request -> exp_rbuf = & rbuf -> payload ; request -> imm = p -> imm_data ; if ( request -> dest_buf ) { assert ( request -> exp_rbuf ) ; memcpy ( request -> dest_buf , request -> exp_rbuf , request -> len ) ; } if ( request -> parent ) { <S2SV_StartBug> fi_ibv_rdm_repost_multi_recv ( request , data_len , <S2SV_EndBug> <S2SV_StartBug> p -> ep ) ; <S2SV_EndBug> } fi_ibv_rdm_cntr_inc ( p -> ep -> recv_cntr ) ; if ( request -> comp_flags & FI_COMPLETION ) { request -> state . eager = FI_IBV_STATE_EAGER_READY_TO_FREE ; fi_ibv_rdm_move_to_cq ( p -> ep -> fi_rcq , request ) ; } else { FI_IBV_RDM_DBG_REQUEST ( "to_pool:<S2SV_blank>" , request , FI_LOG_DEBUG ) ; util_buf_release ( fi_ibv_rdm_request_pool , request ) ; } } else { VERBS_INFO ( FI_LOG_EP_DATA , "%s:<S2SV_blank>%d<S2SV_blank>RECV<S2SV_blank>TRUNCATE,<S2SV_blank>data_len=%d,<S2SV_blank>posted_len=%d,<S2SV_blank>" "conn<S2SV_blank>%p,<S2SV_blank>tag<S2SV_blank>0x%llx,<S2SV_blank>tagmask<S2SV_blank>%llx\\n" , __FUNCTION__ , __LINE__ , data_len , request -> len , request -> minfo . conn , request -> minfo . tag , request -> minfo . tagmask ) ; if ( request -> parent ) { <S2SV_StartBug> fi_ibv_rdm_repost_multi_recv ( request , data_len , <S2SV_EndBug> <S2SV_StartBug> p -> ep ) ; <S2SV_EndBug> } request -> state . eager = FI_IBV_STATE_EAGER_READY_TO_FREE ; fi_ibv_rdm_cntr_inc_err ( p -> ep -> recv_cntr ) ; if ( request -> comp_flags & FI_COMPLETION ) { fi_ibv_rdm_move_to_errcq ( p -> ep -> fi_rcq , request , FI_ETRUNC ) ; } } FI_IBV_RDM_HNDL_REQ_LOG ( ) ; break ; } case FI_IBV_RDM_RNDV_RTS_PKT : { struct fi_ibv_rdm_rndv_header * rndv_header = ( void * ) & rbuf -> header ; assert ( p -> arrived_len == sizeof ( * rndv_header ) ) ; if ( request -> len < rndv_header -> total_len ) { request -> state . err = FI_ETRUNC ; } request -> minfo . conn = p -> conn ; request -> minfo . tag = rndv_header -> base . tag ; request -> minfo . is_tagged = rndv_header -> is_tagged ; request -> rndv . remote_addr = ( void * ) rndv_header -> src_addr ; request -> rndv . rkey = rndv_header -> mem_key ; request -> len = rndv_header -> total_len ; request -> rest_len = rndv_header -> total_len ; request -> imm = p -> imm_data ; request -> rndv . id = rndv_header -> id ; if ( request -> parent ) { <S2SV_StartBug> fi_ibv_rdm_repost_multi_recv ( request , <S2SV_EndBug> rndv_header -> total_len , <S2SV_StartBug> p -> ep ) ; <S2SV_EndBug> } ret = fi_ibv_rdm_move_to_postponed_queue ( request ) ; if ( ret ) return ret ; request -> state . eager = FI_IBV_STATE_EAGER_RECV_END ; request -> state . rndv = FI_IBV_STATE_RNDV_RECV_WAIT4RES ; FI_IBV_RDM_HNDL_REQ_LOG ( ) ; break ; } default : VERBS_INFO ( FI_LOG_EP_DATA , "Got<S2SV_blank>unknown<S2SV_blank>unexpected<S2SV_blank>pkt:<S2SV_blank>%" PRIu64 "\\n" , p -> pkt_type ) ; assert ( 0 ) ; FI_IBV_RDM_HNDL_REQ_LOG_OUT ( ) ; return - FI_EOTHER ; } FI_IBV_RDM_HNDL_REQ_LOG_OUT ( ) ; return FI_SUCCESS ; } | <S2SV_ModStart> parent ) { if ( ! <S2SV_ModStart> -> ep ) ) return - FI_ENOMEM <S2SV_ModStart> parent ) { if ( ! <S2SV_ModStart> -> ep ) ) return - FI_ENOMEM <S2SV_ModStart> parent ) { if ( ! <S2SV_ModStart> -> ep ) ) return - FI_ENOMEM <S2SV_ModStart> parent ) { if ( ! <S2SV_ModStart> -> ep ) ) return - FI_ENOMEM |
4,925 | CWE-000 exit_t * proc ( char * input , char * ipname , exit_t * estat ) { <S2SV_StartBug> pid_t child_pid ; <S2SV_EndBug> int status , i ; char * * arrtok , * inputcpy , * cpy2 ; i = _strlen ( input ) , mem_init ( 4 , & inputcpy , i , & cpy2 , i ) ; inputcpy = _strcpy ( input , inputcpy ) , cpy2 = _strcpy ( inputcpy , cpy2 ) ; i = count_tokens ( inputcpy , "<S2SV_blank>" ) , _free ( 1 , inputcpy ) ; mem_init_two ( 2 , & arrtok , i ) ; arrtok = create_arrtok ( cpy2 , arrtok ) , arrtok [ 0 ] = transform_tok ( arrtok [ 0 ] ) ; if ( check_builtins ( arrtok [ 0 ] , cpy2 , arrtok ) ) { estat = change_status ( estat , "Exit" , estat -> code , 1 ) ; return ( estat ) ; } child_pid = fork ( ) ; if ( child_pid == - 1 ) { _free ( 3 , arrtok [ 0 ] , cpy2 , arrtok ) , perror ( "Error:" ) ; return ( estat ) ; } else if ( child_pid == 0 ) { if ( arrtok [ 0 ] == NULL || * ( arrtok [ 0 ] ) == '\\0' ) { _free ( 3 , arrtok [ 0 ] , cpy2 , arrtok ) ; <S2SV_StartBug> return ( estat ) ; <S2SV_EndBug> } if ( execve ( arrtok [ 0 ] , arrtok , environ ) == - 1 ) { _free ( 3 , arrtok [ 0 ] , cpy2 , arrtok ) , perror ( ipname ) ; estat = change_status ( estat , NULL , 127 , 1 ) ; return ( estat ) ; } } else if ( child_pid != 0 ) { wait ( & status ) , _free ( 3 , arrtok [ 0 ] , cpy2 , arrtok ) ; estat = change_status ( estat , NULL , WEXITSTATUS ( status ) , estat -> exit ) ; } return ( estat ) ; } | <S2SV_ModStart> { pid_t child_pid , <S2SV_ModEnd> int status , <S2SV_ModStart> arrtok ) ; estat = change_status ( estat , NULL , estat -> code , 1 ) ; |
4,926 | CWE-000 static void loadconfig_removable_devices ( void ) { char * cat = "Removable<S2SV_blank>devices" ; char temps [ 512 ] ; char temps2 [ 512 ] ; char s [ 512 ] ; int c ; char * p ; wchar_t * wp ; unsigned int board = 0 , dev = 0 ; for ( c = 0 ; c < FDD_NUM ; c ++ ) { sprintf ( temps , "fdd_%02i_type" , c + 1 ) ; p = config_get_string ( cat , temps , ( c < 2 ) ? "525_2dd" : "none" ) ; fdd_set_type ( c , fdd_get_from_internal_name ( p ) ) ; if ( fdd_get_type ( c ) > 13 ) { fdd_set_type ( c , 13 ) ; } sprintf ( temps , "fdd_%02i_fn" , c + 1 ) ; wp = config_get_wstring ( cat , temps , L"" ) ; memcpy ( discfns [ c ] , wp , ( wcslen ( wp ) << 1 ) + 2 ) ; printf ( "Floppy:<S2SV_blank>%ws\\n" , discfns [ c ] ) ; sprintf ( temps , "fdd_%02i_writeprot" , c + 1 ) ; ui_writeprot [ c ] = ! ! config_get_int ( cat , temps , 0 ) ; <S2SV_StartBug> if ( fdd_get_type ( c ) == ( ( c < 2 ) ? 2 : 0 ) ) <S2SV_EndBug> { sprintf ( temps , "fdd_%02i_type" , c + 1 ) ; config_delete_var ( cat , temps ) ; } if ( wcslen ( discfns [ c ] ) == 0 ) { sprintf ( temps , "fdd_%02i_fn" , c + 1 ) ; config_delete_var ( cat , temps ) ; } if ( ui_writeprot [ c ] == 0 ) { sprintf ( temps , "fdd_%02i_writeprot" , c + 1 ) ; config_delete_var ( cat , temps ) ; } <S2SV_StartBug> } <S2SV_EndBug> memset ( temps , 0 , 512 ) ; for ( c = 0 ; c < CDROM_NUM ; c ++ ) { sprintf ( temps , "cdrom_%02i_host_drive" , c + 1 ) ; cdrom_drives [ c ] . host_drive = config_get_int ( cat , temps , 0 ) ; cdrom_drives [ c ] . prev_host_drive = cdrom_drives [ c ] . host_drive ; sprintf ( temps , "cdrom_%02i_parameters" , c + 1 ) ; p = config_get_string ( cat , temps , NULL ) ; if ( p != NULL ) { sscanf ( p , "%u,<S2SV_blank>%s" , & cdrom_drives [ c ] . sound_on , s ) ; } else { sscanf ( "0,<S2SV_blank>none" , "%u,<S2SV_blank>%s" , & cdrom_drives [ c ] . sound_on , s ) ; } cdrom_drives [ c ] . bus_type = config_string_to_bus ( s , 1 ) ; sprintf ( temps , "cdrom_%02i_ide_channel" , c + 1 ) ; if ( ( cdrom_drives [ c ] . bus_type == CDROM_BUS_ATAPI_PIO_ONLY ) || ( cdrom_drives [ c ] . bus_type == CDROM_BUS_ATAPI_PIO_AND_DMA ) ) { sprintf ( temps2 , "%01u:%01u" , ( c + 2 ) >> 1 , ( c + 2 ) & 1 ) ; p = config_get_string ( cat , temps , temps2 ) ; if ( strstr ( p , ":" ) == NULL ) { sscanf ( p , "%i" , & hdc [ c ] . ide_channel ) ; cdrom_drives [ c ] . ide_channel &= 7 ; } else { sscanf ( p , "%02u:%02u" , & board , & dev ) ; board &= 3 ; dev &= 1 ; cdrom_drives [ c ] . ide_channel = ( board << 1 ) + dev ; } if ( cdrom_drives [ c ] . ide_channel > 7 ) { cdrom_drives [ c ] . ide_channel = 7 ; } } else { config_delete_var ( cat , temps ) ; } sprintf ( temps , "cdrom_%02i_scsi_location" , c + 1 ) ; if ( cdrom_drives [ c ] . bus_type == CDROM_BUS_SCSI ) { sprintf ( temps2 , "%02u:%02u" , c + 2 , 0 ) ; p = config_get_string ( cat , temps , temps2 ) ; sscanf ( p , "%02u:%02u" , & cdrom_drives [ c ] . scsi_device_id , & cdrom_drives [ c ] . scsi_device_lun ) ; if ( cdrom_drives [ c ] . scsi_device_id > 15 ) { cdrom_drives [ c ] . scsi_device_id = 15 ; } if ( cdrom_drives [ c ] . scsi_device_lun > 7 ) { cdrom_drives [ c ] . scsi_device_lun = 7 ; } } else { config_delete_var ( cat , temps ) ; } sprintf ( temps , "cdrom_%02i_image_path" , c + 1 ) ; wp = config_get_wstring ( cat , temps , L"" ) ; memcpy ( cdrom_image [ c ] . image_path , wp , ( wcslen ( wp ) << 1 ) + 2 ) ; if ( cdrom_drives [ c ] . host_drive < 'A' ) { cdrom_drives [ c ] . host_drive = 0 ; } if ( ( cdrom_drives [ c ] . host_drive == 0x200 ) && ( wcslen ( cdrom_image [ c ] . image_path ) == 0 ) ) { cdrom_drives [ c ] . host_drive = 0 ; } if ( cdrom_drives [ c ] . bus_type == CDROM_BUS_DISABLED ) { sprintf ( temps , "cdrom_%02i_host_drive" , c + 1 ) ; config_delete_var ( cat , temps ) ; sprintf ( temps , "cdrom_%02i_parameters" , c + 1 ) ; config_delete_var ( cat , temps ) ; sprintf ( temps , "cdrom_%02i_ide_channel" , c + 1 ) ; config_delete_var ( cat , temps ) ; sprintf ( temps , "cdrom_%02i_scsi_location" , c + 1 ) ; config_delete_var ( cat , temps ) ; sprintf ( temps , "cdrom_%02i_image_path" , c + 1 ) ; config_delete_var ( cat , temps ) ; } sprintf ( temps , "cdrom_%02i_iso_path" , c + 1 ) ; config_delete_var ( cat , temps ) ; } } | <S2SV_ModStart> 0 ) ; sprintf ( temps , "fdd_%02i_turbo" , c + 1 ) ; fdd_set_turbo ( c , ! ! config_get_int ( cat , temps , 0 ) ) ; <S2SV_ModStart> ) ; } if ( fdd_get_turbo ( c ) == 0 ) { sprintf ( temps , "fdd_%02i_turbo" , c + 1 ) ; config_delete_var ( cat , temps ) ; } |
4,927 | CWE-000 static int call_func ( const void * data , size_t len , void * user_handle , void * result_handle , xen_result_func result_func ) { ( void ) user_handle ; # ifdef PRINT_XML printf ( "Data<S2SV_blank>to<S2SV_blank>server:\\n%s\\n" , ( ( char * ) data ) ) ; # endif CURL * curl = curl_easy_init ( ) ; if ( ! curl ) return - 1 ; xen_comms comms = { . func = result_func , . handle = result_handle } ; curl_easy_setopt ( curl , CURLOPT_URL , url ) ; curl_easy_setopt ( curl , CURLOPT_NOPROGRESS , 1 ) ; # ifdef CURLOPT_MUTE curl_easy_setopt ( curl , CURLOPT_MUTE , 1 ) ; # endif curl_easy_setopt ( curl , CURLOPT_WRITEFUNCTION , & write_func ) ; curl_easy_setopt ( curl , CURLOPT_WRITEDATA , & comms ) ; curl_easy_setopt ( curl , CURLOPT_POST , 1 ) ; curl_easy_setopt ( curl , CURLOPT_POSTFIELDS , data ) ; curl_easy_setopt ( curl , CURLOPT_POSTFIELDSIZE , len ) ; <S2SV_StartBug> CURLcode result = curl_easy_perform ( curl ) ; <S2SV_EndBug> curl_easy_cleanup ( curl ) ; return result ; } | <S2SV_ModStart> len ) ; curl_easy_setopt ( curl , CURLOPT_SSL_VERIFYPEER , 0 ) ; curl_easy_setopt ( curl , CURLOPT_SSL_VERIFYHOST , 0 ) ; |
4,928 | CWE-000 static ssize_t panel_debug_base_offset_write ( struct file * file , const char __user * user_buf , size_t count , loff_t * ppos ) { struct mdss_debug_base * dbg = file -> private_data ; u32 off = 0 ; u32 cnt = DEFAULT_BASE_REG_CNT ; char buf [ PANEL_RX_MAX_BUF ] = { 0x0 } ; if ( ! dbg ) return - ENODEV ; if ( count >= sizeof ( buf ) ) return - EFAULT ; if ( copy_from_user ( buf , user_buf , count ) ) return - EFAULT ; buf [ count ] = 0 ; if ( sscanf ( buf , "%x<S2SV_blank>%u" , & off , & cnt ) != 2 ) return - EFAULT ; if ( off > dbg -> max_offset ) return - EINVAL ; if ( cnt > ( dbg -> max_offset - off ) ) cnt = dbg -> max_offset - off ; <S2SV_StartBug> mutex_lock ( & mdss_debug_lock ) ; <S2SV_EndBug> dbg -> off = off ; <S2SV_StartBug> dbg -> cnt = cnt ; <S2SV_EndBug> mutex_unlock ( & mdss_debug_lock ) ; pr_debug ( "offset=%x<S2SV_blank>cnt=%x\\n" , off , cnt ) ; return count ; } | <S2SV_ModStart> - off ; <S2SV_ModEnd> dbg -> off <S2SV_ModStart> cnt = cnt <S2SV_ModEnd> ; pr_debug ( |
4,929 | CWE-000 <S2SV_StartBug> int stream_callback ( ms_speech_connection_t connection , unsigned char * buffer , int len ) <S2SV_EndBug> { ssize_t r = read ( wav_fd , buffer , len ) ; return ( int ) r ; } | <S2SV_ModStart> , int len , void * stream_user_data |
4,930 | CWE-000 int get_d_tag ( Elf64_Sxword d_tag , char * buf , size_t size ) { <S2SV_StartBug> char * sni_name ; <S2SV_EndBug> int sni_value = d_tag ; # include "d_tag.sni" strncpy ( buf , sni_name , size ) ; buf [ size - 1 ] = '\\0' ; return 0 ; } | <S2SV_ModStart> char * sni_name = "(error)<S2SV_blank>unknown<S2SV_blank>DT<S2SV_blank>type" ; const Elf64_Sxword <S2SV_ModEnd> sni_value = d_tag |
4,931 | CWE-000 static int ext4_xattr_block_csum_verify ( struct inode * inode , <S2SV_StartBug> sector_t block_nr , <S2SV_EndBug> <S2SV_StartBug> struct ext4_xattr_header * hdr ) <S2SV_EndBug> { <S2SV_StartBug> if ( ext4_has_metadata_csum ( inode -> i_sb ) && <S2SV_EndBug> <S2SV_StartBug> ( hdr -> h_checksum != ext4_xattr_block_csum ( inode , block_nr , hdr ) ) ) <S2SV_EndBug> return 0 ; return 1 ; } | <S2SV_ModStart> * inode , struct buffer_head * bh ) { <S2SV_ModEnd> struct ext4_xattr_header * <S2SV_ModStart> ext4_xattr_header * hdr = BHDR ( bh ) ; int ret = 1 ; <S2SV_ModEnd> if ( ext4_has_metadata_csum <S2SV_ModStart> -> i_sb ) ) { lock_buffer ( bh ) ; ret = <S2SV_ModEnd> ( hdr -> <S2SV_ModStart> hdr -> h_checksum == <S2SV_ModEnd> ext4_xattr_block_csum ( inode <S2SV_ModStart> ( inode , bh -> b_blocknr <S2SV_ModEnd> , hdr ) <S2SV_ModStart> hdr ) ) ; unlock_buffer ( bh ) ; } return ret <S2SV_ModEnd> ; } <S2SV_null> |
4,932 | CWE-000 void rtl92cu_update_hal_rate_table ( struct ieee80211_hw * hw , struct ieee80211_sta * sta , u8 rssi_level ) { struct rtl_priv * rtlpriv = rtl_priv ( hw ) ; struct rtl_phy * rtlphy = & ( rtlpriv -> phy ) ; struct rtl_mac * mac = rtl_mac ( rtl_priv ( hw ) ) ; u32 ratr_value = ( u32 ) mac -> basic_rates ; u8 * mcsrate = mac -> mcs ; u8 ratr_index = 0 ; u8 nmode = mac -> ht_enable ; u8 mimo_ps = 1 ; u16 shortgi_rate = 0 ; u32 tmp_ratr_value = 0 ; u8 curtxbw_40mhz = mac -> bw_40 ; u8 curshortgi_40mhz = mac -> sgi_40 ; u8 curshortgi_20mhz = mac -> sgi_20 ; enum wireless_mode wirelessmode = mac -> mode ; ratr_value |= ( ( * ( u16 * ) ( mcsrate ) ) ) << 12 ; switch ( wirelessmode ) { case WIRELESS_MODE_B : if ( ratr_value & 0x0000000c ) ratr_value &= 0x0000000d ; else ratr_value &= 0x0000000f ; break ; case WIRELESS_MODE_G : ratr_value &= 0x00000FF5 ; break ; case WIRELESS_MODE_N_24G : case WIRELESS_MODE_N_5G : nmode = 1 ; if ( mimo_ps == 0 ) { ratr_value &= 0x0007F005 ; } else { u32 ratr_mask ; if ( get_rf_type ( rtlphy ) == RF_1T2R || get_rf_type ( rtlphy ) == RF_1T1R ) ratr_mask = 0x000ff005 ; else ratr_mask = 0x0f0ff005 ; if ( curtxbw_40mhz ) ratr_mask |= 0x00000010 ; ratr_value &= ratr_mask ; } break ; default : if ( rtlphy -> rf_type == RF_1T2R ) ratr_value &= 0x000ff0ff ; else ratr_value &= 0x0f0ff0ff ; break ; } ratr_value &= 0x0FFFFFFF ; if ( nmode && ( ( curtxbw_40mhz && curshortgi_40mhz ) || ( ! curtxbw_40mhz && curshortgi_20mhz ) ) ) { ratr_value |= 0x10000000 ; tmp_ratr_value = ( ratr_value >> 12 ) ; for ( shortgi_rate = 15 ; shortgi_rate > 0 ; shortgi_rate -- ) { if ( ( 1 << shortgi_rate ) & tmp_ratr_value ) break ; } shortgi_rate = ( shortgi_rate << 12 ) | ( shortgi_rate << 8 ) | ( shortgi_rate << 4 ) | ( shortgi_rate ) ; } rtl_write_dword ( rtlpriv , REG_ARFR0 + ratr_index * 4 , ratr_value ) ; <S2SV_StartBug> RT_TRACE ( rtlpriv , COMP_RATR , DBG_DMESG , "%x\\n" , <S2SV_EndBug> rtl_read_dword ( rtlpriv , REG_ARFR0 ) ) ; } | <S2SV_ModStart> ratr_value ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
4,933 | CWE-000 Policy * PolicyFromJson ( JsonElement * json_policy ) { Policy * policy = PolicyNew ( ) ; <S2SV_StartBug> { <S2SV_EndBug> <S2SV_StartBug> JsonElement * json_bundles = JsonObjectGetAsArray ( json_policy , "bundles" ) ; <S2SV_EndBug> for ( size_t i = 0 ; i < JsonLength ( json_bundles ) ; i ++ ) { JsonElement * json_bundle = JsonArrayGetAsObject ( json_bundles , i ) ; PolicyAppendBundleJson ( policy , json_bundle ) ; } } <S2SV_StartBug> { <S2SV_EndBug> JsonElement * json_bodies = JsonObjectGetAsArray ( json_policy , "bodies" ) ; for ( size_t i = 0 ; i < JsonLength ( json_bodies ) ; i ++ ) { JsonElement * json_body = JsonArrayGetAsObject ( json_bodies , i ) ; PolicyAppendBodyJson ( policy , json_body ) ; } } return policy ; } | <S2SV_ModStart> ( ) ; <S2SV_ModEnd> JsonElement * json_bundles <S2SV_ModStart> "bundles" ) ; JsonElement * json_bodies = JsonObjectGetAsArray ( json_policy , "bodies" ) ; if ( ( json_bundles == NULL ) && ( json_bodies == NULL ) ) { return NULL ; } if ( json_bundles != NULL ) { <S2SV_ModStart> ; } } if ( json_bodies != NULL ) { <S2SV_ModEnd> for ( size_t |
4,934 | CWE-000 void markAndTraceMachineCodeOfMarkedMethods ( void ) { sqInt annotation ; sqInt annotation1 ; CogMethod * cogMethod ; usqInt map ; usqInt map1 ; sqInt mapByte ; sqInt mapByte1 ; <S2SV_StartBug> usqInt mcpc ; <S2SV_EndBug> usqInt mcpc1 ; sqInt result ; sqInt result1 ; sqInt val ; sqInt val1 ; val = 0 ; val1 = 0 ; if ( leakCheckFullGC ( ) ) { asserta ( allMachineCodeObjectReferencesValid ( ) ) ; } codeModified = 0 ; markAndTraceObjectReferencesInGeneratedRuntime ( ) ; cogMethod = ( ( CogMethod * ) methodZoneBase ) ; while ( cogMethod < ( limitZony ( ) ) ) { if ( ( ( ( cogMethod -> cmType ) ) == CMMethod ) && ( isMarked ( ( cogMethod -> methodObject ) ) ) ) { assert ( ( ( ( ( cogMethod -> cmType ) ) == CMMethod ) && ( isMarked ( ( cogMethod -> methodObject ) ) ) ) || ( ( ( ( cogMethod -> cmType ) ) == CMOpenPIC ) && ( ( isImmediate ( ( cogMethod -> selector ) ) ) || ( isMarked ( ( cogMethod -> selector ) ) ) ) ) ) ; markAndTraceLiteralinat ( ( cogMethod -> selector ) , cogMethod , ( & ( ( cogMethod -> selector ) ) ) ) ; maybeMarkCountersIn ( cogMethod ) ; <S2SV_StartBug> markIfIRC ( ( cogMethod -> nextMethodOrIRCs ) ) ; <S2SV_EndBug> mcpc = ( ( ( usqInt ) cogMethod ) ) + cmNoCheckEntryOffset ; map = ( ( ( ( usqInt ) cogMethod ) ) + ( ( cogMethod -> blockSize ) ) ) - 1 ; while ( ( ( mapByte = byteAt ( map ) ) ) != MapEnd ) { if ( mapByte >= FirstAnnotation ) { mcpc += ( mapByte & DisplacementMask ) ; if ( ( ( ( annotation = ( ( usqInt ) mapByte ) >> AnnotationShift ) ) == IsSendCall ) && ( ( ( ( usqInt ) ( ( mapByte = byteAt ( map - 1 ) ) ) ) >> AnnotationShift ) == IsAnnotationExtension ) ) { annotation += mapByte & DisplacementMask ; map -= 1 ; } result = markLiteralspcmethod ( annotation , ( ( ( char * ) mcpc ) ) , ( ( ( sqInt ) cogMethod ) ) ) ; if ( result != 0 ) { goto l2 ; } } else { if ( mapByte < ( ( ( int ) ( ( usqInt ) ( IsAnnotationExtension ) << AnnotationShift ) ) ) ) { mcpc += ( ( ( sqInt ) ( ( usqInt ) ( ( mapByte - DisplacementX2N ) ) << AnnotationShift ) ) ) ; } } map -= 1 ; } l2 : ; } if ( ( ( ( cogMethod -> cmType ) ) == CMOpenPIC ) && ( ( isImmediate ( ( cogMethod -> selector ) ) ) || ( isMarked ( ( cogMethod -> selector ) ) ) ) ) { assert ( ( ( ( ( cogMethod -> cmType ) ) == CMMethod ) && ( isMarked ( ( cogMethod -> methodObject ) ) ) ) || ( ( ( ( cogMethod -> cmType ) ) == CMOpenPIC ) && ( ( isImmediate ( ( cogMethod -> selector ) ) ) || ( isMarked ( ( cogMethod -> selector ) ) ) ) ) ) ; markAndTraceLiteralinat ( ( cogMethod -> selector ) , cogMethod , ( & ( ( cogMethod -> selector ) ) ) ) ; maybeMarkCountersIn ( cogMethod ) ; <S2SV_StartBug> markIfIRC ( ( cogMethod -> nextMethodOrIRCs ) ) ; <S2SV_EndBug> mcpc1 = ( ( ( usqInt ) cogMethod ) ) + cmNoCheckEntryOffset ; map1 = ( ( ( ( usqInt ) cogMethod ) ) + ( ( cogMethod -> blockSize ) ) ) - 1 ; while ( ( ( mapByte1 = byteAt ( map1 ) ) ) != MapEnd ) { if ( mapByte1 >= FirstAnnotation ) { mcpc1 += ( mapByte1 & DisplacementMask ) ; if ( ( ( ( annotation1 = ( ( usqInt ) mapByte1 ) >> AnnotationShift ) ) == IsSendCall ) && ( ( ( ( usqInt ) ( ( mapByte1 = byteAt ( map1 - 1 ) ) ) ) >> AnnotationShift ) == IsAnnotationExtension ) ) { annotation1 += mapByte1 & DisplacementMask ; map1 -= 1 ; } result1 = markLiteralspcmethod ( annotation1 , ( ( ( char * ) mcpc1 ) ) , ( ( ( sqInt ) cogMethod ) ) ) ; if ( result1 != 0 ) { goto l4 ; } } else { if ( mapByte1 < ( ( ( int ) ( ( usqInt ) ( IsAnnotationExtension ) << AnnotationShift ) ) ) ) { mcpc1 += ( ( ( sqInt ) ( ( usqInt ) ( ( mapByte1 - DisplacementX2N ) ) << AnnotationShift ) ) ) ; } } map1 -= 1 ; } l4 : ; } cogMethod = ( ( CogMethod * ) ( roundUpLength ( ( ( ( sqInt ) cogMethod ) ) + ( ( cogMethod -> blockSize ) ) ) ) ) ; } if ( leakCheckFullGC ( ) ) { asserta ( allMachineCodeObjectReferencesValid ( ) ) ; } if ( codeModified ) { flushICacheFromto ( processor , ( ( usqInt ) methodZoneBase ) , ( ( usqInt ) ( limitZony ( ) ) ) ) ; } } | <S2SV_ModStart> mapByte1 ; usqInt maybeIRCs ; usqInt maybeIRCs1 ; usqInt <S2SV_ModStart> cogMethod ) ; maybeIRCs = <S2SV_ModEnd> ( cogMethod -> <S2SV_ModStart> -> nextMethodOrIRCs ) ; if ( oopisGreaterThan ( maybeIRCs , nilObject ( ) ) ) { markAndTrace ( maybeIRCs - BaseHeaderSize ) ; } <S2SV_ModEnd> mcpc = ( <S2SV_ModStart> cogMethod ) ; maybeIRCs1 = <S2SV_ModEnd> ( cogMethod -> <S2SV_ModStart> -> nextMethodOrIRCs ) ; if ( oopisGreaterThan ( maybeIRCs1 , nilObject ( ) ) ) { markAndTrace ( maybeIRCs1 - BaseHeaderSize ) ; } <S2SV_ModEnd> mcpc1 = ( |
4,935 | CWE-000 void determine_phase ( C2CONST * c2const , COMP H [ ] , MODEL * model , int Nfft , codec2_fft_cfg fwd_cfg , codec2_fft_cfg inv_cfg ) { int i , m , b ; int Ns = Nfft / 2 + 1 ; float Gdbfk [ Ns ] , sample_freqs_kHz [ Ns ] , phase [ Ns ] ; float AmdB [ MAX_AMP + 1 ] , rate_L_sample_freqs_kHz [ MAX_AMP + 1 ] ; for ( m = 1 ; m <= model -> L ; m ++ ) { <S2SV_StartBug> AmdB [ m ] = 20.0 * log10 ( model -> A [ m ] ) ; <S2SV_EndBug> rate_L_sample_freqs_kHz [ m ] = ( float ) m * model -> Wo * ( c2const -> Fs / 2000.0 ) / M_PI ; } for ( i = 0 ; i < Ns ; i ++ ) { sample_freqs_kHz [ i ] = ( c2const -> Fs / 1000.0 ) * ( float ) i / Nfft ; } interp_para ( Gdbfk , & rate_L_sample_freqs_kHz [ 1 ] , & AmdB [ 1 ] , model -> L , sample_freqs_kHz , Ns ) ; mag_to_phase ( phase , Gdbfk , Nfft , fwd_cfg , inv_cfg ) ; for ( m = 1 ; m <= model -> L ; m ++ ) { b = floorf ( 0.5 + m * model -> Wo * Nfft / ( 2.0 * M_PI ) ) ; H [ m ] . real = cosf ( phase [ b ] ) ; H [ m ] . imag = sinf ( phase [ b ] ) ; } } | <S2SV_ModStart> = 20.0 * log10f <S2SV_ModEnd> ( model -> <S2SV_ModStart> [ m ] + 1 |
4,936 | CWE-000 void b_behaviour ( ) { msgbuf mex ; shared_data * infoshared = get_shared_data ( ) ; sops . sem_op = - 1 ; semop ( semid , & sops , 1 ) ; for ( int i = 0 ; i < MAX_AGENDA_LEN ; i ++ ) { } sops . sem_op = 1 ; semop ( semid , & sops , 1 ) ; mex . mtype = 333 ; ind_data_cpy ( & ( mex . info ) , & info ) ; <S2SV_StartBug> printf ( "Info<S2SV_blank>in<S2SV_blank>message:%c,<S2SV_blank>%lu,<S2SV_blank>%d\\n" , mex . info . type , mex . info . genome , mex . info . pid ) ; <S2SV_EndBug> fflush ( stdout ) ; <S2SV_StartBug> strcpy ( mex . mtext , "Hey<S2SV_blank>baby<S2SV_blank>i\'m<S2SV_blank>a<S2SV_blank>process<S2SV_blank>B,<S2SV_blank>wanna<S2SV_blank>fuck?" ) ; <S2SV_EndBug> <S2SV_StartBug> msgsnd ( msgid , & mex , MSG_LEN , 0 ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ; printf ( "SENDING***:%c,<S2SV_blank>%lu,<S2SV_blank>%d\\n" <S2SV_ModEnd> , mex . <S2SV_ModStart> . mtext , "***message!***" <S2SV_ModEnd> ) ; msgsnd <S2SV_ModStart> & mex , MSGBUF_LEN <S2SV_ModEnd> , 0 ) <S2SV_ModStart> 0 ) ; TEST_ERROR ; |
4,937 | CWE-000 int target_write_phys_memory ( struct target * target , uint32_t address , uint32_t size , uint32_t count , const uint8_t * buffer ) { if ( ! target_was_examined ( target ) ) { LOG_ERROR ( "Target<S2SV_blank>not<S2SV_blank>examined<S2SV_blank>yet" ) ; return ERROR_FAIL ; } <S2SV_StartBug> return target -> type -> write_phys_memory ( target , address , size , count , buffer ) ; <S2SV_EndBug> } | <S2SV_ModStart> ERROR_FAIL ; } if ( ! target -> type -> write_phys_memory ) { LOG_ERROR ( "Target<S2SV_blank>%s<S2SV_blank>doesn\'t<S2SV_blank>support<S2SV_blank>write_phys_memory" , target_name ( target ) ) ; return ERROR_FAIL ; } |
4,938 | CWE-000 static void isr_rand ( void * arg ) { struct device * device = arg ; <S2SV_StartBug> if ( nrf_rng_event_get ( NRF_RNG_EVENT_VALRDY ) ) { <S2SV_EndBug> struct entropy_nrf5_dev_data * dev_data = DEV_DATA ( device ) ; <S2SV_StartBug> int ret ; <S2SV_EndBug> <S2SV_StartBug> ret = isr ( ( struct rand * ) dev_data -> isr , true ) ; <S2SV_EndBug> if ( ret != - EBUSY ) { ret = isr ( ( struct rand * ) dev_data -> thr , <S2SV_StartBug> ( ret == - ENOBUFS ) ) ; <S2SV_EndBug> k_sem_give ( & dev_data -> sem_sync ) ; } <S2SV_StartBug> nrf_rng_event_clear ( NRF_RNG_EVENT_VALRDY ) ; <S2SV_EndBug> if ( ret != - EBUSY ) { nrf_rng_task_trigger ( NRF_RNG_TASK_STOP ) ; } } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> = arg ; <S2SV_ModEnd> struct entropy_nrf5_dev_data * <S2SV_ModStart> ) ; int byte , ret ; byte = random_byte_get ( ) ; if ( byte < 0 ) { return ; } <S2SV_ModEnd> ret = isr <S2SV_ModStart> isr , true , byte <S2SV_ModStart> - ENOBUFS ) , byte <S2SV_ModStart> ) ; } <S2SV_ModEnd> if ( ret <S2SV_ModStart> ; } } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
4,939 | CWE-000 void sched_get_nr_running_avg ( int * avg , int * iowait_avg ) { int cpu ; u64 curr_time = sched_clock ( ) ; u64 diff = curr_time - last_get_time ; u64 tmp_avg = 0 , tmp_iowait = 0 ; * avg = 0 ; * iowait_avg = 0 ; if ( ! diff ) <S2SV_StartBug> return ; <S2SV_EndBug> for_each_possible_cpu ( cpu ) { unsigned long flags ; spin_lock_irqsave ( & per_cpu ( nr_lock , cpu ) , flags ) ; <S2SV_StartBug> curr_time = sched_clock ( ) ; <S2SV_EndBug> tmp_avg += per_cpu ( nr_prod_sum , cpu ) ; tmp_avg += per_cpu ( nr , cpu ) * ( curr_time - per_cpu ( last_time , cpu ) ) ; <S2SV_StartBug> tmp_big_avg += per_cpu ( nr_big_prod_sum , cpu ) ; <S2SV_EndBug> tmp_big_avg += nr_eligible_big_tasks ( cpu ) * ( curr_time - per_cpu ( last_time , cpu ) ) ; tmp_iowait += per_cpu ( iowait_prod_sum , cpu ) ; tmp_iowait += nr_iowait_cpu ( cpu ) * ( curr_time - per_cpu ( last_time , cpu ) ) ; per_cpu ( last_time , cpu ) = curr_time ; per_cpu ( nr_prod_sum , cpu ) = 0 ; per_cpu ( iowait_prod_sum , cpu ) = 0 ; spin_unlock_irqrestore ( & per_cpu ( nr_lock , cpu ) , flags ) ; } <S2SV_StartBug> diff = curr_time - last_get_time ; <S2SV_EndBug> last_get_time = curr_time ; * avg = ( int ) div64_u64 ( tmp_avg * 100 , diff ) ; * iowait_avg = ( int ) div64_u64 ( tmp_iowait * 100 , diff ) ; <S2SV_StartBug> trace_sched_get_nr_running_avg ( * avg , * big_avg , * iowait_avg ) ; <S2SV_EndBug> <S2SV_StartBug> BUG_ON ( * avg < 0 || * big_avg < 0 || * iowait_avg < 0 ) ; <S2SV_EndBug> <S2SV_StartBug> pr_debug ( "%s<S2SV_blank>-<S2SV_blank>avg:%d<S2SV_blank>big_avg:%d<S2SV_blank>iowait_avg:%d\\n" , <S2SV_EndBug> __func__ , * avg , * big_avg , * iowait_avg ) ; } | <S2SV_ModStart> diff ) return ; last_get_time = curr_time <S2SV_ModStart> flags ) ; <S2SV_ModEnd> tmp_avg += per_cpu <S2SV_ModStart> ) ) ; tmp_iowait = <S2SV_ModEnd> per_cpu ( iowait_prod_sum <S2SV_ModStart> ) ; } <S2SV_ModEnd> * avg = <S2SV_ModStart> diff ) ; <S2SV_ModEnd> BUG_ON ( * <S2SV_ModStart> avg < 0 ) ; pr_debug ( "%s<S2SV_blank>-<S2SV_blank>avg:%d\\n" , __func__ , * avg ) ; BUG_ON ( * iowait_avg < 0 <S2SV_ModEnd> ) ; pr_debug <S2SV_ModStart> ; pr_debug ( "%s<S2SV_blank>-<S2SV_blank>avg:%d\\n" , __func__ <S2SV_ModEnd> , * iowait_avg |
4,940 | CWE-000 static void update_actor_partitions ( hvr_internal_ctx_t * ctx ) { memset ( ctx -> local_partition_lists , 0x00 , sizeof ( hvr_vertex_t * ) * ctx -> n_partitions ) ; memset ( ctx -> mirror_partition_lists , 0x00 , sizeof ( hvr_vertex_t * ) * ctx -> n_partitions ) ; memset ( ctx -> partition_min_dist_from_local_vertex , 0xff , sizeof ( unsigned ) * ctx -> n_partitions ) ; hvr_vertex_iter_t iter ; hvr_vertex_iter_all_init ( & iter , ctx ) ; for ( hvr_vertex_t * curr = hvr_vertex_iter_next ( & iter ) ; curr ; curr = hvr_vertex_iter_next ( & iter ) ) { update_vertex_partitions_for_vertex ( curr , ctx , ctx -> local_partition_lists , 0 ) ; } for ( unsigned i = 0 ; i < HVR_MAP_BUCKETS ; i ++ ) { hvr_map_seg_t * seg = ctx -> vec_cache . cache_map . buckets [ i ] ; while ( seg ) { for ( unsigned j = 0 ; j < seg -> nkeys ; j ++ ) { <S2SV_StartBug> hvr_vertex_cache_node_t * node = seg -> vals [ j ] [ 0 ] . cached_vert ; <S2SV_EndBug> update_vertex_partitions_for_vertex ( & node -> vert , ctx , ctx -> mirror_partition_lists , node -> min_dist_from_local_vertex ) ; } seg = seg -> next ; } } } | <S2SV_ModStart> = seg -> inline_vals <S2SV_ModEnd> [ j ] |
4,941 | CWE-000 static int xf86TslibControlProc ( DeviceIntPtr device , int what ) { InputInfoPtr pInfo ; unsigned char map [ MAXBUTTONS + 1 ] ; Atom labels [ MAXBUTTONS ] ; int i , axiswidth , axisheight ; struct ts_priv * priv ; # ifdef DEBUG <S2SV_StartBug> ErrorF ( "%s\\n" , __FUNCTION__ ) ; <S2SV_EndBug> # endif pInfo = device -> public . devicePrivate ; priv = pInfo -> private ; switch ( what ) { case DEVICE_INIT : device -> public . on = FALSE ; for ( i = 0 ; i < MAXBUTTONS ; i ++ ) { map [ i + 1 ] = i + 1 ; } xf86TslibInitButtonLabels ( labels , MAXBUTTONS ) ; if ( InitButtonClassDeviceStruct ( device , MAXBUTTONS , labels , map ) == FALSE ) { <S2SV_StartBug> ErrorF ( "unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>Button<S2SV_blank>class<S2SV_blank>device\\n" ) ; <S2SV_EndBug> return ! Success ; } if ( InitValuatorClassDeviceStruct ( device , 2 , labels , 0 , Absolute ) == FALSE ) { <S2SV_StartBug> ErrorF ( "unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>Valuator<S2SV_blank>class<S2SV_blank>device\\n" ) ; <S2SV_EndBug> return ! Success ; } switch ( priv -> rotate ) { case TSLIB_ROTATE_CW : case TSLIB_ROTATE_CCW : axiswidth = priv -> height ; axisheight = priv -> width ; break ; default : axiswidth = priv -> width ; axisheight = priv -> height ; break ; } InitValuatorAxisStruct ( device , 0 , XIGetKnownProperty ( AXIS_LABEL_PROP_ABS_X ) , 0 , axiswidth - 1 , axiswidth , 0 , axiswidth # if GET_ABI_MAJOR ( ABI_XINPUT_VERSION ) >= 12 , Absolute # endif ) ; InitValuatorAxisStruct ( device , 1 , XIGetKnownProperty ( AXIS_LABEL_PROP_ABS_Y ) , 0 , axisheight - 1 , axisheight , 0 , axisheight # if GET_ABI_MAJOR ( ABI_XINPUT_VERSION ) >= 12 , Absolute # endif ) ; if ( InitProximityClassDeviceStruct ( device ) == FALSE ) { <S2SV_StartBug> ErrorF ( "Unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>EVTouch<S2SV_blank>touchscreen<S2SV_blank>ProximityClassDeviceStruct\\n" ) ; <S2SV_EndBug> return ! Success ; } if ( ! InitPtrFeedbackClassDeviceStruct ( device , PointerControlProc ) ) return ! Success ; break ; case DEVICE_ON : # if HAVE_THREADED_INPUT xf86AddEnabledDevice ( pInfo ) ; # else AddEnabledDevice ( pInfo -> fd ) ; # endif device -> public . on = TRUE ; break ; case DEVICE_OFF : case DEVICE_CLOSE : # if HAVE_THREADED_INPUT if ( pInfo -> fd != - 1 ) xf86RemoveEnabledDevice ( pInfo ) ; # endif device -> public . on = FALSE ; break ; } return Success ; } | <S2SV_ModStart> # ifdef DEBUG xf86IDrvMsg ( pInfo , X_ERROR , <S2SV_ModEnd> "%s\\n" , __FUNCTION__ <S2SV_ModStart> FALSE ) { xf86IDrvMsg ( pInfo , X_ERROR , <S2SV_ModEnd> "unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>Button<S2SV_blank>class<S2SV_blank>device\\n" ) ; <S2SV_ModStart> FALSE ) { xf86IDrvMsg ( pInfo , X_ERROR , <S2SV_ModEnd> "unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>Valuator<S2SV_blank>class<S2SV_blank>device\\n" ) ; <S2SV_ModStart> FALSE ) { xf86IDrvMsg ( pInfo , X_ERROR , <S2SV_ModEnd> "Unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>EVTouch<S2SV_blank>touchscreen<S2SV_blank>ProximityClassDeviceStruct\\n" ) ; |
4,942 | CWE-000 static int autoget_gpio_init ( void ) { int ret = 0 ; ret = gpio_request ( GPIO_IN_FPESW , "fepe<S2SV_blank>switch" ) ; if ( ret < 0 ) { printk ( KERN_ERR "Failed<S2SV_blank>to<S2SV_blank>request<S2SV_blank>GPIO<S2SV_blank>%d<S2SV_blank>for<S2SV_blank>fepe<S2SV_blank>switch\\n" , GPIO_IN_FPESW ) ; return ret ; } gpio_direction_input ( GPIO_IN_FPESW ) ; ret = gpio_request ( GPIO_IN_BPESW , "fepe<S2SV_blank>switch" ) ; if ( ret < 0 ) { printk ( KERN_ERR "Failed<S2SV_blank>to<S2SV_blank>request<S2SV_blank>GPIO<S2SV_blank>%d<S2SV_blank>for<S2SV_blank>fepe<S2SV_blank>switch\\n" , GPIO_IN_BPESW ) ; return ret ; } gpio_direction_input ( GPIO_IN_BPESW ) ; ret = gpio_request ( GPIO_IN_DSSW , "fepe<S2SV_blank>switch" ) ; if ( ret < 0 ) { printk ( KERN_ERR "Failed<S2SV_blank>to<S2SV_blank>request<S2SV_blank>GPIO<S2SV_blank>%d<S2SV_blank>for<S2SV_blank>fepe<S2SV_blank>switch\\n" , GPIO_IN_DSSW ) ; return ret ; } gpio_direction_input ( GPIO_IN_DSSW ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> GPIO_IN_DSSW ) ; ret = gpio_request ( GPIO_OUT_MOTORST , "moto<S2SV_blank>reset" ) ; if ( ret < 0 ) { printk ( KERN_ERR "Failed<S2SV_blank>to<S2SV_blank>request<S2SV_blank>GPIO<S2SV_blank>%d<S2SV_blank>for<S2SV_blank>moto<S2SV_blank>reset\\n" , GPIO_OUT_MOTORST ) ; return ret ; } gpio_direction_output ( GPIO_OUT_MOTORST , 1 ) ; ret = gpio_request ( GPIO_OUT_MCUNOTIFY , "mcu<S2SV_blank>notify" ) ; if ( ret < 0 ) { printk ( KERN_ERR "Failed<S2SV_blank>to<S2SV_blank>request<S2SV_blank>GPIO<S2SV_blank>%d<S2SV_blank>for<S2SV_blank>mcu<S2SV_blank>notify\\n" , GPIO_OUT_MCUNOTIFY ) ; return ret ; } gpio_direction_output ( GPIO_OUT_MCUNOTIFY , 0 ) ; |
4,943 | CWE-000 void scf ( ) { <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ( ) { flags -> C = 0x1 ; flags -> N = 0x0 ; flags -> H = 0x0 ; |
4,944 | CWE-000 int check_file ( int iosysid , int ntasks , char * filename , int iotype , int elements_per_pe , int my_rank , int ioid ) { int ncid ; int ndims ; int nvars ; int ngatts ; int unlimdimid ; int natts ; nc_type xtype ; int ret ; int dimids [ NDIM3 ] ; char var_name [ NC_MAX_NAME ] ; if ( ( ret = PIOc_openfile_retry ( iosysid , & ncid , & iotype , filename , 0 , 0 ) ) ) return ret ; printf ( "opened<S2SV_blank>file<S2SV_blank>%s<S2SV_blank>ncid<S2SV_blank>=<S2SV_blank>%d\\n" , filename , ncid ) ; if ( ( ret = PIOc_inq ( ncid , & ndims , & nvars , & ngatts , & unlimdimid ) ) ) return ret ; if ( ndims != NDIM3 || nvars != 1 || ngatts != 0 || unlimdimid != 0 ) return ERR_BAD ; for ( int d = 0 ; d < NDIM3 ; d ++ ) { char my_dim_name [ NC_MAX_NAME ] ; PIO_Offset dimlen ; if ( ( ret = PIOc_inq_dim ( ncid , d , my_dim_name , & dimlen ) ) ) return ret ; if ( dimlen != ( d ? dim_len [ d ] : NUM_TIMESTEPS ) || strcmp ( my_dim_name , dim_name [ d ] ) ) return ERR_BAD ; } <S2SV_StartBug> if ( ( ret = PIOc_inq_var ( ncid , 0 , var_name , & xtype , & ndims , dimids , & natts ) ) ) <S2SV_EndBug> return ret ; if ( xtype != NC_INT || ndims != NDIM3 || dimids [ 0 ] != 0 || dimids [ 1 ] != 1 || dimids [ 2 ] != 2 || natts != 0 ) return ERR_BAD ; int buffer [ elements_per_pe ] ; int buffer_in [ elements_per_pe ] ; for ( int t = 0 ; t < NUM_TIMESTEPS ; t ++ ) { int varid = 0 ; for ( int i = 0 ; i < elements_per_pe ; i ++ ) buffer [ i ] = 100 * t + START_DATA_VAL + my_rank ; if ( ( ret = PIOc_setframe ( ncid , varid , t ) ) ) ERR ( ret ) ; if ( ( ret = PIOc_read_darray ( ncid , varid , ioid , elements_per_pe , buffer_in ) ) ) return ret ; for ( int i = 0 ; i < elements_per_pe ; i ++ ) if ( buffer_in [ i ] != buffer [ i ] ) return ERR_BAD ; } if ( ( ret = PIOc_closefile ( ncid ) ) ) return ret ; return 0 ; } | <S2SV_ModStart> 0 , var_name , NC_MAX_NAME |
4,945 | CWE-000 short wima_widget_marginDown ( WimaWidget item ) { assert_init ; <S2SV_StartBug> return wima_widget_ptr ( item ) -> margins [ 3 ] ; <S2SV_EndBug> } | <S2SV_ModStart> item ) -> widget . |
4,946 | CWE-000 void * thread_picam_start ( void * arg ) { ssize_t s , events ; uint64_t u ; struct thread_data * tdata = arg ; struct internal_t_data itdata ; pthread_setcanceltype ( PTHREAD_CANCEL_DEFERRED , NULL ) ; pthread_cleanup_push ( & cleanup_handler , & itdata ) ; memset ( & itdata , 0 , sizeof ( itdata ) ) ; asprintf ( & itdata . dir , PICAM_STATE_DIR ) ; asprintf ( & itdata . picam_start_hook , PICAM_START_HOOK ) ; asprintf ( & itdata . picam_stop_hook , PICAM_STOP_HOOK ) ; itdata . dir_strlen = strlen ( itdata . dir ) ; itdata . is_recording = & tdata -> is_recording ; s = setup_inotify ( & itdata ) ; itdata . watch_state_enabled = ( _Bool ) s >= 0 ; memset ( & itdata . poll_fds , 0 , sizeof ( itdata . poll_fds ) ) ; itdata . poll_fds [ itdata . poll_fds_len ] . fd = itdata . inotify_fd ; itdata . poll_fds [ itdata . poll_fds_len ] . revents = 0 ; itdata . poll_fds [ itdata . poll_fds_len ++ ] . events = events = POLLIN | POLLPRI ; itdata . poll_fds [ itdata . poll_fds_len ] = itdata . poll_fds [ 0 ] ; itdata . poll_fds [ itdata . poll_fds_len ++ ] . fd = tdata -> timerpipe [ 0 ] ; itdata . poll_fds [ itdata . poll_fds_len ] = itdata . poll_fds [ 0 ] ; itdata . poll_fds [ itdata . poll_fds_len ++ ] . fd = tdata -> record_eventfd ; while ( 1 ) { s = poll ( itdata . poll_fds , 3 , - 1 ) ; <S2SV_StartBug> if ( s < 0 ) <S2SV_EndBug> log_error ( "poll<S2SV_blank>failed" ) ; else if ( s > 0 ) { if ( itdata . poll_fds [ 1 ] . revents & events ) { break ; } <S2SV_StartBug> else if ( itdata . poll_fds [ 0 ] . revents & events ) <S2SV_EndBug> { handle_state_file_created ( & itdata ) ; } <S2SV_StartBug> else <S2SV_EndBug> { if ( itdata . poll_fds [ 2 ] . revents & events ) { pthread_mutex_lock ( & tdata -> record_mutex ) ; s = read ( itdata . poll_fds [ 2 ] . fd , & u , sizeof ( uint64_t ) ) ; if ( s < 0 ) log_error ( "read<S2SV_blank>failed" ) ; pthread_mutex_unlock ( & tdata -> record_mutex ) ; handle_record_event ( & itdata , u ) ; } } } } pthread_cleanup_pop ( 1 ) ; return NULL ; } | <S2SV_ModStart> 1 ) ; _log_debug ( "picam_state.c:<S2SV_blank>poll<S2SV_blank>returned<S2SV_blank>%d\\n" , s ) ; <S2SV_ModStart> ; } else { <S2SV_ModStart> ) ; } <S2SV_ModEnd> if ( itdata |
4,947 | CWE-000 static int write_memory ( struct target * target , target_addr_t address , uint32_t size , uint32_t count , const uint8_t * buffer ) { RISCV013_INFO ( info ) ; LOG_DEBUG ( "writing<S2SV_blank>%d<S2SV_blank>words<S2SV_blank>of<S2SV_blank>%d<S2SV_blank>bytes<S2SV_blank>to<S2SV_blank>0x%08lx" , count , size , ( long ) address ) ; select_dmi ( target ) ; riscv_set_current_hartid ( target , 0 ) ; uint64_t s0 = riscv_get_register ( target , GDB_REGNO_S0 ) ; uint64_t s1 = riscv_get_register ( target , GDB_REGNO_S1 ) ; struct riscv_program program ; riscv_program_init ( & program , target ) ; riscv_addr_t r_data = riscv_program_alloc_w ( & program ) ; riscv_addr_t r_addr = riscv_program_alloc_x ( & program ) ; riscv_program_fence ( & program ) ; riscv_program_lx ( & program , GDB_REGNO_S0 , r_addr ) ; riscv_program_lw ( & program , GDB_REGNO_S1 , r_data ) ; switch ( size ) { case 1 : riscv_program_sbr ( & program , GDB_REGNO_S1 , GDB_REGNO_S0 , 0 ) ; break ; case 2 : riscv_program_shr ( & program , GDB_REGNO_S1 , GDB_REGNO_S0 , 0 ) ; break ; case 4 : riscv_program_swr ( & program , GDB_REGNO_S1 , GDB_REGNO_S0 , 0 ) ; break ; default : LOG_ERROR ( "Unsupported<S2SV_blank>size:<S2SV_blank>%d" , size ) ; return ERROR_FAIL ; } riscv_program_addi ( & program , GDB_REGNO_S0 , GDB_REGNO_S0 , size ) ; riscv_program_sx ( & program , GDB_REGNO_S0 , r_addr ) ; uint32_t value ; switch ( size ) { case 1 : value = buffer [ 0 ] ; break ; case 2 : value = buffer [ 0 ] | ( ( uint32_t ) buffer [ 1 ] << 8 ) ; break ; case 4 : value = buffer [ 0 ] | ( ( uint32_t ) buffer [ 1 ] << 8 ) | ( ( uint32_t ) buffer [ 2 ] << 16 ) | ( ( uint32_t ) buffer [ 3 ] << 24 ) ; break ; default : LOG_ERROR ( "unsupported<S2SV_blank>access<S2SV_blank>size:<S2SV_blank>%d" , size ) ; return ERROR_FAIL ; } switch ( riscv_xlen ( target ) ) { case 64 : riscv_program_write_ram ( & program , r_addr + 4 , ( uint64_t ) address >> 32 ) ; case 32 : riscv_program_write_ram ( & program , r_addr , address ) ; break ; default : LOG_ERROR ( "unknown<S2SV_blank>XLEN<S2SV_blank>%d" , riscv_xlen ( target ) ) ; return ERROR_FAIL ; } riscv_program_write_ram ( & program , r_data , value ) ; LOG_DEBUG ( "M[0x%08lx]<S2SV_blank>writes<S2SV_blank>0x%08lx" , ( long ) address , ( long ) value ) ; if ( riscv_program_exec ( & program , target ) != ERROR_OK ) { uint32_t acs = dmi_read ( target , DMI_ABSTRACTCS ) ; LOG_ERROR ( "failed<S2SV_blank>to<S2SV_blank>execute<S2SV_blank>program,<S2SV_blank>abstractcs=0x%08x" , acs ) ; riscv013_clear_abstract_error ( target ) ; riscv_set_register ( target , GDB_REGNO_S0 , s0 ) ; riscv_set_register ( target , GDB_REGNO_S1 , s1 ) ; LOG_ERROR ( "<S2SV_blank><S2SV_blank>exiting<S2SV_blank>with<S2SV_blank>ERROR_FAIL" ) ; return ERROR_FAIL ; } int d_data = ( r_data - riscv_debug_buffer_addr ( target ) ) / 4 ; int d_addr = ( r_addr - riscv_debug_buffer_addr ( target ) ) / 4 ; riscv013_set_autoexec ( target , d_data , 1 ) ; riscv_addr_t cur_addr = 0xbadbeef ; riscv_addr_t fin_addr = address + ( count * size ) ; <S2SV_StartBug> LOG_DEBUG ( "writing<S2SV_blank>until<S2SV_blank>final<S2SV_blank>address<S2SV_blank>0x%016lx" , fin_addr ) ; <S2SV_EndBug> while ( ( cur_addr = riscv_read_debug_buffer_x ( target , d_addr ) ) < fin_addr ) { <S2SV_StartBug> LOG_DEBUG ( "transferring<S2SV_blank>burst<S2SV_blank>starting<S2SV_blank>at<S2SV_blank>address<S2SV_blank>0x%016lx" , cur_addr ) ; <S2SV_EndBug> riscv_addr_t start = ( cur_addr - address ) / size ; assert ( cur_addr > address ) ; struct riscv_batch * batch = riscv_batch_alloc ( target , 32 , info -> dmi_busy_delay + info -> ac_busy_delay ) ; for ( riscv_addr_t i = start ; i < count ; ++ i ) { riscv_addr_t offset = size * i ; riscv_addr_t t_addr = address + offset ; const uint8_t * t_buffer = buffer + offset ; switch ( size ) { case 1 : value = t_buffer [ 0 ] ; break ; case 2 : value = t_buffer [ 0 ] | ( ( uint32_t ) t_buffer [ 1 ] << 8 ) ; break ; case 4 : value = t_buffer [ 0 ] | ( ( uint32_t ) t_buffer [ 1 ] << 8 ) | ( ( uint32_t ) t_buffer [ 2 ] << 16 ) | ( ( uint32_t ) t_buffer [ 3 ] << 24 ) ; break ; default : LOG_ERROR ( "unsupported<S2SV_blank>access<S2SV_blank>size:<S2SV_blank>%d" , size ) ; return ERROR_FAIL ; } LOG_DEBUG ( "M[0x%08lx]<S2SV_blank>writes<S2SV_blank>0x%08lx" , ( long ) t_addr , ( long ) value ) ; riscv_batch_add_dmi_write ( batch , riscv013_debug_buffer_register ( target , r_data ) , value ) ; if ( riscv_batch_full ( batch ) ) break ; } riscv_batch_run ( batch ) ; riscv_batch_free ( batch ) ; uint32_t abstractcs = dmi_read ( target , DMI_ABSTRACTCS ) ; while ( get_field ( abstractcs , DMI_ABSTRACTCS_BUSY ) ) abstractcs = dmi_read ( target , DMI_ABSTRACTCS ) ; switch ( get_field ( abstractcs , DMI_ABSTRACTCS_CMDERR ) ) { case CMDERR_NONE : LOG_DEBUG ( "successful<S2SV_blank>(partial?)<S2SV_blank>memory<S2SV_blank>write" ) ; break ; case CMDERR_BUSY : LOG_DEBUG ( "memory<S2SV_blank>write<S2SV_blank>resulted<S2SV_blank>in<S2SV_blank>busy<S2SV_blank>response" ) ; riscv013_clear_abstract_error ( target ) ; increase_ac_busy_delay ( target ) ; break ; default : LOG_ERROR ( "error<S2SV_blank>when<S2SV_blank>writing<S2SV_blank>memory,<S2SV_blank>abstractcs=0x%08lx" , ( long ) abstractcs ) ; riscv013_set_autoexec ( target , d_data , 0 ) ; riscv013_clear_abstract_error ( target ) ; riscv_set_register ( target , GDB_REGNO_S0 , s0 ) ; riscv_set_register ( target , GDB_REGNO_S1 , s1 ) ; return ERROR_FAIL ; } } riscv013_set_autoexec ( target , d_data , 0 ) ; riscv_set_register ( target , GDB_REGNO_S0 , s0 ) ; riscv_set_register ( target , GDB_REGNO_S1 , s1 ) ; return ERROR_OK ; } | <S2SV_ModStart> ; LOG_DEBUG ( "writing<S2SV_blank>until<S2SV_blank>final<S2SV_blank>address<S2SV_blank>0x%016" PRIx64 <S2SV_ModEnd> , fin_addr ) <S2SV_ModStart> { LOG_DEBUG ( "transferring<S2SV_blank>burst<S2SV_blank>starting<S2SV_blank>at<S2SV_blank>address<S2SV_blank>0x%016" PRIx64 , <S2SV_ModEnd> cur_addr ) ; |
4,948 | CWE-000 static void mwl_process_txdesc ( struct mwl_priv * priv , struct sk_buff * skb ) { struct mwl_tx_desc * tx_desc ; struct mwl_tx_ctrl * tx_ctrl ; struct ieee80211_tx_info * tx_info ; u8 * ptr ; u32 * head ; int headroom = INTF_HEADER_LEN ; tx_info = IEEE80211_SKB_CB ( skb ) ; tx_ctrl = ( struct mwl_tx_ctrl * ) & IEEE80211_SKB_CB ( skb ) -> status ; ptr = ( u8 * ) skb -> data ; skb_push ( skb , sizeof ( struct mwl_tx_desc ) ) ; tx_desc = ( struct mwl_tx_desc * ) skb -> data ; memset ( tx_desc , 0 , sizeof ( struct mwl_tx_desc ) ) ; skb_push ( skb , headroom ) ; head = ( u32 * ) skb -> data ; * head = cpu_to_le32 ( MWIFIEX_USB_TYPE_DATA ) ; tx_desc -> tx_priority = tx_ctrl -> tx_priority ; tx_desc -> qos_ctrl = cpu_to_le16 ( tx_ctrl -> qos_ctrl ) ; tx_desc -> pkt_len = cpu_to_le16 ( skb -> len ) ; if ( tx_info -> flags & IEEE80211_TX_INTFL_DONT_ENCRYPT ) { <S2SV_StartBug> tx_desc -> flags |= MWL_TX_WCB_FLAGS_DONT_ENCRYPT ; <S2SV_EndBug> } if ( tx_info -> flags & IEEE80211_TX_CTL_NO_CCK_RATE ) { <S2SV_StartBug> tx_desc -> flags |= MWL_TX_WCB_FLAGS_NO_CCK_RATE ; <S2SV_EndBug> } tx_desc -> packet_info = 0 ; tx_desc -> data_rate = 0 ; tx_desc -> type = tx_ctrl -> type ; tx_desc -> xmit_control = tx_ctrl -> xmit_control ; tx_desc -> sap_pkt_info = 0 ; tx_desc -> pkt_ptr = cpu_to_le32 ( ( u8 * ) skb -> data - ptr ) ; tx_desc -> status = 0 ; return ; } | <S2SV_ModStart> -> flags |= cpu_to_le32 ( MWL_TX_WCB_FLAGS_DONT_ENCRYPT ) <S2SV_ModEnd> ; } if <S2SV_ModStart> -> flags |= cpu_to_le32 ( MWL_TX_WCB_FLAGS_NO_CCK_RATE ) <S2SV_ModEnd> ; } tx_desc |
4,949 | CWE-000 Ensure ( single_context_pubnub , subscribe_reestablishing_broken_keep_alive_conection ) { pubnub_init ( pbp , "publ-key" , "sub-Key" ) ; pubnub_set_uuid ( pbp , "admin" ) ; pubnub_set_auth ( pbp , "msgs" ) ; expect_have_dns_for_pubnub_origin ( ) ; expect_outgoing_with_url ( "/subscribe/sub-Key/[ch1,ch2]/0/" "0?pnsdk=unit-test-0.1&channel-group=[chgr2,chgr3," "chgr4]&uuid=admin&auth=msgs" ) ; incoming ( "HTTP/1.1<S2SV_blank>200\\r\\nContent-Length:<S2SV_blank>" "26\\r\\n\\r\\n[[],\\"3516149789251234578\\"]" , NULL ) ; expect ( pbntf_lost_socket , when ( pb , equals ( pbp ) ) ) ; expect ( pbntf_trans_outcome , when ( pb , equals ( pbp ) ) ) ; attest ( pubnub_subscribe ( pbp , "[ch1,ch2]" , "[chgr2,chgr3,chgr4]" ) , equals ( PNR_OK ) ) ; attest ( pubnub_get_channel ( pbp ) , streqs ( NULL ) ) ; attest ( pubnub_get ( pbp ) , equals ( NULL ) ) ; attest ( pubnub_last_http_code ( pbp ) , equals ( 200 ) ) ; expect ( pbntf_enqueue_for_processing , when ( pb , equals ( pbp ) ) , returns ( 0 ) ) ; expect ( pbntf_got_socket , when ( pb , equals ( pbp ) ) , returns ( 0 ) ) ; <S2SV_StartBug> expect ( pbpal_send , when ( data , streqs ( "GET<S2SV_blank>" ) ) , returns ( - 1 ) ) ; <S2SV_EndBug> expect ( pbpal_close , when ( pb , equals ( pbp ) ) , returns ( + 1 ) ) ; expect ( pbpal_closed , when ( pb , equals ( pbp ) ) , returns ( true ) ) ; expect ( pbpal_forget , when ( pb , equals ( pbp ) ) ) ; expect_have_dns_for_pubnub_origin ( ) ; expect_outgoing_with_url ( "/subscribe/sub-Key/[ch1,ch2]/0/" "3516149789251234578?pnsdk=unit-test-0.1&channel-" "group=[chgr2,chgr3,chgr4]&uuid=admin&auth=msgs" ) ; incoming ( "HTTP/1.1<S2SV_blank>200\\r\\nContent-Length:<S2SV_blank>" "150\\r\\n\\r\\n[[msg1,msg2,{\\"text\\":\\"Hello<S2SV_blank>" "World!\\"},msg4,msg5,{\\"key\\":\\"val\\\\ue\\"}]," "\\"352624978925123458\\",\\"chgr4,chgr2,chgr3,chgr4,chgr7,chgr4\\"," "\\"ch5,ch8,ch6,ch17,ch1,ch2\\"]" , NULL ) ; expect ( pbntf_lost_socket , when ( pb , equals ( pbp ) ) ) ; expect ( pbntf_trans_outcome , when ( pb , equals ( pbp ) ) ) ; attest ( pubnub_subscribe ( pbp , "[ch1,ch2]" , "[chgr2,chgr3,chgr4]" ) , equals ( PNR_OK ) ) ; attest ( pubnub_get_channel ( pbp ) , streqs ( "ch5" ) ) ; attest ( pubnub_get_channel ( pbp ) , streqs ( "ch8" ) ) ; attest ( pubnub_get_channel ( pbp ) , streqs ( "ch6" ) ) ; attest ( pubnub_get_channel ( pbp ) , streqs ( "ch17" ) ) ; attest ( pubnub_get_channel ( pbp ) , streqs ( "ch1" ) ) ; attest ( pubnub_get_channel ( pbp ) , streqs ( "ch2" ) ) ; attest ( pubnub_get_channel ( pbp ) , streqs ( NULL ) ) ; attest ( pubnub_get ( pbp ) , streqs ( "msg1" ) ) ; attest ( pubnub_get ( pbp ) , streqs ( "msg2" ) ) ; attest ( pubnub_get ( pbp ) , streqs ( "{\\"text\\":\\"Hello<S2SV_blank>World!\\"}" ) ) ; attest ( pubnub_get ( pbp ) , streqs ( "msg4" ) ) ; attest ( pubnub_get ( pbp ) , streqs ( "msg5" ) ) ; attest ( pubnub_get ( pbp ) , streqs ( "{\\"key\\":\\"val\\\\ue\\"}" ) ) ; attest ( pubnub_get ( pbp ) , equals ( NULL ) ) ; attest ( pubnub_last_http_code ( pbp ) , equals ( 200 ) ) ; expect ( pbntf_enqueue_for_processing , when ( pb , equals ( pbp ) ) , returns ( 0 ) ) ; expect ( pbntf_got_socket , when ( pb , equals ( pbp ) ) , returns ( 0 ) ) ; expect_outgoing_with_url ( "/subscribe/sub-Key/ch17/0/" "352624978925123458?pnsdk=unit-test-0.1&uuid=" "admin&auth=msgs" ) ; incoming ( "HTTP/1.1<S2SV_blank>200\\r\\nContent-Length:<S2SV_blank>" "47\\r\\n\\r\\n[[message],\\"352624979925123457\\",\\"chgr4\\",\\"ch17\\"]" , NULL ) ; expect ( pbntf_lost_socket , when ( pb , equals ( pbp ) ) ) ; expect ( pbntf_trans_outcome , when ( pb , equals ( pbp ) ) ) ; attest ( pubnub_subscribe ( pbp , "ch17" , NULL ) , equals ( PNR_OK ) ) ; attest ( pubnub_subscribe ( pbp , NULL , "chgr2" ) , equals ( PNR_RX_BUFF_NOT_EMPTY ) ) ; attest ( pubnub_get ( pbp ) , streqs ( "message" ) ) ; attest ( pubnub_get ( pbp ) , equals ( NULL ) ) ; attest ( pubnub_get_channel ( pbp ) , streqs ( "ch17" ) ) ; attest ( pubnub_get_channel ( pbp ) , streqs ( NULL ) ) ; attest ( pubnub_last_http_code ( pbp ) , equals ( 200 ) ) ; attest ( pubnub_free ( pbp ) , equals ( - 1 ) ) ; } | <S2SV_ModStart> ; expect ( pbpal_send_str , when ( s <S2SV_ModEnd> , streqs ( |
4,950 | CWE-000 static void print_device ( struct udev_device * device , const char * source , int prop ) { struct timespec ts ; assert_se ( clock_gettime ( CLOCK_MONOTONIC , & ts ) == 0 ) ; <S2SV_StartBug> printf ( "%-6s[%" PRI_TIME ".%06ld]<S2SV_blank>%-8s<S2SV_blank>%s<S2SV_blank>(%s)\\n" , <S2SV_EndBug> source , <S2SV_StartBug> ts . tv_sec , ts . tv_nsec / 1000 , <S2SV_EndBug> udev_device_get_action ( device ) , udev_device_get_devpath ( device ) , udev_device_get_subsystem ( device ) ) ; if ( prop ) { struct udev_list_entry * list_entry ; udev_list_entry_foreach ( list_entry , udev_device_get_properties_list_entry ( device ) ) printf ( "%s=%s\\n" , udev_list_entry_get_name ( list_entry ) , udev_list_entry_get_value ( list_entry ) ) ; printf ( "\\n" ) ; } } | <S2SV_ModStart> ( "%-6s[%" PRI_TIME ".%06" PRI_NSEC "]<S2SV_blank>%-8s<S2SV_blank>%s<S2SV_blank>(%s)\\n" <S2SV_ModEnd> , source , <S2SV_ModStart> . tv_sec , ( nsec_t ) |
4,951 | CWE-000 static void c_object_new ( mrb_vm * vm , mrb_value v [ ] , int argc ) { mrb_value new_obj = mrbc_instance_new ( vm , v -> cls , 0 ) ; char syms [ ] = "______initialize" ; <S2SV_StartBug> uint32_to_bin ( 1 , ( uint8_t * ) & syms [ 0 ] ) ; <S2SV_EndBug> uint16_to_bin ( 10 , ( uint8_t * ) & syms [ 4 ] ) ; uint32_t code [ 2 ] = { MKOPCODE ( OP_SEND ) | MKARG_A ( 0 ) | MKARG_B ( 0 ) | MKARG_C ( argc ) , MKOPCODE ( OP_ABORT ) } ; mrb_irep irep = { 0 , 0 , 0 , 2 , 0 , ( uint8_t * ) code , NULL , ( uint8_t * ) syms , NULL , } ; mrbc_release ( & v [ 0 ] ) ; v [ 0 ] = new_obj ; mrbc_dup ( & new_obj ) ; mrb_irep * org_pc_irep = vm -> pc_irep ; uint16_t org_pc = vm -> pc ; mrb_value * org_regs = vm -> current_regs ; vm -> pc = 0 ; vm -> pc_irep = & irep ; vm -> current_regs = v ; mrbc_vm_run ( vm ) ; vm -> pc = org_pc ; vm -> pc_irep = org_pc_irep ; vm -> current_regs = org_regs ; SET_RETURN ( new_obj ) ; } | <S2SV_ModStart> = "______initialize" ; mrb_sym sym_id = str_to_symid ( & syms [ 6 ] ) ; mrb_proc * m = find_method ( vm , v [ 0 ] , sym_id ) ; if ( m == 0 ) { SET_RETURN ( new_obj ) ; return ; } |
4,952 | CWE-000 static int set_light_backlight ( struct light_device_t * dev , struct light_state_t const * state ) { int nwr , ret = - 1 , fd ; char value [ 20 ] ; int light_level ; pthread_mutex_lock ( & g_lock ) ; light_level = state -> color & 0xff ; <S2SV_StartBug> light_level = light_level << 2 ; <S2SV_EndBug> if ( invert ) { <S2SV_StartBug> light_level = 1023 - light_level ; <S2SV_EndBug> if ( light_level >= 280 ) light_level -= 280 ; } else { <S2SV_StartBug> if ( light_level < 1024 ) <S2SV_EndBug> light_level += 40 ; if ( light_level > 1023 ) light_level = 1023 ; } fd = open ( backlight , O_RDWR ) ; if ( fd > 0 ) { nwr = sprintf ( value , "%d\\n" , light_level ) ; ret = write ( fd , value , nwr ) ; close ( fd ) ; } pthread_mutex_unlock ( & g_lock ) ; return ret ; } | <S2SV_ModStart> & 0xff ; <S2SV_ModEnd> if ( invert <S2SV_ModStart> { light_level = ( int ) ( light_level * 2.85 ) ; light_level = 726 - light_level <S2SV_ModEnd> ; } else <S2SV_ModStart> } else { light_level = ( int ) ( light_level * 3.84 ) <S2SV_ModEnd> ; } fd |
4,953 | CWE-000 int main ( int argc , char * * argv ) { char * input = NULL ; char * output = NULL ; int convert = 0 ; int makefile = 0 ; int opt ; FILE * inp ; FILE * outp = stdout ; while ( ( opt = getopt ( argc , argv , "ctx:p:i:o:" ) ) != - 1 ) { switch ( opt ) { case 'c' : convert = 1 ; break ; case 't' : makefile = 1 ; break ; case 'i' : input = optarg ; break ; case 'p' : newlibpath = optarg ; break ; case 'x' : prefix = optarg ; break ; case 'o' : output = optarg ; break ; default : usage ( ) ; break ; } } if ( input == NULL || newlibpath == NULL ) { usage ( ) ; } if ( output && ( outp = fopen ( output , "w" ) ) == NULL ) { fprintf ( stderr , "Cannot<S2SV_blank>open<S2SV_blank>outputfile<S2SV_blank><%s>\\n" , output ) ; exit ( 1 ) ; } read_list_file ( input ) ; if ( convert ) { int i ; for ( i = 0 ; i < num_files ; i ++ ) { <S2SV_StartBug> fprintf ( outp , "%s/%s\\n" , prefix , files [ i ] ) ; <S2SV_EndBug> } } else if ( makefile ) { int i ; for ( i = 0 ; i < num_files ; i ++ ) { <S2SV_StartBug> fprintf ( outp , "%s/%s.asm<S2SV_blank>" , newlibpath , files [ i ] ) ; <S2SV_EndBug> } } if ( outp != stdout ) { fclose ( stdout ) ; } } | <S2SV_ModStart> ++ ) { outp_filter <S2SV_ModEnd> ( outp , <S2SV_ModStart> ++ ) { outp_filter <S2SV_ModEnd> ( outp , |
4,954 | CWE-000 int32_t init ( xlator_t * this ) { int32_t ret = 0 ; char * tmp = NULL ; struct timeval tv = { 0 , } ; br_stub_private_t * priv = NULL ; if ( ! this -> children ) { gf_msg ( this -> name , GF_LOG_ERROR , 0 , BRS_MSG_NO_CHILD , "FATAL:<S2SV_blank>no<S2SV_blank>children" ) ; goto error_return ; } priv = GF_CALLOC ( 1 , sizeof ( * priv ) , gf_br_stub_mt_private_t ) ; if ( ! priv ) goto error_return ; priv -> local_pool = mem_pool_new ( br_stub_local_t , 512 ) ; if ( ! priv -> local_pool ) goto free_priv ; GF_OPTION_INIT ( "bitrot" , priv -> do_versioning , bool , free_mempool ) ; GF_OPTION_INIT ( "export" , tmp , str , free_mempool ) ; <S2SV_StartBug> strncpy ( priv -> export , tmp , sizeof ( priv -> export ) ) ; <S2SV_EndBug> ( void ) snprintf ( priv -> stub_basepath , sizeof ( priv -> stub_basepath ) , "%s/%s" , priv -> export , BR_STUB_QUARANTINE_DIR ) ; ( void ) gettimeofday ( & tv , NULL ) ; priv -> boot [ 0 ] = htonl ( tv . tv_sec ) ; priv -> boot [ 1 ] = htonl ( tv . tv_usec ) ; pthread_mutex_init ( & priv -> lock , NULL ) ; pthread_cond_init ( & priv -> cond , NULL ) ; INIT_LIST_HEAD ( & priv -> squeue ) ; this -> private = priv ; ret = gf_thread_create ( & priv -> signth , NULL , br_stub_signth , this , "brssign" ) ; if ( ret != 0 ) goto cleanup_lock ; ret = br_stub_bad_object_container_init ( this , priv ) ; if ( ret ) { gf_msg ( this -> name , GF_LOG_ERROR , 0 , BRS_MSG_BAD_CONTAINER_FAIL , "failed<S2SV_blank>to<S2SV_blank>launch<S2SV_blank>the<S2SV_blank>thread<S2SV_blank>for<S2SV_blank>storing<S2SV_blank>bad<S2SV_blank>gfids" ) ; goto cleanup_lock ; } gf_msg_debug ( this -> name , 0 , "bit-rot<S2SV_blank>stub<S2SV_blank>loaded" ) ; return 0 ; cleanup_lock : pthread_cond_destroy ( & priv -> cond ) ; pthread_mutex_destroy ( & priv -> lock ) ; free_mempool : mem_pool_destroy ( priv -> local_pool ) ; free_priv : GF_FREE ( priv ) ; this -> private = NULL ; error_return : return - 1 ; } | <S2SV_ModStart> , tmp , PATH_MAX - 1 ) ; <S2SV_ModEnd> priv -> export <S2SV_ModStart> priv -> export [ PATH_MAX - 1 ] = '\\0' <S2SV_ModEnd> ; ( void |
4,955 | CWE-000 static inline void __generic_make_request ( struct bio * bio ) { struct request_queue * q ; sector_t old_sector ; int ret , nr_sectors = bio_sectors ( bio ) ; dev_t old_dev ; int err = - EIO ; might_sleep ( ) ; if ( bio_check_eod ( bio , nr_sectors ) ) goto end_io ; old_sector = - 1 ; old_dev = 0 ; do { char b [ BDEVNAME_SIZE ] ; q = bdev_get_queue ( bio -> bi_bdev ) ; if ( unlikely ( ! q ) ) { printk ( KERN_ERR "generic_make_request:<S2SV_blank>Trying<S2SV_blank>to<S2SV_blank>access<S2SV_blank>" "nonexistent<S2SV_blank>block-device<S2SV_blank>%s<S2SV_blank>(%Lu)\\n" , bdevname ( bio -> bi_bdev , b ) , ( long long ) bio -> bi_sector ) ; goto end_io ; } if ( unlikely ( ! ( bio -> bi_rw & REQ_DISCARD ) && nr_sectors > queue_max_hw_sectors ( q ) ) ) { printk ( KERN_ERR "bio<S2SV_blank>too<S2SV_blank>big<S2SV_blank>device<S2SV_blank>%s<S2SV_blank>(%u<S2SV_blank>><S2SV_blank>%u)\\n" , bdevname ( bio -> bi_bdev , b ) , bio_sectors ( bio ) , queue_max_hw_sectors ( q ) ) ; goto end_io ; } if ( unlikely ( test_bit ( QUEUE_FLAG_DEAD , & q -> queue_flags ) ) ) goto end_io ; if ( should_fail_request ( bio ) ) goto end_io ; blk_partition_remap ( bio ) ; if ( bio_integrity_enabled ( bio ) && bio_integrity_prep ( bio ) ) goto end_io ; if ( old_sector != - 1 ) <S2SV_StartBug> trace_block_remap ( q , bio , old_dev , old_sector ) ; <S2SV_EndBug> old_sector = bio -> bi_sector ; old_dev = bio -> bi_bdev -> bd_dev ; if ( bio_check_eod ( bio , nr_sectors ) ) goto end_io ; if ( ( bio -> bi_rw & ( REQ_FLUSH | REQ_FUA ) ) && ! q -> flush_flags ) { bio -> bi_rw &= ~ ( REQ_FLUSH | REQ_FUA ) ; if ( ! nr_sectors ) { err = 0 ; goto end_io ; } } if ( ( bio -> bi_rw & REQ_DISCARD ) && ( ! blk_queue_discard ( q ) || ( ( bio -> bi_rw & REQ_SECURE ) && ! blk_queue_secdiscard ( q ) ) ) ) { err = - EOPNOTSUPP ; goto end_io ; } blk_throtl_bio ( q , & bio ) ; if ( ! bio ) break ; trace_block_bio_queue ( q , bio ) ; ret = q -> make_request_fn ( q , bio ) ; } while ( ret ) ; return ; end_io : bio_endio ( bio , err ) ; } | <S2SV_ModStart> - 1 ) trace_block_bio_remap <S2SV_ModEnd> ( q , |
4,956 | CWE-000 unsigned short mdnie_reg_hook ( unsigned short reg , unsigned short value ) { struct mdnie_effect * effect = ( struct mdnie_effect * ) & mdnie_controls ; int i ; int tmp , original ; unsigned short regval ; original = value ; <S2SV_StartBug> if ( unlikely ( ( ! sequence_hook && ! reg_hook ) || g_mdnie -> negative == NEGATIVE_ON ) ) <S2SV_EndBug> return value ; for ( i = 0 ; i < ARRAY_SIZE ( mdnie_controls ) ; i ++ ) { if ( unlikely ( effect -> reg == reg ) ) { if ( likely ( sequence_hook ) ) { tmp = regval = effect -> regval ; } else { tmp = regval = ( value & effect -> mask ) >> effect -> shift ; } if ( likely ( reg_hook ) ) { if ( is_switch ( reg ) ) tmp = effect_switch_hook ( effect , regval ) ; else tmp = secondary_hook ( effect , tmp ) ; if ( tmp > ( effect -> mask >> effect -> shift ) ) tmp = ( effect -> mask >> effect -> shift ) ; if ( tmp < 0 ) tmp = 0 ; regval = ( unsigned short ) tmp ; } value &= ~ effect -> mask ; value |= regval << effect -> shift ; # if 0 printk ( "mdnie:<S2SV_blank>hook<S2SV_blank>on:<S2SV_blank>0x%X<S2SV_blank>val:<S2SV_blank>0x%X<S2SV_blank>-><S2SV_blank>0x%X<S2SV_blank>effect:<S2SV_blank>\\t%4d<S2SV_blank>:<S2SV_blank>\\t%s<S2SV_blank>\\n" , reg , original , value , tmp , effect -> attribute . attr . name ) ; # endif } ++ effect ; } return value ; } | <S2SV_ModStart> ! reg_hook ) <S2SV_ModEnd> ) ) return |
4,957 | CWE-000 BIF_RETTYPE finish_loading_1 ( BIF_ALIST_1 ) { Sint i ; Sint n ; struct m * p = NULL ; Uint exceptions ; Eterm res ; int is_blocking = 0 ; int do_commit = 0 ; if ( ! erts_try_seize_code_write_permission ( BIF_P ) ) { ERTS_BIF_YIELD1 ( bif_export [ BIF_finish_loading_1 ] , BIF_P , BIF_ARG_1 ) ; } n = erts_list_length ( BIF_ARG_1 ) ; if ( n < 0 ) { badarg : if ( p ) { erts_free ( ERTS_ALC_T_LOADER_TMP , p ) ; } erts_release_code_write_permission ( ) ; BIF_ERROR ( BIF_P , BADARG ) ; } p = erts_alloc ( ERTS_ALC_T_LOADER_TMP , n * sizeof ( struct m ) ) ; for ( i = 0 ; i < n ; i ++ ) { Eterm * cons = list_val ( BIF_ARG_1 ) ; Eterm term = CAR ( cons ) ; if ( ! is_internal_magic_ref ( term ) ) { goto badarg ; } p [ i ] . code = erts_magic_ref2bin ( term ) ; p [ i ] . module = erts_module_for_prepared_code ( p [ i ] . code ) ; if ( p [ i ] . module == NIL ) { goto badarg ; } BIF_ARG_1 = CDR ( cons ) ; } if ( n > 1 ) { for ( i = 0 ; i < n ; i ++ ) { if ( erts_has_code_on_load ( p [ i ] . code ) == am_true ) { erts_free ( ERTS_ALC_T_LOADER_TMP , p ) ; erts_release_code_write_permission ( ) ; BIF_ERROR ( BIF_P , SYSTEM_LIMIT ) ; } } } res = am_ok ; erts_start_staging_code_ix ( n ) ; for ( i = 0 ; i < n ; i ++ ) { p [ i ] . modp = erts_put_module ( p [ i ] . module ) ; p [ i ] . modp -> seen = 0 ; } exceptions = 0 ; for ( i = 0 ; i < n ; i ++ ) { <S2SV_StartBug> p [ i ] . exception = 0 ; <S2SV_EndBug> if ( p [ i ] . modp -> seen ) { <S2SV_StartBug> p [ i ] . exception = 1 ; <S2SV_EndBug> exceptions ++ ; } p [ i ] . modp -> seen = 1 ; } if ( exceptions ) { res = exception_list ( BIF_P , am_duplicated , p , exceptions ) ; goto done ; } for ( i = 0 ; i < n ; i ++ ) { if ( p [ i ] . modp -> curr . num_breakpoints > 0 || p [ i ] . modp -> curr . num_traced_exports > 0 || erts_is_default_trace_enabled ( ) || IF_HIPE ( hipe_need_blocking ( p [ i ] . modp ) ) ) { erts_smp_proc_unlock ( BIF_P , ERTS_PROC_LOCK_MAIN ) ; erts_smp_thr_progress_block ( ) ; is_blocking = 1 ; break ; } } if ( is_blocking ) { for ( i = 0 ; i < n ; i ++ ) { if ( p [ i ] . modp -> curr . num_breakpoints ) { erts_clear_module_break ( p [ i ] . modp ) ; ASSERT ( p [ i ] . modp -> curr . num_breakpoints == 0 ) ; } } } exceptions = 0 ; for ( i = 0 ; i < n ; i ++ ) { <S2SV_StartBug> p [ i ] . exception = 0 ; <S2SV_EndBug> if ( p [ i ] . modp -> curr . code_hdr && p [ i ] . modp -> old . code_hdr ) { <S2SV_StartBug> p [ i ] . exception = 1 ; <S2SV_EndBug> exceptions ++ ; } } if ( exceptions ) { res = exception_list ( BIF_P , am_not_purged , p , exceptions ) ; } else { exceptions = 0 ; for ( i = 0 ; i < n ; i ++ ) { Eterm mod ; Eterm retval ; erts_refc_inc ( & p [ i ] . code -> intern . refc , 1 ) ; retval = erts_finish_loading ( p [ i ] . code , BIF_P , 0 , & mod ) ; ASSERT ( retval == NIL || retval == am_on_load ) ; if ( retval == am_on_load ) { <S2SV_StartBug> p [ i ] . exception = 1 ; <S2SV_EndBug> exceptions ++ ; } } if ( exceptions ) { res = exception_list ( BIF_P , am_on_load , p , exceptions ) ; } do_commit = 1 ; } done : return staging_epilogue ( BIF_P , do_commit , res , is_blocking , p , n , 1 ) ; } | <S2SV_ModStart> . exception = THE_NON_VALUE <S2SV_ModEnd> ; if ( <S2SV_ModStart> . exception = am_duplicated <S2SV_ModEnd> ; exceptions ++ <S2SV_ModStart> . exception = THE_NON_VALUE <S2SV_ModEnd> ; if ( <S2SV_ModStart> . exception = am_not_purged <S2SV_ModEnd> ; exceptions ++ <S2SV_ModStart> . exception = am_on_load <S2SV_ModEnd> ; exceptions ++ |
4,958 | CWE-000 int nettest_main ( int argc , char * argv [ ] ) # endif { int mode = 0 ; nettest_proto_e proto = NT_NONE ; int num_packets_to_process = 0 ; uint32_t interval = 0 ; uint32_t pps = 1 ; if ( argc < 6 ) { goto err_with_input ; } mode = atoi ( argv [ 1 ] ) ; if ( mode != NETTEST_SERVER_MODE && mode != NETTEST_CLIENT_MODE ) { goto err_with_input ; } if ( strlen ( argv [ 2 ] ) != strlen ( NETTEST_PROTO_TCP ) ) { goto err_with_input ; } if ( ! strncmp ( argv [ 2 ] , NETTEST_PROTO_TCP , strlen ( NETTEST_PROTO_TCP ) + 1 ) ) { proto = NT_TCP ; } else if ( ! strncmp ( argv [ 2 ] , NETTEST_PROTO_UDP , strlen ( NETTEST_PROTO_UDP ) + 1 ) ) { proto = NT_UDP ; } else if ( ! strncmp ( argv [ 2 ] , NETTEST_PROTO_BROADCAST , strlen ( NETTEST_PROTO_BROADCAST ) + 1 ) ) { proto = NT_BROADCAST ; } else if ( ! strncmp ( argv [ 2 ] , NETTEST_PROTO_MULTICAST , strlen ( NETTEST_PROTO_MULTICAST ) + 1 ) ) { proto = NT_MULTICAST ; } else { goto err_with_input ; } g_app_target_addr = argv [ 3 ] ; g_app_target_port = atoi ( argv [ 4 ] ) ; num_packets_to_process = atoi ( argv [ 5 ] ) ; <S2SV_StartBug> if ( num_packets_to_process < 0 ) { <S2SV_EndBug> goto err_with_input ; } if ( mode == NETTEST_SERVER_MODE ) { if ( proto == NT_TCP ) { tcp_server_thread ( num_packets_to_process ) ; } else if ( proto == NT_UDP ) { udp_server_thread ( num_packets_to_process ) ; } else if ( proto == NT_BROADCAST ) { broadcast_receive ( num_packets_to_process ) ; } else if ( proto == NT_MULTICAST ) { if ( argc != 7 ) { goto err_with_input ; } ipmcast_receiver_thread ( num_packets_to_process , argv [ 6 ] ) ; } } else if ( mode == NETTEST_CLIENT_MODE ) { if ( argc < 7 ) { goto err_with_input ; } pps = atoi ( argv [ 6 ] ) ; <S2SV_StartBug> if ( pps < 0 ) { <S2SV_EndBug> goto err_with_input ; } interval = 1000000ul / pps ; if ( proto == NT_TCP ) { tcp_client_thread ( num_packets_to_process , interval ) ; } else if ( proto == NT_UDP ) { udp_client_thread ( num_packets_to_process , interval ) ; } else if ( proto == NT_BROADCAST ) { broadcast_send ( num_packets_to_process , interval ) ; } else if ( proto == NT_MULTICAST ) { if ( argc != 8 ) { goto err_with_input ; } ipmcast_sender_thread ( num_packets_to_process , interval , argv [ 7 ] ) ; } } printf ( "Exiting<S2SV_blank>nettest_main<S2SV_blank>thread,<S2SV_blank>job<S2SV_blank>finished\\n" ) ; return 0 ; err_with_input : show_usage ( ) ; return - 1 ; } | <S2SV_ModStart> num_packets_to_process < 0 || num_packets_to_process > NETTEST_MAX_PACKETS <S2SV_ModStart> if ( pps <= <S2SV_ModEnd> 0 ) { |
4,959 | CWE-000 static int bio_rwcount_write ( BIO * b , const char * in , int inlen ) { struct rwcount * rw = b -> ptr ; <S2SV_StartBug> ev_ssize_t ret = write ( rw -> fd , in , inlen ) ; <S2SV_EndBug> ++ rw -> write ; <S2SV_StartBug> if ( ret == - 1 && errno == EAGAIN ) { <S2SV_EndBug> BIO_set_retry_write ( b ) ; } return ret ; } | <S2SV_ModStart> ev_ssize_t ret = send <S2SV_ModEnd> ( rw -> <S2SV_ModStart> in , inlen , 0 <S2SV_ModStart> - 1 && EVUTIL_ERR_RW_RETRIABLE ( EVUTIL_SOCKET_ERROR ( ) ) <S2SV_ModEnd> ) { BIO_set_retry_write |
4,960 | CWE-000 int main ( ) { printf ( "main" ) ; while ( true ) { <S2SV_StartBug> Sleep ( SLEEP_TIME ) ; <S2SV_EndBug> system ( "cls" ) ; switch ( game_state ) { case MENU_STATE : draw_menu ( ) ; break ; case GAME_STATE : get_key ( ) ; move_snake ( ) ; <S2SV_StartBug> draw_game ( ) ; <S2SV_EndBug> break ; case GAME_OVER_STATE : draw_game_over ( ) ; break ; case GAME_EXIT_STATE : return 0 ; exit ( 0 ) ; } } return 0 ; } | <S2SV_ModStart> Sleep ( SLEEP_TIME <S2SV_ModEnd> ) ; switch <S2SV_ModStart> ( ) ; merge_snake_to_map <S2SV_ModEnd> ( ) ; |
4,961 | CWE-000 static TupleTableSlot * ExecModifyTable ( PlanState * pstate ) { ModifyTableState * node = castNode ( ModifyTableState , pstate ) ; EState * estate = node -> ps . state ; CmdType operation = node -> operation ; ResultRelInfo * saved_resultRelInfo ; ResultRelInfo * resultRelInfo ; PlanState * subplanstate ; JunkFilter * junkfilter ; TupleTableSlot * slot ; TupleTableSlot * planSlot ; <S2SV_StartBug> ItemPointer tupleid = NULL ; <S2SV_EndBug> ItemPointerData tuple_ctid ; HeapTupleData oldtupdata ; HeapTuple oldtuple ; CHECK_FOR_INTERRUPTS ( ) ; if ( estate -> es_epqTuple != NULL ) elog ( ERROR , "ModifyTable<S2SV_blank>should<S2SV_blank>not<S2SV_blank>be<S2SV_blank>called<S2SV_blank>during<S2SV_blank>EvalPlanQual" ) ; if ( node -> mt_done ) return NULL ; if ( node -> fireBSTriggers ) { fireBSTriggers ( node ) ; node -> fireBSTriggers = false ; } resultRelInfo = node -> resultRelInfo + node -> mt_whichplan ; subplanstate = node -> mt_plans [ node -> mt_whichplan ] ; junkfilter = resultRelInfo -> ri_junkFilter ; saved_resultRelInfo = estate -> es_result_relation_info ; estate -> es_result_relation_info = resultRelInfo ; for ( ; ; ) { ResetPerTupleExprContext ( estate ) ; planSlot = ExecProcNode ( subplanstate ) ; if ( TupIsNull ( planSlot ) ) { node -> mt_whichplan ++ ; if ( node -> mt_whichplan < node -> mt_nplans ) { resultRelInfo ++ ; subplanstate = node -> mt_plans [ node -> mt_whichplan ] ; junkfilter = resultRelInfo -> ri_junkFilter ; estate -> es_result_relation_info = resultRelInfo ; EvalPlanQualSetPlan ( & node -> mt_epqstate , subplanstate -> plan , node -> mt_arowmarks [ node -> mt_whichplan ] ) ; if ( node -> mt_transition_capture != NULL ) { Assert ( node -> mt_transition_tupconv_maps != NULL ) ; node -> mt_transition_capture -> tcs_map = node -> mt_transition_tupconv_maps [ node -> mt_whichplan ] ; } if ( node -> mt_oc_transition_capture != NULL ) { Assert ( node -> mt_transition_tupconv_maps != NULL ) ; node -> mt_oc_transition_capture -> tcs_map = node -> mt_transition_tupconv_maps [ node -> mt_whichplan ] ; } continue ; } else break ; } if ( resultRelInfo -> ri_usesFdwDirectModify ) { Assert ( resultRelInfo -> ri_projectReturning ) ; slot = ExecProcessReturning ( resultRelInfo , NULL , planSlot ) ; estate -> es_result_relation_info = saved_resultRelInfo ; return slot ; } EvalPlanQualSetSlot ( & node -> mt_epqstate , planSlot ) ; <S2SV_StartBug> slot = planSlot ; <S2SV_EndBug> oldtuple = NULL ; if ( junkfilter != NULL ) { if ( operation == CMD_UPDATE || operation == CMD_DELETE ) { char relkind ; Datum datum ; bool isNull ; relkind = resultRelInfo -> ri_RelationDesc -> rd_rel -> relkind ; if ( relkind == RELKIND_RELATION || relkind == RELKIND_MATVIEW ) { datum = ExecGetJunkAttribute ( slot , junkfilter -> jf_junkAttNo , & isNull ) ; if ( isNull ) elog ( ERROR , "ctid<S2SV_blank>is<S2SV_blank>NULL" ) ; tupleid = ( ItemPointer ) DatumGetPointer ( datum ) ; tuple_ctid = * tupleid ; tupleid = & tuple_ctid ; } else if ( AttributeNumberIsValid ( junkfilter -> jf_junkAttNo ) ) { datum = ExecGetJunkAttribute ( slot , junkfilter -> jf_junkAttNo , & isNull ) ; if ( isNull ) elog ( ERROR , "wholerow<S2SV_blank>is<S2SV_blank>NULL" ) ; oldtupdata . t_data = DatumGetHeapTupleHeader ( datum ) ; oldtupdata . t_len = HeapTupleHeaderGetDatumLength ( oldtupdata . t_data ) ; ItemPointerSetInvalid ( & ( oldtupdata . t_self ) ) ; oldtupdata . t_tableOid = ( relkind == RELKIND_VIEW ) ? InvalidOid : RelationGetRelid ( resultRelInfo -> ri_RelationDesc ) ; oldtuple = & oldtupdata ; } else Assert ( relkind == RELKIND_FOREIGN_TABLE ) ; } if ( operation != CMD_DELETE ) slot = ExecFilterJunk ( junkfilter , slot ) ; } switch ( operation ) { case CMD_INSERT : slot = ExecInsert ( node , slot , planSlot , node -> mt_arbiterindexes , node -> mt_onconflict , estate , node -> canSetTag ) ; break ; case CMD_UPDATE : slot = ExecUpdate ( node , tupleid , oldtuple , slot , planSlot , & node -> mt_epqstate , estate , node -> canSetTag ) ; break ; case CMD_DELETE : slot = ExecDelete ( node , tupleid , oldtuple , planSlot , & node -> mt_epqstate , estate , node -> canSetTag ) ; break ; default : elog ( ERROR , "unknown<S2SV_blank>operation" ) ; break ; } if ( slot ) { estate -> es_result_relation_info = saved_resultRelInfo ; return slot ; } } estate -> es_result_relation_info = saved_resultRelInfo ; fireASTriggers ( node ) ; node -> mt_done = true ; return NULL ; } | <S2SV_ModStart> ; ItemPointer tupleid <S2SV_ModEnd> ; ItemPointerData tuple_ctid <S2SV_ModStart> slot = planSlot ; tupleid = NULL |
4,962 | CWE-000 static PyObject * PyArray_NewFromDescr_int ( PyTypeObject * subtype , PyArray_Descr * descr , int nd , npy_intp * dims , npy_intp * strides , void * data , int flags , PyObject * obj , int zeroed ) { PyArrayObject_fields * fa ; int i ; size_t sd ; npy_intp size ; if ( descr -> subarray ) { PyObject * ret ; npy_intp newdims [ 2 * NPY_MAXDIMS ] ; npy_intp * newstrides = NULL ; memcpy ( newdims , dims , nd * sizeof ( npy_intp ) ) ; if ( strides ) { newstrides = newdims + NPY_MAXDIMS ; memcpy ( newstrides , strides , nd * sizeof ( npy_intp ) ) ; } nd = _update_descr_and_dimensions ( & descr , newdims , newstrides , nd ) ; ret = PyArray_NewFromDescr_int ( subtype , descr , nd , newdims , newstrides , data , flags , obj , zeroed ) ; return ret ; } if ( ( unsigned int ) nd > ( unsigned int ) NPY_MAXDIMS ) { PyErr_Format ( PyExc_ValueError , "number<S2SV_blank>of<S2SV_blank>dimensions<S2SV_blank>must<S2SV_blank>be<S2SV_blank>within<S2SV_blank>[0,<S2SV_blank>%d]" , NPY_MAXDIMS ) ; Py_DECREF ( descr ) ; return NULL ; } <S2SV_StartBug> size = 1 ; <S2SV_EndBug> sd = ( size_t ) descr -> elsize ; if ( sd == 0 ) { if ( ! PyDataType_ISSTRING ( descr ) ) { PyErr_SetString ( PyExc_TypeError , "Empty<S2SV_blank>data-type" ) ; Py_DECREF ( descr ) ; return NULL ; } PyArray_DESCR_REPLACE ( descr ) ; if ( descr == NULL ) { return NULL ; } if ( descr -> type_num == NPY_STRING ) { sd = descr -> elsize = 1 ; } else { sd = descr -> elsize = sizeof ( npy_ucs4 ) ; } <S2SV_StartBug> } <S2SV_EndBug> for ( i = 0 ; i < nd ; i ++ ) { npy_intp dim = dims [ i ] ; if ( dim == 0 ) { continue ; } if ( dim < 0 ) { PyErr_SetString ( PyExc_ValueError , "negative<S2SV_blank>dimensions<S2SV_blank>" "are<S2SV_blank>not<S2SV_blank>allowed" ) ; Py_DECREF ( descr ) ; return NULL ; } if ( npy_mul_with_overflow_intp ( & size , size , dim ) ) { PyErr_SetString ( PyExc_ValueError , <S2SV_StartBug> "array<S2SV_blank>is<S2SV_blank>too<S2SV_blank>big." ) ; <S2SV_EndBug> Py_DECREF ( descr ) ; return NULL ; } } fa = ( PyArrayObject_fields * ) subtype -> tp_alloc ( subtype , 0 ) ; if ( fa == NULL ) { Py_DECREF ( descr ) ; return NULL ; } fa -> nd = nd ; fa -> dimensions = NULL ; fa -> data = NULL ; if ( data == NULL ) { fa -> flags = NPY_ARRAY_DEFAULT ; if ( flags ) { fa -> flags |= NPY_ARRAY_F_CONTIGUOUS ; if ( nd > 1 ) { fa -> flags &= ~ NPY_ARRAY_C_CONTIGUOUS ; } flags = NPY_ARRAY_F_CONTIGUOUS ; } } else { fa -> flags = ( flags & ~ NPY_ARRAY_UPDATEIFCOPY ) ; } fa -> descr = descr ; fa -> base = ( PyObject * ) NULL ; fa -> weakreflist = ( PyObject * ) NULL ; if ( nd > 0 ) { fa -> dimensions = npy_alloc_cache_dim ( 2 * nd ) ; if ( fa -> dimensions == NULL ) { PyErr_NoMemory ( ) ; goto fail ; } fa -> strides = fa -> dimensions + nd ; memcpy ( fa -> dimensions , dims , sizeof ( npy_intp ) * nd ) ; if ( strides == NULL ) { sd = _array_fill_strides ( fa -> strides , dims , nd , sd , flags , & ( fa -> flags ) ) ; } else { memcpy ( fa -> strides , strides , sizeof ( npy_intp ) * nd ) ; <S2SV_StartBug> sd *= size ; <S2SV_EndBug> } } else { fa -> dimensions = fa -> strides = NULL ; fa -> flags |= NPY_ARRAY_F_CONTIGUOUS ; } if ( data == NULL ) { if ( sd == 0 ) { sd = descr -> elsize ; } if ( zeroed || PyDataType_FLAGCHK ( descr , NPY_NEEDS_INIT ) ) { data = npy_alloc_cache_zero ( sd ) ; } else { data = npy_alloc_cache ( sd ) ; } if ( data == NULL ) { PyErr_NoMemory ( ) ; goto fail ; } fa -> flags |= NPY_ARRAY_OWNDATA ; } else { fa -> flags &= ~ NPY_ARRAY_OWNDATA ; } fa -> data = data ; PyArray_UpdateFlags ( ( PyArrayObject * ) fa , NPY_ARRAY_UPDATE_ALL ) ; if ( ( subtype != & PyArray_Type ) ) { PyObject * res , * func , * args ; func = PyObject_GetAttr ( ( PyObject * ) fa , npy_ma_str_array_finalize ) ; if ( func && func != Py_None ) { if ( NpyCapsule_Check ( func ) ) { PyArray_FinalizeFunc * cfunc ; cfunc = NpyCapsule_AsVoidPtr ( func ) ; Py_DECREF ( func ) ; if ( cfunc ( ( PyArrayObject * ) fa , obj ) < 0 ) { goto fail ; } } else { args = PyTuple_New ( 1 ) ; if ( obj == NULL ) { obj = Py_None ; } Py_INCREF ( obj ) ; PyTuple_SET_ITEM ( args , 0 , obj ) ; res = PyObject_Call ( func , args , NULL ) ; Py_DECREF ( args ) ; Py_DECREF ( func ) ; if ( res == NULL ) { goto fail ; } else { Py_DECREF ( res ) ; } } } else Py_XDECREF ( func ) ; } return ( PyObject * ) fa ; fail : Py_DECREF ( fa ) ; return NULL ; } | <S2SV_ModStart> NULL ; } <S2SV_ModEnd> sd = ( <S2SV_ModStart> ; } } size = sd ; <S2SV_ModStart> ( PyExc_ValueError , "array<S2SV_blank>is<S2SV_blank>too<S2SV_blank>big;<S2SV_blank>`arr.size<S2SV_blank>*<S2SV_blank>arr.dtype.itemsize`<S2SV_blank>" "is<S2SV_blank>larger<S2SV_blank>than<S2SV_blank>the<S2SV_blank>maximum<S2SV_blank>possible<S2SV_blank>size." <S2SV_ModEnd> ) ; Py_DECREF <S2SV_ModStart> ) ; sd = <S2SV_ModEnd> size ; } |
4,963 | CWE-000 static void radeon_switcheroo_set_state ( struct pci_dev * pdev , enum vga_switcheroo_state state ) { struct drm_device * dev = pci_get_drvdata ( pdev ) ; <S2SV_StartBug> struct radeon_device * rdev = dev -> dev_private ; <S2SV_EndBug> if ( radeon_is_px ( dev ) && state == VGA_SWITCHEROO_OFF ) return ; if ( state == VGA_SWITCHEROO_ON ) { <S2SV_StartBug> unsigned d3_delay = dev -> pdev -> d3_delay ; <S2SV_EndBug> pr_info ( "radeon:<S2SV_blank>switched<S2SV_blank>on\\n" ) ; dev -> switch_power_state = DRM_SWITCH_POWER_CHANGING ; <S2SV_StartBug> if ( d3_delay < 20 && ( rdev -> px_quirk_flags & RADEON_PX_QUIRK_LONG_WAKEUP ) ) <S2SV_EndBug> dev -> pdev -> d3_delay = 20 ; <S2SV_StartBug> radeon_resume_kms ( dev , true , true ) ; <S2SV_EndBug> dev -> pdev -> d3_delay = d3_delay ; dev -> switch_power_state = DRM_SWITCH_POWER_ON ; drm_kms_helper_poll_enable ( dev ) ; } else { pr_info ( "radeon:<S2SV_blank>switched<S2SV_blank>off\\n" ) ; drm_kms_helper_poll_disable ( dev ) ; dev -> switch_power_state = DRM_SWITCH_POWER_CHANGING ; radeon_suspend_kms ( dev , true , true , false ) ; dev -> switch_power_state = DRM_SWITCH_POWER_OFF ; } } | <S2SV_ModStart> pdev ) ; <S2SV_ModEnd> if ( radeon_is_px <S2SV_ModStart> VGA_SWITCHEROO_ON ) { <S2SV_ModEnd> pr_info ( "radeon:<S2SV_blank>switched<S2SV_blank>on\\n" <S2SV_ModStart> = DRM_SWITCH_POWER_CHANGING ; <S2SV_ModEnd> radeon_resume_kms ( dev <S2SV_ModStart> , true ) <S2SV_ModEnd> ; dev -> |
4,964 | CWE-000 ngx_int_t ngx_http_bot_verifier_module_verify_bot ( ngx_http_request_t * r ) { char dervied_address [ INET_ADDRSTRLEN ] ; ngx_int_t error = ngx_http_bot_verifier_module_determine_address ( r , dervied_address ) ; if ( error == NGX_ERROR || error == NGX_DECLINED ) { return NGX_ERROR ; } ngx_log_error ( NGX_LOG_ERR , r -> connection -> log , 0 , "Using<S2SV_blank>%s<S2SV_blank>as<S2SV_blank>connected<S2SV_blank>address" , & dervied_address ) ; struct sockaddr_in sa ; sa . sin_family = AF_INET ; inet_pton ( AF_INET , dervied_address , & ( sa . sin_addr ) ) ; char hostname [ NI_MAXHOST ] ; error = getnameinfo ( ( struct sockaddr * ) & sa , sizeof ( sa ) , hostname , sizeof ( hostname ) , NULL , 0 , 0 ) ; if ( error != 0 ) { ngx_log_error ( NGX_LOG_ERR , r -> connection -> log , 0 , "getnameinfo()<S2SV_blank>error:<S2SV_blank>%s" , gai_strerror ( error ) ) ; return NGX_ERROR ; } ngx_log_error ( NGX_LOG_ERR , r -> connection -> log , 0 , "Lookup<S2SV_blank>hostname<S2SV_blank>%s" , & hostname ) ; ngx_int_t match_result = hostname_matches_provider_domain ( r , ( char * ) hostname ) ; <S2SV_StartBug> ngx_log_error ( NGX_LOG_ERR , r -> connection -> log , 0 , "Match<S2SV_blank>result<S2SV_blank>%d" , match_result ) ; <S2SV_EndBug> <S2SV_StartBug> struct addrinfo * result ; <S2SV_EndBug> error = getaddrinfo ( hostname , NULL , NULL , & result ) ; if ( error != 0 ) { ngx_log_error ( NGX_LOG_ERR , r -> connection -> log , 0 , "getaddrinfo()<S2SV_blank>error:<S2SV_blank>%s" , gai_strerror ( error ) ) ; return NGX_ERROR ; } struct sockaddr_in * forward = ( struct sockaddr_in * ) result -> ai_addr ; char * forward_result = inet_ntoa ( forward -> sin_addr ) ; <S2SV_StartBug> ngx_log_error ( NGX_LOG_ERR , r -> connection -> log , 0 , "Lookup<S2SV_blank>IP<S2SV_blank>%s" , forward_result ) ; <S2SV_EndBug> <S2SV_StartBug> if ( strcmp ( dervied_address , forward_result ) == 0 ) { <S2SV_EndBug> freeaddrinfo ( result ) ; return NGX_OK ; } else { freeaddrinfo ( result ) ; return NGX_DECLINED ; } } | <S2SV_ModStart> hostname ) ; if ( match_result == NGX_DECLINED ) { <S2SV_ModStart> match_result ) ; return match_result ; } <S2SV_ModStart> , 0 , "Forward<S2SV_blank>Result<S2SV_blank>%s" <S2SV_ModEnd> , forward_result ) <S2SV_ModStart> forward_result ) ; ngx_log_error ( NGX_LOG_ERR , r -> connection -> log , 0 , "Derived<S2SV_blank>Address<S2SV_blank>%s" , dervied_address ) ; |
4,965 | CWE-000 static int copy_backup_region ( void ) { <S2SV_StartBug> if ( backup_dest ) <S2SV_EndBug> <S2SV_StartBug> memcpy ( ( void * ) backup_dest , ( void * ) backup_src , backup_sz ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> { if ( purgatory_backup_dest ) { <S2SV_ModEnd> memcpy ( ( <S2SV_ModStart> void * ) purgatory_backup_dest <S2SV_ModEnd> , ( void <S2SV_ModStart> void * ) purgatory_backup_src , purgatory_backup_sz ) ; } <S2SV_ModEnd> return 0 ; |
4,966 | CWE-000 static int bad_name ( DOS_FILE * file ) { int i , spc , suspicious = 0 ; const char * bad_chars = atari_format ? "*?\\\\/:" : "*?<>|\\"\\\\/:" ; const unsigned char * name = file -> dir_ent . name ; const unsigned char * ext = name + 8 ; <S2SV_StartBug> if ( ( file -> lfn == NULL ) && ( file -> dir_ent . lcase & FAT_NO_83NAME ) ) { <S2SV_EndBug> return 1 ; } if ( file -> dir_ent . lcase & FAT_NO_83NAME ) return 0 ; for ( i = 0 ; i < MSDOS_NAME ; i ++ ) { if ( ( name [ i ] < '<S2SV_blank>' && ! ( i == 0 && name [ 0 ] == 0x05 ) ) || name [ i ] == 0x7f ) return 1 ; if ( name [ i ] > 0x7f ) ++ suspicious ; if ( strchr ( bad_chars , name [ i ] ) ) return 1 ; } if ( name [ 0 ] == '<S2SV_blank>' ) return 1 ; if ( no_spaces_in_sfns ) { spc = 0 ; for ( i = 0 ; i < 8 ; i ++ ) { if ( name [ i ] == '<S2SV_blank>' ) spc = 1 ; else if ( spc ) return 1 ; } spc = 0 ; for ( i = 0 ; i < 3 ; i ++ ) { if ( ext [ i ] == '<S2SV_blank>' ) spc = 1 ; else if ( spc ) return 1 ; } } if ( atari_format && suspicious ) return 1 ; return 0 ; } | <S2SV_ModStart> ; if ( ! file -> offset ) return 0 ; if ( |
4,967 | CWE-000 static int timekeeping_suspend ( void ) { struct timekeeper * tk = & tk_core . timekeeper ; unsigned long flags ; struct timespec64 delta , delta_delta ; static struct timespec64 old_delta ; struct timespec tmp ; read_persistent_clock ( & tmp ) ; timekeeping_suspend_time = timespec_to_timespec64 ( tmp ) ; if ( timekeeping_suspend_time . tv_sec || timekeeping_suspend_time . tv_nsec ) persistent_clock_exist = true ; raw_spin_lock_irqsave ( & timekeeper_lock , flags ) ; write_seqcount_begin ( & tk_core . seq ) ; timekeeping_forward_now ( tk ) ; timekeeping_suspended = 1 ; <S2SV_StartBug> if ( has_persistent_clock ( ) ) { <S2SV_EndBug> delta = timespec64_sub ( tk_xtime ( tk ) , timekeeping_suspend_time ) ; delta_delta = timespec64_sub ( delta , old_delta ) ; if ( abs ( delta_delta . tv_sec ) >= 2 ) { old_delta = delta ; } else { timekeeping_suspend_time = timespec64_add ( timekeeping_suspend_time , delta_delta ) ; } <S2SV_StartBug> } <S2SV_EndBug> timekeeping_update ( tk , TK_MIRROR ) ; write_seqcount_end ( & tk_core . seq ) ; raw_spin_unlock_irqrestore ( & timekeeper_lock , flags ) ; clockevents_notify ( CLOCK_EVT_NOTIFY_SUSPEND , NULL ) ; clocksource_suspend ( ) ; clockevents_suspend ( ) ; return 0 ; } | <S2SV_ModStart> = 1 ; <S2SV_ModEnd> delta = timespec64_sub <S2SV_ModStart> ) ; } <S2SV_ModEnd> timekeeping_update ( tk |
4,968 | CWE-000 int * read_tetris ( int fd ) { char * buf ; int * move ; <S2SV_StartBug> int i ; <S2SV_EndBug> int tem_fd = fd ; buf = ft_strnew ( 21 ) ; i = 0 ; if ( ! ( move = ( int * ) malloc ( sizeof ( int ) * 27 ) ) ) { printf ( "read_tetris:<S2SV_blank>malloc<S2SV_blank>fail!\\n" ) ; return ( 0 ) ; } <S2SV_StartBug> printf ( "still<S2SV_blank>in<S2SV_blank>the<S2SV_blank>function~" ) ; <S2SV_EndBug> while ( read ( fd , buf , 21 ) ) { if ( check_newline ( buf ) || ! ( move [ i ++ ] = check_tetris ( my_tetris_num ( buf ) ) ) ) { <S2SV_StartBug> ft_memdel ( ( void * * ) & buf ) ; <S2SV_EndBug> ft_memdel ( ( void * * ) & move ) ; printf ( "read_tetris:<S2SV_blank>check_newline<S2SV_blank>&&<S2SV_blank>check_tetris\\n" ) ; return ( 0 ) ; } <S2SV_StartBug> } <S2SV_EndBug> move [ i ] = '\\0' ; ft_memdel ( ( void * * ) & buf ) ; return ( move ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ; int i <S2SV_ModEnd> ; buf = <S2SV_ModStart> ) ; } <S2SV_ModEnd> while ( read <S2SV_ModStart> ) ) { my_tetris_memdel ( buf , <S2SV_ModEnd> move ) ; <S2SV_ModStart> ) ; } if ( ft_strlen ( buf ) == 20 ) { <S2SV_ModEnd> move [ i <S2SV_ModStart> ) ; } ft_bzero ( buf , 21 ) ; } return ( 0 ) ; } |
4,969 | CWE-000 bool check_lock_list ( struct thread * t ) { <S2SV_StartBug> struct thread * temp = t ; <S2SV_EndBug> struct list_elem * e ; for ( e = list_rbegin ( & lock_list ) ; e != list_rend ( & lock_list ) ; e = list_prev ( e ) ) { struct thread * thread = list_entry ( & lock_list , struct thread , t -> elem ) ; if ( temp -> tid == thread -> tid ) { return true ; } } return false ; } | <S2SV_ModStart> = t ; if ( list_empty ( & lock_list ) ) { return false ; } |
4,970 | CWE-000 void handler_KriaKey ( s32 data ) { switch ( data ) { case 0 : grid_refresh = & refresh_kria ; view_clock = false ; break ; case 1 : <S2SV_StartBug> grid_refresh = & refresh_clock ; <S2SV_EndBug> print_dbg ( "\\r\\ntime:<S2SV_blank>" ) ; print_dbg_ulong ( time_fine ) ; print_dbg ( "<S2SV_blank>" ) ; print_dbg_ulong ( time_rough ) ; view_clock = true ; view_config = false ; break ; case 2 : grid_refresh = & refresh_kria ; view_config = false ; break ; case 3 : grid_refresh = & refresh_kria_config ; view_config = true ; view_clock = false ; break ; default : break ; } monomeFrameDirty ++ ; } | <S2SV_ModStart> = & refresh_clock <S2SV_ModEnd> ; view_clock = |
4,971 | CWE-000 int main ( int argc , char * argv [ ] ) { util_init ( ) ; rpmem_util_cmds_init ( ) ; util_mmap_init ( ) ; int ret = 0 ; struct pmembench * pb = calloc ( 1 , sizeof ( * pb ) ) ; assert ( pb != NULL ) ; if ( argc < 2 ) { pmembench_print_usage ( ) ; <S2SV_StartBug> exit ( EXIT_FAILURE ) ; <S2SV_EndBug> return - 1 ; } pb -> argc = -- argc ; pb -> argv = ++ argv ; char * bench_name = pb -> argv [ 0 ] ; if ( NULL == bench_name ) { ret = - 1 ; goto out ; } int fexists = access ( bench_name , R_OK ) == 0 ; struct benchmark * bench = pmembench_get_bench ( bench_name ) ; if ( NULL != bench ) ret = pmembench_run ( pb , bench ) ; else if ( fexists ) ret = pmembench_run_config ( pb , bench_name ) ; else if ( ( ret = pmembench_parse_opts ( pb ) ) != 0 ) { pmembench_print_usage ( ) ; goto out ; } out : free ( pb ) ; <S2SV_StartBug> return ret ; <S2SV_EndBug> } | <S2SV_ModStart> ( EXIT_FAILURE ) <S2SV_ModEnd> ; } pb <S2SV_ModStart> pb ) ; util_mmap_fini ( ) ; |
4,972 | CWE-000 int rnp_set_debug ( const char * f ) { const char * name ; int i ; if ( f == NULL ) { f = "all" ; } if ( ( name = strrchr ( f , '/' ) ) == NULL ) { name = f ; } else { name += 1 ; } <S2SV_StartBug> for ( i = 0 ; i < debugc && i < MAX_DEBUG_NAMES ; i ++ ) { <S2SV_EndBug> if ( strcmp ( debugv [ i ] , name ) == 0 ) { return 1 ; } } if ( i == MAX_DEBUG_NAMES ) { return 0 ; } debugv [ debugc ++ ] = rnp_strdup ( name ) ; return 1 ; } | <S2SV_ModStart> = 0 ; ( ( i < MAX_DEBUG_NAMES ) && ( <S2SV_ModStart> i < debugc ) ) <S2SV_ModEnd> ; i ++ |
4,973 | CWE-000 void json_value_free ( json_value * value ) { <S2SV_StartBug> json_settings settings = { 0 } ; <S2SV_EndBug> settings . mem_free = default_free ; json_value_free_ex ( & settings , value ) ; } | <S2SV_ModStart> settings = { 0UL , 0 , NULL , NULL , NULL <S2SV_ModEnd> } ; settings |
4,974 | CWE-000 static enum clnt_stat clnt_rdma_call ( struct clnt_req * cc ) { CLIENT * cl = cc -> cc_clnt ; struct cx_data * cx = CX_DATA ( cl ) ; struct rpc_dplx_rec * rec = cx -> cx_rec ; RDMAXPRT * xd = RDMA_DR ( rec ) ; struct poolq_entry * have = xdr_ioq_uv_fetch ( & xd -> sm_dr . ioq , & xd -> cbqh , "call<S2SV_blank>context" , 1 , IOQ_FLAG_NONE ) ; struct rpc_rdma_cbc * cbc = ( struct rpc_rdma_cbc * ) ( _IOQ ( have ) ) ; <S2SV_StartBug> XDR * xdrs ; <S2SV_EndBug> xdr_ioq_release ( & cbc -> workq . ioq_uv . uvqh ) ; xdr_ioq_release ( & cbc -> holdq . ioq_uv . uvqh ) ; xdr_rdma_callq ( xd ) ; cbc -> workq . xdrs [ 0 ] . x_lib [ 1 ] = cbc -> holdq . xdrs [ 0 ] . x_lib [ 1 ] = xd ; ( void ) xdr_ioq_uv_fetch ( & cbc -> holdq , & xd -> outbufs . uvqh , "call<S2SV_blank>buffer" , 1 , IOQ_FLAG_NONE ) ; xdr_ioq_reset ( & cbc -> holdq , 0 ) ; xdrs = cbc -> holdq . xdrs ; cc -> cc_error . re_status = RPC_SUCCESS ; mutex_lock ( & cl -> cl_lock ) ; <S2SV_StartBug> cx -> cx_u . cx_mcalli = ntohl ( cc -> cc_xid ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ! XDR_PUTBYTES ( xdrs , cx -> cx_u . cx_mcallc , cx -> cx_mpos ) <S2SV_EndBug> || ! XDR_PUTUINT32 ( xdrs , cc -> cc_proc ) || ! AUTH_MARSHALL ( cc -> cc_auth , xdrs ) || ! AUTH_WRAP ( cc -> cc_auth , xdrs , cc -> cc_call . proc , cc -> cc_call . where ) ) { mutex_unlock ( & cl -> cl_lock ) ; __warnx ( TIRPC_DEBUG_FLAG_CLNT_RDMA , "%s:<S2SV_blank>%p@%p<S2SV_blank>failed" , __func__ , cl , cx -> cx_rec ) ; xdr_ioq_release ( & cbc -> holdq . ioq_uv . uvqh ) ; return ( RPC_CANTENCODEARGS ) ; } mutex_unlock ( & cl -> cl_lock ) ; if ( ! xdr_rdma_clnt_flushout ( cbc ) ) { cl -> cl_error . re_errno = errno ; return ( RPC_CANTSEND ) ; } return ( RPC_SUCCESS ) ; } | <S2SV_ModStart> XDR * xdrs ; u_int32_t * uint32p <S2SV_ModStart> cl_lock ) ; uint32p = ( u_int32_t * ) & cx -> cx_mcallc [ 0 ] ; * uint32p = htonl <S2SV_ModEnd> ( cc -> <S2SV_ModStart> , cx -> <S2SV_ModEnd> cx_mcallc , cx |
4,975 | CWE-000 struct displaced_step_closure * aarch64_displaced_step_copy_insn ( struct gdbarch * gdbarch , CORE_ADDR from , CORE_ADDR to , struct regcache * regs ) { <S2SV_StartBug> struct displaced_step_closure * dsc = NULL ; <S2SV_EndBug> enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code ( gdbarch ) ; uint32_t insn = read_memory_unsigned_integer ( from , 4 , byte_order_for_code ) ; struct aarch64_displaced_step_data dsd ; aarch64_inst inst ; if ( aarch64_decode_insn ( insn , & inst , 1 ) != 0 ) return NULL ; if ( inst . opcode -> iclass == ldstexcl && bit ( insn , 22 ) ) { return NULL ; } <S2SV_StartBug> dsc = XCNEW ( struct displaced_step_closure ) ; <S2SV_EndBug> dsd . base . insn_addr = from ; dsd . new_addr = to ; dsd . regs = regs ; <S2SV_StartBug> dsd . dsc = dsc ; <S2SV_EndBug> dsd . insn_count = 0 ; aarch64_relocate_instruction ( insn , & visitor , ( struct aarch64_insn_data * ) & dsd ) ; gdb_assert ( dsd . insn_count <= DISPLACED_MODIFIED_INSNS ) ; if ( dsd . insn_count != 0 ) { int i ; for ( i = 0 ; i < dsd . insn_count ; i ++ ) { if ( debug_displaced ) { debug_printf ( "displaced:<S2SV_blank>writing<S2SV_blank>insn<S2SV_blank>" ) ; debug_printf ( "%.8x" , dsd . insn_buf [ i ] ) ; debug_printf ( "<S2SV_blank>at<S2SV_blank>%s\\n" , paddress ( gdbarch , to + i * 4 ) ) ; } write_memory_unsigned_integer ( to + i * 4 , 4 , byte_order_for_code , ( ULONGEST ) dsd . insn_buf [ i ] ) ; } } else { <S2SV_StartBug> xfree ( dsc ) ; <S2SV_EndBug> dsc = NULL ; } <S2SV_StartBug> return dsc ; <S2SV_EndBug> } | <S2SV_ModStart> regs ) { <S2SV_ModEnd> enum bfd_endian byte_order_for_code <S2SV_ModStart> NULL ; } std : : unique_ptr < aarch64_displaced_step_closure > dsc ( new aarch64_displaced_step_closure <S2SV_ModEnd> ) ; dsd <S2SV_ModStart> dsc = dsc . get ( ) <S2SV_ModStart> } else { <S2SV_ModEnd> dsc = NULL <S2SV_ModStart> } return dsc . release ( ) |
4,976 | CWE-000 image cornerness_response ( image S ) { image R = make_image ( S . w , S . h , 1 ) ; const float alpha = 0.06 ; <S2SV_StartBug> int n = S . w * s . h ; <S2SV_EndBug> # pragma omp parallel for for ( int i = 0 ; i < n ; ++ i ) { float IxIx = S . data [ i ] , IyIy = S . data [ i + n ] ; float IxIy = S . data [ i + 2 * n ] ; float det = IxIx * IyIy - IxIy * IxIy ; float trace = IxIx + IyIy ; R . data [ i ] = det - alpha * trace * trace ; } return R ; } | <S2SV_ModStart> . w * S <S2SV_ModEnd> . h ; |
4,977 | CWE-000 static int rpcrdma_bc_setup_rqst ( struct rpcrdma_xprt * r_xprt , struct rpc_rqst * rqst ) { struct rpcrdma_regbuf * rb ; struct rpcrdma_req * req ; size_t size ; req = rpcrdma_create_req ( r_xprt ) ; if ( IS_ERR ( req ) ) return PTR_ERR ( req ) ; req -> rl_backchannel = true ; rb = rpcrdma_alloc_regbuf ( RPCRDMA_HDRBUF_SIZE , DMA_TO_DEVICE , GFP_KERNEL ) ; if ( IS_ERR ( rb ) ) goto out_fail ; req -> rl_rdmabuf = rb ; <S2SV_StartBug> size = r_xprt -> rx_data . inline_rsize ; <S2SV_EndBug> rb = rpcrdma_alloc_regbuf ( size , DMA_TO_DEVICE , GFP_KERNEL ) ; if ( IS_ERR ( rb ) ) goto out_fail ; req -> rl_sendbuf = rb ; xdr_buf_init ( & rqst -> rq_snd_buf , rb -> rg_base , min_t ( size_t , size , PAGE_SIZE ) ) ; rpcrdma_set_xprtdata ( rqst , req ) ; return 0 ; out_fail : rpcrdma_bc_free_rqst ( r_xprt , rqst ) ; return - ENOMEM ; } | <S2SV_ModStart> = rb ; xdr_buf_init ( & req -> rl_hdrbuf , rb -> rg_base , rdmab_length ( rb ) ) ; |
4,978 | CWE-000 static int dpdk_config ( oconfig_item_t * ci ) { <S2SV_StartBug> int i = 0 , ret = 0 ; <S2SV_EndBug> int err = dpdk_shm_init ( sizeof ( dpdk_config_t ) ) ; if ( err ) { DEBUG ( "dpdkstat:<S2SV_blank>error<S2SV_blank>in<S2SV_blank>shm_init,<S2SV_blank>%s" , strerror ( errno ) ) ; return - 1 ; } dpdk_config_init_default ( ) ; for ( i = 0 ; i < ci -> children_num ; i ++ ) { oconfig_item_t * child = ci -> children + i ; if ( strcasecmp ( "Interval" , child -> key ) == 0 ) { g_configuration -> interval = DOUBLE_TO_CDTIME_T ( child -> values [ 0 ] . value . number ) ; DEBUG ( "dpdkstat:<S2SV_blank>Plugin<S2SV_blank>Read<S2SV_blank>Interval<S2SV_blank>%lu<S2SV_blank>milliseconds\\n" , CDTIME_T_TO_MS ( g_configuration -> interval ) ) ; } else if ( strcasecmp ( "Coremask" , child -> key ) == 0 ) { ssnprintf ( g_configuration -> coremask , DATA_MAX_NAME_LEN , "%s" , child -> values [ 0 ] . value . string ) ; DEBUG ( "dpdkstat:COREMASK<S2SV_blank>%s<S2SV_blank>\\n" , g_configuration -> coremask ) ; g_configuration -> eal_argc += 1 ; } else if ( strcasecmp ( "MemoryChannels" , child -> key ) == 0 ) { ssnprintf ( g_configuration -> memory_channels , DATA_MAX_NAME_LEN , "%s" , child -> values [ 0 ] . value . string ) ; DEBUG ( "dpdkstat:Memory<S2SV_blank>Channels<S2SV_blank>%s<S2SV_blank>\\n" , g_configuration -> memory_channels ) ; g_configuration -> eal_argc += 1 ; } else if ( strcasecmp ( "SocketMemory" , child -> key ) == 0 ) { ssnprintf ( g_configuration -> socket_memory , DATA_MAX_NAME_LEN , "%s" , child -> values [ 0 ] . value . string ) ; DEBUG ( "dpdkstat:<S2SV_blank>socket<S2SV_blank>mem<S2SV_blank>%s<S2SV_blank>\\n" , g_configuration -> socket_memory ) ; g_configuration -> eal_argc += 1 ; } else if ( strcasecmp ( "ProcessType" , child -> key ) == 0 ) { ssnprintf ( g_configuration -> process_type , DATA_MAX_NAME_LEN , "%s" , child -> values [ 0 ] . value . string ) ; DEBUG ( "dpdkstat:<S2SV_blank>proc<S2SV_blank>type<S2SV_blank>%s<S2SV_blank>\\n" , g_configuration -> process_type ) ; g_configuration -> eal_argc += 1 ; } else if ( strcasecmp ( "FilePrefix" , child -> key ) == 0 ) { ssnprintf ( g_configuration -> file_prefix , DATA_MAX_NAME_LEN , "/var/run/.%s_config" , child -> values [ 0 ] . value . string ) ; DEBUG ( "dpdkstat:<S2SV_blank>file<S2SV_blank>prefix<S2SV_blank>%s<S2SV_blank>\\n" , g_configuration -> file_prefix ) ; if ( strcasecmp ( g_configuration -> file_prefix , "/var/run/.rte_config" ) != 0 ) { g_configuration -> eal_argc += 1 ; } } else { WARNING ( "dpdkstat:<S2SV_blank>The<S2SV_blank>config<S2SV_blank>option<S2SV_blank>\\"%s\\"<S2SV_blank>is<S2SV_blank>unknown." , child -> key ) ; } } g_configured = 1 ; return 0 ; } | <S2SV_ModStart> i = 0 <S2SV_ModEnd> ; int err |
4,979 | CWE-000 static inline void SetPSDPixel ( Image * image , const size_t channels , const ssize_t type , const size_t packet_size , const Quantum pixel , Quantum * q , ExceptionInfo * exception ) { if ( image -> storage_class == PseudoClass ) { <S2SV_StartBug> if ( packet_size == 1 ) <S2SV_EndBug> SetPixelIndex ( image , ScaleQuantumToChar ( pixel ) , q ) ; else SetPixelIndex ( image , ScaleQuantumToShort ( pixel ) , q ) ; <S2SV_StartBug> SetPixelViaPixelInfo ( image , image -> colormap + ( ssize_t ) <S2SV_EndBug> <S2SV_StartBug> ConstrainColormapIndex ( image , GetPixelIndex ( image , q ) , exception ) , q ) ; <S2SV_EndBug> return ; } switch ( type ) { case - 1 : { SetPixelAlpha ( image , pixel , q ) ; break ; } case - 2 : case 0 : { SetPixelRed ( image , pixel , q ) ; break ; } case 1 : { <S2SV_StartBug> if ( image -> storage_class == PseudoClass ) <S2SV_EndBug> SetPixelAlpha ( image , pixel , q ) ; else SetPixelGreen ( image , pixel , q ) ; break ; } case 2 : { <S2SV_StartBug> if ( image -> storage_class == PseudoClass ) <S2SV_EndBug> SetPixelAlpha ( image , pixel , q ) ; else SetPixelBlue ( image , pixel , q ) ; break ; } case 3 : { if ( image -> colorspace == CMYKColorspace ) SetPixelBlack ( image , pixel , q ) ; else if ( image -> alpha_trait != UndefinedPixelTrait ) SetPixelAlpha ( image , pixel , q ) ; break ; } case 4 : { if ( ( IssRGBCompatibleColorspace ( image -> colorspace ) != MagickFalse ) && ( channels > 3 ) ) break ; if ( image -> alpha_trait != UndefinedPixelTrait ) SetPixelAlpha ( image , pixel , q ) ; break ; } } } | <S2SV_ModStart> PseudoClass ) { PixelInfo * color ; if ( type == 0 ) { <S2SV_ModStart> q ) ; } color = <S2SV_ModEnd> image -> colormap <S2SV_ModStart> , exception ) ; if ( ( type == 0 ) && ( channels > 1 ) ) return ; else color -> alpha = ( MagickRealType ) pixel ; SetPixelViaPixelInfo ( image , color <S2SV_ModStart> 1 : { <S2SV_ModEnd> SetPixelGreen ( image <S2SV_ModStart> 2 : { <S2SV_ModEnd> SetPixelBlue ( image |
4,980 | CWE-000 static pgp_curve_t ask_curve ( ) { pgp_curve_t result = PGP_CURVE_MAX ; long val = 0 ; bool ok = false ; do { printf ( "Please<S2SV_blank>select<S2SV_blank>which<S2SV_blank>elliptic<S2SV_blank>curve<S2SV_blank>you<S2SV_blank>want:\\n" ) ; for ( int i = 0 ; ( i < PGP_CURVE_MAX ) && ( i != PGP_CURVE_ED25519 ) ; i ++ ) { printf ( "\\t(%u)<S2SV_blank>%s\\n" , i + 1 , ec_curves [ i ] . pgp_name ) ; } printf ( "><S2SV_blank>" ) ; ok = rnp_secure_get_long_from_fd ( stdin , & val ) ; ok &= ( val > 0 ) && ( val < PGP_CURVE_MAX ) ; } while ( ! ok ) ; if ( ok ) { <S2SV_StartBug> result = ( pgp_curve_t ) val ; <S2SV_EndBug> } return result ; } | <S2SV_ModStart> ( pgp_curve_t ) ( val - 1 ) <S2SV_ModEnd> ; } return |
4,981 | CWE-000 static int parse_struct_declarator ( int sym , zend_ffi_dcl * struct_dcl , zend_ffi_dcl * field_dcl ) { const char * name ; size_t name_len ; zend_ffi_val bits ; if ( sym == YY__STAR || sym == YY_ID || sym == YY__LPAREN ) { sym = parse_declarator ( sym , field_dcl , & name , & name_len ) ; if ( sym == YY__COLON ) { sym = get_sym ( ) ; sym = parse_constant_expression ( sym , & bits ) ; if ( sym == YY___ATTRIBUTE__ ) { sym = parse_attributes ( sym , field_dcl ) ; } zend_ffi_add_bit_field ( struct_dcl , name , name_len , field_dcl , & bits ) ; } else if ( sym == YY___ATTRIBUTE__ || sym == YY__COMMA || sym == YY__SEMICOLON ) { if ( sym == YY___ATTRIBUTE__ ) { sym = parse_attributes ( sym , field_dcl ) ; } zend_ffi_add_field ( struct_dcl , name , name_len , field_dcl ) ; <S2SV_StartBug> } <S2SV_EndBug> } else if ( sym == YY__COLON ) { sym = get_sym ( ) ; sym = parse_constant_expression ( sym , & bits ) ; zend_ffi_skip_bit_field ( struct_dcl , & bits ) ; <S2SV_StartBug> } <S2SV_EndBug> return sym ; } | <S2SV_ModStart> ) ; } else { yy_error_sym ( "unexpected<S2SV_blank>\'%s\'" , sym ) ; } <S2SV_ModStart> ) ; } else { yy_error_sym ( "unexpected<S2SV_blank>\'%s\'" , sym ) ; } |
4,982 | CWE-000 int regex_match ( const char * expr , const char * search , int msize , regmatch_t * matches ) { regex_t regex ; int reti ; char msgbuf [ 100 ] ; int ret ; reti = regcomp ( & regex , expr , REG_ICASE | REG_EXTENDED ) ; if ( reti ) { <S2SV_StartBug> LOG ( "Could<S2SV_blank>not<S2SV_blank>compile<S2SV_blank>regex:<S2SV_blank>%s\\n" , expr ) ; <S2SV_EndBug> return 0 ; } reti = regexec ( & regex , search , msize , matches , 0 ) ; if ( ! reti ) { ret = 1 ; } else if ( reti == REG_NOMATCH ) { ret = 0 ; } else { regerror ( reti , & regex , msgbuf , sizeof ( msgbuf ) ) ; LOG ( "Regex<S2SV_blank>match<S2SV_blank>failed:<S2SV_blank>%s\\n" , msgbuf ) ; ret = 0 ; } regfree ( & regex ) ; return ret ; } | <S2SV_ModStart> "Could<S2SV_blank>not<S2SV_blank>compile<S2SV_blank>regex:<S2SV_blank>%s\\n" , expr ) ; regerror ( reti , & regex , msgbuf , sizeof ( msgbuf ) ) ; LOG ( "Regex<S2SV_blank>match<S2SV_blank>failed:<S2SV_blank>%s\\n" , msgbuf |
4,983 | CWE-000 jerry_value_t <S2SV_StartBug> jerry_exec_snapshot ( const void * snapshot_p , <S2SV_EndBug> size_t snapshot_size , bool copy_bytecode ) { # ifdef JERRY_ENABLE_SNAPSHOT_EXEC JERRY_ASSERT ( snapshot_p != NULL ) ; static const char * const invalid_version_error_p = "Invalid<S2SV_blank>snapshot<S2SV_blank>version" ; static const char * const invalid_format_error_p = "Invalid<S2SV_blank>snapshot<S2SV_blank>format" ; <S2SV_StartBug> const uint8_t * snapshot_data_p = ( uint8_t * ) snapshot_p ; <S2SV_EndBug> if ( snapshot_size <= sizeof ( jerry_snapshot_header_t ) ) { return ecma_raise_type_error ( invalid_format_error_p ) ; } const jerry_snapshot_header_t * header_p = ( const jerry_snapshot_header_t * ) snapshot_data_p ; if ( header_p -> version != JERRY_SNAPSHOT_VERSION ) { return ecma_raise_type_error ( invalid_version_error_p ) ; } lit_mem_to_snapshot_id_map_entry_t * lit_map_p = NULL ; uint32_t literals_num ; if ( header_p -> lit_table_offset >= snapshot_size ) { return ecma_raise_type_error ( invalid_version_error_p ) ; } <S2SV_StartBug> if ( ! ecma_load_literals_from_snapshot ( snapshot_data_p + header_p -> lit_table_offset , <S2SV_EndBug> header_p -> lit_table_size , & lit_map_p , & literals_num ) ) { JERRY_ASSERT ( lit_map_p == NULL ) ; return ecma_raise_type_error ( invalid_format_error_p ) ; } ecma_compiled_code_t * bytecode_p ; <S2SV_StartBug> bytecode_p = snapshot_load_compiled_code ( snapshot_data_p , <S2SV_EndBug> sizeof ( jerry_snapshot_header_t ) , lit_map_p , copy_bytecode ) ; if ( lit_map_p != NULL ) { jmem_heap_free_block ( lit_map_p , literals_num * sizeof ( lit_mem_to_snapshot_id_map_entry_t ) ) ; } if ( bytecode_p == NULL ) { return ecma_raise_type_error ( invalid_format_error_p ) ; } ecma_value_t ret_val ; if ( header_p -> is_run_global ) { ret_val = vm_run_global ( bytecode_p ) ; ecma_bytecode_deref ( bytecode_p ) ; } else { ret_val = vm_run_eval ( bytecode_p , false ) ; } return ret_val ; # else JERRY_UNUSED ( snapshot_p ) ; JERRY_UNUSED ( snapshot_size ) ; JERRY_UNUSED ( copy_bytecode ) ; return ecma_make_simple_value ( ECMA_SIMPLE_VALUE_FALSE ) ; # endif } | <S2SV_ModStart> jerry_exec_snapshot ( const uint32_t <S2SV_ModEnd> * snapshot_p , <S2SV_ModStart> "Invalid<S2SV_blank>snapshot<S2SV_blank>format" ; const uint32_t <S2SV_ModEnd> * snapshot_data_p = <S2SV_ModStart> * snapshot_data_p = <S2SV_ModEnd> snapshot_p ; if <S2SV_ModStart> ) ; } JERRY_ASSERT ( ( header_p -> lit_table_offset % sizeof ( uint32_t ) ) == 0 ) ; <S2SV_ModStart> ( snapshot_data_p + ( <S2SV_ModStart> header_p -> lit_table_offset / sizeof ( uint32_t ) ) <S2SV_ModStart> = snapshot_load_compiled_code ( ( uint8_t * ) |
4,984 | CWE-000 void cs_log_tx_put ( struct cs_log_tx * tx ) { struct bio * bio ; if ( atomic_dec_and_test ( & tx -> ref_count ) ) { while ( ( bio = bio_list_pop ( & tx -> bl ) ) ) bio_put ( bio ) ; csum_deinit ( & tx -> sum_ctx ) ; <S2SV_StartBug> kfree ( tx ) ; <S2SV_EndBug> } } | <S2SV_ModStart> sum_ctx ) ; kmem_cache_free ( g_cs_log_tx_cache , <S2SV_ModEnd> tx ) ; |
4,985 | CWE-000 boolean input_variant_in_filter ( const VCF_VARIANT_FILTER * Filter , const VCF_VARIANT * Variant ) { long long int cmpResult = 0 ; boolean ret = FALSE ; size_t intervalStart = 0 ; size_t intervalSize = Filter -> RegionCount ; size_t index = intervalStart + intervalSize / 2 ; ret = ( intervalSize == 0 ) ; <S2SV_StartBug> while ( intervalSize > 0 ) { <S2SV_EndBug> cmpResult = strcmp ( Variant -> Chrom , Filter -> Regions [ index ] . Chrom ) ; if ( cmpResult == 0 ) { cmpResult = ( long long int ) ( Variant -> Pos - Filter -> Regions [ index ] . Start ) ; if ( cmpResult >= 0 ) { ret = ( Variant -> Pos <= Filter -> Regions [ index ] . End ) ; if ( ! ret ) { intervalSize /= 2 ; if ( cmpResult > 0 ) index += intervalSize ; else index -= intervalSize ; } } else { intervalSize /= 2 ; if ( cmpResult > 0 ) index += intervalSize ; else index -= intervalSize ; } } else { intervalSize /= 2 ; if ( cmpResult > 0 ) index += intervalSize ; else index -= intervalSize ; } } return ret ; } | <S2SV_ModStart> ; while ( ! ret && |
4,986 | CWE-000 int main ( int argc , char * * argv ) { int i ; <S2SV_StartBug> # if YYDEBUG == 1 <S2SV_EndBug> yydebug = 1 ; # endif if ( argc <= 1 ) { printf ( "you<S2SV_blank>must<S2SV_blank>input<S2SV_blank>file!\\n" ) ; return 1 ; } if ( init_buffer ( ) ) { return 1 ; } for ( i = 1 ; i < argc ; i ++ ) { if ( strcmp ( argv [ i ] , "-debug" ) == 0 ) { printf ( "debugging<S2SV_blank>activated\\n" ) ; debug = 1 ; <S2SV_StartBug> } <S2SV_EndBug> else { lexical_init ( ) ; syntax_init ( ) ; curpwd = malloc ( sizeof ( char ) * strlen ( argv [ i ] ) ) ; getpwd ( curpwd , argv [ i ] ) ; if ( newfile ( argv [ i ] ) ) { fprintf ( stderr , "newfile(%s)<S2SV_blank>error!\\n" , argv [ i ] ) ; continue ; } else { if ( getNextLine ( ) == 0 ) yyparse ( ) ; free ( curpwd ) ; } } } free_buffer ( ) ; return 0 ; } | <S2SV_ModStart> int i ; <S2SV_ModEnd> if ( argc <S2SV_ModStart> 1 ; } else if ( strcmp ( argv [ i ] , "-yydebug" ) == 0 ) { printf ( "yydebug<S2SV_blank>activated\\n" ) ; yydebug = 1 ; } |
4,987 | CWE-000 EipStatus HandleDataOnTcpSocket ( int socket ) { OPENER_TRACE_INFO ( "Entering<S2SV_blank>HandleDataOnTcpSocket<S2SV_blank>for<S2SV_blank>socket:<S2SV_blank>%d\\n" , socket ) ; int remaining_bytes = 0 ; long data_sent = PC_OPENER_ETHERNET_BUFFER_SIZE ; long number_of_read_bytes = recv ( socket , g_ethernet_communication_buffer , 4 , 0 ) ; SocketTimer * socket_timer = SocketTimerArrayGetSocketTimer ( g_timestamps , OPENER_NUMBER_OF_SUPPORTED_SESSIONS , socket ) ; if ( number_of_read_bytes == 0 ) { int error_code = GetSocketErrorNumber ( ) ; char * error_message = GetErrorMessage ( error_code ) ; OPENER_TRACE_ERR ( "networkhandler:<S2SV_blank>socket:<S2SV_blank>%d<S2SV_blank>-<S2SV_blank>connection<S2SV_blank>closed<S2SV_blank>by<S2SV_blank>client:<S2SV_blank>%d<S2SV_blank>-<S2SV_blank>%s\\n" , socket , error_code , error_message ) ; FreeErrorMessage ( error_message ) ; RemoveSocketTimerFromList ( socket ) ; RemoveSession ( socket ) ; return kEipStatusError ; } if ( number_of_read_bytes < 0 ) { int error_code = GetSocketErrorNumber ( ) ; if ( OPENER_SOCKET_WOULD_BLOCK == error_code ) { return kEipStatusOk ; } char * error_message = GetErrorMessage ( error_code ) ; OPENER_TRACE_ERR ( "networkhandler:<S2SV_blank>error<S2SV_blank>on<S2SV_blank>recv:<S2SV_blank>%d<S2SV_blank>-<S2SV_blank>%s\\n" , error_code , error_message ) ; FreeErrorMessage ( error_message ) ; return kEipStatusError ; } const EipUint8 * read_buffer = & g_ethernet_communication_buffer [ 2 ] ; size_t data_size = GetIntFromMessage ( & read_buffer ) + ENCAPSULATION_HEADER_LENGTH - 4 ; if ( ( PC_OPENER_ETHERNET_BUFFER_SIZE - 4 ) < data_size ) { OPENER_TRACE_ERR ( "too<S2SV_blank>large<S2SV_blank>packet<S2SV_blank>received<S2SV_blank>will<S2SV_blank>be<S2SV_blank>ignored,<S2SV_blank>will<S2SV_blank>drop<S2SV_blank>the<S2SV_blank>data\\n" ) ; do { OPENER_TRACE_INFO ( "Entering<S2SV_blank>consumption<S2SV_blank>loop,<S2SV_blank>remaining<S2SV_blank>data<S2SV_blank>to<S2SV_blank>receive:<S2SV_blank>%zu\\n" , data_sent ) ; number_of_read_bytes = recv ( socket , & g_ethernet_communication_buffer [ 0 ] , data_sent , 0 ) ; if ( number_of_read_bytes == 0 ) { int error_code = GetSocketErrorNumber ( ) ; char * error_message = GetErrorMessage ( error_code ) ; OPENER_TRACE_ERR ( "networkhandler:<S2SV_blank>socket:<S2SV_blank>%d<S2SV_blank>-<S2SV_blank>connection<S2SV_blank>closed<S2SV_blank>by<S2SV_blank>client:<S2SV_blank>%d<S2SV_blank>-<S2SV_blank>%s\\n" , socket , error_code , error_message ) ; FreeErrorMessage ( error_message ) ; RemoveSocketTimerFromList ( socket ) ; return kEipStatusError ; } if ( number_of_read_bytes < 0 ) { int error_code = GetSocketErrorNumber ( ) ; char * error_message = GetErrorMessage ( error_code ) ; if ( OPENER_SOCKET_WOULD_BLOCK == error_code ) { return kEipStatusOk ; } OPENER_TRACE_ERR ( "networkhandler:<S2SV_blank>error<S2SV_blank>on<S2SV_blank>recv:<S2SV_blank>%d<S2SV_blank>-<S2SV_blank>%s\\n" , error_code , error_message ) ; FreeErrorMessage ( error_message ) ; return kEipStatusError ; } data_size -= number_of_read_bytes ; if ( ( data_size < PC_OPENER_ETHERNET_BUFFER_SIZE ) && ( data_size != 0 ) ) { data_sent = data_size ; } } while ( 0 < data_size ) ; SocketTimerSetLastUpdate ( socket_timer , g_actual_time ) ; OPENER_ASSERT ( 0 <= data_size ) ; return kEipStatusOk ; } number_of_read_bytes = recv ( socket , & g_ethernet_communication_buffer [ 4 ] , data_size , 0 ) ; if ( 0 == number_of_read_bytes ) { int error_code = GetSocketErrorNumber ( ) ; char * error_message = GetErrorMessage ( error_code ) ; OPENER_TRACE_ERR ( "networkhandler:<S2SV_blank>socket:<S2SV_blank>%d<S2SV_blank>-<S2SV_blank>connection<S2SV_blank>closed<S2SV_blank>by<S2SV_blank>client:<S2SV_blank>%d<S2SV_blank>-<S2SV_blank>%s\\n" , socket , error_code , error_message ) ; FreeErrorMessage ( error_message ) ; RemoveSocketTimerFromList ( socket ) ; RemoveSession ( socket ) ; return kEipStatusError ; } if ( number_of_read_bytes < 0 ) { int error_code = GetSocketErrorNumber ( ) ; char * error_message = GetErrorMessage ( error_code ) ; if ( OPENER_SOCKET_WOULD_BLOCK == error_code ) { return kEipStatusOk ; } OPENER_TRACE_ERR ( "networkhandler:<S2SV_blank>error<S2SV_blank>on<S2SV_blank>recv:<S2SV_blank>%d<S2SV_blank>-<S2SV_blank>%s\\n" , error_code , error_message ) ; FreeErrorMessage ( error_message ) ; return kEipStatusError ; } if ( ( unsigned ) number_of_read_bytes == data_size ) { data_size += 4 ; OPENER_TRACE_INFO ( "Data<S2SV_blank>received<S2SV_blank>on<S2SV_blank>tcp:\\n" ) ; g_current_active_tcp_socket = socket ; struct sockaddr sender_address ; memset ( & sender_address , 0 , sizeof ( sender_address ) ) ; socklen_t fromlen = sizeof ( sender_address ) ; <S2SV_StartBug> getpeername ( socket , ( struct sockaddr * ) & sender_address , & fromlen ) ; <S2SV_EndBug> number_of_read_bytes = HandleReceivedExplictTcpData ( socket , g_ethernet_communication_buffer , data_size , & remaining_bytes , & sender_address ) ; SocketTimer * socket_timer = SocketTimerArrayGetSocketTimer ( g_timestamps , OPENER_NUMBER_OF_SUPPORTED_SESSIONS , socket ) ; if ( NULL != socket_timer ) { SocketTimerSetLastUpdate ( socket_timer , g_actual_time ) ; } g_current_active_tcp_socket = kEipInvalidSocket ; if ( remaining_bytes != 0 ) { OPENER_TRACE_WARN ( "Warning:<S2SV_blank>received<S2SV_blank>packet<S2SV_blank>was<S2SV_blank>to<S2SV_blank>long:<S2SV_blank>%d<S2SV_blank>Bytes<S2SV_blank>left!\\n" , remaining_bytes ) ; } if ( number_of_read_bytes > 0 ) { OPENER_TRACE_INFO ( "TCP<S2SV_blank>reply<S2SV_blank>sent:\\n" ) ; data_sent = send ( socket , ( char * ) & g_ethernet_communication_buffer [ 0 ] , number_of_read_bytes , 0 ) ; SocketTimer * socket_timer = SocketTimerArrayGetSocketTimer ( g_timestamps , OPENER_NUMBER_OF_SUPPORTED_SESSIONS , socket ) ; SocketTimerSetLastUpdate ( socket_timer , g_actual_time ) ; if ( data_sent != number_of_read_bytes ) { OPENER_TRACE_WARN ( "TCP<S2SV_blank>response<S2SV_blank>was<S2SV_blank>not<S2SV_blank>fully<S2SV_blank>sent\\n" ) ; } } return kEipStatusOk ; } else { } return kEipStatusError ; } | <S2SV_ModStart> sender_address ) ; if ( <S2SV_ModStart> & fromlen ) < 0 ) { int error_code = GetSocketErrorNumber ( ) ; char * error_message = GetErrorMessage ( error_code ) ; OPENER_TRACE_ERR ( "networkhandler:<S2SV_blank>could<S2SV_blank>not<S2SV_blank>get<S2SV_blank>peername:<S2SV_blank>%d<S2SV_blank>-<S2SV_blank>%s\\n" , error_code , error_message ) ; FreeErrorMessage ( error_message ) ; } <S2SV_ModEnd> number_of_read_bytes = HandleReceivedExplictTcpData |
4,988 | CWE-000 int main ( int argc , const char * argv [ ] ) { <S2SV_StartBug> for ( int i = 0 ; i < TEST_ARG_COUNT ; i ++ ) { <S2SV_EndBug> <S2SV_StartBug> my_setenv ( "DYNAMORIO_OPTIONS" , test_args [ i ] . input_dynamorio_options ) ; <S2SV_EndBug> dr_app_setup ( ) ; dr_app_start ( ) ; dr_app_stop_and_cleanup ( ) ; if ( last_argv [ 0 ] == '\\0' ) { print ( "ERROR:<S2SV_blank>last_argv<S2SV_blank>not<S2SV_blank>set<S2SV_blank>by<S2SV_blank>dr_client_main" ) ; return 1 ; } const char * want_argv = test_args [ i ] . want_argv ; if ( strncmp ( last_argv , want_argv , sizeof ( last_argv ) ) != 0 ) { print ( "ERROR:<S2SV_blank>last_argv<S2SV_blank>doesn\'t<S2SV_blank>match<S2SV_blank>want_argv:<S2SV_blank>" "got<S2SV_blank>|%s|,<S2SV_blank>want<S2SV_blank>|%s|" , last_argv , want_argv ) ; return 1 ; } print ( "Found<S2SV_blank>the<S2SV_blank>appropriate<S2SV_blank>argv\\n" ) ; memset ( last_argv , 0 , sizeof last_argv ) ; } print ( "all<S2SV_blank>done\\n" ) ; return 0 ; } | <S2SV_ModStart> ] ) { # define BUF_LEN 256 char original_options [ BUF_LEN ] ; my_getenv ( "DYNAMORIO_OPTIONS" , original_options , BUF_LEN ) ; <S2SV_ModStart> ++ ) { char option_buffer [ BUF_LEN ] ; strncpy ( option_buffer , original_options , BUF_LEN ) ; strncat ( option_buffer <S2SV_ModEnd> , test_args [ <S2SV_ModStart> ] . input_dynamorio_options , BUF_LEN ) ; my_setenv ( "DYNAMORIO_OPTIONS" , option_buffer |
4,989 | CWE-000 int nmea_send_msg ( struct nmea_if * nmea_if , struct nmea_msg * sending_msg ) { struct nmea_msg * msg ; int rc ; cli ( ) ; msg = get_empty_frm ( nmea_if , 1 ) ; sei ( ) ; <S2SV_StartBug> if ( ! msg ) <S2SV_EndBug> <S2SV_StartBug> return - ENOSPC ; <S2SV_EndBug> rc = build_nmea_msg ( sending_msg , msg -> msg_buf ) ; if ( rc ) <S2SV_StartBug> return rc ; <S2SV_EndBug> msg -> buf_len = strlen ( msg -> msg_buf ) ; cli ( ) ; msg -> ready = 1 ; if ( ! nmea_if -> tx_running ) nmea_transmitter ( nmea_if ) ; sei ( ) ; return 0 ; } | <S2SV_ModStart> ! msg ) { nmea_if -> cnt_tx_ring_overflow ++ ; <S2SV_ModStart> - ENOSPC ; } <S2SV_ModStart> ) return rc ; printf ( "msg->msg_buf<S2SV_blank>=<S2SV_blank>%s\\r\\n" , msg -> msg_buf ) |
4,990 | CWE-000 int aa_new_mount ( struct aa_label * label , const char * orig_dev_name , struct path * path , const char * type , unsigned long flags , void * data ) { struct aa_profile * profile ; char * buffer = NULL , * dev_buffer = NULL ; const char * name = NULL , * dev_name = NULL , * info = NULL ; bool binary = true ; int error ; int requires_dev = 0 ; struct path dev_path ; AA_BUG ( ! label ) ; AA_BUG ( ! path ) ; dev_name = orig_dev_name ; if ( type ) { struct file_system_type * fstype ; fstype = get_fs_type ( type ) ; if ( ! fstype ) return - ENODEV ; binary = fstype -> fs_flags & FS_BINARY_MOUNTDATA ; requires_dev = fstype -> fs_flags & FS_REQUIRES_DEV ; put_filesystem ( fstype ) ; if ( requires_dev ) { if ( ! dev_name || ! * dev_name ) return - ENOENT ; error = kern_path ( dev_name , LOOKUP_FOLLOW , & dev_path ) ; if ( error ) return error ; } } get_buffers ( buffer , dev_buffer ) ; if ( type && requires_dev ) { error = aa_path_name ( & dev_path , path_flags ( labels_profile ( label ) , & dev_path ) , dev_buffer , & dev_name , & info , labels_profile ( label ) -> disconnected ) ; <S2SV_StartBug> if ( error ) <S2SV_EndBug> goto error ; } error = aa_path_name ( path , path_flags ( labels_profile ( label ) , path ) , buffer , & name , & info , labels_profile ( label ) -> disconnected ) ; if ( error ) goto error ; error = fn_for_each_confined ( label , profile , match_mnt ( profile , name , dev_name , type , flags , data , binary ) ) ; cleanup : put_buffers ( buffer , dev_buffer ) ; <S2SV_StartBug> if ( requires_dev ) <S2SV_EndBug> path_put ( & dev_path ) ; return error ; error : error = fn_for_each ( label , profile , audit_mount ( labels_profile ( label ) , OP_MOUNT , name , dev_name , type , NULL , flags , data , AA_MAY_MOUNT , & nullperms , info , error ) ) ; goto cleanup ; } | <S2SV_ModStart> disconnected ) ; path_put ( & dev_path ) ; <S2SV_ModStart> dev_buffer ) ; <S2SV_ModEnd> return error ; |
4,991 | CWE-000 void bandwidth_pid ( pid_t pid , const char * command , const char * dev , int down , int up ) { EUID_ASSERT ( ) ; EUID_ROOT ( ) ; char * comm = pid_proc_comm ( pid ) ; EUID_USER ( ) ; if ( ! comm ) { fprintf ( stderr , "Error:<S2SV_blank>cannot<S2SV_blank>find<S2SV_blank>sandbox\\n" ) ; exit ( 1 ) ; } if ( strcmp ( comm , "firejail" ) != 0 ) { fprintf ( stderr , "Error:<S2SV_blank>cannot<S2SV_blank>find<S2SV_blank>sandbox\\n" ) ; exit ( 1 ) ; } free ( comm ) ; char * name ; if ( asprintf ( & name , "/run/firejail/network/%d-netmap" , pid ) == - 1 ) errExit ( "asprintf" ) ; struct stat s ; if ( stat ( name , & s ) == - 1 ) { fprintf ( stderr , "Error:<S2SV_blank>the<S2SV_blank>sandbox<S2SV_blank>doesn\'t<S2SV_blank>use<S2SV_blank>a<S2SV_blank>new<S2SV_blank>network<S2SV_blank>namespace\\n" ) ; exit ( 1 ) ; } pid_t child ; if ( find_child ( pid , & child ) == 1 ) { fprintf ( stderr , "Error:<S2SV_blank>cannot<S2SV_blank>join<S2SV_blank>the<S2SV_blank>network<S2SV_blank>namespace\\n" ) ; exit ( 1 ) ; } if ( invalid_sandbox ( child ) ) { fprintf ( stderr , "Error:<S2SV_blank>cannot<S2SV_blank>join<S2SV_blank>the<S2SV_blank>network<S2SV_blank>namespace\\n" ) ; exit ( 1 ) ; } uid_t uid = getuid ( ) ; if ( uid != 0 ) { uid_t sandbox_uid = pid_get_uid ( pid ) ; if ( uid != sandbox_uid ) { fprintf ( stderr , "Error:<S2SV_blank>permission<S2SV_blank>is<S2SV_blank>denied<S2SV_blank>to<S2SV_blank>join<S2SV_blank>a<S2SV_blank>sandbox<S2SV_blank>created<S2SV_blank>by<S2SV_blank>a<S2SV_blank>different<S2SV_blank>user.\\n" ) ; exit ( 1 ) ; } } EUID_ROOT ( ) ; if ( join_namespace ( child , "net" ) ) { fprintf ( stderr , "Error:<S2SV_blank>cannot<S2SV_blank>join<S2SV_blank>the<S2SV_blank>network<S2SV_blank>namespace\\n" ) ; exit ( 1 ) ; } if ( strcmp ( command , "set" ) == 0 ) bandwidth_set ( pid , dev , down , up ) ; else if ( strcmp ( command , "clear" ) == 0 ) bandwidth_remove ( pid , dev ) ; char * devname = NULL ; if ( dev ) { char * fname ; if ( asprintf ( & fname , "%s/%d-netmap" , RUN_FIREJAIL_NETWORK_DIR , ( int ) pid ) == - 1 ) errExit ( "asprintf" ) ; FILE * fp = fopen ( fname , "r" ) ; if ( ! fp ) { fprintf ( stderr , "Error:<S2SV_blank>cannot<S2SV_blank>read<S2SV_blank>network<S2SV_blank>map<S2SV_blank>file<S2SV_blank>%s\\n" , fname ) ; exit ( 1 ) ; } char buf [ 1024 ] ; int len = strlen ( dev ) ; while ( fgets ( buf , 1024 , fp ) ) { char * ptr = strchr ( buf , '\\n' ) ; if ( ptr ) * ptr = '\\0' ; if ( * buf == '\\0' ) break ; if ( strncmp ( buf , dev , len ) == 0 && buf [ len ] == ':' ) { devname = strdup ( buf + len + 1 ) ; if ( ! devname ) errExit ( "strdup" ) ; if ( if_nametoindex ( devname ) == 0 ) { fprintf ( stderr , "Error:<S2SV_blank>cannot<S2SV_blank>find<S2SV_blank>network<S2SV_blank>device<S2SV_blank>%s\\n" , devname ) ; exit ( 1 ) ; } break ; } } free ( fname ) ; fclose ( fp ) ; } char * cmd = NULL ; if ( devname ) { if ( strcmp ( command , "set" ) == 0 ) { if ( asprintf ( & cmd , "%s/firejail/fshaper.sh<S2SV_blank>--%s<S2SV_blank>%s<S2SV_blank>%d<S2SV_blank>%d" , <S2SV_StartBug> LIBDIR , command , devname , down , up ) == - 1 ) <S2SV_EndBug> errExit ( "asprintf" ) ; } else { if ( asprintf ( & cmd , "%s/firejail/fshaper.sh<S2SV_blank>--%s<S2SV_blank>%s" , <S2SV_StartBug> LIBDIR , command , devname ) == - 1 ) <S2SV_EndBug> errExit ( "asprintf" ) ; } } else { <S2SV_StartBug> if ( asprintf ( & cmd , "%s/firejail/fshaper.sh<S2SV_blank>--%s" , LIBDIR , command ) == - 1 ) <S2SV_EndBug> errExit ( "asprintf" ) ; } assert ( cmd ) ; environ = NULL ; if ( setreuid ( 0 , 0 ) ) errExit ( "setreuid" ) ; if ( setregid ( 0 , 0 ) ) errExit ( "setregid" ) ; char * arg [ 4 ] ; arg [ 0 ] = "/bin/sh" ; arg [ 1 ] = "-c" ; arg [ 2 ] = cmd ; arg [ 3 ] = NULL ; clearenv ( ) ; execvp ( arg [ 0 ] , arg ) ; errExit ( "execvp" ) ; } | <S2SV_ModStart> , "%s/firejail/fshaper.sh<S2SV_blank>--%s<S2SV_blank>%s<S2SV_blank>%d<S2SV_blank>%d" , RUN_FIREJAIL_LIB_DIR <S2SV_ModEnd> , command , <S2SV_ModStart> , "%s/firejail/fshaper.sh<S2SV_blank>--%s<S2SV_blank>%s" , RUN_FIREJAIL_LIB_DIR <S2SV_ModEnd> , command , <S2SV_ModStart> , "%s/firejail/fshaper.sh<S2SV_blank>--%s" , RUN_FIREJAIL_LIB_DIR <S2SV_ModEnd> , command ) |
4,992 | CWE-000 static bool <S2SV_StartBug> hidrd_hex_snk_init ( hidrd_snk * snk , char * * perr ) <S2SV_EndBug> { hidrd_hex_snk_inst * hex_snk = ( hidrd_hex_snk_inst * ) snk ; <S2SV_StartBug> hidrd_buf_init ( & hex_snk -> buf ) ; <S2SV_EndBug> hex_snk -> bytes = 0 ; hex_snk -> err = HIDRD_HEX_SNK_ERR_NONE ; if ( perr != NULL ) * perr = strdup ( "" ) ; return true ; } | <S2SV_ModStart> * * perr , size_t width <S2SV_ModStart> -> buf ) ; hex_snk -> width = width |
4,993 | CWE-000 static void draw_led ( led_t * l ) <S2SV_StartBug> { <S2SV_EndBug> double msz = l -> radius * 0.75 ; double off = ( l -> radius - msz ) / 2.0 ; draw_rectangle_filled ( l -> x + off , l -> y + off , msz , msz , l -> on ? GREEN : RED ) ; draw_rectangle_filled ( l -> x , l -> y , l -> radius , l -> radius , BLUE ) ; } | <S2SV_ModStart> l ) { assert ( l ) ; |
4,994 | CWE-000 static void testSCPI_ParamUInt32 ( void ) { TEST_ParamUInt32 ( "10" , TRUE , 10 , TRUE , 0 ) ; TEST_ParamUInt32 ( "" , FALSE , 0 , FALSE , 0 ) ; TEST_ParamUInt32 ( "10.5" , TRUE , 10 , TRUE , 0 ) ; TEST_ParamUInt32 ( "#B101010" , TRUE , 42 , TRUE , 0 ) ; TEST_ParamUInt32 ( "#H101010" , TRUE , 1052688 , TRUE , 0 ) ; TEST_ParamUInt32 ( "#Q10" , TRUE , 8 , TRUE , 0 ) ; TEST_ParamUInt32 ( "" , TRUE , 0 , FALSE , - 109 ) ; TEST_ParamUInt32 ( "abcd" , TRUE , 0 , FALSE , - 104 ) ; TEST_ParamUInt32 ( "10.5V" , TRUE , 0 , FALSE , - 138 ) ; TEST_ParamUInt32 ( "10V" , TRUE , 0 , FALSE , - 138 ) ; <S2SV_StartBug> TEST_ParamUInt32 ( "2147483647" , TRUE , 2147483647 , TRUE , 0 ) ; <S2SV_EndBug> <S2SV_StartBug> TEST_ParamUInt32 ( "4294967295" , TRUE , 4294967295 , TRUE , 0 ) ; <S2SV_EndBug> } | <S2SV_ModStart> , TRUE , 2147483647ULL <S2SV_ModEnd> , TRUE , <S2SV_ModStart> , TRUE , 4294967295ULL <S2SV_ModEnd> , TRUE , |
4,995 | CWE-000 static void bfq_set_next_ioprio_data ( struct bfq_queue * bfqq , struct bfq_io_cq * bic ) { struct task_struct * tsk = current ; int ioprio_class ; ioprio_class = IOPRIO_PRIO_CLASS ( bic -> ioprio ) ; switch ( ioprio_class ) { default : <S2SV_StartBug> dev_err ( bfqq -> bfqd -> queue -> backing_dev_info . dev , <S2SV_EndBug> "bfq:<S2SV_blank>bad<S2SV_blank>prio<S2SV_blank>class<S2SV_blank>%d\\n" , ioprio_class ) ; case IOPRIO_CLASS_NONE : bfqq -> new_ioprio = task_nice_ioprio ( tsk ) ; bfqq -> new_ioprio_class = task_nice_ioclass ( tsk ) ; break ; case IOPRIO_CLASS_RT : bfqq -> new_ioprio = IOPRIO_PRIO_DATA ( bic -> ioprio ) ; bfqq -> new_ioprio_class = IOPRIO_CLASS_RT ; break ; case IOPRIO_CLASS_BE : bfqq -> new_ioprio = IOPRIO_PRIO_DATA ( bic -> ioprio ) ; bfqq -> new_ioprio_class = IOPRIO_CLASS_BE ; break ; case IOPRIO_CLASS_IDLE : bfqq -> new_ioprio_class = IOPRIO_CLASS_IDLE ; bfqq -> new_ioprio = 7 ; bfq_clear_bfqq_idle_window ( bfqq ) ; break ; } if ( bfqq -> new_ioprio < 0 || bfqq -> new_ioprio >= IOPRIO_BE_NR ) { printk ( KERN_CRIT "bfq_set_next_ioprio_data:<S2SV_blank>new_ioprio<S2SV_blank>%d\\n" , bfqq -> new_ioprio ) ; BUG ( ) ; } bfqq -> entity . new_weight = bfq_ioprio_to_weight ( bfqq -> new_ioprio ) ; bfqq -> entity . prio_changed = 1 ; } | <S2SV_ModStart> queue -> backing_dev_info -> <S2SV_ModEnd> dev , "bfq:<S2SV_blank>bad<S2SV_blank>prio<S2SV_blank>class<S2SV_blank>%d\\n" |
4,996 | CWE-000 <S2SV_StartBug> int <S2SV_EndBug> vr_v6_fragment_add ( struct vrouter * router , unsigned short vrf , struct vr_ip6 * ip6 , unsigned short sport , unsigned short dport ) { uint64_t * v6_addr ; struct vr_fragment_key key ; struct vr_ip6_frag * v6_frag ; v6_addr = ( uint64_t * ) ( ip6 -> ip6_src ) ; v6_frag = ( struct vr_ip6_frag * ) ( ip6 + 1 ) ; __fragment_key ( & key , vrf , * v6_addr , * ( v6_addr + 1 ) , * ( v6_addr + 2 ) , * ( v6_addr + 3 ) , v6_frag -> ip6_frag_id ) ; <S2SV_StartBug> return vr_fragment_add ( router , & key , sport , dport , <S2SV_EndBug> ( ntohs ( ip6 -> ip6_plen ) - sizeof ( struct vr_ip6_frag ) ) ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static <S2SV_ModStart> ) ; return __vr_fragment_add <S2SV_ModEnd> ( router , |
4,997 | CWE-000 static PyArray_Descr * _convert_from_array_descr ( PyObject * obj , int align ) { int n , i , totalsize ; int ret ; PyObject * fields , * item , * newobj ; PyObject * name , * tup , * title ; PyObject * nameslist ; PyArray_Descr * new ; PyArray_Descr * conv ; char dtypeflags = NPY_NEEDS_PYAPI ; int maxalign = 0 ; n = PyList_GET_SIZE ( obj ) ; nameslist = PyTuple_New ( n ) ; if ( ! nameslist ) { return NULL ; } totalsize = 0 ; fields = PyDict_New ( ) ; for ( i = 0 ; i < n ; i ++ ) { item = PyList_GET_ITEM ( obj , i ) ; if ( ! PyTuple_Check ( item ) || ( PyTuple_GET_SIZE ( item ) < 2 ) ) { goto fail ; } name = PyTuple_GET_ITEM ( item , 0 ) ; if ( PyBaseString_Check ( name ) ) { title = NULL ; } else if ( PyTuple_Check ( name ) ) { if ( PyTuple_GET_SIZE ( name ) != 2 ) { goto fail ; } title = PyTuple_GET_ITEM ( name , 0 ) ; name = PyTuple_GET_ITEM ( name , 1 ) ; if ( ! PyBaseString_Check ( name ) ) { goto fail ; } } else { goto fail ; } Py_INCREF ( name ) ; # if ! defined ( NPY_PY3K ) if ( PyUnicode_Check ( name ) ) { PyObject * tmp = PyUnicode_AsASCIIString ( name ) ; Py_DECREF ( name ) ; if ( tmp == NULL ) { goto fail ; } name = tmp ; } # endif if ( PyUString_GET_SIZE ( name ) == 0 ) { Py_DECREF ( name ) ; if ( title == NULL ) { name = PyUString_FromFormat ( "f%d" , i ) ; } # if defined ( NPY_PY3K ) else if ( PyUString_Check ( title ) && PyUString_GET_SIZE ( title ) > 0 ) { name = title ; Py_INCREF ( name ) ; } else { goto fail ; } # else else { name = title ; Py_INCREF ( name ) ; } # endif } PyTuple_SET_ITEM ( nameslist , i , name ) ; if ( PyTuple_GET_SIZE ( item ) == 2 ) { if ( align ) { ret = PyArray_DescrAlignConverter ( PyTuple_GET_ITEM ( item , 1 ) , & conv ) ; } else { ret = PyArray_DescrConverter ( PyTuple_GET_ITEM ( item , 1 ) , & conv ) ; } if ( ret == NPY_FAIL ) { PyObject_Print ( PyTuple_GET_ITEM ( item , 1 ) , stderr , 0 ) ; } } else if ( PyTuple_GET_SIZE ( item ) == 3 ) { newobj = PyTuple_GetSlice ( item , 1 , 3 ) ; if ( align ) { ret = PyArray_DescrAlignConverter ( newobj , & conv ) ; } else { ret = PyArray_DescrConverter ( newobj , & conv ) ; } Py_DECREF ( newobj ) ; } else { goto fail ; } if ( ret == NPY_FAIL ) { goto fail ; } if ( ( PyDict_GetItem ( fields , name ) != NULL ) || ( title && PyBaseString_Check ( title ) && ( PyDict_GetItem ( fields , title ) != NULL ) ) ) { # if defined ( NPY_PY3K ) name = PyUnicode_AsUTF8String ( name ) ; # endif PyErr_Format ( PyExc_ValueError , "field<S2SV_blank>\'%s\'<S2SV_blank>occurs<S2SV_blank>more<S2SV_blank>than<S2SV_blank>once" , PyString_AsString ( name ) ) ; # if defined ( NPY_PY3K ) Py_DECREF ( name ) ; <S2SV_StartBug> # endif <S2SV_EndBug> goto fail ; } dtypeflags |= ( conv -> flags & NPY_FROM_FIELDS ) ; if ( align ) { int _align ; _align = conv -> alignment ; if ( _align > 1 ) { totalsize = NPY_NEXT_ALIGNED_OFFSET ( totalsize , _align ) ; } maxalign = PyArray_MAX ( maxalign , _align ) ; } tup = PyTuple_New ( ( title == NULL ? 2 : 3 ) ) ; PyTuple_SET_ITEM ( tup , 0 , ( PyObject * ) conv ) ; PyTuple_SET_ITEM ( tup , 1 , PyInt_FromLong ( ( long ) totalsize ) ) ; if ( title != NULL ) { Py_INCREF ( title ) ; PyTuple_SET_ITEM ( tup , 2 , title ) ; PyDict_SetItem ( fields , name , tup ) ; if ( PyBaseString_Check ( title ) ) { if ( PyDict_GetItem ( fields , title ) != NULL ) { PyErr_SetString ( PyExc_ValueError , "title<S2SV_blank>already<S2SV_blank>used<S2SV_blank>as<S2SV_blank>a<S2SV_blank>name<S2SV_blank>or<S2SV_blank>title." ) ; Py_DECREF ( tup ) ; goto fail ; } PyDict_SetItem ( fields , title , tup ) ; } } else { PyDict_SetItem ( fields , name , tup ) ; } totalsize += conv -> elsize ; Py_DECREF ( tup ) ; } if ( maxalign > 1 ) { totalsize = NPY_NEXT_ALIGNED_OFFSET ( totalsize , maxalign ) ; } new = PyArray_DescrNewFromType ( NPY_VOID ) ; if ( new == NULL ) { Py_XDECREF ( fields ) ; Py_XDECREF ( nameslist ) ; return NULL ; } new -> fields = fields ; new -> names = nameslist ; new -> elsize = totalsize ; new -> flags = dtypeflags ; if ( align ) { new -> flags |= NPY_ALIGNED_STRUCT ; new -> alignment = maxalign ; } return new ; fail : Py_DECREF ( fields ) ; Py_DECREF ( nameslist ) ; return NULL ; } | <S2SV_ModStart> ; # endif Py_DECREF ( conv ) ; |
4,998 | CWE-000 void vStartPolledQueueTasks ( unsigned portBASE_TYPE uxPriority ) { <S2SV_StartBug> static xQueueHandle xPolledQueue ; <S2SV_EndBug> const unsigned portBASE_TYPE uxQueueSize = 10 ; xPolledQueue = xQueueCreate ( uxQueueSize , ( unsigned portBASE_TYPE ) sizeof ( unsigned short ) ) ; xTaskCreate ( vPolledQueueConsumer , "QConsNB" , pollqSTACK_SIZE , ( void * ) & xPolledQueue , uxPriority , NULL ) ; xTaskCreate ( vPolledQueueProducer , "QProdNB" , pollqSTACK_SIZE , ( void * ) & xPolledQueue , uxPriority , NULL ) ; } | <S2SV_ModStart> ) { static QueueHandle_t <S2SV_ModEnd> xPolledQueue ; const |
4,999 | CWE-000 static ssize_t mod_read ( void const * instance , void * * packet_ctx , uint8_t * buffer , size_t buffer_len ) { <S2SV_StartBug> fr_proto_radius_udp_t const * inst = talloc_get_type_abort ( instance , fr_proto_radius_udp_t ) ; <S2SV_EndBug> ssize_t data_size ; size_t packet_len ; decode_fail_t reason ; struct timeval timestamp ; fr_tracking_status_t tracking_status ; fr_tracking_entry_t * track ; fr_udp_src_dst_t src_dst ; data_size = udp_recv ( inst -> sockfd , buffer , buffer_len , 0 , & src_dst . src_ipaddr , & src_dst . src_port , & src_dst . dst_ipaddr , & src_dst . dst_port , & src_dst . if_index , & timestamp ) ; if ( data_size <= 0 ) return data_size ; packet_len = data_size ; if ( ! fr_radius_ok ( buffer , & packet_len , false , & reason ) ) { return 0 ; } src_dst . timestamp = fr_time ( ) ; if ( fr_radius_verify ( buffer , NULL , ( uint8_t const * ) inst -> dummy_client -> secret , talloc_array_length ( inst -> dummy_client -> secret ) ) < 0 ) { return 0 ; } src_dst . client = inst -> dummy_client ; tracking_status = fr_radius_tracking_entry_insert ( inst -> ft , buffer , src_dst . timestamp , & src_dst , & track ) ; switch ( tracking_status ) { case FR_TRACKING_ERROR : case FR_TRACKING_UNUSED : return - 1 ; case FR_TRACKING_SAME : return 0 ; case FR_TRACKING_NEW : case FR_TRACKING_DIFFERENT : break ; } * packet_ctx = track ; return packet_len ; } | <S2SV_ModStart> buffer_len ) { proto_radius_udp_t <S2SV_ModEnd> const * inst <S2SV_ModStart> ( instance , proto_radius_udp_t <S2SV_ModEnd> ) ; ssize_t |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.