How to read caret notations from a binary file in C? - c

Question

I have a requirement to read the characters in a binary file one byte at a time and concatenate them when a certain condition is met. I'm running into problems while reading the null character i.e ^# as denoted in the caret notations. Neither snprintf nor strcpy is helping me concatenate this null character with other characters. It is strange because when I print this character using
printf("%c",char1);
it prints out the null character in the caret notation i.e ^#. So my understanding is that even snprintf should have succeeded in concatenation.
Could anybody please let me know how can I achieve such a concatenation?
Thanks

Answer 1

C strings are null-terminated. If your input data can contain null bytes, you cannot use the string functions safely. Instead, consider just allocating a large-enough buffer (or dynamically resizing it as needed) and write each incoming byte to the right place in that buffer.

Answer 2

Since you're not working with raw ANSI strings, you can't use functions meant to be used with raw ANSI strings, because the way the interpret strings.
In C (and C++) strings are usually null terminated, i.e. the last character is \0 (value 0x00). At least this is true for standard functions for string manipulation and input/ouput (like printf() or strcpy()).
For example, the line
const char *text = "Hello World";
behind the scenes becomes
const char *text = "Hello World\0";
So when you're reading \0 from a file and putting it into your string, you essentially end up with an essentially empty string.
To make the issue more clear, just a simple example:
// Let's just assume the sequence 0x00, 0x01 is some special encoding
const char *input = "Hello\0\1World!";
char output[256];
strcpy(output, input);
// strncpy() is for string manipulation, as such it will stop once it encounters a null terminator
printf("%s\n", output); // This will print 'Hello'
memcpy(output, input, 14); // 14 is the string length above plus null terminator
printf("%s\n", output); // This will again print 'Hello' (since it stops at the terminator)
printf("%s\n", output + 7); // This will print "World" (you're skipping the terminator using the offset)
The following is a quick example I put together. It doesn't necessarily show best practice and it's also likely that there are a few bugs in there, but it should show you some possible concepts how to work with raw byte data, avoiding standard string functions wherever possible.
#include <stdio.h>
#define WIDTH 16
int main (int argc, char **argv) {
int offset = 0;
FILE *fp;
int byte;
char buffer[WIDTH] = ""; // This buffer will store the data read, essentially concatenating it
if (argc < 2)
return 1;
if (fp = fopen(argv[1], "rb")) {
for(;;) {
byte = fgetc(fp); // get the next byte
if (byte == EOF) { // did we read over the end of the file?
if (offset % WIDTH)
printf("%*s %*.*s", 3 * (WIDTH - offset % WIDTH), "", offset % WIDTH, offset % WIDTH, buffer);
else
printf("\n");
return 0;
}
if (offset % WIDTH == 0) { // should we print the offset?
if (offset)
printf(" %*.*s", WIDTH, WIDTH, buffer); // print the char representation of the last line
printf("\n0x%08x", offset);
}
// print the hex representation of the current byte
printf(" %02x", byte);
// add printable characters to our buffer
if (byte >= ' ')
buffer[offset % WIDTH] = byte;
else
buffer[offset % WIDTH] = '.';
// move the offset
++offset;
}
fclose(fp);
}
return 0;
}
Once compiled, pass any file as the first parameter to view its contents (shouldn't be too big to not break formatting).