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
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
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
00215
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
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);
00251
00252
00253 spec = newSpec();
00254 spec->packages = newPackage(spec);
00255
00256
00257 if (spec->packages->header != NULL) {
00258 headerFree(spec->packages->header);
00259 spec->packages->header = NULL;
00260 }
00261
00262
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 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
00307 headerAddEntry(h, RPMTAG_ARCHIVESIZE, RPM_INT32_TYPE,
00308 &csa->cpioArchiveSize, 1);
00309 }
00310
00311
00312 if (_noDirTokens)
00313 expandFilelist(h);
00314 else {
00315 compressFilelist(h);
00316
00317 if (type == RPMLEAD_BINARY)
00318 rpmlibNeedsFeature(h, "CompressedFileNames", "3.0.4-1");
00319 }
00320
00321
00322 if (type == RPMLEAD_BINARY)
00323 providePackageNVR(h);
00324
00325
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
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
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
00363 *hdrp = h = headerReload(h, RPMTAG_HEADERIMMUTABLE);
00364
00365
00366
00367
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 {
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
00393
00394
00395
00396
00397
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
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
00428 sig = headerReload(sig, RPMTAG_HEADERSIGNATURES);
00429
00430
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
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
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;
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
00478 rc = rpmWriteSignature(fd, sig);
00479 if (rc)
00480 goto exit;
00481
00482
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
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
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
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
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
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
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 }