binary to int with strtol in C [closed] - c

Question

Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 7 years ago.
Improve this question
I'm extracting 8 bytes from a big-endian binary file to decode into actual readable information, the second nibble from byte 4, byte 5 and byte 6 need to be concatenated and printed as a long integer value:
example input data (in binary): 0000 0000 0101 0110 1111 1000 0101 0101 0000 0001 0011 1010 0101 0000 0000 0110
example input data (hex representation): 0x0056f855013a5006
In bold are the bits i'm intending to print as long integer.
expected output: 80464
I tried the following but the result of strtol is always 0, I tried using base 0,2,10,16 always result 0.
#include<stdio.h>
#include<stdlib.h>
int main()
{
unsigned char fromfile[8]; //contains 8 bytes from a binary file
unsigned long int output; //output to be printed
unsigned char numbers[4];
numbers[0] = fromfile[4]&0x0f;
numbers[1] = fromfile[5];
numbers[2] = fromfile[6];
numbers[3] = '\0';
output=strtol (numbers,NULL,2);
printf("%lu",output);
return 0;
}
To elaborate fromfile array contains the following:
fromfile[0]=0x00;
fromfile[1]=0x56;
fromfile[2]=0xf8;
fromfile[3]=0x55;
fromfile[4]=0x01;
fromfile[5]=0x3a;
fromfile[6]=0x50;
fromfile[7]=0x06;
Compiling this code using the gcc compiler on a centos virtual machine.

Answer 1

Assuming the input byte order is big-endian, you can do this:
unsigned char fromfile[8]; //contains 8 bytes from a binary file
unsigned long int output; //output to be printed
output =
(fromfile[4] & 0xf) << 16 |
fromfile[5] << 8 |
fromfile[6];
printf("%lu", output);
To explain what's happening in the expression assigned to output, let's look at bytes 4 through 6 of the input which correspond to the binary digits 23 through 0 of the desired value (because of the big endian byte order):
byte: 4 5 6
bit: 23 15 7 0
00001111 11111111 11111111
We're interested in the bits masked with 1 and not interested in bits masked with 0.
fromfile[4] & 0xf takes byte 4 and masks its value with F16 = 000011112, which is exactly the mask underneath byte 4 in the figure above, using the bitwise AND operation (&).
... << 16 shifts the result of step 1 to the left by 16 binary digit positions, which is exactly the position where we need the lower nibble of byte 4 to go according to the figure above.
fromfile[5] << 8 – similarly to step 2, this takes byte 5 and shifts it to the left by 5 positions because that's where its bits are supposed to go.
fromfile[6] doesn't perform a bit shift, because the value read from byte 6 needs to be mapped to the lowest 8 bits of the output value anyway.
So now we have three values (X, Y, and Z mark unknown bits of the values x, y, and z respectively):
0000XXXX 00000000 00000000
00000000 YYYYYYYY 00000000
00000000 00000000 ZZZZZZZZ
To assemble them into one value, we use the binary OR operation (|) twice (x | y | z):
0000XXXX YYYYYYYY ZZZZZZZZ
This is exactly how we want the bits of the input data arranged and we're done.