diff --git a/code/gamespy/darray.c b/code/gamespy/darray.c
index 3db363e2..688729fb 100644
--- a/code/gamespy/darray.c
+++ b/code/gamespy/darray.c
@@ -20,30 +20,30 @@
 #define DEF_GROWBY 8
 
 #ifdef _NO_NOPORT_H_
-	#define gsimalloc	malloc
-	#define gsifree		free
-	#define gsirealloc	realloc
-	#include "common/gsAssert.h"
+    #define gsimalloc	malloc
+    #define gsifree		free
+    #define gsirealloc	realloc
+    #include "common/gsAssert.h"
 #else
-	#include "nonport.h" //for gsimalloc/realloc/free/GS_ASSERT
+    #include "nonport.h" //for gsimalloc/realloc/free/GS_ASSERT
 #endif
 
 
 // STRUCTURES
 struct DArrayImplementation
 {
-	int count, capacity;
-	int elemsize;
-	int growby;
-	ArrayElementFreeFn elemfreefn;
-	void *list; //array of elements
+    int count, capacity;
+    int elemsize;
+    int growby;
+    ArrayElementFreeFn elemfreefn;
+    void *list; //array of elements
 };
 
 // PROTOTYPES
 static void *mylsearch(const void *key, void *base, int count, int size,
-					 ArrayCompareFn comparator);
+                     ArrayCompareFn comparator);
 static void *mybsearch(const void *elem, void *base, int num, int elemsize, 
-					   ArrayCompareFn comparator, int *found);
+                       ArrayCompareFn comparator, int *found);
 // FUNCTIONS
 
 /* FreeElement
@@ -51,8 +51,8 @@ static void *mybsearch(const void *elem, void *base, int num, int elemsize,
  */
 static void FreeElement(DArray array, int n)
 {
-	if (array->elemfreefn != NULL)
-		array->elemfreefn(ArrayNth(array,n));
+    if (array->elemfreefn != NULL)
+        array->elemfreefn(ArrayNth(array,n));
 }
 
 /* ArrayGrow
@@ -60,10 +60,10 @@ static void FreeElement(DArray array, int n)
  */
 static void ArrayGrow(DArray array)
 {
-	GS_ASSERT(array->elemsize)	// sanity check -mj Oct 31st
-	array->capacity +=  array->growby;
-	array->list = gsirealloc(array->list, (size_t) array->capacity * array->elemsize);
-	GS_ASSERT(array->list);
+    GS_ASSERT(array->elemsize)	// sanity check -mj Oct 31st
+    array->capacity +=  array->growby;
+    array->list = gsirealloc(array->list, (size_t) array->capacity * array->elemsize);
+    GS_ASSERT(array->list);
 }
 
 /* SetElement
@@ -71,94 +71,94 @@ static void ArrayGrow(DArray array)
  */
 static void SetElement(DArray array, const void *elem, int pos)
 {
-	GS_ASSERT(array)			// safety check -mj Oct 31st
-	GS_ASSERT(elem)	
-	GS_ASSERT(array->elemsize)	
+    GS_ASSERT(array)			// safety check -mj Oct 31st
+    GS_ASSERT(elem)	
+    GS_ASSERT(array->elemsize)	
 
-	memcpy(ArrayNth(array,pos), elem, (size_t)array->elemsize);
+    memcpy(ArrayNth(array,pos), elem, (size_t)array->elemsize);
 }
 
 DArray ArrayNew(int elemSize, int numElemsToAllocate, 
                 ArrayElementFreeFn elemFreeFn)
 {
-	DArray array;
+    DArray array;
 
-	array = (DArray) gsimalloc(sizeof(struct DArrayImplementation));
-	GS_ASSERT(array);
-	GS_ASSERT(elemSize);
-	if (numElemsToAllocate == 0)
-		numElemsToAllocate = DEF_GROWBY;
-	array->count	= 0;
-	array->capacity = numElemsToAllocate;;
-	array->elemsize = elemSize;
-	array->growby	= numElemsToAllocate;
-	array->elemfreefn = elemFreeFn;
-	if (array->capacity != 0)
-	{
-		array->list = gsimalloc((size_t)array->capacity * array->elemsize);
-		GS_ASSERT(array->list);
-	} else
-		array->list = NULL;
+    array = (DArray) gsimalloc(sizeof(struct DArrayImplementation));
+    GS_ASSERT(array);
+    GS_ASSERT(elemSize);
+    if (numElemsToAllocate == 0)
+        numElemsToAllocate = DEF_GROWBY;
+    array->count	= 0;
+    array->capacity = numElemsToAllocate;;
+    array->elemsize = elemSize;
+    array->growby	= numElemsToAllocate;
+    array->elemfreefn = elemFreeFn;
+    if (array->capacity != 0)
+    {
+        array->list = gsimalloc((size_t)array->capacity * array->elemsize);
+        GS_ASSERT(array->list);
+    } else
+        array->list = NULL;
 
-	return array;
+    return array;
 }
 
 void ArrayFree(DArray array)
 {
-	int i;
-	
-	GS_ASSERT(array);
-	for (i = 0; i < array->count; i++)
-	{
-		FreeElement(array, i);
-	}
-	// mj to do: move these asserts into gsi_free.  maybe, depends on whether user overloads them
-	GS_ASSERT(array->list)
-	GS_ASSERT(array)
-	gsifree(array->list);
-	gsifree(array);
+    int i;
+    
+    GS_ASSERT(array);
+    for (i = 0; i < array->count; i++)
+    {
+        FreeElement(array, i);
+    }
+    // mj to do: move these asserts into gsi_free.  maybe, depends on whether user overloads them
+    GS_ASSERT(array->list)
+    GS_ASSERT(array)
+    gsifree(array->list);
+    gsifree(array);
 }
 
 void *ArrayGetDataPtr(DArray array)
 {
-	GS_ASSERT(array);
-	return array->list;
+    GS_ASSERT(array);
+    return array->list;
 }
 
 void ArraySetDataPtr(DArray array, void *ptr, int count, int capacity)
 {
-	int i;
-	
-	GS_ASSERT(array);
-	if (array->list != NULL)
-	{
-		for (i = 0; i < array->count; i++)
-		{
-			FreeElement(array, i);
-		}
-		gsifree(array->list);
-	}
-	array->list = ptr;
-	array->count = count;
-	array->capacity = capacity;
+    int i;
+    
+    GS_ASSERT(array);
+    if (array->list != NULL)
+    {
+        for (i = 0; i < array->count; i++)
+        {
+            FreeElement(array, i);
+        }
+        gsifree(array->list);
+    }
+    array->list = ptr;
+    array->count = count;
+    array->capacity = capacity;
 
 }
 
 
 int ArrayLength(const DArray array)
 {
-	GS_ASSERT(array)
-	return array->count;
+    GS_ASSERT(array)
+    return array->count;
 }
 
 void *ArrayNth(DArray array, int n)
 {
-	// 2004.Nov.16.JED - modified GS_ASSERT to include "if" to add robustness
-	GS_ASSERT( (n >= 0) && (n < array->count));
-	if( ! ((n >= 0) && (n < array->count)) )
-		return NULL;
-	
-	return (char *)array->list + array->elemsize*n;
+    // 2004.Nov.16.JED - modified GS_ASSERT to include "if" to add robustness
+    GS_ASSERT( (n >= 0) && (n < array->count));
+    if( ! ((n >= 0) && (n < array->count)) )
+        return NULL;
+    
+    return (char *)array->list + array->elemsize*n;
 }
 
 /* ArrayAppend
@@ -166,166 +166,166 @@ void *ArrayNth(DArray array, int n)
  */
 void ArrayAppend(DArray array, const void *newElem)
 {
-	GS_ASSERT(array);
-	if(array)
-		ArrayInsertAt(array, newElem, array->count);
+    GS_ASSERT(array);
+    if(array)
+        ArrayInsertAt(array, newElem, array->count);
 }
 
 void ArrayInsertAt(DArray array, const void *newElem, int n)
 {
-	GS_ASSERT (array)
-	GS_ASSERT ( (n >= 0) && (n <= array->count));
+    GS_ASSERT (array)
+    GS_ASSERT ( (n >= 0) && (n <= array->count));
 
-	if (array->count == array->capacity)
-		ArrayGrow(array);
-	array->count++;
-	if (n < array->count - 1) //if we aren't appending
-		memmove(ArrayNth(array, n+1), ArrayNth(array,n), 
-				(size_t)(array->count - 1 - n) * array->elemsize);
-	SetElement(array, newElem, n);
+    if (array->count == array->capacity)
+        ArrayGrow(array);
+    array->count++;
+    if (n < array->count - 1) //if we aren't appending
+        memmove(ArrayNth(array, n+1), ArrayNth(array,n), 
+                (size_t)(array->count - 1 - n) * array->elemsize);
+    SetElement(array, newElem, n);
 }
 
 void ArrayInsertSorted(DArray array, const void *newElem, ArrayCompareFn comparator)
 {
-	int n;
-	void *res;
-	int found;
+    int n;
+    void *res;
+    int found;
 
-	GS_ASSERT (array)
-	GS_ASSERT (comparator);
+    GS_ASSERT (array)
+    GS_ASSERT (comparator);
 
-	res=mybsearch(newElem, array->list,	array->count, array->elemsize, comparator, &found);
-	n = (((char *)res - (char *)array->list) / array->elemsize);
-	ArrayInsertAt(array, newElem, n);
+    res=mybsearch(newElem, array->list,	array->count, array->elemsize, comparator, &found);
+    n = (((char *)res - (char *)array->list) / array->elemsize);
+    ArrayInsertAt(array, newElem, n);
 }
 
 
 void ArrayRemoveAt(DArray array, int n)
 {
- 	GS_ASSERT (array)
-  	GS_ASSERT( (n >= 0) && (n < array->count));
+     GS_ASSERT (array)
+      GS_ASSERT( (n >= 0) && (n < array->count));
 
-	if (n < array->count - 1) //if not last element
-		memmove(ArrayNth(array,n),ArrayNth(array,n+1),
-			    (size_t)(array->count - 1 - n) * array->elemsize);
-	array->count--;
+    if (n < array->count - 1) //if not last element
+        memmove(ArrayNth(array,n),ArrayNth(array,n+1),
+                (size_t)(array->count - 1 - n) * array->elemsize);
+    array->count--;
 }
 
 void ArrayDeleteAt(DArray array, int n)
 {
- 	GS_ASSERT (array)
-   	GS_ASSERT ( (n >= 0) && (n < array->count));
+     GS_ASSERT (array)
+       GS_ASSERT ( (n >= 0) && (n < array->count));
 
-	FreeElement(array,n);
-	ArrayRemoveAt(array, n);
+    FreeElement(array,n);
+    ArrayRemoveAt(array, n);
 }
 
 
 void ArrayReplaceAt(DArray array, const void *newElem, int n)
 {
- 	GS_ASSERT (array)
-	GS_ASSERT ( (n >= 0) && (n < array->count));
+     GS_ASSERT (array)
+    GS_ASSERT ( (n >= 0) && (n < array->count));
 
-	FreeElement(array, n);
-	SetElement(array, newElem,n);
+    FreeElement(array, n);
+    SetElement(array, newElem,n);
 }
 
 
 void ArraySort(DArray array, ArrayCompareFn comparator)
 {
- 	GS_ASSERT (array)
-	qsort(array->list, (size_t)array->count, (size_t)array->elemsize, comparator);
+     GS_ASSERT (array)
+    qsort(array->list, (size_t)array->count, (size_t)array->elemsize, comparator);
 }
 
 //GS_ASSERT will be raised by ArrayNth if fromindex out of range
 int ArraySearch(DArray array, const void *key, ArrayCompareFn comparator, 
                   int fromIndex, int isSorted)
 {
-	void *res;
-	int found = 1;
-	if (!array || array->count == 0)
-		return NOT_FOUND;
+    void *res;
+    int found = 1;
+    if (!array || array->count == 0)
+        return NOT_FOUND;
 
-   	if (isSorted)
-		res=mybsearch(key, ArrayNth(array,fromIndex),
-					array->count - fromIndex, array->elemsize, comparator, &found);
-	else
-		res=mylsearch(key, ArrayNth(array, fromIndex), 
-					  array->count - fromIndex, array->elemsize, comparator);
-	if (res != NULL && found)
-		return (((char *)res - (char *)array->list) / array->elemsize);
-	else
-		return NOT_FOUND;
+       if (isSorted)
+        res=mybsearch(key, ArrayNth(array,fromIndex),
+                    array->count - fromIndex, array->elemsize, comparator, &found);
+    else
+        res=mylsearch(key, ArrayNth(array, fromIndex), 
+                      array->count - fromIndex, array->elemsize, comparator);
+    if (res != NULL && found)
+        return (((char *)res - (char *)array->list) / array->elemsize);
+    else
+        return NOT_FOUND;
 }
 
 
 void ArrayMap(DArray array, ArrayMapFn fn, void *clientData)
 {
-	int i;
+    int i;
 
- 	GS_ASSERT (array)
-	GS_ASSERT(fn);
+     GS_ASSERT (array)
+    GS_ASSERT(fn);
 
-	for (i = 0; i < array->count; i++)
-		fn(ArrayNth(array,i), clientData);
-		
+    for (i = 0; i < array->count; i++)
+        fn(ArrayNth(array,i), clientData);
+        
 }
 
 void ArrayMapBackwards(DArray array, ArrayMapFn fn, void *clientData)
 {
-	int i;
+    int i;
 
-	GS_ASSERT(fn);
+    GS_ASSERT(fn);
 
-	for (i = (array->count - 1) ; i >= 0 ; i--)
-		fn(ArrayNth(array,i), clientData);
-		
+    for (i = (array->count - 1) ; i >= 0 ; i--)
+        fn(ArrayNth(array,i), clientData);
+        
 }
 
 void * ArrayMap2(DArray array, ArrayMapFn2 fn, void *clientData)
 {
-	int i;
-	void * pcurr;
+    int i;
+    void * pcurr;
 
-	GS_ASSERT(fn);
-	GS_ASSERT(clientData);
+    GS_ASSERT(fn);
+    GS_ASSERT(clientData);
 
-	for (i = 0; i < array->count; i++)
-	{
-		pcurr = ArrayNth(array,i);
-		if(!fn(pcurr, clientData))
-			return pcurr;
-	}
+    for (i = 0; i < array->count; i++)
+    {
+        pcurr = ArrayNth(array,i);
+        if(!fn(pcurr, clientData))
+            return pcurr;
+    }
 
-	return NULL;
+    return NULL;
 }
 
 void * ArrayMapBackwards2(DArray array, ArrayMapFn2 fn, void *clientData)
 {
-	int i;
-	void * pcurr;
+    int i;
+    void * pcurr;
 
-	GS_ASSERT(fn);
-	GS_ASSERT(clientData);
+    GS_ASSERT(fn);
+    GS_ASSERT(clientData);
 
-	for (i = (array->count - 1) ; i >= 0 ; i--)
-	{
-		pcurr = ArrayNth(array,i);
-		if(!fn(pcurr, clientData))
-			return pcurr;
-	}
+    for (i = (array->count - 1) ; i >= 0 ; i--)
+    {
+        pcurr = ArrayNth(array,i);
+        if(!fn(pcurr, clientData))
+            return pcurr;
+    }
 
-	return NULL;
+    return NULL;
 }
 
 void ArrayClear(DArray array)
 {
-	int i;
+    int i;
 
-	// This could be more optimal!
-	//////////////////////////////
-	for(i = (ArrayLength(array) - 1) ; i >= 0 ; i--)
-		ArrayDeleteAt(array, i);
+    // This could be more optimal!
+    //////////////////////////////
+    for(i = (ArrayLength(array) - 1) ; i >= 0 ; i--)
+        ArrayDeleteAt(array, i);
 }
 
 /* mylsearch
@@ -333,17 +333,17 @@ void ArrayClear(DArray array)
  * couldn't use lfind
  */
 static void *mylsearch(const void *key, void *base, int count, int size,
-					 ArrayCompareFn comparator)
+                     ArrayCompareFn comparator)
 {
-	int i;
-	GS_ASSERT(key);
-	GS_ASSERT(base);
-	for (i = 0; i < count; i++)
-	{
-		if (comparator(key, (char *)base + size*i) == 0)
-			return (char *)base + size*i;
-	}
-	return NULL;
+    int i;
+    GS_ASSERT(key);
+    GS_ASSERT(base);
+    for (i = 0; i < count; i++)
+    {
+        if (comparator(key, (char *)base + size*i) == 0)
+            return (char *)base + size*i;
+    }
+    return NULL;
 }
 
 /* mybsearch
@@ -351,27 +351,27 @@ static void *mylsearch(const void *key, void *base, int count, int size,
  */
 static void *mybsearch(const void *elem, void *base, int num, int elemsize, ArrayCompareFn comparator, int *found)
 {
-	int L, H, I, C;
-	
-	GS_ASSERT(elem);
-	GS_ASSERT(base);
-	GS_ASSERT(found);
+    int L, H, I, C;
+    
+    GS_ASSERT(elem);
+    GS_ASSERT(base);
+    GS_ASSERT(found);
 
-	L = 0;
-	H = num - 1;
-	*found = 0;
-	while (L <= H)
-	{
-		I = (L + H) >> 1;
-		C = comparator(((char *)base) + I * elemsize,elem);
-		if (C == 0)
-			*found = 1;
-		if (C < 0) 
-			L = I + 1;
-		else
-		{
-			H = I - 1;
-		}
-	}
-	return ((char *)base) + L * elemsize;
+    L = 0;
+    H = num - 1;
+    *found = 0;
+    while (L <= H)
+    {
+        I = (L + H) >> 1;
+        C = comparator(((char *)base) + I * elemsize,elem);
+        if (C == 0)
+            *found = 1;
+        if (C < 0) 
+            L = I + 1;
+        else
+        {
+            H = I - 1;
+        }
+    }
+    return ((char *)base) + L * elemsize;
 }
diff --git a/code/gamespy/darray.h b/code/gamespy/darray.h
index ad84b13f..29ed76cc 100644
--- a/code/gamespy/darray.h
+++ b/code/gamespy/darray.h
@@ -43,9 +43,9 @@ typedef struct DArrayImplementation *DArray;
  * If the two elements are "equal", return 0.
  */
 #if defined(WIN32)
-	typedef int (__cdecl *ArrayCompareFn)(const void *elem1, const void *elem2);
+    typedef int (__cdecl *ArrayCompareFn)(const void *elem1, const void *elem2);
 #else
-	typedef int (*ArrayCompareFn)(const void *elem1, const void *elem2);
+    typedef int (*ArrayCompareFn)(const void *elem1, const void *elem2);
 #endif
 
 
diff --git a/code/gamespy/gcrypt.c b/code/gamespy/gcrypt.c
index ed0f6ab4..372e239d 100644
--- a/code/gamespy/gcrypt.c
+++ b/code/gamespy/gcrypt.c
@@ -188,3 +188,36 @@ void crypt_docrypt(GCryptInfo *info, unsigned char *out, int len)
         info->wordPtr++;
     }
 }
+
+int enctype2_encoder(unsigned char *secKey, unsigned char *data, int size)
+{
+    GCryptInfo info = {0};
+    int        i;
+    int        header_size = 8;
+
+    // move the data and put it after the header
+    for (i = size - 1; i >= 0; i--) {
+        data[1 + header_size + i] = data[i];
+    }
+
+    // initialize the header
+    for (i = 0; i < header_size; i++) {
+        data[i + 1] = 0;
+    }
+
+    // initialize the crypt key
+    init_crypt_key(data + 1, header_size, &info);
+
+    for (i = 0; i < 6; i++) {
+        data[1 + header_size + size + i] = 0;
+    }
+    crypt_docrypt(&info, data + 1 + header_size, size + 6);
+
+    for (i = 0; secKey[i]; i++) {
+        data[i + 1] ^= secKey[i];
+    }
+
+    size += 1 + header_size + 6;
+    *data = header_size ^ 0xec;
+    return size;
+}
diff --git a/code/gamespy/gserver.c b/code/gamespy/gserver.c
index d5ccc7fe..13571064 100644
--- a/code/gamespy/gserver.c
+++ b/code/gamespy/gserver.c
@@ -13,17 +13,17 @@ Fax(714)549-0757
 ******
 
 Updated 10-15-99 (BGW)
-	Modified ServerParseKeyVals to actually parse and store empty
-	values for keys (i.e. "\delete\\" adds key="delete" and value="")
+    Modified ServerParseKeyVals to actually parse and store empty
+    values for keys (i.e. "\delete\\" adds key="delete" and value="")
 Updated 6-17-99 (DDW)
-	Added new tokenize function to handle empty values for keys
+    Added new tokenize function to handle empty values for keys
   
-	
+    
 *******/
 #if defined(applec) || defined(THINK_C) || defined(__MWERKS__) && !defined(__KATANA__)
-	#include "::nonport.h"
+    #include "::nonport.h"
 #else
-	#include "../nonport.h"
+    #include "../nonport.h"
 #endif
 #include "goaceng.h"
 #include "gserver.h"
@@ -43,11 +43,11 @@ static char *LookupKey(GServer server, char *k);
 
 void ServerFree(void *elem)
 {
-	//free a server!
-	GServer server = *(GServer *)elem;
-	
-	TableFree(server->keyvals);
-	free(server);
+    //free a server!
+    GServer server = *(GServer *)elem;
+    
+    TableFree(server->keyvals);
+    free(server);
 }
 
 static void ServerSetAddressFromString (GServer server, char *address)
@@ -106,107 +106,107 @@ GServer ServerNewData(char **fieldlist, int fieldcount, char *serverdata, GQuery
 
 GServer ServerNew(unsigned long ip, unsigned short port, GQueryType qtype, HashTable keylist)
 {
-	GServer server;
-	int nBuckets, nChains;
+    GServer server;
+    int nBuckets, nChains;
 
-	server = malloc(sizeof(struct GServerImplementation));
-	server->ip = ip;
-	server->port = port;
-	server->ping = 9999;
-	server->querytype = qtype;
-	/* optimize the number of buckets / chains based on query type */
-	switch (qtype)
-	{
-	case qt_basic:
-		nBuckets = 4;
-		nChains = 2;
-		break;
-	case qt_info:
-		nBuckets = 6;
-		nChains = 2;
-		break;
-	case qt_players:
-	case qt_rules:
-		nBuckets = 8;
-		nChains = 2;
-		break;
-	case qt_info_rules:
-	case qt_status:
-	default:
-		nBuckets = 8;
-		nChains=  4;
-		break;
-	}
-	server->keyvals = TableNew2(sizeof(GKeyValuePair),nBuckets,nChains, KeyValHashKeyP, KeyValCompareKeyP, NULL);
-	server->keylist = keylist;
-	return server;
+    server = malloc(sizeof(struct GServerImplementation));
+    server->ip = ip;
+    server->port = port;
+    server->ping = 9999;
+    server->querytype = qtype;
+    /* optimize the number of buckets / chains based on query type */
+    switch (qtype)
+    {
+    case qt_basic:
+        nBuckets = 4;
+        nChains = 2;
+        break;
+    case qt_info:
+        nBuckets = 6;
+        nChains = 2;
+        break;
+    case qt_players:
+    case qt_rules:
+        nBuckets = 8;
+        nChains = 2;
+        break;
+    case qt_info_rules:
+    case qt_status:
+    default:
+        nBuckets = 8;
+        nChains=  4;
+        break;
+    }
+    server->keyvals = TableNew2(sizeof(GKeyValuePair),nBuckets,nChains, KeyValHashKeyP, KeyValCompareKeyP, NULL);
+    server->keylist = keylist;
+    return server;
 }
 
 
 static char *mytok(char *instr, char delim)
 {
-	char *result;
-	static char *thestr;
+    char *result;
+    static char *thestr;
 
-	if (instr)
-		thestr = instr;
-	result=thestr;
-	while (*thestr && *thestr != delim)
-	{
-		thestr++;
-	}
-	if (thestr == result)
-		result = NULL;
-	if (*thestr) //not the null term
-		*thestr++ = '\0';
-	return result;
+    if (instr)
+        thestr = instr;
+    result=thestr;
+    while (*thestr && *thestr != delim)
+    {
+        thestr++;
+    }
+    if (thestr == result)
+        result = NULL;
+    if (*thestr) //not the null term
+        *thestr++ = '\0';
+    return result;
 }
 
 static int CheckValidKey(char *key)
 {
-	const char *InvalidKeys[]={"queryid","final"};
-	int i;
-	for (i = 0; i < sizeof(InvalidKeys)/sizeof(InvalidKeys[0]); i++)
-	{
-		if (strcmp(key,InvalidKeys[i]) == 0)
-			return 0;
-	}
-	return 1;
+    const char *InvalidKeys[]={"queryid","final"};
+    int i;
+    for (i = 0; i < sizeof(InvalidKeys)/sizeof(InvalidKeys[0]); i++)
+    {
+        if (strcmp(key,InvalidKeys[i]) == 0)
+            return 0;
+    }
+    return 1;
 }
 
 
 static char *LookupKey(GServer server, char *k)
 {
-	char **keyindex;
+    char **keyindex;
 
-	keyindex = (char **)TableLookup(server->keylist,&k);
-	if (keyindex != NULL)
-		return *keyindex;
-	k = strdup(k);
-	TableEnter(server->keylist,&k);
-	return k;
+    keyindex = (char **)TableLookup(server->keylist,&k);
+    if (keyindex != NULL)
+        return *keyindex;
+    k = strdup(k);
+    TableEnter(server->keylist,&k);
+    return k;
 }
 
 void ServerParseKeyVals(GServer server, char *keyvals)
 {
-	char *k, *v;
-	GKeyValuePair kvpair;
+    char *k, *v;
+    GKeyValuePair kvpair;
 
-	k = mytok(++keyvals,'\\'); //skip over starting backslash
-	while (k != NULL)
-	{
-		v = mytok(NULL,'\\');
-		if (v == NULL)
-			v = "";
-		if (CheckValidKey(k))
-		{
-			kvpair.key = LookupKey(server, k);
-			kvpair.value = LookupKey(server, v);
-			TableEnter(server->keyvals, &kvpair);
-		}
-		k = mytok(NULL,'\\');
+    k = mytok(++keyvals,'\\'); //skip over starting backslash
+    while (k != NULL)
+    {
+        v = mytok(NULL,'\\');
+        if (v == NULL)
+            v = "";
+        if (CheckValidKey(k))
+        {
+            kvpair.key = LookupKey(server, k);
+            kvpair.value = LookupKey(server, v);
+            TableEnter(server->keyvals, &kvpair);
+        }
+        k = mytok(NULL,'\\');
 
-	}
+    }
 }
 
 
@@ -215,7 +215,7 @@ void ServerParseKeyVals(GServer server, char *keyvals)
 Returns the ping for the specified server. */
 int ServerGetPing(GServer server)
 {
-	return server->ping;
+    return server->ping;
 }
 
 /* ServerGetAddress
@@ -223,7 +223,7 @@ int ServerGetPing(GServer server)
 Returns the string, dotted IP address for the specified server */
 char *ServerGetAddress(GServer server)
 {
-	return (char *)inet_ntoa(*(struct in_addr*)&server->ip);
+    return (char *)inet_ntoa(*(struct in_addr*)&server->ip);
 }
 
 /* ServerGetInetAddress
@@ -231,7 +231,7 @@ char *ServerGetAddress(GServer server)
 Returns the IP address for the specified server */
 unsigned int ServerGetInetAddress(GServer server)
 {
-	return server->ip;
+    return server->ip;
 }
 
 
@@ -240,18 +240,18 @@ unsigned int ServerGetInetAddress(GServer server)
 Returns the "query" port for the specified server. */
 int ServerGetQueryPort(GServer server)
 {
-	return server->port;
+    return server->port;
 }
 
 static GKeyValuePair *ServerRuleLookup(GServer server, char *key)
 {
-	GKeyValuePair kvp;
-	char **keyindex;
-	keyindex = (char **)TableLookup(server->keylist, &key);
-	if (keyindex == NULL)
-		return NULL; //otherwise, the keyindex->keyindex is valid, so use it to lookup
-	kvp.key = *keyindex;
-	return (GKeyValuePair *)TableLookup(server->keyvals, &kvp);
+    GKeyValuePair kvp;
+    char **keyindex;
+    keyindex = (char **)TableLookup(server->keylist, &key);
+    if (keyindex == NULL)
+        return NULL; //otherwise, the keyindex->keyindex is valid, so use it to lookup
+    kvp.key = *keyindex;
+    return (GKeyValuePair *)TableLookup(server->keyvals, &kvp);
 }
 
 /* ServerGet[]Value
@@ -259,60 +259,60 @@ static GKeyValuePair *ServerRuleLookup(GServer server, char *key)
 Returns the value for the specified key. */
 char *ServerGetStringValue(GServer server, char *key, char *sdefault)
 {
-	GKeyValuePair *kv;
+    GKeyValuePair *kv;
 
-	if (strcmp(key,"hostaddr") == 0) //ooh! they want the hostaddr!
-		return ServerGetAddress(server);
-	kv = ServerRuleLookup(server,key);
-	if (!kv)
-		return sdefault;
-	return kv->value;
+    if (strcmp(key,"hostaddr") == 0) //ooh! they want the hostaddr!
+        return ServerGetAddress(server);
+    kv = ServerRuleLookup(server,key);
+    if (!kv)
+        return sdefault;
+    return kv->value;
 }
 
 int ServerGetIntValue(GServer server, char *key, int idefault)
 {
-	GKeyValuePair *kv;
+    GKeyValuePair *kv;
 
-	if (strcmp(key,"ping") == 0) //ooh! they want the ping!
-		return ServerGetPing(server);
-	kv = ServerRuleLookup(server,key);
-	if (!kv)
-		return idefault;
-	return atoi(kv->value);
+    if (strcmp(key,"ping") == 0) //ooh! they want the ping!
+        return ServerGetPing(server);
+    kv = ServerRuleLookup(server,key);
+    if (!kv)
+        return idefault;
+    return atoi(kv->value);
 
 }
 
 double ServerGetFloatValue(GServer server, char *key, double fdefault)
 {
-	GKeyValuePair *kv;
+    GKeyValuePair *kv;
 
-	kv = ServerRuleLookup(server,key);
-	if (!kv)
-		return fdefault;
-	return atof(kv->value);
+    kv = ServerRuleLookup(server,key);
+    if (!kv)
+        return fdefault;
+    return atof(kv->value);
 }
 
 char *ServerGetPlayerStringValue(GServer server, int playernum, char *key, char *sdefault)
 {
-	char newkey[32];
-	
-	sprintf(newkey,"%s_%d",key,playernum);
-	return ServerGetStringValue(server, newkey, sdefault);
+    char newkey[32];
+    
+    sprintf(newkey,"%s_%d",key,playernum);
+    return ServerGetStringValue(server, newkey, sdefault);
 }
 int ServerGetPlayerIntValue(GServer server, int playernum, char *key, int idefault)
 {
-	char newkey[32];
-	
-	sprintf(newkey,"%s_%d",key,playernum);
-	return ServerGetIntValue(server, newkey, idefault);
+    char newkey[32];
+    
+    sprintf(newkey,"%s_%d",key,playernum);
+    return ServerGetIntValue(server, newkey, idefault);
 
 }
 double ServerGetPlayerFloatValue(GServer server, int playernum, char *key, double fdefault)
 {
-	char newkey[32];
-	
-	sprintf(newkey,"%s_%d",key,playernum);
-	return ServerGetFloatValue(server, newkey, fdefault);
+    char newkey[32];
+    
+    sprintf(newkey,"%s_%d",key,playernum);
+    return ServerGetFloatValue(server, newkey, fdefault);
 
 }
 
@@ -324,20 +324,20 @@ key/value. The user-defined instance data will be passed to the KeyFn callback *
 
 static void KeyMapF(void *elem, void *clientData)
 {
-	GKeyValuePair *kv = (GKeyValuePair *)elem;
-	GEnumData *ped = (GEnumData *)clientData;
-	ped->EnumFn(kv->key, kv->value, ped->instance);
+    GKeyValuePair *kv = (GKeyValuePair *)elem;
+    GEnumData *ped = (GEnumData *)clientData;
+    ped->EnumFn(kv->key, kv->value, ped->instance);
 }
 
 
 void ServerEnumKeys(GServer server, KeyEnumFn KeyFn, void *instance)
 {
-	GEnumData ed;
+    GEnumData ed;
 
-	ed.EnumFn = KeyFn;
-	ed.instance = instance;
-	ed.keylist = server->keylist;
-	TableMap(server->keyvals, KeyMapF, &ed);
+    ed.EnumFn = KeyFn;
+    ed.instance = instance;
+    ed.keylist = server->keylist;
+    TableMap(server->keyvals, KeyMapF, &ed);
 }
 
 
@@ -349,21 +349,21 @@ void ServerEnumKeys(GServer server, KeyEnumFn KeyFn, void *instance)
 #define MULTIPLIER -1664117991
 static int StringHash(char *s, int numbuckets)
 {
-	unsigned long hashcode = 0;
-	while (*s != 0)
-		hashcode = hashcode * MULTIPLIER + tolower(*s++);
+    unsigned long hashcode = 0;
+    while (*s != 0)
+        hashcode = hashcode * MULTIPLIER + tolower(*s++);
     return (hashcode % numbuckets);
 
 }
 
 int GStringHash(const void *elem, int numbuckets)
 {
-	return StringHash(*(char **)elem, numbuckets);
+    return StringHash(*(char **)elem, numbuckets);
 }
 
 static int KeyValHashKeyP(const void *elem, int numbuckets)
 {
-	return StringHash(((GKeyValuePair *)elem)->key, numbuckets);
+    return StringHash(((GKeyValuePair *)elem)->key, numbuckets);
 }
 
 
@@ -384,12 +384,12 @@ int GCaseInsensitiveCompare(const void *entry1, const void *entry2)
  */
 static int KeyValCompareKeyP(const void *entry1, const void *entry2)
 {
-   	return ((GKeyValuePair *)entry1)->key - ((GKeyValuePair *)entry2)->key;
+       return ((GKeyValuePair *)entry1)->key - ((GKeyValuePair *)entry2)->key;
 }
 
 void GStringFree(void *elem)
 {
-	free(*(char **)elem);
+    free(*(char **)elem);
 }
 
 /* keyval
@@ -397,8 +397,8 @@ void GStringFree(void *elem)
  *
 static int KeyValCompareKeyA(const void *entry1, const void *entry2)
 {
-   	return CaseInsensitiveCompare(&((GKeyValuePair *)entry1)->key, 
-								  &((GKeyValuePair *)entry2)->key);
+       return CaseInsensitiveCompare(&((GKeyValuePair *)entry1)->key, 
+                                  &((GKeyValuePair *)entry2)->key);
 }
 
 */
\ No newline at end of file
diff --git a/code/gamespy/gserver.h b/code/gamespy/gserver.h
index bfae31b8..b7b9dcf6 100644
--- a/code/gamespy/gserver.h
+++ b/code/gamespy/gserver.h
@@ -27,38 +27,38 @@ extern "C" {
 #endif
 
 #if defined(applec) || defined(THINK_C) || defined(__MWERKS__) && !defined(__KATANA__)
-	#include "::hashtable.h"
+    #include "::hashtable.h"
 #else
-	#include "../hashtable.h"
+    #include "../hashtable.h"
 #endif
 
 struct GServerImplementation
 {
-	unsigned long ip;
-	unsigned short port;
-	short ping;
-	GQueryType querytype;
-	HashTable keyvals;
-	HashTable keylist;
+    unsigned long ip;
+    unsigned short port;
+    short ping;
+    GQueryType querytype;
+    HashTable keyvals;
+    HashTable keylist;
 
 };
 
 typedef struct
 {
-	char *key;
-	char *value;
+    char *key;
+    char *value;
 } GKeyValuePair;
 /*
 typedef struct
 {
-	char *key, *value;
+    char *key, *value;
 } GKeyValuePair;
 */
 typedef struct 
 {
-	KeyEnumFn EnumFn;
-	void *instance;
-	HashTable keylist;
+    KeyEnumFn EnumFn;
+    void *instance;
+    HashTable keylist;
 } GEnumData;
 
 void ServerFree(void *elem);
diff --git a/code/gamespy/gserverlist.c b/code/gamespy/gserverlist.c
index 3b089d35..7847838f 100644
--- a/code/gamespy/gserverlist.c
+++ b/code/gamespy/gserverlist.c
@@ -22,16 +22,16 @@ Fax(714)549-0757
 #include "goaceng.h"
 #include "gserver.h"
 #if defined(applec) || defined(THINK_C) || defined(__MWERKS__) && !defined(__KATANA__)
-	#include "::nonport.h"
+    #include "::nonport.h"
 #else
-	#include "../nonport.h"
+    #include "../nonport.h"
 #endif
 #ifdef _MACOS
-	#include "::darray.h"
-	#include "::hashtable.h"
+    #include "::darray.h"
+    #include "::hashtable.h"
 #else
-	#include "../darray.h"
-	#include "../hashtable.h"
+    #include "../darray.h"
+    #include "../hashtable.h"
 #endif
 #include "common/gsPlatformSocket.h"
 #include "gutil.h"
@@ -63,33 +63,33 @@ extern "C" {
 //todo: check state changes on error
 typedef struct 
 {
-	SOCKET s;
-	GServer currentserver;
-	unsigned long starttime;
-	struct sockaddr_in saddr;
+    SOCKET s;
+    GServer currentserver;
+    unsigned long starttime;
+    struct sockaddr_in saddr;
 } UpdateInfo;
 
 typedef enum { pi_fieldcount, pi_fields, pi_servers } GParseInfoState;
 
 struct GServerListImplementation
 {
-	GServerListState state;
-	DArray servers;
-	UpdateInfo *updatelist; //dynamic array of updateinfos
-	char gamename[32];
-	char seckey[32];
-	char enginename[32];
-	int maxupdates;
-	int nextupdate;
-	int abortupdate;
-	ListCallBackFn CallBackFn;
-	void *instance;
-	char *sortkey;
-	gbool sortascending;
-	SOCKET slsocket;
-	unsigned long lanstarttime;
-	GQueryType querytype;
-	HashTable keylist;
+    GServerListState state;
+    DArray servers;
+    UpdateInfo *updatelist; //dynamic array of updateinfos
+    char gamename[32];
+    char seckey[32];
+    char enginename[32];
+    int maxupdates;
+    int nextupdate;
+    int abortupdate;
+    ListCallBackFn CallBackFn;
+    void *instance;
+    char *sortkey;
+    gbool sortascending;
+    SOCKET slsocket;
+    unsigned long lanstarttime;
+    GQueryType querytype;
+    HashTable keylist;
 
     // Added in 2.0
     int numservers;
@@ -106,7 +106,7 @@ GServerList g_sortserverlist; //global serverlist for sorting info!!
 /* these correspond to the qt_ constants */
 #define NUM_QUERYTYPES 6
 const char *querystrings[NUM_QUERYTYPES] = {"\\basic\\","\\info\\","\\rules\\",
-								"\\players\\","\\info\\\\rules\\","\\status\\"};
+                                "\\players\\","\\info\\\\rules\\","\\status\\"};
 const int querylengths[NUM_QUERYTYPES] = {7,6,7,9,13,8};
 
 static void KeyValFree(void *elem);
@@ -119,31 +119,31 @@ static int KeyValHashKeyA(const void *elem, int numbuckets);
 Creates and returns a new (empty) GServerList. */
 GServerList	ServerListNew(const char *gamename, const char *enginename, const char *seckey, int maxconcupdates, void *CallBackFn, int CallBackFnType, void *instance)
 {
-	GServerList list;
+    GServerList list;
 
-	list = (GServerList) malloc(sizeof(struct GServerListImplementation));
-	assert(list != NULL);
-	list->state = sl_idle;
-	list->servers = ArrayNew(sizeof(GServer), SERVER_GROWBY, ServerFree);
-	list->keylist = TableNew2(sizeof(char *),LIST_NUMKEYBUCKETS,LIST_NUMKEYCHAINS,GStringHash, GCaseInsensitiveCompare, GStringFree);
-	list->maxupdates = maxconcupdates;
-	list->updatelist = malloc(maxconcupdates * sizeof(UpdateInfo));
-	memset(list->updatelist, 0, maxconcupdates * sizeof(UpdateInfo));
-	assert(list->updatelist != NULL);
-	strcpy(list->gamename, gamename);
-	strcpy(list->seckey, seckey);
-	strcpy(list->enginename, enginename);
-	list->CallBackFn = CallBackFn;
-	assert(CallBackFn != NULL);
-	list->instance = instance;
-	list->sortkey = "";
+    list = (GServerList) malloc(sizeof(struct GServerListImplementation));
+    assert(list != NULL);
+    list->state = sl_idle;
+    list->servers = ArrayNew(sizeof(GServer), SERVER_GROWBY, ServerFree);
+    list->keylist = TableNew2(sizeof(char *),LIST_NUMKEYBUCKETS,LIST_NUMKEYCHAINS,GStringHash, GCaseInsensitiveCompare, GStringFree);
+    list->maxupdates = maxconcupdates;
+    list->updatelist = malloc(maxconcupdates * sizeof(UpdateInfo));
+    memset(list->updatelist, 0, maxconcupdates * sizeof(UpdateInfo));
+    assert(list->updatelist != NULL);
+    strcpy(list->gamename, gamename);
+    strcpy(list->seckey, seckey);
+    strcpy(list->enginename, enginename);
+    list->CallBackFn = CallBackFn;
+    assert(CallBackFn != NULL);
+    list->instance = instance;
+    list->sortkey = "";
     // Added in 2.0
     list->numservers = 0;
     // Added in OPM
     list->encryptdata = 1;
 
-	SocketStartUp();
-	return list;	
+    SocketStartUp();
+    return list;	
 }
 
 /* ServerListFree
@@ -151,33 +151,33 @@ GServerList	ServerListNew(const char *gamename, const char *enginename, const ch
 Free a GServerList and all internal sturctures and servers */
 void ServerListFree(GServerList serverlist)
 {
-	ArrayFree(serverlist->servers);
-	TableFree(serverlist->keylist);
-	free(serverlist->updatelist);
+    ArrayFree(serverlist->servers);
+    TableFree(serverlist->keylist);
+    free(serverlist->updatelist);
 
-	free(serverlist);
-	SocketShutDown();
+    free(serverlist);
+    SocketShutDown();
 }
 
  //create update sockets and init structures
 static GError InitUpdateList(GServerList serverlist)
 {
-	int i;
+    int i;
 
-	for (i = 0 ; i < serverlist->maxupdates ; i++)
-	{
-		serverlist->updatelist[i].s = socket(AF_INET, SOCK_DGRAM,IPPROTO_UDP);
-		if (serverlist->updatelist[i].s == INVALID_SOCKET)
-		{ //ran out of sockets, just cap maxupdates here, unless we don't have any
-			if (i == 0)
-				return GE_NOSOCKET;
-			serverlist->maxupdates = i;
-			return 0;
-		}
-		serverlist->updatelist[i].currentserver = NULL;
-		serverlist->updatelist[i].starttime = 0;
-	}
-	return 0;
+    for (i = 0 ; i < serverlist->maxupdates ; i++)
+    {
+        serverlist->updatelist[i].s = socket(AF_INET, SOCK_DGRAM,IPPROTO_UDP);
+        if (serverlist->updatelist[i].s == INVALID_SOCKET)
+        { //ran out of sockets, just cap maxupdates here, unless we don't have any
+            if (i == 0)
+                return GE_NOSOCKET;
+            serverlist->maxupdates = i;
+            return 0;
+        }
+        serverlist->updatelist[i].currentserver = NULL;
+        serverlist->updatelist[i].starttime = 0;
+    }
+    return 0;
 
 
 }
@@ -185,12 +185,12 @@ static GError InitUpdateList(GServerList serverlist)
 //free update sockets 
 static GError FreeUpdateList(GServerList serverlist) 
 {
-	int i;
-	for (i = 0 ; i < serverlist->maxupdates ; i++)
-	{
-		closesocket(serverlist->updatelist[i].s);
-	}
-	return 0;
+    int i;
+    for (i = 0 ; i < serverlist->maxupdates ; i++)
+    {
+        closesocket(serverlist->updatelist[i].s);
+    }
+    return 0;
 
 
 }
@@ -198,30 +198,30 @@ static GError FreeUpdateList(GServerList serverlist)
 //create and connect a server list socket
 static GError CreateServerListSocket(GServerList serverlist)
 {
-	struct   sockaddr_in saddr;
-	struct hostent *hent;
+    struct   sockaddr_in saddr;
+    struct hostent *hent;
 
-	saddr.sin_family = AF_INET;
-	saddr.sin_port = htons(MSPORT);
-	saddr.sin_addr.s_addr = inet_addr(MSHOST);
-	if (saddr.sin_addr.s_addr == INADDR_NONE)
-	{
-		hent = gethostbyname(MSHOST);
-		if (!hent)
-			return GE_NODNS; 
-		saddr.sin_addr.s_addr = *(u_long *)hent->h_addr_list[0];
-	}
-	serverlist->slsocket = socket ( AF_INET, SOCK_STREAM, IPPROTO_TCP );
-	if (serverlist->slsocket == INVALID_SOCKET)
-		return GE_NOSOCKET;
-	if (connect ( serverlist->slsocket, (struct sockaddr *) &saddr, sizeof saddr ) != 0)
-	{
-		closesocket(serverlist->slsocket);
-		return GE_NOCONNECT; 
-	}
+    saddr.sin_family = AF_INET;
+    saddr.sin_port = htons(MSPORT);
+    saddr.sin_addr.s_addr = inet_addr(MSHOST);
+    if (saddr.sin_addr.s_addr == INADDR_NONE)
+    {
+        hent = gethostbyname(MSHOST);
+        if (!hent)
+            return GE_NODNS; 
+        saddr.sin_addr.s_addr = *(u_long *)hent->h_addr_list[0];
+    }
+    serverlist->slsocket = socket ( AF_INET, SOCK_STREAM, IPPROTO_TCP );
+    if (serverlist->slsocket == INVALID_SOCKET)
+        return GE_NOSOCKET;
+    if (connect ( serverlist->slsocket, (struct sockaddr *) &saddr, sizeof saddr ) != 0)
+    {
+        closesocket(serverlist->slsocket);
+        return GE_NOCONNECT; 
+    }
 
-	//else we are connected
-	return 0;
+    //else we are connected
+    return 0;
 
 
 }
@@ -230,16 +230,16 @@ static GError CreateServerListSocket(GServerList serverlist)
 //create and connect a server list socket
 static GError CreateServerListLANSocket(GServerList serverlist)
 {
-	int optval = 1;
+    int optval = 1;
 
-	serverlist->slsocket = socket ( AF_INET, SOCK_DGRAM, IPPROTO_UDP );
-	if (serverlist->slsocket == INVALID_SOCKET)
-		return GE_NOSOCKET;
-	if (setsockopt(serverlist->slsocket, SOL_SOCKET, SO_BROADCAST, (char *)&optval, sizeof(optval)) != 0)
-		return GE_NOSOCKET;
+    serverlist->slsocket = socket ( AF_INET, SOCK_DGRAM, IPPROTO_UDP );
+    if (serverlist->slsocket == INVALID_SOCKET)
+        return GE_NOSOCKET;
+    if (setsockopt(serverlist->slsocket, SOL_SOCKET, SO_BROADCAST, (char *)&optval, sizeof(optval)) != 0)
+        return GE_NOSOCKET;
 
-	//else we are ready to broadcast
-	return 0;
+    //else we are ready to broadcast
+    return 0;
 
 
 }
@@ -247,8 +247,8 @@ static GError CreateServerListLANSocket(GServerList serverlist)
 //trigger the callback and set the new mode
 static void ServerListModeChange(GServerList serverlist, GServerListState newstate)
 {
-	serverlist->state = newstate;
-	serverlist->CallBackFn(serverlist, LIST_STATECHANGED, serverlist->instance, NULL, NULL);
+    serverlist->state = newstate;
+    serverlist->CallBackFn(serverlist, LIST_STATECHANGED, serverlist->instance, NULL, NULL);
 
 }
 
@@ -257,28 +257,28 @@ static void ServerListModeChange(GServerList serverlist, GServerListState newsta
 #define SECURE "\\secure\\"
 static GError SendListRequest(GServerList serverlist, char *filter)
 {
-	char data[256], *ptr, result[64];
-	int len;
+    char data[256], *ptr, result[64];
+    int len;
     int i;
     char *modifier;
-	
-	len = recv(serverlist->slsocket, data, sizeof(data) - 1, 0);
-	if (gsiSocketIsError(len))
-		return GE_NOCONNECT;
-	data[len] = '\0'; //null terminate it
-	
-	ptr = strstr ( data, SECURE );
-	if (!ptr)
-		return GE_DATAERROR;
-	ptr = ptr + strlen(SECURE);
-	gs_encrypt   ( (uchar *) serverlist->seckey, 6, (uchar *)ptr, 6 );
+    
+    len = recv(serverlist->slsocket, data, sizeof(data) - 1, 0);
+    if (gsiSocketIsError(len))
+        return GE_NOCONNECT;
+    data[len] = '\0'; //null terminate it
+    
+    ptr = strstr ( data, SECURE );
+    if (!ptr)
+        return GE_DATAERROR;
+    ptr = ptr + strlen(SECURE);
+    gs_encrypt   ( (uchar *) serverlist->seckey, 6, (uchar *)ptr, 6 );
     if (serverlist->encryptdata) {
         // Added in 2.0
         for(i = 0; i < 6; i++) {
             ptr[i] ^= serverlist->seckey[i];
         }
     }
-	gs_encode ( (uchar *)ptr, 6, (uchar *) result );
+    gs_encode ( (uchar *)ptr, 6, (uchar *) result );
 
     if (serverlist->encryptdata) {
         // Added in 2.0
@@ -291,10 +291,10 @@ static GError SendListRequest(GServerList serverlist, char *filter)
         sprintf(data, "\\gamename\\%s\\gamever\\%s\\location\\0\\validate\\%s\\final\\\\queryid\\1.1\\",
                 serverlist->enginename, ENGINE_VERSION, result); //validate us	
     }
-	
-	len = send ( serverlist->slsocket, data, strlen(data), 0 );
-	if (gsiSocketIsError(len) || len == 0)
-		return GE_NOCONNECT;
+    
+    len = send ( serverlist->slsocket, data, strlen(data), 0 );
+    if (gsiSocketIsError(len) || len == 0)
+        return GE_NOCONNECT;
 
     if (serverlist->querytype == qt_grouprooms) {
         modifier = "groups";
@@ -309,34 +309,34 @@ static GError SendListRequest(GServerList serverlist, char *filter)
     }
 
     //send the list request
-	if (filter)
-		sprintf(data, "\\list\\%s\\gamename\\%s\\where\\%s\\final\\", modifier, serverlist->gamename, filter);
-	else
-		sprintf(data, "\\list\\%s\\gamename\\%s\\final\\", modifier, serverlist->gamename);
-	len = send ( serverlist->slsocket, data, strlen(data), 0 );
-	if (gsiSocketIsError(len) || len == 0)
-		return GE_NOCONNECT;
+    if (filter)
+        sprintf(data, "\\list\\%s\\gamename\\%s\\where\\%s\\final\\", modifier, serverlist->gamename, filter);
+    else
+        sprintf(data, "\\list\\%s\\gamename\\%s\\final\\", modifier, serverlist->gamename);
+    len = send ( serverlist->slsocket, data, strlen(data), 0 );
+    if (gsiSocketIsError(len) || len == 0)
+        return GE_NOCONNECT;
 
-	ServerListModeChange(serverlist, sl_listxfer);
-	return 0;
+    ServerListModeChange(serverlist, sl_listxfer);
+    return 0;
 }
 
 
 static GError SendBroadcastRequest(GServerList serverlist, int startport, int endport, int delta)
 {
-	struct   sockaddr_in saddr;
-	short i;
+    struct   sockaddr_in saddr;
+    short i;
 
-	saddr.sin_family = AF_INET;
-	saddr.sin_addr.s_addr = 0xFFFFFFFF; //broadcast
-	for (i = startport ; i <= endport ; i += delta)
-	{
-		saddr.sin_port = htons(i);
-		sendto(serverlist->slsocket, "\\status\\",8,0,(struct sockaddr *)&saddr,sizeof(saddr));
-	}
-	ServerListModeChange(serverlist, sl_lanlist);
-	serverlist->lanstarttime = current_time();
-	return 0;
+    saddr.sin_family = AF_INET;
+    saddr.sin_addr.s_addr = 0xFFFFFFFF; //broadcast
+    for (i = startport ; i <= endport ; i += delta)
+    {
+        saddr.sin_port = htons(i);
+        sendto(serverlist->slsocket, "\\status\\",8,0,(struct sockaddr *)&saddr,sizeof(saddr));
+    }
+    ServerListModeChange(serverlist, sl_lanlist);
+    serverlist->lanstarttime = current_time();
+    return 0;
 
 
 
@@ -345,13 +345,13 @@ static GError SendBroadcastRequest(GServerList serverlist, int startport, int en
 //just wait for the server list to become idle
 static void DoSyncLoop(GServerList serverlist)
 {
-	while (serverlist->state != sl_idle)
-	{
-		ServerListThink(serverlist);
-		msleep(10);
-		
-	}
-	
+    while (serverlist->state != sl_idle)
+    {
+        ServerListThink(serverlist);
+        msleep(10);
+        
+    }
+    
 }
 
 /* ServerListUpdate
@@ -359,7 +359,7 @@ static void DoSyncLoop(GServerList serverlist)
 Start updating a GServerList without filters */
 GError ServerListUpdate(GServerList serverlist, gbool async)
 {
-	return ServerListUpdate2(serverlist, async, NULL, qt_status);
+    return ServerListUpdate2(serverlist, async, NULL, qt_status);
 }
 
 /* ServerListUpdate2
@@ -367,28 +367,28 @@ GError ServerListUpdate(GServerList serverlist, gbool async)
 Start updating a GServerList. */
 GError ServerListUpdate2(GServerList serverlist, gbool async, char *filter, GQueryType querytype)
 {
-	GError error;
+    GError error;
 
-	if (serverlist->state != sl_idle)
-		return GE_BUSY;
+    if (serverlist->state != sl_idle)
+        return GE_BUSY;
 
-	serverlist->querytype = querytype;
-	error = CreateServerListSocket(serverlist);
-	if (error) return error;
-	error = SendListRequest(serverlist, filter);
-	if (error) return error;
-	error = InitUpdateList(serverlist);
-	if (error) return error;
-	serverlist->nextupdate = 0;
-	serverlist->abortupdate = 0;
+    serverlist->querytype = querytype;
+    error = CreateServerListSocket(serverlist);
+    if (error) return error;
+    error = SendListRequest(serverlist, filter);
+    if (error) return error;
+    error = InitUpdateList(serverlist);
+    if (error) return error;
+    serverlist->nextupdate = 0;
+    serverlist->abortupdate = 0;
     // Added in 2.0
     serverlist->numservers = ServerListCount(serverlist);
     // Added in 2.0
     serverlist->cryptinfo.offset = -1;
-	if (!async)
-		DoSyncLoop(serverlist);
+    if (!async)
+        DoSyncLoop(serverlist);
 
-	return 0;
+    return 0;
 }
 
 /* ServerListLANUpdate
@@ -396,25 +396,25 @@ GError ServerListUpdate2(GServerList serverlist, gbool async, char *filter, GQue
 Start updating a GServerList from servers on the LAN. */
 GError ServerListLANUpdate(GServerList serverlist, gbool async, int startsearchport, int endsearchport, int searchdelta)
 {
-	GError error;
+    GError error;
 
-	assert(searchdelta > 0);
+    assert(searchdelta > 0);
 
-	if (serverlist->state != sl_idle)
-		return GE_BUSY;
+    if (serverlist->state != sl_idle)
+        return GE_BUSY;
 
-	error = InitUpdateList(serverlist);
-	if (error) return error;
-	error = CreateServerListLANSocket(serverlist);
-	if (error) return error;
-	error = SendBroadcastRequest(serverlist, startsearchport, endsearchport, searchdelta);
-	if (error) return error;
-	serverlist->nextupdate = 0;
-	serverlist->abortupdate = 0;
-	if (!async)
-		DoSyncLoop(serverlist);
+    error = InitUpdateList(serverlist);
+    if (error) return error;
+    error = CreateServerListLANSocket(serverlist);
+    if (error) return error;
+    error = SendBroadcastRequest(serverlist, startsearchport, endsearchport, searchdelta);
+    if (error) return error;
+    serverlist->nextupdate = 0;
+    serverlist->abortupdate = 0;
+    if (!async)
+        DoSyncLoop(serverlist);
 
-	return 0;
+    return 0;
 }
 
 //add a new server based on the data
@@ -430,36 +430,36 @@ static GServer ServerListAddServerData(GServerList serverlist, char **fieldlist,
 //add the server to the list with the given ip, port
 static void ServerListAddServer(GServerList serverlist, unsigned long ip, unsigned short port, GQueryType qtype)
 {
-	GServer server;
-	server =  ServerNew(ip, port, qtype, serverlist->keylist);
-	ArrayAppend(serverlist->servers,&server);
+    GServer server;
+    server =  ServerNew(ip, port, qtype, serverlist->keylist);
+    ArrayAppend(serverlist->servers,&server);
  //printf("%d %s:%d\n",++count, ip,port);
 }
 
 //add the server to the list with the given ip, port
 static void ServerListInsertServer(GServerList serverlist, unsigned long ip, unsigned short port, int pos, GQueryType qtype)
 {
-	GServer server;
-	server =  ServerNew(ip, port, qtype, serverlist->keylist);
-	ArrayInsertAt(serverlist->servers,&server,pos);
+    GServer server;
+    server =  ServerNew(ip, port, qtype, serverlist->keylist);
+    ArrayInsertAt(serverlist->servers,&server,pos);
  //printf("%d %s:%d\n",++count, ip,port);
 }
 
 //find the server in the list, returns -1 if it does not exist
 static int ServerListFindServerMax(GServerList serverlist, unsigned int ip, int port, int count)
 {
-	int i;
-	GServer server;
+    int i;
+    GServer server;
 
-	for (i = 0; i < count ; i++)
-	{
-		server = *(GServer *)ArrayNth(serverlist->servers,i);
-		if (port == ServerGetQueryPort(server) && ServerGetInetAddress(server)==ip)
-		{
-			return i;
-		}
-	}
-	return -1;
+    for (i = 0; i < count ; i++)
+    {
+        server = *(GServer *)ArrayNth(serverlist->servers,i);
+        if (port == ServerGetQueryPort(server) && ServerGetInetAddress(server)==ip)
+        {
+            return i;
+        }
+    }
+    return -1;
 }
 
 //find the server in the list, returns -1 if it does not exist
@@ -472,14 +472,14 @@ static int ServerListFindServer(GServerList serverlist, unsigned int ip, int por
 // returns -1 if it does not exist
 static int ServerListFindServerInUpdateList(GServerList serverlist, GServer server)
 {
-	int i;
+    int i;
 
-	for (i = 0 ; i < serverlist->maxupdates ; i++)
-	{
-		if (serverlist->updatelist[i].currentserver == server)
-			return i;
-	}
-	return -1;
+    for (i = 0 ; i < serverlist->maxupdates ; i++)
+    {
+        if (serverlist->updatelist[i].currentserver == server)
+            return i;
+    }
+    return -1;
 }
 
 /* ServerListRemoveServer
@@ -487,22 +487,22 @@ static int ServerListFindServerInUpdateList(GServerList serverlist, GServer serv
 Removes a single server from the list. Frees the memory associated with the GServer */
 void ServerListRemoveServer(GServerList serverlist, char *ip, int port)
 {
-	int currentindex = ServerListFindServer(serverlist, inet_addr(ip), port);
-	int updateindex;
+    int currentindex = ServerListFindServer(serverlist, inet_addr(ip), port);
+    int updateindex;
 
-	if (currentindex == -1)
-		return; //can't do anything, it doesn't exist
+    if (currentindex == -1)
+        return; //can't do anything, it doesn't exist
 
-	//check to see whether we need to change the updatelist or move the nextupdate
-	if (serverlist->state != sl_idle && serverlist->nextupdate > currentindex) 
-	{
-		GServer holdserver = *(GServer *)ArrayNth(serverlist->servers,currentindex);
-		updateindex = ServerListFindServerInUpdateList(serverlist, holdserver);
-		if (updateindex != -1) //is currently being queried, stop it
-			serverlist->updatelist[updateindex].currentserver = NULL;
-		serverlist->nextupdate--; //decrement the next update, since we are removing a server
-	}
-	ArrayDeleteAt(serverlist->servers, currentindex); 
+    //check to see whether we need to change the updatelist or move the nextupdate
+    if (serverlist->state != sl_idle && serverlist->nextupdate > currentindex) 
+    {
+        GServer holdserver = *(GServer *)ArrayNth(serverlist->servers,currentindex);
+        updateindex = ServerListFindServerInUpdateList(serverlist, holdserver);
+        if (updateindex != -1) //is currently being queried, stop it
+            serverlist->updatelist[updateindex].currentserver = NULL;
+        serverlist->nextupdate--; //decrement the next update, since we are removing a server
+    }
+    ArrayDeleteAt(serverlist->servers, currentindex); 
 }
 
 /* ServerListUpdate
@@ -511,100 +511,100 @@ Adds an auxilliary (non-fetched) server to the update list.
 If the engine is idle, the server is added and the engine started. */
 GError ServerListAuxUpdate(GServerList serverlist, const char *ip, int port, gbool async, GQueryType querytype)
 {
-	GError error;
-	int currentindex;
-	int updateindex;
-	unsigned int real_ip = inet_addr(ip);
-	//first, see if the server already exists
-	currentindex = ServerListFindServer(serverlist,real_ip,port);
+    GError error;
+    int currentindex;
+    int updateindex;
+    unsigned int real_ip = inet_addr(ip);
+    //first, see if the server already exists
+    currentindex = ServerListFindServer(serverlist,real_ip,port);
 
 
-	//if we're idle, start things up
-	if (serverlist->state == sl_idle)
-	{
-		//prepare as if we're going to do a normal list fetch,
-		//but skip the call to SendListRequest().
+    //if we're idle, start things up
+    if (serverlist->state == sl_idle)
+    {
+        //prepare as if we're going to do a normal list fetch,
+        //but skip the call to SendListRequest().
 
-		
-		error = InitUpdateList(serverlist);
-		if (error) return error;
-		if (currentindex != -1) //we need to "move" this server to the end of the list
-		{ //move the server to the end of the array
-			GServer holdserver = *(GServer *)ArrayNth(serverlist->servers,currentindex);
-			holdserver->ping = 9999;//clear the ping so it gets recalculated
-			ArrayRemoveAt(serverlist->servers,currentindex);
-			ArrayAppend(serverlist->servers,&holdserver);
-		} else
-		{	//add the aux server
-			ServerListAddServer(serverlist, real_ip, (unsigned short)port, querytype);
-		}
-		
-		serverlist->nextupdate = ArrayLength(serverlist->servers) - 1;
-		serverlist->abortupdate = 0;
+        
+        error = InitUpdateList(serverlist);
+        if (error) return error;
+        if (currentindex != -1) //we need to "move" this server to the end of the list
+        { //move the server to the end of the array
+            GServer holdserver = *(GServer *)ArrayNth(serverlist->servers,currentindex);
+            holdserver->ping = 9999;//clear the ping so it gets recalculated
+            ArrayRemoveAt(serverlist->servers,currentindex);
+            ArrayAppend(serverlist->servers,&holdserver);
+        } else
+        {	//add the aux server
+            ServerListAddServer(serverlist, real_ip, (unsigned short)port, querytype);
+        }
+        
+        serverlist->nextupdate = ArrayLength(serverlist->servers) - 1;
+        serverlist->abortupdate = 0;
 
-		//chane the mode straight to querying
-		ServerListModeChange(serverlist, sl_querying);
-		//is it's a sync call, do it until done
-		if (!async)
-			DoSyncLoop(serverlist);
+        //chane the mode straight to querying
+        ServerListModeChange(serverlist, sl_querying);
+        //is it's a sync call, do it until done
+        if (!async)
+            DoSyncLoop(serverlist);
 
-	}
-	else
-	{
-		//if we're in the middle of an update, we should
-		//be able to just slip the aux server in for querying
-		//ServerListAddServer(serverlist, ip, port);
-		//crt -- make it the next server to be queried
-		//note: this should NEVER be called in a different thread from think!!
-		if (currentindex == -1) //it doesn't exist yet
-			ServerListInsertServer(serverlist, real_ip, (unsigned short)port, serverlist->nextupdate, querytype);
-		else 
-		{ //it exists, find out whats happening to it
-			GServer holdserver = *(GServer *)ArrayNth(serverlist->servers,currentindex);
-			if (currentindex >= serverlist->nextupdate) //hasn't been queried yet!
-				return 0; //it will be queried soon anyway
-			holdserver->ping = 9999;//clear the ping so it gets recalculated
-			updateindex = ServerListFindServerInUpdateList(serverlist, holdserver);
-			if (updateindex != -1) //is currently being queried, stop it
-				serverlist->updatelist[updateindex].currentserver = NULL;
-			ArrayInsertAt(serverlist->servers,&holdserver, serverlist->nextupdate); //insert at new place
-			ArrayRemoveAt(serverlist->servers,currentindex); //remove the old one
-			serverlist->nextupdate--; //decrement the next update, since we are removing a server
-		}
-	}
-	return 0;
+    }
+    else
+    {
+        //if we're in the middle of an update, we should
+        //be able to just slip the aux server in for querying
+        //ServerListAddServer(serverlist, ip, port);
+        //crt -- make it the next server to be queried
+        //note: this should NEVER be called in a different thread from think!!
+        if (currentindex == -1) //it doesn't exist yet
+            ServerListInsertServer(serverlist, real_ip, (unsigned short)port, serverlist->nextupdate, querytype);
+        else 
+        { //it exists, find out whats happening to it
+            GServer holdserver = *(GServer *)ArrayNth(serverlist->servers,currentindex);
+            if (currentindex >= serverlist->nextupdate) //hasn't been queried yet!
+                return 0; //it will be queried soon anyway
+            holdserver->ping = 9999;//clear the ping so it gets recalculated
+            updateindex = ServerListFindServerInUpdateList(serverlist, holdserver);
+            if (updateindex != -1) //is currently being queried, stop it
+                serverlist->updatelist[updateindex].currentserver = NULL;
+            ArrayInsertAt(serverlist->servers,&holdserver, serverlist->nextupdate); //insert at new place
+            ArrayRemoveAt(serverlist->servers,currentindex); //remove the old one
+            serverlist->nextupdate--; //decrement the next update, since we are removing a server
+        }
+    }
+    return 0;
 }
 
 static GError ServerListLANList(GServerList serverlist)
 {
-	struct timeval timeout = {0,0};
-	fd_set set;
-	char indata[1500];
-	struct   sockaddr_in saddr;
-	int saddrlen = sizeof(saddr);
-	int error;
+    struct timeval timeout = {0,0};
+    fd_set set;
+    char indata[1500];
+    struct   sockaddr_in saddr;
+    int saddrlen = sizeof(saddr);
+    int error;
 
-	while (1) //we break if the select fails
-	{
-		FD_ZERO(&set);
-		FD_SET( serverlist->slsocket, &set);
-		error = select(FD_SETSIZE, &set, NULL, NULL, &timeout);
-		if (gsiSocketIsError(error) || 0 == error) //no data
-			break;
-		error = recvfrom(serverlist->slsocket, indata, sizeof(indata) - 1, 0, (struct sockaddr *)&saddr, &saddrlen );
-		if (gsiSocketIsError(error))
-			continue; 
-		//we got data, add the server to the list to update
-		if (strstr(indata,"\\final\\") != NULL)
-			ServerListAddServer(serverlist,saddr.sin_addr.s_addr, ntohs(saddr.sin_port), qt_status);
-	}
-	if (current_time() - serverlist->lanstarttime > LAN_SEARCH_TIME) //done waiting for replies
-	{
-		closesocket(serverlist->slsocket);
-		serverlist->slsocket = INVALID_SOCKET;
-		ServerListModeChange(serverlist, sl_querying);
-	}
-	return 0;
+    while (1) //we break if the select fails
+    {
+        FD_ZERO(&set);
+        FD_SET( serverlist->slsocket, &set);
+        error = select(FD_SETSIZE, &set, NULL, NULL, &timeout);
+        if (gsiSocketIsError(error) || 0 == error) //no data
+            break;
+        error = recvfrom(serverlist->slsocket, indata, sizeof(indata) - 1, 0, (struct sockaddr *)&saddr, &saddrlen );
+        if (gsiSocketIsError(error))
+            continue; 
+        //we got data, add the server to the list to update
+        if (strstr(indata,"\\final\\") != NULL)
+            ServerListAddServer(serverlist,saddr.sin_addr.s_addr, ntohs(saddr.sin_port), qt_status);
+    }
+    if (current_time() - serverlist->lanstarttime > LAN_SEARCH_TIME) //done waiting for replies
+    {
+        closesocket(serverlist->slsocket);
+        serverlist->slsocket = INVALID_SOCKET;
+        ServerListModeChange(serverlist, sl_querying);
+    }
+    return 0;
 }
 
 static int CountSlashOffset(char *data, int len, int slashcount)
@@ -699,35 +699,35 @@ static int ServerListParseInfoList(GServerList serverlist, char *data, int len)
 //reads the server list from the socket and parses it
 static GError ServerListReadList(GServerList serverlist)
 {
-	static char data[2048]; //static input buffer
-	static int oldlen = 0;
-	fd_set set;
-	struct timeval timeout = {0,0};
-	int len, i;
-	char *p;
-	unsigned long ip;
-	unsigned short port;
+    static char data[2048]; //static input buffer
+    static int oldlen = 0;
+    fd_set set;
+    struct timeval timeout = {0,0};
+    int len, i;
+    char *p;
+    unsigned long ip;
+    unsigned short port;
 
-	FD_ZERO(&set);
-	FD_SET(serverlist->slsocket, &set);
+    FD_ZERO(&set);
+    FD_SET(serverlist->slsocket, &set);
 #ifndef KGTRN_ACCESS
-	i = select( FD_SETSIZE, &set, NULL, NULL, &timeout );
-	if (i <= 0)
-		return GE_NOERROR;
+    i = select( FD_SETSIZE, &set, NULL, NULL, &timeout );
+    if (i <= 0)
+        return GE_NOERROR;
 #endif
 
 //append to data
-	len = recv(serverlist->slsocket, data + oldlen, sizeof(data) - oldlen - 1, 0);
-	if (gsiSocketIsError(len) || len == 0)
-	{
-		closesocket(serverlist->slsocket);
-		serverlist->slsocket = INVALID_SOCKET;
-		oldlen = 0; //clear data so it can be used again
-		ServerListHalt(serverlist);
-		ServerListModeChange(serverlist, sl_querying);
-		return GE_NOCONNECT;
+    len = recv(serverlist->slsocket, data + oldlen, sizeof(data) - oldlen - 1, 0);
+    if (gsiSocketIsError(len) || len == 0)
+    {
+        closesocket(serverlist->slsocket);
+        serverlist->slsocket = INVALID_SOCKET;
+        oldlen = 0; //clear data so it can be used again
+        ServerListHalt(serverlist);
+        ServerListModeChange(serverlist, sl_querying);
+        return GE_NOCONNECT;
 
-	}
+    }
 
     if (serverlist->encryptdata && serverlist->cryptinfo.offset != -1) {
         // Added in 2.0
@@ -736,7 +736,7 @@ static GError ServerListReadList(GServerList serverlist)
 
     oldlen += len;
 
-	p = data;
+    p = data;
 
     if (!serverlist->encryptdata) {
         serverlist->cryptinfo.offset = 0;
@@ -790,9 +790,9 @@ static GError ServerListReadList(GServerList serverlist)
             }
         }
     }
-	oldlen = oldlen - (p - data);
-	memmove(data,p,oldlen); //shift it over
-	return 0;
+    oldlen = oldlen - (p - data);
+    memmove(data,p,oldlen); //shift it over
+    return 0;
 
 }
 
@@ -800,96 +800,96 @@ static GError ServerListReadList(GServerList serverlist)
 
 static GError ServerListQueryLoop(GServerList serverlist)
 {
-	int i, scount = 0, error, final;
-	fd_set set;
-	struct timeval timeout = {0,0};
-	char indata[1500];
-	struct sockaddr_in saddr;
-	int saddrlen = sizeof(saddr);
-	GServer server;
+    int i, scount = 0, error, final;
+    fd_set set;
+    struct timeval timeout = {0,0};
+    char indata[1500];
+    struct sockaddr_in saddr;
+    int saddrlen = sizeof(saddr);
+    GServer server;
 
 //first, check for available data
-	FD_ZERO(&set);
-	for (i = 0 ; i < serverlist->maxupdates ; i++)
-		if (serverlist->updatelist[i].currentserver != NULL) //there is a server waiting
-		{
-			scount++;
-			FD_SET( serverlist->updatelist[i].s, &set);
+    FD_ZERO(&set);
+    for (i = 0 ; i < serverlist->maxupdates ; i++)
+        if (serverlist->updatelist[i].currentserver != NULL) //there is a server waiting
+        {
+            scount++;
+            FD_SET( serverlist->updatelist[i].s, &set);
 
-		}
-	if (scount > 0) //there are sockets to check for data
-	{
+        }
+    if (scount > 0) //there are sockets to check for data
+    {
 
-		error = select(FD_SETSIZE, &set, NULL, NULL, &timeout);
-		if (!gsiSocketIsError(error) && 0 != error)
-			for (i = 0 ; i < serverlist->maxupdates ; i++)
-				if (serverlist->updatelist[i].currentserver != NULL && FD_ISSET(serverlist->updatelist[i].s, &set) ) //there is a server waiting
-				{ //we can read data!!
-					saddrlen = sizeof(saddr);
-					error = recvfrom(serverlist->updatelist[i].s, indata, sizeof(indata) - 1, 0,(struct sockaddr *)&saddr, &saddrlen);
+        error = select(FD_SETSIZE, &set, NULL, NULL, &timeout);
+        if (!gsiSocketIsError(error) && 0 != error)
+            for (i = 0 ; i < serverlist->maxupdates ; i++)
+                if (serverlist->updatelist[i].currentserver != NULL && FD_ISSET(serverlist->updatelist[i].s, &set) ) //there is a server waiting
+                { //we can read data!!
+                    saddrlen = sizeof(saddr);
+                    error = recvfrom(serverlist->updatelist[i].s, indata, sizeof(indata) - 1, 0,(struct sockaddr *)&saddr, &saddrlen);
 
-					if (saddr.sin_addr.s_addr != serverlist->updatelist[i].saddr.sin_addr.s_addr ||
-							saddr.sin_port != serverlist->updatelist[i].saddr.sin_port)
-						continue; //it wasn't from this server
+                    if (saddr.sin_addr.s_addr != serverlist->updatelist[i].saddr.sin_addr.s_addr ||
+                            saddr.sin_port != serverlist->updatelist[i].saddr.sin_port)
+                        continue; //it wasn't from this server
 
-					if (!gsiSocketIsError(error)) //we got data
-					{
-						indata[error] = 0; //truncate and parse it
-						final = (strstr(indata,"\\final\\") != NULL);
-						server = serverlist->updatelist[i].currentserver;
-						if (server->ping == 9999) //set the ping
-							server->ping = (short)(current_time() - serverlist->updatelist[i].starttime);
-						ServerParseKeyVals(server, indata); 
-						if (final) //it's all done
-						{
-							serverlist->CallBackFn(serverlist, 
-													LIST_PROGRESS, 
-													serverlist->instance,
-													server,
-													(void *)((serverlist->nextupdate * 100) / ArrayLength(serverlist->servers))); //percent done
-							serverlist->updatelist[i].currentserver = NULL; //reuse the updatelist
-						} 
-					} else
-						serverlist->updatelist[i].currentserver = NULL; //reuse the updatelist
-					
-				}
-	}
-	//kill expired ones
-	for (i = 0 ; i < serverlist->maxupdates ; i++)
-		if (serverlist->updatelist[i].currentserver != NULL && current_time() - serverlist->updatelist[i].starttime > SERVER_TIMEOUT ) 
-		{
-			/* serverlist->CallBackFn(serverlist,  //do we want to notify of dead servers? if so, uncomment!
-				LIST_PROGRESS, 
-				serverlist->instance,
-				*(GServer *)serverlist->updatelist[i].currentserver,
-				(void *)((serverlist->nextupdate * 100) / ArrayLength(serverlist->servers))); //percent done
-				*/
-			serverlist->updatelist[i].currentserver = NULL; //reuse the updatelist
-		}
-		
-	if (serverlist->abortupdate || (serverlist->nextupdate >= ArrayLength(serverlist->servers) && scount == 0)) 
-	{ //we are done!!
-		FreeUpdateList(serverlist);
-		ServerListModeChange(serverlist, sl_idle);
-		return 0;
-	}
-	
+                    if (!gsiSocketIsError(error)) //we got data
+                    {
+                        indata[error] = 0; //truncate and parse it
+                        final = (strstr(indata,"\\final\\") != NULL);
+                        server = serverlist->updatelist[i].currentserver;
+                        if (server->ping == 9999) //set the ping
+                            server->ping = (short)(current_time() - serverlist->updatelist[i].starttime);
+                        ServerParseKeyVals(server, indata); 
+                        if (final) //it's all done
+                        {
+                            serverlist->CallBackFn(serverlist, 
+                                                    LIST_PROGRESS, 
+                                                    serverlist->instance,
+                                                    server,
+                                                    (void *)((serverlist->nextupdate * 100) / ArrayLength(serverlist->servers))); //percent done
+                            serverlist->updatelist[i].currentserver = NULL; //reuse the updatelist
+                        } 
+                    } else
+                        serverlist->updatelist[i].currentserver = NULL; //reuse the updatelist
+                    
+                }
+    }
+    //kill expired ones
+    for (i = 0 ; i < serverlist->maxupdates ; i++)
+        if (serverlist->updatelist[i].currentserver != NULL && current_time() - serverlist->updatelist[i].starttime > SERVER_TIMEOUT ) 
+        {
+            /* serverlist->CallBackFn(serverlist,  //do we want to notify of dead servers? if so, uncomment!
+                LIST_PROGRESS, 
+                serverlist->instance,
+                *(GServer *)serverlist->updatelist[i].currentserver,
+                (void *)((serverlist->nextupdate * 100) / ArrayLength(serverlist->servers))); //percent done
+                */
+            serverlist->updatelist[i].currentserver = NULL; //reuse the updatelist
+        }
+        
+    if (serverlist->abortupdate || (serverlist->nextupdate >= ArrayLength(serverlist->servers) && scount == 0)) 
+    { //we are done!!
+        FreeUpdateList(serverlist);
+        ServerListModeChange(serverlist, sl_idle);
+        return 0;
+    }
+    
 //now, send out queries on available sockets
-	for (i = 0 ; i < serverlist->maxupdates && serverlist->nextupdate < ArrayLength(serverlist->servers) ; i++)
-		if (serverlist->updatelist[i].currentserver == NULL) //it's availalbe
-		{
-			server = *(GServer *)ArrayNth(serverlist->servers,serverlist->nextupdate);
-			serverlist->nextupdate++;
-			serverlist->updatelist[i].currentserver = server;
-			serverlist->updatelist[i].saddr.sin_family = AF_INET;
-			serverlist->updatelist[i].saddr.sin_addr.s_addr = inet_addr(ServerGetAddress(server));
-			serverlist->updatelist[i].saddr.sin_port = htons((short)ServerGetQueryPort(server));
-			sendto(serverlist->updatelist[i].s,querystrings[server->querytype] ,querylengths[server->querytype],0,(struct sockaddr *)&serverlist->updatelist[i].saddr,sizeof(struct sockaddr_in));
-			serverlist->updatelist[i].starttime = current_time();
-		}
+    for (i = 0 ; i < serverlist->maxupdates && serverlist->nextupdate < ArrayLength(serverlist->servers) ; i++)
+        if (serverlist->updatelist[i].currentserver == NULL) //it's availalbe
+        {
+            server = *(GServer *)ArrayNth(serverlist->servers,serverlist->nextupdate);
+            serverlist->nextupdate++;
+            serverlist->updatelist[i].currentserver = server;
+            serverlist->updatelist[i].saddr.sin_family = AF_INET;
+            serverlist->updatelist[i].saddr.sin_addr.s_addr = inet_addr(ServerGetAddress(server));
+            serverlist->updatelist[i].saddr.sin_port = htons((short)ServerGetQueryPort(server));
+            sendto(serverlist->updatelist[i].s,querystrings[server->querytype] ,querylengths[server->querytype],0,(struct sockaddr *)&serverlist->updatelist[i].saddr,sizeof(struct sockaddr_in));
+            serverlist->updatelist[i].starttime = current_time();
+        }
 
 
-	return 0;
+    return 0;
 }
 
 /* ServerListThink
@@ -899,23 +899,23 @@ updating to occur during async server list updates */
 GError ServerListThink(GServerList serverlist)
 {
 
-	switch (serverlist->state)
-	{
-		case sl_idle: return 0;
-		case sl_listxfer:
-				 //read the data
-				return ServerListReadList(serverlist);
-				break;
-		case sl_lanlist:
-				return ServerListLANList(serverlist);
-		case sl_querying: 
-				//do some queries
-				return ServerListQueryLoop(serverlist);
-				break;
-	}
+    switch (serverlist->state)
+    {
+        case sl_idle: return 0;
+        case sl_listxfer:
+                 //read the data
+                return ServerListReadList(serverlist);
+                break;
+        case sl_lanlist:
+                return ServerListLANList(serverlist);
+        case sl_querying: 
+                //do some queries
+                return ServerListQueryLoop(serverlist);
+                break;
+    }
 
 
-	return 0;
+    return 0;
 }
 
 /* ServerListHalt
@@ -923,10 +923,10 @@ GError ServerListThink(GServerList serverlist)
 Halts the current update batch */
 GError ServerListHalt(GServerList serverlist)
 {
-	if (serverlist->state != sl_idle)
-		serverlist->abortupdate = 1;
+    if (serverlist->state != sl_idle)
+        serverlist->abortupdate = 1;
 
-	return 0;
+    return 0;
 }
 
 /* ServerListClear
@@ -935,13 +935,13 @@ Clear and free all of the servers from the server list.
 List must be in the sl_idle state */
 GError ServerListClear(GServerList serverlist)
 {
-	
-	if (serverlist->state != sl_idle)
-		return GE_BUSY;
-	//fastest way to clear is kill and recreate
-	ArrayFree(serverlist->servers);
-	serverlist->servers = ArrayNew(sizeof(GServer), SERVER_GROWBY, ServerFree);
-	return 0;
+    
+    if (serverlist->state != sl_idle)
+        return GE_BUSY;
+    //fastest way to clear is kill and recreate
+    ArrayFree(serverlist->servers);
+    serverlist->servers = ArrayNew(sizeof(GServer), SERVER_GROWBY, ServerFree);
+    return 0;
 }
 
 /* ServerListState
@@ -949,7 +949,7 @@ GError ServerListClear(GServerList serverlist)
 Returns the current state of the server list */
 GServerListState ServerListState(GServerList serverlist)
 {
-	return serverlist->state;
+    return serverlist->state;
 }
 
 /* ServerListErrorDesc
@@ -957,16 +957,16 @@ GServerListState ServerListState(GServerList serverlist)
 Returns a static string description of the specified error */
 char *ServerListErrorDesc(GServerList serverlist, GError error)
 {
-	switch (error)
-	{
-	case GE_NOERROR: return "";
-	case GE_NOSOCKET: return "Unable to create socket";
-	case GE_NODNS: return "Unable to resolve master";
-	case GE_NOCONNECT: return "Connection to master reset";
-	case GE_BUSY: return "Server List is busy";
-	case GE_DATAERROR: return "Unexpected data in server list";
-	}
-	return "UNKNOWN ERROR CODE";
+    switch (error)
+    {
+    case GE_NOERROR: return "";
+    case GE_NOSOCKET: return "Unable to create socket";
+    case GE_NODNS: return "Unable to resolve master";
+    case GE_NOCONNECT: return "Connection to master reset";
+    case GE_BUSY: return "Server List is busy";
+    case GE_DATAERROR: return "Unexpected data in server list";
+    }
+    return "UNKNOWN ERROR CODE";
 
 }
 
@@ -975,9 +975,9 @@ char *ServerListErrorDesc(GServerList serverlist, GError error)
 Returns the server at the specified index, or NULL if the index is out of bounds */
 GServer ServerListGetServer(GServerList serverlist, int index)
 {
-	if (index < 0 || index >= ArrayLength(serverlist->servers))
-		return NULL;
-	return *(GServer *)ArrayNth(serverlist->servers,index);
+    if (index < 0 || index >= ArrayLength(serverlist->servers))
+        return NULL;
+    return *(GServer *)ArrayNth(serverlist->servers,index);
 }
 
 /* ServerListCount
@@ -986,7 +986,7 @@ Returns the number of servers on the specified list. Indexing is 0 based, so
 the actual server indexes are 0 <= valid index < Count */
 int ServerListCount(GServerList serverlist)
 {
-	return ArrayLength(serverlist->servers);
+    return ArrayLength(serverlist->servers);
 }
 
 /****
@@ -994,50 +994,50 @@ Comparision Functions
 ***/
 static int IntKeyCompare(const void *entry1, const void *entry2)
 {
-	GServer server1 = *(GServer *)entry1, server2 = *(GServer *)entry2;
-	int diff;
-	diff = ServerGetIntValue(server1, g_sortserverlist->sortkey, 0) - 
-			ServerGetIntValue(server2, g_sortserverlist->sortkey, 0);
-	if (!g_sortserverlist->sortascending) 
-		diff = -diff;
-	return diff;
-	
+    GServer server1 = *(GServer *)entry1, server2 = *(GServer *)entry2;
+    int diff;
+    diff = ServerGetIntValue(server1, g_sortserverlist->sortkey, 0) - 
+            ServerGetIntValue(server2, g_sortserverlist->sortkey, 0);
+    if (!g_sortserverlist->sortascending) 
+        diff = -diff;
+    return diff;
+    
 }
 
 static int FloatKeyCompare(const void *entry1, const void *entry2)
 {
     GServer server1 = *(GServer *)entry1, server2 = *(GServer *)entry2;
-	double f = ServerGetFloatValue(server1, g_sortserverlist->sortkey, 0) - 
-			ServerGetFloatValue(server2, g_sortserverlist->sortkey, 0);
-	if (!g_sortserverlist->sortascending) 
-		f = -f;
-	if ((float)f > (float)0.0) 
-		return 1;
-	else if ((float)f < (float)0.0) 
-		return -1; 
-	else 
-		return 0;
+    double f = ServerGetFloatValue(server1, g_sortserverlist->sortkey, 0) - 
+            ServerGetFloatValue(server2, g_sortserverlist->sortkey, 0);
+    if (!g_sortserverlist->sortascending) 
+        f = -f;
+    if ((float)f > (float)0.0) 
+        return 1;
+    else if ((float)f < (float)0.0) 
+        return -1; 
+    else 
+        return 0;
 }
 
 static int StrCaseKeyCompare(const void *entry1, const void *entry2)
 {
-	
+    
     GServer server1 = *(GServer *)entry1, server2 = *(GServer *)entry2;
     int diff = strcmp(ServerGetStringValue(server1, g_sortserverlist->sortkey, ""),
-				ServerGetStringValue(server2, g_sortserverlist->sortkey, ""));
-	if (!g_sortserverlist->sortascending) 
-		diff = -diff;
-	return diff;
+                ServerGetStringValue(server2, g_sortserverlist->sortkey, ""));
+    if (!g_sortserverlist->sortascending) 
+        diff = -diff;
+    return diff;
 }
 
 static int StrNoCaseKeyCompare(const void *entry1, const void *entry2)
 {
-	GServer server1 = *(GServer *)entry1, server2 = *(GServer *)entry2;
-	int diff = strcasecmp(ServerGetStringValue(server1, g_sortserverlist->sortkey, ""),
-				ServerGetStringValue(server2, g_sortserverlist->sortkey, ""));
-	if (!g_sortserverlist->sortascending) 
-		diff = -diff;
-	return diff;
+    GServer server1 = *(GServer *)entry1, server2 = *(GServer *)entry2;
+    int diff = strcasecmp(ServerGetStringValue(server1, g_sortserverlist->sortkey, ""),
+                ServerGetStringValue(server2, g_sortserverlist->sortkey, ""));
+    if (!g_sortserverlist->sortascending) 
+        diff = -diff;
+    return diff;
 }
 
 /* ServerListSort
@@ -1047,22 +1047,22 @@ specified comparemode.
 sortkey can be a normal server key, or "ping" or "hostaddr" */
 void ServerListSort(GServerList serverlist, gbool ascending, char *sortkey, GCompareMode comparemode)
 {
-	ArrayCompareFn comparator;
-	switch (comparemode)
-	{
-	case cm_int: comparator = IntKeyCompare;
-		break;
-	case cm_float: comparator = FloatKeyCompare;
-		break;
-	case cm_strcase: comparator = StrCaseKeyCompare;
-		break;
-	case cm_stricase: comparator = StrNoCaseKeyCompare;
-		break;
-	}
-	serverlist->sortkey = sortkey;
-	serverlist->sortascending = ascending;
-	g_sortserverlist = serverlist;
-	ArraySort(serverlist->servers,comparator);
+    ArrayCompareFn comparator;
+    switch (comparemode)
+    {
+    case cm_int: comparator = IntKeyCompare;
+        break;
+    case cm_float: comparator = FloatKeyCompare;
+        break;
+    case cm_strcase: comparator = StrCaseKeyCompare;
+        break;
+    case cm_stricase: comparator = StrNoCaseKeyCompare;
+        break;
+    }
+    serverlist->sortkey = sortkey;
+    serverlist->sortascending = ascending;
+    g_sortserverlist = serverlist;
+    ArraySort(serverlist->servers,comparator);
 
 }
 
diff --git a/code/gamespy/gutil.c b/code/gamespy/gutil.c
index 698aa946..136c2c77 100644
--- a/code/gamespy/gutil.c
+++ b/code/gamespy/gutil.c
@@ -18,68 +18,68 @@ typedef unsigned char uchar;
 
 static void swap_byte(uchar* a, uchar* b)
 {
-	uchar swapByte;
+    uchar swapByte;
 
-	swapByte = *a;
-	*a = *b;
-	*b = swapByte;
+    swapByte = *a;
+    *a = *b;
+    *b = swapByte;
 }
 
 static uchar encode_ct(uchar c)
 {
-	if (c < 26) return (uchar)('A' + c);
-	if (c < 52) return (uchar)('a' + c - 26);
-	if (c < 62) return (uchar)('0' + c - 52);
-	if (c == 62) return (uchar)('+');
-	if (c == 63) return (uchar)('/');
+    if (c < 26) return (uchar)('A' + c);
+    if (c < 52) return (uchar)('a' + c - 26);
+    if (c < 62) return (uchar)('0' + c - 52);
+    if (c == 62) return (uchar)('+');
+    if (c == 63) return (uchar)('/');
 
-	return 0;
+    return 0;
 }
 
 void gs_encode(uchar* ins, int size, uchar* result)
 {
-	int    i, pos;
-	uchar  trip[3];
-	uchar  kwart[4];
+    int    i, pos;
+    uchar  trip[3];
+    uchar  kwart[4];
 
-	i = 0;
-	while (i < size)
-	{
-		for (pos = 0; pos <= 2; pos++, i++)
-			if (i < size) trip[pos] = *ins++;
-			else trip[pos] = '\0';
-		kwart[0] = (unsigned char)((trip[0]) >> 2);
-		kwart[1] = (unsigned char)((((trip[0]) & 3) << 4) + ((trip[1]) >> 4));
-		kwart[2] = (unsigned char)((((trip[1]) & 15) << 2) + ((trip[2]) >> 6));
-		kwart[3] = (unsigned char)((trip[2]) & 63);
-		for (pos = 0; pos <= 3; pos++) *result++ = encode_ct(kwart[pos]);
-	}
-	*result = '\0';
+    i = 0;
+    while (i < size)
+    {
+        for (pos = 0; pos <= 2; pos++, i++)
+            if (i < size) trip[pos] = *ins++;
+            else trip[pos] = '\0';
+        kwart[0] = (unsigned char)((trip[0]) >> 2);
+        kwart[1] = (unsigned char)((((trip[0]) & 3) << 4) + ((trip[1]) >> 4));
+        kwart[2] = (unsigned char)((((trip[1]) & 15) << 2) + ((trip[2]) >> 6));
+        kwart[3] = (unsigned char)((trip[2]) & 63);
+        for (pos = 0; pos <= 3; pos++) *result++ = encode_ct(kwart[pos]);
+    }
+    *result = '\0';
 }
 
 void gs_encrypt(uchar* key, int key_len, uchar* buffer_ptr, int buffer_len)
 {
-	int counter;
-	uchar x, y, xorIndex;
-	uchar state[256];
+    int counter;
+    uchar x, y, xorIndex;
+    uchar state[256];
 
-	for (counter = 0; counter < 256; counter++) state[counter] = (uchar)counter;
+    for (counter = 0; counter < 256; counter++) state[counter] = (uchar)counter;
 
-	x = 0; y = 0;
-	for (counter = 0; counter < 256; counter++)
-	{
-		y = (uchar)((key[x] + state[counter] + y) % 256);
-		x = (uchar)((x + 1) % key_len);
-		swap_byte(&state[counter], &state[y]);
-	}
+    x = 0; y = 0;
+    for (counter = 0; counter < 256; counter++)
+    {
+        y = (uchar)((key[x] + state[counter] + y) % 256);
+        x = (uchar)((x + 1) % key_len);
+        swap_byte(&state[counter], &state[y]);
+    }
 
-	x = 0; y = 0;
-	for (counter = 0; counter < buffer_len; counter++)
-	{
-		x = (uchar)((x + buffer_ptr[counter] + 1) % 256);
-		y = (uchar)((state[x] + y) % 256);
-		swap_byte(&state[x], &state[y]);
-		xorIndex = (uchar)((state[x] + state[y]) % 256);
-		buffer_ptr[counter] ^= state[xorIndex];
-	}
+    x = 0; y = 0;
+    for (counter = 0; counter < buffer_len; counter++)
+    {
+        x = (uchar)((x + buffer_ptr[counter] + 1) % 256);
+        y = (uchar)((state[x] + y) % 256);
+        swap_byte(&state[x], &state[y]);
+        xorIndex = (uchar)((state[x] + state[y]) % 256);
+        buffer_ptr[counter] ^= state[xorIndex];
+    }
 }
diff --git a/code/gamespy/gutil.h b/code/gamespy/gutil.h
index b35d0f6c..f1889513 100644
--- a/code/gamespy/gutil.h
+++ b/code/gamespy/gutil.h
@@ -27,7 +27,7 @@ size: size of the buffer
 OUT
 ---  
 result: pointer to buffer to store result. Size should be (4 * size) / 3 + 1
-	result will be null terminated.
+    result will be null terminated.
 **********/
 void gs_encode(uchar* ins, int size, uchar* result);
 
diff --git a/code/gamespy/hashtable.c b/code/gamespy/hashtable.c
index 9313e503..84ad6275 100644
--- a/code/gamespy/hashtable.c
+++ b/code/gamespy/hashtable.c
@@ -22,208 +22,208 @@
 
 
 #ifdef _NO_NOPORT_H_
-	#define gsimalloc malloc
-	#define gsifree free
-	#define gsirealloc realloc
-	#include <assert.h>
+    #define gsimalloc malloc
+    #define gsifree free
+    #define gsirealloc realloc
+    #include <assert.h>
 #else
-	#include "nonport.h" //for gsimalloc/realloc/free/assert
+    #include "nonport.h" //for gsimalloc/realloc/free/assert
 #endif
 
 
 struct HashImplementation 
 {
-	DArray *buckets;
-	int nbuckets;
-	TableElementFreeFn freefn;
-	TableHashFn hashfn;
-	TableCompareFn compfn;
+    DArray *buckets;
+    int nbuckets;
+    TableElementFreeFn freefn;
+    TableHashFn hashfn;
+    TableCompareFn compfn;
 };
 
 HashTable TableNew(int elemSize, int nBuckets, 
                    TableHashFn hashFn, TableCompareFn compFn, 
- 					 TableElementFreeFn freeFn)
+                      TableElementFreeFn freeFn)
 {
-	return TableNew2(elemSize, nBuckets, 4, hashFn, compFn, freeFn);
+    return TableNew2(elemSize, nBuckets, 4, hashFn, compFn, freeFn);
 }
 HashTable TableNew2(int elemSize, int nBuckets, int nChains,
                    TableHashFn hashFn, TableCompareFn compFn, 
- 					 TableElementFreeFn freeFn)
+                      TableElementFreeFn freeFn)
 {
-	HashTable table;
-	int i;
+    HashTable table;
+    int i;
 
-	assert(hashFn);
-	assert(compFn);
-	assert(elemSize);
-	assert(nBuckets);
+    assert(hashFn);
+    assert(compFn);
+    assert(elemSize);
+    assert(nBuckets);
 
-	table = (HashTable)gsimalloc(sizeof(struct HashImplementation));
-	assert(table);
-	
-	table->buckets = (DArray *)gsimalloc(nBuckets * sizeof(DArray));
-	assert(table->buckets);
-	for (i = 0; i < nBuckets; i++) //ArrayNew will assert if allocation fails
-		table->buckets[i] = ArrayNew(elemSize, nChains, freeFn);
-	table->nbuckets = nBuckets;
-	table->freefn = freeFn;
-	table->compfn = compFn;
-	table->hashfn = hashFn;
+    table = (HashTable)gsimalloc(sizeof(struct HashImplementation));
+    assert(table);
+    
+    table->buckets = (DArray *)gsimalloc(nBuckets * sizeof(DArray));
+    assert(table->buckets);
+    for (i = 0; i < nBuckets; i++) //ArrayNew will assert if allocation fails
+        table->buckets[i] = ArrayNew(elemSize, nChains, freeFn);
+    table->nbuckets = nBuckets;
+    table->freefn = freeFn;
+    table->compfn = compFn;
+    table->hashfn = hashFn;
 
-	return table;
+    return table;
 }
 
 
 void TableFree(HashTable table)
 {
-	int i;
-	
-	assert(table);
+    int i;
+    
+    assert(table);
 
-	if (NULL == table )
-		return;
-	
-	for (i = 0 ; i < table->nbuckets ; i++)
-		ArrayFree(table->buckets[i]);
-	gsifree(table->buckets);
-	gsifree(table);
+    if (NULL == table )
+        return;
+    
+    for (i = 0 ; i < table->nbuckets ; i++)
+        ArrayFree(table->buckets[i]);
+    gsifree(table->buckets);
+    gsifree(table);
 }
 
 
 int TableCount(HashTable table)
 {
-	int i, count = 0;
-	
-	assert(table);
+    int i, count = 0;
+    
+    assert(table);
 
-	if (NULL == table )
-		return count;
+    if (NULL == table )
+        return count;
 
-	for (i = 0 ; i < table->nbuckets ; i++)
-		count += ArrayLength(table->buckets[i]);
-	
-	return count;
+    for (i = 0 ; i < table->nbuckets ; i++)
+        count += ArrayLength(table->buckets[i]);
+    
+    return count;
 }
 
 
 void TableEnter(HashTable table, const void *newElem)
 {
-	int hash, itempos;
-	
-	assert(table);
+    int hash, itempos;
+    
+    assert(table);
 
-	if (NULL == table )
-		return;
+    if (NULL == table )
+        return;
 
-	hash = table->hashfn(newElem, table->nbuckets);
-	itempos = ArraySearch(table->buckets[hash], newElem, table->compfn, 0,0);
-	if (itempos == NOT_FOUND)
-		ArrayAppend(table->buckets[hash], newElem);
-	else
-		ArrayReplaceAt(table->buckets[hash], newElem, itempos);
+    hash = table->hashfn(newElem, table->nbuckets);
+    itempos = ArraySearch(table->buckets[hash], newElem, table->compfn, 0,0);
+    if (itempos == NOT_FOUND)
+        ArrayAppend(table->buckets[hash], newElem);
+    else
+        ArrayReplaceAt(table->buckets[hash], newElem, itempos);
 }
 
 int TableRemove(HashTable table, const void *delElem)
 {
-	int hash, itempos;
-	
-	assert(table);
+    int hash, itempos;
+    
+    assert(table);
 
-	if (NULL == table )
-		return 0;
+    if (NULL == table )
+        return 0;
 
-	hash = table->hashfn(delElem, table->nbuckets);
-	itempos = ArraySearch(table->buckets[hash], delElem, table->compfn, 0,0);
-	if (itempos == NOT_FOUND)
-		return 0;
-	else
-		ArrayDeleteAt(table->buckets[hash], itempos);
-	return 1;
+    hash = table->hashfn(delElem, table->nbuckets);
+    itempos = ArraySearch(table->buckets[hash], delElem, table->compfn, 0,0);
+    if (itempos == NOT_FOUND)
+        return 0;
+    else
+        ArrayDeleteAt(table->buckets[hash], itempos);
+    return 1;
 }
 
 void *TableLookup(HashTable table, const void *elemKey)
 {
-	int hash, itempos;
-	
-	assert(table);
+    int hash, itempos;
+    
+    assert(table);
 
-	if (NULL == table )
-		return NULL;
+    if (NULL == table )
+        return NULL;
 
-	hash = table->hashfn(elemKey, table->nbuckets);
-	itempos = ArraySearch(table->buckets[hash], elemKey, table->compfn, 0,
-						  0);
-	if (itempos == NOT_FOUND)
-		return NULL;
-	else
-		return ArrayNth(table->buckets[hash], itempos);
+    hash = table->hashfn(elemKey, table->nbuckets);
+    itempos = ArraySearch(table->buckets[hash], elemKey, table->compfn, 0,
+                          0);
+    if (itempos == NOT_FOUND)
+        return NULL;
+    else
+        return ArrayNth(table->buckets[hash], itempos);
 }
 
 
 void TableMap(HashTable table, TableMapFn fn, void *clientData)
 {
-	int i;
-	
-	assert(table);
-	assert(fn);
+    int i;
+    
+    assert(table);
+    assert(fn);
 
-	if (NULL == table || NULL == fn)
-		return;
-	
-	for (i = 0 ; i < table->nbuckets ; i++)
-		ArrayMap(table->buckets[i], fn, clientData);
-	
+    if (NULL == table || NULL == fn)
+        return;
+    
+    for (i = 0 ; i < table->nbuckets ; i++)
+        ArrayMap(table->buckets[i], fn, clientData);
+    
 }
 
 void TableMapSafe(HashTable table, TableMapFn fn, void *clientData)
 {
-	int i;
-	
-	assert(fn);
-	
-	for (i = 0 ; i < table->nbuckets ; i++)
-		ArrayMapBackwards(table->buckets[i], fn, clientData);
-	
+    int i;
+    
+    assert(fn);
+    
+    for (i = 0 ; i < table->nbuckets ; i++)
+        ArrayMapBackwards(table->buckets[i], fn, clientData);
+    
 }
 
 void * TableMap2(HashTable table, TableMapFn2 fn, void *clientData)
 {
-	int i;
-	void * pcurr;
-	
-	assert(fn);
-	
-	for (i = 0 ; i < table->nbuckets ; i++)
-	{
-		pcurr = ArrayMap2(table->buckets[i], fn, clientData);
-		if(pcurr)
-			return pcurr;
-	}
+    int i;
+    void * pcurr;
+    
+    assert(fn);
+    
+    for (i = 0 ; i < table->nbuckets ; i++)
+    {
+        pcurr = ArrayMap2(table->buckets[i], fn, clientData);
+        if(pcurr)
+            return pcurr;
+    }
 
-	return NULL;
+    return NULL;
 }
 
 void * TableMapSafe2(HashTable table, TableMapFn2 fn, void *clientData)
 {
-	int i;
-	void * pcurr;
-	
-	assert(fn);
-	
-	for (i = 0 ; i < table->nbuckets ; i++)
-	{
-		pcurr = ArrayMapBackwards2(table->buckets[i], fn, clientData);
-		if(pcurr)
-			return pcurr;
-	}
+    int i;
+    void * pcurr;
+    
+    assert(fn);
+    
+    for (i = 0 ; i < table->nbuckets ; i++)
+    {
+        pcurr = ArrayMapBackwards2(table->buckets[i], fn, clientData);
+        if(pcurr)
+            return pcurr;
+    }
 
-	return NULL;
+    return NULL;
 }
 
 void TableClear(HashTable table)
 {
-	int i;
+    int i;
 
-	for (i = 0 ; i < table->nbuckets ; i++)
-		ArrayClear(table->buckets[i]);
+    for (i = 0 ; i < table->nbuckets ; i++)
+        ArrayClear(table->buckets[i]);
 }
diff --git a/code/gamespy/hashtable.h b/code/gamespy/hashtable.h
index d6c8a4a3..fa00c2ec 100644
--- a/code/gamespy/hashtable.h
+++ b/code/gamespy/hashtable.h
@@ -126,11 +126,11 @@ extern "C" {
 
 HashTable TableNew(int elemSize, int nBuckets, 
                    TableHashFn hashFn, TableCompareFn compFn, 
- 					 TableElementFreeFn freeFn);
+                      TableElementFreeFn freeFn);
 
 HashTable TableNew2(int elemSize, int nBuckets, int nChains,
                    TableHashFn hashFn, TableCompareFn compFn, 
- 					 TableElementFreeFn freeFn);
+                      TableElementFreeFn freeFn);
 
 
  /* TableFree
diff --git a/code/gamespy/md5.h b/code/gamespy/md5.h
index 0fccee0c..0d324291 100644
--- a/code/gamespy/md5.h
+++ b/code/gamespy/md5.h
@@ -38,7 +38,7 @@ The following makes PROTOTYPES default to 0 if it has not already
 #ifdef __cplusplus
 extern "C" {
 #endif
-	
+    
 #ifndef PROTOTYPES
 #define PROTOTYPES 1
 #endif
diff --git a/code/gamespy/md5c.c b/code/gamespy/md5c.c
index de31fc6a..8383e62f 100644
--- a/code/gamespy/md5c.c
+++ b/code/gamespy/md5c.c
@@ -305,7 +305,7 @@ static void Decode (UINT4 *output, unsigned char *input, unsigned int len)
  */
 static void MD5_memcpy (POINTER output, POINTER input, unsigned int len)
 {
-	memcpy(output, input, len);
+    memcpy(output, input, len);
 /*  unsigned int i;
   
   for (i = 0; i < len; i++)
@@ -316,7 +316,7 @@ static void MD5_memcpy (POINTER output, POINTER input, unsigned int len)
  */
 static void MD5_memset (POINTER output, int value, unsigned int len)
 {
-	memset(output, value, len);
+    memset(output, value, len);
  /* unsigned int i;
   
   for (i = 0; i < len; i++)
@@ -327,26 +327,26 @@ static void MD5_memset (POINTER output, int value, unsigned int len)
 
 void MD5Print (unsigned char digest[16], char output[33])
 {
-	static const char hex_digits[] = "0123456789abcdef";
-	unsigned int i;
+    static const char hex_digits[] = "0123456789abcdef";
+    unsigned int i;
 
-	for (i = 0; i < 16; i++)
-	{
-		output[i*2  ] = hex_digits[digest[i] / 16];
-		output[i*2+1] = hex_digits[digest[i] % 16];
-	}
-	output[32] = '\0';
+    for (i = 0; i < 16; i++)
+    {
+        output[i*2  ] = hex_digits[digest[i] / 16];
+        output[i*2+1] = hex_digits[digest[i] % 16];
+    }
+    output[32] = '\0';
 }
 
 void MD5Digest (unsigned char *input, unsigned int len, char output[33])
 {
-	MD5_CTX ctx;
-	unsigned char digest[16];
+    MD5_CTX ctx;
+    unsigned char digest[16];
 
-	MD5Init(&ctx);
-	MD5Update(&ctx, input, len);
-	MD5Final(digest, &ctx);
-	MD5Print(digest, output);
+    MD5Init(&ctx);
+    MD5Update(&ctx, input, len);
+    MD5Final(digest, &ctx);
+    MD5Print(digest, output);
 
 }
 #ifdef __cplusplus