From patchwork Sun Oct 11 21:07:37 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Peter Korsgaard X-Patchwork-Id: 1380555 Return-Path: X-Original-To: incoming-buildroot@patchwork.ozlabs.org Delivered-To: patchwork-incoming-buildroot@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=busybox.net (client-ip=140.211.166.137; helo=fraxinus.osuosl.org; envelope-from=buildroot-bounces@busybox.net; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=korsgaard.com Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20161025 header.b=eAaNkmoQ; dkim-atps=neutral Received: from fraxinus.osuosl.org (smtp4.osuosl.org [140.211.166.137]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 4C8ZCJ10Q3z9sT6 for ; Mon, 12 Oct 2020 08:07:55 +1100 (AEDT) Received: from localhost (localhost [127.0.0.1]) by fraxinus.osuosl.org (Postfix) with ESMTP id 43BFA85E98; Sun, 11 Oct 2020 21:07:52 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from fraxinus.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id dKZaL_AKsODD; Sun, 11 Oct 2020 21:07:50 +0000 (UTC) Received: from ash.osuosl.org (ash.osuosl.org [140.211.166.34]) by fraxinus.osuosl.org (Postfix) with ESMTP id 0E3C685B78; Sun, 11 Oct 2020 21:07:50 +0000 (UTC) X-Original-To: buildroot@lists.busybox.net Delivered-To: buildroot@osuosl.org Received: from silver.osuosl.org (smtp3.osuosl.org [140.211.166.136]) by ash.osuosl.org (Postfix) with ESMTP id A3D011BF2EF for ; Sun, 11 Oct 2020 21:07:48 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by silver.osuosl.org (Postfix) with ESMTP id 8787B2044C for ; Sun, 11 Oct 2020 21:07:48 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from silver.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id oVKv2jHci6Xx for ; Sun, 11 Oct 2020 21:07:45 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.7.6 Received: from mail-ed1-f53.google.com (mail-ed1-f53.google.com [209.85.208.53]) by silver.osuosl.org (Postfix) with ESMTPS id C8FBC203FD for ; Sun, 11 Oct 2020 21:07:44 +0000 (UTC) Received: by mail-ed1-f53.google.com with SMTP id l16so14861764eds.3 for ; Sun, 11 Oct 2020 14:07:44 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=sender:from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=jGOh7Xtas+bgBeKrTo/tQvcJ8TqEv/TDeApcL9DOaGs=; b=eAaNkmoQbtKgUZ+jp+N0/I3psdaoprvmqY6ql4W4LS3kXfey4w8DD4n/x8Kfylp9R6 L/ni2EljKqZMwzQPkRRXxbSDXE2U4wL0uOIg3nVeObwqMjcbI7lvSTq47ixpPJEFyuVn yuRu//ACI39sPtao9oDrIwGvy0LEld1QSvuSe04ANK+nh+Y31CqjXDAbx2k1p4dRkxcC RalXmVjw4YbfQLnKb3Lhl0PnCUQdLSGRqiqeKtB2f+w3ok0jtAoR7PbLGUcrGSXfD/J1 odC9ICOqwd9g9EyW4Y6BrgxtEN99awf3MasGfxBaOGtGF2sNhjReIkH8i7Ifwpanr0Am k4ig== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :mime-version:content-transfer-encoding; bh=jGOh7Xtas+bgBeKrTo/tQvcJ8TqEv/TDeApcL9DOaGs=; b=aQtZl7jTbDPZw/4uGocidf22RjjWSumKWzSKkWok36OmNK/K7SEeAoVUV3JnTJZ524 PVRw4Cx+WexTTnta5cGdZSgHxODhzdAfUAjiHXm7BbSU06ajOJ3TKYMdF6PPQlcNjr6t nKMEWp5nencqgcUiYFRJNUr5K/ctdRdX8AaHlGBXiIf03rcLQUU9zAaK0IeGfeuuudxO E89pcTqHrQSADxf4mFp+BEyNSBIt8QAXF0nWIuE+qFiG2K3pNjlsyx2Q6m925hCx92Z/ /1KFfv1Jhkv4YMP5UKVC60fbVqZu9QnVkOIRvP2/SWpXP9y+41ZlCHa8xiQrATCQrb6C JYkQ== X-Gm-Message-State: AOAM532Px1YhzeIJVFkrk3ZYcxlZd6T36LJ4+ow0phiI4OCD/OSxqhlc wVEMcjsiwnCKzUSl9C6BrXyUJgC4NZw= X-Google-Smtp-Source: ABdhPJxMBmTt2sff86WGg7ofUCyQi+HkfucMd6ky1AnumCsr10HHGxwjHrrEu+SlhnhsT7gAjOCu+Q== X-Received: by 2002:a50:af21:: with SMTP id g30mr10621841edd.46.1602450462426; Sun, 11 Oct 2020 14:07:42 -0700 (PDT) Received: from dell.be.48ers.dk (d51A5BC31.access.telenet.be. [81.165.188.49]) by smtp.gmail.com with ESMTPSA id i8sm9520152ejg.84.2020.10.11.14.07.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 11 Oct 2020 14:07:41 -0700 (PDT) Received: from peko by dell.be.48ers.dk with local (Exim 4.92) (envelope-from ) id 1kRiZA-0005yy-La; Sun, 11 Oct 2020 23:07:40 +0200 From: Peter Korsgaard To: buildroot@buildroot.org Date: Sun, 11 Oct 2020 23:07:37 +0200 Message-Id: <20201011210738.22951-1-peter@korsgaard.com> X-Mailer: git-send-email 2.20.1 MIME-Version: 1.0 Subject: [Buildroot] [PATCH-2020.02.x] package/cryptsetup: add upstream patch to fix runtime issue with json-c >= 0.14.0 X-BeenThere: buildroot@busybox.net X-Mailman-Version: 2.1.29 Precedence: list List-Id: Discussion and development of buildroot List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Peter Korsgaard Errors-To: buildroot-bounces@busybox.net Sender: "buildroot" Fixes #13251 json-c >= 0.14.0 has a name clash with internal cryptsetup functions, causing a runtime issue. Backport an upstream patch to rename the internal functions to fix this. Signed-off-by: Peter Korsgaard --- ...name-clash-with-newer-json-c-library.patch | 512 ++++++++++++++++++ 1 file changed, 512 insertions(+) create mode 100644 package/cryptsetup/0003-Avoid-name-clash-with-newer-json-c-library.patch diff --git a/package/cryptsetup/0003-Avoid-name-clash-with-newer-json-c-library.patch b/package/cryptsetup/0003-Avoid-name-clash-with-newer-json-c-library.patch new file mode 100644 index 0000000000..83ce71c6f5 --- /dev/null +++ b/package/cryptsetup/0003-Avoid-name-clash-with-newer-json-c-library.patch @@ -0,0 +1,512 @@ +From 55cf272d275c561459f2c9c3dc943ef7a69c9d4c Mon Sep 17 00:00:00 2001 +From: Ondrej Kozina +Date: Tue, 14 Apr 2020 17:24:54 +0200 +Subject: [PATCH] Avoid name clash with newer json-c library. + +This is partial revert of previous commit and also +fixes wrong decision to name our internal helpers with +json_object prefix. + +(cherry picked from commit e6a356974330e3ae21579a5737976e9a2aad1b51) +Signed-off-by: Peter Korsgaard +--- + lib/luks2/luks2_internal.h | 8 +++----- + lib/luks2/luks2_json_format.c | 6 +++--- + lib/luks2/luks2_json_metadata.c | 18 ++++++++---------- + lib/luks2/luks2_keyslot.c | 8 ++++---- + lib/luks2/luks2_keyslot_luks2.c | 16 ++++++++-------- + lib/luks2/luks2_keyslot_reenc.c | 20 ++++++++++---------- + lib/luks2/luks2_luks1_convert.c | 22 +++++++++++----------- + lib/luks2/luks2_reencrypt.c | 16 ++++++++-------- + lib/luks2/luks2_segment.c | 12 ++++++------ + 9 files changed, 61 insertions(+), 65 deletions(-) + +diff --git a/lib/luks2/luks2_internal.h b/lib/luks2/luks2_internal.h +index 6a8b8f2a..d2222e84 100644 +--- a/lib/luks2/luks2_internal.h ++++ b/lib/luks2/luks2_internal.h +@@ -59,11 +59,9 @@ json_object *LUKS2_get_segments_jobj(struct luks2_hdr *hdr); + void hexprint_base64(struct crypt_device *cd, json_object *jobj, + const char *sep, const char *line_sep); + +-#if !(defined JSON_C_VERSION_NUM && JSON_C_VERSION_NUM >= ((13 << 8) | 99)) +-uint64_t json_object_get_uint64(json_object *jobj); +-json_object *json_object_new_uint64(uint64_t value); +-#endif +-uint32_t json_object_get_uint32(json_object *jobj); ++uint64_t crypt_jobj_get_uint64(json_object *jobj); ++uint32_t crypt_jobj_get_uint32(json_object *jobj); ++json_object *crypt_jobj_new_uint64(uint64_t value); + + int json_object_object_add_by_uint(json_object *jobj, unsigned key, json_object *jobj_val); + void json_object_object_del_by_uint(json_object *jobj, unsigned key); +diff --git a/lib/luks2/luks2_json_format.c b/lib/luks2/luks2_json_format.c +index d4f36247..32ea0ea4 100644 +--- a/lib/luks2/luks2_json_format.c ++++ b/lib/luks2/luks2_json_format.c +@@ -325,8 +325,8 @@ int LUKS2_generate_hdr( + + json_object_object_add_by_uint(jobj_segments, 0, jobj_segment); + +- json_object_object_add(jobj_config, "json_size", json_object_new_uint64(metadata_size - LUKS2_HDR_BIN_LEN)); +- json_object_object_add(jobj_config, "keyslots_size", json_object_new_uint64(keyslots_size)); ++ json_object_object_add(jobj_config, "json_size", crypt_jobj_new_uint64(metadata_size - LUKS2_HDR_BIN_LEN)); ++ json_object_object_add(jobj_config, "keyslots_size", crypt_jobj_new_uint64(keyslots_size)); + + JSON_DBG(cd, hdr->jobj, "Header JSON:"); + return 0; +@@ -400,6 +400,6 @@ int LUKS2_set_keyslots_size(struct crypt_device *cd, + if (!json_object_object_get_ex(hdr->jobj, "config", &jobj_config)) + return 1; + +- json_object_object_add(jobj_config, "keyslots_size", json_object_new_uint64(keyslots_size)); ++ json_object_object_add(jobj_config, "keyslots_size", crypt_jobj_new_uint64(keyslots_size)); + return 0; + } +diff --git a/lib/luks2/luks2_json_metadata.c b/lib/luks2/luks2_json_metadata.c +index 52421fac..19fb9588 100644 +--- a/lib/luks2/luks2_json_metadata.c ++++ b/lib/luks2/luks2_json_metadata.c +@@ -219,7 +219,7 @@ int LUKS2_get_default_segment(struct luks2_hdr *hdr) + * json_type_int needs to be validated first. + * See validate_json_uint32() + */ +-uint32_t json_object_get_uint32(json_object *jobj) ++uint32_t crypt_jobj_get_uint32(json_object *jobj) + { + return json_object_get_int64(jobj); + } +@@ -241,15 +241,14 @@ static json_bool json_str_to_uint64(json_object *jobj, uint64_t *value) + return 1; + } + +-#if !(defined JSON_C_VERSION_NUM && JSON_C_VERSION_NUM >= ((13 << 8) | 99)) +-uint64_t json_object_get_uint64(json_object *jobj) ++uint64_t crypt_jobj_get_uint64(json_object *jobj) + { + uint64_t r; + json_str_to_uint64(jobj, &r); + return r; + } + +-json_object *json_object_new_uint64(uint64_t value) ++json_object *crypt_jobj_new_uint64(uint64_t value) + { + /* 18446744073709551615 */ + char num[21]; +@@ -263,7 +262,6 @@ json_object *json_object_new_uint64(uint64_t value) + jobj = json_object_new_string(num); + return jobj; + } +-#endif + + /* + * Validate helpers +@@ -457,7 +455,7 @@ static int hdr_validate_json_size(struct crypt_device *cd, json_object *hdr_jobj + + json = json_object_to_json_string_ext(hdr_jobj, + JSON_C_TO_STRING_PLAIN | JSON_C_TO_STRING_NOSLASHESCAPE); +- json_area_size = json_object_get_uint64(jobj1); ++ json_area_size = crypt_jobj_get_uint64(jobj1); + json_size = (uint64_t)strlen(json); + + if (hdr_json_size != json_area_size) { +@@ -545,7 +543,7 @@ static int hdr_validate_crypt_segment(struct crypt_device *cd, + return 1; + } + +- sector_size = json_object_get_uint32(jobj_sector_size); ++ sector_size = crypt_jobj_get_uint32(jobj_sector_size); + if (!sector_size || MISALIGNED_512(sector_size)) { + log_dbg(cd, "Illegal sector size: %" PRIu32, sector_size); + return 1; +@@ -1569,7 +1567,7 @@ static void hdr_dump_keyslots(struct crypt_device *cd, json_object *hdr_jobj) + log_std(cd, " %s: %s%s\n", slot, tmps, r == -ENOENT ? " (unbound)" : ""); + + if (json_object_object_get_ex(val, "key_size", &jobj2)) +- log_std(cd, "\tKey: %u bits\n", json_object_get_uint32(jobj2) * 8); ++ log_std(cd, "\tKey: %u bits\n", crypt_jobj_get_uint32(jobj2) * 8); + + log_std(cd, "\tPriority: %s\n", get_priority_desc(val)); + +@@ -1652,7 +1650,7 @@ static void hdr_dump_segments(struct crypt_device *cd, json_object *hdr_jobj) + log_std(cd, "\tcipher: %s\n", json_object_get_string(jobj1)); + + if (json_object_object_get_ex(jobj_segment, "sector_size", &jobj1)) +- log_std(cd, "\tsector: %" PRIu32 " [bytes]\n", json_object_get_uint32(jobj1)); ++ log_std(cd, "\tsector: %" PRIu32 " [bytes]\n", crypt_jobj_get_uint32(jobj1)); + + if (json_object_object_get_ex(jobj_segment, "integrity", &jobj1) && + json_object_object_get_ex(jobj1, "type", &jobj2)) +@@ -1749,7 +1747,7 @@ int LUKS2_get_data_size(struct luks2_hdr *hdr, uint64_t *size, bool *dynamic) + return 0; + } + +- tmp += json_object_get_uint64(jobj_size); ++ tmp += crypt_jobj_get_uint64(jobj_size); + } + + /* impossible, real device size must not be zero */ +diff --git a/lib/luks2/luks2_keyslot.c b/lib/luks2/luks2_keyslot.c +index 7d06df80..d853fc8e 100644 +--- a/lib/luks2/luks2_keyslot.c ++++ b/lib/luks2/luks2_keyslot.c +@@ -301,11 +301,11 @@ int LUKS2_keyslot_area(struct luks2_hdr *hdr, + + if (!json_object_object_get_ex(jobj_area, "offset", &jobj)) + return -EINVAL; +- *offset = json_object_get_uint64(jobj); ++ *offset = crypt_jobj_get_uint64(jobj); + + if (!json_object_object_get_ex(jobj_area, "size", &jobj)) + return -EINVAL; +- *length = json_object_get_uint64(jobj); ++ *length = crypt_jobj_get_uint64(jobj); + + return 0; + } +@@ -840,8 +840,8 @@ int placeholder_keyslot_alloc(struct crypt_device *cd, + + /* Area object */ + jobj_area = json_object_new_object(); +- json_object_object_add(jobj_area, "offset", json_object_new_uint64(area_offset)); +- json_object_object_add(jobj_area, "size", json_object_new_uint64(area_length)); ++ json_object_object_add(jobj_area, "offset", crypt_jobj_new_uint64(area_offset)); ++ json_object_object_add(jobj_area, "size", crypt_jobj_new_uint64(area_length)); + json_object_object_add(jobj_keyslot, "area", jobj_area); + + json_object_object_add_by_uint(jobj_keyslots, keyslot, jobj_keyslot); +diff --git a/lib/luks2/luks2_keyslot_luks2.c b/lib/luks2/luks2_keyslot_luks2.c +index 7b438a8b..953ba168 100644 +--- a/lib/luks2/luks2_keyslot_luks2.c ++++ b/lib/luks2/luks2_keyslot_luks2.c +@@ -220,7 +220,7 @@ static int luks2_keyslot_set_key(struct crypt_device *cd, + + if (!json_object_object_get_ex(jobj_area, "offset", &jobj2)) + return -EINVAL; +- area_offset = json_object_get_uint64(jobj2); ++ area_offset = crypt_jobj_get_uint64(jobj2); + + if (!json_object_object_get_ex(jobj_area, "encryption", &jobj2)) + return -EINVAL; +@@ -313,7 +313,7 @@ static int luks2_keyslot_get_key(struct crypt_device *cd, + + if (!json_object_object_get_ex(jobj_area, "offset", &jobj2)) + return -EINVAL; +- area_offset = json_object_get_uint64(jobj2); ++ area_offset = crypt_jobj_get_uint64(jobj2); + + if (!json_object_object_get_ex(jobj_area, "encryption", &jobj2)) + return -EINVAL; +@@ -494,8 +494,8 @@ static int luks2_keyslot_alloc(struct crypt_device *cd, + /* Area object */ + jobj_area = json_object_new_object(); + json_object_object_add(jobj_area, "type", json_object_new_string("raw")); +- json_object_object_add(jobj_area, "offset", json_object_new_uint64(area_offset)); +- json_object_object_add(jobj_area, "size", json_object_new_uint64(area_length)); ++ json_object_object_add(jobj_area, "offset", crypt_jobj_new_uint64(area_offset)); ++ json_object_object_add(jobj_area, "size", crypt_jobj_new_uint64(area_length)); + json_object_object_add(jobj_keyslot, "area", jobj_area); + + json_object_object_add_by_uint(jobj_keyslots, keyslot, jobj_keyslot); +@@ -607,7 +607,7 @@ static int luks2_keyslot_dump(struct crypt_device *cd, int keyslot) + log_std(cd, "\tCipher: %s\n", json_object_get_string(jobj1)); + + json_object_object_get_ex(jobj_area, "key_size", &jobj1); +- log_std(cd, "\tCipher key: %u bits\n", json_object_get_uint32(jobj1) * 8); ++ log_std(cd, "\tCipher key: %u bits\n", crypt_jobj_get_uint32(jobj1) * 8); + + json_object_object_get_ex(jobj_kdf, "type", &jobj1); + log_std(cd, "\tPBKDF: %s\n", json_object_get_string(jobj1)); +@@ -617,7 +617,7 @@ static int luks2_keyslot_dump(struct crypt_device *cd, int keyslot) + log_std(cd, "\tHash: %s\n", json_object_get_string(jobj1)); + + json_object_object_get_ex(jobj_kdf, "iterations", &jobj1); +- log_std(cd, "\tIterations: %" PRIu64 "\n", json_object_get_uint64(jobj1)); ++ log_std(cd, "\tIterations: %" PRIu64 "\n", crypt_jobj_get_uint64(jobj1)); + } else { + json_object_object_get_ex(jobj_kdf, "time", &jobj1); + log_std(cd, "\tTime cost: %" PRIu64 "\n", json_object_get_int64(jobj1)); +@@ -640,10 +640,10 @@ static int luks2_keyslot_dump(struct crypt_device *cd, int keyslot) + log_std(cd, "\tAF hash: %s\n", json_object_get_string(jobj1)); + + json_object_object_get_ex(jobj_area, "offset", &jobj1); +- log_std(cd, "\tArea offset:%" PRIu64 " [bytes]\n", json_object_get_uint64(jobj1)); ++ log_std(cd, "\tArea offset:%" PRIu64 " [bytes]\n", crypt_jobj_get_uint64(jobj1)); + + json_object_object_get_ex(jobj_area, "size", &jobj1); +- log_std(cd, "\tArea length:%" PRIu64 " [bytes]\n", json_object_get_uint64(jobj1)); ++ log_std(cd, "\tArea length:%" PRIu64 " [bytes]\n", crypt_jobj_get_uint64(jobj1)); + + return 0; + } +diff --git a/lib/luks2/luks2_keyslot_reenc.c b/lib/luks2/luks2_keyslot_reenc.c +index 64b8d274..c6b92db3 100644 +--- a/lib/luks2/luks2_keyslot_reenc.c ++++ b/lib/luks2/luks2_keyslot_reenc.c +@@ -67,13 +67,13 @@ int reenc_keyslot_alloc(struct crypt_device *cd, + + if (params->data_shift) { + json_object_object_add(jobj_area, "type", json_object_new_string("datashift")); +- json_object_object_add(jobj_area, "shift_size", json_object_new_uint64(params->data_shift << SECTOR_SHIFT)); ++ json_object_object_add(jobj_area, "shift_size", crypt_jobj_new_uint64(params->data_shift << SECTOR_SHIFT)); + } else + /* except data shift protection, initial setting is irrelevant. Type can be changed during reencryption */ + json_object_object_add(jobj_area, "type", json_object_new_string("none")); + +- json_object_object_add(jobj_area, "offset", json_object_new_uint64(area_offset)); +- json_object_object_add(jobj_area, "size", json_object_new_uint64(area_length)); ++ json_object_object_add(jobj_area, "offset", crypt_jobj_new_uint64(area_offset)); ++ json_object_object_add(jobj_area, "size", crypt_jobj_new_uint64(area_length)); + + json_object_object_add(jobj_keyslot, "type", json_object_new_string("reencrypt")); + json_object_object_add(jobj_keyslot, "key_size", json_object_new_int(1)); /* useless but mandatory */ +@@ -113,8 +113,8 @@ static int reenc_keyslot_store_data(struct crypt_device *cd, + !json_object_object_get_ex(jobj_area, "size", &jobj_length)) + return -EINVAL; + +- area_offset = json_object_get_uint64(jobj_offset); +- area_length = json_object_get_uint64(jobj_length); ++ area_offset = crypt_jobj_get_uint64(jobj_offset); ++ area_length = crypt_jobj_get_uint64(jobj_length); + + if (!area_offset || !area_length || ((uint64_t)buffer_len > area_length)) + return -EINVAL; +@@ -242,14 +242,14 @@ static int reenc_keyslot_dump(struct crypt_device *cd, int keyslot) + log_std(cd, "\t%-12s%d [bytes]\n", "Hash data:", json_object_get_int(jobj1)); + } else if (!strcmp(json_object_get_string(jobj_resilience), "datashift")) { + json_object_object_get_ex(jobj_area, "shift_size", &jobj1); +- log_std(cd, "\t%-12s%" PRIu64 "[bytes]\n", "Shift size:", json_object_get_uint64(jobj1)); ++ log_std(cd, "\t%-12s%" PRIu64 "[bytes]\n", "Shift size:", crypt_jobj_get_uint64(jobj1)); + } + + json_object_object_get_ex(jobj_area, "offset", &jobj1); +- log_std(cd, "\tArea offset:%" PRIu64 " [bytes]\n", json_object_get_uint64(jobj1)); ++ log_std(cd, "\tArea offset:%" PRIu64 " [bytes]\n", crypt_jobj_get_uint64(jobj1)); + + json_object_object_get_ex(jobj_area, "size", &jobj1); +- log_std(cd, "\tArea length:%" PRIu64 " [bytes]\n", json_object_get_uint64(jobj1)); ++ log_std(cd, "\tArea length:%" PRIu64 " [bytes]\n", crypt_jobj_get_uint64(jobj1)); + + return 0; + } +@@ -304,7 +304,7 @@ static int reenc_keyslot_validate(struct crypt_device *cd, json_object *jobj_key + return -EINVAL; + if (!validate_json_uint32(jobj_sector_size)) + return -EINVAL; +- sector_size = json_object_get_uint32(jobj_sector_size); ++ sector_size = crypt_jobj_get_uint32(jobj_sector_size); + if (sector_size < SECTOR_SIZE || NOTPOW2(sector_size)) { + log_dbg(cd, "Invalid sector_size (%" PRIu32 ") for checksum resilience mode.", sector_size); + return -EINVAL; +@@ -313,7 +313,7 @@ static int reenc_keyslot_validate(struct crypt_device *cd, json_object *jobj_key + if (!(jobj_shift_size = json_contains(cd, jobj_area, "type:datashift", "Keyslot area", "shift_size", json_type_string))) + return -EINVAL; + +- shift_size = json_object_get_uint64(jobj_shift_size); ++ shift_size = crypt_jobj_get_uint64(jobj_shift_size); + if (!shift_size) + return -EINVAL; + +diff --git a/lib/luks2/luks2_luks1_convert.c b/lib/luks2/luks2_luks1_convert.c +index 7f5f26b7..cbaa8603 100644 +--- a/lib/luks2/luks2_luks1_convert.c ++++ b/lib/luks2/luks2_luks1_convert.c +@@ -91,8 +91,8 @@ static int json_luks1_keyslot(const struct luks_phdr *hdr_v1, int keyslot, struc + } + area_size = offs_b - offs_a; + json_object_object_add(jobj_area, "key_size", json_object_new_int(hdr_v1->keyBytes)); +- json_object_object_add(jobj_area, "offset", json_object_new_uint64(offset)); +- json_object_object_add(jobj_area, "size", json_object_new_uint64(area_size)); ++ json_object_object_add(jobj_area, "offset", crypt_jobj_new_uint64(offset)); ++ json_object_object_add(jobj_area, "size", crypt_jobj_new_uint64(area_size)); + json_object_object_add(keyslot_obj, "area", jobj_area); + + *keyslot_object = keyslot_obj; +@@ -145,7 +145,7 @@ static int json_luks1_segment(const struct luks_phdr *hdr_v1, struct json_object + /* offset field */ + number = (uint64_t)hdr_v1->payloadOffset * SECTOR_SIZE; + +- field = json_object_new_uint64(number); ++ field = crypt_jobj_new_uint64(number); + if (!field) { + json_object_put(segment_obj); + return -ENOMEM; +@@ -401,8 +401,8 @@ static int json_luks1_object(struct luks_phdr *hdr_v1, struct json_object **luks + json_object_object_add(luks1_obj, "config", field); + + json_size = LUKS2_HDR_16K_LEN - LUKS2_HDR_BIN_LEN; +- json_object_object_add(field, "json_size", json_object_new_uint64(json_size)); +- json_object_object_add(field, "keyslots_size", json_object_new_uint64(keyslots_size)); ++ json_object_object_add(field, "json_size", crypt_jobj_new_uint64(json_size)); ++ json_object_object_add(field, "keyslots_size", crypt_jobj_new_uint64(keyslots_size)); + + *luks1_object = luks1_obj; + return 0; +@@ -418,8 +418,8 @@ static void move_keyslot_offset(json_object *jobj, int offset_add) + UNUSED(key); + json_object_object_get_ex(val, "area", &jobj_area); + json_object_object_get_ex(jobj_area, "offset", &jobj2); +- offset = json_object_get_uint64(jobj2) + offset_add; +- json_object_object_add(jobj_area, "offset", json_object_new_uint64(offset)); ++ offset = crypt_jobj_get_uint64(jobj2) + offset_add; ++ json_object_object_add(jobj_area, "offset", crypt_jobj_new_uint64(offset)); + } + } + +@@ -749,7 +749,7 @@ int LUKS2_luks2_to_luks1(struct crypt_device *cd, struct luks2_hdr *hdr2, struct + return -EINVAL; + if (!json_object_object_get_ex(jobj_area, "offset", &jobj1)) + return -EINVAL; +- offset = json_object_get_uint64(jobj1); ++ offset = crypt_jobj_get_uint64(jobj1); + } else { + if (LUKS2_find_area_gap(cd, hdr2, key_size, &offset, &area_length)) + return -EINVAL; +@@ -781,7 +781,7 @@ int LUKS2_luks2_to_luks1(struct crypt_device *cd, struct luks2_hdr *hdr2, struct + + if (!json_object_object_get_ex(jobj_kdf, "iterations", &jobj1)) + continue; +- hdr1->keyblock[i].passwordIterations = json_object_get_uint32(jobj1); ++ hdr1->keyblock[i].passwordIterations = crypt_jobj_get_uint32(jobj1); + + if (!json_object_object_get_ex(jobj_kdf, "salt", &jobj1)) + continue; +@@ -822,7 +822,7 @@ int LUKS2_luks2_to_luks1(struct crypt_device *cd, struct luks2_hdr *hdr2, struct + + if (!json_object_object_get_ex(jobj_digest, "iterations", &jobj1)) + return -EINVAL; +- hdr1->mkDigestIterations = json_object_get_uint32(jobj1); ++ hdr1->mkDigestIterations = crypt_jobj_get_uint32(jobj1); + + if (!json_object_object_get_ex(jobj_digest, "digest", &jobj1)) + return -EINVAL; +@@ -847,7 +847,7 @@ int LUKS2_luks2_to_luks1(struct crypt_device *cd, struct luks2_hdr *hdr2, struct + + if (!json_object_object_get_ex(jobj_segment, "offset", &jobj1)) + return -EINVAL; +- offset = json_object_get_uint64(jobj1) / SECTOR_SIZE; ++ offset = crypt_jobj_get_uint64(jobj1) / SECTOR_SIZE; + if (offset > UINT32_MAX) + return -EINVAL; + /* FIXME: LUKS1 requires offset == 0 || offset >= luks1_hdr_size */ +diff --git a/lib/luks2/luks2_reencrypt.c b/lib/luks2/luks2_reencrypt.c +index 6bac4420..c99577cc 100644 +--- a/lib/luks2/luks2_reencrypt.c ++++ b/lib/luks2/luks2_reencrypt.c +@@ -165,7 +165,7 @@ static uint32_t reencrypt_alignment(struct luks2_hdr *hdr) + if (!json_object_object_get_ex(jobj_area, "sector_size", &jobj_sector_size)) + return 0; + +- return json_object_get_uint32(jobj_sector_size); ++ return crypt_jobj_get_uint32(jobj_sector_size); + } + + static json_object *_enc_create_segments_shift_after(struct crypt_device *cd, +@@ -200,13 +200,13 @@ static json_object *_enc_create_segments_shift_after(struct crypt_device *cd, + json_segment_remove_flag(jobj_seg_new, "in-reencryption"); + tmp = rh->length; + } else { +- json_object_object_add(jobj_seg_new, "offset", json_object_new_uint64(rh->offset + data_offset)); +- json_object_object_add(jobj_seg_new, "iv_tweak", json_object_new_uint64(rh->offset >> SECTOR_SHIFT)); ++ json_object_object_add(jobj_seg_new, "offset", crypt_jobj_new_uint64(rh->offset + data_offset)); ++ json_object_object_add(jobj_seg_new, "iv_tweak", crypt_jobj_new_uint64(rh->offset >> SECTOR_SHIFT)); + tmp = json_segment_get_size(jobj_seg_new, 0) + rh->length; + } + + /* alter size of new segment, reenc_seg == 0 we're finished */ +- json_object_object_add(jobj_seg_new, "size", reenc_seg > 0 ? json_object_new_uint64(tmp) : json_object_new_string("dynamic")); ++ json_object_object_add(jobj_seg_new, "size", reenc_seg > 0 ? crypt_jobj_new_uint64(tmp) : json_object_new_string("dynamic")); + json_object_object_add_by_uint(jobj_segs_post, reenc_seg, jobj_seg_new); + + return jobj_segs_post; +@@ -256,7 +256,7 @@ static json_object *reencrypt_make_hot_segments_encrypt_shift(struct crypt_devic + jobj_seg_shrunk = NULL; + if (json_object_copy(LUKS2_get_segment_jobj(hdr, sg), &jobj_seg_shrunk)) + goto err; +- json_object_object_add(jobj_seg_shrunk, "size", json_object_new_uint64(segment_size - rh->length)); ++ json_object_object_add(jobj_seg_shrunk, "size", crypt_jobj_new_uint64(segment_size - rh->length)); + json_object_object_add_by_uint(jobj_segs_hot, sg++, jobj_seg_shrunk); + } + +@@ -336,7 +336,7 @@ static json_object *reencrypt_make_post_segments_forward(struct crypt_device *cd + goto err; + jobj_old_seg = jobj_old_seg_copy; + fixed_length = rh->device_size - fixed_length; +- json_object_object_add(jobj_old_seg, "size", json_object_new_uint64(fixed_length)); ++ json_object_object_add(jobj_old_seg, "size", crypt_jobj_new_uint64(fixed_length)); + } else + json_object_get(jobj_old_seg); + json_object_object_add_by_uint(jobj_segs_post, 1, jobj_old_seg); +@@ -491,7 +491,7 @@ static json_object *reencrypt_make_hot_segments_backward(struct crypt_device *cd + if (rh->offset) { + if (json_object_copy(LUKS2_get_segment_jobj(hdr, 0), &jobj_old_seg)) + goto err; +- json_object_object_add(jobj_old_seg, "size", json_object_new_uint64(rh->offset)); ++ json_object_object_add(jobj_old_seg, "size", crypt_jobj_new_uint64(rh->offset)); + + json_object_object_add_by_uint(jobj_segs_hot, sg++, jobj_old_seg); + } +@@ -575,7 +575,7 @@ static uint64_t reencrypt_data_shift(struct luks2_hdr *hdr) + if (!json_object_object_get_ex(jobj_area, "shift_size", &jobj_data_shift)) + return 0; + +- return json_object_get_uint64(jobj_data_shift); ++ return crypt_jobj_get_uint64(jobj_data_shift); + } + + static crypt_reencrypt_mode_info reencrypt_mode(struct luks2_hdr *hdr) +diff --git a/lib/luks2/luks2_segment.c b/lib/luks2/luks2_segment.c +index 6ece2fdd..cd5108e8 100644 +--- a/lib/luks2/luks2_segment.c ++++ b/lib/luks2/luks2_segment.c +@@ -55,7 +55,7 @@ uint64_t json_segment_get_offset(json_object *jobj_segment, unsigned blockwise) + !json_object_object_get_ex(jobj_segment, "offset", &jobj)) + return 0; + +- return blockwise ? json_object_get_uint64(jobj) >> SECTOR_SHIFT : json_object_get_uint64(jobj); ++ return blockwise ? crypt_jobj_get_uint64(jobj) >> SECTOR_SHIFT : crypt_jobj_get_uint64(jobj); + } + + const char *json_segment_type(json_object *jobj_segment) +@@ -77,7 +77,7 @@ uint64_t json_segment_get_iv_offset(json_object *jobj_segment) + !json_object_object_get_ex(jobj_segment, "iv_tweak", &jobj)) + return 0; + +- return json_object_get_uint64(jobj); ++ return crypt_jobj_get_uint64(jobj); + } + + uint64_t json_segment_get_size(json_object *jobj_segment, unsigned blockwise) +@@ -88,7 +88,7 @@ uint64_t json_segment_get_size(json_object *jobj_segment, unsigned blockwise) + !json_object_object_get_ex(jobj_segment, "size", &jobj)) + return 0; + +- return blockwise ? json_object_get_uint64(jobj) >> SECTOR_SHIFT : json_object_get_uint64(jobj); ++ return blockwise ? crypt_jobj_get_uint64(jobj) >> SECTOR_SHIFT : crypt_jobj_get_uint64(jobj); + } + + const char *json_segment_get_cipher(json_object *jobj_segment) +@@ -229,8 +229,8 @@ static json_object *_segment_create_generic(const char *type, uint64_t offset, c + return NULL; + + json_object_object_add(jobj, "type", json_object_new_string(type)); +- json_object_object_add(jobj, "offset", json_object_new_uint64(offset)); +- json_object_object_add(jobj, "size", length ? json_object_new_uint64(*length) : json_object_new_string("dynamic")); ++ json_object_object_add(jobj, "offset", crypt_jobj_new_uint64(offset)); ++ json_object_object_add(jobj, "size", length ? crypt_jobj_new_uint64(*length) : json_object_new_string("dynamic")); + + return jobj; + } +@@ -252,7 +252,7 @@ json_object *json_segment_create_crypt(uint64_t offset, + if (!jobj) + return NULL; + +- json_object_object_add(jobj, "iv_tweak", json_object_new_uint64(iv_offset)); ++ json_object_object_add(jobj, "iv_tweak", crypt_jobj_new_uint64(iv_offset)); + json_object_object_add(jobj, "encryption", json_object_new_string(cipher)); + json_object_object_add(jobj, "sector_size", json_object_new_int(sector_size)); + if (reencryption) +-- +2.20.1 +