Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
900 | CWE-000 static gboolean gst_tensor_merge_collect_buffer ( GstTensorMerge * tensor_merge , GstBuffer * tensors_buf , GstClockTime * pts_time , GstClockTime * dts_time ) { GSList * walk = NULL ; GstTensorMergePadData * bestpad = NULL ; GstMemory * mem ; gboolean isEOS = FALSE ; gint old_numerator = G_MAXINT ; gint old_denominator = G_MAXINT ; gint counting = 0 ; GstTensorConfig config ; walk = tensor_merge -> collect -> data ; if ( tensor_merge -> need_set_time ) { while ( walk ) { GstCollectData * data = ( GstCollectData * ) walk -> data ; walk = g_slist_next ( walk ) ; GstBuffer * buf = NULL ; buf = gst_collect_pads_peek ( tensor_merge -> collect , data ) ; if ( buf == NULL ) return TRUE ; if ( tensor_merge -> current_time < GST_BUFFER_PTS ( buf ) ) tensor_merge -> current_time = GST_BUFFER_PTS ( buf ) ; gst_buffer_unref ( buf ) ; } tensor_merge -> need_set_time = FALSE ; } walk = tensor_merge -> collect -> data ; while ( walk ) { GstCollectData * data = ( GstCollectData * ) walk -> data ; GstTensorMergePadData * pad = ( GstTensorMergePadData * ) data ; GstCaps * caps = gst_pad_get_current_caps ( pad -> pad ) ; GstStructure * s = gst_caps_get_structure ( caps , 0 ) ; gst_tensor_config_from_structure ( & config , s ) ; g_assert ( gst_tensor_config_validate ( & config ) ) ; if ( config . rate_d < old_denominator ) old_denominator = config . rate_d ; if ( config . rate_n < old_numerator ) old_numerator = config . rate_n ; gst_caps_unref ( caps ) ; walk = g_slist_next ( walk ) ; GstBuffer * buf = NULL ; buf = gst_collect_pads_peek ( tensor_merge -> collect , data ) ; if ( buf == NULL && pad -> buffer == NULL ) return TRUE ; if ( buf != NULL ) { if ( GST_BUFFER_PTS ( buf ) < tensor_merge -> current_time ) { gst_buffer_unref ( buf ) ; if ( pad -> buffer != NULL ) gst_buffer_unref ( pad -> buffer ) ; pad -> buffer = gst_collect_pads_pop ( tensor_merge -> collect , data ) ; silent_debug ( "Fame<S2SV_blank>Dropped<S2SV_blank>:<S2SV_blank>%lu" , GST_BUFFER_PTS ( pad -> buffer ) ) ; tensor_merge -> need_buffer = TRUE ; return FALSE ; } if ( pad -> buffer != NULL && ABS ( GST_CLOCK_DIFF ( tensor_merge -> current_time , GST_BUFFER_PTS ( pad -> buffer ) ) ) < ABS ( GST_CLOCK_DIFF ( tensor_merge -> current_time , GST_BUFFER_PTS ( buf ) ) ) ) { gst_buffer_unref ( buf ) ; buf = pad -> buffer ; } else { gst_buffer_unref ( buf ) ; buf = gst_collect_pads_pop ( tensor_merge -> collect , data ) ; <S2SV_StartBug> } <S2SV_EndBug> } else { buf = pad -> buffer ; } mem = gst_buffer_get_memory ( buf , 0 ) ; gst_buffer_append_memory ( tensors_buf , mem ) ; silent_debug ( "Append<S2SV_blank>Memory<S2SV_blank>#<S2SV_blank>%d<S2SV_blank>(PTS<S2SV_blank>:<S2SV_blank>%lu)" , gst_buffer_n_memory ( tensors_buf ) , GST_BUFFER_PTS ( buf ) ) ; if ( gst_tensor_merge_compare_pads ( tensor_merge , bestpad , pad ) > 0 ) { bestpad = pad ; * pts_time = bestpad -> pts_timestamp ; * dts_time = bestpad -> dts_timestamp ; } <S2SV_StartBug> gst_buffer_unref ( buf ) ; <S2SV_EndBug> tensor_merge -> tensors_config . info . info [ counting ] = config . info ; counting ++ ; } tensor_merge -> tensors_config . rate_d = old_denominator ; tensor_merge -> tensors_config . rate_n = old_numerator ; GST_BUFFER_PTS ( tensors_buf ) = * pts_time ; GST_BUFFER_DTS ( tensors_buf ) = * dts_time ; return isEOS ; } | <S2SV_ModStart> data ) ; if ( pad -> buffer != NULL ) gst_buffer_unref ( pad -> buffer ) ; pad -> buffer = buf ; <S2SV_ModStart> dts_timestamp ; } <S2SV_ModEnd> tensor_merge -> tensors_config |
901 | CWE-000 static int64_t pcie_slot_set_power_state_ext ( struct pci_slot * slot , uint8_t val , bool surprise_check ) { struct phb * phb = slot -> phb ; struct pci_device * pd = slot -> pd ; uint32_t ecap ; uint16_t state ; if ( slot -> power_state == val ) return OPAL_PARAMETER ; if ( ! ( slot -> slot_cap & PCICAP_EXP_SLOTCAP_PWCTRL ) ) { slot -> power_state = val ; return OPAL_SUCCESS ; } if ( surprise_check && slot -> surprise_pluggable ) { slot -> power_state = val ; <S2SV_StartBug> return OPAL_SUCCESS ; <S2SV_EndBug> } pci_slot_set_state ( slot , PCI_SLOT_STATE_SPOWER_START ) ; slot -> power_state = val ; ecap = pci_cap ( pd , PCI_CFG_CAP_ID_EXP , false ) ; pci_cfg_read16 ( phb , pd -> bdfn , ecap + PCICAP_EXP_SLOTCTL , & state ) ; state &= ~ ( PCICAP_EXP_SLOTCTL_PWRCTLR | PCICAP_EXP_SLOTCTL_PWRI ) ; switch ( val ) { case PCI_SLOT_POWER_OFF : state |= ( PCICAP_EXP_SLOTCTL_PWRCTLR | ( PCIE_INDIC_OFF << 8 ) ) ; break ; case PCI_SLOT_POWER_ON : state |= ( PCIE_INDIC_ON << 8 ) ; break ; default : pci_slot_set_state ( slot , PCI_SLOT_STATE_NORMAL ) ; prlog ( PR_ERR , PCIE_SLOT_PREFIX "Invalid<S2SV_blank>power<S2SV_blank>state<S2SV_blank>(0x%x)\\n" , slot -> id , val ) ; return OPAL_PARAMETER ; } pci_cfg_write16 ( phb , pd -> bdfn , ecap + PCICAP_EXP_SLOTCTL , state ) ; pci_slot_set_state ( slot , PCI_SLOT_STATE_SPOWER_DONE ) ; return OPAL_ASYNC_COMPLETION ; } | <S2SV_ModStart> = val ; if ( val == PCI_SLOT_POWER_ON ) { pci_slot_set_state ( slot , PCI_SLOT_STATE_SPOWER_DONE ) ; return OPAL_ASYNC_COMPLETION ; } |
902 | CWE-000 void tPAGE3_KEY ( void ) { u8 State = 0 ; <S2SV_StartBug> switch ( current_key ) { <S2SV_EndBug> case UP_KEY : State = 0xff ; case DOWN_KEY : if ( bENTER ) { bSETUP_Change_flag = 1 ; switch ( vITEM_Y ) { # ifdef __4CH__ case 0 : Inc_Dec_Count ( 60 , 0 , State , & sys_env . vDWELL [ vITEM_Y ] ) ; EEP_buf [ cSYSENV_vDWELL + vITEM_Y ] = sys_env . vDWELL [ vITEM_Y ] ; break ; case 1 : Inc_Dec_Count ( 1 , 0 , State , & sys_env . bLossAutoSkip ) ; EEP_buf [ cSYSENV_bLossAutoSkip ] = sys_env . bLossAutoSkip ; break ; # endif } tPAGE3_Position ( UNDER_BAR ) ; } else { # ifdef __4CH__ Inc_Dec_Count ( 1 , 0 , ~ State , & vITEM_Y ) ; # endif MenuSelect ( vITEM_Y , 0 ) ; } break ; case ENTER_KEY : if ( bENTER ) { bENTER = 0 ; tPAGE3_Position ( NULL ) ; } else { bENTER = 1 ; tPAGE3_Position ( UNDER_BAR ) ; } break ; case EXIT_KEY : if ( bENTER ) { bENTER = 0 ; tPAGE3_Position ( NULL ) ; } else { vITEM_Y = vPAGE - 1 ; SetupMenu ( ) ; } break ; } } | <S2SV_ModStart> = 0 ; keydata_e current_key = GetCurrentKey ( ) ; |
903 | CWE-000 void wima_item_setSize ( WimaItemHandle item , int w , int h ) { WimaItem * pitem = wima_item_ptr ( item ) ; pitem -> size [ 0 ] = w ; pitem -> size [ 1 ] = h ; if ( ! w ) { <S2SV_StartBug> pitem -> flags &= ~ UI_ITEM_HFIXED ; <S2SV_EndBug> } else { <S2SV_StartBug> pitem -> flags |= UI_ITEM_HFIXED ; <S2SV_EndBug> } if ( ! h ) { <S2SV_StartBug> pitem -> flags &= ~ UI_ITEM_VFIXED ; <S2SV_EndBug> } else { <S2SV_StartBug> pitem -> flags |= UI_ITEM_VFIXED ; <S2SV_EndBug> } } | <S2SV_ModStart> flags &= ~ WIMA_ITEM_HFIXED <S2SV_ModEnd> ; } else <S2SV_ModStart> -> flags |= WIMA_ITEM_HFIXED <S2SV_ModEnd> ; } if <S2SV_ModStart> flags &= ~ WIMA_ITEM_VFIXED <S2SV_ModEnd> ; } else <S2SV_ModStart> -> flags |= WIMA_ITEM_VFIXED <S2SV_ModEnd> ; } } |
904 | CWE-000 <S2SV_StartBug> void killthread ( uint64_t tid ) { <S2SV_EndBug> acquire ( & ptablelock ) ; <S2SV_StartBug> if ( tid < cpuno && threads [ tid ] . proc == cpu -> thread -> proc ) { <S2SV_EndBug> threads [ tid ] . killed = 1 ; <S2SV_StartBug> } <S2SV_EndBug> release ( & ptablelock ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> int64_t <S2SV_ModEnd> killthread ( uint64_t <S2SV_ModStart> tid ) { int64_t ret = 0 ; <S2SV_ModStart> if ( tid >= <S2SV_ModEnd> cpuno && threads <S2SV_ModStart> 1 ; } else { ret = - 1 ; } <S2SV_ModStart> ptablelock ) ; return ret ; |
905 | CWE-000 void rfree ( void * ptr ) { struct mm_heap * cpu_heap ; uint32_t flags ; if ( ! ptr ) return ; if ( is_uncached ( ptr ) ) ptr = uncache_to_cache ( ptr ) ; cpu_heap = memmap . system + cpu_get_id ( ) ; if ( ptr >= ( void * ) cpu_heap -> heap && <S2SV_StartBug> ptr <= ( void * ) cpu_heap -> heap + cpu_heap -> size ) { <S2SV_EndBug> trace_error ( TRACE_CLASS_MEM , "rfree()<S2SV_blank>error:<S2SV_blank>" "attempt<S2SV_blank>to<S2SV_blank>free<S2SV_blank>system<S2SV_blank>heap<S2SV_blank>=<S2SV_blank>%p,<S2SV_blank>cpu<S2SV_blank>=<S2SV_blank>%d" , ( uintptr_t ) ptr , cpu_get_id ( ) ) ; panic ( SOF_IPC_PANIC_MEM ) ; } spin_lock_irq ( & memmap . lock , flags ) ; free_block ( ptr ) ; spin_unlock_irq ( & memmap . lock , flags ) ; } | <S2SV_ModStart> heap && ptr < <S2SV_ModEnd> ( void * |
906 | CWE-000 void float_formating ( s_array * text_array , s_array * flags , double my_double , char var_arg , int after_point , int before_point ) { <S2SV_StartBug> convert_float_to_string ( text_array , my_double , after_point , before_point , var_arg ) ; <S2SV_EndBug> } | <S2SV_ModStart> before_point ) { flag_insertion ( text_array , flags , my_double ) ; |
907 | CWE-000 static int kgsl_mem_entry_track_gpuaddr ( struct kgsl_process_private * process , struct kgsl_mem_entry * entry ) { <S2SV_StartBug> int ret = 0 ; <S2SV_EndBug> struct rb_node * * node ; struct rb_node * parent = NULL ; struct kgsl_pagetable * pagetable = process -> pagetable ; assert_spin_locked ( & process -> mem_lock ) ; if ( kgsl_memdesc_use_cpu_map ( & entry -> memdesc ) ) { if ( ! entry -> memdesc . gpuaddr ) goto done ; } else if ( entry -> memdesc . gpuaddr ) { WARN_ONCE ( 1 , "gpuaddr<S2SV_blank>assigned<S2SV_blank>w/o<S2SV_blank>holding<S2SV_blank>memory<S2SV_blank>lock\\n" ) ; ret = - EINVAL ; goto done ; } if ( kgsl_memdesc_is_secured ( & entry -> memdesc ) ) pagetable = pagetable -> mmu -> securepagetable ; ret = kgsl_mmu_get_gpuaddr ( pagetable , & entry -> memdesc ) ; <S2SV_StartBug> if ( ret ) <S2SV_EndBug> goto done ; node = & process -> mem_rb . rb_node ; while ( * node ) { struct kgsl_mem_entry * cur ; parent = * node ; cur = rb_entry ( parent , struct kgsl_mem_entry , node ) ; if ( entry -> memdesc . gpuaddr < cur -> memdesc . gpuaddr ) node = & parent -> rb_left ; else node = & parent -> rb_right ; } rb_link_node ( & entry -> node , parent , node ) ; rb_insert_color ( & entry -> node , & process -> mem_rb ) ; done : return ret ; } | <S2SV_ModStart> ret = 0 <S2SV_ModEnd> ; struct kgsl_pagetable <S2SV_ModStart> memdesc ) ; <S2SV_ModEnd> done : return |
908 | CWE-000 static bfd_boolean _bfd_riscv_relax_pc ( bfd * abfd , asection * sec , asection * sym_sec , struct bfd_link_info * link_info , Elf_Internal_Rela * rel , bfd_vma symval , bfd_vma max_alignment , bfd_vma reserve_size , bfd_boolean * again ATTRIBUTE_UNUSED , riscv_pcgp_relocs * pcgp_relocs ) { bfd_vma gp = riscv_global_pointer_value ( link_info ) ; BFD_ASSERT ( rel -> r_offset + 4 <= sec -> size ) ; riscv_pcgp_hi_reloc hi_reloc ; memset ( & hi_reloc , 0 , sizeof ( hi_reloc ) ) ; switch ( ELFNN_R_TYPE ( rel -> r_info ) ) { case R_RISCV_PCREL_LO12_I : case R_RISCV_PCREL_LO12_S : { riscv_pcgp_hi_reloc * hi = riscv_find_pcgp_hi_reloc ( pcgp_relocs , symval - sec_addr ( sym_sec ) ) ; if ( hi == NULL ) { riscv_record_pcgp_lo_reloc ( pcgp_relocs , symval - sec_addr ( sym_sec ) ) ; return TRUE ; } hi_reloc = * hi ; symval = hi_reloc . hi_addr ; sym_sec = hi_reloc . sym_sec ; if ( ! riscv_use_pcgp_hi_reloc ( pcgp_relocs , hi -> hi_sec_off ) ) <S2SV_StartBug> ( * _bfd_error_handler ) <S2SV_EndBug> <S2SV_StartBug> ( _ ( "%pB(%pA+0x%lx):<S2SV_blank>Unable<S2SV_blank>to<S2SV_blank>clear<S2SV_blank>RISCV_PCREL_HI20<S2SV_blank>reloc" <S2SV_EndBug> "for<S2SV_blank>cooresponding<S2SV_blank>RISCV_PCREL_LO12<S2SV_blank>reloc" ) , <S2SV_StartBug> abfd , sec , rel -> r_offset ) ; <S2SV_EndBug> } break ; case R_RISCV_PCREL_HI20 : if ( sym_sec -> flags & ( SEC_MERGE | SEC_CODE ) ) return TRUE ; if ( riscv_find_pcgp_lo_reloc ( pcgp_relocs , rel -> r_offset ) ) return TRUE ; break ; default : abort ( ) ; } if ( gp ) { struct bfd_link_hash_entry * h = bfd_link_hash_lookup ( link_info -> hash , RISCV_GP_SYMBOL , FALSE , FALSE , TRUE ) ; if ( h -> u . def . section -> output_section == sym_sec -> output_section ) max_alignment = ( bfd_vma ) 1 << sym_sec -> output_section -> alignment_power ; } if ( VALID_ITYPE_IMM ( symval ) || ( symval >= gp && VALID_ITYPE_IMM ( symval - gp + max_alignment + reserve_size ) ) || ( symval < gp && VALID_ITYPE_IMM ( symval - gp - max_alignment - reserve_size ) ) ) { unsigned sym = hi_reloc . hi_sym ; switch ( ELFNN_R_TYPE ( rel -> r_info ) ) { case R_RISCV_PCREL_LO12_I : rel -> r_info = ELFNN_R_INFO ( sym , R_RISCV_GPREL_I ) ; rel -> r_addend += hi_reloc . hi_addend ; return riscv_delete_pcgp_lo_reloc ( pcgp_relocs , rel -> r_offset , 4 ) ; case R_RISCV_PCREL_LO12_S : rel -> r_info = ELFNN_R_INFO ( sym , R_RISCV_GPREL_S ) ; rel -> r_addend += hi_reloc . hi_addend ; return riscv_delete_pcgp_lo_reloc ( pcgp_relocs , rel -> r_offset , 4 ) ; case R_RISCV_PCREL_HI20 : riscv_record_pcgp_hi_reloc ( pcgp_relocs , rel -> r_offset , rel -> r_addend , symval , ELFNN_R_SYM ( rel -> r_info ) , sym_sec ) ; rel -> r_info = ELFNN_R_INFO ( 0 , R_RISCV_DELETE ) ; rel -> r_addend = 4 ; return riscv_delete_pcgp_hi_reloc ( pcgp_relocs , rel -> r_offset ) ; default : abort ( ) ; } } return TRUE ; } | <S2SV_ModStart> hi_sec_off ) ) _bfd_error_handler <S2SV_ModEnd> ( _ ( <S2SV_ModStart> ( _ ( "%pB(%pA+%#" PRIx64 "):<S2SV_blank>Unable<S2SV_blank>to<S2SV_blank>clear<S2SV_blank>RISCV_PCREL_HI20<S2SV_blank>reloc<S2SV_blank>" "for<S2SV_blank>corresponding<S2SV_blank>RISCV_PCREL_LO12<S2SV_blank>reloc" <S2SV_ModEnd> ) , abfd <S2SV_ModStart> , sec , ( uint64_t ) |
909 | CWE-000 int root_handle_usecond_overflow_event ( void * context , const mcu_event_t * data ) { sched_usecond_counter ++ ; <S2SV_StartBug> root_handle_usecond_match_event ( NULL , 0 ) ; <S2SV_EndBug> return 1 ; } | <S2SV_ModStart> ; root_handle_usecond_match_event ( 0 <S2SV_ModEnd> , 0 ) |
910 | CWE-000 corto_void _test_compositeReferenceApi_tc_createChild ( test_compositeReferenceApi this ) { test_compositeReferenceType o = test_compositeReferenceTypeCreateChild ( root_o , "o" , 10 , 20 ) ; test_assert ( o != NULL ) ; test_assert ( corto_typeof ( o ) == corto_type ( test_compositeReferenceType_o ) ) ; test_assert ( corto_checkState ( o , CORTO_DEFINED ) ) ; <S2SV_StartBug> test_assert ( corto_checkAttr ( o , CORTO_ATTR_SCOPED ) ) ; <S2SV_EndBug> test_assert ( corto_parentof ( o ) == root_o ) ; test_assert ( ! strcmp ( corto_idof ( o ) , "o" ) ) ; test_assert ( o -> x == 10 ) ; test_assert ( o -> y == 20 ) ; test_assert ( ! corto_delete ( o ) ) ; } | <S2SV_ModStart> ( o , CORTO_ATTR_NAMED <S2SV_ModEnd> ) ) ; |
911 | CWE-000 void writechars ( void * _ ) { PutChar ( * ( ( char * ) _ ) ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ) ) ; PutChar ( '\\n' ) ; |
912 | CWE-000 int MQTTSNDeserialize_subscribe ( unsigned char * dup , int * qos , unsigned short * packetid , MQTTSN_topicid * topicFilter , unsigned char * buf , int buflen ) { MQTTSNFlags flags ; unsigned char * curdata = buf ; unsigned char * enddata = NULL ; int rc = 0 ; int mylen = 0 ; FUNC_ENTRY ; <S2SV_StartBug> curdata += ( rc = MQTTSNPacket_decode ( curdata , buflen , & mylen ) ) ; <S2SV_EndBug> enddata = buf + mylen ; if ( enddata - curdata > buflen ) goto exit ; if ( readChar ( & curdata ) != MQTTSN_SUBSCRIBE ) goto exit ; flags . all = readChar ( & curdata ) ; * dup = flags . bits . dup ; * qos = flags . bits . QoS ; * packetid = readInt ( & curdata ) ; topicFilter -> type = ( MQTTSN_topicTypes ) flags . bits . topicIdType ; if ( topicFilter -> type == MQTTSN_TOPIC_TYPE_NORMAL ) { topicFilter -> data . long_ . len = enddata - curdata ; topicFilter -> data . long_ . name = ( char * ) curdata ; } else if ( topicFilter -> type == MQTTSN_TOPIC_TYPE_PREDEFINED ) topicFilter -> data . id = readInt ( & curdata ) ; else if ( topicFilter -> type == MQTTSN_TOPIC_TYPE_SHORT ) { topicFilter -> data . short_name [ 0 ] = readChar ( & curdata ) ; topicFilter -> data . short_name [ 1 ] = readChar ( & curdata ) ; } rc = 1 ; exit : FUNC_EXIT_RC ( rc ) ; return rc ; } | <S2SV_ModStart> ; curdata += <S2SV_ModEnd> MQTTSNPacket_decode ( curdata <S2SV_ModStart> , & mylen <S2SV_ModEnd> ) ; enddata |
913 | CWE-000 <S2SV_StartBug> static void keyword_break ( lily_parse_state * parser , int multi ) <S2SV_EndBug> { lily_emit_break ( parser -> emit ) ; <S2SV_StartBug> if ( multi && code_is_after_exit ( parser ) ) <S2SV_EndBug> lily_raise_syn ( parser -> raiser , "Statement(s)<S2SV_blank>after<S2SV_blank>\'break\'<S2SV_blank>will<S2SV_blank>not<S2SV_blank>execute." ) ; } | <S2SV_ModStart> lily_parse_state * parser <S2SV_ModEnd> ) { lily_emit_break <S2SV_ModStart> ; if ( <S2SV_ModEnd> code_is_after_exit ( parser |
914 | CWE-000 void mmc_get_card ( struct mmc_card * card ) { pm_runtime_get_sync ( & card -> dev ) ; mmc_claim_host ( card -> host ) ; <S2SV_StartBug> # ifdef CONFIG_MMC_BLOCK_DEFERRED_RESUME <S2SV_EndBug> if ( mmc_bus_needs_resume ( card -> host ) ) mmc_resume_bus ( card -> host ) ; <S2SV_StartBug> # endif <S2SV_EndBug> } | <S2SV_ModStart> host ) ; <S2SV_ModEnd> if ( mmc_bus_needs_resume <S2SV_ModStart> host ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
915 | CWE-000 static void dtap_rr_app_inf ( tvbuff_t * tvb , proto_tree * tree , packet_info * pinfo _U_ , guint32 offset , guint len ) { guint32 curr_offset ; guint32 consumed ; guint curr_len ; curr_offset = offset ; curr_len = len ; <S2SV_StartBug> ELEM_MAND_V ( GSM_A_PDU_TYPE_RR , DE_RR_APDU_ID , NULL , ei_gsm_a_rr_missing_mandatory_element ) ; <S2SV_EndBug> <S2SV_StartBug> ELEM_MAND_V ( GSM_A_PDU_TYPE_RR , DE_RR_APDU_FLAGS , NULL , ei_gsm_a_rr_missing_mandatory_element ) ; <S2SV_EndBug> ELEM_MAND_LV ( GSM_A_PDU_TYPE_RR , DE_RR_APDU_DATA , NULL , ei_gsm_a_rr_missing_mandatory_element ) ; } | <S2SV_ModStart> = len ; ELEM_MAND_VV_SHORT <S2SV_ModEnd> ( GSM_A_PDU_TYPE_RR , <S2SV_ModStart> , DE_RR_APDU_ID , <S2SV_ModEnd> GSM_A_PDU_TYPE_RR , DE_RR_APDU_FLAGS <S2SV_ModStart> , DE_RR_APDU_FLAGS , <S2SV_ModEnd> ei_gsm_a_rr_missing_mandatory_element ) ; |
916 | CWE-000 void dealData ( u_char * usearg , const struct pcap_pkthdr * pkthdr , const u_char * packet ) { int fd ; fd = open ( dump_log , O_CREAT | O_WRONLY | O_APPEND ) ; <S2SV_StartBug> if ( fd = - 1 ) { <S2SV_EndBug> printf ( "can<S2SV_blank>not<S2SV_blank>open<S2SV_blank>the<S2SV_blank>file\\n" ) ; exit ( 2 ) ; } write ( fd , packet , pkthdr -> len + 1 ) ; <S2SV_StartBug> clost ( fd ) ; <S2SV_EndBug> analysisData ( pkthdr , packet ) ; } | <S2SV_ModStart> if ( fd == <S2SV_ModEnd> - 1 ) <S2SV_ModStart> 1 ) ; close <S2SV_ModEnd> ( fd ) |
917 | CWE-000 int nx_inflateReset ( z_streamp strm ) { nx_streamp s ; if ( strm == Z_NULL ) return Z_STREAM_ERROR ; s = ( nx_streamp ) strm -> state ; strm -> msg = Z_NULL ; if ( s -> wrap ) s -> adler = s -> wrap & 1 ; s -> total_in = s -> total_out = 0 ; s -> used_in = s -> used_out = 0 ; s -> cur_in = s -> cur_out = 0 ; <S2SV_StartBug> s -> nxcmdp = & s -> nxcmd0 ; <S2SV_EndBug> s -> crc32 = INIT_CRC ; s -> adler32 = INIT_ADLER ; s -> ckidx = 0 ; s -> cksum = INIT_CRC ; s -> havedict = 0 ; return nx_inflateResetKeep ( strm ) ; } | <S2SV_ModStart> ; s -> inf_state = 0 ; s -> resuming = 0 ; s -> history_len = 0 ; s -> |
918 | CWE-000 static void unity_run_single_test_by_name ( const char * filter ) <S2SV_StartBug> { <S2SV_EndBug> char tmp [ 256 ] ; strncpy ( tmp , filter + 1 , sizeof ( tmp ) - 1 ) ; tmp [ strlen ( filter ) - 2 ] = 0 ; for ( const struct test_desc_t * test = s_unity_tests_first ; test != NULL ; test = test -> next ) { if ( strstr ( test -> name , tmp ) != NULL ) { unity_run_single_test ( test ) ; } } } | <S2SV_ModStart> filter ) { if ( s_invert ) { printf ( "Inverse<S2SV_blank>is<S2SV_blank>not<S2SV_blank>supported<S2SV_blank>for<S2SV_blank>that<S2SV_blank>kind<S2SV_blank>of<S2SV_blank>filter\\n" ) ; return ; } |
919 | CWE-000 igraph_real_t t_stat_vector ( igraph_vector_t * v1 ) { <S2SV_StartBug> return ( mean_vector ( v1 ) / stderror_vector ( v1 ) ) ; <S2SV_EndBug> } | <S2SV_ModStart> v1 ) / std_error_vector <S2SV_ModEnd> ( v1 ) |
920 | CWE-000 int sl_cs_exit_contention ( union sl_cs_intern * csi , union sl_cs_intern * cached , sched_tok_t tok ) { struct sl_thd * t = sl_thd_curr ( ) ; struct sl_global * g = sl__globals ( ) ; if ( ! ps_cas ( & g -> lock . u . v , cached -> v , 0 ) ) return 1 ; <S2SV_StartBug> cos_defswitch ( g -> sched_thdcap , t -> prio , g -> timer_next , tok ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> , g -> timeout_next <S2SV_ModEnd> , tok ) |
921 | CWE-000 static sqlite3_index_info * allocateIndexInfo ( Parse * pParse , WhereClause * pWC , Bitmask mUnusable , struct SrcList_item * pSrc , ExprList * pOrderBy ) { int i , j ; int nTerm ; struct sqlite3_index_constraint * pIdxCons ; struct sqlite3_index_orderby * pIdxOrderBy ; struct sqlite3_index_constraint_usage * pUsage ; WhereTerm * pTerm ; int nOrderBy ; sqlite3_index_info * pIdxInfo ; for ( i = nTerm = 0 , pTerm = pWC -> a ; i < pWC -> nTerm ; i ++ , pTerm ++ ) { if ( pTerm -> leftCursor != pSrc -> iCursor ) continue ; if ( pTerm -> prereqRight & mUnusable ) continue ; assert ( IsPowerOfTwo ( pTerm -> eOperator & ~ WO_EQUIV ) ) ; testcase ( pTerm -> eOperator & WO_IN ) ; testcase ( pTerm -> eOperator & WO_ISNULL ) ; testcase ( pTerm -> eOperator & WO_IS ) ; testcase ( pTerm -> eOperator & WO_ALL ) ; if ( ( pTerm -> eOperator & ~ ( WO_ISNULL | WO_EQUIV | WO_IS ) ) == 0 ) continue ; <S2SV_StartBug> if ( pTerm -> wtFlags & TERM_VNULL ) continue ; <S2SV_EndBug> nTerm ++ ; } nOrderBy = 0 ; if ( pOrderBy ) { int n = pOrderBy -> nExpr ; for ( i = 0 ; i < n ; i ++ ) { Expr * pExpr = pOrderBy -> a [ i ] . pExpr ; if ( pExpr -> op != TK_COLUMN || pExpr -> iTable != pSrc -> iCursor ) break ; } if ( i == n ) { nOrderBy = n ; } } pIdxInfo = sqlite3DbMallocZero ( pParse -> db , sizeof ( * pIdxInfo ) + ( sizeof ( * pIdxCons ) + sizeof ( * pUsage ) ) * nTerm + sizeof ( * pIdxOrderBy ) * nOrderBy ) ; if ( pIdxInfo == 0 ) { sqlite3ErrorMsg ( pParse , "out<S2SV_blank>of<S2SV_blank>memory" ) ; return 0 ; } pIdxCons = ( struct sqlite3_index_constraint * ) & pIdxInfo [ 1 ] ; pIdxOrderBy = ( struct sqlite3_index_orderby * ) & pIdxCons [ nTerm ] ; pUsage = ( struct sqlite3_index_constraint_usage * ) & pIdxOrderBy [ nOrderBy ] ; * ( int * ) & pIdxInfo -> nConstraint = nTerm ; * ( int * ) & pIdxInfo -> nOrderBy = nOrderBy ; * ( struct sqlite3_index_constraint * * ) & pIdxInfo -> aConstraint = pIdxCons ; * ( struct sqlite3_index_orderby * * ) & pIdxInfo -> aOrderBy = pIdxOrderBy ; * ( struct sqlite3_index_constraint_usage * * ) & pIdxInfo -> aConstraintUsage = pUsage ; for ( i = j = 0 , pTerm = pWC -> a ; i < pWC -> nTerm ; i ++ , pTerm ++ ) { u8 op ; if ( pTerm -> leftCursor != pSrc -> iCursor ) continue ; if ( pTerm -> prereqRight & mUnusable ) continue ; assert ( IsPowerOfTwo ( pTerm -> eOperator & ~ WO_EQUIV ) ) ; testcase ( pTerm -> eOperator & WO_IN ) ; testcase ( pTerm -> eOperator & WO_IS ) ; testcase ( pTerm -> eOperator & WO_ISNULL ) ; testcase ( pTerm -> eOperator & WO_ALL ) ; if ( ( pTerm -> eOperator & ~ ( WO_ISNULL | WO_EQUIV | WO_IS ) ) == 0 ) continue ; if ( pTerm -> wtFlags & TERM_VNULL ) continue ; <S2SV_StartBug> pIdxCons [ j ] . iColumn = pTerm -> u . leftColumn ; <S2SV_EndBug> pIdxCons [ j ] . iTermOffset = i ; op = ( u8 ) pTerm -> eOperator & WO_ALL ; if ( op == WO_IN ) op = WO_EQ ; pIdxCons [ j ] . op = op ; assert ( WO_EQ == SQLITE_INDEX_CONSTRAINT_EQ ) ; assert ( WO_LT == SQLITE_INDEX_CONSTRAINT_LT ) ; assert ( WO_LE == SQLITE_INDEX_CONSTRAINT_LE ) ; assert ( WO_GT == SQLITE_INDEX_CONSTRAINT_GT ) ; assert ( WO_GE == SQLITE_INDEX_CONSTRAINT_GE ) ; assert ( WO_MATCH == SQLITE_INDEX_CONSTRAINT_MATCH ) ; assert ( pTerm -> eOperator & ( WO_IN | WO_EQ | WO_LT | WO_LE | WO_GT | WO_GE | WO_MATCH ) ) ; j ++ ; } for ( i = 0 ; i < nOrderBy ; i ++ ) { Expr * pExpr = pOrderBy -> a [ i ] . pExpr ; pIdxOrderBy [ i ] . iColumn = pExpr -> iColumn ; pIdxOrderBy [ i ] . desc = pOrderBy -> a [ i ] . sortOrder ; } return pIdxInfo ; } | <S2SV_ModStart> wtFlags & TERM_VNULL ) continue ; if ( pTerm -> u . leftColumn < ( - 1 ) <S2SV_ModStart> ) continue ; if ( pTerm -> u . leftColumn < ( - 1 ) ) continue ; |
922 | CWE-000 DWORD VmDirGetMdbWalEnable ( BOOLEAN * pbMdbEnableWal ) { DWORD keyValue = 1 ; DWORD dwError = 0 ; * pbMdbEnableWal = TRUE ; PVMDIR_CONFIG_CONNECTION_HANDLE pCfgHandle = NULL ; dwError = VmDirRegConfigHandleOpen ( & pCfgHandle ) ; BAIL_ON_VMDIR_ERROR ( dwError ) ; dwError = VmDirRegConfigGetDword ( pCfgHandle , VMDIR_CONFIG_PARAMETER_PARAMS_KEY_PATH , VMDIR_REG_KEY_MDB_ENABLE_WAL , & keyValue ) ; BAIL_ON_VMDIR_ERROR ( dwError ) ; <S2SV_StartBug> * pbMdbEnableWal = keyValue == 1 ; <S2SV_EndBug> cleanup : if ( pCfgHandle ) { VmDirRegConfigHandleClose ( pCfgHandle ) ; } return dwError ; error : goto cleanup ; } | <S2SV_ModStart> * pbMdbEnableWal = ( keyValue != 0 ) <S2SV_ModEnd> ; cleanup : |
923 | CWE-000 static void * receive_thread ( void * server_arg ) { printf ( "receive_thread<S2SV_blank>started\\n" ) ; struct arg_list * arg = ( struct arg_list * ) server_arg ; socklen_t addrlen = sizeof ( arg -> server_addr ) ; <S2SV_StartBug> int connection_state ; <S2SV_EndBug> int last_packet_sent ; while ( 1 ) { if ( recvfrom ( arg -> socket , buff , sizeof ( buff ) , 0 , ( struct sockaddr * ) & arg -> server_addr , & addrlen ) < 0 ) { printf ( "Send<S2SV_blank>Error:<S2SV_blank>%s<S2SV_blank>(Errno:%d)\\n" , strerror ( errno ) , errno ) ; exit ( 1 ) ; } <S2SV_StartBug> unsigned int seq ; <S2SV_EndBug> unsigned int mode ; unsigned char buff [ 4 ] ; mode = buff [ 0 ] >> 4 ; buff [ 0 ] = buff [ 0 ] & 0x0F ; memcpy ( & seq , buff , 4 ) ; seq = ntohl ( seq ) ; switch ( mode ) { case 1 : printf ( "SYN-ACK<S2SV_blank>recevied\\n" ) ; pthread_mutex_lock ( & info_mutex ) ; global_last_packet_received = 1 ; global_seq += seq ; pthread_mutex_unlock ( & info_mutex ) ; break ; case 3 : printf ( "FIN-ACK<S2SV_blank>recevied\\n" ) ; pthread_mutex_lock ( & info_mutex ) ; global_last_packet_received = 3 ; global_seq += seq ; pthread_mutex_unlock ( & info_mutex ) ; break ; case 4 : printf ( "ACK<S2SV_blank>recevied\\n" ) ; pthread_mutex_lock ( & info_mutex ) ; global_last_packet_received = 4 ; global_seq += seq ; pthread_mutex_unlock ( & info_mutex ) ; break ; default : printf ( "receive<S2SV_blank>switch<S2SV_blank>error\\n" ) ; } pthread_mutex_lock ( & info_mutex ) ; if ( global_last_packet_sent == 0 ) { global_connection_state = 0 ; } else if ( global_last_packet_sent == 4 ) { global_connection_state = 1 ; } else if ( global_last_packet_sent == 5 ) { global_connection_state = 1 ; } else if ( global_last_packet_sent == 2 ) { global_connection_state = 2 ; } else if ( global_last_packet_sent == - 1 ) { global_connection_state = - 1 ; } pthread_mutex_unlock ( & info_mutex ) ; } } | <S2SV_ModStart> server_addr ) ; while ( 1 ) { unsigned int seq ; unsigned int mode ; unsigned char buff [ 4 ] ; <S2SV_ModEnd> if ( recvfrom <S2SV_ModStart> ) ; } <S2SV_ModEnd> mode = buff |
924 | CWE-000 static int single_alu_op3 ( struct r600_shader_ctx * ctx , int op , int dst_sel , int dst_chan , int src0_sel , unsigned src0_chan_val , int src1_sel , unsigned src1_chan_val , int src2_sel , unsigned src2_chan_val ) { struct r600_bytecode_alu alu ; int r ; <S2SV_StartBug> assert ( op == ALU_OP3_MULADD_UINT24 ) ; <S2SV_EndBug> memset ( & alu , 0 , sizeof ( struct r600_bytecode_alu ) ) ; alu . op = op ; alu . src [ 0 ] . sel = src0_sel ; if ( src0_sel == V_SQ_ALU_SRC_LITERAL ) alu . src [ 0 ] . value = src0_chan_val ; else alu . src [ 0 ] . chan = src0_chan_val ; alu . src [ 1 ] . sel = src1_sel ; if ( src1_sel == V_SQ_ALU_SRC_LITERAL ) alu . src [ 1 ] . value = src1_chan_val ; else alu . src [ 1 ] . chan = src1_chan_val ; alu . src [ 2 ] . sel = src2_sel ; if ( src2_sel == V_SQ_ALU_SRC_LITERAL ) alu . src [ 2 ] . value = src2_chan_val ; else alu . src [ 2 ] . chan = src2_chan_val ; alu . dst . sel = dst_sel ; alu . dst . chan = dst_chan ; alu . is_op3 = 1 ; alu . last = 1 ; r = r600_bytecode_add_alu ( ctx -> bc , & alu ) ; if ( r ) return r ; return 0 ; } | <S2SV_ModStart> op == ALU_OP3_MULADD_UINT24 || op == ALU_OP3_CNDE_INT |
925 | CWE-000 static struct dentry * __sdcardfs_lookup ( struct dentry * dentry , unsigned int flags , struct path * lower_parent_path , userid_t id ) { int err = 0 ; struct vfsmount * lower_dir_mnt ; struct dentry * lower_dir_dentry = NULL ; struct dentry * lower_dentry ; const struct qstr * name ; struct path lower_path ; struct qstr dname ; struct dentry * ret_dentry = NULL ; struct sdcardfs_sb_info * sbi ; sbi = SDCARDFS_SB ( dentry -> d_sb ) ; d_set_d_op ( dentry , & sdcardfs_ci_dops ) ; if ( IS_ROOT ( dentry ) ) goto out ; name = & dentry -> d_name ; lower_dir_dentry = lower_parent_path -> dentry ; lower_dir_mnt = lower_parent_path -> mnt ; err = vfs_path_lookup ( lower_dir_dentry , lower_dir_mnt , name -> name , 0 , & lower_path ) ; if ( err == - ENOENT ) { struct file * file ; const struct cred * cred = current_cred ( ) ; struct sdcardfs_name_data buffer = { . ctx . actor = sdcardfs_name_match , . to_find = name , . name = __getname ( ) , . found = false , } ; if ( ! buffer . name ) { err = - ENOMEM ; goto out ; } file = dentry_open ( lower_parent_path , O_RDONLY , cred ) ; if ( IS_ERR ( file ) ) { err = PTR_ERR ( file ) ; goto put_name ; } err = iterate_dir ( file , & buffer . ctx ) ; fput ( file ) ; if ( err ) goto put_name ; if ( buffer . found ) err = vfs_path_lookup ( lower_dir_dentry , lower_dir_mnt , buffer . name , 0 , & lower_path ) ; else err = - ENOENT ; put_name : __putname ( buffer . name ) ; } if ( ! err ) { if ( need_graft_path ( dentry ) ) { err = setup_obb_dentry ( dentry , & lower_path ) ; if ( err ) { <S2SV_StartBug> pr_info ( "sdcardfs:<S2SV_blank>base<S2SV_blank>obbpath<S2SV_blank>is<S2SV_blank>not<S2SV_blank>available\\n" ) ; <S2SV_EndBug> sdcardfs_put_reset_orig_path ( dentry ) ; goto out ; } } sdcardfs_set_lower_path ( dentry , & lower_path ) ; ret_dentry = __sdcardfs_interpose ( dentry , dentry -> d_sb , & lower_path , id ) ; if ( IS_ERR ( ret_dentry ) ) { err = PTR_ERR ( ret_dentry ) ; sdcardfs_put_reset_lower_path ( dentry ) ; } goto out ; } if ( err && err != - ENOENT ) goto out ; dname . name = name -> name ; dname . len = name -> len ; lower_dentry = d_hash_and_lookup ( lower_dir_dentry , & dname ) ; if ( IS_ERR ( lower_dentry ) ) return lower_dentry ; if ( ! lower_dentry ) { err = - ENOENT ; goto out ; } lower_path . dentry = lower_dentry ; lower_path . mnt = mntget ( lower_dir_mnt ) ; sdcardfs_set_lower_path ( dentry , & lower_path ) ; if ( flags & ( LOOKUP_CREATE | LOOKUP_RENAME_TARGET ) ) err = 0 ; out : if ( err ) return ERR_PTR ( err ) ; return ret_dentry ; } | <S2SV_ModStart> err ) { printk ( KERN_INFO <S2SV_ModEnd> "sdcardfs:<S2SV_blank>base<S2SV_blank>obbpath<S2SV_blank>is<S2SV_blank>not<S2SV_blank>available\\n" ) ; |
926 | CWE-000 void RTC_IRQHandler ( void ) { <S2SV_StartBug> RTC_IntClear ( RTC_IFC_COMP0 ) ; <S2SV_EndBug> if ( RTC -> COMP0 == 1023 ) { <S2SV_StartBug> uint32_t microseconds = RETAINED -> rtc . microseconds + 31250 ; <S2SV_EndBug> if ( microseconds >= 1000000 ) { microseconds -= 1000000 ; <S2SV_StartBug> ++ RETAINED -> rtc . seconds ; <S2SV_EndBug> } <S2SV_StartBug> RETAINED -> rtc . microseconds = microseconds ; <S2SV_EndBug> fd_event_set ( FD_EVENT_RTC_TICK ) ; if ( rtc_countdown ) { if ( -- rtc_countdown == 0 ) { fd_event_set ( FD_EVENT_RTC_COUNTDOWN ) ; } } } else { <S2SV_StartBug> RETAINED -> rtc . seconds += 2 ; <S2SV_EndBug> } } | <S2SV_ModStart> RTC_IntClear ( RTC_IFC_COMP0 ) ; fd_hal_reset_retained_t * retained = fd_hal_reset_retained ( <S2SV_ModStart> uint32_t microseconds = retained <S2SV_ModEnd> -> rtc . <S2SV_ModStart> 1000000 ; ++ retained <S2SV_ModEnd> -> rtc . <S2SV_ModStart> seconds ; } retained <S2SV_ModEnd> -> rtc . <S2SV_ModStart> } else { retained <S2SV_ModEnd> -> rtc . |
927 | CWE-000 int sbefifo_submit ( struct device * dev , const __be32 * command , size_t cmd_len , __be32 * response , size_t * resp_len ) { struct sbefifo * sbefifo ; struct iov_iter resp_iter ; struct kvec resp_iov ; size_t rbytes ; int rc ; if ( ! dev ) return - ENODEV ; sbefifo = dev_get_drvdata ( dev ) ; if ( ! sbefifo ) return - ENODEV ; if ( WARN_ON_ONCE ( sbefifo -> magic != SBEFIFO_MAGIC ) ) return - ENODEV ; <S2SV_StartBug> if ( ! resp_len || ! command || ! response || cmd_len > SBEFIFO_MAX_CMD_LEN ) <S2SV_EndBug> return - EINVAL ; rbytes = ( * resp_len ) * sizeof ( __be32 ) ; resp_iov . iov_base = response ; resp_iov . iov_len = rbytes ; iov_iter_kvec ( & resp_iter , WRITE | ITER_KVEC , & resp_iov , 1 , rbytes ) ; mutex_lock ( & sbefifo -> lock ) ; rc = __sbefifo_submit ( sbefifo , command , cmd_len , & resp_iter ) ; mutex_unlock ( & sbefifo -> lock ) ; rbytes -= iov_iter_count ( & resp_iter ) ; * resp_len = rbytes / sizeof ( __be32 ) ; return rc ; } | <S2SV_ModStart> || ! response <S2SV_ModEnd> ) return - |
928 | CWE-000 int add_new_element_to_basis_new ( gb_t * basis , const src_t * row , const spd_t * spd , const ht_t * ht ) { const nelts_t fc = row [ 1 ] ; hash_t hv = ht -> val [ spd -> col -> hpos [ fc ] ] ; if ( hv == 0 ) return 0 ; if ( basis -> hom == 0 && check_new_element_for_redundancy ( spd -> col -> hpos [ fc ] , basis , ht ) != 0 ) { return - 1 ; } # if POLY_DEBUG printf ( "new<S2SV_blank>lm<S2SV_blank>from<S2SV_blank>row<S2SV_blank>(basis<S2SV_blank>element<S2SV_blank>%u):<S2SV_blank>" , basis -> load ) ; for ( int ii = 0 ; ii < ht -> nv ; ++ ii ) printf ( "%u<S2SV_blank>" , ht -> exp [ spd -> col -> hpos [ fc ] ] [ ii ] ) ; printf ( "<S2SV_blank>%u<S2SV_blank><S2SV_blank>(%u)\\n" , ht -> val [ spd -> col -> hpos [ fc ] ] , spd -> col -> hpos [ fc ] ) ; # endif nelts_t i ; if ( basis -> load == basis -> size ) enlarge_basis ( basis , 2 * basis -> size ) ; basis -> nt [ basis -> load ] = ( row [ 0 ] - 1 ) / 2 ; basis -> cf [ basis -> load ] = ( cf_t * ) malloc ( basis -> nt [ basis -> load ] * sizeof ( cf_t ) ) ; basis -> eh [ basis -> load ] = ( hash_t * ) malloc ( basis -> nt [ basis -> load ] * sizeof ( hash_t ) ) ; nelts_t ctr = 0 ; deg_t deg = 0 ; for ( i = 1 ; i < row [ 0 ] ; i += 2 ) { basis -> cf [ basis -> load ] [ ctr ] = row [ i + 1 ] ; basis -> eh [ basis -> load ] [ ctr ] = spd -> col -> hpos [ row [ i ] ] ; # if POLY_DEBUG printf ( "%u|" , basis -> cf [ basis -> load ] [ ctr ] ) ; for ( int ii = 0 ; ii < ht -> nv ; ++ ii ) printf ( "%u" , ht -> exp [ basis -> eh [ basis -> load ] [ ctr ] ] [ ii ] ) ; printf ( "<S2SV_blank><S2SV_blank>" ) ; # endif deg = ht -> deg [ basis -> eh [ basis -> load ] [ ctr ] ] > deg ? ht -> deg [ basis -> eh [ basis -> load ] [ ctr ] ] : deg ; ctr ++ ; } # if POLY_DEBUG printf ( "\\n" ) ; printf ( "deg:<S2SV_blank>%u\\n" , deg ) ; printf ( "#<S2SV_blank>terms<S2SV_blank>=<S2SV_blank>1<S2SV_blank>+<S2SV_blank>%u\\n" , ctr - 1 ) ; # endif <S2SV_StartBug> basis -> nt [ basis -> load ] = ctr ; <S2SV_EndBug> basis -> deg [ basis -> load ] = deg ; basis -> red [ basis -> load ] = 0 ; basis -> cf [ basis -> load ] = realloc ( basis -> cf [ basis -> load ] , basis -> nt [ basis -> load ] * sizeof ( cf_t ) ) ; basis -> eh [ basis -> load ] = realloc ( basis -> eh [ basis -> load ] , basis -> nt [ basis -> load ] * sizeof ( hash_t ) ) ; if ( basis -> sf != NULL ) { basis -> sf [ basis -> load ] . size = 3 ; basis -> sf [ basis -> load ] . load = 0 ; basis -> sf [ basis -> load ] . idx = ( nelts_t * ) malloc ( basis -> sf [ basis -> load ] . size * sizeof ( nelts_t ) ) ; } basis -> load ++ ; <S2SV_StartBug> return 1 ; <S2SV_EndBug> } | <S2SV_ModStart> ; # endif if ( ctr > 0 ) { <S2SV_ModStart> load ++ ; } |
929 | CWE-000 void ttyHandler ( int_registers_t regs ) { uint8_t x , y ; switch ( regs . eax ) { case 0 : ttyPrintChar ( ( ( uint8_t ) ( regs . edx & 0xFF ) ) , ( ( uint8_t ) ( ( regs . edx >> 8 ) & 0xFF ) ) ) ; break ; case 1 : ttyPrintString ( regs . esi , ( ( uint8_t ) ( regs . ebx & 0xFF ) ) ) ; break ; case 2 : ttyWriteChar ( ( ( uint8_t ) ( regs . edx & 0xFF ) ) , ( ( uint8_t ) ( ( regs . edx >> 8 ) & 0xFF ) ) ) ; break ; case 3 : ttyGotoXY ( ( ( uint8_t ) ( regs . edx & 0xFF ) ) , ( ( uint8_t ) ( ( regs . edx >> 8 ) & 0xFF ) ) ) ; break ; case 4 : ttyGetXY ( & x , & y ) ; regs . edx = ( uint32_t ) ( ( y << 8 ) | x ) ; break ; case 5 : switch ( regs . ecx ) { case 0 : ttyPrintHex8 ( ( ( uint8_t ) ( regs . edx & 0xFF ) ) , ( ( uint8_t ) ( regs . ebx & 0xFF ) ) ) ; break ; case 1 : ttyPrintHex16 ( ( ( uint16_t ) ( regs . edx & 0xFFFF ) ) , ( ( uint8_t ) ( regs . ebx & 0xFF ) ) ) ; break ; case 2 : ttyPrintHex32 ( regs . edx , ( ( uint8_t ) ( regs . ebx & 0xFF ) ) ) ; break ; } break ; case 6 : ttyPrintDec ( regs . edx , ( ( uint8_t ) ( regs . ebx & 0xFF ) ) ) ; break ; case 7 : ttyPrintFloat ( ( ( float ) regs . edx ) , ( ( uint8_t ) ( regs . ebx & 0xFF ) ) , regs . ecx ) ; break ; case 8 : ttyPrintSci ( ( ( float ) regs . edx ) , ( ( uint8_t ) ( regs . ebx & 0xFF ) ) , regs . ecx ) ; break ; case 9 : ttyScrollUp ( ( uint8_t ) regs . ecx ) ; break ; case 10 : ttyClear ( ) ; break ; case 11 : <S2SV_StartBug> ttyPrintSignedDec ( regs . edx , ( ( uint8_t ) ( regs . ebx & 0xFF ) ) ) ; <S2SV_EndBug> break ; } } | <S2SV_ModStart> : ttyPrintSignedDec ( ( int32_t ) |
930 | CWE-000 int image_IFFT ( HBMP_i_t * src , FFT_STRUCT * fft_dst ) { double tmp ; uint32_t i , j ; uint32_t ifft_width = 1 , ifft_height = 1 ; uint32_t width_iteration = 0 , height_iteration = 0 ; COMPLEX_NUMBER * time_image ; COMPLEX_NUMBER * freq_image ; while ( ifft_width * 2 <= src -> width ) { ifft_width *= 2 ; width_iteration ++ ; } while ( ifft_height * 2 <= src -> width ) { ifft_height *= 2 ; height_iteration ++ ; } show_para ( width_iteration ) ; time_image = ( COMPLEX_NUMBER * ) malloc ( sizeof ( COMPLEX_NUMBER ) * ifft_width * ifft_height ) ; freq_image = ( COMPLEX_NUMBER * ) malloc ( sizeof ( COMPLEX_NUMBER ) * ifft_width * ifft_height ) ; <S2SV_StartBug> memcpy ( freq_image , fft_dst -> freq_image , sizeof ( COMPLEX_NUMBER ) * ifft_width * ifft_width ) ; <S2SV_EndBug> show_para ( freq_image [ 512 ] . real ) ; for ( i = 0 ; i < ifft_height ; i ++ ) { IFFT ( time_image + ifft_width * i , fft_dst -> freq_image + ifft_width * i , width_iteration ) ; } for ( i = 0 ; i < ifft_height ; i ++ ) { for ( j = 0 ; j < ifft_width ; j ++ ) { freq_image [ i + ifft_height * j ] . real = time_image [ j + i * ifft_width ] . real ; freq_image [ i + ifft_height * j ] . imaginary = time_image [ j + i * ifft_width ] . imaginary ; } } for ( i = 0 ; i < ifft_width ; i ++ ) { IFFT ( time_image + ifft_height * i , fft_dst -> freq_image + ifft_height * i , height_iteration ) ; } double max = 0 , min = 0xffffffff ; for ( i = 0 ; i < src -> height ; i ++ ) { for ( j = 0 ; j < src -> width ; j ++ ) { tmp = ( double ) sqrt ( time_image [ j * ifft_height + i ] . real * time_image [ j * ifft_height + i ] . real + time_image [ j * ifft_height + i ] . imaginary * time_image [ j * ifft_height + i ] . imaginary ) ; max = MAX ( max , tmp ) ; min = MIN ( min , tmp ) ; } } <S2SV_StartBug> printf ( "max<S2SV_blank>=<S2SV_blank>%lf" , max ) ; <S2SV_EndBug> printf ( "min<S2SV_blank>=<S2SV_blank>%lf" , min ) ; for ( i = 0 ; i < src -> height ; i ++ ) { for ( j = 0 ; j < src -> width ; j ++ ) { tmp = ( double ) sqrt ( time_image [ j * ifft_height + i ] . real * time_image [ j * ifft_height + i ] . real + <S2SV_StartBug> time_image [ j * ifft_height + i ] . imaginary * time_image [ j * ifft_height + i ] . imaginary ) * 100 ; <S2SV_EndBug> tmp = ( tmp - min ) / ( max - min ) * 255 ; <S2SV_StartBug> printf ( "min<S2SV_blank>=<S2SV_blank>%lf\\n" , tmp ) ; <S2SV_EndBug> src -> yuv_buffer . y_buffer . buffer [ j + src -> width * i ] = ( uint8_t ) tmp ; } } return EPDK_OK ; } | <S2SV_ModStart> * ifft_width * ifft_height <S2SV_ModEnd> ) ; show_para <S2SV_ModStart> ; } } <S2SV_ModEnd> for ( i <S2SV_ModStart> . imaginary ) <S2SV_ModEnd> ; tmp = <S2SV_ModStart> * 255 ; <S2SV_ModEnd> src -> yuv_buffer |
931 | CWE-000 static int do_sched_rt_period_timer ( struct rt_bandwidth * rt_b , int overrun ) { int i , idle = 1 , throttled = 0 ; const struct cpumask * span ; span = sched_rt_period_mask ( ) ; <S2SV_StartBug> for_each_cpu ( i , span ) { <S2SV_EndBug> int enqueue = 0 ; struct rt_rq * rt_rq = sched_rt_period_rt_rq ( rt_b , i ) ; struct rq * rq = rq_of_rt_rq ( rt_rq ) ; raw_spin_lock ( & rq -> lock ) ; if ( rt_rq -> rt_time ) { u64 runtime ; raw_spin_lock ( & rt_rq -> rt_runtime_lock ) ; if ( rt_rq -> rt_throttled ) balance_runtime ( rt_rq ) ; runtime = rt_rq -> rt_runtime ; rt_rq -> rt_time -= min ( rt_rq -> rt_time , overrun * runtime ) ; if ( rt_rq -> rt_throttled && rt_rq -> rt_time < runtime ) { rt_rq -> rt_throttled = 0 ; enqueue = 1 ; if ( rt_rq -> rt_nr_running && rq -> curr == rq -> idle ) rq -> skip_clock_update = - 1 ; } if ( rt_rq -> rt_time || rt_rq -> rt_nr_running ) idle = 0 ; raw_spin_unlock ( & rt_rq -> rt_runtime_lock ) ; } else if ( rt_rq -> rt_nr_running ) { idle = 0 ; if ( ! rt_rq_throttled ( rt_rq ) ) enqueue = 1 ; } if ( rt_rq -> rt_throttled ) throttled = 1 ; if ( enqueue ) sched_rt_rq_enqueue ( rt_rq ) ; raw_spin_unlock ( & rq -> lock ) ; } if ( ! throttled && ( ! rt_bandwidth_enabled ( ) || rt_b -> rt_runtime == RUNTIME_INF ) ) return 1 ; return idle ; } | <S2SV_ModStart> ( ) ; # ifdef CONFIG_RT_GROUP_SCHED if ( rt_b == & root_task_group . rt_bandwidth ) span = cpu_online_mask ; # endif |
932 | CWE-000 void read_print_text ( FILE * file , u_int32_t strLen ) { char * data = malloc ( strLen + 1 ) ; if ( fread ( data , strLen , 1 , file ) != 1 ) <S2SV_StartBug> handle_error ( "Error:<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>read<S2SV_blank>text\\n" ) ; <S2SV_EndBug> data [ strLen ] = 0 ; printf ( "%s\\n" , data ) ; free ( data ) ; } | <S2SV_ModStart> ) handle_error ( "unable<S2SV_blank>to<S2SV_blank>read<S2SV_blank>text" <S2SV_ModEnd> ) ; data |
933 | CWE-000 int insert ( dir * d , int n ) { int hash = extract_bits ( hash_function ( n ) , d -> global_depth ) , i ; bucket * dst = d -> buckets [ hash ] ; if ( dst -> count != bucket_size ) { dst -> list [ dst -> count ++ ] = n ; return hash ; } else { if ( dst -> local_depth == d -> global_depth ) { double_dir ( d , hash ) ; return insert ( d , n ) ; } else { int new_id = extract_bits ( hash , dst -> local_depth ) + pow_2 ( dst -> local_depth ) ; <S2SV_StartBug> bucket * new = create_bucket ( dst -> local_depth + 1 ) ; <S2SV_EndBug> d -> buckets [ new_id ] = new ; <S2SV_StartBug> if ( new_id + pow_2 ( new -> local_depth ) < pow_2 ( d -> global_depth ) ) <S2SV_EndBug> d -> buckets [ new_id + pow_2 ( new -> local_depth ) ] = new ; int t = extract_bits ( hash , dst -> local_depth ) + pow_2 ( dst -> local_depth ) ; dst -> local_depth ++ ; int copy [ bucket_size ] ; memcpy ( copy , dst -> list , bucket_size * ( sizeof ( int ) ) ) ; dst -> count = 0 ; for ( i = 0 ; i < bucket_size ; i ++ ) insert ( d , copy [ i ] ) ; return insert ( d , n ) ; } } } | <S2SV_ModStart> local_depth ) ; int i = new_id ; <S2SV_ModStart> = new ; for ( ; i < pow_2 ( d -> global_depth ) ; i ++ ) if ( extract_bits ( i , new -> local_depth ) == new_id ) d -> buckets [ i ] = new ; int t = extract_bits ( hash , dst -> local_depth ) <S2SV_ModEnd> + pow_2 ( <S2SV_ModStart> + pow_2 ( <S2SV_ModEnd> dst -> local_depth |
934 | CWE-000 _public_ int sd_bus_query_sender_creds ( sd_bus_message * call , uint64_t mask , sd_bus_creds * * creds ) { sd_bus_creds * c ; assert_return ( call , - EINVAL ) ; assert_return ( call -> sealed , - EPERM ) ; assert_return ( call -> bus , - EINVAL ) ; assert_return ( ! bus_pid_changed ( call -> bus ) , - ECHILD ) ; if ( ! BUS_IS_OPEN ( call -> bus -> state ) ) return - ENOTCONN ; c = sd_bus_message_get_creds ( call ) ; if ( c && ( mask & ~ c -> mask ) == 0 ) { * creds = sd_bus_creds_ref ( c ) ; return 0 ; } if ( ! c || ! ( c -> mask & SD_BUS_CREDS_PID ) ) { if ( call -> sender ) return sd_bus_get_name_creds ( call -> bus , call -> sender , mask , creds ) ; else return sd_bus_get_owner_creds ( call -> bus , mask , creds ) ; } <S2SV_StartBug> return bus_creds_extend_by_pid ( c , mask , creds ) ; <S2SV_EndBug> } | <S2SV_ModStart> ) ; } log_debug_elogind ( "Called<S2SV_blank>by<S2SV_blank>UID<S2SV_blank>%u<S2SV_blank>;<S2SV_blank>%s<S2SV_blank>[%s]<S2SV_blank>(%s)" , c -> uid , c -> unique_name ? c -> unique_name : "no<S2SV_blank>name" , c -> label ? c -> label : "no<S2SV_blank>label" , c -> description ? c -> description : "no<S2SV_blank>desc" ) ; |
935 | CWE-000 static int copy_reserved_ports_to_user ( struct task_struct * tsk , int __user * ports , int maxn ) { int num_copied = 0 ; struct task_reserved_port_pair * p ; spin_lock ( & tsk -> port_lock ) ; if ( ! list_empty ( & tsk -> task_reserved_ports ) ) { list_for_each_entry ( p , & tsk -> task_reserved_ports , list ) { int pair [ 2 ] = { p -> low , p -> high } ; spin_unlock ( & tsk -> port_lock ) ; <S2SV_StartBug> printk ( KERN_INFO "<S2SV_blank>found<S2SV_blank>reserved<S2SV_blank>port<S2SV_blank>%d,<S2SV_blank>%d\\n" , pair [ 0 ] , pair [ 1 ] ) ; <S2SV_EndBug> if ( num_copied > maxn - 2 ) { goto out_unlocked ; } if ( copy_to_user ( ports + num_copied , pair , sizeof ( int ) * 2 ) ) { num_copied = - EFAULT ; goto out_unlocked ; } num_copied += 2 ; spin_lock ( & tsk -> port_lock ) ; } } spin_unlock ( & tsk -> port_lock ) ; out_unlocked : return num_copied ; } | <S2SV_ModStart> port_lock ) ; <S2SV_ModEnd> if ( num_copied |
936 | CWE-000 void readCluster ( uint32_t cluster , uint16_t block , uint8_t * buffer ) { uint32_t bAddr = fatInformation . prologBlocks + fatInformation . partitionStart + fatInformation . blocksPerFAT * fatInformation . numFATs + <S2SV_StartBug> cluster * fatInformation . blocksPerCluster + block ; <S2SV_EndBug> readVolumeBlock ( & currVolume , buffer , bAddr ) ; } | <S2SV_ModStart> . numFATs + ( cluster - 2 ) <S2SV_ModEnd> * fatInformation . |
937 | CWE-000 static int do_save_state_blob ( int fd , bool is_chardev , const char * blobtype , const char * filename , size_t buffersize ) { int file_fd ; ptm_res res ; ptm_getstate pgs ; uint16_t offset ; ssize_t numbytes ; bool had_error ; int n ; uint32_t bt ; unsigned char * buffer = NULL ; bt = get_blobtype ( blobtype ) ; if ( ! bt ) { fprintf ( stderr , "Unknown<S2SV_blank>TPM<S2SV_blank>state<S2SV_blank>type<S2SV_blank>\'%s\'" , blobtype ) ; return 1 ; } file_fd = open ( filename , O_WRONLY | O_CREAT | O_TRUNC , S_IRUSR | S_IWUSR ) ; if ( file_fd < 0 ) { fprintf ( stderr , "Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>file<S2SV_blank>\'%s\'<S2SV_blank>for<S2SV_blank>writing:<S2SV_blank>%s\\n" , filename , strerror ( errno ) ) ; return 1 ; } had_error = false ; offset = 0 ; while ( true ) { pgs . u . req . state_flags = htodev32 ( is_chardev , PTM_STATE_FLAG_DECRYPTED ) ; pgs . u . req . type = htodev32 ( is_chardev , bt ) ; pgs . u . req . offset = htodev32 ( is_chardev , offset ) ; n = ctrlcmd ( fd , PTM_GET_STATEBLOB , & pgs , sizeof ( pgs . u . req ) , sizeof ( pgs ) ) ; if ( n < 0 ) { fprintf ( stderr , "Could<S2SV_blank>not<S2SV_blank>execute<S2SV_blank>ioctl<S2SV_blank>PTM_GET_STATEBLOB:<S2SV_blank>" "%s\\n" , strerror ( errno ) ) ; had_error = true ; break ; } res = devtoh32 ( is_chardev , pgs . u . resp . tpm_result ) ; if ( res != 0 && ( res & TPM_NON_FATAL ) == 0 ) { fprintf ( stderr , "TPM<S2SV_blank>result<S2SV_blank>from<S2SV_blank>PTM_GET_STATEBLOB:<S2SV_blank>0x%x\\n" , res ) ; had_error = true ; break ; } numbytes = write ( file_fd , pgs . u . resp . data , devtoh32 ( is_chardev , pgs . u . resp . length ) ) ; <S2SV_StartBug> if ( numbytes != devtoh32 ( is_chardev , pgs . u . resp . length ) ) { <S2SV_EndBug> fprintf ( stderr , "Could<S2SV_blank>not<S2SV_blank>write<S2SV_blank>to<S2SV_blank>file<S2SV_blank>\'%s\':<S2SV_blank>%s\\n" , filename , strerror ( errno ) ) ; had_error = true ; break ; } if ( offset + devtoh32 ( is_chardev , pgs . u . resp . length ) >= devtoh32 ( is_chardev , pgs . u . resp . totlength ) ) break ; if ( buffersize ) { buffer = malloc ( buffersize ) ; if ( ! buffer ) { fprintf ( stderr , "Could<S2SV_blank>not<S2SV_blank>allocate<S2SV_blank>buffer<S2SV_blank>with<S2SV_blank>%zu<S2SV_blank>bytes." , buffersize ) ; had_error = true ; break ; } while ( true ) { n = read ( fd , buffer , buffersize ) ; if ( n < 0 ) { fprintf ( stderr , "Could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>from<S2SV_blank>TPM:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; had_error = true ; break ; } numbytes = write ( file_fd , buffer , n ) ; if ( numbytes < 0 ) { fprintf ( stderr , "Could<S2SV_blank>not<S2SV_blank>write<S2SV_blank>to<S2SV_blank>file<S2SV_blank>\'%s\':<S2SV_blank>%s\\n" , filename , strerror ( errno ) ) ; had_error = true ; break ; } if ( ( size_t ) n < buffersize ) break ; } break ; } else { offset += devtoh32 ( is_chardev , pgs . u . resp . length ) ; } } close ( file_fd ) ; free ( buffer ) ; if ( had_error ) return 1 ; return 0 ; } | <S2SV_ModStart> ; if ( ( uint32_t ) |
938 | CWE-000 <S2SV_StartBug> static void print_ls ( t_config * config , t_packet * packet ) <S2SV_EndBug> { int ret ; <S2SV_StartBug> if ( ft_putstr ( ( char * ) packet ) > HEADER_SIZE - 1 ) <S2SV_EndBug> { while ( ( ret = read ( config -> socket . cmd , config -> buf , MAX_PACKET_SIZE - 1 ) ) > 0 ) { config -> buf [ ret ] = 0 ; ft_putstr ( config -> buf ) ; if ( ret < MAX_PACKET_SIZE - 1 ) break ; } } } | <S2SV_ModStart> t_packet * packet , int ret ) { ( ( char * ) packet ) [ ret ] = 0 ; int r = <S2SV_ModEnd> ft_putstr ( ( <S2SV_ModStart> ) packet ) ; if ( r >= <S2SV_ModEnd> HEADER_SIZE - 1 <S2SV_ModStart> HEADER_SIZE - 1 && ( ( char * ) packet ) [ r - 1 ] > 10 |
939 | CWE-000 static void enqueue_entity ( struct cfs_rq * cfs_rq , struct sched_entity * se , int flags ) { <S2SV_StartBug> if ( ! ( flags & ENQUEUE_WAKEUP ) || ( flags & ENQUEUE_WAKING ) ) <S2SV_EndBug> se -> vruntime += cfs_rq -> min_vruntime ; update_curr ( cfs_rq ) ; <S2SV_StartBug> enqueue_entity_load_avg ( cfs_rq , se ) ; <S2SV_EndBug> account_entity_enqueue ( cfs_rq , se ) ; update_cfs_shares ( cfs_rq ) ; if ( flags & ENQUEUE_WAKEUP ) { place_entity ( cfs_rq , se , 0 ) ; if ( schedstat_enabled ( ) ) enqueue_sleeper ( cfs_rq , se ) ; } check_schedstat_required ( ) ; if ( schedstat_enabled ( ) ) { update_stats_enqueue ( cfs_rq , se ) ; check_spread ( cfs_rq , se ) ; } <S2SV_StartBug> if ( se != cfs_rq -> curr ) <S2SV_EndBug> __enqueue_entity ( cfs_rq , se ) ; se -> on_rq = 1 ; if ( cfs_rq -> nr_running == 1 ) { list_add_leaf_cfs_rq ( cfs_rq ) ; check_enqueue_throttle ( cfs_rq ) ; } } | <S2SV_ModStart> flags ) { bool renorm = <S2SV_ModEnd> ! ( flags <S2SV_ModStart> & ENQUEUE_WAKING ) ; bool curr = cfs_rq -> curr == se ; if ( renorm && curr <S2SV_ModStart> cfs_rq ) ; if ( renorm && ! curr ) se -> vruntime += cfs_rq -> min_vruntime ; <S2SV_ModStart> } if ( ! <S2SV_ModEnd> curr ) __enqueue_entity |
940 | CWE-000 void esp_aes_encrypt ( esp_aes_context * ctx , const unsigned char input [ 16 ] , unsigned char output [ 16 ] ) { esp_aes_acquire_hardware ( ) ; esp_aes_setkey_hardware ( ctx , ESP_AES_ENCRYPT ) ; <S2SV_StartBug> ets_aes_crypt ( input , output ) ; <S2SV_EndBug> esp_aes_release_hardware ( ) ; } | <S2SV_ModStart> ESP_AES_ENCRYPT ) ; esp_aes_block <S2SV_ModEnd> ( input , |
941 | CWE-000 static sint16_t ICACHE_FLASH_ATTR parse_msg ( struct dhcps_msg * m , u16_t len ) { if ( memcmp ( ( char * ) m -> options , & magic_cookie , sizeof ( magic_cookie ) ) == 0 ) { # if DHCPS_DEBUG printf ( "dhcps:<S2SV_blank>len<S2SV_blank>=<S2SV_blank>%d\\n" , len ) ; # endif ip_addr_t addr_tmp ; struct dhcps_pool * pdhcps_pool = NULL ; list_node * pnode = NULL ; list_node * pback_node = NULL ; ip_addr_t first_address ; bool flag = false ; first_address . u_addr . ip4 . addr = dhcps_lease . start_ip . u_addr . ip4 . addr ; client_address . u_addr . ip4 . addr = client_address_plus . u_addr . ip4 . addr ; renew = false ; for ( pback_node = plist ; pback_node != NULL ; pback_node = pback_node -> pnext ) { pdhcps_pool = pback_node -> pnode ; if ( memcmp ( pdhcps_pool -> mac , m -> chaddr , sizeof ( pdhcps_pool -> mac ) ) == 0 ) { if ( memcmp ( & pdhcps_pool -> ip . u_addr . ip4 . addr , m -> ciaddr , sizeof ( pdhcps_pool -> ip . u_addr . ip4 . addr ) ) == 0 ) { renew = true ; } client_address . u_addr . ip4 . addr = pdhcps_pool -> ip . u_addr . ip4 . addr ; pdhcps_pool -> lease_timer = DHCPS_LEASE_TIMER ; pnode = pback_node ; goto POOL_CHECK ; } else if ( pdhcps_pool -> ip . u_addr . ip4 . addr == client_address_plus . u_addr . ip4 . addr ) { addr_tmp . u_addr . ip4 . addr = htonl ( client_address_plus . u_addr . ip4 . addr ) ; addr_tmp . u_addr . ip4 . addr ++ ; client_address_plus . u_addr . ip4 . addr = htonl ( addr_tmp . u_addr . ip4 . addr ) ; client_address . u_addr . ip4 . addr = client_address_plus . u_addr . ip4 . addr ; } if ( flag == false ) { if ( first_address . u_addr . ip4 . addr < pdhcps_pool -> ip . u_addr . ip4 . addr ) { flag = true ; } else { addr_tmp . u_addr . ip4 . addr = htonl ( first_address . u_addr . ip4 . addr ) ; addr_tmp . u_addr . ip4 . addr ++ ; first_address . u_addr . ip4 . addr = htonl ( addr_tmp . u_addr . ip4 . addr ) ; } } } if ( client_address_plus . u_addr . ip4 . addr > dhcps_lease . end_ip . u_addr . ip4 . addr ) { client_address . u_addr . ip4 . addr = first_address . u_addr . ip4 . addr ; } if ( client_address . u_addr . ip4 . addr > dhcps_lease . end_ip . u_addr . ip4 . addr ) { client_address_plus . u_addr . ip4 . addr = dhcps_lease . start_ip . u_addr . ip4 . addr ; pdhcps_pool = NULL ; pnode = NULL ; } else { pdhcps_pool = ( struct dhcps_pool * ) malloc ( sizeof ( struct dhcps_pool ) ) ; pdhcps_pool -> ip . u_addr . ip4 . addr = client_address . u_addr . ip4 . addr ; memcpy ( pdhcps_pool -> mac , m -> chaddr , sizeof ( pdhcps_pool -> mac ) ) ; pdhcps_pool -> lease_timer = DHCPS_LEASE_TIMER ; pnode = ( list_node * ) malloc ( sizeof ( list_node ) ) ; pnode -> pnode = pdhcps_pool ; pnode -> pnext = NULL ; node_insert_to_list ( & plist , pnode ) ; if ( client_address . u_addr . ip4 . addr == dhcps_lease . end_ip . u_addr . ip4 . addr ) { client_address_plus . u_addr . ip4 . addr = dhcps_lease . start_ip . u_addr . ip4 . addr ; } else { addr_tmp . u_addr . ip4 . addr = htonl ( client_address . u_addr . ip4 . addr ) ; addr_tmp . u_addr . ip4 . addr ++ ; client_address_plus . u_addr . ip4 . addr = htonl ( addr_tmp . u_addr . ip4 . addr ) ; } } POOL_CHECK : if ( ( client_address . u_addr . ip4 . addr > dhcps_lease . end_ip . u_addr . ip4 . addr ) || ( ip_addr_isany ( & client_address ) ) ) { printf ( "client_address_plus.addr<S2SV_blank>%x\\n" , client_address_plus . u_addr . ip4 . addr ) ; if ( pnode != NULL ) { <S2SV_StartBug> node_remove_from_list ( & plist , pnode ) ; <S2SV_EndBug> free ( pnode ) ; pnode = NULL ; } if ( pdhcps_pool != NULL ) { free ( pdhcps_pool ) ; pdhcps_pool = NULL ; } return 4 ; } sint16_t ret = parse_options ( & m -> options [ 4 ] , len ) ; ; if ( ret == DHCPS_STATE_RELEASE ) { if ( pnode != NULL ) { <S2SV_StartBug> node_remove_from_list ( & plist , pnode ) ; <S2SV_EndBug> free ( pnode ) ; pnode = NULL ; } if ( pdhcps_pool != NULL ) { free ( pdhcps_pool ) ; pdhcps_pool = NULL ; } memset ( & client_address , 0x0 , sizeof ( client_address ) ) ; } if ( wifi_softap_set_station_info ( m -> chaddr , & client_address ) == false ) { return 0 ; } # if DHCPS_DEBUG printf ( "dhcps:<S2SV_blank>xid<S2SV_blank>changed\\n" ) ; printf ( "dhcps:<S2SV_blank>client_address.addr<S2SV_blank>=<S2SV_blank>%x\\n" , client_address . addr ) ; # endif return ret ; } return 0 ; } | <S2SV_ModStart> NULL ) { node_remove_from_list_0 <S2SV_ModEnd> ( & plist <S2SV_ModStart> NULL ) { node_remove_from_list_0 <S2SV_ModEnd> ( & plist |
942 | CWE-000 NTSTATUS AmtPtpDeviceSpiKmCreateDevice ( _Inout_ PWDFDEVICE_INIT DeviceInit ) { WDF_OBJECT_ATTRIBUTES DeviceAttributes ; PDEVICE_CONTEXT pDeviceContext ; WDFDEVICE Device ; NTSTATUS Status ; WDF_PNPPOWER_EVENT_CALLBACKS pnpPowerCallbacks ; PAGED_CODE ( ) ; TraceEvents ( TRACE_LEVEL_INFORMATION , TRACE_DRIVER , "%!FUNC!<S2SV_blank>Entry" ) ; KdPrintEx ( ( DPFLTR_IHVDRIVER_ID , DPFLTR_INFO_LEVEL , "AmtPtpDeviceSpiKmCreateDevice<S2SV_blank>Entry<S2SV_blank>\\n" ) ) ; WDF_PNPPOWER_EVENT_CALLBACKS_INIT ( & pnpPowerCallbacks ) ; pnpPowerCallbacks . EvtDevicePrepareHardware = AmtPtpEvtDevicePrepareHardware ; pnpPowerCallbacks . EvtDeviceD0Entry = AmtPtpEvtDeviceD0Entry ; pnpPowerCallbacks . EvtDeviceD0Exit = AmtPtpEvtDeviceD0Exit ; WdfDeviceInitSetPnpPowerEventCallbacks ( DeviceInit , & pnpPowerCallbacks ) ; WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE ( & DeviceAttributes , DEVICE_CONTEXT ) ; Status = WdfDeviceCreate ( & DeviceInit , & DeviceAttributes , & Device ) ; if ( NT_SUCCESS ( Status ) ) { pDeviceContext = DeviceGetContext ( Device ) ; pDeviceContext -> SpiDevice = Device ; pDeviceContext -> DelayedRequest = FALSE ; pDeviceContext -> SpiTrackpadIoTarget = WdfDeviceGetIoTarget ( Device ) ; if ( pDeviceContext -> SpiTrackpadIoTarget == NULL ) { Status = STATUS_INVALID_DEVICE_STATE ; goto exit ; } KeInitializeEvent ( & pDeviceContext -> PtpRequestRoutineEvent , NotificationEvent , TRUE ) ; KeInitializeEvent ( & pDeviceContext -> PtpLoopRoutineEvent , NotificationEvent , TRUE ) ; Status = WdfMemoryCreate ( WDF_NO_OBJECT_ATTRIBUTES , NonPagedPool , PTP_POOL_TAG , REPORT_BUFFER_SIZE , & pDeviceContext -> SpiHidReadBuffer , NULL ) ; if ( ! NT_SUCCESS ( Status ) ) { goto exit ; } Status = WdfDeviceCreateDeviceInterface ( Device , & GUID_DEVINTERFACE_AmtPtpDeviceSpiKm , NULL ) ; if ( NT_SUCCESS ( Status ) ) { Status = AmtPtpDeviceSpiKmQueueInitialize ( Device ) ; } } exit : <S2SV_StartBug> KdPrintEx ( ( DPFLTR_IHVDRIVER_ID , DPFLTR_INFO_LEVEL , "AmtPtpDeviceSpiKmCreateDevice<S2SV_blank>Exit<S2SV_blank>\\n" ) ) ; <S2SV_EndBug> TraceEvents ( TRACE_LEVEL_INFORMATION , TRACE_DRIVER , "%!FUNC!<S2SV_blank>Exit,<S2SV_blank>Status<S2SV_blank>=<S2SV_blank>%!STATUS!" , Status ) ; return Status ; } | <S2SV_ModStart> , DPFLTR_INFO_LEVEL , "AmtPtpDeviceSpiKmCreateDevice<S2SV_blank>Exit,<S2SV_blank>Status<S2SV_blank>=<S2SV_blank>0x%x<S2SV_blank>\\n" , Status <S2SV_ModEnd> ) ) ; |
943 | CWE-000 static int wrr_min_index ( ) { int min_index = 0 ; int i ; double min = wrr . tunval [ 0 ] ; for ( i = 0 ; i < wrr . len ; i ++ ) { if ( wrr . tunnel [ i ] -> quota == 0 || wrr . tunnel [ i ] -> permitted > 0 ) { <S2SV_StartBug> if ( wrr . tunnel [ i ] -> srtt_raw < ( wrr . tunnel [ i ] -> srtt_target * 2 ) ) { <S2SV_EndBug> if ( wrr . tunval [ i ] < min ) { min = wrr . tunval [ i ] ; min_index = i ; } } else { <S2SV_StartBug> if ( ( wrr . tunnel [ min_index ] -> srtt_raw > ( wrr . tunnel [ min_index ] -> srtt_target * 2 ) ) && <S2SV_EndBug> ( wrr . tunnel [ i ] -> srtt_raw < wrr . tunnel [ min_index ] -> srtt_raw ) ) { min = wrr . tunval [ i ] ; min_index = i ; } } } } return min_index ; } | <S2SV_ModStart> -> srtt_target * 1.5 <S2SV_ModEnd> ) ) { <S2SV_ModStart> -> srtt_target * 1.5 <S2SV_ModEnd> ) ) && |
944 | CWE-000 int abd_cmp ( abd_t * dabd , abd_t * sabd , size_t size ) { ASSERT3P ( sabd , != , NULL ) ; ASSERT3P ( dabd , != , NULL ) ; ASSERT3P ( sabd , != , dabd ) ; <S2SV_StartBug> ASSERT3S ( sabd -> abd_size , == , size ) ; <S2SV_EndBug> <S2SV_StartBug> ASSERT3S ( dabd -> abd_size , == , size ) ; <S2SV_EndBug> return ( abd_iterate_func2 ( dabd , sabd , 0 , 0 , size , abd_cmp_cb , NULL ) ) ; } | <S2SV_ModStart> ; ASSERT3S ( ( size_t ) <S2SV_ModStart> ; ASSERT3S ( ( size_t ) |
945 | CWE-000 void doSomething ( char * str ) { char buffer [ BUFFER_LEN ] ; char str2 [ BUFFER_LEN ] ; strcpy ( str2 , str ) ; char path [ BUFFER_LEN ] ; char * p = NULL ; char * name = NULL ; int fd ; pid_t pid = fork ( ) ; if ( pid == 0 ) { if ( strcmp ( str , "" ) ) { int type = needRedirect ( str ) ; switch ( type ) { case RE_NO : strcpy ( buffer , str ) ; p = strtok ( buffer , "<S2SV_blank>" ) ; if ( p ) { if ( ! strcmp ( p , "cd" ) ) { p = strtok ( NULL , "" ) ; if ( chdir ( p ) < 0 ) printf ( "no<S2SV_blank>such<S2SV_blank>directory\\n" ) ; } else if ( ! strcmp ( p , "pwd" ) ) { getcwd ( path , BUFFER_LEN ) ; printf ( "%s\\n" , path ) ; } else if ( ! strcmp ( p , "exit" ) ) { exit ( 0 ) ; } else { mysys ( str ) ; } } break ; case RE_ALL : case RE_OUT : name = dealReOutStr ( str2 ) ; if ( name ) { fd = open ( name , O_CREAT | O_RDWR , 0666 ) ; dup2 ( fd , 1 ) ; close ( fd ) ; doSomething ( str2 ) ; } break ; case RE_IN : name = dealReInStr ( str2 ) ; if ( name ) { <S2SV_StartBug> pid = fork ( ) ; <S2SV_EndBug> fd = open ( name , O_CREAT | O_RDWR , 0666 ) ; dup2 ( fd , 0 ) ; close ( fd ) ; doSomething ( str2 ) ; } break ; } } exit ( 0 ) ; } else { waitpid ( pid , NULL , 0 ) ; } } | <S2SV_ModStart> name ) { <S2SV_ModEnd> fd = open |
946 | CWE-000 int32_t mz_stream_posix_open ( void * stream , const char * path , int mode ) { mz_stream_posix * posix = ( mz_stream_posix * ) stream ; const char * mode_fopen = NULL ; if ( path == NULL ) return MZ_STREAM_ERROR ; if ( ( mode & MZ_STREAM_MODE_READWRITE ) == MZ_STREAM_MODE_READ ) mode_fopen = "rb" ; else if ( mode & MZ_STREAM_MODE_APPEND ) mode_fopen = "ab" ; else if ( mode & MZ_STREAM_MODE_CREATE ) mode_fopen = "wb" ; else return MZ_STREAM_ERROR ; posix -> handle = fopen64 ( path , mode_fopen ) ; <S2SV_StartBug> strncpy ( ( char * ) posix -> path , path , posix -> path_size ) ; <S2SV_EndBug> return MZ_OK ; } | <S2SV_ModStart> mode_fopen ) ; <S2SV_ModEnd> return MZ_OK ; |
947 | CWE-000 int aesni_mb_set_session_parameters ( const struct aesni_mb_op_fns * mb_ops , struct aesni_mb_session * sess , const struct rte_crypto_sym_xform * xform ) { const struct rte_crypto_sym_xform * auth_xform = NULL ; <S2SV_StartBug> const struct rte_crypto_sym_xform * cipher_xform = NULL ; <S2SV_EndBug> switch ( aesni_mb_get_chain_order ( xform ) ) { case AESNI_MB_OP_HASH_CIPHER : sess -> chain_order = HASH_CIPHER ; auth_xform = xform ; cipher_xform = xform -> next ; break ; case AESNI_MB_OP_CIPHER_HASH : sess -> chain_order = CIPHER_HASH ; auth_xform = xform -> next ; cipher_xform = xform ; break ; case AESNI_MB_OP_HASH_ONLY : sess -> chain_order = HASH_CIPHER ; auth_xform = xform ; cipher_xform = NULL ; break ; case AESNI_MB_OP_CIPHER_ONLY : if ( xform -> cipher . op == RTE_CRYPTO_CIPHER_OP_ENCRYPT ) sess -> chain_order = CIPHER_HASH ; else sess -> chain_order = HASH_CIPHER ; auth_xform = NULL ; cipher_xform = xform ; break ; case AESNI_MB_OP_NOT_SUPPORTED : default : MB_LOG_ERR ( "Unsupported<S2SV_blank>operation<S2SV_blank>chain<S2SV_blank>order<S2SV_blank>parameter" ) ; <S2SV_StartBug> return - 1 ; <S2SV_EndBug> } sess -> iv . length = 0 ; <S2SV_StartBug> if ( aesni_mb_set_session_auth_parameters ( mb_ops , sess , auth_xform ) ) { <S2SV_EndBug> <S2SV_StartBug> MB_LOG_ERR ( "Invalid/unsupported<S2SV_blank>authentication<S2SV_blank>parameters" ) ; <S2SV_EndBug> return - 1 ; } if ( aesni_mb_set_session_cipher_parameters ( mb_ops , sess , cipher_xform ) ) { MB_LOG_ERR ( "Invalid/unsupported<S2SV_blank>cipher<S2SV_blank>parameters" ) ; <S2SV_StartBug> return - 1 ; <S2SV_EndBug> } return 0 ; } | <S2SV_ModStart> cipher_xform = NULL ; int ret <S2SV_ModStart> ; return - ENOTSUP <S2SV_ModEnd> ; } sess <S2SV_ModStart> = 0 ; ret = aesni_mb_set_session_auth_parameters ( mb_ops , sess , auth_xform ) ; if ( ret != 0 ) { MB_LOG_ERR ( "Invalid/unsupported<S2SV_blank>authentication<S2SV_blank>parameters" ) ; return ret ; } ret = aesni_mb_set_session_cipher_parameters <S2SV_ModEnd> ( mb_ops , <S2SV_ModStart> , sess , cipher_xform ) ; if ( ret != 0 <S2SV_ModEnd> ) { MB_LOG_ERR <S2SV_ModStart> { MB_LOG_ERR ( <S2SV_ModEnd> "Invalid/unsupported<S2SV_blank>cipher<S2SV_blank>parameters" ) ; <S2SV_ModStart> ) ; return ret <S2SV_ModEnd> ; } return |
948 | CWE-000 void Mem_DisableInterrupt ( MEMORY * mem , BYTE interrupt ) { <S2SV_StartBug> mem -> mem [ 0xFFFF ] &= ~ ( interrupt ) ; <S2SV_EndBug> } | <S2SV_ModStart> mem [ 0xFFFF - 0xC000 |
949 | CWE-000 static int sm501_plat_probe ( struct platform_device * dev ) { struct sm501_devdata * sm ; int ret ; sm = kzalloc ( sizeof ( * sm ) , GFP_KERNEL ) ; if ( ! sm ) { ret = - ENOMEM ; goto err1 ; } sm -> dev = & dev -> dev ; sm -> pdev_id = dev -> id ; sm -> platdata = dev_get_platdata ( & dev -> dev ) ; ret = platform_get_irq ( dev , 0 ) ; if ( ret < 0 ) { dev_err ( & dev -> dev , "failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>irq<S2SV_blank>resource\\n" ) ; goto err_res ; } sm -> irq = ret ; sm -> io_res = platform_get_resource ( dev , IORESOURCE_MEM , 1 ) ; sm -> mem_res = platform_get_resource ( dev , IORESOURCE_MEM , 0 ) ; if ( ! sm -> io_res || ! sm -> mem_res ) { dev_err ( & dev -> dev , "failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>IO<S2SV_blank>resource\\n" ) ; ret = - ENOENT ; goto err_res ; } sm -> regs_claim = request_mem_region ( sm -> io_res -> start , 0x100 , "sm501" ) ; if ( ! sm -> regs_claim ) { dev_err ( & dev -> dev , "cannot<S2SV_blank>claim<S2SV_blank>registers\\n" ) ; ret = - EBUSY ; goto err_res ; } platform_set_drvdata ( dev , sm ) ; sm -> regs = ioremap ( sm -> io_res -> start , resource_size ( sm -> io_res ) ) ; if ( ! sm -> regs ) { dev_err ( & dev -> dev , "cannot<S2SV_blank>remap<S2SV_blank>registers\\n" ) ; ret = - EIO ; goto err_claim ; } <S2SV_StartBug> return sm501_init_dev ( sm ) ; <S2SV_EndBug> err_claim : release_resource ( sm -> regs_claim ) ; kfree ( sm -> regs_claim ) ; err_res : kfree ( sm ) ; err1 : return ret ; } | <S2SV_ModStart> err_claim ; } ret = sm501_init_dev ( sm ) ; if ( ret ) { dev_err ( & dev -> dev , "cannot<S2SV_blank>init<S2SV_blank>device\\n" ) ; goto err_ioremap ; } return 0 ; err_ioremap : iounmap ( sm -> regs <S2SV_ModEnd> ) ; err_claim |
950 | CWE-000 int main ( ) { Claves * mis_claves = genera_claves ( ) ; <S2SV_StartBug> char mensaje [ MAX_MENSAJE ] , cifrado * ; <S2SV_EndBug> printf ( "Escriba<S2SV_blank>su<S2SV_blank>mensaje\\n" ) ; scanf ( "%s" , mensaje ) ; <S2SV_StartBug> cifrado = cifra ( mensaje , mis_claves [ 0 ] ) ; <S2SV_EndBug> printf ( "El<S2SV_blank>mensaje<S2SV_blank>cifrado<S2SV_blank>es:\\n%s\\n" , cifrado ) ; return 0 ; } | <S2SV_ModStart> [ MAX_MENSAJE ] ; char * cifrado <S2SV_ModEnd> ; printf ( <S2SV_ModStart> [ 0 ] . publica |
951 | CWE-000 short is_high_score ( int point , int level , int game_difficulty ) { FILE * score_table ; score imp_table [ TB ] ; char aux [ 1024 ] , aux_name [ 1024 ] ; <S2SV_StartBug> short i , j , c , pos = TB , aux_point = 0 , aux_level = 1 ; <S2SV_EndBug> char _home [ 1024 ] ; strcpy ( _home , getenv ( "HOME" ) ) ; <S2SV_StartBug> strcat ( _home , "/.btt" ) ; <S2SV_EndBug> switch ( game_difficulty ) { case EASY : strcat ( _home , "EasyScoreTab" ) ; break ; case NORMAL : strcat ( _home , "NormalScoreTab" ) ; break ; case HARD : strcat ( _home , "HardScoreTab" ) ; break ; case VERY_HARD : strcat ( _home , "VeryHardScoreTab" ) ; break ; case HOPELESS : strcat ( _home , "HopelessScoreTab" ) ; break ; } if ( ( score_table = fopen ( _home , "r+" ) ) == NULL ) { create_score_tab ( _home ) ; } else { fclose ( score_table ) ; } read_score_table ( _home , imp_table ) ; aux [ 0 ] = '<S2SV_blank>' ; for ( i = 0 , j = 1 ; i < TB ; i ++ ) { if ( point >= imp_table [ i ] . point ) { if ( point == 0 ) { j = 8 ; break ; } pos = i ; printf ( "Congrats<S2SV_blank>your<S2SV_blank>score<S2SV_blank>is<S2SV_blank>the<S2SV_blank>number<S2SV_blank>%d<S2SV_blank>of<S2SV_blank>the<S2SV_blank>list\\n" , i + 1 ) ; printf ( "Put<S2SV_blank>your<S2SV_blank>name<S2SV_blank>[10<S2SV_blank>char]:<S2SV_blank><default:<S2SV_blank>\'Stallman\'>\\n" ) ; while ( ( ( c = getchar ( ) ) != 10 ) && ( j < 10 ) ) { aux [ j ++ ] = c ; } aux [ j ] = '\\0' ; break ; } } if ( j == 1 ) { aux [ 1 ] = 'S' ; aux [ 2 ] = 't' ; aux [ 3 ] = 'a' ; aux [ 4 ] = 'l' ; aux [ 5 ] = 'l' ; aux [ 6 ] = 'm' ; aux [ 7 ] = 'a' ; aux [ 8 ] = 'n' ; aux [ 9 ] = '\\0' ; } c = kbhit ( ) ; if ( c != 0 ) { c = kbhit ( ) ; } for ( ; pos < TB ; pos ++ ) { strcpy ( aux_name , imp_table [ pos ] . name ) ; aux_point = imp_table [ pos ] . point ; aux_level = imp_table [ pos ] . level ; strcpy ( imp_table [ pos ] . name , aux ) ; imp_table [ pos ] . point = point ; imp_table [ pos ] . level = level ; strcpy ( aux , aux_name ) ; point = aux_point ; level = aux_level ; } if ( ( score_table = fopen ( _home , "r+" ) ) == NULL ) { fprintf ( stderr , "error<S2SV_blank>-><S2SV_blank>%d\\n" , errno ) ; exit ( ERR_OPEN_FILE ) ; } for ( i = 0 ; i < TB ; i ++ ) { fwrite ( & imp_table [ i ] . name , sizeof ( imp_table [ i ] . name ) , 1 , score_table ) ; fwrite ( & imp_table [ i ] . point , sizeof ( imp_table [ i ] . point ) , 1 , score_table ) ; fwrite ( & imp_table [ i ] . level , sizeof ( imp_table [ i ] . level ) , 1 , score_table ) ; } fclose ( score_table ) ; clear ( ) ; printf_score_tab ( imp_table , game_difficulty ) ; printf ( "\\n" ) ; printf ( "\\n\\t\\t\\t\\tpress<S2SV_blank>" GREEN "ENTER" RESET "\\n" ) ; while ( ( getch ( ) ) != '\\n' ) ; return 0 ; } | <S2SV_ModStart> = TB , aux_level = 1 ; int <S2SV_ModStart> aux_point = 0 <S2SV_ModEnd> ; char _home <S2SV_ModStart> ( _home , "/.bttConfig/btt" <S2SV_ModEnd> ) ; switch |
952 | CWE-000 void pim_upstream_del ( struct pim_upstream * up , const char * name ) { bool notify_msdp = false ; if ( PIM_DEBUG_TRACE ) zlog_debug ( "%s(%s):<S2SV_blank>Delete<S2SV_blank>%s<S2SV_blank>ref<S2SV_blank>count:<S2SV_blank>%d" , __PRETTY_FUNCTION__ , name , up -> sg_str , up -> ref_count ) ; -- up -> ref_count ; if ( up -> ref_count >= 1 ) return ; <S2SV_StartBug> join_timer_stop ( up ) ; <S2SV_EndBug> THREAD_OFF ( up -> t_ka_timer ) ; THREAD_OFF ( up -> t_rs_timer ) ; THREAD_OFF ( up -> t_msdp_reg_timer ) ; if ( up -> join_state == PIM_UPSTREAM_JOINED ) { pim_jp_agg_single_upstream_send ( & up -> rpf , up , 0 ) ; if ( up -> sg . src . s_addr == INADDR_ANY ) { notify_msdp = true ; } } <S2SV_StartBug> if ( up -> sg . src . s_addr != INADDR_ANY ) { <S2SV_EndBug> wheel_remove_item ( pim_upstream_sg_wheel , up ) ; notify_msdp = true ; } pim_upstream_remove_children ( up ) ; pim_mroute_del ( up -> channel_oil , __PRETTY_FUNCTION__ ) ; upstream_channel_oil_detach ( up ) ; if ( up -> sources ) list_delete ( up -> sources ) ; up -> sources = NULL ; if ( up -> parent ) { listnode_delete ( up -> parent -> sources , up ) ; up -> parent = NULL ; } listnode_delete ( pim_upstream_list , up ) ; hash_release ( pim_upstream_hash , up ) ; if ( notify_msdp ) { pim_msdp_up_del ( & up -> sg ) ; } pim_upstream_free ( up ) ; } | <S2SV_ModStart> ) return ; <S2SV_ModEnd> THREAD_OFF ( up <S2SV_ModStart> ; } } join_timer_stop ( up ) ; up -> rpf . source_nexthop . interface = NULL ; |
953 | CWE-000 int udp_recvmsg ( struct kiocb * iocb , struct sock * sk , struct msghdr * msg , size_t len , int noblock , int flags , int * addr_len ) { struct inet_sock * inet = inet_sk ( sk ) ; struct sockaddr_in * sin = ( struct sockaddr_in * ) msg -> msg_name ; struct sk_buff * skb ; unsigned int ulen , copied ; int peeked , off = 0 ; int err ; <S2SV_StartBug> int is_udplite = IS_UDPLITE ( sk ) ; <S2SV_EndBug> bool slow ; if ( flags & MSG_ERRQUEUE ) return ip_recv_error ( sk , msg , len , addr_len ) ; try_again : skb = __skb_recv_datagram ( sk , flags | ( noblock ? MSG_DONTWAIT : 0 ) , & peeked , & off , & err ) ; if ( ! skb ) goto out ; ulen = skb -> len - sizeof ( struct udphdr ) ; copied = len ; if ( copied > ulen ) copied = ulen ; else if ( copied < ulen ) msg -> msg_flags |= MSG_TRUNC ; if ( copied < ulen || UDP_SKB_CB ( skb ) -> partial_cov ) { <S2SV_StartBug> if ( udp_lib_checksum_complete ( skb ) ) <S2SV_EndBug> goto csum_copy_err ; } <S2SV_StartBug> if ( skb_csum_unnecessary ( skb ) ) <S2SV_EndBug> <S2SV_StartBug> err = skb_copy_datagram_iovec ( skb , sizeof ( struct udphdr ) , <S2SV_EndBug> <S2SV_StartBug> msg -> msg_iov , copied ) ; <S2SV_EndBug> else { err = skb_copy_and_csum_datagram_iovec ( skb , sizeof ( struct udphdr ) , msg -> msg_iov ) ; if ( err == - EINVAL ) goto csum_copy_err ; } if ( unlikely ( err ) ) { trace_kfree_skb ( skb , udp_recvmsg ) ; if ( ! peeked ) { atomic_inc ( & sk -> sk_drops ) ; UDP_INC_STATS_USER ( sock_net ( sk ) , UDP_MIB_INERRORS , is_udplite ) ; } goto out_free ; } if ( ! peeked ) UDP_INC_STATS_USER ( sock_net ( sk ) , UDP_MIB_INDATAGRAMS , is_udplite ) ; sock_recv_ts_and_drops ( msg , sk , skb ) ; if ( sin ) { sin -> sin_family = AF_INET ; sin -> sin_port = udp_hdr ( skb ) -> source ; sin -> sin_addr . s_addr = ip_hdr ( skb ) -> saddr ; memset ( sin -> sin_zero , 0 , sizeof ( sin -> sin_zero ) ) ; * addr_len = sizeof ( * sin ) ; } if ( inet -> cmsg_flags ) ip_cmsg_recv ( msg , skb ) ; err = copied ; if ( flags & MSG_TRUNC ) err = ulen ; out_free : skb_free_datagram_locked ( sk , skb ) ; out : return err ; csum_copy_err : slow = lock_sock_fast ( sk ) ; if ( ! skb_kill_datagram ( sk , skb , flags ) ) { UDP_INC_STATS_USER ( sock_net ( sk ) , UDP_MIB_CSUMERRORS , is_udplite ) ; UDP_INC_STATS_USER ( sock_net ( sk ) , UDP_MIB_INERRORS , is_udplite ) ; } unlock_sock_fast ( sk , slow ) ; cond_resched ( ) ; msg -> msg_flags &= ~ MSG_TRUNC ; goto try_again ; } | <S2SV_ModStart> ( sk ) ; bool checksum_valid = false <S2SV_ModStart> partial_cov ) { checksum_valid = ! <S2SV_ModEnd> udp_lib_checksum_complete ( skb <S2SV_ModStart> ( skb ) ; if ( ! checksum_valid <S2SV_ModStart> } if ( checksum_valid || <S2SV_ModStart> ) err = skb_copy_datagram_msg <S2SV_ModEnd> ( skb , <S2SV_ModStart> ) , msg <S2SV_ModEnd> , copied ) |
954 | CWE-000 static uint32_t overlay_get_target_phandle ( const void * fdto , int fragment ) { <S2SV_StartBug> const uint32_t * val ; <S2SV_EndBug> int len ; val = fdt_getprop ( fdto , fragment , "target" , & len ) ; if ( ! val ) return 0 ; <S2SV_StartBug> if ( ( len != sizeof ( * val ) ) || ( * val == ( uint32_t ) - 1 ) ) <S2SV_EndBug> return ( uint32_t ) - 1 ; return fdt32_to_cpu ( * val ) ; } | <S2SV_ModStart> ) { const fdt32_t <S2SV_ModEnd> * val ; <S2SV_ModStart> ) || ( fdt32_to_cpu ( * val ) <S2SV_ModEnd> == ( uint32_t |
955 | CWE-000 static int hook_request_late ( request_rec * r ) { char * my_error_msg = NULL ; modsec_rec * msr = NULL ; int rc ; if ( ( r -> main != NULL ) || ( r -> prev != NULL ) ) { return DECLINED ; } msr = retrieve_tx_context ( r ) ; if ( msr == NULL ) { return DECLINED ; } if ( msr -> phase_request_body_complete ) { msr_log ( msr , 1 , "Internal<S2SV_blank>Error:<S2SV_blank>Attempted<S2SV_blank>to<S2SV_blank>process<S2SV_blank>the<S2SV_blank>request<S2SV_blank>body<S2SV_blank>more<S2SV_blank>than<S2SV_blank>once." ) ; return DECLINED ; } msr -> phase_request_body_complete = 1 ; msr -> remote_user = r -> user ; msr -> dcfg2 = ( directory_config * ) ap_get_module_config ( r -> per_dir_config , & security2_module ) ; msr -> txcfg = create_directory_config ( msr -> mp , NULL ) ; if ( msr -> txcfg == NULL ) return DECLINED ; if ( msr -> dcfg2 != NULL ) { msr -> txcfg = merge_directory_configs ( msr -> mp , msr -> txcfg , msr -> dcfg2 ) ; if ( msr -> txcfg == NULL ) return DECLINED ; } msr -> txcfg = merge_directory_configs ( msr -> mp , msr -> txcfg , msr -> usercfg ) ; init_directory_config ( msr -> txcfg ) ; if ( msr -> txcfg -> is_enabled == 0 ) { if ( msr -> txcfg -> debuglog_level >= 4 ) { msr_log ( msr , 4 , "Processing<S2SV_blank>disabled,<S2SV_blank>skipping<S2SV_blank>(hook<S2SV_blank>request_late)." ) ; } return DECLINED ; } # ifndef REQUEST_EARLY if ( msr -> txcfg -> debuglog_level >= 4 ) { msr_log ( msr , 4 , "First<S2SV_blank>phase<S2SV_blank>starting<S2SV_blank>(dcfg<S2SV_blank>%pp)." , msr -> dcfg2 ) ; } if ( modsecurity_process_phase ( msr , PHASE_REQUEST_HEADERS ) > 0 ) { rc = perform_interception ( msr ) ; if ( rc != DECLINED ) { return rc ; } } # endif if ( msr -> txcfg -> is_enabled == MODSEC_DISABLED ) { if ( msr -> txcfg -> debuglog_level >= 4 ) { msr_log ( msr , 4 , "Skipping<S2SV_blank>phase<S2SV_blank>2<S2SV_blank>as<S2SV_blank>the<S2SV_blank>rule<S2SV_blank>engine<S2SV_blank>was<S2SV_blank>disabled<S2SV_blank>by<S2SV_blank>a<S2SV_blank>rule<S2SV_blank>in<S2SV_blank>phase<S2SV_blank>1." ) ; } return DECLINED ; } if ( msr -> txcfg -> debuglog_level >= 4 ) { msr_log ( msr , 4 , "Second<S2SV_blank>phase<S2SV_blank>starting<S2SV_blank>(dcfg<S2SV_blank>%pp)." , msr -> dcfg2 ) ; } msr -> inbound_error = 0 ; if ( msr -> txcfg -> reqbody_access == 1 ) { if ( msr -> request_content_length > msr -> txcfg -> reqbody_limit ) { if ( ( msr -> txcfg -> is_enabled == MODSEC_ENABLED ) && ( msr -> txcfg -> if_limit_action == REQUEST_BODY_LIMIT_ACTION_REJECT ) ) { msr -> inbound_error = 1 ; msr_log ( msr , 1 , "Request<S2SV_blank>body<S2SV_blank>(Content-Length)<S2SV_blank>is<S2SV_blank>larger<S2SV_blank>than<S2SV_blank>the<S2SV_blank>" "configured<S2SV_blank>limit<S2SV_blank>(%ld).<S2SV_blank>Deny<S2SV_blank>with<S2SV_blank>status<S2SV_blank>(%d)" , msr -> txcfg -> reqbody_limit , HTTP_REQUEST_ENTITY_TOO_LARGE ) ; return HTTP_REQUEST_ENTITY_TOO_LARGE ; } else if ( ( msr -> txcfg -> is_enabled == MODSEC_ENABLED ) && ( msr -> txcfg -> if_limit_action == REQUEST_BODY_LIMIT_ACTION_PARTIAL ) ) { msr -> inbound_error = 1 ; msr_log ( msr , 1 , "Request<S2SV_blank>body<S2SV_blank>(Content-Length)<S2SV_blank>is<S2SV_blank>larger<S2SV_blank>than<S2SV_blank>the<S2SV_blank>" "configured<S2SV_blank>limit<S2SV_blank>(%ld)." , msr -> txcfg -> reqbody_limit ) ; } else if ( ( msr -> txcfg -> is_enabled == MODSEC_DETECTION_ONLY ) && ( msr -> txcfg -> if_limit_action == REQUEST_BODY_LIMIT_ACTION_PARTIAL ) ) { msr_log ( msr , 1 , "Request<S2SV_blank>body<S2SV_blank>(Content-Length)<S2SV_blank>is<S2SV_blank>larger<S2SV_blank>than<S2SV_blank>the<S2SV_blank>" "configured<S2SV_blank>limit<S2SV_blank>(%ld)." , msr -> txcfg -> reqbody_limit ) ; msr -> inbound_error = 1 ; } else { msr_log ( msr , 1 , "Request<S2SV_blank>body<S2SV_blank>(Content-Length)<S2SV_blank>is<S2SV_blank>larger<S2SV_blank>than<S2SV_blank>the<S2SV_blank>" "configured<S2SV_blank>limit<S2SV_blank>(%ld)." , msr -> txcfg -> reqbody_limit ) ; msr -> inbound_error = 1 ; } } } if ( ( msr -> txcfg -> upload_keep_files != KEEP_FILES_OFF ) || ( msr -> txcfg -> upload_validates_files ) ) { msr -> upload_extract_files = 1 ; msr -> upload_remove_files = 1 ; } rc = read_request_body ( msr , & my_error_msg ) ; if ( rc < 0 ) { switch ( rc ) { case - 1 : if ( my_error_msg != NULL ) { msr_log ( msr , 1 , "%s" , my_error_msg ) ; } return HTTP_INTERNAL_SERVER_ERROR ; break ; case - 4 : if ( my_error_msg != NULL ) { msr_log ( msr , 4 , "%s" , my_error_msg ) ; } r -> connection -> keepalive = AP_CONN_CLOSE ; return HTTP_REQUEST_TIME_OUT ; break ; case - 5 : msr -> inbound_error = 1 ; if ( ( msr -> txcfg -> is_enabled == MODSEC_ENABLED ) && ( msr -> txcfg -> if_limit_action == REQUEST_BODY_LIMIT_ACTION_REJECT ) ) { r -> connection -> keepalive = AP_CONN_CLOSE ; if ( my_error_msg != NULL ) { msr_log ( msr , 1 , "%s.<S2SV_blank>Deny<S2SV_blank>with<S2SV_blank>code<S2SV_blank>(%d)" , my_error_msg , HTTP_REQUEST_ENTITY_TOO_LARGE ) ; } return HTTP_REQUEST_ENTITY_TOO_LARGE ; } else { if ( my_error_msg != NULL ) { msr_log ( msr , 1 , "%s" , my_error_msg ) ; } } break ; case - 6 : if ( my_error_msg != NULL ) { msr_log ( msr , 4 , "%s" , my_error_msg ) ; } r -> connection -> keepalive = AP_CONN_CLOSE ; return HTTP_BAD_REQUEST ; break ; <S2SV_StartBug> default : <S2SV_EndBug> break ; } msr -> msc_reqbody_error = 1 ; msr -> msc_reqbody_error_msg = my_error_msg ; } msr -> request_headers = apr_table_copy ( msr -> mp , r -> headers_in ) ; rc = DECLINED ; if ( modsecurity_process_phase ( msr , PHASE_REQUEST_BODY ) > 0 ) { rc = perform_interception ( msr ) ; } if ( msr -> txcfg -> stream_inbody_inspection && msr -> msc_reqbody_read ) { const char * clen = NULL ; clen = apr_psprintf ( msr -> mp , "%" APR_SIZE_T_FMT , msr -> stream_input_length ) ; if ( clen ) apr_table_setn ( r -> headers_in , "Content-Length" , clen ) ; } if ( msr -> txcfg -> disable_backend_compression ) { apr_table_unset ( r -> headers_in , "Accept-Encoding" ) ; apr_table_unset ( r -> headers_in , "TE" ) ; } return rc ; } | <S2SV_ModStart> ; break ; case - 7 : if ( my_error_msg != NULL ) { msr_log ( msr , 4 , "%s" , my_error_msg ) ; } r -> connection -> keepalive = AP_CONN_CLOSE ; return HTTP_BAD_REQUEST ; break ; |
956 | CWE-000 void game_reset_boss ( BSJ_Game * game ) { for ( int i = 0 ; i < game -> boss_projectile_count ; i ++ ) { BSJ_Projectile * projectile = game -> boss_projectiles [ i ] ; projectile -> unused = true ; <S2SV_StartBug> } <S2SV_EndBug> mde ( current_projectiles , 0 ) ; mde ( max_projectiles , 10 ) ; mde ( mode , none ) ; mde ( next_mode , straight_projectiles ) ; mde ( next_mode_countdown , 60 * 3 ) ; mde ( current_countdown_for_next_mode , 0 ) ; } | <S2SV_ModStart> true ; } game -> is_boss_attacking = false ; |
957 | CWE-000 void init_battle_elements ( ) { for ( u8 i = 0 ; i < 4 ; i ++ ) { p_bank [ i ] = malloc_and_clear ( sizeof ( struct pkmn_bank ) ) ; for ( u8 j = 0 ; j < 4 ; j ++ ) { p_bank [ i ] -> objid_hpbox [ j ] = 0x3F ; } } bs_env_windows = ( struct bs_elements_positions * ) malloc_and_clear ( sizeof ( struct bs_elements_positions ) ) ; battle_master = ( struct battle_main * ) malloc_and_clear ( sizeof ( struct battle_main ) ) ; for ( u8 i = 0 ; i < 10 ; ++ i ) { battle_master -> switch_main . type_objid [ i ] = 0x3F ; } residual_cbs_init ( ) ; setup ( ) ; help_system_disable__sp198 ( ) ; super . multi_purpose_state_tracker = 0 ; set_callback1 ( ( SuperCallback ) battle_slidein ) ; battle_type_flags = BATTLE_FLAG_WILD ; <S2SV_StartBug> u16 t = MOVE_TAIL_WHIP ; <S2SV_EndBug> pokemon_setattr ( & party_player [ 0 ] , REQUEST_MOVE3 , & t ) ; <S2SV_StartBug> t = MOVE_WRAP ; <S2SV_EndBug> pokemon_setattr ( & party_player [ 0 ] , REQUEST_MOVE4 , & t ) ; t = 5 ; pokemon_setattr ( & party_player [ 0 ] , REQUEST_PP3 , & t ) ; t = 10 ; pokemon_setattr ( & party_player [ 0 ] , REQUEST_PP4 , & t ) ; t = MOVE_TAIL_WHIP ; pokemon_setattr ( & party_opponent [ 0 ] , REQUEST_MOVE1 , & t ) ; pokemon_setattr ( & party_opponent [ 0 ] , REQUEST_MOVE2 , & t ) ; pokemon_setattr ( & party_opponent [ 0 ] , REQUEST_MOVE3 , & t ) ; } | <S2SV_ModStart> u16 t = MOVE_HOWL <S2SV_ModEnd> ; pokemon_setattr ( <S2SV_ModStart> ; t = MOVE_SWORDS_DANCE <S2SV_ModEnd> ; pokemon_setattr ( |
958 | CWE-000 static void _slurm_rpc_job_step_kill ( uint32_t uid , slurm_msg_t * msg ) { static int active_rpc_cnt = 0 ; int error_code = SLURM_SUCCESS ; DEF_TIMERS ; job_step_kill_msg_t * job_step_kill_msg = ( job_step_kill_msg_t * ) msg -> data ; slurmctld_lock_t job_write_lock = { READ_LOCK , WRITE_LOCK , WRITE_LOCK , NO_LOCK , READ_LOCK } ; struct job_record * job_ptr ; START_TIMER ; if ( slurmctld_conf . debug_flags & DEBUG_FLAG_STEPS ) info ( "Processing<S2SV_blank>RPC:<S2SV_blank>REQUEST_CANCEL_JOB_STEP<S2SV_blank>uid=%d" , uid ) ; _throttle_start ( & active_rpc_cnt ) ; lock_slurmctld ( job_write_lock ) ; job_ptr = find_job_record ( job_step_kill_msg -> job_id ) ; trace_job ( job_ptr , __func__ , "enter" ) ; if ( job_step_kill_msg -> job_step_id == SLURM_BATCH_SCRIPT ) { error_code = job_signal ( job_step_kill_msg -> job_id , job_step_kill_msg -> signal , job_step_kill_msg -> flags , uid , false ) ; unlock_slurmctld ( job_write_lock ) ; _throttle_fini ( & active_rpc_cnt ) ; END_TIMER2 ( "_slurm_rpc_job_step_kill" ) ; if ( error_code ) { if ( slurmctld_conf . debug_flags & DEBUG_FLAG_STEPS ) info ( "Signal<S2SV_blank>%u<S2SV_blank>JobId=%u<S2SV_blank>by<S2SV_blank>UID=%u:<S2SV_blank>%s" , job_step_kill_msg -> signal , job_step_kill_msg -> job_id , uid , slurm_strerror ( error_code ) ) ; slurm_send_rc_msg ( msg , error_code ) ; } else { if ( job_step_kill_msg -> signal == SIGKILL ) { if ( slurmctld_conf . debug_flags & DEBUG_FLAG_STEPS ) info ( "%s:<S2SV_blank>Cancel<S2SV_blank>of<S2SV_blank>JobId=%u<S2SV_blank>by<S2SV_blank>" "UID=%u,<S2SV_blank>%s" , __func__ , job_step_kill_msg -> job_id , uid , TIME_STR ) ; slurmctld_diag_stats . jobs_canceled ++ ; } else { if ( slurmctld_conf . debug_flags & DEBUG_FLAG_STEPS ) info ( "%s:<S2SV_blank>Signal<S2SV_blank>%u<S2SV_blank>of<S2SV_blank>JobId=%u<S2SV_blank>by<S2SV_blank>" "UID=%u,<S2SV_blank>%s" , __func__ , job_step_kill_msg -> signal , job_step_kill_msg -> job_id , uid , TIME_STR ) ; } slurm_send_rc_msg ( msg , SLURM_SUCCESS ) ; schedule_job_save ( ) ; } } else { error_code = job_step_signal ( job_step_kill_msg -> job_id , job_step_kill_msg -> job_step_id , job_step_kill_msg -> signal , <S2SV_StartBug> uid ) ; <S2SV_EndBug> unlock_slurmctld ( job_write_lock ) ; _throttle_fini ( & active_rpc_cnt ) ; END_TIMER2 ( "_slurm_rpc_job_step_kill" ) ; if ( error_code ) { if ( slurmctld_conf . debug_flags & DEBUG_FLAG_STEPS ) info ( "Signal<S2SV_blank>%u<S2SV_blank>of<S2SV_blank>StepId=%u.%u<S2SV_blank>by<S2SV_blank>UID=%u:<S2SV_blank>%s" , job_step_kill_msg -> signal , job_step_kill_msg -> job_id , job_step_kill_msg -> job_step_id , uid , slurm_strerror ( error_code ) ) ; slurm_send_rc_msg ( msg , error_code ) ; } else { if ( job_step_kill_msg -> signal == SIGKILL ) { if ( slurmctld_conf . debug_flags & DEBUG_FLAG_STEPS ) info ( "%s:<S2SV_blank>Cancel<S2SV_blank>of<S2SV_blank>StepId=%u.%u<S2SV_blank>by<S2SV_blank>" "UID=%u<S2SV_blank>%s" , __func__ , job_step_kill_msg -> job_id , job_step_kill_msg -> job_step_id , uid , TIME_STR ) ; } else { if ( slurmctld_conf . debug_flags & DEBUG_FLAG_STEPS ) info ( "%s:<S2SV_blank>Signal<S2SV_blank>%u<S2SV_blank>of<S2SV_blank>StepId=%u.%u<S2SV_blank>" "by<S2SV_blank>UID=%u<S2SV_blank>%s" , __func__ , job_step_kill_msg -> signal , job_step_kill_msg -> job_id , job_step_kill_msg -> job_step_id , uid , TIME_STR ) ; } slurm_send_rc_msg ( msg , SLURM_SUCCESS ) ; schedule_job_save ( ) ; } } trace_job ( job_ptr , __func__ , "return" ) ; } | <S2SV_ModStart> -> signal , job_step_kill_msg -> flags , |
959 | CWE-000 void * async_publish_function ( const void * v ) { <S2SV_StartBug> int queue_id = ( int * ) v ; <S2SV_EndBug> void * data = NULL ; while ( 1 ) { <S2SV_StartBug> while ( data = q_delete ( & async_q [ queue_id ] ) ) <S2SV_EndBug> { } sleep ( 1 ) ; } return NULL ; } | <S2SV_ModStart> v ) { Q * q <S2SV_ModEnd> = ( int <S2SV_ModStart> = q_delete ( q <S2SV_ModEnd> ) ) { |
960 | CWE-000 int search ( unsigned char * x , int m , unsigned char * y , int n ) { int S [ XSIZE ] , FT [ SIGMA ] [ SIGMA ] ; int * trans [ XSIZE ] ; int i , j , p , q ; int iMinus1 , mMinus1 , count ; unsigned char c ; count = 0 ; <S2SV_StartBug> BEGIN_PREPROCESSING <S2SV_EndBug> for ( i = 0 ; i <= m + 1 ; i ++ ) trans [ i ] = ( int * ) malloc ( sizeof ( int ) * ( SIGMA ) ) ; for ( i = 0 ; i <= m + 1 ; i ++ ) for ( j = 0 ; j < SIGMA ; j ++ ) trans [ i ] [ j ] = UNDEFINED ; S [ m ] = m + 1 ; for ( i = m ; i > 0 ; -- i ) { iMinus1 = i - 1 ; c = x [ iMinus1 ] ; trans [ i ] [ c ] = iMinus1 ; p = S [ i ] ; while ( p <= m && ( q = trans [ p ] [ c ] ) == UNDEFINED ) { trans [ p ] [ c ] = iMinus1 ; p = S [ p ] ; } S [ iMinus1 ] = ( p == m + 1 ? m : q ) ; } for ( i = 0 ; i < SIGMA ; i ++ ) { q = trans [ m ] [ i ] ; for ( j = 0 ; j < SIGMA ; j ++ ) if ( q >= 0 ) FT [ i ] [ j ] = trans [ q ] [ j ] ; else FT [ i ] [ j ] = UNDEFINED ; } END_PREPROCESSING BEGIN_SEARCHING for ( i = 0 ; i < m ; i ++ ) y [ n + i ] = x [ i ] ; if ( ! memcmp ( x , y , m ) ) count ++ ; j = m ; mMinus1 = m - 1 ; while ( j < n ) { while ( ( FT [ y [ j ] ] [ y [ j - 1 ] ] ) == UNDEFINED ) j += mMinus1 ; i = j - 2 ; p = FT [ y [ j ] ] [ y [ j - 1 ] ] ; while ( ( p = trans [ p ] [ y [ i ] ] ) != UNDEFINED ) i -- ; if ( i < j - mMinus1 && j < n ) { count ++ ; i ++ ; } j = i + m ; } END_SEARCHING for ( i = 0 ; i <= m + 1 ; i ++ ) free ( trans [ i ] ) ; return count ; } | <S2SV_ModStart> = 0 ; if ( m < 2 ) return - 1 ; |
961 | CWE-000 void __hdd_ipv4_notifier_work_queue ( struct work_struct * work ) { hdd_adapter_t * pAdapter = container_of ( work , hdd_adapter_t , ipv4NotifierWorkQueue ) ; hdd_context_t * pHddCtx ; int status ; ENTER ( ) ; if ( NULL == pAdapter ) { hddLog ( LOGE , FL ( "Adapter<S2SV_blank>is<S2SV_blank>invalid" ) ) ; return ; } pHddCtx = WLAN_HDD_GET_CTX ( pAdapter ) ; status = wlan_hdd_validate_context ( pHddCtx ) ; if ( 0 != status ) { return ; } <S2SV_StartBug> if ( VOS_FALSE == pHddCtx -> sus_res_mcastbcast_filter_valid ) <S2SV_EndBug> { pHddCtx -> sus_res_mcastbcast_filter = pHddCtx -> configuredMcastBcastFilter ; hddLog ( LOG1 , FL ( "saving<S2SV_blank>configuredMcastBcastFilter<S2SV_blank>=<S2SV_blank>%d" ) , pHddCtx -> sus_res_mcastbcast_filter ) ; pHddCtx -> sus_res_mcastbcast_filter_valid = VOS_TRUE ; } if ( ( eConnectionState_Associated == ( WLAN_HDD_GET_STATION_CTX_PTR ( pAdapter ) ) -> conn_info . connState ) && ( pHddCtx -> hdd_wlan_suspended ) ) { <S2SV_StartBug> hdd_conf_arp_offload ( pAdapter , 2 ) ; <S2SV_EndBug> } <S2SV_StartBug> EXIT ( ) ; <S2SV_EndBug> } | <S2SV_ModStart> } if ( <S2SV_ModEnd> ( eConnectionState_Associated == <S2SV_ModStart> ) ) { check_and_set_suspend_resume_mcbc_filter ( pHddCtx ) ; if ( pHddCtx -> cfg_ini -> fhostArpOffload ) { <S2SV_ModStart> ) ; } else { hddLog ( VOS_TRACE_LEVEL_INFO , FL ( "offload:<S2SV_blank>arp<S2SV_blank>offload<S2SV_blank>ini<S2SV_blank>is<S2SV_blank>disabled<S2SV_blank>in<S2SV_blank>host" ) ) ; } } |
962 | CWE-000 static void mono_thread_detach_internal ( MonoInternalThread * thread ) { <S2SV_StartBug> gboolean removed ; <S2SV_EndBug> <S2SV_StartBug> g_assert ( thread != NULL ) ; <S2SV_EndBug> <S2SV_StartBug> SET_CURRENT_OBJECT ( thread ) ; <S2SV_EndBug> THREAD_DEBUG ( g_message ( "%s:<S2SV_blank>mono_thread_detach<S2SV_blank>for<S2SV_blank>%p<S2SV_blank>(%" G_GSIZE_FORMAT ")" , __func__ , thread , ( gsize ) thread -> tid ) ) ; # ifndef HOST_WIN32 mono_w32mutex_abandon ( ) ; # endif if ( thread -> abort_state_handle ) { mono_gchandle_free ( thread -> abort_state_handle ) ; thread -> abort_state_handle = 0 ; } thread -> abort_exc = NULL ; thread -> current_appcontext = NULL ; <S2SV_StartBug> mono_threads_add_joinable_runtime_thread ( thread -> thread_info ) ; <S2SV_EndBug> if ( thread -> synch_cs ) LOCK_THREAD ( thread ) ; thread -> state |= ThreadState_Stopped ; thread -> state &= ~ ThreadState_Background ; if ( thread -> synch_cs ) UNLOCK_THREAD ( thread ) ; mono_thread_clear_interruption_requested ( thread ) ; mono_threads_lock ( ) ; if ( ! threads ) { removed = FALSE ; } else if ( mono_g_hash_table_lookup ( threads , ( gpointer ) thread -> tid ) != thread ) { removed = FALSE ; } else { mono_g_hash_table_remove ( threads , ( gpointer ) thread -> tid ) ; removed = TRUE ; } mono_threads_unlock ( ) ; if ( ! removed ) { mono_domain_unset ( ) ; mono_memory_barrier ( ) ; if ( mono_thread_cleanup_fn ) mono_thread_cleanup_fn ( thread_get_tid ( thread ) ) ; goto done ; } mono_release_type_locks ( thread ) ; <S2SV_StartBug> if ( ! mono_thread_info_lookup ( MONO_UINT_TO_NATIVE_THREAD_ID ( thread -> tid ) ) -> tools_thread ) <S2SV_EndBug> MONO_PROFILER_RAISE ( thread_stopped , ( thread -> tid ) ) ; mono_hazard_pointer_clear ( mono_hazard_pointer_get ( ) , 1 ) ; mono_domain_unset ( ) ; mono_memory_barrier ( ) ; if ( thread == mono_thread_internal_current ( ) ) mono_thread_pop_appdomain_ref ( ) ; mono_free_static_data ( thread -> static_data ) ; thread -> static_data = NULL ; ref_stack_destroy ( thread -> appdomain_refs ) ; thread -> appdomain_refs = NULL ; g_assert ( thread -> suspended ) ; mono_os_event_destroy ( thread -> suspended ) ; g_free ( thread -> suspended ) ; thread -> suspended = NULL ; if ( mono_thread_cleanup_fn ) mono_thread_cleanup_fn ( thread_get_tid ( thread ) ) ; mono_memory_barrier ( ) ; if ( mono_gc_is_moving ( ) ) { MONO_GC_UNREGISTER_ROOT ( thread -> thread_pinning_ref ) ; thread -> thread_pinning_ref = NULL ; } done : SET_CURRENT_OBJECT ( NULL ) ; mono_domain_unset ( ) ; <S2SV_StartBug> mono_thread_info_unset_internal_thread_gchandle ( ( MonoThreadInfo * ) thread -> thread_info ) ; <S2SV_EndBug> } | <S2SV_ModStart> thread ) { MonoThreadInfo * info ; <S2SV_ModStart> gboolean removed ; guint32 gchandle ; <S2SV_ModStart> SET_CURRENT_OBJECT ( thread ) ; info = ( MonoThreadInfo * ) thread -> thread_info ; g_assert ( info <S2SV_ModStart> ; mono_threads_add_joinable_runtime_thread ( info <S2SV_ModEnd> ) ; if <S2SV_ModStart> if ( ! info <S2SV_ModEnd> -> tools_thread ) <S2SV_ModStart> ( ) ; if ( ! mono_thread_info_try_get_internal_thread_gchandle ( info , & gchandle ) ) g_error ( "%s:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>gchandle,<S2SV_blank>info<S2SV_blank>=<S2SV_blank>%p" , __func__ , info ) ; mono_gchandle_free ( gchandle ) ; mono_thread_info_unset_internal_thread_gchandle ( info <S2SV_ModEnd> ) ; } |
963 | CWE-000 void SYS_Init ( void ) { SYS_UnlockReg ( ) ; CLK_EnableXtalRC ( CLK_PWRCTL_HXTEN_Msk ) ; CLK_WaitClockReady ( CLK_STATUS_HXTSTB_Msk ) ; CLK_SetHCLK ( CLK_CLKSEL0_HCLKSEL_HXT , CLK_CLKDIV0_HCLK ( 1 ) ) ; CLK -> PLLCTL |= CLK_PLLCTL_PD_Msk ; CLK -> PLLCTL = CLK_PLLCTL_84MHz_HXT ; CLK_WaitClockReady ( CLK_STATUS_PLLSTB_Msk ) ; CLK_SetHCLK ( CLK_CLKSEL0_HCLKSEL_PLL , CLK_CLKDIV0_HCLK ( 1 ) ) ; CLK_EnableModuleClock ( UART0_MODULE ) ; CLK_EnableModuleClock ( ACMP_MODULE ) ; CLK_SetModuleClock ( UART0_MODULE , CLK_CLKSEL1_UARTSEL_HXT , CLK_CLKDIV0_UART ( 1 ) ) ; SystemCoreClockUpdate ( ) ; <S2SV_StartBug> SYS -> GPE_MFPL = SYS_GPE_MFPL_PE6MFP_ACMP0_P0 ; <S2SV_EndBug> GPIO_DISABLE_DIGITAL_PATH ( PE , ( 1 << 6 ) ) ; <S2SV_StartBug> SYS -> GPG_MFPL = SYS_GPG_MFPL_PG1MFP_UART0_RXD | SYS_GPG_MFPL_PG2MFP_UART0_TXD ; <S2SV_EndBug> SYS_LockReg ( ) ; } | <S2SV_ModStart> SYS -> GPE_MFPL |= <S2SV_ModEnd> SYS_GPE_MFPL_PE6MFP_ACMP0_P0 ; GPIO_DISABLE_DIGITAL_PATH <S2SV_ModStart> SYS -> GPG_MFPL |= <S2SV_ModEnd> SYS_GPG_MFPL_PG1MFP_UART0_RXD | SYS_GPG_MFPL_PG2MFP_UART0_TXD |
964 | CWE-000 static ssize_t auxv_read ( struct file * file , char __user * buf , size_t count , loff_t * ppos ) { struct mm_struct * mm = file -> private_data ; <S2SV_StartBug> unsigned int nwords = 0 ; <S2SV_EndBug> do { nwords += 2 ; } while ( mm -> saved_auxv [ nwords - 2 ] != 0 ) ; return simple_read_from_buffer ( buf , count , ppos , mm -> saved_auxv , nwords * sizeof ( mm -> saved_auxv [ 0 ] ) ) ; } | <S2SV_ModStart> int nwords = 0 ; if ( ! mm ) return |
965 | CWE-000 ngx_int_t redis_add_connection_data ( nchan_redis_conf_t * rcf , nchan_loc_conf_t * lcf , ngx_str_t * override_url ) { rdstore_data_t * rdata ; redis_connect_params_t rcp ; static ngx_str_t default_redis_url = ngx_string ( NCHAN_REDIS_DEFAULT_URL ) ; ngx_str_t * url ; if ( rcf -> url . len == 0 ) { rcf -> url = default_redis_url ; } url = override_url ? override_url : & rcf -> url ; if ( url -> len == 0 ) { url = & default_redis_url ; } parse_redis_url ( url , & rcp ) ; rcp . peername . len = 0 ; rcp . peername . data = NULL ; <S2SV_StartBug> if ( ( rdata = find_rdata_by_connect_params ( & rcp ) ) == NULL ) { <S2SV_EndBug> rdata = redis_create_rdata ( url , & rcp , rcf , lcf ) ; } else { if ( rcf -> ping_interval > 0 && rcf -> ping_interval < rdata -> ping_interval ) { rdata -> ping_interval = rcf -> ping_interval ; } } rcf -> privdata = rdata ; return NGX_OK ; } | <S2SV_ModStart> ; if ( rcf -> ping_interval == NGX_CONF_UNSET ) { rcf -> ping_interval = NCHAN_REDIS_DEFAULT_PING_INTERVAL_TIME ; } if ( rcf -> storage_mode == REDIS_MODE_CONF_UNSET ) { rcf -> storage_mode = REDIS_MODE_DISTRIBUTED ; } if ( rcf -> after_connect_wait_time == NGX_CONF_UNSET ) { rcf -> after_connect_wait_time = 0 ; } if ( |
966 | CWE-000 void * pool_remove_inactive_connections ( void * arg ) { connection_list_element * elt ; for ( ; ; ) { time_t current_time = time ( 0 ) ; pthread_mutex_lock ( & g_descriptors_mutex ) ; LL_FOREACH ( g_connection_list_head , elt ) { if ( current_time - elt -> connection_data . last_share_time > 300 ) { elt -> connection_data . deleted = 1 ; <S2SV_StartBug> elt -> connection_data . disconnection_reason = strdup ( "inactive<S2SV_blank>connection" ) ; <S2SV_EndBug> } } pthread_mutex_unlock ( & g_descriptors_mutex ) ; sleep ( 60 ) ; } return NULL ; } | <S2SV_ModStart> . disconnection_reason = "inactive<S2SV_blank>connection" <S2SV_ModEnd> ; } } |
967 | CWE-000 unsigned I_NetTransfer ( unsigned int buttons ) { int val ; byte inbytes [ 6 ] ; byte outbytes [ 6 ] ; int consistancy ; int i ; outbytes [ 0 ] = buttons >> 24 ; outbytes [ 1 ] = buttons >> 16 ; outbytes [ 2 ] = buttons >> 8 ; outbytes [ 3 ] = buttons ; consistancy = players [ 0 ] . mo -> x ^ players [ 0 ] . mo -> y ^ players [ 1 ] . mo -> x ^ players [ 1 ] . mo -> y ; consistancy = ( consistancy >> 8 ) ^ consistancy ^ ( consistancy >> 16 ) ; outbytes [ 4 ] = ( byte ) ( consistancy & 0xff ) ; outbytes [ 5 ] = vblsinframe ; if ( consoleplayer ) { for ( i = 0 ; i <= 5 ; i ++ ) { val = WaitGetSerialChar ( ) ; if ( val == - 1 ) goto reconnect ; inbytes [ i ] = val ; PutSerialChar ( outbytes [ i ] ) ; } vblsinframe = inbytes [ 5 ] ; } else { for ( i = 0 ; i <= 5 ; i ++ ) { PutSerialChar ( outbytes [ i ] ) ; val = WaitGetSerialChar ( ) ; if ( val == - 1 ) goto reconnect ; inbytes [ i ] = val ; } } if ( inbytes [ 4 ] != outbytes [ 4 ] ) { jagobj_t * pl ; S_Clear ( ) ; pl = W_CacheLumpName ( "neterror" , PU_STATIC ) ; DrawPlaque ( pl , "neterror" ) ; Z_Free ( pl ) ; <S2SV_StartBug> wait ( 200 ) ; <S2SV_EndBug> goto reconnect ; } val = ( inbytes [ 0 ] << 24 ) + ( inbytes [ 1 ] << 16 ) + ( inbytes [ 2 ] << 8 ) + inbytes [ 3 ] ; return val ; reconnect : S_Clear ( ) ; if ( consoleplayer ) <S2SV_StartBug> wait ( 15 ) ; <S2SV_EndBug> I_NetSetup ( ) ; if ( starttype == gt_single ) Jag68k_main ( myargc , myargv ) ; G_PlayerReborn ( 0 ) ; G_PlayerReborn ( 1 ) ; gameaction = ga_warped ; ticbuttons [ 0 ] = ticbuttons [ 1 ] = oldticbuttons [ 0 ] = oldticbuttons [ 1 ] = 0 ; return 0 ; } | <S2SV_ModStart> pl ) ; I_Wait <S2SV_ModEnd> ( 200 ) <S2SV_ModStart> ( consoleplayer ) I_Wait <S2SV_ModEnd> ( 15 ) |
968 | CWE-000 static int handle_file_collision ( struct merge_options * o , const char * collide_path , const char * prev_path1 , const char * prev_path2 , const char * branch1 , const char * branch2 , const struct object_id * a_oid , unsigned int a_mode , const struct object_id * b_oid , unsigned int b_mode , unsigned int conflict_markers_already_present ) { struct merge_file_info mfi ; struct diff_filespec null , a , b ; <S2SV_StartBug> int minimum_score ; <S2SV_EndBug> if ( prev_path1 ) remove_file ( o , 1 , prev_path1 , o -> call_depth || would_lose_untracked ( prev_path1 ) ) ; if ( prev_path2 ) remove_file ( o , 1 , prev_path2 , o -> call_depth || would_lose_untracked ( prev_path2 ) ) ; if ( was_dirty ( o , collide_path ) ) output ( o , 1 , _ ( "Refusing<S2SV_blank>to<S2SV_blank>lose<S2SV_blank>dirty<S2SV_blank>file<S2SV_blank>at<S2SV_blank>%s" ) , collide_path ) ; else if ( would_lose_untracked ( collide_path ) ) output ( o , 1 , _ ( "Refusing<S2SV_blank>to<S2SV_blank>lose<S2SV_blank>untracked<S2SV_blank>file<S2SV_blank>at<S2SV_blank>" "%s,<S2SV_blank>even<S2SV_blank>though<S2SV_blank>it\'s<S2SV_blank>in<S2SV_blank>the<S2SV_blank>way." ) , collide_path ) ; else remove_file ( o , 0 , collide_path , 0 ) ; memset ( & a , 0 , sizeof ( struct diff_filespec ) ) ; memset ( & b , 0 , sizeof ( struct diff_filespec ) ) ; null . path = a . path = b . path = ( char * ) collide_path ; oidcpy ( & null . oid , & null_oid ) ; null . mode = 0 ; oidcpy ( & a . oid , a_oid ) ; a . mode = a_mode ; a . oid_valid = 1 ; oidcpy ( & b . oid , b_oid ) ; b . mode = b_mode ; b . oid_valid = 1 ; minimum_score = o -> rename_score ? o -> rename_score : DEFAULT_RENAME_SCORE ; if ( ! conflict_markers_already_present && minimum_score <= estimate_similarity ( & a , & b , o -> rename_score ) ) { if ( merge_file_1 ( o , & null , & a , & b , branch1 , branch2 , & mfi ) ) return - 1 ; if ( update_file ( o , mfi . clean , & mfi . oid , mfi . mode , collide_path ) ) return - 1 ; if ( ! mfi . clean && ! o -> call_depth && update_stages ( o , collide_path , NULL , & a , & b ) ) return - 1 ; return mfi . clean ; } char * new_path1 = ( o -> call_depth && prev_path1 ) ? strdup ( prev_path1 ) : unique_path ( o , collide_path , branch1 ) ; char * new_path2 = ( o -> call_depth && prev_path2 ) ? strdup ( prev_path2 ) : unique_path ( o , collide_path , branch2 ) ; output ( o , 1 , _ ( "Renaming<S2SV_blank>collisions<S2SV_blank>at<S2SV_blank>%s<S2SV_blank>to<S2SV_blank>%s<S2SV_blank>and<S2SV_blank>%s<S2SV_blank>instead" ) , collide_path , new_path1 , new_path2 ) ; if ( update_file ( o , 0 , a_oid , a_mode , new_path1 ) ) return - 1 ; if ( update_file ( o , 0 , b_oid , b_mode , new_path2 ) ) return - 1 ; if ( ! o -> call_depth ) { if ( o -> branch1 == branch1 ) { if ( update_stages ( o , collide_path , NULL , & a , & b ) ) return - 1 ; } else { if ( update_stages ( o , collide_path , NULL , & b , & a ) ) return - 1 ; } } free ( new_path2 ) ; free ( new_path1 ) ; return 0 ; } | <S2SV_ModStart> int minimum_score ; if ( branch1 != o -> branch1 ) { return handle_file_collision ( o , collide_path , prev_path2 , prev_path1 , branch2 , branch1 , b_oid , b_mode , a_oid , a_mode , conflict_markers_already_present ) ; } |
969 | CWE-000 static int add_client_context ( struct ib_device * device , struct ib_client * client ) { struct ib_client_data * context ; <S2SV_StartBug> unsigned long flags ; <S2SV_EndBug> <S2SV_StartBug> context = kmalloc ( sizeof * context , GFP_KERNEL ) ; <S2SV_EndBug> if ( ! context ) return - ENOMEM ; context -> client = client ; context -> data = NULL ; context -> going_down = false ; down_write ( & lists_rwsem ) ; <S2SV_StartBug> spin_lock_irqsave ( & device -> client_data_lock , flags ) ; <S2SV_EndBug> list_add ( & context -> list , & device -> client_data_list ) ; <S2SV_StartBug> spin_unlock_irqrestore ( & device -> client_data_lock , flags ) ; <S2SV_EndBug> up_write ( & lists_rwsem ) ; return 0 ; } | <S2SV_ModStart> * context ; <S2SV_ModEnd> context = kmalloc <S2SV_ModStart> kmalloc ( sizeof ( * context ) <S2SV_ModEnd> , GFP_KERNEL ) <S2SV_ModStart> lists_rwsem ) ; write_lock_irq <S2SV_ModEnd> ( & device <S2SV_ModStart> device -> client_data_lock <S2SV_ModEnd> ) ; list_add <S2SV_ModStart> client_data_list ) ; write_unlock_irq <S2SV_ModEnd> ( & device <S2SV_ModStart> device -> client_data_lock <S2SV_ModEnd> ) ; up_write |
970 | CWE-000 static void vtimer_state_init ( struct vcpu * vcpu , void * context ) { struct vtimer * vtimer ; struct vtimer_context * c = ( struct vtimer_context * ) context ; c -> offset = vcpu -> vm -> time_offset ; vtimer = & c -> virt_timer ; vtimer -> vcpu = vcpu ; <S2SV_StartBug> init_timer ( & vtimer -> timer ) ; <S2SV_EndBug> vtimer -> timer . function = virt_timer_expire_function ; vtimer -> timer . data = ( unsigned long ) vtimer ; vtimer -> virq = 27 ; vtimer -> cnt_ctl = 0 ; vtimer -> cnt_cval = 0 ; vtimer = & c -> phy_timer ; vtimer -> vcpu = vcpu ; <S2SV_StartBug> init_timer ( & vtimer -> timer ) ; <S2SV_EndBug> vtimer -> timer . function = phys_timer_expire_function ; vtimer -> timer . data = ( unsigned long ) vtimer ; vtimer -> virq = 30 ; vtimer -> cnt_ctl = 0 ; vtimer -> cnt_cval = 0 ; } | <S2SV_ModStart> = vcpu ; init_timer_on_cpu <S2SV_ModEnd> ( & vtimer <S2SV_ModStart> vtimer -> timer , get_pcpu_id ( vcpu ) <S2SV_ModStart> = vcpu ; init_timer_on_cpu <S2SV_ModEnd> ( & vtimer <S2SV_ModStart> vtimer -> timer , get_pcpu_id ( vcpu ) |
971 | CWE-000 static void do_trap_data_abort_guest ( struct cpu_user_regs * regs , const union hsr hsr ) { const struct hsr_dabt dabt = hsr . dabt ; int rc ; mmio_info_t info ; uint8_t fsc = hsr . dabt . dfsc & ~ FSC_LL_MASK ; mfn_t mfn ; if ( dabt . eat ) domain_crash_synchronous ( ) ; info . dabt = dabt ; # ifdef CONFIG_ARM_32 info . gva = READ_CP32 ( HDFAR ) ; # else info . gva = READ_SYSREG64 ( FAR_EL2 ) ; # endif if ( hpfar_is_valid ( dabt . s1ptw , fsc ) ) info . gpa = get_faulting_ipa ( info . gva ) ; else { rc = gva_to_ipa ( info . gva , & info . gpa , GV2M_READ ) ; if ( rc == - EFAULT ) return ; } switch ( fsc ) { case FSC_FLT_PERM : { const struct npfec npfec = { . read_access = ! dabt . write , . write_access = dabt . write , . gla_valid = 1 , . kind = dabt . s1ptw ? npfec_kind_in_gpt : npfec_kind_with_gla } ; p2m_mem_access_check ( info . gpa , info . gva , npfec ) ; return ; } case FSC_FLT_TRANS : if ( try_handle_mmio ( regs , & info ) ) { advance_pc ( regs , hsr ) ; return ; } <S2SV_StartBug> mfn = p2m_lookup ( current -> domain , _gfn ( paddr_to_pfn ( info . gpa ) ) , NULL ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ! mfn_eq ( mfn , INVALID_MFN ) ) <S2SV_EndBug> return ; if ( try_map_mmio ( _gfn ( paddr_to_pfn ( info . gpa ) ) ) ) return ; break ; default : gprintk ( XENLOG_WARNING , "Unsupported<S2SV_blank>DFSC:<S2SV_blank>HSR=%#x<S2SV_blank>DFSC=%#x\\n" , hsr . bits , dabt . dfsc ) ; } gdprintk ( XENLOG_DEBUG , "HSR=0x%x<S2SV_blank>pc=%#" PRIregister "<S2SV_blank>gva=%#" PRIvaddr "<S2SV_blank>gpa=%#" PRIpaddr "\\n" , hsr . bits , regs -> pc , info . gva , info . gpa ) ; inject_dabt_exception ( regs , info . gva , hsr . len ) ; } | <S2SV_ModStart> return ; } if ( likely ( ! altp2m_active <S2SV_ModEnd> ( current -> <S2SV_ModStart> current -> domain ) ) ) { mfn = p2m_lookup ( current -> domain <S2SV_ModStart> mfn , INVALID_MFN ) ) return ; } else if ( altp2m_lazy_copy ( current , _gfn ( paddr_to_pfn ( info . gpa ) ) |
972 | CWE-000 static NTSTATUS FspFsvolClose ( PDEVICE_OBJECT FsvolDeviceObject , PIRP Irp , PIO_STACK_LOCATION IrpSp ) { PAGED_CODE ( ) ; if ( ! FspFileNodeIsValid ( IrpSp -> FileObject -> FsContext ) ) return STATUS_SUCCESS ; PFILE_OBJECT FileObject = IrpSp -> FileObject ; FSP_FILE_NODE * FileNode = FileObject -> FsContext ; FSP_FILE_DESC * FileDesc = FileObject -> FsContext2 ; FSP_FSCTL_TRANSACT_REQ * Request ; ASSERT ( FileNode == FileDesc -> FileNode ) ; FspIopCreateRequestMustSucceed ( 0 , 0 , 0 , & Request ) ; Request -> Kind = FspFsctlTransactCloseKind ; Request -> Req . Close . UserContext = FileNode -> UserContext ; Request -> Req . Close . UserContext2 = FileDesc -> UserContext2 ; FspFileNodeClose ( FileNode , 0 , FALSE ) ; FspFileDescDelete ( FileDesc ) ; FspFileNodeDereference ( FileNode ) ; <S2SV_StartBug> FspIopPostWorkRequestBestEffort ( FsvolDeviceObject , Request ) ; <S2SV_EndBug> Irp -> IoStatus . Information = 0 ; return STATUS_SUCCESS ; } | <S2SV_ModStart> FileNode ) ; if ( FspFsvolDeviceFileRenameIsAcquiredExclusive ( FsvolDeviceObject ) ) { Request -> Hint = ( UINT_PTR ) Irp ; FspIrpSetRequest ( Irp , Request ) ; return FSP_STATUS_IOQ_POST_BEST_EFFORT ; } |
973 | CWE-000 int main ( int argc , char * * argv ) { char * * names = NULL ; var_entry_t * new_entry = NULL ; int num ; int ret = 0 ; ebm_mode mode = boot ; char * prefices [ ] = { "Boot" , "Driver" , "SysPrep" , } ; char * order_name [ ] = { "BootOrder" , "DriverOrder" , "SysPrepOrder" } ; putenv ( "LIBEFIBOOT_REPORT_GPT_ERRORS=1" ) ; set_default_opts ( ) ; parse_opts ( argc , argv ) ; if ( opts . showversion ) { printf ( "version<S2SV_blank>%s\\n" , EFIBOOTMGR_VERSION ) ; return 0 ; } verbose = opts . verbose ; if ( opts . sysprep && opts . driver ) errx ( 25 , "--sysprep<S2SV_blank>and<S2SV_blank>--driver<S2SV_blank>may<S2SV_blank>not<S2SV_blank>be<S2SV_blank>used<S2SV_blank>together." ) ; if ( opts . sysprep || opts . driver ) { if ( opts . bootnext >= 0 || opts . delete_bootnext ) errx ( 26 , "%s<S2SV_blank>mode<S2SV_blank>does<S2SV_blank>not<S2SV_blank>support<S2SV_blank>BootNext<S2SV_blank>options." , opts . sysprep ? "--sysprep" : "--driver" ) ; if ( opts . timeout >= 0 || opts . delete_timeout ) errx ( 27 , "%s<S2SV_blank>mode<S2SV_blank>does<S2SV_blank>not<S2SV_blank>support<S2SV_blank>timeout<S2SV_blank>options." , opts . sysprep ? "--sysprep" : "--driver" ) ; if ( opts . sysprep ) mode = sysprep ; if ( opts . driver ) mode = driver ; } if ( ! efi_variables_supported ( ) ) errorx ( 2 , "EFI<S2SV_blank>variables<S2SV_blank>are<S2SV_blank>not<S2SV_blank>supported<S2SV_blank>on<S2SV_blank>this<S2SV_blank>system." ) ; read_var_names ( prefices [ mode ] , & names ) ; read_vars ( names , & entry_list ) ; set_var_nums ( prefices [ mode ] , & entry_list ) ; if ( opts . delete ) { if ( opts . num == - 1 ) errorx ( 3 , "You<S2SV_blank>must<S2SV_blank>specify<S2SV_blank>an<S2SV_blank>entry<S2SV_blank>to<S2SV_blank>delete<S2SV_blank>" "(see<S2SV_blank>the<S2SV_blank>-b<S2SV_blank>option)." ) ; else { ret = delete_var ( prefices [ mode ] , opts . num ) ; if ( ret < 0 ) error ( 15 , "Could<S2SV_blank>not<S2SV_blank>delete<S2SV_blank>variable" ) ; } } if ( opts . active >= 0 ) { if ( opts . num == - 1 ) { errorx ( 4 , "You<S2SV_blank>must<S2SV_blank>specify<S2SV_blank>a<S2SV_blank>entry<S2SV_blank>to<S2SV_blank>activate<S2SV_blank>(see<S2SV_blank>the<S2SV_blank>-b<S2SV_blank>option" ) ; } else { ret = set_active_state ( prefices [ mode ] ) ; if ( ret < 0 ) <S2SV_StartBug> error ( 16 , "%s" , <S2SV_EndBug> "Could<S2SV_blank>not<S2SV_blank>set<S2SV_blank>active<S2SV_blank>state<S2SV_blank>for<S2SV_blank>%s%04X" , prefices [ mode ] , opts . num ) ; } } if ( opts . create ) { warn_duplicate_name ( & entry_list ) ; new_entry = make_var ( prefices [ mode ] , & entry_list ) ; if ( ! new_entry ) error ( 5 , "Could<S2SV_blank>not<S2SV_blank>prepare<S2SV_blank>%s<S2SV_blank>variable" , prefices [ mode ] ) ; if ( new_entry && ! opts . no_order ) { ret = add_to_order ( order_name [ mode ] , new_entry -> num ) ; if ( ret < 0 ) error ( 6 , "Could<S2SV_blank>not<S2SV_blank>add<S2SV_blank>entry<S2SV_blank>to<S2SV_blank>%s" , order_name [ mode ] ) ; } } if ( opts . delete_order ) { ret = efi_del_variable ( EFI_GLOBAL_GUID , order_name [ mode ] ) ; if ( ret < 0 && errno != ENOENT ) error ( 7 , "Could<S2SV_blank>not<S2SV_blank>remove<S2SV_blank>entry<S2SV_blank>from<S2SV_blank>%s" , order_name [ mode ] ) ; } if ( opts . order ) { ret = set_order ( order_name [ mode ] , prefices [ mode ] , opts . keep_old_entries ) ; if ( ret < 0 ) error ( 8 , "Could<S2SV_blank>not<S2SV_blank>set<S2SV_blank>%s" , order_name [ mode ] ) ; } if ( opts . deduplicate ) { ret = remove_dupes_from_order ( order_name [ mode ] ) ; if ( ret ) error ( 9 , "Could<S2SV_blank>not<S2SV_blank>set<S2SV_blank>%s" , order_name [ mode ] ) ; } if ( opts . delete_bootnext ) { if ( ! is_current_entry ( opts . delete_bootnext ) ) errorx ( 17 , "Boot<S2SV_blank>entry<S2SV_blank>%04X<S2SV_blank>does<S2SV_blank>not<S2SV_blank>exist" , opts . delete_bootnext ) ; ret = efi_del_variable ( EFI_GLOBAL_GUID , "BootNext" ) ; if ( ret < 0 ) error ( 10 , "Could<S2SV_blank>not<S2SV_blank>delete<S2SV_blank>BootNext" ) ; } if ( opts . delete_timeout ) { ret = efi_del_variable ( EFI_GLOBAL_GUID , "Timeout" ) ; if ( ret < 0 ) error ( 11 , "Could<S2SV_blank>not<S2SV_blank>delete<S2SV_blank>Timeout" ) ; } if ( opts . bootnext >= 0 ) { if ( ! is_current_entry ( opts . bootnext & 0xFFFF ) ) errorx ( 12 , "Boot<S2SV_blank>entry<S2SV_blank>%X<S2SV_blank>does<S2SV_blank>not<S2SV_blank>exist" , opts . bootnext ) ; ret = set_u16 ( "BootNext" , opts . bootnext & 0xFFFF ) ; if ( ret < 0 ) error ( 13 , "Could<S2SV_blank>not<S2SV_blank>set<S2SV_blank>BootNext" ) ; } if ( opts . set_timeout ) { ret = set_u16 ( "Timeout" , opts . timeout ) ; if ( ret < 0 ) error ( 14 , "Could<S2SV_blank>not<S2SV_blank>set<S2SV_blank>Timeout" ) ; } if ( opts . set_mirror_lo || opts . set_mirror_hi ) { ret = set_mirror ( opts . below4g , opts . above4g ) ; } if ( ! opts . quiet && ret == 0 ) { switch ( mode ) { case boot : num = read_u16 ( "BootNext" ) ; cond_warning ( opts . verbose >= 2 && num < 0 , "Could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>variable<S2SV_blank>\'BootNext\'" ) ; if ( num >= 0 ) printf ( "BootNext:<S2SV_blank>%04X\\n" , num ) ; num = read_u16 ( "BootCurrent" ) ; cond_warning ( opts . verbose >= 2 && num < 0 , "Could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>variable<S2SV_blank>\'BootCurrent\'" ) ; if ( num >= 0 ) printf ( "BootCurrent:<S2SV_blank>%04X\\n" , num ) ; num = read_u16 ( "Timeout" ) ; cond_warning ( opts . verbose >= 2 && num < 0 , "Could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>variable<S2SV_blank>\'Timeout\'" ) ; if ( num >= 0 ) printf ( "Timeout:<S2SV_blank>%u<S2SV_blank>seconds\\n" , num ) ; show_order ( order_name [ mode ] ) ; show_vars ( prefices [ mode ] ) ; show_mirror ( ) ; break ; case driver : case sysprep : show_order ( order_name [ mode ] ) ; show_vars ( prefices [ mode ] ) ; break ; } } free_vars ( & entry_list ) ; free_array ( names ) ; if ( ret ) return 1 ; return 0 ; } | <S2SV_ModStart> ( 16 , <S2SV_ModEnd> "Could<S2SV_blank>not<S2SV_blank>set<S2SV_blank>active<S2SV_blank>state<S2SV_blank>for<S2SV_blank>%s%04X" , prefices |
974 | CWE-000 int wc_HashGetDigestSize ( enum wc_HashType hash_type ) { int dig_size = HASH_TYPE_E ; switch ( hash_type ) { case WC_HASH_TYPE_MD2 : # ifdef WOLFSSL_MD2 dig_size = MD2_DIGEST_SIZE ; # endif break ; case WC_HASH_TYPE_MD4 : # ifndef NO_MD4 dig_size = MD4_DIGEST_SIZE ; # endif break ; case WC_HASH_TYPE_MD5 : # ifndef NO_MD5 dig_size = WC_MD5_DIGEST_SIZE ; # endif break ; case WC_HASH_TYPE_SHA : # ifndef NO_SHA dig_size = WC_SHA_DIGEST_SIZE ; # endif break ; case WC_HASH_TYPE_SHA224 : # ifdef WOLFSSL_SHA224 dig_size = WC_SHA224_DIGEST_SIZE ; # endif break ; case WC_HASH_TYPE_SHA256 : # ifndef NO_SHA256 dig_size = WC_SHA256_DIGEST_SIZE ; # endif break ; case WC_HASH_TYPE_SHA384 : <S2SV_StartBug> # if defined ( WOLFSSL_SHA512 ) && defined ( WOLFSSL_SHA384 ) <S2SV_EndBug> dig_size = WC_SHA384_DIGEST_SIZE ; # endif break ; case WC_HASH_TYPE_SHA512 : # ifdef WOLFSSL_SHA512 dig_size = WC_SHA512_DIGEST_SIZE ; # endif break ; case WC_HASH_TYPE_MD5_SHA : # if ! defined ( NO_MD5 ) && ! defined ( NO_SHA ) dig_size = WC_MD5_DIGEST_SIZE + WC_SHA_DIGEST_SIZE ; # endif break ; case WC_HASH_TYPE_SHA3_224 : # ifdef WOLFSSL_SHA3 dig_size = WC_SHA3_224_DIGEST_SIZE ; # endif break ; case WC_HASH_TYPE_SHA3_256 : # ifdef WOLFSSL_SHA3 dig_size = WC_SHA3_256_DIGEST_SIZE ; # endif break ; case WC_HASH_TYPE_SHA3_384 : # ifdef WOLFSSL_SHA3 dig_size = WC_SHA3_384_DIGEST_SIZE ; # endif break ; case WC_HASH_TYPE_SHA3_512 : # ifdef WOLFSSL_SHA3 dig_size = WC_SHA3_512_DIGEST_SIZE ; # endif break ; case WC_HASH_TYPE_BLAKE2B : case WC_HASH_TYPE_NONE : default : dig_size = BAD_FUNC_ARG ; break ; } return dig_size ; } | <S2SV_ModStart> WC_HASH_TYPE_SHA384 : # ifdef WOLFSSL_SHA384 <S2SV_ModEnd> dig_size = WC_SHA384_DIGEST_SIZE |
975 | CWE-000 int main ( int argc , char * * argv ) { GOptionContext * options ; GError * error = NULL ; options = g_option_context_new ( NULL ) ; g_option_context_add_main_entries ( options , entries , NULL ) ; if ( ! g_option_context_parse ( options , & argc , & argv , & error ) ) { g_print ( "Failed<S2SV_blank>to<S2SV_blank>parse<S2SV_blank>options:<S2SV_blank>%s\\n" , error -> message ) ; return 1 ; } if ( disable_audio && disable_video ) { g_print ( "Audio<S2SV_blank>and<S2SV_blank>video<S2SV_blank>disabled.<S2SV_blank>Nothing<S2SV_blank>to<S2SV_blank>do.\\n" ) ; return 0 ; } OwrPayload * receive_payload ; owr_init ( NULL ) ; bus = owr_bus_new ( ) ; owr_bus_set_message_callback ( bus , ( OwrBusMessageCallback ) bus_message_print_callback , message_origin_name_func , NULL ) ; if ( ! print_messages ) { g_object_set ( bus , "message-type-mask" , OWR_MESSAGE_TYPE_ERROR , NULL ) ; } owr_bus_add_message_origin ( bus , OWR_MESSAGE_ORIGIN ( owr_window_registry_get ( ) ) ) ; <S2SV_StartBug> recv_transport_agent = owr_transport_agent_new ( FALSE ) ; <S2SV_EndBug> g_assert ( OWR_IS_TRANSPORT_AGENT ( recv_transport_agent ) ) ; owr_bus_add_message_origin ( bus , OWR_MESSAGE_ORIGIN ( recv_transport_agent ) ) ; owr_transport_agent_set_local_port_range ( recv_transport_agent , 5120 , 5127 ) ; if ( ! remote_addr ) owr_transport_agent_add_local_address ( recv_transport_agent , "127.0.0.1" ) ; else if ( local_addr ) owr_transport_agent_add_local_address ( recv_transport_agent , local_addr ) ; <S2SV_StartBug> send_transport_agent = owr_transport_agent_new ( TRUE ) ; <S2SV_EndBug> g_assert ( OWR_IS_TRANSPORT_AGENT ( send_transport_agent ) ) ; owr_bus_add_message_origin ( bus , OWR_MESSAGE_ORIGIN ( send_transport_agent ) ) ; owr_transport_agent_set_local_port_range ( send_transport_agent , 5120 , 5129 ) ; if ( ! remote_addr ) owr_transport_agent_add_local_address ( send_transport_agent , "127.0.0.1" ) ; if ( ! disable_video ) { recv_session_video = owr_media_session_new ( FALSE ) ; owr_bus_add_message_origin ( bus , OWR_MESSAGE_ORIGIN ( recv_session_video ) ) ; send_session_video = owr_media_session_new ( TRUE ) ; owr_bus_add_message_origin ( bus , OWR_MESSAGE_ORIGIN ( send_session_video ) ) ; } if ( ! disable_audio ) { recv_session_audio = owr_media_session_new ( FALSE ) ; owr_bus_add_message_origin ( bus , OWR_MESSAGE_ORIGIN ( recv_session_audio ) ) ; send_session_audio = owr_media_session_new ( TRUE ) ; owr_bus_add_message_origin ( bus , OWR_MESSAGE_ORIGIN ( send_session_audio ) ) ; } if ( ! disable_video ) { g_signal_connect ( recv_session_video , "on-new-candidate" , G_CALLBACK ( got_candidate ) , send_session_video ) ; g_signal_connect ( send_session_video , "on-new-candidate" , G_CALLBACK ( got_candidate ) , recv_session_video ) ; if ( remote_addr ) { g_signal_connect ( recv_session_video , "on-candidate-gathering-done" , G_CALLBACK ( gathering_done ) , send_session_video ) ; g_signal_connect ( send_session_video , "on-candidate-gathering-done" , G_CALLBACK ( gathering_done ) , recv_session_video ) ; owr_session_set_local_port ( OWR_SESSION ( send_session_video ) , OWR_COMPONENT_TYPE_RTP , 5120 ) ; owr_session_set_local_port ( OWR_SESSION ( send_session_video ) , OWR_COMPONENT_TYPE_RTCP , 5121 ) ; owr_session_set_local_port ( OWR_SESSION ( recv_session_video ) , OWR_COMPONENT_TYPE_RTP , 5122 ) ; owr_session_set_local_port ( OWR_SESSION ( recv_session_video ) , OWR_COMPONENT_TYPE_RTCP , 5123 ) ; } } if ( ! disable_audio ) { g_signal_connect ( recv_session_audio , "on-new-candidate" , G_CALLBACK ( got_candidate ) , send_session_audio ) ; g_signal_connect ( send_session_audio , "on-new-candidate" , G_CALLBACK ( got_candidate ) , recv_session_audio ) ; if ( remote_addr ) { g_signal_connect ( recv_session_audio , "on-candidate-gathering-done" , G_CALLBACK ( gathering_done ) , send_session_audio ) ; g_signal_connect ( send_session_audio , "on-candidate-gathering-done" , G_CALLBACK ( gathering_done ) , recv_session_audio ) ; owr_session_set_local_port ( OWR_SESSION ( send_session_audio ) , OWR_COMPONENT_TYPE_RTP , 5124 ) ; owr_session_set_local_port ( OWR_SESSION ( send_session_audio ) , OWR_COMPONENT_TYPE_RTCP , 5125 ) ; owr_session_set_local_port ( OWR_SESSION ( recv_session_audio ) , OWR_COMPONENT_TYPE_RTP , 5126 ) ; owr_session_set_local_port ( OWR_SESSION ( recv_session_audio ) , OWR_COMPONENT_TYPE_RTCP , 5127 ) ; } } if ( ! disable_video ) { g_signal_connect ( recv_session_video , "on-incoming-source" , G_CALLBACK ( got_remote_source ) , NULL ) ; receive_payload = owr_video_payload_new ( OWR_CODEC_TYPE_VP8 , 103 , 90000 , TRUE , FALSE ) ; g_object_set ( receive_payload , "rtx-payload-type" , 123 , NULL ) ; if ( adaptation ) g_object_set ( receive_payload , "adaptation" , TRUE , NULL ) ; owr_media_session_add_receive_payload ( recv_session_video , receive_payload ) ; } if ( ! disable_audio ) { g_signal_connect ( recv_session_audio , "on-incoming-source" , G_CALLBACK ( got_remote_source ) , NULL ) ; receive_payload = owr_audio_payload_new ( OWR_CODEC_TYPE_OPUS , 100 , 48000 , 1 ) ; owr_media_session_add_receive_payload ( recv_session_audio , receive_payload ) ; } if ( ! uri ) { owr_get_capture_sources ( ( ! disable_video ? OWR_MEDIA_TYPE_VIDEO : 0 ) | ( ! disable_audio ? OWR_MEDIA_TYPE_AUDIO : 0 ) , got_sources , NULL ) ; } else { uri_source_agent = owr_uri_source_agent_new ( uri ) ; g_signal_connect ( uri_source_agent , "on-new-source" , G_CALLBACK ( on_new_source ) , NULL ) ; owr_uri_source_agent_play ( uri_source_agent ) ; } g_timeout_add_seconds ( 10 , ( GSourceFunc ) dump_cb , NULL ) ; owr_run ( ) ; g_free ( remote_addr ) ; g_free ( uri ) ; return 0 ; } | <S2SV_ModStart> owr_transport_agent_new ( FALSE , FALSE , FALSE <S2SV_ModStart> owr_transport_agent_new ( TRUE , FALSE , FALSE |
976 | CWE-000 static void dce_virtual_set_crtc_vblank_interrupt_state ( struct amdgpu_device * adev , int crtc , enum amdgpu_interrupt_state state ) { <S2SV_StartBug> if ( crtc >= adev -> mode_info . num_crtc ) { <S2SV_EndBug> DRM_DEBUG ( "invalid<S2SV_blank>crtc<S2SV_blank>%d\\n" , crtc ) ; return ; } if ( state && ! adev -> mode_info . crtcs [ crtc ] -> vsync_timer_enabled ) { DRM_DEBUG ( "Enable<S2SV_blank>software<S2SV_blank>vsync<S2SV_blank>timer\\n" ) ; hrtimer_init ( & adev -> mode_info . crtcs [ crtc ] -> vblank_timer , CLOCK_MONOTONIC , HRTIMER_MODE_REL ) ; hrtimer_set_expires ( & adev -> mode_info . crtcs [ crtc ] -> vblank_timer , DCE_VIRTUAL_VBLANK_PERIOD ) ; adev -> mode_info . crtcs [ crtc ] -> vblank_timer . function = dce_virtual_vblank_timer_handle ; hrtimer_start ( & adev -> mode_info . crtcs [ crtc ] -> vblank_timer , DCE_VIRTUAL_VBLANK_PERIOD , HRTIMER_MODE_REL ) ; } else if ( ! state && adev -> mode_info . crtcs [ crtc ] -> vsync_timer_enabled ) { DRM_DEBUG ( "Disable<S2SV_blank>software<S2SV_blank>vsync<S2SV_blank>timer\\n" ) ; hrtimer_cancel ( & adev -> mode_info . crtcs [ crtc ] -> vblank_timer ) ; } adev -> mode_info . crtcs [ crtc ] -> vsync_timer_enabled = state ; DRM_DEBUG ( "[FM]set<S2SV_blank>crtc<S2SV_blank>%d<S2SV_blank>vblank<S2SV_blank>interrupt<S2SV_blank>state<S2SV_blank>%d\\n" , crtc , state ) ; } | <S2SV_ModStart> mode_info . num_crtc || ! adev -> mode_info . crtcs [ crtc ] |
977 | CWE-000 static int open_socket ( const char * path ) { <S2SV_StartBug> int fd = socket ( AF_UNIX , SOCK_STREAM , 0 ) ; <S2SV_EndBug> struct sockaddr_un addr ; if ( fd < 0 ) return fd ; addr . sun_family = AF_UNIX ; if ( snprintf ( addr . sun_path , sizeof ( addr . sun_path ) , "%s" , path ) >= <S2SV_StartBug> sizeof ( addr . sun_path ) ) <S2SV_EndBug> log_err ( "%s:<S2SV_blank>path<S2SV_blank>name<S2SV_blank>%s<S2SV_blank>is<S2SV_blank>too<S2SV_blank>long<S2SV_blank>for<S2SV_blank>a<S2SV_blank>Unix<S2SV_blank>socket\\n" , __func__ , path ) ; <S2SV_StartBug> if ( connect ( fd , ( const struct sockaddr * ) & addr , strlen ( path ) + sizeof ( addr . sun_family ) ) == 0 ) <S2SV_EndBug> return fd ; <S2SV_StartBug> else <S2SV_EndBug> close ( fd ) ; return - 1 ; } | <S2SV_ModStart> path ) { struct sockaddr_un addr ; int ret , fd ; <S2SV_ModEnd> fd = socket <S2SV_ModStart> , 0 ) <S2SV_ModEnd> ; if ( <S2SV_ModStart> sun_path ) ) { <S2SV_ModStart> path ) ; } ret = <S2SV_ModEnd> connect ( fd <S2SV_ModStart> sun_family ) ) ; if ( ! ret <S2SV_ModEnd> ) return fd <S2SV_ModStart> return fd ; <S2SV_ModEnd> close ( fd |
978 | CWE-000 static int vfio_iommu_type1_attach_group ( void * iommu_data , struct iommu_group * iommu_group ) { struct vfio_iommu * iommu = iommu_data ; struct vfio_group * group ; struct vfio_domain * domain , * d ; struct bus_type * bus = NULL , * mdev_bus ; int ret ; bool resv_msi , msi_remap ; phys_addr_t resv_msi_base ; mutex_lock ( & iommu -> lock ) ; list_for_each_entry ( d , & iommu -> domain_list , next ) { if ( find_iommu_group ( d , iommu_group ) ) { mutex_unlock ( & iommu -> lock ) ; return - EINVAL ; } } if ( iommu -> external_domain ) { if ( find_iommu_group ( iommu -> external_domain , iommu_group ) ) { mutex_unlock ( & iommu -> lock ) ; return - EINVAL ; } } group = kzalloc ( sizeof ( * group ) , GFP_KERNEL ) ; domain = kzalloc ( sizeof ( * domain ) , GFP_KERNEL ) ; if ( ! group || ! domain ) { ret = - ENOMEM ; goto out_free ; } group -> iommu_group = iommu_group ; ret = iommu_group_for_each_dev ( iommu_group , & bus , vfio_bus_type ) ; if ( ret ) goto out_free ; mdev_bus = symbol_get ( mdev_bus_type ) ; if ( mdev_bus ) { if ( ( bus == mdev_bus ) && ! iommu_present ( bus ) ) { symbol_put ( mdev_bus_type ) ; if ( ! iommu -> external_domain ) { INIT_LIST_HEAD ( & domain -> group_list ) ; iommu -> external_domain = domain ; } else kfree ( domain ) ; list_add ( & group -> next , & iommu -> external_domain -> group_list ) ; mutex_unlock ( & iommu -> lock ) ; return 0 ; } symbol_put ( mdev_bus_type ) ; } domain -> domain = iommu_domain_alloc ( bus ) ; if ( ! domain -> domain ) { ret = - EIO ; goto out_free ; } if ( iommu -> nesting ) { int attr = 1 ; ret = iommu_domain_set_attr ( domain -> domain , DOMAIN_ATTR_NESTING , & attr ) ; if ( ret ) goto out_domain ; } ret = iommu_attach_group ( domain -> domain , iommu_group ) ; if ( ret ) goto out_domain ; <S2SV_StartBug> resv_msi = vfio_iommu_has_resv_msi ( iommu_group , & resv_msi_base ) ; <S2SV_EndBug> INIT_LIST_HEAD ( & domain -> group_list ) ; list_add ( & group -> next , & domain -> group_list ) ; msi_remap = resv_msi ? irq_domain_check_msi_remap ( ) : iommu_capable ( bus , IOMMU_CAP_INTR_REMAP ) ; if ( ! allow_unsafe_interrupts && ! msi_remap ) { pr_warn ( "%s:<S2SV_blank>No<S2SV_blank>interrupt<S2SV_blank>remapping<S2SV_blank>support.<S2SV_blank><S2SV_blank>Use<S2SV_blank>the<S2SV_blank>module<S2SV_blank>param<S2SV_blank>\\"allow_unsafe_interrupts\\"<S2SV_blank>to<S2SV_blank>enable<S2SV_blank>VFIO<S2SV_blank>IOMMU<S2SV_blank>support<S2SV_blank>on<S2SV_blank>this<S2SV_blank>platform\\n" , __func__ ) ; ret = - EPERM ; goto out_detach ; } if ( iommu_capable ( bus , IOMMU_CAP_CACHE_COHERENCY ) ) domain -> prot |= IOMMU_CACHE ; list_for_each_entry ( d , & iommu -> domain_list , next ) { if ( d -> domain -> ops == domain -> domain -> ops && d -> prot == domain -> prot ) { iommu_detach_group ( domain -> domain , iommu_group ) ; if ( ! iommu_attach_group ( d -> domain , iommu_group ) ) { list_add ( & group -> next , & d -> group_list ) ; iommu_domain_free ( domain -> domain ) ; kfree ( domain ) ; mutex_unlock ( & iommu -> lock ) ; return 0 ; } ret = iommu_attach_group ( domain -> domain , iommu_group ) ; if ( ret ) goto out_domain ; } } vfio_test_domain_fgsp ( domain ) ; ret = vfio_iommu_replay ( iommu , domain ) ; if ( ret ) goto out_detach ; if ( resv_msi ) { ret = iommu_get_msi_cookie ( domain -> domain , resv_msi_base ) ; if ( ret ) goto out_detach ; } list_add ( & domain -> next , & iommu -> domain_list ) ; mutex_unlock ( & iommu -> lock ) ; return 0 ; out_detach : iommu_detach_group ( domain -> domain , iommu_group ) ; out_domain : iommu_domain_free ( domain -> domain ) ; out_free : kfree ( domain ) ; kfree ( group ) ; mutex_unlock ( & iommu -> lock ) ; return ret ; } | <S2SV_ModStart> ; resv_msi = vfio_iommu_has_sw_msi <S2SV_ModEnd> ( iommu_group , |
979 | CWE-000 void LCD_Config ( void ) { ili9341_Init ( ) ; <S2SV_StartBug> RCC -> APB2ENR |= RCC_APB2ENR_LTDCEN ; <S2SV_EndBug> LTDC -> GCR |= LTDC_GCR_LTDCEN ; LTDC -> SSCR |= 9ul << 16 | 1ul << 0 ; LTDC -> BPCR |= 29ul << 16 | 3ul << 0 ; LTDC -> AWCR |= 269ul << 16 | 323ul << 0 ; LTDC -> TWCR |= 279ul << 16 | 327ul << 0 ; <S2SV_StartBug> LTDC -> BCCR |= 0xfful << 16 | 0x00ul << 8 | 0x00ul << 0 ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> APB2ENR |= RCC_APB2ENR_LTDCEN <S2SV_ModEnd> ; LTDC -> <S2SV_ModStart> << 8 | 0xfful <S2SV_ModEnd> << 0 ; <S2SV_ModStart> << 0 ; LTDC -> GCR |= LTDC_GCR_LTDCEN ; |
980 | CWE-000 B3DPrimitiveEdge * b3dAddLowerEdgeFromFace ( B3DPrimitiveFace * face , B3DPrimitiveEdge * oldEdge ) { B3DPrimitiveVertex * v0 = face -> v0 ; B3DPrimitiveVertex * v1 = face -> v1 ; B3DPrimitiveVertex * v2 = face -> v2 ; int xValue = v1 -> windowPosX ; int index ; index = b3dFirstIndexForInserting ( addedEdges , xValue ) ; for ( ; index < addedEdges -> size ; index ++ ) { B3DPrimitiveEdge * edge = addedEdges -> data [ index ] ; if ( edge -> xValue != xValue ) break ; if ( edge -> rightFace ) continue ; if ( ( edge -> v0 == v1 && edge -> v1 == v2 ) || ( edge -> v0 -> windowPosX == v1 -> windowPosX && edge -> v0 -> windowPosY == v1 -> windowPosY && edge -> v0 -> rasterPosZ == v1 -> rasterPosZ && edge -> v1 -> windowPosX == v2 -> windowPosX && edge -> v1 -> windowPosY == v2 -> windowPosY && edge -> v1 -> rasterPosZ == v2 -> rasterPosZ ) ) { if ( face -> leftEdge == oldEdge ) face -> leftEdge = edge ; else face -> rightEdge = edge ; edge -> rightFace = face ; return edge ; } } { B3DPrimitiveEdge * minorEdge ; int nLines = ( v2 -> windowPosY >> B3D_FixedToIntShift ) - ( v1 -> windowPosY >> B3D_FixedToIntShift ) ; if ( ! nLines ) return NULL ; b3dAllocEdge ( edgeAlloc , minorEdge ) ; <S2SV_StartBug> if ( b3dDebug ) <S2SV_EndBug> if ( ! minorEdge ) <S2SV_StartBug> b3dAbort ( "Edge<S2SV_blank>allocation<S2SV_blank>failed" ) ; <S2SV_EndBug> minorEdge -> v0 = v1 ; minorEdge -> v1 = v2 ; minorEdge -> nLines = nLines ; minorEdge -> leftFace = face ; minorEdge -> rightFace = NULL ; if ( face -> leftEdge == oldEdge ) face -> leftEdge = minorEdge ; else face -> rightEdge = minorEdge ; b3dInitializeEdge ( minorEdge ) ; b3dAddEdgeBeforeIndex ( addedEdges , minorEdge , index ) ; return minorEdge ; } } | <S2SV_ModStart> ; if ( <S2SV_ModEnd> ! minorEdge ) <S2SV_ModStart> ! minorEdge ) return NULL <S2SV_ModEnd> ; minorEdge -> |
981 | CWE-000 Bool ComputeLocalClient ( ClientPtr client ) { const char * cmdname = GetClientCmdName ( client ) ; if ( ! xtransLocalClient ( client ) ) return FALSE ; if ( cmdname ) { char * cmd = strdup ( cmdname ) ; Bool ret ; <S2SV_StartBug> cmd = strtok ( cmd , ":" ) ; <S2SV_EndBug> # if ! defined ( WIN32 ) || defined ( __CYGWIN__ ) <S2SV_StartBug> ret = strcmp ( basename ( cmd ) , "ssh" ) != 0 ; <S2SV_EndBug> # else <S2SV_StartBug> ret = strcmp ( cmd , "ssh" ) != 0 ; <S2SV_EndBug> # endif free ( cmd ) ; return ret ; } return TRUE ; } | <S2SV_ModStart> Bool ret ; char * tok <S2SV_ModEnd> = strtok ( <S2SV_ModStart> ( basename ( tok <S2SV_ModEnd> ) , "ssh" <S2SV_ModStart> = strcmp ( tok <S2SV_ModEnd> , "ssh" ) |
982 | CWE-000 static void sys_dealloc ( PyObject * _self ) { sys_object * self = ( sys_object * ) _self ; PyObject_GC_UnTrack ( _self ) ; <S2SV_StartBug> if ( self -> sys ) { <S2SV_EndBug> addrxlat_sys_decref ( self -> sys ) ; self -> sys = NULL ; } <S2SV_StartBug> Py_XDECREF ( self -> convert ) ; <S2SV_EndBug> Py_TYPE ( self ) -> tp_free ( ( PyObject * ) self ) ; } | <S2SV_ModStart> _self ) ; Py_XDECREF ( self -> convert ) ; <S2SV_ModStart> NULL ; } <S2SV_ModEnd> Py_TYPE ( self |
983 | CWE-000 int main ( void ) { int i ; for ( i = 0 ; i < BUF_SIZE ; i ++ ) { packet [ i ] = i ; } gpio_enable_output ( 0 ) ; radio_init ( ) ; radio_set_addr ( 0x1540 ) ; radio_init ( ) ; radio_set_pan ( 0xABCD ) ; radio_init ( ) ; while ( 1 ) { led_toggle ( 0 ) ; int err = radio_send ( 0x0802 , packet , BUF_SIZE ) ; <S2SV_StartBug> if ( err != SUCCESS ) { <S2SV_EndBug> gpio_toggle ( 0 ) ; } delay_ms ( 250 ) ; } } | <S2SV_ModStart> ( err != TOCK_SUCCESS <S2SV_ModEnd> ) { gpio_toggle |
984 | CWE-000 static int fill_yin_extension ( struct lys_module * module , struct lyxml_elem * yin , struct lys_ext * ext , struct unres_schema * unres ) { const char * value ; struct lyxml_elem * child , * node , * next , * next2 ; int c_ext = 0 , rc ; GETVAL ( value , yin , "name" ) ; if ( lyp_check_identifier ( value , LY_IDENT_EXTENSION , module , NULL ) ) { goto error ; } ext -> name = lydict_insert ( module -> ctx , value , strlen ( value ) ) ; if ( read_yin_common ( module , NULL , ext , LYEXT_PAR_EXT , yin , OPT_MODULE , unres ) ) { goto error ; } LY_TREE_FOR_SAFE ( yin -> child , next , node ) { if ( strcmp ( node -> ns -> value , LY_NSYIN ) ) { c_ext ++ ; } else if ( ! strcmp ( node -> name , "argument" ) ) { GETVAL ( value , node , "name" ) ; ext -> argument = lydict_insert ( module -> ctx , value , strlen ( value ) ) ; LY_TREE_FOR_SAFE ( node -> child , next2 , child ) { if ( child -> ns == node -> ns && ! strcmp ( child -> name , "yin-element" ) ) { GETVAL ( value , child , "value" ) ; if ( ly_strequal ( value , "true" , 0 ) ) { ext -> flags |= LYS_YINELEM ; } } else if ( child -> ns ) { LOGVAL ( LYE_INCHILDSTMT , LY_VLOG_NONE , NULL , child -> name , child -> name ) ; goto error ; } } lyxml_free ( module -> ctx , node ) ; } else { LOGVAL ( LYE_INCHILDSTMT , LY_VLOG_NONE , NULL , node -> name , node -> name ) ; goto error ; } } if ( c_ext ) { ext -> ext = calloc ( c_ext , sizeof * ext -> ext ) ; if ( ! ext -> ext ) { LOGMEM ; goto error ; } LY_TREE_FOR_SAFE ( yin -> child , next , node ) { <S2SV_StartBug> rc = lyp_yin_fill_ext ( ext , LYEXT_PAR_EXT , 0 , 0 , module , node , & ext -> ext [ ext -> ext_size ] , unres ) ; <S2SV_EndBug> ext -> ext_size ++ ; if ( rc ) { goto error ; } } } ext -> plugin = ext_get_plugin ( ext -> name , ext -> module -> name , ext -> module -> rev ? ext -> module -> rev [ 0 ] . date : NULL ) ; return EXIT_SUCCESS ; error : return EXIT_FAILURE ; } | <S2SV_ModStart> ext -> ext , <S2SV_ModEnd> ext -> ext_size <S2SV_ModStart> ext -> ext_size <S2SV_ModEnd> , unres ) |
985 | CWE-000 static unsigned int tcp_xmit_size_goal ( struct sock * sk , u32 mss_now , int large_allowed ) { struct tcp_sock * tp = tcp_sk ( sk ) ; u32 xmit_size_goal , old_size_goal ; xmit_size_goal = mss_now ; if ( large_allowed && sk_can_gso ( sk ) ) { <S2SV_StartBug> xmit_size_goal = ( ( sk -> sk_gso_max_size - 1 ) - <S2SV_EndBug> inet_csk ( sk ) -> icsk_af_ops -> net_header_len - inet_csk ( sk ) -> icsk_ext_hdr_len - tp -> tcp_header_len ) ; xmit_size_goal = tcp_bound_to_half_wnd ( tp , xmit_size_goal ) ; old_size_goal = tp -> xmit_size_goal_segs * mss_now ; if ( likely ( old_size_goal <= xmit_size_goal && old_size_goal + mss_now > xmit_size_goal ) ) { xmit_size_goal = old_size_goal ; } else { tp -> xmit_size_goal_segs = min_t ( u16 , xmit_size_goal / mss_now , sk -> sk_gso_max_segs ) ; xmit_size_goal = tp -> xmit_size_goal_segs * mss_now ; } } return max ( xmit_size_goal , mss_now ) ; } | <S2SV_ModStart> ) ) { u32 gso_size , hlen ; hlen = inet_csk ( sk ) -> icsk_af_ops -> net_header_len + inet_csk ( sk ) -> icsk_ext_hdr_len + tp -> tcp_header_len ; gso_size = sk -> sk_pacing_rate / ( 2 * MSEC_PER_SEC ) ; gso_size = max_t ( u32 , gso_size , sysctl_tcp_min_tso_segs * mss_now ) ; xmit_size_goal = min_t ( u32 , gso_size , <S2SV_ModEnd> sk -> sk_gso_max_size <S2SV_ModStart> sk_gso_max_size - 1 - hlen ) ; xmit_size_goal = min_t ( u32 , xmit_size_goal , sysctl_tcp_limit_output_bytes >> 1 ) ; * / <S2SV_ModEnd> xmit_size_goal = tcp_bound_to_half_wnd |
986 | CWE-000 int memory_failure ( unsigned long pfn , int trapno , int flags ) { struct page * p ; struct page * hpage ; struct page * orig_head ; int res ; unsigned long page_flags ; if ( ! sysctl_memory_failure_recovery ) panic ( "Memory<S2SV_blank>failure<S2SV_blank>from<S2SV_blank>trap<S2SV_blank>%d<S2SV_blank>on<S2SV_blank>page<S2SV_blank>%lx" , trapno , pfn ) ; if ( ! pfn_valid ( pfn ) ) { pr_err ( "Memory<S2SV_blank>failure:<S2SV_blank>%#lx:<S2SV_blank>memory<S2SV_blank>outside<S2SV_blank>kernel<S2SV_blank>control\\n" , pfn ) ; return - ENXIO ; } p = pfn_to_page ( pfn ) ; if ( PageHuge ( p ) ) return memory_failure_hugetlb ( pfn , trapno , flags ) ; if ( TestSetPageHWPoison ( p ) ) { pr_err ( "Memory<S2SV_blank>failure:<S2SV_blank>%#lx:<S2SV_blank>already<S2SV_blank>hardware<S2SV_blank>poisoned\\n" , pfn ) ; return 0 ; } <S2SV_StartBug> arch_unmap_kpfn ( pfn ) ; <S2SV_EndBug> orig_head = hpage = compound_head ( p ) ; num_poisoned_pages_inc ( ) ; if ( ! ( flags & MF_COUNT_INCREASED ) && ! get_hwpoison_page ( p ) ) { if ( is_free_buddy_page ( p ) ) { action_result ( pfn , MF_MSG_BUDDY , MF_DELAYED ) ; return 0 ; } else { action_result ( pfn , MF_MSG_KERNEL_HIGH_ORDER , MF_IGNORED ) ; return - EBUSY ; } } if ( PageTransHuge ( hpage ) ) { lock_page ( p ) ; if ( ! PageAnon ( p ) || unlikely ( split_huge_page ( p ) ) ) { unlock_page ( p ) ; if ( ! PageAnon ( p ) ) pr_err ( "Memory<S2SV_blank>failure:<S2SV_blank>%#lx:<S2SV_blank>non<S2SV_blank>anonymous<S2SV_blank>thp\\n" , pfn ) ; else pr_err ( "Memory<S2SV_blank>failure:<S2SV_blank>%#lx:<S2SV_blank>thp<S2SV_blank>split<S2SV_blank>failed\\n" , pfn ) ; if ( TestClearPageHWPoison ( p ) ) num_poisoned_pages_dec ( ) ; put_hwpoison_page ( p ) ; return - EBUSY ; } unlock_page ( p ) ; VM_BUG_ON_PAGE ( ! page_count ( p ) , p ) ; hpage = compound_head ( p ) ; } shake_page ( p , 0 ) ; if ( ! PageLRU ( p ) && is_free_buddy_page ( p ) ) { if ( flags & MF_COUNT_INCREASED ) action_result ( pfn , MF_MSG_BUDDY , MF_DELAYED ) ; else action_result ( pfn , MF_MSG_BUDDY_2ND , MF_DELAYED ) ; return 0 ; } lock_page ( p ) ; if ( PageCompound ( p ) && compound_head ( p ) != orig_head ) { action_result ( pfn , MF_MSG_DIFFERENT_COMPOUND , MF_IGNORED ) ; res = - EBUSY ; goto out ; } if ( PageHuge ( p ) ) page_flags = hpage -> flags ; else page_flags = p -> flags ; if ( ! PageHWPoison ( p ) ) { pr_err ( "Memory<S2SV_blank>failure:<S2SV_blank>%#lx:<S2SV_blank>just<S2SV_blank>unpoisoned\\n" , pfn ) ; num_poisoned_pages_dec ( ) ; unlock_page ( p ) ; put_hwpoison_page ( p ) ; return 0 ; } if ( hwpoison_filter ( p ) ) { if ( TestClearPageHWPoison ( p ) ) num_poisoned_pages_dec ( ) ; unlock_page ( p ) ; put_hwpoison_page ( p ) ; return 0 ; } if ( ! PageTransTail ( p ) && ! PageLRU ( p ) ) goto identify_page_state ; wait_on_page_writeback ( p ) ; if ( ! hwpoison_user_mappings ( p , pfn , trapno , flags , & hpage ) ) { action_result ( pfn , MF_MSG_UNMAP_FAILED , MF_IGNORED ) ; res = - EBUSY ; goto out ; } if ( PageLRU ( p ) && ! PageSwapCache ( p ) && p -> mapping == NULL ) { action_result ( pfn , MF_MSG_TRUNCATED_LRU , MF_IGNORED ) ; res = - EBUSY ; goto out ; } identify_page_state : res = identify_page_state ( pfn , p , page_flags ) ; out : unlock_page ( p ) ; return res ; } | <S2SV_ModStart> 0 ; } <S2SV_ModEnd> orig_head = hpage |
987 | CWE-000 void handle_string ( t_pf * arg , t_buff * arg_buff , wchar_t * str ) { size_t str_bytes ; <S2SV_StartBug> prepare_string_arg ( arg ) ; <S2SV_EndBug> if ( arg -> specifier == 'S' ) str_bytes = wstr_bytes_to_print ( arg , str ) ; else str_bytes = str_bytes_to_print ( arg , ( char * ) str ) ; str_pre_padding ( arg , arg_buff , str_bytes ) ; if ( arg -> specifier == 's' ) fill_str ( arg_buff , ( char * ) str , str_bytes ) ; if ( arg -> specifier == 'S' ) fill_wide_str ( arg , arg_buff , str , str_bytes ) ; str_post_padding ( arg , arg_buff , str_bytes ) ; } | <S2SV_ModStart> arg ) ; if ( ! str ) { arg -> specifier = 's' ; str = ( wchar_t * ) "(null)" ; } |
988 | CWE-000 long long find_arg_location ( INSTRUCTION_DATABASE * instruction_database , int opcode , int arg ) { char opcode_str [ 3 ] ; if ( opcode < 256 ) sprintf ( opcode_str , "%02x" , opcode ) ; else if ( opcode == 256 ) sprintf ( opcode_str , "pe" ) ; else { ERROR_LOG ( "Invalid<S2SV_blank>opcode<S2SV_blank>for<S2SV_blank>finding<S2SV_blank>args\\n" ) ; return - 1 ; } char arg_string [ 30 ] ; <S2SV_StartBug> if ( arg != - 1 ) <S2SV_EndBug> <S2SV_StartBug> sprintf ( arg_string , "__arg_%s_%01x" , opcode_str , arg ) ; <S2SV_EndBug> else <S2SV_StartBug> sprintf ( arg_string , "__arg_%s_p" , opcode_str ) ; <S2SV_EndBug> int i = 0 ; char * symbol_table_address = instruction_database -> symbol_table_address ; char * string_table_address = instruction_database -> string_table_address ; int symbol_table_count = instruction_database -> symbol_count ; char symbol_name [ 256 ] ; for ( i = 0 ; i < instruction_database -> text_relocation_count ; i ++ ) { char * header_address = instruction_database -> text_relocation_address + 10 * i ; int type = * ( unsigned short * ) ( header_address + 8 ) ; if ( type == IMAGE_REL_AMD64_ADDR32 ) { int symbol_table_index = * ( unsigned int * ) ( header_address + 4 ) ; get_name_for_symbol ( symbol_name , symbol_table_address , symbol_table_index , string_table_address ) ; if ( strcmp ( symbol_name , arg_string ) == 0 ) { int RVA = * ( unsigned int * ) header_address ; if ( opcode < 256 ) return RVA - ( ( char * ) instruction_database -> instruction_translation_start [ opcode ] - instruction_database -> text_section_address ) ; else if ( opcode == 256 ) return RVA - ( ( char * ) instruction_database -> ppu_event_test - instruction_database -> text_section_address ) ; } } } return - 1 ; } | <S2SV_ModStart> if ( arg >= 0 ) sprintf ( arg_string , "__arg_%s_%01x" , opcode_str , arg ) ; else if ( arg == <S2SV_ModEnd> - 1 ) <S2SV_ModStart> ( arg_string , <S2SV_ModEnd> "__arg_%s_p" , opcode_str <S2SV_ModStart> opcode_str ) ; else if ( arg == - 2 ) sprintf ( arg_string , "__arg_%s_s" , opcode_str ) ; else { ERROR_LOG ( "Invalid<S2SV_blank>argument<S2SV_blank>number\\n" ) ; return - 1 ; } |
989 | CWE-000 static int qseecom_unload_app ( struct qseecom_dev_handle * data , bool app_crash ) { unsigned long flags ; unsigned long flags1 ; int ret = 0 ; struct qseecom_command_scm_resp resp ; struct qseecom_registered_app_list * ptr_app = NULL ; bool unload = false ; bool found_app = false ; bool found_dead_app = false ; if ( ! data ) { pr_err ( "Invalid/uninitialized<S2SV_blank>device<S2SV_blank>handle\\n" ) ; return - EINVAL ; } if ( ! memcmp ( data -> client . app_name , "keymaste" , sizeof ( "keymaste" ) - 1 ) ) { pr_debug ( "Do<S2SV_blank>not<S2SV_blank>unload<S2SV_blank>keymaster<S2SV_blank>app<S2SV_blank>from<S2SV_blank>tz\\n" ) ; goto unload_exit ; } __qseecom_cleanup_app ( data ) ; __qseecom_reentrancy_check_if_no_app_blocked ( TZ_OS_APP_SHUTDOWN_ID ) ; if ( data -> client . app_id > 0 ) { spin_lock_irqsave ( & qseecom . registered_app_list_lock , flags ) ; list_for_each_entry ( ptr_app , & qseecom . registered_app_list_head , list ) { if ( ptr_app -> app_id == data -> client . app_id ) { if ( ! strcmp ( ( void * ) ptr_app -> app_name , ( void * ) data -> client . app_name ) ) { <S2SV_StartBug> found_app = true ; <S2SV_EndBug> if ( app_crash || ptr_app -> ref_cnt == 1 ) unload = true ; break ; } else { found_dead_app = true ; break ; } } } spin_unlock_irqrestore ( & qseecom . registered_app_list_lock , flags ) ; if ( found_app == false && found_dead_app == false ) { pr_err ( "Cannot<S2SV_blank>find<S2SV_blank>app<S2SV_blank>with<S2SV_blank>id<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>(%s)\\n" , data -> client . app_id , ( char * ) data -> client . app_name ) ; ret = - EINVAL ; goto unload_exit ; } } if ( found_dead_app ) pr_warn ( "cleanup<S2SV_blank>app_id<S2SV_blank>%d(%s)\\n" , data -> client . app_id , ( char * ) data -> client . app_name ) ; if ( unload ) { struct qseecom_unload_app_ireq req ; req . qsee_cmd_id = QSEOS_APP_SHUTDOWN_COMMAND ; req . app_id = data -> client . app_id ; ret = qseecom_scm_call ( SCM_SVC_TZSCHEDULER , 1 , & req , sizeof ( struct qseecom_unload_app_ireq ) , & resp , sizeof ( resp ) ) ; if ( ret ) { pr_err ( "scm_call<S2SV_blank>to<S2SV_blank>unload<S2SV_blank>app<S2SV_blank>(id<S2SV_blank>=<S2SV_blank>%d)<S2SV_blank>failed\\n" , req . app_id ) ; ret = - EFAULT ; goto unload_exit ; } else { pr_warn ( "App<S2SV_blank>id<S2SV_blank>%d<S2SV_blank>now<S2SV_blank>unloaded\\n" , req . app_id ) ; } if ( resp . result == QSEOS_RESULT_FAILURE ) { pr_err ( "app<S2SV_blank>(%d)<S2SV_blank>unload_failed!!\\n" , data -> client . app_id ) ; ret = - EFAULT ; goto unload_exit ; } if ( resp . result == QSEOS_RESULT_SUCCESS ) pr_debug ( "App<S2SV_blank>(%d)<S2SV_blank>is<S2SV_blank>unloaded!!\\n" , data -> client . app_id ) ; if ( resp . result == QSEOS_RESULT_INCOMPLETE ) { ret = __qseecom_process_incomplete_cmd ( data , & resp ) ; if ( ret ) { pr_err ( "process_incomplete_cmd<S2SV_blank>fail<S2SV_blank>err:<S2SV_blank>%d\\n" , ret ) ; goto unload_exit ; } } } if ( found_app ) { spin_lock_irqsave ( & qseecom . registered_app_list_lock , flags1 ) ; if ( app_crash ) { ptr_app -> ref_cnt = 0 ; pr_debug ( "app_crash:<S2SV_blank>ref_count<S2SV_blank>=<S2SV_blank>0\\n" ) ; } else { if ( ptr_app -> ref_cnt == 1 ) { ptr_app -> ref_cnt = 0 ; pr_debug ( "ref_count<S2SV_blank>set<S2SV_blank>to<S2SV_blank>0\\n" ) ; } else { ptr_app -> ref_cnt -- ; pr_debug ( "Can\'t<S2SV_blank>unload<S2SV_blank>app(%d)<S2SV_blank>inuse\\n" , ptr_app -> app_id ) ; } } if ( unload ) { list_del ( & ptr_app -> list ) ; kzfree ( ptr_app ) ; } spin_unlock_irqrestore ( & qseecom . registered_app_list_lock , flags1 ) ; } unload_exit : qseecom_unmap_ion_allocated_memory ( data ) ; data -> released = true ; return ret ; } | <S2SV_ModStart> found_app = true ; if ( ptr_app -> app_blocked ) app_crash = false |
990 | CWE-000 void schedule_task_complete ( struct task * task ) { uint32_t flags ; tracev_pipe ( "com" ) ; spin_lock_irq ( & sch -> lock , flags ) ; <S2SV_StartBug> list_item_del ( & task -> list ) ; <S2SV_EndBug> task -> state = TASK_STATE_COMPLETED ; spin_unlock_irq ( & sch -> lock , flags ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> flags ) ; <S2SV_ModEnd> task -> state <S2SV_ModStart> flags ) ; wait_completed ( & task -> complete ) ; |
991 | CWE-000 struct GameState * search_by_user ( struct GameState * state , enum PosState fill ) { int ix , iy ; printf ( "Your<S2SV_blank>Turn<S2SV_blank>(as<S2SV_blank>%s).<S2SV_blank>Input<S2SV_blank>x<S2SV_blank>y:" , ( fill == C_BLACK ? "Black" : "White" ) ) ; scanf ( "%d%d" , & ix , & iy ) ; <S2SV_StartBug> assert ( ix >= 0 && ix < B_WIDTH && iy >= 0 && iy < B_HEIGHT ) ; <S2SV_EndBug> return update_state ( state , ix , iy , fill ) ; } | <S2SV_ModStart> iy ) ; ix -- ; iy -- ; |
992 | CWE-000 void fixedT ( struct latticeMesh * mesh , struct macroFields * mfields , struct lbeField * field , unsigned int bid ) { if ( ( field -> colId == 2 ) || ( field -> colId == 3 ) ) { unsigned int i , k ; double * f_eq_nb = ( double * ) malloc ( mesh -> mesh . Q * sizeof ( double ) ) ; double eq_bnd = 0 ; double eq_nb = 0 ; srand ( time ( NULL ) ) ; for ( i = 0 ; i < mesh -> mesh . bd . nbdelem [ bid ] ; i ++ ) { unsigned int id = mesh -> mesh . bd . bdPoints [ bid ] [ i ] ; for ( k = 0 ; k < mesh -> mesh . Q ; k ++ ) { if ( mesh -> mesh . nb [ id ] [ k ] == - 1 ) { int nbid = mesh -> mesh . nb [ id ] [ mesh -> lattice . reverse [ k ] ] ; if ( nbid != - 1 ) { liTempEquilibrium ( & mesh -> lattice , mfields -> rho [ nbid ] , mfields -> U [ nbid ] , f_eq_nb ) ; double r = 1 ; if ( field -> boundary [ bid ] . vectorVal [ 0 ] != 0 ) { r = ( double ) rand ( ) / ( double ) RAND_MAX ; r = ( 1.0 - field -> boundary [ bid ] . vectorVal [ 0 ] / 100 ) + r * ( ( 1.0 + field -> boundary [ bid ] . vectorVal [ 0 ] / 100 ) - ( 1.0 - field -> boundary [ bid ] . vectorVal [ 0 ] / 100 ) ) ; } eq_bnd = mesh -> EOS . _Cv * field -> boundary [ bid ] . scalarVal * r * f_eq_nb [ k ] ; <S2SV_StartBug> eq_nb = mesh -> EOS . _Cv * mfields -> T [ nbid ] * f_eq_nb [ k ] ; <S2SV_EndBug> field -> value [ id ] [ k ] = eq_bnd + ( field -> value [ nbid ] [ k ] - eq_nb ) ; } } } } free ( f_eq_nb ) ; } else { if ( ( field -> colId == 4 ) ) { unsigned int i , k ; double * f_eq_nb = ( double * ) malloc ( mesh -> mesh . Q * sizeof ( double ) ) ; double eq_bnd = 0 ; double eq_nb = 0 ; for ( i = 0 ; i < mesh -> mesh . bd . nbdelem [ bid ] ; i ++ ) { unsigned int id = mesh -> mesh . bd . bdPoints [ bid ] [ i ] ; for ( k = 0 ; k < mesh -> mesh . Q ; k ++ ) { if ( mesh -> mesh . nb [ id ] [ k ] == - 1 ) { int nbid = mesh -> mesh . nb [ id ] [ mesh -> lattice . reverse [ k ] ] ; if ( nbid != - 1 ) { <S2SV_StartBug> myMRTEquilibrium ( & mesh -> lattice , mfields -> T [ nbid ] , mfields -> U [ nbid ] , field -> alpha_1 , field -> alpha_2 , f_eq_nb ) ; <S2SV_EndBug> eq_nb = f_eq_nb [ k ] ; myMRTEquilibrium ( & mesh -> lattice , field -> boundary [ bid ] . scalarVal , mfields -> U [ nbid ] , field -> alpha_1 , field -> alpha_2 , f_eq_nb ) ; eq_bnd = f_eq_nb [ k ] ; field -> value [ id ] [ k ] = eq_bnd + ( field -> value [ nbid ] [ k ] - eq_nb ) ; } } } } free ( f_eq_nb ) ; } else { printf ( "\\n<S2SV_blank><S2SV_blank>[ERROR]<S2SV_blank><S2SV_blank>Unable<S2SV_blank>to<S2SV_blank>apply<S2SV_blank>boundary<S2SV_blank>condition<S2SV_blank>on<S2SV_blank>temperature\\n\\n" ) ; exit ( 1 ) ; } } } | <S2SV_ModStart> . _Cv * singleNodeT ( mesh , mfields , field , nbid ) <S2SV_ModEnd> * f_eq_nb [ <S2SV_ModStart> -> lattice , singleNodeT ( mesh , mfields , field , nbid ) <S2SV_ModEnd> , mfields -> |
993 | CWE-000 static int put_v4l2_edid32 ( struct v4l2_edid __user * kp , struct v4l2_edid32 __user * up ) { void * edid ; if ( ! access_ok ( VERIFY_WRITE , up , sizeof ( * up ) ) || assign_in_user ( & up -> pad , & kp -> pad ) || assign_in_user ( & up -> start_block , & kp -> start_block ) || assign_in_user ( & up -> blocks , & kp -> blocks ) || get_user ( edid , & kp -> edid ) || <S2SV_StartBug> put_user ( ptr_to_compat ( edid ) , & up -> edid ) || <S2SV_EndBug> copy_in_user ( up -> reserved , kp -> reserved , sizeof ( up -> reserved ) ) ) return - EFAULT ; return 0 ; } | <S2SV_ModStart> ( ptr_to_compat ( ( void __user * ) |
994 | CWE-000 static int pymain_read_conf_impl ( _PyMain * pymain , _PyCoreConfig * config , _PyCmdline * cmdline ) { _PyInitError err ; int res = pymain_parse_cmdline ( pymain , config , cmdline ) ; if ( res != 0 ) { return res ; } if ( pymain_init_core_argv ( pymain , config , cmdline ) < 0 ) { return - 1 ; } <S2SV_StartBug> assert ( config -> ignore_environment >= 0 ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ! config -> ignore_environment ) { <S2SV_EndBug> err = cmdline_init_env_warnoptions ( pymain , config , cmdline ) ; if ( _Py_INIT_FAILED ( err ) ) { pymain -> err = err ; return - 1 ; } } <S2SV_StartBug> err = _PyCoreConfig_Read ( config ) ; <S2SV_EndBug> if ( _Py_INIT_FAILED ( err ) ) { pymain -> err = err ; return - 1 ; } return 0 ; } | <S2SV_ModStart> 1 ; } err = _PyCoreConfig_Read ( config ) ; if ( _Py_INIT_FAILED ( err ) ) { pymain -> err = err ; return - 1 ; } <S2SV_ModStart> ( config -> use_environment <S2SV_ModEnd> >= 0 ) <S2SV_ModStart> ; if ( config -> use_environment <S2SV_ModEnd> ) { err <S2SV_ModStart> } err = config_init_warnoptions ( config , cmdline <S2SV_ModEnd> ) ; if |
995 | CWE-000 int main ( int narg , char * * varg ) { QUESTEnv env ; initQUESTEnv ( & env ) ; int numQubits ; long int index ; MultiQubit multiQubit ; double ang1 , ang2 , ang3 ; Complex alpha , beta ; double stateProb , randProb ; double angles [ MaxAngles ] [ 3 ] = { { 1.2320 , 0.4230 , - 0.6523 } , { 2.1213 , 0.0000 , 3.6520 } , { - 3.1213 , 5.0230 , 0.1230 } , { 5.2341 , - 3.1001 , - 1.2340 } , { - 0.1234 , - 0.9876 , 4.1234 } } ; int numAngles = 5 , iAngle ; int rotQubit , measureQubit ; long int numAmps , numAmpsPerRank ; if ( narg >= 2 ) { numQubits = atoi ( varg [ 1 ] ) ; if ( numQubits < 1 || numQubits > maxNumQubits ) { printf ( "<S2SV_blank>***<S2SV_blank>error:<S2SV_blank>argument<S2SV_blank>%d<S2SV_blank>out<S2SV_blank>of<S2SV_blank>range<S2SV_blank>(1<S2SV_blank>--<S2SV_blank>%d)\\n" , numQubits , maxNumQubits ) ; exit ( EXIT_FAILURE ) ; } } else { printf ( "<S2SV_blank>***<S2SV_blank>error:<S2SV_blank>too<S2SV_blank>few<S2SV_blank>arguments,<S2SV_blank>number<S2SV_blank>of<S2SV_blank>qubits<S2SV_blank>expected\\n" ) ; exit ( EXIT_FAILURE ) ; } numAmps = 1L << numQubits ; if ( env . rank == 0 ) { printf ( "Demo<S2SV_blank>of<S2SV_blank>single<S2SV_blank>qubit<S2SV_blank>rotations.\\n" ) ; printf ( "Number<S2SV_blank>of<S2SV_blank>qubits<S2SV_blank>is<S2SV_blank>%d.\\n" , numQubits ) ; printf ( "Number<S2SV_blank>of<S2SV_blank>amps<S2SV_blank>is<S2SV_blank>%ld.\\n" , numAmps ) ; } double wtime_start , wtime_stop ; double * timingVec ; int trial ; if ( REPORT_TIMING && env . rank == 0 ) timingVec = malloc ( N_TRIALS * numQubits * sizeof ( timingVec ) ) ; createMultiQubit ( & multiQubit , numQubits , env ) ; printf ( "alloced<S2SV_blank>mem\\n" ) ; initStateVec ( & multiQubit ) ; <S2SV_StartBug> printf ( "initialized<S2SV_blank>state\\n" ) ; <S2SV_EndBug> ang1 = angles [ 0 ] [ 0 ] ; ang2 = angles [ 0 ] [ 1 ] ; ang3 = angles [ 0 ] [ 2 ] ; alpha . real = cos ( ang1 ) * cos ( ang2 ) ; alpha . imag = cos ( ang1 ) * sin ( ang2 ) ; beta . real = sin ( ang1 ) * cos ( ang3 ) ; beta . imag = sin ( ang1 ) * sin ( ang3 ) ; FILE * timing , * distribution ; char filename [ 100 ] ; if ( REPORT_TIMING && env . rank == 0 ) { sprintf ( filename , "timing.csv" ) ; timing = fopen ( filename , "w" ) ; fprintf ( timing , "qubit,<S2SV_blank>time(s),<S2SV_blank>standardDevUp,<S2SV_blank>standardDevLo,<S2SV_blank>max,<S2SV_blank>min\\n" ) ; sprintf ( filename , "distribution.csv" ) ; distribution = fopen ( filename , "w" ) ; } if ( REPORT_TIMING && INIT_COMMUNICATION ) { rotateQubit ( multiQubit , numQubits - 1 , alpha , beta ) ; syncQUESTEnv ( env ) ; } for ( rotQubit = 0 ; rotQubit < numQubits ; rotQubit ++ ) { for ( trial = 0 ; trial < N_TRIALS ; trial ++ ) { if ( REPORT_TIMING ) syncQUESTEnv ( env ) ; if ( REPORT_TIMING && env . rank == 0 ) wtime_start = system_timer ( ) ; rotateQubit ( multiQubit , rotQubit , alpha , beta ) ; if ( REPORT_TIMING ) syncQUESTEnv ( env ) ; if ( REPORT_TIMING && env . rank == 0 ) { wtime_stop = system_timer ( ) ; timingVec [ trial * numQubits + rotQubit ] = wtime_stop - wtime_start ; } } } printf ( "rotated\\n" ) ; double totalProbability ; totalProbability = calcTotalProbability ( multiQubit ) ; if ( env . rank == 0 ) printf ( "total<S2SV_blank>probability:<S2SV_blank>%.14f\\n" , totalProbability ) ; printf ( "calc<S2SV_blank>prob\\n" ) ; if ( REPORT_TIMING && env . rank == 0 ) { double totTime , avg , standardDev , temp , max , min ; for ( index = 0 ; index < numQubits ; index ++ ) { max = 0 ; min = 10e5 ; totTime = 0 ; for ( trial = 0 ; trial < N_TRIALS ; trial ++ ) { temp = timingVec [ trial * numQubits + index ] ; totTime += temp ; if ( temp < min ) min = temp ; if ( temp > max ) max = temp ; if ( index == numQubits - 2 ) fprintf ( distribution , "%.8f\\n" , timingVec [ trial * numQubits + index ] ) ; } avg = totTime / ( double ) N_TRIALS ; standardDev = 0 ; for ( trial = 0 ; trial < N_TRIALS ; trial ++ ) { temp = timingVec [ trial * numQubits + index ] - avg ; standardDev += temp * temp ; } standardDev = sqrt ( standardDev / ( double ) N_TRIALS ) ; fprintf ( timing , "%d,<S2SV_blank>%.8f,<S2SV_blank>%.8f,<S2SV_blank>%.8f,<S2SV_blank>%.8f,<S2SV_blank>%.8f\\n" , index , avg , avg + 3 * standardDev , avg - 3 * standardDev , max , min ) ; } } if ( REPORT_STATE ) { reportState ( multiQubit ) ; } totalProbability = calcTotalProbability ( multiQubit ) ; if ( env . rank == 0 ) printf ( "total<S2SV_blank>probability:<S2SV_blank>%.14f\\n" , totalProbability ) ; if ( REPORT_TIMING && env . rank == 0 ) fclose ( timing ) ; if ( REPORT_TIMING && env . rank == 0 ) fclose ( distribution ) ; destroyMultiQubit ( multiQubit , env ) ; if ( REPORT_TIMING && env . rank == 0 ) free ( timingVec ) ; closeQUESTEnv ( env ) ; return EXIT_SUCCESS ; } | <S2SV_ModStart> ; printf ( "initialized<S2SV_blank>state<S2SV_blank>rank:<S2SV_blank>%d<S2SV_blank>size:%d\\n" , env . rank , env . numRanks <S2SV_ModEnd> ) ; ang1 |
996 | CWE-000 static int ast_error ( struct compiling * c , const node * n , const char * errmsg ) { PyObject * value , * errstr , * loc , * tmp ; loc = PyErr_ProgramTextObject ( c -> c_filename , LINENO ( n ) ) ; if ( ! loc ) { Py_INCREF ( Py_None ) ; loc = Py_None ; } <S2SV_StartBug> tmp = Py_BuildValue ( "(OiiN)" , c -> c_filename , LINENO ( n ) , n -> n_col_offset , loc ) ; <S2SV_EndBug> if ( ! tmp ) return 0 ; errstr = PyUnicode_FromString ( errmsg ) ; if ( ! errstr ) { Py_DECREF ( tmp ) ; return 0 ; } value = PyTuple_Pack ( 2 , errstr , tmp ) ; Py_DECREF ( errstr ) ; Py_DECREF ( tmp ) ; if ( value ) { PyErr_SetObject ( PyExc_SyntaxError , value ) ; Py_DECREF ( value ) ; } return 0 ; } | <S2SV_ModStart> n -> n_col_offset + 1 |
997 | CWE-000 const char * evil_homedir_get ( void ) { <S2SV_StartBug> char * homedir ; <S2SV_EndBug> char * homedrive ; char * homepath ; homedir = getenv ( "HOME" ) ; if ( ! homedir ) { homedrive = getenv ( "HOMEDRIVE" ) ; homepath = getenv ( "HOMEPATH" ) ; if ( homedrive && homepath ) asprintf ( & homedir , "%s%s" , homedrive , homepath ) ; } if ( ! homedir ) homedir = getenv ( "USERPROFILE" ) ; if ( ! homedir ) homedir = getenv ( "WINDIR" ) ; if ( ! homedir ) homedir = "C:\\\\" ; return homedir ; } | <S2SV_ModStart> void ) { return NULL <S2SV_ModEnd> ; } <S2SV_null> |
998 | CWE-000 static timezone_t tzlookup ( Lisp_Object zone , bool settz ) { static char const tzbuf_format [ ] = "<%+.*" pI "d>%s%" pI "d:%02d:%02d" ; char const * trailing_tzbuf_format = tzbuf_format + sizeof "<%+.*" pI "d" - 1 ; char tzbuf [ sizeof tzbuf_format + 2 * INT_STRLEN_BOUND ( EMACS_INT ) ] ; char const * zone_string ; timezone_t new_tz ; if ( NILP ( zone ) ) return local_tz ; else if ( EQ ( zone , Qt ) ) { zone_string = "UTC0" ; new_tz = utc_tz ; } else { bool plain_integer = INTEGERP ( zone ) ; if ( EQ ( zone , Qwall ) ) zone_string = 0 ; else if ( STRINGP ( zone ) ) zone_string = SSDATA ( ENCODE_SYSTEM ( zone ) ) ; else if ( plain_integer || ( CONSP ( zone ) && INTEGERP ( XCAR ( zone ) ) && CONSP ( XCDR ( zone ) ) ) ) { Lisp_Object abbr ; if ( ! plain_integer ) { abbr = XCAR ( XCDR ( zone ) ) ; zone = XCAR ( zone ) ; } EMACS_INT abszone = eabs ( XINT ( zone ) ) , hour = abszone / ( 60 * 60 ) ; int hour_remainder = abszone % ( 60 * 60 ) ; int min = hour_remainder / 60 , sec = hour_remainder % 60 ; if ( plain_integer ) { int prec = 2 ; EMACS_INT numzone = hour ; if ( hour_remainder != 0 ) { prec += 2 , numzone = 100 * numzone + min ; if ( sec != 0 ) prec += 2 , numzone = 100 * numzone + sec ; } <S2SV_StartBug> sprintf ( tzbuf , tzbuf_format , prec , numzone , <S2SV_EndBug> & "-" [ XINT ( zone ) < 0 ] , hour , min , sec ) ; zone_string = tzbuf ; } else { AUTO_STRING ( leading , "<" ) ; AUTO_STRING_WITH_LEN ( trailing , tzbuf , sprintf ( tzbuf , trailing_tzbuf_format , & "-" [ XINT ( zone ) < 0 ] , hour , min , sec ) ) ; zone_string = SSDATA ( concat3 ( leading , ENCODE_SYSTEM ( abbr ) , trailing ) ) ; } } else xsignal2 ( Qerror , build_string ( "Invalid<S2SV_blank>time<S2SV_blank>zone<S2SV_blank>specification" ) , zone ) ; new_tz = xtzalloc ( zone_string ) ; } if ( settz ) { block_input ( ) ; emacs_setenv_TZ ( zone_string ) ; tzset ( ) ; timezone_t old_tz = local_tz ; local_tz = new_tz ; tzfree ( old_tz ) ; unblock_input ( ) ; } return new_tz ; } | <S2SV_ModStart> , prec , XINT ( zone ) < 0 ? - numzone : |
999 | CWE-000 <S2SV_StartBug> int pthread_create ( pthread_t * thread , const pthread_attr_t * attr , <S2SV_EndBug> void * ( * start_routine ) ( void * ) , void * args ) { int stacksize ; int initial_state ; int res ; if ( attr ) { stacksize = attr -> stack_size ; if ( stacksize < PTHREAD_STACK_MIN ) { errno = EINVAL ; return EINVAL ; } initial_state = attr -> initial_state ; } else { stacksize = PTHREAD_STACK_MIN ; initial_state = PTHREAD_INITIAL_STATE_RUN ; } res = _pthread_create ( thread , stacksize , initial_state , start_routine , args ) ; if ( res ) { errno = res ; return res ; } return 0 ; } | <S2SV_ModStart> int pthread_create ( _pthread_t <S2SV_ModEnd> * thread , <S2SV_ModStart> thread , const _pthread_attr_t <S2SV_ModEnd> * attr , |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.