uint16_t CBChainDescriptorDeserialise(CBChainDescriptor * self){
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (! bytes) {
CBLogError("Attempting to deserialise a CBChainDescriptor with no bytes.");
return 0;
}
if (bytes->length < 1) {
CBLogError("Attempting to deserialise a CBChainDescriptor with no bytes");
return 0;
}
CBVarInt hashNum = CBVarIntDecode(bytes, 0);
if (hashNum.val > 500) {
CBLogError("Attempting to deserialise a CBChainDescriptor with a var int over 500.");
return 0;
}
if (bytes->length < hashNum.size + hashNum.val * 32) {
CBLogError("Attempting to deserialise a CBChainDescriptor with less bytes than required for the hashes.");
return 0;
}
// Deserialise each hash
self->hashes = malloc(sizeof(*self->hashes) * (size_t)hashNum.val);
self->hashNum = hashNum.val;
uint16_t cursor = hashNum.size;
for (uint16_t x = 0; x < self->hashNum; x++) {
self->hashes[x] = CBNewByteArraySubReference(bytes, cursor, 32);
cursor += 32;
}
return cursor;
}
uint32_t CBTransactionInputDeserialise(CBTransactionInput * self){
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (! bytes) {
CBLogError("Attempting to deserialise a CBTransactionInput with no bytes.");
return 0;
}
if (bytes->length < 41) {
CBLogError("Attempting to deserialise a CBTransactionInput with less than 41 bytes.");
return 0;
}
CBVarInt scriptLen = CBVarIntDecode(bytes, 36);
if (scriptLen.val > 10000) {
CBLogError("Attempting to deserialise a CBTransactionInput with too big a script.");
return 0;
}
uint32_t reqLen = (uint32_t)(40 + scriptLen.size + scriptLen.val);
if (bytes->length < reqLen) {
CBLogError("Attempting to deserialise a CBTransactionInput with less bytes than needed according to the length for the script. %i < %i", bytes->length, reqLen);
return 0;
}
// Deserialise by subreferencing byte arrays and reading integers.
self->prevOut.hash = CBByteArraySubReference(bytes, 0, 32);
self->prevOut.index = CBByteArrayReadInt32(bytes, 32);
self->scriptObject = CBNewScriptFromReference(bytes, 36 + scriptLen.size, (uint32_t) scriptLen.val);
self->sequence = CBByteArrayReadInt32(bytes, (uint32_t) (36 + scriptLen.size + scriptLen.val));
return reqLen;
}
uint32_t CBAddressBroadcastDeserialise(CBAddressBroadcast * self){
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (NOT bytes) {
CBLogError("Attempting to deserialise a CBAddressBroadcast with no bytes.");
return 0;
}
if (bytes->length < 26 + self->timeStamps * 4) {
CBLogError("Attempting to deserialise a CBAddressBroadcast without enough bytes to cover one address.");
return 0;
}
CBVarInt num = CBVarIntDecode(bytes, 0);
/* TODO fix this, don't just hack it away
if (num.val > 30) {
CBLogError("Attempting to deserialise a CBAddressBroadcast with a var int over 30.");
return 0;
}
*/
self->addresses = malloc(sizeof(*self->addresses) * (size_t)num.val);
if (NOT self->addresses) {
CBLogError("Cannot allocate %i bytes of memory in CBAddressBroadcastDeserialise\n", sizeof(*self->addresses) * (size_t)num.val);
return 0;
}
self->addrNum = num.val;
uint16_t cursor = num.size;
for (uint8_t x = 0; x < num.val; x++) {
// Make new CBNetworkAddress from the rest of the data.
uint8_t len;
CBByteArray * data = CBByteArraySubReference(bytes, cursor, bytes->length-cursor);
if (data) {
// Create a new network address object. It is public since it is in an address broadcast.
self->addresses[x] = CBNewNetworkAddressFromData(data, true);
if (self->addresses[x]){
// Deserialise
len = CBNetworkAddressDeserialise(self->addresses[x], self->timeStamps);
if (NOT len)
CBLogError("CBAddressBroadcast cannot be deserialised because of an error with the CBNetworkAddress number %u.", x);
}else{
len = 0;
CBLogError("Could not create CBNetworkAddress in CBAddressBroadcastDeserialise for network address %u.", x);
}
}else{
len = 0;
CBLogError("Could not create CBByteArray in CBAddressBroadcastDeserialise for network address %u.", x);
}
if (NOT len) {
// Release bytes
CBReleaseObject(data);
return 0;
}
// Adjust length
data->length = len;
CBReleaseObject(data);
cursor += len;
}
return cursor;
}
uint32_t CBAddressBroadcastDeserialise(CBAddressBroadcast * self){
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (NOT bytes) {
CBGetMessage(self)->onErrorReceived(CB_ERROR_MESSAGE_DESERIALISATION_NULL_BYTES,"Attempting to deserialise a CBAddressBroadcast with no bytes.");
return 0;
}
if (bytes->length < 26 + self->timeStamps * 4) {
CBGetMessage(self)->onErrorReceived(CB_ERROR_MESSAGE_DESERIALISATION_BAD_BYTES,"Attempting to deserialise a CBAddressBroadcast without enough bytes to cover one address.");
return 0;
}
CBVarInt num = CBVarIntDecode(bytes, 0);
if (num.val > 30) {
CBGetMessage(self)->onErrorReceived(CB_ERROR_MESSAGE_DESERIALISATION_BAD_BYTES,"Attempting to deserialise a CBAddressBroadcast with a var int over 30.");
return 0;
}
self->addresses = malloc(sizeof(*self->addresses) * (size_t)num.val);
if (NOT self->addresses) {
CBGetMessage(self)->onErrorReceived(CB_ERROR_OUT_OF_MEMORY,"Cannot allocate %i bytes of memory in CBAddressBroadcastDeserialise\n",sizeof(*self->addresses) * (size_t)num.val);
return 0;
}
self->addrNum = num.val;
uint16_t cursor = num.size;
for (uint8_t x = 0; x < num.val; x++) {
// Make new CBNetworkAddress from the rest of the data.
uint8_t len;
CBByteArray * data = CBByteArraySubReference(bytes, cursor, bytes->length-cursor);
if (data) {
self->addresses[x] = CBNewNetworkAddressFromData(data, CBGetMessage(self)->onErrorReceived);
if (self->addresses[x]){
// Deserialise
len = CBNetworkAddressDeserialise(self->addresses[x], self->timeStamps);
if (NOT len)
CBGetMessage(self)->onErrorReceived(CB_ERROR_MESSAGE_DESERIALISATION_BAD_BYTES,"CBAddressBroadcast cannot be deserialised because of an error with the CBNetworkAddress number %u.",x);
}else{
len = 0;
CBGetMessage(self)->onErrorReceived(CB_ERROR_INIT_FAIL,"Could not create CBNetworkAddress in CBAddressBroadcastDeserialise for network address %u.",x);
}
}else{
len = 0;
CBGetMessage(self)->onErrorReceived(CB_ERROR_INIT_FAIL,"Could not create CBByteArray in CBAddressBroadcastDeserialise for network address %u.",x);
}
if (NOT len) {
// Release bytes
CBReleaseObject(data);
return 0;
}
// Adjust length
data->length = len;
CBReleaseObject(data);
cursor += len;
}
return cursor;
}
uint32_t CBBlockHeadersDeserialise(CBBlockHeaders * self) {
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (NOT bytes) {
CBGetMessage(self)->logError("Attempting to deserialise a CBBlockHeaders with no bytes.");
return 0;
}
if (bytes->length < 82) {
CBGetMessage(self)->logError("Attempting to deserialise a CBBlockHeaders with less bytes than required for one header.");
return 0;
}
CBVarInt headerNum = CBVarIntDecode(bytes, 0);
if (headerNum.val > 2000) {
CBGetMessage(self)->logError("Attempting to deserialise a CBBlockHeaders with a var int over 2000.");
return 0;
}
// Deserialise each header
self->blockHeaders = malloc(sizeof(*self->blockHeaders) * (size_t)headerNum.val);
if (NOT self->blockHeaders) {
CBGetMessage(self)->logError("Cannot allocate %i bytes of memory in CBBlockHeadersDeserialise\n",sizeof(*self->blockHeaders) * (size_t)headerNum.val);
return 0;
}
self->headerNum = headerNum.val;
uint16_t cursor = headerNum.size;
for (uint16_t x = 0; x < headerNum.val; x++) {
// Make new CBBlock from the rest of the data.
CBByteArray * data = CBByteArraySubReference(bytes, cursor, bytes->length-cursor);
if (NOT data) {
CBGetMessage(self)->logError("Cannot create a new CBByteArray in CBBlockHeadersDeserialise for the header number %u.",x);
return 0;
}
self->blockHeaders[x] = CBNewBlockFromData(data, CBGetMessage(self)->logError);
if (NOT self->blockHeaders[x]) {
CBGetMessage(self)->logError("Cannot create a new CBBlock in CBBlockHeadersDeserialise for the header number %u.",x);
CBReleaseObject(data);
return 0;
}
// Deserialise
uint8_t len = CBBlockDeserialise(self->blockHeaders[x], false); // false for no transactions. Only the header.
if (NOT len) {
CBGetMessage(self)->logError("CBBlockHeaders cannot be deserialised because of an error with the CBBlock number %u.",x);
CBReleaseObject(data);
return 0;
}
// Adjust length
data->length = len;
CBReleaseObject(data);
cursor += len;
}
return cursor;
}
uint32_t CBInventoryBroadcastDeserialise(CBInventoryBroadcast * self){
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (NOT bytes) {
CBGetMessage(self)->onErrorReceived(CB_ERROR_MESSAGE_DESERIALISATION_NULL_BYTES,"Attempting to deserialise a CBInventoryBroadcast with no bytes.");
return 0;
}
if (bytes->length < 37) {
CBGetMessage(self)->onErrorReceived(CB_ERROR_MESSAGE_DESERIALISATION_BAD_BYTES,"Attempting to deserialise a CBInventoryBroadcast with less bytes than required for one item.");
return 0;
}
CBVarInt itemNum = CBVarIntDecode(bytes, 0);
if (itemNum.val > 1388) {
CBGetMessage(self)->onErrorReceived(CB_ERROR_MESSAGE_DESERIALISATION_BAD_BYTES,"Attempting to deserialise a CBInventoryBroadcast with a var int over 1388.");
return 0;
}
// Run through the items and deserialise each one.
self->items = malloc(sizeof(*self->items) * (size_t)itemNum.val);
if (NOT self->items) {
CBGetMessage(self)->onErrorReceived(CB_ERROR_OUT_OF_MEMORY,"Cannot allocate %i bytes of memory in CBInventoryBroadcastDeserialise",sizeof(*self->items) * (size_t)itemNum.val);
return 0;
}
self->itemNum = itemNum.val;
uint16_t cursor = itemNum.size;
for (uint16_t x = 0; x < itemNum.val; x++) {
// Make new CBInventoryItem from the rest of the data.
CBByteArray * data = CBByteArraySubReference(bytes, cursor, bytes->length-cursor);
if (NOT data) {
CBGetMessage(self)->onErrorReceived(CB_ERROR_INIT_FAIL,"Could not create a new CBByteArray in CBInventoryBroadcastDeserialise for inventory broadcast number %u.",x);
return 0;
}
self->items[x] = CBNewInventoryItemFromData(data, CBGetMessage(self)->onErrorReceived);
if (NOT self->items[x]) {
CBGetMessage(self)->onErrorReceived(CB_ERROR_INIT_FAIL,"Could not create a new CBInventoryItem in CBInventoryBroadcastDeserialise for inventory broadcast number %u.",x);
CBReleaseObject(data);
return 0;
}
// Deserialise
uint8_t len = CBInventoryItemDeserialise(self->items[x]);
if (NOT len){
CBGetMessage(self)->onErrorReceived(CB_ERROR_MESSAGE_DESERIALISATION_BAD_BYTES,"CBInventoryBroadcast cannot be deserialised because of an error with the CBInventoryItem number %u.",x);
CBReleaseObject(data);
return 0;
}
// Adjust length
data->length = len;
CBReleaseObject(data);
cursor += len;
}
return cursor;
}
uint32_t CBInventoryBroadcastDeserialise(CBInventoryBroadcast * self){
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (NOT bytes) {
CBGetMessage(self)->events->onErrorReceived(CB_ERROR_MESSAGE_DESERIALISATION_NULL_BYTES,"Attempting to deserialise a CBInventoryBroadcast with no bytes.");
return 0;
}
if (bytes->length < 37) {
CBGetMessage(self)->events->onErrorReceived(CB_ERROR_MESSAGE_DESERIALISATION_BAD_BYTES,"Attempting to deserialise a CBInventoryBroadcast with less bytes than required for one item.");
return 0;
}
CBVarInt itemNum = CBVarIntDecode(bytes, 0);
if (itemNum.val > 1388) {
CBGetMessage(self)->events->onErrorReceived(CB_ERROR_MESSAGE_DESERIALISATION_BAD_BYTES,"Attempting to deserialise a CBInventoryBroadcast with a var int over 1388.");
return 0;
}
// Run through the items and deserialise each one.
self->items = malloc(sizeof(*self->items) * (size_t)itemNum.val);
self->itemNum = itemNum.val;
uint16_t cursor = itemNum.size;
for (uint16_t x = 0; x < itemNum.val; x++) {
// Make new CBInventoryItem from the rest of the data.
CBByteArray * data = CBByteArraySubReference(bytes, cursor, bytes->length-cursor);
self->items[x] = CBNewInventoryItemFromData(data, CBGetMessage(self)->events);
// Deserialise
uint8_t len = CBInventoryItemDeserialise(self->items[x]);
if (NOT len) {
CBGetMessage(self)->events->onErrorReceived(CB_ERROR_MESSAGE_DESERIALISATION_BAD_BYTES,"CBInventoryBroadcast cannot be deserialised because of an error with the CBInventoryItem number %u.",x);
// Release bytes
CBReleaseObject(data);
// Because of failure release the CBInventoryItems
for (uint16_t y = 0; y < x + 1; y++) {
CBReleaseObject(self->items[y]);
}
free(self->items);
self->items = NULL;
self->itemNum = 0;
return 0;
}
// Adjust length
data->length = len;
CBReleaseObject(data);
cursor += len;
}
return cursor;
}
uint32_t CBTransactionOutputDeserialise(CBTransactionOutput * self){
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (NOT bytes) {
CBLogError("Attempting to deserialise a CBTransactionOutput with no bytes.");
return 0;
}
if (bytes->length < 9) {
CBLogError("Attempting to deserialise a CBTransactionOutput with less than 9 bytes.");
return 0;
}
uint8_t x = CBByteArrayGetByte(bytes, 8); // Check length for decoding CBVarInt
if (x < 253)
x = 9;
else if (x == 253)
x = 11;
else if (x == 254)
x = 13;
else
x = 17;
if (bytes->length < x) {
CBLogError("Attempting to deserialise a CBTransactionOutput with less than %i bytes required.", x);
return 0;
}
CBVarInt scriptLen = CBVarIntDecode(bytes, 8); // Can now decode.
if (scriptLen.val > 10000) {
CBLogError("Attempting to deserialise a CBTransactionInput with too big a script.");
return 0;
}
uint32_t reqLen = (uint32_t)(8 + scriptLen.size + scriptLen.val);
if (bytes->length < reqLen) {
CBLogError("Attempting to deserialise a CBTransactionOutput with less bytes than needed according to the length for the script. %i < %i", bytes->length, reqLen);
return 0;
}
// Deserialise by subreferencing byte arrays and reading integers.
self->value = CBByteArrayReadInt64(bytes, 0);
self->scriptObject = CBNewScriptFromReference(bytes, 8 + scriptLen.size, (uint32_t) scriptLen.val);
if (NOT self->scriptObject){
CBLogError("Cannot create a new CBScript in CBTransactionOutputDeserialise");
return 0;
}
return reqLen;
}
uint32_t CBNetworkAddressListDeserialise(CBNetworkAddressList * self){
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (! bytes) {
CBLogError("Attempting to deserialise a CBNetworkAddressList with no bytes.");
return CB_DESERIALISE_ERROR;
}
if (bytes->length < 26 + self->timeStamps * 4) {
CBLogError("Attempting to deserialise a CBNetworkAddressList without enough bytes to cover one address.");
return CB_DESERIALISE_ERROR;
}
CBVarInt num = CBVarIntDecode(bytes, 0);
if (num.val > 1000) {
CBLogError("Attempting to deserialise a CBNetworkAddressList with a var int over 1000.");
return CB_DESERIALISE_ERROR;
}
self->addresses = malloc(sizeof(*self->addresses) * (size_t)num.val);
self->addrNum = (uint32_t)num.val;
uint16_t cursor = num.size;
for (uint32_t x = 0; x < num.val; x++) {
// Make new CBNetworkAddress from the rest of the data.
uint32_t len;
CBByteArray * data = CBByteArraySubReference(bytes, cursor, bytes->length-cursor);
// Create a new network address object. It is public since it is in an address broadcast.
self->addresses[x] = CBNewNetworkAddressFromData(data, true);
// Deserialise
len = CBNetworkAddressDeserialise(self->addresses[x], self->timeStamps);
if (len == CB_DESERIALISE_ERROR){
CBLogError("CBNetworkAddressList cannot be deserialised because of an error with the CBNetworkAddress number %u.", x);
// Release bytes
CBReleaseObject(data);
return CB_DESERIALISE_ERROR;
}
// Adjust length
data->length = len;
CBReleaseObject(data);
cursor += len;
}
return cursor;
}
uint32_t CBTransactionInputDeserialise(CBTransactionInput * self){
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (NOT bytes) {
CBGetMessage(self)->onErrorReceived(CB_ERROR_MESSAGE_DESERIALISATION_NULL_BYTES,"Attempting to deserialise a CBTransactionInput with no bytes.");
return 0;
}
if (bytes->length < 41) {
CBGetMessage(self)->onErrorReceived(CB_ERROR_MESSAGE_DESERIALISATION_BAD_BYTES,"Attempting to deserialise a CBTransactionInput with less than 41 bytes.");
return 0;
}
CBVarInt scriptLen = CBVarIntDecode(bytes, 36);
if (scriptLen.val > 10000) {
CBGetMessage(self)->onErrorReceived(CB_ERROR_MESSAGE_DESERIALISATION_BAD_BYTES,"Attempting to deserialise a CBTransactionInput with too big a script.");
return 0;
}
uint32_t reqLen = (uint32_t)(40 + scriptLen.size + scriptLen.val);
if (bytes->length < reqLen) {
CBGetMessage(self)->onErrorReceived(CB_ERROR_MESSAGE_DESERIALISATION_BAD_BYTES,"Attempting to deserialise a CBTransactionInput with less bytes than needed according to the length for the script. %i < %i",bytes->length, reqLen);
return 0;
}
// Deserialise by subreferencing byte arrays and reading integers.
self->prevOut.hash = CBByteArraySubReference(bytes, 0, 32);
if (NOT self->prevOut.hash){
CBGetMessage(self)->onErrorReceived(CB_ERROR_INIT_FAIL,"Cannot create a new CBByteArray in CBTransactionInputDeserialise");
return 0;
}
self->prevOut.index = CBByteArrayReadInt32(bytes, 32);
self->scriptObject = CBNewScriptFromReference(bytes,36 + scriptLen.size, (uint32_t) scriptLen.val);
if (NOT self->scriptObject) {
CBGetMessage(self)->onErrorReceived(CB_ERROR_INIT_FAIL,"Cannot create a new CBScript in CBTransactionInputDeserialise");
CBReleaseObject(self->prevOut.hash);
return 0;
}
self->sequence = CBByteArrayReadInt32(bytes, (uint32_t) (36 + scriptLen.size + scriptLen.val));
return reqLen;
}
uint32_t CBTransactionDeserialise(CBTransaction * self){
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (NOT bytes) {
CBLogError("Attempting to deserialise a CBTransaction with no bytes.");
return 0;
}
if (bytes->length < 10) {
CBLogError("Attempting to deserialise a CBTransaction with less than 10 bytes.");
return 0;
}
self->version = CBByteArrayReadInt32(bytes, 0);
CBVarInt inputOutputLen = CBVarIntDecode(bytes, 4);
if (NOT inputOutputLen.val
|| inputOutputLen.val * 41 > bytes->length - 10) {
CBLogError("Attempting to deserialise a CBTransaction with a bad var int for the number of inputs.");
return 0;
}
uint32_t cursor = 4 + inputOutputLen.size;
self->inputNum = (uint32_t)inputOutputLen.val;
self->inputs = malloc(sizeof(*self->inputs) * self->inputNum);
if (NOT self->inputs) {
CBLogError("Cannot allocate %i bytes of memory in CBTransactionDeserialise for inputs.\n", sizeof(*self->inputs) * self->inputNum);
return 0;
}
for (uint32_t x = 0; x < self->inputNum; x++) {
CBByteArray * data = CBByteArraySubReference(bytes, cursor, bytes->length-cursor);
if (NOT data) {
CBLogError("Cannot create a new CBByteArray in CBTransactionDeserialise for the input number %u.", x);
return 0;
}
CBTransactionInput * input = CBNewTransactionInputFromData(data);
if (NOT input) {
CBLogError("Cannot create a new CBTransactionInput in CBTransactionDeserialise for the input number %u.", x);
CBReleaseObject(data);
return 0;
}
uint32_t len = CBTransactionInputDeserialise(input);
if (NOT len){
CBLogError("CBTransaction cannot be deserialised because of an error with the input number %u.", x);
CBReleaseObject(data);
return 0;
}
// The input was deserialised correctly. Now adjust the length and add it to the transaction.
data->length = len;
CBReleaseObject(data);
self->inputs[x] = input;
cursor += len; // Move along to next input
}
if (bytes->length < cursor + 5) { // Needs at least 5 more for the output CBVarInt and the lockTime
CBLogError("Attempting to deserialise a CBTransaction with not enough bytes for the outputs and lockTime.");
return 0;
}
inputOutputLen = CBVarIntDecode(bytes, cursor);
if (NOT inputOutputLen.val
|| inputOutputLen.val * 9 > bytes->length - 10) {
CBLogError("Attempting to deserialise a CBTransaction with a bad var int for the number of outputs.");
return 0;
}
cursor += inputOutputLen.size; // Move past output CBVarInt
self->outputNum = (uint32_t)inputOutputLen.val;
self->outputs = malloc(sizeof(*self->outputs) * self->outputNum);
if (NOT self->outputs) {
CBLogError("Cannot allocate %i bytes of memory in CBTransactionDeserialise for outputs.\n", sizeof(sizeof(*self->outputs) * self->outputNum));
return 0;
}
for (uint32_t x = 0; x < self->outputNum; x++) {
CBByteArray * data = CBByteArraySubReference(bytes, cursor, bytes->length-cursor);
if (NOT data) {
CBLogError("Cannot create a new CBByteArray in CBTransactionDeserialise for the output number %u.", x);
return 0;
}
CBTransactionOutput * output = CBNewTransactionOutputFromData(data);
if (NOT output) {
CBLogError("Cannot create a new CBTransactionOutput in CBTransactionDeserialise for the output number %u.", x);
CBReleaseObject(data);
return 0;
}
uint32_t len = CBTransactionOutputDeserialise(output);
if (NOT len){
CBLogError("CBTransaction cannot be deserialised because of an error with the output number %u.", x);
CBReleaseObject(data);
return 0;
}
// The output was deserialised correctly. Now adjust the length and add it to the transaction.
data->length = len;
CBReleaseObject(data);
self->outputs[x] = output;
cursor += len; // Move along to next output
}
if (bytes->length < cursor + 4) { // Ensure 4 bytes are available for lockTime
CBLogError("Attempting to deserialise a CBTransaction with not enough bytes for the lockTime.");
return 0;
}
self->lockTime = CBByteArrayReadInt32(bytes, cursor);
return cursor + 4;
}
uint32_t CBVersionDeserialise(CBVersion * self){
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (NOT bytes) {
CBGetMessage(self)->logError("Attempting to deserialise a CBVersion with no bytes.");
return 0;
}
if (bytes->length < 46) {
CBGetMessage(self)->logError("Attempting to deserialise a CBVersion with less than 46 bytes.");
return 0;
}
self->version = CBByteArrayReadInt32(bytes, 0);
self->services = (CBVersionServices) CBByteArrayReadInt64(bytes, 4);
self->time = CBByteArrayReadInt64(bytes, 12);
CBByteArray * data = CBByteArraySubReference(bytes, 20, bytes->length-20); // Get data from 20 bytes to the end of the byte array to deserialise the recieving network address.
if (NOT data) {
CBGetMessage(self)->logError("Cannot create a new CBByteArray in CBVersionDeserialise for the receiving address.");
return 0;
}
self->addRecv = CBNewNetworkAddressFromData(data, CBGetMessage(self)->logError);
if (NOT self->addRecv) {
CBGetMessage(self)->logError("Cannot create a new CBNetworkAddress in CBVersionDeserialise for the receiving address.");
CBReleaseObject(data);
return 0;
}
uint32_t len = CBNetworkAddressDeserialise(self->addRecv, false); // No time from version message.
if (NOT len){
CBGetMessage(self)->logError("CBVersion cannot be deserialised because of an error with the receiving address.");
CBReleaseObject(data);
return 0;
}
// Readjust CBByteArray length for recieving address
data->length = len;
CBReleaseObject(data);
if (self->version >= 106) { // ??? Very old. No need for backwards compatibility? Might as well.
if (bytes->length < 85) {
CBGetMessage(self)->logError("Attempting to deserialise a CBVersion with less than 85 bytes required.");
return 0;
}
// Source address deserialisation
data = CBByteArraySubReference(bytes, 46, bytes->length-46);
if (NOT data) {
CBGetMessage(self)->logError("Cannot create a new CBByteArray in CBVersionDeserialise for the source address.");
return 0;
}
self->addSource = CBNewNetworkAddressFromData(data, CBGetMessage(self)->logError);
if (NOT self->addSource) {
CBGetMessage(self)->logError("Cannot create a new CBNetworkAddress in CBVersionDeserialise for the source address.");
CBReleaseObject(data);
return 0;
}
uint32_t len = CBNetworkAddressDeserialise(self->addSource, false); // No time from version message.
if (NOT len){
CBGetMessage(self)->logError("CBVersion cannot be deserialised because of an error with the source address.");
CBReleaseObject(data);
return 0;
}
// Readjust CBByteArray length for source address
data->length = len;
CBReleaseObject(data);
self->nonce = CBByteArrayReadInt64(bytes, 72);
uint8_t x = CBByteArrayGetByte(bytes, 80); // Check length for decoding CBVarInt
if (x > 253){
CBGetMessage(self)->logError("Attempting to deserialise a CBVersion with a var string that is too big.");
return 0;
}
CBVarInt varInt = CBVarIntDecode(bytes, 80);
if (bytes->length < 84 + varInt.size + varInt.val) {
CBGetMessage(self)->logError("Attempting to deserialise a CBVersion without enough space to cover the userAgent and block height.");
return 0;
}
if (varInt.val > 400) { // cbitcoin accepts userAgents upto 400 bytes
CBGetMessage(self)->logError("Attempting to deserialise a CBVersion with a userAgent over 400 bytes.");
return 0;
}
self->userAgent = CBNewByteArraySubReference(bytes, 80 + varInt.size, (uint32_t)varInt.val);
if (NOT self->userAgent) {
CBGetMessage(self)->logError("Cannot create a new CBByteArray in CBVersionDeserialise");
return 0;
}
self->blockHeight = CBByteArrayReadInt32(bytes, 80 + varInt.size + (uint32_t)varInt.val);
return 84 + varInt.size + (uint32_t)varInt.val;
}else return 46; // Not the further message.
}
uint32_t CBBlockDeserialise(CBBlock * self, bool transactions){
CBByteArray * bytes = CBGetMessage(self)->bytes;
if (NOT bytes) {
CBLogError("Attempting to deserialise a CBBlock with no bytes.");
return 0;
}
if (bytes->length < 82) {
CBLogError("Attempting to deserialise a CBBlock with less than 82 bytes. Minimum for header (With null byte).");
return 0;
}
self->version = CBByteArrayReadInt32(bytes, 0);
self->prevBlockHash = CBByteArraySubReference(bytes, 4, 32);
if (NOT self->prevBlockHash){
CBLogError("Cannot create the previous block hash CBByteArray in CBBlockDeserialise.");
return 0;
}
self->merkleRoot = CBByteArraySubReference(bytes, 36, 32);
if (NOT self->merkleRoot){
CBLogError("Cannot create the merkle root CBByteArray in CBBlockDeserialise.");
return 0;
}
self->time = CBByteArrayReadInt32(bytes, 68);
self->target = CBByteArrayReadInt32(bytes, 72);
self->nonce = CBByteArrayReadInt32(bytes, 76);
// If first VarInt byte is zero, then stop here for headers, otherwise look for 8 more bytes and continue
uint8_t firstByte = CBByteArrayGetByte(bytes, 80);
if (transactions && firstByte) {
// More to come
if (bytes->length < 89) {
CBLogError("Attempting to deserialise a CBBlock with a non-zero varint with less than 89 bytes.");
return 0;
}
CBVarInt transactionNumVarInt = CBVarIntDecode(bytes, 80);
if (transactionNumVarInt.val*60 > bytes->length - 81) {
CBLogError("Attempting to deserialise a CBBlock with too many transactions for the byte data length.");
return 0;
}
self->transactionNum = (uint32_t)transactionNumVarInt.val;
self->transactions = malloc(sizeof(*self->transactions) * self->transactionNum);
if (NOT self->transactionNum) {
CBLogError("Cannot allocate %i bytes of memory in CBBlockDeserialise\n", sizeof(*self->transactions) * self->transactionNum);
return 0;
}
uint32_t cursor = 80 + transactionNumVarInt.size;
for (uint16_t x = 0; x < self->transactionNum; x++) {
CBByteArray * data = CBByteArraySubReference(bytes, cursor, bytes->length-cursor);
if (NOT data) {
CBLogError("Could not create a new CBByteArray in CBBlockDeserialise for the transaction number %u.", x);
}
CBTransaction * transaction = CBNewTransactionFromData(data);
if (NOT transaction){
CBLogError("Could not create a new CBTransaction in CBBlockDeserialise for the transaction number %u.", x);
CBReleaseObject(data);
return 0;
}
uint32_t len = CBTransactionDeserialise(transaction);
if (NOT len){
CBLogError("CBBlock cannot be deserialised because of an error with the transaction number %u.", x);
CBReleaseObject(data);
return 0;
}
// Read just the CBByteArray length
data->length = len;
CBReleaseObject(data);
self->transactions[x] = transaction;
cursor += len;
}
return cursor;
}else{ // Just header
uint8_t x;
if (firstByte < 253) {
x = 1;
}else if (firstByte == 253){
x = 2;
}else if (firstByte == 254){
x = 4;
}else{
x = 8;
}
if (bytes->length < 80 + x + 1) {
CBLogError("Attempting to deserialise a CBBlock header with not enough space to cover the var int.");
return 0;
}
self->transactionNum = (uint32_t)CBVarIntDecode(bytes, 80).val; // This value is undefined in the protocol. Should best be zero when getting the headers since there is not supposed to be any transactions. Would have probably been better if the var int was dropped completely for headers only.
// Ensure null byte is null. This null byte is a bit of a nuissance but it exists in the protocol when there are no transactions.
if (CBByteArrayGetByte(bytes, 80 + x) != 0) {
CBLogError("Attempting to deserialise a CBBlock header with a final byte which is not null. This is not what it is supposed to be but you already knew that right?");
return 0;
}
return 80 + x + 1; // 80 header bytes, the var int and the null byte
}
}