if (left) memcpy(this->buf, p, left);

}

{

	static const uint8 pad[64] = {

		0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

#ifndef MD5_INCLUDED

#define MD5_INCLUDED

struct Md5 {

private:

	uint32 count[2]; ///< message length in bits, lsw first

public:

	Md5();

	void Append(const void *data, const size_t nbytes);

};

#endif /* MD5_INCLUDED */

#include "gfx_type.h"

#include "textfile_type.h"

#include "textfile_gui.h"

#include <unordered_map>

/* Forward declare these; can't do 'struct X' in functions as older GCCs barf on that */

	};

	std::string filename;        ///< filename

	std::string missing_warning; ///< warning when this file is missing

	ChecksumResult check_result; ///< cached result of md5 check

			return false;

		}

		const char *c = item->value->c_str();

			uint j;

			if ('0' <= *c && *c <= '9') {

				j = *c - '0';

		if (s->shortname != ci->unique_id) continue;

		if (!md5sum) return s->files[0].filename.c_str();

		for (uint i = 0; i < Tbase_set::NUM_FILES; i++) {

			}

	}

	return nullptr;

}

/** Basic data to distinguish a scenario. Used in the server list window */

struct ScenarioIdentifier {

	uint32 scenid;           ///< ID for the scenario (generated by content).

	std::string filename;    ///< filename of the file.

	bool operator == (const ScenarioIdentifier &other) const

	{

	}

	bool operator != (const ScenarioIdentifier &other) const

	_scanner.Scan(false);

	for (ScenarioIdentifier &id : _scanner) {

		           : (id.scenid == ci->unique_id)) {

			return id.filename.c_str();

		}

 * @param md5sum array of md5sum to print, if known

 * @param gc GrfConfig, if known

 */

{

	if (md5sum != nullptr) {

	} else {

		fmt::format_to(output_iterator, "GRF ID {:08X}", BSWAP32(grfid));

	}

/* virtual */ void LoggedChangeGRFAdd::FormatTo(std::back_insert_iterator<std::string> &output_iterator, GrfIDMapping &grf_names, GamelogActionType action_type)

{

	/* A NewGRF got added to the game, either at the start of the game (never an issue), or later on when it could be an issue. */

	fmt::format_to(output_iterator, "Added NewGRF: ");

	auto gm = grf_names.find(this->grfid);

	if (gm != grf_names.end() && !gm->second.was_missing) fmt::format_to(output_iterator, ". Gamelog inconsistency: GrfID was already added!");

	grf_names[this->grfid] = gc;

/* virtual */ void LoggedChangeGRFChanged::FormatTo(std::back_insert_iterator<std::string> &output_iterator, GrfIDMapping &grf_names, GamelogActionType action_type)

{

	/* Another version of the same NewGRF got loaded. */

	fmt::format_to(output_iterator, "Compatible NewGRF loaded: ");

	if (grf_names.count(this->grfid) == 0) fmt::format_to(output_iterator, ". Gamelog inconsistency: GrfID was never added!");

	grf_names[this->grfid] = gc;

}

				this->GRFMove(nl[n++]->ident.grfid, -(int)oi);

			}

		} else {

				/* md5sum changed, probably loading 'compatible' GRF */

				this->GRFCompatible(&nl[n]->ident);

			}

	Md5 checksum;

	uint8 buffer[1024];

	size_t len;

	while ((len = fread(buffer, 1, (size > sizeof(buffer)) ? sizeof(buffer) : size, f)) != 0 && size != 0) {

	FioFCloseFile(f);

	checksum.Finish(digest);

}

/** Names corresponding to the GraphicsFileType */

	std::string coding_string = fmt::format("{}{}{}", InteractiveRandom(), current_time, subject);

	Md5 checksum;

	checksum.Append(coding_string.c_str(), coding_string.length());

	checksum.Finish(digest);

static void HandleIncomingNetworkGameInfoGRFConfig(GRFConfig *config, std::string name)

{

	/* Find the matching GRF file */

	if (f == nullptr) {

		AddGRFTextToList(config->name, name.empty() ? GetString(STR_CONFIG_ERROR_INVALID_GRF_UNKNOWN) : name);

		config->status = GCS_NOT_FOUND;

 */

void SerializeGRFIdentifier(Packet *p, const GRFIdentifier *grf)

{

	p->Send_uint32(grf->grfid);

		p->Send_uint8(grf->md5sum[j]);

	}

}

 */

void DeserializeGRFIdentifier(Packet *p, GRFIdentifier *grf)

{

	grf->grfid = p->Recv_uint32();

		grf->md5sum[j] = p->Recv_uint8();

	}

}

			tmp = Game::GetScannerLibrary()->FindMainScript(this, true);

			break;

		case CONTENT_TYPE_NEWGRF: {

			tmp = gc != nullptr ? gc->filename.c_str() : nullptr;

			break;

		}

#ifndef NETWORK_CORE_TCP_CONTENT_TYPE_H

#define NETWORK_CORE_TCP_CONTENT_TYPE_H

/** The values in the enum are important; they are used as database 'keys' */

enum ContentType {

	CONTENT_TYPE_BEGIN         = 1, ///< Helper to mark the begin of the types

	std::string url;                         ///< URL related to the content

	std::string description;                 ///< Description of the content

	uint32 unique_id = 0;                    ///< Unique ID; either GRF ID or shortname

	std::vector<ContentID> dependencies;     ///< The dependencies (unique server side ids)

	StringList tags;                         ///< Tags associated with the content

	State state = State::UNSELECTED;         ///< Whether the content info is selected (for download)

	}

	Md5 checksum;

	/* Generate the MD5 hash */

	std::string salted_password_string = salted_password.str();

	checksum.Append(salted_password_string.data(), salted_password_string.size());

	checksum.Finish(digest);

}

/**

NetworkJoinInfo _network_join;

/** Make sure the server ID length is the same as a md5 hash. */

/***********

 * Sending functions

		DeserializeGRFIdentifier(p, &c);

		/* Check whether we know this GRF */

		if (f == nullptr) {

			/* We do not know this GRF, bail out of initialization */

			Debug(grf, 0, "NewGRF {:08X} not found; checksum {}", BSWAP32(c.grfid), MD5SumToString(c.md5sum));

/** Wrapper function for the HasProc */

static bool HasGRFConfig(const ContentInfo *ci, bool md5sum)

{

}

/**

	ci->description = p->Recv_string(NETWORK_CONTENT_DESC_LENGTH, SVS_REPLACE_WITH_QUESTION_MARK | SVS_ALLOW_NEWLINE);

	ci->unique_id = p->Recv_uint32();

		ci->md5sum[j] = p->Recv_uint8();

	}

	/* Do we already have a stub for this? */

	for (ContentInfo *ici : this->infos) {

			/* Preserve the name if possible */

			if (ci->name.empty()) ci->name = ici->name;

			if (ici->IsSelected()) ci->state = ici->state;

	assert(cv->size() < 255);

	assert(cv->size() < (TCP_MTU - sizeof(PacketSize) - sizeof(byte) - sizeof(uint8)) /

	Packet *p = new Packet(send_md5sum ? PACKET_CONTENT_CLIENT_INFO_EXTID_MD5 : PACKET_CONTENT_CLIENT_INFO_EXTID, TCP_MTU);

	p->Send_uint8((uint8)cv->size());

		p->Send_uint32(ci->unique_id);

		if (!send_md5sum) continue;

			p->Send_uint8(ci->md5sum[j]);

		}

	}

		bool found = false;

		for (ContentInfo *ci2 : this->infos) {

			if (ci->type == ci2->type && ci->unique_id == ci2->unique_id &&

				found = true;

				break;

			}

		for (GRFConfig *c = item->info.grfconfig; c != nullptr; c = c->next) {

			assert(HasBit(c->flags, GCF_COPY));

			if (f == nullptr) {

				/* Don't know the GRF (anymore), so mark game incompatible. */

				c->status = GCS_NOT_FOUND;

GRFConfig::GRFConfig(const GRFConfig &config) :

	ZeroedMemoryAllocator(),

	ident(config.ident),

	filename(config.filename),

	name(config.name),

	info(config.info),

	param_info(config.param_info),

	has_param_defaults(config.has_param_defaults)

{

	MemCpyT<uint32>(this->param, config.param, lengthof(this->param));

	if (config.error != nullptr) this->error = std::make_unique<GRFError>(*config.error);

}

	GRFListCompatibility res = GLC_ALL_GOOD;

	for (GRFConfig *c = grfconfig; c != nullptr; c = c->next) {

		if (f == nullptr || HasBit(f->flags, GCF_INVALID)) {

			/* If we have not found the exactly matching GRF try to find one with the

			 * same grfid, as it most likely is compatible */

				if (!HasBit(c->flags, GCF_COMPATIBLE)) {

					/* Preserve original_md5sum after it has been assigned */

					SetBit(c->flags, GCF_COMPATIBLE);

				}

				/* Non-found has precedence over compatibility load */

			 * already a local one, so there is no need to replace it. */

			if (!HasBit(c->flags, GCF_COPY)) {

				c->filename = f->filename;

				c->name = f->name;

				c->info = f->name;

				c->error = nullptr;

			GRFConfig **pd, *d;

			bool stop = false;

			for (pd = &_all_grfs; (d = *pd) != nullptr; pd = &d->next) {

				/* Because there can be multiple grfs with the same name, make sure we checked all grfs with the same name,

				 *  before inserting the entry. So insert a new grf at the end of all grfs with the same name, instead of

				 *  just after the first with the same name. Avoids doubles in the list. */

 * @param desired_version Requested version

 * @return The matching grf, if it exists in #_all_grfs, else \c nullptr.

 */

{

	assert((mode == FGCM_EXACT) != (md5sum == nullptr));

	const GRFConfig *best = nullptr;

#include "fileio_type.h"

#include "textfile_type.h"

#include "newgrf_text.h"

/** GRF config bit flags */

enum GCF_Flags {

/** Basic data to distinguish a GRF. Used in the server list window */

struct GRFIdentifier {

	uint32 grfid;     ///< GRF ID (defined by Action 0x08)

	GRFIdentifier() = default;

	GRFIdentifier(const GRFIdentifier &other) = default;

	GRFIdentifier(GRFIdentifier &&other) = default;

	GRFIdentifier& operator =(const GRFIdentifier &other) = default;

	 * @param md5sum Expected md5sum, may be \c nullptr (in which case, do not check it).

	 * @return the object has the provided grfid and md5sum.

	 */

	{

		if (this->grfid != grfid) return false;

		if (md5sum == nullptr) return true;

	}

};

	GRFConfig &operator=(GRFConfig &rhs) = delete;

	GRFIdentifier ident; ///< grfid and md5sum to uniquely identify newgrfs

	std::string filename; ///< Filename - either with or without full path

	GRFTextWrapper name; ///< NOSAVE: GRF name (Action 0x08)

	GRFTextWrapper info; ///< NOSAVE: GRF info (author, copyright, ...) (Action 0x08)

size_t GRFGetSizeOfDataSection(FILE *f);

void ScanNewGRFFiles(NewGRFScanCallback *callback);

GRFConfig *GetGRFConfig(uint32 grfid, uint32 mask = 0xFFFFFFFF);

GRFConfig **CopyGRFConfigList(GRFConfig **dst, const GRFConfig *src, bool init_only);

void AppendStaticGRFConfigs(GRFConfig **dst);

					bool compatible = HasBit(c->flags, GCF_COMPATIBLE);

					if (c->status != GCS_NOT_FOUND && !compatible) continue;

					if (f == nullptr || HasBit(f->flags, GCF_INVALID)) continue;

					*l = new GRFConfig(*f);

		i = a->version - b->version;

		if (i != 0) return i < 0;

	}

	/** Filter grfs by tags/name */

		for (const GRFConfig *c = _all_grfs; c != nullptr; c = c->next) {

			bool found = false;

			if (found) continue;

			if (_settings_client.gui.newgrf_show_old_versions) {

				 * If we are the best version, then we definitely want to

				 * show that NewGRF!.

				 */

					this->avails.push_back(c);

				}

			}

		ci->state = ContentInfo::DOES_NOT_EXIST;

		ci->name = c->GetName();

		ci->unique_id = BSWAP32(c->ident.grfid);

		cv.push_back(ci);

	}

	ShowNetworkContentListWindow(cv.size() == 0 ? nullptr : &cv, CONTENT_TYPE_NEWGRF);

/** Helper for creating a MD5sum of all files within of a script. */

struct ScriptFileChecksumCreator : FileScanner {

	Subdirectory dir; ///< The directory to look in.

	/**

	 * Initialise the md5sum to be all zeroes,

	 * so we can easily xor the data.

	 */

	/* Add the file and calculate the md5 sum. */

	virtual bool AddFile(const std::string &filename, size_t basepath_length, const std::string &tar_filename)

		Md5 checksum;

		uint8 buffer[1024];

		size_t len, size;

		/* Open the file ... */

		FILE *f = FioFOpenFile(filename, "rb", this->dir, &size);

			size -= len;

			checksum.Append(buffer, len);

		}

		checksum.Finish(tmp_md5sum);

		FioFCloseFile(f);

		/* ... and xor it to the overall md5sum. */

		return true;

	}

		checksum.Scan(".nut", path);

	}

}

bool ScriptScanner::HasScript(const ContentInfo *ci, bool md5sum)

	for (item = group->item; item != nullptr; item = item->next) {

		GRFConfig *c = nullptr;

		const char *filename = item->name.c_str();

		bool has_grfid = false;

		bool has_md5sum = false;

		has_grfid = DecodeHexText(filename, grfid_buf, lengthof(grfid_buf));

		if (has_grfid) {

			filename += 1 + 2 * lengthof(grfid_buf);

			uint32 grfid = grfid_buf[0] | (grfid_buf[1] << 8) | (grfid_buf[2] << 16) | (grfid_buf[3] << 24);

			if (has_md5sum) {

				if (s != nullptr) c = new GRFConfig(*s);

			}

			if (c == nullptr && !FioCheckFileExists(filename, NEWGRF_DIR)) {

 * @param md5sum the md5sum itself

 * @return the string representation of the md5sum.

 */

{

}

#include "core/bitmath_func.hpp"

#include "core/span_type.hpp"

#include "string_type.h"

char *strecat(char *dst, const char *src, const char *last) NOACCESS(3);

char *strecpy(char *dst, const char *src, const char *last) NOACCESS(3);

	return t - str;

}

bool IsValidChar(WChar key, CharSetFilter afilter);