C: theory on how to extract files from an archived file - c

Question

In C I have created a program which can archive multiple files into an archive file via the command line.
e.g.
$echo 'file1/2' > file1/2.txt
$./archive file1.txt file2.txt arhivedfile
$cat archivedfile
file1
file2
How do I create a process so that in my archivedfile I have:
header
file1
end
header
file2
end
They are all stored in the archive file one after another after another. I know that perhaps a header file is needed(containing filename, size of filename, start and end of file) for extracting these files back out into their original form, but how would I go about doing this.
I am stuck on where and how to start.
Please could someone help me on some logic as to how to approach extracting files back out of an archived file.

Answer 1

As has been mentioned before, start with the algorithm. You already have most of the details.
There are a few approaches you can take:
Random access archive.
Sequential access archive.
Random Access Archive
For this to work, the header needs to act as an index (like the card indexes at a library), indicating; (a) where to find the start of each file; and (b) the length of each file. The algorithm to write the archive file might look like:
Get a list of all the files from the command line.
Create a structure to hold the meta data about each file: name (255 char), size (64-bit int), date and time, and permissions.
For each file, get its stats.
Store the stats of each file within an array of structures.
Open the archive for writing.
Write the header structure.
For each file, append its content to the archive file.
Close the archive file.
(The header might have to include the number of files, too.)
Next, the algorithm for extracting files:
Get an archive file from the command line.
Get a file name to extract, also from the command line.
Create memory for a structure to read meta data about each file.
Read all the meta data from the archive file.
Search for the file name to extract throughout list of the meta data.
Calculate the offset into the archive file for the start of the matching file name.
Seek to the offset.
Read the file content and write it out to a new file.
Close the new file.
Close the archive.
Sequential Access
This is easier. You can do it yourself: think through the steps.
About Programming
It is easy to get caught up in the details of how something should work. I suggest that you take a step back -- something your teacher should discuss in class -- and try to think about the problem at a level above coding, because:
the algorithm you create will be language independent;
fixing mistakes in an algorithm, before code is written, is trivial;
you will have a better understanding of what you need to do before coding;
it will take less time to implement the solution;
you can identify areas that can be implemented in parallel;
you will see any potential roadblocks ahead of time; and
you will be on your way to management positions in no time. ;-)

Answer 2

I would think that the header would need to have information needed to identify the file and how big it is within the archive - for example, file name, original directory, and size in either lines or bytes, depending on which is more useful in your context. You'd then need routines to create a header, add a file to an archive (create a header and append the file data), extract a file from an archive (follow the headers until the correct entry is found and copy the data from the archive to a separate file), and delete a file (start reading the archive, copying data for all entries except the one you want to delete to a new file, then delete the old archive and rename the new one to the old name).
Share and enjoy.

Answer 3

One approach is to imitate the ZIP format: http://en.wikipedia.org/wiki/ZIP_file_format
It uses a directory structure at the end of the file, which contains pointers to the offsets of the files in the archive. The big benefit of this structure is that you can find a given file without having to read the entire archive -- as long as you know the start of the directory and have the ability to randomly access the file.
An alternative is the TAR file format: http://en.wikipedia.org/wiki/Tar_file_format
This is designed for streaming media ("tape archive"), so each entry contains its own metadata. You have to scan the entire file for an entry, but the normal use case is to pack/unpack entire directory trees, so this isn't too bad a penalty.

Answer 4

Doing it in a streaming fashion, like tar, is probably the easiest implementation. First, write a magic number out so you can identify that this is your archive format. I'd then suggest using stat(2) (that's man syntax for the stat man page, section 2) to get the size of the file to be archived. Actually, look closely at the stat fields available to you, there may be some interesting information there you'd want to keep.
Write out the information you need in a tag=value fashion, one per line. For example:
FileName=file1.txt
FileSize=10
FileDir=./blah/blah
FilePerms=0700
End your header with two newlines so you know when to start pushing out FileSize bytes to disk. You don't need an beginning of header marker, because you know the filesize to write out, so you know when to start parsing your header again.
I'm suggesting you use a text format for your header information because then you don't have to worry about byte ordering, etc. that you'd need to worry about if you write a raw binary struct out to disk.
When reading your archive, parse the header lines one by one and populate a local struct to hold that information. Then write out the file to disk, and set any file properties that need updating based on the header info you extracted.
Hope that helps. Good luck.

Answer 5

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct{
int size;
char name[20];
}Header;
void packfiles(char* archive_file, int numfiles, char** filenames){
FILE* fp = fopen(archive_file, "wb");
if(!fp){
perror("Error opening archive file");
exit(1);
}
for(int i = 0; i < numfiles; i++){
FILE* infile = fopen(filenames[i], "rb");
if(!infile){
perror("Error opening input file");
exit(1);
}
//Get file size
fseek(infile, 0, SEEK_END);
int fsize = ftell(infile);
rewind(infile);
//Create header
Header header;
header.size = fsize;
strncpy(header.name, filenames[i], 20);
//Write header and file content to archive
fwrite(&header, sizeof(Header), 1, fp);
for(int j = 0; j < fsize; j++){
fputc(fgetc(infile), fp);
}
//Add padding if necessary
if(fsize % 4 != 0){
for(int j = 0; j < 4-(fsize % 4); j++){
fputc(0, fp);
}
}
fclose(infile);
}
fclose(fp);
}
void unpackfiles(char* archive_file){
FILE* fp = fopen(archive_file, "rb");
if(!fp){
perror("Error opening archive file");
exit(1);
}
while(1){
//Read header
Header header;
int read = fread(&header, sizeof(Header), 1, fp);
if(read == 0){
//EOF
break;
}
else if(read != 1){
perror("Error reading header");
exit(1);
}
//Create output file
FILE* outfile = fopen(header.name, "wb");
if(!outfile){
perror("Error creating output file");
exit(1);
}
//Write file content to output file
for(int i = 0; i < header.size; i++){
fputc(fgetc(fp), outfile);
}
//Skip padding
fseek(fp, 4-(header.size % 4), SEEK_CUR);
fclose(outfile);
}
fclose(fp);
}
int main(int argc, char** argv){
if(argc < 3){
fprintf(stderr, "Usage: %s <archive_file> <file1> [<file2>...]\n", argv[0]);
exit(1);
}
packfiles(argv[1], argc-2, argv+2);
unpackfiles(argv[1]);
return 0;
}