Main Page   Modules   Compound List   File List   Compound Members   File Members   Related Pages  

build/pack.c

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

Generated at Sun Apr 8 18:42:58 2001 for rpm by doxygen1.2.3 written by Dimitri van Heesch, © 1997-2000