build/pack.c Source File

00001 
00006 #include "system.h"
00007 
00008 #include <rpmio_internal.h>
00009 #include <rpmbuild.h>
00010 #include "buildio.h"
00011 
00012 #include "misc.h"
00013 #include "signature.h"
00014 #include "rpmlead.h"
00015 #include "debug.h"
00016 
00017 extern int _noDirTokens;
00018 
00019 /*@access StringBuf @*/ /* compared with NULL */
00020 /*@access TFI_t @*/     /* compared with NULL */
00021 /*@access Header @*/    /* compared with NULL */
00022 /*@access FD_t @*/      /* compared with NULL */
00023 
00026 static inline int genSourceRpmName(Spec spec)
00027 {
00028     if (spec->sourceRpmName == NULL) {
00029         const char *name, *version, *release;
00030         char fileName[BUFSIZ];
00031 
00032         headerNVR(spec->packages->header, &name, &version, &release);
00033         sprintf(fileName, "%s-%s-%s.%ssrc.rpm", name, version, release,
00034             spec->noSource ? "no" : "");
00035         spec->sourceRpmName = xstrdup(fileName);
00036     }
00037 
00038     return 0;
00039 }
00040 
00044 static int cpio_doio(FD_t fdo, Header h, CSA_t * csa, const char * fmodeMacro)
00045 {
00046     const char * rootDir = "/";
00047     rpmdb rpmdb = NULL;
00048     rpmTransactionSet ts = rpmtransCreateSet(rpmdb, rootDir);
00049     TFI_t fi = csa->cpioList;
00050     const char *fmode = rpmExpand(fmodeMacro, NULL);
00051     const char *failedFile = NULL;
00052     FD_t cfd;
00053     int rc;
00054 
00055     if (!(fmode && fmode[0] == 'w'))
00056         fmode = xstrdup("w9.gzdio");
00057     (void) Fflush(fdo);
00058     cfd = Fdopen(fdDup(Fileno(fdo)), fmode);
00059 
00060     rc = fsmSetup(fi->fsm, FSM_PKGBUILD, ts, fi, cfd,
00061                 &csa->cpioArchiveSize, &failedFile);
00062     Fclose(cfd);
00063     (void) fsmTeardown(fi->fsm);
00064 
00065     if (rc) {
00066         rpmError(RPMERR_CPIO, _("create archive failed on file %s: %s\n"),
00067                 failedFile, cpioStrerror(rc));
00068       rc = 1;
00069     }
00070 
00071     if (failedFile)
00072         free((void *)failedFile);
00073     free((void *)fmode);
00074     rpmtransFree(ts);
00075 
00076     return rc;
00077 }
00078 
00081 static int cpio_copy(FD_t fdo, CSA_t *csa)
00082 {
00083     char buf[BUFSIZ];
00084     size_t nb;
00085 
00086     while((nb = Fread(buf, sizeof(buf[0]), sizeof(buf), csa->cpioFdIn)) > 0) {
00087         if (Fwrite(buf, sizeof(buf[0]), nb, fdo) != nb) {
00088             rpmError(RPMERR_CPIO, _("cpio_copy write failed: %s\n"),
00089                         Fstrerror(fdo));
00090             return 1;
00091         }
00092         csa->cpioArchiveSize += nb;
00093     }
00094     if (Ferror(csa->cpioFdIn)) {
00095         rpmError(RPMERR_CPIO, _("cpio_copy read failed: %s\n"),
00096                 Fstrerror(csa->cpioFdIn));
00097         return 1;
00098     }
00099     return 0;
00100 }
00101 
00104 static StringBuf addFileToTagAux(Spec spec, const char *file, StringBuf sb)
00105 {
00106     char buf[BUFSIZ];
00107     const char *fn = buf;
00108     FD_t fd;
00109 
00110     /* XXX use rpmGenPath(rootdir, "%{_buildir}/%{_buildsubdir}/", file) */
00111     fn = rpmGetPath("%{_builddir}/", spec->buildSubdir, "/", file, NULL);
00112 
00113     fd = Fopen(fn, "r.ufdio");
00114     if (fn != buf) free((void *)fn);
00115     if (fd == NULL || Ferror(fd)) {
00116         freeStringBuf(sb);
00117         return NULL;
00118     }
00119     while (fgets(buf, sizeof(buf), (FILE *)fdGetFp(fd))) {
00120         /* XXX display fn in error msg */
00121         if (expandMacros(spec, spec->macros, buf, sizeof(buf))) {
00122             rpmError(RPMERR_BADSPEC, _("line: %s\n"), buf);
00123             return NULL;
00124         }
00125         appendStringBuf(sb, buf);
00126     }
00127     Fclose(fd);
00128 
00129     return sb;
00130 }
00131 
00134 static int addFileToTag(Spec spec, const char *file, Header h, int tag)
00135 {
00136     StringBuf sb = newStringBuf();
00137     char *s;
00138 
00139     if (headerGetEntry(h, tag, NULL, (void **)&s, NULL)) {
00140         appendLineStringBuf(sb, s);
00141         headerRemoveEntry(h, tag);
00142     }
00143 
00144     if ((sb = addFileToTagAux(spec, file, sb)) == NULL)
00145         return 1;
00146     
00147     headerAddEntry(h, tag, RPM_STRING_TYPE, getStringBuf(sb), 1);
00148 
00149     freeStringBuf(sb);
00150     return 0;
00151 }
00152 
00155 static int addFileToArrayTag(Spec spec, char *file, Header h, int tag)
00156 {
00157     StringBuf sb = newStringBuf();
00158     char *s;
00159 
00160     if ((sb = addFileToTagAux(spec, file, sb)) == NULL)
00161         return 1;
00162 
00163     s = getStringBuf(sb);
00164     headerAddOrAppendEntry(h, tag, RPM_STRING_ARRAY_TYPE, &s, 1);
00165 
00166     freeStringBuf(sb);
00167     return 0;
00168 }
00169 
00172 static int processScriptFiles(Spec spec, Package pkg)
00173 {
00174     struct TriggerFileEntry *p;
00175     
00176     if (pkg->preInFile) {
00177         if (addFileToTag(spec, pkg->preInFile, pkg->header, RPMTAG_PREIN)) {
00178             rpmError(RPMERR_BADFILENAME,
00179                      _("Could not open PreIn file: %s\n"), pkg->preInFile);
00180             return RPMERR_BADFILENAME;
00181         }
00182     }
00183     if (pkg->preUnFile) {
00184         if (addFileToTag(spec, pkg->preUnFile, pkg->header, RPMTAG_PREUN)) {
00185             rpmError(RPMERR_BADFILENAME,
00186                      _("Could not open PreUn file: %s\n"), pkg->preUnFile);
00187             return RPMERR_BADFILENAME;
00188         }
00189     }
00190     if (pkg->postInFile) {
00191         if (addFileToTag(spec, pkg->postInFile, pkg->header, RPMTAG_POSTIN)) {
00192             rpmError(RPMERR_BADFILENAME,
00193                      _("Could not open PostIn file: %s\n"), pkg->postInFile);
00194             return RPMERR_BADFILENAME;
00195         }
00196     }
00197     if (pkg->postUnFile) {
00198         if (addFileToTag(spec, pkg->postUnFile, pkg->header, RPMTAG_POSTUN)) {
00199             rpmError(RPMERR_BADFILENAME,
00200                      _("Could not open PostUn file: %s\n"), pkg->postUnFile);
00201             return RPMERR_BADFILENAME;
00202         }
00203     }
00204     if (pkg->verifyFile) {
00205         if (addFileToTag(spec, pkg->verifyFile, pkg->header,
00206                          RPMTAG_VERIFYSCRIPT)) {
00207             rpmError(RPMERR_BADFILENAME,
00208                      _("Could not open VerifyScript file: %s\n"), pkg->verifyFile);
00209             return RPMERR_BADFILENAME;
00210         }
00211     }
00212 
00213     for (p = pkg->triggerFiles; p != NULL; p = p->next) {
00214         headerAddOrAppendEntry(pkg->header, RPMTAG_TRIGGERSCRIPTPROG,
00215                                RPM_STRING_ARRAY_TYPE, &(p->prog), 1);
00216         if (p->script) {
00217             headerAddOrAppendEntry(pkg->header, RPMTAG_TRIGGERSCRIPTS,
00218                                    RPM_STRING_ARRAY_TYPE, &(p->script), 1);
00219         } else if (p->fileName) {
00220             if (addFileToArrayTag(spec, p->fileName, pkg->header,
00221                                   RPMTAG_TRIGGERSCRIPTS)) {
00222                 rpmError(RPMERR_BADFILENAME,
00223                          _("Could not open Trigger script file: %s\n"),
00224                          p->fileName);
00225                 return RPMERR_BADFILENAME;
00226             }
00227         } else {
00228             /* This is dumb.  When the header supports NULL string */
00229             /* this will go away.                                  */
00230             char *bull = "";
00231             headerAddOrAppendEntry(pkg->header, RPMTAG_TRIGGERSCRIPTS,
00232                                    RPM_STRING_ARRAY_TYPE, &bull, 1);
00233         }
00234     }
00235 
00236     return 0;
00237 }
00238 
00239 int readRPM(const char *fileName, Spec *specp, struct rpmlead *lead, Header *sigs,
00240             CSA_t *csa)
00241 {
00242     FD_t fdi;
00243     Spec spec;
00244     rpmRC rc;
00245 
00246     if (fileName != NULL) {
00247         fdi = Fopen(fileName, "r.ufdio");
00248         if (fdi == NULL || Ferror(fdi)) {
00249             rpmError(RPMERR_BADMAGIC, _("readRPM: open %s: %s\n"), fileName,
00250                 Fstrerror(fdi));
00251             return RPMERR_BADMAGIC;
00252         }
00253     } else {
00254         fdi = fdDup(STDIN_FILENO);
00255     }
00256 
00257     /* Get copy of lead */
00258     if ((rc = Fread(lead, sizeof(char), sizeof(*lead), fdi)) != sizeof(*lead)) {
00259         rpmError(RPMERR_BADMAGIC, _("readRPM: read %s: %s\n"), fileName,
00260             Fstrerror(fdi));
00261         return RPMERR_BADMAGIC;
00262     }
00263 
00264     (void)Fseek(fdi, 0, SEEK_SET);      /* XXX FIXME: EPIPE */
00265 
00266     /* Reallocate build data structures */
00267     spec = newSpec();
00268     spec->packages = newPackage(spec);
00269 
00270     /* XXX the header just allocated will be allocated again */
00271     if (spec->packages->header != NULL) {
00272         headerFree(spec->packages->header);
00273         spec->packages->header = NULL;
00274     }
00275 
00276    /* Read the rpm lead and header */
00277     rc = rpmReadPackageInfo(fdi, sigs, &spec->packages->header);
00278     switch (rc) {
00279     case RPMRC_BADMAGIC:
00280         rpmError(RPMERR_BADMAGIC, _("readRPM: %s is not an RPM package\n"),
00281                 fileName);
00282         return RPMERR_BADMAGIC;
00283     case RPMRC_OK:
00284         break;
00285     case RPMRC_FAIL:
00286     case RPMRC_BADSIZE:
00287     case RPMRC_SHORTREAD:
00288     default:
00289         rpmError(RPMERR_BADMAGIC, _("readRPM: reading header from %s\n"),
00290                 fileName);
00291         return RPMERR_BADMAGIC;
00292         /*@notreached@*/ break;
00293     }
00294 
00295     if (specp)
00296         *specp = spec;
00297     else
00298         freeSpec(spec);
00299 
00300     if (csa)
00301         csa->cpioFdIn = fdi;
00302     else
00303         Fclose(fdi);
00304 
00305     return 0;
00306 }
00307 
00308 int writeRPM(Header *hdrp, const char *fileName, int type,
00309                     CSA_t *csa, char *passPhrase, const char **cookie)
00310 {
00311     FD_t fd = NULL;
00312     FD_t ifd = NULL;
00313     int rc, count, sigtype;
00314     const char *sigtarget;
00315     const char * rpmio_flags = NULL;
00316     char *s;
00317     char buf[BUFSIZ];
00318     Header h = *hdrp;
00319     Header sig = NULL;
00320 
00321     if (Fileno(csa->cpioFdIn) < 0) {
00322         csa->cpioArchiveSize = 0;
00323         /* Add a bogus archive size to the Header */
00324         headerAddEntry(h, RPMTAG_ARCHIVESIZE, RPM_INT32_TYPE,
00325                 &csa->cpioArchiveSize, 1);
00326     }
00327 
00328 #ifdef  DYING
00329     /* Choose how filenames are represented. */
00330     if (_noDirTokens)
00331         expandFilelist(h);
00332     else {
00333         compressFilelist(h);
00334         /* Binary packages with dirNames cannot be installed by legacy rpm. */
00335         if (type == RPMLEAD_BINARY)
00336             rpmlibNeedsFeature(h, "CompressedFileNames", "3.0.4-1");
00337     }
00338 #endif
00339 
00340     /* Binary packages now have explicit Provides: name = version-release. */
00341     if (type == RPMLEAD_BINARY)
00342         providePackageNVR(h);
00343 
00344     /* Save payload information */
00345     switch(type) {
00346     case RPMLEAD_SOURCE:
00347         rpmio_flags = rpmExpand("%{?_source_payload:%{_source_payload}}", NULL);
00348         break;
00349     case RPMLEAD_BINARY:
00350         rpmio_flags = rpmExpand("%{?_binary_payload:%{_binary_payload}}", NULL);
00351         break;
00352     }
00353     if (!(rpmio_flags && *rpmio_flags)) {
00354         if (rpmio_flags) free((void *)rpmio_flags);
00355         rpmio_flags = xstrdup("w9.gzdio");
00356     }
00357     s = strchr(rpmio_flags, '.');
00358     if (s) {
00359         headerAddEntry(h, RPMTAG_PAYLOADFORMAT, RPM_STRING_TYPE, "cpio", 1);
00360         if (s[1] == 'g' && s[2] == 'z')
00361             headerAddEntry(h, RPMTAG_PAYLOADCOMPRESSOR, RPM_STRING_TYPE,
00362                 "gzip", 1);
00363         if (s[1] == 'b' && s[2] == 'z') {
00364             headerAddEntry(h, RPMTAG_PAYLOADCOMPRESSOR, RPM_STRING_TYPE,
00365                 "bzip2", 1);
00366             /* Add prereq on rpm version that understands bzip2 payloads */
00367             rpmlibNeedsFeature(h, "PayloadIsBzip2", "3.0.5-1");
00368         }
00369         strcpy(buf, rpmio_flags);
00370         buf[s - rpmio_flags] = '\0';
00371         headerAddEntry(h, RPMTAG_PAYLOADFLAGS, RPM_STRING_TYPE, buf+1, 1);
00372     }
00373 
00374     /* Create and add the cookie */
00375     if (cookie) {
00376         sprintf(buf, "%s %d", buildHost(), (int) time(NULL));
00377         *cookie = xstrdup(buf);
00378         headerAddEntry(h, RPMTAG_COOKIE, RPM_STRING_TYPE, *cookie, 1);
00379     }
00380     
00381     /* Reallocate the header into one contiguous region. */
00382     *hdrp = h = headerReload(h, RPMTAG_HEADERIMMUTABLE);
00383 
00384     /*
00385      * Write the header+archive into a temp file so that the size of
00386      * archive (after compression) can be added to the header.
00387      */
00388     if (makeTempFile(NULL, &sigtarget, &fd)) {
00389         rpmError(RPMERR_CREATE, _("Unable to open temp file.\n"));
00390         return RPMERR_CREATE;
00391     }
00392 
00393     if (headerWrite(fd, h, HEADER_MAGIC_YES)) {
00394         rc = RPMERR_NOSPACE;
00395     } else { /* Write the archive and get the size */
00396         if (csa->cpioList != NULL) {
00397             rc = cpio_doio(fd, h, csa, rpmio_flags);
00398         } else if (Fileno(csa->cpioFdIn) >= 0) {
00399             rc = cpio_copy(fd, csa);
00400         } else {
00401             rpmError(RPMERR_CREATE, _("Bad CSA data\n"));
00402             rc = RPMERR_BADARG;
00403         }
00404     }
00405     if (rpmio_flags) free((void *)rpmio_flags);
00406 
00407     if (rc)
00408         goto exit;
00409 
00410     /*
00411      * Set the actual archive size, and rewrite the header.
00412      * This used to be done using headerModifyEntry(), but now that headers
00413      * have regions, the value is scribbled directly into the header data
00414      * area. Some new scheme for adding the final archive size will have
00415      * to be devised if headerGetEntry() ever changes to return a pointer
00416      * to memory not in the region. <shrug>
00417      */
00418     if (Fileno(csa->cpioFdIn) < 0) {
00419         int_32 * archiveSize;
00420         if (headerGetEntry(h, RPMTAG_ARCHIVESIZE, NULL, (void *)&archiveSize, NULL))
00421             *archiveSize = csa->cpioArchiveSize;
00422     }
00423 
00424     (void)Fseek(fd, 0, SEEK_SET);
00425 
00426     if (headerWrite(fd, h, HEADER_MAGIC_YES))
00427         rc = RPMERR_NOSPACE;
00428 
00429     Fclose(fd);
00430     fd = NULL;
00431     Unlink(fileName);
00432 
00433     if (rc)
00434         goto exit;
00435 
00436     /* Generate the signature */
00437     fflush(stdout);
00438     sig = rpmNewSignature();
00439     rpmAddSignature(sig, sigtarget, RPMSIGTAG_SIZE, passPhrase);
00440     rpmAddSignature(sig, sigtarget, RPMSIGTAG_MD5, passPhrase);
00441     if ((sigtype = rpmLookupSignatureType(RPMLOOKUPSIG_QUERY)) > 0) {
00442         rpmMessage(RPMMESS_NORMAL, _("Generating signature: %d\n"), sigtype);
00443         rpmAddSignature(sig, sigtarget, sigtype, passPhrase);
00444     }
00445 
00446     /* Reallocate the signature into one contiguous region. */
00447     sig = headerReload(sig, RPMTAG_HEADERSIGNATURES);
00448 
00449     /* Open the output file */
00450     fd = Fopen(fileName, "w.ufdio");
00451     if (fd == NULL || Ferror(fd)) {
00452         rpmError(RPMERR_CREATE, _("Could not open %s: %s\n"),
00453                 fileName, Fstrerror(fd));
00454         rc = RPMERR_CREATE;
00455         goto exit;
00456     }
00457 
00458     /* Write the lead section into the package. */
00459     {   int archnum = -1;
00460         int osnum = -1;
00461         struct rpmlead lead;
00462 
00463         if (Fileno(csa->cpioFdIn) < 0) {
00464 #ifndef DYING
00465             rpmGetArchInfo(NULL, &archnum);
00466             rpmGetOsInfo(NULL, &osnum);
00467 #endif
00468         } else if (csa->lead != NULL) {
00469             archnum = csa->lead->archnum;
00470             osnum = csa->lead->osnum;
00471         }
00472 
00473         memset(&lead, 0, sizeof(lead));
00474         /* XXX Set package version conditioned on noDirTokens. */
00475         lead.major = (_noDirTokens ? 3 : 4);
00476         lead.minor = 0;
00477         lead.type = type;
00478         lead.archnum = archnum;
00479         lead.osnum = osnum;
00480         lead.signature_type = RPMSIGTYPE_HEADERSIG;
00481 
00482         {   const char *name, *version, *release;
00483             headerNVR(h, &name, &version, &release);
00484             sprintf(buf, "%s-%s-%s", name, version, release);
00485             strncpy(lead.name, buf, sizeof(lead.name));
00486         }
00487 
00488         if (writeLead(fd, &lead)) {
00489             rpmError(RPMERR_NOSPACE, _("Unable to write package: %s\n"),
00490                  Fstrerror(fd));
00491             rc = RPMERR_NOSPACE;
00492             goto exit;
00493         }
00494     }
00495 
00496     /* Write the signature section into the package. */
00497     rc = rpmWriteSignature(fd, sig);
00498     if (rc)
00499         goto exit;
00500 
00501     /* Append the header and archive */
00502     ifd = Fopen(sigtarget, "r.ufdio");
00503     if (ifd == NULL || Ferror(ifd)) {
00504         rpmError(RPMERR_READ, _("Unable to open sigtarget %s: %s\n"),
00505                 sigtarget, Fstrerror(ifd));
00506         rc = RPMERR_READ;
00507         goto exit;
00508     }
00509 
00510     /* Add signatures to header, and write header into the package. */
00511     {   Header nh = headerRead(ifd, HEADER_MAGIC_YES);
00512 
00513         if (nh == NULL) {
00514             rpmError(RPMERR_READ, _("Unable to read header from %s: %s\n"),
00515                         sigtarget, Fstrerror(ifd));
00516             rc = RPMERR_READ;
00517             goto exit;
00518         }
00519 
00520 #ifdef  NOTYET
00521         headerMergeLegacySigs(nh, sig);
00522 #endif
00523 
00524         rc = headerWrite(fd, nh, HEADER_MAGIC_YES);
00525         headerFree(nh);
00526 
00527         if (rc) {
00528             rpmError(RPMERR_NOSPACE, _("Unable to write header to %s: %s\n"),
00529                         fileName, Fstrerror(fd));
00530             rc = RPMERR_NOSPACE;
00531             goto exit;
00532         }
00533     }
00534         
00535     /* Write the payload into the package. */
00536     while ((count = Fread(buf, sizeof(buf[0]), sizeof(buf), ifd)) > 0) {
00537         if (count == -1) {
00538             rpmError(RPMERR_READ, _("Unable to read payload from %s: %s\n"),
00539                      sigtarget, Fstrerror(ifd));
00540             rc = RPMERR_READ;
00541             goto exit;
00542         }
00543         if (Fwrite(buf, sizeof(buf[0]), count, fd) != count) {
00544             rpmError(RPMERR_NOSPACE, _("Unable to write payload to %s: %s\n"),
00545                      fileName, Fstrerror(fd));
00546             rc = RPMERR_NOSPACE;
00547             goto exit;
00548         }
00549     }
00550     rc = 0;
00551 
00552 exit:
00553     if (sig) {
00554         rpmFreeSignature(sig);
00555         sig = NULL;
00556     }
00557     if (ifd) {
00558         Fclose(ifd);
00559         ifd = NULL;
00560     }
00561     if (fd) {
00562         Fclose(fd);
00563         fd = NULL;
00564     }
00565     if (sigtarget) {
00566         Unlink(sigtarget);
00567         free((void *)sigtarget);
00568     }
00569 
00570     if (rc == 0)
00571         rpmMessage(RPMMESS_NORMAL, _("Wrote: %s\n"), fileName);
00572     else
00573         Unlink(fileName);
00574 
00575     return rc;
00576 }
00577 
00578 static int_32 copyTags[] = {
00579     RPMTAG_CHANGELOGTIME,
00580     RPMTAG_CHANGELOGNAME,
00581     RPMTAG_CHANGELOGTEXT,
00582     0
00583 };
00584 
00585 int packageBinaries(Spec spec)
00586 {
00587     CSA_t csabuf, *csa = &csabuf;
00588     int rc;
00589     const char *errorString;
00590     Package pkg;
00591 
00592     for (pkg = spec->packages; pkg != NULL; pkg = pkg->next) {
00593         const char *fn;
00594 
00595         if (pkg->fileList == NULL)
00596             continue;
00597 
00598         if ((rc = processScriptFiles(spec, pkg)))
00599             return rc;
00600         
00601         if (spec->cookie) {
00602             headerAddEntry(pkg->header, RPMTAG_COOKIE,
00603                            RPM_STRING_TYPE, spec->cookie, 1);
00604         }
00605 
00606         /* Copy changelog from src rpm */
00607         headerCopyTags(spec->packages->header, pkg->header, copyTags);
00608         
00609         headerAddEntry(pkg->header, RPMTAG_RPMVERSION,
00610                        RPM_STRING_TYPE, VERSION, 1);
00611         headerAddEntry(pkg->header, RPMTAG_BUILDHOST,
00612                        RPM_STRING_TYPE, buildHost(), 1);
00613         headerAddEntry(pkg->header, RPMTAG_BUILDTIME,
00614                        RPM_INT32_TYPE, getBuildTime(), 1);
00615 
00616         providePackageNVR(pkg->header);
00617 
00618     {   const char * optflags = rpmExpand("%{optflags}", NULL);
00619         headerAddEntry(pkg->header, RPMTAG_OPTFLAGS, RPM_STRING_TYPE,
00620                         optflags, 1);
00621         free((void *)optflags);
00622     }
00623 
00624         genSourceRpmName(spec);
00625         headerAddEntry(pkg->header, RPMTAG_SOURCERPM, RPM_STRING_TYPE,
00626                        spec->sourceRpmName, 1);
00627         
00628         {   const char *binFormat = rpmGetPath("%{_rpmfilename}", NULL);
00629             char *binRpm, *binDir;
00630             binRpm = headerSprintf(pkg->header, binFormat, rpmTagTable,
00631                                rpmHeaderFormats, &errorString);
00632             free((void *)binFormat);
00633             if (binRpm == NULL) {
00634                 const char *name;
00635                 headerNVR(pkg->header, &name, NULL, NULL);
00636                 rpmError(RPMERR_BADFILENAME, _("Could not generate output "
00637                      "filename for package %s: %s\n"), name, errorString);
00638                 return RPMERR_BADFILENAME;
00639             }
00640             fn = rpmGetPath("%{_rpmdir}/", binRpm, NULL);
00641             if ((binDir = strchr(binRpm, '/')) != NULL) {
00642                 struct stat st;
00643                 const char *dn;
00644                 *binDir = '\0';
00645                 dn = rpmGetPath("%{_rpmdir}/", binRpm, NULL);
00646                 if (Stat(dn, &st) < 0) {
00647                     switch(errno) {
00648                     case  ENOENT:
00649                         if (Mkdir(dn, 0755) == 0)
00650                             break;
00651                         /*@fallthrough@*/
00652                     default:
00653                         rpmError(RPMERR_BADFILENAME,_("cannot create %s: %s\n"),
00654                             dn, strerror(errno));
00655                         break;
00656                     }
00657                 }
00658                 free((void *)dn);
00659             }
00660             free((void *)binRpm);
00661         }
00662 
00663         memset(csa, 0, sizeof(*csa));
00664         csa->cpioArchiveSize = 0;
00665         csa->cpioFdIn = fdNew("init (packageBinaries)");
00666         csa->cpioList = pkg->cpioList;
00667 
00668         rc = writeRPM(&pkg->header, fn, RPMLEAD_BINARY,
00669                     csa, spec->passPhrase, NULL);
00670         csa->cpioFdIn = fdFree(csa->cpioFdIn, "init (packageBinaries)");
00671         free((void *)fn);
00672         if (rc)
00673             return rc;
00674     }
00675     
00676     return 0;
00677 }
00678 
00679 int packageSources(Spec spec)
00680 {
00681     CSA_t csabuf, *csa = &csabuf;
00682     int rc;
00683 
00684     /* Add some cruft */
00685     headerAddEntry(spec->sourceHeader, RPMTAG_RPMVERSION,
00686                    RPM_STRING_TYPE, VERSION, 1);
00687     headerAddEntry(spec->sourceHeader, RPMTAG_BUILDHOST,
00688                    RPM_STRING_TYPE, buildHost(), 1);
00689     headerAddEntry(spec->sourceHeader, RPMTAG_BUILDTIME,
00690                    RPM_INT32_TYPE, getBuildTime(), 1);
00691 
00692     genSourceRpmName(spec);
00693 
00694     FREE(spec->cookie);
00695     
00696     /* XXX this should be %_srpmdir */
00697     {   const char *fn = rpmGetPath("%{_srcrpmdir}/", spec->sourceRpmName,NULL);
00698 
00699         memset(csa, 0, sizeof(*csa));
00700         csa->cpioArchiveSize = 0;
00701         csa->cpioFdIn = fdNew("init (packageSources)");
00702         csa->cpioList = spec->sourceCpioList;
00703 
00704         rc = writeRPM(&spec->sourceHeader, fn, RPMLEAD_SOURCE,
00705                 csa, spec->passPhrase, &(spec->cookie));
00706         csa->cpioFdIn = fdFree(csa->cpioFdIn, "init (packageSources)");
00707         free((void *)fn);
00708     }
00709     return rc;
00710 }