struct Module *sym_array_modules = (struct Module *) 0;

struct Module *sym_array_modules = NULL;

static int AddSymbol(struct Module *mp, unsigned long, char *);

static int AddSymbol(struct Module *mp, unsigned long, const char *);

static int AddModule(unsigned long, char *);

static int AddModule(char *);

	auto int	rtn,

	auto size_t	rtn;

			tmp;

	auto int	tmp;

	auto char	**mod_table;

	char			*modbuf = NULL,

				*newbuf;

	auto struct kernel_sym	*ksym_table,

	int			 modsize = 32,

				*p;

				 result;

	 * The system call which returns the kernel symbol table has

	 * First, we query for the list of loaded modules.  We may

	 * essentialy two modes of operation.  Called with a null pointer

	 * have to grow our buffer in size.

	 * the system call returns the number of symbols defined in the

	 * the table.

	 *

	 * The second mode of operation is to pass a valid pointer to

	 * the call which will then load the current symbol table into

	 * the memory provided.

	 *

	 * Returning the symbol table is essentially an all or nothing

	 * proposition so we need to pre-allocate enough memory for the

	 * complete table regardless of how many symbols we need.

	 *

	 * Bummer.

	if ( (rtn = getsyms((struct kernel_sym *) 0)) < 0 )

	do {

	{

		modsize+=modsize;

		if ( errno == ENOSYS )

		newbuf=realloc(modbuf, modsize);

			Syslog(LOG_INFO, "No module symbols loaded - "

			       "kernel modules not enabled.\n");

		if (newbuf==NULL) {

		else

			/* Well, that sucks. */

	ksym_table = (struct kernel_sym *) malloc(rtn * \

	mod_table = (char **) malloc(rtn * sizeof(char *));

						  sizeof(struct kernel_sym));

	if ( mod_table == NULL )

	if ( ksym_table == (struct kernel_sym *) 0 )

	if ( (rtn = getsyms(ksym_table)) < 0 )

	sym_array_modules = (struct Module *) malloc(rtn * sizeof(struct Module));

	if ( sym_array_modules == NULL )

		Syslog(LOG_WARNING, "Error reading kernel symbols - %s\n", \

		Syslog(LOG_WARNING, " Failed memory allocation for kernel " \

		       strerror(errno));

		       "symbol table.\n");

		free(mod_table);

		free(modbuf);

	tmp = rtn;

	newbuf=modbuf;

	p = ksym_table;

	for (tmp=rtn-1; tmp>=0; tmp--)

	while ( tmp-- )

 		if ( !AddModule(p->value, p->name) )

		mod_table[tmp]=newbuf;

		newbuf+=(strlen(newbuf)+1);

 		if ( !AddModule(mod_table[tmp]) )

			free(ksym_table);

			free(mod_table);

			free(modbuf);

	free(ksym_table);

	free(mod_table);

	free(modbuf);

	for (nmods= 0; nmods < num_modules; ++nmods)

	if (sym_array_modules != NULL) {

	{

		for (nmods= 0; nmods < num_modules; ++nmods)

		mp = &sym_array_modules[nmods];

		{

		if ( mp->num_syms == 0 )

			mp = &sym_array_modules[nmods];

			continue;

			if ( mp->num_syms == 0 )

				continue;

		for (nsyms= 0; nsyms < mp->num_syms; ++nsyms)

			for (nsyms= 0; nsyms < mp->num_syms; ++nsyms)

			free(mp->sym_array[nsyms].name);

				free(mp->sym_array[nsyms].name);

		free(mp->sym_array);

			free(mp->sym_array);

		}

		free(sym_array_modules);

		sym_array_modules = NULL;

 * Arguements:	(unsigned long) address, (char *) symbol

 * Arguements:	(char *) symbol

 *

 *		address:->	The address of the module.

static int AddModule(address, symbol)

static int AddModule(symbol)

     unsigned long address;

	auto int memfd;

	size_t rtn;

	size_t i;

	const char *cbuf;

	int symsize=128;

	int result;

	struct module_symbol *symbuf=NULL,

			     *newbuf;

	 * The following section of code is responsible for determining

	 * First, we query for the list of exported symbols.  We may

	 * whether or not we are done reading the list of modules.

	 * have to grow our buffer in size.

	if ( symbol[0] == '#' )

	do {

	{

		symsize+=symsize;

		newbuf=realloc(symbuf, symsize);

		if ( symbol[1] == '\0' )

		if (newbuf==NULL) {

		{

			/* Well, that sucks. */

			/*

			Syslog(LOG_ERR, "Error loading kernel symbols " \

			 * A symbol which consists of a # sign only

			       "- %s\n", strerror(errno));

			 * signifies a a resident kernel segment.  When we

			if (symbuf!=NULL) free(symbuf);

			 * hit one of these we are done reading the

			 * module list.

			 */

			have_modules = 1;

			return(1);

		}

		/* Allocate space for the module. */

		sym_array_modules = (struct Module *) \

			realloc(sym_array_modules, \

				(num_modules+1) * sizeof(struct Module));

		if ( sym_array_modules == (struct Module *) 0 )

		{

			Syslog(LOG_WARNING, "Cannot allocate Module array.\n");

		if ( (memfd = open("/dev/kmem", O_RDONLY)) < 0 )

		symbuf=newbuf;

		{

			Syslog(LOG_WARNING, "Error opening /dev/kmem\n");

		result=query_module(symbol, QM_SYMBOLS, symbuf, symsize, &rtn);

			return(0);

		}

		if ( lseek64(memfd, address, SEEK_SET) < 0 )

		{

			Syslog(LOG_WARNING, "Error seeking in /dev/kmem\n");

			Syslog(LOG_WARNING, "Symbol %s, value %08x\n", symbol, address);

			return(0);

		}

		if ( read(memfd, \

			  (char *)&sym_array_modules[num_modules].module,  \

			  sizeof(struct module)) < 0 )

		{

			Syslog(LOG_WARNING, "Error reading module "

			       "descriptor.\n");

			return(0);

		}

		close(memfd);

		/* Save the module name. */

		if (result<0 && errno!=ENOSPC) {

		mp->name = (char *) malloc(strlen(&symbol[1]) + 1);

			Syslog(LOG_ERR, "Error querying symbol list for %s " \

		if ( mp->name == (char *) 0 )

			       "- %s\n", symbol, strerror(errno));

			free(symbuf);

		strcpy(mp->name, &symbol[1]);

		}

	} while (result<0);

		mp->num_syms = 0;

	if ( rtn < 0 ) {

		mp->sym_array = (struct sym_table *) 0;

		/* No symbols??? */

		++num_modules;

		Syslog(LOG_INFO, "No module symbols loaded - unknown error.\n");

		return(1);

		free(symbuf);

	}

		return(0);

	else

	{

	    if (num_modules > 0)

		mp = &sym_array_modules[num_modules - 1];

	    else

		mp = &sym_array_modules[0];

		AddSymbol(mp, address, symbol);

	char *symbol;

	const char *symbol;