main(int argc, char** argv)
{
char* file;
Sfio_t* ip;
error_info.id = "r2c";
state.delimiter = ':';
state.terminator = '\n';
state.window = 4 * 1024 * 1024;
state.level = 9;
for (;;)
{
switch (optget(argv, "d:[delimiter]l#[compression-level]q:[quote]t:[terminator]vw#[window-size]T#[test-mask]"))
{
case 'd':
state.delimiter = *opt_info.arg;
continue;
case 'l':
state.level = opt_info.num;
continue;
case 'q':
state.quote = *opt_info.arg;
continue;
case 't':
state.delimiter = *opt_info.arg;
continue;
case 'v':
state.verbose = 1;
continue;
case 'w':
state.window = opt_info.num;
continue;
case 'T':
state.test |= opt_info.num;
continue;
case '?':
error(ERROR_USAGE|4, opt_info.arg);
continue;
case ':':
error(2, opt_info.arg);
continue;
}
break;
}
argv += opt_info.index;
if (error_info.errors)
error(ERROR_USAGE|4, "%s", optusage(NiL));
state.cache = state.window;
if (state.level > 0 && sfdcgzip(sfstdout, state.level) < 0)
error(3, "output compress discipline error");
if (!*argv)
r2c("/dev/stdin", sfstdin, sfstdout);
else
while (file = *argv++)
{
if (streq(file, "-"))
{
file = "/dev/stdin";
ip = sfstdin;
}
else if (!(ip = sfopen(NiL, file, "r")))
{
error(ERROR_SYSTEM|2, "%s: cannot read", file);
continue;
}
r2c(file, ip, sfstdout);
if (ip != sfstdin)
sfclose(ip);
}
flush(sfstdout);
return error_info.errors != 0;
}
int
pzheadwrite(Pz_t* pz, Sfio_t* op)
{
register size_t i;
register size_t m;
register size_t n;
register char* s;
if (pz->flags & PZ_HEAD)
return 0;
pz->oop = op;
if (!(pz->flags & PZ_NOGZIP))
sfdcgzip(op, 0);
if (pz->flags & PZ_NOPZIP)
return 0;
sfputc(op, PZ_MAGIC_1);
sfputc(op, PZ_MAGIC_2);
if (sfsync(op))
return -1;
sfputc(op, pz->major = PZ_MAJOR);
sfputc(op, pz->minor = PZ_MINOR);
sfputu(op, pz->win);
if (pz->disc->comment)
{
sfputc(op, PZ_HDR_comment);
m = strlen(pz->disc->comment) + 1;
sfputu(op, m);
sfwrite(op, pz->disc->comment, m);
}
if (pz->det && (m = sfstrtell(pz->det)))
{
sfputc(op, PZ_HDR_options);
if (!(s = sfstruse(pz->det)))
{
if (pz->disc->errorf)
(*pz->disc->errorf)(pz, pz->disc, ERROR_SYSTEM|2, "out of space");
return -1;
}
m++;
sfputu(op, m);
sfwrite(op, s, m);
}
if (i = pz->prefix.count)
{
sfputc(op, PZ_HDR_prefix);
if (pz->prefix.terminator >= 0)
{
m = 0;
while (i-- > 0)
{
if (!(s = sfgetr(pz->io, pz->prefix.terminator, 0)))
{
if (pz->disc->errorf)
(*pz->disc->errorf)(pz, pz->disc, 2, "%s: cannot read %I*u prefix record%s from data", pz->path, sizeof(pz->prefix.count), pz->prefix.count, pz->prefix.count == 1 ? "" : "s");
return -1;
}
m += n = sfvalue(pz->io);
sfwrite(pz->tmp, s, n);
}
s = sfstrseek(pz->tmp, 0, SEEK_SET);
}
else
{
m = i;
if (!(s = (char*)sfreserve(pz->io, m, 0)))
{
if (pz->disc->errorf)
(*pz->disc->errorf)(pz, pz->disc, 2, "%s: cannot read %I*u prefix byte%s from data", pz->path, sizeof(pz->prefix.count), pz->prefix.count, pz->prefix.count == 1 ? "" : "s");
return -1;
}
}
sfputu(op, m);
sfwrite(op, s, m);
}
pz->flags |= PZ_HEAD;
return pzpartwrite(pz, op);
}
int
sfdcpzip(Sfio_t* sp, const char* path, unsigned long flags, Pzdisc_t* disc)
{
Sfio_t* io;
Sfpzip_t* pz;
Pz_t* oz;
if (flags & PZ_HANDLE)
{
oz = (Pz_t*)sp;
sp = oz->io;
}
else
oz = 0;
if (sfset(sp, 0, 0) & SF_WRITE)
{
if (flags & PZ_STAT)
return -1;
}
else if (!(flags & PZ_FORCE))
{
unsigned char* s;
int r;
int m1;
int m2;
if (!(r = sfset(sp, 0, 0) & SF_SHARE))
sfset(sp, SF_SHARE, 1);
s = (unsigned char*)sfreserve(sp, PZ_GZ_MAGOFF + 2, 1);
if (!r)
sfset(sp, SF_SHARE, 0);
if (!s)
return -1;
m1 = s[0];
m2 = s[1];
r = m1 == PZ_MAGIC_1 && m2 == PZ_MAGIC_2 && s[2] > 0 && s[3] < 10 ||
m1 == GZ_MAGIC_1 && m2 == GZ_MAGIC_2 &&
s[PZ_GZ_MAGOFF] == PZ_GZ_MAGIC_1 && s[PZ_GZ_MAGOFF+1] == PZ_GZ_MAGIC_2;
sfread(sp, s, 0);
if (flags & PZ_STAT)
return r;
if (!r)
{
if (!(flags & PZ_NOGZIP))
{
if (m1 == GZ_MAGIC_1)
{
if (m2 == GZ_MAGIC_2)
r = sfdcgzip(sp, (flags & PZ_CRC) ? 0 : SFGZ_NOCRC);
else if (m2 == LZ_MAGIC_2)
r = sfdclzw(sp, 0);
}
else if (m1 == 'B' && m2 == 'Z' && s[2] == 'h' && s[3] >= '1' && s[3] <= '9')
r = sfdcbzip(sp, 0);
}
return r;
}
sfsync(sp);
}
if (!(io = sfnew(NiL, NiL, SF_UNBOUND, sffileno(sp), (sfset(sp, 0, 0) & (SF_READ|SF_WRITE)))))
return -1;
if (!(pz = newof(0, Sfpzip_t, 1, 0)))
{
io->_file = -1;
sfclose(io);
return -1;
}
pz->disc.version = PZ_VERSION;
flags &= ~(PZ_READ|PZ_WRITE|PZ_STAT|PZ_STREAM|PZ_INTERNAL);
flags |= PZ_PUSHED|PZ_STREAM|((sfset(sp, 0, 0) & SF_READ) ? PZ_READ : PZ_WRITE);
if (oz && (oz->flags & PZ_WRITE))
flags |= PZ_DELAY;
if (disc)
{
pz->disc.errorf = disc->errorf;
pz->disc.window = disc->window;
pz->disc.options = disc->options;
pz->disc.partition = disc->partition;
if (disc->splitf)
flags |= PZ_ACCEPT;
}
if (!(pz->pz = pzopen(&pz->disc, (char*)io, flags)) || (sp->_file = open("/dev/null", 0)) < 0)
{
io->_file = -1;
sfclose(io);
free(pz);
return -1;
}
if (path)
pz->pz->path = path;
pz->sfdisc.exceptf = sfpzexcept;
if (flags & PZ_WRITE)
{
pz->sfdisc.writef = sfpzwrite;
pz->io = io;
}
else
pz->sfdisc.readf = sfpzread;
sfset(sp, SF_SHARE|SF_PUBLIC, 0);
if (sfdisc(sp, &pz->sfdisc) != &pz->sfdisc)
{
close(sp->_file);
sp->_file = io->_file;
sfseek(sp, sftell(io), SEEK_SET);
io->_file = -1;
pzclose(pz->pz);
free(pz);
return -1;
}
if (oz)
oz->flags |= pz->pz->flags & PZ_INTERNAL;
return 1;
}
