diff --git a/server/core/memlog.c b/server/core/memlog.c
index 421a89ab9..d47980290 100644
--- a/server/core/memlog.c
+++ b/server/core/memlog.c
@@ -22,8 +22,8 @@
  * @verbatim
  * Revision History
  *
- * Date		Who		Description
- * 26/09/14	Mark Riddoch	Initial implementation
+ * Date         Who             Description
+ * 26/09/14     Mark Riddoch    Initial implementation
  *
  * @endverbatim
  */
@@ -33,128 +33,140 @@
 #include <string.h>
 #include <stdint.h>
 
-static	MEMLOG		*memlogs = NULL;
-static	SPINLOCK	memlock = SPINLOCK_INIT;
+static MEMLOG *memlogs = NULL;
+static SPINLOCK memlock = SPINLOCK_INIT;
 
 /**
  * Create a new instance of a memory logger.
  *
- * @param name	The name of the memory log
- * @param type	The type of item being logged
- * @param size	The number of items to store in memory before flushign to disk
+ * @param name  The name of the memory log
+ * @param type  The type of item being logged
+ * @param size  The number of items to store in memory before flushign to disk
  *
- * @return MEMLOG*	A memory log handle
+ * @return MEMLOG*      A memory log handle
  */
 MEMLOG *
 memlog_create(char *name, MEMLOGTYPE type, int size)
 {
-MEMLOG	*log;
+    MEMLOG *log;
 
-	if ((log = (MEMLOG *)malloc(sizeof(MEMLOG))) == NULL)
-	{
-		return NULL;
-	}
+    if ((log = (MEMLOG *)malloc(sizeof(MEMLOG))) == NULL)
+    {
+        return NULL;
+    }
 
-	log->name = strdup(name);
-	spinlock_init(&log->lock);
-	log->type = type;
-	log->offset = 0;
-	log->size = size;
-	log->flags = 0;
-	switch (type)
-	{
-	case ML_INT:
-		log->values = malloc(sizeof(int) * size);
-		break;
-	case ML_LONG:
-		log->values = malloc(sizeof(long) * size);
-		break;
-	case ML_LONGLONG:
-		log->values = malloc(sizeof(long long) * size);
-		break;
-	case ML_STRING:
-		log->values = malloc(sizeof(char *) * size);
-		break;
-	}
-	if (log->values == NULL)
-	{
-		free(log);
-		return NULL;
-	}
-	spinlock_acquire(&memlock);
-	log->next = memlogs;
-	memlogs = log;
-	spinlock_release(&memlock);
+    log->name = strdup(name);
+    spinlock_init(&log->lock);
+    log->type = type;
+    log->offset = 0;
+    log->size = size;
+    log->flags = 0;
+    switch (type)
+    {
+    case ML_INT:
+        log->values = malloc(sizeof(int) * size);
+        break;
+    case ML_LONG:
+        log->values = malloc(sizeof(long) * size);
+        break;
+    case ML_LONGLONG:
+        log->values = malloc(sizeof(long long) * size);
+        break;
+    case ML_STRING:
+        log->values = malloc(sizeof(char *) * size);
+        break;
+    }
+    if (log->values == NULL)
+    {
+        free(log);
+        return NULL;
+    }
+    spinlock_acquire(&memlock);
+    log->next = memlogs;
+    memlogs = log;
+    spinlock_release(&memlock);
 
-	return log;
+    return log;
 }
 
 /**
  * Destroy a memory logger any unwritten data will be flushed to disk
  *
- * @param log	The memory log to destroy
+ * @param log   The memory log to destroy
  */
 void
 memlog_destroy(MEMLOG *log)
 {
-MEMLOG *ptr;
+    MEMLOG *ptr;
 
-	if ((log->flags & MLNOAUTOFLUSH) == 0)
-		memlog_flush(log);
-	free(log->values);
+    if ((log->flags & MLNOAUTOFLUSH) == 0)
+    {
+        memlog_flush(log);
+    }
+    free(log->values);
 
-	spinlock_acquire(&memlock);
-	if (memlogs == log)
-		memlogs = log->next;
-	else
-	{
-		ptr = memlogs;
-		while (ptr && ptr->next != log)
-			ptr = ptr->next;
-		if (ptr)
-			ptr->next = log->next;
-	}
-	spinlock_release(&memlock);
-	free(log->name);
-	free(log);
+    spinlock_acquire(&memlock);
+    if (memlogs == log)
+    {
+        memlogs = log->next;
+    }
+    else
+    {
+        ptr = memlogs;
+        while (ptr && ptr->next != log)
+        {
+            ptr = ptr->next;
+        }
+        if (ptr)
+        {
+            ptr->next = log->next;
+        }
+    }
+    spinlock_release(&memlock);
+    free(log->name);
+    free(log);
 }
 
 /**
  * Log a data item to the memory logger
  *
- * @param log	The memory logger
- * @param value	The value to log
+ * @param log   The memory logger
+ * @param value The value to log
  */
 void
 memlog_log(MEMLOG *log, void *value)
 {
-	if (!log)
-		return;
-	spinlock_acquire(&log->lock);
-	switch (log->type)
-	{
-	case ML_INT:
-		((int *)(log->values))[log->offset] = (intptr_t)value;
-		break;
-	case ML_LONG:
-		((long *)(log->values))[log->offset] = (long)value;
-		break;
-	case ML_LONGLONG:
-		((long long *)(log->values))[log->offset] = (long long)value;
-		break;
-	case ML_STRING:
-		((char **)(log->values))[log->offset] = (char *)value;
-		break;
-	}
-	log->offset++;
-	if (log->offset == log->size)
-	{
-		if ((log->flags & MLNOAUTOFLUSH) == 0)
-			memlog_flush(log);
-		log->offset = 0;
-		log->iflags = MLWRAPPED;
-	}
-	spinlock_release(&log->lock);
+    if (!log)
+    {
+        return;
+    }
+    spinlock_acquire(&log->lock);
+    switch (log->type)
+    {
+    case ML_INT:
+        ((int *)(log->values))[log->offset] = (intptr_t)value;
+        break;
+    case ML_LONG:
+        ((long *)(log->values))[log->offset] = (long)value;
+        break;
+    case ML_LONGLONG:
+        ((long long *)(log->values))[log->offset] = (long long)value;
+        break;
+    case ML_STRING:
+        ((char **)(log->values))[log->offset] = (char *)value;
+        break;
+    }
+    log->offset++;
+    if (log->offset == log->size)
+    {
+        if ((log->flags & MLNOAUTOFLUSH) == 0)
+        {
+            memlog_flush(log);
+        }
+        log->offset = 0;
+        log->iflags = MLWRAPPED;
+    }
+    spinlock_release(&log->lock);
 }
 
 /**
@@ -164,30 +176,30 @@ memlog_log(MEMLOG *log, void *value)
 void
 memlog_flush_all()
 {
-MEMLOG	*log;
+    MEMLOG  *log;
 
-	spinlock_acquire(&memlock);
-	log = memlogs;
-	while (log)
-	{
-		spinlock_acquire(&log->lock);
-		memlog_flush(log);
-		spinlock_release(&log->lock);
-		log = log->next;
-	}
-	spinlock_release(&memlock);
+    spinlock_acquire(&memlock);
+    log = memlogs;
+    while (log)
+    {
+        spinlock_acquire(&log->lock);
+        memlog_flush(log);
+        spinlock_release(&log->lock);
+        log = log->next;
+    }
+    spinlock_release(&memlock);
 }
 
 /**
  * Set the flags for a memlog
  *
- * @param	log		The memlog to set the flags for
- * @param	flags		The new flags values
+ * @param       log             The memlog to set the flags for
+ * @param       flags           The new flags values
  */
 void
 memlog_set(MEMLOG *log, unsigned int flags)
 {
-	log->flags = flags;
+    log->flags = flags;
 }
 
 /**
@@ -195,63 +207,65 @@ memlog_set(MEMLOG *log, unsigned int flags)
  *
  * Assumes the the log->lock has been acquired by the caller
  *
- * @param log	The memory log to flush
+ * @param log   The memory log to flush
  */
 void
 memlog_flush(MEMLOG *log)
 {
-FILE	*fp;
-int	i;
+    FILE *fp;
+    int i;
 
-	if ((fp = fopen(log->name, "a")) == NULL)
-		return;
-	if ((log->flags & MLNOAUTOFLUSH) && (log->iflags & MLWRAPPED))
-	{
-		for (i = 0; i < log->size; i++)
-		{
-			int	ind = (i + log->offset) % log->size;
-			switch (log->type)
-			{
-			case ML_INT:
-				fprintf(fp, "%d\n",
-					((int *)(log->values))[ind]);
-				break;
-			case ML_LONG:
-				fprintf(fp, "%ld\n",
-					((long *)(log->values))[ind]);
-				break;
-			case ML_LONGLONG:
-				fprintf(fp, "%lld\n",
-					((long long *)(log->values))[ind]);
-				break;
-			case ML_STRING:
-				fprintf(fp, "%s\n",
-					((char **)(log->values))[ind]);
-				break;
-			}
-		}
-	}
-	else
-	{
-		for (i = 0; i < log->offset; i++)
-		{
-			switch (log->type)
-			{
-			case ML_INT:
-				fprintf(fp, "%d\n", ((int *)(log->values))[i]);
-				break;
-			case ML_LONG:
-				fprintf(fp, "%ld\n", ((long *)(log->values))[i]);
-				break;
-			case ML_LONGLONG:
-				fprintf(fp, "%lld\n", ((long long *)(log->values))[i]);
-				break;
-			case ML_STRING:
-				fprintf(fp, "%s\n", ((char **)(log->values))[i]);
-				break;
-			}
-		}
-	}
-	log->offset = 0;
-	fclose(fp);
+    if ((fp = fopen(log->name, "a")) == NULL)
+    {
+        return;
+    }
+    if ((log->flags & MLNOAUTOFLUSH) && (log->iflags & MLWRAPPED))
+    {
+        for (i = 0; i < log->size; i++)
+        {
+            int ind = (i + log->offset) % log->size;
+            switch (log->type)
+            {
+            case ML_INT:
+                fprintf(fp, "%d\n",
+                        ((int *)(log->values))[ind]);
+                break;
+            case ML_LONG:
+                fprintf(fp, "%ld\n",
+                        ((long *)(log->values))[ind]);
+                break;
+            case ML_LONGLONG:
+                fprintf(fp, "%lld\n",
+                        ((long long *)(log->values))[ind]);
+                break;
+            case ML_STRING:
+                fprintf(fp, "%s\n",
+                        ((char **)(log->values))[ind]);
+                break;
+            }
+        }
+    }
+    else
+    {
+        for (i = 0; i < log->offset; i++)
+        {
+            switch (log->type)
+            {
+            case ML_INT:
+                fprintf(fp, "%d\n", ((int *)(log->values))[i]);
+                break;
+            case ML_LONG:
+                fprintf(fp, "%ld\n", ((long *)(log->values))[i]);
+                break;
+            case ML_LONGLONG:
+                fprintf(fp, "%lld\n", ((long long *)(log->values))[i]);
+                break;
+            case ML_STRING:
+                fprintf(fp, "%s\n", ((char **)(log->values))[i]);
+                break;
+            }
+        }
+    }
+    log->offset = 0;
+    fclose(fp);
 }
diff --git a/server/include/memlog.h b/server/include/memlog.h
index de183a48d..c5a2195b0 100644
--- a/server/include/memlog.h
+++ b/server/include/memlog.h
@@ -24,8 +24,8 @@
  * @verbatim
  * Revision History
  *
- * Date		Who		Description
- * 26/09/14	Mark Riddoch	Initial implementation
+ * Date         Who             Description
+ * 26/09/14     Mark Riddoch    Initial implementation
  *
  * @endverbatim
  */
@@ -33,33 +33,35 @@
 
 typedef enum { ML_INT, ML_LONG, ML_LONGLONG, ML_STRING } MEMLOGTYPE;
 
-typedef struct memlog {
-	char		*name;
-	SPINLOCK	lock;
-	void		*values;
-	int		offset;
-	int		size;
-	MEMLOGTYPE	type;
-	unsigned int	flags;
-	unsigned int	iflags;
-	struct memlog	*next;
+typedef struct memlog
+{
+    char            *name;
+    SPINLOCK        lock;
+    void            *values;
+    int             offset;
+    int             size;
+    MEMLOGTYPE      type;
+    unsigned int    flags;
+    unsigned int    iflags;
+    struct memlog   *next;
 } MEMLOG;
 
 /*
  * MEMLOG flag bits
  */
-#define	MLNOAUTOFLUSH		0x0001
+#define MLNOAUTOFLUSH           0x0001
 
 /*
  * MEMLOG internal flags
  */
-#define MLWRAPPED		0x0001
+#define MLWRAPPED               0x0001
 
 
-extern	MEMLOG *memlog_create(char *, MEMLOGTYPE, int);
-extern	void	memlog_destroy(MEMLOG *);
-extern	void	memlog_set(MEMLOG *, unsigned int);
-extern	void	memlog_log(MEMLOG *, void *);
-extern	void	memlog_flush_all();
-extern	void	memlog_flush(MEMLOG *);
+extern MEMLOG *memlog_create(char *, MEMLOGTYPE, int);
+extern void    memlog_destroy(MEMLOG *);
+extern void    memlog_set(MEMLOG *, unsigned int);
+extern void    memlog_log(MEMLOG *, void *);
+extern void    memlog_flush_all();
+extern void    memlog_flush(MEMLOG *);
+
 #endif