Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
1,300 | CWE-000 <S2SV_StartBug> CITreeError CITree_Delete_Def ( struct CITree * self_ , void * element , size_t index ) <S2SV_EndBug> { CAssertObject ( self_ ) ; struct CCBinaryTree * self = CCast ( self_ ) ; CIListError err = CIList_Remove ( & self -> tree_backend . cIList , self -> swap_space_1 , index ) ; if ( err == CILIST_ERR_EMPTY ) { return CITREE_ERR_EMPTY ; } CCBinaryTree_DecodeSwap ( self , element , NULL ) ; if ( self -> index <= 1 ) { self -> index = CCBINARY_TREE_ROOT ; } else { -- self -> index ; <S2SV_StartBug> CIList_Remove ( & self -> tree_backend . cIList , self -> swap_space_1 , self -> index ) ; <S2SV_EndBug> <S2SV_StartBug> CIList_AddAt ( & self -> tree_backend . cIList , self -> swap_space_1 , index ) ; <S2SV_EndBug> CCBinaryTree_HeapifyDown ( self , index ) ; } return CITREE_OK ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static <S2SV_ModStart> -> index ; err = <S2SV_ModStart> index ) ; err = |
1,301 | CWE-000 static void liferea_htmlview_proxy_changed ( NetworkMonitor * nm , gpointer userdata ) { LifereaHtmlView * htmlview = LIFEREA_HTMLVIEW ( userdata ) ; <S2SV_StartBug> ( RENDERER ( htmlview ) -> setProxy ) ( network_get_proxy_host ( ) , <S2SV_EndBug> network_get_proxy_port ( ) , network_get_proxy_username ( ) , network_get_proxy_password ( ) ) ; } | <S2SV_ModStart> setProxy ) ( network_get_proxy_detect_mode ( ) , |
1,302 | CWE-000 static bool neigh_master_filtered ( struct net_device * dev , int master_idx ) { struct net_device * master ; if ( ! master_idx ) return false ; <S2SV_StartBug> master = netdev_master_upper_dev_get ( dev ) ; <S2SV_EndBug> if ( ! master || master -> ifindex != master_idx ) return true ; return false ; } | <S2SV_ModStart> ; master = dev ? <S2SV_ModStart> ( dev ) : NULL |
1,303 | CWE-000 <S2SV_StartBug> void * const Pr_GetArrayData ( Pr_Array * ap_array ) <S2SV_EndBug> { return ap_array ? ap_array -> data : NULL ; } | <S2SV_ModStart> <S2SV_null> void * <S2SV_ModEnd> Pr_GetArrayData ( Pr_Array |
1,304 | CWE-000 void sdr_cache_init ( uint8_t slot_id ) { int ret ; int fd ; uint8_t rlen ; uint8_t rbuf [ MAX_IPMB_RES_LEN ] = { 0 } ; char * path = NULL ; char sdr_temp_path [ 64 ] = { 0 } ; char sdr_path [ 64 ] = { 0 } ; sprintf ( sdr_temp_path , "/tmp/tsdr_slot%d.bin" , slot_id ) ; sprintf ( sdr_path , "/tmp/sdr_slot%d.bin" , slot_id ) ; ipmi_sel_sdr_req_t req ; ipmi_sel_sdr_res_t * res = ( ipmi_sel_sdr_res_t * ) rbuf ; req . rsv_id = 0 ; req . rec_id = 0 ; req . offset = 0 ; req . nbytes = BYTES_ENTIRE_RECORD ; path = sdr_temp_path ; unlink ( path ) ; fd = open ( path , O_WRONLY | O_CREAT | O_EXCL , 0666 ) ; if ( fd < 0 ) { syslog ( LOG_WARNING , "%s:<S2SV_blank>open<S2SV_blank>fails<S2SV_blank>for<S2SV_blank>path:<S2SV_blank>%s\\n" , __func__ , path ) ; return ; } ret = pal_flock_retry ( fd ) ; if ( ret == - 1 ) { syslog ( LOG_WARNING , "%s:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>flock<S2SV_blank>on<S2SV_blank>%s" , __func__ , path ) ; close ( fd ) ; return ; } while ( 1 ) { ret = bic_get_sdr ( slot_id , & req , res , & rlen ) ; if ( ret ) { syslog ( LOG_WARNING , "%s:<S2SV_blank>bic_get_sdr<S2SV_blank>returns<S2SV_blank>%d\\n" , __func__ , ret ) ; continue ; } <S2SV_StartBug> sdr_full_t * sdr = res -> data ; <S2SV_EndBug> write ( fd , sdr , sizeof ( sdr_full_t ) ) ; req . rec_id = res -> next_rec_id ; if ( req . rec_id == LAST_RECORD_ID ) { break ; } } ret = pal_unflock_retry ( fd ) ; if ( ret == - 1 ) { syslog ( LOG_WARNING , "%s:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>unflock<S2SV_blank>on<S2SV_blank>%s" , __func__ , path ) ; close ( fd ) ; return ; } close ( fd ) ; rename ( sdr_temp_path , sdr_path ) ; } | <S2SV_ModStart> * sdr = ( sdr_full_t * ) |
1,305 | CWE-000 void SOS_publish_from_buffer ( SOS_buffer * buffer , SOS_pub * pub , SOS_pipe * snap_queue ) { SOS_SET_CONTEXT ( pub -> sos_context , "SOS_publish_from_buffer" ) ; SOS_msg_header header ; SOS_data * data ; long this_frame ; int offset ; int elem ; if ( buffer == NULL ) { dlog ( 0 , "ERROR:<S2SV_blank>SOS_buffer<S2SV_blank>*buffer<S2SV_blank>parameter<S2SV_blank>is<S2SV_blank>NULL!" "<S2SV_blank>Terminating.\\n" ) ; exit ( EXIT_FAILURE ) ; } if ( pub == NULL ) { dlog ( 0 , "ERROR:<S2SV_blank>SOS_pub<S2SV_blank>*pub<S2SV_blank>parameter<S2SV_blank>is<S2SV_blank>NULL!" "<S2SV_blank>Terminating.\\n" ) ; exit ( EXIT_FAILURE ) ; } <S2SV_StartBug> pthread_mutex_lock ( pub -> lock ) ; <S2SV_EndBug> dlog ( 7 , "Unpacking<S2SV_blank>the<S2SV_blank>values<S2SV_blank>from<S2SV_blank>the<S2SV_blank>buffer...\\n" ) ; offset = 0 ; SOS_msg_unzip ( buffer , & header , 0 , & offset ) ; dlog ( 7 , "<S2SV_blank><S2SV_blank>...<S2SV_blank>header.msg_size<S2SV_blank>=<S2SV_blank>%d\\n" , header . msg_size ) ; dlog ( 7 , "<S2SV_blank><S2SV_blank>...<S2SV_blank>header.msg_type<S2SV_blank>=<S2SV_blank>%d\\n" , header . msg_type ) ; dlog ( 7 , "<S2SV_blank><S2SV_blank>...<S2SV_blank>header.msg_from<S2SV_blank>=<S2SV_blank>%" SOS_GUID_FMT "\\n" , header . msg_from ) ; dlog ( 7 , "<S2SV_blank><S2SV_blank>...<S2SV_blank>header.ref_guid<S2SV_blank>=<S2SV_blank>%" SOS_GUID_FMT "\\n" , header . ref_guid ) ; dlog ( 7 , "<S2SV_blank><S2SV_blank>...<S2SV_blank>values:\\n" ) ; SOS_buffer_unpack ( buffer , & offset , "l" , & this_frame ) ; pub -> frame = this_frame ; while ( offset < header . msg_size ) { dlog ( 7 , "Unpacking<S2SV_blank>next<S2SV_blank>message<S2SV_blank>@<S2SV_blank>offset<S2SV_blank>%d<S2SV_blank>of<S2SV_blank>%d...\\n" , offset , header . msg_size ) ; SOS_buffer_unpack ( buffer , & offset , "i" , & elem ) ; data = pub -> data [ elem ] ; SOS_buffer_unpack ( buffer , & offset , "ddilg" , & data -> time . pack , & data -> time . send , & data -> val_len , & data -> meta . semantic , & data -> meta . relation_id ) ; dlog ( 7 , "pub->data[%d]->time.pack<S2SV_blank>==<S2SV_blank>%lf" "<S2SV_blank><S2SV_blank><S2SV_blank>pub->data[%d]->time.send<S2SV_blank>==<S2SV_blank>%lf\\n" , elem , data -> time . pack , elem , data -> time . send ) ; switch ( data -> type ) { case SOS_VAL_TYPE_INT : SOS_buffer_unpack ( buffer , & offset , "i" , & data -> val . i_val ) ; break ; case SOS_VAL_TYPE_LONG : SOS_buffer_unpack ( buffer , & offset , "l" , & data -> val . l_val ) ; break ; case SOS_VAL_TYPE_DOUBLE : SOS_buffer_unpack ( buffer , & offset , "d" , & data -> val . d_val ) ; break ; case SOS_VAL_TYPE_STRING : if ( data -> val . c_val != NULL ) { free ( data -> val . c_val ) ; } data -> val . c_val = ( char * ) malloc ( 1 + data -> val_len ) ; memset ( data -> val . c_val , '\\0' , ( 1 + data -> val_len ) ) ; SOS_buffer_unpack ( buffer , & offset , "s" , data -> val . c_val ) ; dlog ( 8 , "[STRING]<S2SV_blank>Extracted<S2SV_blank>pub<S2SV_blank>message<S2SV_blank>string:<S2SV_blank>%s\\n" , data -> val . c_val ) ; break ; default : dlog ( 6 , "Invalid<S2SV_blank>type<S2SV_blank>(%d)<S2SV_blank>at<S2SV_blank>index<S2SV_blank>%d<S2SV_blank>of<S2SV_blank>pub->guid" "<S2SV_blank>==<S2SV_blank>%" SOS_GUID_FMT ".\\n" , data -> type , elem , pub -> guid ) ; break ; } data -> state = SOS_VAL_STATE_CLEAN ; } <S2SV_StartBug> pthread_mutex_unlock ( pub -> lock ) ; <S2SV_EndBug> dlog ( 7 , "<S2SV_blank><S2SV_blank>...<S2SV_blank>done.\\n" ) ; return ; } | <S2SV_ModStart> ) ; } <S2SV_ModEnd> dlog ( 7 <S2SV_ModStart> SOS_VAL_STATE_CLEAN ; } <S2SV_ModEnd> dlog ( 7 |
1,306 | CWE-000 int tick_itemstack ( struct world * world , struct entity * entity ) { if ( entity -> data . itemstack . delayBeforeCanPickup > 0 ) { entity -> data . itemstack . delayBeforeCanPickup -- ; return 0 ; } if ( entity -> age >= 6000 ) { pthread_rwlock_unlock ( & world -> entities -> data_mutex ) ; despawnEntity ( world , entity ) ; pthread_rwlock_rdlock ( & world -> entities -> data_mutex ) ; freeEntity ( entity ) ; return 1 ; } if ( tick_counter % 10 != 0 ) return 0 ; struct boundingbox cebb ; getEntityCollision ( entity , & cebb ) ; cebb . minX -= .625 ; cebb . maxX += .625 ; cebb . maxY += .75 ; cebb . minZ -= .625 ; cebb . maxZ += .625 ; struct boundingbox oebb ; BEGIN_HASHMAP_ITERATION ( entity -> world -> entities ) struct entity * oe = ( struct entity * ) value ; if ( oe == entity || entity_distsq ( entity , oe ) > 16. * 16. ) continue ; if ( oe -> type == ENT_PLAYER && oe -> health > 0. ) { getEntityCollision ( oe , & oebb ) ; if ( boundingbox_intersects ( & oebb , & cebb ) ) { int os = entity -> data . itemstack . slot -> itemCount ; <S2SV_StartBug> pthread_rwlock_unlock ( & world -> entities -> data_mutex ) ; <S2SV_EndBug> pthread_rwlock_unlock ( & world -> entities -> data_mutex ) ; pthread_mutex_lock ( & oe -> data . player . player -> inventory -> mut ) ; int r = addInventoryItem_PI ( oe -> data . player . player , oe -> data . player . player -> inventory , entity -> data . itemstack . slot , 1 ) ; <S2SV_StartBug> pthread_mutex_unlock ( & oe -> data . player . player -> inventory -> mut ) ; <S2SV_EndBug> pthread_rwlock_rdlock ( & world -> entities -> data_mutex ) ; pthread_rwlock_rdlock ( & world -> entities -> data_mutex ) ; if ( r <= 0 ) { BEGIN_BROADCAST_DIST ( entity , 32. ) struct packet * pkt = xmalloc ( sizeof ( struct packet ) ) ; pkt -> id = PKT_PLAY_CLIENT_COLLECTITEM ; pkt -> data . play_client . collectitem . collected_entity_id = entity -> id ; pkt -> data . play_client . collectitem . collector_entity_id = oe -> id ; pkt -> data . play_client . collectitem . pickup_item_count = os - r ; add_queue ( bc_player -> outgoingPacket , pkt ) ; END_BROADCAST ( entity -> world -> players ) pthread_rwlock_unlock ( & world -> entities -> data_mutex ) ; pthread_rwlock_unlock ( & world -> entities -> data_mutex ) ; despawnEntity ( world , entity ) ; pthread_rwlock_rdlock ( & world -> entities -> data_mutex ) ; freeEntity ( entity ) ; return 1 ; } else { BEGIN_BROADCAST_DIST ( entity , 128. ) struct packet * pkt = xmalloc ( sizeof ( struct packet ) ) ; pkt -> id = PKT_PLAY_CLIENT_ENTITYMETADATA ; pkt -> data . play_client . entitymetadata . entity_id = entity -> id ; writeMetadata ( entity , & pkt -> data . play_client . entitymetadata . metadata . metadata , & pkt -> data . play_client . entitymetadata . metadata . metadata_size ) ; add_queue ( bc_player -> outgoingPacket , pkt ) ; END_BROADCAST ( entity -> world -> players ) <S2SV_StartBug> } <S2SV_EndBug> break ; } } else if ( oe -> type == ENT_ITEM ) { if ( oe -> data . itemstack . slot -> item == entity -> data . itemstack . slot -> item && oe -> data . itemstack . slot -> damage == entity -> data . itemstack . slot -> damage && oe -> data . itemstack . slot -> itemCount + entity -> data . itemstack . slot -> itemCount <= maxStackSize ( entity -> data . itemstack . slot ) ) { getEntityCollision ( oe , & oebb ) ; oebb . minX -= .625 ; oebb . maxX += .625 ; cebb . maxY += .75 ; oebb . minZ -= .625 ; oebb . maxZ += .625 ; if ( boundingbox_intersects ( & oebb , & cebb ) ) { pthread_rwlock_unlock ( & world -> entities -> data_mutex ) ; pthread_rwlock_unlock ( & world -> entities -> data_mutex ) ; despawnEntity ( world , entity ) ; pthread_rwlock_rdlock ( & world -> entities -> data_mutex ) ; oe -> data . itemstack . slot -> itemCount += entity -> data . itemstack . slot -> itemCount ; freeEntity ( entity ) ; BEGIN_BROADCAST_DIST ( oe , 128. ) struct packet * pkt = xmalloc ( sizeof ( struct packet ) ) ; pkt -> id = PKT_PLAY_CLIENT_ENTITYMETADATA ; pkt -> data . play_client . entitymetadata . entity_id = oe -> id ; writeMetadata ( oe , & pkt -> data . play_client . entitymetadata . metadata . metadata , & pkt -> data . play_client . entitymetadata . metadata . metadata_size ) ; add_queue ( bc_player -> outgoingPacket , pkt ) ; END_BROADCAST ( oe -> world -> players ) return 1 ; } } } END_HASHMAP_ITERATION ( entity -> world -> entities ) return 0 ; } | <S2SV_ModStart> -> itemCount ; <S2SV_ModEnd> pthread_mutex_lock ( & <S2SV_ModStart> inventory -> mut <S2SV_ModEnd> ) ; if <S2SV_ModStart> -> players ) BREAK_HASHMAP_ITERATION ( entity -> world -> entities ) |
1,307 | CWE-000 static s32 wl_init_priv ( struct bcm_cfg80211 * cfg ) { struct wiphy * wiphy = bcmcfg_to_wiphy ( cfg ) ; struct net_device * ndev = bcmcfg_to_prmry_ndev ( cfg ) ; s32 err = 0 ; cfg -> scan_request = NULL ; cfg -> pwr_save = ! ! ( wiphy -> flags & WIPHY_FLAG_PS_ON_BY_DEFAULT ) ; cfg -> roam_on = false ; cfg -> active_scan = true ; cfg -> rf_blocked = false ; cfg -> vsdb_mode = false ; # if defined ( BCMSDIO ) cfg -> wlfc_on = false ; # endif cfg -> roamoff_on_concurrent = true ; cfg -> disable_roam_event = false ; set_bit ( WL_STATUS_CONNECTED , & cfg -> interrested_state ) ; set_bit ( WL_STATUS_DISCONNECTING , & cfg -> interrested_state ) ; spin_lock_init ( & cfg -> cfgdrv_lock ) ; <S2SV_StartBug> mutex_init ( & cfg -> ioctl_buf_sync ) ; <S2SV_EndBug> init_waitqueue_head ( & cfg -> netif_change_event ) ; init_waitqueue_head ( & cfg -> event_sync_wq ) ; init_completion ( & cfg -> send_af_done ) ; init_completion ( & cfg -> iface_disable ) ; wl_init_eq ( cfg ) ; err = wl_init_priv_mem ( cfg ) ; if ( err ) return err ; if ( wl_create_event_handler ( cfg ) ) return - ENOMEM ; wl_init_event_handler ( cfg ) ; mutex_init ( & cfg -> usr_sync ) ; mutex_init ( & cfg -> event_sync ) ; err = wl_init_scan ( cfg ) ; if ( err ) return err ; wl_init_conf ( cfg -> conf ) ; wl_init_prof ( cfg , ndev ) ; wl_link_down ( cfg ) ; DNGL_FUNC ( dhd_cfg80211_init , ( cfg ) ) ; return err ; } | <S2SV_ModStart> cfgdrv_lock ) ; spin_lock_init ( & cfg -> cfgp2p_lock ) ; |
1,308 | CWE-000 int mariadb_dr_discon_all ( SV * drh , imp_drh_t * imp_drh ) { dTHX ; dSP ; int ret ; SV * * svp ; AV * av ; I32 i ; PERL_UNUSED_ARG ( drh ) ; if ( imp_drh -> taken_pmysqls ) { for ( i = AvFILL ( imp_drh -> taken_pmysqls ) ; i >= 0 ; -- i ) { svp = av_fetch ( imp_drh -> taken_pmysqls , i , FALSE ) ; if ( ! svp || ! * svp ) continue ; SvGETMAGIC ( * svp ) ; if ( ! SvIOK ( * svp ) ) continue ; mariadb_dr_close_mysql ( aTHX_ imp_drh , INT2PTR ( MYSQL * , SvIVX ( * svp ) ) ) ; } av_undef ( imp_drh -> taken_pmysqls ) ; imp_drh -> taken_pmysqls = NULL ; } svp = hv_fetchs ( ( HV * ) DBIc_MY_H ( imp_drh ) , "ChildHandles" , FALSE ) ; if ( svp && * svp ) { SvGETMAGIC ( * svp ) ; if ( SvROK ( * svp ) && SvTYPE ( SvRV ( * svp ) ) == SVt_PVAV ) { av = ( AV * ) SvRV ( * svp ) ; for ( i = AvFILL ( av ) ; i >= 0 ; -- i ) { svp = av_fetch ( av , i , FALSE ) ; if ( ! svp || ! * svp || ! sv_isobject ( * svp ) ) continue ; ENTER ; SAVETMPS ; PUSHMARK ( SP ) ; EXTEND ( SP , 1 ) ; PUSHs ( sv_2mortal ( newSVsv ( * svp ) ) ) ; PUTBACK ; call_method ( "disconnect" , G_VOID | G_DISCARD | G_EVAL | G_KEEPERR ) ; FREETMPS ; LEAVE ; } } } ret = 1 ; if ( imp_drh -> instances ) { warn ( "DBD::MariaDB<S2SV_blank>disconnect_all:<S2SV_blank>%lu<S2SV_blank>database<S2SV_blank>handlers<S2SV_blank>were<S2SV_blank>not<S2SV_blank>released<S2SV_blank>(possible<S2SV_blank>bug<S2SV_blank>in<S2SV_blank>driver)" , imp_drh -> instances ) ; ret = 0 ; } if ( imp_drh -> embedded_started ) { warn ( "DBD::MariaDB<S2SV_blank>disconnect_all:<S2SV_blank>Embedded<S2SV_blank>server<S2SV_blank>was<S2SV_blank>not<S2SV_blank>properly<S2SV_blank>stopped<S2SV_blank>(possible<S2SV_blank>bug<S2SV_blank>in<S2SV_blank>driver)" ) ; ret = 0 ; } # ifndef HAVE_EMBEDDED if ( imp_drh -> non_embedded_started ) { <S2SV_StartBug> mysql_server_end ( ) ; <S2SV_EndBug> imp_drh -> non_embedded_started = FALSE ; imp_drh -> non_embedded_finished = TRUE ; <S2SV_StartBug> } <S2SV_EndBug> # endif if ( imp_drh -> embedded_args ) { warn ( "DBD::MariaDB<S2SV_blank>disconnect_all:<S2SV_blank>mariadb_embedded_options<S2SV_blank>was<S2SV_blank>not<S2SV_blank>released<S2SV_blank>(possible<S2SV_blank>bug<S2SV_blank>in<S2SV_blank>driver)" ) ; ret = 0 ; } if ( imp_drh -> embedded_groups ) { warn ( "DBD::MariaDB<S2SV_blank>disconnect_all:<S2SV_blank>mariadb_embedded_groups<S2SV_blank>was<S2SV_blank>not<S2SV_blank>released<S2SV_blank>(possible<S2SV_blank>bug<S2SV_blank>in<S2SV_blank>driver)" ) ; ret = 0 ; } return ret ; } | <S2SV_ModStart> non_embedded_started ) { # ifndef HAVE_BROKEN_INIT warn ( "DBD::MariaDB<S2SV_blank>disconnect_all:<S2SV_blank>Client<S2SV_blank>library<S2SV_blank>was<S2SV_blank>not<S2SV_blank>properly<S2SV_blank>deinitialized<S2SV_blank>(possible<S2SV_blank>bug<S2SV_blank>in<S2SV_blank>driver)" ) ; ret = 0 ; # else <S2SV_ModStart> = TRUE ; # endif } # endif <S2SV_ModEnd> if ( imp_drh |
1,309 | CWE-000 <S2SV_StartBug> void * NV_NodeID_getDataAsType ( const NV_ID * id , NV_NodeType type ) <S2SV_EndBug> { NV_Node * n ; n = NV_NodeID_getNode ( id ) ; return NV_Node_getDataAsType ( n , type ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> const |
1,310 | CWE-000 void heater_gpio_task ( void * pvParameter ) { gpio_pad_select_gpio ( BLUE_LED ) ; gpio_pad_select_gpio ( HEATER_GPIO ) ; gpio_set_direction ( HEATER_GPIO , GPIO_MODE_OUTPUT ) ; gpio_set_direction ( BLUE_LED , GPIO_MODE_OUTPUT ) ; static int loop_i = 0 ; while ( 1 ) { <S2SV_StartBug> ESP_LOGD ( TAG , "heater><S2SV_blank>loop<S2SV_blank>%d" , loop_i ++ ) ; <S2SV_EndBug> if ( ( heat_request > 0 ) && ( heat_timer > 0 ) ) { int heat_value = heat_request ; if ( heat_value > 10 ) { heat_value = 10 ; } publish_heat_status ( heat_value , heat_timer ) ; int rest_value = 10 - heat_value ; <S2SV_StartBug> gpio_set_level ( HEATER_GPIO , 0 ) ; <S2SV_EndBug> gpio_set_level ( BLUE_LED , 1 ) ; vTaskDelay ( heat_value * 1000 / portTICK_PERIOD_MS ) ; <S2SV_StartBug> gpio_set_level ( HEATER_GPIO , 1 ) ; <S2SV_EndBug> gpio_set_level ( BLUE_LED , 0 ) ; vTaskDelay ( rest_value * 1000 / portTICK_PERIOD_MS ) ; heat_timer -- ; } else { gpio_set_level ( HEATER_GPIO , 0 ) ; <S2SV_StartBug> gpio_set_level ( BLUE_LED , 1 ) ; <S2SV_EndBug> static int idle_loop_i = 0 ; if ( ( idle_loop_i ++ % 20 ) == 0 ) { publish_heat_status ( 0 , 0 ) ; } vTaskDelay ( 1000 / portTICK_PERIOD_MS ) ; } } } | <S2SV_ModStart> 1 ) { ESP_LOGI <S2SV_ModEnd> ( TAG , <S2SV_ModStart> ( HEATER_GPIO , 1 ) ; gpio_set_level ( BLUE_LED , 1 ) ; ESP_LOGI ( TAG , "heater><S2SV_blank>Up<S2SV_blank>on" <S2SV_ModEnd> ) ; vTaskDelay <S2SV_ModStart> ( HEATER_GPIO , 0 ) ; gpio_set_level ( BLUE_LED , 0 ) ; ESP_LOGI ( TAG , "heater><S2SV_blank>Down<S2SV_blank>off" <S2SV_ModEnd> ) ; vTaskDelay <S2SV_ModStart> ( BLUE_LED , 0 ) ; ESP_LOGI ( TAG , "heater><S2SV_blank>IDLE<S2SV_blank>Down<S2SV_blank>off" <S2SV_ModEnd> ) ; static |
1,311 | CWE-000 void perfectErrorCorrection ( ) { char verbose = 0 ; int i ; int round = 0 ; int change = 0 ; int oldchange ; int pro = 0 ; char * dotFile = ( char * ) malloc ( sizeof ( char ) * 100 ) ; do { printf ( "ErrorCorrection<S2SV_blank>Round<S2SV_blank>%i\\n" , round ) ; countKmers ( ) ; change = 0 ; for ( i = 1 ; i < graph -> V ; i ++ ) { if ( i % ( graph -> V / 100 ) ) { pro ++ ; <S2SV_StartBug> printf ( "%i<S2SV_blank>\\%<S2SV_blank>(%i)<S2SV_blank>of<S2SV_blank>reads<S2SV_blank>Corrected\\n" , pro , i ) ; <S2SV_EndBug> } oldchange = change ; while ( collapse ( i , 1 ) ) { change ++ ; if ( change - oldchange > 10 ) break ; } while ( collapse ( i , 0 ) ) { change ++ ; if ( change - oldchange > 10 ) break ; } } round ++ ; if ( round > 10 ) break ; if ( verbose ) { sprintf ( dotFile , "test_%i.dot" , round ) ; writeDot ( dotFile ) ; } } while ( change ) ; indelHandle ( i ) ; } | <S2SV_ModStart> ; printf ( "%i<S2SV_blank>%%<S2SV_blank>(%i)<S2SV_blank>of<S2SV_blank>reads<S2SV_blank>Corrected\\n" <S2SV_ModEnd> , pro , |
1,312 | CWE-000 void nrf51_tag_db_initialize ( void ) { DBG_DB_INITIALIZE ( ) ; <S2SV_StartBug> nrf51_tag_db_entry_count_scan ( ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( ) ; nrf51_tag_db_erase ( ) ; |
1,313 | CWE-000 static gboolean _gl_tex_create ( GstGLMemory * gl_mem , GError * * error ) { GstGLContext * context = gl_mem -> mem . context ; GLenum internal_format ; GLenum tex_format ; GLenum tex_type ; tex_format = gl_mem -> tex_format ; tex_type = GL_UNSIGNED_BYTE ; <S2SV_StartBug> if ( gl_mem -> tex_format == GST_GL_RGB565 ) <S2SV_EndBug> <S2SV_StartBug> tex_type = GL_UNSIGNED_SHORT_5_6_5 ; <S2SV_EndBug> internal_format = gst_gl_sized_gl_format_from_gl_format_type ( context , tex_format , tex_type ) ; if ( ! gl_mem -> texture_wrapped ) { gl_mem -> tex_id = _new_texture ( context , gst_gl_texture_target_to_gl ( gl_mem -> tex_target ) , internal_format , tex_format , tex_type , gl_mem -> tex_width , GL_MEM_HEIGHT ( gl_mem ) ) ; GST_TRACE ( "Generating<S2SV_blank>texture<S2SV_blank>id:%u<S2SV_blank>format:%u<S2SV_blank>type:%u<S2SV_blank>dimensions:%ux%u" , gl_mem -> tex_id , tex_format , tex_type , gl_mem -> tex_width , GL_MEM_HEIGHT ( gl_mem ) ) ; } return TRUE ; } | <S2SV_ModStart> == GST_GL_RGB565 ) { tex_format = GST_GL_RGB ; <S2SV_ModStart> = GL_UNSIGNED_SHORT_5_6_5 ; } |
1,314 | CWE-000 static void mlx5i_init ( struct mlx5_core_dev * mdev , struct net_device * netdev , const struct mlx5e_profile * profile , void * ppriv ) { struct mlx5e_priv * priv = mlx5i_epriv ( netdev ) ; priv -> mdev = mdev ; priv -> netdev = netdev ; priv -> profile = profile ; priv -> ppriv = ppriv ; mlx5e_build_nic_params ( mdev , & priv -> channels . params , profile -> max_nch ( mdev ) ) ; <S2SV_StartBug> mutex_init ( & priv -> state_lock ) ; <S2SV_EndBug> netdev -> hw_features |= NETIF_F_SG ; netdev -> hw_features |= NETIF_F_IP_CSUM ; netdev -> hw_features |= NETIF_F_IPV6_CSUM ; netdev -> hw_features |= NETIF_F_GRO ; netdev -> hw_features |= NETIF_F_TSO ; netdev -> hw_features |= NETIF_F_TSO6 ; netdev -> hw_features |= NETIF_F_RXCSUM ; netdev -> hw_features |= NETIF_F_RXHASH ; netdev -> netdev_ops = & mlx5i_netdev_ops ; } | <S2SV_ModStart> ) ) ; mlx5e_set_rq_type_params ( mdev , & priv -> channels . params , MLX5_WQ_TYPE_LINKED_LIST ) ; priv -> channels . params . lro_en = false ; |
1,315 | CWE-000 int log_enqueue ( int prio , const char * fmt , va_list ap ) { int len , fwd ; char buff [ MAX_MSG_SIZE ] ; struct logmsg * msg ; struct logmsg * lastmsg ; lastmsg = ( struct logmsg * ) la -> tail ; if ( ! la -> empty ) { fwd = sizeof ( struct logmsg ) + strlen ( ( char * ) & lastmsg -> str ) * sizeof ( char ) + 1 ; la -> tail += fwd ; } vsnprintf ( buff , MAX_MSG_SIZE , fmt , ap ) ; len = strlen ( buff ) * sizeof ( char ) + 1 ; if ( la -> head <= la -> tail && ( len + sizeof ( struct logmsg ) ) > ( la -> end - la -> tail ) ) { logdbg ( stderr , "enqueue:<S2SV_blank>rewind<S2SV_blank>tail<S2SV_blank>to<S2SV_blank>%p\\n" , la -> tail ) ; la -> tail = la -> start ; } if ( la -> head > la -> tail && ( len + sizeof ( struct logmsg ) ) > ( la -> head - la -> tail ) ) { logdbg ( stderr , "enqueue:<S2SV_blank>log<S2SV_blank>area<S2SV_blank>overrun,<S2SV_blank>drop<S2SV_blank>msg\\n" ) ; if ( ! la -> empty ) <S2SV_StartBug> la -> tail -= fwd ; <S2SV_EndBug> return 1 ; } la -> empty = 0 ; msg = ( struct logmsg * ) la -> tail ; msg -> prio = prio ; memcpy ( ( void * ) & msg -> str , buff , len ) ; lastmsg -> next = la -> tail ; msg -> next = la -> head ; logdbg ( stderr , "enqueue:<S2SV_blank>%p,<S2SV_blank>%p,<S2SV_blank>%i,<S2SV_blank>%s\\n" , ( void * ) msg , msg -> next , msg -> prio , ( char * ) & msg -> str ) ; # if LOGDBG dump_logarea ( ) ; # endif return 0 ; } | <S2SV_ModStart> la -> tail = lastmsg <S2SV_ModEnd> ; return 1 |
1,316 | CWE-000 void kmain ( ) { term_init ( ) ; show_hello_message ( ) ; gdt_install ( ) ; idt_install ( ) ; irq_install ( ) ; init_pageframe_allocator ( ) ; init_paging ( ) ; initialize_kmalloc ( ) ; set_timer_freq ( TIMER_HZ ) ; irq_set_mask ( 7 ) ; irq_install_handler ( X86_PC_TIMER_IRQ , timer_handler ) ; irq_install_handler ( X86_PC_KEYBOARD_IRQ , keyboard_handler ) ; set_kernel_stack ( KERNEL_BASE_STACK_ADDR ) ; setup_syscall_interface ( ) ; mount_memdisk ( ) ; initialize_tasklets ( ) ; enable_interrupts ( ) ; init_kb ( ) ; <S2SV_StartBug> kthread_create ( simple_kthread ) ; <S2SV_EndBug> run_usermode_init ( ) ; NOT_REACHED ( ) ; } | <S2SV_ModStart> ; kthread_create ( simple_test_kthread ) ; kthread_create ( tasklet_runner_kthread <S2SV_ModEnd> ) ; run_usermode_init |
1,317 | CWE-000 void md_check_recovery ( struct mddev * mddev ) { if ( mddev -> suspended ) return ; if ( mddev -> bitmap ) bitmap_daemon_work ( mddev ) ; if ( signal_pending ( current ) ) { if ( mddev -> pers -> sync_request && ! mddev -> external ) { pr_debug ( "md:<S2SV_blank>%s<S2SV_blank>in<S2SV_blank>immediate<S2SV_blank>safe<S2SV_blank>mode\\n" , mdname ( mddev ) ) ; mddev -> safemode = 2 ; } flush_signals ( current ) ; } if ( mddev -> ro && ! test_bit ( MD_RECOVERY_NEEDED , & mddev -> recovery ) ) return ; if ( ! ( ( mddev -> sb_flags & ~ ( 1 << MD_SB_CHANGE_PENDING ) ) || test_bit ( MD_RECOVERY_NEEDED , & mddev -> recovery ) || <S2SV_StartBug> test_bit ( MD_RECOVERY_DONE , & mddev -> recovery ) || <S2SV_EndBug> test_bit ( MD_RELOAD_SB , & mddev -> flags ) || ( mddev -> external == 0 && mddev -> safemode == 1 ) || ( mddev -> safemode == 2 && ! atomic_read ( & mddev -> writes_pending ) && ! mddev -> in_sync && mddev -> recovery_cp == MaxSector ) ) ) return ; if ( mddev_trylock ( mddev ) ) { int spares = 0 ; if ( mddev -> ro ) { struct md_rdev * rdev ; if ( ! mddev -> external && mddev -> in_sync ) rdev_for_each ( rdev , mddev ) clear_bit ( Blocked , & rdev -> flags ) ; remove_and_add_spares ( mddev , NULL ) ; set_bit ( MD_RECOVERY_INTR , & mddev -> recovery ) ; md_reap_sync_thread ( mddev ) ; clear_bit ( MD_RECOVERY_RECOVER , & mddev -> recovery ) ; clear_bit ( MD_RECOVERY_NEEDED , & mddev -> recovery ) ; clear_bit ( MD_SB_CHANGE_PENDING , & mddev -> sb_flags ) ; goto unlock ; } if ( mddev_is_clustered ( mddev ) ) { struct md_rdev * rdev ; rdev_for_each ( rdev , mddev ) { if ( test_and_clear_bit ( ClusterRemove , & rdev -> flags ) && rdev -> raid_disk < 0 ) md_kick_rdev_from_array ( rdev ) ; } <S2SV_StartBug> if ( test_and_clear_bit ( MD_RELOAD_SB , & mddev -> flags ) ) <S2SV_EndBug> md_reload_sb ( mddev , mddev -> good_device_nr ) ; } if ( ! mddev -> external ) { int did_change = 0 ; spin_lock ( & mddev -> lock ) ; if ( mddev -> safemode && ! atomic_read ( & mddev -> writes_pending ) && ! mddev -> in_sync && mddev -> recovery_cp == MaxSector ) { mddev -> in_sync = 1 ; did_change = 1 ; set_bit ( MD_SB_CHANGE_CLEAN , & mddev -> sb_flags ) ; } if ( mddev -> safemode == 1 ) mddev -> safemode = 0 ; spin_unlock ( & mddev -> lock ) ; if ( did_change ) sysfs_notify_dirent_safe ( mddev -> sysfs_state ) ; } if ( mddev -> sb_flags ) md_update_sb ( mddev , 0 ) ; if ( test_bit ( MD_RECOVERY_RUNNING , & mddev -> recovery ) && ! test_bit ( MD_RECOVERY_DONE , & mddev -> recovery ) ) { clear_bit ( MD_RECOVERY_NEEDED , & mddev -> recovery ) ; goto unlock ; } if ( mddev -> sync_thread ) { md_reap_sync_thread ( mddev ) ; goto unlock ; } mddev -> curr_resync_completed = 0 ; spin_lock ( & mddev -> lock ) ; set_bit ( MD_RECOVERY_RUNNING , & mddev -> recovery ) ; spin_unlock ( & mddev -> lock ) ; clear_bit ( MD_RECOVERY_INTR , & mddev -> recovery ) ; clear_bit ( MD_RECOVERY_DONE , & mddev -> recovery ) ; if ( ! test_and_clear_bit ( MD_RECOVERY_NEEDED , & mddev -> recovery ) || test_bit ( MD_RECOVERY_FROZEN , & mddev -> recovery ) ) goto not_running ; if ( mddev -> reshape_position != MaxSector ) { if ( mddev -> pers -> check_reshape == NULL || mddev -> pers -> check_reshape ( mddev ) != 0 ) goto not_running ; set_bit ( MD_RECOVERY_RESHAPE , & mddev -> recovery ) ; clear_bit ( MD_RECOVERY_RECOVER , & mddev -> recovery ) ; } else if ( ( spares = remove_and_add_spares ( mddev , NULL ) ) ) { clear_bit ( MD_RECOVERY_SYNC , & mddev -> recovery ) ; clear_bit ( MD_RECOVERY_CHECK , & mddev -> recovery ) ; clear_bit ( MD_RECOVERY_REQUESTED , & mddev -> recovery ) ; set_bit ( MD_RECOVERY_RECOVER , & mddev -> recovery ) ; } else if ( mddev -> recovery_cp < MaxSector ) { set_bit ( MD_RECOVERY_SYNC , & mddev -> recovery ) ; clear_bit ( MD_RECOVERY_RECOVER , & mddev -> recovery ) ; } else if ( ! test_bit ( MD_RECOVERY_SYNC , & mddev -> recovery ) ) goto not_running ; if ( mddev -> pers -> sync_request ) { if ( spares ) { bitmap_write_all ( mddev -> bitmap ) ; } INIT_WORK ( & mddev -> del_work , md_start_sync ) ; queue_work ( md_misc_wq , & mddev -> del_work ) ; goto unlock ; } not_running : if ( ! mddev -> sync_thread ) { clear_bit ( MD_RECOVERY_RUNNING , & mddev -> recovery ) ; wake_up ( & resync_wait ) ; if ( test_and_clear_bit ( MD_RECOVERY_RECOVER , & mddev -> recovery ) ) if ( mddev -> sysfs_action ) sysfs_notify_dirent_safe ( mddev -> sysfs_action ) ; } unlock : wake_up ( & mddev -> sb_wait ) ; mddev_unlock ( mddev ) ; } } | <S2SV_ModStart> mddev -> recovery <S2SV_ModEnd> ) || ( <S2SV_ModStart> ) ; } <S2SV_ModEnd> } if ( |
1,318 | CWE-000 static pj_bool_t endpoint_lookup ( pjsip_rx_data * rdata ) { struct ast_sip_endpoint * endpoint ; struct unidentified_request * unid ; int is_ack = rdata -> msg_info . msg -> line . req . method . id == PJSIP_ACK_METHOD ; endpoint = rdata -> endpt_info . mod_data [ endpoint_mod . id ] ; if ( endpoint ) { unid = ao2_find ( unidentified_requests , rdata -> pkt_info . src_name , OBJ_SEARCH_KEY ) ; if ( unid ) { ao2_unlink ( unidentified_requests , unid ) ; ao2_ref ( unid , - 1 ) ; <S2SV_StartBug> } <S2SV_EndBug> return PJ_FALSE ; } endpoint = ast_sip_identify_endpoint ( rdata ) ; if ( endpoint ) { unid = ao2_find ( unidentified_requests , rdata -> pkt_info . src_name , OBJ_SEARCH_KEY ) ; if ( unid ) { ao2_unlink ( unidentified_requests , unid ) ; ao2_ref ( unid , - 1 ) ; } } if ( ! endpoint ) { endpoint = ast_sip_get_artificial_endpoint ( ) ; } rdata -> endpt_info . mod_data [ endpoint_mod . id ] = endpoint ; if ( endpoint == artificial_endpoint && ! is_ack ) { char name [ AST_UUID_STR_LEN ] = "" ; pjsip_uri * from = rdata -> msg_info . from -> uri ; if ( PJSIP_URI_SCHEME_IS_SIP ( from ) || PJSIP_URI_SCHEME_IS_SIPS ( from ) ) { pjsip_sip_uri * sip_from = pjsip_uri_get_uri ( from ) ; ast_copy_pj_str ( name , & sip_from -> user , sizeof ( name ) ) ; } unid = ao2_find ( unidentified_requests , rdata -> pkt_info . src_name , OBJ_SEARCH_KEY ) ; if ( unid ) { check_endpoint ( rdata , unid , name ) ; ao2_ref ( unid , - 1 ) ; } else if ( using_auth_username ) { ao2_wrlock ( unidentified_requests ) ; unid = ao2_find ( unidentified_requests , rdata -> pkt_info . src_name , OBJ_SEARCH_KEY | OBJ_NOLOCK ) ; if ( unid ) { check_endpoint ( rdata , unid , name ) ; } else { unid = ao2_alloc_options ( sizeof ( * unid ) + strlen ( rdata -> pkt_info . src_name ) + 1 , NULL , AO2_ALLOC_OPT_LOCK_RWLOCK ) ; if ( ! unid ) { ao2_unlock ( unidentified_requests ) ; pjsip_endpt_respond_stateless ( ast_sip_get_pjsip_endpoint ( ) , rdata , 500 , NULL , NULL , NULL ) ; return PJ_TRUE ; } strcpy ( unid -> src_name , rdata -> pkt_info . src_name ) ; unid -> first_seen = ast_tvnow ( ) ; unid -> count = 1 ; ao2_link_flags ( unidentified_requests , unid , OBJ_NOLOCK ) ; } ao2_ref ( unid , - 1 ) ; ao2_unlock ( unidentified_requests ) ; } else { log_failed_request ( rdata , "No<S2SV_blank>matching<S2SV_blank>endpoint<S2SV_blank>found" , 0 , 0 ) ; ast_sip_report_invalid_endpoint ( name , rdata ) ; } } <S2SV_StartBug> return PJ_FALSE ; <S2SV_EndBug> } | <S2SV_ModStart> ) ; } apply_acls ( rdata ) ; <S2SV_ModStart> ; } } apply_acls ( rdata ) ; |
1,319 | CWE-000 int lpfc_hba_init_link ( struct lpfc_hba * phba ) { struct lpfc_vport * vport = phba -> pport ; LPFC_MBOXQ_t * pmb ; MAILBOX_t * mb ; int rc ; pmb = mempool_alloc ( phba -> mbox_mem_pool , GFP_KERNEL ) ; if ( ! pmb ) { phba -> link_state = LPFC_HBA_ERROR ; return - ENOMEM ; } mb = & pmb -> u . mb ; pmb -> vport = vport ; lpfc_init_link ( phba , pmb , phba -> cfg_topology , phba -> cfg_link_speed ) ; pmb -> mbox_cmpl = lpfc_sli_def_mbox_cmpl ; lpfc_set_loopback_flag ( phba ) ; rc = lpfc_sli_issue_mbox ( phba , pmb , MBX_NOWAIT ) ; if ( rc != MBX_SUCCESS ) { lpfc_printf_log ( phba , KERN_ERR , LOG_INIT , "0498<S2SV_blank>Adapter<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>init,<S2SV_blank>mbxCmd<S2SV_blank>x%x<S2SV_blank>" "INIT_LINK,<S2SV_blank>mbxStatus<S2SV_blank>x%x\\n" , mb -> mbxCommand , mb -> mbxStatus ) ; writel ( 0 , phba -> HCregaddr ) ; readl ( phba -> HCregaddr ) ; writel ( 0xffffffff , phba -> HAregaddr ) ; readl ( phba -> HAregaddr ) ; phba -> link_state = LPFC_HBA_ERROR ; if ( rc != MBX_BUSY ) mempool_free ( pmb , phba -> mbox_mem_pool ) ; return - EIO ; } <S2SV_StartBug> phba -> cfg_suppress_link_up = 0 ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> -> cfg_suppress_link_up = LPFC_INITIALIZE_LINK <S2SV_ModEnd> ; return 0 |
1,320 | CWE-000 void sim_stop_timer_services ( void ) { int tmr ; sim_debug ( DBG_TRC , & sim_timer_dev , "sim_stop_timer_services()\\n" ) ; for ( tmr = 0 ; tmr <= SIM_NTIMERS ; tmr ++ ) { int32 accum ; if ( sim_clock_unit [ tmr ] ) { sim_cancel ( & sim_timer_units [ tmr ] ) ; if ( rtc_hz [ tmr ] ) sim_activate ( sim_clock_unit [ tmr ] , rtc_currd [ tmr ] ) ; accum = 1 ; while ( sim_clock_cosched_queue [ tmr ] != QUEUE_LIST_END ) { UNIT * cptr = sim_clock_cosched_queue [ tmr ] ; sim_clock_cosched_queue [ tmr ] = cptr -> next ; cptr -> next = NULL ; cptr -> cancel = NULL ; accum += cptr -> time ; _sim_activate ( cptr , accum * rtc_currd [ tmr ] ) ; } } } # if defined ( SIM_ASYNCH_CLOCKS ) pthread_mutex_lock ( & sim_timer_lock ) ; if ( sim_timer_thread_running ) { sim_debug ( DBG_TRC , & sim_timer_dev , "sim_stop_timer_services()<S2SV_blank>-<S2SV_blank>stopping\\n" ) ; pthread_cond_signal ( & sim_timer_wake ) ; pthread_mutex_unlock ( & sim_timer_lock ) ; pthread_join ( sim_timer_thread , NULL ) ; sim_timer_thread_running = FALSE ; while ( sim_wallclock_queue != QUEUE_LIST_END ) { UNIT * uptr = sim_wallclock_queue ; <S2SV_StartBug> double d_due_delta = uptr -> a_due_time - sim_timenow_double ( ) ; <S2SV_EndBug> int32 inst_delay ; <S2SV_StartBug> double inst_delay_d ; <S2SV_EndBug> uptr -> cancel ( uptr ) ; <S2SV_StartBug> if ( d_due_delta < 0.0 ) <S2SV_EndBug> <S2SV_StartBug> d_due_delta = 0.0 ; <S2SV_EndBug> <S2SV_StartBug> inst_delay_d = sim_timer_inst_per_sec ( ) * d_due_delta ; <S2SV_EndBug> <S2SV_StartBug> if ( inst_delay_d > ( double ) 0x7fffffff ) <S2SV_EndBug> <S2SV_StartBug> inst_delay_d = ( double ) 0x7fffffff ; <S2SV_EndBug> inst_delay = ( int32 ) inst_delay_d ; if ( ( inst_delay == 0 ) && ( inst_delay_d != 0.0 ) ) inst_delay = 1 ; _sim_activate ( uptr , inst_delay ) ; } } else pthread_mutex_unlock ( & sim_timer_lock ) ; # endif } | <S2SV_ModStart> sim_wallclock_queue ; double inst_delay_d = uptr -> a_due_gtime - sim_gtime <S2SV_ModEnd> ( ) ; <S2SV_ModStart> int32 inst_delay ; <S2SV_ModEnd> uptr -> cancel <S2SV_ModStart> ; if ( inst_delay_d <S2SV_ModEnd> < 0.0 ) <S2SV_ModStart> < 0.0 ) inst_delay_d <S2SV_ModEnd> = 0.0 ; <S2SV_ModStart> = 0.0 ; <S2SV_ModEnd> if ( inst_delay_d <S2SV_ModStart> ( double ) 0x7FFFFFFF <S2SV_ModEnd> ) inst_delay_d = <S2SV_ModStart> ( double ) 0x7FFFFFFF <S2SV_ModEnd> ; inst_delay = |
1,321 | CWE-000 static bool G_CheckSpot ( int playernum , mapthing_t * mthing ) { fixed_t x ; fixed_t y ; fixed_t xa ; fixed_t ya ; subsector_t * ss ; int i ; int an ; mobj_t * mo ; if ( ! players [ playernum ] . mo ) { for ( i = 0 ; i < playernum ; i ++ ) { if ( ! players [ i ] . mo ) { continue ; } if ( players [ i ] . mo -> x == mthing -> x << FRACBITS && players [ i ] . mo -> y == mthing -> y << FRACBITS ) { <S2SV_StartBug> printf ( "Player<S2SV_blank>%d<S2SV_blank>on<S2SV_blank>spot\\n" , i ) ; <S2SV_EndBug> return false ; } } return true ; } x = mthing -> x << FRACBITS ; y = mthing -> y << FRACBITS ; players [ playernum ] . mo -> flags |= MF_SOLID ; i = P_CheckPosition ( players [ playernum ] . mo , x , y ) ; players [ playernum ] . mo -> flags &= ~ MF_SOLID ; if ( ! i ) { puts ( "Something<S2SV_blank>in<S2SV_blank>the<S2SV_blank>way" ) ; return false ; } if ( corpse_queue_size < 0 ) { I_Error ( "G_CheckSpot:<S2SV_blank>corpse_queue_size<S2SV_blank><<S2SV_blank>0<S2SV_blank>(%d)" , corpse_queue_size ) ; } if ( corpse_queue_size == 0 ) { P_RemoveMobj ( players [ playernum ] . mo ) ; } else { if ( ! corpse_queue ) { corpse_queue = g_queue_new ( ) ; } if ( g_queue_get_length ( corpse_queue ) == corpse_queue_size ) { P_RemoveMobj ( g_queue_pop_head ( corpse_queue ) ) ; } g_queue_push_tail ( corpse_queue , players [ playernum ] . mo ) ; } ss = R_PointInSubsector ( x , y ) ; switch ( mthing -> angle ) { case 45 : an = 1024 ; break ; case 90 : an = 2048 ; break ; case 135 : an = 3072 ; break ; case 180 : an = - 4096 ; break ; case 225 : an = - 3072 ; break ; case 270 : an = - 2048 ; break ; case 315 : an = - 1024 ; break ; case 360 : case 0 : an = 0 ; break ; default : an = 0 ; I_Error ( "Unexpected<S2SV_blank>angle<S2SV_blank>%d\\n" , mthing -> angle ) ; break ; } xa = finecosine [ an ] ; ya = finesine [ an ] ; if ( compatibility_level <= finaldoom_compatibility || compatibility_level == prboom_4_compatibility ) { switch ( an ) { case - 4096 : xa = finetangent [ 2048 ] ; ya = finetangent [ 0 ] ; break ; case - 3072 : xa = finetangent [ 3072 ] ; ya = finetangent [ 1024 ] ; break ; case - 2048 : xa = finesine [ 0 ] ; ya = finetangent [ 2048 ] ; break ; case - 1024 : xa = finesine [ 1024 ] ; ya = finetangent [ 3072 ] ; break ; case 1024 : case 2048 : case 3072 : case 4096 : case 0 : break ; default : I_Error ( "(%d)<S2SV_blank>G_CheckSpot:<S2SV_blank>unexpected<S2SV_blank>angle<S2SV_blank>%d<S2SV_blank>(%d)\\n" , gametic , an , mthing -> angle ) ; break ; } } mo = P_SpawnMobj ( x + 20 * xa , y + 20 * ya , ss -> sector -> floorheight , MT_TFOG ) ; if ( players [ consoleplayer ] . viewz != 1 ) { S_StartSound ( mo , sfx_telept ) ; } return true ; } | <S2SV_ModStart> FRACBITS ) { <S2SV_ModEnd> return false ; |
1,322 | CWE-000 object newSymbol ( str ) char * str ; { int hash ; object newSym , link ; char * p ; hash = 0 ; for ( p = str ; * p ; p ++ ) hash += * p ; if ( hash < 0 ) hash = - hash ; hash = 2 * ( hash % ( objectSize ( symbols ) / 2 ) ) ; newSym = basicAt ( symbols , hash + 1 ) ; <S2SV_StartBug> if ( streq ( str , charPtr ( newSym ) ) ) <S2SV_EndBug> return ( newSym ) ; for ( link = basicAt ( symbols , hash + 2 ) ; link != nilobj ; link = basicAt ( link , 2 ) ) { newSym = basicAt ( link , 1 ) ; if ( streq ( str , charPtr ( newSym ) ) ) return ( newSym ) ; } newSym = allocSymbol ( str ) ; setClass ( newSym , symbolclass ) ; if ( basicAt ( symbols , hash + 1 ) == nilobj ) basicAtPut ( symbols , hash + 1 , newSym ) ; else { link = allocObject ( 2 ) ; basicAtPut ( link , 1 , newSym ) ; basicAtPut ( link , 2 , basicAt ( symbols , hash + 2 ) ) ; basicAtPut ( symbols , hash + 2 , link ) ; } return ( newSym ) ; } | <S2SV_ModStart> ; if ( charPtr ( newSym ) != NULL && |
1,323 | CWE-000 int posix_handle_pair ( xlator_t * this , const char * real_path , char * key , data_t * value , int flags , struct iatt * stbuf ) { int sys_ret = - 1 ; int ret = 0 ; # ifdef GF_DARWIN_HOST_OS const int error_code = EINVAL ; # else const int error_code = EEXIST ; # endif if ( XATTR_IS_PATHINFO ( key ) ) { ret = - EACCES ; goto out ; } else if ( posix_is_gfid2path_xattr ( key ) ) { ret = - ENOTSUP ; <S2SV_StartBug> goto out ; <S2SV_EndBug> } else if ( ZR_FILE_CONTENT_REQUEST ( key ) ) { ret = posix_set_file_contents ( this , real_path , key , value , flags ) ; } else if ( GF_POSIX_ACL_REQUEST ( key ) ) { if ( stbuf && IS_DHT_LINKFILE_MODE ( stbuf ) ) goto out ; ret = posix_pacl_set ( real_path , key , value -> data ) ; } else if ( ! strncmp ( key , POSIX_ACL_ACCESS_XATTR , strlen ( key ) ) && stbuf && IS_DHT_LINKFILE_MODE ( stbuf ) ) { goto out ; } else { sys_ret = sys_lsetxattr ( real_path , key , value -> data , value -> len , flags ) ; # ifdef GF_DARWIN_HOST_OS posix_dump_buffer ( this , real_path , key , value , flags ) ; # endif if ( sys_ret < 0 ) { ret = - errno ; if ( errno == ENOENT ) { if ( ! posix_special_xattr ( marker_xattrs , key ) ) { gf_msg ( this -> name , GF_LOG_ERROR , errno , P_MSG_XATTR_FAILED , "setxattr<S2SV_blank>on<S2SV_blank>%s<S2SV_blank>failed" , real_path ) ; } } else { if ( errno == error_code ) { gf_msg_debug ( this -> name , 0 , "%s:<S2SV_blank>key:%s" "flags:<S2SV_blank>%u<S2SV_blank>length:%d" , real_path , key , flags , value -> len ) ; } else { gf_msg ( this -> name , GF_LOG_ERROR , errno , P_MSG_XATTR_FAILED , "%s:<S2SV_blank>key:%s" "flags:<S2SV_blank>%u<S2SV_blank>length:%d" , real_path , key , flags , value -> len ) ; } } goto out ; } } out : return ret ; } | <S2SV_ModStart> ; goto out <S2SV_ModEnd> ; } else |
1,324 | CWE-000 static void np2srv_module_install_clb ( const char * module_name , const char * revision , sr_module_state_t state , void * UNUSED ( private_ctx ) ) { int rc ; char * data = NULL ; const struct lys_module * mod ; sr_schema_t * schemas = NULL ; size_t count , i , j ; if ( state == SR_MS_IMPLEMENTED ) { rc = sr_get_schema ( np2srv . sr_sess . srs , module_name , revision , NULL , SR_SCHEMA_YIN , & data ) ; if ( rc != SR_ERR_OK ) { ERR ( "Unable<S2SV_blank>to<S2SV_blank>get<S2SV_blank>installed<S2SV_blank>module<S2SV_blank>%s%s%s<S2SV_blank>from<S2SV_blank>sysrepo<S2SV_blank>(%s),<S2SV_blank>schema<S2SV_blank>won\'t<S2SV_blank>be<S2SV_blank>available." , module_name , revision ? "@" : "" , revision ? revision : "" , sr_strerror ( rc ) ) ; return ; } pthread_rwlock_wrlock ( & np2srv . ly_ctx_lock ) ; VRB ( "Loading<S2SV_blank>added<S2SV_blank>schema<S2SV_blank>\\"%s%s%s\\"<S2SV_blank>from<S2SV_blank>sysrepo." , module_name , revision ? "@" : "" , revision ? revision : "" ) ; mod = lys_parse_mem ( np2srv . ly_ctx , data , LYS_IN_YIN ) ; free ( data ) ; if ( ! mod ) { ERR ( "Unable<S2SV_blank>to<S2SV_blank>parse<S2SV_blank>installed<S2SV_blank>module<S2SV_blank>%s%s%s<S2SV_blank>from<S2SV_blank>sysrepo<S2SV_blank>(%s),<S2SV_blank>schema<S2SV_blank>won\'t<S2SV_blank>be<S2SV_blank>available." , module_name , revision ? "@" : "" , revision ? revision : "" , sr_strerror ( rc ) ) ; } else { rc = sr_list_schemas ( np2srv . sr_sess . srs , & schemas , & count ) ; <S2SV_StartBug> if ( rc != SR_ERR_OK ) { <S2SV_EndBug> ERR ( "Unable<S2SV_blank>to<S2SV_blank>get<S2SV_blank>list<S2SV_blank>of<S2SV_blank>sysrepo<S2SV_blank>schemas<S2SV_blank>for<S2SV_blank>%s%s%s<S2SV_blank>module<S2SV_blank>feature<S2SV_blank>(%s)." , module_name , revision ? "@" : "" , revision ? revision : "" , sr_strerror ( rc ) ) ; return ; } for ( i = 0 ; i < count ; i ++ ) { if ( strcmp ( schemas [ i ] . module_name , module_name ) ) { continue ; } for ( j = 0 ; j < schemas [ i ] . enabled_feature_cnt ; ++ j ) { lys_features_enable ( mod , schemas [ i ] . enabled_features [ j ] ) ; } break ; } np2srv_module_assign_clbs ( mod ) ; } } else if ( state == SR_MS_IMPORTED ) { } else { VRB ( "Removing<S2SV_blank>schema<S2SV_blank>\\"%s%s%s\\"<S2SV_blank>according<S2SV_blank>to<S2SV_blank>changes<S2SV_blank>in<S2SV_blank>sysrepo." , module_name , revision ? "@" : "" , revision ? revision : "" ) ; pthread_rwlock_wrlock ( & np2srv . ly_ctx_lock ) ; ly_ctx_remove_module ( np2srv . ly_ctx , module_name , revision , NULL ) ; } pthread_rwlock_unlock ( & np2srv . ly_ctx_lock ) ; } | <S2SV_ModStart> SR_ERR_OK ) { pthread_rwlock_unlock ( & np2srv . ly_ctx_lock ) ; |
1,325 | CWE-000 static void cmd_parse_list ( struct ImapData * idata , char * s ) { struct ImapList * list = NULL ; struct ImapList lb ; char delimbuf [ 5 ] ; <S2SV_StartBug> long litlen ; <S2SV_EndBug> if ( idata -> cmddata && idata -> cmdtype == IMAP_CT_LIST ) list = ( struct ImapList * ) idata -> cmddata ; else list = & lb ; memset ( list , 0 , sizeof ( struct ImapList ) ) ; s = imap_next_word ( s ) ; if ( * s != '(' ) { mutt_debug ( 1 , "Bad<S2SV_blank>LIST<S2SV_blank>response\\n" ) ; return ; } s ++ ; while ( * s ) { if ( mutt_str_strncasecmp ( s , "\\\\NoSelect" , 9 ) == 0 ) list -> noselect = true ; else if ( mutt_str_strncasecmp ( s , "\\\\NoInferiors" , 12 ) == 0 ) list -> noinferiors = true ; else if ( mutt_str_strncasecmp ( s , "\\\\HasNoChildren" , 14 ) == 0 ) list -> noinferiors = true ; s = imap_next_word ( s ) ; if ( * ( s - 2 ) == ')' ) break ; } if ( mutt_str_strncasecmp ( s , "NIL" , 3 ) != 0 ) { delimbuf [ 0 ] = '\\0' ; mutt_str_strcat ( delimbuf , 5 , s ) ; imap_unquote_string ( delimbuf ) ; list -> delim = delimbuf [ 0 ] ; } s = imap_next_word ( s ) ; if ( ! imap_get_literal_count ( s , & litlen ) ) { if ( imap_cmd_step ( idata ) != IMAP_CMD_CONTINUE ) { idata -> status = IMAP_FATAL ; return ; } list -> name = idata -> buf ; } else { imap_unmunge_mbox_name ( idata , s ) ; list -> name = s ; } if ( list -> name [ 0 ] == '\\0' ) { idata -> delim = list -> delim ; mutt_debug ( 3 , "Root<S2SV_blank>delimiter:<S2SV_blank>%c\\n" , idata -> delim ) ; } } | <S2SV_ModStart> 5 ] ; unsigned int <S2SV_ModEnd> litlen ; if |
1,326 | CWE-000 static int decode_subframe ( TAKDecContext * s , int32_t * decoded , int subframe_size , int prev_subframe_size ) { GetBitContext * gb = & s -> gb ; int x , y , i , j , ret = 0 ; int dshift , size , filter_quant , filter_order ; int tfilter [ MAX_PREDICTORS ] ; if ( ! get_bits1 ( gb ) ) return decode_residues ( s , decoded , subframe_size ) ; filter_order = predictor_sizes [ get_bits ( gb , 4 ) ] ; if ( prev_subframe_size > 0 && get_bits1 ( gb ) ) { if ( filter_order > prev_subframe_size ) return AVERROR_INVALIDDATA ; decoded -= filter_order ; subframe_size += filter_order ; if ( filter_order > subframe_size ) return AVERROR_INVALIDDATA ; } else { int lpc_mode ; if ( filter_order > subframe_size ) return AVERROR_INVALIDDATA ; lpc_mode = get_bits ( gb , 2 ) ; if ( lpc_mode > 2 ) return AVERROR_INVALIDDATA ; if ( ( ret = decode_residues ( s , decoded , filter_order ) ) < 0 ) return ret ; if ( lpc_mode ) decode_lpc ( decoded , lpc_mode , filter_order ) ; } dshift = get_bits_esc4 ( gb ) ; size = get_bits1 ( gb ) + 6 ; filter_quant = 10 ; if ( get_bits1 ( gb ) ) { filter_quant -= get_bits ( gb , 3 ) + 1 ; if ( filter_quant < 3 ) return AVERROR_INVALIDDATA ; } s -> predictors [ 0 ] = get_sbits ( gb , 10 ) ; s -> predictors [ 1 ] = get_sbits ( gb , 10 ) ; s -> predictors [ 2 ] = get_sbits ( gb , size ) * ( 1 << ( 10 - size ) ) ; s -> predictors [ 3 ] = get_sbits ( gb , size ) * ( 1 << ( 10 - size ) ) ; if ( filter_order > 4 ) { int tmp = size - get_bits1 ( gb ) ; for ( i = 4 ; i < filter_order ; i ++ ) { if ( ! ( i & 3 ) ) x = tmp - get_bits ( gb , 2 ) ; s -> predictors [ i ] = get_sbits ( gb , x ) * ( 1 << ( 10 - size ) ) ; } } tfilter [ 0 ] = s -> predictors [ 0 ] * 64 ; for ( i = 1 ; i < filter_order ; i ++ ) { int32_t * p1 = & tfilter [ 0 ] ; int32_t * p2 = & tfilter [ i - 1 ] ; for ( j = 0 ; j < ( i + 1 ) / 2 ; j ++ ) { x = * p1 + ( s -> predictors [ i ] * * p2 + 256 >> 9 ) ; * p2 += s -> predictors [ i ] * * p1 + 256 >> 9 ; * p1 ++ = x ; p2 -- ; } tfilter [ i ] = s -> predictors [ i ] * 64 ; } x = 1 << ( 32 - ( 15 - filter_quant ) ) ; y = 1 << ( ( 15 - filter_quant ) - 1 ) ; for ( i = 0 , j = filter_order - 1 ; i < filter_order / 2 ; i ++ , j -- ) { s -> filter [ j ] = x - ( ( tfilter [ i ] + y ) >> ( 15 - filter_quant ) ) ; s -> filter [ i ] = x - ( ( tfilter [ j ] + y ) >> ( 15 - filter_quant ) ) ; } if ( ( ret = decode_residues ( s , & decoded [ filter_order ] , subframe_size - filter_order ) ) < 0 ) return ret ; for ( i = 0 ; i < filter_order ; i ++ ) s -> residues [ i ] = * decoded ++ >> dshift ; y = FF_ARRAY_ELEMS ( s -> residues ) - filter_order ; x = subframe_size - filter_order ; while ( x > 0 ) { int tmp = FFMIN ( y , x ) ; for ( i = 0 ; i < tmp ; i ++ ) { int v = 1 << ( filter_quant - 1 ) ; if ( filter_order & - 16 ) <S2SV_StartBug> v += s -> adsp . scalarproduct_int16 ( & s -> residues [ i ] , s -> filter , <S2SV_EndBug> filter_order & - 16 ) ; for ( j = filter_order & - 16 ; j < filter_order ; j += 4 ) { v += s -> residues [ i + j + 3 ] * s -> filter [ j + 3 ] + s -> residues [ i + j + 2 ] * s -> filter [ j + 2 ] + s -> residues [ i + j + 1 ] * s -> filter [ j + 1 ] + s -> residues [ i + j ] * s -> filter [ j ] ; } v = ( av_clip_intp2 ( v >> filter_quant , 13 ) * ( 1 << dshift ) ) - * decoded ; * decoded ++ = v ; s -> residues [ filter_order + i ] = v >> dshift ; } x -= tmp ; if ( x > 0 ) memcpy ( s -> residues , & s -> residues [ y ] , 2 * filter_order ) ; } emms_c ( ) ; return 0 ; } | <S2SV_ModStart> ) v += ( unsigned ) |
1,327 | CWE-000 <S2SV_StartBug> int pthread_setspecific ( pthread_key_t k , const void * value ) { <S2SV_EndBug> struct pthread_key_specific * specific ; struct pthread_key * key ; int res ; res = list_get ( & key_list , k , ( void * * ) & key ) ; if ( res ) { return res ; } specific = ( struct pthread_key_specific * ) malloc ( sizeof ( struct pthread_key_specific ) ) ; if ( ! specific ) { errno = ENOMEM ; return ENOMEM ; } specific -> thread = pthread_self ( ) ; specific -> value = value ; return 0 ; } | <S2SV_ModStart> int pthread_setspecific ( _pthread_key_t <S2SV_ModEnd> k , const |
1,328 | CWE-000 void print_list ( Cell * list ) { char string [ MAX_PRINT_EXPR_LENGTH + 1 ] ; <S2SV_StartBug> if ( list == NULL ) { <S2SV_EndBug> string [ 0 ] = 'T' ; string [ 1 ] = '\\n' ; string [ 2 ] = '\\0' ; } else if ( list -> type == SYS_SYM_NUM ) { sprintf ( string , "%.*d\\n" , - MAX_PRINT_EXPR_LENGTH , ( int ) ( uintptr_t ) list -> car ) ; } else if ( list -> is_atom ) { if ( list == machine -> nil ) { string [ 0 ] = '(' ; string [ 1 ] = ')' ; string [ 2 ] = '\\n' ; string [ 3 ] = '\\0' ; } else { char * symbol = get_symbol_name ( list ) ; strncpy ( string , symbol , MAX_PRINT_EXPR_LENGTH ) ; string [ strlen ( symbol ) ] = '\\n' ; string [ strlen ( symbol ) + 1 ] = '\\0' ; free ( symbol ) ; } } else { Cell * cell = list ; bool is_going_up = false ; Stack s ; MAKE_STACK ( s , Cell * ) ; PUSH ( s , Cell * , cell ) ; <S2SV_StartBug> int index = 0 ; <S2SV_EndBug> <S2SV_StartBug> string [ index ] = '(' ; <S2SV_EndBug> ++ index ; while ( s . n != 0 || is_going_up ) { if ( index > MAX_PRINT_EXPR_LENGTH - 5 ) { string [ MAX_PRINT_EXPR_LENGTH - 5 ] = '.' ; string [ MAX_PRINT_EXPR_LENGTH - 4 ] = '.' ; string [ MAX_PRINT_EXPR_LENGTH - 3 ] = '.' ; string [ MAX_PRINT_EXPR_LENGTH - 2 ] = '\\n' ; string [ MAX_PRINT_EXPR_LENGTH - 1 ] = '\\0' ; <S2SV_StartBug> printf ( "%s" , string ) ; <S2SV_EndBug> return ; } if ( is_going_up ) { if ( cell -> cdr != machine -> nil ) { string [ index ] = '<S2SV_blank>' ; ++ index ; cell = cell -> cdr ; PUSH ( s , Cell * , cell ) ; is_going_up = false ; } else { string [ index ] = ')' ; ++ index ; if ( s . n != 0 ) { POP ( s , Cell * , cell ) ; } else { is_going_up = false ; } } } else if ( cell -> is_atom || cell -> car -> is_atom ) { Cell * sym_cell = cell ; if ( cell -> is_atom ) { string [ index ] = '.' ; string [ index + 1 ] = '<S2SV_blank>' ; index += 2 ; } else { sym_cell = sym_cell -> car ; } if ( sym_cell -> type == SYS_SYM_NUM ) { index += sprintf ( string + index , "%.*d" , - ( MAX_PRINT_EXPR_LENGTH - index ) , ( int ) ( uintptr_t ) sym_cell -> car ) ; POP ( s , Cell * , cell ) ; POP ( s , Cell * , cell ) ; is_going_up = true ; } else { char * symbol = get_symbol_name ( sym_cell ) ; strncpy ( string + index , symbol , MAX_PRINT_EXPR_LENGTH - index ) ; index += strlen ( symbol ) ; free ( symbol ) ; POP ( s , Cell * , cell ) ; is_going_up = true ; } } else { string [ index ] = '(' ; ++ index ; cell = cell -> car ; PUSH ( s , Cell * , cell ) ; } } string [ index ] = '\\n' ; ++ index ; } printf ( "%s" , string ) ; } | <S2SV_ModStart> 1 ] ; <S2SV_ModEnd> int index = <S2SV_ModStart> index = 0 ; print_list_helper ( list , string , & index , false ) <S2SV_ModStart> index ] = <S2SV_ModEnd> '\\0' ; printf <S2SV_ModStart> ; printf ( "%s\\n" <S2SV_ModEnd> , string ) |
1,329 | CWE-000 Int Parser_GetFatalErrorCount ( Parser parser ) { Int count = 0 ; <S2SV_StartBug> for ( SmileList list = parser -> firstMessage ; SMILE_KIND ( list ) != SMILE_KIND_NULL ; list = LIST_REST ( list ) ) { <S2SV_EndBug> if ( ( ( ParseMessage ) list -> a ) -> messageKind == PARSEMESSAGE_FATAL ) count ++ ; } return count ; } | <S2SV_ModStart> = 0 ; SmileList list ; for ( <S2SV_ModEnd> list = parser |
1,330 | CWE-000 static int binder_mmap ( struct file * filp , struct vm_area_struct * vma ) { int ret ; struct vm_struct * area ; struct binder_proc * proc = filp -> private_data ; const char * failure_string ; struct binder_buffer * buffer ; <S2SV_StartBug> if ( proc -> tsk != current ) <S2SV_EndBug> return - EINVAL ; if ( ( vma -> vm_end - vma -> vm_start ) > SZ_4M ) vma -> vm_end = vma -> vm_start + SZ_4M ; binder_debug ( BINDER_DEBUG_OPEN_CLOSE , "binder_mmap:<S2SV_blank>%d<S2SV_blank>%lx-%lx<S2SV_blank>(%ld<S2SV_blank>K)<S2SV_blank>vma<S2SV_blank>%lx<S2SV_blank>pagep<S2SV_blank>%lx\\n" , proc -> pid , vma -> vm_start , vma -> vm_end , ( vma -> vm_end - vma -> vm_start ) / SZ_1K , vma -> vm_flags , ( unsigned long ) pgprot_val ( vma -> vm_page_prot ) ) ; if ( vma -> vm_flags & FORBIDDEN_MMAP_FLAGS ) { ret = - EPERM ; failure_string = "bad<S2SV_blank>vm_flags" ; goto err_bad_arg ; } vma -> vm_flags = ( vma -> vm_flags | VM_DONTCOPY ) & ~ VM_MAYWRITE ; mutex_lock ( & binder_mmap_lock ) ; if ( proc -> buffer ) { ret = - EBUSY ; failure_string = "already<S2SV_blank>mapped" ; goto err_already_mapped ; } area = get_vm_area ( vma -> vm_end - vma -> vm_start , VM_IOREMAP ) ; if ( area == NULL ) { ret = - ENOMEM ; failure_string = "get_vm_area" ; goto err_get_vm_area_failed ; } proc -> buffer = area -> addr ; proc -> user_buffer_offset = vma -> vm_start - ( uintptr_t ) proc -> buffer ; mutex_unlock ( & binder_mmap_lock ) ; # ifdef CONFIG_CPU_CACHE_VIPT if ( cache_is_vipt_aliasing ( ) ) { while ( CACHE_COLOUR ( ( vma -> vm_start ^ ( uint32_t ) proc -> buffer ) ) ) { pr_info ( "binder_mmap:<S2SV_blank>%d<S2SV_blank>%lx-%lx<S2SV_blank>maps<S2SV_blank>%p<S2SV_blank>bad<S2SV_blank>alignment\\n" , proc -> pid , vma -> vm_start , vma -> vm_end , proc -> buffer ) ; vma -> vm_start += PAGE_SIZE ; } } # endif proc -> pages = kzalloc ( sizeof ( proc -> pages [ 0 ] ) * ( ( vma -> vm_end - vma -> vm_start ) / PAGE_SIZE ) , GFP_KERNEL ) ; if ( proc -> pages == NULL ) { ret = - ENOMEM ; failure_string = "alloc<S2SV_blank>page<S2SV_blank>array" ; goto err_alloc_pages_failed ; } proc -> buffer_size = vma -> vm_end - vma -> vm_start ; vma -> vm_ops = & binder_vm_ops ; vma -> vm_private_data = proc ; preempt_disable ( ) ; ret = binder_update_page_range ( proc , 1 , proc -> buffer , proc -> buffer + PAGE_SIZE , vma ) ; preempt_enable_no_resched ( ) ; if ( ret ) { ret = - ENOMEM ; failure_string = "alloc<S2SV_blank>small<S2SV_blank>buf" ; goto err_alloc_small_buf_failed ; } buffer = proc -> buffer ; INIT_LIST_HEAD ( & proc -> buffers ) ; list_add ( & buffer -> entry , & proc -> buffers ) ; buffer -> free = 1 ; binder_insert_free_buffer ( proc , buffer ) ; proc -> free_async_space = proc -> buffer_size / 2 ; barrier ( ) ; proc -> files = get_files_struct ( current ) ; proc -> vma = vma ; proc -> vma_vm_mm = vma -> vm_mm ; return 0 ; err_alloc_small_buf_failed : kfree ( proc -> pages ) ; proc -> pages = NULL ; err_alloc_pages_failed : mutex_lock ( & binder_mmap_lock ) ; vfree ( proc -> buffer ) ; proc -> buffer = NULL ; err_get_vm_area_failed : err_already_mapped : mutex_unlock ( & binder_mmap_lock ) ; err_bad_arg : pr_err ( "binder_mmap:<S2SV_blank>%d<S2SV_blank>%lx-%lx<S2SV_blank>%s<S2SV_blank>failed<S2SV_blank>%d\\n" , proc -> pid , vma -> vm_start , vma -> vm_end , failure_string , ret ) ; return ret ; } | <S2SV_ModStart> tsk != current -> group_leader |
1,331 | CWE-000 <S2SV_StartBug> int build_job ( int readfd , client_t * client , joblist_t * joblist ) <S2SV_EndBug> { pid_t jpid ; if ( read ( readfd , & jpid , sizeof ( int ) ) != sizeof ( int ) <S2SV_StartBug> || add_job ( jpid , getpid ( ) , readfd , client , joblist ) < 0 ) <S2SV_EndBug> <S2SV_StartBug> { <S2SV_EndBug> return - 1 ; } return 0 ; } | <S2SV_ModStart> ( int readfd , pid_t mpid <S2SV_ModStart> ( jpid , mpid <S2SV_ModEnd> , readfd , <S2SV_ModStart> 0 ) { kill ( mpid , SIGINT ) ; waitpid ( mpid , NULL , 0 ) ; |
1,332 | CWE-000 void chick_reslash ( edict_t * self ) { if ( self -> enemy -> health > 0 ) { <S2SV_StartBug> if ( range ( self , self -> enemy ) == RANGE_MELEE ) <S2SV_EndBug> if ( random ( ) <= 0.9 ) { self -> monsterinfo . currentmove = & chick_move_slash ; return ; } else { self -> monsterinfo . currentmove = & chick_move_end_slash ; return ; } } <S2SV_StartBug> self -> monsterinfo . currentmove = & chick_move_end_slash ; <S2SV_EndBug> } | <S2SV_ModStart> == RANGE_MELEE ) { <S2SV_ModStart> ; } } } |
1,333 | CWE-000 void print_stack ( struct Stack stack ) { <S2SV_StartBug> if ( isempty ( stack ) ) return ; <S2SV_EndBug> for ( int i = stack . size - 1 ; i >= 0 ; -- i ) { printf ( "%s\\n" , stack . array [ i ] ) ; } } | <S2SV_ModStart> ) ) return ; printf ( "\\n" ) |
1,334 | CWE-000 static struct nf_conn * get_next_corpse ( struct net * net , int ( * iter ) ( struct nf_conn * i , void * data ) , void * data , unsigned int * bucket ) { struct nf_conntrack_tuple_hash * h ; struct nf_conn * ct ; <S2SV_StartBug> struct hlist_nulls_node * n ; <S2SV_EndBug> int cpu ; spinlock_t * lockp ; for ( ; * bucket < nf_conntrack_htable_size ; ( * bucket ) ++ ) { lockp = & nf_conntrack_locks [ * bucket % CONNTRACK_LOCKS ] ; local_bh_disable ( ) ; nf_conntrack_lock ( lockp ) ; if ( * bucket < nf_conntrack_htable_size ) { hlist_nulls_for_each_entry ( h , n , & nf_conntrack_hash [ * bucket ] , hnnode ) { if ( NF_CT_DIRECTION ( h ) != IP_CT_DIR_ORIGINAL ) continue ; ct = nf_ct_tuplehash_to_ctrack ( h ) ; if ( net_eq ( nf_ct_net ( ct ) , net ) && iter ( ct , data ) ) goto found ; } } spin_unlock ( lockp ) ; local_bh_enable ( ) ; cond_resched ( ) ; } <S2SV_StartBug> for_each_possible_cpu ( cpu ) { <S2SV_EndBug> struct ct_pcpu * pcpu = per_cpu_ptr ( net -> ct . pcpu_lists , cpu ) ; spin_lock_bh ( & pcpu -> lock ) ; hlist_nulls_for_each_entry ( h , n , & pcpu -> unconfirmed , hnnode ) { ct = nf_ct_tuplehash_to_ctrack ( h ) ; if ( iter ( ct , data ) ) set_bit ( IPS_DYING_BIT , & ct -> status ) ; } spin_unlock_bh ( & pcpu -> lock ) ; cond_resched ( ) ; } return NULL ; found : atomic_inc ( & ct -> ct_general . use ) ; spin_unlock ( lockp ) ; local_bh_enable ( ) ; return ct ; } | <S2SV_ModStart> hlist_nulls_node * n <S2SV_ModEnd> ; spinlock_t * <S2SV_ModStart> ) ; } <S2SV_ModEnd> return NULL ; |
1,335 | CWE-000 void register_chunk ( Chunk * header ) { <S2SV_StartBug> Bin * bin = get_smallest_bin ( header ) ; <S2SV_EndBug> add_chunk ( bin , header ) ; } | <S2SV_ModStart> header ) { size_t size = get_chunk_size ( header ) ; <S2SV_ModStart> = get_smallest_bin ( size <S2SV_ModEnd> ) ; add_chunk |
1,336 | CWE-000 <S2SV_StartBug> int check_target_type ( int c_type ) <S2SV_EndBug> { <S2SV_StartBug> if ( c_type >= 0x4000 && c_type <= 0x7FFF ) { <S2SV_EndBug> return 1 ; } switch ( c_type ) { case SQL_C_CHAR : case SQL_C_LONG : case SQL_C_SHORT : case SQL_C_FLOAT : case SQL_C_NUMERIC : case SQL_C_DEFAULT : case SQL_C_DATE : case SQL_C_TIME : case SQL_C_TIMESTAMP : case SQL_C_TYPE_DATE : case SQL_C_TYPE_TIME : case SQL_C_TYPE_TIMESTAMP : case SQL_C_INTERVAL_YEAR : case SQL_C_INTERVAL_MONTH : case SQL_C_INTERVAL_DAY : case SQL_C_INTERVAL_HOUR : case SQL_C_INTERVAL_MINUTE : case SQL_C_INTERVAL_SECOND : case SQL_C_INTERVAL_YEAR_TO_MONTH : case SQL_C_INTERVAL_DAY_TO_HOUR : case SQL_C_INTERVAL_DAY_TO_MINUTE : case SQL_C_INTERVAL_DAY_TO_SECOND : case SQL_C_INTERVAL_HOUR_TO_MINUTE : case SQL_C_INTERVAL_HOUR_TO_SECOND : case SQL_C_INTERVAL_MINUTE_TO_SECOND : case SQL_C_BINARY : case SQL_C_BIT : case SQL_C_SBIGINT : case SQL_C_UBIGINT : case SQL_C_TINYINT : case SQL_C_SLONG : case SQL_C_SSHORT : case SQL_C_STINYINT : case SQL_C_ULONG : case SQL_C_USHORT : case SQL_C_UTINYINT : case SQL_C_GUID : case SQL_C_WCHAR : case SQL_ARD_TYPE : case SQL_C_DOUBLE : return 1 ; default : return 0 ; } } | <S2SV_ModStart> ( int c_type , int connection_mode <S2SV_ModStart> { if ( connection_mode >= SQL_OV_ODBC3_80 && |
1,337 | CWE-000 void R_init_validate ( DllInfo * info ) { R_registerRoutines ( info , NULL , callMethods , NULL , NULL ) ; VALC_SYM_quote = install ( "quote" ) ; VALC_SYM_deparse = install ( "deparse" ) ; VALC_SYM_one_dot = install ( "." ) ; VALC_SYM_paren = install ( "(" ) ; VALC_SYM_current = install ( "current" ) ; VALC_SYM_errmsg = install ( "err.msg" ) ; VALC_TRUE = ScalarLogical ( 1 ) ; VALC_match_call = ( SEXP ( * ) ( SEXP , SEXP , SEXP , SEXP , SEXP , SEXP , SEXP , SEXP , SEXP ) ) R_GetCCallable ( "matchcall" , "MC_match_call_internal" ) ; VALC_alike = ( SEXP ( * ) ( SEXP , SEXP , SEXP , SEXP ) ) R_GetCCallable ( "alike" , "ALIKEC_alike_ext2" ) ; VALC_merge_msg = ( SEXP ( * ) ( SEXP ) ) R_GetCCallable ( "alike" , "ALIKEC_merge_msg" ) ; VALC_deparse = ( SEXP ( * ) ( SEXP , int ) ) R_GetCCallable ( "alike" , "ALIKEC_deparse" ) ; VALC_pad = ( const char * ( * ) ( SEXP , int , int ) ) R_GetCCallable ( "alike" , "ALIKEC_pad" ) ; VALC_pad_or_quote = ( const char * ( * ) ( SEXP , int , int ) ) R_GetCCallable ( "alike" , "ALIKEC_pad_or_quote" ) ; VALC_get_frame_data = ( SEXP ( * ) ( SEXP , SEXP , SEXP , int ) ) R_GetCCallable ( "matchcall" , "MC_get_frame_data" ) ; VALC_get_fun = ( SEXP ( * ) ( SEXP , SEXP ) ) R_GetCCallable ( "matchcall" , "MC_get_fun" ) ; CSR_strmcpy = ( char * ( * ) ( const char * , size_t ) ) R_GetCCallable ( "cstringr" , "CSR_strmcpy" ) ; CSR_smprintf4 = ( char * ( * ) ( size_t , const char * , const char * , const char * , const char * , const char * ) ) R_GetCCallable ( "cstringr" , "CSR_smprintf4" ) ; CSR_strmlen = ( size_t ( * ) ( const char * , size_t ) ) R_GetCCallable ( "cstringr" , "CSR_strmlen" ) ; VALC_bullet = ( const char * ( * ) ( const char * , const char * , const char * , size_t ) ) R_GetCCallable ( "cstringr" , "CSR_bullet" ) ; <S2SV_StartBug> CSR_collapse = ( const char * ( * ) ( SEXP , const char * , size_t ) ) R_GetCCallable ( "cstringr" , "CSR_collapse" ) ; <S2SV_EndBug> } | <S2SV_ModStart> CSR_collapse = ( <S2SV_ModEnd> char * ( |
1,338 | CWE-000 static int faultin_page ( struct task_struct * tsk , struct vm_area_struct * vma , unsigned long address , unsigned int * flags , int * nonblocking ) { struct mm_struct * mm = vma -> vm_mm ; unsigned int fault_flags = 0 ; int ret ; if ( * flags & FOLL_WRITE ) fault_flags |= FAULT_FLAG_WRITE ; if ( nonblocking ) fault_flags |= FAULT_FLAG_ALLOW_RETRY ; if ( * flags & FOLL_NOWAIT ) fault_flags |= FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_RETRY_NOWAIT ; if ( * flags & FOLL_TRIED ) { VM_WARN_ON_ONCE ( fault_flags & FAULT_FLAG_ALLOW_RETRY ) ; fault_flags |= FAULT_FLAG_TRIED ; } ret = handle_mm_fault ( mm , vma , address , fault_flags ) ; if ( ret & VM_FAULT_ERROR ) { if ( ret & VM_FAULT_OOM ) return - ENOMEM ; if ( ret & ( VM_FAULT_HWPOISON | VM_FAULT_HWPOISON_LARGE ) ) return * flags & FOLL_HWPOISON ? - EHWPOISON : - EFAULT ; if ( ret & ( VM_FAULT_SIGBUS | VM_FAULT_SIGSEGV ) ) return - EFAULT ; BUG ( ) ; } if ( tsk ) { if ( ret & VM_FAULT_MAJOR ) tsk -> maj_flt ++ ; else tsk -> min_flt ++ ; } if ( ret & VM_FAULT_RETRY ) { if ( nonblocking ) * nonblocking = 0 ; return - EBUSY ; } if ( ( ret & VM_FAULT_WRITE ) && ! ( vma -> vm_flags & VM_WRITE ) ) <S2SV_StartBug> * flags &= ~ FOLL_WRITE ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> ) * flags |= FOLL_COW <S2SV_ModEnd> ; return 0 |
1,339 | CWE-000 extern void moveSnek ( snek * snek ) { <S2SV_StartBug> pthread_mutex_lock ( & snek -> moveLock ) ; <S2SV_EndBug> segm * segHead = snek -> seg ; while ( segHead -> next != NULL ) { if ( segHead -> d == 1 && ( segHead -> y + 1 ) == 50 ) segHead -> y = - 1 ; if ( segHead -> d == 3 && ( segHead -> y ) == 0 ) segHead -> y = 50 ; if ( segHead -> d == 2 && ( segHead -> x ) == 30 ) segHead -> x = - 1 ; if ( segHead -> d == 0 && ( segHead -> x ) == 0 ) segHead -> x = 30 ; switch ( segHead -> d ) { case 0 : segHead -> x -- ; break ; case 1 : segHead -> y ++ ; break ; case 2 : segHead -> x ++ ; break ; case 3 : segHead -> y -- ; break ; default : break ; } segHead = segHead -> next ; } switch ( segHead -> d ) { case 0 : segHead -> x -- ; break ; case 1 : segHead -> y ++ ; break ; case 2 : segHead -> x ++ ; break ; case 3 : segHead -> y -- ; break ; default : break ; } alignNextSegment ( snek ) ; <S2SV_StartBug> pthread_mutex_unlock ( & snek -> moveLock ) ; <S2SV_EndBug> } | <S2SV_ModStart> snek ) { <S2SV_ModEnd> segm * segHead <S2SV_ModStart> snek ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
1,340 | CWE-000 int ifconfig_media_get_mediareq ( ifconfig_handle_t * h , const char * name , struct ifmediareq * * ifmr ) { struct _ifconfig_media_status * ms , * ms2 ; unsigned long cmd = SIOCGIFXMEDIA ; <S2SV_StartBug> int s ; <S2SV_EndBug> * ifmr = NULL ; <S2SV_StartBug> if ( ifconfig_socket ( h , AF_LOCAL , & s ) != 0 ) { <S2SV_EndBug> return ( - 1 ) ; } ms = calloc ( 1 , sizeof ( * ms ) ) ; if ( ms == NULL ) { h -> error . errtype = OTHER ; h -> error . errcode = ENOMEM ; return ( - 1 ) ; } ( void ) memset ( ms , 0 , sizeof ( * ms ) ) ; ( void ) strlcpy ( ms -> ifmr . ifm_name , name , sizeof ( ms -> ifmr . ifm_name ) ) ; <S2SV_StartBug> if ( ioctl ( s , cmd , & ms -> ifmr ) < 0 ) { <S2SV_EndBug> cmd = SIOCGIFMEDIA ; <S2SV_StartBug> if ( ioctl ( s , cmd , & ms -> ifmr ) < 0 ) { <S2SV_EndBug> h -> error . errtype = OK ; free ( ms ) ; return ( - 1 ) ; } } if ( ms -> ifmr . ifm_count == 0 ) { * ifmr = & ms -> ifmr ; return ( 0 ) ; } ms2 = realloc ( ms , sizeof ( * ms ) + sizeof ( int ) * ms -> ifmr . ifm_count ) ; if ( ms2 == NULL ) { h -> error . errtype = OTHER ; h -> error . errcode = ENOMEM ; free ( ms ) ; return ( - 1 ) ; } ms2 -> ifmr . ifm_ulist = & ms2 -> medialist [ 0 ] ; <S2SV_StartBug> if ( ioctl ( s , cmd , & ms2 -> ifmr ) < 0 ) { <S2SV_EndBug> <S2SV_StartBug> h -> error . errtype = IOCTL ; <S2SV_EndBug> h -> error . ioctl_request = cmd ; h -> error . errcode = errno ; free ( ms2 ) ; return ( - 1 ) ; } * ifmr = & ms2 -> ifmr ; return ( 0 ) ; } | <S2SV_ModStart> = SIOCGIFXMEDIA ; <S2SV_ModEnd> * ifmr = <S2SV_ModStart> = NULL ; <S2SV_ModEnd> ms = calloc <S2SV_ModStart> ; if ( ifconfig_ioctlwrap ( h , AF_LOCAL <S2SV_ModEnd> , cmd , <S2SV_ModStart> ; if ( ifconfig_ioctlwrap ( h , AF_LOCAL <S2SV_ModEnd> , cmd , <S2SV_ModStart> ; if ( ifconfig_ioctlwrap ( h , AF_LOCAL <S2SV_ModEnd> , cmd , <S2SV_ModStart> 0 ) { <S2SV_ModEnd> free ( ms2 |
1,341 | CWE-000 static int hw_card_start ( struct hw * hw ) { int err ; struct pci_dev * pci = hw -> pci ; <S2SV_StartBug> err = pci_enable_device ( pci ) ; <S2SV_EndBug> if ( err < 0 ) return err ; <S2SV_StartBug> if ( pci_set_dma_mask ( pci , CT_XFI_DMA_MASK ) < 0 || <S2SV_EndBug> pci_set_consistent_dma_mask ( pci , CT_XFI_DMA_MASK ) < 0 ) { printk ( KERN_ERR "architecture<S2SV_blank>does<S2SV_blank>not<S2SV_blank>support<S2SV_blank>PCI<S2SV_blank>" "busmaster<S2SV_blank>DMA<S2SV_blank>with<S2SV_blank>mask<S2SV_blank>0x%llx\\n" , CT_XFI_DMA_MASK ) ; err = - ENXIO ; goto error1 ; } if ( ! hw -> io_base ) { err = pci_request_regions ( pci , "XFi" ) ; if ( err < 0 ) goto error1 ; if ( hw -> model == CTUAA ) hw -> io_base = pci_resource_start ( pci , 5 ) ; else hw -> io_base = pci_resource_start ( pci , 0 ) ; } if ( hw -> model == CTUAA ) { err = uaa_to_xfi ( pci ) ; if ( err ) goto error2 ; } if ( hw -> irq < 0 ) { err = request_irq ( pci -> irq , ct_20k1_interrupt , IRQF_SHARED , "ctxfi" , hw ) ; if ( err < 0 ) { printk ( KERN_ERR "XFi:<S2SV_blank>Cannot<S2SV_blank>get<S2SV_blank>irq<S2SV_blank>%d\\n" , pci -> irq ) ; goto error2 ; } hw -> irq = pci -> irq ; } pci_set_master ( pci ) ; return 0 ; error2 : pci_release_regions ( pci ) ; hw -> io_base = 0 ; error1 : pci_disable_device ( pci ) ; return err ; } | <S2SV_ModStart> -> pci ; const unsigned int dma_bits = BITS_PER_LONG ; <S2SV_ModStart> ; if ( dma_set_mask ( & pci -> dev , DMA_BIT_MASK ( dma_bits ) ) ) { dma_set_coherent_mask ( & pci -> dev , DMA_BIT_MASK ( dma_bits ) ) ; } else { dma_set_mask ( & pci -> dev , DMA_BIT_MASK ( 32 ) ) ; dma_set_coherent_mask ( & pci -> dev , DMA_BIT_MASK ( 32 ) ) <S2SV_ModEnd> ; } if |
1,342 | CWE-000 static void view_details_init ( GTypeInstance * object , gpointer gclass ) { GtkTreeView * treeview = ( GtkTreeView * ) object ; GtkTreeViewColumn * column ; GtkCellRenderer * cell ; ViewDetails * view_details = ( ViewDetails * ) object ; view_details -> items = g_ptr_array_new ( ) ; view_details -> cursor_base = - 1 ; view_details -> wink_item = - 1 ; view_details -> desired_size . width = - 1 ; view_details -> desired_size . height = - 1 ; view_details -> can_change_selection = 0 ; view_details -> lasso_box = FALSE ; view_details -> selection = gtk_tree_view_get_selection ( treeview ) ; gtk_tree_selection_set_mode ( view_details -> selection , GTK_SELECTION_MULTIPLE ) ; gtk_tree_selection_set_select_function ( view_details -> selection , <S2SV_StartBug> test_can_change_selection , view_details , NULL ) ; <S2SV_EndBug> setcolour ( view_details ) ; view_details -> sort_fn = NULL ; gtk_tree_view_set_model ( treeview , GTK_TREE_MODEL ( view_details ) ) ; g_signal_connect ( view_details -> selection , "changed" , G_CALLBACK ( selection_changed ) , view_details ) ; cell = cell_icon_new ( view_details ) ; column = gtk_tree_view_column_new_with_attributes ( NULL , cell , "item" , COL_VIEW_ITEM , NULL ) ; gtk_tree_view_append_column ( treeview , column ) ; ADD_TEXT_COLUMN ( _ ( "_Name" ) , COL_LEAF ) ; gtk_tree_view_column_set_sort_column_id ( column , COL_LEAF ) ; gtk_tree_view_column_set_resizable ( column , TRUE ) ; gtk_tree_view_column_set_reorderable ( column , TRUE ) ; gtk_tree_view_column_set_max_width ( column , ( o_filer_width_limit . int_value == 0 ? o_filer_size_limit . int_value : o_filer_width_limit . int_value ) * monitor_width / 109 ) ; ADD_TEXT_COLUMN ( _ ( "_Type" ) , COL_TYPE ) ; gtk_tree_view_column_set_sort_column_id ( column , COL_TYPE ) ; gtk_tree_view_column_set_resizable ( column , TRUE ) ; gtk_tree_view_column_set_reorderable ( column , TRUE ) ; ADD_TEXT_COLUMN ( _ ( "_Size" ) , COL_SIZE ) ; g_object_set ( G_OBJECT ( cell ) , "xalign" , 1.0 , "font" , "monospace" , NULL ) ; g_signal_connect_after ( object , "realize" , G_CALLBACK ( set_column_mono_font ) , G_OBJECT ( cell ) ) ; gtk_tree_view_column_set_sort_column_id ( column , COL_SIZE ) ; gtk_tree_view_column_set_reorderable ( column , TRUE ) ; ADD_TEXT_COLUMN ( _ ( "_Permissions" ) , COL_PERM ) ; gtk_tree_view_column_set_reorderable ( column , TRUE ) ; g_object_set ( G_OBJECT ( cell ) , "font" , "monospace" , NULL ) ; g_signal_connect_after ( object , "realize" , G_CALLBACK ( set_column_mono_font ) , G_OBJECT ( cell ) ) ; ADD_TEXT_COLUMN ( _ ( "_Owner" ) , COL_OWNER ) ; gtk_tree_view_column_set_sort_column_id ( column , COL_OWNER ) ; gtk_tree_view_column_set_reorderable ( column , TRUE ) ; ADD_TEXT_COLUMN ( _ ( "_Group" ) , COL_GROUP ) ; gtk_tree_view_column_set_sort_column_id ( column , COL_GROUP ) ; gtk_tree_view_column_set_reorderable ( column , TRUE ) ; ADD_TEXT_COLUMN ( _ ( "Last<S2SV_blank>_Modified" ) , COL_MTIME ) ; g_object_set ( G_OBJECT ( cell ) , "font" , "monospace" , NULL ) ; g_signal_connect_after ( object , "realize" , G_CALLBACK ( set_column_mono_font ) , G_OBJECT ( cell ) ) ; gtk_tree_view_column_set_sort_column_id ( column , COL_MTIME ) ; gtk_tree_view_column_set_reorderable ( column , TRUE ) ; ADD_TEXT_COLUMN ( _ ( "Last<S2SV_blank>_Changed" ) , COL_CTIME ) ; g_object_set ( G_OBJECT ( cell ) , "font" , "monospace" , NULL ) ; g_signal_connect_after ( object , "realize" , G_CALLBACK ( set_column_mono_font ) , G_OBJECT ( cell ) ) ; gtk_tree_view_column_set_sort_column_id ( column , COL_CTIME ) ; gtk_tree_view_column_set_reorderable ( column , TRUE ) ; } | <S2SV_ModStart> view_details , NULL <S2SV_ModEnd> ) ; view_details |
1,343 | CWE-000 Res TraceStart ( Trace trace , double mortality , double finishingTime ) { Arena arena ; Res res ; AVERT ( Trace , trace ) ; AVER ( trace -> state == TraceINIT ) ; AVER ( 0.0 <= mortality ) ; AVER ( mortality <= 1.0 ) ; AVER ( finishingTime >= 0.0 ) ; AVER ( trace -> condemned > 0 ) ; arena = trace -> arena ; <S2SV_StartBug> SegTraverse ( arena , traceStartVisit , trace ) ; <S2SV_EndBug> res = RootsIterate ( ArenaGlobals ( arena ) , rootGrey , ( void * ) trace ) ; AVER ( res == ResOK ) ; STATISTIC_STAT ( EVENT2 ( ArenaWriteFaults , arena , arena -> writeBarrierHitCount ) ) ; { Size sSurvivors = ( Size ) ( trace -> condemned * ( 1.0 - mortality ) ) ; double nPolls = finishingTime / ArenaPollALLOCTIME ; if ( nPolls < 1.0 ) nPolls = 1.0 ; if ( nPolls >= ( double ) LONG_MAX ) nPolls = ( double ) LONG_MAX ; trace -> quantumWork = ( trace -> foundation + sSurvivors ) / ( unsigned long ) nPolls + 1 ; } EVENT8 ( TraceStart , trace , mortality , finishingTime , trace -> condemned , trace -> notCondemned , trace -> foundation , trace -> white , trace -> quantumWork ) ; STATISTIC_STAT ( EVENT7 ( TraceStatCondemn , trace , trace -> condemned , trace -> notCondemned , trace -> foundation , trace -> quantumWork , mortality , finishingTime ) ) ; trace -> state = TraceUNFLIPPED ; TracePostStartMessage ( trace ) ; return traceFlip ( trace ) ; } | <S2SV_ModStart> -> arena ; # ifdef TRACE_DEBUG if ( trace -> whiteTable ) TableMap ( trace -> whiteTable , checkWhite , trace ) ; # endif |
1,344 | CWE-000 static bool heap_get_region ( struct mpvk_ctx * vk , struct vk_heap * heap , size_t size , size_t align , struct vk_slab * * out_slab , int * out_index ) { <S2SV_StartBug> if ( ! heap ) <S2SV_EndBug> return false ; struct vk_slab * slab = NULL ; if ( size > MPVK_HEAP_MAXIMUM_SLAB_SIZE ) { slab = slab_alloc ( vk , heap , size ) ; * out_slab = slab ; * out_index = 0 ; return ! ! slab ; } for ( int i = 0 ; i < heap -> num_slabs ; i ++ ) { slab = heap -> slabs [ i ] ; if ( slab -> size < size ) continue ; int best = - 1 ; for ( int n = 0 ; n < slab -> num_regions ; n ++ ) { struct vk_region r = slab -> regions [ n ] ; if ( ! region_fits ( r , size , align ) ) continue ; if ( best >= 0 && region_len ( r ) > region_len ( slab -> regions [ best ] ) ) continue ; best = n ; } if ( best >= 0 ) { * out_slab = slab ; * out_index = best ; return true ; } } size_t cur_size = MPMAX ( size , slab ? slab -> size : 0 ) ; size_t slab_size = MPVK_HEAP_SLAB_GROWTH_RATE * cur_size ; slab_size = MPMAX ( MPVK_HEAP_MINIMUM_SLAB_SIZE , slab_size ) ; slab_size = MPMIN ( MPVK_HEAP_MAXIMUM_SLAB_SIZE , slab_size ) ; assert ( slab_size >= size ) ; slab = slab_alloc ( vk , heap , slab_size ) ; if ( ! slab ) return false ; MP_TARRAY_APPEND ( NULL , heap -> slabs , heap -> num_slabs , slab ) ; assert ( slab -> num_regions == 1 ) ; * out_slab = slab ; * out_index = 0 ; return true ; } | <S2SV_ModStart> out_index ) { <S2SV_ModEnd> struct vk_slab * |
1,345 | CWE-000 void flexsea_send_serial_master ( PacketWrapper * p ) { Port port = p -> port ; uint8_t * str = p -> packed ; <S2SV_StartBug> uint8_t length = COMM_STR_BUF_LEN ; <S2SV_EndBug> int i = 0 ; if ( port == PORT_SPI ) { for ( i = 0 ; i < length ; i ++ ) { comm_str_spi [ i ] = str [ i ] ; } } else if ( port == PORT_USB ) { CDC_Transmit_FS ( str , length ) ; } else if ( port == PORT_WIRELESS ) { puts_expUart ( str , length ) ; } fm_pool_free_block ( p ) ; } | <S2SV_ModStart> -> packed ; uint16_t <S2SV_ModEnd> length = COMM_STR_BUF_LEN |
1,346 | CWE-000 int hit_io_err_recheck_time ( struct path * pp ) { struct timespec curr_time ; int r ; <S2SV_StartBug> if ( pp -> io_err_disable_reinstate == 0 ) <S2SV_EndBug> return 1 ; if ( clock_gettime ( CLOCK_MONOTONIC , & curr_time ) != 0 ) return 1 ; if ( pp -> io_err_pathfail_cnt != PATH_IO_ERR_IN_POLLING_RECHECK ) return 1 ; <S2SV_StartBug> if ( pp -> mpp -> nr_active <= 0 ) { <S2SV_EndBug> io_err_stat_log ( 2 , "%s:<S2SV_blank>recover<S2SV_blank>path<S2SV_blank>early" , pp -> dev ) ; goto recover ; } if ( ( curr_time . tv_sec - pp -> io_err_dis_reinstate_time ) > pp -> mpp -> marginal_path_err_recheck_gap_time ) { io_err_stat_log ( 4 , "%s:<S2SV_blank>reschedule<S2SV_blank>checking<S2SV_blank>after<S2SV_blank>%d<S2SV_blank>seconds" , pp -> dev , pp -> mpp -> marginal_path_err_recheck_gap_time ) ; pp -> io_err_dis_reinstate_time = curr_time . tv_sec ; r = enqueue_io_err_stat_by_path ( pp ) ; if ( r == 1 ) { io_err_stat_log ( 3 , "%s:<S2SV_blank>enqueue<S2SV_blank>fails,<S2SV_blank>to<S2SV_blank>recover" , pp -> dev ) ; goto recover ; } else if ( ! r ) { pp -> io_err_pathfail_cnt = PATH_IO_ERR_IN_CHECKING ; } } return 1 ; recover : pp -> io_err_pathfail_cnt = 0 ; pp -> io_err_disable_reinstate = 0 ; pp -> tick = 1 ; return 0 ; } | <S2SV_ModStart> ( pp -> mpp -> nr_active <= 0 ) { io_err_stat_log ( 2 , "%s:<S2SV_blank>recover<S2SV_blank>path<S2SV_blank>early" , pp -> dev ) ; goto recover ; } <S2SV_ModEnd> if ( pp <S2SV_ModStart> ; if ( clock_gettime ( CLOCK_MONOTONIC , & curr_time ) != 0 || <S2SV_ModEnd> ( curr_time . |
1,347 | CWE-000 int cm_AlignSizeNeededHB ( CM_t * cm , char * errbuf , int L , float size_limit , int do_sample , int do_post , float * ret_mxmb , float * ret_emxmb , float * ret_shmxmb , float * ret_totmb ) { int status ; float totmb = 0. ; float mxmb = 0. ; float emxmb = 0. ; float shmxmb = 0. ; if ( ( status = cm_hb_mx_SizeNeeded ( cm , errbuf , cm -> cp9b , L , NULL , & mxmb ) ) != eslOK ) return status ; totmb = mxmb ; if ( do_post ) { totmb += mxmb ; if ( ( status = cm_hb_emit_mx_SizeNeeded ( cm , errbuf , cm -> cp9b , L , NULL , NULL , & emxmb ) ) != eslOK ) return status ; totmb += emxmb ; } if ( ! do_sample ) { if ( ( status = cm_hb_shadow_mx_SizeNeeded ( cm , errbuf , cm -> cp9b , NULL , NULL , & shmxmb ) ) != eslOK ) return status ; totmb += shmxmb ; } if ( ret_mxmb != NULL ) * ret_mxmb = mxmb ; if ( ret_emxmb != NULL ) * ret_emxmb = emxmb ; if ( ret_shmxmb != NULL ) * ret_shmxmb = shmxmb ; if ( ret_totmb != NULL ) * ret_totmb = totmb ; # if eslDEBUGLEVEL >= 1 <S2SV_StartBug> printf ( "cm_AlignSizeNeededHB()\\n" ) ; <S2SV_EndBug> printf ( "\\t<S2SV_blank>mxmb:<S2SV_blank><S2SV_blank>%.2f\\n" , mxmb ) ; printf ( "\\t<S2SV_blank>emxmb:<S2SV_blank>%.2f\\n" , emxmb ) ; printf ( "\\t<S2SV_blank>shmxmb:%.2f\\n" , shmxmb ) ; printf ( "\\t<S2SV_blank>totmb:<S2SV_blank>%.2f\\n" , totmb ) ; printf ( "\\t<S2SV_blank>limit:<S2SV_blank>%.2f\\n" , size_limit ) ; # endif if ( totmb > size_limit ) ESL_FAIL ( eslERANGE , errbuf , "HMM<S2SV_blank>banded<S2SV_blank>standard<S2SV_blank>alignment<S2SV_blank>mxes<S2SV_blank>need<S2SV_blank>%.2f<S2SV_blank>Mb<S2SV_blank>><S2SV_blank>%.2f<S2SV_blank>Mb<S2SV_blank>limit.\\nUse<S2SV_blank>--mxsize,<S2SV_blank>--maxtau<S2SV_blank>or<S2SV_blank>--tau." , totmb , ( float ) size_limit ) ; return eslOK ; } | <S2SV_ModStart> 1 printf ( "#DEBUG:<S2SV_blank>cm_AlignSizeNeededHB()\\n" ) ; printf ( "#DEBUG:<S2SV_blank>\\t<S2SV_blank>mxmb:<S2SV_blank><S2SV_blank>%.2f\\n" , mxmb ) ; printf ( "#DEBUG:<S2SV_blank>\\t<S2SV_blank>emxmb:<S2SV_blank>%.2f\\n" , emxmb ) ; printf ( "#DEBUG:<S2SV_blank>\\t<S2SV_blank>shmxmb:%.2f\\n" , shmxmb ) ; printf ( "#DEBUG:<S2SV_blank>\\t<S2SV_blank>totmb:<S2SV_blank>%.2f\\n" , totmb ) ; printf ( "#DEBUG:<S2SV_blank>\\t<S2SV_blank>limit:<S2SV_blank>%.2f\\n" <S2SV_ModEnd> , size_limit ) |
1,348 | CWE-000 int main ( void ) { node_t * root = NULL ; <S2SV_StartBug> insert ( & root , 2 ) ; <S2SV_EndBug> insert ( & root , 13 ) ; insert ( & root , 100 ) ; insert ( & root , 3 ) ; insert ( & root , 5 ) ; insert ( & root , 8 ) ; insert ( & root , 0 ) ; insert ( & root , 4 ) ; insert ( & root , 20 ) ; show ( root ) ; delete ( & root , 20 ) ; show ( root ) ; delete ( & root , 20 ) ; show ( root ) ; delete ( & root , 0 ) ; show ( root ) ; delete ( & root , 100 ) ; show ( root ) ; delete_all ( & root ) ; show ( root ) ; return 0 ; } | <S2SV_ModStart> = NULL ; show ( root ) ; delete ( & root , 1 ) ; show ( root ) ; delete_all ( & root ) ; show ( root ) ; |
1,349 | CWE-000 noreturn void usage ( int status ) { FILE * out = status ? stderr : stdout ; fprintf ( out , "%s<S2SV_blank>v%s\\nUsage:<S2SV_blank>%s<S2SV_blank>[OPTION]...<S2SV_blank>{FILE}\\n" , PROGRAM_NAME , VERSION , PROGRAM_NAME ) ; <S2SV_StartBug> fputs ( "\\\n<S2SV_blank>Convert<S2SV_blank>all<S2SV_blank>images<S2SV_blank>with<S2SV_blank>base64<S2SV_blank>encoding.\\n\\\n<S2SV_blank>Changes<S2SV_blank><img><S2SV_blank>tags<S2SV_blank>of<S2SV_blank>HTML<S2SV_blank>file<S2SV_blank>\'FILE\'<S2SV_blank>with<S2SV_blank>their<S2SV_blank>base64<S2SV_blank>strings<S2SV_blank>and<S2SV_blank>print<S2SV_blank>result\\n\\\n<S2SV_blank>to<S2SV_blank>standard<S2SV_blank>output.\\n\\n\\\n<S2SV_blank>OPTIONS\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-i,<S2SV_blank>--in-place<S2SV_blank>[SUFFIX]\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>edit<S2SV_blank>files<S2SV_blank>in<S2SV_blank>place<S2SV_blank>(makes<S2SV_blank>backup<S2SV_blank>if<S2SV_blank>SUFFIX<S2SV_blank>supplied)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-n,<S2SV_blank>--quiet<S2SV_blank>suppress<S2SV_blank>automatic<S2SV_blank>printing<S2SV_blank>to<S2SV_blank>standard<S2SV_blank>output\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-h,<S2SV_blank>--help<S2SV_blank>display<S2SV_blank>this<S2SV_blank>help<S2SV_blank>and<S2SV_blank>exit\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--version<S2SV_blank>output<S2SV_blank>version<S2SV_blank>information<S2SV_blank>and<S2SV_blank>exit\\n\\\n<S2SV_blank>EXAMPLES\\n" , out ) ; <S2SV_EndBug> fprintf ( out , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%s<S2SV_blank>page.html<S2SV_blank>-i.old<S2SV_blank>--quiet\\n" , PROGRAM_NAME ) ; fputs ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>makes<S2SV_blank>backup<S2SV_blank>to<S2SV_blank>\'page.html.old\'<S2SV_blank>and<S2SV_blank>silently<S2SV_blank>parse<S2SV_blank>\'page.html\'.\\n" , out ) ; <S2SV_StartBug> fputs ( "\\\n<S2SV_blank>CONTACT\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Written<S2SV_blank>by<S2SV_blank>Sylvain<S2SV_blank>Saubier<S2SV_blank>(<http:<S2SV_blank>//<S2SV> if ( status ) <S2SV_EndBug> <S2SV_StartBug> fputs ( "\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Report<S2SV_blank>bugs<S2SV_blank>to:<S2SV_blank><feedback@systemicresponse.com>\\n" , out ) ; <S2SV_EndBug> exit ( status ) ; } void opt_print ( const int argc , char * argv [ ] ) { puts ( "---" ) ; printf ( "optind==%d;<S2SV_blank>argc==%d\\n" , optind , argc ) ; printf ( "argv==\\"" ) ; int i = 0 ; while ( i < argc ) { printf ( "%s\\t" , argv [ i ] ) ; i ++ ; } printf ( "\\"\\n" ) ; printf ( "QUIET<S2SV_blank>is<S2SV_blank>%sSET\\n" , quiet ? "" : "UN" ) ; printf ( "SUFFIX<S2SV_blank>is<S2SV_blank>%s\\n" , in_place_suffix ) ; printf ( "FILE<S2SV_blank>COUNT<S2SV_blank>is<S2SV_blank>%d\\n" , argc - optind ) ; puts ( "---" ) ; fflush ( stdout ) ; } | <S2SV_ModStart> ; fputs ( "\\\nConvert<S2SV_blank>all<S2SV_blank>images<S2SV_blank>with<S2SV_blank>base64<S2SV_blank>encoding.\\n\\\nChanges<S2SV_blank><img><S2SV_blank>tags<S2SV_blank>of<S2SV_blank>HTML<S2SV_blank>file<S2SV_blank>\'FILE\'<S2SV_blank>with<S2SV_blank>their<S2SV_blank>base64<S2SV_blank>strings<S2SV_blank>and<S2SV_blank>print<S2SV_blank>result\\n\\\nto<S2SV_blank>standard<S2SV_blank>output.\\n\\n\\\nOPTIONS\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-i,<S2SV_blank>--in-place<S2SV_blank>[SUFFIX]\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>edit<S2SV_blank>files<S2SV_blank>in<S2SV_blank>place<S2SV_blank>(makes<S2SV_blank>backup<S2SV_blank>if<S2SV_blank>SUFFIX<S2SV_blank>supplied)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-n,<S2SV_blank>--quiet<S2SV_blank>suppress<S2SV_blank>automatic<S2SV_blank>printing<S2SV_blank>to<S2SV_blank>standard<S2SV_blank>output\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-h,<S2SV_blank>--help<S2SV_blank>display<S2SV_blank>this<S2SV_blank>help<S2SV_blank>and<S2SV_blank>exit\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--version<S2SV_blank>output<S2SV_blank>version<S2SV_blank>information<S2SV_blank>and<S2SV_blank>exit\\n\\\nEXAMPLES\\n" <S2SV_ModEnd> , out ) <S2SV_ModStart> ; fputs ( "\\\nCONTACT\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Written<S2SV_blank>by<S2SV_blank>Sylvain<S2SV_blank>Saubier<S2SV_blank>(<http:<S2SV_blank>//<S2SV> <S2SV_ModEnd> if ( status <S2SV_ModStart> ) fputs ( "\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Report<S2SV_blank>bugs<S2SV_blank>to:<S2SV_blank><feedback@sylsau.com>\\n" <S2SV_ModEnd> , out ) |
1,350 | CWE-000 START_TEST ( test_parse_cpuset_3 ) { char str [ STR_LEN ] ; cpu_set_t cpuset ; CPU_ZERO ( & cpuset ) ; CPU_SET ( 0 , & cpuset ) ; CPU_SET ( 1 , & cpuset ) ; CPU_SET ( 2 , & cpuset ) ; CPU_SET ( 4 , & cpuset ) ; CPU_SET ( 5 , & cpuset ) ; CPU_SET ( 9 , & cpuset ) ; CPU_SET ( 11 , & cpuset ) ; <S2SV_StartBug> parse_cpuset ( & cpuset , str , sizeof ( str ) ) ; <S2SV_EndBug> ck_assert_str_eq ( "0-2,4-5,9,11" , str ) ; } | <S2SV_ModStart> cpuset ) ; cpuset_tostr <S2SV_ModEnd> ( & cpuset |
1,351 | CWE-000 static inline enum comp_state check_ack ( struct rxe_qp * qp , struct rxe_pkt_info * pkt , struct rxe_send_wqe * wqe ) { unsigned int mask = pkt -> mask ; u8 syn ; switch ( qp -> comp . opcode ) { case - 1 : if ( ! ( mask & RXE_START_MASK ) ) return COMPST_ERROR ; break ; case IB_OPCODE_RC_RDMA_READ_RESPONSE_FIRST : case IB_OPCODE_RC_RDMA_READ_RESPONSE_MIDDLE : if ( pkt -> opcode != IB_OPCODE_RC_RDMA_READ_RESPONSE_MIDDLE && pkt -> opcode != IB_OPCODE_RC_RDMA_READ_RESPONSE_LAST ) { return COMPST_ERROR ; } break ; default : WARN_ON ( 1 ) ; } switch ( pkt -> opcode ) { case IB_OPCODE_RC_RDMA_READ_RESPONSE_FIRST : case IB_OPCODE_RC_RDMA_READ_RESPONSE_LAST : case IB_OPCODE_RC_RDMA_READ_RESPONSE_ONLY : syn = aeth_syn ( pkt ) ; if ( ( syn & AETH_TYPE_MASK ) != AETH_ACK ) return COMPST_ERROR ; case IB_OPCODE_RC_RDMA_READ_RESPONSE_MIDDLE : if ( wqe -> wr . opcode != IB_WR_RDMA_READ && wqe -> wr . opcode != IB_WR_RDMA_READ_WITH_INV ) { <S2SV_StartBug> return COMPST_ERROR ; <S2SV_EndBug> } reset_retry_counters ( qp ) ; return COMPST_READ ; case IB_OPCODE_RC_ATOMIC_ACKNOWLEDGE : syn = aeth_syn ( pkt ) ; if ( ( syn & AETH_TYPE_MASK ) != AETH_ACK ) return COMPST_ERROR ; if ( wqe -> wr . opcode != IB_WR_ATOMIC_CMP_AND_SWP && wqe -> wr . opcode != IB_WR_ATOMIC_FETCH_AND_ADD ) return COMPST_ERROR ; reset_retry_counters ( qp ) ; return COMPST_ATOMIC ; case IB_OPCODE_RC_ACKNOWLEDGE : syn = aeth_syn ( pkt ) ; switch ( syn & AETH_TYPE_MASK ) { case AETH_ACK : reset_retry_counters ( qp ) ; return COMPST_WRITE_SEND ; case AETH_RNR_NAK : return COMPST_RNR_RETRY ; case AETH_NAK : switch ( syn ) { case AETH_NAK_PSN_SEQ_ERROR : if ( psn_compare ( pkt -> psn , qp -> comp . psn ) > 0 ) { qp -> comp . psn = pkt -> psn ; if ( qp -> req . wait_psn ) { qp -> req . wait_psn = 0 ; rxe_run_task ( & qp -> req . task , 1 ) ; } } return COMPST_ERROR_RETRY ; case AETH_NAK_INVALID_REQ : wqe -> status = IB_WC_REM_INV_REQ_ERR ; return COMPST_ERROR ; case AETH_NAK_REM_ACC_ERR : wqe -> status = IB_WC_REM_ACCESS_ERR ; return COMPST_ERROR ; case AETH_NAK_REM_OP_ERR : wqe -> status = IB_WC_REM_OP_ERR ; return COMPST_ERROR ; default : pr_warn ( "unexpected<S2SV_blank>nak<S2SV_blank>%x\\n" , syn ) ; wqe -> status = IB_WC_REM_OP_ERR ; return COMPST_ERROR ; } default : return COMPST_ERROR ; } break ; default : pr_warn ( "unexpected<S2SV_blank>opcode\\n" ) ; } return COMPST_ERROR ; } | <S2SV_ModStart> IB_WR_RDMA_READ_WITH_INV ) { wqe -> status = IB_WC_FATAL_ERR ; |
1,352 | CWE-000 void * threadConnectionHandler ( void * data ) { struct connection * clientConnection ; rc = pthread_mutex_lock ( & connectionMutex ) ; <S2SV_StartBug> int threadId = * ( int * ) data ; <S2SV_EndBug> while ( 1 ) { if ( numConnections > 0 ) { clientConnection = getConnection ( & connectionMutex ) ; if ( clientConnection ) { <S2SV_StartBug> numActiveConnections ++ ; <S2SV_EndBug> threads [ threadId ] . socketId = clientConnection -> socketId ; rc = pthread_mutex_unlock ( & connectionMutex ) ; handleConnection ( clientConnection -> socketId ) ; close ( clientConnection -> socketId ) ; free ( clientConnection ) ; rc = pthread_mutex_lock ( & connectionMutex ) ; threads [ threadId ] . socketId = NO_ACTIVE_CONNECTION ; <S2SV_StartBug> numActiveConnections -- ; <S2SV_EndBug> } } else { rc = pthread_cond_wait ( & gotConnection , & connectionMutex ) ; } } } | <S2SV_ModStart> = * ( ( <S2SV_ModStart> * ) data ) <S2SV_ModStart> clientConnection ) { pthread_mutex_lock ( & activeConnectionMutex ) ; numActiveConnections ++ ; pthread_mutex_unlock ( & activeConnectionMutex ) <S2SV_ModEnd> ; threads [ <S2SV_ModStart> = NO_ACTIVE_CONNECTION ; pthread_mutex_lock ( & activeConnectionMutex ) ; numActiveConnections -- ; pthread_mutex_unlock ( & activeConnectionMutex ) <S2SV_ModEnd> ; } } |
1,353 | CWE-000 gboolean ostree_repo_write_metadata ( OstreeRepo * self , OstreeObjectType objtype , const char * expected_checksum , GVariant * object , guchar * * out_csum , GCancellable * cancellable , GError * * error ) { g_autoptr ( GVariant ) normalized = NULL ; if ( expected_checksum ) { gboolean have_obj ; if ( ! _ostree_repo_has_loose_object ( self , expected_checksum , objtype , & have_obj , cancellable , error ) ) return FALSE ; <S2SV_StartBug> if ( have_obj ) <S2SV_EndBug> { if ( out_csum ) * out_csum = ostree_checksum_to_bytes ( expected_checksum ) ; return TRUE ; } normalized = g_variant_ref ( object ) ; } else { normalized = g_variant_get_normal_form ( object ) ; } if ( ! metadata_size_valid ( objtype , g_variant_get_size ( normalized ) , error ) ) return FALSE ; if ( expected_checksum ) { if ( ! _ostree_validate_structureof_metadata ( objtype , object , error ) ) return FALSE ; } g_autoptr ( GBytes ) vdata = g_variant_get_data_as_bytes ( normalized ) ; if ( ! write_metadata_object ( self , objtype , expected_checksum , vdata , out_csum , cancellable , error ) ) return FALSE ; return TRUE ; } | <S2SV_ModStart> if ( have_obj && ! ( ostree_repo_get_mode ( self ) == OSTREE_REPO_MODE_ARCHIVE_Z2 && self -> generate_sizes ) |
1,354 | CWE-000 <S2SV_StartBug> static void xgene_gpio_sb_domain_activate ( struct irq_domain * d , <S2SV_EndBug> <S2SV_StartBug> struct irq_data * irq_data ) <S2SV_EndBug> { struct xgene_gpio_sb * priv = d -> host_data ; u32 gpio = HWIRQ_TO_GPIO ( priv , irq_data -> hwirq ) ; if ( gpiochip_lock_as_irq ( & priv -> gc , gpio ) ) { dev_err ( priv -> gc . parent , "Unable<S2SV_blank>to<S2SV_blank>configure<S2SV_blank>XGene<S2SV_blank>GPIO<S2SV_blank>standby<S2SV_blank>pin<S2SV_blank>%d<S2SV_blank>as<S2SV_blank>IRQ\\n" , gpio ) ; <S2SV_StartBug> return ; <S2SV_EndBug> } xgene_gpio_set_bit ( & priv -> gc , priv -> regs + MPA_GPIO_SEL_LO , gpio * 2 , 1 ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> <S2SV_null> <S2SV_null> static int <S2SV_ModEnd> xgene_gpio_sb_domain_activate ( struct <S2SV_ModStart> irq_data * irq_data , bool early <S2SV_ModStart> ) ; return - ENOSPC <S2SV_ModStart> 1 ) ; return 0 ; |
1,355 | CWE-000 void prepare_alt_odb ( void ) { const char * alt ; if ( alt_odb_tail ) return ; alt = getenv ( ALTERNATE_DB_ENVIRONMENT ) ; if ( ! alt ) alt = "" ; alt_odb_tail = & alt_odb_list ; <S2SV_StartBug> link_alt_odb_entries ( alt , strlen ( alt ) , PATH_SEP , NULL , 0 ) ; <S2SV_EndBug> read_info_alternates ( get_object_directory ( ) , 0 ) ; } | <S2SV_ModStart> ( alt , <S2SV_ModEnd> PATH_SEP , NULL |
1,356 | CWE-000 void ary1Mpsr ( AryACB * acb , HDSLoc * loc , const char * type , const char * mode , char bad , HDSLoc * * mloc , char * copy , void * * pntr , char * dce , int * status ) { AryDCB * dcb ; AryMCB * mcb ; HDSLoc * tloc = NULL ; char extyp [ DAT__SZTYP + 1 ] ; char newbad ; hdsdim dim [ ARY__MXDIM ] ; hdsdim diml [ ARY__MXDIM ] ; hdsdim dimu [ ARY__MXDIM ] ; int i ; int ndim ; int ndima ; int ndimd ; size_t el ; void * tpntr ; * mloc = NULL ; if ( * status != SAI__OK ) return ; dcb = acb -> dcb ; mcb = acb -> mcb ; ndima = acb -> ndim ; ndimd = dcb -> ndim ; el = 1 ; ndim = ( ndima > ndimd ) ? ndima : ndimd ; for ( i = 0 ; i < ndim ; i ++ ) { dim [ i ] = mcb -> umrb [ i ] - mcb -> lmrb [ i ] + 1 ; el *= dim [ i ] ; } ary1Extyp ( dcb , extyp , status ) ; if ( mcb -> whole && ! strcasecmp ( type , extyp ) && strcmp ( dcb -> form , "SCALED" ) && strcmp ( dcb -> form , "DELTA" ) ) { datClone ( loc , mloc , status ) ; datMap ( * mloc , type , mode , ndimd , dim , pntr , status ) ; * copy = 0 ; * dce = 0 ; } else if ( mcb -> mrful && ( ndimd <= ARY__MXHSL ) && ! strcasecmp ( type , extyp ) && strcmp ( dcb -> form , "SCALED" ) && strcmp ( dcb -> form , "DELTA" ) ) { for ( i = 0 ; i < ndimd ; i ++ ) { diml [ i ] = mcb -> lmrb [ i ] - dcb -> lbnd [ i ] + 1 ; dimu [ i ] = mcb -> umrb [ i ] - dcb -> lbnd [ i ] + 1 ; } datSlice ( loc , ndimd , diml , dimu , mloc , status ) ; datMap ( * mloc , type , mode , ndimd , dim , pntr , status ) ; * copy = 0 ; * dce = 0 ; } else if ( mcb -> mrful && ! strcmp ( dcb -> form , "DELTA" ) && ! strcasecmp ( type , extyp ) && ( ndima == ndimd ) ) { ary1Cmtmp ( type , ndimd , dim , mloc , pntr , status ) ; for ( i = 0 ; i < ndimd ; i ++ ) { diml [ i ] = mcb -> lmrb [ i ] - dcb -> lbnd [ i ] + 1 ; dimu [ i ] = mcb -> umrb [ i ] - dcb -> lbnd [ i ] + 1 ; } <S2SV_StartBug> ary1Undlt ( dcb -> loc , ndimd , diml , dimu , pntr , & newbad , status ) ; <S2SV_EndBug> * copy = 1 ; * dce = 0 ; } else if ( mcb -> mtrex ) { ary1Cmtmp ( type , ndima , dim , mloc , pntr , status ) ; if ( ! strcmp ( dcb -> form , "DELTA" ) ) { for ( i = 0 ; i < ndimd ; i ++ ) { diml [ i ] = mcb -> lmtr [ i ] - dcb -> lbnd [ i ] + 1 ; dimu [ i ] = mcb -> umtr [ i ] - dcb -> lbnd [ i ] + 1 ; dim [ i ] = dimu [ i ] - diml [ i ] + 1 ; } ary1Cmtmp ( extyp , ndimd , dim , & tloc , & tpntr , status ) ; ary1Undlt ( dcb -> loc , ndimd , diml , dimu , tpntr , & newbad , status ) ; datUnmap ( tloc , status ) ; ary1Gtn ( bad , extyp , tloc , ndim , mcb -> lmtr , mcb -> umtr , mcb -> lmtr , mcb -> umtr , type , mcb -> lmrb , mcb -> umrb , 1 , dcb -> scloc , <S2SV_StartBug> pntr , dce , status ) ; <S2SV_EndBug> ary1Antmp ( & tloc , status ) ; } else { ary1Dscl ( dcb , status ) ; ary1Gtn ( bad , dcb -> type , loc , ndim , dcb -> lbnd , dcb -> ubnd , mcb -> lmtr , <S2SV_StartBug> mcb -> umtr , type , mcb -> lmrb , mcb -> umrb , 1 , dcb -> scloc , pntr , <S2SV_EndBug> dce , status ) ; } * copy = 1 ; } else { ary1Cmtmp ( type , ndima , dim , mloc , pntr , status ) ; <S2SV_StartBug> ary1Vbad ( type , el , pntr , status ) ; <S2SV_EndBug> * copy = 1 ; * dce = 0 ; } if ( * status != SAI__OK ) ary1Trace ( "ary1Mpsr" , status ) ; } | <S2SV_ModStart> , dimu , * <S2SV_ModStart> -> scloc , * <S2SV_ModStart> -> scloc , * <S2SV_ModStart> , el , * |
1,357 | CWE-000 void nautilus_files_view_pop_up_background_context_menu ( NautilusFilesView * view , GdkEventButton * event ) { NautilusFilesViewPrivate * priv ; g_assert ( NAUTILUS_IS_FILES_VIEW ( view ) ) ; priv = nautilus_files_view_get_instance_private ( view ) ; update_context_menus_if_pending ( view ) ; <S2SV_StartBug> nautilus_pop_up_context_menu ( GTK_WIDGET ( view ) , priv -> background_menu , event ) ; <S2SV_EndBug> } | <S2SV_ModStart> background_menu , event , NULL |
1,358 | CWE-000 PHP_FUNCTION ( opencc_error ) { <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> opencc_error ) { int len ; if ( zend_parse_parameters_none ( ) == FAILURE ) { return ; } const char * msg ; msg = opencc_error ( ) ; if ( NULL == msg ) { msg = "" ; } len = strlen ( msg ) ; # if PHP_MAJOR_VERSION < 7 RETURN_STRINGL ( msg , len , 0 ) ; # else zend_string * ret = zend_string_alloc ( len , 0 ) ; strncpy ( ret -> val , msg , len ) ; RETURN_STR ( ret ) ; # endif |
1,359 | CWE-000 static GPtrArray * setup_build_args ( GFile * app_dir , const char * module_name , BuilderContext * context , GFile * source_dir , const char * cwd_subdir , char * * flatpak_opts , char * * env_vars , GFile * * cwd_file ) { g_autoptr ( GPtrArray ) args = NULL ; g_autofree char * source_dir_path = g_file_get_path ( source_dir ) ; g_autofree char * source_dir_path_canonical = NULL ; g_autofree char * ccache_dir_path = NULL ; const char * builddir ; int i ; args = g_ptr_array_new_with_free_func ( g_free ) ; g_ptr_array_add ( args , g_strdup ( "flatpak" ) ) ; g_ptr_array_add ( args , g_strdup ( "build" ) ) ; <S2SV_StartBug> source_dir_path_canonical = canonicalize_file_name ( source_dir_path ) ; <S2SV_EndBug> if ( builder_context_get_build_runtime ( context ) ) builddir = "/run/build-runtime/" ; else builddir = "/run/build/" ; g_ptr_array_add ( args , g_strdup ( "--nofilesystem=host" ) ) ; g_ptr_array_add ( args , g_strdup_printf ( "--filesystem=%s" , source_dir_path_canonical ) ) ; if ( strcmp ( source_dir_path_canonical , source_dir_path ) != 0 ) g_ptr_array_add ( args , g_strdup_printf ( "--bind-mount=%s=%s" , source_dir_path , source_dir_path_canonical ) ) ; g_ptr_array_add ( args , g_strdup_printf ( "--bind-mount=%s%s=%s" , builddir , module_name , source_dir_path_canonical ) ) ; if ( cwd_subdir ) g_ptr_array_add ( args , g_strdup_printf ( "--build-dir=%s%s/%s" , builddir , module_name , cwd_subdir ) ) ; else g_ptr_array_add ( args , g_strdup_printf ( "--build-dir=%s%s" , builddir , module_name ) ) ; if ( g_file_query_exists ( builder_context_get_ccache_dir ( context ) , NULL ) ) { ccache_dir_path = g_file_get_path ( builder_context_get_ccache_dir ( context ) ) ; g_ptr_array_add ( args , g_strdup_printf ( "--bind-mount=/run/ccache=%s" , ccache_dir_path ) ) ; } if ( flatpak_opts ) { for ( i = 0 ; flatpak_opts [ i ] != NULL ; i ++ ) g_ptr_array_add ( args , g_strdup ( flatpak_opts [ i ] ) ) ; } if ( env_vars ) { for ( i = 0 ; env_vars [ i ] != NULL ; i ++ ) g_ptr_array_add ( args , g_strdup_printf ( "--env=%s" , env_vars [ i ] ) ) ; } g_ptr_array_add ( args , g_file_get_path ( app_dir ) ) ; * cwd_file = g_file_new_for_path ( source_dir_path_canonical ) ; return g_steal_pointer ( & args ) ; } | <S2SV_ModStart> ; source_dir_path_canonical = realpath ( source_dir_path , NULL <S2SV_ModEnd> ) ; if |
1,360 | CWE-000 void deliverMail ( faction * f , region * r , unit * u , const char * s , unit * receiver ) { <S2SV_StartBug> if ( ! cansee ( f , r , u , 0 ) ) { <S2SV_EndBug> u = NULL ; } if ( ! receiver ) { ADDMSG ( & f -> msgs , msg_message ( "regionmessage" , "region<S2SV_blank>sender<S2SV_blank>string" , r , u , s ) ) ; } else { ADDMSG ( & f -> msgs , msg_message ( "unitmessage" , "region<S2SV_blank>unit<S2SV_blank>sender<S2SV_blank>string" , r , receiver , u , s ) ) ; } } | <S2SV_ModStart> u , 0 , seen_unit |
1,361 | CWE-000 int main ( int argc , char * * argv ) { IntS year , iter , incr ; Bool killedany ; logged = FALSE ; atexit ( check_log ) ; isPartialSoilwatOutput = TRUE ; storeAllIterations = FALSE ; init_args ( argc , argv ) ; printf ( "STEPWAT<S2SV_blank><S2SV_blank>init_args()<S2SV_blank>executed<S2SV_blank>successfully<S2SV_blank>\\n" ) ; if ( UseGrid == TRUE ) { runGrid ( ) ; return 0 ; } parm_Initialize ( 0 ) ; if ( UseSoilwat ) { SXW_Init ( TRUE , NULL ) ; SW_OUT_set_ncol ( ) ; } incr = ( IntS ) ( ( float ) Globals . runModelIterations / 10 ) ; if ( incr == 0 ) incr = 1 ; for ( iter = 1 ; iter <= Globals . runModelIterations ; iter ++ ) { if ( progfp == stderr ) { if ( iter % incr == 0 ) fprintf ( progfp , "." ) ; } else { fprintf ( progfp , "%d\\n" , iter ) ; } if ( BmassFlags . yearly || MortFlags . yearly ) parm_Initialize ( iter ) ; Plot_Initialize ( ) ; RandSeed ( Globals . randseed ) ; Globals . currIter = iter ; for ( year = 1 ; year <= Globals . runModelYears ; year ++ ) { Globals . currYear = year ; rgroup_Establish ( ) ; Env_Generate ( ) ; rgroup_PartResources ( ) ; # ifdef STEPWAT if ( ! isnull ( SXW . debugfile ) ) SXW_PrintDebug ( 0 ) ; # endif rgroup_Grow ( ) ; mort_Main ( & killedany ) ; rgroup_IncrAges ( ) ; grazing_EndOfYear ( ) ; mort_EndOfYear ( ) ; stat_Collect ( year ) ; if ( BmassFlags . yearly ) output_Bmass_Yearly ( year ) ; _kill_annuals ( ) ; proportion_Recovery ( ) ; _kill_extra_growth ( ) ; } if ( MortFlags . summary ) { stat_Collect_GMort ( ) ; stat_Collect_SMort ( ) ; } if ( MortFlags . yearly ) output_Mort_Yearly ( ) ; if ( UseSoilwat ) { if ( Globals . currIter != Globals . runModelIterations ) SXW_Reset ( ) ; } } if ( MortFlags . summary ) stat_Output_AllMorts ( ) ; if ( BmassFlags . summary ) stat_Output_AllBmass ( ) ; # ifdef STEPWAT if ( ! isnull ( SXW . debugfile ) ) { printf ( "entering<S2SV_blank>debugfile\\n" ) ; SXW_PrintDebug ( 1 ) ; } # endif <S2SV_StartBug> free_all_sxw_memory ( ) ; <S2SV_EndBug> printf ( "\\nend<S2SV_blank>program\\n" ) ; fprintf ( progfp , "\\n" ) ; return 0 ; } | <S2SV_ModStart> } # endif SW_OUT_close_files ( ) ; |
1,362 | CWE-000 int qemuDomainNamespaceSetupMemory ( virQEMUDriverPtr driver , virDomainObjPtr vm , virDomainMemoryDefPtr mem ) <S2SV_StartBug> { <S2SV_EndBug> int ret = - 1 ; if ( mem -> model != VIR_DOMAIN_MEMORY_MODEL_NVDIMM ) return 0 ; if ( ! qemuDomainNamespaceEnabled ( vm , QEMU_DOMAIN_NS_MOUNT ) ) return 0 ; <S2SV_StartBug> if ( qemuDomainAttachDeviceMknod ( driver , vm , mem -> nvdimmPath ) < 0 ) <S2SV_EndBug> goto cleanup ; ret = 0 ; cleanup : <S2SV_StartBug> return ret ; <S2SV_EndBug> } | <S2SV_ModStart> mem ) { virQEMUDriverConfigPtr cfg = NULL ; char * * devMountsPath = NULL ; size_t ndevMountsPath = 0 ; <S2SV_ModStart> return 0 ; cfg = virQEMUDriverGetConfig ( driver ) ; if ( qemuDomainGetPreservedMounts ( cfg , vm , & devMountsPath , NULL , & ndevMountsPath ) < 0 ) goto cleanup ; <S2SV_ModStart> mem -> nvdimmPath , devMountsPath , ndevMountsPath <S2SV_ModStart> ; cleanup : virStringListFreeCount ( devMountsPath , ndevMountsPath ) ; virObjectUnref ( cfg ) ; |
1,363 | CWE-000 static void unshare_connection ( struct connection * c ) { c -> name = clone_str ( c -> name , "connection<S2SV_blank>name" ) ; c -> cisco_dns_info = clone_str ( c -> cisco_dns_info , "connection<S2SV_blank>cisco_dns_info" ) ; c -> modecfg_domain = clone_str ( c -> modecfg_domain , "connection<S2SV_blank>modecfg_domain" ) ; c -> modecfg_banner = clone_str ( c -> modecfg_banner , "connection<S2SV_blank>modecfg_banner" ) ; # ifdef HAVE_LABELED_IPSEC c -> policy_label = clone_str ( c -> policy_label , "connection<S2SV_blank>policy_label" ) ; # endif c -> dnshostname = clone_str ( c -> dnshostname , "connection<S2SV_blank>dnshostname" ) ; c -> connalias = clone_str ( c -> connalias , "connection<S2SV_blank>alias" ) ; c -> vti_iface = clone_str ( c -> vti_iface , "connection<S2SV_blank>vti_iface" ) ; struct spd_route * sr ; for ( sr = & c -> spd ; sr != NULL ; sr = sr -> spd_next ) { unshare_connection_end ( & sr -> this ) ; unshare_connection_end ( & sr -> that ) ; } if ( c -> alg_info_ike != NULL ) alg_info_addref ( & c -> alg_info_ike -> ai ) ; if ( c -> alg_info_esp != NULL ) alg_info_addref ( & c -> alg_info_esp -> ai ) ; <S2SV_StartBug> if ( c -> pool != NULL ) <S2SV_EndBug> reference_addresspool ( c -> pool ) ; } | <S2SV_ModStart> ai ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
1,364 | CWE-000 int main ( void ) { Bootstrap ( ) ; printf ( "============><S2SV_blank>Start<S2SV_blank>System<S2SV_blank>Tests\\n\\n" ) ; printf ( "=><S2SV_blank>Test0:<S2SV_blank>check<S2SV_blank>error<S2SV_blank>description\\n" ) ; { const char * error ; assert ( ( error = System_getError ( EINVAL ) ) != NULL ) ; printf ( "\\tEINVAL<S2SV_blank>description:<S2SV_blank>%s\\n" , error ) ; errno = EINVAL ; assert ( Str_isEqual ( System_getLastError ( ) , error ) ) ; } printf ( "=><S2SV_blank>Test0:<S2SV_blank>OK\\n\\n" ) ; <S2SV_StartBug> printf ( "============><S2SV_blank>System<S2SV_blank>Tests:<S2SV_blank>OK\\n\\n" ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> ; printf ( "=><S2SV_blank>Test1:<S2SV_blank>check<S2SV_blank>filedescriptors<S2SV_blank>wrapper\\n" ) ; { assert ( System_getDescriptorsGuarded ( 10 ) == 10 ) ; } printf ( "=><S2SV_blank>Test1:<S2SV_blank>OK\\n\\n" ) ; printf ( |
1,365 | CWE-000 static void write_dep_information ( dep_info * dep ) { FILE * fd = fopen ( dep -> path , "w+" ) ; if ( ! fd ) fatal ( "redo:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>%s" , dep -> path ) ; char hash [ 41 ] ; sha1_to_hex ( dep -> hash , hash ) ; <S2SV_StartBug> char * flags = dep -> flags & DEP_SOURCE ? "s" : "l" ; <S2SV_EndBug> int magic = atoi ( getenv ( "REDO_MAGIC" ) ) ; if ( fprintf ( fd , "%s:%lld.%.9ld:%010u:%s\\n" , hash , ( long long ) dep -> ctime . tv_sec , dep -> ctime . tv_nsec , magic , flags ) < 0 ) fatal ( "redo:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>write<S2SV_blank>to<S2SV_blank>%s" , dep -> path ) ; if ( fclose ( fd ) ) fatal ( "redo:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>close<S2SV_blank>%s" , dep -> path ) ; } | <S2SV_ModStart> * flags = ( <S2SV_ModStart> flags & DEP_SOURCE ) |
1,366 | CWE-000 void check_tore_inter ( t_rt * rt , int type ) { double tmp ; if ( rt -> start -> tor != NULL ) { rt -> tore = rt -> start -> tor ; while ( rt -> tore != NULL ) { if ( rt -> tore -> pln != NULL ) rt -> tore -> pln -> cut = 0 ; if ( type == 0 ) tmp = ft_check_tore ( rt , rt -> ray ) ; <S2SV_StartBug> else <S2SV_EndBug> <S2SV_StartBug> tmp = ft_check_tore ( rt , rt -> light_ray ) ; <S2SV_EndBug> if ( tmp > 0.01 && tmp < rt -> inter -> dst ) new_tore_dst ( rt , type , tmp ) ; rt -> tore = rt -> tore -> next ; } } } | <S2SV_ModStart> ray ) ; if ( type == 1 ) <S2SV_ModEnd> tmp = ft_check_tore <S2SV_ModStart> rt -> light_ray ) ; if ( type == 2 && rt -> inter -> num == rt -> tore -> id && rt -> inter -> light == rt -> tore -> id ) light_tore_inter ( rt |
1,367 | CWE-000 void tb_target_set_jmp_target ( uintptr_t tc_ptr , uintptr_t jmp_addr , uintptr_t addr ) { if ( TCG_TARGET_REG_BITS == 64 ) { tcg_insn_unit i1 , i2 ; intptr_t tb_diff = addr - tc_ptr ; intptr_t br_diff = addr - ( jmp_addr + 4 ) ; uint64_t pair ; if ( tb_diff == ( int16_t ) tb_diff ) { i1 = ADDI | TAI ( TCG_REG_TB , TCG_REG_TB , tb_diff ) ; i2 = B | ( br_diff & 0x3fffffc ) ; } else { intptr_t lo = ( int16_t ) tb_diff ; intptr_t hi = ( int32_t ) ( tb_diff - lo ) ; assert ( tb_diff == hi + lo ) ; i1 = ADDIS | TAI ( TCG_REG_TB , TCG_REG_TB , hi >> 16 ) ; i2 = ADDI | TAI ( TCG_REG_TB , TCG_REG_TB , lo ) ; } # ifdef HOST_WORDS_BIGENDIAN pair = ( uint64_t ) i1 << 32 | i2 ; # else pair = ( uint64_t ) i2 << 32 | i1 ; # endif <S2SV_StartBug> atomic_set ( ( uint64_t * ) jmp_addr , pair ) ; <S2SV_EndBug> flush_icache_range ( jmp_addr , jmp_addr + 8 ) ; } else { intptr_t diff = addr - jmp_addr ; tcg_debug_assert ( in_range_b ( diff ) ) ; atomic_set ( ( uint32_t * ) jmp_addr , B | ( diff & 0x3fffffc ) ) ; flush_icache_range ( jmp_addr , jmp_addr + 4 ) ; } } | <S2SV_ModStart> ; # endif atomic_set__nocheck <S2SV_ModEnd> ( ( uint64_t |
1,368 | CWE-000 int32_t handle_get ( char * filename , uint32_t * length , char * * msg ) <S2SV_StartBug> { <S2SV_EndBug> TRACE ( "%s\\n" , filename ) ; int32_t ret_val = 0 ; ret_val = read_file_to_buffer ( filename , msg , length ) ; if ( ret_val != 0 ) { LOG_EXCEPTION ( "Could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>file." , ret_val , EQ , 0 , FALSE ) ; ret_val = - 1 ; goto EXIT_LABEL ; } EXIT_LABEL : <S2SV_StartBug> return ( ret_val ) ; <S2SV_EndBug> } | <S2SV_ModStart> msg ) { ENTRY ( ) ; <S2SV_ModStart> } EXIT_LABEL : EXIT ( ) ; |
1,369 | CWE-000 static int fname_encrypt ( struct inode * inode , const struct qstr * iname , struct fscrypt_str * oname ) { u32 ciphertext_len ; struct ablkcipher_request * req = NULL ; DECLARE_FS_COMPLETION_RESULT ( ecr ) ; struct fscrypt_info * ci = inode -> i_crypt_info ; struct crypto_ablkcipher * tfm = ci -> ci_ctfm ; int res = 0 ; char iv [ FS_CRYPTO_BLOCK_SIZE ] ; struct scatterlist src_sg , dst_sg ; int padding = 4 << ( ci -> ci_flags & FS_POLICY_FLAGS_PAD_MASK ) ; char * workbuf , buf [ 32 ] , * alloc_buf = NULL ; unsigned lim ; lim = inode -> i_sb -> s_cop -> max_namelen ( inode ) ; if ( iname -> len <= 0 || iname -> len > lim ) return - EIO ; <S2SV_StartBug> ciphertext_len = ( iname -> len < FS_CRYPTO_BLOCK_SIZE ) ? <S2SV_EndBug> FS_CRYPTO_BLOCK_SIZE : iname -> len ; ciphertext_len = size_round_up ( ciphertext_len , padding ) ; <S2SV_StartBug> ciphertext_len = ( ciphertext_len > lim ) ? lim : ciphertext_len ; <S2SV_EndBug> if ( ciphertext_len <= sizeof ( buf ) ) { workbuf = buf ; } else { alloc_buf = kmalloc ( ciphertext_len , GFP_NOFS ) ; if ( ! alloc_buf ) return - ENOMEM ; workbuf = alloc_buf ; } req = ablkcipher_request_alloc ( tfm , GFP_NOFS ) ; if ( ! req ) { printk_ratelimited ( KERN_ERR "%s:<S2SV_blank>crypto_request_alloc()<S2SV_blank>failed\\n" , __func__ ) ; kfree ( alloc_buf ) ; return - ENOMEM ; } ablkcipher_request_set_callback ( req , CRYPTO_TFM_REQ_MAY_BACKLOG | CRYPTO_TFM_REQ_MAY_SLEEP , <S2SV_StartBug> dir_crypt_complete , & ecr ) ; <S2SV_EndBug> memcpy ( workbuf , iname -> name , iname -> len ) ; if ( iname -> len < ciphertext_len ) memset ( workbuf + iname -> len , 0 , ciphertext_len - iname -> len ) ; memset ( iv , 0 , FS_CRYPTO_BLOCK_SIZE ) ; sg_init_one ( & src_sg , workbuf , ciphertext_len ) ; sg_init_one ( & dst_sg , oname -> name , ciphertext_len ) ; ablkcipher_request_set_crypt ( req , & src_sg , & dst_sg , ciphertext_len , iv ) ; res = crypto_ablkcipher_encrypt ( req ) ; if ( res == - EINPROGRESS || res == - EBUSY ) { wait_for_completion ( & ecr . completion ) ; res = ecr . res ; } kfree ( alloc_buf ) ; ablkcipher_request_free ( req ) ; <S2SV_StartBug> if ( res < 0 ) <S2SV_EndBug> printk_ratelimited ( KERN_ERR "%s:<S2SV_blank>Error<S2SV_blank>(error<S2SV_blank>code<S2SV_blank>%d)\\n" , __func__ , res ) ; <S2SV_StartBug> oname -> len = ciphertext_len ; <S2SV_EndBug> <S2SV_StartBug> return res ; <S2SV_EndBug> } | <S2SV_ModStart> ; ciphertext_len = max ( iname -> len , ( u32 ) FS_CRYPTO_BLOCK_SIZE ) ; ciphertext_len = round_up <S2SV_ModEnd> ( ciphertext_len , <S2SV_ModStart> ; ciphertext_len = min ( ciphertext_len , lim ) <S2SV_ModEnd> ; if ( <S2SV_ModStart> | CRYPTO_TFM_REQ_MAY_SLEEP , fname_crypt_complete <S2SV_ModEnd> , & ecr <S2SV_ModStart> < 0 ) { <S2SV_ModStart> res ) ; return res ; } <S2SV_ModStart> ciphertext_len ; return 0 <S2SV_ModEnd> ; } <S2SV_null> |
1,370 | CWE-000 <S2SV_StartBug> VOID <S2SV_EndBug> ODM_UpdateMpDriverStatus ( IN PDM_ODM_T pDM_Odm ) { # if ( DM_ODM_SUPPORT_TYPE & ODM_WIN ) # elif ( DM_ODM_SUPPORT_TYPE & ODM_CE ) PADAPTER Adapter = pDM_Odm -> Adapter ; pDM_Odm -> mp_mode = ( BOOLEAN ) Adapter -> registrypriv . mp_mode ; # else # endif } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static |
1,371 | CWE-000 static void sym_validate_range ( struct symbol * sym ) { struct property * prop ; int base ; long long val , val2 ; char str [ 64 ] ; switch ( sym -> type ) { case S_INT : base = 10 ; break ; case S_HEX : base = 16 ; break ; default : return ; } prop = sym_get_range_prop ( sym ) ; if ( ! prop ) return ; val = strtoll ( sym -> curr . val , NULL , base ) ; val2 = sym_get_range_val ( prop -> expr -> left . sym , base ) ; if ( val >= val2 ) { val2 = sym_get_range_val ( prop -> expr -> right . sym , base ) ; if ( val <= val2 ) return ; } if ( sym -> type == S_INT ) sprintf ( str , "%lld" , val2 ) ; else sprintf ( str , "0x%llx" , val2 ) ; <S2SV_StartBug> sym -> curr . val = strdup ( str ) ; <S2SV_EndBug> } | <S2SV_ModStart> . val = xstrdup <S2SV_ModEnd> ( str ) |
1,372 | CWE-000 static long slb_allocate_kernel ( unsigned long ea , unsigned long id ) { unsigned long context ; unsigned long flags ; int ssize ; if ( id == KERNEL_REGION_ID ) { if ( ( ea & ~ REGION_MASK ) > ( 1UL << MAX_PHYSMEM_BITS ) ) return - EFAULT ; flags = SLB_VSID_KERNEL | mmu_psize_defs [ mmu_linear_psize ] . sllp ; # ifdef CONFIG_SPARSEMEM_VMEMMAP } else if ( id == VMEMMAP_REGION_ID ) { if ( ( ea & ~ REGION_MASK ) >= ( 1ULL << MAX_EA_BITS_PER_CONTEXT ) ) return - EFAULT ; flags = SLB_VSID_KERNEL | mmu_psize_defs [ mmu_vmemmap_psize ] . sllp ; # endif } else if ( id == VMALLOC_REGION_ID ) { if ( ( ea & ~ REGION_MASK ) >= ( 1ULL << MAX_EA_BITS_PER_CONTEXT ) ) return - EFAULT ; if ( ea < H_VMALLOC_END ) <S2SV_StartBug> flags = get_paca ( ) -> vmalloc_sllp ; <S2SV_EndBug> else flags = SLB_VSID_KERNEL | mmu_psize_defs [ mmu_io_psize ] . sllp ; } else { return - EFAULT ; } ssize = MMU_SEGSIZE_1T ; if ( ! mmu_has_feature ( MMU_FTR_1T_SEGMENT ) ) ssize = MMU_SEGSIZE_256M ; context = get_kernel_context ( ea ) ; return slb_insert_entry ( ea , context , flags , ssize , true ) ; } | <S2SV_ModStart> ) flags = local_paca <S2SV_ModEnd> -> vmalloc_sllp ; |
1,373 | CWE-000 int ex_int_handle_mode ( unsigned int my_mode , int is_parallel , int run_version ) { char errmsg [ MAX_ERR_LENGTH ] ; int nc_mode = 0 ; # if NC_HAS_HDF5 static int netcdf4_mode = - 1 ; # endif # if defined ( NC_64BIT_DATA ) static int netcdf5_mode = - 1 ; # endif int filesiz = 1 ; int int64_status ; int pariomode = 0 ; static unsigned int all_modes = EX_NORMAL_MODEL | EX_64BIT_OFFSET | EX_64BIT_DATA | EX_NETCDF4 ; if ( run_version != EX_API_VERS_NODOT && warning_output == 0 ) { int run_version_major = run_version / 100 ; int run_version_minor = run_version % 100 ; int lib_version_major = EX_API_VERS_NODOT / 100 ; int lib_version_minor = EX_API_VERS_NODOT % 100 ; fprintf ( stderr , "EXODUS:<S2SV_blank>Warning:<S2SV_blank>This<S2SV_blank>code<S2SV_blank>was<S2SV_blank>compiled<S2SV_blank>with<S2SV_blank>exodusII<S2SV_blank>" "version<S2SV_blank>%d.%02d,\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>but<S2SV_blank>was<S2SV_blank>linked<S2SV_blank>with<S2SV_blank>exodusII<S2SV_blank>" "library<S2SV_blank>version<S2SV_blank>%d.%02d\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>This<S2SV_blank>is<S2SV_blank>probably<S2SV_blank>an<S2SV_blank>" "error<S2SV_blank>in<S2SV_blank>the<S2SV_blank>build<S2SV_blank>process<S2SV_blank>of<S2SV_blank>this<S2SV_blank>code.\\n" , run_version_major , run_version_minor , lib_version_major , lib_version_minor ) ; warning_output = 1 ; } # if ! NC_HAS_HDF5 if ( my_mode & EX_NETCDF4 ) { snprintf ( errmsg , MAX_ERR_LENGTH , "EXODUS:<S2SV_blank>ERROR:<S2SV_blank>File<S2SV_blank>format<S2SV_blank>specified<S2SV_blank>as<S2SV_blank>netcdf-4,<S2SV_blank>but<S2SV_blank>the<S2SV_blank>" "NetCDF<S2SV_blank>library<S2SV_blank>being<S2SV_blank>used<S2SV_blank>was<S2SV_blank>not<S2SV_blank>configured<S2SV_blank>to<S2SV_blank>enable<S2SV_blank>" "this<S2SV_blank>format\\n" ) ; <S2SV_StartBug> ex_err_fn ( exoid , __func__ , errmsg , EX_BADPARAM ) ; <S2SV_EndBug> EX_FUNC_LEAVE ( EX_FATAL ) ; } # endif # if ! defined ( NC_64BIT_DATA ) if ( my_mode & EX_64BIT_DATA ) { snprintf ( errmsg , MAX_ERR_LENGTH , "EXODUS:<S2SV_blank>ERROR:<S2SV_blank>File<S2SV_blank>format<S2SV_blank>specified<S2SV_blank>as<S2SV_blank>64bit_data,<S2SV_blank>but<S2SV_blank>" "the<S2SV_blank>NetCDF<S2SV_blank>library<S2SV_blank>being<S2SV_blank>used<S2SV_blank>does<S2SV_blank>not<S2SV_blank>support<S2SV_blank>this<S2SV_blank>" "format\\n" ) ; <S2SV_StartBug> ex_err_fn ( exoid , __func__ , errmsg , EX_BADPARAM ) ; <S2SV_EndBug> EX_FUNC_LEAVE ( EX_FATAL ) ; } # endif { unsigned int set_modes = all_modes & my_mode ; if ( set_modes == 0 ) { my_mode |= EX_64BIT_OFFSET ; } else { set_modes = set_modes && ! ( set_modes & ( set_modes - 1 ) ) ; if ( ! set_modes ) { snprintf ( errmsg , MAX_ERR_LENGTH , "EXODUS:<S2SV_blank>ERROR:<S2SV_blank>More<S2SV_blank>than<S2SV_blank>1<S2SV_blank>file<S2SV_blank>format<S2SV_blank>" "(EX_NORMAL_MODEL,<S2SV_blank>EX_LARGE_MODEL,<S2SV_blank>EX_64BIT_OFFSET,<S2SV_blank>" "EX_64BIT_DATA,<S2SV_blank>or<S2SV_blank>EX_NETCDF4)\\nwas<S2SV_blank>specified<S2SV_blank>in<S2SV_blank>the<S2SV_blank>" "mode<S2SV_blank>argument<S2SV_blank>of<S2SV_blank>the<S2SV_blank>ex_create<S2SV_blank>call.<S2SV_blank>Only<S2SV_blank>a<S2SV_blank>single<S2SV_blank>" "format<S2SV_blank>can<S2SV_blank>be<S2SV_blank>specified.\\n" ) ; ex_err ( __func__ , errmsg , EX_BADPARAM ) ; EX_FUNC_LEAVE ( EX_FATAL ) ; } } } int64_status = my_mode & ( EX_ALL_INT64_DB | EX_ALL_INT64_API ) ; if ( ( int64_status & EX_ALL_INT64_DB ) != 0 ) { # if NC_HAS_HDF5 || defined ( NC_64BIT_DATA ) if ( my_mode & EX_NETCDF4 ) { my_mode |= EX_NOCLASSIC ; } # if defined ( NC_64BIT_DATA ) else if ( my_mode & EX_64BIT_DATA ) { ; } # endif else { my_mode &= ~ all_modes ; # if NC_HAS_HDF5 my_mode |= EX_NOCLASSIC ; my_mode |= EX_NETCDF4 ; # else my_mode |= EX_64BIT_DATA ; # endif } # else snprintf ( errmsg , MAX_ERR_LENGTH , "EXODUS:<S2SV_blank>ERROR:<S2SV_blank>64-bit<S2SV_blank>integer<S2SV_blank>storage<S2SV_blank>requested,<S2SV_blank>but<S2SV_blank>the<S2SV_blank>" "netcdf<S2SV_blank>library<S2SV_blank>does<S2SV_blank>not<S2SV_blank>support<S2SV_blank>the<S2SV_blank>required<S2SV_blank>netcdf-4<S2SV_blank>or<S2SV_blank>" "64BIT_DATA<S2SV_blank>extensions.\\n" ) ; <S2SV_StartBug> ex_err_fn ( exoid , __func__ , errmsg , EX_BADPARAM ) ; <S2SV_EndBug> EX_FUNC_LEAVE ( EX_FATAL ) ; # endif } # if defined ( PARALLEL_AWARE_EXODUS ) if ( is_parallel ) { int tmp_mode = 0 ; if ( my_mode & EX_MPIPOSIX ) { pariomode = NC_MPIIO ; tmp_mode = EX_NETCDF4 ; # if ! NC_HAS_HDF5 snprintf ( errmsg , MAX_ERR_LENGTH , "EXODUS:<S2SV_blank>ERROR:<S2SV_blank>EX_MPIPOSIX<S2SV_blank>parallel<S2SV_blank>output<S2SV_blank>requested<S2SV_blank>" "which<S2SV_blank>requires<S2SV_blank>NetCDF-4<S2SV_blank>support,<S2SV_blank>but<S2SV_blank>the<S2SV_blank>library<S2SV_blank>does<S2SV_blank>" "not<S2SV_blank>have<S2SV_blank>that<S2SV_blank>option<S2SV_blank>enabled.\\n" ) ; <S2SV_StartBug> ex_err_fn ( exoid , __func__ , errmsg , EX_BADPARAM ) ; <S2SV_EndBug> EX_FUNC_LEAVE ( EX_FATAL ) ; # endif } else if ( my_mode & EX_MPIIO ) { pariomode = NC_MPIIO ; tmp_mode = EX_NETCDF4 ; # if ! NC_HAS_HDF5 snprintf ( errmsg , MAX_ERR_LENGTH , "EXODUS:<S2SV_blank>ERROR:<S2SV_blank>EX_MPIIO<S2SV_blank>parallel<S2SV_blank>output<S2SV_blank>requested<S2SV_blank>which<S2SV_blank>" "requires<S2SV_blank>NetCDF-4<S2SV_blank>support,<S2SV_blank>but<S2SV_blank>the<S2SV_blank>library<S2SV_blank>does<S2SV_blank>not<S2SV_blank>" "have<S2SV_blank>that<S2SV_blank>option<S2SV_blank>enabled.\\n" ) ; <S2SV_StartBug> ex_err_fn ( exoid , __func__ , errmsg , EX_BADPARAM ) ; <S2SV_EndBug> EX_FUNC_LEAVE ( EX_FATAL ) ; # endif } else if ( my_mode & EX_NETCDF4 ) { pariomode = NC_MPIIO ; tmp_mode = EX_NETCDF4 ; # if ! NC_HAS_HDF5 snprintf ( errmsg , MAX_ERR_LENGTH , "EXODUS:<S2SV_blank>ERROR:<S2SV_blank>EX_NETCDF4<S2SV_blank>parallel<S2SV_blank>output<S2SV_blank>requested<S2SV_blank>which<S2SV_blank>" "requires<S2SV_blank>NetCDF-4<S2SV_blank>support,<S2SV_blank>but<S2SV_blank>the<S2SV_blank>library<S2SV_blank>does<S2SV_blank>not<S2SV_blank>" "have<S2SV_blank>that<S2SV_blank>option<S2SV_blank>enabled.\\n" ) ; <S2SV_StartBug> ex_err_fn ( exoid , __func__ , errmsg , EX_BADPARAM ) ; <S2SV_EndBug> EX_FUNC_LEAVE ( EX_FATAL ) ; # endif } else if ( my_mode & EX_PNETCDF ) { pariomode = NC_PNETCDF ; if ( ( int64_status & EX_ALL_INT64_DB ) != 0 ) { tmp_mode = EX_64BIT_DATA ; } else { tmp_mode = EX_64BIT_OFFSET ; } # if ! NC_HAS_PNETCDF snprintf ( errmsg , MAX_ERR_LENGTH , "EXODUS:<S2SV_blank>ERROR:<S2SV_blank>EX_PNETCDF<S2SV_blank>parallel<S2SV_blank>output<S2SV_blank>requested<S2SV_blank>" "which<S2SV_blank>requires<S2SV_blank>PNetCDF<S2SV_blank>support,<S2SV_blank>but<S2SV_blank>the<S2SV_blank>library<S2SV_blank>does<S2SV_blank>" "not<S2SV_blank>have<S2SV_blank>that<S2SV_blank>option<S2SV_blank>enabled.\\n" ) ; <S2SV_StartBug> ex_err_fn ( exoid , __func__ , errmsg , EX_BADPARAM ) ; <S2SV_EndBug> EX_FUNC_LEAVE ( EX_FATAL ) ; # endif } my_mode &= ~ all_modes ; my_mode |= tmp_mode ; } # endif if ( my_mode & EX_NETCDF4 ) { nc_mode |= NC_NETCDF4 ; } else { if ( netcdf4_mode == - 1 ) { char * option = getenv ( "EXODUS_NETCDF4" ) ; if ( option != NULL ) { netcdf4_mode = NC_NETCDF4 ; if ( option [ 0 ] != 'q' ) { fprintf ( stderr , "EXODUS:<S2SV_blank>Using<S2SV_blank>netcdf<S2SV_blank>version<S2SV_blank>4<S2SV_blank>selected<S2SV_blank>via<S2SV_blank>" "EXODUS_NETCDF4<S2SV_blank>environment<S2SV_blank>variable\\n" ) ; } } else { netcdf4_mode = 0 ; } } nc_mode |= netcdf4_mode ; } if ( ! ( my_mode & EX_NOCLASSIC ) ) { nc_mode |= NC_CLASSIC_MODEL ; } # if defined ( NC_64BIT_DATA ) if ( my_mode & EX_64BIT_DATA ) { nc_mode |= ( NC_64BIT_DATA ) ; } else { if ( netcdf5_mode == - 1 ) { char * option = getenv ( "EXODUS_NETCDF5" ) ; if ( option != NULL ) { netcdf5_mode = NC_64BIT_DATA ; if ( option [ 0 ] != 'q' ) { fprintf ( stderr , "EXODUS:<S2SV_blank>Using<S2SV_blank>netcdf<S2SV_blank>version<S2SV_blank>5<S2SV_blank>(CDF5)<S2SV_blank>selected<S2SV_blank>via<S2SV_blank>" "EXODUS_NETCDF5<S2SV_blank>environment<S2SV_blank>variable\\n" ) ; } } else { netcdf5_mode = 0 ; } } nc_mode |= netcdf5_mode ; } # endif if ( # if NC_HAS_HDF5 ! ( nc_mode & NC_NETCDF4 ) && # endif # if defined ( NC_64BIT_DATA ) ! ( nc_mode & NC_64BIT_DATA ) && # endif filesiz == 1 ) { nc_mode |= NC_64BIT_OFFSET ; } if ( my_mode & EX_SHARE ) { nc_mode |= NC_SHARE ; } ex_opts ( exoptval ) ; if ( my_mode & EX_CLOBBER ) { nc_mode |= NC_CLOBBER ; } else { nc_mode |= NC_NOCLOBBER ; } # if NC_HAS_DISKLESS if ( my_mode & EX_DISKLESS ) { nc_mode |= NC_DISKLESS ; nc_mode |= NC_WRITE ; } # endif return nc_mode | pariomode ; } | <S2SV_ModStart> "this<S2SV_blank>format\\n" ) ; ex_err ( <S2SV_ModEnd> __func__ , errmsg <S2SV_ModStart> "format\\n" ) ; ex_err ( <S2SV_ModEnd> __func__ , errmsg <S2SV_ModStart> "64BIT_DATA<S2SV_blank>extensions.\\n" ) ; ex_err ( <S2SV_ModEnd> __func__ , errmsg <S2SV_ModStart> "not<S2SV_blank>have<S2SV_blank>that<S2SV_blank>option<S2SV_blank>enabled.\\n" ) ; ex_err ( <S2SV_ModEnd> __func__ , errmsg <S2SV_ModStart> "have<S2SV_blank>that<S2SV_blank>option<S2SV_blank>enabled.\\n" ) ; ex_err ( <S2SV_ModEnd> __func__ , errmsg <S2SV_ModStart> "have<S2SV_blank>that<S2SV_blank>option<S2SV_blank>enabled.\\n" ) ; ex_err ( <S2SV_ModEnd> __func__ , errmsg <S2SV_ModStart> "not<S2SV_blank>have<S2SV_blank>that<S2SV_blank>option<S2SV_blank>enabled.\\n" ) ; ex_err ( <S2SV_ModEnd> __func__ , errmsg |
1,374 | CWE-000 <S2SV_StartBug> Message createFileListMessage ( char * username ) { <S2SV_EndBug> char * strList = calloc ( 1 , MAX_FILES_PER_USER * ( 2 + MAX_FILENAME ) ) ; DIR * dirp ; char * path = calloc ( 1 , MAX_FILENAME ) ; <S2SV_StartBug> sprintf ( path , "SERVER/DATA/%s/" , username ) ; <S2SV_EndBug> struct dirent * entry ; dirp = opendir ( path ) ; while ( ( entry = readdir ( dirp ) ) != NULL ) { if ( entry -> d_type == DT_REG ) { strcat ( strList , "\\n" ) ; strcat ( strList , entry -> d_name ) ; } } closedir ( dirp ) ; return createMessagefromString ( list_of_files_resMSG , strList ) ; } | <S2SV_ModStart> char * username , char * dataPath <S2SV_ModStart> ( path , "%s/%s/" , dataPath <S2SV_ModEnd> , username ) |
1,375 | CWE-000 <S2SV_StartBug> int isLinkLocalAddress ( char * address , int family ) <S2SV_EndBug> { if ( ! address || ( strlen ( address ) == 0 ) ) { return 0 ; } if ( ( family != PR_AF_INET ) && ( family != PR_AF_INET6 ) ) { return 0 ; } if ( family == PR_AF_INET6 ) { if ( ( strncasecmp ( address , "fe80" , 4 ) >= 0 ) && ( strncasecmp ( address , "feb0" , 4 ) <= 0 ) ) { return 1 ; } } else { if ( ( strcasecmp ( address , "169.254.1.0" ) >= 0 ) && ( strcasecmp ( address , "169.254.254.255" ) <= 0 ) ) { return 1 ; } } return 0 ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static |
1,376 | CWE-000 void server_pubdown ( char * file , char * out ) { char fullpath [ BUFFER_SIZE ] ; memset ( fullpath , 0 , strlen ( fullpath ) ) ; strcat ( fullpath , filepath ) ; strcat ( fullpath , "/" ) ; strcat ( fullpath , file ) ; if ( access ( fullpath , F_OK ) != - 1 ) { int fd = open ( fullpath , O_RDONLY ) ; <S2SV_StartBug> int bytes = read ( fd , out , sizeof ( out ) ) ; <S2SV_EndBug> close ( fd ) ; } else { <S2SV_StartBug> strcat ( out , "File<S2SV_blank>\\"" ) ; <S2SV_EndBug> strcat ( out , file ) ; strcat ( out , "\\"<S2SV_blank>not<S2SV_blank>found!\\n" ) ; } } | <S2SV_ModStart> , out , FILE_SIZE <S2SV_ModEnd> ) ; close <S2SV_ModStart> ( out , "pubdown::nofile" <S2SV_ModEnd> ) ; } |
1,377 | CWE-000 static bc_tick_t _bc_spirit1_check_state_rx ( void ) { if ( bc_tick_get ( ) >= _bc_spirit1 . rx_tick_timeout ) { if ( _bc_spirit1 . event_handler != NULL ) { _bc_spirit1 . event_handler ( BC_SPIRIT1_EVENT_RX_TIMEOUT ) ; } } SpiritIrqs xIrqStatus ; SpiritIrqGetStatus ( & xIrqStatus ) ; if ( xIrqStatus . IRQ_RX_DATA_DISC ) { SpiritCmdStrobeRx ( ) ; } if ( xIrqStatus . IRQ_RX_DATA_READY ) { uint8_t cRxData = SpiritLinearFifoReadNumElementsRxFifo ( ) ; <S2SV_StartBug> SpiritSpiReadLinearFifo ( cRxData , _bc_spirit1 . rx_buffer ) ; <S2SV_EndBug> _bc_spirit1 . rx_length = cRxData ; if ( _bc_spirit1 . event_handler != NULL ) { _bc_spirit1 . event_handler ( BC_SPIRIT1_EVENT_RX_DONE ) ; } } <S2SV_StartBug> SpiritCmdStrobeFlushRxFifo ( ) ; <S2SV_EndBug> SpiritCmdStrobeRx ( ) ; return BC_TICK_INFINITY ; } | <S2SV_ModStart> ( ) ; if ( cRxData <= BC_SPIRIT1_MAX_PACKET_SIZE ) { <S2SV_ModStart> ; } } } |
1,378 | CWE-000 uint64_t <S2SV_StartBug> GetErrno_Syscall ( uint64_t UNUSED ( instruction_pointer ) , <S2SV_EndBug> uint64_t syscall_num , uint64_t * UNUSED ( syscall_params ) ) { if ( syscall_num != Syscall_GetErrno ) return - ENOSYS ; return GetThreadErrno ( GetCurrentThreadUID ( ) ) ; } | <S2SV_ModStart> uint64_t GetErrno_Syscall ( void ) { <S2SV_ModEnd> return GetThreadErrno ( |
1,379 | CWE-000 static void __sched_fork ( unsigned long clone_flags , struct task_struct * p ) { p -> on_rq = 0 ; p -> se . on_rq = 0 ; p -> se . exec_start = 0 ; p -> se . sum_exec_runtime = 0 ; p -> se . prev_sum_exec_runtime = 0 ; p -> se . nr_migrations = 0 ; p -> se . vruntime = 0 ; INIT_LIST_HEAD ( & p -> se . group_node ) ; # ifdef CONFIG_SCHEDSTATS memset ( & p -> se . statistics , 0 , sizeof ( p -> se . statistics ) ) ; # endif <S2SV_StartBug> cpufreq_task_times_init ( p ) ; <S2SV_EndBug> RB_CLEAR_NODE ( & p -> dl . rb_node ) ; init_dl_task_timer ( & p -> dl ) ; __dl_clear_params ( p ) ; INIT_LIST_HEAD ( & p -> rt . run_list ) ; p -> rt . timeout = 0 ; p -> rt . time_slice = sched_rr_timeslice ; p -> rt . on_rq = 0 ; p -> rt . on_list = 0 ; # ifdef CONFIG_PREEMPT_NOTIFIERS INIT_HLIST_HEAD ( & p -> preempt_notifiers ) ; # endif # ifdef CONFIG_NUMA_BALANCING if ( p -> mm && atomic_read ( & p -> mm -> mm_users ) == 1 ) { p -> mm -> numa_next_scan = jiffies + msecs_to_jiffies ( sysctl_numa_balancing_scan_delay ) ; p -> mm -> numa_scan_seq = 0 ; } if ( clone_flags & CLONE_VM ) p -> numa_preferred_nid = current -> numa_preferred_nid ; else p -> numa_preferred_nid = - 1 ; p -> node_stamp = 0ULL ; p -> numa_scan_seq = p -> mm ? p -> mm -> numa_scan_seq : 0 ; p -> numa_scan_period = sysctl_numa_balancing_scan_delay ; p -> numa_work . next = & p -> numa_work ; p -> numa_faults = NULL ; p -> last_task_numa_placement = 0 ; p -> last_sum_exec_runtime = 0 ; p -> numa_group = NULL ; # endif } | <S2SV_ModStart> ; # endif <S2SV_ModEnd> RB_CLEAR_NODE ( & |
1,380 | CWE-000 int ft_get_line_type ( char * str ) <S2SV_StartBug> { <S2SV_EndBug> if ( ! ft_strcmp ( str , "##start" ) ) return ( 2 ) ; else if ( ! ft_strcmp ( str , "##end" ) ) return ( 3 ) ; else if ( str [ 0 ] == '#' ) return ( 1 ) ; else if ( ft_is_link ( str ) ) return ( 4 ) ; else if ( ft_is_room ( str ) ) return ( 5 ) ; return ( - 1 ) ; } | <S2SV_ModStart> str ) { if ( str == NULL ) return ( - 1 ) ; |
1,381 | CWE-000 static inline void trace_load ( struct ktz_tdq * tdq ) <S2SV_StartBug> { <S2SV_EndBug> struct rq * rq = RQ ( tdq ) ; trace_sched_load_changed ( rq -> cpu , rq -> nr_running ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> tdq ) { # ifdef CONFIG_SMP <S2SV_ModStart> nr_running ) ; # endif |
1,382 | CWE-000 static int process_call_results ( plcConn * conn , SEXP retval , plcRFunction * r_func ) { plcMsgResult * res ; int i = 0 , ret = 0 ; res = malloc ( sizeof ( plcMsgResult ) ) ; res -> msgtype = MT_RESULT ; res -> names = malloc ( 1 * sizeof ( char * ) ) ; res -> types = malloc ( 1 * sizeof ( plcType ) ) ; res -> exception_callback = NULL ; if ( r_func -> retset != 0 ) { if ( handle_retset ( retval , r_func , res ) != 0 ) { free_result ( res , true ) ; return - 1 ; } } else { res -> rows = 1 ; res -> cols = 1 ; res -> data = malloc ( res -> rows * sizeof ( rawdata * ) ) ; for ( i = 0 ; i < res -> rows ; i ++ ) { res -> data [ i ] = malloc ( res -> cols * sizeof ( rawdata ) ) ; } plc_r_copy_type ( & res -> types [ 0 ] , & r_func -> res ) ; res -> names [ 0 ] = strdup ( r_func -> res . argName ) ; if ( retval == R_NilValue ) { res -> data [ 0 ] [ 0 ] . isnull = 1 ; res -> data [ 0 ] [ 0 ] . value = NULL ; } else { for ( i = 0 ; i < res -> rows ; i ++ ) { res -> data [ i ] [ 0 ] . isnull = 0 ; if ( r_func -> res . conv . outputfunc == NULL ) { <S2SV_StartBug> raise_execution_error ( plcconn_global , <S2SV_EndBug> "Type<S2SV_blank>%d<S2SV_blank>is<S2SV_blank>not<S2SV_blank>yet<S2SV_blank>supported<S2SV_blank>by<S2SV_blank>R<S2SV_blank>container" , ( int ) res -> types [ 0 ] . type ) ; free_result ( res , true ) ; return - 1 ; } ret = r_func -> res . conv . outputfunc ( retval , & res -> data [ i ] [ 0 ] . value , & r_func -> res ) ; if ( ret != 0 ) { <S2SV_StartBug> raise_execution_error ( plcconn_global , <S2SV_EndBug> "Exception<S2SV_blank>raised<S2SV_blank>converting<S2SV_blank>function<S2SV_blank>output<S2SV_blank>to<S2SV_blank>function<S2SV_blank>output<S2SV_blank>type<S2SV_blank>%d" , ( int ) res -> types [ 0 ] . type ) ; free_result ( res , true ) ; return - 1 ; } } } } plcontainer_channel_send ( conn , ( plcMessage * ) res ) ; free_result ( res , true ) ; return 0 ; } | <S2SV_ModStart> { raise_execution_error ( <S2SV_ModEnd> "Type<S2SV_blank>%d<S2SV_blank>is<S2SV_blank>not<S2SV_blank>yet<S2SV_blank>supported<S2SV_blank>by<S2SV_blank>R<S2SV_blank>container" , ( <S2SV_ModStart> { raise_execution_error ( <S2SV_ModEnd> "Exception<S2SV_blank>raised<S2SV_blank>converting<S2SV_blank>function<S2SV_blank>output<S2SV_blank>to<S2SV_blank>function<S2SV_blank>output<S2SV_blank>type<S2SV_blank>%d" , ( |
1,383 | CWE-000 int ddcb_register_accelerator ( struct ddcb_accel_funcs * accel ) { int rc ; if ( accel == NULL ) return DDCB_ERR_INVAL ; <S2SV_StartBug> if ddcb_gather_statistics ( ) { <S2SV_EndBug> rc = pthread_mutex_init ( & accel -> slock , NULL ) ; if ( rc != 0 ) return DDCB_ERRNO ; } accel -> priv_data = accel_list ; accel_list = accel ; return DDCB_OK ; } | <S2SV_ModStart> DDCB_ERR_INVAL ; if ( ddcb_gather_statistics ( ) <S2SV_ModEnd> ) { rc |
1,384 | CWE-000 static void mtk_drm_kms_deinit ( struct drm_device * drm ) <S2SV_StartBug> { <S2SV_EndBug> drm_kms_helper_poll_fini ( drm ) ; component_unbind_all ( drm -> dev , drm ) ; drm_mode_config_cleanup ( drm ) ; } | <S2SV_ModStart> drm ) { mtk_fbdev_fini ( drm ) ; |
1,385 | CWE-000 static void include_source_if_needed ( docgen_t * docgen , source_t * source , const char * package_name ) { pony_assert ( source != NULL ) ; pony_assert ( docgen != NULL ) ; const char * source_path = source -> file ; pony_assert ( source_path != NULL ) ; bool was_included = false ; for ( size_t i = 0 ; i < docgen -> included_sources_count ; i ++ ) { pony_assert ( docgen -> included_sources [ i ] != NULL ) ; if ( strcmp ( source_path , docgen -> included_sources [ i ] -> source -> file ) == 0 ) was_included = true ; } if ( ! was_included ) { doc_sources_t * new_elem = copy_source_to_doc_src ( docgen , source , package_name ) ; if ( new_elem != NULL ) { doc_sources_t * * resized_array = ( doc_sources_t * * ) calloc ( sizeof ( doc_sources_t * ) , ( docgen -> included_sources_count + 1 ) ) ; <S2SV_StartBug> for ( size_t i = 0 ; i < docgen -> included_sources_count ; i = i ++ ) { <S2SV_EndBug> pony_assert ( docgen -> included_sources [ i ] != NULL ) ; resized_array [ i ] = docgen -> included_sources [ i ] ; } docgen -> included_sources = resized_array ; docgen -> included_sources [ docgen -> included_sources_count ] = new_elem ; docgen -> included_sources_count = docgen -> included_sources_count + 1 ; } } } | <S2SV_ModStart> included_sources_count ; i <S2SV_ModEnd> ++ ) { |
1,386 | CWE-000 char * flag_wchar ( t_format * fmt , va_list valist ) { wchar_t c ; char * newstr ; c = va_arg ( valist , wchar_t ) ; newstr = conv_utf8_char ( c , 0 ) ; <S2SV_StartBug> return ( newstr ) ; <S2SV_EndBug> } | <S2SV_ModStart> 0 ) ; fmt -> width = ft_strlen ( newstr ) ; |
1,387 | CWE-000 static void mpi_message_pack ( mpi_message_t * msg , void * data , ssize_t send_offset , exchanger_map_t * send_map , exchanger_map_t * receive_map ) { ASSERT ( send_map -> size >= 0 ) ; ASSERT ( receive_map -> size >= 0 ) ; int num_sends = send_map -> size ; int num_receives = receive_map -> size ; msg -> num_sends = num_sends ; msg -> dest_procs = polymec_malloc ( sizeof ( int ) * msg -> num_sends ) ; msg -> send_buffer_sizes = polymec_malloc ( sizeof ( int ) * msg -> num_sends ) ; msg -> send_buffers = polymec_malloc ( sizeof ( void * ) * msg -> num_sends ) ; msg -> num_receives = num_receives ; msg -> source_procs = polymec_malloc ( sizeof ( int ) * msg -> num_receives ) ; msg -> receive_buffer_sizes = polymec_malloc ( sizeof ( int ) * msg -> num_receives ) ; msg -> receive_buffers = polymec_malloc ( sizeof ( void * ) * msg -> num_receives ) ; int pos = 0 , proc , i = 0 ; exchanger_channel_t * c ; while ( exchanger_map_next ( send_map , & pos , & proc , & c ) ) { int num_send_indices = c -> num_indices ; int * send_indices = c -> indices ; int stride = msg -> stride ; msg -> dest_procs [ i ] = proc ; msg -> send_buffer_sizes [ i ] = num_send_indices ; msg -> send_buffers [ i ] = polymec_malloc ( num_send_indices * msg -> data_size * stride ) ; PACK ( msg , MPI_DOUBLE , double ) else PACK ( msg , MPI_FLOAT , float ) else PACK ( msg , MPI_INT , int ) else PACK ( msg , MPI_LONG , long ) else PACK ( msg , MPI_LONG_LONG , long long ) else PACK ( msg , MPI_UINT64_T , uint64_t ) else PACK ( msg , MPI_INT64_T , int64_t ) else PACK ( msg , MPI_CHAR , char ) else PACK ( msg , MPI_BYTE , uint8_t ) <S2SV_StartBug> else PACK ( msg , MPI_COMPLEX_T , complex_t ) <S2SV_EndBug> else polymec_error ( "mpi_message_pack:<S2SV_blank>unsupported<S2SV_blank>type!" ) ; ++ i ; } pos = 0 ; i = 0 ; while ( exchanger_map_next ( receive_map , & pos , & proc , & c ) ) { msg -> receive_buffer_sizes [ i ] = c -> num_indices ; msg -> receive_buffers [ i ] = polymec_malloc ( c -> num_indices * msg -> data_size * msg -> stride ) ; msg -> source_procs [ i ] = proc ; ++ i ; } msg -> requests = polymec_malloc ( ( num_sends + num_receives ) * sizeof ( MPI_Request ) ) ; } | <S2SV_ModStart> ( msg , MPI_C_DOUBLE_COMPLEX , double complex ) else PACK ( msg , MPI_C_FLOAT_COMPLEX , float complex <S2SV_ModEnd> ) else polymec_error |
1,388 | CWE-000 int resenddata ( ) { int backup_len = 0 ; int i = 0 ; uint8_t * postdata = NULL ; int len ; uint32_t first_time = 0 ; <S2SV_StartBug> int ret = 0 ; <S2SV_EndBug> backup_len = im_redis_get_backup_len ( ) ; imlogV ( "resenddata<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>\\n" , backup_len ) ; if ( backup_len > 0 ) { for ( i = 0 ; i < backup_len ; i ++ ) { char name [ CONFIG_FILENAME_LEN ] = { 0x0 } ; char file [ CONFIG_FILEPATH_LEN ] = { 0x0 } ; len = 0 ; if ( im_redis_get_list_head ( name ) < 0 ) { imlogE ( "im_redis_get_list_head<S2SV_blank>Error." ) ; break ; } sprintf ( file , "%s/%s.bak" , SAVE_DIRPATH , name ) ; imlogV ( "resenddata<S2SV_blank>backup<S2SV_blank>file:%s<S2SV_blank>\\n" , file ) ; postdata = GenerateBackupWaveform ( file , & len , & first_time ) ; if ( postdata != NULL ) { imlogV ( "resenddata<S2SV_blank>post<S2SV_blank>len<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>\\n" , len ) ; imlogV ( "resenddata<S2SV_blank>post<S2SV_blank>first_time<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>\\n" , first_time ) ; imlogV ( "resenddata<S2SV_blank>postdata<S2SV_blank>=<S2SV_blank>%x<S2SV_blank>\\n" , postdata [ 0 ] ) ; <S2SV_StartBug> ret = ImCloudData ( postdata , first_time , len , HTTP_RETRY_MAX ) ; <S2SV_EndBug> if ( ret == STATUS_OK ) { im_delfile ( file ) ; <S2SV_StartBug> im_redis_pop_head ( ) ; <S2SV_EndBug> imlogE ( "ImCloud<S2SV_blank>RESend<S2SV_blank>Backup<S2SV_blank>OK.\\n" ) ; } else { if ( ret == INVALID_KEY ) { key_status = KEY_INVALID ; imcloud_status = IMCOULD_ACTIVATE ; free ( postdata ) ; break ; } else { free ( postdata ) ; break ; } imlogE ( "ImCloud<S2SV_blank>RESend<S2SV_blank>Backup<S2SV_blank>Error.\\n" ) ; } free ( postdata ) ; } else { im_delfile ( file ) ; <S2SV_StartBug> im_redis_pop_head ( ) ; <S2SV_EndBug> imlogE ( "ImCloud<S2SV_blank>backup<S2SV_blank>File<S2SV_blank>Error.\\n" ) ; } } } <S2SV_StartBug> return ret ; <S2SV_EndBug> } | <S2SV_ModStart> ret = 0 ; if ( resend_status == RESEND_RESEND ) { imlogV ( "resenddata<S2SV_blank>busy." ) ; return ret ; } resend_status = RESEND_RESEND <S2SV_ModStart> , len , HTTP_RETRY_NONE <S2SV_ModEnd> ) ; if <S2SV_ModStart> ; im_redis_pop_head ( name <S2SV_ModStart> ; im_redis_pop_head ( name <S2SV_ModStart> } } } resend_status = RESEND_IDLE ; |
1,389 | CWE-000 static bool setup_stack ( void * * esp , struct process * p ) { uint8_t * kpage ; bool success = false ; <S2SV_StartBug> kpage = get_frame ( FRAME_ZERO , ( uint8_t * ) PHYS_BASE ) - PGSIZE ) ; <S2SV_EndBug> if ( kpage != NULL ) { <S2SV_StartBug> uint8_t * upage = ( uint8_t * ) PHYS_BASE ) - PGSIZE <S2SV_EndBug> success = install_page ( upage , kpage , true ) ; if ( success ) { struct thread * t = thread_current ( ) ; struct s_page_entry * spage = init_stack_entry ( upage , kpage ) ; <S2SV_StartBug> hash_insert ( t -> s_page_table , spage -> hash_elem ) ; <S2SV_EndBug> char * stack = ( char * ) ROUND_DOWN ( ( int ) kpage + PGSIZE , sizeof ( char * ) ) ; char * stack_bottom = ( char * ) ( kpage + PGSIZE ) ; int argc = list_size ( & p -> args ) ; int i = 0 ; void * * arg_pointers = malloc ( sizeof ( void * ) * argc ) ; struct list_elem * e ; for ( e = list_begin ( & p -> args ) ; e != list_end ( & p -> args ) ; e = list_next ( e ) ) { struct arg * a = list_entry ( e , struct arg , elem ) ; size_t arg_size = strlen ( a -> value ) + 1 ; stack -= arg_size ; strlcpy ( stack , a -> value , arg_size ) ; arg_pointers [ i ] = PHYS_BASE - ( stack_bottom - stack ) ; i ++ ; } stack = ( char * ) ROUND_DOWN ( ( int ) stack , sizeof ( char * ) ) ; stack -= sizeof ( void * ) ; memset ( stack , 0 , sizeof ( void * ) ) ; for ( int i = 0 ; i < argc ; i ++ ) { stack -= sizeof ( char * ) ; memcpy ( stack , & arg_pointers [ i ] , sizeof ( char * ) ) ; } char * * argv_start = PHYS_BASE - ( stack_bottom - stack ) ; stack -= sizeof ( char * * ) ; memcpy ( stack , & argv_start , sizeof ( char * * ) ) ; stack -= sizeof ( int ) ; memcpy ( stack , & argc , sizeof ( int ) ) ; stack -= sizeof ( void * ) ; memset ( stack , 0 , sizeof ( void * ) ) ; * esp = PHYS_BASE - ( stack_bottom - stack ) ; } else free_frame ( kpage ) ; } return success ; } | <S2SV_ModStart> FRAME_ZERO , ( ( <S2SV_ModStart> upage = ( ( <S2SV_ModStart> ) - PGSIZE ; <S2SV_ModStart> -> s_page_table , & |
1,390 | CWE-000 void recieveMessage ( char * text ) { int len = my_strlen ( text ) ; char * p ; int paginate = 1 ; int moveBy = SEGMENT_SIZE - 1 ; PROMPT_DISPLAY ( text ) ; for ( p = text + len - moveBy ; p >= text ; p -= moveBy ) { pushMessage ( newMessageSegment ( paginate , p ) ) ; paginate = 0 ; <S2SV_StartBug> } <S2SV_EndBug> len = moveBy - ( text - p ) ; <S2SV_StartBug> if ( len != 0 ) <S2SV_EndBug> <S2SV_StartBug> pushMessage ( newMessageSegment2 ( paginate , text , len ) ) ; <S2SV_EndBug> if ( * display_tail == NULL ) * display_tail = last_node ( * display_queue ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> = 0 ; ++ display_queue_len ; <S2SV_ModStart> != 0 ) { <S2SV_ModStart> ) ) ; ++ display_queue_len ; } <S2SV_ModStart> display_queue ) ; while ( display_queue_len > NUM_SAVED_SEGMENTS ) { remove_node ( display_tail ) ; -- display_queue_len ; } |
1,391 | CWE-000 GSM_SMSDConfig * SMSD_NewConfig ( const char * name ) { GSM_SMSDConfig * Config ; <S2SV_StartBug> Config = ( GSM_SMSDConfig * ) malloc ( sizeof ( GSM_SMSDConfig ) ) ; <S2SV_EndBug> if ( Config == NULL ) return Config ; Config -> running = FALSE ; Config -> failure = ERR_NONE ; Config -> exit_on_failure = TRUE ; Config -> shutdown = FALSE ; Config -> gsm = NULL ; Config -> gammu_log_buffer = NULL ; Config -> gammu_log_buffer_size = 0 ; Config -> logfilename = NULL ; Config -> RunOnFailure = NULL ; Config -> RunOnSent = NULL ; Config -> RunOnReceive = NULL ; Config -> smsdcfgfile = NULL ; Config -> log_handle = NULL ; Config -> log_type = SMSD_LOG_NONE ; Config -> debug_level = 0 ; Config -> ServiceName = NULL ; Config -> Service = NULL ; Config -> IgnoredMessages = 0 ; Config -> PhoneID = NULL ; # if defined ( HAVE_MYSQL_MYSQL_H ) Config -> conn . my = NULL ; # endif # if defined ( LIBDBI_FOUND ) Config -> conn . dbi = NULL ; # endif # if defined ( HAVE_POSTGRESQL_LIBPQ_FE_H ) Config -> conn . pg = NULL ; # endif <S2SV_StartBug> GSM_StringArray_New ( & ( Config -> IncludeNumbersList ) ) ; <S2SV_EndBug> GSM_StringArray_New ( & ( Config -> ExcludeNumbersList ) ) ; GSM_StringArray_New ( & ( Config -> IncludeSMSCList ) ) ; GSM_StringArray_New ( & ( Config -> ExcludeSMSCList ) ) ; if ( name == NULL ) { Config -> program_name = smsd_name ; } else { Config -> program_name = name ; } return Config ; } | <S2SV_ModStart> * Config ; int i ; <S2SV_ModStart> ; # endif for ( i = 0 ; i < GSM_MAX_MULTI_SMS ; i ++ ) { Config -> SkipMessage [ i ] = FALSE ; } |
1,392 | CWE-000 int AdventurerCard ( int currentPlayer , struct gameState * state , int drawntreasure , int temphand [ ] , int cardDrawn , int z ) { <S2SV_StartBug> while ( drawntreasure < 5 ) { <S2SV_EndBug> if ( state -> deckCount [ currentPlayer ] < 1 ) { shuffle ( currentPlayer , state ) ; } drawCard ( currentPlayer , state ) ; cardDrawn = state -> hand [ currentPlayer ] [ state -> handCount [ currentPlayer ] - 1 ] ; if ( cardDrawn == copper || cardDrawn == silver || cardDrawn == gold ) drawntreasure ++ ; else { temphand [ z ] = cardDrawn ; state -> handCount [ currentPlayer ] -- ; z ++ ; } } while ( z - 1 >= 0 ) { state -> discard [ currentPlayer ] [ state -> discardCount [ currentPlayer ] ++ ] = temphand [ z - 1 ] ; z = z - 1 ; } return 0 ; } | <S2SV_ModStart> ( drawntreasure < 2 <S2SV_ModEnd> ) { if |
1,393 | CWE-000 bool init_dbus ( struct mako_state * state ) { int ret = 0 ; state -> bus = NULL ; state -> xdg_slot = state -> mako_slot = NULL ; ret = sd_bus_open_user ( & state -> bus ) ; if ( ret < 0 ) { <S2SV_StartBug> fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>connect<S2SV_blank>to<S2SV_blank>system<S2SV_blank>bus:<S2SV_blank>%s\\n" , strerror ( - ret ) ) ; <S2SV_EndBug> goto error ; } ret = init_dbus_xdg ( state ) ; if ( ret < 0 ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>XDG<S2SV_blank>interface:<S2SV_blank>%s\\n" , strerror ( - ret ) ) ; goto error ; } ret = init_dbus_mako ( state ) ; if ( ret < 0 ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>Mako<S2SV_blank>interface:<S2SV_blank>%s\\n" , strerror ( - ret ) ) ; goto error ; } ret = sd_bus_request_name ( state -> bus , service_name , 0 ) ; if ( ret < 0 ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>acquire<S2SV_blank>service<S2SV_blank>name:<S2SV_blank>%s\\n" , strerror ( - ret ) ) ; goto error ; } return true ; error : finish_dbus ( state ) ; return false ; } | <S2SV_ModStart> ( stderr , "Failed<S2SV_blank>to<S2SV_blank>connect<S2SV_blank>to<S2SV_blank>user<S2SV_blank>bus:<S2SV_blank>%s\\n" <S2SV_ModEnd> , strerror ( |
1,394 | CWE-000 static int spi_nor_init_params ( struct spi_nor * nor , struct spi_nor_flash_parameter * params ) { struct spi_nor_erase_map * map = & nor -> erase_map ; const struct flash_info * info = nor -> info ; u8 i , erase_mask ; memset ( params , 0 , sizeof ( * params ) ) ; params -> size = info -> sector_size * info -> n_sectors ; params -> page_size = info -> page_size ; params -> hwcaps . mask |= SNOR_HWCAPS_READ ; spi_nor_set_read_settings ( & params -> reads [ SNOR_CMD_READ ] , 0 , 0 , SPINOR_OP_READ , SNOR_PROTO_1_1_1 ) ; if ( ! ( info -> flags & SPI_NOR_NO_FR ) ) { params -> hwcaps . mask |= SNOR_HWCAPS_READ_FAST ; spi_nor_set_read_settings ( & params -> reads [ SNOR_CMD_READ_FAST ] , 0 , 8 , SPINOR_OP_READ_FAST , SNOR_PROTO_1_1_1 ) ; } if ( info -> flags & SPI_NOR_DUAL_READ ) { params -> hwcaps . mask |= SNOR_HWCAPS_READ_1_1_2 ; spi_nor_set_read_settings ( & params -> reads [ SNOR_CMD_READ_1_1_2 ] , 0 , 8 , SPINOR_OP_READ_1_1_2 , SNOR_PROTO_1_1_2 ) ; } if ( info -> flags & SPI_NOR_QUAD_READ ) { params -> hwcaps . mask |= SNOR_HWCAPS_READ_1_1_4 ; spi_nor_set_read_settings ( & params -> reads [ SNOR_CMD_READ_1_1_4 ] , 0 , 8 , SPINOR_OP_READ_1_1_4 , SNOR_PROTO_1_1_4 ) ; } params -> hwcaps . mask |= SNOR_HWCAPS_PP ; spi_nor_set_pp_settings ( & params -> page_programs [ SNOR_CMD_PP ] , SPINOR_OP_PP , SNOR_PROTO_1_1_1 ) ; erase_mask = 0 ; i = 0 ; if ( info -> flags & SECT_4K_PMC ) { erase_mask |= BIT ( i ) ; spi_nor_set_erase_type ( & map -> erase_type [ i ] , 4096u , SPINOR_OP_BE_4K_PMC ) ; i ++ ; } else if ( info -> flags & SECT_4K ) { erase_mask |= BIT ( i ) ; spi_nor_set_erase_type ( & map -> erase_type [ i ] , 4096u , SPINOR_OP_BE_4K ) ; i ++ ; } erase_mask |= BIT ( i ) ; spi_nor_set_erase_type ( & map -> erase_type [ i ] , info -> sector_size , SPINOR_OP_SE ) ; spi_nor_init_uniform_erase_map ( map , erase_mask , params -> size ) ; <S2SV_StartBug> if ( params -> hwcaps . mask & ( SNOR_HWCAPS_READ_QUAD | <S2SV_EndBug> SNOR_HWCAPS_PP_QUAD ) ) { switch ( JEDEC_MFR ( info ) ) { case SNOR_MFR_MACRONIX : params -> quad_enable = macronix_quad_enable ; break ; case SNOR_MFR_ST : case SNOR_MFR_MICRON : break ; default : params -> quad_enable = spansion_quad_enable ; break ; } } if ( ( info -> flags & ( SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ ) ) && ! ( info -> flags & SPI_NOR_SKIP_SFDP ) ) { struct spi_nor_flash_parameter sfdp_params ; struct spi_nor_erase_map prev_map ; memcpy ( & sfdp_params , params , sizeof ( sfdp_params ) ) ; memcpy ( & prev_map , & nor -> erase_map , sizeof ( prev_map ) ) ; if ( spi_nor_parse_sfdp ( nor , & sfdp_params ) ) { nor -> addr_width = 0 ; nor -> flags &= ~ SNOR_F_4B_OPCODES ; memcpy ( & nor -> erase_map , & prev_map , sizeof ( nor -> erase_map ) ) ; } else { memcpy ( params , & sfdp_params , sizeof ( * params ) ) ; } } return 0 ; } | <S2SV_ModStart> ; if ( <S2SV_ModEnd> ( info -> |
1,395 | CWE-000 static Eina_Bool <S2SV_StartBug> _dispatch ( Client * src , void * buffer , int size ) <S2SV_EndBug> { Eina_Debug_Packet_Header * hdr = ( Eina_Debug_Packet_Header * ) buffer ; if ( hdr -> cid ) { Client * dest = _client_find_by_cid ( hdr -> cid ) ; if ( dest ) { if ( dest -> is_master != src -> is_master ) { hdr -> cid = src -> cid ; <S2SV_StartBug> send ( dest -> fd , buffer , size , 0 ) ; <S2SV_EndBug> } else { printf ( "Packet<S2SV_blank>from<S2SV_blank>%d<S2SV_blank>to<S2SV_blank>%d:<S2SV_blank>denied<S2SV_blank>(same<S2SV_blank>type)\\n" , hdr -> cid , dest -> cid ) ; } } } else { printf ( "Invoke<S2SV_blank>%s\\n" , _opcodes [ hdr -> opcode ] -> opcode_string ) ; if ( _opcodes [ hdr -> opcode ] -> cb ) return _opcodes [ hdr -> opcode ] -> cb ( src , ( char * ) buffer + sizeof ( Eina_Debug_Packet_Header ) , size - sizeof ( Eina_Debug_Packet_Header ) ) ; } return EINA_TRUE ; } | <S2SV_ModStart> * buffer , unsigned <S2SV_ModStart> -> cid ; if ( <S2SV_ModStart> size , 0 ) != size ) perror ( "send" |
1,396 | CWE-000 void calculateCenterBound ( TransInfo * t , float r_center [ 3 ] ) { <S2SV_StartBug> float max [ 3 ] ; <S2SV_EndBug> float min [ 3 ] ; int i ; bool is_first = true ; FOREACH_TRANS_DATA_CONTAINER ( t , tc ) { <S2SV_StartBug> for ( i = 0 ; i < tc -> data_len ; i ++ ) { <S2SV_EndBug> if ( is_first == false ) { if ( tc -> data [ i ] . flag & TD_SELECTED ) { if ( ! ( tc -> data [ i ] . flag & TD_NOCENTER ) ) { if ( tc -> use_local_mat ) { float v [ 3 ] ; mul_v3_m4v3 ( v , tc -> mat , tc -> data [ i ] . center ) ; minmax_v3v3_v3 ( min , max , v ) ; } else { minmax_v3v3_v3 ( min , max , tc -> data [ i ] . center ) ; } <S2SV_StartBug> } <S2SV_EndBug> } } else { copy_v3_v3 ( max , tc -> data [ i ] . center ) ; copy_v3_v3 ( min , tc -> data [ i ] . center ) ; is_first = false ; } } } mid_v3_v3v3 ( r_center , min , max ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> [ 3 ] , min [ 3 ] ; bool changed = false ; INIT_MINMAX ( min , max ) ; FOREACH_TRANS_DATA_CONTAINER ( t , tc ) { for ( int <S2SV_ModEnd> i = 0 <S2SV_ModStart> ; i ++ <S2SV_ModEnd> ) { if <S2SV_ModStart> ) ; } changed = true ; } } } } if ( changed ) { <S2SV_ModEnd> mid_v3_v3v3 ( r_center <S2SV_ModStart> ) ; } } |
1,397 | CWE-000 static long snd_timer_user_ioctl_compat ( struct file * file , unsigned int cmd , unsigned long arg ) { void __user * argp = compat_ptr ( arg ) ; switch ( cmd ) { case SNDRV_TIMER_IOCTL_PVERSION : case SNDRV_TIMER_IOCTL_TREAD : case SNDRV_TIMER_IOCTL_GINFO : case SNDRV_TIMER_IOCTL_GPARAMS : case SNDRV_TIMER_IOCTL_GSTATUS : case SNDRV_TIMER_IOCTL_SELECT : case SNDRV_TIMER_IOCTL_PARAMS : case SNDRV_TIMER_IOCTL_START : case SNDRV_TIMER_IOCTL_START_OLD : case SNDRV_TIMER_IOCTL_STOP : case SNDRV_TIMER_IOCTL_STOP_OLD : case SNDRV_TIMER_IOCTL_CONTINUE : case SNDRV_TIMER_IOCTL_CONTINUE_OLD : case SNDRV_TIMER_IOCTL_PAUSE : case SNDRV_TIMER_IOCTL_PAUSE_OLD : case SNDRV_TIMER_IOCTL_NEXT_DEVICE : return snd_timer_user_ioctl ( file , cmd , ( unsigned long ) argp ) ; case SNDRV_TIMER_IOCTL_INFO32 : return snd_timer_user_info_compat ( file , argp ) ; case SNDRV_TIMER_IOCTL_STATUS32 : return snd_timer_user_status_compat ( file , argp ) ; <S2SV_StartBug> } <S2SV_EndBug> return - ENOIOCTLCMD ; } | <S2SV_ModStart> argp ) ; # ifdef CONFIG_X86_X32 case SNDRV_TIMER_IOCTL_STATUS_X32 : return snd_timer_user_status_x32 ( file , argp ) ; # endif |
1,398 | CWE-000 static ssize_t store_protocols ( struct device * device , struct device_attribute * mattr , const char * buf , size_t len ) { struct rc_dev * dev = to_rc_dev ( device ) ; u64 * current_protocols ; struct rc_scancode_filter * filter ; u64 old_protocols , new_protocols ; ssize_t rc ; <S2SV_StartBug> if ( ! dev ) <S2SV_EndBug> return - EINVAL ; <S2SV_StartBug> if ( ! atomic_read ( & dev -> initialized ) ) <S2SV_EndBug> return - ERESTARTSYS ; IR_dprintk ( 1 , "Normal<S2SV_blank>protocol<S2SV_blank>change<S2SV_blank>requested\\n" ) ; current_protocols = & dev -> enabled_protocols ; filter = & dev -> scancode_filter ; if ( ! dev -> change_protocol ) { IR_dprintk ( 1 , "Protocol<S2SV_blank>switching<S2SV_blank>not<S2SV_blank>supported\\n" ) ; return - EINVAL ; } mutex_lock ( & dev -> lock ) ; old_protocols = * current_protocols ; new_protocols = old_protocols ; rc = parse_protocol_change ( & new_protocols , buf ) ; if ( rc < 0 ) goto out ; rc = dev -> change_protocol ( dev , & new_protocols ) ; if ( rc < 0 ) { IR_dprintk ( 1 , "Error<S2SV_blank>setting<S2SV_blank>protocols<S2SV_blank>to<S2SV_blank>0x%llx\\n" , ( long long ) new_protocols ) ; goto out ; } if ( dev -> driver_type == RC_DRIVER_IR_RAW ) ir_raw_load_modules ( & new_protocols ) ; if ( new_protocols != old_protocols ) { * current_protocols = new_protocols ; IR_dprintk ( 1 , "Protocols<S2SV_blank>changed<S2SV_blank>to<S2SV_blank>0x%llx\\n" , ( long long ) new_protocols ) ; } if ( dev -> s_filter && filter -> mask ) { if ( new_protocols ) rc = dev -> s_filter ( dev , filter ) ; else rc = - 1 ; if ( rc < 0 ) { filter -> data = 0 ; filter -> mask = 0 ; dev -> s_filter ( dev , filter ) ; } } rc = len ; out : mutex_unlock ( & dev -> lock ) ; return rc ; } | <S2SV_ModStart> ssize_t rc ; IR_dprintk ( 1 , "Normal<S2SV_blank>protocol<S2SV_blank>change<S2SV_blank>requested\\n" ) ; current_protocols = & dev -> enabled_protocols ; filter = & dev -> scancode_filter ; <S2SV_ModStart> ( ! dev -> change_protocol ) { IR_dprintk ( 1 , "Protocol<S2SV_blank>switching<S2SV_blank>not<S2SV_blank>supported\\n" ) ; <S2SV_ModEnd> return - EINVAL <S2SV_ModStart> - EINVAL ; <S2SV_ModEnd> } mutex_lock ( |
1,399 | CWE-000 inline constr nTrans_GetConnUrls ( nTrans trans ) { is0_ret ( trans , NULL ) ; trans -> conn . s = natsConnection_GetConnectedUrl ( trans -> conn . nc , trans -> conn . conn_urls , 512 ) ; <S2SV_StartBug> is1_ret ( trans -> conn . s == NATS_OK , trans -> conn . conn_urls ) ; <S2SV_EndBug> return NULL ; } | <S2SV_ModStart> 512 ) ; is1_exeret <S2SV_ModEnd> ( trans -> <S2SV_ModStart> s == NATS_OK , trans -> conn . urls = 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.