/* UnrealIRCd module manager.
 * (C) Copyright 2019 Bram Matthys ("Syzop") and the UnrealIRCd Team.
 * License: GPLv2 or later
 * See https://www.unrealircd.org/docs/Module_manager for user documentation.
 */

#include "unrealircd.h"
#ifndef _WIN32

#define MODULEMANAGER_CONNECT_TIMEOUT	7
#define MODULEMANAGER_TRANSFER_TIMEOUT	20

typedef struct ManagedModule ManagedModule;

struct ManagedModule
{
	ManagedModule *prev, *next;
	char *repo_url;
	char *name;
	char *author;
	char *troubleshooting;
	char *documentation;
	char *version;
	char *source;
	char *sha256sum;
	time_t mtime;
	char *min_unrealircd_version;
	char *max_unrealircd_version;
	char *description;
	char *compile_flags;
	MultiLine *post_install_text;
	int unmanaged;
};

static ManagedModule *managed_modules = NULL;

/* We normally do a 'make install' after upgrading a module.
 * However we will skip it if --no-install is done.
 * This is only done during 'make', as it is unexpected to
 * already install modules at the final location before
 * 'make install' was issued.
 */
static int no_make_install = 0;

/* Forward declarations */
int mm_valid_module_name(char *name);
#define safe_free_managed_module(x)	do { free_managed_module(x); x = NULL; } while(0)
void free_managed_module(ManagedModule *m);

typedef enum ParseModuleHeaderStage {
	PMH_STAGE_LOOKING		= 0,
	PMH_STAGE_MODULEHEADER		= 1,
	PMH_STAGE_MOD_HEADER		= 2,
	PMH_STAGE_GOT_NAME		= 3,
	PMH_STAGE_GOT_VERSION		= 4,
	PMH_STAGE_GOT_DESCRIPTION	= 5,
	PMH_STAGE_GOT_AUTHOR		= 6,
	PMT_STAGE_DONE			= 7,
} ParseModuleHeaderStage;

typedef enum ParseModuleConfigStage {
	PMC_STAGE_LOOKING	= 0,
	PMC_STAGE_STARTED	= 1,
	PMC_STAGE_FINISHED	= 2,
} ParseModuleConfigStage;

int parse_quoted_string(char *buf, char *dest, size_t destlen)
{
	char *p, *p2;
	size_t max;
	char *i, *o;

	p = strchr(buf, '"');
	if (!p)
		return 0;
	p2 = strrchr(p+1, '"');
	if (!p2)
		return 0;
	max = p2 - p;
	if (max > destlen)
		max = destlen;
	strlcpy(dest, p+1, max);
	unreal_del_quotes(dest);
	return 1;
}

#undef CheckNull
#define CheckNull(x) if ((!(x)->value) || (!(*((x)->value)))) { config_error("%s:%i: missing parameter", m->name, (x)->line_number); return 0; }

/** Parse a module { } line from a module (not repo!!) */
int mm_module_file_config(ManagedModule *m, ConfigEntry *ce)
{
	ConfigEntry *cep;

	if (ce->value)
	{
		config_error("%s:%d: module { } block should not have a name.",
			m->name, ce->line_number);
		return 0;
	}

	for (cep = ce->items; cep; cep = cep->next)
	{
		if (!strcmp(cep->name, "source") ||
		    !strcmp(cep->name, "version") ||
		    !strcmp(cep->name, "author") ||
		    !strcmp(cep->name, "sha256sum") || 
		    !strcmp(cep->name, "description")
		    )
		{
			config_error("%s:%d: module::%s should not be in here (it only exists in repository entries)",
				m->name, cep->line_number, cep->name);
			return 0;
		}
		else if (!strcmp(cep->name, "troubleshooting"))
		{
			CheckNull(cep);
			safe_strdup(m->troubleshooting, cep->value);
		}
		else if (!strcmp(cep->name, "documentation"))
		{
			CheckNull(cep);
			safe_strdup(m->documentation, cep->value);
		}
		else if (!strcmp(cep->name, "min-unrealircd-version"))
		{
			CheckNull(cep);
			safe_strdup(m->min_unrealircd_version, cep->value);
		}
		else if (!strcmp(cep->name, "max-unrealircd-version"))
		{
			CheckNull(cep);
			safe_strdup(m->max_unrealircd_version, cep->value);
		}
		else if (!strcmp(cep->name, "compile-flags"))
		{
			CheckNull(cep);
			safe_strdup(m->compile_flags, cep->value);
		}
		else if (!strcmp(cep->name, "post-install-text"))
		{
			if (cep->items)
			{
				ConfigEntry *cepp;
				for (cepp = cep->items; cepp; cepp = cepp->next)
					addmultiline(&m->post_install_text, cepp->name);
			} else {
				CheckNull(cep);
				addmultiline(&m->post_install_text, cep->value);
			}
		}
		/* unknown items are silently ignored for future compatibility */
	}

	if (!m->documentation)
	{
		config_error("%s:%d: module::documentation missing", m->name, ce->line_number);
		return 0;
	}

	if (!m->troubleshooting)
	{
		config_error("%s:%d: module::troubleshooting missing", m->name, ce->line_number);
		return 0;
	}

	if (!m->min_unrealircd_version)
	{
		config_error("%s:%d: module::min-unrealircd-version missing", m->name, ce->line_number);
		return 0;
	}

	/* max_unrealircd_version is optional */

	/* post_install_text is optional */

	return 1;
}

#undef CheckNull

int mm_parse_module_file(ManagedModule *m, char *buf, unsigned int line_offset)
{
	ConfigFile *cf;
	ConfigEntry *ce;

	cf = config_parse_with_offset(m->name, buf, line_offset);
	if (!cf)
		return 0; /* eg: parse errors */

	/* Parse the module { } block (only one!) */
	for (ce = cf->items; ce; ce = ce->next)
	{
		if (!strcmp(ce->name, "module"))
		{
			int n = mm_module_file_config(m, ce);
			config_free(cf);
			return n;
		}
	}

	config_free(cf);
	config_error("No module block found within module source file. Contact author.\n");
	return 1;
}

#define MODULECONFIGBUFFER 16384
ManagedModule *mm_parse_module_c_file(char *modulename, char *fname, int silent)
{
	char buf[1024];
	FILE *fd;
	ParseModuleHeaderStage parse_module_header = PMH_STAGE_LOOKING;
	ParseModuleConfigStage parse_module_config = PMC_STAGE_LOOKING;
	char *moduleconfig = NULL;
	int linenr = 0, module_config_start_line = 0;
	char module_header_name[128];
	char module_header_version[64];
	char module_header_description[256];
	char module_header_author[128];
	ManagedModule *m = NULL;

	*module_header_name = *module_header_version = *module_header_description = *module_header_author = '\0';

	if (!mm_valid_module_name(modulename))
	{
		fprintf(stderr, "Module file '%s' contains forbidden characters\n", modulename);
		return NULL;
	}

	fd = fopen(fname, "r");
	if (!fd)
	{
		fprintf(stderr, "Unable to open module '%s', file '%s': %s\n",
			modulename, fname, strerror(errno));
		return NULL;
	}

	moduleconfig = safe_alloc(MODULECONFIGBUFFER); /* should be sufficient */
	while ((fgets(buf, sizeof(buf), fd)))
	{
		linenr++;
		stripcrlf(buf);
		/* parse module header stuff: */
		switch (parse_module_header)
		{
			case PMH_STAGE_LOOKING:
				if (strstr(buf, "ModuleHeader"))
					parse_module_header = PMH_STAGE_MODULEHEADER;
				else
					break;
				/*fallthrough*/
			case PMH_STAGE_MODULEHEADER:
				if (strstr(buf, "MOD_HEADER"))
					parse_module_header = PMH_STAGE_MOD_HEADER;
				break;
			case PMH_STAGE_MOD_HEADER:
				if (parse_quoted_string(buf, module_header_name, sizeof(module_header_name)))
					parse_module_header = PMH_STAGE_GOT_NAME;
				break;
			case PMH_STAGE_GOT_NAME:
				if (parse_quoted_string(buf, module_header_version, sizeof(module_header_version)))
					parse_module_header = PMH_STAGE_GOT_VERSION;
				break;
			case PMH_STAGE_GOT_VERSION:
				if (parse_quoted_string(buf, module_header_description, sizeof(module_header_description)))
					parse_module_header = PMH_STAGE_GOT_DESCRIPTION;
				break;
			case PMH_STAGE_GOT_DESCRIPTION:
				if (parse_quoted_string(buf, module_header_author, sizeof(module_header_author)))
					parse_module_header = PMH_STAGE_GOT_AUTHOR;
				break;
			default:
				break;
		}
		/* parse module config stuff: */
		switch (parse_module_config)
		{
			case PMC_STAGE_LOOKING:
				if (strstr(buf, "<<<MODULE MANAGER START>>>")){
					module_config_start_line = linenr;
					parse_module_config = PMC_STAGE_STARTED;
				}
				break;
			case PMC_STAGE_STARTED:
				if (!strstr(buf, "<<<MODULE MANAGER END>>>"))
				{
					strlcat(moduleconfig, buf, MODULECONFIGBUFFER);
					strlcat(moduleconfig, "\n", MODULECONFIGBUFFER);
				} else
				{
					parse_module_config = PMC_STAGE_FINISHED;
				}
				break;
			default:
				/* Nothing to be done anymore */
				break;
		}
	}
	fclose(fd);

	if (!*module_header_name || !*module_header_version ||
	    !*module_header_description || !*module_header_author)
	{
		fprintf(stderr, "Error parsing module header in %s\n", modulename);
		safe_free(moduleconfig);
		return NULL;
	}

	if (strcmp(module_header_name, modulename))
	{
		fprintf(stderr, "ERROR: Mismatch in module name in header (%s) and filename (%s)\n",
			module_header_name, modulename);
		safe_free(moduleconfig);
		return NULL;
	}

	if (!*moduleconfig)
	{
		if (!silent)
		{
			fprintf(stderr, "ERROR: Module does not contain module config data (<<<MODULE MANAGER START>>>)\n"
					"This means it is not meant to be managed by the module manager\n");
		}
		safe_free(moduleconfig);
		return NULL;
	}

	/* Fill in the fields from MOD_HEADER() */
	m = safe_alloc(sizeof(ManagedModule));
	safe_strdup(m->name, module_header_name);
	safe_strdup(m->version, module_header_version);
	safe_strdup(m->description, module_header_description);
	safe_strdup(m->author, module_header_author);

	if (!mm_parse_module_file(m, moduleconfig, module_config_start_line))
	{
		fprintf(stderr, "ERROR: Problem with module manager data block within the %s module C source file.\n"
		                "You are suggested to contact the module author and paste the above to him/her\n",
		                m->name);
		safe_free_managed_module(m);
		safe_free(moduleconfig);
		return NULL;
	}
	
	safe_free(moduleconfig);
	return m;
}

void print_documentation(void)
{
	fprintf(stderr, "See https://www.unrealircd.org/docs/Module_manager for more information.\n");
}

char *mm_sourceslist_file(void)
{
	static char buf1[512], buf2[512];
	snprintf(buf1, sizeof(buf1), "%s/modules.sources.list", CONFDIR);
	if (!file_exists(buf1))
	{
		/* Possibly UnrealIRCd is not installed yet, so use this one */
		snprintf(buf2, sizeof(buf2), "%s/doc/conf/modules.sources.list", BUILDDIR);
		if (!file_exists(buf2))
		{
			fprintf(stderr, "ERROR: Neither '%s' nor '%s' exist.\n"
			                "No module repositories configured.\n",
			                buf1, buf2);
			print_documentation();
			exit(-1);
		}
		return buf2;
	}
	return buf1;
}

/** Free a managed module struct */
void free_managed_module(ManagedModule *m)
{
	safe_free(m->repo_url);
	safe_free(m->name);
	safe_free(m->source);
	safe_free(m->sha256sum);
	safe_free(m->version);
	safe_free(m->author);
	safe_free(m->troubleshooting);
	safe_free(m->documentation);
	safe_free(m->min_unrealircd_version);
	safe_free(m->max_unrealircd_version);
	safe_free(m->description);
	safe_free(m->compile_flags);
	freemultiline(m->post_install_text);
	safe_free(m);
}

/** Check for valid module name */
int mm_valid_module_name(char *name)
{
	char *p;

	if (!str_starts_with_case_sensitive(name, "third/"))
		return 0;
	name += 6;
	if (strstr(name, ".."))
		return 0;
	for (p = name; *p; p++)
		if (!isalnum(*p) && !strchr("._-", *p))
			return 0;
	return 1;
}

#undef CheckNull
#define CheckNull(x) if ((!(x)->value) || (!(*((x)->value)))) { config_error("%s:%i: missing parameter", repo_url, (x)->line_number); goto fail_mm_repo_module_config; }

/** Parse a module { } line from a repository */
ManagedModule *mm_repo_module_config(char *repo_url, ConfigEntry *ce)
{
	ConfigEntry *cep;
	ManagedModule *m = safe_alloc(sizeof(ManagedModule));

	if (!ce->value)
	{
		config_error("%s:%d: module { } with no name",
			repo_url, ce->line_number);
		goto fail_mm_repo_module_config;
	}
	if (!str_starts_with_case_sensitive(ce->value, "third/"))
	{
		config_error("%s:%d: module { } name must start with: third/",
			repo_url, ce->line_number);
		goto fail_mm_repo_module_config;
	}
	if (!mm_valid_module_name(ce->value))
	{
		config_error("%s:%d: module { } with illegal name: %s",
			repo_url, ce->line_number, ce->value);
		goto fail_mm_repo_module_config;
	}
	safe_strdup(m->name, ce->value);
	safe_strdup(m->repo_url, repo_url);

	for (cep = ce->items; cep; cep = cep->next)
	{
		if (!strcmp(cep->name, "source"))
		{
			CheckNull(cep);
			safe_strdup(m->source, cep->value);
		}
		else if (!strcmp(cep->name, "sha256sum"))
		{
			CheckNull(cep);
			safe_strdup(m->sha256sum, cep->value);
		}
		else if (!strcmp(cep->name, "version"))
		{
			CheckNull(cep);
			safe_strdup(m->version, cep->value);
		}
		else if (!strcmp(cep->name, "author"))
		{
			CheckNull(cep);
			safe_strdup(m->author, cep->value);
		}
		else if (!strcmp(cep->name, "troubleshooting"))
		{
			CheckNull(cep);
			safe_strdup(m->troubleshooting, cep->value);
		}
		else if (!strcmp(cep->name, "documentation"))
		{
			CheckNull(cep);
			safe_strdup(m->documentation, cep->value);
		}
		else if (!strcmp(cep->name, "min-unrealircd-version"))
		{
			CheckNull(cep);
			safe_strdup(m->min_unrealircd_version, cep->value);
		}
		else if (!strcmp(cep->name, "max-unrealircd-version"))
		{
			CheckNull(cep);
			safe_strdup(m->max_unrealircd_version, cep->value);
		}
		else if (!strcmp(cep->name, "compile-flags"))
		{
			CheckNull(cep);
			safe_strdup(m->compile_flags, cep->value);
		}
		else if (!strcmp(cep->name, "description"))
		{
			CheckNull(cep);
			safe_strdup(m->description, cep->value);
		}
		else if (!strcmp(cep->name, "post-install-text"))
		{
			if (cep->items)
			{
				ConfigEntry *cepp;
				for (cepp = cep->items; cepp; cepp = cepp->next)
					addmultiline(&m->post_install_text, cepp->name);
			} else {
				CheckNull(cep);
				addmultiline(&m->post_install_text, cep->value);
			}
		}
		/* unknown items are silently ignored for future compatibility */
	}

	if (!m->source)
	{
		config_error("%s:%d: module::source missing", repo_url, ce->line_number);
		goto fail_mm_repo_module_config;
	}
	if (!m->sha256sum)
	{
		config_error("%s:%d: module::sha256sum missing", repo_url, ce->line_number);
		goto fail_mm_repo_module_config;
	}
	if (!m->version)
	{
		config_error("%s:%d: module::version missing", repo_url, ce->line_number);
		goto fail_mm_repo_module_config;
	}
	if (!m->author)
	{
		config_error("%s:%d: module::author missing", repo_url, ce->line_number);
		goto fail_mm_repo_module_config;
	}
	if (!m->documentation)
	{
		config_error("%s:%d: module::documentation missing", repo_url, ce->line_number);
		goto fail_mm_repo_module_config;
	}
	if (!m->troubleshooting)
	{
		config_error("%s:%d: module::troubleshooting missing", repo_url, ce->line_number);
		goto fail_mm_repo_module_config;
	}
	if (!m->min_unrealircd_version)
	{
		config_error("%s:%d: module::min-unrealircd-version missing", repo_url, ce->line_number);
		goto fail_mm_repo_module_config;
	}
	/* max_unrealircd_version is optional */
	if (!m->description)
	{
		config_error("%s:%d: module::description missing", repo_url, ce->line_number);
		goto fail_mm_repo_module_config;
	}
	/* post_install_text is optional */

	return m;

fail_mm_repo_module_config:
	safe_free_managed_module(m);
	return NULL;
}

#undef CheckNull

int mm_parse_repo_db(char *url, const char *filename)
{
	ConfigFile *cf;
	ConfigEntry *ce;
	ManagedModule *m;

	cf = config_load(filename, url);
	if (!cf)
		return 0; /* eg: parse errors */

	for (ce = cf->items; ce; ce = ce->next)
	{
		if (!strcmp(ce->name, "module"))
		{
			m = mm_repo_module_config(url, ce);
			if (!m)
			{
				config_free(cf);
				return 0;
			}
			AddListItem(m, managed_modules);
		}
	}
	config_free(cf);
	return 1;
}

int mm_refresh_repository(void)
{
	char *sourceslist = mm_sourceslist_file();
	FILE *fd;
	char buf[512];
	const char *tmpfile;
	int linenr = 0;
	int success = 0;
	int numrepos = 0;

	if (!file_exists(TMPDIR))
	{
		(void)mkdir(TMPDIR, S_IRUSR|S_IWUSR|S_IXUSR); /* Create the tmp dir, if it doesn't exist */
		if (!file_exists(TMPDIR))
		{
			/* This is possible if the directory structure does not exist,
			 * eg if ~/unrealircd does not exist at all then ~/unrealircd/tmp
			 * cannot be mkdir'ed either.
			 */
			fprintf(stderr, "ERROR: %s does not exist (yet?), cannot use module manager\n", TMPDIR);
			fprintf(stderr, "       This can only happen if you did not use ./Config or if you rm -rf'ed after running ./Config.\n");
			exit(-1);
		}
	}

	printf("Reading module repository list from '%s'...\n", mm_sourceslist_file());
	fd = fopen(sourceslist, "r");
	if (!fd)
	{
		fprintf(stderr, "ERROR: Could not open '%s': %s\n", sourceslist, strerror(errno));
		return 0;
	}

	while ((fgets(buf, sizeof(buf), fd)))
	{
		char *line = buf;
		linenr++;
		stripcrlf(line);
		/* Skip whitespace */
		while (*line == ' ')
			line++;
		/* Skip empty lines and ones that start with a hash mark (#) */
		if (!*line || (*line == '#'))
			continue;
		if (!str_starts_with_case_sensitive(line, "https://"))
		{
			fprintf(stderr, "ERROR in %s on line %d: URL should start with https://",
				sourceslist, linenr);
			fclose(fd);
			return 0;
		}
		printf("Checking module repository %s...\n", line);
		numrepos++;
		tmpfile = synchronous_http_request(line, 1, MODULEMANAGER_CONNECT_TIMEOUT, MODULEMANAGER_TRANSFER_TIMEOUT);
		if (tmpfile)
		{
			if (!mm_parse_repo_db(line, tmpfile))
			{
				fclose(fd);
				return 0;
			}
			success++;
		}
	}
	fclose(fd);

	if (numrepos == 0)
	{
		fprintf(stderr, "ERROR: No repositories listed in module repository list. "
		                "Did you remove the default UnrealIRCd repository?\n"
		                "All commands, except for './unrealircd module uninstall third/name-of-module', are unavailable.\n");
		return 0;
	}

	return success ? 1 : 0;
}

#define COLUMN_STATUS	0
#define COLUMN_NAME	1
#define COLUMN_VERSION	2

void mm_list_print(char *status, char *name, char *version, char *description, int largest_column[3])
{
	int padstatus = MAX(largest_column[COLUMN_STATUS] - strlen(status), 0);
	int padname = MAX(largest_column[COLUMN_NAME] - strlen(name), 0);
	int padversion = MAX(largest_column[COLUMN_VERSION] - strlen(version), 0);

	printf("| %s%*s | %s%*s | %s%*s | %s\n",
	       status,
	       padstatus, "",
	       name,
	       padname, "",
	       version,
	       padversion, "",
	       description);
}

int mm_check_module_compatibility(ManagedModule *m)
{
	if (strchr(m->min_unrealircd_version, '*'))
	{
		/* By wildcard, eg: "5.*" */
		if (!match_simple(m->min_unrealircd_version, VERSIONONLY))
			return 0;
	} else
	{
		/* By strcmp, eg: "5.0.0" */
		if (strnatcasecmp(m->min_unrealircd_version, VERSIONONLY) > 0)
			return 0;
	}
	if (m->max_unrealircd_version)
	{
		if (strchr(m->max_unrealircd_version, '*'))
		{
			/* By wildcard, eg: "5.*" */
			if (!match_simple(m->max_unrealircd_version, VERSIONONLY))
				return 0;
		} else
		{
			/* By strcmp, eg: "5.0.5" */
			if (strnatcasecmp(m->max_unrealircd_version, VERSIONONLY) <= 0)
				return 0;
		}
	}
	return 1;
}

#define MMMS_INSTALLED		0x0001
#define MMMS_UPGRADE_AVAILABLE	0x0002
#define MMMS_UNAVAILABLE	0x0004
#define MMMS_LOCAL_VERSION_IS_NEWER	0x0008

int mm_get_module_status(ManagedModule *m)
{
	FILE *fd;
	char fname[512];
	const char *our_sha256sum;
	ManagedModule *our_module;

	snprintf(fname, sizeof(fname), "%s/src/modules/%s.c", BUILDDIR, m->name);
	if (!file_exists(fname))
	{
		if (!mm_check_module_compatibility(m))
			return MMMS_UNAVAILABLE;
		return 0;
	}

	our_module = mm_parse_module_c_file(m->name, fname, 1);
	our_sha256sum = sha256sum_file(fname);

	if (our_module && our_module->version && (strnatcasecmp(m->version, our_module->version) < 0))
	{
		safe_free_managed_module(our_module);
		return MMMS_INSTALLED|MMMS_LOCAL_VERSION_IS_NEWER;
	}

	safe_free_managed_module(our_module);

	if (!strcasecmp(our_sha256sum, m->sha256sum))
		return MMMS_INSTALLED;

	if (!mm_check_module_compatibility(m))
		return MMMS_INSTALLED|MMMS_UNAVAILABLE;

	return MMMS_INSTALLED|MMMS_UPGRADE_AVAILABLE;
}

char *mm_get_module_status_string(ManagedModule *m)
{
	int status = mm_get_module_status(m);
	if (status == 0)
		return "";
	else if (status == MMMS_UNAVAILABLE)
		return "unav";
	else if (status == MMMS_INSTALLED)
		return "inst";
	else if (status == (MMMS_INSTALLED|MMMS_UNAVAILABLE))
		return "inst/UNAV";
	else if (status == (MMMS_INSTALLED|MMMS_UPGRADE_AVAILABLE))
		return "inst/UPD";
	else if (status == (MMMS_INSTALLED|MMMS_LOCAL_VERSION_IS_NEWER))
		return "inst/LOCAL";
	return "UNKNOWN?";
}

char *mm_get_module_status_string_long(ManagedModule *m)
{
	int status = mm_get_module_status(m);
	if (status == 0)
		return "Not installed";
	else if (status == MMMS_UNAVAILABLE)
		return "Unavailable for your UnrealIRCd version";
	else if (status == MMMS_INSTALLED)
		return "Installed and up to date";
	else if (status == (MMMS_INSTALLED|MMMS_UNAVAILABLE))
		return "Installed, an upgrade is available but not for your UnrealIRCd version";
	else if (status == (MMMS_INSTALLED|MMMS_UPGRADE_AVAILABLE))
		return "Installed, upgrade available";
	else if (status == (MMMS_INSTALLED|MMMS_LOCAL_VERSION_IS_NEWER))
		return "Installed, local version is newer than online version";
	return "UNKNOWN?";
}

/** Find a module by name, return NULL if not found. */
ManagedModule *mm_find_module(char *name)
{
	ManagedModule *m;

	for (m = managed_modules; m; m = m->next)
		if (!strcasecmp(name, m->name))
			return m;
	return NULL;
}

/** Count the unknown modules (untracked modules) */
int count_unknown_modules(void)
{
	DIR *fd;
	struct dirent *dir;
	int count = 0;
	char dirname[512];

	snprintf(dirname, sizeof(dirname), "%s/src/modules/third", BUILDDIR);

	fd = opendir(dirname);
	if (fd)
	{
		while ((dir = readdir(fd)))
		{
			char *fname = dir->d_name;
			if (filename_has_suffix(fname, ".c"))
			{
				char modname[512], *p;
				snprintf(modname, sizeof(modname), "third/%s", filename_strip_suffix(fname, ".c"));
				if (!mm_find_module(modname))
					count++;
			}
		}
		closedir(fd);
	}
	return count;
}

/** Returns 1 if any 3rd party modules are installed */
int any_third_party_modules_installed(void)
{
	DIR *fd;
	struct dirent *dir;
	char dirname[512];

	snprintf(dirname, sizeof(dirname), "%s/src/modules/third", BUILDDIR);

	fd = opendir(dirname);
	if (fd)
	{
		while ((dir = readdir(fd)))
		{
			char *fname = dir->d_name;
			if (filename_has_suffix(fname, ".c"))
			{
				closedir(fd);
				return 1;
			}
		}
		closedir(fd);
	}
	return 0;
}

void mm_list(char *searchname)
{
	ManagedModule *m;
	int largest_column[3];
	int padname;
	int padversion;
	struct dirent *dir;
	DIR *fd;
	char dirname[512];
	char *status;
	int first_unknown = 1;

	if (searchname)
		printf("Searching for '%s' in names of all available modules...\n", searchname);

	memset(&largest_column, 0, sizeof(largest_column));
	largest_column[COLUMN_STATUS] = strlen("inst/LOCAL");
	largest_column[COLUMN_NAME] = strlen("Name:");
	largest_column[COLUMN_VERSION] = strlen("Version:");

	for (m = managed_modules; m; m = m->next)
	{
		if (strlen(m->name) > largest_column[COLUMN_NAME])
			largest_column[COLUMN_NAME] = strlen(m->name);
		if (strlen(m->version) > largest_column[COLUMN_VERSION])
			largest_column[COLUMN_VERSION] = strlen(m->version);
	}
	/* We try to produce neat output, but not at all costs */
	if (largest_column[COLUMN_NAME] > 32)
		largest_column[COLUMN_NAME] = 32;
	if (largest_column[COLUMN_VERSION] > 16)
		largest_column[COLUMN_VERSION] = 16;

	mm_list_print("Status:", "Name:", "Version:", "Description:", largest_column);
	printf("|=======================================================================================\n");

	for (m = managed_modules; m; m = m->next)
	{
		if (searchname && !strstr(m->name, searchname))
			continue;

		status = mm_get_module_status_string(m);
		mm_list_print(status, m->name, m->version, m->description, largest_column);
	}

	snprintf(dirname, sizeof(dirname), "%s/src/modules/third", BUILDDIR);
	fd = opendir(dirname);
	if (fd)
	{
		while ((dir = readdir(fd)))
		{
			char *fname = dir->d_name;
			if (filename_has_suffix(fname, ".c"))
			{
				char modname[512], *p;
				snprintf(modname, sizeof(modname), "third/%s", filename_strip_suffix(fname, ".c"));
				if (searchname && !strstr(searchname, modname))
					continue;
				if (!mm_find_module(modname))
				{
					if (first_unknown)
					{
						printf("|---------------------------------------------------------------------------------------\n");
						first_unknown = 0;
					}
					mm_list_print("UNKNOWN", modname, "", "", largest_column);
				}
			}
		}
		closedir(fd);
	}

	printf("|=======================================================================================\n");

	printf("\nStatus column legend:\n"
	       "           : not installed\n"
	       "inst       : module installed\n"
	       "inst/UPD   : module installed, upgrade available (latest version differs from yours)\n"
	       "inst/LOCAL : module installed, local version is newer than available online (unusual!)\n"
	       "inst/UNAV  : module installed, upgrade exists but is not available for your UnrealIRCd version (too old UnrealIRCd version?)\n"
	       "unav       : module not available for your UnrealIRCd version\n"
	       "UNKNOWN    : module does not exist in any repository (perhaps you installed it manually?), module will be left untouched\n");

	printf("\nFor more information about a particular module, use './unrealircd module info name-of-module'\n\n");
	print_documentation();
}



/* Helper to get compile flags. Do not return NULL but "" here if none */
const char *mm_get_compile_flags(ManagedModule *m)
{
	static char retbuf[512];
	char *flags;

	if (!m->compile_flags)
		return "";

	/* Simple as-is for now */
	flags = m->compile_flags;

	unreal_add_quotes_r(flags, retbuf, sizeof(retbuf)-1);
	return retbuf;
}

int mm_compile(ManagedModule *m, const char *tmpfile, int test, int upgrade)
{
	char newpath[512];
	char cmd[512];
	const char *basename;
	char *p;
	FILE *fd;
	char buf[512];
	int n;

	if (test)
		printf("\nTest compiling %s...\n", m->name);
	else
		printf("\nCompiling %s...\n", m->name);

	basename = unreal_getfilename(test ? tmpfile : m->name);
	snprintf(newpath, sizeof(newpath), "%s/src/modules/third/%s%s", BUILDDIR, basename, test ? "" : ".c");
	if (!test && upgrade)
	{
		/* It's a good idea to backup the file rather than
		 * just delete it. Perhaps the user had local changes
		 * he/she wished to preserve and accidently went
		 * through the upgrade procedure.
		 */
		char backupfile[512];
		snprintf(backupfile, sizeof(backupfile), "%s.bak", newpath);
		unlink(backupfile);
		(void)rename(newpath, backupfile);
	}

	if (tmpfile && !unreal_copyfileex(tmpfile, newpath, 0))
		return 0;

	snprintf(cmd, sizeof(cmd),
	         "cd \"%s\"; $MAKE custommodule MODULEFILE=\"%s\" EXLIBS=\"%s\"",
	         BUILDDIR,
	         filename_strip_suffix(basename, ".c"),
	         mm_get_compile_flags(m)
	         );
	fd = popen(cmd, "r");
	if (!fd)
	{
		fprintf(stderr, "ERROR: Could not issue command: %s\n", cmd);
		unlink(newpath);
		return 0;
	}
	while((fgets(buf, sizeof(buf), fd)))
	{
		printf("%s", buf);
	}
	n = pclose(fd);

	if (test)
	{
		/* Remove the XXXXXXX.modname.c file */
		unlink(newpath);
		/* Remove the XXXXXXX.modname.so file */
		newpath[strlen(newpath)-2] = '\0'; // cut off .c
		strlcat(newpath, ".so", sizeof(newpath));
		unlink(newpath);
	}

	if (WIFEXITED(n) && (WEXITSTATUS(n) == 0))
		return 1;

	fprintf(stderr, "ERROR: Compile errors encountered while compiling module '%s'\n", m->name);
	if (m->author && m->troubleshooting)
	{
		fprintf(stderr, "You are suggested to contact the author (%s) of this module %s:\n%s\n",
	                m->author, m->name, m->troubleshooting);
	}

	return 0;
}

/** Compile all modules (including unknown), this is used by generic 'make' */
int mm_compile_all(int argc, char *args[])
{
	DIR *fd;
	struct dirent *dir;
	char dirname[512];
	ManagedModule *m;
	int n;

	snprintf(dirname, sizeof(dirname), "%s/src/modules/third", BUILDDIR);
	fd = opendir(dirname);
	if (fd)
	{
		while ((dir = readdir(fd)))
		{
			char *fname = dir->d_name;
			if (filename_has_suffix(fname, ".c"))
			{
				char fullpath[512];
				char modname[512];
				char *p;
				char simplename[512];

				snprintf(fullpath, sizeof(fullpath), "%s/%s", dirname, fname);
				strlcpy(simplename, filename_strip_suffix(fname, ".c"), sizeof(simplename));
				snprintf(modname, sizeof(modname), "third/%s", simplename);

				if (!(m = mm_find_module(modname)))
				{
					m = mm_parse_module_c_file(modname, fullpath, 1);
					if (!m)
					{
						/* No module manager block, create a fake one: */
						m = safe_alloc(sizeof(ManagedModule));
						safe_strdup(m->name, modname);
					}
					m->unmanaged = 1;
					n = mm_compile(m, NULL, 0, 0);
					safe_free_managed_module(m);
				} else {
					n = mm_compile(m, NULL, 0, 0);
				}

				if (n == 0)
				{
					/* Something if it fails? Error was already printed.
					 * We silently continue for now.
					 */
				}
			}
		}
		closedir(fd);
	}
	return 1; // always 1 atm
}

/** Actually download and install the module.
 * This assumes compatibility checks have already been done.
 */
int mm_install_module(ManagedModule *m)
{
	const char *sha256;
	const char *tmpfile;

	printf("Downloading %s from %s...\n", m->name, m->source);
	tmpfile = synchronous_http_request(m->source, 1, MODULEMANAGER_CONNECT_TIMEOUT, MODULEMANAGER_TRANSFER_TIMEOUT);
	if (!tmpfile)
	{
		fprintf(stderr, "Repository %s seems to list a module file that cannot be retrieved (%s).\n", m->repo_url, m->source);
		fprintf(stderr, "Fatal error encountered. Contact %s: %s\n", m->author, m->troubleshooting);
		return 0;
	}

	sha256 = sha256sum_file(tmpfile);
	if (!sha256)
	{
		fprintf(stderr, "ERROR: Temporary file '%s' has disappeared -- strange\n", tmpfile);
		fprintf(stderr, "Fatal error encountered. Check for errors above. Perhaps try running the command again?\n");
		return 0;
	}
	if (strcasecmp(sha256, m->sha256sum))
	{
		fprintf(stderr, "ERROR: SHA256 Checksum mismatch\n"
		                "Expected (value in repository list): %s\n"
		                "Received (value of downloaded file): %s\n",
		                m->sha256sum, sha256);
		fprintf(stderr, "Fatal error encountered, see above. Try running the command again in 5-10 minutes.\n"
		                "If the issue persists, contact the repository manager of %s\n",
		                m->repo_url);
		return 0;
	}
	if (!mm_compile(m, tmpfile, 1, 1))
	{
		fprintf(stderr, "Fatal error encountered, see above.\n");
		return 0;
	}

	if (!mm_compile(m, tmpfile, 0, 1))
	{
		fprintf(stderr, "The test compile went OK earlier, but the final compile did not. BAD!!\n");
		return 0;
	}
	printf("Module %s compiled successfully\n", m->name);
	return 1;
}

/** Uninstall a module.
 * This function takes a string rather than a ManagedModule
 * because it also allows uninstalling of unmanaged (local) modules.
 */
void mm_uninstall_module(char *modulename)
{
	struct dirent *dir;
	DIR *fd;
	char dirname[512], fullname[512];
	int found = 0;

	snprintf(dirname, sizeof(dirname), "%s/src/modules/third", BUILDDIR);
	fd = opendir(dirname);
	if (fd)
	{
		while ((dir = readdir(fd)))
		{
			char *fname = dir->d_name;
			if (filename_has_suffix(fname, ".c") || filename_has_suffix(fname, ".so") || filename_has_suffix(fname, ".dll"))
			{
				char modname[512], *p;
				snprintf(modname, sizeof(modname), "third/%s", filename_strip_suffix(fname, NULL));
				if (!strcasecmp(modname, modulename))
				{
					found = 1;
					snprintf(fullname, sizeof(fullname), "%s/%s", dirname, fname);
					//printf("Deleting '%s'\n", fullname);
					unlink(fullname);
				}
			}
		}
		closedir(fd);
	}

	if (!found)
	{
		fprintf(stderr, "ERROR: Module '%s' is not installed, so can't uninstall.\n", modulename);
		exit(-1);
	}

	printf("Module '%s' uninstalled successfully\n", modulename);
}

void mm_make_install(void)
{
	char cmd[512];
	int n;
	if (no_make_install)
		return;
	printf("Running 'make install'...\n");
	snprintf(cmd, sizeof(cmd), "cd \"%s\"; $MAKE install 1>/dev/null 2>&1", BUILDDIR);
	n = system(cmd);
}

int mm_install(int argc, char *args[], int upgrade)
{
	ManagedModule *m;
	MultiLine *l;
	char *name = args[1];
	int status;

	if (!name)
	{
		fprintf(stderr, "ERROR: Use: module install third/name-of-module\n");
		return 0;
	}

	if (!str_starts_with_case_sensitive(name, "third/"))
	{
		fprintf(stderr, "ERROR: Use: module install third/name-of-module\nYou must prefix the modulename with third/\n");
		return 0;
	}

	m = mm_find_module(name);
	if (!m)
	{
		fprintf(stderr, "ERROR: Module '%s' not found\n", name);
		return 0;
	}
	status = mm_get_module_status(m);
	if (status == MMMS_UNAVAILABLE)
	{
		fprintf(stderr, "ERROR: Module '%s' exists, but is not compatible with your UnrealIRCd version:\n"
		                "Your UnrealIRCd version  : %s\n"
		                "Minimum version required : %s\n",
		                name,
		                VERSIONONLY,
		                m->min_unrealircd_version);
		if (m->max_unrealircd_version)
			fprintf(stderr, "Maximum version          : %s\n", m->max_unrealircd_version);
		return 0;
	}
	if (upgrade && (status == MMMS_INSTALLED))
	{
		/* If updating, and we are already on latest version, then don't upgrade */
		printf("Module %s is the latest version, no upgrade needed\n", m->name);
		return 1;
	}
	if (upgrade && (status == (MMMS_INSTALLED|MMMS_LOCAL_VERSION_IS_NEWER)))
	{
		/* If updating, and we are already on latest version, then don't upgrade */
		printf("Module %s: local version is newer than the online version, not upgrading.\n", m->name);
		return 1;
	}
	if (!mm_install_module(m))
		return 0;
	mm_make_install();
	if (m->post_install_text)
	{
		printf("Post-installation information for %s from the author:\n", m->name);
		printf("---\n");
		for (l = m->post_install_text; l; l = l->next)
			printf(" %s\n", l->line);
		printf("---\n");
	} else {
		printf("Don't forget to add a 'loadmodule' line for the module and rehash\n");
	}
	return 1;
}

void mm_uninstall(int argc, char *args[])
{
	ManagedModule *m;
	char *name = args[1];

	if (!name)
	{
		fprintf(stderr, "ERROR: Use: module uninstall third/name-of-module\n");
		exit(-1);
	}

	if (!str_starts_with_case_sensitive(name, "third/"))
	{
		fprintf(stderr, "ERROR: Use: module uninstall third/name-of-module\nYou must prefix the modulename with third/\n");
		exit(-1);
	}

	mm_uninstall_module(name);
	mm_make_install();
	exit(0);
}

void mm_upgrade(int argc, char *args[])
{
	ManagedModule *m;
	char *name = args[1];
	int upgraded = 0;
	int failed = 0;
	int uptodate_already = 0;
	int update_unavailable = 0;
	int i = 1, n;

	if (args[i] && !strcmp(args[i], "--no-install"))
	{
		no_make_install = 1;
		i++;
	}

	name = args[i];
	if (name)
	{
		// TODO: First check if it needs an upgrade? ;)
		mm_install(argc, args, 1);
		exit(0);
	}

	/* Without arguments means: check all installed modules */
	no_make_install = 1;
	for (m = managed_modules; m; m = m->next)
	{
		int status = mm_get_module_status(m);
		if (status == (MMMS_INSTALLED|MMMS_UPGRADE_AVAILABLE))
		{
			args[1] = m->name;
			if (mm_install(1, args, 1))
				upgraded++;
			else
				failed++;
		} else
		if ((status == MMMS_INSTALLED) || (status == (MMMS_INSTALLED|MMMS_LOCAL_VERSION_IS_NEWER)))
		{
			uptodate_already++;
		} else
		if (status == (MMMS_INSTALLED|MMMS_UNAVAILABLE))
		{
			update_unavailable++;
		}
	}
	no_make_install = 0;
	if (upgraded)
		mm_make_install();

	printf("\n\n");
	if (failed)
	{
		printf("There was %d FAILED module upgrade. %d module(s) upgraded, %d already up-to-date\n",
			failed, upgraded, uptodate_already);
	} else {
		printf("All actions were successful. %d module(s) upgraded, %d already up-to-date\n",
			upgraded, uptodate_already);
	}
	if (update_unavailable)
		printf("%d module(s) have updates but not for your UnrealIRCd version\n", update_unavailable);
	if ((n = count_unknown_modules()))
		printf("%d module(s) are unknown/untracked\n", n);

	printf("For more details, you can always run ./unrealircd module list\n");
}

void mm_info(int argc, char *args[])
{
	ManagedModule *m;
	MultiLine *l;
	char *name = args[1];

	if (!name)
	{
		fprintf(stderr, "ERROR: Use: unrealircd module info name-of-module\n");
		exit(-1);
	}

	m = mm_find_module(name);
	if (!m)
	{
		// TODO: we should probably be a bit more specific if the module exists locally (UNAV) */
		fprintf(stderr, "ERROR: Module '%s' not found in any repository\n", name);
		exit(-1);
	}
	printf("Name:                    %s\n"
	       "Version:                 %s\n"
	       "Description:             %s\n"
	       "Author:                  %s\n"
	       "Documentation:           %s\n"
	       "Troubleshooting:         %s\n"
	       "Source:                  %s\n"
	       "Min. UnrealIRCd version: %s\n",
	       m->name,
	       m->version,
	       m->description,
	       m->author,
	       m->documentation,
	       m->troubleshooting,
	       m->source,
	       m->min_unrealircd_version);
	if (m->max_unrealircd_version)
		printf("Min. UnrealIRCd version: %s\n", m->max_unrealircd_version);
	printf("Status:                  %s\n", mm_get_module_status_string_long(m));
	if (m->post_install_text)
	{
		printf("------  Post-installation text  ------\n");
		for (l = m->post_install_text; l; l = l->next)
			printf(" %s\n", l->line);
		printf("------ End of post-install text ------\n");
	}
}

void mm_usage(void)
{
	fprintf(stderr, "Use any of the following actions:\n"
	                "unrealircd module list                     List all the available and installed modules\n"
	                "unrealircd module info name-of-module      Show more information about the module\n"
	                "unrealircd module install name-of-module   Install the specified module\n"
	                "unrealircd module uninstall name-of-module Uninstall the specified module\n"
	                "unrealircd module upgrade name-of-module   Upgrade the specified module (if needed)\n"
	                "unrealircd module upgrade                  Upgrade all modules (if needed)\n"
	                "unrealircd module generate-repository      Generate a repository index (you are\n"
	                "                                           unlikely to need this, only for repo admins)\n");
	print_documentation();
	exit(-1);
}

void print_md_block(FILE *fdo, ManagedModule *m)
{
	fprintf(fdo, "module \"%s\"\n{\n", m->name);
	fprintf(fdo, "\tdescription \"%s\";\n", unreal_add_quotes(m->description));
	fprintf(fdo, "\tversion \"%s\";\n", unreal_add_quotes(m->version));
	fprintf(fdo, "\tauthor \"%s\";\n", unreal_add_quotes(m->author));
	fprintf(fdo, "\tdocumentation \"%s\";\n", unreal_add_quotes(m->documentation));
	fprintf(fdo, "\ttroubleshooting \"%s\";\n", unreal_add_quotes(m->troubleshooting));
	fprintf(fdo, "\tsource \"%s\";\n", unreal_add_quotes(m->source));
	fprintf(fdo, "\tsha256sum \"%s\";\n", unreal_add_quotes(m->sha256sum));
	fprintf(fdo, "\tlast-updated \"%s\";\n", unreal_add_quotes(timestamp_iso8601(m->mtime)));
	fprintf(fdo, "\tmin-unrealircd-version \"%s\";\n", unreal_add_quotes(m->min_unrealircd_version));
	if (m->max_unrealircd_version)
		fprintf(fdo, "\tmax-unrealircd-version \"%s\";\n", unreal_add_quotes(m->max_unrealircd_version));
	if (m->compile_flags)
		fprintf(fdo, "\tcompile-flags \"%s\";\n", unreal_add_quotes(m->compile_flags));
	if (m->post_install_text)
	{
		MultiLine *l;
		fprintf(fdo, "\tpost-install-text\n"
		             "\t{\n");
		for (l = m->post_install_text; l; l = l->next)
			fprintf(fdo, "\t\t\"%s\";\n", unreal_add_quotes(l->line));
		fprintf(fdo, "\t}\n");
	}
	fprintf(fdo, "}\n\n");
}

void mm_generate_repository_usage(void)
{
	fprintf(stderr, "Usage: ./unrealircd module generate-repository <url base path> <directory-with-modules> <name of output file> [optional-minimum-version-filter]\n");
	fprintf(stderr, "For example: ./unrealircd module generate-repository https://www.unrealircd.org/modules/ src/modules/third modules.lst\n");
}

void mm_generate_repository(int argc, char *args[])
{
	DIR *fd;
	struct dirent *dir;
	int count = 0;
	char *urlbasepath;
	char *dirname;
	char *outputfile;
	char *minversion;
	char modname[128];
	char fullname[512];
	ManagedModule *m;
	FILE *fdo;

	urlbasepath = args[1];
	dirname = args[2];
	outputfile = args[3];
	minversion = args[4];

	if (!urlbasepath || !dirname || !outputfile)
	{
		mm_generate_repository_usage();
		exit(-1);
	}

	if ((strlen(urlbasepath) < 2) || (urlbasepath[strlen(urlbasepath)-1] != '/'))
	{
		fprintf(stderr, "Error: the URL base path must end with a slash\n");
		mm_generate_repository_usage();
		exit(-1);
	}

	fd = opendir(dirname);
	if (!fd)
	{
		fprintf(stderr, "Cannot open directory '%s': %s\n", dirname, strerror(errno));
		exit(-1);
	}

	fdo = fopen(outputfile, "w");
	if (!fdo)
	{
		fprintf(stderr, "Could not open file '%s' for writing: %s\n", outputfile, strerror(errno));
		exit(-1);
	}

	while ((dir = readdir(fd)))
	{
		char *fname = dir->d_name;
		if (filename_has_suffix(fname, ".c"))
		{
			int hide = 0;
			snprintf(fullname, sizeof(fullname), "%s/%s", dirname, fname);
			snprintf(modname, sizeof(modname), "third/%s", filename_strip_suffix(fname, ".c"));
			printf("Processing: %s\n", modname);
			m = mm_parse_module_c_file(modname, fullname, 0);
			if (!m)
			{
				fprintf(stderr, "WARNING: Skipping module '%s' due to errors\n", modname);
				continue;
			}
			m->sha256sum = strdup(sha256sum_file(fullname));
			m->source = safe_alloc(512);
			m->mtime = unreal_getfilemodtime(fullname);
			snprintf(m->source, 512, "%s%s.c", urlbasepath, modname + 6);
			/* filter */
			if (minversion && m->min_unrealircd_version && strncmp(minversion, m->min_unrealircd_version, strlen(minversion)))
				hide = 1;
			/* /filter */
			if (!hide)
				print_md_block(fdo, m);
			safe_free_managed_module(m);
		}
	}
	closedir(fd);
	fclose(fdo);
}

void mm_parse_c_file(int argc, char *args[])
{
	char *fullname = args[1];
	const char *basename;
	char modname[256];
	ManagedModule *m;

	if (!fullname)
	{
		fprintf(stderr, "Usage: ./unrealircd module parse-c-file path/to/file.c\n");
		exit(-1);
	}
	if (!file_exists(fullname))
	{
		fprintf(stderr, "ERROR: Unable to open C file '%s'\n", fullname);
		exit(-1);
	}
	basename = unreal_getfilename(fullname);

	snprintf(modname, sizeof(modname), "third/%s", filename_strip_suffix(basename, ".c"));
	printf("Processing: %s\n", modname);
	m = mm_parse_module_c_file(modname, fullname, 0);
	if (!m)
	{
		fprintf(stderr, "Errors encountered. See above\n");
		exit(-1);
	}
	m->sha256sum = strdup(sha256sum_file(fullname));
	m->source = strdup("...");
	print_md_block(stdout, m);
	safe_free_managed_module(m);
	exit(0);
}

int mm_detect_make_is_gmake(void)
{
	FILE *fd;
	char buf[512], *s;

	fd = popen("$MAKE --version 2>&1", "r");
	if (fd)
	{
		*buf = '\0';
		s = fgets(buf, sizeof(buf), fd);
		pclose(fd);
		if (s && strstr(s, "GNU Make"))
			return 1; /* Good! We are done. */
	}
	return 0;
}

void mm_detect_make(void)
{
	FILE *fd;
	char *s;
	char buf[512];

	/* Get or set $MAKE */
	s = getenv("MAKE");
	if (!s)
		setenv("MAKE", "make", 1);

	if (mm_detect_make_is_gmake())
		return;

	/* Try again with MAKE=gmake */
	setenv("MAKE", "gmake", 1);
	if (mm_detect_make_is_gmake())
		return;

	fprintf(stderr, "ERROR: GNU Make is not found as 'make' or 'gmake'\n");
	exit(-1);
}

void mm_self_test(void)
{
	char name[512];

	if (!file_exists(BUILDDIR))
	{
		fprintf(stderr, "ERROR: Directory %s does not exist.\n"
				"The UnrealIRCd source is required for the module manager to work!\n",
				BUILDDIR);
		exit(-1);
	} else {
		snprintf(name, sizeof(name), "%s/src/modules/third/Makefile", BUILDDIR);
		if (!file_exists(name))
		{
			fprintf(stderr, "ERROR: Directory %s exists, but your UnrealIRCd is not compiled yet.\n"
					"You must compile your UnrealIRCd first (run './Config', then 'make install')\n",
					BUILDDIR);
			exit(-1);
		}
	}
	mm_detect_make();
}

void modulemanager(int argc, char *args[])
{
	if (!args[0])
		mm_usage();

	mm_self_test();

	/* The following operations do not require reading
	 * of the repository list and are always available:
	 */
	if (!strcasecmp(args[0], "uninstall") ||
	    !strcasecmp(args[0], "remove"))
	{
		mm_uninstall(argc, args);
		exit(0);
	}
	else if (!strcasecmp(args[0], "generate-repository"))
	{
		mm_generate_repository(argc, args);
		exit(0);
	}
	else if (!strcasecmp(args[0], "parse-c-file"))
	{
		mm_parse_c_file(argc, args);
		exit(0);
	}
	else if (!strcasecmp(args[0], "compile-all"))
	{
		mm_compile_all(argc, args);
		exit(0);
	}

	/* Check if there are any 3rd party mods at all in src/modules/third/.
	 * If there are none, and we are asked to run 'upgrade' then
	 * we bail out prematurely. This saves a repo check if you have no
	 * third party modules installed.
	 */
	if (!strcasecmp(args[0], "upgrade") && !any_third_party_modules_installed())
	{
		fprintf(stderr, "No third party modules installed. Module manager has nothing to do.\n");
		exit(0);
	}

	/* Fetch the repository list */
	if (!mm_refresh_repository())
	{
		fprintf(stderr, "Fatal error encountered\n");
		exit(-1);
	}

	if (!strcasecmp(args[0], "list"))
		mm_list(args[1]);
	else if (!strcasecmp(args[0], "info"))
		mm_info(argc, args);
	else if (!strcasecmp(args[0], "install"))
	{
		if (mm_install(argc, args, 0))
			fprintf(stderr, "All actions were successful.\n");
		else
			exit(1);
	}
	else if (!strcasecmp(args[0], "upgrade"))
		mm_upgrade(argc, args);
	else
		mm_usage();
}
#endif
