/**

* vim: set ts=4 :

* =============================================================================

* SourceMod

* Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.

* =============================================================================

*

* This program is free software; you can redistribute it and/or modify it under

* the terms of the GNU General Public License, version 3.0, as published by the

* Free Software Foundation.

* 

* This program is distributed in the hope that it will be useful, but WITHOUT

* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

* FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more

* details.

*

* You should have received a copy of the GNU General Public License along with

* this program.  If not, see <http://www.gnu.org/licenses/>.

*

* As a special exception, AlliedModders LLC gives you permission to link the

* code of this program (as well as its derivative works) to "Half-Life 2," the

* "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software

* by the Valve Corporation.  You must obey the GNU General Public License in

* all respects for all other code used.  Additionally, AlliedModders LLC grants

* this exception to all derivative works.  AlliedModders LLC defines further

* exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),

* or <http://www.sourcemod.net/license.php>.

*

* Version: $Id$

*/

#include "GameDataFetcher.h"

#include "bitbuf.h"

#ifdef PLATFORM_WINDOWS

#include <winsock2.h>

#else

#include <unistd.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <netdb.h>

#include <arpa/inet.h>

#define INVALID_SOCKET -1

#define closesocket close

#endif

#include "sh_vector.h"

#include "sh_string.h"

#include "sm_version.h"

#ifdef ORANGEBOX_BUILD

#include "convar_sm_ob.h"

#else

#include "convar_sm.h"

#endif

#include "sourcemm_api.h"

#include "time.h"

#include "TimerSys.h"

#include "compat_wrappers.h"

#include "sm_stringutil.h"

#define QUERY_MAX_LENGTH 1024

BuildMD5ableBuffer g_MD5Builder;

FetcherThread g_FetchThread;

FILE *logfile = NULL;

bool g_disableGameDataUpdate = false;

bool g_restartAfterUpdate = false;

int g_serverPort = 6500;

char g_serverAddress[100] = "hayate.alliedmods.net";

void FetcherThread::RunThread( IThreadHandle *pHandle )

{

	char lock_path[PLATFORM_MAX_PATH];

	g_SourceMod.BuildPath(Path_SM, lock_path, sizeof(lock_path), "data/temp");

	g_LibSys.CreateFolder(lock_path);

	g_SourceMod.BuildPath(Path_SM, lock_path, sizeof(lock_path), "data/temp/gamedata.lock");

	g_Logger.LogMessage("Starting experimental gamedata update fetcher... please report problems to bugs.alliedmods.net");

	char log_path[PLATFORM_MAX_PATH];

	g_SourceMod.BuildPath(Path_SM, log_path, sizeof(log_path), "logs/gamedata");

	g_LibSys.CreateFolder(log_path);

	time_t t;

	GetAdjustedTime(&t);

	tm *curtime = localtime(&t);

	g_SourceMod.BuildPath(Path_SM, log_path, sizeof(log_path), "logs/gamedata/L%02d%02d.log", curtime->tm_mon + 1, curtime->tm_mday);

	logfile = fopen(log_path, "a");

	if (!logfile)

	{

		g_Logger.LogError("Failed to create GameData log file");

		return;

	}

	//Create a blank lock file

	FILE *fp = fopen(lock_path, "w");

	if (fp)

	{

		fclose(fp);

	}

	/* Create a new socket for this connection */

	int socketDescriptor = ConnectSocket();

	if (socketDescriptor == INVALID_SOCKET)

	{

		fclose(logfile);

		unlink(lock_path);

		return;

	}

	char query[QUERY_MAX_LENGTH];

	/* Check for updated gamedata files */

	int len = BuildGameDataQuery(query, QUERY_MAX_LENGTH);

	if (len == 0)

	{

		g_Logger.LogToOpenFile(logfile, "Query Writing failed");

		closesocket(socketDescriptor);

		fclose(logfile);

		unlink(lock_path);

		return;

	}

	if (g_disableGameDataUpdate)

	{

		g_Logger.LogMessage("Skipping GameData Query due to DisableAutoUpdate being set to true");

		closesocket(socketDescriptor);

		fclose(logfile);

		unlink(lock_path);

		return;

	}

	int sent = NonBlockingSend(socketDescriptor, query, len);

	g_Logger.LogToOpenFile(logfile, "Sent Query!");

	if (sent == 0)

	{

		g_Logger.LogToOpenFile(logfile, "Failed to send data");

		closesocket(socketDescriptor);

		fclose(logfile);

		unlink(lock_path);

		return;

	}

	ProcessGameDataQuery(socketDescriptor);

	/* And we're done! */

	closesocket(socketDescriptor);

	fclose(logfile);

	unlink(lock_path);

}

void FetcherThread::OnTerminate( IThreadHandle *pHandle, bool cancel )

{

	g_blockGameDataLoad = false;

}

int FetcherThread::BuildGameDataQuery( char *buffer, int maxlen )

{

	char gamedata_path[PLATFORM_MAX_PATH];

	g_SourceMod.BuildPath(Path_SM, gamedata_path, sizeof(gamedata_path), "gamedata");

	IDirectory *dir = g_LibSys.OpenDirectory(gamedata_path);

	if (dir == NULL)

	{

		return 0;

	}

	bf_write Writer = bf_write("GameDataQuery", buffer, maxlen);

	Writer.WriteByte('A'); //Generic Header char

	Writer.WriteByte('G'); //G for gamedata query, or green, like my hat.

	short build[4] = { SVN_FILE_VERSION };

	Writer.WriteBytes(&build[0], 8);

	Writer.WriteByte(0); // Initialize the file counter - Index 10

	while (dir->MoreFiles())

	{

		if (dir->IsEntryFile())

		{

			const char *name = dir->GetEntryName();

			size_t len = strlen(name);

			if (len >= 4

				&& strcmp(&name[len-4], ".txt") == 0)

			{

				char file[PLATFORM_MAX_PATH];

				g_LibSys.PathFormat(file, sizeof(file), "%s/%s", gamedata_path, name);

				SMCStates states;

				if (g_TextParser.ParseFile_SMC(file, &g_MD5Builder, &states) == SMCError_Okay)

				{

					unsigned char *md5 = g_MD5Builder.GetMD5();

					if (md5 != NULL)

					{

						(uint8_t)buffer[10]++; //Increment the file counter

						Writer.WriteBytes(md5, 16);

						g_Logger.LogToOpenFile(logfile, "%s - \"%s\"", file, g_MD5Builder.GetMD5String());

						FileData *data = new FileData();

						data->filename = new SourceHook::String(file);

						memcpy(data->checksum, g_MD5Builder.GetMD5String(), 33);

						filenames.push_back(data);

					}

					else

					{

						g_Logger.LogToOpenFile(logfile, "%s no md5?", file);

					}

				}

				else

				{

					g_Logger.LogToOpenFile(logfile, "%s failed!", file);

				}

			}

		}

		dir->NextEntry();

	}

	return Writer.GetNumBytesWritten();

}

int FetcherThread::ConnectSocket()

{

	struct protoent *ptrp;

	ptrp = getprotobyname("tcp");

#ifdef WIN32

	WSADATA wsaData;

	WSAStartup(0x0101, &wsaData);

#endif

	if (ptrp == NULL) 

	{

		g_Logger.LogToOpenFile(logfile, "Failed to find TCP");

		return INVALID_SOCKET;

	}

	int socketDescriptor = socket(AF_INET, SOCK_STREAM, ptrp->p_proto);

	if (socketDescriptor == INVALID_SOCKET)

	{

		//bugger aye?

		g_Logger.LogToOpenFile(logfile, "Failed to create a new socket");

		closesocket(socketDescriptor);

		return INVALID_SOCKET;

	}

	struct hostent *he;

	struct sockaddr_in local_addr;

	local_addr.sin_family = AF_INET;

	local_addr.sin_port = htons((u_short)g_serverPort);

	he = gethostbyname(g_serverAddress);

	if (!he)

	{

		if ((local_addr.sin_addr.s_addr = inet_addr(g_serverAddress)) == INADDR_NONE)

		{

			g_Logger.LogToOpenFile(logfile, "Couldnt locate address");

			closesocket(socketDescriptor);

			return INVALID_SOCKET;

		}

	} 

	else 

	{

		memcpy(&local_addr.sin_addr, (struct in_addr *)he->h_addr, he->h_length);

	}

	if (connect(socketDescriptor, (struct sockaddr *) &local_addr, sizeof(local_addr)) < 0)

	{

		g_Logger.LogToOpenFile(logfile, "Couldn't connect");

		closesocket(socketDescriptor);

		return INVALID_SOCKET;

	}

	return socketDescriptor;

}

void FetcherThread::ProcessGameDataQuery(int socketDescriptor)

{

	char buffer[50];

	g_Logger.LogToOpenFile(logfile, "Waiting for reply!");

	//Read in the header bytes

	int returnLen = NonBlockingRecv(socketDescriptor, buffer, 12);

	g_Logger.LogToOpenFile(logfile, "Recv Completed");

	if (returnLen == 0)

	{

		g_Logger.LogToOpenFile(logfile, ",but it failed.");

		/* Timeout or fail? */

		return;

	}

	g_Logger.LogToOpenFile(logfile, "Received Header!");

	bf_read Reader = bf_read("GameDataQuery", buffer, 12);

	if (Reader.ReadByte() != 'A' || Reader.ReadByte() != 'G')

	{

		g_Logger.LogToOpenFile(logfile, "Invalid Query to handle");

		return;

	}

	UpdateStatus updateStatus = (UpdateStatus)Reader.ReadByte();

	short build[4] = {0,0,0,0};

	build[0] = Reader.ReadShort();

	build[1] = Reader.ReadShort();

	build[2] = Reader.ReadShort();

	build[3] = Reader.ReadShort();

	g_Logger.LogToOpenFile(logfile, "Update Status: %i - Latest %i.%i.%i.%i", updateStatus, build[0], build[1], build[2], build[3]);

	HandleUpdateStatus(updateStatus, build);

	int changedFiles = Reader.ReadByte();

	g_Logger.LogToOpenFile(logfile, "Files to download: %i", changedFiles);

	for (int i=0; i<changedFiles; i++)

	{

		//Read in the file index and byte count

		returnLen = NonBlockingRecv(socketDescriptor, buffer, 5);

		if (returnLen == 0)

		{

			/* Timeout or fail? */

			return;

		}

		Reader.StartReading(buffer, 5);

		int index = Reader.ReadByte();

		int tempLen = Reader.ReadUBitLong(32);

		g_Logger.LogToOpenFile(logfile, "File index %i and length %i", index, tempLen);

		void *memPtr;

		memtable->CreateMem(tempLen+1, &memPtr);

		//Read the contents of our file into the memtable

		returnLen = NonBlockingRecv(socketDescriptor, (char *)memPtr, tempLen);

		g_Logger.LogToOpenFile(logfile, "Recieved %i bytes", returnLen);

		if (returnLen == 0)

		{

			/* Timeout or fail? */

			return;

		}

		((unsigned char *)memPtr)[tempLen] = '\0';

		FileData *data = filenames.at(index);

		const char* filename;

		if (data != NULL)

		{

			filename = data->filename->c_str();

			FILE *fp = fopen(filename, "w");

			if (fp)

			{

				fprintf(fp, (const char *)memPtr);

				fclose(fp);

			}

		}

		else

		{

			filename = "";

		}

		memtable->Reset();

		g_Logger.LogToOpenFile(logfile, "Updated File %s", filename);

	}

	g_Logger.LogToOpenFile(logfile, "File Downloads Completed!");

	bool needsRestart = false;

	if (changedFiles > 0)

	{

		needsRestart = true;

		g_Logger.LogMessage("New GameData Files have been downloaded to your gamedata directory. Please restart your server for these to take effect");

	}

	//Read changed file count

	returnLen = NonBlockingRecv(socketDescriptor, buffer, 1);

	if (returnLen == 0)

	{

		/* Timeout or fail? */

		g_Logger.LogToOpenFile(logfile, "Failed to receive unknown count");

		return;

	}

	Reader.StartReading(buffer, 1);

	changedFiles = Reader.ReadByte();

	if (changedFiles == 0)

	{

		g_Logger.LogToOpenFile(logfile, "No unknown files. We're all done");

		return;

	}

	char *changedFileIndexes = new char[changedFiles];

	g_Logger.LogToOpenFile(logfile, "%i Files were unknown", changedFiles);

	returnLen = NonBlockingRecv(socketDescriptor, changedFileIndexes, changedFiles);

	if (returnLen == 0)

	{

		/* Timeout or fail? */

		g_Logger.LogToOpenFile(logfile, "Failed to receive unknown list");

		return;

	}

	Reader.StartReading(changedFileIndexes, changedFiles);

	for (int i=0; i<changedFiles; i++)

	{

		int index = Reader.ReadByte();

		char fileName[30];

		FileData *data = filenames.at(index);

		const char* pathname;

		if (data != NULL)

		{

			pathname = data->filename->c_str();

		}

		else

		{

			pathname = "";

		}

		g_LibSys.GetFileFromPath(fileName, sizeof(fileName), pathname);

		g_Logger.LogToOpenFile(logfile, "Unknown File %i : %s", index, fileName);

	}

	delete [] changedFileIndexes;

	if (needsRestart && g_restartAfterUpdate)

	{

		g_Logger.LogMessage("Automatically restarting server after a successful gamedata update!");

		engine->ServerCommand("quit\n");

	}

}

int FetcherThread::NonBlockingRecv( int socketDescriptor, char *buffer, int len )

{

	fd_set fds;

	struct timeval tv;

	/* Create a 10 Second Timeout */

	tv.tv_sec = 10;

	tv.tv_usec = 0;

	/* Add our socket to a socket set */

	FD_ZERO(&fds);

	FD_SET(socketDescriptor, &fds);

	/* Wait max of 10 seconds for recv to become available */

	select(socketDescriptor+1, &fds, NULL, NULL, &tv);

	int bytesReceived = 0;

	/* Is there a limit on how much we can receive? Some site said 1024 bytes, which will be well short of a file */

	if (FD_ISSET(socketDescriptor, &fds))

	{

		bytesReceived = recv(socketDescriptor, buffer, len, 0);

	}

	if (bytesReceived == 0 || bytesReceived == -1)

	{

		return 0;

	}

	if (bytesReceived < len)

	{

		return bytesReceived + NonBlockingRecv(socketDescriptor, buffer+bytesReceived, len-bytesReceived);

	}

	return bytesReceived;	

}

int FetcherThread::NonBlockingSend( int socketDescriptor, char *buffer, int len )

{

	fd_set fds;

	struct timeval tv;

	tv.tv_sec = 10;

	tv.tv_usec = 0;

	FD_ZERO(&fds);

	FD_SET(socketDescriptor, &fds);

	select(socketDescriptor+1, NULL, &fds, NULL, &tv);

	int sentBytes = 0;

	if (FD_ISSET(socketDescriptor, &fds))

	{

		sentBytes = send(socketDescriptor, buffer, len, 0);

	}

	if (sentBytes == 0 || sentBytes == -1)

	{

		return 0;

	}

	if (sentBytes < len)

	{

		return sentBytes + NonBlockingSend(socketDescriptor, buffer+sentBytes, len-sentBytes);

	}

	return sentBytes;

}

void FetcherThread::HandleUpdateStatus( UpdateStatus status, short version[4] )

{

	switch (status)

	{

		case Update_Unknown:

		case Update_Current:

		{

			break;

		}

		case Update_NewBuild:

		{

			g_Logger.LogMessage("SourceMod Update: A new SVN build is available from sourcemod.net");

			g_Logger.LogMessage("Current Version: %i.%i.%i.%i Available: %i.%i.%i.%i", version[0], version[1], version[2], version[3], version[0], version[1], version[2], version[3]);

			break;

		}

		case Update_MinorAvailable:

		{

			g_Logger.LogMessage("SourceMod Update: An incremental minor release of SourceMod is now available from sourcemod.net");

			g_Logger.LogMessage("Current Version: %i.%i.%i Available: %i.%i.%i", version[0], version[1], version[2], version[0], version[1], version[2]);

			break;

		}

		case Update_MajorAvailable:

		{

			g_Logger.LogMessage("SourceMod Update: An major release of SourceMod is now available from sourcemod.net");

			g_Logger.LogMessage("Current Version: %i.%i.%i Available: %i.%i.%i", version[0], version[1], version[2], version[0], version[1], version[2]);

			break;

		}

		case Update_CriticalAvailable:

		{

			g_Logger.LogError("SourceMod Update: A new critical release of SourceMod is now available from sourcemod.net. It is strongly recommended that you update");

			g_Logger.LogMessage("Current Version: %i.%i.%i.%i Available: %i.%i.%i.%i", version[0], version[1], version[2], version[3], version[0], version[1], version[2], version[3]);

			break;

		}

	}

}

bool g_blockGameDataLoad = false;

class InitFetch : public SMGlobalClass

{

public:

	void OnSourceModAllInitialized_Post()

	{

		char lock_path[PLATFORM_MAX_PATH];

		g_SourceMod.BuildPath(Path_SM, lock_path, sizeof(lock_path), "data/temp/gamedata.lock");