/**

 * vim: set ts=4 :

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

 * SourceMod Updater Extension

 * Copyright (C) 2004-2009 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 <sourcemod_version.h>

#include <stdlib.h>

#include "extension.h"

#include "Updater.h"

#include "md5.h"

#define USTATE_NONE			0

#define USTATE_FOLDERS		1

#define USTATE_CHANGED		2

#define USTATE_CHANGE_FILE	3

#define USTATE_ERRORS		4

using namespace SourceMod;

UpdateReader::UpdateReader() : partFirst(NULL), partLast(NULL)

{

}

UpdateReader::~UpdateReader()

{

}

void UpdateReader::ReadSMC_ParseStart()

{

	ignoreLevel = 0;

	ustate = USTATE_NONE;

}

SMCResult UpdateReader::ReadSMC_NewSection(const SMCStates *states, const char *name)

{

	if (ignoreLevel)

	{

		ignoreLevel++;

		return SMCResult_Continue;

	}

	switch (ustate)

	{

	case USTATE_NONE:

		{

			if (strcmp(name, "Folders") == 0)

			{

				ustate = USTATE_FOLDERS;

			}

			else if (strcmp(name, "Changed") == 0)

			{

				ustate = USTATE_CHANGED;

			}

			else if (strcmp(name, "Errors") == 0)

			{

				ustate = USTATE_ERRORS;

			}

			else

			{

				ignoreLevel++;

			}

			break;

		}

	case USTATE_FOLDERS:

	case USTATE_CHANGE_FILE:

		{

			ignoreLevel++;

			break;

		}

	case USTATE_CHANGED:

		{

			curfile.assign(name);

			url.clear();

			checksum[0] = '\0';

			ustate = USTATE_CHANGE_FILE;

			break;

		}

	}

	return SMCResult_Continue;

}

SMCResult UpdateReader::ReadSMC_KeyValue(const SMCStates *states,

										 const char *key,

										 const char *value)

{

	if (ignoreLevel)

	{

		return SMCResult_Continue;

	}

	switch (ustate)

	{

	case USTATE_CHANGE_FILE:

		{

			if (strcmp(key, "md5sum") == 0)

			{

				if (strlen(value) != 32)

				{

					return SMCResult_Continue;

				}

				strcpy(checksum, value);

			}

			else if (strcmp(key, "location") == 0)

			{

				url.assign(update_url);

				url.append(value);

			}

			break;

		}

	case USTATE_ERRORS:

		{

			if (strcmp(key, "error") == 0)

			{

				AddUpdateError("%s", value);

			}

			break;

		}

	case USTATE_FOLDERS:

		{

			HandleFolder(value);

			break;

		}

	}

	return SMCResult_Continue;

}

SMCResult UpdateReader::ReadSMC_LeavingSection(const SMCStates *states)

{

	if (ignoreLevel)

	{

		ignoreLevel--;

		return SMCResult_Continue;

	}

	switch (ustate)

	{

	case USTATE_FOLDERS:

	case USTATE_CHANGED:

	case USTATE_ERRORS:

		{

			ustate = USTATE_NONE;

			break;

		}

	case USTATE_CHANGE_FILE:

		{

			if (url.size() != 0 && checksum[0] != '\0')

			{

				HandleFile();

			}

			else

			{

				AddUpdateError("Incomplete file definition in update manifest");

			}

			ustate = USTATE_CHANGED;

			break;

		}

	}

	return SMCResult_Continue;

}

void UpdateReader::LinkPart(UpdatePart *part)

{

	part->next = NULL;

	if (partFirst == NULL)

	{

		partFirst = part;

		partLast = part;

	}

	else

	{

		partLast->next = part;

		partLast = part;

	}

}

void UpdateReader::HandleFile()

{

	MD5 md5;

	char real_checksum[33];

	mdl.Reset();

	if (!xfer->Download(url.c_str(), &mdl, NULL))

	{

		AddUpdateError("Could not download \"%s\"", url.c_str());

		AddUpdateError("Error: %s", xfer->LastErrorMessage());

		return;

	}

	md5.update((unsigned char *)mdl.GetBuffer(), mdl.GetSize());

	md5.finalize();

	md5.hex_digest(real_checksum);

	if (mdl.GetSize() == 0)

	{

		AddUpdateError("Zero-length file returned for \"%s\"", curfile.c_str());

		return;

	}

	if (strcasecmp(checksum, real_checksum) != 0)

	{

		AddUpdateError("Checksums for file \"%s\" do not match:", curfile.c_str());

		AddUpdateError("Expected: %s Real: %s", checksum, real_checksum);

		return;

	}

	UpdatePart *part = new UpdatePart;

	part->data = (char*)malloc(mdl.GetSize());

	memcpy(part->data, mdl.GetBuffer(), mdl.GetSize());

	part->file = strdup(curfile.c_str());

	part->length = mdl.GetSize();

	LinkPart(part);

}

void UpdateReader::HandleFolder(const char *folder)

{

	UpdatePart *part = new UpdatePart;

	part->data = NULL;

	part->length = 0;

	part->file = strdup(folder);

	LinkPart(part);

}

static bool md5_file(const char *file, char checksum[33])

{

	MD5 md5;

	FILE *fp;

	long length;

	void *fdata;

	if ((fp = fopen(file, "rb")) == NULL)

	{

		return false;

	}

	fseek(fp, 0, SEEK_END);

	length = ftell(fp);

	fseek(fp, 0, SEEK_SET);

	fdata = malloc(length);

	if (fread(fdata, 1, length, fp) != size_t(length))

	{

		free(fdata);

		fclose(fp);

		return false;

	}

	fclose(fp);

	md5.update((unsigned char*)fdata, length);

	md5.finalize();

	md5.hex_digest(checksum);

	free(fdata);

	return true;

}

/* Path should be sourcemod relative, not gamedata relative */

static bool add_file(IWebForm *form, const char *file, unsigned int &num_files)

{

	char path[PLATFORM_MAX_PATH];

	smutils->BuildPath(Path_SM, path, sizeof(path), "%s", file);

	char checksum[33];

	if (!md5_file(path, checksum))

	{

		return false;

	}

	char name[32];

	smutils->Format(name, sizeof(name), "file_%d_name", num_files);

	form->AddString(name, file);

	smutils->Format(name, sizeof(name), "file_%d_md5", num_files);

	form->AddString(name, checksum);

	num_files++;

	return true;

}

static void add_folders(IWebForm *form, const char *root, unsigned int &num_files)

{

	IDirectory *dir;

	char path[PLATFORM_MAX_PATH];

	char name[PLATFORM_MAX_PATH];

	smutils->BuildPath(Path_SM, path, sizeof(path), "%s", root);

	dir = libsys->OpenDirectory(path);

	if (dir == NULL)

	{

		AddUpdateError("Could not open folder: %s", path);

		return;

	}

	while (dir->MoreFiles())

	{

		if (strcmp(dir->GetEntryName(), ".") == 0 ||

			strcmp(dir->GetEntryName(), "..") == 0)

		{

			dir->NextEntry();

			continue;

		}

		smutils->Format(name, sizeof(name), "%s/%s", root, dir->GetEntryName());

		if (dir->IsEntryDirectory())

		{

			add_folders(form, name, num_files);

		}

		else if (dir->IsEntryFile())

		{

			add_file(form, name, num_files);

		}

		dir->NextEntry();

	}

	libsys->CloseDirectory(dir);

}

void UpdateReader::PerformUpdate(const char *url)

{

	IWebForm *form;

	MemoryDownloader master;

	SMCStates states = {0, 0};

	update_url = url;

	form = webternet->CreateForm();

	xfer = webternet->CreateSession();

	xfer->SetFailOnHTTPError(true);

	form->AddString("version", SM_VERSION_STRING);

	unsigned int num_files = 0;

	add_folders(form, "gamedata", num_files);

	char temp[24];

	smutils->Format(temp, sizeof(temp), "%d", num_files);

	form->AddString("files", temp);

	if (!xfer->PostAndDownload(url, form, &master, NULL))

	{

		AddUpdateError("Could not download \"%s\"", url);

		AddUpdateError("Error: %s", xfer->LastErrorMessage());

		goto cleanup;

	}

	SMCError error;

	char errbuf[256];

	error = textparsers->ParseSMCStream(master.GetBuffer(),

										master.GetSize(),

										this,

										&states,

										errbuf,

										sizeof(errbuf));

	if (error != SMCError_Okay)

	{

		AddUpdateError("Parse error in update manifest: %s", errbuf);

		goto cleanup;

	}

cleanup:

	delete xfer;

	delete form;

}

UpdatePart *UpdateReader::DetachParts()

{

	UpdatePart *first;

	first = partFirst;

	partFirst = NULL;

	partLast = NULL;

	return first;

}