00001
00006 #include "system.h"
00007
00008 #include <rpmio_internal.h>
00009 #include <rpmcb.h>
00010 #include <argv.h>
00011
00012 #include <rpmtypes.h>
00013 #include <rpmtag.h>
00014
00015 #include <pkgio.h>
00016 #include "signature.h"
00017
00018 #define _RPMFI_INTERNAL
00019 #define _RPMEVR_INTERNAL
00020 #define _RPMTAG_INTERNAL
00021 #include <rpmbuild.h>
00022
00023 #include "rpmfi.h"
00024 #include "fsm.h"
00025
00026 #include <rpmversion.h>
00027 #include "buildio.h"
00028
00029 #include "debug.h"
00030
00031
00032
00033
00034
00035
00036
00040 static rpmRC cpio_doio(FD_t fdo, Header h, CSA_t csa,
00041 const char * payload_format, const char * fmodeMacro)
00042
00043
00044
00045 {
00046 rpmts ts = rpmtsCreate();
00047 rpmfi fi = csa->cpioList;
00048 const char *failedFile = NULL;
00049 FD_t cfd;
00050 rpmRC rc = RPMRC_OK;
00051 int xx;
00052
00053 { const char *fmode = rpmExpand(fmodeMacro, NULL);
00054 if (!(fmode && fmode[0] == 'w'))
00055 fmode = xstrdup("w9.gzdio");
00056
00057 (void) Fflush(fdo);
00058 cfd = Fdopen(fdDup(Fileno(fdo)), fmode);
00059
00060 fmode = _free(fmode);
00061 }
00062 if (cfd == NULL)
00063 return RPMRC_FAIL;
00064
00065 xx = fsmSetup(fi->fsm, IOSM_PKGBUILD, payload_format, ts, fi, cfd,
00066 &csa->cpioArchiveSize, &failedFile);
00067 if (xx)
00068 rc = RPMRC_FAIL;
00069 (void) Fclose(cfd);
00070 xx = fsmTeardown(fi->fsm);
00071 if (rc == RPMRC_OK && xx) rc = RPMRC_FAIL;
00072
00073 if (rc) {
00074 const char * msg = iosmStrerror(rc);
00075 if (failedFile)
00076 rpmlog(RPMLOG_ERR, _("create archive failed on file %s: %s\n"),
00077 failedFile, msg);
00078 else
00079 rpmlog(RPMLOG_ERR, _("create archive failed: %s\n"), msg);
00080 msg = _free(msg);
00081 rc = RPMRC_FAIL;
00082 }
00083
00084 failedFile = _free(failedFile);
00085 (void)rpmtsFree(ts);
00086 ts = NULL;
00087
00088 return rc;
00089 }
00090
00093 static rpmRC cpio_copy(FD_t fdo, CSA_t csa)
00094
00095
00096 {
00097 char buf[BUFSIZ];
00098 size_t nb;
00099
00100 while((nb = Fread(buf, sizeof(buf[0]), sizeof(buf), csa->cpioFdIn)) > 0) {
00101 if (Fwrite(buf, sizeof(buf[0]), nb, fdo) != nb) {
00102 rpmlog(RPMLOG_ERR, _("cpio_copy write failed: %s\n"),
00103 Fstrerror(fdo));
00104 return RPMRC_FAIL;
00105 }
00106 csa->cpioArchiveSize += nb;
00107 }
00108 if (Ferror(csa->cpioFdIn)) {
00109 rpmlog(RPMLOG_ERR, _("cpio_copy read failed: %s\n"),
00110 Fstrerror(csa->cpioFdIn));
00111 return RPMRC_FAIL;
00112 }
00113 return RPMRC_OK;
00114 }
00115
00118 static rpmiob addFileToTagAux(Spec spec,
00119 const char * file, rpmiob iob)
00120
00121
00122 {
00123 char buf[BUFSIZ];
00124 const char * fn = buf;
00125 FILE * f;
00126 FD_t fd;
00127
00128 fn = rpmGetPath("%{_builddir}/%{?buildsubdir:%{buildsubdir}/}", file, NULL);
00129
00130 fd = Fopen(fn, "r.fdio");
00131 if (fn != buf) fn = _free(fn);
00132 if (fd == NULL || Ferror(fd)) {
00133 iob = rpmiobFree(iob);
00134 return NULL;
00135 }
00136
00137 if ((f = fdGetFp(fd)) != NULL)
00138
00139 while (fgets(buf, (int)sizeof(buf), f)) {
00140
00141 if (expandMacros(spec, spec->macros, buf, sizeof(buf))) {
00142 rpmlog(RPMLOG_ERR, _("line: %s\n"), buf);
00143 iob = rpmiobFree(iob);
00144 break;
00145 }
00146 iob = rpmiobAppend(iob, buf, 0);
00147 }
00148 (void) Fclose(fd);
00149
00150 return iob;
00151 }
00152
00155 static int addFileToTag(Spec spec, const char * file, Header h, rpmTag tag)
00156
00157
00158 {
00159 HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
00160 rpmiob iob = rpmiobNew(0);
00161 int xx;
00162
00163 he->tag = tag;
00164 xx = headerGet(h, he, 0);
00165 if (xx) {
00166 iob = rpmiobAppend(iob, he->p.str, 1);
00167 xx = headerDel(h, he, 0);
00168 }
00169 he->p.ptr = _free(he->p.ptr);
00170
00171 if ((iob = addFileToTagAux(spec, file, iob)) == NULL)
00172 return 1;
00173
00174 he->tag = tag;
00175 he->t = RPM_STRING_TYPE;
00176 he->p.str = rpmiobStr(iob);
00177 he->c = 1;
00178 xx = headerPut(h, he, 0);
00179
00180 iob = rpmiobFree(iob);
00181 return 0;
00182 }
00183
00186 static int addFileToArrayTag(Spec spec, const char *file, Header h, rpmTag tag)
00187
00188
00189 {
00190 HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
00191 rpmiob iob = rpmiobNew(0);
00192 const char *s;
00193 int xx;
00194
00195 if ((iob = addFileToTagAux(spec, file, iob)) == NULL)
00196 return 1;
00197
00198 s = rpmiobStr(iob);
00199
00200 he->tag = tag;
00201 he->t = RPM_STRING_ARRAY_TYPE;
00202 he->p.argv = &s;
00203 he->c = 1;
00204 he->append = 1;
00205 xx = headerPut(h, he, 0);
00206 he->append = 0;
00207
00208 iob = rpmiobFree(iob);
00209 return 0;
00210 }
00211
00212 rpmRC processScriptFiles(Spec spec, Package pkg)
00213
00214
00215
00216 {
00217 HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
00218 struct TriggerFileEntry *p;
00219 int xx;
00220
00221 if (pkg->preInFile) {
00222 if (addFileToTag(spec, pkg->preInFile, pkg->header, RPMTAG_PREIN)) {
00223 rpmlog(RPMLOG_ERR,
00224 _("Could not open PreIn file: %s\n"), pkg->preInFile);
00225 return RPMRC_FAIL;
00226 }
00227 }
00228 if (pkg->preUnFile) {
00229 if (addFileToTag(spec, pkg->preUnFile, pkg->header, RPMTAG_PREUN)) {
00230 rpmlog(RPMLOG_ERR,
00231 _("Could not open PreUn file: %s\n"), pkg->preUnFile);
00232 return RPMRC_FAIL;
00233 }
00234 }
00235 if (pkg->preTransFile) {
00236 if (addFileToTag(spec, pkg->preTransFile, pkg->header, RPMTAG_PRETRANS)) {
00237 rpmlog(RPMLOG_ERR,
00238 _("Could not open PreTrans file: %s\n"), pkg->preTransFile);
00239 return RPMRC_FAIL;
00240 }
00241 }
00242 if (pkg->postInFile) {
00243 if (addFileToTag(spec, pkg->postInFile, pkg->header, RPMTAG_POSTIN)) {
00244 rpmlog(RPMLOG_ERR,
00245 _("Could not open PostIn file: %s\n"), pkg->postInFile);
00246 return RPMRC_FAIL;
00247 }
00248 }
00249 if (pkg->postUnFile) {
00250 if (addFileToTag(spec, pkg->postUnFile, pkg->header, RPMTAG_POSTUN)) {
00251 rpmlog(RPMLOG_ERR,
00252 _("Could not open PostUn file: %s\n"), pkg->postUnFile);
00253 return RPMRC_FAIL;
00254 }
00255 }
00256 if (pkg->postTransFile) {
00257 if (addFileToTag(spec, pkg->postTransFile, pkg->header, RPMTAG_POSTTRANS)) {
00258 rpmlog(RPMLOG_ERR,
00259 _("Could not open PostTrans file: %s\n"), pkg->postTransFile);
00260 return RPMRC_FAIL;
00261 }
00262 }
00263 if (pkg->verifyFile) {
00264 if (addFileToTag(spec, pkg->verifyFile, pkg->header,
00265 RPMTAG_VERIFYSCRIPT)) {
00266 rpmlog(RPMLOG_ERR,
00267 _("Could not open VerifyScript file: %s\n"), pkg->verifyFile);
00268 return RPMRC_FAIL;
00269 }
00270 }
00271
00272 if (pkg->sanityCheckFile) {
00273 if (addFileToTag(spec, pkg->sanityCheckFile, pkg->header, RPMTAG_SANITYCHECK)) {
00274 rpmlog(RPMLOG_ERR, _("Could not open Test file: %s\n"), pkg->sanityCheckFile);
00275 return RPMRC_FAIL;
00276 }
00277 }
00278
00279 for (p = pkg->triggerFiles; p != NULL; p = p->next) {
00280 he->tag = RPMTAG_TRIGGERSCRIPTPROG;
00281 he->t = RPM_STRING_ARRAY_TYPE;
00282 he->p.argv = (const char **)&p->prog;
00283 he->c = 1;
00284 he->append = 1;
00285 xx = headerPut(pkg->header, he, 0);
00286 he->append = 0;
00287 if (p->script) {
00288 he->tag = RPMTAG_TRIGGERSCRIPTS;
00289 he->t = RPM_STRING_ARRAY_TYPE;
00290 he->p.argv = (const char **)&p->script;
00291 he->c = 1;
00292 he->append = 1;
00293 xx = headerPut(pkg->header, he, 0);
00294 he->append = 0;
00295 } else if (p->fileName) {
00296 if (addFileToArrayTag(spec, p->fileName, pkg->header,
00297 RPMTAG_TRIGGERSCRIPTS)) {
00298 rpmlog(RPMLOG_ERR,
00299 _("Could not open Trigger script file: %s\n"),
00300 p->fileName);
00301 return RPMRC_FAIL;
00302 }
00303 } else {
00304
00305 static const char *bull = "";
00306 he->tag = RPMTAG_TRIGGERSCRIPTS;
00307 he->t = RPM_STRING_ARRAY_TYPE;
00308 he->p.argv = •
00309 he->c = 1;
00310 he->append = 1;
00311 xx = headerPut(pkg->header, he, 0);
00312 he->append = 0;
00313 }
00314 }
00315
00316 return RPMRC_OK;
00317 }
00318
00319 #if defined(DEAD)
00320 int readRPM(const char *fileName, Spec *specp, void * l,
00321 Header *sigs, CSA_t csa)
00322 {
00323 const char * msg = "";
00324 FD_t fdi;
00325 Spec spec;
00326 rpmRC rc;
00327
00328 fdi = (fileName != NULL)
00329 ? Fopen(fileName, "r.fdio")
00330 : fdDup(STDIN_FILENO);
00331
00332 if (fdi == NULL || Ferror(fdi)) {
00333 rpmlog(RPMLOG_ERR, _("readRPM: open %s: %s\n"),
00334 (fileName ? fileName : "<stdin>"),
00335 Fstrerror(fdi));
00336 if (fdi) (void) Fclose(fdi);
00337 return RPMRC_FAIL;
00338 }
00339
00340 { const char item[] = "Lead";
00341 size_t nl = rpmpkgSizeof(item, NULL);
00342
00343 if (nl == 0) {
00344 rc = RPMRC_FAIL;
00345 msg = xstrdup("item size is zero");
00346 } else {
00347 l = xcalloc(1, nl);
00348 msg = NULL;
00349 rc = rpmpkgRead(item, fdi, l, &msg);
00350 }
00351 }
00352
00353 if (rc != RPMRC_OK) {
00354 rpmlog(RPMLOG_ERR, _("readRPM: read %s: %s\n"),
00355 (fileName ? fileName : "<stdin>"), msg);
00356 msg = _free(msg);
00357 return RPMRC_FAIL;
00358 }
00359 msg = _free(msg);
00360
00361
00362
00363 if (Fseek(fdi, 0, SEEK_SET) == -1) {
00364 rpmlog(RPMLOG_ERR, _("%s: Fseek failed: %s\n"),
00365 (fileName ? fileName : "<stdin>"), Fstrerror(fdi));
00366 return RPMRC_FAIL;
00367 }
00368
00369
00370 spec = newSpec();
00371 spec->packages = newPackage(spec);
00372
00373
00374 (void)headerFree(spec->packages->header);
00375 spec->packages->header = NULL;
00376
00377
00378 { rpmts ts = rpmtsCreate();
00379
00380
00381
00382 rc = rpmReadPackageFile(ts, fdi, "readRPM",
00383 &spec->packages->header);
00384
00385
00386 (void)rpmtsFree(ts);
00387 ts = NULL;
00388
00389 if (sigs) *sigs = NULL;
00390 }
00391
00392 switch (rc) {
00393 case RPMRC_OK:
00394 case RPMRC_NOKEY:
00395 case RPMRC_NOTTRUSTED:
00396 break;
00397 case RPMRC_NOTFOUND:
00398 rpmlog(RPMLOG_ERR, _("readRPM: %s is not an RPM package\n"),
00399 (fileName ? fileName : "<stdin>"));
00400 return RPMRC_FAIL;
00401 case RPMRC_FAIL:
00402 default:
00403 rpmlog(RPMLOG_ERR, _("readRPM: reading header from %s\n"),
00404 (fileName ? fileName : "<stdin>"));
00405 return RPMRC_FAIL;
00406 break;
00407 }
00408
00409 if (specp)
00410 *specp = spec;
00411 else
00412 spec = freeSpec(spec);
00413
00414 if (csa != NULL)
00415 csa->cpioFdIn = fdi;
00416 else
00417 (void) Fclose(fdi);
00418
00419 return 0;
00420 }
00421 #endif
00422
00423 #if defined(DEAD)
00424 #define RPMPKGVERSION_MIN 30004
00425 #define RPMPKGVERSION_MAX 40003
00426
00427 static int rpmpkg_version = -1;
00428
00429 static int rpmLeadVersion(void)
00430
00431
00432 {
00433 int rpmlead_version;
00434
00435
00436 if (rpmpkg_version < 0) {
00437 rpmpkg_version = rpmExpandNumeric("%{_package_version}");
00438 if (rpmpkg_version < RPMPKGVERSION_MIN)
00439 rpmpkg_version = RPMPKGVERSION_MIN;
00440 if (rpmpkg_version > RPMPKGVERSION_MAX)
00441 rpmpkg_version = RPMPKGVERSION_MAX;
00442 }
00443
00444 rpmlead_version = rpmpkg_version / 10000;
00445
00446 if (rpmlead_version < 3 || rpmlead_version > 4)
00447 rpmlead_version = 3;
00448 return rpmlead_version;
00449 }
00450 #endif
00451
00452 void providePackageNVR(Header h)
00453 {
00454 HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
00455 const char *N, *V, *R;
00456 #ifdef RPM_VENDOR_MANDRIVA
00457 const char *D;
00458 int gotD;
00459 #endif
00460 rpmuint32_t E;
00461 int gotE;
00462 const char *pEVR;
00463 char *p;
00464 rpmuint32_t pFlags = RPMSENSE_EQUAL;
00465 const char ** provides = NULL;
00466 const char ** providesEVR = NULL;
00467 rpmuint32_t * provideFlags = NULL;
00468 int providesCount;
00469 int bingo = 1;
00470 size_t nb;
00471 int xx;
00472 int i;
00473
00474
00475 xx = headerNEVRA(h, &N, NULL, &V, &R, NULL);
00476 if (!(N && V && R))
00477 return;
00478
00479 nb = 21 + strlen(V) + 1 + strlen(R) + 1;
00480 #ifdef RPM_VENDOR_MANDRIVA
00481 he->tag = RPMTAG_DISTEPOCH;
00482 gotD = headerGet(h, he, 0);
00483 D = (he->p.str ? he->p.str : NULL);
00484 nb += (gotD ? strlen(D) + 1 : 0);
00485 #endif
00486 pEVR = p = alloca(nb);
00487 *p = '\0';
00488 he->tag = RPMTAG_EPOCH;
00489 gotE = headerGet(h, he, 0);
00490 E = (he->p.ui32p ? he->p.ui32p[0] : 0);
00491 he->p.ptr = _free(he->p.ptr);
00492 if (gotE) {
00493 sprintf(p, "%d:", E);
00494 p += strlen(p);
00495 }
00496 p = stpcpy( stpcpy( stpcpy(p, V) , "-") , R);
00497 #ifdef RPM_VENDOR_MANDRIVA
00498 if (gotD) {
00499 p = stpcpy( stpcpy( p, ":"), D);
00500 D = _free(D);
00501 }
00502 #endif
00503 V = _free(V);
00504 R = _free(R);
00505
00506
00507
00508
00509
00510 he->tag = RPMTAG_PROVIDENAME;
00511
00512 xx = headerGet(h, he, 0);
00513
00514 provides = he->p.argv;
00515 providesCount = he->c;
00516 if (!xx)
00517 goto exit;
00518
00519
00520
00521
00522 he->tag = RPMTAG_PROVIDEVERSION;
00523
00524 xx = headerGet(h, he, 0);
00525
00526 providesEVR = he->p.argv;
00527 if (!xx) {
00528 for (i = 0; i < providesCount; i++) {
00529
00530 static const char * vdummy = "";
00531 static rpmsenseFlags fdummy = RPMSENSE_ANY;
00532
00533 he->tag = RPMTAG_PROVIDEVERSION;
00534 he->t = RPM_STRING_ARRAY_TYPE;
00535 he->p.argv = &vdummy;
00536 he->c = 1;
00537 he->append = 1;
00538
00539 xx = headerPut(h, he, 0);
00540
00541 he->append = 0;
00542
00543 he->tag = RPMTAG_PROVIDEFLAGS;
00544 he->t = RPM_UINT32_TYPE;
00545 he->p.ui32p = (rpmuint32_t *) &fdummy;
00546 he->c = 1;
00547 he->append = 1;
00548
00549 xx = headerPut(h, he, 0);
00550
00551 he->append = 0;
00552 }
00553 goto exit;
00554 }
00555
00556 he->tag = RPMTAG_PROVIDEFLAGS;
00557
00558 xx = headerGet(h, he, 0);
00559
00560 provideFlags = he->p.ui32p;
00561
00562
00563 if (provides && providesEVR && provideFlags)
00564 for (i = 0; i < providesCount; i++) {
00565 if (!(provides[i] && providesEVR[i]))
00566 continue;
00567 if (!(provideFlags[i] == RPMSENSE_EQUAL &&
00568 !strcmp(N, provides[i]) && !strcmp(pEVR, providesEVR[i])))
00569 continue;
00570 bingo = 0;
00571 break;
00572 }
00573
00574
00575 exit:
00576
00577 provides = _free(provides);
00578 providesEVR = _free(providesEVR);
00579 provideFlags = _free(provideFlags);
00580
00581
00582 if (bingo) {
00583 he->tag = RPMTAG_PROVIDENAME;
00584 he->t = RPM_STRING_ARRAY_TYPE;
00585 he->p.argv = &N;
00586 he->c = 1;
00587 he->append = 1;
00588
00589 xx = headerPut(h, he, 0);
00590
00591 he->append = 0;
00592
00593 he->tag = RPMTAG_PROVIDEVERSION;
00594 he->t = RPM_STRING_ARRAY_TYPE;
00595 he->p.argv = &pEVR;
00596 he->c = 1;
00597 he->append = 1;
00598
00599 xx = headerPut(h, he, 0);
00600
00601 he->append = 0;
00602
00603 he->tag = RPMTAG_PROVIDEFLAGS;
00604 he->t = RPM_UINT32_TYPE;
00605 he->p.ui32p = &pFlags;
00606 he->c = 1;
00607 he->append = 1;
00608
00609 xx = headerPut(h, he, 0);
00610
00611 he->append = 0;
00612 }
00613 N = _free(N);
00614 }
00615
00616 rpmRC writeRPM(Header *hdrp, unsigned char ** pkgidp, const char *fileName,
00617 CSA_t csa, char *passPhrase, const char **cookie)
00618 {
00619 HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
00620 FD_t fd = NULL;
00621 FD_t ifd = NULL;
00622 rpmuint32_t sigtag;
00623 const char * sigtarget;
00624 const char * rpmio_flags = NULL;
00625 const char * payload_format = NULL;
00626 const char * SHA1 = NULL;
00627 const char * msg = NULL;
00628 char *s;
00629 char buf[BUFSIZ];
00630 Header h;
00631 Header sigh = NULL;
00632 int addsig = 0;
00633 int isSource;
00634 rpmRC rc = RPMRC_OK;
00635 size_t nbr;
00636 size_t nbw;
00637 int xx;
00638
00639
00640 h = headerLink(*hdrp);
00641 (void)headerFree(*hdrp);
00642 *hdrp = NULL;
00643
00644 if (pkgidp)
00645 *pkgidp = NULL;
00646
00647
00648 isSource =
00649 (headerIsEntry(h, RPMTAG_SOURCERPM) == 0 &&
00650 headerIsEntry(h, RPMTAG_ARCH) != 0);
00651 if (isSource) {
00652 payload_format = rpmExpand("%{?_source_payload_format}", NULL);
00653 rpmio_flags = rpmExpand("%{?_source_payload}", NULL);
00654 } else {
00655 payload_format = rpmExpand("%{?_binary_payload_format}", NULL);
00656 rpmio_flags = rpmExpand("%{?_binary_payload}", NULL);
00657 }
00658
00659 if (!(payload_format && *payload_format)) {
00660 payload_format = _free(payload_format);
00661 payload_format = xstrdup("cpio");
00662 }
00663 if (!(rpmio_flags && *rpmio_flags)) {
00664 rpmio_flags = _free(rpmio_flags);
00665 rpmio_flags = xstrdup("w9.gzdio");
00666 }
00667 s = strchr(rpmio_flags, '.');
00668 if (s) {
00669
00670 if (payload_format) {
00671 if (!strcmp(payload_format, "tar")
00672 || !strcmp(payload_format, "ustar")) {
00673
00674
00675 (void) rpmlibNeedsFeature(h, "PayloadIsUstar", "4.4.4-1");
00676 }
00677 #if defined(SUPPORT_AR_PAYLOADS)
00678 if (!strcmp(payload_format, "ar")) {
00679
00680
00681 (void) rpmlibNeedsFeature(h, "PayloadIsAr", "5.1-1");
00682 }
00683 #endif
00684
00685 he->tag = RPMTAG_PAYLOADFORMAT;
00686 he->t = RPM_STRING_TYPE;
00687 he->p.str = payload_format;
00688 he->c = 1;
00689 xx = headerPut(h, he, 0);
00690 }
00691
00692
00693 if (s[1] == 'g' && s[2] == 'z') {
00694 he->tag = RPMTAG_PAYLOADCOMPRESSOR;
00695 he->t = RPM_STRING_TYPE;
00696 he->p.str = xstrdup("gzip");
00697 he->c = 1;
00698 xx = headerPut(h, he, 0);
00699 he->p.ptr = _free(he->p.ptr);
00700 } else if (s[1] == 'b' && s[2] == 'z') {
00701 he->tag = RPMTAG_PAYLOADCOMPRESSOR;
00702 he->t = RPM_STRING_TYPE;
00703 he->p.str = xstrdup("bzip2");
00704 he->c = 1;
00705 xx = headerPut(h, he, 0);
00706 he->p.ptr = _free(he->p.ptr);
00707 } else if (s[1] == 'l' && s[2] == 'z') {
00708 he->tag = RPMTAG_PAYLOADCOMPRESSOR;
00709 he->t = RPM_STRING_TYPE;
00710 he->p.str = xstrdup("lzma");
00711 he->c = 1;
00712 xx = headerPut(h, he, 0);
00713 he->p.ptr = _free(he->p.ptr);
00714 (void) rpmlibNeedsFeature(h, "PayloadIsLzma", "4.4.6-1");
00715 } else if (s[1] == 'x' && s[2] == 'z') {
00716 he->tag = RPMTAG_PAYLOADCOMPRESSOR;
00717 he->t = RPM_STRING_TYPE;
00718 he->p.str = xstrdup("xz");
00719 he->c = 1;
00720 xx = headerPut(h, he, 0);
00721 he->p.ptr = _free(he->p.ptr);
00722 (void) rpmlibNeedsFeature(h, "PayloadIsXz", "5.2-1");
00723 }
00724 strcpy(buf, rpmio_flags);
00725 buf[s - rpmio_flags] = '\0';
00726
00727 he->tag = RPMTAG_PAYLOADFLAGS;
00728 he->t = RPM_STRING_TYPE;
00729 he->p.str = buf+1;
00730 he->c = 1;
00731 xx = headerPut(h, he, 0);
00732 }
00733
00734
00735 if (cookie) {
00736 sprintf(buf, "%s %u", buildHost(), (unsigned) (*getBuildTime()));
00737 *cookie = xstrdup(buf);
00738 he->tag = RPMTAG_COOKIE;
00739 he->t = RPM_STRING_TYPE;
00740 he->p.str = *cookie;
00741 he->c = 1;
00742 xx = headerPut(h, he, 0);
00743 }
00744
00745
00746 h = headerReload(h, RPMTAG_HEADERIMMUTABLE);
00747 if (h == NULL) {
00748 rpmlog(RPMLOG_ERR, _("Unable to create immutable header region.\n"));
00749 rc = RPMRC_FAIL;
00750 goto exit;
00751 }
00752
00753 *hdrp = headerLink(h);
00754
00755
00756
00757
00758
00759 sigtarget = NULL;
00760 if (rpmTempFile(NULL, &sigtarget, &fd)) {
00761 rpmlog(RPMLOG_ERR, _("Unable to open temp file.\n"));
00762 rc = RPMRC_FAIL;
00763 goto exit;
00764 }
00765
00766
00767 fdInitDigest(fd, PGPHASHALGO_SHA1, 0);
00768 { const char item[] = "Header";
00769 msg = NULL;
00770 rc = rpmpkgWrite(item, fd, h, &msg);
00771 if (rc != RPMRC_OK) {
00772 rpmlog(RPMLOG_ERR, "%s: %s: %s\n", sigtarget, item,
00773 (msg && *msg ? msg : "write failed\n"));
00774 msg = _free(msg);
00775 rc = RPMRC_FAIL;
00776 goto exit;
00777 }
00778 msg = _free(msg);
00779 (void) Fflush(fd);
00780 }
00781 fdFiniDigest(fd, PGPHASHALGO_SHA1, &SHA1, NULL, 1);
00782
00783
00784 if (csa->cpioList != NULL)
00785 rc = cpio_doio(fd, h, csa, payload_format, rpmio_flags);
00786 else if (Fileno(csa->cpioFdIn) >= 0)
00787 rc = cpio_copy(fd, csa);
00788 else
00789 assert(0);
00790
00791 rpmio_flags = _free(rpmio_flags);
00792 payload_format = _free(payload_format);
00793 if (rc != RPMRC_OK)
00794 goto exit;
00795
00796 (void) Fclose(fd);
00797 fd = NULL;
00798 (void) Unlink(fileName);
00799
00800
00801 (void) fflush(stdout);
00802 sigh = headerNew();
00803 (void) rpmAddSignature(sigh, sigtarget, RPMSIGTAG_SIZE, passPhrase);
00804 (void) rpmAddSignature(sigh, sigtarget, RPMSIGTAG_MD5, passPhrase);
00805
00806 sigtag = RPMSIGTAG_GPG;
00807 addsig = (passPhrase && passPhrase[0]);
00808
00809 if (addsig) {
00810 rpmlog(RPMLOG_NOTICE, _("Generating signature: %d\n"), sigtag);
00811 (void) rpmAddSignature(sigh, sigtarget, sigtag, passPhrase);
00812 }
00813
00814 if (SHA1) {
00815 he->tag = (rpmTag) RPMSIGTAG_SHA1;
00816 he->t = RPM_STRING_TYPE;
00817 he->p.str = SHA1;
00818 he->c = 1;
00819 xx = headerPut(sigh, he, 0);
00820 SHA1 = _free(SHA1);
00821 }
00822
00823 { rpmuint32_t payloadSize = csa->cpioArchiveSize;
00824 he->tag = (rpmTag) RPMSIGTAG_PAYLOADSIZE;
00825 he->t = RPM_UINT32_TYPE;
00826 he->p.ui32p = &payloadSize;
00827 he->c = 1;
00828 xx = headerPut(sigh, he, 0);
00829 }
00830
00831
00832 sigh = headerReload(sigh, RPMTAG_HEADERSIGNATURES);
00833 if (sigh == NULL) {
00834 rpmlog(RPMLOG_ERR, _("Unable to reload signature header.\n"));
00835 rc = RPMRC_FAIL;
00836 goto exit;
00837 }
00838
00839
00840 { size_t slen = 0;
00841 void * uh = headerUnload(sigh, &slen);
00842 static const size_t align = 1024;
00843 size_t nb = align - 96 - 16 - 16;
00844 rpmuint8_t * b;
00845
00846 uh = _free(uh);
00847 assert(slen < nb);
00848 nb -= slen;
00849 b = memset(alloca(nb), 0, nb);
00850 he->tag = (rpmTag) RPMSIGTAG_PADDING;
00851 he->t = RPM_BIN_TYPE;
00852 he->p.ui8p = b;
00853 he->c = nb;
00854 xx = headerPut(sigh, he, 0);
00855 sigh = headerReload(sigh, RPMTAG_HEADERSIGNATURES);
00856 assert(sigh != NULL);
00857 }
00858
00859
00860 fd = Fopen(fileName, "w.fdio");
00861 if (fd == NULL || Ferror(fd)) {
00862 rpmlog(RPMLOG_ERR, _("Could not open %s: %s\n"),
00863 fileName, Fstrerror(fd));
00864 rc = RPMRC_FAIL;
00865 goto exit;
00866 }
00867
00868
00869 { const char item[] = "Lead";
00870 size_t nl = rpmpkgSizeof(item, NULL);
00871
00872 msg = NULL;
00873 if (nl == 0)
00874 rc = RPMRC_FAIL;
00875 else {
00876 void * l = memset(alloca(nl), 0, nl);
00877 const char *N, *V, *R;
00878 (void) headerNEVRA(h, &N, NULL, &V, &R, NULL);
00879 sprintf(buf, "%s-%s-%s", N, V, R);
00880 N = _free(N);
00881 V = _free(V);
00882 R = _free(R);
00883 msg = buf;
00884 rc = rpmpkgWrite(item, fd, l, &msg);
00885 }
00886
00887 if (rc != RPMRC_OK) {
00888 rpmlog(RPMLOG_ERR, _("Unable to write package: %s\n"),
00889 Fstrerror(fd));
00890 rc = RPMRC_FAIL;
00891 goto exit;
00892 }
00893 }
00894
00895
00896 { const char item[] = "Signature";
00897
00898 msg = NULL;
00899 rc = rpmpkgWrite(item, fd, sigh, &msg);
00900 if (rc != RPMRC_OK) {
00901 rpmlog(RPMLOG_ERR, "%s: %s: %s\n", fileName, item,
00902 (msg && *msg ? msg : "write failed\n"));
00903 msg = _free(msg);
00904 rc = RPMRC_FAIL;
00905 goto exit;
00906 }
00907 msg = _free(msg);
00908 }
00909
00910
00911 ifd = Fopen(sigtarget, "r.fdio");
00912 if (ifd == NULL || Ferror(ifd)) {
00913 rpmlog(RPMLOG_ERR, _("Unable to open sigtarget %s: %s\n"),
00914 sigtarget, Fstrerror(ifd));
00915 rc = RPMRC_FAIL;
00916 goto exit;
00917 }
00918
00919
00920 { const char item[] = "Header";
00921 Header nh = NULL;
00922
00923 msg = NULL;
00924 rc = rpmpkgRead(item, ifd, &nh, &msg);
00925 if (rc != RPMRC_OK) {
00926 rpmlog(RPMLOG_ERR, "%s: %s: %s\n", sigtarget, item,
00927 (msg && *msg ? msg : "read failed\n"));
00928 msg = _free(msg);
00929 rc = RPMRC_FAIL;
00930 goto exit;
00931 }
00932 msg = _free(msg);
00933
00934 #ifdef NOTYET
00935 (void) headerMergeLegacySigs(nh, sigh);
00936 #endif
00937
00938 msg = NULL;
00939 rc = rpmpkgWrite(item, fd, nh, &msg);
00940 (void)headerFree(nh);
00941 nh = NULL;
00942 if (rc != RPMRC_OK) {
00943 rpmlog(RPMLOG_ERR, "%s: %s: %s\n", fileName, item,
00944 (msg && *msg ? msg : "write failed\n"));
00945 msg = _free(msg);
00946 rc = RPMRC_FAIL;
00947 goto exit;
00948 }
00949 msg = _free(msg);
00950 }
00951
00952
00953 while ((nbr = Fread(buf, sizeof(buf[0]), sizeof(buf), ifd)) > 0) {
00954 if (Ferror(ifd)) {
00955 rpmlog(RPMLOG_ERR, _("Unable to read payload from %s: %s\n"),
00956 sigtarget, Fstrerror(ifd));
00957 rc = RPMRC_FAIL;
00958 goto exit;
00959 }
00960 nbw = (int)Fwrite(buf, sizeof(buf[0]), nbr, fd);
00961 if (nbr != nbw || Ferror(fd)) {
00962 rpmlog(RPMLOG_ERR, _("Unable to write payload to %s: %s\n"),
00963 fileName, Fstrerror(fd));
00964 rc = RPMRC_FAIL;
00965 goto exit;
00966 }
00967 }
00968 rc = RPMRC_OK;
00969
00970 exit:
00971 SHA1 = _free(SHA1);
00972 (void)headerFree(h);
00973 h = NULL;
00974
00975
00976 if (sigh != NULL && pkgidp != NULL) {
00977 he->tag = (rpmTag) RPMSIGTAG_MD5;
00978 xx = headerGet(sigh, he, 0);
00979 if (he->t == RPM_BIN_TYPE && he->p.ptr != NULL && he->c == 16)
00980 *pkgidp = he->p.ui8p;
00981 }
00982
00983 (void)headerFree(sigh);
00984 sigh = NULL;
00985 if (ifd) {
00986 (void) Fclose(ifd);
00987 ifd = NULL;
00988 }
00989 if (fd) {
00990 (void) Fclose(fd);
00991 fd = NULL;
00992 }
00993 if (sigtarget) {
00994 (void) Unlink(sigtarget);
00995 sigtarget = _free(sigtarget);
00996 }
00997
00998 if (rc == RPMRC_OK)
00999 rpmlog(RPMLOG_NOTICE, _("Wrote: %s\n"), fileName);
01000 else
01001 (void) Unlink(fileName);
01002
01003 return rc;
01004 }
01005
01006 static int rpmlibMarkers(Header h)
01007
01008 {
01009 HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
01010 rpmuint32_t val;
01011 int xx;
01012
01013 he->tag = RPMTAG_RPMVERSION;
01014 he->t = RPM_STRING_TYPE;
01015 he->p.str = xstrdup(VERSION);
01016 he->c = 1;
01017 xx = headerPut(h, he, 0);
01018 he->p.ptr = _free(he->p.ptr);
01019
01020 if (!(_rpmbuildFlags & 4)) {
01021 val = (rpmuint32_t)rpmlibTimestamp();
01022 he->tag = RPMTAG_RPMLIBTIMESTAMP;
01023 he->t = RPM_UINT32_TYPE;
01024 he->p.ui32p = &val;
01025 he->c = 1;
01026 xx = headerPut(h, he, 0);
01027
01028 val = (rpmuint32_t)rpmlibVendor();
01029 he->tag = RPMTAG_RPMLIBVENDOR;
01030 he->t = RPM_UINT32_TYPE;
01031 he->p.ui32p = &val;
01032 he->c = 1;
01033 xx = headerPut(h, he, 0);
01034
01035 val = (rpmuint32_t)rpmlibVersion();
01036 he->tag = RPMTAG_RPMLIBVERSION;
01037 he->t = RPM_UINT32_TYPE;
01038 he->p.ui32p = &val;
01039 he->c = 1;
01040 xx = headerPut(h, he, 0);
01041 }
01042
01043 he->tag = RPMTAG_BUILDHOST;
01044 he->t = RPM_STRING_TYPE;
01045 he->p.str = buildHost();
01046 he->c = 1;
01047 xx = headerPut(h, he, 0);
01048
01049 he->tag = RPMTAG_BUILDTIME;
01050 he->t = RPM_UINT32_TYPE;
01051 he->p.ui32p = getBuildTime();
01052 he->c = 1;
01053 xx = headerPut(h, he, 0);
01054
01055 return 0;
01056 }
01057
01058
01059 static rpmTag copyTags[] = {
01060 RPMTAG_CHANGELOGTIME,
01061 RPMTAG_CHANGELOGNAME,
01062 RPMTAG_CHANGELOGTEXT,
01063 0
01064 };
01065
01066 rpmRC packageBinaries(Spec spec)
01067 {
01068 HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
01069 struct cpioSourceArchive_s csabuf;
01070 CSA_t csa = &csabuf;
01071 const char *errorString;
01072 Package pkg;
01073 rpmRC rc;
01074 int xx;
01075
01076 for (pkg = spec->packages; pkg != NULL; pkg = pkg->next) {
01077 const char *fn;
01078
01079 if (pkg->fileList == NULL)
01080 continue;
01081
01082 if (spec->cookie) {
01083 he->tag = RPMTAG_COOKIE;
01084 he->t = RPM_STRING_TYPE;
01085 he->p.str = spec->cookie;
01086 he->c = 1;
01087 xx = headerPut(pkg->header, he, 0);
01088 }
01089
01090
01091 headerCopyTags(spec->packages->header, pkg->header, copyTags);
01092
01093
01094 (void) rpmlibMarkers(pkg->header);
01095
01096 he->tag = RPMTAG_OPTFLAGS;
01097 he->t = RPM_STRING_TYPE;
01098 he->p.str = rpmExpand("%{optflags}", NULL);
01099 he->c = 1;
01100 xx = headerPut(pkg->header, he, 0);
01101 he->p.ptr = _free(he->p.ptr);
01102
01103 if (!(_rpmbuildFlags & 4)) {
01104 if (spec->sourcePkgId != NULL) {
01105 he->tag = RPMTAG_SOURCEPKGID;
01106 he->t = RPM_BIN_TYPE;
01107 he->p.ptr = spec->sourcePkgId;
01108 he->c = 16;
01109 xx = headerPut(pkg->header, he, 0);
01110 }
01111 }
01112
01113 { const char *binFormat = rpmGetPath("%{_rpmfilename}", NULL);
01114 char *binRpm, *binDir;
01115 binRpm = headerSprintf(pkg->header, binFormat, NULL,
01116 rpmHeaderFormats, &errorString);
01117 binFormat = _free(binFormat);
01118 if (binRpm == NULL) {
01119 he->tag = RPMTAG_NVRA;
01120 xx = headerGet(pkg->header, he, 0);
01121 rpmlog(RPMLOG_ERR, _("Could not generate output "
01122 "filename for package %s: %s\n"), he->p.str, errorString);
01123 he->p.ptr = _free(he->p.ptr);
01124
01125 return RPMRC_FAIL;
01126
01127 }
01128 fn = rpmGetPath("%{_rpmdir}/", binRpm, NULL);
01129 if ((binDir = strchr(binRpm, '/')) != NULL) {
01130 struct stat st;
01131 const char *dn;
01132 *binDir = '\0';
01133 dn = rpmGetPath("%{_rpmdir}/", binRpm, NULL);
01134 if (Stat(dn, &st) < 0) {
01135 switch(errno) {
01136 case ENOENT:
01137 if (rpmioMkpath(dn, 0755, -1, -1) == 0)
01138 break;
01139
01140 default:
01141 rpmlog(RPMLOG_ERR,_("cannot create %s: %s\n"),
01142 dn, strerror(errno));
01143 break;
01144 }
01145 }
01146 dn = _free(dn);
01147 }
01148 binRpm = _free(binRpm);
01149 }
01150
01151 memset(csa, 0, sizeof(*csa));
01152 csa->cpioArchiveSize = 0;
01153
01154
01155 csa->cpioFdIn = fdNew("init (packageBinaries)");
01156
01157
01158 csa->cpioList = rpmfiLink(pkg->cpioList, "packageBinaries");
01159
01160 assert(csa->cpioList != NULL);
01161
01162 rc = writeRPM(&pkg->header, NULL, fn,
01163 csa, spec->passPhrase, NULL);
01164
01165
01166 csa->cpioList->te = _free(csa->cpioList->te);
01167
01168 csa->cpioList = rpmfiFree(csa->cpioList);
01169
01170 csa->cpioFdIn = fdFree(csa->cpioFdIn, "init (packageBinaries)");
01171
01172
01173 fn = _free(fn);
01174 if (rc)
01175 return rc;
01176 }
01177
01178 return RPMRC_OK;
01179 }
01180
01181 rpmRC packageSources(Spec spec)
01182 {
01183 HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
01184 struct cpioSourceArchive_s csabuf;
01185 CSA_t csa = &csabuf;
01186 rpmRC rc;
01187 int xx;
01188 #if defined(RPM_VENDOR_OPENPKG) || defined(RPM_VENDOR_FEDORA) || defined(RPM_VENDOR_MANDRIVA) || defined(RPM_VENDOR_ARK)
01189 rpmuint32_t val;
01190 #endif
01191
01192
01193 (void) rpmlibMarkers(spec->sourceHeader);
01194
01195 #if defined(RPM_VENDOR_OPENPKG) || defined(RPM_VENDOR_FEDORA) || defined(RPM_VENDOR_MANDRIVA) || defined(RPM_VENDOR_ARK)
01196
01197 he->tag = RPMTAG_SOURCEPACKAGE;
01198 he->t = RPM_UINT32_TYPE;
01199 val = 1;
01200 he->p.ui32p = &val;
01201 he->c = 1;
01202 xx = headerPut(spec->sourceHeader, he, 0);
01203 #endif
01204
01205
01206 { const char ** av = NULL;
01207 (void)rpmGetMacroEntries(NULL, NULL, 1, &av);
01208 if (av != NULL && av[0] != NULL) {
01209 he->tag = RPMTAG_BUILDMACROS;
01210 he->t = RPM_STRING_ARRAY_TYPE;
01211 he->p.argv = av;
01212 he->c = argvCount(av);
01213 xx = headerPut(spec->sourceHeader, he, 0);
01214 }
01215
01216 av = argvFree(av);
01217
01218 }
01219
01220 spec->cookie = _free(spec->cookie);
01221
01222
01223 { const char *srcrpmdir = rpmGetPath("%{_srcrpmdir}/", NULL);
01224 const char *fn = rpmGetPath("%{_srcrpmdir}/", spec->sourceRpmName,NULL);
01225
01226 rc = rpmioMkpath(srcrpmdir, 0755, -1, -1);
01227
01228 memset(csa, 0, sizeof(*csa));
01229 csa->cpioArchiveSize = 0;
01230
01231
01232 csa->cpioFdIn = fdNew("init (packageSources)");
01233
01234
01235 csa->cpioList = rpmfiLink(spec->sourceCpioList, "packageSources");
01236
01237 assert(csa->cpioList != NULL);
01238
01239 spec->sourcePkgId = NULL;
01240 rc = writeRPM(&spec->sourceHeader, &spec->sourcePkgId, fn,
01241 csa, spec->passPhrase, &(spec->cookie));
01242
01243
01244 csa->cpioList->te = _free(csa->cpioList->te);
01245
01246 csa->cpioList = rpmfiFree(csa->cpioList);
01247
01248 csa->cpioFdIn = fdFree(csa->cpioFdIn, "init (packageSources)");
01249
01250
01251 srcrpmdir = _free(srcrpmdir);
01252 fn = _free(fn);
01253 }
01254
01255 return (rc ? RPMRC_FAIL : RPMRC_OK);
01256 }