build.c

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