Segmentation Fault with fread() from my created binary file - c

Question

I'm new to c from python. I'm trying to write two c scripts, one that reads a plain-text file in FASTA format (for DNA/RNA/protein sequences). They look like this...
>sequence1
ATCTATGTCGCTCGCTCGAGAGCTA
>sequence2
CGTCGCTGGGATCGATTTCGATAGCT
>sequence3
AAATATAACTCGCTAGCTCGATCGATC
>sequence4
CTCTCTCCTCTCTCTATATAGGGG
...where individual sequences are separated by ">" characters. Within each sequence, the actual sequence and its label are separated by a newline character. (ie ">label \n sequence"). The script for reading the plain-text and then writing it to a binary file seems to work. However, when I try to read the binary file and print its contents, I get a Segmentation Fault (Core dump).
I tried to produce a reduced example for posting here, but that example seems to work without error. So, I feel forced to attach my whole code snippets here. I must be missing something.
Here's the first script which reads in a plain text fasta file, splits it first by the ">" character, and then by the newline character, to make "sequence" structures for each sequence in the above FASTA file. These structures are then written to "your_sequences.bin".
#include <stdio.h>
#include <string.h>
#define BUZZ_SIZE 1024
struct sequence {
char *sequence;
char *label;
};
int main(int argc, char *argv[]) {
FILE *fptr;
char buffer[BUZZ_SIZE];
char fasta[BUZZ_SIZE];
char *token;
char *seqs[3];
int idx = 0;
const char fasta_delim[2] = ">";
const char newline[3] = "\n";
/* Read-in plain-text */
fptr = fopen(argv[1],"r");
while (fgets(buffer, BUZZ_SIZE, fptr) != NULL) {
strcat(fasta, buffer);
}
fclose(fptr);
/* Process text, first by splitting by > and then by \n for each sequence, and then write to binary */
FILE *out;
out = fopen("your_sequences.bin","wb");
struct sequence final_entry;
token = strtok(fasta,fasta_delim);
while (token != NULL) {
seqs[idx++] = token;
token = strtok(NULL,fasta_delim);
}
for (idx=0; idx<4; idx++) {
token = strtok(seqs[idx],newline);
char *this_seq[1];
int p = 0;
while (token != NULL) {
this_seq[p] = token;
token = strtok(NULL,newline);
p++;
}
final_entry.label = this_seq[0];
final_entry.sequence = this_seq[1];
printf("%s\n%s\n\n", final_entry.label, final_entry.sequence);
fwrite(&final_entry, sizeof(struct sequence), 1, out);
}
fclose(out);
return(0);
}
This outputs, as expected from the fprint() statement toward the bottom:
sequence1
ATCTATGTCGCTCGCTCGAGAGCTA
sequence2
CGTCGCTGGGATCGATTTCGATAGCT
sequence3
AAATATAACTCGCTAGCTCGATCGATC
sequence4
CTCTCTCCTCTCTCTATATAGGGG
I'm thinking the error has to be somewhere in the above script (ie my binary file is messed up), because the Segmentation Fault is caused by the fread() statement in the script below. I don't think I've made an error in calling fread(), but maybe I'm wrong.
#include <stdio.h>
#define BUZZ_SIZE 1024
struct sequence {
char *sequence;
char *label; };
int main(int argc, char *argv[]) {
struct sequence this_seq;
int n;
FILE *fasta_bin;
fasta_bin = fopen(argv[1],"rb");
for (n=0;n<4;n++) {
fread(&this_seq, sizeof(struct sequence), 1, fasta_bin);
printf (">%s\n%s\n", this_seq.label, this_seq.sequence);
}
fclose(fasta_bin);
return(0);
}
This outputs the segmentation fault
[1] 8801 segmentation fault (core dumped)
I've tinkered around with and gone over this a good amount over the past couple hours. I hope I haven't made some stupid mistake a wasted your time!
Thanks for your help.

Answer 1

I'm thinking the error has to be somewhere in the above script (ie my
binary file is messed up),
Sort of.
because the Segmentation Fault is caused by
the fread() statement in the script below.
I'm fairly confident that the error occurs not in the fread() but in the following printf().
I don't think I've made an
error in calling fread(), but maybe I'm wrong.
Your fread() corresponds to the fwrite(). There is every reason to expect that you will accurately read back what was written. The main problem here is a common one for C neophytes: you've misunderstood the nature of C strings (a null-terminated array of char), and failed to appreciate the crucial, but subtle, distinction between arrays and pointers.
To expand on that a bit, C does not have a first-class string data type. Instead, the standard library provides "string" functions that operate on sequences of objects of type char, where the end of the sequence is marked by a terminator char with the value 0. Such sequences typically are contained in char arrays, and always can be treated as if they were. Because that's what the standard library supports, that convention is ubiquitously used in programs and third-party libraries, too.
C, however, has no mechanism for passing arrays to functions or receiving them as return values. Nor do the assignment operator or most others work on arrays -- not even the indexing operator, []. Instead, in most contexts, values of array type are automatically converted to pointers to the first array element, and these can be passed around and used as operands to a wide variety of operators. Seeing (part of) this, inexperienced C programmers often mistakenly identify strings with such pointers instead of with the pointed-to data.
Of course a pointer value is just an address. You can copy it around and store it at any number of locations in the program, but this does nothing to the pointed-to data. And now I finally come around to the point: you can also write out a pointer value and read it back in, as your programs do, but it is rarely useful to do so, because the pointed-to data don't come along when you do that. Unless you read the pointer back into the same process that wrote it, the read-back pointer value is unlikely to be valid, and it certainly does not have the same significance it did in the program that wrote it.
You must instead write the pointed-to data, but you have to choose a format. In particular, titles and sequences generally have varying lengths, and one of the key things you need to decide is how, if at all, your binary format should reflect that. If I might be so bold, however, I have a suggestion for a well-defined format you could use: Fasta format! Seriously.
There's not much you can do short of data compression to express fasta-format data more compactly, as that format does little more than it needs to do to express the varying-length data it conveys. The question you need to answer, then, is what exactly you're trying to achieve by your reformatting -- both the reason for reformatting at all, and based on that, what your target format actually is.

Answer 2

You are getting segmentation fault because in your program you are using pointer without allocating memory to them:
printf (">%s\n%s\n", this_seq.label, this_seq.sequence);
You first need to allocate memory to this_seq.label and this_seq.sequence pointers, something like this:
this_seq.sequence = malloc(size_of_sequence);
if (this_seq.sequence == NULL)
exit(EXIT_FAILURE);
this_seq.label = malloc(size_of_label);
if (this_seq.label == NULL)
exit(EXIT_FAILURE);
and then read the data into them, like this:
fread(this_seq.sequence, size_of_sequence, 1, fasta_bin);
fread(this_seq.label, size_of_label, 1, fasta_bin);

Answer 3

The problem is that struct sequence doesn't actually carry any salvageable information, it only contains pointers.
Pointers carry memory addresses, they point where the actual information is in memory, but of course if you are reading the file in another process with an entirely different memory space, the information won't be there. In fact, you are likely to crash for trying to interact with memory space that wasn't properly initialized first.
A very simple solution is, don't use pointers, use arrays:
struct sequence
{
char sequence[1024];
char label[1024];
}
Now the structure actually carry the data, no longer just pointers. You will be able to read and write it to file with no worries. However, some code will need to be changed further.
You can no longer assign data to them like x.label = label, you need to use strcpy(), like strcpy(x.label, label). Those changes will need to be made everywhere in the code where you assign values to the properties of this structure.