build.c

   1 /** \ingroup rpmcli
   2  * Parse spec file and build package.
   3  */
   4
   5 #include "system.h"
   6
   7 #include <libgen.h>
   8
   9 #include <rpm/rpmcli.h>
  10 #include <rpm/rpmtag.h>
  11 #include <rpm/rpmlib.h>         /* rpmrc, MACHTABLE .. */
  12 #include <rpm/rpmbuild.h>
  13
  14 #include <rpm/rpmps.h>
  15 #include <rpm/rpmte.h>
  16 #include <rpm/rpmts.h>
  17 #include <rpm/rpmfileutil.h>
  18 #include <rpm/rpmlog.h>
  19 #include <lib/misc.h>
  20
  21 #include "build.h"
  22 #include "debug.h"
  23
  24 /**
  25  */
  26 static int checkSpec(rpmts ts, Header h)
  27 {
  28     rpmps ps;
  29     int rc;
  30
  31     if (!headerIsEntry(h, RPMTAG_REQUIRENAME)
  32      && !headerIsEntry(h, RPMTAG_CONFLICTNAME))
  33         return 0;
  34
  35     rc = rpmtsAddInstallElement(ts, h, NULL, 0, NULL);
  36
  37     rc = rpmtsCheck(ts);
  38
  39     ps = rpmtsProblems(ts);
  40     if (rc == 0 && rpmpsNumProblems(ps) > 0) {
  41         rpmlog(RPMLOG_ERR, _("Failed build dependencies:\n"));
  42         rpmpsPrint(NULL, ps);
  43         rc = 1;
  44     }
  45     ps = rpmpsFree(ps);
  46
  47     /* XXX nuke the added package. */
  48     rpmtsClean(ts);
  49
  50     return rc;
  51 }
  52
  53 /**
  54  */
  55 static int isSpecFile(const char * specfile)
  56 {
  57     char buf[256];
  58     const char * s;
  59     FILE * f;
  60     int count;
  61     int checking;
  62
  63     f = fopen(specfile, "r");
  64     if (f == NULL || ferror(f)) {
  65         rpmlog(RPMLOG_ERR, _("Unable to open spec file %s: %s\n"),
  66                 specfile, strerror(errno));
  67         return 0;
  68     }
  69     count = fread(buf, sizeof(buf[0]), sizeof(buf), f);
  70     (void) fclose(f);
  71
  72     if (count == 0)
  73         return 0;
  74
  75     checking = 1;
  76     for (s = buf; count--; s++) {
  77         switch (*s) {
  78         case '\r':
  79         case '\n':
  80             checking = 1;
  81             break;
  82         case ':':
  83             checking = 0;
  84             break;
  85         default:
  86 #if 0
  87             if (checking && !(isprint(*s) || isspace(*s))) return 0;
  88             break;
  89 #else
  90             if (checking && !(isprint(*s) || isspace(*s)) && *(unsigned char *)s < 32) return 0;
  91             break;
  92 #endif
  93         }
  94     }
  95     return 1;
  96 }
  97
  98 /*
  99  * Try to find a spec from a tarball pointed to by arg.
 100  * Return absolute path to spec name on success, otherwise NULL.
 101  */
 102 static char * getTarSpec(const char *arg)
 103 {
 104     char *specFile = NULL;
 105     char *specDir;
 106     char *specBase;
 107     char *tmpSpecFile;
 108     const char **try;
 109     char tarbuf[BUFSIZ];
 110     int gotspec = 0, res;
 111     static const char *tryspec[] = { "Specfile", "\\*.spec", NULL };
 112
 113     specDir = rpmGetPath("%{_specdir}", NULL);
 114     tmpSpecFile = rpmGetPath("%{_specdir}/", "rpm-spec.XXXXXX", NULL);
 115
 116     (void) close(mkstemp(tmpSpecFile));
 117
 118     for (try = tryspec; *try != NULL; try++) {
 119         FILE *fp;
 120         char *cmd;
 121
 122         cmd = rpmExpand("%{uncompress: ", arg, "} | ",
 123                         "%{__tar} xOvf - --wildcards ", *try,
 124                         " 2>&1 > ", tmpSpecFile, NULL);
 125
 126         if (!(fp = popen(cmd, "r"))) {
 127             rpmlog(RPMLOG_ERR, _("Failed to open tar pipe: %m\n"));
 128         } else {
 129             char *fok = fgets(tarbuf, sizeof(tarbuf) - 1, fp);
 130             pclose(fp);
 131             gotspec = (fok != NULL) && isSpecFile(tmpSpecFile);
 132         }
 133
 134         if (!gotspec)
 135             unlink(tmpSpecFile);
 136         free(cmd);
 137     }
 138
 139     if (!gotspec) {
 140         rpmlog(RPMLOG_ERR, _("Failed to read spec file from %s\n"), arg);
 141         goto exit;
 142     }
 143
 144     specBase = basename(tarbuf);
 145     /* remove trailing \n */
 146     specBase[strlen(specBase)-1] = '\0';
 147
 148     rasprintf(&specFile, "%s/%s", specDir, specBase);
 149     res = rename(tmpSpecFile, specFile);
 150
 151     if (res) {
 152         rpmlog(RPMLOG_ERR, _("Failed to rename %s to %s: %m\n"),
 153                 tmpSpecFile, specFile);
 154         free(specFile);
 155         specFile = NULL;
 156     } else {
 157         /* mkstemp() can give unnecessarily strict permissions, fixup */
 158         mode_t mask;
 159         umask(mask = umask(0));
 160         (void) chmod(specFile, 0666 & ~mask);
 161     }
 162
 163 exit:
 164     (void) unlink(tmpSpecFile);
 165     free(tmpSpecFile);
 166     free(specDir);
 167     return specFile;
 168 }
 169
 170 /**
 171  */
 172 static int buildForTarget(rpmts ts, const char * arg, BTA_t ba)
 173 {
 174     const char * passPhrase = ba->passPhrase;
 175     const char * cookie = ba->cookie;
 176     int buildAmount = ba->buildAmount;
 177     char * buildRootURL = NULL;
 178     char * specFile = NULL;
 179     rpmSpec spec = NULL;
 180     int rc = 1; /* assume failure */
 181
 182 #ifndef DYING
 183     rpmSetTables(RPM_MACHTABLE_BUILDARCH, RPM_MACHTABLE_BUILDOS);
 184 #endif
 185
 186     if (ba->buildRootOverride)
 187         buildRootURL = rpmGenPath(NULL, ba->buildRootOverride, NULL);
 188
 189     /* Create build tree if necessary */
 190     const char * buildtree = "%{_topdir}:%{_specdir}:%{_sourcedir}:%{_builddir}:%{_rpmdir}:%{_srcrpmdir}:%{_buildrootdir}";
 191     const char * rootdir = rpmtsRootDir(ts);
 192     if (rpmMkdirs(!rstreq(rootdir, "/") ? rootdir : NULL , buildtree)) {
 193         goto exit;
 194     }
 195
 196     if (ba->buildMode == 't') {
 197         char *srcdir = NULL, *dir;
 198
 199         specFile = getTarSpec(arg);
 200         if (!specFile)
 201             goto exit;
 202
 203         /* Make the directory of the tarball %_sourcedir for this run */
 204         /* dirname() may modify contents so extra hoops needed. */
 205         if (*arg != '/') {
 206             dir = rpmGetCwd();
 207             rstrscat(&dir, "/", arg, NULL);
 208         } else {
 209             dir = xstrdup(arg);
 210         }
 211         srcdir = dirname(dir);
 212         addMacro(NULL, "_sourcedir", NULL, srcdir, RMIL_TARBALL);
 213         free(dir);
 214     } else {
 215         specFile = xstrdup(arg);
 216     }
 217
 218     if (*specFile != '/') {
 219         char *cwd = rpmGetCwd();
 220         char *s = NULL;
 221         rasprintf(&s, "%s/%s", cwd, arg);
 222         free(cwd);
 223         free(specFile);
 224         specFile = s;
 225     }
 226
 227     struct stat st;
 228     if (stat(specFile, &st) < 0) {
 229         rpmlog(RPMLOG_ERR, _("failed to stat %s: %m\n"), specFile);
 230         goto exit;
 231     }
 232     if (! S_ISREG(st.st_mode)) {
 233         rpmlog(RPMLOG_ERR, _("File %s is not a regular file.\n"), specFile);
 234         goto exit;
 235     }
 236
 237     /* Try to verify that the file is actually a specfile */
 238     if (!isSpecFile(specFile)) {
 239         rpmlog(RPMLOG_ERR,
 240                 _("File %s does not appear to be a specfile.\n"), specFile);
 241         goto exit;
 242     }
 243
 244     /* Don't parse spec if only its removal is requested */
 245     if (ba->buildAmount == RPMBUILD_RMSPEC) {
 246         rc = unlink(specFile);
 247         goto exit;
 248     }
 249
 250     /* Parse the spec file */
 251 #define _anyarch(_f)    \
 252 (((_f)&(RPMBUILD_PREP|RPMBUILD_BUILD|RPMBUILD_INSTALL|RPMBUILD_PACKAGEBINARY)) == 0)
 253     if (parseSpec(ts, specFile, ba->rootdir, buildRootURL, 0, passPhrase,
 254                 cookie, _anyarch(buildAmount), ba->force))
 255     {
 256         goto exit;
 257     }
 258 #undef  _anyarch
 259     if ((spec = rpmtsSetSpec(ts, NULL)) == NULL) {
 260         goto exit;
 261     }
 262
 263     if ( ba->buildAmount&RPMBUILD_RMSOURCE && !(ba->buildAmount&~(RPMBUILD_RMSOURCE|RPMBUILD_RMSPEC)) ) {
 264         rc = doRmSource(spec);
 265         if ( rc == RPMRC_OK && ba->buildAmount&RPMBUILD_RMSPEC )
 266             rc = unlink(specFile);
 267         goto exit;
 268     }
 269
 270     /* Assemble source header from parsed components */
 271     initSourceHeader(spec);
 272
 273     /* Check build prerequisites */
 274     if (!ba->noDeps && checkSpec(ts, spec->sourceHeader)) {
 275         goto exit;
 276     }
 277
 278     if (buildSpec(ts, spec, buildAmount, ba->noBuild)) {
 279         goto exit;
 280     }
 281
 282     if (ba->buildMode == 't')
 283         (void) unlink(specFile);
 284     rc = 0;
 285
 286 exit:
 287     free(specFile);
 288     freeSpec(spec);
 289     free(buildRootURL);
 290     return rc;
 291 }
 292
 293 int build(rpmts ts, const char * arg, BTA_t ba, const char * rcfile)
 294 {
 295     char *t, *te;
 296     int rc = 0;
 297     char * targets = ba->targets;
 298 #define buildCleanMask  (RPMBUILD_RMSOURCE|RPMBUILD_RMSPEC)
 299     int cleanFlags = ba->buildAmount & buildCleanMask;
 300     rpmVSFlags vsflags, ovsflags;
 301
 302     vsflags = rpmExpandNumeric("%{_vsflags_build}");
 303     if (ba->qva_flags & VERIFY_DIGEST)
 304         vsflags |= _RPMVSF_NODIGESTS;
 305     if (ba->qva_flags & VERIFY_SIGNATURE)
 306         vsflags |= _RPMVSF_NOSIGNATURES;
 307     if (ba->qva_flags & VERIFY_HDRCHK)
 308         vsflags |= RPMVSF_NOHDRCHK;
 309     ovsflags = rpmtsSetVSFlags(ts, vsflags);
 310
 311     if (targets == NULL) {
 312         rc =  buildForTarget(ts, arg, ba);
 313         goto exit;
 314     }
 315
 316     /* parse up the build operators */
 317
 318     printf(_("Building target platforms: %s\n"), targets);
 319
 320     ba->buildAmount &= ~buildCleanMask;
 321     for (t = targets; *t != '\0'; t = te) {
 322         char *target;
 323         if ((te = strchr(t, ',')) == NULL)
 324             te = t + strlen(t);
 325         target = xmalloc(te-t+1);
 326         strncpy(target, t, (te-t));
 327         target[te-t] = '\0';
 328         if (*te != '\0')
 329             te++;
 330         else    /* XXX Perform clean-up after last target build. */
 331             ba->buildAmount |= cleanFlags;
 332
 333         printf(_("Building for target %s\n"), target);
 334
 335         /* Read in configuration for target. */
 336         rpmFreeMacros(NULL);
 337         rpmFreeRpmrc();
 338         (void) rpmReadConfigFiles(rcfile, target);
 339         free(target);
 340         rc = buildForTarget(ts, arg, ba);
 341         if (rc)
 342             break;
 343     }
 344
 345 exit:
 346     vsflags = rpmtsSetVSFlags(ts, ovsflags);
 347     /* Restore original configuration. */
 348     rpmFreeMacros(NULL);
 349     rpmFreeRpmrc();
 350     (void) rpmReadConfigFiles(rcfile, NULL);
 351
 352     return rc;
 353 }