CITS2002 2022-sem2 Project2 23006364.tar

Project2/000075500000000000000000000000001432373655000062655Project2/README.md000075500000000000000000000020501432371144300075360# Trove Program

## If you are marking this project, Please read both README files from v1.0 and v2.0, the Notice sections in the two README files are different.

## v 2.0

- Introduced multi-threads to boost the speed of the Build / Update Function of the program 
  - (save about 50% time, works especially well with a large number of files, depends on the machine you are running)
  - (Warning: This version has Potential FLAWS. Please read the README.md instruction of v2.0 to get more info. if this program frequently crashes on the test machine, For stability reasons, I suggest using v1.0 for the automation test.)

- improve the reading speed of trove-file, this will speed up the program overall ( a little bit :) )
- introducing access() to check the file's state.
- enlarge the hashtable size to suit greater number of files and words.

## v 1.0

- Implement the basic functions that are listed in [Project Instruction](https://teaching.csse.uwa.edu.au/units/CITS2002/projects/project2.php)
- ADD -v function to print out debug info

Project2/v1.0/000075500000000000000000000000001432373714100067465Project2/v2.0/000075500000000000000000000000001432373713500067525Project2/v1.0/inc/000075500000000000000000000000001432373530100075135Project2/v1.0/makefile000075500000000000000000000014211432373630700104520#  CITS2002 Project 2 2022
#  Student:   23006364   HU   ZHUO   100

CC	= gcc -std=c99 -Wall -Werror

trove: 	src/tools.c inc/tools.h \
		src/list.c inc/list.h \
		src/hashtable_list.c inc/hashtable_list.h \
		src/mlist.c inc/mlist.h \
		src/hashtable_mlist.c inc/hashtable_mlist.h \
		src/trovefileIO.c inc/trovefileIO.h \
		src/wordFileIO.c inc/wordFileIO.h \
		src/trove.c inc/trove.h
	$(CC) -c src/tools.c 
	$(CC) -c src/list.c 
	$(CC) -c src/hashtable_list.c 
	$(CC) -c src/mlist.c 
	$(CC) -c src/hashtable_mlist.c 
	$(CC) -c src/trovefileIO.c 
	$(CC) -c src/wordFileIO.c 
	$(CC) -c src/trove.c 
	$(CC) -o trove tools.o list.o hashtable_list.o mlist.o hashtable_mlist.o trovefileIO.o wordFileIO.o trove.o
	rm -f *.o

clean:
	rm -f trove
	rm -f /tmp/troveProject2/v1.0/README.md000075500000000000000000000133031432371110100102140# Trove Program v1.0

Program Trove provides a similar function to Spotlight indexing the contents of files.

Trove makes it easier to search for certain words from a list of files.

[TOC]



## Features:

- Indexing a list of files
- Update the Index File with a list of files
- Remove certain files from the Index file
- Searching the word from Index File
- Change the limitation of word length

## Building

```shell
make / make trove
```

## Executing

1.  

   ```shell
   ./trove [-f trovefile]  word
   ```

   If any file does not exist at the time of the search (it may have been deleted since the trove-file was built), then the file is *not* listed.

   If any files containing the requested word are found, then *trove* will exit with success; otherwise with failure.

   

2.  

   ```shell
   ./trove [-f trovefile] [-b | -r | -u] [-l length]  filelist
   ```

   A *filelist* is a sequence of one-or-more filenames or directory names. The contents of each named file should be indexed, and each named directory (and its subdirectories) should be traversed to locate files to be indexed.

   If the requested action can be performed successfully, then the *trove* will exit with success; otherwise with failure.

## The following command-line options are supported

------

| Command | Explanation |
| ------------ | ------------------------------------------------------------ |
| -b           | build a new trove-file from the contents of a *filelist*. The new trove-file will replace an existing trove-file of the same name. |
| -f trovefile | provides the name of the trove-file to be built or searched. If the -f option is not provided, the default name of the trove-file is **/tmp/trove** |
| -l length    | only words of at least the indicated length should be added to the trove-file. *length* must be a positive integer (not greater than 65535), for example: *-l 6*.  If the -l option is not provided, the default length is **4**. |
| -r           | if any of the files from the *filelist* appear in the trove-file, remove all of their information from the trove-file. |
| -u           | update the trove-file with the contents of all files in the *filelist*. If the information from any of the files already exists in the trove-file, then that (old) information is first removed. |
| -v | if you only use this argument, the program will return an error, print more information about trove-file after operations making any changes to trove-file (it disabled searching function just like -l did) |

## Notes  (Strongly Suggest Reading This before marking)

- Please set up the environment for this project before building and running, The following packages are required to run this project:
  1. build-essential (I believe you have already installed this)
  2. md5sum (This is required to check if the file has been modified after the trove-file has been built or updated)
- Do not put the trove program file or any other opened file (or the directory containing these) into the file list while updating or building, The program will not be able to read from these files. Any attempt to build or update the trove-file using those will fail. The program will return an error and terminate without making any changes to trove-file.
- Although the build and update function accepts a directory as input for the file list, the remove function does not support a directory as input. You can remove all the files under a certain directory using the * sign (but it wouldn't remove the files under the subdirectory of it)
- Please notice that files that are deleted or modified since the trove-file was built or updated, will be permanently removed from trove-file the next time you use the trove program. And this removal will not be resumed even if the deletion or changes made to these files are revocated. You will need to rebuild or update the trove-file to reinclude those files back into the trove-file( index file ) and make it rebecome searchable.
- There is a new argument 'v' added to the program, which is not required in the project outline. But I found it will make the terminal looks messy if the program always prints out the debug info, so this argument has been introduced to allow print information about trove-file after the user makes any changes to trove-file and if you don't use this argument those debug info will not show up. This is mainly used during debugging, but it would be helpful if you want to quickly find out what changes are made to the trove-file after operations like 'building'. Please notice this argument also disables the search function.
- You may find that in my source files, there is no int type variable, instead they are replaced by many uint_t. In fact in the previous version of my work int is often used instead of uint_t, but if trove file records a huge file, the total length of the words recorded from that file gets greater than 2147483647(2^31-1), my program will crash, and pop up segment fault. So it recalls me to use various data types for different situations instead of just using int for everything. But unsigned short, int, unsigned int,  long long... there are too many names, Therefore I include stdint.h to give them a uniform format.
- The trove program using PATH_MAX which is the POSIX equivalent for Microsoft's MAX_PATH, includes 255 characters plus one for a terminating NUL.
- Although I used malloc and realloc to implement dynamic memory control of my program, I cannot help to notice that the efficiency of this technic is very slow, especially when I dynamically allocate memory one letter by one for each word, the program will spend minutes to read a 10MByte file.
- The Larger the trove-file gets, the slower Upadate, Remove, Search functions will be.

Project2/v1.0/src/000075500000000000000000000000001432373532000075325Project2/v2.0/inc/000075500000000000000000000000001432373602500075205Project2/v2.0/makefile000075500000000000000000000014211432373627300104550#  CITS2002 Project 2 2022
#  Student:   23006364   HU   ZHUO   100

CC	= gcc -std=c99 -Wall -Werror

trove: 	src/tools.c inc/tools.h \
		src/list.c inc/list.h \
		src/hashtable_list.c inc/hashtable_list.h \
		src/mlist.c inc/mlist.h \
		src/hashtable_mlist.c inc/hashtable_mlist.h \
		src/trovefileIO.c inc/trovefileIO.h \
		src/wordFileIO.c inc/wordFileIO.h \
		src/trove.c inc/trove.h
	$(CC) -c src/tools.c 
	$(CC) -c src/list.c 
	$(CC) -c src/hashtable_list.c 
	$(CC) -c src/mlist.c 
	$(CC) -c src/hashtable_mlist.c 
	$(CC) -c src/trovefileIO.c 
	$(CC) -c src/wordFileIO.c 
	$(CC) -c src/trove.c 
	$(CC) -o trove tools.o list.o hashtable_list.o mlist.o hashtable_mlist.o trovefileIO.o wordFileIO.o trove.o
	rm -f *.o

clean:
	rm -f trove
	rm -f /tmp/troveProject2/v2.0/README.md000075500000000000000000000121031432371100300102130# Trove Program v2.0

Program Trove provides a similar function to Spotlight indexing the contents of files.

Trove makes it easier to search for certain words from a list of files.

[TOC]



## Features:

- Indexing a list of files
- Update the Index File with a list of files
- Remove certain files from the Index file
- Searching the word from Index File
- Change the limitation of word length
- Multi-thread

## Building

```shell
make / make trove
```

## Executing

1.  

   ```shell
   ./trove [-f trovefile]  word
   ```

   If any file does not exist at the time of the search (it may have been deleted since the trove-file was built), then the file is *not* listed.

   If any files containing the requested word are found, then *trove* will exit with success; otherwise with failure.

   

2.  

   ```shell
   ./trove [-f trovefile] [-b | -r | -u] [-l length]  filelist
   ```

   A *filelist* is a sequence of one-or-more filenames or directory names. The contents of each named file should be indexed, and each named directory (and its subdirectories) should be traversed to locate files to be indexed.

   If the requested action can be performed successfully, then the *trove* will exit with success; otherwise with failure.

## The following command-line options are supported

------

| Command | Explanation |
| ------------ | ------------------------------------------------------------ |
| -b           | build a new trove-file from the contents of a *filelist*. The new trove-file will replace an existing trove-file of the same name. |
| -f trovefile | provides the name of the trove-file to be built or searched. If the -f option is not provided, the default name of the trove-file is **/tmp/trove** |
| -l length    | only words of at least the indicated length should be added to the trove-file. *length* must be a positive integer (not greater than 65535), for example: *-l 6*.  If the -l option is not provided, the default length is **4**. |
| -r           | if any of the files from the *filelist* appear in the trove-file, remove all of their information from the trove-file. |
| -u           | update the trove-file with the contents of all files in the *filelist*. If the information from any of the files already exists in the trove-file, then that (old) information is first removed. |
| -v | if you only use this argument, the program will return an error, print more information about trove-file after operations making any changes to trove-file (it disabled searching function just like -l did) |

## Notes  (Strongly Suggest Reading This before marking)

- Although optimized, the program inevitably sacrifices little stability while improving the speed of reading words from files (That is why adding multi-thread only has impacts on Building / Updating, because these function needs to read a large amount of files while Removing and Searching are just operating a single trove-file). While using it, you should try to avoid putting a directory containing multiple huge files into the file-list. In that case, you should enter the file name of the file inside the directory into the file-list separately. 
  - That is because each time reading a word file, the program will create a new thread and use fopen to read it directly. However, if the program runs too fast, it will soon reach the limit of open file at same time, and the fopen will return NULL pointer which will take as a failure of opening the file. 
  - This depends on the machine you are running, if you have an excellent machine that has extremely fast IO, there is no problem
  - At first, I use usleep() to slow the program down according to the size got from stat(), however stat() cannot get the real size of files that is larger than 8192 Bytes, so it will still cause problems when reading multiple large files under the same directory put in file-list. 
  - Then I tried to use popen("ls -l filenmae", "r") to get the real size of the file, but frequently IO to shell slows down the program way too much. Even without usleep(), the multi-threads version is slower than the mono-thread version!!!
  - so eventually I set the usleep(1000) to keep it stable for most of the files on my computer while being fast, But the drawback is obvious, this is a fixed setting, which means it may not be stable running on other machines.
  - if this program frequently crashes on the test machine, you can longer the time of usleep() in worFileIO.c to suit the test machine. Or for stability reasons, just use the mono-thread version for the automation test.

- Compare to v1.0, v2.0 upgrades the technic of reading words and Lines from files. (especially when reading trove-file). In the older version, for both word and line objects program uses malloc sizeof(char) * 1 and uses realloc to get one more size for every character got from the file. in v2.0, for word objects, the program uses calloc sizeof(char) * 20 to store it and for line object, the program uses calloc sizeof(char) * 1000 and will if the object need to get larger than that, v2.0 can also be dynamic and expands the memory using realloc().
Project2/v2.0/src/000075500000000000000000000000001432373605200075365Project2/v1.0/inc/hashtable_list.h000075500000000000000000000026441432371431600126660/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#ifndef _HASHTABLE_LIST_H
#define _HASHTABLE_LIST_H

#include "list.h"

/* The following include does nothing,
 *  These header files are included here just to show
 *  some of the functions/datatype are using
 *  are declared in the corresponding header file
 *  Because there is protection setted in every header file,
 *  it is safe to include them multiple times
 *  without causing muitiple inclusion error
 *  it is fine to remove them if you want
 */

#include "tools.h"
#include "list.h"

#define HASHTABLE_LIST_SIZE 2027

// WE DEFINE A HASHTABLE AS A (WILL BE, DYNAMICALLY ALLOCATED) ARRAY OF LISTs
typedef LIST *HASHTABLE_LIST;

// ALLOCATE SPACE AND INITIALISE A NEW HASHTABLE_LIST
extern HASHTABLE_LIST *hashtable_list_new(void);

// ADD NEW STRING TO A GIVEN HASHTABLE_LIST
extern void hashtable_list_add(HASHTABLE_LIST *hashtable, char *string);

// CHECK IF A REQUIRED STRING ALREADY EXISTS IN THE GIVEN HASHTABLE_LIST
extern bool hashtable_list_find(HASHTABLE_LIST *hashtable, char *string);

// PRINT THE HASHTABLE_LIST
extern void hashtable_list_print(HASHTABLE_LIST *hashtable);

// REMOVE A STRING FROM THE HASHTABLE_LIST
extern void hashtable_list_remove(HASHTABLE_LIST *hashtable, char *string);

// FREE THE HASHTABLE_LIST
extern void hashtable_list_free(HASHTABLE_LIST *hashtable);

#endifProject2/v1.0/inc/hashtable_mlist.h000075500000000000000000000037711432371431400130430/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#ifndef _HASHTABLE_MLIST_H
#define _HASHTABLE_MLIST_H

#include "mlist.h"

/* The following include does nothing,
 *  These header files are included here just to show
 *  some of the functions/datatype are using
 *  are declared in the corresponding header file
 *  Because there is protection setted in every header file,
 *  it is safe to include them multiple times
 *  without causing muitiple inclusion error
 *  it is fine to remove them if you want
 */

#include "tools.h"
#include "list.h"
#include "hashtable_list.h"

#define HASHTABLE_MLIST_SIZE 997

typedef MLIST *HASHTABLE_MLIST;

// ALLOCATE SPACE AND INITIALISE A NEW HASHTABLE_MLIST
extern HASHTABLE_MLIST *hashtable_mlist_new(void);

// ADD NEW FILENAME TO THE HASHTABLE_MLIST
extern void hashtable_mlist_add(HASHTABLE_MLIST *hashtable, char *filename, char *word);

// RETURN THE A LIST CONTIANING ALL THE FILENAMES IN HASHTABLE_MLIST
extern LIST *hashtable_mlist_filename(HASHTABLE_MLIST *hashtable);

//  PRINT ALL OF FILENAMES IN THE HASHTABLE_MLIST
extern void hashtable_mlist_filename_print(HASHTABLE_MLIST *hashtable);

// RETURN THE KEYWORD LIST OF THE GIVEN FILENAME
extern HASHTABLE_LIST *hashtable_mlist_filename_list(HASHTABLE_MLIST *hashtable, char *filename);

// PRINT FILENAMES HAVING THE KEYWORD UNDER THEIR WORD LIST
extern void hashtable_mlist_files_have_word_print(HASHTABLE_MLIST *hashtable, char *keyword);

// UPDATE HASHTABLE1 USING HASHTABLE2
extern void hashtable_mlist_update(HASHTABLE_MLIST *hashtable1, HASHTABLE_MLIST *hashtable2);

//  REMOVE A MLIST HAVING GIVEN FILENAME FROM THE HASHTABLE_MLIST
extern void hashtable_mlist_remove(HASHTABLE_MLIST *, char *filename);

//  PRINT EVERYTHING IN HASHTABLE_MLIST
extern void hashtable_mlist_print(HASHTABLE_MLIST *hashtable);

//  FREE THE SPACE ALLOCATED FOR A GIVEN HASHTABLE_MLIST
extern void hashtable_mlist_free(HASHTABLE_MLIST *hashtable);

#endifProject2/v1.0/inc/list.h000075500000000000000000000016021432371431200106400/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#ifndef _LIST_H
#define _LIST_H

#include "tools.h"

// IMPLITATION OF LIST
typedef struct list
{
    char *word;
    struct list *next;
} LIST;

// MAKE A NFW BLANK LIST ITEM
extern LIST *list_new(void);

// DETERMINE IF THE TARGET IS STORED IN A GIVEN LIST
extern bool list_find(LIST *list, char *target);

// ADD NEW CHAIN TO THE LIST, DO NOTHING IF THE CHAIN IS ALREADY IN THE LIST
extern LIST *list_add(LIST *list, char *word);

// REMOVE CHAIN FROM THE LIST, DO NOTHING IF THE CHAIN IS NOT IN THE LIST
extern void list_remove(LIST *list, char *target);

// PRINT THE LIST
extern void list_print(LIST *list);

// SPECIAL list_print (ONLY USED FOR TESTING)
extern void list_file_print(LIST *list);

// FREE THE MEMORY OF THE LIST
extern void list_free(LIST *list);

#endifProject2/v1.0/inc/mlist.h000075500000000000000000000023441432373551500110310/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#ifndef _MLIST_H
#define _MLIST_H

#include "hashtable_list.h"

// A MOTHER LIST HAS TWO LINKS, ONE FOR A SIMPLE LIST, ONE FOR THE NEXT MOTHER LIST
typedef struct mlist
{
    char *filename;
    char *md5;
    HASHTABLE_LIST *words;
    struct mlist *next;
} MLIST;

// MAKE A BLANK MLIST ITEM
extern MLIST *mlist_new(void);

// DETERMINE IF THE TARGET FILENAME IS STORED IN A GIVEN MLIST
extern bool mlist_find(MLIST *mlist, char *target);

// ADD NEW FILENAME TO THE MLIST, DO NOTHING IF THE FILENAME IS ALREADY IN THE MLIST
extern MLIST *mlist_add(MLIST *mlist, char *filename);

// REPLACE THE CHAIN IN MLIST1 WITH THE SAME FILENAME IN MLIST2, INSERT A NEW CHAIN IF THE FILENAME IN MLIST2 IS NOT IN MLIST1
extern void mlist_update(MLIST *mlist1, MLIST *mlist2);

// REMOVE FILENAME FROM THE MLIST, DO NOTHING IF THE FILENAME IS NOT IN THE MLIST
extern void mlist_remove(MLIST *mlist, char *target);

// Print the MLIST
extern void mlist_print(MLIST *mlist);

// PRINT THE FILE NAME IN THE MLIST
extern void mlist_filename_print(MLIST *mlist);

// FREE THE MEMORY OF THE MLIST
extern void mlist_free(MLIST *mlist);

#endifProject2/v1.0/inc/tools.h000075500000000000000000000033421432371425200110330/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

// open up all features including POSIX_C_SOURCE
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif

#ifndef _TOOLS_H
#define _TOOLS_H

#include <ctype.h>
#include <dirent.h>
#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>

extern uint32_t wordlen;
extern uint32_t ARG_MAX;

// CHECK IF THE MEMORY ALLOCATION WAS SUCCESSFUL
#ifndef CHECK_MEM
#define CHECK_MEM(p)        \
    if (p == NULL)          \
    {                       \
        perror(__func__);   \
        exit(EXIT_FAILURE); \
    }
#endif

// DJBHASH FUNCTION FOR HASHING STRING
extern uint16_t DJBHash(char *string);

// CHECK IF THE STRING IS A WORD
extern bool isString(char *string);

// CHANGE THE KEYLEN
extern void change_wordlen(uint32_t len);

// CHECK IF THE WORD LEN IS GREATER THAN KEYLEN
extern bool wordlen_check(char *word);

// IF THE FILE IS EXIST RETURN THE FILE POINTER OTHERWISE POP UP ERROR MESSAGE
extern FILE *openfile(char *filename);

// GET THE REAL PATH OF THE FILE
extern char *getRealPath(char *filename);

// GET ONE LINE FROM THE FILE
extern char *getLine(FILE *file);

// CHECK IF THE GIVEN STRING IS A INTERGER
extern bool isInt(char *str);

// CHECK IF THE GIVEN NAME IS A FILE
extern bool isFile(char *name);

// CHECK IF THE GIVEN NAME IS DIRECTORY
extern bool isDirectory(char *name);

// CALCULATE MD5 HASH OF THE GIVEN FILE
extern char *md5sum(char *filename);

// CHECK IF THE STORED MD5 HASH IS THE SAME AS THE MD5 HASH OF THE FILE
extern bool md5check(char *md5, char *filename);

#endifProject2/v1.0/inc/trove.h000075500000000000000000000011651432373650400110370/*  
*   CITS2002  Project 2  2022-sem2
*   Student:  23006364   HU ZHUO   100
*/

#ifndef _TROVE_H
#define _TROVE_H

#include "trovefileIO.h"

/* The following include does nothing, 
*  These header files are included here just to show 
*  some of the functions/datatype are using
*  are declared in the corresponding header file
*  Because there is protection setted in every header file,
*  it is safe to include them multiple times 
*  without causing muitiple inclusion error
*  it is fine to remove them if you want
*/

#include "wordFileIO.h"
#include "tools.h"
#include "hashtable_mlist.h"

#endifProject2/v1.0/inc/trovefileIO.h000075500000000000000000000026401432373645700121350/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#ifndef _TROVEFILEIO_H
#define _TROVEFILEIO_H

#include "wordFileIO.h"

/* The following include does nothing,
 *  These header files are included here just to show
 *  some of the functions/datatype are using
 *  are declared in the corresponding header file
 *  Because there is protection setted in every header file,
 *  it is safe to include them multiple times
 *  without causing muitiple inclusion error
 *  it is fine to remove them if you want
 */

#include "tools.h"
#include "list.h"
#include "hashtable_list.h"
#include "mlist.h"
#include "hashtable_mlist.h"

extern char *TROVE_FILE;
extern FILE *TROVE_FILE_P;

// CHANGE THE TROVE FILE NAME
extern void change_trove_file(char *filename);

// READ THE TROVE FILE AND LOAD THE HASHTABLE FROM IT
extern HASHTABLE_MLIST *trovefile_load(void);

// REPLACE THE TROVE FILE WITH THE NEW ONE, REMOVE THE OLD ONE AND REPLACE IT WITH THE NEW ONE
extern void trovefile_write(HASHTABLE_MLIST *hashtable);

// UPDATE THE HASHTABLE TO THE TROVE FILE, OVERWRITING THE OLD DATA HAVE SAME FILE NAME WHILE KEEPING THE OTHER DATA
extern void trovefile_update(HASHTABLE_MLIST *hashtbale);

// PRINT ALL THE FILENAME IN THE TROVE FILE
extern void trovefile_print(void);

// PRINT ALL THE FILENAME IN THE TROVE FILE
extern void trovefile_filename_print(void);

#endifProject2/v1.0/inc/wordFileIO.h000075500000000000000000000013511432373644400117030/*  
*   CITS2002  Project 2  2022-sem2
*   Student:  23006364   HU ZHUO   100
*/

#ifndef _WORDFILEIO_H
#define _WORDFILEIO_H

#include "hashtable_mlist.h"

/* The following include does nothing, 
*  These header files are included here just to show 
*  some of the functions/datatype are using
*  are declared in the corresponding header file
*  Because there is protection setted in every header file,
*  it is safe to include them multiple times 
*  without causing muitiple inclusion error
*  it is fine to remove them if you want
*/

#include "tools.h"
#include "hashtable_mlist.h"


// RECORD ALL THE WORDS FROM FILE INTO THE HASHTABLE
extern void recordWord(char *filename, HASHTABLE_MLIST *hashtable);

#endifProject2/v1.0/src/hashtable_list.c000075500000000000000000000037661432373537700127170/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#include "../inc/hashtable_list.h"

// ALLOCATE SPACE AND INITIALISE A NEW HASHTABLE_LIST
HASHTABLE_LIST *hashtable_list_new(void)
{
    HASHTABLE_LIST *new = (HASHTABLE_LIST *)malloc(sizeof(LIST *) * HASHTABLE_LIST_SIZE);
    CHECK_MEM(new);
    memset(new, 0, sizeof(LIST *) * HASHTABLE_LIST_SIZE);

    for (uint16_t i = 0; i < HASHTABLE_LIST_SIZE; i++)
    {
        new[i] = list_new();
    }
    return new;
}

// ADD A NEW STRING TO A GIVEN HASHTABLE_LIST
void hashtable_list_add(HASHTABLE_LIST *hashtable, char *string)
{
    uint16_t hash = DJBHash(string) % HASHTABLE_LIST_SIZE;

    hashtable[hash] = list_add(hashtable[hash], string);
}

// CHECK IF A REQUIRED STRING ALREADY EXISTS IN THE GIVEN HASHTABLE_LIST
bool hashtable_list_find(HASHTABLE_LIST *hashtable, char *string)
{
    uint16_t hash = DJBHash(string) % HASHTABLE_LIST_SIZE;

    return list_find(hashtable[hash], string);
}

// PRINT THE HASHTABLE_LIST
void hashtable_list_print(HASHTABLE_LIST *hashtable)
{
    for (uint16_t i = 0; i < HASHTABLE_LIST_SIZE; i++)
    {
        LIST *list = hashtable[i];
        if (list != NULL)
        {
            list_print(list);
        }
    }
    printf("\n");
}

// REMOVE A STRING FROM THE HASHTABLE_LIST
extern void hashtable_list_remove(HASHTABLE_LIST *hashtable, char *string)
{
    uint16_t hash = DJBHash(string) % HASHTABLE_LIST_SIZE;
    list_remove(hashtable[hash], string);
    if (hashtable[hash]->next == NULL && hashtable[hash]->word != NULL && string != NULL)
    {
        if (!strcmp(hashtable[hash]->word, string))
        {
            hashtable[hash] = list_new();
        }
    }
}

// FREE THE HASHTABLE_LIST
void hashtable_list_free(HASHTABLE_LIST *hashtable)
{
    for (uint16_t i = 0; i < HASHTABLE_LIST_SIZE; i++)
    {
        list_free(hashtable[i]);
        hashtable[i] = NULL;
    }
    free(hashtable);
    hashtable = NULL;
}
Project2/v1.0/src/hashtable_mlist.c000075500000000000000000000116111432373540600130510/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#include "../inc/hashtable_mlist.h"

// ALLOCATE SPACE AND INITIALISE A NEW HASHTABLE_MLIST
HASHTABLE_MLIST *hashtable_mlist_new(void)
{
    HASHTABLE_MLIST *new = (HASHTABLE_MLIST *)malloc(sizeof(MLIST *) * HASHTABLE_MLIST_SIZE);
    CHECK_MEM(new);
    memset(new, 0, sizeof(MLIST *) * HASHTABLE_MLIST_SIZE);

    for (uint16_t i = 0; i < HASHTABLE_MLIST_SIZE; i++)
    {
        new[i] = mlist_new();
    }
    return new;
}

// ADD NEW FILENAME TO THE HASHTABLE_MLISTT
void hashtable_mlist_add(HASHTABLE_MLIST *hashtable, char *filename, char *word)
{
    uint16_t hash = DJBHash(filename) % HASHTABLE_MLIST_SIZE;

    hashtable[hash] = mlist_add(hashtable[hash], filename);
    if (hashtable[hash]->words == NULL)
    {
        hashtable[hash]->words = hashtable_list_new();
    }
    hashtable_list_add(hashtable[hash]->words, word);
}

// RETURN THE A LIST CONTIANING ALL THE FILENAMES IN HASHTABLE_MLIST
LIST *hashtable_mlist_filename(HASHTABLE_MLIST *hashtable)
{
    LIST *list = list_new();
    for (uint16_t i = 0; i < HASHTABLE_MLIST_SIZE; i++)
    {
        MLIST *mlist = hashtable[i];
        while (mlist != NULL && mlist->filename != NULL)
        {
            list = list_add(list, mlist->filename);
            mlist = mlist->next;
        }
    }
    return list;
}

//  PRINT ALL OF FILENAMES IN THE HASHTABLE_MLIST
void hashtable_mlist_filename_print(HASHTABLE_MLIST *hashtable)
{
    for (uint16_t i = 0; i < HASHTABLE_MLIST_SIZE; i++)
    {
        MLIST *mlist = hashtable[i];
        mlist_filename_print(mlist);
    }
}

// CHECK IF THE FILENAME ALREADY EXISTS IN A GIVEN HASHTABLE_MLIST
bool hashtable_mlist_find(HASHTABLE_MLIST *hashtable, char *filename)
{
    uint16_t hash = DJBHash(filename) % HASHTABLE_MLIST_SIZE;

    return mlist_find(hashtable[hash], filename);
}

// RETURN THE KEYWORD LIST OF THE GIVEN FILENAME
HASHTABLE_LIST *hashtable_mlist_filename_list(HASHTABLE_MLIST *hashtable, char *filename)
{
    uint16_t hash = DJBHash(filename) % HASHTABLE_MLIST_SIZE;

    MLIST *mlist = hashtable[hash];
    if (mlist_find(mlist, filename))
    {
        while (mlist != NULL && mlist->filename != NULL && filename != NULL)
        {
            if (!strcmp(mlist->filename, filename))
            {
                return mlist->words;
            }
            mlist = mlist->next;
        }
    }
    return mlist_add(hashtable[hash], filename)->words;
}

// RETURN THE LIST OF FILENAME HAVING THE KEYWORD UNDER THEIR HASHTABLE_LIST
LIST *hashtable_mlist_files_have_word(HASHTABLE_MLIST *hashtable, char *keyword)
{
    LIST *list = list_new();
    for (uint16_t i = 0; i < HASHTABLE_MLIST_SIZE; i++)
    {
        MLIST *mlist = hashtable[i];
        while (mlist != NULL)
        {
            if (hashtable_list_find(mlist->words, keyword))
            {
                list = list_add(list, mlist->filename);
            }
            mlist = mlist->next;
        }
    }
    return list;
}

// PRINT FILENAMES HAVING THE KEYWORD UNDER THEIR WORD LIST
void hashtable_mlist_files_have_word_print(HASHTABLE_MLIST *hashtable, char *keyword)
{
    LIST *list = hashtable_mlist_files_have_word(hashtable, keyword);
    if (list == NULL || list->word == NULL)
    {
        exit(EXIT_FAILURE);
    }
    list_file_print(list);
    list_free(list);
    printf("\n");
}

// UPDATE HASHTABLE1 USING HASHTABLE2
void hashtable_mlist_update(HASHTABLE_MLIST *hashtable1, HASHTABLE_MLIST *hashtable2)
{
    for (uint16_t i = 0; i < HASHTABLE_MLIST_SIZE; i++)
    {
        MLIST *mlist1 = hashtable1[i];
        MLIST *mlist2 = hashtable2[i];
        mlist_update(mlist1, mlist2);
    }
}

//  REMOVE A MLIST HAVING GIVEN FILENAME FROM THE HASHTABLE_MLIST
void hashtable_mlist_remove(HASHTABLE_MLIST *hashtable, char *filename)
{
    filename = getRealPath(filename);
    printf("\t%s\n", filename);
    uint16_t hash = DJBHash(filename) % HASHTABLE_MLIST_SIZE;

    mlist_remove(hashtable[hash], filename);
    if (hashtable[hash]->next == NULL && hashtable[hash]->filename != NULL && filename != NULL)
    {
        if (!strcmp(hashtable[hash]->filename, filename))
        {
            hashtable[hash] = mlist_new();
        }
    }

    free(filename);
}

//  PRINT EVERYTHING IN HASHTABLE_MLIST
void hashtable_mlist_print(HASHTABLE_MLIST *hashtable)
{
    for (uint16_t i = 0; i < HASHTABLE_MLIST_SIZE; i++)
    {
        if (hashtable[i] != NULL)
        {
            mlist_print(hashtable[i]);
        }
    }
}

//  FREE THE SPACE ALLOCATED FOR A GIVEN HASHTABLE_MLIST
void hashtable_mlist_free(HASHTABLE_MLIST *hashtable)
{
    for (uint16_t i = 0; i < HASHTABLE_MLIST_SIZE; i++)
    {
        mlist_free(hashtable[i]);
        hashtable[i] = NULL;
    }
    free(hashtable);
    hashtable = NULL;
}Project2/v1.0/src/list.c000075500000000000000000000046031432373541200106610/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#include "../inc/list.h"

// MAKE A NFW BLANK LIST ITEM
LIST *list_new(void)
{
    LIST *new = (LIST *)malloc(sizeof(LIST) * 1);
    CHECK_MEM(new);
    memset(new, 0, sizeof(LIST) * 1);

    new->word = NULL;
    new->next = NULL;

    return new;
}

// DETERMINE IF THE TARGET IS STORED IN A GIVEN LIST
bool list_find(LIST *list, char *target)
{
    while (target != NULL && list != NULL)
    {
        if (list->word != NULL && !strcmp(list->word, target))
        {
            return true;
        }
        list = list->next;
    }
    return false;
}

//  ALLOCATE SPACE FOR A NEW LIST ITEM AND CHECK IF ALLOCATION SUCCEEDS
LIST *list_new_item(char *word)
{
    LIST *newList = (LIST *)malloc(sizeof(LIST) * 1);
    CHECK_MEM(newList);
    memset(newList, 0, sizeof(LIST) * 1);

    newList->word = strdup(word);
    newList->next = list_new();

    return newList;
}

// ADD NEW CHAIN TO THE LIST, DO NOTHING IF THE CHAIN IS ALREADY IN THE LIST
LIST *list_add(LIST *list, char *word)
{
    LIST *tmp = list;
    if (list_find(list, word))
    {
        return tmp;
    }
    else
    {
        LIST *newList = list_new_item(word);
        newList->next = tmp;
        return newList;
    }
}

// REMOVE CHAIN FROM THE LIST, DO NOTHING IF THE CHAIN IS NOT IN THE LIST
void list_remove(LIST *list, char *target)
{
    while (target != NULL && list != NULL)
    {
        if (!strcmp(list->word, target))
        {
            LIST *tmp = list->next;
            list->next = list->next->next;
            free(tmp);
            break;
        }
        list = list->next;
    }
}

// PRINT THE LIST
void list_print(LIST *list)
{
    while (list != NULL)
    {
        if (list->word != NULL)
        {
            printf("\t%s,", list->word);
        }
        list = list->next;
    }
}

// SPECIAL list_print
void list_file_print(LIST *list)
{
    while (list != NULL)
    {
        if (list->word != NULL)
        {
            printf("%s\n", list->word);
        }
        list = list->next;
    }
}

// FREE THE MEMORY OF THE LIST
void list_free(LIST *list)
{
    while (list != NULL)
    {
        LIST *tmp = list;
        list = list->next;
        free(tmp);
        tmp = NULL;
    }
    free(list);
    list = NULL;
}Project2/v1.0/src/mlist.c000075500000000000000000000101201432373541400110270/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#include "../inc/mlist.h"

// MAKE A BLANK MLIST ITEM
MLIST *mlist_new(void)
{
    MLIST *mlist = (MLIST *)malloc(sizeof(MLIST));
    CHECK_MEM(mlist);
    memset(mlist, 0, sizeof(MLIST));

    mlist->filename = NULL;
    mlist->md5 = NULL;
    mlist->words = hashtable_list_new();
    mlist->next = NULL;

    return mlist;
}

//  DETERMINE IF THE TARGET FILENAME IS STORED IN A GIVEN MLIST
bool mlist_find(MLIST *mlist, char *target)
{
    while (mlist != NULL && mlist->filename != NULL && target != NULL)
    {
        if (!strcmp(mlist->filename, target))
        {
            return true;
        }
        mlist = mlist->next;
    }
    return false;
}

//  ALLOCATE SPACE FOR A NEW MLIST ITEM AND CHECK IF ALLOCATION SUCCEEDS
MLIST *mlist_new_item(char *filename)
{
    MLIST *newMList = (MLIST *)malloc(sizeof(MLIST) * 1);
    CHECK_MEM(newMList);
    memset(newMList, 0, sizeof(MLIST) * 1);

    newMList->filename = strdup(filename);
    newMList->md5 = strdup(md5sum(filename));
    newMList->words = hashtable_list_new();
    newMList->next = mlist_new();

    return newMList;
}

// ADD NEW FILENAME TO THE MLIST, REPLACE IT IF THE FILENAME IS ALREADY IN THE MLIST
MLIST *mlist_add(MLIST *mlist, char *filename)
{
    if (mlist_find(mlist, filename))
    {
        return mlist;
    }
    else
    {
        MLIST *newMList = mlist_new_item(filename);
        newMList->next = mlist;
        return newMList;
    }
}

// REPLACE THE CHAIN IN MLIST1 WITH THE SAME FILENAME IN MLIST2, INSERT A NEW CHAIN IF THE FILENAME IN MLIST2 IS NOT IN MLIST1
void mlist_update(MLIST *mlist1, MLIST *mlist2)
{
    MLIST *tmp = mlist1;
    while (mlist1 != NULL && mlist1->filename != NULL)
    {
        while (mlist2 != NULL && mlist2->filename != NULL)
        {
            if (!strcmp(mlist2->filename, mlist1->filename))
            {
                mlist1->words = mlist2->words;
                mlist_remove(mlist2, mlist1->filename);
            }
            mlist2 = mlist2->next;
        }
        mlist1 = mlist1->next;
    }
    mlist1->next = mlist2;
    mlist1 = tmp;
}

// REMOVE CHAIN FROM THE MLIST, DO NOTHING IF THE FILENAME IS NOT IN THE MLIST
void mlist_remove(MLIST *mlist, char *target)
{
    while (mlist->next != NULL && mlist->filename != NULL && target != NULL)
    {
        if (!strcmp(mlist->filename, target))
        {
            MLIST *tmp = mlist->next;
            mlist->next = mlist->next->next;
            free(tmp);
            break;
        }
        mlist = mlist->next;
    }
}

// Print the MLIST
void mlist_print(MLIST *mlist)
{
    if (mlist != NULL)
    {
        while (mlist->next != NULL)
        {
            if (mlist->filename != NULL)
            {
                printf("\t%s:\n", mlist->filename);
                printf("\tMD5: %s\n", mlist->md5);
                hashtable_list_print(mlist->words);
                printf("\n");
            }
            mlist = mlist->next;
        }
        if (mlist->next == NULL && mlist->filename != NULL)
        {
            printf("\t%s:\n", mlist->filename);
            hashtable_list_print(mlist->words);
            printf("\n");
        }
    }
}

// PRINT THE FILE NAME IN THE MLIST
void mlist_filename_print(MLIST *mlist)
{
    if (mlist != NULL)
    {
        while (mlist->next != NULL)
        {
            if (mlist->filename != NULL)
            {
                printf("\t%s\n", mlist->filename);
            }
            mlist = mlist->next;
        }
        if (mlist->next == NULL && mlist->filename != NULL)
        {
            printf("\t%s\n", mlist->filename);
        }
    }
}

// FREE THE MLIST
void mlist_free(MLIST *mlist)
{
    while (mlist != NULL)
    {
        MLIST *tmp = mlist;
        free(tmp->filename);
        free(tmp->md5);
        hashtable_list_free(mlist->words);
        mlist = mlist->next;
        free(tmp);
        tmp = NULL;
    }
    free(mlist);
    mlist = NULL;
}Project2/v1.0/src/tools.c000075500000000000000000000071461432373541600110570/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#include "../inc/tools.h"

uint32_t ARG_MAX = 2097152;
uint32_t wordlen = 4;

// DJBHASH FUNCTION FOR HASHING STRING
uint16_t DJBHash(char *string)
{
    uint16_t hash = 5381;
    char c = *string;

    while (c != '\0')
    {
        hash = hash * 33 + c;
        c = *++string;
    }
    return hash;
}

// CHECK IF THE STRING IS A WORD
bool isString(char *string)
{
    char c = *string;
    while (c != '\0')
    {
        if (!isalnum(c))
        {
            return false;
        }
        c = *++string;
    }
    return true;
}

// CHANGE THE WORDLEN
void change_wordlen(uint32_t len)
{
    wordlen = len;
}

// CHECK IF THE WORD LEN IS GREATER THAN KEYLEN
bool wordlen_check(char *word)
{
    char *tmp = word;
    uint32_t len = strlen(tmp);
    if (len >= wordlen)
    {
        return true;
    }
    return false;
}

// IF THE FILE IS EXIST RETURN THE FILE POINTER OTHERWISE POP UP ERROR MESSAGE
FILE *openfile(char *filename)
{
    FILE *file = fopen(filename, "r+");
    if (file == NULL)
    {
        printf("File %s does not exist\n", filename);
        perror("fopen");
        exit(EXIT_FAILURE);
    }
    return file;
}

// GET THE REAL PATH OF THE FILE
char *getRealPath(char *filename)
{
    char *fileRealPath = (char *)malloc(PATH_MAX);
    CHECK_MEM(fileRealPath);

    realpath(filename, fileRealPath);
    return fileRealPath;
}

// GET ONE LINE FROM THE FILE
char *getLine(FILE *file)
{
    char *line = (char *)malloc(1);
    CHECK_MEM(line);

    char c = fgetc(file);
    uint64_t len = 0;

    while (!feof(file))
    {
        if (c != '\n')
        {
            line[len] = c;
            len++;
            line = (char *)realloc(line, sizeof(char) * (len + 1));
        }
        else
        {
            line[len] = '\0';
            break;
        }
        c = fgetc(file);
    }
    return line;
}

// A FUNCTION CHANGE THE GIVEN INT TO STRING
char *itoa(uint16_t num)
{
    char *str = (char *)malloc(sizeof(char) * 20);
    CHECK_MEM(str);
    memset(str, 0, sizeof(char) * 20);

    sprintf(str, "%d", num);
    return str;
}

// CHECK IF THE GIVEN STRING IS A INTERGER
bool isInt(char *str)
{
    if (!strcmp(itoa(atoi(str)), str))
    {
        return true;
    }
    return false;
}

// CHECK IF THE GIVEN NAME IS A FILE
bool isFile(char *name)
{
    struct stat statbuf;
    if (stat(name, &statbuf))
    {
        return false;
    }
    return S_ISREG(statbuf.st_mode);
}

// CHECK IF THE GIVEN NAME IS DIRECTORY
bool isDirectory(char *name)
{
    struct stat statbuf;
    if (stat(name, &statbuf))
    {
        return false;
    }
    return S_ISDIR(statbuf.st_mode);
}

// CALCULATE MD5 HASH OF THE GIVEN FILE
char *md5sum(char *filename)
{
    char *md5 = (char *)malloc(sizeof(char) * 33);
    CHECK_MEM(md5);
    memset(md5, 0, sizeof(char) * 33);
    char *cmd = strdup("md5sum '");

    cmd = (char *)realloc(cmd, sizeof(char) * (strlen(cmd) + strlen(filename) + 2));
    strcat(cmd, filename);
    strcat(cmd, "'");

    FILE *terminal = popen(cmd, "r");

    fgets(md5, sizeof(char) * 33, terminal);
    md5[32] = '\0';

    pclose(terminal);
    free(cmd);

    return md5;
}

// CHECK IF THE STORED MD5 HASH IS THE SAME AS THE MD5 HASH OF THE FILE
bool md5check(char *md5, char *filename)
{
    char *md5new = md5sum(filename);
    if (!strcmp(md5, md5new))
    {
        free(md5new);
        return true;
    }
    free(md5new);
    return false;
}Project2/v1.0/src/trove.c000075500000000000000000000127061432373542100110500/*  
*   CITS2002  Project 2  2022-sem2
*   Student:  23006364   HU ZHUO   100
*/

#include "../inc/trove.h"

bool info = false;

// IF THE ARGUMENT IS NOT CORRECT, PRINT THE USAGE AND EXIT
void err_print(void)
{
    printf("%s\n%s\n\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n",
           "Usage:\t./trove [-f trove-file] [-b | -r | -u] [-l length] [-v] filelist",
           "or\t./trove [-f trove-file] word",
           "where options are",
           "-b\t\tbuild a new trove-file",
           "-f trove-file\tprovide the name of the trove-file to be built or searched",
           "-l length\tspecify the minimum-length of words added to the trove-file",
           "-r\t\tremove a trove-file",
           "-u\t\tupdate a trove-file",
           "-v\t\tadditional option to print details");
    exit(EXIT_FAILURE);
}

// BUILD FUNCTION
void build_trove(uint32_t argc, char *argv[], HASHTABLE_MLIST *hashtable)
{
    printf("\tTrove-File:\t%s\n\tWordlen limit:\t%d\n", TROVE_FILE, wordlen);
    printf("\t--------------------------Building--------------------------\n");
    hashtable = hashtable_mlist_new();
    for (; optind < argc; optind++)
    {
        recordWord(argv[optind], hashtable);
    }
    trovefile_write(hashtable);
    if (info)
    {
        printf("\tThe Trove File is now Containing:\n");
        printf("\t----------------------Trove File Detail----------------------\n");
        trovefile_print();
    }
    exit(EXIT_SUCCESS);
}

// REMOVE FUNCTION
void remove_func(uint32_t argc, char *argv[], HASHTABLE_MLIST *hashtable)
{
    printf("\tTrove-File:\t%s\n", TROVE_FILE);
    printf("\t--------------------------Removing--------------------------\n");
    hashtable = trovefile_load();
    for (; optind < argc; optind++)
    {
        if (!access(argv[optind], R_OK))
        {
            hashtable_mlist_remove(hashtable, argv[optind]);
        }
    }
    trovefile_write(hashtable);
    if (info)
    {
        printf("\tAfter Remove, The Trove File Containing:\n");
        printf("\t-------------------------Trove File-------------------------\n");
        trovefile_filename_print();
    }
    exit(EXIT_SUCCESS);
}

// UPDATE FUNCTION
void update_trove(uint32_t argc, char *argv[], HASHTABLE_MLIST *hashtable)
{
    printf("\tTrove-File:\t%s\n\tWordlen limit:\t%d\n", TROVE_FILE, wordlen);
    printf("\t--------------------------Updating--------------------------\n");
    hashtable = hashtable_mlist_new();
    for (; optind < argc; optind++)
    {
        recordWord(argv[optind], hashtable);
    }
    trovefile_update(hashtable);
    if (info)
    {
        printf("\tThe Trove File is now Containing:\n");
        printf("\t----------------------Trove File Detail----------------------\n");
        trovefile_print();
    }
    exit(EXIT_SUCCESS);
}

// SERACH FUNCTION
void search_func(uint32_t argc, char *argv[], HASHTABLE_MLIST *hashtable)
{
    printf("\tSearching...\n\tTrove File:\t%s\n\tTarget Word:\t\"%s\"\n", TROVE_FILE, argv[argc - 1]);
    printf("\t-----------------------SEARCH RESULT------------------------\n");
    hashtable = trovefile_load();
    hashtable_mlist_files_have_word_print(hashtable, argv[argc - 1]);
    trovefile_write(hashtable);
    exit(EXIT_SUCCESS);
}

int32_t main(int32_t argc, char *argv[])
{
    uint32_t result;
    uint16_t argc_cor = 2;
    uint16_t function = 0; // 0: search 1: build, 2: remove, 3: update

    HASHTABLE_MLIST *hashtable = hashtable_mlist_new();

    while ((result = getopt(argc, argv, "f:brul:v")) != -1)
    {
        switch (result)
        {
        case 'f':

            change_trove_file(optarg);
            argc_cor += 2;
            break;

        case 'l':

            if (!isInt(optarg) || atoi(optarg) < 1)     // if the length is not a positive integer or larger than 255
            {
                err_print();
            }
            change_wordlen(atoi(optarg));
            argc_cor += 2;
            if (function == 0)
            {
                function = 4; // 4: not allow search and remove, if -l argument is used
            }
            break;

        case 'b':

            if ((function && function != 4) || argc <= argc_cor++)
            {
                err_print();
            }
            function = 1; // 1: build
            break;

        case 'r':

            if ((function && function != 4) || argc <= argc_cor++)
            {
                err_print();
            }
            function = 2; // 2: remove
            break;

        case 'u':

            if ((function && function != 4) || argc <= argc_cor++)
            {
                err_print();
            }
            function = 3; // 3: update
            break;

        case 'v':

            argc_cor++;
            info = true;
            break;

        default:
            err_print();
        }
    }

    if (argc == argc_cor && !function && !info) // SEARCH FUNCTION
    {
        if (!isString(argv[argc - 1]))
        {
            err_print();
        }
        search_func(argc, argv, hashtable);
    }
    else if (function == 1) // BUILD FUNCTION
    {
        build_trove(argc, argv, hashtable);
    }
    else if (function == 2) // REMOVE FUNCTION
    {
        remove_func(argc, argv, hashtable);
    }
    else if (function == 3) // UPDATE FUNCTION
    {
        update_trove(argc, argv, hashtable);
    }

    err_print();
    return 1;
}Project2/v1.0/src/trovefileIO.c000075500000000000000000000173611432373546000121450/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#include "../inc/trovefileIO.h"

char *TROVE_FILE = "/tmp/trove";
FILE *TROVE_FILE_P = NULL;

// CHANGE THE TROVE FILE NAME
void change_trove_file(char *filename)
{
    TROVE_FILE = strdup(filename);
}

// OPEN THE TROVE FILE
void trovefile_open(void)
{
    char *cmd = (char *)malloc(sizeof(char) * ARG_MAX);
    CHECK_MEM(cmd);
    memset(cmd, '\0', ARG_MAX);

    strcpy(cmd, "zcat '");
    strcat(cmd, TROVE_FILE);
    strcat(cmd, "'");

    if (access(TROVE_FILE, R_OK))
    {
        perror("access");
        exit(EXIT_FAILURE);
    }
    TROVE_FILE_P = popen(cmd, "r");
}

// CLOSE THE TROVE FILE AND GZIP IT
void trovefile_gz_close(void)
{
    fclose(TROVE_FILE_P);

    char *cmd = (char *)malloc(sizeof(char) * ARG_MAX);
    CHECK_MEM(cmd);
    memset(cmd, '\0', ARG_MAX);

    strcpy(cmd, "gzip -9 '");
    strcat(cmd, TROVE_FILE);
    strcat(cmd, "'");

    system(cmd);

    strcpy(cmd, "mv '");
    strcat(cmd, TROVE_FILE);
    strcat(cmd, ".gz' '");
    strcat(cmd, TROVE_FILE);
    strcat(cmd, "'");

    system(cmd);
    free(cmd);
}

// LOAD THE WORDS FROM THE TROVE FILE INTO THE HASHTABLE
void load_from_troveFile(char *filename, char *wordslist, HASHTABLE_MLIST *hashtable)
{
    char *word = (char *)malloc(sizeof(char) * 1);
    CHECK_MEM(word);
    memset(word, '\0', 1);

    char *tmp = (char *)malloc(sizeof(char) * 1);
    CHECK_MEM(tmp);
    memset(tmp, '\0', 1);
    char c = *wordslist;

    uint32_t len = 0;

    while (c != '\0')
    {
        if (isalnum(c))
        {
            tmp = realloc(tmp, sizeof(char) * (len + 2));
            tmp[len] = c;
            len++;
        }
        else
        {
            tmp[len] = '\0';
            word = strdup(tmp);
            len = 0;

            free(tmp);

            tmp = (char *)malloc(sizeof(char) * 1);
            CHECK_MEM(tmp);
            memset(tmp, '\0', 1);

            if (wordlen_check(word))
            {
                hashtable_mlist_add(hashtable, filename, word);
            }
        }
        c = *(++wordslist);
    }

    free(word);
    free(tmp);
}

HASHTABLE_MLIST *trovefile_load(void)
{
    HASHTABLE_MLIST *hashtable_mlist = hashtable_mlist_new();
    trovefile_open();

    while (!feof(TROVE_FILE_P))
    {
        char *filename = getLine(TROVE_FILE_P);
        char *md5 = getLine(TROVE_FILE_P);
        char *wordslist = getLine(TROVE_FILE_P);
        if (access(filename, R_OK) || !md5check(md5, filename))
        {
            continue;
        }
        load_from_troveFile(filename, wordslist, hashtable_mlist);
    }
    fclose(TROVE_FILE_P);
    return hashtable_mlist;
}

/* THE FOLLOWING 4 FUNCTIONS ARE USED TO READ FROM THE HASHTABLE
 *  YOU MAY FIND THEM FAMILIAR AND THAT IS BECAUSE
 *  THEY ARE JUST A DIFFERENT VERSION OF XXX_print FUNCTIONS
 *  FROM list.c, mlist.c, hastable_list.c, hashtable_mlist.c
 */

// READ THE LIST
char *list_read(LIST *list)
{
    char *str = strdup("");
    char *space = " ";

    if (list != NULL)
    {
        while (list->next != NULL)
        {
            if (list->word != NULL)
            {
                str = (char *)realloc(str, sizeof(char) * (strlen(str) + strlen(list->word) + 2));
                strcat(str, space);
                strcat(str, list->word);
            }
            list = list->next;
        }
        if (list->next == NULL)
        {
            if (list->word != NULL)
            {
                str = (char *)realloc(str, sizeof(char) * (strlen(str) + strlen(list->word) + 1));
                strcat(str, space);
                strcat(str, list->word);
            }
        }
    }
    return str;
}

// READ THE HASHTABLE
char *hashtable_list_read(HASHTABLE_LIST *hashtable)
{
    char *str = strdup("");
    char *str_list;

    for (uint16_t i = 0; i < HASHTABLE_LIST_SIZE; i++)
    {
        LIST *list = hashtable[i];
        if (list != NULL)
        {
            str_list = list_read(list);
        }
        str = (char *)realloc(str, sizeof(char) * (strlen(str) + strlen(str_list) + 1));
        strcat(str, str_list);
    }
    return str;
}

// READ the MLIST
char *mlist_read(MLIST *mlist)
{
    char *str = strdup("");
    char *str_hashtable_list;
    char *str_filename;
    char *md5;
    char *linespace = "\n";

    if (mlist != NULL)
    {
        while (mlist->next != NULL)
        {
            if (mlist->filename != NULL)
            {
                str_filename = strdup(mlist->filename);
                str = (char *)realloc(str, sizeof(char) * (strlen(str) + strlen(mlist->filename) + 2));
                strcat(str, str_filename);
                strcat(str, linespace);

                md5 = strdup(mlist->md5);
                str = (char *)realloc(str, sizeof(char) * (strlen(str) + strlen(mlist->md5) + 2));
                strcat(str, md5);
                strcat(str, linespace);

                str_hashtable_list = hashtable_list_read(mlist->words);
                str = (char *)realloc(str, sizeof(char) * (strlen(str) + strlen(str_hashtable_list) + 2));
                strcat(str, str_hashtable_list);
                strcat(str, linespace);
            }
            mlist = mlist->next;
        }
        if (mlist->next == NULL && mlist->filename != NULL)
        {
            str_filename = strdup(mlist->filename);
            str = (char *)realloc(str, sizeof(char) * (strlen(str) + strlen(mlist->filename) + 2));
            strcat(str, str_filename);
            strcat(str, linespace);

            md5 = strdup(mlist->md5);
            str = (char *)realloc(str, sizeof(char) * (strlen(str) + strlen(mlist->md5) + 2));
            strcat(str, md5);
            strcat(str, linespace);

            str_hashtable_list = hashtable_list_read(mlist->words);
            str = (char *)realloc(str, sizeof(char) * (strlen(str) + strlen(str_hashtable_list) + 2));
            strcat(str, str_hashtable_list);
            strcat(str, linespace);
        }
    }
    return str;
}

//  READ the hashtable
char *hashtable_mlist_read(HASHTABLE_MLIST *hashtable)
{
    char *str = strdup("");
    char *str_mlist;

    for (uint16_t i = 0; i < HASHTABLE_MLIST_SIZE; i++)
    {
        while (hashtable[i] != NULL)
        {
            str_mlist = mlist_read(hashtable[i]);
            str = (char *)realloc(str, sizeof(char) * (strlen(str) + strlen(str_mlist) + 1));
            strcat(str, str_mlist);
            hashtable[i] = hashtable[i]->next;
        }
    }
    return str;
}

// REMOVE THE OLD DATA AND REPLACE IT WITH THE NEW ONE
void trovefile_write(HASHTABLE_MLIST *hashtable)
{
    TROVE_FILE_P = fopen(TROVE_FILE, "w+");
    fseek(TROVE_FILE_P, 0, SEEK_SET);

    char *str = hashtable_mlist_read(hashtable);
    fprintf(TROVE_FILE_P, "%s", str);

    hashtable_mlist_free(hashtable);
    trovefile_gz_close();
}

// UPDATE THE OLD HASHTABLE WHICH HAVING THE SAME FILE NAME AS IN NEW WHILE KEEPING THE OTHER DATA
void trovefile_update(HASHTABLE_MLIST *hashtable)
{
    HASHTABLE_MLIST *old_hashtable = trovefile_load();
    hashtable_mlist_update(old_hashtable, hashtable);
    trovefile_write(old_hashtable);
}

// PRINT EVERYTHING IN THE TROVE FILE
void trovefile_print(void)
{
    HASHTABLE_MLIST *hashtable = trovefile_load();
    hashtable_mlist_print(hashtable);
    hashtable_mlist_free(hashtable);
    printf("\n");
}

// PRINT ALL THE FILENAME IN THE TROVE FILE
void trovefile_filename_print(void)
{
    HASHTABLE_MLIST *hashtable = trovefile_load();
    hashtable_mlist_filename_print(hashtable);
    hashtable_mlist_free(hashtable);
    printf("\n");
}Project2/v1.0/src/wordFileIO.c000075500000000000000000000054341432373542500117200/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#include "../inc/wordFileIO.h"

// RECORD ALL THE WORDS FROM FILE INTO THE HASHTABLE
void recordWord_file(char *filename, HASHTABLE_MLIST *hashtable)
{
    filename = getRealPath(filename);
    printf("\t%s\n", filename);
    FILE *fp = openfile(filename);

    char *word = (char *)malloc(sizeof(char) * 1);
    CHECK_MEM(word);
    memset(word, '\0', 1);

    char *tmp = (char *)malloc(sizeof(char) * 1);
    CHECK_MEM(tmp);
    memset(tmp, '\0', 1);

    uint32_t len = 0;

    char c = fgetc(fp);
    while (!feof(fp))
    {
        if (isalnum(c))
        {
            tmp = realloc(tmp, sizeof(char) * (len + 2));
            tmp[len] = c;
            len++;
        }
        else
        {
            tmp[len] = '\0';
            word = strdup(tmp);
            len = 0;

            free(tmp);

            tmp = (char *)malloc(sizeof(char) * 1);
            CHECK_MEM(tmp);
            memset(tmp, '\0', 1);

            if (wordlen_check(word))
            {
                hashtable_mlist_add(hashtable, filename, word);
            }
        }
        c = fgetc(fp);
    }

    fclose(fp);
    free(word);
    free(tmp);
}

// TRAVESE THE DIRECTORY AND RECORD ALL THE FILES USE recordWord_file
void recordWord_dir(char *filename, HASHTABLE_MLIST *hashtable)
{
    DIR *dir;
    struct dirent *ptr;
    char path[PATH_MAX];

    printf("\tOpening Directory:\t%s\n", filename);
    dir = opendir(filename);

    if (dir == NULL)
    {
        perror("OPEN DIR ERROR");
        exit(EXIT_FAILURE);
    }

    while ((ptr = readdir(dir)) != NULL)
    {
        if (!strcmp(ptr->d_name, ".") || !strcmp(ptr->d_name, ".."))
        {
            continue;
        }
        else if (ptr->d_type == 8)
        {
            strcpy(path, filename);
            strcat(path, "/");
            strcat(path, ptr->d_name);
            recordWord_file(path, hashtable);
        }
        else if (ptr->d_type == 10)
        {
            continue;
        }
        else if (ptr->d_type == 4)
        {
            strcpy(path, filename);
            strcat(path, "/");
            strcat(path, ptr->d_name);
            printf("\n");

            recordWord_dir(path, hashtable);
        }
    }
    closedir(dir);
}

// THE OVERALL FUNTION FOR RECORDING
void recordWord(char *filename, HASHTABLE_MLIST *hashtable)
{
    struct stat statbuf;
    if (stat(filename, &statbuf))
    {
        perror("stat");
        exit(EXIT_FAILURE);
    }
    else if (S_ISDIR(statbuf.st_mode))
    {
        recordWord_dir(filename, hashtable);
    }
    else if (S_ISREG(statbuf.st_mode))
    {
        recordWord_file(filename, hashtable);
    }
}Project2/v2.0/inc/hashtable_list.h000075500000000000000000000026211432373607700126720/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#ifndef _HASHTABLE_LIST_H
#define _HASHTABLE_LIST_H

#include "list.h"

/* The following include does nothing,
 *  These header files are included here just to show
 *  some of the functions/datatype are using
 *  are declared in the corresponding header file
 *  Because there is protection setted in every header file,
 *  it is safe to include them multiple times
 *  without causing muitiple inclusion error
 *  it is fine to remove them if you want
 */

#include "tools.h"

#define HASHTABLE_LIST_SIZE 2999

// WE DEFINE A HASHTABLE AS A (WILL BE, DYNAMICALLY ALLOCATED) ARRAY OF LISTs
typedef LIST *HASHTABLE_LIST;

// ALLOCATE SPACE AND INITIALISE A NEW HASHTABLE_LIST
extern HASHTABLE_LIST *hashtable_list_new(void);

// ADD NEW STRING TO A GIVEN HASHTABLE_LIST
extern void hashtable_list_add(HASHTABLE_LIST *hashtable, char *string);

// CHECK IF A REQUIRED STRING ALREADY EXISTS IN THE GIVEN HASHTABLE_LIST
extern bool hashtable_list_find(HASHTABLE_LIST *hashtable, char *string);

// PRINT THE HASHTABLE_LIST
extern void hashtable_list_print(HASHTABLE_LIST *hashtable);

// REMOVE A STRING FROM THE HASHTABLE_LIST
extern void hashtable_list_remove(HASHTABLE_LIST *hashtable, char *string);

// FREE THE HASHTABLE_LIST
extern void hashtable_list_free(HASHTABLE_LIST *hashtable);

#endifProject2/v2.0/inc/hashtable_mlist.h000075500000000000000000000037721432371434000130440/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#ifndef _HASHTABLE_MLIST_H
#define _HASHTABLE_MLIST_H

#include "mlist.h"

/* The following include does nothing,
 *  These header files are included here just to show
 *  some of the functions/datatype are using
 *  are declared in the corresponding header file
 *  Because there is protection setted in every header file,
 *  it is safe to include them multiple times
 *  without causing muitiple inclusion error
 *  it is fine to remove them if you want
 */

#include "tools.h"
#include "list.h"
#include "hashtable_list.h"

#define HASHTABLE_MLIST_SIZE 4999

typedef MLIST *HASHTABLE_MLIST;

// ALLOCATE SPACE AND INITIALISE A NEW HASHTABLE_MLIST
extern HASHTABLE_MLIST *hashtable_mlist_new(void);

// ADD NEW FILENAME TO THE HASHTABLE_MLIST
extern void hashtable_mlist_add(HASHTABLE_MLIST *hashtable, char *filename, char *word);

// RETURN THE A LIST CONTIANING ALL THE FILENAMES IN HASHTABLE_MLIST
extern LIST *hashtable_mlist_filename(HASHTABLE_MLIST *hashtable);

//  PRINT ALL OF FILENAMES IN THE HASHTABLE_MLIST
extern void hashtable_mlist_filename_print(HASHTABLE_MLIST *hashtable);

// RETURN THE KEYWORD LIST OF THE GIVEN FILENAME
extern HASHTABLE_LIST *hashtable_mlist_filename_list(HASHTABLE_MLIST *hashtable, char *filename);

// PRINT FILENAMES HAVING THE KEYWORD UNDER THEIR WORD LIST
extern void hashtable_mlist_files_have_word_print(HASHTABLE_MLIST *hashtable, char *keyword);

// UPDATE HASHTABLE1 USING HASHTABLE2
extern void hashtable_mlist_update(HASHTABLE_MLIST *hashtable1, HASHTABLE_MLIST *hashtable2);

//  REMOVE A MLIST HAVING GIVEN FILENAME FROM THE HASHTABLE_MLIST
extern void hashtable_mlist_remove(HASHTABLE_MLIST *, char *filename);

//  PRINT EVERYTHING IN HASHTABLE_MLIST
extern void hashtable_mlist_print(HASHTABLE_MLIST *hashtable);

//  FREE THE SPACE ALLOCATED FOR A GIVEN HASHTABLE_MLIST
extern void hashtable_mlist_free(HASHTABLE_MLIST *hashtable);

#endifProject2/v2.0/inc/list.h000075500000000000000000000016021432371434400106460/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#ifndef _LIST_H
#define _LIST_H

#include "tools.h"

// IMPLITATION OF LIST
typedef struct list
{
    char *word;
    struct list *next;
} LIST;

// MAKE A NFW BLANK LIST ITEM
extern LIST *list_new(void);

// DETERMINE IF THE TARGET IS STORED IN A GIVEN LIST
extern bool list_find(LIST *list, char *target);

// ADD NEW CHAIN TO THE LIST, DO NOTHING IF THE CHAIN IS ALREADY IN THE LIST
extern LIST *list_add(LIST *list, char *word);

// REMOVE CHAIN FROM THE LIST, DO NOTHING IF THE CHAIN IS NOT IN THE LIST
extern void list_remove(LIST *list, char *target);

// PRINT THE LIST
extern void list_print(LIST *list);

// SPECIAL list_print (ONLY USED FOR TESTING)
extern void list_file_print(LIST *list);

// FREE THE MEMORY OF THE LIST
extern void list_free(LIST *list);

#endifProject2/v2.0/inc/mlist.h000075500000000000000000000023441432373612000110230/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#ifndef _MLIST_H
#define _MLIST_H

#include "hashtable_list.h"

// A MOTHER LIST HAS TWO LINKS, ONE FOR A SIMPLE LIST, ONE FOR THE NEXT MOTHER LIST
typedef struct mlist
{
    char *filename;
    char *md5;
    HASHTABLE_LIST *words;
    struct mlist *next;
} MLIST;

// MAKE A BLANK MLIST ITEM
extern MLIST *mlist_new(void);

// DETERMINE IF THE TARGET FILENAME IS STORED IN A GIVEN MLIST
extern bool mlist_find(MLIST *mlist, char *target);

// ADD NEW FILENAME TO THE MLIST, DO NOTHING IF THE FILENAME IS ALREADY IN THE MLIST
extern MLIST *mlist_add(MLIST *mlist, char *filename);

// REPLACE THE CHAIN IN MLIST1 WITH THE SAME FILENAME IN MLIST2, INSERT A NEW CHAIN IF THE FILENAME IN MLIST2 IS NOT IN MLIST1
extern void mlist_update(MLIST *mlist1, MLIST *mlist2);

// REMOVE FILENAME FROM THE MLIST, DO NOTHING IF THE FILENAME IS NOT IN THE MLIST
extern void mlist_remove(MLIST *mlist, char *target);

// Print the MLIST
extern void mlist_print(MLIST *mlist);

// PRINT THE FILE NAME IN THE MLIST
extern void mlist_filename_print(MLIST *mlist);

// FREE THE MEMORY OF THE MLIST
extern void mlist_free(MLIST *mlist);

#endifProject2/v2.0/inc/tools.h000075500000000000000000000033701432371435600110420/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

// open up all features including POSIX_C_SOURCE
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif

#ifndef _TOOLS_H
#define _TOOLS_H

#include <ctype.h>
#include <dirent.h>
#include <limits.h>
#include <pthread.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>

extern uint32_t wordlen;
extern uint32_t ARG_MAX;

// CHECK IF THE MEMORY ALLOCATION WAS SUCCESSFUL
#ifndef CHECK_MEM
#define CHECK_MEM(p)        \
    if (p == NULL)          \
    {                       \
        perror(__func__);   \
        exit(EXIT_FAILURE); \
    }
#endif

// DJBHASH FUNCTION FOR HASHING STRING
extern uint16_t DJBHash(char *string);

// CHECK IF THE STRING IS A WORD
extern bool isString(char *string);

// CHANGE THE KEYLEN
extern void change_wordlen(uint32_t len);

// CHECK IF THE WORD LEN IS GREATER THAN KEYLEN
extern bool wordlen_check(char *word);

// IF THE FILE IS EXIST RETURN THE FILE POINTER OTHERWISE POP UP ERROR MESSAGE
extern FILE *openfile(char *filename);

// GET THE REAL PATH OF THE FILE
extern char *getRealPath(char *filename);

// GET ONE LINE FROM THE FILE
extern char *getLine(FILE *file);

// CHECK IF THE GIVEN STRING IS A INTERGER
extern bool isInt(char *str);

// CHECK IF THE GIVEN NAME IS A FILE
extern bool isFile(char *name);

// CHECK IF THE GIVEN NAME IS DIRECTORY
extern bool isDirectory(char *name);

// CALCULATE MD5 HASH OF THE GIVEN FILE
extern char *md5sum(char *filename);

// CHECK IF THE STORED MD5 HASH IS THE SAME AS THE MD5 HASH OF THE FILE
extern bool md5check(char *md5, char *filename);

#endifProject2/v2.0/inc/trove.h000075500000000000000000000011731432373620400110340/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#ifndef _TROVE_H
#define _TROVE_H

#include "trovefileIO.h"

/* The following include does nothing,
 *  These header files are included here just to show
 *  some of the functions/datatype are using
 *  are declared in the corresponding header file
 *  Because there is protection setted in every header file,
 *  it is safe to include them multiple times
 *  without causing muitiple inclusion error
 *  it is fine to remove them if you want
 */

#include "wordFileIO.h"
#include "tools.h"
#include "hashtable_mlist.h"

#endifProject2/v2.0/inc/trovefileIO.h000075500000000000000000000026401432373614200121250/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#ifndef _TROVEFILEIO_H
#define _TROVEFILEIO_H

#include "wordFileIO.h"

/* The following include does nothing,
 *  These header files are included here just to show
 *  some of the functions/datatype are using
 *  are declared in the corresponding header file
 *  Because there is protection setted in every header file,
 *  it is safe to include them multiple times
 *  without causing muitiple inclusion error
 *  it is fine to remove them if you want
 */

#include "tools.h"
#include "list.h"
#include "hashtable_list.h"
#include "mlist.h"
#include "hashtable_mlist.h"

extern char *TROVE_FILE;
extern FILE *TROVE_FILE_P;

// CHANGE THE TROVE FILE NAME
extern void change_trove_file(char *filename);

// READ THE TROVE FILE AND LOAD THE HASHTABLE FROM IT
extern HASHTABLE_MLIST *trovefile_load(void);

// REPLACE THE TROVE FILE WITH THE NEW ONE, REMOVE THE OLD ONE AND REPLACE IT WITH THE NEW ONE
extern void trovefile_write(HASHTABLE_MLIST *hashtable);

// UPDATE THE HASHTABLE TO THE TROVE FILE, OVERWRITING THE OLD DATA HAVE SAME FILE NAME WHILE KEEPING THE OTHER DATA
extern void trovefile_update(HASHTABLE_MLIST *hashtbale);

// PRINT ALL THE FILENAME IN THE TROVE FILE
extern void trovefile_print(void);

// PRINT ALL THE FILENAME IN THE TROVE FILE
extern void trovefile_filename_print(void);

#endifProject2/v2.0/inc/wordFileIO.h000075500000000000000000000015601432373622100116770/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#ifndef _WORDFILEIO_H
#define _WORDFILEIO_H

#include "hashtable_mlist.h"

/* The following include does nothing,
 *  These header files are included here just to show
 *  some of the functions/datatype are using
 *  are declared in the corresponding header file
 *  Because there is protection setted in every header file,
 *  it is safe to include them multiple times
 *  without causing muitiple inclusion error
 *  it is fine to remove them if you want
 */

#include "tools.h"
#include "hashtable_mlist.h"

// RECORD ALL THE WORDS FROM FILE INTO THE HASHTABLE
extern void recordWord(char *filename, HASHTABLE_MLIST *hashtable);

// RECORD ALL THE WORDS FROM FILE INTO THE HASHTABLE
extern void recordWord_MULTI(char *filename, HASHTABLE_MLIST *hashtable);

#endifProject2/v2.0/src/hashtable_list.c000075500000000000000000000036721432373635700127130/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#include "../inc/hashtable_list.h"

// ALLOCATE SPACE AND INITIALISE A NEW HASHTABLE_LIST
HASHTABLE_LIST *hashtable_list_new(void)
{
    HASHTABLE_LIST *new = (HASHTABLE_LIST *)calloc(HASHTABLE_LIST_SIZE, sizeof(LIST *));
    CHECK_MEM(new);

    for (uint16_t i = 0; i < HASHTABLE_LIST_SIZE; i++)
    {
        new[i] = list_new();
    }
    return new;
}

// ADD A NEW STRING TO A GIVEN HASHTABLE_LIST
void hashtable_list_add(HASHTABLE_LIST *hashtable, char *string)
{
    uint16_t hash = DJBHash(string) % HASHTABLE_LIST_SIZE;

    hashtable[hash] = list_add(hashtable[hash], string);
}

// CHECK IF A REQUIRED STRING ALREADY EXISTS IN THE GIVEN HASHTABLE_LIST
bool hashtable_list_find(HASHTABLE_LIST *hashtable, char *string)
{
    uint16_t hash = DJBHash(string) % HASHTABLE_LIST_SIZE;

    return list_find(hashtable[hash], string);
}

// PRINT THE HASHTABLE_LIST
void hashtable_list_print(HASHTABLE_LIST *hashtable)
{
    for (uint16_t i = 0; i < HASHTABLE_LIST_SIZE; i++)
    {
        LIST *list = hashtable[i];
        if (list != NULL)
        {
            list_print(list);
        }
    }
    printf("\n");
}

// REMOVE A STRING FROM THE HASHTABLE_LIST
extern void hashtable_list_remove(HASHTABLE_LIST *hashtable, char *string)
{
    uint16_t hash = DJBHash(string) % HASHTABLE_LIST_SIZE;
    list_remove(hashtable[hash], string);
    if (hashtable[hash]->next == NULL && hashtable[hash]->word != NULL && string != NULL)
    {
        if (!strcmp(hashtable[hash]->word, string))
        {
            hashtable[hash] = list_new();
        }
    }
}

// FREE THE HASHTABLE_LIST
void hashtable_list_free(HASHTABLE_LIST *hashtable)
{
    for (uint16_t i = 0; i < HASHTABLE_LIST_SIZE; i++)
    {
        list_free(hashtable[i]);
        hashtable[i] = NULL;
    }
    free(hashtable);
    hashtable = NULL;
}
Project2/v2.0/src/hashtable_mlist.c000075500000000000000000000115131432373636600130610/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#include "../inc/hashtable_mlist.h"

// ALLOCATE SPACE AND INITIALISE A NEW HASHTABLE_MLIST
HASHTABLE_MLIST *hashtable_mlist_new(void)
{
    HASHTABLE_MLIST *new = (HASHTABLE_MLIST *)calloc(HASHTABLE_MLIST_SIZE, sizeof(MLIST *));
    CHECK_MEM(new);

    for (uint16_t i = 0; i < HASHTABLE_MLIST_SIZE; i++)
    {
        new[i] = mlist_new();
    }
    return new;
}

// ADD NEW FILENAME TO THE HASHTABLE_MLISTT
void hashtable_mlist_add(HASHTABLE_MLIST *hashtable, char *filename, char *word)
{
    uint16_t hash = DJBHash(filename) % HASHTABLE_MLIST_SIZE;

    hashtable[hash] = mlist_add(hashtable[hash], filename);
    if (hashtable[hash]->words == NULL)
    {
        hashtable[hash]->words = hashtable_list_new();
    }
    hashtable_list_add(hashtable[hash]->words, word);
}

// RETURN THE A LIST CONTIANING ALL THE FILENAMES IN HASHTABLE_MLIST
LIST *hashtable_mlist_filename(HASHTABLE_MLIST *hashtable)
{
    LIST *list = list_new();
    for (uint16_t i = 0; i < HASHTABLE_MLIST_SIZE; i++)
    {
        MLIST *mlist = hashtable[i];
        while (mlist != NULL && mlist->filename != NULL)
        {
            list = list_add(list, mlist->filename);
            mlist = mlist->next;
        }
    }
    return list;
}

//  PRINT ALL OF FILENAMES IN THE HASHTABLE_MLIST
void hashtable_mlist_filename_print(HASHTABLE_MLIST *hashtable)
{
    for (uint16_t i = 0; i < HASHTABLE_MLIST_SIZE; i++)
    {
        MLIST *mlist = hashtable[i];
        mlist_filename_print(mlist);
    }
}

// CHECK IF THE FILENAME ALREADY EXISTS IN A GIVEN HASHTABLE_MLIST
bool hashtable_mlist_find(HASHTABLE_MLIST *hashtable, char *filename)
{
    uint16_t hash = DJBHash(filename) % HASHTABLE_MLIST_SIZE;

    return mlist_find(hashtable[hash], filename);
}

// RETURN THE KEYWORD LIST OF THE GIVEN FILENAME
HASHTABLE_LIST *hashtable_mlist_filename_list(HASHTABLE_MLIST *hashtable, char *filename)
{
    uint16_t hash = DJBHash(filename) % HASHTABLE_MLIST_SIZE;

    MLIST *mlist = hashtable[hash];
    if (mlist_find(mlist, filename))
    {
        while (mlist != NULL && mlist->filename != NULL && filename != NULL)
        {
            if (!strcmp(mlist->filename, filename))
            {
                return mlist->words;
            }
            mlist = mlist->next;
        }
    }
    return mlist_add(hashtable[hash], filename)->words;
}

// RETURN THE LIST OF FILENAME HAVING THE KEYWORD UNDER THEIR HASHTABLE_LIST
LIST *hashtable_mlist_files_have_word(HASHTABLE_MLIST *hashtable, char *keyword)
{
    LIST *list = list_new();
    for (uint16_t i = 0; i < HASHTABLE_MLIST_SIZE; i++)
    {
        MLIST *mlist = hashtable[i];
        while (mlist != NULL)
        {
            if (hashtable_list_find(mlist->words, keyword))
            {
                list = list_add(list, mlist->filename);
            }
            mlist = mlist->next;
        }
    }
    return list;
}

// PRINT FILENAMES HAVING THE KEYWORD UNDER THEIR WORD LIST
void hashtable_mlist_files_have_word_print(HASHTABLE_MLIST *hashtable, char *keyword)
{
    LIST *list = hashtable_mlist_files_have_word(hashtable, keyword);
    if (list == NULL || list->word == NULL)
    {
        exit(EXIT_FAILURE);
    }
    list_file_print(list);
    list_free(list);
    printf("\n");
}

// UPDATE HASHTABLE1 USING HASHTABLE2
void hashtable_mlist_update(HASHTABLE_MLIST *hashtable1, HASHTABLE_MLIST *hashtable2)
{
    for (uint16_t i = 0; i < HASHTABLE_MLIST_SIZE; i++)
    {
        MLIST *mlist1 = hashtable1[i];
        MLIST *mlist2 = hashtable2[i];
        mlist_update(mlist1, mlist2);
    }
}

//  REMOVE A MLIST HAVING GIVEN FILENAME FROM THE HASHTABLE_MLIST
void hashtable_mlist_remove(HASHTABLE_MLIST *hashtable, char *filename)
{
    filename = getRealPath(filename);
    printf("\t%s\n", filename);
    uint16_t hash = DJBHash(filename) % HASHTABLE_MLIST_SIZE;

    mlist_remove(hashtable[hash], filename);
    if (hashtable[hash]->next == NULL && hashtable[hash]->filename != NULL && filename != NULL)
    {
        if (!strcmp(hashtable[hash]->filename, filename))
        {
            hashtable[hash] = mlist_new();
        }
    }

    free(filename);
}

//  PRINT EVERYTHING IN HASHTABLE_MLIST
void hashtable_mlist_print(HASHTABLE_MLIST *hashtable)
{
    for (uint16_t i = 0; i < HASHTABLE_MLIST_SIZE; i++)
    {
        if (hashtable[i] != NULL)
        {
            mlist_print(hashtable[i]);
        }
    }
}

//  FREE THE SPACE ALLOCATED FOR A GIVEN HASHTABLE_MLIST
void hashtable_mlist_free(HASHTABLE_MLIST *hashtable)
{
    for (uint16_t i = 0; i < HASHTABLE_MLIST_SIZE; i++)
    {
        mlist_free(hashtable[i]);
        hashtable[i] = NULL;
    }
    free(hashtable);
    hashtable = NULL;
}Project2/v2.0/src/list.c000075500000000000000000000044611432373637100106710/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#include "../inc/list.h"

// MAKE A NFW BLANK LIST ITEM
LIST *list_new(void)
{
    LIST *new = (LIST *)calloc(1, sizeof(LIST *));
    CHECK_MEM(new);

    new->word = NULL;
    new->next = NULL;

    return new;
}

// DETERMINE IF THE TARGET IS STORED IN A GIVEN LIST
bool list_find(LIST *list, char *target)
{
    while (target != NULL && list != NULL)
    {
        if (list->word != NULL && !strcmp(list->word, target))
        {
            return true;
        }
        list = list->next;
    }
    return false;
}

//  ALLOCATE SPACE FOR A NEW LIST ITEM AND CHECK IF ALLOCATION SUCCEEDS
LIST *list_new_item(char *word)
{
    LIST *newList = (LIST *)calloc(1, sizeof(LIST));
    CHECK_MEM(newList);

    newList->word = strdup(word);
    newList->next = list_new();

    return newList;
}

// ADD NEW CHAIN TO THE LIST, DO NOTHING IF THE CHAIN IS ALREADY IN THE LIST
LIST *list_add(LIST *list, char *word)
{
    LIST *tmp = list;
    if (list_find(list, word))
    {
        return tmp;
    }
    else
    {
        LIST *newList = list_new_item(word);
        newList->next = tmp;
        return newList;
    }
}

// REMOVE CHAIN FROM THE LIST, DO NOTHING IF THE CHAIN IS NOT IN THE LIST
void list_remove(LIST *list, char *target)
{
    while (target != NULL && list != NULL)
    {
        if (!strcmp(list->word, target))
        {
            LIST *tmp = list->next;
            list->next = list->next->next;
            free(tmp);
            break;
        }
        list = list->next;
    }
}

// PRINT THE LIST
void list_print(LIST *list)
{
    while (list != NULL)
    {
        if (list->word != NULL)
        {
            printf("\t%s,", list->word);
        }
        list = list->next;
    }
}

// SPECIAL list_print
void list_file_print(LIST *list)
{
    while (list != NULL)
    {
        if (list->word != NULL)
        {
            printf("%s\n", list->word);
        }
        list = list->next;
    }
}

// FREE THE MEMORY OF THE LIST
void list_free(LIST *list)
{
    while (list != NULL)
    {
        LIST *tmp = list;
        list = list->next;
        free(tmp);
        tmp = NULL;
    }
    free(list);
    list = NULL;
}Project2/v2.0/src/mlist.c000075500000000000000000000077771432373637200110640/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#include "../inc/mlist.h"

// MAKE A BLANK MLIST ITEM
MLIST *mlist_new(void)
{
    MLIST *mlist = (MLIST *)calloc(1, sizeof(MLIST));
    CHECK_MEM(mlist);

    mlist->filename = NULL;
    mlist->md5 = NULL;
    mlist->words = hashtable_list_new();
    mlist->next = NULL;

    return mlist;
}

//  DETERMINE IF THE TARGET FILENAME IS STORED IN A GIVEN MLIST
bool mlist_find(MLIST *mlist, char *target)
{
    while (mlist != NULL && mlist->filename != NULL && target != NULL)
    {
        if (!strcmp(mlist->filename, target))
        {
            return true;
        }
        mlist = mlist->next;
    }
    return false;
}

//  ALLOCATE SPACE FOR A NEW MLIST ITEM AND CHECK IF ALLOCATION SUCCEEDS
MLIST *mlist_new_item(char *filename)
{
    MLIST *newMList = (MLIST *)calloc(1, sizeof(MLIST));
    CHECK_MEM(newMList);

    newMList->filename = strdup(filename);
    newMList->md5 = strdup(md5sum(filename));
    newMList->words = hashtable_list_new();
    newMList->next = mlist_new();

    return newMList;
}

// ADD NEW FILENAME TO THE MLIST, REPLACE IT IF THE FILENAME IS ALREADY IN THE MLIST
MLIST *mlist_add(MLIST *mlist, char *filename)
{
    if (mlist_find(mlist, filename))
    {
        return mlist;
    }
    else
    {
        MLIST *newMList = mlist_new_item(filename);
        newMList->next = mlist;
        return newMList;
    }
}

// REPLACE THE CHAIN IN MLIST1 WITH THE SAME FILENAME IN MLIST2, INSERT A NEW CHAIN IF THE FILENAME IN MLIST2 IS NOT IN MLIST1
void mlist_update(MLIST *mlist1, MLIST *mlist2)
{
    MLIST *tmp = mlist1;
    while (mlist1 != NULL && mlist1->filename != NULL)
    {
        while (mlist2 != NULL && mlist2->filename != NULL)
        {
            if (!strcmp(mlist2->filename, mlist1->filename))
            {
                mlist1->words = mlist2->words;
                mlist_remove(mlist2, mlist1->filename);
            }
            mlist2 = mlist2->next;
        }
        mlist1 = mlist1->next;
    }
    mlist1->next = mlist2;
    mlist1 = tmp;
}

// REMOVE CHAIN FROM THE MLIST, DO NOTHING IF THE FILENAME IS NOT IN THE MLIST
void mlist_remove(MLIST *mlist, char *target)
{
    while (mlist->next != NULL && mlist->filename != NULL && target != NULL)
    {
        if (!strcmp(mlist->filename, target))
        {
            MLIST *tmp = mlist->next;
            mlist->next = mlist->next->next;
            free(tmp);
            break;
        }
        mlist = mlist->next;
    }
}

// Print the MLIST
void mlist_print(MLIST *mlist)
{
    if (mlist != NULL)
    {
        while (mlist->next != NULL)
        {
            if (mlist->filename != NULL)
            {
                printf("\t%s:\n", mlist->filename);
                printf("\tMD5: %s\n", mlist->md5);
                hashtable_list_print(mlist->words);
                printf("\n");
            }
            mlist = mlist->next;
        }
        if (mlist->next == NULL && mlist->filename != NULL)
        {
            printf("\t%s:\n", mlist->filename);
            hashtable_list_print(mlist->words);
            printf("\n");
        }
    }
}

// PRINT THE FILE NAME IN THE MLIST
void mlist_filename_print(MLIST *mlist)
{
    if (mlist != NULL)
    {
        while (mlist->next != NULL)
        {
            if (mlist->filename != NULL)
            {
                printf("\t%s\n", mlist->filename);
            }
            mlist = mlist->next;
        }
        if (mlist->next == NULL && mlist->filename != NULL)
        {
            printf("\t%s\n", mlist->filename);
        }
    }
}

// FREE THE MLIST
void mlist_free(MLIST *mlist)
{
    while (mlist != NULL)
    {
        MLIST *tmp = mlist;
        free(tmp->filename);
        free(tmp->md5);
        hashtable_list_free(mlist->words);
        mlist = mlist->next;
        free(tmp);
        tmp = NULL;
    }
    free(mlist);
    mlist = NULL;
}Project2/v2.0/src/tools.c000075500000000000000000000071611432373637500110620/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#include "../inc/tools.h"

uint32_t ARG_MAX = 2097152;
uint32_t wordlen = 4;

// DJBHASH FUNCTION FOR HASHING STRING
uint16_t DJBHash(char *string)
{
    uint16_t hash = 5381;
    char c = *string;

    while (c != '\0')
    {
        hash = hash * 33 + c;
        c = *++string;
    }
    return hash;
}

// CHECK IF THE STRING IS A WORD
bool isString(char *string)
{
    char c = *string;
    while (c != '\0')
    {
        if (!isalnum(c))
        {
            return false;
        }
        c = *++string;
    }
    return true;
}

// CHANGE THE WORDLEN
void change_wordlen(uint32_t len)
{
    wordlen = len;
}

// CHECK IF THE WORD LEN IS GREATER THAN KEYLEN
bool wordlen_check(char *word)
{
    char *tmp = word;
    uint32_t len = strlen(tmp);
    if (len >= wordlen)
    {
        return true;
    }
    return false;
}

// IF THE FILE IS EXIST RETURN THE FILE POINTER OTHERWISE POP UP ERROR MESSAGE
FILE *openfile(char *filename)
{
    FILE *file = fopen(filename, "r+");
    if (file == NULL)
    {
        printf("File %s does not exist\n", filename);
        perror("fopen");
        exit(EXIT_FAILURE);
    }
    return file;
}

// GET THE REAL PATH OF THE FILE
char *getRealPath(char *filename)
{
    char *fileRealPath = (char *)calloc(PATH_MAX, sizeof(char));
    CHECK_MEM(fileRealPath);

    realpath(filename, fileRealPath);
    return fileRealPath;
}

// GET ONE LINE FROM THE FILE
char *getLine(FILE *file)
{
    char *line = (char *)calloc(1000, sizeof(char));
    CHECK_MEM(line);

    char c = fgetc(file);
    uint64_t len = 0;

    while (!feof(file))
    {
        if (c != '\n')
        {
            line[len] = c;
            len++;
            if (len > 999)
            {
                line = (char *)realloc(line, sizeof(char) * (len + 2));
            }
        }
        else
        {
            line[len] = '\0';
            break;
        }
        c = fgetc(file);
    }
    return line;
}

// A FUNCTION CHANGE THE GIVEN INT TO STRING
char *itoa(uint16_t num)
{
    char *str = (char *)calloc(20, sizeof(char));
    CHECK_MEM(str);

    sprintf(str, "%d", num);
    return str;
}

// CHECK IF THE GIVEN STRING IS A INTERGER
bool isInt(char *str)
{
    if (!strcmp(itoa(atoi(str)), str))
    {
        return true;
    }
    return false;
}

// CHECK IF THE GIVEN NAME IS A FILE
bool isFile(char *name)
{
    struct stat statbuf;
    if (stat(name, &statbuf))
    {
        return false;
    }
    return S_ISREG(statbuf.st_mode);
}

// CHECK IF THE GIVEN NAME IS DIRECTORY
bool isDirectory(char *name)
{
    struct stat statbuf;
    if (stat(name, &statbuf))
    {
        return false;
    }
    return S_ISDIR(statbuf.st_mode);
}

// CALCULATE MD5 HASH OF THE GIVEN FILE
char *md5sum(char *filename)
{
    char *md5 = (char *)calloc(33, sizeof(char));
    CHECK_MEM(md5);
    char *cmd = strdup("md5sum '");

    cmd = (char *)realloc(cmd, sizeof(char) * (strlen(cmd) + strlen(filename) + 2));
    strcat(cmd, filename);
    strcat(cmd, "'");

    FILE *terminal = popen(cmd, "r");

    fgets(md5, sizeof(char) * 33, terminal);
    md5[32] = '\0';

    pclose(terminal);
    free(cmd);

    return md5;
}

// CHECK IF THE STORED MD5 HASH IS THE SAME AS THE MD5 HASH OF THE FILE
bool md5check(char *md5, char *filename)
{
    char *md5new = md5sum(filename);
    if (!strcmp(md5, md5new))
    {
        free(md5new);
        return true;
    }
    free(md5new);
    return false;
}Project2/v2.0/src/trove.c000075500000000000000000000127721432373640000110520/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#include "../inc/trove.h"

bool info = false;

// IF THE ARGUMENT IS NOT CORRECT, PRINT THE USAGE AND EXIT
void err_print(void)
{
    printf("%s\n%s\n\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n",
           "Usage:\t./trove [-f trove-file] [-b | -r | -u] [-l length] [-v] filelist",
           "or\t./trove [-f trove-file] word",
           "where options are",
           "-b\t\tbuild a new trove-file",
           "-f trove-file\tprovide the name of the trove-file to be built or searched",
           "-l length\tspecify the minimum-length of words added to the trove-file",
           "-r\t\tremove a trove-file",
           "-u\t\tupdate a trove-file",
           "-v\t\tadditional option to print details");
    exit(EXIT_FAILURE);
}

// BUILD FUNCTION
void build_trove(uint32_t argc, char *argv[], HASHTABLE_MLIST *hashtable)
{
    printf("\tTrove-File:\t%s\n\tWordlen limit:\t%d\n", TROVE_FILE, wordlen);
    printf("\t--------------------------Building--------------------------\n");
    hashtable = hashtable_mlist_new();
    for (; optind < argc; optind++)
    {
        recordWord(argv[optind], hashtable);
    }
    trovefile_write(hashtable);
    if (info)
    {
        printf("\tThe Trove File is now Containing:\n");
        printf("\t----------------------Trove File Detail----------------------\n");
        trovefile_print();
    }
    exit(EXIT_SUCCESS);
}

// REMOVE FUNCTION
void remove_func(uint32_t argc, char *argv[], HASHTABLE_MLIST *hashtable)
{
    printf("\tTrove-File:\t%s\n", TROVE_FILE);
    printf("\t--------------------------Removing--------------------------\n");
    hashtable = trovefile_load();
    for (; optind < argc; optind++)
    {
        if (!access(argv[optind], R_OK))
        {
            hashtable_mlist_remove(hashtable, argv[optind]);
        }
    }
    trovefile_write(hashtable);
    if (info)
    {
        printf("\tAfter Remove, The Trove File Containing:\n");
        printf("\t-------------------------Trove File-------------------------\n");
        trovefile_filename_print();
    }
    exit(EXIT_SUCCESS);
}

// UPDATE FUNCTION
void update_trove(uint32_t argc, char *argv[], HASHTABLE_MLIST *hashtable)
{
    printf("\tTrove-File:\t%s\n\tWordlen limit:\t%d\n", TROVE_FILE, wordlen);
    printf("\t--------------------------Updating--------------------------\n");
    hashtable = hashtable_mlist_new();
    for (; optind < argc; optind++)
    {
        recordWord(argv[optind], hashtable);
    }
    trovefile_update(hashtable);
    if (info)
    {
        printf("\tThe Trove File is now Containing:\n");
        printf("\t----------------------Trove File Detail----------------------\n");
        trovefile_print();
    }
    exit(EXIT_SUCCESS);
}

// SERACH FUNCTION
void search_func(uint32_t argc, char *argv[], HASHTABLE_MLIST *hashtable)
{
    printf("\tSearching...\n\tTrove File:\t%s\n\tTarget Word:\t\"%s\"\n", TROVE_FILE, argv[argc - 1]);
    printf("\t-----------------------SEARCH RESULT------------------------\n");
    hashtable = trovefile_load();
    hashtable_mlist_files_have_word_print(hashtable, argv[argc - 1]);
    trovefile_write(hashtable);
    exit(EXIT_SUCCESS);
}

int32_t main(int32_t argc, char *argv[])
{
    uint32_t result;
    uint16_t argc_cor = 2;
    uint16_t function = 0; // 0: search 1: build, 2: remove, 3: update

    HASHTABLE_MLIST *hashtable = hashtable_mlist_new();
    char *cmd = "ulimit -n 2048\n";
    system(cmd);

    while ((result = getopt(argc, argv, "f:brul:v")) != -1)
    {
        switch (result)
        {
        case 'f':

            change_trove_file(optarg);
            argc_cor += 2;
            break;

        case 'l':

            if (!isInt(optarg) || atoi(optarg) < 1) // if the length is not a positive integer or larger than 255
            {
                err_print();
            }
            change_wordlen(atoi(optarg));
            argc_cor += 2;
            if (function == 0)
            {
                function = 4; // 4: not allow search and remove, if -l argument is used
            }
            break;

        case 'b':

            if ((function && function != 4) || argc <= argc_cor++)
            {
                err_print();
            }
            function = 1; // 1: build
            break;

        case 'r':

            if ((function && function != 4) || argc <= argc_cor++)
            {
                err_print();
            }
            function = 2; // 2: remove
            break;

        case 'u':

            if ((function && function != 4) || argc <= argc_cor++)
            {
                err_print();
            }
            function = 3; // 3: update
            break;

        case 'v':

            argc_cor++;
            info = true;
            break;

        default:
            err_print();
        }
    }

    if (argc == argc_cor && !function && !info) // SEARCH FUNCTION
    {
        if (!isString(argv[argc - 1]))
        {
            err_print();
        }
        search_func(argc, argv, hashtable);
    }
    else if (function == 1) // BUILD FUNCTION
    {
        build_trove(argc, argv, hashtable);
    }
    else if (function == 2) // REMOVE FUNCTION
    {
        remove_func(argc, argv, hashtable);
    }
    else if (function == 3) // UPDATE FUNCTION
    {
        update_trove(argc, argv, hashtable);
    }

    err_print();
    return 1;
}Project2/v2.0/src/trovefileIO.c000075500000000000000000000172171432373640200121430/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#include "../inc/trovefileIO.h"

char *TROVE_FILE = "/tmp/trove";
FILE *TROVE_FILE_P = NULL;

// CHANGE THE TROVE FILE NAME
void change_trove_file(char *filename)
{
    TROVE_FILE = strdup(filename);
}

// OPEN THE TROVE FILE
void trovefile_open(void)
{
    char *cmd = (char *)calloc(ARG_MAX, sizeof(char));
    CHECK_MEM(cmd);

    strcpy(cmd, "zcat '");
    strcat(cmd, TROVE_FILE);
    strcat(cmd, "'");

    if (access(TROVE_FILE, R_OK))
    {
        perror("access");
        exit(EXIT_FAILURE);
    }
    TROVE_FILE_P = popen(cmd, "r");
}

// CLOSE THE TROVE FILE AND GZIP IT
void trovefile_gz_close(void)
{
    fclose(TROVE_FILE_P);

    char *cmd = (char *)calloc(ARG_MAX, sizeof(char));
    CHECK_MEM(cmd);

    strcpy(cmd, "gzip -9 '");
    strcat(cmd, TROVE_FILE);
    strcat(cmd, "'");

    system(cmd);

    strcpy(cmd, "mv '");
    strcat(cmd, TROVE_FILE);
    strcat(cmd, ".gz' '");
    strcat(cmd, TROVE_FILE);
    strcat(cmd, "'");

    system(cmd);
    free(cmd);
}

// LOAD THE WORDS FROM THE TROVE FILE INTO THE HASHTABLE
void load_from_troveFile(char *filename, char *wordslist, HASHTABLE_MLIST *hashtable)
{
    char *word = (char *)calloc(1, sizeof(char));
    CHECK_MEM(word);

    char *tmp = (char *)calloc(20, sizeof(char));
    CHECK_MEM(tmp);
    char c = *wordslist;

    uint32_t len = 0;

    while (c != '\0')
    {
        if (isalnum(c))
        {
            if (len > 19)
            {
                tmp = realloc(tmp, sizeof(char) * (len + 2));
            }
            tmp[len] = c;
            len++;
        }
        else
        {
            tmp[len] = '\0';
            word = strdup(tmp);
            len = 0;

            free(tmp);

            tmp = (char *)calloc(20, sizeof(char));
            CHECK_MEM(tmp);

            if (wordlen_check(word))
            {
                hashtable_mlist_add(hashtable, filename, word);
            }
        }
        c = *(++wordslist);
    }

    free(word);
    free(tmp);
}

HASHTABLE_MLIST *trovefile_load(void)
{
    HASHTABLE_MLIST *hashtable_mlist = hashtable_mlist_new();
    trovefile_open();

    while (!feof(TROVE_FILE_P))
    {
        char *filename = getLine(TROVE_FILE_P);
        char *md5 = getLine(TROVE_FILE_P);
        char *wordslist = getLine(TROVE_FILE_P);
        if (access(filename, R_OK) || !md5check(md5, filename))
        {
            continue;
        }
        load_from_troveFile(filename, wordslist, hashtable_mlist);
    }
    fclose(TROVE_FILE_P);
    return hashtable_mlist;
}

/* THE FOLLOWING 4 FUNCTIONS ARE USED TO READ FROM THE HASHTABLE
 *  YOU MAY FIND THEM FAMILIAR AND THAT IS BECAUSE
 *  THEY ARE JUST A DIFFERENT VERSION OF XXX_print FUNCTIONS
 *  FROM list.c, mlist.c, hastable_list.c, hashtable_mlist.c
 */

// READ THE LIST
char *list_read(LIST *list)
{
    char *str = strdup("");
    char *space = " ";

    if (list != NULL)
    {
        while (list->next != NULL)
        {
            if (list->word != NULL)
            {
                str = (char *)realloc(str, sizeof(char) * (strlen(str) + strlen(list->word) + 2));
                strcat(str, space);
                strcat(str, list->word);
            }
            list = list->next;
        }
        if (list->next == NULL)
        {
            if (list->word != NULL)
            {
                str = (char *)realloc(str, sizeof(char) * (strlen(str) + strlen(list->word) + 1));
                strcat(str, space);
                strcat(str, list->word);
            }
        }
    }
    return str;
}

// READ THE HASHTABLE
char *hashtable_list_read(HASHTABLE_LIST *hashtable)
{
    char *str = strdup("");
    char *str_list;

    for (uint16_t i = 0; i < HASHTABLE_LIST_SIZE; i++)
    {
        LIST *list = hashtable[i];
        if (list != NULL)
        {
            str_list = list_read(list);
        }
        str = (char *)realloc(str, sizeof(char) * (strlen(str) + strlen(str_list) + 1));
        strcat(str, str_list);
    }
    return str;
}

// READ the MLIST
char *mlist_read(MLIST *mlist)
{
    char *str = strdup("");
    char *str_hashtable_list;
    char *str_filename;
    char *md5;
    char *linespace = "\n";

    if (mlist != NULL)
    {
        while (mlist->next != NULL)
        {
            if (mlist->filename != NULL)
            {
                str_filename = strdup(mlist->filename);
                str = (char *)realloc(str, sizeof(char) * (strlen(str) + strlen(mlist->filename) + 2));
                strcat(str, str_filename);
                strcat(str, linespace);

                md5 = strdup(mlist->md5);
                str = (char *)realloc(str, sizeof(char) * (strlen(str) + strlen(mlist->md5) + 2));
                strcat(str, md5);
                strcat(str, linespace);

                str_hashtable_list = hashtable_list_read(mlist->words);
                str = (char *)realloc(str, sizeof(char) * (strlen(str) + strlen(str_hashtable_list) + 2));
                strcat(str, str_hashtable_list);
                strcat(str, linespace);
            }
            mlist = mlist->next;
        }
        if (mlist->next == NULL && mlist->filename != NULL)
        {
            str_filename = strdup(mlist->filename);
            str = (char *)realloc(str, sizeof(char) * (strlen(str) + strlen(mlist->filename) + 2));
            strcat(str, str_filename);
            strcat(str, linespace);

            md5 = strdup(mlist->md5);
            str = (char *)realloc(str, sizeof(char) * (strlen(str) + strlen(mlist->md5) + 2));
            strcat(str, md5);
            strcat(str, linespace);

            str_hashtable_list = hashtable_list_read(mlist->words);
            str = (char *)realloc(str, sizeof(char) * (strlen(str) + strlen(str_hashtable_list) + 2));
            strcat(str, str_hashtable_list);
            strcat(str, linespace);
        }
    }
    return str;
}

//  READ the hashtable
char *hashtable_mlist_read(HASHTABLE_MLIST *hashtable)
{
    char *str = strdup("");
    char *str_mlist;

    for (uint16_t i = 0; i < HASHTABLE_MLIST_SIZE; i++)
    {
        while (hashtable[i] != NULL)
        {
            str_mlist = mlist_read(hashtable[i]);
            str = (char *)realloc(str, sizeof(char) * (strlen(str) + strlen(str_mlist) + 1));
            strcat(str, str_mlist);
            hashtable[i] = hashtable[i]->next;
        }
    }
    return str;
}

// REMOVE THE OLD DATA AND REPLACE IT WITH THE NEW ONE
void trovefile_write(HASHTABLE_MLIST *hashtable)
{
    TROVE_FILE_P = fopen(TROVE_FILE, "w+");
    fseek(TROVE_FILE_P, 0, SEEK_SET);

    char *str = hashtable_mlist_read(hashtable);
    fprintf(TROVE_FILE_P, "%s", str);

    hashtable_mlist_free(hashtable);
    trovefile_gz_close();
}

// UPDATE THE OLD HASHTABLE WHICH HAVING THE SAME FILE NAME AS IN NEW WHILE KEEPING THE OTHER DATA
void trovefile_update(HASHTABLE_MLIST *hashtable)
{
    HASHTABLE_MLIST *old_hashtable = trovefile_load();
    hashtable_mlist_update(old_hashtable, hashtable);
    trovefile_write(old_hashtable);
}

// PRINT EVERYTHING IN THE TROVE FILE
void trovefile_print(void)
{
    HASHTABLE_MLIST *hashtable = trovefile_load();
    hashtable_mlist_print(hashtable);
    hashtable_mlist_free(hashtable);
    printf("\n");
}

// PRINT ALL THE FILENAME IN THE TROVE FILE
void trovefile_filename_print(void)
{
    HASHTABLE_MLIST *hashtable = trovefile_load();
    hashtable_mlist_filename_print(hashtable);
    hashtable_mlist_free(hashtable);
    printf("\n");
}Project2/v2.0/src/wordFileIO.c000075500000000000000000000067571432373640500117310/*
 *   CITS2002  Project 2  2022-sem2
 *   Student:  23006364   HU ZHUO   100
 */

#include "../inc/wordFileIO.h"

HASHTABLE_MLIST *hashtable_global;

// RECORD ALL THE WORDS FROM FILE INTO THE HASHTABLE
void recordWord_file(char *filename, HASHTABLE_MLIST *hashtable)
{
    filename = getRealPath(filename);

    printf("\t%s\n", filename); // Print the name of the file
    FILE *fp = openfile(filename);

    char *word = (char *)calloc(2, sizeof(char));
    CHECK_MEM(word);

    char *tmp = (char *)calloc(1, sizeof(char));
    CHECK_MEM(tmp);

    uint32_t len = 0;

    char c = fgetc(fp);
    while (!feof(fp))
    {
        if (isalnum(c))
        {
            if (len >= 20)
            {
                tmp = realloc(tmp, sizeof(char) * (len + 2));
            }
            tmp[len] = c;
            len++;
        }
        else
        {
            tmp[len] = '\0';
            word = strdup(tmp);
            len = 0;

            free(tmp);

            tmp = (char *)calloc(2, sizeof(char));
            CHECK_MEM(tmp);

            if (wordlen_check(word))
            {
                hashtable_mlist_add(hashtable, filename, word);
            }
        }
        c = fgetc(fp);
    }

    fclose(fp);
    free(word);
    free(tmp);
}

// THREADED recordWord_file FUNCTION
void *recordWord_file_thread(void *thread_data)
{
    char *filename = (char *)thread_data;
    recordWord(filename, hashtable_global);
    pthread_exit(NULL);
}

// TRAVESE THE DIRECTORY AND RECORD ALL THE FILES USE recordWord_file_thread
void recordWord_dir(char *filename, HASHTABLE_MLIST *hashtable)
{
    DIR *dir;
    struct dirent *ptr;
    char path[PATH_MAX];
    uint32_t NUM_THREADS = SHRT_MAX;
    pthread_t threads[NUM_THREADS];
    uint32_t tid = 0;

    printf("\tOpening Directory:\t%s\n", filename);
    dir = opendir(filename);

    if (dir == NULL)
    {
        perror("OPEN DIR ERROR");
        exit(EXIT_FAILURE);
    }

    while ((ptr = readdir(dir)) != NULL)
    {
        if (!strcmp(ptr->d_name, ".") || !strcmp(ptr->d_name, ".."))
        {
            continue;
        }
        else if (ptr->d_type == 8)
        {
            strcpy(path, filename);
            strcat(path, "/");
            strcat(path, ptr->d_name);
            char *thread_data = strdup(path);
            int32_t rc = pthread_create(&threads[tid], NULL, recordWord_file_thread, (void *)thread_data);

            if (rc != 0)
            {
                printf("ERROR; return code from pthread_create() is %d\n", rc);
                exit(EXIT_FAILURE);
            }
            usleep(1000);
            tid++;
        }
        else if (ptr->d_type == 10)
        {
            continue;
        }
        else if (ptr->d_type == 4)
        {
            strcpy(path, filename);
            strcat(path, "/");
            strcat(path, ptr->d_name);
            printf("\n");

            recordWord_dir(path, hashtable);
        }
    }
    closedir(dir);
}

// THE OVERALL FUNTION FOR RECORDING
void recordWord(char *filename, HASHTABLE_MLIST *hashtable)
{
    hashtable_global = hashtable;

    struct stat statbuf;
    if (stat(filename, &statbuf))
    {
        perror("fopen");
        exit(EXIT_FAILURE);
    }
    else if (S_ISDIR(statbuf.st_mode))
    {
        recordWord_dir(filename, hashtable);
    }
    else if (S_ISREG(statbuf.st_mode))
    {
        recordWord_file(filename, hashtable);
    }
}