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); }