/* extensions.c - core analysis suite
 *
 * Copyright (C) 2001, 2002 Mission Critical Linux, Inc.
 * Copyright (C) 2002-2013 David Anderson
 * Copyright (C) 2002-2013 Red Hat, Inc. 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 as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * 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.
 */

#include "defs.h"
#include <dlfcn.h>

static int in_extensions_library(char *, char *);
static char *get_extensions_directory(char *);

#define DUMP_EXTENSIONS   (0)
#define LOAD_EXTENSION    (1)
#define UNLOAD_EXTENSION  (2)

/*
 *  Load, unload, or list the extension libaries.
 */
void
cmd_extend(void)
{
        int c;
	int flag;

	flag = DUMP_EXTENSIONS;

        while ((c = getopt(argcnt, args, "lu")) != EOF) {
                switch(c)
                {
		case 'l':
			if (flag & UNLOAD_EXTENSION) {
				error(INFO, 
					"-l and -u are mutually exclusive\n");
				argerrs++;
			} else
				flag |= LOAD_EXTENSION;
			break;

		case 'u':
                        if (flag & LOAD_EXTENSION) {
                                error(INFO, 
                                        "-u and -l are mutually exclusive\n");
                                argerrs++;
                        } else
                                flag |= UNLOAD_EXTENSION;
			break;

                default:
                        argerrs++;
                        break;
                }
        }

        if (argerrs)
                cmd_usage(pc->curcmd, SYNOPSIS);

	switch (flag)
	{
	case DUMP_EXTENSIONS:
		if (!args[optind]) {
			dump_extension_table(!VERBOSE);
			return;
		}
		/* FALLTHROUGH */

	case LOAD_EXTENSION:
		if (!args[optind]) { 
			error(INFO, 
		       "-l requires one or more extension library arguments\n");
			cmd_usage(pc->curcmd, SYNOPSIS);
			break;
		}

        	while (args[optind]) {
			load_extension(args[optind]);
			optind++;
		}
		break;

	case UNLOAD_EXTENSION:
		if (!args[optind]) { 
			unload_extension(NULL);
			break;
		}

        	while (args[optind]) {
			unload_extension(args[optind]);
			optind++;
		}
		break;
	}
}

/*
 *  List all extension libaries and their commands in either the extend
 *  command format or for "help -e" (verbose).
 */
void 
dump_extension_table(int verbose)
{
	int i;
	struct extension_table *ext;
	struct command_table_entry *cp;
	char buf[BUFSIZE];
	int longest, others;

	if (!extension_table)
		return;

	if (verbose) {
       		for (ext = extension_table; ext; ext = ext->next) {
                        fprintf(fp, "        filename: %s\n", ext->filename);
                        fprintf(fp, "          handle: %lx\n", (ulong)ext->handle);


			fprintf(fp, "           flags: %lx (", ext->flags);
			others = 0;
			if (ext->flags & REGISTERED)
				fprintf(fp, "%sREGISTERED", others++ ?
					"|" : "");
			fprintf(fp, ")\n");
                        fprintf(fp, "            next: %lx\n", (ulong)ext->next);
                        fprintf(fp, "            prev: %lx\n", (ulong)ext->prev);

                        for (i = 0, cp = ext->command_table; cp->name; cp++, i++) {
                        	fprintf(fp, "command_table[%d]: %lx\n", i, (ulong)cp); 
				fprintf(fp, "                  name: %s\n", cp->name);
				fprintf(fp, "                  func: %lx\n", (ulong)cp->func);
				fprintf(fp, "             help_data: %lx\n", (ulong)cp->help_data); 
				fprintf(fp, "                 flags: %lx (", cp->flags);
				others = 0;
				if (cp->flags & CLEANUP)
					fprintf(fp, "%sCLEANUP", others++ ? "|" : "");
				if (cp->flags & REFRESH_TASK_TABLE)
					fprintf(fp, "%sREFRESH_TASK_TABLE", others++ ? "|" : "");
				if (cp->flags & HIDDEN_COMMAND)
					fprintf(fp, "%sHIDDEN_COMMAND", others++ ? "|" : "");
				fprintf(fp, ")\n");
			}

			if (ext->next) 
				fprintf(fp, "\n");
		}
		return;
	}


       /*
	*  Print them out in the order they were loaded.
	*/
	for (longest = 0, ext = extension_table; ext; ext = ext->next) {
		if (strlen(ext->filename) > longest)
			longest = strlen(ext->filename);
	}

	fprintf(fp, "%s  COMMANDS\n", 
		mkstring(buf, longest, LJUST, "SHARED OBJECT"));
	longest = MAX(longest, strlen("SHARED OBJECT"));

	for (ext = extension_table; ext; ext = ext->next) 
		if (ext->next == NULL)
			break;

	do {
                fprintf(fp, "%s  ", 
                        mkstring(buf, longest, LJUST, ext->filename));
                for (cp = ext->command_table; cp->name; cp++)
                        fprintf(fp, "%s ", cp->name);
		fprintf(fp, "\n");
	} while ((ext = ext->prev));
}


/*
 *  Load an extension library.
 */
void 
load_extension(char *lib)
{
	struct extension_table *ext, *curext;
	char buf[BUFSIZE];
	size_t size;
	char *env;
	int env_len;

	if ((env = getenv("CRASH_EXTENSIONS")))
		env_len = strlen(env)+1;
	else
		env_len = 0;	

	size = sizeof(struct extension_table) + strlen(lib) + 
		MAX(env_len, strlen("/usr/lib64/crash/extensions/")) + 1;

	if ((ext = (struct extension_table *)malloc(size)) == NULL) 
		error(FATAL, "cannot malloc extension_table space.");

	BZERO(ext, size);

	ext->filename = (char *)((ulong)ext + sizeof(struct extension_table));
	
       /*
	*  If the library is not specified by an absolute pathname, dlopen() 
        *  does not look in the current directory, so modify the filename.
	*  If it's not in the current directory, check the extensions library
	*  directory.
        */
	if ((*lib != '.') && (*lib != '/')) {
		if (file_exists(lib, NULL))
			sprintf(ext->filename, "./%s", lib);
		else if (in_extensions_library(lib, buf))
			strcpy(ext->filename, buf);
		else {
			error(INFO, "%s: %s\n", lib, strerror(ENXIO));
			free(ext);
			return;
		}
	} else 
		strcpy(ext->filename, lib);

	if (!is_shared_object(ext->filename)) {
		error(INFO, "%s: not an ELF format object file\n",
			ext->filename);
		free(ext);
		return;
	}

	for (curext = extension_table; curext; curext = curext->next) {
		if (same_file(curext->filename, ext->filename)) {
			fprintf(fp, "%s: shared object already loaded\n", 
				ext->filename);
			free(ext);
			return;
		}
	}

       /*
        *  register_extension() will be called by the shared object's
        *  _init() function before dlopen() returns below.
	*/
	pc->curext = ext;
	ext->handle = dlopen(ext->filename, RTLD_NOW|RTLD_GLOBAL); 

	if (!ext->handle) {
		strcpy(buf, dlerror());
		error(INFO, "%s\n", buf);
		if (strstr(buf, "undefined symbol: register_extension")) {
			error(INFO, "%s may be statically linked: ",
				pc->program_name);
			fprintf(fp, "recompile without the -static flag\n");
		}
		free(ext);
		return;
	}

	if (!(ext->flags & REGISTERED)) {
		dlclose(ext->handle);
		if (ext->flags & (DUPLICATE_COMMAND_NAME | NO_MINIMAL_COMMANDS))
			error(INFO, 
		         "%s: shared object unloaded\n", ext->filename);
		else
			error(INFO, 
		         "%s: no commands registered: shared object unloaded\n",
				ext->filename);
		free(ext);
		return;
	}

	fprintf(fp, "%s: shared object loaded\n", ext->filename);

	/*
	 *  Put new libraries at the head of the list.
         */
	if (extension_table) {
		extension_table->prev = ext;
		ext->next = extension_table;
	}
	extension_table = ext;

	help_init();
}

/*
 *  Check the extensions library directories.
 */
static int
in_extensions_library(char *lib, char *buf)
{
	char *env;

	if ((env = getenv("CRASH_EXTENSIONS"))) {
		sprintf(buf, "%s%s%s", env,
			LASTCHAR(env) == '/' ? "" : "/",
			lib);
		if (file_exists(buf, NULL))
			return TRUE;
	}

	if (BITS64()) {
		sprintf(buf, "/usr/lib64/crash/extensions/%s", lib);
		if (file_exists(buf, NULL))
			return TRUE;
	}

       	sprintf(buf, "/usr/lib/crash/extensions/%s", lib);
	if (file_exists(buf, NULL))
		return TRUE;
 
       	sprintf(buf, "./extensions/%s", lib);
	if (file_exists(buf, NULL))
		return TRUE;

	return FALSE;
}

/*
 * Look for an extensions directory using the proper order. 
 */
static char *
get_extensions_directory(char *dirbuf)
{
	char *env;

	if ((env = getenv("CRASH_EXTENSIONS"))) {
		if (is_directory(env)) {
			strcpy(dirbuf, env);
			return dirbuf;
		}
	}

	if (BITS64()) {
		sprintf(dirbuf, "/usr/lib64/crash/extensions");
		if (is_directory(dirbuf))
			return dirbuf;
	}

       	sprintf(dirbuf, "/usr/lib/crash/extensions");
	if (is_directory(dirbuf))
		return dirbuf;
 
       	sprintf(dirbuf, "./extensions");
	if (is_directory(dirbuf))
		return dirbuf;

	return NULL;
}


void
preload_extensions(void)
{
	DIR *dirp;
	struct dirent *dp;
	char dirbuf[BUFSIZE];
	char filename[BUFSIZE];
	int found;

	if (!get_extensions_directory(dirbuf))
		return;

        dirp = opendir(dirbuf);
	if (!dirp) {
		error(INFO, "%s: %s\n", dirbuf, strerror(errno));
		return;
	}

	pc->curcmd = pc->program_name;

        for (found = 0, dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
		sprintf(filename, "%s%s%s", dirbuf, 
			LASTCHAR(dirbuf) == '/' ? "" : "/",
			dp->d_name);

		if (!is_shared_object(filename))
			continue;

		found++;

		load_extension(dp->d_name);
	}

	closedir(dirp);
	
	if (found)
		fprintf(fp, "\n");
	else
		error(NOTE, 
		    "%s: no extension modules found in directory\n\n",
			dirbuf);
}

/*
 *  Unload all, or as specified, extension libraries.
 */
void 
unload_extension(char *lib)
{
        struct extension_table *ext;
	int found;
	char buf[BUFSIZE];

	if (!lib) {
		while (extension_table) {
			ext = extension_table;
                        if (dlclose(ext->handle))
                                error(FATAL,
                                    "dlclose: %s: shared object not open\n",
                                        ext->filename);

			fprintf(fp, "%s: shared object unloaded\n", 
				ext->filename);

			extension_table = ext->next;
			free(ext);
		}

		help_init();
		return;
	}

	if ((*lib != '.') && (*lib != '/')) {
		if (!file_exists(lib, NULL) &&
		    in_extensions_library(lib, buf))
			lib = buf;
	} 

	if (!file_exists(lib, NULL)) {
		error(INFO, "%s: %s\n", lib, strerror(ENXIO));
		return;
	}

        for (ext = extension_table, found = FALSE; ext; ext = ext->next) {
                if (same_file(lib, ext->filename)) {
			found = TRUE;
			if (dlclose(ext->handle))
				error(INFO, 
				    "dlclose: %s: shared object not open\n", 
					ext->filename);
			else {
				fprintf(fp, "%s: shared object unloaded\n",
					ext->filename);

				if (extension_table == ext) {       /* first */
					extension_table = ext->next;
					if (ext->next)
						ext->next->prev = NULL;
				} else if (ext->next == NULL)       /* last */
					ext->prev->next = NULL;
				else {                              /* middle */
					ext->prev->next = ext->next;
					ext->next->prev = ext->prev;
				}

				free(ext);
				help_init();
				break;
			}
		}
		else if (STREQ(basename(lib), basename(ext->filename))) {
			error(INFO, "%s and %s are different object files\n",
				lib, ext->filename);
			found = TRUE;
		}
        }

	if (!found)
		error(INFO, "%s: not loaded\n", lib);
}

/*
 *  Register the command_table as long as there are no command namespace
 *  clashes with the currently-existing command set.  Also delete any aliases
 *  that clash, giving the registered command name priority.
 *
 *  This function is called from the shared object's _init() function
 *  before the dlopen() call returns back to load_extension() above.  
 *  The mark of approval for load_extension() is the setting of the 
 *  REGISTERED bit in the "current" extension_table structure flags.
 */ 
void 
register_extension(struct command_table_entry *command_table)
{
	struct command_table_entry *cp;

	pc->curext->flags |= NO_MINIMAL_COMMANDS;

        for (cp = command_table; cp->name; cp++) {
		if (get_command_table_entry(cp->name)) {
			error(INFO, 
                  "%s: \"%s\" is a duplicate of a currently-existing command\n",
				pc->curext->filename, cp->name);
			pc->curext->flags |= DUPLICATE_COMMAND_NAME;
			return;
		}
		if (cp->flags & MINIMAL)
			pc->curext->flags &= ~NO_MINIMAL_COMMANDS;
	}

	if ((pc->flags & MINIMAL_MODE) && (pc->curext->flags & NO_MINIMAL_COMMANDS)) {
		error(INFO, 
		      "%s: does not contain any commands which support minimal mode\n",
		      pc->curext->filename);
		return;
	}

	if (pc->flags & MINIMAL_MODE) {
		for (cp = command_table; cp->name; cp++) {
			if (!(cp->flags & MINIMAL)) {
				error(WARNING, 
				      "%s: command \"%s\" does not support minimal mode\n",
				      pc->curext->filename, cp->name);
			}
		}
	}

        for (cp = command_table; cp->name; cp++) {
		if (is_alias(cp->name)) {
			error(INFO, 
               "alias \"%s\" deleted: name clash with extension command\n",
				cp->name);
			deallocate_alias(cp->name);
		}
	}

	pc->curext->command_table = command_table;   
	pc->curext->flags |= REGISTERED;             /* Mark of approval */
}

/* 
 *  Hooks for sial.
 */
unsigned long 
get_curtask(void) 
{ 
	return CURRENT_TASK(); 
}

char *
crash_global_cmd(void) 
{ 
	return pc->curcmd;
}

struct command_table_entry *
crash_cmd_table(void) 
{ 
	return pc->cmd_table; 
}