agorise/c-multiaddr
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge pull request #4 from jmjatlanta/master

Browse source 
Multiple fixes to code
This commit is contained in:
John M. Jones 2017-02-15 12:14:04 -05:00 committed by GitHub
commit 5cb09b3708
8 changed files with 157 additions and 134 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

27
include/multiaddr/protocols.h
View file

@ -8,28 +8,33 @@
#include <errno.h> #include <errno.h>
#include "varhexutils.h" #include "varhexutils.h"
struct protocol struct Protocol
{ {
char hexcode[21]; //char hexcode[21];
int deccode; int deccode;
int size; int size;
char name[30]; char name[30];
}; };
struct protocol *protocol_P; //Pointer for holding multiple structures struct ProtocolListItem {
struct Protocol* current;
struct ProtocolListItem* next;
};
int protocol_REMOVE_id(int remid); //Function to remove & shift back all data, sort of like c++ vectors. int protocol_REMOVE_id(struct ProtocolListItem* head, int remid); //Function to remove & shift back all data, sort of like c++ vectors.
void unload_protocols(); void unload_protocols(struct ProtocolListItem* head);
void load_protocols(); /**
* load the available protocols into the global protocol_P
* @returns True(1) on success, otherwise 0
*/
int load_protocols(struct ProtocolListItem** head);
struct protocol * proto_with_name(char proto_w_name[]); //Search for protocol with inputted name struct Protocol * proto_with_name(const struct ProtocolListItem* head, const char* proto_w_name); //Search for protocol with inputted name
struct protocol * proto_with_deccode(int proto_w_deccode); //Search for protocol with inputted deccode struct Protocol * proto_with_deccode(const struct ProtocolListItem* head, int proto_w_deccode); //Search for protocol with inputted deccode
void pp(); //Purely for debugging purposes, prints the entire loaded protocols. void protocols_with_string(const struct ProtocolListItem* head, char * meee, int sizi); // NOT FINISHED, DO NOT USE!
void protocols_with_string(char * meee,int sizi); // NOT FINISHED, DO NOT USE!
#endif #endif

6
include/multiaddr/protoutils.h
View file

@ -32,10 +32,10 @@ uint64_t ip2int(const char * ipconvertint);
char * int2ip(int inputintip); char * int2ip(int inputintip);
//I didn't feel another address_bytes_to_string was necesarry sry guys //I didn't feel another address_bytes_to_string was necesarry sry guys
int bytes_to_string(char * resultzx, const uint8_t * catx,int xbsize); int bytes_to_string(char** resultzx, const uint8_t * catx,int xbsize);
char * address_string_to_bytes(struct protocol * xx, const char * abc, size_t getsznow); char * address_string_to_bytes(struct Protocol * xx, const char * abc, size_t getsznow);
int string_to_bytes(uint8_t * finalbytes,size_t* realbbsize,char * strx, size_t strsize); int string_to_bytes(uint8_t** finalbytes,size_t* realbbsize, const char * strx, size_t strsize);
#endif #endif

8
include/multiaddr/varhexutils.h
View file

@ -33,7 +33,13 @@ void vthconvert(int size, char * crrz01, uint8_t * xbuf);
char * Var_To_Hex(int realsize, const uint8_t * TOHEXINPUT); //VAR[binformat] TO HEX char * Var_To_Hex(int realsize, const uint8_t * TOHEXINPUT); //VAR[binformat] TO HEX
uint8_t * Hex_To_Var(char * Hexstr); //HEX TO VAR[BINFORMAT] /**
* Turn a hex string into a byte array
* @param incoming a string of hex values
* @param num_bytes the size of the result
* @returns a pointer to the converted value
*/
unsigned char* Hex_To_Var(char * Hexstr, size_t* num_bytes);
// //
void convert(char * convert_result, uint8_t * buf); //Both of them read them properly. void convert(char * convert_result, uint8_t * buf); //Both of them read them properly.

8
multiaddr.c
View file

@ -50,7 +50,7 @@ struct MultiAddress* multiaddress_new_from_bytes(const uint8_t* byteaddress, int
return NULL; return NULL;
} }
memcpy(out->bytes, byteaddress, size); memcpy(out->bytes, byteaddress, size);
if(!bytes_to_string(out->string,byteaddress,size)==1) if(!bytes_to_string(&out->string,byteaddress,size)==1)
{ {
multiaddress_free(out); multiaddress_free(out);
return NULL; return NULL;
@ -64,14 +64,14 @@ struct MultiAddress* multiaddress_new_from_string(const char* straddress)//Const
{ {
struct MultiAddress* out = multiaddress_new(); struct MultiAddress* out = multiaddress_new();
if (out != NULL) { if (out != NULL) {
out->string = malloc(sizeof(straddress) + 1); out->string = malloc(strlen(straddress) + 1);
if (out->string == NULL) { if (out->string == NULL) {
multiaddress_free(out); multiaddress_free(out);
return NULL; return NULL;
} }
strcpy(out->string, straddress); strcpy(out->string, straddress);
if (string_to_bytes(out->bytes, &out->bsize, out->string, sizeof(out->string)) == 0 ) if (string_to_bytes(&out->bytes, &out->bsize, out->string, strlen(out->string)) == 0 )
{ {
multiaddress_free(out); multiaddress_free(out);
return NULL; return NULL;
@ -138,7 +138,7 @@ int multiaddress_encapsulate(struct MultiAddress* result, char* string)
return 0; return 0;
} }
strcpy(result->string, string); strcpy(result->string, string);
if(string_to_bytes(result->bytes, &result->bsize, result->string, sizeof(result->string)) == 0) if(string_to_bytes(&result->bytes, &result->bsize, result->string, sizeof(result->string)) == 0)
{ {
multiaddress_free(result); multiaddress_free(result);
return 0; return 0;

111
protocols.c
View file

@ -7,23 +7,20 @@
#include "multiaddr/protocols.h" #include "multiaddr/protocols.h"
#include "multiaddr/varhexutils.h" #include "multiaddr/varhexutils.h"
int CNT_PROTOCOLNUM=0; /*
int protocol_REMOVE_id(struct ProtocolListItem* protocol_P, int remid)//Function to remove & shift back all data, sort of like c++ vectors.
struct protocol *protocol_P; //Pointer for holding multiple structures
int protocol_REMOVE_id(int remid)//Function to remove & shift back all data, sort of like c++ vectors.
{ {
if(remid < CNT_PROTOCOLNUM && remid >= 0&&CNT_PROTOCOLNUM!=0) //Checking to see if remid actually exists. if(remid < CNT_PROTOCOLNUM && remid >= 0&&CNT_PROTOCOLNUM!=0) //Checking to see if remid actually exists.
{ {
for(int i=remid; i<CNT_PROTOCOLNUM-1; ++i) //While i < num of registered protocols //Needs to be tested that -1 is for valgrind debugging for(int i=remid; i<CNT_PROTOCOLNUM-1; ++i) //While i < num of registered protocols //Needs to be tested that -1 is for valgrind debugging
{ {
strcpy((protocol_P+i)->hexcode, (protocol_P+i+1)->hexcode); //shift memory to the user we want to remove. //strcpy((protocol_P+i)->hexcode, (protocol_P+i+1)->hexcode); //shift memory to the user we want to remove.
(protocol_P+i)->deccode = (protocol_P+i+1)->deccode; //Same as above (protocol_P+i)->deccode = (protocol_P+i+1)->deccode; //Same as above
(protocol_P+i)->size = (protocol_P+i+1)->size; //Same as above (protocol_P+i)->size = (protocol_P+i+1)->size; //Same as above
strcpy((protocol_P+i)->name, (protocol_P+i+1)->name); //Same as above strcpy((protocol_P+i)->name, (protocol_P+i+1)->name); //Same as above
}//Overwriting user done. Time to get rid of that extra memory. }//Overwriting user done. Time to get rid of that extra memory.
protocol_P = (struct protocol*) realloc(protocol_P, (CNT_PROTOCOLNUM-1) * sizeof(struct protocol)); protocol_P = (struct Protocol*) realloc(protocol_P, (CNT_PROTOCOLNUM-1) * sizeof(struct Protocol));
//Memory erased, //Memory erased,
CNT_PROTOCOLNUM--; //Since the record no longer exists, we should decrease the ammount of users. CNT_PROTOCOLNUM--; //Since the record no longer exists, we should decrease the ammount of users.
return 1; //Purely for error checking, in case someone ever wants it/ return 1; //Purely for error checking, in case someone ever wants it/
@ -41,13 +38,52 @@ int protocol_REMOVE_id(int remid)//Function to remove & shift back all data, sor
return 0; return 0;
} }
} }
void unload_protocols() */
void unload_protocols(struct ProtocolListItem* head)
{ {
free(protocol_P); struct ProtocolListItem* current = head;
CNT_PROTOCOLNUM=0; while (current != NULL) {
struct ProtocolListItem* next = current->next;
free(current->current);
free(current);
current = next;
} }
void load_protocols() }
/**
* load the available protocols into the global protocol_P
* @returns True(1) on success, otherwise 0
*/
int load_protocols(struct ProtocolListItem** head)
{ {
unload_protocols(*head);
int num_protocols = 14;
int dec_code[] = {4, 41, 6, 17, 33, 132, 301, 302, 42, 480, 443, 477, 444, 275};
int size[] = {32, 128, 16, 16, 16, 16, 0, 0, -1, 0, 0, 0, 10, 0 };
char* name[] = { "ip4", "ip6", "tcp", "udp", "dccp", "sctp", "udt", "utp", "ipfs", "http", "https", "ws", "onion", "libp2p-webrtc-star" };
struct ProtocolListItem* last = NULL;
for(int i = 0; i < num_protocols; i++) {
struct ProtocolListItem* current_item = (struct ProtocolListItem*)malloc(sizeof(struct ProtocolListItem));
current_item->current = (struct Protocol*)malloc(sizeof(struct Protocol));
current_item->next = NULL;
current_item->current->deccode = dec_code[i];
strcpy(current_item->current->name, name[i]);
current_item->current->size = size[i];
if (*head == NULL) {
*head = current_item;
} else {
last->next = current_item;
}
last = current_item;
}
return 1;
}
/*
void load_protocols_from_file(struct Protocol** in)
{
struct Protocol* protocol_P = *in;
FILE *FPROC_POINT; //File pointer. FILE *FPROC_POINT; //File pointer.
FPROC_POINT = fopen("proto-dat", "r");//Opening proto-dat Or protocols.csv, I just formatted it to my liking. FPROC_POINT = fopen("proto-dat", "r");//Opening proto-dat Or protocols.csv, I just formatted it to my liking.
if(FPROC_POINT != NULL) //While pointer is not null. if(FPROC_POINT != NULL) //While pointer is not null.
@ -62,13 +98,13 @@ void load_protocols()
//ADD MEMORY FOR NEW PROTOCOL //ADD MEMORY FOR NEW PROTOCOL
if(CNT_PROTOCOLNUM==0) //If there are no registered protocols yet, allocate memory to pointer. if(CNT_PROTOCOLNUM==0) //If there are no registered protocols yet, allocate memory to pointer.
{ {
protocol_P = (struct protocol*) malloc (sizeof(struct protocol)); protocol_P = (struct Protocol*) malloc (sizeof(struct Protocol));
} }
else //Reallocate memory to fit one more protocol else //Reallocate memory to fit one more Protocol
{ {
protocol_P = (struct protocol*) realloc(protocol_P, (CNT_PROTOCOLNUM+1) * sizeof(struct protocol)); protocol_P = (struct Protocol*) realloc(protocol_P, (CNT_PROTOCOLNUM+1) * sizeof(struct protocol));
} }
strcpy((protocol_P+CNT_PROTOCOLNUM)->hexcode, W_BUFF); //Copy word to structure at hexcode A hexcode is a string so we keep it as such //strcpy((protocol_P+CNT_PROTOCOLNUM)->hexcode, W_BUFF); //Copy word to structure at hexcode A hexcode is a string so we keep it as such
break; break;
} }
case 1://Second word - DECCODE case 1://Second word - DECCODE
@ -96,53 +132,42 @@ void load_protocols()
} }
} }
fclose(FPROC_POINT); fclose(FPROC_POINT);
protocol_REMOVE_id(0); protocol_REMOVE_id(protocol_P, 0);
} }
else else
{ {
perror("Fatal Error:"); perror("Fatal Error:");
} }
} }
struct protocol * proto_with_name(char proto_w_name[]) //Search for protocol with inputted name */
{
for(int i=0; i<CNT_PROTOCOLNUM; i++) struct Protocol* proto_with_name(const struct ProtocolListItem* head, const char* proto_w_name) //Search for Protocol with inputted name
{ {
if(strcmp(proto_w_name, (protocol_P+i)->name) == 0) const struct ProtocolListItem* current = head;
while(current != NULL)
{ {
return (protocol_P+i); if (strcmp(proto_w_name, current->current->name) == 0) {
return current->current;
} }
current = current->next;
} }
return NULL; return NULL;
} }
struct protocol * proto_with_deccode(int proto_w_deccode) //Search for protocol with inputted deccode
struct Protocol* proto_with_deccode(const struct ProtocolListItem* head, int proto_w_deccode) //Search for Protocol with inputted deccode
{ {
for(int i=0; i<CNT_PROTOCOLNUM; i++) const struct ProtocolListItem* current = head;
while(current != NULL)
{ {
if((protocol_P+i)->deccode == proto_w_deccode) if (current->current->deccode == proto_w_deccode) {
{ return current->current;
return (protocol_P+i);
} }
current = current->next;
} }
return NULL; return NULL;
} }
void pp() //Purely for debugging purposes, prints the entire loaded protocols.
{ void protocols_with_string(const struct ProtocolListItem* head, char* meee, int sizi) // NOT FINISHED, DO NOT USE!
for(int i=0;i<CNT_PROTOCOLNUM;i++)
{
if(i>=9)
{printf("=========== ~%d~ ===========\n", i+1);}
else
{printf("=========== ~0%d~ ===========\n", i+1);}
printf(">> HEX-CODE: %s\n", (protocol_P+i)->hexcode);
printf(">> DEC-CODE: %d\n", (protocol_P+i)->deccode);
printf(">> SIZE: %d\n", (protocol_P+i)->size);
printf(">> NAME: %s\n", (protocol_P+i)->name);
}
printf("----------------------------\n");
printf("TOTAL PROTOCOLS: %d\n",CNT_PROTOCOLNUM);
}
void protocols_with_string(char * meee,int sizi) // NOT FINISHED, DO NOT USE!
{ {
int finalsize = 0; int finalsize = 0;

81
protoutils.c
View file

@ -291,13 +291,16 @@ char * int2ip(int inputintip)
return xxx_int2ip_result; return xxx_int2ip_result;
} }
//I didn't feel another address_bytes_to_string was necesarry sry guys //I didn't feel another address_bytes_to_string was necesarry sry guys
int bytes_to_string(char * resultzx, const uint8_t* catx,int xbsize) int bytes_to_string(char** buffer, const uint8_t* catx, int xbsize)
{ {
*buffer = malloc(800);
char* resultzx = *buffer;
bzero(resultzx, 800); bzero(resultzx, 800);
uint8_t * bytes = NULL; uint8_t * bytes = NULL;
int size = 0; int size = 0;
size = xbsize; size = xbsize;
load_protocols(); struct ProtocolListItem* head = NULL;
load_protocols(&head);
char hex[xbsize*2]; char hex[xbsize*2];
bzero(hex,xbsize*2); bzero(hex,xbsize*2);
strcat(hex,Var_To_Hex(size, catx)); strcat(hex,Var_To_Hex(size, catx));
@ -309,21 +312,17 @@ int bytes_to_string(char * resultzx, const uint8_t* catx,int xbsize)
//Stage 1 ID: //Stage 1 ID:
if(lastpos!=0) if(lastpos!=0)
{ {
lastpos+1; lastpos++;
} }
pid[0] = hex[lastpos]; pid[0] = hex[lastpos];
pid[1] = hex[lastpos+1]; pid[1] = hex[lastpos+1];
pid[2] = '\0'; pid[2] = '\0';
if(lastpos == 0) if(proto_with_deccode(head, Hex_To_Int(pid)))
{
load_protocols();
}
if(proto_with_deccode(Hex_To_Int(pid)))
{ {
//////////Stage 2: Address //////////Stage 2: Address
struct protocol * PID; struct Protocol * PID;
PID = NULL; PID = NULL;
PID = proto_with_deccode(Hex_To_Int(pid)); PID = proto_with_deccode(head, Hex_To_Int(pid));
if(strcmp(PID->name,"ipfs")!=0) if(strcmp(PID->name,"ipfs")!=0)
{ {
lastpos = lastpos+2; lastpos = lastpos+2;
@ -403,9 +402,8 @@ int bytes_to_string(char * resultzx, const uint8_t* catx,int xbsize)
//printf("\nIPFS_ADDR[%d] = %c\n\n",IPFS_PARSE,hex[i]); //printf("\nIPFS_ADDR[%d] = %c\n\n",IPFS_PARSE,hex[i]);
IPFS_PARSE++; IPFS_PARSE++;
} }
unsigned char addrbuf[strlen(IPFS_ADDR)/2]; size_t num_bytes = 0;
bzero(addrbuf,strlen(IPFS_ADDR)/2); unsigned char* addrbuf = Hex_To_Var(IPFS_ADDR, &num_bytes);
memcpy(addrbuf,Hex_To_Var(IPFS_ADDR),sizeof(addrbuf));
size_t rezbuflen = strlen(IPFS_ADDR); size_t rezbuflen = strlen(IPFS_ADDR);
unsigned char rezultat[rezbuflen]; unsigned char rezultat[rezbuflen];
bzero(rezultat,rezbuflen); bzero(rezultat,rezbuflen);
@ -413,9 +411,11 @@ int bytes_to_string(char * resultzx, const uint8_t* catx,int xbsize)
pointyaddr = rezultat; pointyaddr = rezultat;
int returnstatus = 0; int returnstatus = 0;
returnstatus = multiaddr_encoding_base58_encode(addrbuf, sizeof(addrbuf), &pointyaddr, &rezbuflen); returnstatus = multiaddr_encoding_base58_encode(addrbuf, sizeof(addrbuf), &pointyaddr, &rezbuflen);
free(addrbuf);
if(returnstatus == 0) if(returnstatus == 0)
{ {
printf("\nERROR!!!!!\n"); printf("\nERROR!!!!!\n");
unload_protocols(head);
return 0; return 0;
} }
strcat(resultzx, "/"); strcat(resultzx, "/");
@ -425,12 +425,13 @@ int bytes_to_string(char * resultzx, const uint8_t* catx,int xbsize)
} }
} }
strcat(resultzx, "/"); strcat(resultzx, "/");
unload_protocols(); unload_protocols(head);
return 1;
} }
// //
char * address_string_to_bytes(struct protocol * xx, const char * abc,size_t getsznow) char * address_string_to_bytes(struct Protocol * xx, const char * abc,size_t getsznow)
{ {
static char astb__stringy[800] = "\0"; static char astb__stringy[800] = "\0";
bzero(astb__stringy,800); bzero(astb__stringy,800);
@ -644,48 +645,43 @@ char * address_string_to_bytes(struct protocol * xx, const char * abc,size_t get
* @param strx the incoming string * @param strx the incoming string
* @param strsize the string length * @param strsize the string length
*/ */
int string_to_bytes(uint8_t * finalbytes, size_t* realbbsize, char * strx, size_t strsize) int string_to_bytes(uint8_t** finalbytes, size_t* realbbsize, const char* strx, size_t strsize)
{ {
if(strx[0] != '/') if(strx[0] != '/')
{ {
printf("Error, must start with '/'\n"); printf("Error, must start with '/'\n");
return 0; return 0;
} }
//Getting total words
int totalwords = 0;
char* totp;
char totalwordstest[strsize + 1];
bzero(totalwordstest,strsize + 1);
strcat(totalwordstest, strx);
totp = strtok(totalwordstest, "/");
while(totp != NULL)
{
totp = strtok (NULL, "/");
totalwords++;
}
//Initializing variables to store our processed HEX in: //Initializing variables to store our processed HEX in:
int malf=0; //In case something goes wrong this will be 1. int malf=0; //In case something goes wrong this will be 1.
char processed[800];//HEX CONTAINER char processed[800];//HEX CONTAINER
bzero(processed,800); bzero(processed,800);
//Now Setting up variables for calculating which is the first //Now Setting up variables for calculating which is the first
//and second word: //and second word:
int firstorsecond = 1; //1=Protocol && 2 = Address int firstorsecond = 1; //1=Protocol && 2 = Address
char pstring[strsize + 1];//We do not want to harm the initial string.
bzero(pstring,strsize + 1); // copy input so as to not harm it
strcat(pstring,strx); char pstring[strsize + 1];
strcpy(pstring,strx);
// load up the list of protocols
struct ProtocolListItem* head = NULL;
load_protocols(&head);
//Starting to extract words and process them: //Starting to extract words and process them:
char * wp; char * wp;
char * end; char * end;
wp=strtok_r(pstring,"/",&end); wp=strtok_r(pstring,"/",&end);
load_protocols(); struct Protocol * protx;
struct protocol * protx;
while(wp) while(wp)
{ {
if(firstorsecond==1)//This is the Protocol if(firstorsecond==1)//This is the Protocol
{ {
if(proto_with_name(wp)) if(proto_with_name(head, wp))
{ {
protx=proto_with_name(wp); protx=proto_with_name(head, wp);
//printf("PROTOCOL: %s\n",protx->name); //printf("PROTOCOL: %s\n",protx->name);
strcat(processed, Int_To_Hex(protx->deccode)); strcat(processed, Int_To_Hex(protx->deccode));
firstorsecond=2;//Since the next word will be an address firstorsecond=2;//Since the next word will be an address
@ -716,8 +712,7 @@ int string_to_bytes(uint8_t * finalbytes, size_t* realbbsize, char * strx, size_
wp=strtok_r(NULL,"/",&end); wp=strtok_r(NULL,"/",&end);
} }
protx=NULL; protx=NULL;
unload_protocols(); unload_protocols(head);
//printf("Processed contains: %s \n",processed);
if(malf==1) if(malf==1)
{ {
@ -725,17 +720,7 @@ int string_to_bytes(uint8_t * finalbytes, size_t* realbbsize, char * strx, size_
} }
else else
{ {
bzero(finalbytes,400); *finalbytes = Hex_To_Var(processed, realbbsize);
//printf("XXX: %s\n",xxx);
memcpy(finalbytes, Hex_To_Var(processed), 400);
realbbsize[0] = 0;
for(int i=0;i<400;i++)
{
if(finalbytes[i])
{
realbbsize[0]++;
}
}
return 1; return 1;
} }
} }

5
testing.c
View file

@ -4,8 +4,7 @@
int main() int main()
{ {
char addrstr[100]; char addrstr[100];
bzero(addrstr,100); strcpy(addrstr,"/ip4/192.168.1.1/tcp/8080/");
strcat(addrstr,"/ip4/192.168.1.1/tcp/8080/");
printf("INITIAL: %s\n",addrstr); printf("INITIAL: %s\n",addrstr);
struct MultiAddress* a; struct MultiAddress* a;
a= multiaddress_new_from_string(addrstr); a= multiaddress_new_from_string(addrstr);
@ -14,7 +13,7 @@ int main()
//Remember, Decapsulation happens from right to left, never in reverse! //Remember, Decapsulation happens from right to left, never in reverse!
printf("A STRING:%s\n",a->string); printf("A STRING:%s\n",a->string);
multiaddress_encapsulate(a,"/ip4/192.31.200.1/udp/3333/"); multiaddress_encapsulate(a,"/ip4/192.131.200.111/udp/3333/");
printf("A STRING ENCAPSULATED:%s\n",a->string); printf("A STRING ENCAPSULATED:%s\n",a->string);
multiaddress_decapsulate(a,"udp"); multiaddress_decapsulate(a,"udp");

39
varhexutils.c
View file

@ -116,32 +116,35 @@ char * Var_To_Hex(int realsize, const uint8_t * TOHEXINPUT) //VAR[binformat] TO
return convert_resultz1; return convert_resultz1;
} }
} }
uint8_t * Hex_To_Var(char * Hexstr) //HEX TO VAR[BINFORMAT]
/**
* Turn a hex string into a byte array
* @param incoming a string of hex values
* @param num_bytes the size of the result
* @returns a pointer to the converted value
*/
unsigned char* Hex_To_Var(const char* incoming, size_t* num_bytes) //HEX TO VAR[BINFORMAT]
{ {
static uint8_t buffy_HEX[400] = {0}; // the return value
bzero(buffy_HEX,400); unsigned char* retVal = NULL;
int i; int incoming_size = strlen(incoming);
char codo[800] = "\0"; *num_bytes = incoming_size / 2;
bzero(codo,800); retVal = (unsigned char*)malloc(*num_bytes);
strcpy(codo, Hexstr);
char code[3]; char code[3];
bzero(code,3);
code[3]='\0'; code[3]='\0';
int x = 0; int i=0;
int fori001=0; for(i=0; i < incoming_size; i += 2)
for(fori001=0;fori001<800;fori001++)
{ {
strncpy(&code[0],&codo[fori001],1); code[0] = incoming[i];
strncpy(&code[1],&codo[fori001+1],1); code[1] = incoming[i+1];
char *ck = NULL; char *ck = NULL;
uint64_t lu = 0; uint64_t lu = 0;
lu=strtoul(code, &ck, 16); lu=strtoul(code, &ck, 16);
buffy_HEX[x] = lu; retVal[i] = lu;
//printf("%s - %lu\n",code,lu); i++;
fori001++;
x++;
} }
return buffy_HEX; return retVal;
} }
// //
void convert(char * convert_result, uint8_t * buf) //Both of them read them properly. void convert(char * convert_result, uint8_t * buf) //Both of them read them properly.