rugged 1.6.3 → 1.9.0

data/vendor/libgit2/deps/ntlmclient/CMakeLists.txt

@@ -31,7 +31,7 @@ elseif(USE_HTTPS STREQUAL "OpenSSL-Dynamic")
 elseif(USE_HTTPS STREQUAL "mbedTLS")
 	add_definitions(-DCRYPT_MBEDTLS)
 	include_directories(${MBEDTLS_INCLUDE_DIR})
-	set(SRC_NTLMCLIENT_CRYPTO "crypt_mbedtls.c" "crypt_mbedtls.h")
+	set(SRC_NTLMCLIENT_CRYPTO "crypt_mbedtls.c" "crypt_mbedtls.h" "crypt_builtin_md4.c")
 else()
 	message(FATAL_ERROR "Unable to use libgit2's HTTPS backend (${USE_HTTPS}) for NTLM crypto")
 endif()

data/vendor/libgit2/deps/ntlmclient/crypt_builtin_md4.c

@@ -0,0 +1,311 @@
+/*
+ * Copyright (c) Edward Thomson.  All rights reserved.
+ *
+ * This file is part of ntlmclient, distributed under the MIT license.
+ * For full terms and copyright information, and for third-party
+ * copyright information, see the included LICENSE.txt file.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "ntlm.h"
+#include "crypt.h"
+
+/*
+ * Below is the MD4 code from RFC 1320, with minor modifications
+ * to make it compile on a modern compiler. It is included since
+ * many system crypto libraries lack MD4, sensibly.
+ */
+
+/* MD4C.C - RSA Data Security, Inc., MD4 message-digest algorithm
+ */
+
+/* Copyright (C) 1990-2, RSA Data Security, Inc. All rights reserved.
+
+   License to copy and use this software is granted provided that it
+   is identified as the "RSA Data Security, Inc. MD4 Message-Digest
+   Algorithm" in all material mentioning or referencing this software
+   or this function.
+
+   License is also granted to make and use derivative works provided
+   that such works are identified as "derived from the RSA Data
+   Security, Inc. MD4 Message-Digest Algorithm" in all material
+   mentioning or referencing the derived work.
+
+   RSA Data Security, Inc. makes no representations concerning either
+   the merchantability of this software or the suitability of this
+   software for any particular purpose. It is provided "as is"
+   without express or implied warranty of any kind.
+
+   These notices must be retained in any copies of any part of this
+   documentation and/or software.
+ */
+
+/* POINTER defines a generic pointer type */
+typedef unsigned char *POINTER;
+
+/* UINT2 defines a two byte word */
+typedef uint16_t UINT2;
+
+/* UINT4 defines a four byte word */
+typedef uint32_t UINT4;
+
+#define MD4_memcpy memcpy
+#define MD4_memset memset
+
+/* MD4 context. */
+typedef struct {
+  UINT4 state[4];                                   /* state (ABCD) */
+  UINT4 count[2];        /* number of bits, modulo 2^64 (lsb first) */
+  unsigned char buffer[64];                         /* input buffer */
+} MD4_CTX;
+
+/* Constants for MD4Transform routine.
+ */
+#define S11 3
+#define S12 7
+#define S13 11
+#define S14 19
+#define S21 3
+#define S22 5
+#define S23 9
+#define S24 13
+#define S31 3
+#define S32 9
+#define S33 11
+#define S34 15
+
+static void MD4Transform(UINT4 [4], const unsigned char [64]);
+static void Encode (unsigned char *, UINT4 *, unsigned int);
+static void Decode (UINT4 *, const unsigned char *, unsigned int);
+
+static unsigned char PADDING[64] = {
+  0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+/* F, G and H are basic MD4 functions.
+ */
+#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
+#define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
+#define H(x, y, z) ((x) ^ (y) ^ (z))
+
+/* ROTATE_LEFT rotates x left n bits.
+ */
+#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
+
+/* FF, GG and HH are transformations for rounds 1, 2 and 3 */
+/* Rotation is separate from addition to prevent recomputation */
+#define FF(a, b, c, d, x, s) { \
+    (a) += F ((b), (c), (d)) + (x); \
+    (a) = ROTATE_LEFT ((a), (s)); \
+  }
+#define GG(a, b, c, d, x, s) { \
+    (a) += G ((b), (c), (d)) + (x) + (UINT4)0x5a827999; \
+    (a) = ROTATE_LEFT ((a), (s)); \
+  }
+#define HH(a, b, c, d, x, s) { \
+    (a) += H ((b), (c), (d)) + (x) + (UINT4)0x6ed9eba1; \
+    (a) = ROTATE_LEFT ((a), (s)); \
+  }
+
+/* MD4 initialization. Begins an MD4 operation, writing a new context.
+ */
+static void MD4Init (MD4_CTX *context)
+{
+  context->count[0] = context->count[1] = 0;
+
+  /* Load magic initialization constants.
+   */
+  context->state[0] = 0x67452301;
+  context->state[1] = 0xefcdab89;
+  context->state[2] = 0x98badcfe;
+  context->state[3] = 0x10325476;
+}
+
+/* MD4 block update operation. Continues an MD4 message-digest
+     operation, processing another message block, and updating the
+     context.
+ */
+static void MD4Update (MD4_CTX *context, const unsigned char *input, unsigned int inputLen)
+{
+  unsigned int i, index, partLen;
+
+  /* Compute number of bytes mod 64 */
+  index = (unsigned int)((context->count[0] >> 3) & 0x3F);
+  /* Update number of bits */
+  if ((context->count[0] += ((UINT4)inputLen << 3))
+      < ((UINT4)inputLen << 3))
+    context->count[1]++;
+  context->count[1] += ((UINT4)inputLen >> 29);
+
+  partLen = 64 - index;
+
+  /* Transform as many times as possible.
+   */
+  if (inputLen >= partLen) {
+    MD4_memcpy
+      ((POINTER)&context->buffer[index], (POINTER)input, partLen);
+    MD4Transform (context->state, context->buffer);
+
+    for (i = partLen; i + 63 < inputLen; i += 64)
+      MD4Transform (context->state, &input[i]);
+
+    index = 0;
+  }
+  else
+    i = 0;
+
+  /* Buffer remaining input */
+  MD4_memcpy
+    ((POINTER)&context->buffer[index], (POINTER)&input[i],
+     inputLen-i);
+}
+
+/* MD4 finalization. Ends an MD4 message-digest operation, writing the
+     the message digest and zeroizing the context.
+ */
+static void MD4Final (unsigned char digest[16], MD4_CTX *context)
+{
+  unsigned char bits[8];
+  unsigned int index, padLen;
+
+  /* Save number of bits */
+  Encode (bits, context->count, 8);
+
+  /* Pad out to 56 mod 64.
+   */
+  index = (unsigned int)((context->count[0] >> 3) & 0x3f);
+  padLen = (index < 56) ? (56 - index) : (120 - index);
+  MD4Update (context, PADDING, padLen);
+
+  /* Append length (before padding) */
+  MD4Update (context, bits, 8);
+  /* Store state in digest */
+  Encode (digest, context->state, 16);
+
+  /* Zeroize sensitive information.
+   */
+  MD4_memset ((POINTER)context, 0, sizeof (*context));
+}
+
+/* MD4 basic transformation. Transforms state based on block.
+ */
+static void MD4Transform (UINT4 state[4], const unsigned char block[64])
+{
+  UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
+
+  Decode (x, block, 64);
+
+  /* Round 1 */
+  FF (a, b, c, d, x[ 0], S11); /* 1 */
+  FF (d, a, b, c, x[ 1], S12); /* 2 */
+  FF (c, d, a, b, x[ 2], S13); /* 3 */
+  FF (b, c, d, a, x[ 3], S14); /* 4 */
+  FF (a, b, c, d, x[ 4], S11); /* 5 */
+  FF (d, a, b, c, x[ 5], S12); /* 6 */
+  FF (c, d, a, b, x[ 6], S13); /* 7 */
+  FF (b, c, d, a, x[ 7], S14); /* 8 */
+  FF (a, b, c, d, x[ 8], S11); /* 9 */
+  FF (d, a, b, c, x[ 9], S12); /* 10 */
+  FF (c, d, a, b, x[10], S13); /* 11 */
+  FF (b, c, d, a, x[11], S14); /* 12 */
+  FF (a, b, c, d, x[12], S11); /* 13 */
+  FF (d, a, b, c, x[13], S12); /* 14 */
+  FF (c, d, a, b, x[14], S13); /* 15 */
+  FF (b, c, d, a, x[15], S14); /* 16 */
+
+  /* Round 2 */
+  GG (a, b, c, d, x[ 0], S21); /* 17 */
+  GG (d, a, b, c, x[ 4], S22); /* 18 */
+  GG (c, d, a, b, x[ 8], S23); /* 19 */
+  GG (b, c, d, a, x[12], S24); /* 20 */
+  GG (a, b, c, d, x[ 1], S21); /* 21 */
+  GG (d, a, b, c, x[ 5], S22); /* 22 */
+  GG (c, d, a, b, x[ 9], S23); /* 23 */
+  GG (b, c, d, a, x[13], S24); /* 24 */
+  GG (a, b, c, d, x[ 2], S21); /* 25 */
+  GG (d, a, b, c, x[ 6], S22); /* 26 */
+  GG (c, d, a, b, x[10], S23); /* 27 */
+  GG (b, c, d, a, x[14], S24); /* 28 */
+  GG (a, b, c, d, x[ 3], S21); /* 29 */
+  GG (d, a, b, c, x[ 7], S22); /* 30 */
+  GG (c, d, a, b, x[11], S23); /* 31 */
+  GG (b, c, d, a, x[15], S24); /* 32 */
+
+  /* Round 3 */
+  HH (a, b, c, d, x[ 0], S31); /* 33 */
+  HH (d, a, b, c, x[ 8], S32); /* 34 */
+  HH (c, d, a, b, x[ 4], S33); /* 35 */
+  HH (b, c, d, a, x[12], S34); /* 36 */
+  HH (a, b, c, d, x[ 2], S31); /* 37 */
+  HH (d, a, b, c, x[10], S32); /* 38 */
+  HH (c, d, a, b, x[ 6], S33); /* 39 */
+  HH (b, c, d, a, x[14], S34); /* 40 */
+  HH (a, b, c, d, x[ 1], S31); /* 41 */
+  HH (d, a, b, c, x[ 9], S32); /* 42 */
+  HH (c, d, a, b, x[ 5], S33); /* 43 */
+  HH (b, c, d, a, x[13], S34); /* 44 */
+  HH (a, b, c, d, x[ 3], S31); /* 45 */
+  HH (d, a, b, c, x[11], S32); /* 46 */
+  HH (c, d, a, b, x[ 7], S33); /* 47 */
+  HH (b, c, d, a, x[15], S34); /* 48 */
+
+  state[0] += a;
+  state[1] += b;
+  state[2] += c;
+  state[3] += d;
+
+  /* Zeroize sensitive information.
+   */
+  MD4_memset ((POINTER)x, 0, sizeof (x));
+}
+
+/* Encodes input (UINT4) into output (unsigned char). Assumes len is
+     a multiple of 4.
+ */
+static void Encode (unsigned char *output, UINT4 *input, unsigned int len)
+{
+  unsigned int i, j;
+
+  for (i = 0, j = 0; j < len; i++, j += 4) {
+    output[j] = (unsigned char)(input[i] & 0xff);
+    output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
+    output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
+    output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
+  }
+}
+
+/* Decodes input (unsigned char) into output (UINT4). Assumes len is
+     a multiple of 4.
+ */
+static void Decode (UINT4 *output, const unsigned char *input, unsigned int len)
+{
+  unsigned int i, j;
+
+  for (i = 0, j = 0; j < len; i++, j += 4)
+    output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
+      (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
+}
+
+bool ntlm_md4_digest(
+	unsigned char out[CRYPT_MD4_DIGESTSIZE],
+	ntlm_client *ntlm,
+	const unsigned char *in,
+	size_t in_len)
+{
+	MD4_CTX ctx;
+
+	NTLM_UNUSED(ntlm);
+
+	if (in_len > UINT_MAX)
+		return false;
+
+	MD4Init(&ctx);
+	MD4Update(&ctx, in, (unsigned int)in_len);
+	MD4Final (out, &ctx);
+
+	return true;
+}

data/vendor/libgit2/deps/ntlmclient/crypt_commoncrypto.c

@@ -59,11 +59,12 @@ bool ntlm_des_encrypt(
 	ntlm_des_block *plaintext,
 	ntlm_des_block *key)
 {
+	CCCryptorStatus result;
 	size_t written;
 
 	NTLM_UNUSED(ntlm);
 
-	CCCryptorStatus result = CCCrypt(kCCEncrypt,
+	result = CCCrypt(kCCEncrypt,
 		kCCAlgorithmDES, kCCOptionECBMode,
 		key, sizeof(ntlm_des_block), NULL,
 		plaintext, sizeof(ntlm_des_block),

data/vendor/libgit2/deps/ntlmclient/crypt_mbedtls.c

@@ -12,7 +12,6 @@
 #include "mbedtls/ctr_drbg.h"
 #include "mbedtls/des.h"
 #include "mbedtls/entropy.h"
-#include "mbedtls/md4.h"
 
 #include "ntlm.h"
 #include "crypt.h"
@@ -88,25 +87,6 @@ done:
 	return success;
 }
 
-bool ntlm_md4_digest(
-	unsigned char out[CRYPT_MD4_DIGESTSIZE],
-	ntlm_client *ntlm,
-	const unsigned char *in,
-	size_t in_len)
-{
-	mbedtls_md4_context ctx;
-
-	NTLM_UNUSED(ntlm);
-
-	mbedtls_md4_init(&ctx);
-	mbedtls_md4_starts(&ctx);
-	mbedtls_md4_update(&ctx, in, in_len);
-	mbedtls_md4_finish(&ctx, out);
-	mbedtls_md4_free(&ctx);
-
-	return true;
-}
-
 bool ntlm_hmac_md5_init(
 	ntlm_client *ntlm,
 	const unsigned char *key,

data/vendor/libgit2/deps/ntlmclient/crypt_openssl.c

@@ -26,18 +26,18 @@
 
 #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(CRYPT_OPENSSL_DYNAMIC)
 
-static inline HMAC_CTX *HMAC_CTX_new(void)
+NTLM_INLINE(HMAC_CTX *) HMAC_CTX_new(void)
 {
 	return calloc(1, sizeof(HMAC_CTX));
 }
 
-static inline int HMAC_CTX_reset(HMAC_CTX *ctx)
+NTLM_INLINE(int) HMAC_CTX_reset(HMAC_CTX *ctx)
 {
 	ntlm_memzero(ctx, sizeof(HMAC_CTX));
 	return 1;
 }
 
-static inline void HMAC_CTX_free(HMAC_CTX *ctx)
+NTLM_INLINE(void) HMAC_CTX_free(HMAC_CTX *ctx)
 {
 	free(ctx);
 }
@@ -48,7 +48,7 @@ static inline void HMAC_CTX_free(HMAC_CTX *ctx)
 	(defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER >= 0x03050000fL) || \
 	defined(CRYPT_OPENSSL_DYNAMIC)
 
-static inline void HMAC_CTX_cleanup(HMAC_CTX *ctx)
+NTLM_INLINE(void) HMAC_CTX_cleanup(HMAC_CTX *ctx)
 {
 	NTLM_UNUSED(ctx);
 }

data/vendor/libgit2/deps/ntlmclient/ntlm.c

@@ -43,7 +43,7 @@ static bool supports_unicode(ntlm_client *ntlm)
 		false : true;
 }
 
-static inline bool increment_size(size_t *out, size_t incr)
+NTLM_INLINE(bool) increment_size(size_t *out, size_t incr)
 {
 	if (SIZE_MAX - *out < incr) {
 		*out = (size_t)-1;
@@ -272,7 +272,7 @@ int ntlm_client_set_timestamp(ntlm_client *ntlm, uint64_t timestamp)
 	return 0;
 }
 
-static inline bool write_buf(
+NTLM_INLINE(bool) write_buf(
 	ntlm_client *ntlm,
 	ntlm_buf *out,
 	const unsigned char *buf,
@@ -291,7 +291,7 @@ static inline bool write_buf(
 	return true;
 }
 
-static inline bool write_byte(
+NTLM_INLINE(bool) write_byte(
 	ntlm_client *ntlm,
 	ntlm_buf *out,
 	uint8_t value)
@@ -305,7 +305,7 @@ static inline bool write_byte(
 	return true;
 }
 
-static inline bool write_int16(
+NTLM_INLINE(bool) write_int16(
 	ntlm_client *ntlm,
 	ntlm_buf *out,
 	uint16_t value)
@@ -320,7 +320,7 @@ static inline bool write_int16(
 	return true;
 }
 
-static inline bool write_int32(
+NTLM_INLINE(bool) write_int32(
 	ntlm_client *ntlm,
 	ntlm_buf *out,
 	uint32_t value)
@@ -337,7 +337,7 @@ static inline bool write_int32(
 	return true;
 }
 
-static inline bool write_version(
+NTLM_INLINE(bool) write_version(
 	ntlm_client *ntlm,
 	ntlm_buf *out,
 	ntlm_version *version)
@@ -348,7 +348,7 @@ static inline bool write_version(
 		write_int32(ntlm, out, version->reserved);
 }
 
-static inline bool write_bufinfo(
+NTLM_INLINE(bool) write_bufinfo(
 	ntlm_client *ntlm,
 	ntlm_buf *out,
 	size_t len,
@@ -369,7 +369,7 @@ static inline bool write_bufinfo(
 		write_int32(ntlm, out, (uint32_t)offset);
 }
 
-static inline bool read_buf(
+NTLM_INLINE(bool) read_buf(
 	unsigned char *out,
 	ntlm_client *ntlm,
 	ntlm_buf *message,
@@ -386,7 +386,7 @@ static inline bool read_buf(
 	return true;
 }
 
-static inline bool read_byte(
+NTLM_INLINE(bool) read_byte(
 	uint8_t *out,
 	ntlm_client *ntlm,
 	ntlm_buf *message)
@@ -400,7 +400,7 @@ static inline bool read_byte(
 	return true;
 }
 
-static inline bool read_int16(
+NTLM_INLINE(bool) read_int16(
 	uint16_t *out,
 	ntlm_client *ntlm,
 	ntlm_buf *message)
@@ -418,7 +418,7 @@ static inline bool read_int16(
 	return true;
 }
 
-static inline bool read_int32(
+NTLM_INLINE(bool) read_int32(
 	uint32_t *out,
 	ntlm_client *ntlm,
 	ntlm_buf *message)
@@ -438,7 +438,7 @@ static inline bool read_int32(
 	return true;
 }
 
-static inline bool read_int64(
+NTLM_INLINE(bool) read_int64(
 	uint64_t *out,
 	ntlm_client *ntlm,
 	ntlm_buf *message)
@@ -462,7 +462,7 @@ static inline bool read_int64(
 	return true;
 }
 
-static inline bool read_version(
+NTLM_INLINE(bool) read_version(
 	ntlm_version *out,
 	ntlm_client *ntlm,
 	ntlm_buf *message)
@@ -473,7 +473,7 @@ static inline bool read_version(
 		read_int32(&out->reserved, ntlm, message);
 }
 
-static inline bool read_bufinfo(
+NTLM_INLINE(bool) read_bufinfo(
 	uint16_t *out_len,
 	uint32_t *out_offset,
 	ntlm_client *ntlm,
@@ -486,7 +486,7 @@ static inline bool read_bufinfo(
 		read_int32(out_offset, ntlm, message);
 }
 
-static inline bool read_string_unicode(
+NTLM_INLINE(bool) read_string_unicode(
 	char **out,
 	ntlm_client *ntlm,
 	ntlm_buf *message,
@@ -504,7 +504,7 @@ static inline bool read_string_unicode(
 	return ret;
 }
 
-static inline bool read_string_ascii(
+NTLM_INLINE(bool) read_string_ascii(
 	char **out,
 	ntlm_client *ntlm,
 	ntlm_buf *message,
@@ -526,7 +526,7 @@ static inline bool read_string_ascii(
 	return true;
 }
 
-static inline bool read_string(
+NTLM_INLINE(bool) read_string(
 	char **out,
 	ntlm_client *ntlm,
 	ntlm_buf *message,
@@ -539,7 +539,7 @@ static inline bool read_string(
 		return read_string_ascii(out, ntlm, message, string_len);
 }
 
-static inline bool read_target_info(
+NTLM_INLINE(bool) read_target_info(
 	char **server_out,
 	char **domain_out,
 	char **server_dns_out,
@@ -965,7 +965,7 @@ static void des_key_from_password(
 	generate_odd_parity(out);
 }
 
-static inline bool generate_lm_hash(
+NTLM_INLINE(bool) generate_lm_hash(
 	ntlm_des_block out[2],
 	ntlm_client *ntlm,
 	const char *password)
@@ -988,9 +988,9 @@ static inline bool generate_lm_hash(
 	keystr2_len = (password_len > 7) ? MIN(14, password_len) - 7 : 0;
 
 	for (i = 0; i < keystr1_len; i++)
-		keystr1[i] = (unsigned char)toupper(password[i]);
+		keystr1[i] = (unsigned char)toupper((unsigned char)password[i]);
 	for (i = 0; i < keystr2_len; i++)
-		keystr2[i] = (unsigned char)toupper(password[i+7]);
+		keystr2[i] = (unsigned char)toupper((unsigned char)password[i+7]);
 
 	/* DES encrypt the LM constant using the password as the key */
 	des_key_from_password(&key1, keystr1, keystr1_len);

data/vendor/libgit2/deps/ntlmclient/unicode_builtin.c

@@ -12,6 +12,7 @@
 #include "ntlm.h"
 #include "unicode.h"
 #include "compat.h"
+#include "util.h"
 
 typedef unsigned int    UTF32;   /* at least 32 bits */
 typedef unsigned short  UTF16;   /* at least 16 bits */
@@ -180,7 +181,7 @@ static ConversionResult ConvertUTF16toUTF8 (
  * definition of UTF-8 goes up to 4-byte sequences.
  */
 
-static inline bool isLegalUTF8(const UTF8 *source, int length) {
+NTLM_INLINE(bool) isLegalUTF8(const UTF8 *source, int length) {
     UTF8 a;
     const UTF8 *srcptr = source+length;
     switch (length) {
@@ -288,7 +289,7 @@ typedef enum {
 	unicode_builtin_utf16_to_8
 } unicode_builtin_encoding_direction;
 
-static inline bool unicode_builtin_encoding_convert(
+NTLM_INLINE(bool) unicode_builtin_encoding_convert(
 	char **converted,
 	size_t *converted_len,
 	ntlm_client *ntlm,
@@ -372,13 +373,13 @@ static inline bool unicode_builtin_encoding_convert(
 			goto done;
 		}
 
+		out_len = out_start - out;
+
 		if ((new_out = realloc(out, out_size)) == NULL) {
 			ntlm_client_set_errmsg(ntlm, "out of memory");
 			goto done;
 		}
 
-		out_len = out_start - out;
-
 		out = new_out;
 		out_start = new_out + out_len;
 		out_end = out + out_size;

data/vendor/libgit2/deps/ntlmclient/unicode_iconv.c

@@ -14,6 +14,7 @@
 #include "ntlmclient.h"
 #include "unicode.h"
 #include "ntlm.h"
+#include "util.h"
 #include "compat.h"
 
 typedef enum {
@@ -40,7 +41,7 @@ bool ntlm_unicode_init(ntlm_client *ntlm)
 	return true;
 }
 
-static inline bool unicode_iconv_encoding_convert(
+NTLM_INLINE(bool) unicode_iconv_encoding_convert(
 	char **converted,
 	size_t *converted_len,
 	ntlm_client *ntlm,