From a128834ef5635310b5a119a954efbebda2876920 Mon Sep 17 00:00:00 2001 From: DistroBaker Date: Wed, 24 Mar 2021 15:00:35 +0000 Subject: [PATCH] Merged update from upstream sources This is an automated DistroBaker update from upstream sources. If you do not know what this is about or would like to opt out, contact the OSCI team. Source: https://src.fedoraproject.org/rpms/s390utils.git#02409651fa3e00305b229c9ad3af575ed5f517ad --- .gitignore | 1 + s390-tools-2.16.0-genprotimg.patch | 1021 ++++++++++++++++++++++++++++ s390-tools-2.16.0-zkey.patch | 50 ++ s390utils.spec | 23 +- sources | 2 +- 5 files changed, 1093 insertions(+), 4 deletions(-) create mode 100644 s390-tools-2.16.0-genprotimg.patch create mode 100644 s390-tools-2.16.0-zkey.patch diff --git a/.gitignore b/.gitignore index 52c737a..29be767 100644 --- a/.gitignore +++ b/.gitignore @@ -23,3 +23,4 @@ src_vipa-2.0.4.tar.gz /s390-tools-2.14.0.tar.gz /s390-tools-2.15.0.tar.gz /s390-tools-2.15.1.tar.gz +/s390-tools-2.16.0.tar.gz diff --git a/s390-tools-2.16.0-genprotimg.patch b/s390-tools-2.16.0-genprotimg.patch new file mode 100644 index 0000000..6f96a14 --- /dev/null +++ b/s390-tools-2.16.0-genprotimg.patch @@ -0,0 +1,1021 @@ +From b6bdd7744aba06d82f30b0c84012f0b06ccb01de Mon Sep 17 00:00:00 2001 +From: Marc Hartmayer +Date: Wed, 24 Feb 2021 15:04:11 +0000 +Subject: [PATCH] genprotimg: use `pv_` namespace for our Buffer implementation +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Use `pv_` namespace for our Buffer implementation so a symbol clash with other +libraries is less likely. + +Fixes: https://github.com/ibm-s390-linux/s390-tools/issues/109 +Reviewed-by: Jan Hoeppner +Signed-off-by: Marc Hartmayer +Signed-off-by: Jan Höppner +--- + genprotimg/src/pv/pv_comp.c | 26 +++++------ + genprotimg/src/pv/pv_comp.h | 4 +- + genprotimg/src/pv/pv_comps.c | 10 ++--- + genprotimg/src/pv/pv_comps.h | 4 +- + genprotimg/src/pv/pv_hdr.c | 24 +++++------ + genprotimg/src/pv/pv_hdr.h | 4 +- + genprotimg/src/pv/pv_image.c | 70 +++++++++++++++--------------- + genprotimg/src/pv/pv_image.h | 14 +++--- + genprotimg/src/pv/pv_ipib.c | 4 +- + genprotimg/src/pv/pv_ipib.h | 2 +- + genprotimg/src/pv/pv_stage3.c | 26 +++++------ + genprotimg/src/pv/pv_stage3.h | 10 ++--- + genprotimg/src/utils/buffer.c | 18 ++++---- + genprotimg/src/utils/buffer.h | 16 +++---- + genprotimg/src/utils/crypto.c | 72 +++++++++++++++---------------- + genprotimg/src/utils/crypto.h | 28 ++++++------ + genprotimg/src/utils/file_utils.c | 4 +- + genprotimg/src/utils/file_utils.h | 2 +- + 18 files changed, 169 insertions(+), 169 deletions(-) + +diff --git a/genprotimg/src/pv/pv_comp.c b/genprotimg/src/pv/pv_comp.c +index 1f64eea8..21879ae7 100644 +--- a/genprotimg/src/pv/pv_comp.c ++++ b/genprotimg/src/pv/pv_comp.c +@@ -73,12 +73,12 @@ PvComponent *pv_component_new_file(PvComponentType type, const gchar *path, + return pv_component_new(type, size, DATA_FILE, (void **)&file, err); + } + +-PvComponent *pv_component_new_buf(PvComponentType type, const Buffer *buf, ++PvComponent *pv_component_new_buf(PvComponentType type, const PvBuffer *buf, + GError **err) + { + g_assert(buf); + +- g_autoptr(Buffer) dup_buf = buffer_dup(buf, FALSE); ++ g_autoptr(PvBuffer) dup_buf = pv_buffer_dup(buf, FALSE); + return pv_component_new(type, buf->size, DATA_BUFFER, (void **)&dup_buf, + err); + } +@@ -90,7 +90,7 @@ void pv_component_free(PvComponent *component) + + switch ((PvComponentDataType)component->d_type) { + case DATA_BUFFER: +- buffer_clear(&component->buf); ++ pv_buffer_clear(&component->buf); + break; + case DATA_FILE: + comp_file_free(component->file); +@@ -162,21 +162,21 @@ gint pv_component_align_and_encrypt(PvComponent *component, const gchar *tmp_pat + + switch ((PvComponentDataType)component->d_type) { + case DATA_BUFFER: { +- g_autoptr(Buffer) enc_buf = NULL; ++ g_autoptr(PvBuffer) enc_buf = NULL; + + if (!(IS_PAGE_ALIGNED(pv_component_size(component)))) { +- g_autoptr(Buffer) new = NULL; ++ g_autoptr(PvBuffer) new = NULL; + + /* create a page aligned copy */ +- new = buffer_dup(component->buf, TRUE); +- buffer_clear(&component->buf); ++ new = pv_buffer_dup(component->buf, TRUE); ++ pv_buffer_clear(&component->buf); + component->buf = g_steal_pointer(&new); + } + enc_buf = encrypt_buf(parms, component->buf, err); + if (!enc_buf) + return -1; + +- buffer_clear(&component->buf); ++ pv_buffer_clear(&component->buf); + component->buf = g_steal_pointer(&enc_buf); + return 0; + } +@@ -220,10 +220,10 @@ gint pv_component_align(PvComponent *component, const gchar *tmp_path, + + switch (component->d_type) { + case DATA_BUFFER: { +- g_autoptr(Buffer) buf = NULL; ++ g_autoptr(PvBuffer) buf = NULL; + +- buf = buffer_dup(component->buf, TRUE); +- buffer_clear(&component->buf); ++ buf = pv_buffer_dup(component->buf, TRUE); ++ pv_buffer_clear(&component->buf); + component->buf = g_steal_pointer(&buf); + return 0; + } break; +@@ -301,7 +301,7 @@ int64_t pv_component_update_pld(const PvComponent *comp, EVP_MD_CTX *ctx, + + switch (comp->d_type) { + case DATA_BUFFER: { +- const Buffer *buf = comp->buf; ++ const PvBuffer *buf = comp->buf; + + g_assert(buf->size <= INT64_MAX); + g_assert(buf->size == size); +@@ -425,7 +425,7 @@ gint pv_component_write(const PvComponent *component, FILE *f, GError **err) + + switch (component->d_type) { + case DATA_BUFFER: { +- const Buffer *buf = component->buf; ++ const PvBuffer *buf = component->buf; + + if (seek_and_write_buffer(f, buf, offset, err) < 0) + return -1; +diff --git a/genprotimg/src/pv/pv_comp.h b/genprotimg/src/pv/pv_comp.h +index aa1b5ae7..a4ffae81 100644 +--- a/genprotimg/src/pv/pv_comp.h ++++ b/genprotimg/src/pv/pv_comp.h +@@ -41,7 +41,7 @@ typedef struct { + gint d_type; /* PvComponentDataType */ + union { + struct comp_file *file; +- Buffer *buf; ++ PvBuffer *buf; + void *data; + }; + uint64_t src_addr; +@@ -51,7 +51,7 @@ typedef struct { + + PvComponent *pv_component_new_file(PvComponentType type, const gchar *path, + GError **err); +-PvComponent *pv_component_new_buf(PvComponentType type, const Buffer *buf, ++PvComponent *pv_component_new_buf(PvComponentType type, const PvBuffer *buf, + GError **err); + void pv_component_free(PvComponent *component); + gint pv_component_type(const PvComponent *component); +diff --git a/genprotimg/src/pv/pv_comps.c b/genprotimg/src/pv/pv_comps.c +index 15d32f09..2d364fd0 100644 +--- a/genprotimg/src/pv/pv_comps.c ++++ b/genprotimg/src/pv/pv_comps.c +@@ -210,13 +210,13 @@ GSList *pv_img_comps_get_comps(const PvImgComps *comps) + return comps->comps; + } + +-gint pv_img_comps_finalize(PvImgComps *comps, Buffer **pld_digest, +- Buffer **ald_digest, Buffer **tld_digest, ++gint pv_img_comps_finalize(PvImgComps *comps, PvBuffer **pld_digest, ++ PvBuffer **ald_digest, PvBuffer **tld_digest, + uint64_t *nep, GError **err) + { +- g_autoptr(Buffer) tmp_pld_digest = NULL; +- g_autoptr(Buffer) tmp_ald_digest = NULL; +- g_autoptr(Buffer) tmp_tld_digest = NULL; ++ g_autoptr(PvBuffer) tmp_pld_digest = NULL; ++ g_autoptr(PvBuffer) tmp_ald_digest = NULL; ++ g_autoptr(PvBuffer) tmp_tld_digest = NULL; + + comps->finalized = TRUE; + for (GSList *iterator = comps->comps; iterator; iterator = iterator->next) { +diff --git a/genprotimg/src/pv/pv_comps.h b/genprotimg/src/pv/pv_comps.h +index d555e36f..891ecdff 100644 +--- a/genprotimg/src/pv/pv_comps.h ++++ b/genprotimg/src/pv/pv_comps.h +@@ -32,8 +32,8 @@ gint pv_img_comps_add_component(PvImgComps *comps, PvComponent **comp, + GError **err); + PvComponent *pv_img_comps_get_nth_comp(PvImgComps *comps, guint n); + gint pv_img_comps_set_offset(PvImgComps *comps, gsize offset, GError **err); +-gint pv_img_comps_finalize(PvImgComps *comps, Buffer **pld_digest, +- Buffer **ald_digest, Buffer **tld_digest, ++gint pv_img_comps_finalize(PvImgComps *comps, PvBuffer **pld_digest, ++ PvBuffer **ald_digest, PvBuffer **tld_digest, + uint64_t *nep, GError **err); + void pv_img_comps_free(PvImgComps *comps); + +diff --git a/genprotimg/src/pv/pv_hdr.c b/genprotimg/src/pv/pv_hdr.c +index 45e721dd..e46e1761 100644 +--- a/genprotimg/src/pv/pv_hdr.c ++++ b/genprotimg/src/pv/pv_hdr.c +@@ -76,17 +76,17 @@ uint64_t pv_hdr_get_nks(const PvHdr *hdr) + } + + /* In-place modification of ``buf`` */ +-static gint pv_hdr_encrypt(const PvHdr *hdr, const PvImage *img, Buffer *buf, ++static gint pv_hdr_encrypt(const PvHdr *hdr, const PvImage *img, PvBuffer *buf, + GError **err) + { + uint32_t hdr_len = pv_hdr_size(hdr); + uint32_t aad_len = pv_hdr_aad_size(hdr); + guint tag_len = pv_hdr_tag_size(hdr); + uint32_t enc_len = pv_hdr_enc_size_casted(hdr); +- const Buffer aad_part = { .data = buf->data, .size = aad_len }; +- Buffer enc_part = { .data = (uint8_t *)buf->data + aad_len, ++ const PvBuffer aad_part = { .data = buf->data, .size = aad_len }; ++ PvBuffer enc_part = { .data = (uint8_t *)buf->data + aad_len, + .size = enc_len }; +- Buffer tag_part = { .data = (uint8_t *)buf->data + hdr_len - tag_len, ++ PvBuffer tag_part = { .data = (uint8_t *)buf->data + hdr_len - tag_len, + .size = tag_len }; + struct cipher_parms parms; + int64_t c_len; +@@ -119,9 +119,9 @@ static gint pv_hdr_aad_init(PvHdr *hdr, const PvImage *img, GError **err) + g_autofree union ecdh_pub_key *cust_pub_key = NULL; + struct pv_hdr_key_slot *hdr_slot = hdr->slots; + struct pv_hdr_head *head = &hdr->head; +- g_autoptr(Buffer) pld = NULL; +- g_autoptr(Buffer) ald = NULL; +- g_autoptr(Buffer) tld = NULL; ++ g_autoptr(PvBuffer) pld = NULL; ++ g_autoptr(PvBuffer) ald = NULL; ++ g_autoptr(PvBuffer) tld = NULL; + uint64_t nep = 0; + + g_assert(sizeof(head->iv) == img->gcm_iv->size); +@@ -250,7 +250,7 @@ PvHdr *pv_hdr_new(const PvImage *img, GError **err) + return g_steal_pointer(&ret); + } + +-static void pv_hdr_memcpy(const PvHdr *hdr, const Buffer *dst) ++static void pv_hdr_memcpy(const PvHdr *hdr, const PvBuffer *dst) + { + uint64_t nks = pv_hdr_get_nks(hdr); + uint8_t *data; +@@ -270,13 +270,13 @@ static void pv_hdr_memcpy(const PvHdr *hdr, const Buffer *dst) + } + } + +-Buffer *pv_hdr_serialize(const PvHdr *hdr, const PvImage *img, +- enum PvCryptoMode mode, GError **err) ++PvBuffer *pv_hdr_serialize(const PvHdr *hdr, const PvImage *img, ++ enum PvCryptoMode mode, GError **err) + { + uint32_t hdr_size = pv_hdr_size(hdr); +- g_autoptr(Buffer) ret = NULL; ++ g_autoptr(PvBuffer) ret = NULL; + +- ret = buffer_alloc(hdr_size); ++ ret = pv_buffer_alloc(hdr_size); + pv_hdr_memcpy(hdr, ret); + + if (mode == PV_ENCRYPT) { +diff --git a/genprotimg/src/pv/pv_hdr.h b/genprotimg/src/pv/pv_hdr.h +index 8df7a6f1..fbcc9e9e 100644 +--- a/genprotimg/src/pv/pv_hdr.h ++++ b/genprotimg/src/pv/pv_hdr.h +@@ -23,8 +23,8 @@ + PvHdr *pv_hdr_new(const PvImage *img, GError **err); + void pv_hdr_free(PvHdr *hdr); + G_GNUC_UNUSED gboolean pv_hdr_uses_encryption(const PvHdr *hdr); +-Buffer *pv_hdr_serialize(const PvHdr *hdr, const PvImage *img, +- enum PvCryptoMode mode, GError **err); ++PvBuffer *pv_hdr_serialize(const PvHdr *hdr, const PvImage *img, ++ enum PvCryptoMode mode, GError **err); + uint32_t pv_hdr_size(const PvHdr *hdr); + uint32_t pv_hdr_aad_size(const PvHdr *hdr); + uint64_t pv_hdr_enc_size(const PvHdr *hdr); +diff --git a/genprotimg/src/pv/pv_image.c b/genprotimg/src/pv/pv_image.c +index 59eca5e3..375e40f6 100644 +--- a/genprotimg/src/pv/pv_image.c ++++ b/genprotimg/src/pv/pv_image.c +@@ -56,7 +56,7 @@ static gint pv_img_prepare_component(const PvImage *img, PvComponent *comp, + GError **err) + { + struct cipher_parms parms = { 0 }; +- g_autoptr(Buffer) tweak = NULL; ++ g_autoptr(PvBuffer) tweak = NULL; + prepare_func func = NULL; + void *opaque = NULL; + gint rc; +@@ -76,7 +76,7 @@ static gint pv_img_prepare_component(const PvImage *img, PvComponent *comp, + EVP_CIPHER_iv_length(cipher)); + g_assert(img->xts_key->size <= UINT_MAX); + +- tweak = buffer_alloc(sizeof(comp->tweak.data)); ++ tweak = pv_buffer_alloc(sizeof(comp->tweak.data)); + memcpy(tweak->data, comp->tweak.data, tweak->size); + func = pv_component_align_and_encrypt; + parms.cipher = cipher; +@@ -93,11 +93,11 @@ static gint pv_img_prepare_component(const PvImage *img, PvComponent *comp, + return 0; + } + +-static Buffer *pv_img_read_key(const gchar *path, guint key_size, +- GError **err) ++static PvBuffer *pv_img_read_key(const gchar *path, guint key_size, ++ GError **err) + { +- g_autoptr(Buffer) tmp_ret = NULL; +- Buffer *ret = NULL; ++ g_autoptr(PvBuffer) tmp_ret = NULL; ++ PvBuffer *ret = NULL; + gsize bytes_read; + FILE *f = NULL; + gsize size; +@@ -116,7 +116,7 @@ static Buffer *pv_img_read_key(const gchar *path, guint key_size, + if (!f) + return NULL; + +- tmp_ret = buffer_alloc(size); ++ tmp_ret = pv_buffer_alloc(size); + if (file_read(f, tmp_ret->data, 1, tmp_ret->size, &bytes_read, err) < 0) + goto err; + +@@ -160,8 +160,8 @@ static HostKeyList *pv_img_get_host_keys(GSList *host_keys_with_path, gint nid, + return g_steal_pointer(&ret); + } + +-static Buffer *pv_img_get_key(const EVP_CIPHER *cipher, const gchar *path, +- GError **err) ++static PvBuffer *pv_img_get_key(const EVP_CIPHER *cipher, const gchar *path, ++ GError **err) + { + gint key_len = EVP_CIPHER_key_length(cipher); + +@@ -173,8 +173,8 @@ static Buffer *pv_img_get_key(const EVP_CIPHER *cipher, const gchar *path, + return generate_aes_key((guint)key_len, err); + } + +-static Buffer *pv_img_get_iv(const EVP_CIPHER *cipher, const gchar *path, +- GError **err) ++static PvBuffer *pv_img_get_iv(const EVP_CIPHER *cipher, const gchar *path, ++ GError **err) + { + gint iv_len = EVP_CIPHER_iv_length(cipher); + +@@ -485,23 +485,23 @@ static void pv_hdr_key_slot_free(PvHdrKeySlot *slot) + WRAPPED_G_DEFINE_AUTOPTR_CLEANUP_FUNC(PvHdrKeySlot, pv_hdr_key_slot_free) + + static PvHdrKeySlot *pv_hdr_key_slot_new(const EVP_CIPHER *gcm_cipher, +- const Buffer *cust_root_key, ++ const PvBuffer *cust_root_key, + EVP_PKEY *cust_key, EVP_PKEY *host_key, + GError **err) + { + g_autoptr(PvHdrKeySlot) ret = g_new0(PvHdrKeySlot, 1); + g_autofree union ecdh_pub_key *pub = NULL; +- g_autoptr(Buffer) exchange_key = NULL; +- g_autoptr(Buffer) digest_key = NULL; +- g_autoptr(Buffer) iv = NULL; +- Buffer pub_buf; ++ g_autoptr(PvBuffer) exchange_key = NULL; ++ g_autoptr(PvBuffer) digest_key = NULL; ++ g_autoptr(PvBuffer) iv = NULL; ++ PvBuffer pub_buf; + /* No AAD data is used */ +- Buffer aad = { .data = NULL, .size = 0 }; ++ PvBuffer aad = { .data = NULL, .size = 0 }; + /* Set the output buffers for the encrypted data and the + * generated GCM tag + */ +- Buffer enc = { .data = ret->wrapped_key, .size = sizeof(ret->wrapped_key) }; +- Buffer tag = { .data = ret->tag, .size = sizeof(ret->tag) }; ++ PvBuffer enc = { .data = ret->wrapped_key, .size = sizeof(ret->wrapped_key) }; ++ PvBuffer tag = { .data = ret->tag, .size = sizeof(ret->tag) }; + struct cipher_parms parms; + int64_t c_len = 0; + +@@ -530,7 +530,7 @@ static PvHdrKeySlot *pv_hdr_key_slot_new(const EVP_CIPHER *gcm_cipher, + g_assert(exchange_key->size == (guint)EVP_CIPHER_key_length(gcm_cipher)); + + /* create zero IV */ +- iv = buffer_alloc((guint)EVP_CIPHER_iv_length(gcm_cipher)); ++ iv = pv_buffer_alloc((guint)EVP_CIPHER_iv_length(gcm_cipher)); + parms.iv_or_tweak = iv; + parms.key = exchange_key; + parms.cipher = gcm_cipher; +@@ -637,13 +637,13 @@ void pv_img_free(PvImage *img) + g_slist_free_full(img->key_slots, (GDestroyNotify)pv_hdr_key_slot_free); + g_slist_free_full(img->host_pub_keys, (GDestroyNotify)EVP_PKEY_free); + EVP_PKEY_free(img->cust_pub_priv_key); +- buffer_clear(&img->stage3a); ++ pv_buffer_clear(&img->stage3a); + pv_img_comps_free(img->comps); + g_free(img->tmp_dir); +- buffer_free(img->xts_key); +- buffer_free(img->cust_root_key); +- buffer_free(img->gcm_iv); +- buffer_free(img->cust_comm_key); ++ pv_buffer_free(img->xts_key); ++ pv_buffer_free(img->cust_root_key); ++ pv_buffer_free(img->gcm_iv); ++ pv_buffer_free(img->cust_comm_key); + g_free(img); + } + +@@ -684,13 +684,13 @@ gint pv_img_add_component(PvImage *img, const PvArg *arg, GError **err) + return 0; + } + +-gint pv_img_calc_pld_ald_tld_nep(const PvImage *img, Buffer **pld, Buffer **ald, +- Buffer **tld, uint64_t *nep, GError **err) ++gint pv_img_calc_pld_ald_tld_nep(const PvImage *img, PvBuffer **pld, PvBuffer **ald, ++ PvBuffer **tld, uint64_t *nep, GError **err) + { + return pv_img_comps_finalize(img->comps, pld, ald, tld, nep, err); + } + +-static gint pv_img_build_stage3b(PvImage *img, Buffer *stage3b, GError **err) ++static gint pv_img_build_stage3b(PvImage *img, PvBuffer *stage3b, GError **err) + { + g_autofree struct stage3b_args *args = NULL; + +@@ -708,7 +708,7 @@ static gint pv_img_build_stage3b(PvImage *img, Buffer *stage3b, GError **err) + gint pv_img_add_stage3b_comp(PvImage *img, const gchar *path, GError **err) + { + g_autoptr(PvComponent) comp = NULL; +- g_autoptr(Buffer) stage3b = NULL; ++ g_autoptr(PvBuffer) stage3b = NULL; + + stage3b = stage3b_getblob(path, err); + if (!stage3b) +@@ -825,7 +825,7 @@ static gint get_stage3a_data_size(const PvImage *img, gsize *data_size, + + gint pv_img_load_and_set_stage3a(PvImage *img, const gchar *path, GError **err) + { +- g_autoptr(Buffer) stage3a = NULL; ++ g_autoptr(PvBuffer) stage3a = NULL; + gsize bin_size, data_size = 0; + + if (get_stage3a_data_size(img, &data_size, err) < 0) +@@ -845,8 +845,8 @@ gint pv_img_load_and_set_stage3a(PvImage *img, const gchar *path, GError **err) + } + + /* Creates the PV IPIB and sets the stage3a arguments */ +-static gint pv_img_build_stage3a(Buffer *stage3a, gsize stage3a_bin_size, +- GSList *comps, const Buffer *hdr, GError **err) ++static gint pv_img_build_stage3a(PvBuffer *stage3a, gsize stage3a_bin_size, ++ GSList *comps, const PvBuffer *hdr, GError **err) + { + g_autofree struct ipl_parameter_block *ipib = NULL; + +@@ -866,9 +866,9 @@ static gint pv_img_build_stage3a(Buffer *stage3a, gsize stage3a_bin_size, + } + + /* Creates the actual PV header (serialized and AES-GCM encrypted) */ +-static Buffer *pv_img_create_pv_hdr(PvImage *img, GError **err) ++static PvBuffer *pv_img_create_pv_hdr(PvImage *img, GError **err) + { +- g_autoptr(Buffer) hdr_buf = NULL; ++ g_autoptr(PvBuffer) hdr_buf = NULL; + g_autoptr(PvHdr) hdr = NULL; + + hdr = pv_hdr_new(img, err); +@@ -887,7 +887,7 @@ static Buffer *pv_img_create_pv_hdr(PvImage *img, GError **err) + */ + gint pv_img_finalize(PvImage *pv, const gchar *stage3b_path, GError **err) + { +- g_autoptr(Buffer) hdr = NULL; ++ g_autoptr(PvBuffer) hdr = NULL; + + /* load stage3b template into memory and add it to the list of + * components. This must be done before calling +diff --git a/genprotimg/src/pv/pv_image.h b/genprotimg/src/pv/pv_image.h +index 7c624e24..116fb1a9 100644 +--- a/genprotimg/src/pv/pv_image.h ++++ b/genprotimg/src/pv/pv_image.h +@@ -25,7 +25,7 @@ + + typedef struct { + gchar *tmp_dir; /* directory used for temporary files */ +- Buffer *stage3a; /* stage3a containing IPIB and PV header */ ++ PvBuffer *stage3a; /* stage3a containing IPIB and PV header */ + gsize stage3a_bin_size; /* size of stage3a.bin */ + struct psw_t stage3a_psw; /* (short) PSW that is written to + * location 0 of the created image +@@ -35,15 +35,15 @@ typedef struct { + GSList *host_pub_keys; /* public host keys */ + gint nid; /* Elliptic Curve used for the key derivation */ + /* keys and cipher used for the AES-GCM encryption */ +- Buffer *cust_root_key; +- Buffer *gcm_iv; ++ PvBuffer *cust_root_key; ++ PvBuffer *gcm_iv; + const EVP_CIPHER *gcm_cipher; + /* Information for the IPIB and PV header */ + uint64_t pcf; + uint64_t scf; +- Buffer *cust_comm_key; ++ PvBuffer *cust_comm_key; + const EVP_CIPHER *cust_comm_cipher; +- Buffer *xts_key; ++ PvBuffer *xts_key; + const EVP_CIPHER *xts_cipher; + GSList *key_slots; + GSList *optional_items; +@@ -54,8 +54,8 @@ PvImage *pv_img_new(PvArgs *args, const gchar *stage3a_path, GError **err); + void pv_img_free(PvImage *img); + gint pv_img_add_component(PvImage *img, const PvArg *arg, GError **err); + gint pv_img_finalize(PvImage *img, const gchar *stage3b_path, GError **err); +-gint pv_img_calc_pld_ald_tld_nep(const PvImage *img, Buffer **pld, Buffer **ald, +- Buffer **tld, uint64_t *nep, GError **err); ++gint pv_img_calc_pld_ald_tld_nep(const PvImage *img, PvBuffer **pld, PvBuffer **ald, ++ PvBuffer **tld, uint64_t *nep, GError **err); + gint pv_img_load_and_set_stage3a(PvImage *img, const gchar *path, GError **err); + const PvComponent *pv_img_get_stage3b_comp(const PvImage *img, GError **err); + gint pv_img_add_stage3b_comp(PvImage *img, const gchar *path, GError **err); +diff --git a/genprotimg/src/pv/pv_ipib.c b/genprotimg/src/pv/pv_ipib.c +index 2517e548..59fe0086 100644 +--- a/genprotimg/src/pv/pv_ipib.c ++++ b/genprotimg/src/pv/pv_ipib.c +@@ -35,7 +35,7 @@ uint64_t pv_ipib_get_size(uint32_t num_comp) + } + + static gint pv_ipib_init(IplParameterBlock *ipib, GSList *comps, +- const Buffer *hdr) ++ const PvBuffer *hdr) + { + g_assert(sizeof(struct ipl_pl_hdr) <= UINT32_MAX); + g_assert(sizeof(struct ipl_pb0_pv_comp) <= UINT32_MAX); +@@ -100,7 +100,7 @@ static gint pv_ipib_init(IplParameterBlock *ipib, GSList *comps, + return 0; + } + +-IplParameterBlock *pv_ipib_new(GSList *comps, const Buffer *hdr, GError **err) ++IplParameterBlock *pv_ipib_new(GSList *comps, const PvBuffer *hdr, GError **err) + { + uint64_t ipib_size = pv_ipib_get_size(g_slist_length(comps)); + g_autoptr(IplParameterBlock) ret = NULL; +diff --git a/genprotimg/src/pv/pv_ipib.h b/genprotimg/src/pv/pv_ipib.h +index 93317901..4b66643d 100644 +--- a/genprotimg/src/pv/pv_ipib.h ++++ b/genprotimg/src/pv/pv_ipib.h +@@ -19,7 +19,7 @@ + typedef struct ipl_parameter_block IplParameterBlock; + + uint64_t pv_ipib_get_size(uint32_t num_comp); +-IplParameterBlock *pv_ipib_new(GSList *comps, const Buffer *hdr, GError **err); ++IplParameterBlock *pv_ipib_new(GSList *comps, const PvBuffer *hdr, GError **err); + void pv_ipib_free(IplParameterBlock *ipib); + + WRAPPED_G_DEFINE_AUTOPTR_CLEANUP_FUNC(IplParameterBlock, pv_ipib_free) +diff --git a/genprotimg/src/pv/pv_stage3.c b/genprotimg/src/pv/pv_stage3.c +index a1e5b164..bff9db7d 100644 +--- a/genprotimg/src/pv/pv_stage3.c ++++ b/genprotimg/src/pv/pv_stage3.c +@@ -24,12 +24,12 @@ + ((struct stage3a_args *)((uint64_t)data_ptr + loader_size - \ + sizeof(struct stage3a_args))) + +-static Buffer *loader_getblob(const gchar *filename, gsize *loader_size, +- gsize args_size, gsize data_size, +- gboolean data_aligned, GError **err) ++static PvBuffer *loader_getblob(const gchar *filename, gsize *loader_size, ++ gsize args_size, gsize data_size, ++ gboolean data_aligned, GError **err) + { + g_autoptr(GMappedFile) mapped_file = NULL; +- g_autoptr(Buffer) ret = NULL; ++ g_autoptr(PvBuffer) ret = NULL; + gsize size, tmp_loader_size; + gchar *loader_data; + +@@ -60,7 +60,7 @@ static Buffer *loader_getblob(const gchar *filename, gsize *loader_size, + size = (data_aligned ? PAGE_ALIGN(tmp_loader_size) : tmp_loader_size) + + data_size; + +- ret = buffer_alloc(size); ++ ret = pv_buffer_alloc(size); + + /* copy the loader "template" */ + memcpy(ret->data, loader_data, tmp_loader_size); +@@ -71,8 +71,8 @@ static Buffer *loader_getblob(const gchar *filename, gsize *loader_size, + return g_steal_pointer(&ret); + } + +-Buffer *stage3a_getblob(const gchar *filename, gsize *loader_size, +- gsize data_size, GError **err) ++PvBuffer *stage3a_getblob(const gchar *filename, gsize *loader_size, ++ gsize data_size, GError **err) + { + return loader_getblob(filename, loader_size, + sizeof(struct stage3a_args), data_size, TRUE, +@@ -83,8 +83,8 @@ Buffer *stage3a_getblob(const gchar *filename, gsize *loader_size, + /* Set the right offsets and sizes in the stage3a template + add + * the IPIB block with the PV header + */ +-static gint stage3a_set_data(Buffer *loader, gsize loader_size, +- const Buffer *hdr, struct ipl_parameter_block *ipib, ++static gint stage3a_set_data(PvBuffer *loader, gsize loader_size, ++ const PvBuffer *hdr, struct ipl_parameter_block *ipib, + GError **err) + { + uint32_t ipib_size = GUINT32_FROM_BE(ipib->hdr.len); +@@ -126,15 +126,15 @@ static gint stage3a_set_data(Buffer *loader, gsize loader_size, + return 0; + } + +-gint build_stage3a(Buffer *loader, gsize loader_size, const Buffer *hdr, ++gint build_stage3a(PvBuffer *loader, gsize loader_size, const PvBuffer *hdr, + struct ipl_parameter_block *ipib, GError **err) + { + return stage3a_set_data(loader, loader_size, hdr, ipib, err); + } + +-Buffer *stage3b_getblob(const gchar *filename, GError **err) ++PvBuffer *stage3b_getblob(const gchar *filename, GError **err) + { +- g_autoptr(Buffer) ret = NULL; ++ g_autoptr(PvBuffer) ret = NULL; + gsize rb_size; + + ret = loader_getblob(filename, &rb_size, sizeof(struct stage3b_args), 0, +@@ -146,7 +146,7 @@ Buffer *stage3b_getblob(const gchar *filename, GError **err) + return g_steal_pointer(&ret); + } + +-void build_stage3b(Buffer *stage3b, const struct stage3b_args *args) ++void build_stage3b(PvBuffer *stage3b, const struct stage3b_args *args) + { + g_assert(stage3b->size > sizeof(*args)); + +diff --git a/genprotimg/src/pv/pv_stage3.h b/genprotimg/src/pv/pv_stage3.h +index baaf921b..364408ee 100644 +--- a/genprotimg/src/pv/pv_stage3.h ++++ b/genprotimg/src/pv/pv_stage3.h +@@ -19,12 +19,12 @@ + #include "boot/stage3b.h" + #include "utils/buffer.h" + +-Buffer *stage3a_getblob(const gchar *filename, gsize *loader_size, +- gsize data_size, GError **err); +-gint build_stage3a(Buffer *dc, gsize dc_size, const Buffer *hdr, ++PvBuffer *stage3a_getblob(const gchar *filename, gsize *loader_size, ++ gsize data_size, GError **err); ++gint build_stage3a(PvBuffer *dc, gsize dc_size, const PvBuffer *hdr, + struct ipl_parameter_block *ipib, GError **err); +-Buffer *stage3b_getblob(const gchar *filename, GError **err); +-void build_stage3b(Buffer *stage3b, const struct stage3b_args *args); ++PvBuffer *stage3b_getblob(const gchar *filename, GError **err); ++void build_stage3b(PvBuffer *stage3b, const struct stage3b_args *args); + void memblob_init(struct memblob *arg, uint64_t src, uint64_t size); + + #endif +diff --git a/genprotimg/src/utils/buffer.c b/genprotimg/src/utils/buffer.c +index 35aed742..509dc0de 100644 +--- a/genprotimg/src/utils/buffer.c ++++ b/genprotimg/src/utils/buffer.c +@@ -17,18 +17,18 @@ + #include "common.h" + #include "file_utils.h" + +-Buffer *buffer_alloc(gsize size) ++PvBuffer *pv_buffer_alloc(gsize size) + { +- Buffer *ret = g_new0(Buffer, 1); ++ PvBuffer *ret = g_new0(PvBuffer, 1); + + ret->data = g_malloc0(size); + ret->size = size; + return ret; + } + +-Buffer *buffer_dup(const Buffer *buf, gboolean page_aligned) ++PvBuffer *pv_buffer_dup(const PvBuffer *buf, gboolean page_aligned) + { +- Buffer *ret; ++ PvBuffer *ret; + gsize size; + + if (!buf) +@@ -38,19 +38,19 @@ Buffer *buffer_dup(const Buffer *buf, gboolean page_aligned) + if (page_aligned) + size = PAGE_ALIGN(size); + +- ret = buffer_alloc(size); ++ ret = pv_buffer_alloc(size); + + /* content will be 0-right-padded */ + memcpy(ret->data, buf->data, buf->size); + return ret; + } + +-gint buffer_write(const Buffer *buf, FILE *file, GError **err) ++gint pv_buffer_write(const PvBuffer *buf, FILE *file, GError **err) + { + return file_write(file, buf->data, buf->size, 1, NULL, err); + } + +-void buffer_free(Buffer *buf) ++void pv_buffer_free(PvBuffer *buf) + { + if (!buf) + return; +@@ -59,11 +59,11 @@ void buffer_free(Buffer *buf) + g_free(buf); + } + +-void buffer_clear(Buffer **buf) ++void pv_buffer_clear(PvBuffer **buf) + { + if (!buf || !*buf) + return; + +- buffer_free(*buf); ++ pv_buffer_free(*buf); + *buf = NULL; + } +diff --git a/genprotimg/src/utils/buffer.h b/genprotimg/src/utils/buffer.h +index 7239d5c9..824b72cb 100644 +--- a/genprotimg/src/utils/buffer.h ++++ b/genprotimg/src/utils/buffer.h +@@ -15,17 +15,17 @@ + + #include "common.h" + +-typedef struct Buffer { ++typedef struct PvBuffer { + void *data; + gsize size; /* in bytes */ +-} Buffer; ++} PvBuffer; + +-Buffer *buffer_alloc(gsize size); +-void buffer_free(Buffer *buf); +-void buffer_clear(Buffer **buf); +-gint buffer_write(const Buffer *buf, FILE *file, GError **err); +-Buffer *buffer_dup(const Buffer *buf, gboolean page_aligned); ++PvBuffer *pv_buffer_alloc(gsize size); ++void pv_buffer_free(PvBuffer *buf); ++void pv_buffer_clear(PvBuffer **buf); ++gint pv_buffer_write(const PvBuffer *buf, FILE *file, GError **err); ++PvBuffer *pv_buffer_dup(const PvBuffer *buf, gboolean page_aligned); + +-WRAPPED_G_DEFINE_AUTOPTR_CLEANUP_FUNC(Buffer, buffer_free) ++WRAPPED_G_DEFINE_AUTOPTR_CLEANUP_FUNC(PvBuffer, pv_buffer_free) + + #endif +diff --git a/genprotimg/src/utils/crypto.c b/genprotimg/src/utils/crypto.c +index 44facc28..05c3e832 100644 +--- a/genprotimg/src/utils/crypto.c ++++ b/genprotimg/src/utils/crypto.c +@@ -89,15 +89,15 @@ EVP_MD_CTX *digest_ctx_new(const EVP_MD *md, GError **err) + return g_steal_pointer(&ctx); + } + +-Buffer *digest_ctx_finalize(EVP_MD_CTX *ctx, GError **err) ++PvBuffer *digest_ctx_finalize(EVP_MD_CTX *ctx, GError **err) + { + gint md_size = EVP_MD_size(EVP_MD_CTX_md(ctx)); +- g_autoptr(Buffer) ret = NULL; ++ g_autoptr(PvBuffer) ret = NULL; + guint digest_size; + + g_assert(md_size > 0); + +- ret = buffer_alloc((guint)md_size); ++ ret = pv_buffer_alloc((guint)md_size); + if (EVP_DigestFinal_ex(ctx, ret->data, &digest_size) != 1) { + g_set_error(err, PV_CRYPTO_ERROR, PV_CRYPTO_ERROR_INTERNAL, + _("EVP_DigestFinal_ex failed")); +@@ -110,10 +110,10 @@ Buffer *digest_ctx_finalize(EVP_MD_CTX *ctx, GError **err) + } + + /* Returns the digest of @buf using the hash algorithm @md */ +-static Buffer *digest_buffer(const EVP_MD *md, const Buffer *buf, GError **err) ++static PvBuffer *digest_buffer(const EVP_MD *md, const PvBuffer *buf, GError **err) + { + g_autoptr(EVP_MD_CTX) md_ctx = NULL; +- g_autoptr(Buffer) ret = NULL; ++ g_autoptr(PvBuffer) ret = NULL; + g_assert(buf); + + md_ctx = digest_ctx_new(md, err); +@@ -134,9 +134,9 @@ static Buffer *digest_buffer(const EVP_MD *md, const Buffer *buf, GError **err) + } + + /* Returns the SHA256 digest of @buf */ +-Buffer *sha256_buffer(const Buffer *buf, GError **err) ++PvBuffer *sha256_buffer(const PvBuffer *buf, GError **err) + { +- g_autoptr(Buffer) ret = NULL; ++ g_autoptr(PvBuffer) ret = NULL; + + ret = digest_buffer(EVP_sha256(), buf, err); + if (!ret) +@@ -207,10 +207,10 @@ union ecdh_pub_key *evp_pkey_to_ecdh_pub_key(EVP_PKEY *key, GError **err) + return g_steal_pointer(&ret); + } + +-static Buffer *derive_key(EVP_PKEY *cust, EVP_PKEY *host, GError **err) ++static PvBuffer *derive_key(EVP_PKEY *cust, EVP_PKEY *host, GError **err) + { + g_autoptr(EVP_PKEY_CTX) ctx = NULL; +- g_autoptr(Buffer) ret = NULL; ++ g_autoptr(PvBuffer) ret = NULL; + gsize key_size; + + ctx = EVP_PKEY_CTX_new(cust, NULL); +@@ -236,7 +236,7 @@ static Buffer *derive_key(EVP_PKEY *cust, EVP_PKEY *host, GError **err) + return NULL; + } + +- ret = buffer_alloc(key_size); ++ ret = pv_buffer_alloc(key_size); + if (EVP_PKEY_derive(ctx, ret->data, &key_size) != 1) { + g_set_error(err, PV_CRYPTO_ERROR, PV_CRYPTO_ERROR_DERIVE, + _("Key derivation failed")); +@@ -247,11 +247,11 @@ static Buffer *derive_key(EVP_PKEY *cust, EVP_PKEY *host, GError **err) + return g_steal_pointer(&ret); + } + +-Buffer *compute_exchange_key(EVP_PKEY *cust, EVP_PKEY *host, GError **err) ++PvBuffer *compute_exchange_key(EVP_PKEY *cust, EVP_PKEY *host, GError **err) + { +- g_autoptr(Buffer) raw = buffer_alloc(70); +- g_autoptr(Buffer) ret = NULL; +- g_autoptr(Buffer) key = NULL; ++ g_autoptr(PvBuffer) raw = pv_buffer_alloc(70); ++ g_autoptr(PvBuffer) ret = NULL; ++ g_autoptr(PvBuffer) key = NULL; + guchar *data; + + key = derive_key(cust, host, err); +@@ -290,10 +290,10 @@ gint generate_tweak(union tweak *tweak, uint16_t i, GError **err) + return 0; + } + +-static Buffer *generate_rand_data(guint size, const gchar *err_msg, +- GError **err) ++static PvBuffer *generate_rand_data(guint size, const gchar *err_msg, ++ GError **err) + { +- g_autoptr(Buffer) buf = buffer_alloc(size); ++ g_autoptr(PvBuffer) buf = pv_buffer_alloc(size); + + g_assert(size <= INT_MAX); + +@@ -307,14 +307,14 @@ static Buffer *generate_rand_data(guint size, const gchar *err_msg, + return g_steal_pointer(&buf); + } + +-Buffer *generate_aes_iv(guint size, GError **err) ++PvBuffer *generate_aes_iv(guint size, GError **err) + { + return generate_rand_data(size, + _("Generating a IV failed because the required amount of random data is not available"), + err); + } + +-Buffer *generate_aes_key(guint size, GError **err) ++PvBuffer *generate_aes_key(guint size, GError **err) + { + return generate_rand_data(size, + _("Generating a key failed because the required amount of random data is not available"), +@@ -1756,8 +1756,8 @@ static gint __encrypt_decrypt_bio(const struct cipher_parms *parms, BIO *b_in, + gint cipher_block_size = EVP_CIPHER_block_size(cipher); + guchar in_buf[PAGE_SIZE], + out_buf[PAGE_SIZE + (guint)cipher_block_size]; +- const Buffer *key = parms->key; +- const Buffer *tweak = parms->iv_or_tweak; ++ const PvBuffer *key = parms->key; ++ const PvBuffer *tweak = parms->iv_or_tweak; + g_autofree guchar *tmp_tweak = NULL; + gint out_len, tweak_size; + gsize tmp_size_in = 0, tmp_size_out = 0; +@@ -1895,11 +1895,11 @@ static gint __encrypt_decrypt_bio(const struct cipher_parms *parms, BIO *b_in, + return 0; + } + +-static Buffer *__encrypt_decrypt_buffer(const struct cipher_parms *parms, +- const Buffer *in, gboolean encrypt, +- GError **err) ++static PvBuffer *__encrypt_decrypt_buffer(const struct cipher_parms *parms, ++ const PvBuffer *in, gboolean encrypt, ++ GError **err) + { +- g_autoptr(Buffer) ret = NULL; ++ g_autoptr(PvBuffer) ret = NULL; + g_autoptr(BIO) b_out = NULL; + g_autoptr(BIO) b_in = NULL; + gsize in_size, out_size; +@@ -1927,19 +1927,19 @@ static Buffer *__encrypt_decrypt_buffer(const struct cipher_parms *parms, + return NULL; + } + +- ret = buffer_alloc((unsigned long)data_size); ++ ret = pv_buffer_alloc((unsigned long)data_size); + memcpy(ret->data, data, ret->size); + return g_steal_pointer(&ret); + } + +-Buffer *encrypt_buf(const struct cipher_parms *parms, const Buffer *in, +- GError **err) ++PvBuffer *encrypt_buf(const struct cipher_parms *parms, const PvBuffer *in, ++ GError **err) + { + return __encrypt_decrypt_buffer(parms, in, TRUE, err); + } + +-Buffer *decrypt_buf(const struct cipher_parms *parms, const Buffer *in, +- GError **err) ++PvBuffer *decrypt_buf(const struct cipher_parms *parms, const PvBuffer *in, ++ GError **err) + { + return __encrypt_decrypt_buffer(parms, in, FALSE, err); + } +@@ -1993,16 +1993,16 @@ G_GNUC_UNUSED static gint decrypt_file(const struct cipher_parms *parms, + } + + /* GCM mode uses (zero-)padding */ +-static int64_t gcm_encrypt_decrypt(const Buffer *in, const Buffer *aad, ++static int64_t gcm_encrypt_decrypt(const PvBuffer *in, const PvBuffer *aad, + const struct cipher_parms *parms, +- Buffer *out, Buffer *tag, ++ PvBuffer *out, PvBuffer *tag, + enum PvCryptoMode mode, GError **err) + { + g_autoptr(EVP_CIPHER_CTX) ctx = NULL; + const EVP_CIPHER *cipher = parms->cipher; +- const Buffer *iv = parms->iv_or_tweak; ++ const PvBuffer *iv = parms->iv_or_tweak; + gboolean encrypt = mode == PV_ENCRYPT; +- const Buffer *key = parms->key; ++ const PvBuffer *key = parms->key; + int64_t ret = -1; + gint len = -1; + +@@ -2097,8 +2097,8 @@ static int64_t gcm_encrypt_decrypt(const Buffer *in, const Buffer *aad, + return ret; + } + +-int64_t gcm_encrypt(const Buffer *in, const Buffer *aad, +- const struct cipher_parms *parms, Buffer *out, Buffer *tag, ++int64_t gcm_encrypt(const PvBuffer *in, const PvBuffer *aad, ++ const struct cipher_parms *parms, PvBuffer *out, PvBuffer *tag, + GError **err) + { + return gcm_encrypt_decrypt(in, aad, parms, out, tag, PV_ENCRYPT, err); +diff --git a/genprotimg/src/utils/crypto.h b/genprotimg/src/utils/crypto.h +index 286cf457..3cda4507 100644 +--- a/genprotimg/src/utils/crypto.h ++++ b/genprotimg/src/utils/crypto.h +@@ -117,8 +117,8 @@ union tweak { + + struct cipher_parms { + const EVP_CIPHER *cipher; +- const Buffer *key; +- const Buffer *iv_or_tweak; ++ const PvBuffer *key; ++ const PvBuffer *iv_or_tweak; + }; + + int check_crl_valid_for_cert(X509_CRL *crl, X509 *cert, +@@ -152,24 +152,24 @@ X509_CRL *get_first_valid_crl(X509_STORE_CTX *ctx, X509 *cert, GError **err); + void store_setup_crl_download(X509_STORE *st); + EVP_PKEY *read_ec_pubkey_cert(X509 *cert, gint nid, GError **err); + +-Buffer *compute_exchange_key(EVP_PKEY *cust, EVP_PKEY *host, GError **err); +-Buffer *generate_aes_key(guint size, GError **err); +-Buffer *generate_aes_iv(guint size, GError **err); ++PvBuffer *compute_exchange_key(EVP_PKEY *cust, EVP_PKEY *host, GError **err); ++PvBuffer *generate_aes_key(guint size, GError **err); ++PvBuffer *generate_aes_iv(guint size, GError **err); + EVP_PKEY *generate_ec_key(gint nid, GError **err); + gint generate_tweak(union tweak *tweak, uint16_t i, GError **err); + union ecdh_pub_key *evp_pkey_to_ecdh_pub_key(EVP_PKEY *key, GError **err); + EVP_MD_CTX *digest_ctx_new(const EVP_MD *md, GError **err); +-Buffer *digest_ctx_finalize(EVP_MD_CTX *ctx, GError **err); +-Buffer *sha256_buffer(const Buffer *buf, GError **err); +-int64_t gcm_encrypt(const Buffer *in, const Buffer *aad, +- const struct cipher_parms *parms, Buffer *out, +- Buffer *tag, GError **err); ++PvBuffer *digest_ctx_finalize(EVP_MD_CTX *ctx, GError **err); ++PvBuffer *sha256_buffer(const PvBuffer *buf, GError **err); ++int64_t gcm_encrypt(const PvBuffer *in, const PvBuffer *aad, ++ const struct cipher_parms *parms, PvBuffer *out, ++ PvBuffer *tag, GError **err); + gint encrypt_file(const struct cipher_parms *parms, const gchar *in_path, + const gchar *path_out, gsize *in_size, gsize *out_size, + GError **err); +-Buffer *encrypt_buf(const struct cipher_parms *parms, const Buffer *in, +- GError **err); +-G_GNUC_UNUSED Buffer *decrypt_buf(const struct cipher_parms *parms, +- const Buffer *in, GError **err); ++PvBuffer *encrypt_buf(const struct cipher_parms *parms, const PvBuffer *in, ++ GError **err); ++G_GNUC_UNUSED PvBuffer *decrypt_buf(const struct cipher_parms *parms, ++ const PvBuffer *in, GError **err); + + #endif +diff --git a/genprotimg/src/utils/file_utils.c b/genprotimg/src/utils/file_utils.c +index 1d6fc370..ba33400f 100644 +--- a/genprotimg/src/utils/file_utils.c ++++ b/genprotimg/src/utils/file_utils.c +@@ -171,13 +171,13 @@ gint seek_and_write_file(FILE *o, const CompFile *ifile, uint64_t offset, + return ret; + } + +-gint seek_and_write_buffer(FILE *o, const Buffer *buf, uint64_t offset, ++gint seek_and_write_buffer(FILE *o, const PvBuffer *buf, uint64_t offset, + GError **err) + { + if (file_seek(o, offset, err) < 0) + return -1; + +- if (buffer_write(buf, o, err) < 0) ++ if (pv_buffer_write(buf, o, err) < 0) + return -1; + + return 0; +diff --git a/genprotimg/src/utils/file_utils.h b/genprotimg/src/utils/file_utils.h +index 47df1148..456e7aca 100644 +--- a/genprotimg/src/utils/file_utils.h ++++ b/genprotimg/src/utils/file_utils.h +@@ -26,7 +26,7 @@ gint file_write(FILE *out, const void *ptr, gsize size, gsize count, + gsize *count_written, GError **err); + gint pad_file_right(const gchar *path_out, const gchar *path_in, + gsize *size_out, guint padding, GError **err); +-gint seek_and_write_buffer(FILE *out, const Buffer *buf, uint64_t offset, ++gint seek_and_write_buffer(FILE *out, const PvBuffer *buf, uint64_t offset, + GError **err); + gint seek_and_write_file(FILE *o, const CompFile *ifile, uint64_t offset, + GError **err); diff --git a/s390-tools-2.16.0-zkey.patch b/s390-tools-2.16.0-zkey.patch new file mode 100644 index 0000000..42b2014 --- /dev/null +++ b/s390-tools-2.16.0-zkey.patch @@ -0,0 +1,50 @@ +From 3f3f063c98278f53ad3b34e68b70fca62eaea8fb Mon Sep 17 00:00:00 2001 +From: Ingo Franzki +Date: Tue, 23 Feb 2021 08:52:26 +0100 +Subject: [PATCH] zkey: Fix build error when the compiler flags are overridden +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +When the compiler flags are overridden, the build of zkey may fail with: + +kms.c:44:2: error: #error KMS_PLUGIN_LOCATION must be defined + 44 | #error KMS_PLUGIN_LOCATION must be defined + | ^~~~~ + +The Makefile uses CFLAGS variable for defining the KMS_PLUGIN_LOCATION, +but it should rather use ALL_CFLAGS. + +Also use ALL_CPPFLAGS for defining HAVE_LUKS2_SUPPORT. + +Fixes: https://github.com/ibm-s390-linux/s390-tools/issues/108 + +Signed-off-by: Ingo Franzki +Reviewed-by: Jan Hoeppner +Signed-off-by: Jan Höppner +--- + zkey/Makefile | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/zkey/Makefile b/zkey/Makefile +index 41129bcf..f74e2091 100644 +--- a/zkey/Makefile ++++ b/zkey/Makefile +@@ -18,7 +18,7 @@ ifneq (${HAVE_CRYPTSETUP2},0) + ifneq (${HAVE_OPENSSL},0) + BUILD_TARGETS += zkey-cryptsetup + INSTALL_TARGETS += install-zkey-cryptsetup +- CPPFLAGS += -DHAVE_LUKS2_SUPPORT ++ ALL_CPPFLAGS += -DHAVE_LUKS2_SUPPORT + else + BUILD_TARGETS += zkey-cryptsetup-skip-openssl + INSTALL_TARGETS += zkey-cryptsetup-skip-openssl +@@ -34,7 +34,7 @@ endif + + libs = $(rootdir)/libutil/libutil.a + +-CFLAGS += -DKMS_PLUGIN_LOCATION=\"$(ZKEYKMSPLUGINDIR)\" ++ALL_CFLAGS += -DKMS_PLUGIN_LOCATION=\"$(ZKEYKMSPLUGINDIR)\" + + detect-libcryptsetup.dep: + echo "#include " > detect-libcryptsetup.dep diff --git a/s390utils.spec b/s390utils.spec index be478c1..0dfc069 100644 --- a/s390utils.spec +++ b/s390utils.spec @@ -5,8 +5,8 @@ Name: s390utils Summary: Utilities and daemons for IBM z Systems -Version: 2.15.1 -Release: 5%{?dist} +Version: 2.16.0 +Release: 2%{?dist} Epoch: 2 License: MIT ExclusiveArch: s390 s390x @@ -35,6 +35,12 @@ Source25: 91-zipl.install Patch0: s390-tools-zipl-invert-script-options.patch Patch1: s390-tools-zipl-blscfg-rpm-nvr-sort.patch +# upstream fixes +# https://github.com/ibm-s390-linux/s390-tools/commit/3f3f063c98278f53ad3b34e68b70fca62eaea8fb +Patch100: s390-tools-2.16.0-zkey.patch +# https://github.com/ibm-s390-linux/s390-tools/commit/b6bdd7744aba06d82f30b0c84012f0b06ccb01de +Patch101: s390-tools-2.16.0-genprotimg.patch + Requires: s390utils-core = %{epoch}:%{version}-%{release} Requires: s390utils-base = %{epoch}:%{version}-%{release} Requires: s390utils-osasnmpd = %{epoch}:%{version}-%{release} @@ -61,6 +67,10 @@ be used together with the zSeries (s390) Linux kernel and device drivers. %patch0 -p1 -b .zipl-invert-script-options %patch1 -p1 -b .blscfg-rpm-nvr-sort +# upstream fixes +%patch100 -p1 +%patch101 -p1 + # remove --strip from install find . -name Makefile | xargs sed -i 's/$(INSTALL) -s/$(INSTALL)/g' @@ -236,7 +246,6 @@ This package provides minimal set of tools needed to system to boot. License: MIT Summary: S390 base tools Requires: gawk sed coreutils -Requires: sysfsutils Requires: sg3_utils Requires: ethtool Requires: tar @@ -408,6 +417,7 @@ getent group zkeyadm > /dev/null || groupadd -r zkeyadm %{_sbindir}/dasdstat %{_sbindir}/dasdview %{_sbindir}/dbginfo.sh +%{_sbindir}/hsci %{_sbindir}/hyptop %{_sbindir}/ip_watcher.pl %{_sbindir}/lschp @@ -477,6 +487,7 @@ getent group zkeyadm > /dev/null || groupadd -r zkeyadm %{_mandir}/man8/dasdview.8* %{_mandir}/man8/dumpconf.8* %{_mandir}/man8/genprotimg.8.* +%{_mandir}/man8/hsci.8* %{_mandir}/man8/hyptop.8* %{_mandir}/man8/lschp.8* %{_mandir}/man8/lscss.8* @@ -805,6 +816,12 @@ User-space development files for the s390/s390x architecture. %changelog +* Mon Mar 01 2021 Dan Horák - 2:2.16.0-2 +- drop superfluous Require from s390utils-base + +* Wed Feb 24 2021 Dan Horák - 2:2.16.0-1 +- rebased to 2.16.0 + * Wed Jan 27 2021 Fedora Release Engineering - 2:2.15.1-5 - Rebuilt for https://fedoraproject.org/wiki/Fedora_34_Mass_Rebuild diff --git a/sources b/sources index 1787355..404b75d 100644 --- a/sources +++ b/sources @@ -1 +1 @@ -SHA512 (s390-tools-2.15.1.tar.gz) = a62ab491bac153b78161b7b1fb80ef1aa5ddb8657a9329f5ad9f8a16f106a9a9af1a37ceb328ed34eb44adb406207faec12ed0fb6648b5198498bf2fd411f0cf +SHA512 (s390-tools-2.16.0.tar.gz) = d0866e2f372ba2938ccab264846d6cfe3db1b760cff6645fbefcd33a8ce8e7d971e442ccefda7e8e4d59818293147caa57fa593a3e66cd77e1e661928336793c