void varbufversion
(struct varbuf *vb,
const struct versionrevision *version,
enum versiondisplayepochwhen vdew)
{
switch (vdew) {
case vdew_never:
break;
case vdew_nonambig:
if (!version->epoch &&
(!version->version || !strchr(version->version,':')) &&
(!version->revision || !strchr(version->revision,':'))) break;
/* Fall through. */
case vdew_always:
varbufprintf(vb,"%lu:",version->epoch);
break;
default:
internerr("unknown versiondisplayepochwhen '%d'", vdew);
}
if (version->version) varbufaddstr(vb,version->version);
if (version->revision && *version->revision) {
varbufaddc(vb,'-');
varbufaddstr(vb,version->revision);
}
}
/* FIXME: Ideally we'd use openat() here, to avoid the path mangling, but
* it's not widely available yet, so this will do for now. */
static void
dir_file_sync(const char *dir, const char *filename)
{
struct varbuf path = VARBUF_INIT;
int fd;
varbufprintf(&path, "%s/%s", dir, filename);
fd = open(path.buf, O_WRONLY);
if (fd < 0)
ohshite(_("unable to open file '%s'"), path.buf);
if (fsync(fd))
ohshite(_("unable to sync file '%s'"), path.buf);
if (close(fd))
ohshite(_("unable to close file '%s'"), path.buf);
varbuf_destroy(&path);
}
void describedepcon(struct varbuf *addto, struct dependency *dep) {
const char *fmt;
struct varbuf depstr = VARBUF_INIT;
switch (dep->type) {
case dep_depends:
fmt = _("%s depends on %s");
break;
case dep_predepends:
fmt = _("%s pre-depends on %s");
break;
case dep_recommends:
fmt = _("%s recommends %s");
break;
case dep_suggests:
fmt = _("%s suggests %s");
break;
case dep_breaks:
fmt = _("%s breaks %s");
break;
case dep_conflicts:
fmt = _("%s conflicts with %s");
break;
case dep_enhances:
fmt = _("%s enhances %s");
break;
default:
internerr("unknown deptype '%d'", dep->type);
}
varbufdependency(&depstr, dep);
varbufaddc(&depstr, 0);
varbufprintf(addto, fmt, dep->up->name, depstr.buf);
varbuf_destroy(&depstr);
}
static int
mksplit(const char *file_src, const char *prefix, size_t partsize,
size_t maxpartsize, bool msdos)
{
int fd_src;
struct stat st;
char hash[MD5HASHLEN + 1];
char *package, *version;
int nparts, curpart;
off_t startat;
char *prefixdir = NULL, *msdos_prefix = NULL;
struct varbuf file_dst = VARBUF_INIT;
struct varbuf partmagic = VARBUF_INIT;
struct varbuf partname = VARBUF_INIT;
char *partdata;
fd_src = open(file_src, O_RDONLY);
if (fd_src < 0)
ohshite(_("unable to open source file `%.250s'"), file_src);
if (fstat(fd_src, &st))
ohshite(_("unable to fstat source file"));
if (!S_ISREG(st.st_mode))
ohshit(_("source file `%.250s' not a plain file"), file_src);
fd_md5(fd_src, hash, -1, "md5hash");
lseek(fd_src, 0, SEEK_SET);
/* FIXME: Use libdpkg-deb. */
package = deb_field(file_src, "Package");
version = deb_field(file_src, "Version");
nparts = (st.st_size + partsize - 1) / partsize;
setvbuf(stdout, NULL, _IONBF, 0);
printf("Splitting package %s into %d parts: ", package, nparts);
if (msdos) {
char *t;
t = m_strdup(prefix);
prefixdir = m_strdup(dirname(t));
free(t);
t = m_strdup(prefix);
msdos_prefix = m_strdup(basename(t));
free(t);
prefix = clean_msdos_filename(msdos_prefix);
}
partdata = m_malloc(partsize);
curpart = 1;
for (startat = 0; startat < st.st_size; startat += partsize) {
int fd_dst;
ssize_t partrealsize;
varbufreset(&file_dst);
/* Generate output filename. */
if (msdos) {
struct varbuf refname = VARBUF_INIT;
int prefix_max;
varbufprintf(&refname, "%dof%d", curpart, nparts);
prefix_max = max(8 - strlen(refname.buf), 0);
varbufprintf(&file_dst, "%s/%.*s%.8s.deb",
prefixdir, prefix_max, prefix,
refname.buf);
varbuf_destroy(&refname);
} else {
varbufprintf(&file_dst, "%s.%dof%d.deb",
prefix, curpart, nparts);
}
/* Read data from the original package. */
partrealsize = read(fd_src, partdata, partsize);
if (partrealsize < 0)
ohshite("mksplit: read");
if ((size_t)partrealsize > maxpartsize) {
ohshit("Header is too long, making part too long. "
"Your package name or version\n"
"numbers must be extraordinarily long, "
"or something. Giving up.\n");
}
/* Split the data. */
fd_dst = open(file_dst.buf, O_CREAT | O_WRONLY, 0644);
if (fd_dst < 0)
ohshite(_("unable to open file '%s'"), file_dst.buf);
/* Write the ar header. */
dpkg_ar_put_magic(file_dst.buf, fd_dst);
/* Write the debian-split part. */
varbufprintf(&partmagic, "%s\n%s\n%s\n%s\n%zu\n%zu\n%d/%d\n",
SPLITVERSION, package, version, hash,
st.st_size, partsize, curpart, nparts);
dpkg_ar_member_put_mem(file_dst.buf, fd_dst, PARTMAGIC,
partmagic.buf, partmagic.used);
varbufreset(&partmagic);
/* Write the data part. */
varbufprintf(&partname, "data.%d", curpart);
dpkg_ar_member_put_mem(file_dst.buf, fd_dst, partname.buf,
partdata, (size_t)partrealsize);
varbufreset(&partname);
close(fd_dst);
printf("%d ", curpart);
curpart++;
}
varbuf_destroy(&file_dst);
varbuf_destroy(&partname);
varbuf_destroy(&partmagic);
free(partdata);
free(prefixdir);
free(msdos_prefix);
close(fd_src);
printf("done\n");
return 0;
}
void
show1package(const struct lstitem *head, struct pkginfo *pkg)
{
struct varbuf vb = VARBUF_INIT, fb = VARBUF_INIT, wb = VARBUF_INIT;
/* Make sure we have package info available, even if it's all empty. */
if (!pkg->installed.valid)
blankpackageperfile(&pkg->installed);
while (head) {
int ok;
char fmt[16];
ok = 0;
if (head->width > 0)
snprintf(fmt, 16, "%%%s%zds",
((head->pad) ? "-" : ""), head->width);
else
strcpy(fmt, "%s");
if (head->type == string) {
varbufprintf(&fb, fmt, head->data);
ok = 1;
} else if (head->type == field) {
const struct fieldinfo *fip;
for (fip = fieldinfos; fip->name; fip++)
if (strcasecmp(head->data, fip->name) == 0) {
fip->wcall(&wb, pkg, &pkg->installed, 0, fip);
varbufaddc(&wb, '\0');
varbufprintf(&fb, fmt, wb.buf);
varbufreset(&wb);
ok = 1;
break;
}
if (!fip->name && pkg->installed.valid) {
const struct arbitraryfield *afp;
for (afp = pkg->installed.arbs; afp; afp = afp->next)
if (strcasecmp(head->data, afp->name) == 0) {
varbufprintf(&fb, fmt, afp->value);
ok = 1;
break;
}
}
}
if (ok) {
size_t len = strlen(fb.buf);
if ((head->width > 0) && (len > head->width))
len = head->width;
varbufaddbuf(&vb, fb.buf, len);
}
varbufreset(&fb);
head = head->next;
}
if (vb.buf) {
varbufaddc(&vb, '\0');
fputs(vb.buf, stdout);
}
varbuffree(&wb);
varbuffree(&fb);
varbuffree(&vb);
}
void
pkg_format_show(const struct pkg_format_node *head,
struct pkginfo *pkg, struct pkginfoperfile *pif)
{
struct varbuf vb = VARBUF_INIT, fb = VARBUF_INIT, wb = VARBUF_INIT;
while (head) {
bool ok;
char fmt[16];
ok = false;
if (head->width > 0)
snprintf(fmt, 16, "%%%s%zds",
((head->pad) ? "-" : ""), head->width);
else
strcpy(fmt, "%s");
if (head->type == string) {
varbufprintf(&fb, fmt, head->data);
ok = true;
} else if (head->type == field) {
const struct fieldinfo *fip;
for (fip = fieldinfos; fip->name; fip++)
if (strcasecmp(head->data, fip->name) == 0) {
fip->wcall(&wb, pkg, pif, 0, fip);
varbufaddc(&wb, '\0');
varbufprintf(&fb, fmt, wb.buf);
varbufreset(&wb);
ok = true;
break;
}
if (!fip->name) {
const struct arbitraryfield *afp;
for (afp = pif->arbs; afp; afp = afp->next)
if (strcasecmp(head->data, afp->name) == 0) {
varbufprintf(&fb, fmt, afp->value);
ok = true;
break;
}
}
}
if (ok) {
size_t len = strlen(fb.buf);
if ((head->width > 0) && (len > head->width))
len = head->width;
varbufaddbuf(&vb, fb.buf, len);
}
varbufreset(&fb);
head = head->next;
}
if (vb.buf) {
varbufaddc(&vb, '\0');
fputs(vb.buf, stdout);
}
varbuf_destroy(&wb);
varbuf_destroy(&fb);
varbuf_destroy(&vb);
}
