others
/* $Id$ */
/* Copyright (c) 2006-2014 Pierre Pronchery <khorben@defora.org> */
/* This file is part of DeforaOS Unix others */
/* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, version 3 of the License.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* TODO:
* - libutils in UNIX
* - reuse code from mkdir -p and ls -l
* - share code with ar etc (packing framework)
* - implement ustar format */
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include "tar.h"
#ifndef PROGNAME
# define PROGNAME "tar"
#endif
#ifndef min
# define min(a, b) ((a) < (b) ? (a) : (b))
#endif
/* tar */
/* private */
/* types */
typedef int Prefs;
#define PREFS_A 0x01
#define PREFS_c 0x02
#define PREFS_t 0x04
#define PREFS_v 0x08
#define PREFS_vv 0x18
#define PREFS_x 0x20
/* constants */
#define TAR_BLKSIZ 512
/* prototypes */
static int _tar(Prefs * prefs, char const * archive, int filec,
char * filev[]);
static int _tar_error(char const * message, int ret);
static int _tar_usage(void);
/* functions */
/* tar */
static int _tar_create(Prefs * prefs, char const * archive, int filec,
char * filev[]);
static int _tar_extract(Prefs * prefs, char const * archive, int filec,
char * filev[]);
static int _tar_list(Prefs * prefs, char const * archive, int filec,
char * filev[]);
static int _tar(Prefs * prefs, char const * archive, int filec,
char * filev[])
{
if(*prefs & PREFS_c)
return _tar_create(prefs, archive, filec, filev);
if(*prefs & PREFS_t)
return _tar_list(prefs, archive, filec, filev);
if(*prefs & PREFS_x)
return _tar_extract(prefs, archive, filec, filev);
return 1;
}
#define _from_buffer_cpy(a) tfhb->a[sizeof(tfhb->a)-1] = '\0'; \
tfh->a = strtol(tfhb->a, &p, 8); \
if(*tfhb->a == '\0' || *p != '\0') return 1;
static int _tar_from_buffer(TarFileHeaderBuffer * tfhb, TarFileHeader * tfh)
{
char * p;
size_t len;
_from_buffer_cpy(mode);
_from_buffer_cpy(uid);
_from_buffer_cpy(gid);
_from_buffer_cpy(size); /* FIXME data type too short? */
_from_buffer_cpy(mtime);
for(p = tfhb->filename; *p == '/'; p++);
/* FIXME ".." directory traversal */
memcpy(&tfh->filename, p, tfhb->filename + sizeof(tfhb->filename) - p);
tfh->filename[sizeof(tfh->filename) - 1] = '\0';
len = strlen(tfh->filename);
if(tfh->filename[len] == '/')
tfh->type = FT_DIRECTORY;
else
tfh->type = tfhb->type;
memcpy(&tfh->link, tfhb->link, sizeof(tfhb->link));
tfh->link[sizeof(tfh->link) - 1] = '\0';
return 0;
}
static int _tar_mkdir_parent(char * filename)
{
char * p;
struct stat st;
if(filename[0] == '\0')
return 0;
for(p = &filename[1]; *p != '\0'; p++)
{
if(*p != '/')
continue;
*p = '\0';
if(!(stat(filename, &st) == 0 && S_ISDIR(st.st_mode))
&& mkdir(filename, 0777) == -1)
{
*p = '/';
return _tar_error(filename, 1);
}
for(*p++ = '/'; *p == '/'; p++);
if(*p == '\0')
return 0;
}
return 0;
}
static void _tar_print(Prefs * prefs, TarFileHeader * fh)
{
if((*prefs & PREFS_vv) == PREFS_vv)
/* FIXME */
fprintf(stderr, "%s %u %u %s\n", "----------",
(unsigned)fh->uid, (unsigned)fh->gid,
fh->filename);
else if(*prefs & PREFS_v)
fprintf(stderr, "%s\n", fh->filename);
}
static int _tar_seek(FILE * fp, char const * archive, size_t count)
{
char buf[TAR_BLKSIZ];
size_t step;
if(fp == stdin)
for(; count != 0; count -= step)
{
if((step = count % TAR_BLKSIZ) == 0)
step = TAR_BLKSIZ;
if(fread(buf, sizeof(*buf), step, fp) != step)
return _tar_error(archive, 1);
}
else if(fseek(fp, count, SEEK_CUR) != 0)
return _tar_error(archive, 1);
return 0;
}
static int _tar_skip(FILE * fp, char const * archive, TarFileHeader * fh)
{
size_t count = fh->size % TAR_BLKSIZ;
if(count != 0)
count = TAR_BLKSIZ - count;
count+=fh->size;
return _tar_seek(fp, archive, count);
}
static void _tar_stat_to_buffer(char const * filename, struct stat * st,
TarFileHeaderBuffer * tfhb)
{
uint8_t * p;
size_t i;
int checksum = 0;
memset(tfhb, 0, sizeof(*tfhb));
snprintf(tfhb->filename, sizeof(tfhb->filename), "%s", filename);
snprintf(tfhb->mode, sizeof(tfhb->mode), "%07o", (unsigned)st->st_mode);
snprintf(tfhb->uid, sizeof(tfhb->uid), "%07o", (unsigned)st->st_uid);
snprintf(tfhb->gid, sizeof(tfhb->gid), "%07o", (unsigned)st->st_gid);
snprintf(tfhb->size, sizeof(tfhb->size), "%011o",
(unsigned)st->st_size);
snprintf(tfhb->mtime, sizeof(tfhb->mtime), "%011o",
(unsigned)st->st_mtime);
memset(&tfhb->checksum, ' ', sizeof(tfhb->checksum));
if(S_ISDIR(st->st_mode))
tfhb->type = FT_DIRECTORY;
else if(S_ISCHR(st->st_mode))
tfhb->type = FT_CHAR;
else if(S_ISBLK(st->st_mode))
tfhb->type = FT_BLOCK;
/* FIXME link */
p = (uint8_t *)tfhb;
for(i = 0; i < sizeof(*tfhb); i++)
checksum += p[i];
snprintf(tfhb->checksum, sizeof(tfhb->checksum), "%06o%c ", checksum,
'\0');
}
static int _create_do(Prefs * prefs, FILE * fp, char const * archive,
char const * filename);
static int _tar_create(Prefs * prefs, char const * archive, int filec,
char * filev[])
{
FILE * fp = stdout;
int i;
if(archive != NULL && (fp = fopen(archive, "w")) == NULL)
return _tar_error(archive, 1);
for(i = 0; i < filec; i++)
if(_create_do(prefs, fp, archive, filev[i]) != 0)
break;
if(i != filec)
{
fclose(fp);
return 1;
}
for(i = 0; i < TAR_BLKSIZ * 2 && fputc('\0', fp) == '\0'; i++);
if(archive != NULL)
fclose(fp);
return (i == TAR_BLKSIZ * 2) ? 0 : 1;
}
static int _doc_header(Prefs * prefs, FILE * fp, char const * archive,
FILE * fp2, char const * filename, TarFileHeaderBuffer * tfhb);
static int _doc_normal(FILE * fp, char const * archive, FILE * fp2,
char const * filename);
static int _create_do(Prefs * prefs, FILE * fp, char const * archive,
char const * filename)
{
FILE * fp2;
TarFileHeaderBuffer tfhb;
int ret;
if((fp2 = fopen(filename, "r")) == NULL)
return 1;
if(_doc_header(prefs, fp, archive, fp2, filename, &tfhb) != 0)
{
fclose(fp2);
return 1;
}
switch(tfhb.type)
{
case FT_NORMAL:
case FT_CONTIGUOUS:
ret = _doc_normal(fp, archive, fp2, filename);
break;
case FT_HARDLINK:
case FT_SYMLINK:
case FT_CHAR:
case FT_BLOCK:
case FT_DIRECTORY: /* FIXME recurse */
case FT_FIFO:
ret = 0;
break;
default:
ret = 1;
}
fclose(fp2);
return ret;
}
static int _doc_header(Prefs * prefs, FILE * fp, char const * archive,
FILE * fp2, char const * filename, TarFileHeaderBuffer * tfhb)
{
TarFileHeader tfh;
struct stat st;
int i;
if(fstat(fileno(fp2), &st) != 0)
return _tar_error(filename, 1);
_tar_stat_to_buffer(filename, &st, tfhb);
_tar_from_buffer(tfhb, &tfh);
_tar_print(prefs, &tfh);
if(fwrite(tfhb, sizeof(*tfhb), 1, fp) != 1)
return _tar_error(archive, 1);
for(i = sizeof(*tfhb); i < TAR_BLKSIZ && fputc('\0', fp) == '\0'; i++);
if(i != TAR_BLKSIZ)
return _tar_error(archive, 1);
return 0;
}
static int _doc_normal(FILE * fp, char const * archive, FILE * fp2,
char const * filename)
{
int ret = 0;
size_t read;
size_t cnt;
char buf[BUFSIZ];
for(cnt = 0; (read = fread(buf, sizeof(*buf), sizeof(buf), fp2)) != 0;
cnt += read)
if(fwrite(buf, sizeof(*buf), read, fp) != read)
{
ret = _tar_error(archive, 1);
break;
}
if(ret == 0 && read == 0 && !feof(fp2))
return _tar_error(filename, 1);
for(cnt = TAR_BLKSIZ - (cnt % TAR_BLKSIZ);
cnt > 0 && fputc('\0', fp) == '\0'; cnt--);
return (cnt == 0) ? 0 : _tar_error(archive, 1);
}
static int _extract_do(Prefs * prefs, FILE * fp, char const * archive,
TarFileHeader * fh, int filec, char * filev[]);
static int _tar_extract(Prefs * prefs, char const * archive, int filec,
char * filev[])
{
FILE * fp = stdin;
TarFileHeaderBuffer fhdrb;
TarFileHeader fhdr;
size_t size;
int ret = 0;
if(archive != NULL && (fp = fopen(archive, "r")) == NULL)
return _tar_error(archive, 1);
while((size = fread(&fhdrb, sizeof(fhdrb), 1, fp)) == 1)
{
if(_tar_seek(fp, archive, TAR_BLKSIZ - sizeof(fhdrb)) != 0)
{
ret = 1;
break;
}
if(_tar_from_buffer(&fhdrb, &fhdr) != 0
|| _extract_do(prefs, fp, archive, &fhdr,
filec, filev) != 0)
ret = 1;
}
if(ret == 0 && size == 0 && !feof(fp))
ret = _tar_error(archive, 1);
if(archive != NULL)
fclose(fp);
return ret;
}
static int _dox_normal(FILE * fp, char const * archive, TarFileHeader * fh);
static int _dox_hardlink(TarFileHeader * fh);
static int _dox_symlink(TarFileHeader * fh);
static int _dox_char(FILE * fp, char const * archive, TarFileHeader * fh);
static int _dox_block(FILE * fp, char const * archive, TarFileHeader * fh);
static int _dox_directory(TarFileHeader * fh);
static int _dox_fifo(TarFileHeader * fh);
static int _extract_do(Prefs * prefs, FILE * fp, char const * archive,
TarFileHeader * fh, int filec, char * filev[])
{
int i;
for(i = 0; i < filec; i++)
if(strcmp(fh->filename, filev[i]) == 0)
break;
if(filec != 0 && i == filec)
return _tar_skip(fp, archive, fh);
_tar_print(prefs, fh);
if(_tar_mkdir_parent(fh->filename) != 0)
return _tar_skip(fp, archive, fh);
switch((int)fh->type)
{
case FT_NORMAL:
case FT_CONTIGUOUS:
case '0': /* FIXME GNU compatibility */
return _dox_normal(fp, archive, fh);
case FT_HARDLINK:
return _dox_hardlink(fh);
case FT_SYMLINK:
return _dox_symlink(fh);
case FT_CHAR:
return _dox_char(fp, archive, fh);
case FT_BLOCK:
return _dox_block(fp, archive, fh);
case FT_DIRECTORY:
return _dox_directory(fh);
case FT_FIFO:
return _dox_fifo(fh);
default:
return _tar_skip(fp, archive, fh);
}
}
static int _dox_normal(FILE * fp, char const * archive, TarFileHeader * fh)
{
FILE * fp2;
size_t cnt;
size_t read;
char buf[BUFSIZ];
if((fp2 = fopen(fh->filename, "w")) == NULL)
return _tar_error(fh->filename, 1);
for(cnt = 0; cnt < fh->size; cnt += BUFSIZ)
{
read = fread(buf, sizeof(*buf), min(BUFSIZ, fh->size - cnt),
fp);
if(read == 0)
return _tar_error(archive, 1);
if(fwrite(buf, sizeof(*buf), read, fp2) != read)
{
fclose(fp2);
return _tar_error(fh->filename, 1);
}
}
fclose(fp2);
if((cnt = fh->size % TAR_BLKSIZ) != 0
&& _tar_seek(fp, archive, TAR_BLKSIZ - cnt) != 0)
return 1;
return 0;
}
static int _dox_hardlink(TarFileHeader * fh)
{
if(link(fh->link, fh->filename) != 0)
return _tar_error(fh->filename, 1);
return 0;
}
static int _dox_symlink(TarFileHeader * fh)
{
if(symlink(fh->link, fh->filename) != 0)
return _tar_error(fh->filename, 1);
return 0;
}
static int _dox_char(FILE * fp, char const * archive, TarFileHeader * fh)
{
/* FIXME */
return 1;
}
static int _dox_block(FILE * fp, char const * archive, TarFileHeader * fh)
{
/* FIXME */
return 1;
}
static int _dox_directory(TarFileHeader * fh)
{
if(mkdir(fh->filename, fh->mode) != 0)
return _tar_error(fh->filename, 1);
return 0;
}
static int _dox_fifo(TarFileHeader * fh)
{
if(mkfifo(fh->filename, fh->mode) != 0)
return _tar_error(fh->filename, 1);
return 0;
}
static int _list_do(Prefs * prefs, FILE * fp, char const * archive,
TarFileHeader * fh, int filec, char * filev[]);
static int _tar_list(Prefs * prefs, char const * archive, int filec,
char * filev[])
{
FILE * fp = stdin;
TarFileHeaderBuffer fhdrb;
TarFileHeader fhdr;
size_t size;
int ret = 0;
if(archive != NULL && (fp = fopen(archive, "r")) == NULL)
return _tar_error(archive, 1);
while((size = fread(&fhdrb, sizeof(fhdrb), 1, fp)) == 1)
{
if(_tar_seek(fp, archive, TAR_BLKSIZ - sizeof(fhdrb)) != 0)
{
ret = 1;
break;
}
if(_tar_from_buffer(&fhdrb, &fhdr) != 0
|| _list_do(prefs, fp, archive, &fhdr, filec,
filev) != 0)
ret = 1;
}
if(ret == 0 && size == 0 && !feof(fp))
ret = _tar_error(archive, 1);
if(archive != NULL)
fclose(fp);
return ret;
}
static int _list_do(Prefs * prefs, FILE * fp, char const * archive,
TarFileHeader * fh, int filec, char * filev[])
{
int i;
for(i = 0; i < filec; i++)
if(strcmp(fh->filename, filev[i]) == 0)
break;
if(filec == 0 || i != filec)
_tar_print(prefs, fh);
return _tar_skip(fp, archive, fh);
}
/* tar_error */
static int _tar_error(char const * message, int ret)
{
fputs(PROGNAME ": ", stderr);
perror(message);
return ret;
}
/* tar_usage */
static int _tar_usage(void)
{
fputs("Usage: " PROGNAME " -ctvx [-f archive][file...]\n\
-c Create an archive\n\
-f Specify an archive to work with (default: stdin or stdout)\n\
-t List the contents of an archive\n\
-v Verbose mode\n\
-x Extract from archive\n", stderr);
return 1;
}
/* public */
/* functions */
/* main */
int main(int argc, char * argv[])
{
int o;
Prefs prefs = 0;
char const * archive = NULL;
while((o = getopt(argc, argv, "cvtxf:")) != -1)
switch(o)
{
case 'c':
prefs -= prefs & PREFS_t;
prefs -= prefs & PREFS_x;
prefs |= PREFS_c;
break;
case 'f':
archive = optarg;
break;
case 't':
prefs -= prefs & PREFS_c;
prefs -= prefs & PREFS_x;
prefs |= PREFS_t;
break;
case 'v':
prefs |= (prefs & PREFS_v) == PREFS_v
? PREFS_vv : PREFS_v;
break;
case 'x':
prefs -= prefs & PREFS_c;
prefs -= prefs & PREFS_t;
prefs |= PREFS_x;
break;
default:
return _tar_usage();
}
if(prefs == 0)
return _tar_usage();
return (_tar(&prefs, archive, argc - optind, &argv[optind]) == 0)
? 0 : 2;
}