Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
534,600 |
CWE-000 <S2SV_StartBug> int serial_read ( uint32_t sercom ) { <S2SV_EndBug> <S2SV_StartBug> int data = - 1 ; <S2SV_EndBug> if ( ioread8 ( sercom + USART_INTFLAG ) & INTFLAG_RXC ) { data = ioread16 ( sercom + USART_DATA ) ; } <S2SV_StartBug> return data ; <S2SV_EndBug> }
|
<S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> uint8_t <S2SV_ModEnd> serial_read ( uint32_t <S2SV_ModStart> sercom ) { return <S2SV_ModEnd> ioread16 ( sercom <S2SV_ModStart> ) ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null>
|
534,601 |
CWE-000 static JSON_Value * parse_number_value ( const char * * string ) { char * end ; double number = 0 ; # ifdef JSON_FIXED_NUMBER intmax_t fixed ; errno = 0 ; fixed = strtoimax ( * string , & end , 10 ) ; <S2SV_StartBug> if ( errno == 0 && INT64_MIN <= fixed && fixed <= INT64_MAX ) { <S2SV_EndBug> * string = end ; return json_value_init_fixed ( fixed ) ; } # endif errno = 0 ; number = strtod ( * string , & end ) ; if ( errno || ! is_decimal ( * string , end - * string ) ) { return NULL ; } * string = end ; return json_value_init_number ( number ) ; }
|
<S2SV_ModStart> fixed <= INT64_MAX && end != NULL && ( * end == 0x00 || ( * end != '.' && * end != 'e' && * end != 'E' ) )
|
534,602 |
CWE-000 int shard_common_mknod_cbk ( call_frame_t * frame , void * cookie , xlator_t * this , int32_t op_ret , int32_t op_errno , inode_t * inode , struct iatt * buf , struct iatt * preparent , struct iatt * postparent , dict_t * xdata ) { int shard_block_num = ( long ) cookie ; int call_count = 0 ; shard_local_t * local = NULL ; local = frame -> local ; if ( op_ret < 0 ) { if ( op_errno == EEXIST ) { <S2SV_StartBug> local -> eexist_count ++ ; <S2SV_EndBug> <S2SV_StartBug> } else { <S2SV_EndBug> local -> op_ret = op_ret ; local -> op_errno = op_errno ; } gf_msg_debug ( this -> name , 0 , "mknod<S2SV_blank>of<S2SV_blank>shard<S2SV_blank>%d<S2SV_blank>" "failed:<S2SV_blank>%s" , shard_block_num , strerror ( op_errno ) ) ; goto done ; } shard_link_block_inode ( local , shard_block_num , inode , buf ) ; done : call_count = shard_call_count_return ( frame ) ; if ( call_count == 0 ) { SHARD_UNSET_ROOT_FS_ID ( frame , local ) ; local -> create_count = 0 ; local -> post_mknod_handler ( frame , this ) ; } return 0 ; }
|
<S2SV_ModStart> EEXIST ) { LOCK ( & frame -> lock ) ; { <S2SV_ModStart> ++ ; } UNLOCK ( & frame -> lock ) ; }
|
534,603 |
CWE-000 <S2SV_StartBug> inline void <S2SV_EndBug> rpc_array_set_bool ( rpc_object_t array , size_t index , bool value ) { <S2SV_StartBug> rpc_array_set_value ( array , index , rpc_bool_create ( value ) ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> <S2SV_null> <S2SV_null> inline int <S2SV_ModEnd> rpc_array_set_bool ( rpc_object_t <S2SV_ModStart> value ) { return ( <S2SV_ModStart> value ) ) )
|
534,604 |
CWE-000 int drm_fb_helper_restore_fbdev_mode_unlocked ( struct drm_fb_helper * fb_helper ) { bool do_delayed ; int ret ; if ( ! drm_fbdev_emulation ) <S2SV_StartBug> return - ENODEV ; <S2SV_EndBug> mutex_lock ( & fb_helper -> lock ) ; ret = restore_fbdev_mode ( fb_helper ) ; do_delayed = fb_helper -> delayed_hotplug ; if ( do_delayed ) fb_helper -> delayed_hotplug = false ; mutex_unlock ( & fb_helper -> lock ) ; if ( do_delayed ) drm_fb_helper_hotplug_event ( fb_helper ) ; return ret ; }
|
<S2SV_ModStart> return - ENODEV ; if ( READ_ONCE ( fb_helper -> deferred_setup ) ) return 0
|
534,605 |
CWE-000 void FlowInitConfig ( char quiet ) { SCLogDebug ( "initializing<S2SV_blank>flow<S2SV_blank>engine..." ) ; memset ( & flow_config , 0 , sizeof ( flow_config ) ) ; SC_ATOMIC_INIT ( flow_flags ) ; SC_ATOMIC_INIT ( flow_memuse ) ; SC_ATOMIC_INIT ( flow_prune_idx ) ; FlowQueueInit ( & flow_spare_q ) ; FlowQueueInit ( & flow_recycle_q ) ; flow_config . hash_rand = ( uint32_t ) RandomGet ( ) ; flow_config . hash_size = FLOW_DEFAULT_HASHSIZE ; flow_config . memcap = FLOW_DEFAULT_MEMCAP ; flow_config . prealloc = FLOW_DEFAULT_PREALLOC ; intmax_t val = 0 ; if ( ConfGetInt ( "flow.emergency-recovery" , & val ) == 1 ) { if ( val <= 100 && val >= 1 ) { flow_config . emergency_recovery = ( uint8_t ) val ; } else { SCLogError ( SC_ERR_INVALID_VALUE , "flow.emergency-recovery<S2SV_blank>must<S2SV_blank>be<S2SV_blank>in<S2SV_blank>the<S2SV_blank>range<S2SV_blank>of<S2SV_blank>1<S2SV_blank>and<S2SV_blank>100<S2SV_blank>(as<S2SV_blank>percentage)" ) ; flow_config . emergency_recovery = FLOW_DEFAULT_EMERGENCY_RECOVERY ; } } else { SCLogDebug ( "flow.emergency-recovery,<S2SV_blank>using<S2SV_blank>default<S2SV_blank>value" ) ; flow_config . emergency_recovery = FLOW_DEFAULT_EMERGENCY_RECOVERY ; } const char * conf_val ; uint32_t configval = 0 ; if ( ( ConfGet ( "flow.memcap" , & conf_val ) ) == 1 ) { <S2SV_StartBug> if ( ParseSizeStringU64 ( conf_val , & flow_config . memcap ) < 0 ) { <S2SV_EndBug> SCLogError ( SC_ERR_SIZE_PARSE , "Error<S2SV_blank>parsing<S2SV_blank>flow.memcap<S2SV_blank>" "from<S2SV_blank>conf<S2SV_blank>file<S2SV_blank>-<S2SV_blank>%s.<S2SV_blank><S2SV_blank>Killing<S2SV_blank>engine" , conf_val ) ; exit ( EXIT_FAILURE ) ; } } if ( ( ConfGet ( "flow.hash-size" , & conf_val ) ) == 1 ) { <S2SV_StartBug> if ( ByteExtractStringUint32 ( & configval , 10 , strlen ( conf_val ) , <S2SV_EndBug> conf_val ) > 0 ) { flow_config . hash_size = configval ; } } if ( ( ConfGet ( "flow.prealloc" , & conf_val ) ) == 1 ) <S2SV_StartBug> { <S2SV_EndBug> if ( ByteExtractStringUint32 ( & configval , 10 , strlen ( conf_val ) , conf_val ) > 0 ) { flow_config . prealloc = configval ; } } SCLogDebug ( "Flow<S2SV_blank>config<S2SV_blank>from<S2SV_blank>suricata.yaml:<S2SV_blank>memcap:<S2SV_blank>%" PRIu64 ",<S2SV_blank>hash-size:<S2SV_blank>" "%" PRIu32 ",<S2SV_blank>prealloc:<S2SV_blank>%" PRIu32 , flow_config . memcap , flow_config . hash_size , flow_config . prealloc ) ; uint64_t hash_size = flow_config . hash_size * sizeof ( FlowBucket ) ; if ( ! ( FLOW_CHECK_MEMCAP ( hash_size ) ) ) { SCLogError ( SC_ERR_FLOW_INIT , "allocating<S2SV_blank>flow<S2SV_blank>hash<S2SV_blank>failed:<S2SV_blank>" "max<S2SV_blank>flow<S2SV_blank>memcap<S2SV_blank>is<S2SV_blank>smaller<S2SV_blank>than<S2SV_blank>projected<S2SV_blank>hash<S2SV_blank>size.<S2SV_blank>" "Memcap:<S2SV_blank>%" PRIu64 ",<S2SV_blank>Hash<S2SV_blank>table<S2SV_blank>size<S2SV_blank>%" PRIu64 ".<S2SV_blank>Calculate<S2SV_blank>" "total<S2SV_blank>hash<S2SV_blank>size<S2SV_blank>by<S2SV_blank>multiplying<S2SV_blank>\\"flow.hash-size\\"<S2SV_blank>with<S2SV_blank>%" PRIuMAX ",<S2SV_blank>" "which<S2SV_blank>is<S2SV_blank>the<S2SV_blank>hash<S2SV_blank>bucket<S2SV_blank>size." , flow_config . memcap , hash_size , ( uintmax_t ) sizeof ( FlowBucket ) ) ; exit ( EXIT_FAILURE ) ; } flow_hash = SCMallocAligned ( flow_config . hash_size * sizeof ( FlowBucket ) , CLS ) ; if ( unlikely ( flow_hash == NULL ) ) { SCLogError ( SC_ERR_FATAL , "Fatal<S2SV_blank>error<S2SV_blank>encountered<S2SV_blank>in<S2SV_blank>FlowInitConfig.<S2SV_blank>Exiting..." ) ; exit ( EXIT_FAILURE ) ; } memset ( flow_hash , 0 , flow_config . hash_size * sizeof ( FlowBucket ) ) ; uint32_t i = 0 ; for ( i = 0 ; i < flow_config . hash_size ; i ++ ) { FBLOCK_INIT ( & flow_hash [ i ] ) ; SC_ATOMIC_INIT ( flow_hash [ i ] . next_ts ) ; } ( void ) SC_ATOMIC_ADD ( flow_memuse , ( flow_config . hash_size * sizeof ( FlowBucket ) ) ) ; if ( quiet == FALSE ) { SCLogConfig ( "allocated<S2SV_blank>%" PRIu64 "<S2SV_blank>bytes<S2SV_blank>of<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>the<S2SV_blank>flow<S2SV_blank>hash...<S2SV_blank>" "%" PRIu32 "<S2SV_blank>buckets<S2SV_blank>of<S2SV_blank>size<S2SV_blank>%" PRIuMAX "" , SC_ATOMIC_GET ( flow_memuse ) , flow_config . hash_size , ( uintmax_t ) sizeof ( FlowBucket ) ) ; } for ( i = 0 ; i < flow_config . prealloc ; i ++ ) { if ( ! ( FLOW_CHECK_MEMCAP ( sizeof ( Flow ) + FlowStorageSize ( ) ) ) ) { SCLogError ( SC_ERR_FLOW_INIT , "preallocating<S2SV_blank>flows<S2SV_blank>failed:<S2SV_blank>" "max<S2SV_blank>flow<S2SV_blank>memcap<S2SV_blank>reached.<S2SV_blank>Memcap<S2SV_blank>%" PRIu64 ",<S2SV_blank>" "Memuse<S2SV_blank>%" PRIu64 "." , flow_config . memcap , ( ( uint64_t ) SC_ATOMIC_GET ( flow_memuse ) + ( uint64_t ) sizeof ( Flow ) ) ) ; exit ( EXIT_FAILURE ) ; } Flow * f = FlowAlloc ( ) ; if ( f == NULL ) { SCLogError ( SC_ERR_FLOW_INIT , "preallocating<S2SV_blank>flow<S2SV_blank>failed:<S2SV_blank>%s" , strerror ( errno ) ) ; exit ( EXIT_FAILURE ) ; } FlowEnqueue ( & flow_spare_q , f ) ; } if ( quiet == FALSE ) { SCLogConfig ( "preallocated<S2SV_blank>%" PRIu32 "<S2SV_blank>flows<S2SV_blank>of<S2SV_blank>size<S2SV_blank>%" PRIuMAX "" , flow_spare_q . len , ( uintmax_t ) ( sizeof ( Flow ) + + FlowStorageSize ( ) ) ) ; SCLogConfig ( "flow<S2SV_blank>memory<S2SV_blank>usage:<S2SV_blank>%" PRIu64 "<S2SV_blank>bytes,<S2SV_blank>maximum:<S2SV_blank>%" PRIu64 , SC_ATOMIC_GET ( flow_memuse ) , flow_config . memcap ) ; } FlowInitFlowProto ( ) ; return ; }
|
<S2SV_ModStart> { if ( conf_val == NULL ) { SCLogError ( SC_ERR_INVALID_YAML_CONF_ENTRY , "Invalid<S2SV_blank>value<S2SV_blank>for<S2SV_blank>flow.memcap:<S2SV_blank>NULL" ) ; exit ( EXIT_FAILURE ) ; } if ( <S2SV_ModStart> { if ( conf_val == NULL ) { SCLogError ( SC_ERR_INVALID_YAML_CONF_ENTRY , "Invalid<S2SV_blank>value<S2SV_blank>for<S2SV_blank>flow.hash-size:<S2SV_blank>NULL" ) ; exit ( EXIT_FAILURE ) ; } if ( <S2SV_ModStart> 1 ) { if ( conf_val == NULL ) { SCLogError ( SC_ERR_INVALID_YAML_CONF_ENTRY , "Invalid<S2SV_blank>value<S2SV_blank>for<S2SV_blank>flow.prealloc:<S2SV_blank>NULL" ) ; exit ( EXIT_FAILURE ) ; }
|
534,606 |
CWE-000 int voice_extn_compress_voip_close_input_stream ( struct audio_stream * stream ) { struct stream_in * in = ( struct stream_in * ) stream ; struct audio_device * adev = in -> dev ; int status = 0 ; ALOGD ( "%s:<S2SV_blank>enter" , __func__ ) ; if ( voip_data . in_stream_count > 0 ) { <S2SV_StartBug> adev -> active_input = NULL ; <S2SV_EndBug> voip_data . in_stream_count -- ; <S2SV_StartBug> status = voip_stop_call ( adev ) ; <S2SV_EndBug> in -> pcm = NULL ; } ALOGV ( "%s:<S2SV_blank>exit:<S2SV_blank>status(%d)" , __func__ , status ) ; return status ; }
|
<S2SV_ModStart> 0 ) { <S2SV_ModEnd> voip_data . in_stream_count <S2SV_ModStart> status = voip_stop_call ( adev ) ; adev -> active_input = get_next_active_input
|
534,607 |
CWE-000 void R_DrawBspLeafs ( void ) { const vec4_t leaf_colors [ ] = { { 0.2 , 0.2 , 0.2 , 0.4 } , { 0.8 , 0.2 , 0.2 , 0.4 } , { 0.2 , 0.8 , 0.2 , 0.4 } , { 0.2 , 0.2 , 0.8 , 0.4 } , { 0.8 , 0.8 , 0.2 , 0.4 } , { 0.2 , 0.8 , 0.8 , 0.4 } , { 0.8 , 0.2 , 0.8 , 0.4 } , { 0.8 , 0.8 , 0.8 , 0.4 } } ; if ( ! r_draw_bsp_leafs -> value ) { return ; } R_SetArrayState ( r_model_state . world ) ; R_EnableTexture ( texunit_diffuse , false ) ; R_BindDiffuseTexture ( r_image_state . null -> texnum ) ; <S2SV_StartBug> R_EnablePolygonOffset ( true ) ; <S2SV_EndBug> const r_bsp_leaf_t * l = r_model_state . world -> bsp -> leafs ; for ( uint16_t i = 0 ; i < r_model_state . world -> bsp -> num_leafs ; i ++ , l ++ ) { if ( l -> vis_frame != r_locals . vis_frame ) { continue ; } if ( r_draw_bsp_leafs -> integer == 2 ) { R_Color ( leaf_colors [ l -> cluster % lengthof ( leaf_colors ) ] ) ; } else { R_Color ( leaf_colors [ i % lengthof ( leaf_colors ) ] ) ; } r_bsp_surface_t * * s = l -> first_leaf_surface ; for ( uint16_t j = 0 ; j < l -> num_leaf_surfaces ; j ++ , s ++ ) { if ( ( * s ) -> vis_frame != r_locals . vis_frame ) { continue ; } R_DrawArrays ( GL_TRIANGLE_FAN , ( * s ) -> index , ( * s ) -> num_edges ) ; } } R_EnablePolygonOffset ( false ) ; R_EnableTexture ( texunit_diffuse , true ) ; R_Color ( NULL ) ; }
|
<S2SV_ModStart> R_EnablePolygonOffset ( true ) ; R_PolygonOffset ( R_OFFSET_FACTOR , R_OFFSET_UNITS
|
534,608 |
CWE-000 int create ( char * filename ) { unsigned long int seconds ; seconds = time ( NULL ) ; int inode_num ; char data [ BLK_SIZE ] ; int parent_inode_num = rootinode ; char * cwd ; cwd = present_working_directory ( ) ; inode_num = rfs_create ( seconds , F_TYPE ) ; struct dentry newfile , file ; newfile . inode_num = inode_num ; memcpy ( newfile . name , filename , strlen ( filename ) ) ; newfile . name [ strlen ( filename ) ] = '\\0' ; <S2SV_StartBug> convert_struct_to_string ( data , & newfile , sizeof ( struct dentry ) ) ; <S2SV_EndBug> if ( ! rfs_write ( parent_inode_num , data , sizeof ( struct dentry ) , 0 ) ) { return 0 ; } return 1 ; }
|
<S2SV_ModStart> = '\\0' ; if ( dentry_index != 0 ) { memcpy ( dirdata + dentry_index , & newfile , sizeof ( struct dentry ) ) ; dentry_index ++ ; }
|
534,609 |
CWE-000 void ipccb ( const gchar * line ) { gchar * * args = g_strsplit ( line , ":" , 3 ) ; Page * page = NULL ; long lid = atol ( args [ 0 ] ) ; for ( int i = 0 ; i < pages -> len ; i ++ ) if ( ( ( Page * ) pages -> pdata [ i ] ) -> id == lid ) page = pages -> pdata [ i ] ; if ( ! page ) return ; Coms type = * args [ 1 ] ; gchar * arg = args [ 2 ] ; gchar * ipkeys = NULL ; switch ( type ) { case Cload : loadconf ( ) ; break ; case Coverset : GFA ( page -> overset , g_strdup ( * arg ? arg : NULL ) ) resetconf ( page , webkit_web_page_get_uri ( page -> kit ) , true ) ; if ( page -> apnode ) makehint ( page , page -> lasttype , NULL , g_strdup ( page -> apkeys ) ) ; break ; case Cstart : pagestart ( page ) ; break ; case Con : g_strfreev ( page -> refreq ) ; page -> refreq = NULL ; <S2SV_StartBug> pageon ( page ) ; <S2SV_EndBug> break ; case Ckey : { gchar key [ 2 ] = { 0 } ; key [ 0 ] = toupper ( arg [ 0 ] ) ; ipkeys = page -> apkeys ? g_strconcat ( page -> apkeys , key , NULL ) : g_strdup ( key ) ; type = page -> lasttype ; arg = NULL ; } case Cclick : case Clink : case Curi : case Cspawn : case Crange : if ( arg ) { page -> rangestart = NULL ; page -> script = * arg == 'y' ; } if ( ! makehint ( page , type , confcstr ( "hintkeys" ) , ipkeys ) ) { send ( page , "showmsg" , "No<S2SV_blank>hint" ) ; send ( page , "tonormal" , NULL ) ; } break ; case Ctext : { WebKitDOMDocument * doc = webkit_web_page_get_dom_document ( page -> kit ) ; makelist ( page , doc , Ctext , NULL , NULL ) ; break ; } case Crm : rmhint ( page ) ; break ; case Cmode : mode ( page ) ; break ; case Cfocus : focus ( page ) ; break ; case Cblur : blur ( page ) ; break ; case Cwhite : if ( * arg == 'r' ) setwblist ( true ) ; if ( * arg == 'n' ) setwblist ( false ) ; if ( * arg == 'w' ) showwhite ( page , true ) ; if ( * arg == 'b' ) showwhite ( page , false ) ; break ; case Ctlget : textlinkget ( page , arg ) ; break ; case Ctlset : textlinkset ( page , arg ) ; break ; case Cwithref : g_strfreev ( page -> refreq ) ; page -> refreq = g_strsplit ( arg , "<S2SV_blank>" , 2 ) ; break ; case Cscroll : halfscroll ( page , * arg == 'd' ) ; break ; } g_strfreev ( args ) ; if ( page && page -> sync ) g_main_loop_quit ( page -> sync ) ; }
|
<S2SV_ModStart> pageon ( page , * arg == 'f'
|
534,610 |
CWE-000 static grub_err_t grub_cmd_initrd ( grub_command_t cmd __attribute__ ( ( unused ) ) , int argc , char * argv [ ] ) { grub_file_t * files = 0 ; int i , nfiles = 0 ; grub_size_t size = 0 ; grub_uint8_t * ptr ; if ( argc == 0 ) { grub_error ( GRUB_ERR_BAD_ARGUMENT , N_ ( "filename<S2SV_blank>expected" ) ) ; goto fail ; } if ( ! loaded ) { grub_error ( GRUB_ERR_BAD_ARGUMENT , N_ ( "you<S2SV_blank>need<S2SV_blank>to<S2SV_blank>load<S2SV_blank>the<S2SV_blank>kernel<S2SV_blank>first" ) ) ; goto fail ; } files = grub_zalloc ( argc * sizeof ( files [ 0 ] ) ) ; if ( ! files ) goto fail ; for ( i = 0 ; i < argc ; i ++ ) { grub_file_filter_disable_compression ( ) ; files [ i ] = grub_file_open ( argv [ i ] ) ; if ( ! files [ i ] ) goto fail ; nfiles ++ ; size += ALIGN_UP ( grub_file_size ( files [ i ] ) , 4 ) ; } initrd_mem = grub_efi_allocate_pages_max ( GRUB_EFI_MAX_USABLE_ADDRESS , BYTES_TO_PAGES ( size ) ) ; if ( ! initrd_mem ) <S2SV_StartBug> { <S2SV_EndBug> grub_error ( GRUB_ERR_OUT_OF_MEMORY , N_ ( "can\'t<S2SV_blank>allocate<S2SV_blank>initrd" ) ) ; goto fail ; } grub_dprintf ( "linux" , "initrd_mem<S2SV_blank>=<S2SV_blank>%lx\\n" , ( unsigned long ) initrd_mem ) ; params -> ramdisk_size = size ; params -> ramdisk_image = ( grub_uint32_t ) ( grub_addr_t ) initrd_mem ; ptr = initrd_mem ; for ( i = 0 ; i < nfiles ; i ++ ) { grub_ssize_t cursize = grub_file_size ( files [ i ] ) ; if ( grub_file_read ( files [ i ] , ptr , cursize ) != cursize ) { if ( ! grub_errno ) grub_error ( GRUB_ERR_FILE_READ_ERROR , N_ ( "premature<S2SV_blank>end<S2SV_blank>of<S2SV_blank>file<S2SV_blank>%s" ) , argv [ i ] ) ; goto fail ; } grub_tpm_measure ( ptr , cursize , GRUB_BINARY_PCR , "grub_linuxefi" , "Initrd" ) ; grub_print_error ( ) ; ptr += cursize ; grub_memset ( ptr , 0 , ALIGN_UP_OVERHEAD ( cursize , 4 ) ) ; ptr += ALIGN_UP_OVERHEAD ( cursize , 4 ) ; } params -> ramdisk_size = size ; fail : for ( i = 0 ; i < nfiles ; i ++ ) grub_file_close ( files [ i ] ) ; grub_free ( files ) ; if ( initrd_mem && grub_errno ) grub_efi_free_pages ( ( grub_efi_physical_address_t ) ( grub_addr_t ) initrd_mem , BYTES_TO_PAGES ( size ) ) ; return grub_errno ; }
|
<S2SV_ModStart> ! initrd_mem ) initrd_mem = grub_efi_allocate_pages_max ( 0x3fffffff , BYTES_TO_PAGES ( size ) ) ; if ( ! initrd_mem )
|
534,611 |
CWE-000 void HSD_AObjRemove ( HSD_AObj * aobj ) { if ( aobj ) { HSD_FObj * fobj = aobj -> fobj ; if ( fobj ) HSD_FObjRemoveAll ( fobj ) ; aobj -> fobj = NULL ; HSD_JObj * jobj = HSD_JOBJ ( aobj -> hsd_obj ) ; if ( jobj ) HSD_JObjUnref ( jobj ) ; <S2SV_StartBug> aobj -> jobj = NULL ; <S2SV_EndBug> HSD_AObjFree ( aobj ) ; } }
|
<S2SV_ModStart> ; aobj -> hsd_obj <S2SV_ModEnd> = NULL ;
|
534,612 |
CWE-000 static int set_dlr_clear_gateway_fault ( void * fd , u8 * err ) { struct ksz_request_actual req ; int rc ; set_dlr_req ( & req , DEV_CMD_PUT , SVC_DLR_CLEAR_GATEWAY_PARTIAL_FAULT , CLASS_DLR_OBJECT , 0 , 0 , NULL , 0 ) ; <S2SV_StartBug> rc = dlr_ioctl ( fd , & req ) ; <S2SV_EndBug> if ( ! rc ) rc = req . result ; if ( ! rc ) { * err = ( u8 ) req . output ; } return rc ; }
|
<S2SV_ModStart> ; rc = sw_ioctl <S2SV_ModEnd> ( fd ,
|
534,613 |
CWE-000 static void ping6 ( struct in6_addr * addr , const struct interface * iface ) { struct sockaddr_in6 dest = { AF_INET6 , 0 , 0 , * addr , iface -> ifindex } ; struct icmp6_hdr echo = { . icmp6_type = ICMP6_ECHO_REQUEST } ; struct iovec iov = { & echo , sizeof ( echo ) } ; <S2SV_StartBug> if ( ! strncmp ( iface -> name , "lan" , 3 ) ) { <S2SV_EndBug> odhcpd_setup_route ( addr , 128 , iface , NULL , 128 , true ) ; odhcpd_send ( pan_ping_socket , & dest , & iov , 1 , iface ) ; odhcpd_setup_route ( addr , 128 , iface , NULL , 128 , false ) ; } else { odhcpd_setup_route ( addr , 128 , iface , NULL , 128 , true ) ; odhcpd_send ( ping_socket , & dest , & iov , 1 , iface ) ; odhcpd_setup_route ( addr , 128 , iface , NULL , 128 , false ) ; } }
|
<S2SV_ModStart> ; if ( iface -> support_slip &&
|
534,614 |
CWE-000 ansigraphic_image_RGB_t * ansigraphic_newImage_RGB ( int32_t width , int32_t height ) { ansigraphic_image_RGB_t * image = ( ansigraphic_image_RGB_t * ) malloc ( sizeof ( ansigraphic_image_RGB_t ) ) ; int32_t x , y ; char * pixel ; if ( image == 0 ) return 0 ; else if ( ( image -> pixels = ( ansigraphic_pixel_RGB_t * ) malloc ( sizeof ( ansigraphic_pixel_RGB_t ) * width * height ) ) == 0 ) { free ( image ) ; return 0 ; } image -> width = width ; image -> height = height ; write ( 1 , "\\033[2J\\033[0;0f\\033[s" , 13 ) ; y = - 1 ; while ( ++ y < height ) { x = - 1 ; while ( ++ x < width ) { pixel = image -> pixels [ x + ( y * width ) ] . pixel ; pixel [ 0 ] = '\\033' ; pixel [ 1 ] = '[' ; pixel [ 2 ] = '3' ; pixel [ 3 ] = '8' ; pixel [ 4 ] = ';' ; pixel [ 5 ] = '2' ; pixel [ 6 ] = ';' ; pixel [ 7 ] = '0' ; pixel [ 8 ] = '0' ; pixel [ 9 ] = '0' ; pixel [ 10 ] = ';' ; pixel [ 11 ] = '0' ; pixel [ 12 ] = '0' ; pixel [ 13 ] = '0' ; pixel [ 14 ] = ';' ; pixel [ 15 ] = '0' ; pixel [ 16 ] = '0' ; pixel [ 17 ] = '0' ; pixel [ 18 ] = ';' ; pixel [ 19 ] = '4' ; pixel [ 20 ] = '8' ; pixel [ 21 ] = ';' ; pixel [ 22 ] = '2' ; pixel [ 23 ] = ';' ; pixel [ 24 ] = '0' ; pixel [ 25 ] = '0' ; pixel [ 26 ] = '0' ; pixel [ 27 ] = ';' ; pixel [ 28 ] = '0' ; pixel [ 29 ] = '0' ; pixel [ 30 ] = '0' ; pixel [ 31 ] = ';' ; pixel [ 32 ] = '0' ; pixel [ 33 ] = '0' ; pixel [ 34 ] = '0' ; pixel [ 35 ] = 'm' ; pixel [ 36 ] = '<S2SV_blank>' ; pixel [ 37 ] = '\\033' ; pixel [ 38 ] = '[' ; pixel [ 39 ] = '0' ; pixel [ 40 ] = 'm' ; if ( x + 1 < width ) { <S2SV_StartBug> pixel [ 41 ] = 0 ; <S2SV_EndBug> <S2SV_StartBug> pixel [ 42 ] = 0 ; <S2SV_EndBug> } else { pixel [ 41 ] = '\\r' ; pixel [ 42 ] = '\\n' ; } } } return image ; }
|
<S2SV_ModStart> 41 ] = '\\033' <S2SV_ModEnd> ; pixel [ <S2SV_ModStart> 42 ] = '_' <S2SV_ModEnd> ; } else
|
534,615 |
CWE-000 void * startPeerThread ( void * threadData ) { serverSysInfo_t * connectInfo = ( serverSysInfo_t * ) threadData ; char * servPassword = connectInfo -> conf . password ; char * servDownloadFolder = connectInfo -> conf . saveFilesFolder ; int inputConnectFd = connectInfo -> socketFd ; int inputMsgSize = 0 ; char inputPassBuff [ MAX_PASS_LEN ] ; memset ( & inputPassBuff , 0 , sizeof ( inputPassBuff ) ) ; if ( ( inputMsgSize = recvfrom ( inputConnectFd , & inputPassBuff , MAX_PASS_LEN * sizeof ( char ) , 0 , NULL , 0 ) ) < 0 ) { return EXIT_FAILURE ; } if ( checkPassword ( servPassword , inputPassBuff ) == FALSE ) { close ( inputConnectFd ) ; <S2SV_StartBug> pthread_exit ( ) ; <S2SV_EndBug> } inputMsgSize = 0 ; file_info_msg_t inputFileInfo ; size_t inputMsgBuffSize = sizeof ( char ) * MAX_FILESIZE_CHAR_NUM + sizeof ( char ) * MAX_FILENAME_LEN ; char * fileInfoMsgBuff = ( char * ) malloc ( inputMsgBuffSize ) ; memset ( fileInfoMsgBuff , 0 , inputMsgBuffSize ) ; if ( ( inputMsgSize = recvfrom ( inputConnectFd , fileInfoMsgBuff , inputMsgBuffSize , 0 , NULL , 0 ) ) < 0 ) { return EXIT_FAILURE ; } if ( deserialize_FileInfoMsg ( & inputFileInfo , fileInfoMsgBuff , ';' ) ) { return EXIT_FAILURE ; } size_t recvFuleFullPathSize = strlen ( servDownloadFolder ) * sizeof ( char ) + strlen ( inputFileInfo . fileName ) * sizeof ( char ) ; char * recvFileFullPath = ( char * ) malloc ( recvFuleFullPathSize ) ; memset ( recvFileFullPath , 0 , recvFuleFullPathSize ) ; strncpy ( recvFileFullPath , servDownloadFolder , strlen ( servDownloadFolder ) ) ; strncpy ( & recvFileFullPath [ strlen ( servDownloadFolder ) ] , inputFileInfo . fileName , strlen ( inputFileInfo . fileName ) ) ; <S2SV_StartBug> FILE * recvFile = fopen ( recvFileFullPath , "wb" ) ; <S2SV_EndBug> if ( recvFile == NULL ) { return EXIT_FAILURE ; } file_size_t remainData = inputFileInfo . fileSize ; close ( inputConnectFd ) ; <S2SV_StartBug> fclose ( recvFile ) ; <S2SV_EndBug> free ( fileInfoMsgBuff ) ; free ( recvFileFullPath ) ; return EXIT_SUCCESS ; }
|
<S2SV_ModStart> inputConnectFd ) ; return EXIT_FAILURE <S2SV_ModEnd> ; } inputMsgSize <S2SV_ModStart> ) ) ; <S2SV_ModEnd> file_size_t remainData = <S2SV_ModStart> inputConnectFd ) ; <S2SV_ModEnd> free ( fileInfoMsgBuff
|
534,616 |
CWE-000 void ADIO_Init ( int * argc , char * * * argv , int * error_code ) { # if defined ( ROMIO_XFS ) || defined ( ROMIO_LUSTRE ) char * c ; # endif ADIOI_UNREFERENCED_ARG ( argc ) ; ADIOI_UNREFERENCED_ARG ( argv ) ; # ifdef ROMIO_INSIDE_MPICH MPIR_Ext_init ( ) ; # endif ADIOI_Flatlist = ( ADIOI_Flatlist_node * ) ADIOI_Malloc ( sizeof ( ADIOI_Flatlist_node ) ) ; ADIOI_Flatlist -> type = MPI_DATATYPE_NULL ; ADIOI_Flatlist -> next = NULL ; ADIOI_Flatlist -> blocklens = NULL ; ADIOI_Flatlist -> indices = NULL ; # if defined ( ROMIO_XFS ) || defined ( ROMIO_LUSTRE ) c = getenv ( "MPIO_DIRECT_READ" ) ; if ( c && ( ! strcmp ( c , "true" ) || ! strcmp ( c , "TRUE" ) ) ) ADIOI_Direct_read = 1 ; else ADIOI_Direct_read = 0 ; c = getenv ( "MPIO_DIRECT_WRITE" ) ; if ( c && ( ! strcmp ( c , "true" ) || ! strcmp ( c , "TRUE" ) ) ) ADIOI_Direct_write = 1 ; else ADIOI_Direct_write = 0 ; # endif # ifdef ROMIO_DAOS <S2SV_StartBug> char * uuid_str ; <S2SV_EndBug> <S2SV_StartBug> char * svcl_str ; <S2SV_EndBug> <S2SV_StartBug> char * group ; <S2SV_EndBug> uuid_t pool_uuid ; daos_pool_info_t pool_info ; daos_rank_list_t * svcl = NULL ; int rc ; <S2SV_StartBug> uuid_str = getenv ( "DAOS_POOL" ) ; <S2SV_EndBug> if ( uuid_str != NULL ) { if ( uuid_parse ( uuid_str , pool_uuid ) < 0 ) { printf ( "Failed<S2SV_blank>to<S2SV_blank>parse<S2SV_blank>pool<S2SV_blank>UUID<S2SV_blank>env\\n" ) ; return ; } } <S2SV_StartBug> svcl_str = getenv ( "DAOS_SVCL" ) ; <S2SV_EndBug> if ( svcl_str != NULL ) { svcl = daos_rank_list_parse ( svcl_str , ":" ) ; if ( svcl == NULL ) { printf ( "Failed<S2SV_blank>to<S2SV_blank>parse<S2SV_blank>SVC<S2SV_blank>list<S2SV_blank>env\\n" ) ; return ; } } <S2SV_StartBug> group = getenv ( "DAOS_GROUP" ) ; <S2SV_EndBug> rc = daos_pool_connect ( pool_uuid , group , svcl , DAOS_PC_RW , & daos_pool_oh , & pool_info , NULL ) ; if ( rc < 0 ) <S2SV_StartBug> printf ( "Failed<S2SV_blank>to<S2SV_blank>connect<S2SV_blank>to<S2SV_blank>pool\\n" ) ; <S2SV_EndBug> if ( group ) free ( group ) ; if ( svcl ) crt_rank_list_free ( svcl ) ; if ( svcl_str ) free ( svcl_str ) ; if ( uuid_str ) free ( uuid_str ) ; # endif # ifdef ADIOI_MPE_LOGGING { MPE_Log_get_state_eventIDs ( & ADIOI_MPE_open_a , & ADIOI_MPE_open_b ) ; MPE_Log_get_state_eventIDs ( & ADIOI_MPE_read_a , & ADIOI_MPE_read_b ) ; MPE_Log_get_state_eventIDs ( & ADIOI_MPE_write_a , & ADIOI_MPE_write_b ) ; MPE_Log_get_state_eventIDs ( & ADIOI_MPE_lseek_a , & ADIOI_MPE_lseek_b ) ; MPE_Log_get_state_eventIDs ( & ADIOI_MPE_close_a , & ADIOI_MPE_close_b ) ; MPE_Log_get_state_eventIDs ( & ADIOI_MPE_writelock_a , & ADIOI_MPE_writelock_b ) ; MPE_Log_get_state_eventIDs ( & ADIOI_MPE_readlock_a , & ADIOI_MPE_readlock_b ) ; MPE_Log_get_state_eventIDs ( & ADIOI_MPE_unlock_a , & ADIOI_MPE_unlock_b ) ; MPE_Log_get_state_eventIDs ( & ADIOI_MPE_postwrite_a , & ADIOI_MPE_postwrite_b ) ; MPE_Log_get_state_eventIDs ( & ADIOI_MPE_openinternal_a , & ADIOI_MPE_openinternal_b ) ; MPE_Log_get_state_eventIDs ( & ADIOI_MPE_stat_a , & ADIOI_MPE_stat_b ) ; MPE_Log_get_state_eventIDs ( & ADIOI_MPE_iread_a , & ADIOI_MPE_iread_b ) ; MPE_Log_get_state_eventIDs ( & ADIOI_MPE_iwrite_a , & ADIOI_MPE_iwrite_b ) ; int comm_world_rank ; MPI_Comm_rank ( MPI_COMM_WORLD , & comm_world_rank ) ; if ( comm_world_rank == 0 ) { MPE_Describe_state ( ADIOI_MPE_open_a , ADIOI_MPE_open_b , "open" , "orange" ) ; MPE_Describe_state ( ADIOI_MPE_read_a , ADIOI_MPE_read_b , "read" , "green" ) ; MPE_Describe_state ( ADIOI_MPE_write_a , ADIOI_MPE_write_b , "write" , "blue" ) ; MPE_Describe_state ( ADIOI_MPE_lseek_a , ADIOI_MPE_lseek_b , "lseek" , "red" ) ; MPE_Describe_state ( ADIOI_MPE_close_a , ADIOI_MPE_close_b , "close" , "grey" ) ; MPE_Describe_state ( ADIOI_MPE_writelock_a , ADIOI_MPE_writelock_b , "writelock" , "plum" ) ; MPE_Describe_state ( ADIOI_MPE_readlock_a , ADIOI_MPE_readlock_b , "readlock" , "magenta" ) ; MPE_Describe_state ( ADIOI_MPE_unlock_a , ADIOI_MPE_unlock_b , "unlock" , "purple" ) ; MPE_Describe_state ( ADIOI_MPE_postwrite_a , ADIOI_MPE_postwrite_b , "postwrite" , "ivory" ) ; MPE_Describe_state ( ADIOI_MPE_openinternal_a , ADIOI_MPE_openinternal_b , "open<S2SV_blank>system" , "blue" ) ; MPE_Describe_state ( ADIOI_MPE_stat_a , ADIOI_MPE_stat_b , "stat" , "purple" ) ; MPE_Describe_state ( ADIOI_MPE_iread_a , ADIOI_MPE_iread_b , "iread" , "purple" ) ; MPE_Describe_state ( ADIOI_MPE_iwrite_a , ADIOI_MPE_iwrite_b , "iwrite" , "purple" ) ; } } # endif * error_code = MPI_SUCCESS ; MPI_Op_create ( my_consensus , 1 , & ADIO_same_amode ) ; }
|
<S2SV_ModStart> char * uuid_str = NULL <S2SV_ModStart> char * svcl_str = NULL <S2SV_ModStart> char * group = NULL <S2SV_ModStart> int rc ; rc = daos_init ( ) ; if ( rc ) { printf ( "daos_init()<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>%d\\n" , rc ) ; return ; } <S2SV_ModStart> ; } } printf ( "POOL<S2SV_blank>UUID<S2SV_blank>=<S2SV_blank>%s\\n" , uuid_str ) ; <S2SV_ModStart> ; } } printf ( "SVC<S2SV_blank>LIST<S2SV_blank>=<S2SV_blank>%s\\n" , svcl_str ) ; <S2SV_ModStart> getenv ( "DAOS_GROUP" ) ; if ( group != NULL ) printf ( "GROUP<S2SV_blank>=<S2SV_blank>%s\\n" , group <S2SV_ModStart> ) printf ( "Failed<S2SV_blank>to<S2SV_blank>connect<S2SV_blank>to<S2SV_blank>pool<S2SV_blank>(%d)\\n" , rc <S2SV_ModEnd> ) ; #
|
534,617 |
CWE-000 char * getJSONValueFromString ( const char * json , const char * key ) { if ( NULL == json || NULL == key ) { oidc_setArgNullFuncError ( __func__ ) ; return NULL ; <S2SV_StartBug> } <S2SV_EndBug> cJSON * cj = stringToJson ( json ) ; if ( cj == NULL ) { return NULL ; } char * value = getJSONValue ( cj , key ) ; secFreeJson ( cj ) ; return value ; }
|
<S2SV_ModStart> NULL ; } initCJSON ( ) ;
|
534,618 |
CWE-000 static gboolean initable_init ( GInitable * initable , GCancellable * cancellable , GError * * error ) { # ifdef HAVE_SELINUX gboolean ret = FALSE ; OstreeSePolicy * self = OSTREE_SEPOLICY ( initable ) ; g_autoptr ( GFile ) etc_selinux_dir = NULL ; g_autoptr ( GFile ) policy_config_path = NULL ; g_autoptr ( GFile ) policy_root = NULL ; g_autoptr ( GFileInputStream ) filein = NULL ; g_autoptr ( GDataInputStream ) datain = NULL ; gboolean enabled = FALSE ; g_autofree char * policytype = NULL ; const char * selinux_prefix = "SELINUX=" ; const char * selinuxtype_prefix = "SELINUXTYPE=" ; if ( self -> rootfs_dfd == - 1 ) { if ( ! glnx_opendirat ( AT_FDCWD , gs_file_get_path_cached ( self -> path ) , TRUE , & self -> rootfs_dfd_owned , error ) ) goto out ; self -> rootfs_dfd = self -> rootfs_dfd_owned ; } <S2SV_StartBug> etc_selinux_dir = g_file_resolve_relative_path ( self -> path , "etc/selinux" ) ; <S2SV_EndBug> if ( ! g_file_query_exists ( etc_selinux_dir , NULL ) ) { g_object_unref ( etc_selinux_dir ) ; etc_selinux_dir = g_file_resolve_relative_path ( self -> path , "usr/etc/selinux" ) ; } policy_config_path = g_file_get_child ( etc_selinux_dir , "config" ) ; if ( g_file_query_exists ( policy_config_path , NULL ) ) { filein = g_file_read ( policy_config_path , cancellable , error ) ; if ( ! filein ) goto out ; datain = g_data_input_stream_new ( ( GInputStream * ) filein ) ; while ( TRUE ) { gsize len ; GError * temp_error = NULL ; g_autofree char * line = g_data_input_stream_read_line_utf8 ( datain , & len , cancellable , & temp_error ) ; if ( temp_error ) { g_propagate_error ( error , temp_error ) ; goto out ; } if ( ! line ) break ; if ( g_str_has_prefix ( line , selinuxtype_prefix ) ) { policytype = g_strstrip ( g_strdup ( line + strlen ( selinuxtype_prefix ) ) ) ; policy_root = g_file_get_child ( etc_selinux_dir , policytype ) ; } else if ( g_str_has_prefix ( line , selinux_prefix ) ) { const char * enabled_str = line + strlen ( selinux_prefix ) ; if ( g_ascii_strncasecmp ( enabled_str , "enforcing" , strlen ( "enforcing" ) ) == 0 || g_ascii_strncasecmp ( enabled_str , "permissive" , strlen ( "permissive" ) ) == 0 ) enabled = TRUE ; } } } if ( enabled ) { self -> runtime_enabled = is_selinux_enabled ( ) == 1 ; g_setenv ( "LIBSELINUX_DISABLE_PCRE_PRECOMPILED" , "1" , FALSE ) ; if ( selinux_set_policy_root ( gs_file_get_path_cached ( policy_root ) ) != 0 ) { g_set_error ( error , G_IO_ERROR , G_IO_ERROR_FAILED , "selinux_set_policy_root(%s):<S2SV_blank>%s" , gs_file_get_path_cached ( etc_selinux_dir ) , strerror ( errno ) ) ; goto out ; } self -> selinux_hnd = selabel_open ( SELABEL_CTX_FILE , NULL , 0 ) ; if ( ! self -> selinux_hnd ) { g_set_error ( error , G_IO_ERROR , G_IO_ERROR_FAILED , "With<S2SV_blank>policy<S2SV_blank>root<S2SV_blank>\'%s\':<S2SV_blank>selabel_open(SELABEL_CTX_FILE):<S2SV_blank>%s" , gs_file_get_path_cached ( etc_selinux_dir ) , strerror ( errno ) ) ; goto out ; } { char * con = NULL ; if ( selabel_lookup_raw ( self -> selinux_hnd , & con , "/" , 0755 ) != 0 ) { g_set_error ( error , G_IO_ERROR , G_IO_ERROR_FAILED , "With<S2SV_blank>policy<S2SV_blank>root<S2SV_blank>\'%s\':<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>look<S2SV_blank>up<S2SV_blank>context<S2SV_blank>of<S2SV_blank>/:<S2SV_blank>%s" , gs_file_get_path_cached ( etc_selinux_dir ) , strerror ( errno ) ) ; goto out ; } freecon ( con ) ; } if ( ! get_policy_checksum ( & self -> selinux_policy_csum , cancellable , error ) ) { g_prefix_error ( error , "While<S2SV_blank>calculating<S2SV_blank>SELinux<S2SV_blank>checksum:<S2SV_blank>" ) ; goto out ; } self -> selinux_policy_name = g_steal_pointer ( & policytype ) ; self -> selinux_policy_root = g_object_ref ( etc_selinux_dir ) ; } ret = TRUE ; out : return ret ; # else return TRUE ; # endif }
|
<S2SV_ModStart> rootfs_dfd_owned ; } else if ( ! self -> path ) { self -> path = ot_fdrel_to_gfile ( self -> rootfs_dfd , "." ) ; } else g_assert_not_reached ( ) ;
|
534,619 |
CWE-000 int main ( int argc , char * * argv ) { STARTTIMER ; if ( argc != 5 ) { ERROR ( "Wrong<S2SV_blank>number<S2SV_blank>of<S2SV_blank>arguments\\n" ) ; ERROR ( "It<S2SV_blank>must<S2SV_blank>be<S2SV_blank>%s<S2SV_blank>MATRIX_SIZE<S2SV_blank>INPUT_FILENAME1<S2SV_blank>INPUT_FILENAME2<S2SV_blank>OUTPUT_FILENAME\\n" , argv [ 0 ] ) ; return EXIT_FAILURE ; } Matrix * a ; Matrix * b ; Matrix * c ; MPI_Datatype matrix_type ; MPI_Status status ; int n = atoi ( argv [ 1 ] ) ; char * path_a = argv [ 2 ] ; char * path_b = argv [ 3 ] ; char * path_c = argv [ 4 ] ; int world_rank ; int world_size ; MPI_Init ( & argc , & argv ) ; MPI_Comm_rank ( MPI_COMM_WORLD , & world_rank ) ; MPI_Comm_size ( MPI_COMM_WORLD , & world_size ) ; matrix_type = create_matrix_type ( ) ; a = read_matrix_bin ( n , n , path_a ) ; b = read_matrix_bin ( n , n , path_b ) ; c = init_matrix ( n , n , ( int * ) malloc ( sizeof ( int ) * n * n ) ) ; <S2SV_StartBug> MpiMatrix * * workers = create_meta_data ( n ) <S2SV_EndBug> for ( int worker = 1 ; worker < world_size ; worker ++ ) { <S2SV_StartBug> int * cols_a = get_cols_a ( a , workers [ i - 1 ] ) ; <S2SV_EndBug> <S2SV_StartBug> int * rows_b = get_rows_b ( b , workers [ i - 1 ] ) ; <S2SV_EndBug> MpiMatrix * meta = workers [ i - 1 ] ; MPI_Send ( meta , 1 , matrix_type , worker , MATRIX_META , MPI_COMM_WORLD ) ; MPI_Send ( cols_a , a -> rows * ( meta -> stop_col - meta -> start_col ) , MPI_INT , worker , MATRIX_A , MPI_COMM_WORLD ) ; <S2SV_StartBug> MPI_Send ( cols_b , b -> cols * ( meta -> stop_row - meta -> start_row ) , MPI_INT , worker , MATRIX_B , MPI_COMM_WORLD ) ; <S2SV_EndBug> free ( cols_a ) ; free ( rows_b ) ; } for ( int worker = 1 ; worker < world_size ; worker ++ ) { int * result ; int result_count ; int * result_index ; MPI_Probe ( 0 , MATRIX_DATA , MPI_COMM_WORLD , & status ) ; MPI_Get_count ( & status , MPI_INT , & result_count ) ; result = ( int * ) malloc ( sizeof ( int ) * result_count ) ; result_index = ( int * ) malloc ( sizeof ( int ) * result_count ) ; MPI_Recv ( result , result_count , MPI_INT , worker , MATRIX_DATA , MPI_COMM_WORLD , & status ) ; MPI_Recv ( result_index , result_count , MPI_INT , worker , INDEX , MPI_COMM_WORLD , & status ) ; for ( int i = 0 ; i < result_count ; i ++ ) { c -> values [ result_index [ i ] ] = result [ i ] ; } free ( result ) ; free ( result_index ) ; } write_matrix_bin ( c , path_c ) ; free_matrix ( a ) ; free_matrix ( b ) ; free_matrix ( c ) ; MPI_Finalize ( ) ; ENDTIMER ; return EXIT_SUCCESS ; }
|
<S2SV_ModStart> ( n ) ; <S2SV_ModStart> ++ ) { MpiMatrix * meta = workers [ worker <S2SV_ModEnd> - 1 ] <S2SV_ModStart> - 1 ] ; int * cols_a = get_cols_a ( a , meta <S2SV_ModStart> ( b , meta ) <S2SV_ModEnd> ; MPI_Send ( <S2SV_ModStart> ; MPI_Send ( rows_b <S2SV_ModEnd> , b ->
|
534,620 |
CWE-000 void * Radio_routin ( void * param ) { uint8_t stringformat [ 256 * 2 ] ; int msgid = - 1 ; struct msg_st data ; long int msgtype = 0 ; int len ; struct json_object * pragma = NULL ; uint8_t readbuffer [ 256 + sizeof ( st_ServerMsgUp ) ] ; pst_ServerMsgUp pstServerMsgUp = ( pst_ServerMsgUp ) readbuffer ; data . msg_type = 1 ; creat_msg_q : while ( ( msgid = msgget ( ( key_t ) 1234 , 0666 | IPC_CREAT ) == - 1 ) ) { printf ( "msgget<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>error:<S2SV_blank>%d\\r\\n" , errno ) ; sleep ( 1 ) ; } while ( 1 ) { if ( ( len = read ( fd_cdev , readbuffer , sizeof ( readbuffer ) ) ) > 0 ) { pstServerMsgUp -> Msg . stData2Server . payload = & readbuffer [ sizeof ( st_ServerMsgUp ) ] ; pragma = json_object_new_object ( ) ; if ( pstServerMsgUp -> enMsgUpFramType == en_MsgUpFramDataReceive ) { json_object_object_add ( pragma , "FrameType" , json_object_new_string ( "UpData" ) ) ; switch ( pstServerMsgUp -> Msg . stData2Server . ClassType ) { case 0 : json_object_object_add ( pragma , "NodeType" , json_object_new_string ( "Class<S2SV_blank>A" ) ) ; break ; case 1 : json_object_object_add ( pragma , "NodeType" , json_object_new_string ( "Class<S2SV_blank>B" ) ) ; break ; case 2 : json_object_object_add ( pragma , "NodeType" , json_object_new_string ( "Class<S2SV_blank>C" ) ) ; break ; } memset ( stringformat , 0 , 256 * 2 ) ; Hex2Str ( pstServerMsgUp -> Msg . stData2Server . DevEUI , stringformat , 8 ) ; json_object_object_add ( pragma , "DevEUI" , json_object_new_string ( stringformat ) ) ; memset ( stringformat , 0 , 256 * 2 ) ; Hex2Str ( pstServerMsgUp -> Msg . stData2Server . AppEUI , stringformat , 8 ) ; json_object_object_add ( pragma , "NetAddr" , json_object_new_int ( pstServerMsgUp -> Msg . stData2Server . DevAddr ) ) ; json_object_object_add ( pragma , "AppEUI" , json_object_new_string ( stringformat ) ) ; json_object_object_add ( pragma , "Port" , json_object_new_int ( pstServerMsgUp -> Msg . stData2Server . fPort ) ) ; json_object_object_add ( pragma , "ConfirmRequest" , json_object_new_boolean ( pstServerMsgUp -> Msg . stData2Server . CtrlBits . AckRequest ) ) ; <S2SV_StartBug> json_object_object_add ( pragma , "Confirm" , json_object_new_boolean ( pstServerMsgUp -> Msg . stData2Server . CtrlBits . Ack ) ) ; <S2SV_EndBug> json_object_object_add ( pragma , "Battery" , json_object_new_int ( pstServerMsgUp -> Msg . stData2Server . Battery ) ) ; json_object_object_add ( pragma , "Rssi" , json_object_new_int ( pstServerMsgUp -> Msg . stData2Server . rssi ) ) ; json_object_object_add ( pragma , "Snr" , json_object_new_double ( pstServerMsgUp -> Msg . stData2Server . snr ) ) ; memset ( stringformat , 0 , 256 * 2 ) ; Hex2Str ( pstServerMsgUp -> Msg . stData2Server . payload , stringformat , pstServerMsgUp -> Msg . stData2Server . size ) ; json_object_object_add ( pragma , "Data" , json_object_new_string ( stringformat ) ) ; } else if ( pstServerMsgUp -> enMsgUpFramType == en_MsgUpFramConfirm ) { json_object_object_add ( pragma , "FrameType" , json_object_new_string ( "UpConfirm" ) ) ; switch ( pstServerMsgUp -> Msg . stConfirm2Server . ClassType ) { case 0 : json_object_object_add ( pragma , "NodeType" , json_object_new_string ( "Class<S2SV_blank>A" ) ) ; break ; case 1 : json_object_object_add ( pragma , "NodeType" , json_object_new_string ( "Class<S2SV_blank>B" ) ) ; break ; case 2 : json_object_object_add ( pragma , "NodeType" , json_object_new_string ( "Class<S2SV_blank>C" ) ) ; break ; } memset ( stringformat , 0 , 256 * 2 ) ; Hex2Str ( pstServerMsgUp -> Msg . stConfirm2Server . DevEUI , stringformat , 8 ) ; json_object_object_add ( pragma , "DevEUI" , json_object_new_string ( stringformat ) ) ; json_object_object_add ( pragma , "NetAddr" , json_object_new_int ( pstServerMsgUp -> Msg . stConfirm2Server . DevAddr ) ) ; switch ( pstServerMsgUp -> Msg . stConfirm2Server . enConfirm2Server ) { case en_Confirm2ServerSuccess : json_object_object_add ( pragma , "Result" , json_object_new_string ( "Success" ) ) ; break ; case en_Confirm2ServerRadioBusy : json_object_object_add ( pragma , "Result" , json_object_new_string ( "Busy" ) ) ; break ; case en_Confirm2ServerOffline : json_object_object_add ( pragma , "Result" , json_object_new_string ( "Not<S2SV_blank>Active" ) ) ; break ; case en_Confirm2ServerTooLong : json_object_object_add ( pragma , "Result" , json_object_new_string ( "Too<S2SV_blank>Long" ) ) ; break ; case en_Confirm2ServerPortNotAllow : json_object_object_add ( pragma , "Result" , json_object_new_string ( "Port<S2SV_blank>Error" ) ) ; break ; default : json_object_object_add ( pragma , "Result" , json_object_new_string ( "Unkown<S2SV_blank>Fault" ) ) ; break ; } json_object_object_add ( pragma , "Rssi" , json_object_new_int ( pstServerMsgUp -> Msg . stConfirm2Server . rssi ) ) ; json_object_object_add ( pragma , "Snr" , json_object_new_double ( pstServerMsgUp -> Msg . stConfirm2Server . snr ) ) ; } else { } memset ( data . text , 0 , MSG_Q_BUFFER_SIZE ) ; strcpy ( data . text , json_object_to_json_string ( pragma ) ) ; json_object_put ( pragma ) ; if ( msgsnd ( msgid , ( void * ) & data , strlen ( data . text ) , 0 ) == - 1 ) { printf ( "msgsnd<S2SV_blank>failed\\r\\n" ) ; goto creat_msg_q ; } } else { usleep ( 100000 ) ; } } }
|
<S2SV_ModStart> ( pragma , <S2SV_ModEnd> "Battery" , json_object_new_int
|
534,621 |
CWE-000 int msr_save ( const char * save_path , const char * whitelist_path , const char * msr_path_format , int num_cpu ) { int err = 0 ; int tmp_err = 0 ; int i , j ; <S2SV_StartBug> int msr_fd ; <S2SV_EndBug> char err_msg [ NAME_MAX ] ; size_t num_msr = 0 ; uint64_t * msr_offset = NULL ; uint64_t * msr_mask = NULL ; uint64_t * save_buffer = NULL ; FILE * save_fid = NULL ; err = msr_parse_whitelist ( whitelist_path , & num_msr , & msr_offset , & msr_mask ) ; if ( err ) <S2SV_StartBug> { <S2SV_EndBug> goto exit ; } save_buffer = ( uint64_t * ) malloc ( num_msr * num_cpu * sizeof ( uint64_t ) ) ; if ( ! save_buffer ) { err = errno ? errno : - 1 ; snprintf ( err_msg , NAME_MAX , "Unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>msr<S2SV_blank>save<S2SV_blank>state<S2SV_blank>buffer<S2SV_blank>of<S2SV_blank>size:<S2SV_blank>%zu!" , num_msr * num_cpu * sizeof ( uint64_t ) ) ; perror ( err_msg ) ; goto exit ; } for ( i = 0 ; i < num_cpu ; ++ i ) { char msr_file_name [ NAME_MAX ] ; snprintf ( msr_file_name , NAME_MAX , msr_path_format , i ) ; msr_fd = open ( msr_file_name , O_RDWR ) ; if ( msr_fd == - 1 ) { err = errno ? errno : - 1 ; snprintf ( err_msg , NAME_MAX , "Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>MSR<S2SV_blank>file<S2SV_blank>\\"%s\\"!" , msr_file_name ) ; perror ( err_msg ) ; goto exit ; } for ( j = 0 ; j < num_msr ; ++ j ) { ssize_t read_count = pread ( msr_fd , save_buffer + i * num_msr + j , sizeof ( uint64_t ) , msr_offset [ j ] ) ; if ( read_count != sizeof ( uint64_t ) ) { err = errno ? errno : - 1 ; <S2SV_StartBug> snprintf ( err_msg , NAME_MAX , "Failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>msr<S2SV_blank>value<S2SV_blank>from<S2SV_blank>MSR<S2SV_blank>file<S2SV_blank>\\"%s\\"!" , msr_file_name ) ; <S2SV_EndBug> perror ( err_msg ) ; goto exit ; } save_buffer [ i * num_msr + j ] &= msr_mask [ j ] ; } tmp_err = close ( msr_fd ) ; msr_fd = - 1 ; if ( tmp_err ) { err = errno ? errno : - 1 ; snprintf ( err_msg , NAME_MAX , "Could<S2SV_blank>not<S2SV_blank>close<S2SV_blank>MSR<S2SV_blank>file<S2SV_blank>\\"%s\\"!" , msr_file_name ) ; perror ( err_msg ) ; goto exit ; } } save_fid = fopen ( save_path , "w" ) ; if ( ! save_fid ) { err = errno ? errno : - 1 ; snprintf ( err_msg , NAME_MAX , "Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>output<S2SV_blank>file<S2SV_blank>\\"%s\\"!" , save_path ) ; perror ( err_msg ) ; goto exit ; } size_t num_write = fwrite ( save_buffer , sizeof ( uint64_t ) , num_msr * num_cpu , save_fid ) ; if ( num_write != num_msr * num_cpu ) { err = errno ? errno : - 1 ; snprintf ( err_msg , NAME_MAX , "Could<S2SV_blank>not<S2SV_blank>write<S2SV_blank>all<S2SV_blank>values<S2SV_blank>to<S2SV_blank>output<S2SV_blank>file<S2SV_blank>\\"%s\\"!" , save_path ) ; perror ( err_msg ) ; goto exit ; } tmp_err = fclose ( save_fid ) ; save_fid = NULL ; if ( tmp_err ) { err = errno ? errno : - 1 ; snprintf ( err_msg , NAME_MAX , "Could<S2SV_blank>not<S2SV_blank>close<S2SV_blank>MSR<S2SV_blank>file<S2SV_blank>\\"%s\\"!" , save_path ) ; perror ( err_msg ) ; goto exit ; } exit : if ( save_buffer ) { free ( save_buffer ) ; } if ( msr_offset ) { free ( msr_offset ) ; } if ( msr_mask ) { free ( msr_mask ) ; } if ( save_fid ) { fclose ( save_fid ) ; } if ( msr_fd != - 1 ) { close ( msr_fd ) ; } return err ; }
|
<S2SV_ModStart> ; int msr_fd = - 1 <S2SV_ModStart> err ) { goto exit ; } if ( ! msr_offset || ! msr_mask ) { err = - 1 ; <S2SV_ModStart> , NAME_MAX , "Failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>msr<S2SV_blank>value<S2SV_blank>0x%zX<S2SV_blank>from<S2SV_blank>MSR<S2SV_blank>file<S2SV_blank>\\"%s\\"!" , msr_offset [ j ] <S2SV_ModEnd> , msr_file_name )
|
534,622 |
CWE-000 gchar * get_info_msg ( ) { if ( finished_drawing ) { if ( edit ) { if ( cur_path -> n == - 1 ) { return "Click<S2SV_blank>and<S2SV_blank>drag<S2SV_blank>point.<S2SV_blank>Then<S2SV_blank>press<S2SV_blank>\'y\'<S2SV_blank>to<S2SV_blank>yank<S2SV_blank>the<S2SV_blank>new<S2SV_blank>circle." ; } else if ( cur_path -> n == 1 ) { return "Click<S2SV_blank>and<S2SV_blank>drag<S2SV_blank>point.<S2SV_blank>Then<S2SV_blank>press<S2SV_blank>\'y\'<S2SV_blank>to<S2SV_blank>yank<S2SV_blank>the<S2SV_blank>new<S2SV_blank>coordinates." ; } else { <S2SV_StartBug> if ( cur_path -> points [ edit_point ] . straight ) <S2SV_EndBug> <S2SV_StartBug> return "Click<S2SV_blank>and<S2SV_blank>drag<S2SV_blank>point.<S2SV_blank>\'.\'<S2SV_blank>=<S2SV_blank>curve.<S2SV_blank>\'d\'<S2SV_blank>=<S2SV_blank>delete.<S2SV_blank>\'a\'/\'i\'<S2SV_blank>=<S2SV_blank>append/insert<S2SV_blank>point.<S2SV_blank>Enter<S2SV_blank>=<S2SV_blank>toggle<S2SV_blank>cycle.<S2SV_blank>\'y\'<S2SV_blank>=<S2SV_blank>yank<S2SV_blank>path." ; <S2SV_EndBug> else <S2SV_StartBug> return "Click<S2SV_blank>and<S2SV_blank>drag<S2SV_blank>point.<S2SV_blank>\'-\'<S2SV_blank>=<S2SV_blank>straight.<S2SV_blank>\'d\'<S2SV_blank>=<S2SV_blank>delete.<S2SV_blank>\'a\'/\'i\'<S2SV_blank>=<S2SV_blank>append/insert<S2SV_blank>point.<S2SV_blank>Enter<S2SV_blank>=<S2SV_blank>toggle<S2SV_blank>cycle.<S2SV_blank>\'y\'<S2SV_blank>=<S2SV_blank>yank<S2SV_blank>path." ; <S2SV_EndBug> } } else { if ( mode == CURVE_MODE ) return "Click<S2SV_blank>to<S2SV_blank>start<S2SV_blank>drawing<S2SV_blank>a<S2SV_blank>curve.<S2SV_blank>Press<S2SV_blank>\'-\'<S2SV_blank>for<S2SV_blank>straight<S2SV_blank>line<S2SV_blank>mode,<S2SV_blank>\'c\'<S2SV_blank>for<S2SV_blank>circle<S2SV_blank>mode." ; else if ( mode == STRAIGHT_MODE ) return "Click<S2SV_blank>to<S2SV_blank>start<S2SV_blank>drawing<S2SV_blank>straight<S2SV_blank>lines.<S2SV_blank>Press<S2SV_blank>\'.\'<S2SV_blank>for<S2SV_blank>curve<S2SV_blank>mode,<S2SV_blank>\'c\'<S2SV_blank>for<S2SV_blank>circle<S2SV_blank>mode." ; else if ( mode == CIRCLE_MODE ) return "Click<S2SV_blank>to<S2SV_blank>start<S2SV_blank>drawing<S2SV_blank>circle.<S2SV_blank>Press<S2SV_blank>\'-\'<S2SV_blank>for<S2SV_blank>straight<S2SV_blank>line<S2SV_blank>mode,<S2SV_blank>\'.\'<S2SV_blank>for<S2SV_blank>curve<S2SV_blank>mode." ; } } else { if ( mode == CURVE_MODE ) <S2SV_StartBug> return "Click<S2SV_blank>to<S2SV_blank>add<S2SV_blank>point.<S2SV_blank>Escape<S2SV_blank>=<S2SV_blank>end<S2SV_blank>path.<S2SV_blank>Enter<S2SV_blank>=<S2SV_blank>make<S2SV_blank>cycle.<S2SV_blank>\'-\'<S2SV_blank>=<S2SV_blank>straight<S2SV_blank>line<S2SV_blank>mode." ; <S2SV_EndBug> else if ( mode == STRAIGHT_MODE ) <S2SV_StartBug> return "Click<S2SV_blank>to<S2SV_blank>add<S2SV_blank>point.<S2SV_blank>Escape<S2SV_blank>=<S2SV_blank>end<S2SV_blank>path.<S2SV_blank>Enter<S2SV_blank>=<S2SV_blank>make<S2SV_blank>cycle.<S2SV_blank>\'.\'<S2SV_blank>=<S2SV_blank>curve<S2SV_blank>mode." ; <S2SV_EndBug> else if ( mode == CIRCLE_MODE ) return "Click<S2SV_blank>to<S2SV_blank>end<S2SV_blank>circle." ; } return "" ; }
|
<S2SV_ModStart> { if ( edit_point == cur_path -> n - 1 ) { return "Click<S2SV_blank>and<S2SV_blank>drag<S2SV_blank>point<S2SV_blank>to<S2SV_blank>move.<S2SV_blank>Then<S2SV_blank>press<S2SV_blank>\'y\'<S2SV_blank>to<S2SV_blank>yank<S2SV_blank>path.\\n\'d\'<S2SV_blank>=<S2SV_blank>delete.<S2SV_blank>\'a\'/\'i\'<S2SV_blank>=<S2SV_blank>append/insert<S2SV_blank>point.<S2SV_blank>Enter<S2SV_blank>=<S2SV_blank>toggle<S2SV_blank>cycle." ; } else if ( <S2SV_ModStart> straight ) return "Click<S2SV_blank>and<S2SV_blank>drag<S2SV_blank>point<S2SV_blank>to<S2SV_blank>move.<S2SV_blank>Then<S2SV_blank>press<S2SV_blank>\'y\'<S2SV_blank>to<S2SV_blank>yank<S2SV_blank>path.\\n\'.\'<S2SV_blank>=<S2SV_blank>curve.<S2SV_blank>\'d\'<S2SV_blank>=<S2SV_blank>delete.<S2SV_blank>\'a\'/\'i\'<S2SV_blank>=<S2SV_blank>append/insert<S2SV_blank>point.<S2SV_blank>Enter<S2SV_blank>=<S2SV_blank>toggle<S2SV_blank>cycle." <S2SV_ModEnd> ; else return <S2SV_ModStart> ; else return "Click<S2SV_blank>and<S2SV_blank>drag<S2SV_blank>point<S2SV_blank>to<S2SV_blank>move.<S2SV_blank>Then<S2SV_blank>press<S2SV_blank>\'y\'<S2SV_blank>to<S2SV_blank>yank<S2SV_blank>path.\\n\'-\'<S2SV_blank>=<S2SV_blank>straight.<S2SV_blank>\'d\'<S2SV_blank>=<S2SV_blank>delete.<S2SV_blank>\'a\'/\'i\'<S2SV_blank>=<S2SV_blank>append/insert<S2SV_blank>point.<S2SV_blank>Enter<S2SV_blank>=<S2SV_blank>toggle<S2SV_blank>cycle." <S2SV_ModEnd> ; } } <S2SV_ModStart> CURVE_MODE ) return "Click<S2SV_blank>to<S2SV_blank>add<S2SV_blank>point.<S2SV_blank>Escape<S2SV_blank>=<S2SV_blank>end<S2SV_blank>path.<S2SV_blank>Enter<S2SV_blank>=<S2SV_blank>toggle<S2SV_blank>cycle.<S2SV_blank>\'-\'<S2SV_blank>=<S2SV_blank>straight<S2SV_blank>line<S2SV_blank>mode." <S2SV_ModEnd> ; else if <S2SV_ModStart> STRAIGHT_MODE ) return "Click<S2SV_blank>to<S2SV_blank>add<S2SV_blank>point.<S2SV_blank>Escape<S2SV_blank>=<S2SV_blank>end<S2SV_blank>path.<S2SV_blank>Enter<S2SV_blank>=<S2SV_blank>toggle<S2SV_blank>cycle.<S2SV_blank>\'.\'<S2SV_blank>=<S2SV_blank>curve<S2SV_blank>mode." <S2SV_ModEnd> ; else if
|
534,623 |
CWE-000 void song_library_free ( struct song_library * const this ) { <S2SV_StartBug> this -> c . remove_all_songs ( this ) ; <S2SV_EndBug> free ( this ) ; }
|
<S2SV_ModStart> this -> c -> <S2SV_ModEnd> remove_all_songs ( this
|
534,624 |
CWE-000 static PetscErrorCode CreateBoundaryMesh ( DM dm , DM * subdm , AppCtx * user ) { DMLabel label ; PetscInt dim ; PetscErrorCode ierr ; PetscFunctionBeginUser ; ierr = DMLabelCreate ( "sub" , & label ) ; CHKERRQ ( ierr ) ; ierr = DMPlexMarkBoundaryFaces ( dm , label ) ; CHKERRQ ( ierr ) ; ierr = DMPlexLabelComplete ( dm , label ) ; CHKERRQ ( ierr ) ; ierr = DMPlexCreateSubmesh ( dm , label , 1 , subdm ) ; CHKERRQ ( ierr ) ; ierr = DMLabelDestroy ( & label ) ; CHKERRQ ( ierr ) ; ierr = DMGetDimension ( * subdm , & dim ) ; CHKERRQ ( ierr ) ; ierr = SetupDiscretization ( * subdm , dim , user -> cellSimplex , user ) ; CHKERRQ ( ierr ) ; <S2SV_StartBug> PetscFunctionReturn ( 0 ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> ierr ) ; ierr = PetscObjectSetName ( ( PetscObject ) * subdm , "boundary" ) ; CHKERRQ ( ierr ) ; ierr = DMViewFromOptions ( * subdm , NULL , "-sub_dm_view" ) ; CHKERRQ ( ierr ) ;
|
534,625 |
CWE-000 avro_schema_t avro_schema_link ( avro_schema_t to ) { if ( ! is_avro_named_type ( to ) ) { avro_set_error ( "Can<S2SV_blank>only<S2SV_blank>link<S2SV_blank>to<S2SV_blank>named<S2SV_blank>types" ) ; return NULL ; } struct avro_link_schema_t * link = ( struct avro_link_schema_t * ) avro_new ( struct avro_link_schema_t ) ; if ( ! link ) { avro_set_error ( "Cannot<S2SV_blank>allocate<S2SV_blank>new<S2SV_blank>link<S2SV_blank>schema" ) ; return NULL ; } <S2SV_StartBug> link -> to = avro_schema_incref ( to ) ; <S2SV_EndBug> avro_schema_init ( & link -> obj , AVRO_LINK ) ; return & link -> obj ; }
|
<S2SV_ModStart> -> to = to <S2SV_ModEnd> ; avro_schema_init (
|
534,626 |
CWE-000 int rand_pos ( ) { <S2SV_StartBug> if ( seed <= 0 ) <S2SV_EndBug> { seed += m ; } seed = a * ( seed % q ) - r * ( seed / q ) ; <S2SV_StartBug> return seed ; <S2SV_EndBug> }
|
<S2SV_ModStart> ( ) { <S2SV_ModEnd> seed = a <S2SV_ModStart> q ) ; if ( seed <= 0 ) { seed += m ; }
|
534,627 |
CWE-000 static void update_recirc_rules__ ( struct bond * bond ) { struct match match ; struct bond_pr_rule_op * pr_op , * next_op ; uint64_t ofpacts_stub [ 128 / 8 ] ; struct ofpbuf ofpacts ; int i ; ofpbuf_use_stub ( & ofpacts , ofpacts_stub , sizeof ofpacts_stub ) ; HMAP_FOR_EACH ( pr_op , hmap_node , & bond -> pr_rule_ops ) { pr_op -> op = DEL ; } if ( bond -> hash && bond -> recirc_id ) { for ( i = 0 ; i < BOND_BUCKETS ; i ++ ) { struct bond_slave * slave = bond -> hash [ i ] . slave ; if ( slave ) { match_init_catchall ( & match ) ; match_set_recirc_id ( & match , bond -> recirc_id ) ; match_set_dp_hash_masked ( & match , i , BOND_MASK ) ; add_pr_rule ( bond , & match , slave -> ofp_port , & bond -> hash [ i ] . pr_rule ) ; } } } HMAP_FOR_EACH_SAFE ( pr_op , next_op , hmap_node , & bond -> pr_rule_ops ) { int error ; switch ( pr_op -> op ) { case ADD : ofpbuf_clear ( & ofpacts ) ; ofpact_put_OUTPUT ( & ofpacts ) -> port = pr_op -> out_ofport ; error = ofproto_dpif_add_internal_flow ( bond -> ofproto , & pr_op -> match , RECIRC_RULE_PRIORITY , 0 , & ofpacts , pr_op -> pr_rule ) ; if ( error ) { char * err_s = match_to_string ( & pr_op -> match , RECIRC_RULE_PRIORITY ) ; VLOG_ERR ( "failed<S2SV_blank>to<S2SV_blank>add<S2SV_blank>post<S2SV_blank>recirculation<S2SV_blank>flow<S2SV_blank>%s" , err_s ) ; free ( err_s ) ; } break ; case DEL : error = ofproto_dpif_delete_internal_flow ( bond -> ofproto , & pr_op -> match , RECIRC_RULE_PRIORITY ) ; if ( error ) { char * err_s = match_to_string ( & pr_op -> match , RECIRC_RULE_PRIORITY ) ; VLOG_ERR ( "failed<S2SV_blank>to<S2SV_blank>remove<S2SV_blank>post<S2SV_blank>recirculation<S2SV_blank>flow<S2SV_blank>%s" , err_s ) ; free ( err_s ) ; } hmap_remove ( & bond -> pr_rule_ops , & pr_op -> hmap_node ) ; <S2SV_StartBug> * pr_op -> pr_rule = NULL ; <S2SV_EndBug> <S2SV_StartBug> free ( pr_op ) ; <S2SV_EndBug> break ; } } ofpbuf_uninit ( & ofpacts ) ; }
|
<S2SV_ModStart> hmap_node ) ; if ( bond -> hash ) { <S2SV_ModStart> = NULL ; }
|
534,628 |
CWE-000 uint32_t USBD_ReadEP ( uint32_t EPNum , uint8_t * pData , uint32_t size ) { uint32_t n , sz , idx , setup = 0 ; idx = IDX ( EPNum , RX , 0 ) ; sz = BD [ idx ] . bc ; if ( ( EPNum == 0 ) && ( TOK_PID ( idx ) == SETUP_TOKEN ) ) { setup = 1 ; } if ( size < sz ) { util_assert ( 0 ) ; sz = size ; } for ( n = 0 ; n < sz ; n ++ ) { pData [ n ] = EPBuf [ idx ] [ n ] ; } BD [ idx ] . bc = OutEpSize [ EPNum ] ; if ( ( Data1 >> ( idx / 2 ) & 1 ) == ( ( BD [ idx ] . stat >> 6 ) & 1 ) ) { if ( setup && ( pData [ 6 ] == 0 ) ) { protected_and ( & Data1 , ~ 1 ) ; } else { protected_xor ( & Data1 , ( 1 << ( idx / 2 ) ) ) ; } } if ( ( Data1 >> ( idx / 2 ) ) & 1 ) { BD [ idx ] . stat = BD_DTS_MASK | BD_DATA01_MASK ; BD [ idx ] . stat |= BD_OWN_MASK ; } else { BD [ idx ] . stat = BD_DTS_MASK ; BD [ idx ] . stat |= BD_OWN_MASK ; } <S2SV_StartBug> USB0 -> CTL &= ~ USB_CTL_TXSUSPENDTOKENBUSY_MASK ; <S2SV_EndBug> return ( sz ) ; }
|
<S2SV_ModStart> BD_OWN_MASK ; } <S2SV_ModEnd> return ( sz
|
534,629 |
CWE-000 void ass_lazy_track_init ( ASS_Library * lib , ASS_Track * track ) { if ( track -> PlayResX > 0 && track -> PlayResY > 0 ) return ; if ( track -> PlayResX <= 0 && track -> PlayResY <= 0 ) { ass_msg ( lib , MSGL_WARN , "Neither<S2SV_blank>PlayResX<S2SV_blank>nor<S2SV_blank>PlayResY<S2SV_blank>defined.<S2SV_blank>Assuming<S2SV_blank>384x288" ) ; track -> PlayResX = 384 ; track -> PlayResY = 288 ; } else { if ( track -> PlayResY <= 0 && track -> PlayResX == 1280 ) { track -> PlayResY = 1024 ; ass_msg ( lib , MSGL_WARN , "PlayResY<S2SV_blank>undefined,<S2SV_blank>setting<S2SV_blank>to<S2SV_blank>%d" , track -> PlayResY ) ; } else if ( track -> PlayResY <= 0 ) { <S2SV_StartBug> track -> PlayResY = track -> PlayResX * 3 / 4 ; <S2SV_EndBug> ass_msg ( lib , MSGL_WARN , "PlayResY<S2SV_blank>undefined,<S2SV_blank>setting<S2SV_blank>to<S2SV_blank>%d" , track -> PlayResY ) ; } else if ( track -> PlayResX <= 0 && track -> PlayResY == 1024 ) { track -> PlayResX = 1280 ; ass_msg ( lib , MSGL_WARN , "PlayResX<S2SV_blank>undefined,<S2SV_blank>setting<S2SV_blank>to<S2SV_blank>%d" , track -> PlayResX ) ; } else if ( track -> PlayResX <= 0 ) { <S2SV_StartBug> track -> PlayResX = track -> PlayResY * 4 / 3 ; <S2SV_EndBug> ass_msg ( lib , MSGL_WARN , "PlayResX<S2SV_blank>undefined,<S2SV_blank>setting<S2SV_blank>to<S2SV_blank>%d" , track -> PlayResX ) ; } } }
|
<S2SV_ModStart> -> PlayResY = FFMAX ( 1 , <S2SV_ModStart> 3 / 4 ) <S2SV_ModStart> -> PlayResX = FFMAX ( 1 , <S2SV_ModStart> 4 / 3 )
|
534,630 |
CWE-000 unsigned int alloc ( unsigned int size , unsigned char page_align , heap_t * heap ) { unsigned int new_size = size + sizeof ( header_t ) + sizeof ( footer_t ) ; int iterator = find_smallest_hole ( new_size , page_align , heap ) ; if ( iterator == - 1 ) { unsigned int old_length = heap -> end_address - heap -> start_address ; unsigned int old_end_address = heap -> end_address ; expand ( old_length + 0x1000 , heap ) ; unsigned int new_length = heap -> end_address - heap -> start_address ; iterator = 0 ; unsigned int idx = - 1 ; unsigned int value = 0x0 ; while ( iterator < heap -> index . size ) { unsigned int tmp = ( unsigned int ) lookup_ordered_array ( iterator , & heap -> index ) ; if ( tmp > value ) { value = tmp ; idx = iterator ; } iterator ++ ; } if ( idx == - 1 ) { header_t * header = ( header_t * ) old_end_address ; header -> magic = HEAP_MAGIC ; header -> size = new_length - old_length ; header -> is_hole = 1 ; footer_t * footer = ( footer_t * ) ( old_end_address + header -> size - sizeof ( footer_t ) ) ; footer -> magic = HEAP_MAGIC ; footer -> header = header ; puts ( "??\\n" ) ; insert_ordered_array ( ( void * ) header , & heap -> index ) ; } else { header_t * header = lookup_ordered_array ( idx , & heap -> index ) ; header -> size += new_length - old_length ; footer_t * footer = ( footer_t * ) ( ( unsigned int ) header + header -> size - sizeof ( footer_t ) ) ; footer -> header = header ; footer -> magic = HEAP_MAGIC ; } return alloc ( size , page_align , heap ) ; } header_t * orig_hole_header = ( header_t * ) lookup_ordered_array ( iterator , & heap -> index ) ; unsigned int orig_hole_pos = ( unsigned int ) orig_hole_header ; unsigned int orig_hole_size = orig_hole_header -> size ; if ( orig_hole_size - new_size < sizeof ( header_t ) + sizeof ( footer_t ) ) { size += orig_hole_size - new_size ; new_size = orig_hole_size ; } int was_aligned = 0 ; int aligned_pos ; int aligned_size ; header_t * aligned_block ; if ( page_align && not_aligned ( orig_hole_pos + sizeof ( header_t ) ) ) { was_aligned = 1 ; int offset = ( 0x1000 - ( orig_hole_pos & 0xFFF ) ) - sizeof ( header_t ) ; unsigned int aligned_location = orig_hole_pos + offset ; aligned_block = ( header_t * ) ( aligned_location ) ; aligned_block -> size = new_size ; aligned_block -> magic = HEAP_MAGIC ; aligned_block -> is_hole = 0 ; footer_t * block_footer = ( footer_t * ) ( ( unsigned int ) aligned_location - sizeof ( footer_t ) ) ; block_footer -> magic = HEAP_MAGIC ; block_footer -> header = aligned_block ; aligned_pos = aligned_location ; } header_t * block_header ; if ( was_aligned ) { block_header = aligned_block ; } else { block_header = ( header_t * ) orig_hole_pos ; block_header -> magic = HEAP_MAGIC ; block_header -> is_hole = 0 ; block_header -> size = new_size ; footer_t * block_footer = ( footer_t * ) ( orig_hole_pos + sizeof ( header_t ) + size ) ; block_footer -> magic = HEAP_MAGIC ; block_footer -> header = block_header ; } header_t * hole ; unsigned int positive = ( orig_hole_size > new_size ) ? 1 : 0 ; unsigned diff = orig_hole_size - new_size ; <S2SV_StartBug> printf ( "DIFF<S2SV_blank>:<S2SV_blank>[%x]\\n" , new_size ) ; <S2SV_EndBug> if ( positive && diff > ( sizeof ( header_t ) + sizeof ( footer_t ) ) ) { if ( was_aligned ) { <S2SV_StartBug> printf ( "AB<S2SV_blank>[%x]\\n" , aligned_block ) ; <S2SV_EndBug> new_size = ( ( unsigned int ) aligned_block - orig_hole_pos ) + new_size ; } header_t * hole_header = ( header_t * ) ( orig_hole_pos + new_size ) ; hole_header -> magic = HEAP_MAGIC ; hole_header -> is_hole = 1 ; hole_header -> size = orig_hole_size - new_size ; footer_t * hole_footer = ( footer_t * ) ( ( unsigned int ) hole_header + orig_hole_size - new_size - sizeof ( footer_t ) ) ; if ( ( unsigned int ) hole_footer < heap -> end_address ) { hole_footer -> magic = HEAP_MAGIC ; hole_footer -> header = hole_header ; } hole = hole_header ; remove_ordered_array ( iterator , & heap -> index ) ; <S2SV_StartBug> if ( hole_header -> size == 0xFFFFFFE0 ) { <S2SV_EndBug> printf ( "OGPOS<S2SV_blank>[%x]\\n" , orig_hole_pos ) ; printf ( "OGSIZ<S2SV_blank>{%x]\\n" , orig_hole_size ) ; printf ( "NSIZ<S2SV_blank>[%x]\\n" , new_size ) ; printf ( "HOLEHDR<S2SV_blank>-><S2SV_blank>[%x]\\n" , hole_header -> size ) ; } insert_ordered_array ( ( void * ) hole_header , & heap -> index ) ; } int block_ptr = ( void * ) ( ( unsigned int ) block_header + sizeof ( header_t ) ) ; return block_ptr ; }
|
<S2SV_ModStart> - new_size ; <S2SV_ModEnd> if ( positive <S2SV_ModStart> was_aligned ) { <S2SV_ModEnd> new_size = ( <S2SV_ModStart> index ) ; <S2SV_ModEnd> insert_ordered_array ( (
|
534,631 |
CWE-000 PixMapComponents * pixmap_filter_split_into_components ( PixMapImage * image ) { int width = pixmap_image_get_width ( image ) ; int height = pixmap_image_get_height ( image ) ; int max_value = pixmap_image_get_max_color_value ( image ) ; PixMapImageType type = pixmap_image_get_type ( image ) ; PixMapComponents * res = malloc ( sizeof ( PixMapComponents ) ) ; if ( ! res ) return NULL ; res -> red = pixmap_image_new ( NULL , width , height , max_value , type ) ; res -> green = pixmap_image_new ( NULL , width , height , max_value , type ) ; res -> blue = pixmap_image_new ( NULL , width , height , max_value , type ) ; if ( ! res -> red || ! res -> green || ! res -> blue ) return NULL ; int error = 0 ; for ( int y = 0 ; y < height ; y ++ ) { for ( int x = 0 ; x < width ; x ++ ) { RGB pixel = pixmap_image_get_pixel ( image , x , y ) ; <S2SV_StartBug> pixmap_image_set_pixel ( res -> red , x , y , pixel . red , 0 , 0 , error ) ; <S2SV_EndBug> <S2SV_StartBug> pixmap_image_set_pixel ( res -> green , x , y , 0 , pixel . green , 0 , error ) ; <S2SV_EndBug> <S2SV_StartBug> pixmap_image_set_pixel ( res -> blue , x , y , 0 , 0 , pixel . blue , error ) ; <S2SV_EndBug> if ( error ) { pixmap_image_close ( res -> red ) ; pixmap_image_close ( res -> green ) ; pixmap_image_close ( res -> blue ) ; return NULL ; } } } return res ; }
|
<S2SV_ModStart> , 0 , & <S2SV_ModStart> , 0 , & <S2SV_ModStart> . blue , &
|
534,632 |
CWE-000 int isci_task_I_T_nexus_reset ( struct domain_device * dev ) { struct isci_host * ihost = dev_to_ihost ( dev ) ; struct isci_remote_device * idev ; unsigned long flags ; int ret ; spin_lock_irqsave ( & ihost -> scic_lock , flags ) ; idev = isci_get_device ( dev -> lldd_dev ) ; spin_unlock_irqrestore ( & ihost -> scic_lock , flags ) ; if ( ! idev ) { <S2SV_StartBug> ret = TMF_RESP_FUNC_COMPLETE ; <S2SV_EndBug> goto out ; } ret = isci_reset_device ( ihost , dev , idev ) ; out : isci_put_device ( idev ) ; return ret ; }
|
<S2SV_ModStart> { ret = - ENODEV <S2SV_ModEnd> ; goto out
|
534,633 |
CWE-000 void i40iw_process_aeq ( struct i40iw_device * iwdev ) { struct i40iw_sc_dev * dev = & iwdev -> sc_dev ; struct i40iw_aeq * aeq = & iwdev -> aeq ; struct i40iw_sc_aeq * sc_aeq = & aeq -> sc_aeq ; struct i40iw_aeqe_info aeinfo ; struct i40iw_aeqe_info * info = & aeinfo ; int ret ; struct i40iw_qp * iwqp = NULL ; struct i40iw_sc_cq * cq = NULL ; struct i40iw_cq * iwcq = NULL ; struct i40iw_sc_qp * qp = NULL ; struct i40iw_qp_host_ctx_info * ctx_info = NULL ; unsigned long flags ; u32 aeqcnt = 0 ; if ( ! sc_aeq -> size ) return ; do { memset ( info , 0 , sizeof ( * info ) ) ; ret = dev -> aeq_ops -> get_next_aeqe ( sc_aeq , info ) ; if ( ret ) break ; aeqcnt ++ ; i40iw_debug ( dev , I40IW_DEBUG_AEQ , "%s<S2SV_blank>ae_id<S2SV_blank>=<S2SV_blank>0x%x<S2SV_blank>bool<S2SV_blank>qp=%d<S2SV_blank>qp_id<S2SV_blank>=<S2SV_blank>%d\\n" , __func__ , info -> ae_id , info -> qp , info -> qp_cq_id ) ; if ( info -> qp ) { spin_lock_irqsave ( & iwdev -> qptable_lock , flags ) ; iwqp = iwdev -> qp_table [ info -> qp_cq_id ] ; if ( ! iwqp ) { spin_unlock_irqrestore ( & iwdev -> qptable_lock , flags ) ; i40iw_debug ( dev , I40IW_DEBUG_AEQ , "%s<S2SV_blank>qp_id<S2SV_blank>%d<S2SV_blank>is<S2SV_blank>already<S2SV_blank>freed\\n" , __func__ , info -> qp_cq_id ) ; continue ; } i40iw_add_ref ( & iwqp -> ibqp ) ; spin_unlock_irqrestore ( & iwdev -> qptable_lock , flags ) ; qp = & iwqp -> sc_qp ; spin_lock_irqsave ( & iwqp -> lock , flags ) ; iwqp -> hw_tcp_state = info -> tcp_state ; iwqp -> hw_iwarp_state = info -> iwarp_state ; iwqp -> last_aeq = info -> ae_id ; spin_unlock_irqrestore ( & iwqp -> lock , flags ) ; ctx_info = & iwqp -> ctx_info ; ctx_info -> err_rq_idx_valid = true ; } else { if ( info -> ae_id != I40IW_AE_CQ_OPERATION_ERROR ) continue ; } switch ( info -> ae_id ) { case I40IW_AE_LLP_FIN_RECEIVED : if ( qp -> term_flags ) <S2SV_StartBug> continue ; <S2SV_EndBug> if ( atomic_inc_return ( & iwqp -> close_timer_started ) == 1 ) { iwqp -> hw_tcp_state = I40IW_TCP_STATE_CLOSE_WAIT ; if ( ( iwqp -> hw_tcp_state == I40IW_TCP_STATE_CLOSE_WAIT ) && ( iwqp -> ibqp_state == IB_QPS_RTS ) ) { i40iw_next_iw_state ( iwqp , I40IW_QP_STATE_CLOSING , 0 , 0 , 0 ) ; i40iw_cm_disconn ( iwqp ) ; } iwqp -> cm_id -> add_ref ( iwqp -> cm_id ) ; i40iw_schedule_cm_timer ( iwqp -> cm_node , ( struct i40iw_puda_buf * ) iwqp , I40IW_TIMER_TYPE_CLOSE , 1 , 0 ) ; } break ; case I40IW_AE_LLP_CLOSE_COMPLETE : if ( qp -> term_flags ) i40iw_terminate_done ( qp , 0 ) ; else i40iw_cm_disconn ( iwqp ) ; break ; case I40IW_AE_RESET_SENT : i40iw_next_iw_state ( iwqp , I40IW_QP_STATE_ERROR , 1 , 0 , 0 ) ; i40iw_cm_disconn ( iwqp ) ; break ; case I40IW_AE_LLP_CONNECTION_RESET : if ( atomic_read ( & iwqp -> close_timer_started ) ) <S2SV_StartBug> continue ; <S2SV_EndBug> i40iw_cm_disconn ( iwqp ) ; break ; case I40IW_AE_QP_SUSPEND_COMPLETE : i40iw_qp_suspend_resume ( dev , & iwqp -> sc_qp , false ) ; break ; case I40IW_AE_TERMINATE_SENT : i40iw_terminate_send_fin ( qp ) ; break ; case I40IW_AE_LLP_TERMINATE_RECEIVED : i40iw_terminate_received ( qp , info ) ; break ; case I40IW_AE_CQ_OPERATION_ERROR : i40iw_pr_err ( "Processing<S2SV_blank>an<S2SV_blank>iWARP<S2SV_blank>related<S2SV_blank>AE<S2SV_blank>for<S2SV_blank>CQ<S2SV_blank>misc<S2SV_blank>=<S2SV_blank>0x%04X\\n" , info -> ae_id ) ; cq = ( struct i40iw_sc_cq * ) ( unsigned long ) info -> compl_ctx ; iwcq = ( struct i40iw_cq * ) cq -> back_cq ; if ( iwcq -> ibcq . event_handler ) { struct ib_event ibevent ; ibevent . device = iwcq -> ibcq . device ; ibevent . event = IB_EVENT_CQ_ERR ; ibevent . element . cq = & iwcq -> ibcq ; iwcq -> ibcq . event_handler ( & ibevent , iwcq -> ibcq . cq_context ) ; } break ; case I40IW_AE_LLP_DOUBT_REACHABILITY : break ; case I40IW_AE_PRIV_OPERATION_DENIED : case I40IW_AE_STAG_ZERO_INVALID : case I40IW_AE_IB_RREQ_AND_Q1_FULL : case I40IW_AE_DDP_UBE_INVALID_DDP_VERSION : case I40IW_AE_DDP_UBE_INVALID_MO : case I40IW_AE_DDP_UBE_INVALID_QN : case I40IW_AE_DDP_NO_L_BIT : case I40IW_AE_RDMAP_ROE_INVALID_RDMAP_VERSION : case I40IW_AE_RDMAP_ROE_UNEXPECTED_OPCODE : case I40IW_AE_ROE_INVALID_RDMA_READ_REQUEST : case I40IW_AE_ROE_INVALID_RDMA_WRITE_OR_READ_RESP : case I40IW_AE_INVALID_ARP_ENTRY : case I40IW_AE_INVALID_TCP_OPTION_RCVD : case I40IW_AE_STALE_ARP_ENTRY : case I40IW_AE_LLP_RECEIVED_MPA_CRC_ERROR : case I40IW_AE_LLP_SEGMENT_TOO_SMALL : case I40IW_AE_LLP_SYN_RECEIVED : case I40IW_AE_LLP_TOO_MANY_RETRIES : case I40IW_AE_LCE_QP_CATASTROPHIC : case I40IW_AE_LCE_FUNCTION_CATASTROPHIC : case I40IW_AE_LCE_CQ_CATASTROPHIC : case I40IW_AE_UDA_XMIT_DGRAM_TOO_LONG : case I40IW_AE_UDA_XMIT_DGRAM_TOO_SHORT : ctx_info -> err_rq_idx_valid = false ; default : if ( ! info -> sq && ctx_info -> err_rq_idx_valid ) { ctx_info -> err_rq_idx = info -> wqe_idx ; ctx_info -> tcp_info_valid = false ; ctx_info -> iwarp_info_valid = false ; ret = dev -> iw_priv_qp_ops -> qp_setctx ( & iwqp -> sc_qp , iwqp -> host_ctx . va , ctx_info ) ; } i40iw_terminate_connection ( qp , info ) ; break ; } if ( info -> qp ) i40iw_rem_ref ( & iwqp -> ibqp ) ; } while ( 1 ) ; if ( aeqcnt ) dev -> aeq_ops -> repost_aeq_entries ( dev , aeqcnt ) ; }
|
<S2SV_ModStart> -> term_flags ) break <S2SV_ModEnd> ; if ( <S2SV_ModStart> close_timer_started ) ) break <S2SV_ModEnd> ; i40iw_cm_disconn (
|
534,634 |
CWE-000 void rip_redistribute_delete ( int type , int sub_type , struct prefix_ipv4 * p , ifindex_t ifindex ) { int ret ; struct route_node * rp ; struct rip_info * rinfo ; ret = rip_destination_check ( p -> prefix ) ; if ( ! ret ) return ; rp = route_node_lookup ( rip -> table , ( struct prefix * ) p ) ; if ( rp ) { struct list * list = rp -> info ; if ( list != NULL && listcount ( list ) != 0 ) { rinfo = listgetdata ( listhead ( list ) ) ; if ( rinfo != NULL && rinfo -> type == type && rinfo -> sub_type == sub_type && rinfo -> nh . ifindex == ifindex ) { rinfo -> metric = RIP_METRIC_INFINITY ; RIP_TIMER_ON ( rinfo -> t_garbage_collect , rip_garbage_collect , rip -> garbage_time ) ; RIP_TIMER_OFF ( rinfo -> t_timeout ) ; rinfo -> flags |= RIP_RTF_CHANGED ; if ( IS_RIP_DEBUG_EVENT ) zlog_debug ( <S2SV_StartBug> "Poisone<S2SV_blank>%s/%d<S2SV_blank>on<S2SV_blank>the<S2SV_blank>interface<S2SV_blank>%s<S2SV_blank>with<S2SV_blank>an<S2SV_blank>" <S2SV_EndBug> "infinity<S2SV_blank>metric<S2SV_blank>[delete]" , inet_ntoa ( p -> prefix ) , p -> prefixlen , ifindex2ifname ( ifindex , VRF_DEFAULT ) ) ; rip_event ( RIP_TRIGGERED_UPDATE , 0 ) ; } } route_unlock_node ( rp ) ; } }
|
<S2SV_ModStart> ) zlog_debug ( "Poison<S2SV_blank>%s/%d<S2SV_blank>on<S2SV_blank>the<S2SV_blank>interface<S2SV_blank>%s<S2SV_blank>with<S2SV_blank>an<S2SV_blank>" <S2SV_ModEnd> "infinity<S2SV_blank>metric<S2SV_blank>[delete]" , inet_ntoa
|
534,635 |
CWE-000 int resampler_resample_from_input ( struct resampler_itfe * resampler , int16_t * in , size_t * inFrameCount , int16_t * out , size_t * outFrameCount ) { <S2SV_StartBug> struct resampler * rsmp = ( struct resampler * ) resampler ; <S2SV_EndBug> spx_uint32_t inFrames , outFrames ; if ( rsmp == NULL || in == NULL || inFrameCount == NULL || out == NULL || outFrameCount == NULL ) { return - EINVAL ; } if ( rsmp -> provider != NULL ) { * outFrameCount = 0 ; return - ENOSYS ; } if ( rsmp -> channel_count == 1 ) { speex_resampler_process_int ( rsmp -> speex_resampler , 0 , in , <S2SV_StartBug> & inFrames , <S2SV_EndBug> out , <S2SV_StartBug> & outFrames ) ; <S2SV_EndBug> } else { speex_resampler_process_interleaved_int ( rsmp -> speex_resampler , in , <S2SV_StartBug> & inFrames , <S2SV_EndBug> out , <S2SV_StartBug> & outFrames ) ; <S2SV_EndBug> } <S2SV_StartBug> * inFrameCount = inFrames ; <S2SV_EndBug> * outFrameCount = outFrames ; ALOGV ( "resampler_resample_from_input()<S2SV_blank>DONE<S2SV_blank>in<S2SV_blank>%zu<S2SV_blank>out<S2SV_blank>%zu" , * inFrameCount , * outFrameCount ) ; return 0 ; }
|
<S2SV_ModStart> * ) resampler <S2SV_ModEnd> ; if ( <S2SV_ModStart> , in , ( spx_uint32_t * ) inFrameCount <S2SV_ModEnd> , out , <S2SV_ModStart> , out , ( spx_uint32_t * ) outFrameCount <S2SV_ModEnd> ) ; } <S2SV_ModStart> , in , ( spx_uint32_t * ) inFrameCount <S2SV_ModEnd> , out , <S2SV_ModStart> , out , ( spx_uint32_t * ) outFrameCount <S2SV_ModEnd> ) ; } <S2SV_ModStart> ) ; } <S2SV_ModEnd> ALOGV ( "resampler_resample_from_input()<S2SV_blank>DONE<S2SV_blank>in<S2SV_blank>%zu<S2SV_blank>out<S2SV_blank>%zu"
|
534,636 |
CWE-000 WimaItemHandle wima_item_find ( WimaItemHandle item , int x , int y , uint32_t flags , uint32_t mask ) { WimaItemHandle best_hit ; best_hit . item = - 1 ; WimaItem * pitem = wima_item_ptr ( item ) ; <S2SV_StartBug> if ( pitem -> flags & UI_ITEM_FROZEN ) { <S2SV_EndBug> return best_hit ; } if ( wima_item_contains ( item , x , y ) ) { WimaItemHandle kid = wima_item_firstChild ( item ) ; while ( kid . item >= 0 ) { WimaItemHandle hit = wima_item_find ( kid , x , y , flags , mask ) ; if ( hit . item >= 0 ) { best_hit = hit ; } kid = wima_item_nextSibling ( kid ) ; } if ( best_hit . item >= 0 ) { return best_hit ; } if ( ( ( mask == UI_ANY ) && ( ( flags == UI_ANY ) || ( pitem -> flags & flags ) ) ) || ( ( pitem -> flags & flags ) == mask ) ) { return item ; } } return best_hit ; }
|
<S2SV_ModStart> -> flags & WIMA_ITEM_FROZEN <S2SV_ModEnd> ) { return
|
534,637 |
CWE-000 double atan2 ( double oy , double ox ) { double ah , al , t , xh , x , y , z ; int i , k , hx , hy , sx , sy ; # ifndef lint <S2SV_StartBug> volatile int inexact ; <S2SV_EndBug> # endif hy = ( ( int * ) & oy ) [ HIWORD ] ; sy = hy & 0x80000000 ; hy &= ~ 0x80000000 ; hx = ( ( int * ) & ox ) [ HIWORD ] ; sx = hx & 0x80000000 ; hx &= ~ 0x80000000 ; if ( hy > hx || ( hy == hx && ( ( unsigned * ) & oy ) [ LOWORD ] > ( ( unsigned * ) & ox ) [ LOWORD ] ) ) { i = hx ; hx = hy ; hy = i ; x = fabs ( oy ) ; y = fabs ( ox ) ; if ( sx ) { ah = pio2 ; al = pio2_lo ; } else { ah = - pio2 ; al = - pio2_lo ; sy ^= 0x80000000 ; } } else { x = fabs ( ox ) ; y = fabs ( oy ) ; if ( sx ) { ah = mpi ; al = mpi_lo ; sy ^= 0x80000000 ; } else { ah = al = zero ; } } if ( hx >= 0x7fe00000 || hx - hy >= 0x03600000 ) { if ( hx >= 0x7ff00000 ) { if ( ( ( hx ^ 0x7ff00000 ) | ( ( int * ) & x ) [ LOWORD ] ) != 0 ) return ( ox * oy ) ; if ( hy >= 0x7ff00000 ) ah += pio4 ; # ifndef lint inexact = ( int ) ah ; # endif return ( ( sy ) ? - ah : ah ) ; } if ( hx - hy >= 0x03600000 ) { if ( ( int ) ah == 0 ) ah = y / x ; return ( ( sy ) ? - ah : ah ) ; } y *= twom3 ; x *= twom3 ; hy -= 0x00300000 ; hx -= 0x00300000 ; } else if ( hy < 0x00100000 ) { if ( ( hy | ( ( int * ) & y ) [ LOWORD ] ) == 0 ) { if ( ( hx | ( ( int * ) & x ) [ LOWORD ] ) == 0 ) return ( _SVID_libm_err ( ox , oy , 3 ) ) ; # ifndef lint inexact = ( int ) ah ; # endif return ( ( sy ) ? - ah : ah ) ; } y *= two110 ; x *= two110 ; hy = ( ( int * ) & y ) [ HIWORD ] ; hx = ( ( int * ) & x ) [ HIWORD ] ; } k = ( ( ( hx - hy ) + 0x00004000 ) >> 13 ) & ~ 0x3 ; if ( k > 644 ) k = 644 ; ah += TBL [ k ] ; al += TBL [ k + 1 ] ; t = TBL [ k + 2 ] ; xh = x ; ( ( int * ) & xh ) [ LOWORD ] = 0 ; z = ( ( y - t * xh ) - t * ( x - xh ) ) / ( x + y * t ) ; x = z * z ; t = ah + ( z + ( al + ( z * x ) * ( p1 + x * ( p2 + x * ( p3 + x * p4 ) ) ) ) ) ; return ( ( sy ) ? - t : t ) ; }
|
<S2SV_ModStart> volatile int inexact __attribute__ ( ( unused ) )
|
534,638 |
CWE-000 PyTypeObject * new_list_type ( PyNameSpace * ns ) { PyTypeObject * type = new_type ( LIST_TYPE , ns , list_buitinfuncs , builtinfunc_array_entries ( list_buitinfuncs ) , sizeof ( PyTypeObject ) , PYOBJ_FLAGS_INHERITABLE | PYOBJ_FLAG_ISBUILTIN ) ; new_builtin_attribute ( type -> __type_namespace__ , ( PyObject * ) new_string ( "list" , sizeof ( "list" ) - 1 ) , "__name__" ) ; new_builtin_attribute ( type -> __type_namespace__ , ( PyObject * ) type , "__class__" ) ; <S2SV_StartBug> return type ; <S2SV_EndBug> }
|
<S2SV_ModStart> "__class__" ) ; pyc_decrement_refcount ( ( PyObject * ) type ) ;
|
534,639 |
CWE-000 inline INT poly_fmult_two_polys2x2 ( const UINT deg , COMPLEX const * const p1_11 , const UINT p1_stride , COMPLEX const * const p2_11 , const UINT p2_stride , COMPLEX * const result_11 , const UINT result_stride , fft_wrapper_plan_t plan_fwd , fft_wrapper_plan_t plan_inv , COMPLEX * const buf0 , COMPLEX * const buf1 , COMPLEX * const buf2 ) { <S2SV_StartBug> UINT ret_code ; <S2SV_EndBug> COMPLEX const * const p1_12 = p1_11 + p1_stride ; COMPLEX const * const p1_21 = p1_12 + p1_stride ; COMPLEX const * const p1_22 = p1_21 + p1_stride ; COMPLEX const * const p2_12 = p2_11 + p2_stride ; COMPLEX const * const p2_21 = p2_12 + p2_stride ; COMPLEX const * const p2_22 = p2_21 + p2_stride ; COMPLEX * const result_12 = result_11 + result_stride ; COMPLEX * const result_21 = result_12 + result_stride ; COMPLEX * const result_22 = result_21 + result_stride ; ret_code = poly_fmult_two_polys ( deg , p1_11 , p2_11 , result_11 , plan_fwd , plan_inv , buf0 , buf1 , buf2 , 0 ) ; CHECK_RETCODE ( ret_code , leave_fun ) ; ret_code = poly_fmult_two_polys ( deg , p1_12 , p2_21 , result_11 , plan_fwd , plan_inv , buf0 , buf1 , buf2 , 1 ) ; CHECK_RETCODE ( ret_code , leave_fun ) ; ret_code = poly_fmult_two_polys ( deg , p1_11 , p2_12 , result_12 , plan_fwd , plan_inv , buf0 , buf1 , buf2 , 0 ) ; CHECK_RETCODE ( ret_code , leave_fun ) ; ret_code = poly_fmult_two_polys ( deg , p1_12 , p2_22 , result_12 , plan_fwd , plan_inv , buf0 , buf1 , buf2 , 1 ) ; CHECK_RETCODE ( ret_code , leave_fun ) ; ret_code = poly_fmult_two_polys ( deg , p1_21 , p2_11 , result_21 , plan_fwd , plan_inv , buf0 , buf1 , buf2 , 0 ) ; CHECK_RETCODE ( ret_code , leave_fun ) ; ret_code = poly_fmult_two_polys ( deg , p1_22 , p2_21 , result_21 , plan_fwd , plan_inv , buf0 , buf1 , buf2 , 1 ) ; CHECK_RETCODE ( ret_code , leave_fun ) ; ret_code = poly_fmult_two_polys ( deg , p1_21 , p2_12 , result_22 , plan_fwd , plan_inv , buf0 , buf1 , buf2 , 0 ) ; CHECK_RETCODE ( ret_code , leave_fun ) ; ret_code = poly_fmult_two_polys ( deg , p1_22 , p2_22 , result_22 , plan_fwd , plan_inv , buf0 , buf1 , buf2 , 1 ) ; CHECK_RETCODE ( ret_code , leave_fun ) ; leave_fun : return ret_code ; }
|
<S2SV_ModStart> buf2 ) { INT <S2SV_ModEnd> ret_code ; COMPLEX
|
534,640 |
CWE-000 static void try_add_empty_parent_dir_entry_from_wt ( const char * worktree , struct index_state * istate , GList * ignore_list , const char * path ) { if ( index_name_exists ( istate , path , strlen ( path ) , 0 ) != NULL ) return ; char * parent_dir = g_path_get_dirname ( path ) ; if ( strcmp ( parent_dir , "." ) == 0 ) { g_free ( parent_dir ) ; return ; } char * full_dir = g_build_filename ( worktree , parent_dir , NULL ) ; SeafStat st ; if ( seaf_stat ( full_dir , & st ) < 0 ) { goto out ; } if ( is_empty_dir ( full_dir , ignore_list ) ) { # ifdef WIN32 wchar_t * parent_dir_w = g_utf8_to_utf16 ( parent_dir , - 1 , NULL , NULL , NULL ) ; wchar_t * pw ; for ( pw = parent_dir_w ; * pw != L'\\0' ; ++ pw ) if ( * pw == L'/' ) * pw = L'\\\\' ; wchar_t * long_path = win32_83_path_to_long_path ( worktree , parent_dir_w , wcslen ( parent_dir_w ) ) ; g_free ( parent_dir_w ) ; if ( ! long_path ) { seaf_warning ( "Convert<S2SV_blank>%s<S2SV_blank>to<S2SV_blank>long<S2SV_blank>path<S2SV_blank>failed.\\n" , parent_dir ) ; goto out ; } char * utf8_path = g_utf16_to_utf8 ( long_path , - 1 , NULL , NULL , NULL ) ; <S2SV_StartBug> char * p ; <S2SV_EndBug> for ( p = utf8_path ; * p != 0 ; ++ p ) if ( * p == '\\\\' ) * p = '/' ; g_free ( long_path ) ; add_empty_dir_to_index ( istate , utf8_path , & st ) ; # else add_empty_dir_to_index ( istate , parent_dir , & st ) ; # endif } out : g_free ( parent_dir ) ; g_free ( full_dir ) ; }
|
<S2SV_ModStart> NULL ) ; if ( ! utf8_path ) { g_free ( long_path ) ; goto out ; }
|
534,641 |
CWE-000 static int i915_huc_load_status_info ( struct seq_file * m , void * data ) { struct drm_i915_private * dev_priv = node_to_i915 ( m -> private ) ; <S2SV_StartBug> struct intel_uc_fw * huc_fw = & dev_priv -> huc . fw ; <S2SV_EndBug> if ( ! HAS_HUC_UCODE ( dev_priv ) ) return 0 ; <S2SV_StartBug> seq_puts ( m , "HuC<S2SV_blank>firmware<S2SV_blank>status:\\n" ) ; <S2SV_EndBug> seq_printf ( m , "\\tpath:<S2SV_blank>%s\\n" , huc_fw -> path ) ; seq_printf ( m , "\\tfetch:<S2SV_blank>%s\\n" , intel_uc_fw_status_repr ( huc_fw -> fetch_status ) ) ; seq_printf ( m , "\\tload:<S2SV_blank>%s\\n" , intel_uc_fw_status_repr ( huc_fw -> load_status ) ) ; seq_printf ( m , "\\tversion<S2SV_blank>wanted:<S2SV_blank>%d.%d\\n" , huc_fw -> major_ver_wanted , huc_fw -> minor_ver_wanted ) ; seq_printf ( m , "\\tversion<S2SV_blank>found:<S2SV_blank>%d.%d\\n" , huc_fw -> major_ver_found , huc_fw -> minor_ver_found ) ; seq_printf ( m , "\\theader:<S2SV_blank>offset<S2SV_blank>is<S2SV_blank>%d;<S2SV_blank>size<S2SV_blank>=<S2SV_blank>%d\\n" , huc_fw -> header_offset , huc_fw -> header_size ) ; seq_printf ( m , "\\tuCode:<S2SV_blank>offset<S2SV_blank>is<S2SV_blank>%d;<S2SV_blank>size<S2SV_blank>=<S2SV_blank>%d\\n" , huc_fw -> ucode_offset , huc_fw -> ucode_size ) ; seq_printf ( m , "\\tRSA:<S2SV_blank>offset<S2SV_blank>is<S2SV_blank>%d;<S2SV_blank>size<S2SV_blank>=<S2SV_blank>%d\\n" , huc_fw -> rsa_offset , huc_fw -> rsa_size ) ; intel_runtime_pm_get ( dev_priv ) ; seq_printf ( m , "\\nHuC<S2SV_blank>status<S2SV_blank>0x%08x:\\n" , I915_READ ( HUC_STATUS2 ) ) ; intel_runtime_pm_put ( dev_priv ) ; return 0 ; }
|
<S2SV_ModStart> ) ; struct drm_printer p <S2SV_ModEnd> ; if ( <S2SV_ModStart> return 0 ; p = drm_seq_file_printer ( m ) ; intel_uc_fw_dump ( & dev_priv -> huc . fw , & p <S2SV_ModEnd> ) ; intel_runtime_pm_get
|
534,642 |
CWE-000 static PyObject * bytes_concat ( PyObject * a , PyObject * b ) { Py_buffer va , vb ; PyObject * result = NULL ; va . len = - 1 ; vb . len = - 1 ; if ( PyObject_GetBuffer ( a , & va , PyBUF_SIMPLE ) != 0 || PyObject_GetBuffer ( b , & vb , PyBUF_SIMPLE ) != 0 ) { PyErr_Format ( PyExc_TypeError , "can\'t<S2SV_blank>concat<S2SV_blank>%.100s<S2SV_blank>to<S2SV_blank>%.100s" , <S2SV_StartBug> Py_TYPE ( a ) -> tp_name , Py_TYPE ( b ) -> tp_name ) ; <S2SV_EndBug> goto done ; } if ( va . len == 0 && PyBytes_CheckExact ( b ) ) { result = b ; Py_INCREF ( result ) ; goto done ; } if ( vb . len == 0 && PyBytes_CheckExact ( a ) ) { result = a ; Py_INCREF ( result ) ; goto done ; } if ( va . len > PY_SSIZE_T_MAX - vb . len ) { PyErr_NoMemory ( ) ; goto done ; } result = PyBytes_FromStringAndSize ( NULL , va . len + vb . len ) ; if ( result != NULL ) { memcpy ( PyBytes_AS_STRING ( result ) , va . buf , va . len ) ; memcpy ( PyBytes_AS_STRING ( result ) + va . len , vb . buf , vb . len ) ; } done : if ( va . len != - 1 ) PyBuffer_Release ( & va ) ; if ( vb . len != - 1 ) PyBuffer_Release ( & vb ) ; return result ; }
|
<S2SV_ModStart> , Py_TYPE ( b <S2SV_ModEnd> ) -> tp_name <S2SV_ModStart> , Py_TYPE ( a <S2SV_ModEnd> ) -> tp_name
|
534,643 |
CWE-000 void editorDrawRows ( ) { int y ; for ( y = 0 ; y < E . screenrows ; y ++ ) { <S2SV_StartBug> write ( STDERR_FILENO , "~\\r\\n" , 3 ) ; <S2SV_EndBug> } <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> ( STDERR_FILENO , "~" , 1 ) ; if ( y < E . screenrows - 1 ) { write ( STDOUT_FILENO , "\\r\\n" , 2 <S2SV_ModEnd> ) ; } <S2SV_ModStart> ; } } }
|
534,644 |
CWE-000 static int dpdk_fin_input ( libtrace_t * libtrace ) { libtrace_list_node_t * n ; if ( libtrace -> format_data != NULL ) { if ( FORMAT ( libtrace ) -> port != 0xFF ) rte_eth_dev_callback_unregister ( FORMAT ( libtrace ) -> port , RTE_ETH_EVENT_INTR_LSC , dpdk_lsc_callback , FORMAT ( libtrace ) ) ; rte_eth_dev_close ( FORMAT ( libtrace ) -> port ) ; dpdk_free_memory ( FORMAT ( libtrace ) -> pktmbuf_pool , FORMAT ( libtrace ) -> nic_numa_node ) ; for ( n = FORMAT ( libtrace ) -> per_stream -> head ; n ; n = n -> next ) { dpdk_per_stream_t * stream = n -> data ; if ( stream -> mempool ) dpdk_free_memory ( stream -> mempool , rte_lcore_to_socket_id ( stream -> lcore ) ) ; } libtrace_list_deinit ( FORMAT ( libtrace ) -> per_stream ) ; <S2SV_StartBug> free ( libtrace -> format_data ) ; <S2SV_EndBug> } return 0 ; }
|
<S2SV_ModStart> per_stream ) ; if ( FORMAT ( libtrace ) -> rss_key ) free ( FORMAT ( libtrace ) -> rss_key ) ;
|
534,645 |
CWE-000 static inline void high_threshold_int_check ( struct adux1050_chip * adux1050 , u16 high_status_change ) { u8 stg_cnt ; u8 temp_ht_enable = adux1050 -> high_thresh_enable ; u8 temp_ht_intr_err = GET_HIGH_STATUS ( adux1050 -> user_intr_err ) ; for ( stg_cnt = 0 ; stg_cnt < TOTAL_STG ; stg_cnt ++ ) { if ( ( ! ( temp_ht_intr_err & 1 ) ) && ( temp_ht_enable & 1 ) ) { if ( high_status_change & 1 ) { if ( adux1050 -> high_status & 1 ) { <S2SV_StartBug> dev_info ( adux1050 -> dev , "St<S2SV_blank>=<S2SV_blank>%de\\n" , <S2SV_EndBug> stg_cnt ) ; if ( adux1050 -> send_event ) { # ifdef CONFIG_SOMC_EXTENSION if ( stg_cnt == adux1050 -> volume_down_stg ) { input_event ( adux1050 -> input , EV_KEY , KEY_VOLUMEDOWN , 1 ) ; } else if ( stg_cnt == adux1050 -> volume_up_stg ) { input_event ( adux1050 -> input , EV_KEY , KEY_VOLUMEUP , 1 ) ; } else if ( stg_cnt == adux1050 -> hdmi_switch_stg && adux1050 -> hdmi_detect ) { input_event ( adux1050 -> input , EV_KEY , KEY_SWITCHVIDEOMODE , 1 ) ; } # endif indicate_active_state ( adux1050 , stg_cnt , TH_HIGH ) ; } } else { <S2SV_StartBug> dev_info ( adux1050 -> dev , "St<S2SV_blank>=<S2SV_blank>%dx\\n" , <S2SV_EndBug> stg_cnt ) ; if ( adux1050 -> send_event ) { # ifdef CONFIG_SOMC_EXTENSION if ( stg_cnt == adux1050 -> volume_down_stg ) { input_event ( adux1050 -> input , EV_KEY , KEY_VOLUMEDOWN , 0 ) ; } else if ( stg_cnt == adux1050 -> volume_up_stg ) { input_event ( adux1050 -> input , EV_KEY , KEY_VOLUMEUP , 0 ) ; } else if ( stg_cnt == adux1050 -> hdmi_switch_stg && adux1050 -> hdmi_detect ) { input_event ( adux1050 -> input , EV_KEY , KEY_SWITCHVIDEOMODE , 0 ) ; } # endif indicate_idle_state ( adux1050 , stg_cnt , TH_HIGH ) ; } } } } temp_ht_enable = temp_ht_enable >> 1 ; high_status_change = high_status_change >> 1 ; adux1050 -> high_status = adux1050 -> high_status >> 1 ; temp_ht_intr_err = temp_ht_intr_err >> 1 ; } }
|
<S2SV_ModStart> 1 ) { dev_dbg <S2SV_ModEnd> ( adux1050 -> <S2SV_ModStart> } else { dev_dbg <S2SV_ModEnd> ( adux1050 ->
|
534,646 |
CWE-000 int fpga_driver_write_buffer_to_cl ( int slot_id , int channel , int fd , size_t buffer_size , size_t address ) { int rc ; size_t write_offset = 0 ; while ( write_offset < buffer_size ) { if ( write_offset != 0 ) { printf ( "Partial<S2SV_blank>write<S2SV_blank>by<S2SV_blank>driver,<S2SV_blank>trying<S2SV_blank>again<S2SV_blank>with<S2SV_blank>remainder<S2SV_blank>of<S2SV_blank>buffer<S2SV_blank>(%lu<S2SV_blank>bytes)\\n" , buffer_size - write_offset ) ; } rc = pwrite ( fd , write_buffer + write_offset , buffer_size - write_offset , <S2SV_StartBug> 0x10000000 + channel * MEM_16G + write_offset ) ; <S2SV_EndBug> if ( rc < 0 ) { fail_on ( ( rc = ( rc < 0 ) ? errno : 0 ) , out , "call<S2SV_blank>to<S2SV_blank>pwrite<S2SV_blank>failed." ) ; } write_offset += rc ; } rc = 0 ; out : return rc ; }
|
<S2SV_ModStart> - write_offset , address <S2SV_ModEnd> + write_offset )
|
534,647 |
CWE-000 int drm_writeback_connector_init ( struct drm_device * dev , struct drm_writeback_connector * wb_connector , const struct drm_connector_funcs * con_funcs , const struct drm_encoder_helper_funcs * enc_helper_funcs , const u32 * formats , int n_formats ) { struct drm_property_blob * blob ; struct drm_connector * connector = & wb_connector -> base ; struct drm_mode_config * config = & dev -> mode_config ; int ret = create_writeback_properties ( dev ) ; if ( ret != 0 ) return ret ; blob = drm_property_create_blob ( dev , n_formats * sizeof ( * formats ) , formats ) ; if ( IS_ERR ( blob ) ) return PTR_ERR ( blob ) ; drm_encoder_helper_add ( & wb_connector -> encoder , enc_helper_funcs ) ; ret = drm_encoder_init ( dev , & wb_connector -> encoder , & drm_writeback_encoder_funcs , DRM_MODE_ENCODER_VIRTUAL , NULL ) ; if ( ret ) goto fail ; connector -> interlace_allowed = 0 ; ret = drm_connector_init ( dev , connector , con_funcs , DRM_MODE_CONNECTOR_WRITEBACK ) ; if ( ret ) goto connector_fail ; <S2SV_StartBug> ret = drm_mode_connector_attach_encoder ( connector , <S2SV_EndBug> & wb_connector -> encoder ) ; if ( ret ) goto attach_fail ; INIT_LIST_HEAD ( & wb_connector -> job_queue ) ; spin_lock_init ( & wb_connector -> job_lock ) ; wb_connector -> fence_context = dma_fence_context_alloc ( 1 ) ; spin_lock_init ( & wb_connector -> fence_lock ) ; snprintf ( wb_connector -> timeline_name , sizeof ( wb_connector -> timeline_name ) , "CONNECTOR:%d-%s" , connector -> base . id , connector -> name ) ; drm_object_attach_property ( & connector -> base , config -> writeback_out_fence_ptr_property , 0 ) ; drm_object_attach_property ( & connector -> base , config -> writeback_fb_id_property , 0 ) ; drm_object_attach_property ( & connector -> base , config -> writeback_pixel_formats_property , blob -> base . id ) ; wb_connector -> pixel_formats_blob_ptr = blob ; return 0 ; attach_fail : drm_connector_cleanup ( connector ) ; connector_fail : drm_encoder_cleanup ( & wb_connector -> encoder ) ; fail : drm_property_blob_put ( blob ) ; return ret ; }
|
<S2SV_ModStart> ; ret = drm_connector_attach_encoder <S2SV_ModEnd> ( connector ,
|
534,648 |
CWE-000 static void * _PyMem_DebugRawRealloc ( void * ctx , void * p , size_t nbytes ) { debug_alloc_api_t * api = ( debug_alloc_api_t * ) ctx ; <S2SV_StartBug> uint8_t * q = ( uint8_t * ) p , * oldq ; <S2SV_EndBug> uint8_t * tail ; size_t total ; size_t original_nbytes ; int i ; if ( p == NULL ) return _PyMem_DebugRawAlloc ( 0 , ctx , nbytes ) ; _PyMem_DebugCheckAddress ( api -> api_id , p ) ; bumpserialno ( ) ; original_nbytes = read_size_t ( q - 2 * SST ) ; total = nbytes + 4 * SST ; if ( nbytes > PY_SSIZE_T_MAX - 4 * SST ) return NULL ; <S2SV_StartBug> oldq = q ; <S2SV_EndBug> q = ( uint8_t * ) api -> alloc . realloc ( api -> alloc . ctx , q - 2 * SST , total ) ; if ( q == NULL ) return NULL ; <S2SV_StartBug> if ( q == oldq && nbytes < original_nbytes ) { <S2SV_EndBug> memset ( q + nbytes , DEADBYTE , original_nbytes - nbytes ) ; } write_size_t ( q , nbytes ) ; assert ( q [ SST ] == ( uint8_t ) api -> api_id ) ; for ( i = 1 ; i < SST ; ++ i ) assert ( q [ SST + i ] == FORBIDDENBYTE ) ; q += 2 * SST ; tail = q + nbytes ; memset ( tail , FORBIDDENBYTE , SST ) ; write_size_t ( tail + SST , _PyRuntime . mem . serialno ) ; if ( nbytes > original_nbytes ) { memset ( q + original_nbytes , CLEANBYTE , nbytes - original_nbytes ) ; } return q ; }
|
<S2SV_ModStart> * ) p <S2SV_ModEnd> ; uint8_t * <S2SV_ModStart> return NULL ; <S2SV_ModEnd> q = ( <S2SV_ModStart> return NULL ; <S2SV_ModEnd> write_size_t ( q
|
534,649 |
CWE-000 int init_expr ( Token * t , char endChar ) { while ( node_used_ct > 0 ) { nodes [ -- node_used_ct ] . l = NULL ; nodes [ node_used_ct ] . r = NULL ; nodes [ node_used_ct ] . tkn = NULL ; nodes [ node_used_ct ] . depth = 0 ; nodes [ node_used_ct ] . loc = 0 ; } <S2SV_StartBug> TreeMaxWidth = 0 ; <S2SV_EndBug> TreeMaxDepth = 0 ; TreeMinWidth = 0 ; int len , nest = 0 ; for ( len = 0 ; ! ( t -> kind == endChar && nest == 0 ) ; len ++ ) { expr_tkns [ len ] = * t ; if ( expr_tkns [ len ] . hKind == LParens ) { nest ++ ; } else if ( expr_tkns [ len ] . hKind == RParens ) { if ( nest == 0 ) error ( "Invalid<S2SV_blank>\')\',<S2SV_blank>\']\',<S2SV_blank>\'}\'" ) ; nest -- ; } nextToken ( t , 0 ) ; } arrayCount = 0 ; te_tmp = NULL ; var_tmp = NULL ; tdef_tmp = NULL ; memset ( & left_val , 0 , sizeof ( TableEntry ) ) ; left_val . var = ( VarElement * ) malloc ( sizeof ( VarElement ) ) ; memset ( left_val . var , 0 , sizeof ( VarElement ) ) ; parse_flags . f [ 0 ] = 0 ; parse_flag = & parse_flags . f [ 0 ] ; val_stack . idx = 0 ; return len ; }
|
<S2SV_ModStart> 0 ; } TreeMaxDepth <S2SV_ModEnd> = 0 ;
|
534,650 |
CWE-000 void _Class_Object_Init ( Word * word , Namespace * ns ) { Stack * nsstack = _Context_ -> Compiler0 -> NamespacesStack ; Stack_Init ( nsstack ) ; do { Word * initWord ; if ( ( initWord = _Finder_FindWord_InOneNamespace ( _Finder_ , ns , ( byte * ) "init" ) ) ) { _Stack_Push ( nsstack , ( int64 ) initWord ) ; } ns = ns -> ContainingNamespace ; } while ( ns ) ; int64 i ; SetState ( _Debugger_ , DEBUG_SHTL_OFF , true ) ; for ( i = Stack_Depth ( nsstack ) ; i > 0 ; i -- ) { Word * initWord = ( Word * ) _Stack_Pop ( nsstack ) ; DataStack_Push ( ( int64 ) word -> W_Object ) ; <S2SV_StartBug> d0 ( CfrTil_PrintDataStack ( ) ) ; <S2SV_EndBug> <S2SV_StartBug> Word_Eval ( initWord ) ; <S2SV_EndBug> d0 ( CfrTil_PrintDataStack ( ) ) ; } SetState ( _Debugger_ , DEBUG_SHTL_OFF , false ) ; }
|
<S2SV_ModStart> W_Object ) ; <S2SV_ModEnd> Word_Eval ( initWord <S2SV_ModStart> Word_Eval ( initWord <S2SV_ModEnd> ) ; }
|
534,651 |
CWE-000 int getDnsServer ( char * addr ) { int ret , i = 0 ; char ch , str [ 100 ] ; FILE * fp ; fp = fopen ( "/etc/resolv.conf" , "r" ) ; if ( fp == NULL ) { printf ( "Error<S2SV_blank>in<S2SV_blank>file<S2SV_blank>opening\\n" ) ; <S2SV_StartBug> return ; <S2SV_EndBug> } while ( ( ch = fgetc ( fp ) ) != EOF ) { str [ i ++ ] = ch ; } fclose ( fp ) ; str [ i ] = '\\0' ; printf ( "FILE<S2SV_blank>:\\n%s\\n" , str ) ; getDnsServerIp ( str , addr ) ; printf ( "DNS<S2SV_blank>IP<S2SV_blank>ADDR<S2SV_blank>:<S2SV_blank>%s\\n" , addr ) ; return 0 ; }
|
<S2SV_ModStart> ) ; return - 1
|
534,652 |
CWE-000 int ext4_get_encryption_info ( struct inode * inode ) { struct ext4_inode_info * ei = EXT4_I ( inode ) ; struct ext4_crypt_info * crypt_info ; char full_key_descriptor [ EXT4_KEY_DESC_PREFIX_SIZE + ( EXT4_KEY_DESCRIPTOR_SIZE * 2 ) + 1 ] ; struct key * keyring_key = NULL ; struct ext4_encryption_key * master_key ; struct ext4_encryption_context ctx ; const struct user_key_payload * ukp ; struct ext4_sb_info * sbi = EXT4_SB ( inode -> i_sb ) ; struct crypto_ablkcipher * ctfm ; const char * cipher_str ; int for_fname = 0 ; int mode ; int res ; if ( ei -> i_crypt_info ) return 0 ; if ( ! ext4_read_workqueue ) { res = ext4_init_crypto ( ) ; if ( res ) return res ; } res = ext4_xattr_get ( inode , EXT4_XATTR_INDEX_ENCRYPTION , EXT4_XATTR_NAME_ENCRYPTION_CONTEXT , & ctx , sizeof ( ctx ) ) ; if ( res < 0 ) { if ( ! DUMMY_ENCRYPTION_ENABLED ( sbi ) ) return res ; ctx . contents_encryption_mode = ext4_default_data_encryption_mode ( ) ; ctx . filenames_encryption_mode = EXT4_ENCRYPTION_MODE_AES_256_CTS ; ctx . flags = 0 ; } else if ( res != sizeof ( ctx ) ) return - EINVAL ; res = 0 ; crypt_info = kmem_cache_alloc ( ext4_crypt_info_cachep , GFP_KERNEL ) ; if ( ! crypt_info ) return - ENOMEM ; crypt_info -> ci_flags = ctx . flags ; crypt_info -> ci_data_mode = ctx . contents_encryption_mode ; crypt_info -> ci_filename_mode = ctx . filenames_encryption_mode ; crypt_info -> ci_ctfm = NULL ; memcpy ( crypt_info -> ci_master_key , ctx . master_key_descriptor , sizeof ( crypt_info -> ci_master_key ) ) ; if ( S_ISDIR ( inode -> i_mode ) || S_ISLNK ( inode -> i_mode ) ) for_fname = 1 ; else if ( ! S_ISREG ( inode -> i_mode ) ) BUG ( ) ; mode = for_fname ? crypt_info -> ci_filename_mode : crypt_info -> ci_data_mode ; switch ( mode ) { case EXT4_ENCRYPTION_MODE_AES_256_XTS : cipher_str = "xts(aes)" ; break ; case EXT4_ENCRYPTION_MODE_AES_256_CTS : cipher_str = "cts(cbc(aes))" ; break ; <S2SV_StartBug> case EXT4_ENCRYPTION_MODE_PRIVATE : <S2SV_EndBug> cipher_str = "bugon" ; break ; default : printk_once ( KERN_WARNING "ext4:<S2SV_blank>unsupported<S2SV_blank>key<S2SV_blank>mode<S2SV_blank>%d<S2SV_blank>(ino<S2SV_blank>%u)\\n" , mode , ( unsigned ) inode -> i_ino ) ; res = - ENOKEY ; goto out ; } if ( DUMMY_ENCRYPTION_ENABLED ( sbi ) ) { memset ( crypt_info -> ci_raw_key , 0x42 , EXT4_AES_256_XTS_KEY_SIZE ) ; goto got_key ; } memcpy ( full_key_descriptor , EXT4_KEY_DESC_PREFIX , EXT4_KEY_DESC_PREFIX_SIZE ) ; sprintf ( full_key_descriptor + EXT4_KEY_DESC_PREFIX_SIZE , "%*phN" , EXT4_KEY_DESCRIPTOR_SIZE , ctx . master_key_descriptor ) ; full_key_descriptor [ EXT4_KEY_DESC_PREFIX_SIZE + ( 2 * EXT4_KEY_DESCRIPTOR_SIZE ) ] = '\\0' ; keyring_key = request_key ( & key_type_logon , full_key_descriptor , NULL ) ; if ( IS_ERR ( keyring_key ) ) { res = PTR_ERR ( keyring_key ) ; keyring_key = NULL ; goto out ; } if ( keyring_key -> type != & key_type_logon ) { printk_once ( KERN_WARNING "ext4:<S2SV_blank>key<S2SV_blank>type<S2SV_blank>must<S2SV_blank>be<S2SV_blank>logon\\n" ) ; res = - ENOKEY ; goto out ; } down_read ( & keyring_key -> sem ) ; ukp = user_key_payload ( keyring_key ) ; if ( ukp -> datalen != sizeof ( struct ext4_encryption_key ) ) { res = - EINVAL ; up_read ( & keyring_key -> sem ) ; goto out ; } master_key = ( struct ext4_encryption_key * ) ukp -> data ; BUILD_BUG_ON ( EXT4_AES_128_ECB_KEY_SIZE != EXT4_KEY_DERIVATION_NONCE_SIZE ) ; if ( master_key -> size != EXT4_AES_256_XTS_KEY_SIZE ) { printk_once ( KERN_WARNING "ext4:<S2SV_blank>key<S2SV_blank>size<S2SV_blank>incorrect:<S2SV_blank>%d\\n" , master_key -> size ) ; res = - ENOKEY ; up_read ( & keyring_key -> sem ) ; goto out ; } res = ext4_derive_key_aes ( ctx . nonce , master_key -> raw , crypt_info -> ci_raw_key ) ; up_read ( & keyring_key -> sem ) ; if ( res ) goto out ; got_key : if ( for_fname || ( crypt_info -> ci_data_mode != EXT4_ENCRYPTION_MODE_PRIVATE ) ) { ctfm = crypto_alloc_ablkcipher ( cipher_str , 0 , 0 ) ; if ( ! ctfm || IS_ERR ( ctfm ) ) { res = ctfm ? PTR_ERR ( ctfm ) : - ENOMEM ; pr_debug ( "%s:<S2SV_blank>error<S2SV_blank>%d<S2SV_blank>(inode<S2SV_blank>%u)<S2SV_blank>allocating<S2SV_blank>crypto<S2SV_blank>tfm\\n" , __func__ , res , ( unsigned ) inode -> i_ino ) ; goto out ; } crypt_info -> ci_ctfm = ctfm ; crypto_ablkcipher_clear_flags ( ctfm , ~ 0 ) ; crypto_tfm_set_flags ( crypto_ablkcipher_tfm ( ctfm ) , CRYPTO_TFM_REQ_WEAK_KEY ) ; res = crypto_ablkcipher_setkey ( ctfm , crypt_info -> ci_raw_key , ext4_encryption_key_size ( mode ) ) ; if ( res ) goto out ; memzero_explicit ( crypt_info -> ci_raw_key , sizeof ( crypt_info -> ci_raw_key ) ) ; } else if ( ! ext4_is_ice_enabled ( ) ) { pr_warn ( "%s:<S2SV_blank>ICE<S2SV_blank>support<S2SV_blank>not<S2SV_blank>available\\n" , __func__ ) ; res = - EINVAL ; goto out ; } if ( cmpxchg ( & ei -> i_crypt_info , NULL , crypt_info ) != NULL ) crypt_info = NULL ; out : if ( res == - ENOKEY ) res = 0 ; key_put ( keyring_key ) ; memzero_explicit ( crypt_info -> ci_raw_key , sizeof ( crypt_info -> ci_raw_key ) ) ; ext4_free_crypt_info ( crypt_info ) ; return res ; }
|
<S2SV_ModStart> break ; case EXT4_ENCRYPTION_MODE_AES_256_HEH : cipher_str = "heh(aes)" ; break ; case
|
534,653 |
CWE-000 static enum cmd_retval cmd_new_window_exec ( struct cmd * self , struct cmdq_item * item ) { struct args * args = self -> args ; struct cmd_find_state * current = & item -> shared -> current ; struct session * s = item -> target . s ; struct winlink * wl = item -> target . wl ; struct client * c = cmd_find_client ( item , NULL , 1 ) ; int idx = item -> target . idx ; const char * cmd , * path , * template , * tmp ; char * * argv , * cause , * cp , * cwd , * name ; int argc , detached ; struct environ_entry * envent ; struct cmd_find_state fs ; if ( args_has ( args , 'a' ) && wl != NULL ) { if ( ( idx = winlink_shuffle_up ( s , wl ) ) == - 1 ) { cmdq_error ( item , "no<S2SV_blank>free<S2SV_blank>window<S2SV_blank>indexes" ) ; return ( CMD_RETURN_ERROR ) ; } } detached = args_has ( args , 'd' ) ; if ( args -> argc == 0 ) { cmd = options_get_string ( s -> options , "default-command" ) ; if ( cmd != NULL && * cmd != '\\0' ) { argc = 1 ; argv = ( char * * ) & cmd ; } else { argc = 0 ; argv = NULL ; } } else { argc = args -> argc ; argv = args -> argv ; } path = NULL ; if ( item -> client != NULL && item -> client -> session == NULL ) envent = environ_find ( item -> client -> environ , "PATH" ) ; else envent = environ_find ( s -> environ , "PATH" ) ; if ( envent != NULL ) path = envent -> value ; if ( ( tmp = args_get ( args , 'c' ) ) != NULL ) cwd = format_single ( item , tmp , c , s , NULL , NULL ) ; else cwd = xstrdup ( server_client_get_cwd ( item -> client , s ) ) ; if ( ( tmp = args_get ( args , 'n' ) ) != NULL ) name = format_single ( item , tmp , c , s , NULL , NULL ) ; else <S2SV_StartBug> name = NULL ; <S2SV_EndBug> wl = NULL ; if ( idx != - 1 ) wl = winlink_find_by_index ( & s -> windows , idx ) ; if ( wl != NULL && args_has ( args , 'k' ) ) { notify_session_window ( "window-unlinked" , s , wl -> window ) ; wl -> flags &= ~ WINLINK_ALERTFLAGS ; winlink_stack_remove ( & s -> lastw , wl ) ; winlink_remove ( & s -> windows , wl ) ; if ( wl == s -> curw ) { detached = 0 ; s -> curw = NULL ; } } if ( idx == - 1 ) idx = - 1 - options_get_number ( s -> options , "base-index" ) ; wl = session_new ( s , name , argc , argv , path , cwd , idx , & cause ) ; if ( wl == NULL ) { cmdq_error ( item , "create<S2SV_blank>window<S2SV_blank>failed:<S2SV_blank>%s" , cause ) ; free ( cause ) ; goto error ; } if ( ! detached ) { session_select ( s , wl -> idx ) ; cmd_find_from_winlink ( current , wl , 0 ) ; server_redraw_session_group ( s ) ; } else server_status_session_group ( s ) ; if ( args_has ( args , 'P' ) ) { if ( ( template = args_get ( args , 'F' ) ) == NULL ) template = NEW_WINDOW_TEMPLATE ; cp = format_single ( item , template , c , s , wl , NULL ) ; cmdq_print ( item , "%s" , cp ) ; free ( cp ) ; } cmd_find_from_winlink ( & fs , wl , 0 ) ; hooks_insert ( s -> hooks , item , & fs , "after-new-window" ) ; free ( name ) ; free ( cwd ) ; return ( CMD_RETURN_NORMAL ) ; error : free ( name ) ; free ( cwd ) ; return ( CMD_RETURN_ERROR ) ; }
|
<S2SV_ModStart> ; else name <S2SV_ModEnd> = NULL ;
|
534,654 |
CWE-000 void HeuristicResolve ( ) { <S2SV_StartBug> struct timeval start , end ; <S2SV_EndBug> hTime = 0.0 ; hSteps = 0 ; gettimeofday ( & start , NULL ) ; int sent1 = 0 ; while ( 1 ) { if ( sentlist [ sent1 ] . num_pred == 0 ) break ; sent1 ++ ; } <S2SV_StartBug> hSteps = 20 ; <S2SV_EndBug> gettimeofday ( & end , NULL ) ; int seconds = ( end . tv_sec - start . tv_sec ) ; <S2SV_StartBug> double useconds = ( end . tv_usec + start . tv_usec ) / ( 1000000000.0 ) ; <S2SV_EndBug> hTime = seconds + useconds ; printf ( "HeuristicResolve:<S2SV_blank>#steps<S2SV_blank>=<S2SV_blank>%i,<S2SV_blank>time<S2SV_blank>=<S2SV_blank>%lg\\n\\n" , hSteps , hTime ) ; }
|
<S2SV_ModStart> start , end ; Assignment Theta [ MAXPRED ] <S2SV_ModStart> ++ ; } int heuristic [ ] = orderByPreds ( sent1 , sentlist [ sent1 ] . pred ) ; for ( i = 0 ; i < sent1 ; i ++ ) { hSteps += Unify ( sent1 , heuristic [ i ] , Theta ) ; } <S2SV_ModEnd> gettimeofday ( & <S2SV_ModStart> end . tv_usec - <S2SV_ModEnd> start . tv_usec
|
534,655 |
CWE-000 static grpc_resolver * dns_create ( grpc_resolver_args * args , const char * default_port , <S2SV_StartBug> const char * lb_policy_name ) { <S2SV_EndBug> if ( 0 != strcmp ( args -> uri -> authority , "" ) ) { gpr_log ( GPR_ERROR , "authority<S2SV_blank>based<S2SV_blank>dns<S2SV_blank>uri\'s<S2SV_blank>not<S2SV_blank>supported" ) ; return NULL ; } <S2SV_StartBug> const char * path = args -> uri -> path ; <S2SV_EndBug> if ( path [ 0 ] == '/' ) ++ path ; <S2SV_StartBug> char * proxy_name = grpc_get_http_proxy_server ( ) ; <S2SV_EndBug> <S2SV_StartBug> dns_resolver * r = gpr_malloc ( sizeof ( dns_resolver ) ) ; <S2SV_EndBug> memset ( r , 0 , sizeof ( * r ) ) ; gpr_ref_init ( & r -> refs , 1 ) ; gpr_mu_init ( & r -> mu ) ; grpc_resolver_init ( & r -> base , & dns_resolver_vtable ) ; r -> target_name = gpr_strdup ( path ) ; r -> name_to_resolve = proxy_name == NULL ? gpr_strdup ( path ) : proxy_name ; r -> default_port = gpr_strdup ( default_port ) ; gpr_backoff_init ( & r -> backoff_state , BACKOFF_MULTIPLIER , BACKOFF_JITTER , BACKOFF_MIN_SECONDS * 1000 , BACKOFF_MAX_SECONDS * 1000 ) ; r -> lb_policy_name = gpr_strdup ( lb_policy_name ) ; return & r -> base ; }
|
<S2SV_ModStart> lb_policy_name ) { dns_resolver * r ; grpc_error * error = GRPC_ERROR_NONE ; char * proxy_name ; const char * path = args -> uri -> path ; <S2SV_ModStart> NULL ; } error = grpc_ares_init ( ) ; if ( error != GRPC_ERROR_NONE ) { GRPC_LOG_IF_ERROR ( "ares_library_init()<S2SV_blank>failed" , error ) ; return NULL ; } <S2SV_ModEnd> if ( path <S2SV_ModStart> ++ path ; <S2SV_ModEnd> proxy_name = grpc_get_http_proxy_server <S2SV_ModStart> ( ) ; <S2SV_ModEnd> r = gpr_malloc
|
534,656 |
CWE-000 void cdrom_phase_callback ( uint8_t id ) { switch ( cdrom [ id ] . packet_status ) { case CDROM_PHASE_IDLE : cdrom_log ( "CD-ROM<S2SV_blank>%i:<S2SV_blank>CDROM_PHASE_IDLE\\n" , id ) ; cdrom [ id ] . pos = 0 ; cdrom [ id ] . phase = 1 ; cdrom [ id ] . status = READY_STAT | DRQ_STAT | ( cdrom [ id ] . status & ERR_STAT ) ; return ; case CDROM_PHASE_COMMAND : cdrom_log ( "CD-ROM<S2SV_blank>%i:<S2SV_blank>CDROM_PHASE_COMMAND\\n" , id ) ; cdrom [ id ] . status = BUSY_STAT | ( cdrom [ id ] . status & ERR_STAT ) ; memcpy ( cdrom [ id ] . atapi_cdb , ( uint8_t * ) cdrom [ id ] . buffer , cdrom [ id ] . cdb_len ) ; cdrom_command ( id , cdrom [ id ] . atapi_cdb ) ; return ; case CDROM_PHASE_COMPLETE : cdrom_log ( "CD-ROM<S2SV_blank>%i:<S2SV_blank>CDROM_PHASE_COMPLETE\\n" , id ) ; cdrom [ id ] . status = READY_STAT ; cdrom [ id ] . phase = 3 ; cdrom [ id ] . packet_status = 0xFF ; <S2SV_StartBug> ui_sb_update_icon ( SB_CDROM | id , 0 ) ; <S2SV_EndBug> cdrom_irq_raise ( id ) ; return ; case CDROM_PHASE_DATA_OUT : cdrom_log ( "CD-ROM<S2SV_blank>%i:<S2SV_blank>CDROM_PHASE_DATA_OUT\\n" , id ) ; cdrom [ id ] . status = READY_STAT | DRQ_STAT | ( cdrom [ id ] . status & ERR_STAT ) ; cdrom [ id ] . phase = 0 ; cdrom_irq_raise ( id ) ; return ; case CDROM_PHASE_DATA_OUT_DMA : cdrom_log ( "CD-ROM<S2SV_blank>%i:<S2SV_blank>CDROM_PHASE_DATA_OUT_DMA\\n" , id ) ; cdrom_read_from_dma ( id ) ; cdrom [ id ] . packet_status = CDROM_PHASE_COMPLETE ; cdrom [ id ] . status = READY_STAT ; cdrom [ id ] . phase = 3 ; ui_sb_update_icon ( SB_CDROM | id , 0 ) ; cdrom_irq_raise ( id ) ; return ; case CDROM_PHASE_DATA_IN : cdrom_log ( "CD-ROM<S2SV_blank>%i:<S2SV_blank>CDROM_PHASE_DATA_IN\\n" , id ) ; cdrom [ id ] . status = READY_STAT | DRQ_STAT | ( cdrom [ id ] . status & ERR_STAT ) ; cdrom [ id ] . phase = 2 ; cdrom_irq_raise ( id ) ; return ; case CDROM_PHASE_DATA_IN_DMA : cdrom_log ( "CD-ROM<S2SV_blank>%i:<S2SV_blank>CDROM_PHASE_DATA_IN_DMA\\n" , id ) ; cdrom_write_to_dma ( id ) ; cdrom [ id ] . packet_status = CDROM_PHASE_COMPLETE ; cdrom [ id ] . status = READY_STAT ; cdrom [ id ] . phase = 3 ; ui_sb_update_icon ( SB_CDROM | id , 0 ) ; cdrom_irq_raise ( id ) ; return ; case CDROM_PHASE_ERROR : cdrom_log ( "CD-ROM<S2SV_blank>%i:<S2SV_blank>CDROM_PHASE_ERROR\\n" , id ) ; cdrom [ id ] . status = READY_STAT | ERR_STAT ; cdrom [ id ] . phase = 3 ; <S2SV_StartBug> cdrom_irq_raise ( id ) ; <S2SV_EndBug> return ; } }
|
<S2SV_ModStart> = 0xFF ; cdrom_buf_free ( id ) ; <S2SV_ModStart> = 3 ; cdrom_buf_free ( id ) ; <S2SV_ModStart> cdrom_irq_raise ( id ) ; ui_sb_update_icon ( SB_CDROM | id , 0
|
534,657 |
CWE-000 gint main ( gint argc , gchar * * argv ) { g_test_init ( & argc , & argv , NULL ) ; g_test_message ( "Testing<S2SV_blank>filesystem<S2SV_blank>miner" ) ; ADD_TEST ( "/indexing-tree/recursive-indexing" , test_recursive_indexing ) ; ADD_TEST ( "/indexing-tree/non-recursive-indexing" , <S2SV_StartBug> test_recursive_indexing ) ; <S2SV_EndBug> ADD_TEST ( "/indexing-tree/separate-recursive-and-non-recursive" , test_separate_recursive_and_non_recursive ) ; ADD_TEST ( "/indexing-tree/recursive-in-non-recursive" , test_recursive_in_non_recursive ) ; ADD_TEST ( "/indexing-tree/non-recursive-in-recursive" , test_non_recursive_in_recursive ) ; ADD_TEST ( "/indexing-tree/empty-root" , test_empty_root ) ; ADD_TEST ( "/indexing-tree/missing-root" , test_missing_root ) ; ADD_TEST ( "/indexing-tree/skip-hidden-files" , test_skip_hidden_files ) ; ADD_TEST ( "/indexing-tree/index-hidden-files" , test_index_hidden_files ) ; ADD_TEST ( "/indexing-tree/file-filter-default-accept" , test_file_filter_default_accept ) ; ADD_TEST ( "/indexing-tree/file-filter-default-deny" , test_file_filter_default_deny ) ; ADD_TEST ( "/indexing-tree/directory-filter-default-accept" , test_directory_filter_default_accept ) ; ADD_TEST ( "/indexing-tree/directory-filter-default-deny" , test_directory_filter_default_deny ) ; ADD_TEST ( "/indexing-tree/content-filter-default-accept" , test_content_filter_default_accept ) ; ADD_TEST ( "/indexing-tree/content-filter-default-deny" , test_content_filter_default_deny ) ; ADD_TEST ( "/indexing-tree/content-filter-on-parent-root" , test_content_filter_on_parent_root ) ; ADD_TEST ( "/non-monitored/create" , test_non_monitored_create ) ; ADD_TEST ( "/non-monitored/update" , test_non_monitored_update ) ; ADD_TEST ( "/non-monitored/delete" , test_non_monitored_delete ) ; ADD_TEST ( "/non-monitored/move" , test_non_monitored_move ) ; ADD_TEST ( "/monitored/create" , test_monitored_create ) ; ADD_TEST ( "/monitored/update" , test_monitored_update ) ; ADD_TEST ( "/monitored/delete" , test_monitored_delete ) ; ADD_TEST ( "/monitored/move" , test_monitored_move ) ; ADD_TEST ( "/monitored/atomic-replace" , test_monitored_atomic_replace ) ; ADD_TEST ( "monitored/changes-after-no-mtime-check" , test_changes_after_no_mtime_check ) ; ADD_TEST ( "event-queue/create-and-update" , test_event_queue_create_and_update ) ; ADD_TEST ( "event-queue/create-and-delete" , test_event_queue_create_and_delete ) ; ADD_TEST ( "event-queue/create-and-move" , <S2SV_StartBug> test_event_queue_create_and_delete ) ; <S2SV_EndBug> ADD_TEST ( "event-queue/update-and-update" , test_event_queue_update_and_update ) ; ADD_TEST ( "event-queue/update-and-delete" , test_event_queue_update_and_delete ) ; ADD_TEST ( "event-queue/update-and-move" , test_event_queue_update_and_move ) ; ADD_TEST ( "event-queue/delete-and-create" , test_event_queue_delete_and_create ) ; ADD_TEST ( "event-queue/move-and-update" , test_event_queue_move_and_update ) ; ADD_TEST ( "event-queue/move-and-create-origin" , test_event_queue_move_and_create_origin ) ; ADD_TEST ( "event-queue/move-and-delete" , test_event_queue_move_and_delete ) ; ADD_TEST ( "event-queue/move-and-move" , test_event_queue_move_and_move ) ; ADD_TEST ( "event-queue/move-and-move-back" , test_event_queue_move_and_move_back ) ; ADD_TEST ( "api/check_file" , test_api_check_file ) ; return g_test_run ( ) ; }
|
<S2SV_ModStart> ( "/indexing-tree/non-recursive-indexing" , test_non_recursive_indexing <S2SV_ModEnd> ) ; ADD_TEST <S2SV_ModStart> ( "event-queue/create-and-move" , test_event_queue_create_and_move <S2SV_ModEnd> ) ; ADD_TEST
|
534,658 |
CWE-000 void * totemknet_buffer_alloc ( void ) { <S2SV_StartBug> return malloc ( FRAME_SIZE_MAX ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> return malloc ( KNET_MAX_PACKET_SIZE <S2SV_ModEnd> ) ; }
|
534,659 |
CWE-000 void admin_get_stats ( network_mysqld_con * con , char * p ) { if ( ! p ) { admin_supported_stats ( con ) ; return ; } if ( con -> is_admin_client ) { con -> admin_read_merge = 1 ; return ; } char buffer [ 32 ] ; cetus_pid_t process_id = getpid ( ) ; sprintf ( buffer , "%d" , process_id ) ; GPtrArray * fields = network_mysqld_proto_fielddefs_new ( ) ; MAKE_FIELD_DEF_3_COL ( fields , "PID" , "name" , "value" ) ; GPtrArray * rows = g_ptr_array_new_with_free_func ( ( void * ) network_mysqld_mysql_field_row_free ) ; chassis * chas = con -> srv ; query_stats_t * stats = & ( chas -> query_stats ) ; char buf1 [ 32 ] = { 0 } ; char buf2 [ 32 ] = { 0 } ; if ( strcasecmp ( p , "client_query" ) == 0 ) { snprintf ( buf1 , 32 , "%lu" , stats -> client_query . ro ) ; snprintf ( buf2 , 32 , "%lu" , stats -> client_query . rw ) ; APPEND_ROW_3_COL ( rows , g_strdup ( buffer ) , "client_query.ro" , buf1 ) ; APPEND_ROW_3_COL ( rows , g_strdup ( buffer ) , "client_query.rw" , buf2 ) ; } else if ( strcasecmp ( p , "proxyed_query" ) == 0 ) { snprintf ( buf1 , 32 , "%lu" , stats -> proxyed_query . ro ) ; snprintf ( buf2 , 32 , "%lu" , stats -> proxyed_query . rw ) ; APPEND_ROW_3_COL ( rows , g_strdup ( buffer ) , "proxyed_query.ro" , buf1 ) ; APPEND_ROW_3_COL ( rows , g_strdup ( buffer ) , "proxyed_query.rw" , buf2 ) ; } else if ( strcasecmp ( p , "query_time_table" ) == 0 ) { int i = 0 ; for ( i ; i < MAX_QUERY_TIME && stats -> query_time_table [ i ] ; ++ i ) { GPtrArray * row = g_ptr_array_new_with_free_func ( g_free ) ; g_ptr_array_add ( row , g_strdup ( buffer ) ) ; g_ptr_array_add ( row , g_strdup_printf ( "query_time_table.%d" , i + 1 ) ) ; g_ptr_array_add ( row , g_strdup_printf ( "%lu" , stats -> query_time_table [ i ] ) ) ; g_ptr_array_add ( rows , row ) ; } } else if ( strcasecmp ( p , "query_wait_table" ) == 0 ) { int i = 0 ; for ( i ; i < MAX_WAIT_TIME && stats -> query_wait_table [ i ] ; ++ i ) { GPtrArray * row = g_ptr_array_new_with_free_func ( g_free ) ; g_ptr_array_add ( row , g_strdup ( buffer ) ) ; g_ptr_array_add ( row , g_strdup_printf ( "query_wait_table.%d" , i + 1 ) ) ; g_ptr_array_add ( row , g_strdup_printf ( "%lu" , stats -> query_wait_table [ i ] ) ) ; g_ptr_array_add ( rows , row ) ; } } else if ( strcasecmp ( p , "server_query_details" ) == 0 ) { int i = 0 ; <S2SV_StartBug> for ( i ; i < network_backends_count ( chas -> priv -> backends ) <S2SV_EndBug> && i < MAX_SERVER_NUM ; ++ i ) { GPtrArray * row = g_ptr_array_new_with_free_func ( g_free ) ; g_ptr_array_add ( row , g_strdup ( buffer ) ) ; g_ptr_array_add ( row , g_strdup_printf ( "server_query_details.%d.ro" , i + 1 ) ) ; g_ptr_array_add ( row , g_strdup_printf ( "%lu" , stats -> server_query_details [ i ] . ro ) ) ; g_ptr_array_add ( rows , row ) ; row = g_ptr_array_new_with_free_func ( g_free ) ; g_ptr_array_add ( row , g_strdup ( buffer ) ) ; g_ptr_array_add ( row , g_strdup_printf ( "server_query_details.%d.rw" , i + 1 ) ) ; g_ptr_array_add ( row , g_strdup_printf ( "%lu" , stats -> server_query_details [ i ] . rw ) ) ; g_ptr_array_add ( rows , row ) ; } } else if ( strcasecmp ( p , "reset" ) == 0 ) { APPEND_ROW_3_COL ( rows , g_strdup ( buffer ) , "reset" , "0" ) ; } else { APPEND_ROW_3_COL ( rows , g_strdup ( buffer ) , ( char * ) p , ( char * ) p ) ; } network_mysqld_con_send_resultset ( con -> client , fields , rows ) ; network_mysqld_proto_fielddefs_free ( fields ) ; g_ptr_array_free ( rows , TRUE ) ; }
|
<S2SV_ModStart> = 0 ; int backends_num = network_backends_count ( chas -> priv -> backends ) ; <S2SV_ModStart> ; i < backends_num <S2SV_ModEnd> && i <
|
534,660 |
CWE-000 void sntp_set_system_time ( u32_t sec ) { char buf [ 32 ] ; struct tm current_time_val ; time_t current_time = ( time_t ) sec ; # ifdef _MSC_VER localtime_s ( & current_time_val , & current_time ) ; # else localtime_r ( & current_time , & current_time_val ) ; # endif strftime ( buf , sizeof ( buf ) , "%d.%m.%Y<S2SV_blank>%H:%M:%S" , & current_time_val ) ; <S2SV_StartBug> printf ( "SNTP<S2SV_blank>time:<S2SV_blank>%s\\n" , buf ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> current_time_val ) ; LWIP_PLATFORM_DIAG ( <S2SV_ModEnd> ( "SNTP<S2SV_blank>time:<S2SV_blank>%s\\n" , <S2SV_ModStart> , buf ) )
|
534,661 |
CWE-000 static inline void * _sched_main ( void * data ) { thread_set_name ( "PbWorker" ) ; sched_loop_t * context = ( sched_loop_t * ) data ; context -> started = 1 ; sched_task_context_t * stc = NULL ; if ( NULL == ( stc = sched_task_context_new ( context ) ) ) ERROR_LOG_ERRNO_GOTO ( KILLED , "Cannot<S2SV_blank>initialize<S2SV_blank>the<S2SV_blank>thread<S2SV_blank>locals<S2SV_blank>for<S2SV_blank>the<S2SV_blank>scheduler<S2SV_blank>thread<S2SV_blank>%u" , context -> thread_id ) ; if ( ERROR_CODE ( int ) == sched_rscope_init_thread ( ) ) ERROR_LOG_ERRNO_GOTO ( KILLED , "Cannot<S2SV_blank>initialize<S2SV_blank>the<S2SV_blank>thread<S2SV_blank>locals<S2SV_blank>for<S2SV_blank>request<S2SV_blank>local<S2SV_blank>scope<S2SV_blank>for<S2SV_blank>thread<S2SV_blank>%u" , context -> thread_id ) ; LOG_DEBUG ( "Scheduler<S2SV_blank>%u:<S2SV_blank>loop<S2SV_blank>started" , context -> thread_id ) ; for ( ; ! _killed ; ) { if ( context -> front == context -> rear ) { struct timespec abstime ; struct timeval now ; gettimeofday ( & now , NULL ) ; abstime . tv_sec = now . tv_sec + 1 ; abstime . tv_nsec = 0 ; if ( pthread_mutex_lock ( & context -> mutex ) < 0 ) LOG_WARNING_ERRNO ( "Cannot<S2SV_blank>acquire<S2SV_blank>the<S2SV_blank>scheduler<S2SV_blank>event<S2SV_blank>mutex" ) ; while ( context -> rear == context -> front ) { if ( pthread_cond_timedwait ( & context -> cond , & context -> mutex , & abstime ) < 0 && errno != ETIMEDOUT && errno != EINTR ) LOG_WARNING_ERRNO ( "Cannot<S2SV_blank>finish<S2SV_blank>pthread_cond_timedwait" ) ; if ( _killed ) goto KILLED ; abstime . tv_sec ++ ; } if ( pthread_mutex_unlock ( & context -> mutex ) < 0 ) LOG_WARNING_ERRNO ( "Cannot<S2SV_blank>release<S2SV_blank>the<S2SV_blank>scheduler<S2SV_blank>event<S2SV_blank>mutex" ) ; } LOG_TRACE ( "Scheduler<S2SV_blank>Thread<S2SV_blank>%u:<S2SV_blank>new<S2SV_blank>event<S2SV_blank>acquired" , context -> thread_id ) ; uint32_t position = context -> front & ( context -> size - 1 ) ; itc_equeue_event_t current = context -> events [ position ] ; BARRIER ( ) ; arch_atomic_sw_increment_u32 ( & context -> front ) ; BARRIER ( ) ; if ( _dispatcher_waiting_event && ( context -> rear - context -> front == context -> size - 1 ) && ERROR_CODE ( int ) == itc_equeue_wait_interrupt ( ) ) LOG_WARNING ( "Cannot<S2SV_blank>invoke<S2SV_blank>the<S2SV_blank>wait<S2SV_blank>interrupt<S2SV_blank>callback" ) ; if ( _dispatcher_waiting ) { if ( pthread_mutex_lock ( & _dispatcher_mutex ) < 0 ) LOG_WARNING_ERRNO ( "Cannot<S2SV_blank>lock<S2SV_blank>the<S2SV_blank>dispatcher<S2SV_blank>mutex" ) ; if ( pthread_cond_signal ( & _dispatcher_cond ) < 0 ) LOG_WARNING_ERRNO ( "Cannot<S2SV_blank>notify<S2SV_blank>the<S2SV_blank>dispatcher<S2SV_blank>for<S2SV_blank>the<S2SV_blank>avaliable<S2SV_blank>space" ) ; if ( pthread_mutex_unlock ( & _dispatcher_mutex ) < 0 ) LOG_WARNING_ERRNO ( "Cannot<S2SV_blank>unlock<S2SV_blank>the<S2SV_blank>dispatcher<S2SV_blank>mutex" ) ; } switch ( current . type ) { case ITC_EQUEUE_EVENT_TYPE_IO : arch_atomic_sw_increment_u32 ( & context -> num_running_reqs ) ; BARRIER ( ) ; arch_atomic_sw_increment_u32 ( & context -> pending_reqs_id_begin ) ; if ( sched_task_new_request ( stc , _service , current . io . in , current . io . out ) == ERROR_CODE ( sched_task_request_t ) ) LOG_ERROR ( "Cannot<S2SV_blank>add<S2SV_blank>the<S2SV_blank>incoming<S2SV_blank>request<S2SV_blank>to<S2SV_blank>scheduler" ) ; uint32_t concurrency = sched_task_num_concurrent_requests ( stc ) ; if ( ERROR_CODE ( uint32_t ) == concurrency ) { LOG_WARNING ( "Cannot<S2SV_blank>get<S2SV_blank>the<S2SV_blank>size<S2SV_blank>of<S2SV_blank>concurrent<S2SV_blank>tasks" ) ; break ; } arch_atomic_sw_assignment_u32 ( & context -> num_running_reqs , concurrency ) ; break ; case ITC_EQUEUE_EVENT_TYPE_TASK : if ( sched_task_async_completed ( current . task . task ) == ERROR_CODE ( int ) ) LOG_ERROR ( "Cannot<S2SV_blank>notify<S2SV_blank>the<S2SV_blank>scheduler<S2SV_blank>about<S2SV_blank>the<S2SV_blank>task<S2SV_blank>completion" ) ; break ; default : LOG_ERROR ( "Invalid<S2SV_blank>task<S2SV_blank>type" ) ; } while ( sched_step_next ( stc , _mod_mem ) > 0 && ! _killed ) ; uint32_t concurrency = sched_task_num_concurrent_requests ( stc ) ; arch_atomic_sw_assignment_u32 ( & context -> num_running_reqs , concurrency ) ; BARRIER ( ) ; if ( _dispatcher_waiting_event && ! ITC_EQUEUE_EVENT_MASK_ALLOWS ( _last_mask , ITC_EQUEUE_EVENT_TYPE_IO ) && ! _scheduler_saturated ( context ) && ERROR_CODE ( int ) == itc_equeue_wait_interrupt ( ) ) LOG_ERROR ( "Cannot<S2SV_blank>interrupt<S2SV_blank>the<S2SV_blank>equeue" ) ; <S2SV_StartBug> } <S2SV_EndBug> KILLED : LOG_INFO ( "Scheduler<S2SV_blank>thread<S2SV_blank>%u<S2SV_blank>gets<S2SV_blank>killed" , context -> thread_id ) ; if ( NULL != stc && ERROR_CODE ( int ) == sched_task_context_free ( stc ) ) LOG_WARNING ( "Cannot<S2SV_blank>finalize<S2SV_blank>the<S2SV_blank>thread<S2SV_blank>locals<S2SV_blank>for<S2SV_blank>scheduler<S2SV_blank>%d" , context -> thread_id ) ; if ( ERROR_CODE ( int ) == sched_rscope_finalize_thread ( ) ) LOG_WARNING ( "Cannot<S2SV_blank>finalize<S2SV_blank>the<S2SV_blank>thread<S2SV_blank>locals<S2SV_blank>for<S2SV_blank>the<S2SV_blank>request<S2SV_blank>local<S2SV_blank>scope<S2SV_blank>for<S2SV_blank>thread<S2SV_blank>%u" , context -> thread_id ) ; return NULL ; }
|
<S2SV_ModStart> "Cannot<S2SV_blank>interrupt<S2SV_blank>the<S2SV_blank>equeue" ) ; if ( _dispatcher_waiting ) { if ( pthread_mutex_lock ( & _dispatcher_mutex ) < 0 ) LOG_WARNING_ERRNO ( "Cannot<S2SV_blank>lock<S2SV_blank>the<S2SV_blank>dispatcher<S2SV_blank>mutex" ) ; if ( pthread_cond_signal ( & _dispatcher_cond ) < 0 ) LOG_WARNING_ERRNO ( "Cannot<S2SV_blank>notify<S2SV_blank>the<S2SV_blank>dispatcher<S2SV_blank>for<S2SV_blank>the<S2SV_blank>avaliable<S2SV_blank>space" ) ; if ( pthread_mutex_unlock ( & _dispatcher_mutex ) < 0 ) LOG_WARNING_ERRNO ( "Cannot<S2SV_blank>unlock<S2SV_blank>the<S2SV_blank>dispatcher<S2SV_blank>mutex" ) ; }
|
534,662 |
CWE-000 void task_print_stats ( ) { <S2SV_StartBug> unsigned i ; <S2SV_EndBug> PRINTF ( "REAL<S2SV_blank>TIME<S2SV_blank>end<S2SV_blank>is<S2SV_blank>65536*%u+%u\\r\\n" , overflow , ( unsigned ) TBR ) ; BLOCK_PRINTF_BEGIN ( ) ; BLOCK_PRINTF ( "filter:\\r\\n" ) ; for ( i = 0 ; i < NUM_BUCKETS ; ++ i ) { BLOCK_PRINTF ( "%04x<S2SV_blank>" , GV ( filter , i ) ) ; if ( i > 0 && ( i + 1 ) % 8 == 0 ) { BLOCK_PRINTF ( "\\r\\n" ) ; } } BLOCK_PRINTF_END ( ) ; PRINTF ( "stats:<S2SV_blank>inserts<S2SV_blank>%u<S2SV_blank>members<S2SV_blank>%u<S2SV_blank>total<S2SV_blank>%u\\r\\n" , GV ( inserted_count ) , GV ( member_count ) , NUM_INSERTS ) ; TRANSITION_TO ( task_done ) ; }
|
<S2SV_ModStart> { unsigned i <S2SV_ModEnd> ; PRINTF (
|
534,663 |
CWE-000 void new_message ( int type , const char * msgfmt , ... ) { va_list args ; size_t i ; va_start ( args , msgfmt ) ; vsnprintf ( next_msg , sizeof ( next_msg ) , msgfmt , args ) ; va_end ( args ) ; if ( msglen > 0 ) { if ( ! overstrike ) { i = strlen ( next_msg ) ; if ( ( type & MT_delayed ) == 0 ) { <S2SV_StartBug> type & MT_standout ? top_standout ( next_msg ) : <S2SV_EndBug> fputs ( next_msg , stdout ) ; <S2SV_StartBug> ( void ) clear_eol ( msglen - i ) ; <S2SV_EndBug> msglen = i ; next_msg [ 0 ] = '\\0' ; } } } else { if ( ( type & MT_delayed ) == 0 ) { <S2SV_StartBug> type & MT_standout ? top_standout ( next_msg ) : fputs ( next_msg , stdout ) ; <S2SV_EndBug> <S2SV_StartBug> msglen = strlen ( next_msg ) ; <S2SV_EndBug> next_msg [ 0 ] = '\\0' ; } } }
|
<S2SV_ModStart> 0 ) { if ( <S2SV_ModStart> type & MT_standout ) { <S2SV_ModEnd> top_standout ( next_msg <S2SV_ModStart> ( next_msg ) ; } else { <S2SV_ModEnd> fputs ( next_msg <S2SV_ModStart> stdout ) ; } <S2SV_ModEnd> clear_eol ( msglen <S2SV_ModStart> 0 ) { if ( <S2SV_ModStart> type & MT_standout ) { <S2SV_ModEnd> top_standout ( next_msg <S2SV_ModStart> ( next_msg ) ; } else { <S2SV_ModEnd> fputs ( next_msg <S2SV_ModStart> stdout ) ; }
|
534,664 |
CWE-000 void start_sequence ( struct dali_config * c , UInt32 * time ) { struct render_state * state = c -> render_state ; int i ; for ( i = 0 ; i < countof ( state -> current_frames ) ; i ++ ) { if ( state -> orig_frames [ i ] ) free ( state -> orig_frames [ i ] ) ; state -> orig_frames [ i ] = state -> current_frames [ i ] ; state -> current_frames [ i ] = state -> target_frames [ i ] ; state -> target_frames [ i ] = 0 ; state -> orig_digits [ i ] = state -> target_digits [ i ] ; } fill_target_digits ( c , time ) ; for ( i = 0 ; i < countof ( state -> target_frames ) ; i ++ ) { <S2SV_StartBug> int colonic_p = ( i == 2 || i == 5 ) ; <S2SV_EndBug> state -> target_frames [ i ] = copy_frame ( c , ( state -> target_digits [ i ] == - 1 ? ( colonic_p ? state -> empty_colon : state -> empty_frame ) : state -> base_frames [ state -> target_digits [ i ] ] ) ) ; } draw_clock ( c ) ; }
|
<S2SV_ModStart> ++ ) { state -> target_digits [ i ] = 1 ;
|
534,665 |
CWE-000 static GtkWidget * decode_add_simple_page ( decode_as_t * entry ) { GtkWidget * page , * label , * scrolled_window , * combo_box ; gchar prompt [ MAX_DECODE_AS_PROMPT_LEN ] ; page = ws_gtk_box_new ( GTK_ORIENTATION_HORIZONTAL , 5 , FALSE ) ; g_object_set_data ( G_OBJECT ( page ) , E_PAGE_ACTION , decode_simple ) ; g_object_set_data ( G_OBJECT ( page ) , E_PAGE_TABLE , ( gchar * ) entry -> table_name ) ; g_object_set_data ( G_OBJECT ( page ) , E_PAGE_DECODE_AS_DATA , ( gchar * ) entry ) ; <S2SV_StartBug> if ( entry -> num_items == 1 ) <S2SV_EndBug> { g_object_set_data ( G_OBJECT ( page ) , E_PAGE_VALUE , entry -> values [ 0 ] . build_values [ 0 ] ( & cfile . edt -> pi ) ) ; <S2SV_StartBug> g_object_set_data ( G_OBJECT ( page ) , E_PAGE_CURR_LAYER_NUM , GUINT_TO_POINTER ( ( guint ) cfile . edt -> pi . curr_layer_num ) ) ; <S2SV_EndBug> entry -> values -> label_func ( & cfile . edt -> pi , prompt ) ; label = gtk_label_new ( prompt ) ; gtk_box_pack_start ( GTK_BOX ( page ) , label , FALSE , FALSE , 0 ) ; } else { if ( entry -> pre_value_str ) { label = gtk_label_new ( entry -> pre_value_str ) ; gtk_box_pack_start ( GTK_BOX ( page ) , label , FALSE , FALSE , 0 ) ; } combo_box = decode_add_multivalue_combo_box ( page , entry ) ; gtk_box_pack_start ( GTK_BOX ( page ) , combo_box , FALSE , FALSE , 0 ) ; if ( entry -> post_value_str ) { label = gtk_label_new ( entry -> post_value_str ) ; gtk_box_pack_start ( GTK_BOX ( page ) , label , FALSE , FALSE , 0 ) ; } } scrolled_window = decode_add_simple_menu ( page , entry ) ; gtk_box_pack_start ( GTK_BOX ( page ) , scrolled_window , TRUE , TRUE , 0 ) ; decode_dimmable = g_slist_prepend ( decode_dimmable , scrolled_window ) ; return ( page ) ; }
|
<S2SV_ModStart> entry ) ; g_object_set_data ( G_OBJECT ( page ) , E_PAGE_CURR_LAYER_NUM , GUINT_TO_POINTER ( ( guint ) cfile . edt -> pi . curr_layer_num ) ) ; <S2SV_ModStart> ) ) ; <S2SV_ModEnd> entry -> values
|
534,666 |
CWE-000 int tool_tests ( void ) { <S2SV_StartBug> int result = 0 ; <S2SV_EndBug> TEST_CASE ( test_deq_basic , 0 ) ; TEST_CASE ( test_deq_basic2 , 0 ) ; TEST_CASE ( test_deq_multi , 0 ) ; TEST_CASE ( test_bitmask , 0 ) ; return result ; }
|
<S2SV_ModStart> result = 0 ; char * test_group = "tool_tests"
|
534,667 |
CWE-000 void gatMemcachedCommand ( client * c ) { unsigned long expire ; robj * o ; expire = ( unsigned long ) c -> argv [ 2 ] -> ptr ; o = lookupKeyRead ( c -> db , c -> argv [ 1 ] ) ; if ( ! o ) { <S2SV_StartBug> replyMemcachedBinaryHeaderForGetOrTouch ( c , NULL , 0 , 0 , 0 , 0 ) ; <S2SV_EndBug> return ; } c -> binary_header . request . cas = getMemcachedValueCas ( o ) ; <S2SV_StartBug> replyMemcachedBinaryHeaderForGetOrTouch ( c , NULL , 0 , getMemcachedValueLength ( o ) , getMemcachedValueFlags ( o ) , 1 ) ; <S2SV_EndBug> addReplyStringMemcached ( c , getMemcachedValuePtr ( o ) , getMemcachedValueLength ( o ) ) ; if ( expire == MEMCACHED_MAX_EXP_TIME ) { dbDelete ( c -> db , c -> argv [ 1 ] ) ; rewriteClientCommandVector ( c , 2 , shared . del , c -> argv [ 1 ] ) ; } else { if ( expire == 0 ) { removeExpire ( c -> db , c -> argv [ 1 ] ) ; rewriteClientCommandVector ( c , 2 , memcached_shared . persistcmd , c -> argv [ 1 ] ) ; } else { setExpire ( c , c -> db , c -> argv [ 1 ] , mstime ( ) + expire * 1000 ) ; rewriteClientCommandVector ( c , 3 , memcached_shared . expirecmd , c -> argv [ 1 ] , c -> argv [ 2 ] ) ; } } server . dirty ++ ; }
|
<S2SV_ModStart> o ) { if ( ! ( c -> flags & CLIENT_NO_REPLY ) ) { <S2SV_ModStart> 0 ) ; } <S2SV_ModStart> o ) ; c -> flags &= ~ CLIENT_NO_REPLY ;
|
534,668 |
CWE-000 void decrement_hour ( struct state * s ) { s -> hour -- ; <S2SV_StartBug> if ( s -> hour < 0 ) { <S2SV_EndBug> decrement_day ( s ) ; <S2SV_StartBug> s -> hour += 24 ; <S2SV_EndBug> } }
|
<S2SV_ModStart> s -> hour == <S2SV_ModEnd> 0 ) { <S2SV_ModStart> s -> hour == <S2SV_ModEnd> 24 ; }
|
534,669 |
CWE-000 void schedule_init ( ) { slotOffset_t start_slotOffset ; slotOffset_t running_slotOffset ; open_addr_t temp_neighbor ; memset ( & schedule_vars , 0 , sizeof ( schedule_vars_t ) ) ; for ( running_slotOffset = 0 ; running_slotOffset < MAXACTIVESLOTS ; running_slotOffset ++ ) { schedule_resetEntry ( & schedule_vars . scheduleBuf [ running_slotOffset ] ) ; } schedule_vars . backoffExponent = MINBE - 1 ; schedule_vars . maxActiveSlots = MAXACTIVESLOTS ; <S2SV_StartBug> start_slotOffset = SCHEDULE_MINIMAL_6TISCH_SLOTOFFSET ; <S2SV_EndBug> if ( idmanager_getIsDAGroot ( ) == TRUE ) { schedule_startDAGroot ( ) ; } start_slotOffset += SCHEDULE_MINIMAL_6TISCH_ACTIVE_CELLS ; memset ( & temp_neighbor , 0 , sizeof ( temp_neighbor ) ) ; for ( running_slotOffset = start_slotOffset ; running_slotOffset < start_slotOffset + NUMSERIALRX ; running_slotOffset ++ ) { schedule_addActiveSlot ( running_slotOffset , CELLTYPE_SERIALRX , FALSE , 0 , & temp_neighbor ) ; } open_addr_t node_229 ; uint8_t slotoffset = 10 ; uint8_t choffset = 11 ; node_229 . type = ADDR_64B ; node_229 . addr_64b [ 0 ] = 0x05 ; node_229 . addr_64b [ 1 ] = 0x43 ; node_229 . addr_64b [ 2 ] = 0x32 ; node_229 . addr_64b [ 3 ] = 0xff ; node_229 . addr_64b [ 4 ] = 0x03 ; node_229 . addr_64b [ 5 ] = 0xd7 ; node_229 . addr_64b [ 6 ] = 0xb0 ; node_229 . addr_64b [ 7 ] = 0x68 ; open_addr_t * my_address = idmanager_getMyID ( ADDR_64B ) ; if ( ! packetfunctions_sameAddress ( my_address , & node_229 ) ) { uint8_t i = 0 ; for ( i = 0 ; i < NUMBER_OF_NODES ; i ++ ) { schedule_addActiveSlot ( schedule_index ++ , CELLTYPE_RX , FALSE , 7 , & node_229 ) ; } } }
|
<S2SV_ModStart> = MAXACTIVESLOTS ; schedule_vars . backoff = openrandom_get16b ( ) % ( 1 << MAXBE ) ;
|
534,670 |
CWE-000 void free_output_file ( output_file_t * f ) { <S2SV_StartBug> if ( f ) <S2SV_EndBug> free ( f ) ; <S2SV_StartBug> return ; <S2SV_EndBug> }
|
<S2SV_ModStart> f ) { output_file_t * next ; while ( f ) { next = f -> next ; <S2SV_ModStart> if ( f -> filename ) free ( f -> filename ) ; <S2SV_ModEnd> free ( f <S2SV_ModStart> f ) ; f = next ; }
|
534,671 |
CWE-000 int main ( int argc , char * argv [ ] ) { DIR * dp ; struct dirent * dirp , * direntlist , * cdirent ; char * dirname ; int dirnsize , dirnite ; dirnsize = 10 ; direntlist = calloc ( dirnsize , sizeof ( struct dirent ) ) ; cdirent = direntlist ; dirnite = 0 ; <S2SV_StartBug> if ( argc == 1 ) { <S2SV_EndBug> <S2SV_StartBug> if ( ( dirname = getwd ( dirname ) ) == NULL ) { <S2SV_EndBug> fprintf ( stderr , "can\'t<S2SV_blank>get<S2SV_blank>the<S2SV_blank>CWD<S2SV_blank>%s\\n" , strerror ( errno ) ) ; exit ( EXIT_FAILURE ) ; } if ( ( dp = opendir ( dirname ) ) == NULL ) { fprintf ( stderr , "can\'t<S2SV_blank>open<S2SV_blank>the<S2SV_blank>%s:<S2SV_blank>%s\\n" , dirname , strerror ( errno ) ) ; exit ( EXIT_FAILURE ) ; } while ( ( dirp = readdir ( dp ) ) != NULL ) { if ( dirnsize == dirnite ) { dirnsize *= 2 ; direntlist = realloc ( ( void * ) direntlist , dirnsize * sizeof ( struct dirent ) ) ; cdirent = direntlist + dirnite ; } memcpy ( cdirent , dirp , sizeof ( struct dirent ) ) ; dirnite ++ ; cdirent ++ ; } } closedir ( dp ) ; printf ( "the<S2SV_blank>count<S2SV_blank>of<S2SV_blank>the<S2SV_blank>stat<S2SV_blank>is<S2SV_blank>%d\\n" , dirnite ) ; int i ; cdirent = direntlist ; for ( i = 0 ; i < dirnite ; cdirent ++ , i ++ ) { printf ( "%d:\\t%u\\t\\t%s" , i , cdirent -> d_ino , cdirent -> d_name ) ; printf ( "\\t%u,<S2SV_blank>%u,<S2SV_blank>%u\\n" , strlen ( cdirent -> d_name ) , sizeof ( * cdirent ) , sizeof ( cdirent -> d_ino ) ) ; } return 0 ; }
|
<S2SV_ModStart> = 0 ; dirname = NULL ; <S2SV_ModStart> ( dirname = getcwd ( dirname , 0 <S2SV_ModEnd> ) ) ==
|
534,672 |
CWE-000 int ast_hashtab_insert_immediate_bucket ( struct ast_hashtab * tab , const void * obj , unsigned int h ) # endif { int c ; struct ast_hashtab_bucket * b ; if ( ! tab || ! obj ) return 0 ; for ( c = 0 , b = tab -> array [ h ] ; b ; b = b -> next ) c ++ ; if ( c + 1 > tab -> largest_bucket_size ) tab -> largest_bucket_size = c + 1 ; if ( ! ( b = <S2SV_StartBug> # if ( defined ( MALLOC_DEBUG ) && ! defined ( STANDALONE ) ) <S2SV_EndBug> __ast_calloc ( 1 , sizeof ( * b ) , file , lineno , func ) # else ast_calloc ( 1 , sizeof ( * b ) ) # endif ) ) return 0 ; b -> object = obj ; b -> next = tab -> array [ h ] ; tab -> array [ h ] = b ; if ( b -> next ) b -> next -> prev = b ; tlist_add_head ( & ( tab -> tlist ) , b ) ; tab -> hash_tab_elements ++ ; if ( ( * tab -> resize ) ( tab ) ) ast_hashtab_resize ( tab ) ; return 1 ; }
|
<S2SV_ModStart> b = # ifdef __AST_DEBUG_MALLOC <S2SV_ModEnd> __ast_calloc ( 1
|
534,673 |
CWE-000 int aml8726_clkmsr_bus_frequency ( ) { struct resource mem ; struct aml8726_clkmsr_softc sc ; phandle_t node ; u_long pbase , psize ; u_long start , size ; int freq ; KASSERT ( aml8726_soc_hw_rev != AML_SOC_HW_REV_UNKNOWN , ( "aml8726_soc_hw_rev<S2SV_blank>isn\'t<S2SV_blank>initialized" ) ) ; <S2SV_StartBug> if ( ( node = OF_finddevice ( "clkmsr" ) ) != 0 ) <S2SV_EndBug> if ( fdt_is_compatible_strict ( node , "amlogic,aml8726-clkmsr" ) ) goto moveon ; <S2SV_StartBug> if ( ( node = OF_finddevice ( "/soc" ) ) == 0 ) <S2SV_EndBug> return ( 0 ) ; if ( ( node = fdt_find_compatible ( node , "amlogic,aml8726-clkmsr" , 1 ) ) == 0 ) return ( 0 ) ; moveon : if ( fdt_get_range ( OF_parent ( node ) , 0 , & pbase , & psize ) != 0 || fdt_regsize ( node , & start , & size ) != 0 ) return ( 0 ) ; start += pbase ; memset ( & mem , 0 , sizeof ( mem ) ) ; mem . r_bustag = fdtbus_bs_tag ; if ( bus_space_map ( mem . r_bustag , start , size , 0 , & mem . r_bushandle ) != 0 ) return ( 0 ) ; memset ( & sc , 0 , sizeof ( sc ) ) ; sc . res [ 0 ] = & mem ; freq = aml8726_clkmsr_clock_frequency ( & sc , AML_CLKMSR_CLK81 ) * 1000000 ; bus_space_unmap ( mem . r_bustag , mem . r_bushandle , size ) ; return ( freq ) ; }
|
<S2SV_ModStart> ) ) != - 1 <S2SV_ModEnd> ) if ( <S2SV_ModStart> ) ) == - 1 <S2SV_ModEnd> ) return (
|
534,674 |
CWE-000 int __ext_dns_message_write_resource_record ( extDnsCtx * ctx , extDnsResourceRecord * rr , char * buffer , int buffer_size , int position ) { int limit ; int result ; if ( rr -> name == NULL ) { ext_dns_log ( EXT_DNS_LEVEL_CRITICAL , "Recevied<S2SV_blank>request<S2SV_blank>to<S2SV_blank>dump<S2SV_blank>resource<S2SV_blank>record<S2SV_blank>with<S2SV_blank>a<S2SV_blank>NULL<S2SV_blank>reference<S2SV_blank>label.." ) ; return position ; } limit = position + __ext_dns_message_get_resource_size ( rr ) ; if ( limit > buffer_size ) { <S2SV_StartBug> ext_dns_log ( EXT_DNS_LEVEL_WARNING , "found<S2SV_blank>more<S2SV_blank>content<S2SV_blank>%d<S2SV_blank>(bytes)<S2SV_blank>to<S2SV_blank>be<S2SV_blank>placed<S2SV_blank>into<S2SV_blank>the<S2SV_blank>buffer<S2SV_blank>than<S2SV_blank>is<S2SV_blank>accepted<S2SV_blank>%d<S2SV_blank>(bytes)<S2SV_blank>while<S2SV_blank>writting<S2SV_blank>record" , <S2SV_EndBug> <S2SV_StartBug> limit , buffer_size ) ; <S2SV_EndBug> return - 1 ; } ext_dns_log ( EXT_DNS_LEVEL_DEBUG , "PLACING<S2SV_blank>Resource<S2SV_blank>record:<S2SV_blank><S2SV_blank>Encoding<S2SV_blank>resource<S2SV_blank>name:<S2SV_blank>%s" , rr -> name ) ; result = ext_dns_encode_domain_name ( ctx , rr -> name , buffer + position , buffer_size - position ) ; if ( result == - 1 ) return - 1 ; position += result ; ext_dns_log ( EXT_DNS_LEVEL_DEBUG , "<S2SV_blank><S2SV_blank><S2SV_blank>name<S2SV_blank>position<S2SV_blank>after<S2SV_blank>placing<S2SV_blank>name:<S2SV_blank>%d" , position ) ; ext_dns_set_16bit ( rr -> type , buffer + position ) ; position += 2 ; ext_dns_set_16bit ( rr -> class , buffer + position ) ; position += 2 ; ext_dns_set_32bit ( rr -> ttl , buffer + position ) ; position += 4 ; if ( rr -> type == extDnsTypeA ) { ext_dns_set_16bit ( rr -> rdlength , buffer + position ) ; position += 2 ; memcpy ( buffer + position , rr -> rdata , rr -> rdlength ) ; position += rr -> rdlength ; } else if ( rr -> type == extDnsTypeMX ) { ext_dns_set_16bit ( ext_dns_strlen ( rr -> name_content ) + 4 , buffer + position ) ; position += 2 ; ext_dns_set_16bit ( rr -> preference , buffer + position ) ; position += 2 ; result = ext_dns_encode_domain_name ( ctx , rr -> name_content , buffer + position , buffer_size - position ) ; if ( result == - 1 ) return - 1 ; position += result ; ext_dns_log ( EXT_DNS_LEVEL_DEBUG , "<S2SV_blank><S2SV_blank><S2SV_blank>written<S2SV_blank>rdlength:<S2SV_blank>%d" , ext_dns_strlen ( rr -> name_content ) + 4 ) ; } else if ( rr -> type == extDnsTypeCNAME || rr -> type == extDnsTypePTR || rr -> type == extDnsTypeNS ) { ext_dns_set_16bit ( ext_dns_strlen ( rr -> name_content ) + 2 , buffer + position ) ; position += 2 ; ext_dns_log ( EXT_DNS_LEVEL_DEBUG , "<S2SV_blank><S2SV_blank>enconding<S2SV_blank>type<S2SV_blank>%s:<S2SV_blank>%s" , ext_dns_message_get_qtype_to_str ( ctx , rr -> type ) , rr -> name_content ) ; result = ext_dns_encode_domain_name ( ctx , rr -> name_content , buffer + position , buffer_size - position ) ; if ( result == - 1 ) return - 1 ; position += result ; } else if ( rr -> type == extDnsTypeTXT || rr -> type == extDnsTypeSPF ) { ext_dns_set_16bit ( rr -> rdlength , buffer + position ) ; position += 2 ; memcpy ( buffer + position , rr -> rdata , rr -> rdlength ) ; position += rr -> rdlength ; } else if ( rr -> type == extDnsTypeSOA ) { ext_dns_set_16bit ( ext_dns_strlen ( rr -> mname ) + ext_dns_strlen ( rr -> contact_address ) + 24 , buffer + position ) ; position += 2 ; result = ext_dns_encode_domain_name ( ctx , rr -> mname , buffer + position , buffer_size - position ) ; if ( result == - 1 ) return - 1 ; position += result ; result = ext_dns_encode_domain_name ( ctx , rr -> contact_address , buffer + position , buffer_size - position ) ; if ( result == - 1 ) return - 1 ; position += result ; ext_dns_set_32bit ( rr -> serial , buffer + position ) ; position += 4 ; ext_dns_set_32bit ( rr -> refresh , buffer + position ) ; position += 4 ; ext_dns_set_32bit ( rr -> retry , buffer + position ) ; position += 4 ; ext_dns_set_32bit ( rr -> expire , buffer + position ) ; position += 4 ; ext_dns_set_32bit ( rr -> minimum , buffer + position ) ; position += 4 ; } else { ext_dns_set_16bit ( rr -> rdlength , buffer + position ) ; position += 2 ; memcpy ( buffer + position , rr -> rdata , rr -> rdlength ) ; position += rr -> rdlength ; } ext_dns_log ( EXT_DNS_LEVEL_DEBUG , "<S2SV_blank><S2SV_blank><S2SV_blank>after<S2SV_blank>writting<S2SV_blank>rdata<S2SV_blank>section:<S2SV_blank>%d" , position ) ; return position ; }
|
<S2SV_ModStart> { ext_dns_log ( EXT_DNS_LEVEL_CRITICAL , "found<S2SV_blank>more<S2SV_blank>content<S2SV_blank>%d<S2SV_blank>(bytes)<S2SV_blank>to<S2SV_blank>be<S2SV_blank>placed<S2SV_blank>into<S2SV_blank>the<S2SV_blank>buffer<S2SV_blank>than<S2SV_blank>is<S2SV_blank>accepted<S2SV_blank>%d<S2SV_blank>(bytes)<S2SV_blank>while<S2SV_blank>writting<S2SV_blank>record<S2SV_blank>as<S2SV_blank>response<S2SV_blank>for<S2SV_blank>%s" <S2SV_ModEnd> , limit , <S2SV_ModStart> limit , buffer_size , rr -> name
|
534,675 |
CWE-000 static bool usart_tx_in_progress ( void ) { <S2SV_StartBug> return ! ( USART2 -> SR & ( 1 << 7 ) ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> ) { return <S2SV_ModEnd> ( USART2 -> <S2SV_ModStart> -> SR & USART_SR_TXE ) == 0 <S2SV_ModEnd> ; } <S2SV_null>
|
534,676 |
CWE-000 <S2SV_StartBug> static void filter_itanium_setbits ( unsigned char * data , unsigned int bit_field , int bit_pos , int bit_count ) <S2SV_EndBug> { <S2SV_StartBug> int i , in_addr = bit_pos / 8 ; <S2SV_EndBug> <S2SV_StartBug> int in_bit = bit_pos & 7 ; <S2SV_EndBug> unsigned int and_mask = 0xffffffff >> ( 32 - bit_count ) ; and_mask = ~ ( and_mask << in_bit ) ; bit_field <<= in_bit ; for ( i = 0 ; i < 4 ; i ++ ) { data [ in_addr + i ] &= and_mask ; data [ in_addr + i ] |= bit_field ; and_mask = ( and_mask >> 8 ) | 0xff000000 ; bit_field >>= 8 ; } }
|
<S2SV_ModStart> int bit_field , unsigned <S2SV_ModStart> int bit_pos , unsigned <S2SV_ModStart> bit_count ) { unsigned <S2SV_ModStart> / 8 ; unsigned
|
534,677 |
CWE-000 int nsub ( string_buffer_t * const string_buffer , regex_t const regexp , string_buffer_t * const replacement_buffer , int const num ) { char * const string = malloc ( ( string_buffer -> eos + 1 ) * sizeof ( char ) ) ; <S2SV_StartBug> string_buffer_t * original_replacement = sbuffer_clone ( replacement_buffer ) ; <S2SV_EndBug> size_t i = 0 , j = 0 , matched = 0 , n = 0 ; size_t const str_len = string_buffer -> eos ; strcpy ( string , string_buffer -> char_at ) ; for ( ; ; ) { regmatch_t matches [ 10 ] ; int result = regexec ( & regexp , string_buffer -> char_at + i , 10 , matches , 0 ) ; if ( result ) { <S2SV_StartBug> free ( string ) ; <S2SV_EndBug> return matched ; } else matched = 1 ; if ( ++ n == num ) { insert_subexpr_matches ( matches , string_buffer -> char_at + i , <S2SV_StartBug> replacement_buffer <S2SV_EndBug> ) ; sbuffer_set_end_of_string ( string_buffer , i + matches [ 0 ] . rm_so ) ; sbuffer_append_buf ( <S2SV_StartBug> string_buffer , replacement_buffer <S2SV_EndBug> ) ; sbuffer_append ( string_buffer , string + j + matches [ 0 ] . rm_eo , str_len - j - matches [ 0 ] . rm_eo ) ; <S2SV_StartBug> i += matches [ 0 ] . rm_so + replacement_buffer -> eos ; <S2SV_EndBug> } i += matches [ 0 ] . rm_eo ; j += matches [ 0 ] . rm_eo ; sbuffer_reinit ( replacement_buffer , original_replacement -> char_at ) ; } }
|
<S2SV_ModStart> ; string_buffer_t * replacement <S2SV_ModEnd> = sbuffer_clone ( <S2SV_ModStart> free ( string ) ; sbuffer_delete ( replacement <S2SV_ModStart> + i , replacement <S2SV_ModEnd> ) ; sbuffer_set_end_of_string <S2SV_ModStart> ( string_buffer , replacement <S2SV_ModEnd> ) ; sbuffer_append <S2SV_ModStart> . rm_so + replacement -> eos ; } i += matches [ 0 ] . rm_eo ; j += matches [ 0 ] . rm_eo ; sbuffer_reinit ( replacement , replacement_buffer -> <S2SV_ModEnd> char_at ) ;
|
534,678 |
CWE-000 asmlinkage int sys_my_xtime ( struct timespec * current_time ) { struct timespec buff ; printk ( KERN_ALERT "my_xtime:<S2SV_blank>my_xtime<S2SV_blank>was<S2SV_blank>called!\\n" ) ; if ( copy_from_user ( & buff , current_time , sizeof ( buff ) ) ) { printk ( KERN_ALERT "my_xtime:<S2SV_blank>COPY<S2SV_blank>FROM<S2SV_blank>USER<S2SV_blank>FAILURE!\\n" ) ; return - EFAULT ; } buff = current_kernel_time ( ) ; if ( copy_to_user ( current_time , & buff , sizeof ( buff ) ) ) { printk ( KERN_ALERT "my_xtime:<S2SV_blank>COPY<S2SV_blank>TO<S2SV_blank>USER<S2SV_blank>FAILURE!\\n" ) ; return - EFAULT ; } <S2SV_StartBug> return 0 ; <S2SV_EndBug> printk ( KERN_ALERT "my_xtime:<S2SV_blank>SUCCESFUL<S2SV_blank>COPY!\\n" ) ; <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> EFAULT ; } <S2SV_ModEnd> printk ( KERN_ALERT <S2SV_ModStart> "my_xtime:<S2SV_blank>SUCCESFUL<S2SV_blank>COPY!\\n" ) ; return 0 ;
|
534,679 |
CWE-000 int ble_ll_conn_hci_update ( uint8_t * cmdbuf ) { int rc ; uint8_t ctrl_proc ; uint16_t handle ; struct ble_ll_conn_sm * connsm ; struct hci_conn_update * hcu ; handle = get_le16 ( cmdbuf ) ; connsm = ble_ll_conn_find_active_conn ( handle ) ; if ( ! connsm ) { return BLE_ERR_UNK_CONN_ID ; } if ( IS_PENDING_CTRL_PROC ( connsm , BLE_LL_CTRL_PROC_CONN_PARAM_REQ ) || IS_PENDING_CTRL_PROC ( connsm , BLE_LL_CTRL_PROC_CONN_UPDATE ) ) { return BLE_ERR_CMD_DISALLOWED ; } if ( connsm -> conn_features && ( connsm -> conn_features & BLE_LL_FEAT_CONN_PARM_REQ ) == 0 ) { if ( connsm -> conn_role == BLE_LL_CONN_ROLE_SLAVE ) { <S2SV_StartBug> return BLE_ERR_CMD_DISALLOWED ; <S2SV_EndBug> } ctrl_proc = BLE_LL_CTRL_PROC_CONN_UPDATE ; } else { ctrl_proc = BLE_LL_CTRL_PROC_CONN_PARAM_REQ ; } if ( connsm -> csmflags . cfbit . awaiting_host_reply ) { if ( connsm -> conn_role == BLE_LL_CONN_ROLE_SLAVE ) { return BLE_ERR_LMP_COLLISION ; } else { connsm -> csmflags . cfbit . awaiting_host_reply = 0 ; ble_ll_ctrl_reject_ind_send ( connsm , connsm -> host_reply_opcode , BLE_ERR_LMP_COLLISION ) ; } } if ( connsm -> csmflags . cfbit . chanmap_update_scheduled ) { if ( connsm -> conn_role == BLE_LL_CONN_ROLE_SLAVE ) { return BLE_ERR_DIFF_TRANS_COLL ; } } hcu = & connsm -> conn_param_req ; hcu -> handle = handle ; hcu -> conn_itvl_min = get_le16 ( cmdbuf + 2 ) ; hcu -> conn_itvl_max = get_le16 ( cmdbuf + 4 ) ; hcu -> conn_latency = get_le16 ( cmdbuf + 6 ) ; hcu -> supervision_timeout = get_le16 ( cmdbuf + 8 ) ; hcu -> min_ce_len = get_le16 ( cmdbuf + 10 ) ; hcu -> max_ce_len = get_le16 ( cmdbuf + 12 ) ; if ( hcu -> min_ce_len > hcu -> max_ce_len ) { return BLE_ERR_INV_HCI_CMD_PARMS ; } rc = ble_ll_conn_hci_chk_conn_params ( hcu -> conn_itvl_min , hcu -> conn_itvl_max , hcu -> conn_latency , hcu -> supervision_timeout ) ; if ( ! rc ) { ble_ll_ctrl_proc_start ( connsm , ctrl_proc ) ; } return rc ; }
|
<S2SV_ModStart> ) { return BLE_ERR_UNSUPP_REM_FEATURE <S2SV_ModEnd> ; } ctrl_proc
|
534,680 |
CWE-000 void FORTRAN ( init_c_string_array ) ( int * length , char * * mr_blk1 , char * * * fer_ptr ) { int i ; char * * ptr ; # ifdef MEMORYDEBUG char msg [ 1024 ] ; <S2SV_StartBug> sprintf ( msg , "init_c_string_array<S2SV_blank>assigned<S2SV_blank>as<S2SV_blank>an<S2SV_blank>array<S2SV_blank>of<S2SV_blank>%d<S2SV_blank>64-bit<S2SV_blank>pointers<S2SV_blank>(%d<S2SV_blank>bytes)<S2SV_blank>initialize<S2SV_blank>to<S2SV_blank>NULL" , <S2SV_EndBug> mr_blk1 , * length , ( * length ) * 8 ) ; FerMem_WriteDebugMessage ( mr_blk1 , mr_blk1 + ( * length ) , msg ) ; # endif * fer_ptr = mr_blk1 ; ptr = mr_blk1 ; for ( i = 0 ; i < ( * length ) * ( 8 / sizeof ( char * ) ) ; i ++ ) { * ptr = NULL ; ptr ++ ; } }
|
<S2SV_ModStart> ( msg , "assigned<S2SV_blank>by<S2SV_blank>init_c_string_array<S2SV_blank>as<S2SV_blank>an<S2SV_blank>array<S2SV_blank>of<S2SV_blank>%d<S2SV_blank>64-bit<S2SV_blank>pointers<S2SV_blank>(%d<S2SV_blank>bytes)<S2SV_blank>initialize<S2SV_blank>to<S2SV_blank>NULL" , <S2SV_ModEnd> * length ,
|
534,681 |
CWE-000 static int binder_update_page_range ( struct binder_proc * proc , int allocate , void * start , void * end , struct vm_area_struct * vma ) { void * page_addr ; unsigned long user_page_addr ; struct vm_struct tmp_area ; struct page * * page ; struct mm_struct * mm ; binder_debug ( BINDER_DEBUG_BUFFER_ALLOC , <S2SV_StartBug> "binder:<S2SV_blank>%d:<S2SV_blank>%s<S2SV_blank>pages<S2SV_blank>%p-%p\\n" , proc -> pid , <S2SV_EndBug> allocate ? "allocate" : "free" , start , end ) ; if ( end <= start ) return 0 ; if ( vma ) mm = NULL ; else mm = get_task_mm ( proc -> tsk ) ; if ( mm ) { down_write ( & mm -> mmap_sem ) ; vma = proc -> vma ; if ( vma && mm != proc -> vma_vm_mm ) { pr_err ( "binder:<S2SV_blank>%d:<S2SV_blank>vma<S2SV_blank>mm<S2SV_blank>and<S2SV_blank>task<S2SV_blank>mm<S2SV_blank>mismatch\\n" , proc -> pid ) ; vma = NULL ; } } if ( allocate == 0 ) goto free_range ; if ( vma == NULL ) { binder_debug ( BINDER_DEBUG_TOP_ERRORS , "binder:<S2SV_blank>%d:<S2SV_blank>binder_alloc_buf<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>" "map<S2SV_blank>pages<S2SV_blank>in<S2SV_blank>userspace,<S2SV_blank>no<S2SV_blank>vma\\n" , proc -> pid ) ; goto err_no_vma ; } for ( page_addr = start ; page_addr < end ; page_addr += PAGE_SIZE ) { int ret ; struct page * * page_array_ptr ; page = & proc -> pages [ ( page_addr - proc -> buffer ) / PAGE_SIZE ] ; BUG_ON ( * page ) ; * page = alloc_page ( GFP_KERNEL | __GFP_ZERO ) ; if ( * page == NULL ) { binder_debug ( BINDER_DEBUG_TOP_ERRORS , "binder:<S2SV_blank>%d:<S2SV_blank>binder_alloc_buf<S2SV_blank>failed<S2SV_blank>" <S2SV_StartBug> "for<S2SV_blank>page<S2SV_blank>at<S2SV_blank>%p\\n" , proc -> pid , page_addr ) ; <S2SV_EndBug> goto err_alloc_page_failed ; } tmp_area . addr = page_addr ; tmp_area . size = PAGE_SIZE + PAGE_SIZE ; page_array_ptr = page ; ret = map_vm_area ( & tmp_area , PAGE_KERNEL , & page_array_ptr ) ; if ( ret ) { binder_debug ( BINDER_DEBUG_TOP_ERRORS , "binder:<S2SV_blank>%d:<S2SV_blank>binder_alloc_buf<S2SV_blank>failed<S2SV_blank>" <S2SV_StartBug> "to<S2SV_blank>map<S2SV_blank>page<S2SV_blank>at<S2SV_blank>%p<S2SV_blank>in<S2SV_blank>kernel\\n" , <S2SV_EndBug> proc -> pid , page_addr ) ; goto err_map_kernel_failed ; } user_page_addr = ( uintptr_t ) page_addr + proc -> user_buffer_offset ; ret = vm_insert_page ( vma , user_page_addr , page [ 0 ] ) ; if ( ret ) { binder_debug ( BINDER_DEBUG_TOP_ERRORS , "binder:<S2SV_blank>%d:<S2SV_blank>binder_alloc_buf<S2SV_blank>failed<S2SV_blank>" "to<S2SV_blank>map<S2SV_blank>page<S2SV_blank>at<S2SV_blank>%lx<S2SV_blank>in<S2SV_blank>userspace\\n" , proc -> pid , user_page_addr ) ; goto err_vm_insert_page_failed ; } } if ( mm ) { up_write ( & mm -> mmap_sem ) ; mmput ( mm ) ; } return 0 ; free_range : for ( page_addr = end - PAGE_SIZE ; page_addr >= start ; page_addr -= PAGE_SIZE ) { page = & proc -> pages [ ( page_addr - proc -> buffer ) / PAGE_SIZE ] ; if ( vma ) zap_page_range ( vma , ( uintptr_t ) page_addr + proc -> user_buffer_offset , PAGE_SIZE , NULL ) ; err_vm_insert_page_failed : unmap_kernel_range ( ( unsigned long ) page_addr , PAGE_SIZE ) ; err_map_kernel_failed : __free_page ( * page ) ; * page = NULL ; err_alloc_page_failed : ; } err_no_vma : if ( mm ) { up_write ( & mm -> mmap_sem ) ; mmput ( mm ) ; } return - ENOMEM ; }
|
<S2SV_ModStart> ( BINDER_DEBUG_BUFFER_ALLOC , "binder:<S2SV_blank>%d:<S2SV_blank>%s<S2SV_blank>pages<S2SV_blank>%pK-%pK\\n" <S2SV_ModEnd> , proc -> <S2SV_ModStart> BINDER_DEBUG_TOP_ERRORS , "binder:<S2SV_blank>%d:<S2SV_blank>binder_alloc_buf<S2SV_blank>failed<S2SV_blank>" "for<S2SV_blank>page<S2SV_blank>at<S2SV_blank>%pK\\n" <S2SV_ModEnd> , proc -> <S2SV_ModStart> BINDER_DEBUG_TOP_ERRORS , "binder:<S2SV_blank>%d:<S2SV_blank>binder_alloc_buf<S2SV_blank>failed<S2SV_blank>" "to<S2SV_blank>map<S2SV_blank>page<S2SV_blank>at<S2SV_blank>%pK<S2SV_blank>in<S2SV_blank>kernel\\n" <S2SV_ModEnd> , proc ->
|
534,682 |
CWE-000 char * rsa_sha256_sign_file ( RSA * privKey , const char * file ) { unsigned char * output = NULL ; FILE * fd = NULL ; EVP_MD_CTX * ctx = NULL ; EVP_PKEY_CTX * pkey_ctx = NULL ; unsigned char * buffer = NULL ; fd = fopen ( file , "r" ) ; if ( fd == NULL ) { error ( "Failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>file<S2SV_blank>%s." , file ) ; goto done ; } EVP_PKEY * pkey = EVP_PKEY_new ( ) ; if ( EVP_PKEY_assign_RSA ( pkey , privKey ) != 1 ) { error ( "Failed<S2SV_blank>to<S2SV_blank>assign<S2SV_blank>signing<S2SV_blank>key." ) ; goto done ; } pkey_ctx = EVP_PKEY_CTX_new ( pkey , NULL ) ; EVP_PKEY_CTX_set_rsa_padding ( pkey_ctx , RSA_PKCS1_PSS_PADDING ) ; ctx = EVP_MD_CTX_create ( ) ; if ( ctx == NULL ) { error ( "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>context" ) ; goto done ; } const EVP_MD * md = EVP_get_digestbyname ( "SHA256" ) ; if ( md == NULL ) { error ( "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>digest" ) ; goto done ; } if ( EVP_DigestSignInit ( ctx , & pkey_ctx , md , NULL , pkey ) != 1 ) { error ( "Failed<S2SV_blank>to<S2SV_blank>init<S2SV_blank>signing<S2SV_blank>digest" ) ; goto done ; } const int bufSize = 4096 ; buffer = malloc ( bufSize ) ; if ( buffer == NULL ) { error ( "Failed<S2SV_blank>to<S2SV_blank>malloc<S2SV_blank>buffer<S2SV_blank>to<S2SV_blank>read<S2SV_blank>file." ) ; goto done ; } size_t bRead = 0 ; while ( ( bRead = fread ( buffer , 1 , bufSize , fd ) ) > 0 ) { printf ( "read<S2SV_blank>%zu<S2SV_blank>bytes\\n" , bRead ) ; if ( EVP_DigestSignUpdate ( ctx , buffer , bRead ) != 1 ) { error ( "Failed<S2SV_blank>to<S2SV_blank>update<S2SV_blank>digest." ) ; goto done ; } } size_t req = 0 ; if ( EVP_DigestSignFinal ( ctx , NULL , & req ) != 1 ) { error ( "Failed<S2SV_blank>to<S2SV_blank>sign<S2SV_blank>digest<S2SV_blank>(1)." ) ; goto done ; } if ( ! ( req > 0 ) ) { error ( "Failed<S2SV_blank>to<S2SV_blank>sign<S2SV_blank>digest<S2SV_blank>(2)." ) ; goto done ; } output = OPENSSL_malloc ( req + 1 ) ; if ( output == NULL ) { error ( "Failed<S2SV_blank>to<S2SV_blank>malloc<S2SV_blank>output." ) ; goto done ; } size_t output_len = req ; if ( EVP_DigestSignFinal ( ctx , output , & output_len ) != 1 ) { error ( "Failed<S2SV_blank>to<S2SV_blank>sign<S2SV_blank>digest<S2SV_blank>(3)." ) ; goto done ; } <S2SV_StartBug> printf ( "signature<S2SV_blank>length<S2SV_blank>%d" , output_len ) ; <S2SV_EndBug> output [ output_len ] = 0 ; done : { EVP_MD_CTX_destroy ( ctx ) ; fclose ( fd ) ; free ( buffer ) ; } char * b64 = to_base64 ( ( char * ) output ) ; free ( output ) ; return b64 ; }
|
<S2SV_ModStart> } printf ( "signature<S2SV_blank>length<S2SV_blank>%zu" <S2SV_ModEnd> , output_len )
|
534,683 |
CWE-000 void LS_size ( ) { int i ; linkls * current ; current = & Linkls ; i = 0 ; while ( current -> next != NULL ) { current = current -> next ; i ++ ; } <S2SV_StartBug> printf ( "LS_size<S2SV_blank>%d\\n" , i ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> } printf ( "LS_size<S2SV_blank>0<S2SV_blank>%d\\n" <S2SV_ModEnd> , i )
|
534,684 |
CWE-000 off_t ngx_chain_coalesce_file ( ngx_chain_t * * in , off_t limit ) { off_t total , size , aligned , fprev ; ngx_fd_t fd ; ngx_chain_t * cl ; total = 0 ; cl = * in ; fd = cl -> buf -> file -> fd ; do { size = cl -> buf -> file_last - cl -> buf -> file_pos ; if ( size > limit - total ) { size = limit - total ; aligned = ( cl -> buf -> file_pos + size + ngx_pagesize - 1 ) & ~ ( ( off_t ) ngx_pagesize - 1 ) ; if ( aligned <= cl -> buf -> file_last ) { size = aligned - cl -> buf -> file_pos ; } <S2SV_StartBug> } <S2SV_EndBug> total += size ; fprev = cl -> buf -> file_pos + size ; cl = cl -> next ; } while ( cl && cl -> buf -> in_file && total < limit && fd == cl -> buf -> file -> fd && fprev == cl -> buf -> file_pos ) ; * in = cl ; return total ; }
|
<S2SV_ModStart> file_pos ; } total += size ; break ;
|
534,685 |
CWE-000 int m_push ( stack_t * * head , int num , int * state ) { int status ; <S2SV_StartBug> if ( state == 1 ) <S2SV_EndBug> { status = add_node_end ( head , num ) ; if ( status == - 1 ) return ( - 1 ) ; return ( 0 ) ; } status = add_node_begin ( head , num ) ; if ( status == - 1 ) return ( - 1 ) ; return ( 0 ) ; }
|
<S2SV_ModStart> int status ; printf ( "value<S2SV_blank>of<S2SV_blank>state:<S2SV_blank>%d\\n" , * state ) ; if ( * <S2SV_ModEnd> state == 1
|
534,686 |
CWE-000 void aeDeleteFileEvent ( aeEventLoop * eventLoop , int fd , int mask ) { if ( fd >= eventLoop -> setsize ) return ; aeFileEvent * fe = & eventLoop -> events [ fd ] ; if ( fe -> mask == AE_NONE ) return ; aeApiDelEvent ( eventLoop , fd , mask ) ; fe -> mask = fe -> mask & ( ~ mask ) ; if ( fd == eventLoop -> maxfd && fe -> mask == AE_NONE ) { int j ; for ( j = eventLoop -> maxfd - 1 ; j >= 0 ; j -- ) if ( eventLoop -> events [ j ] . mask != AE_NONE ) break ; eventLoop -> maxfd = j ; } <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> j ; } close ( fd ) ;
|
534,687 |
CWE-000 static void xenbus_va_dev_error ( struct xenbus_device * dev , int err , const char * fmt , va_list ap ) { unsigned int len ; char * printf_buffer ; char * path_buffer ; # define PRINTF_BUFFER_SIZE 4096 printf_buffer = kmalloc ( PRINTF_BUFFER_SIZE , GFP_KERNEL ) ; if ( ! printf_buffer ) return ; len = sprintf ( printf_buffer , "%i<S2SV_blank>" , - err ) ; vsnprintf ( printf_buffer + len , PRINTF_BUFFER_SIZE - len , fmt , ap ) ; dev_err ( & dev -> dev , "%s\\n" , printf_buffer ) ; path_buffer = kasprintf ( GFP_KERNEL , "error/%s" , dev -> nodename ) ; <S2SV_StartBug> if ( ! path_buffer || <S2SV_EndBug> <S2SV_StartBug> xenbus_write ( XBT_NIL , path_buffer , "error" , printf_buffer ) ) <S2SV_EndBug> dev_err ( & dev -> dev , "failed<S2SV_blank>to<S2SV_blank>write<S2SV_blank>error<S2SV_blank>node<S2SV_blank>for<S2SV_blank>%s<S2SV_blank>(%s)\\n" , dev -> nodename , printf_buffer ) ; kfree ( printf_buffer ) ; kfree ( path_buffer ) ; }
|
<S2SV_ModStart> ; if ( path_buffer ) <S2SV_ModEnd> xenbus_write ( XBT_NIL <S2SV_ModStart> path_buffer , "error" <S2SV_ModEnd> , printf_buffer )
|
534,688 |
CWE-000 static bool intel_fbdev_init_bios ( struct drm_device * dev , struct intel_fbdev * ifbdev ) { struct intel_framebuffer * fb = NULL ; struct drm_crtc * crtc ; struct intel_crtc * intel_crtc ; unsigned int max_size = 0 ; for_each_crtc ( dev , crtc ) { struct drm_i915_gem_object * obj = intel_fb_obj ( crtc -> primary -> state -> fb ) ; intel_crtc = to_intel_crtc ( crtc ) ; if ( ! crtc -> state -> active || ! obj ) { DRM_DEBUG_KMS ( "pipe<S2SV_blank>%c<S2SV_blank>not<S2SV_blank>active<S2SV_blank>or<S2SV_blank>no<S2SV_blank>fb,<S2SV_blank>skipping\\n" , pipe_name ( intel_crtc -> pipe ) ) ; continue ; } if ( obj -> base . size > max_size ) { DRM_DEBUG_KMS ( "found<S2SV_blank>possible<S2SV_blank>fb<S2SV_blank>from<S2SV_blank>plane<S2SV_blank>%c\\n" , pipe_name ( intel_crtc -> pipe ) ) ; fb = to_intel_framebuffer ( crtc -> primary -> state -> fb ) ; max_size = obj -> base . size ; } } if ( ! fb ) { DRM_DEBUG_KMS ( "no<S2SV_blank>active<S2SV_blank>fbs<S2SV_blank>found,<S2SV_blank>not<S2SV_blank>using<S2SV_blank>BIOS<S2SV_blank>config\\n" ) ; goto out ; } for_each_crtc ( dev , crtc ) { unsigned int cur_size ; intel_crtc = to_intel_crtc ( crtc ) ; if ( ! crtc -> state -> active ) { DRM_DEBUG_KMS ( "pipe<S2SV_blank>%c<S2SV_blank>not<S2SV_blank>active,<S2SV_blank>skipping\\n" , pipe_name ( intel_crtc -> pipe ) ) ; continue ; } DRM_DEBUG_KMS ( "checking<S2SV_blank>plane<S2SV_blank>%c<S2SV_blank>for<S2SV_blank>BIOS<S2SV_blank>fb\\n" , pipe_name ( intel_crtc -> pipe ) ) ; cur_size = intel_crtc -> config -> base . adjusted_mode . crtc_hdisplay ; cur_size = cur_size * fb -> base . format -> cpp [ 0 ] ; if ( fb -> base . pitches [ 0 ] < cur_size ) { DRM_DEBUG_KMS ( "fb<S2SV_blank>not<S2SV_blank>wide<S2SV_blank>enough<S2SV_blank>for<S2SV_blank>plane<S2SV_blank>%c<S2SV_blank>(%d<S2SV_blank>vs<S2SV_blank>%d)\\n" , pipe_name ( intel_crtc -> pipe ) , cur_size , fb -> base . pitches [ 0 ] ) ; fb = NULL ; break ; } cur_size = intel_crtc -> config -> base . adjusted_mode . crtc_vdisplay ; cur_size = intel_fb_align_height ( dev , cur_size , <S2SV_StartBug> fb -> base . pixel_format , <S2SV_EndBug> fb -> base . modifier ) ; cur_size *= fb -> base . pitches [ 0 ] ; DRM_DEBUG_KMS ( "pipe<S2SV_blank>%c<S2SV_blank>area:<S2SV_blank>%dx%d,<S2SV_blank>bpp:<S2SV_blank>%d,<S2SV_blank>size:<S2SV_blank>%d\\n" , pipe_name ( intel_crtc -> pipe ) , intel_crtc -> config -> base . adjusted_mode . crtc_hdisplay , intel_crtc -> config -> base . adjusted_mode . crtc_vdisplay , fb -> base . format -> cpp [ 0 ] * 8 , cur_size ) ; if ( cur_size > max_size ) { DRM_DEBUG_KMS ( "fb<S2SV_blank>not<S2SV_blank>big<S2SV_blank>enough<S2SV_blank>for<S2SV_blank>plane<S2SV_blank>%c<S2SV_blank>(%d<S2SV_blank>vs<S2SV_blank>%d)\\n" , pipe_name ( intel_crtc -> pipe ) , cur_size , max_size ) ; fb = NULL ; break ; } DRM_DEBUG_KMS ( "fb<S2SV_blank>big<S2SV_blank>enough<S2SV_blank>for<S2SV_blank>plane<S2SV_blank>%c<S2SV_blank>(%d<S2SV_blank>>=<S2SV_blank>%d)\\n" , pipe_name ( intel_crtc -> pipe ) , max_size , cur_size ) ; } if ( ! fb ) { DRM_DEBUG_KMS ( "BIOS<S2SV_blank>fb<S2SV_blank>not<S2SV_blank>suitable<S2SV_blank>for<S2SV_blank>all<S2SV_blank>pipes,<S2SV_blank>not<S2SV_blank>using\\n" ) ; goto out ; } ifbdev -> preferred_bpp = fb -> base . format -> cpp [ 0 ] * 8 ; ifbdev -> fb = fb ; drm_framebuffer_reference ( & ifbdev -> fb -> base ) ; for_each_crtc ( dev , crtc ) { intel_crtc = to_intel_crtc ( crtc ) ; if ( ! crtc -> state -> active ) continue ; WARN ( ! crtc -> primary -> fb , "re-used<S2SV_blank>BIOS<S2SV_blank>config<S2SV_blank>but<S2SV_blank>lost<S2SV_blank>an<S2SV_blank>fb<S2SV_blank>on<S2SV_blank>crtc<S2SV_blank>%d\\n" , crtc -> base . id ) ; } DRM_DEBUG_KMS ( "using<S2SV_blank>BIOS<S2SV_blank>fb<S2SV_blank>for<S2SV_blank>initial<S2SV_blank>console\\n" ) ; return true ; out : return false ; }
|
<S2SV_ModStart> -> base . format -> format <S2SV_ModEnd> , fb ->
|
534,689 |
CWE-000 static int __gnix_vc_hndl_conn_req ( struct gnix_cm_nic * cm_nic , char * msg_buffer , struct gnix_address src_cm_nic_addr ) { int ret = FI_SUCCESS ; gni_return_t __attribute__ ( ( unused ) ) status ; struct gnix_fid_ep * ep = NULL ; gnix_ht_key_t key ; struct gnix_av_addr_entry entry ; struct gnix_address src_addr , target_addr ; struct gnix_vc * vc = NULL ; struct gnix_work_req * work_req ; int src_vc_id ; gni_smsg_attr_t src_smsg_attr ; uint64_t src_vc_ptr ; uint64_t peer_caps ; struct wq_hndl_conn_req * data = NULL ; gni_mem_handle_t tmp_mem_hndl ; int src_mapped = 0 ; fi_addr_t fi_addr ; xpmem_segid_t peer_segid ; xpmem_apid_t peer_apid ; uint8_t name_type , rx_ctx_cnt ; bool accessible ; ssize_t __attribute__ ( ( unused ) ) len ; struct gnix_ep_name * error_data ; GNIX_TRACE ( FI_LOG_EP_CTRL , "\\n" ) ; __gnix_vc_unpack_conn_req ( msg_buffer , & target_addr , & src_addr , & src_vc_id , & src_vc_ptr , & src_smsg_attr , & tmp_mem_hndl , & peer_caps , & peer_segid , & name_type , & rx_ctx_cnt ) ; GNIX_DEBUG ( FI_LOG_EP_CTRL , "conn<S2SV_blank>req<S2SV_blank>rx:<S2SV_blank>(From<S2SV_blank>Aries<S2SV_blank>addr<S2SV_blank>0x%x<S2SV_blank>Id<S2SV_blank>%d<S2SV_blank>to<S2SV_blank>Aries<S2SV_blank>0x%x<S2SV_blank>Id<S2SV_blank>%d<S2SV_blank>src<S2SV_blank>vc<S2SV_blank>0x%lx<S2SV_blank>)\\n" , src_addr . device_addr , src_addr . cdm_id , target_addr . device_addr , target_addr . cdm_id , src_vc_ptr ) ; __gnix_vc_set_ht_key ( & target_addr , & key ) ; ep = ( struct gnix_fid_ep * ) _gnix_ht_lookup ( cm_nic -> addr_to_ep_ht , key ) ; if ( ep == NULL ) { GNIX_WARN ( FI_LOG_EP_DATA , "_gnix_ht_lookup<S2SV_blank>addr_to_ep<S2SV_blank>failed\\n" ) ; return - FI_ENOENT ; } COND_ACQUIRE ( ep -> requires_lock , & ep -> vc_lock ) ; if ( ep -> av ) { ret = _gnix_av_reverse_lookup ( ep -> av , src_addr , & fi_addr ) ; if ( ret == FI_SUCCESS ) { src_mapped = 1 ; vc = _gnix_ep_vc_lookup ( ep , fi_addr ) ; } } if ( ( vc == NULL ) || ( vc -> conn_state == GNIX_VC_CONN_NONE ) ) { if ( vc == NULL ) { entry . gnix_addr = src_addr ; entry . cm_nic_cdm_id = src_cm_nic_addr . cdm_id ; ret = _gnix_vc_alloc ( ep , & entry , & vc ) ; if ( ret != FI_SUCCESS ) { GNIX_WARN ( FI_LOG_EP_CTRL , "_gnix_vc_alloc<S2SV_blank>returned<S2SV_blank>%s\\n" , fi_strerror ( - ret ) ) ; goto err ; } vc -> conn_state = GNIX_VC_CONNECTING ; if ( src_mapped ) { ret = _gnix_ep_vc_store ( ep , vc , fi_addr ) ; if ( unlikely ( ret != FI_SUCCESS ) ) { _gnix_vc_destroy ( vc ) ; GNIX_WARN ( FI_LOG_EP_DATA , "_gnix_ep_vc_store<S2SV_blank>returned<S2SV_blank>%s\\n" , fi_strerror ( - ret ) ) ; goto err ; } } else { GNIX_INFO ( FI_LOG_EP_CTRL , "Received<S2SV_blank>conn.<S2SV_blank>request<S2SV_blank>from<S2SV_blank>unmapped<S2SV_blank>peer<S2SV_blank>EP,<S2SV_blank>vc:<S2SV_blank>%p<S2SV_blank>addr:<S2SV_blank>0x%lx\\n" , vc , src_addr ) ; dlist_insert_tail ( & vc -> list , & ep -> unmapped_vcs ) ; if ( vc -> ep -> caps & FI_SOURCE ) { error_data = calloc ( 1 , sizeof ( * error_data ) ) ; if ( error_data == NULL ) { ret = - FI_ENOMEM ; goto err ; } vc -> gnix_ep_name = ( void * ) error_data ; error_data -> gnix_addr = src_addr ; error_data -> name_type = name_type ; error_data -> cm_nic_cdm_id = cm_nic -> my_name . cm_nic_cdm_id ; error_data -> cookie = cm_nic -> my_name . cookie ; error_data -> rx_ctx_cnt = rx_ctx_cnt ; } } } else { vc -> conn_state = GNIX_VC_CONNECTING ; } <S2SV_StartBug> work_req = calloc ( 1 , sizeof ( * work_req ) ) ; <S2SV_EndBug> if ( work_req == NULL ) { ret = - FI_ENOMEM ; goto err ; } data = calloc ( 1 , sizeof ( struct wq_hndl_conn_req ) ) ; if ( data == NULL ) { ret = - FI_ENOMEM ; goto err ; } memcpy ( & data -> src_smsg_attr , & src_smsg_attr , sizeof ( src_smsg_attr ) ) ; data -> vc = vc ; data -> src_vc_id = src_vc_id ; data -> src_vc_ptr = src_vc_ptr ; data -> irq_mem_hndl = tmp_mem_hndl ; data -> peer_segid = peer_segid ; work_req -> progress_fn = __gnix_vc_conn_ack_prog_fn ; work_req -> data = data ; work_req -> completer_fn = __gnix_vc_conn_ack_comp_fn ; work_req -> completer_data = data ; fastlock_acquire ( & cm_nic -> wq_lock ) ; dlist_insert_before ( & work_req -> list , & cm_nic -> cm_nic_wq ) ; fastlock_release ( & cm_nic -> wq_lock ) ; } else { if ( vc -> conn_state != GNIX_VC_CONNECTING ) { GNIX_WARN ( FI_LOG_EP_CTRL , "vc<S2SV_blank>%p<S2SV_blank>not<S2SV_blank>in<S2SV_blank>connecting<S2SV_blank>state<S2SV_blank>nor<S2SV_blank>in<S2SV_blank>cm<S2SV_blank>wq\\n" , vc , vc -> conn_state ) ; ret = - FI_EINVAL ; goto err ; } ret = _gnix_vc_smsg_init ( vc , src_vc_id , & src_smsg_attr , & tmp_mem_hndl ) ; if ( ret != FI_SUCCESS ) { GNIX_WARN ( FI_LOG_EP_CTRL , "_gnix_vc_smsg_init<S2SV_blank>returned<S2SV_blank>%s\\n" , fi_strerror ( - ret ) ) ; goto err ; } ret = _gnix_xpmem_accessible ( ep , src_cm_nic_addr , & accessible ) ; if ( ( ret == FI_SUCCESS ) && ( accessible == true ) ) { ret = _gnix_xpmem_get_apid ( ep -> xpmem_hndl , peer_segid , & peer_apid ) ; if ( ret == FI_SUCCESS ) { vc -> modes |= GNIX_VC_MODE_XPMEM ; vc -> peer_apid = peer_apid ; } } <S2SV_StartBug> vc -> conn_state = GNIX_VC_CONNECTED ; <S2SV_EndBug> vc -> peer_id = src_vc_id ; GNIX_DEBUG ( FI_LOG_EP_CTRL , "moving<S2SV_blank>vc<S2SV_blank>%p<S2SV_blank>state<S2SV_blank>to<S2SV_blank>connected\\n" , vc ) ; ret = _gnix_vc_sched_new_conn ( vc ) ; if ( ret != FI_SUCCESS ) GNIX_WARN ( FI_LOG_EP_DATA , "_gnix_vc_sched_new_conn<S2SV_blank>returned<S2SV_blank>%s\\n" , fi_strerror ( - ret ) ) ; } <S2SV_StartBug> vc -> peer_caps = peer_caps ; <S2SV_EndBug> err : COND_RELEASE ( ep -> requires_lock , & ep -> vc_lock ) ; return ret ; }
|
<S2SV_ModStart> GNIX_VC_CONNECTING ; } vc -> peer_caps = peer_caps ; <S2SV_ModStart> } vc -> peer_caps = peer_caps ; vc -> peer_id = src_vc_id ; vc -> <S2SV_ModStart> conn_state = GNIX_VC_CONNECTED <S2SV_ModEnd> ; GNIX_DEBUG ( <S2SV_ModStart> ) ; } <S2SV_ModEnd> err : COND_RELEASE
|
534,690 |
CWE-000 static void emit_dbg_loc ( EmitContext * ctx , LLVMBuilderRef builder , const unsigned char * cil_code ) { MonoCompile * cfg = ctx -> cfg ; if ( ctx -> minfo && cil_code && cil_code >= cfg -> header -> code && cil_code < cfg -> header -> code + cfg -> header -> code_size ) { MonoDebugSourceLocation * loc ; LLVMValueRef loc_md ; <S2SV_StartBug> loc = mono_debug_symfile_lookup_location ( ctx -> minfo , cil_code - cfg -> header -> code ) ; <S2SV_EndBug> if ( loc ) { # if LLVM_API_VERSION > 100 loc_md = mono_llvm_di_create_location ( ctx -> module -> di_builder , ctx -> dbg_md , loc -> row , loc -> column ) ; mono_llvm_di_set_location ( builder , loc_md ) ; # else LLVMValueRef md_args [ 16 ] ; int nmd_args ; nmd_args = 0 ; md_args [ nmd_args ++ ] = LLVMConstInt ( LLVMInt32Type ( ) , loc -> row , FALSE ) ; md_args [ nmd_args ++ ] = LLVMConstInt ( LLVMInt32Type ( ) , loc -> column , FALSE ) ; md_args [ nmd_args ++ ] = ctx -> dbg_md ; md_args [ nmd_args ++ ] = NULL ; loc_md = LLVMMDNode ( md_args , nmd_args ) ; LLVMSetCurrentDebugLocation ( builder , loc_md ) ; # endif <S2SV_StartBug> mono_debug_symfile_free_location ( loc ) ; <S2SV_EndBug> } } }
|
<S2SV_ModStart> ; loc = mono_debug_method_lookup_location <S2SV_ModEnd> ( ctx -> <S2SV_ModStart> ; # endif mono_debug_free_source_location <S2SV_ModEnd> ( loc )
|
534,691 |
CWE-000 void print_board ( ) { <S2SV_StartBug> system ( "printf<S2SV_blank>\\"\\033c\\"" ) ; <S2SV_EndBug> for ( int col = 0 ; col < HEIGHT ; col ++ ) { <S2SV_StartBug> for ( int row = 0 ; row < WIDTH ; row ++ ) <S2SV_EndBug> { <S2SV_StartBug> if ( row == row_player && col == col_player ) printf ( "%c" , PLAYER ) ; <S2SV_EndBug> else if ( array [ col ] [ row ] [ 1 ] != '0' ) { <S2SV_StartBug> printf ( "%c" , array [ row ] [ col ] [ 1 ] ) ; <S2SV_EndBug> } else { <S2SV_StartBug> printf ( "%c" , array [ row ] [ col ] [ 0 ] ) ; <S2SV_EndBug> } } printf ( "\\n" ) ; } <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> "printf<S2SV_blank>\\"\\033c\\"" ) ; for ( int row = 0 ; row < WIDTH ; row ++ ) { <S2SV_ModStart> ++ ) { if ( col == col_player && <S2SV_ModEnd> row == row_player <S2SV_ModStart> row == row_player <S2SV_ModEnd> ) printf ( <S2SV_ModStart> , array [ col ] [ row <S2SV_ModEnd> ] [ 1 <S2SV_ModStart> , array [ col ] [ row <S2SV_ModEnd> ] [ 0 <S2SV_ModStart> ) ; } printf ( "\\ncol_player:<S2SV_blank>%d,<S2SV_blank>row_player:<S2SV_blank>%d\\n" , col_player , row_player ) ; printf ( "\\nChar<S2SV_blank>on<S2SV_blank>[6,8]:<S2SV_blank>%c\\n" , array [ 6 ] [ 8 ] [ 0 ] ) ;
|
534,692 |
CWE-000 <S2SV_StartBug> void hash_table_destroy ( struct hash_table * table ) <S2SV_EndBug> { if ( ! table ) return ; for ( int i = 0 ; i < table -> num_buckets ; i ++ ) { struct hash_entry * cur = table -> buckets [ i ] , * next = NULL ; while ( cur ) { next = cur -> next ; <S2SV_StartBug> hash_entry_destroy ( cur ) ; <S2SV_EndBug> cur = next ; } } free ( table -> buckets ) ; free ( table ) ; }
|
<S2SV_ModStart> hash_table * table , void ( destroy ) ( void * ) <S2SV_ModStart> -> next ; if ( cur -> value ) destroy ( cur -> value ) ; cur -> value = NULL ;
|
534,693 |
CWE-000 void wcnss_reset_fiq ( bool clk_chk_en ) { if ( wcnss_hardware_type ( ) == WCNSS_PRONTO_HW ) { if ( clk_chk_en ) { wcnss_log_debug_regs_on_bite ( ) ; } else { wcnss_pronto_log_debug_regs ( ) ; <S2SV_StartBug> if ( wcnss_get_mux_control ( ) ) <S2SV_EndBug> <S2SV_StartBug> wcnss_log_iris_regs ( ) ; <S2SV_EndBug> } wmb ( ) ; __raw_writel ( 1 << 16 , penv -> fiq_reg ) ; } else { wcnss_riva_log_debug_regs ( ) ; } }
|
<S2SV_ModStart> ( ) ; # ifdef CONFIG_WCNSS_REGISTER_DUMP_ON_BITE <S2SV_ModStart> ( ) ; # endif
|
534,694 |
CWE-000 static void proxy_device_error_cb ( MbimDevice * device , GError * error , MbimProxy * self ) { if ( g_error_matches ( error , MBIM_PROTOCOL_ERROR , MBIM_PROTOCOL_ERROR_NOT_OPENED ) ) { <S2SV_StartBug> g_debug ( "Device<S2SV_blank>not<S2SV_blank>opened<S2SV_blank>error<S2SV_blank>reported,<S2SV_blank>forcing<S2SV_blank>close" ) ; <S2SV_EndBug> mbim_device_close_force ( device , NULL ) ; } }
|
<S2SV_ModStart> { g_debug ( "device<S2SV_blank>\'%s\'<S2SV_blank>reports<S2SV_blank>as<S2SV_blank>being<S2SV_blank>closed..." , mbim_device_get_path ( device ) ) ; reset_client_service_subscribe_lists ( self , device <S2SV_ModEnd> ) ; mbim_device_close_force
|
534,695 |
CWE-000 int main ( void ) { size_t buff_size = SIZE * sizeof ( double ) ; double * data = malloc ( buff_size ) ; <S2SV_StartBug> int out_size ; <S2SV_EndBug> for ( int i = 0 ; i < SIZE ; i ++ ) { data [ i ] = i ; } struct sz_params p ; memset ( & p , - 1 , sizeof ( p ) ) ; p . dataEndianType = LITTLE_ENDIAN_DATA ; p . max_quant_intervals = 65536 ; p . quantization_intervals = 0 ; p . layers = 1 ; p . sampleDistance = 100 ; p . predThreshold = 0.97 ; p . offset = 0 ; p . szMode = SZ_BEST_COMPRESSION ; p . errorBoundMode = ABS ; p . absErrBound = 0.0001 ; p . relBoundRatio = 0.001 ; p . pw_relBoundRatio = 0.000001 ; p . segment_size = 32 ; unsigned char * out_buff = malloc ( buff_size * 2 ) ; SZ_Init_Params ( & p ) ; <S2SV_StartBug> int ret = SZ_compress_args2 ( SZ_DOUBLE , data , out_buff , & out_size , ABS , 10.0 , 0.0 , 0 , 0 , 0 , 0 , SIZE ) ; <S2SV_EndBug> printf ( "%d<S2SV_blank>%d\\n" , ret , out_size ) ; double * result = malloc ( buff_size ) ; ret = SZ_decompress_args ( SZ_DOUBLE , out_buff , out_size , ( void * ) result , 0 , 0 , 0 , 0 , SIZE ) ; for ( int i = 0 ; i < 5 ; i ++ ) { printf ( "%f\\n" , result [ i ] ) ; } SZ_Finalize ( ) ; return 0 ; }
|
<S2SV_ModStart> buff_size ) ; size_t <S2SV_ModEnd> out_size ; for <S2SV_ModStart> , 0.0 , 0.0 , 0 ,
|
534,696 |
CWE-000 void apple_produce ( void ) { for ( ; ; ) { random_seed = 214013 * random_seed + 2531011 ; apple . apple_grade = random_seed % 3 + 1 ; apple . apple_position . y = random_seed % ( LINES - 2 ) + 1 ; apple . apple_position . x = random_seed % ( COLS - 2 ) + 1 ; for ( int i = snake . body . head ; i < snake . body . tail ; i = ( i + 1 ) % snake . body . max_length ) if ( ABS ( apple . apple_position . x - ( ( struct Vec2 * ) ( snake . body . data + i * snake . body . element_size ) ) -> x ) < 2 && ABS ( apple . apple_position . y - ( ( struct Vec2 * ) ( snake . body . data + i * snake . body . element_size ) ) -> y ) < 2 ) continue ; break ; } <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> break ; } return ;
|
534,697 |
CWE-000 int main ( int argc , char * argv [ ] ) { # ifdef MPI_ENABLED MPI_Init ( & argc , & argv ) ; MPI_Comm_rank ( MPI_COMM_WORLD , & rank ) ; MPI_Comm_size ( MPI_COMM_WORLD , & size ) ; <S2SV_StartBug> play ( WHITE , 10 ) ; <S2SV_EndBug> MPI_Finalize ( ) ; # else <S2SV_StartBug> play_serial ( WHITE , 8 ) ; <S2SV_EndBug> # endif return 0 ; }
|
<S2SV_ModStart> ( WHITE , 8 <S2SV_ModEnd> ) ; MPI_Finalize <S2SV_ModStart> ( WHITE , 10 <S2SV_ModEnd> ) ; #
|
534,698 |
CWE-000 static void pocli_free ( struct pocli * pcli ) { while ( pmemobj_tx_stage ( ) != TX_STAGE_NONE ) { while ( pmemobj_tx_stage ( ) != TX_STAGE_NONE ) pmemobj_tx_process ( ) ; pmemobj_tx_end ( ) ; } <S2SV_StartBug> pmemobj_close ( pcli -> ctx . pop ) ; <S2SV_EndBug> free ( pcli -> inbuf ) ; free ( pcli ) ; }
|
<S2SV_ModStart> ) ; } VEC_DELETE ( & pcli -> ctx . free_on_abort ) ;
|
534,699 |
CWE-000 int * convertCharParaBinario ( int indice ) { int i = 7 ; int * binario = ( int * ) calloc ( 8 , sizeof ( int ) ) ; if ( binario == 0 ) { <S2SV_StartBug> printf ( "Não<S2SV_blank>foi<S2SV_blank>possível<S2SV_blank>alocar<S2SV_blank>a<S2SV_blank>memória<S2SV_blank>para<S2SV_blank>o<S2SV_blank>inteiro<S2SV_blank>com<S2SV_blank>os<S2SV_blank>bits\\n" ) ; <S2SV_EndBug> exit ( 1 ) ; } while ( indice > 0 ) { binario [ i ] = indice % 2 ; indice = indice / 2 ; i -- ; } return binario ; }
|
<S2SV_ModStart> 0 ) { fprintf ( stderr , <S2SV_ModEnd> "Não<S2SV_blank>foi<S2SV_blank>possível<S2SV_blank>alocar<S2SV_blank>a<S2SV_blank>memória<S2SV_blank>para<S2SV_blank>o<S2SV_blank>inteiro<S2SV_blank>com<S2SV_blank>os<S2SV_blank>bits\\n" ) ;
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.