shared/json: use int64_t instead of intmax_t

We were already asserting that the intmax_t and uintmax_t types
are the same as int64_t and uint64_t. Pretty much everywhere in
the code base we use the latter types. In principle intmax_t could
be something different on some new architecture, and then the code would
fail to compile or behave differently. We actually do not want the code
to behave differently on those architectures, because that'd break
interoperability. So let's just use int64_t/uint64_t since that's what
we indend to use.

diff --git a/src/cryptsetup/cryptsetup-tokens/cryptsetup-token-systemd-tpm2.c b/src/cryptsetup/cryptsetup-tokens/cryptsetup-token-systemd-tpm2.c
index 5471cb35b6378bf5dc25b8b284e64d8fd90741b5..e2d28a5dda82621f281efb0bc73d3fd95ceeb932 100644 (file)
--- a/src/cryptsetup/cryptsetup-tokens/cryptsetup-token-systemd-tpm2.c
+++ b/src/cryptsetup/cryptsetup-tokens/cryptsetup-token-systemd-tpm2.c
@@ -200,7 +200,7 @@ _public_ int cryptsetup_token_validate(
         }
 
         JSON_VARIANT_ARRAY_FOREACH(e, w) {
-                uintmax_t u;
+                uint64_t u;
 
                 if (!json_variant_is_number(e)) {
                         crypt_log_debug(cd, "TPM2 PCR is not a number.");

diff --git a/src/cryptsetup/cryptsetup-tokens/luks2-tpm2.c b/src/cryptsetup/cryptsetup-tokens/luks2-tpm2.c
index 4167275317ad2d010681d2f5ac2416e1134e47e9..3d39dfa8848964aaa2bce7b5376374d69b361525 100644 (file)
--- a/src/cryptsetup/cryptsetup-tokens/luks2-tpm2.c
+++ b/src/cryptsetup/cryptsetup-tokens/luks2-tpm2.c
@@ -78,7 +78,7 @@ int parse_luks2_tpm2_data(
                 return -EINVAL;
 
         JSON_VARIANT_ARRAY_FOREACH(e, w) {
-                uintmax_t u;
+                uint64_t u;
 
                 if (!json_variant_is_number(e))
                         return -EINVAL;

diff --git a/src/cryptsetup/cryptsetup-tpm2.c b/src/cryptsetup/cryptsetup-tpm2.c
index 8757212969169d3518918f867027bf9bcd57ead1..cb139518a716d885124f5343cdf92aab7b82eb83 100644 (file)
--- a/src/cryptsetup/cryptsetup-tpm2.c
+++ b/src/cryptsetup/cryptsetup-tpm2.c
@@ -116,7 +116,7 @@ int find_tpm2_auto_data(
 
                 assert(pcr_mask == 0);
                 JSON_VARIANT_ARRAY_FOREACH(e, w) {
-                        uintmax_t u;
+                        uint64_t u;
 
                         if (!json_variant_is_number(e))
                                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),

diff --git a/src/home/homectl.c b/src/home/homectl.c
index a4f3116544d2b7d019cf782c35250edc3914fad3..f6a21993956c583fdb9b586ab40bd8aac6d5e951 100644 (file)
--- a/src/home/homectl.c
+++ b/src/home/homectl.c
@@ -759,7 +759,7 @@ static int update_last_change(JsonVariant **v, bool with_password, bool override
 
         c = json_variant_by_key(*v, "lastChangeUSec");
         if (c) {
-                uintmax_t u;
+                uint64_t u;
 
                 if (!override)
                         goto update_password;
@@ -782,7 +782,7 @@ update_password:
 
         c = json_variant_by_key(*v, "lastPasswordChangeUSec");
         if (c) {
-                uintmax_t u;
+                uint64_t u;
 
                 if (!override)
                         return 0;

diff --git a/src/network/networkctl.c b/src/network/networkctl.c
index 2d0866a81d5d1a3eed78d8f8ded40a33328a6085..68dd4b185c7c9ba546a099aa419254e1a162a47f 100644 (file)
--- a/src/network/networkctl.c
+++ b/src/network/networkctl.c
@@ -133,9 +133,9 @@ static int dump_link_description(char **patterns) {
                 return log_oom();
 
         JSON_VARIANT_ARRAY_FOREACH(i, json_variant_by_key(v, "Interfaces")) {
-                char ifindex_str[DECIMAL_STR_MAX(intmax_t)];
+                char ifindex_str[DECIMAL_STR_MAX(int64_t)];
                 const char *name;
-                intmax_t index;
+                int64_t index;
                 size_t pos;
 
                 name = json_variant_string(json_variant_by_key(i, "Name"));

diff --git a/src/network/networkd-json.c b/src/network/networkd-json.c
index 7148c2ee14342b7a3797de2fd751f2e7aa66c5b3..4828a0ed50cb4c329a3b6e137b99d858edd5c352 100644 (file)
--- a/src/network/networkd-json.c
+++ b/src/network/networkd-json.c
@@ -94,7 +94,7 @@ int link_build_json(Link *link, JsonVariant **ret) {
 }
 
 static int link_json_compare(JsonVariant * const *a, JsonVariant * const *b) {
-        intmax_t index_a, index_b;
+        int64_t index_a, index_b;
 
         assert(a && *a);
         assert(b && *b);

diff --git a/src/nspawn/nspawn-oci.c b/src/nspawn/nspawn-oci.c
index 9912c5acbb77605b4efbb6e992ab4c25989977eb..9e59d6a8144fbf34ad6d4a8399386b910455939a 100644 (file)
--- a/src/nspawn/nspawn-oci.c
+++ b/src/nspawn/nspawn-oci.c
@@ -99,7 +99,7 @@ static int oci_terminal(const char *name, JsonVariant *v, JsonDispatchFlags flag
 
 static int oci_console_dimension(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
         unsigned *u = userdata;
-        uintmax_t k;
+        uint64_t k;
 
         assert(u);
 
@@ -226,7 +226,7 @@ static int oci_rlimit_value(const char *name, JsonVariant *v, JsonDispatchFlags
 
                 z = (rlim_t) json_variant_unsigned(v);
 
-                if ((uintmax_t) z != json_variant_unsigned(v))
+                if ((uint64_t) z != json_variant_unsigned(v))
                         return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL),
                                         "rlimits limit out of range, refusing.");
         }
@@ -346,7 +346,7 @@ static int oci_capabilities(const char *name, JsonVariant *v, JsonDispatchFlags
 
 static int oci_oom_score_adj(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
         Settings *s = userdata;
-        intmax_t k;
+        int64_t k;
 
         assert(s);
 
@@ -363,14 +363,14 @@ static int oci_oom_score_adj(const char *name, JsonVariant *v, JsonDispatchFlags
 
 static int oci_uid_gid(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
         uid_t *uid = userdata, u;
-        uintmax_t k;
+        uint64_t k;
 
         assert(uid);
         assert_cc(sizeof(uid_t) == sizeof(gid_t));
 
         k = json_variant_unsigned(v);
         u = (uid_t) k;
-        if ((uintmax_t) u != k)
+        if ((uint64_t) u != k)
                 return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL),
                                 "UID/GID out of range: %ji", k);
 
@@ -698,7 +698,7 @@ static int oci_namespaces(const char *name, JsonVariant *v, JsonDispatchFlags fl
 
 static int oci_uid_gid_range(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
         uid_t *uid = userdata, u;
-        uintmax_t k;
+        uint64_t k;
 
         assert(uid);
         assert_cc(sizeof(uid_t) == sizeof(gid_t));
@@ -709,7 +709,7 @@ static int oci_uid_gid_range(const char *name, JsonVariant *v, JsonDispatchFlags
 
         k = json_variant_unsigned(v);
         u = (uid_t) k;
-        if ((uintmax_t) u != k)
+        if ((uint64_t) u != k)
                 return json_log(v, flags, SYNTHETIC_ERRNO(ERANGE),
                                 "UID/GID out of range: %ji", k);
         if (u == 0)
@@ -803,7 +803,7 @@ static int oci_device_type(const char *name, JsonVariant *v, JsonDispatchFlags f
 
 static int oci_device_major(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
         unsigned *u = userdata;
-        uintmax_t k;
+        uint64_t k;
 
         assert_se(u);
 
@@ -818,7 +818,7 @@ static int oci_device_major(const char *name, JsonVariant *v, JsonDispatchFlags
 
 static int oci_device_minor(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
         unsigned *u = userdata;
-        uintmax_t k;
+        uint64_t k;
 
         assert_se(u);
 
@@ -833,14 +833,14 @@ static int oci_device_minor(const char *name, JsonVariant *v, JsonDispatchFlags
 
 static int oci_device_file_mode(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
         mode_t *mode = userdata, m;
-        uintmax_t k;
+        uint64_t k;
 
         assert(mode);
 
         k = json_variant_unsigned(v);
         m = (mode_t) k;
 
-        if ((m & ~07777) != 0 || (uintmax_t) m != k)
+        if ((m & ~07777) != 0 || (uint64_t) m != k)
                 return json_log(v, flags, SYNTHETIC_ERRNO(ERANGE),
                                 "fileMode out of range, refusing.");
 
@@ -1175,7 +1175,7 @@ static int oci_cgroup_devices(const char *name, JsonVariant *v, JsonDispatchFlag
 
 static int oci_cgroup_memory_limit(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
         uint64_t *m = userdata;
-        uintmax_t k;
+        uint64_t k;
 
         assert(m);
 
@@ -1275,7 +1275,7 @@ struct cpu_data {
 
 static int oci_cgroup_cpu_shares(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
         uint64_t *u = userdata;
-        uintmax_t k;
+        uint64_t k;
 
         assert(u);
 
@@ -1290,7 +1290,7 @@ static int oci_cgroup_cpu_shares(const char *name, JsonVariant *v, JsonDispatchF
 
 static int oci_cgroup_cpu_quota(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
         uint64_t *u = userdata;
-        uintmax_t k;
+        uint64_t k;
 
         assert(u);
 
@@ -1382,7 +1382,7 @@ static int oci_cgroup_cpu(const char *name, JsonVariant *v, JsonDispatchFlags fl
 
 static int oci_cgroup_block_io_weight(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
         Settings *s = userdata;
-        uintmax_t k;
+        uint64_t k;
         int r;
 
         assert(s);
@@ -1414,18 +1414,18 @@ static int oci_cgroup_block_io_weight_device(const char *name, JsonVariant *v, J
                 struct device_data {
                         unsigned major;
                         unsigned minor;
-                        uintmax_t weight;
+                        uint64_t weight;
                 } data = {
                         .major = UINT_MAX,
                         .minor = UINT_MAX,
-                        .weight = UINTMAX_MAX,
+                        .weight = UINT64_MAX,
                 };
 
                 static const JsonDispatch table[] =  {
-                        { "major",      JSON_VARIANT_UNSIGNED, oci_device_major,       offsetof(struct device_data, major),  JSON_MANDATORY  },
-                        { "minor",      JSON_VARIANT_UNSIGNED, oci_device_minor,       offsetof(struct device_data, minor),  JSON_MANDATORY  },
-                        { "weight",     JSON_VARIANT_UNSIGNED, json_dispatch_uintmax,  offsetof(struct device_data, weight), 0               },
-                        { "leafWeight", JSON_VARIANT_INTEGER,  oci_unsupported,        0,                                    JSON_PERMISSIVE },
+                        { "major",      JSON_VARIANT_UNSIGNED, oci_device_major,     offsetof(struct device_data, major),  JSON_MANDATORY  },
+                        { "minor",      JSON_VARIANT_UNSIGNED, oci_device_minor,     offsetof(struct device_data, minor),  JSON_MANDATORY  },
+                        { "weight",     JSON_VARIANT_UNSIGNED, json_dispatch_uint64, offsetof(struct device_data, weight), 0               },
+                        { "leafWeight", JSON_VARIANT_INTEGER,  oci_unsupported,      0,                                    JSON_PERMISSIVE },
                         {}
                 };
 
@@ -1435,7 +1435,7 @@ static int oci_cgroup_block_io_weight_device(const char *name, JsonVariant *v, J
                 if (r < 0)
                         return r;
 
-                if (data.weight == UINTMAX_MAX)
+                if (data.weight == UINT64_MAX)
                         continue;
 
                 if (data.weight < CGROUP_BLKIO_WEIGHT_MIN || data.weight > CGROUP_BLKIO_WEIGHT_MAX)
@@ -1475,16 +1475,16 @@ static int oci_cgroup_block_io_throttle(const char *name, JsonVariant *v, JsonDi
                 struct device_data {
                         unsigned major;
                         unsigned minor;
-                        uintmax_t rate;
+                        uint64_t rate;
                 } data = {
                         .major = UINT_MAX,
                         .minor = UINT_MAX,
                 };
 
                 static const JsonDispatch table[] = {
-                        { "major", JSON_VARIANT_UNSIGNED, oci_device_major,       offsetof(struct device_data, major), JSON_MANDATORY },
-                        { "minor", JSON_VARIANT_UNSIGNED, oci_device_minor,       offsetof(struct device_data, minor), JSON_MANDATORY },
-                        { "rate",  JSON_VARIANT_UNSIGNED, json_dispatch_uintmax,  offsetof(struct device_data, rate),  JSON_MANDATORY },
+                        { "major", JSON_VARIANT_UNSIGNED, oci_device_major,     offsetof(struct device_data, major), JSON_MANDATORY },
+                        { "minor", JSON_VARIANT_UNSIGNED, oci_device_minor,     offsetof(struct device_data, minor), JSON_MANDATORY },
+                        { "rate",  JSON_VARIANT_UNSIGNED, json_dispatch_uint64, offsetof(struct device_data, rate),  JSON_MANDATORY },
                         {}
                 };
 
@@ -1557,7 +1557,7 @@ static int oci_cgroup_pids(const char *name, JsonVariant *v, JsonDispatchFlags f
 
                 m = (uint64_t) json_variant_unsigned(k);
 
-                if ((uintmax_t) m != json_variant_unsigned(k))
+                if ((uint64_t) m != json_variant_unsigned(k))
                         return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL),
                                         "pids limit out of range, refusing.");
         }
@@ -2097,7 +2097,7 @@ static int oci_linux(const char *name, JsonVariant *v, JsonDispatchFlags flags,
 
 static int oci_hook_timeout(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
         usec_t *u = userdata;
-        uintmax_t k;
+        uint64_t k;
 
         k = json_variant_unsigned(v);
         if (k == 0 || k > (UINT64_MAX-1)/USEC_PER_SEC)

diff --git a/src/nss-resolve/nss-resolve.c b/src/nss-resolve/nss-resolve.c
index e2a29475a225536ffb0c49ce71269393de1dbe29..d77ffdd9f22a41395c835762d1128abad43e45e0 100644 (file)
--- a/src/nss-resolve/nss-resolve.c
+++ b/src/nss-resolve/nss-resolve.c
@@ -82,7 +82,7 @@ static uint32_t ifindex_to_scopeid(int family, const void *a, int ifindex) {
 
 static int json_dispatch_ifindex(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
         int *ifi = userdata;
-        intmax_t t;
+        int64_t t;
 
         assert(variant);
         assert(ifi);
@@ -100,7 +100,7 @@ static int json_dispatch_ifindex(const char *name, JsonVariant *variant, JsonDis
 
 static int json_dispatch_family(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
         int *family = userdata;
-        intmax_t t;
+        int64_t t;
 
         assert(variant);
         assert(family);
@@ -160,7 +160,7 @@ static int json_dispatch_address(const char *name, JsonVariant *variant, JsonDis
                 return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is array of unexpected size.", strna(name));
 
         JSON_VARIANT_ARRAY_FOREACH(i, variant) {
-                intmax_t b;
+                int64_t b;
 
                 if (!json_variant_is_integer(i))
                         return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "Element %zu of JSON field '%s' is not an integer.", k, strna(name));

diff --git a/src/resolve/resolved-varlink.c b/src/resolve/resolved-varlink.c
index 4a26f6b9febd2e369d053fc93b51c14af6868f0b..cc684608a601185688746283b24807766651a3fa 100644 (file)
--- a/src/resolve/resolved-varlink.c
+++ b/src/resolve/resolved-varlink.c
@@ -364,7 +364,7 @@ static int json_dispatch_address(const char *name, JsonVariant *variant, JsonDis
                 return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is array of unexpected size.", strna(name));
 
         JSON_VARIANT_ARRAY_FOREACH(i, variant) {
-                intmax_t b;
+                int64_t b;
 
                 if (!json_variant_is_integer(i))
                         return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "Element %zu of JSON field '%s' is not an integer.", k, strna(name));

diff --git a/src/shared/json-internal.h b/src/shared/json-internal.h
index 652fde6147f3f4fb4102fdb9c26745cb15f11048..778cc51e7564c3b95c0f71fe866e8f453f8cebbe 100644 (file)
--- a/src/shared/json-internal.h
+++ b/src/shared/json-internal.h
@@ -12,8 +12,8 @@ typedef union JsonValue  {
         /* Encodes a simple value. This structure is generally 8 bytes wide (as double is 64bit). */
         bool boolean;
         double real;
-        intmax_t integer;
-        uintmax_t unsig;
+        int64_t integer;
+        uint64_t unsig;
 } JsonValue;
 
 /* Let's protect us against accidental structure size changes on our most relevant arch */

diff --git a/src/shared/json.c b/src/shared/json.c
index 0ee14e7898312b55692aa9d1ef9c81f2146ad346..5e162ec0fffd08e28776460a62c3810e2cf2f81f 100644 (file)
--- a/src/shared/json.c
+++ b/src/shared/json.c
@@ -305,7 +305,7 @@ static int json_variant_new(JsonVariant **ret, JsonVariantType type, size_t spac
         return 0;
 }
 
-int json_variant_new_integer(JsonVariant **ret, intmax_t i) {
+int json_variant_new_integer(JsonVariant **ret, int64_t i) {
         JsonVariant *v;
         int r;
 
@@ -326,7 +326,7 @@ int json_variant_new_integer(JsonVariant **ret, intmax_t i) {
         return 0;
 }
 
-int json_variant_new_unsigned(JsonVariant **ret, uintmax_t u) {
+int json_variant_new_unsigned(JsonVariant **ret, uint64_t u) {
         JsonVariant *v;
         int r;
 
@@ -751,10 +751,10 @@ static size_t json_variant_size(JsonVariant* v) {
                 return offsetof(JsonVariant, value) + sizeof(double);
 
         case JSON_VARIANT_UNSIGNED:
-                return offsetof(JsonVariant, value) + sizeof(uintmax_t);
+                return offsetof(JsonVariant, value) + sizeof(uint64_t);
 
         case JSON_VARIANT_INTEGER:
-                return offsetof(JsonVariant, value) + sizeof(intmax_t);
+                return offsetof(JsonVariant, value) + sizeof(int64_t);
 
         case JSON_VARIANT_BOOLEAN:
                 return offsetof(JsonVariant, value) + sizeof(bool);
@@ -895,7 +895,7 @@ mismatch:
         return false;
 }
 
-intmax_t json_variant_integer(JsonVariant *v) {
+int64_t json_variant_integer(JsonVariant *v) {
         if (!v)
                 goto mismatch;
         if (v == JSON_VARIANT_MAGIC_ZERO_INTEGER ||
@@ -913,16 +913,16 @@ intmax_t json_variant_integer(JsonVariant *v) {
                 return v->value.integer;
 
         case JSON_VARIANT_UNSIGNED:
-                if (v->value.unsig <= INTMAX_MAX)
-                        return (intmax_t) v->value.unsig;
+                if (v->value.unsig <= INT64_MAX)
+                        return (int64_t) v->value.unsig;
 
                 log_debug("Unsigned integer %ju requested as signed integer and out of range, returning 0.", v->value.unsig);
                 return 0;
 
         case JSON_VARIANT_REAL: {
-                intmax_t converted;
+                int64_t converted;
 
-                converted = (intmax_t) v->value.real;
+                converted = (int64_t) v->value.real;
 
                 DISABLE_WARNING_FLOAT_EQUAL;
                 if ((double) converted == v->value.real)
@@ -942,7 +942,7 @@ mismatch:
         return 0;
 }
 
-uintmax_t json_variant_unsigned(JsonVariant *v) {
+uint64_t json_variant_unsigned(JsonVariant *v) {
         if (!v)
                 goto mismatch;
         if (v == JSON_VARIANT_MAGIC_ZERO_INTEGER ||
@@ -958,7 +958,7 @@ uintmax_t json_variant_unsigned(JsonVariant *v) {
 
         case JSON_VARIANT_INTEGER:
                 if (v->value.integer >= 0)
-                        return (uintmax_t) v->value.integer;
+                        return (uint64_t) v->value.integer;
 
                 log_debug("Signed integer %ju requested as unsigned integer and out of range, returning 0.", v->value.integer);
                 return 0;
@@ -967,9 +967,9 @@ uintmax_t json_variant_unsigned(JsonVariant *v) {
                 return v->value.unsig;
 
         case JSON_VARIANT_REAL: {
-                uintmax_t converted;
+                uint64_t converted;
 
-                converted = (uintmax_t) v->value.real;
+                converted = (uint64_t) v->value.real;
 
                 DISABLE_WARNING_FLOAT_EQUAL;
                 if ((double) converted == v->value.real)
@@ -1009,7 +1009,7 @@ double json_variant_real(JsonVariant *v) {
         case JSON_VARIANT_INTEGER: {
                 double converted = (double) v->value.integer;
 
-                if ((intmax_t) converted == v->value.integer)
+                if ((int64_t) converted == v->value.integer)
                         return converted;
 
                 log_debug("Signed integer %ji requested as real, and cannot be converted losslessly, returning 0.", v->value.integer);
@@ -1019,7 +1019,7 @@ double json_variant_real(JsonVariant *v) {
         case JSON_VARIANT_UNSIGNED: {
                 double converted = (double) v->value.unsig;
 
-                if ((uintmax_t) converted == v->value.unsig)
+                if ((uint64_t) converted == v->value.unsig)
                         return converted;
 
                 log_debug("Unsigned integer %ju requested as real, and cannot be converted losslessly, returning 0.", v->value.unsig);
@@ -1155,21 +1155,21 @@ bool json_variant_has_type(JsonVariant *v, JsonVariantType type) {
         if (rt == JSON_VARIANT_INTEGER && type == JSON_VARIANT_UNSIGNED)
                 return v->value.integer >= 0;
         if (rt == JSON_VARIANT_UNSIGNED && type == JSON_VARIANT_INTEGER)
-                return v->value.unsig <= INTMAX_MAX;
+                return v->value.unsig <= INT64_MAX;
 
         /* Any integer that can be converted lossley to a real and back may also be considered a real */
         if (rt == JSON_VARIANT_INTEGER && type == JSON_VARIANT_REAL)
-                return (intmax_t) (double) v->value.integer == v->value.integer;
+                return (int64_t) (double) v->value.integer == v->value.integer;
         if (rt == JSON_VARIANT_UNSIGNED && type == JSON_VARIANT_REAL)
-                return (uintmax_t) (double) v->value.unsig == v->value.unsig;
+                return (uint64_t) (double) v->value.unsig == v->value.unsig;
 
         DISABLE_WARNING_FLOAT_EQUAL;
 
         /* Any real that can be converted losslessly to an integer and back may also be considered an integer */
         if (rt == JSON_VARIANT_REAL && type == JSON_VARIANT_INTEGER)
-                return (double) (intmax_t) v->value.real == v->value.real;
+                return (double) (int64_t) v->value.real == v->value.real;
         if (rt == JSON_VARIANT_REAL && type == JSON_VARIANT_UNSIGNED)
-                return (double) (uintmax_t) v->value.real == v->value.real;
+                return (double) (uint64_t) v->value.real == v->value.real;
 
         REENABLE_WARNING;
 
@@ -1961,7 +1961,7 @@ int json_variant_set_field_string(JsonVariant **v, const char *field, const char
         return json_variant_set_field(v, field, m);
 }
 
-int json_variant_set_field_integer(JsonVariant **v, const char *field, intmax_t i) {
+int json_variant_set_field_integer(JsonVariant **v, const char *field, int64_t i) {
         _cleanup_(json_variant_unrefp) JsonVariant *m = NULL;
         int r;
 
@@ -1972,7 +1972,7 @@ int json_variant_set_field_integer(JsonVariant **v, const char *field, intmax_t
         return json_variant_set_field(v, field, m);
 }
 
-int json_variant_set_field_unsigned(JsonVariant **v, const char *field, uintmax_t u) {
+int json_variant_set_field_unsigned(JsonVariant **v, const char *field, uint64_t u) {
         _cleanup_(json_variant_unrefp) JsonVariant *m = NULL;
         int r;
 
@@ -2189,13 +2189,13 @@ static int json_variant_copy(JsonVariant **nv, JsonVariant *v) {
         t = json_variant_type(v);
         switch (t) {
         case JSON_VARIANT_INTEGER:
-                k = sizeof(intmax_t);
+                k = sizeof(int64_t);
                 value.integer = json_variant_integer(v);
                 source = &value;
                 break;
 
         case JSON_VARIANT_UNSIGNED:
-                k = sizeof(uintmax_t);
+                k = sizeof(uint64_t);
                 value.unsig = json_variant_unsigned(v);
                 source = &value;
                 break;
@@ -2525,8 +2525,8 @@ static int json_parse_string(const char **p, char **ret) {
 static int json_parse_number(const char **p, JsonValue *ret) {
         bool negative = false, exponent_negative = false, is_real = false;
         double x = 0.0, y = 0.0, exponent = 0.0, shift = 1.0;
-        intmax_t i = 0;
-        uintmax_t u = 0;
+        int64_t i = 0;
+        uint64_t u = 0;
         const char *c;
 
         assert(p);
@@ -2550,23 +2550,23 @@ static int json_parse_number(const char **p, JsonValue *ret) {
                         if (!is_real) {
                                 if (negative) {
 
-                                        if (i < INTMAX_MIN / 10) /* overflow */
+                                        if (i < INT64_MIN / 10) /* overflow */
                                                 is_real = true;
                                         else {
-                                                intmax_t t = 10 * i;
+                                                int64_t t = 10 * i;
 
-                                                if (t < INTMAX_MIN + (*c - '0')) /* overflow */
+                                                if (t < INT64_MIN + (*c - '0')) /* overflow */
                                                         is_real = true;
                                                 else
                                                         i = t - (*c - '0');
                                         }
                                 } else {
-                                        if (u > UINTMAX_MAX / 10) /* overflow */
+                                        if (u > UINT64_MAX / 10) /* overflow */
                                                 is_real = true;
                                         else {
-                                                uintmax_t t = 10 * u;
+                                                uint64_t t = 10 * u;
 
-                                                if (t > UINTMAX_MAX - (*c - '0')) /* overflow */
+                                                if (t > UINT64_MAX - (*c - '0')) /* overflow */
                                                         is_real = true;
                                                 else
                                                         u = t + (*c - '0');
@@ -3288,14 +3288,14 @@ int json_buildv(JsonVariant **ret, va_list ap) {
                 }
 
                 case _JSON_BUILD_INTEGER: {
-                        intmax_t j;
+                        int64_t j;
 
                         if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                 r = -EINVAL;
                                 goto finish;
                         }
 
-                        j = va_arg(ap, intmax_t);
+                        j = va_arg(ap, int64_t);
 
                         if (current->n_suppress == 0) {
                                 r = json_variant_new_integer(&add, j);
@@ -3316,14 +3316,14 @@ int json_buildv(JsonVariant **ret, va_list ap) {
                 }
 
                 case _JSON_BUILD_UNSIGNED: {
-                        uintmax_t j;
+                        uint64_t j;
 
                         if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
                                 r = -EINVAL;
                                 goto finish;
                         }
 
-                        j = va_arg(ap, uintmax_t);
+                        j = va_arg(ap, uint64_t);
 
                         if (current->n_suppress == 0) {
                                 r = json_variant_new_unsigned(&add, j);
@@ -4064,8 +4064,8 @@ int json_dispatch_tristate(const char *name, JsonVariant *variant, JsonDispatchF
         return 0;
 }
 
-int json_dispatch_intmax(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
-        intmax_t *i = userdata;
+int json_dispatch_int64(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+        int64_t *i = userdata;
 
         assert(variant);
         assert(i);
@@ -4077,8 +4077,8 @@ int json_dispatch_intmax(const char *name, JsonVariant *variant, JsonDispatchFla
         return 0;
 }
 
-int json_dispatch_uintmax(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
-        uintmax_t *u = userdata;
+int json_dispatch_uint64(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
+        uint64_t *u = userdata;
 
         assert(variant);
         assert(u);
@@ -4228,7 +4228,7 @@ int json_dispatch_variant(const char *name, JsonVariant *variant, JsonDispatchFl
 
 int json_dispatch_uid_gid(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
         uid_t *uid = userdata;
-        uintmax_t k;
+        uint64_t k;
 
         assert_cc(sizeof(uid_t) == sizeof(uint32_t));
         assert_cc(sizeof(gid_t) == sizeof(uint32_t));

diff --git a/src/shared/json.h b/src/shared/json.h
index 6e649a3c339b69012c123325235752f4fde1e313..0676e7bf5c8c6b8382111879df72138da7faaea1 100644 (file)
--- a/src/shared/json.h
+++ b/src/shared/json.h
@@ -59,8 +59,8 @@ typedef enum JsonVariantType {
 int json_variant_new_stringn(JsonVariant **ret, const char *s, size_t n);
 int json_variant_new_base64(JsonVariant **ret, const void *p, size_t n);
 int json_variant_new_hex(JsonVariant **ret, const void *p, size_t n);
-int json_variant_new_integer(JsonVariant **ret, intmax_t i);
-int json_variant_new_unsigned(JsonVariant **ret, uintmax_t u);
+int json_variant_new_integer(JsonVariant **ret, int64_t i);
+int json_variant_new_unsigned(JsonVariant **ret, uint64_t u);
 int json_variant_new_real(JsonVariant **ret, double d);
 int json_variant_new_boolean(JsonVariant **ret, bool b);
 int json_variant_new_array(JsonVariant **ret, JsonVariant **array, size_t n);
@@ -81,8 +81,8 @@ void json_variant_unref_many(JsonVariant **array, size_t n);
 DEFINE_TRIVIAL_CLEANUP_FUNC(JsonVariant *, json_variant_unref);
 
 const char *json_variant_string(JsonVariant *v);
-intmax_t json_variant_integer(JsonVariant *v);
-uintmax_t json_variant_unsigned(JsonVariant *v);
+int64_t json_variant_integer(JsonVariant *v);
+uint64_t json_variant_unsigned(JsonVariant *v);
 double json_variant_real(JsonVariant *v);
 bool json_variant_boolean(JsonVariant *v);
 
@@ -189,8 +189,8 @@ int json_variant_filter(JsonVariant **v, char **to_remove);
 
 int json_variant_set_field(JsonVariant **v, const char *field, JsonVariant *value);
 int json_variant_set_field_string(JsonVariant **v, const char *field, const char *value);
-int json_variant_set_field_integer(JsonVariant **v, const char *field, intmax_t value);
-int json_variant_set_field_unsigned(JsonVariant **v, const char *field, uintmax_t value);
+int json_variant_set_field_integer(JsonVariant **v, const char *field, int64_t value);
+int json_variant_set_field_unsigned(JsonVariant **v, const char *field, uint64_t value);
 int json_variant_set_field_boolean(JsonVariant **v, const char *field, bool b);
 int json_variant_set_field_strv(JsonVariant **v, const char *field, char **l);
 
@@ -240,8 +240,8 @@ enum {
 };
 
 #define JSON_BUILD_STRING(s) _JSON_BUILD_STRING, (const char*) { s }
-#define JSON_BUILD_INTEGER(i) _JSON_BUILD_INTEGER, (intmax_t) { i }
-#define JSON_BUILD_UNSIGNED(u) _JSON_BUILD_UNSIGNED, (uintmax_t) { u }
+#define JSON_BUILD_INTEGER(i) _JSON_BUILD_INTEGER, (int64_t) { i }
+#define JSON_BUILD_UNSIGNED(u) _JSON_BUILD_UNSIGNED, (uint64_t) { u }
 #define JSON_BUILD_REAL(d) _JSON_BUILD_REAL, (double) { d }
 #define JSON_BUILD_BOOLEAN(b) _JSON_BUILD_BOOLEAN, (bool) { b }
 #define JSON_BUILD_ARRAY(...) _JSON_BUILD_ARRAY_BEGIN, __VA_ARGS__, _JSON_BUILD_ARRAY_END
@@ -297,8 +297,8 @@ int json_dispatch_strv(const char *name, JsonVariant *variant, JsonDispatchFlags
 int json_dispatch_boolean(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
 int json_dispatch_tristate(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
 int json_dispatch_variant(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_intmax(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
-int json_dispatch_uintmax(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
+int json_dispatch_int64(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
+int json_dispatch_uint64(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
 int json_dispatch_uint32(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
 int json_dispatch_int32(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
 int json_dispatch_uid_gid(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
@@ -306,12 +306,6 @@ int json_dispatch_user_group_name(const char *name, JsonVariant *variant, JsonDi
 int json_dispatch_id128(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
 int json_dispatch_unsupported(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata);
 
-assert_cc(sizeof(uintmax_t) == sizeof(uint64_t));
-#define json_dispatch_uint64 json_dispatch_uintmax
-
-assert_cc(sizeof(intmax_t) == sizeof(int64_t));
-#define json_dispatch_int64 json_dispatch_intmax
-
 assert_cc(sizeof(uint32_t) == sizeof(unsigned));
 #define json_dispatch_uint json_dispatch_uint32
 

diff --git a/src/shared/user-record.c b/src/shared/user-record.c
index e16395f03276b9c18fcc36626789ee86812f6924..268f8a3998fe9046adb24d349c6cc5ec9811cb1b 100644 (file)
--- a/src/shared/user-record.c
+++ b/src/shared/user-record.c
@@ -252,7 +252,7 @@ int json_dispatch_gecos(const char *name, JsonVariant *variant, JsonDispatchFlag
 
 static int json_dispatch_nice(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
         int *nl = userdata;
-        intmax_t m;
+        int64_t m;
 
         if (json_variant_is_null(variant)) {
                 *nl = INT_MAX;
@@ -276,10 +276,10 @@ static int json_dispatch_rlimit_value(const char *name, JsonVariant *variant, Js
         if (json_variant_is_null(variant))
                 *ret = RLIM_INFINITY;
         else if (json_variant_is_unsigned(variant)) {
-                uintmax_t w;
+                uint64_t w;
 
                 w = json_variant_unsigned(variant);
-                if (w == RLIM_INFINITY || (uintmax_t) w != json_variant_unsigned(variant))
+                if (w == RLIM_INFINITY || (uint64_t) w != json_variant_unsigned(variant))
                         return json_log(variant, flags, SYNTHETIC_ERRNO(ERANGE), "Resource limit value '%s' is out of range.", name);
 
                 *ret = (rlim_t) w;
@@ -453,7 +453,7 @@ static int json_dispatch_image_path(const char *name, JsonVariant *variant, Json
 
 static int json_dispatch_umask(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
         mode_t *m = userdata;
-        uintmax_t k;
+        uint64_t k;
 
         if (json_variant_is_null(variant)) {
                 *m = MODE_INVALID;
@@ -473,7 +473,7 @@ static int json_dispatch_umask(const char *name, JsonVariant *variant, JsonDispa
 
 static int json_dispatch_access_mode(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
         mode_t *m = userdata;
-        uintmax_t k;
+        uint64_t k;
 
         if (json_variant_is_null(variant)) {
                 *m = MODE_INVALID;
@@ -564,8 +564,7 @@ static int json_dispatch_storage(const char *name, JsonVariant *variant, JsonDis
 }
 
 static int json_dispatch_tasks_or_memory_max(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
-        uint64_t *limit = userdata;
-        uintmax_t k;
+        uint64_t *limit = userdata, k;
 
         if (json_variant_is_null(variant)) {
                 *limit = UINT64_MAX;
@@ -584,8 +583,7 @@ static int json_dispatch_tasks_or_memory_max(const char *name, JsonVariant *vari
 }
 
 static int json_dispatch_weight(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
-        uint64_t *weight = userdata;
-        uintmax_t k;
+        uint64_t *weight = userdata, k;
 
         if (json_variant_is_null(variant)) {
                 *weight = UINT64_MAX;

diff --git a/src/test/test-json.c b/src/test/test-json.c
index 83f3d566a6e76a9f421f950cd304e7f5a8560cba..d0bc810c7f36582d41c16b1318030a4e1b1f02f9 100644 (file)
--- a/src/test/test-json.c
+++ b/src/test/test-json.c
@@ -54,15 +54,15 @@ static void test_tokenizer(const char *data, ...) {
                                   fabsl((d - v.real) / v.real) < 1e-10);
 
                 } else if (t == JSON_TOKEN_INTEGER) {
-                        intmax_t i;
+                        int64_t i;
 
-                        i = va_arg(ap, intmax_t);
+                        i = va_arg(ap, int64_t);
                         assert_se(i == v.integer);
 
                 } else if (t == JSON_TOKEN_UNSIGNED) {
-                        uintmax_t u;
+                        uint64_t u;
 
-                        u = va_arg(ap, uintmax_t);
+                        u = va_arg(ap, uint64_t);
                         assert_se(u == v.unsig);
 
                 } else if (t == JSON_TOKEN_BOOLEAN) {
@@ -575,15 +575,15 @@ int main(int argc, char *argv[]) {
         test_tokenizer("x", -EINVAL);
         test_tokenizer("", JSON_TOKEN_END);
         test_tokenizer(" ", JSON_TOKEN_END);
-        test_tokenizer("0", JSON_TOKEN_UNSIGNED, (uintmax_t) 0, JSON_TOKEN_END);
-        test_tokenizer("-0", JSON_TOKEN_INTEGER, (intmax_t) 0, JSON_TOKEN_END);
-        test_tokenizer("1234", JSON_TOKEN_UNSIGNED, (uintmax_t) 1234, JSON_TOKEN_END);
-        test_tokenizer("-1234", JSON_TOKEN_INTEGER, (intmax_t) -1234, JSON_TOKEN_END);
-        test_tokenizer("18446744073709551615", JSON_TOKEN_UNSIGNED, (uintmax_t) UINT64_MAX, JSON_TOKEN_END);
-        test_tokenizer("-9223372036854775808", JSON_TOKEN_INTEGER, (intmax_t) INT64_MIN, JSON_TOKEN_END);
+        test_tokenizer("0", JSON_TOKEN_UNSIGNED, (uint64_t) 0, JSON_TOKEN_END);
+        test_tokenizer("-0", JSON_TOKEN_INTEGER, (int64_t) 0, JSON_TOKEN_END);
+        test_tokenizer("1234", JSON_TOKEN_UNSIGNED, (uint64_t) 1234, JSON_TOKEN_END);
+        test_tokenizer("-1234", JSON_TOKEN_INTEGER, (int64_t) -1234, JSON_TOKEN_END);
+        test_tokenizer("18446744073709551615", JSON_TOKEN_UNSIGNED, (uint64_t) UINT64_MAX, JSON_TOKEN_END);
+        test_tokenizer("-9223372036854775808", JSON_TOKEN_INTEGER, (int64_t) INT64_MIN, JSON_TOKEN_END);
         test_tokenizer("18446744073709551616", JSON_TOKEN_REAL, (double) 18446744073709551616.0L, JSON_TOKEN_END);
         test_tokenizer("-9223372036854775809", JSON_TOKEN_REAL, (double) -9223372036854775809.0L, JSON_TOKEN_END);
-        test_tokenizer("-1234", JSON_TOKEN_INTEGER, (intmax_t) -1234, JSON_TOKEN_END);
+        test_tokenizer("-1234", JSON_TOKEN_INTEGER, (int64_t) -1234, JSON_TOKEN_END);
         test_tokenizer("3.141", JSON_TOKEN_REAL, (double) 3.141, JSON_TOKEN_END);
         test_tokenizer("0.0", JSON_TOKEN_REAL, (double) 0.0, JSON_TOKEN_END);
         test_tokenizer("7e3", JSON_TOKEN_REAL, (double) 7e3, JSON_TOKEN_END);
@@ -607,7 +607,7 @@ int main(int argc, char *argv[]) {
         test_tokenizer("\"\\udc00\\udc00\"", -EINVAL);
         test_tokenizer("\"\\ud801\\udc37\"", JSON_TOKEN_STRING, "\xf0\x90\x90\xb7", JSON_TOKEN_END);
 
-        test_tokenizer("[1, 2, -3]", JSON_TOKEN_ARRAY_OPEN, JSON_TOKEN_UNSIGNED, (uintmax_t) 1, JSON_TOKEN_COMMA, JSON_TOKEN_UNSIGNED, (uintmax_t) 2, JSON_TOKEN_COMMA, JSON_TOKEN_INTEGER, (intmax_t) -3, JSON_TOKEN_ARRAY_CLOSE, JSON_TOKEN_END);
+        test_tokenizer("[1, 2, -3]", JSON_TOKEN_ARRAY_OPEN, JSON_TOKEN_UNSIGNED, (uint64_t) 1, JSON_TOKEN_COMMA, JSON_TOKEN_UNSIGNED, (uint64_t) 2, JSON_TOKEN_COMMA, JSON_TOKEN_INTEGER, (int64_t) -3, JSON_TOKEN_ARRAY_CLOSE, JSON_TOKEN_END);
 
         test_variant("{\"k\": \"v\", \"foo\": [1, 2, 3], \"bar\": {\"zap\": null}}", test_1);
         test_variant("{\"mutant\": [1, null, \"1\", {\"1\": [1, \"1\"]}], \"thisisaverylongproperty\": 1.27}", test_2);

diff --git a/src/test/test-varlink.c b/src/test/test-varlink.c
index a2708ecd086c7dbcc462c05989fbacc5f61013f7..d442b8b5f195683679e1726cc932a253bf53f823 100644 (file)
--- a/src/test/test-varlink.c
+++ b/src/test/test-varlink.c
@@ -26,7 +26,7 @@ static int block_write_fd = -1;
 static int method_something(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
         _cleanup_(json_variant_unrefp) JsonVariant *ret = NULL;
         JsonVariant *a, *b;
-        intmax_t x, y;
+        int64_t x, y;
         int r;
 
         a = json_variant_by_key(parameters, "a");