1. Homepage
  2. Programming
  3. COMP1521 Computer Systems Fundamentals Assignment 2: a file archiver

COMP1521 Computer Systems Fundamentals Assignment 2: a file archiver

Engage in a Conversation
COMP1521Computer Systems Fundamentalsfile archiverAustraliaUNSWC

The Task

A file archive is a single file which can contain the contents, names and other metadata of multiple files. These can make backup and transport of files more convenient, and can often make compression more efficient. We often refer to tools that can create or manipulate these as file archivers. CourseNana.COM

There are a vast number of archive formats: on *nix-like systems, tar is common; whereas on Windows, Zip is common. Wikipedia's list of archive formats is a marvellous rabbit-hole to explore. CourseNana.COM

In this assignment, you will be implementing rain, a file archiver for the drop format. CourseNana.COM

The drop format is made up of one or more droplets; where a droplet records one file system object; This format is described in more detail below. CourseNana.COM

A complete implementation of rain can CourseNana.COM

Getting Started

Create a new directory for this assignment, change to this directory, and fetch the provided code by running CourseNana.COM

mkdir -m 700 rain
cd rain
1521 fetch rain

If you're not working at CSE, you can download the provided files as a zip file or a tar file. CourseNana.COM

This will give you the following files: CourseNana.COM

rain.c
is the only file you need to change: it contains partial definitions of four functions, list_drop, check_drop, extract_drop, and create_drop, to which you need to add code to complete the assignment. You can also add your own functions to this file.
rain_main.c
contains a main, which has code to parse the command line arguments, and which then calls one of list_drop, extract_drop, create_drop, or check_drop, depending on the command line arguments given to rain. Do not change this file.
rain.h
contains shared function declarations and some useful constant definitions. Do not change this file.
rain_hash.c
contains the droplet_hash function; you should call this function to calculate hashes for subset 1. Do not change this file.
rain_6_bit.c
contains the droplet_to_6_bit and droplet_from_6_bit functions. You should call these to implement the 6-bit format for subset 3. Do not change this file.
rain.mk
contains a Makefile fragment for rain.

You can run make to compile the provided code; and you should be able to run the result. CourseNana.COM

make
dcc    -c -o rain.o rain.c
dcc    -c -o rain_main.o rain_main.c
dcc    -c -o rain_hash.o rain_hash.c
dcc    -c -o rain_6_bit.o rain_6_bit.c
dcc   rain.o rain_main.o rain_hash.o rain_6_bit.o   -o rain
./rain -l a.drop
list_drop called to list drop: 'a.drop'

If you are running make without dcc available you can compile like this: CourseNana.COM

make CC=gcc
gcc    -c -o rain.o rain.c
gcc    -c -o rain_main.o rain_main.c
gcc    -c -o rain_hash.o rain_hash.c
gcc    -c -o rain_6_bit.o rain_6_bit.c
gcc   rain.o rain_main.o rain_hash.o rain_6_bit.o   -o rain
./rain -l a.drop
list_drop called to list drop: 'a.drop'

If you don't have make available you can compile like this: CourseNana.COM

dcc rain.c rain_main.c rain_hash.c rain_6_bit.c -o rain
./rain -C b.drop
check_drop called to check drop: 'a.drop'

If you don't have make or dcc available you can compile like this: CourseNana.COM

gcc -Wall rain.c rain_main.c rain_hash.c rain_6_bit.c -o rain
./rain -C b.drop
check_drop called to check drop: 'a.drop'

You may optionally create extra .c or .h files. CourseNana.COM

You should run unzip to get a directory called examples/ full of .drop files to test your program against. CourseNana.COM

unzip examples.zip

Subset 0

To complete subset 0, you need to implement code that can CourseNana.COM

  • print a list of the contents of a drop, and
  • print a detailed list of the contents of a drop.

Subset 0: Print a list of the contents of a drop

Given the -l command-line argument, rain should print the path names of the files/directories in a drop. CourseNana.COM

For example: CourseNana.COM

List each item in the drop called text_file.drop, which is in the examples directory
./rain -l examples/text_file.drop
hello.txt
List each item in the drop called 4_files.drop, which is in the examples directory
./rain -l examples/4_files.drop
256.bin
hello.txt
last_goodbye.txt
these_days.txt
List each item in the drop called hello_world.drop, which is in the examples directory
./rain -l examples/hello_world.drop
hello.c
hello.cpp
hello.d
hello.go
hello.hs
hello.java
hello.js
hello.pl
hello.py
hello.rs
hello.s
hello.sh
hello.sql

Subset 0: Print a detailed list of the contents of a drop

Given the -L command-line argument, rain should, for each file in the specified drop, print: CourseNana.COM

  1. the file/directory permissions,
  2. the droplet format which will be one of 6, 7 or 8 (the default),
  3. the file/directory size in bytes, and
  4. the file/directory path name.
./rain -L examples/text_file.drop
-rw-r--r--  8     56  hello.txt
List the details of each item in the drop called 4_files.drop, which is in the examples directory
./rain -L examples/4_files.drop
-rw-r--r--  8    256  256.bin
-rw-r--r--  8     56  hello.txt
-r--r--r--  8    166  last_goodbye.txt
-r--rw-r--  8    148  these_days.txt
List the details of each item in the drop called hello_world.drop, which is in the examples directory
./rain -L examples/hello_world.drop
-rw-r--r--  8     93  hello.c
-rw-r--r--  8     82  hello.cpp
-rw-r--r--  8     65  hello.d
-rw-r--r--  8     77  hello.go
-rw-r--r--  8     32  hello.hs
-rw-r--r--  8    117  hello.java
-rw-r--r--  8     30  hello.js
-rwxr-xr-x  8     47  hello.pl
-rwxr-xr-x  8    103  hello.py
-rw-r--r--  8     45  hello.rs
-rw-r--r--  8    123  hello.s
-rwxr-xr-x  8     41  hello.sh
-rw-r--r--  8     24  hello.sql

Subset 1

To complete subset 1, you need to implement code that can CourseNana.COM

  • check the contents of a drop, and
  • extract files from a drop.

Subset 1: Check the contents of a drop

Given the -C command-line argument, rain should check the hashes in the specified drop. For example: CourseNana.COM

Check the drop called 4_files.drop, which is in the examples directory
./rain -C examples/4_files.drop
256.bin - correct hash
hello.txt - correct hash
last_goodbye.txt - correct hash
these_days.txt - correct hash
Check the drop called examples/hello_world.bad_hash.drop, which is in the examples directory
./rain -C examples/hello_world.bad_hash.drop
hello.c - correct hash
hello.cpp - correct hash
hello.d - correct hash
hello.go - correct hash
hello.hs - correct hash
hello.java - correct hash
hello.js - correct hash
hello.pl - correct hash
hello.py - correct hash
hello.rs - correct hash
hello.s - correct hash
hello.sh - correct hash
hello.sql - incorrect hash 0x19 should be 0x43

It should also check the droplet magic number (first byte) of each droplet, and emit an error if it is incorrect. CourseNana.COM

Check the drop called text_file.bad_magic.drop, which is in the examples directory
./rain -C examples/text_file.bad_magic.drop
error: incorrect first droplet byte: 0x39 should be 0x63

Subset 1: Extract files from a drop

Given the -x command-line argument, rain should extract the files in the specified drop. CourseNana.COM

It should set file permissions for extracted files to the permissions specified in the drop. CourseNana.COM

rain will extract files into the current working directory.
So as not to clutter your assignment directory, you should create a
temporary directory, 'tmp', and change to it.  Once in that directory,
both your rain program and 'examples/' will be in its parent
directory --- hence the use of '..' in these path names.

Make a directory called tmp.
mkdir -p tmp/
Change into the tmp directory.
cd tmp/
Forcibly remove all files inside the tmp directory.
rm -f * .*
Use your program to extract the contents of text_file.drop.
../rain -x ../examples/text_file.drop
Extracting: hello.txt
Show the contents of hello.txt in the terminal.
You can manually open it in your text editor too, if you like.
cat hello.txt
Hello COMP1521
I hope you are enjoying this assignment.
Forcibly remove all files inside the tmp directory.
rm -f * .*
Use your program to extract the contents of hello_world.drop.
../rain -x ../examples/hello_world.drop
Extracting: hello.c
Extracting: hello.cpp
Extracting: hello.d
Extracting: hello.go
Extracting: hello.hs
Extracting: hello.java
Extracting: hello.js
Extracting: hello.pl
Extracting: hello.py
Extracting: hello.rs
Extracting: hello.s
Extracting: hello.sh
Extracting: hello.sql
Show the first 25 lines from the extracted files to confirm the extraction was successful.
cat $(echo * | sort) | head -n 25
extern int puts(const char *s);

int main(void)
{
    puts("Hello, World!");
    return 0;
}
#include <iostream>

int main () {
  std::cout << "Hello, world!" << std::endl;
}
import std.stdio;

void main() {
    writeln("Hello, world!");
}
package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}
main = putStrLn "Hello, World!"
Forcibly remove all files inside the tmp directory
rm -f * .*
Use your program to extract the contents of meta.drop.
../rain -x ../examples/meta.drop
Extracting: 1_file.subdirectory.7-bit.drop
Extracting: 1_file.subdirectory.drop
Extracting: 2_files.7-bit.drop
Extracting: 2_files.drop
Extracting: 3_files.7-bit.drop
Extracting: 3_files.bad_hash.drop
Extracting: 3_files.bad_magic.drop
Extracting: 3_files.drop
Extracting: 3_files.subdirectory.7-bit.drop
Extracting: 3_files.subdirectory.bad_hash.drop
Extracting: 3_files.subdirectory.bad_magic.drop
Extracting: 3_files.subdirectory.drop
Extracting: 4_files.drop
Extracting: all_the_modes.subdirectory.7-bit.drop
Extracting: all_the_modes.subdirectory.drop
Extracting: all_three_formats.6-bit.drop
Extracting: binary_file.drop
Extracting: hello_world.7-bit.drop
Extracting: hello_world.bad_hash.drop
Extracting: hello_world.bad_magic.drop
Extracting: hello_world.drop
Extracting: lecture_code.subdirectory.7-bit.drop
Extracting: lecture_code.subdirectory.drop
Extracting: small.6-bit.drop
Extracting: small.7-bit.drop
Extracting: small.drop
Extracting: text_file.7-bit.drop
Extracting: text_file.bad_hash.drop
Extracting: text_file.bad_magic.drop
Extracting: text_file.drop
Extracting: tiny.6-bit.drop
Extracting: tiny.7-bit.drop
Extracting: tiny.drop
Show the first 10 items in this directory alphabetically to check extraction was successful.
ls -1 $(echo * | sort) | head
1_file.subdirectory.drop
1_file.subdirectory.compressed.drop
2_files.drop
2_files.compressed.drop
3_files.bad_hash.drop
3_files.bad_magic.drop
3_files.drop
3_files.compressed.drop
3_files.subdirectory.bad_hash.drop
3_files.subdirectory.bad_magic.drop
Go back into the directory with your code.
cd ../
Remove the tmp directory and everything inside it.
rm -rf tmp/

Subset 2

To complete subset 2, you need to implement code that can CourseNana.COM

  • create a drop from a list of files.

Subset 2: Create a drop from a list of files

Given the -c command-line argument, rain should create a drop containing the specified files. CourseNana.COM

These "echo" lines show you how to create these test files and what their contents are.

Create a file called hello.txt with the contents "hello".
echo hello >hello.txt
Create a file called hola.txt with the contents "hola".
echo hola >hola.txt
Create a file called hi.txt with the contents "hi".
echo hi >hi.txt
Set the permissions of these files to 644 (octal permission string (equivalent to rw-r--r--)).
When you list the contents of the drop, the permissions should match this.
chmod 644 hello.txt hola.txt hi.txt
Create a drop called selamat.drop with the files hello.txt, hola.txt, and hi.txt.
./rain -c selamat.drop hello.txt hola.txt hi.txt
Adding: hello.txt
Adding: hola.txt
Adding: hi.txt
List the contents of selamat.drop.
./rain -L selamat.drop
-rw-r--r--  8      6  hello.txt
-rw-r--r--  8      5  hola.txt
-rw-r--r--  8      3  hi.txt
Make a directory called tmp.
mkdir -p tmp/
Change into the tmp directory.
cd tmp/
Forcibly remove all files inside the tmp directory.
rm -f * .*
Use your program to extract the contents of selamat.drop.
../rain -x ../selamat.drop
Extracting: hello.txt
Extracting: hola.txt
Extracting: hi.txt
Check that the extracted file hello.txt is the same as the source file ../hello.txt.
diff -s ../hello.txt hello.txt
Files ../hello.txt and hello.txt are identical
Check that the extracted file hola.txt is the same as the source file ../hola.txt.
diff -s ../hola.txt hola.txt
Files ../hola.txt and hola.txt are identical
Check that the extracted file hi.txt is the same as the source file ../hi.txt.
diff -s ../hi.txt hi.txt
Files ../hi.txt and hi.txt are identical
Go back into the directory with your code.
cd ../
Remove the tmp directory and everything inside it.
rm -rf tmp/

It is also possible to append droplets to an existing drop file using the -a command-line option. For example: CourseNana.COM

./rain -a bonjour.drop hello.txt
Adding: hello.txt
./rain -L bonjour.drop
-rw-r--r--  8      6  hello.txt
./rain -a bonjour.drop hola.txt hi.txt
Adding: hola.txt
Adding: hi.txt
./rain -L bonjour.drop
-rw-r--r--  8      6  hello.txt
-rw-r--r--  8      5  hola.txt
-rw-r--r--  8      3  hi.txt

Subset 3

To complete subset 3, you need to implement code that can CourseNana.COM

  • create a drop from a list of files and directories,
  • extract directories from a drop, and
  • manipulate 6-bit and 7-bit storage formats.

Subset 3: Create a drop from a list of files and directories

Given the -c command-line argument, rain should be able to add files in sub-directories. For example: CourseNana.COM

Create a drop called a.drop with the file "hello.txt" that is contained within 2 levels of directories.
./rain -c a.drop examples/2_files.d/hello.txt 
Adding: examples
Adding: examples/2_files.d
Adding: examples/2_files.d/hello.txt

If a directory is specified when creating a drop, rain should add the entire directory tree to the drop. CourseNana.COM

Create a drop called a.drop with *all* the contents within the directory "3_files.subdirectory.d"
which is in the "examples" directory.
./rain -c a.drop examples/3_files.subdirectory.d
Adding: examples
Adding: examples/3_files.subdirectory.d
Adding: examples/3_files.subdirectory.d/goodbye
Adding: examples/3_files.subdirectory.d/goodbye/last_goodbye.txt
Adding: examples/3_files.subdirectory.d/hello
Adding: examples/3_files.subdirectory.d/hello/hello.txt
Adding: examples/3_files.subdirectory.d/these_days.txt

Given the -L command-line argument and a drop containing directories, rain should be able to list files and directories. For example: CourseNana.COM

./rain -L examples/1_file.subdirectory.drop 
drwxr-xr-x  8      0  hello
-rw-r--r--  8     56  hello/hello.txt

Subset 3: Extract directories from a drop

Given the -x command-line argument, and a drop containing directories, rain should be able to extract files and directories. For example: CourseNana.COM

./rain -x examples/3_files.subdirectory.drop 
Creating directory: goodbye
Extracting: goodbye/last_goodbye.txt
Creating directory: hello
Extracting: hello/hello.txt
Extracting: these_days.txt

CourseNana.COM

Subset 3: Manipulate 6-bit and 7-bit storage formats

The -7 and -6 options allow droplets to be created in 7-bit and 6-bit format. For example: CourseNana.COM

./rain -7 -c seven.drop hello.txt
Adding: hello.txt
./rain -L seven.drop
-rw-r--r--  7      6  hello.txt
./rain -6 -c six.drop hola.txt hi.txt
Adding: hola.txt
Adding: hi.txt
./rain -L six.drop
-rw-r--r--  6      5  hola.txt
-rw-r--r--  6      3  hi.txt

It is possible for drops to contain droplets in multiple formats. For example: CourseNana.COM

./rain -a mixed.drop hello.txt
Adding: hello.txt
./rain -L mixed.drop
-rw-r--r--  8      6  hello.txt
./rain -7 -a mixed.drop hi.txt
Adding: hi.txt
./rain -L mixed.drop
-rw-r--r--  8      6  hello.txt
-rw-r--r--  7      3  hi.txt
./rain -6 -a mixed.drop hola.txt
Adding: hola.txt
./rain -L mixed.drop
-rw-r--r--  8      6  hello.txt
-rw-r--r--  7      3  hi.txt
-rw-r--r--  6      5  hola.txt

Your code should handle creating, listing, checking, and extracting drops in 7-bit and 6-bit format. CourseNana.COM

Your code should produce an error if asked to create a droplet containing bytes which can be encoded in the specified format. For example: CourseNana.COM

 echo Hello >Hello.txt
./rain -6 -c broken.drop Hello.txt
error: byte 0x48 can not be represented in 6-bit format

Handling Errors

Error checking is an important part of this assignment. Automarking will test error handling. CourseNana.COM

Error messages should be one line (only) and be written to stderr (not stdout). CourseNana.COM

rain should  exit with status 1 after an error. CourseNana.COM

rain should check all file operations for errors. CourseNana.COM

As much as possible match the reference implementation error messages exactly. CourseNana.COM

The reference implementation uses perror to report errors from file operations and other system calls. CourseNana.COM

It is not necessary to remove files and directories already created or partially created when an error occurs. CourseNana.COM

You may extract a file or directory from droplet before determining if the droplet hash is correct. CourseNana.COM

You may not extract the file or directory from a droplet before determining if the droplet magic number is correct. CourseNana.COM

You can extract previous file or directory from a droplet. CourseNana.COM

Where multiple errors messages could be produced, for example, if two non-existent files are specified to be added to a drop, rain may produce any one of the error messages. CourseNana.COM

Reference implementation

A reference implementation is a common, efficient, and effective method to provide or define an operational specification; and it's something you will likely work with after you leave UNSW. CourseNana.COM

We've provided a reference implementation, 1521 rain, which you can use to find the correct outputs and behaviours for any input: CourseNana.COM

1521 rain -L examples/tiny.6-bit.drop
-rw-r--r--  6      0  a

Every concrete example shown below is runnable using the reference implementation; run 1521 rain instead of ./rain. CourseNana.COM

Where any aspect of this assignment is undefined in this specification, you should match the behaviour exhibited by the reference implementation. Discovering and matching the reference implementation's behaviour is deliberately a part of this assignment. CourseNana.COM

If you discover what you believe to be a bug in the reference implementation, please report it in the class forum. If it is a bug, we may fix the bug; or otherwise indicate that you do not need to match the reference implementation's behaviour in that specific case. CourseNana.COM

The drop and droplet format

drops must follow exactly the format produced by the reference implementation. CourseNana.COM

A drop consists of a sequence of one or more droplets. Each droplet contains the information about one file or directory. CourseNana.COM

The first byte of a drop file is the first byte of the first droplet. That droplet is immediately followed by either another droplet, or by the end of the drop file. CourseNana.COM

namelengthtypedescription
magic numberBunsigned, 8-bit, little-endianbyte 0 in every droplet must be 0x63 (ASCII 'c')
droplet formatBunsigned, 8-bit, little-endianbyte 1 in every droplet must be one of 0x36, 0x37, 0x38 (ASCII '6', '7', '8')
permissions10 Bcharactersbytes 2—11 are the type and permissions as a ls-like character array; e.g., "-rwxr-xr-x"
pathname lengthBunsigned, 16-bit, little-endianbytes 12—13 are an unsigned 2-byte (16-bit) little-endian integer, giving the length of
pathnamepathname-lengthcharactersthe filename of the object in this droplet.
content lengthBunsigned, 48-bit, little-endianthe next bytes are an unsigned 6-byte (48-bit) little-endian integer giving the length of the file that was encoded to give
contentcontent-length for 8-bit format, see below for other formatsbytesthe data of the object in this droplet.
hashBunsigned, 8-bit, little-endianthe last byte of a droplet is a droplet-hash of all bytes of this droplet except this byte.

droplet content encodings (Subset 3 only)

  • 8-bit format (droplet format == 0x38 contents is an array of bytes, which are exactly equivalent to the bytes in the original file. CourseNana.COM

  • 7-bit format (droplet format == 0x37) contents is an array of bytes representing packed seven-bit values, with the trailing bits set to zero. Every byte of the original file is taken as a seven-bit value, and packed as described below. This format can store any seven bit value — so, for example, any byte containing valid ASCII can be stored. CourseNana.COM

    This format needs (7.0/8)content-length bytes. 7-bit format is used only in subset 3. CourseNana.COM

  • 6-bit format (droplet format == 0x36) contents is an array of bytes of packed six-bit values where the trailing bits in the last byte are zero, and which are translated using the functions droplet_to_6_bit and droplet_from_6_bit in rain_6_bit.c. CourseNana.COM

    This format cannot store all ASCII values, for example upper case letters can't be stored in 6-bit format. CourseNana.COM

    This format needs (6.0/8)content-length bytes. CourseNana.COM

6-bit format is used only in subset 3.

Packed n-bit encoding (Subset 3 only)

We often store smaller values inside larger types. For example, the integer 42 only needs six bits; but we often will store it in a full thirty-two-bit integer, wasting many bits of zeroes. Assuming we know how many bits the value needs, we could only store the relevant bits. CourseNana.COM

For example, let's say we have three seven-bit values a, b, c, made up of arbitrary bit-strings, and stored in eight-bit variables CourseNana.COM

  • a: 0b0AAA_AAAA,
  • b: 0b0BBB_BBBB,
  • c: 0b0CCC_CCCC,
then a packed seven-bit encoding of these values in order would be:
    0bAAAA_AAAB_BBBB_BBCC_CCCC_C???

However, we have a problem: what happens to the trailing bits, which don't have a value? Note that we've defined all trailing bits to be zero above, which would here give: CourseNana.COM

    0bAAAA_AAAB_BBBB_BBCC_CCCC_C000

Inspecting drops and droplets

The hexdump utility can show the individual bytes of a file. We can use this to inspect drops and droplets. CourseNana.COM

For example, here is a drop, made up of two droplets. CourseNana.COM

hexdump -vC  examples/2_files.drop
00000000  63 38 2d 72 77 2d 72 2d  2d 72 2d 2d 09 00 68 65  |c8-rw-r--r--..he|
00000010  6c 6c 6f 2e 74 78 74 38  00 00 00 00 00 48 65 6c  |llo.txt8.....Hel|
00000020  6c 6f 20 43 4f 4d 50 31  35 32 31 0a 49 20 68 6f  |lo COMP1521.I ho|
00000030  70 65 20 79 6f 75 20 61  72 65 20 65 6e 6a 6f 79  |pe you are enjoy|
00000040  69 6e 67 20 74 68 69 73  20 61 73 73 69 67 6e 6d  |ing this assignm|
00000050  65 6e 74 2e 0a 2d 63 38  2d 72 77 2d 72 2d 2d 72  |ent..-c8-rw-r--r|
00000060  2d 2d 10 00 6c 61 73 74  5f 67 6f 6f 64 62 79 65  |--..last_goodbye|
00000070  2e 74 78 74 a6 00 00 00  00 00 54 68 69 73 20 69  |.txt......This i|
00000080  73 20 6f 75 72 20 6c 61  73 74 20 67 6f 6f 64 62  |s our last goodb|
00000090  79 65 0a 49 20 68 61 74  65 20 74 6f 20 66 65 65  |ye.I hate to fee|
000000a0  6c 20 74 68 65 20 6c 6f  76 65 20 62 65 74 77 65  |l the love betwe|
000000b0  65 6e 20 75 73 20 64 69  65 0a 42 75 74 20 69 74  |en us die.But it|
000000c0  27 73 20 6f 76 65 72 0a  4a 75 73 74 20 68 65 61  |'s over.Just hea|
000000d0  72 20 74 68 69 73 20 61  6e 64 20 74 68 65 6e 20  |r this and then |
000000e0  49 27 6c 6c 20 67 6f 0a  59 6f 75 20 67 61 76 65  |I'll go.You gave|
000000f0  20 6d 65 20 6d 6f 72 65  20 74 6f 20 6c 69 76 65  | me more to live|
00000100  20 66 6f 72 0a 4d 6f 72  65 20 74 68 61 6e 20 79  | for.More than y|
00000110  6f 75 27 6c 6c 20 65 76  65 72 20 6b 6e 6f 77 0a  |ou'll ever know.|
00000120  60                                                |`|
00000121

Each line of hexdump output is in three groups: CourseNana.COM

  • the address column: this starts at 0x00000000, and increases by 0x10 (or 16 in base 10) each line; CourseNana.COM

  • the data columns: after the address, we get (up to) 16 two-digit hexadecimal values, grouped into two blocks of eight values each, which represents the actual data of the file, and CourseNana.COM

  • the human readable stripe: at the very end of each line, between the vertical bars (|) is the human readable version of the bytes preceding, or a '.' if the byte wouldn't ordinarily be visible. CourseNana.COM

You could also use the hd, od, or xxd utilities instead of hexdump . Also provided for the assignment is 1521 dump_drop which prints the contents of a drop in a mroe structured way, e.g.: CourseNana.COM

1521 dump_drop examples/2_files.drop
------------------------------------------------------------------------------
Field Name      Field Offset  Field Hex                      Field ASCII     Field Numeric

magic           0x00000000    63                             c
format          0x00000001    38                             8
mode            0x00000002    2d 72 77 2d 72 2d 2d 72 2d 2d  -rw-r--r--
path length     0x0000000c    09 00                                          9
pathname        0x0000000e                                   hello.txt
content length  0x00000017    38 00 00 00 00 00                              56
contents        0x0000001d
"""
Hello COMP1521.I hope you are enjoying this assignment..
"""
hash            0x00000055    2d

------------------------------------------------------------------------------
Field Name      Field Offset  Field Hex                      Field ASCII     Field Numeric

magic           0x00000056    63                             c
format          0x00000057    38                             8
mode            0x00000058    2d 72 77 2d 72 2d 2d 72 2d 2d  -rw-r--r--
path length     0x00000062    10 00                                          16
pathname        0x00000064                                   last_goodbye.txt
content length  0x00000074    a6 00 00 00 00 00                              166
contents        0x0000007a
"""
This is our last goodbye.I hate to feel the love between us die.But it's over.Just hear this and then I'll go.You gave me more to live for.More than you'll ever know.
"""
hash            0x00000120    60

6-bit format (Subset 3 only)

droplet 6-bit format defines a subset of 64 8-bit values (bytes) to have a six-bit encoding; those six bits are then stored packed. CourseNana.COM

The remaining 192 8-bit values can not be encoded in 6-bit format. CourseNana.COM

The functions droplet_to_6_bit and droplet_from_6_bit in rain_6_bit.c to convert 8-bit values to and from 6-bit format. CourseNana.COM

You can find the mapping by reading the code in rain_6_bit.c. CourseNana.COM

The droplet hash (Subsets 1, 2, 3)

Each droplet ends with a hash (sometimes referred to as a digest) which calculated from the other values of the droplet. This allows us to detect if any bytes of the drop have changed, for example by disk or network errors. CourseNana.COM

The droplet_hash() function makes one step of computation of the hash of a sequence of bytes: CourseNana.COM

uint8_t droplet_hash(uint8_t current_hash_value, uint8_t byte_value) {
    return ((current_hash_value * 33) & 0xff) ^ byte_value;
}

Given the hash value of the sequence up to this byte, and the value of this byte it calculates the new hash value. CourseNana.COM

If we create a drop of a single one-byte file, like this: CourseNana.COM

echo >a
1521 rain -c a.drop a

We can then inspect the drop, and see its hash is 0x15. CourseNana.COM

hexdump -Cv a.drop
00000000  63 38 2d 72 77 2d 72 2d  2d 72 2d 2d 01 00 61 01  |c8-rw-r--r--..a.|
00000010  00 00 00 00 00 0a 15                              |.......|
00000017

Here's the sequence of calls that calculated that value: CourseNana.COM

droplet_hash(0x00, 0x63) = 0x63
droplet_hash(0x63, 0x38) = 0xfb
droplet_hash(0xfb, 0x2d) = 0x76
droplet_hash(0x76, 0x72) = 0x44
droplet_hash(0x44, 0x77) = 0xb3
droplet_hash(0xb3, 0x2d) = 0x3e
droplet_hash(0x3e, 0x72) = 0x8c
droplet_hash(0x8c, 0x2d) = 0x21
droplet_hash(0x21, 0x2d) = 0x6c
droplet_hash(0x6c, 0x72) = 0x9e
droplet_hash(0x9e, 0x2d) = 0x73
droplet_hash(0x73, 0x2d) = 0xfe
droplet_hash(0xfe, 0x01) = 0xbf
droplet_hash(0xbf, 0x00) = 0x9f
droplet_hash(0x9f, 0x61) = 0x1e
droplet_hash(0x1e, 0x01) = 0xdf
droplet_hash(0xdf, 0x00) = 0xbf
droplet_hash(0xbf, 0x00) = 0x9f
droplet_hash(0x9f, 0x00) = 0x7f
droplet_hash(0x7f, 0x00) = 0x5f
droplet_hash(0x5f, 0x00) = 0x3f
droplet_hash(0x3f, 0x0a) = 0x15

Assumptions and Clarifications

Like all good programmers, you should make as few assumptions as possible. If in doubt, match the output of the reference implementation. CourseNana.COM

  • Your submitted code must be a single C program only. You may not submit code in other languages. CourseNana.COM

  • You can call functions from the C standard library available by default on CSE Linux systems: including, e.g., stdio.h, stdlib.h, string.h, math.h, assert.h. CourseNana.COM

  • We will compile your code with dcc when marking. Run-time errors from illegal or invalid C will cause your code to fail automarking (and will likely result in you losing marks). CourseNana.COM

  • Your program must not require extra compile options. It must compile successfully with: CourseNana.COM

    dcc *.c -o rain
    
  • You may not use functions from other libraries. In other words, you cannot use the dcc -l flag. CourseNana.COM

  • If your program prints debugging output, it will fail automarking tests. Make sure you disable any debugging output before submission. CourseNana.COM

  • You may not create or use temporary files. CourseNana.COM

  • You may not create subprocesses: you may not use posix_spawn, posix_spawnp, system, popen, fork, vfork, clone, or any of the exec* family of functions, like execve. CourseNana.COM

  • rain only has to handle ordinary files and directories. CourseNana.COM

    rain does not have to handle symbolic links, devices or other special files. CourseNana.COM

    rain will not be given directories containing symbolic links, devices or other special files. CourseNana.COM

    rain does not have to handle hard links. CourseNana.COM

  • If completing a rain command would produce multiple errors, you may produce any of the errors and stop. CourseNana.COM

    You do not have to produce the particular error that the reference implementation does. CourseNana.COM

  • If a droplet path name contains a directory then a droplet for the directory will appear in the drop beforehand. CourseNana.COM

    For example, if there is a droplet for the path name a/b/file.txt then there will be preceding droplets for the directories a and a/b, CourseNana.COM

    You may also assume the droplet for the directory specifies the directory is writable. CourseNana.COM

  • When adding an entire directory (subset 3) to a drop you may add the directory contents in any order to the drop, after the directory droplet. CourseNana.COM

    You do not have to match the order the reference implementation uses. CourseNana.COM

  • When a rain command specifies adding files with a common sub-directory. You may add a droplet for the sub-directory multiple times. For example, given this command: CourseNana.COM

    ./rain -c a.drop b/file1 b/file2
    
    You may add two (duplicate) droplets for b.
  • You can assume the path name of a drop being created with -c, will not also be added to the drop, and will not be in a directory being added to the drop. CourseNana.COM

  • It is not necessary to check the hashes or magic numbers of droplets in subset 0. Subset 0 tests will only use valid droplets. CourseNana.COM

  • The reference implementation checks the magic number (first byte), format and hash when listing (-l and -L) and extracting (-x) drops. and stops with an error emssage if they are are invalid, for example: CourseNana.COM

    CourseNana.COM

    ./rain -l examples/text_file.bad_hash.drop
    error: incorrect droplet hash 0x2d should be 0x77
    ./rain -L examples/text_file.bad_magic.drop
    error: incorrect first droplet byte: 0x39 should be 0x63
    

    This is very desirable behaviour and you can implement this in your code. However it will not be tested with -l, -L and -x command line options to avoid problems in automarking. CourseNana.COM

    Your code will only be tested with the -C option on drops with invalid hashes, magic numbers and formats CourseNana.COM

  • It is not necessary to check the hashes or magic numbers in an existing drop when appending to it (-a). CourseNana.COM

If you need clarification on what you can and cannot use or do for this assignment, ask in the class forum. CourseNana.COM

You are required to submit intermediate versions of your assignment. See below for details. CourseNana.COM

Assessment

Testing

When you think your program is working, you can use autotest to run some simple automated tests: CourseNana.COM

CourseNana.COM

1521 autotest rain rain.c [optionally: any extra .c or .h files]

1521 autotest will not test everything.
Always do your own testing. CourseNana.COM

Automarking will be run by the lecturer after the submission deadline, using a superset of tests to those autotest runs for you. CourseNana.COM

Get in Touch with Our Experts

QQ QQ
Wechat WeChat
Whatsapp Whatsapp
COMP1521代写,Computer Systems Fundamentals代写,file archiver代写,Australia代写,UNSW代写,C代写,COMP1521代编,Computer Systems Fundamentals代编,file archiver代编,Australia代编,UNSW代编,C代编,COMP1521代考,Computer Systems Fundamentals代考,file archiver代考,Australia代考,UNSW代考,C代考,COMP1521help,Computer Systems Fundamentalshelp,file archiverhelp,Australiahelp,UNSWhelp,Chelp,COMP1521作业代写,Computer Systems Fundamentals作业代写,file archiver作业代写,Australia作业代写,UNSW作业代写,C作业代写,COMP1521编程代写,Computer Systems Fundamentals编程代写,file archiver编程代写,Australia编程代写,UNSW编程代写,C编程代写,COMP1521programming help,Computer Systems Fundamentalsprogramming help,file archiverprogramming help,Australiaprogramming help,UNSWprogramming help,Cprogramming help,COMP1521assignment help,Computer Systems Fundamentalsassignment help,file archiverassignment help,Australiaassignment help,UNSWassignment help,Cassignment help,COMP1521solution,Computer Systems Fundamentalssolution,file archiversolution,Australiasolution,UNSWsolution,Csolution,