XOF: use size_t internally, unsigned long long externally

src/libsodium/crypto_xof/shake128/ref/shake128_ref.c

@@ -25,14 +25,12 @@ shake128_ref_init(shake128_state_internal *state)
 }
 
 int
-shake128_ref_update(shake128_state_internal *state,
-                    const unsigned char     *in,
-                    unsigned long long       inlen)
+shake128_ref_update(shake128_state_internal *state, const unsigned char *in, size_t inlen)
 {
     size_t i;
 
     if (state->phase != SHAKE128_PHASE_ABSORBING) {
-        state->phase = SHAKE128_PHASE_ABSORBING;
+        state->phase  = SHAKE128_PHASE_ABSORBING;
         state->offset = 0;
     }
 
@@ -94,7 +92,7 @@ shake128_ref_squeeze(shake128_state_internal *state, unsigned char *out, size_t
 }
 
 int
-shake128_ref(unsigned char *out, size_t outlen, const unsigned char *in, unsigned long long inlen)
+shake128_ref(unsigned char *out, size_t outlen, const unsigned char *in, size_t inlen)
 {
     shake128_state_internal state;
 

src/libsodium/crypto_xof/shake128/ref/shake128_ref.h

@@ -15,16 +15,13 @@ typedef struct shake128_state_internal_ {
     unsigned char domain; /* Domain separation byte */
 } shake128_state_internal;
 
-int shake128_ref(unsigned char *out, size_t outlen, const unsigned char *in,
-                 unsigned long long inlen);
+int shake128_ref(unsigned char *out, size_t outlen, const unsigned char *in, size_t inlen);
 
 int shake128_ref_init(shake128_state_internal *state);
 
 int shake128_ref_init_with_domain(shake128_state_internal *state, unsigned char domain);
 
-int shake128_ref_update(shake128_state_internal *state,
-                        const unsigned char     *in,
-                        unsigned long long       inlen);
+int shake128_ref_update(shake128_state_internal *state, const unsigned char *in, size_t inlen);
 
 int shake128_ref_squeeze(shake128_state_internal *state, unsigned char *out, size_t outlen);
 

src/libsodium/crypto_xof/shake128/xof_shake128.c

@@ -28,7 +28,7 @@ crypto_xof_shake128(unsigned char *out, size_t outlen, const unsigned char *in,
 
     COMPILER_ASSERT(sizeof(crypto_xof_shake128_state) >= sizeof(shake128_state_internal));
 
-    return shake128_ref(out, outlen, in, inlen);
+    return shake128_ref(out, outlen, in, (size_t) inlen);
 }
 
 int
@@ -58,7 +58,7 @@ crypto_xof_shake128_update(crypto_xof_shake128_state *state,
 {
     shake128_state_internal *st = (shake128_state_internal *) (void *) state;
 
-    return shake128_ref_update(st, in, inlen);
+    return shake128_ref_update(st, in, (size_t) inlen);
 }
 
 int

src/libsodium/crypto_xof/shake256/ref/shake256_ref.c

@@ -25,14 +25,12 @@ shake256_ref_init(shake256_state_internal *state)
 }
 
 int
-shake256_ref_update(shake256_state_internal *state,
-                    const unsigned char     *in,
-                    unsigned long long       inlen)
+shake256_ref_update(shake256_state_internal *state, const unsigned char *in, size_t inlen)
 {
     size_t i;
 
     if (state->phase != SHAKE256_PHASE_ABSORBING) {
-        state->phase = SHAKE256_PHASE_ABSORBING;
+        state->phase  = SHAKE256_PHASE_ABSORBING;
         state->offset = 0;
     }
 
@@ -94,7 +92,7 @@ shake256_ref_squeeze(shake256_state_internal *state, unsigned char *out, size_t
 }
 
 int
-shake256_ref(unsigned char *out, size_t outlen, const unsigned char *in, unsigned long long inlen)
+shake256_ref(unsigned char *out, size_t outlen, const unsigned char *in, size_t inlen)
 {
     shake256_state_internal state;
 

src/libsodium/crypto_xof/shake256/ref/shake256_ref.h

@@ -15,16 +15,13 @@ typedef struct shake256_state_internal_ {
     unsigned char domain; /* Domain separation byte */
 } shake256_state_internal;
 
-int shake256_ref(unsigned char *out, size_t outlen, const unsigned char *in,
-                 unsigned long long inlen);
+int shake256_ref(unsigned char *out, size_t outlen, const unsigned char *in, size_t inlen);
 
 int shake256_ref_init(shake256_state_internal *state);
 
 int shake256_ref_init_with_domain(shake256_state_internal *state, unsigned char domain);
 
-int shake256_ref_update(shake256_state_internal *state,
-                        const unsigned char     *in,
-                        unsigned long long       inlen);
+int shake256_ref_update(shake256_state_internal *state, const unsigned char *in, size_t inlen);
 
 int shake256_ref_squeeze(shake256_state_internal *state, unsigned char *out, size_t outlen);
 

src/libsodium/crypto_xof/shake256/xof_shake256.c

@@ -28,7 +28,7 @@ crypto_xof_shake256(unsigned char *out, size_t outlen, const unsigned char *in,
 
     COMPILER_ASSERT(sizeof(crypto_xof_shake256_state) >= sizeof(shake256_state_internal));
 
-    return shake256_ref(out, outlen, in, inlen);
+    return shake256_ref(out, outlen, in, (size_t) inlen);
 }
 
 int
@@ -58,7 +58,7 @@ crypto_xof_shake256_update(crypto_xof_shake256_state *state,
 {
     shake256_state_internal *st = (shake256_state_internal *) (void *) state;
 
-    return shake256_ref_update(st, in, inlen);
+    return shake256_ref_update(st, in, (size_t) inlen);
 }
 
 int

src/libsodium/crypto_xof/turboshake128/ref/turboshake128_ref.c

@@ -25,14 +25,12 @@ turboshake128_ref_init(turboshake128_state_internal *state)
 }
 
 int
-turboshake128_ref_update(turboshake128_state_internal *state,
-                         const unsigned char          *in,
-                         unsigned long long            inlen)
+turboshake128_ref_update(turboshake128_state_internal *state, const unsigned char *in, size_t inlen)
 {
     size_t i;
 
     if (state->phase != TURBOSHAKE128_PHASE_ABSORBING) {
-        state->phase = TURBOSHAKE128_PHASE_ABSORBING;
+        state->phase  = TURBOSHAKE128_PHASE_ABSORBING;
         state->offset = 0;
     }
 
@@ -94,8 +92,7 @@ turboshake128_ref_squeeze(turboshake128_state_internal *state, unsigned char *ou
 }
 
 int
-turboshake128_ref(unsigned char *out, size_t outlen, const unsigned char *in,
-                  unsigned long long inlen)
+turboshake128_ref(unsigned char *out, size_t outlen, const unsigned char *in, size_t inlen)
 {
     turboshake128_state_internal state;
 

src/libsodium/crypto_xof/turboshake128/ref/turboshake128_ref.h

@@ -18,8 +18,7 @@ typedef struct turboshake128_state_internal_ {
     unsigned char domain; /* Domain separation byte */
 } turboshake128_state_internal;
 
-int turboshake128_ref(unsigned char *out, size_t outlen, const unsigned char *in,
-                      unsigned long long inlen);
+int turboshake128_ref(unsigned char *out, size_t outlen, const unsigned char *in, size_t inlen);
 
 int turboshake128_ref_init(turboshake128_state_internal *state);
 
@@ -27,7 +26,7 @@ int turboshake128_ref_init_with_domain(turboshake128_state_internal *state, unsi
 
 int turboshake128_ref_update(turboshake128_state_internal *state,
                              const unsigned char          *in,
-                             unsigned long long            inlen);
+                             size_t                        inlen);
 
 int turboshake128_ref_squeeze(turboshake128_state_internal *state, unsigned char *out,
                               size_t outlen);

src/libsodium/crypto_xof/turboshake128/xof_turboshake128.c

@@ -28,7 +28,7 @@ crypto_xof_turboshake128(unsigned char *out, size_t outlen, const unsigned char
 
     COMPILER_ASSERT(sizeof(crypto_xof_turboshake128_state) >= sizeof(turboshake128_state_internal));
 
-    return turboshake128_ref(out, outlen, in, inlen);
+    return turboshake128_ref(out, outlen, in, (size_t) inlen);
 }
 
 int
@@ -59,7 +59,7 @@ crypto_xof_turboshake128_update(crypto_xof_turboshake128_state *state,
 {
     turboshake128_state_internal *st = (turboshake128_state_internal *) (void *) state;
 
-    return turboshake128_ref_update(st, in, inlen);
+    return turboshake128_ref_update(st, in, (size_t) inlen);
 }
 
 int

src/libsodium/crypto_xof/turboshake256/ref/turboshake256_ref.c

@@ -25,14 +25,12 @@ turboshake256_ref_init(turboshake256_state_internal *state)
 }
 
 int
-turboshake256_ref_update(turboshake256_state_internal *state,
-                         const unsigned char          *in,
-                         unsigned long long            inlen)
+turboshake256_ref_update(turboshake256_state_internal *state, const unsigned char *in, size_t inlen)
 {
     size_t i;
 
     if (state->phase != TURBOSHAKE256_PHASE_ABSORBING) {
-        state->phase = TURBOSHAKE256_PHASE_ABSORBING;
+        state->phase  = TURBOSHAKE256_PHASE_ABSORBING;
         state->offset = 0;
     }
 
@@ -94,8 +92,7 @@ turboshake256_ref_squeeze(turboshake256_state_internal *state, unsigned char *ou
 }
 
 int
-turboshake256_ref(unsigned char *out, size_t outlen, const unsigned char *in,
-                  unsigned long long inlen)
+turboshake256_ref(unsigned char *out, size_t outlen, const unsigned char *in, size_t inlen)
 {
     turboshake256_state_internal state;
 

src/libsodium/crypto_xof/turboshake256/ref/turboshake256_ref.h

@@ -18,8 +18,7 @@ typedef struct turboshake256_state_internal_ {
     unsigned char domain; /* Domain separation byte */
 } turboshake256_state_internal;
 
-int turboshake256_ref(unsigned char *out, size_t outlen, const unsigned char *in,
-                      unsigned long long inlen);
+int turboshake256_ref(unsigned char *out, size_t outlen, const unsigned char *in, size_t inlen);
 
 int turboshake256_ref_init(turboshake256_state_internal *state);
 
@@ -27,7 +26,7 @@ int turboshake256_ref_init_with_domain(turboshake256_state_internal *state, unsi
 
 int turboshake256_ref_update(turboshake256_state_internal *state,
                              const unsigned char          *in,
-                             unsigned long long            inlen);
+                             size_t                        inlen);
 
 int turboshake256_ref_squeeze(turboshake256_state_internal *state, unsigned char *out,
                               size_t outlen);

src/libsodium/crypto_xof/turboshake256/xof_turboshake256.c

@@ -28,7 +28,7 @@ crypto_xof_turboshake256(unsigned char *out, size_t outlen, const unsigned char
 
     COMPILER_ASSERT(sizeof(crypto_xof_turboshake256_state) >= sizeof(turboshake256_state_internal));
 
-    return turboshake256_ref(out, outlen, in, inlen);
+    return turboshake256_ref(out, outlen, in, (size_t) inlen);
 }
 
 int
@@ -59,7 +59,7 @@ crypto_xof_turboshake256_update(crypto_xof_turboshake256_state *state,
 {
     turboshake256_state_internal *st = (turboshake256_state_internal *) (void *) state;
 
-    return turboshake256_ref_update(st, in, inlen);
+    return turboshake256_ref_update(st, in, (size_t) inlen);
 }
 
 int