Creating my own archive tool in C [closed] - c

Question

Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 7 years ago.
Improve this question
i was just assigned a project to create an archiving tool for unix. So after creating the program i would do something like
"./bar -c test_archive.bar file.1"
It would create a test_archive.bar with file.1 inside of it. Then i could do some command where i list the files inside etc. etc.. But i'm having trouble understanding the concept of making a test_archive.bar, i realize in essence its just a file, but if you were to say open a .tgz "vi file.tgz" it would give a list of directories/files inside,
So, are there any good ways to go about creating a archive/directory in which i can extrapolate some files within and list their names etc..
Note: I have looked at tar.c and all the files included in that but every file is so abstracted it's very hard to follow.
Note: i know how to read the command line flags etc.

Answer 1

Using a old (but still valid) tar format is actually pretty easy to do. Wikipedia has a nice explanation of the format here. All you need to do is this:
For each file:
Fill out and emit a header to the tar file
Emit the file contents
Pad the file size to a multiple of 512 bytes
The most basic valid header for a tar file is: (Copied from Wikipedia, basically)
100 bytes: File name
8 bytes: File mode
8 bytes: Owner's numeric ID
8 bytes: Group's numeric ID
12 bytes: File's size
12 bytes: Timestamp of last modified time
8 bytes: Checksum
1 byte: File type
100 bytes: Name of linked file
The file type can be 0 (a normal file), 1 (a hard link) or 2 (a symlink). The name of linked file is the name of the file that a link points at. If I recall correctly, if you have a hard link or symbolic link, the file content should be empty.
To quote Wikipedia:
"Numeric values are encoded in octal numbers using ASCII digits, with leading zeroes. For historical reasons, a final NUL or space character should be used."
"The checksum is calculated by taking the sum of the unsigned byte values of the header record with the eight checksum bytes taken to be ascii spaces (decimal value 32). It is stored as a six digit octal number with leading zeroes followed by a NUL and then a space."
Here's a simple tarball generator. Creating an extractor, dealing with automatic file feeding, etc, is left as an exercise for the reader.
#include<stdio.h>
#include<string.h>
struct tar_header{
char name[100];
char mode[8];
char owner[8];
char group[8];
char size[12];
char modified[12];
char checksum[8];
char type[1];
char link[100];
char padding[255];
};
void fexpand(FILE* f, size_t amount, int value){
while( amount-- ){
fputc( value, f );
}
}
void tar_add(FILE* tar_file, const char* file, const char* internal_name){
//Get current position; round to a multiple of 512 if we aren't there already
size_t index = ftell( tar_file );
size_t offset = index % 512;
if( offset != 0 ){
fexpand( tar_file, 512 - offset, 0);
}
//Store the index for the header to return to later
index = ftell( tar_file );
//Write some space for our header
fexpand( tar_file, sizeof(struct tar_header), 0 );
//Write the input file to the tar file
FILE* input = fopen( file, "rb" );
if( input == NULL ){
fprintf( stderr, "Failed to open %s for reading\n", file);
return;
}
//Copy the file content to the tar file
while( !feof(input) ){
char buffer[2000];
size_t read = fread( buffer, 1, 2000, input );
fwrite( buffer, 1, read, tar_file);
}
//Get the end to calculate the size of the file
size_t end = ftell( tar_file );
//Round the file size to a multiple of 512 bytes
offset = end % 512;
if( end != 0 ){
fexpand( tar_file, 512 - offset, 0);
}
//Fill out a new tar header
struct tar_header header;
memset( &header, 0, sizeof( struct tar_header ) );
snprintf( header.name, 100, "%s", internal_name );
snprintf( header.mode, 8, "%06o ", 0777 ); //You should probably query the input file for this info
snprintf( header.owner, 8, "%06o ", 0 ); //^
snprintf( header.group, 8, "%06o ", 0 ); //^
snprintf( header.size, 12, "%011o", end - 512 - index );
snprintf( header.modified, 12, "%011o ", time(0) ); //Again, get this from the filesystem
memset( header.checksum, ' ', 8);
header.type[0] = '0';
//Calculate the checksum
size_t checksum = 0;
int i;
const unsigned char* bytes = &header;
for( i = 0; i < sizeof( struct tar_header ); ++i ){
checksum += bytes[i];
}
snprintf( header.checksum, 8, "%06o ", checksum );
//Save the new end to return to after writing the header
end = ftell(tar_file);
//Write the header
fseek( tar_file, index, SEEK_SET );
fwrite( bytes, 1, sizeof( struct tar_header ), tar_file );
//Return to the end
fseek( tar_file, end, SEEK_SET );
fclose( input );
}
int main( int argc, char* argv[] ){
if( argc > 1 ){
FILE* tar = fopen( argv[1], "wb" );
if( !tar ){
fprintf( stderr, "Failed to open %s for writing\n", argv[1] );
return 1;
}
int i;
for( i = 2; i < argc; ++i ){
tar_add( tar, argv[i], argv[i] );
}
//Pad out the end of the tar file
fexpand( tar, 1024, 0);
fclose( tar );
return 0;
}
fprintf( stderr, "Please specify some file names!\n" );
return 0;
}

Answer 2

So, are there any good ways to go about creating a archive/directory
in which i can extrapolate some files within and list their names
etc..
There are basically two approaches:
Copy file contents one after another, each prefixed with "header" block, containing information about file name, size and (optionally) other attributes. Tar is an example of this. Example:
Copy file contents one after another and put somewhere (on the beginning of at the end) "index" which contains list of file names with their sizes and (optionally) other attributes. When you look at file sizes, you can compute where individual files begin/end.
Most real world archivers use combination of those, and add other features such as check sums, compression and encryption.
Example
Suppose we have Two files named hello.txt containg Hello, World! (12 bytes) and bar.txt containg foobar (6 bytes).
In first method, archive would look like that
[hello.txt,12][Hello, World!][bar.txt,6][foobar]
^- fixed size ^- 12 bytes ^- fixed size ^- 6 bytes
Length of header blocks would habe to be either constant, or you have to encode somewhere their length.
In second:
[Hello, World!foobar][hello.txt,12,bar.txt,6]
^- 12+6 bytes