jeang3nie/seahag
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Minor refactor and formatting changes

Browse source
This commit is contained in:
Nathan Fisher 2024-02-11 01:09:21 -05:00
parent a988a7877e
commit f4e9b80737
28 changed files with 291 additions and 291 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

134
haggis.c
View file

@ -85,10 +85,10 @@ void haggis_device_init(dev_t rdev, haggis_device *dev) {
dev->minor.val = (uint32_t)minor(rdev);
}
int haggis_store_device(FILE *stream, haggis_device *dev) {
if (fwrite(dev->major.bytes, 1, 4, stream) != 4)
int haggis_store_device(haggis_device *self, FILE *stream) {
if (fwrite(self->major.bytes, 1, 4, stream) != 4)
return 1;
if (fwrite(dev->minor.bytes, 1, 4, stream) != 4)
if (fwrite(self->minor.bytes, 1, 4, stream) != 4)
return 1;
return 0;
}
@ -109,21 +109,21 @@ int haggis_store_cksum(FILE *stream, haggis_checksum *cksum) {
flag = 0;
if (fwrite(&flag, 1, 1, stream) != 1)
return 1;
if (fwrite(cksum->sum.md5, 1, 16, stream) != 16)
if (fwrite(cksum->md5, 1, 16, stream) != 16)
return 1;
break;
case sha1:
flag = 1;
if (fwrite(&flag, 1, 1, stream) != 1)
return 1;
if (fwrite(cksum->sum.sha1, 1, 20, stream) != 20)
if (fwrite(cksum->sha1, 1, 20, stream) != 20)
return 1;
break;
case sha256:
flag = 2;
if (fwrite(&flag, 1, 1, stream) != 1)
return 1;
if (fwrite(cksum->sum.sha256, 1, 32, stream) != 32)
if (fwrite(cksum->sha256, 1, 32, stream) != 32)
return 1;
break;
case skip:
@ -143,17 +143,17 @@ int haggis_load_cksum(FILE *stream, haggis_checksum *cksum) {
switch (flag) {
case md5:
cksum->tag = 0;
if (fread(&cksum->sum.md5, 1, 16, stream) != 16)
if (fread(&cksum->md5, 1, 16, stream) != 16)
return 1;
break;
case sha1:
cksum->tag = 1;
if (fread(&cksum->sum.sha1, 1, 20, stream) != 20)
if (fread(&cksum->sha1, 1, 20, stream) != 20)
return 1;
break;
case sha256:
cksum->tag = 2;
if (fread(&cksum->sum.sha256, 1, 32, stream) != 32)
if (fread(&cksum->sha256, 1, 32, stream) != 32)
return 1;
break;
case skip:
@ -169,7 +169,7 @@ void init_md5(haggis_file *f) {
f->cksum.tag = md5;
MD5Init(&ctx);
MD5Update(&ctx, f->data, (size_t)f->len.val);
MD5Final(f->cksum.sum.md5, &ctx);
MD5Final(f->cksum.md5, &ctx);
}
int validate_md5(haggis_file *file) {
@ -179,7 +179,7 @@ int validate_md5(haggis_file *file) {
MD5Init(&ctx);
MD5Update(&ctx, file->data, (size_t)file->len.val);
MD5Final(digest, &ctx);
if (memcmp(file->cksum.sum.md5, digest, sizeof(digest)))
if (memcmp(file->cksum.md5, digest, sizeof(digest)))
return 2;
return 0;
}
@ -191,7 +191,7 @@ void init_sha1(haggis_file *f) {
f->cksum.tag = sha1;
SHA1_Init(&ctx);
SHA1_Update(&ctx, f->data, (size_t)f->len.val);
SHA1_Final(f->cksum.sum.sha1, &ctx);
SHA1_Final(f->cksum.sha1, &ctx);
}
int validate_sha1(haggis_file *file) {
@ -201,7 +201,7 @@ int validate_sha1(haggis_file *file) {
SHA1_Init(&ctx);
SHA1_Update(&ctx, file->data, (size_t)file->len.val);
SHA1_Final(digest, &ctx);
if (memcmp(file->cksum.sum.sha1, digest, sizeof(digest)))
if (memcmp(file->cksum.sha1, digest, sizeof(digest)))
return 2;
return 0;
}
@ -235,7 +235,7 @@ void init_sha256(haggis_file *f) {
f->cksum.tag = sha256;
SHA256_Init(&ctx);
SHA256_Update(&ctx, f->data, (size_t)f->len.val);
SHA256_Final(f->cksum.sum.sha256, &ctx);
SHA256_Final(f->cksum.sha256, &ctx);
}
int validate_sha256(haggis_file *file) {
@ -245,7 +245,7 @@ int validate_sha256(haggis_file *file) {
SHA256_Init(&ctx);
SHA256_Update(&ctx, file->data, (size_t)file->len.val);
SHA256_Final(digest, &ctx);
if (memcmp(file->cksum.sum.sha256, digest, sizeof(digest)))
if (memcmp(file->cksum.sha256, digest, sizeof(digest)))
return 2;
return 0;
}
@ -407,22 +407,22 @@ int haggis_load_filetype(FILE *stream, haggis_typeflag tag, haggis_filetype *fil
switch (tag) {
case normal:
file->tag = 0;
return haggis_load_file(stream, &file->f_type.file);
return haggis_load_file(stream, &file->file);
case hardlink:
return haggis_load_filename(stream, &file->f_type.target);
return haggis_load_filename(stream, &file->target);
file->tag = 1;
case softlink:
return haggis_load_filename(stream, &file->f_type.target);
return haggis_load_filename(stream, &file->target);
file->tag = 2;
case directory:
file->tag = 3;
break;
case character:
file->tag = 4;
return haggis_load_device(stream, &file->f_type.dev);
return haggis_load_device(stream, &file->dev);
case block:
file->tag = 5;
return haggis_load_device(stream, &file->f_type.dev);
return haggis_load_device(stream, &file->dev);
case fifo:
file->tag = 6;
break;
@ -441,19 +441,19 @@ int haggis_store_filetype(FILE *stream, haggis_filetype *filetype) {
flag = 0;
if (fwrite(&flag, 1, 1, stream) != 1)
return 1;
if (haggis_store_file(stream, &filetype->f_type.file) != 0)
if (haggis_store_file(stream, &filetype->file) != 0)
return 1;
break;
case hardlink:
flag = 1;
if (fwrite(&flag, 1, 1, stream) != 1)
return 1;
return haggis_store_filename(stream, &filetype->f_type.target);
return haggis_store_filename(stream, &filetype->target);
case softlink:
flag = 2;
if (fwrite(&flag, 1, 1, stream) != 1)
return 1;
return haggis_store_filename(stream, &filetype->f_type.target);
return haggis_store_filename(stream, &filetype->target);
case directory:
flag = 3;
if (fwrite(&flag, 1, 1, stream) != 1)
@ -463,14 +463,14 @@ int haggis_store_filetype(FILE *stream, haggis_filetype *filetype) {
flag = 4;
if (fwrite(&flag, 1, 1, stream) != 1)
return 1;
if (haggis_store_device(stream, &filetype->f_type.dev) != 0)
if (haggis_store_device(&filetype->dev, stream) != 0)
return 1;
break;
case block:
flag = 5;
if (fwrite(&flag, 1, 1, stream) != 1)
return 1;
if (haggis_store_device(stream, &filetype->f_type.dev) != 0)
if (haggis_store_device(&filetype->dev, stream) != 0)
return 1;
break;
case fifo:
@ -504,14 +504,14 @@ void haggis_node_deinit(haggis_node *node) {
if (node->name.name != NULL) haggis_filename_deinit(&node->name);
switch (node->filetype.tag) {
case normal:
if (node->filetype.f_type.file.data != NULL) {
free(node->filetype.f_type.file.data);
if (node->filetype.file.data != NULL) {
free(node->filetype.file.data);
}
break;
case hardlink:
case softlink:
if (node->filetype.f_type.target.name != NULL) {
haggis_filename_deinit(&node->filetype.f_type.target);
if (node->filetype.target.name != NULL) {
haggis_filename_deinit(&node->filetype.target);
}
break;
case character:
@ -534,7 +534,7 @@ int haggis_init_hardlink_node(
haggis_msg *msg;
node->filetype.tag = hardlink;
haggis_filename_init(target, &node->filetype.f_type.target);
haggis_filename_init(target, &node->filetype.target);
body.f_name = strndup(node->name.name, PATH_MAX);
msg = haggis_msg_init(NodeCreated, body);
if (msg == NULL)
@ -563,7 +563,7 @@ int haggis_init_file_node(
}
}
node->filetype.tag = normal;
res = haggis_file_init(node->name.name, &node->filetype.f_type.file, a);
res = haggis_file_init(node->name.name, &node->filetype.file, a);
if (res != 0) {
haggis_node_deinit(node);
return 1;
@ -591,7 +591,7 @@ int haggis_init_dev_node(
return 0;
}
}
haggis_device_init(st->st_rdev, &node->filetype.f_type.dev);
haggis_device_init(st->st_rdev, &node->filetype.dev);
body.f_name = strndup(node->name.name, PATH_MAX);
msg = haggis_msg_init(NodeCreated, body);
haggis_mq_push(mq, msg);
@ -674,7 +674,7 @@ haggis_node* haggis_create_node(
}
target = malloc(res + 1);
memcpy(target, pathbuf, (unsigned long)res);
haggis_filename_init(target, &node->filetype.f_type.target);
haggis_filename_init(target, &node->filetype.target);
body.f_name = strndup(file, PATH_MAX);
msg = haggis_msg_init(NodeCreated, body);
haggis_mq_push(mq, msg);
@ -743,8 +743,8 @@ int haggis_extract_dev(haggis_node *node, char *basedir) {
free(path);
return 2;
}
major = (int)node->filetype.f_type.dev.major.val;
minor = (int)node->filetype.f_type.dev.minor.val;
major = (int)node->filetype.dev.major.val;
minor = (int)node->filetype.dev.minor.val;
dev = makedev(major, minor);
if (node->filetype.tag == block) {
mode = (mode_t)node->mode.val | S_IFBLK;
@ -791,7 +791,7 @@ int haggis_extract_symlink(haggis_node *node, char *basedir) {
free(path);
return 2;
}
target = node->filetype.f_type.target.name;
target = node->filetype.target.name;
if (access(path, F_OK) == 0)
unlink(path);
ret = symlink(target, path);
@ -814,7 +814,7 @@ int haggis_extract_hardlink(haggis_node *node, char *basedir) {
free(path);
return 2;
}
target = get_full_path(&node->filetype.f_type.target, basedir);
target = get_full_path(&node->filetype.target, basedir);
if (target == NULL) {
free(path);
return 1;
@ -875,8 +875,8 @@ char* haggis_extract_file(haggis_node *node, char *basedir) {
free(path);
return NULL;
}
len = (size_t)node->filetype.f_type.file.len.val;
ret = fwrite(node->filetype.f_type.file.data, len, 1, fd);
len = (size_t)node->filetype.file.len.val;
ret = fwrite(node->filetype.file.data, len, 1, fd);
if (ret != len) {
free(path);
fclose(fd);
@ -887,42 +887,42 @@ char* haggis_extract_file(haggis_node *node, char *basedir) {
return path;
}
int haggis_extract_node(char *basedir, haggis_node *node, haggis_mq *mq) {
int haggis_extract_node(haggis_node *self, char *basedir, haggis_mq *mq) {
haggis_msg *msg;
char *path, *dir, *fullpath;
int ret = 0;
path = get_full_path(&node->name, basedir);
path = get_full_path(&self->name, basedir);
dir = dirname(strndup(path, PATH_MAX));
mkdir_p(dir);
switch (node->filetype.tag) {
switch (self->filetype.tag) {
case block:
case character:
if (geteuid() == 0) {
ret = haggis_extract_dev(node, basedir);
ret = haggis_extract_dev(self, basedir);
} else {
ret = -1;
msg = calloc(1, sizeof(haggis_msg));
if (msg == NULL) return 2;
msg->tag = DevNodeSkipped;
msg->body.f_name = strndup(node->name.name, PATH_MAX);
msg->body.f_name = strndup(self->name.name, PATH_MAX);
haggis_mq_push(mq, msg);
}
break;
case fifo:
ret = haggis_extract_fifo(node, basedir);
ret = haggis_extract_fifo(self, basedir);
break;
case softlink:
ret = haggis_extract_symlink(node, basedir);
ret = haggis_extract_symlink(self, basedir);
break;
case hardlink:
ret = haggis_extract_hardlink(node, basedir);
ret = haggis_extract_hardlink(self, basedir);
break;
case directory:
ret = haggis_extract_dir(node, basedir);
ret = haggis_extract_dir(self, basedir);
break;
case normal:
fullpath = haggis_extract_file(node, basedir);
fullpath = haggis_extract_file(self, basedir);
if (fullpath == NULL) {
ret = errno;
}
@ -932,62 +932,62 @@ int haggis_extract_node(char *basedir, haggis_node *node, haggis_mq *mq) {
}
if (ret) return ret;
if (geteuid() == 0) {
ret = chown(path, (uid_t)node->uid.val, (gid_t)node->gid.val);
ret = chown(path, (uid_t)self->uid.val, (gid_t)self->gid.val);
if (ret != 0) {
free(path);
return errno;
}
}
ret = chmod(path, (mode_t)node->mode.val);
ret = chmod(path, (mode_t)self->mode.val);
if (ret) return ret;
msg = calloc(1, sizeof(haggis_msg));
if (msg == NULL)
return 2;
msg->tag = NodeExtracted;
msg->body.f_name = strndup(node->name.name, PATH_MAX);
msg->body.f_name = strndup(self->name.name, PATH_MAX);
haggis_mq_push(mq, msg);
return ret;
}
int haggis_load_node(FILE *stream, haggis_node *node) {
int haggis_load_node(haggis_node *self, FILE *stream) {
int res;
u16 mode;
haggis_typeflag tag;
mode.val = 0;
res = haggis_load_filename(stream, &node->name);
res = haggis_load_filename(stream, &self->name);
if (res)
return res;
res = load_u32(stream, &node->uid);
res = load_u32(stream, &self->uid);
if (res != 4)
return 2;
res = load_u32(stream, &node->gid);
res = load_u32(stream, &self->gid);
if (res != 4)
return 2;
res = load_u64(stream, &node->mtime);
res = load_u64(stream, &self->mtime);
if (res != 8)
return 2;
res = load_u16(stream, &mode);
if (res != 2)
return 2;
tag = haggis_filetype_from_mode(mode);
node->mode.bytes[0] = mode.bytes[0] & 037;
node->mode.bytes[1] = mode.bytes[1];
res = haggis_load_filetype(stream, tag, &node->filetype);
self->mode.bytes[0] = mode.bytes[0] & 037;
self->mode.bytes[1] = mode.bytes[1];
res = haggis_load_filetype(stream, tag, &self->filetype);
if (res)
return res;
return 0;
}
int haggis_store_node(FILE *stream, haggis_node *node) {
int haggis_store_node(haggis_node *self, FILE *stream) {
u16 mode;
if (haggis_store_filename(stream, &node->name) != (size_t)(node->name.len.val) + 2)
if (haggis_store_filename(stream, &self->name) != (size_t)(self->name.len.val) + 2)
return 2;
if (store_u32(stream, &node->uid) != 4) return 2;
if (store_u32(stream, &node->gid) != 4) return 2;
if (store_u64(stream, &node->mtime) != 8) return 2;
mode = haggis_derive_mode(node->mode, &node->filetype);
if (store_u32(stream, &self->uid) != 4) return 2;
if (store_u32(stream, &self->gid) != 4) return 2;
if (store_u64(stream, &self->mtime) != 8) return 2;
mode = haggis_derive_mode(self->mode, &self->filetype);
if (store_u16(stream, &mode) != 2) return 2;
return haggis_store_filetype(stream, &node->filetype);
return haggis_store_filetype(stream, &self->filetype);
}

6
include/bytes.h
View file

@ -37,11 +37,11 @@
#include "haggis.h"
int load_u16(FILE *stream, u16 *num);
int load_u16 (FILE *stream, u16 *num);
int store_u16(FILE *stream, u16 *num);
int load_u32(FILE *stream, u32 *num);
int load_u32 (FILE *stream, u32 *num);
int store_u32(FILE *stream, u32 *num);
int load_u64(FILE *stream, u64 *num);
int load_u64 (FILE *stream, u64 *num);
int store_u64(FILE *stream, u64 *num);
#endif

85
include/haggis.h
View file

@ -42,17 +42,17 @@ typedef uint8_t u8;
typedef union {
uint16_t val;
u8 bytes[2];
u8 bytes[2];
} u16;
typedef union {
uint32_t val;
u8 bytes[4];
u8 bytes[4];
} u32;
typedef union {
uint64_t val;
u8 bytes[8];
u8 bytes[8];
} u64;
typedef struct {
@ -70,20 +70,20 @@ typedef enum {
typedef struct {
haggis_algorithm tag;
union {
u8 md5[16];
u8 sha1[20];
u8 sha256[32];
} sum;
u8 md5[16];
u8 sha1[20];
u8 sha256[32];
};
} haggis_checksum;
typedef struct {
u64 len;
haggis_checksum cksum;
u8 *data;
u64 len;
haggis_checksum cksum;
u8 *data;
} haggis_file;
typedef struct {
u16 len;
u16 len;
char *name;
} haggis_filename;
@ -99,20 +99,20 @@ typedef enum {
} haggis_typeflag;
typedef struct {
haggis_typeflag tag;
haggis_typeflag tag;
union {
haggis_file file;
haggis_file file;
haggis_filename target;
haggis_device dev;
} f_type;
haggis_device dev;
};
} haggis_filetype;
typedef struct {
haggis_filename name;
u32 uid;
u32 gid;
u64 mtime;
u16 mode;
u32 uid;
u32 gid;
u64 mtime;
u16 mode;
haggis_filetype filetype;
} haggis_node;
@ -120,18 +120,18 @@ typedef struct {
typedef struct __bucket {
union {
ino_t val;
ino_t val;
uint8_t bytes[sizeof(ino_t)];
} key;
uint64_t hash;
char * path;
} key;
uint64_t hash;
char *path;
} haggis_bucket;
typedef struct {
pthread_mutex_t mutex;
size_t len;
size_t capacity;
haggis_bucket *buckets;
size_t len;
size_t capacity;
haggis_bucket *buckets;
} haggis_linkmap;
typedef enum {
@ -144,12 +144,12 @@ typedef enum {
typedef union {
char *f_name;
int err;
int err;
} haggis_message_body;
struct _mq_node {
struct _mq_node *prev;
struct _mq_node *next;
struct _mq_node *prev;
struct _mq_node *next;
haggis_message_type tag;
haggis_message_body body;
};
@ -157,20 +157,21 @@ struct _mq_node {
typedef struct _mq_node haggis_msg;
typedef struct {
pthread_cond_t cond;
size_t count;
pthread_mutex_t mutex;
haggis_msg *head;
haggis_msg *tail;
pthread_cond_t cond;
size_t count;
pthread_mutex_t mutex;
haggis_msg *head;
haggis_msg *tail;
} haggis_mq;
haggis_linkmap* haggis_linkmap_init();
void haggis_linkmap_deinit(haggis_linkmap *map);
char* haggis_linkmap_get_or_add(haggis_linkmap *map, ino_t inode, char *path);
void haggis_node_deinit(haggis_node *node);
haggis_node* haggis_create_node(char *file, haggis_algorithm a, haggis_linkmap *map, haggis_mq *mq);
int haggis_extract_node(char *basedir, haggis_node *node, haggis_mq *mq);
int haggis_load_node(FILE *stream, haggis_node *node);
int haggis_store_node(FILE *stream, haggis_node *node);
haggis_linkmap* haggis_linkmap_init ();
void haggis_linkmap_deinit (haggis_linkmap *self);
char* haggis_linkmap_get_or_add(haggis_linkmap *self, ino_t inode, char *path);
void haggis_node_deinit (haggis_node *self);
haggis_node* haggis_create_node (char *file, haggis_algorithm a, haggis_linkmap *map,
haggis_mq *mq);
int haggis_extract_node (haggis_node *self, char *basedir, haggis_mq *mq);
int haggis_load_node (haggis_node *self, FILE *stream);
int haggis_store_node (haggis_node *self, FILE *stream);
#endif // !HAGGIS_H

76
include/haggis_private.h
View file

@ -43,54 +43,54 @@
#include "haggis.h"
#include "mq.h"
int haggis_store_header(FILE *stream);
int haggis_check_header(FILE *stream);
void haggis_device_init(dev_t rdev, haggis_device *dev);
int haggis_store_device(FILE *stream, haggis_device *dev);
int haggis_load_device(FILE *stream, haggis_device *dev);
int haggis_store_cksum(FILE *stream, haggis_checksum *cksum);
int haggis_load_cksum(FILE *stream, haggis_checksum *cksum);
int validate_md5(haggis_file *file);
int validate_sha1(haggis_file *file);
int validate_sha256(haggis_file *file);
int haggis_validate_cksum(haggis_file *file);
int haggis_file_init(char *path, haggis_file *hf, haggis_algorithm a);
int haggis_store_file(FILE *stream, haggis_file *file);
int haggis_load_file(FILE *stream, haggis_file *f);
void haggis_filename_init(char *target, haggis_filename *fname);
void haggis_filename_deinit(haggis_filename *fname);
int haggis_load_filename(FILE *stream, haggis_filename *n);
int haggis_store_filename(FILE *stream, haggis_filename *n);
int haggis_load_filetype(FILE *stream, haggis_typeflag tag, haggis_filetype *file);
int haggis_store_filetype(FILE *stream, haggis_filetype *filetype);
uint64_t hash_fnv1a_64(uint8_t *key, size_t len);
uint64_t hash_str_fnv1a_64(char *s);
int haggis_store_header (FILE *stream);
int haggis_check_header (FILE *stream);
void haggis_device_init (dev_t rdev, haggis_device *dev);
int haggis_store_device (haggis_device *self, FILE *stream);
int haggis_load_device (FILE *stream, haggis_device *dev);
int haggis_store_cksum (FILE *stream, haggis_checksum *cksum);
int haggis_load_cksum (FILE *stream, haggis_checksum *cksum);
int validate_md5 (haggis_file *file);
int validate_sha1 (haggis_file *file);
int validate_sha256 (haggis_file *file);
int haggis_validate_cksum (haggis_file *file);
int haggis_file_init (char *path, haggis_file *hf, haggis_algorithm a);
int haggis_store_file (FILE *stream, haggis_file *file);
int haggis_load_file (FILE *stream, haggis_file *f);
void haggis_filename_init (char *target, haggis_filename *fname);
void haggis_filename_deinit(haggis_filename *fname);
int haggis_load_filename (FILE *stream, haggis_filename *n);
int haggis_store_filename (FILE *stream, haggis_filename *n);
int haggis_load_filetype (FILE *stream, haggis_typeflag tag, haggis_filetype *file);
int haggis_store_filetype (FILE *stream, haggis_filetype *filetype);
uint64_t hash_fnv1a_64 (uint8_t *key, size_t len);
uint64_t hash_str_fnv1a_64 (char *s);
struct _map_node {
struct _map_node *next;
void * key;
uint64_t hash;
void *data;
void *key;
uint64_t hash;
void *data;
};
typedef struct _map_node hmap_node;
typedef struct {
size_t capacity;
size_t len;
size_t keysize;
size_t capacity;
size_t len;
size_t keysize;
hmap_node *buckets;
} hmap;
hmap_node* hmap_node_init(void *key, size_t keysize, void *data);
void hmap_node_deinit(hmap_node *node);
void* hmap_node_attach(hmap_node *root, hmap_node *leaf, size_t keysize);
void* hmap_node_search(hmap_node *root, void *key, size_t keysize);
hmap* hmap_init(size_t keysize);
void hmap_deinit(hmap *map);
int hmap_expand(hmap *map);
void* hmap_insert(hmap *map, void *key, void *data);
void* hmap_get(hmap *map, void *key);
void* hmap_remove(hmap *map, void *key);
hmap_node* hmap_node_init (void *key, size_t keysize, void *data);
void hmap_node_deinit(hmap_node *self);
void* hmap_node_attach(hmap_node *root, hmap_node *leaf, size_t keysize);
void* hmap_node_search(hmap_node *root, void *key, size_t keysize);
hmap* hmap_init (size_t keysize);
void hmap_deinit (hmap *self);
int hmap_expand (hmap *self);
void* hmap_insert (hmap *self, void *key, void *data);
void* hmap_get (hmap *self, void *key);
void* hmap_remove (hmap *self, void *key);
#endif // !HAGGIS_PRIVATE_H

14
include/jobq.h
View file

@ -39,26 +39,26 @@
typedef union {
haggis_node *node;
char *f_name;
char *f_name;
} haggis_job;
struct _job_node {
struct _job_node *prev;
haggis_job *job;
haggis_job *job;
struct _job_node *next;
};
typedef struct _job_node haggis_jobq_node;
typedef struct {
pthread_cond_t *cond;
size_t count;
pthread_mutex_t *mutex;
pthread_cond_t *cond;
size_t count;
pthread_mutex_t *mutex;
haggis_jobq_node *head;
haggis_jobq_node *tail;
} haggis_jobq;
int haggis_jobq_push(haggis_jobq *queue, haggis_job *job);
haggis_job* haggis_jobq_pop(haggis_jobq *queue);
int haggis_jobq_push(haggis_jobq *self, haggis_job *job);
haggis_job* haggis_jobq_pop (haggis_jobq *self);
#endif // !JOBQ_H

12
include/mq.h
View file

@ -36,11 +36,11 @@
#include <pthread.h>
#include "haggis.h"
haggis_msg* haggis_msg_init(haggis_message_type tag, haggis_message_body body);
void haggis_msg_deinit(haggis_msg *msg);
int haggis_mq_init(haggis_mq *mq);
int haggis_mq_push(haggis_mq *queue, haggis_msg *msg);
haggis_msg* haggis_mq_pop(haggis_mq *queue);
haggis_msg* haggis_mq_try_pop(haggis_mq *queue);
haggis_msg* haggis_msg_init (haggis_message_type tag, haggis_message_body body);
void haggis_msg_deinit(haggis_msg *self);
int haggis_mq_init (haggis_mq *self);
int haggis_mq_push (haggis_mq *self, haggis_msg *msg);
haggis_msg* haggis_mq_pop (haggis_mq *self);
haggis_msg* haggis_mq_try_pop(haggis_mq *self);
#endif // !MQ_H

38
jobq.c
View file

@ -33,42 +33,42 @@
#include "jobq.h"
int haggis_jobq_push(haggis_jobq *queue, haggis_job *job) {
int haggis_jobq_push(haggis_jobq *self, haggis_job *job) {
haggis_jobq_node *new = malloc(sizeof(haggis_jobq_node));
if (new == NULL)
return 1;
new->job = job;
new->next = new->prev = NULL;
pthread_mutex_lock(queue->mutex);
if (queue->tail == NULL) {
queue->tail = queue->head = new;
pthread_mutex_lock(self->mutex);
if (self->tail == NULL) {
self->tail = self->head = new;
} else {
new->next = queue->tail;
queue->tail->prev = new;
queue->tail = new;
new->next = self->tail;
self->tail->prev = new;
self->tail = new;
}
queue->count++;
pthread_mutex_unlock(queue->mutex);
self->count++;
pthread_mutex_unlock(self->mutex);
return 0;
}
haggis_job* haggis_jobq_pop(haggis_jobq *queue) {
haggis_job* haggis_jobq_pop(haggis_jobq *self) {
haggis_jobq_node *j;
haggis_job *job;
while (queue->count == 0)
pthread_cond_wait(queue->cond, queue->mutex);
pthread_mutex_lock(queue->mutex);
queue->count--;
j = queue->head;
while (self->count == 0)
pthread_cond_wait(self->cond, self->mutex);
pthread_mutex_lock(self->mutex);
self->count--;
j = self->head;
job = j->job;
if (queue->tail == queue->head) {
queue->tail = queue->head = NULL;
if (self->tail == self->head) {
self->tail = self->head = NULL;
} else {
queue->head = queue->head->prev;
self->head = self->head->prev;
}
free(j);
pthread_mutex_unlock(queue->mutex);
pthread_mutex_unlock(self->mutex);
return job;
}

66
linkmap.c
View file

@ -38,7 +38,7 @@
#include <string.h> // strndup
#define FNV64_OFFSET_BASIS 14695981039346656037u
#define FNV64_PRIME 1099511628211u
#define FNV64_PRIME 1099511628211u
uint64_t hash_fnv1a_64(uint8_t *key, size_t len) {
int i;
@ -78,38 +78,38 @@ haggis_linkmap* haggis_linkmap_init() {
return map;
}
void haggis_linkmap_deinit(haggis_linkmap *map) {
free(map->buckets);
free(map);
void haggis_linkmap_deinit(haggis_linkmap *self) {
free(self->buckets);
free(self);
}
int haggis_linkmap_expand(haggis_linkmap *map) {
int haggis_linkmap_expand(haggis_linkmap *self) {
haggis_bucket *buckets_new;
haggis_bucket *buckets_old;
size_t i, hash, idx;
buckets_new = calloc(map->capacity + HAGGIS_BUCKETS_BASE, sizeof(haggis_bucket));
buckets_new = calloc(self->capacity + HAGGIS_BUCKETS_BASE, sizeof(haggis_bucket));
if (buckets_new == NULL)
return 2;
for (i = 0; i < map->capacity + HAGGIS_BUCKETS_BASE; i++) {
map->buckets[i].path = NULL;
for (i = 0; i < self->capacity + HAGGIS_BUCKETS_BASE; i++) {
self->buckets[i].path = NULL;
}
for (i = 0; i < map->capacity; i++) {
if (map->buckets[i].key.val != 0) {
hash = hash_fnv1a_64(&map->buckets[i].key.bytes[0], sizeof(ino_t));
map ->capacity += HAGGIS_BUCKETS_BASE;
idx = map->capacity % hash;
buckets_new[idx] = map->buckets[i];
for (i = 0; i < self->capacity; i++) {
if (self->buckets[i].key.val != 0) {
hash = hash_fnv1a_64(&self->buckets[i].key.bytes[0], sizeof(ino_t));
self ->capacity += HAGGIS_BUCKETS_BASE;
idx = self->capacity % hash;
buckets_new[idx] = self->buckets[i];
}
}
buckets_old = map->buckets;
map->buckets = buckets_new;
buckets_old = self->buckets;
self->buckets = buckets_new;
free(buckets_old);
map->capacity += HAGGIS_BUCKETS_BASE;
self->capacity += HAGGIS_BUCKETS_BASE;
return 0;
}
char* haggis_linkmap_get_or_add(haggis_linkmap *map, ino_t inode, char * path) {
char* haggis_linkmap_get_or_add(haggis_linkmap *self, ino_t inode, char * path) {
union {
ino_t val;
u8 bytes[sizeof(ino_t)];
@ -117,29 +117,29 @@ char* haggis_linkmap_get_or_add(haggis_linkmap *map, ino_t inode, char * path) {
char * target = NULL;
size_t idx, hash, i;
pthread_mutex_lock(&map->mutex);
if (map->len >= map->capacity)
haggis_linkmap_expand(map);
pthread_mutex_lock(&self->mutex);
if (self->len >= self->capacity)
haggis_linkmap_expand(self);
key.val = inode;
hash = hash_fnv1a_64(key.bytes, sizeof(ino_t));
idx = hash % map->capacity;
for (i = 0; i < map->capacity; i++) {
if (map->buckets[idx].key.val == inode) {
target = strndup(map->buckets[idx].path, PATH_MAX - 1);
map->buckets[idx].path = path;
idx = hash % self->capacity;
for (i = 0; i < self->capacity; i++) {
if (self->buckets[idx].key.val == inode) {
target = strndup(self->buckets[idx].path, PATH_MAX - 1);
self->buckets[idx].path = path;
break;
} else if (map->buckets[idx].key.val == 0) {
map->buckets[idx].key.val = inode;
map->buckets[idx].hash = hash;
map->buckets[idx].path = path;
map->len++;
} else if (self->buckets[idx].key.val == 0) {
self->buckets[idx].key.val = inode;
self->buckets[idx].hash = hash;
self->buckets[idx].path = path;
self->len++;
break;
} else {
idx++;
if (idx == map->capacity)
if (idx == self->capacity)
idx = 0;
}
}
pthread_mutex_unlock(&map->mutex);
pthread_mutex_unlock(&self->mutex);
return target;
}

76
mq.c
View file

@ -46,82 +46,82 @@ haggis_msg* haggis_msg_init(haggis_message_type tag, haggis_message_body body) {
return msg;
}
void haggis_msg_deinit(haggis_msg *msg) {
switch (msg->tag) {
void haggis_msg_deinit(haggis_msg *self) {
switch (self->tag) {
case DevNodeSkipped:
case NodeCreated:
case NodeExtracted:
free(msg->body.f_name);
free(self->body.f_name);
break;
case EndOfArchive:
case ArchiveError:
break;
}
free(msg);
free(self);
}
int haggis_mq_init(haggis_mq *mq) {
int haggis_mq_init(haggis_mq *self) {
int ret;
mq->head = NULL;
mq->tail = NULL;
ret = pthread_mutex_init(&mq->mutex, NULL);
self->head = NULL;
self->tail = NULL;
ret = pthread_mutex_init(&self->mutex, NULL);
if (ret != 0)
return ret;
return pthread_cond_init(&mq->cond, NULL);
return pthread_cond_init(&self->cond, NULL);
}
int haggis_mq_push(haggis_mq *queue, haggis_msg *msg) {
pthread_mutex_lock(&queue->mutex);
if (queue->tail == NULL) {
queue->tail = queue->head = msg;
int haggis_mq_push(haggis_mq *self, haggis_msg *msg) {
pthread_mutex_lock(&self->mutex);
if (self->tail == NULL) {
self->tail = self->head = msg;
} else {
msg->next = queue->tail;
queue->tail->prev = msg;
queue->tail = msg;
msg->next = self->tail;
self->tail->prev = msg;
self->tail = msg;
}
queue->count++;
pthread_cond_broadcast(&queue->cond);
pthread_mutex_unlock(&queue->mutex);
self->count++;
pthread_cond_broadcast(&self->cond);
pthread_mutex_unlock(&self->mutex);
return 0;
}
haggis_msg* haggis_mq_pop(haggis_mq *queue) {
haggis_msg* haggis_mq_pop(haggis_mq *self) {
haggis_msg *msg;
while (queue->count == 0)
pthread_cond_wait(&queue->cond, &queue->mutex);
pthread_mutex_lock(&queue->mutex);
queue->count--;
msg = queue->head;
while (self->count == 0)
pthread_cond_wait(&self->cond, &self->mutex);
pthread_mutex_lock(&self->mutex);
self->count--;
msg = self->head;
if (msg->tag == EndOfArchive)
return msg;
if (queue->tail == queue->head) {
queue->tail = queue->head = NULL;
if (self->tail == self->head) {
self->tail = self->head = NULL;
} else {
queue->head = queue->head->prev;
self->head = self->head->prev;
}
pthread_mutex_unlock(&queue->mutex);
pthread_mutex_unlock(&self->mutex);
msg->prev = msg->next = NULL;
return msg;
}
haggis_msg* haggis_mq_try_pop(haggis_mq *queue) {
haggis_msg* haggis_mq_try_pop(haggis_mq *self) {
haggis_msg *msg;
if (queue->count == 0)
if (self->count == 0)
return NULL;
pthread_mutex_lock(&queue->mutex);
queue->count--;
msg = queue->head;
pthread_mutex_lock(&self->mutex);
self->count--;
msg = self->head;
if (msg->tag == EndOfArchive)
return msg;
if (queue->tail == queue->head) {
queue->tail = queue->head = NULL;
if (self->tail == self->head) {
self->tail = self->head = NULL;
} else {
queue->head = queue->head->prev;
self->head = self->head->prev;
}
pthread_mutex_unlock(&queue->mutex);
pthread_mutex_unlock(&self->mutex);
msg->prev = msg->next = NULL;
return msg;
}

8
test/create_dev_node.c
View file

@ -16,12 +16,12 @@ int main() {
node = haggis_create_node(path, sha256, map, &mq);
assert(node->filetype.tag == character || node->filetype.tag == block);
#if defined(__linux__)
assert(node->filetype.f_type.dev.major.val == 1);
assert(node->filetype.f_type.dev.minor.val == 3);
assert(node->filetype.dev.major.val == 1);
assert(node->filetype.dev.minor.val == 3);
#elif defined(__FreeBSD__)
assert(node->filetype.f_type.dev.major.val == 0);
assert(node->filetype.dev.major.val == 0);
#endif /* if defined (__linux__) */
haggis_node_deinit(node);
haggis_linkmap_deinit(map);
return 0;
}
}

14
test/create_file_node.c
View file

@ -12,10 +12,10 @@ int main() {
haggis_node *node;
haggis_mq mq;
char *path = "create_dev_node.c";
uint8_t sum[] = {169, 53, 195, 76, 81, 143, 0, 198, 121, 240,
35, 26, 176, 103, 200, 73, 229, 249, 238, 164,
54, 32, 101, 168, 23, 58, 200, 254, 228, 193,
215, 6};
uint8_t sum[] = { 0x69, 0x05, 0x0c, 0x52, 0x1d, 0xc9, 0x5e, 0x8d, 0x29,
0x42, 0xb3, 0x77, 0x81, 0x6f, 0x00, 0x47, 0x19, 0xd3,
0x67, 0x03, 0xd5, 0xaa, 0xce, 0x4f, 0x3f, 0x40, 0xc0,
0x52, 0x54, 0xc1, 0x5b, 0x13 };
int i;
map = haggis_linkmap_init();
@ -24,11 +24,11 @@ int main() {
node = haggis_create_node(path, sha256, map, &mq);
assert(node->filetype.tag == normal);
for (i = 0; i < 32; i++) {
assert(sum[i] == node->filetype.f_type.file.cksum.sum.sha256[i]);
assert(sum[i] == node->filetype.file.cksum.sha256[i]);
}
assert(node->filetype.f_type.file.len.val == 746);
assert(node->filetype.file.len.val == 726);
assert(memcmp(path, node->name.name, 17) == 0);
haggis_node_deinit(node);
haggis_linkmap_deinit(map);
return 0;
}
}

4
test/create_symlink_node.c
View file

@ -19,8 +19,8 @@ int main() {
node = haggis_create_node(path, sha256, map, &mq);
assert(node->filetype.tag == softlink);
assert(memcmp(path, node->name.name, 10) == 0);
assert(memcmp(node->filetype.f_type.target.name, "device", 6) == 0);
assert(memcmp(node->filetype.target.name, "device", 6) == 0);
haggis_node_deinit(node);
haggis_linkmap_deinit(map);
return 0;
}
}

4
test/extract_dev_node.c
View file

@ -31,7 +31,7 @@ int main() {
assert(msg->tag == NodeCreated);
assert(memcmp(msg->body.f_name, "dev/null", 8) == 0);
haggis_msg_deinit(msg);
ret = haggis_extract_node("output/extracted", node, &mq);
ret = haggis_extract_node(node, "output/extracted", &mq);
msg = haggis_mq_pop(&mq);
assert(msg->tag == NodeExtracted);
assert(memcmp(msg->body.f_name, "dev/null", 8) == 0);
@ -39,4 +39,4 @@ int main() {
haggis_node_deinit(node);
haggis_linkmap_deinit(map);
return 0;
}
}

4
test/extract_dir_node.c
View file

@ -24,7 +24,7 @@ int main() {
assert(msg->tag == NodeCreated);
assert(memcmp(msg->body.f_name, path, 6) == 0);
haggis_msg_deinit(msg);
ret = haggis_extract_node("output/extracted", node, &mq);
ret = haggis_extract_node(node, "output/extracted", &mq);
assert(ret == 0);
msg = haggis_mq_pop(&mq);
assert(msg->tag == NodeExtracted);
@ -33,4 +33,4 @@ int main() {
haggis_node_deinit(node);
haggis_linkmap_deinit(map);
return 0;
}
}

4
test/extract_fifo_node.c
View file

@ -20,7 +20,7 @@ int main() {
assert(node != NULL);
assert(node->filetype.tag == fifo);
assert(memcmp(node->name.name, path, 11) == 0);
ret = haggis_extract_node("output/extracted", node, &mq);
ret = haggis_extract_node(node, "output/extracted", &mq);
assert(ret == 0);
msg = haggis_mq_pop(&mq);
assert(msg->tag == NodeCreated);
@ -35,4 +35,4 @@ int main() {
haggis_node_deinit(node);
haggis_linkmap_deinit(map);
return 0;
}
}

2
test/extract_file_node.c
View file

@ -20,7 +20,7 @@ int main() {
assert(node != NULL);
assert(node->filetype.tag == normal);
assert(memcmp(node->name.name, inf, 8) == 0);
ret = haggis_extract_node("output/extracted", node, &mq);
ret = haggis_extract_node(node, "output/extracted", &mq);
assert(ret == 0);
msg = haggis_mq_pop(&mq);
assert(msg->tag == NodeCreated);

4
test/extract_hardlink_node.c
View file

@ -33,10 +33,10 @@ int main() {
assert(node1 != NULL);
assert(node1->filetype.tag == hardlink);
assert(memcmp(node1->name.name, lnk, 15) == 0);
ret = haggis_extract_node("output/extracted", node0, &mq);
ret = haggis_extract_node(node0, "output/extracted", &mq);
assert(ret == 0);
haggis_node_deinit(node0);
ret = haggis_extract_node("output/extracted", node1, &mq);
ret = haggis_extract_node(node1, "output/extracted", &mq);
assert(ret == 0);
haggis_node_deinit(node1);
msg = haggis_mq_pop(&mq);

4
test/extract_symlink_node.c
View file

@ -23,8 +23,8 @@ int main() {
assert(node != NULL);
assert(node->filetype.tag == softlink);
assert(memcmp(node->name.name, lnk, 14) == 0);
assert(memcmp(node->filetype.f_type.target.name, tgt, 11) == 0);
ret = haggis_extract_node("output/extracted", node, &mq);
assert(memcmp(node->filetype.target.name, tgt, 11) == 0);
ret = haggis_extract_node(node, "output/extracted", &mq);
assert(ret == 0);
msg = haggis_mq_pop(&mq);
assert(msg->tag == NodeCreated);

2
test/init_file_md5.c
View file

@ -10,5 +10,5 @@ int main() {
assert(haggis_file_init(f, &hf, md5) == 0);
assert(hf.cksum.tag == md5);
assert(memcmp(buf, hf.cksum.sum.md5, 16) == 0);
assert(memcmp(buf, hf.cksum.md5, 16) == 0);
}

3
test/init_file_sha1.c
View file

@ -11,6 +11,5 @@ int main() {
assert(haggis_file_init(f, &hf, sha1) == 0);
assert(hf.cksum.tag == sha1);
assert(memcmp(buf, hf.cksum.sum.sha1, 20) == 0);
assert(memcmp(buf, hf.cksum.sha1, 20) == 0);
}

2
test/init_file_sha256.c
View file

@ -12,6 +12,6 @@ int main() {
assert(haggis_file_init(f, &hf, sha256) == 0);
assert(hf.cksum.tag == sha256);
assert(memcmp(buf, hf.cksum.sum.sha256, 32) == 0);
assert(memcmp(buf, hf.cksum.sha256, 32) == 0);
}

2
test/load_md5.c
View file

@ -13,7 +13,7 @@ int main() {
if (haggis_load_cksum(f, &cksum)) return 1;
assert(cksum.tag == md5);
for (i = 0; i < 16; i++) {
assert(cksum.sum.md5[i] == (uint8_t)i);
assert(cksum.md5[i] == (uint8_t)i);
}
fclose(f);
}

2
test/load_sha1.c
View file

@ -13,7 +13,7 @@ int main() {
if (haggis_load_cksum(f, &cksum)) return 1;
assert(cksum.tag == sha1);
for (i = 0; i < 20; i++) {
assert(cksum.sum.sha1[i] == (uint8_t)i);
assert(cksum.sha1[i] == (uint8_t)i);
}
fclose(f);
}

2
test/load_sha256.c
View file

@ -13,7 +13,7 @@ int main() {
if (haggis_load_cksum(f, &cksum)) return 1;
assert(cksum.tag == sha256);
for (i = 0; i < 32; i++) {
assert(cksum.sum.sha256[i] == (uint8_t)i);
assert(cksum.sha256[i] == (uint8_t)i);
}
fclose(f);
}

8
test/store_device.c
View file

@ -2,14 +2,14 @@
#include <stdio.h>
int main() {
haggis_device dev;
FILE *f;
int ret;
haggis_device dev;
FILE *f;
int ret;
dev.major.val = 42;
dev.minor.val = 69;
f = fopen("output/device", "w");
ret = haggis_store_device(f, &dev);
ret = haggis_store_device(&dev, f);
fflush(f);
fclose(f);
return ret;

2
test/store_md5.c
View file

@ -10,7 +10,7 @@ int main() {
cksum.tag = md5;
for (i = 0; i < 16; i++) {
cksum.sum.md5[i] = (uint8_t)i;
cksum.md5[i] = (uint8_t)i;
}
f = fopen("output/md5", "w");
ret = haggis_store_cksum(f, &cksum);

2
test/store_sha1.c
View file

@ -10,7 +10,7 @@ int main() {
cksum.tag = sha1;
for (i = 0; i < 20; i++) {
cksum.sum.md5[i] = (uint8_t)i;
cksum.md5[i] = (uint8_t)i;
}
f = fopen("output/sha1", "w");
ret = haggis_store_cksum(f, &cksum);

2
test/store_sha256.c
View file

@ -10,7 +10,7 @@ int main() {
cksum.tag = sha256;
for (i = 0; i < 32; i++) {
cksum.sum.sha256[i] = (uint8_t)i;
cksum.sha256[i] = (uint8_t)i;
}
f = fopen("output/sha256", "w");
ret = haggis_store_cksum(f, &cksum);