/* Constructors */
Transaction * createNewTransaction(uint32_t lockTime, uint32_t version,
void (*onErrorReceived)(Error error, char *, ...)) {
assert(lockTime >= 0);
assert(version >= 0);
assert(onErrorReceived != NULL);
Transaction * self = malloc(sizeof(*self)); /*Create memory for Transaction */
if (!self) {
onErrorReceived(ERROR_OUT_OF_MEMORY,
"Cannot allocate %i bytes of memory for NewTransaction in createNewTransaction\n",
sizeof(*self));
return NULL;
}
getObject(self)->destroy = destroyTransaction; /*assign destructor function to object*/
if (setUpTransactionData(self, lockTime, version, onErrorReceived)) {
return self;
}
/* Initialization failed; Clean up everything and return NULL*/
free(self);
return NULL;
}
/**
@fn Message * createNewMessage(void (*onErrorReceived)(Error error,char *,...))
@brief Creates a new Message
@returns Message
*/
Message * createNewMessage(void (*onErrorReceived)(Error error,char *,...))
{
assert(onErrorReceived != NULL);
Message * self = malloc(sizeof(*self)); /**<Create memory for Message */
if (!self) {
onErrorReceived(ERROR_OUT_OF_MEMORY,"Cannot allocate %i bytes of memory for Message\n",sizeof(*self));
return NULL;
}
/**< checking that this object was created from the getObject */
if(getObject(self) != NULL){
/**< retrieve the base object and use it to update the underlying base object details */
getObject(self)->destroy = destroyMessage; /**<assign destructor function to object*/
getObject(self)->referenceCount = 1;
/**< Set other Message fields */
self->bytes = NULL;
self->onErrorReceived = onErrorReceived;
self->expectResponse = FALSE;
return self;
}
/**< creation failed; Clean up everything and return NULL */
free(self);
return NULL;
}
int initByteArrayFromString(ByteArray * self, char * string,
int terminator, void(*onErrorReceived)(Error error, char *, ...)){
self->onErrorReceived = onErrorReceived;
self->length = (uint32_t)(strlen(string) + terminator);
self->sharedData = malloc(sizeof(*self->sharedData));
if (! self->sharedData) {
onErrorReceived(ERROR_OUT_OF_MEMORY,"Cannot allocate %i bytes of memory in InitByteArrayFromString for the sharedData structure.\n",sizeof(*self->sharedData));
return FALSE;
}
self->sharedData->data = malloc(self->length);
if (! self->sharedData->data) {
onErrorReceived(ERROR_OUT_OF_MEMORY,"Cannot allocate %i bytes of memory in InitByteArrayFromString for the shared data.\n",self->length);
return FALSE;
}
self->sharedData->referenceCount = 1;
self->offset = 0;
memmove(self->sharedData->data, string, self->length);
return TRUE;
}
CBInventoryBroadcast * CBNewInventoryBroadcast(void (*onErrorReceived)(CBError error,char *,...)){
CBInventoryBroadcast * self = malloc(sizeof(*self));
if (NOT self) {
onErrorReceived(CB_ERROR_OUT_OF_MEMORY,"Cannot allocate %i bytes of memory in CBNewInventoryBroadcast\n",sizeof(*self));
return NULL;
}
CBGetObject(self)->free = CBFreeInventoryBroadcast;
if(CBInitInventoryBroadcast(self,onErrorReceived))
return self;
free(self);
return NULL;
}
NetworkAddress * createNewNetworkAddress(uint32_t time,ByteArray * ip,uint16_t port,uint64_t services,void(*onErrorReceived)(Error error, char *, ...)){
NetworkAddress * self = malloc(sizeof(*self));
if (! self) {
onErrorReceived(ERROR_OUT_OF_MEMORY,"Cannot allocate %i bytes of memory in CBNewNetworkAddress\n",sizeof(*self));
return NULL;
}
getObject(self)->destroy = destroyNetworkAddress;
if (initializeNetworkAddress(self,time,ip,port,services,onErrorReceived))
return self;
free(self);
return NULL;
}
AddressBroadcast * createNewAddressBroadcastFromSerialisedData(ByteArray * data,uint8_t timeStamps,void(*onErrorReceived)(Error error, char *, ...)){
AddressBroadcast * self = malloc(sizeof(*self));
if (! self) {
onErrorReceived(ERROR_OUT_OF_MEMORY,"Cannot allocate %i bytes of memory in NewAddressBroadcast\n",sizeof(*self));
return NULL;
}
getObject(self)->destroy = destroyAddressBroadcast;
if (initializeAddressBroadcastFromSerialisedData(self,timeStamps,data,onErrorReceived))
return self;
free(self);
return NULL;
}
CBMessage * CBNewMessageByObject(void (*onErrorReceived)(CBError error,char *,...)){
CBMessage * self = malloc(sizeof(*self));
if (NOT self) {
onErrorReceived(CB_ERROR_OUT_OF_MEMORY,"Cannot allocate %i bytes of memory in CBNewMessageByObject\n",sizeof(*self));
return NULL;
}
CBGetObject(self)->free = CBFreeMessage;
if (CBInitMessageByObject(self,onErrorReceived))
return self;
free(self);
return NULL;
}
BEFullNode * BENewFullNode(void (*onErrorReceived)(CBError error,char *,...)){
BEFullNode * self = malloc(sizeof(*self));
if (NOT self) {
onErrorReceived(CB_ERROR_OUT_OF_MEMORY,"Cannot allocate %i bytes of memory in BENewFullNode\n",sizeof(*self));
return NULL;
}
CBGetObject(self)->free = BEFreeFullNode;
if (BEInitFullNode(self,onErrorReceived))
return self;
free(self);
return NULL;
}
CBAddressBroadcast * CBNewAddressBroadcastFromData(CBByteArray * data,bool timeStamps,void (*onErrorReceived)(CBError error,char *,...)){
CBAddressBroadcast * self = malloc(sizeof(*self));
if (NOT self) {
onErrorReceived(CB_ERROR_OUT_OF_MEMORY,"Cannot allocate %i bytes of memory in CBNewAddressBroadcast\n",sizeof(*self));
return NULL;
}
CBGetObject(self)->free = CBFreeAddressBroadcast;
if (CBInitAddressBroadcastFromData(self,timeStamps,data,onErrorReceived))
return self;
free(self);
return NULL;
}
CBTransactionInput * CBNewUnsignedTransactionInput(uint32_t sequence,CBByteArray * prevOutHash,uint32_t prevOutIndex,void (*onErrorReceived)(CBError error,char *,...)){
CBTransactionInput * self = malloc(sizeof(*self));
if (NOT self) {
onErrorReceived(CB_ERROR_OUT_OF_MEMORY,"Cannot allocate %i bytes of memory in CBNewUnsignedTransactionInput\n",sizeof(*self));
return NULL;
}
CBGetObject(self)->free = CBFreeTransactionInput;
if(CBInitUnsignedTransactionInput(self,sequence,prevOutHash,prevOutIndex, onErrorReceived))
return self;
free(self);
return NULL;
}
CBTransactionInput * CBNewTransactionInputFromData(CBByteArray * data,void (*onErrorReceived)(CBError error,char *,...)){
CBTransactionInput * self = malloc(sizeof(*self));
if (NOT self) {
onErrorReceived(CB_ERROR_OUT_OF_MEMORY,"Cannot allocate %i bytes of memory in CBNewTransactionInputFromData\n",sizeof(*self));
return NULL;
}
CBGetObject(self)->free = CBFreeTransactionInput;
if(CBInitTransactionInputFromData(self, data, onErrorReceived))
return self;
free(self);
return NULL;
}
Address * createNewAddressFromString(ByteArray * string,uint8_t cacheString,void (*onErrorReceived)(Error error,char *,...)){
Address * self = malloc(sizeof(*self));
if ( !self ) {
onErrorReceived(ERROR_OUT_OF_MEMORY,"Cannot allocate %i bytes of memory in NewAddressFromString\n",sizeof(*self));
return NULL;
}
getObject(self)->destroy = destroyAddress;
if (initializeAddressFromString(self,string,cacheString,onErrorReceived))
return self;
free(self);
return NULL;
}
VersionChecksumBytes * createNewVersionChecksumBytesFromBytes(uint8_t * bytes,uint32_t size,int cacheString,void (*onErrorReceived)(Error error,char *,...)){
VersionChecksumBytes * self = malloc(sizeof(*self));
if (! self) {
onErrorReceived(ERROR_OUT_OF_MEMORY,"Cannot allocate %i bytes of memory in NewVersionChecksumBytesFromBytes\n",sizeof(*self));
return NULL;
}
getObject(self)->destroy = destroyVersionChecksumBytes;
if(initializeVersionChecksumBytesFromBytes(self,bytes,size,cacheString,onErrorReceived)){
return self;
}
free(self);
return NULL;
}
ByteArray * createNewByteArrayFromString(char * string, int terminator,
void(*onErrorReceived)(Error error, char *, ...)){
ByteArray * self = malloc(sizeof(*self));
if (! self) {
onErrorReceived(ERROR_OUT_OF_MEMORY,"Cannot allocate %i bytes of memory in NewByteArrayFromString\n",sizeof(*self));
return NULL;
}
getObject(self)->destroy = destroyByteArray;
if(initByteArrayFromString(self,string,terminator,onErrorReceived))
return self;
free(self);
return NULL;
}
NetworkAddress * createNewNetworkAddressFromSerialisedData(ByteArray * data,void(*onErrorReceived)(Error error, char *, ...))
{
NetworkAddress * self = malloc(sizeof(*self));
if (!self) {
onErrorReceived(ERROR_OUT_OF_MEMORY,"Cannot allocate %i bytes of memory in CBNewNetworkAddress\n",sizeof(*self));
return NULL;
}
getObject(self)->destroy = destroyNetworkAddress;
if(initializeNetworkAddressFromSerialisedData(self,data,onErrorReceived))
return self;
free(self);
return NULL;
}
/**
@fn ByteArray * createNewByteArrayOfSize(uint32_t size,void (*onErrorReceived)(Error error,char *,...))
@brief createNewByteArrayOfSize
@param self
@param ref
@param offset
*/
ByteArray * createNewByteArrayOfSize(uint32_t size,void (*onErrorReceived)(Error error,char *,...)){
ByteArray * self = malloc(sizeof(*self));
if (! self) {
onErrorReceived(ERROR_OUT_OF_MEMORY,"Cannot allocate %i bytes of memory in createNewByteArrayOfSize\n",sizeof(*self));
return NULL;
}
getObject(self)->destroy = destroyByteArray;
if(initByteArrayOfSize(self,size,onErrorReceived))
return self;
free(self);
return NULL;
}
BlockHeaders * newBlockHeadersFromData(ByteArray * data,void (*onErrorReceived)(Error error,char *,...)){
assert(data != NULL && onErrorReceived != NULL);
BlockHeaders * self = malloc(sizeof(*self));
if (!self) {
onErrorReceived(ERROR_OUT_OF_MEMORY,"Cannot allocate %i bytes of memory in newBlockHeadersFromData\n",sizeof(*self));
return NULL;
}
getObject(self)->destroy = destroyBlockHeaders;
if(initBlockHeadersFromData(self,data,onErrorReceived))
return self;
free(self);
return NULL;
}
Address * createNewAddressFromRIPEMD160Hash(uint8_t * hash,uint8_t netVersionByte,uint8_t cacheString,void (*onErrorReceived)(Error error,char *,...)){
Address * self = malloc(sizeof(*self));
if (!self) {
onErrorReceived(ERROR_OUT_OF_MEMORY,"Cannot allocate %i bytes of memory in createNewAddressFromRIPEMD160Hash\n",sizeof(*self));
return NULL;
}
getObject(self)->destroy = destroyAddress;
if (initializeAddressFromRIPEMD160Hash(self,netVersionByte,hash,cacheString,onErrorReceived)) {
return self;
}
free(self);
return NULL;
}
Transaction * createNewTransactionFromByteArray(ByteArray * bytes,
void (*onErrorReceived)(Error error, char *, ...)) {
Transaction * self = malloc(sizeof(*self)); /*Create memory for Transaction*/
if (!self) {
onErrorReceived(ERROR_OUT_OF_MEMORY,
"Cannot allocate %i bytes of memory for NewTransaction in createNewTransactionFromByteArray\n",
sizeof(*self));
return NULL;
}
if (setUpTransactionDataUsingByteArray(self, bytes, onErrorReceived)) {
return self;
}
/* Initialization failed; Clean up everything and return NULL*/
free(self);
return NULL;
}
TransactionOutput * createNewTransactionOutputFromData(ByteArray * data, void (*onErrorReceived)(Error error,char *,...))
{
assert(data != NULL);
assert(onErrorReceived != NULL);
TransactionOutput * self = malloc(sizeof(*self));
if (!self) {
onErrorReceived(ERROR_OUT_OF_MEMORY,"Cannot allocate %i bytes of memory in createNewTransactionOutputFromData\n", sizeof(*self));
return NULL;
}
getObject(self)->destroy = destroyTransactionOutput; /*assign destructor function to object */
if(initializeTransactionOutputFromData(self, data, onErrorReceived)) {
return self;
}
/* Initialization failed; Clean up everything and return NULL */
free(self);
return NULL;
}
InventoryVector * createNewInventoryVectorFromData(ByteArray * data, void (*onErrorReceived)(Error error,char *,...))
{
assert(data != NULL);
assert(onErrorReceived != NULL);
InventoryVector * self = malloc(sizeof(*self));
if (!self) {
onErrorReceived(ERROR_OUT_OF_MEMORY,
"Cannot allocate %i bytes of memory in createNewInventoryVectorFromData\n",
sizeof(*self));
return NULL;
}
getObject(self)->destroy = destroyInventoryVector; /**<assign destructor function to object*/
if (initializeInventoryVectorFromData(self, data, onErrorReceived)) {
return self;
}
free(self);
return NULL;
}
uint8_t initializeAddressFromRIPEMD160Hash(Address * self,uint8_t netVersionByte,uint8_t * hash,uint8_t cacheString,void (*onErrorReceived)(Error error,char *,...))
{
/* Build address and then complete intitialization with VersionChecksumBytes*/
uint8_t * addressData = malloc(25); /* 1 version byte, 20 hash bytes, 4 checksum bytes.*/
if ( addressData==NULL) {
onErrorReceived(ERROR_OUT_OF_MEMORY,"Cannot allocate 25 bytes of memory in initializeAddressFromRIPEMD160Hash\n");
return FALSE;
}
/* Set version byte */
addressData[0] = netVersionByte;
/* Move hash */
memmove(addressData+1, hash, 20);
/* Make checksum and move it into address; check https://en.bitcoin.it/wiki/Technical_background_of_Bitcoin_addresses for step by step explanation */
uint8_t checksum[32];
uint8_t checksum2[32];
Sha256(addressData,21,checksum);
Sha256(checksum,32,checksum2);
memmove(addressData+21, checksum2, 4);
/* initialise VersionChecksumBytes*/
if (! initializeVersionChecksumBytesFromBytes(getVersionChecksumBytes(self), addressData, 25,cacheString, onErrorReceived)) {
return FALSE;
}
return TRUE;
}
bool BEInitFullNode(BEFullNode * self,void (*onErrorReceived)(CBError error,char *,...)){
if (NOT CBInitNetworkCommunicator(CBGetNetworkCommunicator(self), onErrorReceived))
return false;
// Set network communicator fields.
CBGetNetworkCommunicator(self)->blockHeight = 0;
CBGetNetworkCommunicator(self)->callbackHandler = self;
CBGetNetworkCommunicator(self)->flags = CB_NETWORK_COMMUNICATOR_AUTO_DISCOVERY | CB_NETWORK_COMMUNICATOR_AUTO_HANDSHAKE | CB_NETWORK_COMMUNICATOR_AUTO_PING;
CBGetNetworkCommunicator(self)->version = CB_PONG_VERSION;
CBNetworkCommunicatorSetAlternativeMessages(CBGetNetworkCommunicator(self), NULL, NULL);
// Find home directory.
const char * homeDir;
struct passwd * pwd = getpwuid(getuid());
if (NOT pwd)
return false;
homeDir = pwd->pw_dir;
unsigned long homeLen = strlen(homeDir);
// Open or create a new address store
unsigned long dataDirLen = strlen(BE_DATA_DIRECTORY);
char * addressFilePath = malloc(homeLen + dataDirLen + strlen(BE_ADDRESS_DATA_FILE) + 1);
memcpy(addressFilePath, homeDir, homeLen);
memcpy(addressFilePath + homeLen, BE_DATA_DIRECTORY, strlen(BE_DATA_DIRECTORY));
strcpy(addressFilePath + homeLen + dataDirLen, BE_ADDRESS_DATA_FILE);
self->addressFile = fopen(addressFilePath, "rb+");
if (self->addressFile) {
// The address store exists.
free(addressFilePath);
// Get the file length
fseek(self->addressFile, 0, SEEK_END);
unsigned long fileLen = ftell(self->addressFile);
fseek(self->addressFile, 0, SEEK_SET);
// Read file into a CBByteArray
CBByteArray * buffer = CBNewByteArrayOfSize((uint32_t)fileLen, onErrorReceived);
if (NOT buffer) {
fclose(self->addressFile);
return false;
}
if(fread(CBByteArrayGetData(buffer), fileLen, 1, self->addressFile) != fileLen){
CBReleaseObject(buffer);
fclose(self->addressFile);
return false;
}
// Create the CBAddressManager
CBGetNetworkCommunicator(self)->addresses = CBNewAddressManagerFromData(buffer, onErrorReceived, BEFullNodeOnBadTime);
CBReleaseObject(buffer);
if (NOT CBAddressManagerDeserialise(CBGetNetworkCommunicator(self)->addresses)){
fclose(self->addressFile);
CBReleaseObject(CBGetNetworkCommunicator(self)->addresses);
onErrorReceived(CB_ERROR_INIT_FAIL,"There was an error when deserialising the CBAddressManager for the BEFullNode.");
return false;
}
}else{
// The address store does not exist
CBGetNetworkCommunicator(self)->addresses = CBNewAddressManager(onErrorReceived, BEFullNodeOnBadTime);
if (NOT CBGetNetworkCommunicator(self)->addresses)
return false;
// Create the file
self->addressFile = fopen(addressFilePath, "wb");
free(addressFilePath);
if (NOT self->addressFile){
CBReleaseObject(CBGetNetworkCommunicator(self)->addresses);
return false;
}
}
// Create block validator
return true;
}
