Reindent all code using astyle --style=ansi -s4 -SLYUH -m0 -k3 -c --mode=c -rn

contrib/mdx/md4.c

@@ -47,16 +47,16 @@
  * F and G are optimized compared to their RFC 1320 definitions, with the
  * optimization for F borrowed from Colin Plumb's MD5 implementation.
  */
-#define F(x, y, z)			((z) ^ ((x) & ((y) ^ (z))))
-#define G(x, y, z)			(((x) & ((y) | (z))) | ((y) & (z)))
-#define H(x, y, z)			((x) ^ (y) ^ (z))
+#define F(x, y, z)          ((z) ^ ((x) & ((y) ^ (z))))
+#define G(x, y, z)          (((x) & ((y) | (z))) | ((y) & (z)))
+#define H(x, y, z)          ((x) ^ (y) ^ (z))
 
 /*
  * The MD4 transformation for all three rounds.
  */
 #define STEP(f, a, b, c, d, x, s) \
-	(a) += f((b), (c), (d)) + (x); \
-	(a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s))));
+    (a) += f((b), (c), (d)) + (x); \
+    (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s))));
 
 /*
  * SET reads 4 input bytes in little-endian byte order and stores them
@@ -68,18 +68,18 @@
  */
 #if defined(__i386__) || defined(__x86_64__) || defined(__vax__)
 #define SET(n) \
-	(*(MD4_u32plus *)&ptr[(n) * 4])
+    (*(MD4_u32plus *)&ptr[(n) * 4])
 #define GET(n) \
-	SET(n)
+    SET(n)
 #else
 #define SET(n) \
-	(ctx->block[(n)] = \
-	(MD4_u32plus)ptr[(n) * 4] | \
-	((MD4_u32plus)ptr[(n) * 4 + 1] << 8) | \
-	((MD4_u32plus)ptr[(n) * 4 + 2] << 16) | \
-	((MD4_u32plus)ptr[(n) * 4 + 3] << 24))
+    (ctx->block[(n)] = \
+    (MD4_u32plus)ptr[(n) * 4] | \
+    ((MD4_u32plus)ptr[(n) * 4 + 1] << 8) | \
+    ((MD4_u32plus)ptr[(n) * 4 + 2] << 16) | \
+    ((MD4_u32plus)ptr[(n) * 4 + 3] << 24))
 #define GET(n) \
-	(ctx->block[(n)])
+    (ctx->block[(n)])
 #endif
 
 /*
@@ -88,187 +88,193 @@
  */
 static const void *body(MD4_CTX *ctx, const void *data, unsigned long size)
 {
-	const unsigned char *ptr;
-	MD4_u32plus a, b, c, d;
-	MD4_u32plus saved_a, saved_b, saved_c, saved_d;
-
-	ptr = (const unsigned char *)data;
-
-	a = ctx->a;
-	b = ctx->b;
-	c = ctx->c;
-	d = ctx->d;
-
-	do {
-		saved_a = a;
-		saved_b = b;
-		saved_c = c;
-		saved_d = d;
-
-/* Round 1 */
-		STEP(F, a, b, c, d, SET(0), 3)
-		STEP(F, d, a, b, c, SET(1), 7)
-		STEP(F, c, d, a, b, SET(2), 11)
-		STEP(F, b, c, d, a, SET(3), 19)
-		STEP(F, a, b, c, d, SET(4), 3)
-		STEP(F, d, a, b, c, SET(5), 7)
-		STEP(F, c, d, a, b, SET(6), 11)
-		STEP(F, b, c, d, a, SET(7), 19)
-		STEP(F, a, b, c, d, SET(8), 3)
-		STEP(F, d, a, b, c, SET(9), 7)
-		STEP(F, c, d, a, b, SET(10), 11)
-		STEP(F, b, c, d, a, SET(11), 19)
-		STEP(F, a, b, c, d, SET(12), 3)
-		STEP(F, d, a, b, c, SET(13), 7)
-		STEP(F, c, d, a, b, SET(14), 11)
-		STEP(F, b, c, d, a, SET(15), 19)
-
-/* Round 2 */
-		STEP(G, a, b, c, d, GET(0) + 0x5a827999, 3)
-		STEP(G, d, a, b, c, GET(4) + 0x5a827999, 5)
-		STEP(G, c, d, a, b, GET(8) + 0x5a827999, 9)
-		STEP(G, b, c, d, a, GET(12) + 0x5a827999, 13)
-		STEP(G, a, b, c, d, GET(1) + 0x5a827999, 3)
-		STEP(G, d, a, b, c, GET(5) + 0x5a827999, 5)
-		STEP(G, c, d, a, b, GET(9) + 0x5a827999, 9)
-		STEP(G, b, c, d, a, GET(13) + 0x5a827999, 13)
-		STEP(G, a, b, c, d, GET(2) + 0x5a827999, 3)
-		STEP(G, d, a, b, c, GET(6) + 0x5a827999, 5)
-		STEP(G, c, d, a, b, GET(10) + 0x5a827999, 9)
-		STEP(G, b, c, d, a, GET(14) + 0x5a827999, 13)
-		STEP(G, a, b, c, d, GET(3) + 0x5a827999, 3)
-		STEP(G, d, a, b, c, GET(7) + 0x5a827999, 5)
-		STEP(G, c, d, a, b, GET(11) + 0x5a827999, 9)
-		STEP(G, b, c, d, a, GET(15) + 0x5a827999, 13)
-
-/* Round 3 */
-		STEP(H, a, b, c, d, GET(0) + 0x6ed9eba1, 3)
-		STEP(H, d, a, b, c, GET(8) + 0x6ed9eba1, 9)
-		STEP(H, c, d, a, b, GET(4) + 0x6ed9eba1, 11)
-		STEP(H, b, c, d, a, GET(12) + 0x6ed9eba1, 15)
-		STEP(H, a, b, c, d, GET(2) + 0x6ed9eba1, 3)
-		STEP(H, d, a, b, c, GET(10) + 0x6ed9eba1, 9)
-		STEP(H, c, d, a, b, GET(6) + 0x6ed9eba1, 11)
-		STEP(H, b, c, d, a, GET(14) + 0x6ed9eba1, 15)
-		STEP(H, a, b, c, d, GET(1) + 0x6ed9eba1, 3)
-		STEP(H, d, a, b, c, GET(9) + 0x6ed9eba1, 9)
-		STEP(H, c, d, a, b, GET(5) + 0x6ed9eba1, 11)
-		STEP(H, b, c, d, a, GET(13) + 0x6ed9eba1, 15)
-		STEP(H, a, b, c, d, GET(3) + 0x6ed9eba1, 3)
-		STEP(H, d, a, b, c, GET(11) + 0x6ed9eba1, 9)
-		STEP(H, c, d, a, b, GET(7) + 0x6ed9eba1, 11)
-		STEP(H, b, c, d, a, GET(15) + 0x6ed9eba1, 15)
-
-		a += saved_a;
-		b += saved_b;
-		c += saved_c;
-		d += saved_d;
-
-		ptr += 64;
-	} while (size -= 64);
-
-	ctx->a = a;
-	ctx->b = b;
-	ctx->c = c;
-	ctx->d = d;
-
-	return ptr;
+    const unsigned char *ptr;
+    MD4_u32plus a, b, c, d;
+    MD4_u32plus saved_a, saved_b, saved_c, saved_d;
+
+    ptr = (const unsigned char *)data;
+
+    a = ctx->a;
+    b = ctx->b;
+    c = ctx->c;
+    d = ctx->d;
+
+    do
+    {
+        saved_a = a;
+        saved_b = b;
+        saved_c = c;
+        saved_d = d;
+
+        /* Round 1 */
+        STEP(F, a, b, c, d, SET(0), 3)
+        STEP(F, d, a, b, c, SET(1), 7)
+        STEP(F, c, d, a, b, SET(2), 11)
+        STEP(F, b, c, d, a, SET(3), 19)
+        STEP(F, a, b, c, d, SET(4), 3)
+        STEP(F, d, a, b, c, SET(5), 7)
+        STEP(F, c, d, a, b, SET(6), 11)
+        STEP(F, b, c, d, a, SET(7), 19)
+        STEP(F, a, b, c, d, SET(8), 3)
+        STEP(F, d, a, b, c, SET(9), 7)
+        STEP(F, c, d, a, b, SET(10), 11)
+        STEP(F, b, c, d, a, SET(11), 19)
+        STEP(F, a, b, c, d, SET(12), 3)
+        STEP(F, d, a, b, c, SET(13), 7)
+        STEP(F, c, d, a, b, SET(14), 11)
+        STEP(F, b, c, d, a, SET(15), 19)
+
+        /* Round 2 */
+        STEP(G, a, b, c, d, GET(0) + 0x5a827999, 3)
+        STEP(G, d, a, b, c, GET(4) + 0x5a827999, 5)
+        STEP(G, c, d, a, b, GET(8) + 0x5a827999, 9)
+        STEP(G, b, c, d, a, GET(12) + 0x5a827999, 13)
+        STEP(G, a, b, c, d, GET(1) + 0x5a827999, 3)
+        STEP(G, d, a, b, c, GET(5) + 0x5a827999, 5)
+        STEP(G, c, d, a, b, GET(9) + 0x5a827999, 9)
+        STEP(G, b, c, d, a, GET(13) + 0x5a827999, 13)
+        STEP(G, a, b, c, d, GET(2) + 0x5a827999, 3)
+        STEP(G, d, a, b, c, GET(6) + 0x5a827999, 5)
+        STEP(G, c, d, a, b, GET(10) + 0x5a827999, 9)
+        STEP(G, b, c, d, a, GET(14) + 0x5a827999, 13)
+        STEP(G, a, b, c, d, GET(3) + 0x5a827999, 3)
+        STEP(G, d, a, b, c, GET(7) + 0x5a827999, 5)
+        STEP(G, c, d, a, b, GET(11) + 0x5a827999, 9)
+        STEP(G, b, c, d, a, GET(15) + 0x5a827999, 13)
+
+        /* Round 3 */
+        STEP(H, a, b, c, d, GET(0) + 0x6ed9eba1, 3)
+        STEP(H, d, a, b, c, GET(8) + 0x6ed9eba1, 9)
+        STEP(H, c, d, a, b, GET(4) + 0x6ed9eba1, 11)
+        STEP(H, b, c, d, a, GET(12) + 0x6ed9eba1, 15)
+        STEP(H, a, b, c, d, GET(2) + 0x6ed9eba1, 3)
+        STEP(H, d, a, b, c, GET(10) + 0x6ed9eba1, 9)
+        STEP(H, c, d, a, b, GET(6) + 0x6ed9eba1, 11)
+        STEP(H, b, c, d, a, GET(14) + 0x6ed9eba1, 15)
+        STEP(H, a, b, c, d, GET(1) + 0x6ed9eba1, 3)
+        STEP(H, d, a, b, c, GET(9) + 0x6ed9eba1, 9)
+        STEP(H, c, d, a, b, GET(5) + 0x6ed9eba1, 11)
+        STEP(H, b, c, d, a, GET(13) + 0x6ed9eba1, 15)
+        STEP(H, a, b, c, d, GET(3) + 0x6ed9eba1, 3)
+        STEP(H, d, a, b, c, GET(11) + 0x6ed9eba1, 9)
+        STEP(H, c, d, a, b, GET(7) + 0x6ed9eba1, 11)
+        STEP(H, b, c, d, a, GET(15) + 0x6ed9eba1, 15)
+
+        a += saved_a;
+        b += saved_b;
+        c += saved_c;
+        d += saved_d;
+
+        ptr += 64;
+    }
+    while (size -= 64);
+
+    ctx->a = a;
+    ctx->b = b;
+    ctx->c = c;
+    ctx->d = d;
+
+    return ptr;
 }
 
 void MD4_Init(MD4_CTX *ctx)
 {
-	ctx->a = 0x67452301;
-	ctx->b = 0xefcdab89;
-	ctx->c = 0x98badcfe;
-	ctx->d = 0x10325476;
+    ctx->a = 0x67452301;
+    ctx->b = 0xefcdab89;
+    ctx->c = 0x98badcfe;
+    ctx->d = 0x10325476;
 
-	ctx->lo = 0;
-	ctx->hi = 0;
+    ctx->lo = 0;
+    ctx->hi = 0;
 }
 
 void MD4_Update(MD4_CTX *ctx, const void *data, unsigned long size)
 {
-	MD4_u32plus saved_lo;
-	unsigned long used, available;
-
-	saved_lo = ctx->lo;
-	if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
-		ctx->hi++;
-	ctx->hi += size >> 29;
-
-	used = saved_lo & 0x3f;
-
-	if (used) {
-		available = 64 - used;
-
-		if (size < available) {
-			memcpy(&ctx->buffer[used], data, size);
-			return;
-		}
-
-		memcpy(&ctx->buffer[used], data, available);
-		data = (const unsigned char *)data + available;
-		size -= available;
-		body(ctx, ctx->buffer, 64);
-	}
-
-	if (size >= 64) {
-		data = body(ctx, data, size & ~(unsigned long)0x3f);
-		size &= 0x3f;
-	}
-
-	memcpy(ctx->buffer, data, size);
+    MD4_u32plus saved_lo;
+    unsigned long used, available;
+
+    saved_lo = ctx->lo;
+    if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
+        ctx->hi++;
+    ctx->hi += size >> 29;
+
+    used = saved_lo & 0x3f;
+
+    if (used)
+    {
+        available = 64 - used;
+
+        if (size < available)
+        {
+            memcpy(&ctx->buffer[used], data, size);
+            return;
+        }
+
+        memcpy(&ctx->buffer[used], data, available);
+        data = (const unsigned char *)data + available;
+        size -= available;
+        body(ctx, ctx->buffer, 64);
+    }
+
+    if (size >= 64)
+    {
+        data = body(ctx, data, size & ~(unsigned long)0x3f);
+        size &= 0x3f;
+    }
+
+    memcpy(ctx->buffer, data, size);
 }
 
 void MD4_Final(unsigned char *result, MD4_CTX *ctx)
 {
-	unsigned long used, available;
-
-	used = ctx->lo & 0x3f;
-
-	ctx->buffer[used++] = 0x80;
-
-	available = 64 - used;
-
-	if (available < 8) {
-		memset(&ctx->buffer[used], 0, available);
-		body(ctx, ctx->buffer, 64);
-		used = 0;
-		available = 64;
-	}
-
-	memset(&ctx->buffer[used], 0, available - 8);
-
-	ctx->lo <<= 3;
-	ctx->buffer[56] = ctx->lo;
-	ctx->buffer[57] = ctx->lo >> 8;
-	ctx->buffer[58] = ctx->lo >> 16;
-	ctx->buffer[59] = ctx->lo >> 24;
-	ctx->buffer[60] = ctx->hi;
-	ctx->buffer[61] = ctx->hi >> 8;
-	ctx->buffer[62] = ctx->hi >> 16;
-	ctx->buffer[63] = ctx->hi >> 24;
-
-	body(ctx, ctx->buffer, 64);
-
-	result[0] = ctx->a;
-	result[1] = ctx->a >> 8;
-	result[2] = ctx->a >> 16;
-	result[3] = ctx->a >> 24;
-	result[4] = ctx->b;
-	result[5] = ctx->b >> 8;
-	result[6] = ctx->b >> 16;
-	result[7] = ctx->b >> 24;
-	result[8] = ctx->c;
-	result[9] = ctx->c >> 8;
-	result[10] = ctx->c >> 16;
-	result[11] = ctx->c >> 24;
-	result[12] = ctx->d;
-	result[13] = ctx->d >> 8;
-	result[14] = ctx->d >> 16;
-	result[15] = ctx->d >> 24;
-
-	memset(ctx, 0, sizeof(*ctx));
+    unsigned long used, available;
+
+    used = ctx->lo & 0x3f;
+
+    ctx->buffer[used++] = 0x80;
+
+    available = 64 - used;
+
+    if (available < 8)
+    {
+        memset(&ctx->buffer[used], 0, available);
+        body(ctx, ctx->buffer, 64);
+        used = 0;
+        available = 64;
+    }
+
+    memset(&ctx->buffer[used], 0, available - 8);
+
+    ctx->lo <<= 3;
+    ctx->buffer[56] = ctx->lo;
+    ctx->buffer[57] = ctx->lo >> 8;
+    ctx->buffer[58] = ctx->lo >> 16;
+    ctx->buffer[59] = ctx->lo >> 24;
+    ctx->buffer[60] = ctx->hi;
+    ctx->buffer[61] = ctx->hi >> 8;
+    ctx->buffer[62] = ctx->hi >> 16;
+    ctx->buffer[63] = ctx->hi >> 24;
+
+    body(ctx, ctx->buffer, 64);
+
+    result[0] = ctx->a;
+    result[1] = ctx->a >> 8;
+    result[2] = ctx->a >> 16;
+    result[3] = ctx->a >> 24;
+    result[4] = ctx->b;
+    result[5] = ctx->b >> 8;
+    result[6] = ctx->b >> 16;
+    result[7] = ctx->b >> 24;
+    result[8] = ctx->c;
+    result[9] = ctx->c >> 8;
+    result[10] = ctx->c >> 16;
+    result[11] = ctx->c >> 24;
+    result[12] = ctx->d;
+    result[13] = ctx->d >> 8;
+    result[14] = ctx->d >> 16;
+    result[15] = ctx->d >> 24;
+
+    memset(ctx, 0, sizeof(*ctx));
 }
 
 #endif

contrib/mdx/md4.h

@@ -31,11 +31,12 @@
 /* Any 32-bit or wider unsigned integer data type will do */
 typedef unsigned int MD4_u32plus;
 
-typedef struct {
-	MD4_u32plus lo, hi;
-	MD4_u32plus a, b, c, d;
-	unsigned char buffer[64];
-	MD4_u32plus block[16];
+typedef struct
+{
+    MD4_u32plus lo, hi;
+    MD4_u32plus a, b, c, d;
+    unsigned char buffer[64];
+    MD4_u32plus block[16];
 } MD4_CTX;
 
 extern void MD4_Init(MD4_CTX *ctx);

contrib/mdx/md5.c

@@ -48,19 +48,19 @@
  * architectures that lack an AND-NOT instruction, just like in Colin Plumb's
  * implementation.
  */
-#define F(x, y, z)			((z) ^ ((x) & ((y) ^ (z))))
-#define G(x, y, z)			((y) ^ ((z) & ((x) ^ (y))))
-#define H(x, y, z)			(((x) ^ (y)) ^ (z))
-#define H2(x, y, z)			((x) ^ ((y) ^ (z)))
-#define I(x, y, z)			((y) ^ ((x) | ~(z)))
+#define F(x, y, z)          ((z) ^ ((x) & ((y) ^ (z))))
+#define G(x, y, z)          ((y) ^ ((z) & ((x) ^ (y))))
+#define H(x, y, z)          (((x) ^ (y)) ^ (z))
+#define H2(x, y, z)         ((x) ^ ((y) ^ (z)))
+#define I(x, y, z)          ((y) ^ ((x) | ~(z)))
 
 /*
  * The MD5 transformation for all four rounds.
  */
 #define STEP(f, a, b, c, d, x, t, s) \
-	(a) += f((b), (c), (d)) + (x) + (t); \
-	(a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
-	(a) += (b);
+    (a) += f((b), (c), (d)) + (x) + (t); \
+    (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
+    (a) += (b);
 
 /*
  * SET reads 4 input bytes in little-endian byte order and stores them
@@ -72,18 +72,18 @@
  */
 #if defined(__i386__) || defined(__x86_64__) || defined(__vax__)
 #define SET(n) \
-	(*(MD5_u32plus *)&ptr[(n) * 4])
+    (*(MD5_u32plus *)&ptr[(n) * 4])
 #define GET(n) \
-	SET(n)
+    SET(n)
 #else
 #define SET(n) \
-	(ctx->block[(n)] = \
-	(MD5_u32plus)ptr[(n) * 4] | \
-	((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \
-	((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \
-	((MD5_u32plus)ptr[(n) * 4 + 3] << 24))
+    (ctx->block[(n)] = \
+    (MD5_u32plus)ptr[(n) * 4] | \
+    ((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \
+    ((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \
+    ((MD5_u32plus)ptr[(n) * 4 + 3] << 24))
 #define GET(n) \
-	(ctx->block[(n)])
+    (ctx->block[(n)])
 #endif
 
 /*
@@ -92,205 +92,211 @@
  */
 static const void *body(MD5_CTX *ctx, const void *data, unsigned long size)
 {
-	const unsigned char *ptr;
-	MD5_u32plus a, b, c, d;
-	MD5_u32plus saved_a, saved_b, saved_c, saved_d;
-
-	ptr = (const unsigned char *)data;
-
-	a = ctx->a;
-	b = ctx->b;
-	c = ctx->c;
-	d = ctx->d;
-
-	do {
-		saved_a = a;
-		saved_b = b;
-		saved_c = c;
-		saved_d = d;
-
-/* Round 1 */
-		STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7)
-		STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12)
-		STEP(F, c, d, a, b, SET(2), 0x242070db, 17)
-		STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22)
-		STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7)
-		STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12)
-		STEP(F, c, d, a, b, SET(6), 0xa8304613, 17)
-		STEP(F, b, c, d, a, SET(7), 0xfd469501, 22)
-		STEP(F, a, b, c, d, SET(8), 0x698098d8, 7)
-		STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12)
-		STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17)
-		STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22)
-		STEP(F, a, b, c, d, SET(12), 0x6b901122, 7)
-		STEP(F, d, a, b, c, SET(13), 0xfd987193, 12)
-		STEP(F, c, d, a, b, SET(14), 0xa679438e, 17)
-		STEP(F, b, c, d, a, SET(15), 0x49b40821, 22)
-
-/* Round 2 */
-		STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5)
-		STEP(G, d, a, b, c, GET(6), 0xc040b340, 9)
-		STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14)
-		STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20)
-		STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5)
-		STEP(G, d, a, b, c, GET(10), 0x02441453, 9)
-		STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14)
-		STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20)
-		STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5)
-		STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9)
-		STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14)
-		STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20)
-		STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5)
-		STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9)
-		STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)
-		STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)
-
-/* Round 3 */
-		STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)
-		STEP(H2, d, a, b, c, GET(8), 0x8771f681, 11)
-		STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)
-		STEP(H2, b, c, d, a, GET(14), 0xfde5380c, 23)
-		STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4)
-		STEP(H2, d, a, b, c, GET(4), 0x4bdecfa9, 11)
-		STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16)
-		STEP(H2, b, c, d, a, GET(10), 0xbebfbc70, 23)
-		STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4)
-		STEP(H2, d, a, b, c, GET(0), 0xeaa127fa, 11)
-		STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16)
-		STEP(H2, b, c, d, a, GET(6), 0x04881d05, 23)
-		STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4)
-		STEP(H2, d, a, b, c, GET(12), 0xe6db99e5, 11)
-		STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16)
-		STEP(H2, b, c, d, a, GET(2), 0xc4ac5665, 23)
-
-/* Round 4 */
-		STEP(I, a, b, c, d, GET(0), 0xf4292244, 6)
-		STEP(I, d, a, b, c, GET(7), 0x432aff97, 10)
-		STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15)
-		STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21)
-		STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6)
-		STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10)
-		STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15)
-		STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21)
-		STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6)
-		STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10)
-		STEP(I, c, d, a, b, GET(6), 0xa3014314, 15)
-		STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21)
-		STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6)
-		STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10)
-		STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15)
-		STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21)
-
-		a += saved_a;
-		b += saved_b;
-		c += saved_c;
-		d += saved_d;
-
-		ptr += 64;
-	} while (size -= 64);
-
-	ctx->a = a;
-	ctx->b = b;
-	ctx->c = c;
-	ctx->d = d;
-
-	return ptr;
+    const unsigned char *ptr;
+    MD5_u32plus a, b, c, d;
+    MD5_u32plus saved_a, saved_b, saved_c, saved_d;
+
+    ptr = (const unsigned char *)data;
+
+    a = ctx->a;
+    b = ctx->b;
+    c = ctx->c;
+    d = ctx->d;
+
+    do
+    {
+        saved_a = a;
+        saved_b = b;
+        saved_c = c;
+        saved_d = d;
+
+        /* Round 1 */
+        STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7)
+        STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12)
+        STEP(F, c, d, a, b, SET(2), 0x242070db, 17)
+        STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22)
+        STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7)
+        STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12)
+        STEP(F, c, d, a, b, SET(6), 0xa8304613, 17)
+        STEP(F, b, c, d, a, SET(7), 0xfd469501, 22)
+        STEP(F, a, b, c, d, SET(8), 0x698098d8, 7)
+        STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12)
+        STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17)
+        STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22)
+        STEP(F, a, b, c, d, SET(12), 0x6b901122, 7)
+        STEP(F, d, a, b, c, SET(13), 0xfd987193, 12)
+        STEP(F, c, d, a, b, SET(14), 0xa679438e, 17)
+        STEP(F, b, c, d, a, SET(15), 0x49b40821, 22)
+
+        /* Round 2 */
+        STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5)
+        STEP(G, d, a, b, c, GET(6), 0xc040b340, 9)
+        STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14)
+        STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20)
+        STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5)
+        STEP(G, d, a, b, c, GET(10), 0x02441453, 9)
+        STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14)
+        STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20)
+        STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5)
+        STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9)
+        STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14)
+        STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20)
+        STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5)
+        STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9)
+        STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)
+        STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)
+
+        /* Round 3 */
+        STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)
+        STEP(H2, d, a, b, c, GET(8), 0x8771f681, 11)
+        STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)
+        STEP(H2, b, c, d, a, GET(14), 0xfde5380c, 23)
+        STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4)
+        STEP(H2, d, a, b, c, GET(4), 0x4bdecfa9, 11)
+        STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16)
+        STEP(H2, b, c, d, a, GET(10), 0xbebfbc70, 23)
+        STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4)
+        STEP(H2, d, a, b, c, GET(0), 0xeaa127fa, 11)
+        STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16)
+        STEP(H2, b, c, d, a, GET(6), 0x04881d05, 23)
+        STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4)
+        STEP(H2, d, a, b, c, GET(12), 0xe6db99e5, 11)
+        STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16)
+        STEP(H2, b, c, d, a, GET(2), 0xc4ac5665, 23)
+
+        /* Round 4 */
+        STEP(I, a, b, c, d, GET(0), 0xf4292244, 6)
+        STEP(I, d, a, b, c, GET(7), 0x432aff97, 10)
+        STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15)
+        STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21)
+        STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6)
+        STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10)
+        STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15)
+        STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21)
+        STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6)
+        STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10)
+        STEP(I, c, d, a, b, GET(6), 0xa3014314, 15)
+        STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21)
+        STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6)
+        STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10)
+        STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15)
+        STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21)
+
+        a += saved_a;
+        b += saved_b;
+        c += saved_c;
+        d += saved_d;
+
+        ptr += 64;
+    }
+    while (size -= 64);
+
+    ctx->a = a;
+    ctx->b = b;
+    ctx->c = c;
+    ctx->d = d;
+
+    return ptr;
 }
 
 void MD5_Init(MD5_CTX *ctx)
 {
-	ctx->a = 0x67452301;
-	ctx->b = 0xefcdab89;
-	ctx->c = 0x98badcfe;
-	ctx->d = 0x10325476;
+    ctx->a = 0x67452301;
+    ctx->b = 0xefcdab89;
+    ctx->c = 0x98badcfe;
+    ctx->d = 0x10325476;
 
-	ctx->lo = 0;
-	ctx->hi = 0;
+    ctx->lo = 0;
+    ctx->hi = 0;
 }
 
 void MD5_Update(MD5_CTX *ctx, const void *data, unsigned long size)
 {
-	MD5_u32plus saved_lo;
-	unsigned long used, available;
-
-	saved_lo = ctx->lo;
-	if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
-		ctx->hi++;
-	ctx->hi += size >> 29;
-
-	used = saved_lo & 0x3f;
-
-	if (used) {
-		available = 64 - used;
-
-		if (size < available) {
-			memcpy(&ctx->buffer[used], data, size);
-			return;
-		}
-
-		memcpy(&ctx->buffer[used], data, available);
-		data = (const unsigned char *)data + available;
-		size -= available;
-		body(ctx, ctx->buffer, 64);
-	}
-
-	if (size >= 64) {
-		data = body(ctx, data, size & ~(unsigned long)0x3f);
-		size &= 0x3f;
-	}
-
-	memcpy(ctx->buffer, data, size);
+    MD5_u32plus saved_lo;
+    unsigned long used, available;
+
+    saved_lo = ctx->lo;
+    if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
+        ctx->hi++;
+    ctx->hi += size >> 29;
+
+    used = saved_lo & 0x3f;
+
+    if (used)
+    {
+        available = 64 - used;
+
+        if (size < available)
+        {
+            memcpy(&ctx->buffer[used], data, size);
+            return;
+        }
+
+        memcpy(&ctx->buffer[used], data, available);
+        data = (const unsigned char *)data + available;
+        size -= available;
+        body(ctx, ctx->buffer, 64);
+    }
+
+    if (size >= 64)
+    {
+        data = body(ctx, data, size & ~(unsigned long)0x3f);
+        size &= 0x3f;
+    }
+
+    memcpy(ctx->buffer, data, size);
 }
 
 void MD5_Final(unsigned char *result, MD5_CTX *ctx)
 {
-	unsigned long used, available;
-
-	used = ctx->lo & 0x3f;
-
-	ctx->buffer[used++] = 0x80;
-
-	available = 64 - used;
-
-	if (available < 8) {
-		memset(&ctx->buffer[used], 0, available);
-		body(ctx, ctx->buffer, 64);
-		used = 0;
-		available = 64;
-	}
-
-	memset(&ctx->buffer[used], 0, available - 8);
-
-	ctx->lo <<= 3;
-	ctx->buffer[56] = ctx->lo;
-	ctx->buffer[57] = ctx->lo >> 8;
-	ctx->buffer[58] = ctx->lo >> 16;
-	ctx->buffer[59] = ctx->lo >> 24;
-	ctx->buffer[60] = ctx->hi;
-	ctx->buffer[61] = ctx->hi >> 8;
-	ctx->buffer[62] = ctx->hi >> 16;
-	ctx->buffer[63] = ctx->hi >> 24;
-
-	body(ctx, ctx->buffer, 64);
-
-	result[0] = ctx->a;
-	result[1] = ctx->a >> 8;
-	result[2] = ctx->a >> 16;
-	result[3] = ctx->a >> 24;
-	result[4] = ctx->b;
-	result[5] = ctx->b >> 8;
-	result[6] = ctx->b >> 16;
-	result[7] = ctx->b >> 24;
-	result[8] = ctx->c;
-	result[9] = ctx->c >> 8;
-	result[10] = ctx->c >> 16;
-	result[11] = ctx->c >> 24;
-	result[12] = ctx->d;
-	result[13] = ctx->d >> 8;
-	result[14] = ctx->d >> 16;
-	result[15] = ctx->d >> 24;
-
-	memset(ctx, 0, sizeof(*ctx));
+    unsigned long used, available;
+
+    used = ctx->lo & 0x3f;
+
+    ctx->buffer[used++] = 0x80;
+
+    available = 64 - used;
+
+    if (available < 8)
+    {
+        memset(&ctx->buffer[used], 0, available);
+        body(ctx, ctx->buffer, 64);
+        used = 0;
+        available = 64;
+    }
+
+    memset(&ctx->buffer[used], 0, available - 8);
+
+    ctx->lo <<= 3;
+    ctx->buffer[56] = ctx->lo;
+    ctx->buffer[57] = ctx->lo >> 8;
+    ctx->buffer[58] = ctx->lo >> 16;
+    ctx->buffer[59] = ctx->lo >> 24;
+    ctx->buffer[60] = ctx->hi;
+    ctx->buffer[61] = ctx->hi >> 8;
+    ctx->buffer[62] = ctx->hi >> 16;
+    ctx->buffer[63] = ctx->hi >> 24;
+
+    body(ctx, ctx->buffer, 64);
+
+    result[0] = ctx->a;
+    result[1] = ctx->a >> 8;
+    result[2] = ctx->a >> 16;
+    result[3] = ctx->a >> 24;
+    result[4] = ctx->b;
+    result[5] = ctx->b >> 8;
+    result[6] = ctx->b >> 16;
+    result[7] = ctx->b >> 24;
+    result[8] = ctx->c;
+    result[9] = ctx->c >> 8;
+    result[10] = ctx->c >> 16;
+    result[11] = ctx->c >> 24;
+    result[12] = ctx->d;
+    result[13] = ctx->d >> 8;
+    result[14] = ctx->d >> 16;
+    result[15] = ctx->d >> 24;
+
+    memset(ctx, 0, sizeof(*ctx));
 }
 
 #endif

contrib/mdx/md5.h

@@ -31,11 +31,12 @@
 /* Any 32-bit or wider unsigned integer data type will do */
 typedef unsigned int MD5_u32plus;
 
-typedef struct {
-	MD5_u32plus lo, hi;
-	MD5_u32plus a, b, c, d;
-	unsigned char buffer[64];
-	MD5_u32plus block[16];
+typedef struct
+{
+    MD5_u32plus lo, hi;
+    MD5_u32plus a, b, c, d;
+    unsigned char buffer[64];
+    MD5_u32plus block[16];
 } MD5_CTX;
 
 extern void MD5_Init(MD5_CTX *ctx);

contrib/rc4/rc4.c

@@ -42,11 +42,11 @@
 static __inline void
 swap_bytes(u_char *a, u_char *b)
 {
-	u_char temp;
+    u_char temp;
 
-	temp = *a;
-	*a = *b;
-	*b = temp;
+    temp = *a;
+    *a = *b;
+    *b = temp;
 }
 
 /*
@@ -56,20 +56,21 @@ swap_bytes(u_char *a, u_char *b)
 void
 rc4_init(struct rc4_state *const state, const u_char *key, int keylen)
 {
-	u_char j;
-	int i;
+    u_char j;
+    int i;
 
-	/* Initialize state with identity permutation */
-	for (i = 0; i < 256; i++)
-		state->perm[i] = (u_char)i;
-	state->index1 = 0;
-	state->index2 = 0;
+    /* Initialize state with identity permutation */
+    for (i = 0; i < 256; i++)
+        state->perm[i] = (u_char)i;
+    state->index1 = 0;
+    state->index2 = 0;
 
-	/* Randomize the permutation using key data */
-	for (j = i = 0; i < 256; i++) {
-		j += state->perm[i] + key[i % keylen];
-		swap_bytes(&state->perm[i], &state->perm[j]);
-	}
+    /* Randomize the permutation using key data */
+    for (j = i = 0; i < 256; i++)
+    {
+        j += state->perm[i] + key[i % keylen];
+        swap_bytes(&state->perm[i], &state->perm[j]);
+    }
 }
 
 /*
@@ -80,24 +81,25 @@ rc4_init(struct rc4_state *const state, const u_char *key, int keylen)
  */
 void
 rc4_crypt(struct rc4_state *const state,
-	const u_char *inbuf, u_char *outbuf, int buflen)
+          const u_char *inbuf, u_char *outbuf, int buflen)
 {
-	int i;
-	u_char j;
+    int i;
+    u_char j;
 
-	for (i = 0; i < buflen; i++) {
+    for (i = 0; i < buflen; i++)
+    {
 
-		/* Update modification indicies */
-		state->index1++;
-		state->index2 += state->perm[state->index1];
+        /* Update modification indicies */
+        state->index1++;
+        state->index2 += state->perm[state->index1];
 
-		/* Modify permutation */
-		swap_bytes(&state->perm[state->index1],
-		    &state->perm[state->index2]);
+        /* Modify permutation */
+        swap_bytes(&state->perm[state->index1],
+                   &state->perm[state->index2]);
 
-		/* Encrypt/decrypt next byte */
-		j = state->perm[state->index1] + state->perm[state->index2];
-		outbuf[i] = inbuf[i] ^ state->perm[j];
-	}
+        /* Encrypt/decrypt next byte */
+        j = state->perm[state->index1] + state->perm[state->index2];
+        outbuf[i] = inbuf[i] ^ state->perm[j];
+    }
 }
 

contrib/rc4/rc4.h

@@ -39,15 +39,16 @@
 #ifndef _SYS_CRYPTO_RC4_RC4_H_
 #define _SYS_CRYPTO_RC4_RC4_H_
 
-struct rc4_state {
-	u_char	perm[256];
-	u_char	index1;
-	u_char	index2;
+struct rc4_state
+{
+    u_char  perm[256];
+    u_char  index1;
+    u_char  index2;
 };
 
 extern void rc4_init(struct rc4_state *state, const u_char *key, int keylen);
 extern void rc4_crypt(struct rc4_state *state,
-		const u_char *inbuf, u_char *outbuf, int buflen);
+                      const u_char *inbuf, u_char *outbuf, int buflen);
 
 #endif
 

include/bdsm/netbios_defs.h

@@ -54,22 +54,22 @@
 
 typedef struct
 {
-  uint16_t                    trn_id;     // Transaction ID
-  uint16_t                    flags;      // Various flags
-  uint16_t                    queries;    // Number of queries in this packet
-  uint16_t                    answers;    // Number of answers
-  uint16_t                    ns_count;   // Number of authorities (?)
-  uint16_t                    ar_count;   // Additionnal (??)
-  char                        payload[];
+    uint16_t                    trn_id;     // Transaction ID
+    uint16_t                    flags;      // Various flags
+    uint16_t                    queries;    // Number of queries in this packet
+    uint16_t                    answers;    // Number of answers
+    uint16_t                    ns_count;   // Number of authorities (?)
+    uint16_t                    ar_count;   // Additionnal (??)
+    char                        payload[];
 } __attribute__((packed))   netbios_query_packet;
 
 typedef struct
 {
-  uint8_t                     opcode;     // 'TYPE'
-  uint8_t                     flags;      // 0-6 reserved (== 0), byte 7 is the
-                                          // beginning of the length field (!!)
-  uint16_t                    length;     // payload length;
-  uint8_t                     payload[];
+    uint8_t                     opcode;     // 'TYPE'
+    uint8_t                     flags;      // 0-6 reserved (== 0), byte 7 is the
+    // beginning of the length field (!!)
+    uint16_t                    length;     // payload length;
+    uint8_t                     payload[];
 } __attribute__((packed))   netbios_session_packet;
 
 #endif

include/bdsm/netbios_ns.h

@@ -39,10 +39,10 @@
  */
 typedef struct                netbios_ns_entry_s
 {
-  struct netbios_ns_entry_s     *next;
-  struct in_addr                address;
-  char                          name[NETBIOS_NAME_LENGTH + 1];
-  char                          type;
+    struct netbios_ns_entry_s     *next;
+    struct in_addr                address;
+    char                          name[NETBIOS_NAME_LENGTH + 1];
+    char                          type;
 }                             netbios_ns_entry;
 
 /**
@@ -78,11 +78,12 @@ char                netbios_ns_entry_type(netbios_ns_entry *entry);
  * structure, use the related functions to interact with it.
  */
 
-typedef struct {
-  int                 socket;
-  struct sockaddr_in  addr;
-  uint16_t            last_trn_id;  // Last transaction id used;
-  netbios_ns_entry  *entries;     // NS entries cache, mainly used by discover()
+typedef struct
+{
+    int                 socket;
+    struct sockaddr_in  addr;
+    uint16_t            last_trn_id;  // Last transaction id used;
+    netbios_ns_entry  *entries;     // NS entries cache, mainly used by discover()
 }                   netbios_ns;
 
 /**
@@ -111,7 +112,7 @@ void          netbios_ns_destroy(netbios_ns *ns);
  * @return the ipv4 address in network byte-order or 0 if it wasn't successfull.
  */
 int           netbios_ns_resolve(netbios_ns *ns, const char *name,
-                                 char type, uint32_t * addr);
+                                 char type, uint32_t *addr);
 
 /**
  * @brief Try to discover all the Netbios/SMB speaking machine on the LAN.
@@ -182,7 +183,7 @@ void                netbios_ns_clear(netbios_ns *ns);
  * @return The added entry
  */
 netbios_ns_entry    *netbios_ns_entry_add(netbios_ns *ns, const char *name,
-                                          char type, uint32_t ip);
+        char type, uint32_t ip);
 /**
  * @internal
  * @brief Find an entry in
@@ -194,6 +195,6 @@ netbios_ns_entry    *netbios_ns_entry_add(netbios_ns *ns, const char *name,
  * @return [description]
  */
 netbios_ns_entry    *netbios_ns_entry_find(netbios_ns *ns, const char *by_name,
-                                           uint32_t ip);
+        uint32_t ip);
 
 #endif

include/bdsm/netbios_query.h

@@ -24,17 +24,18 @@
 
 #include "bdsm/netbios_defs.h"
 
-typedef struct              netbios_query_s {
-  size_t                      payload_size;
-  size_t                      cursor;
-  netbios_query_packet      *packet;
+typedef struct              netbios_query_s
+{
+    size_t                      payload_size;
+    size_t                      cursor;
+    netbios_query_packet      *packet;
 }                           netbios_query;
 
 netbios_query   *netbios_query_new(size_t payload_size, int is_query,
-                                     char opcode);
+                                   char opcode);
 void              netbios_query_destroy(netbios_query *q);
 void              netbios_query_set_flag(netbios_query *q,
-                                         uint16_t flag, int value);
+        uint16_t flag, int value);
 int               netbios_query_append(netbios_query *q, const char *data,
                                        size_t data_size);
 

include/bdsm/netbios_session.h

@@ -33,19 +33,20 @@
 #define NETBIOS_SESSION_ERROR       -1
 #define NETBIOS_SESSION_REFUSED     -2
 
-typedef struct              netbios_session_s {
-  // The address of the remote peer;
-  struct sockaddr_in          remote_addr;
-  // The socket of the TCP connection to the HOST'
-  int                         socket;
-  // The current sessions state; See macro before (eg. NETBIOS_SESSION_ERROR)
-  int                         state;
-  // What is the size of the allocated payload;
-  size_t                      packet_payload_size;
-  // Where is the write cursor relative to the beginning of the payload
-  size_t                      packet_cursor;
-  // Our allocated packet, this is where the magic happen (both send and recv :)
-  netbios_session_packet      *packet;
+typedef struct              netbios_session_s
+{
+    // The address of the remote peer;
+    struct sockaddr_in          remote_addr;
+    // The socket of the TCP connection to the HOST'
+    int                         socket;
+    // The current sessions state; See macro before (eg. NETBIOS_SESSION_ERROR)
+    int                         state;
+    // What is the size of the allocated payload;
+    size_t                      packet_payload_size;
+    // Where is the write cursor relative to the beginning of the payload
+    size_t                      packet_cursor;
+    // Our allocated packet, this is where the magic happen (both send and recv :)
+    netbios_session_packet      *packet;
 }                           netbios_session;
 
 
@@ -53,12 +54,12 @@ typedef struct              netbios_session_s {
 netbios_session   *netbios_session_new(size_t buf_size);
 void              netbios_session_destroy(netbios_session *);
 int               netbios_session_connect(struct in_addr *addr,
-                                          netbios_session *s,
-                                          const char *name,
-                                          int direct_tcp);
+        netbios_session *s,
+        const char *name,
+        int direct_tcp);
 void              netbios_session_packet_init(netbios_session *s);
 int               netbios_session_packet_append(netbios_session *s,
-                                                const char *data, size_t size);
+        const char *data, size_t size);
 int               netbios_session_packet_send(netbios_session *s);
 ssize_t           netbios_session_packet_recv(netbios_session *s, void **data);
 

include/bdsm/smb_buffer.h

@@ -32,8 +32,8 @@
   */
 typedef struct
 {
-  void      *data;  /// Data pointed
-  size_t    size;   /// Size in byte of the pointed
+    void      *data;  /// Data pointed
+    size_t    size;   /// Size in byte of the pointed
 } smb_buffer;
 
 /**

include/bdsm/smb_defs.h

@@ -30,10 +30,10 @@
 
 enum
 {
-  /// SMB with Direct-TCP connection (OSX supports only this)
-  SMB_TRANSPORT_TCP       = 1,
-  /// SMB with Netbios over TCP (older mechanism)
-  SMB_TRANSPORT_NBT       = 2
+    /// SMB with Direct-TCP connection (OSX supports only this)
+    SMB_TRANSPORT_TCP       = 1,
+    /// SMB with Netbios over TCP (older mechanism)
+    SMB_TRANSPORT_NBT       = 2
 };
 
 //-----------------------------------------------------------------------------/
@@ -41,16 +41,16 @@ enum
 //-----------------------------------------------------------------------------/
 enum
 {
-  /// Error state, there was an error somewhere
-  SMB_STATE_ERROR             = -1,
-  /// The SMB session has just been created
-  SMB_STATE_NEW               = 0,
-  /// A Netbios session has been successfully established.
-  SMB_STATE_NETBIOS_OK        = 1,
-  /// Dialect was successfully negotiated
-  SMB_STATE_DIALECT_OK        = 2,
-  /// Session Authentication was successfull, you can become nasty
-  SMB_STATE_SESSION_OK        = 3
+    /// Error state, there was an error somewhere
+    SMB_STATE_ERROR             = -1,
+    /// The SMB session has just been created
+    SMB_STATE_NEW               = 0,
+    /// A Netbios session has been successfully established.
+    SMB_STATE_NETBIOS_OK        = 1,
+    /// Dialect was successfully negotiated
+    SMB_STATE_DIALECT_OK        = 2,
+    /// Session Authentication was successfull, you can become nasty
+    SMB_STATE_SESSION_OK        = 3
 };
 
 //-----------------------------------------------------------------------------/
@@ -59,15 +59,15 @@ enum
 // smb_fseek operations
 enum
 {
-  /// Set the read pointer at the given position
-  SMB_SEEK_SET                = 0,
-  /// Adjusts the read pointer relatively to the actual position
-  SMB_SEEK_CUR                = 1
+    /// Set the read pointer at the given position
+    SMB_SEEK_SET                = 0,
+    /// Adjusts the read pointer relatively to the actual position
+    SMB_SEEK_CUR                = 1
 };
 
 enum smb_session_supports_what
 {
-  SMB_SESSION_XSEC            = 0,
+    SMB_SESSION_XSEC            = 0,
 };
 
 //-----------------------------------------------------------------------------/

include/bdsm/smb_ntlm.h

@@ -29,12 +29,12 @@ typedef uint8_t smb_ntlmh[SMB_NTLM_HASH_SIZE];
 
 typedef struct
 {
-  uint32_t    header;
-  uint32_t    reserved;
-  uint64_t    timestamp;
-  uint64_t    challenge;
-  uint32_t    unknown;
-  uint8_t     target[];
+    uint32_t    header;
+    uint32_t    reserved;
+    uint64_t    timestamp;
+    uint64_t    challenge;
+    uint32_t    unknown;
+    uint8_t     target[];
 } __attribute__((packed)) smb_ntlm_blob;
 
 
@@ -53,36 +53,36 @@ typedef struct
 
 typedef struct
 {
-  _NTLMSSP_COMMON
-  uint32_t    flags;
-  _NTLMSSP_FIELD(domain)
-  _NTLMSSP_FIELD(host)
-  uint8_t     names[];
+    _NTLMSSP_COMMON
+    uint32_t    flags;
+    _NTLMSSP_FIELD(domain)
+    _NTLMSSP_FIELD(host)
+    uint8_t     names[];
 } __attribute__((packed)) smb_ntlmssp_nego;
 
 typedef struct
 {
-  _NTLMSSP_COMMON
-  _NTLMSSP_FIELD(name)
-  uint32_t    flags;
-  uint64_t    challenge;
-  uint64_t    reserved;
-  _NTLMSSP_FIELD(tgt) // Target Info
-  uint8_t     data[];
+    _NTLMSSP_COMMON
+    _NTLMSSP_FIELD(name)
+    uint32_t    flags;
+    uint64_t    challenge;
+    uint64_t    reserved;
+    _NTLMSSP_FIELD(tgt) // Target Info
+    uint8_t     data[];
 } __attribute__((packed)) smb_ntlmssp_challenge;
 
 typedef struct
 {
-  _NTLMSSP_COMMON
-  _NTLMSSP_FIELD(lm)
-  _NTLMSSP_FIELD(ntlm)
-  _NTLMSSP_FIELD(domain)
-  _NTLMSSP_FIELD(user)
-  _NTLMSSP_FIELD(host)
-  _NTLMSSP_FIELD(session_key)
-
-  uint32_t    flags;
-  uint8_t     data[];
+    _NTLMSSP_COMMON
+    _NTLMSSP_FIELD(lm)
+    _NTLMSSP_FIELD(ntlm)
+    _NTLMSSP_FIELD(domain)
+    _NTLMSSP_FIELD(user)
+    _NTLMSSP_FIELD(host)
+    _NTLMSSP_FIELD(session_key)
+
+    uint32_t    flags;
+    uint8_t     data[];
 } __attribute__((packed)) smb_ntlmssp_auth;
 
 uint64_t    smb_ntlm_generate_challenge();

include/bdsm/smb_packets.h

@@ -32,24 +32,24 @@
 
 typedef struct
 {
-  uint8_t         magic[4];     // { 0xff, 0x53, 0x4d, 0x42 } "\xffSMB"
-  uint8_t         command;      // The actual SMB command
-  uint32_t        status;       // 'NT Status'
-  uint8_t         flags;        // Packet flags
-  uint16_t        flags2;       // More flags ? (lol)
-  uint16_t        pid_high;     // Unused ?
-  uint64_t        signature;    // Unused ?
-  uint16_t        reserved;     // More usuned bit (we have so much BW :)
-  uint16_t        tid;          // A kind of fd for share. (tree_connect)
-  uint16_t        pid;          // Process ID.
-  uint16_t        uid;          // User ID.
-  uint16_t        mux_id;       // Multiplex ID. Increment it sometimes.
+    uint8_t         magic[4];     // { 0xff, 0x53, 0x4d, 0x42 } "\xffSMB"
+    uint8_t         command;      // The actual SMB command
+    uint32_t        status;       // 'NT Status'
+    uint8_t         flags;        // Packet flags
+    uint16_t        flags2;       // More flags ? (lol)
+    uint16_t        pid_high;     // Unused ?
+    uint64_t        signature;    // Unused ?
+    uint16_t        reserved;     // More usuned bit (we have so much BW :)
+    uint16_t        tid;          // A kind of fd for share. (tree_connect)
+    uint16_t        pid;          // Process ID.
+    uint16_t        uid;          // User ID.
+    uint16_t        mux_id;       // Multiplex ID. Increment it sometimes.
 } __attribute__((packed))       smb_header;
 
 typedef struct
 {
-  smb_header    header;       // A packet header full of gorgeous goodness.
-  uint8_t         payload[];    // Ze yummy data inside. Eat 5 fruits/day !
+    smb_header    header;       // A packet header full of gorgeous goodness.
+    uint8_t         payload[];    // Ze yummy data inside. Eat 5 fruits/day !
 } __attribute__((packed))       smb_packet;
 
 
@@ -59,9 +59,9 @@ typedef struct
 //-> Negotiate Protocol
 typedef struct
 {
-  uint8_t         wct; // zero
-  uint16_t        bct;
-  char            dialects[];
+    uint8_t         wct; // zero
+    uint16_t        bct;
+    char            dialects[];
 
 } __attribute__((packed))   smb_nego_req;
 
@@ -83,17 +83,17 @@ typedef struct
 //<- Negotiate Protocol
 typedef struct
 {
-  SMB_NEGO_RESP_COMMON
-  uint64_t        challenge;      // Normally 8 bytes, if not then wtf monkey
-  uint8_t         payload[];      // The rest isn't really meaningfull for us
+    SMB_NEGO_RESP_COMMON
+    uint64_t        challenge;      // Normally 8 bytes, if not then wtf monkey
+    uint8_t         payload[];      // The rest isn't really meaningfull for us
 } __attribute__((packed))   smb_nego_resp;
 
 //<- Negotiate Protocol
 typedef struct
 {
-  SMB_NEGO_RESP_COMMON
-  uint8_t         srv_guid[16];
-  uint8_t         gssapi[];
+    SMB_NEGO_RESP_COMMON
+    uint8_t         srv_guid[16];
+    uint8_t         gssapi[];
 } __attribute__((packed))   smb_nego_xsec_resp;
 
 #define SMB_SESSION_REQ_COMMON \
@@ -107,45 +107,45 @@ typedef struct
 //-> Session Setup
 typedef struct
 {
-  SMB_SESSION_REQ_COMMON
-  uint16_t        oem_pass_len; // Length of LM2 response
-  uint16_t        uni_pass_len; // Length of NTLM2 response
-  uint32_t        reserved2;    // 0x00000000
-  uint32_t        caps;         // Capabilities
-  uint16_t        payload_size;
-  uint8_t         payload[];
+    SMB_SESSION_REQ_COMMON
+    uint16_t        oem_pass_len; // Length of LM2 response
+    uint16_t        uni_pass_len; // Length of NTLM2 response
+    uint32_t        reserved2;    // 0x00000000
+    uint32_t        caps;         // Capabilities
+    uint16_t        payload_size;
+    uint8_t         payload[];
 } __attribute__((packed))   smb_session_req;
 
 //-> Session Setup
 typedef struct
 {
-  SMB_SESSION_REQ_COMMON
-  uint16_t        xsec_blob_size; // Length of GSSAPI/SPNEGO blob
-  uint32_t        reserved2;      // 0x00000000
-  uint32_t        caps;           // Capabilities
-  uint16_t        payload_size;
-  uint8_t         payload[];
+    SMB_SESSION_REQ_COMMON
+    uint16_t        xsec_blob_size; // Length of GSSAPI/SPNEGO blob
+    uint32_t        reserved2;      // 0x00000000
+    uint32_t        caps;           // Capabilities
+    uint16_t        payload_size;
+    uint8_t         payload[];
 } __attribute__((packed))   smb_session_xsec_req;
 
 
 //<- Session Setup
 typedef struct
 {
-  uint8_t         wct;
-  SMB_ANDX_MEMBERS
-  uint16_t        action;
-  uint16_t        bct;
-  uint8_t         bullshit[];
+    uint8_t         wct;
+    SMB_ANDX_MEMBERS
+    uint16_t        action;
+    uint16_t        bct;
+    uint8_t         bullshit[];
 } __attribute__((packed))   smb_session_resp;
 
 typedef struct
 {
-  uint8_t         wct;
-  SMB_ANDX_MEMBERS
-  uint16_t        action;
-  uint16_t        xsec_blob_size;
-  uint16_t        payload_size;
-  uint8_t         payload[];
+    uint8_t         wct;
+    SMB_ANDX_MEMBERS
+    uint16_t        action;
+    uint16_t        xsec_blob_size;
+    uint16_t        payload_size;
+    uint8_t         payload[];
 } __attribute__((packed))   smb_session_xsec_resp;
 
 
@@ -153,25 +153,25 @@ typedef struct
 //-> Tree Connect
 typedef struct
 {
-  uint8_t         wct;              // 4
-  SMB_ANDX_MEMBERS
-  uint16_t        flags;
-  uint16_t        passwd_len;       // 1 if not used. Used in Share Level Auth
-  uint16_t        bct;
-  uint8_t         payload[];        // Password | Path | Service
+    uint8_t         wct;              // 4
+    SMB_ANDX_MEMBERS
+    uint16_t        flags;
+    uint16_t        passwd_len;       // 1 if not used. Used in Share Level Auth
+    uint16_t        bct;
+    uint8_t         payload[];        // Password | Path | Service
 
 } __attribute__((packed))   smb_tree_connect_req;
 
 //<- Tree Connect
 typedef struct
 {
-  uint8_t         wct;              // 7
-  SMB_ANDX_MEMBERS
-  uint16_t        opt_support;
-  uint32_t        max_rights;
-  uint32_t        guest_rights;
-  uint16_t        bct;
-  uint8_t         payload[];
+    uint8_t         wct;              // 7
+    SMB_ANDX_MEMBERS
+    uint16_t        opt_support;
+    uint32_t        max_rights;
+    uint32_t        guest_rights;
+    uint16_t        bct;
+    uint8_t         payload[];
 } __attribute__((packed))   smb_tree_connect_resp;
 
 
@@ -179,43 +179,43 @@ typedef struct
 //-> Create File
 typedef struct
 {
-  uint8_t         wct;                // 24
-  SMB_ANDX_MEMBERS
-  uint8_t         reserved2;
-  uint16_t        path_length;
-  uint32_t        flags;
-  uint32_t        root_fid;
-  uint32_t        access_mask;
-  uint64_t        alloc_size;
-  uint32_t        file_attr;
-  uint32_t        share_access;
-  uint32_t        disposition;
-  uint32_t        create_opts;
-  uint32_t        impersonation;
-  uint8_t         security_flags;
-  uint16_t        bct;
-  uint8_t         path[];             // UTF16 Path, starting with '\'
+    uint8_t         wct;                // 24
+    SMB_ANDX_MEMBERS
+    uint8_t         reserved2;
+    uint16_t        path_length;
+    uint32_t        flags;
+    uint32_t        root_fid;
+    uint32_t        access_mask;
+    uint64_t        alloc_size;
+    uint32_t        file_attr;
+    uint32_t        share_access;
+    uint32_t        disposition;
+    uint32_t        create_opts;
+    uint32_t        impersonation;
+    uint8_t         security_flags;
+    uint16_t        bct;
+    uint8_t         path[];             // UTF16 Path, starting with '\'
 } __attribute__((packed))   smb_create_req;
 
 //<- Create File
 typedef struct
 {
-  uint8_t         wct;                // 34
-  SMB_ANDX_MEMBERS
-  uint8_t         oplock_level;
-  uint16_t        fid;
-  uint32_t        action;
-  uint64_t        created;            // File creation time
-  uint64_t        accessed;           // File last access time
-  uint64_t        written;            // File last write time
-  uint64_t        changed;            // File last modification time
-  uint32_t        attr;
-  uint64_t        alloc_size;
-  uint64_t        size;
-  uint16_t        filetype;
-  uint16_t        ipc_state;
-  uint8_t         is_dir;
-  uint16_t        bct;                // 0
+    uint8_t         wct;                // 34
+    SMB_ANDX_MEMBERS
+    uint8_t         oplock_level;
+    uint16_t        fid;
+    uint32_t        action;
+    uint64_t        created;            // File creation time
+    uint64_t        accessed;           // File last access time
+    uint64_t        written;            // File last write time
+    uint64_t        changed;            // File last modification time
+    uint32_t        attr;
+    uint64_t        alloc_size;
+    uint64_t        size;
+    uint16_t        filetype;
+    uint16_t        ipc_state;
+    uint8_t         is_dir;
+    uint16_t        bct;                // 0
 } __attribute__((packed))   smb_create_resp;
 
 
@@ -223,10 +223,10 @@ typedef struct
 //-> Close File
 typedef struct
 {
-  uint8_t         wct;                // 3
-  uint16_t        fid;
-  uint32_t        last_write;         // Not defined == 0xffffffff
-  uint16_t        bct;                // 0
+    uint8_t         wct;                // 3
+    uint16_t        fid;
+    uint32_t        last_write;         // Not defined == 0xffffffff
+    uint16_t        bct;                // 0
 } __attribute__((packed))   smb_close_req;
 
 
@@ -234,59 +234,59 @@ typedef struct
 //-> Read File
 typedef struct
 {
-  uint8_t         wct;                // 12
-  SMB_ANDX_MEMBERS
-  uint16_t        fid;
-  uint32_t        offset;
-  uint16_t        max_count;
-  uint16_t        min_count;
-  uint32_t        max_count_high;     // Continuation of max_count field
-  uint16_t        remaining;
-  uint32_t        offset_high;        // Continuation of offset field'
-  uint16_t        bct;                // 0
+    uint8_t         wct;                // 12
+    SMB_ANDX_MEMBERS
+    uint16_t        fid;
+    uint32_t        offset;
+    uint16_t        max_count;
+    uint16_t        min_count;
+    uint32_t        max_count_high;     // Continuation of max_count field
+    uint16_t        remaining;
+    uint32_t        offset_high;        // Continuation of offset field'
+    uint16_t        bct;                // 0
 } __attribute__((packed))   smb_read_req;
 
 //<- Read File
 typedef struct
 {
-  uint8_t         wct;                // 12
-  SMB_ANDX_MEMBERS
-  uint16_t        remaining;
-  uint16_t        compact_mode;
-  uint16_t        reserved;
-  uint16_t        data_len;
-  uint16_t        data_offset;
-  uint32_t        data_len_high;
-  uint32_t        reserved2;
-  uint16_t        reserved3;
-  uint16_t        bct;
-  uint8_t         padding;
-  uint8_t         file[];
+    uint8_t         wct;                // 12
+    SMB_ANDX_MEMBERS
+    uint16_t        remaining;
+    uint16_t        compact_mode;
+    uint16_t        reserved;
+    uint16_t        data_len;
+    uint16_t        data_offset;
+    uint32_t        data_len_high;
+    uint32_t        reserved2;
+    uint16_t        reserved3;
+    uint16_t        bct;
+    uint8_t         padding;
+    uint8_t         file[];
 } __attribute__((packed))   smb_read_resp;
 
 //-> Trans
 typedef struct
 {
-  uint8_t       wct;                    // 16
-  uint16_t      total_param_count;
-  uint16_t      total_data_count;
-  uint16_t      max_param_count;
-  uint16_t      max_data_count;
-  uint8_t       max_setup_count;
-  uint8_t       reserved;
-  uint16_t      flags;
-  uint32_t      timeout;
-  uint16_t      reserved2;
-  uint16_t      param_count;
-  uint16_t      param_offset;
-  uint16_t      data_count;
-  uint16_t      data_offset;
-  uint8_t       setup_count;
-  uint8_t       reserved3;
-  uint16_t      pipe_function;
-  uint16_t      fid;
-  uint16_t      bct;
-  uint8_t       payload[];
+    uint8_t       wct;                    // 16
+    uint16_t      total_param_count;
+    uint16_t      total_data_count;
+    uint16_t      max_param_count;
+    uint16_t      max_data_count;
+    uint8_t       max_setup_count;
+    uint8_t       reserved;
+    uint16_t      flags;
+    uint32_t      timeout;
+    uint16_t      reserved2;
+    uint16_t      param_count;
+    uint16_t      param_offset;
+    uint16_t      data_count;
+    uint16_t      data_offset;
+    uint8_t       setup_count;
+    uint8_t       reserved3;
+    uint16_t      pipe_function;
+    uint16_t      fid;
+    uint16_t      bct;
+    uint8_t       payload[];
 } __attribute__((packed))   smb_trans_req;
 
 
@@ -296,130 +296,130 @@ typedef struct
 //-> Trans2
 typedef struct
 {
-  uint8_t       wct;                // 15
-  uint16_t      total_param_count;
-  uint16_t      total_data_count;
-  uint16_t      max_param_count;
-  uint16_t      max_data_count;
-  uint8_t       max_setup_count;
-  uint8_t       reserved;
-  uint16_t      flags;
-  uint32_t      timeout;
-  uint16_t      reserve2;
-  uint16_t      param_count;
-  uint16_t      param_offset;
-  uint16_t      data_count;
-  uint16_t      data_offset;
-  uint8_t       setup_count;
-  uint8_t       reserved3;
-  uint16_t      cmd;
-  uint16_t      bct;
-  uint8_t       padding[3];
-  uint8_t       payload[];
+    uint8_t       wct;                // 15
+    uint16_t      total_param_count;
+    uint16_t      total_data_count;
+    uint16_t      max_param_count;
+    uint16_t      max_data_count;
+    uint8_t       max_setup_count;
+    uint8_t       reserved;
+    uint16_t      flags;
+    uint32_t      timeout;
+    uint16_t      reserve2;
+    uint16_t      param_count;
+    uint16_t      param_offset;
+    uint16_t      data_count;
+    uint16_t      data_offset;
+    uint8_t       setup_count;
+    uint8_t       reserved3;
+    uint16_t      cmd;
+    uint16_t      bct;
+    uint8_t       padding[3];
+    uint8_t       payload[];
 } __attribute__((packed))   smb_trans2_req;
 
 //// -> Trans2|FindFirst2
 typedef struct
 {
-  uint16_t      attrs;              // Search attributes
-  uint16_t      count;              // Search count
-  uint16_t      flags;
-  uint16_t      interest;           // What kind of info do we want ?
-  uint32_t      storage;            // ? => 0
-  uint8_t       pattern[];          // The queried pattern "\\folder\\*"
+    uint16_t      attrs;              // Search attributes
+    uint16_t      count;              // Search count
+    uint16_t      flags;
+    uint16_t      interest;           // What kind of info do we want ?
+    uint32_t      storage;            // ? => 0
+    uint8_t       pattern[];          // The queried pattern "\\folder\\*"
 } __attribute__((packed))   smb_tr2_find2;
 
 //// -> Trans2|QueryPathInfo
 typedef struct
 {
-  uint16_t      interest;
-  uint32_t      reserved;
-  uint8_t       path[];
+    uint16_t      interest;
+    uint32_t      reserved;
+    uint8_t       path[];
 } __attribute__((packed))   smb_tr2_query;
 
 //<- Trans2
 
 typedef struct
 {
-  uint8_t       wct;                // 10
-  uint16_t      total_param_count;
-  uint16_t      total_data_count;
-  uint16_t      reserved;
-  uint16_t      param_count;
-  uint16_t      param_offset;
-  uint16_t      param_displacement; // ??
-  uint16_t      data_count;
-  uint16_t      data_offset;
-  uint16_t      data_displacement;  // ??
-  uint8_t       setup_count;
-  uint8_t       reserved2;
-  uint16_t      bct;
-  uint8_t       padding;
-  uint8_t       payload[];
+    uint8_t       wct;                // 10
+    uint16_t      total_param_count;
+    uint16_t      total_data_count;
+    uint16_t      reserved;
+    uint16_t      param_count;
+    uint16_t      param_offset;
+    uint16_t      param_displacement; // ??
+    uint16_t      data_count;
+    uint16_t      data_offset;
+    uint16_t      data_displacement;  // ??
+    uint8_t       setup_count;
+    uint8_t       reserved2;
+    uint16_t      bct;
+    uint8_t       padding;
+    uint8_t       payload[];
 } __attribute__((packed))   smb_trans2_resp;
 
 //// <- Trans2|FindFirst2Params
 typedef struct
 {
-  uint16_t      id;
-  uint16_t      count;
-  uint16_t      eos;
-  uint16_t      ea_error_offset;
-  uint16_t      last_name_offset;
-  uint16_t      padding;
+    uint16_t      id;
+    uint16_t      count;
+    uint16_t      eos;
+    uint16_t      ea_error_offset;
+    uint16_t      last_name_offset;
+    uint16_t      padding;
 } __attribute__((packed))   smb_tr2_find2_params;
 
 //// <- Trans2|FindFirst2FileInfo
 typedef struct
 {
-  uint32_t      next_entry;
-  uint32_t      index;
-  uint64_t      created;            // File creation time
-  uint64_t      accessed;           // File last access time
-  uint64_t      written;            // File last write time
-  uint64_t      changed;            // File last modification time
-  uint64_t      size;
-  uint64_t      alloc_size;
-  uint32_t      attr;
-  uint32_t      name_len;
-  uint32_t      ea_list_len;
-  uint8_t       short_name_len;
-  uint8_t       reserved;
-  uint8_t       short_name[24];
-  uint8_t       name[];
+    uint32_t      next_entry;
+    uint32_t      index;
+    uint64_t      created;            // File creation time
+    uint64_t      accessed;           // File last access time
+    uint64_t      written;            // File last write time
+    uint64_t      changed;            // File last modification time
+    uint64_t      size;
+    uint64_t      alloc_size;
+    uint32_t      attr;
+    uint32_t      name_len;
+    uint32_t      ea_list_len;
+    uint8_t       short_name_len;
+    uint8_t       reserved;
+    uint8_t       short_name[24];
+    uint8_t       name[];
 } __attribute__((packed))   smb_tr2_find2_entry;
 
 
 //// <- Trans2|QueryPathInfo
 typedef struct
 {
-  uint64_t      created;
-  uint64_t      accessed;
-  uint64_t      written;
-  uint64_t      changed;
-  uint32_t      attr;
-  uint32_t      reserved;
-  uint64_t      alloc_size;
-  uint64_t      size;
-  uint32_t      link_count;
-  uint8_t       rm_pending;
-  uint8_t       is_dir;
-  uint16_t      reserved2;
-  uint32_t      ea_list_len;
-  uint32_t      name_len;
-  uint8_t       name[];
+    uint64_t      created;
+    uint64_t      accessed;
+    uint64_t      written;
+    uint64_t      changed;
+    uint32_t      attr;
+    uint32_t      reserved;
+    uint64_t      alloc_size;
+    uint64_t      size;
+    uint32_t      link_count;
+    uint8_t       rm_pending;
+    uint8_t       is_dir;
+    uint16_t      reserved2;
+    uint32_t      ea_list_len;
+    uint32_t      name_len;
+    uint8_t       name[];
 } __attribute__((packed))   smb_tr2_path_info;
 
 
 //-> Example
 typedef struct
 {
-  uint8_t         wct;                // ??
-  SMB_ANDX_MEMBERS
-  // Fill me
-  uint16_t        bct;
-  //uint8_t         padding;
-  uint8_t         file[];
+    uint8_t         wct;                // ??
+    SMB_ANDX_MEMBERS
+    // Fill me
+    uint16_t        bct;
+    //uint8_t         padding;
+    uint8_t         file[];
 } __attribute__((packed))   smb_example_t;
 
 

include/bdsm/smb_spnego.h

@@ -23,7 +23,7 @@
 #include "bdsm/smb_types.h"
 
 int             smb_session_login_spnego(smb_session *s, const char *domain,
-                                         const char *user, const char *password);
+        const char *user, const char *password);
 
 
 #endif

include/bdsm/smb_types.h

@@ -59,60 +59,63 @@ typedef uint32_t    smb_fd;
  */
 typedef struct  smb_file_s
 {
-  struct smb_file_s   *next;          // Next file in this share
-  char                *name;
-  smb_fid             fid;
-  smb_tid             tid;
-  size_t              name_len;
-  uint64_t            created;
-  uint64_t            accessed;
-  uint64_t            written;
-  uint64_t            changed;
-  uint64_t            alloc_size;
-  uint64_t            size;
-  uint32_t            attr;
-  uint32_t            readp;          // Current read pointer (position);
-  int                 is_dir;         // 0 -> file, 1 -> directory
+    struct smb_file_s   *next;          // Next file in this share
+    char                *name;
+    smb_fid             fid;
+    smb_tid             tid;
+    size_t              name_len;
+    uint64_t            created;
+    uint64_t            accessed;
+    uint64_t            written;
+    uint64_t            changed;
+    uint64_t            alloc_size;
+    uint64_t            size;
+    uint32_t            attr;
+    uint32_t            readp;          // Current read pointer (position);
+    int                 is_dir;         // 0 -> file, 1 -> directory
 } smb_file;
 
 typedef struct smb_share_s
 {
-  struct smb_share_s  *next;          // Next share in this session
-  struct smb_file_s   *files;         // List of all open files for this share
-  smb_tid             tid;
-  uint16_t            opts;           // Optionnal support opts
-  uint16_t            rights;         // Maximum rights field
-  uint16_t            guest_rights;
+    struct smb_share_s  *next;          // Next share in this session
+    struct smb_file_s   *files;         // List of all open files for this share
+    smb_tid             tid;
+    uint16_t            opts;           // Optionnal support opts
+    uint16_t            rights;         // Maximum rights field
+    uint16_t            guest_rights;
 } smb_share;
 
-typedef struct smb_transport_s {
-  void              *session;
-  void              *(*new)(size_t buf_size);
-  int               (*connect)(struct in_addr *addr, void *s, const char *name);
-  void              (*destroy)(void *s);
-  void              (*pkt_init)(void *s);
-  int               (*pkt_append)(void *s, void *data, size_t size);
-  int               (*send)(void *s);
-  ssize_t           (*recv)(void *s, void **data);
+typedef struct smb_transport_s
+{
+    void              *session;
+    void              *(*new)(size_t buf_size);
+    int (*connect)(struct in_addr *addr, void *s, const char *name);
+    void (*destroy)(void *s);
+    void (*pkt_init)(void *s);
+    int (*pkt_append)(void *s, void *data, size_t size);
+    int (*send)(void *s);
+    ssize_t (*recv)(void *s, void **data);
 }                   smb_transport;
 
 // An structure to store user credentials;
 // login:password@domain (also DOMAIN\login)
-typedef struct {
-    char *    domain;
-    char *    login;
-    char *    password;
+typedef struct
+{
+    char     *domain;
+    char     *login;
+    char     *password;
 }           smb_creds;
 
-typedef struct {
-  char                name[16];       // The server name
-  uint16_t            dialect;        // The selected dialect
-  uint16_t            security_mode;  // Security mode
-  uint16_t            uid;            // uid attributed by the server.
-  uint32_t            session_key;    // The session key sent by the server on protocol negotiate
-  uint32_t            caps;           // Server caps replyed during negotiate
-  uint64_t            challenge;      // For challenge response security
-  uint64_t            ts;             // It seems Win7 requires it :-/
+typedef struct
+{
+    char                name[16];       // The server name
+    uint16_t            dialect;        // The selected dialect
+    uint16_t            security_mode;  // Security mode
+    uint16_t            uid;            // uid attributed by the server.
+    uint32_t            session_key;    // The session key sent by the server on protocol negotiate
+    uint32_t            caps;           // Server caps replyed during negotiate
+    uint64_t            challenge;      // For challenge response security
+    uint64_t            ts;             // It seems Win7 requires it :-/
 }                   smb_srv_info;
 
 /**
@@ -120,20 +123,20 @@ typedef struct {
  */
 typedef struct
 {
-  int                 state;
-  bool                guest;            // Are we logged as guest ?
+    int                 state;
+    bool                guest;            // Are we logged as guest ?
 
-  // Informations about the smb server we are connected to.
-  smb_srv_info        srv;
+    // Informations about the smb server we are connected to.
+    smb_srv_info        srv;
 
 
-  ASN1_TYPE           spnego_asn1;
-  smb_buffer          xsec_target;
+    ASN1_TYPE           spnego_asn1;
+    smb_buffer          xsec_target;
 
-  smb_creds           creds;
-  smb_transport       transport;
+    smb_creds           creds;
+    smb_transport       transport;
 
-  struct smb_share_s  *shares;          // shares->files | Map fd <-> smb_file
+    struct smb_share_s  *shares;          // shares->files | Map fd <-> smb_file
 }                   smb_session;
 
 /**
@@ -161,9 +164,9 @@ typedef smb_file *smb_stat;
  */
 typedef struct
 {
-  size_t          payload_size; // Size of the allocated payload
-  size_t          cursor;       // Write cursor in the payload
-  smb_packet      *packet;      // Yummy yummy, Fruity fruity !
+    size_t          payload_size; // Size of the allocated payload
+    size_t          cursor;       // Write cursor in the payload
+    smb_packet      *packet;      // Yummy yummy, Fruity fruity !
 }                               smb_message;
 
 

src/hmac_md5.c

@@ -25,54 +25,54 @@
 unsigned char *HMAC_MD5(const void *key, size_t key_len, const void *msg,
                         size_t msg_len, void *hmac)
 {
-  static uint8_t  hmac_static[16];
+    static uint8_t  hmac_static[16];
 
-  uint8_t         key_pad[64], o_key_pad[64], i_key_pad[64], kcat[80];
-  void            *cat, *out;
-  MD5_CTX         ctx;
+    uint8_t         key_pad[64], o_key_pad[64], i_key_pad[64], kcat[80];
+    void            *cat, *out;
+    MD5_CTX         ctx;
 
-  assert(key != NULL && msg != NULL);
+    assert(key != NULL && msg != NULL);
 
-  // This is Microsoft variation of HMAC_MD5 for NTLMv2
-  // It seems they truncate over-sized keys instead of rehashing
-  if (key_len > 64)
-    key_len = 64;
-  else
-  {
-    memcpy(key_pad, key, key_len);
-    memset(key_pad + key_len, 0, 64 - key_len);
-  }
+    // This is Microsoft variation of HMAC_MD5 for NTLMv2
+    // It seems they truncate over-sized keys instead of rehashing
+    if (key_len > 64)
+        key_len = 64;
+    else
+    {
+        memcpy(key_pad, key, key_len);
+        memset(key_pad + key_len, 0, 64 - key_len);
+    }
 
-  // Compute the o/i XORed padded keys
-  for (unsigned i = 0; i < 64; i++)
-  {
-   o_key_pad[i] = 0x5c ^ key_pad[i];
-   i_key_pad[i] = 0x36 ^ key_pad[i];
-  }
+    // Compute the o/i XORed padded keys
+    for (unsigned i = 0; i < 64; i++)
+    {
+        o_key_pad[i] = 0x5c ^ key_pad[i];
+        i_key_pad[i] = 0x36 ^ key_pad[i];
+    }
 
-  // Concatenate inner padded key with message
-  cat = malloc(msg_len + 64);
-  assert (cat != NULL);
-  memcpy(cat, i_key_pad, 64);
-  memcpy(cat + 64, msg, msg_len);
+    // Concatenate inner padded key with message
+    cat = malloc(msg_len + 64);
+    assert(cat != NULL);
+    memcpy(cat, i_key_pad, 64);
+    memcpy(cat + 64, msg, msg_len);
 
-  // MD5 of the result
-  MD5_Init(&ctx);
-  MD5_Update(&ctx, cat, msg_len + 64);
-  MD5_Final(key_pad, &ctx);
-  free(cat);
+    // MD5 of the result
+    MD5_Init(&ctx);
+    MD5_Update(&ctx, cat, msg_len + 64);
+    MD5_Final(key_pad, &ctx);
+    free(cat);
 
-  memcpy(kcat, o_key_pad, 64);
-  memcpy(kcat + 64, key_pad, 16);
+    memcpy(kcat, o_key_pad, 64);
+    memcpy(kcat + 64, key_pad, 16);
 
-  if (hmac != NULL)
-    out = hmac;
-  else
-    out = hmac_static;
+    if (hmac != NULL)
+        out = hmac;
+    else
+        out = hmac_static;
 
-  MD5_Init(&ctx);
-  MD5_Update(&ctx, kcat, 80);
-  MD5_Final(out, &ctx);
+    MD5_Init(&ctx);
+    MD5_Update(&ctx, kcat, 80);
+    MD5_Final(out, &ctx);
 
-  return (out);
+    return (out);
 }

src/netbios_ns.c

@@ -37,188 +37,189 @@
 
 static int    ns_open_socket(netbios_ns *ns)
 {
-  int sock_opt;
+    int sock_opt;
 
-  if ((ns->socket = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
-    goto error;
+    if ((ns->socket = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
+        goto error;
 
-  sock_opt = 1;
-  if (setsockopt(ns->socket, SOL_SOCKET, SO_BROADCAST,
-      (void *)&sock_opt, sizeof(sock_opt)) < 0)
-    goto error;
+    sock_opt = 1;
+    if (setsockopt(ns->socket, SOL_SOCKET, SO_BROADCAST,
+                   (void *)&sock_opt, sizeof(sock_opt)) < 0)
+        goto error;
 
-  sock_opt = 0;
-  if (setsockopt(ns->socket, IPPROTO_IP, IP_MULTICAST_LOOP,
-      (void *)&sock_opt, sizeof(sock_opt)) < 0)
-    goto error;
+    sock_opt = 0;
+    if (setsockopt(ns->socket, IPPROTO_IP, IP_MULTICAST_LOOP,
+                   (void *)&sock_opt, sizeof(sock_opt)) < 0)
+        goto error;
 
-  ns->addr.sin_family       = AF_INET;
-  ns->addr.sin_port         = htons(0);
-  ns->addr.sin_addr.s_addr  = 0;
-  if (bind(ns->socket, (struct sockaddr *)&ns->addr, sizeof(ns->addr)) < 0)
-    goto error;
+    ns->addr.sin_family       = AF_INET;
+    ns->addr.sin_port         = htons(0);
+    ns->addr.sin_addr.s_addr  = 0;
+    if (bind(ns->socket, (struct sockaddr *)&ns->addr, sizeof(ns->addr)) < 0)
+        goto error;
 
-  return (1);
+    return (1);
 
-  error:
+error:
     perror("netbios_ns_new, open_socket: ");
     return (0);
 }
 
 netbios_ns  *netbios_ns_new()
 {
-  netbios_ns  *ns;
+    netbios_ns  *ns;
 
-  assert(ns = malloc(sizeof(netbios_ns)));
-  memset((void *)ns, 0, sizeof(netbios_ns));
+    assert(ns = malloc(sizeof(netbios_ns)));
+    memset((void *)ns, 0, sizeof(netbios_ns));
 
-  if (!ns_open_socket(ns))
-  {
-    netbios_ns_destroy(ns);
-    return (0);
-  }
+    if (!ns_open_socket(ns))
+    {
+        netbios_ns_destroy(ns);
+        return (0);
+    }
 
-  ns->entries       = NULL;
-  ns->last_trn_id   = rand();
+    ns->entries       = NULL;
+    ns->last_trn_id   = rand();
 
-  return (ns);
+    return (ns);
 }
 
 void          netbios_ns_destroy(netbios_ns *ns)
 {
-  if (!ns)
-    return;
+    if (!ns)
+        return;
 
-  netbios_ns_clear(ns);
+    netbios_ns_clear(ns);
 
-  close(ns->socket);
-  free(ns);
+    close(ns->socket);
+    free(ns);
 }
 
 int               netbios_ns_send_query(netbios_ns *ns, netbios_query *q,
                                         uint32_t ip)
 {
-  struct sockaddr_in  addr;
-  ssize_t             sent;
-  uint16_t            trn_id;
+    struct sockaddr_in  addr;
+    ssize_t             sent;
+    uint16_t            trn_id;
 
-  assert(ns != NULL && q != NULL);
+    assert(ns != NULL && q != NULL);
 
-  trn_id = ns->last_trn_id + 1; // Increment transaction ID, not to reuse them
-  q->packet->trn_id = htons(trn_id);
+    trn_id = ns->last_trn_id + 1; // Increment transaction ID, not to reuse them
+    q->packet->trn_id = htons(trn_id);
 
-  addr.sin_addr.s_addr  = ip;
-  addr.sin_family       = AF_INET;
-  addr.sin_port         = htons(NETBIOS_PORT_NAME);
+    addr.sin_addr.s_addr  = ip;
+    addr.sin_family       = AF_INET;
+    addr.sin_port         = htons(NETBIOS_PORT_NAME);
 
-  sent = sendto(ns->socket, (void *)q->packet,
-                sizeof(netbios_query_packet) + q->cursor, 0,
-                (struct sockaddr *)&addr, sizeof(struct sockaddr_in));
-  netbios_query_destroy(q);
+    sent = sendto(ns->socket, (void *)q->packet,
+                  sizeof(netbios_query_packet) + q->cursor, 0,
+                  (struct sockaddr *)&addr, sizeof(struct sockaddr_in));
+    netbios_query_destroy(q);
 
-  if (sent < 0){
-    perror("netbios_ns_send_query: ");
-    return (0);
-  }
+    if (sent < 0)
+    {
+        perror("netbios_ns_send_query: ");
+        return (0);
+    }
 
-  ns->last_trn_id = trn_id; // Remember the last transaction id.
-  return (1);
+    ns->last_trn_id = trn_id; // Remember the last transaction id.
+    return (1);
 }
 
 ssize_t           netbios_ns_recv(int sock, void *buf, size_t buf_size,
                                   struct timeval *timeout, struct sockaddr *addr,
                                   socklen_t *addr_len)
 {
-  fd_set        read_fds, error_fds;
-  int           res;
+    fd_set        read_fds, error_fds;
+    int           res;
 
-  assert(sock && buf != NULL && buf_size > 0);
+    assert(sock && buf != NULL && buf_size > 0);
 
-  FD_ZERO(&read_fds);
-  FD_ZERO(&error_fds);
-  FD_SET(sock, &read_fds);
-  FD_SET(sock, &error_fds);
+    FD_ZERO(&read_fds);
+    FD_ZERO(&error_fds);
+    FD_SET(sock, &read_fds);
+    FD_SET(sock, &error_fds);
 
-  res = select(sock + 1, &read_fds, 0, &error_fds, timeout);
+    res = select(sock + 1, &read_fds, 0, &error_fds, timeout);
 
-  if (res < 0)
-    goto error;
-  if (FD_ISSET(sock, &error_fds))
-    goto error;
+    if (res < 0)
+        goto error;
+    if (FD_ISSET(sock, &error_fds))
+        goto error;
 
-  if (FD_ISSET(sock, &read_fds))
-  {
-    return (recvfrom(sock, buf, buf_size, 0, addr, addr_len));
-  }
-  else
-    return (0);
+    if (FD_ISSET(sock, &read_fds))
+    {
+        return (recvfrom(sock, buf, buf_size, 0, addr, addr_len));
+    }
+    else
+        return (0);
 
-  error:
+error:
     perror("netbios_ns_recv: ");
     return (-1);
 }
 
-int      netbios_ns_resolve(netbios_ns *ns, const char *name, char type, uint32_t * addr)
+int      netbios_ns_resolve(netbios_ns *ns, const char *name, char type, uint32_t *addr)
 {
-  netbios_ns_entry  *cached;
-  struct timeval      timeout;
-  netbios_query     *q;
-  char                *encoded_name;
-  char                footer[4] = { 0x00, 0x20, 0x00, 0x01 };
-  char                recv_buffer[512]; // Hu ?
-  ssize_t             recv;
-  uint32_t            ip;
+    netbios_ns_entry  *cached;
+    struct timeval      timeout;
+    netbios_query     *q;
+    char                *encoded_name;
+    char                footer[4] = { 0x00, 0x20, 0x00, 0x01 };
+    char                recv_buffer[512]; // Hu ?
+    ssize_t             recv;
+    uint32_t            ip;
 
 
-  assert(ns != NULL);
+    assert(ns != NULL);
 
 
-  if ((cached = netbios_ns_entry_find(ns, name, 0)) != NULL)
-    return (cached->address.s_addr);
+    if ((cached = netbios_ns_entry_find(ns, name, 0)) != NULL)
+        return (cached->address.s_addr);
 
-  if ((encoded_name = netbios_name_encode(name, 0, type)) == NULL)
-    return (-1);
+    if ((encoded_name = netbios_name_encode(name, 0, type)) == NULL)
+        return (-1);
 
     // Prepare packet
-  q = netbios_query_new(34 + 4, 1, NETBIOS_OP_NAME_QUERY);
-  netbios_query_set_flag(q, NETBIOS_FLAG_RECURSIVE, 1);
-  netbios_query_set_flag(q, NETBIOS_FLAG_BROADCAST, 1);
+    q = netbios_query_new(34 + 4, 1, NETBIOS_OP_NAME_QUERY);
+    netbios_query_set_flag(q, NETBIOS_FLAG_RECURSIVE, 1);
+    netbios_query_set_flag(q, NETBIOS_FLAG_BROADCAST, 1);
+
+    // Append the queried name to the packet
+    netbios_query_append(q, encoded_name, strlen(encoded_name) + 1);
+
+    // Magic footer (i.e. Question type (Netbios) / class (IP)
+    netbios_query_append(q, footer, 4);
+    q->packet->queries = htons(1);
+
+    // We broadcast this query
+    inet_aton("255.255.255.255", (struct in_addr *)&ip);
+
+    // Let's send it
+    if (!netbios_ns_send_query(ns, q, ip))
+        return (0);
+    else
+        BDSM_dbg("netbios_ns_resolve, name query sent for '%s' !\n", name);
+
+    free(encoded_name);
+
+    // Now wait for a reply and pray
+    timeout.tv_sec = 2;
+    timeout.tv_usec = 420;
+    recv = netbios_ns_recv(ns->socket, (void *)recv_buffer, 512, &timeout, 0, 0);
+
+    if (recv <= 0)
+        perror("netbios_ns_resolve:");
+    else if (recv == 0)
+        BDSM_dbg("netbios_ns_resolve, received NO reply for '%s' !\n", name);
+    else
+    {
+        BDSM_dbg("netbios_ns_resolve, received a reply for '%s' !\n", name);
+        *addr = (*(uint32_t *)(recv_buffer + recv - 4));
+        return (1);
+    }
 
-  // Append the queried name to the packet
-  netbios_query_append(q, encoded_name, strlen(encoded_name) + 1);
-
-  // Magic footer (i.e. Question type (Netbios) / class (IP)
-  netbios_query_append(q, footer, 4);
-  q->packet->queries = htons(1);
-
-  // We broadcast this query
-  inet_aton("255.255.255.255", (struct in_addr *)&ip);
-
-  // Let's send it
-  if (!netbios_ns_send_query(ns, q, ip))
     return (0);
-  else
-    BDSM_dbg("netbios_ns_resolve, name query sent for '%s' !\n", name);
-
-  free(encoded_name);
-
-  // Now wait for a reply and pray
-  timeout.tv_sec = 2;
-  timeout.tv_usec = 420;
-  recv = netbios_ns_recv(ns->socket, (void *)recv_buffer, 512, &timeout, 0, 0);
-
-  if (recv <= 0)
-    perror("netbios_ns_resolve:");
-  else if (recv == 0)
-    BDSM_dbg("netbios_ns_resolve, received NO reply for '%s' !\n", name);
-  else
-  {
-    BDSM_dbg("netbios_ns_resolve, received a reply for '%s' !\n", name);
-    *addr = (*(uint32_t *)(recv_buffer + recv - 4));
-    return (1);
-  }
-
-  return (0);
 }
 
 // We have a small recursive function for discovery, to stack received reply
@@ -226,147 +227,147 @@ int      netbios_ns_resolve(netbios_ns *ns, const char *name, char type, uint32_
 static void   netbios_ns_discover_rec(netbios_ns *ns, struct timeval *timeout,
                                       void *recv_buffer)
 {
-  struct sockaddr_in  recv_addr;
-  socklen_t           recv_addr_len;
-  int                 res;
-
-  recv_addr_len = sizeof(recv_addr);
-  res = netbios_ns_recv(ns->socket, recv_buffer, 256, timeout,
-                        (struct sockaddr *)&recv_addr, &recv_addr_len);
-  if (res > 0 && timeout->tv_sec && timeout->tv_usec)
-  {
-    netbios_ns_discover_rec(ns, timeout, recv_buffer);
-
-    BDSM_dbg("Discover: received a reply from %s\n",
-      inet_ntoa(recv_addr.sin_addr));
-    netbios_ns_inverse(ns, recv_addr.sin_addr.s_addr);
-  }
+    struct sockaddr_in  recv_addr;
+    socklen_t           recv_addr_len;
+    int                 res;
+
+    recv_addr_len = sizeof(recv_addr);
+    res = netbios_ns_recv(ns->socket, recv_buffer, 256, timeout,
+                          (struct sockaddr *)&recv_addr, &recv_addr_len);
+    if (res > 0 && timeout->tv_sec && timeout->tv_usec)
+    {
+        netbios_ns_discover_rec(ns, timeout, recv_buffer);
+
+        BDSM_dbg("Discover: received a reply from %s\n",
+                 inet_ntoa(recv_addr.sin_addr));
+        netbios_ns_inverse(ns, recv_addr.sin_addr.s_addr);
+    }
 }
 
 int           netbios_ns_discover(netbios_ns *ns)
 {
-  const char  broadcast_name[] = NETBIOS_WILDCARD;
-  char        footer[4]        = { 0x00, 0x20, 0x00, 0x01 };
-
-  struct timeval      timeout;
-  netbios_query     *q;
-  char                recv_buffer[256]; // Hu ?
-  uint32_t            ip;
-
-  assert (ns != NULL);
-
-  //
-  // First step, we broadcast a packet to receive a message from every
-  // NETBIOS nodes on the local network
-  //
-  q = netbios_query_new(34 + 4, 1, NETBIOS_OP_NAME_QUERY);
-  // Append the queried name to the packet
-  netbios_query_append(q, broadcast_name, strlen(broadcast_name) + 1);
-  // Magic footer (i.e. Question type (Netbios) / class (IP)
-  netbios_query_append(q, footer, 4);
-  q->packet->queries = htons(1);
-
-  // We broadcast this query
-  inet_aton("255.255.255.255", (struct in_addr *)&ip);
-
-  // Let's send it
-  if (!netbios_ns_send_query(ns, q, ip))
-  {
-    BDSM_dbg("Unable to send netbios 'discovery query'.\n");
-    return (0);
-  }
-  else
-    BDSM_dbg("netbios_ns_discover, name query sent for '*'.\n");
+    const char  broadcast_name[] = NETBIOS_WILDCARD;
+    char        footer[4]        = { 0x00, 0x20, 0x00, 0x01 };
+
+    struct timeval      timeout;
+    netbios_query     *q;
+    char                recv_buffer[256]; // Hu ?
+    uint32_t            ip;
+
+    assert(ns != NULL);
+
+    //
+    // First step, we broadcast a packet to receive a message from every
+    // NETBIOS nodes on the local network
+    //
+    q = netbios_query_new(34 + 4, 1, NETBIOS_OP_NAME_QUERY);
+    // Append the queried name to the packet
+    netbios_query_append(q, broadcast_name, strlen(broadcast_name) + 1);
+    // Magic footer (i.e. Question type (Netbios) / class (IP)
+    netbios_query_append(q, footer, 4);
+    q->packet->queries = htons(1);
+
+    // We broadcast this query
+    inet_aton("255.255.255.255", (struct in_addr *)&ip);
+
+    // Let's send it
+    if (!netbios_ns_send_query(ns, q, ip))
+    {
+        BDSM_dbg("Unable to send netbios 'discovery query'.\n");
+        return (0);
+    }
+    else
+        BDSM_dbg("netbios_ns_discover, name query sent for '*'.\n");
+
+
+
+    //
+    // Second step, we list every IP that answered to our broadcast.
+    //
+    timeout.tv_sec = 2;
+    timeout.tv_usec = 420;
+    netbios_ns_discover_rec(ns, &timeout, (void *)recv_buffer);
 
-
-
-  //
-  // Second step, we list every IP that answered to our broadcast.
-  //
-  timeout.tv_sec = 2;
-  timeout.tv_usec = 420;
-  netbios_ns_discover_rec(ns, &timeout, (void *)recv_buffer);
-
-  return (1);
+    return (1);
 }
 
 // Perform inverse name resolution. Grap an IP and return the first <20> field
 // returned by the host
 const char        *netbios_ns_inverse(netbios_ns *ns, uint32_t ip)
 {
-  const char  broadcast_name[] = NETBIOS_WILDCARD;
-  char        footer[4]        = { 0x00, 0x21, 0x00, 0x01 }; // NBSTAT/IP
-
-  netbios_ns_entry  *cached;
-  struct timeval      timeout;
-  netbios_query     *q;
-  char                recv_buffer[512]; // Hu ?
-  ssize_t             recv;
-
-  assert(ns != NULL && ip != 0);
-
-  if ((cached = netbios_ns_entry_find(ns, NULL, ip)) != NULL)
-    return (cached->name);
-
-  // Prepare NBSTAT query packet
-  q = netbios_query_new(34 + 4, 1, NETBIOS_OP_NAME_QUERY);
-  netbios_query_append(q, broadcast_name, strlen(broadcast_name) + 1);
-  netbios_query_append(q, footer, 4);
-  q->packet->queries = htons(1);
-
-  // Let's send it
-  if (!netbios_ns_send_query(ns, q, ip))
-    return (NULL);
-  else
-    BDSM_dbg("netbios_ns_inverse, reverse name query sent for '%s' !\n",
-            inet_ntoa(*(struct in_addr *)&ip));
-
-  // Now wait for a reply and pray
-  timeout.tv_sec = 1;
-  timeout.tv_usec = 500;
-  recv = netbios_ns_recv(ns->socket, (void *)recv_buffer, 512, &timeout, 0, 0);
-
-  if (recv <= 0)
-    goto error;
-  else
-    BDSM_dbg("netbios_ns_inverse, received a reply for '%s' !\n",
-            inet_ntoa(*(struct in_addr*)&ip));
-
-
-  // Now we've got something, let's find the <20>/<0> name
-  netbios_query_packet  *p = (netbios_query_packet *)recv_buffer;
-  uint8_t                 name_count;
-  uint8_t                 name_idx;
-  char                    *names;
-  char                    *current_name;
-  char                    current_type;
-  netbios_ns_entry      *entry = NULL, *res = NULL;
-
-  BDSM_dbg("Queried name length: %u\n", p->payload[0]);
-  name_count = p->payload[p->payload[0] + 12];
-  BDSM_dbg("Number of names: %hhu\n", name_count);
-  names = p->payload + p->payload[0] + 13;
-
-  for(name_idx = 0; name_idx < name_count; name_idx++)
-  {
-    current_name = names + name_idx * 18;
-    current_type = current_name[15];
-
-    BDSM_dbg("Found name : %s (type == 0x%x)\n", current_name, current_type);
-    if (current_type == 0x20 || current_type == 0)
-      entry = netbios_ns_entry_add(ns, current_name, current_type, ip);
-    if (current_type == 0x20)
-      res = entry;
-  }
-
-  if (res)        // We prefer a <20> name.
-    return(res->name);
-  else if (entry) // Did we found a <0> or <20> name ?
-    return(entry->name);
-  else
-    return (NULL);
-
-  error:
+    const char  broadcast_name[] = NETBIOS_WILDCARD;
+    char        footer[4]        = { 0x00, 0x21, 0x00, 0x01 }; // NBSTAT/IP
+
+    netbios_ns_entry  *cached;
+    struct timeval      timeout;
+    netbios_query     *q;
+    char                recv_buffer[512]; // Hu ?
+    ssize_t             recv;
+
+    assert(ns != NULL && ip != 0);
+
+    if ((cached = netbios_ns_entry_find(ns, NULL, ip)) != NULL)
+        return (cached->name);
+
+    // Prepare NBSTAT query packet
+    q = netbios_query_new(34 + 4, 1, NETBIOS_OP_NAME_QUERY);
+    netbios_query_append(q, broadcast_name, strlen(broadcast_name) + 1);
+    netbios_query_append(q, footer, 4);
+    q->packet->queries = htons(1);
+
+    // Let's send it
+    if (!netbios_ns_send_query(ns, q, ip))
+        return (NULL);
+    else
+        BDSM_dbg("netbios_ns_inverse, reverse name query sent for '%s' !\n",
+                 inet_ntoa(*(struct in_addr *)&ip));
+
+    // Now wait for a reply and pray
+    timeout.tv_sec = 1;
+    timeout.tv_usec = 500;
+    recv = netbios_ns_recv(ns->socket, (void *)recv_buffer, 512, &timeout, 0, 0);
+
+    if (recv <= 0)
+        goto error;
+    else
+        BDSM_dbg("netbios_ns_inverse, received a reply for '%s' !\n",
+                 inet_ntoa(*(struct in_addr *)&ip));
+
+
+    // Now we've got something, let's find the <20>/<0> name
+    netbios_query_packet  *p = (netbios_query_packet *)recv_buffer;
+    uint8_t                 name_count;
+    uint8_t                 name_idx;
+    char                    *names;
+    char                    *current_name;
+    char                    current_type;
+    netbios_ns_entry      *entry = NULL, *res = NULL;
+
+    BDSM_dbg("Queried name length: %u\n", p->payload[0]);
+    name_count = p->payload[p->payload[0] + 12];
+    BDSM_dbg("Number of names: %hhu\n", name_count);
+    names = p->payload + p->payload[0] + 13;
+
+    for (name_idx = 0; name_idx < name_count; name_idx++)
+    {
+        current_name = names + name_idx * 18;
+        current_type = current_name[15];
+
+        BDSM_dbg("Found name : %s (type == 0x%x)\n", current_name, current_type);
+        if (current_type == 0x20 || current_type == 0)
+            entry = netbios_ns_entry_add(ns, current_name, current_type, ip);
+        if (current_type == 0x20)
+            res = entry;
+    }
+
+    if (res)        // We prefer a <20> name.
+        return (res->name);
+    else if (entry) // Did we found a <0> or <20> name ?
+        return (entry->name);
+    else
+        return (NULL);
+
+error:
     perror("netbios_ns_inverse: ");
     return (NULL);
 }

src/netbios_ns_entry.c

@@ -25,123 +25,123 @@
 
 const char          *netbios_ns_entry_name(netbios_ns_entry *entry)
 {
-  if (entry != NULL)
-    return (entry->name);
-  else
-    return (NULL);
+    if (entry != NULL)
+        return (entry->name);
+    else
+        return (NULL);
 }
 
 uint32_t            netbios_ns_entry_ip(netbios_ns_entry *entry)
 {
-  if (entry != NULL)
-    return (entry->address.s_addr);
-  else
-    return (0);
+    if (entry != NULL)
+        return (entry->address.s_addr);
+    else
+        return (0);
 }
 
 char                netbios_ns_entry_type(netbios_ns_entry *entry)
 {
-  if (entry != NULL)
-    return (entry->type);
-  else
-    return (-1);
+    if (entry != NULL)
+        return (entry->type);
+    else
+        return (-1);
 }
 
 void                netbios_ns_clear(netbios_ns *ns)
 {
-  netbios_ns_entry  *next;
+    netbios_ns_entry  *next;
 
-  assert(ns != NULL);
+    assert(ns != NULL);
 
-  while (ns->entries != NULL)
-  {
-    next = ns->entries->next;
-    free(ns->entries->next);
-    ns->entries = next;
-  }
+    while (ns->entries != NULL)
+    {
+        next = ns->entries->next;
+        free(ns->entries->next);
+        ns->entries = next;
+    }
 }
 
 netbios_ns_entry *netbios_ns_entry_add(netbios_ns *ns, const char *name,
-                                         char type, uint32_t ip)
+                                       char type, uint32_t ip)
 {
-  netbios_ns_entry  *entry;
+    netbios_ns_entry  *entry;
 
-  entry = malloc(sizeof(netbios_ns_entry));
-  assert(entry != NULL);
-  memset((void *)entry, 0, sizeof(netbios_ns_entry));
+    entry = malloc(sizeof(netbios_ns_entry));
+    assert(entry != NULL);
+    memset((void *)entry, 0, sizeof(netbios_ns_entry));
 
-  if (name != NULL)
-  {
-    memcpy(entry->name, name, NETBIOS_NAME_LENGTH);
-    entry->name[NETBIOS_NAME_LENGTH] = 0;
-  }
+    if (name != NULL)
+    {
+        memcpy(entry->name, name, NETBIOS_NAME_LENGTH);
+        entry->name[NETBIOS_NAME_LENGTH] = 0;
+    }
 
-  entry->type           = type;
-  entry->address.s_addr = ip;
-  entry->next           = ns->entries;
+    entry->type           = type;
+    entry->address.s_addr = ip;
+    entry->next           = ns->entries;
 
-  ns->entries = entry;
+    ns->entries = entry;
 
-  return (ns->entries);
+    return (ns->entries);
 }
 // Find an entry in the list. Search by name if name is not NULL,
 // or by ip otherwise
 netbios_ns_entry *netbios_ns_entry_find(netbios_ns *ns, const char *by_name,
-                                          uint32_t ip)
+                                        uint32_t ip)
 {
-  netbios_ns_entry  *found = NULL;
-  netbios_ns_entry  *iter;
+    netbios_ns_entry  *found = NULL;
+    netbios_ns_entry  *iter;
 
-  assert(ns != NULL);
+    assert(ns != NULL);
 
-  iter = ns->entries;
-  while(iter != NULL && found == NULL)
-  {
-    if (by_name != NULL)
+    iter = ns->entries;
+    while (iter != NULL && found == NULL)
     {
-      if (!strncmp(by_name, iter->name, NETBIOS_NAME_LENGTH))
-        found = iter;
+        if (by_name != NULL)
+        {
+            if (!strncmp(by_name, iter->name, NETBIOS_NAME_LENGTH))
+                found = iter;
+        }
+        else if (iter->address.s_addr == ip)
+            found = iter;
+
+        iter = iter->next;
     }
-    else if (iter->address.s_addr == ip)
-      found = iter;
-
-    iter = iter->next;
-  }
 
-  return (found);
+    return (found);
 }
 
 int             netbios_ns_entry_count(netbios_ns *ns)
 {
-  netbios_ns_entry  *iter;
-  int                 res;
+    netbios_ns_entry  *iter;
+    int                 res;
 
-  assert (ns != NULL);
+    assert(ns != NULL);
 
-  iter  = ns->entries;
-  res   = 0;
-  while (iter != NULL)
-  {
-    res++;
-    iter = iter->next;
-  }
+    iter  = ns->entries;
+    res   = 0;
+    while (iter != NULL)
+    {
+        res++;
+        iter = iter->next;
+    }
 
-  return (res);
+    return (res);
 }
 
 netbios_ns_entry  *netbios_ns_entry_at(netbios_ns *ns, int pos)
 {
-  netbios_ns_entry  *iter = NULL;
-  int                 i = 0;
+    netbios_ns_entry  *iter = NULL;
+    int                 i = 0;
 
-  assert(ns != NULL);
+    assert(ns != NULL);
 
-  iter = ns->entries;
-  while (i < pos && iter != NULL)
-  {
-    i++;
-    iter = iter->next;
-  }
+    iter = ns->entries;
+    while (i < pos && iter != NULL)
+    {
+        i++;
+        iter = iter->next;
+    }
 
-  return (iter);
+    return (iter);
 }

src/netbios_query.c

@@ -25,78 +25,78 @@
 #include "bdsm/netbios_query.h"
 
 netbios_query   *netbios_query_new(size_t payload_size,
-                                     int is_query, char opcode)
+                                   int is_query, char opcode)
 {
-  netbios_query *q;
+    netbios_query *q;
 
-  q = malloc(sizeof(netbios_query));
-  assert(q);
-  memset((void *)q, 0, sizeof(netbios_query));
+    q = malloc(sizeof(netbios_query));
+    assert(q);
+    memset((void *)q, 0, sizeof(netbios_query));
 
-  q->packet = malloc(sizeof(netbios_query_packet) + payload_size);
-  assert(q->packet);
-  memset((void *)q->packet, 0, sizeof(netbios_query_packet) + payload_size);
+    q->packet = malloc(sizeof(netbios_query_packet) + payload_size);
+    assert(q->packet);
+    memset((void *)q->packet, 0, sizeof(netbios_query_packet) + payload_size);
 
-  q->payload_size = payload_size;
+    q->payload_size = payload_size;
 
-  q->packet->flags  = htons(opcode << 11);
-  netbios_query_set_flag(q, NETBIOS_FLAG_QUERY, !is_query);
+    q->packet->flags  = htons(opcode << 11);
+    netbios_query_set_flag(q, NETBIOS_FLAG_QUERY, !is_query);
 
-  return (q);
+    return (q);
 }
 
 void              netbios_query_destroy(netbios_query *q)
 {
-  assert(q);
+    assert(q);
 
-  free(q->packet);
-  free(q);
+    free(q->packet);
+    free(q);
 }
 
 void              netbios_query_set_flag(netbios_query *q,
-                                         uint16_t flag, int value)
+        uint16_t flag, int value)
 {
-  assert(q && q->packet);
+    assert(q && q->packet);
 
-  if (value)
-    q->packet->flags = htons(ntohs(q->packet->flags) | flag);
-  else
-    q->packet->flags = htons(ntohs(q->packet->flags) & ~flag);
+    if (value)
+        q->packet->flags = htons(ntohs(q->packet->flags) | flag);
+    else
+        q->packet->flags = htons(ntohs(q->packet->flags) & ~flag);
 }
 
 void              netbios_query_print(netbios_query *q)
 {
-  assert(q && q->packet);
-
-  printf("--- netbios_query dump :\n");
-  printf("payload = %zu, cursor = %zu.\n", q->payload_size, q->cursor);
-  printf("Transaction id = %u.\n", q->packet->trn_id);
-
-  printf("-------------------------\n");
-  for(unsigned i = 0; i < sizeof(netbios_query_packet) + q->cursor; i++)
-  {
-    char c;
-    if ((i % 8) == 0 && i != 0)
-      printf("\n");
-    if ((i % 8) == 0)
-      printf("0x");
-
-    c = ((char *)q->packet)[i];
-    printf("%.2hhX ", c);
-  }
-  printf("\n");
-  printf("-------------------------\n");
+    assert(q && q->packet);
+
+    printf("--- netbios_query dump :\n");
+    printf("payload = %zu, cursor = %zu.\n", q->payload_size, q->cursor);
+    printf("Transaction id = %u.\n", q->packet->trn_id);
+
+    printf("-------------------------\n");
+    for (unsigned i = 0; i < sizeof(netbios_query_packet) + q->cursor; i++)
+    {
+        char c;
+        if ((i % 8) == 0 && i != 0)
+            printf("\n");
+        if ((i % 8) == 0)
+            printf("0x");
+
+        c = ((char *)q->packet)[i];
+        printf("%.2hhX ", c);
+    }
+    printf("\n");
+    printf("-------------------------\n");
 }
 
 int               netbios_query_append(netbios_query *q, const char *data,
                                        size_t data_size)
 {
-  assert(q && q->packet);
+    assert(q && q->packet);
 
-  if (q->payload_size - q->cursor < data_size)
-    return (-1);
+    if (q->payload_size - q->cursor < data_size)
+        return (-1);
 
-  memcpy(((char *)&q->packet->payload) + q->cursor, data, data_size);
-  q->cursor += data_size;
-  return (0);
+    memcpy(((char *)&q->packet->payload) + q->cursor, data, data_size);
+    q->cursor += data_size;
+    return (0);
 }

src/netbios_session.c

@@ -32,193 +32,193 @@
 
 static int        open_socket_and_connect(netbios_session *s)
 {
-  if ((s->socket = socket(AF_INET, SOCK_STREAM, 0)) < 0)
-    goto error;
-  if (connect(s->socket, (struct sockaddr *)&s->remote_addr, sizeof(s->remote_addr)) <0)
-    goto error;
+    if ((s->socket = socket(AF_INET, SOCK_STREAM, 0)) < 0)
+        goto error;
+    if (connect(s->socket, (struct sockaddr *)&s->remote_addr, sizeof(s->remote_addr)) <0)
+        goto error;
 
-  return (1);
+    return (1);
 
-  error:
+error:
     perror("netbios_session_new, open_socket: ");
     return (0);
 }
 
 netbios_session *netbios_session_new(size_t buf_size)
 {
-  netbios_session   *session;
-  size_t            packet_size;
+    netbios_session   *session;
+    size_t            packet_size;
 
-  session = (netbios_session *)malloc(sizeof(netbios_session));
-  assert(session != NULL);
-  memset((void *) session, 0, sizeof(netbios_session));
+    session = (netbios_session *)malloc(sizeof(netbios_session));
+    assert(session != NULL);
+    memset((void *) session, 0, sizeof(netbios_session));
 
-  session->packet_payload_size = buf_size;
-  packet_size = sizeof(netbios_session_packet) + session->packet_payload_size;
-  session->packet = (netbios_session_packet *)malloc(packet_size);
-  assert(session->packet != NULL);
+    session->packet_payload_size = buf_size;
+    packet_size = sizeof(netbios_session_packet) + session->packet_payload_size;
+    session->packet = (netbios_session_packet *)malloc(packet_size);
+    assert(session->packet != NULL);
 
-  return(session);
+    return (session);
 }
 
 void              netbios_session_destroy(netbios_session *s)
 {
-  if (!s)
-    return;
-  close(s->socket);
+    if (!s)
+        return;
+    close(s->socket);
 
-  free(s->packet);
-  free(s);
+    free(s->packet);
+    free(s);
 }
 
 int               netbios_session_connect(struct in_addr *addr,
-                                          netbios_session *s,
-                                          const char *name,
-                                          int direct_tcp)
+        netbios_session *s,
+        const char *name,
+        int direct_tcp)
 {
-  ssize_t                   recv_size;
-  char                      *encoded_name;
-
-  assert(s != NULL && s->packet != NULL);
-
-  if (direct_tcp)
-    s->remote_addr.sin_port       = htons(NETBIOS_PORT_DIRECT);
-  else
-    s->remote_addr.sin_port       = htons(NETBIOS_PORT_SESSION);
-  s->remote_addr.sin_family       = AF_INET;
-  s->remote_addr.sin_addr.s_addr  = addr->s_addr;
-  if (!open_socket_and_connect(s))
-    goto error;
-
-  if (!direct_tcp)
-  {
-  // Send the Session Request message
-    netbios_session_packet_init(s);
-    s->packet->opcode = NETBIOS_OP_SESSION_REQ;
-    encoded_name = netbios_name_encode(name, 0, NETBIOS_FILESERVER);
-    netbios_session_packet_append(s, encoded_name, strlen(encoded_name) + 1);
-    free(encoded_name);
-    encoded_name = netbios_name_encode("LIBDSM", 0, NETBIOS_WORKSTATION);
-    netbios_session_packet_append(s, encoded_name, strlen(encoded_name) + 1);
-    free(encoded_name);
-
-    s->state = NETBIOS_SESSION_CONNECTING;
-    if (!netbios_session_packet_send(s))
-      goto error;
-
-    // Now receiving the reply from the server.
-    recv_size = netbios_session_packet_recv(s, NULL);
-    if (recv_size < 0)
-      goto error;
-
-    // Reply was negative, we are not connected :(
-    if (s->packet->opcode != NETBIOS_OP_SESSION_REQ_OK)
+    ssize_t                   recv_size;
+    char                      *encoded_name;
+
+    assert(s != NULL && s->packet != NULL);
+
+    if (direct_tcp)
+        s->remote_addr.sin_port       = htons(NETBIOS_PORT_DIRECT);
+    else
+        s->remote_addr.sin_port       = htons(NETBIOS_PORT_SESSION);
+    s->remote_addr.sin_family       = AF_INET;
+    s->remote_addr.sin_addr.s_addr  = addr->s_addr;
+    if (!open_socket_and_connect(s))
+        goto error;
+
+    if (!direct_tcp)
     {
-      s->state = NETBIOS_SESSION_REFUSED;
-      return (0);
+        // Send the Session Request message
+        netbios_session_packet_init(s);
+        s->packet->opcode = NETBIOS_OP_SESSION_REQ;
+        encoded_name = netbios_name_encode(name, 0, NETBIOS_FILESERVER);
+        netbios_session_packet_append(s, encoded_name, strlen(encoded_name) + 1);
+        free(encoded_name);
+        encoded_name = netbios_name_encode("LIBDSM", 0, NETBIOS_WORKSTATION);
+        netbios_session_packet_append(s, encoded_name, strlen(encoded_name) + 1);
+        free(encoded_name);
+
+        s->state = NETBIOS_SESSION_CONNECTING;
+        if (!netbios_session_packet_send(s))
+            goto error;
+
+        // Now receiving the reply from the server.
+        recv_size = netbios_session_packet_recv(s, NULL);
+        if (recv_size < 0)
+            goto error;
+
+        // Reply was negative, we are not connected :(
+        if (s->packet->opcode != NETBIOS_OP_SESSION_REQ_OK)
+        {
+            s->state = NETBIOS_SESSION_REFUSED;
+            return (0);
+        }
     }
-  }
 
-  // Reply was OK or DirectTCP, a session has been established
-  s->state = NETBIOS_SESSION_CONNECTED;
-  return(1);
+    // Reply was OK or DirectTCP, a session has been established
+    s->state = NETBIOS_SESSION_CONNECTED;
+    return (1);
 
-  error:
+error:
     s->state = NETBIOS_SESSION_ERROR;
     return (0);
 }
 
 void              netbios_session_packet_init(netbios_session *s)
 {
-  assert(s != NULL);
+    assert(s != NULL);
 
-  s->packet_cursor  = 0;
-  s->packet->flags  = 0;
-  s->packet->opcode = NETBIOS_OP_SESSION_MSG;
+    s->packet_cursor  = 0;
+    s->packet->flags  = 0;
+    s->packet->opcode = NETBIOS_OP_SESSION_MSG;
 }
 
 int               netbios_session_packet_append(netbios_session *s,
-                                                const char *data, size_t size)
+        const char *data, size_t size)
 {
-  char  *start;
+    char  *start;
 
-  assert(s && s->packet);
+    assert(s && s->packet);
 
-  if (s->packet_payload_size - s->packet_cursor < size)
-    return (0);
+    if (s->packet_payload_size - s->packet_cursor < size)
+        return (0);
 
-  start = ((char *)&s->packet->payload) + s->packet_cursor;
-  memcpy(start, data, size);
-  s->packet_cursor += size;
+    start = ((char *)&s->packet->payload) + s->packet_cursor;
+    memcpy(start, data, size);
+    s->packet_cursor += size;
 
-  return (1);
+    return (1);
 }
 
 int               netbios_session_packet_send(netbios_session *s)
 {
-  ssize_t         to_send;
-  ssize_t         sent;
+    ssize_t         to_send;
+    ssize_t         sent;
 
-  assert(s && s->packet && s->socket && s->state > 0);
+    assert(s && s->packet && s->socket && s->state > 0);
 
-  s->packet->length = htons(s->packet_cursor);
-  to_send           = sizeof(netbios_session_packet) + s->packet_cursor;
-  sent              = send(s->socket, (void *)s->packet, to_send, 0);
+    s->packet->length = htons(s->packet_cursor);
+    to_send           = sizeof(netbios_session_packet) + s->packet_cursor;
+    sent              = send(s->socket, (void *)s->packet, to_send, 0);
 
-  if (sent != to_send)
-  {
-    perror("netbios_session_packet_send: Unable to send (full?) packet");
-    return (0);
-  }
+    if (sent != to_send)
+    {
+        perror("netbios_session_packet_send: Unable to send (full?) packet");
+        return (0);
+    }
 
-  return (sent);
+    return (sent);
 }
 
 ssize_t           netbios_session_packet_recv(netbios_session *s, void **data)
 {
-  ssize_t         res;
-  size_t          total, sofar;
+    ssize_t         res;
+    size_t          total, sofar;
 
-  assert(s != NULL && s->packet != NULL && s->socket && s->state > 0);
+    assert(s != NULL && s->packet != NULL && s->socket && s->state > 0);
 
-  res = recv(s->socket, (void *)(s->packet), s->packet_payload_size, 0);
-  if (res < 0)
-  {
-    perror("netbios_session_packet_recv: ");
-    return (-1);
-  }
-
-  if ((size_t)res > sizeof(netbios_session_packet) && data != NULL)
-    *data = (void *)s->packet->payload;
-  else if (data != NULL)
-    *data = NULL;
+    res = recv(s->socket, (void *)(s->packet), s->packet_payload_size, 0);
+    if (res < 0)
+    {
+        perror("netbios_session_packet_recv: ");
+        return (-1);
+    }
 
-  total  = ntohs(s->packet->length);
-  total |= (s->packet->flags & 0x01) << 16;
-  sofar  = res - sizeof(netbios_session_packet);
+    if ((size_t)res > sizeof(netbios_session_packet) && data != NULL)
+        *data = (void *)s->packet->payload;
+    else if (data != NULL)
+        *data = NULL;
 
-  //fprintf(stderr, "Total = %ld, sofar = %ld\n", total, sofar);
+    total  = ntohs(s->packet->length);
+    total |= (s->packet->flags & 0x01) << 16;
+    sofar  = res - sizeof(netbios_session_packet);
 
-  while (sofar < total)
-  {
-    res = recv(s->socket, (void *)(s->packet) + 4 + sofar, total - sofar, 0);
-    //xfprintf(stderr, "Total = %ld, sofar = %ld, res = %ld\n", total, sofar, res);
+    //fprintf(stderr, "Total = %ld, sofar = %ld\n", total, sofar);
 
-    if (res < 0)
+    while (sofar < total)
     {
-      perror("netbios_session_packet_recv: ");
-      return (-1);
+        res = recv(s->socket, (void *)(s->packet) + 4 + sofar, total - sofar, 0);
+        //xfprintf(stderr, "Total = %ld, sofar = %ld, res = %ld\n", total, sofar, res);
+
+        if (res < 0)
+        {
+            perror("netbios_session_packet_recv: ");
+            return (-1);
+        }
+        sofar += res;
     }
-    sofar += res;
-  }
 
-  if (sofar > total)
-  {
-    BDSM_dbg("netbios_session_packet_recv: Packet size mismatch (%ld/%ld)\n",
-              sofar, total);
-    return(-1);
-  }
+    if (sofar > total)
+    {
+        BDSM_dbg("netbios_session_packet_recv: Packet size mismatch (%ld/%ld)\n",
+                 sofar, total);
+        return (-1);
+    }
 
-  return (sofar);
+    return (sofar);
 }
 

src/netbios_utils.c

@@ -24,17 +24,17 @@
 
 static short  nibble_encode(char c)
 {
-  short n1, n2;
+    short n1, n2;
 
-  n1 = (toupper(c) >> 4)   + 'A';
-  n2 = (toupper(c) & 0x0F) + 'A';
+    n1 = (toupper(c) >> 4)   + 'A';
+    n2 = (toupper(c) & 0x0F) + 'A';
 
-  return ((n1 << 8) | n2);
+    return ((n1 << 8) | n2);
 }
 
 static char   nibble_decode(char c1, char c2)
 {
-  return (((c1 - 'A') << 4) + (c2 - 'A'));
+    return (((c1 - 'A') << 4) + (c2 - 'A'));
 }
 
 
@@ -43,82 +43,82 @@ static char   nibble_decode(char c1, char c2)
 void  netbios_name_level1_encode(const char *name, char *encoded_name,
                                  unsigned type)
 {
-  size_t    name_length = strlen(name);
+    size_t    name_length = strlen(name);
 
-  if (name_length > NETBIOS_NAME_LENGTH)
-    name_length = NETBIOS_NAME_LENGTH;
+    if (name_length > NETBIOS_NAME_LENGTH)
+        name_length = NETBIOS_NAME_LENGTH;
 
-  for(unsigned int i = 0; i < NETBIOS_NAME_LENGTH; i++)
-  {
-    if (i < name_length)
+    for (unsigned int i = 0; i < NETBIOS_NAME_LENGTH; i++)
     {
-      encoded_name[2 * i]     = nibble_encode(name[i]) >> 8;
-      encoded_name[2 * i + 1] = nibble_encode(name[i]) & 0x00FF;
+        if (i < name_length)
+        {
+            encoded_name[2 * i]     = nibble_encode(name[i]) >> 8;
+            encoded_name[2 * i + 1] = nibble_encode(name[i]) & 0x00FF;
+        }
+        else
+        {
+            encoded_name[2 * i]     = 'C';
+            encoded_name[2 * i + 1] = 'A';
+        }
     }
-    else
-    {
-      encoded_name[2 * i]     = 'C';
-      encoded_name[2 * i + 1] = 'A';
-    }
-  }
 
-  encoded_name[30] = nibble_encode(type) >> 8;
-  encoded_name[31] = nibble_encode(type) &  0x00FF;
-  encoded_name[32] = '\0';
+    encoded_name[30] = nibble_encode(type) >> 8;
+    encoded_name[31] = nibble_encode(type) &  0x00FF;
+    encoded_name[32] = '\0';
 }
 
 // encoded_name: 33bytes long
 // name: at least 16bytes long (the string will be null-terminated)
 void  netbios_name_level1_decode(const char *encoded_name, char *name)
 {
-  for (unsigned int i = 0; i < NETBIOS_NAME_LENGTH; i++)
-  {
-    name[i] = nibble_decode(encoded_name[2 * i], encoded_name[2 * i + 1]);
-  }
-  name[NETBIOS_NAME_LENGTH] = 0;
+    for (unsigned int i = 0; i < NETBIOS_NAME_LENGTH; i++)
+    {
+        name[i] = nibble_decode(encoded_name[2 * i], encoded_name[2 * i + 1]);
+    }
+    name[NETBIOS_NAME_LENGTH] = 0;
 }
 
 // XXX: Supports domain
 char  *netbios_name_encode(const char *name, char *domain,
                            unsigned type)
 {
-  (void )domain; // Unused yet
+    (void)domain;  // Unused yet
 
-  size_t    encoded_size = 34; // length byte + 32 bytes for encoded name + terminator
-  char      *encoded_name;
+    size_t    encoded_size = 34; // length byte + 32 bytes for encoded name + terminator
+    char      *encoded_name;
 
-  if (!name)
-    return (0);
+    if (!name)
+        return (0);
 
-  encoded_name = malloc(encoded_size);
-  encoded_name[0] = 32; // length of the field;
-  netbios_name_level1_encode(name, encoded_name + 1, type);
-  encoded_name[33] = 0;
+    encoded_name = malloc(encoded_size);
+    encoded_name[0] = 32; // length of the field;
+    netbios_name_level1_encode(name, encoded_name + 1, type);
+    encoded_name[33] = 0;
 
-  //printf("Encoded name (l2): %s.\n", encoded_name);
+    //printf("Encoded name (l2): %s.\n", encoded_name);
 
-  return (encoded_name);
+    return (encoded_name);
 }
 
 int             netbios_name_decode(const char *encoded_name,
                                     char *name, char **domain)
 {
-  (void )domain; // Unused yet
+    (void)domain;  // Unused yet
 
-  size_t  encoded_length;
+    size_t  encoded_length;
 
-  if (!encoded_name || !name)
-    return(-1);
+    if (!encoded_name || !name)
+        return (-1);
 
-  encoded_length =  strlen(encoded_name);
+    encoded_length =  strlen(encoded_name);
 
-  // XXX Support domain name :p
-  if(encoded_length != 33)
-    return (-1);
+    // XXX Support domain name :p
+    if (encoded_length != 33)
+        return (-1);
 
-  netbios_name_level1_decode(encoded_name + 1, name);
-  name[33] = '\0';
-  return (32);
+    netbios_name_level1_decode(encoded_name + 1, name);
+    name[33] = '\0';
+    return (32);
 }
 
 

src/smb_buffer.c

@@ -24,27 +24,27 @@
 
 void    smb_buffer_init(smb_buffer *buf, void *data, size_t size)
 {
-  assert(buf != NULL);
+    assert(buf != NULL);
 
-  buf->data = data;
-  buf->size = size;
+    buf->data = data;
+    buf->size = size;
 }
 
 void    smb_buffer_alloc(smb_buffer *buf, size_t size)
 {
-  assert(buf != NULL);
+    assert(buf != NULL);
 
-  buf->data = malloc(size);
-  buf->size = size;
+    buf->data = malloc(size);
+    buf->size = size;
 
-  assert(buf->data != NULL);
+    assert(buf->data != NULL);
 }
 
 void    smb_buffer_free(smb_buffer *buf)
 {
-  if (buf == NULL || buf->data == NULL)
-    return;
+    if (buf == NULL || buf->data == NULL)
+        return;
 
-  free(buf->data);
-  smb_buffer_init(buf, NULL, 0);
+    free(buf->data);
+    smb_buffer_init(buf, NULL, 0);
 }

src/smb_fd.c

@@ -22,130 +22,130 @@
 
 void        smb_session_share_add(smb_session *s, smb_share *share)
 {
-  smb_share *iter;
+    smb_share *iter;
 
-  assert(s != NULL && share != NULL);
+    assert(s != NULL && share != NULL);
 
-  if (s->shares == NULL)
-  {
-    s->shares = share;
-    return;
-  }
+    if (s->shares == NULL)
+    {
+        s->shares = share;
+        return;
+    }
 
-  iter = s->shares;
-  while(iter->next != NULL)
-    iter = iter->next;
-  iter->next = share;
+    iter = s->shares;
+    while (iter->next != NULL)
+        iter = iter->next;
+    iter->next = share;
 }
 
 smb_share *smb_session_share_get(smb_session *s, smb_tid tid)
 {
-  smb_share *iter;
+    smb_share *iter;
 
-  assert(s != NULL && tid);
+    assert(s != NULL && tid);
 
-  iter = s->shares;
-  while(iter != NULL && iter->tid != tid)
-    iter = iter->next;
+    iter = s->shares;
+    while (iter != NULL && iter->tid != tid)
+        iter = iter->next;
 
-  return (iter);
+    return (iter);
 }
 
 smb_share *smb_session_share_remove(smb_session *s, smb_tid tid)
 {
-  smb_share *iter, *keep;
-
-  assert(s != NULL && tid);
-  iter = s->shares;
-
-  if (iter == NULL)
+    smb_share *iter, *keep;
+
+    assert(s != NULL && tid);
+    iter = s->shares;
+
+    if (iter == NULL)
+        return (NULL);
+    if (iter->tid == tid)
+    {
+        s->shares = s->shares->next;
+        return (iter);
+    }
+
+    while (iter->next != NULL && iter->next->tid != tid)
+        iter = iter->next;
+
+    if (iter->next != NULL) // We found it
+    {
+        keep = iter->next;
+        iter->next = iter->next->next;
+        return (keep);
+    }
     return (NULL);
-  if (iter->tid == tid)
-  {
-    s->shares = s->shares->next;
-    return (iter);
-  }
-
-  while(iter->next != NULL && iter->next->tid != tid)
-    iter = iter->next;
-
-  if (iter->next != NULL) // We found it
-  {
-    keep = iter->next;
-    iter->next = iter->next->next;
-    return (keep);
-  }
-  return (NULL);
 }
 
 int         smb_session_file_add(smb_session *s, smb_tid tid, smb_file *f)
 {
-  smb_share *share;
-  smb_file  *iter;
+    smb_share *share;
+    smb_file  *iter;
 
-  assert(s != NULL && tid && f != NULL);
+    assert(s != NULL && tid && f != NULL);
 
-  if ((share = smb_session_share_get(s, tid)) == NULL)
-    return (0);
+    if ((share = smb_session_share_get(s, tid)) == NULL)
+        return (0);
 
-  if (share->files == NULL)
-    share->files = f;
-  else
-  {
-    iter = share->files;
-    while (iter->next != NULL)
-      iter = iter->next;
-    iter->next = f;
-  }
+    if (share->files == NULL)
+        share->files = f;
+    else
+    {
+        iter = share->files;
+        while (iter->next != NULL)
+            iter = iter->next;
+        iter->next = f;
+    }
 
-  return (1);
+    return (1);
 }
 
 smb_file  *smb_session_file_get(smb_session *s, smb_fd fd)
 {
-  smb_share *share;
-  smb_file  *iter;
+    smb_share *share;
+    smb_file  *iter;
 
-  assert(s != NULL && fd);
+    assert(s != NULL && fd);
 
-  if ((share = smb_session_share_get(s, SMB_FD_TID(fd))) == NULL)
-    return (NULL);
+    if ((share = smb_session_share_get(s, SMB_FD_TID(fd))) == NULL)
+        return (NULL);
 
-  iter = share->files;
-  while(iter != NULL && iter->fid != SMB_FD_FID(fd))
-    iter = iter->next;
+    iter = share->files;
+    while (iter != NULL && iter->fid != SMB_FD_FID(fd))
+        iter = iter->next;
 
-  return (iter);
+    return (iter);
 }
 
 smb_file  *smb_session_file_remove(smb_session *s, smb_fd fd)
 {
-  smb_share *share;
-  smb_file  *iter, *keep;
+    smb_share *share;
+    smb_file  *iter, *keep;
 
-  assert(s != NULL && fd);
+    assert(s != NULL && fd);
 
-  if ((share = smb_session_share_get(s, SMB_FD_TID(fd))) == NULL)
-    return (NULL);
+    if ((share = smb_session_share_get(s, SMB_FD_TID(fd))) == NULL)
+        return (NULL);
 
-  iter = share->files;
+    iter = share->files;
 
-  if (iter == NULL)
-    return (NULL);
-  if (iter->fid == SMB_FD_FID(fd))
-  {
-    share->files = iter->next;
-    return (iter);
-  }
-
-  while(iter->next != NULL && iter->next->fid != SMB_FD_TID(fd))
-    iter = iter->next;
-  if (iter->next != NULL)
-  {
-    keep = iter->next;
-    iter->next = iter->next->next;
-    return (keep);
-  }
-  else
-    return (NULL);
+    if (iter == NULL)
+        return (NULL);
+    if (iter->fid == SMB_FD_FID(fd))
+    {
+        share->files = iter->next;
+        return (iter);
+    }
+
+    while (iter->next != NULL && iter->next->fid != SMB_FD_TID(fd))
+        iter = iter->next;
+    if (iter->next != NULL)
+    {
+        keep = iter->next;
+        iter->next = iter->next->next;
+        return (keep);
+    }
+    else
+        return (NULL);
 }

src/smb_file.c

@@ -30,167 +30,167 @@
 smb_fd      smb_fopen(smb_session *s, smb_tid tid, const char *path,
                       uint32_t o_flags)
 {
-  smb_share       *share;
-  smb_file        *file;
-  smb_message     *req_msg, resp_msg;
-  smb_create_req  *req;
-  smb_create_resp *resp;
-  size_t            path_len;
-  int               res;
-
-  assert(s != NULL && path != NULL);
-  if ((share = smb_session_share_get(s, tid)) == NULL)
-    return (0);
-
-  req_msg = smb_message_new(SMB_CMD_CREATE, 128);
-
-  // Set SMB Headers
-  smb_message_set_andx_members(req_msg);
-  req_msg->packet->header.tid = tid;
-
-  // Create AndX Params
-  req = (smb_create_req *)req_msg->packet->payload;
-  req->wct            = 24;
-  req->flags          = 0;
-  req->root_fid       = 0;
-  req->access_mask    = o_flags;
-  req->alloc_size     = 0;
-  req->file_attr      = 0;
-  req->share_access   = SMB_SHARE_READ | SMB_SHARE_WRITE;
-  req->disposition    = 1;  // 1 = Open and file if doesn't exist
-  req->create_opts    = 0;  // We dont't support create
-  req->impersonation  = 2;  // ?????
-  req->security_flags = 0;  // ???
-
-  // Create AndX 'Body'
-  smb_message_advance(req_msg, sizeof(smb_create_req));
-  smb_message_put8(req_msg, 0);   // Align beginning of path
-  path_len = smb_message_put_utf16(req_msg, path, strlen(path) + 1);
-  // smb_message_put16(req_msg, 0);  // ??
-  req->path_length  = path_len;
-  req->bct          = path_len + 1;
-
-  res = smb_session_send_msg(s, req_msg);
-  smb_message_destroy(req_msg);
-  if (!res)
-    return (0);
-
-  if (!smb_session_recv_msg(s, &resp_msg))
-    return (0);
-  if (resp_msg.packet->header.status != NT_STATUS_SUCCESS)
-    return (0);
-
-  resp = (smb_create_resp *)resp_msg.packet->payload;
-  file = calloc(1, sizeof(smb_file));
-  assert(file != NULL);
-
-  file->fid           = resp->fid;
-  file->tid           = tid;
-  file->created       = resp->created;
-  file->accessed      = resp->accessed;
-  file->written       = resp->written;
-  file->changed       = resp->changed;
-  file->alloc_size    = resp->alloc_size;
-  file->size          = resp->size;
-  file->attr          = resp->attr;
-  file->is_dir        = resp->is_dir;
-
-  smb_session_file_add(s, tid, file); // XXX Check return
-
-  return (SMB_FD(tid, file->fid));
+    smb_share       *share;
+    smb_file        *file;
+    smb_message     *req_msg, resp_msg;
+    smb_create_req  *req;
+    smb_create_resp *resp;
+    size_t            path_len;
+    int               res;
+
+    assert(s != NULL && path != NULL);
+    if ((share = smb_session_share_get(s, tid)) == NULL)
+        return (0);
+
+    req_msg = smb_message_new(SMB_CMD_CREATE, 128);
+
+    // Set SMB Headers
+    smb_message_set_andx_members(req_msg);
+    req_msg->packet->header.tid = tid;
+
+    // Create AndX Params
+    req = (smb_create_req *)req_msg->packet->payload;
+    req->wct            = 24;
+    req->flags          = 0;
+    req->root_fid       = 0;
+    req->access_mask    = o_flags;
+    req->alloc_size     = 0;
+    req->file_attr      = 0;
+    req->share_access   = SMB_SHARE_READ | SMB_SHARE_WRITE;
+    req->disposition    = 1;  // 1 = Open and file if doesn't exist
+    req->create_opts    = 0;  // We dont't support create
+    req->impersonation  = 2;  // ?????
+    req->security_flags = 0;  // ???
+
+    // Create AndX 'Body'
+    smb_message_advance(req_msg, sizeof(smb_create_req));
+    smb_message_put8(req_msg, 0);   // Align beginning of path
+    path_len = smb_message_put_utf16(req_msg, path, strlen(path) + 1);
+    // smb_message_put16(req_msg, 0);  // ??
+    req->path_length  = path_len;
+    req->bct          = path_len + 1;
+
+    res = smb_session_send_msg(s, req_msg);
+    smb_message_destroy(req_msg);
+    if (!res)
+        return (0);
+
+    if (!smb_session_recv_msg(s, &resp_msg))
+        return (0);
+    if (resp_msg.packet->header.status != NT_STATUS_SUCCESS)
+        return (0);
+
+    resp = (smb_create_resp *)resp_msg.packet->payload;
+    file = calloc(1, sizeof(smb_file));
+    assert(file != NULL);
+
+    file->fid           = resp->fid;
+    file->tid           = tid;
+    file->created       = resp->created;
+    file->accessed      = resp->accessed;
+    file->written       = resp->written;
+    file->changed       = resp->changed;
+    file->alloc_size    = resp->alloc_size;
+    file->size          = resp->size;
+    file->attr          = resp->attr;
+    file->is_dir        = resp->is_dir;
+
+    smb_session_file_add(s, tid, file); // XXX Check return
+
+    return (SMB_FD(tid, file->fid));
 }
 
 void        smb_fclose(smb_session *s, smb_fd fd)
 {
-  smb_file        *file;
-  smb_message     *msg;
-  smb_close_req   *req;
+    smb_file        *file;
+    smb_message     *msg;
+    smb_close_req   *req;
 
-  assert(s != NULL && fd);
+    assert(s != NULL && fd);
 
-  // XXX Memory leak, destroy the file after removing it
-  if ((file = smb_session_file_remove(s, fd)) == NULL)
-    return;
+    // XXX Memory leak, destroy the file after removing it
+    if ((file = smb_session_file_remove(s, fd)) == NULL)
+        return;
 
-  msg = smb_message_new(SMB_CMD_CLOSE, 64);
-  req = (smb_close_req *)msg->packet->payload;
+    msg = smb_message_new(SMB_CMD_CLOSE, 64);
+    req = (smb_close_req *)msg->packet->payload;
 
-  msg->packet->header.tid = SMB_FD_TID(fd);
+    msg->packet->header.tid = SMB_FD_TID(fd);
 
-  smb_message_advance(msg, sizeof(smb_close_req));
-  req->wct        = 3;
-  req->fid        = SMB_FD_FID(fd);
-  req->last_write = ~0;
-  req->bct        = 0;
+    smb_message_advance(msg, sizeof(smb_close_req));
+    req->wct        = 3;
+    req->fid        = SMB_FD_FID(fd);
+    req->last_write = ~0;
+    req->bct        = 0;
 
-  // We don't check for succes or failure, since we actually don't really
-  // care about creating a potentiel leak server side.
-  smb_session_send_msg(s, msg);
-  smb_session_recv_msg(s, 0);
+    // We don't check for succes or failure, since we actually don't really
+    // care about creating a potentiel leak server side.
+    smb_session_send_msg(s, msg);
+    smb_session_recv_msg(s, 0);
 }
 
 ssize_t   smb_fread(smb_session *s, smb_fd fd, void *buf, size_t buf_size)
 {
-  smb_file        *file;
-  smb_message     *req_msg, resp_msg;
-  smb_read_req    *req;
-  smb_read_resp   *resp;
-  size_t            max_read;
-  int               res;
-
-  assert(s != NULL && buf != NULL && fd);
-  if ((file = smb_session_file_get(s, fd)) == NULL)
-    return (-1);
-
-  req_msg = smb_message_new(SMB_CMD_READ, 64);
-  req_msg->packet->header.tid = file->tid;
-  smb_message_set_andx_members(req_msg);
-  smb_message_advance(req_msg, sizeof(smb_read_req));
-
-  max_read = SMB_IO_BUFSIZE - 256; // XXX
-  max_read = max_read < buf_size ? max_read : buf_size;
-
-  req = (smb_read_req *)req_msg->packet->payload;
-  req->wct              = 12;
-  req->fid              = file->fid;
-  req->offset           = file->readp;
-  req->max_count        = max_read;
-  req->min_count        = max_read;
-  req->max_count_high   = 0;
-  req->remaining        = 0;
-  req->offset_high      = 0;
-  req->bct              = 0;
-
-  res = smb_session_send_msg(s, req_msg);
-  smb_message_destroy(req_msg);
-  if (!res)
-    return (-1);
-
-  if (!smb_session_recv_msg(s, &resp_msg))
-    return (-1);
-  if (resp_msg.packet->header.status != NT_STATUS_SUCCESS)
-    return (-1);
-
-  resp = (smb_read_resp *)resp_msg.packet->payload;
-  memcpy(buf, resp->file, resp->data_len);
-  smb_fseek(s, fd, resp->data_len, SEEK_CUR);
-
-  return (resp->data_len);
+    smb_file        *file;
+    smb_message     *req_msg, resp_msg;
+    smb_read_req    *req;
+    smb_read_resp   *resp;
+    size_t            max_read;
+    int               res;
+
+    assert(s != NULL && buf != NULL && fd);
+    if ((file = smb_session_file_get(s, fd)) == NULL)
+        return (-1);
+
+    req_msg = smb_message_new(SMB_CMD_READ, 64);
+    req_msg->packet->header.tid = file->tid;
+    smb_message_set_andx_members(req_msg);
+    smb_message_advance(req_msg, sizeof(smb_read_req));
+
+    max_read = SMB_IO_BUFSIZE - 256; // XXX
+    max_read = max_read < buf_size ? max_read : buf_size;
+
+    req = (smb_read_req *)req_msg->packet->payload;
+    req->wct              = 12;
+    req->fid              = file->fid;
+    req->offset           = file->readp;
+    req->max_count        = max_read;
+    req->min_count        = max_read;
+    req->max_count_high   = 0;
+    req->remaining        = 0;
+    req->offset_high      = 0;
+    req->bct              = 0;
+
+    res = smb_session_send_msg(s, req_msg);
+    smb_message_destroy(req_msg);
+    if (!res)
+        return (-1);
+
+    if (!smb_session_recv_msg(s, &resp_msg))
+        return (-1);
+    if (resp_msg.packet->header.status != NT_STATUS_SUCCESS)
+        return (-1);
+
+    resp = (smb_read_resp *)resp_msg.packet->payload;
+    memcpy(buf, resp->file, resp->data_len);
+    smb_fseek(s, fd, resp->data_len, SEEK_CUR);
+
+    return (resp->data_len);
 }
 
 ssize_t   smb_fseek(smb_session *s, smb_fd fd, ssize_t offset, int whence)
 {
-  smb_file  *file;
+    smb_file  *file;
 
-  assert(s != NULL);
+    assert(s != NULL);
 
-  if (!fd || (file = smb_session_file_get(s, fd)) == NULL)
-    return(0);
+    if (!fd || (file = smb_session_file_get(s, fd)) == NULL)
+        return (0);
 
-  if (whence == SMB_SEEK_SET)
-    file->readp = offset;
-  else if (whence == SMB_SEEK_CUR)
-    file->readp += offset;
+    if (whence == SMB_SEEK_SET)
+        file->readp = offset;
+    else if (whence == SMB_SEEK_CUR)
+        file->readp += offset;
 
-  return (file->readp);
+    return (file->readp);
 }

src/smb_message.c

@@ -30,163 +30,163 @@
 
 smb_message   *smb_message_new(uint8_t cmd, size_t payload_size)
 {
-  const char    magic[4] = SMB_MAGIC;
-  smb_message *msg;
+    const char    magic[4] = SMB_MAGIC;
+    smb_message *msg;
 
-  msg = (smb_message *)calloc(1, sizeof(smb_message));
-  assert(msg != NULL);
+    msg = (smb_message *)calloc(1, sizeof(smb_message));
+    assert(msg != NULL);
 
-  msg->packet = (smb_packet *)calloc(1, sizeof(smb_packet) + payload_size);
-  assert(msg != NULL);
+    msg->packet = (smb_packet *)calloc(1, sizeof(smb_packet) + payload_size);
+    assert(msg != NULL);
 
-  msg->payload_size = payload_size;
-  msg->cursor = 0;
+    msg->payload_size = payload_size;
+    msg->cursor = 0;
 
-  for (unsigned i = 0; i < 4; i++)
-    msg->packet->header.magic[i] = magic[i];
-  msg->packet->header.command   = cmd;
-  msg->packet->header.pid       = getpid();
+    for (unsigned i = 0; i < 4; i++)
+        msg->packet->header.magic[i] = magic[i];
+    msg->packet->header.command   = cmd;
+    msg->packet->header.pid       = getpid();
 
-  return (msg);
+    return (msg);
 }
 
 // Duplicate a message while growing payload_size.
 smb_message   *smb_message_grow(smb_message *msg, size_t size)
 {
-  smb_message *copy;
+    smb_message *copy;
 
-  assert(msg != NULL && msg->packet != NULL);
+    assert(msg != NULL && msg->packet != NULL);
 
-  copy = malloc(sizeof(smb_message));
-  assert(copy != NULL);
-  copy->cursor        = msg->cursor;
-  copy->payload_size  = msg->payload_size + size;
+    copy = malloc(sizeof(smb_message));
+    assert(copy != NULL);
+    copy->cursor        = msg->cursor;
+    copy->payload_size  = msg->payload_size + size;
 
-  copy->packet = malloc(sizeof(smb_packet) + copy->payload_size);
-  assert(copy->packet != NULL);
-  memcpy((void *)copy->packet, (void *)msg->packet, msg->payload_size);
+    copy->packet = malloc(sizeof(smb_packet) + copy->payload_size);
+    assert(copy->packet != NULL);
+    memcpy((void *)copy->packet, (void *)msg->packet, msg->payload_size);
 
-  return (copy);
+    return (copy);
 }
 
 void            smb_message_destroy(smb_message *msg)
 {
-  if (msg != NULL)
-    free(msg->packet);
-  free(msg);
+    if (msg != NULL)
+        free(msg->packet);
+    free(msg);
 }
 
 int             smb_message_append(smb_message *msg, const void *data,
                                    size_t data_size)
 {
-  assert(msg != NULL && data != NULL);
+    assert(msg != NULL && data != NULL);
 
-  if (data_size > msg->payload_size - msg->cursor)
-    return (0);
+    if (data_size > msg->payload_size - msg->cursor)
+        return (0);
 
-  memcpy(msg->packet->payload + msg->cursor, data, data_size);
-  msg->cursor += data_size;
+    memcpy(msg->packet->payload + msg->cursor, data, data_size);
+    msg->cursor += data_size;
 
-  //fprintf(stderr, "Cursor is at %d (append)\n", msg->cursor);
+    //fprintf(stderr, "Cursor is at %d (append)\n", msg->cursor);
 
-  return (1);
+    return (1);
 }
 
 int             smb_message_advance(smb_message *msg, size_t size)
 {
-  assert(msg != NULL);
+    assert(msg != NULL);
 
-  if (msg->payload_size < msg->cursor + size)
-    return (0);
+    if (msg->payload_size < msg->cursor + size)
+        return (0);
 
-  msg->cursor += size;
+    msg->cursor += size;
 
-  //fprintf(stderr, "Cursor is at %d (advance)\n", msg->cursor);
-  return (1);
+    //fprintf(stderr, "Cursor is at %d (advance)\n", msg->cursor);
+    return (1);
 }
 
 int             smb_message_put8(smb_message *msg, uint8_t data)
 {
-  return(smb_message_append(msg, (void *)&data, 1));
+    return (smb_message_append(msg, (void *)&data, 1));
 }
 
 int             smb_message_put16(smb_message *msg, uint16_t data)
 {
-    return(smb_message_append(msg, (void *)&data, 2));
+    return (smb_message_append(msg, (void *)&data, 2));
 }
 
 int             smb_message_put32(smb_message *msg, uint32_t data)
 {
-    return(smb_message_append(msg, (void *)&data, 4));
+    return (smb_message_append(msg, (void *)&data, 4));
 }
 
 int             smb_message_put64(smb_message *msg, uint64_t data)
 {
-    return(smb_message_append(msg, (void *)&data, 8));
+    return (smb_message_append(msg, (void *)&data, 8));
 }
 
 size_t          smb_message_put_utf16(smb_message *msg, const char *str,
                                       size_t str_len)
 {
-  char          *utf_str;
-  size_t        utf_str_len;
-  int           res;
+    char          *utf_str;
+    size_t        utf_str_len;
+    int           res;
 
-  utf_str_len = smb_to_utf16(str, str_len, &utf_str);
-  res = smb_message_append(msg, utf_str, utf_str_len);
-  free(utf_str);
+    utf_str_len = smb_to_utf16(str, str_len, &utf_str);
+    res = smb_message_append(msg, utf_str, utf_str_len);
+    free(utf_str);
 
-  // fprintf(stderr, "put_utf16, adds %d bytes, cursor is at %d\n",
-  //         utf_str_len, msg->cursor);
+    // fprintf(stderr, "put_utf16, adds %d bytes, cursor is at %d\n",
+    //         utf_str_len, msg->cursor);
 
-  if (res)
-    return(utf_str_len);
-  return (0);
+    if (res)
+        return (utf_str_len);
+    return (0);
 }
 
 int             smb_message_put_uuid(smb_message *msg, uint32_t a, uint16_t b,
                                      uint16_t c, const uint8_t d[8])
 {
-  assert(msg != NULL);
-
-  if (!smb_message_put32(msg, a))
-    return (0);
-  if (!smb_message_put16(msg, b))
-    return (0);
-  if (!smb_message_put16(msg, c))
-    return (0);
-  for (int i = 0; i < 8; i++)
-    if (!smb_message_put8(msg, d[i]))
-      return (0);
-
-  return (1);
+    assert(msg != NULL);
+
+    if (!smb_message_put32(msg, a))
+        return (0);
+    if (!smb_message_put16(msg, b))
+        return (0);
+    if (!smb_message_put16(msg, c))
+        return (0);
+    for (int i = 0; i < 8; i++)
+        if (!smb_message_put8(msg, d[i]))
+            return (0);
+
+    return (1);
 }
 
 void            smb_message_flag(smb_message *msg, uint32_t flag, int value)
 {
-  uint32_t      *flags;
+    uint32_t      *flags;
 
-  assert(msg != NULL && msg->packet != NULL);
+    assert(msg != NULL && msg->packet != NULL);
 
-  // flags + flags2 is actually 24 bit long, we have to be cautious
-  flags = (uint32_t *)&(msg->packet->header.flags);
-  flag &= 0x00FFFFFF;
+    // flags + flags2 is actually 24 bit long, we have to be cautious
+    flags = (uint32_t *)&(msg->packet->header.flags);
+    flag &= 0x00FFFFFF;
 
-  if (value)
-    *flags |= flag;
-  else
-    *flags &= ~flag;
+    if (value)
+        *flags |= flag;
+    else
+        *flags &= ~flag;
 }
 
 void            smb_message_set_andx_members(smb_message *msg)
 {
-  // This could have been any type with the 'SMB_ANDX_MEMBERS';
-  smb_session_req   *req;
+    // This could have been any type with the 'SMB_ANDX_MEMBERS';
+    smb_session_req   *req;
 
-  assert(msg != NULL);
+    assert(msg != NULL);
 
-  req = (smb_session_req *)msg->packet->payload;
-  req->andx           = 0xff;
-  req->andx_reserved  = 0;
-  req->andx_offset    = 0;
+    req = (smb_session_req *)msg->packet->payload;
+    req->andx           = 0xff;
+    req->andx_reserved  = 0;
+    req->andx_offset    = 0;
 }

src/smb_ntlm.c

@@ -33,112 +33,112 @@
 
 uint64_t    smb_ntlm_generate_challenge()
 {
-  uint64_t        result;
-  uint64_t        *memory;
-  struct timeval  t;
+    uint64_t        result;
+    uint64_t        *memory;
+    struct timeval  t;
 
-  gettimeofday(&t, NULL);
-  srandom(t.tv_usec);
-  // Get random data from uninitialized memory, and 'random' memory address
-  memory = malloc(sizeof(uint64_t));
+    gettimeofday(&t, NULL);
+    srandom(t.tv_usec);
+    // Get random data from uninitialized memory, and 'random' memory address
+    memory = malloc(sizeof(uint64_t));
 
-  result = random() + (random() << 32) + (uint64_t)memory * *memory;
+    result = random() + (random() << 32) + (uint64_t)memory **memory;
 
-  return (result);
+    return (result);
 }
 
 void        smb_ntlm_generate_xkey(smb_ntlmh *cli_session_key)
 {
-  uint64_t  *key = (uint64_t *)cli_session_key;
+    uint64_t  *key = (uint64_t *)cli_session_key;
 
-  key[0] = smb_ntlm_generate_challenge();
-  key[1] = smb_ntlm_generate_challenge();
+    key[0] = smb_ntlm_generate_challenge();
+    key[1] = smb_ntlm_generate_challenge();
 }
 
 void        smb_ntlm_hash(const char *password, smb_ntlmh *hash)
 {
-  MD4_CTX   ctx;
-  char      *ucs2le_pass;
-  size_t    sz;
+    MD4_CTX   ctx;
+    char      *ucs2le_pass;
+    size_t    sz;
 
-  assert(password != NULL && hash != NULL);
+    assert(password != NULL && hash != NULL);
 
-  sz = smb_to_utf16(password, strlen(password), &ucs2le_pass);
-  memset((void *)hash, 0, SMB_NTLM_HASH_SIZE);
+    sz = smb_to_utf16(password, strlen(password), &ucs2le_pass);
+    memset((void *)hash, 0, SMB_NTLM_HASH_SIZE);
 
-  MD4_Init(&ctx);
-  MD4_Update(&ctx, (uint8_t *)ucs2le_pass, sz);
-  MD4_Final((uint8_t *)hash, &ctx);
+    MD4_Init(&ctx);
+    MD4_Update(&ctx, (uint8_t *)ucs2le_pass, sz);
+    MD4_Final((uint8_t *)hash, &ctx);
 
-  free(ucs2le_pass);
+    free(ucs2le_pass);
 }
 
 static void _upcase(char *str)
 {
-  assert (str != NULL);
-
-  while (*str)
-  {
-    if (isalpha(*str))
-      *str = toupper(*str);
-    str++;
-  }
+    assert(str != NULL);
+
+    while (*str)
+    {
+        if (isalpha(*str))
+            *str = toupper(*str);
+        str++;
+    }
 }
 
 void        smb_ntlm2_hash(const char *user, const char *password,
                            const char *dest, smb_ntlmh *hash)
 {
-  smb_ntlmh     hash_v1;
-  char          *ucs_user, *ucs_dest, *data, user_upper[64];
-  size_t        ucs_user_len, ucs_dest_len, data_len;
+    smb_ntlmh     hash_v1;
+    char          *ucs_user, *ucs_dest, *data, user_upper[64];
+    size_t        ucs_user_len, ucs_dest_len, data_len;
 
-  smb_ntlm_hash(password, &hash_v1);
+    smb_ntlm_hash(password, &hash_v1);
 
-  strlcpy(user_upper, user, 64);
-  _upcase(user_upper);
+    strlcpy(user_upper, user, 64);
+    _upcase(user_upper);
 
-  ucs_user_len  = smb_to_utf16(user_upper, strlen(user_upper), &ucs_user);
-  ucs_dest_len  = smb_to_utf16(dest, strlen(dest), &ucs_dest);
-  data_len      = ucs_user_len + ucs_dest_len;
-  data          = alloca(data_len);
+    ucs_user_len  = smb_to_utf16(user_upper, strlen(user_upper), &ucs_user);
+    ucs_dest_len  = smb_to_utf16(dest, strlen(dest), &ucs_dest);
+    data_len      = ucs_user_len + ucs_dest_len;
+    data          = alloca(data_len);
 
-  memcpy(data, ucs_user, ucs_user_len);
-  memcpy(data + ucs_user_len, ucs_dest, ucs_dest_len);
+    memcpy(data, ucs_user, ucs_user_len);
+    memcpy(data + ucs_user_len, ucs_dest, ucs_dest_len);
 
-  HMAC_MD5(hash_v1, SMB_NTLM_HASH_SIZE, data, data_len, hash);
+    HMAC_MD5(hash_v1, SMB_NTLM_HASH_SIZE, data, data_len, hash);
 
-  free(ucs_user);
-  free(ucs_dest);
+    free(ucs_user);
+    free(ucs_dest);
 }
 
 uint8_t     *smb_ntlm2_response(smb_ntlmh *hash_v2, uint64_t srv_challenge,
                                 smb_buffer *blob)
 {
-  smb_buffer      data;
-  uint8_t         *response, hmac[16];
+    smb_buffer      data;
+    uint8_t         *response, hmac[16];
 
 
-  smb_buffer_alloca(&data, sizeof(uint64_t) + blob->size);
-  memcpy(data.data, (void *)&srv_challenge, sizeof(uint64_t));
-  memcpy(data.data + sizeof(uint64_t), blob->data, blob->size);
+    smb_buffer_alloca(&data, sizeof(uint64_t) + blob->size);
+    memcpy(data.data, (void *)&srv_challenge, sizeof(uint64_t));
+    memcpy(data.data + sizeof(uint64_t), blob->data, blob->size);
 
-  HMAC_MD5(hash_v2, SMB_NTLM_HASH_SIZE, data.data, data.size, &hmac);
+    HMAC_MD5(hash_v2, SMB_NTLM_HASH_SIZE, data.data, data.size, &hmac);
 
-  response = malloc(blob->size + 16);
-  assert(response != NULL);
-  memcpy(response, (void *)hmac, 16);
-  memcpy(response + 16, blob->data, blob->size);
+    response = malloc(blob->size + 16);
+    assert(response != NULL);
+    memcpy(response, (void *)hmac, 16);
+    memcpy(response + 16, blob->data, blob->size);
 
-  return (response);
+    return (response);
 }
 
 uint8_t     *smb_lm2_response(smb_ntlmh *hash_v2, uint64_t srv_challenge,
                               uint64_t user_challenge)
 {
-  smb_buffer buf;
+    smb_buffer buf;
 
-  smb_buffer_init(&buf, (void *)&user_challenge, 8);
-  return (smb_ntlm2_response(hash_v2, srv_challenge, &buf));
+    smb_buffer_init(&buf, (void *)&user_challenge, 8);
+    return (smb_ntlm2_response(hash_v2, srv_challenge, &buf));
 }
 
 // static void   _wcamelcase(char *str)
@@ -218,62 +218,62 @@ uint8_t     *smb_lm2_response(smb_ntlmh *hash_v2, uint64_t srv_challenge,
 size_t      smb_ntlm_make_blob(smb_ntlm_blob **out_blob, uint64_t ts,
                                uint64_t user_challenge, smb_buffer *target)
 {
-  smb_ntlm_blob *blob;
+    smb_ntlm_blob *blob;
 
-  assert(out_blob != NULL && target != NULL);
+    assert(out_blob != NULL && target != NULL);
 
-  blob = malloc(target->size + sizeof(smb_ntlm_blob));
+    blob = malloc(target->size + sizeof(smb_ntlm_blob));
 
-  memset((void *)blob, 0, sizeof(smb_ntlm_blob));
-  blob->header    = 0x101;
-  blob->timestamp = ts;
-  blob->challenge = user_challenge;
+    memset((void *)blob, 0, sizeof(smb_ntlm_blob));
+    blob->header    = 0x101;
+    blob->timestamp = ts;
+    blob->challenge = user_challenge;
 
-  memcpy(blob->target, target->data, target->size);
+    memcpy(blob->target, target->data, target->size);
 
-  *out_blob = blob;
-  return (sizeof(smb_ntlm_blob) + target->size);
+    *out_blob = blob;
+    return (sizeof(smb_ntlm_blob) + target->size);
 }
 
 void        smb_ntlm2_session_key(smb_ntlmh *hash_v2, void *ntlm2,
                                   smb_ntlmh *xkey, smb_ntlmh *xkey_crypt)
 {
-  struct rc4_state  rc4;
-  smb_ntlmh         hmac_ntlm2;
+    struct rc4_state  rc4;
+    smb_ntlmh         hmac_ntlm2;
 
-  HMAC_MD5(&hash_v2, 16, ntlm2, 16, &hmac_ntlm2);
+    HMAC_MD5(&hash_v2, 16, ntlm2, 16, &hmac_ntlm2);
 
-  rc4_init(&rc4, hmac_ntlm2, 16);
-  rc4_crypt(&rc4, (void *)xkey, (void *)xkey_crypt, 16);
+    rc4_init(&rc4, hmac_ntlm2, 16);
+    rc4_crypt(&rc4, (void *)xkey, (void *)xkey_crypt, 16);
 }
 
 
 void        smb_ntlmssp_negotiate(const char *host, const char *domain,
                                   smb_buffer *token)
 {
-  smb_ntlmssp_nego  *nego;
+    smb_ntlmssp_nego  *nego;
 
-  assert(host != NULL && domain != NULL && token != NULL);
+    assert(host != NULL && domain != NULL && token != NULL);
 
-  token->size = sizeof(smb_ntlmssp_nego) + strlen(host) + strlen(domain);
-  if (token->size % 2) // Align on Word
-    token->size += 1;
-  smb_buffer_alloc(token, token->size);
-  // fprintf(stderr, "Token size if %ld\n", token->size);
+    token->size = sizeof(smb_ntlmssp_nego) + strlen(host) + strlen(domain);
+    if (token->size % 2) // Align on Word
+        token->size += 1;
+    smb_buffer_alloc(token, token->size);
+    // fprintf(stderr, "Token size if %ld\n", token->size);
 
 
-  nego      = (smb_ntlmssp_nego *)token->data;
+    nego      = (smb_ntlmssp_nego *)token->data;
 
-  nego->type  = SMB_NTLMSSP_CMD_NEGO;
-  nego->flags = 0x60088215;//0x20080205;
-  nego->domain_len = nego->domain_maxlen = strlen(domain);
-  nego->domain_offset = 32;
-  nego->host_len = nego->host_maxlen = strlen(host);
-  nego->host_offset = 32 + strlen(domain);
+    nego->type  = SMB_NTLMSSP_CMD_NEGO;
+    nego->flags = 0x60088215;//0x20080205;
+    nego->domain_len = nego->domain_maxlen = strlen(domain);
+    nego->domain_offset = 32;
+    nego->host_len = nego->host_maxlen = strlen(host);
+    nego->host_offset = 32 + strlen(domain);
 
-  memcpy(nego->id, "NTLMSSP", 8);
-  memcpy(nego->names, domain, strlen(domain));
-  memcpy(nego->names + strlen(domain), domain, strlen(domain));
+    memcpy(nego->id, "NTLMSSP", 8);
+    memcpy(nego->names, domain, strlen(domain));
+    memcpy(nego->names + strlen(domain), domain, strlen(domain));
 }
 
 #define __AUTH_APPEND(FIELD, value, size, cursor)           \
@@ -287,67 +287,67 @@ void        smb_ntlmssp_response(uint64_t srv_challenge, uint64_t srv_ts,
                                  const char *user, const char *password,
                                  smb_buffer *target, smb_buffer *token)
 {
-  smb_ntlmssp_auth      *auth;
-  smb_ntlm_blob         *blob;
-  smb_ntlmh             hash_v2, xkey, xkey_crypt;
-  smb_buffer            buf;
-  void                  *lm2, *ntlm2;
-  size_t                blob_size, utf_sz, cursor = 0;
-  uint64_t              user_challenge;
-  char                  *utf;
-
-  assert(host != NULL && domain != NULL && user != NULL && password != NULL);
-  assert(token != NULL && target != NULL);
-
-  //// We compute most of the data first to know the final token size
-  smb_ntlm2_hash(user, password, domain, &hash_v2);
-  user_challenge = smb_ntlm_generate_challenge();
-  smb_ntlm_generate_xkey(&xkey);
-  blob_size = smb_ntlm_make_blob(&blob, srv_ts, user_challenge, target);
-
-  lm2   = smb_lm2_response(&hash_v2, srv_challenge, smb_ntlm_generate_challenge());
-  smb_buffer_init(&buf, blob, blob_size);
-  ntlm2 = smb_ntlm2_response(&hash_v2, srv_challenge, &buf);
-  smb_ntlm2_session_key(&hash_v2, ntlm2, &xkey, &xkey_crypt);
-
-  smb_buffer_init(&buf, NULL, 0);
-  free(blob);
-
-  // Compute size of and allocate token
-  token->size = sizeof(smb_ntlmssp_auth)
-                + strlen(host) * 2
-                + strlen(domain) * 2
-                + strlen(user) * 2
-                + blob_size + 16 // Blob + HMAC
-                + 8 + 16  // LM2 Response (miniblob=user_challenge + HMAC)
-                + 16;     // Session Key
-  if (token->size % 2) // Align on Word
-    token->size += 1;
-  smb_buffer_alloc(token, token->size);
-
-  auth = (smb_ntlmssp_auth *)token->data;
-  memset(auth, 0, token->size);
-
-  memcpy(auth->id, "NTLMSSP", 8);
-  auth->type  = SMB_NTLMSSP_CMD_AUTH;
-  auth->flags = 0x60088215;
-
-
-  __AUTH_APPEND(lm, lm2, 24, cursor)
-  __AUTH_APPEND(ntlm, ntlm2, blob_size + 16, cursor)
-
-  utf_sz = smb_to_utf16(domain, strlen(domain), &utf);
-  __AUTH_APPEND(domain, utf, utf_sz, cursor)
-  free(utf);
-  utf_sz = smb_to_utf16(user, strlen(user), &utf);
-  __AUTH_APPEND(user, utf, utf_sz, cursor)
-  free(utf);
-  utf_sz = smb_to_utf16(host, strlen(host), &utf);
-  __AUTH_APPEND(host, utf, utf_sz, cursor)
-  free(utf);
-
-  __AUTH_APPEND(session_key, &xkey_crypt, 16, cursor)
-
-  free(lm2);
-  free(ntlm2);
+    smb_ntlmssp_auth      *auth;
+    smb_ntlm_blob         *blob;
+    smb_ntlmh             hash_v2, xkey, xkey_crypt;
+    smb_buffer            buf;
+    void                  *lm2, *ntlm2;
+    size_t                blob_size, utf_sz, cursor = 0;
+    uint64_t              user_challenge;
+    char                  *utf;
+
+    assert(host != NULL && domain != NULL && user != NULL && password != NULL);
+    assert(token != NULL && target != NULL);
+
+    //// We compute most of the data first to know the final token size
+    smb_ntlm2_hash(user, password, domain, &hash_v2);
+    user_challenge = smb_ntlm_generate_challenge();
+    smb_ntlm_generate_xkey(&xkey);
+    blob_size = smb_ntlm_make_blob(&blob, srv_ts, user_challenge, target);
+
+    lm2   = smb_lm2_response(&hash_v2, srv_challenge, smb_ntlm_generate_challenge());
+    smb_buffer_init(&buf, blob, blob_size);
+    ntlm2 = smb_ntlm2_response(&hash_v2, srv_challenge, &buf);
+    smb_ntlm2_session_key(&hash_v2, ntlm2, &xkey, &xkey_crypt);
+
+    smb_buffer_init(&buf, NULL, 0);
+    free(blob);
+
+    // Compute size of and allocate token
+    token->size = sizeof(smb_ntlmssp_auth)
+                  + strlen(host) * 2
+                  + strlen(domain) * 2
+                  + strlen(user) * 2
+                  + blob_size + 16 // Blob + HMAC
+                  + 8 + 16  // LM2 Response (miniblob=user_challenge + HMAC)
+                  + 16;     // Session Key
+    if (token->size % 2) // Align on Word
+        token->size += 1;
+    smb_buffer_alloc(token, token->size);
+
+    auth = (smb_ntlmssp_auth *)token->data;
+    memset(auth, 0, token->size);
+
+    memcpy(auth->id, "NTLMSSP", 8);
+    auth->type  = SMB_NTLMSSP_CMD_AUTH;
+    auth->flags = 0x60088215;
+
+
+    __AUTH_APPEND(lm, lm2, 24, cursor)
+    __AUTH_APPEND(ntlm, ntlm2, blob_size + 16, cursor)
+
+    utf_sz = smb_to_utf16(domain, strlen(domain), &utf);
+    __AUTH_APPEND(domain, utf, utf_sz, cursor)
+    free(utf);
+    utf_sz = smb_to_utf16(user, strlen(user), &utf);
+    __AUTH_APPEND(user, utf, utf_sz, cursor)
+    free(utf);
+    utf_sz = smb_to_utf16(host, strlen(host), &utf);
+    __AUTH_APPEND(host, utf, utf_sz, cursor)
+    free(utf);
+
+    __AUTH_APPEND(session_key, &xkey_crypt, 16, cursor)
+
+    free(lm2);
+    free(ntlm2);
 }

src/smb_session.c

@@ -32,125 +32,125 @@ static int        smb_negotiate(smb_session *s, int xsec);
 
 smb_session   *smb_session_new()
 {
-  smb_session *s;
+    smb_session *s;
 
-  s = malloc(sizeof(smb_session));
-  assert(s != NULL);
-  memset((void *)s, 0, sizeof(smb_session));
+    s = malloc(sizeof(smb_session));
+    assert(s != NULL);
+    memset((void *)s, 0, sizeof(smb_session));
 
-  s->guest              = false;
+    s->guest              = false;
 
-  // Explicitly sets pointer to NULL, insted of 0
-  s->spnego_asn1        = NULL;
-  s->transport.session  = NULL;
-  s->shares             = NULL;
+    // Explicitly sets pointer to NULL, insted of 0
+    s->spnego_asn1        = NULL;
+    s->transport.session  = NULL;
+    s->shares             = NULL;
 
-  s->creds.domain       = NULL;
-  s->creds.login        = NULL;
-  s->creds.password     = NULL;
+    s->creds.domain       = NULL;
+    s->creds.login        = NULL;
+    s->creds.password     = NULL;
 
-  smb_buffer_init(&s->xsec_target, NULL, 0);
+    smb_buffer_init(&s->xsec_target, NULL, 0);
 
-  // Until we know more, assume server supports everything.
-  // s->c
+    // Until we know more, assume server supports everything.
+    // s->c
 
-  return (s);
+    return (s);
 }
 
 void            smb_session_destroy(smb_session *s)
 {
-  if (s != NULL)
-  {
-    // FIXME Free smb_share and smb_file
-    if (s->transport.session != NULL)
+    if (s != NULL)
     {
-      s->transport.destroy(s->transport.session);
-      s->transport.session = NULL;
+        // FIXME Free smb_share and smb_file
+        if (s->transport.session != NULL)
+        {
+            s->transport.destroy(s->transport.session);
+            s->transport.session = NULL;
+        }
+
+        if (s->spnego_asn1 != NULL)
+            asn1_delete_structure(&s->spnego_asn1);
+
+        smb_buffer_free(&s->xsec_target);
+
+        // Free stored credentials.
+        free(s->creds.domain);
+        free(s->creds.login);
+        free(s->creds.password);
+        free(s);
     }
-
-    if (s->spnego_asn1 != NULL)
-      asn1_delete_structure(&s->spnego_asn1);
-
-    smb_buffer_free(&s->xsec_target);
-
-    // Free stored credentials.
-    free(s->creds.domain);
-    free(s->creds.login);
-    free(s->creds.password);
-    free(s);
-  }
 }
 
 int             smb_session_state(smb_session *s)
 {
-  if (s != NULL)
-    return (s->state);
-  else
-    return (SMB_STATE_ERROR);
+    if (s != NULL)
+        return (s->state);
+    else
+        return (SMB_STATE_ERROR);
 }
 
 void            smb_session_set_creds(smb_session *s, const char *domain,
                                       const char *login, const char *password)
 {
-  assert(s != NULL);
-
-  if (domain != NULL)
-  {
-    if (s->creds.domain != NULL)
-      free(s->creds.domain);
-    s->creds.domain = strndup(domain, SMB_CREDS_MAXLEN);
-  }
-
-  if (login != NULL)
-  {
-    if (s->creds.login != NULL)
-      free(s->creds.login);
-    s->creds.login = strndup(login, SMB_CREDS_MAXLEN);
-  }
-
-  if (password != NULL)
-  {
-    if (s->creds.password != NULL)
-      free(s->creds.password);
-    s->creds.password = strndup(password, SMB_CREDS_MAXLEN);
-  }
+    assert(s != NULL);
+
+    if (domain != NULL)
+    {
+        if (s->creds.domain != NULL)
+            free(s->creds.domain);
+        s->creds.domain = strndup(domain, SMB_CREDS_MAXLEN);
+    }
+
+    if (login != NULL)
+    {
+        if (s->creds.login != NULL)
+            free(s->creds.login);
+        s->creds.login = strndup(login, SMB_CREDS_MAXLEN);
+    }
+
+    if (password != NULL)
+    {
+        if (s->creds.password != NULL)
+            free(s->creds.password);
+        s->creds.password = strndup(password, SMB_CREDS_MAXLEN);
+    }
 }
 
 int             smb_session_connect(smb_session *s, const char *name,
                                     uint32_t ip, int transport)
 {
-  assert(s != NULL && name != NULL);
-
-  if (s->transport.session != NULL)
-    s->transport.destroy(s->transport.session);
-
-  switch (transport)
-  {
-    case SMB_TRANSPORT_TCP:
-      smb_transport_tcp(&s->transport);
-      break;
-    case SMB_TRANSPORT_NBT:
-      smb_transport_nbt(&s->transport);
-      break;
-    default:
-      goto error;
-  }
-
-  if ((s->transport.session = s->transport.new(SMB_IO_BUFSIZE)) == NULL)
-    goto error;
-  if (!s->transport.connect((struct in_addr *)&ip, s->transport.session, name))
-    goto error;
-
-  memcpy(s->srv.name, name, strlen(name) + 1);
-  s->state = SMB_STATE_NETBIOS_OK;
-
-  if (!smb_negotiate(s, 1))     // Try to negotiate with extended security
-    if (!smb_negotiate(s, 0))   // Try to negotiate withOUT extended security
-      return (0);
-
-  return(1);
-
-  error:
+    assert(s != NULL && name != NULL);
+
+    if (s->transport.session != NULL)
+        s->transport.destroy(s->transport.session);
+
+    switch (transport)
+    {
+        case SMB_TRANSPORT_TCP:
+            smb_transport_tcp(&s->transport);
+            break;
+        case SMB_TRANSPORT_NBT:
+            smb_transport_nbt(&s->transport);
+            break;
+        default:
+            goto error;
+    }
+
+    if ((s->transport.session = s->transport.new(SMB_IO_BUFSIZE)) == NULL)
+        goto error;
+    if (!s->transport.connect((struct in_addr *)&ip, s->transport.session, name))
+        goto error;
+
+    memcpy(s->srv.name, name, strlen(name) + 1);
+    s->state = SMB_STATE_NETBIOS_OK;
+
+    if (!smb_negotiate(s, 1))     // Try to negotiate with extended security
+        if (!smb_negotiate(s, 0))   // Try to negotiate withOUT extended security
+            return (0);
+
+    return (1);
+
+error:
     s->state = SMB_STATE_ERROR;
     return (0);
 }
@@ -158,195 +158,195 @@ int             smb_session_connect(smb_session *s, const char *name,
 // xsec == 1 -> add Extended security flag
 static int        smb_negotiate(smb_session *s, int xsec)
 {
-  (void)xsec; // FIXME
+    (void)xsec; // FIXME
 
-  const char          *dialects[] = SMB_DIALECTS;
-  smb_message         *msg = NULL;
-  smb_message         answer;
-  smb_nego_resp       *nego;
+    const char          *dialects[] = SMB_DIALECTS;
+    smb_message         *msg = NULL;
+    smb_message         answer;
+    smb_nego_resp       *nego;
 
 
-  msg = smb_message_new(SMB_CMD_NEGOTIATE, 128);
+    msg = smb_message_new(SMB_CMD_NEGOTIATE, 128);
 
-  smb_message_put8(msg, 0);   // wct
-  smb_message_put16(msg, 0);  // bct, will be updated later
+    smb_message_put8(msg, 0);   // wct
+    smb_message_put16(msg, 0);  // bct, will be updated later
 
-  for(unsigned i = 0; dialects[i] != NULL; i++)
-    smb_message_append(msg, dialects[i], strlen(dialects[i]) + 1);
-  *((uint16_t *)(msg->packet->payload + 1)) = msg->cursor - 3;
+    for (unsigned i = 0; dialects[i] != NULL; i++)
+        smb_message_append(msg, dialects[i], strlen(dialects[i]) + 1);
+    *((uint16_t *)(msg->packet->payload + 1)) = msg->cursor - 3;
 
-  if (!smb_session_send_msg(s, msg))
-  {
+    if (!smb_session_send_msg(s, msg))
+    {
+        smb_message_destroy(msg);
+        goto error;
+    }
     smb_message_destroy(msg);
-    goto error;
-  }
-  smb_message_destroy(msg);
 
-  if (!smb_session_recv_msg(s, &answer))
-    goto error;
+    if (!smb_session_recv_msg(s, &answer))
+        goto error;
 
-  nego = (smb_nego_resp *)answer.packet->payload;
-  if (answer.packet->header.status != NT_STATUS_SUCCESS && nego->wct != 0x11)
-    goto error;
+    nego = (smb_nego_resp *)answer.packet->payload;
+    if (answer.packet->header.status != NT_STATUS_SUCCESS && nego->wct != 0x11)
+        goto error;
 
-  s->srv.dialect        = nego->dialect_index;
-  s->srv.security_mode  = nego->security_mode;
-  s->srv.caps           = nego->caps;
-  s->srv.ts             = nego->ts;
-  s->srv.session_key    = nego->session_key;
+    s->srv.dialect        = nego->dialect_index;
+    s->srv.security_mode  = nego->security_mode;
+    s->srv.caps           = nego->caps;
+    s->srv.ts             = nego->ts;
+    s->srv.session_key    = nego->session_key;
 
-  // Copy SPNEGO supported mechanisms  token for later usage (login_gss())
-  if (smb_session_supports(s, SMB_SESSION_XSEC))
-    BDSM_dbg("Server is supporting extended security\n");
-  else
-    s->srv.challenge      = nego->challenge;
+    // Copy SPNEGO supported mechanisms  token for later usage (login_gss())
+    if (smb_session_supports(s, SMB_SESSION_XSEC))
+        BDSM_dbg("Server is supporting extended security\n");
+    else
+        s->srv.challenge      = nego->challenge;
 
-  // Yeah !
-  s->state              = SMB_STATE_DIALECT_OK;
+    // Yeah !
+    s->state              = SMB_STATE_DIALECT_OK;
 
-  return (1);
+    return (1);
 
-  error:
+error:
     s->state = SMB_STATE_ERROR;
     return (0);
 }
 
 
 static int        smb_session_login_ntlm(smb_session *s, const char *domain,
-                                         const char *user, const char *password)
+        const char *user, const char *password)
 {
-  smb_message           answer;
-  smb_message           *msg = NULL;
-  smb_session_req       *req = NULL;
-  uint8_t               *ntlm2 = NULL;
-  smb_ntlmh             hash_v2;
-  uint64_t              user_challenge;
-  //uint8_t               blob[128];
-  //size_t                blob_size;
-
-  msg = smb_message_new(SMB_CMD_SETUP, 512);
-  smb_message_set_andx_members(msg);
-
-  req = (smb_session_req *)msg->packet->payload;
-  req->wct              = 13;
-  req->max_buffer       = SMB_SESSION_MAX_BUFFER;
-  req->mpx_count        = 16; // XXX ?
-  req->vc_count         = 1;
-  //req->session_key      = s->srv.session_key; // XXX Useless on the wire?
-  req->caps             = s->srv.caps; // XXX caps & our_caps_mask
-
-  smb_message_advance(msg, sizeof(smb_session_req));
-
-  user_challenge = smb_ntlm_generate_challenge();
-
-  // LM2 Response
-  smb_ntlm2_hash(user, password, domain, &hash_v2);
-  ntlm2 = smb_lm2_response(&hash_v2, s->srv.challenge, user_challenge);
-  smb_message_append(msg, ntlm2, 16 + 8);
-  free(ntlm2);
-
-  // NTLM2 Response (Win7 unsupported, replaced by extended security)
-  // blob_size = smb_ntlm_make_blob((smb_ntlm_blob *)blob, s->srv.ts,
-  //                                user_challenge, domain);
-  // ntlm2 = smb_ntlm2_response(&hash_v2, s->srv.challenge, blob, blob_size);
-  // smb_message_append(msg, ntlm2, 16 + blob_size);
-  // free(ntlm2);
-
-  req->oem_pass_len = 16 + SMB_LM2_BLOB_SIZE;
-  req->uni_pass_len = 0; //16 + blob_size; //SMB_NTLM2_BLOB_SIZE;
-  if (msg->cursor / 2) // Padding !
-    smb_message_put8(msg, 0);
-
-  smb_message_put_utf16(msg, user, strlen(user));
-  smb_message_put16(msg, 0);
-  smb_message_put_utf16(msg, domain, strlen(domain));
-  smb_message_put16(msg, 0);
-  smb_message_put_utf16(msg, SMB_OS, strlen(SMB_OS));
-  smb_message_put16(msg, 0);
-  smb_message_put_utf16(msg, SMB_LANMAN, strlen(SMB_LANMAN));
-  smb_message_put16(msg, 0);
-
-  req->payload_size = msg->cursor - sizeof(smb_session_req);
-
-  if (!smb_session_send_msg(s, msg))
-  {
+    smb_message           answer;
+    smb_message           *msg = NULL;
+    smb_session_req       *req = NULL;
+    uint8_t               *ntlm2 = NULL;
+    smb_ntlmh             hash_v2;
+    uint64_t              user_challenge;
+    //uint8_t               blob[128];
+    //size_t                blob_size;
+
+    msg = smb_message_new(SMB_CMD_SETUP, 512);
+    smb_message_set_andx_members(msg);
+
+    req = (smb_session_req *)msg->packet->payload;
+    req->wct              = 13;
+    req->max_buffer       = SMB_SESSION_MAX_BUFFER;
+    req->mpx_count        = 16; // XXX ?
+    req->vc_count         = 1;
+    //req->session_key      = s->srv.session_key; // XXX Useless on the wire?
+    req->caps             = s->srv.caps; // XXX caps & our_caps_mask
+
+    smb_message_advance(msg, sizeof(smb_session_req));
+
+    user_challenge = smb_ntlm_generate_challenge();
+
+    // LM2 Response
+    smb_ntlm2_hash(user, password, domain, &hash_v2);
+    ntlm2 = smb_lm2_response(&hash_v2, s->srv.challenge, user_challenge);
+    smb_message_append(msg, ntlm2, 16 + 8);
+    free(ntlm2);
+
+    // NTLM2 Response (Win7 unsupported, replaced by extended security)
+    // blob_size = smb_ntlm_make_blob((smb_ntlm_blob *)blob, s->srv.ts,
+    //                                user_challenge, domain);
+    // ntlm2 = smb_ntlm2_response(&hash_v2, s->srv.challenge, blob, blob_size);
+    // smb_message_append(msg, ntlm2, 16 + blob_size);
+    // free(ntlm2);
+
+    req->oem_pass_len = 16 + SMB_LM2_BLOB_SIZE;
+    req->uni_pass_len = 0; //16 + blob_size; //SMB_NTLM2_BLOB_SIZE;
+    if (msg->cursor / 2) // Padding !
+        smb_message_put8(msg, 0);
+
+    smb_message_put_utf16(msg, user, strlen(user));
+    smb_message_put16(msg, 0);
+    smb_message_put_utf16(msg, domain, strlen(domain));
+    smb_message_put16(msg, 0);
+    smb_message_put_utf16(msg, SMB_OS, strlen(SMB_OS));
+    smb_message_put16(msg, 0);
+    smb_message_put_utf16(msg, SMB_LANMAN, strlen(SMB_LANMAN));
+    smb_message_put16(msg, 0);
+
+    req->payload_size = msg->cursor - sizeof(smb_session_req);
+
+    if (!smb_session_send_msg(s, msg))
+    {
+        smb_message_destroy(msg);
+        BDSM_dbg("Unable to send Session Setup AndX message\n");
+        return (0);
+    }
     smb_message_destroy(msg);
-    BDSM_dbg("Unable to send Session Setup AndX message\n");
-    return (0);
-  }
-  smb_message_destroy(msg);
 
-  if (smb_session_recv_msg(s, &answer) == 0)
-  {
-    BDSM_dbg("Unable to get Session Setup AndX reply\n");
-    return (0);
-  }
+    if (smb_session_recv_msg(s, &answer) == 0)
+    {
+        BDSM_dbg("Unable to get Session Setup AndX reply\n");
+        return (0);
+    }
 
-  smb_session_resp *r = (smb_session_resp *)answer.packet->payload;
-  if (answer.packet->header.status != NT_STATUS_SUCCESS)
-  {
-    BDSM_dbg("Session Setup AndX : failure.\n");
-    return (0);
-  }
+    smb_session_resp *r = (smb_session_resp *)answer.packet->payload;
+    if (answer.packet->header.status != NT_STATUS_SUCCESS)
+    {
+        BDSM_dbg("Session Setup AndX : failure.\n");
+        return (0);
+    }
 
-  if (r->action & 0x0001)
-    s->guest = true;
+    if (r->action & 0x0001)
+        s->guest = true;
 
-  s->srv.uid  = answer.packet->header.uid;
-  s->state    = SMB_STATE_SESSION_OK;
+    s->srv.uid  = answer.packet->header.uid;
+    s->state    = SMB_STATE_SESSION_OK;
 
-  return (1);
+    return (1);
 }
 
 int             smb_session_login(smb_session *s)
 {
-  assert(s != NULL);
-
-  if (smb_session_supports(s, SMB_SESSION_XSEC))
-    return(smb_session_login_spnego(s, s->creds.domain, s->creds.login,
-                                    s->creds.password));
-  else
-    return(smb_session_login_ntlm(s, s->creds.domain, s->creds.login,
-                                  s->creds.password));
+    assert(s != NULL);
+
+    if (smb_session_supports(s, SMB_SESSION_XSEC))
+        return (smb_session_login_spnego(s, s->creds.domain, s->creds.login,
+                                         s->creds.password));
+    else
+        return (smb_session_login_ntlm(s, s->creds.domain, s->creds.login,
+                                       s->creds.password));
 }
 
 
 int             smb_session_is_guest(smb_session *s)
 {
-  // Invalid session object
-  if (s == NULL)
-    return (-1);
+    // Invalid session object
+    if (s == NULL)
+        return (-1);
 
-  // We're not logged in yet.
-  if (smb_session_state(s) != SMB_STATE_SESSION_OK)
-    return (-1);
+    // We're not logged in yet.
+    if (smb_session_state(s) != SMB_STATE_SESSION_OK)
+        return (-1);
 
-  // We're logged in as guest
-  if (s->guest)
-    return (1);
+    // We're logged in as guest
+    if (s->guest)
+        return (1);
 
-  // We're logged in as regular user
-  return (0);
+    // We're logged in as regular user
+    return (0);
 }
 
 const char      *smb_session_server_name(smb_session *s)
 {
-  if (s == NULL)
-    return (NULL);
-  else
-    return (s->srv.name);
+    if (s == NULL)
+        return (NULL);
+    else
+        return (s->srv.name);
 }
 
 int             smb_session_supports(smb_session *s, int what)
 {
-  if (s == NULL)
-    return (0);
+    if (s == NULL)
+        return (0);
 
-  switch (what)
-  {
-    case SMB_SESSION_XSEC:
-      return (s->srv.caps & SMB_CAPS_XSEC);
-    default:
-      return (0);
-  }
+    switch (what)
+    {
+        case SMB_SESSION_XSEC:
+            return (s->srv.caps & SMB_CAPS_XSEC);
+        default:
+            return (0);
+    }
 }

src/smb_session_msg.c

@@ -22,45 +22,45 @@
 
 int             smb_session_send_msg(smb_session *s, smb_message *msg)
 {
-  size_t        pkt_sz;
+    size_t        pkt_sz;
 
-  assert(s != NULL && s->state >= SMB_STATE_NETBIOS_OK);
-  assert(s->transport.session != NULL);
-  assert(msg != NULL && msg->packet != NULL);
+    assert(s != NULL && s->state >= SMB_STATE_NETBIOS_OK);
+    assert(s->transport.session != NULL);
+    assert(msg != NULL && msg->packet != NULL);
 
-  msg->packet->header.flags   = 0x18;
-  msg->packet->header.flags2  = 0xc843;
-  // msg->packet->header.flags2  = 0xc043; // w/o extended security;
-  msg->packet->header.uid = s->srv.uid;
+    msg->packet->header.flags   = 0x18;
+    msg->packet->header.flags2  = 0xc843;
+    // msg->packet->header.flags2  = 0xc043; // w/o extended security;
+    msg->packet->header.uid = s->srv.uid;
 
-  s->transport.pkt_init(s->transport.session);
+    s->transport.pkt_init(s->transport.session);
 
-  pkt_sz = sizeof(smb_packet) + msg->cursor;
-  if (!s->transport.pkt_append(s->transport.session, (void *)msg->packet, pkt_sz))
-    return (0);
-  if (!s->transport.send(s->transport.session))
-    return (0);
+    pkt_sz = sizeof(smb_packet) + msg->cursor;
+    if (!s->transport.pkt_append(s->transport.session, (void *)msg->packet, pkt_sz))
+        return (0);
+    if (!s->transport.send(s->transport.session))
+        return (0);
 
-  return (1);
+    return (1);
 }
 
 ssize_t         smb_session_recv_msg(smb_session *s, smb_message *msg)
 {
-  void                      *data;
-  ssize_t                   payload_size;
+    void                      *data;
+    ssize_t                   payload_size;
 
-  assert(s != NULL && s->transport.session != NULL);
+    assert(s != NULL && s->transport.session != NULL);
 
-  payload_size = s->transport.recv(s->transport.session, &data);
-  if(payload_size <= 0)
-    return (0);
+    payload_size = s->transport.recv(s->transport.session, &data);
+    if (payload_size <= 0)
+        return (0);
 
-  if (msg != NULL)
-  {
-    msg->packet = (smb_packet *)data;
-    msg->payload_size = payload_size - sizeof(smb_header);
-    msg->cursor       = 0;
-  }
+    if (msg != NULL)
+    {
+        msg->packet = (smb_packet *)data;
+        msg->payload_size = payload_size - sizeof(smb_header);
+        msg->cursor       = 0;
+    }
 
-  return (payload_size - sizeof(smb_header));
+    return (payload_size - sizeof(smb_header));
 }

src/smb_share.c

@@ -32,138 +32,138 @@
 
 smb_tid         smb_tree_connect(smb_session *s, const char *name)
 {
-  smb_tree_connect_req  *req;
-  smb_tree_connect_resp *resp;
-  smb_message   resp_msg;
-  smb_message   *req_msg;
-  smb_share     *share;
-  size_t          path_len;
-  char            *path;
-
-  assert(s != NULL && name != NULL);
-
-  // Build \\SERVER\Share path from name
-  path_len  = strlen(name) + strlen(s->srv.name) + 4;
-  path      = alloca(path_len);
-  snprintf(path, path_len, "\\\\%s\\%s", s->srv.name, name);
-
-  req_msg = smb_message_new(SMB_CMD_TREE_CONNECT, 128);
-
-  // Packet headers
-  smb_message_set_andx_members(req_msg);
-  req_msg->packet->header.tid   = 0xffff; // Behavior of libsmbclient
-
-  // Packet payload
-  req = (smb_tree_connect_req *)req_msg->packet->payload;
-  smb_message_advance(req_msg, sizeof(smb_tree_connect_req));
-  req->wct          = 4;
-  req->flags        = 0x0c; // (??)
-  req->passwd_len   = 1;    // Null byte
-
-  smb_message_put8(req_msg, 0); // Ze null byte password;
-  smb_message_put_utf16(req_msg, path, strlen(path) + 1);
-  smb_message_append(req_msg, "?????", strlen("?????") + 1);
-  req->bct = strlen(path) * 2 + 2 + 6 + 1;
-
-  if (!smb_session_send_msg(s, req_msg))
-  {
+    smb_tree_connect_req  *req;
+    smb_tree_connect_resp *resp;
+    smb_message   resp_msg;
+    smb_message   *req_msg;
+    smb_share     *share;
+    size_t          path_len;
+    char            *path;
+
+    assert(s != NULL && name != NULL);
+
+    // Build \\SERVER\Share path from name
+    path_len  = strlen(name) + strlen(s->srv.name) + 4;
+    path      = alloca(path_len);
+    snprintf(path, path_len, "\\\\%s\\%s", s->srv.name, name);
+
+    req_msg = smb_message_new(SMB_CMD_TREE_CONNECT, 128);
+
+    // Packet headers
+    smb_message_set_andx_members(req_msg);
+    req_msg->packet->header.tid   = 0xffff; // Behavior of libsmbclient
+
+    // Packet payload
+    req = (smb_tree_connect_req *)req_msg->packet->payload;
+    smb_message_advance(req_msg, sizeof(smb_tree_connect_req));
+    req->wct          = 4;
+    req->flags        = 0x0c; // (??)
+    req->passwd_len   = 1;    // Null byte
+
+    smb_message_put8(req_msg, 0); // Ze null byte password;
+    smb_message_put_utf16(req_msg, path, strlen(path) + 1);
+    smb_message_append(req_msg, "?????", strlen("?????") + 1);
+    req->bct = strlen(path) * 2 + 2 + 6 + 1;
+
+    if (!smb_session_send_msg(s, req_msg))
+    {
+        smb_message_destroy(req_msg);
+        return (0);
+    }
     smb_message_destroy(req_msg);
-    return (0);
-  }
-  smb_message_destroy(req_msg);
 
-  if (!smb_session_recv_msg(s, &resp_msg))
-    return (0);
-  if (resp_msg.packet->header.status != NT_STATUS_SUCCESS)
-    return (0);
+    if (!smb_session_recv_msg(s, &resp_msg))
+        return (0);
+    if (resp_msg.packet->header.status != NT_STATUS_SUCCESS)
+        return (0);
 
-  resp  = (smb_tree_connect_resp *)resp_msg.packet->payload;
-  share = calloc(1, sizeof(smb_share));
-  assert(share != NULL);
+    resp  = (smb_tree_connect_resp *)resp_msg.packet->payload;
+    share = calloc(1, sizeof(smb_share));
+    assert(share != NULL);
 
-  share->tid          = resp_msg.packet->header.tid;
-  share->opts         = resp->opt_support;
-  share->rights       = resp->max_rights;
-  share->guest_rights = resp->guest_rights;
+    share->tid          = resp_msg.packet->header.tid;
+    share->opts         = resp->opt_support;
+    share->rights       = resp->max_rights;
+    share->guest_rights = resp->guest_rights;
 
-  smb_session_share_add(s, share);
+    smb_session_share_add(s, share);
 
-  return(share->tid);
+    return (share->tid);
 }
 
 int           smb_tree_disconnect(smb_session *s, smb_tid tid)
 {
-  assert(s != NULL && tid);
-  BDSM_dbg("smb_tree_disconnect: NOT IMPLEMENTED YET\n");
-  return (0);
+    assert(s != NULL && tid);
+    BDSM_dbg("smb_tree_disconnect: NOT IMPLEMENTED YET\n");
+    return (0);
 }
 
 // Here we parse the NetShareEnumAll response packet payload to extract
 // The share list.
 static size_t   smb_share_parse_enum(smb_message *msg, char ***list)
 {
-  uint32_t          share_count, i;
-  uint8_t           *data, *eod;
+    uint32_t          share_count, i;
+    uint8_t           *data, *eod;
 
-  assert(msg != NULL && list != NULL);
-  // Let's skip smb parameters and DCE/RPC stuff until we are at the begginning of
-  // NetShareCtrl
+    assert(msg != NULL && list != NULL);
+    // Let's skip smb parameters and DCE/RPC stuff until we are at the begginning of
+    // NetShareCtrl
 
-  share_count = *((uint32_t *)(msg->packet->payload + 60));
-  data        = msg->packet->payload + 72 + share_count * 12;
-  eod         = msg->packet->payload + msg->payload_size;
+    share_count = *((uint32_t *)(msg->packet->payload + 60));
+    data        = msg->packet->payload + 72 + share_count * 12;
+    eod         = msg->packet->payload + msg->payload_size;
 
-  *list       = calloc(share_count + 1, sizeof(char *));
-  assert(*list != NULL);
+    *list       = calloc(share_count + 1, sizeof(char *));
+    assert(*list != NULL);
 
-  for (i = 0; i < share_count && data < eod; i++)
-  {
-    uint32_t name_len, com_len;
+    for (i = 0; i < share_count && data < eod; i++)
+    {
+        uint32_t name_len, com_len;
 
-    name_len = *((uint32_t *)data);   // Read 'Max Count', make it a multiple of 2
-    data    += 3 * sizeof(uint32_t);  // Move pointer to beginning of Name.
+        name_len = *((uint32_t *)data);   // Read 'Max Count', make it a multiple of 2
+        data    += 3 * sizeof(uint32_t);  // Move pointer to beginning of Name.
 
-    smb_from_utf16((const char *)data, name_len * 2, (*list) + i);
+        smb_from_utf16((const char *)data, name_len * 2, (*list) + i);
 
-    if (name_len % 2) name_len += 1;  // Align next move
-    data    += name_len * 2;          // Move the pointer to Comment 'Max count'
+        if (name_len % 2) name_len += 1;  // Align next move
+        data    += name_len * 2;          // Move the pointer to Comment 'Max count'
 
-    com_len  = *((uint32_t *)data);
-    data    += 3 * sizeof(uint32_t);  // Move pointer to beginning of Comment.
-    if (com_len % 2) com_len += 1;    // Align next move
-    data    += com_len * 2;           // Move the pointer to next item
-  }
+        com_len  = *((uint32_t *)data);
+        data    += 3 * sizeof(uint32_t);  // Move pointer to beginning of Comment.
+        if (com_len % 2) com_len += 1;    // Align next move
+        data    += com_len * 2;           // Move the pointer to next item
+    }
 
-  return (i);
+    return (i);
 }
 
 size_t          smb_share_list_count(smb_share_list list)
 {
-  size_t        res;
+    size_t        res;
 
-  if (list == NULL)
-    return (0);
+    if (list == NULL)
+        return (0);
 
-  for(res = 0; list[res] != NULL; res++)
-    ;
+    for (res = 0; list[res] != NULL; res++)
+        ;
 
-  return (res);
+    return (res);
 }
 
 const char      *smb_share_list_at(smb_share_list list, size_t index)
 {
-  assert (list != NULL);
+    assert(list != NULL);
 
-  return (list[index]);
+    return (list[index]);
 }
 
 void            smb_share_list_destroy(smb_share_list list)
 {
-  assert(list != NULL);
+    assert(list != NULL);
 
-  for (size_t i = 0; list[i] != NULL; i++)
-    free(list[i]);
-  free(list);
+    for (size_t i = 0; list[i] != NULL; i++)
+        free(list[i]);
+    free(list);
 }
 
 // We should normally implement SCERPC and SRVSVC to perform a share list. But
@@ -171,185 +171,185 @@ void            smb_share_list_destroy(smb_share_list list)
 // PS: Worst function _EVER_. I don't understand a bit myself
 size_t          smb_share_get_list(smb_session *s, char ***list)
 {
-  smb_message           *req, resp;
-  smb_trans_req         *trans;
-  smb_tid               ipc_tid;
-  smb_fd                srvscv_fd;
-  uint16_t              rpc_len;
-  ssize_t               res, frag_len_cursor;
-
-
-  assert(s != NULL && list != NULL);
-  *list = NULL;
-
-  ipc_tid = smb_tree_connect(s, "IPC$");
-  if (!ipc_tid)
-    return (0);
-
-  srvscv_fd = smb_fopen(s, ipc_tid, "\\srvsvc", SMB_MOD_RW);
-  if (!srvscv_fd)
-    return (0);
-
-  //// Phase 1:
-  // We bind a context or whatever for DCE/RPC
-
-  req = smb_message_new(SMD_CMD_TRANS, 256);
-  req->packet->header.tid = ipc_tid;
-
-  smb_message_advance(req, sizeof(smb_trans_req));
-  trans = (smb_trans_req *)req->packet->payload;
-
-  memset((void *)trans, 0, sizeof(smb_trans_req));
-
-  rpc_len = SMB_IO_BUFSIZE - 256; // XXX
-
-  trans->wct                    = 16;
-  trans->total_data_count       = 72;
-  trans->max_data_count         = rpc_len;
-  trans->param_offset           = 84;
-  trans->data_count             = 72;
-  trans->data_offset            = 84;
-  trans->setup_count            = 2;
-  trans->pipe_function          = 0x26;
-  trans->fid                    = SMB_FD_FID(srvscv_fd);
-  trans->bct                    = 89;
-
-  smb_message_put8(req, 0);   // Padding
-  smb_message_put_utf16(req, "\\PIPE\\", strlen("\\PIPE\\") + 1);
-  smb_message_put16(req, 0);  // Padding to be aligned with wtf boundary :-/
-
-  // Now we'll 'build' the DCE/RPC Packet. This basically a copycat
-  // from wireshark values.
-  smb_message_put8(req, 5);     // version major
-  smb_message_put8(req, 0);     // minor
-  smb_message_put8(req, 0x0b);  // Packet type = 'bind'
-  smb_message_put8(req, 0x03);  // Packet flags = ??
-  smb_message_put32(req, 0x10); // Representation = little endian/ASCII. Damn
-  smb_message_put16(req, 72);   // Data len again
-  smb_message_put16(req, 0);    // Auth len ?
-  smb_message_put32(req, 19);   // Call ID ?
-  smb_message_put16(req, rpc_len);      // Max Xmit size
-  smb_message_put16(req, rpc_len);      // Max Recv size
-  smb_message_put32(req, 0);    // Assoc group ?
-
-  smb_message_put32(req, 1);    // Num Ctx Item
-  // Adding the CtxItem, whatever could that be
-  smb_message_put16(req, 0);    // ContextID
-  smb_message_put16(req, 1);    // Num Trans Item
-  // SRVSVC UUID
-  const uint8_t uuid_e[8] = {0x12, 0x78, 0x5a, 0x47, 0xbf, 0x6e, 0xe1, 0x88};
-  smb_message_put_uuid(req, 0x4b324fc8, 0x1670, 0x01d3, uuid_e);
-  smb_message_put16(req, 3);    // Version
-  smb_message_put16(req, 0);    // Minor
-  // Another UUID
-  const uint8_t uuid_e2[8] = {0x9f, 0xe8, 0x08, 0x00, 0x2b, 0x10, 0x48, 0x60};
-  smb_message_put_uuid(req, 0x8a885d04, 0x1ceb, 0x11c9, uuid_e2);
-  smb_message_put32(req, 2);    // Another version
-
-  // Let's send this ugly pile of shit over the network !
-  res = smb_session_send_msg(s, req);
-  smb_message_destroy(req);
-  if (!res)
-    return (0);
-
-  // Is the server throwing pile of shit back at me ?
-  res = smb_session_recv_msg(s, &resp);
-  if (!res || resp.packet->payload[68])
-  {
-    BDSM_dbg("Bind call failed: 0x%hhx (reason = 0x%hhx)\n",
-            resp.packet->payload[68], resp.packet->payload[70]);
-    return (0);
-  }
-
-
-  //// Phase 2:
-  // Now we have the 'bind' done (regarless of what it is), we'll call
-  // NetShareEnumAll
-
-  req = smb_message_new(SMD_CMD_TRANS, 256);
-  req->packet->header.tid = ipc_tid;
-
-  smb_message_advance(req, sizeof(smb_trans_req));
-  trans = (smb_trans_req *)req->packet->payload;
-
-  memset((void *)trans, 0, sizeof(smb_trans_req));
-
-  trans->wct              = 16;
-  trans->max_data_count   = 4280;
-  trans->setup_count      = 2;
-  trans->pipe_function    = 0x26; // TransactNmPipe;
-  trans->fid              = SMB_FD_FID(srvscv_fd);
-
-  smb_message_put8(req, 0);  // Padding
-  smb_message_put_utf16(req, "\\PIPE\\", strlen("\\PIPE\\") + 1);
-  smb_message_put16(req, 0); // Padding
-
-  // Now we'll 'build' the DCE/RPC Packet. This basically a copycat
-  // from wireshark values.
-  smb_message_put8(req, 5);     // version major
-  smb_message_put8(req, 0);     // minor
-  smb_message_put8(req, 0);     // Packet type = 'request'
-  smb_message_put8(req, 0x03);  // Packet flags = ??
-  smb_message_put32(req, 0x10); // Representation = little endian/ASCII. Damn
-  // Let's save the cursor here to update that later
-  frag_len_cursor = req->cursor;
-  smb_message_put16(req, 0);    // Data len again (frag length)
-  smb_message_put16(req, 0);    // Auth len ?
-  smb_message_put32(req, 12);   // Call ID ?
-  smb_message_put32(req, 64);   // Alloc hint ?
-  smb_message_put16(req, 0);    // Context ID ?
-  smb_message_put16(req, 15);   // OpNum = NetShareEnumAll
-
-  // Pointer to server UNC
-  smb_message_put32(req, 0x00020000);   // Referent ID ?
-  smb_message_put32(req, strlen(s->srv.name) + 1);            // Max count
-  smb_message_put32(req, 0);            // Offset
-  smb_message_put32(req, strlen(s->srv.name) + 1);            // Actual count
+    smb_message           *req, resp;
+    smb_trans_req         *trans;
+    smb_tid               ipc_tid;
+    smb_fd                srvscv_fd;
+    uint16_t              rpc_len;
+    ssize_t               res, frag_len_cursor;
+
+
+    assert(s != NULL && list != NULL);
+    *list = NULL;
+
+    ipc_tid = smb_tree_connect(s, "IPC$");
+    if (!ipc_tid)
+        return (0);
+
+    srvscv_fd = smb_fopen(s, ipc_tid, "\\srvsvc", SMB_MOD_RW);
+    if (!srvscv_fd)
+        return (0);
+
+    //// Phase 1:
+    // We bind a context or whatever for DCE/RPC
+
+    req = smb_message_new(SMD_CMD_TRANS, 256);
+    req->packet->header.tid = ipc_tid;
+
+    smb_message_advance(req, sizeof(smb_trans_req));
+    trans = (smb_trans_req *)req->packet->payload;
+
+    memset((void *)trans, 0, sizeof(smb_trans_req));
+
+    rpc_len = SMB_IO_BUFSIZE - 256; // XXX
+
+    trans->wct                    = 16;
+    trans->total_data_count       = 72;
+    trans->max_data_count         = rpc_len;
+    trans->param_offset           = 84;
+    trans->data_count             = 72;
+    trans->data_offset            = 84;
+    trans->setup_count            = 2;
+    trans->pipe_function          = 0x26;
+    trans->fid                    = SMB_FD_FID(srvscv_fd);
+    trans->bct                    = 89;
+
+    smb_message_put8(req, 0);   // Padding
+    smb_message_put_utf16(req, "\\PIPE\\", strlen("\\PIPE\\") + 1);
+    smb_message_put16(req, 0);  // Padding to be aligned with wtf boundary :-/
+
+    // Now we'll 'build' the DCE/RPC Packet. This basically a copycat
+    // from wireshark values.
+    smb_message_put8(req, 5);     // version major
+    smb_message_put8(req, 0);     // minor
+    smb_message_put8(req, 0x0b);  // Packet type = 'bind'
+    smb_message_put8(req, 0x03);  // Packet flags = ??
+    smb_message_put32(req, 0x10); // Representation = little endian/ASCII. Damn
+    smb_message_put16(req, 72);   // Data len again
+    smb_message_put16(req, 0);    // Auth len ?
+    smb_message_put32(req, 19);   // Call ID ?
+    smb_message_put16(req, rpc_len);      // Max Xmit size
+    smb_message_put16(req, rpc_len);      // Max Recv size
+    smb_message_put32(req, 0);    // Assoc group ?
+
+    smb_message_put32(req, 1);    // Num Ctx Item
+    // Adding the CtxItem, whatever could that be
+    smb_message_put16(req, 0);    // ContextID
+    smb_message_put16(req, 1);    // Num Trans Item
+    // SRVSVC UUID
+    const uint8_t uuid_e[8] = {0x12, 0x78, 0x5a, 0x47, 0xbf, 0x6e, 0xe1, 0x88};
+    smb_message_put_uuid(req, 0x4b324fc8, 0x1670, 0x01d3, uuid_e);
+    smb_message_put16(req, 3);    // Version
+    smb_message_put16(req, 0);    // Minor
+    // Another UUID
+    const uint8_t uuid_e2[8] = {0x9f, 0xe8, 0x08, 0x00, 0x2b, 0x10, 0x48, 0x60};
+    smb_message_put_uuid(req, 0x8a885d04, 0x1ceb, 0x11c9, uuid_e2);
+    smb_message_put32(req, 2);    // Another version
+
+    // Let's send this ugly pile of shit over the network !
+    res = smb_session_send_msg(s, req);
+    smb_message_destroy(req);
+    if (!res)
+        return (0);
+
+    // Is the server throwing pile of shit back at me ?
+    res = smb_session_recv_msg(s, &resp);
+    if (!res || resp.packet->payload[68])
+    {
+        BDSM_dbg("Bind call failed: 0x%hhx (reason = 0x%hhx)\n",
+                 resp.packet->payload[68], resp.packet->payload[70]);
+        return (0);
+    }
+
+
+    //// Phase 2:
+    // Now we have the 'bind' done (regarless of what it is), we'll call
+    // NetShareEnumAll
+
+    req = smb_message_new(SMD_CMD_TRANS, 256);
+    req->packet->header.tid = ipc_tid;
+
+    smb_message_advance(req, sizeof(smb_trans_req));
+    trans = (smb_trans_req *)req->packet->payload;
+
+    memset((void *)trans, 0, sizeof(smb_trans_req));
+
+    trans->wct              = 16;
+    trans->max_data_count   = 4280;
+    trans->setup_count      = 2;
+    trans->pipe_function    = 0x26; // TransactNmPipe;
+    trans->fid              = SMB_FD_FID(srvscv_fd);
+
+    smb_message_put8(req, 0);  // Padding
+    smb_message_put_utf16(req, "\\PIPE\\", strlen("\\PIPE\\") + 1);
+    smb_message_put16(req, 0); // Padding
+
+    // Now we'll 'build' the DCE/RPC Packet. This basically a copycat
+    // from wireshark values.
+    smb_message_put8(req, 5);     // version major
+    smb_message_put8(req, 0);     // minor
+    smb_message_put8(req, 0);     // Packet type = 'request'
+    smb_message_put8(req, 0x03);  // Packet flags = ??
+    smb_message_put32(req, 0x10); // Representation = little endian/ASCII. Damn
+    // Let's save the cursor here to update that later
+    frag_len_cursor = req->cursor;
+    smb_message_put16(req, 0);    // Data len again (frag length)
+    smb_message_put16(req, 0);    // Auth len ?
+    smb_message_put32(req, 12);   // Call ID ?
+    smb_message_put32(req, 64);   // Alloc hint ?
+    smb_message_put16(req, 0);    // Context ID ?
+    smb_message_put16(req, 15);   // OpNum = NetShareEnumAll
+
+    // Pointer to server UNC
+    smb_message_put32(req, 0x00020000);   // Referent ID ?
+    smb_message_put32(req, strlen(s->srv.name) + 1);            // Max count
+    smb_message_put32(req, 0);            // Offset
+    smb_message_put32(req, strlen(s->srv.name) + 1);            // Actual count
     // The server name, supposed to be downcased
-  smb_message_put_utf16(req, s->srv.name, strlen(s->srv.name) + 1);
-  if ((strlen(s->srv.name) % 2) == 0) // It won't be aligned with the terminating byte
-    smb_message_put16(req, 0);
+    smb_message_put_utf16(req, s->srv.name, strlen(s->srv.name) + 1);
+    if ((strlen(s->srv.name) % 2) == 0) // It won't be aligned with the terminating byte
+        smb_message_put16(req, 0);
 
 
-  smb_message_put32(req, 1);            // Level 1 ?
-  smb_message_put32(req, 1);            // Ctr ?
-  smb_message_put32(req, 0x00020004);   // Referent ID ?
-  smb_message_put64(req, 0);            // Count/Null Pointer to NetShareInfo1
-  smb_message_put32(req, 0xffffffff);   // Max Buffer (0xffffffff required by smbX)
+    smb_message_put32(req, 1);            // Level 1 ?
+    smb_message_put32(req, 1);            // Ctr ?
+    smb_message_put32(req, 0x00020004);   // Referent ID ?
+    smb_message_put64(req, 0);            // Count/Null Pointer to NetShareInfo1
+    smb_message_put32(req, 0xffffffff);   // Max Buffer (0xffffffff required by smbX)
 
-  smb_message_put32(req, 0x00020008);   // Referent ID ?
-  smb_message_put32(req, 0);            // Resume ?
+    smb_message_put32(req, 0x00020008);   // Referent ID ?
+    smb_message_put32(req, 0);            // Resume ?
 
-  // Sets length values
-  trans->bct              = req->cursor - sizeof(smb_trans_req);
-  trans->data_count       = trans->bct - 17; // 17 -> padding + \PIPE\ + padding
-  trans->total_data_count = trans->data_count;
-  req->packet->payload[frag_len_cursor] = trans->data_count; // (data_count SHOULD stay < 256)
-  trans->data_offset      = 84;
-  trans->param_offset     = 84;
+    // Sets length values
+    trans->bct              = req->cursor - sizeof(smb_trans_req);
+    trans->data_count       = trans->bct - 17; // 17 -> padding + \PIPE\ + padding
+    trans->total_data_count = trans->data_count;
+    req->packet->payload[frag_len_cursor] = trans->data_count; // (data_count SHOULD stay < 256)
+    trans->data_offset      = 84;
+    trans->param_offset     = 84;
 
 
-  // Let's send this ugly pile of shit over the network !
-  res = smb_session_send_msg(s, req);
-  smb_message_destroy(req);
-  if (!res)
-    return (0);
+    // Let's send this ugly pile of shit over the network !
+    res = smb_session_send_msg(s, req);
+    smb_message_destroy(req);
+    if (!res)
+        return (0);
 
-  // Is the server throwing pile of shit back at me ?
-  res = smb_session_recv_msg(s, &resp);
-  if (!res && (uint32_t)resp.packet->payload[resp.payload_size - 4])
-  {
-    BDSM_dbg("NetShareEnumAll call failed.\n");
-    return (0);
-  }
+    // Is the server throwing pile of shit back at me ?
+    res = smb_session_recv_msg(s, &resp);
+    if (!res && (uint32_t)resp.packet->payload[resp.payload_size - 4])
+    {
+        BDSM_dbg("NetShareEnumAll call failed.\n");
+        return (0);
+    }
 
 
-  //// Phase 3
-  // We parse the list of Share (finally !) and build function response
-  res = smb_share_parse_enum(&resp, list);
+    //// Phase 3
+    // We parse the list of Share (finally !) and build function response
+    res = smb_share_parse_enum(&resp, list);
 
-  // Close the pipe
-  smb_fclose(s, srvscv_fd);
+    // Close the pipe
+    smb_fclose(s, srvscv_fd);
 
-  return (res);
+    return (res);
 }

src/smb_spnego.c

@@ -32,293 +32,293 @@ static const char ntlmssp_oid[] = "1.3.6.1.4.1.311.2.2.10";
 
 static void     asn1_display_error(const char *where, int errcode)
 {
-  BDSM_dbg("%s error: %s\n", where, asn1_strerror(errcode));
+    BDSM_dbg("%s error: %s\n", where, asn1_strerror(errcode));
 }
 
 static int      init_asn1(smb_session *s)
 {
-  int           res;
-
-  assert (s != NULL);
-
-  if (s->spnego_asn1 != NULL)
-    return (1);
-
-  res = asn1_array2tree(spnego_asn1_conf, &s->spnego_asn1, NULL);
-  if (res != ASN1_SUCCESS)
-  {
-    asn1_display_error("init_asn1", res);
-    return (0);
-  }
-  else
-  {
-    BDSM_dbg("init_asn1: ASN.1 parser initialized\n");
-    return (1);
-  }
+    int           res;
+
+    assert(s != NULL);
+
+    if (s->spnego_asn1 != NULL)
+        return (1);
+
+    res = asn1_array2tree(spnego_asn1_conf, &s->spnego_asn1, NULL);
+    if (res != ASN1_SUCCESS)
+    {
+        asn1_display_error("init_asn1", res);
+        return (0);
+    }
+    else
+    {
+        BDSM_dbg("init_asn1: ASN.1 parser initialized\n");
+        return (1);
+    }
 }
 
 static void     clean_asn1(smb_session *s)
 {
-  assert (s != NULL);
+    assert(s != NULL);
 
-  if (s->spnego_asn1 != NULL)
-    asn1_delete_structure(&s->spnego_asn1);
+    if (s->spnego_asn1 != NULL)
+        asn1_delete_structure(&s->spnego_asn1);
 }
 
 static int      negotiate(smb_session *s, const char *domain)
 {
-  smb_message           *msg = NULL;
-  smb_session_xsec_req  *req = NULL;
-  smb_buffer            ntlm;
-  ASN1_TYPE             token;
-  int                   res, der_size = 128;
-  char                  der[128], err_desc[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
-
-  msg = smb_message_new(SMB_CMD_SETUP, 512);
-  smb_message_set_andx_members(msg);
-  req = (smb_session_xsec_req *)msg->packet->payload;
-  //msg->packet->header.mux_id  = 1;
-
-  req->wct              = 12;
-  req->max_buffer       = SMB_SESSION_MAX_BUFFER;
-  req->mpx_count        = 16; // XXX ?
-  req->vc_count         = 1;
-  req->caps             = s->srv.caps; // XXX caps & our_caps_mask
-  req->session_key      = s->srv.session_key;
-
-  smb_message_advance(msg, sizeof(smb_session_xsec_req));
-
-
-  asn1_create_element(s->spnego_asn1, "SPNEGO.GSSAPIContextToken", &token);
-
-  res = asn1_write_value(token, "thisMech", spnego_oid, 1);
-  if (res != ASN1_SUCCESS) goto error;
-  res = asn1_write_value(token, "spnego", "negTokenInit", 1);
-  if (res != ASN1_SUCCESS) goto error;
-  res = asn1_write_value(token, "spnego.negTokenInit.mechTypes", "NEW", 1);
-  if (res != ASN1_SUCCESS) goto error;
-  res = asn1_write_value(token, "spnego.negTokenInit.mechTypes.?1", ntlmssp_oid, 1);
-  if (res != ASN1_SUCCESS) goto error;
-  res = asn1_write_value(token, "spnego.negTokenInit.reqFlags", NULL, 0);
-  if (res != ASN1_SUCCESS) goto error;
-  res = asn1_write_value(token, "spnego.negTokenInit.mechListMIC", NULL, 0);
-  if (res != ASN1_SUCCESS) goto error;
-
-  smb_ntlmssp_negotiate(domain, domain, &ntlm);
-  res = asn1_write_value(token, "spnego.negTokenInit.mechToken", ntlm.data,
-                         ntlm.size);
-  smb_buffer_free(&ntlm);
-  if (res != ASN1_SUCCESS) goto error;
-
-  res = asn1_der_coding(token, "", der, &der_size, err_desc);
-  if (res != ASN1_SUCCESS)
-  {
-    smb_message_destroy(msg);
-    BDSM_dbg("Encoding error: %s", err_desc);
-    return (0);
-  }
-
-  smb_message_append(msg, der, der_size);
-  smb_message_put_utf16(msg, SMB_OS, strlen(SMB_OS));
-  smb_message_put16(msg, 0);
-  smb_message_put_utf16(msg, SMB_LANMAN, strlen(SMB_LANMAN));
-  smb_message_put16(msg, 0);
-  smb_message_put16(msg, 0);
+    smb_message           *msg = NULL;
+    smb_session_xsec_req  *req = NULL;
+    smb_buffer            ntlm;
+    ASN1_TYPE             token;
+    int                   res, der_size = 128;
+    char                  der[128], err_desc[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
+
+    msg = smb_message_new(SMB_CMD_SETUP, 512);
+    smb_message_set_andx_members(msg);
+    req = (smb_session_xsec_req *)msg->packet->payload;
+    //msg->packet->header.mux_id  = 1;
+
+    req->wct              = 12;
+    req->max_buffer       = SMB_SESSION_MAX_BUFFER;
+    req->mpx_count        = 16; // XXX ?
+    req->vc_count         = 1;
+    req->caps             = s->srv.caps; // XXX caps & our_caps_mask
+    req->session_key      = s->srv.session_key;
+
+    smb_message_advance(msg, sizeof(smb_session_xsec_req));
+
+
+    asn1_create_element(s->spnego_asn1, "SPNEGO.GSSAPIContextToken", &token);
+
+    res = asn1_write_value(token, "thisMech", spnego_oid, 1);
+    if (res != ASN1_SUCCESS) goto error;
+    res = asn1_write_value(token, "spnego", "negTokenInit", 1);
+    if (res != ASN1_SUCCESS) goto error;
+    res = asn1_write_value(token, "spnego.negTokenInit.mechTypes", "NEW", 1);
+    if (res != ASN1_SUCCESS) goto error;
+    res = asn1_write_value(token, "spnego.negTokenInit.mechTypes.?1", ntlmssp_oid, 1);
+    if (res != ASN1_SUCCESS) goto error;
+    res = asn1_write_value(token, "spnego.negTokenInit.reqFlags", NULL, 0);
+    if (res != ASN1_SUCCESS) goto error;
+    res = asn1_write_value(token, "spnego.negTokenInit.mechListMIC", NULL, 0);
+    if (res != ASN1_SUCCESS) goto error;
+
+    smb_ntlmssp_negotiate(domain, domain, &ntlm);
+    res = asn1_write_value(token, "spnego.negTokenInit.mechToken", ntlm.data,
+                           ntlm.size);
+    smb_buffer_free(&ntlm);
+    if (res != ASN1_SUCCESS) goto error;
+
+    res = asn1_der_coding(token, "", der, &der_size, err_desc);
+    if (res != ASN1_SUCCESS)
+    {
+        smb_message_destroy(msg);
+        BDSM_dbg("Encoding error: %s", err_desc);
+        return (0);
+    }
+
+    smb_message_append(msg, der, der_size);
+    smb_message_put_utf16(msg, SMB_OS, strlen(SMB_OS));
+    smb_message_put16(msg, 0);
+    smb_message_put_utf16(msg, SMB_LANMAN, strlen(SMB_LANMAN));
+    smb_message_put16(msg, 0);
+    smb_message_put16(msg, 0);
+
+    req->xsec_blob_size = der_size;
+    req->payload_size   = msg->cursor - sizeof(smb_session_xsec_req);
 
-  req->xsec_blob_size = der_size;
-  req->payload_size   = msg->cursor - sizeof(smb_session_xsec_req);
+    asn1_delete_structure(&token);
 
-  asn1_delete_structure(&token);
+    if (!smb_session_send_msg(s, msg))
+    {
+        smb_message_destroy(msg);
+        BDSM_dbg("Unable to send Session Setup AndX (NTLMSSP_NEGOTIATE) message\n");
+        return (0);
+    }
 
-  if (!smb_session_send_msg(s, msg))
-  {
     smb_message_destroy(msg);
-    BDSM_dbg("Unable to send Session Setup AndX (NTLMSSP_NEGOTIATE) message\n");
-    return (0);
-  }
-
-  smb_message_destroy(msg);
-  return (1);
+    return (1);
 
-  error:
+error:
     asn1_display_error("smb_session_login negotiate()", res);
     smb_message_destroy(msg);
-    return(0);
+    return (0);
 }
 
 static int      challenge(smb_session *s)
 {
-  char                  err_desc[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
-  char                  resp_token[256];
-  smb_message           msg;
-  smb_session_xsec_resp *resp;
-  smb_ntlmssp_challenge *challenge;
-  ASN1_TYPE             token;
-  int                   res, resp_token_size = 256;
-
-  assert (s != NULL);
-
-  if (smb_session_recv_msg(s, &msg) == 0)
-  {
-    BDSM_dbg("spnego challenge(): Unable to receive message\n");
-    return (0);
-  }
-
-  if (msg.packet->header.status != NT_STATUS_MORE_PROCESSING_REQUIRED)
-  {
-    BDSM_dbg("spnego challenge(): Bad status (0x%x)\n",
-             msg.packet->header.status);
-    return (0);
-  }
-
-  resp = (smb_session_xsec_resp *)msg.packet->payload;
-
-  asn1_create_element(s->spnego_asn1, "SPNEGO.NegotiationToken", &token);
-  res = asn1_der_decoding(&token, resp->payload, resp->xsec_blob_size,
-                          err_desc);
-  if (res != ASN1_SUCCESS)
-  {
-    asn1_delete_structure(&token);
-    asn1_display_error("NegTokenResp parsing", res);
-    BDSM_dbg("Parsing error detail: %s\n", err_desc);
-    return (0);
-  }
+    char                  err_desc[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
+    char                  resp_token[256];
+    smb_message           msg;
+    smb_session_xsec_resp *resp;
+    smb_ntlmssp_challenge *challenge;
+    ASN1_TYPE             token;
+    int                   res, resp_token_size = 256;
+
+    assert(s != NULL);
+
+    if (smb_session_recv_msg(s, &msg) == 0)
+    {
+        BDSM_dbg("spnego challenge(): Unable to receive message\n");
+        return (0);
+    }
+
+    if (msg.packet->header.status != NT_STATUS_MORE_PROCESSING_REQUIRED)
+    {
+        BDSM_dbg("spnego challenge(): Bad status (0x%x)\n",
+                 msg.packet->header.status);
+        return (0);
+    }
+
+    resp = (smb_session_xsec_resp *)msg.packet->payload;
+
+    asn1_create_element(s->spnego_asn1, "SPNEGO.NegotiationToken", &token);
+    res = asn1_der_decoding(&token, resp->payload, resp->xsec_blob_size,
+                            err_desc);
+    if (res != ASN1_SUCCESS)
+    {
+        asn1_delete_structure(&token);
+        asn1_display_error("NegTokenResp parsing", res);
+        BDSM_dbg("Parsing error detail: %s\n", err_desc);
+        return (0);
+    }
+
+    // XXX Check the value of "negTokenResp.negResult"
+
+    res = asn1_read_value(token, "negTokenResp.responseToken", resp_token,
+                          &resp_token_size);
+    if (res != ASN1_SUCCESS)
+    {
+        asn1_delete_structure(&token);
+        asn1_display_error("NegTokenResp read responseToken", res);
+        return (0);
+    }
+
+    // We got the server challenge, yeaaah.
+    challenge = (smb_ntlmssp_challenge *)resp_token;
+    smb_buffer_alloc(&s->xsec_target, challenge->tgt_len);
+    memcpy(s->xsec_target.data,
+           challenge->data + challenge->tgt_offset - sizeof(smb_ntlmssp_challenge),
+           s->xsec_target.size);
+    s->srv.challenge = challenge->challenge;
+    s->srv.uid       = msg.packet->header.uid;
+
+    fprintf(stderr, "Server challenge is 0x%lx\n", s->srv.challenge);
 
-  // XXX Check the value of "negTokenResp.negResult"
-
-  res = asn1_read_value(token, "negTokenResp.responseToken", resp_token,
-                        &resp_token_size);
-  if (res != ASN1_SUCCESS)
-  {
-    asn1_delete_structure(&token);
-    asn1_display_error("NegTokenResp read responseToken", res);
-    return (0);
-  }
-
-  // We got the server challenge, yeaaah.
-  challenge = (smb_ntlmssp_challenge *)resp_token;
-  smb_buffer_alloc(&s->xsec_target, challenge->tgt_len);
-  memcpy(s->xsec_target.data,
-         challenge->data + challenge->tgt_offset - sizeof(smb_ntlmssp_challenge),
-         s->xsec_target.size);
-  s->srv.challenge = challenge->challenge;
-  s->srv.uid       = msg.packet->header.uid;
-
-  fprintf(stderr, "Server challenge is 0x%lx\n", s->srv.challenge);
-
-  return (1);
+    return (1);
 }
 
 static int      auth(smb_session *s, const char *domain, const char *user,
                      const char *password)
 {
-  smb_message           *msg = NULL, resp;
-  smb_session_xsec_req  *req = NULL;
-  smb_buffer            ntlm;
-  ASN1_TYPE             token;
-  int                   res, der_size = 512;
-  char                  der[512], err_desc[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
-
-  msg = smb_message_new(SMB_CMD_SETUP, 512);
-  smb_message_set_andx_members(msg);
-  req = (smb_session_xsec_req *)msg->packet->payload;
-
-  req->wct              = 12;
-  req->max_buffer       = SMB_SESSION_MAX_BUFFER;
-  req->mpx_count        = 16; // XXX ?
-  req->vc_count         = 1;
-  req->caps             = s->srv.caps; // XXX caps & our_caps_mask
-  req->session_key      = s->srv.session_key;
-
-  smb_message_advance(msg, sizeof(smb_session_xsec_req));
-
-
-  asn1_create_element(s->spnego_asn1, "SPNEGO.NegotiationToken", &token);
-
-  // Select a response message type
-  res = asn1_write_value(token, "", "negTokenResp", 1);
-  if (res != ASN1_SUCCESS) goto error;
-
-  // Delete all optionnal field except 'ResponseToken'
-  res = asn1_write_value(token, "negTokenResp.negResult", NULL, 0);
-  if (res != ASN1_SUCCESS) goto error;
-  res = asn1_write_value(token, "negTokenResp.supportedMech", NULL, 0);
-  if (res != ASN1_SUCCESS) goto error;
-  res = asn1_write_value(token, "negTokenResp.mechListMIC", NULL, 0);
-  if (res != ASN1_SUCCESS) goto error;
-
-
-  smb_ntlmssp_response(s->srv.challenge, s->srv.ts - 4200, domain, domain, user,
-                       password, &s->xsec_target, &ntlm);
-  res = asn1_write_value(token, "negTokenResp.responseToken", ntlm.data,
-                         ntlm.size);
-  smb_buffer_free(&ntlm);
-  if (res != ASN1_SUCCESS) goto error;
-
-  res = asn1_der_coding(token, "", der, &der_size, err_desc);
-  if (res != ASN1_SUCCESS)
-  {
-    smb_message_destroy(msg);
-    BDSM_dbg("Encoding error: %s", err_desc);
-    return (0);
-  }
-
-  smb_message_append(msg, der, der_size);
-  if (msg->cursor % 2)
-    smb_message_put8(msg, 0);
-  smb_message_put_utf16(msg, SMB_OS, strlen(SMB_OS));
-  smb_message_put16(msg, 0);
-  smb_message_put_utf16(msg, SMB_LANMAN, strlen(SMB_LANMAN));
-  smb_message_put16(msg, 0);
-  smb_message_put16(msg, 0); // Empty PDC name
+    smb_message           *msg = NULL, resp;
+    smb_session_xsec_req  *req = NULL;
+    smb_buffer            ntlm;
+    ASN1_TYPE             token;
+    int                   res, der_size = 512;
+    char                  der[512], err_desc[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
+
+    msg = smb_message_new(SMB_CMD_SETUP, 512);
+    smb_message_set_andx_members(msg);
+    req = (smb_session_xsec_req *)msg->packet->payload;
+
+    req->wct              = 12;
+    req->max_buffer       = SMB_SESSION_MAX_BUFFER;
+    req->mpx_count        = 16; // XXX ?
+    req->vc_count         = 1;
+    req->caps             = s->srv.caps; // XXX caps & our_caps_mask
+    req->session_key      = s->srv.session_key;
+
+    smb_message_advance(msg, sizeof(smb_session_xsec_req));
+
+
+    asn1_create_element(s->spnego_asn1, "SPNEGO.NegotiationToken", &token);
+
+    // Select a response message type
+    res = asn1_write_value(token, "", "negTokenResp", 1);
+    if (res != ASN1_SUCCESS) goto error;
+
+    // Delete all optionnal field except 'ResponseToken'
+    res = asn1_write_value(token, "negTokenResp.negResult", NULL, 0);
+    if (res != ASN1_SUCCESS) goto error;
+    res = asn1_write_value(token, "negTokenResp.supportedMech", NULL, 0);
+    if (res != ASN1_SUCCESS) goto error;
+    res = asn1_write_value(token, "negTokenResp.mechListMIC", NULL, 0);
+    if (res != ASN1_SUCCESS) goto error;
+
+
+    smb_ntlmssp_response(s->srv.challenge, s->srv.ts - 4200, domain, domain, user,
+                         password, &s->xsec_target, &ntlm);
+    res = asn1_write_value(token, "negTokenResp.responseToken", ntlm.data,
+                           ntlm.size);
+    smb_buffer_free(&ntlm);
+    if (res != ASN1_SUCCESS) goto error;
+
+    res = asn1_der_coding(token, "", der, &der_size, err_desc);
+    if (res != ASN1_SUCCESS)
+    {
+        smb_message_destroy(msg);
+        BDSM_dbg("Encoding error: %s", err_desc);
+        return (0);
+    }
+
+    smb_message_append(msg, der, der_size);
+    if (msg->cursor % 2)
+        smb_message_put8(msg, 0);
+    smb_message_put_utf16(msg, SMB_OS, strlen(SMB_OS));
+    smb_message_put16(msg, 0);
+    smb_message_put_utf16(msg, SMB_LANMAN, strlen(SMB_LANMAN));
+    smb_message_put16(msg, 0);
+    smb_message_put16(msg, 0); // Empty PDC name
+
+    req->xsec_blob_size = der_size;
+    req->payload_size   = msg->cursor - sizeof(smb_session_xsec_req);
 
-  req->xsec_blob_size = der_size;
-  req->payload_size   = msg->cursor - sizeof(smb_session_xsec_req);
+    asn1_delete_structure(&token);
 
-  asn1_delete_structure(&token);
+    if (!smb_session_send_msg(s, msg))
+    {
+        smb_message_destroy(msg);
+        BDSM_dbg("Unable to send Session Setup AndX (NTLMSSP_AUTH) message\n");
+        return (0);
+    }
 
-  if (!smb_session_send_msg(s, msg))
-  {
-    smb_message_destroy(msg);
-    BDSM_dbg("Unable to send Session Setup AndX (NTLMSSP_AUTH) message\n");
-    return (0);
-  }
-
-  if (smb_session_recv_msg(s, &resp) == 0)
-    return (0);
+    if (smb_session_recv_msg(s, &resp) == 0)
+        return (0);
 
-  if (resp.packet->header.status != NT_STATUS_SUCCESS)
-    return (0);
-  else
-    return (1);
+    if (resp.packet->header.status != NT_STATUS_SUCCESS)
+        return (0);
+    else
+        return (1);
 
-  error:
+error:
     asn1_display_error("smb_session_login auth()", res);
     smb_message_destroy(msg);
-    return(0);
+    return (0);
 }
 
 int             smb_session_login_spnego(smb_session *s, const char *domain,
-                                         const char *user, const char *password)
+        const char *user, const char *password)
 {
-  int           res;
-  assert(s != NULL && domain != NULL && user != NULL && password != NULL);
+    int           res;
+    assert(s != NULL && domain != NULL && user != NULL && password != NULL);
 
-  if (!init_asn1(s))
-    return (0);
+    if (!init_asn1(s))
+        return (0);
 
-  if (!negotiate(s, domain))
-    goto error;
-  if (!challenge(s))
-    goto error;
+    if (!negotiate(s, domain))
+        goto error;
+    if (!challenge(s))
+        goto error;
 
-  res = auth(s, domain, user, password);
+    res = auth(s, domain, user, password);
 
-  clean_asn1(s);
+    clean_asn1(s);
 
-  return (res);
+    return (res);
 
-  error:
+error:
     BDSM_dbg("login_spnego Interrupted\n");
     clean_asn1(s);
     return (0);

src/smb_stat.c

@@ -23,65 +23,65 @@
 
 smb_stat        smb_stat_fd(smb_session *s, smb_fd fd)
 {
-  assert (s != NULL && fd);
+    assert(s != NULL && fd);
 
-  return (smb_session_file_get(s, fd));
+    return (smb_session_file_get(s, fd));
 }
 
 size_t            smb_stat_list_count(smb_stat_list list)
 {
-  size_t          count = 0;
+    size_t          count = 0;
 
-  while(list != NULL)
-  {
-    list = list->next;
-    ++count;
-  }
+    while (list != NULL)
+    {
+        list = list->next;
+        ++count;
+    }
 
-  return (count);
+    return (count);
 }
 
 smb_stat        smb_stat_list_at(smb_stat_list list, size_t index)
 {
-  size_t          pos = 0;
+    size_t          pos = 0;
 
-  while(list != NULL && pos < index)
-  {
-    list = list->next;
-    pos++;
-  }
+    while (list != NULL && pos < index)
+    {
+        list = list->next;
+        pos++;
+    }
 
-  return (list);
+    return (list);
 }
 
 const char        *smb_stat_name(smb_stat info)
 {
-  if (info == NULL)
-    return (NULL);
-  else
-    return (info->name);
+    if (info == NULL)
+        return (NULL);
+    else
+        return (info->name);
 }
 
 uint64_t          smb_stat_get(smb_stat info, int what)
 {
-  if (info == NULL)
-    return (0);
+    if (info == NULL)
+        return (0);
 
-  switch (what)
-  {
-    case SMB_STAT_SIZE:
-      return(info->size);
-    case SMB_STAT_ALLOC_SIZE:
-      return(info->alloc_size);
-    case SMB_STAT_CTIME:
-      return(info->created);
-    case SMB_STAT_ATIME:
-      return(info->accessed);
-    case SMB_STAT_WTIME:
-      return(info->written);
-    case SMB_STAT_MTIME:
-      return(info->changed);
-    default:
-      return (0);
-  }
+    switch (what)
+    {
+        case SMB_STAT_SIZE:
+            return (info->size);
+        case SMB_STAT_ALLOC_SIZE:
+            return (info->alloc_size);
+        case SMB_STAT_CTIME:
+            return (info->created);
+        case SMB_STAT_ATIME:
+            return (info->accessed);
+        case SMB_STAT_WTIME:
+            return (info->written);
+        case SMB_STAT_MTIME:
+            return (info->changed);
+        default:
+            return (0);
+    }
 }

src/smb_trans2.c

@@ -29,226 +29,226 @@
 
 static smb_file *smb_find_parse(smb_message *msg)
 {
-  smb_trans2_resp       *tr2;
-  smb_tr2_find2_params  *params;
-  smb_tr2_find2_entry   *iter;
-  smb_file              *files, *tmp;
-  uint8_t               *eod;
-  size_t                count, i;
-
-  assert(msg != NULL);
-
-  // Let's parse the answer we got from server
-  tr2     = (smb_trans2_resp *)msg->packet->payload;
-  params  = (smb_tr2_find2_params *)tr2->payload;
-  iter    = (smb_tr2_find2_entry *)(tr2->payload + sizeof(smb_tr2_find2_params));
-  eod     = msg->packet->payload + msg->payload_size;
-  count   = params->count;
-  files   = NULL;
-
-  for(i = 0; i < count && (uint8_t *)iter < eod; i++)
-  {
-    // Create a smb_file and fill it
-    tmp = calloc(1, sizeof(smb_file));
-    assert(tmp != NULL);
-
-    tmp->name_len = smb_from_utf16((const char *)iter->name, iter->name_len,
-                                  &tmp->name);
-    tmp->name[tmp->name_len] = 0;
-
-    tmp->created    = iter->created;
-    tmp->accessed   = iter->accessed;
-    tmp->written    = iter->written;
-    tmp->changed    = iter->changed;
-    tmp->size       = iter->size;
-    tmp->alloc_size = iter->alloc_size;
-    tmp->attr       = iter->attr;
-    tmp->is_dir     = tmp->attr & SMB_ATTR_DIR;
-
-    tmp->next = files;
-    files     = tmp;
-
-    iter = (smb_tr2_find2_entry *)(((char *)iter) + iter->next_entry);
-  }
-
-  return (files);
+    smb_trans2_resp       *tr2;
+    smb_tr2_find2_params  *params;
+    smb_tr2_find2_entry   *iter;
+    smb_file              *files, *tmp;
+    uint8_t               *eod;
+    size_t                count, i;
+
+    assert(msg != NULL);
+
+    // Let's parse the answer we got from server
+    tr2     = (smb_trans2_resp *)msg->packet->payload;
+    params  = (smb_tr2_find2_params *)tr2->payload;
+    iter    = (smb_tr2_find2_entry *)(tr2->payload + sizeof(smb_tr2_find2_params));
+    eod     = msg->packet->payload + msg->payload_size;
+    count   = params->count;
+    files   = NULL;
+
+    for (i = 0; i < count && (uint8_t *)iter < eod; i++)
+    {
+        // Create a smb_file and fill it
+        tmp = calloc(1, sizeof(smb_file));
+        assert(tmp != NULL);
+
+        tmp->name_len = smb_from_utf16((const char *)iter->name, iter->name_len,
+                                       &tmp->name);
+        tmp->name[tmp->name_len] = 0;
+
+        tmp->created    = iter->created;
+        tmp->accessed   = iter->accessed;
+        tmp->written    = iter->written;
+        tmp->changed    = iter->changed;
+        tmp->size       = iter->size;
+        tmp->alloc_size = iter->alloc_size;
+        tmp->attr       = iter->attr;
+        tmp->is_dir     = tmp->attr & SMB_ATTR_DIR;
+
+        tmp->next = files;
+        files     = tmp;
+
+        iter = (smb_tr2_find2_entry *)(((char *)iter) + iter->next_entry);
+    }
+
+    return (files);
 }
 
 static smb_message *smb_tr2_recv(smb_session *s)
 {
-  smb_message           recv, *res;
-  smb_trans2_resp       *tr2;
-  size_t                growth;
-  int                   remaining;
-
-  if (!smb_session_recv_msg(s, &recv))
-    return (NULL);
-
-  tr2         = (smb_trans2_resp *)recv.packet->payload;
-  growth      = tr2->total_data_count - tr2->data_count;
-  res         = smb_message_grow(&recv, growth);
-  res->cursor = recv.payload_size;
-  remaining   = (int)tr2->total_data_count -
-                (tr2->data_displacement + tr2->data_count);
-
-  while(remaining > 0)
-  {
-    remaining = smb_session_recv_msg(s, &recv);
-    if (remaining)
-    {
-      tr2   = (smb_trans2_resp *)recv.packet->payload;
-      smb_message_append(res, tr2->payload + 2 /*pad*/, tr2->data_count);
-      remaining = (int)tr2->total_data_count -
+    smb_message           recv, *res;
+    smb_trans2_resp       *tr2;
+    size_t                growth;
+    int                   remaining;
+
+    if (!smb_session_recv_msg(s, &recv))
+        return (NULL);
+
+    tr2         = (smb_trans2_resp *)recv.packet->payload;
+    growth      = tr2->total_data_count - tr2->data_count;
+    res         = smb_message_grow(&recv, growth);
+    res->cursor = recv.payload_size;
+    remaining   = (int)tr2->total_data_count -
                   (tr2->data_displacement + tr2->data_count);
+
+    while (remaining > 0)
+    {
+        remaining = smb_session_recv_msg(s, &recv);
+        if (remaining)
+        {
+            tr2   = (smb_trans2_resp *)recv.packet->payload;
+            smb_message_append(res, tr2->payload + 2 /*pad*/, tr2->data_count);
+            remaining = (int)tr2->total_data_count -
+                        (tr2->data_displacement + tr2->data_count);
+        }
     }
-  }
 
-  return (res);
+    return (res);
 }
 
 smb_file  *smb_find(smb_session *s, smb_tid tid, const char *pattern)
 {
-  smb_message           *msg;
-  smb_trans2_req        *tr2;
-  smb_tr2_find2         *find;
-  size_t                pattern_len, msg_len;
-  int                   res;
-
-  assert(s != NULL && pattern != NULL && tid);
-
-  pattern_len = strlen(pattern) + 1;
-  msg_len     = sizeof(smb_trans2_req) + sizeof(smb_tr2_find2);
-  msg_len    += pattern_len * 2 + 3;
-
-  msg = smb_message_new(SMB_CMD_TRANS2, msg_len);
-  msg->packet->header.tid = tid;
-
-  tr2 = (smb_trans2_req *)msg->packet->payload;
-  tr2->wct                = 15;
-  tr2->total_param_count  = pattern_len * 2 + sizeof(smb_tr2_find2);
-  tr2->max_param_count    = 10; // ?? Why not the same or 12 ?
-  tr2->max_data_count     = 0xffff;
-  tr2->param_count        = tr2->total_param_count;
-  tr2->param_offset       = 68; // Offset of find_first_params in packet;
-  tr2->data_count         = 0;
-  tr2->data_offset        = 88; // Offset of pattern in packet
-  tr2->setup_count        = 1;
-  tr2->cmd                = SMB_TR2_FIND_FIRST;
-  tr2->bct                = sizeof(smb_tr2_find2) + pattern_len * 2;
-
-  find = (smb_tr2_find2 *) tr2->payload;
-  find->attrs     = SMB_FIND2_ATTR_DEFAULT;
-  find->count     = 1366;     // ??
-  find->flags     = SMB_FIND2_FLAG_DEFAULT;
-  find->interest  = 0x0104;   // 'Find file both directory info'
-
-  smb_message_advance(msg, sizeof(smb_trans2_req));
-  smb_message_advance(msg, sizeof(smb_tr2_find2));
-  smb_message_put_utf16(msg, pattern, pattern_len);
-
-  // Adds padding at the end if necessary.
-  while (tr2->bct % 4)
-  {
-    smb_message_put8(msg, 0);
-    tr2->bct++;
-  }
-
-  res = smb_session_send_msg(s, msg);
-  smb_message_destroy(msg);
-  if (!res)
-  {
-    BDSM_dbg("Unable to query pattern: %s\n", pattern);
-    return (NULL);
-  }
-
-  if ((msg = smb_tr2_recv(s)) == NULL)
-    return (NULL);
-
-  return (smb_find_parse(msg));
+    smb_message           *msg;
+    smb_trans2_req        *tr2;
+    smb_tr2_find2         *find;
+    size_t                pattern_len, msg_len;
+    int                   res;
+
+    assert(s != NULL && pattern != NULL && tid);
+
+    pattern_len = strlen(pattern) + 1;
+    msg_len     = sizeof(smb_trans2_req) + sizeof(smb_tr2_find2);
+    msg_len    += pattern_len * 2 + 3;
+
+    msg = smb_message_new(SMB_CMD_TRANS2, msg_len);
+    msg->packet->header.tid = tid;
+
+    tr2 = (smb_trans2_req *)msg->packet->payload;
+    tr2->wct                = 15;
+    tr2->total_param_count  = pattern_len * 2 + sizeof(smb_tr2_find2);
+    tr2->max_param_count    = 10; // ?? Why not the same or 12 ?
+    tr2->max_data_count     = 0xffff;
+    tr2->param_count        = tr2->total_param_count;
+    tr2->param_offset       = 68; // Offset of find_first_params in packet;
+    tr2->data_count         = 0;
+    tr2->data_offset        = 88; // Offset of pattern in packet
+    tr2->setup_count        = 1;
+    tr2->cmd                = SMB_TR2_FIND_FIRST;
+    tr2->bct                = sizeof(smb_tr2_find2) + pattern_len * 2;
+
+    find = (smb_tr2_find2 *) tr2->payload;
+    find->attrs     = SMB_FIND2_ATTR_DEFAULT;
+    find->count     = 1366;     // ??
+    find->flags     = SMB_FIND2_FLAG_DEFAULT;
+    find->interest  = 0x0104;   // 'Find file both directory info'
+
+    smb_message_advance(msg, sizeof(smb_trans2_req));
+    smb_message_advance(msg, sizeof(smb_tr2_find2));
+    smb_message_put_utf16(msg, pattern, pattern_len);
+
+    // Adds padding at the end if necessary.
+    while (tr2->bct % 4)
+    {
+        smb_message_put8(msg, 0);
+        tr2->bct++;
+    }
+
+    res = smb_session_send_msg(s, msg);
+    smb_message_destroy(msg);
+    if (!res)
+    {
+        BDSM_dbg("Unable to query pattern: %s\n", pattern);
+        return (NULL);
+    }
+
+    if ((msg = smb_tr2_recv(s)) == NULL)
+        return (NULL);
+
+    return (smb_find_parse(msg));
 }
 
 
 smb_file  *smb_fstat(smb_session *s, smb_tid tid, const char *path)
 {
-  smb_message           *msg, reply;
-  smb_trans2_req        *tr2;
-  smb_trans2_resp       *tr2_resp;
-  smb_tr2_query         *query;
-  smb_tr2_path_info     *info;
-  smb_file              *file;
-  size_t                path_len, msg_len;
-  int                   res;
-
-  assert(s != NULL && path != NULL && tid);
-
-  path_len  = strlen(path) + 1;
-  msg_len   = sizeof(smb_trans2_req) + sizeof(smb_tr2_query);
-  msg_len  += path_len * 2 + 3; // +3 for eventual padding
-
-  msg = smb_message_new(SMB_CMD_TRANS2, msg_len);
-  msg->packet->header.tid = tid;
-
-  tr2 = (smb_trans2_req *)msg->packet->payload;
-  tr2->wct                = 15;
-  tr2->total_param_count  = path_len * 2 + sizeof(smb_tr2_query);
-  tr2->max_param_count    = 2; // ?? Why not the same or 12 ?
-  tr2->max_data_count     = 0xffff;
-  tr2->param_count        = tr2->total_param_count;
-  tr2->param_offset       = 68; // Offset of find_first_params in packet;
-  tr2->data_count         = 0;
-  tr2->data_offset        = 96; // Offset of pattern in packet
-  tr2->setup_count        = 1;
-  tr2->cmd                = SMB_TR2_QUERY_PATH;
-  tr2->bct                = sizeof(smb_tr2_query) + path_len * 2 + 3;
-
-  query = (smb_tr2_query *)tr2->payload;
-  query->interest   = 0x0107;   // Query File All Info
-
-  smb_message_advance(msg, sizeof(smb_trans2_req));
-  smb_message_advance(msg, sizeof(smb_tr2_query));
-  smb_message_put_utf16(msg, path, path_len);
-
-  // Adds padding at the end if necessary.
-  if (msg->cursor % 4)
-  {
-    int padding = 4 - msg->cursor % 4;
-    tr2->bct += padding;
-    for (int i = 0; i < padding; i++)
-      smb_message_put8(msg, 0);
-  }
-
-  res = smb_session_send_msg(s, msg);
-  smb_message_destroy(msg);
-  if (!res)
-  {
-    BDSM_dbg("Unable to query pattern: %s\n", path);
-    return (NULL);
-  }
-
-  if (!smb_session_recv_msg(s, &reply)
-      || reply.packet->header.status != NT_STATUS_SUCCESS)
-  {
-    BDSM_dbg("Unable to recv msg or failure for %s\n", path);
-    return (NULL);
-  }
-
-  tr2_resp  = (smb_trans2_resp *)reply.packet->payload;
-  info      = (smb_tr2_path_info *)(tr2_resp->payload + 4); //+4 is padding
-  file      = calloc(1, sizeof(smb_file));
-  assert(file != NULL);
-
-  file->name_len  = smb_from_utf16((const char *)info->name, info->name_len,
-                                  &file->name);
-  file->name[info->name_len] = 0;
-
-  file->created     = info->created;
-  file->accessed    = info->accessed;
-  file->written     = info->written;
-  file->changed     = info->changed;
-  file->alloc_size  = info->alloc_size;
-  file->size        = info->size;
-  file->attr        = info->attr;
-  file->is_dir      = info->is_dir;
-
-  return (file);
+    smb_message           *msg, reply;
+    smb_trans2_req        *tr2;
+    smb_trans2_resp       *tr2_resp;
+    smb_tr2_query         *query;
+    smb_tr2_path_info     *info;
+    smb_file              *file;
+    size_t                path_len, msg_len;
+    int                   res;
+
+    assert(s != NULL && path != NULL && tid);
+
+    path_len  = strlen(path) + 1;
+    msg_len   = sizeof(smb_trans2_req) + sizeof(smb_tr2_query);
+    msg_len  += path_len * 2 + 3; // +3 for eventual padding
+
+    msg = smb_message_new(SMB_CMD_TRANS2, msg_len);
+    msg->packet->header.tid = tid;
+
+    tr2 = (smb_trans2_req *)msg->packet->payload;
+    tr2->wct                = 15;
+    tr2->total_param_count  = path_len * 2 + sizeof(smb_tr2_query);
+    tr2->max_param_count    = 2; // ?? Why not the same or 12 ?
+    tr2->max_data_count     = 0xffff;
+    tr2->param_count        = tr2->total_param_count;
+    tr2->param_offset       = 68; // Offset of find_first_params in packet;
+    tr2->data_count         = 0;
+    tr2->data_offset        = 96; // Offset of pattern in packet
+    tr2->setup_count        = 1;
+    tr2->cmd                = SMB_TR2_QUERY_PATH;
+    tr2->bct                = sizeof(smb_tr2_query) + path_len * 2 + 3;
+
+    query = (smb_tr2_query *)tr2->payload;
+    query->interest   = 0x0107;   // Query File All Info
+
+    smb_message_advance(msg, sizeof(smb_trans2_req));
+    smb_message_advance(msg, sizeof(smb_tr2_query));
+    smb_message_put_utf16(msg, path, path_len);
+
+    // Adds padding at the end if necessary.
+    if (msg->cursor % 4)
+    {
+        int padding = 4 - msg->cursor % 4;
+        tr2->bct += padding;
+        for (int i = 0; i < padding; i++)
+            smb_message_put8(msg, 0);
+    }
+
+    res = smb_session_send_msg(s, msg);
+    smb_message_destroy(msg);
+    if (!res)
+    {
+        BDSM_dbg("Unable to query pattern: %s\n", path);
+        return (NULL);
+    }
+
+    if (!smb_session_recv_msg(s, &reply)
+        || reply.packet->header.status != NT_STATUS_SUCCESS)
+    {
+        BDSM_dbg("Unable to recv msg or failure for %s\n", path);
+        return (NULL);
+    }
+
+    tr2_resp  = (smb_trans2_resp *)reply.packet->payload;
+    info      = (smb_tr2_path_info *)(tr2_resp->payload + 4); //+4 is padding
+    file      = calloc(1, sizeof(smb_file));
+    assert(file != NULL);
+
+    file->name_len  = smb_from_utf16((const char *)info->name, info->name_len,
+                                     &file->name);
+    file->name[info->name_len] = 0;
+
+    file->created     = info->created;
+    file->accessed    = info->accessed;
+    file->written     = info->written;
+    file->changed     = info->changed;
+    file->alloc_size  = info->alloc_size;
+    file->size        = info->size;
+    file->attr        = info->attr;
+    file->is_dir      = info->is_dir;
+
+    return (file);
 }

src/smb_transport.c

@@ -25,39 +25,39 @@ int               transport_connect_nbt(struct in_addr *addr,
                                         netbios_session *s,
                                         const char *name)
 {
-  return (netbios_session_connect(addr, s, name, 0));
+    return (netbios_session_connect(addr, s, name, 0));
 }
 
 int               transport_connect_tcp(struct in_addr *addr,
                                         netbios_session *s,
                                         const char *name)
 {
-  return (netbios_session_connect(addr, s, name, 1));
+    return (netbios_session_connect(addr, s, name, 1));
 }
 
 void              smb_transport_nbt(smb_transport *tr)
 {
-  assert(tr != NULL);
-
-  // Sorry for the dirty cast.
-  tr->new           = (void *)netbios_session_new;
-  tr->connect       = (void *)transport_connect_nbt;
-  tr->destroy       = (void *)netbios_session_destroy;
-  tr->pkt_init      = (void *)netbios_session_packet_init;
-  tr->pkt_append    = (void *)netbios_session_packet_append;
-  tr->send          = (void *)netbios_session_packet_send;
-  tr->recv          = (void *)netbios_session_packet_recv;
+    assert(tr != NULL);
+
+    // Sorry for the dirty cast.
+    tr->new           = (void *)netbios_session_new;
+    tr->connect       = (void *)transport_connect_nbt;
+    tr->destroy       = (void *)netbios_session_destroy;
+    tr->pkt_init      = (void *)netbios_session_packet_init;
+    tr->pkt_append    = (void *)netbios_session_packet_append;
+    tr->send          = (void *)netbios_session_packet_send;
+    tr->recv          = (void *)netbios_session_packet_recv;
 }
 
 void              smb_transport_tcp(smb_transport *tr)
 {
-  assert(tr != NULL);
-
-  tr->new           = (void *)netbios_session_new;
-  tr->connect       = (void *)transport_connect_tcp;
-  tr->destroy       = (void *)netbios_session_destroy;
-  tr->pkt_init      = (void *)netbios_session_packet_init;
-  tr->pkt_append    = (void *)netbios_session_packet_append;
-  tr->send          = (void *)netbios_session_packet_send;
-  tr->recv          = (void *)netbios_session_packet_recv;
+    assert(tr != NULL);
+
+    tr->new           = (void *)netbios_session_new;
+    tr->connect       = (void *)transport_connect_tcp;
+    tr->destroy       = (void *)netbios_session_destroy;
+    tr->pkt_init      = (void *)netbios_session_packet_init;
+    tr->pkt_append    = (void *)netbios_session_packet_append;
+    tr->send          = (void *)netbios_session_packet_send;
+    tr->recv          = (void *)netbios_session_packet_recv;
 }

src/smb_utils.c

@@ -28,58 +28,58 @@
 
 static const char *current_encoding()
 {
-  static int locale_set = 0;
+    static int locale_set = 0;
 
-  if (!locale_set)
-  {
-    setlocale(LC_ALL, "");
-    locale_set = 1;
-  }
-  //fprintf(stderr, "%s\n", nl_langinfo(CODESET));
-  return (nl_langinfo(CODESET));
+    if (!locale_set)
+    {
+        setlocale(LC_ALL, "");
+        locale_set = 1;
+    }
+    //fprintf(stderr, "%s\n", nl_langinfo(CODESET));
+    return (nl_langinfo(CODESET));
 }
 
 static size_t smb_iconv(const char *src, size_t src_len, char **dst,
                         size_t dst_len, const char *src_enc,
                         const char *dst_enc)
 {
-  iconv_t   ic;
-  char      *out;
-  size_t    outleft;
+    iconv_t   ic;
+    char      *out;
+    size_t    outleft;
 
-  assert(src != NULL && dst != NULL && src_enc != NULL && dst_enc != NULL);
+    assert(src != NULL && dst != NULL && src_enc != NULL && dst_enc != NULL);
 
-  if (!src_len)
-  {
-    *dst = NULL;
-    return (0);
-  }
+    if (!src_len)
+    {
+        *dst = NULL;
+        return (0);
+    }
 
-  if ((ic = iconv_open(dst_enc, src_enc)) == (iconv_t)-1)
-  {
-    fprintf(stderr, "Unable to open iconv to convert from %s to %s\n",
-            src_enc, dst_enc);
-    return (0);
-  }
+    if ((ic = iconv_open(dst_enc, src_enc)) == (iconv_t)-1)
+    {
+        fprintf(stderr, "Unable to open iconv to convert from %s to %s\n",
+                src_enc, dst_enc);
+        return (0);
+    }
 
-  outleft = dst_len; // The utf-16 str is at most 2x bigger than the utf-8 one. (i think ?)
-  out     = *dst = malloc(outleft);
+    outleft = dst_len; // The utf-16 str is at most 2x bigger than the utf-8 one. (i think ?)
+    out     = *dst = malloc(outleft);
 
-  assert(out != NULL);
-  iconv(ic, (char **)&src, &src_len, &out, &outleft);
-  assert(src_len == 0);
+    assert(out != NULL);
+    iconv(ic, (char **)&src, &src_len, &out, &outleft);
+    assert(src_len == 0);
 
-  return (dst_len - outleft);
+    return (dst_len - outleft);
 }
 
 size_t      smb_to_utf16(const char *src, size_t src_len, char **dst)
 {
-  return(smb_iconv(src, src_len, dst, src_len * 2,
-         current_encoding(), "UCS-2LE"));
+    return (smb_iconv(src, src_len, dst, src_len * 2,
+                      current_encoding(), "UCS-2LE"));
 }
 
 size_t      smb_from_utf16(const char *src, size_t src_len, char **dst)
 {
-  return(smb_iconv(src, src_len, dst, src_len,
-         "UCS-2LE", current_encoding()));
+    return (smb_iconv(src, src_len, dst, src_len,
+                      "UCS-2LE", current_encoding()));
 }