trunk/uar/uar.c

#define _XOPEN_SOURCE 500

#include "uar.h"
#include "malloc.h"

#include <assert.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

#if defined(__linux__)
#    include <linux/limits.h>
#elif defined(__APPLE__)
#    include <sys/syslimits.h>
#else
#    include <limits.h>
#endif

const unsigned char UAR_MAGIC[] = { 0x99, 'U', 'A', 'R' };

struct uar_header
{
    uint8_t magic[4];
    uint16_t version;
    uint32_t flags;
    uint64_t nfiles;
    uint64_t size;
} __attribute__ ((packed));

enum uar_file_type
{
    UF_FILE,
    UF_DIR,
    UF_LINK,
};

struct uar_file
{
    enum uar_file_type type;
    char *name;
    uint64_t namelen;
    uint32_t offset;
    union
    {
        uint64_t size;
        struct
        {
            char *loc;
            uint64_t loclen;
        } linkinfo;
    } data;
    mode_t mode;
};

struct uar_archive
{
    struct uar_header header;
    struct uar_file **files;
    enum uar_error ecode;
    bool is_stream;
    uint8_t *buffer;
};

static void *
uar_set_error (struct uar_archive *uar, enum uar_error ecode)
{
    uar->ecode = ecode;
    return NULL;
}

const char *
uar_strerror (const struct uar_archive *restrict uar)
{
    switch (uar->ecode)
        {
        case UAR_SUCCESS:
            return "success";
        case UAR_INVALID_MAGIC:
            return "invalid archive magic";
        case UAR_INVALID_FILE:
            return "invalid file";
        case UAR_INVALID_PATH:
            return "invalid path string";
        case UAR_IO_ERROR:
            return "archive I/O error";
        case UAR_OUT_OF_MEMORY:
            return "out of memory";
        case UAR_INVALID_ARGUMENT:
            return "invalid argument";
        case UAR_INVALID_OPERATION:
            return "invalid operation";
        default:
            return "unknown error";
        }
}

bool
uar_has_error (const struct uar_archive *restrict uar)
{
    return uar->ecode != UAR_SUCCESS;
}

struct uar_archive *
uar_open (const char *filename)
{
    struct uar_archive *uar = NULL;
    FILE *stream = NULL;
    int cerrno;

    errno = 0;
    uar = malloc (sizeof (struct uar_archive));

    if (uar == NULL)
        return NULL;

    stream = fopen (filename, "rb");

    if (stream == NULL)
        {
            uar_set_error (uar, UAR_IO_ERROR);
            goto uar_open_ret;
        }

    fseek (stream, 0, SEEK_END);
    size_t size = ftell (stream);
    fseek (stream, 0, SEEK_SET);

    if (fread (&uar->header, sizeof (struct uar_header), 1, stream) != 1)
        {
            uar_set_error (uar, UAR_IO_ERROR);
            goto uar_open_ret;
        }

    if (memcmp (uar->header.magic, UAR_MAGIC, 4) != 0)
        {
            uar_set_error (uar, UAR_INVALID_MAGIC);
            goto uar_open_ret;
        }

    uint64_t filearr_size = uar->header.nfiles * sizeof (struct uar_file);

    if (filearr_size > size)
        {
            uar_set_error (uar, UAR_IO_ERROR);
            goto uar_open_ret;
        }

    if (uar->header.size > size)
        {
            uar_set_error (uar, UAR_IO_ERROR);
            goto uar_open_ret;
        }

    uar->files = calloc (uar->header.nfiles, sizeof (struct uar_file *));

    if (uar->files == NULL)
        {
            uar_set_error (uar, UAR_OUT_OF_MEMORY);
            goto uar_open_ret;
        }

    for (uint64_t i = 0; i < uar->header.nfiles; i++)
        {
            struct uar_file *file = malloc (sizeof (struct uar_file));

            if (file == NULL)
                {
                    uar_set_error (uar, UAR_OUT_OF_MEMORY);
                    goto uar_open_ret;
                }

            if (fread (file, sizeof (struct uar_file), 1, stream) != 1)
                {
                    uar_set_error (uar, UAR_IO_ERROR);
                    goto uar_open_ret;
                }

            if (file->namelen > PATH_MAX)
                {
                    uar_set_error (uar, UAR_INVALID_PATH);
                    goto uar_open_ret;
                }

            file->name = malloc (file->namelen);

            if (file->name == NULL)
                {
                    uar_set_error (uar, UAR_OUT_OF_MEMORY);
                    goto uar_open_ret;
                }

            if (fread (file->name, 1, file->namelen, stream) != file->namelen)
                {
                    uar_set_error (uar, UAR_IO_ERROR);
                    goto uar_open_ret;
                }

            uar->files[i] = file;
        }

    uar->buffer = malloc (uar->header.size + 1);

    if (uar->buffer == NULL)
        {
            uar_set_error (uar, UAR_OUT_OF_MEMORY);
            goto uar_open_ret;
        }

    if (fread (uar->buffer, 1, uar->header.size, stream) != uar->header.size)
        {
            uar_set_error (uar, UAR_IO_ERROR);
            goto uar_open_ret;
        }

uar_open_ret:
    cerrno = errno;
    fclose (stream);
    errno = cerrno;
    return uar;
}

void
uar_close (struct uar_archive *uar)
{
    if (uar == NULL)
        return;

    free (uar->buffer);
    free (uar->files);
    free (uar);
}

struct uar_archive *
uar_create ()
{
    struct uar_archive *uar = malloc (sizeof (struct uar_archive));

    if (uar == NULL)
        return NULL;

    uar->is_stream = false;
    uar->buffer = NULL;
    uar->header.size = sizeof (struct uar_header);
    memcpy (uar->header.magic, UAR_MAGIC, 4);
    uar->header.version = 1;
    uar->header.flags = 0;
    uar->header.nfiles = 0;

    return uar;
}

bool
uar_add_file_entry (struct uar_archive *restrict uar, struct uar_file *file)
{
    if (uar == NULL || file == NULL)
        {
            uar_set_error (uar, UAR_INVALID_ARGUMENT);
            return false;
        }

    uar->files = realloc (uar->files,
                          (uar->header.nfiles + 1) * sizeof (struct uar_file));

    if (uar->files == NULL)
        {
            uar_set_error (uar, UAR_OUT_OF_MEMORY);
            return false;
        }

    uar->files[uar->header.nfiles] = file;
    uar->header.nfiles++;
    return true;
}

struct uar_file *
uar_file_create (const char *name, uint64_t namelen, uint64_t size,
                 uint32_t offset)
{
    struct uar_file *file;
    assert (namelen < PATH_MAX);

    file = malloc (sizeof (struct uar_file));

    if (file == NULL)
        return NULL;

    file->type = UF_FILE;
    file->mode = 0644;
    file->name = malloc (namelen + 1);

    if (file->name == NULL)
        {
            free (file);
            return NULL;
        }

    file->name[namelen] = 0;
    file->namelen = namelen;
    file->data.size = size;
    file->offset = offset;

    strncpy (file->name, name, namelen);
    return file;
}

void
uar_file_destroy (struct uar_file *file)
{
    if (file == NULL)
        return;

    free (file->name);
    free (file);
}

struct uar_file *
uar_add_file (struct uar_archive *restrict uar, const char *name,
              const char *path)
{
    assert (uar != NULL && "uar is NULL");
    assert (name != NULL && "name is NULL");
    assert (path != NULL && "path is NULL");
    assert (!uar->is_stream && "uar in non-stream mode is not supported yet");

    uint64_t namelen = strlen (name);

    if (namelen >= PATH_MAX)
        {
            uar_set_error (uar, UAR_INVALID_PATH);
            return NULL;
        }

    FILE *stream = fopen (path, "rb");

    if (stream == NULL)
        {
            uar_set_error (uar, UAR_IO_ERROR);
            return NULL;
        }

    fseek (stream, 0, SEEK_END);
    uint64_t size = ftell (stream);
    fseek (stream, 0, SEEK_SET);

    struct uar_file *file
        = uar_file_create (name, namelen, size, uar->header.size);

    if (file == NULL)
        {
            uar_set_error (uar, UAR_OUT_OF_MEMORY);
            fclose (stream);
            return NULL;
        }

    uar->header.size += size;

    if (!uar_add_file_entry (uar, file))
        {
            uar_file_destroy (file);
            fclose (stream);
            return NULL;
        }

    uar->buffer = realloc (uar->buffer, uar->header.size);

    if (uar->buffer == NULL)
        {
            uar_set_error (uar, UAR_OUT_OF_MEMORY);
            fclose (stream);
            return NULL;
        }

    if (fread (uar->buffer + file->offset, size, 1, stream) != 1)
        {
            uar_set_error (uar, UAR_IO_ERROR);
            fclose (stream);
            return NULL;
        }

    fclose (stream);
    return file;
}

static char *
path_concat (const char *p1, const char *p2, size_t len1, size_t len2)
{
    char *path = malloc (len1 + len2 + 2);

    if (path == NULL)
        return NULL;

    strncpy (path, p1, len1);
    path[len1] = '/';
    strncpy (path + len1 + 1, p2, len2);
    path[len1 + len2 + 1] = 0;
    return path;
}

struct uar_file *
uar_add_dir (struct uar_archive *uar, const char *name, const char *path)
{
    assert (uar != NULL && "uar is NULL");
    assert (name != NULL && "name is NULL");
    assert (path != NULL && "path is NULL");
    assert (!uar->is_stream && "uar in non-stream mode is not supported yet");

    uint64_t namelen = strlen (name);

    if (namelen >= PATH_MAX)
        {
            uar_set_error (uar, UAR_INVALID_PATH);
            return NULL;
        }

    DIR *dir = opendir (path);
    struct dirent *entry = NULL;

    if (dir == NULL)
        {
            uar_set_error (uar, UAR_INVALID_FILE);
            return NULL;
        }

    struct uar_file *dir_file
        = uar_file_create (name, namelen, 0, uar->header.size);
    uint64_t dir_size = 0;

    if (!uar_add_file_entry (uar, dir_file))
        {
            uar_file_destroy (dir_file);
            return NULL;
        }

    while ((entry = readdir (dir)) != NULL)
        {
            if (strcmp (entry->d_name, ".") == 0
                || strcmp (entry->d_name, "..") == 0)
                continue;

            struct stat stinfo = { 0 };

            if (256 + namelen >= PATH_MAX)
                {
                    uar_set_error (uar, UAR_INVALID_PATH);
                    uar_file_destroy (dir_file);
                    closedir (dir);
                    return NULL;
                }

            uint64_t dnamelen = strlen (entry->d_name);

            char *fullpath
                = path_concat (path, entry->d_name, strlen (path), dnamelen);
            assert (fullpath != NULL);

            char *fullname
                = path_concat (name, entry->d_name, namelen, dnamelen);
            assert (fullname != NULL);

            if (stat (fullpath, &stinfo) != 0)
                {
                    int current_errno = errno;
                    uar_set_error (uar, UAR_IO_ERROR);
                    uar_file_destroy (dir_file);
                    closedir (dir);
                    free (fullpath);
                    free (fullname);
                    errno = current_errno;
                    return NULL;
                }

            if (S_ISREG (stinfo.st_mode))
                {
                    struct uar_file *file
                        = uar_add_file (uar, fullname, fullpath);

                    if (file == NULL)
                        {
                            int current_errno = errno;
                            uar_file_destroy (dir_file);
                            closedir (dir);
                            free (fullpath);
                            free (fullname);
                            errno = current_errno;
                            return NULL;
                        }

                    file->mode = stinfo.st_mode & 07777;
                    dir_size += file->data.size;
                }
            else if (S_ISDIR (stinfo.st_mode))
                {
                    struct uar_file *direntry
                        = uar_add_dir (uar, fullname, fullpath);

                    if (direntry == NULL)
                        {
                            int current_errno = errno;
                            uar_file_destroy (dir_file);
                            closedir (dir);
                            free (fullpath);
                            free (fullname);
                            errno = current_errno;
                            return NULL;
                        }

                    direntry->mode = stinfo.st_mode & 07777;
                    dir_size += direntry->data.size;
                }
            else
                assert (false && "Not supported");

            free (fullpath);
        }

    closedir (dir);

    dir_file->type = UF_DIR;
    dir_file->data.size = dir_size;

    return dir_file;
}

void
uar_file_set_mode (struct uar_file *file, mode_t mode)
{
    file->mode = mode;
}

static void
uar_debug_print_file (const struct uar_archive *uar, struct uar_file *file,
                      bool print_contents)
{
    printf ("    size: %lu\n", file->data.size);

    if (print_contents)
        {
            printf ("    contents:\n");
            printf ("==================\n");
            fflush (stdout);

            ssize_t size = write (STDOUT_FILENO, uar->buffer + file->offset,
                                  file->data.size);

            if (size == -1 || ((uint64_t) size) != file->data.size)
                {
                    perror ("write");
                    return;
                }

            putchar ('\n');
            printf ("==================\n");
        }
}

void
uar_debug_print (const struct uar_archive *uar, bool print_file_contents)
{
    printf ("uar_archive:\n");
    printf ("  magic: %02x %02x %02x %02x\n", uar->header.magic[0],
            uar->header.magic[1], uar->header.magic[2], uar->header.magic[3]);
    printf ("  version: %u\n", uar->header.version);
    printf ("  flags: %u\n", uar->header.flags);
    printf ("  nfiles: %lu\n", uar->header.nfiles);
    printf ("  size: %lu\n", uar->header.size);
    printf ("  stream?: %i\n", uar->is_stream);

    for (uint64_t i = 0; i < uar->header.nfiles; i++)
        {
            struct uar_file *file = uar->files[i];

            printf ("  %s[%lu]:\n",
                    file->type == UF_FILE  ? "file"
                    : file->type == UF_DIR ? "directory"
                                           : "link",
                    i);
            printf ("    name: \033[1m%s%s\033[0m\n", file->name,
                    file->type == UF_DIR    ? "/"
                    : file->type == UF_LINK ? "@"
                                            : "");
            printf ("    offset: %u\n", file->offset);
            printf ("    mode: %04o\n", file->mode);

            switch (file->type)
                {
                case UF_FILE:
                    uar_debug_print_file (uar, file, print_file_contents);
                    break;

                case UF_DIR:
                    printf ("    size: %lu\n", file->data.size);
                    break;

                default:
                    printf ("  info: unknown file type\n");
                    break;
                }
        }
}

bool
uar_write (struct uar_archive *uar, const char *filename)
{
    FILE *stream = fopen (filename, "wb");

    if (stream == NULL)
        {
            uar_set_error (uar, UAR_IO_ERROR);
            return false;
        }

    if (fwrite (&uar->header, sizeof (struct uar_header), 1, stream) != 1)
        {
            uar_set_error (uar, UAR_IO_ERROR);
            fclose (stream);
            return false;
        }

    for (uint64_t i = 0; i < uar->header.nfiles; i++)
        {
            struct uar_file *file = uar->files[i];

            if (fwrite (file, sizeof (struct uar_file), 1, stream) != 1)
                {
                    uar_set_error (uar, UAR_IO_ERROR);
                    fclose (stream);
                    return false;
                }

            if (fwrite (file->name, 1, file->namelen, stream) != file->namelen)
                {
                    uar_set_error (uar, UAR_IO_ERROR);
                    fclose (stream);
                    return false;
                }
        }

    if (fwrite (uar->buffer, uar->header.size, 1, stream) != 1)
        {
            uar_set_error (uar, UAR_IO_ERROR);
            fclose (stream);
            return false;
        }

    fclose (stream);
    return true;
}

const char *
uar_get_file_name (const struct uar_file *file)
{
    return file->name;
}

bool
uar_extract (struct uar_archive *uar, const char *cwd,
             bool (*callback) (struct uar_file *file))
{
    if (cwd != NULL && chdir (cwd) != 0)
        {
            uar_set_error (uar, UAR_SYSTEM_ERROR);
            return false;
        }

    for (uint64_t i = 0; i < uar->header.nfiles; i++)
        {
            struct uar_file *file = uar->files[i];

            if (callback != NULL && !callback (file))
                return false;

            switch (file->type)
                {
                case UF_FILE:
                    {
                        FILE *stream = fopen (file->name, "wb");

                        if (stream == NULL)
                            {
                                uar_set_error (uar, UAR_IO_ERROR);
                                return false;
                            }

                        if (fwrite (uar->buffer + file->offset, 1,
                                    file->data.size, stream)
                            != file->data.size)
                            {
                                uar_set_error (uar, UAR_IO_ERROR);
                                return false;
                            }

                        fchmod (fileno (stream), file->mode);
                        fclose (stream);
                    }
                    break;

                case UF_DIR:
                    if (mkdir (file->name, file->mode) != 0)
                        {
                            uar_set_error (uar, UAR_SYSTEM_ERROR);
                            return false;
                        }

                    break;

                default:
                    assert (false && "unknown file type");
                    return false;
                }
        }

    return true;
}
1	#define _XOPEN_SOURCE 500
2
3	#include "uar.h"
4	#include "malloc.h"
5
6	#include <assert.h>
7	#include <dirent.h>
8	#include <errno.h>
9	#include <fcntl.h>
10	#include <stdbool.h>
11	#include <stdint.h>
12	#include <stdio.h>
13	#include <stdlib.h>
14	#include <string.h>
15	#include <sys/stat.h>
16	#include <sys/types.h>
17	#include <unistd.h>
18
19	#if defined(__linux__)
20	# include <linux/limits.h>
21	#elif defined(__APPLE__)
22	# include <sys/syslimits.h>
23	#else
24	# include <limits.h>
25	#endif
26
27	const unsigned char UAR_MAGIC[] = { 0x99, 'U', 'A', 'R' };
28
29	struct uar_header
30	{
31	uint8_t magic[4];
32	uint16_t version;
33	uint32_t flags;
34	uint64_t nfiles;
35	uint64_t size;
36	} __attribute__ ((packed));
37
38	enum uar_file_type
39	{
40	UF_FILE,
41	UF_DIR,
42	UF_LINK,
43	};
44
45	struct uar_file
46	{
47	enum uar_file_type type;
48	char *name;
49	uint64_t namelen;
50	uint32_t offset;
51	union
52	{
53	uint64_t size;
54	struct
55	{
56	char *loc;
57	uint64_t loclen;
58	} linkinfo;
59	} data;
60	mode_t mode;
61	};
62
63	struct uar_archive
64	{
65	struct uar_header header;
66	struct uar_file **files;
67	enum uar_error ecode;
68	bool is_stream;
69	uint8_t *buffer;
70	};
71
72	static void *
73	uar_set_error (struct uar_archive *uar, enum uar_error ecode)
74	{
75	uar->ecode = ecode;
76	return NULL;
77	}
78
79	const char *
80	uar_strerror (const struct uar_archive *restrict uar)
81	{
82	switch (uar->ecode)
83	{
84	case UAR_SUCCESS:
85	return "success";
86	case UAR_INVALID_MAGIC:
87	return "invalid archive magic";
88	case UAR_INVALID_FILE:
89	return "invalid file";
90	case UAR_INVALID_PATH:
91	return "invalid path string";
92	case UAR_IO_ERROR:
93	return "archive I/O error";
94	case UAR_OUT_OF_MEMORY:
95	return "out of memory";
96	case UAR_INVALID_ARGUMENT:
97	return "invalid argument";
98	case UAR_INVALID_OPERATION:
99	return "invalid operation";
100	default:
101	return "unknown error";
102	}
103	}
104
105	bool
106	uar_has_error (const struct uar_archive *restrict uar)
107	{
108	return uar->ecode != UAR_SUCCESS;
109	}
110
111	struct uar_archive *
112	uar_open (const char *filename)
113	{
114	struct uar_archive *uar = NULL;
115	FILE *stream = NULL;
116	int cerrno;
117
118	errno = 0;
119	uar = malloc (sizeof (struct uar_archive));
120
121	if (uar == NULL)
122	return NULL;
123
124	stream = fopen (filename, "rb");
125
126	if (stream == NULL)
127	{
128	uar_set_error (uar, UAR_IO_ERROR);
129	goto uar_open_ret;
130	}
131
132	fseek (stream, 0, SEEK_END);
133	size_t size = ftell (stream);
134	fseek (stream, 0, SEEK_SET);
135
136	if (fread (&uar->header, sizeof (struct uar_header), 1, stream) != 1)
137	{
138	uar_set_error (uar, UAR_IO_ERROR);
139	goto uar_open_ret;
140	}
141
142	if (memcmp (uar->header.magic, UAR_MAGIC, 4) != 0)
143	{
144	uar_set_error (uar, UAR_INVALID_MAGIC);
145	goto uar_open_ret;
146	}
147
148	uint64_t filearr_size = uar->header.nfiles * sizeof (struct uar_file);
149
150	if (filearr_size > size)
151	{
152	uar_set_error (uar, UAR_IO_ERROR);
153	goto uar_open_ret;
154	}
155
156	if (uar->header.size > size)
157	{
158	uar_set_error (uar, UAR_IO_ERROR);
159	goto uar_open_ret;
160	}
161
162	uar->files = calloc (uar->header.nfiles, sizeof (struct uar_file *));
163
164	if (uar->files == NULL)
165	{
166	uar_set_error (uar, UAR_OUT_OF_MEMORY);
167	goto uar_open_ret;
168	}
169
170	for (uint64_t i = 0; i < uar->header.nfiles; i++)
171	{
172	struct uar_file *file = malloc (sizeof (struct uar_file));
173
174	if (file == NULL)
175	{
176	uar_set_error (uar, UAR_OUT_OF_MEMORY);
177	goto uar_open_ret;
178	}
179
180	if (fread (file, sizeof (struct uar_file), 1, stream) != 1)
181	{
182	uar_set_error (uar, UAR_IO_ERROR);
183	goto uar_open_ret;
184	}
185
186	if (file->namelen > PATH_MAX)
187	{
188	uar_set_error (uar, UAR_INVALID_PATH);
189	goto uar_open_ret;
190	}
191
192	file->name = malloc (file->namelen);
193
194	if (file->name == NULL)
195	{
196	uar_set_error (uar, UAR_OUT_OF_MEMORY);
197	goto uar_open_ret;
198	}
199
200	if (fread (file->name, 1, file->namelen, stream) != file->namelen)
201	{
202	uar_set_error (uar, UAR_IO_ERROR);
203	goto uar_open_ret;
204	}
205
206	uar->files[i] = file;
207	}
208
209	uar->buffer = malloc (uar->header.size + 1);
210
211	if (uar->buffer == NULL)
212	{
213	uar_set_error (uar, UAR_OUT_OF_MEMORY);
214	goto uar_open_ret;
215	}
216
217	if (fread (uar->buffer, 1, uar->header.size, stream) != uar->header.size)
218	{
219	uar_set_error (uar, UAR_IO_ERROR);
220	goto uar_open_ret;
221	}
222
223	uar_open_ret:
224	cerrno = errno;
225	fclose (stream);
226	errno = cerrno;
227	return uar;
228	}
229
230	void
231	uar_close (struct uar_archive *uar)
232	{
233	if (uar == NULL)
234	return;
235
236	free (uar->buffer);
237	free (uar->files);
238	free (uar);
239	}
240
241	struct uar_archive *
242	uar_create ()
243	{
244	struct uar_archive *uar = malloc (sizeof (struct uar_archive));
245
246	if (uar == NULL)
247	return NULL;
248
249	uar->is_stream = false;
250	uar->buffer = NULL;
251	uar->header.size = sizeof (struct uar_header);
252	memcpy (uar->header.magic, UAR_MAGIC, 4);
253	uar->header.version = 1;
254	uar->header.flags = 0;
255	uar->header.nfiles = 0;
256
257	return uar;
258	}
259
260	bool
261	uar_add_file_entry (struct uar_archive restrict uar, struct uar_file file)
262	{
263	if (uar == NULL \|\| file == NULL)
264	{
265	uar_set_error (uar, UAR_INVALID_ARGUMENT);
266	return false;
267	}
268
269	uar->files = realloc (uar->files,
270	(uar->header.nfiles + 1) * sizeof (struct uar_file));
271
272	if (uar->files == NULL)
273	{
274	uar_set_error (uar, UAR_OUT_OF_MEMORY);
275	return false;
276	}
277
278	uar->files[uar->header.nfiles] = file;
279	uar->header.nfiles++;
280	return true;
281	}
282
283	struct uar_file *
284	uar_file_create (const char *name, uint64_t namelen, uint64_t size,
285	uint32_t offset)
286	{
287	struct uar_file *file;
288	assert (namelen < PATH_MAX);
289
290	file = malloc (sizeof (struct uar_file));
291
292	if (file == NULL)
293	return NULL;
294
295	file->type = UF_FILE;
296	file->mode = 0644;
297	file->name = malloc (namelen + 1);
298
299	if (file->name == NULL)
300	{
301	free (file);
302	return NULL;
303	}
304
305	file->name[namelen] = 0;
306	file->namelen = namelen;
307	file->data.size = size;
308	file->offset = offset;
309
310	strncpy (file->name, name, namelen);
311	return file;
312	}
313
314	void
315	uar_file_destroy (struct uar_file *file)
316	{
317	if (file == NULL)
318	return;
319
320	free (file->name);
321	free (file);
322	}
323
324	struct uar_file *
325	uar_add_file (struct uar_archive restrict uar, const char name,
326	const char *path)
327	{
328	assert (uar != NULL && "uar is NULL");
329	assert (name != NULL && "name is NULL");
330	assert (path != NULL && "path is NULL");
331	assert (!uar->is_stream && "uar in non-stream mode is not supported yet");
332
333	uint64_t namelen = strlen (name);
334
335	if (namelen >= PATH_MAX)
336	{
337	uar_set_error (uar, UAR_INVALID_PATH);
338	return NULL;
339	}
340
341	FILE *stream = fopen (path, "rb");
342
343	if (stream == NULL)
344	{
345	uar_set_error (uar, UAR_IO_ERROR);
346	return NULL;
347	}
348
349	fseek (stream, 0, SEEK_END);
350	uint64_t size = ftell (stream);
351	fseek (stream, 0, SEEK_SET);
352
353	struct uar_file *file
354	= uar_file_create (name, namelen, size, uar->header.size);
355
356	if (file == NULL)
357	{
358	uar_set_error (uar, UAR_OUT_OF_MEMORY);
359	fclose (stream);
360	return NULL;
361	}
362
363	uar->header.size += size;
364
365	if (!uar_add_file_entry (uar, file))
366	{
367	uar_file_destroy (file);
368	fclose (stream);
369	return NULL;
370	}
371
372	uar->buffer = realloc (uar->buffer, uar->header.size);
373
374	if (uar->buffer == NULL)
375	{
376	uar_set_error (uar, UAR_OUT_OF_MEMORY);
377	fclose (stream);
378	return NULL;
379	}
380
381	if (fread (uar->buffer + file->offset, size, 1, stream) != 1)
382	{
383	uar_set_error (uar, UAR_IO_ERROR);
384	fclose (stream);
385	return NULL;
386	}
387
388	fclose (stream);
389	return file;
390	}
391
392	static char *
393	path_concat (const char p1, const char p2, size_t len1, size_t len2)
394	{
395	char *path = malloc (len1 + len2 + 2);
396
397	if (path == NULL)
398	return NULL;
399
400	strncpy (path, p1, len1);
401	path[len1] = '/';
402	strncpy (path + len1 + 1, p2, len2);
403	path[len1 + len2 + 1] = 0;
404	return path;
405	}
406
407	struct uar_file *
408	uar_add_dir (struct uar_archive uar, const char name, const char *path)
409	{
410	assert (uar != NULL && "uar is NULL");
411	assert (name != NULL && "name is NULL");
412	assert (path != NULL && "path is NULL");
413	assert (!uar->is_stream && "uar in non-stream mode is not supported yet");
414
415	uint64_t namelen = strlen (name);
416
417	if (namelen >= PATH_MAX)
418	{
419	uar_set_error (uar, UAR_INVALID_PATH);
420	return NULL;
421	}
422
423	DIR *dir = opendir (path);
424	struct dirent *entry = NULL;
425
426	if (dir == NULL)
427	{
428	uar_set_error (uar, UAR_INVALID_FILE);
429	return NULL;
430	}
431
432	struct uar_file *dir_file
433	= uar_file_create (name, namelen, 0, uar->header.size);
434	uint64_t dir_size = 0;
435
436	if (!uar_add_file_entry (uar, dir_file))
437	{
438	uar_file_destroy (dir_file);
439	return NULL;
440	}
441
442	while ((entry = readdir (dir)) != NULL)
443	{
444	if (strcmp (entry->d_name, ".") == 0
445	\|\| strcmp (entry->d_name, "..") == 0)
446	continue;
447
448	struct stat stinfo = { 0 };
449
450	if (256 + namelen >= PATH_MAX)
451	{
452	uar_set_error (uar, UAR_INVALID_PATH);
453	uar_file_destroy (dir_file);
454	closedir (dir);
455	return NULL;
456	}
457
458	uint64_t dnamelen = strlen (entry->d_name);
459
460	char *fullpath
461	= path_concat (path, entry->d_name, strlen (path), dnamelen);
462	assert (fullpath != NULL);
463
464	char *fullname
465	= path_concat (name, entry->d_name, namelen, dnamelen);
466	assert (fullname != NULL);
467
468	if (stat (fullpath, &stinfo) != 0)
469	{
470	int current_errno = errno;
471	uar_set_error (uar, UAR_IO_ERROR);
472	uar_file_destroy (dir_file);
473	closedir (dir);
474	free (fullpath);
475	free (fullname);
476	errno = current_errno;
477	return NULL;
478	}
479
480	if (S_ISREG (stinfo.st_mode))
481	{
482	struct uar_file *file
483	= uar_add_file (uar, fullname, fullpath);
484
485	if (file == NULL)
486	{
487	int current_errno = errno;
488	uar_file_destroy (dir_file);
489	closedir (dir);
490	free (fullpath);
491	free (fullname);
492	errno = current_errno;
493	return NULL;
494	}
495
496	file->mode = stinfo.st_mode & 07777;
497	dir_size += file->data.size;
498	}
499	else if (S_ISDIR (stinfo.st_mode))
500	{
501	struct uar_file *direntry
502	= uar_add_dir (uar, fullname, fullpath);
503
504	if (direntry == NULL)
505	{
506	int current_errno = errno;
507	uar_file_destroy (dir_file);
508	closedir (dir);
509	free (fullpath);
510	free (fullname);
511	errno = current_errno;
512	return NULL;
513	}
514
515	direntry->mode = stinfo.st_mode & 07777;
516	dir_size += direntry->data.size;
517	}
518	else
519	assert (false && "Not supported");
520
521	free (fullpath);
522	}
523
524	closedir (dir);
525
526	dir_file->type = UF_DIR;
527	dir_file->data.size = dir_size;
528
529	return dir_file;
530	}
531
532	void
533	uar_file_set_mode (struct uar_file *file, mode_t mode)
534	{
535	file->mode = mode;
536	}
537
538	static void
539	uar_debug_print_file (const struct uar_archive uar, struct uar_file file,
540	bool print_contents)
541	{
542	printf (" size: %lu\n", file->data.size);
543
544	if (print_contents)
545	{
546	printf (" contents:\n");
547	printf ("==================\n");
548	fflush (stdout);
549
550	ssize_t size = write (STDOUT_FILENO, uar->buffer + file->offset,
551	file->data.size);
552
553	if (size == -1 \|\| ((uint64_t) size) != file->data.size)
554	{
555	perror ("write");
556	return;
557	}
558
559	putchar ('\n');
560	printf ("==================\n");
561	}
562	}
563
564	void
565	uar_debug_print (const struct uar_archive *uar, bool print_file_contents)
566	{
567	printf ("uar_archive:\n");
568	printf (" magic: %02x %02x %02x %02x\n", uar->header.magic[0],
569	uar->header.magic[1], uar->header.magic[2], uar->header.magic[3]);
570	printf (" version: %u\n", uar->header.version);
571	printf (" flags: %u\n", uar->header.flags);
572	printf (" nfiles: %lu\n", uar->header.nfiles);
573	printf (" size: %lu\n", uar->header.size);
574	printf (" stream?: %i\n", uar->is_stream);
575
576	for (uint64_t i = 0; i < uar->header.nfiles; i++)
577	{
578	struct uar_file *file = uar->files[i];
579
580	printf (" %s[%lu]:\n",
581	file->type == UF_FILE ? "file"
582	: file->type == UF_DIR ? "directory"
583	: "link",
584	i);
585	printf (" name: \033[1m%s%s\033[0m\n", file->name,
586	file->type == UF_DIR ? "/"
587	: file->type == UF_LINK ? "@"
588	: "");
589	printf (" offset: %u\n", file->offset);
590	printf (" mode: %04o\n", file->mode);
591
592	switch (file->type)
593	{
594	case UF_FILE:
595	uar_debug_print_file (uar, file, print_file_contents);
596	break;
597
598	case UF_DIR:
599	printf (" size: %lu\n", file->data.size);
600	break;
601
602	default:
603	printf (" info: unknown file type\n");
604	break;
605	}
606	}
607	}
608
609	bool
610	uar_write (struct uar_archive uar, const char filename)
611	{
612	FILE *stream = fopen (filename, "wb");
613
614	if (stream == NULL)
615	{
616	uar_set_error (uar, UAR_IO_ERROR);
617	return false;
618	}
619
620	if (fwrite (&uar->header, sizeof (struct uar_header), 1, stream) != 1)
621	{
622	uar_set_error (uar, UAR_IO_ERROR);
623	fclose (stream);
624	return false;
625	}
626
627	for (uint64_t i = 0; i < uar->header.nfiles; i++)
628	{
629	struct uar_file *file = uar->files[i];
630
631	if (fwrite (file, sizeof (struct uar_file), 1, stream) != 1)
632	{
633	uar_set_error (uar, UAR_IO_ERROR);
634	fclose (stream);
635	return false;
636	}
637
638	if (fwrite (file->name, 1, file->namelen, stream) != file->namelen)
639	{
640	uar_set_error (uar, UAR_IO_ERROR);
641	fclose (stream);
642	return false;
643	}
644	}
645
646	if (fwrite (uar->buffer, uar->header.size, 1, stream) != 1)
647	{
648	uar_set_error (uar, UAR_IO_ERROR);
649	fclose (stream);
650	return false;
651	}
652
653	fclose (stream);
654	return true;
655	}
656
657	const char *
658	uar_get_file_name (const struct uar_file *file)
659	{
660	return file->name;
661	}
662
663	bool
664	uar_extract (struct uar_archive uar, const char cwd,
665	bool (callback) (struct uar_file file))
666	{
667	if (cwd != NULL && chdir (cwd) != 0)
668	{
669	uar_set_error (uar, UAR_SYSTEM_ERROR);
670	return false;
671	}
672
673	for (uint64_t i = 0; i < uar->header.nfiles; i++)
674	{
675	struct uar_file *file = uar->files[i];
676
677	if (callback != NULL && !callback (file))
678	return false;
679
680	switch (file->type)
681	{
682	case UF_FILE:
683	{
684	FILE *stream = fopen (file->name, "wb");
685
686	if (stream == NULL)
687	{
688	uar_set_error (uar, UAR_IO_ERROR);
689	return false;
690	}
691
692	if (fwrite (uar->buffer + file->offset, 1,
693	file->data.size, stream)
694	!= file->data.size)
695	{
696	uar_set_error (uar, UAR_IO_ERROR);
697	return false;
698	}
699
700	fchmod (fileno (stream), file->mode);
701	fclose (stream);
702	}
703	break;
704
705	case UF_DIR:
706	if (mkdir (file->name, file->mode) != 0)
707	{
708	uar_set_error (uar, UAR_SYSTEM_ERROR);
709	return false;
710	}
711
712	break;
713
714	default:
715	assert (false && "unknown file type");
716	return false;
717	}
718	}
719
720	return true;
721	}