lib/rpmlead.c

   1 /** \ingroup lead
   2  * \file lib/rpmlead.c
   3  */
   4
   5 #include "system.h"
   6
   7 #include <netinet/in.h>
   8
   9 #include <rpm/rpmlib.h>         /* rpmGetOs/ArchInfo() */
  10 #include <rpm/rpmlog.h>
  11 #include <rpm/rpmstring.h>
  12
  13 #include "lib/signature.h"
  14 #include "lib/rpmlead.h"
  15 #include "lib/legacy.h"
  16
  17 #include "debug.h"
  18
  19 static unsigned char const lead_magic[] = {
  20     RPMLEAD_MAGIC0, RPMLEAD_MAGIC1, RPMLEAD_MAGIC2, RPMLEAD_MAGIC3
  21 };
  22
  23 /** \ingroup lead
  24  * The lead data structure.
  25  * The lead needs to be 8 byte aligned.
  26  * @deprecated The lead (except for signature_type) is legacy.
  27  * @todo Don't use any information from lead.
  28  */
  29 struct rpmlead_s {
  30     unsigned char magic[4];
  31     unsigned char major;
  32     unsigned char minor;
  33     short type;
  34     short archnum;
  35     char name[66];
  36     short osnum;
  37     short signature_type;       /*!< Signature header type (RPMSIG_HEADERSIG) */
  38     char reserved[16];      /*!< Pad to 96 bytes -- 8 byte aligned! */
  39 };
  40
  41 rpmlead rpmLeadNew(void)
  42 {
  43     int archnum, osnum;
  44     rpmlead l = calloc(1, sizeof(*l));
  45
  46     rpmGetArchInfo(NULL, &archnum);
  47     rpmGetOsInfo(NULL, &osnum);
  48
  49     l->major = (_noDirTokens ? 4: 3);
  50     l->minor = 0;
  51     l->archnum = archnum;
  52     l->osnum = osnum;
  53     l->signature_type = RPMSIGTYPE_HEADERSIG;
  54     return l;
  55 }
  56
  57 rpmlead rpmLeadFromHeader(Header h)
  58 {
  59     char * nevr;
  60     assert(h != NULL);
  61     rpmlead l = rpmLeadNew();
  62
  63     l->type = (headerIsSource(h) ? 1 : 0);
  64     nevr = headerGetNEVR(h, NULL);
  65     rstrlcpy(l->name, nevr, sizeof(l->name));
  66     free(nevr);
  67
  68     return l;
  69 }
  70
  71 rpmlead rpmLeadFree(rpmlead lead)
  72 {
  73     assert(lead != NULL);
  74     free(lead);
  75     return NULL;
  76 }
  77
  78 /* The lead needs to be 8 byte aligned */
  79 rpmRC rpmLeadWrite(FD_t fd, rpmlead lead)
  80 {
  81     struct rpmlead_s l;
  82     assert(lead != NULL);
  83
  84     memcpy(&l, lead, sizeof(l));
  85
  86     memcpy(&l.magic, lead_magic, sizeof(l.magic));
  87     l.type = htons(lead->type);
  88     l.archnum = htons(lead->archnum);
  89     l.osnum = htons(lead->osnum);
  90     l.signature_type = htons(lead->signature_type);
  91
  92     if (Fwrite(&l, 1, sizeof(l), fd) != sizeof(l))
  93         return RPMRC_FAIL;
  94
  95     return RPMRC_OK;
  96 }
  97
  98 rpmRC rpmLeadCheck(rpmlead lead, const char **msg)
  99 {
 100     if (memcmp(lead->magic, lead_magic, sizeof(lead_magic))) {
 101         if (msg) *msg = _("not an rpm package");
 102         return RPMRC_NOTFOUND;
 103     }
 104     if (lead->signature_type != RPMSIGTYPE_HEADERSIG) {
 105         if (msg) *msg = _("illegal signature type");
 106         return RPMRC_FAIL;
 107     }
 108     if (lead->major < 3 || lead->major > 4) {
 109         if (msg) *msg = _("unsupported RPM package version");
 110         return RPMRC_FAIL;
 111     }
 112     return RPMRC_OK;
 113 }
 114
 115 rpmRC rpmLeadRead(FD_t fd, rpmlead lead)
 116 {
 117     assert(lead != NULL);
 118     memset(lead, 0, sizeof(*lead));
 119     /* FIX: remove timed read */
 120     if (timedRead(fd, (char *)lead, sizeof(*lead)) != sizeof(*lead)) {
 121         if (Ferror(fd)) {
 122             rpmlog(RPMLOG_ERR, _("read failed: %s (%d)\n"),
 123                         Fstrerror(fd), errno);
 124             return RPMRC_FAIL;
 125         }
 126         return RPMRC_NOTFOUND;
 127     }
 128     lead->type = ntohs(lead->type);
 129     lead->archnum = ntohs(lead->archnum);
 130     lead->osnum = ntohs(lead->osnum);
 131     lead->signature_type = ntohs(lead->signature_type);
 132
 133     return RPMRC_OK;
 134 }