← Commit list

94ce87c391

Stefan Eissing
Stefan Eissing
2025-11-26
SUCCESS Duration: 148s

Subject

types: remove curl_int64_t/curl_uint64_t

Binary

No binary (build failed)

Architecture & Compiler Flags

Architecture: x86_64-linux-gnu Compiler: gcc (Ubuntu 11.4.0-1ubuntu1~22.04.3) 11.4.0

—

Build Log

(log yok)

Commit Diff GitHub →

lib/curl_setup.h +0 -14lib/curl_sha512_256.c +90 -90lib/vquic/curl_osslq.c +3 -4src/tool_util.c +4 -4
lib/curl_setup.h+0 -14
@@ -571,20 +571,6 @@
#endif
#define CURL_OFF_T_MIN (-CURL_OFF_T_MAX - 1)
-#if (SIZEOF_CURL_OFF_T != 8)
-# error "curl_off_t must be exactly 64 bits"
-#else
- typedef unsigned CURL_TYPEOF_CURL_OFF_T curl_uint64_t;
- typedef CURL_TYPEOF_CURL_OFF_T curl_int64_t;
-# ifndef CURL_SUFFIX_CURL_OFF_TU
-# error "CURL_SUFFIX_CURL_OFF_TU must be defined"
-# endif
-# define CURL_UINT64_SUFFIX CURL_SUFFIX_CURL_OFF_TU
-# define CURL_UINT64_C(val) CURL_CONC_MACROS(val,CURL_UINT64_SUFFIX)
-# define FMT_PRId64 CURL_FORMAT_CURL_OFF_T
-# define FMT_PRIu64 CURL_FORMAT_CURL_OFF_TU
-#endif
-
#define FMT_OFF_T CURL_FORMAT_CURL_OFF_T
#define FMT_OFF_TU CURL_FORMAT_CURL_OFF_TU
lib/curl_sha512_256.c+90 -90
@@ -287,30 +287,30 @@ static CURLcode Curl_sha512_256_finish(unsigned char *digest,
Can be moved to other headers to reuse. */
#define CURL_GET_64BIT_BE(ptr) \
- ( ((curl_uint64_t)(((const unsigned char*)(ptr))[0]) << 56) | \
- ((curl_uint64_t)(((const unsigned char*)(ptr))[1]) << 48) | \
- ((curl_uint64_t)(((const unsigned char*)(ptr))[2]) << 40) | \
- ((curl_uint64_t)(((const unsigned char*)(ptr))[3]) << 32) | \
- ((curl_uint64_t)(((const unsigned char*)(ptr))[4]) << 24) | \
- ((curl_uint64_t)(((const unsigned char*)(ptr))[5]) << 16) | \
- ((curl_uint64_t)(((const unsigned char*)(ptr))[6]) << 8) | \
- (curl_uint64_t)(((const unsigned char*)(ptr))[7]) )
+ ( ((uint64_t)(((const uint8_t*)(ptr))[0]) << 56) | \
+ ((uint64_t)(((const uint8_t*)(ptr))[1]) << 48) | \
+ ((uint64_t)(((const uint8_t*)(ptr))[2]) << 40) | \
+ ((uint64_t)(((const uint8_t*)(ptr))[3]) << 32) | \
+ ((uint64_t)(((const uint8_t*)(ptr))[4]) << 24) | \
+ ((uint64_t)(((const uint8_t*)(ptr))[5]) << 16) | \
+ ((uint64_t)(((const uint8_t*)(ptr))[6]) << 8) | \
+ (uint64_t)(((const uint8_t*)(ptr))[7]) )
#define CURL_PUT_64BIT_BE(ptr,val) do { \
- ((unsigned char*)(ptr))[7]=(unsigned char)((curl_uint64_t)(val)); \
- ((unsigned char*)(ptr))[6]=(unsigned char)(((curl_uint64_t)(val)) >> 8); \
- ((unsigned char*)(ptr))[5]=(unsigned char)(((curl_uint64_t)(val)) >> 16); \
- ((unsigned char*)(ptr))[4]=(unsigned char)(((curl_uint64_t)(val)) >> 24); \
- ((unsigned char*)(ptr))[3]=(unsigned char)(((curl_uint64_t)(val)) >> 32); \
- ((unsigned char*)(ptr))[2]=(unsigned char)(((curl_uint64_t)(val)) >> 40); \
- ((unsigned char*)(ptr))[1]=(unsigned char)(((curl_uint64_t)(val)) >> 48); \
- ((unsigned char*)(ptr))[0]=(unsigned char)(((curl_uint64_t)(val)) >> 56); \
+ ((uint8_t*)(ptr))[7]=(uint8_t)((uint64_t)(val)); \
+ ((uint8_t*)(ptr))[6]=(uint8_t)(((uint64_t)(val)) >> 8); \
+ ((uint8_t*)(ptr))[5]=(uint8_t)(((uint64_t)(val)) >> 16); \
+ ((uint8_t*)(ptr))[4]=(uint8_t)(((uint64_t)(val)) >> 24); \
+ ((uint8_t*)(ptr))[3]=(uint8_t)(((uint64_t)(val)) >> 32); \
+ ((uint8_t*)(ptr))[2]=(uint8_t)(((uint64_t)(val)) >> 40); \
+ ((uint8_t*)(ptr))[1]=(uint8_t)(((uint64_t)(val)) >> 48); \
+ ((uint8_t*)(ptr))[0]=(uint8_t)(((uint64_t)(val)) >> 56); \
} while(0)
/* Defined as a function. The macro version may duplicate the binary code
* size as each argument is used twice, so if any calculation is used
* as an argument, the calculation could be done twice. */
-static CURL_FORCEINLINE curl_uint64_t Curl_rotr64(curl_uint64_t value,
+static CURL_FORCEINLINE uint64_t Curl_rotr64(uint64_t value,
unsigned int bits)
{
bits %= 64;
@@ -376,22 +376,22 @@ struct Curl_sha512_256ctx {
* compilers may automatically use fast load/store instruction for big
* endian data on little endian machine.
*/
- curl_uint64_t H[SHA512_256_HASH_SIZE_WORDS];
+ uint64_t H[SHA512_256_HASH_SIZE_WORDS];
/**
* SHA-512/256 input data buffer. The buffer is properly aligned. Smart
* compilers may automatically use fast load/store instruction for big
* endian data on little endian machine.
*/
- curl_uint64_t buffer[SHA512_256_BLOCK_SIZE_WORDS];
+ uint64_t buffer[SHA512_256_BLOCK_SIZE_WORDS];
/**
* The number of bytes, lower part
*/
- curl_uint64_t count;
+ uint64_t count;
/**
* The number of bits, high part. Unlike lower part, this counts the number
* of bits, not bytes.
*/
- curl_uint64_t count_bits_hi;
+ uint64_t count_bits_hi;
};
/**
@@ -413,23 +413,23 @@ static CURLcode Curl_sha512_256_init(void *context)
/* Check whether the header and this file use the same numbers */
DEBUGASSERT(CURL_SHA512_256_DIGEST_LENGTH == CURL_SHA512_256_DIGEST_SIZE);
- DEBUGASSERT(sizeof(curl_uint64_t) == 8);
+ DEBUGASSERT(sizeof(uint64_t) == 8);
/* Initial hash values, see FIPS PUB 180-4 section 5.3.6.2 */
/* Values generated by "IV Generation Function" as described in
* section 5.3.6 */
- ctx->H[0] = CURL_UINT64_C(0x22312194FC2BF72C);
- ctx->H[1] = CURL_UINT64_C(0x9F555FA3C84C64C2);
- ctx->H[2] = CURL_UINT64_C(0x2393B86B6F53B151);
- ctx->H[3] = CURL_UINT64_C(0x963877195940EABD);
- ctx->H[4] = CURL_UINT64_C(0x96283EE2A88EFFE3);
- ctx->H[5] = CURL_UINT64_C(0xBE5E1E2553863992);
- ctx->H[6] = CURL_UINT64_C(0x2B0199FC2C85B8AA);
- ctx->H[7] = CURL_UINT64_C(0x0EB72DDC81C52CA2);
+ ctx->H[0] = UINT64_C(0x22312194FC2BF72C);
+ ctx->H[1] = UINT64_C(0x9F555FA3C84C64C2);
+ ctx->H[2] = UINT64_C(0x2393B86B6F53B151);
+ ctx->H[3] = UINT64_C(0x963877195940EABD);
+ ctx->H[4] = UINT64_C(0x96283EE2A88EFFE3);
+ ctx->H[5] = UINT64_C(0xBE5E1E2553863992);
+ ctx->H[6] = UINT64_C(0x2B0199FC2C85B8AA);
+ ctx->H[7] = UINT64_C(0x0EB72DDC81C52CA2);
/* Initialise number of bytes and high part of number of bits. */
- ctx->count = CURL_UINT64_C(0);
- ctx->count_bits_hi = CURL_UINT64_C(0);
+ ctx->count = UINT64_C(0);
+ ctx->count_bits_hi = UINT64_C(0);
return CURLE_OK;
}
@@ -442,23 +442,23 @@ static CURLcode Curl_sha512_256_init(void *context)
* @param data the data buffer with #CURL_SHA512_256_BLOCK_SIZE bytes block
*/
static
-void Curl_sha512_256_transform(curl_uint64_t H[SHA512_256_HASH_SIZE_WORDS],
+void Curl_sha512_256_transform(uint64_t H[SHA512_256_HASH_SIZE_WORDS],
const void *data)
{
/* Working variables,
see FIPS PUB 180-4 section 6.7, 6.4. */
- curl_uint64_t a = H[0];
- curl_uint64_t b = H[1];
- curl_uint64_t c = H[2];
- curl_uint64_t d = H[3];
- curl_uint64_t e = H[4];
- curl_uint64_t f = H[5];
- curl_uint64_t g = H[6];
- curl_uint64_t h = H[7];
+ uint64_t a = H[0];
+ uint64_t b = H[1];
+ uint64_t c = H[2];
+ uint64_t d = H[3];
+ uint64_t e = H[4];
+ uint64_t f = H[5];
+ uint64_t g = H[6];
+ uint64_t h = H[7];
/* Data buffer, used as a cyclic buffer.
See FIPS PUB 180-4 section 5.2.2, 6.7, 6.4. */
- curl_uint64_t W[16];
+ uint64_t W[16];
/* 'Ch' and 'Maj' macro functions are defined with widely-used optimization.
See FIPS PUB 180-4 formulae 4.8, 4.9. */
@@ -480,47 +480,47 @@ void Curl_sha512_256_transform(curl_uint64_t H[SHA512_256_HASH_SIZE_WORDS],
unsigned int t;
/* K constants array.
See FIPS PUB 180-4 section 4.2.3 for K values. */
- static const curl_uint64_t K[80] = {
- CURL_UINT64_C(0x428a2f98d728ae22), CURL_UINT64_C(0x7137449123ef65cd),
- CURL_UINT64_C(0xb5c0fbcfec4d3b2f), CURL_UINT64_C(0xe9b5dba58189dbbc),
- CURL_UINT64_C(0x3956c25bf348b538), CURL_UINT64_C(0x59f111f1b605d019),
- CURL_UINT64_C(0x923f82a4af194f9b), CURL_UINT64_C(0xab1c5ed5da6d8118),
- CURL_UINT64_C(0xd807aa98a3030242), CURL_UINT64_C(0x12835b0145706fbe),
- CURL_UINT64_C(0x243185be4ee4b28c), CURL_UINT64_C(0x550c7dc3d5ffb4e2),
- CURL_UINT64_C(0x72be5d74f27b896f), CURL_UINT64_C(0x80deb1fe3b1696b1),
- CURL_UINT64_C(0x9bdc06a725c71235), CURL_UINT64_C(0xc19bf174cf692694),
- CURL_UINT64_C(0xe49b69c19ef14ad2), CURL_UINT64_C(0xefbe4786384f25e3),
- CURL_UINT64_C(0x0fc19dc68b8cd5b5), CURL_UINT64_C(0x240ca1cc77ac9c65),
- CURL_UINT64_C(0x2de92c6f592b0275), CURL_UINT64_C(0x4a7484aa6ea6e483),
- CURL_UINT64_C(0x5cb0a9dcbd41fbd4), CURL_UINT64_C(0x76f988da831153b5),
- CURL_UINT64_C(0x983e5152ee66dfab), CURL_UINT64_C(0xa831c66d2db43210),
- CURL_UINT64_C(0xb00327c898fb213f), CURL_UINT64_C(0xbf597fc7beef0ee4),
- CURL_UINT64_C(0xc6e00bf33da88fc2), CURL_UINT64_C(0xd5a79147930aa725),
- CURL_UINT64_C(0x06ca6351e003826f), CURL_UINT64_C(0x142929670a0e6e70),
- CURL_UINT64_C(0x27b70a8546d22ffc), CURL_UINT64_C(0x2e1b21385c26c926),
- CURL_UINT64_C(0x4d2c6dfc5ac42aed), CURL_UINT64_C(0x53380d139d95b3df),
- CURL_UINT64_C(0x650a73548baf63de), CURL_UINT64_C(0x766a0abb3c77b2a8),
- CURL_UINT64_C(0x81c2c92e47edaee6), CURL_UINT64_C(0x92722c851482353b),
- CURL_UINT64_C(0xa2bfe8a14cf10364), CURL_UINT64_C(0xa81a664bbc423001),
- CURL_UINT64_C(0xc24b8b70d0f89791), CURL_UINT64_C(0xc76c51a30654be30),
- CURL_UINT64_C(0xd192e819d6ef5218), CURL_UINT64_C(0xd69906245565a910),
- CURL_UINT64_C(0xf40e35855771202a), CURL_UINT64_C(0x106aa07032bbd1b8),
- CURL_UINT64_C(0x19a4c116b8d2d0c8), CURL_UINT64_C(0x1e376c085141ab53),
- CURL_UINT64_C(0x2748774cdf8eeb99), CURL_UINT64_C(0x34b0bcb5e19b48a8),
- CURL_UINT64_C(0x391c0cb3c5c95a63), CURL_UINT64_C(0x4ed8aa4ae3418acb),
- CURL_UINT64_C(0x5b9cca4f7763e373), CURL_UINT64_C(0x682e6ff3d6b2b8a3),
- CURL_UINT64_C(0x748f82ee5defb2fc), CURL_UINT64_C(0x78a5636f43172f60),
- CURL_UINT64_C(0x84c87814a1f0ab72), CURL_UINT64_C(0x8cc702081a6439ec),
- CURL_UINT64_C(0x90befffa23631e28), CURL_UINT64_C(0xa4506cebde82bde9),
- CURL_UINT64_C(0xbef9a3f7b2c67915), CURL_UINT64_C(0xc67178f2e372532b),
- CURL_UINT64_C(0xca273eceea26619c), CURL_UINT64_C(0xd186b8c721c0c207),
- CURL_UINT64_C(0xeada7dd6cde0eb1e), CURL_UINT64_C(0xf57d4f7fee6ed178),
- CURL_UINT64_C(0x06f067aa72176fba), CURL_UINT64_C(0x0a637dc5a2c898a6),
- CURL_UINT64_C(0x113f9804bef90dae), CURL_UINT64_C(0x1b710b35131c471b),
- CURL_UINT64_C(0x28db77f523047d84), CURL_UINT64_C(0x32caab7b40c72493),
- CURL_UINT64_C(0x3c9ebe0a15c9bebc), CURL_UINT64_C(0x431d67c49c100d4c),
- CURL_UINT64_C(0x4cc5d4becb3e42b6), CURL_UINT64_C(0x597f299cfc657e2a),
- CURL_UINT64_C(0x5fcb6fab3ad6faec), CURL_UINT64_C(0x6c44198c4a475817)
+ static const uint64_t K[80] = {
+ UINT64_C(0x428a2f98d728ae22), UINT64_C(0x7137449123ef65cd),
+ UINT64_C(0xb5c0fbcfec4d3b2f), UINT64_C(0xe9b5dba58189dbbc),
+ UINT64_C(0x3956c25bf348b538), UINT64_C(0x59f111f1b605d019),
+ UINT64_C(0x923f82a4af194f9b), UINT64_C(0xab1c5ed5da6d8118),
+ UINT64_C(0xd807aa98a3030242), UINT64_C(0x12835b0145706fbe),
+ UINT64_C(0x243185be4ee4b28c), UINT64_C(0x550c7dc3d5ffb4e2),
+ UINT64_C(0x72be5d74f27b896f), UINT64_C(0x80deb1fe3b1696b1),
+ UINT64_C(0x9bdc06a725c71235), UINT64_C(0xc19bf174cf692694),
+ UINT64_C(0xe49b69c19ef14ad2), UINT64_C(0xefbe4786384f25e3),
+ UINT64_C(0x0fc19dc68b8cd5b5), UINT64_C(0x240ca1cc77ac9c65),
+ UINT64_C(0x2de92c6f592b0275), UINT64_C(0x4a7484aa6ea6e483),
+ UINT64_C(0x5cb0a9dcbd41fbd4), UINT64_C(0x76f988da831153b5),
+ UINT64_C(0x983e5152ee66dfab), UINT64_C(0xa831c66d2db43210),
+ UINT64_C(0xb00327c898fb213f), UINT64_C(0xbf597fc7beef0ee4),
+ UINT64_C(0xc6e00bf33da88fc2), UINT64_C(0xd5a79147930aa725),
+ UINT64_C(0x06ca6351e003826f), UINT64_C(0x142929670a0e6e70),
+ UINT64_C(0x27b70a8546d22ffc), UINT64_C(0x2e1b21385c26c926),
+ UINT64_C(0x4d2c6dfc5ac42aed), UINT64_C(0x53380d139d95b3df),
+ UINT64_C(0x650a73548baf63de), UINT64_C(0x766a0abb3c77b2a8),
+ UINT64_C(0x81c2c92e47edaee6), UINT64_C(0x92722c851482353b),
+ UINT64_C(0xa2bfe8a14cf10364), UINT64_C(0xa81a664bbc423001),
+ UINT64_C(0xc24b8b70d0f89791), UINT64_C(0xc76c51a30654be30),
+ UINT64_C(0xd192e819d6ef5218), UINT64_C(0xd69906245565a910),
+ UINT64_C(0xf40e35855771202a), UINT64_C(0x106aa07032bbd1b8),
+ UINT64_C(0x19a4c116b8d2d0c8), UINT64_C(0x1e376c085141ab53),
+ UINT64_C(0x2748774cdf8eeb99), UINT64_C(0x34b0bcb5e19b48a8),
+ UINT64_C(0x391c0cb3c5c95a63), UINT64_C(0x4ed8aa4ae3418acb),
+ UINT64_C(0x5b9cca4f7763e373), UINT64_C(0x682e6ff3d6b2b8a3),
+ UINT64_C(0x748f82ee5defb2fc), UINT64_C(0x78a5636f43172f60),
+ UINT64_C(0x84c87814a1f0ab72), UINT64_C(0x8cc702081a6439ec),
+ UINT64_C(0x90befffa23631e28), UINT64_C(0xa4506cebde82bde9),
+ UINT64_C(0xbef9a3f7b2c67915), UINT64_C(0xc67178f2e372532b),
+ UINT64_C(0xca273eceea26619c), UINT64_C(0xd186b8c721c0c207),
+ UINT64_C(0xeada7dd6cde0eb1e), UINT64_C(0xf57d4f7fee6ed178),
+ UINT64_C(0x06f067aa72176fba), UINT64_C(0x0a637dc5a2c898a6),
+ UINT64_C(0x113f9804bef90dae), UINT64_C(0x1b710b35131c471b),
+ UINT64_C(0x28db77f523047d84), UINT64_C(0x32caab7b40c72493),
+ UINT64_C(0x3c9ebe0a15c9bebc), UINT64_C(0x431d67c49c100d4c),
+ UINT64_C(0x4cc5d4becb3e42b6), UINT64_C(0x597f299cfc657e2a),
+ UINT64_C(0x5fcb6fab3ad6faec), UINT64_C(0x6c44198c4a475817)
};
/* One step of SHA-512/256 computation,
@@ -541,7 +541,7 @@ void Curl_sha512_256_transform(curl_uint64_t H[SHA512_256_HASH_SIZE_WORDS],
see FIPS PUB 180-4 section 6.4.2 step 3. This macro version reassigns
all working variables on each step. */
#define SHA2STEP64RV(vA,vB,vC,vD,vE,vF,vG,vH,kt,wt) do { \
- curl_uint64_t tmp_h_ = (vH); \
+ uint64_t tmp_h_ = (vH); \
SHA2STEP64((vA),(vB),(vC),(vD),(vE),(vF),(vG),tmp_h_,(kt),(wt)); \
(vH) = (vG); \
(vG) = (vF); \
@@ -558,7 +558,7 @@ void Curl_sha512_256_transform(curl_uint64_t H[SHA512_256_HASH_SIZE_WORDS],
see FIPS PUB 180-4 section 3.1.2. */
#define SHA512_GET_W_FROM_DATA(buf,t) \
CURL_GET_64BIT_BE( \
- ((const unsigned char*) (buf)) + (t) * SHA512_256_BYTES_IN_WORD)
+ ((const uint8_t*) (buf)) + (t) * SHA512_256_BYTES_IN_WORD)
/* During first 16 steps, before making any calculation on each step, the
W element is read from the input data buffer as a big-endian value and
@@ -573,9 +573,9 @@ void Curl_sha512_256_transform(curl_uint64_t H[SHA512_256_HASH_SIZE_WORDS],
As only the last 16 'W' are used in calculations, it is possible to
use 16 elements array of W as a cyclic buffer.
Note: ((t-16) & 15) have same value as (t & 15) */
-#define Wgen(w,t) \
- (curl_uint64_t)( (w)[(t - 16) & 15] + sig1((w)[((t) - 2) & 15]) \
- + (w)[((t) - 7) & 15] + sig0((w)[((t) - 15) & 15]) )
+#define Wgen(w,t) \
+ (uint64_t)( (w)[(t - 16) & 15] + sig1((w)[((t) - 2) & 15]) \
+ + (w)[((t) - 7) & 15] + sig0((w)[((t) - 15) & 15]) )
/* During the last 64 steps, before making any calculation on each step,
current W element is generated from other W elements of the cyclic
@@ -628,7 +628,7 @@ static CURLcode Curl_sha512_256_update(void *context,
if(length > ctx->count)
ctx->count_bits_hi += 1U << 3; /* Value wrap */
ctx->count_bits_hi += ctx->count >> 61;
- ctx->count &= CURL_UINT64_C(0x1FFFFFFFFFFFFFFF);
+ ctx->count &= UINT64_C(0x1FFFFFFFFFFFFFFF);
if(bytes_have) {
unsigned int bytes_left = CURL_SHA512_256_BLOCK_SIZE - bytes_have;
@@ -685,7 +685,7 @@ static CURLcode Curl_sha512_256_update(void *context,
static CURLcode Curl_sha512_256_finish(unsigned char *digest, void *context)
{
struct Curl_sha512_256ctx *const ctx = (struct Curl_sha512_256ctx *)context;
- curl_uint64_t num_bits; /**< Number of processed bits */
+ uint64_t num_bits; /**< Number of processed bits */
unsigned int bytes_have; /**< Number of bytes in the context buffer */
/* the void pointer here is required to mute Intel compiler warning */
void *const ctx_buf = ctx->buffer;
lib/vquic/curl_osslq.c+3 -4
@@ -1272,8 +1272,8 @@ static CURLcode h3_quic_recv(void *reader_ctx,
}
else {
CURL_TRC_CF(x->data, x->cf, "[%" PRId64 "] h3_quic_recv -> RESET, "
- "rv=%d, app_err=%" FMT_PRIu64,
- x->s->id, rv, (curl_uint64_t)app_error_code);
+ "rv=%d, app_err=%" PRIu64,
+ x->s->id, rv, app_error_code);
if(app_error_code != NGHTTP3_H3_NO_ERROR)
x->s->reset = TRUE;
}
@@ -2246,8 +2246,7 @@ static bool cf_osslq_conn_is_alive(struct Curl_cfilter *cf,
"assume connection is dead.");
goto out;
}
- CURL_TRC_CF(data, cf, "negotiated idle timeout: %" FMT_PRIu64 "ms",
- (curl_uint64_t)idle_ms);
+ CURL_TRC_CF(data, cf, "negotiated idle timeout: %" PRIu64 "ms", idle_ms);
idletime = curlx_timediff_ms(curlx_now(), ctx->q.last_io);
if(idle_ms && idletime > 0 && (uint64_t)idletime > idle_ms)
goto out;
src/tool_util.c+4 -4
@@ -31,16 +31,16 @@
struct timeval tvrealnow(void)
{
/* UNIX EPOCH (1970-01-01) in FILETIME (1601-01-01) as 64-bit value */
- static const curl_uint64_t EPOCH = (curl_uint64_t)116444736000000000ULL;
+ static const uint64_t EPOCH = UINT64_C(116444736000000000);
SYSTEMTIME systime;
FILETIME ftime; /* 100ns since 1601-01-01, as double 32-bit value */
- curl_uint64_t time; /* 100ns since 1601-01-01, as 64-bit value */
+ uint64_t time; /* 100ns since 1601-01-01, as 64-bit value */
struct timeval now;
GetSystemTime(&systime);
SystemTimeToFileTime(&systime, &ftime);
- time = ((curl_uint64_t)ftime.dwLowDateTime);
- time += ((curl_uint64_t)ftime.dwHighDateTime) << 32;
+ time = ((uint64_t)ftime.dwLowDateTime);
+ time += ((uint64_t)ftime.dwHighDateTime) << 32;
now.tv_sec = (long)((time - EPOCH) / 10000000L); /* unit is 100ns */
now.tv_usec = (long)(systime.wMilliseconds * 1000);