Copying content from one file to another, segmentation fault - c

Question

I'm trying to copy 50 jpegs, one by one from a large .raw file, however currently I get a segmentation fault error. Here's my code:
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
typedef uint8_t BYTE;
//SOI - 0xFF 0xD8
//EOI - 0xFF 0xD9
//APPn - 0xFF 0xEn
int main(void)
{
//FAT - 512 bytes per block
BYTE block[512];
//open file containing pictures
FILE* card_file = fopen("card.raw", "rd");
FILE* jpeg_file;
//make sure the file opened without errors
if (card_file == NULL)
{
printf("something went wrong and file could not be opened");
return 1;
}
int i = 0;
while (fread(&block, sizeof(BYTE), 512, card_file) != 0)
{
//jpeg start signature
if(block[0] == 0xFF && block[1] == 0xD8)
{
i++;
if(jpeg_file != NULL)
fclose(jpeg_file);
//create a new jpeg file to copy bytes to
jpeg_file = fopen((char*)i, "w+");
}
//write 512 bytes to a jpeg file
if(jpeg_file != NULL)
fwrite(block, sizeof(block), 1, jpeg_file);
}
fclose(card_file);
return 0;
}
when I run it through GDB, my code gets all the way to if(block[0] == 0xFF && block1 == 0xD8), then it skips the condition and segmentation fault occurs. I don't see what might be causing this.
Here's a screenshot:
Code updated:
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <cs50.h>
typedef uint8_t BYTE;
/*struct jpg*/
/*{*/
/* BYTE soi[2] = { 0xFF, 0xD8 };*/
/* BYTE eoi[2] = { 0xFF, 0xD9 };*/
/*};*/
//SOI - 0xFF 0xD8
//EOI - 0xFF 0xD9
//APPn - 0xFF 0xEn
int main(void)
{
//FAT - 512 bytes per block
BYTE block[512];
//jpeg name
char name[6];
bool is_open = false;
//JPEG
//struct jpg image;
//open file containing pictures
FILE* card_file = fopen("card.raw", "r");
FILE* jpeg_file;
//make sure the file opened without errors
if (card_file == NULL)
{
printf("something went wrong and file could not be opened");
return 1;
}
int i = 0;
while (fread(block, sizeof(BYTE), 512, card_file) != 0)
{
//jpeg start signature
if ((block[0] == 0xFF) && (block[1] == 0xD8) && (block[2] == 0xFF) && ((block[3] == 0xe1) || (block[3] == 0xe0)))
{
//assign jpeg name
sprintf(name, "%d.jpg", i++);
if(is_open)
fclose(jpeg_file);
//create a new jpeg file to copy bytes to
jpeg_file = fopen(name, "a+");
is_open = true;
}
//write 512 bytes to a jpeg file
if(is_open)
fwrite(block, sizeof(block), 1, jpeg_file);
}
fclose(jpeg_file);
fclose(card_file);
return 0;
}
Now it doesn't crash, however only 9 out of 50 jpegs are properly recovered. cs50.h is there just so I have access to bool type. What's a better way to write 50 files? I seem to have a logical flaw with my booleans.

Answer 1

fopen((char*)i, "w+"); is completely invalid. You are casting an integer as a pointer, which is going to crash.
You need to format the number as a filename:
char path[PATH_MAX];
sprintf(path, "%d", i);
fopen(path, "w+");
You are also not initializing jpeg_file -- if the condition fails, jpeg_file will be a wild pointer, which also crashes. You should initialize jpeg_file to NULL.

Answer 2

In your fread call, you should pass the address of the array. Hence, the statement should be fread(block, sizeof(BYTE), 512, card_file).
Postscript:
In your code, there is assumption that the size of the input file is an integral multiple of 512, which needn't the case for JPEG files. The last fread might return a number less than 512 which needs to be handled in your implementation logic. Hence, the number of elements to write should be determined by the return value of fread
You would need to close the jpeg_file pointer after the loop terminates.
Last, because you are working with JPEG, you may want to handle a case for EXIF files with thumbnails. In this case, you would get 2 SOI (start of image) markers.