build/parseReqs.c

   1 /** \ingroup rpmbuild
   2  * \file build/parseReqs.c
   3  *  Parse dependency tag from spec file or from auto-dependency generator.
   4  */
   5
   6 #include "system.h"
   7
   8 #include <rpm/rpmtypes.h>
   9 #include <rpm/rpmbuild.h>
  10 #include <rpm/rpmlog.h>
  11 #include "debug.h"
  12
  13 /**
  14  */
  15 static struct ReqComp {
  16 const char * token;
  17     rpmsenseFlags sense;
  18 } const ReqComparisons[] = {
  19     { "<=", RPMSENSE_LESS | RPMSENSE_EQUAL},
  20     { "=<", RPMSENSE_LESS | RPMSENSE_EQUAL},
  21     { "<", RPMSENSE_LESS},
  22
  23     { "==", RPMSENSE_EQUAL},
  24     { "=", RPMSENSE_EQUAL},
  25
  26     { ">=", RPMSENSE_GREATER | RPMSENSE_EQUAL},
  27     { "=>", RPMSENSE_GREATER | RPMSENSE_EQUAL},
  28     { ">", RPMSENSE_GREATER},
  29
  30     { NULL, 0 },
  31 };
  32
  33 #define SKIPWHITE(_x)   {while(*(_x) && (risspace(*_x) || *(_x) == ',')) (_x)++;}
  34 #define SKIPNONWHITE(_x){while(*(_x) &&!(risspace(*_x) || *(_x) == ',')) (_x)++;}
  35
  36 rpmRC parseRCPOT(rpmSpec spec, Package pkg, const char *field, rpmTag tagN,
  37                int index, rpmsenseFlags tagflags)
  38 {
  39     const char *r, *re, *v, *ve;
  40     char * N, * EVR;
  41     rpmsenseFlags Flags;
  42     Header h;
  43
  44     switch (tagN) {
  45     case RPMTAG_PROVIDEFLAGS:
  46         tagflags |= RPMSENSE_PROVIDES;
  47         h = pkg->header;
  48         break;
  49     case RPMTAG_OBSOLETEFLAGS:
  50         tagflags |= RPMSENSE_OBSOLETES;
  51         h = pkg->header;
  52         break;
  53     case RPMTAG_CONFLICTFLAGS:
  54         tagflags |= RPMSENSE_CONFLICTS;
  55         h = pkg->header;
  56         break;
  57     case RPMTAG_BUILDCONFLICTS:
  58         tagflags |= RPMSENSE_CONFLICTS;
  59         h = spec->buildRestrictions;
  60         break;
  61     case RPMTAG_PREREQ:
  62         /* XXX map legacy PreReq into Requires(pre,preun) */
  63         tagflags |= (RPMSENSE_SCRIPT_PRE|RPMSENSE_SCRIPT_PREUN);
  64         h = pkg->header;
  65         break;
  66     case RPMTAG_TRIGGERPREIN:
  67         tagflags |= RPMSENSE_TRIGGERPREIN;
  68         h = pkg->header;
  69         break;
  70     case RPMTAG_TRIGGERIN:
  71         tagflags |= RPMSENSE_TRIGGERIN;
  72         h = pkg->header;
  73         break;
  74     case RPMTAG_TRIGGERPOSTUN:
  75         tagflags |= RPMSENSE_TRIGGERPOSTUN;
  76         h = pkg->header;
  77         break;
  78     case RPMTAG_TRIGGERUN:
  79         tagflags |= RPMSENSE_TRIGGERUN;
  80         h = pkg->header;
  81         break;
  82     case RPMTAG_BUILDPREREQ:
  83     case RPMTAG_BUILDREQUIRES:
  84         tagflags |= RPMSENSE_ANY;
  85         h = spec->buildRestrictions;
  86         break;
  87     default:
  88     case RPMTAG_REQUIREFLAGS:
  89         tagflags |= RPMSENSE_ANY;
  90         h = pkg->header;
  91         break;
  92     }
  93
  94     for (r = field; *r != '\0'; r = re) {
  95         SKIPWHITE(r);
  96         if (*r == '\0')
  97             break;
  98
  99         Flags = (tagflags & ~RPMSENSE_SENSEMASK);
 100
 101         /*
 102          * Tokens must begin with alphanumeric, _, or /, but we don't know
 103          * the spec's encoding so we only check what we can: plain ascii.
 104          */
 105         if (isascii(r[0]) && !(risalnum(r[0]) || r[0] == '_' || r[0] == '/')) {
 106             rpmlog(RPMLOG_ERR,
 107                      _("line %d: Dependency tokens must begin with alpha-numeric, '_' or '/': %s\n"),
 108                      spec->lineNum, spec->line);
 109             return RPMRC_FAIL;
 110         }
 111
 112         re = r;
 113         SKIPNONWHITE(re);
 114         N = xmalloc((re-r) + 1);
 115         rstrlcpy(N, r, (re-r) + 1);
 116
 117         /* Parse EVR */
 118         v = re;
 119         SKIPWHITE(v);
 120         ve = v;
 121         SKIPNONWHITE(ve);
 122
 123         re = v; /* ==> next token (if no EVR found) starts here */
 124
 125         /* Check for possible logical operator */
 126         if (ve > v) {
 127           const struct ReqComp *rc;
 128           for (rc = ReqComparisons; rc->token != NULL; rc++) {
 129             if ((ve-v) != strlen(rc->token) || !rstreqn(v, rc->token, (ve-v)))
 130                 continue;
 131
 132             if (r[0] == '/') {
 133                 rpmlog(RPMLOG_ERR,
 134                          _("line %d: Versioned file name not permitted: %s\n"),
 135                          spec->lineNum, spec->line);
 136                 return RPMRC_FAIL;
 137             }
 138
 139             switch(tagN) {
 140             case RPMTAG_BUILDPREREQ:
 141             case RPMTAG_PREREQ:
 142             case RPMTAG_PROVIDEFLAGS:
 143             case RPMTAG_OBSOLETEFLAGS:
 144                 /* Add prereq on rpmlib that has versioned dependencies. */
 145                 if (!rpmExpandNumeric("%{?_noVersionedDependencies}"))
 146                     (void) rpmlibNeedsFeature(h, "VersionedDependencies", "3.0.3-1");
 147                 break;
 148             default:
 149                 break;
 150             }
 151             Flags |= rc->sense;
 152
 153             /* now parse EVR */
 154             v = ve;
 155             SKIPWHITE(v);
 156             ve = v;
 157             SKIPNONWHITE(ve);
 158             break;
 159           }
 160         }
 161
 162         if (Flags & RPMSENSE_SENSEMASK) {
 163             if (*v == '\0' || ve == v) {
 164                 rpmlog(RPMLOG_ERR, _("line %d: Version required: %s\n"),
 165                         spec->lineNum, spec->line);
 166                 return RPMRC_FAIL;
 167             }
 168             EVR = xmalloc((ve-v) + 1);
 169             rstrlcpy(EVR, v, (ve-v) + 1);
 170             if (rpmCharCheck(spec, EVR, ve-v, ".-_+:")) return RPMRC_FAIL;
 171             re = ve;    /* ==> next token after EVR string starts here */
 172         } else
 173             EVR = NULL;
 174
 175         (void) addReqProv(spec, h, tagN, N, EVR, Flags, index);
 176
 177         N = _free(N);
 178         EVR = _free(EVR);
 179
 180     }
 181
 182     return RPMRC_OK;
 183 }