Esempio n. 1
0
void RichRuler::RightDown(Point p, dword)
{
	if(p.x < x0 - 3) {
		newtabalign--;
		if(newtabalign < ALIGN_LEFT) newtabalign = ALIGN_CENTER;
		Refresh();
		return;
	}

	track = FindMarker(p);
	if(track < 0)
		pos = ((p.x - x0) / zoom + snap / 2) / snap * snap;
	WhenRightDown();
}
int ReadHex(FILE *infile, BitSequence *A, int Length, char *str)
{
    int         i, ch, started;
    BitSequence ich;

    if ( Length == 0 ) {
        A[0] = 0x00;
        return 1;
    }
    memset(A, 0x00, Length);
    started = 0;
    i = 0;
    if ( FindMarker(infile, str) )
        while ( (ch = fgetc(infile)) != EOF ) 
        {
            if ( !isxdigit(ch) ) {
                if ( !started ) {
                    if ( ch == '\n' )
                        break;
                    else
                        continue;
                }
                else
                    break;
            }
            started = 1;
            if ( (ch >= '0') && (ch <= '9') )
                ich = ch - '0';
            else if ( (ch >= 'A') && (ch <= 'F') )
                ich = ch - 'A' + 10;
            else if ( (ch >= 'a') && (ch <= 'f') )
                ich = ch - 'a' + 10;

            A[i / 2] = (A[i / 2] << 4) | ich;
            if ( (++i / 2) == Length )
                break;
        }
    else
        return 0;

    return 1;
}
Esempio n. 3
0
void RichRuler::LeftDown(Point p, dword)
{
	track = FindMarker(p);
	if(track >= 0) {
		trackdx = marker[track].pos * zoom + x0 - p.x;
		SetCapture();
		WhenBeginTrack();
	}
	else
	if(p.x < 16) {
		newtabalign++;
		if(newtabalign > ALIGN_CENTER) newtabalign = ALIGN_LEFT;
		Refresh();
		return;
	}
	else {
		pos = ((p.x - x0) / zoom + snap / 2) / snap * snap;
		WhenLeftDown();
	}
}
int main( void )
{
    unsigned long long    inlen;
    int                    result = 0;
    FILE                *fp_in;
    char                marker[20];
    int                    refLen;

#ifdef cKeccakFixedOutputLengthInBytes
    refLen = cKeccakFixedOutputLengthInBytes;
#else
    refLen = cKeccakR_SizeInBytes;
#endif

    printf( "Testing Keccak[r=%u, c=%u] against %s over %d squeezed bytes\n", cKeccakR, cKeccakB - cKeccakR, testVectorFile, refLen );
    if ( (fp_in = fopen(testVectorFile, "r")) == NULL ) 
    {
        printf("Couldn't open <%s> for read\n", testVectorFile);
        return 1;
    }

    for ( inlen = 0; inlen <= cKeccakMaxMessageSizeInBytes; ++inlen )
    {
        sprintf( marker, "Len = %u", inlen * 8 );
        if ( !FindMarker(fp_in, marker) )
        {
            printf("ERROR: no test vector found (%u bytes)\n", inlen );
            result = 1;
            break;
        }
        if ( !ReadHex(fp_in, input, (int)inlen, "Msg = ") ) 
        {
            printf("ERROR: unable to read 'Msg' (%u bytes)\n", inlen );
            result = 1;
            break;
        }

        result = crypto_hash( output, input, inlen );
        if ( result != 0 )
        {
            printf("ERROR: crypto_hash() (%u bytes)\n", inlen);
            result = 1;
            break;
        }

        #ifdef cKeccakFixedOutputLengthInBytes
        if ( !ReadHex(fp_in, input, refLen, "MD = ") )
        #else
        if ( !ReadHex(fp_in, input, refLen, "Squeezed = ") )
        #endif
        {
            printf("ERROR: unable to read 'Squeezed/MD' (%u bytes)\n", inlen );
            result = 1;
            break;
        }
        if ( memcmp( output, input, refLen ) != 0) 
        {
            printf("ERROR: hash verification (%u bytes)\n", inlen );
            for(result=0; result<refLen; result++)
                printf("%02X ", output[result]);
            printf("\n");
            result = 1;
            break;
        }
    }

    fclose( fp_in );
    if ( !result )
        printf( "\nSuccess!\n");

    //printf( "\nPress a key ...");
    //getchar();
    //printf( "\n");
    return ( result );
}
Esempio n. 5
0
size_t BazisLib::Network::BufferedSocketBase::RecvToMarker( void *pBuffer, size_t length, const void *pMarker, size_t markerSize )
{
	if (!markerSize)
	{
		m_LastRecvError = kInvalidArgument;
		return 0;
	}

	//1. Try searching for the marker in the internal buffer
	//2. If failed, copy data to external buffer and try receiving more until the buffer is full
	//3. After every iteration try finding the marker
	//4. If failed, return 0
	//   If found, put what's left to the internal buffer

	size_t availableInternally = m_Buffer.GetSize() - m_BufferOffset;
	size_t off = FindMarker(m_Buffer.GetData(m_BufferOffset), min(availableInternally, length), pMarker, markerSize);
	if (off != -1)
	{
		ASSERT((off + markerSize) <= length);
		memcpy(pBuffer, m_Buffer.GetData(m_BufferOffset), off + markerSize);
		m_BufferOffset += (off + markerSize);
		m_LastRecvError = kSuccess;
		return off + markerSize;
	}
	//The marker was not found in the buffer. Try to fetch more

	if (availableInternally >= length)
	{
		m_LastRecvError = kBufferFull;
		return 0;
	}

	memcpy(pBuffer, m_Buffer.GetData(m_BufferOffset), availableInternally);
	//At this point the internal buffer has been completely copied to the user buffer. We will copy it back if we go to the fallback routine.

	size_t bufOff = availableInternally, prevOff = 0;
	while (bufOff < length)
	{
		size_t todo = length - bufOff;
		size_t done = RawRecv(((char *)pBuffer) + bufOff, todo);
		if (done == 0)
		{
			m_LastRecvError = kSocketClosed;
			return 0;
		}
		else if (done == -1)
		{
			m_LastRecvError = kSocketClosed;
			return 0;
		}

		off = FindMarker(((char *)pBuffer) + prevOff, bufOff + done - prevOff, pMarker, markerSize);
		if (off != -1)
		{
			off += prevOff;	//Adjust 'off' so that it contains the offset from the beginning of buffer
			off += markerSize;

			//Off now points to the end of the data we are returning
			size_t writeBackSize = bufOff + done - off;
			if (!m_Buffer.EnsureSize(writeBackSize))
			{
				m_LastRecvError = kOutOfMemoryAndLostData;
				return 0;
			}

			m_BufferOffset = 0;
			memcpy(m_Buffer.GetData(), ((char *)pBuffer) + off, writeBackSize);
			m_Buffer.SetSize(writeBackSize);
			
			return off;
		}

		bufOff += done;
		if (bufOff > markerSize)
			prevOff = bufOff - markerSize + 1;
		else
			prevOff = 0;
	}

	//Fallback case. We cannot go further as the user-supplied buffer has been filled completely.
	//This should happen relatively rarely, so copying the data back to our internal buffer
	//should not be a performance problem here.

	//The data from the internal buffer has been copied to the user buffer, as we assumed that we
	//are going to return it. Now we are copying it back.
	ASSERT(bufOff == length);

	//An optimization is possible here: if the original m_BufferOffset was 0, we do not need to
	//copy back the first part of the buffer. However, it's probably impractical to implement.

	if (!m_Buffer.EnsureSize(bufOff))
	{
		m_LastRecvError = kOutOfMemoryAndLostData;
		return 0;
	}

	m_BufferOffset = 0;
	memcpy(m_Buffer.GetData(), pBuffer, bufOff);
	m_Buffer.SetSize(bufOff);

	m_LastRecvError = kBufferFull;
	return 0;
}
int main( void )
{
    unsigned long long    inlen;
    unsigned long long    offset;
    unsigned long long    size;
    int                    result = 0;
    FILE                *fp_in;
    char                marker[20];
    int                    refLen;
    hashState			state;

#ifdef cKeccakFixedOutputLengthInBytes
    refLen = cKeccakFixedOutputLengthInBytes;
#else
    refLen = cKeccakR_SizeInBytes;
#endif

    printf( "Testing Keccak[r=%u, c=%u] using crypto_hash() against %s over %d squeezed bytes\n", cKeccakR, cKeccakB - cKeccakR, testVectorFile, refLen );
    if ( (fp_in = fopen(testVectorFile, "r")) == NULL ) 
    {
        printf("Couldn't open <%s> for read\n", testVectorFile);
        return 1;
    }

    for ( inlen = 0; inlen <= cKeccakMaxMessageSizeInBytes; ++inlen )
    {
        sprintf( marker, "Len = %u", inlen * 8 );
        if ( !FindMarker(fp_in, marker) )
        {
            printf("ERROR: no test vector found (%u bytes)\n", inlen );
            result = 1;
            break;
        }
        if ( !ReadHex(fp_in, input, (int)inlen, "Msg = ") ) 
        {
            printf("ERROR: unable to read 'Msg' (%u bytes)\n", inlen );
            result = 1;
            break;
        }

        result = crypto_hash( output, input, inlen );
        if ( result != 0 )
        {
            printf("ERROR: crypto_hash() (%u bytes)\n", inlen);
            result = 1;
            break;
        }

        #ifdef cKeccakFixedOutputLengthInBytes
        if ( !ReadHex(fp_in, input, refLen, "MD = ") )
        #else
        if ( !ReadHex(fp_in, input, refLen, "Squeezed = ") )
        #endif
        {
            printf("ERROR: unable to read 'Squeezed/MD' (%u bytes)\n", inlen );
            result = 1;
            break;
        }
        if ( memcmp( output, input, refLen ) != 0) 
        {
            printf("ERROR: hash verification (%u bytes)\n", inlen );
            for(result=0; result<refLen; result++)
                printf("%02X ", output[result]);
            printf("\n");
            result = 1;
            break;
        }
    }
    if ( !result )
        printf( "\nSuccess!\n");
	result = 0;

    refLen = cKeccakHashRefSizeInBytes;
    printf( "\nTesting Keccak[r=%u, c=%u] using Init/Update/Final() against %s over %d squeezed bytes\n", cKeccakR, cKeccakB - cKeccakR, testVectorFile, refLen );
    fseek( fp_in, 0, SEEK_SET );
    for ( inlen = 0; inlen <= cKeccakMaxMessageSizeInBits; ++inlen )
    {
        sprintf( marker, "Len = %u", inlen );
        if ( !FindMarker(fp_in, marker) )
        {
            printf("ERROR: no test vector found (%u bits)\n", inlen );
            result = 1;
            break;
        }
        if ( !ReadHex(fp_in, input, (int)inlen, "Msg = ") ) 
        {
            printf("ERROR: unable to read 'Msg' (%u bits)\n", inlen );
            result = 1;
            break;
        }

		result = Init( &state );
        if ( result != 0 )
        {
            printf("ERROR: Init() (%u bits)\n", inlen);
            result = 1;
            break;
        }

		for ( offset = 0; offset < inlen; offset += size )
		{
			//	vary sizes for Update()
			if ( (inlen %8) < 2 )
			{
				//	byte per byte
				size = 8;
			}
			else if ( (inlen %8) < 4 )
			{
				//	incremental
				size = offset + 8;
			}
			else
			{
				//	random
				size = ((rand() % ((inlen + 8) / 8)) + 1) * 8;
			}

			if ( size > (inlen - offset) ) 
			{
				size = inlen - offset;
			}
			//printf("Update() inlen %u, size %u, offset %u\n", (unsigned int)inlen, (unsigned int)size, (unsigned int)offset );
			result = Update( &state, input + offset / 8, size );
	        if ( result != 0 )
	        {
	            printf("ERROR: Update() (%u bits)\n", inlen);
	            result = 1;
	            break;
	        }
		}
		result = Final( &state, output, refLen );
        if ( result != 0 )
        {
            printf("ERROR: Final() (%u bits)\n", inlen);
            result = 1;
            break;
        }

        #ifdef cKeccakFixedOutputLengthInBytes
        if ( !ReadHex(fp_in, input, refLen, "MD = ") )
        #else
        if ( !ReadHex(fp_in, input, refLen, "Squeezed = ") )
        #endif
        {
            printf("ERROR: unable to read 'Squeezed/MD' (%u bits)\n", inlen );
            result = 1;
            break;
        }
        if ( memcmp( output, input, refLen ) != 0) 
        {
            printf("ERROR: hash verification (%u bits)\n", inlen );
            for(result=0; result<refLen; result++)
                printf("%02X ", output[result]);
            printf("\n");
            result = 1;
            break;
        }
    }

    fclose( fp_in );
    if ( !result )
        printf( "\nSuccess!\n");

    //printf( "\nPress a key ...");
    //getchar();
    //printf( "\n");
    return ( result );
}
Esempio n. 7
0
/**************************************************************************//*!
 *
 * @name  HandleSerialClassReady
 *
 * @brief This function handles Serial Event when Agent is in READY 
 *        State
 *
 * @param controller_ID :   Serial Controller ID
 * @param event_type    :   Serial Bus Event ID
 * @param psBuffer      :   Pointer to Buffer Structure
 *
 * @return None
 ******************************************************************************
 * This function handles Serial Event when Agent is in READY State
 *****************************************************************************/
static void HandleSerialClassReady(
    uint_8 controller_ID,       /* [IN] Controller ID */
    uint_8 event_type,          /* [IN] Serial Bus Event ID */
    PBUFFER psBuffer            /* [IN] Pointer to Buffer Structure */
)
{
    static PBUFFER  psBuffer_tmp;
    psBuffer_tmp = psBuffer;
    switch(event_type)
    {
        case SCI_TRANSMIT_COMPLETE:
        {
            break;
        }
        case SCI_RECEIVE_COMPLETE:
        {
            if(g_read_enable == FALSE)
            {
                /* Disable Packet Decoding until there is a 
                Read call from app */
                PrepareRecvPcktHeader(PACKET_HEADER_SIZE);
                break;
            }
            
            switch(psBuffer->pBuffer[0])
            {
                case MASTER_SEND_HEADER:
                {

                    /* Master send header received */
                    PSERIAL_COMM pRxComm = &g_Serial.RxComm;
                    uint_16 recv_pkt_size = 
                        *(uint_16_ptr)(&psBuffer->pBuffer[1]);
                    
                    /* Change State to Wait Receive */
                    g_Serial.SerialFsm = SERIAL_WAIT_RECEIVE;
                    
                    /* We Prepare to receive data here */
                    pRxComm->Buff.pBuffer = (g_recv_buffer.pBuffer == NULL) ?
                        DummyRecvBuffer : g_recv_buffer.pBuffer;
                    pRxComm->Buff.Length = recv_pkt_size;
                    pRxComm->Buff.CurOffSet = 0;
                    
                    /* Setup Data receive */
                    (void)SCI_Read(controller_ID, &pRxComm->Buff);

					/* Send wait send response */
                    SendPktHeader(MASTER_SEND_ACK, 0);
                    break;
                }
                case MASTER_RECV_HEADER:
                {
                    /* Master receive header received */
                    uint_8 producer = g_send_queue.producer;
                    uint_8 consumer = g_send_queue.consumer;
                    uint_8 queue;
                    PTR_SERIAL_CLASS_BUFFER pserial_class_buffer;
                    
                    /* Queue not full */                    
                    if(producer != consumer)
                    {
                        uint_16 send_pkt_size;
                        
                        queue = (uint_8) 
                            (g_send_queue.consumer % MAX_XMIT_QUEUE_ELEMENTS);                        
                        pserial_class_buffer = 
                            &g_send_queue.class_buffer[queue];
                        
                        send_pkt_size = 
                            (uint_16)(pserial_class_buffer->transfer_size - 
                            pserial_class_buffer->cur_offset);
                        /* Change State to Transmit */
                        g_Serial.SerialFsm = SERIAL_WAIT_TRANSMIT;
                        /* Send wait recv response */
                        SendPktHeader(MASTER_RECV_ACK, 
                            MIN(send_pkt_size, g_Serial.MaxPktSize));
                    }
                    else
                    {
                        /* Prepare to receive next packet header */
                        PrepareRecvPcktHeader(PACKET_HEADER_SIZE);
                    }
                    break;
                }
                default:
                {
                    /* We have lost sync with Manager here */
                    /* Find our Marker */
                    if(psBuffer->CurOffSet < PACKET_HEADER_SIZE)
                    {
                        /* Prepare to receive header */
                        PrepareRecvPcktHeader(PACKET_HEADER_SIZE);
                    }
                    else
                    {
                        /* Find the error position and correct it */
                        uint_16 pos = FindMarker(psBuffer->pBuffer, 
                            psBuffer->CurOffSet);
                        PrepareRecvPcktHeader(pos);
                    }
                    break;
                }
            }
            break;
        }
        case SCI_RECEIVE_OVERRUN:
        case SCI_RECEIVE_NOISE_DETECTED:
        case SCI_RECEIVE_FRAME_ERROR:
        case SCI_RECEIVE_PARITY_ERROR:
        {
        }
    }
}