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
00018 extern int _noDirTokens;
00019
00020
00021
00022
00023
00024
00025
00026
00029 static inline int genSourceRpmName(Spec spec)
00030
00031 {
00032 if (spec->sourceRpmName == NULL) {
00033 const char *name, *version, *release;
00034 char fileName[BUFSIZ];
00035
00036 (void) headerNVR(spec->packages->header, &name, &version, &release);
00037 sprintf(fileName, "%s-%s-%s.%ssrc.rpm", name, version, release,
00038 spec->noSource ? "no" : "");
00039 spec->sourceRpmName = xstrdup(fileName);
00040 }
00041
00042 return 0;
00043 }
00044
00048 static int cpio_doio(FD_t fdo, Header h, CSA_t csa,
00049 const char * fmodeMacro)
00050
00051 {
00052 const char * rootDir = "/";
00053 rpmdb rpmdb = NULL;
00054 rpmTransactionSet ts = rpmtransCreateSet(rpmdb, rootDir);
00055 TFI_t fi = csa->cpioList;
00056 const char *failedFile = NULL;
00057 FD_t cfd;
00058 int rc, ec;
00059
00060 { const char *fmode = rpmExpand(fmodeMacro, NULL);
00061 if (!(fmode && fmode[0] == 'w'))
00062 fmode = xstrdup("w9.gzdio");
00063
00064 (void) Fflush(fdo);
00065 cfd = Fdopen(fdDup(Fileno(fdo)), fmode);
00066
00067 fmode = _free(fmode);
00068 }
00069 if (cfd == NULL)
00070 return 1;
00071
00072 rc = fsmSetup(fi->fsm, FSM_PKGBUILD, ts, fi, cfd,
00073 &csa->cpioArchiveSize, &failedFile);
00074 (void) Fclose(cfd);
00075 ec = fsmTeardown(fi->fsm);
00076 if (!rc) rc = ec;
00077
00078 if (rc) {
00079 if (failedFile)
00080 rpmError(RPMERR_CPIO, _("create archive failed on file %s: %s\n"),
00081 failedFile, cpioStrerror(rc));
00082 else
00083 rpmError(RPMERR_CPIO, _("create archive failed: %s\n"),
00084 cpioStrerror(rc));
00085 rc = 1;
00086 }
00087
00088 failedFile = _free(failedFile);
00089 ts = rpmtransFree(ts);
00090
00091 return rc;
00092 }
00093
00096 static int cpio_copy(FD_t fdo, CSA_t csa)
00097
00098 {
00099 char buf[BUFSIZ];
00100 size_t nb;
00101
00102 while((nb = Fread(buf, sizeof(buf[0]), sizeof(buf), csa->cpioFdIn)) > 0) {
00103 if (Fwrite(buf, sizeof(buf[0]), nb, fdo) != nb) {
00104 rpmError(RPMERR_CPIO, _("cpio_copy write failed: %s\n"),
00105 Fstrerror(fdo));
00106 return 1;
00107 }
00108 csa->cpioArchiveSize += nb;
00109 }
00110 if (Ferror(csa->cpioFdIn)) {
00111 rpmError(RPMERR_CPIO, _("cpio_copy read failed: %s\n"),
00112 Fstrerror(csa->cpioFdIn));
00113 return 1;
00114 }
00115 return 0;
00116 }
00117
00120 static StringBuf addFileToTagAux(Spec spec,
00121 const char * file, StringBuf sb)
00122
00123 {
00124 char buf[BUFSIZ];
00125 const char * fn = buf;
00126 FILE * f;
00127 FD_t fd;
00128
00129
00130 fn = rpmGetPath("%{_builddir}/", spec->buildSubdir, "/", file, NULL);
00131
00132 fd = Fopen(fn, "r.ufdio");
00133 if (fn != buf) fn = _free(fn);
00134 if (fd == NULL || Ferror(fd)) {
00135 sb = freeStringBuf(sb);
00136 return NULL;
00137 }
00138 if ((f = fdGetFp(fd)) != NULL)
00139 while (fgets(buf, sizeof(buf), f)) {
00140
00141 if (expandMacros(spec, spec->macros, buf, sizeof(buf))) {
00142 rpmError(RPMERR_BADSPEC, _("line: %s\n"), buf);
00143 sb = freeStringBuf(sb);
00144 break;
00145 }
00146 appendStringBuf(sb, buf);
00147 }
00148 (void) Fclose(fd);
00149
00150 return sb;
00151 }
00152
00155 static int addFileToTag(Spec spec, const char * file, Header h, int tag)
00156
00157 {
00158 HGE_t hge = (HGE_t)headerGetEntryMinMemory;
00159 StringBuf sb = newStringBuf();
00160 char *s;
00161
00162 if (hge(h, tag, NULL, (void **)&s, NULL)) {
00163 appendLineStringBuf(sb, s);
00164 (void) headerRemoveEntry(h, tag);
00165 }
00166
00167 if ((sb = addFileToTagAux(spec, file, sb)) == NULL)
00168 return 1;
00169
00170 (void) headerAddEntry(h, tag, RPM_STRING_TYPE, getStringBuf(sb), 1);
00171
00172 sb = freeStringBuf(sb);
00173 return 0;
00174 }
00175
00178 static int addFileToArrayTag(Spec spec, const char *file, Header h, int tag)
00179
00180 {
00181 StringBuf sb = newStringBuf();
00182 char *s;
00183
00184 if ((sb = addFileToTagAux(spec, file, sb)) == NULL)
00185 return 1;
00186
00187 s = getStringBuf(sb);
00188 (void) headerAddOrAppendEntry(h, tag, RPM_STRING_ARRAY_TYPE, &s, 1);
00189
00190 sb = freeStringBuf(sb);
00191 return 0;
00192 }
00193
00196 static int processScriptFiles(Spec spec, Package pkg)
00197
00198 {
00199 struct TriggerFileEntry *p;
00200
00201 if (pkg->preInFile) {
00202 if (addFileToTag(spec, pkg->preInFile, pkg->header, RPMTAG_PREIN)) {
00203 rpmError(RPMERR_BADFILENAME,
00204 _("Could not open PreIn file: %s\n"), pkg->preInFile);
00205 return RPMERR_BADFILENAME;
00206 }
00207 }
00208 if (pkg->preUnFile) {
00209 if (addFileToTag(spec, pkg->preUnFile, pkg->header, RPMTAG_PREUN)) {
00210 rpmError(RPMERR_BADFILENAME,
00211 _("Could not open PreUn file: %s\n"), pkg->preUnFile);
00212 return RPMERR_BADFILENAME;
00213 }
00214 }
00215 if (pkg->postInFile) {
00216 if (addFileToTag(spec, pkg->postInFile, pkg->header, RPMTAG_POSTIN)) {
00217 rpmError(RPMERR_BADFILENAME,
00218 _("Could not open PostIn file: %s\n"), pkg->postInFile);
00219 return RPMERR_BADFILENAME;
00220 }
00221 }
00222 if (pkg->postUnFile) {
00223 if (addFileToTag(spec, pkg->postUnFile, pkg->header, RPMTAG_POSTUN)) {
00224 rpmError(RPMERR_BADFILENAME,
00225 _("Could not open PostUn file: %s\n"), pkg->postUnFile);
00226 return RPMERR_BADFILENAME;
00227 }
00228 }
00229 if (pkg->verifyFile) {
00230 if (addFileToTag(spec, pkg->verifyFile, pkg->header,
00231 RPMTAG_VERIFYSCRIPT)) {
00232 rpmError(RPMERR_BADFILENAME,
00233 _("Could not open VerifyScript file: %s\n"), pkg->verifyFile);
00234 return RPMERR_BADFILENAME;
00235 }
00236 }
00237
00238 for (p = pkg->triggerFiles; p != NULL; p = p->next) {
00239 (void) headerAddOrAppendEntry(pkg->header, RPMTAG_TRIGGERSCRIPTPROG,
00240 RPM_STRING_ARRAY_TYPE, &(p->prog), 1);
00241 if (p->script) {
00242 (void) headerAddOrAppendEntry(pkg->header, RPMTAG_TRIGGERSCRIPTS,
00243 RPM_STRING_ARRAY_TYPE, &(p->script), 1);
00244 } else if (p->fileName) {
00245 if (addFileToArrayTag(spec, p->fileName, pkg->header,
00246 RPMTAG_TRIGGERSCRIPTS)) {
00247 rpmError(RPMERR_BADFILENAME,
00248 _("Could not open Trigger script file: %s\n"),
00249 p->fileName);
00250 return RPMERR_BADFILENAME;
00251 }
00252 } else {
00253
00254
00255 char *bull = "";
00256 (void) headerAddOrAppendEntry(pkg->header, RPMTAG_TRIGGERSCRIPTS,
00257 RPM_STRING_ARRAY_TYPE, &bull, 1);
00258 }
00259 }
00260
00261 return 0;
00262 }
00263
00264 int readRPM(const char *fileName, Spec *specp, struct rpmlead *lead,
00265 Header *sigs, CSA_t csa)
00266 {
00267 FD_t fdi;
00268 Spec spec;
00269 rpmRC rc;
00270
00271 fdi = (fileName != NULL)
00272 ? Fopen(fileName, "r.ufdio")
00273 : fdDup(STDIN_FILENO);
00274
00275 if (fdi == NULL || Ferror(fdi)) {
00276 rpmError(RPMERR_BADMAGIC, _("readRPM: open %s: %s\n"),
00277 (fileName ? fileName : "<stdin>"),
00278 Fstrerror(fdi));
00279 if (fdi) (void) Fclose(fdi);
00280 return RPMERR_BADMAGIC;
00281 }
00282
00283
00284 if ((rc = Fread(lead, sizeof(char), sizeof(*lead), fdi)) != sizeof(*lead)) {
00285 rpmError(RPMERR_BADMAGIC, _("readRPM: read %s: %s\n"),
00286 (fileName ? fileName : "<stdin>"),
00287 Fstrerror(fdi));
00288 return RPMERR_BADMAGIC;
00289 }
00290
00291
00292 if (Fseek(fdi, 0, SEEK_SET) == -1) {
00293 rpmError(RPMERR_FSEEK, _("%s: Fseek failed: %s\n"),
00294 (fileName ? fileName : "<stdin>"), Fstrerror(fdi));
00295 return RPMERR_FSEEK;
00296 }
00297
00298
00299 spec = newSpec();
00300 spec->packages = newPackage(spec);
00301
00302
00303 spec->packages->header = headerFree(spec->packages->header);
00304
00305
00306 rc = rpmReadPackageInfo(fdi, sigs, &spec->packages->header);
00307 switch (rc) {
00308 case RPMRC_BADMAGIC:
00309 rpmError(RPMERR_BADMAGIC, _("readRPM: %s is not an RPM package\n"),
00310 (fileName ? fileName : "<stdin>"));
00311 return RPMERR_BADMAGIC;
00312 case RPMRC_OK:
00313 break;
00314 case RPMRC_FAIL:
00315 case RPMRC_BADSIZE:
00316 case RPMRC_SHORTREAD:
00317 default:
00318 rpmError(RPMERR_BADMAGIC, _("readRPM: reading header from %s\n"),
00319 (fileName ? fileName : "<stdin>"));
00320 return RPMERR_BADMAGIC;
00321 break;
00322 }
00323
00324 if (specp)
00325 *specp = spec;
00326 else
00327 spec = freeSpec(spec);
00328
00329 if (csa != NULL)
00330 csa->cpioFdIn = fdi;
00331 else
00332 (void) Fclose(fdi);
00333
00334 return 0;
00335 }
00336
00337 static unsigned char header_magic[8] = {
00338 0x8e, 0xad, 0xe8, 0x01, 0x00, 0x00, 0x00, 0x00
00339 };
00340
00341 #define RPMPKGVERSION_MIN 30004
00342 #define RPMPKGVERSION_MAX 40003
00343 static int rpmpkg_version = -1;
00344
00345 static int rpmLeadVersion(void)
00346 {
00347 int rpmlead_version;
00348
00349
00350 if (rpmpkg_version < 0) {
00351 rpmpkg_version = rpmExpandNumeric("%{_package_version}");
00352 if (rpmpkg_version < RPMPKGVERSION_MIN)
00353 rpmpkg_version = RPMPKGVERSION_MIN;
00354 if (rpmpkg_version > RPMPKGVERSION_MAX)
00355 rpmpkg_version = RPMPKGVERSION_MAX;
00356 }
00357
00358 rpmlead_version = rpmpkg_version / 10000;
00359 if (_noDirTokens || (rpmlead_version < 3 || rpmlead_version > 4))
00360 rpmlead_version = 3;
00361 return rpmlead_version;
00362 }
00363
00364 int writeRPM(Header *hdrp, const char *fileName, int type,
00365 CSA_t csa, char *passPhrase, const char **cookie)
00366 {
00367 FD_t fd = NULL;
00368 FD_t ifd = NULL;
00369 int count, sigtype;
00370 const char * sigtarget;
00371 const char * rpmio_flags = NULL;
00372 const char * sha1 = NULL;
00373 char *s;
00374 char buf[BUFSIZ];
00375 Header h;
00376 Header sig = NULL;
00377 int rc = 0;
00378
00379
00380 h = headerLink(*hdrp);
00381 *hdrp = headerFree(*hdrp);
00382
00383 if (Fileno(csa->cpioFdIn) < 0) {
00384 csa->cpioArchiveSize = 0;
00385
00386 (void) headerAddEntry(h, RPMTAG_ARCHIVESIZE, RPM_INT32_TYPE,
00387 &csa->cpioArchiveSize, 1);
00388 }
00389
00390
00391 if (type == RPMLEAD_BINARY)
00392 providePackageNVR(h);
00393
00394
00395 switch(type) {
00396 case RPMLEAD_SOURCE:
00397 rpmio_flags = rpmExpand("%{?_source_payload:%{_source_payload}}", NULL);
00398 break;
00399 case RPMLEAD_BINARY:
00400 rpmio_flags = rpmExpand("%{?_binary_payload:%{_binary_payload}}", NULL);
00401 break;
00402 }
00403 if (!(rpmio_flags && *rpmio_flags)) {
00404 rpmio_flags = _free(rpmio_flags);
00405 rpmio_flags = xstrdup("w9.gzdio");
00406 }
00407 s = strchr(rpmio_flags, '.');
00408 if (s) {
00409 (void) headerAddEntry(h, RPMTAG_PAYLOADFORMAT, RPM_STRING_TYPE, "cpio", 1);
00410 if (s[1] == 'g' && s[2] == 'z')
00411 (void) headerAddEntry(h, RPMTAG_PAYLOADCOMPRESSOR, RPM_STRING_TYPE,
00412 "gzip", 1);
00413 if (s[1] == 'b' && s[2] == 'z') {
00414 (void) headerAddEntry(h, RPMTAG_PAYLOADCOMPRESSOR, RPM_STRING_TYPE,
00415 "bzip2", 1);
00416
00417 (void) rpmlibNeedsFeature(h, "PayloadIsBzip2", "3.0.5-1");
00418 }
00419 strcpy(buf, rpmio_flags);
00420 buf[s - rpmio_flags] = '\0';
00421 (void) headerAddEntry(h, RPMTAG_PAYLOADFLAGS, RPM_STRING_TYPE, buf+1, 1);
00422 }
00423
00424
00425 if (cookie) {
00426 sprintf(buf, "%s %d", buildHost(), (int) time(NULL));
00427 *cookie = xstrdup(buf);
00428 (void) headerAddEntry(h, RPMTAG_COOKIE, RPM_STRING_TYPE, *cookie, 1);
00429 }
00430
00431
00432 h = headerReload(h, RPMTAG_HEADERIMMUTABLE);
00433 if (h == NULL) {
00434 rc = RPMERR_RELOAD;
00435 rpmError(RPMERR_RELOAD, _("Unable to create immutable header region.\n"));
00436 goto exit;
00437 }
00438
00439 *hdrp = headerLink(h);
00440
00441
00442
00443
00444
00445 if (makeTempFile(NULL, &sigtarget, &fd)) {
00446 rc = RPMERR_CREATE;
00447 rpmError(RPMERR_CREATE, _("Unable to open temp file.\n"));
00448 goto exit;
00449 }
00450
00451 if (headerWrite(fd, h, HEADER_MAGIC_YES)) {
00452 rc = RPMERR_NOSPACE;
00453 rpmError(RPMERR_NOSPACE, _("Unable to write temp header\n"));
00454 } else {
00455 if (csa->cpioList != NULL) {
00456 rc = cpio_doio(fd, h, csa, rpmio_flags);
00457 } else if (Fileno(csa->cpioFdIn) >= 0) {
00458 rc = cpio_copy(fd, csa);
00459 } else {
00460 rc = RPMERR_BADARG;
00461 rpmError(RPMERR_BADARG, _("Bad CSA data\n"));
00462 }
00463 }
00464 rpmio_flags = _free(rpmio_flags);
00465
00466 if (rc)
00467 goto exit;
00468
00469
00470
00471
00472
00473
00474
00475
00476
00477
00478
00479 if (Fileno(csa->cpioFdIn) < 0) {
00480 HGE_t hge = (HGE_t)headerGetEntryMinMemory;
00481 int_32 * archiveSize;
00482 if (hge(h, RPMTAG_ARCHIVESIZE, NULL, (void *)&archiveSize, NULL))
00483 *archiveSize = csa->cpioArchiveSize;
00484 }
00485
00486 (void) Fflush(fd);
00487 if (Fseek(fd, sizeof(header_magic), SEEK_SET) == -1) {
00488 rc = RPMERR_FSEEK;
00489 rpmError(RPMERR_FSEEK, _("%s: Fseek failed: %s\n"),
00490 sigtarget, Fstrerror(fd));
00491 }
00492
00493 fdInitSHA1(fd, 0);
00494 if (headerWrite(fd, h, HEADER_MAGIC_NO)) {
00495 rc = RPMERR_NOSPACE;
00496 rpmError(RPMERR_NOSPACE, _("Unable to write final header\n"));
00497 }
00498 (void) Fflush(fd);
00499 fdFiniSHA1(fd, (void **)&sha1, NULL, 1);
00500
00501 (void) Fclose(fd);
00502 fd = NULL;
00503 (void) Unlink(fileName);
00504
00505 if (rc)
00506 goto exit;
00507
00508
00509 (void) fflush(stdout);
00510 sig = rpmNewSignature();
00511 (void) rpmAddSignature(sig, sigtarget, RPMSIGTAG_SIZE, passPhrase);
00512 (void) rpmAddSignature(sig, sigtarget, RPMSIGTAG_MD5, passPhrase);
00513 if ((sigtype = rpmLookupSignatureType(RPMLOOKUPSIG_QUERY)) > 0) {
00514 rpmMessage(RPMMESS_NORMAL, _("Generating signature: %d\n"), sigtype);
00515 (void) rpmAddSignature(sig, sigtarget, sigtype, passPhrase);
00516 }
00517
00518 if (sha1) {
00519 (void) headerAddEntry(sig, RPMTAG_SHA1HEADER, RPM_STRING_TYPE, sha1, 1);
00520 sha1 = _free(sha1);
00521 }
00522
00523
00524 sig = headerReload(sig, RPMTAG_HEADERSIGNATURES);
00525 if (sig == NULL) {
00526 rc = RPMERR_RELOAD;
00527 rpmError(RPMERR_RELOAD, _("Unable to reload signature header.\n"));
00528 goto exit;
00529 }
00530
00531
00532 fd = Fopen(fileName, "w.ufdio");
00533 if (fd == NULL || Ferror(fd)) {
00534 rc = RPMERR_CREATE;
00535 rpmError(RPMERR_CREATE, _("Could not open %s: %s\n"),
00536 fileName, Fstrerror(fd));
00537 goto exit;
00538 }
00539
00540
00541 { int archnum = -1;
00542 int osnum = -1;
00543 struct rpmlead lead;
00544
00545 if (Fileno(csa->cpioFdIn) < 0) {
00546 #ifndef DYING
00547 rpmGetArchInfo(NULL, &archnum);
00548 rpmGetOsInfo(NULL, &osnum);
00549 #endif
00550 } else if (csa->lead != NULL) {
00551 archnum = csa->lead->archnum;
00552 osnum = csa->lead->osnum;
00553 }
00554
00555 memset(&lead, 0, sizeof(lead));
00556 lead.major = rpmLeadVersion();
00557 lead.minor = 0;
00558 lead.type = type;
00559 lead.archnum = archnum;
00560 lead.osnum = osnum;
00561 lead.signature_type = RPMSIGTYPE_HEADERSIG;
00562
00563 { const char *name, *version, *release;
00564 (void) headerNVR(h, &name, &version, &release);
00565 sprintf(buf, "%s-%s-%s", name, version, release);
00566 strncpy(lead.name, buf, sizeof(lead.name));
00567 }
00568
00569 if (writeLead(fd, &lead)) {
00570 rc = RPMERR_NOSPACE;
00571 rpmError(RPMERR_NOSPACE, _("Unable to write package: %s\n"),
00572 Fstrerror(fd));
00573 goto exit;
00574 }
00575 }
00576
00577
00578 rc = rpmWriteSignature(fd, sig);
00579 if (rc)
00580 goto exit;
00581
00582
00583 ifd = Fopen(sigtarget, "r.ufdio");
00584 if (ifd == NULL || Ferror(ifd)) {
00585 rc = RPMERR_READ;
00586 rpmError(RPMERR_READ, _("Unable to open sigtarget %s: %s\n"),
00587 sigtarget, Fstrerror(ifd));
00588 goto exit;
00589 }
00590
00591
00592 { Header nh = headerRead(ifd, HEADER_MAGIC_YES);
00593
00594 if (nh == NULL) {
00595 rc = RPMERR_READ;
00596 rpmError(RPMERR_READ, _("Unable to read header from %s: %s\n"),
00597 sigtarget, Fstrerror(ifd));
00598 goto exit;
00599 }
00600
00601 #ifdef NOTYET
00602 (void) headerMergeLegacySigs(nh, sig);
00603 #endif
00604
00605 rc = headerWrite(fd, nh, HEADER_MAGIC_YES);
00606 nh = headerFree(nh);
00607
00608 if (rc) {
00609 rc = RPMERR_NOSPACE;
00610 rpmError(RPMERR_NOSPACE, _("Unable to write header to %s: %s\n"),
00611 fileName, Fstrerror(fd));
00612 goto exit;
00613 }
00614 }
00615
00616
00617 while ((count = Fread(buf, sizeof(buf[0]), sizeof(buf), ifd)) > 0) {
00618 if (count == -1) {
00619 rc = RPMERR_READ;
00620 rpmError(RPMERR_READ, _("Unable to read payload from %s: %s\n"),
00621 sigtarget, Fstrerror(ifd));
00622 goto exit;
00623 }
00624 if (Fwrite(buf, sizeof(buf[0]), count, fd) != count) {
00625 rc = RPMERR_NOSPACE;
00626 rpmError(RPMERR_NOSPACE, _("Unable to write payload to %s: %s\n"),
00627 fileName, Fstrerror(fd));
00628 goto exit;
00629 }
00630 }
00631 rc = 0;
00632
00633 exit:
00634 sha1 = _free(sha1);
00635 h = headerFree(h);
00636 sig = rpmFreeSignature(sig);
00637 if (ifd) {
00638 (void) Fclose(ifd);
00639 ifd = NULL;
00640 }
00641 if (fd) {
00642 (void) Fclose(fd);
00643 fd = NULL;
00644 }
00645 if (sigtarget) {
00646 (void) Unlink(sigtarget);
00647 sigtarget = _free(sigtarget);
00648 }
00649
00650 if (rc == 0)
00651 rpmMessage(RPMMESS_NORMAL, _("Wrote: %s\n"), fileName);
00652 else
00653 (void) Unlink(fileName);
00654
00655 return rc;
00656 }
00657
00658 static int_32 copyTags[] = {
00659 RPMTAG_CHANGELOGTIME,
00660 RPMTAG_CHANGELOGNAME,
00661 RPMTAG_CHANGELOGTEXT,
00662 0
00663 };
00664
00665 int packageBinaries(Spec spec)
00666 {
00667 struct cpioSourceArchive_s csabuf;
00668 CSA_t csa = &csabuf;
00669 int rc;
00670 const char *errorString;
00671 Package pkg;
00672
00673 #if defined(__s390x__)
00674 int32_t bt = (int32_t)(*getBuildTime());
00675 #endif
00676
00677 for (pkg = spec->packages; pkg != NULL; pkg = pkg->next) {
00678 const char *fn;
00679
00680 if (pkg->fileList == NULL)
00681 continue;
00682
00683 if ((rc = processScriptFiles(spec, pkg)))
00684 return rc;
00685
00686 if (spec->cookie) {
00687 (void) headerAddEntry(pkg->header, RPMTAG_COOKIE,
00688 RPM_STRING_TYPE, spec->cookie, 1);
00689 }
00690
00691
00692 headerCopyTags(spec->packages->header, pkg->header, copyTags);
00693
00694 (void) headerAddEntry(pkg->header, RPMTAG_RPMVERSION,
00695 RPM_STRING_TYPE, VERSION, 1);
00696 (void) headerAddEntry(pkg->header, RPMTAG_BUILDHOST,
00697 RPM_STRING_TYPE, buildHost(), 1);
00698 #if defined(__s390x__)
00699 (void) headerAddEntry(pkg->header, RPMTAG_BUILDTIME,
00700 RPM_INT32_TYPE, &bt, 1);
00701 #else
00702 (void) headerAddEntry(pkg->header, RPMTAG_BUILDTIME,
00703 RPM_INT32_TYPE, getBuildTime(), 1);
00704 #endif
00705
00706 providePackageNVR(pkg->header);
00707
00708 { const char * optflags = rpmExpand("%{optflags}", NULL);
00709 (void) headerAddEntry(pkg->header, RPMTAG_OPTFLAGS, RPM_STRING_TYPE,
00710 optflags, 1);
00711 optflags = _free(optflags);
00712 }
00713
00714 (void) genSourceRpmName(spec);
00715 (void) headerAddEntry(pkg->header, RPMTAG_SOURCERPM, RPM_STRING_TYPE,
00716 spec->sourceRpmName, 1);
00717
00718 { const char *binFormat = rpmGetPath("%{_rpmfilename}", NULL);
00719 char *binRpm, *binDir;
00720 binRpm = headerSprintf(pkg->header, binFormat, rpmTagTable,
00721 rpmHeaderFormats, &errorString);
00722 binFormat = _free(binFormat);
00723 if (binRpm == NULL) {
00724 const char *name;
00725 (void) headerNVR(pkg->header, &name, NULL, NULL);
00726 rpmError(RPMERR_BADFILENAME, _("Could not generate output "
00727 "filename for package %s: %s\n"), name, errorString);
00728 return RPMERR_BADFILENAME;
00729 }
00730 fn = rpmGetPath("%{_rpmdir}/", binRpm, NULL);
00731 if ((binDir = strchr(binRpm, '/')) != NULL) {
00732 struct stat st;
00733 const char *dn;
00734 *binDir = '\0';
00735 dn = rpmGetPath("%{_rpmdir}/", binRpm, NULL);
00736 if (Stat(dn, &st) < 0) {
00737 switch(errno) {
00738 case ENOENT:
00739 if (Mkdir(dn, 0755) == 0)
00740 break;
00741
00742 default:
00743 rpmError(RPMERR_BADFILENAME,_("cannot create %s: %s\n"),
00744 dn, strerror(errno));
00745 break;
00746 }
00747 }
00748 dn = _free(dn);
00749 }
00750 binRpm = _free(binRpm);
00751 }
00752
00753 memset(csa, 0, sizeof(*csa));
00754 csa->cpioArchiveSize = 0;
00755 csa->cpioFdIn = fdNew("init (packageBinaries)");
00756 csa->cpioList = pkg->cpioList;
00757
00758 rc = writeRPM(&pkg->header, fn, RPMLEAD_BINARY,
00759 csa, spec->passPhrase, NULL);
00760 csa->cpioFdIn = fdFree(csa->cpioFdIn, "init (packageBinaries)");
00761 fn = _free(fn);
00762 if (rc)
00763 return rc;
00764 }
00765
00766 return 0;
00767 }
00768
00769 int packageSources(Spec spec)
00770 {
00771 struct cpioSourceArchive_s csabuf;
00772 CSA_t csa = &csabuf;
00773 int rc;
00774
00775 #if defined(__s390x__)
00776 int32_t bt = (int32_t)(*getBuildTime());
00777 #endif
00778
00779
00780 (void) headerAddEntry(spec->sourceHeader, RPMTAG_RPMVERSION,
00781 RPM_STRING_TYPE, VERSION, 1);
00782 (void) headerAddEntry(spec->sourceHeader, RPMTAG_BUILDHOST,
00783 RPM_STRING_TYPE, buildHost(), 1);
00784 #if defined(__s390x__)
00785 (void) headerAddEntry(spec->sourceHeader, RPMTAG_BUILDTIME,
00786 RPM_INT32_TYPE, &bt, 1);
00787 #else
00788 (void) headerAddEntry(spec->sourceHeader, RPMTAG_BUILDTIME,
00789 RPM_INT32_TYPE, getBuildTime(), 1);
00790 #endif
00791
00792 (void) genSourceRpmName(spec);
00793
00794 spec->cookie = _free(spec->cookie);
00795
00796
00797 { const char *fn = rpmGetPath("%{_srcrpmdir}/", spec->sourceRpmName,NULL);
00798
00799 memset(csa, 0, sizeof(*csa));
00800 csa->cpioArchiveSize = 0;
00801 csa->cpioFdIn = fdNew("init (packageSources)");
00802 csa->cpioList = spec->sourceCpioList;
00803
00804 rc = writeRPM(&spec->sourceHeader, fn, RPMLEAD_SOURCE,
00805 csa, spec->passPhrase, &(spec->cookie));
00806 csa->cpioFdIn = fdFree(csa->cpioFdIn, "init (packageSources)");
00807 fn = _free(fn);
00808 }
00809 return rc;
00810 }