build/files.c

Go to the documentation of this file.

#include "system.h"

#define MYALLPERMS      07777

#include <regex.h>

#include <rpmio_internal.h>
#include <fts.h>

#include <rpmbuild.h>

#include "cpio.h"

#include "argv.h"
#include "rpmfc.h"

#define _RPMFI_INTERNAL
#include "rpmfi.h"

#include "rpmsx.h"


#define _RPMTE_INTERNAL
#include "rpmte.h"

#include "buildio.h"

#include "legacy.h"     /* XXX dodigest */
#include "misc.h"
#include "debug.h"

/*@access Header @*/
/*@access rpmfi @*/
/*@access rpmte @*/
/*@access FD_t @*/
/*@access StringBuf @*/         /* compared with NULL */

#define SKIPWHITE(_x)   {while(*(_x) && (xisspace(*_x) || *(_x) == ',')) (_x)++;}
#define SKIPNONWHITE(_x){while(*(_x) &&!(xisspace(*_x) || *(_x) == ',')) (_x)++;}

#define MAXDOCDIR 1024

typedef enum specdFlags_e {
    SPECD_DEFFILEMODE   = (1 << 0),
    SPECD_DEFDIRMODE    = (1 << 1),
    SPECD_DEFUID        = (1 << 2),
    SPECD_DEFGID        = (1 << 3),
    SPECD_DEFVERIFY     = (1 << 4),

    SPECD_FILEMODE      = (1 << 8),
    SPECD_DIRMODE       = (1 << 9),
    SPECD_UID           = (1 << 10),
    SPECD_GID           = (1 << 11),
    SPECD_VERIFY        = (1 << 12)
} specdFlags;

typedef struct FileListRec_s {
    struct stat fl_st;
#define fl_dev  fl_st.st_dev
#define fl_ino  fl_st.st_ino
#define fl_mode fl_st.st_mode
#define fl_nlink fl_st.st_nlink
#define fl_uid  fl_st.st_uid
#define fl_gid  fl_st.st_gid
#define fl_rdev fl_st.st_rdev
#define fl_size fl_st.st_size
#define fl_mtime fl_st.st_mtime

/*@only@*/
    const char *diskURL;        /* get file from here       */
/*@only@*/
    const char *fileURL;        /* filename in cpio archive */
/*@observer@*/
    const char *uname;
/*@observer@*/
    const char *gname;
    unsigned    flags;
    specdFlags  specdFlags;     /* which attributes have been explicitly specified. */
    unsigned    verifyFlags;
/*@only@*/
    const char *langs;          /* XXX locales separated with | */
} * FileListRec;

typedef struct AttrRec_s {
/*@null@*/
    const char *ar_fmodestr;
/*@null@*/
    const char *ar_dmodestr;
/*@null@*/
    const char *ar_user;
/*@null@*/
    const char *ar_group;
    mode_t      ar_fmode;
    mode_t      ar_dmode;
} * AttrRec;

/*@-readonlytrans@*/
/*@unchecked@*/ /*@observer@*/
static struct AttrRec_s root_ar = { NULL, NULL, "root", "root", 0, 0 };
/*@=readonlytrans@*/

/* list of files */
/*@unchecked@*/ /*@only@*/ /*@null@*/
static StringBuf check_fileList = NULL;

typedef struct FileList_s {
/*@only@*/
    const char * buildRootURL;
/*@only@*/
    const char * prefix;

    int fileCount;
    int totalFileSize;
    int processingFailed;

    int passedSpecialDoc;
    int isSpecialDoc;

    int noGlob;
    unsigned devtype;
    unsigned devmajor;
    int devminor;
    
    int isDir;
    int inFtw;
    int currentFlags;
    specdFlags currentSpecdFlags;
    int currentVerifyFlags;
    struct AttrRec_s cur_ar;
    struct AttrRec_s def_ar;
    specdFlags defSpecdFlags;
    int defVerifyFlags;
    int nLangs;
/*@only@*/ /*@null@*/
    const char ** currentLangs;

    /* Hard coded limit of MAXDOCDIR docdirs.         */
    /* If you break it you are doing something wrong. */
    const char * docDirs[MAXDOCDIR];
    int docDirCount;
    
/*@only@*/
    FileListRec fileList;
    int fileListRecsAlloced;
    int fileListRecsUsed;
} * FileList;

static void nullAttrRec(/*@out@*/ AttrRec ar)   /*@modifies ar @*/
{
    ar->ar_fmodestr = NULL;
    ar->ar_dmodestr = NULL;
    ar->ar_user = NULL;
    ar->ar_group = NULL;
    ar->ar_fmode = 0;
    ar->ar_dmode = 0;
}

static void freeAttrRec(AttrRec ar)     /*@modifies ar @*/
{
    ar->ar_fmodestr = _free(ar->ar_fmodestr);
    ar->ar_dmodestr = _free(ar->ar_dmodestr);
    ar->ar_user = _free(ar->ar_user);
    ar->ar_group = _free(ar->ar_group);
    /* XXX doesn't free ar (yet) */
    /*@-nullstate@*/
    return;
    /*@=nullstate@*/
}

static void dupAttrRec(const AttrRec oar, /*@in@*/ /*@out@*/ AttrRec nar)
        /*@modifies nar @*/
{
    if (oar == nar)
        return;
    freeAttrRec(nar);
    nar->ar_fmodestr = (oar->ar_fmodestr ? xstrdup(oar->ar_fmodestr) : NULL);
    nar->ar_dmodestr = (oar->ar_dmodestr ? xstrdup(oar->ar_dmodestr) : NULL);
    nar->ar_user = (oar->ar_user ? xstrdup(oar->ar_user) : NULL);
    nar->ar_group = (oar->ar_group ? xstrdup(oar->ar_group) : NULL);
    nar->ar_fmode = oar->ar_fmode;
    nar->ar_dmode = oar->ar_dmode;
}

#if 0

static void dumpAttrRec(const char * msg, AttrRec ar)
        /*@globals fileSystem@*/
        /*@modifies fileSystem @*/
{
    if (msg)
        fprintf(stderr, "%s:\t", msg);
    fprintf(stderr, "(%s, %s, %s, %s)\n",
        ar->ar_fmodestr,
        ar->ar_user,
        ar->ar_group,
        ar->ar_dmodestr);
}
#endif

/*@-boundswrite@*/
/*@null@*/
static char *strtokWithQuotes(/*@null@*/ char *s, char *delim)
        /*@modifies *s @*/
{
    static char *olds = NULL;
    char *token;

    if (s == NULL)
        s = olds;
    if (s == NULL)
        return NULL;

    /* Skip leading delimiters */
    s += strspn(s, delim);
    if (*s == '\0')
        return NULL;

    /* Find the end of the token.  */
    token = s;
    if (*token == '"') {
        token++;
        /* Find next " char */
        s = strchr(token, '"');
    } else {
        s = strpbrk(token, delim);
    }

    /* Terminate it */
    if (s == NULL) {
        /* This token finishes the string */
        olds = strchr(token, '\0');
    } else {
        /* Terminate the token and make olds point past it */
        *s = '\0';
        olds = s+1;
    }

    /*@-retalias -temptrans @*/
    return token;
    /*@=retalias =temptrans @*/
}
/*@=boundswrite@*/

static void timeCheck(int tc, Header h)
        /*@globals internalState @*/
        /*@modifies internalState @*/
{
    HGE_t hge = (HGE_t)headerGetEntryMinMemory;
    HFD_t hfd = headerFreeData;
    int * mtime;
    const char ** files;
    rpmTagType fnt;
    int count, x;
    time_t currentTime = time(NULL);

    x = hge(h, RPMTAG_OLDFILENAMES, &fnt, (void **) &files, &count);
    x = hge(h, RPMTAG_FILEMTIMES, NULL, (void **) &mtime, NULL);
    
/*@-boundsread@*/
    for (x = 0; x < count; x++) {
        if ((currentTime - mtime[x]) > tc)
            rpmMessage(RPMMESS_WARNING, _("TIMECHECK failure: %s\n"), files[x]);
    }
    files = hfd(files, fnt);
/*@=boundsread@*/
}

typedef struct VFA {
/*@observer@*/ /*@null@*/ const char * attribute;
    int not;
    int flag;
} VFA_t;

/*@-exportlocal -exportheadervar@*/
/*@unchecked@*/
VFA_t verifyAttrs[] = {
    { "md5",    0,      RPMVERIFY_MD5 },
    { "size",   0,      RPMVERIFY_FILESIZE },
    { "link",   0,      RPMVERIFY_LINKTO },
    { "user",   0,      RPMVERIFY_USER },
    { "group",  0,      RPMVERIFY_GROUP },
    { "mtime",  0,      RPMVERIFY_MTIME },
    { "mode",   0,      RPMVERIFY_MODE },
    { "rdev",   0,      RPMVERIFY_RDEV },
    { NULL, 0,  0 }
};
/*@=exportlocal =exportheadervar@*/

/*@-boundswrite@*/
static int parseForVerify(char * buf, FileList fl)
        /*@modifies buf, fl->processingFailed,
                fl->currentVerifyFlags, fl->defVerifyFlags,
                fl->currentSpecdFlags, fl->defSpecdFlags @*/
{
    char *p, *pe, *q;
    const char *name;
    int *resultVerify;
    int negated;
    int verifyFlags;
    specdFlags * specdFlags;

    if ((p = strstr(buf, (name = "%verify"))) != NULL) {
        resultVerify = &(fl->currentVerifyFlags);
        specdFlags = &fl->currentSpecdFlags;
    } else if ((p = strstr(buf, (name = "%defverify"))) != NULL) {
        resultVerify = &(fl->defVerifyFlags);
        specdFlags = &fl->defSpecdFlags;
    } else
        return 0;

    for (pe = p; (pe-p) < strlen(name); pe++)
        *pe = ' ';

    SKIPSPACE(pe);

    if (*pe != '(') {
        rpmError(RPMERR_BADSPEC, _("Missing '(' in %s %s\n"), name, pe);
        fl->processingFailed = 1;
        return RPMERR_BADSPEC;
    }

    /* Bracket %*verify args */
    *pe++ = ' ';
    for (p = pe; *pe && *pe != ')'; pe++)
        {};

    if (*pe == '\0') {
        rpmError(RPMERR_BADSPEC, _("Missing ')' in %s(%s\n"), name, p);
        fl->processingFailed = 1;
        return RPMERR_BADSPEC;
    }

    /* Localize. Erase parsed string */
    q = alloca((pe-p) + 1);
    strncpy(q, p, pe-p);
    q[pe-p] = '\0';
    while (p <= pe)
        *p++ = ' ';

    negated = 0;
    verifyFlags = RPMVERIFY_NONE;

    for (p = q; *p != '\0'; p = pe) {
        SKIPWHITE(p);
        if (*p == '\0')
            break;
        pe = p;
        SKIPNONWHITE(pe);
        if (*pe != '\0')
            *pe++ = '\0';

        {   VFA_t *vfa;
            for (vfa = verifyAttrs; vfa->attribute != NULL; vfa++) {
                if (strcmp(p, vfa->attribute))
                    /*@innercontinue@*/ continue;
                verifyFlags |= vfa->flag;
                /*@innerbreak@*/ break;
            }
            if (vfa->attribute)
                continue;
        }

        if (!strcmp(p, "not")) {
            negated ^= 1;
        } else {
            rpmError(RPMERR_BADSPEC, _("Invalid %s token: %s\n"), name, p);
            fl->processingFailed = 1;
            return RPMERR_BADSPEC;
        }
    }

    *resultVerify = negated ? ~(verifyFlags) : verifyFlags;
    *specdFlags |= SPECD_VERIFY;

    return 0;
}
/*@=boundswrite@*/

#define isAttrDefault(_ars)     ((_ars)[0] == '-' && (_ars)[1] == '\0')

/*@-boundswrite@*/
static int parseForDev(char * buf, FileList fl)
        /*@modifies buf, fl->processingFailed,
                fl->noGlob, fl->devtype, fl->devmajor, fl->devminor @*/
{
    const char * name;
    const char * errstr = NULL;
    char *p, *pe, *q;
    int rc = RPMERR_BADSPEC;    /* assume error */

    if ((p = strstr(buf, (name = "%dev"))) == NULL)
        return 0;

    for (pe = p; (pe-p) < strlen(name); pe++)
        *pe = ' ';
    SKIPSPACE(pe);

    if (*pe != '(') {
        errstr = "'('";
        goto exit;
    }

    /* Bracket %dev args */
    *pe++ = ' ';
    for (p = pe; *pe && *pe != ')'; pe++)
        {};
    if (*pe != ')') {
        errstr = "')'";
        goto exit;
    }

    /* Localize. Erase parsed string */
    q = alloca((pe-p) + 1);
    strncpy(q, p, pe-p);
    q[pe-p] = '\0';
    while (p <= pe)
        *p++ = ' ';

    p = q; SKIPWHITE(p);
    pe = p; SKIPNONWHITE(pe); if (*pe != '\0') *pe++ = '\0';
    if (*p == 'b')
        fl->devtype = 'b';
    else if (*p == 'c')
        fl->devtype = 'c';
    else {
        errstr = "devtype";
        goto exit;
    }

    p = pe; SKIPWHITE(p);
    pe = p; SKIPNONWHITE(pe); if (*pe != '\0') *pe++ = '\0';
    for (pe = p; *pe && xisdigit(*pe); pe++)
        {} ;
    if (*pe == '\0') {
        fl->devmajor = atoi(p);
        /*@-unsignedcompare @*/ /* LCL: ge is ok */
        if (!(fl->devmajor >= 0 && fl->devmajor < 256)) {
            errstr = "devmajor";
            goto exit;
        }
        /*@=unsignedcompare @*/
        pe++;
    } else {
        errstr = "devmajor";
        goto exit;
    }

    p = pe; SKIPWHITE(p);
    pe = p; SKIPNONWHITE(pe); if (*pe != '\0') *pe++ = '\0';
    for (pe = p; *pe && xisdigit(*pe); pe++)
        {} ;
    if (*pe == '\0') {
        fl->devminor = atoi(p);
        if (!(fl->devminor >= 0 && fl->devminor < 256)) {
            errstr = "devminor";
            goto exit;
        }
        pe++;
    } else {
        errstr = "devminor";
        goto exit;
    }

    fl->noGlob = 1;

    rc = 0;

exit:
    if (rc) {
        rpmError(RPMERR_BADSPEC, _("Missing %s in %s %s\n"), errstr, name, p);
        fl->processingFailed = 1;
    }
    return rc;
}
/*@=boundswrite@*/

/*@-boundswrite@*/
static int parseForAttr(char * buf, FileList fl)
        /*@modifies buf, fl->processingFailed,
                fl->cur_ar, fl->def_ar,
                fl->currentSpecdFlags, fl->defSpecdFlags @*/
{
    const char *name;
    char *p, *pe, *q;
    int x;
    struct AttrRec_s arbuf;
    AttrRec ar = &arbuf, ret_ar;
    specdFlags * specdFlags;

    if ((p = strstr(buf, (name = "%attr"))) != NULL) {
        ret_ar = &(fl->cur_ar);
        specdFlags = &fl->currentSpecdFlags;
    } else if ((p = strstr(buf, (name = "%defattr"))) != NULL) {
        ret_ar = &(fl->def_ar);
        specdFlags = &fl->defSpecdFlags;
    } else
        return 0;

    for (pe = p; (pe-p) < strlen(name); pe++)
        *pe = ' ';

    SKIPSPACE(pe);

    if (*pe != '(') {
        rpmError(RPMERR_BADSPEC, _("Missing '(' in %s %s\n"), name, pe);
        fl->processingFailed = 1;
        return RPMERR_BADSPEC;
    }

    /* Bracket %*attr args */
    *pe++ = ' ';
    for (p = pe; *pe && *pe != ')'; pe++)
        {};

    if (ret_ar == &(fl->def_ar)) {      /* %defattr */
        q = pe;
        q++;
        SKIPSPACE(q);
        if (*q != '\0') {
            rpmError(RPMERR_BADSPEC,
                     _("Non-white space follows %s(): %s\n"), name, q);
            fl->processingFailed = 1;
            return RPMERR_BADSPEC;
        }
    }

    /* Localize. Erase parsed string */
    q = alloca((pe-p) + 1);
    strncpy(q, p, pe-p);
    q[pe-p] = '\0';
    while (p <= pe)
        *p++ = ' ';

    nullAttrRec(ar);

    p = q; SKIPWHITE(p);
    if (*p != '\0') {
        pe = p; SKIPNONWHITE(pe); if (*pe != '\0') *pe++ = '\0';
        ar->ar_fmodestr = p;
        p = pe; SKIPWHITE(p);
    }
    if (*p != '\0') {
        pe = p; SKIPNONWHITE(pe); if (*pe != '\0') *pe++ = '\0';
        ar->ar_user = p;
        p = pe; SKIPWHITE(p);
    }
    if (*p != '\0') {
        pe = p; SKIPNONWHITE(pe); if (*pe != '\0') *pe++ = '\0';
        ar->ar_group = p;
        p = pe; SKIPWHITE(p);
    }
    if (*p != '\0' && ret_ar == &(fl->def_ar)) {        /* %defattr */
        pe = p; SKIPNONWHITE(pe); if (*pe != '\0') *pe++ = '\0';
        ar->ar_dmodestr = p;
        p = pe; SKIPWHITE(p);
    }

    if (!(ar->ar_fmodestr && ar->ar_user && ar->ar_group) || *p != '\0') {
        rpmError(RPMERR_BADSPEC, _("Bad syntax: %s(%s)\n"), name, q);
        fl->processingFailed = 1;
        return RPMERR_BADSPEC;
    }

    /* Do a quick test on the mode argument and adjust for "-" */
    if (ar->ar_fmodestr && !isAttrDefault(ar->ar_fmodestr)) {
        unsigned int ui;
        x = sscanf(ar->ar_fmodestr, "%o", &ui);
        if ((x == 0) || (ar->ar_fmode & ~MYALLPERMS)) {
            rpmError(RPMERR_BADSPEC, _("Bad mode spec: %s(%s)\n"), name, q);
            fl->processingFailed = 1;
            return RPMERR_BADSPEC;
        }
        ar->ar_fmode = ui;
    } else
        ar->ar_fmodestr = NULL;

    if (ar->ar_dmodestr && !isAttrDefault(ar->ar_dmodestr)) {
        unsigned int ui;
        x = sscanf(ar->ar_dmodestr, "%o", &ui);
        if ((x == 0) || (ar->ar_dmode & ~MYALLPERMS)) {
            rpmError(RPMERR_BADSPEC, _("Bad dirmode spec: %s(%s)\n"), name, q);
            fl->processingFailed = 1;
            return RPMERR_BADSPEC;
        }
        ar->ar_dmode = ui;
    } else
        ar->ar_dmodestr = NULL;

    if (!(ar->ar_user && !isAttrDefault(ar->ar_user)))
        ar->ar_user = NULL;

    if (!(ar->ar_group && !isAttrDefault(ar->ar_group)))
        ar->ar_group = NULL;

    dupAttrRec(ar, ret_ar);

    /* XXX fix all this */
    *specdFlags |= SPECD_UID | SPECD_GID | SPECD_FILEMODE | SPECD_DIRMODE;
    
    return 0;
}
/*@=boundswrite@*/

/*@-boundswrite@*/
static int parseForConfig(char * buf, FileList fl)
        /*@modifies buf, fl->processingFailed, fl->currentFlags @*/
{
    char *p, *pe, *q;
    const char *name;

    if ((p = strstr(buf, (name = "%config"))) == NULL)
        return 0;

    fl->currentFlags |= RPMFILE_CONFIG;

    /* Erase "%config" token. */
    for (pe = p; (pe-p) < strlen(name); pe++)
        *pe = ' ';
    SKIPSPACE(pe);
    if (*pe != '(')
        return 0;

    /* Bracket %config args */
    *pe++ = ' ';
    for (p = pe; *pe && *pe != ')'; pe++)
        {};

    if (*pe == '\0') {
        rpmError(RPMERR_BADSPEC, _("Missing ')' in %s(%s\n"), name, p);
        fl->processingFailed = 1;
        return RPMERR_BADSPEC;
    }

    /* Localize. Erase parsed string. */
    q = alloca((pe-p) + 1);
    strncpy(q, p, pe-p);
    q[pe-p] = '\0';
    while (p <= pe)
        *p++ = ' ';

    for (p = q; *p != '\0'; p = pe) {
        SKIPWHITE(p);
        if (*p == '\0')
            break;
        pe = p;
        SKIPNONWHITE(pe);
        if (*pe != '\0')
            *pe++ = '\0';
        if (!strcmp(p, "missingok")) {
            fl->currentFlags |= RPMFILE_MISSINGOK;
        } else if (!strcmp(p, "noreplace")) {
            fl->currentFlags |= RPMFILE_NOREPLACE;
        } else {
            rpmError(RPMERR_BADSPEC, _("Invalid %s token: %s\n"), name, p);
            fl->processingFailed = 1;
            return RPMERR_BADSPEC;
        }
    }

    return 0;
}
/*@=boundswrite@*/

static int langCmp(const void * ap, const void * bp)
        /*@*/
{
/*@-boundsread@*/
    return strcmp(*(const char **)ap, *(const char **)bp);
/*@=boundsread@*/
}

/*@-bounds@*/
static int parseForLang(char * buf, FileList fl)
        /*@modifies buf, fl->processingFailed,
                fl->currentLangs, fl->nLangs @*/
{
    char *p, *pe, *q;
    const char *name;

  while ((p = strstr(buf, (name = "%lang"))) != NULL) {

    for (pe = p; (pe-p) < strlen(name); pe++)
        *pe = ' ';
    SKIPSPACE(pe);

    if (*pe != '(') {
        rpmError(RPMERR_BADSPEC, _("Missing '(' in %s %s\n"), name, pe);
        fl->processingFailed = 1;
        return RPMERR_BADSPEC;
    }

    /* Bracket %lang args */
    *pe++ = ' ';
    for (pe = p; *pe && *pe != ')'; pe++)
        {};

    if (*pe == '\0') {
        rpmError(RPMERR_BADSPEC, _("Missing ')' in %s(%s\n"), name, p);
        fl->processingFailed = 1;
        return RPMERR_BADSPEC;
    }

    /* Localize. Erase parsed string. */
    q = alloca((pe-p) + 1);
    strncpy(q, p, pe-p);
    q[pe-p] = '\0';
    while (p <= pe)
        *p++ = ' ';

    /* Parse multiple arguments from %lang */
    for (p = q; *p != '\0'; p = pe) {
        char *newp;
        size_t np;
        int i;

        SKIPWHITE(p);
        pe = p;
        SKIPNONWHITE(pe);

        np = pe - p;
        
        /* Sanity check on locale lengths */
        if (np < 1 || (np == 1 && *p != 'C') || np >= 32) {
            rpmError(RPMERR_BADSPEC,
                _("Unusual locale length: \"%.*s\" in %%lang(%s)\n"),
                (int)np, p, q);
            fl->processingFailed = 1;
            return RPMERR_BADSPEC;
        }

        /* Check for duplicate locales */
        if (fl->currentLangs != NULL)
        for (i = 0; i < fl->nLangs; i++) {
            if (strncmp(fl->currentLangs[i], p, np))
                /*@innercontinue@*/ continue;
            rpmError(RPMERR_BADSPEC, _("Duplicate locale %.*s in %%lang(%s)\n"),
                (int)np, p, q);
            fl->processingFailed = 1;
            return RPMERR_BADSPEC;
        }

        /* Add new locale */
        fl->currentLangs = xrealloc(fl->currentLangs,
                                (fl->nLangs + 1) * sizeof(*fl->currentLangs));
        newp = xmalloc( np+1 );
        strncpy(newp, p, np);
        newp[np] = '\0';
        fl->currentLangs[fl->nLangs++] = newp;
        if (*pe == ',') pe++;   /* skip , if present */
    }
  }

    /* Insure that locales are sorted. */
    if (fl->currentLangs)
        qsort(fl->currentLangs, fl->nLangs, sizeof(*fl->currentLangs), langCmp);

    return 0;
}
/*@=bounds@*/

/*@-boundswrite@*/
static int parseForRegexLang(const char * fileName, /*@out@*/ char ** lang)
        /*@globals rpmGlobalMacroContext, h_errno @*/
        /*@modifies *lang, rpmGlobalMacroContext @*/
{
    static int initialized = 0;
    static int hasRegex = 0;
    static regex_t compiledPatt;
    static char buf[BUFSIZ];
    int x;
    regmatch_t matches[2];
    const char *s;

    if (! initialized) {
        const char *patt = rpmExpand("%{?_langpatt}", NULL);
        int rc = 0;
        if (!(patt && *patt != '\0'))
            rc = 1;
        else if (regcomp(&compiledPatt, patt, REG_EXTENDED))
            rc = -1;
        patt = _free(patt);
        if (rc)
            return rc;
        hasRegex = 1;
        initialized = 1;
    }
    
    memset(matches, 0, sizeof(matches));
    if (! hasRegex || regexec(&compiledPatt, fileName, 2, matches, REG_NOTEOL))
        return 1;

    /* Got match */
    s = fileName + matches[1].rm_eo - 1;
    x = matches[1].rm_eo - matches[1].rm_so;
    buf[x] = '\0';
    while (x) {
        buf[--x] = *s--;
    }
    if (lang)
        *lang = buf;
    return 0;
}
/*@=boundswrite@*/

/*@-exportlocal -exportheadervar@*/
/*@unchecked@*/
VFA_t virtualFileAttributes[] = {
        { "%dir",       0,      0 },    /* XXX why not RPMFILE_DIR? */
        { "%doc",       0,      RPMFILE_DOC },
        { "%ghost",     0,      RPMFILE_GHOST },
        { "%exclude",   0,      RPMFILE_EXCLUDE },
        { "%readme",    0,      RPMFILE_README },
        { "%license",   0,      RPMFILE_LICENSE },
        { "%pubkey",    0,      RPMFILE_PUBKEY },
        { "%policy",    0,      RPMFILE_POLICY },

#if WHY_NOT
        { "%icon",      0,      RPMFILE_ICON },
        { "%spec",      0,      RPMFILE_SPEC },
        { "%config",    0,      RPMFILE_CONFIG },
        { "%missingok", 0,      RPMFILE_CONFIG|RPMFILE_MISSINGOK },
        { "%noreplace", 0,      RPMFILE_CONFIG|RPMFILE_NOREPLACE },
#endif

        { NULL, 0, 0 }
};
/*@=exportlocal =exportheadervar@*/

/*@-boundswrite@*/
static int parseForSimple(/*@unused@*/Spec spec, Package pkg, char * buf,
                          FileList fl, /*@out@*/ const char ** fileName)
        /*@globals rpmGlobalMacroContext, h_errno @*/
        /*@modifies buf, fl->processingFailed, *fileName,
                fl->currentFlags,
                fl->docDirs, fl->docDirCount, fl->isDir,
                fl->passedSpecialDoc, fl->isSpecialDoc,
                pkg->specialDoc, rpmGlobalMacroContext @*/
{
    char *s, *t;
    int res, specialDoc = 0;
    char specialDocBuf[BUFSIZ];

    specialDocBuf[0] = '\0';
    *fileName = NULL;
    res = 0;

    t = buf;
    while ((s = strtokWithQuotes(t, " \t\n")) != NULL) {
        t = NULL;
        if (!strcmp(s, "%docdir")) {
            s = strtokWithQuotes(NULL, " \t\n");
            if (fl->docDirCount == MAXDOCDIR) {
                rpmError(RPMERR_INTERNAL, _("Hit limit for %%docdir\n"));
                fl->processingFailed = 1;
                res = 1;
            }
        
            if (s != NULL)
                fl->docDirs[fl->docDirCount++] = xstrdup(s);
            if (s == NULL || strtokWithQuotes(NULL, " \t\n")) {
                rpmError(RPMERR_INTERNAL, _("Only one arg for %%docdir\n"));
                fl->processingFailed = 1;
                res = 1;
            }
            break;
        }
#if defined(__LCLINT__)
        assert(s != NULL);
#endif

    /* Set flags for virtual file attributes */
    {   VFA_t *vfa;
        for (vfa = virtualFileAttributes; vfa->attribute != NULL; vfa++) {
            if (strcmp(s, vfa->attribute))
                /*@innercontinue@*/ continue;
            if (!vfa->flag) {
                if (!strcmp(s, "%dir"))
                    fl->isDir = 1;      /* XXX why not RPMFILE_DIR? */
            } else {
                if (vfa->not)
                    fl->currentFlags &= ~vfa->flag;
                else
                    fl->currentFlags |= vfa->flag;
            }

            /*@innerbreak@*/ break;
        }
        /* if we got an attribute, continue with next token */
        if (vfa->attribute != NULL)
            continue;
    }

        if (*fileName) {
            /* We already got a file -- error */
            rpmError(RPMERR_BADSPEC, _("Two files on one line: %s\n"),
                *fileName);
            fl->processingFailed = 1;
            res = 1;
        }

        /*@-branchstate@*/
        if (*s != '/') {
            if (fl->currentFlags & RPMFILE_DOC) {
                specialDoc = 1;
                strcat(specialDocBuf, " ");
                strcat(specialDocBuf, s);
            } else
            if (fl->currentFlags & (RPMFILE_POLICY|RPMFILE_PUBKEY|RPMFILE_ICON))
            {
                *fileName = s;
            } else {
                const char * sfn = NULL;
                int urltype = urlPath(s, &sfn);
                switch (urltype) {
                default: /* relative path, not in %doc and not a URL */
                    rpmError(RPMERR_BADSPEC,
                        _("File must begin with \"/\": %s\n"), s);
                    fl->processingFailed = 1;
                    res = 1;
                    /*@switchbreak@*/ break;
                case URL_IS_PATH:
                    *fileName = s;
                    /*@switchbreak@*/ break;
                }
            }
        } else {
            *fileName = s;
        }
        /*@=branchstate@*/
    }

    if (specialDoc) {
        if (*fileName || (fl->currentFlags & ~(RPMFILE_DOC))) {
            rpmError(RPMERR_BADSPEC,
                     _("Can't mix special %%doc with other forms: %s\n"),
                     (*fileName ? *fileName : ""));
            fl->processingFailed = 1;
            res = 1;
        } else {
        /* XXX WATCHOUT: buf is an arg */
           {    static char *_docdir_fmt= 0;
                static int oneshot = 0;
                const char *ddir, *fmt, *errstr;
                if (!oneshot) {
                    _docdir_fmt = rpmExpand("%{?_docdir_fmt}", NULL);
                    if (!_docdir_fmt || !*_docdir_fmt)
                        _docdir_fmt = "%{NAME}-%{VERSION}";
                    oneshot = 1;
                }
                fmt = headerSprintf(pkg->header, _docdir_fmt, rpmTagTable, rpmHeaderFormats, &errstr);
                if (!fmt) {
                    rpmError(RPMERR_BADSPEC, _("illegal _docdir_fmt: %s\n"), errstr);
                    fl->processingFailed = 1;
                    res = 1;
                }
                ddir = rpmGetPath("%{_docdir}/", fmt, NULL);
                strcpy(buf, ddir);
                ddir = _free(ddir);
            }

        /* XXX FIXME: this is easy to do as macro expansion */

            if (! fl->passedSpecialDoc) {
                char *compress_doc;

                pkg->specialDoc = newStringBuf();
                appendStringBuf(pkg->specialDoc, "DOCDIR=\"$RPM_BUILD_ROOT\"");
                appendLineStringBuf(pkg->specialDoc, buf);
                appendLineStringBuf(pkg->specialDoc, "export DOCDIR");
                appendLineStringBuf(pkg->specialDoc, "rm -rf \"$DOCDIR\"");
                appendLineStringBuf(pkg->specialDoc, MKDIR_P " \"$DOCDIR\"");

                compress_doc = rpmExpand("%{__compress_doc}", NULL);
                if (compress_doc && *compress_doc != '%')
                    appendLineStringBuf(pkg->specialDoc, compress_doc);
                compress_doc = _free(compress_doc);

                /*@-temptrans@*/
                *fileName = buf;
                /*@=temptrans@*/
                fl->passedSpecialDoc = 1;
                fl->isSpecialDoc = 1;
            }

            appendStringBuf(pkg->specialDoc, "cp -pr ");
            appendStringBuf(pkg->specialDoc, specialDocBuf);
            appendLineStringBuf(pkg->specialDoc, " \"$DOCDIR\"");
        }
    }

    return res;
}
/*@=boundswrite@*/

static int compareFileListRecs(const void * ap, const void * bp)        /*@*/
{
    const char *aurl = ((FileListRec)ap)->fileURL;
    const char *a = NULL;
    const char *burl = ((FileListRec)bp)->fileURL;
    const char *b = NULL;
    (void) urlPath(aurl, &a);
    (void) urlPath(burl, &b);
    return strcmp(a, b);
}

static int isDoc(FileList fl, const char * fileName)    /*@*/
{
    int x = fl->docDirCount;

    while (x--) {
        if (strstr(fileName, fl->docDirs[x]) == fileName)
            return 1;
    }
    return 0;
}

static int