0003-Avoid-name-clash-with-newer-json-c-library.patch 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512
  1. From 55cf272d275c561459f2c9c3dc943ef7a69c9d4c Mon Sep 17 00:00:00 2001
  2. From: Ondrej Kozina <okozina@redhat.com>
  3. Date: Tue, 14 Apr 2020 17:24:54 +0200
  4. Subject: [PATCH] Avoid name clash with newer json-c library.
  5. This is partial revert of previous commit and also
  6. fixes wrong decision to name our internal helpers with
  7. json_object prefix.
  8. (cherry picked from commit e6a356974330e3ae21579a5737976e9a2aad1b51)
  9. Signed-off-by: Peter Korsgaard <peter@korsgaard.com>
  10. ---
  11. lib/luks2/luks2_internal.h | 8 +++-----
  12. lib/luks2/luks2_json_format.c | 6 +++---
  13. lib/luks2/luks2_json_metadata.c | 18 ++++++++----------
  14. lib/luks2/luks2_keyslot.c | 8 ++++----
  15. lib/luks2/luks2_keyslot_luks2.c | 16 ++++++++--------
  16. lib/luks2/luks2_keyslot_reenc.c | 20 ++++++++++----------
  17. lib/luks2/luks2_luks1_convert.c | 22 +++++++++++-----------
  18. lib/luks2/luks2_reencrypt.c | 16 ++++++++--------
  19. lib/luks2/luks2_segment.c | 12 ++++++------
  20. 9 files changed, 61 insertions(+), 65 deletions(-)
  21. diff --git a/lib/luks2/luks2_internal.h b/lib/luks2/luks2_internal.h
  22. index 6a8b8f2a..d2222e84 100644
  23. --- a/lib/luks2/luks2_internal.h
  24. +++ b/lib/luks2/luks2_internal.h
  25. @@ -59,11 +59,9 @@ json_object *LUKS2_get_segments_jobj(struct luks2_hdr *hdr);
  26. void hexprint_base64(struct crypt_device *cd, json_object *jobj,
  27. const char *sep, const char *line_sep);
  28. -#if !(defined JSON_C_VERSION_NUM && JSON_C_VERSION_NUM >= ((13 << 8) | 99))
  29. -uint64_t json_object_get_uint64(json_object *jobj);
  30. -json_object *json_object_new_uint64(uint64_t value);
  31. -#endif
  32. -uint32_t json_object_get_uint32(json_object *jobj);
  33. +uint64_t crypt_jobj_get_uint64(json_object *jobj);
  34. +uint32_t crypt_jobj_get_uint32(json_object *jobj);
  35. +json_object *crypt_jobj_new_uint64(uint64_t value);
  36. int json_object_object_add_by_uint(json_object *jobj, unsigned key, json_object *jobj_val);
  37. void json_object_object_del_by_uint(json_object *jobj, unsigned key);
  38. diff --git a/lib/luks2/luks2_json_format.c b/lib/luks2/luks2_json_format.c
  39. index d4f36247..32ea0ea4 100644
  40. --- a/lib/luks2/luks2_json_format.c
  41. +++ b/lib/luks2/luks2_json_format.c
  42. @@ -325,8 +325,8 @@ int LUKS2_generate_hdr(
  43. json_object_object_add_by_uint(jobj_segments, 0, jobj_segment);
  44. - json_object_object_add(jobj_config, "json_size", json_object_new_uint64(metadata_size - LUKS2_HDR_BIN_LEN));
  45. - json_object_object_add(jobj_config, "keyslots_size", json_object_new_uint64(keyslots_size));
  46. + json_object_object_add(jobj_config, "json_size", crypt_jobj_new_uint64(metadata_size - LUKS2_HDR_BIN_LEN));
  47. + json_object_object_add(jobj_config, "keyslots_size", crypt_jobj_new_uint64(keyslots_size));
  48. JSON_DBG(cd, hdr->jobj, "Header JSON:");
  49. return 0;
  50. @@ -400,6 +400,6 @@ int LUKS2_set_keyslots_size(struct crypt_device *cd,
  51. if (!json_object_object_get_ex(hdr->jobj, "config", &jobj_config))
  52. return 1;
  53. - json_object_object_add(jobj_config, "keyslots_size", json_object_new_uint64(keyslots_size));
  54. + json_object_object_add(jobj_config, "keyslots_size", crypt_jobj_new_uint64(keyslots_size));
  55. return 0;
  56. }
  57. diff --git a/lib/luks2/luks2_json_metadata.c b/lib/luks2/luks2_json_metadata.c
  58. index 52421fac..19fb9588 100644
  59. --- a/lib/luks2/luks2_json_metadata.c
  60. +++ b/lib/luks2/luks2_json_metadata.c
  61. @@ -219,7 +219,7 @@ int LUKS2_get_default_segment(struct luks2_hdr *hdr)
  62. * json_type_int needs to be validated first.
  63. * See validate_json_uint32()
  64. */
  65. -uint32_t json_object_get_uint32(json_object *jobj)
  66. +uint32_t crypt_jobj_get_uint32(json_object *jobj)
  67. {
  68. return json_object_get_int64(jobj);
  69. }
  70. @@ -241,15 +241,14 @@ static json_bool json_str_to_uint64(json_object *jobj, uint64_t *value)
  71. return 1;
  72. }
  73. -#if !(defined JSON_C_VERSION_NUM && JSON_C_VERSION_NUM >= ((13 << 8) | 99))
  74. -uint64_t json_object_get_uint64(json_object *jobj)
  75. +uint64_t crypt_jobj_get_uint64(json_object *jobj)
  76. {
  77. uint64_t r;
  78. json_str_to_uint64(jobj, &r);
  79. return r;
  80. }
  81. -json_object *json_object_new_uint64(uint64_t value)
  82. +json_object *crypt_jobj_new_uint64(uint64_t value)
  83. {
  84. /* 18446744073709551615 */
  85. char num[21];
  86. @@ -263,7 +262,6 @@ json_object *json_object_new_uint64(uint64_t value)
  87. jobj = json_object_new_string(num);
  88. return jobj;
  89. }
  90. -#endif
  91. /*
  92. * Validate helpers
  93. @@ -457,7 +455,7 @@ static int hdr_validate_json_size(struct crypt_device *cd, json_object *hdr_jobj
  94. json = json_object_to_json_string_ext(hdr_jobj,
  95. JSON_C_TO_STRING_PLAIN | JSON_C_TO_STRING_NOSLASHESCAPE);
  96. - json_area_size = json_object_get_uint64(jobj1);
  97. + json_area_size = crypt_jobj_get_uint64(jobj1);
  98. json_size = (uint64_t)strlen(json);
  99. if (hdr_json_size != json_area_size) {
  100. @@ -545,7 +543,7 @@ static int hdr_validate_crypt_segment(struct crypt_device *cd,
  101. return 1;
  102. }
  103. - sector_size = json_object_get_uint32(jobj_sector_size);
  104. + sector_size = crypt_jobj_get_uint32(jobj_sector_size);
  105. if (!sector_size || MISALIGNED_512(sector_size)) {
  106. log_dbg(cd, "Illegal sector size: %" PRIu32, sector_size);
  107. return 1;
  108. @@ -1569,7 +1567,7 @@ static void hdr_dump_keyslots(struct crypt_device *cd, json_object *hdr_jobj)
  109. log_std(cd, " %s: %s%s\n", slot, tmps, r == -ENOENT ? " (unbound)" : "");
  110. if (json_object_object_get_ex(val, "key_size", &jobj2))
  111. - log_std(cd, "\tKey: %u bits\n", json_object_get_uint32(jobj2) * 8);
  112. + log_std(cd, "\tKey: %u bits\n", crypt_jobj_get_uint32(jobj2) * 8);
  113. log_std(cd, "\tPriority: %s\n", get_priority_desc(val));
  114. @@ -1652,7 +1650,7 @@ static void hdr_dump_segments(struct crypt_device *cd, json_object *hdr_jobj)
  115. log_std(cd, "\tcipher: %s\n", json_object_get_string(jobj1));
  116. if (json_object_object_get_ex(jobj_segment, "sector_size", &jobj1))
  117. - log_std(cd, "\tsector: %" PRIu32 " [bytes]\n", json_object_get_uint32(jobj1));
  118. + log_std(cd, "\tsector: %" PRIu32 " [bytes]\n", crypt_jobj_get_uint32(jobj1));
  119. if (json_object_object_get_ex(jobj_segment, "integrity", &jobj1) &&
  120. json_object_object_get_ex(jobj1, "type", &jobj2))
  121. @@ -1749,7 +1747,7 @@ int LUKS2_get_data_size(struct luks2_hdr *hdr, uint64_t *size, bool *dynamic)
  122. return 0;
  123. }
  124. - tmp += json_object_get_uint64(jobj_size);
  125. + tmp += crypt_jobj_get_uint64(jobj_size);
  126. }
  127. /* impossible, real device size must not be zero */
  128. diff --git a/lib/luks2/luks2_keyslot.c b/lib/luks2/luks2_keyslot.c
  129. index 7d06df80..d853fc8e 100644
  130. --- a/lib/luks2/luks2_keyslot.c
  131. +++ b/lib/luks2/luks2_keyslot.c
  132. @@ -301,11 +301,11 @@ int LUKS2_keyslot_area(struct luks2_hdr *hdr,
  133. if (!json_object_object_get_ex(jobj_area, "offset", &jobj))
  134. return -EINVAL;
  135. - *offset = json_object_get_uint64(jobj);
  136. + *offset = crypt_jobj_get_uint64(jobj);
  137. if (!json_object_object_get_ex(jobj_area, "size", &jobj))
  138. return -EINVAL;
  139. - *length = json_object_get_uint64(jobj);
  140. + *length = crypt_jobj_get_uint64(jobj);
  141. return 0;
  142. }
  143. @@ -840,8 +840,8 @@ int placeholder_keyslot_alloc(struct crypt_device *cd,
  144. /* Area object */
  145. jobj_area = json_object_new_object();
  146. - json_object_object_add(jobj_area, "offset", json_object_new_uint64(area_offset));
  147. - json_object_object_add(jobj_area, "size", json_object_new_uint64(area_length));
  148. + json_object_object_add(jobj_area, "offset", crypt_jobj_new_uint64(area_offset));
  149. + json_object_object_add(jobj_area, "size", crypt_jobj_new_uint64(area_length));
  150. json_object_object_add(jobj_keyslot, "area", jobj_area);
  151. json_object_object_add_by_uint(jobj_keyslots, keyslot, jobj_keyslot);
  152. diff --git a/lib/luks2/luks2_keyslot_luks2.c b/lib/luks2/luks2_keyslot_luks2.c
  153. index 7b438a8b..953ba168 100644
  154. --- a/lib/luks2/luks2_keyslot_luks2.c
  155. +++ b/lib/luks2/luks2_keyslot_luks2.c
  156. @@ -220,7 +220,7 @@ static int luks2_keyslot_set_key(struct crypt_device *cd,
  157. if (!json_object_object_get_ex(jobj_area, "offset", &jobj2))
  158. return -EINVAL;
  159. - area_offset = json_object_get_uint64(jobj2);
  160. + area_offset = crypt_jobj_get_uint64(jobj2);
  161. if (!json_object_object_get_ex(jobj_area, "encryption", &jobj2))
  162. return -EINVAL;
  163. @@ -313,7 +313,7 @@ static int luks2_keyslot_get_key(struct crypt_device *cd,
  164. if (!json_object_object_get_ex(jobj_area, "offset", &jobj2))
  165. return -EINVAL;
  166. - area_offset = json_object_get_uint64(jobj2);
  167. + area_offset = crypt_jobj_get_uint64(jobj2);
  168. if (!json_object_object_get_ex(jobj_area, "encryption", &jobj2))
  169. return -EINVAL;
  170. @@ -494,8 +494,8 @@ static int luks2_keyslot_alloc(struct crypt_device *cd,
  171. /* Area object */
  172. jobj_area = json_object_new_object();
  173. json_object_object_add(jobj_area, "type", json_object_new_string("raw"));
  174. - json_object_object_add(jobj_area, "offset", json_object_new_uint64(area_offset));
  175. - json_object_object_add(jobj_area, "size", json_object_new_uint64(area_length));
  176. + json_object_object_add(jobj_area, "offset", crypt_jobj_new_uint64(area_offset));
  177. + json_object_object_add(jobj_area, "size", crypt_jobj_new_uint64(area_length));
  178. json_object_object_add(jobj_keyslot, "area", jobj_area);
  179. json_object_object_add_by_uint(jobj_keyslots, keyslot, jobj_keyslot);
  180. @@ -607,7 +607,7 @@ static int luks2_keyslot_dump(struct crypt_device *cd, int keyslot)
  181. log_std(cd, "\tCipher: %s\n", json_object_get_string(jobj1));
  182. json_object_object_get_ex(jobj_area, "key_size", &jobj1);
  183. - log_std(cd, "\tCipher key: %u bits\n", json_object_get_uint32(jobj1) * 8);
  184. + log_std(cd, "\tCipher key: %u bits\n", crypt_jobj_get_uint32(jobj1) * 8);
  185. json_object_object_get_ex(jobj_kdf, "type", &jobj1);
  186. log_std(cd, "\tPBKDF: %s\n", json_object_get_string(jobj1));
  187. @@ -617,7 +617,7 @@ static int luks2_keyslot_dump(struct crypt_device *cd, int keyslot)
  188. log_std(cd, "\tHash: %s\n", json_object_get_string(jobj1));
  189. json_object_object_get_ex(jobj_kdf, "iterations", &jobj1);
  190. - log_std(cd, "\tIterations: %" PRIu64 "\n", json_object_get_uint64(jobj1));
  191. + log_std(cd, "\tIterations: %" PRIu64 "\n", crypt_jobj_get_uint64(jobj1));
  192. } else {
  193. json_object_object_get_ex(jobj_kdf, "time", &jobj1);
  194. log_std(cd, "\tTime cost: %" PRIu64 "\n", json_object_get_int64(jobj1));
  195. @@ -640,10 +640,10 @@ static int luks2_keyslot_dump(struct crypt_device *cd, int keyslot)
  196. log_std(cd, "\tAF hash: %s\n", json_object_get_string(jobj1));
  197. json_object_object_get_ex(jobj_area, "offset", &jobj1);
  198. - log_std(cd, "\tArea offset:%" PRIu64 " [bytes]\n", json_object_get_uint64(jobj1));
  199. + log_std(cd, "\tArea offset:%" PRIu64 " [bytes]\n", crypt_jobj_get_uint64(jobj1));
  200. json_object_object_get_ex(jobj_area, "size", &jobj1);
  201. - log_std(cd, "\tArea length:%" PRIu64 " [bytes]\n", json_object_get_uint64(jobj1));
  202. + log_std(cd, "\tArea length:%" PRIu64 " [bytes]\n", crypt_jobj_get_uint64(jobj1));
  203. return 0;
  204. }
  205. diff --git a/lib/luks2/luks2_keyslot_reenc.c b/lib/luks2/luks2_keyslot_reenc.c
  206. index 64b8d274..c6b92db3 100644
  207. --- a/lib/luks2/luks2_keyslot_reenc.c
  208. +++ b/lib/luks2/luks2_keyslot_reenc.c
  209. @@ -67,13 +67,13 @@ int reenc_keyslot_alloc(struct crypt_device *cd,
  210. if (params->data_shift) {
  211. json_object_object_add(jobj_area, "type", json_object_new_string("datashift"));
  212. - json_object_object_add(jobj_area, "shift_size", json_object_new_uint64(params->data_shift << SECTOR_SHIFT));
  213. + json_object_object_add(jobj_area, "shift_size", crypt_jobj_new_uint64(params->data_shift << SECTOR_SHIFT));
  214. } else
  215. /* except data shift protection, initial setting is irrelevant. Type can be changed during reencryption */
  216. json_object_object_add(jobj_area, "type", json_object_new_string("none"));
  217. - json_object_object_add(jobj_area, "offset", json_object_new_uint64(area_offset));
  218. - json_object_object_add(jobj_area, "size", json_object_new_uint64(area_length));
  219. + json_object_object_add(jobj_area, "offset", crypt_jobj_new_uint64(area_offset));
  220. + json_object_object_add(jobj_area, "size", crypt_jobj_new_uint64(area_length));
  221. json_object_object_add(jobj_keyslot, "type", json_object_new_string("reencrypt"));
  222. json_object_object_add(jobj_keyslot, "key_size", json_object_new_int(1)); /* useless but mandatory */
  223. @@ -113,8 +113,8 @@ static int reenc_keyslot_store_data(struct crypt_device *cd,
  224. !json_object_object_get_ex(jobj_area, "size", &jobj_length))
  225. return -EINVAL;
  226. - area_offset = json_object_get_uint64(jobj_offset);
  227. - area_length = json_object_get_uint64(jobj_length);
  228. + area_offset = crypt_jobj_get_uint64(jobj_offset);
  229. + area_length = crypt_jobj_get_uint64(jobj_length);
  230. if (!area_offset || !area_length || ((uint64_t)buffer_len > area_length))
  231. return -EINVAL;
  232. @@ -242,14 +242,14 @@ static int reenc_keyslot_dump(struct crypt_device *cd, int keyslot)
  233. log_std(cd, "\t%-12s%d [bytes]\n", "Hash data:", json_object_get_int(jobj1));
  234. } else if (!strcmp(json_object_get_string(jobj_resilience), "datashift")) {
  235. json_object_object_get_ex(jobj_area, "shift_size", &jobj1);
  236. - log_std(cd, "\t%-12s%" PRIu64 "[bytes]\n", "Shift size:", json_object_get_uint64(jobj1));
  237. + log_std(cd, "\t%-12s%" PRIu64 "[bytes]\n", "Shift size:", crypt_jobj_get_uint64(jobj1));
  238. }
  239. json_object_object_get_ex(jobj_area, "offset", &jobj1);
  240. - log_std(cd, "\tArea offset:%" PRIu64 " [bytes]\n", json_object_get_uint64(jobj1));
  241. + log_std(cd, "\tArea offset:%" PRIu64 " [bytes]\n", crypt_jobj_get_uint64(jobj1));
  242. json_object_object_get_ex(jobj_area, "size", &jobj1);
  243. - log_std(cd, "\tArea length:%" PRIu64 " [bytes]\n", json_object_get_uint64(jobj1));
  244. + log_std(cd, "\tArea length:%" PRIu64 " [bytes]\n", crypt_jobj_get_uint64(jobj1));
  245. return 0;
  246. }
  247. @@ -304,7 +304,7 @@ static int reenc_keyslot_validate(struct crypt_device *cd, json_object *jobj_key
  248. return -EINVAL;
  249. if (!validate_json_uint32(jobj_sector_size))
  250. return -EINVAL;
  251. - sector_size = json_object_get_uint32(jobj_sector_size);
  252. + sector_size = crypt_jobj_get_uint32(jobj_sector_size);
  253. if (sector_size < SECTOR_SIZE || NOTPOW2(sector_size)) {
  254. log_dbg(cd, "Invalid sector_size (%" PRIu32 ") for checksum resilience mode.", sector_size);
  255. return -EINVAL;
  256. @@ -313,7 +313,7 @@ static int reenc_keyslot_validate(struct crypt_device *cd, json_object *jobj_key
  257. if (!(jobj_shift_size = json_contains(cd, jobj_area, "type:datashift", "Keyslot area", "shift_size", json_type_string)))
  258. return -EINVAL;
  259. - shift_size = json_object_get_uint64(jobj_shift_size);
  260. + shift_size = crypt_jobj_get_uint64(jobj_shift_size);
  261. if (!shift_size)
  262. return -EINVAL;
  263. diff --git a/lib/luks2/luks2_luks1_convert.c b/lib/luks2/luks2_luks1_convert.c
  264. index 7f5f26b7..cbaa8603 100644
  265. --- a/lib/luks2/luks2_luks1_convert.c
  266. +++ b/lib/luks2/luks2_luks1_convert.c
  267. @@ -91,8 +91,8 @@ static int json_luks1_keyslot(const struct luks_phdr *hdr_v1, int keyslot, struc
  268. }
  269. area_size = offs_b - offs_a;
  270. json_object_object_add(jobj_area, "key_size", json_object_new_int(hdr_v1->keyBytes));
  271. - json_object_object_add(jobj_area, "offset", json_object_new_uint64(offset));
  272. - json_object_object_add(jobj_area, "size", json_object_new_uint64(area_size));
  273. + json_object_object_add(jobj_area, "offset", crypt_jobj_new_uint64(offset));
  274. + json_object_object_add(jobj_area, "size", crypt_jobj_new_uint64(area_size));
  275. json_object_object_add(keyslot_obj, "area", jobj_area);
  276. *keyslot_object = keyslot_obj;
  277. @@ -145,7 +145,7 @@ static int json_luks1_segment(const struct luks_phdr *hdr_v1, struct json_object
  278. /* offset field */
  279. number = (uint64_t)hdr_v1->payloadOffset * SECTOR_SIZE;
  280. - field = json_object_new_uint64(number);
  281. + field = crypt_jobj_new_uint64(number);
  282. if (!field) {
  283. json_object_put(segment_obj);
  284. return -ENOMEM;
  285. @@ -401,8 +401,8 @@ static int json_luks1_object(struct luks_phdr *hdr_v1, struct json_object **luks
  286. json_object_object_add(luks1_obj, "config", field);
  287. json_size = LUKS2_HDR_16K_LEN - LUKS2_HDR_BIN_LEN;
  288. - json_object_object_add(field, "json_size", json_object_new_uint64(json_size));
  289. - json_object_object_add(field, "keyslots_size", json_object_new_uint64(keyslots_size));
  290. + json_object_object_add(field, "json_size", crypt_jobj_new_uint64(json_size));
  291. + json_object_object_add(field, "keyslots_size", crypt_jobj_new_uint64(keyslots_size));
  292. *luks1_object = luks1_obj;
  293. return 0;
  294. @@ -418,8 +418,8 @@ static void move_keyslot_offset(json_object *jobj, int offset_add)
  295. UNUSED(key);
  296. json_object_object_get_ex(val, "area", &jobj_area);
  297. json_object_object_get_ex(jobj_area, "offset", &jobj2);
  298. - offset = json_object_get_uint64(jobj2) + offset_add;
  299. - json_object_object_add(jobj_area, "offset", json_object_new_uint64(offset));
  300. + offset = crypt_jobj_get_uint64(jobj2) + offset_add;
  301. + json_object_object_add(jobj_area, "offset", crypt_jobj_new_uint64(offset));
  302. }
  303. }
  304. @@ -749,7 +749,7 @@ int LUKS2_luks2_to_luks1(struct crypt_device *cd, struct luks2_hdr *hdr2, struct
  305. return -EINVAL;
  306. if (!json_object_object_get_ex(jobj_area, "offset", &jobj1))
  307. return -EINVAL;
  308. - offset = json_object_get_uint64(jobj1);
  309. + offset = crypt_jobj_get_uint64(jobj1);
  310. } else {
  311. if (LUKS2_find_area_gap(cd, hdr2, key_size, &offset, &area_length))
  312. return -EINVAL;
  313. @@ -781,7 +781,7 @@ int LUKS2_luks2_to_luks1(struct crypt_device *cd, struct luks2_hdr *hdr2, struct
  314. if (!json_object_object_get_ex(jobj_kdf, "iterations", &jobj1))
  315. continue;
  316. - hdr1->keyblock[i].passwordIterations = json_object_get_uint32(jobj1);
  317. + hdr1->keyblock[i].passwordIterations = crypt_jobj_get_uint32(jobj1);
  318. if (!json_object_object_get_ex(jobj_kdf, "salt", &jobj1))
  319. continue;
  320. @@ -822,7 +822,7 @@ int LUKS2_luks2_to_luks1(struct crypt_device *cd, struct luks2_hdr *hdr2, struct
  321. if (!json_object_object_get_ex(jobj_digest, "iterations", &jobj1))
  322. return -EINVAL;
  323. - hdr1->mkDigestIterations = json_object_get_uint32(jobj1);
  324. + hdr1->mkDigestIterations = crypt_jobj_get_uint32(jobj1);
  325. if (!json_object_object_get_ex(jobj_digest, "digest", &jobj1))
  326. return -EINVAL;
  327. @@ -847,7 +847,7 @@ int LUKS2_luks2_to_luks1(struct crypt_device *cd, struct luks2_hdr *hdr2, struct
  328. if (!json_object_object_get_ex(jobj_segment, "offset", &jobj1))
  329. return -EINVAL;
  330. - offset = json_object_get_uint64(jobj1) / SECTOR_SIZE;
  331. + offset = crypt_jobj_get_uint64(jobj1) / SECTOR_SIZE;
  332. if (offset > UINT32_MAX)
  333. return -EINVAL;
  334. /* FIXME: LUKS1 requires offset == 0 || offset >= luks1_hdr_size */
  335. diff --git a/lib/luks2/luks2_reencrypt.c b/lib/luks2/luks2_reencrypt.c
  336. index 6bac4420..c99577cc 100644
  337. --- a/lib/luks2/luks2_reencrypt.c
  338. +++ b/lib/luks2/luks2_reencrypt.c
  339. @@ -165,7 +165,7 @@ static uint32_t reencrypt_alignment(struct luks2_hdr *hdr)
  340. if (!json_object_object_get_ex(jobj_area, "sector_size", &jobj_sector_size))
  341. return 0;
  342. - return json_object_get_uint32(jobj_sector_size);
  343. + return crypt_jobj_get_uint32(jobj_sector_size);
  344. }
  345. static json_object *_enc_create_segments_shift_after(struct crypt_device *cd,
  346. @@ -200,13 +200,13 @@ static json_object *_enc_create_segments_shift_after(struct crypt_device *cd,
  347. json_segment_remove_flag(jobj_seg_new, "in-reencryption");
  348. tmp = rh->length;
  349. } else {
  350. - json_object_object_add(jobj_seg_new, "offset", json_object_new_uint64(rh->offset + data_offset));
  351. - json_object_object_add(jobj_seg_new, "iv_tweak", json_object_new_uint64(rh->offset >> SECTOR_SHIFT));
  352. + json_object_object_add(jobj_seg_new, "offset", crypt_jobj_new_uint64(rh->offset + data_offset));
  353. + json_object_object_add(jobj_seg_new, "iv_tweak", crypt_jobj_new_uint64(rh->offset >> SECTOR_SHIFT));
  354. tmp = json_segment_get_size(jobj_seg_new, 0) + rh->length;
  355. }
  356. /* alter size of new segment, reenc_seg == 0 we're finished */
  357. - json_object_object_add(jobj_seg_new, "size", reenc_seg > 0 ? json_object_new_uint64(tmp) : json_object_new_string("dynamic"));
  358. + json_object_object_add(jobj_seg_new, "size", reenc_seg > 0 ? crypt_jobj_new_uint64(tmp) : json_object_new_string("dynamic"));
  359. json_object_object_add_by_uint(jobj_segs_post, reenc_seg, jobj_seg_new);
  360. return jobj_segs_post;
  361. @@ -256,7 +256,7 @@ static json_object *reencrypt_make_hot_segments_encrypt_shift(struct crypt_devic
  362. jobj_seg_shrunk = NULL;
  363. if (json_object_copy(LUKS2_get_segment_jobj(hdr, sg), &jobj_seg_shrunk))
  364. goto err;
  365. - json_object_object_add(jobj_seg_shrunk, "size", json_object_new_uint64(segment_size - rh->length));
  366. + json_object_object_add(jobj_seg_shrunk, "size", crypt_jobj_new_uint64(segment_size - rh->length));
  367. json_object_object_add_by_uint(jobj_segs_hot, sg++, jobj_seg_shrunk);
  368. }
  369. @@ -336,7 +336,7 @@ static json_object *reencrypt_make_post_segments_forward(struct crypt_device *cd
  370. goto err;
  371. jobj_old_seg = jobj_old_seg_copy;
  372. fixed_length = rh->device_size - fixed_length;
  373. - json_object_object_add(jobj_old_seg, "size", json_object_new_uint64(fixed_length));
  374. + json_object_object_add(jobj_old_seg, "size", crypt_jobj_new_uint64(fixed_length));
  375. } else
  376. json_object_get(jobj_old_seg);
  377. json_object_object_add_by_uint(jobj_segs_post, 1, jobj_old_seg);
  378. @@ -491,7 +491,7 @@ static json_object *reencrypt_make_hot_segments_backward(struct crypt_device *cd
  379. if (rh->offset) {
  380. if (json_object_copy(LUKS2_get_segment_jobj(hdr, 0), &jobj_old_seg))
  381. goto err;
  382. - json_object_object_add(jobj_old_seg, "size", json_object_new_uint64(rh->offset));
  383. + json_object_object_add(jobj_old_seg, "size", crypt_jobj_new_uint64(rh->offset));
  384. json_object_object_add_by_uint(jobj_segs_hot, sg++, jobj_old_seg);
  385. }
  386. @@ -575,7 +575,7 @@ static uint64_t reencrypt_data_shift(struct luks2_hdr *hdr)
  387. if (!json_object_object_get_ex(jobj_area, "shift_size", &jobj_data_shift))
  388. return 0;
  389. - return json_object_get_uint64(jobj_data_shift);
  390. + return crypt_jobj_get_uint64(jobj_data_shift);
  391. }
  392. static crypt_reencrypt_mode_info reencrypt_mode(struct luks2_hdr *hdr)
  393. diff --git a/lib/luks2/luks2_segment.c b/lib/luks2/luks2_segment.c
  394. index 6ece2fdd..cd5108e8 100644
  395. --- a/lib/luks2/luks2_segment.c
  396. +++ b/lib/luks2/luks2_segment.c
  397. @@ -55,7 +55,7 @@ uint64_t json_segment_get_offset(json_object *jobj_segment, unsigned blockwise)
  398. !json_object_object_get_ex(jobj_segment, "offset", &jobj))
  399. return 0;
  400. - return blockwise ? json_object_get_uint64(jobj) >> SECTOR_SHIFT : json_object_get_uint64(jobj);
  401. + return blockwise ? crypt_jobj_get_uint64(jobj) >> SECTOR_SHIFT : crypt_jobj_get_uint64(jobj);
  402. }
  403. const char *json_segment_type(json_object *jobj_segment)
  404. @@ -77,7 +77,7 @@ uint64_t json_segment_get_iv_offset(json_object *jobj_segment)
  405. !json_object_object_get_ex(jobj_segment, "iv_tweak", &jobj))
  406. return 0;
  407. - return json_object_get_uint64(jobj);
  408. + return crypt_jobj_get_uint64(jobj);
  409. }
  410. uint64_t json_segment_get_size(json_object *jobj_segment, unsigned blockwise)
  411. @@ -88,7 +88,7 @@ uint64_t json_segment_get_size(json_object *jobj_segment, unsigned blockwise)
  412. !json_object_object_get_ex(jobj_segment, "size", &jobj))
  413. return 0;
  414. - return blockwise ? json_object_get_uint64(jobj) >> SECTOR_SHIFT : json_object_get_uint64(jobj);
  415. + return blockwise ? crypt_jobj_get_uint64(jobj) >> SECTOR_SHIFT : crypt_jobj_get_uint64(jobj);
  416. }
  417. const char *json_segment_get_cipher(json_object *jobj_segment)
  418. @@ -229,8 +229,8 @@ static json_object *_segment_create_generic(const char *type, uint64_t offset, c
  419. return NULL;
  420. json_object_object_add(jobj, "type", json_object_new_string(type));
  421. - json_object_object_add(jobj, "offset", json_object_new_uint64(offset));
  422. - json_object_object_add(jobj, "size", length ? json_object_new_uint64(*length) : json_object_new_string("dynamic"));
  423. + json_object_object_add(jobj, "offset", crypt_jobj_new_uint64(offset));
  424. + json_object_object_add(jobj, "size", length ? crypt_jobj_new_uint64(*length) : json_object_new_string("dynamic"));
  425. return jobj;
  426. }
  427. @@ -252,7 +252,7 @@ json_object *json_segment_create_crypt(uint64_t offset,
  428. if (!jobj)
  429. return NULL;
  430. - json_object_object_add(jobj, "iv_tweak", json_object_new_uint64(iv_offset));
  431. + json_object_object_add(jobj, "iv_tweak", crypt_jobj_new_uint64(iv_offset));
  432. json_object_object_add(jobj, "encryption", json_object_new_string(cipher));
  433. json_object_object_add(jobj, "sector_size", json_object_new_int(sector_size));
  434. if (reencryption)
  435. --
  436. 2.20.1