rpm  5.4.14
pack.c
Go to the documentation of this file.
1 
6 #include "system.h"
7 
8 #include <rpmio_internal.h> /* XXX fdGetFp, fdInitDigest, fdFiniDigest */
9 #include <rpmcb.h>
10 #include <argv.h>
11 
12 #include <rpmtypes.h>
13 #include <rpmtag.h>
14 
15 #include <pkgio.h>
16 #include "signature.h" /* XXX rpmTempFile */
17 
18 #define _RPMFI_INTERNAL /* XXX fi->fsm */
19 #define _RPMEVR_INTERNAL /* XXX RPMSENSE_ANY */
20 #define _RPMTAG_INTERNAL
21 #include <rpmbuild.h>
22 
23 #include "rpmfi.h"
24 #include "fsm.h"
25 
26 #include <rpmversion.h>
27 #include "buildio.h"
28 
29 #include "debug.h"
30 
31 /*@access rpmts @*/
32 /*@access rpmfi @*/ /* compared with NULL */
33 /*@access Header @*/ /* compared with NULL */
34 /*@access FD_t @*/ /* compared with NULL */
35 /*@access CSA_t @*/
36 
40 static rpmRC cpio_doio(FD_t fdo, /*@unused@*/ Header h, CSA_t csa,
41  const char * payload_format, const char * fmodeMacro)
42  /*@globals rpmGlobalMacroContext, h_errno, fileSystem, internalState @*/
43  /*@modifies fdo, csa, rpmGlobalMacroContext,
44  fileSystem, internalState @*/
45 {
46  rpmts ts = rpmtsCreate();
47  rpmfi fi = csa->fi;
48  const char *failedFile = NULL;
49  FD_t cfd;
50  rpmRC rc = RPMRC_OK;
51  int xx;
52 
53  { const char *fmode = rpmExpand(fmodeMacro, NULL);
54  if (!(fmode && fmode[0] == 'w')) {
55  fmode = _free(fmode);
56  fmode = xstrdup("w9.gzdio");
57  }
58  /*@-nullpass@*/
59  (void) Fflush(fdo);
60  cfd = Fdopen(fdDup(Fileno(fdo)), fmode);
61  /*@=nullpass@*/
62  fmode = _free(fmode);
63  }
64  if (cfd == NULL)
65  return RPMRC_FAIL;
66 
67  xx = fsmSetup(fi->fsm, IOSM_PKGBUILD, payload_format, ts, fi, cfd,
68  &csa->cpioArchiveSize, &failedFile);
69  if (xx)
70  rc = RPMRC_FAIL;
71  (void) Fclose(cfd);
72  xx = fsmTeardown(fi->fsm);
73  if (rc == RPMRC_OK && xx) rc = RPMRC_FAIL;
74 
75  if (rc) {
76  const char * msg = iosmStrerror(rc);
77  if (failedFile)
78  rpmlog(RPMLOG_ERR, _("create archive failed on file %s: %s\n"),
79  failedFile, msg);
80  else
81  rpmlog(RPMLOG_ERR, _("create archive failed: %s\n"), msg);
82  msg = _free(msg);
83  rc = RPMRC_FAIL;
84  }
85 
86  failedFile = _free(failedFile);
87  (void)rpmtsFree(ts);
88  ts = NULL;
89 
90  return rc;
91 }
92 
95 static rpmRC cpio_copy(FD_t fdo, CSA_t csa)
96  /*@globals fileSystem, internalState @*/
97  /*@modifies fdo, csa, fileSystem, internalState @*/
98 {
99  char buf[BUFSIZ];
100  size_t nb;
101 
102  while((nb = Fread(buf, sizeof(buf[0]), sizeof(buf), csa->cpioFdIn)) > 0) {
103  if (Fwrite(buf, sizeof(buf[0]), nb, fdo) != nb) {
104  rpmlog(RPMLOG_ERR, _("cpio_copy write failed: %s\n"),
105  Fstrerror(fdo));
106  return RPMRC_FAIL;
107  }
108  csa->cpioArchiveSize += nb;
109  }
110  if (Ferror(csa->cpioFdIn)) {
111  rpmlog(RPMLOG_ERR, _("cpio_copy read failed: %s\n"),
112  Fstrerror(csa->cpioFdIn));
113  return RPMRC_FAIL;
114  }
115  return RPMRC_OK;
116 }
117 
120 static /*@only@*/ /*@null@*/ rpmiob addFileToTagAux(Spec spec,
121  const char * file, /*@only@*/ rpmiob iob)
122  /*@globals rpmGlobalMacroContext, h_errno, fileSystem, internalState @*/
123  /*@modifies rpmGlobalMacroContext, fileSystem, internalState @*/
124 {
125  char buf[BUFSIZ];
126  const char * fn = buf;
127  FILE * f;
128  FD_t fd;
129 
130  fn = rpmGetPath("%{_builddir}/%{?buildsubdir:%{buildsubdir}/}", file, NULL);
131 
132  fd = Fopen(fn, "r.fdio");
133  if (fn != buf) fn = _free(fn);
134  if (fd == NULL || Ferror(fd)) {
135  iob = rpmiobFree(iob);
136  return NULL;
137  }
138  /*@-type@*/ /* FIX: cast? */
139  if ((f = fdGetFp(fd)) != NULL)
140  /*@=type@*/
141  while (fgets(buf, (int)sizeof(buf), f)) {
142  /* XXX display fn in error msg */
143  if (expandMacros(spec, spec->macros, buf, sizeof(buf))) {
144  rpmlog(RPMLOG_ERR, _("line: %s\n"), buf);
145  iob = rpmiobFree(iob);
146  break;
147  }
148  iob = rpmiobAppend(iob, buf, 0);
149  }
150  (void) Fclose(fd);
151 
152  return iob;
153 }
154 
157 static int addFileToTag(Spec spec, const char * file, Header h, rpmTag tag)
158  /*@globals rpmGlobalMacroContext, h_errno, fileSystem, internalState @*/
159  /*@modifies h, rpmGlobalMacroContext, fileSystem, internalState @*/
160 {
161  HE_t he = (HE_t) memset(alloca(sizeof(*he)), 0, sizeof(*he));
162  rpmiob iob = rpmiobNew(0);
163  int xx;
164 
165  he->tag = tag;
166  xx = headerGet(h, he, 0);
167  if (xx) {
168  iob = rpmiobAppend(iob, he->p.str, 1);
169  xx = headerDel(h, he, 0);
170  }
171  he->p.ptr = _free(he->p.ptr);
172 
173  if ((iob = addFileToTagAux(spec, file, iob)) == NULL)
174  return 1;
175 
176  he->tag = tag;
177  he->t = RPM_STRING_TYPE;
178  he->p.str = rpmiobStr(iob);
179  he->c = 1;
180  xx = headerPut(h, he, 0);
181 
182  iob = rpmiobFree(iob);
183  return 0;
184 }
185 
188 static int addFileToArrayTag(Spec spec, const char *file, Header h, rpmTag tag)
189  /*@globals rpmGlobalMacroContext, h_errno, fileSystem, internalState @*/
190  /*@modifies h, rpmGlobalMacroContext, fileSystem, internalState @*/
191 {
192  HE_t he = (HE_t) memset(alloca(sizeof(*he)), 0, sizeof(*he));
193  rpmiob iob = rpmiobNew(0);
194  const char *s;
195  int xx;
196 
197  if ((iob = addFileToTagAux(spec, file, iob)) == NULL)
198  return 1;
199 
200  s = rpmiobStr(iob);
201 
202  he->tag = tag;
203  he->t = RPM_STRING_ARRAY_TYPE;
204  he->p.argv = &s;
205  he->c = 1;
206  he->append = 1;
207  xx = headerPut(h, he, 0);
208  he->append = 0;
209 
210  iob = rpmiobFree(iob);
211  return 0;
212 }
213 
215  /*@globals rpmGlobalMacroContext, h_errno, fileSystem, internalState @*/
216  /*@modifies pkg->header, rpmGlobalMacroContext,
217  fileSystem, internalState @*/
218 {
219  HE_t he = (HE_t) memset(alloca(sizeof(*he)), 0, sizeof(*he));
220  struct TriggerFileEntry *p;
221  int xx;
222 
223  if (pkg->preInFile) {
224  if (addFileToTag(spec, pkg->preInFile, pkg->header, RPMTAG_PREIN)) {
226  _("Could not open PreIn file: %s\n"), pkg->preInFile);
227  return RPMRC_FAIL;
228  }
229  }
230  if (pkg->preUnFile) {
231  if (addFileToTag(spec, pkg->preUnFile, pkg->header, RPMTAG_PREUN)) {
233  _("Could not open PreUn file: %s\n"), pkg->preUnFile);
234  return RPMRC_FAIL;
235  }
236  }
237  if (pkg->preTransFile) {
238  if (addFileToTag(spec, pkg->preTransFile, pkg->header, RPMTAG_PRETRANS)) {
240  _("Could not open PreTrans file: %s\n"), pkg->preTransFile);
241  return RPMRC_FAIL;
242  }
243  }
244  if (pkg->postInFile) {
245  if (addFileToTag(spec, pkg->postInFile, pkg->header, RPMTAG_POSTIN)) {
247  _("Could not open PostIn file: %s\n"), pkg->postInFile);
248  return RPMRC_FAIL;
249  }
250  }
251  if (pkg->postUnFile) {
252  if (addFileToTag(spec, pkg->postUnFile, pkg->header, RPMTAG_POSTUN)) {
254  _("Could not open PostUn file: %s\n"), pkg->postUnFile);
255  return RPMRC_FAIL;
256  }
257  }
258  if (pkg->postTransFile) {
259  if (addFileToTag(spec, pkg->postTransFile, pkg->header, RPMTAG_POSTTRANS)) {
261  _("Could not open PostTrans file: %s\n"), pkg->postTransFile);
262  return RPMRC_FAIL;
263  }
264  }
265  if (pkg->verifyFile) {
266  if (addFileToTag(spec, pkg->verifyFile, pkg->header,
269  _("Could not open VerifyScript file: %s\n"), pkg->verifyFile);
270  return RPMRC_FAIL;
271  }
272  }
273 
274  if (pkg->sanityCheckFile) {
275  if (addFileToTag(spec, pkg->sanityCheckFile, pkg->header, RPMTAG_SANITYCHECK)) {
276  rpmlog(RPMLOG_ERR, _("Could not open Test file: %s\n"), pkg->sanityCheckFile);
277  return RPMRC_FAIL;
278  }
279  }
280 
281  for (p = pkg->triggerFiles; p != NULL; p = p->next) {
283  he->t = RPM_STRING_ARRAY_TYPE;
284  he->p.argv = (const char **)&p->prog; /* XXX NOCAST */
285  he->c = 1;
286  he->append = 1;
287  xx = headerPut(pkg->header, he, 0);
288  he->append = 0;
289  if (p->script) {
291  he->t = RPM_STRING_ARRAY_TYPE;
292  he->p.argv = (const char **)&p->script; /* XXX NOCAST */
293  he->c = 1;
294  he->append = 1;
295  xx = headerPut(pkg->header, he, 0);
296  he->append = 0;
297  } else if (p->fileName) {
298  if (addFileToArrayTag(spec, p->fileName, pkg->header,
301  _("Could not open Trigger script file: %s\n"),
302  p->fileName);
303  return RPMRC_FAIL;
304  }
305  } else {
306  /*@observer@*/
307  static const char *bull = "";
309  he->t = RPM_STRING_ARRAY_TYPE;
310  he->p.argv = &bull;
311  he->c = 1;
312  he->append = 1;
313  xx = headerPut(pkg->header, he, 0);
314  he->append = 0;
315  }
316  }
317 
318  return RPMRC_OK;
319 }
320 
321 #if defined(DEAD)
322 int readRPM(const char *fileName, Spec *specp, void * l,
323  Header *sigs, CSA_t csa)
324 {
325  const char * msg = "";
326  FD_t fdi;
327  Spec spec;
328  rpmRC rc;
329 
330  fdi = (fileName != NULL)
331  ? Fopen(fileName, "r.fdio")
332  : fdDup(STDIN_FILENO);
333 
334  if (fdi == NULL || Ferror(fdi)) {
335  rpmlog(RPMLOG_ERR, _("readRPM: open %s: %s\n"),
336  (fileName ? fileName : "<stdin>"),
337  Fstrerror(fdi));
338  if (fdi) (void) Fclose(fdi);
339  return RPMRC_FAIL;
340  }
341 
342  { const char item[] = "Lead";
343  size_t nl = rpmpkgSizeof(item, NULL);
344 
345  if (nl == 0) {
346  rc = RPMRC_FAIL;
347  msg = xstrdup("item size is zero");
348  } else {
349  l = xcalloc(1, nl); /* XXX memory leak */
350  msg = NULL;
351  rc = rpmpkgRead(item, fdi, l, &msg);
352  }
353  }
354 
355  if (rc != RPMRC_OK) {
356  rpmlog(RPMLOG_ERR, _("readRPM: read %s: %s\n"),
357  (fileName ? fileName : "<stdin>"), msg);
358  msg = _free(msg);
359  return RPMRC_FAIL;
360  }
361  msg = _free(msg);
362  /*@=sizeoftype@*/
363 
364  /* XXX FIXME: EPIPE on <stdin> */
365  if (Fseek(fdi, 0, SEEK_SET) == -1) {
366  rpmlog(RPMLOG_ERR, _("%s: Fseek failed: %s\n"),
367  (fileName ? fileName : "<stdin>"), Fstrerror(fdi));
368  return RPMRC_FAIL;
369  }
370 
371  /* Reallocate build data structures */
372  spec = newSpec();
373  spec->packages = newPackage(spec);
374 
375  /* XXX the header just allocated will be allocated again */
376  (void)headerFree(spec->packages->header);
377  spec->packages->header = NULL;
378 
379  /* Read the rpm lead, signatures, and header */
380  { rpmts ts = rpmtsCreate();
381 
382  /* XXX W2DO? pass fileName? */
383  /*@-mustmod@*/ /* LCL: segfault */
384  rc = rpmReadPackageFile(ts, fdi, "readRPM",
385  &spec->packages->header);
386  /*@=mustmod@*/
387 
388  (void)rpmtsFree(ts);
389  ts = NULL;
390 
391  if (sigs) *sigs = NULL; /* XXX HACK */
392  }
393 
394  switch (rc) {
395  case RPMRC_OK:
396  case RPMRC_NOKEY:
397  case RPMRC_NOTTRUSTED:
398  break;
399  case RPMRC_NOTFOUND:
400  rpmlog(RPMLOG_ERR, _("readRPM: %s is not an RPM package\n"),
401  (fileName ? fileName : "<stdin>"));
402  return RPMRC_FAIL;
403  case RPMRC_FAIL:
404  default:
405  rpmlog(RPMLOG_ERR, _("readRPM: reading header from %s\n"),
406  (fileName ? fileName : "<stdin>"));
407  return RPMRC_FAIL;
408  /*@notreached@*/ break;
409  }
410 
411  if (specp)
412  *specp = spec;
413  else
414  spec = freeSpec(spec);
415 
416  if (csa != NULL)
417  csa->cpioFdIn = fdi;
418  else
419  (void) Fclose(fdi);
420 
421  return 0;
422 }
423 #endif
424 
425 #if defined(DEAD)
426 #define RPMPKGVERSION_MIN 30004
427 #define RPMPKGVERSION_MAX 40003
428 /*@unchecked@*/
429 static int rpmpkg_version = -1;
430 
431 static int rpmLeadVersion(void)
432  /*@globals rpmpkg_version, rpmGlobalMacroContext, h_errno @*/
433  /*@modifies rpmpkg_version, rpmGlobalMacroContext @*/
434 {
435  int rpmlead_version;
436 
437  /* Intitialize packaging version from macro configuration. */
438  if (rpmpkg_version < 0) {
439  rpmpkg_version = rpmExpandNumeric("%{_package_version}");
440  if (rpmpkg_version < RPMPKGVERSION_MIN)
441  rpmpkg_version = RPMPKGVERSION_MIN;
442  if (rpmpkg_version > RPMPKGVERSION_MAX)
443  rpmpkg_version = RPMPKGVERSION_MAX;
444  }
445 
446  rpmlead_version = rpmpkg_version / 10000;
447  /* XXX silly sanity check. */
448  if (rpmlead_version < 3 || rpmlead_version > 4)
449  rpmlead_version = 3;
450  return rpmlead_version;
451 }
452 #endif
453 
455 {
456  HE_t he = (HE_t) memset(alloca(sizeof(*he)), 0, sizeof(*he));
457  const char *N, *V, *R;
458 #ifdef RPM_VENDOR_MANDRIVA
459  const char *D;
460  int gotD;
461 #endif
462  rpmuint32_t E;
463  int gotE;
464  const char *pEVR;
465  char *p;
466  rpmuint32_t pFlags = RPMSENSE_EQUAL;
467  const char ** provides = NULL;
468  const char ** providesEVR = NULL;
469  rpmuint32_t * provideFlags = NULL;
470  int providesCount;
471  int bingo = 1;
472  size_t nb;
473  int xx;
474  int i;
475 
476  /* Generate provides for this package N-V-R. */
477  xx = headerNEVRA(h, &N, NULL, &V, &R, NULL);
478  if (!(N && V && R)) {
479  N = _free(N);
480  V = _free(V);
481  R = _free(R);
482  return;
483  }
484 
485  nb = 21 + strlen(V) + 1 + strlen(R) + 1;
486 #ifdef RPM_VENDOR_MANDRIVA
487  he->tag = RPMTAG_DISTEPOCH;
488  gotD = headerGet(h, he, 0);
489  D = (he->p.str ? he->p.str : NULL);
490  nb += (gotD ? strlen(D) + 1 : 0);
491 #endif
492  pEVR = p = alloca(nb);
493  *p = '\0';
494  he->tag = RPMTAG_EPOCH;
495  gotE = headerGet(h, he, 0);
496  E = (he->p.ui32p ? he->p.ui32p[0] : 0);
497  he->p.ptr = _free(he->p.ptr);
498  if (gotE) {
499  sprintf(p, "%d:", E);
500  p += strlen(p);
501  }
502  p = stpcpy( stpcpy( stpcpy(p, V) , "-") , R);
503 #ifdef RPM_VENDOR_MANDRIVA
504  if (gotD) {
505  p = stpcpy( stpcpy( p, ":"), D);
506  D = _free(D);
507  }
508 #endif
509  V = _free(V);
510  R = _free(R);
511 
512  /*
513  * Rpm prior to 3.0.3 does not have versioned provides.
514  * If no provides at all are available, we can just add.
515  */
516  he->tag = RPMTAG_PROVIDENAME;
517 /*@-nullstate@*/
518  xx = headerGet(h, he, 0);
519 /*@=nullstate@*/
520  provides = he->p.argv;
521  providesCount = he->c;
522  if (!xx)
523  goto exit;
524 
525  /*
526  * Otherwise, fill in entries on legacy packages.
527  */
529 /*@-nullstate@*/
530  xx = headerGet(h, he, 0);
531 /*@=nullstate@*/
532  providesEVR = he->p.argv;
533  if (!xx) {
534  for (i = 0; i < providesCount; i++) {
535  /*@observer@*/
536  static const char * vdummy = "";
537  static rpmsenseFlags fdummy = RPMSENSE_ANY;
538 
540  he->t = RPM_STRING_ARRAY_TYPE;
541  he->p.argv = &vdummy;
542  he->c = 1;
543  he->append = 1;
544 /*@-nullstate@*/
545  xx = headerPut(h, he, 0);
546 /*@=nullstate@*/
547  he->append = 0;
548 
549  he->tag = RPMTAG_PROVIDEFLAGS;
550  he->t = RPM_UINT32_TYPE;
551  he->p.ui32p = (void *) &fdummy;
552  he->c = 1;
553  he->append = 1;
554 /*@-nullstate@*/
555  xx = headerPut(h, he, 0);
556 /*@=nullstate@*/
557  he->append = 0;
558  }
559  goto exit;
560  }
561 
562  he->tag = RPMTAG_PROVIDEFLAGS;
563 /*@-nullstate@*/
564  xx = headerGet(h, he, 0);
565 /*@=nullstate@*/
566  provideFlags = he->p.ui32p;
567 
568  /*@-nullderef@*/ /* LCL: providesEVR is not NULL */
569  if (provides && providesEVR && provideFlags)
570  for (i = 0; i < providesCount; i++) {
571  if (!(provides[i] && providesEVR[i]))
572  continue;
573  if (!(provideFlags[i] == RPMSENSE_EQUAL &&
574  !strcmp(N, provides[i]) && !strcmp(pEVR, providesEVR[i])))
575  continue;
576  bingo = 0;
577  break;
578  }
579  /*@=nullderef@*/
580 
581 exit:
582 /*@-usereleased@*/
583  provides = _free(provides);
584  providesEVR = _free(providesEVR);
585  provideFlags = _free(provideFlags);
586 /*@=usereleased@*/
587 
588  if (bingo) {
589  he->tag = RPMTAG_PROVIDENAME;
590  he->t = RPM_STRING_ARRAY_TYPE;
591  he->p.argv = &N;
592  he->c = 1;
593  he->append = 1;
594 /*@-nullstate@*/
595  xx = headerPut(h, he, 0);
596 /*@=nullstate@*/
597  he->append = 0;
598 
600  he->t = RPM_STRING_ARRAY_TYPE;
601  he->p.argv = &pEVR;
602  he->c = 1;
603  he->append = 1;
604 /*@-nullstate@*/
605  xx = headerPut(h, he, 0);
606 /*@=nullstate@*/
607  he->append = 0;
608 
609  he->tag = RPMTAG_PROVIDEFLAGS;
610  he->t = RPM_UINT32_TYPE;
611  he->p.ui32p = &pFlags;
612  he->c = 1;
613  he->append = 1;
614 /*@-nullstate@*/
615  xx = headerPut(h, he, 0);
616 /*@=nullstate@*/
617  he->append = 0;
618  }
619  N = _free(N);
620 }
621 
627 static
628 unsigned char nibble(char c)
629  /*@*/
630 {
631  if (c >= '0' && c <= '9')
632  return (unsigned char) (c - '0');
633  if (c >= 'A' && c <= 'F')
634  return (unsigned char)((int)(c - 'A') + 10);
635  if (c >= 'a' && c <= 'f')
636  return (unsigned char)((int)(c - 'a') + 10);
637  return (unsigned char) '\0';
638 }
639 
640 rpmRC writeRPM(Header *hdrp, unsigned char ** pkgidp, const char * fn,
641  CSA_t csa, char * passPhrase, const char ** cookie, void * _dig)
642 
643 {
644  HE_t he = (HE_t) memset(alloca(sizeof(*he)), 0, sizeof(*he));
645  FD_t fd = NULL;
646  FD_t ifd = NULL;
647 pgpDig dig = _dig;
648  rpmuint32_t sigtag;
649  const char * sigtarget = NULL; /* XXX coverity #1035966 */
650  const char * rpmio_flags = NULL;
651  const char * payload_format = NULL;
652  const char * SHA1 = NULL;
653  const char * msg = NULL;
654  char * s;
655  char buf[BUFSIZ];
656  Header h;
657  Header sigh = NULL;
658  int addsig = 0;
659  int isSource;
660  rpmRC rc = RPMRC_OK;
661  size_t nbr;
662  size_t nbw;
663  int xx;
664 
665  /* Transfer header reference form *hdrp to h. */
666  h = headerLink(*hdrp);
667 
668  (void)headerFree(*hdrp);
669  *hdrp = NULL;
670 
671  if (pkgidp)
672  *pkgidp = NULL;
673 
674  /* Save payload information */
675  isSource =
676  (headerIsEntry(h, RPMTAG_SOURCERPM) == 0 &&
677  headerIsEntry(h, RPMTAG_ARCH) != 0);
678  if (isSource) {
679  payload_format = rpmExpand("%{?_source_payload_format}", NULL);
680  rpmio_flags = rpmExpand("%{?_source_payload}", NULL);
681  } else {
682  payload_format = rpmExpand("%{?_binary_payload_format}", NULL);
683  rpmio_flags = rpmExpand("%{?_binary_payload}", NULL);
684  }
685 
686  if (!(payload_format && *payload_format)) {
687  payload_format = _free(payload_format);
688  payload_format = xstrdup("cpio");
689  }
690  if (!(rpmio_flags && *rpmio_flags)) {
691  rpmio_flags = _free(rpmio_flags);
692  rpmio_flags = xstrdup("w9.gzdio");
693  }
694  s = strchr(rpmio_flags, '.');
695  if (s) {
696 
697  if (payload_format) {
698  if (!strcmp(payload_format, "tar")
699  || !strcmp(payload_format, "ustar")) {
700  /* XXX addition to header is too late to be displayed/sorted. */
701  /* Add prereq on rpm version that understands tar payloads */
702  (void) rpmlibNeedsFeature(h, "PayloadIsUstar", "4.4.4-1");
703  }
704 #if defined(SUPPORT_AR_PAYLOADS)
705  if (!strcmp(payload_format, "ar")) {
706  /* XXX addition to header is too late to be displayed/sorted. */
707  /* Add prereq on rpm version that understands tar payloads */
708  (void) rpmlibNeedsFeature(h, "PayloadIsAr", "5.1-1");
709  }
710 #endif
711 
713  he->t = RPM_STRING_TYPE;
714  he->p.str = payload_format;
715  he->c = 1;
716  xx = headerPut(h, he, 0);
717  }
718 
719  /* XXX addition to header is too late to be displayed/sorted. */
720  if (s[1] == 'g' && s[2] == 'z') {
722  he->t = RPM_STRING_TYPE;
723  he->p.str = xstrdup("gzip");
724  he->c = 1;
725  xx = headerPut(h, he, 0);
726  he->p.ptr = _free(he->p.ptr);
727  } else if (s[1] == 'b' && s[2] == 'z') {
729  he->t = RPM_STRING_TYPE;
730  he->p.str = xstrdup("bzip2");
731  he->c = 1;
732  xx = headerPut(h, he, 0);
733  he->p.ptr = _free(he->p.ptr);
734  } else if (s[1] == 'l' && s[2] == 'z') {
736  he->t = RPM_STRING_TYPE;
737  he->p.str = xstrdup("lzma");
738  he->c = 1;
739  xx = headerPut(h, he, 0);
740  he->p.ptr = _free(he->p.ptr);
741  (void) rpmlibNeedsFeature(h, "PayloadIsLzma", "4.4.6-1");
742  } else if (s[1] == 'x' && s[2] == 'z') {
744  he->t = RPM_STRING_TYPE;
745  he->p.str = xstrdup("xz");
746  he->c = 1;
747  xx = headerPut(h, he, 0);
748  he->p.ptr = _free(he->p.ptr);
749  (void) rpmlibNeedsFeature(h, "PayloadIsXz", "5.2-1");
750  }
751  strncpy(buf, rpmio_flags, sizeof(buf)-1);
752  buf[s - rpmio_flags] = '\0';
753 
754  he->tag = RPMTAG_PAYLOADFLAGS;
755  he->t = RPM_STRING_TYPE;
756  he->p.str = buf+1;
757  he->c = 1;
758  xx = headerPut(h, he, 0);
759  }
760  s = NULL;
761 
762  /* Create and add the cookie */
763  if (cookie) {
764  sprintf(buf, "%s %u", buildHost(), (unsigned) (*getBuildTime()));
765  *cookie = xstrdup(buf); /* XXX memory leak */
766  he->tag = RPMTAG_COOKIE;
767  he->t = RPM_STRING_TYPE;
768  he->p.str = *cookie;
769  he->c = 1;
770  xx = headerPut(h, he, 0);
771  }
772 
773  /* Add the non-repudiable public key (skip if --sign was specified) */
774  if (!addsig && dig && dig->pub && dig->publen > 0) {
775  rpmuint8_t atype = PGPARMOR_PUBKEY;
776  s = pgpArmorWrap(atype, dig->pub, dig->publen);
777 assert(s);
778  he->tag = (rpmTag) RPMTAG_PUBKEYS;
779  he->t = RPM_STRING_ARRAY_TYPE;
780  he->p.argv = (const char **) &s;
781  he->c = 1;
782  he->append = 1;
783  xx = headerPut(h, he, 0);
784  he->append = 0;
785  s = _free(s);
786  }
787 
788  /* Reallocate the header into one contiguous region. */
790  if (h == NULL) { /* XXX can't happen */
791  rpmlog(RPMLOG_ERR, _("Unable to create immutable header region.\n"));
792  rc = RPMRC_FAIL;
793  goto exit;
794  }
795  /* Re-reference reallocated header. */
796  *hdrp = headerLink(h);
797 
798  /*
799  * Write the header+archive into a temp file so that the size of
800  * archive (after compression) can be added to the header.
801  */
802  sigtarget = NULL;
803  if (rpmTempFile(NULL, &sigtarget, &fd)) {
804  rpmlog(RPMLOG_ERR, _("Unable to open temp file.\n"));
805  rc = RPMRC_FAIL;
806  goto exit;
807  }
808 
809  /* Write the header to a temp file, computing header SHA1 on the fly. */
811 assert(fd->ndigests == 1);
812  { const char item[] = "Header";
813  msg = NULL;
814  rc = rpmpkgWrite(item, fd, h, &msg);
815  if (rc != RPMRC_OK) {
816  rpmlog(RPMLOG_ERR, "%s: %s: %s\n", sigtarget, item,
817  (msg && *msg ? msg : "write failed\n"));
818  msg = _free(msg);
819  rc = RPMRC_FAIL;
820  goto exit;
821  }
822  msg = _free(msg);
823  (void) Fflush(fd);
824  }
825 
826  { /* XXX Dupe the header SHA1 for the RFC 2440/4880 signature. */
827  DIGEST_CTX ctx = (dig ? rpmDigestDup(fd->digests[0]) : NULL);
829 
830  /* Finalize the header SHA1. */
831  /* XXX FIXME: get binary octets, not ASCII. */
832  fdFiniDigest(fd, PGPHASHALGO_SHA1, &SHA1, NULL, 1);
833 
834 sigp->hash_algo = PGPHASHALGO_SHA1; /* XXX DSA assumed */
835 sigp->signhash16[0] = (rpmuint8_t) (nibble(SHA1[0]) << 4) | nibble(SHA1[1]);
836 sigp->signhash16[1] = (rpmuint8_t) (nibble(SHA1[2]) << 4) | nibble(SHA1[3]);
837 
838  /* Sign the header SHA1. */
839  if (ctx)
840  rpmbcExportSignature(dig, ctx);
841 
842  }
843 
844  /* Append the payload to the temp file. */
845  if (csa->fi != NULL)
846  rc = cpio_doio(fd, h, csa, payload_format, rpmio_flags);
847  else if (Fileno(csa->cpioFdIn) >= 0)
848  rc = cpio_copy(fd, csa);
849  else
850 assert(0);
851 
852  if (rc != RPMRC_OK)
853  goto exit;
854 
855  (void) Fclose(fd);
856  fd = NULL;
857  (void) Unlink(fn);
858 
859  /* Generate the signature */
860  (void) fflush(stdout);
861  sigh = headerNew();
862  (void) rpmAddSignature(sigh, sigtarget, RPMSIGTAG_SIZE, passPhrase);
863  (void) rpmAddSignature(sigh, sigtarget, RPMSIGTAG_MD5, passPhrase);
864 
865  sigtag = RPMSIGTAG_GPG;
866  addsig = (passPhrase && passPhrase[0]);
867 
868  if (addsig) {
869  rpmlog(RPMLOG_NOTICE, _("Generating signature: %d\n"), sigtag);
870  (void) rpmAddSignature(sigh, sigtarget, sigtag, passPhrase);
871  }
872  else if (dig && dig->sig && dig->siglen > 0) {
873  he->tag = (rpmTag) RPMSIGTAG_DSA; /* XXX DSA assumed */
874  he->t = RPM_BIN_TYPE;
875  he->p.ptr = (void *) dig->sig;
876  he->c = dig->siglen;
877  xx = headerPut(sigh, he, 0);
878  dig->sig = _free(dig->sig); /* XXX lazily instead? */
879  dig->siglen = 0;
880  }
881 
882  if (SHA1) {
883  he->tag = (rpmTag) RPMSIGTAG_SHA1;
884  he->t = RPM_STRING_TYPE;
885  he->p.str = SHA1;
886  he->c = 1;
887  xx = headerPut(sigh, he, 0);
888  SHA1 = _free(SHA1);
889  }
890 
891  { rpmuint32_t payloadSize = csa->cpioArchiveSize;
893  he->t = RPM_UINT32_TYPE;
894  he->p.ui32p = &payloadSize;
895  he->c = 1;
896  xx = headerPut(sigh, he, 0);
897  }
898 
899  /* Reallocate the signature header into one contiguous region. */
901  if (sigh == NULL) { /* XXX can't happen */
902  rpmlog(RPMLOG_ERR, _("Unable to reload signature header.\n"));
903  rc = RPMRC_FAIL;
904  goto exit;
905  }
906 
907  /* Pad the signature header to put the metadata header at known offset. */
908  { size_t slen = 0;
909  void * uh = headerUnload(sigh, &slen);
910  static const size_t align = 1024;
911  size_t nb = align - 96 - 16 - 16;
912  rpmuint8_t * b;
913 
914  uh = _free(uh);
915 assert(slen < nb);
916  nb -= slen;
917  b = memset(alloca(nb), 0, nb);
918  he->tag = (rpmTag) RPMSIGTAG_PADDING;
919  he->t = RPM_BIN_TYPE;
920  he->p.ui8p = b;
921  he->c = nb;
922  xx = headerPut(sigh, he, 0);
924 assert(sigh != NULL);
925  }
926 
927  /* Open the output file */
928  fd = Fopen(fn, "w.fdio");
929  if (fd == NULL || Ferror(fd)) {
930  rpmlog(RPMLOG_ERR, _("Could not open %s: %s\n"),
931  fn, Fstrerror(fd));
932  rc = RPMRC_FAIL;
933  goto exit;
934  }
935 
936  /* Write the lead section into the package. */
937  { const char item[] = "Lead";
938  size_t nl = rpmpkgSizeof(item, NULL);
939 
940  msg = NULL;
941  if (nl == 0)
942  rc = RPMRC_FAIL;
943  else {
944  void * l = memset(alloca(nl), 0, nl);
945  const char *N, *V, *R;
946  (void) headerNEVRA(h, &N, NULL, &V, &R, NULL);
947  sprintf(buf, "%s-%s-%s", N, V, R);
948  N = _free(N);
949  V = _free(V);
950  R = _free(R);
951  msg = buf;
952  rc = rpmpkgWrite(item, fd, l, &msg);
953  }
954 
955  if (rc != RPMRC_OK) {
956  rpmlog(RPMLOG_ERR, _("Unable to write package: %s\n"),
957  Fstrerror(fd));
958  rc = RPMRC_FAIL;
959  goto exit;
960  }
961  }
962 
963  /* Write the signature section into the package. */
964  { const char item[] = "Signature";
965 
966  msg = NULL;
967  rc = rpmpkgWrite(item, fd, sigh, &msg);
968  if (rc != RPMRC_OK) {
969  rpmlog(RPMLOG_ERR, "%s: %s: %s\n", fn, item,
970  (msg && *msg ? msg : "write failed\n"));
971  msg = _free(msg);
972  rc = RPMRC_FAIL;
973  goto exit;
974  }
975  msg = _free(msg);
976  }
977 
978  /* Append the header and archive */
979  ifd = Fopen(sigtarget, "r.fdio");
980  if (ifd == NULL || Ferror(ifd)) {
981  rpmlog(RPMLOG_ERR, _("Unable to open sigtarget %s: %s\n"),
982  sigtarget, Fstrerror(ifd));
983  rc = RPMRC_FAIL;
984  goto exit;
985  }
986 
987  /* Add signatures to header, and write header into the package. */
988  { const char item[] = "Header";
989  Header nh = NULL;
990 
991  msg = NULL;
992  rc = rpmpkgRead(item, ifd, &nh, &msg);
993  if (rc != RPMRC_OK) {
994  rpmlog(RPMLOG_ERR, "%s: %s: %s\n", sigtarget, item,
995  (msg && *msg ? msg : "read failed\n"));
996  msg = _free(msg);
997  rc = RPMRC_FAIL;
998  goto exit;
999  }
1000  msg = _free(msg);
1001 
1002 #ifdef NOTYET
1003  (void) headerMergeLegacySigs(nh, sigh);
1004 #endif
1005 
1006  msg = NULL;
1007  rc = rpmpkgWrite(item, fd, nh, &msg);
1008  (void)headerFree(nh);
1009  nh = NULL;
1010  if (rc != RPMRC_OK) {
1011  rpmlog(RPMLOG_ERR, "%s: %s: %s\n", fn, item,
1012  (msg && *msg ? msg : "write failed\n"));
1013  msg = _free(msg);
1014  rc = RPMRC_FAIL;
1015  goto exit;
1016  }
1017  msg = _free(msg);
1018  }
1019 
1020  /* Write the payload into the package. */
1021  while ((nbr = Fread(buf, sizeof(buf[0]), sizeof(buf), ifd)) > 0) {
1022  if (Ferror(ifd)) {
1023  rpmlog(RPMLOG_ERR, _("Unable to read payload from %s: %s\n"),
1024  sigtarget, Fstrerror(ifd));
1025  rc = RPMRC_FAIL;
1026  goto exit;
1027  }
1028  nbw = (int)Fwrite(buf, sizeof(buf[0]), nbr, fd);
1029  if (nbr != nbw || Ferror(fd)) {
1030  rpmlog(RPMLOG_ERR, _("Unable to write payload to %s: %s\n"),
1031  fn, Fstrerror(fd));
1032  rc = RPMRC_FAIL;
1033  goto exit;
1034  }
1035  }
1036  rc = RPMRC_OK;
1037 
1038 exit:
1039  SHA1 = _free(SHA1);
1040  rpmio_flags = _free(rpmio_flags);
1041  payload_format = _free(payload_format);
1042  (void)headerFree(h);
1043  h = NULL;
1044 
1045  /* XXX Fish the pkgid out of the signature header. */
1046  if (sigh != NULL && pkgidp != NULL) {
1047  he->tag = (rpmTag) RPMSIGTAG_MD5;
1048  xx = headerGet(sigh, he, 0);
1049  if (he->t == RPM_BIN_TYPE && he->p.ptr != NULL && he->c == 16)
1050  *pkgidp = he->p.ui8p; /* XXX memory leak */
1051  }
1052 
1053  (void)headerFree(sigh);
1054  sigh = NULL;
1055  if (ifd) {
1056  (void) Fclose(ifd);
1057  ifd = NULL;
1058  }
1059  if (fd) {
1060  (void) Fclose(fd);
1061  fd = NULL;
1062  }
1063  if (sigtarget) {
1064  (void) Unlink(sigtarget);
1065  sigtarget = _free(sigtarget);
1066  }
1067 
1068  if (rc == RPMRC_OK)
1069  rpmlog(RPMLOG_NOTICE, _("Wrote: %s\n"), fn);
1070  else
1071  (void) Unlink(fn);
1072 
1073  return rc;
1074 }
1075 
1077  /*@modifies h @*/
1078 {
1079  HE_t he = (HE_t) memset(alloca(sizeof(*he)), 0, sizeof(*he));
1080  rpmuint32_t val;
1081  int xx;
1082 
1083  he->tag = RPMTAG_RPMVERSION;
1084  he->t = RPM_STRING_TYPE;
1085  he->p.str = xstrdup(VERSION);
1086  he->c = 1;
1087  xx = headerPut(h, he, 0);
1088  he->p.ptr = _free(he->p.ptr);
1089 
1090  if (!(_rpmbuildFlags & 4)) {
1091  val = (rpmuint32_t)rpmlibTimestamp();
1093  he->t = RPM_UINT32_TYPE;
1094  he->p.ui32p = &val;
1095  he->c = 1;
1096  xx = headerPut(h, he, 0);
1097 
1098  val = (rpmuint32_t)rpmlibVendor();
1099  he->tag = RPMTAG_RPMLIBVENDOR;
1100  he->t = RPM_UINT32_TYPE;
1101  he->p.ui32p = &val;
1102  he->c = 1;
1103  xx = headerPut(h, he, 0);
1104 
1105  val = (rpmuint32_t)rpmlibVersion();
1106  he->tag = RPMTAG_RPMLIBVERSION;
1107  he->t = RPM_UINT32_TYPE;
1108  he->p.ui32p = &val;
1109  he->c = 1;
1110  xx = headerPut(h, he, 0);
1111  }
1112 
1113  he->tag = RPMTAG_BUILDHOST;
1114  he->t = RPM_STRING_TYPE;
1115  he->p.str = buildHost();
1116  he->c = 1;
1117  xx = headerPut(h, he, 0);
1118 
1119  he->tag = RPMTAG_BUILDTIME;
1120  he->t = RPM_UINT32_TYPE;
1121  he->p.ui32p = getBuildTime();
1122  he->c = 1;
1123  xx = headerPut(h, he, 0);
1124 
1125  return 0;
1126 }
1127 
1128 /*@unchecked@*/
1129 static rpmTag copyTags[] = {
1133  0
1134 };
1135 
1136 static rpmRC checkPackages(const char *pkgcheck)
1137 {
1138  int fail = rpmExpandNumeric("%{?_nonzero_exit_pkgcheck_terminate_build}");
1139  int xx;
1140 
1141  rpmlog(RPMLOG_NOTICE, _("Executing \"%s\":\n"), pkgcheck);
1142  /* XXX FIXME: use popen(3) through %(...) instead. */
1143  xx = system(pkgcheck);
1144  if (WEXITSTATUS(xx) == -1 || WEXITSTATUS(xx) == 127) {
1145  rpmlog(RPMLOG_ERR, _("Execution of \"%s\" failed.\n"), pkgcheck);
1146  if (fail) return 127;
1147  }
1148  if (WEXITSTATUS(xx) != 0) {
1149  rpmlog(RPMLOG_ERR, _("Package check \"%s\" failed.\n"), pkgcheck);
1150  if (fail) return RPMRC_FAIL;
1151  }
1152 
1153  return RPMRC_OK;
1154 }
1155 
1157 {
1158  HE_t he = (HE_t) memset(alloca(sizeof(*he)), 0, sizeof(*he));
1159  struct cpioSourceArchive_s csabuf;
1160  CSA_t csa = &csabuf;
1161  const char *errorString;
1162  Package pkg;
1163  rpmRC rc = RPMRC_OK; /* assume success */
1164  int xx;
1165  ARGV_t pkglist = NULL;
1166 
1167  for (pkg = spec->packages; pkg != NULL; pkg = pkg->next) {
1168  const char *fn;
1169 
1170  if (pkg->fileList == NULL)
1171  continue;
1172 
1173  if (spec->cookie) {
1174  he->tag = RPMTAG_COOKIE;
1175  he->t = RPM_STRING_TYPE;
1176  he->p.str = spec->cookie;
1177  he->c = 1;
1178  xx = headerPut(pkg->header, he, 0);
1179  }
1180 
1181  /* Copy changelog from src rpm */
1182  headerCopyTags(spec->packages->header, pkg->header, copyTags);
1183 
1184  /* Add rpmlib markers for tracking. */
1185  (void) rpmlibMarkers(pkg->header);
1186 
1187  he->tag = RPMTAG_OPTFLAGS;
1188  he->t = RPM_STRING_TYPE;
1189  he->p.str = rpmExpand("%{optflags}", NULL);
1190  he->c = 1;
1191  xx = headerPut(pkg->header, he, 0);
1192  he->p.ptr = _free(he->p.ptr);
1193 
1194 if (!(_rpmbuildFlags & 4)) {
1195  if (spec->sourcePkgId != NULL) {
1196  he->tag = RPMTAG_SOURCEPKGID;
1197  he->t = RPM_BIN_TYPE;
1198  he->p.ptr = spec->sourcePkgId;
1199  he->c = 16;
1200  xx = headerPut(pkg->header, he, 0);
1201  }
1202 }
1203 
1204  { const char *binFormat = rpmGetPath("%{_rpmfilename}", NULL);
1205  char *binRpm, *binDir;
1206  binRpm = headerSprintf(pkg->header, binFormat, NULL,
1207  rpmHeaderFormats, &errorString);
1208  binFormat = _free(binFormat);
1209  if (binRpm == NULL) {
1210  he->tag = RPMTAG_NVRA;
1211  xx = headerGet(pkg->header, he, 0);
1212  rpmlog(RPMLOG_ERR, _("Could not generate output "
1213  "filename for package %s: %s\n"), he->p.str, errorString);
1214  he->p.ptr = _free(he->p.ptr);
1215  rc = RPMRC_FAIL;
1216  goto exit;
1217  }
1218  fn = rpmGetPath("%{_rpmdir}/", binRpm, NULL);
1219  if ((binDir = strchr(binRpm, '/')) != NULL) {
1220  struct stat st;
1221  const char *dn;
1222  *binDir = '\0';
1223  dn = rpmGetPath("%{_rpmdir}/", binRpm, NULL);
1224  if (Stat(dn, &st) < 0) {
1225  switch(errno) {
1226  case ENOENT:
1227  if (rpmioMkpath(dn, 0755, -1, -1) == 0)
1228  /*@switchbreak@*/ break;
1229  /*@fallthrough@*/
1230  default:
1231  rpmlog(RPMLOG_ERR,_("cannot create %s: %s\n"),
1232  dn, strerror(errno));
1233  /*@switchbreak@*/ break;
1234  }
1235  }
1236  dn = _free(dn);
1237  }
1238  binRpm = _free(binRpm);
1239  }
1240 
1241  memset(csa, 0, sizeof(*csa));
1242  csa->cpioArchiveSize = 0;
1243  /*@-type@*/ /* LCL: function typedefs */
1244 /*@-onlytrans@*/
1245  csa->cpioFdIn = fdNew("init (packageBinaries)");
1246 /*@=onlytrans@*/
1247 /*@-assignexpose -newreftrans@*/
1248  csa->fi = rpmfiLink(pkg->fi, "packageBinaries");
1249 /*@=assignexpose =newreftrans@*/
1250 assert(csa->fi != NULL);
1251 
1252  rc = writeRPM(&pkg->header, NULL, fn,
1253  csa, spec->passPhrase, NULL, spec->dig);
1254 
1255 /*@-onlytrans@*/
1256  csa->fi->te = _free(csa->fi->te); /* XXX memory leak */
1257 /*@=onlytrans@*/
1258  csa->fi = rpmfiFree(csa->fi);
1259 /*@-nullpass -onlytrans -refcounttrans @*/
1260  csa->cpioFdIn = fdFree(csa->cpioFdIn, "init (packageBinaries)");
1261 /*@=nullpass =onlytrans =refcounttrans @*/
1262  /*@=type@*/
1263  if (rc == RPMRC_OK) {
1264  /* Do check each written package if enabled */
1265  char *pkgcheck = rpmExpand("%{?_build_pkgcheck} ", fn, NULL);
1266  if (pkgcheck[0] != ' ') {
1267  rc = checkPackages(pkgcheck);
1268  }
1269  pkgcheck = _free(pkgcheck);
1270  xx = argvAdd(&pkglist, fn);
1271  }
1272  fn = _free(fn);
1273  if (rc) {
1274  pkglist = argvFree(pkglist);
1275  goto exit;
1276  }
1277  }
1278 
1279  /* Now check the package set if enabled */
1280  if (pkglist != NULL) {
1281  char *pkgcheck_set = NULL;
1282  char *pkgs = NULL;
1283  size_t pkglen = 0;
1284  int i;
1285  for (i = 0; i < argvCount(pkglist); i++)
1286  pkglen += strlen(pkglist[i]) + 1;
1287  pkgs = xcalloc(1, pkglen);
1288  for (i = 0; i < argvCount(pkglist); i++) {
1289  if (i)
1290  strcat(pkgs, " ");
1291  strcat(pkgs, pkglist[i]);
1292  }
1293 
1294  pkgcheck_set = rpmExpand("%{?_build_pkgcheck_set} ", pkgs, NULL);
1295  if (pkgcheck_set[0] != ' ') { /* run only if _build_pkgcheck_set is defined */
1296  rc = checkPackages(pkgcheck_set);
1297  }
1298  pkgcheck_set = _free(pkgcheck_set);
1299  pkglist = argvFree(pkglist);
1300  pkgs = _free(pkgs);
1301  }
1302 
1303 exit:
1304 
1305  return rc;
1306 }
1307 
1309 {
1310  HE_t he = (HE_t) memset(alloca(sizeof(*he)), 0, sizeof(*he));
1311  struct cpioSourceArchive_s csabuf;
1312  CSA_t csa = &csabuf;
1313  rpmRC rc;
1314  int xx;
1315 #if defined(RPM_VENDOR_OPENPKG) || defined(RPM_VENDOR_FEDORA) || defined(RPM_VENDOR_MANDRIVA) || defined(RPM_VENDOR_ARK) /* backward-compat-rpmtag-sourcepackage */
1316  rpmuint32_t val;
1317 #endif
1318 
1319  /* Add rpmlib markers for tracking. */
1320  (void) rpmlibMarkers(spec->sourceHeader);
1321 
1322 #if defined(RPM_VENDOR_OPENPKG) || defined(RPM_VENDOR_FEDORA) || defined(RPM_VENDOR_MANDRIVA) || defined(RPM_VENDOR_ARK) /* backward-compat-rpmtag-sourcepackage */
1323  /* Mark package as a SRPM for backward compatibility with RPM < 4.4.6 */
1324  he->tag = RPMTAG_SOURCEPACKAGE;
1325  he->t = RPM_UINT32_TYPE;
1326  val = 1;
1327  he->p.ui32p = &val;
1328  he->c = 1;
1329  xx = headerPut(spec->sourceHeader, he, 0);
1330 #endif
1331 
1332  /* Add build scriptlet status/time (if any) to SRPM's. */
1333  { size_t ix; /* XXX coverity #1035951 */
1334  for (ix = 0; ix < RPMSCRIPT_MAX; ix++) {
1335  if (spec->sstates[ix] == 0)
1336  continue;
1337  if (spec->smetrics[ix] == 0)
1338  continue;
1339  break;
1340  }
1341  if (ix < RPMSCRIPT_MAX) {
1342  he->tag = RPMTAG_SCRIPTSTATES;
1343  he->t = RPM_UINT32_TYPE;
1344  he->p.ui32p = spec->sstates;
1345  he->c = RPMSCRIPT_MAX;
1346  xx = headerPut(spec->sourceHeader, he, 0);
1347  he->tag = RPMTAG_SCRIPTMETRICS;
1348  he->t = RPM_UINT32_TYPE;
1349  he->p.ui32p = spec->smetrics;
1350  he->c = RPMSCRIPT_MAX;
1351  xx = headerPut(spec->sourceHeader, he, 0);
1352  }
1353  }
1354 
1355  /* Add macros used during build to SRPM's. */
1356  { const char ** av = NULL;
1357  (void)rpmGetMacroEntries(NULL, NULL, 1, &av);
1358  if (av != NULL && av[0] != NULL) {
1359  he->tag = RPMTAG_BUILDMACROS;
1360  he->t = RPM_STRING_ARRAY_TYPE;
1361  he->p.argv = av;
1362  he->c = argvCount(av);
1363  xx = headerPut(spec->sourceHeader, he, 0);
1364  }
1365 /*@-nullstate@*/
1366  av = argvFree(av);
1367 /*@=nullstate@*/
1368  }
1369 
1370  spec->cookie = _free(spec->cookie);
1371 
1372  /* XXX this should be %_srpmdir */
1373  { const char *srcrpmdir = rpmGetPath("%{_srcrpmdir}/", NULL);
1374  const char *fn = rpmGetPath("%{_srcrpmdir}/", spec->sourceRpmName,NULL);
1375  const char *pkgcheck = rpmExpand("%{?_build_pkgcheck_srpm} ", fn, NULL);
1376 
1377  rc = rpmioMkpath(srcrpmdir, 0755, -1, -1);
1378 
1379  memset(csa, 0, sizeof(*csa));
1380  csa->cpioArchiveSize = 0;
1381  /*@-type@*/ /* LCL: function typedefs */
1382 /*@-onlytrans@*/
1383  csa->cpioFdIn = fdNew("init (packageSources)");
1384 /*@=onlytrans@*/
1385 /*@-assignexpose -newreftrans@*/
1386  csa->fi = rpmfiLink(spec->fi, "packageSources");
1387 /*@=assignexpose =newreftrans@*/
1388 #ifdef DYING
1389 assert(csa->fi != NULL);
1390 #else
1391  if (csa->fi == NULL) { /* XXX segfault avoidance */
1392  srcrpmdir = _free(srcrpmdir);
1393  fn = _free(fn);
1394  pkgcheck = _free(pkgcheck);
1395  return RPMRC_FAIL;
1396  }
1397 #endif
1398 
1399  spec->sourcePkgId = NULL;
1400  rc = writeRPM(&spec->sourceHeader, &spec->sourcePkgId, fn,
1401  csa, spec->passPhrase, &spec->cookie, spec->dig);
1402 
1403  /* Do check SRPM package if enabled */
1404  if (rc == RPMRC_OK && pkgcheck[0] != ' ') {
1405  rc = checkPackages(pkgcheck);
1406  }
1407 
1408 /*@-onlytrans@*/
1409  csa->fi->te = _free(csa->fi->te); /* XXX memory leak */
1410 /*@=onlytrans@*/
1411  csa->fi = rpmfiFree(csa->fi);
1412 /*@-nullpass -onlytrans -refcounttrans @*/
1413  csa->cpioFdIn = fdFree(csa->cpioFdIn, "init (packageSources)");
1414 /*@=nullpass =onlytrans =refcounttrans @*/
1415  /*@=type@*/
1416  srcrpmdir = _free(srcrpmdir);
1417  fn = _free(fn);
1418  pkgcheck = _free(pkgcheck);
1419  }
1420 
1421  rc = (rc ? RPMRC_FAIL : RPMRC_OK);
1422 
1423  return rc;
1424 }
char * cookie
Definition: rpmts-py.c:1341
static void fdInitDigest(FD_t fd, pgpHashAlgo hashalgo, int _flags)
Attach digest to fd.
rpmTagType t
Definition: rpmtag.h:502
char * fileName
Definition: rpmspec.h:31
const char * str
Definition: rpmtag.h:73
int xx
Definition: spec.c:744
rpmTag tag
Definition: rpmtag.h:501
char * iosmStrerror(int rc)
Return formatted error message on payload handling failure.
Definition: iosm.c:2767
iter fi
Definition: fsm.c:170
const void * uh
Definition: rpmts-py.c:977
const char ** argv
Definition: rpmtag.h:75
Header headerNew(void)
Create new (empty) header instance.
Definition: header.c:180
DIGEST_CTX ctx
Definition: signature.c:785
#define headerFree(_h)
Definition: rpmtag.h:870
rpmlog(RPMLOG_ERR,"%s\n", buf)
static int addFileToTag(Spec spec, const char *file, Header h, rpmTag tag)
Definition: pack.c:157
const char * sourceRpmName
Definition: rpmspec.h:167
static rpmTag copyTags[]
Definition: pack.c:1129
Package next
Definition: rpmspec.h:255
rpmiob fileList
Definition: rpmspec.h:253
rpmRC rpmpkgWrite(const char *fn, FD_t fd, void *ptr, const char **msg)
Write item onto file descriptor.
Definition: pkgio.c:1665
const char * postInFile
Definition: rpmspec.h:230
int _rpmbuildFlags
Definition: poptBT.c:53
size_t Fwrite(const void *buf, size_t size, size_t nmemb, FD_t fd)
fwrite(3) clone.
Definition: rpmio.c:2432
char * xstrdup(const char *str)
Definition: rpmmalloc.c:321
rpmuint32_t * ui32p
Definition: rpmtag.h:70
FD_t Fopen(const char *path, const char *_fmode)
fopen(3) clone.
Definition: rpmio.c:2831
char * rpmGetPath(const char *path,...)
Return (malloc&#39;ed) expanded, canonicalized, file path.
Definition: macro.c:3371
Spec freeSpec(Spec spec)
Destroy a spec file control structure.
static int addFileToArrayTag(Spec spec, const char *file, Header h, rpmTag tag)
Definition: pack.c:188
Structure(s) used for file info tag sets.
static char *size_t nb
fgets(3) analogue that reads \ continuations.
Definition: macro.c:409
struct rpmts_s * rpmts
The RPM Transaction Set.
Definition: rpmtypes.h:14
int rc
Definition: poptALL.c:670
char * prog
Definition: rpmspec.h:35
rpmts rpmtsFree(rpmts ts)
Destroy transaction set, closing the database as well.
const char * buildHost(void)
Return build hostname.
Definition: names.c:206
The Header data structure.
int rpmioMkpath(const char *path, mode_t mode, uid_t uid, gid_t gid)
Insure that directories in path exist, creating as needed.
Definition: rpmio.c:3015
void headerMergeLegacySigs(Header h, const Header sigh)
Translate and merge legacy signature tags into header.
Definition: hdrNVR.c:242
headerSprintfExtension rpmHeaderFormats
Table of query format extensions.
Definition: formats.c:305
static unsigned char nibble(char c)
Convert hex to binary nibble.
Definition: pack.c:628
#define VERSION
Definition: config.h:1289
int Stat(const char *path, struct stat *st)
stat(2) clone.
Definition: rpmrpc.c:1361
Header headerReload(Header h, rpmTag tag)
Convert header to on-disk representation, and then reload.
Definition: header.c:1314
enum rpmTag_e rpmTag
Definition: rpmtag.h:468
int Fflush(FD_t fd)
fflush(3) clone.
Definition: rpmio.c:2914
int errno
Header sourceHeader
Definition: rpmspec.h:171
rpmfi rpmfiFree(rpmfi fi)
Destroy a file info set.
rpmiob rpmiobFree(rpmiob iob)
Destroy a I/O buffer instance.
FD_t fdDup(int fdno)
Definition: rpmio.c:264
rpmiob rpmiobAppend(rpmiob iob, const char *s, size_t nl)
Append string to I/O buffer.
Definition: rpmiob.c:77
Header headerLink(Header h)
Reference a header instance.
Header h
Definition: spec.c:739
int Fseek(FD_t fd, _libio_off_t offset, int whence)
fseek(3) clone.
Definition: rpmio.c:2455
char * passPhrase
Definition: rpmspec.h:156
FD_t fdNew(const char *msg)
static int rpmlibMarkers(Header h)
Definition: pack.c:1076
DIGEST_CTX * digests
struct pgpDig_s * pgpDig
Definition: rpmiotypes.h:86
rpmRC writeRPM(Header *hdrp, unsigned char **pkgidp, const char *fileName, CSA_t csa, char *passPhrase, const char **cookie, void *_dig)
Write rpm package to file.
Definition: pack.c:640
unsigned char rpmuint8_t
Private int typedefs to avoid C99 portability issues.
Definition: rpmiotypes.h:26
struct rpmiob_s * rpmiob
Definition: rpmiotypes.h:60
sprintf(t," (%u)",(unsigned) dig->nbytes)
char * passPhrase
Definition: rpmts-py.c:1340
const char * N
Definition: rpmds.c:2714
rpmRC packageBinaries(Spec spec)
Generate binary package(s).
Definition: pack.c:1156
char * alloca()
enum rpmRC_e rpmRC
RPM return codes.
Definition: signature.c:616
goto exit
Definition: db3.c:1903
memset(_r, 0, sizeof(*_r))
Header header
Definition: rpmspec.h:217
int headerDel(Header h, HE_t he, unsigned int flags)
Remove tag container from header.
Definition: header.c:2312
unsigned int rpmuint32_t
Definition: rpmiotypes.h:28
rpmuint32_t rpmlibVendor(void)
Definition: rpmversion.c:21
rpmts rpmtsCreate(void)
Create an empty transaction set.
Definition: rpmts.c:1468
const char * Fstrerror(FD_t fd)
strerror(3) clone.
Definition: rpmio.c:2399
void * xcalloc(size_t nmemb, size_t size)
Definition: rpmmalloc.c:300
assert(key->size==sizeof(hdrNum))
Package newPackage(Spec spec)
Create and initialize package control structure.
Definition: spec.c:204
void * ptr
Definition: rpmtag.h:67
int ix
Definition: rpmps-py.c:174
char * p
Definition: macro.c:413
char * headerSprintf(Header h, const char *fmt, headerTagTableEntry tags, headerSprintfExtension exts, errmsg_t *errmsg)
Return formatted output string from header tags.
Definition: hdrfmt.c:6748
int rpmAddSignature(Header sigh, const char *file, rpmSigTag sigTag, const char *passPhrase)
Generate signature(s) from a header+payload file, save in signature header.
Definition: signature.c:433
const char * cookie
Definition: rpmspec.h:159
int headerIsEntry(Header h, rpmTag tag)
Check if tag is in header.
Definition: header.c:1438
int rpmGetMacroEntries(MacroContext mc, void *_mire, int used, const char ***avp)
Return macro entries as string array.
Definition: macro.c:319
FD_t fdFree(FD_t fd, const char *msg)
size_t rpmpkgSizeof(const char *fn, const void *ptr)
Return size of item in bytes.
Definition: pkgio.c:1619
int rpmTempFile(const char *prefix, const char **fnptr, void *fdptr)
Return file handle for a temporaray file.
Definition: signature.c:30
int argvCount(const ARGV_t argv)
Return no.
Definition: argv.c:71
enum evrFlags_e rpmsenseFlags
Definition: rpmevr.h:74
he tag
Definition: db3.c:1927
rpmTagData p
Definition: rpmtag.h:504
MacroContext macros
Definition: rpmspec.h:177
DIGEST_CTX rpmDigestDup(DIGEST_CTX octx)
Duplicate a digest context.
Definition: digest.c:209
ARGV_t argvFree(ARGV_t argv)
Destroy an argv array.
Definition: argv.c:44
rpmuint32_t sstates[RPMSCRIPT_MAX]
Definition: rpmspec.h:182
static const char * file
Definition: parseFiles.c:20
static rpmiob addFileToTagAux(Spec spec, const char *file, rpmiob iob)
Definition: pack.c:120
rpmuint32_t * getBuildTime(void)
Return build time stamp.
Definition: names.c:197
pgpDigParams pgpGetSignature(pgpDig dig)
Return OpenPGP signature parameters.
Definition: rpmpgp.c:1226
rpmRC rpmReadPackageFile(rpmts ts, FD_t fd, const char *fn, Header *hdrp)
Return package header from file handle, verifying digests/signatures.
Definition: package.c:83
struct _HE_s * HE_t
Destroy an extension cache.
Definition: rpmtag.h:59
struct TriggerFileEntry * triggerFiles
Definition: rpmspec.h:248
Digest private data.
Definition: digest.c:127
int headerGet(Header h, HE_t he, unsigned int flags)
Retrieve extension or tag value from a header.
Definition: header.c:2230
rpmuint32_t smetrics[RPMSCRIPT_MAX]
Definition: rpmspec.h:183
static rpmRC checkPackages(const char *pkgcheck)
Definition: pack.c:1136
The FD_t File Handle data structure.
int headerPut(Header h, HE_t he, unsigned int flags)
Add or append tag container to header.
Definition: header.c:2293
return k val
Definition: rpmmtree.c:401
Spec newSpec(void)
Create and initialize Spec structure.
Definition: spec.c:642
int argvAdd(ARGV_t *argvp, ARGstr_t val)
Add a string to an argv array.
Definition: argv.c:199
rpmTagCount c
Definition: rpmtag.h:505
Generate and verify rpm package signatures.
The structure used to store values parsed from a spec file.
Definition: rpmspec.h:113
rpmuint32_t cpioArchiveSize
Definition: buildio.h:16
char * rpmExpand(const char *arg,...)
Return (malloc&#39;ed) concatenated macro expansion(s).
Definition: macro.c:3178
static rpmRC cpio_copy(FD_t fdo, CSA_t csa)
Definition: pack.c:95
const char * preInFile
Definition: rpmspec.h:228
size_t Fread(void *buf, size_t size, size_t nmemb, FD_t fd)
fread(3) clone.
Definition: rpmio.c:2410
struct TriggerFileEntry * next
Definition: rpmspec.h:37
rpmuint8_t * ui8p
Definition: rpmtag.h:68
char * script
Definition: rpmspec.h:33
node fd
Definition: rpmfd-py.c:124
char * pgpArmorWrap(rpmuint8_t atype, const unsigned char *s, size_t ns)
Wrap a OpenPGP packets in ascii armor for transport.
Definition: rpmpgp.c:1579
rpmuint32_t rpmlibVersion(void)
Definition: rpmversion.c:11
int Fclose(FD_t fd)
fclose(3) clone.
Definition: rpmio.c:2532
rpmiob rpmiobNew(size_t len)
Create an I/O buffer.
Definition: rpmiob.c:44
int fsmTeardown(void *_fsm)
Clean file state machine.
Definition: fsm.c:751
int rpmbcExportSignature(pgpDig dig, DIGEST_CTX ctx)
Definition: rpmbc.c:923
Routines to read and write packages.
static const char *char c
Return text between pl and matching pr characters.
Definition: macro.c:470
rpmuint32_t rpmlibTimestamp(void)
Definition: rpmversion.c:16
const char * postUnFile
Definition: rpmspec.h:234
size_t ndigests
int Ferror(FD_t fd)
ferror(3) clone.
Definition: rpmio.c:2942
char * rpmiobStr(rpmiob iob)
Return I/O buffer (as string).
Definition: rpmiob.c:112
Package packages
Definition: rpmspec.h:204
void headerCopyTags(Header headerFrom, Header headerTo, rpmTag *tagstocopy)
Duplicate tag values from one header into another.
Definition: header.c:2210
Definition: rpmtag.h:500
return strcmp(ame->name, bme->name)
const char * s
Definition: poptALL.c:734
This is the only module users of librpmbuild should need to include.
rpmfi rpmfiLink(rpmfi fi, const char *msg)
Reference a file info set instance.
Methods to handle package elements.
#define SEEK_SET
Definition: system.h:226
char * stpcpy(char *dest, const char *src)
const char * SHA1
Definition: signature.c:684
void * headerUnload(Header h, size_t *lenp)
headerUnload.
Definition: header.c:648
rpmRC packageSources(Spec spec)
Generate source package.
Definition: pack.c:1308
FD_t Fdopen(FD_t ofd, const char *fmode)
Definition: rpmio.c:2716
const char * msg
Definition: rpmts-py.c:976
File state machine to handle a payload within an rpm package.
rpmRC processScriptFiles(Spec spec, Package pkg)
Append files (if any) to scriptlet tags.
Definition: pack.c:214
struct pgpDigParams_s * pgpDigParams
Definition: rpmiotypes.h:90
static void * fdGetFp(FD_t fd)
int fsmSetup(void *_fsm, iosmFileStage goal, const char *afmt, const void *_ts, const void *_fi, FD_t cfd, unsigned int *archiveSize, const char **failedFile)
Load external data into file state machine.
Definition: fsm.c:627
FILE * f
Definition: macro.c:411
return NULL
Definition: poptALL.c:613
rpmfi fi
Definition: rpmspec.h:173
const char * verifyFile
Definition: rpmspec.h:240
int expandMacros(void *spec, MacroContext mc, char *sbuf, size_t slen)
Expand macro into buffer.
Definition: macro.c:2687
int Fileno(FD_t fd)
fileno(3) clone.
Definition: rpmio.c:2989
static void
Print copy of spec file, filling in Group/Description/Summary from specspo.
Definition: spec.c:737
static void fdFiniDigest(FD_t fd, pgpHashAlgo hashalgo, void *datap, size_t *lenp, int asAscii)
char * buf
Parse (and execute) macro undefinition.
Definition: macro.c:703
#define _(Text)
Definition: system.h:29
The structure used to store values for a package.
Definition: rpmspec.h:214
char * b
Definition: macro.c:746
const char * preUnFile
Definition: rpmspec.h:232
int
Save source and expand field into target.
Definition: rpmds.c:2709
struct rpmfi_s * rpmfi
File info tag sets from a header, so that a header can be discarded early.
Definition: rpmfi.h:83
rpmRC rpmpkgRead(const char *fn, FD_t fd, void *ptr, const char **msg)
Read item from file descriptor.
Definition: pkgio.c:1647
ARGstr_t * ARGV_t
Definition: argv.h:12
static rpmRC cpio_doio(FD_t fdo, Header h, CSA_t csa, const char *payload_format, const char *fmodeMacro)
Definition: pack.c:40
rpmfi fi
Definition: rpmspec.h:221
int headerNEVRA(Header h, const char **np, const char **ep, const char **vp, const char **rp, const char **ap)
Return name, epoch, version, release, arch strings from header.
Definition: hdrNVR.c:162
int rpmlibNeedsFeature(Header h, const char *feature, const char *featureEVR)
Add rpmlib feature dependency.
Definition: reqprov.c:212
static void * _free(const void *p)
Wrapper to free(3), hides const compilation noise, permit NULL, return NULL.
Definition: rpmiotypes.h:647
pgpDigParams sigp
Definition: signature.c:748
int i
Definition: spec.c:743
pgpDig dig
Definition: rpmts-py.c:979
strncpy(sbuf, f, flen)
void providePackageNVR(Header h)
Retrofit an explicit Provides: N = E:V-R dependency into package headers.
Definition: pack.c:454
const char * postTransFile
Definition: rpmspec.h:238
int rpmExpandNumeric(const char *arg)
Return macro expansion as a numeric value.
Definition: macro.c:3252
void * dig
Definition: rpmspec.h:202
const char ** av
Definition: rpmts-py.c:788
size_t fn
Definition: macro.c:1698
const char * preTransFile
Definition: rpmspec.h:236
unsigned char * sourcePkgId
Definition: rpmspec.h:169
const char * sanityCheckFile
Definition: rpmspec.h:242
Spec spec
Definition: spec-py.c:121
unsigned int append
Definition: rpmtag.h:509
int Unlink(const char *path)
unlink(2) clone.
Definition: rpmrpc.c:397