tools/rpmtool.c

Go to the documentation of this file.

#include "system.h"
const char *__progname;

#include <rpmcli.h>
#include <rpmxp.h>

#include <rpmlead.h>
#include <signature.h>
#include "header_internal.h"
#include "misc.h"
#include "debug.h"

static int _rpmtool_debug = 0;

typedef struct rpmavi_s * rpmavi;

struct rpmavi_s {
    const char ** av;
    int flags;
};

static rpmavi rpmaviFree(rpmavi avi)
{
    if (avi) {
        memset(avi, 0, sizeof(*avi));
        avi = _free(avi);
    }
    return NULL;
}

static rpmavi rpmaviNew(const char ** av, int flags)
{
    rpmavi avi = xcalloc(1, sizeof(*avi));
    if (avi) {
        avi->av = av;
        avi->flags = flags;
    }
    return avi;
}

static const char * rpmaviNext(rpmavi avi)
{
    const char * a = NULL;

    if (avi && avi->av && *avi->av)
        a = *avi->av++;
    return a;
}

/*@observer@*/ /*@unchecked@*/
static const struct headerTagTableEntry_s rpmSTagTbl[] = {
        { "RPMTAG_HEADERIMAGE", HEADER_IMAGE, RPM_BIN_TYPE },
        { "RPMTAG_HEADERSIGNATURES", HEADER_SIGNATURES, RPM_BIN_TYPE },
        { "RPMTAG_HEADERIMMUTABLE", HEADER_IMMUTABLE, RPM_BIN_TYPE },
        { "RPMTAG_HEADERREGIONS", HEADER_REGIONS, RPM_BIN_TYPE },
        { "RPMTAG_SIGSIZE", 999+1, RPM_INT32_TYPE },
        { "RPMTAG_SIGLEMD5_1", 999+2, RPM_BIN_TYPE },
        { "RPMTAG_SIGPGP", 999+3, RPM_BIN_TYPE },
        { "RPMTAG_SIGLEMD5_2", 999+4, RPM_BIN_TYPE },
        { "RPMTAG_SIGMD5", 999+5, RPM_BIN_TYPE },
        { "RPMTAG_SIGGPG", 999+6, RPM_BIN_TYPE },
        { "RPMTAG_SIGPGP5", 999+7, RPM_BIN_TYPE },
        { "RPMTAG_SIGPAYLOADSIZE", 999+8, RPM_INT32_TYPE },
        { "RPMTAG_BADSHA1_1", HEADER_SIGBASE+8, RPM_STRING_TYPE },
        { "RPMTAG_BADSHA1_2", HEADER_SIGBASE+9, RPM_STRING_TYPE },
        { "RPMTAG_PUBKEYS", HEADER_SIGBASE+10, RPM_STRING_ARRAY_TYPE },
        { "RPMTAG_DSAHEADER", HEADER_SIGBASE+11, RPM_BIN_TYPE },
        { "RPMTAG_RSAHEADER", HEADER_SIGBASE+12, RPM_BIN_TYPE },
        { "RPMTAG_SHA1HEADER", HEADER_SIGBASE+13, RPM_STRING_TYPE },
        { NULL, 0 }
};

/*@observer@*/ /*@unchecked@*/
const struct headerTagTableEntry_s * rpmSTagTable = rpmSTagTbl;


typedef enum rpmtoolIOBits_e {
    RPMIOBITS_NONE      = 0,
    RPMIOBITS_LEAD      = (1 <<  0),
    RPMIOBITS_SHEADER   = (1 <<  1),
    RPMIOBITS_HEADER    = (1 <<  2),
    RPMIOBITS_PAYLOAD   = (1 <<  3),
    RPMIOBITS_FDIO      = (1 <<  4),
    RPMIOBITS_UFDIO     = (1 <<  5),
    RPMIOBITS_GZDIO     = (1 <<  6),
    RPMIOBITS_BZDIO     = (1 <<  7),
    RPMIOBITS_UNCOMPRESS= (1 <<  8),
    RPMIOBITS_BINARY    = (1 <<  9),
    RPMIOBITS_DUMP      = (1 << 10),
    RPMIOBITS_XML       = (1 << 11)
} rpmtoolIOBits;

static const char * iav[] = { "-", NULL };
static const char * ifmt = NULL;
static const char * ipath = NULL;
static const char * imode = NULL;
static rpmtoolIOBits ibits = RPMIOBITS_NONE;

static const char * oav[] = { "-", NULL };
static const char * ofmt = NULL;
static const char * opath = NULL;
static const char * omode = NULL;
static rpmtoolIOBits obits = RPMIOBITS_NONE;

static struct iobits_s {
    const char * name;
    rpmtoolIOBits bits;
} iobits[] = {
    { "lead",           RPMIOBITS_LEAD },
    { "sheader",        RPMIOBITS_SHEADER },
    { "header",         RPMIOBITS_HEADER },
    { "payload",        RPMIOBITS_PAYLOAD },
#define _RPMIOBITS_PKGMASK \
    (RPMIOBITS_LEAD|RPMIOBITS_SHEADER|RPMIOBITS_HEADER|RPMIOBITS_PAYLOAD)

    { "fdio",           RPMIOBITS_FDIO },
    { "ufdio",          RPMIOBITS_UFDIO },
    { "gzdio",          RPMIOBITS_GZDIO },
    { "bzdio",          RPMIOBITS_BZDIO },
#define _RPMIOBITS_MODEMASK \
    (RPMIOBITS_FDIO|RPMIOBITS_UFDIO|RPMIOBITS_GZDIO|RPMIOBITS_BZDIO)

    { "uncompress",     RPMIOBITS_UNCOMPRESS },
    { "binary",         RPMIOBITS_BINARY },
    { "dump",           RPMIOBITS_DUMP },
    { "xml",            RPMIOBITS_XML },
    { NULL,     0 },
};

static int parseFmt(const char * fmt, rpmtoolIOBits * bits, const char ** mode)
{
    const char *f, *fe;

    if (fmt != NULL)
    for (f = fmt; f && *f; f = fe) {
        struct iobits_s * iop;
        size_t nfe;
        
        if ((fe = strchr(f, ',')) == NULL)
            fe = f + strlen(f);
        nfe = (fe - f);

        for (iop = iobits; iop->name != NULL; iop++) {
            if (strncmp(iop->name, f, nfe))
                continue;
            *bits |= iop->bits;
            if ((iop->bits & _RPMIOBITS_MODEMASK) && mode && *mode) {
                char * t = xmalloc(2 + strlen(iop->name) + 1);
                t[0] = (*mode)[0];
                t[1] = (*mode)[1];
                (void) stpcpy(t+2, iop->name);
                *mode = _free(*mode);
                *mode = t;
            }
            break;
        }

        if (iop->name == NULL) {
            fprintf(stderr, _("%s: unknown format token \"%*s\", ignored\n"),
                        __progname, nfe, f);
        }

        if (*fe == ',') fe++;   /* skip ',' */
    }
    return 0;
}


static struct poptOption optionsTable[] = {
 { "debug", 'd', POPT_ARG_VAL|POPT_ARGFLAG_DOC_HIDDEN,  &_rpmtool_debug, -1,
        NULL, NULL },

 { "lead", 'L', POPT_BIT_SET,   &obits, RPMIOBITS_LEAD,
        N_("extract lead"), NULL},
 { "sheader", 'S', POPT_BIT_SET,&obits, RPMIOBITS_SHEADER,
        N_("extract signature header"), NULL},
 { "header", 'H', POPT_BIT_SET, &obits, RPMIOBITS_HEADER,
        N_("extract metadata header"), NULL},
 { "dump", 'D', POPT_BIT_SET,   &obits, (RPMIOBITS_HEADER|RPMIOBITS_DUMP),
        N_("dump metadata header"), NULL},
 { "xml", 'X', POPT_BIT_SET,    &obits, (RPMIOBITS_HEADER|RPMIOBITS_XML),
        N_("dump metadata header in xml"), NULL},
 { "archive", 'A', POPT_BIT_SET,&obits, RPMIOBITS_PAYLOAD,
        N_("extract compressed payload"), NULL},
 { "payload", 'P', POPT_BIT_SET,&obits, RPMIOBITS_PAYLOAD|RPMIOBITS_UNCOMPRESS,
        N_("extract uncompressed payload"), NULL},

 { "ipath", 0, POPT_ARG_STRING|POPT_ARGFLAG_DOC_HIDDEN, &ipath, 0,
        N_("input PATH"), N_("PATH") },
 { "imode", 0, POPT_ARG_STRING|POPT_ARGFLAG_DOC_HIDDEN, &imode, 0,
        N_("input MODE"), N_("MODE") },
 { "ifmt", 'I', POPT_ARG_STRING,                        &ifmt, 0,
        N_("input format, FMT is comma separated list of (lead|sheader|header|payload), (ufdio|gzdio|bzdio), (binary|xml)"), N_("FMT") },

 { "opath", 0, POPT_ARG_STRING|POPT_ARGFLAG_DOC_HIDDEN, &opath, 0,
        N_("output PATH"), N_("PATH") },
 { "omode", 0, POPT_ARG_STRING|POPT_ARGFLAG_DOC_HIDDEN, &omode, 0,
        N_("output MODE"), N_("MODE") },
 { "ofmt", 'O', POPT_ARG_STRING,                        &ofmt, 0,
        N_("ouput format, FMT is comma separated list of (lead|sheader|header|payload), (ufdio|gzdio|bzdio), (binary|xml|dump)"), N_("FMT") },

 { NULL, '\0', POPT_ARG_INCLUDE_TABLE, rpmcliAllPoptTable, 0,
        N_("Common options for all rpm modes and executables:"),
        NULL }, 

   POPT_AUTOALIAS
   POPT_AUTOHELP
   POPT_TABLEEND
};

static void initTool(const char * argv0)
{
    setprogname(argv0);
    /* XXX glibc churn sanity */
    if (__progname == NULL) {
        if ((__progname = strrchr(argv0, '/')) != NULL) __progname++;
        else __progname = argv0;
    }

    if (!strcmp(__progname, "rpmlead")) {
        ibits = _RPMIOBITS_PKGMASK;
        obits = RPMIOBITS_LEAD;
    }
    if (!strcmp(__progname, "rpmsignature")) {
        ibits = _RPMIOBITS_PKGMASK;
        obits = RPMIOBITS_SHEADER;
    }
    if (!strcmp(__progname, "rpmheader")) {
        ibits = _RPMIOBITS_PKGMASK;
        obits = RPMIOBITS_HEADER;
    }
    if (!strcmp(__progname, "rpm2cpio")) {
        ibits = _RPMIOBITS_PKGMASK;
        obits = RPMIOBITS_PAYLOAD | RPMIOBITS_UNCOMPRESS;
    }
    if (!strcmp(__progname, "rpmarchive")) {
        ibits = _RPMIOBITS_PKGMASK;
        obits = RPMIOBITS_PAYLOAD;
    }
    if (!strcmp(__progname, "dump")) {
        ibits = _RPMIOBITS_PKGMASK;
        obits = RPMIOBITS_HEADER | RPMIOBITS_DUMP;
    }
    if (!strcmp(__progname, "rpmdump")) {
        ibits = _RPMIOBITS_PKGMASK;
        obits = RPMIOBITS_HEADER | RPMIOBITS_DUMP;
    }
}

static void spewHeader(FD_t fdo, Header h)
{
    headerTagTableEntry tbl = (headerIsEntry(h, RPMTAG_HEADERI18NTABLE))
                                ? rpmTagTable : rpmSTagTable;

    if (obits & RPMIOBITS_DUMP) {
        headerDump(h, stdout, HEADER_DUMP_INLINE, tbl);
    } else if (obits & RPMIOBITS_XML) {
        const char * errstr = NULL;
        const char * fmt = "[%{*:xml}\n]";
        char * t;

        t = headerSprintf(h, fmt, tbl, rpmHeaderFormats, &errstr);
                
        if (t != NULL) {
            if (rpmxpDTD != NULL && *rpmxpDTD != '\0')
                Fwrite(rpmxpDTD, strlen(rpmxpDTD), 1, fdo);
            Fwrite(t, strlen(t), 1, fdo);
        }
        t = _free(t);
    } else
        headerWrite(fdo, h, HEADER_MAGIC_YES);
}

int
main(int argc, char *const argv[])
{
    struct rpmlead lead;
    Header sigh = NULL;
    Header h = NULL;
    FD_t fdi = NULL;
    FD_t fdo = NULL;
    const char ** av = NULL;
    rpmavi avi = NULL;
    const char * ifn = NULL;
    const char * ofn = NULL;
    const char * s;
    char * t, *te;
    poptContext optCon;
    rpmRC rc = RPMRC_OK;
    int ec = 0;
    int xx;

    imode = xstrdup("r.ufdio");
    omode = xstrdup("w.ufdio");

    initTool(argv[0]);       /* Retrofit glibc __progname */

    /* Parse CLI options and args. */
    optCon = rpmcliInit(argc, argv, optionsTable);
    if (optCon == NULL)
        exit(EXIT_FAILURE);

    av = poptGetArgs(optCon);
if (_rpmtool_debug)
fprintf(stderr, "*** av %p av[0] %p av[1] %p\n", av,
(av && av[0] ? av[0] : NULL),
(av && av[0] && av[1] ? av[1] : NULL));
    if (av == NULL) av = iav;

    /* Parse input and output format. */
    parseFmt(ifmt, &ibits, &imode);
    if (!(ibits & _RPMIOBITS_PKGMASK))
        ibits |= _RPMIOBITS_PKGMASK;

    parseFmt(ofmt, &obits, &omode);
    if (!(obits & _RPMIOBITS_PKGMASK))
        obits |= RPMIOBITS_HEADER;

    /* Insure desired output is possible. */
    if (((ibits & obits) & _RPMIOBITS_PKGMASK) != (obits & _RPMIOBITS_PKGMASK))
    {
        fprintf(stderr, _("%s: no input(0x%x) for output(0x%x) components\n"),
                __progname, ibits, obits);
        ec++;
        goto bottom;
    }

    avi = rpmaviNew(av, 0);
    while ((ifn = rpmaviNext(avi)) != NULL) {

        /* Open input file. */
        if (fdi == NULL) {
if (_rpmtool_debug)
fprintf(stderr, "*** Fopen(%s,%s)\n", ifn, imode);
            fdi = Fopen(ifn, imode);
            if (fdi == NULL || Ferror(fdi)) {
                fprintf(stderr, _("%s: input  Fopen(%s, \"%s\"): %s\n"),
                        __progname, ifn, imode, Fstrerror(fdi));
                ec++;
                goto bottom;
            }
        }

        /* Read package components. */
        if (ibits & RPMIOBITS_LEAD) {
            rc = readLead(fdi, &lead);
            if (rc != RPMRC_OK) {
                fprintf(stderr, _("%s: readLead(%s) failed(%d)\n"),
                        __progname, ifn, rc);
                ec++;
                goto bottom;
            }
        }

        if (ibits & RPMIOBITS_SHEADER) {
            const char * msg = NULL;
            rc = rpmReadSignature(fdi, &sigh, RPMSIGTYPE_HEADERSIG, &msg);
            if (rc != RPMRC_OK) {
                fprintf(stderr, _("%s: rpmReadSignature(%s) failed(%d): %s\n"),
                        __progname, ifn, rc, msg);
                msg = _free(msg);
                ec++;
                goto bottom;
            }
        }

        if (ibits & RPMIOBITS_HEADER) {
            h = headerRead(fdi, HEADER_MAGIC_YES);
            if (h == NULL) {
                fprintf(stderr, _("%s: headerRead(%s) failed\n"),
                        __progname, ifn);
                ec++;
                goto bottom;
            }
        }

        /* Determine output file name, and create directories in path. */
        if (fdo == NULL) {
            if (opath != NULL) {
                const char * errstr = "(unkown error)";
                int ut;

                /* Macro and --queryformat expanded file path. */
                s = rpmGetPath(opath, NULL);
                ofn = headerSprintf(h, s, rpmTagTable, rpmHeaderFormats, &errstr);
                s = _free(s);
                if (ofn == NULL) {
                    fprintf(stderr, _("%s: headerSprintf(%s) failed: %s\n"),
                                __progname, ofn, errstr);
                    ec++;
                    goto bottom;
                }

                /* Create directories in path. */
                s = xstrdup(ofn);
                ut = urlPath(s, (const char **)&t);
                if (t != NULL)
                for (te=strchr(t+1,'/'); (t=te) != NULL; te = strchr(t+1,'/')) {
                    *t = '\0';
                    rc = rpmMkdirPath(s, "opath");
                    *t = '/';
                    if (rc != RPMRC_OK) break;
                }
                s = _free(s);
                if (rc != RPMRC_OK) {
                    fprintf(stderr, _("%s: rpmMkdirPath(%s) failed.\n"),
                                __progname, ofn);
                    ec++;
                    goto bottom;
                }
            }

            /* Open output file. */
if (_rpmtool_debug)
fprintf(stderr, "*** Fopen(%s,%s)\n", (ofn != NULL ? ofn : "-"), omode);
            fdo = (ofn != NULL ? Fopen(ofn, omode) : fdDup(STDOUT_FILENO));
            if (fdo == NULL || Ferror(fdo)) {
                fprintf(stderr, _("%s: output Fopen(%s, \"%s\"): %s\n"),
                        __progname, (ofn != NULL ? ofn : "<stdout>"),
                        omode, Fstrerror(fdo));
                ec++;
                goto bottom;
            }
        }

        /* Write package components. */
        if (obits & RPMIOBITS_LEAD)
            writeLead(fdo, &lead);

        if (obits & RPMIOBITS_SHEADER)
            spewHeader(fdo, sigh);

        if (obits & RPMIOBITS_HEADER)
            spewHeader(fdo, h);

        if (obits & RPMIOBITS_PAYLOAD)
        {
            if (obits & RPMIOBITS_UNCOMPRESS) {
                const char * payload_compressor = NULL;
                const char * rpmio_flags;
                FD_t gzdi;

                /* Retrieve type of payload compression. */
                if (!headerGetEntry(h, RPMTAG_PAYLOADCOMPRESSOR, NULL,
                            (void **) &payload_compressor, NULL))
                    payload_compressor = "gzip";
                rpmio_flags = t = alloca(sizeof("r.gzdio"));
                *t++ = 'r';
                if (!strcmp(payload_compressor, "gzip"))
                    t = stpcpy(t, ".gzdio");
                if (!strcmp(payload_compressor, "bzip2"))
                    t = stpcpy(t, ".bzdio");

                gzdi = Fdopen(fdi, rpmio_flags);        /* XXX gzdi == fdi */
                if (gzdi == NULL) {
                    fprintf(stderr, _("%s: output Fdopen(%s, \"%s\"): %s\n"),
                        __progname, (ofn != NULL ? ofn : "-"),
                        rpmio_flags, Fstrerror(fdo));
                    ec++;
                    goto bottom;
                }

                rc = ufdCopy(gzdi, fdo);
                xx = Fclose(gzdi);      /* XXX gzdi == fdi */
                if (rc <= 0) {
                    ec++;
                    goto bottom;
                }
            } else {
                char buffer[BUFSIZ];
                int ct;
                while ((ct = Fread(buffer, sizeof(buffer), 1, fdi)))
                    Fwrite(buffer, ct, 1, fdo);
            }
        }

bottom:
        sigh = headerFree(sigh);
        h = headerFree(h);
        ofn = _free(ofn);

        if (fdi != NULL && Fileno(fdi) != STDIN_FILENO) {
            xx = Fclose(fdi);
            fdi = NULL;
        }
        if (fdo != NULL && Fileno(fdo) != STDOUT_FILENO) {
            xx = Fclose(fdo);
            fdo = NULL;
        }
    }
    avi = rpmaviFree(avi);

exit:
    sigh = headerFree(sigh);
    h = headerFree(h);
    ofn = _free(ofn);

    if (fdi != NULL && Fileno(fdi) != STDIN_FILENO) {
        xx = Fclose(fdi);
        fdi = NULL;
    }
    if (fdo != NULL && Fileno(fdo) != STDOUT_FILENO) {
        xx = Fclose(fdi);
        fdi = NULL;
    }
    optCon = rpmcliFini(optCon);

    imode = _free(imode);
    omode = _free(omode);

    return ec;
}

---