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