Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
2,700 | CWE-000 void iotjs_set_process_exitcode ( int code ) { const jerry_value_t process = iotjs_module_get ( "process" ) ; jerry_value_t jstring = jerry_create_string ( ( jerry_char_t * ) IOTJS_MAGIC_STRING_EXITCODE ) ; jerry_value_t jcode = jerry_create_number ( code ) ; <S2SV_StartBug> jerry_release_value ( jerry_set_property ( process , jstring , jcode ) ) ; <S2SV_EndBug> jerry_release_value ( jstring ) ; jerry_release_value ( jcode ) ; } | <S2SV_ModStart> code ) ; jerry_value_t ret_val = <S2SV_ModEnd> jerry_set_property ( process <S2SV_ModStart> , jcode ) ; if ( jerry_value_is_error ( ret_val ) ) { iotjs_environment_get ( ) -> exitcode = 1 ; } jerry_release_value ( ret_val |
2,701 | CWE-000 static int sys_open ( const char * ufile ) { char * kfile = copy_in_string ( ufile ) ; struct file_descriptor * fd ; int handle = - 1 ; <S2SV_StartBug> fd = malloc ( sizeof * fd ) ; <S2SV_EndBug> if ( fd != NULL ) { lock_acquire ( & fs_lock ) ; fd -> file = filesys_open ( kfile ) ; if ( fd -> file != NULL ) } } | <S2SV_ModStart> malloc ( sizeof <S2SV_ModEnd> fd ) ; |
2,702 | CWE-000 <S2SV_StartBug> TEST ( buffer_dupe_string_outside ) { <S2SV_EndBug> CeBuffer_t buffer = { } ; ce_buffer_load_string ( & buffer , g_multiline_string_with_empty_line , g_name ) ; <S2SV_StartBug> char * dupe = ce_buffer_dupe_string ( & buffer , ( CePoint_t ) { 5 , 5 } , 10 ) ; <S2SV_EndBug> <S2SV_StartBug> EXPECT ( dupe == NULL ) ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> TEST ( buffer_dupe_string_entire_buffer_plus_newline <S2SV_ModEnd> ) { CeBuffer_t <S2SV_ModStart> CePoint_t ) { 0 , 0 } , 34 <S2SV_ModEnd> ) ; EXPECT <S2SV_ModStart> ; EXPECT ( strcmp ( dupe , "0123456789\\n\\nabcdefghij\\nklmnopqrst\\n" ) == 0 <S2SV_ModEnd> ) ; } |
2,703 | CWE-000 <S2SV_StartBug> int sqlite3VdbeReset ( Vdbe * p ) { <S2SV_EndBug> sqlite3 * db ; db = p -> db ; sqlite3VdbeHalt ( p ) ; if ( p -> pc >= 0 ) { vdbeInvokeSqllog ( p ) ; sqlite3VdbeTransferError ( p ) ; if ( p -> runOnlyOnce ) p -> expired = 1 ; } else if ( p -> rc && p -> expired ) { sqlite3ErrorWithMsg ( db , p -> rc , p -> zErrMsg ? "%s" : 0 , p -> zErrMsg ) ; } # ifdef SQLITE_DEBUG <S2SV_StartBug> int i ; <S2SV_EndBug> if ( p -> apCsr ) for ( i = 0 ; i < p -> nCursor ; i ++ ) assert ( p -> apCsr [ i ] == 0 ) ; if ( p -> aMem ) { for ( i = 0 ; i < p -> nMem ; i ++ ) assert ( p -> aMem [ i ] . flags == MEM_Undefined ) ; } # endif sqlite3DbFree ( db , p -> zErrMsg ) ; p -> zErrMsg = 0 ; p -> pResultSet = 0 ; # ifdef VDBE_PROFILE { FILE * out = fopen ( "vdbe_profile.out" , "a" ) ; if ( out ) { int i ; fprintf ( out , "----<S2SV_blank>" ) ; for ( i = 0 ; i < p -> nOp ; i ++ ) { fprintf ( out , "%02x" , p -> aOp [ i ] . opcode ) ; } fprintf ( out , "\\n" ) ; if ( p -> zSql ) { char c , pc = 0 ; fprintf ( out , "--<S2SV_blank>" ) ; for ( i = 0 ; ( c = p -> zSql [ i ] ) != 0 ; i ++ ) { if ( pc == '\\n' ) fprintf ( out , "--<S2SV_blank>" ) ; putc ( c , out ) ; pc = c ; } if ( pc != '\\n' ) fprintf ( out , "\\n" ) ; } for ( i = 0 ; i < p -> nOp ; i ++ ) { char zHdr [ 100 ] ; sqlite3_snprintf ( sizeof ( zHdr ) , zHdr , "%6u<S2SV_blank>%12llu<S2SV_blank>%8llu<S2SV_blank>" , p -> aOp [ i ] . cnt , p -> aOp [ i ] . cycles , p -> aOp [ i ] . cnt > 0 ? p -> aOp [ i ] . cycles / p -> aOp [ i ] . cnt : 0 ) ; fprintf ( out , "%s" , zHdr ) ; sqlite3VdbePrintOp ( out , i , & p -> aOp [ i ] ) ; } fclose ( out ) ; } } # endif p -> magic = VDBE_MAGIC_RESET ; return p -> rc & db -> errMask ; } | <S2SV_ModStart> p ) { # ifdef SQLITE_DEBUG int i ; # endif <S2SV_ModStart> # ifdef SQLITE_DEBUG <S2SV_ModEnd> if ( p |
2,704 | CWE-000 <S2SV_StartBug> int compareOrder ( struct climate_info * * states , char codex [ 3 ] , int currentStates ) <S2SV_EndBug> { int order = 0 ; while ( order < currentStates ) { if ( strcmp ( ( states [ order ] ) -> code , codex ) == 0 ) { return order ; } order ++ ; } return - 1 ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static |
2,705 | CWE-000 void init_fan_pwm ( uint8_t duty_cycle ) { <S2SV_StartBug> TCCR0B |= _BV ( CS00 ) ; <S2SV_EndBug> <S2SV_StartBug> TCCR0A |= _BV ( COM1B1 ) | _BV ( WGM00 ) ; <S2SV_EndBug> <S2SV_StartBug> TCCR0A &= ~ _BV ( COM0B1 ) ; <S2SV_EndBug> DDRC |= _BV ( PC1 ) ; OCR1B = ( uint8_t ) duty_cycle ; } | <S2SV_ModStart> duty_cycle ) { TCCR1B <S2SV_ModEnd> |= _BV ( <S2SV_ModStart> CS00 ) ; TCCR1B |= _BV ( WGM12 ) ; TCCR1A <S2SV_ModEnd> |= _BV ( <S2SV_ModStart> | _BV ( WGM10 ) ; TCCR1A <S2SV_ModEnd> &= ~ _BV <S2SV_ModStart> ~ _BV ( COM1B0 <S2SV_ModEnd> ) ; DDRC |
2,706 | CWE-000 void create_header ( FILE * of ) { fprintf ( of , "/*<S2SV_blank>Adventure<S2SV_blank>Writing<S2SV_blank>System,<S2SV_blank>generated<S2SV_blank>file<S2SV_blank>*/\\n\\n" ) ; fprintf ( of , "#include<stdio.h>\\n" ) ; fprintf ( of , "#include<stdlib.h>\\n" ) ; fprintf ( of , "#include\\"aws.h\\"\\n\\n" ) ; fprintf ( of , "#include\\"inout.h\\"\\n" ) ; <S2SV_StartBug> fprintf ( of , "#include\\"modern.h\\"\\n\\n" ) ; <S2SV_EndBug> fprintf ( of , "extern<S2SV_blank>int<S2SV_blank>verb;\\nextern<S2SV_blank>int<S2SV_blank>noun1;\\nextern<S2SV_blank>int<S2SV_blank>noun2;\\n" "extern<S2SV_blank>int<S2SV_blank>adve;\\n" ) ; fprintf ( of , "int<S2SV_blank>dummy;\\n" ) ; fprintf ( of , "\\n" ) ; } | <S2SV_ModStart> ( of , "#include\\"systemdef.h\\"\\n\\n" <S2SV_ModEnd> ) ; fprintf |
2,707 | CWE-000 static void p2p_search ( struct p2p_data * p2p ) { int freq = 0 ; enum p2p_scan_type type ; u16 pw_id = DEV_PW_DEFAULT ; int res ; if ( p2p -> drv_in_listen ) { p2p_dbg ( p2p , "Driver<S2SV_blank>is<S2SV_blank>still<S2SV_blank>in<S2SV_blank>Listen<S2SV_blank>state<S2SV_blank>-<S2SV_blank>wait<S2SV_blank>for<S2SV_blank>it<S2SV_blank>to<S2SV_blank>end<S2SV_blank>before<S2SV_blank>continuing" ) ; return ; } p2p -> cfg -> stop_listen ( p2p -> cfg -> cb_ctx ) ; <S2SV_StartBug> if ( ( p2p -> find_type == P2P_FIND_PROGRESSIVE && <S2SV_EndBug> ( freq = p2p_get_next_prog_freq ( p2p ) ) > 0 ) || ( p2p -> find_type == P2P_FIND_START_WITH_FULL && ( freq = p2p -> find_specified_freq ) > 0 ) ) { type = P2P_SCAN_SOCIAL_PLUS_ONE ; p2p_dbg ( p2p , "Starting<S2SV_blank>search<S2SV_blank>(+<S2SV_blank>freq<S2SV_blank>%u)" , freq ) ; } else { type = P2P_SCAN_SOCIAL ; p2p_dbg ( p2p , "Starting<S2SV_blank>search" ) ; } res = p2p -> cfg -> p2p_scan ( p2p -> cfg -> cb_ctx , type , freq , p2p -> num_req_dev_types , p2p -> req_dev_types , p2p -> find_dev_id , pw_id ) ; if ( res < 0 ) { p2p_dbg ( p2p , "Scan<S2SV_blank>request<S2SV_blank>schedule<S2SV_blank>failed" ) ; p2p_continue_find ( p2p ) ; } } | <S2SV_ModStart> ; if ( p2p -> find_pending_full && ( p2p -> find_type == P2P_FIND_PROGRESSIVE || p2p -> find_type == P2P_FIND_START_WITH_FULL ) ) { type = P2P_SCAN_FULL ; p2p_dbg ( p2p , "Starting<S2SV_blank>search<S2SV_blank>(pending<S2SV_blank>full<S2SV_blank>scan)" ) ; p2p -> find_pending_full = 0 ; } else if ( |
2,708 | CWE-000 static void php_zip_object_free_storage ( zend_object * object ) { ze_zip_object * intern = php_zip_fetch_object ( object ) ; int i ; if ( ! intern ) { return ; } if ( intern -> za ) { if ( zip_close ( intern -> za ) != 0 ) { <S2SV_StartBug> php_error_docref ( NULL , E_WARNING , "Cannot<S2SV_blank>destroy<S2SV_blank>the<S2SV_blank>zip<S2SV_blank>context:<S2SV_blank>%s" , zip_strerror ( intern -> za ) ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> intern -> za = NULL ; } if ( intern -> buffers_cnt > 0 ) { for ( i = 0 ; i < intern -> buffers_cnt ; i ++ ) { efree ( intern -> buffers [ i ] ) ; } efree ( intern -> buffers ) ; } intern -> za = NULL ; zend_object_std_dtor ( & intern -> zo ) ; if ( intern -> filename ) { efree ( intern -> filename ) ; } } | <S2SV_ModStart> 0 ) { # if LIBZIP_VERSION_MAJOR == 1 && LIBZIP_VERSION_MINOR == 3 && LIBZIP_VERSION_MICRO == 1 <S2SV_ModStart> ) ) ; # else php_error_docref ( NULL , E_WARNING , "Cannot<S2SV_blank>destroy<S2SV_blank>the<S2SV_blank>zip<S2SV_blank>context:<S2SV_blank>%s" , zip_strerror ( intern -> za ) ) ; zip_discard ( intern -> za ) ; # endif } <S2SV_ModEnd> } if ( |
2,709 | CWE-000 static void vos_wd_detect_thread_stuck_cb ( void * priv ) { if ( ! ( vos_is_logp_in_progress ( VOS_MODULE_ID_SYS , NULL ) || vos_is_load_unload_in_progress ( VOS_MODULE_ID_SYS , NULL ) ) ) { <S2SV_StartBug> set_bit ( WD_WLAN_DETECT_THREAD_STUCK_MASK , <S2SV_EndBug> & gpVosWatchdogContext -> wdEventFlag ) ; <S2SV_StartBug> set_bit ( WD_POST_EVENT_MASK , & gpVosWatchdogContext -> wdEventFlag ) ; <S2SV_EndBug> wake_up_interruptible ( & gpVosWatchdogContext -> wdWaitQueue ) ; } } | <S2SV_ModStart> { set_bit ( WD_WLAN_DETECT_THREAD_STUCK <S2SV_ModEnd> , & gpVosWatchdogContext <S2SV_ModStart> ; set_bit ( WD_POST_EVENT <S2SV_ModEnd> , & gpVosWatchdogContext |
2,710 | CWE-000 static struct compunit_symtab * dw2_lookup_symbol ( struct objfile * objfile , int block_index , const char * name , domain_enum domain ) { struct compunit_symtab * stab_best = NULL ; struct dwarf2_per_objfile * dwarf2_per_objfile = get_dwarf2_per_objfile ( objfile ) ; lookup_name_info lookup_name ( name , symbol_name_match_type : : FULL ) ; struct dw2_symtab_iterator iter ; struct dwarf2_per_cu_data * per_cu ; dw2_symtab_iter_init ( & iter , dwarf2_per_objfile , 1 , block_index , domain , name ) ; while ( ( per_cu = dw2_symtab_iter_next ( & iter ) ) != NULL ) { struct symbol * sym , * with_opaque = NULL ; <S2SV_StartBug> struct compunit_symtab * stab = dw2_instantiate_symtab ( per_cu ) ; <S2SV_EndBug> const struct blockvector * bv = COMPUNIT_BLOCKVECTOR ( stab ) ; struct block * block = BLOCKVECTOR_BLOCK ( bv , block_index ) ; sym = block_find_symbol ( block , name , domain , block_find_non_opaque_type_preferred , & with_opaque ) ; if ( sym != NULL && SYMBOL_MATCHES_SEARCH_NAME ( sym , lookup_name ) ) return stab ; if ( with_opaque != NULL && SYMBOL_MATCHES_SEARCH_NAME ( with_opaque , lookup_name ) ) stab_best = stab ; } return stab_best ; } | <S2SV_ModStart> dw2_instantiate_symtab ( per_cu , false |
2,711 | CWE-000 int get_byte_kbinput ( int kbinput ) { <S2SV_StartBug> static int byte_digits = 0 , byte = 0 ; <S2SV_EndBug> int retval = ERR ; <S2SV_StartBug> byte_digits ++ ; <S2SV_EndBug> switch ( byte_digits ) { case 1 : if ( '0' <= kbinput && kbinput <= '2' ) byte = ( kbinput - '0' ) * 100 ; else retval = kbinput ; break ; case 2 : if ( ( '0' <= kbinput && kbinput <= '5' ) || ( byte < 200 && '6' <= kbinput && kbinput <= '9' ) ) byte += ( kbinput - '0' ) * 10 ; else retval = kbinput ; break ; case 3 : if ( ( '0' <= kbinput && kbinput <= '5' ) || ( byte < 250 && '6' <= kbinput && kbinput <= '9' ) ) { byte += kbinput - '0' ; retval = byte ; } else retval = kbinput ; break ; default : retval = kbinput ; break ; } if ( retval != ERR ) { byte_digits = 0 ; byte = 0 ; } # ifdef DEBUG fprintf ( stderr , "get_byte_kbinput():<S2SV_blank>kbinput<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>byte_digits<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>byte<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>retval<S2SV_blank>=<S2SV_blank>%d\\n" , kbinput , byte_digits , byte , retval ) ; # endif return retval ; } | <S2SV_ModStart> { static int byte = 0 <S2SV_ModEnd> ; int retval <S2SV_ModStart> = ERR ; switch ( ++ <S2SV_ModEnd> byte_digits ) { |
2,712 | CWE-000 <S2SV_StartBug> void ydb_hiber_start_wait_any ( unsigned long long sleep_nsec ) <S2SV_EndBug> { <S2SV_StartBug> int timeoutms ; <S2SV_EndBug> <S2SV_StartBug> unsigned long long timeout_msec ; <S2SV_EndBug> boolean_t error_encountered ; DCL_THREADGBL_ACCESS ; SETUP_THREADGBL_ACCESS ; if ( process_exiting ) { send_msg_csa ( CSA_ARG ( NULL ) VARLSTCNT ( 1 ) ERR_CALLINAFTERXIT ) ; <S2SV_StartBug> return ; <S2SV_EndBug> } ESTABLISH_NORET ( ydb_simpleapi_ch , error_encountered ) ; if ( error_encountered ) { REVERT ; <S2SV_StartBug> return ; <S2SV_EndBug> } if ( YDB_MAX_TIME_NSEC < sleep_nsec ) rts_error_csa ( CSA_ARG ( NULL ) VARLSTCNT ( 3 ) ERR_TIME2LONG , 1 , YDB_MAX_TIME_NSEC ) ; timeout_msec = ( sleep_nsec / NANOSECS_IN_MSEC ) ; <S2SV_StartBug> assert ( MAXPOSINT4 > timeout_msec ) ; <S2SV_EndBug> <S2SV_StartBug> timeoutms = ( int ) timeout_msec ; <S2SV_EndBug> <S2SV_StartBug> hiber_start_wait_any ( timeoutms ) ; <S2SV_EndBug> REVERT ; <S2SV_StartBug> return ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> int <S2SV_ModEnd> ydb_hiber_start_wait_any ( unsigned <S2SV_ModStart> ) { int sleepms <S2SV_ModEnd> ; unsigned long <S2SV_ModStart> unsigned long long sleep_msec , max_time_nsec <S2SV_ModEnd> ; boolean_t error_encountered <S2SV_ModStart> ) ; return YDB_OK <S2SV_ModStart> REVERT ; return - ( TREF ( ydb_error_code ) ) ; } ISSUE_TIME2LONG_ERROR_IF_NEEDED ( sleep_nsec ) ; assert ( MAXPOSINT4 >= ( sleep_nsec / NANOSECS_IN_MSEC ) ) ; sleep_msec <S2SV_ModEnd> = ( sleep_nsec <S2SV_ModStart> NANOSECS_IN_MSEC ) ; sleepms <S2SV_ModEnd> = ( int <S2SV_ModStart> ( int ) sleep_msec <S2SV_ModEnd> ; hiber_start_wait_any ( <S2SV_ModStart> ; hiber_start_wait_any ( sleepms <S2SV_ModEnd> ) ; REVERT <S2SV_ModStart> REVERT ; return YDB_OK |
2,713 | CWE-000 static INT32 _uartReadRxBuf ( INT nNum , PUINT8 pucBuf , UINT32 uLen ) { UINT32 i ; UINT32 uOffset = nNum * UARTOFFSET ; UART_BUFFER_T * dev ; dev = ( UART_BUFFER_T * ) & UART_DEV [ nNum ] ; if ( dev -> bIsUseUARTRxInt == TRUE ) { <S2SV_StartBug> if ( dev -> uRecCnt == 0 ) <S2SV_EndBug> <S2SV_StartBug> return 0 ; <S2SV_EndBug> if ( uLen > dev -> uRecCnt ) uLen = dev -> uRecCnt ; for ( i = uLen ; i > 0 ; i -- ) { * pucBuf ++ = dev -> pucUartRxBuf [ dev -> uUartRxHead ] ; dev -> uUartRxHead = _uartRxBufGetNextOne ( nNum , dev -> uUartRxHead ) ; <S2SV_StartBug> } <S2SV_EndBug> dev -> uRecCnt -= uLen ; } else { for ( i = 0 ; i < uLen ; i ++ ) { while ( ! ( inpw ( REG_UART0_FSR + uOffset ) & UART_FSR_RX_EMPTY_Msk ) ) ; * pucBuf ++ = inpb ( REG_UART0_RBR + uOffset ) ; } } return ( uLen ) ; } | <S2SV_ModStart> ( dev -> uUartRxHead == dev -> uUartRxTail <S2SV_ModEnd> ) return 0 <S2SV_ModStart> ) return 0 <S2SV_ModEnd> ; for ( <S2SV_ModStart> uUartRxHead ) ; if ( dev -> uUartRxHead == dev -> uUartRxTail ) break ; } uLen = uLen - i + 1 <S2SV_ModEnd> ; } else |
2,714 | CWE-000 static NTSTATUS dosysvol_referral ( struct loadparm_context * lp_ctx , struct ldb_context * sam_ctx , const struct tsocket_address * client , struct dfs_GetDFSReferral * r , const char * domain_name , const char * dfs_name ) { const char * site_name = NULL ; bool need_fqdn = false ; unsigned int i , c = 0 , nb_entries = 0 ; struct dc_set * * set ; char * client_str = NULL ; NTSTATUS status ; struct dfs_referral_type * referrals ; if ( lpcfg_server_role ( lp_ctx ) != ROLE_ACTIVE_DIRECTORY_DC ) { return NT_STATUS_INVALID_PARAMETER ; } if ( r -> in . req . max_referral_level < 3 ) { DEBUG ( 2 , ( "invalid<S2SV_blank>max_referral_level<S2SV_blank>%u\\n" , r -> in . req . max_referral_level ) ) ; return NT_STATUS_UNSUCCESSFUL ; } DEBUG ( 10 , ( "in<S2SV_blank>this<S2SV_blank>we<S2SV_blank>have<S2SV_blank>request<S2SV_blank>for<S2SV_blank>%s<S2SV_blank>and<S2SV_blank>share<S2SV_blank>%s<S2SV_blank>requested<S2SV_blank>is<S2SV_blank>%s\\n" , domain_name , dfs_name , r -> in . req . servername ) ) ; if ( strchr ( domain_name , '.' ) ) { need_fqdn = 1 ; } if ( tsocket_address_is_inet ( client , "ip" ) ) { client_str = tsocket_address_inet_addr_string ( client , r ) ; if ( client_str == NULL ) { return NT_STATUS_NO_MEMORY ; } } <S2SV_StartBug> site_name = samdb_client_site_name ( sam_ctx , r , client_str , NULL ) ; <S2SV_EndBug> status = get_dcs ( r , sam_ctx , site_name , need_fqdn , & set , 0 ) ; if ( ! NT_STATUS_IS_OK ( status ) ) { DEBUG ( 3 , ( "Unable<S2SV_blank>to<S2SV_blank>get<S2SV_blank>list<S2SV_blank>of<S2SV_blank>DCs<S2SV_blank>-<S2SV_blank>%s\\n" , nt_errstr ( status ) ) ) ; return status ; } for ( i = 0 ; set [ i ] ; i ++ ) { nb_entries = nb_entries + set [ i ] -> count ; } r -> out . resp = talloc_zero ( r , struct dfs_referral_resp ) ; if ( r -> out . resp == NULL ) { return NT_STATUS_NO_MEMORY ; } r -> out . resp -> path_consumed = strlen_m ( r -> in . req . servername ) * 2 ; r -> out . resp -> header_flags = DFS_HEADER_FLAG_STORAGE_SVR ; r -> out . resp -> nb_referrals = nb_entries ; referrals = talloc_zero_array ( r -> out . resp , struct dfs_referral_type , r -> out . resp -> nb_referrals ) ; if ( referrals == NULL ) { return NT_STATUS_NO_MEMORY ; } r -> out . resp -> referral_entries = referrals ; c = 0 ; for ( i = 0 ; set [ i ] ; i ++ ) { uint32_t j ; for ( j = 0 ; j < set [ i ] -> count ; j ++ ) { struct dfs_referral_type * ref = & referrals [ c ] ; const char * referral_str ; referral_str = talloc_asprintf ( referrals , "\\\\%s\\\\%s" , set [ i ] -> names [ j ] , dfs_name ) ; if ( referral_str == NULL ) { return NT_STATUS_NO_MEMORY ; } DEBUG ( 8 , ( "Doing<S2SV_blank>a<S2SV_blank>dfs<S2SV_blank>referral<S2SV_blank>for<S2SV_blank>%s<S2SV_blank>with<S2SV_blank>this<S2SV_blank>value<S2SV_blank>" "%s<S2SV_blank>requested<S2SV_blank>%s\\n" , set [ i ] -> names [ j ] , referral_str , r -> in . req . servername ) ) ; status = fill_normal_dfs_referraltype ( referrals , ref , r -> in . req . max_referral_level , r -> in . req . servername , referral_str , c == 0 ) ; if ( ! NT_STATUS_IS_OK ( status ) ) { DEBUG ( 2 , ( "%s:<S2SV_blank>Unable<S2SV_blank>to<S2SV_blank>fill<S2SV_blank>domain<S2SV_blank>referral<S2SV_blank>" "structure<S2SV_blank>-<S2SV_blank>%s\\n" , __location__ , nt_errstr ( status ) ) ) ; return status ; } c ++ ; } } return NT_STATUS_OK ; } | <S2SV_ModStart> client_str , NULL , true |
2,715 | CWE-000 int RVTH_CDECL _tmain ( int argc , TCHAR * argv [ ] ) { int ret ; int recrypt_key = - 1 ; ( ( void ) argc ) ; ( ( void ) argv ) ; puts ( "RVT-H<S2SV_blank>Tool<S2SV_blank>v" VERSION_STRING "\\n" "Copyright<S2SV_blank>(c)<S2SV_blank>2018<S2SV_blank>by<S2SV_blank>David<S2SV_blank>Korth." ) ; # ifdef RP_GIT_VERSION puts ( RP_GIT_VERSION ) ; # ifdef RP_GIT_DESCRIBE puts ( RP_GIT_DESCRIBE ) ; # endif # endif putchar ( '\\n' ) ; while ( true ) { static const struct option long_options [ ] = { { _T ( "recrypt" ) , required_argument , 0 , _T ( 'k' ) } , { _T ( "help" ) , no_argument , 0 , _T ( 'h' ) } , { NULL , 0 , 0 , 0 } } ; int c = getopt_long ( argc , argv , _T ( "k:h" ) , long_options , NULL ) ; if ( c == - 1 ) break ; switch ( c ) { case _T ( 'k' ) : if ( ! optarg ) { print_error ( argv [ 0 ] , _T ( "no<S2SV_blank>recryption<S2SV_blank>method<S2SV_blank>specified" ) ) ; return EXIT_FAILURE ; } if ( ! _tcsicmp ( optarg , _T ( "default" ) ) ) { recrypt_key = - 1 ; } else if ( ! _tcsicmp ( optarg , _T ( "debug" ) ) ) { recrypt_key = RVTH_CryptoType_Debug ; } else if ( ! _tcsicmp ( optarg , _T ( "retail" ) ) ) { recrypt_key = RVTH_CryptoType_Retail ; } else if ( ! _tcsicmp ( optarg , _T ( "korean" ) ) ) { recrypt_key = RVTH_CryptoType_Korean ; } else { print_error ( argv [ 0 ] , _T ( "unknown<S2SV_blank>encryption<S2SV_blank>key<S2SV_blank>\'%s\'" ) , optarg ) ; return EXIT_FAILURE ; } break ; case 'h' : print_help ( argv [ 0 ] ) ; return EXIT_SUCCESS ; case '?' : default : print_error ( argv [ 0 ] , NULL ) ; return EXIT_FAILURE ; } } if ( optind >= argc ) { print_error ( argv [ 0 ] , _T ( "no<S2SV_blank>parameters<S2SV_blank>specified" ) ) ; return EXIT_FAILURE ; } if ( ! _tcscmp ( argv [ optind ] , _T ( "help" ) ) ) { print_help ( argv [ 0 ] ) ; return EXIT_FAILURE ; } else if ( ! _tcscmp ( argv [ optind ] , _T ( "list" ) ) || ! _tcscmp ( argv [ optind ] , _T ( "list-banks" ) ) ) { if ( argc < optind + 2 ) { print_error ( argv [ 0 ] , _T ( "RVT-H<S2SV_blank>device<S2SV_blank>or<S2SV_blank>disk<S2SV_blank>image<S2SV_blank>not<S2SV_blank>specified" ) ) ; return EXIT_FAILURE ; } ret = list_banks ( argv [ optind + 1 ] ) ; } else if ( ! _tcscmp ( argv [ optind ] , _T ( "extract" ) ) ) { if ( argc < optind + 4 ) { print_error ( argv [ 0 ] , _T ( "missing<S2SV_blank>parameters<S2SV_blank>for<S2SV_blank>\'extract\'" ) ) ; return EXIT_FAILURE ; } ret = extract ( argv [ optind + 1 ] , argv [ optind + 2 ] , argv [ optind + 3 ] , recrypt_key ) ; } else if ( ! _tcscmp ( argv [ optind ] , _T ( "import" ) ) ) { if ( argc < optind + 4 ) { print_error ( argv [ 0 ] , _T ( "missing<S2SV_blank>parameters<S2SV_blank>for<S2SV_blank>\'import\'" ) ) ; return EXIT_FAILURE ; } ret = import ( argv [ optind + 1 ] , argv [ optind + 2 ] , argv [ optind + 3 ] ) ; } else if ( ! _tcscmp ( argv [ optind ] , _T ( "delete" ) ) ) { if ( argc < 3 ) { print_error ( argv [ 0 ] , _T ( "missing<S2SV_blank>parameters<S2SV_blank>for<S2SV_blank>\'delete\'" ) ) ; return EXIT_FAILURE ; } ret = delete_bank ( argv [ optind + 1 ] , argv [ optind + 2 ] ) ; } else if ( ! _tcscmp ( argv [ optind ] , _T ( "undelete" ) ) ) { if ( argc < 3 ) { print_error ( argv [ 0 ] , _T ( "missing<S2SV_blank>parameters<S2SV_blank>for<S2SV_blank>\'undelete\'" ) ) ; return EXIT_FAILURE ; } ret = undelete_bank ( argv [ optind + 1 ] , argv [ optind + 2 ] ) ; } <S2SV_StartBug> # ifdef HAVE_UDEV <S2SV_EndBug> else if ( ! _tcscmp ( argv [ optind ] , _T ( "query" ) ) ) { ret = query ( ) ; } <S2SV_StartBug> # endif <S2SV_EndBug> else { const TCHAR * p ; bool isFilename = false ; for ( p = argv [ optind ] ; * p != 0 ; p ++ ) { if ( * p == _T ( '/' ) || * p == _T ( '.' ) ) { isFilename = true ; break ; } # ifdef _WIN32 else if ( * p == '\\\\' ) { isFilename = true ; break ; } # endif } if ( isFilename ) { ret = list_banks ( argv [ optind ] ) ; } else { print_error ( argv [ 0 ] , _T ( "unrecognized<S2SV_blank>command<S2SV_blank>\'%s\'" ) , argv [ optind ] ) ; ret = EXIT_FAILURE ; } } return ret ; } | <S2SV_ModStart> ) ; } <S2SV_ModEnd> else if ( <S2SV_ModStart> ) ; } <S2SV_ModEnd> else { const |
2,716 | CWE-000 static void finish_update_zedge_x2 ( void * context , unimesh_t * mesh , int i , int j , int k , real_t t , unimesh_patch_t * patch ) { <S2SV_StartBug> ASSERT ( i == patch -> nx - 1 ) ; <S2SV_EndBug> } | <S2SV_ModStart> patch ) { <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
2,717 | CWE-000 void sgemm_main ( int index , char transa , char transb , int M , int N , int K , int lda , float alpha , int ldb , float beta , int ldc ) { float * a = matrix_init ( M , K ) ; float * b = matrix_init ( K , N ) ; float * c = matrix_init ( M , N ) ; <S2SV_StartBug> float * a_mkl = malloc ( M * N * sizeof ( float ) ) ; <S2SV_EndBug> <S2SV_StartBug> memcpy ( a_mkl , a , M * N * sizeof ( float ) ) ; <S2SV_EndBug> float * b_mkl = malloc ( K * N * sizeof ( float ) ) ; memcpy ( b_mkl , b , K * N * sizeof ( float ) ) ; float * c_mkl = malloc ( M * N * sizeof ( float ) ) ; memcpy ( c_mkl , c , M * N * sizeof ( float ) ) ; printf ( "----------GEMM<S2SV_blank>%d----------\\n" , index ) ; sgemm_opt ( index , & transa , & transb , & M , & N , & K , & alpha , a , & lda , b , & ldb , & beta , c , & ldc ) ; sgemm_mkl ( & transa , & transb , & M , & N , & K , & alpha , a_mkl , & lda , b_mkl , & ldb , & beta , c_mkl , & ldc ) ; verify_result ( c , c_mkl , M , N ) ; free ( a ) ; free ( b ) ; free ( c ) ; } | <S2SV_ModStart> ( M * K <S2SV_ModEnd> * sizeof ( <S2SV_ModStart> , M * K <S2SV_ModEnd> * sizeof ( |
2,718 | CWE-000 static unsigned long long get_unsigned ( t_format * form , va_list valist ) { unsigned long long result ; result = 0 ; if ( form -> size == N ) result = va_arg ( valist , unsigned int ) ; else if ( form -> size == HH ) <S2SV_StartBug> result = va_arg ( valist , int ) ; <S2SV_EndBug> else if ( form -> size == H ) <S2SV_StartBug> result = va_arg ( valist , int ) ; <S2SV_EndBug> else if ( form -> size == L ) result = va_arg ( valist , unsigned long ) ; else if ( form -> size == LL ) result = va_arg ( valist , unsigned long long ) ; else if ( form -> size == Z ) result = va_arg ( valist , size_t ) ; else if ( form -> size == J ) result = va_arg ( valist , uintmax_t ) ; return ( result ) ; } | <S2SV_ModStart> ) result = ( unsigned char ) <S2SV_ModStart> ) result = ( unsigned short ) |
2,719 | CWE-000 static bool clnt_rdma_freeres ( CLIENT * cl , xdrproc_t xdr_res , void * res_ptr ) { struct cx_data * cx = CX_DATA ( cl ) ; <S2SV_StartBug> struct cm_data * cm = CM_DATA ( cx ) ; <S2SV_EndBug> XDR * xdrs ; sigset_t mask , newmask ; bool dummy = 0 ; if ( ! xdr_res ) goto out ; xdrs = & ( cm -> cm_xdrs ) ; sigfillset ( & newmask ) ; thr_sigsetmask ( SIG_SETMASK , & newmask , & mask ) ; xdrs -> x_op = XDR_FREE ; if ( xdr_res ) dummy = ( * xdr_res ) ( xdrs , res_ptr ) ; thr_sigsetmask ( SIG_SETMASK , & mask , NULL ) ; <S2SV_StartBug> rpc_dplx_rsc ( cl , RPC_DPLX_FLAG_NONE ) ; <S2SV_EndBug> out : return ( dummy ) ; } | <S2SV_ModStart> ( cx ) ; struct rpc_dplx_rec * rec = cx -> cx_rec <S2SV_ModStart> NULL ) ; rpc_dplx_rsi ( rec <S2SV_ModEnd> , RPC_DPLX_FLAG_NONE ) |
2,720 | CWE-000 void i2c_isr_handler ( uint8_t port ) { port_info_t * pi = & port_info [ port ] ; KINETIS_I2C_t * i2c = get_i2c_ctrl ( port ) ; uint8_t status = i2c -> S ; uint8_t sub_state = pi -> sub_state ; uint8_t completion_status = 0xff ; if ( pi -> state == STATE_TX ) { if ( status & I2C_S_ARBL ) { pi -> state = STATE_ERROR ; i2c -> S = I2C_S_ARBL ; i2c -> C1 = I2C_C1_IICEN ; completion_status = I2C_STATUS_ARB_LOST ; } else if ( status & I2C_S_RXAK ) { pi -> state = STATE_ERROR ; i2c -> C1 = I2C_C1_IICEN ; completion_status = sub_state == SUB_STATE_ADDR ? I2C_STATUS_ADDR_NAK : I2C_STATUS_DATA_NAK ; } else { if ( sub_state == SUB_STATE_ADDR ) { pi -> sub_state = SUB_STATE_DATA ; i2c -> D = pi -> data [ 0 ] ; } else if ( pi -> processed == pi -> data_len - 1 ) { pi -> processed ++ ; pi -> state = STATE_WAITING ; i2c -> C1 = I2C_C1_IICEN ; completion_status = I2C_STATUS_OK ; } else { pi -> processed ++ ; i2c -> D = pi -> data [ pi -> processed ] ; } } if ( completion_status != 0xff ) send_write_completion ( port , completion_status ) ; } else if ( pi -> state == STATE_RX ) { if ( sub_state == SUB_STATE_ADDR ) { if ( status & I2C_S_ARBL ) { pi -> state = STATE_ERROR ; i2c -> S = I2C_S_ARBL ; i2c -> C1 = I2C_C1_IICEN ; completion_status = I2C_STATUS_ARB_LOST ; } else if ( status & I2C_S_RXAK ) { pi -> state = STATE_ERROR ; i2c -> C1 = I2C_C1_IICEN ; <S2SV_StartBug> completion_status = sub_state == SUB_STATE_ADDR ? I2C_STATUS_ADDR_NAK : I2C_STATUS_DATA_NAK ; <S2SV_EndBug> } else { pi -> sub_state = SUB_STATE_DATA ; i2c -> C1 = pi -> data_len > 1 ? I2C_C1_IICEN | I2C_C1_IICIE | I2C_C1_MST : I2C_C1_IICEN | I2C_C1_IICIE | I2C_C1_MST | I2C_C1_TXAK ; uint8_t __attribute__ ( ( unused ) ) data = i2c -> D ; } } else { if ( pi -> processed == pi -> data_len - 2 ) { i2c -> C1 = I2C_C1_IICEN | I2C_C1_IICIE | I2C_C1_MST | I2C_C1_TXAK ; } if ( pi -> processed == pi -> data_len - 1 ) { i2c -> C1 = I2C_C1_IICEN | I2C_C1_MST | I2C_C1_TX ; pi -> data [ pi -> processed ++ ] = i2c -> D ; for ( int i = 0 ; i < 20 ; i ++ ) { __asm__ volatile ( "nop" ) ; } i2c -> C1 = I2C_C1_IICEN ; completion_status = I2C_STATUS_OK ; } else { pi -> data [ pi -> processed ++ ] = i2c -> D ; } } if ( completion_status != 0xff ) send_read_completion ( port , completion_status ) ; } else { DEBUG_OUT ( "Spurious<S2SV_blank>I2C<S2SV_blank>interrupt" ) ; } i2c -> S = I2C_S_IICIF ; } | <S2SV_ModStart> = sub_state == I2C_STATUS_ADDR_NAK <S2SV_ModEnd> ; } else |
2,721 | CWE-000 char * str_manager ( t_format * sfmt , size_t * ln ) { char * res ; if ( sfmt -> gdata -> data . pc == NULL ) <S2SV_StartBug> res = ft_strdup ( "(null)" ) ; <S2SV_EndBug> else { if ( sfmt -> gdata -> full_type -> modifier == M_L || sfmt -> gdata -> full_type -> type == T_WSTR ) res = wcs_to_utf8 ( sfmt -> gdata -> data . pwc , sfmt -> precision ) ; else { if ( sfmt -> precision >= 0 ) { res = ft_strnew ( sfmt -> precision ) ; ft_memcpy ( res , sfmt -> gdata -> data . pc , sfmt -> precision ) ; } else res = ft_strdup ( sfmt -> gdata -> data . pc ) ; } align ( & res , sfmt ) ; <S2SV_StartBug> } <S2SV_EndBug> * ln = ft_strlen ( res ) ; <S2SV_StartBug> return ( res ) ; <S2SV_EndBug> } | <S2SV_ModStart> ) res = str_null ( sfmt , ln <S2SV_ModEnd> ) ; else <S2SV_ModStart> sfmt ) ; <S2SV_ModEnd> * ln = <S2SV_ModStart> res ) ; } |
2,722 | CWE-000 static int check_table_version ( struct ireq * iq ) { if ( iq -> sc -> addonly || iq -> sc -> resume ) return 0 ; int rc , bdberr ; unsigned long long version ; rc = bdb_table_version_select ( iq -> sc -> table , NULL , & version , & bdberr ) ; if ( rc != 0 ) { errstat_set_strf ( & iq -> errstat , <S2SV_StartBug> "failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>version<S2SV_blank>for<S2SV_blank>table:%s<S2SV_blank>rc:%d\\n" , <S2SV_EndBug> iq -> sc -> table , rc ) ; iq -> errstat . errval = ERR_SC ; return SC_INTERNAL_ERROR ; } if ( iq -> usedbtablevers != version ) { errstat_set_strf ( & iq -> errstat , "stale<S2SV_blank>version<S2SV_blank>for<S2SV_blank>table:%s<S2SV_blank>master:%d<S2SV_blank>replicant:%d\\n" , iq -> sc -> table , version , iq -> usedbtablevers ) ; <S2SV_StartBug> iq -> errstat . errval = ERR_SC ; <S2SV_EndBug> return SC_INTERNAL_ERROR ; } return 0 ; } | <S2SV_ModStart> -> errstat , "failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>version<S2SV_blank>for<S2SV_blank>table:%s<S2SV_blank>rc:%d\\n" , iq -> sc -> table , rc ) ; sc_errf ( iq -> sc , <S2SV_ModStart> usedbtablevers ) ; sc_errf ( iq -> sc , "stale<S2SV_blank>version<S2SV_blank>for<S2SV_blank>table:%s<S2SV_blank>master:%d<S2SV_blank>replicant:%d\\n" , iq -> sc -> table , version , iq -> usedbtablevers ) ; |
2,723 | CWE-000 A_exp ArrayType ( ) { A_pos nilPos = 0 ; <S2SV_StartBug> A_dec arrtype = A_TypeDec ( nilPos , A_NametyList ( A_Namety ( S_Symbol ( "arrtype" ) , A_ArrayTy ( nilPos , S_Symbol ( "int" ) ) ) , NULL ) ) ; <S2SV_EndBug> <S2SV_StartBug> A_dec arr1 = A_VarDec ( nilPos , S_Symbol ( "arr1" ) , S_Symbol ( "arrtype" ) , A_ArrayExp ( nilPos , S_Symbol ( "arrtype" ) , A_IntExp ( nilPos , 10 ) , A_IntExp ( nilPos , 0 ) ) ) ; <S2SV_EndBug> <S2SV_StartBug> return A_LetExp ( nilPos , A_DecList ( arrtype , A_DecList ( arr1 , NULL ) ) , <S2SV_EndBug> <S2SV_StartBug> A_VarExp ( nilPos , A_SimpleVar ( nilPos , S_Symbol ( "arr1" ) ) ) ) ; <S2SV_EndBug> } | <S2SV_ModStart> = A_TypeDec ( ++ <S2SV_ModStart> , A_ArrayTy ( ++ <S2SV_ModStart> = A_VarDec ( ++ <S2SV_ModStart> , A_ArrayExp ( ++ <S2SV_ModStart> , A_IntExp ( ++ <S2SV_ModStart> , A_IntExp ( ++ <S2SV_ModStart> return A_LetExp ( ++ <S2SV_ModStart> , A_VarExp ( ++ <S2SV_ModStart> , A_SimpleVar ( ++ |
2,724 | CWE-000 esp_err_t spi_bus_add_device ( spi_host_device_t host , const spi_device_interface_config_t * dev_config , spi_device_handle_t * handle ) { int freecs ; int apbclk = APB_CLK_FREQ ; int eff_clk ; int duty_cycle ; spi_clock_reg_t clk_reg ; SPI_CHECK ( host >= SPI_HOST && host <= VSPI_HOST , "invalid<S2SV_blank>host" , ESP_ERR_INVALID_ARG ) ; SPI_CHECK ( spihost [ host ] != NULL , "host<S2SV_blank>not<S2SV_blank>initialized" , ESP_ERR_INVALID_STATE ) ; SPI_CHECK ( dev_config -> spics_io_num < 0 || GPIO_IS_VALID_OUTPUT_GPIO ( dev_config -> spics_io_num ) , "spics<S2SV_blank>pin<S2SV_blank>invalid" , ESP_ERR_INVALID_ARG ) ; SPI_CHECK ( dev_config -> clock_speed_hz > 0 , "invalid<S2SV_blank>sclk<S2SV_blank>speed" , ESP_ERR_INVALID_ARG ) ; for ( freecs = 0 ; freecs < NO_CS ; freecs ++ ) { if ( __sync_bool_compare_and_swap ( & spihost [ host ] -> device [ freecs ] , NULL , ( spi_device_t * ) 1 ) ) break ; } SPI_CHECK ( freecs != NO_CS , "no<S2SV_blank>free<S2SV_blank>cs<S2SV_blank>pins<S2SV_blank>for<S2SV_blank>host" , ESP_ERR_NOT_FOUND ) ; SPI_CHECK ( dev_config -> cs_ena_pretrans == 0 || ( dev_config -> flags & SPI_DEVICE_HALFDUPLEX ) , "cs<S2SV_blank>pretrans<S2SV_blank>delay<S2SV_blank>incompatible<S2SV_blank>with<S2SV_blank>full-duplex" , ESP_ERR_INVALID_ARG ) ; duty_cycle = ( dev_config -> duty_cycle_pos == 0 ? 128 : dev_config -> duty_cycle_pos ) ; eff_clk = spi_cal_clock ( apbclk , dev_config -> clock_speed_hz , duty_cycle , ( uint32_t * ) & clk_reg ) ; <S2SV_StartBug> uint32_t dummy_limit = spi_dummy_limit ( ! spihost [ host ] -> no_gpio_matrix ) ; <S2SV_EndBug> SPI_CHECK ( dev_config -> flags & SPI_DEVICE_HALFDUPLEX || ( eff_clk / 1000 / 1000 ) < ( dummy_limit / 1000 / 1000 ) || dev_config -> flags & SPI_DEVICE_NO_DUMMY , <S2SV_StartBug> "When<S2SV_blank>GPIO<S2SV_blank>matrix<S2SV_blank>is<S2SV_blank>used<S2SV_blank>in<S2SV_blank>full-duplex<S2SV_blank>mode<S2SV_blank>at<S2SV_blank>frequency<S2SV_blank>><S2SV_blank>26MHz,<S2SV_blank>device<S2SV_blank>cannot<S2SV_blank>read<S2SV_blank>correct<S2SV_blank>data.\\n\\\n<S2SV_blank>Please<S2SV_blank>note<S2SV_blank>the<S2SV_blank>SPI<S2SV_blank>can<S2SV_blank>only<S2SV_blank>work<S2SV_blank>at<S2SV_blank>divisors<S2SV_blank>of<S2SV_blank>80MHz,<S2SV_blank>and<S2SV_blank>the<S2SV_blank>driver<S2SV_blank>always<S2SV_blank>tries<S2SV_blank>to<S2SV_blank>find<S2SV_blank>the<S2SV_blank>closest<S2SV_blank>frequency<S2SV_blank>to<S2SV_blank>your<S2SV_blank>configuration.\\n\\\n<S2SV_blank>Specify<S2SV_blank>``SPI_DEVICE_NO_DUMMY``<S2SV_blank>to<S2SV_blank>ignore<S2SV_blank>this<S2SV_blank>checking.<S2SV_blank>Then<S2SV_blank>you<S2SV_blank>can<S2SV_blank>output<S2SV_blank>data<S2SV_blank>at<S2SV_blank>higher<S2SV_blank>speed,<S2SV_blank>or<S2SV_blank>read<S2SV_blank>data<S2SV_blank>at<S2SV_blank>your<S2SV_blank>own<S2SV_blank>risk." , <S2SV_EndBug> ESP_ERR_INVALID_ARG ) ; spi_device_t * dev = malloc ( sizeof ( spi_device_t ) ) ; if ( dev == NULL ) goto nomem ; memset ( dev , 0 , sizeof ( spi_device_t ) ) ; spihost [ host ] -> device [ freecs ] = dev ; dev -> trans_queue = xQueueCreate ( dev_config -> queue_size , sizeof ( spi_trans_priv ) ) ; dev -> ret_queue = xQueueCreate ( dev_config -> queue_size , sizeof ( spi_trans_priv ) ) ; if ( ! dev -> trans_queue || ! dev -> ret_queue ) goto nomem ; dev -> host = spihost [ host ] ; memcpy ( & dev -> cfg , dev_config , sizeof ( spi_device_interface_config_t ) ) ; dev -> cfg . duty_cycle_pos = duty_cycle ; dev -> clk_cfg = ( clock_config_t ) { . eff_clk = eff_clk , . dummy_num = ( dev -> clk_cfg . eff_clk >= dummy_limit ? 1 : 0 ) , . reg = clk_reg , } ; if ( dev_config -> spics_io_num >= 0 ) { gpio_set_direction ( dev_config -> spics_io_num , GPIO_MODE_OUTPUT ) ; <S2SV_StartBug> spicommon_cs_initialize ( host , dev_config -> spics_io_num , freecs , spihost [ host ] -> no_gpio_matrix == false ) ; <S2SV_EndBug> } if ( dev_config -> flags & SPI_DEVICE_CLK_AS_CS ) { spihost [ host ] -> hw -> pin . master_ck_sel |= ( 1 << freecs ) ; } else { spihost [ host ] -> hw -> pin . master_ck_sel &= ( 1 << freecs ) ; } if ( dev_config -> flags & SPI_DEVICE_POSITIVE_CS ) { spihost [ host ] -> hw -> pin . master_cs_pol |= ( 1 << freecs ) ; } else { spihost [ host ] -> hw -> pin . master_cs_pol &= ( 1 << freecs ) ; } * handle = dev ; ESP_LOGD ( SPI_TAG , "SPI%d:<S2SV_blank>New<S2SV_blank>device<S2SV_blank>added<S2SV_blank>to<S2SV_blank>CS%d,<S2SV_blank>effective<S2SV_blank>clock:<S2SV_blank>%dkHz" , host , freecs , dev -> clk_cfg . eff_clk / 1000 ) ; return ESP_OK ; nomem : if ( dev ) { if ( dev -> trans_queue ) vQueueDelete ( dev -> trans_queue ) ; if ( dev -> ret_queue ) vQueueDelete ( dev -> ret_queue ) ; } free ( dev ) ; return ESP_ERR_NO_MEM ; } | <S2SV_ModStart> spi_dummy_limit ( ! ( spihost [ host ] -> flags & SPICOMMON_BUSFLAG_NATIVE_PINS ) <S2SV_ModEnd> ) ; SPI_CHECK <S2SV_ModStart> & SPI_DEVICE_NO_DUMMY , "When<S2SV_blank>GPIO<S2SV_blank>matrix<S2SV_blank>is<S2SV_blank>used<S2SV_blank>in<S2SV_blank>full-duplex<S2SV_blank>mode<S2SV_blank>at<S2SV_blank>frequency<S2SV_blank>><S2SV_blank>26MHz,<S2SV_blank>device<S2SV_blank>cannot<S2SV_blank>read<S2SV_blank>correct<S2SV_blank>data.\\n\\\nPlease<S2SV_blank>note<S2SV_blank>the<S2SV_blank>SPI<S2SV_blank>can<S2SV_blank>only<S2SV_blank>work<S2SV_blank>at<S2SV_blank>divisors<S2SV_blank>of<S2SV_blank>80MHz,<S2SV_blank>and<S2SV_blank>the<S2SV_blank>driver<S2SV_blank>always<S2SV_blank>tries<S2SV_blank>to<S2SV_blank>find<S2SV_blank>the<S2SV_blank>closest<S2SV_blank>frequency<S2SV_blank>to<S2SV_blank>your<S2SV_blank>configuration.\\n\\\nSpecify<S2SV_blank>``SPI_DEVICE_NO_DUMMY``<S2SV_blank>to<S2SV_blank>ignore<S2SV_blank>this<S2SV_blank>checking.<S2SV_blank>Then<S2SV_blank>you<S2SV_blank>can<S2SV_blank>output<S2SV_blank>data<S2SV_blank>at<S2SV_blank>higher<S2SV_blank>speed,<S2SV_blank>or<S2SV_blank>read<S2SV_blank>data<S2SV_blank>at<S2SV_blank>your<S2SV_blank>own<S2SV_blank>risk." <S2SV_ModEnd> , ESP_ERR_INVALID_ARG ) <S2SV_ModStart> , freecs , ! ( spihost [ host ] -> flags & SPICOMMON_BUSFLAG_NATIVE_PINS ) <S2SV_ModEnd> ) ; } |
2,725 | CWE-000 int32_t glusterd_import_new_brick ( dict_t * peer_data , int32_t vol_count , int32_t brick_count , glusterd_brickinfo_t * * brickinfo , char * prefix ) { char key [ 512 ] = { 0 , } ; int ret = - 1 ; char * hostname = NULL ; char * path = NULL ; char * brick_id = NULL ; int decommissioned = 0 ; glusterd_brickinfo_t * new_brickinfo = NULL ; char msg [ 2048 ] = { 0 } ; char * brick_uuid_str = NULL ; GF_ASSERT ( peer_data ) ; GF_ASSERT ( vol_count >= 0 ) ; GF_ASSERT ( brickinfo ) ; GF_ASSERT ( prefix ) ; memset ( key , 0 , sizeof ( key ) ) ; snprintf ( key , sizeof ( key ) , "%s%d.brick%d.hostname" , prefix , vol_count , brick_count ) ; ret = dict_get_str ( peer_data , key , & hostname ) ; if ( ret ) { snprintf ( msg , sizeof ( msg ) , "%s<S2SV_blank>missing<S2SV_blank>in<S2SV_blank>payload" , key ) ; goto out ; } memset ( key , 0 , sizeof ( key ) ) ; snprintf ( key , sizeof ( key ) , "%s%d.brick%d.path" , prefix , vol_count , brick_count ) ; ret = dict_get_str ( peer_data , key , & path ) ; if ( ret ) { snprintf ( msg , sizeof ( msg ) , "%s<S2SV_blank>missing<S2SV_blank>in<S2SV_blank>payload" , key ) ; goto out ; } memset ( key , 0 , sizeof ( key ) ) ; snprintf ( key , sizeof ( key ) , "%s%d.brick%d.brick_id" , prefix , vol_count , brick_count ) ; ret = dict_get_str ( peer_data , key , & brick_id ) ; memset ( key , 0 , sizeof ( key ) ) ; snprintf ( key , sizeof ( key ) , "%s%d.brick%d.decommissioned" , prefix , vol_count , brick_count ) ; ret = dict_get_int32 ( peer_data , key , & decommissioned ) ; if ( ret ) { ret = 0 ; } ret = glusterd_brickinfo_new ( & new_brickinfo ) ; if ( ret ) goto out ; <S2SV_StartBug> strcpy ( new_brickinfo -> path , path ) ; <S2SV_EndBug> <S2SV_StartBug> strcpy ( new_brickinfo -> hostname , hostname ) ; <S2SV_EndBug> new_brickinfo -> decommissioned = decommissioned ; if ( brick_id ) strcpy ( new_brickinfo -> brick_id , brick_id ) ; memset ( key , 0 , sizeof ( key ) ) ; snprintf ( key , sizeof ( key ) , "%s%d.brick%d" , prefix , vol_count , brick_count ) ; ret = gd_import_new_brick_snap_details ( peer_data , key , new_brickinfo ) ; if ( ret ) goto out ; memset ( key , 0 , sizeof ( key ) ) ; snprintf ( key , sizeof ( key ) , "%s%d.brick%d.uuid" , prefix , vol_count , brick_count ) ; ret = dict_get_str ( peer_data , key , & brick_uuid_str ) ; if ( ret ) goto out ; gf_uuid_parse ( brick_uuid_str , new_brickinfo -> uuid ) ; * brickinfo = new_brickinfo ; out : if ( msg [ 0 ] ) { gf_msg ( "glusterd" , GF_LOG_ERROR , 0 , GD_MSG_BRICK_IMPORT_FAIL , "%s" , msg ) ; gf_event ( EVENT_IMPORT_BRICK_FAILED , "peer=%s;brick=%s" , new_brickinfo -> hostname , new_brickinfo -> path ) ; } gf_msg_debug ( "glusterd" , 0 , "Returning<S2SV_blank>with<S2SV_blank>%d" , ret ) ; return ret ; } | <S2SV_ModStart> goto out ; strncpy <S2SV_ModEnd> ( new_brickinfo -> <S2SV_ModStart> path , path , sizeof ( new_brickinfo -> path ) - 1 ) ; strncpy <S2SV_ModEnd> ( new_brickinfo -> <S2SV_ModStart> hostname , hostname , sizeof ( new_brickinfo -> hostname ) - 1 |
2,726 | CWE-000 int FTI_TestConfig ( FTIT_configuration * FTI_Conf , FTIT_topology * FTI_Topo , FTIT_checkpoint * FTI_Ckpt , FTIT_execution * FTI_Exec ) { if ( FTI_Topo -> nbHeads != 0 && FTI_Topo -> nbHeads != 1 ) { FTI_Print ( "The<S2SV_blank>number<S2SV_blank>of<S2SV_blank>heads<S2SV_blank>needs<S2SV_blank>to<S2SV_blank>be<S2SV_blank>set<S2SV_blank>to<S2SV_blank>0<S2SV_blank>or<S2SV_blank>1." , FTI_WARN ) ; return FTI_NSCS ; } if ( FTI_Topo -> nbProc % FTI_Topo -> nodeSize != 0 ) { FTI_Print ( "Number<S2SV_blank>of<S2SV_blank>ranks<S2SV_blank>is<S2SV_blank>not<S2SV_blank>a<S2SV_blank>multiple<S2SV_blank>of<S2SV_blank>the<S2SV_blank>node<S2SV_blank>size." , FTI_WARN ) ; return FTI_NSCS ; } if ( FTI_Topo -> nbNodes % FTI_Topo -> groupSize != 0 ) { FTI_Print ( "The<S2SV_blank>number<S2SV_blank>of<S2SV_blank>nodes<S2SV_blank>is<S2SV_blank>not<S2SV_blank>multiple<S2SV_blank>of<S2SV_blank>the<S2SV_blank>group<S2SV_blank>size." , FTI_WARN ) ; return FTI_NSCS ; } int L2req = ( FTI_Ckpt [ 2 ] . ckptIntv > 0 ) ? 1 : 0 ; int RSreq = ( FTI_Ckpt [ 3 ] . ckptIntv > 0 ) ? 1 : 0 ; if ( FTI_Topo -> groupSize <= 2 && ( L2req || RSreq ) ) { FTI_Print ( "The<S2SV_blank>group<S2SV_blank>size<S2SV_blank>must<S2SV_blank>be<S2SV_blank>bigger<S2SV_blank>than<S2SV_blank>2" , FTI_WARN ) ; return FTI_NSCS ; } if ( FTI_Topo -> groupSize >= 32 && RSreq ) { FTI_Print ( "The<S2SV_blank>group<S2SV_blank>size<S2SV_blank>must<S2SV_blank>be<S2SV_blank>lower<S2SV_blank>than<S2SV_blank>32" , FTI_WARN ) ; return FTI_NSCS ; } if ( FTI_Conf -> verbosity > 3 || FTI_Conf -> verbosity < 1 ) { FTI_Print ( "Verbosity<S2SV_blank>needs<S2SV_blank>to<S2SV_blank>be<S2SV_blank>set<S2SV_blank>to<S2SV_blank>1,<S2SV_blank>2<S2SV_blank>or<S2SV_blank>3." , FTI_WARN ) ; return FTI_NSCS ; } if ( FTI_Conf -> blockSize > ( 2048 * 1024 ) || FTI_Conf -> blockSize < ( 1 * 1024 ) ) { FTI_Print ( "Block<S2SV_blank>size<S2SV_blank>needs<S2SV_blank>to<S2SV_blank>be<S2SV_blank>set<S2SV_blank>between<S2SV_blank>1<S2SV_blank>and<S2SV_blank>2048." , FTI_WARN ) ; return FTI_NSCS ; } <S2SV_StartBug> if ( ( FTI_Conf -> dcpMode < 2001 ) || ( FTI_Conf -> dcpMode > 2002 ) ) { <S2SV_EndBug> FTI_Print ( "dCP<S2SV_blank>mode<S2SV_blank>(\'Basic:dcp_mode\')<S2SV_blank>must<S2SV_blank>be<S2SV_blank>either<S2SV_blank>1<S2SV_blank>(MD5)<S2SV_blank>or<S2SV_blank>2<S2SV_blank>(CRC32),<S2SV_blank>dCP<S2SV_blank>disabled." , FTI_WARN ) ; FTI_Conf -> dcpEnabled = false ; } if ( ( FTI_Conf -> dcpBlockSize < 512 ) || ( FTI_Conf -> dcpBlockSize > USHRT_MAX ) ) { char str [ FTI_BUFS ] ; snprintf ( str , FTI_BUFS , "dCP<S2SV_blank>block<S2SV_blank>size<S2SV_blank>(\'Basic:dcp_block_size\')<S2SV_blank>must<S2SV_blank>be<S2SV_blank>between<S2SV_blank>512<S2SV_blank>and<S2SV_blank>%d<S2SV_blank>bytes,<S2SV_blank>dCP<S2SV_blank>disabled" , USHRT_MAX ) ; FTI_Print ( str , FTI_WARN ) ; FTI_Conf -> dcpEnabled = false ; } if ( FTI_Conf -> transferSize > ( 1024 * 1024 * 64 ) || FTI_Conf -> transferSize < ( 1024 * 1024 * 8 ) ) { FTI_Print ( "Transfer<S2SV_blank>size<S2SV_blank>(default<S2SV_blank>=<S2SV_blank>16MB)<S2SV_blank>not<S2SV_blank>set<S2SV_blank>in<S2SV_blank>Cofiguration<S2SV_blank>file." , FTI_WARN ) ; FTI_Conf -> transferSize = 16 * 1024 * 1024 ; } if ( FTI_Conf -> test != 0 && FTI_Conf -> test != 1 ) { FTI_Print ( "Local<S2SV_blank>test<S2SV_blank>size<S2SV_blank>needs<S2SV_blank>to<S2SV_blank>be<S2SV_blank>set<S2SV_blank>to<S2SV_blank>0<S2SV_blank>or<S2SV_blank>1." , FTI_WARN ) ; return FTI_NSCS ; } if ( FTI_Conf -> saveLastCkpt != 0 && FTI_Conf -> saveLastCkpt != 1 ) { FTI_Print ( "Keep<S2SV_blank>last<S2SV_blank>ckpt.<S2SV_blank>needs<S2SV_blank>to<S2SV_blank>be<S2SV_blank>set<S2SV_blank>to<S2SV_blank>0<S2SV_blank>or<S2SV_blank>1." , FTI_WARN ) ; return FTI_NSCS ; } int i ; for ( i = 1 ; i < 5 ; i ++ ) { if ( FTI_Ckpt [ i ] . ckptIntv == 0 ) { FTI_Ckpt [ i ] . ckptIntv = - 1 ; } if ( FTI_Ckpt [ i ] . isInline != 0 && FTI_Ckpt [ i ] . isInline != 1 ) { FTI_Ckpt [ i ] . isInline = 1 ; } if ( FTI_Ckpt [ i ] . isInline == 0 && FTI_Topo -> nbHeads != 1 ) { FTI_Print ( "If<S2SV_blank>inline<S2SV_blank>is<S2SV_blank>set<S2SV_blank>to<S2SV_blank>0<S2SV_blank>then<S2SV_blank>head<S2SV_blank>should<S2SV_blank>be<S2SV_blank>set<S2SV_blank>to<S2SV_blank>1." , FTI_WARN ) ; return FTI_NSCS ; } } if ( FTI_Exec -> syncIterMax < 0 ) { FTI_Exec -> syncIterMax = 512 ; FTI_Print ( "Variable<S2SV_blank>\'Basic:max_sync_intv\'<S2SV_blank>is<S2SV_blank>not<S2SV_blank>set.<S2SV_blank>Set<S2SV_blank>to<S2SV_blank>default<S2SV_blank>(512<S2SV_blank>iterations)." , FTI_WARN ) ; } else if ( ( FTI_Exec -> syncIterMax & ( FTI_Exec -> syncIterMax - 1 ) ) != 0 ) { int check = 1 ; while ( ( ( check << 1 ) < FTI_Exec -> syncIterMax ) && ( ( check << 1 ) > 0 ) ) { check = check << 1 ; } FTI_Exec -> syncIterMax = check ; char str [ FTI_BUFS ] ; snprintf ( str , FTI_BUFS , "Maximal<S2SV_blank>sync.<S2SV_blank>intv.<S2SV_blank>has<S2SV_blank>to<S2SV_blank>be<S2SV_blank>a<S2SV_blank>power<S2SV_blank>of<S2SV_blank>2.<S2SV_blank>Set<S2SV_blank>to<S2SV_blank>nearest<S2SV_blank>lower<S2SV_blank>value<S2SV_blank>(%d<S2SV_blank>iterations)" , FTI_Exec -> syncIterMax ) ; FTI_Print ( str , FTI_WARN ) ; } else if ( FTI_Exec -> syncIterMax == 0 ) { FTI_Exec -> syncIterMax = 512 ; FTI_Print ( "Variable<S2SV_blank>\'Basic:max_sync_intv\'<S2SV_blank>is<S2SV_blank>set<S2SV_blank>to<S2SV_blank>default<S2SV_blank>(512<S2SV_blank>iterations)." , FTI_DBUG ) ; } if ( FTI_Topo -> groupSize < 1 ) { FTI_Topo -> groupSize = 1 ; } switch ( FTI_Conf -> ioMode ) { case FTI_IO_POSIX : FTI_Print ( "Selected<S2SV_blank>Ckpt<S2SV_blank>I/O<S2SV_blank>is<S2SV_blank>POSIX" , FTI_INFO ) ; break ; case FTI_IO_MPI : FTI_Print ( "Selected<S2SV_blank>Ckpt<S2SV_blank>I/O<S2SV_blank>is<S2SV_blank>MPI-I/O" , FTI_INFO ) ; break ; case FTI_IO_FTIFF : FTI_Print ( "Selected<S2SV_blank>Ckpt<S2SV_blank>I/O<S2SV_blank>is<S2SV_blank>FTI-FF" , FTI_INFO ) ; break ; # ifdef ENABLE_SIONLIB case FTI_IO_SIONLIB : FTI_Print ( "Selected<S2SV_blank>Ckpt<S2SV_blank>I/O<S2SV_blank>is<S2SV_blank>SIONLIB" , FTI_INFO ) ; break ; # endif case FTI_IO_HDF5 : # ifdef ENABLE_HDF5 FTI_Print ( "Selected<S2SV_blank>Ckpt<S2SV_blank>I/O<S2SV_blank>is<S2SV_blank>HDF5" , FTI_INFO ) ; # else FTI_Print ( "Selected<S2SV_blank>Ckpt<S2SV_blank>I/O<S2SV_blank>is<S2SV_blank>HDF5,<S2SV_blank>but<S2SV_blank>HDF5<S2SV_blank>is<S2SV_blank>not<S2SV_blank>enabled.<S2SV_blank>Setting<S2SV_blank>IO<S2SV_blank>mode<S2SV_blank>to<S2SV_blank>POSIX." , FTI_WARN ) ; FTI_Conf -> ioMode = FTI_IO_POSIX ; # endif break ; default : FTI_Conf -> ioMode = FTI_IO_POSIX ; FTI_Print ( "Variable<S2SV_blank>\'Basic:ckpt_io\'<S2SV_blank>is<S2SV_blank>not<S2SV_blank>set.<S2SV_blank>Set<S2SV_blank>to<S2SV_blank>default<S2SV_blank>(POSIX)." , FTI_WARN ) ; break ; } return FTI_SCES ; } | <S2SV_ModStart> -> dcpMode < FTI_DCP_MODE_MD5 <S2SV_ModEnd> ) || ( <S2SV_ModStart> -> dcpMode > FTI_DCP_MODE_CRC32 <S2SV_ModEnd> ) ) { |
2,727 | CWE-000 int compress_stop ( struct compress * compress ) { if ( ! is_compress_running ( compress ) ) <S2SV_StartBug> return oops ( compress , - ENODEV , "device<S2SV_blank>not<S2SV_blank>ready" ) ; <S2SV_EndBug> if ( ioctl ( compress -> fd , SNDRV_COMPRESS_STOP ) ) return oops ( compress , errno , "cannot<S2SV_blank>stop<S2SV_blank>the<S2SV_blank>stream" ) ; return 0 ; } | <S2SV_ModStart> ( compress , <S2SV_ModEnd> ENODEV , "device<S2SV_blank>not<S2SV_blank>ready" |
2,728 | CWE-000 SQLITE_PRIVATE int sqlite3BtreeSetVersion ( Btree * pBtree , int iVersion ) { BtShared * pBt = pBtree -> pBt ; int rc ; assert ( iVersion == 1 || iVersion == 2 ) ; pBt -> btsFlags &= ~ BTS_NO_WAL ; if ( iVersion == 1 ) pBt -> btsFlags |= BTS_NO_WAL ; <S2SV_StartBug> rc = sqlite3BtreeBeginTrans ( pBtree , 0 ) ; <S2SV_EndBug> if ( rc == SQLITE_OK ) { u8 * aData = pBt -> pPage1 -> aData ; if ( aData [ 18 ] != ( u8 ) iVersion || aData [ 19 ] != ( u8 ) iVersion ) { <S2SV_StartBug> rc = sqlite3BtreeBeginTrans ( pBtree , 2 ) ; <S2SV_EndBug> if ( rc == SQLITE_OK ) { rc = sqlite3PagerWrite ( pBt -> pPage1 -> pDbPage ) ; if ( rc == SQLITE_OK ) { aData [ 18 ] = ( u8 ) iVersion ; aData [ 19 ] = ( u8 ) iVersion ; } } } } pBt -> btsFlags &= ~ BTS_NO_WAL ; return rc ; } | <S2SV_ModStart> pBtree , 0 , 0 <S2SV_ModStart> pBtree , 2 , 0 |
2,729 | CWE-000 static int ebpf_dev_map_delete_elem ( GBPFDriver * self , int map_desc , void * key ) { EBPFDevDriver * driver = ( EBPFDevDriver * ) self ; union ebpf_req req ; req . map_fd = map_desc ; req . key = key ; <S2SV_StartBug> return ioctl ( driver -> ebpf_fd , EBPFIOC_MAP_LOOKUP_ELEM , & req ) ; <S2SV_EndBug> } | <S2SV_ModStart> -> ebpf_fd , EBPFIOC_MAP_DELETE_ELEM <S2SV_ModEnd> , & req |
2,730 | CWE-000 void main ( int argc , char * * argv ) { char * mntpt , * srvpost , srvfile [ 64 ] ; int backwards = 0 , fd , mntflags , oldserver , notree ; quotefmtinstall ( ) ; srvpost = nil ; oldserver = 0 ; notree = 0 ; mntflags = MREPL ; ARGBEGIN { case 'A' : doauth = 0 ; break ; case 'a' : mntflags = MAFTER ; break ; case 'b' : mntflags = MBEFORE ; break ; case 'c' : <S2SV_StartBug> mntflags |= MCREATE ; <S2SV_EndBug> break ; case 'C' : mntflags |= MCACHE ; break ; case 'd' : debug ++ ; break ; case 'f' : break ; case 'O' : case 'o' : oldserver = 1 ; break ; case 'E' : if ( ( encproto = lookup ( EARGF ( usage ( ) ) , encprotos ) ) < 0 ) usage ( ) ; break ; case 'e' : ealgs = EARGF ( usage ( ) ) ; if ( * ealgs == 0 || strcmp ( ealgs , "clear" ) == 0 ) ealgs = nil ; break ; case 'k' : keyspec = EARGF ( usage ( ) ) ; break ; case 'p' : filterp = aan ; break ; case 's' : srvpost = EARGF ( usage ( ) ) ; break ; case 'B' : backwards = 1 ; break ; case 'm' : notree = 1 ; break ; default : usage ( ) ; } ARGEND ; mntpt = 0 ; if ( backwards ) { switch ( argc ) { default : mntpt = argv [ 0 ] ; break ; case 0 : usage ( ) ; } } else { switch ( argc ) { case 2 : mntpt = argv [ 1 ] ; break ; case 3 : if ( notree ) usage ( ) ; mntpt = argv [ 2 ] ; break ; default : usage ( ) ; } } if ( encproto == Enctls ) sysfatal ( "%s:<S2SV_blank>tls<S2SV_blank>has<S2SV_blank>not<S2SV_blank>yet<S2SV_blank>been<S2SV_blank>implemented" , argv [ 0 ] ) ; notify ( catcher ) ; alarm ( 60 * 1000 ) ; if ( backwards ) fd = passive ( ) ; else if ( notree ) fd = connect ( argv [ 0 ] , nil , oldserver ) ; else fd = connect ( argv [ 0 ] , argv [ 1 ] , oldserver ) ; if ( ! oldserver ) fprint ( fd , "impo<S2SV_blank>%s<S2SV_blank>%s\\n" , filterp ? "aan" : "nofilter" , encprotos [ encproto ] ) ; if ( encproto != Encnone && ealgs && ai ) { unsigned char key [ 16 ] ; unsigned char digest [ SHA1dlen ] ; char fromclientsecret [ 21 ] ; char fromserversecret [ 21 ] ; int i ; memmove ( key + 4 , ai -> secret , ai -> nsecret ) ; srand ( truerand ( ) ) ; for ( i = 0 ; i < 4 ; i ++ ) key [ i ] = rand ( ) ; if ( write ( fd , key , 4 ) != 4 ) sysfatal ( "can\'t<S2SV_blank>write<S2SV_blank>key<S2SV_blank>part:<S2SV_blank>%r" ) ; if ( readn ( fd , key + 12 , 4 ) != 4 ) sysfatal ( "can\'t<S2SV_blank>read<S2SV_blank>key<S2SV_blank>part:<S2SV_blank>%r" ) ; sha1 ( key , sizeof ( key ) , digest , nil ) ; mksecret ( fromclientsecret , digest ) ; mksecret ( fromserversecret , digest + 10 ) ; if ( filterp ) fd = filter ( fd , filterp , argv [ 0 ] ) ; procsetname ( "pushssl" ) ; fd = pushssl ( fd , ealgs , fromclientsecret , fromserversecret , nil ) ; if ( fd < 0 ) sysfatal ( "can\'t<S2SV_blank>establish<S2SV_blank>ssl<S2SV_blank>connection:<S2SV_blank>%r" ) ; } else if ( filterp ) fd = filter ( fd , filterp , argv [ 0 ] ) ; if ( srvpost ) { sprint ( srvfile , "/srv/%s" , srvpost ) ; remove ( srvfile ) ; post ( srvfile , srvpost , fd ) ; } procsetname ( "mount<S2SV_blank>on<S2SV_blank>%s" , mntpt ) ; if ( mount ( fd , - 1 , mntpt , mntflags , "" , '9' ) < 0 ) sysfatal ( "can\'t<S2SV_blank>mount<S2SV_blank>%s:<S2SV_blank>%r" , argv [ 1 ] ) ; alarm ( 0 ) ; if ( backwards && argc > 1 ) { exec ( argv [ 1 ] , & argv [ 1 ] ) ; sysfatal ( "exec:<S2SV_blank>%r" ) ; } exits ( 0 ) ; } | <S2SV_ModStart> mntflags |= MCREATE <S2SV_ModEnd> ; break ; |
2,731 | CWE-000 <S2SV_StartBug> void parallelize_force_array ( MPI_Comm mcw , int world_rank , int world_size , int n , double * F ) <S2SV_EndBug> { int i , j , k , max = getMax ( world_size ) , receiver , sender , tag = 0 ; <S2SV_StartBug> double * buffer = ( double * ) calloc ( n , sizeof ( double ) ) ; <S2SV_EndBug> MPI_Status status ; for ( i = 1 , j = 2 ; j <= max ; i *= 2 , j *= 2 ) { if ( ( world_rank % j ) == i ) { receiver = world_rank - i ; MPI_Send ( F , n , <S2SV_StartBug> MPI_DOUBLE , <S2SV_EndBug> receiver , tag , mcw ) ; } else if ( ( world_rank % j ) == 0 ) { sender = world_rank + i ; if ( sender < world_size ) { MPI_Recv ( buffer , n , <S2SV_StartBug> MPI_DOUBLE , <S2SV_EndBug> sender , MPI_ANY_TAG , mcw , & status ) ; for ( k = 0 ; k < n ; k ++ ) { F [ k ] += buffer [ k ] ; } } } } return ; } | <S2SV_ModStart> int n , long <S2SV_ModStart> = 0 ; long <S2SV_ModStart> buffer = ( long <S2SV_ModStart> , sizeof ( long <S2SV_ModStart> , n , MPI_LONG_DOUBLE <S2SV_ModEnd> , receiver , <S2SV_ModStart> , n , MPI_LONG_DOUBLE <S2SV_ModEnd> , sender , |
2,732 | CWE-000 int main ( ) { Board board ; char str [ 8192 ] ; int megabytes = 16 ; int nthreads = 1 ; Thread * threads = createThreadPool ( nthreads ) ; initializeMagics ( ) ; initializeZorbist ( ) ; initializePSQT ( ) ; initializeMasks ( ) ; initializeBoard ( & board , "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR<S2SV_blank>w<S2SV_blank>KQkq<S2SV_blank>-<S2SV_blank>0<S2SV_blank>1" ) ; initializeTranspositionTable ( & Table , megabytes ) ; # ifdef TUNE runTexelTuning ( threads ) ; exit ( 0 ) ; # endif while ( 1 ) { getInput ( str ) ; if ( stringEquals ( str , "uci" ) ) { <S2SV_StartBug> printf ( "id<S2SV_blank>name<S2SV_blank>Ethereal<S2SV_blank>9.04\\n" ) ; <S2SV_EndBug> printf ( "id<S2SV_blank>author<S2SV_blank>Andrew<S2SV_blank>Grant\\n" ) ; printf ( "option<S2SV_blank>name<S2SV_blank>Hash<S2SV_blank>type<S2SV_blank>spin<S2SV_blank>default<S2SV_blank>16<S2SV_blank>min<S2SV_blank>1<S2SV_blank>max<S2SV_blank>65536\\n" ) ; printf ( "option<S2SV_blank>name<S2SV_blank>Threads<S2SV_blank>type<S2SV_blank>spin<S2SV_blank>default<S2SV_blank>1<S2SV_blank>min<S2SV_blank>1<S2SV_blank>max<S2SV_blank>2048\\n" ) ; printf ( "uciok\\n" ) ; fflush ( stdout ) ; } else if ( stringEquals ( str , "isready" ) ) { printf ( "readyok\\n" ) ; fflush ( stdout ) ; } else if ( stringStartsWith ( str , "setoption" ) ) { if ( stringStartsWith ( str , "setoption<S2SV_blank>name<S2SV_blank>Hash<S2SV_blank>value" ) ) { megabytes = atoi ( str + strlen ( "setoption<S2SV_blank>name<S2SV_blank>Hash<S2SV_blank>value" ) ) ; destroyTranspositionTable ( & Table ) ; initializeTranspositionTable ( & Table , megabytes ) ; } if ( stringStartsWith ( str , "setoption<S2SV_blank>name<S2SV_blank>Threads<S2SV_blank>value" ) ) { free ( threads ) ; nthreads = atoi ( str + strlen ( "setoption<S2SV_blank>name<S2SV_blank>Threads<S2SV_blank>value" ) ) ; threads = createThreadPool ( nthreads ) ; } } else if ( stringEquals ( str , "ucinewgame" ) ) { resetThreadPool ( threads ) ; clearTranspositionTable ( & Table ) ; } else if ( stringStartsWith ( str , "position" ) ) uciPosition ( str , & board ) ; else if ( stringStartsWith ( str , "go" ) ) uciGo ( str , threads , & board ) ; else if ( stringEquals ( str , "quit" ) ) break ; else if ( stringStartsWith ( str , "perft" ) ) { printf ( "%" PRIu64 "\\n" , perft ( & board , atoi ( str + strlen ( "perft<S2SV_blank>" ) ) ) ) ; fflush ( stdout ) ; } else if ( stringStartsWith ( str , "bench" ) ) runBenchmark ( threads , atoi ( str + strlen ( "bench<S2SV_blank>" ) ) ) ; } return 1 ; } | <S2SV_ModStart> { printf ( "id<S2SV_blank>name<S2SV_blank>Ethereal<S2SV_blank>9.05\\n" <S2SV_ModEnd> ) ; printf |
2,733 | CWE-000 static int mpd_command_playlistadd ( struct evbuffer * evbuf , int argc , char * * argv , char * * errmsg ) { char * vp_playlist ; char * vp_item ; int ret ; if ( argc < 3 ) { <S2SV_StartBug> * errmsg = string_printf ( "Missing<S2SV_blank>argument<S2SV_blank>for<S2SV_blank>command<S2SV_blank>\'playlistadd\'" ) ; <S2SV_EndBug> return ACK_ERROR_ARG ; } if ( ! default_pl_dir || strstr ( argv [ 1 ] , ":/" ) ) { vp_playlist = prepend_slash ( argv [ 1 ] ) ; } else { <S2SV_StartBug> vp_playlist = string_printf ( "%s/%s" , default_pl_dir , argv [ 1 ] ) ; <S2SV_EndBug> } vp_item = prepend_slash ( argv [ 2 ] ) ; ret = library_playlist_add ( vp_playlist , vp_item ) ; free ( vp_playlist ) ; free ( vp_item ) ; if ( ret < 0 ) { <S2SV_StartBug> * errmsg = string_printf ( "Error<S2SV_blank>saving<S2SV_blank>queue<S2SV_blank>to<S2SV_blank>file<S2SV_blank>\'%s\'" , argv [ 1 ] ) ; <S2SV_EndBug> return ACK_ERROR_ARG ; } return 0 ; } | <S2SV_ModStart> * errmsg = safe_asprintf <S2SV_ModEnd> ( "Missing<S2SV_blank>argument<S2SV_blank>for<S2SV_blank>command<S2SV_blank>\'playlistadd\'" ) <S2SV_ModStart> { vp_playlist = safe_asprintf <S2SV_ModEnd> ( "%s/%s" , <S2SV_ModStart> * errmsg = safe_asprintf <S2SV_ModEnd> ( "Error<S2SV_blank>saving<S2SV_blank>queue<S2SV_blank>to<S2SV_blank>file<S2SV_blank>\'%s\'" , |
2,734 | CWE-000 PHP_FUNCTION ( apcu_fetch ) { zval * key ; zval * success = NULL ; time_t t ; if ( ! APCG ( enabled ) ) { RETURN_FALSE ; } if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) , "z|z" , & key , & success ) == FAILURE ) { return ; } t = apc_time ( ) ; if ( success ) { ZVAL_DEREF ( success ) ; zval_ptr_dtor ( success ) ; ZVAL_FALSE ( success ) ; } if ( Z_TYPE_P ( key ) != IS_STRING && Z_TYPE_P ( key ) != IS_ARRAY ) { convert_to_string ( key ) ; } if ( Z_TYPE_P ( key ) == IS_ARRAY || ( Z_TYPE_P ( key ) == IS_STRING && Z_STRLEN_P ( key ) > 0 ) ) { if ( Z_TYPE_P ( key ) == IS_STRING ) { if ( apc_cache_fetch ( apc_user_cache , Z_STR_P ( key ) , t , & return_value ) ) { if ( success ) { ZVAL_TRUE ( success ) ; } } else { ZVAL_BOOL ( return_value , 0 ) ; } } else if ( Z_TYPE_P ( key ) == IS_ARRAY ) { HashPosition hpos ; zval * hentry ; zval result ; array_init ( & result ) ; zend_hash_internal_pointer_reset_ex ( Z_ARRVAL_P ( key ) , & hpos ) ; while ( ( hentry = zend_hash_get_current_data_ex ( Z_ARRVAL_P ( key ) , & hpos ) ) ) { ZVAL_DEREF ( hentry ) ; if ( Z_TYPE_P ( hentry ) == IS_STRING ) { zval result_entry , * iresult = & result_entry ; ZVAL_UNDEF ( iresult ) ; if ( apc_cache_fetch ( apc_user_cache , Z_STR_P ( hentry ) , t , & iresult ) ) { <S2SV_StartBug> add_assoc_zval ( & result , Z_STRVAL_P ( hentry ) , & result_entry ) ; <S2SV_EndBug> } } else { apc_warning ( "apc_fetch()<S2SV_blank>expects<S2SV_blank>a<S2SV_blank>string<S2SV_blank>or<S2SV_blank>array<S2SV_blank>of<S2SV_blank>strings." ) ; } zend_hash_move_forward_ex ( Z_ARRVAL_P ( key ) , & hpos ) ; } RETVAL_ZVAL ( & result , 0 , 1 ) ; if ( success ) { ZVAL_TRUE ( success ) ; } } } else { apc_warning ( "apc_fetch()<S2SV_blank>expects<S2SV_blank>a<S2SV_blank>string<S2SV_blank>or<S2SV_blank>array<S2SV_blank>of<S2SV_blank>strings." ) ; RETURN_FALSE ; } return ; } | <S2SV_ModStart> ) ) { zend_symtable_update ( Z_ARRVAL ( result ) , Z_STR_P <S2SV_ModEnd> ( hentry ) |
2,735 | CWE-000 void status_deinit ( void ) { APP_ENABLE ( false ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> false ) ; event_removeListener ( & EVENT_TIMER_1_HZ , & callback ) ; |
2,736 | CWE-000 cavelist * getCaves ( compound_file * cf ) { cavelist * cl = malloc ( sizeof ( cavelist ) ) ; if ( ! cl ) return NULL ; cavelist * current_cl = cl ; short injectState = INJECT_STATE_NONE ; off_t i = 0 ; for ( ; i < cf -> size ; i ++ ) { if ( cf -> buffer [ i ] == 0 && injectState == INJECT_STATE_NONE ) { current_cl -> start = i ; injectState = INJECT_STATE_PARSING ; } <S2SV_StartBug> else if ( cf -> buffer [ i ] != 0 && injectState == INJECT_STATE_PARSING && injectState ) { <S2SV_EndBug> current_cl -> end = i ; current_cl -> next = malloc ( sizeof ( cavelist ) ) ; if ( ! current_cl -> next ) break ; current_cl = current_cl -> next ; injectState = INJECT_STATE_NONE ; } } if ( injectState == INJECT_STATE_PARSING ) current_cl -> end = i ; <S2SV_StartBug> return cl ; <S2SV_EndBug> } | <S2SV_ModStart> injectState == INJECT_STATE_PARSING <S2SV_ModEnd> ) { current_cl <S2SV_ModStart> = i ; current_cl -> next = NULL ; |
2,737 | CWE-000 void free ( void * pBlock ) { <S2SV_StartBug> vPortFree ( pBlock ) ; <S2SV_EndBug> <S2SV_StartBug> __asm volatile ( "dsb" : : : "memory" ) ; <S2SV_EndBug> __asm volatile ( "dmb" : : : "memory" ) ; __asm volatile ( "cpsie<S2SV_blank>i" : : : "memory" ) ; } | <S2SV_ModStart> pBlock ) { uspi_EnterCritical ( ) ; <S2SV_ModStart> pBlock ) ; uspi_LeaveCritical ( <S2SV_ModEnd> ) ; } |
2,738 | CWE-000 <S2SV_StartBug> int main ( void ) { <S2SV_EndBug> handle_init ( ) ; app_event_loop ( ) ; handle_deinit ( ) ; } | <S2SV_ModStart> void ) { tens_hour_Xpos = TENS_HOUR_ZERO_ZERO ; ones_hour_Xpos = 9 ; long_minutes_offset = 81 ; short_minutes_offset = 113 ; |
2,739 | CWE-000 void do_cursorpos ( bool force ) { char saved_byte ; size_t sum , cur_xpt = xplustabs ( ) + 1 ; size_t cur_lenpt = strlenpt ( openfile -> current -> data ) + 1 ; int linepct , colpct , charpct ; if ( suppress_cursorpos && ! force ) { suppress_cursorpos = FALSE ; return ; } <S2SV_StartBug> curs_set ( 0 ) ; <S2SV_EndBug> saved_byte = openfile -> current -> data [ openfile -> current_x ] ; openfile -> current -> data [ openfile -> current_x ] = '\\0' ; sum = get_totsize ( openfile -> fileage , openfile -> current ) ; openfile -> current -> data [ openfile -> current_x ] = saved_byte ; if ( openfile -> current != openfile -> filebot ) sum -- ; linepct = 100 * openfile -> current -> lineno / openfile -> filebot -> lineno ; colpct = 100 * cur_xpt / cur_lenpt ; charpct = ( openfile -> totsize == 0 ) ? 0 : 100 * sum / openfile -> totsize ; statusline ( HUSH , _ ( "line<S2SV_blank>%ld/%ld<S2SV_blank>(%d%%),<S2SV_blank>col<S2SV_blank>%lu/%lu<S2SV_blank>(%d%%),<S2SV_blank>char<S2SV_blank>%lu/%lu<S2SV_blank>(%d%%)" ) , ( long ) openfile -> current -> lineno , ( long ) openfile -> filebot -> lineno , linepct , ( unsigned long ) cur_xpt , ( unsigned long ) cur_lenpt , colpct , ( unsigned long ) sum , ( unsigned long ) openfile -> totsize , charpct ) ; suppress_cursorpos = FALSE ; } | <S2SV_ModStart> return ; } <S2SV_ModEnd> saved_byte = openfile |
2,740 | CWE-000 static int prefix_LRE ( struct ccw1 * ccw , struct PFX_eckd_data * pfxdata , unsigned int trk , unsigned int totrk , int cmd , struct dasd_device * basedev , struct dasd_device * startdev , unsigned int format , unsigned int rec_on_trk , int count , unsigned int blksize , unsigned int tlf ) { struct dasd_eckd_private * basepriv , * startpriv ; struct LRE_eckd_data * lredata ; struct DE_eckd_data * dedata ; int rc = 0 ; basepriv = basedev -> private ; startpriv = startdev -> private ; dedata = & pfxdata -> define_extent ; lredata = & pfxdata -> locate_record ; ccw -> cmd_code = DASD_ECKD_CCW_PFX ; ccw -> flags = 0 ; if ( cmd == DASD_ECKD_CCW_WRITE_FULL_TRACK ) { ccw -> count = sizeof ( * pfxdata ) + 2 ; ccw -> cda = ( __u32 ) __pa ( pfxdata ) ; memset ( pfxdata , 0 , sizeof ( * pfxdata ) + 2 ) ; } else { ccw -> count = sizeof ( * pfxdata ) ; ccw -> cda = ( __u32 ) __pa ( pfxdata ) ; memset ( pfxdata , 0 , sizeof ( * pfxdata ) ) ; } if ( format > 1 ) { DBF_DEV_EVENT ( DBF_ERR , basedev , "PFX<S2SV_blank>LRE<S2SV_blank>unknown<S2SV_blank>format<S2SV_blank>0x%x" , format ) ; BUG ( ) ; return - EINVAL ; } pfxdata -> format = format ; pfxdata -> base_address = basepriv -> ned -> unit_addr ; pfxdata -> base_lss = basepriv -> ned -> ID ; pfxdata -> validity . define_extent = 1 ; <S2SV_StartBug> if ( startpriv -> uid . type != UA_BASE_DEVICE ) { <S2SV_EndBug> pfxdata -> validity . verify_base = 1 ; <S2SV_StartBug> if ( startpriv -> uid . type == UA_HYPER_PAV_ALIAS ) <S2SV_EndBug> pfxdata -> validity . hyper_pav = 1 ; } rc = define_extent ( NULL , dedata , trk , totrk , cmd , basedev , blksize ) ; if ( dedata -> ga_extended & 0x08 && dedata -> ga_extended & 0x02 ) pfxdata -> validity . time_stamp = 1 ; if ( format == 1 ) { locate_record_ext ( NULL , lredata , trk , rec_on_trk , count , cmd , basedev , blksize , tlf ) ; } return rc ; } | <S2SV_ModStart> uid . type == UA_BASE_PAV_ALIAS ) <S2SV_ModEnd> pfxdata -> validity <S2SV_ModStart> == UA_HYPER_PAV_ALIAS ) { pfxdata -> validity . verify_base = 1 ; |
2,741 | CWE-000 static void iwl_trans_pcie_stop_device ( struct iwl_trans * trans , bool low_power ) { struct iwl_trans_pcie * trans_pcie = IWL_TRANS_GET_PCIE_TRANS ( trans ) ; <S2SV_StartBug> mutex_lock ( & trans_pcie -> mutex ) ; <S2SV_EndBug> <S2SV_StartBug> _iwl_trans_pcie_stop_device ( trans , low_power ) ; <S2SV_EndBug> mutex_unlock ( & trans_pcie -> mutex ) ; } | <S2SV_ModStart> trans ) ; bool was_in_rfkill ; <S2SV_ModStart> mutex ) ; trans_pcie -> opmode_down = true ; was_in_rfkill = test_bit ( STATUS_RFKILL_OPMODE , & trans -> status ) ; <S2SV_ModStart> trans , low_power ) ; iwl_trans_pcie_handle_stop_rfkill ( trans , was_in_rfkill |
2,742 | CWE-000 static ngx_int_t ngx_http_client_recv ( ngx_http_conf_client * client , char * * data , int size ) { <S2SV_StartBug> ssize_t recv_num = 0 , tmp_recv = 0 ; <S2SV_EndBug> char buff [ ngx_pagesize ] ; <S2SV_StartBug> char * tmp_data ; <S2SV_EndBug> ngx_int_t page_count = 0 ; * data = NULL ; while ( recv_num < size || size == 0 ) { tmp_recv = recv ( client -> sd , buff , ngx_pagesize , 0 ) ; if ( tmp_recv <= 0 ) { break ; } recv_num += tmp_recv ; if ( * data == NULL ) { * data = ( char * ) ngx_calloc ( ngx_pagesize , ngx_cycle -> log ) ; if ( * data == NULL ) { return NGX_ERROR ; } page_count ++ ; } if ( recv_num >= ( ssize_t ) ( page_count * ngx_pagesize ) ) { tmp_data = * data ; page_count ++ ; * data = ( char * ) ngx_calloc ( page_count * ngx_pagesize , ngx_cycle -> log ) ; if ( * data == NULL ) { return NGX_ERROR ; } ngx_memcpy ( * data , tmp_data , recv_num - tmp_recv ) ; ngx_free ( tmp_data ) ; } ngx_memcpy ( * data + recv_num - tmp_recv , buff , tmp_recv ) ; } if ( * data != NULL ) { * ( * data + recv_num ) = '\\0' ; } return recv_num ; } | <S2SV_ModStart> size ) { char * tmp_data <S2SV_ModEnd> ; char buff <S2SV_ModStart> ngx_pagesize ] ; ssize_t recv_num = 0 , tmp_recv = 0 <S2SV_ModEnd> ; ngx_int_t page_count |
2,743 | CWE-000 static void update_stream ( stream_t * stream ) { void * buffer ; <S2SV_StartBug> if ( stream -> feed_size <= stream -> fragment_size ) return ; <S2SV_EndBug> if ( ! ( buffer = al_get_audio_stream_fragment ( stream -> ptr ) ) ) return ; memcpy ( buffer , stream -> buffer , stream -> fragment_size ) ; stream -> feed_size -= stream -> fragment_size ; memmove ( stream -> buffer , stream -> buffer + stream -> fragment_size , stream -> feed_size ) ; al_set_audio_stream_fragment ( stream -> ptr , buffer ) ; } | <S2SV_ModStart> stream -> feed_size < <S2SV_ModEnd> stream -> fragment_size |
2,744 | CWE-000 void carrotos_armcm3_update_wallclock ( void ) { <S2SV_StartBug> struct carrotos_target_CPU * cpu - carrotos_current_cpu ( ) ; <S2SV_EndBug> int flags = carrotos_armcm3_save_irq ( ) ; uint32_t x = armcm3_systick_current_value ( ) ; carrotos_armcm3_fix_rtc ( x ) ; if ( x > cpu -> systick_last_val ) cpu -> systick_flags |= IGNORE_NEXT_SYSTICK_IRQ ; cpu -> systick_last_val = x ; carrotos_armcm3_restore_irq ( flags ) ; } | <S2SV_ModStart> ) { struct carrotos_armcm3_CPU * cpu = <S2SV_ModEnd> carrotos_current_cpu ( ) |
2,745 | CWE-000 bool cons_to_bool ( Cons * cons ) { Cons * truth = cons_from_string ( "#t" ) ; if ( cons_equal ( cons , truth ) ) { <S2SV_StartBug> destroy_cons ( truth ) ; <S2SV_EndBug> return true ; } <S2SV_StartBug> destroy_cons ( truth ) ; <S2SV_EndBug> return false ; } | <S2SV_ModStart> ) ) { cons_destroy <S2SV_ModEnd> ( truth ) <S2SV_ModStart> true ; } cons_destroy <S2SV_ModEnd> ( truth ) |
2,746 | CWE-000 static inline int wv_get_value_integer ( WavpackFrameContext * s , uint32_t * crc , int S ) { <S2SV_StartBug> int bit ; <S2SV_EndBug> if ( s -> extra_bits ) { S <<= s -> extra_bits ; if ( s -> got_extra_bits && get_bits_left ( & s -> gb_extra_bits ) >= s -> extra_bits ) { S |= get_bits_long ( & s -> gb_extra_bits , s -> extra_bits ) ; * crc = * crc * 9 + ( S & 0xffff ) * 3 + ( ( unsigned ) S >> 16 ) ; } } bit = ( S & s -> and ) | s -> or ; bit = ( ( S + bit ) << s -> shift ) - bit ; if ( s -> hybrid ) bit = av_clip ( bit , s -> hybrid_minclip , s -> hybrid_maxclip ) ; return bit << s -> post_shift ; } | <S2SV_ModStart> S ) { unsigned <S2SV_ModEnd> bit ; if |
2,747 | CWE-000 void <S2SV_StartBug> get_co ( double freq , double dfreq , const double T0 , const double m , <S2SV_EndBug> const size_t Ntk , const double * T , const double * k , const size_t N , double * * A , double * * B , double * * C , double * * D ) { * A = malloc_array ( N + 1 ) ; * B = malloc_array ( N + 1 ) ; * C = malloc_array ( N + 1 ) ; * D = malloc_array ( N + 1 ) ; <S2SV_StartBug> double h = 1. / N ; <S2SV_EndBug> double r3h = 3. * Ra * Ra * h * h ; double t00 = temper ( 0. , T0 , m ) , t01 = temper ( h / 2. , T0 , m ) , tN1 = temper ( 1. - h / 2. , T0 , m ) , tN0 = temper ( 1. , T0 , m ) ; double k00 = interp_log ( t00 , Ntk , T , k ) , k01 = interp_log ( t01 , Ntk , T , k ) , kN1 = interp_log ( tN1 , Ntk , T , k ) , kN0 = interp_log ( tN1 , Ntk , T , k ) ; double u00 = Up ( t00 , freq , dfreq ) , u01 = Up ( t01 , freq , dfreq ) , uN1 = Up ( tN1 , freq , dfreq ) , uN0 = Up ( tN0 , freq , dfreq ) ; for ( int j = 1 ; j <= N ; j ++ ) { double xf = j * h - h / 2. ; double tf = temper ( xf , T0 , m ) ; double kf = interp_log ( tf , Ntk , T , k ) ; ( * A ) [ j ] = xf / kf ; ( * C ) [ j - 1 ] = ( * A ) [ j ] ; } for ( int j = 1 ; j < N ; j ++ ) { double xf = j * h ; double tf = temper ( xf , T0 , m ) ; double kf = interp_log ( tf , Ntk , T , k ) ; ( * B ) [ j ] = ( * A ) [ j ] + ( * C ) [ j ] + r3h * xf * kf ; double Uf = Up ( tf , freq , dfreq ) ; ( * D ) [ j ] = r3h * xf * kf * Uf ; } ( * A ) [ 0 ] = 0. ; ( * C ) [ 0 ] = 8. / ( r3h * k01 ) - k01 / 2. ; ( * B ) [ 0 ] = ( * A ) [ 0 ] + ( * C ) [ 0 ] + k00 + k01 ; ( * D ) [ 0 ] = k00 * u00 + k01 * u01 ; double alpha = r3h * ( 2. - h / 2. ) ; double beta = Ra * h * ( 2. - h / 2. ) ; ( * A ) [ N ] = 8. * ( 1. - h / 2. ) / ( alpha * kN1 ) - kN1 / 2. ; ( * C ) [ N ] = 0. ; ( * B ) [ N ] = ( * A ) [ N ] + ( * C ) [ N ] + kN0 + kN1 + ( 4. * mN ) / beta ; ( * D ) [ N ] = kN1 * uN1 + kN0 * uN0 ; } | <S2SV_ModStart> const double m , const double radius <S2SV_ModStart> ) ; double Ra = radius ; double |
2,748 | CWE-000 int uvl_input ( uvl_t * handle , const uv_buf_t buf ) { struct pbuf * p = pbuf_alloc ( PBUF_RAW , buf . len , PBUF_POOL ) ; if ( ! p ) { LLOG ( LLOG_WARNING , "device<S2SV_blank>read:<S2SV_blank>pbuf_alloc<S2SV_blank>failed" ) ; return - 1 ; } if ( pbuf_take ( p , buf . base , buf . len ) != ERR_OK ) { LLOG ( LLOG_ERROR , "pbuf_take" ) ; return - 1 ; } struct uvl_input_req * input = ( struct uvl_input_req * ) malloc ( sizeof ( struct uvl_input_req ) ) ; int ret ; <S2SV_StartBug> if ( input == NULL ) goto fail_malloc ; <S2SV_EndBug> ret = uv_async_init ( handle -> loop , & input -> async , uvl_async_input_cb ) ; <S2SV_StartBug> if ( ret ) goto fail ; <S2SV_EndBug> input -> async . data = handle ; ret = uv_async_send ( & input -> async ) ; <S2SV_StartBug> if ( ret ) goto fail ; <S2SV_EndBug> input -> p = p ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> fail : <S2SV_StartBug> free ( input ) ; <S2SV_EndBug> fail_malloc : return - 1 ; } | <S2SV_ModStart> NULL ) goto fail ; input -> async . data = handle ; input -> p = p <S2SV_ModEnd> ; ret = <S2SV_ModStart> ret ) goto fail_free <S2SV_ModEnd> ; ret = <S2SV_ModStart> ret ) goto fail_close <S2SV_ModEnd> ; return 0 <S2SV_ModStart> ; return 0 ; fail_close : uv_close ( ( uv_handle_t * ) & input -> async , uvl_async_input_close_cb ) ; fail_free : free ( input ) <S2SV_ModStart> ; fail : <S2SV_ModEnd> return - 1 |
2,749 | CWE-000 StrMapIterator * SMI_Create ( MapStrToPtr * pTable ) { <S2SV_StartBug> StrMapIterator * pIter = ( StrMapIterator * ) malloc ( sizeof ( StrMapIterator ) ) ; <S2SV_EndBug> if ( pTable == NULL ) { fprintf ( stderr , "Table<S2SV_blank>is<S2SV_blank>NULL" ) ; return NULL ; <S2SV_StartBug> } <S2SV_EndBug> pIter -> m_pTable = pTable ; pIter -> m_Index = 0 ; pIter -> m_ListPos = NULL ; return pIter ; } | <S2SV_ModStart> StrMapIterator * pIter <S2SV_ModEnd> ; if ( <S2SV_ModStart> NULL ; } pIter = ( StrMapIterator * ) malloc ( sizeof ( StrMapIterator ) ) ; |
2,750 | CWE-000 apr_status_t md_reg_sync ( md_reg_t * reg , apr_pool_t * p , apr_pool_t * ptemp , apr_array_header_t * master_mds , int can_http , int can_https ) { sync_ctx ctx ; md_store_t * store = reg -> store ; apr_status_t rv ; if ( APR_SUCCESS != ( rv = sync_props ( reg , ptemp , can_http , can_https ) ) ) { reg -> was_synched = 0 ; return rv ; } reg -> was_synched = 1 ; ctx . p = ptemp ; ctx . conf_mds = master_mds ; ctx . store_mds = apr_array_make ( ptemp , 100 , sizeof ( md_t * ) ) ; rv = md_store_md_iter ( find_changes , & ctx , store , ptemp , MD_SG_DOMAINS , "*" ) ; if ( APR_STATUS_IS_ENOENT ( rv ) ) { rv = APR_SUCCESS ; } md_log_perror ( MD_LOG_MARK , MD_LOG_DEBUG , rv , p , "sync:<S2SV_blank>found<S2SV_blank>%d<S2SV_blank>mds<S2SV_blank>in<S2SV_blank>store" , ctx . store_mds -> nelts ) ; if ( APR_SUCCESS == rv ) { int i , fields ; md_t * md , * config_md , * smd , * omd ; const char * common ; for ( i = 0 ; i < ctx . conf_mds -> nelts ; ++ i ) { md = APR_ARRAY_IDX ( ctx . conf_mds , i , md_t * ) ; smd = md_find_closest_match ( ctx . store_mds , md ) ; if ( smd ) { fields = 0 ; if ( strcmp ( md -> name , smd -> name ) ) { md -> name = apr_pstrdup ( p , smd -> name ) ; } if ( ! md_equal_domains ( md , smd , 1 ) ) { md_log_perror ( MD_LOG_MARK , MD_LOG_DEBUG , rv , p , "%s:<S2SV_blank>%d<S2SV_blank>domains<S2SV_blank>changed" , smd -> name ) ; smd -> domains = md_array_str_clone ( ptemp , md -> domains ) ; fields |= MD_UPD_DOMAINS ; } while ( APR_SUCCESS == rv && ( omd = md_get_by_dns_overlap ( ctx . store_mds , md ) ) ) { common = md_common_name ( md , omd ) ; assert ( common ) ; config_md = md_get_by_name ( ctx . conf_mds , omd -> name ) ; if ( config_md && md_contains ( config_md , common , 0 ) ) { rv = APR_EINVAL ; md_log_perror ( MD_LOG_MARK , MD_LOG_ERR , rv , p , "domain<S2SV_blank>%s<S2SV_blank>used<S2SV_blank>in<S2SV_blank>md<S2SV_blank>%s<S2SV_blank>and<S2SV_blank>%s" , common , md -> name , omd -> name ) ; } else if ( config_md ) { omd -> domains = md_array_str_remove ( ptemp , omd -> domains , common , 0 ) ; rv = md_reg_update ( reg , ptemp , omd -> name , omd , MD_UPD_DOMAINS ) ; } else { omd -> domains = md_array_str_remove ( ptemp , omd -> domains , common , 0 ) ; md_log_perror ( MD_LOG_MARK , MD_LOG_WARNING , rv , p , "domain<S2SV_blank>%s,<S2SV_blank>configured<S2SV_blank>in<S2SV_blank>md<S2SV_blank>%s,<S2SV_blank>is<S2SV_blank>part<S2SV_blank>of<S2SV_blank>the<S2SV_blank>stored<S2SV_blank>md<S2SV_blank>%s." "<S2SV_blank>That<S2SV_blank>md<S2SV_blank>however<S2SV_blank>is<S2SV_blank>no<S2SV_blank>longer<S2SV_blank>mentioned<S2SV_blank>in<S2SV_blank>the<S2SV_blank>config.<S2SV_blank>" "If<S2SV_blank>you<S2SV_blank>longer<S2SV_blank>want<S2SV_blank>it,<S2SV_blank>remove<S2SV_blank>the<S2SV_blank>md<S2SV_blank>from<S2SV_blank>the<S2SV_blank>store." , common , md -> name , omd -> name ) ; } } if ( MD_SVAL_UPDATE ( md , smd , ca_url ) ) { smd -> ca_url = md -> ca_url ; fields |= MD_UPD_CA_URL ; } if ( MD_SVAL_UPDATE ( md , smd , ca_proto ) ) { smd -> ca_proto = md -> ca_proto ; fields |= MD_UPD_CA_PROTO ; } if ( MD_SVAL_UPDATE ( md , smd , ca_agreement ) ) { smd -> ca_agreement = md -> ca_agreement ; fields |= MD_UPD_AGREEMENT ; } if ( MD_VAL_UPDATE ( md , smd , drive_mode ) ) { smd -> drive_mode = md -> drive_mode ; fields |= MD_UPD_DRIVE_MODE ; } if ( ! apr_is_empty_array ( md -> contacts ) && ! md_array_str_eq ( md -> contacts , smd -> contacts , 0 ) ) { smd -> contacts = md -> contacts ; fields |= MD_UPD_CONTACTS ; } if ( MD_VAL_UPDATE ( md , smd , renew_window ) || MD_VAL_UPDATE ( md , smd , renew_norm ) ) { md_log_perror ( MD_LOG_MARK , MD_LOG_DEBUG , rv , p , "%s:<S2SV_blank>update<S2SV_blank>renew<S2SV_blank>norm=%ld,<S2SV_blank>window=%ld" , smd -> name , ( long ) md -> renew_norm , ( long ) md -> renew_window ) ; smd -> renew_norm = md -> renew_norm ; smd -> renew_window = md -> renew_window ; fields |= MD_UPD_RENEW_WINDOW ; } if ( md -> ca_challenges ) { md -> ca_challenges = md_array_str_compact ( p , md -> ca_challenges , 0 ) ; if ( ! smd -> ca_challenges || ! md_array_str_eq ( md -> ca_challenges , smd -> ca_challenges , 0 ) ) { smd -> ca_challenges = apr_array_copy ( ptemp , md -> ca_challenges ) ; fields |= MD_UPD_CA_CHALLENGES ; } } else if ( smd -> ca_challenges ) { smd -> ca_challenges = NULL ; fields |= MD_UPD_CA_CHALLENGES ; } <S2SV_StartBug> if ( fields ) { <S2SV_EndBug> rv = md_reg_update ( reg , ptemp , smd -> name , smd , fields ) ; md_log_perror ( MD_LOG_MARK , MD_LOG_DEBUG , rv , p , "md<S2SV_blank>%s<S2SV_blank>updated" , smd -> name ) ; } } else { rv = md_reg_add ( reg , md , ptemp ) ; md_log_perror ( MD_LOG_MARK , MD_LOG_DEBUG , rv , p , "new<S2SV_blank>md<S2SV_blank>%s<S2SV_blank>added" , md -> name ) ; } } } else { md_log_perror ( MD_LOG_MARK , MD_LOG_ERR , rv , p , "loading<S2SV_blank>mds" ) ; } return rv ; } | <S2SV_ModStart> } if ( ! md_pkey_spec_eq ( md -> pkey_spec , smd -> pkey_spec ) ) { fields |= MD_UPD_PKEY_SPEC ; smd -> pkey_spec = NULL ; if ( md -> pkey_spec ) { smd -> pkey_spec = apr_pmemdup ( p , md -> pkey_spec , sizeof ( md_pkey_spec_t ) ) ; } } if ( |
2,751 | CWE-000 static irqreturn_t stmpe_ts_handler ( int irq , void * data ) { u8 data_set [ 4 ] ; int x , y , z ; struct stmpe_touch * ts = data ; cancel_delayed_work_sync ( & ts -> work ) ; stmpe_set_bits ( ts -> stmpe , STMPE_REG_TSC_CTRL , STMPE_TSC_CTRL_TSC_EN , 0 ) ; stmpe_block_read ( ts -> stmpe , STMPE_REG_TSC_DATA_XYZ , 4 , data_set ) ; x = ( data_set [ 0 ] << 4 ) | ( data_set [ 1 ] >> 4 ) ; y = ( ( data_set [ 1 ] & 0xf ) << 8 ) | data_set [ 2 ] ; z = data_set [ 3 ] ; <S2SV_StartBug> input_report_abs ( ts -> idev , ABS_X , x ) ; <S2SV_EndBug> input_report_abs ( ts -> idev , ABS_Y , y ) ; input_report_abs ( ts -> idev , ABS_PRESSURE , z ) ; input_report_key ( ts -> idev , BTN_TOUCH , 1 ) ; input_sync ( ts -> idev ) ; __stmpe_reset_fifo ( ts -> stmpe ) ; stmpe_set_bits ( ts -> stmpe , STMPE_REG_TSC_CTRL , STMPE_TSC_CTRL_TSC_EN , STMPE_TSC_CTRL_TSC_EN ) ; schedule_delayed_work ( & ts -> work , msecs_to_jiffies ( 50 ) ) ; return IRQ_HANDLED ; } | <S2SV_ModStart> 3 ] ; calibration_pointer ( & x , & y ) ; |
2,752 | CWE-000 void save_restriction_restore ( Lisp_Object data ) { struct buffer * cur = NULL ; struct buffer * buf = ( CONSP ( data ) ? XMARKER ( XCAR ( data ) ) -> buffer : XBUFFER ( data ) ) ; if ( buf && buf != current_buffer && ! NILP ( BVAR ( buf , pt_marker ) ) ) { cur = current_buffer ; set_buffer_internal ( buf ) ; } if ( CONSP ( data ) ) { struct Lisp_Marker * beg = XMARKER ( XCAR ( data ) ) ; struct Lisp_Marker * end = XMARKER ( XCDR ( data ) ) ; eassert ( buf == end -> buffer ) ; if ( buf && ( beg -> charpos != BUF_BEGV ( buf ) || end -> charpos != BUF_ZV ( buf ) ) ) { ptrdiff_t pt = BUF_PT ( buf ) ; SET_BUF_BEGV_BOTH ( buf , beg -> charpos , beg -> bytepos ) ; SET_BUF_ZV_BOTH ( buf , end -> charpos , end -> bytepos ) ; if ( pt < beg -> charpos || pt > end -> charpos ) SET_BUF_PT_BOTH ( buf , clip_to_bounds ( beg -> charpos , pt , end -> charpos ) , clip_to_bounds ( beg -> bytepos , BUF_PT_BYTE ( buf ) , end -> bytepos ) ) ; buf -> clip_changed = 1 ; } <S2SV_StartBug> free_cons ( XCONS ( data ) ) ; <S2SV_EndBug> } else { if ( buf && ( BUF_BEGV ( buf ) != BUF_BEG ( buf ) || BUF_ZV ( buf ) != BUF_Z ( buf ) ) ) { SET_BUF_BEGV_BOTH ( buf , BUF_BEG ( buf ) , BUF_BEG_BYTE ( buf ) ) ; SET_BUF_ZV_BOTH ( buf , BUF_Z ( buf ) , BUF_Z_BYTE ( buf ) ) ; buf -> clip_changed = 1 ; } } invalidate_current_column ( ) ; if ( cur ) set_buffer_internal ( cur ) ; } | <S2SV_ModStart> 1 ; } Fset_marker ( XCAR ( data ) , Qnil , Qnil ) ; Fset_marker ( XCDR ( data ) , Qnil , Qnil ) ; |
2,753 | CWE-000 int perfmon_initialize ( int num_trans ) { int idx = 0 ; int memsize = 0 ; pstat_Global . n_stat_values = 0 ; pstat_Global . global_stats = NULL ; pstat_Global . n_trans = 0 ; pstat_Global . tran_stats = NULL ; pstat_Global . is_watching = NULL ; pstat_Global . n_watchers = 0 ; pstat_Global . initialized = false ; pstat_Global . activation_flag = prm_get_integer_value ( PRM_ID_EXTENDED_STATISTICS_ACTIVATION ) ; pstat_Global . n_stat_values = metadata_initialize ( ) ; # if defined ( SERVER_MODE ) || defined ( SA_MODE ) # if ! defined ( HAVE_ATOMIC_BUILTINS ) ( void ) pthread_mutex_init ( & pstat_Global . watch_lock , NULL ) ; # endif pstat_Global . global_stats = ( UINT64 * ) malloc ( PERFMON_VALUES_MEMSIZE ) ; if ( pstat_Global . global_stats == NULL ) { er_set ( ER_ERROR_SEVERITY , ARG_FILE_LINE , ER_OUT_OF_VIRTUAL_MEMORY , 1 , PERFMON_VALUES_MEMSIZE ) ; goto error ; } memset ( pstat_Global . global_stats , 0 , PERFMON_VALUES_MEMSIZE ) ; assert ( num_trans > 0 ) ; pstat_Global . n_trans = num_trans + 1 ; memsize = pstat_Global . n_trans * sizeof ( UINT64 * ) ; pstat_Global . tran_stats = ( UINT64 * * ) malloc ( memsize ) ; if ( pstat_Global . tran_stats == NULL ) { er_set ( ER_ERROR_SEVERITY , ARG_FILE_LINE , ER_OUT_OF_VIRTUAL_MEMORY , 1 , memsize ) ; goto error ; } memsize = pstat_Global . n_trans * PERFMON_VALUES_MEMSIZE ; pstat_Global . tran_stats [ 0 ] = ( UINT64 * ) malloc ( memsize ) ; if ( pstat_Global . tran_stats [ 0 ] == NULL ) { er_set ( ER_ERROR_SEVERITY , ARG_FILE_LINE , ER_OUT_OF_VIRTUAL_MEMORY , 1 , memsize ) ; goto error ; } memset ( pstat_Global . tran_stats [ 0 ] , 0 , memsize ) ; for ( idx = 1 ; idx < pstat_Global . n_trans ; idx ++ ) { pstat_Global . tran_stats [ idx ] = pstat_Global . tran_stats [ 0 ] + pstat_Global . n_stat_values * idx ; } memsize = pstat_Global . n_trans * sizeof ( bool ) ; pstat_Global . is_watching = ( bool * ) malloc ( memsize ) ; if ( pstat_Global . is_watching == NULL ) { er_set ( ER_ERROR_SEVERITY , ARG_FILE_LINE , ER_OUT_OF_VIRTUAL_MEMORY , 1 , memsize ) ; goto error ; } memset ( pstat_Global . is_watching , 0 , memsize ) ; pstat_Global . n_watchers = 0 ; <S2SV_StartBug> goto exit ; <S2SV_EndBug> error : perfmon_finalize ( ) ; return ER_OUT_OF_VIRTUAL_MEMORY ; <S2SV_StartBug> # endif <S2SV_EndBug> exit : pstat_Global . initialized = true ; return NO_ERROR ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> = 0 ; pstat_Global . initialized = true ; return NO_ERROR <S2SV_ModEnd> ; error : <S2SV_ModStart> ER_OUT_OF_VIRTUAL_MEMORY ; # else <S2SV_ModEnd> pstat_Global . initialized <S2SV_ModStart> return NO_ERROR ; # endif |
2,754 | CWE-000 <S2SV_StartBug> DEFUN ( find , <S2SV_EndBug> find_cmd , "find<S2SV_blank>COMMAND..." , "Find<S2SV_blank>CLI<S2SV_blank>command<S2SV_blank>containing<S2SV_blank>text\\n" "Text<S2SV_blank>to<S2SV_blank>search<S2SV_blank>for\\n" ) { char * text = argv_concat ( argv , argc , 1 ) ; const struct cmd_node * node ; const struct cmd_element * cli ; vector clis ; for ( unsigned int i = 0 ; i < vector_active ( cmdvec ) ; i ++ ) { node = vector_slot ( cmdvec , i ) ; <S2SV_StartBug> if ( ! node ) <S2SV_EndBug> continue ; clis = node -> cmd_vector ; for ( unsigned int j = 0 ; j < vector_active ( clis ) ; j ++ ) { cli = vector_slot ( clis , j ) ; if ( strcasestr ( cli -> string , text ) ) vty_out ( vty , "<S2SV_blank><S2SV_blank>(%s)<S2SV_blank><S2SV_blank>%s\\n" , node_names [ node -> node ] , cli -> string ) ; } } XFREE ( MTYPE_TMP , text ) ; return CMD_SUCCESS ; } | <S2SV_ModStart> <S2SV_null> DEFUN ( no_banner_motd , no_banner_motd_cmd , "no<S2SV_blank>banner<S2SV_blank>motd" , NO_STR "Set<S2SV_blank>banner<S2SV_blank>string\\n" "Strings<S2SV_blank>for<S2SV_blank>motd\\n" ) { host . motd = NULL <S2SV_ModEnd> ; if ( <S2SV_ModStart> ; if ( host . motdfile ) XFREE ( MTYPE_HOST , host . motdfile ) ; host . motdfile = NULL <S2SV_ModEnd> ; return CMD_SUCCESS |
2,755 | CWE-000 SUBREQUEST_FUNC ( mod_cgi_handle_subrequest ) { int status ; plugin_data * p = p_d ; handler_ctx * hctx = con -> plugin_ctx [ p -> id ] ; if ( con -> mode != p -> id ) return HANDLER_GO_ON ; if ( NULL == hctx ) return HANDLER_GO_ON ; # if 0 log_error_write ( srv , __FILE__ , __LINE__ , "sdd" , "subrequest,<S2SV_blank>pid<S2SV_blank>=" , hctx , hctx -> pid ) ; # endif if ( hctx -> pid == 0 ) { if ( ! con -> file_started ) return HANDLER_WAIT_FOR_EVENT ; return HANDLER_FINISHED ; } # ifndef __WIN32 switch ( waitpid ( hctx -> pid , & status , WNOHANG ) ) { case 0 : if ( con -> file_started ) return HANDLER_FINISHED ; return HANDLER_WAIT_FOR_EVENT ; case - 1 : if ( errno == EINTR ) return HANDLER_WAIT_FOR_EVENT ; if ( errno == ECHILD && con -> file_started == 0 ) { return HANDLER_WAIT_FOR_EVENT ; } log_error_write ( srv , __FILE__ , __LINE__ , "ss" , "waitpid<S2SV_blank>failed:<S2SV_blank>" , strerror ( errno ) ) ; con -> mode = DIRECT ; con -> http_status = 500 ; hctx -> pid = 0 ; fdevent_event_del ( srv -> ev , & ( hctx -> fde_ndx ) , hctx -> fd ) ; fdevent_unregister ( srv -> ev , hctx -> fd ) ; if ( close ( hctx -> fd ) ) { log_error_write ( srv , __FILE__ , __LINE__ , "sds" , "cgi<S2SV_blank>close<S2SV_blank>failed<S2SV_blank>" , hctx -> fd , strerror ( errno ) ) ; } cgi_handler_ctx_free ( hctx ) ; con -> plugin_ctx [ p -> id ] = NULL ; return HANDLER_FINISHED ; default : hctx -> pid = 0 ; <S2SV_StartBug> if ( con -> file_started ) return HANDLER_FINISHED ; <S2SV_EndBug> if ( WIFEXITED ( status ) ) { return HANDLER_WAIT_FOR_EVENT ; } log_error_write ( srv , __FILE__ , __LINE__ , "s" , "cgi<S2SV_blank>died<S2SV_blank>?" ) ; con -> http_status = 500 ; con -> mode = DIRECT ; fdevent_event_del ( srv -> ev , & ( hctx -> fde_ndx ) , hctx -> fd ) ; fdevent_unregister ( srv -> ev , hctx -> fd ) ; if ( close ( hctx -> fd ) ) { log_error_write ( srv , __FILE__ , __LINE__ , "sds" , "cgi<S2SV_blank>close<S2SV_blank>failed<S2SV_blank>" , hctx -> fd , strerror ( errno ) ) ; } cgi_handler_ctx_free ( hctx ) ; con -> plugin_ctx [ p -> id ] = NULL ; return HANDLER_FINISHED ; } # else return HANDLER_ERROR ; # endif } | <S2SV_ModStart> ; if ( cgi_demux_response ( srv , hctx ) == FDEVENT_HANDLED_ERROR ) { log_error_write ( srv , __FILE__ , __LINE__ , "s" , "demuxer<S2SV_blank>failed:<S2SV_blank>" ) ; } if ( |
2,756 | CWE-000 static int snd_usb_pcm_prepare ( struct snd_pcm_substream * substream ) { struct snd_pcm_runtime * runtime = substream -> runtime ; struct snd_usb_substream * subs = runtime -> private_data ; struct usb_host_interface * alts ; struct usb_interface * iface ; int ret ; if ( ! subs -> cur_audiofmt ) { snd_printk ( KERN_ERR "usbaudio:<S2SV_blank>no<S2SV_blank>format<S2SV_blank>is<S2SV_blank>specified!\\n" ) ; return - ENXIO ; } down_read ( & subs -> stream -> chip -> shutdown_rwsem ) ; if ( subs -> stream -> chip -> shutdown ) { ret = - ENODEV ; goto unlock ; } if ( snd_BUG_ON ( ! subs -> data_endpoint ) ) { ret = - EIO ; goto unlock ; } snd_usb_endpoint_sync_pending_stop ( subs -> sync_endpoint ) ; snd_usb_endpoint_sync_pending_stop ( subs -> data_endpoint ) ; ret = set_format ( subs , subs -> cur_audiofmt ) ; if ( ret < 0 ) goto unlock ; iface = usb_ifnum_to_if ( subs -> dev , subs -> cur_audiofmt -> iface ) ; alts = & iface -> altsetting [ subs -> cur_audiofmt -> altset_idx ] ; ret = snd_usb_init_sample_rate ( subs -> stream -> chip , subs -> cur_audiofmt -> iface , alts , subs -> cur_audiofmt , subs -> cur_rate ) ; if ( ret < 0 ) goto unlock ; if ( subs -> need_setup_ep ) { ret = configure_endpoint ( subs ) ; if ( ret < 0 ) goto unlock ; subs -> need_setup_ep = false ; } subs -> data_endpoint -> maxframesize = bytes_to_frames ( runtime , subs -> data_endpoint -> maxpacksize ) ; subs -> data_endpoint -> curframesize = bytes_to_frames ( runtime , subs -> data_endpoint -> curpacksize ) ; subs -> hwptr_done = 0 ; subs -> transfer_done = 0 ; subs -> last_delay = 0 ; subs -> last_frame_number = 0 ; runtime -> delay = 0 ; if ( subs -> direction == SNDRV_PCM_STREAM_PLAYBACK ) <S2SV_StartBug> ret = start_endpoints ( subs , true ) ; <S2SV_EndBug> unlock : up_read ( & subs -> stream -> chip -> shutdown_rwsem ) ; return ret ; } | <S2SV_ModStart> start_endpoints ( subs <S2SV_ModEnd> ) ; unlock |
2,757 | CWE-000 <S2SV_StartBug> NRF_RESULT NRF_SetTXAddress ( nrf24l01_dev * dev , uint8_t * address ) { <S2SV_EndBug> uint8_t rx [ 5 ] ; if ( NRF_SendCommand ( dev , NRF_CMD_W_REGISTER | NRF_TX_ADDR , address , rx , 5 ) != NRF_OK ) { return NRF_ERROR ; } return NRF_OK ; } | <S2SV_ModStart> NRF_RESULT NRF_SetTXAddress ( nrf24L01_Dev <S2SV_ModEnd> * dev , |
2,758 | CWE-000 int fits_already_open ( fitsfile * * fptr , char * url , char * urltype , char * infile , char * extspec , char * rowfilter , char * binspec , char * colspec , int mode , int * isopen , int * status ) { FITSfile * oldFptr ; int ii ; char oldurltype [ MAX_PREFIX_LEN ] , oldinfile [ FLEN_FILENAME ] ; char oldextspec [ FLEN_FILENAME ] , oldoutfile [ FLEN_FILENAME ] ; char oldrowfilter [ FLEN_FILENAME ] ; char oldbinspec [ FLEN_FILENAME ] , oldcolspec [ FLEN_FILENAME ] ; char cwd [ FLEN_FILENAME ] ; char tmpStr [ FLEN_FILENAME ] ; char tmpinfile [ FLEN_FILENAME ] ; * isopen = 0 ; if ( mode == 0 ) return ( * status ) ; if ( fits_strcasecmp ( urltype , "FILE://" ) == 0 ) { <S2SV_StartBug> fits_path2url ( infile , tmpinfile , status ) ; <S2SV_EndBug> if ( tmpinfile [ 0 ] != '/' ) { fits_get_cwd ( cwd , status ) ; strcat ( cwd , "/" ) ; if ( strlen ( cwd ) + strlen ( tmpinfile ) > FLEN_FILENAME - 1 ) { ffpmsg ( "File<S2SV_blank>name<S2SV_blank>is<S2SV_blank>too<S2SV_blank>long.<S2SV_blank>(fits_already_open)" ) ; return ( * status = FILE_NOT_OPENED ) ; } strcat ( cwd , tmpinfile ) ; fits_clean_url ( cwd , tmpinfile , status ) ; } } else strcpy ( tmpinfile , infile ) ; for ( ii = 0 ; ii < NMAXFILES ; ii ++ ) { if ( FptrTable [ ii ] != 0 ) { oldFptr = FptrTable [ ii ] ; fits_parse_input_url ( oldFptr -> filename , oldurltype , oldinfile , oldoutfile , oldextspec , oldrowfilter , oldbinspec , oldcolspec , status ) ; if ( * status > 0 ) { ffpmsg ( "could<S2SV_blank>not<S2SV_blank>parse<S2SV_blank>the<S2SV_blank>previously<S2SV_blank>opened<S2SV_blank>filename:<S2SV_blank>(ffopen)" ) ; ffpmsg ( oldFptr -> filename ) ; return ( * status ) ; } if ( fits_strcasecmp ( oldurltype , "FILE://" ) == 0 ) { <S2SV_StartBug> fits_path2url ( oldinfile , tmpStr , status ) ; <S2SV_EndBug> if ( tmpStr [ 0 ] != '/' ) { fits_get_cwd ( cwd , status ) ; strcat ( cwd , "/" ) ; strcat ( cwd , tmpStr ) ; fits_clean_url ( cwd , tmpStr , status ) ; } strcpy ( oldinfile , tmpStr ) ; } if ( ! strcmp ( urltype , oldurltype ) && ! strcmp ( tmpinfile , oldinfile ) ) { if ( ( ! rowfilter [ 0 ] && ! oldrowfilter [ 0 ] && ! binspec [ 0 ] && ! oldbinspec [ 0 ] && ! colspec [ 0 ] && ! oldcolspec [ 0 ] ) || ( ! strcmp ( rowfilter , oldrowfilter ) && ! strcmp ( binspec , oldbinspec ) && ! strcmp ( colspec , oldcolspec ) && ! strcmp ( extspec , oldextspec ) ) ) { if ( mode == READWRITE && oldFptr -> writemode == READONLY ) { ffpmsg ( "cannot<S2SV_blank>reopen<S2SV_blank>file<S2SV_blank>READWRITE<S2SV_blank>when<S2SV_blank>previously<S2SV_blank>opened<S2SV_blank>READONLY" ) ; ffpmsg ( url ) ; return ( * status = FILE_NOT_OPENED ) ; } * fptr = ( fitsfile * ) calloc ( 1 , sizeof ( fitsfile ) ) ; if ( ! ( * fptr ) ) { ffpmsg ( "failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>structure<S2SV_blank>for<S2SV_blank>following<S2SV_blank>file:<S2SV_blank>(ffopen)" ) ; ffpmsg ( url ) ; return ( * status = MEMORY_ALLOCATION ) ; } ( * fptr ) -> Fptr = oldFptr ; ( * fptr ) -> HDUposition = 0 ; ( ( ( * fptr ) -> Fptr ) -> open_count ) ++ ; if ( binspec [ 0 ] ) extspec [ 0 ] = '\\0' ; rowfilter [ 0 ] = '\\0' ; binspec [ 0 ] = '\\0' ; colspec [ 0 ] = '\\0' ; * isopen = 1 ; } } } } return ( * status ) ; } | <S2SV_ModStart> 0 ) { if ( <S2SV_ModStart> ( infile , FLEN_FILENAME , tmpinfile , status ) ) return ( * <S2SV_ModEnd> status ) ; <S2SV_ModStart> 0 ) { if ( <S2SV_ModStart> ( oldinfile , FLEN_FILENAME , tmpStr , status ) ) return ( * <S2SV_ModEnd> status ) ; |
2,759 | CWE-000 int http_extra_flush ( http_connection_t * hc ) { htsbuf_data_t * hd ; int r , serr = 0 ; if ( atomic_add ( & hc -> hc_extra_insend , 1 ) != 0 ) goto fin ; while ( 1 ) { <S2SV_StartBug> pthread_mutex_lock ( & hc -> hc_extra_lock ) ; <S2SV_EndBug> <S2SV_StartBug> hd = TAILQ_FIRST ( & hc -> hc_extra . hq_q ) ; <S2SV_EndBug> do { r = send ( hc -> hc_fd , hd -> hd_data + hd -> hd_data_off , hd -> hd_data_size - hd -> hd_data_off , MSG_DONTWAIT | ( TAILQ_NEXT ( hd , hd_link ) ? MSG_MORE : 0 ) ) ; serr = errno ; } while ( r < 0 && serr == EINTR ) ; if ( r > 0 && r + hd -> hd_data_off >= hd -> hd_data_size ) { atomic_dec ( & hc -> hc_extra_chunks , 1 ) ; htsbuf_data_free ( & hc -> hc_extra , hd ) ; } else if ( r > 0 ) { hd -> hd_data_off += r ; hc -> hc_extra . hq_size -= r ; } <S2SV_StartBug> pthread_mutex_unlock ( & hc -> hc_extra_lock ) ; <S2SV_EndBug> if ( r < 0 ) { if ( ERRNO_AGAIN ( serr ) ) serr = 0 ; break ; } } fin : atomic_dec ( & hc -> hc_extra_insend , 1 ) ; return serr ; } | <S2SV_ModStart> 1 ) { r = - 1 ; serr = 0 ; <S2SV_ModStart> -> hc_extra_lock ) ; if ( atomic_add ( & hc -> hc_extra_insend , 0 ) != 1 ) goto unlock <S2SV_ModStart> . hq_q ) ; if ( hd == NULL ) goto unlock <S2SV_ModStart> r ; } unlock : |
2,760 | CWE-000 <S2SV_StartBug> TEST ( pattern_length_is_not_limited ) <S2SV_EndBug> { <S2SV_StartBug> const char * const COMMANDS = "highlight<S2SV_blank>/\\\\.(7z|Z|a|ace|alz|apkg|arc|arj|bz" <S2SV_EndBug> "|bz2|cab|cpio|deb|gz|jar|lha|lrz|lz|lzma|lzo|rar|rpm|rz|t7z|tZ|tar|tbz" "|tbz2|tgz|tlz|txz|tzo|war|xz|zip)$/<S2SV_blank>ctermfg=red" ; <S2SV_StartBug> assert_int_equal ( 0 , exec_commands ( COMMANDS , & lwin , CIT_COMMAND ) ) ; <S2SV_EndBug> assert_string_equal ( "/\\\\.(7z|Z|a|ace|alz|apkg|arc|arj|bz" "|bz2|cab|cpio|deb|gz|jar|lha|lrz|lz|lzma|lzo|rar|rpm|rz|t7z|tZ|tar|tbz" "|tbz2|tgz|tlz|txz|tzo|war|xz|zip)$/" , matchers_get_expr ( cfg . cs . file_hi [ 0 ] . matchers ) ) ; } | <S2SV_ModStart> <S2SV_null> TEST ( empty_re_with_flags <S2SV_ModEnd> ) { const <S2SV_ModStart> const COMMANDS = "highlight<S2SV_blank>//i<S2SV_blank>ctermfg=red" ; assert_false ( <S2SV_ModEnd> exec_commands ( COMMANDS <S2SV_ModStart> , CIT_COMMAND ) == 0 <S2SV_ModEnd> ) ; } |
2,761 | CWE-000 void ir_gen_call ( IrContext * ir_context , Scope * scope , AstNode * call ) { assert ( KIND ( call , eAstNode_call ) ) ; AstNode * proc = call -> call . proc ; call -> place = ir_new_arg_existing_object ( ir_context , call -> call . retvar ) ; AstNode * args = call -> call . args ; ir_gen_actual_args ( ir_context , scope , args ) ; if ( is_extern_proc ( proc ) ) { alloc_data_object ( ir_context , call -> call . retvar , call -> call . param_scope ) ; for ( ListItem * li = args -> node_list . last ; li ; li = li -> prev ) { AstNode * arg = KIND ( li , eList_ast_node ) -> ast_node ; <S2SV_StartBug> alloc_data_object ( ir_context , arg -> actual_arg . param , call -> call . param_scope ) ; <S2SV_EndBug> } ir_emit_call ( ir_context , proc -> proc . decorated_name , call -> call . param_scope , call -> call . retvar , true ) ; } else { for ( ListItem * li = args -> node_list . first ; li ; li = li -> next ) { AstNode * arg = KIND ( li , eList_ast_node ) -> ast_node ; <S2SV_StartBug> alloc_data_object ( ir_context , arg -> actual_arg . param , call -> call . param_scope ) ; <S2SV_EndBug> } alloc_data_object ( ir_context , call -> call . retvar , call -> call . param_scope ) ; ir_emit_call ( ir_context , proc -> proc . name , call -> call . param_scope , call -> call . retvar , false ) ; } } | <S2SV_ModStart> , arg -> call_arg <S2SV_ModEnd> . param , <S2SV_ModStart> , arg -> call_arg <S2SV_ModEnd> . param , |
2,762 | CWE-000 int main ( int argc , char * argv [ ] ) { if ( _t_ez_job_create1 ( ) && <S2SV_StartBug> _t_ez_job_create2 ( ) <S2SV_EndBug> ) puts ( "t_ez_job<S2SV_blank>...<S2SV_blank>ok!" ) ; else exit ( 1 ) ; return 0 ; } | <S2SV_ModStart> _t_ez_job_create2 ( ) && _t_ez_job_copy ( ) |
2,763 | CWE-000 <S2SV_StartBug> static int runner ( int local , const char * path , char * * args , int return_ec ) <S2SV_EndBug> { pid_t pid ; struct timeval time_start , time_end ; if ( show ) { int i ; if ( wrapper ) fprintf ( stderr , "WRAPPER=\'%s\'<S2SV_blank>" , wrapper ) ; fprintf ( stderr , "%s<S2SV_blank>" , path ) ; for ( i = 0 ; args [ i ] ; i ++ ) fprintf ( stderr , "%s<S2SV_blank>" , args [ i ] ) ; fputc ( '\\n' , stderr ) ; } if ( noop ) return 0 ; if ( time_subcmds && gettimeofday ( & time_start , NULL ) < 0 ) fprintf ( stderr , "gettimeofday():<S2SV_blank>%s\\n" , strerror ( errno ) ) ; pid = fork ( ) ; switch ( pid ) { case - 1 : die ( "fork():" ) ; case 0 : { int nargs = dynarray_count ( args ) ; int i_in = 0 , i_out = 0 ; char * * argv ; if ( wrapper ) { char * p ; nargs ++ ; for ( p = wrapper ; * p ; p ++ ) nargs += * p == ',' ; } argv = umalloc ( ( 2 + nargs ) * sizeof * argv ) ; if ( wrapper ) { char * p , * last ; for ( p = last = wrapper ; * p ; p ++ ) if ( * p == ',' ) { * p = '\\0' ; argv [ i_out ++ ] = last ; last = p + 1 ; } if ( last != p ) argv [ i_out ++ ] = last ; } argv [ i_out ++ ] = local ? actual_path ( "../" , path ) : ( char * ) path ; while ( args [ i_in ] ) argv [ i_out ++ ] = args [ i_in ++ ] ; argv [ i_out ++ ] = NULL ; # ifdef DEBUG fprintf ( stderr , "%s:\\n" , * argv ) ; for ( int i = 0 ; argv [ i ] ; i ++ ) fprintf ( stderr , "<S2SV_blank><S2SV_blank>[%d]<S2SV_blank>=<S2SV_blank>\\"%s\\",\\n" , i , argv [ i ] ) ; # endif if ( wrapper ) local = 0 ; ( local ? execv : execvp ) ( argv [ 0 ] , argv ) ; die ( "execv(\\"%s\\"):" , argv [ 0 ] ) ; } default : { int status , i ; if ( wait ( & status ) == - 1 ) die ( "wait()" ) ; if ( time_subcmds && gettimeofday ( & time_end , NULL ) < 0 ) fprintf ( stderr , "gettimeofday():<S2SV_blank>%s\\n" , strerror ( errno ) ) ; if ( WIFEXITED ( status ) && ( i = WEXITSTATUS ( status ) ) != 0 ) { <S2SV_StartBug> if ( ! return_ec ) <S2SV_EndBug> die ( "%s<S2SV_blank>returned<S2SV_blank>%d" , path , i ) ; } else if ( WIFSIGNALED ( status ) ) { int sig = WTERMSIG ( status ) ; <S2SV_StartBug> fprintf ( stderr , "%s<S2SV_blank>caught<S2SV_blank>signal<S2SV_blank>%d\\n" , path , sig ) ; <S2SV_EndBug> exit ( 128 + sig ) ; } if ( time_subcmds ) { time_t secdiff = time_end . tv_sec - time_start . tv_sec ; suseconds_t usecdiff = time_end . tv_usec - time_start . tv_usec ; if ( usecdiff < 0 ) { secdiff -- ; usecdiff += 1000000L ; } printf ( "%s<S2SV_blank>%ld.%ld\\n" , path , ( long ) secdiff , ( long ) usecdiff ) ; } return i ; } } } | <S2SV_ModStart> , int return_ec , const char * to_remove <S2SV_ModStart> { if ( to_remove ) remove ( to_remove ) ; if ( <S2SV_ModStart> path , sig ) ; if ( to_remove ) remove ( to_remove |
2,764 | CWE-000 void * aws_iot_mqtt_tests_yield_with_rc ( void * ptr ) { IoT_Error_t rc = SUCCESS ; struct timeval start , end , result ; static int cntr = 0 ; AWS_IoT_Client * pClient = ( AWS_IoT_Client * ) ptr ; while ( terminate_yield_with_rc_thread == false && ( NETWORK_ATTEMPTING_RECONNECT == rc || NETWORK_RECONNECTED == rc || SUCCESS == rc ) ) { usleep ( 500000 ) ; printf ( "<S2SV_blank>Client<S2SV_blank>state<S2SV_blank>:<S2SV_blank>%d<S2SV_blank>" , aws_iot_mqtt_get_client_state ( pClient ) ) ; rc = aws_iot_mqtt_yield ( pClient , 100 ) ; printf ( "yield<S2SV_blank>rc<S2SV_blank>%d\\n" , rc ) ; if ( captureYieldReturnCode && SUCCESS != rc ) { printf ( "yield<S2SV_blank>rc<S2SV_blank>capture<S2SV_blank>%d\\n" , rc ) ; captureYieldReturnCode = false ; yieldRC = rc ; } } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ; } } return NULL ; |
2,765 | CWE-000 int auth_sha1_v2_client_pre_encrypt ( obfs * self , char * * pplaindata , int datalength , size_t * capacity ) { char * plaindata = * pplaindata ; auth_simple_local_data * local = ( auth_simple_local_data * ) self -> l_data ; <S2SV_StartBug> char * out_buffer = ( char * ) malloc ( datalength * 2 + 4096 ) ; <S2SV_EndBug> char * buffer = out_buffer ; char * data = plaindata ; int len = datalength ; int pack_len ; if ( len > 0 && local -> has_sent_header == 0 ) { int head_size = get_head_size ( plaindata , datalength , 30 ) ; if ( head_size > datalength ) head_size = datalength ; pack_len = auth_sha1_v2_pack_auth_data ( ( auth_simple_global_data * ) self -> server . g_data , & self -> server , data , head_size , buffer ) ; buffer += pack_len ; data += head_size ; len -= head_size ; local -> has_sent_header = 1 ; } while ( len > auth_simple_pack_unit_size ) { pack_len = auth_sha1_v2_pack_data ( data , auth_simple_pack_unit_size , buffer ) ; buffer += pack_len ; data += auth_simple_pack_unit_size ; len -= auth_simple_pack_unit_size ; } if ( len > 0 ) { pack_len = auth_sha1_v2_pack_data ( data , len , buffer ) ; buffer += pack_len ; } <S2SV_StartBug> len = buffer - out_buffer ; <S2SV_EndBug> <S2SV_StartBug> if ( * capacity < len ) { <S2SV_EndBug> <S2SV_StartBug> * pplaindata = ( char * ) realloc ( * pplaindata , * capacity = len * 2 ) ; <S2SV_EndBug> plaindata = * pplaindata ; } memmove ( plaindata , out_buffer , len ) ; free ( out_buffer ) ; return len ; } | <S2SV_ModStart> * ) malloc ( ( size_t ) <S2SV_ModStart> 2 + 4096 ) <S2SV_ModStart> } len = ( int ) ( <S2SV_ModStart> buffer - out_buffer ) <S2SV_ModStart> ; if ( ( int ) <S2SV_ModStart> * capacity = ( size_t ) ( <S2SV_ModStart> * 2 ) ) |
2,766 | CWE-000 void pl_inodelk_xattr_fill ( xlator_t * this , inode_t * inode , dict_t * dict , char * domname , gf_boolean_t keep_max ) { int32_t count = 0 ; int32_t maxcount = - 1 ; int ret = - 1 ; if ( keep_max ) { ret = dict_get_int32 ( dict , GLUSTERFS_INODELK_COUNT , & maxcount ) ; <S2SV_StartBug> } <S2SV_EndBug> count = get_inodelk_count ( this , inode , domname ) ; if ( maxcount >= count ) return ; ret = dict_set_int32 ( dict , GLUSTERFS_INODELK_COUNT , count ) ; if ( ret < 0 ) { <S2SV_StartBug> gf_log ( this -> name , GF_LOG_DEBUG , "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>count<S2SV_blank>for<S2SV_blank>" <S2SV_EndBug> "key<S2SV_blank>%s" , GLUSTERFS_INODELK_COUNT ) ; } return ; } | <S2SV_ModStart> maxcount ) ; if ( ret < 0 ) gf_msg_debug ( this -> name , 0 , "<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>fetch<S2SV_blank>the<S2SV_blank>value<S2SV_blank>for<S2SV_blank>key<S2SV_blank>%s" , GLUSTERFS_INODELK_COUNT ) ; <S2SV_ModStart> 0 ) { gf_msg_debug <S2SV_ModEnd> ( this -> <S2SV_ModStart> -> name , 0 <S2SV_ModEnd> , "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>count<S2SV_blank>for<S2SV_blank>" "key<S2SV_blank>%s" |
2,767 | CWE-000 static void iotjs_https_jthis_destroy ( void * nativep ) { iotjs_https_t * https_data = ( iotjs_https_t * ) nativep ; <S2SV_StartBug> IOTJS_RELEASE ( https_data ) ; <S2SV_EndBug> printf ( "destroyed<S2SV_blank>native<S2SV_blank>jthis\\n" ) ; } | <S2SV_ModStart> ) nativep ; IOTJS_VALIDATED_STRUCT_DESTRUCTOR ( iotjs_https_t , https_data ) ; _this -> URL = NULL ; |
2,768 | CWE-000 void cgit_parse_url ( const char * url ) { char * c , * cmd , * p ; struct cgit_repo * repo ; ctx . repo = NULL ; <S2SV_StartBug> if ( ! url || url [ 0 ] == '\\0' ) <S2SV_EndBug> return ; ctx . repo = cgit_get_repoinfo ( url ) ; if ( ctx . repo ) { ctx . qry . repo = ctx . repo -> url ; return ; } cmd = NULL ; c = strchr ( url , '/' ) ; while ( c ) { c [ 0 ] = '\\0' ; repo = cgit_get_repoinfo ( url ) ; if ( repo ) { ctx . repo = repo ; cmd = c ; } c [ 0 ] = '/' ; c = strchr ( c + 1 , '/' ) ; } if ( ctx . repo ) { ctx . qry . repo = ctx . repo -> url ; p = strchr ( cmd + 1 , '/' ) ; if ( p ) { p [ 0 ] = '\\0' ; if ( p [ 1 ] ) ctx . qry . path = trim_end ( p + 1 , '/' ) ; } if ( cmd [ 1 ] ) ctx . qry . page = xstrdup ( cmd + 1 ) ; <S2SV_StartBug> return ; <S2SV_EndBug> } } | <S2SV_ModStart> = NULL ; ctx . qry . page = NULL ; <S2SV_ModStart> 1 ) ; <S2SV_ModEnd> } } <S2SV_null> |
2,769 | CWE-000 Test ( cipher_crypto , TestChkSig ) { cipher__PubKey pk , pk2 ; cipher__SecKey sk , sk2 ; cipher__Address addr , addr2 ; unsigned char buff [ 257 ] ; GoSlice b = { buff , 0 , 257 } ; cipher__SHA256 h , h2 ; cipher__Sig sig , sig2 ; int errcode ; SKY_cipher_GenerateKeyPair ( & pk , & sk ) ; errcode = SKY_cipher_PubKey_Verify ( & pk ) ; cr_assert ( errcode == SKY_OK ) ; errcode = SKY_cipher_SecKey_Verify ( & sk ) ; cr_assert ( errcode == SKY_OK ) ; SKY_cipher_AddressFromPubKey ( & pk , & addr ) ; errcode = SKY_cipher_Address_Verify ( & addr , & pk ) ; cr_assert ( errcode == SKY_OK ) ; randBytes ( & b , 256 ) ; SKY_cipher_SumSHA256 ( b , & h ) ; <S2SV_StartBug> SKY_cipher_SignHash ( & h , & sk , & sig ) ; <S2SV_EndBug> errcode = SKY_cipher_ChkSig ( & addr , & h , & sig ) ; cr_assert ( errcode == SKY_OK ) ; memset ( & sig , 0 , sizeof ( sig ) ) ; errcode = SKY_cipher_ChkSig ( & addr , & h , & sig ) ; cr_assert ( errcode == SKY_ERROR ) ; int i ; for ( i = 0 ; i < 100 ; i ++ ) { randBytes ( & b , 65 ) ; SKY_cipher_NewSig ( b , & sig ) ; errcode = SKY_cipher_ChkSig ( & addr , & h , & sig ) ; cr_assert ( errcode == SKY_ERROR ) ; } randBytes ( & b , 256 ) ; SKY_cipher_SumSHA256 ( b , & h2 ) ; <S2SV_StartBug> SKY_cipher_SignHash ( & h2 , & sk , & sig2 ) ; <S2SV_EndBug> errcode = SKY_cipher_ChkSig ( & addr , & h2 , & sig2 ) ; cr_assert ( errcode == SKY_OK ) ; errcode = SKY_cipher_ChkSig ( & addr , & h , & sig2 ) ; cr_assert ( errcode == SKY_ERROR ) ; errcode = SKY_cipher_ChkSig ( & addr , & h2 , & sig ) ; cr_assert ( errcode == SKY_ERROR ) ; SKY_cipher_GenerateKeyPair ( & pk2 , & sk2 ) ; SKY_cipher_AddressFromPubKey ( & pk2 , & addr2 ) ; memset ( & h , 0 , sizeof ( h ) ) ; <S2SV_StartBug> SKY_cipher_SignHash ( & h , & sk , & sig ) ; <S2SV_EndBug> <S2SV_StartBug> SKY_cipher_SignHash ( & h , & sk2 , & sig2 ) ; <S2SV_EndBug> errcode = SKY_cipher_ChkSig ( & addr , & h , & sig ) ; cr_assert ( errcode == SKY_OK ) ; errcode = SKY_cipher_ChkSig ( & addr2 , & h , & sig2 ) ; cr_assert ( errcode == SKY_OK ) ; cr_assert ( not ( eq ( u8 [ 65 ] , sig , sig2 ) ) ) ; randBytes ( & b , 256 ) ; SKY_cipher_SumSHA256 ( b , & h ) ; <S2SV_StartBug> SKY_cipher_SignHash ( & h , & sk , & sig ) ; <S2SV_EndBug> <S2SV_StartBug> SKY_cipher_SignHash ( & h , & sk2 , & sig2 ) ; <S2SV_EndBug> errcode = SKY_cipher_ChkSig ( & addr , & h , & sig ) ; cr_assert ( errcode == SKY_OK ) ; errcode = SKY_cipher_ChkSig ( & addr2 , & h , & sig2 ) ; cr_assert ( errcode == SKY_OK ) ; cr_assert ( not ( eq ( u8 [ 65 ] , sig , sig2 ) ) ) ; errcode = SKY_cipher_ChkSig ( & addr , & h , & sig2 ) ; cr_assert ( errcode == SKY_ERROR ) ; errcode = SKY_cipher_ChkSig ( & addr2 , & h , & sig ) ; cr_assert ( errcode == SKY_ERROR ) ; } | <S2SV_ModStart> h ) ; SKY_cipher_MustSignHash <S2SV_ModEnd> ( & h <S2SV_ModStart> h2 ) ; SKY_cipher_MustSignHash <S2SV_ModEnd> ( & h2 <S2SV_ModStart> ) ) ; SKY_cipher_MustSignHash <S2SV_ModEnd> ( & h <S2SV_ModStart> sig ) ; SKY_cipher_MustSignHash <S2SV_ModEnd> ( & h <S2SV_ModStart> h ) ; SKY_cipher_MustSignHash <S2SV_ModEnd> ( & h <S2SV_ModStart> sig ) ; SKY_cipher_MustSignHash <S2SV_ModEnd> ( & h |
2,770 | CWE-000 static void * winMultiWindowWMProc ( void * pArg ) { WMProcArgPtr pProcArg = ( WMProcArgPtr ) pArg ; WMInfoPtr pWMInfo = pProcArg -> pWMInfo ; pthread_cleanup_push ( & winMultiWindowThreadExit , NULL ) ; winInitMultiWindowWM ( pWMInfo , pProcArg ) ; # if CYGMULTIWINDOW_DEBUG ErrorF ( "winMultiWindowWMProc<S2SV_blank>()\\n" ) ; # endif for ( ; ; ) { WMMsgNodePtr pNode ; pNode = PopMessage ( & pWMInfo -> wmMsgQueue , pWMInfo ) ; if ( pNode == NULL ) { ErrorF ( "winMultiWindowWMProc<S2SV_blank>-<S2SV_blank>Queue<S2SV_blank>is<S2SV_blank>Empty?<S2SV_blank><S2SV_blank>Exiting.\\n" ) ; pthread_exit ( NULL ) ; } # if CYGMULTIWINDOW_DEBUG ErrorF ( "winMultiWindowWMProc<S2SV_blank>-<S2SV_blank>MSG:<S2SV_blank>%s<S2SV_blank>(%d)<S2SV_blank>ID:<S2SV_blank>%d\\n" , MessageName ( & ( pNode -> msg ) ) , ( int ) pNode -> msg . msg , ( int ) pNode -> msg . dwID ) ; # endif switch ( pNode -> msg . msg ) { # if 0 case WM_WM_MOVE : break ; case WM_WM_SIZE : break ; # endif case WM_WM_RAISE : { const static uint32_t values [ ] = { XCB_STACK_MODE_ABOVE } ; xcb_configure_window ( pWMInfo -> conn , pNode -> msg . iWindow , XCB_CONFIG_WINDOW_STACK_MODE , values ) ; } # if 0 PreserveWin32Stack ( pWMInfo , pNode -> msg . iWindow , GW_HWNDPREV ) ; # endif break ; case WM_WM_LOWER : { const static uint32_t values [ ] = { XCB_STACK_MODE_BELOW } ; xcb_configure_window ( pWMInfo -> conn , pNode -> msg . iWindow , XCB_CONFIG_WINDOW_STACK_MODE , values ) ; } break ; case WM_WM_MAP2 : xcb_change_property ( pWMInfo -> conn , XCB_PROP_MODE_REPLACE , pNode -> msg . iWindow , pWMInfo -> atmPrivMap , XCB_ATOM_INTEGER , 32 , sizeof ( HWND ) / 4 , & ( pNode -> msg . hwndWindow ) ) ; break ; case WM_WM_MAP3 : xcb_change_property ( pWMInfo -> conn , XCB_PROP_MODE_REPLACE , pNode -> msg . iWindow , pWMInfo -> atmPrivMap , XCB_ATOM_INTEGER , 32 , sizeof ( HWND ) / 4 , & ( pNode -> msg . hwndWindow ) ) ; UpdateName ( pWMInfo , pNode -> msg . iWindow ) ; <S2SV_StartBug> UpdateIcon ( pWMInfo , pNode -> msg . iWindow ) ; <S2SV_EndBug> UpdateStyle ( pWMInfo , pNode -> msg . iWindow ) ; { WindowPtr pWin = GetProp ( pNode -> msg . hwndWindow , WIN_WINDOW_PROP ) ; if ( pWin ) { winReshapeMultiWindow ( pWin ) ; winUpdateRgnMultiWindow ( pWin ) ; } } break ; case WM_WM_UNMAP : xcb_unmap_window ( pWMInfo -> conn , pNode -> msg . iWindow ) ; break ; case WM_WM_KILL : { if ( IsWmProtocolAvailable ( pWMInfo , pNode -> msg . iWindow , pWMInfo -> atmWmDelete ) ) SendXMessage ( pWMInfo -> conn , pNode -> msg . iWindow , pWMInfo -> atmWmProtos , pWMInfo -> atmWmDelete ) ; else xcb_kill_client ( pWMInfo -> conn , pNode -> msg . iWindow ) ; } break ; case WM_WM_ACTIVATE : { Bool neverFocus = FALSE ; xcb_get_property_cookie_t cookie ; xcb_icccm_wm_hints_t hints ; cookie = xcb_icccm_get_wm_hints ( pWMInfo -> conn , pNode -> msg . iWindow ) ; if ( xcb_icccm_get_wm_hints_reply ( pWMInfo -> conn , cookie , & hints , NULL ) ) { if ( hints . flags & XCB_ICCCM_WM_HINT_INPUT ) neverFocus = ! hints . input ; } if ( ! neverFocus ) xcb_set_input_focus ( pWMInfo -> conn , XCB_INPUT_FOCUS_POINTER_ROOT , pNode -> msg . iWindow , XCB_CURRENT_TIME ) ; if ( IsWmProtocolAvailable ( pWMInfo , pNode -> msg . iWindow , pWMInfo -> atmWmTakeFocus ) ) SendXMessage ( pWMInfo -> conn , pNode -> msg . iWindow , pWMInfo -> atmWmProtos , pWMInfo -> atmWmTakeFocus ) ; } break ; case WM_WM_NAME_EVENT : UpdateName ( pWMInfo , pNode -> msg . iWindow ) ; break ; case WM_WM_ICON_EVENT : UpdateIcon ( pWMInfo , pNode -> msg . iWindow ) ; break ; case WM_WM_HINTS_EVENT : { if ( IsOverrideRedirect ( pWMInfo -> conn , pNode -> msg . iWindow ) ) break ; UpdateStyle ( pWMInfo , pNode -> msg . iWindow ) ; } break ; case WM_WM_CHANGE_STATE : UpdateState ( pWMInfo , pNode -> msg . iWindow ) ; break ; default : ErrorF ( "winMultiWindowWMProc<S2SV_blank>-<S2SV_blank>Unknown<S2SV_blank>Message.<S2SV_blank><S2SV_blank>Exiting.\\n" ) ; pthread_exit ( NULL ) ; break ; } free ( pNode ) ; xcb_flush ( pWMInfo -> conn ) ; { xcb_generic_event_t * event = xcb_poll_for_event ( pWMInfo -> conn ) ; if ( event ) { if ( ( event -> response_type & ~ 0x80 ) == 0 ) { xcb_generic_error_t * err = ( xcb_generic_error_t * ) event ; ErrorF ( "winMultiWindowWMProc<S2SV_blank>-<S2SV_blank>Error<S2SV_blank>code:<S2SV_blank>%i,<S2SV_blank>ID:<S2SV_blank>0x%08x,<S2SV_blank>" "Major<S2SV_blank>opcode:<S2SV_blank>%i,<S2SV_blank>Minor<S2SV_blank>opcode:<S2SV_blank>%i\\n" , err -> error_code , err -> resource_id , err -> major_code , err -> minor_code ) ; } } } { int e = xcb_connection_has_error ( pWMInfo -> conn ) ; if ( e ) { ErrorF ( "winMultiWindowWMProc<S2SV_blank>-<S2SV_blank>Fatal<S2SV_blank>error<S2SV_blank>%d<S2SV_blank>on<S2SV_blank>xcb<S2SV_blank>connection\\n" , e ) ; pthread_exit ( NULL ) ; break ; } } } pthread_cond_destroy ( & pWMInfo -> wmMsgQueue . pcNotEmpty ) ; pthread_mutex_destroy ( & pWMInfo -> wmMsgQueue . pmMutex ) ; free ( pProcArg ) ; # if CYGMULTIWINDOW_DEBUG ErrorF ( "-winMultiWindowWMProc<S2SV_blank>()\\n" ) ; # endif pthread_cleanup_pop ( 0 ) ; return NULL ; } | <S2SV_ModStart> iWindow ) ; UpdateStyle ( pWMInfo , pNode -> msg . iWindow ) ; UpdateIcon <S2SV_ModEnd> ( pWMInfo , |
2,771 | CWE-000 int32_t mcp23017_enable_pin_intrrupt ( const mcp23017_dev_t * dev , const uint8_t port , const uint8_t pin_num , const uint8_t default_value , const mcp_int_condition_t condition ) { uint8_t reg ; int32_t r ; <S2SV_StartBug> if ( pin_num > 8 || default_value > 1 || port > 1 ) { <S2SV_EndBug> r = EINVAL ; goto fail ; } reg = MCP23x17_DEFVAL + port ; if ( ( r = mcp23017_set_bit ( dev , reg , default_value , pin_num ) ) != 0 ) { goto fail ; } reg = MCP23x17_INTCON + port ; if ( ( r = mcp23017_set_bit ( dev , reg , condition , pin_num ) ) != 0 ) { goto fail ; } reg = MCP23x17_GPINTEN + port ; if ( ( r = mcp23017_set_bit ( dev , reg , condition , pin_num ) ) != 0 ) { goto fail ; } fail : return r ; } | <S2SV_ModStart> if ( pin_num >= <S2SV_ModEnd> 8 || default_value |
2,772 | CWE-000 static int orte_oob_base_open ( mca_base_open_flag_t flags ) { orte_oob_base . max_uri_length = - 1 ; OBJ_CONSTRUCT ( & orte_oob_base . peers , opal_hash_table_t ) ; opal_hash_table_init ( & orte_oob_base . peers , 128 ) ; OBJ_CONSTRUCT ( & orte_oob_base . actives , opal_list_t ) ; <S2SV_StartBug> orte_oob_base . ev_base = orte_event_base ; <S2SV_EndBug> # if OPAL_ENABLE_FT_CR == 1 orte_state . add_job_state ( ORTE_JOB_STATE_FT_CHECKPOINT , orte_oob_base_ft_event , ORTE_ERROR_PRI ) ; orte_state . add_job_state ( ORTE_JOB_STATE_FT_CONTINUE , orte_oob_base_ft_event , ORTE_ERROR_PRI ) ; orte_state . add_job_state ( ORTE_JOB_STATE_FT_RESTART , orte_oob_base_ft_event , ORTE_ERROR_PRI ) ; # endif return mca_base_framework_components_open ( & orte_oob_base_framework , flags ) ; } | <S2SV_ModStart> opal_list_t ) ; if ( ORTE_PROC_IS_APP || ORTE_PROC_IS_TOOL ) { <S2SV_ModStart> = orte_event_base ; } else { orte_oob_base . ev_base = opal_progress_thread_init ( "OOB-BASE" ) ; } |
2,773 | CWE-000 npy_cdouble cbesh_wrap2_e ( double v , npy_cdouble z ) { int n = 1 ; int kode = 2 ; int m = 2 ; int nz , ierr ; int sign = 1 ; npy_cdouble cy ; cy . real = NPY_NAN ; <S2SV_StartBug> cy . imag = NPY_NAN ; <S2SV_EndBug> if ( v < 0 ) { v = - v ; sign = - 1 ; } F_FUNC ( zbesh , ZBESH ) ( CADDR ( z ) , & v , & kode , & m , & n , CADDR ( cy ) , & nz , & ierr ) ; DO_SFERR ( "hankel2e:" , & cy ) ; if ( sign == - 1 ) { cy = rotate ( cy , - v ) ; } return cy ; } | <S2SV_ModStart> = NPY_NAN ; if ( npy_isnan ( v ) || npy_isnan ( z . real ) || npy_isnan ( z . imag ) ) { return cy ; } |
2,774 | CWE-000 static int msm_compr_copy ( struct snd_compr_stream * cstream , char __user * buf , size_t count ) { struct snd_compr_runtime * runtime = cstream -> runtime ; struct msm_compr_audio * prtd = runtime -> private_data ; void * dstn ; size_t copy ; uint64_t bytes_available = 0 ; unsigned long flags ; pr_debug ( "%s:<S2SV_blank>count<S2SV_blank>=<S2SV_blank>%zd\\n" , __func__ , count ) ; if ( ! prtd -> buffer ) { pr_err ( "%s:<S2SV_blank>Buffer<S2SV_blank>is<S2SV_blank>not<S2SV_blank>allocated<S2SV_blank>yet<S2SV_blank>??" , __func__ ) ; return 0 ; } spin_lock_irqsave ( & prtd -> lock , flags ) ; if ( atomic_read ( & prtd -> error ) ) { pr_err ( "%s<S2SV_blank>Got<S2SV_blank>RESET<S2SV_blank>EVENTS<S2SV_blank>notification" , __func__ ) ; spin_unlock_irqrestore ( & prtd -> lock , flags ) ; return - ENETRESET ; } spin_unlock_irqrestore ( & prtd -> lock , flags ) ; dstn = prtd -> buffer + prtd -> app_pointer ; if ( count < prtd -> buffer_size - prtd -> app_pointer ) { if ( copy_from_user ( dstn , buf , count ) ) return - EFAULT ; prtd -> app_pointer += count ; } else { copy = prtd -> buffer_size - prtd -> app_pointer ; if ( copy_from_user ( dstn , buf , copy ) ) return - EFAULT ; if ( copy_from_user ( prtd -> buffer , buf + copy , count - copy ) ) return - EFAULT ; prtd -> app_pointer = count - copy ; } spin_lock_irqsave ( & prtd -> lock , flags ) ; prtd -> bytes_received += count ; if ( atomic_read ( & prtd -> start ) ) { if ( atomic_read ( & prtd -> xrun ) ) { pr_debug ( "%s:<S2SV_blank>in<S2SV_blank>xrun,<S2SV_blank>count<S2SV_blank>=<S2SV_blank>%zd\\n" , __func__ , count ) ; bytes_available = prtd -> bytes_received - prtd -> copied_total ; <S2SV_StartBug> if ( bytes_available >= runtime -> fragment_size ) { <S2SV_EndBug> pr_debug ( "%s:<S2SV_blank>handle<S2SV_blank>xrun,<S2SV_blank>bytes_to_write<S2SV_blank>=<S2SV_blank>%llu\\n" , __func__ , bytes_available ) ; atomic_set ( & prtd -> xrun , 0 ) ; msm_compr_send_buffer ( prtd ) ; } } } spin_unlock_irqrestore ( & prtd -> lock , flags ) ; return count ; } | <S2SV_ModStart> ( bytes_available >= prtd -> dsp_fragment_size <S2SV_ModEnd> ) { pr_debug |
2,775 | CWE-000 void outputMemory ( ) { printf ( "+---------+-------+------------+-------+\\n" ) ; printf ( "|<S2SV_blank><S2SV_blank>Status<S2SV_blank>|<S2SV_blank>Start<S2SV_blank>|<S2SV_blank>Block<S2SV_blank>Size<S2SV_blank>|<S2SV_blank>End<S2SV_blank><S2SV_blank><S2SV_blank>|\\n" ) ; Chunk * first = first_chunk_address ( ) , * last = last_chunk_address ( ) ; for ( Chunk * chunk = first ; chunk <= last ; chunk += get_chunk_size ( chunk ) ) { char * status = is_used ( chunk ) ? "In<S2SV_blank>use" : "Free" ; <S2SV_StartBug> size_t blockSize = get_block_size ( chunk ) ; <S2SV_EndBug> <S2SV_StartBug> void * blockStart = get_block_start ( chunk ) , <S2SV_EndBug> <S2SV_StartBug> * blockEnd = get_block_end ( chunk ) ; <S2SV_EndBug> <S2SV_StartBug> printf ( "|%9s|%7p|%12n|%7p|\\n" status , blockStart , blockSize , blockEnd ) ; <S2SV_EndBug> } printf ( "+---------+-------+------------+-------+\\n" ) ; } | <S2SV_ModStart> : "Free" ; unsigned int blockSize = block_size <S2SV_ModEnd> ( chunk ) <S2SV_ModStart> * blockStart = block_start <S2SV_ModEnd> ( chunk ) <S2SV_ModStart> * blockEnd = block_end <S2SV_ModEnd> ( chunk ) <S2SV_ModStart> ; printf ( "|%9s|%7p|%12u|%7p|\\n" , <S2SV_ModEnd> status , blockStart |
2,776 | CWE-000 void mca_oob_tcp_peer_try_connect ( int fd , short args , void * cbdata ) { mca_oob_tcp_conn_op_t * op = ( mca_oob_tcp_conn_op_t * ) cbdata ; mca_oob_tcp_peer_t * peer = op -> peer ; int rc ; opal_socklen_t addrlen = 0 ; mca_oob_tcp_addr_t * addr ; char * host ; mca_oob_tcp_send_t * snd ; bool connected = false ; opal_output_verbose ( OOB_TCP_DEBUG_CONNECT , orte_oob_base_framework . framework_output , "%s<S2SV_blank>orte_tcp_peer_try_connect:<S2SV_blank>" "attempting<S2SV_blank>to<S2SV_blank>connect<S2SV_blank>to<S2SV_blank>proc<S2SV_blank>%s" , ORTE_NAME_PRINT ( ORTE_PROC_MY_NAME ) , ORTE_NAME_PRINT ( & ( peer -> name ) ) ) ; rc = tcp_peer_create_socket ( peer ) ; if ( ORTE_SUCCESS != rc ) { opal_output ( 0 , "%s<S2SV_blank>CANNOT<S2SV_blank>CREATE<S2SV_blank>SOCKET" , ORTE_NAME_PRINT ( ORTE_PROC_MY_NAME ) ) ; ORTE_FORCED_TERMINATE ( 1 ) ; OBJ_RELEASE ( op ) ; return ; } opal_output_verbose ( OOB_TCP_DEBUG_CONNECT , orte_oob_base_framework . framework_output , "%s<S2SV_blank>orte_tcp_peer_try_connect:<S2SV_blank>" "attempting<S2SV_blank>to<S2SV_blank>connect<S2SV_blank>to<S2SV_blank>proc<S2SV_blank>%s<S2SV_blank>on<S2SV_blank>socket<S2SV_blank>%d" , ORTE_NAME_PRINT ( ORTE_PROC_MY_NAME ) , ORTE_NAME_PRINT ( & ( peer -> name ) ) , peer -> sd ) ; addrlen = sizeof ( struct sockaddr_in ) ; peer -> active_addr = NULL ; OPAL_LIST_FOREACH ( addr , & peer -> addrs , mca_oob_tcp_addr_t ) { opal_output_verbose ( OOB_TCP_DEBUG_CONNECT , orte_oob_base_framework . framework_output , "%s<S2SV_blank>orte_tcp_peer_try_connect:<S2SV_blank>" "attempting<S2SV_blank>to<S2SV_blank>connect<S2SV_blank>to<S2SV_blank>proc<S2SV_blank>%s<S2SV_blank>on<S2SV_blank>%s:%d<S2SV_blank>-<S2SV_blank>%d<S2SV_blank>retries" , ORTE_NAME_PRINT ( ORTE_PROC_MY_NAME ) , ORTE_NAME_PRINT ( & ( peer -> name ) ) , opal_net_get_hostname ( ( struct sockaddr * ) & addr -> addr ) , opal_net_get_port ( ( struct sockaddr * ) & addr -> addr ) , addr -> retries ) ; if ( MCA_OOB_TCP_FAILED == addr -> state ) { opal_output_verbose ( OOB_TCP_DEBUG_CONNECT , orte_oob_base_framework . framework_output , "%s<S2SV_blank>orte_tcp_peer_try_connect:<S2SV_blank>%s:%d<S2SV_blank>is<S2SV_blank>down" , ORTE_NAME_PRINT ( ORTE_PROC_MY_NAME ) , opal_net_get_hostname ( ( struct sockaddr * ) & addr -> addr ) , opal_net_get_port ( ( struct sockaddr * ) & addr -> addr ) ) ; continue ; } if ( mca_oob_tcp_component . max_retries < addr -> retries ) { opal_output_verbose ( OOB_TCP_DEBUG_CONNECT , orte_oob_base_framework . framework_output , "%s<S2SV_blank>orte_tcp_peer_try_connect:<S2SV_blank>%s:%d<S2SV_blank>retries<S2SV_blank>exceeded" , ORTE_NAME_PRINT ( ORTE_PROC_MY_NAME ) , opal_net_get_hostname ( ( struct sockaddr * ) & addr -> addr ) , opal_net_get_port ( ( struct sockaddr * ) & addr -> addr ) ) ; continue ; } peer -> active_addr = addr ; retry_connect : addr -> retries ++ ; if ( connect ( peer -> sd , ( struct sockaddr * ) & addr -> addr , addrlen ) < 0 ) { if ( opal_socket_errno == EINPROGRESS || opal_socket_errno == EWOULDBLOCK ) { opal_output_verbose ( OOB_TCP_DEBUG_CONNECT , orte_oob_base_framework . framework_output , "%s<S2SV_blank>waiting<S2SV_blank>for<S2SV_blank>connect<S2SV_blank>completion<S2SV_blank>to<S2SV_blank>%s<S2SV_blank>-<S2SV_blank>activating<S2SV_blank>send<S2SV_blank>event" , ORTE_NAME_PRINT ( ORTE_PROC_MY_NAME ) , ORTE_NAME_PRINT ( & peer -> name ) ) ; if ( ! peer -> send_ev_active ) { opal_event_add ( & peer -> send_event , 0 ) ; peer -> send_ev_active = true ; } OBJ_RELEASE ( op ) ; return ; } if ( ECONNABORTED == opal_socket_errno ) { if ( addr -> retries < mca_oob_tcp_component . max_retries ) { opal_output_verbose ( OOB_TCP_DEBUG_CONNECT , orte_oob_base_framework . framework_output , "%s<S2SV_blank>connection<S2SV_blank>aborted<S2SV_blank>by<S2SV_blank>OS<S2SV_blank>to<S2SV_blank>%s<S2SV_blank>-<S2SV_blank>retrying" , ORTE_NAME_PRINT ( ORTE_PROC_MY_NAME ) , ORTE_NAME_PRINT ( & peer -> name ) ) ; goto retry_connect ; } else { addr -> state = MCA_OOB_TCP_FAILED ; continue ; } } } else { addr -> retries = 0 ; connected = true ; peer -> num_retries = 0 ; break ; } } if ( ! connected ) { if ( 0 < mca_oob_tcp_component . retry_delay ) { if ( mca_oob_tcp_component . max_recon_attempts < 0 || peer -> num_retries < mca_oob_tcp_component . max_recon_attempts ) { struct timeval tv ; <S2SV_StartBug> OPAL_LIST_FOREACH ( addr , & peer -> addrs , mca_oob_tcp_addr_t ) { <S2SV_EndBug> addr -> state = MCA_OOB_TCP_UNCONNECTED ; addr -> retries = 0 ; } tv . tv_sec = mca_oob_tcp_component . retry_delay ; tv . tv_usec = 0 ; ++ peer -> num_retries ; ORTE_RETRY_TCP_CONN_STATE ( peer , mca_oob_tcp_peer_try_connect , & tv ) ; goto cleanup ; } } peer -> state = MCA_OOB_TCP_FAILED ; host = orte_get_proc_hostname ( & ( peer -> name ) ) ; if ( NULL == host && NULL != peer -> active_addr ) { host = opal_net_get_hostname ( ( struct sockaddr * ) & ( peer -> active_addr -> addr ) ) ; } opal_output ( orte_clean_output , "------------------------------------------------------------\\n" "A<S2SV_blank>process<S2SV_blank>or<S2SV_blank>daemon<S2SV_blank>was<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>complete<S2SV_blank>a<S2SV_blank>TCP<S2SV_blank>connection\\n" "to<S2SV_blank>another<S2SV_blank>process:\\n" "<S2SV_blank><S2SV_blank>Local<S2SV_blank>host:<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%s\\n" "<S2SV_blank><S2SV_blank>Remote<S2SV_blank>host:<S2SV_blank><S2SV_blank><S2SV_blank>%s\\n" "This<S2SV_blank>is<S2SV_blank>usually<S2SV_blank>caused<S2SV_blank>by<S2SV_blank>a<S2SV_blank>firewall<S2SV_blank>on<S2SV_blank>the<S2SV_blank>remote<S2SV_blank>host.<S2SV_blank>Please\\n" "check<S2SV_blank>that<S2SV_blank>any<S2SV_blank>firewall<S2SV_blank>(e.g.,<S2SV_blank>iptables)<S2SV_blank>has<S2SV_blank>been<S2SV_blank>disabled<S2SV_blank>and\\n" "try<S2SV_blank>again.\\n" "------------------------------------------------------------" , orte_process_info . nodename , ( NULL == host ) ? "<unknown>" : host ) ; <S2SV_StartBug> ORTE_ACTIVATE_TCP_CMP_OP ( peer , NULL , mca_oob_tcp_component_failed_to_connect ) ; <S2SV_EndBug> if ( NULL != peer -> send_msg ) { } while ( NULL != ( snd = ( mca_oob_tcp_send_t * ) opal_list_remove_first ( & peer -> send_queue ) ) ) { } goto cleanup ; } opal_output_verbose ( OOB_TCP_DEBUG_CONNECT , orte_oob_base_framework . framework_output , "%s<S2SV_blank>orte_tcp_peer_try_connect:<S2SV_blank>" "Connection<S2SV_blank>to<S2SV_blank>proc<S2SV_blank>%s<S2SV_blank>succeeded" , ORTE_NAME_PRINT ( ORTE_PROC_MY_NAME ) , ORTE_NAME_PRINT ( & peer -> name ) ) ; if ( ! peer -> recv_ev_active ) { opal_event_add ( & peer -> recv_event , 0 ) ; peer -> recv_ev_active = true ; } if ( ORTE_SUCCESS == ( rc = tcp_peer_send_connect_ack ( peer ) ) ) { peer -> state = MCA_OOB_TCP_CONNECT_ACK ; } else if ( ORTE_ERR_UNREACH == rc ) { int cmpval = orte_util_compare_name_fields ( ORTE_NS_CMP_ALL , ORTE_PROC_MY_NAME , & peer -> name ) ; if ( OPAL_VALUE1_GREATER == cmpval ) { peer -> state = MCA_OOB_TCP_CONNECTING ; ORTE_ACTIVATE_TCP_CONN_STATE ( peer , mca_oob_tcp_peer_try_connect ) ; } else { peer -> state = MCA_OOB_TCP_UNCONNECTED ; } <S2SV_StartBug> return ; <S2SV_EndBug> } else { opal_output ( 0 , "%s<S2SV_blank>orte_tcp_peer_try_connect:<S2SV_blank>" "tcp_peer_send_connect_ack<S2SV_blank>to<S2SV_blank>proc<S2SV_blank>%s<S2SV_blank>on<S2SV_blank>%s:%d<S2SV_blank>failed:<S2SV_blank>%s<S2SV_blank>(%d)" , ORTE_NAME_PRINT ( ORTE_PROC_MY_NAME ) , ORTE_NAME_PRINT ( & ( peer -> name ) ) , opal_net_get_hostname ( ( struct sockaddr * ) & addr -> addr ) , opal_net_get_port ( ( struct sockaddr * ) & addr -> addr ) , opal_strerror ( rc ) , rc ) ; <S2SV_StartBug> ORTE_FORCED_TERMINATE ( 1 ) ; <S2SV_EndBug> } cleanup : OBJ_RELEASE ( op ) ; } | <S2SV_ModStart> timeval tv ; CLOSE_THE_SOCKET ( peer -> sd ) ; <S2SV_ModStart> host ) ; CLOSE_THE_SOCKET ( peer -> sd ) ; <S2SV_ModStart> MCA_OOB_TCP_UNCONNECTED ; } CLOSE_THE_SOCKET ( peer -> sd ) ; <S2SV_ModStart> rc ) ; CLOSE_THE_SOCKET ( peer -> sd ) ; |
2,777 | CWE-000 spi_errCode spi_rx_one_data_unit ( const spi_settings setting , uint8_t * totalByteRxed , uint8_t * dataRx ) { <S2SV_StartBug> GPIO_PORTA_DATA_R &= ~ 0x8 ; <S2SV_EndBug> spi_enable_spi ( ) ; delayms ( 5 ) ; if ( spi_check_rx_not_empty ( ) == ERR_NO_ERR ) { <S2SV_StartBug> spi_wait_busy ( ) ; <S2SV_EndBug> uint8_t tempRxData = SSI0_DR_R & 0x000000FF ; <S2SV_StartBug> dataRx [ * totalByteRxed ] = tempRxData ; <S2SV_EndBug> * totalByteRxed = * totalByteRxed + 1 ; } return ERR_NO_ERR ; } | <S2SV_ModStart> dataRx ) { spi_wait_busy ( <S2SV_ModEnd> ) ; if <S2SV_ModStart> ERR_NO_ERR ) { <S2SV_ModEnd> dataRx [ * <S2SV_ModStart> totalByteRxed ] = SSI0_DR_R & 0x000000FF <S2SV_ModEnd> ; * totalByteRxed |
2,778 | CWE-000 arc_buf_t * arc_alloc_buf ( spa_t * spa , void * tag , arc_buf_contents_t type , int32_t size ) { arc_buf_hdr_t * hdr = arc_hdr_alloc ( spa_load_guid ( spa ) , size , size , <S2SV_StartBug> B_FALSE , ZIO_COMPRESS_OFF , type , B_FALSE ) ; <S2SV_EndBug> ASSERT ( ! MUTEX_HELD ( HDR_LOCK ( hdr ) ) ) ; arc_buf_t * buf = NULL ; VERIFY0 ( arc_buf_alloc_impl ( hdr , spa , NULL , tag , B_FALSE , B_FALSE , B_FALSE , B_FALSE , & buf ) ) ; arc_buf_thaw ( buf ) ; return ( buf ) ; } | <S2SV_ModStart> type , B_FALSE <S2SV_ModEnd> ) ; arc_buf_t |
2,779 | CWE-000 long drm_ioctl ( struct file * filp , unsigned int cmd , unsigned long arg ) { struct drm_file * file_priv = filp -> private_data ; struct drm_device * dev ; const struct drm_ioctl_desc * ioctl = NULL ; drm_ioctl_t * func ; unsigned int nr = DRM_IOCTL_NR ( cmd ) ; int retcode = - EINVAL ; char stack_kdata [ 128 ] ; char * kdata = NULL ; unsigned int in_size , out_size , drv_size , ksize ; bool is_driver_ioctl ; <S2SV_StartBug> dev = file_priv -> minor -> dev ; <S2SV_EndBug> if ( drm_device_is_unplugged ( dev ) ) return - ENODEV ; is_driver_ioctl = nr >= DRM_COMMAND_BASE && nr < DRM_COMMAND_END ; if ( is_driver_ioctl ) { if ( nr - DRM_COMMAND_BASE >= dev -> driver -> num_ioctls ) goto err_i1 ; ioctl = & dev -> driver -> ioctls [ nr - DRM_COMMAND_BASE ] ; } else { if ( nr >= DRM_CORE_IOCTL_COUNT ) goto err_i1 ; ioctl = & drm_ioctls [ nr ] ; } drv_size = _IOC_SIZE ( ioctl -> cmd ) ; out_size = in_size = _IOC_SIZE ( cmd ) ; if ( ( cmd & ioctl -> cmd & IOC_IN ) == 0 ) in_size = 0 ; if ( ( cmd & ioctl -> cmd & IOC_OUT ) == 0 ) out_size = 0 ; ksize = max ( max ( in_size , out_size ) , drv_size ) ; DRM_DEBUG ( "pid=%d,<S2SV_blank>dev=0x%lx,<S2SV_blank>auth=%d,<S2SV_blank>%s\\n" , task_pid_nr ( current ) , ( long ) old_encode_dev ( file_priv -> minor -> kdev -> devt ) , file_priv -> authenticated , ioctl -> name ) ; <S2SV_StartBug> func = ioctl -> func ; <S2SV_EndBug> if ( unlikely ( ! func ) ) { DRM_DEBUG ( "no<S2SV_blank>function\\n" ) ; retcode = - EINVAL ; goto err_i1 ; } <S2SV_StartBug> retcode = drm_ioctl_permit ( ioctl -> flags , file_priv ) ; <S2SV_EndBug> if ( unlikely ( retcode ) ) goto err_i1 ; if ( ksize <= sizeof ( stack_kdata ) ) { kdata = stack_kdata ; } else { kdata = kmalloc ( ksize , GFP_KERNEL ) ; if ( ! kdata ) { retcode = - ENOMEM ; goto err_i1 ; } } if ( copy_from_user ( kdata , ( void __user * ) arg , in_size ) != 0 ) { retcode = - EFAULT ; goto err_i1 ; } if ( ksize > in_size ) memset ( kdata + in_size , 0 , ksize - in_size ) ; if ( ! drm_core_check_feature ( dev , DRIVER_LEGACY ) || <S2SV_StartBug> ( ioctl -> flags & DRM_UNLOCKED ) ) <S2SV_EndBug> retcode = func ( dev , kdata , file_priv ) ; else { mutex_lock ( & drm_global_mutex ) ; retcode = func ( dev , kdata , file_priv ) ; mutex_unlock ( & drm_global_mutex ) ; } if ( copy_to_user ( ( void __user * ) arg , kdata , out_size ) != 0 ) retcode = - EFAULT ; err_i1 : if ( ! ioctl ) DRM_DEBUG ( "invalid<S2SV_blank>ioctl:<S2SV_blank>pid=%d,<S2SV_blank>dev=0x%lx,<S2SV_blank>auth=%d,<S2SV_blank>cmd=0x%02x,<S2SV_blank>nr=0x%02x\\n" , task_pid_nr ( current ) , ( long ) old_encode_dev ( file_priv -> minor -> kdev -> devt ) , file_priv -> authenticated , cmd , nr ) ; if ( kdata != stack_kdata ) kfree ( kdata ) ; if ( retcode ) DRM_DEBUG ( "ret<S2SV_blank>=<S2SV_blank>%d\\n" , retcode ) ; return retcode ; } | <S2SV_ModStart> bool is_driver_ioctl ; int flags ; <S2SV_ModStart> name ) ; flags = ioctl -> flags ; if ( drm_master_relax ) { if ( nr == DRM_IOCTL_NR ( DRM_IOCTL_SET_MASTER ) ) flags = DRM_AUTH ; else if ( nr == DRM_IOCTL_NR ( DRM_IOCTL_DROP_MASTER ) ) flags = DRM_MASTER ; } <S2SV_ModStart> = drm_ioctl_permit ( <S2SV_ModEnd> flags , file_priv <S2SV_ModStart> ) || ( <S2SV_ModEnd> flags & DRM_UNLOCKED |
2,780 | CWE-000 static int connect_conn_chk ( struct task * t ) { struct check * check = t -> context ; struct server * s = check -> server ; struct conn_stream * cs = check -> cs ; struct connection * conn = cs_conn ( cs ) ; struct protocol * proto ; struct tcpcheck_rule * tcp_rule = NULL ; int ret ; int quickack ; if ( conn ) return SF_ERR_INTERNAL ; if ( check -> type == PR_O2_TCPCHK_CHK ) { check -> current_step = NULL ; tcp_rule = get_first_tcpcheck_rule ( check -> tcpcheck_rules ) ; } if ( check -> type && check -> type != PR_O2_TCPCHK_CHK && ! ( check -> state & CHK_ST_AGENT ) ) { bo_putblk ( check -> bo , s -> proxy -> check_req , s -> proxy -> check_len ) ; if ( ( check -> type ) == PR_O2_SSL3_CHK ) { int gmt_time = htonl ( date . tv_sec ) ; memcpy ( check -> bo -> data + 11 , & gmt_time , 4 ) ; } else if ( ( check -> type ) == PR_O2_HTTP_CHK ) { if ( s -> proxy -> options2 & PR_O2_CHK_SNDST ) bo_putblk ( check -> bo , trash . str , httpchk_build_status_header ( s , trash . str , trash . size ) ) ; if ( s -> proxy -> options2 & PR_O2_EXP_TYPE ) bo_putstr ( check -> bo , "Connection:<S2SV_blank>close\\r\\n" ) ; bo_putstr ( check -> bo , "\\r\\n" ) ; * check -> bo -> p = '\\0' ; } } if ( ( check -> type & PR_O2_LB_AGENT_CHK ) && check -> send_string_len ) { bo_putblk ( check -> bo , check -> send_string , check -> send_string_len ) ; } if ( tcp_rule && tcp_rule -> action == TCPCHK_ACT_CONNECT ) { tcpcheck_main ( check ) ; return SF_ERR_UP ; } cs = check -> cs = cs_new ( NULL ) ; if ( ! check -> cs ) return SF_ERR_RESOURCE ; conn = cs -> conn ; if ( is_addr ( & check -> addr ) ) { conn -> addr . to = check -> addr ; } else { conn -> addr . to = s -> addr ; } <S2SV_StartBug> if ( ( conn -> addr . to . ss_family == AF_INET ) || ( conn -> addr . to . ss_family == AF_INET6 ) ) { <S2SV_EndBug> int i = 0 ; i = srv_check_healthcheck_port ( check ) ; <S2SV_StartBug> if ( i == 0 ) { <S2SV_EndBug> cs -> data = check ; return SF_ERR_CHK_PORT ; <S2SV_StartBug> } <S2SV_EndBug> set_host_port ( & conn -> addr . to , i ) ; } <S2SV_StartBug> proto = protocol_by_family ( conn -> addr . to . ss_family ) ; <S2SV_EndBug> conn_prepare ( conn , proto , check -> xprt ) ; conn_install_mux ( conn , & mux_pt_ops , cs ) ; cs_attach ( cs , check , & check_conn_cb ) ; conn -> target = & s -> obj_type ; clear_addr ( & conn -> addr . from ) ; quickack = check -> type == 0 || check -> type == PR_O2_TCPCHK_CHK ; if ( tcp_rule && tcp_rule -> action == TCPCHK_ACT_EXPECT ) quickack = 0 ; ret = SF_ERR_INTERNAL ; if ( proto && proto -> connect ) ret = proto -> connect ( conn , check -> type , quickack ? 2 : 0 ) ; if ( check -> type ) cs_want_send ( cs ) ; # ifdef USE_OPENSSL if ( s -> check . sni ) ssl_sock_set_servername ( conn , s -> check . sni ) ; # endif if ( s -> check . send_proxy && ! ( check -> state & CHK_ST_AGENT ) ) { conn -> send_proxy_ofs = 1 ; conn -> flags |= CO_FL_SEND_PROXY ; } return ret ; } | <S2SV_ModStart> addr ; } proto = protocol_by_family ( conn -> addr . to . ss_family ) ; conn_prepare ( conn , proto , check -> xprt ) ; conn_install_mux ( conn , & mux_pt_ops , cs ) ; cs_attach ( cs , check , & check_conn_cb ) ; conn -> target = & s -> obj_type ; <S2SV_ModStart> == 0 ) <S2SV_ModEnd> return SF_ERR_CHK_PORT ; <S2SV_ModStart> return SF_ERR_CHK_PORT ; <S2SV_ModEnd> set_host_port ( & <S2SV_ModStart> ) ; } <S2SV_ModEnd> clear_addr ( & |
2,781 | CWE-000 void glist_drawiofor ( t_glist * glist , t_object * ob , int firsttime , char * tag , int x1 , int y1 , int x2 , int y2 ) { int n = obj_noutlets ( ob ) , nplus = ( n == 1 ? 1 : n - 1 ) , i ; int width = x2 - x1 ; int iow = IOWIDTH * glist -> gl_zoom , ioh = IOHEIGHT * glist -> gl_zoom ; for ( i = 0 ; i < n ; i ++ ) { int onset = x1 + ( width - iow ) * i / nplus ; if ( firsttime ) <S2SV_StartBug> sys_vgui ( ".x%lx.c<S2SV_blank>create<S2SV_blank>rectangle<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>\\\n<S2SV_blank>-tags<S2SV_blank>[list<S2SV_blank>%so%d<S2SV_blank>outlet]<S2SV_blank>-fill<S2SV_blank>black\\n" , <S2SV_EndBug> glist_getcanvas ( glist ) , onset , y2 - ioh + glist -> gl_zoom , onset + iow , y2 , tag , i ) ; else sys_vgui ( ".x%lx.c<S2SV_blank>coords<S2SV_blank>%so%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d\\n" , glist_getcanvas ( glist ) , tag , i , onset , y2 - ioh + glist -> gl_zoom , onset + iow , y2 ) ; } n = obj_ninlets ( ob ) ; nplus = ( n == 1 ? 1 : n - 1 ) ; for ( i = 0 ; i < n ; i ++ ) { int onset = x1 + ( width - iow ) * i / nplus ; if ( firsttime ) <S2SV_StartBug> sys_vgui ( ".x%lx.c<S2SV_blank>create<S2SV_blank>rectangle<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>\\\n<S2SV_blank>-tags<S2SV_blank>[list<S2SV_blank>%si%d<S2SV_blank>inlet]<S2SV_blank>-fill<S2SV_blank>black\\n" , <S2SV_EndBug> glist_getcanvas ( glist ) , onset , y1 , onset + iow , y1 + ioh - glist -> gl_zoom , tag , i ) ; else sys_vgui ( ".x%lx.c<S2SV_blank>coords<S2SV_blank>%si%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d\\n" , glist_getcanvas ( glist ) , tag , i , onset , y1 , onset + iow , y1 + ioh - glist -> gl_zoom ) ; } } | <S2SV_ModStart> ) sys_vgui ( ".x%lx.c<S2SV_blank>create<S2SV_blank>rectangle<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>" "-tags<S2SV_blank>[list<S2SV_blank>%so%d<S2SV_blank>outlet]<S2SV_blank>-fill<S2SV_blank>black\\n" <S2SV_ModEnd> , glist_getcanvas ( <S2SV_ModStart> ) sys_vgui ( ".x%lx.c<S2SV_blank>create<S2SV_blank>rectangle<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>" "-tags<S2SV_blank>[list<S2SV_blank>%si%d<S2SV_blank>inlet]<S2SV_blank>-fill<S2SV_blank>black\\n" <S2SV_ModEnd> , glist_getcanvas ( |
2,782 | CWE-000 static void hdd_conf_suspend_ind ( hdd_context_t * pHddCtx , hdd_adapter_t * pAdapter ) { eHalStatus halStatus = eHAL_STATUS_FAILURE ; tpSirWlanSuspendParam wlanSuspendParam = vos_mem_malloc ( sizeof ( tSirWlanSuspendParam ) ) ; check_and_set_suspend_resume_mcbc_filter ( pHddCtx ) ; if ( NULL == wlanSuspendParam ) { hddLog ( VOS_TRACE_LEVEL_FATAL , "%s:<S2SV_blank>vos_mem_alloc<S2SV_blank>failed<S2SV_blank>" , __func__ ) ; return ; } hddLog ( VOS_TRACE_LEVEL_INFO , "%s:<S2SV_blank>send<S2SV_blank>wlan<S2SV_blank>suspend<S2SV_blank>indication" , __func__ ) ; if ( ( pHddCtx -> cfg_ini -> nEnableSuspend == WLAN_MAP_SUSPEND_TO_MCAST_BCAST_FILTER ) ) { hdd_conf_hostoffload ( pAdapter , TRUE ) ; wlanSuspendParam -> configuredMcstBcstFilterSetting = pHddCtx -> configuredMcastBcastFilter ; hddLog ( VOS_TRACE_LEVEL_INFO , FL ( "saving<S2SV_blank>configuredMcastBcastFilterSetting<S2SV_blank>=<S2SV_blank>%d" ) , wlanSuspendParam -> configuredMcstBcstFilterSetting ) ; # ifdef WLAN_FEATURE_PACKET_FILTERING <S2SV_StartBug> wlan_hdd_set_mc_addr_list ( pAdapter , TRUE ) ; <S2SV_EndBug> # endif if ( ( pHddCtx -> cfg_ini -> fEnableMCAddrList ) && WDA_IS_MCAST_FLT_ENABLE_IN_FW ) { hddLog ( VOS_TRACE_LEVEL_INFO , "offload:<S2SV_blank>MCaddrlist:<S2SV_blank>FW<S2SV_blank>capability<S2SV_blank>set<S2SV_blank>" ) ; pHddCtx -> configuredMcastBcastFilter &= ~ ( HDD_MCASTBCASTFILTER_FILTER_ALL_MULTICAST ) ; } wlanSuspendParam -> configuredMcstBcstFilterSetting = pHddCtx -> configuredMcastBcastFilter ; wlanSuspendParam -> wlan_sus_callback = hdd_suspend_ind_callback ; wlanSuspendParam -> context = pAdapter ; hdd_mc_addr_list_cfg_config ( pHddCtx , true ) ; } halStatus = sme_ConfigureSuspendInd ( pHddCtx -> hHal , wlanSuspendParam ) ; if ( eHAL_STATUS_SUCCESS == halStatus ) { pHddCtx -> hdd_mcastbcast_filter_set = TRUE ; } else { hddLog ( VOS_TRACE_LEVEL_ERROR , FL ( "sme_ConfigureSuspendInd<S2SV_blank>returned<S2SV_blank>failure<S2SV_blank>%d" ) , halStatus ) ; vos_mem_free ( wlanSuspendParam ) ; } } | <S2SV_ModStart> # ifdef WLAN_FEATURE_PACKET_FILTERING <S2SV_ModEnd> # endif if |
2,783 | CWE-000 static void close_connection ( connection_list_element * connection , const char * message ) { struct connection_pool_data * conn_data = & connection -> connection_data ; <S2SV_StartBug> pthread_mutex_lock ( & g_connections_mutex ) ; <S2SV_EndBug> LL_DELETE ( g_connection_list_head , connection ) ; -- g_connections_count ; g_connection_changed = 1 ; close ( conn_data -> connection_descriptor . fd ) ; if ( conn_data -> block ) { free ( conn_data -> block ) ; } if ( conn_data -> worker_name ) { free ( conn_data -> worker_name ) ; } if ( conn_data -> miner ) { -- conn_data -> miner -> connections_count ; if ( conn_data -> miner -> connections_count == 0 ) { <S2SV_StartBug> conn_data -> miner -> state = MINER_ARCHIVE ; <S2SV_EndBug> } } pthread_mutex_unlock ( & g_connections_mutex ) ; uint32_t ip = conn_data -> ip ; uint16_t port = conn_data -> port ; if ( conn_data -> miner ) { char address_buf [ 33 ] = { 0 } ; <S2SV_StartBug> xdag_hash2address ( conn_data -> miner -> id . data , address_buf ) ; <S2SV_EndBug> xdag_info ( "Pool:<S2SV_blank>miner<S2SV_blank>%s<S2SV_blank>disconnected<S2SV_blank>from<S2SV_blank>%u.%u.%u.%u:%u<S2SV_blank>by<S2SV_blank>%s" , address_buf , ip & 0xff , ip >> 8 & 0xff , ip >> 16 & 0xff , ip >> 24 & 0xff , ntohs ( port ) , message ) ; } else { xdag_info ( "Pool:<S2SV_blank>disconnected<S2SV_blank>from<S2SV_blank>%u.%u.%u.%u:%u<S2SV_blank>by<S2SV_blank>%s" , ip & 0xff , ip >> 8 & 0xff , ip >> 16 & 0xff , ip >> 24 & 0xff , ntohs ( port ) , message ) ; } free ( connection ) ; } | <S2SV_ModStart> -> connection_data ; struct xdag_field id ; enum miner_state state = MINER_UNKNOWN ; <S2SV_ModStart> 0 ) { state = <S2SV_ModStart> state = MINER_ARCHIVE ; id = conn_data -> miner -> id ; } else { state = conn_data -> miner -> state <S2SV_ModStart> ; xdag_hash2address ( ( state == MINER_ARCHIVE ? <S2SV_ModEnd> id . data <S2SV_ModStart> id . data : conn_data -> miner -> id . data ) |
2,784 | CWE-000 static int parse_pem_cert_mem ( gnutls_certificate_credentials_t res , const char * input_cert , int input_cert_size ) { int size ; const char * ptr ; gnutls_datum_t tmp ; int ret , count , i ; unsigned ncerts = 0 ; gnutls_pcert_st * pcerts = NULL ; gnutls_str_array_t names ; gnutls_x509_crt_t unsorted [ DEFAULT_MAX_VERIFY_DEPTH ] ; _gnutls_str_array_init ( & names ) ; ptr = memmem ( input_cert , input_cert_size , PEM_CERT_SEP , sizeof ( PEM_CERT_SEP ) - 1 ) ; if ( ptr == NULL ) ptr = memmem ( input_cert , input_cert_size , PEM_CERT_SEP2 , sizeof ( PEM_CERT_SEP2 ) - 1 ) ; if ( ptr == NULL ) { gnutls_assert ( ) ; return GNUTLS_E_BASE64_DECODING_ERROR ; } size = input_cert_size - ( ptr - input_cert ) ; count = 0 ; do { tmp . data = ( void * ) ptr ; tmp . size = size ; ret = gnutls_x509_crt_init ( & unsorted [ count ] ) ; if ( ret < 0 ) { gnutls_assert ( ) ; goto cleanup ; } ret = gnutls_x509_crt_import ( unsorted [ count ] , & tmp , GNUTLS_X509_FMT_PEM ) ; if ( ret < 0 ) { gnutls_assert ( ) ; goto cleanup ; } count ++ ; ptr ++ ; <S2SV_StartBug> size = input_cert_size - ( ptr - input_cert ) ; <S2SV_EndBug> if ( size > 0 ) { char * ptr3 ; ptr3 = memmem ( ptr , size , PEM_CERT_SEP , sizeof ( PEM_CERT_SEP ) - 1 ) ; if ( ptr3 == NULL ) ptr3 = memmem ( ptr , size , PEM_CERT_SEP2 , sizeof ( PEM_CERT_SEP2 ) - 1 ) ; ptr = ptr3 ; <S2SV_StartBug> } else <S2SV_EndBug> ptr = NULL ; } while ( ptr != NULL && count < DEFAULT_MAX_VERIFY_DEPTH ) ; ret = get_x509_name ( unsorted [ 0 ] , & names ) ; if ( ret < 0 ) { gnutls_assert ( ) ; goto cleanup ; } pcerts = gnutls_malloc ( sizeof ( gnutls_pcert_st ) * count ) ; if ( pcerts == NULL ) { gnutls_assert ( ) ; return GNUTLS_E_MEMORY_ERROR ; } ncerts = count ; ret = gnutls_pcert_import_x509_list ( pcerts , unsorted , & ncerts , GNUTLS_X509_CRT_LIST_SORT ) ; if ( ret < 0 ) { gnutls_free ( pcerts ) ; pcerts = NULL ; gnutls_assert ( ) ; goto cleanup ; } ret = certificate_credential_append_crt_list ( res , names , pcerts , ncerts ) ; if ( ret < 0 ) { gnutls_assert ( ) ; goto cleanup ; } for ( i = 0 ; i < count ; i ++ ) gnutls_x509_crt_deinit ( unsorted [ i ] ) ; return ncerts ; cleanup : _gnutls_str_array_clear ( & names ) ; for ( i = 0 ; i < count ; i ++ ) gnutls_x509_crt_deinit ( unsorted [ i ] ) ; if ( pcerts ) { for ( i = 0 ; i < count ; i ++ ) gnutls_pcert_deinit ( & pcerts [ i ] ) ; gnutls_free ( pcerts ) ; } return ret ; } | <S2SV_ModStart> ++ ; size -- <S2SV_ModEnd> ; if ( <S2SV_ModStart> = ptr3 ; size = input_cert_size - ( ptr - input_cert ) ; |
2,785 | CWE-000 char * dirfs ( char * path ) { struct statfs st ; char * fs ; if ( statfs ( path , & st ) == - 1 ) err ( 1 , NULL ) ; <S2SV_StartBug> fs = & st . f_fstypename ; <S2SV_EndBug> return fs ; } | <S2SV_ModStart> ; fs = <S2SV_ModEnd> st . f_fstypename |
2,786 | CWE-000 struct net_device * rtw_init_netdev ( struct rtw_adapter * old_padapter ) { struct rtw_adapter * padapter ; struct net_device * pnetdev ; RT_TRACE ( _module_os_intfs_c_ , _drv_info_ , ( "+init_net_dev\\n" ) ) ; if ( old_padapter != NULL ) pnetdev = rtw_alloc_etherdev_with_old_priv ( sizeof ( struct rtw_adapter ) , ( void * ) old_padapter ) ; else pnetdev = rtw_alloc_etherdev ( sizeof ( struct rtw_adapter ) ) ; <S2SV_StartBug> if ( ! pnetdev ) <S2SV_EndBug> <S2SV_StartBug> return NULL ; <S2SV_EndBug> pnetdev -> dev . type = & wlan_type ; padapter = rtw_netdev_priv ( pnetdev ) ; padapter -> pnetdev = pnetdev ; # if LINUX_VERSION_CODE < KERNEL_VERSION ( 2 , 6 , 24 ) SET_MODULE_OWNER ( pnetdev ) ; # endif # if ( LINUX_VERSION_CODE >= KERNEL_VERSION ( 2 , 6 , 29 ) ) DBG_8192D ( "register<S2SV_blank>rtw_netdev_ops<S2SV_blank>to<S2SV_blank>netdev_ops\\n" ) ; pnetdev -> netdev_ops = & rtw_netdev_ops ; # else pnetdev -> open = netdev_open ; pnetdev -> stop = netdev_close ; pnetdev -> hard_start_xmit = rtw_xmit_entry ; pnetdev -> set_mac_address = rtw_net_set_mac_address ; pnetdev -> get_stats = rtw_net_get_stats ; pnetdev -> do_ioctl = rtw_ioctl ; # endif # ifdef CONFIG_TCP_CSUM_OFFLOAD_TX pnetdev -> features |= NETIF_F_IP_CSUM ; # endif pnetdev -> watchdog_timeo = HZ * 3 ; # ifdef CONFIG_WIRELESS_EXT pnetdev -> wireless_handlers = ( struct iw_handler_def * ) & rtw_handlers_def ; # endif loadparam ( padapter , pnetdev ) ; return pnetdev ; } | <S2SV_ModStart> ! pnetdev ) { pr_err ( "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>ether<S2SV_blank>device\\n" ) ; <S2SV_ModStart> return NULL ; } |
2,787 | CWE-000 pde_t * setupkvm ( void ) { pde_t * pgdir ; struct kmap * k ; if ( ( pgdir = ( pde_t * ) kalloc ( ) ) == 0 ) return 0 ; <S2SV_StartBug> pde_t ( * pgdir ) [ NPDENTRIES ] = ( pde_t ( * ) [ NPDENTRIES ] ) pgdir ; <S2SV_EndBug> memset ( pgdir , 0 , PGSIZE ) ; if ( P2V ( PHYSTOP ) > ( void * ) DEVSPACE ) panic ( "PHYSTOP<S2SV_blank>too<S2SV_blank>high" ) ; for ( k = kmap ; k < & kmap [ NELEM ( kmap ) ] ; k ++ ) if ( mappages ( pgdir , k -> virt , k -> phys_end - k -> phys_start , ( uint ) k -> phys_start , k -> perm ) < 0 ) { freevm ( pgdir ) ; return 0 ; } return pgdir ; } | <S2SV_ModStart> pgdir ) [ NPDPENTRIES <S2SV_ModEnd> ] = ( <S2SV_ModStart> * ) [ NPDPENTRIES <S2SV_ModEnd> ] ) pgdir |
2,788 | CWE-000 void _i386_elf_sections_read ( ) { elf_section_header_t * cur_header = ( elf_section_header_t * ) meminfo . elf_sec -> addr ; <S2SV_StartBug> meminfo . kernel_reserved_start = ( cur_header + 1 ) -> sh_addr ; <S2SV_EndBug> <S2SV_StartBug> meminfo . kernel_reserved_end = ( cur_header + ( meminfo . elf_sec -> num ) - 1 ) -> sh_addr ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> -> addr ; ++ cur_header ; <S2SV_ModStart> . kernel_reserved_start = cur_header <S2SV_ModEnd> -> sh_addr ; <S2SV_ModStart> . kernel_reserved_end = 0 ; uint32_t i = 0 ; for ( i = 0 ; i < <S2SV_ModEnd> meminfo . elf_sec <S2SV_ModStart> elf_sec -> num - 1 ; i ++ ) { if ( cur_header -> sh_addr > meminfo . kernel_reserved_end ) { meminfo . kernel_reserved_end = cur_header <S2SV_ModEnd> -> sh_addr ; <S2SV_ModStart> sh_addr ; } ++ cur_header ; } meminfo . kernel_reserved_end += meminfo . kernel_reserved_end % 0x1000 ; } |
2,789 | CWE-000 void help_routine ( ) { printf ( "Available<S2SV_blank>commands:\\n\\n" ) ; printf ( "uberforcer<S2SV_blank>help\\t\\t\\t\\t\\tshow<S2SV_blank>help<S2SV_blank>file\\n" ) ; printf ( "uberforcer<S2SV_blank>crypt<S2SV_blank><password><S2SV_blank><salt>\\t\\tencrypt<S2SV_blank>provided<S2SV_blank><password>,<S2SV_blank>using<S2SV_blank>provided<S2SV_blank><salt>\\n" ) ; printf ( "uberforcer<S2SV_blank>decrypt<S2SV_blank><hash><S2SV_blank><args>\\t\\tbruteforce<S2SV_blank>provided<S2SV_blank><hash>,<S2SV_blank>using<S2SV_blank>additional<S2SV_blank>arguments<S2SV_blank><args><S2SV_blank>[optional].<S2SV_blank>available<S2SV_blank>arguments:<S2SV_blank>-r,<S2SV_blank>-i,<S2SV_blank>-a,<S2SV_blank>-l,<S2SV_blank>-t\\n" ) ; printf ( "uberforcer<S2SV_blank>benchmark<S2SV_blank><args>\\t\\t\\tperform<S2SV_blank>benchmarking,<S2SV_blank>using<S2SV_blank>bruteforcing<S2SV_blank>arguments<S2SV_blank><args><S2SV_blank>[optional].<S2SV_blank>available<S2SV_blank>arguments:<S2SV_blank>-r,<S2SV_blank>-i,<S2SV_blank>-a,<S2SV_blank>-l,<S2SV_blank>-t\\n" ) ; <S2SV_StartBug> printf ( "uberforcer<S2SV_blank>server<S2SV_blank><port><S2SV_blank><args>\\t\\t\\tstart<S2SV_blank>bruteforcing<S2SV_blank>server<S2SV_blank>on<S2SV_blank>the<S2SV_blank>provided<S2SV_blank>port,<S2SV_blank>using<S2SV_blank>bruteforcing<S2SV_blank>arguments<S2SV_blank><args><S2SV_blank>[optional].<S2SV_blank>available<S2SV_blank>arguments:<S2SV_blank>-r,<S2SV_blank>-i,<S2SV_blank>-a,<S2SV_blank>-l\\n" ) ; <S2SV_EndBug> printf ( "uberforcer<S2SV_blank>client<S2SV_blank><host><S2SV_blank><port><S2SV_blank><args>\\t\\tstart<S2SV_blank>bruteforcing<S2SV_blank>client<S2SV_blank>to<S2SV_blank>connect<S2SV_blank>to<S2SV_blank>server<S2SV_blank>on<S2SV_blank><host>:<port>,<S2SV_blank>using<S2SV_blank>bruteforcing<S2SV_blank>arguments<S2SV_blank><args><S2SV_blank>[optional].<S2SV_blank>available<S2SV_blank>arguments:<S2SV_blank>-r,<S2SV_blank>-i,<S2SV_blank>-t\\n" ) ; printf ( "\\n" ) ; printf ( "Available<S2SV_blank><args><S2SV_blank>arguments:\\n" ) ; printf ( "-r<S2SV_blank>or<S2SV_blank>--recursive\\t\\t\\t\\tuse<S2SV_blank>recursive<S2SV_blank>bruteforcing<S2SV_blank>algorithm;<S2SV_blank>mutually<S2SV_blank>exclusive<S2SV_blank>with<S2SV_blank>--iterative\\n" ) ; printf ( "-i<S2SV_blank>or<S2SV_blank>--iterative\\t\\t\\t\\t[default]<S2SV_blank>use<S2SV_blank>iterative<S2SV_blank>bruteforcing<S2SV_blank>algorithm;<S2SV_blank>mutually<S2SV_blank>exclusive<S2SV_blank>with<S2SV_blank>--recursive\\n" ) ; printf ( "-a<S2SV_blank><value><S2SV_blank>or<S2SV_blank>--alphabet<S2SV_blank><value>\\t\\tavailable<S2SV_blank>alphabet;<S2SV_blank>default:<S2SV_blank>[A-Za-z0-9]\\n" ) ; printf ( "-l<S2SV_blank><value><S2SV_blank>or<S2SV_blank>--length<S2SV_blank><value>\\t\\t\\tpresumed<S2SV_blank>length<S2SV_blank>of<S2SV_blank>password;<S2SV_blank>default:<S2SV_blank>4\\n" ) ; printf ( "-t<S2SV_blank><value><S2SV_blank>or<S2SV_blank>--threads<S2SV_blank><value>\\t\\t\\tNumber<S2SV_blank>of<S2SV_blank>threads<S2SV_blank>for<S2SV_blank>multithreading<S2SV_blank>bruteforce;<S2SV_blank>default:<S2SV_blank>1\\n" ) ; } | <S2SV_ModStart> ; printf ( "uberforcer<S2SV_blank>server<S2SV_blank><hash><S2SV_blank><port><S2SV_blank><args>\\t\\t\\tstart<S2SV_blank>bruteforcing<S2SV_blank>server<S2SV_blank>on<S2SV_blank>the<S2SV_blank>provided<S2SV_blank>port,<S2SV_blank>to<S2SV_blank>bruteforce<S2SV_blank><hash>,<S2SV_blank>using<S2SV_blank>bruteforcing<S2SV_blank>arguments<S2SV_blank><args><S2SV_blank>[optional].<S2SV_blank>available<S2SV_blank>arguments:<S2SV_blank>-r,<S2SV_blank>-i,<S2SV_blank>-a,<S2SV_blank>-l\\n" <S2SV_ModEnd> ) ; printf |
2,790 | CWE-000 void pre_auton ( ) { <S2SV_StartBug> bDisplayCompetitonStatusOnLcd = false ; <S2SV_EndBug> } | <S2SV_ModStart> ( ) { bDisplayCompetitionStatusOnLcd <S2SV_ModEnd> = false ; |
2,791 | CWE-000 int qdr_forward_closest_CT ( qdr_core_t * core , qdr_address_t * addr , qd_message_t * msg , qdr_delivery_t * in_delivery , bool exclude_inprocess , bool control ) { qdr_link_t * out_link ; qdr_delivery_t * out_delivery ; if ( ! exclude_inprocess ) { bool receive_complete = qd_message_receive_complete ( msg ) ; qdr_subscription_t * sub = DEQ_HEAD ( addr -> subscriptions ) ; if ( sub ) { if ( receive_complete ) qdr_forward_on_message_CT ( core , sub , in_delivery ? in_delivery -> link : 0 , msg ) ; <S2SV_StartBug> else <S2SV_EndBug> <S2SV_StartBug> DEQ_INSERT_TAIL ( in_delivery -> subscriptions , sub ) ; <S2SV_EndBug> if ( in_delivery && ! in_delivery -> settled ) { in_delivery -> disposition = PN_ACCEPTED ; in_delivery -> settled = true ; qdr_delivery_push_CT ( core , in_delivery ) ; } if ( DEQ_SIZE ( addr -> subscriptions ) > 1 ) { DEQ_REMOVE_HEAD ( addr -> subscriptions ) ; DEQ_INSERT_TAIL ( addr -> subscriptions , sub ) ; } addr -> deliveries_to_container ++ ; return 1 ; } } qdr_link_ref_t * link_ref = DEQ_HEAD ( addr -> rlinks ) ; if ( link_ref ) { out_link = link_ref -> link ; out_delivery = qdr_forward_new_delivery_CT ( core , in_delivery , out_link , msg ) ; qdr_forward_deliver_CT ( core , out_link , out_delivery ) ; if ( DEQ_SIZE ( addr -> rlinks ) > 1 ) { DEQ_REMOVE_HEAD ( addr -> rlinks ) ; DEQ_INSERT_TAIL ( addr -> rlinks , link_ref ) ; } addr -> deliveries_egress ++ ; core -> deliveries_egress ++ ; if ( qdr_connection_route_container ( out_link -> conn ) ) { core -> deliveries_egress_route_container ++ ; addr -> deliveries_egress_route_container ++ ; } return 1 ; } if ( addr -> cost_epoch != core -> cost_epoch ) qdr_forward_find_closest_remotes_CT ( core , addr ) ; qdr_node_t * next_node ; if ( addr -> next_remote >= 0 ) { qdr_node_t * rnode = core -> routers_by_mask_bit [ addr -> next_remote ] ; if ( rnode ) { _qdbm_next ( addr -> closest_remotes , & addr -> next_remote ) ; if ( addr -> next_remote == - 1 ) qd_bitmask_first_set ( addr -> closest_remotes , & addr -> next_remote ) ; if ( rnode -> next_hop ) next_node = rnode -> next_hop ; else next_node = rnode ; out_link = control ? PEER_CONTROL_LINK ( core , next_node ) : PEER_DATA_LINK ( core , next_node ) ; if ( out_link ) { out_delivery = qdr_forward_new_delivery_CT ( core , in_delivery , out_link , msg ) ; qdr_forward_deliver_CT ( core , out_link , out_delivery ) ; addr -> deliveries_transit ++ ; core -> deliveries_transit ++ ; return 1 ; } } } return 0 ; } | <S2SV_ModStart> ) ; else { <S2SV_ModStart> sub ) ; qd_message_Q2_holdoff_disable ( msg ) ; } |
2,792 | CWE-000 static int sbs_probe ( struct i2c_client * client , const struct i2c_device_id * id ) { struct sbs_info * chip ; struct power_supply_desc * sbs_desc ; struct sbs_platform_data * pdata = client -> dev . platform_data ; struct power_supply_config psy_cfg = { } ; int rc ; int irq ; sbs_desc = devm_kmemdup ( & client -> dev , & sbs_default_desc , sizeof ( * sbs_desc ) , GFP_KERNEL ) ; if ( ! sbs_desc ) return - ENOMEM ; sbs_desc -> name = devm_kasprintf ( & client -> dev , GFP_KERNEL , "sbs-%s" , dev_name ( & client -> dev ) ) ; if ( ! sbs_desc -> name ) return - ENOMEM ; chip = devm_kzalloc ( & client -> dev , sizeof ( struct sbs_info ) , GFP_KERNEL ) ; if ( ! chip ) return - ENOMEM ; chip -> client = client ; chip -> enable_detection = false ; psy_cfg . of_node = client -> dev . of_node ; psy_cfg . drv_data = chip ; chip -> ignore_changes = 1 ; chip -> last_state = POWER_SUPPLY_STATUS_UNKNOWN ; rc = of_property_read_u32 ( client -> dev . of_node , "sbs,i2c-retry-count" , & chip -> i2c_retry_count ) ; if ( rc ) chip -> i2c_retry_count = 0 ; rc = of_property_read_u32 ( client -> dev . of_node , "sbs,poll-retry-count" , & chip -> poll_retry_count ) ; if ( rc ) chip -> poll_retry_count = 0 ; if ( pdata ) { chip -> poll_retry_count = pdata -> poll_retry_count ; chip -> i2c_retry_count = pdata -> i2c_retry_count ; } chip -> i2c_retry_count = chip -> i2c_retry_count + 1 ; chip -> gpio_detect = devm_gpiod_get_optional ( & client -> dev , "sbs,battery-detect" , GPIOD_IN ) ; if ( IS_ERR ( chip -> gpio_detect ) ) { dev_err ( & client -> dev , "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>gpio:<S2SV_blank>%ld\\n" , PTR_ERR ( chip -> gpio_detect ) ) ; return PTR_ERR ( chip -> gpio_detect ) ; } i2c_set_clientdata ( client , chip ) ; if ( ! chip -> gpio_detect ) goto skip_gpio ; irq = gpiod_to_irq ( chip -> gpio_detect ) ; if ( irq <= 0 ) { dev_warn ( & client -> dev , "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>gpio<S2SV_blank>as<S2SV_blank>irq:<S2SV_blank>%d\\n" , irq ) ; goto skip_gpio ; } rc = devm_request_threaded_irq ( & client -> dev , irq , NULL , sbs_irq , <S2SV_StartBug> IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING , <S2SV_EndBug> dev_name ( & client -> dev ) , chip ) ; if ( rc ) { dev_warn ( & client -> dev , "Failed<S2SV_blank>to<S2SV_blank>request<S2SV_blank>irq:<S2SV_blank>%d\\n" , rc ) ; goto skip_gpio ; } skip_gpio : if ( ! ( force_load || chip -> gpio_detect ) ) { rc = sbs_read_word_data ( client , sbs_data [ REG_STATUS ] . addr ) ; if ( rc < 0 ) { dev_err ( & client -> dev , "%s:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>device<S2SV_blank>status\\n" , __func__ ) ; goto exit_psupply ; } } chip -> power_supply = devm_power_supply_register ( & client -> dev , sbs_desc , & psy_cfg ) ; if ( IS_ERR ( chip -> power_supply ) ) { dev_err ( & client -> dev , "%s:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>register<S2SV_blank>power<S2SV_blank>supply\\n" , __func__ ) ; rc = PTR_ERR ( chip -> power_supply ) ; goto exit_psupply ; } dev_info ( & client -> dev , "%s:<S2SV_blank>battery<S2SV_blank>gas<S2SV_blank>gauge<S2SV_blank>device<S2SV_blank>registered\\n" , client -> name ) ; INIT_DELAYED_WORK ( & chip -> work , sbs_delayed_work ) ; chip -> enable_detection = true ; return 0 ; exit_psupply : return rc ; } | <S2SV_ModStart> IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT |
2,793 | CWE-000 int __attribute__ ( ( __section__ ( ".libc" ) ) ) write ( int handle , void * _buffer , unsigned int count ) { int i ; for ( i = 0 ; i < count ; i ++ ) { <S2SV_StartBug> write_char ( * ( ( UCHAR * ) _buffer + i ) , 1 ) ; <S2SV_EndBug> } return i ; } | <S2SV_ModStart> + i ) <S2SV_ModEnd> ) ; } |
2,794 | CWE-000 void default_idle ( void ) { void ( * powersave ) ( void ) ; int cpu = smp_processor_id ( ) ; powersave = ppc_md . power_save ; if ( ! need_resched ( ) ) { if ( powersave != NULL ) powersave ( ) ; # ifdef CONFIG_SMP else { set_thread_flag ( TIF_POLLING_NRFLAG ) ; while ( ! need_resched ( ) && ! cpu_is_offline ( cpu ) ) barrier ( ) ; clear_thread_flag ( TIF_POLLING_NRFLAG ) ; } # endif } <S2SV_StartBug> if ( need_resched ( ) ) <S2SV_EndBug> schedule ( ) ; if ( cpu_is_offline ( cpu ) && system_state == SYSTEM_RUNNING ) cpu_die ( ) ; } | <S2SV_ModStart> # endif } <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
2,795 | CWE-000 ADIOS_VARINFO * adios_read_flexpath_inq_var ( const ADIOS_FILE * adiosfile , const char * varname ) { flexpath_reader_file * fp = ( flexpath_reader_file * ) adiosfile -> fh ; <S2SV_StartBug> ADIOS_VARINFO * v = NULL ; <S2SV_EndBug> fp_verbose ( fp , "entering<S2SV_blank>flexpath_inq_var,<S2SV_blank>varname:<S2SV_blank>%s\\n" , varname ) ; timestep_separated_lists * ts_var_list = flexpath_get_curr_timestep_list ( fp ) ; flexpath_var * fpvar = find_fp_var ( ts_var_list -> var_list , varname ) ; if ( fpvar ) { v = calloc ( 1 , sizeof ( ADIOS_VARINFO ) ) ; if ( ! v ) { adios_error ( err_no_memory , "Cannot<S2SV_blank>allocate<S2SV_blank>buffer<S2SV_blank>in<S2SV_blank>adios_read_flexpath_inq_var()" ) ; return NULL ; } v = convert_var_info ( fpvar , v , varname , adiosfile ) ; <S2SV_StartBug> fp_verbose ( fp , "leaving<S2SV_blank>flexpath_inq_var\\n" ) ; <S2SV_EndBug> } else { adios_error ( err_invalid_varname , "Cannot<S2SV_blank>find<S2SV_blank>var<S2SV_blank>%s\\n" , varname ) ; } return v ; } | <S2SV_ModStart> v = NULL <S2SV_ModEnd> ; timestep_separated_lists * <S2SV_ModStart> adiosfile ) ; <S2SV_ModEnd> } else { |
2,796 | CWE-000 int lwm2m_write_handler ( struct lwm2m_engine_obj_inst * obj_inst , struct lwm2m_engine_res_inst * res , struct lwm2m_engine_obj_field * obj_field , struct lwm2m_engine_context * context ) { struct lwm2m_input_context * in ; struct lwm2m_obj_path * path ; s64_t temp64 = 0 ; s32_t temp32 = 0 ; void * data_ptr = NULL ; size_t data_len = 0 ; size_t len = 0 ; size_t total_size = 0 ; int ret = 0 ; u8_t tkl = 0 ; u8_t token [ 8 ] ; bool last_block = true ; struct block_context * block_ctx = NULL ; if ( ! obj_inst || ! res || ! obj_field || ! context ) { return - EINVAL ; } in = context -> in ; path = context -> path ; data_ptr = res -> data_ptr ; data_len = res -> data_len ; if ( res -> pre_write_cb ) { data_ptr = res -> pre_write_cb ( obj_inst -> obj_inst_id , & data_len ) ; } if ( res -> post_write_cb ) { ret = get_option_int ( in -> in_cpkt , COAP_OPTION_BLOCK1 ) ; if ( ret >= 0 ) { last_block = ! GET_MORE ( ret ) ; tkl = coap_header_get_token ( in -> in_cpkt , token ) ; if ( tkl && ! get_block_ctx ( token , tkl , & block_ctx ) ) { total_size = block_ctx -> ctx . total_size ; SYS_LOG_DBG ( "BLOCK1:<S2SV_blank>total:%zu<S2SV_blank>current:%zu" "<S2SV_blank>last:%u" , block_ctx -> ctx . total_size , block_ctx -> ctx . current , last_block ) ; } } } if ( data_ptr && data_len > 0 ) { switch ( obj_field -> data_type ) { case LWM2M_RES_TYPE_OPAQUE : ret = lwm2m_write_handler_opaque ( obj_inst , res , in , data_ptr , data_len , last_block , total_size ) ; if ( ret < 0 ) { return ret ; } break ; case LWM2M_RES_TYPE_STRING : engine_get_string ( in , ( u8_t * ) data_ptr , data_len ) ; len = strlen ( ( char * ) data_ptr ) ; break ; case LWM2M_RES_TYPE_U64 : engine_get_s64 ( in , & temp64 ) ; * ( u64_t * ) data_ptr = temp64 ; len = 8 ; break ; case LWM2M_RES_TYPE_U32 : case LWM2M_RES_TYPE_TIME : engine_get_s32 ( in , & temp32 ) ; * ( u32_t * ) data_ptr = temp32 ; len = 4 ; break ; case LWM2M_RES_TYPE_U16 : engine_get_s32 ( in , & temp32 ) ; * ( u16_t * ) data_ptr = temp32 ; len = 2 ; break ; case LWM2M_RES_TYPE_U8 : engine_get_s32 ( in , & temp32 ) ; * ( u8_t * ) data_ptr = temp32 ; len = 1 ; break ; case LWM2M_RES_TYPE_S64 : engine_get_s64 ( in , ( s64_t * ) data_ptr ) ; len = 8 ; break ; case LWM2M_RES_TYPE_S32 : engine_get_s32 ( in , ( s32_t * ) data_ptr ) ; len = 4 ; break ; case LWM2M_RES_TYPE_S16 : engine_get_s32 ( in , & temp32 ) ; * ( s16_t * ) data_ptr = temp32 ; len = 2 ; break ; case LWM2M_RES_TYPE_S8 : engine_get_s32 ( in , & temp32 ) ; * ( s8_t * ) data_ptr = temp32 ; len = 1 ; break ; case LWM2M_RES_TYPE_BOOL : engine_get_bool ( in , ( bool * ) data_ptr ) ; len = 1 ; break ; case LWM2M_RES_TYPE_FLOAT32 : engine_get_float32fix ( in , ( float32_value_t * ) data_ptr ) ; len = 4 ; break ; case LWM2M_RES_TYPE_FLOAT64 : engine_get_float64fix ( in , ( float64_value_t * ) data_ptr ) ; len = 8 ; break ; default : SYS_LOG_ERR ( "unknown<S2SV_blank>obj<S2SV_blank>data_type<S2SV_blank>%d" , obj_field -> data_type ) ; return - EINVAL ; } <S2SV_StartBug> } <S2SV_EndBug> if ( res -> post_write_cb && obj_field -> data_type != LWM2M_RES_TYPE_OPAQUE ) { ret = res -> post_write_cb ( obj_inst -> obj_inst_id , data_ptr , len , last_block , total_size ) ; } NOTIFY_OBSERVER_PATH ( path ) ; return ret ; } | <S2SV_ModStart> ; } } else { return - ENOENT ; } |
2,797 | CWE-000 bool compare_ppm ( const char * img1_filename , const char * img2_filename , const char * diff_filename ) { unsigned char img1 [ MED_INPUT_IMG_SZ ] , img2 [ MED_INPUT_IMG_SZ ] , diff [ MED_INPUT_IMG_SZ ] ; char temp [ 512 ] ; int tempInt ; unsigned tempUnsigned ; bool rv = true ; <S2SV_StartBug> if ( readppm ( img1 , & tempInt , temp , & tempInt , & tempUnsigned , & tempUnsigned , & tempUnsigned , <S2SV_EndBug> ( char * ) img1_filename ) != true ) { # ifdef DEBUG printf ( "error<S2SV_blank>reading<S2SV_blank>ppm<S2SV_blank>1<S2SV_blank>for<S2SV_blank>comparison\\n" ) ; # endif return false ; } if ( readppm ( img2 , & tempInt , temp , & tempInt , & tempUnsigned , & tempUnsigned , & tempUnsigned , ( char * ) img2_filename ) != true ) { # ifdef DEBUG printf ( "error<S2SV_blank>reading<S2SV_blank>ppm<S2SV_blank>2<S2SV_blank>for<S2SV_blank>comparison\\n" ) ; # endif return false ; } for ( int i = 0 ; i < MED_INPUT_IMG_SZ ; i ++ ) { if ( img1 [ i ] != img2 [ i ] ) { diff [ i ] = 255 ; rv = false ; } else diff [ i ] = 0 ; } if ( diff_filename != NULL ) dump_ppm_data ( diff_filename , MED_INPUT_IMG_WT , MED_INPUT_IMG_HT , 1 , diff ) ; return rv ; } | <S2SV_ModStart> = true ; return true <S2SV_ModEnd> ; } <S2SV_null> |
2,798 | CWE-000 void common_rtc_set_interrupt ( uint32_t us_timestamp , uint32_t cc_channel , uint32_t int_mask ) { uint64_t current_time64 = common_rtc_64bit_us_get ( ) ; uint64_t timestamp64 = us_timestamp + ( current_time64 & ~ ( uint64_t ) 0xFFFFFFFF ) ; if ( us_timestamp < ( uint32_t ) ( current_time64 & 0xFFFFFFFF ) ) { timestamp64 += ( ( uint64_t ) 1 << 32 ) ; } uint32_t compare_value = ( uint32_t ) CEIL_DIV ( ( timestamp64 ) * RTC_INPUT_FREQ , 1000000 ) ; <S2SV_StartBug> uint32_t closest_safe_compare = common_rtc_32bit_ticks_get ( ) + 2 ; <S2SV_EndBug> if ( ( int ) ( compare_value - closest_safe_compare ) <= 0 ) { compare_value = closest_safe_compare ; } nrf_rtc_cc_set ( COMMON_RTC_INSTANCE , cc_channel , RTC_WRAP ( compare_value ) ) ; nrf_rtc_event_enable ( COMMON_RTC_INSTANCE , int_mask ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> 1000000 ) ; core_util_critical_section_enter ( ) ; <S2SV_ModStart> int_mask ) ; core_util_critical_section_exit ( ) ; |
2,799 | CWE-000 static void emit_shift_u8_off_pr64 ( struct dynarec_compiler * compiler , uint8_t op , uint8_t shift , uint32_t off , enum X86_REG base ) { assert ( shift < 32 ) ; emit_rex_prefix ( compiler , base , 0 , 0 ) ; * ( compiler -> map ++ ) = 0xc1 ; if ( is_imms8 ( off ) ) { * ( compiler -> map ++ ) = 0x60 | op | ( base & 7 ) ; emit_imms8 ( compiler , off ) ; } else { * ( compiler -> map ++ ) = 0xa0 | op | ( base & 7 ) ; emit_imm32 ( compiler , off ) ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ) ; } emit_imm8 ( compiler , shift ) ; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.