attempting to implement 'untar'

lib/tar.c

@@ -0,0 +1,286 @@
+#include <hio-tar.h>
+#include <hio-utl.h>
+#include <hio-prv.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+static hio_uint8_t _end_block[HIO_TAR_BLKSIZE] = { 0, };
+
+#if 0
+static int verify_checksum(const char *p)
+{
+	int n, u = 0;
+
+	for (n = 0; n < 512; n++) 
+	{
+		if (n < 148 || n > 155)
+			/* Standard tar checksum adds unsigned bytes. */
+			u += ((hio_uint8_t*)p)[n];
+		else
+			u += 0x20;
+
+	}
+	return (u == parseoct(p + 148, 8));
+}
+#endif
+
+static int create_dir (hio_bch_t *pathname, int mode)
+{
+	char *p;
+	int n;
+	hio_oow_t pathlen;
+
+	pathlen = hio_count_bcstr(pathname);
+
+	/* Strip trailing '/' TODO: improve ...*/ 
+	if (pathname[pathlen - 1] == '/')
+		pathname[pathlen - 1] = '\0';
+
+	n = mkdir(pathname, mode);
+	if (n <= -1) 
+	{
+		/* On failure, try creating parent directory. */
+		p = hio_rfind_bchar_in_bcstr(pathname, '/');
+		if (p) 
+		{
+			*p = '\0';
+			create_dir(pathname, 0755);
+			*p = '/';
+			n = mkdir(pathname, mode);
+		}
+	}
+
+	return n;
+}
+
+static FILE* create_file (char *pathname, int mode)
+{
+	FILE *fp;
+	fp = fopen(pathname, "wb+");
+	if (!fp) 
+	{
+		char* p = hio_rfind_bchar_in_bcstr(pathname, '/');
+		if (p) 
+		{
+			*p = '\0';
+			create_dir(pathname, 0755);
+			*p = '/';
+			fp = fopen(pathname, "wb+");
+		}
+	}
+	return fp;
+}
+
+static int extract_tar (hio_t* hio, FILE* fp)
+{
+	char buf[HIO_TAR_BLKSIZE];
+	FILE* f = NULL;
+	int filesize;
+
+	while (1)
+	{
+		int is_sober;
+		const hio_bch_t* endptr;
+		hio_iolen_t nbytes;
+		hio_tar_hdr_t* hdr;
+		hio_uint32_t mode;
+
+		nbytes = fread(buf, 1, HIO_TAR_BLKSIZE, fp);
+		if (nbytes < HIO_TAR_BLKSIZE)
+		{
+			hio_seterrbfmt (hio, HIO_EINVAL, "truncated trailing block");
+			return -1;
+		}
+
+		/* all-zero byte block ends the archive */
+		if (HIO_MEMCMP(buf, _end_block, HIO_TAR_BLKSIZE) == 0) break;
+
+#if 0
+		if (!verify_checksum(buf)) 
+		{
+			hio_seterrbfmt (hio, HIO_EINVAL, "invalid checksum value");
+			return -1;
+		}
+#endif
+
+		hdr = (hio_tar_hdr_t*)buf;
+		filesize = hio_bchars_to_uintmax(hdr->size, HIO_COUNTOF(hdr->size), HIO_BCHARS_TO_UINTMAX_MAKE_OPTION(0,0,0,8), &endptr, &is_sober);
+		mode = hio_bchars_to_uintmax(hdr->mode, HIO_COUNTOF(hdr->mode), HIO_BCHARS_TO_UINTMAX_MAKE_OPTION(0,0,0,8), &endptr, &is_sober);
+
+		switch (hdr->typeflag) 
+		{
+			case HIO_TAR_LNKTYPE:
+				printf(" Ignoring hardlink %s\n", hdr->name);
+				break;
+			case HIO_TAR_SYMTYPE:
+				printf(" Ignoring symlink %s\n", hdr->name);
+				break;
+			case HIO_TAR_CHRTYPE:
+				printf(" Ignoring character device %s\n", hdr->name);
+				break;
+			case HIO_TAR_BLKTYPE:
+				printf(" Ignoring block device %s\n", hdr->name);
+				break;
+			case HIO_TAR_DIRTYPE:
+				printf(" Extracting dir %s\n", hdr->name);
+				if (filesize != 0)
+				{
+					/* something wrong */
+				}
+				create_dir(hdr->name, mode);
+				break;
+			case HIO_TAR_FIFOTYPE:
+				printf(" Ignoring FIFO %s\n", hdr->name);
+				break;
+
+			case HIO_TAR_CONTTYPE:
+				printf(" Ignoring cont %s\n", hdr->name);
+				break;
+
+			default:
+				printf(" Extracting file %s\n", hdr->name);
+				f = create_file(hdr->name, mode);
+
+				while (filesize > 0) 
+				{
+					nbytes = fread(buf, 1, HIO_TAR_BLKSIZE, fp);
+					if (nbytes < HIO_TAR_BLKSIZE) 
+					{
+						fprintf(stderr, "Short read - Expected 512, got %d\n", (int)nbytes);
+						return -1;
+					}
+					if (filesize < HIO_TAR_BLKSIZE) nbytes = filesize;
+
+					if (f) 
+					{
+						if (fwrite(buf, 1, nbytes, f) != nbytes)
+						{
+							fprintf(stderr, "Failed write\n");
+							break;
+						}
+					}
+					filesize -= nbytes;
+				}
+
+				fclose (f);
+				break;
+		}
+	}
+
+	return 0;
+}
+
+
+int hio_extract_tar (hio_t* hio, const hio_bch_t* archive_file)
+{
+	FILE* fp;
+	int n;
+
+	fp = fopen(archive_file, "r");
+	if (!fp) return -1;
+
+	n = extract_tar(hio, fp);
+
+	fclose (fp);
+	return n;
+}
+
+
+
+
+hio_tar_t* hio_tar_open (hio_t* hio, hio_oow_t xtnsize)
+{
+	hio_tar_t* tar;
+
+	tar = (hio_tar_t*)hio_callocmem(hio, HIO_SIZEOF(*tar) + xtnsize);
+	if (tar)
+	{
+		if (hio_tar_init(tar) <= -1)
+		{
+			hio_freemem (hio, tar);
+			tar = HIO_NULL;
+		}
+	}
+
+	return tar;
+}
+
+void hio_tar_close (hio_tar_t* tar)
+{
+	hio_tar_fini (tar);
+	hio_freemem (tar->hio, tar);
+}
+
+int hio_tar_init (hio_tar_t* tar)
+{
+	tar->state = HIO_TAR_STATE_START;
+	tar->blk.len = 0;
+	return 0;
+}
+
+void hio_tar_fini (hio_tar_t* tar)
+{
+}
+
+
+static int process_header (hio_tar_t* tar)
+{
+	hio_tar_hdr_t* hdr;
+
+	HIO_ASSERT (tar->hio, tar->blk.len == HIO_TAR_BLKSIZE);
+	hdr = (hio_tar_hdr_t*)tar->blk.buf;
+
+	/* all-zero byte block ends the archive */
+	if (HIO_MEMCMP(hdr, _end_block, HIO_TAR_BLKSIZE) == 0) 
+	{
+		tar->state = HIO_TAR_STATE_END;
+		return 0;
+	}
+
+	return 0;
+}
+
+#define hio_tar_endfeed(tar) hio_tar_feed(tar, HIO_NULL, 0)
+
+int hio_tar_feed (hio_tar_t* tar, const void* ptr, hio_oow_t len)
+{
+	if (!ptr)
+	{
+		/* EOF indicator */
+		if (tar->state != HIO_TAR_STATE_END || tar->blk.len > 0)
+		{
+			/* ERROR - premature end of file */
+			return -1;
+		}
+	}
+
+	while (len > 0)
+	{
+		switch (tar->state)
+		{
+			case HIO_TAR_STATE_START:
+			{
+				hio_oow_t cplen;
+				cplen = HIO_COUNTOF(tar->blk.buf) - tar->blk.len;
+				if (len < cplen) cplen = len;
+				HIO_MEMCPY (&tar->blk.buf[tar->blk.len], ptr, cplen);
+				len -= cplen;
+				break;
+			}
+
+			case HIO_TAR_STATE_FILE:
+				break;
+
+			case HIO_TAR_STATE_END:
+				if (len > 0)
+				{
+					/* garbage after the final ending block */
+					return -1;
+				}
+				break;
+		}
+	}
+
+	return 0;
+}