Overview
Your quilt within the Lizard Legion was once blown, and youve been revealed as a double agent and driven out! It was once
all very James Bond, whereas you raze whisper so yourself, and what a brave underground helicopter get away it was once however
you’re feeling lucky to contain escaped with your pores and skin. (Literally… they’d contain aged you to make a human suit!)
Now that youre help on the outside, youve been tasked with establishing a plan to enable final resistance
fighters silent all thru the Lizard Legion to clandestinely glide records help to your organization with out elevating
suspicion. As of unhurried, members of the Lizard Legion contain found the PC traditional DOOM, and it has change into
your whole rage to form contemporary mods for it at headquarters, so your group has decided to bid mods for this title as a
automobile for exfiltration. By burying encrypted bits within textures and assorted sport records blocks, records could perchance also be
hidden within innocuous WAD (Wheres The total Info) files.
On this project, you are going to put in pressure a userspace filesystem daemon utilizing the FUSE (Filesystem in UserSpacE)
API to access records in WAD structure, the atypical aged in a vary of traditional PC sport titles (collectively with DOOM
and Hexen). On this well-known early prototype, you have to contain been tasked with imposing learn and write access to
files and directories all thru the WAD files as a proof-of-thought. As such, you are going to want to put in pressure learn and
write functionality for both files and directories within your FUSE-based mostly program. We, as your comrades-inarms
battling the Reptilian invasion, will provide sample WAD files to uncover the functionality of your
implementation. (The resistance is counting on you!) The resistance makes bid of university classes as quilt for
typical operations, so youll put up the project by capability of Canvas.
Structure
The project is broken into three major parts:
1) Produce a library to learn from and write to WAD files and manufacture a directory and file building from them.
2) Put into effect a userspace daemon (by capability of FUSE) to access the directory building once mounted.
3) Take a look at your implementation by navigating the mounted directory, examining the names and file contents, and
collectively with directories and files of your luxuriate in.
Whereas proper implementation could perchance also fluctuate, the daemons parameters must match these laid out on this doc, and
the directory building, naming, and file contents must silent be properly offered by capability of the filesystem.
File Format
The WAD file structure comprises records in three sections: the header, which presents total layout records,
the descriptors, which listing parts within the file, and the lumps, which contain the records themselves. NOTE:
all numbers are in miniature-Endian structure and, where relevant, are designated in bytes! Since Reptilian stores
its variables in memory in miniature-Endian structure as properly, it’s no longer wanted to develop any byte-recount inversions
when discovering out in or writing records, however this is silent well-known records to take hold of.
File Header
The header comprises the file magic, descriptor count, and region (offset) of the descriptors within the file:
The magic for a wad file is once in a while ASCII and continually ends within the suffix “WAD” (e.g., “IWAD” or “PWAD”).
It is also well-known to reward that the descriptor listing, origin at the feature indicated by the descriptor
offset, is continually located at the head of the WAD file.
Descriptors
The files descriptors contain records about parts within the WAD file its file offset, length, and
identify:
Some parts could contain explicit naming conventions that will differentiate them from long-established bid material
files. These marker parts will doubtless be interpreted by the daemon as directories and could perchance also be displayed
accordingly within the filesystem (see below).
Lumps
Substances within the WAD structure are saved as lumps described by the descriptors. These lumps will doubtless be
represented within the filesystem by the daemon as particular person files that will perchance also be opened, learn, and closed.
You could no longer write to reward lumps, however you are going to be establishing empty files whose lumps you contain
to write to.
Marker Substances
There are two main forms of marker parts in WAD files, every of which must silent be interpreted as
directories by our daemon. The variety entails plot markers and namespace markers.
Draw marker names are of the structure “E#M#”, where # represents a single decimal digit (e.g., “E1M9”).
They’re followed by ten (10) plot element descriptors. The parts for the subsequent 10 descriptors must silent be
placed inside of of a directory with the maps identify. Draw marker directories can no longer contain files or directories
added to them.
Namespace markers come in pairs. A namespaces origin is marked with a descriptor whose identify has
the suffix “_START” (e.g., “F1_START”), and its ending is marked with a descriptor whose identify has the
suffix “_END” (e.g., “F1_END”). Any descriptors for parts falling between the origin and ending
markers for a namespace must silent be placed within a directory with the namespaces identify (e.g., “F1”).
The namespace marker’s identify, with the exception of the suffixes, obtained’t ever exceed two characters. These will doubtless be
the roughly directories you are going to be to blame for establishing.
Shall we embrace, the following descriptors, in recount, within the descriptor listing, must silent consequence on this organization:
Library
Your library will contain a category to verbalize WAD records as described on this half.
Wad Class
The Wad class is aged to verbalize WAD records and could perchance also contain the following capabilities. The root of all paths
within the WAD records must silent be “/”, and each directory must silent be separated by ‘/’ (e.g., “/F/F1/LOLWUT”).
public static Wad* loadWad(const string &course)
Object allocator; dynamically creates a Wad object and loads the WAD file records from course into memory.
Caller must deallocate the memory utilizing the delete key phrase.
public string getMagic()
Returns the magic for this WAD records.
public bool isContent(const string &course)
Returns proper if course represents bid material (records), and spurious in any other case.
public bool isDirectory(const string &course)
Returns proper if course represents a directory, and spurious in any other case.
public int getSize(const string &course)
If course represents bid material, returns the likelihood of bytes in its records; in any other case, returns -1.
public int getContents(const string &course, char *buffer, int length, int offset = 0)
If course represents bid material, copies as many bytes as are available, up to length, of bid material’s records into the preexisting
buffer. If offset is equipped, records must silent be copied starting from that byte within the bid material. Returns
possibility of bytes copied into buffer, or -1 if course doesn’t describe bid material (e.g., if it represents a directory).
public int getDirectory(const string &course, vector
If course represents a directory, areas entries for in an instant contained parts in directory. The parts
must silent be placed within the directory within the same recount as they’re found within the WAD file. Returns the likelihood of
parts within the directory, or -1 if course doesn’t describe a directory (e.g., if it represents bid material).
Offset Length Title
0 0 F_START
0 0 F1_START
67500 0 E1M1
67500 1380 THINGS
68880 6650 LINEDEFS
75532 19440 SIDEDEFS
94972 1868 VERTEXES
96840 8784 SEGS
105624 948 SSECTORS
106572 6608 NODES
113180 2210 SECTORS
115392 904 REJECT
116296 6922 BLOCKMAP
42 9001 LOLWUT
0 0 F1_END
0 0 F_END
F
F1
E1M1
THINGS
LINEDEFS
SIDEDEFS
VERTEXES
SEGS
SSECTORS
NODES
SECTORS
REJECT
BLOCKMAP
LOLWUT
Directory Structure
public void createDirectory(const string &course)
course entails the identify of the contemporary directory to be created. If given a official course, creates a brand contemporary directory
utilizing namespace markers at course. The 2 contemporary namespace markers will doubtless be added factual before the _END
marker of its guardian directory. Unique directories can no longer be created inside of plot markers.
public void createFile(const string &course)
course entails the identify of the contemporary file to be created. If given a official course, creates an empty file at course,
with an offset and length of 0. The file will doubtless be added to the descriptor listing factual before the _END marker
of its guardian directory. Unique files can no longer be created inside of plot markers.
public int writeToFile(const string &course, const char *buffer, int length, int offset = 0)
If given a official course to an empty file, augments file size and generates a lump offset, then writes length amount
of bytes from the buffer into the files lump records. If offset is equipped, records must silent be written starting from that
byte within the lump bid material. Returns possibility of bytes copied from buffer, or -1 if course doesn’t describe bid material
(e.g., if it represents a directory).
Daemon Characterize & Parameters
Your daemon must silent contain identify wadfs and could perchance also win at a minimal three parameters the single-threaded
flag “-s”, the target WAD file, and the mount directory. Shall we embrace, this bid must silent mount TINY.WAD
in /home/reptilian/mountdir
$ ./wadfs -s TINY.WAD /home/reptilian/mountdir
$
and this must silent consequence from executing the ls bid to uncover segment of its contents:
$ ls /home/reptilian/mountdir/F/F1 -al
total 0
drwxrwxrwx. 2 root root 0 Jan 1 1970 .
drwxrwxrwx. 2 root root
drwxrwxrwx. 2 root root
0 Jan 1 1970 ..
0 Jan 1 1970 E1M1
-rwxrwxrwx. 2 root root 9001 Jan 1 1970 LOLWUT
Your daemon must silent rush within the background. Develop no longer laborious-code the debug (-d) or foreground (-f) flags!
We can bid the following bid below to unmount your filesystem:
$ fusermount -u /home/reptilian/mountdir
Additional Credit
That you just can also glimpse when checking out with your daemon that there is an better limit to how large files you manufacture in
your filesystem could perchance also be. Your assignment is to configure your library and daemon such that you just are in a feature to manufacture
large files on your filesystem (utilizing “cp” to replica in a 200KB image file, shall we embrace). Operating your
daemon in debug mode (-d) could perchance also provide you with hints as to how sure calls are expected to behave.
NOTE: If a file or directory is created within the foundation directory, this could perchance also be placed at the very discontinue of the
descriptor listing, in location of before an “_END” namespace marker.
Building with FUSE
FUSE is a userspace filesystem API that is supported in an instant by the Linux kernel. It enables userspace programs
to create records to the kernel about filesystems the kernel can no longer verbalize by itself.
Set up & Setup
To bid the FUSE library, you are going to want to set up it within Reptilian and alternate the FUSE permissions:
$ sudo factual set up libfuse-dev fuse
$ sudo chmod 666 /dev/fuse
NOTE: whereas you reboot the digital machine, you are going to want to re-add the FUSE permissions, as they’ll almost definitely be reset!
Respect Directives
In recount to form programs utilizing the FUSE library system, you are going to want to specify the file offset bits as 64 and
identify the FUSE model. We counsel specifying FUSE model 26 (even supposing this is optional):
$ g++ -D_FILE_OFFSET_BITS=64 -DFUSE_USE_VERSION=26 myproggy.cpp -o myproggy -lfuse
Submissions
You could put up the following at the head of this project:
Chronicle (p3.txt) in man internet page structure on Canvas, collectively with hyperlink to unlisted screencast video
Compressed tar archive (wad.tar.gz) for libWad library and wadfs daemon on Canvas
Chronicle
Your file will verbalize the plan you implemented the daemon, collectively with your total structure / program
building. It must consist of a proof of the plan you describe the WAD file parts as a directory building
in memory, as properly as how this building was once utilized within the daemon when working. It would come with a
description of how checking out was once carried out along with any known bugs. The file must silent be no bigger than 600
phrases, quilt all relevant elements of the project, and be organized and formatted professionally this is no longer a
memo!
File and Directory Necessities
Your daemon must put in pressure, at a minimal, the following filesystem capabilities to create learn and write
access:
1) Retrieving file and directory attributes
2) Reading from reward files, and writing to contemporary ones
3) Reading from reward directories, and writing to contemporary ones
Info and directories must silent be given corpulent learn, write, and raze permissions.
The above necessities will doubtless be carried out utilizing, at a minimal, the following six fuse callback capabilities:
get_attr, mknod, mkdir, learn, write, and readdir
It is very urged to closely apply the linked sources at the bottom of this pdf to help with your
FUSE implementation. All changes to the filesystem, reminiscent of directory and file introduction, must continue to exist between
mounting and unmounting.
To form the library and daemon, we can raze these instructions:
$ tar zxvf wad.tar.gz
$ cd libWad
$ make
$ cd ..
$ cd wadfs
$ make
$ cd ..
To rush your daemon, we can raze this bid:
$ ./wadfs/wadfs -s somewadfile.wad /some/mount/directory
To form another program utilizing your library, we can raze this bid:
$ c++ -o program_name sourcefile.cpp -L ./libWad -lWad
Priceless Hyperlinks
That you just can also get the following sources helpful when discovering out about how to put in pressure a FUSE daemon:
https://www.cs.nmsu.edu/~pfeiffer/fuse-tutorial/html/
https://engineering.facile.it/weblog/eng/write-filesystem-fuse/
https://maastaar.win/fuse/linux/filesystem/c/2019/09/28/writing-less-easy-yet-dull-filesystem-utilizing-FUSE-in-C/
https://www.cs.hmc.edu/~geoff/classes/hmc.cs137.201601/homework/fuse/fuse_doc.html
http://slade.mancubus.win/index.php?internet page=about
Screencast
As properly as to the written text file, you’ll need to silent put up a screencast (with audio) strolling thru your library
and the daemon you wrote to create the filesystem interface, describing your main capabilities and
structures (~5:30).
Compressed Archive (wad.tar.gz)
Your compressed tar file must silent contain the following directory/file building:
wad.tar.gz
wad.tar
libWad (directory)
Makefile
Wad.h
(Moderately a range of source files)
wadfs (directory)
Makefile
(Moderately a range of source files)
- WE OFFER THE BEST CUSTOM PAPER WRITING SERVICES. WE HAVE DONE THIS QUESTION BEFORE, WE CAN ALSO DO IT FOR YOU.
- Assignment status: Already Solved By Our Experts
- (USA, AUS, UK & CA PhD. Writers)
- CLICK HERE TO GET A PROFESSIONAL WRITER TO WORK ON THIS PAPER AND OTHER SIMILAR PAPERS, GET A NON PLAGIARIZED PAPER FROM OUR EXPERTS
QUALITY: 100% ORIGINAL PAPER – NO ChatGPT.NO PLAGIARISM – CUSTOM PAPER
Looking for unparalleled custom paper writing services? Our team of experienced professionals at AcademicWritersBay.com is here to provide you with top-notch assistance that caters to your unique needs.
We understand the importance of producing original, high-quality papers that reflect your personal voice and meet the rigorous standards of academia. That’s why we assure you that our work is completely plagiarism-free—we craft bespoke solutions tailored exclusively for you.
Why Choose AcademicWritersBay.com?
- Our papers are 100% original, custom-written from scratch.
- We’re here to support you around the clock, any day of the year.
- You’ll find our prices competitive and reasonable.
- We handle papers across all subjects, regardless of urgency or difficulty.
- Need a paper urgently? We can deliver within 6 hours!
- Relax with our on-time delivery commitment.
- We offer money-back and privacy guarantees to ensure your satisfaction and confidentiality.
- Benefit from unlimited amendments upon request to get the paper you envisioned.
- We pledge our dedication to meeting your expectations and achieving the grade you deserve.
Our Process: Getting started with us is as simple as can be. Here’s how to do it:
- Click on the “Place Your Order” tab at the top or the “Order Now” button at the bottom. You’ll be directed to our order form.
- Provide the specifics of your paper in the “PAPER DETAILS” section.
- Select your academic level, the deadline, and the required number of pages.
- Click on “CREATE ACCOUNT & SIGN IN” to provide your registration details, then “PROCEED TO CHECKOUT.”
- Follow the simple payment instructions and soon, our writers will be hard at work on your paper.
AcademicWritersBay.com is dedicated to expediting the writing process without compromising on quality. Our roster of writers boasts individuals with advanced degrees—Masters and PhDs—in a myriad of disciplines, ensuring that no matter the complexity or field of your assignment, we have the expertise to tackle it with finesse. Our quick turnover doesn’t mean rushed work; it means efficiency and priority handling, ensuring your deadlines are met with the excellence your academics demand.
