Ejemplo n.º 1
0
void 
msgUnpackSync(void *buf, MsgSync * sync)
{
	sync->originTimestamp.seconds = flip32(*(UInteger32 *) (buf + 40));
	DBGV("msgUnpackSync: originTimestamp.seconds %u\n", sync->originTimestamp.seconds);
	sync->originTimestamp.nanoseconds = flip32(*(Integer32 *) (buf + 44));
	DBGV("msgUnpackSync: originTimestamp.nanoseconds %d\n", sync->originTimestamp.nanoseconds);
	sync->epochNumber = flip16(*(UInteger16 *) (buf + 48));
	DBGV("msgUnpackSync: epochNumber %d\n", sync->epochNumber);
	sync->currentUTCOffset = flip16(*(Integer16 *) (buf + 50));
	DBGV("msgUnpackSync: currentUTCOffset %d\n", sync->currentUTCOffset);
	sync->grandmasterCommunicationTechnology = *(UInteger8 *) (buf + 53);
	DBGV("msgUnpackSync: grandmasterCommunicationTechnology %d\n", sync->grandmasterCommunicationTechnology);
	memcpy(sync->grandmasterClockUuid, (buf + 54), 6);
	DBGV("msgUnpackSync: grandmasterClockUuid %02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx\n",
	    sync->grandmasterClockUuid[0], sync->grandmasterClockUuid[1], sync->grandmasterClockUuid[2],
	    sync->grandmasterClockUuid[3], sync->grandmasterClockUuid[4], sync->grandmasterClockUuid[5]);
	sync->grandmasterPortId = flip16(*(UInteger16 *) (buf + 60));
	DBGV("msgUnpackSync: grandmasterPortId %d\n", sync->grandmasterPortId);
	sync->grandmasterSequenceId = flip16(*(UInteger16 *) (buf + 62));
	DBGV("msgUnpackSync: grandmasterSequenceId %d\n", sync->grandmasterSequenceId);
	sync->grandmasterClockStratum = *(UInteger8 *) (buf + 67);
	DBGV("msgUnpackSync: grandmasterClockStratum %d\n", sync->grandmasterClockStratum);
	memcpy(sync->grandmasterClockIdentifier, (buf + 68), 4);
	DBGV("msgUnpackSync: grandmasterClockIdentifier %c%c%c%c\n",
	    sync->grandmasterClockIdentifier[0], sync->grandmasterClockIdentifier[1],
	    sync->grandmasterClockIdentifier[2], sync->grandmasterClockIdentifier[3]);
	sync->grandmasterClockVariance = flip16(*(Integer16 *) (buf + 74));
	DBGV("msgUnpackSync: grandmasterClockVariance %d\n", sync->grandmasterClockVariance);
	sync->grandmasterPreferred = *(UInteger8 *) (buf + 77);
	DBGV("msgUnpackSync: grandmasterPreferred %d\n", sync->grandmasterPreferred);
	sync->grandmasterIsBoundaryClock = *(UInteger8 *) (buf + 79);
	DBGV("msgUnpackSync: grandmasterIsBoundaryClock %d\n", sync->grandmasterIsBoundaryClock);
	sync->syncInterval = *(Integer8 *) (buf + 83);
	DBGV("msgUnpackSync: syncInterval %d\n", sync->syncInterval);
	sync->localClockVariance = flip16(*(Integer16 *) (buf + 86));
	DBGV("msgUnpackSync: localClockVariance %d\n", sync->localClockVariance);
	sync->localStepsRemoved = flip16(*(UInteger16 *) (buf + 90));
	DBGV("msgUnpackSync: localStepsRemoved %d\n", sync->localStepsRemoved);
	sync->localClockStratum = *(UInteger8 *) (buf + 95);
	DBGV("msgUnpackSync: localClockStratum %d\n", sync->localClockStratum);
	memcpy(sync->localClockIdentifer, (buf + 96), PTP_CODE_STRING_LENGTH);
	DBGV("msgUnpackSync: localClockIdentifer %c%c%c%c\n",
	    sync->localClockIdentifer[0], sync->localClockIdentifer[1],
	    sync->localClockIdentifer[2], sync->localClockIdentifer[3]);
	sync->parentCommunicationTechnology = *(UInteger8 *) (buf + 101);
	DBGV("msgUnpackSync: parentCommunicationTechnology %d\n", sync->parentCommunicationTechnology);
	memcpy(sync->parentUuid, (buf + 102), PTP_UUID_LENGTH);
	DBGV("msgUnpackSync: parentUuid %02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx\n",
	    sync->parentUuid[0], sync->parentUuid[1], sync->parentUuid[2],
	    sync->parentUuid[3], sync->parentUuid[4], sync->parentUuid[5]);
	sync->parentPortField = flip16(*(UInteger16 *) (buf + 110));
	DBGV("msgUnpackSync: parentPortField %d\n", sync->parentPortField);
	sync->estimatedMasterVariance = flip16(*(Integer16 *) (buf + 114));
	DBGV("msgUnpackSync: estimatedMasterVariance %d\n", sync->estimatedMasterVariance);
	sync->estimatedMasterDrift = flip32(*(Integer32 *) (buf + 116));
	DBGV("msgUnpackSync: estimatedMasterDrift %d\n", sync->estimatedMasterDrift);
	sync->utcReasonable = *(UInteger8 *) (buf + 123);
	DBGV("msgUnpackSync: utcReasonable %d\n", sync->utcReasonable);
}
Ejemplo n.º 2
0
/*pack delayResp message into OUT buffer of ptpClock*/
void msgPackDelayResp(const PtpClock *ptpClock, Octet *buf, const MsgHeader *header, const Timestamp *receiveTimestamp)
{
    /*changes in header*/
    *(char*)(buf + 0) = *(char*)(buf + 0) & 0xF0; //RAZ messageType
    *(char*)(buf + 0) = *(char*)(buf + 0) | DELAY_RESP; //Table 19
    *(UInteger16*)(buf + 2) = flip16(DELAY_RESP_LENGTH);
    /* *(UInteger8*)(buf+4) = header->domainNumber; */ /* TODO: Why? */
    memset((buf + 8), 0, 8);

    /*Copy correctionField of delayReqMessage*/
    *(Integer32*)(buf + 8) = flip32(header->correctionfield >> 32);
    *(Integer32*)(buf + 12) = flip32((Integer32)header->correctionfield);

    *(UInteger16*)(buf + 30) = flip16(header->sequenceId);

    *(UInteger8*)(buf + 32) = CTRL_DELAY_RESP; //Table 23
    *(Integer8*)(buf + 33) = ptpClock->portDS.logMinDelayReqInterval; //Table 24

    /*delay_resp message*/
    *(UInteger16*)(buf + 34) = flip16(receiveTimestamp->secondsField.msb);
    *(UInteger32*)(buf + 36) = flip32(receiveTimestamp->secondsField.lsb);
    *(UInteger32*)(buf + 40) = flip32(receiveTimestamp->nanosecondsField);
    memcpy((buf + 44), header->sourcePortIdentity.clockIdentity, CLOCK_IDENTITY_LENGTH);
    *(UInteger16*)(buf + 52) = flip16(header->sourcePortIdentity.portNumber);
}
Ejemplo n.º 3
0
/*Unpack PdelayResp message from IN buffer of ptpClock to msgtmp.presp*/
void msgUnpackPDelayRespFollowUp(const Octet *buf, MsgPDelayRespFollowUp *prespfollow)
{
    prespfollow->responseOriginTimestamp.secondsField.msb = flip16(*(UInteger16*)(buf + 34));
    prespfollow->responseOriginTimestamp.secondsField.lsb = flip32(*(UInteger32*)(buf + 36));
    prespfollow->responseOriginTimestamp.nanosecondsField = flip32(*(UInteger32*)(buf + 40));
    memcpy(prespfollow->requestingPortIdentity.clockIdentity, (buf + 44), CLOCK_IDENTITY_LENGTH);
    prespfollow->requestingPortIdentity.portNumber = flip16(*(UInteger16*)(buf + 52));
}
Ejemplo n.º 4
0
/*Unpack delayResp message from IN buffer of ptpClock to msgtmp.presp*/
void msgUnpackDelayResp(const Octet *buf, MsgDelayResp *resp)
{
    resp->receiveTimestamp.secondsField.msb = flip16(*(UInteger16*)(buf + 34));
    resp->receiveTimestamp.secondsField.lsb = flip32(*(UInteger32*)(buf + 36));
    resp->receiveTimestamp.nanosecondsField = flip32(*(UInteger32*)(buf + 40));
    memcpy(resp->requestingPortIdentity.clockIdentity, (buf + 44), CLOCK_IDENTITY_LENGTH);
    resp->requestingPortIdentity.portNumber = flip16(*(UInteger16*)(buf + 52));
}
Ejemplo n.º 5
0
void msgUnpackFollowUp(void *buf, MsgFollowUp *follow)
{
  follow->associatedSequenceId = flip16(*(UInteger16*)((char*)buf + 42));
  DBGV("msgUnpackFollowUp: associatedSequenceId %u\n", follow->associatedSequenceId);
  follow->preciseOriginTimestamp.seconds = flip32(*(UInteger32*)((char*)buf + 44));
  DBGV("msgUnpackFollowUp: preciseOriginTimestamp.seconds %u\n", follow->preciseOriginTimestamp.seconds);
  follow->preciseOriginTimestamp.nanoseconds = flip32(*(Integer32*)((char*)buf + 48));
  DBGV("msgUnpackFollowUp: preciseOriginTimestamp.nanoseconds %d\n", follow->preciseOriginTimestamp.nanoseconds);
}
Ejemplo n.º 6
0
void msgPackFollowUp(void *buf, UInteger16 associatedSequenceId,
  TimeRepresentation *preciseOriginTimestamp, PtpClock *ptpClock)
{
  *(UInteger8*)((char*)buf + 20) = 2;  /* messageType */
  *(Integer32*)((char*)buf + 28) = shift16(flip16(ptpClock->port_id_field), 0) | shift16(flip16(ptpClock->last_general_event_sequence_number), 1);
  *(UInteger8*)((char*)buf + 32) = PTP_FOLLOWUP_MESSAGE;  /* control */
  clearFlag(((char*)buf + 34), PTP_SYNC_BURST);
  clearFlag(((char*)buf + 34), PARENT_STATS);
  
  *(Integer32*)((char*)buf + 40) = shift16(flip16(associatedSequenceId), 1);
  *(Integer32*)((char*)buf + 44) = flip32(preciseOriginTimestamp->seconds);
  *(Integer32*)((char*)buf + 48) = flip32(preciseOriginTimestamp->nanoseconds);
}
Ejemplo n.º 7
0
/*Unpack Announce message from IN buffer of ptpClock to msgtmp.Announce*/
void msgUnpackAnnounce(const Octet *buf, MsgAnnounce *announce)
{
    announce->originTimestamp.secondsField.msb = flip16(*(UInteger16*)(buf + 34));
    announce->originTimestamp.secondsField.lsb = flip32(*(UInteger32*)(buf + 36));
    announce->originTimestamp.nanosecondsField = flip32(*(UInteger32*)(buf + 40));
    announce->currentUtcOffset = flip16(*(UInteger16*)(buf + 44));
    announce->grandmasterPriority1 = *(UInteger8*)(buf + 47);
    announce->grandmasterClockQuality.clockClass = *(UInteger8*)(buf + 48);
    announce->grandmasterClockQuality.clockAccuracy = *(Enumeration8*)(buf + 49);
    announce->grandmasterClockQuality.offsetScaledLogVariance = flip16(*(UInteger16*)(buf + 50));
    announce->grandmasterPriority2 = *(UInteger8*)(buf + 52);
    memcpy(announce->grandmasterIdentity, (buf + 53), CLOCK_IDENTITY_LENGTH);
    announce->stepsRemoved = flip16(*(UInteger16*)(buf + 61));
    announce->timeSource = *(Enumeration8*)(buf + 63);
}
Ejemplo n.º 8
0
void msgPackDelayResp(void *buf, MsgHeader *header,
  TimeRepresentation *delayReceiptTimestamp, PtpClock *ptpClock)
{
  *(UInteger8*)((char*)buf + 20) = 2;  /* messageType */
  *(Integer32*)((char*)buf + 28) = shift16(flip16(ptpClock->port_id_field), 0) | shift16(flip16(ptpClock->last_general_event_sequence_number), 1);
  *(UInteger8*)((char*)buf + 32) = PTP_DELAY_RESP_MESSAGE;  /* control */
  clearFlag(((char*)buf + 34), PTP_SYNC_BURST);
  clearFlag(((char*)buf + 34), PARENT_STATS);
  
  *(Integer32*)((char*)buf + 40) = flip32(delayReceiptTimestamp->seconds);
  *(Integer32*)((char*)buf + 44) = flip32(delayReceiptTimestamp->nanoseconds);
  *(Integer32*)((char*)buf + 48) = shift8(header->sourceCommunicationTechnology, 1);
  memcpy((char*)buf + 50, header->sourceUuid, 6);
  *(Integer32*)((char*)buf + 56) = shift16(flip16(header->sourcePortId), 0) | shift16(flip16(header->sequenceId), 1);
}
Ejemplo n.º 9
0
/*pack Follow_up message into OUT buffer of ptpClock*/
void msgPackFollowUp(const PtpClock *ptpClock, Octet*buf, const Timestamp *preciseOriginTimestamp)
{
    /*changes in header*/
    *(char*)(buf + 0) = *(char*)(buf + 0) & 0xF0; //RAZ messageType
    *(char*)(buf + 0) = *(char*)(buf + 0) | FOLLOW_UP; //Table 19
    *(UInteger16*)(buf + 2) = flip16(FOLLOW_UP_LENGTH);
    *(UInteger16*)(buf + 30) = flip16(ptpClock->sentSyncSequenceId - 1);//sentSyncSequenceId has already been incremented in issueSync
    *(UInteger8*)(buf + 32) = CTRL_FOLLOW_UP; //Table 23
    *(Integer8*)(buf + 33) = ptpClock->portDS.logSyncInterval;

    /*Follow_up message*/
    *(UInteger16*)(buf + 34) = flip16(preciseOriginTimestamp->secondsField.msb);
    *(UInteger32*)(buf + 36) = flip32(preciseOriginTimestamp->secondsField.lsb);
    *(UInteger32*)(buf + 40) = flip32(preciseOriginTimestamp->nanosecondsField);
}
Ejemplo n.º 10
0
void miner_gen_nonce2_work(struct mm_work *mw, uint32_t nonce2, struct work *work)
{
	uint8_t merkle_root[32], merkle_sha[64];
	uint32_t *data32, *swap32, tmp32;
	int i;

	tmp32 = bswap_32(nonce2);
	memcpy(mw->coinbase + mw->nonce2_offset, (uint8_t *)(&tmp32), sizeof(uint32_t));
	work->nonce2 = nonce2;

	dsha256(mw->coinbase, mw->coinbase_len, merkle_root);
	memcpy(merkle_sha, merkle_root, 32);
	for (i = 0; i < mw->nmerkles; i++) {
		memcpy(merkle_sha + 32, mw->merkles[i], 32);
		dsha256(merkle_sha, 64, merkle_root);
		memcpy(merkle_sha, merkle_root, 32);
	}
	data32 = (uint32_t *)merkle_sha;
	swap32 = (uint32_t *)merkle_root;
	flip32(swap32, data32);

	memcpy(mw->header + mw->merkle_offset, merkle_root, 32);
	memcpy(work->header, mw->header, 128);
	
	calc_midstate(mw, work);
}
Ejemplo n.º 11
0
/*pack delayReq message into OUT buffer of ptpClock*/
void msgPackDelayReq(const PtpClock *ptpClock, Octet *buf, const Timestamp *originTimestamp)
{
    /*changes in header*/
    *(char*)(buf + 0) = *(char*)(buf + 0) & 0xF0; //RAZ messageType
    *(char*)(buf + 0) = *(char*)(buf + 0) | DELAY_REQ; //Table 19
    *(UInteger16*)(buf + 2) = flip16(DELAY_REQ_LENGTH);
    *(UInteger16*)(buf + 30) = flip16(ptpClock->sentDelayReqSequenceId);
    *(UInteger8*)(buf + 32) = CTRL_DELAY_REQ; //Table 23
    *(Integer8*)(buf + 33) = 0x7F; //Table 24
    memset((buf + 8), 0, 8);

    /*delay_req message*/
    *(UInteger16*)(buf + 34) = flip16(originTimestamp->secondsField.msb);
    *(UInteger32*)(buf + 36) = flip32(originTimestamp->secondsField.lsb);
    *(UInteger32*)(buf + 40) = flip32(originTimestamp->nanosecondsField);
}
Ejemplo n.º 12
0
/*Pack SYNC message into OUT buffer of ptpClock*/
void msgPackSync(const PtpClock *ptpClock, Octet *buf, const Timestamp *originTimestamp)
{
    /*changes in header*/
    *(char*)(buf + 0) = *(char*)(buf + 0) & 0xF0; //RAZ messageType
    *(char*)(buf + 0) = *(char*)(buf + 0) | SYNC; //Table 19
    *(UInteger16*)(buf + 2) = flip16(SYNC_LENGTH);
    *(UInteger16*)(buf + 30) = flip16(ptpClock->sentSyncSequenceId);
    *(UInteger8*)(buf + 32) = CTRL_SYNC; //Table 23
    *(Integer8*)(buf + 33) = ptpClock->portDS.logSyncInterval;
    memset((buf + 8), 0, 8); /* correction field */

    /*Sync message*/
    *(UInteger16*)(buf + 34) = flip16(originTimestamp->secondsField.msb);
    *(UInteger32*)(buf + 36) = flip32(originTimestamp->secondsField.lsb);
    *(UInteger32*)(buf + 40) = flip32(originTimestamp->nanosecondsField);
}
Ejemplo n.º 13
0
/* Used externally as confirmation of correct OCL code */
int blake256_test(unsigned char *pdata, const unsigned char *ptarget, uint32_t nonce)
{
	uint32_t tmp_hash7, Htarg = le32toh(((const uint32_t *)ptarget)[7]);
	uint32_t data[20], ohash[8];

	be32enc_vect(data, (const uint32_t *)pdata, 19);
	data[19] = nonce;
    
        applog(LOG_DEBUG, "Dat0: %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x", data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9],
            data[10], data[11], data[12], data[13], data[14], data[15], data[16], data[17], data[18], data[19]);
    
    sph_blake256_context     ctx_blake;
    static unsigned char pblank[1];
    sph_blake256_init(&ctx_blake);
    sph_blake256 (&ctx_blake, (unsigned char *)data, 80);
    sph_blake256_close(&ctx_blake, (unsigned char *)ohash);

	flip32(ohash, ohash); // Not needed for scrypt-chacha - mikaelh
    uint32_t *o = ohash;
	applog(LOG_DEBUG, "Nonce: %x, Output buffe0: %x %x %x %x %x %x %x %x", nonce, o[0], o[1], o[2], o[3], o[4], o[5], o[6], o[7]);
    
	tmp_hash7 = ohash[7];

	applog(LOG_DEBUG, "Nonce %x harget %08lx diff1 %08lx hash %08lx",
                                nonce,
				(long unsigned int)Htarg,
				(long unsigned int)diff1targ_blake256,
				(long unsigned int)tmp_hash7);
	if (tmp_hash7 > diff1targ_blake256)
		return -1;
	if (tmp_hash7 > Htarg)
		return 0;
	return 1;
}
Ejemplo n.º 14
0
void msgUnpackDelayResp(void *buf, MsgDelayResp *resp)
{
  resp->delayReceiptTimestamp.seconds = flip32(*(UInteger32*)((char*)buf + 40));
  DBGV("msgUnpackDelayResp: delayReceiptTimestamp.seconds %u\n", resp->delayReceiptTimestamp.seconds);
  resp->delayReceiptTimestamp.nanoseconds = flip32(*(Integer32*)((char*)buf + 44));
  DBGV("msgUnpackDelayResp: delayReceiptTimestamp.nanoseconds %d\n", resp->delayReceiptTimestamp.nanoseconds);
  resp->requestingSourceCommunicationTechnology = *(UInteger8*)((char*)buf + 49);
  DBGV("msgUnpackDelayResp: requestingSourceCommunicationTechnology %d\n", resp->requestingSourceCommunicationTechnology);
  memcpy(resp->requestingSourceUuid, ((char*)buf + 50), 6);
  DBGV("msgUnpackDelayResp: requestingSourceUuid %02x:%02x:%02x:%02x:%02x:%02x\n",
    resp->requestingSourceUuid[0], resp->requestingSourceUuid[1], resp->requestingSourceUuid[2],
    resp->requestingSourceUuid[3], resp->requestingSourceUuid[4], resp->requestingSourceUuid[5]);
  resp->requestingSourcePortId = flip16(*(UInteger16*)((char*)buf + 56));
  DBGV("msgUnpackDelayResp: requestingSourcePortId %d\n", resp->requestingSourcePortId);
  resp->requestingSourceSequenceId = flip16(*(UInteger16*)((char*)buf + 58));
  DBGV("msgUnpackDelayResp: requestingSourceSequenceId %d\n", resp->requestingSourceSequenceId);
}
Ejemplo n.º 15
0
/*pack PdelayRespfollowup message into OUT buffer of ptpClock*/
void msgPackPDelayRespFollowUp(Octet *buf, const MsgHeader *header, const Timestamp *responseOriginTimestamp)
{
    /*changes in header*/
    *(char*)(buf + 0) = *(char*)(buf + 0) & 0xF0; //RAZ messageType
    *(char*)(buf + 0) = *(char*)(buf + 0) | PDELAY_RESP_FOLLOW_UP; //Table 19
    *(UInteger16*)(buf + 2) = flip16(PDELAY_RESP_FOLLOW_UP_LENGTH);
    *(UInteger16*)(buf + 30) = flip16(header->sequenceId);
    *(UInteger8*)(buf + 32) = CTRL_OTHER; //Table 23
    *(Integer8*)(buf + 33) = 0x7F; //Table 24

    /*Copy correctionField of PdelayReqMessage*/
    *(Integer32*)(buf + 8) = flip32(header->correctionfield >> 32);
    *(Integer32*)(buf + 12) = flip32((Integer32)header->correctionfield);

    /*Pdelay_resp_follow_up message*/
    *(UInteger16*)(buf + 34) = flip16(responseOriginTimestamp->secondsField.msb);
    *(UInteger32*)(buf + 36) = flip32(responseOriginTimestamp->secondsField.lsb);
    *(UInteger32*)(buf + 40) = flip32(responseOriginTimestamp->nanosecondsField);
    memcpy((buf + 44), header->sourcePortIdentity.clockIdentity, CLOCK_IDENTITY_LENGTH);
    *(UInteger16*)(buf + 52) = flip16(header->sourcePortIdentity.portNumber);
}
Ejemplo n.º 16
0
void xcoin_regenhash(struct work *work)
{
        uint32_t data[20];
        char *scratchbuf;
        uint32_t *nonce = (uint32_t *)(work->data + 76);
        uint32_t *ohash = (uint32_t *)(work->hash);

        be32enc_vect(data, (const uint32_t *)work->data, 19);
        data[19] = htobe32(*nonce);
        xhash(ohash, data);
        flip32(ohash, ohash);
}
Ejemplo n.º 17
0
/*Unpack Header from IN buffer to msgTmpHeader field */
void msgUnpackHeader(const Octet *buf, MsgHeader *header)
{
    Integer32 msb;
    UInteger32 lsb;

    header->transportSpecific = (*(Nibble*)(buf + 0)) >> 4;
    header->messageType = (*(Enumeration4*)(buf + 0)) & 0x0F;
    header->versionPTP = (*(UInteger4*)(buf + 1)) & 0x0F; //force reserved bit to zero if not
    header->messageLength = flip16(*(UInteger16*)(buf + 2));
    header->domainNumber = (*(UInteger8*)(buf + 4));
    memcpy(header->flagField, (buf + 6), FLAG_FIELD_LENGTH);
    memcpy(&msb, (buf + 8), 4);
    memcpy(&lsb, (buf + 12), 4);
    header->correctionfield = flip32(msb);
    header->correctionfield <<= 32;
    header->correctionfield += flip32(lsb);
    memcpy(header->sourcePortIdentity.clockIdentity, (buf + 20), CLOCK_IDENTITY_LENGTH);
    header->sourcePortIdentity.portNumber = flip16(*(UInteger16*)(buf + 28));
    header->sequenceId = flip16(*(UInteger16*)(buf + 30));
    header->controlField = (*(UInteger8*)(buf + 32));
    header->logMessageInterval = (*(Integer8*)(buf + 33));
}
Ejemplo n.º 18
0
void 
msgPackSync(void *buf, Boolean burst,
    TimeRepresentation * originTimestamp, PtpClock * ptpClock)
{
	*(UInteger8 *) (buf + 20) = 1;	/* messageType */
	*(Integer32 *) (buf + 28) = shift16(flip16(ptpClock->port_id_field), 0) | shift16(flip16(ptpClock->last_sync_event_sequence_number), 1);
	*(UInteger8 *) (buf + 32) = PTP_SYNC_MESSAGE;	/* control */
	if (ptpClock->burst_enabled && burst)
		setFlag((buf + 34), PTP_SYNC_BURST);
	else
		clearFlag((buf + 34), PTP_SYNC_BURST);
	if (ptpClock->parent_stats)
		setFlag((buf + 34), PARENT_STATS);
	else
		clearFlag((buf + 34), PARENT_STATS);


	*(Integer32 *) (buf + 40) = flip32(originTimestamp->seconds);
	*(Integer32 *) (buf + 44) = flip32(originTimestamp->nanoseconds);
	*(Integer32 *) (buf + 48) = shift16(flip16(ptpClock->epoch_number), 0) | shift16(flip16(ptpClock->current_utc_offset), 1);
	*(Integer32 *) (buf + 52) = shift8(ptpClock->grandmaster_communication_technology, 1);
	memcpy((buf + 54), ptpClock->grandmaster_uuid_field, 6);
	*(Integer32 *) (buf + 60) = shift16(flip16(ptpClock->grandmaster_port_id_field), 0) | shift16(flip16(ptpClock->grandmaster_sequence_number), 1);
	*(Integer32 *) (buf + 64) = shift8(ptpClock->grandmaster_stratum, 3);
	memcpy((buf + 68), ptpClock->grandmaster_identifier, 4);
	*(Integer32 *) (buf + 72) = shift16(flip16(ptpClock->grandmaster_variance), 1);
	*(Integer32 *) (buf + 76) = shift16(flip16(ptpClock->grandmaster_preferred), 0) | shift16(flip16(ptpClock->grandmaster_is_boundary_clock), 1);
	*(Integer32 *) (buf + 80) = shift16(flip16(ptpClock->sync_interval), 1);
	*(Integer32 *) (buf + 84) = shift16(flip16(ptpClock->clock_variance), 1);
	*(Integer32 *) (buf + 88) = shift16(flip16(ptpClock->steps_removed), 1);
	*(Integer32 *) (buf + 92) = shift8(ptpClock->clock_stratum, 3);
	memcpy((buf + 96), ptpClock->clock_identifier, 4);
	*(Integer32 *) (buf + 100) = shift8(ptpClock->parent_communication_technology, 1);
	memcpy((buf + 102), ptpClock->parent_uuid, 6);
	*(Integer32 *) (buf + 108) = shift16(flip16(ptpClock->parent_port_id), 1);
	*(Integer32 *) (buf + 112) = shift16(flip16(ptpClock->observed_variance), 1);
	*(Integer32 *) (buf + 116) = flip32(ptpClock->observed_drift);
	*(Integer32 *) (buf + 120) = shift8(ptpClock->utc_reasonable, 3);
}
Ejemplo n.º 19
0
void scrypt_regenhash(struct work *work)
{
	uint32_t data[20];
	char *scratchbuf;
	uint32_t *nonce = (uint32_t *)(work->data + 76);
	uint32_t *ohash = (uint32_t *)(work->hash);

	be32enc_vect(data, (const uint32_t *)work->data, 19);
	data[19] = htobe32(*nonce);
	scratchbuf = (char *)alloca(SCRATCHBUF_SIZE);
	scrypt_1024_1_1_256_sp(data, scratchbuf, ohash);
	flip32(ohash, ohash);
}
Ejemplo n.º 20
0
/*pack PdelayResp message into OUT buffer of ptpClock*/
void msgPackPDelayResp(Octet *buf, const MsgHeader *header, const Timestamp *requestReceiptTimestamp)
{
    /*changes in header*/
    *(char*)(buf + 0) = *(char*)(buf + 0) & 0xF0; //RAZ messageType
    *(char*)(buf + 0) = *(char*)(buf + 0) | PDELAY_RESP; //Table 19
    *(UInteger16*)(buf + 2) = flip16(PDELAY_RESP_LENGTH);
    /* *(UInteger8*)(buf+4) = header->domainNumber; */ /* TODO: Why? */
    memset((buf + 8), 0, 8);


    *(UInteger16*)(buf + 30) = flip16(header->sequenceId);

    *(UInteger8*)(buf + 32) = CTRL_OTHER; //Table 23
    *(Integer8*)(buf + 33) = 0x7F; //Table 24

    /*Pdelay_resp message*/
    *(UInteger16*)(buf + 34) = flip16(requestReceiptTimestamp->secondsField.msb);
    *(UInteger32*)(buf + 36) = flip32(requestReceiptTimestamp->secondsField.lsb);
    *(UInteger32*)(buf + 40) = flip32(requestReceiptTimestamp->nanosecondsField);
    memcpy((buf + 44), header->sourcePortIdentity.clockIdentity, CLOCK_IDENTITY_LENGTH);
    *(UInteger16*)(buf + 52) = flip16(header->sourcePortIdentity.portNumber);

}
Ejemplo n.º 21
0
static void calc_midstate(struct mm_work *mw, struct work *work)
{
	unsigned char data[64];
	uint32_t *data32 = (uint32_t *)data;

	flip64(data32, mw->header);

	sha256_init();
	sha256_update(data, 64);
	sha256_final(work->data);

	memcpy(data, work->data, 32);
	flip32(work->data, data);
	
	memcpy(work->data + 32, mw->header + 64, 12);
}
Ejemplo n.º 22
0
void scrypt_regenhash(struct work *work)
{
	uint32_t data[20];
	char *scratchbuf;
	uint32_t timestamp;
	cl_uint nfactor = 10;    // scrypt default	
	uint32_t *nonce = (uint32_t *)(work->data + 76);
	uint32_t *ohash = (uint32_t *)(work->hash);
 	
	//if (opt_scrypt_vert) {
		timestamp = bswap_32(*((uint32_t *)(work->data + 17*4)));
 		nfactor = alt_GetNfactor(timestamp) + 1;
  //}	

	be32enc_vect(data, (const uint32_t *)work->data, 19);
	data[19] = htobe32(*nonce);
	//scratchbuf = alloca(SCRATCHBUF_SIZE);
	scratchbuf = alloca((1 << nfactor) * 128 + 512);
	scrypt_1024_1_1_256_sp(data, scratchbuf, ohash, (1 << nfactor));
	flip32(ohash, ohash);
}
Ejemplo n.º 23
0
void calc_prepare1(struct work *work, uint8_t *buf)
{
	sha256_ctx ctx;
	unsigned char digest[32];

	sha256_init(&ctx, buf);

	memcpy(digest + 0, buf + 32 + 8, 4);
	memcpy(digest + 4, buf + 32 + 4, 4);
	memcpy(digest + 8, buf + 32 + 0, 4);

	sha256_update(&ctx, digest, 12);
	sha256_final(&ctx, digest);

	memcpy(work->a0, digest + 8, 4);
	memcpy(work->a1, digest + 4, 4);
	memcpy(work->a2, digest + 0, 4);
	memcpy(work->e0, digest + 24, 4);
	memcpy(work->e1, digest + 20, 4);
	memcpy(work->e2, digest + 16, 4);
	flip32(digest, digest);
}
Ejemplo n.º 24
0
void scrypt_regenhash(struct work *work)
{
	uint32_t data[20];
	char *scratchbuf;
	uint32_t timestamp;
	cl_uint nfactor = 10;    // scrypt default	
	uint32_t *nonce = (uint32_t *)(work->data + 76);
	uint32_t *ohash = (uint32_t *)(work->hash);
 	
	if (opt_nscrypt) {
		timestamp = bswap_32(*((uint32_t *)(work->data + 17*4)));

		// find a way to implement r/m learning -- simulate it for the miners
 	//	nfactor = vert_GetNfactor(timestamp) + 1;
 		nfactor = hin_getNFactor(work->work_block,work->work_difficulty) + 1;
	}	

	be32enc_vect(data, (const uint32_t *)work->data, 19);
	data[19] = htobe32(*nonce);
	//scratchbuf = alloca(SCRATCHBUF_SIZE);
	scratchbuf = alloca((1 << nfactor) * 128 + 512);
	scrypt_1024_1_1_256_sp(data, scratchbuf, ohash, (1 << nfactor));
	flip32(ohash, ohash);
}
Ejemplo n.º 25
0
UInteger16 msgPackManagementResponse(void *buf, MsgHeader *header, MsgManagement *manage, PtpClock *ptpClock)
{
  TimeInternal internalTime;
  TimeRepresentation externalTime;
  
  *(UInteger8*)((char*)buf + 20) = 2;  /* messageType */
  *(Integer32*)((char*)buf + 28) = shift16(flip16(ptpClock->port_id_field), 0) | shift16(flip16(ptpClock->last_general_event_sequence_number), 1);
  *(UInteger8*)((char*)buf + 32) = PTP_MANAGEMENT_MESSAGE;  /* control */
  clearFlag(((char*)buf + 34), PTP_SYNC_BURST);
  clearFlag(((char*)buf + 34), PARENT_STATS);
  *(Integer32*)((char*)buf + 40) = shift8(header->sourceCommunicationTechnology, 1);
  memcpy((char*)buf + 42, header->sourceUuid, 6);
  *(Integer32*)((char*)buf + 48) = shift16(flip16(header->sourcePortId), 0) | shift16(flip16(MM_STARTING_BOUNDARY_HOPS), 1);
  *(Integer32*)((char*)buf + 52) = shift16(flip16(manage->startingBoundaryHops - manage->boundaryHops + 1), 0);
  
  switch(manage->managementMessageKey)
  {
  case PTP_MM_OBTAIN_IDENTITY:
    *(UInteger8*)((char*)buf + 55) = PTP_MM_CLOCK_IDENTITY;
    *(Integer32*)((char*)buf + 56) = shift16(flip16(64), 1);
    *(Integer32*)((char*)buf + 60) = shift8(ptpClock->clock_communication_technology, 3);
    memcpy((char*)buf + 64, ptpClock->clock_uuid_field, 6);
    *(Integer32*)((char*)buf + 72) = shift16(flip16(ptpClock->clock_port_id_field), 1);
    memcpy(((char*)buf + 76), MANUFACTURER_ID, 48);
    return 124;
    
  case PTP_MM_GET_DEFAULT_DATA_SET:
    *(UInteger8*)((char*)buf + 55) = PTP_MM_DEFAULT_DATA_SET;
    *(Integer32*)((char*)buf + 56) = shift16(flip16(76), 1);
    *(Integer32*)((char*)buf + 60) = shift8(ptpClock->clock_communication_technology, 3);
    memcpy((char*)buf + 64, ptpClock->clock_uuid_field, 6);
    *(Integer32*)((char*)buf + 72) = shift16(flip16(ptpClock->clock_port_id_field), 1);
    *(Integer32*)((char*)buf + 76) = shift8(ptpClock->clock_stratum, 3);
    memcpy((char*)buf + 80, ptpClock->clock_identifier, 4);
    *(Integer32*)((char*)buf + 84) = shift16(flip16(ptpClock->clock_variance), 1);
    *(Integer32*)((char*)buf + 88) = shift8(ptpClock->clock_followup_capable, 3);
    *(Integer32*)((char*)buf + 92) = shift8(ptpClock->preferred, 3);
    *(Integer32*)((char*)buf + 96) = shift8(ptpClock->initializable, 3);
    *(Integer32*)((char*)buf + 100) = shift8(ptpClock->external_timing, 3);
    *(Integer32*)((char*)buf + 104) = shift8(ptpClock->is_boundary_clock, 3);
    *(Integer32*)((char*)buf + 108) = shift8(ptpClock->sync_interval, 3);
    memcpy((char*)buf + 112, ptpClock->subdomain_name, 16);
    *(Integer32*)((char*)buf + 128) = shift16(flip16(ptpClock->number_ports), 1);
    *(Integer32*)((char*)buf + 132) = shift16(flip16(ptpClock->number_foreign_records), 1);
    return 136;
    
  case PTP_MM_GET_CURRENT_DATA_SET:
    *(UInteger8*)((char*)buf + 55) = PTP_MM_CURRENT_DATA_SET;
    *(Integer32*)((char*)buf + 56) = shift16(flip16(20), 1);
    *(Integer32*)((char*)buf + 60) = shift16(flip16(ptpClock->steps_removed), 1);
    
    fromInternalTime(&ptpClock->offset_from_master, &externalTime, 0);
    *(Integer32*)((char*)buf + 64) = flip32(externalTime.seconds);
    *(Integer32*)((char*)buf + 68) = flip32(externalTime.nanoseconds);
    
    fromInternalTime(&ptpClock->one_way_delay, &externalTime, 0);
    *(Integer32*)((char*)buf + 72) = flip32(externalTime.seconds);
    *(Integer32*)((char*)buf + 76) = flip32(externalTime.nanoseconds);
    return 80;
    
  case PTP_MM_GET_PARENT_DATA_SET:
    *(UInteger8*)((char*)buf + 55) = PTP_MM_PARENT_DATA_SET;
    *(Integer32*)((char*)buf + 56) = shift16(flip16(90), 1);
    *(Integer32*)((char*)buf + 60) = shift8(ptpClock->parent_communication_technology, 3);
    memcpy((char*)buf + 64, ptpClock->parent_uuid, 6);
    *(Integer32*)((char*)buf + 72) = shift16(flip16(ptpClock->parent_port_id), 1);
    *(Integer32*)((char*)buf + 76) = shift16(flip16(ptpClock->parent_last_sync_sequence_number), 1);
    *(Integer32*)((char*)buf + 80) = shift8(ptpClock->parent_followup_capable, 1);
    *(Integer32*)((char*)buf + 84) = shift8(ptpClock->parent_external_timing, 3);
    *(Integer32*)((char*)buf + 88) = shift16(flip16(ptpClock->parent_variance), 1);
    *(Integer32*)((char*)buf + 92) = shift8(ptpClock->parent_stats, 3);
    *(Integer32*)((char*)buf + 96) = shift16(flip16(ptpClock->observed_variance), 1);
    *(Integer32*)((char*)buf + 100) = flip32(ptpClock->observed_drift);
    *(Integer32*)((char*)buf + 104) = shift8(ptpClock->utc_reasonable, 3);
    *(Integer32*)((char*)buf + 108) = shift8(ptpClock->grandmaster_communication_technology, 3);
    memcpy((char*)buf + 112, ptpClock->grandmaster_uuid_field, 6);
    *(Integer32*)((char*)buf + 120) = shift16(flip16(ptpClock->grandmaster_port_id_field), 1);
    *(Integer32*)((char*)buf + 124) = shift8(ptpClock->grandmaster_stratum, 3);
    memcpy((char*)buf + 128, ptpClock->grandmaster_identifier, 4);
    *(Integer32*)((char*)buf + 132) = shift16(flip16(ptpClock->grandmaster_variance), 1);
    *(Integer32*)((char*)buf + 136) = shift8(ptpClock->grandmaster_preferred, 3);
    *(Integer32*)((char*)buf + 140) = shift8(ptpClock->grandmaster_is_boundary_clock, 3);
    *(Integer32*)((char*)buf + 144) = shift16(flip16(ptpClock->grandmaster_sequence_number), 1);
    return 148;
    
  case PTP_MM_GET_PORT_DATA_SET:
    if(manage->targetPortId && manage->targetPortId != ptpClock->port_id_field)
    {
      *(UInteger8*)((char*)buf + 55) = PTP_MM_NULL;
      *(Integer32*)((char*)buf + 56) = shift16(flip16(0), 1);
      return 0;
    }
    
    *(UInteger8*)((char*)buf + 55) = PTP_MM_PORT_DATA_SET;
    *(Integer32*)((char*)buf + 56) = shift16(flip16(52), 1);
    *(Integer32*)((char*)buf + 60) = shift16(flip16(ptpClock->port_id_field), 1);
    *(Integer32*)((char*)buf + 64) = shift8(ptpClock->port_state, 3);
    *(Integer32*)((char*)buf + 68) = shift16(flip16(ptpClock->last_sync_event_sequence_number), 1);
    *(Integer32*)((char*)buf + 72) = shift16(flip16(ptpClock->last_general_event_sequence_number), 1);
    *(Integer32*)((char*)buf + 76) = shift8(ptpClock->port_communication_technology, 3);
    memcpy((char*)buf + 80, ptpClock->port_uuid_field, 6);
    *(Integer32*)((char*)buf + 88) = shift16(flip16(ptpClock->port_id_field), 1);
    *(Integer32*)((char*)buf + 92) = shift8(ptpClock->burst_enabled, 3);
    *(Integer32*)((char*)buf + 96) = shift8(4, 1) | shift8(2, 2) | shift8(2, 3);
    memcpy((char*)buf + 100, ptpClock->subdomain_address, 4);
    memcpy((char*)buf + 106, ptpClock->event_port_address, 2);
    memcpy((char*)buf + 110, ptpClock->general_port_address, 2);
    return 112;
    
  case PTP_MM_GET_GLOBAL_TIME_DATA_SET:
    *(UInteger8*)((char*)buf + 55) = PTP_MM_GLOBAL_TIME_DATA_SET;
    *(Integer32*)((char*)buf + 56) = shift16(flip16(24), 1);
    
    getTime(&internalTime);
    fromInternalTime(&internalTime, &externalTime, ptpClock->halfEpoch);
    *(Integer32*)((char*)buf + 60) = flip32(externalTime.seconds);
    *(Integer32*)((char*)buf + 64) = flip32(externalTime.nanoseconds);
    
    *(Integer32*)((char*)buf + 68) = shift16(flip16(ptpClock->current_utc_offset), 1);
    *(Integer32*)((char*)buf + 72) = shift8(ptpClock->leap_59, 3);
    *(Integer32*)((char*)buf + 76) = shift8(ptpClock->leap_61, 3);
    *(Integer32*)((char*)buf + 80) = shift16(flip16(ptpClock->epoch_number), 1);
    return 84;
    
  case PTP_MM_GET_FOREIGN_DATA_SET:
    if((manage->targetPortId && manage->targetPortId != ptpClock->port_id_field)
      || !manage->recordKey || manage->recordKey > ptpClock->number_foreign_records)
    {
      *(UInteger8*)((char*)buf + 55) = PTP_MM_NULL;
      *(Integer32*)((char*)buf + 56) = shift16(flip16(0), 1);
      return 0;
    }
    
    *(UInteger8*)((char*)buf + 55) = PTP_MM_FOREIGN_DATA_SET;
    *(Integer32*)((char*)buf + 56) = shift16(flip16(28), 1);
    *(Integer32*)((char*)buf + 60) = shift16(flip16(ptpClock->port_id_field), 1);
    *(Integer32*)((char*)buf + 64) = shift16(flip16(manage->recordKey - 1), 1);
    *(Integer32*)((char*)buf + 68) = shift8(ptpClock->foreign[manage->recordKey - 1].foreign_master_communication_technology, 3);
    memcpy((char*)buf + 72, ptpClock->foreign[manage->recordKey - 1].foreign_master_uuid, 6);
    *(Integer32*)((char*)buf + 80) = shift16(flip16(ptpClock->foreign[manage->recordKey - 1].foreign_master_port_id), 1);
    *(Integer32*)((char*)buf + 84) = shift16(flip16(ptpClock->foreign[manage->recordKey - 1].foreign_master_syncs), 1);
    return 88;
    
  default:
    return 0;
  }
}
Ejemplo n.º 26
0
/*Unpack Follow_up message from IN buffer of ptpClock to msgtmp.follow*/
void msgUnpackFollowUp(const Octet *buf, MsgFollowUp *follow)
{
    follow->preciseOriginTimestamp.secondsField.msb = flip16(*(UInteger16*)(buf + 34));
    follow->preciseOriginTimestamp.secondsField.lsb = flip32(*(UInteger32*)(buf + 36));
    follow->preciseOriginTimestamp.nanosecondsField = flip32(*(UInteger32*)(buf + 40));
}
Ejemplo n.º 27
0
/*Unpack PdelayReq message from IN buffer of ptpClock to msgtmp.req*/
void msgUnpackPDelayReq(const Octet *buf, MsgPDelayReq *pdelayreq)
{
    pdelayreq->originTimestamp.secondsField.msb = flip16(*(UInteger16*)(buf + 34));
    pdelayreq->originTimestamp.secondsField.lsb = flip32(*(UInteger32*)(buf + 36));
    pdelayreq->originTimestamp.nanosecondsField = flip32(*(UInteger32*)(buf + 40));
}
Ejemplo n.º 28
0
void msgUnpackManagementPayload(void *buf, MsgManagement *manage)
{
  switch(manage->managementMessageKey)
  {
  case PTP_MM_CLOCK_IDENTITY:
    DBGV("msgUnloadManagementPayload: managementMessageKey PTP_MM_CLOCK_IDENTITY\n");
    manage->payload.clockIdentity.clockCommunicationTechnology = *(UInteger8*)((char*)buf + 63);
    memcpy(manage->payload.clockIdentity.clockUuidField, (char*)buf + 64, PTP_UUID_LENGTH);
    manage->payload.clockIdentity.clockPortField = flip16(*(UInteger16*)((char*)buf + 74));
    memcpy(manage->payload.clockIdentity.manufacturerIdentity, (char*)buf + 76, MANUFACTURER_ID_LENGTH);
    break;
    
  case PTP_MM_DEFAULT_DATA_SET:
    DBGV("msgUnloadManagementPayload: managementMessageKey PTP_MM_DEFAULT_DATA_SET\n");
    manage->payload.defaultData.clockCommunicationTechnology = *(UInteger8*)((char*)buf + 63);
    memcpy(manage->payload.defaultData.clockUuidField, (char*)buf + 64, PTP_UUID_LENGTH); 
    manage->payload.defaultData.clockPortField = flip16(*(UInteger16*)((char*)buf + 74));
    manage->payload.defaultData.clockStratum = *(UInteger8*)((char*)buf + 79);
    memcpy(manage->payload.defaultData.clockIdentifier, (char*)buf + 80, PTP_CODE_STRING_LENGTH);
    manage->payload.defaultData.clockVariance = flip16(*(UInteger16*)((char*)buf + 86));
    manage->payload.defaultData.clockFollowupCapable = *(UInteger8*)((char*)buf + 91);
    manage->payload.defaultData.preferred = *(UInteger8*)((char*)buf + 95);
    manage->payload.defaultData.initializable = *(UInteger8*)((char*)buf + 99);
    manage->payload.defaultData.externalTiming = *(UInteger8*)((char*)buf + 103);
    manage->payload.defaultData.isBoundaryClock = *(UInteger8*)((char*)buf + 107);
    manage->payload.defaultData.syncInterval = *(UInteger8*)((char*)buf + 111);
    memcpy(manage->payload.defaultData.subdomainName, (char*)buf + 112, PTP_SUBDOMAIN_NAME_LENGTH);
    manage->payload.defaultData.numberPorts = flip16(*(UInteger16*)((char*)buf + 130));
    manage->payload.defaultData.numberForeignRecords = flip16(*(UInteger16*)((char*)buf + 134));
    break;
    
  case PTP_MM_CURRENT_DATA_SET:
    DBGV("msgUnloadManagementPayload: managementMessageKey PTP_MM_CURRENT_DATA_SET\n");
    manage->payload.current.stepsRemoved = flip16(*(UInteger16*)((char*)buf + 62));
    manage->payload.current.offsetFromMaster.seconds = flip32(*(UInteger32*)((char*)buf + 64));
    manage->payload.current.offsetFromMaster.nanoseconds = flip32(*(UInteger32*)((char*)buf + 68));
    manage->payload.current.oneWayDelay.seconds = flip32(*(UInteger32*)((char*)buf + 72));
    manage->payload.current.oneWayDelay.nanoseconds = flip32(*(Integer32*)((char*)buf + 76));
    break;
    
  case PTP_MM_PARENT_DATA_SET:
    DBGV("msgUnloadManagementPayload: managementMessageKey PTP_MM_PORT_DATA_SET\n");
    manage->payload.parent.parentCommunicationTechnology = *(UInteger8*)((char*)buf + 63);
    memcpy(manage->payload.parent.parentUuid, (char*)buf + 64, PTP_UUID_LENGTH);
    manage->payload.parent.parentPortId = flip16(*(UInteger16*)((char*)buf + 74));
    manage->payload.parent.parentLastSyncSequenceNumber = flip16(*(UInteger16*)((char*)buf + 74));
    manage->payload.parent.parentFollowupCapable = *(UInteger8*)((char*)buf + 83);
    manage->payload.parent.parentExternalTiming = *(UInteger8*)((char*)buf + 87);
    manage->payload.parent.parentVariance = flip16(*(UInteger16*)((char*)buf + 90));
    manage->payload.parent.parentStats = *(UInteger8*)((char*)buf + 85);
    manage->payload.parent.observedVariance = flip16(*(Integer16*)((char*)buf + 98));
    manage->payload.parent.observedDrift = flip32(*(Integer32*)((char*)buf + 100));
    manage->payload.parent.utcReasonable = *(UInteger8*)((char*)buf + 107);
    manage->payload.parent.grandmasterCommunicationTechnology = *(UInteger8*)((char*)buf + 111);
    memcpy(manage->payload.parent.grandmasterUuidField, (char*)buf + 112, PTP_UUID_LENGTH);
    manage->payload.parent.grandmasterPortIdField = flip16(*(UInteger16*)((char*)buf + 122));
    manage->payload.parent.grandmasterStratum = *(UInteger8*)((char*)buf + 127);
    memcpy(manage->payload.parent.grandmasterIdentifier, (char*)buf + 128, PTP_CODE_STRING_LENGTH);
    manage->payload.parent.grandmasterVariance = flip16(*(Integer16*)((char*)buf + 134));
    manage->payload.parent.grandmasterPreferred = *(UInteger8*)((char*)buf + 139);
    manage->payload.parent.grandmasterIsBoundaryClock = *(UInteger8*)((char*)buf + 144);
    manage->payload.parent.grandmasterSequenceNumber = flip16(*(UInteger16*)((char*)buf + 146));
    break;
    
  case PTP_MM_PORT_DATA_SET:
    DBGV("msgUnloadManagementPayload: managementMessageKey PTP_MM_FOREIGN_DATA_SET\n");
    manage->payload.port.returnedPortNumber = flip16(*(UInteger16*)((char*)buf + 62));
    manage->payload.port.portState = *(UInteger8*)((char*)buf + 67);
    manage->payload.port.lastSyncEventSequenceNumber = flip16(*(UInteger16*)((char*)buf + 70));
    manage->payload.port.lastGeneralEventSequenceNumber = flip16(*(UInteger16*)((char*)buf + 74));
    manage->payload.port.portCommunicationTechnology = *(UInteger8*)((char*)buf + 79);
    memcpy(manage->payload.port.portUuidField, (char*)buf + 80, PTP_UUID_LENGTH);
    manage->payload.port.portIdField = flip16(*(UInteger16*)((char*)buf + 90));
    manage->payload.port.burstEnabled = *(UInteger8*)((char*)buf + 95);
    manage->payload.port.subdomainAddressOctets = *(UInteger8*)((char*)buf + 97);
    manage->payload.port.eventPortAddressOctets = *(UInteger8*)((char*)buf + 98);
    manage->payload.port.generalPortAddressOctets = *(UInteger8*)((char*)buf + 99);
    memcpy(manage->payload.port.subdomainAddress, (char*)buf + 100, SUBDOMAIN_ADDRESS_LENGTH);
    memcpy(manage->payload.port.eventPortAddress, (char*)buf + 106, PORT_ADDRESS_LENGTH);
    memcpy(manage->payload.port.generalPortAddress, (char*)buf + 110, PORT_ADDRESS_LENGTH);
    break;
  
  case PTP_MM_GLOBAL_TIME_DATA_SET:
    DBGV("msgUnloadManagementPayload: managementMessageKey PTP_MM_GLOBAL_TIME_DATA_SET\n");
    manage->payload.globalTime.localTime.seconds = flip32(*(UInteger32*)((char*)buf + 60));
    manage->payload.globalTime.localTime.nanoseconds = flip32(*(Integer32*)((char*)buf + 64));
    manage->payload.globalTime.currentUtcOffset = flip16(*(Integer16*)((char*)buf + 70));
    manage->payload.globalTime.leap59 = *(UInteger8*)((char*)buf + 75);
    manage->payload.globalTime.leap61 = *(UInteger8*)((char*)buf + 79);
    manage->payload.globalTime.epochNumber = flip16(*(UInteger16*)((char*)buf + 82));
    break;
    
    
  case PTP_MM_FOREIGN_DATA_SET:
    DBGV("msgUnloadManagementPayload: managementMessageKey PTP_MM_FOREIGN_DATA_SET\n");
    manage->payload.foreign.returnedPortNumber = flip16(*(UInteger16*)((char*)buf + 62));
    manage->payload.foreign.returnedRecordNumber = flip16(*(UInteger16*)((char*)buf + 68));
    manage->payload.foreign.foreignMasterCommunicationTechnology = *(UInteger8*)((char*)buf + 71);
    memcpy(manage->payload.foreign.foreignMasterUuid, (char*)buf + 72, PTP_UUID_LENGTH);
    manage->payload.foreign.foreignMasterPortId = flip16(*(UInteger16*)((char*)buf + 82));
    manage->payload.foreign.foreignMasterSyncs = flip16(*(UInteger16*)((char*)buf + 66));
    break;
    
  case PTP_MM_NULL:
    DBGV("msgUnloadManagementPayload: managementMessageKey NULL\n");
    break;
    
  default:
    DBGV("msgUnloadManagementPayload: managementMessageKey ?\n");
    break;
  }
  
  return;
}
Ejemplo n.º 29
0
UInteger8 msgUnloadManagement(void *buf, MsgManagement *manage,
  PtpClock *ptpClock, RunTimeOpts *rtOpts)
{
  TimeInternal internalTime;
  TimeRepresentation externalTime;
  
  switch(manage->managementMessageKey)
  {
  case PTP_MM_INITIALIZE_CLOCK:
    if(ptpClock->initializable)
      return PTP_INITIALIZING;
    break;
    
  case PTP_MM_GOTO_FAULTY_STATE:
    DBG("event FAULT_DETECTED (forced by management message)\n");
    return PTP_FAULTY;
    break;
    
  case PTP_MM_DISABLE_PORT:
    if(manage->targetPortId == 1)
    {
      DBG("event DESIGNATED_DISABLED\n");
      return PTP_DISABLED;
    }
    break;
    
  case PTP_MM_ENABLE_PORT:
    if(manage->targetPortId == 1)
    {
      DBG("event DESIGNATED_ENABLED\n");
      return PTP_INITIALIZING;
    }
    break;
    
  case PTP_MM_CLEAR_DESIGNATED_PREFERRED_MASTER:
    ptpClock->preferred = FALSE;
    break;
      
  case PTP_MM_SET_DESIGNATED_PREFERRED_MASTER:
    ptpClock->preferred = TRUE;
    break;
    
  case PTP_MM_DISABLE_BURST:
    break;
    
  case PTP_MM_ENABLE_BURST:
    break;
    
  case PTP_MM_SET_SYNC_INTERVAL:
    rtOpts->syncInterval = *(Integer8*)((char*)buf + 63);
    break;
    
  case PTP_MM_SET_SUBDOMAIN:
    memcpy(rtOpts->subdomainName, (char*)buf + 60, 16);
    DBG("set subdomain to %s\n", rtOpts->subdomainName);
    break;
    
  case PTP_MM_SET_TIME:
    externalTime.seconds = flip32(*(UInteger32*)((char*)buf + 60));
    externalTime.nanoseconds = flip32(*(Integer32*)((char*)buf + 64));
    toInternalTime(&internalTime, &externalTime, &ptpClock->halfEpoch);
    setTime(&internalTime);
    break;
    
  case PTP_MM_UPDATE_DEFAULT_DATA_SET:
    if(!rtOpts->slaveOnly)
      ptpClock->clock_stratum = *(UInteger8*)((char*)buf + 63);
    memcpy(ptpClock->clock_identifier, (char*)buf + 64, 4);
    ptpClock->clock_variance = flip16(*(Integer16*)((char*)buf + 70));
    ptpClock->preferred = *(UInteger8*)((char*)buf + 75);
    rtOpts->syncInterval = *(UInteger8*)((char*)buf + 79);
    memcpy(rtOpts->subdomainName, (char*)buf + 80, 16);
    break;
    
  case PTP_MM_UPDATE_GLOBAL_TIME_PROPERTIES:
    ptpClock->current_utc_offset = flip16(*(Integer16*)((char*)buf + 62));
    ptpClock->leap_59 = *(UInteger8*)((char*)buf + 67);
    ptpClock->leap_61 = *(UInteger8*)((char*)buf + 71);
    ptpClock->epoch_number = flip16(*(UInteger16*)((char*)buf + 74));
    break;
    
  default:
    break;
  }
  
  return ptpClock->port_state;
}
Ejemplo n.º 30
0
Archivo: miner.c Proyecto: homolumo/mm
void miner_gen_nonce2_work(struct mm_work *mw, uint32_t nonce2, struct work *work)
{
	uint8_t merkle_root[32], merkle_sha[64];
	uint32_t *data32, *swap32, tmp32;
	int i;

	tmp32 = bswap_32(nonce2);
	memcpy(mw->coinbase + mw->nonce2_offset, (uint8_t *)(&tmp32), sizeof(uint32_t));
	work->nonce2 = nonce2;

	gen_hash(mw->coinbase, merkle_root, mw->coinbase_len);
	memcpy(merkle_sha, merkle_root, 32);
	for (i = 0; i < mw->nmerkles; i++) {
		memcpy(merkle_sha + 32, mw->merkles[i], 32);
		gen_hash(merkle_sha, merkle_root, 64);
		memcpy(merkle_sha, merkle_root, 32);
	}
	data32 = (uint32_t *)merkle_sha;
	swap32 = (uint32_t *)merkle_root;
	flip32(swap32, data32);

	memcpy(mw->header + mw->merkle_offset, merkle_root, 32);

	debug32("D: Work nonce2: %08x\n", work->nonce2);
	calc_midstate(mw, work);

	uint8_t work_t[44];
#ifdef HW_PRE_CALC
	uint8_t work_t[] = {
		0x05, 0x4e, 0x53, 0xc3, 0xc4, 0xd4, 0xba, 0x3e, 0x65, 0x40, 0x99, 0x4f, 0x06, 0x67, 0x91, 0x31,
		0xa7, 0x2d, 0x66, 0xaa, 0x68, 0x4f, 0x0e, 0xdb, 0xc3, 0x6d, 0x95, 0x8a, 0x46, 0x6e, 0x4d, 0xb2,
		0x1c, 0x26, 0x52, 0xfb, 0x52, 0xa0, 0x26, 0xf4, 0x19, 0x06, 0x12, 0x42};
#endif

	memcpy(work_t, work->data, 44);
	rev(work_t, 32);
	rev(work_t + 32, 12);
	memcpy(work->data, work_t, 44);

#ifdef HW_PRE_CALC
	calc_prepare(work, work_t);
	memcpy((uint8_t *)(&tmp32), work->a1, 4);
	debug32("%08x,", tmp32);
	memcpy((uint8_t *)(&tmp32), work->a0, 4);
	debug32("%08x,", tmp32);
	memcpy((uint8_t *)(&tmp32), work->e2, 4);
	debug32("%08x,", tmp32);
	memcpy((uint8_t *)(&tmp32), work->e1, 4);
	debug32("%08x,", tmp32);
	memcpy((uint8_t *)(&tmp32), work->e0, 4);
	debug32("%08x,", tmp32);
	memcpy((uint8_t *)(&tmp32), work->a2, 4);
	debug32("%08x", tmp32);
	debug32("\n");
#endif

	calc_prepare1(work, work->data);
	memcpy((uint8_t *)(&tmp32), work->a1, 4);
	memcpy((uint8_t *)(&tmp32), work->a0, 4);
	memcpy((uint8_t *)(&tmp32), work->e2, 4);
	memcpy((uint8_t *)(&tmp32), work->e1, 4);
	memcpy((uint8_t *)(&tmp32), work->e0, 4);
	memcpy((uint8_t *)(&tmp32), work->a2, 4);
}