/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 */

#include <stdlib.h>

#include <stdio.h>

#include <sys/types.h>

#include <dirent.h>

#include <errno.h>

#include <strings.h>

#include <dlfcn.h>

#include <thread.h>

#include <synch.h>

#include <stdarg.h>

#include "usb.h"

#include "wr_libusb.h"

/*

 * libusb wrapper library

 *

 * Implements the libusb specification and calls into platform dependent

 * library implementations of sunray and solaris.

 *

 * Loads the .so's found in the default directory or pointed

 * to by the environment variable SUN_LIBUSBPLUGIN_DIR

 * If there are problems with the module then unload

 * the module and continue

 *

 * Reads plugin versions from the libusb_version variable

 * Reads plugin prefixes from libusb_prefix variable

 * Calls libusb_init implementation of the plugin to determine whether

 * the plugin bus is supported, unsupported, or exclusive.

 * This is from the return values 0, -1, 2

 *

 * In the exclusive case all others plugins will be disabled

 * Case1: ret = PLUGIN_EXCLUSIVE [2]:

 *		Sun Ray Environment where server bus is not requested

 *		via an environment variable

 * Case2: ret = FAILURE [-1]

 *		In the failure case the scenario is an app running

 *		in a workstation where the sunray bus cannot be made available.

 * Case3: ret = SUCCESS [0]:

 *		All busses are supported

 *

 * The plugins implement certain policies to determine whether access

 * to their bus will be granted and how.

 * These policies are internal to the plugin and not relevant to the wrapper

 * The wrapper merely supports the implementation of these  policies

 * via environment variables and init return values.

 *

 * Loads all the symbols of the plugins and maps apps calls -> plugin

 *

 * The wrapper library maintains the open device handle states to be

 * able to map the device handle to the correct plugin. As such each

 * open and close results in updates to the dev handle list.

 *

 */

static int  read_plugin_entries(void);

static int  load_plugin_syms(plugin_info_t *, void *, int);

static void wusb_symbol(char **, int, char *, char *);

static int  get_pindex(struct usb_dev_handle *, const char *);

static void unload_plugin(int);

static int  load_plugins();

static int  get_index_devicep(struct usb_device *);

static int  get_index_devhdl(struct usb_dev_handle *);

static int  usb_add_dev(struct usb_dev_handle *, struct usb_device *, int);

static void usb_del_dev(struct usb_dev_handle *, int);

static int  check_sym_hdl(int, int);

static void *lookup_sym_hdl(usb_dev_handle *, int, const char *);

static void  usb_dprintf(int level, char *format, ...);

static int  is_libusb_plugin(char *);

static int		libusb_debug = DEBUG_NONE;

struct usb_bus		*usb_busses;

static mutex_t		bus_lock = DEFAULTMUTEX;

static wrapper_info_t	winfo;

static plugin_info_t	p_info[MAX_PLUGINS];

#ifdef	_LP64

#define	PLUGIN_PREFIX		"/64/"

#else	/* _LP64 */

#define	PLUGIN_PREFIX		""

#endif	/* _LP64 */

/*

 * Reads the plugin libraries from the specified dir

 * or the user supplied SUN_LIBUSBPLUGIN_DIR

 * populates the p_name and p_path fields of the array of plugin_info structs

 * increments the array index pindex after each .so is read

 * returns -1(FAILURE) on error

 */

static int

read_plugin_entries()

{

	int	pindex = 0;

	int	plugin_found = 0;

	char	*alt_dir;

	DIR	*dirp;

	struct	dirent *dp;

	char	*tmpplugindir = PLUGIN_DIR;

	char	*suffix;

	char	modpath[PATH_MAX + 1];

	char	plugindir[PATH_MAX + 1];

	if ((alt_dir = getenv("SUN_LIBUSBPLUGIN_DIR")) != NULL) {

		tmpplugindir = alt_dir;

	}

	if (strnlen(tmpplugindir, PATH_MAX) >

	    (PATH_MAX - sizeof (PLUGIN_PREFIX))) {

		usb_dprintf(DEBUG_FUNCTIONS,

		    "Invalid plugin directory: %s\n", tmpplugindir);

		return (FAILURE);

	}

	/*

	 * Construct the plugin directory

	 * Default plugin for 32 bit: /usr/lib/libusb_plugins/

	 *		  for 64 bit: /usr/lib/libusb_plugins/64/

	 *

	 * If SUN_LIBUSBPLUGIN_DIR is set, the plugin is:

	 *	32bit: SUN_LIBUSBPLUGIN_DIR/

	 *	64bit: SUN_LIBUSBPLUGIN_DIR/64/

	 */

	snprintf(plugindir, PATH_MAX, "%s%s", tmpplugindir,

	    PLUGIN_PREFIX);

	usb_dprintf(DEBUG_FUNCTIONS, "plugins dir: %s\n", plugindir);

	if ((dirp = opendir(plugindir)) == NULL) {

		usb_dprintf(DEBUG_ERRORS, "%s: %s \n",

		    plugindir, strerror(errno));

		return (FAILURE);

	}

	while (dirp) {

		errno = 0;

		if ((dp = readdir(dirp)) != NULL) {

			usb_dprintf(DEBUG_FUNCTIONS,

			    "reading entry %s\n", dp->d_name);

			/* skip . and .. entries */

			if (strncmp(dp->d_name,	".", 1) == 0) {

				continue;

			}

			if (strncmp(dp->d_name, "..", 2) == 0) {

				continue;

			}

			/*

			 * Ignore files that are not *.so.X

			 * this ensures that libusb.so.1 and plugins.so.1

			 * and libusb.so.2 and plugin.so.2 can both be

			 * supported

			 */

			if ((suffix = strstr(dp->d_name, MOD_SUFFIX)) == NULL) {

				continue;

			} else if (suffix[strlen(MOD_SUFFIX)] != '.') {

				usb_dprintf(DEBUG_RECOVERABLE,

				    "did not load %s:%s\n",

				    plugindir, dp->d_name);

				continue;

			}

			usb_dprintf(DEBUG_FUNCTIONS,

			    "reading .so file %s:%s\n", plugindir, dp->d_name);

			p_info[pindex].p_name = strdup(dp->d_name);

			/*

			 * using PATH_MAX len here

			 */

			if (strlen(p_info[pindex].p_name) > PATH_MAX) {

				usb_dprintf(DEBUG_RECOVERABLE,

				    "pathname > PATH_MAX %s",

				    p_info[pindex].p_name);

				/* go on to try read next module */

				free(p_info[pindex].p_name);

				continue;

			}

			(void) strncpy(modpath, plugindir, PATH_MAX);

			(void) strncat(modpath, "/", 1);

			(void) strncat(modpath,

			    p_info[pindex].p_name, PATH_MAX);

			p_info[pindex].p_path = strdup(modpath);

			usb_dprintf(DEBUG_FUNCTIONS,

			    "Path is %s\n", p_info[pindex].p_path);

			/*

			 * If we do not detect a valid libusb plugin

			 * then let's skip and continue

			 * do not update pindex if we want to continue

			 * we will dlopen and dlclose in this check

			 */

			if (is_libusb_plugin(p_info[pindex].p_path) !=

			    SUCCESS) {

				free(p_info[pindex].p_path);

				free(p_info[pindex].p_name);

				continue;

			}

			plugin_found = 1;

			if (++pindex == MAX_PLUGINS) {

				usb_dprintf(DEBUG_FUNCTIONS,

				    "Max plugins read %d\n", pindex);

				break;

			}

		} else {

			if (errno == 0) {

				(void) closedir(dirp);

				if (!plugin_found) {

					usb_dprintf(DEBUG_ERRORS,

					    "No plugin found \n");

					return (FAILURE);

				} else {

					/* end of dir stream */

					return (SUCCESS);

				}

			} else {

				(void) closedir(dirp);

				return (FAILURE);

			}

		}

	}

	return (SUCCESS);

}

/*

 * In a directory crowded with a lot of .so's

 * filter out potential libusb plugins - helps

 * the plugin loader to only load valid plugins

 * uses the libusb_version symbol as a filter

 */

static int

is_libusb_plugin(char *modname)

{

	void	*hdl;

	void	*hdl_sym1;

	void	*hdl_sym2;

	char	*symbol1 = "usb_init";

	char	*symbol2 = "libusb_prefix";

	hdl = dlopen(modname, RTLD_NOW);

	if (hdl == NULL) {

		usb_dprintf(DEBUG_RECOVERABLE,

		    "%s could not be loaded \n", modname);

		return (FAILURE);

	}

	hdl_sym1 = (void *)(dlsym(hdl, symbol1));

	hdl_sym2 = (void *)(dlsym(hdl, symbol2));

	(void) dlclose(hdl);

	if ((hdl_sym1 == NULL) && (hdl_sym2 == NULL)) {

		usb_dprintf(DEBUG_FUNCTIONS,

		    "%s not a libusb plugin: unload\n", modname);

		return (FAILURE);

	} else {

		return (SUCCESS);

	}

}

/*

 * Read the plugin entry names

 * Load the plugins and populate the proper data structures

 * this includes things like bus/dev ptr mappings, handles, etc.

 * Also loads all the symbols also and store the handles

 * Lock: called with bus_lock held

 * called from usb_init

 */

static int

load_plugins()

{

	int	pindex = 0;

	void	*handle;

	int	module_loaded = 0;

	if (read_plugin_entries() != SUCCESS) {

		usb_dprintf(DEBUG_FUNCTIONS,

		    "Failed to load libusb plugins \n");

		return (FAILURE);

	}

	usb_dprintf(DEBUG_FUNCTIONS,

	    "load_plugin: modname is %s\n", p_info[pindex].p_name);

	/*

	 * Will load at most MAX_PLUGINS

	 */

	while (pindex < MAX_PLUGINS) {

		/* reached the end of modules read into the array */

		if (p_info[pindex].p_name == NULL) {

			break;

		}

		usb_dprintf(DEBUG_FUNCTIONS, "loading:%s pindex:%d\n",

		    p_info[pindex].p_name, pindex);

		handle = dlopen(p_info[pindex].p_path,	RTLD_NOW);

		if (handle == NULL) {

			usb_dprintf(DEBUG_RECOVERABLE,

			    "handle for %s is null\n", p_info[pindex].p_name);

			usb_dprintf(DEBUG_RECOVERABLE, dlerror());

			p_info[pindex].p_handle = NULL;

			free(p_info[pindex].p_name);

			free(p_info[pindex].p_path);

			/* just try to load the next one */

			pindex += 1;

			continue;

		} else {

			p_info[pindex].p_handle = handle;

		}

		if (load_plugin_syms(p_info, handle, pindex) != SUCCESS) {

			usb_dprintf(DEBUG_FUNCTIONS, "Failed to load"

			    "symbols for plugin %s\n",

			    p_info[pindex].p_name);

			unload_plugin(pindex);

			pindex += 1;

			/* try the next plugin */

			continue;

		}

		module_loaded = 1;

		pindex += 1;

	}

	if (!module_loaded) {

		usb_dprintf(DEBUG_FUNCTIONS, "No module could be loaded \n");

		return (FAILURE);

	} else {

		/* ploaded is the highest index that had a module entry */

		winfo.ploaded = pindex;

		return (SUCCESS);

	}

}

/*

 * For debugging of bus pointers

 */

static void

dump_busses()

{

	struct usb_bus	*busp;

	for (busp = usb_busses; busp != NULL; busp = busp->next) {

		usb_dprintf(DEBUG_DETAILED, "busp is 0x%x\n", busp);

	}

}

/*

 * Used to unload plugin

 * calling libusb_fini

 */

static void

unload_plugin(int pindex)

{

	int	sym_idx;

	int	(*hdl_libusb_fini)(void);

	free(p_info[pindex].p_name);

	free(p_info[pindex].p_path);

	p_info[pindex].p_name = NULL;

	/* call the plugins libusb_fini here */

	if (check_sym_hdl(pindex, LIBUSB_FINI) < 0) {

		(void) usb_dprintf(DEBUG_RECOVERABLE,

		    "hdl_libusb_fini is NULL \n");

	} else {

		hdl_libusb_fini =

		    LIBUSB_FINI_CAST(p_info[pindex].sym_hdl[LIBUSB_FINI]);

		(*hdl_libusb_fini)();

	}

	if (p_info[pindex].p_handle != NULL) {

		(void) dlclose(p_info[pindex].p_handle);

		p_info[pindex].exclusive_flag = 0;

		p_info[pindex].active_flag = 0;

		p_info[pindex].p_handle = NULL;

	}

	for (sym_idx = 0; sym_idx < NUM_SYMS; sym_idx ++) {

		p_info[pindex].sym_hdl[sym_idx] = NULL;

	}

}

/*

 * In trying to map the device handle to a bus

 * walk through the dev handle pointers added

 * during open and find the matching dev handle

 * that exists for that bus. On no match return

 * FAILURE on match return the bus index for this

 * dev handle

 */

static int

get_index_devhdl(struct usb_dev_handle *dev)

{

	int		pindex;

	dev_handles_t	*devh;

	for (pindex = 0; pindex < winfo.ploaded; pindex ++) {

		for (devh = p_info[pindex].dev_handles; devh != NULL;

		    devh = devh->next) {

			if (dev == devh->dev) {

				return (pindex);

			}

		}

	}

	return (FAILURE);

}

/*

 * upon a call to open adds the device handle to the

 * list of handles the wrapper will maintain

 * so that it can map device handles to bus

 * holds bus_lock

 * This is needed simply because we want to able

 * to map the device handles to the plugin module

 */

static int

usb_add_dev(struct usb_dev_handle *dev, struct usb_device *device,

	int pindex)

{

	dev_handles_t	*devh, *curr_devh;

	(void) mutex_lock(&bus_lock);

	/* first device handle to be added */

	if (p_info[pindex].dev_handles == NULL) {

		devh = (dev_handles_t *)malloc(sizeof (dev_handles_t));

		if (devh == NULL) {

			usb_dprintf(DEBUG_FUNCTIONS,

			    "Error adding device to list \n");

			(void) mutex_unlock(&bus_lock);

			return (FAILURE);

		}

		p_info[pindex].dev_handles = devh;

		devh->prev = NULL;

		devh->next = NULL;

	} else {

		curr_devh = p_info[pindex].dev_handles;

		while (curr_devh->next != NULL) {

			curr_devh = curr_devh->next;

		}

		/* curr_devh points to last devh handle */

		curr_devh->next = (dev_handles_t *)

		    malloc(sizeof (dev_handles_t));

		if (curr_devh->next == NULL) {

			usb_dprintf(DEBUG_FUNCTIONS,

			    "Error adding device to list \n");

			(void) mutex_unlock(&bus_lock);

			return (FAILURE);

		}

		devh = curr_devh->next;

		devh->next = NULL;

		devh->prev = curr_devh;

	}

	devh->device = device;

	devh->dev = dev;

	(void) mutex_unlock(&bus_lock);

	return (SUCCESS);

}

/*

 * upon a call to usb_close removes the device handle from the

 * list of handles the wrapper will maintain

 * entries do not get removed on a device removal only on close

 * holds bus_lock

 */

static void

usb_del_dev(struct usb_dev_handle *dev, int pindex)

{

	dev_handles_t	*d_dev;

	(void) mutex_lock(&bus_lock);

	d_dev = p_info[pindex].dev_handles;

	while (d_dev != NULL) {

		if (d_dev->dev == dev) {

			/* Not the last dev hdl */

			if (d_dev->next != NULL) {

				usb_dprintf(DEBUG_DETAILED,

				    "d_dev->next != NULL\n");

				d_dev->next->prev = d_dev->prev;

			}

			/* Not the first dev hdl */

			if (d_dev->prev != NULL) {

				usb_dprintf(DEBUG_DETAILED,

				    "d_dev->prev != NULL\n");

				d_dev->prev->next = d_dev->next;

			} else {

				/*

				 * first dev hdl on list

				 * if only handle then point to NULL

				 */

				p_info[pindex].dev_handles = d_dev->next;

				if (d_dev->next != NULL) {

					usb_dprintf(DEBUG_DETAILED,

					    "d_dev->next != NULL\n");

					d_dev->next->prev = NULL;

				}

			}

			free(d_dev);

			break;

		}

		d_dev = d_dev->next;

	}

	(void) mutex_unlock(&bus_lock);

}

/*