Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
1,200 | CWE-000 static int ext2_read ( struct direntry_struct * entry , char * buf , size_t len ) { struct inode_block_table * current_ibt ; size_t bytes_read = 0 ; size_t bytes_to_copy = 0 ; size_t start_block = 0 ; size_t start_block_offset = 0 ; if ( entry == NULL ) return - EIO ; if ( entry -> fd == NULL ) return - EIO ; if ( entry -> blocks == NULL ) return - EIO ; size_t read_seek_offset = entry -> fd -> seek_offset ; char * disk_read_buffer = kmalloc ( 0x400 , 1 , "ext2_read<S2SV_blank>disk_read_buffer" ) ; <S2SV_StartBug> if ( read_seek_offset > len ) <S2SV_EndBug> bytes_to_copy = 0 ; else bytes_to_copy = len - read_seek_offset ; start_block = read_seek_offset / 0x400 ; start_block_offset = read_seek_offset % 0x400 ; klog ( KLOG_INFO , "ext2_read():<S2SV_blank>inode=%d,<S2SV_blank>mode=%x,<S2SV_blank>size=%d,<S2SV_blank>size_blocks=%d,<S2SV_blank>read_seek=%x,<S2SV_blank>btc=%d,<S2SV_blank>stb=%d" , entry -> inode_no , entry -> mode , entry -> size , entry -> size_blocks , read_seek_offset , bytes_to_copy , start_block ) ; for ( current_ibt = entry -> blocks ; bytes_to_copy > 0 ; current_ibt = current_ibt -> next ) { if ( current_ibt == NULL ) return - EIO ; for ( int i = 0 ; i < VFS_INODE_BLOCK_TABLE_LEN ; i ++ ) { if ( current_ibt -> blocks [ i ] == 0 ) break ; klog ( KLOG_INFO , "ext2_read():<S2SV_blank>inode=%d,<S2SV_blank>tc=%d,<S2SV_blank>stb=%d<S2SV_blank>blk=%d<S2SV_blank>:<S2SV_blank>%x<S2SV_blank>%x" , entry -> inode_no , bytes_to_copy , start_block , current_ibt -> blocks [ i ] , ( current_ibt -> blocks [ i ] * EXT2_BLOCK_SIZE / 512 ) , ( current_ibt -> blocks [ i ] * EXT2_BLOCK_SIZE / 512 ) * 0x200 ) ; if ( ! start_block ) { entry -> parent -> bd -> fops . seek ( entry -> parent -> bd -> drv_struct , entry -> parent -> partition -> sector_offset + ( current_ibt -> blocks [ i ] * EXT2_BLOCK_SIZE / 512 ) , SEEK_SET ) ; entry -> parent -> bd -> fops . read ( entry -> parent -> bd -> drv_struct , disk_read_buffer , 0x400 / 0x200 ) ; if ( bytes_to_copy < 0x400 ) { memcpy ( buf + bytes_read , disk_read_buffer + start_block_offset , bytes_to_copy ) ; bytes_to_copy -= bytes_to_copy ; break ; } else { memcpy ( buf + bytes_read , disk_read_buffer + start_block_offset , 0x400 ) ; bytes_to_copy -= 0x400 ; } bytes_read += 0x400 - start_block_offset ; start_block_offset = 0 ; } klog ( KLOG_INFO , "ext2_read():<S2SV_blank>inode=%d,<S2SV_blank>btr=%d" , entry -> inode_no , bytes_read ) ; if ( start_block == 0 ) start_block = 0 ; else start_block -- ; } } kfree ( disk_read_buffer ) ; return 0 ; } | <S2SV_ModStart> ; if ( len > ( entry -> size - read_seek_offset ) ) bytes_to_copy = 0 ; else bytes_to_copy = len <S2SV_ModEnd> ; start_block = |
1,201 | CWE-000 static int pty_open_ptmx_index ( struct file_desc * d , struct tty_info * info , int flags ) <S2SV_StartBug> { <S2SV_EndBug> return __pty_open_ptmx_index ( info -> tie -> pty -> index , flags , open_tty_reg , d , path_from_reg ( d ) ) ; } | <S2SV_ModStart> flags ) { if ( info -> fdstore_id >= 0 ) return fdstore_get ( info -> fdstore_id ) ; |
1,202 | CWE-000 u32 rtl92ce_get_desc ( u8 * p_desc , bool istx , u8 desc_name ) { u32 ret = 0 ; if ( istx ) { switch ( desc_name ) { case HW_DESC_OWN : ret = GET_TX_DESC_OWN ( p_desc ) ; break ; case HW_DESC_TXBUFF_ADDR : ret = GET_TX_DESC_TX_BUFFER_ADDRESS ( p_desc ) ; break ; default : RT_ASSERT ( false , "ERR<S2SV_blank>txdesc<S2SV_blank>:%d<S2SV_blank>not<S2SV_blank>process\\n" , desc_name ) ; break ; } } else { <S2SV_StartBug> struct rx_desc_92c * pdesc = ( struct rx_desc_92c * ) p_desc ; <S2SV_EndBug> switch ( desc_name ) { case HW_DESC_OWN : <S2SV_StartBug> ret = GET_RX_DESC_OWN ( pdesc ) ; <S2SV_EndBug> break ; case HW_DESC_RXPKT_LEN : <S2SV_StartBug> ret = GET_RX_DESC_PKT_LEN ( pdesc ) ; <S2SV_EndBug> break ; case HW_DESC_RXBUFF_ADDR : <S2SV_StartBug> ret = GET_RX_STATUS_DESC_BUFF_ADDR ( pdesc ) ; <S2SV_EndBug> break ; default : RT_ASSERT ( false , "ERR<S2SV_blank>rxdesc<S2SV_blank>:%d<S2SV_blank>not<S2SV_blank>process\\n" , desc_name ) ; break ; } } return ret ; } | <S2SV_ModStart> } else { <S2SV_ModEnd> switch ( desc_name <S2SV_ModStart> = GET_RX_DESC_OWN ( p_desc <S2SV_ModEnd> ) ; break <S2SV_ModStart> = GET_RX_DESC_PKT_LEN ( p_desc <S2SV_ModEnd> ) ; break <S2SV_ModStart> : ret = GET_RX_DESC_BUFF_ADDR ( p_desc <S2SV_ModEnd> ) ; break |
1,203 | CWE-000 int main ( int argc , char * * argv ) { char * run_test_name = NULL ; printf ( "**<S2SV_blank>test_01:<S2SV_blank>Valvula:<S2SV_blank>a<S2SV_blank>high<S2SV_blank>performance<S2SV_blank>policy<S2SV_blank>daemon\\n" ) ; printf ( "**<S2SV_blank>Copyright<S2SV_blank>(C)<S2SV_blank>2016<S2SV_blank>Advanced<S2SV_blank>Software<S2SV_blank>Production<S2SV_blank>Line,<S2SV_blank>S.L.\\n**\\n" ) ; printf ( "**<S2SV_blank>Regression<S2SV_blank>tests:<S2SV_blank>valvula:<S2SV_blank>%s<S2SV_blank>\\n" , VERSION ) ; printf ( "**<S2SV_blank>To<S2SV_blank>gather<S2SV_blank>information<S2SV_blank>about<S2SV_blank>time<S2SV_blank>performance<S2SV_blank>you<S2SV_blank>can<S2SV_blank>use:\\n**\\n" ) ; printf ( "**<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>time<S2SV_blank>./test_01<S2SV_blank>[--help]<S2SV_blank>[--debug]<S2SV_blank>[--no-unmap]<S2SV_blank>[--run-test=NAME]\\n**\\n" ) ; printf ( "**<S2SV_blank>To<S2SV_blank>gather<S2SV_blank>information<S2SV_blank>about<S2SV_blank>memory<S2SV_blank>consumed<S2SV_blank>(and<S2SV_blank>leaks)<S2SV_blank>use:\\n**\\n" ) ; printf ( "**<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>>><S2SV_blank>libtool<S2SV_blank>--mode=execute<S2SV_blank>valgrind<S2SV_blank>--leak-check=yes<S2SV_blank>--show-reachable=yes<S2SV_blank>--error-limit=no<S2SV_blank>./test_01<S2SV_blank>[--debug]\\n**\\n" ) ; printf ( "**<S2SV_blank>Providing<S2SV_blank>--run-test=NAME<S2SV_blank>will<S2SV_blank>run<S2SV_blank>only<S2SV_blank>the<S2SV_blank>provided<S2SV_blank>regression<S2SV_blank>test.\\n" ) ; printf ( "**<S2SV_blank>Available<S2SV_blank>tests:<S2SV_blank>test_00,<S2SV_blank>test_01,<S2SV_blank>test_02,<S2SV_blank>test_02a,<S2SV_blank>test_02b,<S2SV_blank>test_02c,<S2SV_blank>test_02d,<S2SV_blank>test_02e,\\n" ) ; printf ( "**<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>test_02f,<S2SV_blank>test_03,<S2SV_blank>test_03a,<S2SV_blank>test_04,<S2SV_blank>test_05,\\n" ) ; <S2SV_StartBug> printf ( "**<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>test_06,<S2SV_blank>test_07,<S2SV_blank>test_08\\n" ) ; <S2SV_EndBug> printf ( "**\\n" ) ; printf ( "**<S2SV_blank>Report<S2SV_blank>bugs<S2SV_blank>to:\\n**\\n" ) ; printf ( "**<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><valvula@lists.aspl.es><S2SV_blank>Valvula<S2SV_blank>Mailing<S2SV_blank>list\\n**\\n" ) ; while ( argc > 0 ) { if ( axl_cmp ( argv [ argc ] , "--help" ) ) exit ( 0 ) ; if ( axl_cmp ( argv [ argc ] , "--debug" ) ) test_common_enable_debug = axl_true ; if ( axl_cmp ( argv [ argc ] , "--no-unmap" ) ) valvulad_module_set_no_unmap_modules ( axl_true ) ; if ( argv [ argc ] && axl_memcmp ( argv [ argc ] , "--run-test" , 10 ) ) { run_test_name = argv [ argc ] + 11 ; printf ( "INFO:<S2SV_blank>running<S2SV_blank>test:<S2SV_blank>%s\\n" , run_test_name ) ; } argc -- ; } CHECK_TEST ( "test_00" ) run_test ( test_00 , "Test<S2SV_blank>00:<S2SV_blank>generic<S2SV_blank>API<S2SV_blank>function<S2SV_blank>checks" ) ; CHECK_TEST ( "test_01" ) run_test ( test_01 , "Test<S2SV_blank>01:<S2SV_blank>basic<S2SV_blank>server<S2SV_blank>startup<S2SV_blank>(using<S2SV_blank>default<S2SV_blank>configuration)" ) ; CHECK_TEST ( "test_01a" ) run_test ( test_01a , "Test<S2SV_blank>01-a:<S2SV_blank>basic<S2SV_blank>mail<S2SV_blank>policy<S2SV_blank>request" ) ; CHECK_TEST ( "test_02" ) run_test ( test_02 , "Test<S2SV_blank>02:<S2SV_blank>database<S2SV_blank>functions" ) ; CHECK_TEST ( "test_02a" ) run_test ( test_02a , "Test<S2SV_blank>02a:<S2SV_blank>API<S2SV_blank>functions<S2SV_blank>to<S2SV_blank>get<S2SV_blank>data<S2SV_blank>from<S2SV_blank>requests" ) ; CHECK_TEST ( "test_02b" ) run_test ( test_02b , "Test<S2SV_blank>02-b:<S2SV_blank>test<S2SV_blank>local<S2SV_blank>domains<S2SV_blank>detection<S2SV_blank>support" ) ; CHECK_TEST ( "test_02c" ) run_test ( test_02c , "Test<S2SV_blank>02-c:<S2SV_blank>test<S2SV_blank>local<S2SV_blank>accounts<S2SV_blank>detection<S2SV_blank>support" ) ; CHECK_TEST ( "test_02d" ) run_test ( test_02d , "Test<S2SV_blank>02-d:<S2SV_blank>more<S2SV_blank>test<S2SV_blank>local<S2SV_blank>accounts<S2SV_blank>detection<S2SV_blank>support" ) ; CHECK_TEST ( "test_02e" ) run_test ( test_02e , "Test<S2SV_blank>02-e:<S2SV_blank>detect<S2SV_blank>accounts<S2SV_blank>and<S2SV_blank>notifications<S2SV_blank>with<S2SV_blank>(=)<S2SV_blank>in<S2SV_blank>the<S2SV_blank>midle" ) ; CHECK_TEST ( "test_02f" ) run_test ( test_02f , "Test<S2SV_blank>02-f:<S2SV_blank>accounts<S2SV_blank>with<S2SV_blank>characters<S2SV_blank>that<S2SV_blank>can<S2SV_blank>be<S2SV_blank>used<S2SV_blank>for<S2SV_blank>SQL<S2SV_blank>injection" ) ; CHECK_TEST ( "test_03" ) run_test ( test_03 , "Test<S2SV_blank>03:<S2SV_blank>checking<S2SV_blank>mod-ticket" ) ; CHECK_TEST ( "test_03a" ) run_test ( test_03a , "Test<S2SV_blank>03a:<S2SV_blank>checking<S2SV_blank>mod-ticket<S2SV_blank>transport<S2SV_blank>change<S2SV_blank>support" ) ; CHECK_TEST ( "test_04" ) run_test ( test_04 , "Test<S2SV_blank>04:<S2SV_blank>test<S2SV_blank>valvulad-mgr.py" ) ; CHECK_TEST ( "test_05" ) run_test ( test_05 , "Test<S2SV_blank>05:<S2SV_blank>test<S2SV_blank>mod-bwl" ) ; CHECK_TEST ( "test_06" ) run_test ( test_06 , "Test<S2SV_blank>06:<S2SV_blank>test<S2SV_blank>mod-slm" ) ; CHECK_TEST ( "test_07" ) run_test ( test_07 , "Test<S2SV_blank>07:<S2SV_blank>test<S2SV_blank>mod-mquota" ) ; <S2SV_StartBug> CHECK_TEST ( "test_08" ) <S2SV_EndBug> run_test ( test_08 , "Test<S2SV_blank>08:<S2SV_blank>test<S2SV_blank>mod-mquota" ) ; printf ( "All<S2SV_blank>tests<S2SV_blank>passed<S2SV_blank>OK!\\n" ) ; return 0 ; } | <S2SV_ModStart> ; printf ( "**<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>test_06,<S2SV_blank>test_07,<S2SV_blank>test_07a,<S2SV_blank>test_08\\n" <S2SV_ModEnd> ) ; printf <S2SV_ModStart> ; CHECK_TEST ( "test_07a" ) run_test ( test_07a , "Test<S2SV_blank>07a:<S2SV_blank>test<S2SV_blank>mod-mquota<S2SV_blank>(more<S2SV_blank>tests)" ) ; CHECK_TEST ( |
1,204 | CWE-000 <S2SV_StartBug> DECL_EXTERN_API ( DWORD , StringSizeW , IN LPCWSTR szcString ) <S2SV_EndBug> { <S2SV_StartBug> LPWSTR p = ( LPWSTR ) szcString ; <S2SV_EndBug> while ( * p ) { <S2SV_StartBug> p ++ ; <S2SV_EndBug> } <S2SV_StartBug> return ( DWORD ) ( p - szcString ) * sizeof ( WCHAR ) ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> DECL_EXTERN_API ( BOOLEAN , StringToLowerW , IN OUT LPWSTR lpStr <S2SV_ModEnd> ) { LPWSTR <S2SV_ModStart> LPWSTR p = lpStr ; for ( ; * p ; ++ <S2SV_ModEnd> p ) { <S2SV_ModStart> p ) { * p = __tolower ( * p ) <S2SV_ModEnd> ; } return <S2SV_ModStart> ; } return TRUE <S2SV_ModEnd> ; } <S2SV_null> |
1,205 | CWE-000 BREthereumHandshakeStatus ethereumHandshakeTransition ( BREthereumHandshake handshake ) { BREthereumNode node = handshake -> node ; BREthereumBoolean originated = ethereumNodeDidOriginate ( handshake -> node ) ; if ( handshake -> nextState == BRE_HANDSHAKE_NEW ) { handshake -> nextState = BRE_HANDSHAKE_ACKAUTH ; if ( ETHEREUM_BOOLEAN_IS_TRUE ( originated ) ) { _sendAuthInitiator ( handshake ) ; ethereumNodeWriteToPeer ( node , handshake -> authBufCipher , authCipherBufLen , "auth<S2SV_blank>initiator" ) ; } else { int ec = ethereumNodeReadFromPeer ( node , handshake -> authBufCipher , authCipherBufLen , "auth<S2SV_blank>from<S2SV_blank>receiver" ) ; if ( ec ) { return BRE_HANDSHAKE_ERROR ; } _readAuthFromInitiator ( handshake ) ; } } else if ( handshake -> nextState == BRE_HANDSHAKE_ACKAUTH ) { <S2SV_StartBug> handshake -> nextState = BRE_HANDSHAKE_WRITEHELLO ; <S2SV_EndBug> if ( ETHEREUM_BOOLEAN_IS_TRUE ( originated ) ) { int ec = ethereumNodeReadFromPeer ( node , handshake -> ackBufCipher , ackCipherBufLen , "auth<S2SV_blank>ack<S2SV_blank>from<S2SV_blank>receivier" ) ; if ( ec ) { return BRE_HANDSHAKE_ERROR ; } _readAuthAckFromRecipient ( handshake ) ; } else { _sendAuthAckToInitiator ( handshake ) ; ethereumNodeWriteToPeer ( node , handshake -> ackBufCipher , ackCipherBufLen , "auth<S2SV_blank>ack<S2SV_blank>to<S2SV_blank>initiator" ) ; } _initFrameCoder ( handshake ) ; } else if ( handshake -> nextState == BRE_HANDSHAKE_WRITEHELLO ) { handshake -> nextState = BRE_HANDSHAKE_READHELLO ; uint8_t * encryptedHello = NULL ; size_t encryptedHelloSize = 0 ; _sendHelloMessage ( handshake , & encryptedHello , & encryptedHelloSize ) ; int ec = ethereumNodeWriteToPeer ( node , encryptedHello , encryptedHelloSize , "hello<S2SV_blank>message<S2SV_blank>to<S2SV_blank>remote<S2SV_blank>peer" ) ; if ( ec ) { if ( encryptedHello != NULL ) { free ( encryptedHello ) ; } return BRE_HANDSHAKE_ERROR ; } <S2SV_StartBug> free ( encryptedHello ) ; <S2SV_EndBug> } else if ( handshake -> nextState == BRE_HANDSHAKE_READHELLO ) { uint8_t header [ 32 ] ; int ec = ethereumNodeReadFromPeer ( node , header , 32 , "hello<S2SV_blank>message<S2SV_blank>header<S2SV_blank>from<S2SV_blank>remote<S2SV_blank>peer<S2SV_blank>" ) ; if ( ec ) { eth_log ( HANDSHAKE_LOG_TOPIC , "%s" , "Error:<S2SV_blank>reading<S2SV_blank>in<S2SV_blank>hello<S2SV_blank>message<S2SV_blank>from<S2SV_blank>remote<S2SV_blank>peer" ) ; return BRE_HANDSHAKE_ERROR ; } size_t payloadSize = 0 ; ec = _decryptMessageHelloHeader ( handshake , header , 32 , & payloadSize ) ; if ( ec ) { return BRE_HANDSHAKE_ERROR ; } size_t frameSize = payloadSize + ( ( 16 - ( payloadSize % 16 ) ) % 16 ) + 16 ; uint8_t * frame ; array_new ( frame , frameSize ) ; ec = ethereumNodeReadFromPeer ( node , frame , frameSize , "reading<S2SV_blank>hello<S2SV_blank>message<S2SV_blank>body<S2SV_blank>from<S2SV_blank>remote<S2SV_blank>peer<S2SV_blank>" ) ; if ( ec ) { eth_log ( HANDSHAKE_LOG_TOPIC , "%s" , "Error:<S2SV_blank>reading<S2SV_blank>in<S2SV_blank>hello<S2SV_blank>message<S2SV_blank>from<S2SV_blank>remote<S2SV_blank>peer" ) ; array_free ( frame ) ; return BRE_HANDSHAKE_ERROR ; } BREthereumP2PHello remoteHello ; ec = _decryptMessageHelloFrame ( handshake , frame , frameSize , payloadSize , & remoteHello ) ; if ( ec ) { return BRE_HANDSHAKE_ERROR ; } <S2SV_StartBug> handshake -> nextState = BRE_HANDSHAKE_FINISHED ; <S2SV_EndBug> } return handshake -> nextState ; } | <S2SV_ModStart> -> nextState = BRE_HANDSHAKE_READHELLO <S2SV_ModEnd> ; if ( <S2SV_ModStart> ( encryptedHello ) ; handshake -> nextState = BRE_HANDSHAKE_FINISHED <S2SV_ModStart> BRE_HANDSHAKE_ERROR ; } <S2SV_ModEnd> } return handshake |
1,206 | CWE-000 static int fetch_md_cb ( tse_task_t * task , void * data ) { daos_array_open_t * args = * ( ( daos_array_open_t * * ) data ) ; daos_obj_fetch_t * fetch_args ; struct io_params * params ; int rc = task -> dt_result ; if ( rc != 0 ) return rc ; D__ALLOC_PTR ( params ) ; if ( params == NULL ) { D__ERROR ( "Failed<S2SV_blank>memory<S2SV_blank>allocation\\n" ) ; return - DER_NOMEM ; } params -> next = NULL ; params -> user_sgl_used = false ; daos_iov_set ( & params -> dkey , ARRAY_MD_KEY , strlen ( ARRAY_MD_KEY ) ) ; params -> sgl . sg_iovs = malloc ( sizeof ( daos_iov_t ) * 2 ) ; daos_iov_set ( & params -> sgl . sg_iovs [ 0 ] , args -> cell_size , sizeof ( daos_size_t ) ) ; daos_iov_set ( & params -> sgl . sg_iovs [ 1 ] , args -> block_size , sizeof ( daos_size_t ) ) ; params -> sgl . sg_nr . num = 2 ; params -> sgl . sg_nr . num_out = 0 ; daos_iov_set ( & params -> iod . iod_name , ARRAY_MD_KEY , strlen ( ARRAY_MD_KEY ) ) ; daos_csum_set ( & params -> iod . iod_kcsum , NULL , 0 ) ; params -> iod . iod_recxs = malloc ( sizeof ( daos_recx_t ) ) ; params -> iod . iod_nr = 1 ; params -> iod . iod_recxs [ 0 ] . rx_idx = 0 ; params -> iod . iod_recxs [ 0 ] . rx_nr = 2 ; params -> iod . iod_eprs = NULL ; params -> iod . iod_csums = NULL ; params -> iod . iod_size = sizeof ( daos_size_t ) ; params -> iod . iod_type = DAOS_IOD_ARRAY ; <S2SV_StartBug> fetch_args = daos_task_get_args ( DAOS_OPC_OBJ_FETCH , task ) ; <S2SV_EndBug> fetch_args -> oh = * args -> oh ; fetch_args -> epoch = args -> epoch ; fetch_args -> dkey = & params -> dkey ; fetch_args -> nr = 1 ; fetch_args -> iods = & params -> iod ; fetch_args -> sgls = & params -> sgl ; rc = tse_task_register_comp_cb ( task , free_io_params_cb , & params , sizeof ( params ) ) ; if ( rc != 0 ) return rc ; return 0 ; } | <S2SV_ModStart> = daos_task_get_args ( <S2SV_ModEnd> task ) ; |
1,207 | CWE-000 static PyObject * cmatrices_calculate_glrlm ( PyObject * self , PyObject * args ) { int Ng , Nr , force2D , force2Ddimension ; PyObject * image_obj , * mask_obj ; PyArrayObject * image_arr , * mask_arr ; int n_a ; int size [ 3 ] ; int strides [ 3 ] ; npy_intp dims [ 3 ] ; PyArrayObject * glrlm_arr , * angles_arr ; int * image ; char * mask ; int distances [ 1 ] = { 1 } ; int * angles ; double * glrlm ; int k ; if ( ! PyArg_ParseTuple ( args , "OOiiii" , & image_obj , & mask_obj , & Ng , & Nr , & force2D , & force2Ddimension ) ) return NULL ; image_arr = ( PyArrayObject * ) PyArray_FROM_OTF ( image_obj , NPY_INT , NPY_ARRAY_FORCECAST | NPY_ARRAY_UPDATEIFCOPY | NPY_ARRAY_IN_ARRAY ) ; mask_arr = ( PyArrayObject * ) PyArray_FROM_OTF ( mask_obj , NPY_BOOL , NPY_ARRAY_FORCECAST | NPY_ARRAY_UPDATEIFCOPY | NPY_ARRAY_IN_ARRAY ) ; if ( check_arrays ( image_arr , mask_arr , size , strides ) > 0 ) return NULL ; if ( ! force2D ) force2Ddimension = - 1 ; if ( generate_angles ( size , distances , 3 , 1 , 0 , force2Ddimension , & angles , & n_a ) > 0 ) { Py_XDECREF ( image_arr ) ; Py_XDECREF ( mask_arr ) ; <S2SV_StartBug> PyErr_SetString ( PyExc_RuntimeError , "Expecting<S2SV_blank>calculating<S2SV_blank>angles." ) ; <S2SV_EndBug> return NULL ; } dims [ 0 ] = Ng ; dims [ 1 ] = Nr ; dims [ 2 ] = n_a ; <S2SV_StartBug> glrlm_arr = ( PyArrayObject * ) PyArray_SimpleNew ( 3 , dims , NPY_DOUBLE ) ; <S2SV_EndBug> image = ( int * ) PyArray_DATA ( image_arr ) ; mask = ( char * ) PyArray_DATA ( mask_arr ) ; glrlm = ( double * ) PyArray_DATA ( glrlm_arr ) ; for ( k = Ng * Nr * n_a - 1 ; k >= 0 ; k -- ) glrlm [ k ] = 0 ; if ( ! calculate_glrlm ( image , mask , size , strides , angles , n_a , glrlm , Ng , Nr ) ) { Py_XDECREF ( image_arr ) ; Py_XDECREF ( mask_arr ) ; Py_XDECREF ( glrlm_arr ) ; free ( angles ) ; PyErr_SetString ( PyExc_RuntimeError , "Calculation<S2SV_blank>of<S2SV_blank>GLRLM<S2SV_blank>Failed." ) ; return NULL ; } Py_XDECREF ( image_arr ) ; Py_XDECREF ( mask_arr ) ; dims [ 0 ] = n_a ; dims [ 1 ] = 3 ; angles_arr = ( PyArrayObject * ) PyArray_SimpleNewFromData ( 2 , dims , NPY_INT , angles ) ; PyArray_ENABLEFLAGS ( angles_arr , NPY_ARRAY_OWNDATA ) ; return Py_BuildValue ( "OO" , PyArray_Return ( glrlm_arr ) , PyArray_Return ( angles_arr ) ) ; } | <S2SV_ModStart> ( PyExc_RuntimeError , "Error<S2SV_blank>calculating<S2SV_blank>angles." <S2SV_ModEnd> ) ; return <S2SV_ModStart> = n_a ; if ( dims [ 0 ] * dims [ 1 ] * dims [ 2 ] > 2147483648 ) { free ( angles ) ; Py_XDECREF ( image_arr ) ; Py_XDECREF ( mask_arr ) ; PyErr_SetString ( PyExc_RuntimeError , "Number<S2SV_blank>of<S2SV_blank>elements<S2SV_blank>in<S2SV_blank>GLRLM<S2SV_blank>would<S2SV_blank>overflow<S2SV_blank>index<S2SV_blank>variable!<S2SV_blank>Increase<S2SV_blank>bin<S2SV_blank>width<S2SV_blank>or<S2SV_blank>decrease<S2SV_blank>number<S2SV_blank>of<S2SV_blank>angles<S2SV_blank>to<S2SV_blank>prevent<S2SV_blank>this<S2SV_blank>error." ) ; return NULL ; } |
1,208 | CWE-000 static bool skip_sys_exit ( struct opts * opts , struct ftrace_task_handle * task ) { <S2SV_StartBug> unsigned long ip = task -> func_stack [ 0 ] . addr ; <S2SV_EndBug> if ( ! opts -> kernel || task -> user_stack_count != 0 ) <S2SV_StartBug> return false ; <S2SV_EndBug> if ( is_kernel_address ( ip ) ) { struct sym * sym = find_symtabs ( NULL , ip ) ; if ( ! strncmp ( sym -> name , "sys_exit" , 8 ) ) return true ; } return false ; } | <S2SV_ModStart> unsigned long ip ; if ( <S2SV_ModEnd> task -> func_stack <S2SV_ModStart> task -> func_stack == NULL ) return true <S2SV_ModEnd> ; if ( <S2SV_ModStart> ) return false ; ip = task -> func_stack [ 0 ] . addr |
1,209 | CWE-000 int llmeta_set_tablename_alias ( void * ptran , const char * tablename_alias , const char * url , char * * errstr ) { struct llmeta_tablename_alias_key key = { 0 } ; <S2SV_StartBug> struct llmeta_tablename_alias_data data = { 0 } ; <S2SV_EndBug> char key_buf [ LLMETA_IXLEN ] = { 0 } ; char data_buf [ LLMETA_TABLENAME_ALIAS_DATA_LEN ] = { 0 } ; int retries = 0 ; int bdberr = 0 ; int rc = 0 ; tran_type * trans = NULL ; if ( __llmeta_preop_alias ( & key , tablename_alias , key_buf , sizeof ( key_buf ) , errstr ) ) return - 1 ; if ( ! url ) { logmsg ( LOGMSG_ERROR , "%s:<S2SV_blank>NULL<S2SV_blank>argument\\n" , __func__ ) ; if ( errstr ) * errstr = strdup ( ( ! tablename_alias ) ? "tablename_alias<S2SV_blank>null" : "url<S2SV_blank>null" ) ; return - 1 ; } if ( strlen ( url ) + 1 > sizeof ( data . url ) ) { logmsg ( LOGMSG_ERROR , "%s:<S2SV_blank>tablename<S2SV_blank>url<S2SV_blank>too<S2SV_blank>long,<S2SV_blank>limit<S2SV_blank>is<S2SV_blank>%zu\\n" , __func__ , sizeof ( data . url ) ) ; if ( errstr ) * errstr = strdup ( "tablename<S2SV_blank>url<S2SV_blank>too<S2SV_blank>long" ) ; return - 1 ; } strncpy ( data . url , url , sizeof ( data . url ) ) ; if ( llmeta_tablename_alias_data_put ( & data , ( uint8_t * ) data_buf , ( uint8_t * ) ( data_buf + sizeof ( data_buf ) ) ) == NULL ) { logmsg ( LOGMSG_ERROR , "%s:<S2SV_blank>tablename<S2SV_blank>url<S2SV_blank>serializing<S2SV_blank>error\\n" , __func__ ) ; if ( errstr ) * errstr = strdup ( "tablename<S2SV_blank>url<S2SV_blank>serializing<S2SV_blank>error" ) ; return - 1 ; } retries = 0 ; retry : if ( ++ retries >= 500 ) { logmsg ( LOGMSG_ERROR , "%s:<S2SV_blank>giving<S2SV_blank>up<S2SV_blank>after<S2SV_blank>%d<S2SV_blank>retries\\n" , __func__ , retries ) ; if ( errstr ) * errstr = strdup ( "failed<S2SV_blank>to<S2SV_blank>commit<S2SV_blank>transaction,<S2SV_blank>tried<S2SV_blank>500<S2SV_blank>times" ) ; return - 1 ; } trans = bdb_tran_begin ( llmeta_bdb_state , ptran , & bdberr ) ; if ( ! trans ) { if ( bdberr == BDBERR_DEADLOCK ) goto retry ; logmsg ( LOGMSG_ERROR , "%s:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>transaction<S2SV_blank>bdberr=%d\\n" , __func__ , bdberr ) ; if ( errstr ) * errstr = strdup ( "failed<S2SV_blank>to<S2SV_blank>start<S2SV_blank>transaction" ) ; return - 1 ; } rc = bdb_lite_add ( llmeta_bdb_state , trans , & data_buf , sizeof ( data_buf ) , & key_buf , & bdberr ) ; if ( rc || bdberr != BDBERR_NOERROR ) { if ( bdberr == BDBERR_DEADLOCK ) goto retry ; if ( bdberr == BDBERR_ADD_DUPE ) { logmsg ( LOGMSG_ERROR , "%s:<S2SV_blank>tablename<S2SV_blank>alias<S2SV_blank>already<S2SV_blank>exists!\\n" , __func__ ) ; if ( errstr ) * errstr = strdup ( "tablename<S2SV_blank>alias<S2SV_blank>already<S2SV_blank>exists" ) ; rc = - 1 ; } else { logmsg ( LOGMSG_ERROR , "%s:<S2SV_blank>unrecognized<S2SV_blank>error<S2SV_blank>adding<S2SV_blank>row<S2SV_blank>rc=%d<S2SV_blank>bdberr=%d!\\n" , __func__ , rc , bdberr ) ; if ( errstr ) * errstr = strdup ( "unhandled<S2SV_blank>error" ) ; rc = - 1 ; } } if ( ! rc ) { rc = bdb_tran_commit ( llmeta_bdb_state , trans , & bdberr ) ; if ( rc || bdberr != BDBERR_NOERROR ) { if ( bdberr == BDBERR_DEADLOCK ) goto retry ; logmsg ( LOGMSG_ERROR , "%s:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>commit<S2SV_blank>transaction<S2SV_blank>bdberr=%d\\n" , __func__ , bdberr ) ; if ( errstr ) * errstr = strdup ( "failed<S2SV_blank>to<S2SV_blank>commit<S2SV_blank>transaction" ) ; return - 1 ; } } else { rc = bdb_tran_abort ( llmeta_bdb_state , trans , & bdberr ) ; if ( rc || bdberr != BDBERR_NOERROR ) { logmsg ( LOGMSG_ERROR , "%s:<S2SV_blank>trans<S2SV_blank>abort<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>bdberr<S2SV_blank>" "%d\\n" , __func__ , bdberr ) ; } return - 1 ; } return 0 ; } | <S2SV_ModStart> data = { { 0 } <S2SV_ModEnd> } ; char |
1,210 | CWE-000 void Update_SMPU_data ( void ) { event_record_t count_record ; long_t S_Time , E_Time , Event_count , P_Time , SMCPU_CRC ; Read_Event_from_Serial_EEProm ( Events_Ring_Buffer . Head , ( event_record_t * ) & count_record ) ; if ( count_record . Field . Token == LATEST_EVENT_TOKEN ) { E_Time . LWord = count_record . Field . Date_Time ; } else { E_Time . LWord = 0x0000 ; } Read_Event_from_Serial_EEProm ( Events_Ring_Buffer . Head + 1 , ( event_record_t * ) & count_record ) ; if ( count_record . Field . Token != LATEST_EVENT_TOKEN || count_record . Field . Token != OLD_EVENT_TOKEN ) { Read_Event_from_Serial_EEProm ( 0 , ( event_record_t * ) & count_record ) ; S_Time . LWord = count_record . Field . Date_Time ; Event_count . LWord = Events_Ring_Buffer . Tail ; } else if ( count_record . Field . Token == OLD_EVENT_TOKEN ) { S_Time . LWord = count_record . Field . Date_Time ; Event_count . LWord = MAXIMUM_EVENTS ; } else { S_Time . LWord = 0x0000 ; Event_count . LWord = 0 ; } GLCD_Info . Message_Buffer [ OFFSET_EVENT_COUNT ] = Event_count . Byte . Byte1 ; GLCD_Info . Message_Buffer [ OFFSET_EVENT_COUNT + 1 ] = Event_count . Byte . Byte2 ; GLCD_Info . Message_Buffer [ OFFSET_EVENT_COUNT + 2 ] = Event_count . Byte . Byte3 ; GLCD_Info . Message_Buffer [ OFFSET_EVENT_COUNT + 3 ] = Event_count . Byte . Byte4 ; GLCD_Info . Message_Buffer [ OFFSET_START_TIME ] = S_Time . Byte . Byte1 ; GLCD_Info . Message_Buffer [ OFFSET_START_TIME + 1 ] = S_Time . Byte . Byte2 ; GLCD_Info . Message_Buffer [ OFFSET_START_TIME + 2 ] = S_Time . Byte . Byte3 ; GLCD_Info . Message_Buffer [ OFFSET_START_TIME + 3 ] = S_Time . Byte . Byte4 ; GLCD_Info . Message_Buffer [ OFFSET_END_TIME ] = E_Time . Byte . Byte1 ; GLCD_Info . Message_Buffer [ OFFSET_END_TIME + 1 ] = E_Time . Byte . Byte2 ; GLCD_Info . Message_Buffer [ OFFSET_END_TIME + 2 ] = E_Time . Byte . Byte3 ; GLCD_Info . Message_Buffer [ OFFSET_END_TIME + 3 ] = E_Time . Byte . Byte4 ; P_Time . LWord = SystemClock ; GLCD_Info . Message_Buffer [ OFFSET_PRESENT_TIME ] = P_Time . Byte . Byte1 ; GLCD_Info . Message_Buffer [ OFFSET_PRESENT_TIME + 1 ] = P_Time . Byte . Byte2 ; GLCD_Info . Message_Buffer [ OFFSET_PRESENT_TIME + 2 ] = P_Time . Byte . Byte3 ; GLCD_Info . Message_Buffer [ OFFSET_PRESENT_TIME + 3 ] = P_Time . Byte . Byte4 ; SMCPU_CRC . LWord = 0x87654321 ; GLCD_Info . Message_Buffer [ OFFSET_SMCPU_CRC ] = SMCPU_CRC . Byte . Byte1 ; GLCD_Info . Message_Buffer [ OFFSET_SMCPU_CRC + 1 ] = SMCPU_CRC . Byte . Byte2 ; GLCD_Info . Message_Buffer [ OFFSET_SMCPU_CRC + 2 ] = SMCPU_CRC . Byte . Byte3 ; GLCD_Info . Message_Buffer [ OFFSET_SMCPU_CRC + 3 ] = SMCPU_CRC . Byte . Byte4 ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> . Byte4 ; GLCD_Info . Message_Buffer [ OFFSET_SMCPU_CRC + 4 ] = Network_config ; |
1,211 | CWE-000 int gctl_error ( struct gctl_req * req , const char * fmt , ... ) { va_list ap ; if ( req == NULL ) return ( EINVAL ) ; if ( sbuf_done ( req -> serror ) ) { if ( ! req -> nerror ) req -> nerror = EEXIST ; <S2SV_StartBug> } <S2SV_EndBug> if ( req -> nerror ) <S2SV_StartBug> return ( req -> nerror ) ; <S2SV_EndBug> va_start ( ap , fmt ) ; sbuf_vprintf ( req -> serror , fmt , ap ) ; va_end ( ap ) ; sbuf_finish ( req -> serror ) ; if ( g_debugflags & G_F_CTLDUMP ) printf ( "gctl<S2SV_blank>%p<S2SV_blank>error<S2SV_blank>\\"%s\\"\\n" , req , sbuf_data ( req -> serror ) ) ; <S2SV_StartBug> return ( 0 ) ; <S2SV_EndBug> } | <S2SV_ModStart> = EEXIST ; <S2SV_ModEnd> return ( req <S2SV_ModStart> -> nerror ) ; } if ( ! req -> nerror ) req -> nerror = EINVAL <S2SV_ModStart> ; return ( req -> nerror <S2SV_ModEnd> ) ; } |
1,212 | CWE-000 void test_get ( const char * key ) { status_t s ; uint64_t value = 0 ; sskiplist_t * ssl = NULL ; <S2SV_StartBug> s = ssl_open ( opt . prefix , opt . p , & ssl ) ; <S2SV_EndBug> if ( ! s . ok ) { log_fatal ( "%s" , s . errmsg ) ; } ssl_get ( ssl , key , strlen ( key ) , & value ) ; log_info ( "sskiplist.ssl_get(%s):<S2SV_blank>%ld\\n" , key , value ) ; ssl_close ( ssl ) ; } | <S2SV_ModStart> ( opt . name <S2SV_ModEnd> , opt . |
1,213 | CWE-000 static void ipr_mask_and_clear_interrupts ( struct ipr_ioa_cfg * ioa_cfg , u32 clr_ints ) { volatile u32 int_reg ; int i ; for ( i = 0 ; i < ioa_cfg -> hrrq_num ; i ++ ) { spin_lock ( & ioa_cfg -> hrrq [ i ] . _lock ) ; ioa_cfg -> hrrq [ i ] . allow_interrupts = 0 ; spin_unlock ( & ioa_cfg -> hrrq [ i ] . _lock ) ; } <S2SV_StartBug> wmb ( ) ; <S2SV_EndBug> if ( ioa_cfg -> sis64 ) writeq ( ~ 0 , ioa_cfg -> regs . set_interrupt_mask_reg ) ; else writel ( ~ 0 , ioa_cfg -> regs . set_interrupt_mask_reg ) ; if ( ioa_cfg -> sis64 ) writel ( ~ 0 , ioa_cfg -> regs . clr_interrupt_reg ) ; writel ( clr_ints , ioa_cfg -> regs . clr_interrupt_reg32 ) ; int_reg = readl ( ioa_cfg -> regs . sense_interrupt_reg ) ; } | <S2SV_ModStart> ) ; } <S2SV_ModEnd> if ( ioa_cfg |
1,214 | CWE-000 static void progress_current_animation ( struct sprite * sprite ) { struct animation * animation = sprite -> active_animation ; switch ( sprite -> active_animation -> mode ) { case LOOP_FRAMES : sprite -> current_frame = sprite -> current_frame == animation -> loop_to ? animation -> loop_from : sprite -> current_frame + 1 ; break ; case FREEZE_LAST_FRAME : sprite -> current_frame = <S2SV_StartBug> sprite -> current_frame + 1 == animation -> n_frames <S2SV_EndBug> ? sprite -> current_frame : sprite -> current_frame + 1 ; <S2SV_StartBug> case PINGPONG_FRAMES : <S2SV_EndBug> default : sprite -> current_frame = sprite -> current_frame ; } } | <S2SV_ModStart> -> current_frame = ( <S2SV_ModStart> animation -> n_frames ) <S2SV_ModStart> + 1 ; break ; <S2SV_ModStart> case PINGPONG_FRAMES : break ; |
1,215 | CWE-000 void enter_failsafe_mode ( struct intel_vgpu * vgpu , int reason ) { switch ( reason ) { case GVT_FAILSAFE_UNSUPPORTED_GUEST : pr_err ( "Detected<S2SV_blank>your<S2SV_blank>guest<S2SV_blank>driver<S2SV_blank>doesn\'t<S2SV_blank>support<S2SV_blank>GVT-g.\\n" ) ; break ; case GVT_FAILSAFE_INSUFFICIENT_RESOURCE : pr_err ( "Graphics<S2SV_blank>resource<S2SV_blank>is<S2SV_blank>not<S2SV_blank>enough<S2SV_blank>for<S2SV_blank>the<S2SV_blank>guest\\n" ) ; <S2SV_StartBug> case GVT_FAILSAFE_GUEST_ERR : <S2SV_EndBug> <S2SV_StartBug> pr_err ( "GVT<S2SV_blank>Internal<S2SV_blank>error<S2SV_blank><S2SV_blank>for<S2SV_blank>the<S2SV_blank>guest\\n" ) ; <S2SV_EndBug> default : break ; } pr_err ( "Now<S2SV_blank>vgpu<S2SV_blank>%d<S2SV_blank>will<S2SV_blank>enter<S2SV_blank>failsafe<S2SV_blank>mode.\\n" , vgpu -> id ) ; vgpu -> failsafe = true ; } | <S2SV_ModStart> "Graphics<S2SV_blank>resource<S2SV_blank>is<S2SV_blank>not<S2SV_blank>enough<S2SV_blank>for<S2SV_blank>the<S2SV_blank>guest\\n" ) ; break ; <S2SV_ModStart> ( "GVT<S2SV_blank>Internal<S2SV_blank>error<S2SV_blank><S2SV_blank>for<S2SV_blank>the<S2SV_blank>guest\\n" ) ; break |
1,216 | CWE-000 static void ion_handle_kmap_put ( struct ion_handle * handle ) { struct ion_buffer * buffer = handle -> buffer ; <S2SV_StartBug> if ( ! handle -> kmap_cnt ) { <S2SV_EndBug> WARN ( 1 , "%s:<S2SV_blank>Double<S2SV_blank>unmap<S2SV_blank>detected!<S2SV_blank>bailing...\\n" , __func__ ) ; return ; } handle -> kmap_cnt -- ; if ( ! handle -> kmap_cnt ) ion_buffer_kmap_put ( buffer ) ; } | <S2SV_ModStart> -> buffer ; <S2SV_ModEnd> handle -> kmap_cnt |
1,217 | CWE-000 static struct sk_buff * ipv6_gso_segment ( struct sk_buff * skb , netdev_features_t features ) { struct sk_buff * segs = ERR_PTR ( - EINVAL ) ; struct ipv6hdr * ipv6h ; const struct net_offload * ops ; int proto ; struct frag_hdr * fptr ; unsigned int unfrag_ip6hlen ; u8 * prevhdr ; int offset = 0 ; bool encap , udpfrag ; int nhoff ; if ( unlikely ( skb_shinfo ( skb ) -> gso_type & ~ ( SKB_GSO_TCPV4 | SKB_GSO_UDP | SKB_GSO_DODGY | SKB_GSO_TCP_ECN | SKB_GSO_GRE | SKB_GSO_GRE_CSUM | SKB_GSO_IPIP | SKB_GSO_SIT | SKB_GSO_UDP_TUNNEL | SKB_GSO_UDP_TUNNEL_CSUM | SKB_GSO_MPLS | SKB_GSO_TCPV6 | 0 ) ) ) goto out ; skb_reset_network_header ( skb ) ; nhoff = skb_network_header ( skb ) - skb_mac_header ( skb ) ; if ( unlikely ( ! pskb_may_pull ( skb , sizeof ( * ipv6h ) ) ) ) goto out ; encap = SKB_GSO_CB ( skb ) -> encap_level > 0 ; if ( encap ) features &= skb -> dev -> hw_enc_features ; SKB_GSO_CB ( skb ) -> encap_level += sizeof ( * ipv6h ) ; ipv6h = ipv6_hdr ( skb ) ; __skb_pull ( skb , sizeof ( * ipv6h ) ) ; segs = ERR_PTR ( - EPROTONOSUPPORT ) ; proto = ipv6_gso_pull_exthdrs ( skb , ipv6h -> nexthdr ) ; if ( skb -> encapsulation && skb_shinfo ( skb ) -> gso_type & ( SKB_GSO_SIT | SKB_GSO_IPIP ) ) udpfrag = proto == IPPROTO_UDP && encap ; else udpfrag = proto == IPPROTO_UDP && ! skb -> encapsulation ; ops = rcu_dereference ( inet6_offloads [ proto ] ) ; if ( likely ( ops && ops -> callbacks . gso_segment ) ) { skb_reset_transport_header ( skb ) ; segs = ops -> callbacks . gso_segment ( skb , features ) ; } if ( IS_ERR ( segs ) ) goto out ; for ( skb = segs ; skb ; skb = skb -> next ) { ipv6h = ( struct ipv6hdr * ) ( skb_mac_header ( skb ) + nhoff ) ; ipv6h -> payload_len = htons ( skb -> len - nhoff - sizeof ( * ipv6h ) ) ; skb -> network_header = ( u8 * ) ipv6h - skb -> head ; if ( udpfrag ) { unfrag_ip6hlen = ip6_find_1stfragopt ( skb , & prevhdr ) ; <S2SV_StartBug> fptr = ( struct frag_hdr * ) ( ( u8 * ) ipv6h + unfrag_ip6hlen ) ; <S2SV_EndBug> fptr -> frag_off = htons ( offset ) ; if ( skb -> next != NULL ) fptr -> frag_off |= htons ( IP6_MF ) ; offset += ( ntohs ( ipv6h -> payload_len ) - sizeof ( struct frag_hdr ) ) ; } if ( encap ) skb_reset_inner_headers ( skb ) ; } out : return segs ; } | <S2SV_ModStart> prevhdr ) ; if ( unfrag_ip6hlen < 0 ) return ERR_PTR ( unfrag_ip6hlen ) ; |
1,218 | CWE-000 <S2SV_StartBug> static unsigned long alloc_handle ( struct zs_pool * pool ) <S2SV_EndBug> { return ( unsigned long ) kmem_cache_alloc ( pool -> handle_cachep , <S2SV_StartBug> pool -> flags & ~ __GFP_HIGHMEM ) ; <S2SV_EndBug> } | <S2SV_ModStart> zs_pool * pool , gfp_t gfp <S2SV_ModStart> -> handle_cachep , gfp <S2SV_ModEnd> & ~ __GFP_HIGHMEM |
1,219 | CWE-000 int64_t SAM_SeekFunc ( void * ptr , int64_t pos , int whence ) { CustomIOCtx_t * io = ( CustomIOCtx_t * ) ptr ; int64_t ret = - 1 ; if ( ! io -> pMoovFile ) { if ( AVSEEK_SIZE != whence ) { ret = ( int64_t ) fseeko ( io -> pFile , ( off_t ) pos , whence ) ; if ( 0 == ret ) { ret = ( int64_t ) ftello ( io -> pFile ) ; } } } else { switch ( whence ) { case SEEK_SET : ret = pos ; break ; case SEEK_CUR : ret += pos ; break ; case SEEK_END : ret = io -> iFileSize + pos ; break ; case AVSEEK_SIZE : return io -> iFileSize ; default : return - 1 ; } <S2SV_StartBug> if ( ret >= 0 && ret <= io -> iFileSize ) <S2SV_EndBug> { <S2SV_StartBug> if ( ret < io -> iMoovAtomOffset ) <S2SV_EndBug> { if ( ! fseeko ( io -> pFile , ( off_t ) ret , SEEK_SET ) ) <S2SV_StartBug> io -> iOffset = ret ; <S2SV_EndBug> else ret = - 1 ; } else { if ( ! fseeko ( io -> pMoovFile , ( off_t ) ( ret - io -> iMoovAtomOffset ) , SEEK_SET ) ) io -> iOffset = ret ; else ret = - 1 ; } } else { ret = - 1 ; } } return ret ; } | <S2SV_ModStart> >= 0 && ( uint64_t ) <S2SV_ModStart> { if ( ( uint64_t ) <S2SV_ModStart> -> iOffset = ( uint64_t ) |
1,220 | CWE-000 <S2SV_StartBug> DEFUNSH ( VTYSH_RIPD , vtysh_exit_ripd , vtysh_exit_ripd_cmd , "exit" , <S2SV_EndBug> "Exit<S2SV_blank>current<S2SV_blank>mode<S2SV_blank>and<S2SV_blank>down<S2SV_blank>to<S2SV_blank>previous<S2SV_blank>mode\\n" ) { return vtysh_exit ( vty ) ; } | <S2SV_ModStart> <S2SV_null> DEFUNSH ( VTYSH_BGPD , exit_vrf_policy , exit_vrf_policy_cmd , "exit-vrf-policy" , "Exit<S2SV_blank>from<S2SV_blank>VRF<S2SV_blank>policy<S2SV_blank>configuration<S2SV_blank>mode\\n" ) { if ( vty -> node == BGP_VRF_POLICY_NODE ) vty -> node = BGP_NODE ; return CMD_SUCCESS <S2SV_ModEnd> ; } <S2SV_null> |
1,221 | CWE-000 char * hash_table_get ( const hash_table_t * ht , const char * key ) { hash_node_t * find_node ; if ( key == NULL || ht == NULL ) <S2SV_StartBug> return ( 0 ) ; <S2SV_EndBug> find_node = ht -> array [ key_index ( ( const unsigned char * ) key , ht -> size ) ] ; if ( find_node == NULL ) return ( NULL ) ; while ( find_node != NULL ) { if ( strcmp ( find_node -> key , key ) == 0 ) return ( find_node -> value ) ; find_node = find_node -> next ; printf ( "hit<S2SV_blank>the<S2SV_blank>while<S2SV_blank>loop\\n" ) ; } return ( NULL ) ; } | <S2SV_ModStart> ) return ( NULL <S2SV_ModEnd> ) ; find_node |
1,222 | CWE-000 static void test_establish_intro_wrong_keytype2 ( void * arg ) { int retval ; char circ_nonce [ DIGEST_LEN ] = { 0 } ; uint8_t cell_body [ RELAY_PAYLOAD_SIZE ] ; ssize_t cell_len = 0 ; or_circuit_t * intro_circ = or_circuit_new ( 0 , NULL ) ; ; ( void ) arg ; crypto_rand ( circ_nonce , sizeof ( circ_nonce ) ) ; helper_prepare_circ_for_intro ( intro_circ , circ_nonce ) ; cell_len = new_establish_intro_encoded_cell ( circ_nonce , cell_body ) ; <S2SV_StartBug> tt_u64_op ( cell_len , OP_GT , 0 ) ; <S2SV_EndBug> cell_body [ 0 ] = 42 ; setup_full_capture_of_logs ( LOG_INFO ) ; retval = hs_intro_received_establish_intro ( intro_circ , cell_body , cell_len ) ; expect_log_msg_containing ( "Unrecognized<S2SV_blank>AUTH_KEY_TYPE<S2SV_blank>42." ) ; teardown_capture_of_logs ( ) ; tt_int_op ( retval , OP_EQ , - 1 ) ; done : circuit_free ( TO_CIRCUIT ( intro_circ ) ) ; } | <S2SV_ModStart> cell_body ) ; tt_i64_op <S2SV_ModEnd> ( cell_len , |
1,223 | CWE-000 uint16_t MEM_If_Erase_FS ( uint32_t Add ) { uint32_t NbOfPages = 0 ; uint32_t PageError = 0 ; HAL_StatusTypeDef status ; FLASH_EraseInitTypeDef eraseinitstruct ; if ( Add < ( uint32_t ) BOOTLOADER_APP_START_ADDRESS ) { return 3 ; } <S2SV_StartBug> NbOfPages = ( ( BOOTLOADER_APP_END_ADDRESS - BOOTLOADER_APP_START_ADDRESS ) / FLASH_PAGE_SIZE ) + 1 ; <S2SV_EndBug> eraseinitstruct . TypeErase = FLASH_TYPEERASE_PAGES ; eraseinitstruct . PageAddress = BOOTLOADER_APP_START_ADDRESS ; eraseinitstruct . NbPages = NbOfPages ; <S2SV_StartBug> status = HAL_FLASHEx_Erase ( & eraseinitstruct , & PageError ) ; <S2SV_EndBug> if ( status != HAL_OK ) { return ! USBD_OK ; } return ( USBD_OK ) ; } | <S2SV_ModStart> 3 ; } # if 0 <S2SV_ModStart> = NbOfPages ; # else NbOfPages = 1 ; eraseinitstruct . TypeErase = FLASH_TYPEERASE_PAGES ; eraseinitstruct . PageAddress = Add ; eraseinitstruct . NbPages = NbOfPages ; # endif HAL_GPIO_TogglePin ( GPIOC , GPIO_PIN_13 ) ; <S2SV_ModStart> , & PageError ) ; HAL_GPIO_TogglePin ( GPIOC , GPIO_PIN_13 |
1,224 | CWE-000 static int bnx2x_ptp_adjfreq ( struct ptp_clock_info * ptp , s32 ppb ) { struct bnx2x * bp = container_of ( ptp , struct bnx2x , ptp_clock_info ) ; int rc ; int drift_dir = 1 ; int val , period , period1 , period2 , dif , dif1 , dif2 ; int best_dif = BNX2X_MAX_PHC_DRIFT , best_period = 0 , best_val = 0 ; DP ( BNX2X_MSG_PTP , "PTP<S2SV_blank>adjfreq<S2SV_blank>called,<S2SV_blank>ppb<S2SV_blank>=<S2SV_blank>%d\\n" , ppb ) ; if ( ! netif_running ( bp -> dev ) ) { DP ( BNX2X_MSG_PTP , "PTP<S2SV_blank>adjfreq<S2SV_blank>called<S2SV_blank>while<S2SV_blank>the<S2SV_blank>interface<S2SV_blank>is<S2SV_blank>down\\n" ) ; <S2SV_StartBug> return - EFAULT ; <S2SV_EndBug> } if ( ppb < 0 ) { ppb = - ppb ; drift_dir = 0 ; } if ( ppb == 0 ) { best_val = 1 ; best_period = 0x1FFFFFF ; } else if ( ppb >= BNX2X_MAX_PHC_DRIFT ) { best_val = 31 ; best_period = 1 ; } else { for ( val = 0 ; val <= 31 ; val ++ ) { if ( ( val & 0x7 ) == 0 ) continue ; period1 = val * 1000000 / ppb ; period2 = period1 + 1 ; if ( period1 != 0 ) dif1 = ppb - ( val * 1000000 / period1 ) ; else dif1 = BNX2X_MAX_PHC_DRIFT ; if ( dif1 < 0 ) dif1 = - dif1 ; dif2 = ppb - ( val * 1000000 / period2 ) ; if ( dif2 < 0 ) dif2 = - dif2 ; dif = ( dif1 < dif2 ) ? dif1 : dif2 ; period = ( dif1 < dif2 ) ? period1 : period2 ; if ( dif < best_dif ) { best_dif = dif ; best_val = val ; best_period = period ; } } } rc = bnx2x_send_update_drift_ramrod ( bp , drift_dir , best_val , best_period ) ; if ( rc ) { BNX2X_ERR ( "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>drift\\n" ) ; return - EFAULT ; } DP ( BNX2X_MSG_PTP , "Configured<S2SV_blank>val<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>period<S2SV_blank>=<S2SV_blank>%d\\n" , best_val , best_period ) ; return 0 ; } | <S2SV_ModStart> ; return - ENETDOWN <S2SV_ModEnd> ; } if |
1,225 | CWE-000 static int start_ap ( uint8_t target_apic_id , int cpu_number ) { if ( cpu_number == MAX_CPUS ) { panic ( "smp:<S2SV_blank>CPU<S2SV_blank>limit<S2SV_blank>exceeded" , cpu_count ) ; } cpu_local_t * cpu_local = & cpu_locals [ cpu_number ] ; cpu_local -> cpu_number = cpu_number ; cpu_local -> kernel_stack = ( void * ) & cpu_stacks [ cpu_number ] ; <S2SV_StartBug> tss_t * tss = & cpu_tss [ cpu_number ] ; <S2SV_EndBug> tss -> rsp0 = ( uint64_t ) ( & cpu_stacks [ cpu_number ] ) ; tss -> ist1 = ( uint64_t ) ( & cpu_int_stacks [ cpu_number ] ) ; void * trampoline = prepare_smp_trampoline ( ( void * ) ap_kernel_entry , ( void * ) ( ( size_t ) kernel_pagemap - KERNEL_PHYS_OFFSET ) , & cpu_stacks [ cpu_number ] , cpu_local , tss ) ; lapic_write ( APICREG_ICR1 , ( ( uint32_t ) target_apic_id ) << 24 ) ; lapic_write ( APICREG_ICR0 , 0x4500 ) ; sleep ( 10 ) ; lapic_write ( APICREG_ICR1 , ( ( uint32_t ) target_apic_id ) << 24 ) ; lapic_write ( APICREG_ICR0 , 0x4600 | ( uint32_t ) ( size_t ) trampoline ) ; sleep ( 1 ) ; if ( check_ap_flag ( ) ) { goto success ; } else { lapic_write ( APICREG_ICR1 , ( ( uint32_t ) target_apic_id ) << 24 ) ; lapic_write ( APICREG_ICR0 , 0x4600 | ( uint32_t ) ( size_t ) trampoline ) ; sleep ( 1000 ) ; if ( check_ap_flag ( ) ) goto success ; else return - 1 ; } success : return 0 ; } | <S2SV_ModStart> cpu_number ] ; cpu_local -> lapic_id = target_apic_id ; |
1,226 | CWE-000 decnodes_allocator * create_allocator ( size_t num_node_slot ) { decnodes_allocator * result = malloc ( sizeof ( decnodes_allocator ) ) ; result -> nodes_count = INIT_NUM_NODES ; if ( num_node_slot < MIN_NUM_NODE_SLOT ) { result -> num_nodes_slot = MIN_NUM_NODE_SLOT ; result -> slots_size = MIN_NUM_NODE_SLOT * sizeof ( decnode ) ; <S2SV_StartBug> result -> cur_slots_off = 1 ; <S2SV_EndBug> result -> slots_count = 2 ; result -> slots = malloc ( MAX_SLOTS_COUNT * sizeof ( decnode * ) ) ; result -> slots [ 0 ] = malloc ( result -> slots_size ) ; result -> slots [ 1 ] = malloc ( result -> slots_size ) ; } else { result -> num_nodes_slot = num_node_slot ; result -> slots_size = num_node_slot * sizeof ( decnode ) ; <S2SV_StartBug> result -> cur_slots_off = 0 ; <S2SV_EndBug> result -> slots_count = 1 ; result -> slots = malloc ( MAX_SLOTS_COUNT * sizeof ( decnode * ) ) ; result -> slots [ 0 ] = malloc ( result -> slots_size ) ; } <S2SV_StartBug> result -> cur_slot = result -> slots [ result -> cur_slots_off ] ; <S2SV_EndBug> return result ; } | <S2SV_ModStart> ; result -> cur_slot_index <S2SV_ModEnd> = 1 ; <S2SV_ModStart> ; result -> cur_slot_index <S2SV_ModEnd> = 0 ; <S2SV_ModStart> [ result -> cur_slot_index <S2SV_ModEnd> ] ; return |
1,227 | CWE-000 void soft_reset_device ( struct device * dev ) { <S2SV_StartBug> reset_pif ( & dev -> pif , 1 ) ; <S2SV_EndBug> } | <S2SV_ModStart> dev ) { add_interrupt_event <S2SV_ModEnd> ( & dev <S2SV_ModStart> & dev -> r4300 . cp0 , HW2_INT , 0 ) ; add_interrupt_event ( & dev -> r4300 . cp0 , NMI_INT , 50000000 <S2SV_ModEnd> ) ; } |
1,228 | CWE-000 static void pic_8259A_init ( void ) { outb ( PIC_M_CTRL , 0x11 ) ; outb ( PIC_M_DATA , 0X20 ) ; outb ( PIC_M_DATA , 0x04 ) ; outb ( PIC_M_DATA , 0x01 ) ; outb ( PIC_S_CTRL , 0x11 ) ; outb ( PIC_S_DATA , 0x28 ) ; outb ( PIC_S_DATA , 0x02 ) ; outb ( PIC_S_DATA , 0x01 ) ; <S2SV_StartBug> outb ( PIC_M_DATA , 0xfd ) ; <S2SV_EndBug> outb ( PIC_S_DATA , 0xff ) ; put_str ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>PIC<S2SV_blank>initialization<S2SV_blank>completion\\n" ) ; } | <S2SV_ModStart> ( PIC_M_DATA , 0xfe <S2SV_ModEnd> ) ; outb |
1,229 | CWE-000 int tunnel_event ( tunnel_t * tun , HANDLE h ) { int ret , evt ; WSANETWORKEVENTS events ; assert ( valid_tunnel ( tun ) && h ) ; trace_tun ( "id=0x%02x<S2SV_blank>%s<S2SV_blank>h=%x" , tun -> id , tun -> proc ? "proc" : "tcp" , h ) ; if ( tun -> proc ) { if ( h == tun -> proc ) { info ( 0 , "tunnel<S2SV_blank>0x%02x<S2SV_blank>process<S2SV_blank>has<S2SV_blank>terminated" , tun -> id ) ; return tunnel_close_event ( tun ) ; } if ( h == tun -> rio . io . hEvent ) { ret = tunnel_fdread_event ( tun ) ; } else { assert ( h == tun -> wio . io . hEvent ) ; ret = tunnel_fdwrite_event ( tun ) ; } } else { ret = 0 ; events . lNetworkEvents = 0 ; if ( ! WSAEnumNetworkEvents ( tun -> sock . fd , tun -> sock . evt , & events ) ) { evt = ( int ) events . lNetworkEvents ; debug ( 1 , "close=%i,<S2SV_blank>conn=%i/%i,<S2SV_blank>read=%i,<S2SV_blank>write=%i,<S2SV_blank>accept=%i" , ! ! ( evt & FD_CLOSE ) , ! ! ( evt & FD_CONNECT ) , tun -> connected , ! ! ( evt & FD_READ ) , ! ! ( evt & FD_WRITE ) , ! ! ( evt & FD_ACCEPT ) ) ; if ( evt & FD_ACCEPT ) { debug ( 0 , "FD_ACCEPT" ) ; ret = tunnel_accept_event ( tun ) ; } else if ( evt & FD_CONNECT ) { debug ( 0 , "FD_CONNECT" ) ; ret = tunnel_connect_event ( tun , events . iErrorCode [ FD_CONNECT_BIT ] ) ; if ( ! ret ) { assert ( tun -> connected ) ; ret = tunnel_socksend_event ( tun ) ; if ( ret >= 0 ) ret = tunnel_sockrecv_event ( tun ) ; } } else if ( evt & FD_WRITE ) { debug ( 0 , "FD_WRITE" ) ; ret = tunnel_socksend_event ( tun ) ; } if ( ( ret >= 0 ) && ( evt & FD_READ ) ) { debug ( 0 , "FD_READ" ) ; <S2SV_StartBug> ret = tunnel_sockrecv_event ( tun ) ; <S2SV_EndBug> if ( evt & FD_CLOSE ) while ( ( ret = tunnel_sockrecv_event ( tun ) ) > 0 ) ; } if ( evt & FD_CLOSE ) { debug ( 0 , "FD_CLOSE" ) ; return tunnel_close_event ( tun ) ; } } else { if ( WSAGetLastError ( ) != ERROR_IO_PENDING ) return wsaerror ( "WSAEnumNetworkEvents" ) ; } } if ( ret < 0 ) tunnel_close ( tun ) ; return 0 ; } | <S2SV_ModStart> "FD_READ" ) ; if ( tun -> connected ) |
1,230 | CWE-000 <S2SV_StartBug> PetscErrorCode DMCreateSubDM_DA ( DM dm , PetscInt numFields , PetscInt fields [ ] , IS * is , DM * subdm ) <S2SV_EndBug> { DM_DA * da = ( DM_DA * ) dm -> data ; PetscSection section ; PetscErrorCode ierr ; PetscFunctionBegin ; if ( subdm ) { PetscSF sf ; Vec coords ; void * ctx ; ierr = DMCreate ( PetscObjectComm ( ( PetscObject ) dm ) , subdm ) ; CHKERRQ ( ierr ) ; ierr = DMGetPointSF ( dm , & sf ) ; CHKERRQ ( ierr ) ; ierr = DMSetPointSF ( * subdm , sf ) ; CHKERRQ ( ierr ) ; ierr = DMGetApplicationContext ( dm , & ctx ) ; CHKERRQ ( ierr ) ; ierr = DMSetApplicationContext ( * subdm , ctx ) ; CHKERRQ ( ierr ) ; ierr = DMGetCoordinatesLocal ( dm , & coords ) ; CHKERRQ ( ierr ) ; if ( coords ) { ierr = DMSetCoordinatesLocal ( * subdm , coords ) ; CHKERRQ ( ierr ) ; } else { ierr = DMGetCoordinates ( dm , & coords ) ; CHKERRQ ( ierr ) ; if ( coords ) { ierr = DMSetCoordinates ( * subdm , coords ) ; CHKERRQ ( ierr ) ; } } ierr = DMSetType ( * subdm , DMDA ) ; CHKERRQ ( ierr ) ; ierr = DMSetDimension ( * subdm , dm -> dim ) ; CHKERRQ ( ierr ) ; ierr = DMDASetSizes ( * subdm , da -> M , da -> N , da -> P ) ; CHKERRQ ( ierr ) ; ierr = DMDASetNumProcs ( * subdm , da -> m , da -> n , da -> p ) ; CHKERRQ ( ierr ) ; ierr = DMDASetBoundaryType ( * subdm , da -> bx , da -> by , da -> bz ) ; CHKERRQ ( ierr ) ; ierr = DMDASetDof ( * subdm , numFields ) ; CHKERRQ ( ierr ) ; ierr = DMDASetStencilType ( * subdm , da -> stencil_type ) ; CHKERRQ ( ierr ) ; ierr = DMDASetStencilWidth ( * subdm , da -> s ) ; CHKERRQ ( ierr ) ; ierr = DMDASetOwnershipRanges ( * subdm , da -> lx , da -> ly , da -> lz ) ; CHKERRQ ( ierr ) ; } ierr = DMGetDefaultSection ( dm , & section ) ; CHKERRQ ( ierr ) ; if ( section ) { ierr = DMCreateSubDM_Section_Private ( dm , numFields , fields , is , subdm ) ; CHKERRQ ( ierr ) ; } else { if ( is ) { PetscInt * indices , cnt = 0 , dof = da -> w , i , j ; ierr = PetscMalloc1 ( da -> Nlocal * numFields / dof , & indices ) ; CHKERRQ ( ierr ) ; for ( i = da -> base / dof ; i < ( da -> base + da -> Nlocal ) / dof ; ++ i ) { for ( j = 0 ; j < numFields ; ++ j ) { indices [ cnt ++ ] = dof * i + fields [ j ] ; } } if ( cnt != da -> Nlocal * numFields / dof ) SETERRQ2 ( PETSC_COMM_SELF , PETSC_ERR_PLIB , "Count<S2SV_blank>%d<S2SV_blank>does<S2SV_blank>not<S2SV_blank>equal<S2SV_blank>expected<S2SV_blank>value<S2SV_blank>%d" , cnt , da -> Nlocal * numFields / dof ) ; ierr = ISCreateGeneral ( PetscObjectComm ( ( PetscObject ) dm ) , cnt , indices , PETSC_OWN_POINTER , is ) ; CHKERRQ ( ierr ) ; } } PetscFunctionReturn ( 0 ) ; } | <S2SV_ModStart> PetscInt numFields , const |
1,231 | CWE-000 void cover_memcpy ( struct BUF * des , int a , struct BUF * src , int b , unsigned count ) { int i ; int samp ; <S2SV_StartBug> short * des_left = ( short * ) ( des -> addr + a ) ; <S2SV_EndBug> <S2SV_StartBug> short * des_right = des_left + 16 ; <S2SV_EndBug> <S2SV_StartBug> short * src_buf = ( short * ) ( src -> addr + b ) ; <S2SV_EndBug> # ifdef CONFIG_SND_AML_SPLIT_MODE <S2SV_StartBug> for ( i = 0 ; i < count ; i += 2 ) { <S2SV_EndBug> samp = ( ( * src_buf ++ ) * direct_left_gain ) >> 8 ; <S2SV_StartBug> * des_left ++ = ( short ) samp ; <S2SV_EndBug> samp = ( ( * src_buf ++ ) * direct_right_gain ) >> 8 ; <S2SV_StartBug> * des_right ++ = ( short ) samp ; <S2SV_EndBug> } # else int j ; for ( i = 0 ; i < count ; i += 64 ) { for ( j = 0 ; j < 16 ; j ++ ) { samp = ( ( * src_buf ++ ) * direct_left_gain ) >> 8 ; <S2SV_StartBug> * des_left ++ = ( short ) samp ; <S2SV_EndBug> samp = ( ( * src_buf ++ ) * direct_right_gain ) >> 8 ; <S2SV_StartBug> * des_right ++ = ( short ) samp ; <S2SV_EndBug> } des_left += 16 ; des_right += 16 ; } # endif } | <S2SV_ModStart> int samp ; int16_t * des_left = ( int16_t <S2SV_ModEnd> * ) ( <S2SV_ModStart> a ) ; int16_t <S2SV_ModEnd> * des_right = <S2SV_ModStart> + 16 ; int16_t * src_buf = ( int16_t <S2SV_ModEnd> * ) ( <S2SV_ModStart> ; i += 4 <S2SV_ModEnd> ) { samp <S2SV_ModStart> ++ = ( int16_t <S2SV_ModEnd> ) samp ; <S2SV_ModStart> ++ = ( int16_t <S2SV_ModEnd> ) samp ; <S2SV_ModStart> ++ = ( int16_t <S2SV_ModEnd> ) samp ; <S2SV_ModStart> ++ = ( int16_t <S2SV_ModEnd> ) samp ; |
1,232 | CWE-000 static void * worker_thread ( void * arg ) { NC_MSG_TYPE msgtype ; int rc , idx = * ( ( int * ) arg ) , monitored ; struct nc_session * ncs ; nc_libssh_thread_verbosity ( np2_verbose_level ) ; while ( ( control == LOOP_CONTINUE ) && np2srv . workers [ idx ] ) { pthread_rwlock_rdlock ( & np2srv . ly_ctx_lock ) ; if ( ! np2srv . ly_ctx ) { pthread_rwlock_unlock ( & np2srv . ly_ctx_lock ) ; control = LOOP_STOP ; break ; } if ( nc_server_endpt_count ( ) && ( ! np2srv . nc_max_sessions || ( nc_ps_session_count ( np2srv . nc_ps ) < np2srv . nc_max_sessions ) ) ) { msgtype = nc_accept ( 0 , & ncs ) ; if ( msgtype == NC_MSG_HELLO ) { np2srv_new_session_clb ( NULL , ncs ) ; } } rc = nc_ps_poll ( np2srv . nc_ps , 0 , & ncs ) ; <S2SV_StartBug> if ( rc & ( NC_PSPOLL_NOSESSIONS | NC_PSPOLL_TIMEOUT | NC_PSPOLL_ERROR ) ) { <S2SV_EndBug> pthread_rwlock_unlock ( & np2srv . ly_ctx_lock ) ; np_sleep ( 10 ) ; continue ; } switch ( nc_session_get_ti ( ncs ) ) { # ifdef NC_ENABLED_SSH case NC_TI_LIBSSH : # endif # ifdef NC_ENABLED_TLS case NC_TI_OPENSSL : # endif # if defined ( NC_ENABLED_SSH ) || defined ( NC_ENABLED_TLS ) monitored = 1 ; break ; # endif default : monitored = 0 ; break ; } if ( rc & NC_PSPOLL_BAD_RPC ) { if ( monitored ) { ncm_session_bad_rpc ( ncs ) ; } VRB ( "Session<S2SV_blank>%d:<S2SV_blank>thread<S2SV_blank>%d<S2SV_blank>event<S2SV_blank>bad<S2SV_blank>RPC." , nc_session_get_id ( ncs ) , idx ) ; } if ( rc & NC_PSPOLL_RPC ) { if ( monitored ) { ncm_session_rpc ( ncs ) ; } VRB ( "Session<S2SV_blank>%d:<S2SV_blank>thread<S2SV_blank>%d<S2SV_blank>event<S2SV_blank>new<S2SV_blank>RPC." , nc_session_get_id ( ncs ) , idx ) ; } if ( rc & NC_PSPOLL_REPLY_ERROR ) { if ( monitored ) { ncm_session_rpc_reply_error ( ncs ) ; } VRB ( "Session<S2SV_blank>%d:<S2SV_blank>thread<S2SV_blank>%d<S2SV_blank>event<S2SV_blank>reply<S2SV_blank>error." , nc_session_get_id ( ncs ) , idx ) ; } if ( rc & NC_PSPOLL_SESSION_TERM ) { VRB ( "Session<S2SV_blank>%d:<S2SV_blank>thread<S2SV_blank>%d<S2SV_blank>event<S2SV_blank>session<S2SV_blank>terminated." , nc_session_get_id ( ncs ) , idx ) ; np2srv_del_session_clb ( ncs ) ; } else if ( rc & NC_PSPOLL_SSH_CHANNEL ) { VRB ( "Session<S2SV_blank>%d:<S2SV_blank>thread<S2SV_blank>%d<S2SV_blank>event<S2SV_blank>new<S2SV_blank>SSH<S2SV_blank>channel." , nc_session_get_id ( ncs ) , idx ) ; msgtype = nc_session_accept_ssh_channel ( ncs , & ncs ) ; if ( msgtype == NC_MSG_HELLO ) { np2srv_new_session_clb ( NULL , ncs ) ; } else if ( msgtype == NC_MSG_BAD_HELLO ) { if ( monitored ) { ncm_bad_hello ( ) ; } } } pthread_rwlock_unlock ( & np2srv . ly_ctx_lock ) ; } nc_thread_destroy ( ) ; free ( arg ) ; np2srv . workers [ idx ] = 0 ; return NULL ; } | <S2SV_ModStart> ) ; if ( <S2SV_ModStart> NC_PSPOLL_ERROR ) ) && ! ( rc & NC_PSPOLL_SESSION_TERM ) ) |
1,233 | CWE-000 static const char * hfinfo_char_value_format ( const header_field_info * hfinfo , char buf [ 32 ] , guint32 value ) { <S2SV_StartBug> int display = hfinfo -> display & FIELD_DISPLAY_E_MASK ; <S2SV_EndBug> return hfinfo_char_value_format_display ( display , buf , value ) ; } | <S2SV_ModStart> int display = FIELD_DISPLAY ( <S2SV_ModStart> hfinfo -> display ) <S2SV_ModEnd> ; return hfinfo_char_value_format_display |
1,234 | CWE-000 void linked_list_free ( struct linked_list * * list ) { struct linked_list * cur_p = * list ; struct linked_list * next = NULL ; while ( cur_p ) { <S2SV_StartBug> next = get_list_pointer ( cur_p -> next ) ; <S2SV_EndBug> free_byte_stream ( cur_p -> key ) ; delete_node ( cur_p ) ; cur_p = next ; } } | <S2SV_ModStart> { next = get_clear_pointer <S2SV_ModEnd> ( cur_p -> |
1,235 | CWE-000 void parse_request_file ( struct http_req_hdr * header ) { <S2SV_StartBug> header -> req_file = ( char * ) malloc ( sizeof ( char ) ) ; <S2SV_EndBug> char path_buf [ 256 ] ; sprintf ( path_buf , "%s%s" , ROOT_PATH , header -> uri ) ; char * p = index ( path_buf , '?' ) ; if ( p ) strncpy ( header -> req_file , path_buf , ( size_t ) ( p - path_buf ) ) ; else strcpy ( header -> req_file , path_buf ) ; } | <S2SV_ModStart> header ) { <S2SV_ModEnd> char path_buf [ |
1,236 | CWE-000 static void scan_profile ( FILE * f ) { int comment , i ; char * p ; char buf [ BUFSIZ ] ; while ( 1 ) { p = buf ; comment = 0 ; while ( ( i = getc ( f ) ) != EOF ) { if ( i == '*' && ! comment && p > buf && p [ - 1 ] == '/' ) { comment = p - buf ; * p ++ = i ; } else if ( i == '/' && comment && p > buf && p [ - 1 ] == '*' ) { p = buf + comment - 1 ; comment = 0 ; <S2SV_StartBug> } else if ( isspace ( i ) ) { <S2SV_EndBug> if ( p > buf && ! comment ) break ; } else { * p ++ = i ; } } if ( p != buf ) { * p ++ = 0 ; if ( verbose ) printf ( "profile:<S2SV_blank>%s\\n" , buf ) ; set_option ( buf ) ; } else if ( i == EOF ) return ; } } | <S2SV_ModStart> ( isspace ( ( unsigned char ) |
1,237 | CWE-000 int tcp_comms_construct ( Tcp_Comms * comms_ptr , MMAL_COMPONENT_T * camera_ptr , Tcp_Params * tcp_params_ptr , unsigned short port_number ) { <S2SV_StartBug> comms_ptr -> server . fd = socket ( AF_INET , SOCK_STREAM , 0 ) ; <S2SV_EndBug> if ( comms_ptr -> server . fd < 0 ) { <S2SV_StartBug> LOG_ERROR ( "tcp_comms<S2SV_blank>can\'t<S2SV_blank>create<S2SV_blank>socket;<S2SV_blank>errno=%d\\n" , errno ) ; <S2SV_EndBug> return - 1 ; } comms_ptr -> server . saddr_len = sizeof ( struct sockaddr_in ) ; struct sockaddr_in * saddr_ptr = ( struct sockaddr_in * ) & comms_ptr -> server . saddr ; saddr_ptr -> sin_family = AF_INET ; saddr_ptr -> sin_addr . s_addr = INADDR_ANY ; saddr_ptr -> sin_port = htons ( port_number ) ; if ( bind ( comms_ptr -> server . fd , ( struct sockaddr * ) saddr_ptr , comms_ptr -> server . saddr_len ) < 0 ) { <S2SV_StartBug> LOG_ERROR ( "tcp_comms<S2SV_blank>can\'t<S2SV_blank>bind;<S2SV_blank>errno=%d\\n" , errno ) ; <S2SV_EndBug> return - 1 ; } if ( listen ( comms_ptr -> server . fd , 3 ) < 0 ) { <S2SV_StartBug> LOG_ERROR ( "tcp_comms<S2SV_blank>can\'t<S2SV_blank>listen;<S2SV_blank>errno=%d\\n" , errno ) ; <S2SV_EndBug> return - 1 ; } comms_ptr -> camera_ptr = camera_ptr ; <S2SV_StartBug> pthread_t pthread_id ; <S2SV_EndBug> int status = pthread_create ( & pthread_id , NULL , server_thread , comms_ptr ) ; if ( status != 0 ) { LOG_ERROR ( "tcp_comms<S2SV_blank>can\'t<S2SV_blank>pthread_create<S2SV_blank>(%d)\\n" , status ) ; return - 1 ; } return 0 ; } | <S2SV_ModStart> port_number ) { char errmsg [ MAX_ERR_MSG ] ; <S2SV_ModStart> { LOG_ERROR ( "tcp_comms<S2SV_blank>can\'t<S2SV_blank>create<S2SV_blank>socket,<S2SV_blank>errno=%d;<S2SV_blank>%s\\n" , errno , strerror_r ( errno , errmsg , MAX_ERR_MSG ) <S2SV_ModEnd> ) ; return <S2SV_ModStart> { LOG_ERROR ( "tcp_comms<S2SV_blank>can\'t<S2SV_blank>bind,<S2SV_blank>errno=%d;<S2SV_blank>%s\\n" , errno , strerror_r ( errno , errmsg , MAX_ERR_MSG ) <S2SV_ModEnd> ) ; return <S2SV_ModStart> { LOG_ERROR ( "tcp_comms<S2SV_blank>can\'t<S2SV_blank>listen,<S2SV_blank>errno=%d;<S2SV_blank>%s\\n" , errno , strerror_r ( errno , errmsg , MAX_ERR_MSG ) <S2SV_ModEnd> ) ; return <S2SV_ModStart> = camera_ptr ; comms_ptr -> params_ptr = tcp_params_ptr ; |
1,238 | CWE-000 int __blkdev_issue_zeroout ( struct block_device * bdev , sector_t sector , sector_t nr_sects , gfp_t gfp_mask , struct bio * * biop , unsigned flags ) { int ret ; int bi_size = 0 ; struct bio * bio = * biop ; unsigned int sz ; sector_t bs_mask ; bs_mask = ( bdev_logical_block_size ( bdev ) >> 9 ) - 1 ; if ( ( sector | nr_sects ) & bs_mask ) return - EINVAL ; ret = __blkdev_issue_write_zeroes ( bdev , sector , nr_sects , gfp_mask , biop , flags ) ; if ( ret != - EOPNOTSUPP || ( flags & BLKDEV_ZERO_NOFALLBACK ) ) goto out ; ret = 0 ; while ( nr_sects != 0 ) { <S2SV_StartBug> bio = next_bio ( bio , min ( nr_sects , ( sector_t ) BIO_MAX_PAGES ) , <S2SV_EndBug> gfp_mask ) ; bio -> bi_iter . bi_sector = sector ; bio -> bi_bdev = bdev ; bio_set_op_attrs ( bio , REQ_OP_WRITE , 0 ) ; while ( nr_sects != 0 ) { <S2SV_StartBug> sz = min ( ( sector_t ) PAGE_SIZE >> 9 , nr_sects ) ; <S2SV_EndBug> bi_size = bio_add_page ( bio , ZERO_PAGE ( 0 ) , sz << 9 , 0 ) ; nr_sects -= bi_size >> 9 ; <S2SV_StartBug> sector += bi_size >> 9 ; <S2SV_EndBug> <S2SV_StartBug> if ( bi_size < ( sz << 9 ) ) <S2SV_EndBug> break ; } cond_resched ( ) ; } * biop = bio ; out : return ret ; } | <S2SV_ModStart> ( bio , __blkdev_sectors_to_bio_pages ( nr_sects <S2SV_ModEnd> ) , gfp_mask <S2SV_ModStart> sector_t ) PAGE_SIZE , nr_sects << 9 ) ; bi_size = bio_add_page ( bio , ZERO_PAGE ( 0 ) , sz , 0 ) ; nr_sects -= bi_size >> 9 ; sector += <S2SV_ModEnd> bi_size >> 9 <S2SV_ModStart> >> 9 ; <S2SV_ModEnd> if ( bi_size <S2SV_ModStart> ( bi_size < sz <S2SV_ModEnd> ) break ; |
1,239 | CWE-000 <S2SV_StartBug> int16_t _get_power ( void ) <S2SV_EndBug> { int16_t power ; _dev -> driver -> get ( _dev , NETOPT_TX_POWER , & power , sizeof ( int16_t ) ) ; return power ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static |
1,240 | CWE-000 static int action_luksFormat ( void ) { int r = - EINVAL , keysize , integrity_keysize = 0 , luks_version ; const char * header_device ; char * msg = NULL , * key = NULL , * password = NULL ; char cipher [ MAX_CIPHER_LEN ] , cipher_mode [ MAX_CIPHER_LEN ] , integrity [ MAX_CIPHER_LEN ] ; size_t passwordLen ; struct crypt_device * cd = NULL ; struct crypt_params_luks1 params = { . hash = opt_hash ? : DEFAULT_LUKS1_HASH , . data_alignment = opt_align_payload , . data_device = opt_header_device ? action_argv [ 0 ] : NULL , } ; struct crypt_params_luks2 params2 = { . pbkdf = { . type = opt_pbkdf , . hash = params . hash , . time_ms = opt_iteration_time ? : DEFAULT_LUKS2_ITER_TIME , . max_memory_kb = opt_pbkdf_memory , . parallel_threads = opt_pbkdf_parallel } , . data_alignment = params . data_alignment , . data_device = params . data_device , } ; if ( ! opt_type ) return - EINVAL ; else if ( ! strcmp ( opt_type , "luks2" ) ) luks_version = 2 ; else luks_version = 1 ; header_device = opt_header_device ? : action_argv [ 0 ] ; if ( asprintf ( & msg , _ ( "This<S2SV_blank>will<S2SV_blank>overwrite<S2SV_blank>data<S2SV_blank>on<S2SV_blank>%s<S2SV_blank>irrevocably." ) , header_device ) == - 1 ) { log_err ( _ ( "memory<S2SV_blank>allocation<S2SV_blank>error<S2SV_blank>in<S2SV_blank>action_luksFormat" ) ) ; r = - ENOMEM ; goto out ; } r = yesDialog ( msg , NULL ) ? 0 : - EINVAL ; free ( msg ) ; if ( r < 0 ) goto out ; r = crypt_parse_name_and_mode ( opt_cipher ? : DEFAULT_CIPHER ( LUKS1 ) , cipher , NULL , cipher_mode ) ; if ( r < 0 ) { log_err ( _ ( "No<S2SV_blank>known<S2SV_blank>cipher<S2SV_blank>specification<S2SV_blank>pattern<S2SV_blank>detected.\\n" ) ) ; goto out ; } if ( luks_version == 2 && opt_integrity ) { r = crypt_parse_integrity_mode ( opt_integrity , integrity , & integrity_keysize ) ; if ( r < 0 ) { log_err ( _ ( "No<S2SV_blank>known<S2SV_blank>integrity<S2SV_blank>specification<S2SV_blank>pattern<S2SV_blank>detected.\\n" ) ) ; goto out ; } params2 . integrity . type = integrity ; } if ( tools_is_cipher_null ( cipher ) ) opt_force_password = 1 ; if ( ( r = crypt_init ( & cd , header_device ) ) ) { if ( opt_header_device ) log_err ( _ ( "Cannot<S2SV_blank>use<S2SV_blank>%s<S2SV_blank>as<S2SV_blank>on-disk<S2SV_blank>header.\\n" ) , header_device ) ; goto out ; } keysize = ( opt_key_size ? : DEFAULT_LUKS1_KEYBITS ) / 8 + integrity_keysize ; if ( opt_random ) crypt_set_rng_type ( cd , CRYPT_RNG_RANDOM ) ; else if ( opt_urandom ) crypt_set_rng_type ( cd , CRYPT_RNG_URANDOM ) ; r = tools_get_key ( _ ( "Enter<S2SV_blank>passphrase:<S2SV_blank>" ) , & password , & passwordLen , opt_keyfile_offset , opt_keyfile_size , opt_key_file , opt_timeout , _verify_passphrase ( 1 ) , 1 , cd ) ; if ( r < 0 ) goto out ; if ( opt_master_key_file ) { r = _read_mk ( opt_master_key_file , & key , keysize ) ; if ( r < 0 ) goto out ; } <S2SV_StartBug> if ( luks_version == 1 ) <S2SV_EndBug> r = crypt_format ( cd , CRYPT_LUKS1 , cipher , cipher_mode , opt_uuid , key , keysize , & params ) ; <S2SV_StartBug> else <S2SV_EndBug> r = crypt_format ( cd , CRYPT_LUKS2 , cipher , cipher_mode , opt_uuid , key , keysize , & params2 ) ; check_signal ( & r ) ; if ( r < 0 ) goto out ; r = crypt_keyslot_add_by_volume_key ( cd , opt_key_slot , key , keysize , password , passwordLen ) ; out : crypt_free ( cd ) ; crypt_safe_free ( key ) ; crypt_safe_free ( password ) ; return r ; } | <S2SV_ModStart> == 1 ) { r = set_pbkdf_params ( cd ) ; if ( r ) { log_err ( _ ( "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>pbkdf<S2SV_blank>parameters.\\n" ) ) ; goto out ; } <S2SV_ModStart> params ) ; } |
1,241 | CWE-000 PROCESS_THREAD ( ping6_process , ev , data ) { PROCESS_BEGIN ( ) ; PRINTF ( "ping6<S2SV_blank>running.\\n" ) ; PRINTF ( "Button<S2SV_blank>1:<S2SV_blank>5<S2SV_blank>pings<S2SV_blank>16<S2SV_blank>byte<S2SV_blank>payload.\\n" ) ; <S2SV_StartBug> uip_ip6addr ( & dest_addr , 0xaaaa , 0 , 0 , 0 , 0x0215 , 0x2000 , 0x0002 , 0x2145 ) ; <S2SV_EndBug> count = 0 ; icmp6_new ( NULL ) ; while ( 1 ) { PROCESS_YIELD ( ) ; # if BUTTON_SENSOR_ON if ( ev == sensors_event && data == & button_sensor && count == 0 ) { ping6handler ( ) ; } # endif if ( ev == PROCESS_EVENT_TIMER && etimer_expired ( & ping6_periodic_timer ) ) { ping6handler ( ) ; } if ( ev == tcpip_icmp6_event && * ( uint8_t * ) data == ICMP6_ECHO_REPLY ) { PRINTF ( "Echo<S2SV_blank>Reply\\n" ) ; } } PROCESS_END ( ) ; } | <S2SV_ModStart> & dest_addr , UIP_DS6_DEFAULT_PREFIX <S2SV_ModEnd> , 0 , |
1,242 | CWE-000 lwm2mcore_Sid_t lwm2mcore_SetSwUpdateSupportedObjects ( uint16_t instanceId , bool value ) { <S2SV_StartBug> LE_INFO ( "lwm2mcore_UpdateSetSwSupportedObjects<S2SV_blank>oiid<S2SV_blank>%d,<S2SV_blank>value<S2SV_blank>%d" , instanceId , value ) ; <S2SV_EndBug> return LWM2MCORE_ERR_COMPLETED_OK ; } | <S2SV_ModStart> value ) { LE_DEBUG <S2SV_ModEnd> ( "lwm2mcore_UpdateSetSwSupportedObjects<S2SV_blank>oiid<S2SV_blank>%d,<S2SV_blank>value<S2SV_blank>%d" , |
1,243 | CWE-000 static int f2fs_create ( struct inode * dir , struct dentry * dentry , umode_t mode , bool excl ) { struct f2fs_sb_info * sbi = F2FS_I_SB ( dir ) ; struct inode * inode ; nid_t ino = 0 ; int err ; if ( unlikely ( f2fs_cp_error ( sbi ) ) ) return - EIO ; dquot_initialize ( dir ) ; inode = f2fs_new_inode ( dir , mode ) ; if ( IS_ERR ( inode ) ) return PTR_ERR ( inode ) ; if ( ! test_opt ( sbi , DISABLE_EXT_IDENTIFY ) ) set_file_temperature ( sbi , inode , dentry -> d_name . name ) ; inode -> i_op = & f2fs_file_inode_operations ; inode -> i_fop = & f2fs_file_operations ; inode -> i_mapping -> a_ops = & f2fs_dblock_aops ; ino = inode -> i_ino ; f2fs_lock_op ( sbi ) ; err = f2fs_add_link ( dentry , inode ) ; if ( err ) goto out ; f2fs_unlock_op ( sbi ) ; alloc_nid_done ( sbi , ino ) ; <S2SV_StartBug> d_instantiate ( dentry , inode ) ; <S2SV_EndBug> unlock_new_inode ( inode ) ; if ( IS_DIRSYNC ( dir ) ) f2fs_sync_fs ( sbi -> sb , 1 ) ; f2fs_balance_fs ( sbi , true ) ; return 0 ; out : handle_failed_inode ( inode ) ; return err ; } | <S2SV_ModStart> ino ) ; unlock_new_inode ( inode ) ; <S2SV_ModStart> ( dentry , <S2SV_ModEnd> inode ) ; |
1,244 | CWE-000 int main ( int argc , char * argv [ ] ) { unsigned int i = 0 , NSTEP ; seconds_t h , TMIN , TMAX , t_curr , t_next ; mpfr_inits2 ( nbits , h , TMIN , TMAX , t_curr , t_next , NULL ) ; angle_t TH10 , TH20 ; mpfr_inits2 ( nbits , TH10 , TH20 , NULL ) ; velocity_t W10 , W20 ; mpfr_inits2 ( nbits , W10 , W20 , NULL ) ; y_t yin , yout ; mpfr_inits2 ( nbits , yin . th1 , yin . w1 , yin . th2 , yin . w2 , yout . th1 , yout . w1 , yout . th2 , yout . w2 , NULL ) ; mpfr_set_flt ( TMIN , atof ( argv [ 1 ] ) , MPFR_RNDN ) ; mpfr_set_flt ( TMAX , atof ( argv [ 2 ] ) , MPFR_RNDN ) ; mpfr_set_flt ( TH10 , atof ( argv [ 3 ] ) , MPFR_RNDN ) ; mpfr_set_flt ( W10 , atof ( argv [ 4 ] ) , MPFR_RNDN ) ; mpfr_set_flt ( TH20 , atof ( argv [ 5 ] ) , MPFR_RNDN ) ; mpfr_set_flt ( W20 , atof ( argv [ 6 ] ) , MPFR_RNDN ) ; NSTEP = atoi ( argv [ 7 ] ) ; <S2SV_StartBug> mpfr_sub ( h , TMAX , TMIN , MPFR_RNDN ) ; <S2SV_EndBug> NSTEP -- ; mpfr_div_ui ( h , h , NSTEP , MPFR_RNDN ) ; NSTEP ++ ; mpfr_t radian_conv ; mpfr_init2 ( radian_conv , nbits ) ; mpfr_const_pi ( radian_conv , MPFR_RNDN ) ; mpfr_div_si ( radian_conv , radian_conv , 180 , MPFR_RNDN ) ; mpfr_set ( t_curr , TMIN , MPFR_RNDN ) ; mpfr_mul ( yin . th1 , TH10 , radian_conv , MPFR_RNDN ) ; mpfr_mul ( yin . w1 , W10 , radian_conv , MPFR_RNDN ) ; mpfr_mul ( yin . th2 , TH20 , radian_conv , MPFR_RNDN ) ; mpfr_mul ( yin . w2 , W20 , radian_conv , MPFR_RNDN ) ; mpfr_clears ( TMIN , TMAX , TH10 , W10 , TH20 , W20 , radian_conv , NULL ) ; <S2SV_StartBug> mpfr_out_str ( stdout , 10 , 0 , t_curr , MPFR_RNDD ) ; putchar ( '<S2SV_blank>' ) ; <S2SV_EndBug> mpfr_out_str ( stdout , 10 , 0 , yin . th1 , MPFR_RNDD ) ; putchar ( '<S2SV_blank>' ) ; mpfr_out_str ( stdout , 10 , 0 , yin . w1 , MPFR_RNDD ) ; putchar ( '<S2SV_blank>' ) ; mpfr_out_str ( stdout , 10 , 0 , yin . th2 , MPFR_RNDD ) ; putchar ( '<S2SV_blank>' ) ; mpfr_out_str ( stdout , 10 , 0 , yin . w2 , MPFR_RNDD ) ; putchar ( '<S2SV_blank>' ) ; putchar ( '\\n' ) ; for ( i = 0 ; i < NSTEP - 1 ; i ++ ) { mpfr_add ( t_next , t_curr , h , MPFR_RNDN ) ; runge_kutta ( t_curr , & yin , & yout , h ) ; <S2SV_StartBug> mpfr_out_str ( stdout , 10 , 0 , t_next , MPFR_RNDD ) ; putchar ( '<S2SV_blank>' ) ; <S2SV_EndBug> mpfr_out_str ( stdout , 10 , 0 , yout . th1 , MPFR_RNDD ) ; putchar ( '<S2SV_blank>' ) ; mpfr_out_str ( stdout , 10 , 0 , yout . w1 , MPFR_RNDD ) ; putchar ( '<S2SV_blank>' ) ; mpfr_out_str ( stdout , 10 , 0 , yout . th2 , MPFR_RNDD ) ; putchar ( '<S2SV_blank>' ) ; mpfr_out_str ( stdout , 10 , 0 , yout . w2 , MPFR_RNDD ) ; putchar ( '<S2SV_blank>' ) ; putchar ( '\\n' ) ; mpfr_set ( yin . th1 , yout . th1 , MPFR_RNDN ) ; mpfr_set ( yin . w1 , yout . w1 , MPFR_RNDN ) ; mpfr_set ( yin . th2 , yout . th2 , MPFR_RNDN ) ; mpfr_set ( yin . w2 , yout . w2 , MPFR_RNDN ) ; mpfr_set ( t_curr , t_next , MPFR_RNDN ) ; } mpfr_clears ( h , t_curr , t_next , yin . th1 , yin . w1 , yin . th2 , yin . w2 , yout . th1 , yout . w1 , yout . th2 , yout . w2 , NULL ) ; mpfr_free_cache ( ) ; return 0 ; } | <S2SV_ModStart> ] ) ; if ( NSTEP < 2 ) { printf ( "Number<S2SV_blank>of<S2SV_blank>steps<S2SV_blank>must<S2SV_blank>be<S2SV_blank>greater<S2SV_blank>than<S2SV_blank>1" ) ; return 0 ; } <S2SV_ModStart> NULL ) ; mpfr_printf ( "%0.6RNf<S2SV_blank>%0.6RNf<S2SV_blank>%0.6RNF<S2SV_blank>%0.6RNF<S2SV_blank>%0.6RNF\\n" , t_curr , yin . th1 , yin . w1 , yin . th2 , yin . w2 <S2SV_ModEnd> ) ; for <S2SV_ModStart> h ) ; mpfr_printf ( "%0.6RNf<S2SV_blank>%0.6RNf<S2SV_blank>%0.6RNF<S2SV_blank>%0.6RNF<S2SV_blank>%0.6RNF\\n" <S2SV_ModEnd> , t_next , <S2SV_ModStart> , t_next , yout . th1 , yout . w1 , yout . th2 , yout . w2 <S2SV_ModEnd> ) ; mpfr_set |
1,245 | CWE-000 static int crypto4xx_crypt_aes_ccm ( struct aead_request * req , bool decrypt ) { struct crypto4xx_ctx * ctx = crypto_tfm_ctx ( req -> base . tfm ) ; <S2SV_StartBug> struct crypto_aead * aead = crypto_aead_reqtfm ( req ) ; <S2SV_EndBug> __le32 iv [ 16 ] ; u32 tmp_sa [ SA_AES128_CCM_LEN + 4 ] ; struct dynamic_sa_ctl * sa = ( struct dynamic_sa_ctl * ) tmp_sa ; unsigned int len = req -> cryptlen ; if ( decrypt ) len -= crypto_aead_authsize ( aead ) ; if ( crypto4xx_aead_need_fallback ( req , len , true , decrypt ) ) return crypto4xx_aead_fallback ( req , ctx , decrypt ) ; memcpy ( tmp_sa , decrypt ? ctx -> sa_in : ctx -> sa_out , ctx -> sa_len * 4 ) ; sa -> sa_command_0 . bf . digest_len = crypto_aead_authsize ( aead ) >> 2 ; if ( req -> iv [ 0 ] == 1 ) { sa -> sa_command_1 . bf . crypto_mode9_8 = 1 ; } iv [ 3 ] = cpu_to_le32 ( 0 ) ; crypto4xx_memcpy_to_le32 ( iv , req -> iv , 16 - ( req -> iv [ 0 ] + 1 ) ) ; return crypto4xx_build_pd ( & req -> base , ctx , req -> src , req -> dst , len , iv , sizeof ( iv ) , <S2SV_StartBug> sa , ctx -> sa_len , req -> assoclen ) ; <S2SV_EndBug> } | <S2SV_ModStart> ) ; struct crypto4xx_aead_reqctx * rctx = aead_request_ctx ( req ) ; struct <S2SV_ModStart> req -> assoclen , rctx -> dst |
1,246 | CWE-000 void join_timer_start ( struct pim_upstream * up ) { <S2SV_StartBug> struct pim_neighbor * nbr ; <S2SV_EndBug> nbr = pim_neighbor_find ( up -> rpf . source_nexthop . interface , up -> rpf . rpf_addr . u . prefix4 ) ; if ( PIM_DEBUG_PIM_EVENTS ) { zlog_debug ( "%s:<S2SV_blank>starting<S2SV_blank>%d<S2SV_blank>sec<S2SV_blank>timer<S2SV_blank>for<S2SV_blank>upstream<S2SV_blank>(S,G)=%s" , __PRETTY_FUNCTION__ , qpim_t_periodic , <S2SV_StartBug> up -> sg_str ) ; <S2SV_EndBug> } if ( nbr ) pim_jp_agg_add_group ( nbr -> upstream_jp_agg , up , 1 ) ; else { THREAD_OFF ( up -> t_join_timer ) ; THREAD_TIMER_ON ( master , up -> t_join_timer , on_join_timer , up , qpim_t_periodic ) ; } } | <S2SV_ModStart> pim_neighbor * nbr = NULL ; if ( up -> rpf . source_nexthop . interface ) { <S2SV_ModEnd> nbr = pim_neighbor_find <S2SV_ModStart> sg_str ) ; } |
1,247 | CWE-000 struct dst_entry * inet_csk_route_req ( const struct sock * sk , struct flowi4 * fl4 , const struct request_sock * req ) { const struct inet_request_sock * ireq = inet_rsk ( req ) ; struct net * net = read_pnet ( & ireq -> ireq_net ) ; <S2SV_StartBug> struct ip_options_rcu * opt = ireq -> opt ; <S2SV_EndBug> <S2SV_StartBug> struct rtable * rt ; <S2SV_EndBug> flowi4_init_output ( fl4 , ireq -> ir_iif , ireq -> ir_mark , RT_CONN_FLAGS ( sk ) , RT_SCOPE_UNIVERSE , sk -> sk_protocol , inet_sk_flowi_flags ( sk ) , ( opt && opt -> opt . srr ) ? opt -> opt . faddr : ireq -> ir_rmt_addr , ireq -> ir_loc_addr , ireq -> ir_rmt_port , htons ( ireq -> ir_num ) ) ; security_req_classify_flow ( req , flowi4_to_flowi ( fl4 ) ) ; rt = ip_route_output_flow ( net , fl4 , sk ) ; if ( IS_ERR ( rt ) ) goto no_route ; if ( opt && opt -> opt . is_strictroute && rt -> rt_uses_gateway ) goto route_err ; return & rt -> dst ; route_err : ip_rt_put ( rt ) ; no_route : __IP_INC_STATS ( net , IPSTATS_MIB_OUTNOROUTES ) ; return NULL ; } | <S2SV_ModStart> ip_options_rcu * opt <S2SV_ModEnd> ; struct rtable <S2SV_ModStart> rtable * rt ; opt = rcu_dereference ( ireq -> ireq_opt ) |
1,248 | CWE-000 Scheme_Object * extract_impersonator_results ( int c , int argc , Scheme_Object * * argv2 , const char * what , Scheme_Object * o , Scheme_Chaperone * px , Scheme_Cont_Frame_Data * cframe , int * _need_pop ) { int extra = c - argc ; int i , fail_reason = 0 ; Scheme_Object * post ; char nth [ 32 ] ; Scheme_Config * config = NULL ; if ( ! extra ) return NULL ; post = NULL ; for ( i = 0 ; i < extra ; ) { if ( ! i && SCHEME_PROCP ( argv2 [ 0 ] ) ) { post = argv2 [ i ] ; i ++ ; } else if ( SAME_OBJ ( argv2 [ i ] , mark_symbol ) ) { if ( i + 3 > extra ) { fail_reason = 2 ; break ; } if ( post && ! * _need_pop ) { scheme_push_continuation_frame ( cframe ) ; * _need_pop = 1 ; } scheme_set_cont_mark ( argv2 [ i + 1 ] , argv2 [ i + 2 ] ) ; i += 3 ; } else { fail_reason = 1 ; break ; } } if ( ! fail_reason ) { if ( config ) { if ( post && ! * _need_pop ) { scheme_push_continuation_frame ( cframe ) ; * _need_pop = 1 ; } scheme_set_cont_mark ( scheme_parameterization_key , ( Scheme_Object * ) config ) ; } return post ; } switch ( i % 10 ) { case 1 : sprintf ( nth , "%dst" , i ) ; break ; case 2 : sprintf ( nth , "%dnd" , i ) ; break ; case 3 : sprintf ( nth , "%drd" , i ) ; break ; default : sprintf ( nth , "%dth" , i ) ; } if ( fail_reason == 1 ) { scheme_raise_exn ( MZEXN_FAIL_CONTRACT , "procedure<S2SV_blank>%s:<S2SV_blank>wrapper\'s<S2SV_blank>%s<S2SV_blank>result<S2SV_blank>is<S2SV_blank>not<S2SV_blank>valid;\\n" "<S2SV_blank>%s<S2SV_blank>extra<S2SV_blank>result<S2SV_blank>(before<S2SV_blank>original<S2SV_blank>argument<S2SV_blank>count)<S2SV_blank>should<S2SV_blank>be\\n" <S2SV_StartBug> "<S2SV_blank>\'mark%s\'parameter%s\\n" <S2SV_EndBug> "<S2SV_blank><S2SV_blank>original:<S2SV_blank>%V\\n" "<S2SV_blank><S2SV_blank>wrapper:<S2SV_blank>%V\\n" "<S2SV_blank><S2SV_blank>received:<S2SV_blank>%V" , what , nth , <S2SV_StartBug> nth , <S2SV_EndBug> ( i ? "<S2SV_blank>or<S2SV_blank>" : ",<S2SV_blank>" ) , <S2SV_StartBug> ( i ? "" : ",<S2SV_blank>or<S2SV_blank>a<S2SV_blank>wrapper<S2SV_blank>for<S2SV_blank>the<S2SV_blank>original<S2SV_blank>procedure\'s<S2SV_blank>result" ) , <S2SV_EndBug> o , SCHEME_VEC_ELS ( px -> redirects ) [ 0 ] , argv2 [ i ] ) ; } else if ( fail_reason == 2 ) { scheme_raise_exn ( MZEXN_FAIL_CONTRACT , "procedure<S2SV_blank>%s:<S2SV_blank>wrapper\'s<S2SV_blank>%s<S2SV_blank>result<S2SV_blank>needs<S2SV_blank>addition<S2SV_blank>extra<S2SV_blank>results;\\n" "<S2SV_blank>%s<S2SV_blank>extra<S2SV_blank>result<S2SV_blank>(before<S2SV_blank>original<S2SV_blank>argument<S2SV_blank>count)<S2SV_blank>needs<S2SV_blank>an\\n" "<S2SV_blank>additional<S2SV_blank>%s<S2SV_blank>after<S2SV_blank>%V\\n" "<S2SV_blank><S2SV_blank>original:<S2SV_blank>%V\\n" "<S2SV_blank><S2SV_blank>wrapper:<S2SV_blank>%V" , what , nth , nth , ( ( i + 1 < extra ) ? "result" : "two<S2SV_blank>results" ) , argv2 [ i ] , o , SCHEME_VEC_ELS ( px -> redirects ) [ 0 ] ) ; } return NULL ; } | <S2SV_ModStart> , "procedure<S2SV_blank>%s:<S2SV_blank>wrapper\'s<S2SV_blank>%s<S2SV_blank>result<S2SV_blank>is<S2SV_blank>not<S2SV_blank>valid;\\n" "<S2SV_blank>%s<S2SV_blank>extra<S2SV_blank>result<S2SV_blank>(before<S2SV_blank>original<S2SV_blank>argument<S2SV_blank>count)<S2SV_blank>should<S2SV_blank>be\\n" "<S2SV_blank>\'mark%s\\n" <S2SV_ModEnd> "<S2SV_blank><S2SV_blank>original:<S2SV_blank>%V\\n" "<S2SV_blank><S2SV_blank>wrapper:<S2SV_blank>%V\\n" "<S2SV_blank><S2SV_blank>received:<S2SV_blank>%V" <S2SV_ModStart> nth , nth <S2SV_ModEnd> , ( i <S2SV_ModStart> ? "" : "<S2SV_blank>or<S2SV_blank>a<S2SV_blank>wrapper<S2SV_blank>for<S2SV_blank>the<S2SV_blank>original<S2SV_blank>procedure\'s<S2SV_blank>result" <S2SV_ModEnd> ) , o |
1,249 | CWE-000 int int2e_ip2_cart ( double * out , int * dims , int * shls , int * atm , int natm , int * bas , int nbas , double * env , CINTOpt * opt , double * cache ) { int ng [ ] = { 0 , 0 , 1 , 0 , 1 , 1 , 1 , 3 } ; CINTEnvVars envs ; CINTinit_int2e_EnvVars ( & envs , ng , shls , atm , natm , bas , nbas , env ) ; envs . f_gout = & CINTgout2e_int2e_ip2 ; envs . f_gout_simd1 = & CINTgout2e_int2e_ip2_simd1 ; <S2SV_StartBug> envs . common_factor *= 1 ; <S2SV_EndBug> return CINT2e_cart_drv ( out , dims , & envs , opt , cache ) ; } | <S2SV_ModStart> & CINTgout2e_int2e_ip2_simd1 ; <S2SV_ModEnd> return CINT2e_cart_drv ( |
1,250 | CWE-000 gboolean nemo_list_model_add_file ( NemoListModel * model , NemoFile * file , NemoDirectory * directory ) { GtkTreeIter iter ; GtkTreePath * path ; FileEntry * file_entry ; GSequenceIter * ptr , * parent_ptr ; GSequence * files ; gboolean replace_dummy ; GHashTable * parent_hash ; parent_ptr = g_hash_table_lookup ( model -> details -> directory_reverse_map , directory ) ; if ( parent_ptr ) { file_entry = g_sequence_get ( parent_ptr ) ; ptr = g_hash_table_lookup ( file_entry -> reverse_map , file ) ; } else { file_entry = NULL ; ptr = g_hash_table_lookup ( model -> details -> top_reverse_map , file ) ; } if ( ptr != NULL ) { g_warning ( "file<S2SV_blank>already<S2SV_blank>in<S2SV_blank>tree<S2SV_blank>(parent_ptr:<S2SV_blank>%p)!!!\\n" , parent_ptr ) ; return FALSE ; } file_entry = g_new0 ( FileEntry , 1 ) ; file_entry -> file = nemo_file_ref ( file ) ; file_entry -> parent = NULL ; file_entry -> subdirectory = NULL ; file_entry -> files = NULL ; files = model -> details -> files ; parent_hash = model -> details -> top_reverse_map ; replace_dummy = FALSE ; if ( parent_ptr != NULL ) { file_entry -> parent = g_sequence_get ( parent_ptr ) ; file_entry -> parent -> loaded = 1 ; parent_hash = file_entry -> parent -> reverse_map ; files = file_entry -> parent -> files ; if ( g_sequence_get_length ( files ) == 1 ) { GSequenceIter * dummy_ptr = g_sequence_get_iter_at_pos ( files , 0 ) ; FileEntry * dummy_entry = g_sequence_get ( dummy_ptr ) ; if ( dummy_entry -> file == NULL ) { model -> details -> stamp ++ ; g_sequence_remove ( dummy_ptr ) ; replace_dummy = TRUE ; } } } if ( model -> details -> temp_unsorted ) file_entry -> ptr = g_sequence_append ( files , file_entry ) ; else file_entry -> ptr = g_sequence_insert_sorted ( files , file_entry , nemo_list_model_file_entry_compare_func , model ) ; g_hash_table_insert ( parent_hash , file , file_entry -> ptr ) ; iter . stamp = model -> details -> stamp ; iter . user_data = file_entry -> ptr ; path = gtk_tree_model_get_path ( GTK_TREE_MODEL ( model ) , & iter ) ; if ( replace_dummy ) { gtk_tree_model_row_changed ( GTK_TREE_MODEL ( model ) , path , & iter ) ; } else { gtk_tree_model_row_inserted ( GTK_TREE_MODEL ( model ) , path , & iter ) ; } if ( nemo_file_is_directory ( file ) ) { guint count ; <S2SV_StartBug> file_entry -> files = g_sequence_new ( ( GDestroyNotify ) file_entry_free ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ! nemo_file_get_directory_item_count ( file , & count , NULL ) || count > 0 ) { <S2SV_EndBug> add_dummy_row ( model , file_entry ) ; gtk_tree_model_row_has_child_toggled ( GTK_TREE_MODEL ( model ) , path , & iter ) ; } } gtk_tree_path_free ( path ) ; return TRUE ; } | <S2SV_ModStart> guint count ; gboolean got_count , unreadable ; <S2SV_ModStart> file_entry_free ) ; got_count = <S2SV_ModEnd> nemo_file_get_directory_item_count ( file <S2SV_ModStart> & count , & unreadable ) ; if ( ( ! got_count && ! unreadable <S2SV_ModEnd> ) || count |
1,251 | CWE-000 static enum optics_ret lens_histo_read ( struct optics_lens * lens , optics_epoch_t epoch , struct optics_histo * value ) { ( void ) epoch ; struct lens_histo * histo = lens_sub_ptr ( lens -> lens , optics_histo ) ; if ( ! histo ) return optics_err ; <S2SV_StartBug> value -> buckets_len = histo -> buckets_len ; <S2SV_EndBug> memcpy ( value -> buckets , histo -> buckets , histo -> buckets_len * sizeof ( histo -> buckets [ 0 ] ) ) ; <S2SV_StartBug> struct lens_histo_epoch * counters = & histo -> epochs [ epoch ] ; <S2SV_EndBug> <S2SV_StartBug> value -> below = atomic_exchange_explicit ( & counters -> below , 0 , memory_order_relaxed ) ; <S2SV_EndBug> <S2SV_StartBug> value -> above = atomic_exchange_explicit ( & counters -> above , 0 , memory_order_relaxed ) ; <S2SV_EndBug> for ( size_t i = 0 ; i < histo -> buckets_len - 1 ; ++ i ) { value -> counts [ i ] += atomic_exchange_explicit ( & counters -> counts [ i ] , 0 , memory_order_relaxed ) ; } return optics_ok ; } | <S2SV_ModStart> return optics_err ; if ( ! value -> buckets_len ) { <S2SV_ModStart> ) ) ; } else { if ( histo -> buckets_len != value -> buckets_len ) return optics_err ; for ( size_t i = 0 ; i < histo -> buckets_len ; ++ i ) if ( histo -> buckets [ i ] != value -> buckets [ i ] ) return optics_err ; } <S2SV_ModStart> value -> below += <S2SV_ModEnd> atomic_exchange_explicit ( & <S2SV_ModStart> value -> above += <S2SV_ModEnd> atomic_exchange_explicit ( & |
1,252 | CWE-000 boolean sliparm ( const struct permonst * ptr , const struct objclass * oc ) { return ( ( boolean ) <S2SV_StartBug> ( is_whirly ( ptr ) || ptr -> msize <= oc -> a_minsize || <S2SV_EndBug> noncorporeal ( ptr ) ) ) ; } | <S2SV_ModStart> ptr -> msize < <S2SV_ModEnd> oc -> a_minsize |
1,253 | CWE-000 void bc_vm_sig ( int sig ) { if ( sig == SIGINT ) { <S2SV_StartBug> const char * msg = ! strcmp ( bcg . name , dc_name ) ? dc_sig_msg : bc_sig_msg ; <S2SV_EndBug> <S2SV_StartBug> size_t len = strlen ( msg ) ; <S2SV_EndBug> <S2SV_StartBug> if ( write ( 2 , msg , len ) == ( ssize_t ) len ) <S2SV_EndBug> bcg . sig += ( bcg . signe = bcg . sig == bcg . sigc ) ; } else bcg . sig_other = 1 ; } | <S2SV_ModStart> SIGINT ) { <S2SV_ModEnd> size_t len = <S2SV_ModStart> = strlen ( bcg . sig_msg <S2SV_ModEnd> ) ; if <S2SV_ModStart> ( 2 , bcg . sig_msg <S2SV_ModEnd> , len ) |
1,254 | CWE-000 bool init ( void ) { pari_init ( cfg . memory , 1000000 ) ; if ( ! random_init ( ) ) return false ; if ( cfg . datadir ) { default0 ( "datadir" , cfg . datadir ) ; } pari_sp ltop = avma ; <S2SV_StartBug> ellmodulareqn ( 2 , - 1 , - 1 ) ; <S2SV_EndBug> avma = ltop ; output_init ( & cfg ) ; input_init ( & cfg ) ; return true ; } | <S2SV_ModStart> = avma ; pari_CATCH ( e_FILE ) { } pari_TRY { <S2SV_ModStart> 1 ) ; } pari_ENDCATCH |
1,255 | CWE-000 REBTYPE ( Struct ) { REBVAL * val = D_ARG ( 1 ) ; REBVAL * arg ; switch ( action ) { case SYM_CHANGE : { arg = D_ARG ( 2 ) ; if ( ! IS_BINARY ( arg ) ) fail ( Error_Unexpected_Type ( REB_BINARY , VAL_TYPE ( arg ) ) ) ; if ( VAL_LEN_AT ( arg ) != VAL_STRUCT_DATA_LEN ( val ) ) fail ( arg ) ; memcpy ( VAL_STRUCT_DATA_HEAD ( val ) , BIN_HEAD ( VAL_SERIES ( arg ) ) , VAL_STRUCT_DATA_LEN ( val ) ) ; Move_Value ( D_OUT , val ) ; return R_OUT ; } case SYM_REFLECT : { INCLUDE_PARAMS_OF_REFLECT ; UNUSED ( ARG ( value ) ) ; REBSYM property = VAL_WORD_SYM ( ARG ( property ) ) ; assert ( property != SYM_0 ) ; switch ( property ) { <S2SV_StartBug> case SYM_LENGTH_OF : <S2SV_EndBug> Init_Integer ( D_OUT , VAL_STRUCT_DATA_LEN ( val ) ) ; return R_OUT ; case SYM_VALUES : { fail_if_non_accessible ( val ) ; REBSER * bin = Make_Binary ( VAL_STRUCT_SIZE ( val ) ) ; memcpy ( BIN_HEAD ( bin ) , VAL_STRUCT_DATA_AT ( val ) , VAL_STRUCT_SIZE ( val ) ) ; TERM_BIN_LEN ( bin , VAL_STRUCT_SIZE ( val ) ) ; Init_Binary ( D_OUT , bin ) ; return R_OUT ; } case SYM_SPEC : Init_Block ( D_OUT , Struct_To_Array ( VAL_STRUCT ( val ) ) ) ; return R_OUT ; default : break ; } fail ( Error_Cannot_Reflect ( REB_STRUCT , ARG ( property ) ) ) ; } default : break ; } fail ( Error_Illegal_Action ( REB_STRUCT , action ) ) ; } | <S2SV_ModStart> ) { case SYM_LENGTH <S2SV_ModEnd> : Init_Integer ( |
1,256 | CWE-000 int main ( int argc , char * argv [ ] ) { struct addrinfo hints ; struct addrinfo * result , * rp ; int sfd , s , j ; size_t len ; ssize_t nread ; if ( argc < 4 ) { fprintf ( stderr , "Usage:<S2SV_blank>%s<S2SV_blank>host<S2SV_blank>thread-count<S2SV_blank>header-count<S2SV_blank>[port]\\n" , argv [ 0 ] ) ; exit ( EXIT_FAILURE ) ; } char * host = argv [ 1 ] ; int header_count = atoi ( argv [ 3 ] ) ; snprintf ( req_buf , sizeof ( req_buf ) , "POST<S2SV_blank>/post<S2SV_blank>HTTP/1.1\\r\\nHost:<S2SV_blank>%s\\r\\nConnection:<S2SV_blank>close\\r\\nContent-length:%d\\r\\n" , host , sizeof ( post_buf ) ) ; int i ; for ( i = 0 ; i < header_count ; i ++ ) { sprintf ( req_buf + strlen ( req_buf ) , "header%d:%d\\r\\n" , i , i ) ; } strcat ( req_buf , "\\r\\n" ) ; memset ( post_buf , '0' , sizeof ( post_buf ) ) ; int thread_count = atoi ( argv [ 2 ] ) ; <S2SV_StartBug> char * port = argc == 5 ? argv [ 4 ] : "443" ; <S2SV_EndBug> memset ( & hints , 0 , sizeof ( struct addrinfo ) ) ; hints . ai_family = AF_UNSPEC ; hints . ai_socktype = SOCK_STREAM ; hints . ai_flags = 0 ; hints . ai_protocol = 0 ; s = getaddrinfo ( host , port , & hints , & result ) ; if ( s != 0 ) { fprintf ( stderr , "getaddrinfo:<S2SV_blank>%s\\n" , gai_strerror ( s ) ) ; exit ( EXIT_FAILURE ) ; } for ( rp = result ; rp != NULL ; rp = rp -> ai_next ) { sfd = socket ( rp -> ai_family , rp -> ai_socktype , rp -> ai_protocol ) ; if ( sfd == - 1 ) continue ; if ( connect ( sfd , rp -> ai_addr , rp -> ai_addrlen ) != - 1 ) break ; close ( sfd ) ; } if ( rp == NULL ) { fprintf ( stderr , "Could<S2SV_blank>not<S2SV_blank>connect\\n" ) ; exit ( EXIT_FAILURE ) ; } SSL_load_error_strings ( ) ; SSL_library_init ( ) ; mutex_buf = ( pthread_mutex_t * ) OPENSSL_malloc ( CRYPTO_num_locks ( ) * sizeof ( pthread_mutex_t ) ) ; for ( i = 0 ; i < CRYPTO_num_locks ( ) ; i ++ ) { pthread_mutex_init ( & mutex_buf [ i ] , NULL ) ; } CRYPTO_set_locking_callback ( SSL_locking_callback ) ; CRYPTO_THREADID_set_callback ( SSL_pthreads_thread_id ) ; SSL_CTX * client_ctx = SSL_CTX_new ( SSLv23_client_method ( ) ) ; SSL * ssl = SSL_new ( client_ctx ) ; SSL_set_fd ( ssl , sfd ) ; int ret = SSL_connect ( ssl ) ; int read_count = 0 ; int write_count = 1 ; printf ( "Sent<S2SV_blank>request\\n" ) ; if ( ( ret = SSL_write ( ssl , req_buf , strlen ( req_buf ) ) ) <= 0 ) { int error = SSL_get_error ( ssl , ret ) ; printf ( "SSL_write<S2SV_blank>failed<S2SV_blank>%d" , error ) ; exit ( 1 ) ; } SSL_write ( ssl , post_buf , sizeof ( post_buf ) ) ; char input_buf [ 1024 ] ; int read_bytes = SSL_read ( ssl , input_buf , sizeof ( input_buf ) ) ; if ( read_bytes > 0 && read_bytes < 1024 ) input_buf [ read_bytes ] = '\\0' ; else input_buf [ 1023 ] = '\\0' ; SSL_SESSION * session = SSL_get_session ( ssl ) ; close ( sfd ) ; struct thread_info tinfo ; tinfo . rp = rp ; tinfo . session = session ; <S2SV_StartBug> pthread_t * threads = malloc ( thread_count * sizeof ( pthread_t ) ) ; <S2SV_EndBug> for ( i = 0 ; i < thread_count ; i ++ ) { pthread_create ( threads + i , NULL , spawn_same_session_send , & tinfo ) ; } void * retval ; for ( i = 0 ; i < thread_count ; i ++ ) { retval = NULL ; pthread_join ( threads [ i ] , & retval ) ; if ( retval != NULL ) { printf ( "Thread<S2SV_blank>%d<S2SV_blank>failed<S2SV_blank>0x%x\\n" , i , retval ) ; } } printf ( "All<S2SV_blank>threads<S2SV_blank>finished\\n" ) ; exit ( 0 ) ; } | <S2SV_ModStart> ] ) ; const <S2SV_ModStart> * threads = ( pthread_t * ) |
1,257 | CWE-000 static void recv_cb_offload_disabled ( struct net_context * context , struct net_pkt * pkt , int status , void * user_data ) { struct net_udp_hdr hdr , * udp_hdr ; <S2SV_StartBug> udp_hdr = net_udp_get_hdr ( pkt , & hdr ) ; <S2SV_EndBug> zassert_not_equal ( udp_hdr -> chksum , 0 , "Checksum<S2SV_blank>is<S2SV_blank>not<S2SV_blank>set\\n" ) ; if ( net_pkt_family ( pkt ) == AF_INET ) { struct net_ipv4_hdr * ipv4 = NET_IPV4_HDR ( pkt ) ; zassert_not_equal ( ipv4 -> chksum , 0 , "IPv4<S2SV_blank>checksum<S2SV_blank>is<S2SV_blank>not<S2SV_blank>set\\n" ) ; } k_sem_give ( & wait_data ) ; net_pkt_unref ( pkt ) ; } | <S2SV_ModStart> , & hdr ) ; zassert_not_null ( udp_hdr , "UDP<S2SV_blank>header<S2SV_blank>missing" |
1,258 | CWE-000 <S2SV_StartBug> ATF_TC_BODY ( fchdir_failure , tc ) <S2SV_EndBug> <S2SV_StartBug> { <S2SV_EndBug> pid = getpid ( ) ; <S2SV_StartBug> snprintf ( pcregex , sizeof ( pcregex ) , "fchdir.*%d.*return,failure" , pid ) ; <S2SV_EndBug> FILE * pipefd = setup ( fds , auclass ) ; <S2SV_StartBug> ATF_REQUIRE_EQ ( - 1 , fchdir ( - 1 ) ) ; <S2SV_EndBug> check_audit ( fds , pcregex , pipefd ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> <S2SV_null> ATF_TC_BODY ( fchdir_success <S2SV_ModEnd> , tc ) <S2SV_ModStart> tc ) { char dirpath [ 50 ] ; ATF_REQUIRE ( getcwd ( dirpath , sizeof ( dirpath ) ) != NULL ) ; ATF_REQUIRE ( ( filedesc = open ( dirpath , O_RDONLY ) ) != - 1 ) ; <S2SV_ModStart> pcregex ) , "fchdir.*%d.*return,success" <S2SV_ModEnd> , pid ) <S2SV_ModStart> ; ATF_REQUIRE_EQ ( 0 <S2SV_ModEnd> , fchdir ( <S2SV_ModStart> , fchdir ( filedesc <S2SV_ModEnd> ) ) ; <S2SV_ModStart> pipefd ) ; close ( filedesc ) ; |
1,259 | CWE-000 void test_0To512BytesData ( ) { int ret ; unsigned int i , frame_length = 0 , recv_length = 0 ; yahdlc_control_t control_send , control_recv ; char send_data [ 512 ] , frame_data [ 520 ] , recv_data [ 520 ] ; yahdlc_state_t state ; yahdlc_reset_state ( & state ) ; for ( i = 0 ; i < sizeof ( send_data ) ; i ++ ) { send_data [ i ] = ( char ) ( rand ( ) % 0x70 ) ; } for ( i = 0 ; i <= sizeof ( send_data ) ; i ++ ) { control_send . frame = YAHDLC_FRAME_DATA ; ret = yahdlc_frame_data ( & control_send , send_data , i , frame_data , & frame_length ) ; TEST_ASSERT ( frame_length <= ( ( i + 6 ) + 2 ) ) ; TEST_ASSERT_EQUAL_INT ( ret , 0 ) ; <S2SV_StartBug> ret = yahdlc_get_data ( & state , & control_recv , frame_data , frame_length , recv_data , <S2SV_EndBug> & recv_length ) ; TEST_ASSERT_EQUAL_INT ( ret , ( frame_length - 1 ) ) ; TEST_ASSERT_EQUAL_INT ( recv_length , i ) ; ret = memcmp ( send_data , recv_data , i ) ; TEST_ASSERT_EQUAL_INT ( ret , 0 ) ; } } | <S2SV_ModStart> 0 ) ; recv_length = 0 ; |
1,260 | CWE-000 int rpcsvc_auth_array ( rpcsvc_t * svc , char * volname , int * autharr , int arrlen ) { int count = 0 ; int result = RPCSVC_AUTH_REJECT ; char * srchstr = NULL ; int ret = 0 ; struct rpcsvc_auth_list * auth = NULL ; struct rpcsvc_auth_list * tmp = NULL ; if ( ( ! svc ) || ( ! autharr ) || ( ! volname ) ) return - 1 ; memset ( autharr , 0 , arrlen * sizeof ( int ) ) ; if ( list_empty ( & svc -> authschemes ) ) { gf_log ( GF_RPCSVC , GF_LOG_ERROR , "No<S2SV_blank>authentication!" ) ; goto err ; } list_for_each_entry_safe ( auth , tmp , & svc -> authschemes , authlist ) { if ( count >= arrlen ) break ; result = gf_asprintf ( & srchstr , "rpc-auth.%s.%s" , auth -> name , volname ) ; if ( result == - 1 ) { count = - 1 ; goto err ; } ret = dict_get_str_boolean ( svc -> options , srchstr , 0xC00FFEE ) ; GF_FREE ( srchstr ) ; switch ( ret ) { case _gf_true : <S2SV_StartBug> result = RPCSVC_AUTH_ACCEPT ; <S2SV_EndBug> autharr [ count ] = auth -> auth -> authnum ; <S2SV_StartBug> ++ count ; <S2SV_EndBug> break ; case _gf_false : result = RPCSVC_AUTH_REJECT ; break ; default : <S2SV_StartBug> result = RPCSVC_AUTH_DONTCARE ; <S2SV_EndBug> } } err : return count ; } | <S2SV_ModStart> case _gf_true : <S2SV_ModEnd> autharr [ count <S2SV_ModStart> ; ++ count <S2SV_ModEnd> ; break ; <S2SV_ModStart> ; default : break <S2SV_ModEnd> ; } } |
1,261 | CWE-000 static int amdgpu_device_ip_fini ( struct amdgpu_device * adev ) { int i , r ; amdgpu_amdkfd_device_fini ( adev ) ; for ( i = 0 ; i < adev -> num_ip_blocks ; i ++ ) { if ( ! adev -> ip_blocks [ i ] . status . hw ) continue ; if ( adev -> ip_blocks [ i ] . version -> type == AMD_IP_BLOCK_TYPE_SMC ) { r = adev -> ip_blocks [ i ] . version -> funcs -> set_clockgating_state ( ( void * ) adev , AMD_CG_STATE_UNGATE ) ; if ( r ) { DRM_ERROR ( "set_clockgating_state(ungate)<S2SV_blank>of<S2SV_blank>IP<S2SV_blank>block<S2SV_blank><%s><S2SV_blank>failed<S2SV_blank>%d\\n" , adev -> ip_blocks [ i ] . version -> funcs -> name , r ) ; return r ; } r = adev -> ip_blocks [ i ] . version -> funcs -> hw_fini ( ( void * ) adev ) ; if ( r ) { DRM_DEBUG ( "hw_fini<S2SV_blank>of<S2SV_blank>IP<S2SV_blank>block<S2SV_blank><%s><S2SV_blank>failed<S2SV_blank>%d\\n" , adev -> ip_blocks [ i ] . version -> funcs -> name , r ) ; } adev -> ip_blocks [ i ] . status . hw = false ; break ; } } for ( i = adev -> num_ip_blocks - 1 ; i >= 0 ; i -- ) { if ( ! adev -> ip_blocks [ i ] . status . hw ) continue ; <S2SV_StartBug> if ( adev -> ip_blocks [ i ] . version -> type == AMD_IP_BLOCK_TYPE_GMC ) { <S2SV_EndBug> amdgpu_free_static_csa ( adev ) ; amdgpu_device_wb_fini ( adev ) ; amdgpu_device_vram_scratch_fini ( adev ) ; } if ( adev -> ip_blocks [ i ] . version -> type != AMD_IP_BLOCK_TYPE_UVD && adev -> ip_blocks [ i ] . version -> type != AMD_IP_BLOCK_TYPE_VCE ) { r = adev -> ip_blocks [ i ] . version -> funcs -> set_clockgating_state ( ( void * ) adev , AMD_CG_STATE_UNGATE ) ; if ( r ) { DRM_ERROR ( "set_clockgating_state(ungate)<S2SV_blank>of<S2SV_blank>IP<S2SV_blank>block<S2SV_blank><%s><S2SV_blank>failed<S2SV_blank>%d\\n" , adev -> ip_blocks [ i ] . version -> funcs -> name , r ) ; return r ; } } r = adev -> ip_blocks [ i ] . version -> funcs -> hw_fini ( ( void * ) adev ) ; if ( r ) { DRM_DEBUG ( "hw_fini<S2SV_blank>of<S2SV_blank>IP<S2SV_blank>block<S2SV_blank><%s><S2SV_blank>failed<S2SV_blank>%d\\n" , adev -> ip_blocks [ i ] . version -> funcs -> name , r ) ; } adev -> ip_blocks [ i ] . status . hw = false ; } amdgpu_irq_disable_all ( adev ) ; for ( i = adev -> num_ip_blocks - 1 ; i >= 0 ; i -- ) { if ( ! adev -> ip_blocks [ i ] . status . sw ) continue ; <S2SV_StartBug> r = adev -> ip_blocks [ i ] . version -> funcs -> sw_fini ( ( void * ) adev ) ; <S2SV_EndBug> if ( r ) { DRM_DEBUG ( "sw_fini<S2SV_blank>of<S2SV_blank>IP<S2SV_blank>block<S2SV_blank><%s><S2SV_blank>failed<S2SV_blank>%d\\n" , adev -> ip_blocks [ i ] . version -> funcs -> name , r ) ; } adev -> ip_blocks [ i ] . status . sw = false ; adev -> ip_blocks [ i ] . status . valid = false ; } for ( i = adev -> num_ip_blocks - 1 ; i >= 0 ; i -- ) { if ( ! adev -> ip_blocks [ i ] . status . late_initialized ) continue ; if ( adev -> ip_blocks [ i ] . version -> funcs -> late_fini ) adev -> ip_blocks [ i ] . version -> funcs -> late_fini ( ( void * ) adev ) ; adev -> ip_blocks [ i ] . status . late_initialized = false ; } if ( amdgpu_sriov_vf ( adev ) ) if ( amdgpu_virt_release_full_gpu ( adev , false ) ) DRM_ERROR ( "failed<S2SV_blank>to<S2SV_blank>release<S2SV_blank>exclusive<S2SV_blank>mode<S2SV_blank>on<S2SV_blank>fini\\n" ) ; return 0 ; } | <S2SV_ModStart> ) continue ; <S2SV_ModEnd> if ( adev <S2SV_ModStart> ) continue ; if ( adev -> ip_blocks [ i ] . version -> type == AMD_IP_BLOCK_TYPE_GMC ) { amdgpu_free_static_csa ( adev ) ; amdgpu_device_wb_fini ( adev ) ; amdgpu_device_vram_scratch_fini ( adev ) ; } |
1,262 | CWE-000 static void ext4_orphan_cleanup ( struct super_block * sb , struct ext4_super_block * es ) { unsigned int s_flags = sb -> s_flags ; int nr_orphans = 0 , nr_truncates = 0 ; # ifdef CONFIG_QUOTA int i ; # endif if ( ! es -> s_last_orphan ) { jbd_debug ( 4 , "no<S2SV_blank>orphan<S2SV_blank>inodes<S2SV_blank>to<S2SV_blank>clean<S2SV_blank>up\\n" ) ; return ; } if ( bdev_read_only ( sb -> s_bdev ) ) { ext4_msg ( sb , KERN_ERR , "write<S2SV_blank>access<S2SV_blank>" "unavailable,<S2SV_blank>skipping<S2SV_blank>orphan<S2SV_blank>cleanup" ) ; return ; } if ( ! ext4_feature_set_ok ( sb , 0 ) ) { ext4_msg ( sb , KERN_INFO , "Skipping<S2SV_blank>orphan<S2SV_blank>cleanup<S2SV_blank>due<S2SV_blank>to<S2SV_blank>" "unknown<S2SV_blank>ROCOMPAT<S2SV_blank>features" ) ; return ; } if ( EXT4_SB ( sb ) -> s_mount_state & EXT4_ERROR_FS ) { if ( es -> s_last_orphan ) jbd_debug ( 1 , "Errors<S2SV_blank>on<S2SV_blank>filesystem,<S2SV_blank>" "clearing<S2SV_blank>orphan<S2SV_blank>list.\\n" ) ; es -> s_last_orphan = 0 ; jbd_debug ( 1 , "Skipping<S2SV_blank>orphan<S2SV_blank>recovery<S2SV_blank>on<S2SV_blank>fs<S2SV_blank>with<S2SV_blank>errors.\\n" ) ; return ; } if ( s_flags & MS_RDONLY ) { ext4_msg ( sb , KERN_INFO , "orphan<S2SV_blank>cleanup<S2SV_blank>on<S2SV_blank>readonly<S2SV_blank>fs" ) ; sb -> s_flags &= ~ MS_RDONLY ; } # ifdef CONFIG_QUOTA sb -> s_flags |= MS_ACTIVE ; for ( i = 0 ; i < MAXQUOTAS ; i ++ ) { if ( EXT4_SB ( sb ) -> s_qf_names [ i ] ) { int ret = ext4_quota_on_mount ( sb , i ) ; if ( ret < 0 ) ext4_msg ( sb , KERN_ERR , "Cannot<S2SV_blank>turn<S2SV_blank>on<S2SV_blank>journaled<S2SV_blank>" "quota:<S2SV_blank>error<S2SV_blank>%d" , ret ) ; } } # endif while ( es -> s_last_orphan ) { struct inode * inode ; <S2SV_StartBug> inode = ext4_orphan_get ( sb , le32_to_cpu ( es -> s_last_orphan ) ) ; <S2SV_EndBug> if ( IS_ERR ( inode ) ) { es -> s_last_orphan = 0 ; break ; } list_add ( & EXT4_I ( inode ) -> i_orphan , & EXT4_SB ( sb ) -> s_orphan ) ; dquot_initialize ( inode ) ; if ( inode -> i_nlink ) { ext4_msg ( sb , KERN_DEBUG , "%s:<S2SV_blank>truncating<S2SV_blank>inode<S2SV_blank>%lu<S2SV_blank>to<S2SV_blank>%lld<S2SV_blank>bytes" , __func__ , inode -> i_ino , inode -> i_size ) ; jbd_debug ( 2 , "truncating<S2SV_blank>inode<S2SV_blank>%lu<S2SV_blank>to<S2SV_blank>%lld<S2SV_blank>bytes\\n" , inode -> i_ino , inode -> i_size ) ; mutex_lock ( & inode -> i_mutex ) ; ext4_truncate ( inode ) ; mutex_unlock ( & inode -> i_mutex ) ; nr_truncates ++ ; } else { ext4_msg ( sb , KERN_DEBUG , "%s:<S2SV_blank>deleting<S2SV_blank>unreferenced<S2SV_blank>inode<S2SV_blank>%lu" , __func__ , inode -> i_ino ) ; jbd_debug ( 2 , "deleting<S2SV_blank>unreferenced<S2SV_blank>inode<S2SV_blank>%lu\\n" , inode -> i_ino ) ; nr_orphans ++ ; } iput ( inode ) ; } # define PLURAL ( x ) ( x ) , ( ( x ) == 1 ) ? "" : "s" if ( nr_orphans ) ext4_msg ( sb , KERN_INFO , "%d<S2SV_blank>orphan<S2SV_blank>inode%s<S2SV_blank>deleted" , PLURAL ( nr_orphans ) ) ; if ( nr_truncates ) ext4_msg ( sb , KERN_INFO , "%d<S2SV_blank>truncate%s<S2SV_blank>cleaned<S2SV_blank>up" , PLURAL ( nr_truncates ) ) ; # ifdef CONFIG_QUOTA for ( i = 0 ; i < MAXQUOTAS ; i ++ ) { if ( sb_dqopt ( sb ) -> files [ i ] ) dquot_quota_off ( sb , i ) ; } # endif sb -> s_flags = s_flags ; } | <S2SV_ModStart> * inode ; if ( EXT4_SB ( sb ) -> s_mount_state & EXT4_ERROR_FS ) { jbd_debug ( 1 , "Skipping<S2SV_blank>orphan<S2SV_blank>recovery<S2SV_blank>on<S2SV_blank>fs<S2SV_blank>with<S2SV_blank>errors.\\n" ) ; es -> s_last_orphan = 0 ; break ; } |
1,263 | CWE-000 <S2SV_StartBug> void lst_remove_at ( t_list * * lst , int where ) <S2SV_EndBug> { t_list * node ; t_list * prev ; int i ; if ( ( node = * lst ) == NULL ) return ; prev = NULL ; i = 0 ; while ( node ) { <S2SV_StartBug> if ( i == where ) <S2SV_EndBug> { if ( prev ) prev -> next = node -> next ; else <S2SV_StartBug> * lst = node -> next ; <S2SV_EndBug> free ( node ) ; return ; } prev = node ; node = node -> next ; i ++ ; } } | <S2SV_ModStart> lst , int index , void ( * del ) ( void * , size_t s ) <S2SV_ModEnd> ) { t_list <S2SV_ModStart> ( i == index <S2SV_ModEnd> ) { if <S2SV_ModStart> node -> next ; del ( node -> content , node -> content_size ) |
1,264 | CWE-000 static void parse_cmdoption ( int argc , char * argv [ ] ) { int32_t ch ; while ( ( ch = getopt ( argc , argv , "d:f:hm:t:v:" ) ) != - 1 ) { switch ( ch ) { case 'd' : options . device = optarg ; break ; case 'f' : options . cpufamily = optarg ; break ; case 'm' : strlcpy ( options . cpumodel , optarg , sizeof ( options . cpumodel ) ) ; break ; case 't' : if ( ! strcmp ( optarg , "client" ) ) { options . cputype = CLIENT ; } else if ( ! strcmp ( optarg , "server" ) ) { options . cputype = SERVER ; } else { options . cputype = UNKNOWN ; } break ; case 'v' : strlcpy ( options . cpuvendor , optarg , sizeof ( options . cpuvendor ) ) ; break ; case '?' : case 'h' : default : usage ( ) ; } } argc -= optind ; argv += optind ; if ( ! options . device ) { options . device = "/dev/cpuctl0" ; <S2SV_StartBug> if ( ( options . fd = open ( options . device , O_RDWR ) ) == - 1 ) { <S2SV_EndBug> exit_error ( 1 , "ERROR:<S2SV_blank>Couldn\'t<S2SV_blank>open<S2SV_blank>%s:<S2SV_blank>%s\\n" , options . device , strerror ( errno ) ) ; } <S2SV_StartBug> } <S2SV_EndBug> if ( ! options . cpufamily ) { options . cpufamily = getcpufamily ( ) ; } if ( ! options . cputype ) { options . cputype = getcputype ( ) ; } if ( ! strlen ( options . cpuvendor ) ) { getcpuvendor ( options . cpuvendor ) ; } if ( ! strlen ( options . cpumodel ) ) { getcpumodel ( options . cpumodel ) ; } } | <S2SV_ModStart> = "/dev/cpuctl0" ; } <S2SV_ModStart> ) ; } <S2SV_ModEnd> if ( ! |
1,265 | CWE-000 static void release_atom ( zt_gc_t * gc UNUSED , void * pdata UNUSED , void * * v ) { atom * * a = ( atom * * ) v ; <S2SV_StartBug> atoms_freed ++ ; <S2SV_EndBug> free ( * a ) ; * a = NULL ; } | <S2SV_ModStart> ) v ; objects_freed <S2SV_ModEnd> ++ ; free |
1,266 | CWE-000 bool AntAssignChannel ( AntAssignChannelInfoType * psAntSetupInfo_ ) { if ( AntRadioStatusChannel ( psAntSetupInfo_ -> AntChannel ) != ANT_UNCONFIGURED ) { DebugPrintf ( "AntAssignChannel<S2SV_blank>error:<S2SV_blank>channel<S2SV_blank>is<S2SV_blank>not<S2SV_blank>unconfigured\\n\\r" ) ; return FALSE ; } G_au8AntLibConfig [ 4 ] = AntCalculateTxChecksum ( G_au8AntLibConfig ) ; G_au8AntSetNetworkKey [ 2 ] = psAntSetupInfo_ -> AntNetwork ; for ( u8 i = 0 ; i < ANT_NETWORK_NUMBER_BYTES ; i ++ ) { G_au8AntSetNetworkKey [ i + 3 ] = psAntSetupInfo_ -> AntNetworkKey [ i ] ; G_asAntChannelConfiguration [ psAntSetupInfo_ -> AntChannel ] . AntNetworkKey [ i ] = psAntSetupInfo_ -> AntNetworkKey [ i ] ; } G_au8AntSetNetworkKey [ 11 ] = AntCalculateTxChecksum ( G_au8AntSetNetworkKey ) ; G_au8AntAssignChannel [ 2 ] = psAntSetupInfo_ -> AntChannel ; G_au8AntAssignChannel [ 3 ] = psAntSetupInfo_ -> AntChannelType ; G_asAntChannelConfiguration [ psAntSetupInfo_ -> AntChannel ] . AntChannelType = psAntSetupInfo_ -> AntChannelType ; G_au8AntAssignChannel [ 4 ] = psAntSetupInfo_ -> AntNetwork ; G_asAntChannelConfiguration [ psAntSetupInfo_ -> AntChannel ] . AntNetwork = psAntSetupInfo_ -> AntNetwork ; G_au8AntAssignChannel [ 5 ] = AntCalculateTxChecksum ( G_au8AntAssignChannel ) ; G_au8AntSetChannelID [ 2 ] = psAntSetupInfo_ -> AntChannel ; G_au8AntSetChannelID [ 3 ] = psAntSetupInfo_ -> AntDeviceIdLo ; G_asAntChannelConfiguration [ psAntSetupInfo_ -> AntChannel ] . AntDeviceIdLo = psAntSetupInfo_ -> AntDeviceIdLo ; G_au8AntSetChannelID [ 4 ] = psAntSetupInfo_ -> AntDeviceIdHi ; G_asAntChannelConfiguration [ psAntSetupInfo_ -> AntChannel ] . AntDeviceIdHi = psAntSetupInfo_ -> AntDeviceIdHi ; G_au8AntSetChannelID [ 5 ] = psAntSetupInfo_ -> AntDeviceType ; G_asAntChannelConfiguration [ psAntSetupInfo_ -> AntChannel ] . AntDeviceType = psAntSetupInfo_ -> AntDeviceType ; G_au8AntSetChannelID [ 6 ] = psAntSetupInfo_ -> AntTransmissionType ; G_asAntChannelConfiguration [ psAntSetupInfo_ -> AntChannel ] . AntTransmissionType = psAntSetupInfo_ -> AntTransmissionType ; G_au8AntSetChannelID [ 7 ] = AntCalculateTxChecksum ( G_au8AntSetChannelID ) ; G_au8AntSetChannelPeriod [ 2 ] = psAntSetupInfo_ -> AntChannel ; G_au8AntSetChannelPeriod [ 3 ] = psAntSetupInfo_ -> AntChannelPeriodLo ; G_asAntChannelConfiguration [ psAntSetupInfo_ -> AntChannel ] . AntChannelPeriodLo = psAntSetupInfo_ -> AntChannelPeriodLo ; G_au8AntSetChannelPeriod [ 4 ] = psAntSetupInfo_ -> AntChannelPeriodHi ; G_asAntChannelConfiguration [ psAntSetupInfo_ -> AntChannel ] . AntChannelPeriodHi = psAntSetupInfo_ -> AntChannelPeriodHi ; G_au8AntSetChannelPeriod [ 5 ] = AntCalculateTxChecksum ( G_au8AntSetChannelPeriod ) ; G_au8AntSetChannelRFFreq [ 2 ] = psAntSetupInfo_ -> AntChannel ; G_au8AntSetChannelRFFreq [ 3 ] = psAntSetupInfo_ -> AntFrequency ; G_asAntChannelConfiguration [ psAntSetupInfo_ -> AntChannel ] . AntFrequency = psAntSetupInfo_ -> AntFrequency ; G_au8AntSetChannelRFFreq [ 4 ] = AntCalculateTxChecksum ( G_au8AntSetChannelRFFreq ) ; <S2SV_StartBug> G_au8AntSetChannelPower [ 2 ] = psAntSetupInfo_ -> AntChannel ; <S2SV_EndBug> <S2SV_StartBug> G_au8AntSetChannelPower [ 3 ] = psAntSetupInfo_ -> AntTxPower ; <S2SV_EndBug> G_asAntChannelConfiguration [ psAntSetupInfo_ -> AntChannel ] . AntTxPower = psAntSetupInfo_ -> AntTxPower ; G_au8AntSetChannelPower [ 4 ] = AntCalculateTxChecksum ( G_au8AntSetChannelPower ) ; AntApi_u32Timeout = G_u32SystemTime1ms ; AntApi_StateMachine = AntApiSM_AssignChannel ; return TRUE ; } | <S2SV_ModStart> ; G_au8AntSetChannelPower [ 3 ] = psAntSetupInfo_ -> AntTxPower ; G_asAntChannelConfiguration [ psAntSetupInfo_ -> AntChannel ] . AntTxPower = psAntSetupInfo_ -> AntTxPower ; G_au8AntSetChannelPower [ 4 ] = AntCalculateTxChecksum ( G_au8AntSetChannelPower ) ; G_au8AntSetSearchTimeout [ <S2SV_ModStart> -> AntChannel ; G_au8AntSetSearchTimeout [ 3 ] = ANT_INFINITE_SEARCH_TIMEOUT ; G_au8AntSetSearchTimeout [ 4 ] = AntCalculateTxChecksum ( G_au8AntSetSearchTimeout <S2SV_ModEnd> ) ; AntApi_u32Timeout |
1,267 | CWE-000 TEST ( polyfill ) { int numHexagons = H3_EXPORT ( maxPolyfillSize ) ( & sfGeoPolygon , 9 ) ; H3Index * hexagons = calloc ( numHexagons , sizeof ( H3Index ) ) ; H3_EXPORT ( polyfill ) ( & sfGeoPolygon , 9 , hexagons ) ; <S2SV_StartBug> int actualNumHexagons = 0 ; <S2SV_EndBug> for ( int i = 0 ; i < numHexagons ; i ++ ) { if ( hexagons [ i ] != 0 ) { actualNumHexagons ++ ; } } t_assert ( actualNumHexagons == 1253 , "got<S2SV_blank>expected<S2SV_blank>polyfill<S2SV_blank>size" ) ; free ( hexagons ) ; } | <S2SV_ModStart> int actualNumHexagons = countActualHexagons ( hexagons , numHexagons ) ; <S2SV_ModEnd> t_assert ( actualNumHexagons |
1,268 | CWE-000 static void ipr_process_error ( struct ipr_cmnd * ipr_cmd ) { struct ipr_ioa_cfg * ioa_cfg = ipr_cmd -> ioa_cfg ; struct ipr_hostrcb * hostrcb = ipr_cmd -> u . hostrcb ; u32 ioasc = be32_to_cpu ( ipr_cmd -> s . ioasa . hdr . ioasc ) ; u32 fd_ioasc ; <S2SV_StartBug> char * envp [ ] = { "ASYNC_ERR_LOG=1" , NULL } ; <S2SV_EndBug> if ( ioa_cfg -> sis64 ) fd_ioasc = be32_to_cpu ( hostrcb -> hcam . u . error64 . fd_ioasc ) ; else fd_ioasc = be32_to_cpu ( hostrcb -> hcam . u . error . fd_ioasc ) ; list_del_init ( & hostrcb -> queue ) ; list_add_tail ( & ipr_cmd -> queue , & ipr_cmd -> hrrq -> hrrq_free_q ) ; if ( ! ioasc ) { ipr_handle_log_data ( ioa_cfg , hostrcb ) ; if ( fd_ioasc == IPR_IOASC_NR_IOA_RESET_REQUIRED ) ipr_initiate_ioa_reset ( ioa_cfg , IPR_SHUTDOWN_ABBREV ) ; } else if ( ioasc != IPR_IOASC_IOA_WAS_RESET && ioasc != IPR_IOASC_ABORTED_CMD_TERM_BY_HOST ) { dev_err ( & ioa_cfg -> pdev -> dev , "Host<S2SV_blank>RCB<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>IOASC:<S2SV_blank>0x%08X\\n" , ioasc ) ; } list_add_tail ( & hostrcb -> queue , & ioa_cfg -> hostrcb_report_q ) ; <S2SV_StartBug> hostrcb = ipr_get_free_hostrcb ( ioa_cfg ) ; <S2SV_EndBug> kobject_uevent_env ( & ioa_cfg -> host -> shost_dev . kobj , KOBJ_CHANGE , envp ) ; ipr_send_hcam ( ioa_cfg , IPR_HCAM_CDB_OP_CODE_LOG_DATA , hostrcb ) ; } | <S2SV_ModStart> u32 fd_ioasc ; <S2SV_ModEnd> if ( ioa_cfg <S2SV_ModStart> hostrcb_report_q ) ; schedule_work ( & ioa_cfg -> work_q ) ; <S2SV_ModStart> ipr_get_free_hostrcb ( ioa_cfg <S2SV_ModEnd> ) ; ipr_send_hcam |
1,269 | CWE-000 capture_metrics_t * capture_metrics_init ( bed_t * target_design ) { capture_metrics_t * cm = calloc ( 1 , sizeof ( capture_metrics_t ) ) ; <S2SV_StartBug> cm -> t_target_cov = target_coverage_init ( target_design -> num_chroms ) ; <S2SV_EndBug> cm -> t_target_cov -> chrom_names = target_design -> chrom_names ; for ( int cur_chrom = 0 ; cur_chrom < target_design -> num_chroms ; cur_chrom ++ ) { bed_chrom_t * cur_chrom_bed = target_design -> chroms [ cur_chrom ] ; cm -> t_target_cov -> chroms [ cur_chrom ] = target_coverage_block_init ( cur_chrom_bed -> num_targets ) ; for ( int chrom_target = 0 ; chrom_target < cur_chrom_bed -> num_targets ; chrom_target ++ ) { cm -> t_target_cov -> chroms [ cur_chrom ] -> start_pos [ chrom_target ] = cur_chrom_bed -> start_pos [ chrom_target ] ; cm -> t_target_cov -> chroms [ cur_chrom ] -> end_pos [ chrom_target ] = cur_chrom_bed -> end_pos [ chrom_target ] ; size_t span = cur_chrom_bed -> end_pos [ chrom_target ] - cur_chrom_bed -> start_pos [ chrom_target ] ; cm -> t_target_cov -> chroms [ cur_chrom ] -> base_coverage [ chrom_target ] = calloc ( span , sizeof ( uint32_t ) ) ; } } die_on_alloc_fail ( cm ) ; return cm ; } | <S2SV_ModStart> ; cm -> t_total = target_design -> num_targets ; cm -> |
1,270 | CWE-000 static int remoteConnectNetworkEventRegisterAny ( virConnectPtr conn , virNetworkPtr net , int eventID , virConnectNetworkEventGenericCallback callback , void * opaque , virFreeCallback freecb ) { int rv = - 1 ; struct private_data * priv = conn -> privateData ; remote_connect_network_event_register_any_args args ; remote_connect_network_event_register_any_ret ret ; int callbackID ; int count ; remote_nonnull_network network ; remoteDriverLock ( priv ) ; if ( ( count = virNetworkEventStateRegisterClient ( conn , priv -> eventState , net , eventID , callback , opaque , freecb , & callbackID ) ) < 0 ) goto done ; if ( count == 1 ) { args . eventID = eventID ; if ( net ) { make_nonnull_network ( & network , net ) ; args . net = & network ; } else { args . net = NULL ; } memset ( & ret , 0 , sizeof ( ret ) ) ; if ( call ( conn , priv , 0 , REMOTE_PROC_CONNECT_NETWORK_EVENT_REGISTER_ANY , ( xdrproc_t ) xdr_remote_connect_network_event_register_any_args , ( char * ) & args , ( xdrproc_t ) xdr_remote_connect_network_event_register_any_ret , ( char * ) & ret ) == - 1 ) { virObjectEventStateDeregisterID ( conn , priv -> eventState , <S2SV_StartBug> callbackID ) ; <S2SV_EndBug> goto done ; } virObjectEventStateSetRemote ( conn , priv -> eventState , callbackID , ret . callbackID ) ; } rv = callbackID ; done : remoteDriverUnlock ( priv ) ; return rv ; } | <S2SV_ModStart> eventState , callbackID , false |
1,271 | CWE-000 void nd6_dad_stop ( struct ifaddr * ifa ) { struct dadq * dp ; if ( ! dad_init ) return ; mutex_enter ( & nd6_dad_lock ) ; dp = nd6_dad_find ( ifa ) ; if ( dp == NULL ) { mutex_exit ( & nd6_dad_lock ) ; return ; } <S2SV_StartBug> TAILQ_REMOVE ( & dadq , dp , dad_list ) ; <S2SV_EndBug> <S2SV_StartBug> mutex_exit ( & nd6_dad_lock ) ; <S2SV_EndBug> nd6_dad_stoptimer ( dp ) ; kmem_intr_free ( dp , sizeof ( * dp ) ) ; ifafree ( ifa ) ; } | <S2SV_ModStart> return ; } nd6_dad_destroytimer ( dp <S2SV_ModEnd> ) ; mutex_exit <S2SV_ModStart> ( & nd6_dad_lock <S2SV_ModEnd> ) ; ifafree |
1,272 | CWE-000 void save_main_config ( void ) { char str [ 256 ] ; raine_push_config_state ( ) ; <S2SV_StartBug> sprintf ( str , "%sconfig/%s" , dir_cfg . exe_path , dir_cfg . config_file ) ; <S2SV_EndBug> raine_set_config_file ( str ) ; raine_pop_config_state ( ) ; } | <S2SV_ModStart> ( ) ; snprintf ( str , 256 <S2SV_ModEnd> , "%sconfig/%s" , |
1,273 | CWE-000 int remove_directory ( char * dirname ) { DIR * dp ; struct dirent * ent ; char buf [ PATH_MAX ] ; int saved_errno = 0 ; int ret = 0 ; dp = opendir ( dirname ) ; if ( dp == NULL ) return - 1 ; pr_dbg ( "removing<S2SV_blank>%s<S2SV_blank>directory\\n" , dirname ) ; while ( ( ent = readdir ( dp ) ) != NULL ) { <S2SV_StartBug> if ( ent -> d_name [ 0 ] == '.' ) <S2SV_EndBug> continue ; snprintf ( buf , sizeof ( buf ) , "%s/%s" , dirname , ent -> d_name ) ; if ( unlink ( buf ) < 0 ) { saved_errno = errno ; ret = - 1 ; break ; } } closedir ( dp ) ; if ( rmdir ( dirname ) < 0 && ret == 0 ) ret = - 1 ; else errno = saved_errno ; return ret ; } | <S2SV_ModStart> { if ( ! strcmp ( <S2SV_ModStart> ent -> d_name , "." ) || ! strcmp ( ent -> d_name , ".." ) <S2SV_ModEnd> ) continue ; |
1,274 | CWE-000 int rtnl_tc_msg_build ( struct rtnl_tc * tc , int type , int flags , struct nl_msg * * result ) { struct nl_msg * msg ; struct rtnl_tc_ops * ops ; struct tcmsg tchdr = { . tcm_family = AF_UNSPEC , . tcm_ifindex = tc -> tc_ifindex , . tcm_handle = tc -> tc_handle , . tcm_parent = tc -> tc_parent , } ; int err = - NLE_MSGSIZE ; msg = nlmsg_alloc_simple ( type , flags ) ; if ( ! msg ) return - NLE_NOMEM ; if ( nlmsg_append ( msg , & tchdr , sizeof ( tchdr ) , NLMSG_ALIGNTO ) < 0 ) goto nla_put_failure ; if ( tc -> ce_mask & TCA_ATTR_KIND ) NLA_PUT_STRING ( msg , TCA_KIND , tc -> tc_kind ) ; ops = rtnl_tc_get_ops ( tc ) ; if ( ops && ( ops -> to_msg_fill || ops -> to_msg_fill_raw ) ) { struct nlattr * opts ; void * data = rtnl_tc_data ( tc ) ; if ( ops -> to_msg_fill ) { if ( ! ( opts = nla_nest_start ( msg , TCA_OPTIONS ) ) ) goto nla_put_failure ; if ( ( err = ops -> to_msg_fill ( tc , data , msg ) ) < 0 ) goto nla_put_failure ; <S2SV_StartBug> nla_nest_end ( msg , opts ) ; <S2SV_EndBug> } else if ( ( err = ops -> to_msg_fill_raw ( tc , data , msg ) ) < 0 ) goto nla_put_failure ; } * result = msg ; return 0 ; nla_put_failure : nlmsg_free ( msg ) ; return err ; } | <S2SV_ModStart> goto nla_put_failure ; if ( strcmp ( "cgroup" , tc -> tc_kind ) ) nla_nest_end ( msg , opts ) ; else nla_nest_end_keep_empty <S2SV_ModEnd> ( msg , |
1,275 | CWE-000 enum ipa_client_type ipa_get_client_mapping ( int pipe_idx ) { <S2SV_StartBug> if ( pipe_idx >= IPA_CLIENT_MAX || pipe_idx < 0 ) { <S2SV_EndBug> IPAERR ( "Bad<S2SV_blank>pipe<S2SV_blank>index!\\n" ) ; return - EINVAL ; } return ipa_ctx -> ep [ pipe_idx ] . client ; } | <S2SV_ModStart> ( pipe_idx >= IPA_NUM_PIPES <S2SV_ModEnd> || pipe_idx < |
1,276 | CWE-000 int initSpcap ( spcap * restrict spcapf , nvmeRaid * restrict raid , metaFile * restrict file ) { int i ; spcapf -> raid = raid ; spcapf -> file = file ; for ( i = 0 ; i < raid -> numdisks ; i ++ ) { spcapf -> currPtr [ i ] = spcapf -> buffs [ i ] = spdk_zmalloc ( BUFFSIZE , SUPERSECTORLENGTH , NULL ) ; if ( ! spcapf -> currPtr [ i ] ) return - 1 ; spcapf -> dataWrote [ i ] = 0 ; <S2SV_StartBug> spcapf -> curlba [ i ] = super_getdisklba ( raid , file -> startBlock + i ) ; <S2SV_EndBug> } return 0 ; } | <S2SV_ModStart> startBlock + i * SUPERSECTORNUM |
1,277 | CWE-000 static void resolve_promise_with_null ( napi_env env , napi_deferred deferred ) { napi_value null ; <S2SV_StartBug> napi_get_null ( env , & null ) ; <S2SV_EndBug> <S2SV_StartBug> napi_handle_scope handle_scope ; <S2SV_EndBug> <S2SV_StartBug> napi_open_handle_scope ( env , & handle_scope ) ; <S2SV_EndBug> <S2SV_StartBug> napi_resolve_deferred ( env , deferred , null ) ; <S2SV_EndBug> <S2SV_StartBug> napi_close_handle_scope ( env , handle_scope ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> napi_value null ; napi_status status ; status = <S2SV_ModStart> null ) ; CHECK_STATUS_UNCAUGHT ( status , napi_get_null , ) ; <S2SV_ModStart> napi_handle_scope handle_scope ; status = <S2SV_ModStart> handle_scope ) ; CHECK_STATUS_UNCAUGHT ( status , napi_open_handle_scope , ) ; status = <S2SV_ModStart> null ) ; CHECK_STATUS_UNCAUGHT ( status , napi_resolve_deferred , ) ; status = <S2SV_ModStart> handle_scope ) ; CHECK_STATUS_UNCAUGHT ( status , napi_close_handle_scope , ) ; |
1,278 | CWE-000 int get_message ( int fd , char * buf , fd_set * master , login_helper * h ) { int length = 0 , nbytes ; while ( 1 ) { <S2SV_StartBug> nbytes = get_packet ( fd , buf + length , master , h ) ; <S2SV_EndBug> if ( nbytes == 0 ) { break ; } else if ( buf [ length + nbytes ] = '\\n' ) { <S2SV_StartBug> break ; <S2SV_EndBug> } else { length += nbytes ; } } return length ; } | <S2SV_ModStart> fd , buf <S2SV_ModEnd> , master , <S2SV_ModStart> '\\n' ) { length = length + nbytes ; |
1,279 | CWE-000 STATIC void _xfs_buf_ioapply ( struct xfs_buf * bp ) { struct blk_plug plug ; int op ; int op_flags = 0 ; int offset ; int size ; int i ; bp -> b_error = 0 ; if ( ! bp -> b_ioend_wq ) bp -> b_ioend_wq = bp -> b_target -> bt_mount -> m_buf_workqueue ; if ( bp -> b_flags & XBF_WRITE ) { op = REQ_OP_WRITE ; if ( bp -> b_flags & XBF_SYNCIO ) op_flags = REQ_SYNC ; if ( bp -> b_flags & XBF_FUA ) op_flags |= REQ_FUA ; if ( bp -> b_flags & XBF_FLUSH ) op_flags |= REQ_PREFLUSH ; if ( bp -> b_ops ) { bp -> b_ops -> verify_write ( bp ) ; if ( bp -> b_error ) { xfs_force_shutdown ( bp -> b_target -> bt_mount , SHUTDOWN_CORRUPT_INCORE ) ; return ; } } else if ( bp -> b_bn != XFS_BUF_DADDR_NULL ) { struct xfs_mount * mp = bp -> b_target -> bt_mount ; if ( xfs_sb_version_hascrc ( & mp -> m_sb ) ) { xfs_warn ( mp , <S2SV_StartBug> "%s:<S2SV_blank>no<S2SV_blank>ops<S2SV_blank>on<S2SV_blank>block<S2SV_blank>0x%llx/0x%x" , <S2SV_EndBug> __func__ , bp -> b_bn , bp -> b_length ) ; xfs_hex_dump ( bp -> b_addr , XFS_CORRUPTION_DUMP_LEN ) ; dump_stack ( ) ; } } } else if ( bp -> b_flags & XBF_READ_AHEAD ) { op = REQ_OP_READ ; op_flags = REQ_RAHEAD ; } else { op = REQ_OP_READ ; } op_flags |= REQ_META ; offset = bp -> b_offset ; size = BBTOB ( bp -> b_io_length ) ; blk_start_plug ( & plug ) ; for ( i = 0 ; i < bp -> b_map_count ; i ++ ) { xfs_buf_ioapply_map ( bp , i , & offset , & size , op , op_flags ) ; if ( bp -> b_error ) break ; if ( size <= 0 ) break ; } blk_finish_plug ( & plug ) ; } | <S2SV_ModStart> ( mp , "%s:<S2SV_blank>no<S2SV_blank>buf<S2SV_blank>ops<S2SV_blank>on<S2SV_blank>daddr<S2SV_blank>0x%llx<S2SV_blank>len<S2SV_blank>%d" <S2SV_ModEnd> , __func__ , |
1,280 | CWE-000 static int lfs_commit_movescan ( lfs_t * lfs , void * p , lfs_entry_t entry ) { struct lfs_commit_move * move = p ; if ( lfs_tag_type ( entry . tag ) == LFS_TYPE_DELETE && lfs_tag_id ( entry . tag ) <= move -> id . from ) { <S2SV_StartBug> move -> id . from += 1 ; <S2SV_EndBug> return 0 ; } if ( lfs_tag_id ( entry . tag ) != move -> id . from ) { return 0 ; } int err = lfs_dir_get ( lfs , & ( lfs_dir_t ) { . pair [ 0 ] = move -> commit -> block , . off = move -> commit -> off , . etag = move -> commit -> ptag , . stop_at_commit = true } , lfs_tag_type ( entry . tag ) & 0x100 ? 0x7ffff000 : 0x7c1ff000 , & ( lfs_entry_t ) { lfs_mktag ( lfs_tag_type ( entry . tag ) , move -> id . to , 0 ) } ) ; if ( err && err != LFS_ERR_NOENT ) { return err ; } if ( err != LFS_ERR_NOENT ) { return 0 ; } entry . tag = lfs_mktag ( 0 , move -> id . to , 0 ) | ( entry . tag & 0xffe00fff ) ; return lfs_commit_commit ( lfs , move -> commit , entry ) ; } | <S2SV_ModStart> += 1 ; return 0 ; } if ( lfs_tag_type ( entry . tag ) == LFS_TYPE_MOVE ) { |
1,281 | CWE-000 apr_status_t h2_conn_io_write ( h2_conn_io * io , const char * data , size_t length ) { apr_status_t status = APR_SUCCESS ; apr_size_t remain ; if ( io -> buffer_output ) { while ( length > 0 ) { remain = assure_scratch_space ( io ) ; if ( remain >= length ) { # if LOG_SCRATCH ap_log_cerror ( APLOG_MARK , APLOG_DEBUG , 0 , io -> c , APLOGNO ( 03389 ) "h2_conn_io(%ld):<S2SV_blank>write_to_scratch(%ld)" , io -> c -> id , ( long ) length ) ; # endif memcpy ( io -> scratch + io -> slen , data , length ) ; io -> slen += length ; length = 0 ; } else { # if LOG_SCRATCH ap_log_cerror ( APLOG_MARK , APLOG_DEBUG , 0 , io -> c , APLOGNO ( 03390 ) "h2_conn_io(%ld):<S2SV_blank>write_to_scratch(%ld)" , io -> c -> id , ( long ) remain ) ; # endif memcpy ( io -> scratch + io -> slen , data , remain ) ; io -> slen += remain ; data += remain ; length -= remain ; } } } else { status = apr_brigade_write ( io -> output , NULL , NULL , data , length ) ; } <S2SV_StartBug> return status ; <S2SV_EndBug> } | <S2SV_ModStart> ) ; } io -> needs_flush = - 1 ; |
1,282 | CWE-000 bool param_init ( void ) { TRACE ( "initialize<S2SV_blank>parameter...\\r\\n" ) ; if ( fm_init ( ) ) { if ( ! fm_read ( PARAM_START_ADDRESS , ( uint8_t * ) & flash_map , sizeof ( flash_map_t ) ) ) { return FALSE ; } param_setted = ( 0 == memcmp ( flash_map . flag , PARAM_SETTED_FLAG , PARAM_SETTED_FLAG_LEN ) ) ; <S2SV_StartBug> flash_map . parameters . bt_name [ BT_NAME_MAX_LEN ] = '\\0' ; <S2SV_EndBug> TRACE ( "parameter<S2SV_blank>status(%d)\\r\\n" , param_setted ) ; return TRUE ; } return FALSE ; } | <S2SV_ModStart> ) ) ; # ifdef __MASTER <S2SV_ModStart> = '\\0' ; # endif |
1,283 | CWE-000 static void ngx_stream_proxy_process_connection ( ngx_event_t * ev , ngx_uint_t from_upstream ) { ngx_connection_t * c , * pc ; ngx_stream_session_t * s ; ngx_stream_upstream_t * u ; ngx_stream_proxy_srv_conf_t * pscf ; c = ev -> data ; s = c -> data ; <S2SV_StartBug> u = s -> upstream ; <S2SV_EndBug> c = s -> connection ; pc = u -> peer . connection ; pscf = ngx_stream_get_module_srv_conf ( s , ngx_stream_proxy_module ) ; if ( ev -> timedout ) { ev -> timedout = 0 ; if ( ev -> delayed ) { ev -> delayed = 0 ; if ( ! ev -> ready ) { if ( ngx_handle_read_event ( ev , 0 ) != NGX_OK ) { ngx_stream_proxy_finalize ( s , NGX_STREAM_INTERNAL_SERVER_ERROR ) ; return ; } if ( u -> connected && ! c -> read -> delayed && ! pc -> read -> delayed ) { ngx_add_timer ( c -> write , pscf -> timeout ) ; } return ; } } else { if ( s -> connection -> type == SOCK_DGRAM ) { if ( pscf -> responses == NGX_MAX_INT32_VALUE ) { pc -> read -> ready = 0 ; pc -> read -> eof = 1 ; ngx_stream_proxy_process ( s , 1 , 0 ) ; return ; } ngx_connection_error ( pc , NGX_ETIMEDOUT , "upstream<S2SV_blank>timed<S2SV_blank>out" ) ; if ( u -> received == 0 ) { ngx_stream_proxy_next_upstream ( s ) ; return ; } } else { ngx_connection_error ( c , NGX_ETIMEDOUT , "connection<S2SV_blank>timed<S2SV_blank>out" ) ; } ngx_stream_proxy_finalize ( s , NGX_STREAM_OK ) ; return ; } } else if ( ev -> delayed ) { ngx_log_debug0 ( NGX_LOG_DEBUG_STREAM , c -> log , 0 , "stream<S2SV_blank>connection<S2SV_blank>delayed" ) ; if ( ngx_handle_read_event ( ev , 0 ) != NGX_OK ) { ngx_stream_proxy_finalize ( s , NGX_STREAM_INTERNAL_SERVER_ERROR ) ; } return ; } if ( from_upstream && ! u -> connected ) { return ; } ngx_stream_proxy_process ( s , from_upstream , ev -> write ) ; } | <S2SV_ModStart> -> upstream ; if ( c -> close ) { ngx_log_error ( NGX_LOG_INFO , c -> log , 0 , "shutdown<S2SV_blank>timeout" ) ; ngx_stream_proxy_finalize ( s , NGX_STREAM_OK ) ; return ; } |
1,284 | CWE-000 static void atexit_callfuncs ( void ) { PyObject * exc_type = NULL , * exc_value , * exc_tb , * r ; atexit_callback * cb ; PyObject * module ; atexitmodule_state * modstate ; int i ; module = PyState_FindModule ( & atexitmodule ) ; if ( module == NULL ) return ; modstate = GET_ATEXIT_STATE ( module ) ; if ( modstate -> ncallbacks == 0 ) return ; for ( i = modstate -> ncallbacks - 1 ; i >= 0 ; i -- ) { cb = modstate -> atexit_callbacks [ i ] ; if ( cb == NULL ) continue ; r = PyObject_Call ( cb -> func , cb -> args , cb -> kwargs ) ; Py_XDECREF ( r ) ; if ( r == NULL ) { if ( exc_type ) { Py_DECREF ( exc_type ) ; Py_XDECREF ( exc_value ) ; Py_XDECREF ( exc_tb ) ; } PyErr_Fetch ( & exc_type , & exc_value , & exc_tb ) ; <S2SV_StartBug> if ( ! PyErr_GivenExceptionMatches ( exc_type , PyExc_SystemExit ) ) { <S2SV_EndBug> PySys_WriteStderr ( "Error<S2SV_blank>in<S2SV_blank>atexit._run_exitfuncs:\\n" ) ; PyErr_NormalizeException ( & exc_type , & exc_value , & exc_tb ) ; PyErr_Display ( exc_type , exc_value , exc_tb ) ; } } } atexit_cleanup ( modstate ) ; if ( exc_type ) PyErr_Restore ( exc_type , exc_value , exc_tb ) ; } | <S2SV_ModStart> ; if ( 1 <S2SV_ModEnd> ) { PySys_WriteStderr |
1,285 | CWE-000 static void <S2SV_StartBug> catch_rethrow_command ( char * arg , int from_tty , <S2SV_EndBug> struct cmd_list_element * command ) { int tempflag = get_cmd_context ( command ) == CATCH_TEMPORARY ; catch_exception_command_1 ( EX_EVENT_RETHROW , arg , tempflag , from_tty ) ; } | <S2SV_ModStart> void catch_rethrow_command ( const |
1,286 | CWE-000 void addEdge ( struct node * n1 , struct node * n2 ) { <S2SV_StartBug> n1 -> connected [ n1 -> counter ] = n2 ; <S2SV_EndBug> n1 -> counter ++ ; <S2SV_StartBug> n2 -> connected [ n2 -> counter ] = n1 ; <S2SV_EndBug> n2 -> counter ++ ; } | <S2SV_ModStart> n2 ) { matrix <S2SV_ModEnd> [ n1 -> <S2SV_ModStart> [ n1 -> x ] [ n1 -> y ] <S2SV_ModEnd> [ n2 -> <S2SV_ModStart> [ n2 -> x ] [ n2 -> y ] = 1 ; matrix [ n2 -> x ] [ n2 -> y ] [ n1 -> x ] [ n1 -> y ] = 1 <S2SV_ModEnd> ; } <S2SV_null> |
1,287 | CWE-000 <S2SV_StartBug> static PHP_METHOD ( Phalcon_Cache_Frontend_Data , afterRetrieve ) { <S2SV_EndBug> zend_long ZEPHIR_LAST_CALL_STATUS ; zval * data , data_sub ; zval * this_ptr = getThis ( ) ; ZVAL_UNDEF ( & data_sub ) ; ZEPHIR_MM_GROW ( ) ; <S2SV_StartBug> zephir_fetch_params ( 1 , 1 , 0 , & data ) ; <S2SV_EndBug> if ( zephir_is_numeric ( data ) ) { RETVAL_ZVAL ( data , 1 , 0 ) ; <S2SV_StartBug> RETURN_MM ( ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> if ( ZEPHIR_IS_EMPTY ( data ) ) { RETVAL_ZVAL ( data , 1 , 0 ) ; RETURN_MM ( ) ; } <S2SV_StartBug> ZEPHIR_RETURN_CALL_FUNCTION ( "unserialize" , NULL , 63 , data ) ; <S2SV_EndBug> zephir_check_call_status ( ) ; RETURN_MM ( ) ; } | <S2SV_ModStart> static PHP_METHOD ( Phalcon_Mvc_Collection , serialize ) { zval * _0 = NULL ; zend_long ZEPHIR_LAST_CALL_STATUS <S2SV_ModEnd> ; ZEPHIR_MM_GROW ( <S2SV_ModStart> ( ) ; ZEPHIR_CALL_METHOD ( & _0 , this_ptr , "toarray" , NULL <S2SV_ModEnd> , 0 ) <S2SV_ModStart> 0 ) ; zephir_check_call_status <S2SV_ModEnd> ( ) ; <S2SV_ModStart> ( ) ; ZEPHIR_RETURN_CALL_FUNCTION ( "serialize" <S2SV_ModEnd> , NULL , <S2SV_ModStart> , NULL , 68 , _0 <S2SV_ModEnd> ) ; zephir_check_call_status |
1,288 | CWE-000 static int unicode_decode_call_errorhandler_writer ( const char * errors , PyObject * * errorHandler , const char * encoding , const char * reason , const char * * input , const char * * inend , Py_ssize_t * startinpos , Py_ssize_t * endinpos , PyObject * * exceptionObject , const char * * inptr , _PyUnicodeWriter * writer ) { static const char * argparse = "Un;decoding<S2SV_blank>error<S2SV_blank>handler<S2SV_blank>must<S2SV_blank>return<S2SV_blank>(str,<S2SV_blank>int)<S2SV_blank>tuple" ; PyObject * restuple = NULL ; PyObject * repunicode = NULL ; Py_ssize_t insize ; Py_ssize_t newpos ; Py_ssize_t replen ; Py_ssize_t remain ; PyObject * inputobj = NULL ; int need_to_grow = 0 ; const char * new_inptr ; if ( * errorHandler == NULL ) { * errorHandler = PyCodec_LookupError ( errors ) ; if ( * errorHandler == NULL ) goto onError ; } make_decode_exception ( exceptionObject , encoding , * input , * inend - * input , * startinpos , * endinpos , reason ) ; if ( * exceptionObject == NULL ) goto onError ; restuple = PyObject_CallFunctionObjArgs ( * errorHandler , * exceptionObject , NULL ) ; if ( restuple == NULL ) goto onError ; if ( ! PyTuple_Check ( restuple ) ) { PyErr_SetString ( PyExc_TypeError , & argparse [ 3 ] ) ; goto onError ; } if ( ! PyArg_ParseTuple ( restuple , argparse , & repunicode , & newpos ) ) goto onError ; inputobj = PyUnicodeDecodeError_GetObject ( * exceptionObject ) ; if ( ! inputobj ) goto onError ; remain = * inend - * input - * endinpos ; * input = PyBytes_AS_STRING ( inputobj ) ; insize = PyBytes_GET_SIZE ( inputobj ) ; * inend = * input + insize ; Py_DECREF ( inputobj ) ; if ( newpos < 0 ) newpos = insize + newpos ; if ( newpos < 0 || newpos > insize ) { PyErr_Format ( PyExc_IndexError , "position<S2SV_blank>%zd<S2SV_blank>from<S2SV_blank>error<S2SV_blank>handler<S2SV_blank>out<S2SV_blank>of<S2SV_blank>bounds" , newpos ) ; goto onError ; } replen = PyUnicode_GET_LENGTH ( repunicode ) ; if ( replen > 1 ) { writer -> min_length += replen - 1 ; need_to_grow = 1 ; } new_inptr = * input + newpos ; if ( * inend - new_inptr > remain ) { writer -> min_length += * inend - new_inptr - remain ; need_to_grow = 1 ; } if ( need_to_grow ) { writer -> overallocate = 1 ; <S2SV_StartBug> if ( _PyUnicodeWriter_Prepare ( writer , writer -> min_length , <S2SV_EndBug> PyUnicode_MAX_CHAR_VALUE ( repunicode ) ) == - 1 ) goto onError ; } if ( _PyUnicodeWriter_WriteStr ( writer , repunicode ) == - 1 ) goto onError ; * endinpos = newpos ; * inptr = new_inptr ; Py_DECREF ( restuple ) ; return 0 ; onError : Py_XDECREF ( restuple ) ; return - 1 ; } | <S2SV_ModStart> writer -> min_length - writer -> pos |
1,289 | CWE-000 static void dwc_initialize_chan_dw ( struct dw_dma_chan * dwc ) <S2SV_StartBug> { <S2SV_EndBug> u32 cfghi = DWC_CFGH_FIFO_MODE ; u32 cfglo = DWC_CFGL_CH_PRIOR ( dwc -> priority ) ; bool hs_polarity = dwc -> dws . hs_polarity ; cfghi |= DWC_CFGH_DST_PER ( dwc -> dws . dst_id ) ; cfghi |= DWC_CFGH_SRC_PER ( dwc -> dws . src_id ) ; <S2SV_StartBug> cfglo |= hs_polarity ? DWC_CFGL_HS_DST_POL | DWC_CFGL_HS_SRC_POL : 0 ; <S2SV_EndBug> channel_writel ( dwc , CFG_LO , cfglo ) ; channel_writel ( dwc , CFG_HI , cfghi ) ; } | <S2SV_ModStart> dwc ) { struct dw_dma * dw = to_dw_dma ( dwc -> chan . device ) ; <S2SV_ModStart> src_id ) ; cfghi |= DWC_CFGH_PROTCTL ( dw -> pdata -> protctl ) ; |
1,290 | CWE-000 static void # endif CitusCopyDestReceiverReceive ( TupleTableSlot * slot , DestReceiver * dest ) { CitusCopyDestReceiver * copyDest = ( CitusCopyDestReceiver * ) dest ; <S2SV_StartBug> DistTableCacheEntry * tableMetadata = copyDest -> tableMetadata ; <S2SV_EndBug> char partitionMethod = tableMetadata -> partitionMethod ; int partitionColumnIndex = copyDest -> partitionColumnIndex ; TupleDesc tupleDescriptor = copyDest -> tupleDescriptor ; <S2SV_StartBug> CopyStmt * copyStatement = copyDest -> copyStatement ; <S2SV_EndBug> int shardCount = tableMetadata -> shardIntervalArrayLength ; ShardInterval * * shardIntervalCache = tableMetadata -> sortedShardIntervalArray ; bool useBinarySearch = copyDest -> useBinarySearch ; FmgrInfo * hashFunction = tableMetadata -> hashFunction ; FmgrInfo * compareFunction = tableMetadata -> shardIntervalCompareFunction ; HTAB * shardConnectionHash = copyDest -> shardConnectionHash ; CopyOutState copyOutState = copyDest -> copyOutState ; FmgrInfo * columnOutputFunctions = copyDest -> columnOutputFunctions ; bool stopOnFailure = copyDest -> stopOnFailure ; Datum * columnValues = NULL ; bool * columnNulls = NULL ; Datum partitionColumnValue = 0 ; ShardInterval * shardInterval = NULL ; int64 shardId = 0 ; bool shardConnectionsFound = false ; ShardConnections * shardConnections = NULL ; EState * executorState = copyDest -> executorState ; MemoryContext executorTupleContext = GetPerTupleMemoryContext ( executorState ) ; MemoryContext oldContext = MemoryContextSwitchTo ( executorTupleContext ) ; slot_getallattrs ( slot ) ; columnValues = slot -> tts_values ; columnNulls = slot -> tts_isnull ; if ( partitionColumnIndex >= 0 ) { if ( columnNulls [ partitionColumnIndex ] ) { Oid relationId = copyDest -> distributedRelationId ; char * relationName = get_rel_name ( relationId ) ; Oid schemaOid = get_rel_namespace ( relationId ) ; char * schemaName = get_namespace_name ( schemaOid ) ; char * qualifiedTableName = quote_qualified_identifier ( schemaName , relationName ) ; ereport ( ERROR , ( errcode ( ERRCODE_NULL_VALUE_NOT_ALLOWED ) , errmsg ( "the<S2SV_blank>partition<S2SV_blank>column<S2SV_blank>of<S2SV_blank>table<S2SV_blank>%s<S2SV_blank>should<S2SV_blank>have<S2SV_blank>a<S2SV_blank>value" , qualifiedTableName ) ) ) ; } partitionColumnValue = columnValues [ partitionColumnIndex ] ; } <S2SV_StartBug> shardInterval = FindShardInterval ( partitionColumnValue , shardIntervalCache , <S2SV_EndBug> shardCount , partitionMethod , compareFunction , hashFunction , useBinarySearch ) ; if ( shardInterval == NULL ) { ereport ( ERROR , ( errcode ( ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE ) , errmsg ( "could<S2SV_blank>not<S2SV_blank>find<S2SV_blank>shard<S2SV_blank>for<S2SV_blank>partition<S2SV_blank>column<S2SV_blank>" "value" ) ) ) ; } shardId = shardInterval -> shardId ; MemoryContextSwitchTo ( copyDest -> memoryContext ) ; shardConnections = GetShardHashConnections ( shardConnectionHash , shardId , & shardConnectionsFound ) ; if ( ! shardConnectionsFound ) { OpenCopyConnections ( copyStatement , shardConnections , stopOnFailure , copyOutState -> binary ) ; if ( copyOutState -> binary ) { SendCopyBinaryHeaders ( copyOutState , shardId , shardConnections -> connectionList ) ; } } resetStringInfo ( copyOutState -> fe_msgbuf ) ; AppendCopyRowData ( columnValues , columnNulls , tupleDescriptor , copyOutState , columnOutputFunctions ) ; SendCopyDataToAll ( copyOutState -> fe_msgbuf , shardId , shardConnections -> connectionList ) ; MemoryContextSwitchTo ( oldContext ) ; # if PG_VERSION_NUM >= 90600 return true ; # endif } | <S2SV_ModStart> ) dest ; <S2SV_ModEnd> int partitionColumnIndex = <S2SV_ModStart> copyDest -> copyStatement <S2SV_ModEnd> ; HTAB * <S2SV_ModStart> ( partitionColumnValue , copyDest -> tableMetadata <S2SV_ModEnd> ) ; if |
1,291 | CWE-000 int neigh_resolve_output ( struct in_addr * nexhop , struct rte_mbuf * m , struct netif_port * port ) { struct neighbour_entry * neighbour ; struct neighbour_mbuf_entry * m_buf ; uint32_t src_ip ; unsigned int hashkey ; union inet_addr saddr , daddr ; uint32_t nexhop_addr = nexhop -> s_addr ; if ( port -> flag & NETIF_PORT_FLAG_NO_ARP ) return netif_xmit ( m , port ) ; hashkey = neigh_hashkey ( nexhop_addr , port ) ; neighbour = neigh_lookup_entry ( & nexhop_addr , port , hashkey ) ; if ( neighbour ) { if ( neighbour -> flag & NEIGHBOUR_BUILD ) { if ( neighbour -> que_num > arp_unres_qlen ) { rte_pktmbuf_free ( m ) ; return EDPVS_DROP ; } m_buf = rte_zmalloc ( "neigh_new_mbuf" , sizeof ( struct neighbour_mbuf_entry ) , RTE_CACHE_LINE_SIZE ) ; if ( ! m_buf ) { rte_pktmbuf_free ( m ) ; return EDPVS_DROP ; } m_buf -> m = m ; list_add_tail ( & m_buf -> neigh_mbuf_list , & neighbour -> queue_list ) ; neighbour -> que_num ++ ; memset ( & saddr , 0 , sizeof ( saddr ) ) ; daddr . in . s_addr = nexhop_addr ; inet_addr_select ( AF_INET , port , & daddr , 0 , & saddr ) ; src_ip = saddr . in . s_addr ; if ( ! src_ip ) { return EDPVS_PKTSTOLEN ; } if ( neigh_send_arp ( port , src_ip , nexhop_addr ) ) { <S2SV_StartBug> RTE_LOG ( INFO , NEIGHBOUR , "[%s]<S2SV_blank>send<S2SV_blank>arp<S2SV_blank>failed\\n" , __func__ ) ; <S2SV_EndBug> return EDPVS_NOMEM ; } return EDPVS_OK ; } else if ( neighbour -> flag & NEIGHBOUR_COMPLETED ) { neigh_fill_mac ( neighbour , m ) ; netif_xmit ( m , neighbour -> port ) ; return EDPVS_OK ; } return EDPVS_IDLE ; } else { neighbour = neigh_add_table ( nexhop_addr , NULL , port , hashkey , 0 ) ; if ( ! neighbour ) { <S2SV_StartBug> RTE_LOG ( INFO , NEIGHBOUR , "[%s]<S2SV_blank>add<S2SV_blank>neighbour<S2SV_blank>wrong\\n" , __func__ ) ; <S2SV_EndBug> return EDPVS_NOMEM ; } if ( neighbour -> que_num > arp_unres_qlen ) { rte_pktmbuf_free ( m ) ; return EDPVS_DROP ; } m_buf = rte_zmalloc ( "neigh_new_mbuf" , sizeof ( struct neighbour_mbuf_entry ) , RTE_CACHE_LINE_SIZE ) ; if ( ! m_buf ) { rte_pktmbuf_free ( m ) ; return EDPVS_DROP ; } m_buf -> m = m ; list_add_tail ( & m_buf -> neigh_mbuf_list , & neighbour -> queue_list ) ; neighbour -> que_num ++ ; memset ( & saddr , 0 , sizeof ( saddr ) ) ; daddr . in . s_addr = nexhop_addr ; inet_addr_select ( AF_INET , port , & daddr , 0 , & saddr ) ; src_ip = saddr . in . s_addr ; if ( ! src_ip ) { return EDPVS_PKTSTOLEN ; } if ( neigh_send_arp ( port , src_ip , nexhop_addr ) ) { <S2SV_StartBug> RTE_LOG ( INFO , NEIGHBOUR , "[%s]<S2SV_blank>send<S2SV_blank>arp<S2SV_blank>failed\\n" , __func__ ) ; <S2SV_EndBug> return EDPVS_NOMEM ; } return EDPVS_OK ; } } | <S2SV_ModStart> { RTE_LOG ( ERR <S2SV_ModEnd> , NEIGHBOUR , <S2SV_ModStart> { RTE_LOG ( ERR <S2SV_ModEnd> , NEIGHBOUR , <S2SV_ModStart> { RTE_LOG ( ERR <S2SV_ModEnd> , NEIGHBOUR , |
1,292 | CWE-000 <S2SV_StartBug> Node * parse_band ( Parser * parser ) { <S2SV_EndBug> Node * cur_node = parse_bshift ( parser ) ; while ( curtok ( parser ) == T_AMP ) { eattok ( parser , T_AMP ) ; cur_node = new_BinOp ( T_AMP , cur_node , parse_bshift ( parser ) , parser -> lex -> line ) ; } return cur_node ; } | <S2SV_ModStart> parser ) { YASL_TRACE_LOG ( "parsing<S2SV_blank>&<S2SV_blank>in<S2SV_blank>line<S2SV_blank>%d\\n" , parser -> lex -> line ) ; |
1,293 | CWE-000 int ossl_ecdsa_verify_sig ( const unsigned char * dgst , int dgst_len , const ECDSA_SIG * sig , EC_KEY * eckey ) { int ret = - 1 , i ; BN_CTX * ctx ; const BIGNUM * order ; BIGNUM * u1 , * u2 , * m , * X ; EC_POINT * point = NULL ; const EC_GROUP * group ; const EC_POINT * pub_key ; if ( eckey == NULL || ( group = EC_KEY_get0_group ( eckey ) ) == NULL || ( pub_key = EC_KEY_get0_public_key ( eckey ) ) == NULL || sig == NULL ) { ECerr ( EC_F_OSSL_ECDSA_VERIFY_SIG , EC_R_MISSING_PARAMETERS ) ; return - 1 ; } if ( ! EC_KEY_can_sign ( eckey ) ) { ECerr ( EC_F_OSSL_ECDSA_VERIFY_SIG , EC_R_CURVE_DOES_NOT_SUPPORT_SIGNING ) ; return - 1 ; } ctx = BN_CTX_new ( ) ; if ( ctx == NULL ) { ECerr ( EC_F_OSSL_ECDSA_VERIFY_SIG , ERR_R_MALLOC_FAILURE ) ; return - 1 ; } BN_CTX_start ( ctx ) ; u1 = BN_CTX_get ( ctx ) ; u2 = BN_CTX_get ( ctx ) ; m = BN_CTX_get ( ctx ) ; X = BN_CTX_get ( ctx ) ; if ( X == NULL ) { ECerr ( EC_F_OSSL_ECDSA_VERIFY_SIG , ERR_R_BN_LIB ) ; goto err ; } order = EC_GROUP_get0_order ( group ) ; if ( order == NULL ) { ECerr ( EC_F_OSSL_ECDSA_VERIFY_SIG , ERR_R_EC_LIB ) ; goto err ; } if ( BN_is_zero ( sig -> r ) || BN_is_negative ( sig -> r ) || BN_ucmp ( sig -> r , order ) >= 0 || BN_is_zero ( sig -> s ) || BN_is_negative ( sig -> s ) || BN_ucmp ( sig -> s , order ) >= 0 ) { ECerr ( EC_F_OSSL_ECDSA_VERIFY_SIG , EC_R_BAD_SIGNATURE ) ; ret = 0 ; goto err ; } # if 0 if ( ! BN_rshift1 ( m , order ) ) { ECerr ( EC_F_OSSL_ECDSA_VERIFY_SIG , ERR_R_BN_LIB ) ; goto err ; } <S2SV_StartBug> if ( BN_cmp ( sig -> r , m ) <= 0 ) { <S2SV_EndBug> ECerr ( EC_F_OSSL_ECDSA_VERIFY_SIG , EC_R_BAD_SIGNATURE ) ; ret = 0 ; goto err ; } # endif if ( ! BN_mod_inverse ( u2 , sig -> s , order , ctx ) ) { ECerr ( EC_F_OSSL_ECDSA_VERIFY_SIG , ERR_R_BN_LIB ) ; goto err ; } i = BN_num_bits ( order ) ; if ( 8 * dgst_len > i ) dgst_len = ( i + 7 ) / 8 ; if ( ! BN_bin2bn ( dgst , dgst_len , m ) ) { ECerr ( EC_F_OSSL_ECDSA_VERIFY_SIG , ERR_R_BN_LIB ) ; goto err ; } if ( ( 8 * dgst_len > i ) && ! BN_rshift ( m , m , 8 - ( i & 0x7 ) ) ) { ECerr ( EC_F_OSSL_ECDSA_VERIFY_SIG , ERR_R_BN_LIB ) ; goto err ; } if ( ! BN_mod_mul ( u1 , m , u2 , order , ctx ) ) { ECerr ( EC_F_OSSL_ECDSA_VERIFY_SIG , ERR_R_BN_LIB ) ; goto err ; } if ( ! BN_mod_mul ( u2 , sig -> r , u2 , order , ctx ) ) { ECerr ( EC_F_OSSL_ECDSA_VERIFY_SIG , ERR_R_BN_LIB ) ; goto err ; } if ( ( point = EC_POINT_new ( group ) ) == NULL ) { ECerr ( EC_F_OSSL_ECDSA_VERIFY_SIG , ERR_R_MALLOC_FAILURE ) ; goto err ; } if ( ! EC_POINT_mul ( group , point , u1 , pub_key , u2 , ctx ) ) { ECerr ( EC_F_OSSL_ECDSA_VERIFY_SIG , ERR_R_EC_LIB ) ; goto err ; } if ( EC_METHOD_get_field_type ( EC_GROUP_method_of ( group ) ) == NID_X9_62_prime_field ) { if ( ! EC_POINT_get_affine_coordinates_GFp ( group , point , X , NULL , ctx ) ) { ECerr ( EC_F_OSSL_ECDSA_VERIFY_SIG , ERR_R_EC_LIB ) ; goto err ; } } # ifndef OPENSSL_NO_EC2M else { if ( ! EC_POINT_get_affine_coordinates_GF2m ( group , point , X , NULL , ctx ) ) { ECerr ( EC_F_OSSL_ECDSA_VERIFY_SIG , ERR_R_EC_LIB ) ; goto err ; } } # endif if ( ! BN_nnmod ( u1 , X , order , ctx ) ) { ECerr ( EC_F_OSSL_ECDSA_VERIFY_SIG , ERR_R_BN_LIB ) ; goto err ; } ret = ( BN_ucmp ( u1 , sig -> r ) == 0 ) ; err : BN_CTX_end ( ctx ) ; BN_CTX_free ( ctx ) ; EC_POINT_free ( point ) ; return ret ; } | <S2SV_ModStart> ( sig -> s <S2SV_ModEnd> , m ) |
1,294 | CWE-000 OPJ_BOOL opj_t2_encode_packets ( opj_t2_t * p_t2 , OPJ_UINT32 p_tile_no , opj_tcd_tile_t * p_tile , OPJ_UINT32 p_maxlayers , OPJ_BYTE * p_dest , OPJ_UINT32 * p_data_written , OPJ_UINT32 p_max_len , opj_codestream_info_t * cstr_info , OPJ_UINT32 p_tp_num , OPJ_INT32 p_tp_pos , OPJ_UINT32 p_pino , J2K_T2_MODE p_t2_mode , opj_event_mgr_t * p_manager ) { OPJ_BYTE * l_current_data = p_dest ; OPJ_UINT32 l_nb_bytes = 0 ; OPJ_UINT32 compno ; OPJ_UINT32 poc ; opj_pi_iterator_t * l_pi = 00 ; opj_pi_iterator_t * l_current_pi = 00 ; opj_image_t * l_image = p_t2 -> image ; opj_cp_t * l_cp = p_t2 -> cp ; opj_tcp_t * l_tcp = & l_cp -> tcps [ p_tile_no ] ; OPJ_UINT32 pocno = ( l_cp -> rsiz == OPJ_PROFILE_CINEMA_4K ) ? 2 : 1 ; OPJ_UINT32 l_max_comp = l_cp -> m_specific_param . m_enc . m_max_comp_size > 0 ? l_image -> numcomps : 1 ; OPJ_UINT32 l_nb_pocs = l_tcp -> numpocs + 1 ; l_pi = opj_pi_initialise_encode ( l_image , l_cp , p_tile_no , p_t2_mode ) ; if ( ! l_pi ) { return OPJ_FALSE ; } * p_data_written = 0 ; if ( p_t2_mode == THRESH_CALC ) { l_current_pi = l_pi ; for ( compno = 0 ; compno < l_max_comp ; ++ compno ) { OPJ_UINT32 l_comp_len = 0 ; l_current_pi = l_pi ; for ( poc = 0 ; poc < pocno ; ++ poc ) { OPJ_UINT32 l_tp_num = compno ; opj_pi_create_encode ( l_pi , l_cp , p_tile_no , poc , l_tp_num , p_tp_pos , p_t2_mode ) ; if ( l_current_pi -> poc . prg == OPJ_PROG_UNKNOWN ) { opj_pi_destroy ( l_pi , l_nb_pocs ) ; return OPJ_FALSE ; } while ( opj_pi_next ( l_current_pi ) ) { if ( l_current_pi -> layno < p_maxlayers ) { l_nb_bytes = 0 ; if ( ! opj_t2_encode_packet ( p_tile_no , p_tile , l_tcp , l_current_pi , l_current_data , & l_nb_bytes , p_max_len , cstr_info , <S2SV_StartBug> p_manager ) ) { <S2SV_EndBug> opj_pi_destroy ( l_pi , l_nb_pocs ) ; return OPJ_FALSE ; } l_comp_len += l_nb_bytes ; l_current_data += l_nb_bytes ; p_max_len -= l_nb_bytes ; * p_data_written += l_nb_bytes ; } } if ( l_cp -> m_specific_param . m_enc . m_max_comp_size ) { if ( l_comp_len > l_cp -> m_specific_param . m_enc . m_max_comp_size ) { opj_pi_destroy ( l_pi , l_nb_pocs ) ; return OPJ_FALSE ; } } ++ l_current_pi ; } } } else { opj_pi_create_encode ( l_pi , l_cp , p_tile_no , p_pino , p_tp_num , p_tp_pos , p_t2_mode ) ; l_current_pi = & l_pi [ p_pino ] ; if ( l_current_pi -> poc . prg == OPJ_PROG_UNKNOWN ) { opj_pi_destroy ( l_pi , l_nb_pocs ) ; return OPJ_FALSE ; } while ( opj_pi_next ( l_current_pi ) ) { if ( l_current_pi -> layno < p_maxlayers ) { l_nb_bytes = 0 ; if ( ! opj_t2_encode_packet ( p_tile_no , p_tile , l_tcp , l_current_pi , <S2SV_StartBug> l_current_data , & l_nb_bytes , p_max_len , cstr_info , p_manager ) ) { <S2SV_EndBug> opj_pi_destroy ( l_pi , l_nb_pocs ) ; return OPJ_FALSE ; } l_current_data += l_nb_bytes ; p_max_len -= l_nb_bytes ; * p_data_written += l_nb_bytes ; if ( cstr_info ) { if ( cstr_info -> index_write ) { opj_tile_info_t * info_TL = & cstr_info -> tile [ p_tile_no ] ; opj_packet_info_t * info_PK = & info_TL -> packet [ cstr_info -> packno ] ; if ( ! cstr_info -> packno ) { info_PK -> start_pos = info_TL -> end_header + 1 ; } else { info_PK -> start_pos = ( ( l_cp -> m_specific_param . m_enc . m_tp_on | l_tcp -> POC ) && info_PK -> start_pos ) ? info_PK -> start_pos : info_TL -> packet [ cstr_info -> packno - 1 ] . end_pos + 1 ; } info_PK -> end_pos = info_PK -> start_pos + l_nb_bytes - 1 ; info_PK -> end_ph_pos += info_PK -> start_pos - 1 ; } cstr_info -> packno ++ ; } ++ p_tile -> packno ; } } } opj_pi_destroy ( l_pi , l_nb_pocs ) ; return OPJ_TRUE ; } | <S2SV_ModStart> , cstr_info , p_t2_mode , <S2SV_ModStart> , p_max_len , cstr_info , p_t2_mode <S2SV_ModEnd> , p_manager ) |
1,295 | CWE-000 void collect_data_local_file ( t_list * * list , char * str_part ) { DIR * dir ; char * path ; char * slash ; path = NULL ; slash = NULL ; if ( ( dir = opendir ( str_part ) ) ) <S2SV_StartBug> load_dir_autocomplete ( dir , list , str_part , NULL ) ; <S2SV_EndBug> else if ( str_part && ( slash = ft_strrchr ( str_part , '/' ) ) ) { path = ft_strndup ( str_part , ( slash - str_part ) + 1 ) ; if ( ( dir = opendir ( path ) ) ) <S2SV_StartBug> load_dir_autocomplete ( dir , list , str_part , slash + 1 ) ; <S2SV_EndBug> else ft_free ( ( void * * ) & path ) ; } if ( ! dir && ! path ) { path = ft_getcwd ( ) ; if ( ( dir = opendir ( path ) ) ) load_dir_autocomplete ( dir , list , path , ( str_part && str_part [ 0 ] ? str_part : NULL ) ) ; } closedir ( dir ) ; free ( path ) ; } | <S2SV_ModStart> ) ) ) load_dir_and_add_slash_autocomplete <S2SV_ModEnd> ( dir , <S2SV_ModStart> , list , path <S2SV_ModEnd> , slash + |
1,296 | CWE-000 int usage ( void ) { fprintf ( stderr , "usage:<S2SV_blank>mkbootimg\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--kernel<S2SV_blank><filename>\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--ramdisk<S2SV_blank><filename><S2SV_blank>]\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--second<S2SV_blank><2ndbootloader-filename><S2SV_blank>]\\n" <S2SV_StartBug> "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--cmdline<S2SV_blank><kernel-commandline><S2SV_blank>]\\n" <S2SV_EndBug> "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--board<S2SV_blank><boardname><S2SV_blank>]\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--base<S2SV_blank><address><S2SV_blank>]\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--pagesize<S2SV_blank><pagesize><S2SV_blank>]\\n" <S2SV_StartBug> "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--dt<S2SV_blank><filename><S2SV_blank>]\\n" <S2SV_EndBug> "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--kernel_offset<S2SV_blank><base<S2SV_blank>offset><S2SV_blank>]\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--ramdisk_offset<S2SV_blank><base<S2SV_blank>offset><S2SV_blank>]\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--second_offset<S2SV_blank><base<S2SV_blank>offset><S2SV_blank>]\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--tags_offset<S2SV_blank><base<S2SV_blank>offset><S2SV_blank>]\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--os_version<S2SV_blank><A.B.C<S2SV_blank>version><S2SV_blank>]\\n" <S2SV_StartBug> "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--os_patch_level<S2SV_blank><YYYY-MM-DD<S2SV_blank>date><S2SV_blank>]\\n" <S2SV_EndBug> "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--hash<S2SV_blank><sha1(default)|sha256><S2SV_blank>]\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--id<S2SV_blank>]\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-o|--output<S2SV_blank><filename>\\n" ) ; return 1 ; } | <S2SV_ModStart> "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--kernel<S2SV_blank><filename>\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--ramdisk<S2SV_blank><filename><S2SV_blank>]\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--second<S2SV_blank><2ndbootloader-filename><S2SV_blank>]\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--recovery_dtbo<S2SV_blank><recoverydtbo-filename><S2SV_blank>]\\n" <S2SV_ModStart> "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--board<S2SV_blank><boardname><S2SV_blank>]\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--base<S2SV_blank><address><S2SV_blank>]\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--pagesize<S2SV_blank><pagesize><S2SV_blank>]\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--dt<S2SV_blank><dtb-filename><S2SV_blank>]\\n" <S2SV_ModEnd> "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--kernel_offset<S2SV_blank><base<S2SV_blank>offset><S2SV_blank>]\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--ramdisk_offset<S2SV_blank><base<S2SV_blank>offset><S2SV_blank>]\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--second_offset<S2SV_blank><base<S2SV_blank>offset><S2SV_blank>]\\n" <S2SV_ModStart> "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--tags_offset<S2SV_blank><base<S2SV_blank>offset><S2SV_blank>]\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--os_version<S2SV_blank><A.B.C<S2SV_blank>version><S2SV_blank>]\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--os_patch_level<S2SV_blank><YYYY-MM-DD<S2SV_blank>date><S2SV_blank>]\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>[<S2SV_blank>--header_version<S2SV_blank><version<S2SV_blank>number><S2SV_blank>]\\n" |
1,297 | CWE-000 retVal p_list ( string inName ) { FILE * in = fopen ( inName , READMODE ) ; byte * buffer = NULL ; string buffer2 = NULL ; rType ridge ; <S2SV_StartBug> P_FTADD ( FUNCNAME ) ; P_GDTINIT ( inName , false ) ; <S2SV_EndBug> if ( ! in ) { perror ( MSG_PERROR ) ; P_FREEALL ( ) ; return errno ; } if ( ( ridge = p_sCaC ( in , NULL ) ) ) return ridge ; p_print ( "%s\\n" , inName ) ; while ( ridge != rType_end && ( buffer = p_getRdg ( in , & ridge ) ) && ridge != rType_end ) { free ( buffer ) ; while ( ( ridge == rType_dname || ridge == rType_fname ) && buffer ) { p_print ( MSG_FILEFOUND1 ) ; if ( ridge == rType_dname ) { p_getRdgDT . dirCount -- ; p_print ( MSG_FILEFOUND1 ) ; p_getRdgDT . dirCount ++ ; p_print ( "%s" , P_DTCURR ( p_getRdgDT ) ) ; } else { while ( ( buffer = p_getRdg ( in , & ridge ) ) && <S2SV_StartBug> ( ridge += P_RTYPECORR ) <= P_DATA ) <S2SV_EndBug> { if ( ! ( buffer2 = calloc ( ( ridge += P_DCORR ) + STRALLOC , sizeof ( string ) ) ) || ! memcpy ( buffer2 , buffer , ridge ) ) { perror ( MSG_PERROR ) ; P_FREEALL ( ) ; <S2SV_StartBug> return errno ; <S2SV_EndBug> } p_print ( buffer2 ) ; free ( buffer ) ; <S2SV_StartBug> free ( buffer2 ) ; buffer2 = NULL ; <S2SV_EndBug> } if ( buffer ) free ( buffer ) ; buffer = NULL ; } p_print ( MSG_FILEFOUND2 ) ; ridge -= P_RTYPECORR ; } } if ( ! buffer ) { P_FREEALL ( ) ; return ridge ; } P_FREEALL ( ) ; return none ; } | <S2SV_ModStart> rType ridge ; retVal ret = none ; <S2SV_ModStart> ) <= P_DATA && ( buffer = p_dToS ( buffer , ridge + P_DCORR , true , & ret ) ) ) { p_print ( buffer ) ; free ( buffer ) ; } if ( ret ) { <S2SV_ModEnd> P_FREEALL ( ) <S2SV_ModStart> ) ; return ret ; } if ( buffer ) <S2SV_ModEnd> free ( buffer <S2SV_ModStart> buffer ) ; if ( ridge == rType_end ) <S2SV_ModEnd> buffer = NULL |
1,298 | CWE-000 static void updateReceivers ( struct receiver * * receivers , u_int32_t dst_addr , u_int8_t version , u_int32_t num_pkts , struct receiver * * topReceivers ) { struct receiver * r ; u_int32_t size ; int a ; HASH_FIND_INT ( * receivers , ( int * ) & dst_addr , r ) ; if ( r == NULL ) { if ( ( ( size = HASH_COUNT ( * receivers ) ) < MAX_TABLE_SIZE_1 ) || ( ( a = acceptable ( num_pkts ) ) != 0 ) ) { r = ( struct receiver * ) malloc ( sizeof ( struct receiver ) ) ; if ( ! r ) return ; r -> addr = dst_addr ; r -> version = version ; r -> num_pkts = num_pkts ; HASH_ADD_INT ( * receivers , addr , r ) ; if ( ( size = HASH_COUNT ( * receivers ) ) > MAX_TABLE_SIZE_2 ) { HASH_SORT ( * receivers , receivers_sort_asc ) ; <S2SV_StartBug> * receivers = cutBackTo ( * receivers , MAX_TABLE_SIZE_1 ) ; <S2SV_EndBug> <S2SV_StartBug> mergeTables ( * receivers , topReceivers ) ; <S2SV_EndBug> if ( ( size = HASH_COUNT ( * topReceivers ) ) > MAX_TABLE_SIZE_1 ) { HASH_SORT ( * topReceivers , receivers_sort_asc ) ; <S2SV_StartBug> * topReceivers = cutBackTo ( * topReceivers , MAX_TABLE_SIZE_1 ) ; <S2SV_EndBug> } resetReceivers ( * receivers ) ; * receivers = NULL ; } } } else r -> num_pkts += num_pkts ; } | <S2SV_ModStart> = cutBackTo ( receivers , size <S2SV_ModEnd> , MAX_TABLE_SIZE_1 ) <S2SV_ModStart> ; mergeTables ( <S2SV_ModEnd> receivers , topReceivers <S2SV_ModStart> = cutBackTo ( topReceivers , size , MAX_TABLE_SIZE_1 ) ; } <S2SV_ModEnd> * receivers = |
1,299 | CWE-000 <S2SV_StartBug> static void ServerNetworkLayerUDP_deleteMembers ( ServerNetworkLayerUDP * layer ) { <S2SV_EndBug> } | <S2SV_ModStart> void ServerNetworkLayerUDP_deleteMembers ( UA_ServerNetworkLayer * nl ) { <S2SV_ModStart> ServerNetworkLayerUDP * layer = nl -> handle ; free ( layer ) ; UA_String_deleteMembers ( & nl -> discoveryUrl ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.